diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9fb1fd68ace..43e3b08edab 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -18,46 +18,128 @@ on:
   # Allow manual triggering
   workflow_dispatch:
 
+env:
+  PYTHON_VERSION: "3.13"
+
 jobs:
-  test:
+  lint:
+    name: Lint & Type Check
     runs-on: ubuntu-latest
     
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v7
       
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v7
       with:
-        python-version: '3.13'
+        python-version: ${{ env.PYTHON_VERSION }}
+        cache: 'pip'
+        
+    - name: Install linting dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+        
+    - name: Run Ruff linter
+      run: ruff check . --output-format=github
         
-    - name: Cache Python dependencies
-      uses: actions/cache@v3
+    - name: Run Ruff formatter check
+      run: ruff format --check .
+        
+    - name: Run mypy type checker
+      run: mypy build.py data/*.py
+
+  test:
+    name: Tests (Python ${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13"]
+    
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v7
+      
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v7
       with:
-        path: ~/.cache/pip
-        key: ${{ runner.os }}-pip-${{ hashFiles('requirements.txt') }}
-        restore-keys: |
-          ${{ runner.os }}-pip-
-          
+        python-version: ${{ matrix.python-version }}
+        cache: 'pip'
+        
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        make install
+        pip install -r requirements.txt
+        pip install pytest pytest-cov pytest-asyncio
+        
+    - name: Run tests with coverage
+      run: |
+        python -m pytest tests/ -v --tb=short --cov=. --cov-report=xml --cov-report=term-missing
+        
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v7
+      if: matrix.python-version == '3.13'
+      with:
+        files: ./coverage.xml
+        fail_ci_if_error: false
+        verbose: true
+
+  build-test:
+    name: Build Test
+    runs-on: ubuntu-latest
+    needs: [lint, test]
+    
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v7
+      
+    - name: Set up Python
+      uses: actions/setup-python@v7
+      with:
+        python-version: ${{ env.PYTHON_VERSION }}
+        cache: 'pip'
         
-    - name: Run tests
-      run: make test
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
         
-    - name: Lint with flake8
-      run: make lint
+    - name: Show build system info
+      run: python build.py info
         
     - name: Quick build test
-      run: make quick
+      run: |
+        python data/scripts/quick_build.py
         
     - name: Verify build outputs
       run: |
-        # Check that required files exist in dist/
-        test -f dist/index.html
-        test -f dist/cna.html
-        test -f dist/data-quality.html
-        test -f dist/static/css/style.css
+        # Check that required files exist
+        test -f web/index.html
+        test -f web/cna.html
+        test -f web/data-quality.html
+        test -f web/static/css/style.css
         echo "✅ Build outputs verified"
+        
+    - name: Validate data consistency
+      run: python build.py validate --quiet
+
+  security:
+    name: Security Scan
+    runs-on: ubuntu-latest
+    
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v7
+      
+    - name: Set up Python
+      uses: actions/setup-python@v7
+      with:
+        python-version: ${{ env.PYTHON_VERSION }}
+        cache: 'pip'
+        
+    - name: Install pip-audit
+      run: pip install pip-audit
+      
+    - name: Run security audit
+      run: pip-audit -r requirements.txt
diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index 33914f7f3b2..bdb7f97f220 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -5,13 +5,29 @@ on:
   push:
     branches: [ main ]
   
-  # Run every 6 hours
+  # Primary trigger: nvd-scrapper sends this right after it publishes a new
+  # snapshot and purges the CDN, so the site rebuilds within minutes of fresh
+  # data instead of waiting on the cron below. It only fires on a clean
+  # publish, so a run the producer refused never triggers a rebuild here.
+  repository_dispatch:
+    types: [nvd-published]
+
+  # Hourly backup, kept because the dispatch above depends on a token in
+  # another repo. Offset from :00 because scheduled workflows on the hour sit in
+  # the most contended slot on GitHub Actions and are frequently delayed or dropped.
   schedule:
-    - cron: '0 */6 * * *'
+    - cron: '25 * * * *'
   
   # Allow manual triggering
   workflow_dispatch:
 
+# A run commits to main and pushes. A dispatch and the hourly cron can land
+# close together, and a slow run can still be in flight when the next fires,
+# so serialise rather than race the push.
+concurrency:
+  group: build-and-deploy
+  cancel-in-progress: false
+
 permissions:
   contents: write
   pages: write
@@ -22,25 +38,24 @@ jobs:
     runs-on: ubuntu-latest
     
     steps:
+    # Check out the branch tip as of job start, not the SHA the event was
+    # created at. A dispatch or cron that queues behind a running build
+    # would otherwise start from a main that the running build then pushes
+    # past, and its "Commit updated data" push is rejected as non-fast-forward.
+    # The concurrency group guarantees the previous build has pushed by now.
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v7
       with:
+        ref: ${{ github.ref }}
         persist-credentials: true
         fetch-depth: 0
       
     - name: Set up Python
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v7
       with:
         python-version: '3.13'
-        
-    - name: Cache Python dependencies
-      uses: actions/cache@v3
-      with:
-        path: ~/.cache/pip
-        key: ${{ runner.os }}-pip-${{ hashFiles('requirements.txt') }}
-        restore-keys: |
-          ${{ runner.os }}-pip-
-          
+        cache: 'pip'
+
     - name: Install Python dependencies
       run: |
         python -m pip install --upgrade pip
@@ -50,38 +65,44 @@ jobs:
       run: |
         python -m pytest tests/ -v --tb=short
         
-    - name: Cache CVE data
-      id: cache-cve-data
-      uses: actions/cache@v4
-      with:
-        path: data/raw
-        key: cve-raw-data-${{ github.run_id }}
-        restore-keys: |
-          cve-raw-data-
-
+    - name: Download fresh KEV and EPSS data
+      run: |
+        cd data && python -c "
+        from download_cve_data import CVEDataDownloader
+        d = CVEDataDownloader()
+        d.download_kev_data(force=True)
+        d.parse_kev_json()
+        d.download_epss_data(force=True)
+        d.parse_epss_csv()
+        "
+        
     - name: Build site
-      run: make build
-      env:
-        CVE_BUILD_QUIET: "1"
+      run: |
+        python build.py --quiet
         
+    - name: Validate build output
+      run: python build.py validate --quiet
+
     - name: Copy CNAME for GitHub Pages
-      run: cp CNAME dist/CNAME
+      run: cp CNAME web/CNAME
       
     - name: Deploy to GitHub Pages
-      uses: peaceiris/actions-gh-pages@v3
+      uses: peaceiris/actions-gh-pages@v4
       if: github.ref == 'refs/heads/main'
       with:
         github_token: ${{ secrets.GITHUB_TOKEN }}
-        publish_dir: ./dist
+        publish_dir: ./web
         publish_branch: gh-pages
         force_orphan: true
         
+    # repository_dispatch is the same unattended data refresh as schedule, just
+    # triggered on time, so it has to persist web/ the same way.
     - name: Commit updated data
-      if: github.event_name == 'schedule'
+      if: github.event_name == 'schedule' || github.event_name == 'repository_dispatch'
       run: |
         git config --local user.email "action@github.com"
         git config --local user.name "GitHub Action"
         git checkout main
-        git add data/
-        git diff --staged --quiet || git commit -m "Auto-update CVE data $(date -u +%Y-%m-%d)"
+        git add web/
+        git diff --staged --quiet || git commit -m "Auto-update CVE data $(date -u +%Y-%m-%dT%H:%MZ)"
         git push
diff --git a/.github/workflows/run-pipeline.yml b/.github/workflows/run-pipeline.yml
deleted file mode 100644
index 4dc3c683714..00000000000
--- a/.github/workflows/run-pipeline.yml
+++ /dev/null
@@ -1,86 +0,0 @@
-name: Scheduled Data Pipeline
-
-on:
-  push:
-    branches: [ main ]
-  schedule:
-    # Run every 6 hours
-    - cron: '0 */6 * * *'
-  workflow_dispatch:
-
-jobs:
-  build-and-publish:
-    runs-on: ubuntu-latest
-    
-    # Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
-    permissions:
-      contents: write
-      pages: write
-      id-token: write
-    
-    # Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
-    # However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
-    concurrency:
-      group: "pages"
-      cancel-in-progress: false
-    
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    
-    steps:
-    - name: Checkout Code
-      uses: actions/checkout@v4
-      with:
-        token: ${{ secrets.GITHUB_TOKEN }}
-        persist-credentials: true
-      
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: '3.13'
-        cache: 'pip'
-        
-    - name: Install Dependencies
-      run: |
-        python -m pip install --upgrade pip
-        make install
-    
-    - name: Cache CVE data
-      id: cache-cve-data
-      uses: actions/cache@v4
-      with:
-        path: data/raw
-        key: cve-raw-data-${{ github.run_id }}
-        restore-keys: |
-          cve-raw-data-
-    
-    - name: Run the Data Pipeline
-      run: make build
-      env:
-        CVE_BUILD_QUIET: "1"
-      
-    - name: Commit and Push Changes
-      run: |
-        git config --local user.email "github-actions[bot]@users.noreply.github.com"
-        git config --local user.name "github-actions[bot]"
-        git add data/
-        if git diff --staged --quiet; then
-          echo "No changes to commit"
-        else
-          git commit -m "Automated: Update CVE data [skip ci]"
-          git pull --rebase origin main
-          git push
-        fi
-    
-    - name: Setup Pages
-      uses: actions/configure-pages@v4
-    
-    - name: Upload artifact
-      uses: actions/upload-pages-artifact@v3
-      with:
-        path: './dist'
-    
-    - name: Deploy to GitHub Pages
-      id: deployment
-      uses: actions/deploy-pages@v4
diff --git a/.gitignore b/.gitignore
index 007843e6f74..1e1ae48982a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -192,10 +192,10 @@ $RECYCLE.BIN/
 *.bak
 .cache/
 temp/
-data/cache/
-data/raw/
-dist/
-web/
+data/cache/nvd.json
+data/cache/cvelistV5/
 .DS_Store
-*.pkl
-**/cache/
+data/cache/nvd.jsonl
+
+# Claude Code local state
+.claude/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 00000000000..a88444047b4
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,66 @@
+# Pre-commit hooks for CVEDB
+# Install: pre-commit install
+# Run all: pre-commit run --all-files
+# See https://pre-commit.com for more information
+
+repos:
+  # Ruff - Fast Python linter and formatter (replaces flake8, black, isort)
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.4
+    hooks:
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+        types_or: [python, pyi]
+      - id: ruff-format
+        types_or: [python, pyi]
+
+  # Standard pre-commit hooks
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+        exclude: ^(web/|data/cache/)
+      - id: end-of-file-fixer
+        exclude: ^(web/|data/cache/)
+      - id: check-yaml
+        args: [--unsafe]  # Allow custom tags in YAML
+      - id: check-json
+        exclude: ^(web/data/|data/cache/)
+      - id: check-added-large-files
+        args: ['--maxkb=1000']
+      - id: check-merge-conflict
+      - id: detect-private-key
+      - id: check-case-conflict
+
+  # Type checking with mypy
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.14.1
+    hooks:
+      - id: mypy
+        args: [--ignore-missing-imports, --no-error-summary]
+        files: ^(build\.py|data/.*\.py)$
+        additional_dependencies:
+          - types-requests
+          - types-aiofiles
+
+  # Security scanning
+  - repo: https://github.com/PyCQA/bandit
+    rev: 1.8.2
+    hooks:
+      - id: bandit
+        args: [-c, pyproject.toml, -r, .]
+        files: ^(build\.py|data/.*\.py)$
+        additional_dependencies: ["bandit[toml]"]
+
+# Configuration for pre-commit CI
+ci:
+  autofix_commit_msg: |
+    [pre-commit.ci] auto fixes from pre-commit.com hooks
+    
+    for more information, see https://pre-commit.ci
+  autofix_prs: true
+  autoupdate_branch: ''
+  autoupdate_commit_msg: '[pre-commit.ci] pre-commit autoupdate'
+  autoupdate_schedule: weekly
+  skip: [mypy]  # Skip mypy in CI as it needs dependencies
+  submodules: false
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7190535a677..16451cac64d 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -18,7 +18,7 @@ Be respectful and constructive in all interactions. We're all here to build bett
 
 ```bash
 # Fork and clone the repository
-git clone https://github.com/cvedb/cvedb.github.io.git
+git clone https://github.com/CVEDB/cvedb.github.io.git
 cd cvedb.github.io
 
 # Install dependencies
@@ -108,7 +108,7 @@ We especially welcome contributions in:
 
 - Open an issue for discussion
 - Check [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) for technical details
-- Review [docs/ROADMAP.md](docs/ROADMAP.md) for project direction
+- Review [docs/COUNTING.md](docs/COUNTING.md) for how CVEs are counted
 
 ---
 
diff --git a/Makefile b/Makefile
index 75ea603076f..ffa36264316 100644
--- a/Makefile
+++ b/Makefile
@@ -32,11 +32,11 @@ install:
 
 # Full build
 build:
-	python scripts/build.py
+	python build.py
 
 # Quick template-only build
 quick:
-	python scripts/quick_build.py
+	python data/scripts/quick_build.py
 
 # Run tests
 test:
@@ -44,18 +44,19 @@ test:
 
 # Run tests with coverage
 test-coverage:
-	python -m pytest tests/ -v --cov=src/cvedb --cov-report=term-missing
+	python -m pytest tests/ -v --cov=data --cov-report=term-missing
 
 # Run linters
 lint:
-	python -m flake8 src/cvedb/ --max-line-length=120 --ignore=E501,W503
+	python -m flake8 data/ --max-line-length=120 --ignore=E501,W503
 
 # Clean build artifacts
 clean:
-	rm -rf dist/
+	rm -rf web/*.html
+	rm -rf web/data/*.json
 	rm -rf __pycache__
-	rm -rf src/cvedb/__pycache__
-	rm -rf scripts/__pycache__
+	rm -rf data/__pycache__
+	rm -rf data/scripts/__pycache__
 	rm -rf tests/__pycache__
 	rm -rf .pytest_cache
 	rm -rf .coverage
@@ -63,26 +64,26 @@ clean:
 # Start local development server
 serve:
 	@echo "Starting local server at http://localhost:8000"
-	cd dist && python -m http.server 8000
+	cd web && python -m http.server 8000
 
 # Individual rebuild targets
 rebuild-cna:
-	python scripts/rebuild_cna.py
+	python data/scripts/rebuild_cna.py
 
 rebuild-cpe:
-	python scripts/rebuild_cpe.py
+	python data/scripts/rebuild_cpe.py
 
 rebuild-cvss:
-	python scripts/rebuild_cvss.py
+	python data/scripts/rebuild_cvss.py
 
 rebuild-cwe:
-	python scripts/rebuild_cwe.py
+	python data/scripts/rebuild_cwe.py
 
 rebuild-growth:
-	python scripts/rebuild_growth.py
+	python data/scripts/rebuild_growth.py
 
 rebuild-quality:
-	python scripts/rebuild_data_quality.py
+	python data/scripts/rebuild_data_quality.py
 
 # Rebuild all analysis files without full build
 rebuild-all: rebuild-cna rebuild-cpe rebuild-cvss rebuild-cwe rebuild-growth rebuild-quality
diff --git a/build.py b/build.py
new file mode 100644
index 00000000000..65159522a11
--- /dev/null
+++ b/build.py
@@ -0,0 +1,2094 @@
+#!/usr/bin/env python3
+"""
+CVEDB Static Site Generator
+Fixed build system that works with existing code structure
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from collections import defaultdict
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from functools import cache
+from pathlib import Path
+from typing import Annotated, Any, cast
+
+import jinja2
+import requests
+
+
+# Add data folder to path for imports
+sys.path.append("data")
+
+import typer
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from data.async_downloader import AsyncCVEDownloader
+from data.logging_config import LogLevel, get_logger, setup_logging
+
+
+logger = get_logger(__name__)
+console = Console()
+
+# Create Typer app
+app = typer.Typer(
+    name="cve-icu",
+    help="CVEDB Static Site Generator - Build and manage vulnerability intelligence site.",
+    add_completion=True,
+    rich_markup_mode="rich",
+    invoke_without_command=True,  # Allow running without subcommand
+)
+
+
+def _validated_log_level(value: str) -> LogLevel:
+    """Coerce a free-form --log-level string to the accepted literal set.
+
+    Typer hands us an arbitrary str, so an unrecognised value would otherwise
+    reach setup_logging and be silently accepted.
+    """
+    level = value.upper()
+    if level not in ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"):
+        raise typer.BadParameter(f"Invalid log level {value!r}. Choose from DEBUG, INFO, WARNING, ERROR, CRITICAL.")
+    return cast("LogLevel", level)
+
+
+@app.callback(invoke_without_command=True)
+def default_command(
+    ctx: typer.Context,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Minimal output mode for CI/CD")] = False,
+    refresh_data: Annotated[
+        bool, typer.Option("--refresh-data", "-r", help="Download fresh CVE data before building")
+    ] = False,
+    force_refresh: Annotated[
+        bool, typer.Option("--force-refresh", "-f", help="Force re-download even if cache is valid")
+    ] = False,
+    validate_flag: Annotated[bool, typer.Option("--validate", help="Validate data consistency after build")] = False,
+    accept_baseline: Annotated[
+        bool,
+        typer.Option("--accept-baseline", help="Skip the source-manifest regression check"),
+    ] = False,
+    strict: Annotated[bool, typer.Option("--strict", help="Treat data guards as fatal outside CI")] = False,
+    log_level: Annotated[str, typer.Option("--log-level", help="Logging level (DEBUG, INFO, WARNING, ERROR)")] = "INFO",
+) -> None:
+    """Default command - runs build if no subcommand specified.
+
+    This maintains backward compatibility with the original CLI:
+        python build.py              # Runs build
+        python build.py --quiet      # Runs build in quiet mode
+        python build.py build        # Explicitly runs build subcommand
+    """
+    # If a subcommand is being invoked, skip this callback
+    if ctx.invoked_subcommand is not None:
+        return
+
+    # No subcommand - run build with the provided options
+    build(
+        quiet=quiet,
+        refresh_data=refresh_data,
+        force_refresh=force_refresh,
+        accept_baseline=accept_baseline,
+        strict=strict,
+        validate=validate_flag,
+        log_level=log_level,
+    )
+
+
+class CVESiteBuilder:
+    """Main class for building the CVEDB static site"""
+
+    def __init__(self, quiet: bool = False) -> None:
+        self.quiet: bool = quiet or os.getenv("CVE_BUILD_QUIET", "").lower() in ("1", "true", "yes")
+        self.current_year: int = datetime.now().year
+        self.available_years: list[int] = list(range(1999, self.current_year + 1))
+
+        # Regression guard configuration. See verify_no_regression() for how
+        # the allowance was derived; it is deliberately much tighter than a
+        # percentage band would be.
+        self.published_totals_url: str = "https://cvedb.github.io/data/cve_all.json"
+        # Count of non-rejected CVEs published before 1999, measured during the
+        # year-data pass and emitted into cve_all.json so validation can subtract
+        # a real number instead of guessing. See docs/COUNTING.md.
+        self.excluded_pre_1999: int | None = None
+        self.regression_allowance: int = 10
+        # Measured from the producer's last run (source_age_hours), not from
+        # our download. The producer moved to an hourly cron on 2026-09-22, but
+        # GitHub drops most scheduled triggers, so observed publish gaps run
+        # 5-7h. A day is comfortably clear of that spread while still catching
+        # a feed that has genuinely stopped.
+        self.max_source_age_hours: float = 24.0
+        self.accept_baseline: bool = False
+        # These guards exist to stop bad data being *published*. A local build
+        # publishes nothing, so blocking a developer working from a deliberately
+        # old cache is friction with no safety benefit. CI is the deploy path,
+        # so there they are fatal; locally they warn. --strict forces fatal
+        # anywhere, which is how you test the guard itself.
+        self.strict_data_guards: bool = bool(os.getenv("CI"))
+        self.base_dir: Path = Path(__file__).parent
+        self.output_root_dir: Path = self.base_dir / "web"
+        self.templates_dir: Path = self.base_dir / "templates"
+        self.source_static_dir: Path = self.output_root_dir / "static"
+        self.data_scripts_dir: Path = self.base_dir / "data"
+        self.cache_dir: Path = self.data_scripts_dir / "cache"
+        self._set_output_dirs(self.output_root_dir)
+
+        # Set up Jinja2 environment
+        self.jinja_env = Environment(
+            loader=FileSystemLoader(self.templates_dir), autoescape=select_autoescape(["html", "xml"])
+        )
+
+        # Add custom filters and globals
+        self.jinja_env.globals["current_year"] = self.current_year
+        self.jinja_env.globals["available_years"] = self.available_years
+        self.jinja_env.filters["format_number"] = self.format_number
+
+        if not self.quiet:
+            logger.info("🚀 CVEDB Build System Initialized")
+            logger.info(f"📅 Current Year: {self.current_year}")
+            logger.info(f"📊 Coverage: 1999-{self.current_year} ({len(self.available_years)} years)")
+            logger.info(f"🌐 Web output: {self.web_dir}")
+            logger.debug(f"📁 Data scripts: {self.data_scripts_dir}")
+
+    def _set_output_dirs(self, web_dir: Path) -> None:
+        """Update output directory paths for staged/production builds."""
+        self.web_dir = web_dir
+        self.static_dir = self.web_dir / "static"
+        self.data_dir = self.web_dir / "data"
+
+    def print_verbose(self, message: str) -> None:
+        """Print message only if not in quiet mode"""
+        if not self.quiet:
+            logger.info(message)
+
+    def print_always(self, message: str) -> None:
+        """Print message regardless of quiet mode (for errors and essential info)"""
+        logger.info(message)
+
+    @staticmethod
+    @cache
+    def format_number(num: int | float) -> str:
+        """Format numbers for display (e.g., 1000 -> 1K). Cached for performance."""
+        if num >= 1000000:
+            return f"{num / 1000000:.1f}M"
+        elif num >= 1000:
+            return f"{num / 1000:.1f}K"
+        return str(num)
+
+    def verify_source_manifest(self, accept_baseline: bool = False) -> dict[str, Any] | None:
+        """Run the producer-manifest gates before any bulk download.
+
+        Returns the manifest when one is available, else None. Raises when the
+        producer reports a degraded run or the snapshot has regressed against
+        the last one we accepted.
+        """
+        from download_cve_data import CVEDataDownloader
+
+        checker = CVEDataDownloader(cache_dir=self.cache_dir, quiet=self.quiet)
+        manifest = checker.fetch_source_manifest()
+        if manifest is None:
+            logger.warning("⚠️  Proceeding without manifest verification")
+            return None
+
+        if accept_baseline:
+            logger.warning("⚠️  --accept-baseline: skipping manifest regression check")
+        else:
+            checker.verify_manifest_healthy(manifest)
+            checker.verify_manifest_not_regressed(manifest, checker.fetch_baseline_manifest())
+        return dict(manifest)
+
+    def refresh_data(self, force: bool = False, accept_baseline: bool = False) -> bool:
+        """Refresh CVE data from all sources using async parallel downloads.
+
+        Downloads data from 5 sources in parallel (~3x faster than sequential):
+        - NVD CVE database
+        - CNA organization list
+        - CNA name mappings
+        - EPSS exploit prediction scores
+        - CISA KEV catalog
+
+        Args:
+            force: Force re-download even if cache is valid
+
+        Returns:
+            True if all critical downloads succeeded
+        """
+        self.print_verbose("📥 Refreshing CVE data from all sources...")
+
+        # The async path downloads nvd.json directly, bypassing the manifest
+        # gate in CVEDataDownloader.ensure_data_available(). Run the same checks
+        # here so a manual --refresh-data cannot skip verification.
+        source_manifest = self.verify_source_manifest(accept_baseline=accept_baseline)
+
+        try:
+            downloader = AsyncCVEDownloader(
+                cache_dir=self.cache_dir,
+                quiet=self.quiet,
+            )
+            results = downloader.download_all_sync(force=force)
+
+            # Record the manifest only after the download it describes succeeded.
+            if source_manifest is not None:
+                from download_cve_data import CVEDataDownloader
+
+                CVEDataDownloader(cache_dir=self.cache_dir, quiet=self.quiet).persist_accepted_manifest(source_manifest)
+
+            # Parse supplemental data
+            downloader.parse_epss()
+            downloader.parse_kev()
+
+            # Check for critical failures (NVD is required)
+            nvd_result = results.get("nvd")
+            if not nvd_result or not nvd_result.success:
+                logger.error("❌ NVD download failed - cannot proceed")
+                return False
+
+            # Log summary
+            successful = sum(1 for r in results.values() if r.success)
+            self.print_verbose(f"✅ Data refresh complete: {successful}/{len(results)} sources")
+
+            return True
+
+        except ImportError as e:
+            # httpx is optional. Previously this returned True, so a refresh
+            # reported success in about a second having downloaded nothing.
+            # Fall back to the synchronous downloader, which uses requests.
+            logger.warning(f"⚠️  Async downloads unavailable: {e}")
+            logger.info("   Falling back to sequential downloads (pip install httpx to parallelise)")
+            return self.refresh_data_sync(force=force, manifest=source_manifest)
+        except Exception as e:
+            logger.error(f"❌ Data refresh failed: {e}")
+            return False
+
+    def refresh_data_sync(self, force: bool = False, manifest: dict[str, Any] | None = None) -> bool:
+        """Sequential fallback for when httpx is unavailable.
+
+        Slower than the async path but functionally equivalent, and honest: it
+        actually downloads, and reports failure when it fails.
+        """
+        from download_cve_data import CVEDataDownloader
+
+        downloader = CVEDataDownloader(cache_dir=self.cache_dir, quiet=self.quiet)
+        try:
+            # Covers nvd.json plus the CNA mapping files, and verifies the
+            # snapshot against the manifest.
+            downloader.download_data(force=force, manifest=manifest)
+            downloader.download_cna_mapping_files()
+
+            if downloader.download_epss_data(force=force):
+                downloader.parse_epss_csv()
+            if downloader.download_kev_data(force=force):
+                downloader.parse_kev_json()
+
+            # download_data may have resolved a newer snapshot than the one we
+            # gated, if a publish landed mid-download. Record what we actually have.
+            accepted = downloader.accepted_manifest
+            if accepted is not None:
+                downloader.persist_accepted_manifest(accepted)
+
+            self.print_verbose("✅ Data refresh complete (sequential)")
+            return True
+        except Exception as e:
+            logger.error(f"❌ Sequential data refresh failed: {e}")
+            return False
+
+    def clean_build(self) -> None:
+        """Clean and recreate the active output directory."""
+        self.print_verbose("🧹 Cleaning web directory...")
+
+        if self.web_dir.exists():
+            shutil.rmtree(self.web_dir)
+
+        self.web_dir.mkdir(parents=True, exist_ok=True)
+        self.data_dir.mkdir(parents=True, exist_ok=True)
+
+        self.print_verbose("✅ Web directory cleaned and recreated")
+
+    def ensure_static_assets(self) -> None:
+        """Ensure static assets are in place"""
+        self.print_verbose("📁 Checking static assets...")
+
+        if not self.static_dir.exists():
+            if self.source_static_dir.exists() and self.static_dir != self.source_static_dir:
+                self.print_verbose("📦 Copying static assets into staged output...")
+                shutil.copytree(self.source_static_dir, self.static_dir)
+            else:
+                self.print_verbose("⚠️  Warning: Static directory not found, creating...")
+                self.static_dir.mkdir(parents=True, exist_ok=True)
+
+        # Check for required files
+        required_files = ["css/style.css", "js/app.js", "images/logo.png"]
+
+        for file_path in required_files:
+            full_path = self.static_dir / file_path
+            if full_path.exists():
+                self.print_verbose(f"  ✅ Found {file_path}")
+            else:
+                self.print_verbose(f"  ⚠️  Missing {file_path}")
+
+        # Preserve root-level deployment files (for example GitHub Pages custom domain).
+        for root_file_name in ["CNAME"]:
+            source_root_file = self.output_root_dir / root_file_name
+            destination_root_file = self.web_dir / root_file_name
+            if source_root_file.exists():
+                shutil.copy2(source_root_file, destination_root_file)
+                self.print_verbose(f"  ✅ Preserved {root_file_name}")
+
+        self.print_verbose("✅ Static assets check complete")
+
+    def validate_build_outputs(self) -> None:
+        """Validate critical artifacts before publishing staged output."""
+        required_html = [
+            "index.html",
+            "years.html",
+            "cna-hub.html",
+            "cna.html",
+            "cpe.html",
+            "cvss.html",
+            "cwe.html",
+            "calendar.html",
+            "growth.html",
+            "scoring.html",
+            "epss.html",
+            "kev.html",
+            "data-quality.html",
+            "about.html",
+        ]
+        required_json = [
+            "cna_analysis.json",
+            "cna_analysis_current_year.json",
+            "cpe_analysis.json",
+            "cpe_analysis_current_year.json",
+            "cvss_analysis.json",
+            "cvss_analysis_current_year.json",
+            "cwe_analysis.json",
+            "cwe_analysis_current_year.json",
+            "calendar_analysis.json",
+            "calendar_analysis_current_year.json",
+            "growth_analysis.json",
+            "yearly_summary.json",
+            "cve_all.json",
+            "epss_analysis.json",
+            "kev_analysis.json",
+            "risk_matrix.json",
+            "scoring_comparison.json",
+            "data_quality.json",
+            "homepage_summary.json",
+        ]
+
+        missing_html = [name for name in required_html if not (self.web_dir / name).exists()]
+        missing_json = [name for name in required_json if not (self.data_dir / name).exists()]
+        if missing_html or missing_json:
+            missing = ", ".join([*missing_html, *[f"data/{name}" for name in missing_json]])
+            raise RuntimeError(f"Missing required build artifacts: {missing}")
+
+    def publish_staged_site(self, staged_web_dir: Path) -> None:
+        """Atomically replace production web output with staged build."""
+        final_web_dir = self.output_root_dir
+        backup_web_dir = self.base_dir / ".web_backup"
+
+        if backup_web_dir.exists():
+            shutil.rmtree(backup_web_dir)
+
+        if final_web_dir.exists():
+            final_web_dir.rename(backup_web_dir)
+
+        try:
+            staged_web_dir.rename(final_web_dir)
+        except OSError as exc:
+            if backup_web_dir.exists() and not final_web_dir.exists():
+                backup_web_dir.rename(final_web_dir)
+            raise RuntimeError(f"Failed to publish staged site: {exc}") from exc
+        else:
+            if backup_web_dir.exists():
+                shutil.rmtree(backup_web_dir)
+
+    def generate_year_data_json(self) -> list[dict[str, Any]]:
+        """Generate JSON data files for all available years"""
+        self.print_verbose("📊 Generating year data JSON files...")
+
+        try:
+            # Import the real CVE years analyzer
+            from cve_years import CVEYearsAnalyzer
+
+            self.print_verbose("🔽 Initializing CVE data processing...")
+            analyzer = CVEYearsAnalyzer(quiet=self.quiet)
+
+            # Generate data for all years
+            all_year_data = []
+
+            for year in self.available_years:
+                self.print_verbose(f"  📅 Processing year {year}...")
+
+                try:
+                    # Use the real analyzer to get year data
+                    year_data = analyzer.get_year_data(year)
+
+                    if year_data:
+                        # Save individual year file
+                        year_file = self.data_dir / f"cve_{year}.json"
+                        with open(year_file, "w") as f:
+                            json.dump(year_data, f, indent=2, default=str)
+
+                        all_year_data.append(year_data)
+                        self.print_verbose(
+                            f"    ✅ Generated cve_{year}.json ({year_data.get('total_cves', 0):,} CVEs)"
+                        )
+                    else:
+                        self.print_verbose(f"    ⚠️  Skipped {year} - no data available")
+
+                except (KeyError, json.JSONDecodeError, OSError) as e:
+                    self.print_always(f"  ❌ Failed to process {year}: {e}")
+                    continue
+
+            # The buckets are populated by now, so this is a cheap lookup rather
+            # than a second pass over the feed.
+            self.excluded_pre_1999 = analyzer.count_excluded_pre_1999()
+            self.print_verbose(
+                f"  📅 {self.excluded_pre_1999:,} non-rejected CVEs published pre-1999 (excluded from year files)"
+            )
+
+            self.print_always(f"✅ Generated {len(all_year_data)} year data files")
+            return all_year_data
+
+        except ImportError as e:
+            logger.error(f"❌ Failed to import CVE years analyzer: {e}")
+            logger.info("📝 Creating minimal data as fallback...")
+            return self.create_minimal_year_data()
+        except (json.JSONDecodeError, OSError, KeyError) as e:
+            logger.error(f"❌ Error generating year data: {e}")
+            self.print_verbose("📝 Creating minimal data as fallback...")
+            return self.create_minimal_year_data()
+
+    def create_minimal_year_data(self) -> list[dict[str, Any]]:
+        """Create minimal year data for basic functionality"""
+        self.print_verbose("📝 Creating minimal year data for basic functionality...")
+        all_year_data: list[dict[str, Any]] = []
+
+        for year in self.available_years:
+            year_data = {
+                "year": year,
+                "total_cves": max(100, (year - 1999) * 500),
+                "date_data": {
+                    "monthly_distribution": {str(i): max(10, (year - 1999) * 5) for i in range(1, 13)},
+                    "daily_analysis": {
+                        "total_days": 365,
+                        "days_with_cves": min(365, max(50, (year - 1999) * 10)),
+                        "avg_cves_per_day": max(1, (year - 1999) * 1.5),
+                        "max_cves_in_day": max(5, (year - 1999) * 3),
+                        "daily_counts": {},
+                    },
+                },
+            }
+
+            # Save individual year file
+            year_file = self.data_dir / f"cve_{year}.json"
+            with open(year_file, "w") as f:
+                json.dump(year_data, f, indent=2)
+
+            all_year_data.append(year_data)
+
+        logger.info(f"✅ Generated {len(all_year_data)} minimal year data files")
+        return all_year_data
+
+    def generate_combined_analysis_json(self, all_year_data: list[dict[str, Any]]) -> dict[str, str]:
+        """Generate combined analysis JSON files"""
+        logger.info("📊 Generating combined analysis JSON files...")
+
+        # Generate comprehensive CNA analysis using CVE V5 as authoritative source
+        try:
+            from cve_v5_processor import CVEV5Processor
+
+            if not self.quiet:
+                logger.info("  🏢 Generating comprehensive CNA analysis from CVE V5 data...")
+            v5_processor = CVEV5Processor(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet)
+            cna_analysis = v5_processor.generate_comprehensive_cna_analysis()
+
+            if cna_analysis:
+                if not self.quiet:
+                    logger.info(
+                        f"  ✅ Generated cna_analysis.json with {cna_analysis['total_cnas']} CNAs (CVE V5 authoritative)"
+                    )
+            else:
+                logger.error("  ❌ CVE V5 CNA analysis failed")
+
+        except (ImportError, json.JSONDecodeError, OSError, subprocess.SubprocessError) as e:
+            logger.error(f"  ❌ Error generating CVE V5 CNA analysis: {e}")
+            import traceback
+
+            traceback.print_exc()
+            logger.warning("  ⚠️  CNA analysis will be missing")
+
+        # Generate current year CNA analysis using CVE V5 data
+        try:
+            from cve_v5_processor import CVEV5Processor
+
+            if not self.quiet:
+                logger.info("  🗓️  Generating current year CNA analysis from CVE V5 data...")
+            v5_processor = CVEV5Processor(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet)
+            current_cna_analysis = v5_processor.generate_current_year_analysis()
+
+            if current_cna_analysis:
+                if not self.quiet:
+                    logger.info(
+                        f"  ✅ Generated cna_analysis_current_year.json with {current_cna_analysis['total_cnas']} CNAs (CVE V5 authoritative)"
+                    )
+            else:
+                logger.error("  ❌ CVE V5 current year analysis failed")
+
+        except (ImportError, json.JSONDecodeError, OSError, subprocess.SubprocessError) as e:
+            logger.error(f"  ❌ Error generating CVE V5 current year CNA analysis: {e}")
+            import traceback
+
+            traceback.print_exc()
+            logger.warning("  ⚠️  Current year CNA analysis will be missing")
+
+        # Fall back to NVD-based CNA analysis if CVE V5 artifacts are unavailable.
+        if (
+            not (self.data_dir / "cna_analysis.json").exists()
+            or not (self.data_dir / "cna_analysis_current_year.json").exists()
+        ):
+            self.generate_cna_analysis_fallback(all_year_data)
+
+        # Generate CPE analysis
+        try:
+            from cpe_analysis import CPEAnalyzer
+
+            if not self.quiet:
+                logger.info("  🔍 Generating comprehensive CPE analysis...")
+            cpe_analyzer = CPEAnalyzer(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet)
+            cpe_analysis = cpe_analyzer.generate_cpe_analysis(all_year_data)
+
+            if cpe_analysis:
+                if not self.quiet:
+                    logger.info(
+                        f"  ✅ Generated cpe_analysis.json with {cpe_analysis['total_unique_cpes']:,} unique CPEs"
+                    )
+            else:
+                logger.error("  ❌ CPE analysis failed")
+
+        except (ImportError, json.JSONDecodeError, OSError) as e:
+            logger.error(f"  ❌ Error generating CPE analysis: {e}")
+            import traceback
+
+            traceback.print_exc()
+            logger.warning("  ⚠️  CPE analysis will be missing")
+
+        # Generate current year CPE analysis
+        try:
+            from cpe_analysis import CPEAnalyzer
+
+            if not self.quiet:
+                logger.info("  📅 Generating current year CPE analysis...")
+            cpe_analyzer = CPEAnalyzer(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet)
+            current_year_data = next((data for data in all_year_data if data["year"] == datetime.now().year), {})
+            current_cpe_analysis = cpe_analyzer.generate_current_year_cpe_analysis(current_year_data)
+
+            if current_cpe_analysis:
+                if not self.quiet:
+                    logger.info(
+                        f"  ✅ Generated cpe_analysis_current_year.json with {current_cpe_analysis['total_unique_cpes']:,} unique CPEs"
+                    )
+            else:
+                logger.error("  ❌ Current year CPE analysis failed")
+
+        except (ImportError, json.JSONDecodeError, OSError, KeyError) as e:
+            logger.error(f"  ❌ Error generating current year CPE analysis: {e}")
+            import traceback
+
+            traceback.print_exc()
+            logger.warning("  ⚠️  Current year CPE analysis will be missing")
+
+        # Generate CVSS analysis
+        try:
+            from cvss_analysis import CVSSAnalyzer
+
+            if not self.quiet:
+                logger.info("  📊 Generating comprehensive CVSS analysis...")
+            cvss_analyzer = CVSSAnalyzer(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet)
+            cvss_analysis = cvss_analyzer.generate_cvss_analysis(all_year_data)
+
+            if cvss_analysis:
+                if not self.quiet:
+                    logger.info("  ✅ Comprehensive CVSS analysis generated")
+            else:
+                logger.error("  ❌ Comprehensive CVSS analysis failed")
+
+        except (ImportError, json.JSONDecodeError, OSError) as e:
+            logger.error(f"  ❌ Error generating comprehensive CVSS analysis: {e}")
+            import traceback
+
+            traceback.print_exc()
+            logger.warning("  ⚠️  Comprehensive CVSS analysis will be missing")
+
+        # Generate current year CVSS analysis
+        try:
+            current_year_entry: dict[str, Any] | None = next(
+                (d for d in all_year_data if d.get("year") == self.current_year), None
+            )
+            if current_year_entry:
+                if not self.quiet:
+                    logger.info("  📅 Generating current year CVSS analysis...")
+                current_year_cvss_analysis = cvss_analyzer.generate_current_year_cvss_analysis(current_year_entry)
+
+                if current_year_cvss_analysis:
+                    if not self.quiet:
+                        logger.info("  ✅ Current year CVSS analysis generated")
+                else:
+                    logger.error("  ❌ Current year CVSS analysis failed")
+            else:
+                logger.warning(f"  ⚠️  No data found for current year {self.current_year}")
+
+        except (ImportError, json.JSONDecodeError, OSError, KeyError) as e:
+            logger.error(f"  ❌ Error generating current year CVSS analysis: {e}")
+            import traceback
+
+            traceback.print_exc()
+            logger.warning("  ⚠️  Current year CVSS analysis will be missing")
+
+        # Generate CWE analysis
+        try:
+            from cwe_analysis import CWEAnalyzer
+
+            if not self.quiet:
+                logger.info("  🔍 Generating comprehensive CWE analysis...")
+            cwe_analyzer = CWEAnalyzer(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet)
+            cwe_analysis = cwe_analyzer.generate_cwe_analysis(all_year_data)
+
+            if cwe_analysis:
+                if not self.quiet:
+                    logger.info(
+                        f"  ✅ Generated cwe_analysis.json with {cwe_analysis['total_unique_cwes']} unique CWEs"
+                    )
+            else:
+                logger.error("  ❌ CWE analysis failed")
+
+        except (ImportError, json.JSONDecodeError, OSError) as e:
+            logger.error(f"  ❌ Error generating CWE analysis: {e}")
+            import traceback
+
+            traceback.print_exc()
+            logger.warning("  ⚠️  CWE analysis will be missing")
+
+        # Generate current year CWE analysis
+        try:
+            current_year_entry = next((d for d in all_year_data if d.get("year") == self.current_year), None)
+            if current_year_entry:
+                if not self.quiet:
+                    logger.info("  📅 Generating current year CWE analysis...")
+                current_year_cwe_analysis = cwe_analyzer.generate_current_year_cwe_analysis(current_year_entry)
+
+                if current_year_cwe_analysis:
+                    if not self.quiet:
+                        logger.info(
+                            f"  ✅ Generated cwe_analysis_current_year.json with {current_year_cwe_analysis['total_unique_cwes']} unique CWEs"
+                        )
+                else:
+                    logger.error("  ❌ Current year CWE analysis failed")
+            else:
+                logger.warning(f"  ⚠️  No data found for current year {self.current_year}")
+
+        except (ImportError, json.JSONDecodeError, OSError, KeyError) as e:
+            logger.error(f"  ❌ Error generating current year CWE analysis: {e}")
+            import traceback
+
+            traceback.print_exc()
+            logger.warning("  ⚠️  Current year CWE analysis will be missing")
+
+        # Generate Calendar analysis
+        try:
+            from calendar_analysis import CalendarAnalyzer
+
+            if not self.quiet:
+                logger.info("  📅 Generating comprehensive calendar analysis...")
+            calendar_analyzer = CalendarAnalyzer(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet)
+            calendar_analysis = calendar_analyzer.generate_calendar_analysis()
+
+            if calendar_analysis:
+                if not self.quiet:
+                    logger.info(
+                        f"  ✅ Generated calendar_analysis.json with {calendar_analysis['metadata']['total_days']:,} days of data"
+                    )
+            else:
+                logger.error("  ❌ Calendar analysis failed")
+
+        except (ImportError, json.JSONDecodeError, OSError) as e:
+            logger.error(f"  ❌ Error generating calendar analysis: {e}")
+            import traceback
+
+            traceback.print_exc()
+            logger.warning("  ⚠️  Calendar analysis will be missing")
+
+        # Generate current year calendar analysis
+        try:
+            current_year_calendar_analysis = calendar_analyzer.generate_current_year_calendar_analysis()
+
+            if current_year_calendar_analysis:
+                logger.info(
+                    f"  ✅ Generated calendar_analysis_current_year.json with {current_year_calendar_analysis['metadata']['total_days']:,} days"
+                )
+            else:
+                logger.error("  ❌ Current year calendar analysis failed")
+
+        except (ImportError, json.JSONDecodeError, OSError, KeyError) as e:
+            logger.error(f"  ❌ Error generating current year calendar analysis: {e}")
+            import traceback
+
+            traceback.print_exc()
+            logger.warning("  ⚠️  Current year calendar analysis will be missing")
+
+        # Generate growth analysis
+        try:
+            from yearly_analysis import YearlyAnalyzer
+
+            logger.info("  📈 Generating growth analysis...")
+            yearly_analyzer = YearlyAnalyzer(self.base_dir, self.cache_dir, self.data_dir)
+            growth_analysis = yearly_analyzer.generate_growth_analysis(all_year_data)
+
+            if growth_analysis:
+                logger.info("  ✅ Growth analysis generated")
+            else:
+                logger.error("  ❌ Growth analysis failed")
+
+        except (ImportError, json.JSONDecodeError, OSError) as e:
+            logger.error(f"  ❌ Error generating growth analysis: {e}")
+            import traceback
+
+            traceback.print_exc()
+            logger.warning("  ⚠️  Growth analysis will be missing")
+
+        # Generate scoring analysis (EPSS, KEV, Risk Matrix)
+        try:
+            from scoring_analysis import ScoringAnalyzer
+
+            logger.info("  🎯 Generating scoring analysis (EPSS, KEV, Risk Matrix)...")
+            scoring_analyzer = ScoringAnalyzer(self.base_dir, self.cache_dir, self.data_dir)
+            scoring_results = scoring_analyzer.generate_all_scoring_analysis()
+
+            if scoring_results:
+                logger.info(f"  ✅ Scoring analysis generated: {', '.join(scoring_results.keys())}")
+            else:
+                logger.error("  ❌ Scoring analysis failed")
+
+        except (ImportError, json.JSONDecodeError, OSError) as e:
+            logger.error(f"  ❌ Error generating scoring analysis: {e}")
+            import traceback
+
+            traceback.print_exc()
+            logger.warning("  ⚠️  Scoring analysis will be missing")
+
+        # Generate cve_all.json from year data
+        self.generate_cve_all_json(all_year_data)
+        self.generate_homepage_summary_json(all_year_data)
+        self.generate_source_reconciliation_json(all_year_data)
+
+        logger.info("✅ Combined analysis JSON files generated")
+
+        return {
+            "cna_analysis": "generated",
+            "cpe_analysis": "generated",
+            "cvss_analysis": "generated",
+            "cwe_analysis": "generated",
+            "calendar_analysis": "generated",
+            "growth_analysis": "generated",
+            "cve_all": "generated",
+            "homepage_summary": "generated",
+            "source_reconciliation": "generated",
+        }
+
+    def _read_json_file(self, file_name: str, default: Any) -> Any:
+        """Read a JSON file from the output data directory with graceful fallback."""
+        file_path = self.data_dir / file_name
+        if not file_path.exists():
+            logger.warning(f"  ⚠️  Missing {file_name}, using defaults for homepage summary")
+            return default
+
+        try:
+            with open(file_path, encoding="utf-8") as f:
+                return json.load(f)
+        except (json.JSONDecodeError, OSError) as e:
+            logger.warning(f"  ⚠️  Could not read {file_name} ({e}), using defaults for homepage summary")
+            return default
+
+    def generate_source_reconciliation_json(self, all_year_data: list[dict[str, Any]]) -> None:
+        """Publish the per-year disagreement between the NVD and V5 pipelines.
+
+        The site shows counts from both: yearly figures come from the NVD mirror,
+        publisher attribution from cvelistV5. They are different record sets, so a
+        year can carry two slightly different totals. Rather than hide that, the
+        delta is measured here and surfaced on the data quality page.
+        """
+        logger.info("  🔍 Generating source_reconciliation.json...")
+
+        nvd_years = {
+            int(y["year"]): int(y.get("total_cves", 0)) for y in all_year_data if isinstance(y.get("year"), int)
+        }
+
+        cna_raw = self._read_json_file("cna_analysis.json", {})
+        v5_years: dict[int, int] = defaultdict(int)
+        for cna in cna_raw.get("cna_list", []):
+            for year, count in (cna.get("cves_by_year") or {}).items():
+                try:
+                    v5_years[int(year)] += int(count)
+                except (TypeError, ValueError):
+                    continue
+
+        drifts = reconcile_yearly_sources(nvd_years, dict(v5_years))
+        flagged = [d for d in drifts if not d.ok]
+
+        payload = {
+            "generated_at": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+            "sources": {
+                "nvd": {
+                    "label": "NVD mirror",
+                    "used_for": "yearly and daily counts, CVSS, CWE, CPE",
+                    "file": "yearly_summary.json",
+                },
+                "v5": {
+                    "label": "CVE Program cvelistV5",
+                    "used_for": "publisher attribution",
+                    "file": "cna_analysis.json",
+                },
+            },
+            "thresholds": {
+                "modern_year_floor": MODERN_YEAR_FLOOR,
+                "max_abs": MAX_YEAR_DRIFT_ABS,
+                "max_pct": MAX_YEAR_DRIFT_PCT,
+            },
+            "totals": {
+                "nvd": sum(nvd_years.values()),
+                "v5": sum(v5_years.values()),
+                "delta": sum(v5_years.values()) - sum(nvd_years.values()),
+            },
+            "years": [
+                {
+                    "year": d.year,
+                    "nvd": d.nvd,
+                    "v5": d.v5,
+                    "delta": d.delta,
+                    "pct": round(d.pct, 3),
+                    "modern": d.modern,
+                    "within_threshold": d.ok,
+                }
+                for d in drifts
+            ],
+            "flagged_years": [d.year for d in flagged],
+        }
+
+        output_file = self.data_dir / "source_reconciliation.json"
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(payload, f, indent=2)
+
+        if flagged:
+            logger.warning(
+                f"  ⚠️  {len(flagged)} year(s) drift beyond threshold between sources: "
+                + ", ".join(str(d.year) for d in flagged)
+            )
+        else:
+            logger.info("  ✅ Generated source_reconciliation.json (all modern years within threshold)")
+
+    def generate_homepage_summary_json(self, all_year_data: list[dict[str, Any]]) -> None:
+        """Generate a compact aggregate payload for homepage charts and stat cards."""
+        logger.info("  🏠 Generating homepage_summary.json...")
+
+        # Build compact yearly totals directly from generated year data.
+        yearly_summary_years: dict[str, dict[str, Any]] = {}
+        for year_data in sorted(all_year_data, key=lambda x: x.get("year", 0)):
+            year = year_data.get("year")
+            if not isinstance(year, int):
+                continue
+            yearly_summary_years[str(year)] = {
+                "year": year,
+                "total_cves": year_data.get("total_cves", 0),
+            }
+
+        growth_analysis_raw = self._read_json_file("growth_analysis.json", {})
+        cvss_analysis_raw = self._read_json_file("cvss_analysis.json", {})
+        epss_analysis_raw = self._read_json_file("epss_analysis.json", {})
+        kev_analysis_raw = self._read_json_file("kev_analysis.json", {})
+        cwe_analysis_raw = self._read_json_file("cwe_analysis.json", {})
+        cna_analysis_raw = self._read_json_file("cna_analysis.json", {})
+        cpe_analysis_raw = self._read_json_file("cpe_analysis.json", {})
+        calendar_current_year_raw = self._read_json_file("calendar_analysis_current_year.json", {})
+
+        homepage_summary = {
+            "generated_at": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+            **self.source_provenance(),
+            "current_year": self.current_year,
+            "yearly_summary": {
+                "years": yearly_summary_years,
+            },
+            "growth_analysis": {
+                "growth_data": growth_analysis_raw.get("growth_data", []),
+            },
+            "cvss_analysis": {
+                "score_distribution": cvss_analysis_raw.get("score_distribution", {}),
+                "kev_global_count": cvss_analysis_raw.get("kev_global_count", 0),
+                # Sum across CVSS versions, so a CVE scored under both v3.1 and v4.0
+                # counts twice. This is a count of scores, not of distinct CVEs.
+                "total_scores_all_versions": cvss_analysis_raw.get("total_cves_with_cvss", 0),
+            },
+            "epss_analysis": {
+                "statistics": epss_analysis_raw.get("statistics", {}),
+                "total_cves_with_epss": epss_analysis_raw.get("total_cves_with_epss", 0),
+                # EPSS rows matched to a CVE this site counts, by publication date.
+                # This is the figure comparable with the yearly totals.
+                "total_cves_with_epss_matched": epss_analysis_raw.get("total_cves_with_epss_matched", 0),
+                "epss_without_published_record": epss_analysis_raw.get("epss_without_published_record", 0),
+            },
+            "kev_analysis": {
+                "statistics": kev_analysis_raw.get("statistics", {}),
+                "by_year_added": kev_analysis_raw.get("by_year_added", {}),
+                "by_year_published": kev_analysis_raw.get("by_year_published", {}),
+            },
+            "cwe_analysis": {
+                "top_cwes": cwe_analysis_raw.get("top_cwes", [])[:10],
+                "total_cves_with_cwe": cwe_analysis_raw.get("total_cves_with_cwe", 0),
+                "total_unique_cwes": cwe_analysis_raw.get("total_unique_cwes", 0),
+            },
+            "cna_analysis": {
+                "cna_list": cna_analysis_raw.get("cna_list", [])[:25],
+                "total_cnas": cna_analysis_raw.get("total_cnas", 0),
+                "active_cnas": cna_analysis_raw.get("active_cnas", 0),
+            },
+            "cpe_analysis": {
+                "top_cpes": cpe_analysis_raw.get("top_cpes", [])[:25],
+                # Aggregated by product and by vendor. top_cpes is a list of CPE
+                # strings, so it holds several rows per product (version, edition,
+                # architecture) and must not be shown as a product ranking.
+                "top_products": cpe_analysis_raw.get("top_products", [])[:25],
+                "top_vendors": cpe_analysis_raw.get("top_vendors", [])[:25],
+                "total_cpe_entries": cpe_analysis_raw.get("total_cpe_entries", 0),
+                "total_cves_with_cpes": cpe_analysis_raw.get("total_cves_with_cpes", 0),
+            },
+            "calendar_analysis_current_year": {
+                "daily_data": calendar_current_year_raw.get("daily_data", []),
+            },
+        }
+
+        output_file = self.data_dir / "homepage_summary.json"
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(homepage_summary, f, indent=2)
+
+        logger.info("  ✅ Generated homepage_summary.json")
+
+    def generate_cna_analysis_fallback(self, all_year_data: list[dict[str, Any]]) -> None:
+        """Fallback CNA generation using cached NVD data when CVE V5 data is unavailable."""
+        logger.warning("  ⚠️  Falling back to NVD-based CNA analysis")
+        try:
+            from cna_analysis import CNAAnalyzer
+
+            cna_analyzer = CNAAnalyzer(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet)
+            comprehensive = cna_analyzer.generate_comprehensive_cna_analysis(all_year_data)
+            cna_list = comprehensive.get("cna_list", [])
+            fallback_total = sum(cna.get("count", 0) for cna in cna_list)
+            comprehensive["repository_stats"] = {
+                "total_cves": fallback_total,
+                "source": "nvd_fallback",
+            }
+
+            # Persist normalized fallback metadata for downstream validation.
+            with open(self.data_dir / "cna_analysis.json", "w", encoding="utf-8") as f:
+                json.dump(comprehensive, f, indent=2)
+
+            current_year_data = next((data for data in all_year_data if data.get("year") == self.current_year), {})
+            current_year = cna_analyzer.generate_current_year_cna_analysis(current_year_data)
+
+            logger.info(
+                "  ✅ Fallback CNA analysis generated: "
+                f"{comprehensive.get('total_cnas', 0)} total CNAs, "
+                f"{current_year.get('total_cnas', 0)} current-year CNAs, "
+                f"{fallback_total:,} total CVEs"
+            )
+        except (ImportError, json.JSONDecodeError, OSError, KeyError, TypeError) as e:
+            logger.error(f"  ❌ Fallback CNA analysis failed: {e}")
+
+    def _write_fallback_data_quality_json(self, reason: str) -> None:
+        """Write a minimal data_quality.json payload when detailed analysis cannot be generated."""
+        fallback_data = {
+            "generated_at": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+            **self.source_provenance(),
+            "status": "fallback",
+            "reason": reason,
+            "stats": {
+                "total_cnas_in_analysis": 0,
+                "exact_matches": 0,
+                "case_mismatches": 0,
+                "org_name_matches": 0,
+                "normalized_matches": 0,
+                "partial_matches": 0,
+                "unmatched": 0,
+                "case_mismatch_cves": 0,
+                "org_name_match_cves": 0,
+                "normalized_match_cves": 0,
+                "partial_match_cves": 0,
+                "unmatched_cves": 0,
+            },
+            "case_mismatches": [],
+            "org_name_matches": [],
+            "normalized_matches": [],
+            "partial_matches": [],
+            "unmatched": [],
+        }
+
+        output_file = self.data_dir / "data_quality.json"
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(fallback_data, f, indent=2)
+
+        logger.warning(f"  ⚠️  Wrote fallback data_quality.json ({reason})")
+
+    def generate_cve_all_json(self, all_year_data: list[dict[str, Any]]) -> None:
+        """Generate overall CVE statistics across all years"""
+        logger.info("  📊 Generating cve_all.json...")
+
+        if not all_year_data:
+            logger.warning("  ⚠️  No year data available")
+            return
+
+        # Calculate totals
+        total_cves = sum(year_data.get("total_cves", 0) for year_data in all_year_data)
+        years_with_data = len(all_year_data)
+
+        # Find peak year
+        peak_year_data = max(all_year_data, key=lambda x: x.get("total_cves", 0))
+        peak_year = peak_year_data.get("year", self.current_year)
+        peak_count = peak_year_data.get("total_cves", 0)
+
+        # Calculate YOY growth (current vs previous year)
+        current_year_data = next((d for d in all_year_data if d.get("year") == self.current_year), None)
+        prev_year_data = next((d for d in all_year_data if d.get("year") == self.current_year - 1), None)
+
+        yoy_growth = 0
+        if current_year_data and prev_year_data:
+            current_count = current_year_data.get("total_cves", 0)
+            prev_count = prev_year_data.get("total_cves", 0)
+            if prev_count > 0:
+                yoy_growth = ((current_count - prev_count) / prev_count) * 100
+
+        # Create yearly trend data using list comprehension
+        yearly_data = [
+            {"year": year_data.get("year"), "count": year_data.get("total_cves", 0)}
+            for year_data in sorted(all_year_data, key=lambda x: x.get("year", 0))
+        ]
+
+        cve_all_data = {
+            "generated_at": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+            **self.source_provenance(),
+            "total_cves": total_cves,
+            "years_covered": years_with_data,
+            "current_year": self.current_year,
+            "current_year_cves": current_year_data.get("total_cves", 0) if current_year_data else 0,
+            "peak_year": peak_year,
+            "peak_count": peak_count,
+            "yoy_growth_rate": round(yoy_growth, 1),
+            # Records this file deliberately omits, so downstream consumers can
+            # reconcile against V5-sourced totals without a magic number.
+            "excluded_pre_1999": self.excluded_pre_1999,
+            "yearly_trend": yearly_data,
+        }
+
+        # Save to file
+        output_file = self.data_dir / "cve_all.json"
+        with open(output_file, "w") as f:
+            json.dump(cve_all_data, f, indent=2)
+
+        logger.info(f"  ✅ Generated cve_all.json with {total_cves:,} total CVEs")
+
+        # Also generate yearly_summary.json for efficient loading
+        self.generate_yearly_summary_json(all_year_data)
+
+    def generate_yearly_summary_json(self, all_year_data: list[dict[str, Any]]) -> None:
+        """Generate consolidated yearly summary for efficient single-file loading.
+
+        This file contains all the data needed by years.html in one request,
+        avoiding 27 separate HTTP requests for individual year files.
+        """
+        logger.info("  📊 Generating yearly_summary.json...")
+
+        if not all_year_data:
+            logger.warning("  ⚠️  No year data available for summary")
+            return
+
+        # Build summary structure with everything years.html needs
+        summary = {
+            "generated_at": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+            **self.source_provenance(),
+            "years": {},
+        }
+
+        for year_data in sorted(all_year_data, key=lambda x: x.get("year", 0)):
+            year = year_data.get("year")
+            if not year:
+                continue
+
+            # Extract just the aggregates needed for charts (skip daily_counts)
+            year_summary = {
+                "year": year,
+                "total_cves": year_data.get("total_cves", 0),
+                "date_data": {
+                    "monthly_distribution": year_data.get("date_data", {}).get("monthly_distribution", {}),
+                    "daily_analysis": {
+                        "total_days": year_data.get("date_data", {}).get("daily_analysis", {}).get("total_days", 0),
+                        "avg_per_day": year_data.get("date_data", {}).get("daily_analysis", {}).get("avg_per_day", 0),
+                        "highest_day": year_data.get("date_data", {}).get("daily_analysis", {}).get("highest_day", {}),
+                        "lowest_day": year_data.get("date_data", {}).get("daily_analysis", {}).get("lowest_day", {}),
+                        # Note: daily_counts omitted to save ~300KB
+                    },
+                },
+                "cvss": year_data.get("cvss", {}),
+                "kev": year_data.get("kev", {}),
+                "vendors": year_data.get("vendors", {}),
+                "cwe": year_data.get("cwe", {}),
+                "metadata": year_data.get("metadata", {}),
+            }
+
+            summary["years"][year] = year_summary
+
+        output_file = self.data_dir / "yearly_summary.json"
+        with open(output_file, "w") as f:
+            json.dump(summary, f)  # No indent for smaller file size
+
+        # Calculate file size
+        file_size = output_file.stat().st_size / 1024
+        logger.info(f"  ✅ Generated yearly_summary.json ({file_size:.1f}KB, {len(summary['years'])} years)")
+
+    def generate_current_year_analysis_json(self, all_year_data: list[dict[str, Any]]) -> dict[str, str]:
+        """Generate current year specific analysis files"""
+        logger.debug(f"🗓️  Current year ({self.current_year}) analysis already handled in combined analysis")
+
+        # Current year analysis is now handled in generate_combined_analysis_json
+        # This method is kept for compatibility but doesn't need to do anything
+
+        return {"cna_current": "handled_in_combined_analysis"}
+
+    def generate_data_quality_json(self) -> None:
+        """Generate data quality analysis JSON using CNAScorecard-style name matching"""
+        logger.info("🔍 Generating data quality analysis...")
+
+        output_env_key = "CVE_OUTPUT_DATA_DIR"
+        previous_output_env = os.environ.get(output_env_key)
+        os.environ[output_env_key] = str(self.data_dir)
+
+        try:
+            # Import and run the rebuild_data_quality script
+            import sys
+
+            script_dir = self.base_dir / "data" / "scripts"
+            if str(script_dir) not in sys.path:
+                sys.path.insert(0, str(script_dir))
+
+            # Import the module
+            import importlib.util
+
+            spec = importlib.util.spec_from_file_location(
+                "rebuild_data_quality", script_dir / "rebuild_data_quality.py"
+            )
+            if spec is None or spec.loader is None:
+                raise ImportError("Could not load rebuild_data_quality module")
+            rebuild_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(rebuild_module)
+
+            # Run the main function (it handles its own output)
+            rebuild_module.main()
+
+            output_file = self.data_dir / "data_quality.json"
+            if output_file.exists():
+                logger.info("  ✅ Data quality analysis generated")
+            else:
+                self._write_fallback_data_quality_json("rebuild script completed without output")
+
+        except FileNotFoundError:
+            logger.warning("  ⚠️  rebuild_data_quality.py not found, skipping data quality analysis")
+            self._write_fallback_data_quality_json("rebuild_data_quality.py not found")
+        except SystemExit as e:
+            logger.warning(f"  ⚠️  Data quality script exited early ({e}), skipping data quality analysis")
+            self._write_fallback_data_quality_json(f"data quality script exited early ({e})")
+        except (ImportError, OSError) as e:
+            logger.warning(f"  ⚠️  Error generating data quality: {e}")
+            self._write_fallback_data_quality_json(f"data quality generation error: {e}")
+        finally:
+            if previous_output_env is None:
+                os.environ.pop(output_env_key, None)
+            else:
+                os.environ[output_env_key] = previous_output_env
+
+    def _static_asset_version(self) -> str:
+        """Short hash of the CSS and JS, so the query string changes only when they do."""
+        h = hashlib.sha256()
+        for rel in ("css/style.css", "js/app.js"):
+            f = self.source_static_dir / rel
+            if f.exists():
+                h.update(f.read_bytes())
+        return h.hexdigest()[:8]
+
+    def generate_html_pages(self) -> None:
+        """Generate HTML pages from templates"""
+        self.print_verbose("📄 Generating HTML pages...")
+
+        # Define pages to generate
+        pages = [
+            {"template": "index.html", "output": "index.html", "title": "CVE Intelligence Dashboard"},
+            {"template": "years.html", "output": "years.html", "title": "Yearly Analysis"},
+            {"template": "cna-hub.html", "output": "cna-hub.html", "title": "CNA Intelligence Hub"},
+            {"template": "cna.html", "output": "cna.html", "title": "CNA Intelligence Dashboard"},
+            {"template": "cpe.html", "output": "cpe.html", "title": "CPE Analysis"},
+            {"template": "cvss.html", "output": "cvss.html", "title": "CVSS Analysis"},
+            {"template": "cwe.html", "output": "cwe.html", "title": "CWE Analysis"},
+            {"template": "calendar.html", "output": "calendar.html", "title": "Calendar View"},
+            {"template": "growth.html", "output": "growth.html", "title": "Growth Analysis"},
+            {"template": "scoring.html", "output": "scoring.html", "title": "Scoring Hub"},
+            {"template": "epss.html", "output": "epss.html", "title": "EPSS Analysis"},
+            {"template": "kev.html", "output": "kev.html", "title": "KEV Analysis"},
+            {"template": "data-quality.html", "output": "data-quality.html", "title": "CNA Name Matching"},
+            {"template": "about.html", "output": "about.html", "title": "About CVEDB"},
+        ]
+
+        # Cache-buster for static assets. The site rebuilds hourly, so without this
+        # a browser keeps serving the previous CSS/JS against the new markup.
+        asset_version = self._static_asset_version()
+
+        # Generate each page
+        for page in pages:
+            try:
+                template = self.jinja_env.get_template(page["template"])
+
+                context = {
+                    "title": f"{page['title']} - CVEDB",
+                    "current_year": self.current_year,
+                    "available_years": self.available_years,
+                    "asset_version": asset_version,
+                }
+
+                html_content = template.render(**context)
+
+                with open(self.web_dir / page["output"], "w") as f:
+                    f.write(html_content)
+
+                self.print_verbose(f"  📄 Generated {page['output']}")
+
+            except (jinja2.TemplateError, OSError) as e:
+                self.print_always(f"  ❌ Error generating {page['output']}: {e}")
+
+        self.print_always("✅ HTML pages generated successfully")
+
+    def build_site(
+        self,
+        refresh_data: bool = False,
+        force_refresh: bool = False,
+        accept_baseline: bool = False,
+        strict: bool = False,
+    ) -> bool:
+        """Main build function - orchestrates the entire build process
+
+        Args:
+            refresh_data: If True, refresh CVE data before building
+            force_refresh: If True, force re-download even if cache is valid
+            accept_baseline: If True, skip the manifest regression check
+            strict: If True, treat data guards as fatal even outside CI
+        """
+        self.print_always("\n🏗️  Starting CVEDB site build...")
+        if not self.quiet:
+            logger.info("=" * 50)
+
+        staged_web_dir = Path(tempfile.mkdtemp(prefix=".web_build_", dir=self.base_dir))
+        self._set_output_dirs(staged_web_dir)
+
+        try:
+            # Step 0: Optionally refresh data from upstream sources
+            self.accept_baseline = accept_baseline
+            if strict:
+                self.strict_data_guards = True
+
+            if refresh_data and not self.refresh_data(force=force_refresh, accept_baseline=accept_baseline):
+                logger.error("❌ Data refresh failed, cannot continue build")
+                return False
+
+            # Step 1: Clean build directory
+            self.clean_build()
+
+            # Step 2: Ensure static assets are in place
+            self.ensure_static_assets()
+
+            # Step 3: Generate JSON data files
+            all_year_data = self.generate_year_data_json()
+
+            if not all_year_data:
+                logger.error("❌ No year data generated, cannot continue build")
+                return False
+
+            # Step 3.4: Republish the accepted source manifest with the site so
+            # the next build can use it as its regression baseline. Keeping the
+            # baseline on the live site (rather than in the repo) is what lets
+            # the scheduled workflow stop committing web/ back to main.
+            self.publish_source_manifest()
+
+            # Step 3.5: Guard against truncated/incomplete upstream feeds.
+            # A complete historical year that comes back with zero CVEs means the
+            # source feed was partial when downloaded. Fail loudly here so bad
+            # data is never published or committed.
+            self.verify_historical_year_coverage(all_year_data)
+
+            # Step 3.6: Refuse to publish data older than the freshness limit,
+            # and refuse counts that fall below what is already live. These are
+            # independent of the producer-side manifest checks: they catch our
+            # own analysis regressions, which the producer cannot see.
+            self.verify_data_freshness()
+            self.verify_no_regression(all_year_data)
+
+            # Step 4: Generate combined analysis JSON files
+            combined_analysis = self.generate_combined_analysis_json(all_year_data)
+
+            # Step 5: Generate current year analysis files
+            current_year_analysis = self.generate_current_year_analysis_json(all_year_data)
+
+            # Step 6: Generate data quality analysis
+            self.generate_data_quality_json()
+
+            # Step 7: Generate HTML pages
+            self.generate_html_pages()
+
+            # Step 8: Validate generated artifacts before publishing
+            self.validate_build_outputs()
+
+            # Step 9: Atomically publish staged output
+            self.publish_staged_site(staged_web_dir)
+            self._set_output_dirs(self.output_root_dir)
+
+            if not self.quiet:
+                logger.info("\n" + "=" * 50)
+            self.print_always("✅ Build completed successfully!")
+            if not self.quiet:
+                logger.info(f"📁 Site generated in: {self.web_dir}")
+                logger.info("🌐 Ready for deployment")
+                logger.info(f"📊 Coverage: {len(self.available_years)} years (1999-{self.current_year})")
+                logger.info(f"📊 Year data files: {len(all_year_data)} years processed")
+                logger.debug(f"🏢 CNA Analysis: {combined_analysis.get('cna_analysis', 'processed')}")
+                logger.debug(f"📈 CVE All data: {combined_analysis.get('cve_all', 'processed')}")
+                logger.debug(f"🗓️  Current year analysis: {current_year_analysis.get('cna_current', 'processed')}")
+
+            return True
+
+        except (ImportError, json.JSONDecodeError, OSError, RuntimeError, jinja2.TemplateError) as e:
+            logger.error(f"\n❌ Build failed: {e}")
+            if not self.quiet:
+                import traceback
+
+                traceback.print_exc()
+            return False
+        finally:
+            self._set_output_dirs(self.output_root_dir)
+            if staged_web_dir.exists():
+                shutil.rmtree(staged_web_dir, ignore_errors=True)
+
+    def publish_source_manifest(self) -> None:
+        """Copy the accepted source manifest into the site output.
+
+        Published at /data/source_manifest.json, which is where the downloader
+        looks for its regression baseline on the next run. Absent manifest is
+        not fatal: the producer may not have published one, in which case the
+        next run simply has no baseline to compare against.
+        """
+        manifest_src = self.cache_dir / "source_manifest.json"
+        cache_info_src = self.cache_dir / "cache_info.json"
+        if not manifest_src.exists():
+            self.print_verbose("  ⚠️  No accepted source manifest to publish")
+            return
+
+        # Only publish a manifest that describes the snapshot we actually built
+        # from. The cached manifest survives across runs, so republishing it
+        # blindly could advertise a baseline for data this build never used,
+        # which would then wrongly gate every future run.
+        try:
+            with open(manifest_src) as f:
+                manifest = json.load(f)
+            with open(cache_info_src) as f:
+                cache_info = json.load(f)
+        except (OSError, json.JSONDecodeError) as e:
+            logger.warning(f"  ⚠️  Could not verify manifest against cache info: {e}")
+            return
+
+        manifest_run = manifest.get("last_run_iso")
+        cached_run = cache_info.get("source_last_run")
+        if manifest_run != cached_run:
+            logger.warning(
+                f"  ⚠️  Not publishing source manifest: it describes run "
+                f"{manifest_run}, but the cached snapshot came from {cached_run}"
+            )
+            return
+
+        destination = self.data_dir / "source_manifest.json"
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(manifest_src, destination)
+        self.print_verbose(f"  ✅ Published source_manifest.json (run {manifest_run})")
+
+    def enforce_data_guard(self, summary: str, detail: str, remedy: str) -> None:
+        """Fail the build in CI, warn locally.
+
+        Args:
+            summary: one-line statement of what is wrong.
+            detail: the specific numbers, shown in both modes.
+            remedy: what the developer should do about it.
+        """
+        if self.strict_data_guards:
+            raise RuntimeError(f"{summary}\n{detail}\n{remedy}")
+
+        logger.warning(f"  ⚠️  {summary}")
+        for line in detail.splitlines():
+            logger.warning(f"  ⚠️  {line}")
+        logger.warning(f"  ⚠️  {remedy}")
+        logger.warning("  ⚠️  Not fatal outside CI. Use --strict to make it fatal here.")
+
+    def fetch_published_totals(self) -> dict[str, Any] | None:
+        """Fetch the currently published cve_all.json to use as a baseline.
+
+        Read from the live site rather than the repo so the check survives the
+        scheduled workflow no longer committing web/ back to main.
+        """
+        try:
+            response = requests.get(self.published_totals_url, timeout=30)
+            if response.status_code == 404:
+                logger.info("  📊 No published totals yet (first run)")
+                return None
+            response.raise_for_status()
+            published = response.json()
+        except (requests.RequestException, ValueError, json.JSONDecodeError) as e:
+            logger.warning(f"  ⚠️  Could not fetch published totals: {e}")
+            return None
+
+        if not isinstance(published, dict) or "total_cves" not in published:
+            logger.warning("  ⚠️  Published totals are malformed; ignoring")
+            return None
+        return published
+
+    def verify_no_regression(self, all_year_data: list[dict[str, Any]]) -> None:
+        """Fail the build if our own counts fall below what is already published.
+
+        This is deliberately independent of the source-manifest check in the
+        downloader. That one catches a bad snapshot from the producer; this one
+        catches a bug in our own analysis code, which the producer cannot see.
+
+        Keying: both sides here are OUR outputs, bucketed by publication date.
+        Never compare these to the manifest's year_counts, which are keyed by
+        CVE-ID year and are a different partition of the same data.
+
+        Thresholds are tight on purpose. Sweeping the 400 builds published
+        between 2026-06-26 and 2026-08-17 showed no legitimate run ever reduced
+        the site-wide total by more than 10, because the handful of genuine CVE
+        withdrawals in any window are outweighed by same-window additions. A
+        10-CVE allowance caught 15 of the 17 known bad builds with no false
+        positives; a 0.1% band, which is the intuitive choice, caught only 7.
+
+        Raises:
+            RuntimeError: on a material regression in the total or any closed year.
+        """
+        if self.accept_baseline:
+            logger.warning("  ⚠️  --accept-baseline: skipping published-totals regression check")
+            return
+
+        published = self.fetch_published_totals()
+        if published is None:
+            logger.info("  📊 No baseline available; skipping regression check")
+            return
+
+        problems: list[str] = []
+
+        prev_total = published.get("total_cves", 0)
+        new_total = sum(d.get("total_cves", 0) for d in all_year_data)
+        if new_total < prev_total - self.regression_allowance:
+            problems.append(
+                f"total {prev_total:,} -> {new_total:,} ({new_total - prev_total:,}, "
+                f"allowance {self.regression_allowance})"
+            )
+
+        new_years = {int(d["year"]): d.get("total_cves", 0) for d in all_year_data if "year" in d}
+        for entry in published.get("yearly_trend", []):
+            year = int(entry.get("year", 0))
+            # The current year is still accumulating, so only closed years are
+            # expected to hold steady.
+            if year >= self.current_year:
+                continue
+            prev_count = entry.get("count", 0)
+            new_count = new_years.get(year, 0)
+            if new_count < prev_count - self.regression_allowance:
+                problems.append(f"year {year} {prev_count:,} -> {new_count:,} ({new_count - prev_count:,})")
+
+        if problems:
+            self.enforce_data_guard(
+                "Counts regressed against the published site.",
+                "  " + "\n  ".join(problems),
+                "This usually means a bad upstream snapshot, an analysis regression, "
+                "or a stale local cache. Refresh with 'python build.py refresh --force', "
+                "or re-run with --accept-baseline if the decrease is confirmed as real.",
+            )
+            return
+
+        logger.info(f"    ✅ No regression against published totals ({prev_total:,} -> {new_total:,})")
+
+    def verify_data_freshness(self) -> None:
+        """Warn when the snapshot behind this build is old.
+
+        generated_at records when the build ran, which says nothing about how
+        old the underlying data is. This surfaces the difference rather than
+        letting a stale cache be published under a fresh timestamp.
+
+        Age is measured from the producer's last run, not from our download.
+        data_age_hours is only the gap between downloading and building - in CI
+        about seven minutes - so a month-old snapshot fetched just now still
+        reports ~0. Gating on that could never fire, which is how this guard
+        originally shipped.
+        """
+        info = self.source_provenance()
+        age_hours = info.get("source_age_hours")
+        if age_hours is None:
+            # cache_info files written before source_last_run existed, and
+            # those from the async download path, carry no producer timestamp.
+            # There is nothing to measure, so say so rather than guessing.
+            logger.warning("  ⚠️  Could not determine source age from cache info")
+            return
+
+        if age_hours > self.max_source_age_hours:
+            self.enforce_data_guard(
+                f"Source snapshot is {age_hours:.1f}h old, over the {self.max_source_age_hours}h limit.",
+                f"  produced {info.get('source_last_run')}, downloaded {info.get('data_as_of')}",
+                "Stale data must not be published under a fresh timestamp. "
+                "Refresh with 'python build.py refresh --force'.",
+            )
+            return
+        logger.info(f"    ✅ Source snapshot is {age_hours:.1f}h old")
+
+    @cache  # noqa: B019 - per-build instance, process is short-lived
+    def source_provenance(self) -> dict[str, Any]:
+        """Provenance of the snapshot this build is using.
+
+        Separate from generated_at, which is build time. Embedded in every
+        output so the site can show how old the data actually is.
+        """
+        cache_info_file = self.cache_dir / "cache_info.json"
+        provenance: dict[str, Any] = {
+            "data_as_of": None,
+            # Build latency: how long between fetching the snapshot and
+            # building from it. Near zero on a normal run. NOT data age - see
+            # source_age_hours, which is what verify_data_freshness() gates on.
+            "data_age_hours": None,
+            "source_last_run": None,
+            # True data age: how long since the producer last refreshed the
+            # feed. Independent of when we happened to download it.
+            "source_age_hours": None,
+            "source_cve_count": None,
+        }
+        try:
+            with open(cache_info_file) as f:
+                info = json.load(f)
+        except (OSError, json.JSONDecodeError) as e:
+            logger.warning(f"  ⚠️  Could not read cache info: {e}")
+            return provenance
+
+        provenance["source_last_run"] = info.get("source_last_run")
+        provenance["source_cve_count"] = info.get("source_cve_count")
+
+        download_time = info.get("download_time")
+        if download_time:
+            stamp = self._parse_cache_timestamp(download_time, "download_time")
+            if stamp is not None:
+                provenance["data_as_of"] = stamp.isoformat().replace("+00:00", "Z")
+                provenance["data_age_hours"] = round((datetime.now(UTC) - stamp).total_seconds() / 3600, 1)
+
+        source_last_run = info.get("source_last_run")
+        if source_last_run:
+            stamp = self._parse_cache_timestamp(source_last_run, "source_last_run")
+            if stamp is not None:
+                provenance["source_age_hours"] = round((datetime.now(UTC) - stamp).total_seconds() / 3600, 1)
+
+        return provenance
+
+    @staticmethod
+    def _parse_cache_timestamp(value: str, field: str) -> datetime | None:
+        """Parse an ISO timestamp from cache_info, or warn and return None."""
+        try:
+            stamp = datetime.fromisoformat(value)
+        except ValueError as e:
+            logger.warning(f"  ⚠️  Could not parse {field} {value!r}: {e}")
+            return None
+        # Older cache_info files carry a naive local timestamp.
+        if stamp.tzinfo is None:
+            stamp = stamp.replace(tzinfo=UTC)
+        return stamp
+
+    def verify_historical_year_coverage(self, all_year_data: list[dict[str, Any]]) -> None:
+        """Fail the build if any complete historical year has zero CVEs.
+
+        A truncated or partially-served upstream feed can silently drop an
+        entire year to zero records (this happened to 1999 on 2026-07-08).
+        Complete historical years never legitimately have zero CVEs, so treat
+        that as a fatal error rather than publishing a summary with a missing
+        year. The current year is excluded since it is still accumulating data.
+        """
+        counts = {int(d["year"]): d.get("total_cves", 0) for d in all_year_data if "year" in d}
+        earliest_year = self.available_years[0]
+        empty_years = [year for year in range(earliest_year, self.current_year) if counts.get(year, 0) <= 0]
+        if empty_years:
+            raise RuntimeError(
+                f"Historical year(s) with zero CVEs detected: {', '.join(map(str, empty_years))}. "
+                "This usually means the upstream CVE feed was truncated or incomplete when "
+                "downloaded. Aborting build to avoid publishing or committing partial data."
+            )
+        logger.info(
+            f"    ✅ Historical year coverage verified ({earliest_year}-{self.current_year - 1}, all years non-empty)"
+        )
+
+
+def main() -> None:
+    """Main entry point - delegates to Typer CLI"""
+    app()
+
+
+@app.command()
+def build(
+    quiet: Annotated[
+        bool, typer.Option("--quiet", "-q", help="Minimal output mode - reduces verbosity for CI/CD environments")
+    ] = False,
+    refresh_data: Annotated[
+        bool, typer.Option("--refresh-data", "-r", help="Download fresh CVE data from all sources before building")
+    ] = False,
+    force_refresh: Annotated[
+        bool,
+        typer.Option(
+            "--force-refresh", "-f", help="Force re-download even if cache is valid (requires --refresh-data)"
+        ),
+    ] = False,
+    validate: Annotated[
+        bool, typer.Option("--validate", help="Validate data counting consistency after build")
+    ] = False,
+    accept_baseline: Annotated[
+        bool,
+        typer.Option(
+            "--accept-baseline",
+            help="Skip the source-manifest regression check. Use only when the producer "
+            "has legitimately published a smaller snapshot and it has been confirmed.",
+        ),
+    ] = False,
+    strict: Annotated[
+        bool,
+        typer.Option(
+            "--strict",
+            help="Treat data freshness and regression guards as fatal outside CI (they are always fatal in CI).",
+        ),
+    ] = False,
+    log_level: Annotated[str, typer.Option("--log-level", help="Logging level")] = "INFO",
+) -> None:
+    """Build the CVEDB static site.
+
+    This is the main build command that generates all HTML pages
+    and JSON data files for the CVEDB vulnerability intelligence site.
+
+    Examples:
+        python build.py build              # Normal verbose output
+        python build.py build --quiet      # Minimal output for CI/CD
+        python build.py build --refresh-data  # Download fresh data before build
+        python build.py build --refresh-data --force-refresh  # Force re-download
+        python build.py build --validate   # Validate data consistency
+    """
+    # Validate log level
+    valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR"]
+    if log_level.upper() not in valid_levels:
+        console.print(f"[red]Invalid log level: {log_level}. Must be one of {valid_levels}[/red]")
+        raise typer.Exit(1)
+
+    # Setup logging based on args
+    if quiet:
+        setup_logging(level="WARNING")
+    else:
+        setup_logging(level=_validated_log_level(log_level))
+
+    builder = CVESiteBuilder(quiet=quiet)
+    success = builder.build_site(
+        refresh_data=refresh_data,
+        force_refresh=force_refresh,
+        accept_baseline=accept_baseline,
+        strict=strict,
+    )
+
+    if success and validate:
+        logger.info("\n🔍 Running data validation...")
+        if not validate_data_counts(builder):
+            console.print("[red]❌ Validation failed[/red]")
+            raise typer.Exit(1)
+        console.print("[green]✅ Validation passed[/green]")
+
+    if not success:
+        raise typer.Exit(1)
+
+
+@app.command()
+def refresh(
+    force: Annotated[bool, typer.Option("--force", "-f", help="Force re-download even if cache is valid")] = False,
+    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Minimal output mode")] = False,
+) -> None:
+    """Download fresh CVE data from all sources.
+
+    Downloads data from 5 sources in parallel (~3x faster than sequential):
+    - NVD CVE database
+    - CNA organization list
+    - CNA name mappings
+    - EPSS exploit prediction scores
+    - KEV (Known Exploited Vulnerabilities)
+    """
+    if quiet:
+        setup_logging(level="WARNING")
+    else:
+        setup_logging(level="INFO")
+
+    builder = CVESiteBuilder(quiet=quiet)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        progress.add_task(description="Downloading CVE data...", total=None)
+        success = builder.refresh_data(force=force)
+
+    if success:
+        console.print("[green]✅ Data refresh completed successfully[/green]")
+    else:
+        console.print("[red]❌ Data refresh failed[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def validate(
+    quiet: Annotated[bool, typer.Option("--quiet", "-q", help="Minimal output mode")] = False,
+) -> None:
+    """Validate data counting consistency.
+
+    Checks that:
+    - Sum of year files equals cve_all.json total
+    - CNA analysis totals are consistent
+    - Yearly trend data matches totals
+    """
+    if quiet:
+        setup_logging(level="WARNING")
+    else:
+        setup_logging(level="INFO")
+
+    builder = CVESiteBuilder(quiet=quiet)
+
+    console.print("\n🔍 Running data validation...")
+    if validate_data_counts(builder):
+        console.print("[green]✅ All validation checks passed[/green]")
+    else:
+        console.print("[red]❌ Validation failed[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def info() -> None:
+    """Show build system information and paths."""
+    builder = CVESiteBuilder(quiet=True)
+
+    console.print("\n[bold cyan]CVEDB Build System Info[/bold cyan]\n")
+    console.print(f"  📅 Current Year: [green]{builder.current_year}[/green]")
+    console.print(
+        f"  📊 Year Coverage: [green]1999-{builder.current_year}[/green] ({len(builder.available_years)} years)"
+    )
+    console.print(f"  🌐 Web Output: [blue]{builder.web_dir}[/blue]")
+    console.print(f"  📁 Templates: [blue]{builder.templates_dir}[/blue]")
+    console.print(f"  💾 Cache Dir: [blue]{builder.cache_dir}[/blue]")
+    console.print(f"  📂 Data Dir: [blue]{builder.data_dir}[/blue]")
+
+    # Check cache status
+    cache_info = builder.cache_dir / "cache_info.json"
+    if cache_info.exists():
+        import json
+
+        with open(cache_info) as f:
+            info = json.load(f)
+        console.print("\n  [bold]Cache Status:[/bold]")
+        console.print(f"    Last download: [yellow]{info.get('download_time', 'unknown')}[/yellow]")
+    else:
+        console.print("\n  [yellow]⚠️  No cache info found - run 'build --refresh-data'[/yellow]")
+
+
+# --- CNA vs cve_all reconciliation -------------------------------------------
+#
+# cve_all.json is assembled from the 1999+ year files (NVD-sourced);
+# cna_analysis.json counts every non-rejected cvelistV5 record. The gap between
+# them is two independent terms, and only one of them can indicate a problem:
+#
+#   1. Pre-1999 publications - legacy CVEs backdated to their original 1988-1998
+#      disclosure date. Frozen history: it does not grow with the corpus. The
+#      exact count is measured during the build and published as
+#      cve_all.json:excluded_pre_1999.
+#   2. NVD ingestion lag - cvelistV5 has a CVE the moment the CNA publishes it;
+#      NVD ingests behind. This scales with DAILY publication volume, not corpus
+#      size - one Oracle CPU day alone lands 1,100-1,400 CVEs.
+#
+# Bounding (2) is the only useful check here, but it used to be measured as
+# abs((1) + (2)) against a flat 1,000. The fixed 679-record offset ate two thirds
+# of that budget, leaving ~321 CVEs of lag headroom, and the first busy
+# publication day tipped it over (2026-08-25: diff 1,196, deploy failed).
+# Subtracting (1) explicitly restores the full budget to the term that varies.
+
+# Used only when cve_all.json predates the excluded_pre_1999 field. Measured
+# 2026-08-26 against the NVD feed; it moves only if NVD re-dates legacy records.
+PRE_1999_FALLBACK = 679
+
+# Largest single publication day observed through 2026-08 is 1,474 (2026-07-21,
+# Oracle CPU). Two consecutive days of that with no ingestion is a stalled NVD
+# feed worth failing the deploy over; less than that is NVD catching up normally.
+MAX_INGESTION_LAG = 3000
+
+# V5 leads NVD, always. NVD pulling ahead by more than a rounding margin means a
+# feed is wrong - a real bug the previous abs() comparison could not see.
+MAX_NVD_LEAD = 100
+
+
+@dataclass(frozen=True)
+class ReconciliationResult:
+    """Outcome of comparing the V5-sourced CNA total against NVD-sourced cve_all."""
+
+    ok: bool
+    lag: int
+    pre_1999: int
+    message: str
+
+
+# Per-year reconciliation between the two sources.
+#
+# yearly_summary.json counts from the NVD mirror; cna_analysis.json counts from
+# the CVE Program's cvelistV5 repository. Both bucket by publication year, so a
+# year's totals should agree closely - but they are different record sets, and
+# NVD normalised historical publication dates differently. Years before the CNA
+# programme widened are therefore allowed to differ freely; modern years are not.
+MODERN_YEAR_FLOOR = 2016
+MAX_YEAR_DRIFT_ABS = 250
+MAX_YEAR_DRIFT_PCT = 0.5
+
+
+@dataclass(frozen=True)
+class YearDrift:
+    """One year's disagreement between the NVD-sourced and V5-sourced counts."""
+
+    year: int
+    nvd: int
+    v5: int
+    modern: bool
+
+    @property
+    def delta(self) -> int:
+        return self.v5 - self.nvd
+
+    @property
+    def pct(self) -> float:
+        return (self.delta / self.nvd * 100) if self.nvd else 0.0
+
+    @property
+    def ok(self) -> bool:
+        if not self.modern:
+            return True
+        if abs(self.delta) <= MAX_YEAR_DRIFT_ABS:
+            return True
+        # With no NVD baseline the percentage is undefined, and .pct reports 0.0
+        # to stay JSON-safe - so it must never be the thing that approves a year.
+        if not self.nvd:
+            return False
+        return abs(self.pct) <= MAX_YEAR_DRIFT_PCT
+
+
+def reconcile_yearly_sources(
+    nvd_years: dict[int, int],
+    v5_years: dict[int, int],
+) -> list[YearDrift]:
+    """Compare per-year CVE counts from the NVD and V5 pipelines.
+
+    Returns one YearDrift per year present in either source, oldest first.
+    Callers decide what to do with the ones whose .ok is False.
+    """
+    drifts: list[YearDrift] = []
+    for year in sorted({*nvd_years, *v5_years}):
+        drifts.append(
+            YearDrift(
+                year=year,
+                nvd=nvd_years.get(year, 0),
+                v5=v5_years.get(year, 0),
+                modern=year >= MODERN_YEAR_FLOOR,
+            )
+        )
+    return drifts
+
+
+def reconcile_cna_vs_year_totals(
+    repo_total: int,
+    cve_all_total: int,
+    excluded_pre_1999: int | None = None,
+) -> ReconciliationResult:
+    """Reconcile the CNA (V5) total against the cve_all (NVD, 1999+) total.
+
+    Subtracts the known pre-1999 offset, then bounds what remains - NVD
+    ingestion lag - in both directions. See the module comment above and
+    docs/COUNTING.md for where the thresholds come from.
+    """
+    pre_1999 = PRE_1999_FALLBACK if excluded_pre_1999 is None else excluded_pre_1999
+    lag = repo_total - cve_all_total - pre_1999
+
+    if lag < -MAX_NVD_LEAD:
+        return ReconciliationResult(
+            ok=False,
+            lag=lag,
+            pre_1999=pre_1999,
+            message=(
+                f"cve_all ({cve_all_total:,}) leads CNA data by {-lag:,} after the "
+                f"{pre_1999:,} pre-1999 offset - NVD should never be ahead of cvelistV5"
+            ),
+        )
+
+    if lag > MAX_INGESTION_LAG:
+        return ReconciliationResult(
+            ok=False,
+            lag=lag,
+            pre_1999=pre_1999,
+            message=(
+                f"NVD ingestion lag ({lag:,}) exceeds {MAX_INGESTION_LAG:,} - cvelistV5 "
+                f"has CVEs the NVD feed has not picked up (CNA {repo_total:,} vs "
+                f"cve_all {cve_all_total:,}, pre-1999 offset {pre_1999:,})"
+            ),
+        )
+
+    return ReconciliationResult(
+        ok=True,
+        lag=lag,
+        pre_1999=pre_1999,
+        message=(
+            f"CNA total ({repo_total:,}) reconciles with cve_all ({cve_all_total:,}) "
+            f"[pre-1999: {pre_1999:,}, NVD lag: {lag:,}]"
+        ),
+    )
+
+
+def validate_data_counts(builder: CVESiteBuilder) -> bool:
+    """Validate that data counting is consistent across output files.
+
+    See COUNTING.md for detailed documentation of expected behavior.
+    """
+    import json
+
+    data_dir = builder.data_dir
+    errors: list[str] = []
+    warnings: list[str] = []
+
+    logger.info("  📊 Checking year file totals...")
+
+    # 1. Sum of year files should equal cve_all.json total
+    year_sum = 0
+    for year in range(1999, builder.current_year + 1):
+        year_file = data_dir / f"cve_{year}.json"
+        if year_file.exists():
+            with open(year_file) as f:
+                data = json.load(f)
+            year_sum += data.get("total_cves", 0)
+
+    cve_all_file = data_dir / "cve_all.json"
+    if cve_all_file.exists():
+        with open(cve_all_file) as f:
+            cve_all = json.load(f)
+        cve_all_total = cve_all.get("total_cves", 0)
+
+        if year_sum != cve_all_total:
+            errors.append(f"Year files sum ({year_sum:,}) != cve_all.json total ({cve_all_total:,})")
+        else:
+            logger.info(f"    ✅ Year files sum matches cve_all.json: {year_sum:,}")
+    else:
+        errors.append("cve_all.json not found")
+
+    # 2. CNA analysis should have repository_stats.total_cves matching CNA list sum
+    logger.info("  🏢 Checking CNA analysis totals...")
+    cna_file = data_dir / "cna_analysis.json"
+    if cna_file.exists():
+        with open(cna_file) as f:
+            cna_data = json.load(f)
+
+        repo_total = cna_data.get("repository_stats", {}).get("total_cves", 0)
+        cna_list = cna_data.get("cna_list", [])
+        cna_sum = sum(cna.get("count", 0) for cna in cna_list)
+
+        if repo_total != cna_sum:
+            errors.append(f"CNA repo_stats ({repo_total:,}) != sum of CNA counts ({cna_sum:,})")
+        else:
+            logger.info(f"    ✅ CNA counts consistent: {cna_sum:,}")
+
+        # Both sides exclude REJECTED, so the remaining gap is the pre-1999
+        # offset plus NVD ingestion lag. Subtract the former, bound the latter.
+        if cve_all_file.exists():
+            excluded_pre_1999 = cve_all.get("excluded_pre_1999")
+            if excluded_pre_1999 is None:
+                warnings.append(
+                    f"cve_all.json has no excluded_pre_1999 field; reconciling against the "
+                    f"{PRE_1999_FALLBACK:,} fallback. Rebuild to measure it."
+                )
+
+            reconciliation = reconcile_cna_vs_year_totals(repo_total, cve_all_total, excluded_pre_1999)
+            if reconciliation.ok:
+                logger.info(f"    ✅ {reconciliation.message}")
+            else:
+                errors.append(reconciliation.message)
+    else:
+        warnings.append("cna_analysis.json not found")
+
+    # 2b. Per-year agreement between the NVD-sourced and V5-sourced counts
+    logger.info("  🔍 Checking per-year agreement between sources...")
+    recon_file = data_dir / "source_reconciliation.json"
+    if recon_file.exists():
+        with open(recon_file, encoding="utf-8") as f:
+            recon = json.load(f)
+        flagged = recon.get("flagged_years", [])
+        if flagged:
+            detail = ", ".join(
+                f"{y['year']} (NVD {y['nvd']:,} vs V5 {y['v5']:,}, {y['delta']:+,})"
+                for y in recon.get("years", [])
+                if y["year"] in flagged
+            )
+            warnings.append(f"Sources disagree beyond threshold for: {detail}")
+        else:
+            worst = max(
+                (y for y in recon.get("years", []) if y["modern"]),
+                key=lambda y: abs(y["delta"]),
+                default=None,
+            )
+            if worst:
+                logger.info(
+                    f"    ✅ Modern years agree within threshold (largest gap {worst['year']}: {worst['delta']:+,})"
+                )
+
+    # 3. Yearly trend in cve_all.json should match year files
+    logger.info("  📈 Checking yearly trend consistency...")
+    if cve_all_file.exists():
+        yearly_trend = cve_all.get("yearly_trend", [])
+        trend_sum = sum(y.get("count", 0) for y in yearly_trend)
+        if trend_sum != cve_all_total:
+            errors.append(f"yearly_trend sum ({trend_sum:,}) != total_cves ({cve_all_total:,})")
+        else:
+            logger.info(f"    ✅ Yearly trend sum matches total: {trend_sum:,}")
+
+    # Report results
+    if errors:
+        logger.error("\n  ❌ Validation errors:")
+        for error in errors:
+            logger.error(f"     - {error}")
+
+    if warnings:
+        logger.warning("\n  ⚠️  Validation warnings:")
+        for warning in warnings:
+            logger.warning(f"     - {warning}")
+
+    return len(errors) == 0
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data/async_downloader.py b/data/async_downloader.py
new file mode 100644
index 00000000000..1f1cb51988a
--- /dev/null
+++ b/data/async_downloader.py
@@ -0,0 +1,455 @@
+#!/usr/bin/env python3
+"""
+Async CVE Data Downloader
+
+Provides parallel download capabilities for CVE data from multiple sources.
+Uses httpx for async HTTP requests, enabling ~3x faster downloads by
+fetching from NVD, EPSS, KEV, and CNA sources simultaneously.
+
+Usage:
+    # Async context manager for parallel downloads
+    async with AsyncCVEDownloader() as downloader:
+        results = await downloader.download_all_sources()
+
+    # Or use the sync wrapper
+    downloader = AsyncCVEDownloader()
+    results = downloader.download_all_sync()
+"""
+
+from __future__ import annotations
+
+import asyncio
+import csv
+import gzip
+import hashlib
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+
+try:
+    import httpx
+
+    HTTPX_AVAILABLE = True
+except ImportError:
+    HTTPX_AVAILABLE = False
+
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class DownloadResult:
+    """Result of a single download operation."""
+
+    source: str
+    success: bool
+    path: Path | None = None
+    size_bytes: int = 0
+    duration_seconds: float = 0.0
+    error: str | None = None
+    from_cache: bool = False
+
+
+@dataclass
+class AsyncCVEDownloader:
+    """Async downloader for CVE data from multiple sources.
+
+    Downloads data from 5 sources in parallel:
+    1. NVD CVE database (nvd.json) - Main CVE data
+    2. CNA List (cna_list.json) - CNA organization list
+    3. CNA Name Map (cna_name_map.json) - CNA name mappings
+    4. EPSS Scores (epss_scores-current.csv.gz) - Exploit prediction scores
+    5. KEV Catalog (known_exploited_vulnerabilities.json) - Known exploited CVEs
+
+    Attributes:
+        cache_dir: Directory for cached downloads
+        cache_duration: How long to consider cache valid
+        timeout: HTTP request timeout in seconds
+        quiet: Suppress info logging
+    """
+
+    cache_dir: Path = field(default_factory=lambda: Path(__file__).parent / "cache")
+    cache_duration: timedelta = field(default_factory=lambda: timedelta(minutes=50))
+    timeout: int = 120
+    quiet: bool = False
+
+    # URL configurations
+    nvd_url: str = "https://nvd.handsonhacking.org/nvd.json"
+    cna_list_url: str = "https://raw.githubusercontent.com/CVEProject/cve-website/dev/src/assets/data/CNAsList.json"
+    cna_name_map_url: str = "https://www.cve.org/cve-partner-name-map.json"
+    epss_url: str = "https://epss.empiricalsecurity.com/epss_scores-current.csv.gz"
+    kev_url: str = "https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json"
+
+    _client: Any = field(default=None, init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        """Ensure cache directory exists."""
+        self.cache_dir = Path(self.cache_dir)
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+        # Define cache file paths
+        self.nvd_file = self.cache_dir / "nvd.json"
+        self.cna_list_file = self.cache_dir / "cna_list.json"
+        self.cna_name_map_file = self.cache_dir / "cna_name_map.json"
+        self.epss_cache_file = self.cache_dir / "epss_scores-current.csv.gz"
+        self.epss_parsed_file = self.cache_dir / "epss_scores-current.json"
+        self.kev_cache_file = self.cache_dir / "known_exploited_vulnerabilities.json"
+        self.kev_parsed_file = self.cache_dir / "known_exploited_vulnerabilities_parsed.json"
+        self.cache_info_file = self.cache_dir / "cache_info.json"
+
+    async def __aenter__(self) -> AsyncCVEDownloader:
+        """Create async HTTP client on context entry."""
+        if not HTTPX_AVAILABLE:
+            raise ImportError("httpx is required for async downloads. Install with: pip install httpx")
+        self._client = httpx.AsyncClient(timeout=self.timeout, follow_redirects=True)
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Close async HTTP client on context exit."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    def _is_cache_valid(self, cache_file: Path) -> bool:
+        """Check if a cache file exists and is not expired."""
+        if not cache_file.exists():
+            return False
+        try:
+            mtime = datetime.fromtimestamp(cache_file.stat().st_mtime)
+            return datetime.now() - mtime < self.cache_duration
+        except OSError:
+            return False
+
+    async def _download_file(
+        self,
+        url: str,
+        cache_file: Path,
+        source_name: str,
+        force: bool = False,
+        is_binary: bool = False,
+    ) -> DownloadResult:
+        """Download a single file with caching support.
+
+        Args:
+            url: URL to download from
+            cache_file: Path to save the file
+            source_name: Human-readable name for logging
+            force: Force download even if cache is valid
+            is_binary: Whether to save as binary (for gzip files)
+
+        Returns:
+            DownloadResult with success status and metadata
+        """
+        start_time = datetime.now()
+
+        # Check cache first
+        if not force and self._is_cache_valid(cache_file):
+            if not self.quiet:
+                logger.debug(f"  ✅ Using cached {source_name}")
+            return DownloadResult(
+                source=source_name,
+                success=True,
+                path=cache_file,
+                size_bytes=cache_file.stat().st_size if cache_file.exists() else 0,
+                duration_seconds=0.0,
+                from_cache=True,
+            )
+
+        if not self.quiet:
+            logger.info(f"  🔽 Downloading {source_name}...")
+
+        try:
+            response = await self._client.get(url)
+            response.raise_for_status()
+
+            # Save content
+            if is_binary:
+                cache_file.write_bytes(response.content)
+            else:
+                cache_file.write_text(response.text, encoding="utf-8")
+
+            duration = (datetime.now() - start_time).total_seconds()
+            size = len(response.content)
+
+            if not self.quiet:
+                size_str = f"{size / (1024 * 1024):.2f} MB" if size > 1024 * 1024 else f"{size / 1024:.1f} KB"
+                logger.info(f"  ✅ {source_name} complete ({size_str} in {duration:.1f}s)")
+
+            return DownloadResult(
+                source=source_name,
+                success=True,
+                path=cache_file,
+                size_bytes=size,
+                duration_seconds=duration,
+            )
+
+        except httpx.HTTPError as e:
+            duration = (datetime.now() - start_time).total_seconds()
+            error_msg = str(e)
+
+            # Try to use stale cache as fallback
+            if cache_file.exists():
+                logger.warning(f"  ⚠️  {source_name} download failed, using stale cache: {error_msg}")
+                return DownloadResult(
+                    source=source_name,
+                    success=True,
+                    path=cache_file,
+                    size_bytes=cache_file.stat().st_size,
+                    duration_seconds=duration,
+                    from_cache=True,
+                    error=f"Using stale cache: {error_msg}",
+                )
+
+            logger.error(f"  ❌ {source_name} download failed: {error_msg}")
+            return DownloadResult(
+                source=source_name,
+                success=False,
+                duration_seconds=duration,
+                error=error_msg,
+            )
+
+    async def download_nvd(self, force: bool = False) -> DownloadResult:
+        """Download NVD CVE database."""
+        result = await self._download_file(self.nvd_url, self.nvd_file, "NVD CVE Data", force)
+
+        # Update cache info if successful
+        if result.success and not result.from_cache:
+            cache_info = {
+                "download_time": datetime.now().isoformat(),
+                "file_size": result.size_bytes,
+                "file_hash": self._calculate_hash(self.nvd_file),
+                "source_url": self.nvd_url,
+            }
+            self.cache_info_file.write_text(json.dumps(cache_info, indent=2))
+
+        return result
+
+    async def download_cna_list(self, force: bool = False) -> DownloadResult:
+        """Download CNA organization list."""
+        return await self._download_file(self.cna_list_url, self.cna_list_file, "CNA List", force)
+
+    async def download_cna_name_map(self, force: bool = False) -> DownloadResult:
+        """Download CNA name mapping."""
+        return await self._download_file(self.cna_name_map_url, self.cna_name_map_file, "CNA Name Map", force)
+
+    async def download_epss(self, force: bool = False) -> DownloadResult:
+        """Download EPSS scores (gzipped CSV)."""
+        return await self._download_file(self.epss_url, self.epss_cache_file, "EPSS Scores", force, is_binary=True)
+
+    async def download_kev(self, force: bool = False) -> DownloadResult:
+        """Download CISA KEV catalog."""
+        return await self._download_file(self.kev_url, self.kev_cache_file, "KEV Catalog", force)
+
+    async def download_all_sources(self, force: bool = False) -> dict[str, DownloadResult]:
+        """Download all data sources in parallel.
+
+        This is the main method that provides ~3x speedup by running
+        all downloads concurrently.
+
+        Args:
+            force: Force download even if caches are valid
+
+        Returns:
+            Dict mapping source names to DownloadResult objects
+        """
+        if not self.quiet:
+            logger.info("🚀 Starting parallel download of all CVE data sources...")
+
+        start_time = datetime.now()
+
+        # Run all downloads in parallel
+        results = await asyncio.gather(
+            self.download_nvd(force),
+            self.download_cna_list(force),
+            self.download_cna_name_map(force),
+            self.download_epss(force),
+            self.download_kev(force),
+            return_exceptions=True,
+        )
+
+        # Convert to dict and handle exceptions
+        source_names = ["nvd", "cna_list", "cna_name_map", "epss", "kev"]
+        results_dict: dict[str, DownloadResult] = {}
+
+        for name, result in zip(source_names, results):
+            if isinstance(result, BaseException):
+                results_dict[name] = DownloadResult(
+                    source=name,
+                    success=False,
+                    error=str(result),
+                )
+            else:
+                results_dict[name] = result
+
+        total_duration = (datetime.now() - start_time).total_seconds()
+
+        # Summary logging
+        if not self.quiet:
+            successful = sum(1 for r in results_dict.values() if r.success)
+            total_bytes = sum(r.size_bytes for r in results_dict.values() if r.success)
+            cached = sum(1 for r in results_dict.values() if r.from_cache)
+
+            logger.info("\n📊 Download Summary:")
+            logger.info(f"  ✅ Successful: {successful}/{len(results_dict)}")
+            logger.info(f"  📦 Total size: {total_bytes / (1024 * 1024):.2f} MB")
+            logger.info(f"  💾 From cache: {cached}")
+            logger.info(f"  ⏱️  Total time: {total_duration:.1f}s")
+
+        return results_dict
+
+    def _calculate_hash(self, file_path: Path) -> str:
+        """Calculate SHA256 hash of file."""
+        hash_sha256 = hashlib.sha256()
+        content = file_path.read_bytes()
+        hash_sha256.update(content)
+        return hash_sha256.hexdigest()
+
+    def parse_epss(self) -> dict[str, dict[str, float]] | None:
+        """Parse EPSS CSV into JSON mapping.
+
+        Returns dict like:
+        {
+            "CVE-2024-12345": {"epss_score": 0.1234, "epss_percentile": 0.9876},
+            ...
+        }
+        """
+        if not self.epss_cache_file.exists():
+            return None
+
+        if not self.quiet:
+            logger.info("  🔍 Parsing EPSS CSV...")
+
+        mapping: dict[str, dict[str, float]] = {}
+        try:
+            with gzip.open(self.epss_cache_file, mode="rt", encoding="utf-8") as f:
+                lines = (line for line in f if not line.startswith("#"))
+                reader = csv.DictReader(lines)
+                for row in reader:
+                    cve_id = row.get("cve") or row.get("CVE")
+                    if not cve_id:
+                        continue
+                    try:
+                        score = float(row.get("epss", "0") or 0)
+                    except ValueError:
+                        score = 0.0
+                    try:
+                        percentile = float(row.get("percentile", "0") or 0)
+                    except ValueError:
+                        percentile = 0.0
+                    mapping[cve_id.strip()] = {
+                        "epss_score": score,
+                        "epss_percentile": percentile,
+                    }
+
+            # Save parsed JSON
+            self.epss_parsed_file.write_text(json.dumps(mapping), encoding="utf-8")
+
+            if not self.quiet:
+                logger.info(f"  ✅ EPSS parsed: {len(mapping):,} CVEs")
+
+            return mapping
+
+        except (gzip.BadGzipFile, csv.Error, OSError) as e:
+            logger.warning(f"  ⚠️  EPSS parse failed: {e}")
+            return None
+
+    def parse_kev(self) -> dict[str, bool] | None:
+        """Parse KEV JSON into CVE set.
+
+        Returns dict like:
+        {
+            "CVE-2024-12345": True,
+            ...
+        }
+        """
+        if not self.kev_cache_file.exists():
+            return None
+
+        if not self.quiet:
+            logger.info("  🔍 Parsing KEV JSON...")
+
+        try:
+            raw = json.loads(self.kev_cache_file.read_text(encoding="utf-8"))
+
+            vulnerabilities = raw.get("vulnerabilities")
+            if vulnerabilities is None and isinstance(raw, list):
+                vulnerabilities = raw
+
+            mapping: dict[str, bool] = {
+                cve_id.strip(): True
+                for entry in (vulnerabilities if isinstance(vulnerabilities, list) else [])
+                if (cve_id := entry.get("cveID") or entry.get("cveId") or entry.get("cve"))
+                and isinstance(cve_id, str)
+                and cve_id.startswith("CVE-")
+            }
+
+            # Save parsed JSON
+            self.kev_parsed_file.write_text(json.dumps(mapping), encoding="utf-8")
+
+            if not self.quiet:
+                logger.info(f"  ✅ KEV parsed: {len(mapping):,} CVEs")
+
+            return mapping
+
+        except (json.JSONDecodeError, OSError) as e:
+            logger.warning(f"  ⚠️  KEV parse failed: {e}")
+            return None
+
+    def download_all_sync(self, force: bool = False) -> dict[str, DownloadResult]:
+        """Synchronous wrapper for download_all_sources().
+
+        Use this when you need to call from non-async code.
+
+        Example:
+            downloader = AsyncCVEDownloader()
+            results = downloader.download_all_sync()
+        """
+
+        async def _run() -> dict[str, DownloadResult]:
+            async with self as dl:
+                return await dl.download_all_sources(force)
+
+        return asyncio.run(_run())
+
+
+async def main_async() -> None:
+    """Async main entry point."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Download CVE data (async)")
+    parser.add_argument("--force", action="store_true", help="Force download")
+    parser.add_argument("--cache-dir", help="Custom cache directory")
+
+    args = parser.parse_args()
+
+    # cache_dir is typed Path and passed through Path() in __post_init__, so
+    # None would fail there. Fall back to the dataclass default instead.
+    downloader = AsyncCVEDownloader(cache_dir=Path(args.cache_dir)) if args.cache_dir else AsyncCVEDownloader()
+
+    async with downloader:
+        results = await downloader.download_all_sources(force=args.force)
+
+        # Parse supplemental data
+        downloader.parse_epss()
+        downloader.parse_kev()
+
+        # Show results
+        for name, result in results.items():
+            status = "✅" if result.success else "❌"
+            print(f"{status} {name}: {result.path or result.error}")
+
+
+def main() -> None:
+    """Sync main entry point."""
+    asyncio.run(main_async())
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data/cache/cache_info.json b/data/cache/cache_info.json
new file mode 100644
index 00000000000..4c4164c995a
--- /dev/null
+++ b/data/cache/cache_info.json
@@ -0,0 +1,9 @@
+{
+  "download_time": "2026-09-23T23:17:01.624095+00:00",
+  "file_size": 1856883164,
+  "file_hash": "71b3a2aa907c684d680964813c5260ae76684ee23803a2674314af72cce4fe13",
+  "source_url": "https://nvd.handsonhacking.org/nvd.json",
+  "source_last_run": "2026-09-23T22:43:35.530306+00:00",
+  "source_cve_count": 396856,
+  "source_commit_sha": "38ff9ea004ec0186966cda3966bb221588e2d4af"
+}
\ No newline at end of file
diff --git a/data/cache/cna_list.json b/data/cache/cna_list.json
new file mode 100644
index 00000000000..2363a00c366
--- /dev/null
+++ b/data/cache/cna_list.json
@@ -0,0 +1,31592 @@
+[
+  {
+    "shortName": "adobe",
+    "cnaID": "CNA-2009-0001",
+    "organizationName": "Adobe Systems Incorporated",
+    "scope": "Adobe issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@adobe.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Adobe security contact page",
+            "url": "https://helpx.adobe.com/security/alertus.html"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://hackerone.com/adobe"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://helpx.adobe.com/security.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "AMD",
+    "cnaID": "CNA-2020-0013",
+    "organizationName": "Advanced Micro Devices Inc.",
+    "scope": "AMD branded products and technologies only. AMD does not evaluate, remediate, or issue CVE IDs for vulnerabilities that only affect End-of-Life/End-of-Support products and technologies.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@amd.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.amd.com/en/resources/product-security.html#vulnerability"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.amd.com/en/resources/product-security.html#security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "airbus",
+    "cnaID": "CNA-2017-0026",
+    "organizationName": "Airbus",
+    "scope": "All Airbus products (supported products and end-of-life/end-of-service products), as well as vulnerabilities in third-party software discovered by Airbus that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vuln@airbus.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.airbus.com/en/airbus-contact-us#:~:text=Vulnerability%20disclosure%20guidelines"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://airbus-seclab.github.io/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Netherlands"
+  },
+  {
+    "shortName": "Alias",
+    "cnaID": "CNA-2020-0004",
+    "organizationName": "Alias Robotics S.L.",
+    "scope": "All Alias Robotics products, as well as vulnerabilities discovered by Alias Robotics that are not within another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@aliasrobotics.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/aliasrobotics/RVD#disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/aliasrobotics/RVD"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "alibaba",
+    "cnaID": "CNA-2017-0024",
+    "organizationName": "Alibaba, Inc.",
+    "scope": "Projects listed on its <a href='https://github.com/alibaba' target='_blank'>Alibaba GitHub website</a> only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "alibaba-cna@list.alibaba-inc.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/alibaba/disclosure/blob/main/README.md"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.alibaba.com/announcement.htm"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "Ampere",
+    "cnaID": "CNA-2020-0006",
+    "organizationName": "Ampere Computing",
+    "scope": "Ampere issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@amperecomputing.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://amperecomputing.com/products/product-security.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://amperecomputing.com/products/product-security.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "google_android",
+    "cnaID": "CNA-2011-0002",
+    "organizationName": "Android (associated with Google Inc. or Open Handset Alliance)",
+    "scope": "Android issues, as well as vulnerabilities in third-party software discovered by Android that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "android-cna-team@google.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://source.android.com/security/overview/updates-resources#report-issues"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://source.android.com/security/bulletin"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "Google",
+        "organizationName": "Google LLC"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "apache",
+    "cnaID": "CNA-2016-0004",
+    "organizationName": "Apache Software Foundation",
+    "scope": "All Apache Software Foundation issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@apache.org"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Apache security contact page",
+            "url": "https://www.apache.org/security/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.apache.org/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.openwall.com/lists/oss-security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "apple",
+    "cnaID": "CNA-2009-0002",
+    "organizationName": "Apple Inc.",
+    "scope": "Apple issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product-security@apple.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Apple security contact page",
+            "url": "https://support.apple.com/en-us/HT201220"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://support.apple.com/en-us/HT201220"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.apple.com/en-us/HT201222"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Arista",
+    "cnaID": "CNA-2021-0008",
+    "organizationName": "Arista Networks, Inc.",
+    "scope": "All Arista products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@arista.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.arista.com/en/support/advisories-notices"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.arista.com/en/support/advisories-notices"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ABB",
+    "cnaID": "CNA-2019-0013",
+    "organizationName": "Asea Brown Boveri Ltd. (ABB)",
+    "scope": "ABB issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cybersecurity@ch.abb.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://library.e.abb.com/public/5961d0d7e2a747728a531a79e3752c31/9ADB005059_ABB_SoftwareVulnerabilityWhitepaper_RevG.pdf?x-sign=y1gE9dzvYeyMAo08CtpfnMmrkal+yQmKEnAZzibtRGINn/cNyboac07SS64tnFN5"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://global.abb/group/en/technology/cyber-security/alerts-and-notifications"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "atlassian",
+    "cnaID": "CNA-2017-0015",
+    "organizationName": "Atlassian",
+    "scope": "All Atlassian products, as well as Atlassian-maintained projects hosted on <a href='https://bitbucket.org/' target='_blank'>https://bitbucket.org/</a> and <a href='https://github.com/atlassian/' target='_blank'>https://github.com/atlassian/</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@atlassian.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://bugcrowd.com/atlassian"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.atlassian.com/trust/security/advisory-publishing-policy"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "autodesk",
+    "cnaID": "CNA-2017-0025",
+    "organizationName": "Autodesk",
+    "scope": "All currently supported <a href='https://knowledge.autodesk.com/support' target='_blank'>Autodesk Applications and Cloud Services</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@autodesk.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.autodesk.com/trust/security/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.autodesk.com/trust/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "avaya",
+    "cnaID": "CNA-2018-0008",
+    "organizationName": "Avaya, Inc.",
+    "scope": "All Avaya Generally Available (GA) products that are not in another CNA\u2019s scope. A CVE ID will not be issued for End of Manufacturing Support (EoMS) products/versions.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "securityalerts@avaya.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://downloads.avaya.com/css/P8/documents/100045520"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.avaya.com/security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Axis",
+    "cnaID": "CNA-2021-0014",
+    "organizationName": "Axis Communications AB",
+    "scope": "All products of Axis Communications AB including end-of-life/end-of-service products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product-security@axis.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://help.axis.com/en-us/axis-vulnerability-management-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.axis.com/support/cybersecurity/vulnerability-management"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Sweden"
+  },
+  {
+    "shortName": "BD",
+    "cnaID": "CNA-2021-0021",
+    "organizationName": "Becton, Dickinson and Company (BD)",
+    "scope": "BD software-enabled medical devices only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "SMB-BD-CNA@bd.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://cybersecurity.bd.com/vulnerability-disclosures"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cybersecurity.bd.com/bulletins-and-patches"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Bitdefender",
+    "cnaID": "CNA-2019-0008",
+    "organizationName": "Bitdefender",
+    "scope": "All Bitdefender products, as well as vulnerabilities in third-party software discovered by Bitdefender that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-requests@bitdefender.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.bitdefender.com/media/materials/bug_bounty/Bitdefender_Bug_Bounty_Terms_and_Conditions.pdf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.bitdefender.com/support/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Romania"
+  },
+  {
+    "shortName": "blackberry",
+    "cnaID": "CNA-2014-0001",
+    "organizationName": "BlackBerry",
+    "scope": "All BlackBerry products identified on <a href='https://www.blackberry.com/us/en' target='_blank'>https://www.blackberry.com/us/en</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@blackberry.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "BlackBerry security contact page",
+            "url": "https://global.blackberry.com/en/secure/report-an-issue/en"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.blackberry.com/us/en/services/blackberry-product-security-incident-response/report-an-issue/blackberry-coordinated-vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.blackberry.com/us/en/services/blackberry-product-security-incident-response"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Canada"
+  },
+  {
+    "shortName": "brocade",
+    "cnaID": "CNA-2016-0006",
+    "organizationName": "Brocade Communications Systems LLC, a Broadcom Company",
+    "scope": "Brocade products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "brocade.sirt@broadcom.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://support.broadcom.com/web/ecx/support-content-notification/-/external/content/SecurityAdvisories/0/21739"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.broadcom.com/support/fibre-channel-networking/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "canonical",
+    "cnaID": "CNA-2005-0001",
+    "organizationName": "Canonical Ltd.",
+    "scope": "All Canonical issues (including Ubuntu Linux) only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@ubuntu.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Ubuntu security contact page",
+            "url": "https://wiki.ubuntu.com/SecurityTeam/FAQ#Contact"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://ubuntu.com/security/disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://usn.ubuntu.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "UK"
+  },
+  {
+    "shortName": "ca",
+    "cnaID": "CNA-2017-0013",
+    "organizationName": "CA Technologies - A Broadcom Company",
+    "scope": "CA Technologies issues only. Note that Broadcom PSIRT handles all CA issues.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "PSIRT@broadcom.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.broadcom.com/support/resources/product-security-center"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Broadcom Enterprise Software Advisories",
+          "url": "https://support.broadcom.com/security-advisory/security-advisories-list.html?segment=ES"
+        },
+        {
+          "label": "Broadcom Mainframe Software Advisories",
+          "url": "https://support.broadcom.com/security-advisory/security-advisories-list.html?segment=MF"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "certcc",
+    "cnaID": "CNA-2005-0002",
+    "organizationName": "CERT/CC",
+    "scope": "Vulnerability assignment related to its vulnerability coordination role.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cert@cert.org"
+          }
+        ],
+        "contact": [
+          {
+            "label": "CERT/CC contact page",
+            "url": "https://kb.cert.org/vuls/report/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://certcc.github.io/CERT-Guide-to-CVD/tutorials/coord_certcc/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.kb.cert.org/vuls/bypublished/desc/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "CERTVDE",
+    "cnaID": "CNA-2020-0010",
+    "organizationName": "CERT@VDE",
+    "scope": "<strong>Root Scope:</strong> Organizations that are cooperative partners of CERT@VDE.<br/><strong>CNA Scope:</strong> Products of CERT@VDE cooperative partners and brands listed at <a href='https://cert.vde.com/en/cna/' target='_blank'>https://cert.vde.com/en/cna/</a>. Also, industrial and infrastructure control systems (and its components) of European Union (EU) based vendors unless covered by the scope of another CNA.  Partners and brands include but are not limited to: ADS-TEC Industrial IT, Auma, sipos, Beckhoff, Bender, Bucher Automation, CLAAS, 365FarmNet, Satinfo, Carlo Gavazzi Controls, Codesys, DURAG GROUP, Draeger, Endress+Hauser, Euchner, Festo Didactic, Festo, Frauscher, GEA, HIMA, Harman, Helmholz, Hilscher, K4 DIGITAL, KEB, Krohne, Kuka, Lenze, BHN Services, MB connect line, Miele, Murrelektronik, PHOENIX CONTACT, Etherwan Systems, Innominate, Pepperl+Fuchs, Pilz, SMA, SWARCO, Trumpf, TRUMPF Laser, TRUMPF Werkzeugmaschinen, VARTA Storage, VEGA, WAGO, M&amp;M Software, Weidmueller, Welotec, Wiesemann &amp; Theis, ifm.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "info@cert.vde.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://cert.vde.com/en/more/certvde/disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cert.vde.com/en-us/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "Root"
+        },
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "checkpoint",
+    "cnaID": "CNA-2016-0008",
+    "organizationName": "Check Point Software Ltd.",
+    "scope": "Check Point Security Gateways product line only, and any vulnerabilities discovered by Check Point that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@checkpoint.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://cpr-zero.checkpoint.com/policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.checkpoint.com/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Israel"
+  },
+  {
+    "shortName": "Chrome",
+    "cnaID": "CNA-2011-0003",
+    "organizationName": "Chrome",
+    "scope": "Chrome issues and projects that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@chromium.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.google.com/about/appsecurity/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://chromereleases.googleblog.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "Google",
+        "organizationName": "Google LLC"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "cisco",
+    "cnaID": "CNA-2007-0001",
+    "organizationName": "Cisco Systems, Inc.",
+    "scope": "All Cisco products, and any third-party research targets that are not in another CNA\u2019s scope. Cisco will not issue a CVE ID for issues reported on products that are past the Last Day of Support milestone, as defined on Cisco\u2019s End-of-Life Policy, which is available at <a href='https://www.cisco.com/c/en/us/products/eos-eol-policy.html' target='_blank'>https://www.cisco.com/c/en/us/products/eos-eol-policy.html</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@cisco.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.cisco.com/c/en/us/about/security-center/security-vulnerability-policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Cisco Advisories",
+          "url": "https://tools.cisco.com/security/center/resources/security_vulnerability_policy.html#sa"
+        },
+        {
+          "label": "Duo Advisories",
+          "url": "https://duo.com/labs/psa/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Hosted Service",
+        "Open Source",
+        "Researcher",
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "cloudflare",
+    "cnaID": "CNA-2018-0003",
+    "organizationName": "Cloudflare, Inc.",
+    "scope": "All Cloudflare products, projects hosted at <a href='https://github.com/cloudflare/' target='_blank'>https://github.com/cloudflare/</a>, and any vulnerabilities discovered by Cloudflare that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@cloudflare.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.cloudflare.com/disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://hackerone.com/cloudflare/hacktivity"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Crafter_CMS",
+    "cnaID": "CNA-2020-0030",
+    "organizationName": "Crafter CMS",
+    "scope": "<a href='https://craftercms.org/' target='_blank'>Crafter CMS</a> issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@craftersoftware.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://docs.craftercms.org/en/4.0/security/security-policies.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.craftercms.org/en/4.0/security/advisory.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "icscert",
+    "cnaID": "CNA-2012-0001",
+    "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)",
+    "scope": "Vulnerabilities that are (1) reported to or observed by CISA, (2) affect industrial control systems or medical devices, and (3) are not covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [],
+        "form": [
+          {
+            "label": "Submit a Report",
+            "url": "https://www.cisa.gov/report"
+          }
+        ]
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.cisa.gov/coordinated-vulnerability-disclosure-process"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "ICS Advisories",
+          "url": "https://cisa.gov/icsa"
+        },
+        {
+          "label": "ICS Medical Advisories",
+          "url": "https://cisa.gov/icsma"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": true,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "Root"
+        },
+        {
+          "helpText": "reports to CISA ICS Root",
+          "role": "CNA-LR"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "CSW",
+    "cnaID": "CNA-2020-0034",
+    "organizationName": "Cyber Security Works Pvt. Ltd.",
+    "scope": "Vulnerabilities in third-party software discovered by CSW that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclose@cybersecurityworks.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://cybersecurityworks.com/vulnerability-disclosure-policy.php"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cybersecurityworks.com/zerodays-vulnerability-list/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "India"
+  },
+  {
+    "shortName": "dahua",
+    "cnaID": "CNA-2017-0014",
+    "organizationName": "Dahua Technologies",
+    "scope": "Dahua consumer Internet of Things (IoT) products, excludes End-of-Life products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cybersecurity@dahuatech.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.dahuasecurity.com/aboutUs/trustedCenter/trustworthy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.dahuasecurity.com/aboutUs/trustedCenter/trustworthy"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "debian",
+    "cnaID": "CNA-2005-0003",
+    "organizationName": "Debian GNU/Linux",
+    "scope": "Debian issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@debian.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.debian.org/security/disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.debian.org/security/#DSAS"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "dell",
+    "cnaID": "CNA-2011-0004",
+    "organizationName": "Dell",
+    "scope": "Dell, Dell EMC, and VCE issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@dell.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.dell.com/support/contents/us/en/04/article/product-support/self-support-knowledgebase/security-antivirus/alerts-vulnerabilities/dell-vulnerability-response-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.dell.com/support/security/en-us"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "DEVOLUTIONS",
+    "cnaID": "CNA-2021-0031",
+    "organizationName": "Devolutions Inc.",
+    "scope": "All Devolutions products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@devolutions.net"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://devolutions.net/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://devolutions.net/security/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Canada"
+  },
+  {
+    "shortName": "Document_Fdn.",
+    "cnaID": "CNA-2019-0002",
+    "organizationName": "Document Foundation, The",
+    "scope": "Projects within The Document Foundation only, e.g., LibreOffice, LibreOffice Online; The Document Foundation discourages reporting denial of service bugs as security issues.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@documentfoundation.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.libreoffice.org/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.libreoffice.org/security-info/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "drupal",
+    "cnaID": "CNA-2017-0002",
+    "organizationName": "Drupal.org",
+    "scope": "All projects hosted under <a href='https://www.drupal.org' target='_blank'>drupal.org</a>, including End of Life (EOL) code.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@drupal.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.drupal.org/drupal-security-team/security-advisory-process-and-permissions-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.drupal.org/security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Eaton",
+    "cnaID": "CNA-2019-0014",
+    "organizationName": "Eaton",
+    "scope": "Eaton issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@eaton.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.eaton.com/us/en-us/company/news-insights/cybersecurity/vulnerabilitydisclosure.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.eaton.com/us/en-us/company/news-insights/cybersecurity/security-notifications.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Ireland"
+  },
+  {
+    "shortName": "eclipse",
+    "cnaID": "CNA-2017-0008",
+    "organizationName": "Eclipse Foundation",
+    "scope": "All projects hosted by the Eclipse Foundation as listed at <a href='https://www.eclipse.org/projects/' target='_blank'>https://www.eclipse.org/projects/</a> and services provided by the Eclipse Foundation to support open source projects as listed at <a href='https://www.eclipsestatus.io/' target='_blank'>https://www.eclipsestatus.io/</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@eclipse.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.eclipse.org/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.eclipse.org/security/known.php"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Belgium"
+  },
+  {
+    "shortName": "elastic",
+    "cnaID": "CNA-2017-0011",
+    "organizationName": "Elastic",
+    "scope": "Elasticsearch, Kibana, Beats, Logstash, X-Pack, and Elastic Cloud Enterprise products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@elastic.co"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.elastic.co/community/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.elastic.co/community/security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Netherlands"
+  },
+  {
+    "shortName": "EA",
+    "cnaID": "CNA-2020-0027",
+    "organizationName": "Electronic Arts, Inc.",
+    "scope": "EA issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@ea.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.ea.com/security/disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.ea.com/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Esri",
+    "cnaID": "CNA-2021-0011",
+    "organizationName": "Environmental Systems Research Institute, Inc.",
+    "scope": "All Esri products only, including ArcGIS.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@esri.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://trust.arcgis.com/en/security-concern/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Trust Center",
+          "url": "https://trust.arcgis.com/en/"
+        },
+        {
+          "label": "Security Advisories",
+          "url": "https://www.esri.com/arcgis-blog/tag/cve"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ESET",
+    "cnaID": "CNA-2021-0029",
+    "organizationName": "ESET, spol. s r.o.",
+    "scope": "All ESET products only and vulnerabilities discovered by ESET that are not covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email ESET PSIRT",
+            "emailAddr": "security@eset.com"
+          },
+          {
+            "label": "Email ESET Research",
+            "emailAddr": "vulnerability.disclosures@eset.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Inbound Reports Policy",
+        "language": "",
+        "url": "https://www.eset.com/int/security-vulnerability-reporting/"
+      },
+      {
+        "label": "Outbound Reports Policy",
+        "language": "",
+        "url": "https://www.eset.com/int/research/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "ESET PSIRT Advisories",
+          "url": "https://support-feed.eset.com/advisories/"
+        },
+        {
+          "label": "ESET Research Advisories",
+          "url": "https://github.com/eset/vulnerability-disclosures"
+        },
+        {
+          "label": "WeLiveSecurity Advisories",
+          "url": "https://welivesecurity.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Slovak Republic"
+  },
+  {
+    "shortName": "F5",
+    "cnaID": "CNA-2016-0009",
+    "organizationName": "F5, Inc.",
+    "scope": "All F5 products and services, commercial and open source, which have not yet reached End of Technical Support (EoTS). All legacy acquisition products and brands including, but not limited to, NGINX, Shape Security, Volterra, and Threat Stack. F5 does not issue CVEs for products which are no longer supported.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "f5sirt@f5.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://support.f5.com/csp/article/K4602"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://my.f5.com/manage/s/new-updated-articles#sort=%40f5_updated_published_date%20descending&amp;f:@f5_document_type=[Security%20Advisory]&amp;periodFilter=4&amp;dateField=0"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Meta",
+    "cnaID": "CNA-2018-0001",
+    "organizationName": "Meta Platforms, Inc.",
+    "scope": "Meta-supported open source projects, mobile apps, and other software, as well as vulnerabilities in third-party software discovered by Meta that are not in another CNA\u2019s scope; see: <a href='https://www.facebook.com/whitehat' target='_blank'>https://www.facebook.com/whitehat</a> and <a href='https://github.com/facebook/' target='_blank'>https://github.com/facebook/</a>.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Meta security contact page",
+            "url": "https://www.facebook.com/whitehat"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.facebook.com/security/advisories/Vulnerability-Disclosure-Policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.facebook.com/security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "fedora",
+    "cnaID": "CNA-2017-0021",
+    "organizationName": "Fedora Project",
+    "scope": "Vulnerabilities in open source projects affecting the Fedora Project, that are not covered by a more specific CNA. CVEs can be assigned to vulnerabilities affecting end-of-life or unsupported releases by the Fedora Project.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Fedora Bug Report page",
+            "url": "https://fedoraproject.org/wiki/Bugs_and_feature_requests"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://fedoraproject.org/wiki/Security_Bugs#Reporting_a_Security_Vulnerability"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://bodhi.fedoraproject.org/updates/?type=security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Fidelis",
+    "cnaID": "CNA-2021-0026",
+    "organizationName": "Fidelis Security, LLC",
+    "scope": "Fidelis issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@fidelissecurity.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://fidelissecurity.com/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.fidelissecurity.com/hc/en-us/categories/360001842694-Advisories-News-and-Policies"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "flexera",
+    "cnaID": "CNA-2017-0004",
+    "organizationName": "Flexera Software LLC",
+    "scope": "All Flexera, Revenera, and Snow Software products, and vulnerabilities discovered by Secunia Research that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-info.flexera.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.flexera.com/products/operations/software-vulnerability-research/secunia-research/disclosure-policy.html?_ga=2.126100429.1927534686.1582843801-707336045.1578583910"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security-info.flexera.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "floragunn",
+    "cnaID": "CNA-2019-0005",
+    "organizationName": "floragunn GmbH",
+    "scope": "All issues related to Search Guard only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@search-guard.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://search-guard.com/disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://search-guard.com/cve-advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Fluid_Attacks",
+    "cnaID": "CNA-2021-0020",
+    "organizationName": "Fluid Attacks",
+    "scope": "Vulnerabilities in third-party software discovered by or reported to Fluid Attacks that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "help@fluidattacks.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://fluidattacks.com/advisories/policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://fluidattacks.com/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Colombia"
+  },
+  {
+    "shortName": "forcepoint",
+    "cnaID": "CNA-2017-0033",
+    "organizationName": "Forcepoint",
+    "scope": "Forcepoint products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@forcepoint.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Forcepoint security contact page",
+            "url": "https://www.forcepoint.com/product-security-report-issue"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.forcepoint.com/company/innovation/product-security-report-issue"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.forcepoint.com/s/knowledge-base#t=All&sort=relevancy&f:@sfrecordtypename=[Security%20Advisory]"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "fortinet",
+    "cnaID": "CNA-2016-0010",
+    "organizationName": "Fortinet, Inc.",
+    "scope": "Fortinet issues only.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [],
+        "form": [
+          {
+            "label": "PSIRT contact form",
+            "url": "https://www.fortiguard.com/faq/psirt-contact"
+          }
+        ]
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.fortiguard.com/psirt_policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.fortiguard.com/psirt"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "FSOFT",
+    "cnaID": "CNA-2021-0032",
+    "organizationName": "FPT Software Co., Ltd.",
+    "scope": "All products and services developed and operated by FPT Software, as well as vulnerabilities in third-party software discovered by FPT Software that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security_report@fpt.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://fptsoftware.com/vulnerability-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://fptsoftware.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Vietnam"
+  },
+  {
+    "shortName": "freebsd",
+    "cnaID": "CNA-2005-0004",
+    "organizationName": "FreeBSD",
+    "scope": "Primarily FreeBSD issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secteam@freebsd.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.freebsd.org/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.freebsd.org/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Gallagher",
+    "cnaID": "CNA-2020-0024",
+    "organizationName": "Gallagher Group Ltd.",
+    "scope": "All Gallagher security products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclosures@gallagher.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security.gallagher.com/responsible-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.gallagher.com/Security-Advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "New Zealand"
+  },
+  {
+    "shortName": "GitHub_M",
+    "cnaID": "CNA-2019-0009",
+    "organizationName": "GitHub, Inc.",
+    "scope": "CVEs requested by code owners using the GitHub Security Advisories feature and vulnerabilities affecting open source projects discovered by security researchers at GitHub or Microsoft not covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-advisories@github.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://help.github.com/en/articles/about-maintainer-security-advisories"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "GitHub_P",
+    "cnaID": "CNA-2020-0007",
+    "organizationName": "GitHub, Inc. (Products Only)",
+    "scope": "GitHub Enterprise Server issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product-cna@github.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://bounty.github.com/#rules"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://enterprise.github.com/releases"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "GitLab",
+    "cnaID": "CNA-2020-0018",
+    "organizationName": "GitLab Inc.",
+    "scope": "The GitLab application, any project hosted on GitLab.com in a public repository, and any vulnerabilities discovered by GitLab that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@gitlab.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://about.gitlab.com/security/disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://gitlab.com/gitlab-org/cves"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Google",
+    "cnaID": "CNA-2020-0005",
+    "organizationName": "Google LLC",
+    "scope": "<strong>Root Scope:</strong> Alphabet organizations.<br/><strong>CNA Scope:</strong> Google products, including open source software published and maintained by Google, and vulnerabilities in third-party software discovered by Google that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "alphabet-cna@google.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.google.ch/about/appsecurity/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Cloud Advisories",
+          "url": "https://cloud.google.com/support/bulletins"
+        },
+        {
+          "label": "Advisories",
+          "url": "https://github.com/google/security-research"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "role": [
+        "Root",
+        "CNA"
+      ],
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "Root"
+        },
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "hackerone",
+    "cnaID": "CNA-2016-0011",
+    "organizationName": "HackerOne",
+    "scope": "Provides CVE IDs for its customers as part of its bug bounty and vulnerability coordination platform.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "HackerOne Support Portal",
+            "url": "https://support.hackerone.com/support/home"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hackerone.com/disclosure-guidelines"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://hackerone.com/hacktivity?querystring=&filter=type:hacker-published&order_direction=DESC&order_field=popular"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Bug Bounty Provider"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "hikvision",
+    "cnaID": "CNA-2018-0002",
+    "organizationName": "Hangzhou Hikvision Digital Technology Co., Ltd.",
+    "scope": "All <a href='http://www.hikvision.com/en/' target='_blank'>Hikvision Internet of Things (IoT) products</a> including cameras and digital video recorders (DVRs).",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "hsrc@hikvision.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hikvision.com/en/policies/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://us.hikvision.com/en/support-resources/cybersecurity-center/security-notices"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "HCL",
+    "cnaID": "CNA-2019-0010",
+    "organizationName": "HCL Software",
+    "scope": "All HCL products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@hcl-software.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hcl-software.com/resources/psirt"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.hcl-software.com/community?id=community_forum&amp;sys_id=038a2b921b7bb34c77761fc58d4bcb0d"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "India"
+  },
+  {
+    "shortName": "hpe",
+    "cnaID": "CNA-2016-0003",
+    "organizationName": "Hewlett Packard Enterprise (HPE)",
+    "scope": "HPE and acquisitions issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-alert@hpe.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://support.hpe.com/hpesc/public/docDisplay?docLocale=en_US&docId=a00100637en_us"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.hpe.com/portal/site/hpsc/public/kb/secBullArchive/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Hitachi_Energy",
+    "cnaID": "CNA-2021-0028",
+    "organizationName": "Hitachi Energy",
+    "scope": "Hitachi Energy products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cybersecurity@hitachienergy.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://publisher.hitachienergy.com/preview?DocumentID=9AKK107991A7713&LanguageCode=en&DocumentPartId=&Action=Launch"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.hitachienergy.com/cybersecurity/alerts-and-notifications"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "hp",
+    "cnaID": "CNA-2009-0003",
+    "organizationName": "HP Inc.",
+    "scope": "Issues with any HP-branded product, including computing software and hardware, imaging and printing, as well as HyperX, Teradici, Poly, and Plantronics branded devices.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "hp-security-alert@hp.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://support.hp.com/us-en/document/ish_12775610-12775642-16"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.hp.com/us-en/security-bulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "huawei",
+    "cnaID": "CNA-2016-0012",
+    "organizationName": "Huawei Technologies",
+    "scope": "Huawei issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@huawei.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Huawei security contact page",
+            "url": "https://www.huawei.com/psirt"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.huawei.com/en/psirt/vul-response-process"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.huawei.com/en/psirt/all-bulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "@huntr_ai",
+    "cnaID": "CNA-2021-0018",
+    "organizationName": "Protect AI (formerly huntr.dev)",
+    "scope": "Vulnerabilities in Protect AI products, third-party code vulnerabilities reported by researchers collaborating with huntr and vulnerabilities discovered by, or reported to, Protect AI that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@huntr.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://huntr.com/guidelines/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://huntr.com/bounties/hacktivity"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Bug Bounty Provider",
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ibm",
+    "cnaID": "CNA-2011-0007",
+    "organizationName": "IBM Corporation",
+    "scope": "All IBM branded products (IBM will confirm support status and notify researcher).",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@us.ibm.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.ibm.com/security/secure-engineering/report.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.ibm.com/support/pages/bulletin/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "intel",
+    "cnaID": "CNA-2016-0005",
+    "organizationName": "Intel Corporation",
+    "scope": "Intel branded products and technologies and Intel managed open source projects.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@intel.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Intel security contact page",
+            "url": "https://security-center.intel.com/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.intel.com/content/www/us/en/security-center/vulnerability-handling-guidelines.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.intel.com/content/www/us/en/security-center/default.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "isc",
+    "cnaID": "CNA-2016-0020",
+    "organizationName": "Internet Systems Consortium (ISC)",
+    "scope": "All <a href='https://www.isc.org/' target='_blank'>ISC.org</a> projects.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-officer@isc.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://kb.isc.org/docs/aa-00861"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://kb.isc.org/docs/aa-01020"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "INCD",
+    "cnaID": "CNA-2021-0030",
+    "organizationName": "Israel National Cyber Directorate (INCD)",
+    "scope": "Vulnerability assignment related to its vulnerability coordination role.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@cyber.gov.il"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.gov.il/en/departments/general/cve_policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.gov.il/en/departments/faq/cve_advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Israel"
+  },
+  {
+    "shortName": "jenkins",
+    "cnaID": "CNA-2018-0015",
+    "organizationName": "Jenkins Project",
+    "scope": "Jenkins and Jenkins plugins distributed by the Jenkins Project (listed on <a href='https://plugins.jenkins.io/' target='_blank'>plugins.jenkins.io</a>) only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "jenkinsci-cert@googlegroups.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://jenkins.io/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://jenkins.io/security/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "jci",
+    "cnaID": "CNA-2019-0001",
+    "organizationName": "Johnson Controls",
+    "scope": "Johnson Controls products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productsecurity@jci.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.johnsoncontrols.com/trust-center/cybersecurity/response#CoordinatedDisclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.johnsoncontrols.com/trust-center/cybersecurity/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Joomla",
+    "cnaID": "CNA-2020-0036",
+    "organizationName": "Joomla! Project",
+    "scope": "Core Joomla! CMS, the Joomla Framework, and Joomla! Extensions issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@joomla.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://developer.joomla.org/security.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://developer.joomla.org/security-centre.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "jpcert",
+    "cnaID": "CNA-2010-0001",
+    "organizationName": "JPCERT/CC",
+    "scope": "<strong>Root Scope:</strong> Japan organizations.<br/><strong>CNA Scope:</strong> Vulnerability assignment related to its vulnerability coordination role.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vuls@jpcert.or.jp"
+          }
+        ],
+        "contact": [
+          {
+            "label": "JPCERT/CC contact page",
+            "url": "https://www.jpcert.or.jp/vh/index.html"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.jpcert.or.jp/english/vh/2018/20180330-vulpolicy.pdf#search='disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://jvn.jp/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "Root"
+        },
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "juniper",
+    "cnaID": "CNA-2016-0001",
+    "organizationName": "Juniper Networks, Inc.",
+    "scope": "Juniper issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "sirt@juniper.net"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Juniper security contact page",
+            "url": "https://www.juniper.net/us/en/security/report-vulnerability/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.juniper.net/us/en/security/report-vulnerability/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://kb.juniper.net/InfoCenter/index?page=content&channel=SECURITY_ADVISORIES"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Kaspersky",
+    "cnaID": "CNA-2017-0027",
+    "organizationName": "Kaspersky",
+    "scope": "Kaspersky B2C and B2B products, as well as vulnerabilities discovered in third-party software not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@kaspersky.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://support.kaspersky.com/general/vulnerability.aspx?el=12429#block0"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.kaspersky.com/general/vulnerability.aspx?el=12430"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Russia"
+  },
+  {
+    "shortName": "krcert",
+    "cnaID": "CNA-2016-0021",
+    "organizationName": "KrCERT/CC",
+    "scope": "Vulnerability assignment related to its vulnerability coordination role.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vuln_notice@krcert.or.kr"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://knvd.krcert.or.kr/processingProcedures.do"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.krcert.or.kr/kr/bbs/list.do?menuNo=205023&bbsId=B0000302"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "South Korea"
+  },
+  {
+    "shortName": "kubernetes",
+    "cnaID": "CNA-2017-0022",
+    "organizationName": "Kubernetes",
+    "scope": "Kubernetes issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@kubernetes.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://kubernetes.io/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://kubernetes.io/cve"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "larry_cashdollar",
+    "cnaID": "CNA-2016-0007",
+    "organizationName": "Larry Cashdollar",
+    "scope": "Third-party products he researches that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "larry0@me.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "http://www.vapidlabs.com/misc/policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "http://www.vapidlabs.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "lenovo",
+    "cnaID": "CNA-2016-0013",
+    "organizationName": "Lenovo Group Ltd.",
+    "scope": "Lenovo general-purpose computers, software for general-purpose operating systems, mobile devices, enterprise storage, and networking products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@lenovo.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.lenovo.com/us/en/product-security/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.lenovo.com/us/en/product_security/home"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "LY-Corporation",
+    "cnaID": "CNA-2020-0038",
+    "organizationName": "LY Corporation",
+    "scope": "Current versions of LINE Messenger Application for iOS, Android, Mac, and Windows, plus LINE Open Source projects hosted on <a href='https://github.com/line' target='_blank'>https://github.com/line</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "ml-sec-cna@lycorp.co.jp"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://line.github.io/security-advisory-blog/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://line.github.io/security-advisory-blog/advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "jpcert",
+        "organizationName": "JPCERT/CC"
+      },
+      "type": [
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "Logitech",
+    "cnaID": "CNA-2020-0032",
+    "organizationName": "Logitech",
+    "scope": "All current products/software/apps made by <a href='https://www.logitech.com/' target='_blank'>Logitech</a>, <a href='https://www.ultimateears.com/' target='_blank'>Ultimate Ears</a>, <a href='https://www.jaybirdsport.com/' target='_blank'>Jaybird</a>, <a href='https://www.streamlabs.com/' target='_blank'>Streamlabs</a>, <a href='https://www.logitechg.com/' target='_blank'>Logitech G</a>, <a href='https://www.logicool.co.jp/' target='_blank'>Logicool</a>, <a href='https://www.bluedesigns.com/' target='_blank'>Blue</a>, and <a href='https://www.astrogaming.com/' target='_blank'>Astro Gaming</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@logitech.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://hackerone.com/logitech"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://hackerone.com/logitech/hacktivity"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "Mattermost",
+    "cnaID": "CNA-2020-0028",
+    "organizationName": "Mattermost, Inc.",
+    "scope": "All Mattermost issues, and vulnerabilities discovered by Mattermost that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "responsibledisclosure@mattermost.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://mattermost.com/security-vulnerability-report/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://mattermost.com/security-updates/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Mautic",
+    "cnaID": "CNA-2021-0005",
+    "organizationName": "Mautic",
+    "scope": "Mautic core and officially supported plugins.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Mautic Security Team",
+            "url": "https://www.mautic.org/mautic-security-team"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.mautic.org/mautic-security-team/mautic-security-advisory-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/mautic/mautic/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Trellix",
+    "cnaID": "CNA-2016-0022",
+    "organizationName": "Trellix",
+    "scope": "All Trellix Enterprise (formerly McAfee Enterprise and FireEye) products, as well as vulnerabilities in third-party software discovered by Trellix Advanced Research Center (Trellix ACR) that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "trellixpsirt@trellix.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Report an issue",
+            "url": "https://hackerone.com/trellix"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://kcm.trellix.com/corporate/index?page=content&id=KB95564"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://supportm.trellix.com/webcenter/portal/supportportal/pages_knowledgecenter"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "OpenText",
+    "cnaID": "CNA-2014-0002",
+    "organizationName": "OpenText (formerly Micro Focus)",
+    "scope": "All OpenText products (including Carbonite, Zix, Micro Focus, others).",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@opentext.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.opentext.com/about/security-acknowledgements"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://knowledge.opentext.com/knowledge/llisapi.dll/open/alerts"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "microsoft",
+    "cnaID": "CNA-2005-0005",
+    "organizationName": "Microsoft Corporation",
+    "scope": "Microsoft issues only, excluding end-of-life (EOL) as listed in the <a href='https://learn.microsoft.com/en-US/lifecycle/' target='_blank'>Microsoft Lifecycle Policy</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@microsoft.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Microsoft security contact page",
+            "url": "https://technet.microsoft.com/en-us/security/ff852094.aspx"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.microsoft.com/en-us/msrc/cvd?rtc=1"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.microsoft.com/en-us/msrc/technical-security-notifications"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "mitre",
+    "cnaID": "CNA-1999-0001",
+    "organizationName": "MITRE Corporation",
+    "scope": "All vulnerabilities, and Open Source software product vulnerabilities, not already covered by a CNA listed on this website.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [],
+        "form": [
+          {
+            "label": "MITRE CVE Request web form",
+            "url": "https://cveform.mitre.org/"
+          }
+        ]
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "N/A",
+        "language": "",
+        "url": ""
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "N/A",
+          "url": ""
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": true,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "N/A"
+      ],
+      "TLR": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "reports to CVE Board",
+          "role": "Top-Level Root"
+        },
+        {
+          "helpText": "reports to MITRE TL-Root",
+          "role": "CNA-LR"
+        },
+        {
+          "helpText": "reports to CVE Board",
+          "role": "Secretariat"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Mitsubishi",
+    "cnaID": "CNA-2020-0039",
+    "organizationName": "Mitsubishi Electric Corporation",
+    "scope": "Vulnerabilities related to products of Mitsubishi Electric Group.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "Mitsubishielectric.Psirt@yd.MitsubishiElectric.co.jp"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.mitsubishielectric.com/psirt/disclosurepolicy/index.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.mitsubishielectric.com/psirt/vulnerability/index.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "jpcert",
+        "organizationName": "JPCERT/CC"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "mongodb",
+    "cnaID": "CNA-2018-0013",
+    "organizationName": "MongoDB, Inc.",
+    "scope": "MongoDB products only, not including end-of-life components or products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@mongodb.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.mongodb.com/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.mongodb.com/resources/products/mongodb-security-bulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "mozilla",
+    "cnaID": "CNA-2012-0002",
+    "organizationName": "Mozilla Corporation",
+    "scope": "Mozilla issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@mozilla.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.mozilla.org/en-US/about/governance/policies/security-group/bugs/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.mozilla.org/en-US/security/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "naver",
+    "cnaID": "CNA-2018-0007",
+    "organizationName": "Naver Corporation",
+    "scope": "Naver products only, except Line products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@navercorp.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://cve.naver.com/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cve.naver.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "South Korea"
+  },
+  {
+    "shortName": "NEC",
+    "cnaID": "CNA-2021-0012",
+    "organizationName": "NEC Corporation",
+    "scope": "NEC issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt-info@mlsig.jp.nec.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://jpn.nec.com/security-info/policy_en.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://jpn.nec.com/security-info/index.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "jpcert",
+        "organizationName": "JPCERT/CC"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "netapp",
+    "cnaID": "CNA-2017-0035",
+    "organizationName": "NetApp, Inc.",
+    "scope": "All NetApp products as well as projects hosted on <a href='https://github.com/netapp' target='_blank'>https://github.com/netapp</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-alert@netapp.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "NetApp security contact page",
+            "url": "https://security.netapp.com/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security.netapp.com/policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.netapp.com/advisory/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "netflix",
+    "cnaID": "CNA-2017-0016",
+    "organizationName": "Netflix, Inc.",
+    "scope": "Current versions of Netflix Mobile Streaming Application for iOS, Android, and Windows Mobile, plus all Netflix Open Source projects hosted on <a href='https://github.com/Netflix/' target='_blank'>https://github.com/Netflix/</a> and <a href='https://github.com/spinnaker/' target='_blank'>https://github.com/spinnaker/</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-report@netflix.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://help.netflix.com/en/node/6657"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/Netflix/security-bulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Absolute",
+    "cnaID": "CNA-2021-0033",
+    "organizationName": "Absolute Software",
+    "scope": "Absolute issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "securityresponse@absolute.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.absolute.com/platform/security-information/vulnerability-reporting-management"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.absolute.com/platform/security-information/vulnerability-archive/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "NLnet_Labs",
+    "cnaID": "CNA-2020-0033",
+    "organizationName": "NLnet Labs",
+    "scope": "All NLnet Labs projects.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "sep@nlnetlabs.nl"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://nlnetlabs.nl/security-report/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "RPKI Advisories",
+          "url": "https://nlnetlabs.nl/projects/rpki/security-advisories/"
+        },
+        {
+          "label": "NSD Advisories",
+          "url": "https://nlnetlabs.nl/projects/nsd/security-advisories/"
+        },
+        {
+          "label": "Unbound Advisories",
+          "url": "https://nlnetlabs.nl/projects/unbound/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Netherlands"
+  },
+  {
+    "shortName": "nodejs",
+    "cnaID": "CNA-2017-0036",
+    "organizationName": "Node.js",
+    "scope": "All actively developed versions of software developed under the Node.js project on <a href='https://github.com/nodejs/' target='_blank'>https://github.com/nodejs/</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-request@iojs.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://nodejs.org/en/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/nodejs/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "GEN",
+    "cnaID": "CNA-2020-0016",
+    "organizationName": "Gen Digital Inc.",
+    "scope": "All Gen Digital products and websites.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@gendigital.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.gendigital.com/us/en/contact-us/report-a-potential-security-vulnerability/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.gendigital.com/us/en/contact-us/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Nozomi",
+    "cnaID": "CNA-2020-0029",
+    "organizationName": "Nozomi Networks Inc.",
+    "scope": "All Nozomi Networks products, as well as vulnerabilities in third-party software discovered by Nozomi Networks that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "prodsec@nozominetworks.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security.nozominetworks.com/psirt"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.nozominetworks.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "nvidia",
+    "cnaID": "CNA-2016-0015",
+    "organizationName": "NVIDIA Corporation",
+    "scope": "NVIDIA issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@nvidia.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "NVIDIA security contact page",
+            "url": "https://www.nvidia.com/en-us/security/report-vulnerability/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.nvidia.com/en-us/security/psirt-policies/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.nvidia.com/en-us/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "obdev",
+    "cnaID": "CNA-2016-0016",
+    "organizationName": "Objective Development Software GmbH",
+    "scope": "Objective Development issues only.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Objective Development security page",
+            "url": "https://obdev.at/go/cna"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://obdev.at/cve/vulnerability-disclosure-policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://obdev.at/cve/published-vulnerabilities.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Austria"
+  },
+  {
+    "shortName": "Octopus",
+    "cnaID": "CNA-2021-0017",
+    "organizationName": "Octopus Deploy",
+    "scope": "All Octopus Deploy products, as well as Octopus Deploy maintained projects hosted on <a href='https://github.com/OctopusDeploy' target='_blank'>https://github.com/OctopusDeploy</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@octopus.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://octopus.com/security/disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://advisories.octopus.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "odoo",
+    "cnaID": "CNA-2018-0009",
+    "organizationName": "Odoo",
+    "scope": "Odoo issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@odoo.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.odoo.com/security-report"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.odoo.com/r/security-issues"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Belgium"
+  },
+  {
+    "shortName": "openEuler",
+    "cnaID": "CNA-2020-0020",
+    "organizationName": "openEuler",
+    "scope": "openEuler issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "openeuler-security@openeuler.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://openeuler.org/en/security/vulnerability-reporting/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.openeuler.org/zh/security/security-bulletins/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "openssl",
+    "cnaID": "CNA-2016-0019",
+    "organizationName": "OpenSSL Software Foundation",
+    "scope": "OpenSSL software projects only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "openssl-security@openssl.org"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Reporting Security Bugs",
+            "url": "https://www.openssl.org/community/#securityreports"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.openssl.org/policies/secpolicy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.openssl.org/news/vulnerabilities.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "OpenVPN",
+    "cnaID": "CNA-2020-0017",
+    "organizationName": "OpenVPN Inc.",
+    "scope": "All products and projects in which OpenVPN is directly involved commercially and for OpenVPN community projects, including Private Tunnel.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@openvpn.net"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://openvpn.net/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Business VPN Advisories",
+          "url": "https://openvpn.net/security-advisories/"
+        },
+        {
+          "label": "Community Advisories",
+          "url": "https://community.openvpn.net/openvpn/wiki/SecurityAnnouncements"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Opera",
+    "cnaID": "CNA-2019-0017",
+    "organizationName": "Opera Norway AS",
+    "scope": "All Opera group products.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Opera security contact page",
+            "url": "https://security.opera.com/en/report-security-issue/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security.opera.com/en/policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.opera.com/en/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Norway"
+  },
+  {
+    "shortName": "OPPO",
+    "cnaID": "CNA-2019-0006",
+    "organizationName": "OPPO Mobile Telecommunication Corp., Ltd.",
+    "scope": "OPPO devices only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@oppo.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security.oppo.com/en/responsibleDisclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.oppo.com/en/notice"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "oracle",
+    "cnaID": "CNA-2008-0001",
+    "organizationName": "Oracle",
+    "scope": "Oracle supported version product issues only; CVE IDs will not be assigned for unsupported products or versions (Oracle will confirm support status and notify researcher).",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secalert_us@oracle.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Oracle security contact page",
+            "url": "https://www.oracle.com/support/assurance/vulnerability-remediation/reporting-security-vulnerabilities.html"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.oracle.com/corporate/security-practices/assurance/vulnerability/disclosure.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.oracle.com/security-alerts/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Hosted Service",
+        "Open Source",
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "OTRS",
+    "cnaID": "CNA-2019-0015",
+    "organizationName": "OTRS AG",
+    "scope": "Vulnerabilities for OTRS and ((OTRS)) Community Edition and modules only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@otrs.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://otrs.com/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://otrs.com/overview-release-notes-security-advisories/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "palo_alto",
+    "cnaID": "CNA-2018-0005",
+    "organizationName": "Palo Alto Networks, Inc.",
+    "scope": "All Palo Alto Networks products, and vulnerabilities discovered by Palo Alto Networks that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@paloaltonetworks.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.paloaltonetworks.com/security-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://securityadvisories.paloaltonetworks.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Patchstack",
+    "cnaID": "CNA-2021-0025",
+    "organizationName": "Patchstack",
+    "scope": "Vulnerabilities in third-party products discovered by Patchstack and Patchstack Bug Bounty program unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "audit@patchstack.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://patchstack.com/patchstack-vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Database",
+          "url": "https://patchstack.com/database/"
+        },
+        {
+          "label": "Advisories",
+          "url": "https://patchstack.com/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Bug Bounty Provider",
+        "Hosted Service",
+        "Open Source",
+        "Researcher",
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Estonia"
+  },
+  {
+    "shortName": "Pega",
+    "cnaID": "CNA-2020-0012",
+    "organizationName": "Pegasystems Inc.",
+    "scope": "Pegasystems products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "securityreport@pega.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.pega.com/responsible-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.pega.com/trust/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "php",
+    "cnaID": "CNA-2018-0014",
+    "organizationName": "PHP Group",
+    "scope": "Vulnerabilities in PHP code (code in <a href='https://github.com/php/php-src' target='_blank'>https://github.com/php/php-src</a>) only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@php.net"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://wiki.php.net/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.php.net/ChangeLog-8.php"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Perforce",
+    "cnaID": "CNA-2016-0023",
+    "organizationName": "Perforce",
+    "scope": "All Perforce products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@perforce.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.perforce.com/company/security-compliance-policies"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://portal.perforce.com/s/cve-dashboard"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "qnap",
+    "cnaID": "CNA-2017-0030",
+    "organizationName": "QNAP Systems, Inc.",
+    "scope": "QNAP issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@qnap.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.qnap.com/en-us/security-advisory/report"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.qnap.com/en/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "qualcomm",
+    "cnaID": "CNA-2017-0007",
+    "organizationName": "Qualcomm, Inc.",
+    "scope": "Qualcomm and Snapdragon issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product-security@qualcomm.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.qualcomm.com/news/onq/2019/01/16/inside-qualcomm-technologies-vulnerability-rewards-program"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.qualcomm.com/company/product-security/bulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "rapid7",
+    "cnaID": "CNA-2016-0024",
+    "organizationName": "Rapid7, Inc.",
+    "scope": "All Rapid7 products, and vulnerabilities discovered by Rapid7 that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@rapid7.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.rapid7.com/security/disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.rapid7.com/db/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "redhat",
+    "cnaID": "CNA-2005-0006",
+    "organizationName": "Red Hat, Inc.",
+    "scope": "<strong>Root Scope:</strong> The Red Hat Root\u2019s scope includes the open source community. Any open source organizations that prefer Red Hat as their Root; organizations are free to choose another Root if it suits them better.<br/><strong>CNA-LR Scope:</strong> Vulnerabilities in software developed by a CNA within the Red Hat Root hierarchy.<br/><strong>CNA Scope:</strong> Vulnerabilities in open source projects affecting Red Hat software that are not covered by a more specific CNA. CVEs can be assigned to vulnerabilities affecting end-of-life or unsupported Red Hat software.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Root contact email",
+            "emailAddr": "RootCNA-Coordination@redhat.com"
+          },
+          {
+            "label": "CNA-LR contact email",
+            "emailAddr": "cnalr-coordination@redhat.com"
+          },
+          {
+            "label": "CNA contact email",
+            "emailAddr": "secalert@redhat.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Red Hat security contact page",
+            "url": "https://access.redhat.com/security/team/contact"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://access.redhat.com/articles/red_hat_cna_vulnerability_disclosure_policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://access.redhat.com/security/security-updates/#/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "reports to MITRE Top-Level Root",
+          "role": "Root"
+        },
+        {
+          "helpText": "reports to Red Hat Root",
+          "role": "CNA-LR"
+        },
+        {
+          "helpText": "reports to Red Hat Root",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Replicated",
+    "cnaID": "CNA-2020-0023",
+    "organizationName": "Replicated, Inc.",
+    "scope": "Replicated products and services only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@replicated.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.replicated.com/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.replicated.com/security/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "bosch",
+    "cnaID": "CNA-2019-0004",
+    "organizationName": "Robert Bosch GmbH",
+    "scope": "Bosch products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@bosch.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://psirt.bosch.com/bosch-responsible-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://psirt.bosch.com/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Salesforce",
+    "cnaID": "CNA-2019-0007",
+    "organizationName": "Salesforce, Inc.",
+    "scope": "<a href='https://trust.salesforce.com/en/trust-and-compliance-documentation/' target='_blank'>Salesforce products</a> only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@salesforce.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://trust.salesforce.com/en/security/responsible-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://trust.salesforce.com/en/security/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Samsung_Mobile",
+    "cnaID": "CNA-2021-0001",
+    "organizationName": "Samsung Mobile",
+    "scope": "Samsung Mobile Galaxy products, personal computers, and related services only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "mobile.security@samsung.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security.samsungmobile.com/securityReporting.smsb"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.samsungmobile.com/workScope.smsb"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "South Korea"
+  },
+  {
+    "shortName": "sap",
+    "cnaID": "CNA-2017-0038",
+    "organizationName": "SAP SE",
+    "scope": "All SAP products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@sap.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.sap.com/about/trust-center/security/incident-management.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://url.sap/sapsecuritypatchday"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Secomea",
+    "cnaID": "CNA-2020-0037",
+    "organizationName": "Secomea A/S",
+    "scope": "Supported Secomea products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerabilityreporting@secomea.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.secomea.com/cybersecurity-advisory/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.secomea.com/cybersecurity-advisory/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Denmark"
+  },
+  {
+    "shortName": "schneider",
+    "cnaID": "CNA-2017-0009",
+    "organizationName": "Schneider Electric",
+    "scope": "Products supported by Schneider Electric and its affiliates, including products branded Schneider Electric or any other brands owned or controlled by Schneider Electric (such as but not limited to APC, Eliwell, Proface, ProLeit, Lauritz Knudsen Electrical & Automation, etc.), excluding Aveva and RIB products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email \u2013 Schneider Electric & Affiliates",
+            "emailAddr": "cpcert@se.com"
+          },
+          {
+            "label": "Email \u2013 Lauritz Knudsen Electrical & Automation",
+            "emailAddr": "LK-EA-CERT@LK-EA.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Report Vulnerability \u2013 Schneider Electric",
+            "url": "https://www.se.com/ww/en/work/support/cybersecurity/report-a-vulnerability/"
+          },
+          {
+            "label": "Report Vulnerability \u2013 Lauritz Knudsen Electrical & Automation",
+            "url": "https://www.lk-ea.com/services/cybersecurity/support-portal"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.se.com/ww/en/work/support/cybersecurity/vulnerability-policy.jsp"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.se.com/ww/en/work/support/cybersecurity/security-notifications.jsp"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "SICK_AG",
+    "cnaID": "CNA-2019-0016",
+    "organizationName": "SICK AG",
+    "scope": "SICK AG issues and issues in EHS products (when related to the Endress+Hauser SICK (EHS) joint venture).",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@sick.de"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://sick.com/psirt"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://sick.com/psirt#advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "siemens",
+    "cnaID": "CNA-2017-0006",
+    "organizationName": "Siemens",
+    "scope": "Siemens issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productcert@siemens.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Siemens security contact page",
+            "url": "https://www.siemens.com/cert"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.siemens.com/global/en/products/services/cert/vulnerability-process.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.siemens.com/global/en/products/services/cert.html#SiemensSecurityAdvisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Semtech",
+    "cnaID": "CNA-2020-0015",
+    "organizationName": "Semtech Corporation",
+    "scope": "All Semtech products (including Sierra Wireless products) only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": " security@semtech.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.semtech.com/company/security/report-vulnerability"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.semtech.com/company/security/security-bulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Canada"
+  },
+  {
+    "shortName": "Silver_Peak",
+    "cnaID": "CNA-2020-0011",
+    "organizationName": "Silver Peak Systems, Inc.",
+    "scope": "Silver Peak product issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "sirt@silver-peak.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.silver-peak.com/support/user-documentation/security-advisories"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.silver-peak.com/support/user-documentation/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Simplinx",
+    "cnaID": "CNA-2021-0007",
+    "organizationName": "Simplinx Ltd.",
+    "scope": "Simplinx products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@simplinx.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://simplinx.com/en/vulnerability-handling-and-disclosure-process/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://simplinx.com/en/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "T\u00fcrkiye"
+  },
+  {
+    "shortName": "snyk",
+    "cnaID": "CNA-2017-0029",
+    "organizationName": "Snyk",
+    "scope": "Vulnerabilities in Snyk products and vulnerabilities discovered by, or reported to, Snyk that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "report@snyk.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://snyk.io/vulnerability-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://snyk.io/vuln/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "UK"
+  },
+  {
+    "shortName": "SolarWinds",
+    "cnaID": "CNA-2021-0027",
+    "organizationName": "SolarWinds",
+    "scope": "SolarWinds products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@solarwinds.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.solarwinds.com/information-security/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.solarwinds.com/trust-center/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "sonicwall",
+    "cnaID": "CNA-2018-0004",
+    "organizationName": "SonicWall, Inc.",
+    "scope": "SonicWall issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "PSIRT@sonicwall.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://psirt.global.sonicwall.com/vuln-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://psirt.global.sonicwall.com/vuln-list"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Sophos",
+    "cnaID": "CNA-2021-0003",
+    "organizationName": "Sophos Limited",
+    "scope": "Sophos issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-alert@sophos.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://sophos.com/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://community.sophos.com/b/security-blog/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "UK"
+  },
+  {
+    "shortName": "INCIBE",
+    "cnaID": "CNA-2020-0002",
+    "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)",
+    "scope": "<strong>Root Scope:</strong> Spain organizations.<br/><strong>CNA Scope:</strong> Vulnerability assignment related to its vulnerability coordination role for Industrial Control Systems (ICS), Information Technologies (IT), and Internet of Things (IoT) systems issues at the national level, and vulnerabilities reported to INCIBE by Spain organizations and researchers that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@incibe.es"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy (Spanish)",
+        "language": "Spanish",
+        "url": "https://www.incibe.es/incibe-cert/alerta-temprana/vulnerabilidades/asignacion-publicacion-cve"
+      },
+      {
+        "label": "Policy (English)",
+        "language": "English",
+        "url": "https://www.incibe.es/en/incibe-cert/early-warning/vulnerabilities/cve-assignment-publication"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories (Spanish)",
+          "url": "https://www.incibe.es/incibe-cert/alerta-temprana/vulnerabilidades/avisos-cna"
+        },
+        {
+          "label": "Advisories (English)",
+          "url": "https://www.incibe.es/en/incibe-cert/early-warning/vulnerabilities/advisories-cna"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "Root"
+        },
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "suse",
+    "cnaID": "CNA-2014-0003",
+    "organizationName": "SUSE",
+    "scope": "SUSE and Rancher specific security issues, and vulnerabilities discovered by SUSE that are not covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@suse.de"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.suse.com/support/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.suse.com/support/update/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Swift",
+    "cnaID": "CNA-2021-0004",
+    "organizationName": "Swift Project",
+    "scope": "The Swift Project only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@forums.swift.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://swift.org/support/security.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://swift.org/support/security.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "symantec",
+    "cnaID": "CNA-2012-0003",
+    "organizationName": "Symantec - A Division of Broadcom",
+    "scope": "Symantec Enterprise products as well as vulnerabilities in third-party software discovered by Symantec that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "symantec.psirt@broadcom.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.broadcom.com/support/security-center/vulnerability-management"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.broadcom.com/security-advisory/security-advisories-list.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Synaptics",
+    "cnaID": "CNA-2020-0021",
+    "organizationName": "Synaptics, Inc.",
+    "scope": "Synaptics issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@synaptics.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.synaptics.com/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Touchpad Family Advisories",
+          "url": "https://www.synaptics.com/products/touchpad-family"
+        },
+        {
+          "label": "Biometrics Advisories",
+          "url": "https://www.synaptics.com/products/biometrics"
+        },
+        {
+          "label": "Far-Field Voice DSPs Advisories",
+          "url": "https://www.synaptics.com/products/far-field-voice-dsp"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "synology",
+    "cnaID": "CNA-2017-0012",
+    "organizationName": "Synology Inc.",
+    "scope": "Synology issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@synology.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Synology security contact page",
+            "url": "https://www.synology.com/en-global/support/security"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.synology.com/en-us/security/bounty_program"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.synology.com/en-global/security/advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "BlackDuck",
+    "cnaID": "CNA-2021-0013",
+    "organizationName": "Black Duck Software, Inc.",
+    "scope": "All Black Duck (formerly Synopsys Software Integrity Group) products, as well as vulnerabilities in third-party software discovered by Black Duck that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@blackduck.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.blackduck.com/company/legal/vulnerability-disclosure-policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.blackduck.com/blog/category.cyrc.html#1"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "talos",
+    "cnaID": "CNA-2016-0017",
+    "organizationName": "Talos",
+    "scope": "Third-party products it researches.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "talos-cna@cisco.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://tools.cisco.com/security/center/resources/vendor_vulnerability_policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://talosintelligence.com/vulnerability_reports"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Tcpdump",
+    "cnaID": "CNA-2020-0003",
+    "organizationName": "Tcpdump Group",
+    "scope": "Tcpdump and Libpcap only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@tcpdump.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.tcpdump.org/security.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.tcpdump.org/public-cve-list.txt"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Canada"
+  },
+  {
+    "shortName": "tenable",
+    "cnaID": "CNA-2017-0023",
+    "organizationName": "Tenable Network Security, Inc.",
+    "scope": "Tenable products and third-party products it researches not covered by another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnreport@tenable.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Tenable security contact page",
+            "url": "https://www.tenable.com/security/report/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.tenable.com/security/report"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.tenable.com/security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "TianoCore",
+    "cnaID": "CNA-2020-0031",
+    "organizationName": "TianoCore.org",
+    "scope": "Software vulnerabilities related to the TianoCore Open Source.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "infosec-cna@edk2.groups.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/tianocore/tianocore.github.io/wiki/Reporting-Security-Issues"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://tianocore-docs.github.io/SecurityAdvisory/draft/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "tibco",
+    "cnaID": "CNA-2017-0001",
+    "organizationName": "TIBCO Software Inc.",
+    "scope": "TIBCO issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@tibco.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.tibco.com/security/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.tibco.com/services/support/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Tigera",
+    "cnaID": "CNA-2019-0011",
+    "organizationName": "Tigera, Inc.",
+    "scope": "All vulnerabilities for Calico and all of Tigera\u2019s products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@tigera.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.projectcalico.org/vulnerability-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.projectcalico.org/security-bulletins/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Toshiba",
+    "cnaID": "CNA-2021-0024",
+    "organizationName": "Toshiba Corporation",
+    "scope": "Vulnerabilities related to products and services of Toshiba Group.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "hdq-toshiba-psirt@ml.toshiba.co.jp"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.global.toshiba/ww/cybersecurity/corporate/psirt.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.global.toshiba/ww/cybersecurity/corporate/psirt.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "jpcert",
+        "organizationName": "JPCERT/CC"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "TR-CERT",
+    "cnaID": "CNA-2021-0034",
+    "organizationName": "TR-CERT (Computer Emergency Response Team of the Republic of T\u00fcrkiye)",
+    "scope": "Vulnerability assignment related to its vulnerability coordination role.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@siberguvenlik.gov.tr"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Report a Vulnerability",
+            "language": "",
+            "url": "https://siberguvenlik.gov.tr/cve-bilgilendirme"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://siberguvenlik.gov.tr/cve-bilgilendirme"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://siberguvenlik.gov.tr/guvenlik-bildirimleri"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "T\u00fcrkiye"
+  },
+  {
+    "shortName": "trendmicro",
+    "cnaID": "CNA-2017-0017",
+    "organizationName": "Trend Micro, Inc.",
+    "scope": "Trend Micro <a href='https://success.trendmicro.com/solution/1105726-supported-products-trend-micro' target='_blank'>supported products</a>, including any end-of-life products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@trendmicro.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Trend Micro security contact page",
+            "url": "https://success.trendmicro.com/vulnerability-response"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://success.trendmicro.com/vulnerability-response"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://success.trendmicro.com/vulnerability-response#report"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "twcert",
+    "cnaID": "CNA-2018-0012",
+    "organizationName": "TWCERT/CC",
+    "scope": "Vulnerability assignment related to its vulnerability coordination role.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@cert.org.tw"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy (Chinese)",
+        "language": "Chinese",
+        "url": "https://www.twcert.org.tw/tw/dl-365-89f30879c74a49d38509c6ccb47d2a6b.html"
+      },
+      {
+        "label": "Policy (English)",
+        "language": "English",
+        "url": "https://www.twcert.org.tw/en/dl-45-75e0a2e1be7b42c99bbc2c11377e796b.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories (Chinese)",
+          "url": "https://www.twcert.org.tw/tw/lp-132-1.html"
+        },
+        {
+          "label": "Advisories (English)",
+          "url": "https://www.twcert.org.tw/en/lp-139-2.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "Vaadin",
+    "cnaID": "CNA-2021-0015",
+    "organizationName": "Vaadin Ltd.",
+    "scope": "All Vaadin products and supported open source projects hosted at <a href='https://github.com/vaadin' target='_blank'>https://github.com/vaadin</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@vaadin.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://vaadin.com/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://vaadin.com/security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Finland"
+  },
+  {
+    "shortName": "Vivo",
+    "cnaID": "CNA-2020-0008",
+    "organizationName": "Vivo Mobile Communication Co., Ltd.",
+    "scope": "Vivo issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@vivo.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.vivo.com/en/activity/security-advisory"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.vivo.com/en/activity/security-advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "vmware",
+    "cnaID": "CNA-2016-0025",
+    "organizationName": "VMware by Broadcom",
+    "scope": "VMware, Spring, and Cloud Foundry issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vmware.psirt@broadcom.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.broadcom.com/support/vmware-services/security-response"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.broadcom.com/support/vmware-security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Wordfence",
+    "cnaID": "CNA-2021-0022",
+    "organizationName": "Wordfence",
+    "scope": "WordPress Plugins, Themes, and Core Vulnerabilities discovered by, or reported to, the Wordfence/Defiant team.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-request@wordfence.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.wordfence.com/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.wordfence.com/blog/category/vulnerabilities/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "WPScan",
+    "cnaID": "CNA-2021-0002",
+    "organizationName": "WPScan",
+    "scope": "WordPress core, plugins, and themes.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "contact@wpscan.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://wpscan.com/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Word Press Advisories",
+          "url": "https://wpscan.com/wordpresses"
+        },
+        {
+          "label": "Word Press Plug In Advisories",
+          "url": "https://wpscan.com/plugins"
+        },
+        {
+          "label": "Word Press Theme Advisories",
+          "url": "https://wpscan.com/themes"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "XEN",
+    "cnaID": "CNA-2021-0009",
+    "organizationName": "Xen Project",
+    "scope": "All sub-projects under Xen Project\u2019s umbrella (see <a href='https://xenproject.org/developers/teams/' target='_blank'>Xen Project Teams</a>), except those sub-projects that have their own security response process; and the Xen components inside other projects, where Xen Project is the primary developer.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@xen.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://xenproject.org/about/security-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://xenbits.xen.org/xsa/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "UK"
+  },
+  {
+    "shortName": "Xiaomi",
+    "cnaID": "CNA-2020-0019",
+    "organizationName": "Xiaomi Technology Co., Ltd.",
+    "scope": "Xiaomi issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@xiaomi.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://trust.mi.com/misrc/response"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://trust.mi.com/misrc/bulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "Xylem",
+    "cnaID": "CNA-2021-0006",
+    "organizationName": "Xylem",
+    "scope": "Xylem products and technologies only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product.security@xyleminc.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.xylem.com/en-us/about-xylem/cybersecurity/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.xylem.com/en-us/about-xylem/cybersecurity/advisories?page=1&pagesize=24&categories=1324"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "yandex",
+    "cnaID": "CNA-2016-0018",
+    "organizationName": "Yandex N.V.",
+    "scope": "Yandex issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "browser-security@yandex-team.ru"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://yandex.com/bugbounty/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cloud.yandex.com/docs/overview/security-bulletins/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Russia"
+  },
+  {
+    "shortName": "Zabbix",
+    "cnaID": "CNA-2020-0022",
+    "organizationName": "Zabbix",
+    "scope": "Zabbix products and Zabbix projects listed on <a href='https://git.zabbix.com/' target='_blank'>https://git.zabbix.com/</a> only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@zabbix.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.zabbix.com/zabbix_security_policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.zabbix.com/projects/ZBX/issues/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Latvia"
+  },
+  {
+    "shortName": "zephyr",
+    "cnaID": "CNA-2017-0032",
+    "organizationName": "Zephyr Project",
+    "scope": "Zephyr project components, and vulnerabilities that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerabilities@zephyrproject.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://docs.zephyrproject.org/latest/security/security-overview.html#security-vulnerability-reporting"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.zephyrproject.org/latest/security/vulnerabilities.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "zdi",
+    "cnaID": "CNA-2017-0018",
+    "organizationName": "Zero Day Initiative",
+    "scope": "Products and projects covered by its bug bounty programs that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "zdi-disclosures@trendmicro.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "ZDI contact page",
+            "url": "https://www.zerodayinitiative.com/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.zerodayinitiative.com/advisories/disclosure_policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.zerodayinitiative.com/advisories/published/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Bug Bounty Provider",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "Zoom",
+    "cnaID": "CNA-2021-0016",
+    "organizationName": "Zoom Communications, Inc.",
+    "scope": "Zoom and Keybase issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-reports@zoom.us"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://zoom.us/docs/en-us/trust/vulnerability-disclosure.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://zoom.us/trust/security/security-bulletin"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Zscaler",
+    "cnaID": "CNA-2020-0009",
+    "organizationName": "Zscaler, Inc.",
+    "scope": "Zscaler issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@zscaler.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.zscaler.com/company/vulnerability-disclosure-program"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://trust.zscaler.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ZTE",
+    "cnaID": "CNA-2017-0019",
+    "organizationName": "ZTE Corporation",
+    "scope": "<a href='https://www.zte.com.cn/global/products' target='_blank'>ZTE products</a> only.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [],
+        "form": [
+          {
+            "label": "ZTE PSIRT contact form",
+            "url": "https://www.zte.com.cn/global/cybersecurity/ztepsirt.html"
+          }
+        ]
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.zte.com.cn/global/cybersecurity/ztepsirt/bug-bounty/products.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "http://support.zte.com.cn/support/news/NewsMain.aspx"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "Zyxel",
+    "cnaID": "CNA-2021-0023",
+    "organizationName": "Zyxel Corporation",
+    "scope": "Zyxel products issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@zyxel.com.tw"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.zyxel.com/support/security_advisories.shtml"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.zyxel.com/support/security_advisories.shtml"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "Snow",
+    "cnaID": "CNA-2021-0036",
+    "organizationName": "Snow Software",
+    "scope": "All Snow Software products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@snowsoftware.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://www.snowsoftware.com/seo/snow-responsible-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://community.snowsoftware.com/s/group/0F91r000000QUhPCAW/news-updates"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Sweden"
+  },
+  {
+    "shortName": "LGE",
+    "cnaID": "CNA-2021-0037",
+    "organizationName": "LG Electronics",
+    "scope": "LG Electronics products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product.security@lge.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://lgsecurity.lge.com/reporting"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Security Bulletins",
+          "url": "https://lgsecurity.lge.com/bulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "South Korea"
+  },
+  {
+    "shortName": "Censys",
+    "cnaID": "CNA-2021-0035",
+    "organizationName": "Censys",
+    "scope": "All Censys products, and vulnerabilities discovered by Censys that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@censys.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://censys.io/vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://censys.io/blog"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "PingIdentity",
+    "cnaID": "CNA-2021-0042",
+    "organizationName": "Ping Identity Corporation",
+    "scope": "All Ping Identity and ForgeRock products (supported products and end-of-life/end-of-service products), as well as vulnerabilities in third-party software discovered by Ping Identity or ForgeRock that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Security Email",
+            "emailAddr": "security@pingidentity.com"
+          },
+          {
+            "label": "PSIRT Email",
+            "emailAddr": "psirt@pingidentity.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Bug Bounty Program",
+            "url": "https://hackerone.com/pingidentity"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.pingidentity.com/en/company/security-at-ping-identity.html"
+      },
+      {
+        "label": "Ping Identity PGP Keys",
+        "language": "",
+        "url": "https://www.pingidentity.com/.well-known/security.txt"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.pingidentity.com/pingam/latest/release-notes/security-advisories.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Hosted Service",
+        "Researcher",
+        "Bug Bounty Provider"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Palantir",
+    "cnaID": "CNA-2021-0041",
+    "organizationName": "Palantir Technologies",
+    "scope": "Palantir products and technologies only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@palantir.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://palantir.com/responsible-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.palantir.com/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "M-Files",
+    "cnaID": "CNA-2021-0038",
+    "organizationName": "M-Files Corporation",
+    "scope": "M-Files and Hubshare products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@m-files.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://www.m-files.com/company/trust-center/vulnerability-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://empower.m-files.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Finland"
+  },
+  {
+    "shortName": "JFrog",
+    "cnaID": "CNA-2021-0039",
+    "organizationName": "JFrog",
+    "scope": "All JFrog products (supported products and end-of-life/end-of-service products); vulnerabilities in third-party software discovered by JFrog that are not in another CNA\u2019s scope; and vulnerabilities in third-party software discovered by external researchers and disclosed to JFrog (includes any embedded devices and their associated mobile applications) that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@jfrog.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://jfrog.com/trust/report-vulnerability/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.jfrog.com/confluence/display/RTF/Fixed+Security+Vulnerabilities"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Israel"
+  },
+  {
+    "shortName": "NCSC.ch",
+    "cnaID": "CNA-2021-0040",
+    "organizationName": "Switzerland National Cyber Security Centre (NCSC)",
+    "scope": "Vulnerabilities in software reported to the NCSC-CH for coordinated disclosure, which are not in another CNA's scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerability@ncsc.ch"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://www.ncsc.admin.ch/ncsc/en/home/infos-fuer/infos-it-spezialisten/themen/schwachstelle-melden.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.ncsc.admin.ch/ncsc/en/home/infos-fuer/infos-it-spezialisten/themen/schwachstelle-melden/cve-list.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "MediaTek",
+    "cnaID": "CNA-2021-0043",
+    "organizationName": "MediaTek, Inc.",
+    "scope": "MediaTek product issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@mediatek.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://corp.mediatek.com/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://corp.mediatek.com/product-security-bulletin"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "THA-PSIRT",
+    "cnaID": "CNA-2021-0045",
+    "organizationName": "Thales Group",
+    "scope": "<strong>Root Scope:</strong> Products and technologies of subsidiaries of Thales Group.<br/><strong>CNA Scope:</strong> Thales branded products and technologies, products and technologies of subsidiaries of Thales Group, unless covered by the scope of another CNA as well as vulnerabilities in third-party software discovered by Thales Group and subsidiaries that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@thalesgroup.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Customer Support Portal",
+            "url": "https://supportportal.thalesgroup.com/csm"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://www.thalesgroup.com/en/global/group/psirt"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cpl.thalesgroup.com/software-monetization/security-updates"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "role": [
+        "Root",
+        "CNA"
+      ],
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "Root"
+        },
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "Yugabyte",
+    "cnaID": "CNA-2021-0047",
+    "organizationName": "Yugabyte, Inc.",
+    "scope": "Yugabyte products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@yugabyte.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://docs.yugabyte.com/latest/secure/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.yugabyte.com/latest/secure/vulnerability-disclosure-policy/#security-tracker-cve-list"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Hosted Service",
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ASUSTOR",
+    "cnaID": "CNA-2021-0048",
+    "organizationName": "ASUSTOR, Inc.",
+    "scope": "ASUSTOR issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@asustor.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.asustor.com/security/security_advisory"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.asustor.com/security/security_advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "Okta",
+    "cnaID": "CNA-2021-0049",
+    "organizationName": "Okta",
+    "scope": "Okta issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@okta.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.okta.com/vulnerability-reporting-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://trust.okta.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "CERT-In",
+    "cnaID": "CNA-2021-0050",
+    "organizationName": "Indian Computer Emergency Response Team (CERT-In)",
+    "scope": "Vulnerability coordination for vulnerabilities in all products reported to CERT-In in accordance with our vulnerability coordination role as a CERT. Vulnerability assignments for vulnerabilities impacting all products designed, developed, and manufactured in India.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vdisclose@cert-in.org.in"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.cert-in.org.in/RVDCP.jsp"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.cert-in.org.in/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "India"
+  },
+  {
+    "shortName": "WDC_PSIRT",
+    "cnaID": "CNA-2021-0051",
+    "organizationName": "Western Digital",
+    "scope": "Western Digital products including WD, SanDisk, SanDisk Professional, G-Technology, and HGST only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@wdc.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.westerndigital.com/support/productsecurity/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.westerndigital.com/support/productsecurity"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "AppCheck",
+    "cnaID": "CNA-2021-0052",
+    "organizationName": "AppCheck Ltd.",
+    "scope": "Vulnerabilities discovered by AppCheck that are not within another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "info@appcheck-ng.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://appcheck-ng.com/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://appcheck-ng.com/category/security-alerts/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "UK"
+  },
+  {
+    "shortName": "Acronis",
+    "cnaID": "CNA-2021-0053",
+    "organizationName": "Acronis International GmbH",
+    "scope": "All Acronis products, including Acronis Cyber Protect, Acronis Cyber Protect Home Office, Acronis DeviceLock DLP, and Acronis Snap Deploy.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@acronis.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://hackerone.com/acronis"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security-advisory.acronis.com/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "Carrier",
+    "cnaID": "CNA-2021-0054",
+    "organizationName": "Carrier Global Corporation",
+    "scope": "Carrier Global products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productsecurity@carrier.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.corporate.carrier.com/product-security/reporting-response-disclosures/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.corporate.carrier.com/product-security/advisories-resources/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Hosted Service",
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "PandoraFMS",
+    "cnaID": "CNA-2021-0055",
+    "organizationName": "Pandora FMS",
+    "scope": "Pandora FMS, Pandora ITSM, and Pandora RC issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@pandorafms.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://pandorafms.com/en/security/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://pandorafms.com/common-vulnerabilities-and-exposures/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "Silabs",
+    "cnaID": "CNA-2021-0056",
+    "organizationName": "Silicon Labs",
+    "scope": "Silicon Labs issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product-security@silabs.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.silabs.com/security/security-vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://community.silabs.com/s/alert/Alert__c/00B1M000009sQ4R"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Panasonic_Holdings_Corporation",
+    "cnaID": "CNA-2021-0057",
+    "organizationName": "Panasonic Holdings Corporation",
+    "scope": "All products and services developed and/or sold by Panasonic Group companies.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product-security@gg.jp.panasonic.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.panasonic.com/global/corporate/product-security/sec/psirt/policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.panasonic.com/global/corporate/product-security/sec/psirt/advisories.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "jpcert",
+        "organizationName": "JPCERT/CC"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "ZGR",
+    "cnaID": "CNA-2021-0058",
+    "organizationName": "ZGR",
+    "scope": "ZGR manufactured products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@zigor.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.zigor.com/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.zigor.com/list-of-vulnerabilities/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "Profelis",
+    "cnaID": "CNA-2021-0059",
+    "organizationName": "Profelis IT Consultancy",
+    "scope": "Products and services developed by Profelis IT Consultancy including enterprise directory solution SambaBox and password reset product PassBox.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@profelis.com.tr"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "Turkish",
+        "url": "https://www.profelis.com.tr/politikalar/gizlilik-politikamiz/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "Turkish",
+          "url": "https://www.profelis.com.tr/politikalar/bilgi-guvenligi-politikamiz/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "T\u00fcrkiye"
+  },
+  {
+    "shortName": "TeamViewer",
+    "cnaID": "CNA-2021-0060",
+    "organizationName": "TeamViewer Germany GmbH",
+    "scope": "TeamViewer and 1E issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@teamviewer.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://vdp.teamviewer.com"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.teamviewer.com/en/trust-center/security-bulletins/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Mirantis",
+    "cnaID": "CNA-2001-0062",
+    "organizationName": "Mirantis",
+    "scope": "All Mirantis products (supported products and end-of-life/end-of-service products) and open source offerings, as well as vulnerabilities in third-party software discovered by Mirantis that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@mirantis.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/Mirantis/security/blob/main/vulnerability-disclosure-policy.md"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/Mirantis/security/blob/main/advisories/advisories.md"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "VulDB",
+    "cnaID": "CNA-2001-0063",
+    "organizationName": "VulDB",
+    "scope": "Vulnerabilities in VulDB products and vulnerabilities discovered by, or reported to, the VulDB vulnerability database that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@vuldb.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://vuldb.com/?doc.submission"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://vuldb.com/?cna.recent"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "OpenBMC",
+    "cnaID": "CNA-2021-0066",
+    "organizationName": "The OpenBMC Project",
+    "scope": "Vulnerabilities related to the repositories maintained by the OpenBMC project.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "openbmc-security@lists.ozlabs.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/openbmc/openbmc/wiki/Security-working-group"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/openbmc/openbmc/issues?utf8=%E2%9C%93&q=Security+Advisory"
+        },
+        {
+          "label": "Advisories",
+          "url": "https://github.com/openbmc/openbmc/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "DIVD",
+    "cnaID": "CNA-2022-0001",
+    "organizationName": "Dutch Institute for Vulnerability Disclosure (DIVD)",
+    "scope": "Vulnerabilities in software discovered by DIVD, and vulnerabilities reported to DIVD for coordinated disclosure, which are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "csirt@divd.nl"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.divd.nl/code/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://csirt.divd.nl/cves/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Netherlands"
+  },
+  {
+    "shortName": "Baxter",
+    "cnaID": "CNA-2022-0002",
+    "organizationName": "Baxter Healthcare",
+    "scope": "Baxter\u2019s commercially available products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productsecurity@baxter.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.baxter.com/product-security#disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.baxter.com/product-security#additionalresources"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Citrix",
+    "cnaID": "CNA-2022-0003",
+    "organizationName": "Citrix Systems, Inc.",
+    "scope": "Citrix issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@citrix.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.citrix.com/about/trust-center/vulnerability-process.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.citrix.com/securitybulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "JetBrains",
+    "cnaID": "CNA-2022-0004",
+    "organizationName": "JetBrains s.r.o.",
+    "scope": "JetBrains products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@jetbrains.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.jetbrains.com/legal/docs/terms/coordinated-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.jetbrains.com/privacy-security/issues-fixed/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "Czech Republic"
+  },
+  {
+    "shortName": "Medtronic",
+    "cnaID": "CNA-2022-0005",
+    "organizationName": "Medtronic",
+    "scope": "All products of Medtronic or a Medtronic company including supported products and end-of-life/end-of-service products, as well as vulnerabilities in third-party software discovered in Medtronic products that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@medtronic.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://global.medtronic.com/xg-en/product-security/coordinated-disclosure-process.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://global.medtronic.com/xg-en/product-security/security-bulletins.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ASRG",
+    "cnaID": "CNA-2022-0006",
+    "organizationName": "Automotive Security Research Group (ASRG)",
+    "scope": "All automotive and related infrastructure vulnerabilities that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@asrg.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.asrg.io/disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.asrg.io/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Netskope",
+    "cnaID": "CNA-2022-0007",
+    "organizationName": "Netskope",
+    "scope": "All Netskope products and services.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@netskope.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.netskope.com/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.netskope.com/company/security-compliance-and-assurance/security-advisories-and-disclosures"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Go",
+    "cnaID": "CNA-2022-0008",
+    "organizationName": "Go Project",
+    "scope": "Vulnerabilities in software published by the Go Project (including the Go standard library, Go toolchain, and the golang.org modules) and publicly disclosed vulnerabilities in publicly importable packages in the Go ecosystem, unless covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@golang.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://go.dev/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://pkg.go.dev/vuln/list"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "Google",
+        "organizationName": "Google LLC"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "GE_Vernova",
+    "cnaID": "CNA-2022-0009",
+    "organizationName": "GE Vernova",
+    "scope": "All GE Vernova products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "GEV.PSIRT@gevernova.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.gevernova.com/gas-power/products/digital-and-controls/cybersecurity/vulnerability-response"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.gevernova.com/gas-power/products/digital-and-controls/cybersecurity/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ZUSO_ART",
+    "cnaID": "CNA-2022-0010",
+    "organizationName": "ZUSO Advanced Research Team (ZUSO ART)",
+    "scope": "Vulnerabilities in third-party products discovered by ZUSO ART that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "ART@zuso.ai"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://zuso.ai/Policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://zuso.ai/Advisory.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "Anolis",
+    "cnaID": "CNA-2022-0011",
+    "organizationName": "OpenAnolis",
+    "scope": "OpenAnolis issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@openanolis.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://openanolis.cn/sig/security-committee/doc/479850544775086233"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://anas.openanolis.cn/errata"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "Philips",
+    "cnaID": "CNA-2022-0012",
+    "organizationName": "Philips",
+    "scope": "Philips issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productsecurity@philips.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.philips.com/a-w/security/coordinated-vulnerability-disclosure.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.philips.com/a-w/security/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Netherlands"
+  },
+  {
+    "shortName": "HYPR",
+    "cnaID": "CNA-2022-0013",
+    "organizationName": "HYPR Corp",
+    "scope": "All HYPR products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@hypr.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hypr.com/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.hypr.com/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Hitachi",
+    "cnaID": "CNA-2022-0014",
+    "organizationName": "Hitachi, Ltd.",
+    "scope": "Hitachi products excluding Hitachi Energy and Hitachi Vantara products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "hirt@hitachi.co.jp"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hitachi.com/hirt/publications/hirt-pub10008"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.hitachi.com/hirt/security/security.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "jpcert",
+        "organizationName": "JPCERT/CC"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "Hallo_Welt",
+    "cnaID": "CNA-2022-0015",
+    "organizationName": "Hallo Welt! GmbH",
+    "scope": "BlueSpice vulnerabilities only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@bluespice.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://bluespice.com/filebase/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://en.wiki.bluespice.com/wiki/Security:Security_Advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "SailPoint",
+    "cnaID": "CNA-2022-0016",
+    "organizationName": "SailPoint Technologies",
+    "scope": "SailPoint issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@sailpoint.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.sailpoint.com/legal/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.sailpoint.com/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Hitachi_Vantara",
+    "cnaID": "CNA-2022-0017",
+    "organizationName": "Hitachi Vantara",
+    "scope": "All Hitachi Vantara products and technologies.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security.vulnerabilities@hitachivantara.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hitachivantara.com/en-us/security#section-vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://knowledge.hitachivantara.com/portal/app/portlets/results/viewsolution.jsp?solutionid=241403050017684"
+        },
+        {
+          "label": "Known Vulnerability Updates",
+          "url": "https://support.pentaho.com/hc/en-us/categories/360003921092--Known-Vulnerability-Updates"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "GE_Healthcare",
+    "cnaID": "CNA-2022-0018",
+    "organizationName": "GE Healthcare",
+    "scope": "GE Healthcare products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "CVD@gehealthcare.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.gehealthcare.com/security/cvd"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Public Advisories",
+          "url": "https://www.gehealthcare.com/security"
+        },
+        {
+          "label": "Registered Customer Portal Advisories",
+          "url": "https://securityupdate.gehealthcare.com"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "openGauss",
+    "cnaID": "CNA-2022-0019",
+    "organizationName": "openGauss Community",
+    "scope": "openGauss issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "securities@opengauss.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://opengauss.org/zh/security.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://opengauss.org/en/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "FULL",
+    "cnaID": "CNA-2022-0020",
+    "organizationName": "FULL INTERNET",
+    "scope": "All FULL products, as well as vulnerabilities in third-party software discovered by FULL that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@wpfull.com.br"
+          }
+        ],
+        "contact": [
+          {
+            "label": "FULL security contact page",
+            "url": "https://security.full.services/enviar-vulnerabilidade/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security.full.services/politica-de-divulgacao-de-vulnerabilidades/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.full.services/vulnerabilidades-no-wordpress/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Bug Bounty Provider",
+        "Hosted Service",
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "Brazil"
+  },
+  {
+    "shortName": "The_Missing_Link",
+    "cnaID": "CNA-2022-0021",
+    "organizationName": "The Missing Link Australia (TML)",
+    "scope": "TML vulnerability disclosure policy applies to any third-party vendor products to whom TML will assign the CVEs for vulnerabilities, if the product is not a part of another CNA scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vdp@themissinglink.com.au"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.themissinglink.com.au/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.themissinglink.com.au/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "NCSC-NL",
+    "cnaID": "CNA-2022-0022",
+    "organizationName": "National Cyber Security Centre Netherlands (NCSC-NL)",
+    "scope": "Vulnerabilities in software discovered by NCSC-NL, and vulnerabilities reported to NCSC-NL for coordinated disclosure, which are not in another CNA's scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cert@ncsc.nl"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "Dutch",
+        "url": "https://www.ncsc.nl/contact/kwetsbaarheid-melden"
+      },
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://english.ncsc.nl/contact/reporting-a-vulnerability-cvd"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.ncsc.nl/actueel/beveiligingsadviezen"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Netherlands"
+  },
+  {
+    "shortName": "Dassault_Systemes",
+    "cnaID": "CNA-2022-0023",
+    "organizationName": "Dassault Syst\u00e8mes",
+    "scope": "All websites of the corporate group and of any subsidiaries, including but not limited to <a href='https://www.3ds.com' target='_blank'>www.3ds.com</a> and <a href='https://www.solidworks.com' target='_blank'>www.solidworks.com</a>; all Software as a Service solutions, such as 3DEXPERIENCE or ScienceCloud, but also any online hosting linked to our brands; and all Dassault Syst\u00e8mes licensed software products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "3DS.Information-Security@3ds.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.3ds.com/vulnerability"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.3ds.com/vulnerability/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "KNIME",
+    "cnaID": "CNA-2022-0024",
+    "organizationName": "KNIME AG",
+    "scope": "All vulnerabilities on software products that our company provides, including KNIME Analytics Platform, KNIME Server, and KNIME Hub.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@knime.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.knime.com/security/policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.knime.com/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "Unisoc",
+    "cnaID": "CNA-2022-0025",
+    "organizationName": "Unisoc (Shanghai) Technologies Co., Ltd.",
+    "scope": "Unisoc issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@unisoc.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://www.unisoc.com/en_us/secy/flawedPolicy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "English",
+          "url": "https://www.unisoc.com/en_us/secy/announcement"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "OpenHarmony",
+    "cnaID": "CNA-2022-0026",
+    "organizationName": "OpenHarmony",
+    "scope": "openHarmony issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "scy@openharmony.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "English",
+        "url": "https://gitee.com/openharmony/security/tree/master/en/security-process"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "English",
+          "url": "https://gitee.com/openharmony/security/tree/master/en/security-disclosure"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "Crestron",
+    "cnaID": "CNA-2022-0027",
+    "organizationName": "Crestron Electronics, Inc.",
+    "scope": "Crestron products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "support@crestron.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.crestron.com/Security/Report-A-Product-Vulnerability"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.crestron.com/Security/Security_Advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Rockwell",
+    "cnaID": "CNA-2022-0028",
+    "organizationName": "Rockwell Automation",
+    "scope": "All Rockwell Automation products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "PSIRT@rockwellautomation.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.rockwellautomation.com/en-us/company/about-us/legal-notices/vulnerability-policy.html..html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.rockwellautomation.com/en-us/trust-center/security-advisories.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "OpenNMS",
+    "cnaID": "CNA-2022-0029",
+    "organizationName": "The OpenNMS Group",
+    "scope": "OpenNMS issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@opennms.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.opennms.com/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://www.opennms.com/en/blog/category/blog/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Dragos",
+    "cnaID": "CNA-2022-0030",
+    "organizationName": "Dragos, Inc.",
+    "scope": "Dragos products and third-party products it researches related to operational technology (OT)/industrial control systems (ICS) not covered by another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "ot-cert@dragos.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.dragos.com/vulnerabilities-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.dragos.com/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "CyberArk",
+    "cnaID": "CNA-2022-0031",
+    "organizationName": "CyberArk Labs",
+    "scope": "Vulnerabilities discovered by CyberArk Labs that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "dl-IdentitySecurityLab@paloaltonetworks.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://labs.cyberark.com/coordinated-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://labs.cyberark.com/cyberark-labs-security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "Israel"
+  },
+  {
+    "shortName": "DualVS",
+    "cnaID": "CNA-2022-0032",
+    "organizationName": "Dual Vipers LLC",
+    "scope": "Dual Vipers projects and products (both open and closed source), as well as vulnerabilities in third-party software discovered by Dual Vipers that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "bugs@dualvs.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://advisory.dualvs.com/VDP.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://advisory.dualvs.com"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Hosted Service",
+        "Open Source",
+        "Researcher",
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Bugcrowd",
+    "cnaID": "CNA-2022-0033",
+    "organizationName": "Bugcrowd Inc.",
+    "scope": "Vulnerabilities discovered by researchers in collaboration with Bugcrowd, with approval of Bugcrowd\u2019s clients, and not in the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordinator@bugcrowd.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://bugcrowd.com/bugcrowd"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://bugcrowd.com/crowdstream?filter=disclosures"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Bug Bounty Provider",
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "SK-CERT",
+    "cnaID": "CNA-2022-0034",
+    "organizationName": "National Cyber Security Centre SK-CERT",
+    "scope": "Vulnerabilities in software discovered by National Cyber Security Centre SK-CERT, and vulnerabilities reported to National Cyber Security Centre SK-CERT for coordinated disclosure, which are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "incident@nbu.gov.sk"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.sk-cert.sk/wp-content/uploads/2019/10/Vulnerability_reporting.pdf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://www.sk-cert.sk/threat/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Slovak Republic"
+  },
+  {
+    "shortName": "NetRise",
+    "cnaID": "CNA-2022-0036",
+    "organizationName": "NetRise",
+    "scope": "Vulnerabilities in third-party Extended Internet of Things (XIoT) devices and firmware NetRise researches that are not covered by another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "research@netrise.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.netrise.io/hubfs/resources/Vuln%20Disclosure%20Policy%20v1.pdf?hsLang=en"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.netrise.io/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "HashiCorp",
+    "cnaID": "CNA-2022-0037",
+    "organizationName": "HashiCorp Inc.",
+    "scope": "All HashiCorp products and projects unless covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@hashicorp.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hashicorp.com/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://discuss.hashicorp.com/c/security/52"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "GreenRocketSecurity",
+    "cnaID": "CNA-2022-0039",
+    "organizationName": "Green Rocket Security Inc.",
+    "scope": "Green Rocket Security products including EOL unless covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "info@greenrocketsecurity.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://greenrocketsecurity.com/disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://www.greenrocketsecurity.com/resources/security-updates/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Seagate",
+    "cnaID": "CNA-2022-0040",
+    "organizationName": "Seagate Technology",
+    "scope": "Any Seagate or LaCie software or hardware, open or closed source, supported and end of life, as well as any vulnerabilities in third-party software discovered by Seagate that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@seagate.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.seagate.com/legal-privacy/responsible-vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://www.seagate.com/support/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "senhasegura",
+    "cnaID": "CNA-2022-0041",
+    "organizationName": "senhasegura",
+    "scope": "Vulnerabilities in senhasegura products, and other vulnerabilities discovered by senhasegura that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@senhasegura.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://docs.senhasegura.io/security-guidance/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://docs.senhasegura.io/security-center-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "Brazil"
+  },
+  {
+    "shortName": "KrakenD",
+    "cnaID": "CNA-2022-0042",
+    "organizationName": "KrakenD, S.L.",
+    "scope": "KrakenD EE, KrakenD CE, and Lura issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@krakend.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.krakend.io/security-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://www.krakend.io/tags/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "ONEKEY",
+    "cnaID": "CNA-2022-0043",
+    "organizationName": "ONEKEY GmbH",
+    "scope": "All ONEKEY products and vulnerabilities in third-party software discovered by ONEKEY that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "research@onekey.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.onekey.com/responsible-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://onekey.com/research/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Zowe",
+    "cnaID": "CNA-2022-0044",
+    "organizationName": "Zowe",
+    "scope": "Vulnerabilities in <a href='https://zowe.org' target='_blank'>Zowe.org</a> open source projects.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "zowe-security@lists.openmainframeproject.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://zowe.org/security.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://github.com/zowe/community/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Honor",
+    "cnaID": "CNA-2022-0045",
+    "organizationName": "Honor Device Co., Ltd.",
+    "scope": "Vulnerabilities in Honor products and services unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@hihonor.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hihonor.com/global/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://www.hihonor.com/global/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "Honeywell",
+    "cnaID": "CNA-2022-0046",
+    "organizationName": "Honeywell International Inc.",
+    "scope": "All Honeywell products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@honeywell.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.honeywell.com/us/en/product-security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://sps.honeywell.com/us/en/support/productivity/cyber-security-notifications"
+        },
+        {
+          "label": "EOL & Security Notices",
+          "url": "https://buildings.honeywell.com/us/en/brands/our-brands/security/support-and-resources/product-resources/eol-and-security-notices"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Qualys",
+    "cnaID": "CNA-2022-0047",
+    "organizationName": "Qualys, Inc.",
+    "scope": "All Qualys products and vulnerabilities discovered by Qualys that are not covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "bugreport@qualys.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.qualys.com/docs/responsible-disclosure-policy.pdf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://www.qualys.com/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "GRAFANA",
+    "cnaID": "CNA-2022-0048",
+    "organizationName": "Grafana Labs",
+    "scope": "All Grafana Labs open source and commercial products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-team@grafana.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://grafana.com/legal/report-a-security-issue/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://grafana.com/security/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "wolfSSL",
+    "cnaID": "CNA-2022-0049",
+    "organizationName": "wolfSSL Inc.",
+    "scope": "Transport Layer Security (TLS) and Cryptographic issues found in wolfSSL products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "facts@wolfssl.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "wolfSSL Security Vulnerabilities page",
+            "url": "https://www.wolfssl.com/docs/security-vulnerabilities/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.wolfssl.com/docs/security-vulnerabilities/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://www.wolfssl.com/docs/security-vulnerabilities/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Docker",
+    "cnaID": "CNA-2022-0050",
+    "organizationName": "Docker Inc.",
+    "scope": "All Docker products, including Docker Desktop and Docker Hub, as well as Docker maintained open source projects.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@docker.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.docker.com/trust/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://docs.docker.com/security/"
+        },
+        {
+          "label": "Desktop Release Notes",
+          "language": "",
+          "url": "https://docs.docker.com/desktop/release-notes/"
+        },
+        {
+          "label": "Engine Release Notes",
+          "language": "",
+          "url": "https://docs.docker.com/engine/release-notes/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Proofpoint",
+    "cnaID": "CNA-2022-0051",
+    "organizationName": "Proofpoint Inc.",
+    "scope": "All Proofpoint products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@proofpoint.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.proofpoint.com/us/security/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://proofpoint.com/security/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Hosted Service",
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Baidu",
+    "cnaID": "CNA-2022-0052",
+    "organizationName": "Baidu, Inc.",
+    "scope": "Projects listed on Baidu\u2019s <a href='https://github.com/PaddlePaddle' target='_blank'>PaddlePaddle GitHub website</a> only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "paddle-security@baidu.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/PaddlePaddle/Paddle/security/policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://github.com/PaddlePaddle/Paddle/tree/develop/security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "Canon",
+    "cnaID": "CNA-2022-0054",
+    "organizationName": "Canon Inc.",
+    "scope": "Vulnerabilities in products and services under the Canon brand.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Canon PSIRT Report a Product Security Issue page",
+            "url": "https://psirt.canon/vulnerability-report-form/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://psirt.canon/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://psirt.canon/advisory-information/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "jpcert",
+        "organizationName": "JPCERT/CC"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "Checkmk",
+    "cnaID": "CNA-2022-0055",
+    "organizationName": "Checkmk GmbH",
+    "scope": "All products of Checkmk GmbH including Checkmk and Checkmk Appliance, Nagvis, Robotmk, and packages published on <a href='https://exchange.checkmk.com/' target='_blank'>exchange.checkmk.com</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@checkmk.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://checkmk.com/responsible-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://checkmk.com/werks"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "dotCMS",
+    "cnaID": "CNA-2023-0001",
+    "organizationName": "dotCMS LLC",
+    "scope": "All dotCMS product services including the vulnerabilities reported in our open source core located at <a href='https://github.com/dotCMS/core' target='_blank'>https://github.com/dotCMS/core</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@dotcms.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.dotcms.com/docs/latest/responsible-disclosure-policy"
+      },
+      {
+        "label": "Reporting Issues",
+        "language": "",
+        "url": "https://www.dotcms.com/docs/latest/security-and-privacy#:~:text=dotCMS%20will%20disclose%20all%20issues,fix%20the%20reported%20security%20issue"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://www.dotcms.com/docs/latest/known-security-issues"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Hosted Service"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "DHIS2",
+    "cnaID": "CNA-2023-0002",
+    "organizationName": "The HISP Centre at the University of Oslo",
+    "scope": "Security issues in <a href='https://github.com/dhis2' target='_blank'>DHIS2</a> open source web and mobile software applications.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@dhis2.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://dhis2.org/security/vulnerability-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://dhis2.org/security/vulnerabilities/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "Norway"
+  },
+  {
+    "shortName": "NI",
+    "cnaID": "CNA-2023-0003",
+    "organizationName": "National Instruments",
+    "scope": "NI products only (including National Instruments).",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@ni.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://ni.com/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://www.ni.com/en-us/support/documentation/supplemental/11/available-critical-and-security-updates-for-ni-software.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Genetec",
+    "cnaID": "CNA-2023-0004",
+    "organizationName": "Genetec Inc.",
+    "scope": "Genetec products and solutions only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@genetec.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.genetec.com/trust-cybersecurity/resources"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://resources.genetec.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Hosted Service",
+        "Vendor"
+      ]
+    },
+    "country": "Canada"
+  },
+  {
+    "shortName": "AHA",
+    "cnaID": "CNA-2023-0005",
+    "organizationName": "Austin Hackers Anonymous",
+    "scope": "Vulnerabilities in the AHA! website and other AHA! controlled assets, as well as vulnerabilities identified in assets owned, operated, or maintained by another organization unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@takeonme.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://takeonme.org/cve.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://takeonme.org/cve.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "XI",
+    "cnaID": "CNA-2023-0006",
+    "organizationName": "Exodus Intelligence",
+    "scope": "Vulnerabilities discovered by Exodus Intelligence as well as acquisitions from independent researchers via its Research Sponsorship Program (RSP).",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclosures@exodusintel.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://blog.exodusintel.com/2021/03/17/2021-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://blog.exodusintel.com/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Bug Bounty Provider",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "B.Braun",
+    "cnaID": "CNA-2023-0007",
+    "organizationName": "B. Braun SE",
+    "scope": "B. Braun\u2019s commercially available products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productsecurity@bbraun.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.bbraun.com/en/products-and-solutions/b--braun-product-security.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.bbraun.com/en/products-and-solutions/b--braun-product-security.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "OX",
+    "cnaID": "CNA-2023-0008",
+    "organizationName": "Open-Xchange",
+    "scope": "Products and services provided by Open-Xchange, PowerDNS, and Dovecot.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@open-xchange.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://vdp.open-xchange.com/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://documentation.open-xchange.com/appsuite/security/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source",
+        "Vendor"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Hillstone",
+    "cnaID": "CNA-2023-0009",
+    "organizationName": "Hillstone Networks Inc.",
+    "scope": "Vulnerabilities in our products listed at <a href='https://www.hillstonenet.com/hillstone-networks-product-portfolio' target='_blank'>https://www.hillstonenet.com/hillstone-networks-product-portfolio</a> and the products we sell only in China listed at <a href='https://www.hillstonenet.com.cn/product_service/' target='_blank'>https://www.hillstonenet.com.cn/product_service/</a>, not including our websites.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@hillstonenet.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hillstonenet.com.cn/support-and-training/psirt"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.hillstonenet.com.cn/support-and-training/psirt/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "STAR_Labs",
+    "cnaID": "CNA-2023-0010",
+    "organizationName": "STAR Labs SG Pte. Ltd.",
+    "scope": "Vulnerabilities discovered by, or reported to, STAR Labs SG that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "info@starlabs.sg"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://starlabs.sg/advisories/STAR%20Labs%20SG%20Pte.%20Ltd.%20Vulnerability%20Disclosure%20Policy.pdf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://starlabs.sg/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "Singapore"
+  },
+  {
+    "shortName": "ShopBeat",
+    "cnaID": "CNA-2023-0011",
+    "organizationName": "Shop Beat Solutions (Pty) LTD",
+    "scope": "Vulnerabilities in Shop Beat products and services and vulnerabilities discovered by Shop Beat unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "support@shopbeat.co.za"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.shopbeat.co.za/disclosure_policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.shopbeat.co.za/security_advisory_location.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Hosted Service",
+        "Vendor"
+      ]
+    },
+    "country": "South Africa"
+  },
+  {
+    "shortName": "SN",
+    "cnaID": "CNA-2023-0012",
+    "organizationName": "ServiceNow",
+    "scope": "All ServiceNow products (supported products and end-of-life/end-of-service products), as well as vulnerabilities in third-party software discovered by ServiceNow that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@servicenow.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.servicenow.com/company/trust/privacy/responsible-disclosure.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.servicenow.com/kb?id=kb_article_view&sysparm_article=KB1226057"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Hosted Service",
+        "Researcher",
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "WatchGuard",
+    "cnaID": "CNA-2023-0013",
+    "organizationName": "WatchGuard Technologies, Inc.",
+    "scope": "Vulnerabilities in all WatchGuard products and products of WatchGuard subsidiaries.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@watchguard.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.watchguard.com/wgrd-psirt/responsible-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.watchguard.com/wgrd-psirt/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "IDEMIA",
+    "cnaID": "CNA-2023-0014",
+    "organizationName": "IDEMIA",
+    "scope": "All IDEMIA products (supported products and end-of-life/end-of-service products), as well as vulnerabilities in third-party software discovered by IDEMIA that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@idemia.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.idemia.com/idemia-product-security-incident-response-team-psirt"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.idemia.com/vulnerability-information"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher",
+        "Vendor"
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "GandC",
+    "cnaID": "CNA-2023-0015",
+    "organizationName": "Glyph & Cog, LLC",
+    "scope": "Xpdf open source project, including the xpdf viewer and associated command line tools.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "xpdf@xpdfreader.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.xpdfreader.com/disclosure.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.xpdfreader.com/security-fixes.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Open Source",
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Liferay",
+    "cnaID": "CNA-2023-0016",
+    "organizationName": "Liferay, Inc.",
+    "scope": "All Liferay supported products and end-of-life/end-of-service products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@liferay.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://liferay.dev/portal/security/reporting"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://liferay.dev/portal/security/known-vulnerabilities"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Securifera",
+    "cnaID": "CNA-2023-0017",
+    "organizationName": "Securifera, Inc.",
+    "scope": "Vulnerabilities in vendor products discovered by Securifera, or related parties, while performing vulnerability research or security assessments.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "contact@securifera.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.securifera.com/advisories/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.securifera.com/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "CyberDanube",
+    "cnaID": "CNA-2023-0018",
+    "organizationName": "CyberDanube",
+    "scope": "All CyberDanube products, as well as vulnerabilities in third-party hardware/software discovered by CyberDanube or partners actively engaged in vulnerability research coordination, which are not within the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "office@cyberdanube.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://cyberdanube.com/en/responsible-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cyberdanube.com/en/blogs/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Researcher",
+        "Vendor"
+      ]
+    },
+    "country": "Austria"
+  },
+  {
+    "shortName": "StrongDM",
+    "cnaID": "CNA-2023-0019",
+    "organizationName": "StrongDM",
+    "scope": "StrongDM issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@strongdm.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://hackerone.com/strongdm"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.strongdm.com/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "SEL",
+    "cnaID": "CNA-2023-0020",
+    "organizationName": "Schweitzer Engineering Laboratories, Inc.",
+    "scope": "All Schweitzer Engineering Laboratories products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@selinc.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://selinc.com/support/security-notifications/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://selinc.com/support/security-notifications/external-reports/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "VulnCheck",
+    "cnaID": "CNA-2023-0021",
+    "organizationName": "VulnCheck",
+    "scope": "Vulnerabilities observed by, discovered by, or reported to VulnCheck that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclosure@vulncheck.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://vulncheck.com/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://vulncheck.com/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Bug Bounty Provider",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Halborn",
+    "cnaID": "CNA-2023-0022",
+    "organizationName": "Halborn",
+    "scope": "All blockchain and Web3 products that rely on smart contracts written in Rust, Go, and Solidity, as well as blockchain associated Web2 and Web3 infrastructure not covered by another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclosures@halborn.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://halborn.com/disclosures/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://halborn.com/disclosures/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Ribose",
+    "cnaID": "CNA-2023-0023",
+    "organizationName": "Ribose Limited",
+    "scope": "All Ribose products and services, including open source projects, supported products, and end-of-life/end-of-service products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@ribose.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://open.ribose.com/cve-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://open.ribose.com/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Hosted Service",
+        "Open Source",
+        "Vendor"
+      ]
+    },
+    "country": "UK"
+  },
+  {
+    "shortName": "42Gears",
+    "cnaID": "CNA-2023-0024",
+    "organizationName": "42Gears Mobility Systems Pvt Ltd",
+    "scope": "42Gears branded products and technologies only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@42gears.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy (click on \u201cSecurity Response Center\u201d)",
+        "language": "",
+        "url": "https://www.42gears.com/security-and-compliance/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories (click on \u201cSecurity Advisories\u201d)",
+          "url": "https://www.42gears.com/security-and-compliance/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "India"
+  },
+  {
+    "shortName": "Solidigm",
+    "cnaID": "CNA-2023-0025",
+    "organizationName": "Solidigm",
+    "scope": "Solidigm branded products and technologies.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "Security@Solidigm.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.solidigm.com/support-page/support-security.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.solidigm.com/support-page/support-security.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Illumio",
+    "cnaID": "CNA-2023-0026",
+    "organizationName": "Illumio",
+    "scope": "Illumio issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@illumio.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.illumio.com/legal/responsible-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.illumio.com/LandingPages/Categories/security-advisories.htm"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "BLSOPS",
+    "cnaID": "CNA-2023-0027",
+    "organizationName": "Black Lantern Security",
+    "scope": "Vulnerabilities in vendor products discovered by BLSOPS, or related parties, while performing vulnerability research or security assessments, unless covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cves@blacklanternsecurity.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.blacklanternsecurity.com/disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.blacklanternsecurity.com/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "IoT83",
+    "cnaID": "CNA-2023-0028",
+    "organizationName": "IoT83 Ltd",
+    "scope": "Vulnerabilities in IoT83 product(s), services, and components only. Third-party, open source components used in IoT83 product(s), services, and components are not in scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@iot83.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.iot83.com/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.iot83.com/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Moxa",
+    "cnaID": "CNA-2023-0029",
+    "organizationName": "Moxa Inc.",
+    "scope": "Moxa products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@moxa.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.moxa.com/en/support/product-support/security-advisory/cybersecurity-vulnerability-management-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.moxa.com/en/support/product-support/security-advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "Temporal",
+    "cnaID": "CNA-2023-0030",
+    "organizationName": "Temporal Technologies Inc.",
+    "scope": "All Temporal Technologies software.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@temporal.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://docs.temporal.io/temporal-technologies-inc-security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.temporal.io/temporal-technologies-inc-security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Hosted Service",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "AMI",
+    "cnaID": "CNA-2023-0031",
+    "organizationName": "AMI",
+    "scope": "Vulnerabilities in AMI firmware and software products, as well as vulnerabilities discovered by AMI that are not covered by another CNA scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email for BIOS Products",
+            "emailAddr": "biossecurity@ami.com"
+          },
+          {
+            "label": "Email for MegaRAC Products",
+            "emailAddr": "megarac.security@ami.com"
+          },
+          {
+            "label": "Email for Tektagon Products",
+            "emailAddr": "tektagonsecurity@ami.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.ami.com/security-center/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.ami.com/security-center/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Payara",
+    "cnaID": "CNA-2023-0032",
+    "organizationName": "Payara",
+    "scope": "All Payara Platform product distributions (Payara Server, Micro, Embedded) for both Enterprise (commercial) and Community (OSS) distributions.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@payara.fish"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Community Edition Policy",
+        "language": "",
+        "url": "https://docs.payara.fish/community/docs/Security/Overview.html"
+      },
+      {
+        "label": "Enterprise Edition Policy",
+        "language": "",
+        "url": "https://docs.payara.fish/enterprise/docs/Security/Overview.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Community Edition Advisories",
+          "url": "https://docs.payara.fish/community/docs/Security/Security%20Fix%20List.html"
+        },
+        {
+          "label": "Enterprise Edition Advisories",
+          "url": "https://docs.payara.fish/enterprise/docs/Security/Security%20Fix%20List.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source",
+        "Vendor"
+      ]
+    },
+    "country": "UK"
+  },
+  {
+    "shortName": "NCSC-FI",
+    "cnaID": "CNA-2023-0033",
+    "organizationName": "National Cyber Security Centre Finland (NCSC-FI)",
+    "scope": "Vulnerabilities in software discovered by NCSC-FI, and vulnerabilities reported to NCSC-FI for coordinated disclosure, which are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulncoord@ncsc.fi"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy (Finnish)",
+        "language": "Finnish",
+        "url": "https://www.kyberturvallisuuskeskus.fi/fi/ajankohtaista/haavoittuvuudet-miten-niista-ilmoitetaan-oikein"
+      },
+      {
+        "label": "Policy (English)",
+        "language": "English",
+        "url": "https://www.kyberturvallisuuskeskus.fi/en/our-services/situation-awareness-and-network-management/vulnerability-coordination"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories (Finnish)",
+          "url": "https://www.kyberturvallisuuskeskus.fi/fi/haavoittuvuudet"
+        },
+        {
+          "label": "Advisories (English)",
+          "url": "https://www.kyberturvallisuuskeskus.fi/en/haavoittuvuudet"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Finland"
+  },
+  {
+    "shortName": "samsung.tv_appliance",
+    "cnaID": "CNA-2023-0034",
+    "organizationName": "Samsung TV & Appliance",
+    "scope": "Samsung TV &amp; Appliance products, Samsung-owned open source projects listed on <a href='https://github.com/Samsung/' target='_blank'>https://github.com/Samsung/</a>, as well as vulnerabilities in third-party software discovered by Samsung that are not in another CNA\u2019s scope. Vulnerabilities affecting end-of-life/end-of-service products are in scope. The following categories of Samsung Products are in scope: Internet-connected home appliances, B2C product (smart TV, smart monitor, soundbar, and projector), and B2B products (digital signage, interactive display, and kiosk).",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "PSIRT@samsung.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://SecurityReport.samsung.com/#DisclosurePolicy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Smart TV, Audio, and Displays Advisories",
+          "url": "https://Security.SamsungTV.com/securityUpdates"
+        },
+        {
+          "label": "Digital Appliances Advisories",
+          "url": "https://Security.SamsungDA.com/securityUpdates.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source",
+        "Researcher",
+        "Vendor"
+      ]
+    },
+    "country": "South Korea"
+  },
+  {
+    "shortName": "SRA",
+    "cnaID": "CNA-2023-0035",
+    "organizationName": "Security Risk Advisors (SRA)",
+    "scope": "Vulnerabilities discovered by SRA that are not within the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "advisories@sra.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://sra.io/disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://sra.io/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Arm",
+    "cnaID": "CNA-2023-0036",
+    "organizationName": "Arm Limited",
+    "scope": "Arm-branded products and technologies and Arm-managed open source projects.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@arm.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://developer.arm.com/documentation/102850/0100"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://developer.arm.com/Arm%20Security%20Center"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source",
+        "Vendor"
+      ]
+    },
+    "country": "UK"
+  },
+  {
+    "shortName": "ODA",
+    "cnaID": "CNA-2023-0037",
+    "organizationName": "Open Design Alliance",
+    "scope": "Open Design Alliance products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@opendesign.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.opendesign.com/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.opendesign.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "BHV",
+    "cnaID": "CNA-2023-0038",
+    "organizationName": "Biohacking Village",
+    "scope": "Vulnerabilities discovered by researchers in collaboration with Biohacking Village, with approval of Biohacking Village\u2019s sponsors, that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@villageb.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.villageb.io/cvd"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.villageb.io/security-advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Gitea",
+    "cnaID": "CNA-2023-0039",
+    "organizationName": "Gitea Limited",
+    "scope": "Gitea issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@gitea.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/go-gitea/gitea/blob/main/SECURITY.md"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://about.gitea.com/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source",
+        "Vendor"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "Google_Devices",
+    "cnaID": "CNA-2023-0040",
+    "organizationName": "Google Devices",
+    "scope": "Google Devices - Pixel, Nest, and Chromecast.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "dspa-cve@google.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://support.google.com/product-documentation/answer/13658251?hl=en&amp;ref_topic=12974021&amp;sjid=11464995960873540884-NA"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Nest Advisories",
+          "url": "https://support.google.com/product-documentation/topic/12974021?hl=en&amp;ref_topic=10123615&amp;sjid=5419128013624043298-NA"
+        },
+        {
+          "label": "Pixel Advisories",
+          "url": "https://source.android.com/docs/security/bulletin/pixel"
+        },
+        {
+          "label": "Chromecast Advisories",
+          "url": "https://source.android.com/docs/security/bulletin/chromecast"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "Google",
+        "organizationName": "Google LLC"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "MIM",
+    "cnaID": "CNA-2023-0041",
+    "organizationName": "MIM Software Inc.",
+    "scope": "MIM software products, platforms, and services as well as vulnerabilities reported to MIM Software in third-party components or libraries used by MIM Software products, platforms, and services not covered by another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@mimsoftware.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.mimsoftware.com/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.mimsoftware.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "IDBS",
+    "cnaID": "CNA-2023-0042",
+    "organizationName": "ID Business Solutions",
+    "scope": "IDBS products as listed on <a href='https://www.idbs.com/products/' target='_blank'>https://www.idbs.com/products/</a>.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "IDBS contact page",
+            "url": "https://idbs.my.site.com/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.idbs.com/about/coordinated-vulnerability-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://help.idbs.com/advisories/en/index-en.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "UK"
+  },
+  {
+    "shortName": "Hanwha_Vision",
+    "cnaID": "CNA-2023-0043",
+    "organizationName": "Hanwha Vision Co., Ltd.",
+    "scope": "Hanwha Vision (formerly Samsung Techwin and Hanwha Techwin) products and solutions only, including end-of-life (EOL).",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure.cctv@hanwha.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hanwhavision.com/en/support/cybersecurity/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.hanwhavision.com/en/support/cybersecurity/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "South Korea"
+  },
+  {
+    "shortName": "CrowdStrike",
+    "cnaID": "CNA-2023-0044",
+    "organizationName": "CrowdStrike Holdings, Inc.",
+    "scope": "All CrowdStrike products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "bugs@crowdstrike.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.crowdstrike.com/report-a-security-bug/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.crowdstrike.com/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ProgressSoftware",
+    "cnaID": "CNA-2023-0045",
+    "organizationName": "Progress Software Corporation",
+    "scope": "Vulnerabilities in software published and maintained by Progress Software Corporation.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@progress.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.progress.com/security/vulnerability-reporting-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://community.progress.com/s/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "CERT-PL",
+    "cnaID": "CNA-2023-0046",
+    "organizationName": "CERT.PL",
+    "scope": "Vulnerabilities in software discovered by CERT.PL, and vulnerabilities reported to CERT.PL for coordinated disclosure, which are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cvd@cert.pl"
+          }
+        ],
+        "contact": [],
+        "form": [
+          {
+            "label": "CERT.PL contact form (Polish)",
+            "url": "https://incydent.cert.pl/#!/lang=pl,entityType=notObligatedEntity,easyIncidentType=vulnerability"
+          },
+          {
+            "label": "CERT.PL contact form (English)",
+            "url": "https://incydent.cert.pl/#!/lang=en,entityType=notObligatedEntity,easyIncidentType=vulnerability"
+          }
+        ]
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy (Polish)",
+        "language": "Polish",
+        "url": "https://cert.pl/cvd/"
+      },
+      {
+        "label": "Policy (English)",
+        "language": "English",
+        "url": "https://cert.pl/en/cvd/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories (Polish)",
+          "url": "https://cert.pl/cve/"
+        },
+        {
+          "label": "Advisories (English)",
+          "url": "https://cert.pl/en/cve/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Poland"
+  },
+  {
+    "shortName": "CISA",
+    "cnaID": "CNA-2023-0047",
+    "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)",
+    "scope": "<strong>Top-Level Root Scope:</strong> Vulnerabilities that are (1) reported to or observed by CISA and (2) affect critical infrastructure, U.S. civilian government, industrial control systems, or medical devices, and (3) are not covered by another CNA\u2019s scope.<br/><strong>ADP Scope:</strong> View scope <a href='/ProgramOrganization/ADPs#ActiveAdps'>here</a>.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [],
+        "form": [
+          {
+            "label": "Submit a Report",
+            "url": "https://www.cisa.gov/report"
+          }
+        ]
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.cisa.gov/coordinated-vulnerability-disclosure-process"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.cisa.gov/news-events/cybersecurity-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": true,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "type": [
+        "N/A"
+      ],
+      "TLR": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "reports to CVE Board",
+          "role": "Top-Level Root"
+        },
+        {
+          "helpText": "Authorized Data Publisher",
+          "role": "ADP"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "cisa-cg",
+    "cnaID": "CNA-2023-0048",
+    "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) U.S. Civilian Government",
+    "scope": "Vulnerabilities that are (1) reported to or observed by CISA, (2) affect critical infrastructure or U.S. civilian government, and (3) are not covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Submit a Report",
+            "url": "https://www.cisa.gov/report"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.cisa.gov/coordinated-vulnerability-disclosure-process"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.cisa.gov/news-events/cybersecurity-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "CERT"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Phoenix",
+    "cnaID": "CNA-2023-0049",
+    "organizationName": "Phoenix Technologies, Inc.",
+    "scope": "All Phoenix Technologies products (supported products and end-of-life/end-of-service products), as well as vulnerabilities in third-party software discovered by Phoenix Technologies that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Report a Security Vulnerability",
+            "url": "https://phoenixtech.com/report-a-security-vulnerability/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://phoenixtech.com/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://phoenixtech.com/security-notifications/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "VULSec",
+    "cnaID": "CNA-2023-0050",
+    "organizationName": "VULSec Labs",
+    "scope": "Vulnerabilities discovered by, or reported to, VULSec Labs that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Vulnerability Report Form",
+            "url": "https://www.vulsec.org/vulnerability-report"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.vulsec.org/conditions/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.vulsec.org/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Israel"
+  },
+  {
+    "shortName": "Mandiant",
+    "cnaID": "CNA-2023-0051",
+    "organizationName": "Mandiant Inc.",
+    "scope": "Vulnerabilities in Mandiant products or discovered by Mandiant while performing vulnerability research or security assessments, unless covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "mandiant-cve@google.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://about.google/intl/ALL_us/appsecurity/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/mandiant/Vulnerability-Disclosures"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "Google",
+        "organizationName": "Google LLC"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher",
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Everpure",
+    "cnaID": "CNA-2023-0052",
+    "organizationName": "Everpure, Inc.",
+    "scope": "Everpure (formerly Pure Storage, Inc.) products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@purestorage.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://support.purestorage.com/bundle/m_product_security_policy/page/Employee_Handbooks/Technical_Services/PSIRT/topics/concept/c_pure_storage_vulnerability_reporting_and_disclosure_policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.purestorage.com/bundle/m_security_bulletins/page/Pure_Security/topics/concept/c_security_bulletins.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "PSF",
+    "cnaID": "CNA-2023-0053",
+    "organizationName": "Python Software Foundation",
+    "scope": "Only supported and end-of-life Python versions available at <a href='https://python.org/downloads' target='_blank'>https://python.org/downloads</a> and pip versions available at <a href='https://pypi.org/project/pip' target='_blank'>https://pypi.org/project/pip</a>, Pallets projects available at <a href='https://github.com/pallets' target='_blank'>https://github.com/pallets</a> (such as Flask, Jinja, Click, MarkupSafe, Werkzeug, and ItsDangerous), and excluding distributions of Python, pip, and Pallets projects maintained by third-party redistributors.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@python.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.python.org/cve-numbering-authority/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://mail.python.org/archives/list/security-announce@python.org/latest"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "securin",
+    "cnaID": "CNA-2023-0054",
+    "organizationName": "Securin",
+    "scope": "Vulnerabilities found in Securin products and services (including end-of-life/end-of-service products), as well as vulnerabilities in third-party software discovered by Securin that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclose@securin.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.securin.io/disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.securin.io/discover-zero-days"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Nokia",
+    "cnaID": "CNA-2023-0055",
+    "organizationName": "Nokia",
+    "scope": "All vulnerabilities in Nokia products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-alert@nokia.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.nokia.com/notices/responsible-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.nokia.com/about-us/security-and-privacy/product-security-advisory/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Finland"
+  },
+  {
+    "shortName": "ICT",
+    "cnaID": "CNA-2023-0056",
+    "organizationName": "Integrated Control Technology LTD",
+    "scope": "All ICT security products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-disclosures@ict.co"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://ict.co/help-support/responsible-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://ict.co/help-support/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "New Zealand"
+  },
+  {
+    "shortName": "Xerox",
+    "cnaID": "CNA-2023-0057",
+    "organizationName": "Xerox Corporation",
+    "scope": "Xerox Corporation issues only.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Xerox Security Response Center",
+            "url": "https://forms.business.xerox.com/en-us/xerox-security-response-center/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security.business.xerox.com/vulnerability-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.business.xerox.com/en-us/documents/bulletins/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "SoftIron",
+    "cnaID": "CNA-2023-0058",
+    "organizationName": "SoftIron",
+    "scope": "SoftIron HyperCloud branded products and technologies only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@softiron.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://softiron.com/legal/security-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://advisories.softiron.cloud/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ADI",
+    "cnaID": "CNA-2023-0059",
+    "organizationName": "Analog Devices, Inc.",
+    "scope": "Vulnerabilities in ADI firmware and software products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "securityalert@analog.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.analog.com/en/support/technical-support/product-security-response-center/vulnerability-disclosure-policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.analog.com/en/support/technical-support/product-security-response-center.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "AlgoSec",
+    "cnaID": "CNA-2023-0060",
+    "organizationName": "AlgoSec",
+    "scope": "AlgoSec products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security.vulnerabilities@algosec.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.algosec.com/resources/guide/algosec-security-center/#:~:text=Frequently%20asked%20questions-,Overview,-At%20AlgoSec%2C%20we"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.algosec.com/resources/guide/algosec-security-center/#:~:text=05-,Security%20advisories,-List%20of%20CVEs"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Israel"
+  },
+  {
+    "shortName": "Canon_EMEA",
+    "cnaID": "CNA-2023-0061",
+    "organizationName": "Canon EMEA",
+    "scope": "Products, services, and solutions developed by Canon EMEA, Canon USA Inc., and those from IRIS, NT-ware, Onyx Graphics Inc., and Therefore Corporation, which are not under the Canon Brand.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product-security@canon-europe.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.canon-europe.com/psirt"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.canon-europe.com/psirt/advisory-information"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "UK"
+  },
+  {
+    "shortName": "Lexmark",
+    "cnaID": "CNA-2023-0063",
+    "organizationName": "Lexmark International Inc.",
+    "scope": "Lexmark products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "securityalerts@lexmark.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.lexmark.com/en_us/solutions/security/lexmark-security-advisories.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.lexmark.com/en_us/solutions/security/lexmark-security-advisories.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "KeeperSecurity",
+    "cnaID": "CNA-2023-0064",
+    "organizationName": "Keeper Security, Inc.",
+    "scope": "Keeper Security products and services only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@keepersecurity.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.keepersecurity.com/security.html?s=reporting"
+      },
+      {
+        "label": "Bounty Program Policy",
+        "language": "",
+        "url": "https://bugcrowd.com/keepersecurity"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.keeper.io/release-notes/keeper-security/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Caliptra",
+    "cnaID": "CNA-2023-0065",
+    "organizationName": "Caliptra Project",
+    "scope": "Caliptra Project components and vulnerabilities that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerabilities.caliptra-wg@lists.chipsalliance.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/chipsalliance/Caliptra/security/policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/chipsalliance/Caliptra/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "PaperCut",
+    "cnaID": "CNA-2023-0066",
+    "organizationName": "PaperCut Software Pty Ltd",
+    "scope": "PaperCut MF, PaperCut NG, PaperCut Hive, PaperCut Pocket, PaperCut Mobility Print, QRdoc, PaperCut Views, PaperCut Multiverse, <a href='https://www.papercut.com' target='_blank'>https://www.papercut.com</a>, and all other PaperCut products and services.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@papercut.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.papercut.com/contact/security/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.papercut.com/kb/Main/CommonSecurityQuestions"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "WrenSecurity",
+    "cnaID": "CNA-2023-0067",
+    "organizationName": "Wren Security",
+    "scope": "Wren Security maintained software.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclosure@wrensecurity.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://wrensecurity.org/community/disclosure.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Wren:IDM Advisories",
+          "url": "https://github.com/WrenSecurity/wrenidm/security"
+        },
+        {
+          "label": "Wren:AM Advisories",
+          "url": "https://github.com/WrenSecurity/wrenam/security"
+        },
+        {
+          "label": "Wren:DS Advisories",
+          "url": "https://github.com/WrenSecurity/wrends/security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "Czech Republic"
+  },
+  {
+    "shortName": "KCFTech",
+    "cnaID": "CNA-2023-0068",
+    "organizationName": "KCF Technologies, Inc.",
+    "scope": "All KCF Technologies products including base stations, repeaters, numerous sensor types, and the SMARTdiagnostics cloud software.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@kcftech.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://kcftech.com/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://status.kcftech.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "YokogawaGroup",
+    "cnaID": "CNA-2023-0069",
+    "organizationName": "Yokogawa Group",
+    "scope": "Yokogawa Group companies\u2019 products and Yokogawa Group subsidiaries\u2019 products.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [],
+        "form": [
+          {
+            "label": "Yokogawa Report Vulnerability form",
+            "url": "https://contact.yokogawa.com/cs/gw?c-id=000983"
+          }
+        ]
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.yokogawa.com/solutions/products-and-services/announcements/vulpolicy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Yokogawa Electric Corporation Advisories",
+          "url": "https://www.yokogawa.com/library/resources/white-papers/yokogawa-security-advisory-report-list/"
+        },
+        {
+          "label": "Yokogawa Test & Measurement Corporation Advisories",
+          "url": "https://www.yokogawa.com/ymi/important-notice-about-the-product/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "jpcert",
+        "organizationName": "JPCERT/CC"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "libreswan",
+    "cnaID": "CNA-2023-0070",
+    "organizationName": "Libreswan Project",
+    "scope": "Libreswan software.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@libreswan.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://libreswan.org/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://libreswan.org/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "n/a"
+  },
+  {
+    "shortName": "NX",
+    "cnaID": "CNA-2023-0071",
+    "organizationName": "Network Optix",
+    "scope": "All Network Optix products, including <a href='https://www.networkoptix.com/nx-witness' target='_blank'>https://www.networkoptix.com/nx-witness</a> and <a href='https://www.networkoptix.com/powered-by-nx' target='_blank'>https://www.networkoptix.com/powered-by-nx</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@networkoptix.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.networkoptix.com/vulnerability-disclosure-program"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.networkoptix.com/blog"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Dfinity",
+    "cnaID": "CNA-2023-0072",
+    "organizationName": "DFINITY Foundation",
+    "scope": "All Internet Computer projects as found on the following GitHub pages: <a href='https://github.com/dfinity' target='_blank'>https://github.com/dfinity</a> and <a href='https://github.com/dfinity-lab' target='_blank'>https://github.com/dfinity-lab</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-cna@dfinity.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/dfinity/ic/security/policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://internetcomputer.org/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "SEC-VLab",
+    "cnaID": "CNA-2023-0073",
+    "organizationName": "SEC Consult Vulnerability Lab",
+    "scope": "All vulnerabilities discovered in third-party hardware/software by SEC Consult Vulnerability Lab (part of SEC Consult, an Eviden business), which are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-research@sec-consult.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://sec-consult.com/vulnerability-lab/responsible-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://sec-consult.com/vulnerability-lab/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "Austria"
+  },
+  {
+    "shortName": "Armis",
+    "cnaID": "CNA-2023-0074",
+    "organizationName": "Armis, Inc.",
+    "scope": "All Armis products, as well as vulnerabilities in third-party software discovered by Armis that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@armis.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.armis.com/legal-compliance/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.armis.com/legal-compliance/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "SmileDigitalHealth",
+    "cnaID": "CNA-2023-0075",
+    "organizationName": "Smile CDR Inc. (doing business as \u201cSmile Digital Health\u201d)",
+    "scope": "All Smile Digital Health products and HAPI FHIR.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@smiledigitalhealth.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.smiledigitalhealth.com/responsible-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.smiledigitalhealth.com/legal/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "Canada"
+  },
+  {
+    "shortName": "WSO2",
+    "cnaID": "CNA-2023-0076",
+    "organizationName": "WSO2 LLC",
+    "scope": "WSO2 products and services scoped under Responsible Disclosure Program <a href='https://security.docs.wso2.com/en/latest/security-reporting/reward-and-acknowledgement-program/#products-services-in-scope' target='_blank'>https://security.docs.wso2.com/en/latest/security-reporting/reward-and-acknowledgement-program/#products-services-in-scope</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@wso2.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security.docs.wso2.com/en/latest/security-reporting/reward-and-acknowledgement-program/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.docs.wso2.com/en/latest/security-announcements/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Hosted Service"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ARCON",
+    "cnaID": "CNA-2023-0077",
+    "organizationName": "ARCON Techsolutions Private Limited",
+    "scope": "Vulnerabilities in ARCON\u2019s products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product.security@arconnet.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://arconnet.com/product-security-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://arconnet.com/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "India"
+  },
+  {
+    "shortName": "Checkmarx",
+    "cnaID": "CNA-2023-0078",
+    "organizationName": "Checkmarx",
+    "scope": "Vulnerabilities in Checkmarx products and open source vulnerabilities discovered by, or reported to, Checkmarx, that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "oss-report@checkmarx.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://devhub.checkmarx.com/disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://advisory.checkmarx.net/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ]
+    },
+    "country": "Israel"
+  },
+  {
+    "shortName": "ASR",
+    "cnaID": "CNA-2023-0079",
+    "organizationName": "ASR Microelectronics Co., Ltd.",
+    "scope": "ASR products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product-security@asrmicro.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.asrmicro.com/en/goods/policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.asrmicro.com/en/goods/psirt"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "Ciena",
+    "cnaID": "CNA-2023-0080",
+    "organizationName": "Ciena Corporation",
+    "scope": "Ciena and Blue Planet branded products and technologies only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@ciena.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.ciena.com/__data/assets/pdf_file/0026/128933/Notice-of-Vulnerability-Disclosure-Policy-VDP.pdf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.ciena.com/product-security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Zohocorp",
+    "cnaID": "CNA-2023-0081",
+    "organizationName": "Zohocorp",
+    "scope": "ManageEngine, Zoho, and Zakya branded on-premise products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@zohocorp.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://bugbounty.zohocorp.com/bb/info"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.manageengine.com/security/advisory/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "India"
+  },
+  {
+    "shortName": "Fortra",
+    "cnaID": "CNA-2023-0082",
+    "organizationName": "Fortra, LLC",
+    "scope": "All Fortra products and vulnerabilities discovered by Fortra in other products not covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security.reports@fortra.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.fortra.com/security/policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.fortra.com/security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "EDB",
+    "cnaID": "CNA-2023-0083",
+    "organizationName": "EnterpriseDB Corporation",
+    "scope": "All EnterpriseDB products and vulnerabilities identified in open source libraries used by EnterpriseDB products unless covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclosures@enterprisedb.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.enterprisedb.com/docs/security/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.enterprisedb.com/docs/security/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "HiddenLayer",
+    "cnaID": "CNA-2023-0084",
+    "organizationName": "HiddenLayer, Inc.",
+    "scope": "All HiddenLayer systems, services, and products, as well as vulnerabilities in third-party software discovered by HiddenLayer that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclosure@hiddenlayer.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://hiddenlayer.com/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://hiddenlayer.com/research/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "arcinfo",
+    "cnaID": "CNA-2023-0085",
+    "organizationName": "ARC Informatique",
+    "scope": "ARC Informatique products and services.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@arcinfo.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.pcvue.com/policies/vuln_disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.pcvue.com/security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "ConcreteCMS",
+    "cnaID": "CNA-2024-0001",
+    "organizationName": "Concrete CMS",
+    "scope": "Concrete CMS Core versions 8.5 and above.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@concretecms.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.concretecms.org/security"
+      },
+      {
+        "label": "HackerOne Policy",
+        "language": "",
+        "url": "https://hackerone.com/concretecms?type=team"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.concretecms.org/about/project-news/security"
+        },
+        {
+          "label": "Disclosed CVEs",
+          "url": "https://docs.google.com/spreadsheets/d/1lduRBavCZYnKPyPRUhaUNGP2Fza-5SE6MJoAcMSvqSQ/edit#gid=0"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Pentraze",
+    "cnaID": "CNA-2024-0002",
+    "organizationName": "Pentraze Cybersecurity",
+    "scope": "Vulnerabilities in third-party software discovered by Pentraze Cybersecurity that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@pentraze.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://pentraze.com/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://pentraze.com/vulnerability-reports/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "Dominican Republic"
+  },
+  {
+    "shortName": "ELAN",
+    "cnaID": "CNA-2024-0003",
+    "organizationName": "ELAN Microelectronics Corp.",
+    "scope": "ELAN issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@emc.com.tw"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.emc.com.tw/emc/tw/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Touchpad Solutions Advisories",
+          "url": "https://www.emc.com.tw/emc/en/Product/Solution/TouchpadSolutions"
+        },
+        {
+          "label": "Biometric Solutions Advisories",
+          "url": "https://www.emc.com.tw/emc/en/Product/Solution/BiometricSolutions"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "ChromeOS",
+    "cnaID": "CNA-2024-0004",
+    "organizationName": "ChromeOS Project",
+    "scope": "Vulnerabilities that are (1) reported to ChromeOS Security, (2) affect ChromeOS device software and hardware, including our open source dependencies, and (3) are not covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "chromeos-security@chromium.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.google.com/about/appsecurity/research/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://chromereleases.googleblog.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "Google",
+        "organizationName": "Google LLC"
+      },
+      "type": [
+        "Vendor",
+        "Bug Bounty Provider"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "PostgreSQL",
+    "cnaID": "CNA-2024-0005",
+    "organizationName": "PostgreSQL",
+    "scope": "<a href='https://www.postgresql.org/download/' target='_blank'>postgresql.org/download</a> software and related projects listed at <a href='https://www.postgresql.org/support/security/' target='_blank'>postgresql.org/support/security</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@postgresql.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.postgresql.org/support/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.postgresql.org/support/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Canada"
+  },
+  {
+    "shortName": "curl",
+    "cnaID": "CNA-2024-0006",
+    "organizationName": "curl",
+    "scope": "All products made and managed by the curl project. This includes curl, libcurl, and trurl.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@curl.se"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://curl.se/dev/vuln-disclosure.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://curl.se/docs/security.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Sweden"
+  },
+  {
+    "shortName": "milestonesys",
+    "cnaID": "CNA-2024-0007",
+    "organizationName": "Milestone Systems A/S",
+    "scope": "Supported Milestone XProtect products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@milestonesys.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://doc.milestonesys.com/latest/en-US/portal/htm/chapter-page-cve-vulnerabilitymanagementpolicy.htm"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://supportcommunity.milestonesys.com/s/knowledgebase?language=en_US"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Denmark"
+  },
+  {
+    "shortName": "ENISA",
+    "cnaID": "CNA-2024-0008",
+    "organizationName": "EU Agency for Cybersecurity (ENISA)",
+    "scope": "<strong>Root Scope:</strong> European Union (EU) member states/EU authorities, EU CSIRTs network members, and cooperative partners under ENISA\u2019s mandate as well as other CNAs who choose ENISA as their Root.<br/><br/><strong>CNA Scope:</strong> Vulnerabilities in information technology (IT) products discovered by European Union (EU) Computer Security Incident Response Teams (CSIRTs) or reported to ENISA or to EU CSIRTs for coordinated disclosure, as long as they do not fall under a CNA with a more specific scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vuln@enisa.europa.eu"
+          }
+        ],
+        "contact": [
+          {
+            "label": "EU CSIRTs network contacts",
+            "url": "https://github.com/enisaeu/CNW/tree/main#vulnerability-disclosure-policies"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://csirtsnetwork.eu/homepage?tab=cvd"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/enisaeu/CNW/tree/main/advisories"
+        },
+        {
+          "label": "Vulnerability List",
+          "url": "https://euvd.enisa.europa.eu/search?assigner=ENISA"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "Root"
+        },
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Consortium"
+      ]
+    },
+    "country": "Greece"
+  },
+  {
+    "shortName": "Sonatype",
+    "cnaID": "CNA-2024-0009",
+    "organizationName": "Sonatype Inc.",
+    "scope": "All Sonatype products and vulnerabilities in third-party software discovered by Sonatype that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@sonatype.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://help.sonatype.com/en/responsible-disclosure.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.sonatype.com/hc/en-us/sections/203012668-Security-Advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ERIC",
+    "cnaID": "CNA-2024-0010",
+    "organizationName": "Ericsson",
+    "scope": "Ericsson issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@ericsson.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.ericsson.com/en/about-us/security/ericsson-product-security-and-vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.ericsson.com/en/about-us/security/security-bulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Sweden"
+  },
+  {
+    "shortName": "tlt_net",
+    "cnaID": "CNA-2024-0011",
+    "organizationName": "Teltonika Networks",
+    "scope": "Teltonika Networks products and services only.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Teltonika Networks Security Center",
+            "url": "https://teltonika-networks.com/support/security-center"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://teltonika-networks.com/support/security-center"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://teltonika-networks.com/support/security-center"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Lithuania"
+  },
+  {
+    "shortName": "FSI",
+    "cnaID": "CNA-2024-0012",
+    "organizationName": "Financial Security Institute (FSI)",
+    "scope": "Vulnerability assignment related to FSI\u2019s vulnerability coordination role in the South Korea financial sector that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vuln@fsec.or.kr"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.fsec.or.kr/bbs/detail?menuNo=1010&bbsNo=11403"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.fsec.or.kr/bbs/1010"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "CERT",
+        "Researcher",
+        "Bug Bounty Provider"
+      ]
+    },
+    "country": "South Korea"
+  },
+  {
+    "shortName": "glibc",
+    "cnaID": "CNA-2024-0013",
+    "organizationName": "GNU C Library",
+    "scope": "Security issues and vulnerabilities in the GNU C Library.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "glibc-cna@sourceware.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://sourceware.org/glibc/security.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://sourceware.org/git/?p=glibc.git;a=tree;f=advisories;hb=HEAD"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "BT",
+    "cnaID": "CNA-2024-0015",
+    "organizationName": "BeyondTrust Inc.",
+    "scope": "All BeyondTrust products, including <a href='https://www.beyondtrust.com/products/password-safe' target='_blank'>PasswordSafe</a>, <a href='https://www.beyondtrust.com/products/privileged-remote-access' target='_blank'>Privileged Remote Access</a>, <a href='https://www.beyondtrust.com/products/remote-support' target='_blank'>Remote Support</a>, <a href='https://www.beyondtrust.com/products/privilege-management-for-windows-and-mac' target='_blank'>Privilege Management for Windows/Mac</a>, <a href='https://www.beyondtrust.com/products/privilege-management-for-unix-and-linux' target='_blank'>Privilege Management for Unix/Linux</a>, <a href='https://www.beyondtrust.com/products/identity-security-insights' target='_blank'>Identity Security Insights</a>, <a href='https://www.beyondtrust.com/products/active-directory-bridge' target='_blank'>Active Directory (AD) Bridge</a>, and <a href='https://www.beyondtrust.com/products/total-pasm' target='_blank'>Total PASM</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@beyondtrust.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.beyondtrust.com/disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.beyondtrust.com/trust-center/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Linux",
+    "cnaID": "CNA-2024-0016",
+    "organizationName": "kernel.org",
+    "scope": "Any vulnerabilities in the Linux kernel as listed on kernel.org, excluding end-of-life (EOL) versions.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@kernel.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.kernel.org/doc/html/latest/process/security-bugs.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://lore.kernel.org/linux-cve-announce/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "DevCycle",
+    "cnaID": "CNA-2024-0017",
+    "organizationName": "DevCycle",
+    "scope": "All DevCycle products (including end-of-life/end-of-service products) as listed on <a href='https://devcycle.com/' target='_blank'>https://devcycle.com/</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@devcycle.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/DevCycleHQ/.github/blob/main/.github/SECURITY.md"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/DevCycleHQ/.github/blob/main/.github/SECURITY.md#previous-vulnerabilities-reported"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service",
+        "Open Source"
+      ]
+    },
+    "country": "Canada"
+  },
+  {
+    "shortName": "directcyber",
+    "cnaID": "CNA-2024-0018",
+    "organizationName": "DirectCyber",
+    "scope": "Issues in third-party products identified by or reported to DirectCyber, unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "report@directcyber.com.au"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://directcyber.com.au/report.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://directcyber.com.au/advisory.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher",
+        "Open Source"
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "sec1",
+    "cnaID": "CNA-2024-0019",
+    "organizationName": "Sec1",
+    "scope": "Vulnerabilities found in cybersecurity software solutions developed and maintained by Sec1 as listed on <a href='https://sec1.io/' target='_blank'>https://sec1.io/</a>, and vulnerabilities identified in software projects or products where Sec1 has a direct and substantial contribution or partnership, unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@sec1.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://sec1.io/sec1-public-disclosure-policy-for-cve-reporting/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://sec1.io/sec1-security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "India"
+  },
+  {
+    "shortName": "TECNOMobile",
+    "cnaID": "CNA-2024-0020",
+    "organizationName": "TECNO Mobile Limited",
+    "scope": "Vulnerabilities in TECNO products and services only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security.tecno@tecno-mobile.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security.tecno.com"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.tecno.com/SRC/blog"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "CoolKit",
+    "cnaID": "CNA-2024-0021",
+    "organizationName": "SHENZHEN CoolKit Technology CO., LTD.",
+    "scope": "Products of eWeLink Solutions only, details are available at <a href='https://ewelink.cc/our-projects-scope/' target='_blank'>https://ewelink.cc/our-projects-scope/</a>.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "eWeLink Security Report Center",
+            "url": "https://ewelink.cc/security-report-center/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://ewelink.cc/wp-content/uploads/2022/04/eWeLinks-Vulnerability-Disclosure-Policy.pdf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://ewelink.cc/security-advisories-and-notices/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "openam-jp",
+    "cnaID": "CNA-2024-0022",
+    "organizationName": "OpenAM Consortium",
+    "scope": "Open source projects hosted on <a href='https://github.com/openam-jp' target='_blank'>https://github.com/openam-jp</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerability@openam.jp"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://openam-jp.github.io/Disclosure-Policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://openam-jp.github.io/Advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "jpcert",
+        "organizationName": "JPCERT/CC"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source",
+        "Consortium"
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "rami.io",
+    "cnaID": "CNA-2024-0023",
+    "organizationName": "rami.io GmbH",
+    "scope": "All rami.io GmbH products and open source projects, including pretix, official pretix plugins and apps, and Venueless.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@rami.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://rami.io/security/disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://rami.io/security/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service",
+        "Open Source"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Dremio",
+    "cnaID": "CNA-2024-0024",
+    "organizationName": "Dremio Corporation",
+    "scope": "All Dremio Corporation products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@dremio.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.dremio.com/platform/security/responsible-disclosure-limitations/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.dremio.com/current/reference/bulletins/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "JAMF",
+    "cnaID": "CNA-2024-0025",
+    "organizationName": "Jamf",
+    "scope": "Jamf issues and Jamf Open Source.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productsecurity@jamf.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.jamf.com/security/vulnerability-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories in Resolved Issues",
+          "url": "https://learn.jamf.com/en-US/bundle/jamf-pro-release-notes-current/page/Resolved_Issues.html"
+        },
+        {
+          "label": "Advisories in Release History",
+          "url": "https://learn.jamf.com/en-US/bundle/jamf-infrastructure-manager-ldap-proxy-install-guide/page/Release_History.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Edgewatch",
+    "cnaID": "CNA-2024-0026",
+    "organizationName": "Edgewatch Security Intelligence",
+    "scope": "Vulnerabilities in third-party software discovered by Edgewatch that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@edgewatch.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://edgewatch.com/legal/disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://edgewatch.com/vulnerability-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "type": [
+        "Hosted Service",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "cirosec",
+    "cnaID": "CNA-2024-0027",
+    "organizationName": "cirosec GmbH",
+    "scope": "Vulnerabilities discovered by or reported to cirosec researchers that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-request@cirosec.de"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "German",
+        "url": "https://cirosec.de/cirosec-responsible-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cirosec.de/en/blog/#vulnerabilities"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Microchip",
+    "cnaID": "CNA-2024-0028",
+    "organizationName": "Microchip Technology",
+    "scope": "Microchip Technology products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@microchip.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://microchip.com/psirt"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://microchip.com/psirt"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Tego_Cyber",
+    "cnaID": "CNA-2024-0029",
+    "organizationName": "Tego Cyber, Inc.",
+    "scope": "Tego Cyber issues and vulnerabilities discovered by Tego in third-party products, unless covered under the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@tegocyber.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://tegocyber.com/security/vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://tegocyber.com/security/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "N-able",
+    "cnaID": "CNA-2024-0030",
+    "organizationName": "N-able",
+    "scope": "N-able branded products and technologies only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@n-able.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.n-able.com/security-and-privacy/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://me.n-able.com/s/global-search/%40uri#t=All&amp;sort=relevancy&amp;f:@repositorytype=[Security_Advisory]"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "OS-S",
+    "cnaID": "CNA-2024-0031",
+    "organizationName": "OpenSource Security GmbH",
+    "scope": "Vulnerabilities discovered by or reported to OpenSource Security, unless covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@os-s.de"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://os-s.net/en/research/responsible-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://os-s.net/en/publications/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "TXOne",
+    "cnaID": "CNA-2024-0032",
+    "organizationName": "TXOne Networks, Inc.",
+    "scope": "Vulnerabilities in TXOne Networks products, including end-of-life products, or third-party operational technology (OT) and industrial control systems (ICS) products, unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@txone.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.txone.com/psirt/disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.txone.com/psirt/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "SCIEX",
+    "cnaID": "CNA-2024-0033",
+    "organizationName": "SCIEX",
+    "scope": "SCIEX branded products only.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "SCIEX Support",
+            "url": "https://sciex.com/support"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://sciex.com/support/product-security/coordinated-vulnerabilities-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://sciex.com/support/product-security/known-vulnerabilities"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "LMS",
+    "cnaID": "CNA-2024-0034",
+    "organizationName": "Leica Microsystems",
+    "scope": "Leica Microsystems products as listed on <a href='https://www.leica-microsystems.com/products' target='_blank'>https://www.leica-microsystems.com/products</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productsecurity@leica-microsystems.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.leica-microsystems.com/company/product-security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.leica-microsystems.com/company/product-security/product-security-updates/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "vx",
+    "cnaID": "CNA-2024-0035",
+    "organizationName": "VotingWorks",
+    "scope": "Vulnerabilities in VotingWorks voting systems, hardware, and software.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@voting.works"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/votingworks/vxsuite?tab=security-ov-file"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/votingworks/vxsuite/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ConnectWise",
+    "cnaID": "CNA-2024-0036",
+    "organizationName": "ConnectWise LLC",
+    "scope": "All ConnectWise products and services and vulnerabilities discovered by ConnectWise in third party products that are not within another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclosure@connectwise.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Trust Center",
+            "url": "https://www.connectwise.com/company/trust"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.connectwise.com/company/trust/security/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Bulletins",
+          "url": "https://www.connectwise.com/company/trust/security-bulletins"
+        },
+        {
+          "label": "Advisories",
+          "url": "https://www.connectwise.com/company/trust/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ClickHouse",
+    "cnaID": "CNA-2024-0037",
+    "organizationName": "ClickHouse, Inc.",
+    "scope": "ClickHouse-owned products, not including end-of-life components.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@clickhouse.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/ClickHouse/ClickHouse/security/policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://clickhouse.com/docs/en/whats-new/security-changelog"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "sba-research",
+    "cnaID": "CNA-2024-0038",
+    "organizationName": "SBA Research gGmbH",
+    "scope": "Vulnerabilities discovered by SBA Research or reported to SBA Research by partner organizations that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@sba-research.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.sba-research.org/about/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/sbaresearch/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "Austria"
+  },
+  {
+    "shortName": "WindRiver",
+    "cnaID": "CNA-2024-0039",
+    "organizationName": "Wind River Systems Inc.",
+    "scope": "All Wind River branded products as found on <a href='https://windriver.com' target='_blank'>windriver.com</a> including vulnerabilities in natively developed or modified product incorporated components, and only product incorporated third-party components not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "PSIRT@windriver.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.windriver.com/psirt-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.windriver.com/security/vulnerability-responses"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "KoreLogic",
+    "cnaID": "CNA-2024-0040",
+    "organizationName": "KoreLogic Security",
+    "scope": "Vulnerabilities in the KoreLogic website and other KoreLogic controlled assets, as well as vulnerabilities discovered by or reported to KoreLogic, unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclosures@korelogic.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://korelogic.com/KoreLogic-Public-Vulnerability-Disclosure-Policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://korelogic.com/advisories.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "HeroDevs",
+    "cnaID": "CNA-2024-0041",
+    "organizationName": "HeroDevs",
+    "scope": "End of life open source projects supported by HeroDevs if hosted on <a href='https://HeroDevs.com' target='_blank'>HeroDevs.com</a>, or issues in open source projects discovered by or reported to HeroDevs, unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclosures@herodevs.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://docs.herodevs.com/policies/security-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.herodevs.com/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Kong",
+    "cnaID": "CNA-2024-0042",
+    "organizationName": "Kong Inc.",
+    "scope": "Kong products; Kong Konnect, Kong Enterprise, Kong Mesh, and Kong Insomnia, including Kong Opensource; Kong Gateway, Kuma, Insomnia.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerability@konghq.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://konghq.com/compliance/bug-bounty"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://konghq.com/compliance/psa"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "upKeeper",
+    "cnaID": "CNA-2024-0043",
+    "organizationName": "upKeeper Solutions",
+    "scope": "All upKeeper Solutions products, excluding end-of-life (EOL) as listed in the upKeeper Solutions End of Life Policy.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@upkeeper.se"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://support.upkeeper.se/hc/en-us/articles/14123589368092-Coordinated-Vulnerability-Disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.upkeeper.se/hc/en-us/articles/14170844051868-Security-Advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Sweden"
+  },
+  {
+    "shortName": "Cato",
+    "cnaID": "CNA-2024-0044",
+    "organizationName": "Cato Networks",
+    "scope": "All Cato Networks products and vulnerabilities in third-party products affecting Cato products unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerability-report@catonetworks.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://event.catonetworks.com/securityissuesreport"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://securityadvisories.catonetworks.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "Israel"
+  },
+  {
+    "shortName": "AMZN",
+    "cnaID": "CNA-2024-0045",
+    "organizationName": "Amazon",
+    "scope": "All Amazon and AWS products (including subsidiaries, supported, and EOL/EOS products), as well as vulnerabilities in third party software discovered by Amazon/AWS that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "aws-security@amazon.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://aws.amazon.com/security/vulnerability-reporting"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://aws.amazon.com/security/security-bulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Bug Bounty Provider",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "RealPage",
+    "cnaID": "CNA-2024-0046",
+    "organizationName": "RealPage",
+    "scope": "Vulnerabilities in RealPage products and services including but not limited to: Keyready, Knock CRM, HomeWiseDocs, REDS (Real Estate Data Solutions), G5, WhiteSky Communications, Chirp Systems, STRATIS IoT, Modern Message (Community Rewards), Hipercept, Investor Management Services, AIM, FUEL, Buildium, All Property Management, SimpleBills, DepositIQ, Rentlytics, ClickPay, LeaseLabs, PEX, On-Site, American Utility Management (AUM), Axiometrics, Lease Rent Optimization (LRO), AssetEye, NWP Services Corporation, Indatus, ActiveBuilding, RentMineOnline (RMO), MyNewPlace, Compliance Depot, SeniorLiving.net, eREI, Domin-8, Level One, Propertyware, Opstechnology, LeasingDesk, and YieldStar.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "responsibledisclosure@realpage.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.realpage.com/support/security/responsible-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.realpage.com/support/security/responsible-disclosure/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Huntress",
+    "cnaID": "CNA-2024-0047",
+    "organizationName": "Huntress Labs Inc.",
+    "scope": "All Huntress products, as well as vulnerabilities in third-party software discovered by Huntress that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-disclosures@huntresslabs.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://support.huntress.io/hc/en-us/categories/10962594482579-Vulnerability-Disclosures"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.huntress.io/hc/en-us/categories/10962594482579-Vulnerability-Disclosures"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Forescout",
+    "cnaID": "CNA-2024-0048",
+    "organizationName": "Forescout Technologies",
+    "scope": "Vulnerabilities in Forescout products and vulnerabilities in other products discovered by Forescout that are not in another CNA's scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@forescout.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.forescout.com/security-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.forescout.com/bundle/vulnerabilities/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "9front",
+    "cnaID": "CNA-2024-0049",
+    "organizationName": "9front Systems",
+    "scope": "All software produced as part of the Plan9front open source operating system, as well as its applications and cyberinfrastructure. Vulnerabilities discovered by or reported to 9front Systems for all Plan 9 software not covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "bugs@9front.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "http://bugs.9front.org/disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "http://bugs.9front.org/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ivanti",
+    "cnaID": "CNA-2024-0050",
+    "organizationName": "Ivanti",
+    "scope": "Vulnerabilities in supported Ivanti products and infrastructure, excluding third-party components, and meeting severity thresholds defined in Ivanti\u2019s Disclosure Policy found <a href='https://www.ivanti.com/support/contact-security' target='_blank'>here</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "responsible.disclosure@ivanti.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.ivanti.com/support/contact-security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.ivanti.com/blog/topics/security-advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "imaginationtech",
+    "cnaID": "CNA-2024-0051",
+    "organizationName": "Imagination Technologies",
+    "scope": "Imagination Technologies branded products and technologies and Imagination Technologies (IMG) managed open source projects.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product.security@imgtec.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.imaginationtech.com/product-security-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.imaginationtech.com/gpu-driver-vulnerabilities/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "UK"
+  },
+  {
+    "shortName": "Intigriti",
+    "cnaID": "CNA-2024-0052",
+    "organizationName": "Intigriti",
+    "scope": "Vulnerabilities in Intigriti products and vulnerabilities discovered by, or reported to, Intigriti that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@intigriti.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://app.intigriti.com/programs/intigriti/intigriti/detail"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://trust.intigriti.com/resources"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Bug Bounty Provider",
+        "Hosted Service",
+        "Vendor"
+      ]
+    },
+    "country": "Belgium"
+  },
+  {
+    "shortName": "Stryker",
+    "cnaID": "CNA-2024-0053",
+    "organizationName": "Stryker Corporation",
+    "scope": "All products of Stryker or a Stryker company including end-of-life/end-of-service products, and vulnerabilities in third-party software used in Stryker products that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productsecurity@stryker.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.stryker.com/us/en/about/governance/cyber-security.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.stryker.com/us/en/about/governance/cyber-security/product-security.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "watchdog",
+    "cnaID": "CNA-2024-0054",
+    "organizationName": "WatchDogDevelopment.com, LLC",
+    "scope": "All WatchDog products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@watchdog.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://watchdog.com/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://watchdog.com/vulnerability-disclosure-policy/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Proton",
+    "cnaID": "CNA-2024-0056",
+    "organizationName": "Proton AG",
+    "scope": "Proton AG issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "Security@proton.me"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://proton.me/security/vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://proton.me/security/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "Wiz",
+    "cnaID": "CNA-2024-0057",
+    "organizationName": "Wiz, Inc.",
+    "scope": "Vulnerabilities identified in Wiz products, and vulnerabilities discovered by, or reported to, Wiz that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@wiz.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.wiz.io/security-disclosures"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.wiz.io/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Supermicro",
+    "cnaID": "CNA-2024-0058",
+    "organizationName": "Super Micro Computer, Inc.",
+    "scope": "Supermicro branded products, managed system, or software projects.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@supermicro.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.supermicro.com/en/support/security_center#!report"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.supermicro.com/en/support/security_center#!advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "MON-CSIRT",
+    "cnaID": "CNA-2024-0059",
+    "organizationName": "Monash University - Cyber Security Incident Response Team",
+    "scope": "Vulnerabilities in any Monash University developed products, or vulnerabilities identified in third-party vendor products used by Monash University, unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@monash.edu"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.monash.edu/cybersecurity/about/mon-csirt"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.monash.edu/cybersecurity/about/mon-csirt"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "CERT",
+        "Open Source",
+        "Researcher"
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "seal",
+    "cnaID": "CNA-2024-0060",
+    "organizationName": "Seal Security",
+    "scope": "Vulnerabilities in Seal products or services and vulnerabilities discovered in open source libraries unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@sealsecurity.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://docs.sealsecurity.io/vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://app.sealsecurity.io/repository"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Cytiva",
+    "cnaID": "CNA-2024-0061",
+    "organizationName": "Cytiva",
+    "scope": "Cytiva branded products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cytiva_productsecurity@cytiva.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.cytivalifesciences.com/en/se/product-security/disclosure-process"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.cytivalifesciences.com/en/se/product-security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Arxscan",
+    "cnaID": "CNA-2024-0062",
+    "organizationName": "Arxscan, Inc.",
+    "scope": "Arxscan issues only.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Arxscan Report a Vulnerability page",
+            "url": "https://arxscan.com/cybersecurity-vulnerability-policy/report-a-vulnerability"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://arxscan.com/cybersecurity-vulnerability-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://arxscan.com/cybersecurity-vulnerability-policy/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "PlexTrac",
+    "cnaID": "CNA-2024-0063",
+    "organizationName": "PlexTrac, Inc.",
+    "scope": "Vulnerabilities within PlexTrac\u2019s products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@plextrac.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://plextrac.com/vulnerability-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.plextrac.com/plextrac-documentation/master/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ASUS",
+    "cnaID": "CNA-2024-0064",
+    "organizationName": "ASUSTeK Computer Incorporation",
+    "scope": "ASUS issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@asus.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.asus.com/content/asus-product-security-advisory/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.asus.com/content/asus-product-security-advisory/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "Pall",
+    "cnaID": "CNA-2024-0065",
+    "organizationName": "Pall Corporation",
+    "scope": "Pall branded products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productsecurity@pall.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.pall.com/en/about-pall/product-security-cvd.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.pall.com/en/about-pall/product-security-cvd/known-vulnerabilities.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "MyMMT",
+    "cnaID": "CNA-2024-0066",
+    "organizationName": "Mammotome",
+    "scope": "All Mammotome products.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Mammotome Report a Vulnerability page",
+            "url": "https://www.mammotome.com/us/en/legal/product-security/report-a-security-vulnerability"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.mammotome.com/us/en/legal/product-security/product-security-overview"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.mammotome.com/us/en/legal/product-security/product-security-updates"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "wikimedia-foundation",
+    "cnaID": "CNA-2024-0067",
+    "organizationName": "The Wikimedia Foundation",
+    "scope": "Any code repository hosted under <a href='https://gerrit.wikimedia.org' target='_blank'>gerrit.wikimedia.org</a>, <a href='https://gitlab.wikimedia.org' target='_blank'>gitlab.wikimedia.org</a>, or <a href='https://github.com/wikimedia' target='_blank'>github.com/wikimedia</a> that is not labeled as archived or marked as a fork of an upstream project. Please see our <a href='https://www.mediawiki.org/wiki/Reporting_security_bugs' target='_blank'>disclosure policy</a> for additional exclusions to scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@wikimedia.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.mediawiki.org/wiki/Reporting_security_bugs"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://gitlab.wikimedia.org/repos/security/wikimedia-cve-assignments"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "RTI",
+    "cnaID": "CNA-2024-0068",
+    "organizationName": "Real-Time Innovations, Inc.",
+    "scope": "All RTI Connext products, including EOL products. See <a href='https://www.rti.com/products' target='_blank'>https://www.rti.com/products</a> for more information.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@rti.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://community.rti.com/static/documentation/connext-dds/current/doc/vulnerabilities/#rti-s-approach-to-vulnerability-detection-and-management"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://community.rti.com/static/documentation/connext-dds/current/doc/vulnerabilities/#"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "PingCAP",
+    "cnaID": "CNA-2024-0069",
+    "organizationName": "PingCAP (US), Inc.",
+    "scope": "Vulnerabilities in the following PingCAP maintained products and components: TiDB (code available at <a href='https://github.com/pingcap/tidb' target='_blank'>https://github.com/pingcap/tidb</a>); TiKV (code available at <a href='https://github.com/tikv/tikv' target='_blank'>https://github.com/tikv/tikv</a>); PD (Placement Driver, code available at <a href='https://github.com/tikv/pd' target='_blank'>https://github.com/tikv/pd</a>); TiFlash (code available at <a href='https://github.com/pingcap/tiflash' target='_blank'>https://github.com/pingcap/tiflash</a>); and tidbcloud (PingCAP\u2019s cloud database service). This scope includes vulnerabilities in all supported versions of these products. CVE IDs will not be assigned for vulnerabilities found in unsupported versions or for third-party dependencies not maintained by PingCAP.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@pingcap.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.pingcap.com/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.pingcap.com/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Hosted Service"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "OMRON",
+    "cnaID": "CNA-2024-0070",
+    "organizationName": "OMRON Corporation",
+    "scope": "Omron Group companies\u2019 Industrial Automation, Healthcare, Social Systems, Device &amp; Module Solutions issues only.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "OMRON PSIRT Contact page",
+            "url": "https://www.omron.com/contact/ContactForm.do?FID=00282"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.omron.com/contact/ContactForm.do?FID=00282"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.omron.com/global/en/inquiry/vulnerability_information/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "jpcert",
+        "organizationName": "JPCERT/CC"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "CSA",
+    "cnaID": "CNA-2024-0071",
+    "organizationName": "Cyber Security Agency of Singapore",
+    "scope": "Vulnerabilities reported to CSA unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "singcert@csa.gov.sg"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.csa.gov.sg/resources/singcert/csa-as-a-cve-numbering-authority--cna-"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.csa.gov.sg/alerts-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "CERT"
+      ]
+    },
+    "country": "Singapore"
+  },
+  {
+    "shortName": "LeicaBiosystems",
+    "cnaID": "CNA-2024-0072",
+    "organizationName": "Leica Biosystems",
+    "scope": "All Leica Biosystems products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "lbs.productsecurity@leicabiosystems.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.leicabiosystems.com/us/about/coordinated-vulnerability-disclosure-cvd-process/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.leicabiosystems.com/us/about/product-security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Neo4j",
+    "cnaID": "CNA-2024-0073",
+    "organizationName": "Neo4j",
+    "scope": "Neo4j products and Neo4j-maintained projects only, not including end-of-life components or products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@neo4j.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://neo4j.com/trust-center/responsible-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://neo4j.com/security/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "Sweden"
+  },
+  {
+    "shortName": "OnLogic",
+    "cnaID": "CNA-2024-0074",
+    "organizationName": "OnLogic",
+    "scope": "OnLogic issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "soc@onlogic.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://storage.googleapis.com/ls-public-web-content/Security/STORM-Cybersecurity%20Policy-Vulnerability%20Disclosure.pdf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.onlogic.com/security-advisory/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "OB",
+    "cnaID": "CNA-2024-0075",
+    "organizationName": "OceanBase",
+    "scope": "OceanBase products only, not including end-of-life components or products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@oceanbase.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://en.oceanbase.com/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/oceanbase/oceanbase/issues"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "Gridware",
+    "cnaID": "CNA-2024-0076",
+    "organizationName": "Gridware Cybersecurity",
+    "scope": "Gridware software, services, and infrastructure issues, as well as vulnerabilities discovered by or reported to Gridware researchers that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "ict.security@gridware.com.au"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.gridware.com.au/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.gridware.com.au/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "BECDX",
+    "cnaID": "CNA-2024-0077",
+    "organizationName": "Beckman Coulter Diagnostics",
+    "scope": "Beckman Coulter Diagnostics manufactured products and technologies only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "ProductSecurity@beckman.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.beckmancoulter.com/en/about-beckman-coulter/product-security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.beckmancoulter.com/en/about-beckman-coulter/product-security/product-security-updates"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Omnissa",
+    "cnaID": "CNA-2024-0078",
+    "organizationName": "Omnissa, LLC",
+    "scope": "All Omnissa products and services, including Workspace ONE and Horizon.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@omnissa.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.omnissa.com/omnissa-external-vulnerability-response-and-remediation-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.omnissa.com/omnissa-security-response/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "graphql-java",
+    "cnaID": "CNA-2024-0079",
+    "organizationName": "GraphQL Java",
+    "scope": "GraphQL Java, Java DataLoader, GraphQL Java Extended Scalars, and GraphQL Java Extended Validation.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@graphql-java.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Reporting a Vulnerability page",
+            "url": "https://github.com/graphql-java/graphql-java/security#reporting-a-vulnerability"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.graphql-java.com/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.graphql-java.com/security/#common-vulnerabilities-and-exposures-cves"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "BECLS",
+    "cnaID": "CNA-2024-0080",
+    "organizationName": "Beckman Coulter Life Sciences",
+    "scope": "Beckman Coulter Life Sciences manufactured products and technologies only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "ProductSecurity@beckman.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.beckman.com/about-us/compliance/coordinated-vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.beckman.com/about-us/compliance/coordinated-vulnerability-disclosure/product-security-updates"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Radiometer",
+    "cnaID": "CNA-2024-0081",
+    "organizationName": "Radiometer Medical ApS",
+    "scope": "Radiometer products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product.security@radiometer.dk"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.radiometer.com/en/about-radiometer/legal/coordinated-vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.radiometer.com/en/myradiometer"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Denmark"
+  },
+  {
+    "shortName": "Deltaww",
+    "cnaID": "CNA-2024-0082",
+    "organizationName": "Delta Electronics, Inc.",
+    "scope": "Delta Electronics products as listed on <a href='https://www.deltaww.com' target='_blank'>www.deltaww.com</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "Delta.PSIRT@deltaww.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.deltaww.com/en-US/information/Cybersecurity-Vulnerability-Management-Policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.deltaww.com/en-US/Cybersecurity_Advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "bizerba",
+    "cnaID": "CNA-2024-0083",
+    "organizationName": "Bizerba SE & Co. KG",
+    "scope": "Bizerba products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@bizerba.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.bizerba.com/int/en/family-owned-and-operated-company-since-1866/corporate-governance-acting-responsibly-globally/security-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.bizerba.com/us/en/family-owned-and-operated-company-since-1866/corporate-governance-acting-responsibly-globally/bizerba-security-information"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "iManage",
+    "cnaID": "CNA-2024-0084",
+    "organizationName": "iManage LLC",
+    "scope": "iManage issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "ProductVulnerability@imanage.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://imanage.com/about/vulnerability-report/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.imanage.com/security/Security_Vulnerabilities.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Automox",
+    "cnaID": "CNA-2024-0085",
+    "organizationName": "Automox Inc.",
+    "scope": "All products created by Automox.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclosures@automox.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.automox.com/platform/security/responsible-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.automox.com/platform/security/security-bulletin"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Delinea",
+    "cnaID": "CNA-2024-0086",
+    "organizationName": "Delinea, Inc.",
+    "scope": "Vulnerabilities in Delinea products or services listed on <a href='https://www.delinea.com' target='_blank'>delinea.com</a>, or vulnerabilities in third-party products or services discovered by or reported to Delinea, unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@delinea.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://trust.delinea.com/?itemUid=56583ca0-6561-4cf3-a150-8c0c45d214cf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://trust.delinea.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "CEP",
+    "cnaID": "CNA-2024-0087",
+    "organizationName": "Cepheid",
+    "scope": "Cepheid products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productsecurity@cepheid.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.cepheid.com/en-US/legal/product-security.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.cepheid.com/en-US/legal/product-security/product-security-updates.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "S21sec",
+    "cnaID": "CNA-2024-0088",
+    "organizationName": "S21sec Cyber Solutions by Thales",
+    "scope": "Vulnerabilities discovered by S21sec that are not within another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "es.dis.s21sec.cve.coordination@thalesgroup.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.s21sec.com/CVEdisclosurepolicy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.s21sec.com/CVElist/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "THA-PSIRT",
+        "organizationName": "Thales Group"
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "Roche",
+    "cnaID": "CNA-2024-0089",
+    "organizationName": "Roche Diagnostics",
+    "scope": "Roche\u2019s medical technology products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product.security@roche.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://diagnostics.roche.com/global/en/legal/vulnerability-and-incident-handling-policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://diagnostics.roche.com/global/en/legal/product-security-advisory.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "MolDev",
+    "cnaID": "CNA-2025-0001",
+    "organizationName": "Molecular Devices",
+    "scope": "Molecular Devices products only as listed on <a href='https://www.moleculardevices.com/products' target='_blank'>moleculardevices.com/products</a>.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "CVD Submission Contact and Process",
+            "url": "https://www.moleculardevices.com/coordinated-vulnerability-disclosure-policy"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.moleculardevices.com/coordinated-vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.moleculardevices.com/s/article/Molecular-Devices-Security-Advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "SOCRadar",
+    "cnaID": "CNA-2025-0002",
+    "organizationName": "SOCRadar Cyber Intelligence Inc.",
+    "scope": "Vulnerabilities in SOCRadar products and services and vulnerabilities discovered by or reported to SOCRadar that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@socradar.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://socradar.io/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://socradar.io/labs/cve-radar/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "PTC",
+    "cnaID": "CNA-2025-0003",
+    "organizationName": "PTC Inc.",
+    "scope": "All currently supported PTC software products and cloud/SaaS services.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Vulnerability Reporting page",
+            "url": "https://www.ptc.com/documents/security/coordinated-vulnerability-disclosure"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.ptc.com/documents/security/coordinated-vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.ptc.com/en/about/trust-center/advisory-center"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "HemoCue",
+    "cnaID": "CNA-2025-0004",
+    "organizationName": "HemoCue AB",
+    "scope": "HemoCue branded products and technologies only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productsecurity@hemocue.se"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://global.hemocue.com/product-security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://global.hemocue.com/product-security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Sweden"
+  },
+  {
+    "shortName": "securepoint",
+    "cnaID": "CNA-2025-0005",
+    "organizationName": "Securepoint GmbH",
+    "scope": "Securepoint GmbH issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@securepoint.de"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.securepoint.de/disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://wiki.securepoint.de/Advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Centreon",
+    "cnaID": "CNA-2025-0006",
+    "organizationName": "Centreon",
+    "scope": "All Centreon product issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@centreon.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://vdp.centreon.com/p/centreon-VDP"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://thewatch.centreon.com/latest-security-bulletins-64"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "ATIS",
+    "cnaID": "CNA-2025-0007",
+    "organizationName": "ATISoluciones Dise\u00f1o de Sistemas Electr\u00f3nicos, S.L.",
+    "scope": "AtiSoluciones products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@atisoluciones.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.atisoluciones.com/politica-cve"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.atisoluciones.com/incidentes-cve"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "PangeaCyber",
+    "cnaID": "CNA-2025-0008",
+    "organizationName": "Pangea Cyber Corporation",
+    "scope": "All Pangea Cyber products and services, as well as vulnerabilities in third-party software that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@pangea.cloud"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://pangea.cloud/security/vdp"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://pangea.cloud/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Softing",
+    "cnaID": "CNA-2025-0009",
+    "organizationName": "Softing",
+    "scope": "Softing issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@softing.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://company.softing.com/psirt.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://company.softing.com/psirt.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Danfoss",
+    "cnaID": "CNA-2025-0010",
+    "organizationName": "Danfoss",
+    "scope": "Danfoss products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@danfoss.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.danfoss.com/en/service-and-support/coordinated-vulnerability-disclosure/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.danfoss.com/en/service-and-support/coordinated-vulnerability-disclosure/danfoss-security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Denmark"
+  },
+  {
+    "shortName": "Saviynt",
+    "cnaID": "CNA-2025-0011",
+    "organizationName": "Saviynt Inc.",
+    "scope": "Vulnerabilities discovered in Saviynt products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@saviynt.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://saviynt.com/saviynt-responsible-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://saviynt.com/trust-compliance-security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "CPANSec",
+    "cnaID": "CNA-2025-0012",
+    "organizationName": "CPAN Security Group",
+    "scope": "Vulnerabilities in Perl and CPAN Modules (including End-of-Life Perl versions) found at <a href='https://perl.org' target='_blank'>https://perl.org</a>, <a href='https://cpan.org' target='_blank'>https://cpan.org</a>, or <a href='https://metacpan.org/' target='_blank'>https://metacpan.org/</a>, excluding distributions of Perl or CPAN Modules maintained by third-party redistributors.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-request@security.metacpan.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security.metacpan.org/docs/cna-disclosure-policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://lists.security.metacpan.org/cve-announce/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "Canada"
+  },
+  {
+    "shortName": "IDT-DNA",
+    "cnaID": "CNA-2025-0013",
+    "organizationName": "Integrated DNA Technologies, Inc.",
+    "scope": "Vulnerabilities within IDT-manufactured products, software, and services that are in-service.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "ProductSecurity@idtdna.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.idtdna.com/pages/support/vulnerability-disclosure-process/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.idtdna.com/pages/support/vulnerability-disclosure-process/known-vulnerabilities"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "TMUS",
+    "cnaID": "CNA-2025-0014",
+    "organizationName": "T-Mobile US",
+    "scope": "All T-Mobile US products (including end-of-life/end-of-service products), as well as vulnerabilities in third-party software/hardware discovered by T-Mobile US that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@t-mobile.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://bugcrowd.com/engagements/t-mobile"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://t-mobile.github.io/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Digi",
+    "cnaID": "CNA-2025-0015",
+    "organizationName": "Digi International Inc.",
+    "scope": "Digi branded products and services only.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Submit a Security Vulnerability page",
+            "url": "https://www.digi.com/resources/security/submit-security-vulnerability"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.digi.com/resources/security/submit-security-vulnerability"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.digi.com/resources/security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Qt",
+    "cnaID": "CNA-2025-0016",
+    "organizationName": "Qt Group",
+    "scope": "All supported Qt Group products. Excludes third-party redistributions and downstream packaging of Qt open source releases not published by Qt Group.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@qt.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.qt.io/terms-conditions/responsible-vulnerability-disclosure-process"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://wiki.qt.io/List_of_known_vulnerabilities_in_Qt_products"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Finland"
+  },
+  {
+    "shortName": "TPLink",
+    "cnaID": "CNA-2025-0017",
+    "organizationName": "TP-Link Systems Inc.",
+    "scope": "TP-Link issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@tp-link.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Report a Vulnerability",
+            "url": "https://www.tp-link.com/us/press/security-advisory/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.tp-link.com/us/press/security-advisory/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.tp-link.com/us/press/security-advisory/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "SDC",
+    "cnaID": "CNA-2025-0018",
+    "organizationName": "Sandisk",
+    "scope": "Sandisk products listed at <a href='https://shop.sandisk.com/product-portfolio' target='_blank'>https://shop.sandisk.com/product-portfolio</a> only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@sandisk.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://shop.sandisk.com/support/product-security/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://shop.sandisk.com/support/product-security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "CTOne",
+    "cnaID": "CNA-2025-0019",
+    "organizationName": "CTOne Inc.",
+    "scope": "Vulnerabilities in cellular (LTE/4G/5G) devices and protocols that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "tr2@ctone.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://ctone.com//wp-content/uploads/2024/07/CTOne-Vulnerability-Disclosure-Policy.pdf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://ctone.com/published-product-vulnerabilities/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher",
+        "Bug Bounty Provider"
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "Jaspersoft",
+    "cnaID": "CNA-2025-0020",
+    "organizationName": "Jaspersoft",
+    "scope": "Jaspersoft products and services only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@cloud.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://community.jaspersoft.com/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://community.jaspersoft.com/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Spotfire",
+    "cnaID": "CNA-2025-0021",
+    "organizationName": "Spotfire",
+    "scope": "Vulnerabilities associated with the Spotfire product only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@cloud.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://community.spotfire.com/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://community.spotfire.com/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Insyde",
+    "cnaID": "CNA-2025-0022",
+    "organizationName": "Insyde Software",
+    "scope": "Vulnerabilities in all of Insyde Software\u2019s firmware and software products, as well as vulnerabilities discovered by Insyde Software that are not covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security.report@insyde.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.insyde.com/security-pledge/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.insyde.com/security-pledge/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "EEF",
+    "cnaID": "CNA-2025-0023",
+    "organizationName": "Erlang Ecosystem Foundation",
+    "scope": "Vulnerabilities in active packages hosted on <a href='https://hex.pm/' target='_blank'>Hex.pm</a>, and in active projects hosted under the GitHub organizations <a href='https://github.com/elixir-lang' target='_blank'>@elixir-lang</a>, <a href='https://github.com/erlang' target='_blank'>@erlang</a>, <a href='https://github.com/erlef-cna' target='_blank'>@erlef-cna</a>, <a href='https://github.com/erlef' target='_blank'>@erlef</a>, <a href='https://github.com/gleam-lang' target='_blank'>@gleam-lang</a>, <a href='https://github.com/hexpm' target='_blank'>@hexpm</a>, <a href='https://github.com/nerves-hub'>@nerves-hub</a>, <a href='https://github.com/nerves-project'>@nerves-project</a>, and <a href='https://github.com/OpenRiak'>@OpenRiak</a> unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@erlef.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://cna.erlef.org/security-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cna.erlef.org/cves"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Consortium",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "SCHUTZWERK",
+    "cnaID": "CNA-2025-0024",
+    "organizationName": "SCHUTZWERK GmbH",
+    "scope": "Vulnerabilities discovered by, reported to, or coordinated by, SCHUTZWERK unless covered by another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "advisories@schutzwerk.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.schutzwerk.com/en/advisories/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.schutzwerk.com/blog/tags/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Stackable",
+    "cnaID": "CNA-2025-0025",
+    "organizationName": "Stackable GmbH",
+    "scope": "Vulnerabilities in Stackable products including end-of-life or unsupported Stackable software, as well as open source projects that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@stackable.tech"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://stackable.tech/en/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://advisories.stackable.tech/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "ExtremeNetworks",
+    "cnaID": "CNA-2025-0026",
+    "organizationName": "Extreme Networks, Inc.",
+    "scope": "Vulnerabilities discovered in Extreme Networks, Inc.\u2019s products and services.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@extremenetworks.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.extremenetworks.com/support/psirt"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://extreme-networks.my.site.com/ExtrSearch#q=cve&t=Knowledge&sort=relevancy&f:@sfrecordtypename=[Security_Advisory]"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "harborist",
+    "cnaID": "CNA-2025-0027",
+    "organizationName": "Harborist",
+    "scope": "All projects listed under <a href='https://www.npmjs.com/~ljharb' target='_blank'>https://www.npmjs.com/~ljharb</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "ljharb@harbor.ist"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/harborist/.github/blob/main/DISCLOSURE_POLICY.md"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/harborist/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "TRO",
+    "cnaID": "CNA-2025-0028",
+    "organizationName": "Teradyne Robotics",
+    "scope": "All products released by Teradyne Robotics subsidiaries, Universal Robots (UR) and Mobile Industrial Robots (MiR), including both actively supported and end-of-life/end-of-service products, as well as vulnerabilities in third-party software identified by Teradyne Robotics that are outside the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "productsecurity@teradyne-robotics.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "UR Policy",
+        "language": "",
+        "url": "https://www.universal-robots.com/articles/coordinated-disclosure/"
+      },
+      {
+        "label": "MiR Policy",
+        "language": "",
+        "url": "https://mobile-industrial-robots.com/coordinated-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "UR Advisories",
+          "url": "https://www.universal-robots.com/articles/?filter_Applications[]=226617&filters[]=226617"
+        },
+        {
+          "label": "MiR Advisories",
+          "url": "https://mobile-industrial-robots.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Denmark"
+  },
+  {
+    "shortName": "Profisee",
+    "cnaID": "CNA-2025-0029",
+    "organizationName": "Profisee Group, Inc.",
+    "scope": "Vulnerabilities found in software developed by Profisee only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "securityteam@profisee.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://profisee.com/security/vulnerabilities/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://profisee.com/security/vulnerabilities/detail/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "openjs",
+    "cnaID": "CNA-2025-0030",
+    "organizationName": "OpenJS Foundation",
+    "scope": "All projects listed at <a href='https://openjsf.org/projects' target='_blank'>https://openjsf.org/projects</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@lists.openjsf.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://cna.openjsf.org/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cna.openjsf.org/security-advisories.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Toreon",
+    "cnaID": "CNA-2025-0031",
+    "organizationName": "Toreon",
+    "scope": "Vulnerabilities discovered by or reported to Toreon that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "disclosure@toreon.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.toreon.com/cna-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.toreon.com/news/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "Belgium"
+  },
+  {
+    "shortName": "MHV",
+    "cnaID": "CNA-2025-0032",
+    "organizationName": "Maritime Hacking Village",
+    "scope": "Vulnerabilities discovered by researchers in collaboration with Maritime Hacking Village that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@maritimehackingvillage.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.maritimehackingvillage.com/cvd"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://maritimehackingvillage.com/security-advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "FERMAX",
+    "cnaID": "CNA-2025-0032",
+    "organizationName": "Fermax Technologies SLU",
+    "scope": "Vulnerabilities discovered in the services and applications of the MeetMe and DuoxMe products that are not covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@fermax.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.fermax.com/legal/en/vulnerability-management-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.fermax.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "Altium",
+    "cnaID": "CNA-2025-0033",
+    "organizationName": "Altium",
+    "scope": "Vulnerabilities in the following Altium products only: Altium Designer, A365, Octopart, and Altium Enterprise Server.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "a365.security@altium.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.altium365.com/trust/vulnerability-program"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.altium365.com/trust/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "TYPO3",
+    "cnaID": "CNA-2025-0034",
+    "organizationName": "TYPO3 Association",
+    "scope": "Vulnerabilities in TYPO3 open-source products only, including TYPO3 CMS core and 3rd party extensions for TYPO3, unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@typo3.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://typo3.org/community/teams/security/security-in-typo3"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://advisories.typo3.org/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "TCS-CERT",
+    "cnaID": "CNA-2025-0035",
+    "organizationName": "TCS-CERT (Thales Cyber Solutions Customer\u2019s CERT)",
+    "scope": "Vulnerabilities related to TCS-CERT\u2019s customers\u2019 environment and vulnerabilities related to research conducted by Cyber Solutions by Thales\u2019 Intrusion and Application Security Team.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "team@tcs-cert.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://cds.thalesgroup.com/en/tcs-cert/advisory"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cds.thalesgroup.com/en/tcs-cert/advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "THA-PSIRT",
+        "organizationName": "Thales Group"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Belgium"
+  },
+  {
+    "shortName": "rust",
+    "cnaID": "CNA-2025-0036",
+    "organizationName": "The Rust Project",
+    "scope": "Repositories, packages, and websites maintained by the Rust Project. More details: <a href='https://www.rust-lang.org/policies/security#scope' target='_blank'>https://www.rust-lang.org/policies/security#scope</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@rust-lang.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.rust-lang.org/policies/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://groups.google.com/g/rustlang-security-announcements"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Arteche",
+    "cnaID": "CNA-2025-0037",
+    "organizationName": "Arteche",
+    "scope": "Arteche issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@arteche.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.arteche.com/es/cmis/document/default/848286f4-236d-4b55-896b-c9e503ea688e"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.arteche.com/en/cybersecurity-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "GoogleCloud",
+    "cnaID": "CNA-2025-0038",
+    "organizationName": "Google Cloud",
+    "scope": "Vulnerabilities in any Google Cloud developed product and not under the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "google-cloud-cve-program@google.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://about.google/company-info/appsecurity/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "language": "",
+          "url": "https://cloud.google.com/support/bulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "Google",
+        "organizationName": "Google LLC"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "bcorg",
+    "cnaID": "CNA-2025-0039",
+    "organizationName": "Legion of the Bouncy Castle Inc.",
+    "scope": "Legion of the Bouncy Castle issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "feedback-crypto@bouncycastle.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.bouncycastle.org/disclosure.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.bouncycastle.org/vulnerability-advisory.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "NETGEAR",
+    "cnaID": "CNA-2025-0040",
+    "organizationName": "NETGEAR",
+    "scope": "Vulnerabilities in all products from NETGEAR, its subsidiaries, and third-party components used in NETGEAR products that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@netgear.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.netgear.com/about/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.netgear.com/about/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "spartans-security",
+    "cnaID": "CNA-2025-0041",
+    "organizationName": "Spartans Security",
+    "scope": "Vulnerabilities in software, services, and infrastructure owned and managed by Spartans Security, and vulnerabilities researched and found by Spartans Security in third-party products that are not part of another CNA's scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerability@spartanssec.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.spartanssec.com/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.spartanssec.com/blog"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "Antenna",
+    "cnaID": "CNA-2025-0042",
+    "organizationName": "Antenna",
+    "scope": "Antenna issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security_team@antenna.dev"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://antenna.dev/security/reporting"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://antenna.dev/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "GV",
+    "cnaID": "CNA-2025-0043",
+    "organizationName": "GeoVision Inc.",
+    "scope": "Vulnerabilities in GeoVision products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@geovision.com.tw"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.geovision.com.tw/cyber_security.php"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.geovision.com.tw/cyber_security.php"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "Commvault",
+    "cnaID": "CNA-2025-0044",
+    "organizationName": "Commvault Systems Inc.",
+    "scope": "Vulnerabilities in Commvault SaaS and software products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "PSIRT@Commvault.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://trust.commvault.com/resources?s=vwnojdk0a0vsbx0qknnb&amp;name=vulnerability-disclosure-policy#689bba5cdc60fd4597bfd694"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://documentation.commvault.com/securityadvisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "AxxonSoft",
+    "cnaID": "CNA-2025-0045",
+    "organizationName": "AxxonSoft Limited",
+    "scope": "AxxonSoft products and solutions, Abetechs GmbH products and solutions (GRUNDIG security products, and C-WERK software solutions).",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@axxonsoft.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.axxonsoft.com/legal/axxonsoft-vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.axxonsoft.com/legal/axxonsoft-vulnerability-disclosure-policy/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service"
+      ]
+    },
+    "country": "Ireland"
+  },
+  {
+    "shortName": "HackRTU",
+    "cnaID": "CNA-2025-0046",
+    "organizationName": "HackRTU",
+    "scope": "Vulnerability assignment related to its vulnerability coordination role for Industrial Control Systems (ICS) that are not covered by another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve.coordination@hackrtu.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hackrtu.com/cna/cve-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.hackrtu.com/cna/cve-list/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "Echo",
+    "cnaID": "CNA-2025-0047",
+    "organizationName": "Echo Software Ltd.",
+    "scope": "Vulnerabilities in Echo products, as well as vulnerabilities discovered by or reported to Echo that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@echohq.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.echohq.com/vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.echohq.com/vulnerability-disclosure"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ]
+    },
+    "country": "Israel"
+  },
+  {
+    "shortName": "Uniview",
+    "cnaID": "CNA-2025-0048",
+    "organizationName": "Zhejiang Uniview Technologies Co., Ltd.",
+    "scope": "Uniview products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@uniview.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://global.uniview.com/About_Us/Security/Process/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://global.uniview.com/About_Us/Security/Notice/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "YesWeHack",
+    "cnaID": "CNA-2025-0049",
+    "organizationName": "YesWeHack",
+    "scope": "Vulnerabilities discovered by YesWeHack community hunters on products being tested on the platform with the permission of their owners, as part of Coordinated Vulnerability Disclosure.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "support@yeswehack.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://yeswehack.com/programs/yes-we-hack"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.yeswehack.com/product/trust-security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Bug Bounty Provider"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "Leonardo",
+    "cnaID": "CNA-2025-0050",
+    "organizationName": "Leonardo S.p.A.",
+    "scope": "Vulnerabilities found in the following product: Leonardo SC2.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@leonardo.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://cybersecurity.leonardo.com/documents/16277703/0/VULNERABILITIES+REPORT+%28LDO_IT25_01520%29.pdf?t=1757318888035"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cybersecurity.leonardo.com/documents/16277703/0/VULNERABILITIES+REPORT+%28LDO_IT25_01520%29.pdf?t=1757318888035"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor",
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Italy"
+  },
+  {
+    "shortName": "azure-access",
+    "cnaID": "CNA-2025-0051",
+    "organizationName": "Azure Access Technology",
+    "scope": "Azure Access branded products and technologies only.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Responsible Disclosure contact page",
+            "url": "https://azure-access.com/responsible-disclosure-policy"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://azure-access.com/responsible-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://azure-access.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Almaviva",
+    "cnaID": "CNA-2025-0052",
+    "organizationName": "Almaviva S.p.A.",
+    "scope": "Vulnerabilities in Almaviva proprietary software solutions such as Joshua CybeRisk Vision, Jiano, Sofia, and Giotto, as well as Almaviva-developed IT solutions.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-reporting@almaviva.it"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.almaviva.it/it_IT/CNA_vulnerability_disclosure_policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.cyberiskvision.com/zero-day/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service"
+      ]
+    },
+    "country": "Italy"
+  },
+  {
+    "shortName": "XONA",
+    "cnaID": "CNA-2025-0053",
+    "organizationName": "Xona Systems",
+    "scope": "All software produced as part of the Xona Platform including the CSG (Critical System Gateway) and XCM (Xona Central Manager) and vulnerabilities discovered by or reported to Xona Systems for Xona software or its underlying Operating System or Firmware not covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product-security@xonasystems.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.xonasystems.com/product-security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.xonasystems.com/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "BCNY",
+    "cnaID": "CNA-2025-0054",
+    "organizationName": "The Browser Company of New York",
+    "scope": "The Browser Company of New York branded products and technologies only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@thebrowser.company"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.thebrowser.company/security/cve-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Arc Security Bulletins",
+          "url": "https://arc.net/security/bulletins"
+        },
+        {
+          "label": "Dia Security Bulletins",
+          "url": "https://diabrowser.com/security/bulletins"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Bug Bounty Provider"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Foxit",
+    "cnaID": "CNA-2025-0055",
+    "organizationName": "Foxit Software Incorporated",
+    "scope": "Foxit issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-ml@foxit.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.foxit.com/support/responsible-disclosure-policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.foxit.com/support/security.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Nutanix",
+    "cnaID": "CNA-2025-0056",
+    "organizationName": "Nutanix",
+    "scope": "Nutanix issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@nutanix.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://portal.nutanix.com/page/security/security-contact"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://portal.nutanix.com/page/security/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "DSF",
+    "cnaID": "CNA-2025-0057",
+    "organizationName": "Django Software Foundation",
+    "scope": "Only supported and end-of-life Django versions available at <a href='https://www.djangoproject.com/download/' target='_blank'>https://www.djangoproject.com/download/</a> and projects listed at <a href='https://github.com/django' target='_blank'>https://github.com/django</a> (such as Django, channels, and daphne), excluding distributions maintained by third-party redistributors.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@djangoproject.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.djangoproject.com/foundation/cve-numbering-authority/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.djangoproject.com/en/stable/releases/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Altera",
+    "cnaID": "CNA-2025-0058",
+    "organizationName": "Altera",
+    "scope": "Altera products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@altera.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.altera.com/security/psirt"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.altera.com/security/psirt"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Tanium",
+    "cnaID": "CNA-2025-0059",
+    "organizationName": "Tanium Inc.",
+    "scope": "Vulnerabilities found in Tanium products and vulnerabilities in third-party software discovered by Tanium that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@tanium.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.tanium.com/vulnerability-reporting-terms/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.tanium.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "2N",
+    "cnaID": "CNA-2025-0060",
+    "organizationName": "2N Telekomunikace a.s.",
+    "scope": "All products of 2N Telekomunikace a.s. including end-of-life/end-of-service products.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Report a security vulnerability",
+            "url": "https://www.2n.com/en-GB/about-2n/cybersecurity/form/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.2n.com/en-GB/about-2n/cybersecurity/vulnerability-management"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.2n.com/en-GB/about-2n/cybersecurity/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Czech Republic"
+  },
+  {
+    "shortName": "NetScaler",
+    "cnaID": "CNA-2025-0061",
+    "organizationName": "NetScaler",
+    "scope": "NetScaler issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure@cloud.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.cloud.com/trust-center/product-security/vulnerability-response"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://support.citrix.com/support-home/topic-article-list?trendingCategory=20&trendingTopicName=Security%20Bulletin"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "runZero",
+    "cnaID": "CNA-2025-0062",
+    "organizationName": "runZero, Inc.",
+    "scope": "Vulnerabilities in runZero products, as well as vulnerabilities discovered by, or reported to, runZero that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "todb@runzero.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.runzero.com/legal/disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.runzero.com/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher",
+        "Hosted Service",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Hackrate",
+    "cnaID": "CNA-2026-0001",
+    "organizationName": "Hackrate Kft.",
+    "scope": "Vulnerabilities that are discovered, validated, and coordinated through the Hackrate Ethical Hacking Platform, including: software, web applications, APIs, and cloud services; vulnerabilities validated and triaged by our internal security team; and findings disclosed under our coordination that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@hckrt.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://hckrt.com/vdp/disclosure-guidelines"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.hckrt.com/hacktivity"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Bug Bounty Provider"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Hungary"
+  },
+  {
+    "shortName": "NIBEGroup",
+    "cnaID": "CNA-2026-0002",
+    "organizationName": "NIBE Group",
+    "scope": "Products, services, and solutions developed or sold by NIBE Industrier AB or any of its subsidiaries; open-source projects owned by NIBE Industrier AB or any of its subsidiaries; vulnerabilities in third-party products used by NIBE Industrier AB or any of its subsidiaries which are outside the scope of another CNA; and subsidiaries of NIBE Industrier AB are listed on <a href='https://www.nibe.com' target='_blank'>https://www.nibe.com</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerability@nibegroup.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://vdp.nibegroup.com"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://vdp.nibegroup.com"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Sweden"
+  },
+  {
+    "shortName": "Vantive",
+    "cnaID": "CNA-2026-0003",
+    "organizationName": "Vantive",
+    "scope": "Vantive\u2019s commercially available products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "global.corp.product.security@vantive.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.vantive.com/contact-support/security-updates"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.vantive.com/contact-support/security-updates"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "ByteDance",
+    "cnaID": "CNA-2026-0004",
+    "organizationName": "ByteDance, Ltd.",
+    "scope": "ByteDance issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "src@bytedance.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://bytedance.larkoffice.com/docx/DmandP3o9oEQBdx0fkycqMHNnPd"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://src.bytedance.com/announcement"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "Nintendo",
+    "cnaID": "CNA-2026-0005",
+    "organizationName": "Nintendo Co., Ltd.",
+    "scope": "System vulnerabilities regarding the Nintendo Switch 2, Nintendo Switch, Nintendo Switch Lite, and vulnerabilities regarding Nintendo Switch 2 and Nintendo Switch applications for which Nintendo is the publisher worldwide.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Nintendo HackerOne page",
+            "url": "https://hackerone.com/nintendo"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.nintendo.com/jp/security-advisories/en/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.nintendo.com/jp/security-advisories/en/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "jpcert",
+        "organizationName": "JPCERT/CC"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "TCL_Smart_Terminal",
+    "cnaID": "CNA-2026-0006",
+    "organizationName": "TCL Electronics Holdings Limited",
+    "scope": "TCL smart TV, smart pad, and mobile phone devices only. Projects listed on <a href='https://github.com/TclSecLab/CNA/blob/main/README_EN.md' target='_blank'>https://github.com/TclSecLab/CNA/blob/main/README_EN.md</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@tcl.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/TclSecLab/CNA/blob/main/TSRC%20Disclosure%20Policy.md"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories 1",
+          "url": "https://src.tcl.com/en/noticeList"
+        },
+        {
+          "label": "Advisories 2",
+          "url": "https://github.com/TclSecLab/CNA"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "China"
+  },
+  {
+    "shortName": "CODRA",
+    "cnaID": "CNA-2026-0007",
+    "organizationName": "CODRA",
+    "scope": "CODRA\u2019s products and related services.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "secure.panorama@codra.net"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://my.codra.net/en-gb/messages/csirt-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://my.codra.net/en-gb/csirt"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "PRJBLK",
+    "cnaID": "CNA-2026-0008",
+    "organizationName": "Project Black",
+    "scope": "Vulnerabilities discovered by Project Black that are not within another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@projectblack.io"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://projectblack.io/blog/vulnerability-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://projectblack.io/blog/tag/advisory/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "DTEX",
+    "cnaID": "CNA-2026-0009",
+    "organizationName": "DTEX Systems, Inc.",
+    "scope": "All DTEX products, including DTEX Forwarder for Mac, DTEX Forwarder for Linux, DTEX Forwarder for Windows, and DTEX platform including DTEX Analytics Server.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerability-disclosure@dtexsystems.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://advisories.dtexsystems.com/vulnerability-disclosure-policy.pdf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://advisories.dtexsystems.com"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Vestel",
+    "cnaID": "CNA-2026-0010",
+    "organizationName": "Vestel Electronics Industry & Trade Co.",
+    "scope": "Vestel-owned brands and products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@vestel.com.tr"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://vestelinternational.com/en/vulnerability-disclose-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://vestelinternational.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "T\u00fcrkiye"
+  },
+  {
+    "shortName": "JupiterOne",
+    "cnaID": "CNA-2026-0011",
+    "organizationName": "JupiterOne, Inc.",
+    "scope": "All JupiterOne open source and commercial products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@jupiterone.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.jupiterone.com/legal-and-security-hub"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://docs.jupiterone.io/release-notes/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "cygence",
+    "cnaID": "CNA-2026-0012",
+    "organizationName": "Cygence Pty Ltd",
+    "scope": "Issues in third-party products identified by, or reported, to Cygence, unless covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@cygence.com.au"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.cygence.com.au/disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.cygence.com.au/vulnerability-disclosures"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "TuranSec",
+    "cnaID": "CNA-2026-0013",
+    "organizationName": "Turan Security",
+    "scope": "Vulnerabilities discovered through independent research conducted by TuranSec to products and projects that are not CNAs themselves.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@turansec.uz"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://cve.turansec.uz/disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cve.turansec.uz/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Uzbekistan"
+  },
+  {
+    "shortName": "BombadilSystems",
+    "cnaID": "CNA-2026-0014",
+    "organizationName": "Bombadil Systems LLC",
+    "scope": "Vulnerabilities in third-party software discovered by Bombadil Systems that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve@bombadil.systems"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://bombadil.systems/disclosure.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://bombadil.systems/advisories.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Researcher"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Cribl",
+    "cnaID": "CNA-2026-0015",
+    "organizationName": "Cribl, Inc.",
+    "scope": "Vulnerabilities identified in Cribl products, and vulnerabilities discovered by, or reported to, Cribl that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Cribl contact page",
+            "url": "https://cribl.io/vulnerability-disclosure-program/"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://cribl.io/vulnerability-disclosure-program/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://trust.cribl.io/notifications"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "HDFG",
+    "cnaID": "CNA-2026-0016",
+    "organizationName": "The HDF Group",
+    "scope": "All HDF software including HDF5, HDF4, HSDS, HDFView.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@hdfgroup.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": " https://github.com/HDFGroup/hdf5/security/policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/HDFGroup/hdf5/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "FB",
+    "cnaID": "CNA-2026-0017",
+    "organizationName": "Fujifilm Business Innovation Corp.",
+    "scope": "Fuji Xerox and FUJIFILM Business Innovation products such as multifunction devices, printers, production printers, software, and cloud services.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "dgi-fb_vulnerability_report@fujifilm.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.fujifilm.com/fbglobal/eng/company/quality/vdp"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.fujifilm.com/fbglobal/eng/company/quality/product_security/vulnerability"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "jpcert",
+        "organizationName": "JPCERT/CC"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Japan"
+  },
+  {
+    "shortName": "Acer",
+    "cnaID": "CNA-2026-0018",
+    "organizationName": "Acer Inc.",
+    "scope": "Acer issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerability@acer.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.acer.com/us-en/support/security-advisory"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.acer.com/us-en/support/security-advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "Canva",
+    "cnaID": "CNA-2026-0019",
+    "organizationName": "Canva",
+    "scope": "All Canva products, including open-source software published and maintained by Canva, as well as vulnerabilities in third-party software discovered by Canva that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@canva.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.canva.com/security/vulnerability-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://trust.canva.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Researcher"
+      ]
+    },
+    "country": "Australia"
+  },
+  {
+    "shortName": "QCI",
+    "cnaID": "CNA-2026-0020",
+    "organizationName": "Quanta Computer, Inc.",
+    "scope": "Quanta Computer PSIRT products and services only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "PSIRT@quantatw.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.quantatw.com/Quanta/english/product/sec_process.aspx"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.quantatw.com/Quanta/english/product/qci_sec.aspx"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "SNOW",
+    "cnaID": "CNA-2026-0021",
+    "organizationName": "Snowflake",
+    "scope": "Snowflake products, including those of its subsidiaries, and vulnerabilities in third-party software that are discovered by, or reported to, Snowflake that are not within another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@snowflake.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://hackerone.com/snowflake?type=team"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.snowflake.com/en/why-snowflake/snowflake-security-hub/security-bulletins/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "FTI",
+    "cnaID": "CNA-2026-0022",
+    "organizationName": "Fsas Technologies",
+    "scope": "Fsas Technologies (a Fujitsu company) in the Europe/EMEA region only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "FsasTech-PSIRT@fujitsu.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security.eu.fsastech.com"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security.eu.fsastech.com"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Synopsys",
+    "cnaID": "CNA-2026-0023",
+    "organizationName": "Synopsys, Inc.",
+    "scope": "All Synopsys products and technologies only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@synopsys.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.synopsys.com/company/legal/vulnerability-disclosure-policy.html"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.synopsys.com/company/legal/vulnerability-disclosure-policy/advisories.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Entrust",
+    "cnaID": "CNA-2026-0024",
+    "organizationName": "Entrust Corporation",
+    "scope": "All products under the following brand names: Entrust, Datacard, Entrust Datacard, nCipher, Onfido, Hytrust, SafeLayer, Antelop, Evidos, SMS Passcode.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@entrust.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.entrust.com/legal-compliance/security#responsibledisclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.entrust.com/knowledgebase/content-type/security-advisory"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "CSAI",
+    "cnaID": "CNA-2026-0025",
+    "organizationName": "Cloud Security Alliance",
+    "scope": "Vulnerabilities in software developed and maintained by the Cloud Security Alliance (github.com/CloudSecurityAlliance/*).",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-mgmt@cloudsecurityalliance.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/CloudSecurityAlliance/csa-product-security/blob/main/docs/vulnerability-disclosure-policy.md"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://labs.cloudsecurityalliance.org/advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "OAI",
+    "cnaID": "CNA-2026-0026",
+    "organizationName": "OpenAI",
+    "scope": "<strong>CNA Scope:</strong> Vulnerabilities in OpenAI installed software including desktop apps, mobile apps, and SDKs only.<br/><br/><strong><a href='/Resources/Roles/Cnas/FrontierAiResearcherCNAsPilot.pdf' target='_blank'>Frontier AI Researcher CVE Numbering Authorities (CNAs) Pilot</a> Scope:</strong> Vulnerabilities discovered by OpenAI that are not within another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@openai.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://openai.com/policies/openai-cve-assignment-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://trust.openai.com/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "AI Researcher (Frontier AI Researcher CVE Numbering Authorities (CNAs) Pilot)"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "CIRCL",
+    "cnaID": "CNA-2026-0027",
+    "organizationName": "Computer Incident Response Center Luxembourg (CIRCL)",
+    "scope": "Vulnerability assignment related to vulnerability coordination in Luxembourg, which may include reports on software, products, hardware, or services submitted to CIRCL in its role as the national authority for vulnerability coordination in Luxembourg and within the CSIRTs network.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "info@circl.lu"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.circl.lu/pub/coordinated-vulnerability-disclosure/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://vulnerability.circl.lu/search?assigner=CIRCL"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "CERT"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Luxembourg"
+  },
+  {
+    "shortName": "Ygreky",
+    "cnaID": "CNA-2026-0028",
+    "organizationName": "Ygreky SASU",
+    "scope": "All Ygreky products and infrastructure, and vulnerabilities discovered by, or reported to, Ygreky that are not covered by the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulns@ygreky.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://ygreky.com/disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://ygreky.com/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher",
+        "Open Source",
+        "Bug Bounty Provider"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "OCD",
+    "cnaID": "CNA-2026-0029",
+    "organizationName": "Orange Cyberdefense",
+    "scope": "Orange Cyberdefense branded products and technologies, unless embedded component or software covered by the scope of another CNA; as well as vulnerabilities in third-party software discovered by Orange Cyberdefense that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerability@orangecyberdefense.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.orangecyberdefense.com/global/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://advisories.orangecyberdefense.com/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "CERT",
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "gvision-it",
+    "cnaID": "CNA-2026-0030",
+    "organizationName": "GVision Italia S.r.l.",
+    "scope": "Vulnerabilities affecting EU-certified and EU-hardened firmware, software components, and related services distributed and maintained by GVision Italia. This includes firmware variants modified, certified, and maintained by GVision Italia for the European market; associated software components, configuration tools, and update mechanisms under GVision Italia responsibility; and, public-facing services and portals operated by GVision Italia related to device management and security. This scope explicitly excludes products or firmware versions not modified or maintained by GVision Italia.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@gvision.it"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://gvision.it/security-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://gvision.it/security-advisories/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Italy"
+  },
+  {
+    "shortName": "BAE",
+    "cnaID": "CNA-2026-0031",
+    "organizationName": "BAE Systems, Inc.",
+    "scope": "All products of BAE Systems.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "vulnerability@baesystems.us"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.baesystems.com/en-us/vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.geospatialexploitationproducts.com/socet-gxp/vulnerabilities-disclosure/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Hosted Service"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Hologic",
+    "cnaID": "CNA-2026-0032",
+    "organizationName": "Hologic, Inc.",
+    "scope": "Hologic products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "CoordinatedVulnerability@hologic.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hologic.com/security/coordinated-vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.hologic.com/support/usa/breast-skeletal-products-cybersecurity"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Airlock",
+    "cnaID": "CNA-2026-0033",
+    "organizationName": "Airlock by Ergon",
+    "scope": "Airlock issues only: Airlock SaaS, Airlock Identity and Access Management (IAM), Airlock Gateway, and Airlock Microgateway.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@airlock.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.airlock.com/security-advisories"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.airlock.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "ThinkstAppliedResearch",
+    "cnaID": "CNA-2026-0034",
+    "organizationName": "Thinkst Applied Research",
+    "scope": "Thinkst Applied Research\u2019s products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@thinkst.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://help.canary.tools/hc/en-gb/articles/10895067088925"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://canary.tools/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "South Africa"
+  },
+  {
+    "shortName": "eclypsium",
+    "cnaID": "CNA-2026-0035",
+    "organizationName": "Eclypsium, Inc.",
+    "scope": "All software created and distributed by Eclypsium, as well as vulnerabilities discovered by, or reported to, Eclypsium that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "advisories@eclypsium.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://eclypsium.com/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://eclypsium.com/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Cynet",
+    "cnaID": "CNA-2026-0036",
+    "organizationName": "Cynet Security Inc.",
+    "scope": "Vulnerabilities in Cynet Security products and services, including the Cynet Platform (formerly marketed as Cynet360 and All in One), endpoint agents (Windows, macOS, Linux), Cynet-managed APIs, web applications, and internet-facing infrastructure operated by Cynet Security.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "responsible-disclosure@cynet.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.cynet.com/cynet-responsible-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://cynet.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "linqi",
+    "cnaID": "CNA-2026-0037",
+    "organizationName": "linqi GmbH",
+    "scope": "Vulnerabilities in linqi products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@linqi.de"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://linqi.help/en/reference/security/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://linqi.help/en/reference/security/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "OMICRON",
+    "cnaID": "CNA-2026-0038",
+    "organizationName": "OMICRON electronics",
+    "scope": "OMICRON electronics issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product.security@omicronenergy.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.omicronenergy.com/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.omicronenergy.com/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Austria"
+  },
+  {
+    "shortName": "IQSIGHT",
+    "cnaID": "CNA-2026-0039",
+    "organizationName": "IQSIGHT B.V.",
+    "scope": "All IQSIGHT (formerly Bosch Building Technology - Video Systems) products including end-of-life products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@iqsight.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.iqsight.com/en/support/product-security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.iqsight.com/en/support/product-security/vulnerability-report/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Netherlands"
+  },
+  {
+    "shortName": "systemd",
+    "cnaID": "CNA-2026-0040",
+    "organizationName": "The systemd project",
+    "scope": "All components from the systemd project, including systemd, udev, systemd-journald, systemd-resolved, systemd-boot, systemd-stub, mkosi, and other components maintained on <a href='https://github.com/systemd' target='_blank'>https://github.com/systemd</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "systemd-security@redhat.com"
+          }
+        ],
+        "contact": [
+          {
+            "label": "Report a Vulnerability page",
+            "url": "https://github.com/systemd/systemd/security/advisories/new"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/systemd/systemd/security/policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/systemd/systemd/security/advisories?state=published"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Secur0",
+    "cnaID": "CNA-2026-0041",
+    "organizationName": "Secur0",
+    "scope": "Vulnerabilities identified by Secur0 or third parties in the programs listed at <a href='https://app.secur0.com/programs' target='_blank'>https://app.secur0.com/programs</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@secur0.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://secur0.com/en/vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://secur0.com/en/cna/cve-list"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "type": [
+        "Bug Bounty Provider"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "sirius",
+    "cnaID": "CNA-2026-0042",
+    "organizationName": "Sirius Computer, Inc.",
+    "scope": "Sirius branded products, managed systems, and software projects only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@sirius.computer"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://sirius.computer/security-disclosure-policy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://sirius.computer/security-disclosure-policy/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Verizon",
+    "cnaID": "CNA-2026-0043",
+    "organizationName": "Verizon",
+    "scope": "All Verizon products and services.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@verizon.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/Verizon/cve"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/Verizon/cve"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service",
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "VulNow",
+    "cnaID": "CNA-2026-0044",
+    "organizationName": "VulNow",
+    "scope": "Vulnerabilities observed by, discovered by, or reported to VulNow that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cvd@vul.now"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://vul.now/cvd"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://vul.now/precve"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Netherlands"
+  },
+  {
+    "shortName": "Bull",
+    "cnaID": "CNA-2026-0045",
+    "organizationName": "Bull SAS",
+    "scope": "Products and technologies branded by Bull and its subsidiaries, unless covered by the scope of another CNA as well as vulnerabilities in third-party software and hardware discovered by Bull and its subsidiaries that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "dl-psirt@bull.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://myatos.my.site.com/psmcustomer/s/article/Responsible-Disclosure?language=en_US"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://myatos.my.site.com/psmcustomer/s/topic/0TObD0000000XonWAE/psirt?language=en_US"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "illumos",
+    "cnaID": "CNA-2026-0046",
+    "organizationName": "The illumos project",
+    "scope": "The illumos project\u2019s <a href='https://code.illumos.org/plugins/gitiles/illumos-gate' target='_blank'>illumos-gate repository</a> and related downstream distributions such as <a href='https://openindiana.org' target='_blank'>OpenIndiana</a>, <a href='https://wiki.smartos.org' target='_blank'>SmartOS</a>, and <a href='https://omnios.org' target='_blank'>OmniOS</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@illumos.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://illumos.org/docs/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://illumos.org/docs/security/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "redhat",
+        "organizationName": "Red Hat, Inc."
+      },
+      "type": [
+        "Open Source"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "tuxcare",
+    "cnaID": "CNA-2026-0047",
+    "organizationName": "Tuxcare Inc.",
+    "scope": "Vulnerabilities in products developed, maintained, and distributed by TuxCare, including TuxCare Extended Lifecycle Support (ELS) and TuxCare SecureChain for OSS.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cve-coordination@tuxcare.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://tuxcare.com/vulnerability-reporting/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://tuxcare.com/cve-tracker/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "HDS",
+    "cnaID": "CNA-2026-0048",
+    "organizationName": "HDS a.s.",
+    "scope": "Vulnerabilities in products developed, maintained, or distributed by HDS and vulnerabilities in third party components if they affect HDS products and HDS is responsible for their integration.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "product.security@hds.sk"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.hds.sk/cybersecurity-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.hds.sk/cybersecurity-policy"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Slovak Republic"
+  },
+  {
+    "shortName": "AISLE",
+    "cnaID": "CNA-2026-0049",
+    "organizationName": "AISLE Incorporated",
+    "scope": "All AISLE products as well as vulnerabilities discovered in third-party software not covered by other CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@aisle.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://aisle.com/vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://aisle.com/cve-discoveries"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Netherlands"
+  },
+  {
+    "shortName": "Scality",
+    "cnaID": "CNA-2026-0050",
+    "organizationName": "Scality SA",
+    "scope": "All Scality-branded software products developed, maintained, and distributed by Scality, including but not limited to Scality RING, Scality ARTESCA, and Autonomous Data Infrastructure (ADI) products. The scope includes all versions of these products currently under active support, as well as legacy versions unless otherwise specified in the Scality Vulnerability Disclosure Policy.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@scality.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.scality.com/legal/scality-vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.scality.com/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "Tacit",
+    "cnaID": "CNA-2026-0051",
+    "organizationName": "Tacit",
+    "scope": "Vulnerabilities affecting software products, services, or components referenced in Tacit platform by software publishers.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "contact@tacit.now"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://tacit.now/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": ""
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Hosted Service",
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "France"
+  },
+  {
+    "shortName": "Anthropic",
+    "cnaID": "CNA-2026-0052",
+    "organizationName": "Anthropic, PBC",
+    "scope": "<strong>CNA Scope:</strong> Vulnerabilities in software, services, and open-source projects developed, maintained, or distributed by Anthropic. This includes Claude Code, Claude Desktop, browser extensions, the Model Context Protocol (MCP) SDKs and reference servers, Anthropic API client SDKs, and related developer tooling published under the Anthropic, anthropic-experimental, and modelcontextprotocol GitHub organizations.<br/><br/><strong><a href='/Resources/Roles/Cnas/FrontierAiResearcherCNAsPilot.pdf' target='_blank'>Frontier AI Researcher CVE Numbering Authorities (CNAs) Pilot</a> Scope:</strong> Vulnerabilities discovered by Anthropic that are not within another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security-cna@anthropic.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Disclosure Policy",
+        "language": "",
+        "url": "https://www.anthropic.com/responsible-disclosure-policy"
+      },
+      {
+        "label": "AI Researcher Disclosure Policy",
+        "language": "",
+        "url": "https://www.anthropic.com/coordinated-vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Security Advisories",
+          "url": "https://trust.anthropic.com/resources#6a44049fd659a87d0068f0c5"
+        },
+        {
+          "label": "CVD Program Advisories",
+          "url": "https://red.anthropic.com/2026/cvd/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "AI Researcher (Frontier AI Researcher CVE Numbering Authorities (CNAs) Pilot)"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "hsi",
+    "cnaID": "CNA-2026-0053",
+    "organizationName": "Haverford Systems, Inc.",
+    "scope": "All products for Haverford Systems brands, PTZOptics and HuddleCamHD (supported products and end-of-life/end-of-service products), as well as vulnerabilities in third-party software discovered by Haverford Systems that are not in another CNA\u2019s scope.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@havsys.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://psirt.havsys.com/disclosure-policy.pdf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://ptzoptics.com/known-vulnerabilities-and-fixes/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "NCSC",
+    "cnaID": "CNA-2026-0054",
+    "organizationName": "NATO Cyber Security Centre",
+    "scope": "Vulnerabilities in commercial off-the-shelf software (COTS) selected for inclusion in the NATO Approved Software List (A2SL) that are not in the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "pentest@ncia.nato.int"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://github.com/NCSC-Assess/Disclosure-Policy/blob/main/policy.md"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://github.com/NCSC-Assess/Advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Belgium"
+  },
+  {
+    "shortName": "postiz",
+    "cnaID": "CNA-2026-0055",
+    "organizationName": "Postiz",
+    "scope": "Postiz products and projects only including: the core repository for postiz-app (github.com/gitroomhq/postiz-app); all gitroomhq repositories that are official components, tooling, or integrations of Postiz; official Postiz container images published under gitroomhq on GHCR; official Postiz CLI tools and NPM packages (NPM org: @postiz); Postiz-Cloud related infrastructure and services. (API, Frontend, Configurations etc.); and plugins for Postiz maintained within the gitroomhq organization.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Postiz Security Contact page",
+            "url": "https://postiz.gadvisory.org/request"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Disclosure Policy",
+        "language": "",
+        "url": "https://github.com/gitroomhq/postiz-app/blob/main/SECURITY.md"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://postiz.gadvisory.org/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor",
+        "Open Source",
+        "Hosted Service"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "Syncro",
+    "cnaID": "CNA-2026-0056",
+    "organizationName": "Syncro Soft SRL",
+    "scope": "All Syncro Soft SRL products, including Oxygen XML suite of products, published on <a href='https://www.oxygenxml.com' target='_blank'>https://www.oxygenxml.com</a> including end-of-life/end-of-service products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@oxygenxml.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Disclosure Policy",
+        "language": "",
+        "url": "https://www.oxygenxml.com/security/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.oxygenxml.com/security/advisories.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Romania"
+  },
+  {
+    "shortName": "Ubiquiti",
+    "cnaID": "CNA-2026-0057",
+    "organizationName": "Ubiquiti, Inc.",
+    "scope": "Vulnerabilities in all Ubiquiti products and products of Ubiquiti subsidiaries only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@ui.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Disclosure Policy",
+        "language": "",
+        "url": "http://ui.com/downloads/compliance/vulnerability-disclosure-policy.pdf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://community.ui.com/releases?security-updates"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "wibu",
+    "cnaID": "CNA-2026-0058",
+    "organizationName": "WIBU-SYSTEMS AG",
+    "scope": "WIBU-SYSTEMS products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cert@wibu.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.wibu.com/.well-known/WIBU-SYSTEMS_Vulnerability_Disclosure_Policy.pdf"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.wibu.com/support/security-advisories.html"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "Grayback",
+    "cnaID": "CNA-2026-0059",
+    "organizationName": "Grayback Security",
+    "scope": "Vulnerabilities identified by Grayback or third parties in the programs listed at <a href='https://app.grayback.es/programs' target='_blank'>https://app.grayback.es/programs</a>.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@grayback.es"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy (Spanish)",
+        "language": "Spanish",
+        "url": "https://www.grayback.es/disclosure-policy"
+      },
+      {
+        "label": "Policy (English)",
+        "language": "English",
+        "url": "https://www.grayback.es/en/disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.grayback.es/en/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "type": [
+        "Bug Bounty Provider"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "Circutor",
+    "cnaID": "CNA-2026-0060",
+    "organizationName": "Circutor",
+    "scope": "All vulnerabilities affecting Circutor and Circontrol products.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "psirt@circutor.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://circutor.sharepoint.com/:b:/s/GestorDocumental/IQBd8ld4COldTb18_WDDF_OvAZRXTbSyciP5rYwXBDoDyVw?e=gL9GNd"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://circutor.com/soporte/ciberseguridad/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "Velneo",
+    "cnaID": "CNA-2026-0061",
+    "organizationName": "Velneo",
+    "scope": "Vulnerabilities in all Velneo brand products and technologies, including software components, application servers, runtime environments, development environments, and cloud services, unless they are covered by the more specific scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@velneo.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://velneo.es/mivelneo/politica-de-divulgacion-de-vulnerabilidades/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://velneo.es/avisos-de-seguridad/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "INCIBE",
+        "organizationName": "Spanish National Cybersecurity Institute, S.A. (INCIBE)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Spain"
+  },
+  {
+    "shortName": "S4M",
+    "cnaID": "CNA-2026-0062",
+    "organizationName": "Security4Media",
+    "scope": "Vulnerabilities in specialized software or hardware used in media and broadcasting, discovered by or reported to Security4Media, that are not in the scope of another CNA.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "info@security4media.org"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://security4media.org/disclosurepolicy/"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://security4media.org/cve-infos/"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Switzerland"
+  },
+  {
+    "shortName": "Airoha",
+    "cnaID": "CNA-2026-0063",
+    "organizationName": "Airoha Technology Corp.",
+    "scope": "Airoha product issues only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@airoha.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.airoha.com/about/governance/intellectual/security-contact#disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.airoha.com/product-security-bulletin"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "n/a",
+        "organizationName": "n/a"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "type": [
+        "Vendor"
+      ]
+    },
+    "country": "Taiwan"
+  },
+  {
+    "shortName": "Zenitel",
+    "cnaID": "CNA-2026-0064",
+    "organizationName": "Zenitel Norway AS",
+    "scope": "Zenitel products only.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@zenitel.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://zenitel.com/security/vulnerability-disclosure"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://zenitel.com/security/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Norway"
+  },
+  {
+    "shortName": "esaqa",
+    "cnaID": "CNA-2026-0065",
+    "organizationName": "esaqa GmbH",
+    "scope": "All products developed and maintained by esaqa GmbH.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@esaqa.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://esaqa.com/vulnerability-disclosure-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://gitlab.com/esaqa/esaqa/security-advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "ENISA",
+        "organizationName": "EU Agency for Cybersecurity (ENISA)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "mitre",
+        "organizationName": "MITRE Corporation"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "Germany"
+  },
+  {
+    "shortName": "HONA",
+    "cnaID": "CNA-2026-0066",
+    "organizationName": "Honeywell Aerospace",
+    "scope": "All Honeywell Aerospace products.",
+    "contact": [
+      {
+        "email": [],
+        "contact": [
+          {
+            "label": "Report a Vulnerability page",
+            "url": "https://www.honeywellaerospace.com/us/en/product-security"
+          }
+        ],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.honeywellaerospace.com/us/en/product-security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://www.honeywellaerospace.com/us/en/product-security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "RES",
+    "cnaID": "CNA-2026-0067",
+    "organizationName": "RedEye Security",
+    "scope": "Vulnerabilities in RedEye Security\u2019s own products: software that RedEye develops and distributes for customers to deploy and operate in their own environments. Caver, RedEye\u2019s self-hosted, Splunk-compatible SIEM and OCSF data-lake platform, including its server components, collectors and agents, command-line tooling, and officially distributed installers and container images. Out of scope: vulnerabilities in third-party components and dependencies that RedEye redistributes but does not maintain; vulnerabilities in RedEye-operated hosted services and web properties that RedEye remediates server-side with no customer action required; and the content of RedEye\u2019s threat-intelligence and CVE detection feeds.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "security@redeyesecurity.com"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://redeyesecurity.com/security"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://redeyesecurity.com/security/advisories"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  },
+  {
+    "shortName": "chainguard",
+    "cnaID": "CNA-2026-0068",
+    "organizationName": "Chainguard, Inc.",
+    "scope": "Chainguard Containers/Libraries/VMs, tooling, and vulnerabilities introduced by our packaging or patching of Wolfi packages (upstream flaws in packaged software excluded). Additionally, vulnerabilities in open source projects identified through the Athena coalition, where upstream has remediated without an assigned identifier, or where no maintainer is active, and no more specific CNA covers the project.",
+    "contact": [
+      {
+        "email": [
+          {
+            "label": "Email",
+            "emailAddr": "cna@chainguard.dev"
+          }
+        ],
+        "contact": [],
+        "form": []
+      }
+    ],
+    "disclosurePolicy": [
+      {
+        "label": "Policy",
+        "language": "",
+        "url": "https://www.chainguard.dev/legal/coordinated-vulnerability-handling-policy"
+      }
+    ],
+    "securityAdvisories": {
+      "alerts": [],
+      "advisories": [
+        {
+          "label": "Advisories",
+          "url": "https://images.chainguard.dev/security"
+        }
+      ]
+    },
+    "resources": [],
+    "CNA": {
+      "isRoot": false,
+      "root": {
+        "shortName": "icscert",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)"
+      },
+      "type": [
+        "Vendor",
+        "Hosted Service",
+        "Open Source",
+        "Researcher"
+      ],
+      "TLR": {
+        "shortName": "CISA",
+        "organizationName": "Cybersecurity and Infrastructure Security Agency (CISA)"
+      },
+      "roles": [
+        {
+          "helpText": "",
+          "role": "CNA"
+        }
+      ]
+    },
+    "country": "USA"
+  }
+]
\ No newline at end of file
diff --git a/data/cache/cna_name_map.json b/data/cache/cna_name_map.json
new file mode 100644
index 00000000000..c55d9c83cb7
--- /dev/null
+++ b/data/cache/cna_name_map.json
@@ -0,0 +1,502 @@
+{
+  "4a68d2b9-b68a-4765-95bd-17f35092666b": "1E Limited",
+  "be69f613-e5f6-419b-800c-30351aa8933c": "2N Telekomunikace a.s.",
+  "40f8fa2f-7875-43d0-a30e-e901a5537754": "360 Security Technology, Inc.",
+  "f5a594e6-46a7-4e60-8a08-0a786e70e433": "Dassault Syst\u00e8mes",
+  "e5d7a401-f4d6-4559-911a-da9b371cd8ce": "42Gears Mobility Systems Pvt Ltd",
+  "1d66c9f9-fff2-411a-aa19-ca6312fa25e9": "9front Systems",
+  "c09c270a-b464-47c1-9133-acb35b22c19a": "Protect AI",
+  "2b718523-d88f-4f37-9bbd-300c20644bf9": "Asea Brown Boveri Ltd.",
+  "41aa6afe-1500-4418-b88a-c03054d337df": "Analog Devices, Inc.",
+  "26969f82-7e87-44d8-9cb5-f6fb926ddd43": "Austin Hackers Anonymous",
+  "1a4f025a-074d-4105-b4e2-52bd8eabe2ea": "AISLE Incorporated",
+  "b58fc414-a1e4-4f92-9d70-1add41838648": "Advanced Micro Devices Inc.",
+  "7e9044f1-7f56-4c38-8864-c0c7302263d6": "AMI",
+  "ff89ba41-3aa1-4d27-914a-91399e9639e5": "Amazon",
+  "343c750b-1a7b-4cc9-8d3c-54320f491138": "Arcon Techsolutions Private Limited",
+  "68630edc-a58c-4cbd-9b01-0e130455c8ae": "ASR Microelectronics Co., Ltd.",
+  "c15abc07-96a9-4d11-a503-5d621bfe42ba": "Automotive Security Research Group (ASRG)",
+  "54bf65a7-a193-42d2-b1ba-8e150d3c35e1": "ASUSTeK Computer Incorporation",
+  "f35eaae9-79f2-4d0d-a5c7-7bea6ed6be77": "ASUSTOR Inc.",
+  "68e1e1d3-5247-4d65-9f39-ef1a02cf571e": "ATISoluciones Dise\u00f1o de Sistemas Electr\u00f3nicos, S.L.",
+  "b6533044-ea05-4482-8458-7bddeca0d079": "Absolute Software",
+  "8fc372e3-d9c5-46e4-9410-38469745c639": "Acer Inc.",
+  "73dc0fef-1c66-4a72-9d2d-0a0f4012c175": "Acronis International GmbH",
+  "5a3e03c4-1435-455d-97de-ca8ebb9bb79d": "Airlock by Ergon",
+  "34e3dd7a-f061-4e75-a5eb-9fce7dd970ab": "Airoha Technology Corp.",
+  "ca5f073f-8266-4d43-b3e3-6eb0bb18a738": "AlgoSec",
+  "dc524f69-879d-41dc-ab8f-724e78658a1a": "Alias Robotics S.L.",
+  "d3a2b522-ae05-4a18-9021-f3a9980c9e79": "Almaviva S.p.A.",
+  "04c0172e-9735-4a9d-a92a-fe01fa863447": "Altera",
+  "4760f414-e1ae-4ff1-bdad-c7a9c3538b79": "Altium",
+  "cc32bfe3-ea85-4e6c-be66-ec0978e01d7d": "Ampere Computing",
+  "cb8f1db9-b4b1-487b-a760-f65c4f368d8e": "OpenAnolis",
+  "1521590e-cbd7-42d6-a3ad-daaaf27e5ad2": "Antenna",
+  "98a01053-8a31-4f6d-9aa9-252be161adc6": "Anthropic, PBC",
+  "2c188fdb-58e1-4908-8fce-3e437b94f1ae": "AppCheck Ltd.",
+  "c8b34d1a-69ae-45c3-88fe-f3b3d44f39b7": "Arista Networks, Inc.",
+  "56a131ea-b967-4a0d-a41e-5f3549952846": "Arm Limited",
+  "dd59f033-460c-4b88-a075-d4d3fedb6191": "Armis, Inc.",
+  "234d70f9-0044-41cc-af73-5a8c1ad91dbe": "Arteche",
+  "7392e5a8-a524-41f3-8610-31fe55665a87": "Arxscan, Inc.",
+  "035b3f01-8d8d-46ce-893b-090f51e52bcd": "Automox Inc.",
+  "f2daf9a0-02c2-4b83-a01d-63b3b304b807": "Axis Communications AB",
+  "15ede60e-6fda-426e-be9c-e788f151a377": "AxxonSoft Limited",
+  "653264ec-f98b-4e8f-b8b4-540a01b7657d": "B. Braun SE",
+  "680fc732-2f93-4644-b832-4823a2307b35": "BAE Systems, Inc.",
+  "59469e6c-7ea7-446f-8e43-06aa32c115e8": "The Browser Company of New York",
+  "2325d071-eabf-4b7b-a4ea-0819b6629a18": "Becton, Dickinson and Company (BD)",
+  "787b8ffc-e8e5-441e-a05d-2f38be7849ac": "Beckman Coulter Diagnostics",
+  "4ad3d9a7-bd20-4af3-8862-46d6b5a570db": "Beckman Coulter Life Sciences",
+  "e0a5077a-1e68-4ee4-bddc-a375c097fc17": "Biohacking Village",
+  "27b6da8a-f51d-48d9-9eef-9b7f3405d20d": "Black Lantern Security",
+  "13061848-ea10-403d-bd75-c83a022c2891": "BeyondTrust Inc.",
+  "87064355-471e-4662-90e0-b44aa58c04c8": "Bulk Download Org",
+  "084566ad-deee-4e89-acff-6b7b1bf9d4b7": "Baicells Technologies Co., Ltd.",
+  "7b443bca-21a2-4df8-b477-ec36491d9932": "Baidu, Inc.",
+  "dba971b9-eb30-4121-91e1-3b45611354aa": "Baxter Healthcare",
+  "b3d5ebe7-963e-41fb-98e1-2edaeabb8f82": "Bitdefender",
+  "8cad7728-009c-4a3d-a95e-ca62e6ff8a0b": "Black Duck Software, Inc.",
+  "aa17e1a1-c329-4d6e-a1ed-8d0188aea082": "Bombadil Systems LLC",
+  "4ac701fe-44e9-4bcd-9585-dd6449257611": "Bugcrowd Inc.",
+  "5bcc34ac-0282-4e8a-96fc-046c583d3048": "Bull SAS",
+  "7355b6a3-0978-4b03-b73e-1260473ccd13": "ByteDance, Ltd.",
+  "4b64e669-e209-4c76-9214-404e7514e4a5": "Cepheid",
+  "66834db9-ab24-42b4-be80-296b2e40335c": "Indian Computer Emergency Response Team (CERT-In)",
+  "4bb8329e-dd38-46c1-aafb-9bf32bcb93c6": "CERT.PL",
+  "270ccfa6-a436-4e77-922e-914ec3a9685c": "CERT@VDE",
+  "4dc25b0b-6629-412f-8bc9-2791ce2a7c5d": "CERT@VDE",
+  "fcaade79-89af-42a2-9990-f53b2bb16ffd": "CERT@VDE",
+  "5a6e4751-2f3f-4070-9419-94fb35b644e8": "Computer Incident Response Center Luxembourg",
+  "134c704f-9b21-4f2e-91b3-4a467353bcc0": "CISA-ADP",
+  "4f6b02d3-7d8f-49c4-97a2-c13be7fbec6f": "CISA-WEB",
+  "30aa36b7-a224-4bc9-b7d3-abea20aa4887": "CODRA",
+  "9b29abf9-4ab0-4765-b253-1875cd9b441e": "CPAN Security Group",
+  "5f57b9bf-260d-4433-bf07-b6a79e9bb7d4": "Cyber Security Agency of Singapore",
+  "6b84742c-cd87-4dbd-810c-dc7b220241cc": "Cloud Security Alliance",
+  "ee1bbb37-1770-46bd-bba8-910037954ee0": "Cyber Security Works Pvt. Ltd.",
+  "2178e952-2986-45b6-b8f2-5bf9ee8fd4f6": "CTOne Inc.",
+  "af854a3a-2127-422b-91ae-364da2661108": "CVE Program",
+  "b01ddd03-5ef6-483b-b2c5-acba77f1a554": "Caliptra Project",
+  "f98c90f0-e9bd-4fa7-911b-51993f3571fd": "Canon Inc.",
+  "4586e0a2-224d-4f8a-9cb4-8882b208c0b3": "Canon EMEA",
+  "61adb53e-e4b3-47f7-8a93-4717c9e77dc6": "Canva",
+  "e24e6442-3ae1-4538-a7b8-7ac95586db8f": "Carrier Global Corporation",
+  "2505284f-8ffb-486c-bf60-e19c1097a90b": "Cato Networks",
+  "f2a9712a-1544-417f-836a-2cf81e524170": "Censys",
+  "bd4443e6-1eef-43f3-9886-25fc9ceeaae7": "Centreon",
+  "596c5446-0ce5-4ba2-aa66-48b3b757a647": "Checkmarx",
+  "f7d6281c-4801-44ce-ace2-493291dedb0f": "Checkmk GmbH",
+  "ebfee0ef-53dd-4cf3-9e2a-08a5bd7a7e28": "Chrome",
+  "7f6e188d-c52a-4a19-8674-3c3fa7d1fc7f": "ChromeOS Project",
+  "7bd90cf1-1651-495e-9ae8-9415fb3c9feb": "Ciena Corporation",
+  "59aea6fb-2240-4284-b9fd-48e3851c2128": "Circutor",
+  "e437aed5-38e0-4fa3-a98b-cb73e7acaec6": "Citrix Systems, Inc.",
+  "cb7ba516-3b07-4c98-b0c2-715220f1a8f6": "ClickHouse, Inc.",
+  "66ea3993-44a4-4fa9-a940-7c877137164c": "Coalfire Labs",
+  "050066fd-a2f9-4f32-ab5d-4c53f48bc333": "Commvault Systems Inc",
+  "ff5b8ace-8b95-4078-9743-eac1ca5451de": "Concrete CMS",
+  "7d616e1a-3288-43b1-a0dd-0a65d3e70a49": "ConnectWise LLC",
+  "68870bb1-d075-4169-957d-e580b18692b9": "SHENZHEN CoolKit Technology CO., LTD.",
+  "25b0b659-c4b4-483f-aecb-067757d23ef3": "Crestron Electronics, Inc.",
+  "af879a92-7297-456a-bb0e-905ac6c64bdc": "Cribl, Inc.",
+  "13ddcd98-6f4a-40a8-8e24-29ca0aee4661": "CrowdStrike Holdings, Inc.",
+  "24e70c8d-eeca-431d-8285-199a41b4014e": "Cybellum Technologies LTD",
+  "96148269-fe82-4198-b1bf-3a73ce8bc92e": "CyberArk Labs",
+  "7d092a75-6bbd-48c6-a15a-0297458009bc": "CyberDanube",
+  "27cb0907-61e9-450e-a955-163567771b21": "Cynet Security Inc",
+  "57bb28e2-988a-4cc7-a455-5d42e7c90de2": "Cytiva",
+  "bfee16bd-18e6-446c-9a65-f5b2e3d89c23": "Devolutions Inc.",
+  "e666a739-ec3b-46a8-8d97-3f0729afca0e": "The HISP Centre at the University of Oslo",
+  "b87402ff-ae37-4194-9dae-31abdbd6f217": "Dutch Institute for Vulnerability Disclosure (DIVD)",
+  "6a34fbeb-21d4-45e7-8e0a-62b95bc12c92": "Django Software Foundation",
+  "b98feede-7066-4b27-a111-28762b394a3e": "DTEX Systems, Inc.",
+  "d7ff35af-cf88-454c-bab9-af60602f10f8": "Danfoss",
+  "17539d52-06bd-4776-9c7a-95dc115e9083": "DeepSurface Security, Inc.",
+  "1443cd92-d354-46d2-9290-d812316ca43a": "Delinea, Inc.",
+  "759f5e80-c8e1-4224-bead-956d7b33c98b": "Delta Electronics, Inc.",
+  "c9684ca8-242e-45f6-aa30-5f918acec317": "DevCycle",
+  "6b35d637-e00f-4228-858c-b20ad6e1d07b": "Dfinity Foundation",
+  "e8a6bb0b-e373-42b1-a5de-93e314325576": "Digi International Inc.",
+  "686469e6-3ff6-451b-ab8b-cf5b9e89401e": "Docker Inc.",
+  "4fe7d05b-1353-44cc-8b7a-1e416936dff2": "Document Foundation, The",
+  "12bdf821-1545-4a87-aac5-61670cc6fcef": "Dragos, Inc.",
+  "05b98450-cf83-4905-9546-e47a66a8fec2": "Dremio Corporation",
+  "dd6125b6-b251-4b06-8913-f3c5b13dab39": "Dual Vipers",
+  "442d7a9f-d735-4edc-91a9-bdd618cbff51": "Electronic Arts, Inc.",
+  "20be33e2-bf35-4d13-8fad-18bd2f3e3659": "EnterpriseDB Corporation",
+  "6b3ad84c-e1a6-4bf7-a703-f496b71e49db": "Erlang Ecosystem Foundation",
+  "36106deb-8e95-420b-a0a0-e70af5d245df": "ELAN Microelectronics Corp.",
+  "a6d3dc9e-0591-4a13-bce7-0f5b31ff6158": "EU Agency for Cybersecurity (ENISA)",
+  "c7ff4023-84df-4ad5-938c-aa18879f9c9a": "EU Agency for Cybersecurity (ENISA)",
+  "85b1779b-6ecd-4f52-bcc5-73eac4659dcf": "Ericsson",
+  "4a9b9929-2450-4021-b7b9-469a0255b215": "ESET, spol. s r.o.",
+  "63703b7d-23e2-41ef-94b3-a3c6333f7759": "Eaton",
+  "abd028dc-c042-4c4d-9749-38d0f850af89": "Echo Software Ltd",
+  "8ca67973-55d1-4246-bb7c-ce7e65ad8782": "Edgewatch Security Intelligence",
+  "a5eeab90-a3f7-4c12-814a-9e4a377371d5": "Entrust Corporation",
+  "cedc17bb-4939-4f40-a1f4-30ae8af1094e": "Environmental Systems Research Institute, Inc. (Esri)",
+  "3895c224-4e1d-482a-adb3-fa64795683ac": "Everpure, Inc.",
+  "1c053176-eef3-4d6a-ae0b-24728c86587b": "Extreme Networks, Inc.",
+  "126858f1-1b65-4b74-81ca-7034f7f7723f": "F-Secure",
+  "47e4fddc-a2f1-48a0-beab-943c84c1c954": "Fujifilm Business Innovation Corp.",
+  "539080bd-5750-4cce-b30b-eed9a4ef6dcc": "Fermax Technologies SLU",
+  "fb6462e6-781a-4ab2-8658-077d5bd973cc": "Frappe Technologies Pvt. Ltd.",
+  "09832df1-09c1-45b4-8a85-16c601d30feb": "Financial Security Institute (FSI)",
+  "5ac195ad-69e7-48e7-9c1e-bfc958c39761": "FPT SOFTWARE CO., LTD",
+  "763b0cbd-1a52-41de-b280-f255286be201": "Fsas Technologies",
+  "7b3a0a97-1010-475c-bf70-fd02f6461e21": "FULL INTERNET",
+  "11ea3a0d-87b4-4e67-a1fa-f5a6be5d6676": "Fidelis Security, LLC",
+  "84fe0718-d6bb-4716-a7e8-81a6d1daa869": "Fluid Attacks",
+  "a14582b7-06f4-4d66-8e82-3d7ba3739e88": "Forescout Technologies",
+  "6b18ae97-0aab-4af2-9ba4-74b2b139ddfa": "ForgeRock Inc.",
+  "df4dee71-de3a-4139-9588-11b62fe6c0ff": "Fortra, LLC",
+  "14984358-7092-470d-8f34-ade47a7658a2": "Foxit Software Incorporated",
+  "171caf72-b841-4e04-a68e-93493aff2b94": "GE Healthcare",
+  "dbd8429d-f261-4b1e-94cc-ae3132817e2e": "Gen Digital Inc.",
+  "2cf0fb33-79e2-44e0-beb8-826cc5ce3250": "GE Vernova",
+  "57da9224-a3e2-4646-9d0e-c4dc2e05e7da": "Grafana Labs",
+  "b032eb24-20d9-4339-ace7-0ff5ed06c339": "GS McNamara LLC",
+  "0df08a0e-a200-4957-9bb0-084f562506f9": "GeoVision Inc.",
+  "0c426f27-3ee1-4eff-be88-288d5a1822bc": "Gallagher Group Ltd",
+  "ace9cabe-4f4f-416b-8c39-b0e002761924": "Glyph & Cog, LLC",
+  "f2b06212-cb4b-41a4-9501-fa2e367495b8": "Genetec Inc.",
+  "a0819718-46f1-4df5-94e2-005712e83aaa": "GitHub (maintainer security advisories)",
+  "82327ea3-741d-41e4-88f8-2cf9e791e760": "GitHub Inc, (Products Only)",
+  "ceab7361-8a18-47b1-92ba-4d7d25f6715a": "GitLab Inc.",
+  "88ee5874-cf24-4952-aea0-31affedb7ff2": "Gitea Limited",
+  "1bb62c36-49e3-4200-9d77-64a1400537cc": "Go Project",
+  "14ed7db2-1595-443d-9d34-6215bf890778": "Google LLC",
+  "f736148d-52c1-4e4d-a7ac-fc90135696b9": "Google LLC",
+  "f45cbf4e-4146-4068-b7e1-655ffc2c548c": "Google Cloud",
+  "1ea499d5-4dc2-4c43-8d69-d7cbe07d1359": "Google Open Source Software",
+  "83238938-5644-45f0-9007-c0392bcf6222": "Google Devices",
+  "1a37b84a-8e51-4525-b3d6-87e2fae01dbd": "Government Technology Agency of Singapore Cyber Security Group",
+  "772f0079-75c2-41ca-913e-d9072716578b": "Grayback Security",
+  "6a7d5611-ec52-41f4-b33a-a457deec1320": "Green Rocket Security Inc.",
+  "b7efe717-a805-47cf-8e9a-921fca0ce0ce": "Gridware Cybersecurity",
+  "1e47fe04-f25f-42fa-b674-36de2c5e3cfc": "HCL Software",
+  "0253b833-3e77-4dfe-9d57-17db1a2f0a74": "The HDF Group",
+  "691c08ec-8258-4a34-b4f4-2c8dd8a5a6fe": "HDS a.s. , Slovakia",
+  "dce6e192-ff49-4263-9134-f0beccb9bc13": "Hitachi Vantara",
+  "065f5ffc-e71d-4927-83ac-42cd1909ab14": "Honeywell Aerospace",
+  "ff95705b-1a40-4639-8017-a58fa868baee": "Hallo Welt! GmbH",
+  "0dc7baee-4a9f-419f-bd0a-e21ec5dac512": "HYPR Corp",
+  "ffb98d57-deaa-4918-a669-5225ccc13e39": "HackRTU",
+  "7004884b-51e2-48e8-b4a2-5ca29e80453e": "Hackrate Kft.",
+  "79d7e77b-4bd9-4e64-ae2c-02965b1d2b73": "Halborn",
+  "fc9afe74-3f80-4fb7-a313-e6f036a89882": "Hanwha Vision Co., Ltd.",
+  "67fedba0-ff2e-4543-ba5b-aa93e87718cc": "HashiCorp Inc.",
+  "42c92647-e108-4257-8e69-88a778eca73b": "HemoCue AB",
+  "36c7be3b-2937-45df-85ea-ca7133ea542c": "HeroDevs",
+  "6f8de1f0-f67e-45a6-b68f-98777fdb759c": "HiddenLayer, Inc.",
+  "2b565742-f273-46f9-b583-07c1fcdea31a": "Hillstone Networks Inc.",
+  "50d0f415-c707-4733-9afc-8f6c0e9b3f82": "Hitachi, Ltd.",
+  "e383dce4-0c27-4495-91c4-0db157728d17": "Hitachi Energy",
+  "ee257e46-ecd1-4f55-b658-3889ba148f5a": "Hologic, Inc.",
+  "0dc86260-d7e3-4e81-ba06-3508e030ce8d": "Honeywell International Inc.",
+  "3836d913-7555-4dd0-a509-f5667fdf5fe4": "Honor Device Co., Ltd.",
+  "5dacb0b8-2277-4717-899c-254586fe4912": "Huntress Labs Inc.",
+  "56c94bcb-ac34-4d7f-b660-d297a6b7ff82": "Integrated Control Technology LTD",
+  "8be6d43e-04e8-46c1-9d44-11b9f55fa4eb": "ID Business Solutions",
+  "a87f365f-9d39-4848-9b3a-58c7cae69cab": "IDEMIA",
+  "79c06a19-4450-43d2-b569-68e8c9aecf87": "Integrated DNA Technologies, Inc.",
+  "a57ee1ae-c9c1-4f40-aa7b-cf10760fde3f": "Israel National Cyber Directorate",
+  "0cbda920-cd7f-484a-8e76-bf7f4b7f4516": "Spanish National Cybersecurity Institute, S.A.",
+  "62b06128-63d9-4806-baf8-94bcbb3730d6": "Spanish National Cybersecurity Institute, S.A. (INCIBE)",
+  "4237bc98-ed97-4aeb-8e67-37a47a9e179d": "IQSIGHT B.V.",
+  "ea070963-4842-4451-bceb-906a17f8dc69": "Illumio",
+  "8338d8cb-57f7-4252-abc0-96fd13e98d21": "Insyde Software",
+  "3ba556a3-57d7-4c5d-b460-9d6daa180ee1": "Intigriti",
+  "3a96e08e-f252-4cef-abdb-d6d0e8542541": "IoT83 Ltd",
+  "67325c3f-c596-46c5-a235-e1a1e73abe4e": "Jamf",
+  "48a46f29-ae42-4e1d-90dd-c1676c1e5e6d": "JFrog",
+  "db6d2600-d19b-4111-a010-f3c4ed70cd50": "Jaspersoft",
+  "547ada31-17d8-4964-bc5f-1b8238ba8014": "JetBrains s.r.o.",
+  "6ff30186-7fb7-4ad9-be33-533e7b05e586": "The Joomla! Project",
+  "1086eaff-806a-4eb6-9faf-dc17462e6621": "JupiterOne, Inc.",
+  "a2e6421e-a653-4ece-8310-44b860954e0e": "KCF Technologies, Inc.",
+  "296541fb-a0e3-4ca7-ab3d-683e666d143e": "KNIME AG",
+  "e45d732a-8f6b-4b6b-be76-7420f6a2b988": "Kaspersky",
+  "2d016d95-e9db-46d1-ba13-90699261154b": "Keeper Security, Inc.",
+  "02762ae7-200e-4b20-9b2b-a77d5b8fc4cb": "Kong Inc.",
+  "bbf0bd87-ece2-41be-b873-96928ee8fab9": "KoreLogic Security",
+  "e5bd9809-e237-4575-952b-81f8a96826ee": "KrakenD, S.L.",
+  "42f21055-226c-4bce-a3c8-ecf55a3551fb": "LG Electronics",
+  "e85693ac-4252-46b2-8d11-0473fe226189": "Leica Microsystems",
+  "657f3255-0560-4aed-82e4-7f579ec6acfb": "LY Corporation",
+  "74152744-3f64-4a72-ae83-344e711f5f7d": "Leica Biosystems",
+  "8e3ba3f5-47c4-402c-abcd-41d42167cf63": "Leonardo S.p.A.",
+  "7bc73191-a2b6-4c63-9918-753964601853": "Lexmark International Inc.",
+  "8b54e794-c6f0-462e-9faa-c1001a673ac3": "Liferay, Inc.",
+  "416baaa9-dc9f-4396-8d5f-8c081fb06d67": "kernel.org",
+  "b573e801-1dd3-4adf-bd73-c9b814fbe067": "Logitech",
+  "bcf7a16e-bfdc-46e4-9e42-4187da3f4410": "M-Files Corporation",
+  "56a186b1-7f5e-4314-ba38-38d5499fccfd": "Maritime Hacking Village",
+  "f77a3b2e-a86f-4a4e-80d3-3d1378fbb974": "MIM Software Inc.",
+  "9c1820ae-fb77-4810-a8aa-ca46e7474d2f": "Monash University - Cyber Security Incident Response Team",
+  "974a0f82-723c-4ff6-9d9e-2b7fac2ba1ab": "Mammotome",
+  "027e81ed-0dd4-4685-ab4d-884aec5bb484": "Mandiant Inc.",
+  "9302f53e-dde5-4bf3-b2f2-a83f91ac0eee": "Mattermost, Inc",
+  "4e531c38-7a33-45d3-98dd-d909c0d8852e": "Mautic",
+  "ee979b05-11f8-4f25-a7e0-a1fa9c190374": "MediaTek, Inc.",
+  "3c337f33-b2bd-4529-9792-f48cdb2838b4": "Medtronic",
+  "478c68dd-22c1-4a41-97cd-654224dfacff": "Mend",
+  "4fc57720-52fe-4431-a0fb-3d2c8747b827": "Meta Platforms, Inc.",
+  "dc3f6da9-85b5-4a73-84a2-2ec90b40fca5": "Microchip Technology",
+  "cf45122d-9d50-442a-9b23-e05cde9943d8": "Milestone Systems A/S",
+  "ac17a704-eccd-4263-a802-5cee95c1d547": "Mirantis",
+  "e0f77b61-78fd-4786-b3fb-1ee347a748ad": "Mitsubishi Electric Corporation",
+  "f4c121f3-f405-4fcc-84f2-1ec93574a404": "Molecular Devices",
+  "2e0a0ee2-d866-482a-9f5e-ac03d156dbaa": "Moxa Inc.",
+  "a5532a13-c4dd-4202-bef1-e0b8f2f8d12b": "N-able",
+  "47237f96-ddbe-4467-a5ee-293a770beacd": "NATO Cyber Security Centre",
+  "db4dfee8-a97e-4877-bfae-eba6d14a2166": "National Cyber Security Centre Finland",
+  "cf4a7ff5-dd38-4ede-a530-ffaa7ea59c39": "National Cyber Security Centre - Netherlands (NCSC-NL)",
+  "455daabc-a392-441d-aa46-37d35189897c": "Switzerland National Cyber Security Centre (NCSC)",
+  "f2760a35-e0d8-4637-ac4c-cc1a2de3e282": "NEC Corporation",
+  "a2826606-91e7-4eb6-899e-8484bd4575d5": "NETGEAR",
+  "bca5b2e8-03a4-4781-b4ca-c6a078c0bfd4": "National Instruments",
+  "e9ecf56c-646d-4b4e-a9b1-f838732727c6": "NIBE Group",
+  "206fc3a0-e175-490b-9eaa-a5738056c9f6": "NLnet Labs",
+  "96d4e157-0bf0-48b3-8efd-382c68caf4e0": "Network Optix",
+  "3b236295-4ccd-4a1f-a1c1-a72eecc8d7b6": "Neo4j",
+  "5ccc118b-b6ed-4e23-9af6-6cd82d99b891": "NetRise",
+  "50a63c94-1ea7-4568-8c11-eb79e7c5a2b5": "NetScaler",
+  "bf992f6a-e49d-4e94-9479-c4cff32c62bc": "Netskope",
+  "60e0823a-f1a8-4923-bd51-812de398c42c": "Nintendo Co., Ltd.",
+  "b48c3b8f-639e-4c16-8725-497bc411dad0": "Nokia",
+  "bec8025f-a851-46e5-b3a3-058e6b0aa23c": "Nozomi Networks Inc.",
+  "2ffdacf6-8681-47df-b023-4f11abd61c1d": "Nutanix",
+  "8f4f43ab-ba69-4d92-aa1d-d772184d6fb7": "OpenAI",
+  "7f247420-63a8-4d59-ac93-d85dd04cd014": "OceanBase",
+  "6064c9f1-42e5-4cc5-a67a-1636d7a9d3fd": "Orange Cyberdefense",
+  "8a9629cb-c5e7-4d2a-a894-111e8039b7ea": "Open Design Alliance",
+  "57995746-fc30-4a4d-94f6-a13d079c41f4": "OMICRON electronics",
+  "bba440f9-ef23-4224-aa62-7ac0935d18d1": "OMRON Corporation",
+  "2d533b80-6e4a-4e20-93e2-171235122846": "ONEKEY GmbH",
+  "7f2b1ad8-5432-4d64-91a1-9099af1cc695": "OPPO",
+  "f47b0b3c-2275-4575-b915-297849b1fddf": "OpenSource Security GmbH",
+  "2e1bf29f-dc29-4ed8-830c-7b9348b6f0e8": "OTRS AG",
+  "8ce71d90-2354-404b-a86e-bec2cc4e6981": "Open-Xchange",
+  "6f4f8c89-ef06-4bae-a2a5-6734ddf76272": "Octopus Deploy",
+  "59b22baa-87b2-4371-8e4a-e080df12f74a": "Okta",
+  "de5a6978-88fe-4c27-a7df-d0d5b52d5b52": "Omnissa, LLC",
+  "8471e5c7-5028-4216-879d-e92a25514b01": "OnLogic",
+  "7eaec9cd-e18a-43f9-bb90-5f82d308c514": "The OpenBMC Project",
+  "03686db1-8513-43c4-b487-c6ad847afd3a": "OpenCloudOS Community",
+  "0cf5dd6e-1214-4398-a481-30441e48fafd": "OpenHarmony",
+  "70b007e9-5235-4ee5-90b5-a71a81beeda0": "The OpenNMS Group",
+  "f81092c5-7f14-476d-80dc-24857f90be84": "OpenText (formerly Micro Focus)",
+  "36a55730-e66d-4d39-8ca6-3c3b3017965e": "OpenVPN Inc.",
+  "9aee7086-24f5-48b4-9428-908ac90b8b54": "Opera Norway AS",
+  "ab69c47f-b95e-4bf2-b2d9-4b1fd1b24b4a": "Project Black",
+  "28c92f92-d60d-412d-b760-e73465c3df22": "Python Software Foundation",
+  "0b655efc-079c-4cb9-9e8d-164871239f4e": "PTC Inc.",
+  "bbcbe11d-db20-4bc2-8a6e-c79f87041fd4": "Palantir Technologies",
+  "2437d4d6-30d0-455c-a503-2cc33fee5e7b": "Pall Corporation",
+  "2163caeb-3942-4e93-a74b-8c75338146ce": "Panasonic Holdings Corporation",
+  "63375d6c-d89a-45ed-8ecc-c8c361b0e04c": "Pandora FMS",
+  "3fd9ee05-5fa9-4b45-beea-026ef6883a4b": "Pangea Cyber Corporation",
+  "eb41dac7-0af8-4f84-9f6d-0272772514f4": "PaperCut Software Pty Ltd",
+  "21595511-bba5-4825-b968-b78d1f9984a3": "Patchstack O\u00dc",
+  "769c9ae7-73c3-4e47-ae19-903170fc3eb8": "Payara",
+  "c91e5604-2bd1-401f-a0ec-b25342b57ef9": "Pegasystems",
+  "41c37e40-543d-43a2-b660-2fee83ea851a": "Pentraze Cybersecurity",
+  "ca2a266c-be2f-4d4b-92d0-47b76b1a9c4e": "Perforce",
+  "20705f08-db8b-4497-8f94-7eea62317651": "Philips",
+  "22d9ba52-f336-4b0d-bf1f-0efbdcc3c1de": "Phoenix Technologies, Inc.",
+  "5998a2e9-ae88-42cd-b6e0-7564fd979f9e": "Ping Identity Corporation",
+  "de71880c-95a5-4720-a0d3-dd544d4cd160": "PingCAP (US), Inc.",
+  "5fea7123-217b-4b2d-ada8-8892719b43cd": "PlexTrac, Inc.",
+  "f86ef6dc-4d3a-42ad-8f28-e6d5547a5007": "PostgreSQL",
+  "3039e14d-1e9f-46c2-98a6-44436e4ca5d5": "Profelis IT Consultancy",
+  "c0ec9282-ea44-45d7-9b32-48d87cb37538": "Profisee Group, Inc.",
+  "f9fea0b6-671e-4eea-8fde-31911902ae05": "Progress Software Corporation",
+  "d83a79dd-e128-4b83-8b64-84faf54eed46": "Proofpoint Inc.",
+  "b2fa7fcc-7d08-41f0-853b-11242c5539db": "Proton AG",
+  "feb22aaf-0d24-412e-a9d3-326c30e47313": "Quanta Computer, Inc.",
+  "a59d8014-47c4-4630-ab43-e1b13cbe58e3": "Qt Group",
+  "8a309ac4-d8c7-4735-9c1d-ca39c5dfbcda": "Qualys, Inc.",
+  "023dfa14-4ddb-486e-ab2e-b8f6dce2973d": "RedEye Security",
+  "c99a06c2-e59b-4bc4-a99f-772c1a5b62ad": "Rhino Mobility",
+  "3f572a00-62e2-4423-959a-7ea25eff1638": "Real-Time Innovations, Inc.",
+  "46b595e9-1acc-41cb-9398-adaf98d37a9b": "Radiometer Medical ApS",
+  "40c1df6c-c2a6-49c2-8d4d-e1aecdebdcb1": "RealPage",
+  "7d06583b-61c8-4499-8067-80a92a3b48e1": "Replicated, Inc.",
+  "6504adb2-f5e9-4c9b-9eda-5e19c93bd9b3": "Ribose Limited",
+  "5cdcf916-2b10-4ec8-bfc1-d054821e439e": "Roche Diagnostics",
+  "b73dd486-f505-4403-b634-40b078b177f0": "Rockwell Automation",
+  "50b5080a-775f-442e-83b5-926b5ca517b6": "S21sec Cyber Solutions by Thales",
+  "33894801-a172-4154-8366-c82685d14ceb": "Security4Media",
+  "23637b5d-af4c-4cf9-b8f6-deb7fd0f8423": "SCHUTZWERK GmbH",
+  "9d1ee86a-646e-405c-8a66-8c7ff4f47690": "SCIEX",
+  "634960e2-700d-44e8-9cc5-06f1161e61db": "Sandisk",
+  "551230f0-3615-47bd-b7cc-93e92e730bbf": "SEC Consult Vulnerability Lab",
+  "5804bb70-792c-43e0-8596-486cc0efe699": "Schweitzer Engineering Laboratories, Inc.",
+  "a6863dd2-93fc-443d-bef1-79f0b5020988": "SICK AG",
+  "bc375322-d3d7-4481-b261-e29662236cfd": "National Cyber Security Centre SK-CERT",
+  "303448ea-6ef3-4077-ad29-5c9bf253c375": "ServiceNow",
+  "412d305a-227d-44f9-a262-a31ba44f2aea": "Snowflake",
+  "9919078d-dfa5-4198-80ba-9d782f70aee7": "SOCRadar Cyber Intelligence Inc.",
+  "57dba5dd-1a03-47f6-8b36-e84e47d335d8": "Security Risk Advisors",
+  "b1571b85-cbc9-431f-830b-0c8155323a69": "STAR Labs SG Pte. Ltd.",
+  "2cfc7547-56a0-4049-8b52-c3078e8a8719": "SailPoint Technologies",
+  "c9b25dee-ae6d-4083-ba23-638c500cc364": "Salesforce, Inc.",
+  "3af57064-a867-422c-b2ad-40307b65c458": "Samsung Mobile",
+  "bd8dbf88-98d9-42c6-be08-cf8e48a32093": "Saviynt Inc.",
+  "a9f5af8f-c4eb-4593-af4e-e72a1155233f": "Scality SA",
+  "c6156efd-4bd0-48d7-8520-680200527478": "Seagate Technology",
+  "f2815942-3388-4c08-ba09-6c15850fda90": "Secomea",
+  "4daa8cea-433a-44bd-9456-53b127fc289a": "Secur0",
+  "c35fbbdf-8d87-49b6-8120-920a36e62b7f": "Securifera, Inc.",
+  "747bec18-acd0-4d99-a5c8-5e366c66ab7e": "Semtech",
+  "d3f162d7-5820-4c58-beef-03f43baaf8ad": "Shop Beat Solutions (Pty) LTD",
+  "030b2754-1501-44a4-bef8-48be86a33bf4": "Silicon Labs",
+  "83cc1b1a-46b0-4ac1-94f2-bbef3319bc4c": "Silver Peak Systems, Inc.",
+  "af54143c-83a9-48ea-ae07-21085edcda65": "Simplinx Ltd.",
+  "9298a079-d405-41ad-88d5-00b079d2802b": "Smile CDR Inc. (doing business as \u201cSmile Digital Health\u201d)",
+  "ea911274-ddd9-4e68-b39a-d7d6ae8b8a65": "Snow Software",
+  "0a72a055-908d-47f5-a16a-1f09049c16c6": "SoftIron",
+  "10de8ef9-5c89-4b17-8228-e97b74acf4bd": "Softing",
+  "49f11609-934d-4621-84e6-e02e032104d6": "SolarWinds",
+  "f946a70c-00eb-42ce-8e9b-634d1f7b5a6f": "Solidigm",
+  "103e4ec9-0a87-450b-af77-479448ddef11": "Sonatype Inc.",
+  "526a354d-e866-4174-ae7d-bac848e5c4c5": "Sophos",
+  "42b59230-ec95-491e-8425-5a5befa1a469": "Splunk",
+  "8b479ca1-d558-42a2-87eb-a4751ba58a09": "Spotfire",
+  "b84ce93d-f1af-4696-9d05-c521fba618da": "Stackable GmbH",
+  "ebf2cdfb-f390-4894-8ec9-f81bf1c57e6b": "StrongDM",
+  "bb7d2aeb-44ed-46d0-a7b7-671e03a2d5cb": "Stryker Corporation",
+  "def9a96e-e099-41a9-bfac-30fd4f82c411": "Super Micro Computer, Inc.",
+  "e4a1ddda-f4f5-496e-96c8-82c37d06abd0": "Swift Project",
+  "54bb2a58-4278-44a9-851f-17e74ee51f48": "Synaptics",
+  "e3c51cf0-0dc0-404a-819f-71a56b572cd3": "Syncro Soft SRL",
+  "57878e6a-11da-41a0-8ffb-1cd889c115bd": "Synopsys, Inc.",
+  "7df0e196-c666-448b-ae59-41ef9d03aa1e": "TCL Electronics Holdings Limited",
+  "64c5ae8f-7972-4697-86a0-7ada793ac795": "TCS-CERT | Cyber Solutions by Thales",
+  "907edf6c-bf03-423e-ab1a-8da27e1aa1ea": "TECNO Mobile Limited",
+  "9d5917ae-205d-4ae5-8749-1f49479b1395": "Thales Group",
+  "0f4efc09-fabf-44c2-8097-529b28cb019b": "Thales Group",
+  "07aac9b9-e3e9-4d03-a447-764bd31371d7": "The Missing Link Australia",
+  "ce0dbb48-7ac0-486d-9f50-3d79f6d791ba": "T-Mobile US",
+  "f23511db-6c3e-4e32-a477-6aa17d310630": "TP-Link Systems Inc.",
+  "ca940d4e-fea4-4aa2-9a58-591a58b1ce21": "TR-CERT (Computer Emergency Response Team of the Republic of Turkey)",
+  "1b7e193f-2525-49a1-b171-84af8827c9eb": "Teradyne Robotics",
+  "13430f76-86eb-43b2-a71c-82c956ef31b6": "TeamViewer Germany GmbH",
+  "3ad20294-822c-4ebc-9301-f9a7cf62d46e": "TXOne Networks, Inc.",
+  "f4fb688c-4412-4426-b4b8-421ecf27b14a": "TYPO3 Association",
+  "543290f7-4bf7-41f6-8696-351f55b865b0": "Tacit",
+  "3938794e-25f5-4123-a1ba-5cbd7f104512": "Tanium Inc.",
+  "cfdbb673-b408-4d03-89c1-c3d73ed80896": "The Tcpdump Group",
+  "f9e827b9-b7b0-4d38-8e58-a17ae994d264": "Tego Cyber, Inc",
+  "61241ed8-fa44-4f23-92db-b8c443751968": "Temporal Technologies Inc.",
+  "ba3c294d-a544-4fff-ad44-2de7c7bbb6be": "Teradici Corporation",
+  "0f2be0ad-3469-4e56-b38f-4eb96719b425": "Thinkst Applied Research",
+  "65518388-201a-4f93-8712-366d21fe8d2c": "TianoCore.org",
+  "e6d453f4-3dae-4941-bcea-9af25f4e824d": "Tigera",
+  "1c6b5737-9389-4011-8117-89fa251edfb2": "Toreon",
+  "ecc0f906-8666-484c-bcf8-c3b7520a72f0": "Toshiba Corporation",
+  "309f9ea4-e3e9-4c6c-b79d-e8eb01244f2c": "Turan Security",
+  "fe490ce8-0395-4072-90d8-2707e1bdf984": "Ubiquiti Inc.",
+  "63f92e9c-2193-4c24-98a9-93640392c3d3": "Unisoc (Shanghai) Technologies Co., Ltd.",
+  "94840d3b-273f-4394-8a3a-23e618158e9a": "Zhejiang Uniview Technologies Co.,Ltd.",
+  "6b4ace4a-d6e0-415b-9ce8-aa20e97e4b24": "VDOO Connected Trust Ltd.",
+  "2fdefc65-d750-4b8d-96ee-6e2c0c42dbfe": "VULSec Labs",
+  "9e0f3122-90e9-42d5-93de-8c6b98deef7e": "Vaadin Ltd.",
+  "8a658f00-b329-43ab-bd48-2d5c2137a4b1": "Vantive",
+  "6b608899-1da4-4a4d-8cfe-114101467ac1": "Velneo",
+  "0ad0730f-8185-46ee-afe7-b0fbf5f57d6c": "Verizon",
+  "5431be70-064b-4f6a-be51-69eacabef109": "Vestel Electronics Industry & Trade Co.",
+  "c6f5cd8e-fe3d-4460-82c2-f8a4e7b272c8": "Vivo Mobile Communication Technology Co.,LTD.",
+  "1af790b2-7ee1-4545-860a-a788eba489b5": "VulDB",
+  "427737d6-c7b4-491b-8494-be49e761079e": "VulNow",
+  "83251b91-4cc7-4094-a5c7-464a1b83ea10": "VulnCheck",
+  "66d34ac2-a5dc-40cb-b4ff-2e79722c57c7": "Vulnscope Technologies",
+  "cb3b742e-5145-4748-b44b-5ffd45bf3b6a": "Western Digital",
+  "1bfdd5d7-9bf6-4a53-96ea-42e2716d7a81": "WPScan",
+  "ed10eef1-636d-4fbe-9993-6890dfa878f8": "WSO2 LLC",
+  "5d1c2695-1a31-4499-88ae-e847036fd7e3": "WatchGuard Technologies, Inc.",
+  "0bf9931a-6ebf-4f48-bd14-39ee5e1d61f8": "Wind River Systems Inc.",
+  "9947ef80-c5d5-474a-bbab-97341a59000e": "Wiz, Inc.",
+  "b15e7b5b-3da4-40ae-a43c-f7aa60e62599": "Wordfence",
+  "b6ef82d7-f637-461b-aedd-74f5857d5f5b": "Wren Security",
+  "23aa2041-22e1-471f-9209-9b7396fa234f": "Xen Project",
+  "902ff664-2e36-43e3-a1aa-3210c82d1b67": "Exodus Intelligence",
+  "1659d7e7-0fd8-41a4-b7d8-e16533acba10": "Xona Systems",
+  "10b61619-3869-496c-8a1e-f291b0e71e3f": "Xerox Corporation",
+  "b57733aa-7326-4f07-8e09-0be8e0df1909": "Xiaomi Technology Co Ltd",
+  "15c01472-ff32-4bec-916d-912e60a9fe4c": "Xylem",
+  "30a5e7fb-040d-440a-8cdf-a4a2068ce72e": "YesWeHack",
+  "8c0ba754-92aa-4681-b4d5-510f1148573c": "Ygreky SASU",
+  "7168b535-132a-4efe-a076-338f829b2eb9": "Yokogawa Group",
+  "d4ae51d3-4db5-465e-bc8a-eb6768324078": "Yugabyte, Inc.",
+  "1d120b86-904b-457e-9254-9d27ed61a691": "ZGR",
+  "256c161b-b921-402b-8c3b-c6c9c14d5d88": "ZUSO Advanced Research Team",
+  "72de3e22-0555-4a0d-ae81-9249e0f0a1e8": "Zabbix",
+  "cf9c5165-6fe5-4ec0-b5f1-404f1df30a4e": "Zenitel Norway AS",
+  "0fc0942c-577d-436f-ae8e-945763c79b02": "Zohocorp",
+  "99b9af0d-a833-4a5d-9e2f-8b1324f35351": "Zoom Video Communications, Inc.",
+  "b1336bef-059d-4e13-b11b-9a6ef21b3c78": "Zowe",
+  "73c6f63b-efac-410d-a0a9-569700f85a04": "Zscaler, Inc.",
+  "96e50032-ad0d-4058-a115-4d2c13821f9f": "Zyxel Corporation",
+  "078d4453-3bcd-4900-85e6-15281da43538": "Adobe Systems Incorporated",
+  "24a3c815-5f22-4d74-967a-30958d6466f4": "Airbus",
+  "0cc2b86d-1d45-434d-ae74-11d09ec61ae8": "Alibaba, Inc.",
+  "f0158376-9dc2-43b6-827c-5f631a4d8d09": "Apache Software Foundation",
+  "286789f9-fbc2-4510-9f9a-43facdede74c": "Apple Inc.",
+  "3f4a04a2-6ad9-471b-9581-c5c12f925c8d": "Appthority",
+  "87c8e6ad-f0f5-4ca8-89e2-89f26d6ed932": "ARC Informatique",
+  "d7d587a5-d946-484d-88e8-e8bde582b1fd": "ASUSTOR Inc. (inactive)",
+  "f08a6ab8-ed46-4c22-8884-d911ccfe3c66": "Atlassian",
+  "7e40ea87-bc65-4944-9723-dd79dd760601": "Autodesk",
+  "9d670455-bdb5-4cca-a883-5914865f5d96": "Avaya Inc.",
+  "a0340c66-c385-4f8b-991b-3d05f6fd5220": "Azure Access Technology",
+  "24f6982c-767b-4a39-abbc-4eeb3e3d07cf": "Booz Allen Hamilton, Inc.",
+  "91579145-5d7b-4cc5-b925-a0262ff19630": "Legion of the Bouncy Castle Inc.",
+  "0beee27a-7d8c-424f-8e46-ac453fa147e6": "Bizerba SE & Co. KG",
+  "dbe78b00-5e7b-4fda-8748-329789ecfc5c": "BlackBerry",
+  "c95f66b2-7e7c-41c5-8f09-6f86ec68659c": "Robert Bosch GmbH",
+  "87b297d7-335e-4844-9551-11b97995a791": "Brocade Communications Systems LLC, a Broadcom Company",
+  "e291eae9-7c0a-46ac-ba7d-5251811f8b7f": "CA Technologies",
+  "cc1ad9ee-3454-478d-9317-d3e869d708bc": "Canonical Ltd.",
+  "37e5125f-f79b-445b-8fad-9564f167944b": "CERT/CC",
+  "897c38be-0345-43cd-b6cf-fe179e0c4f45": "Check Point Software Technologies Ltd.",
+  "a341c0d1-ebf7-493f-a84e-38cf86618674": "cirosec GmbH",
+  "9119a7d8-5eab-497f-8521-727c672e3725": "Cybersecurity and Infrastructure Security Agency (CISA) U.S. Civilian Government",
+  "84d840c2-f705-4730-aa49-d8456bc2d082": "CISA-TLR",
+  "d1c1063e-7a18-46af-9102-31f8928bc633": "Cisco Systems, Inc.",
+  "a22f1246-ba21-4bb4-a601-ad51614c1513": "Cloudflare, Inc.",
+  "4ff2b028-869f-4b00-a7b2-05997f6f14fd": "Crafter CMS",
+  "8207d157-a9c5-4c55-ab16-b67a7ac0b646": "CyberSecurity Philippines - CERT",
+  "2499f714-1537-4658-8207-48ae4bb9eae9": "curl",
+  "446512bf-f6b9-49cd-a165-0100ef5b9ceb": "CyberSecurity Malaysia",
+  "07437d28-5abb-492e-90f6-4b93be924c2f": "Cygence Pty Ltd",
+  "79ee569e-7d1e-4364-98f0-3a18e2a739ad": "Dahua Technologies",
+  "79363d38-fa19-49d1-9214-5f28da3f3ac5": "Debian GNU/Linux",
+  "c550e75a-17ff-4988-97f0-544cde3820fe": "Dell",
+  "430a6cef-dc26-47e3-9fa8-52fb7f19644e": "DirectCyber",
+  "5b9d93f2-25c7-46b4-ab60-d201718c9dd8": "dotCMS LLC",
+  "2c85b837-eb8b-40ed-9d74-228c62987387": "Drupal.org",
+  "7cd4c57f-0a88-4dda-be53-70336b413766": "Duo Security, Inc.",
+  "7556d962-6fb7-411e-85fa-6cd62f095ba8": "Distributed Weakness Filing Project",
+  "e51fbebd-6053-4e49-959f-1b94eeb69a2c": "Eclipse Foundation",
+  "d4a31c54-a580-4ac9-a230-48143acf784a": "Eclypsium, Inc.",
+  "271b6943-45a9-4f3a-ab4e-976f3fa05b5a": "Elastic",
+  "fdf66990-8419-4c8c-8848-ec15d75773b4": "esaqa GmbH",
+  "9dacffd4-cb11-413f-8451-fbbfd4ddc0ab": "F5, Inc.",
+  "92fb86c3-55a5-4fb5-9c3f-4757b9e96dc5": "Fedora Project (Infrastructure Software)",
+  "44d08088-2bea-4760-83a6-1e9be26b15ab": "Flexera Software LLC",
+  "9f311a02-c44f-4938-8530-9219246b8255": "floragunn GmbH",
+  "e23ea22c-8c39-4eff-8980-2881e5ae54e2": "Forcepoint",
+  "6abe59d8-c742-4dff-8ce8-9b0ca1073da8": "Fortinet, Inc.",
+  "63664ac6-956c-4cba-a5d0-f46076e16109": "FreeBSD",
+  "a6e330db-fd8a-4376-8911-9848c28c3713": "github user delete workaround",
+  "3ff69d7a-14f2-4f67-a097-88dee7810d18": "GNU C Library",
+  "baff130e-b8d5-4e15-b3d3-c3cf5d5545c6": "Android (associated with Google Inc. or Open Handset Alliance)",
+  "f0d0cb98-89ec-4608-9db9-fccd160dfeab": "GraphQL Java",
+  "9c8ecc0c-3d1b-4c36-ae42-dbf9f87e057c": "GVision Italia S.r.l.",
+  "36234546-b8fa-4601-9d6f-f4e334aa8ea1": "HackerOne",
+  "7ffcee3d-2c14-4c3e-b844-86c6a321a158": "Harborist",
+  "4aabb4e1-8672-4298-9ebf-8ce29242160a": "herodevs-SADP"
+}
\ No newline at end of file
diff --git a/data/cache/epss_scores-current.csv.gz b/data/cache/epss_scores-current.csv.gz
new file mode 100644
index 00000000000..0ff5822bbf8
Binary files /dev/null and b/data/cache/epss_scores-current.csv.gz differ
diff --git a/data/cache/epss_scores-current.json b/data/cache/epss_scores-current.json
new file mode 100644
index 00000000000..a5e9e4babba
--- /dev/null
+++ b/data/cache/epss_scores-current.json
@@ -0,0 +1 @@
+{"CVE-1999-0001": {"epss_score": 0.01151, "epss_percentile": 0.78036}, "CVE-1999-0002": {"epss_score": 0.09123, "epss_percentile": 0.9241}, "CVE-1999-0003": {"epss_score": 0.89352, "epss_percentile": 0.9952}, "CVE-1999-0004": {"epss_score": 0.03037, "epss_percentile": 0.86264}, "CVE-1999-0005": {"epss_score": 0.13652, "epss_percentile": 0.94021}, "CVE-1999-0006": {"epss_score": 0.08244, "epss_percentile": 0.91946}, "CVE-1999-0007": {"epss_score": 0.03203, "epss_percentile": 0.86627}, "CVE-1999-0008": {"epss_score": 0.05208, "epss_percentile": 0.89613}, "CVE-1999-0009": {"epss_score": 0.8048, "epss_percentile": 0.99091}, "CVE-1999-0010": {"epss_score": 0.02, "epss_percentile": 0.83213}, "CVE-1999-0011": {"epss_score": 0.10976, "epss_percentile": 0.93181}, "CVE-1999-0012": {"epss_score": 0.00456, "epss_percentile": 0.63318}, "CVE-1999-0013": {"epss_score": 0.00541, "epss_percentile": 0.67044}, "CVE-1999-0014": {"epss_score": 0.0086, "epss_percentile": 0.74542}, "CVE-1999-0015": {"epss_score": 0.25986, "epss_percentile": 0.96098}, "CVE-1999-0016": {"epss_score": 0.78781, "epss_percentile": 0.99003}, "CVE-1999-0017": {"epss_score": 0.00545, "epss_percentile": 0.67176}, "CVE-1999-0018": {"epss_score": 0.10302, "epss_percentile": 0.92934}, "CVE-1999-0019": {"epss_score": 0.01078, "epss_percentile": 0.77352}, "CVE-1999-0021": {"epss_score": 0.0321, "epss_percentile": 0.86648}, "CVE-1999-0022": {"epss_score": 0.0034, "epss_percentile": 0.56285}, "CVE-1999-0023": {"epss_score": 0.00658, "epss_percentile": 0.7049}, "CVE-1999-0024": {"epss_score": 0.02834, "epss_percentile": 0.85787}, "CVE-1999-0025": {"epss_score": 0.0144, "epss_percentile": 0.80298}, "CVE-1999-0026": {"epss_score": 0.00502, "epss_percentile": 0.65372}, "CVE-1999-0027": {"epss_score": 0.00455, "epss_percentile": 0.63301}, "CVE-1999-0028": {"epss_score": 0.00075, "epss_percentile": 0.23006}, "CVE-1999-0029": {"epss_score": 0.0038, "epss_percentile": 0.58973}, "CVE-1999-0030": {"epss_score": 0.00267, "epss_percentile": 0.49996}, "CVE-1999-0031": {"epss_score": 0.02939, "epss_percentile": 0.86031}, "CVE-1999-0032": {"epss_score": 0.00194, "epss_percentile": 0.41561}, "CVE-1999-0033": {"epss_score": 0.00078, "epss_percentile": 0.23606}, "CVE-1999-0034": {"epss_score": 0.00348, "epss_percentile": 0.56819}, "CVE-1999-0035": {"epss_score": 0.00309, "epss_percentile": 0.53682}, "CVE-1999-0036": {"epss_score": 0.00834, "epss_percentile": 0.74107}, "CVE-1999-0037": {"epss_score": 0.02077, "epss_percentile": 0.83515}, "CVE-1999-0038": {"epss_score": 0.00154, "epss_percentile": 0.36677}, "CVE-1999-0039": {"epss_score": 0.20729, "epss_percentile": 0.95406}, "CVE-1999-0040": {"epss_score": 0.00225, "epss_percentile": 0.45146}, "CVE-1999-0041": {"epss_score": 0.07175, "epss_percentile": 0.913}, "CVE-1999-0042": {"epss_score": 0.05486, "epss_percentile": 0.89923}, "CVE-1999-0043": {"epss_score": 0.01582, "epss_percentile": 0.81144}, "CVE-1999-0044": {"epss_score": 0.00232, "epss_percentile": 0.45964}, "CVE-1999-0045": {"epss_score": 0.13182, "epss_percentile": 0.93894}, "CVE-1999-0046": {"epss_score": 0.02832, "epss_percentile": 0.85777}, "CVE-1999-0047": {"epss_score": 0.02172, "epss_percentile": 0.83873}, "CVE-1999-0048": {"epss_score": 0.01797, "epss_percentile": 0.82309}, "CVE-1999-0049": {"epss_score": 0.00071, "epss_percentile": 0.22072}, "CVE-1999-0050": {"epss_score": 0.00997, "epss_percentile": 0.7646}, "CVE-1999-0051": {"epss_score": 0.00246, "epss_percentile": 0.47736}, "CVE-1999-0052": {"epss_score": 0.01067, "epss_percentile": 0.77233}, "CVE-1999-0053": {"epss_score": 0.00562, "epss_percentile": 0.67691}, "CVE-1999-0054": {"epss_score": 0.00562, "epss_percentile": 0.67691}, "CVE-1999-0055": {"epss_score": 0.0008, "epss_percentile": 0.24108}, "CVE-1999-0056": {"epss_score": 0.00067, "epss_percentile": 0.21038}, "CVE-1999-0057": {"epss_score": 0.04446, "epss_percentile": 0.88698}, "CVE-1999-0058": {"epss_score": 0.007, "epss_percentile": 0.71468}, "CVE-1999-0059": {"epss_score": 0.00721, "epss_percentile": 0.71971}, "CVE-1999-0060": {"epss_score": 0.06841, "epss_percentile": 0.91062}, "CVE-1999-0061": {"epss_score": 0.01661, "epss_percentile": 0.81626}, "CVE-1999-0062": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0063": {"epss_score": 0.12053, "epss_percentile": 0.93556}, "CVE-1999-0064": {"epss_score": 0.00284, "epss_percentile": 0.51475}, "CVE-1999-0065": {"epss_score": 0.00907, "epss_percentile": 0.7527}, "CVE-1999-0066": {"epss_score": 0.12381, "epss_percentile": 0.93656}, "CVE-1999-0067": {"epss_score": 0.8996, "epss_percentile": 0.99553}, "CVE-1999-0068": {"epss_score": 0.02836, "epss_percentile": 0.85791}, "CVE-1999-0069": {"epss_score": 0.00693, "epss_percentile": 0.71315}, "CVE-1999-0070": {"epss_score": 0.69703, "epss_percentile": 0.986}, "CVE-1999-0071": {"epss_score": 0.0215, "epss_percentile": 0.83783}, "CVE-1999-0072": {"epss_score": 0.00071, "epss_percentile": 0.22132}, "CVE-1999-0073": {"epss_score": 0.00259, "epss_percentile": 0.4904}, "CVE-1999-0074": {"epss_score": 0.0588, "epss_percentile": 0.9029}, "CVE-1999-0075": {"epss_score": 0.00661, "epss_percentile": 0.70574}, "CVE-1999-0076": {"epss_score": 0.00787, "epss_percentile": 0.73308}, "CVE-1999-0077": {"epss_score": 0.15621, "epss_percentile": 0.94471}, "CVE-1999-0078": {"epss_score": 0.00109, "epss_percentile": 0.29921}, "CVE-1999-0079": {"epss_score": 0.00676, "epss_percentile": 0.70925}, "CVE-1999-0080": {"epss_score": 0.01463, "epss_percentile": 0.80444}, "CVE-1999-0081": {"epss_score": 0.00661, "epss_percentile": 0.70574}, "CVE-1999-0082": {"epss_score": 0.02357, "epss_percentile": 0.84485}, "CVE-1999-0083": {"epss_score": 0.00681, "epss_percentile": 0.71044}, "CVE-1999-0084": {"epss_score": 0.00146, "epss_percentile": 0.35629}, "CVE-1999-0085": {"epss_score": 0.04573, "epss_percentile": 0.88865}, "CVE-1999-0086": {"epss_score": 0.00479, "epss_percentile": 0.64436}, "CVE-1999-0087": {"epss_score": 0.00562, "epss_percentile": 0.67691}, "CVE-1999-0088": {"epss_score": 0.04464, "epss_percentile": 0.88727}, "CVE-1999-0089": {"epss_score": 0.00067, "epss_percentile": 0.21157}, "CVE-1999-0090": {"epss_score": 0.00071, "epss_percentile": 0.22132}, "CVE-1999-0091": {"epss_score": 0.00071, "epss_percentile": 0.22132}, "CVE-1999-0092": {"epss_score": 0.0071, "epss_percentile": 0.71712}, "CVE-1999-0093": {"epss_score": 0.00067, "epss_percentile": 0.21098}, "CVE-1999-0094": {"epss_score": 0.00081, "epss_percentile": 0.24264}, "CVE-1999-0095": {"epss_score": 0.09826, "epss_percentile": 0.92721}, "CVE-1999-0096": {"epss_score": 0.00661, "epss_percentile": 0.70574}, "CVE-1999-0097": {"epss_score": 0.01076, "epss_percentile": 0.77323}, "CVE-1999-0098": {"epss_score": 0.00962, "epss_percentile": 0.75986}, "CVE-1999-0099": {"epss_score": 0.01375, "epss_percentile": 0.79827}, "CVE-1999-0100": {"epss_score": 0.01322, "epss_percentile": 0.79447}, "CVE-1999-0101": {"epss_score": 0.03249, "epss_percentile": 0.86747}, "CVE-1999-0102": {"epss_score": 0.00677, "epss_percentile": 0.70957}, "CVE-1999-0103": {"epss_score": 0.48093, "epss_percentile": 0.97621}, "CVE-1999-0104": {"epss_score": 0.03605, "epss_percentile": 0.87416}, "CVE-1999-0105": {"epss_score": 0.00084, "epss_percentile": 0.25016}, "CVE-1999-0106": {"epss_score": 0.00173, "epss_percentile": 0.39074}, "CVE-1999-0107": {"epss_score": 0.38218, "epss_percentile": 0.97091}, "CVE-1999-0108": {"epss_score": 0.00399, "epss_percentile": 0.6012}, "CVE-1999-0109": {"epss_score": 0.00362, "epss_percentile": 0.57771}, "CVE-1999-0111": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0112": {"epss_score": 0.03656, "epss_percentile": 0.87517}, "CVE-1999-0113": {"epss_score": 0.18663, "epss_percentile": 0.95048}, "CVE-1999-0114": {"epss_score": 0.00062, "epss_percentile": 0.19759}, "CVE-1999-0115": {"epss_score": 0.01244, "epss_percentile": 0.78833}, "CVE-1999-0116": {"epss_score": 0.09037, "epss_percentile": 0.92376}, "CVE-1999-0117": {"epss_score": 0.00064, "epss_percentile": 0.20133}, "CVE-1999-0118": {"epss_score": 0.01244, "epss_percentile": 0.78833}, "CVE-1999-0119": {"epss_score": 0.11702, "epss_percentile": 0.93456}, "CVE-1999-0120": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0121": {"epss_score": 0.00071, "epss_percentile": 0.22145}, "CVE-1999-0122": {"epss_score": 0.06705, "epss_percentile": 0.90958}, "CVE-1999-0123": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-1999-0124": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0125": {"epss_score": 0.00568, "epss_percentile": 0.67907}, "CVE-1999-0126": {"epss_score": 0.00362, "epss_percentile": 0.57771}, "CVE-1999-0127": {"epss_score": 0.0006, "epss_percentile": 0.19029}, "CVE-1999-0128": {"epss_score": 0.15798, "epss_percentile": 0.9451}, "CVE-1999-0129": {"epss_score": 0.00137, "epss_percentile": 0.34221}, "CVE-1999-0130": {"epss_score": 0.00886, "epss_percentile": 0.74955}, "CVE-1999-0131": {"epss_score": 0.00096, "epss_percentile": 0.27397}, "CVE-1999-0132": {"epss_score": 0.00587, "epss_percentile": 0.68477}, "CVE-1999-0133": {"epss_score": 0.00306, "epss_percentile": 0.53405}, "CVE-1999-0134": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0135": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0136": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0137": {"epss_score": 0.00291, "epss_percentile": 0.52212}, "CVE-1999-0138": {"epss_score": 0.00073, "epss_percentile": 0.22484}, "CVE-1999-0139": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0140": {"epss_score": 0.07744, "epss_percentile": 0.91654}, "CVE-1999-0141": {"epss_score": 0.0006, "epss_percentile": 0.19133}, "CVE-1999-0142": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0143": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-1999-0144": {"epss_score": 0.01987, "epss_percentile": 0.83162}, "CVE-1999-0145": {"epss_score": 0.00716, "epss_percentile": 0.71866}, "CVE-1999-0146": {"epss_score": 0.06605, "epss_percentile": 0.90881}, "CVE-1999-0147": {"epss_score": 0.04477, "epss_percentile": 0.8874}, "CVE-1999-0148": {"epss_score": 0.05694, "epss_percentile": 0.90127}, "CVE-1999-0149": {"epss_score": 0.0371, "epss_percentile": 0.87603}, "CVE-1999-0150": {"epss_score": 0.01393, "epss_percentile": 0.79967}, "CVE-1999-0151": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0152": {"epss_score": 0.01393, "epss_percentile": 0.79967}, "CVE-1999-0153": {"epss_score": 0.26519, "epss_percentile": 0.96152}, "CVE-1999-0154": {"epss_score": 0.57787, "epss_percentile": 0.98083}, "CVE-1999-0155": {"epss_score": 0.0083, "epss_percentile": 0.74031}, "CVE-1999-0156": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-1999-0157": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0158": {"epss_score": 0.00502, "epss_percentile": 0.65392}, "CVE-1999-0159": {"epss_score": 0.00417, "epss_percentile": 0.61251}, "CVE-1999-0160": {"epss_score": 0.00493, "epss_percentile": 0.65052}, "CVE-1999-0161": {"epss_score": 0.00337, "epss_percentile": 0.56063}, "CVE-1999-0162": {"epss_score": 0.01039, "epss_percentile": 0.76953}, "CVE-1999-0163": {"epss_score": 0.00181, "epss_percentile": 0.40126}, "CVE-1999-0164": {"epss_score": 0.00067, "epss_percentile": 0.21112}, "CVE-1999-0165": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-1999-0166": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0167": {"epss_score": 0.00098, "epss_percentile": 0.27693}, "CVE-1999-0168": {"epss_score": 0.00696, "epss_percentile": 0.71393}, "CVE-1999-0169": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0170": {"epss_score": 0.28135, "epss_percentile": 0.96314}, "CVE-1999-0171": {"epss_score": 0.00173, "epss_percentile": 0.39074}, "CVE-1999-0172": {"epss_score": 0.01624, "epss_percentile": 0.81414}, "CVE-1999-0173": {"epss_score": 0.03047, "epss_percentile": 0.86284}, "CVE-1999-0174": {"epss_score": 0.08058, "epss_percentile": 0.91858}, "CVE-1999-0175": {"epss_score": 0.01445, "epss_percentile": 0.80323}, "CVE-1999-0176": {"epss_score": 0.0461, "epss_percentile": 0.88913}, "CVE-1999-0177": {"epss_score": 0.00555, "epss_percentile": 0.67471}, "CVE-1999-0178": {"epss_score": 0.06961, "epss_percentile": 0.9115}, "CVE-1999-0179": {"epss_score": 0.04278, "epss_percentile": 0.88486}, "CVE-1999-0180": {"epss_score": 0.00639, "epss_percentile": 0.69941}, "CVE-1999-0181": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0182": {"epss_score": 0.03016, "epss_percentile": 0.86214}, "CVE-1999-0183": {"epss_score": 0.00725, "epss_percentile": 0.72052}, "CVE-1999-0184": {"epss_score": 0.01208, "epss_percentile": 0.78536}, "CVE-1999-0185": {"epss_score": 0.01488, "epss_percentile": 0.80616}, "CVE-1999-0186": {"epss_score": 0.04993, "epss_percentile": 0.89369}, "CVE-1999-0188": {"epss_score": 0.00067, "epss_percentile": 0.21112}, "CVE-1999-0189": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0190": {"epss_score": 0.00067, "epss_percentile": 0.21112}, "CVE-1999-0191": {"epss_score": 0.61953, "epss_percentile": 0.98269}, "CVE-1999-0192": {"epss_score": 0.0666, "epss_percentile": 0.90923}, "CVE-1999-0193": {"epss_score": 0.05606, "epss_percentile": 0.90044}, "CVE-1999-0194": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0195": {"epss_score": 0.00178, "epss_percentile": 0.39716}, "CVE-1999-0196": {"epss_score": 0.06994, "epss_percentile": 0.9117}, "CVE-1999-0197": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0198": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0199": {"epss_score": 0.00677, "epss_percentile": 0.70954}, "CVE-1999-0200": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0201": {"epss_score": 0.00943, "epss_percentile": 0.75773}, "CVE-1999-0202": {"epss_score": 0.00639, "epss_percentile": 0.69941}, "CVE-1999-0203": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0204": {"epss_score": 0.03186, "epss_percentile": 0.86591}, "CVE-1999-0205": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0206": {"epss_score": 0.00495, "epss_percentile": 0.65115}, "CVE-1999-0207": {"epss_score": 0.0613, "epss_percentile": 0.90501}, "CVE-1999-0208": {"epss_score": 0.44866, "epss_percentile": 0.97457}, "CVE-1999-0209": {"epss_score": 0.42373, "epss_percentile": 0.97329}, "CVE-1999-0210": {"epss_score": 0.08326, "epss_percentile": 0.91991}, "CVE-1999-0211": {"epss_score": 0.0054, "epss_percentile": 0.67019}, "CVE-1999-0212": {"epss_score": 0.00727, "epss_percentile": 0.72086}, "CVE-1999-0213": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0214": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0215": {"epss_score": 0.03114, "epss_percentile": 0.86431}, "CVE-1999-0216": {"epss_score": 0.00524, "epss_percentile": 0.66314}, "CVE-1999-0217": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0218": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0219": {"epss_score": 0.05805, "epss_percentile": 0.90223}, "CVE-1999-0220": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-1999-0221": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0222": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0223": {"epss_score": 0.00084, "epss_percentile": 0.25016}, "CVE-1999-0224": {"epss_score": 0.28996, "epss_percentile": 0.96408}, "CVE-1999-0225": {"epss_score": 0.16121, "epss_percentile": 0.94575}, "CVE-1999-0226": {"epss_score": 0.11702, "epss_percentile": 0.93456}, "CVE-1999-0227": {"epss_score": 0.04618, "epss_percentile": 0.88926}, "CVE-1999-0228": {"epss_score": 0.04618, "epss_percentile": 0.88926}, "CVE-1999-0229": {"epss_score": 0.04875, "epss_percentile": 0.8924}, "CVE-1999-0230": {"epss_score": 0.00534, "epss_percentile": 0.66782}, "CVE-1999-0231": {"epss_score": 0.00497, "epss_percentile": 0.65187}, "CVE-1999-0232": {"epss_score": 0.00495, "epss_percentile": 0.65115}, "CVE-1999-0233": {"epss_score": 0.30773, "epss_percentile": 0.96568}, "CVE-1999-0234": {"epss_score": 0.0009, "epss_percentile": 0.26126}, "CVE-1999-0235": {"epss_score": 0.03302, "epss_percentile": 0.86866}, "CVE-1999-0236": {"epss_score": 0.09155, "epss_percentile": 0.92425}, "CVE-1999-0237": {"epss_score": 0.03309, "epss_percentile": 0.86884}, "CVE-1999-0238": {"epss_score": 0.01595, "epss_percentile": 0.81233}, "CVE-1999-0239": {"epss_score": 0.04098, "epss_percentile": 0.88255}, "CVE-1999-0240": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0241": {"epss_score": 0.0253, "epss_percentile": 0.85023}, "CVE-1999-0242": {"epss_score": 0.00699, "epss_percentile": 0.7145}, "CVE-1999-0243": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0244": {"epss_score": 0.01911, "epss_percentile": 0.82828}, "CVE-1999-0245": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-1999-0246": {"epss_score": 0.00732, "epss_percentile": 0.72186}, "CVE-1999-0247": {"epss_score": 0.0405, "epss_percentile": 0.88175}, "CVE-1999-0248": {"epss_score": 0.00407, "epss_percentile": 0.60609}, "CVE-1999-0249": {"epss_score": 0.01446, "epss_percentile": 0.80324}, "CVE-1999-0250": {"epss_score": 0.0057, "epss_percentile": 0.67961}, "CVE-1999-0251": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0252": {"epss_score": 0.0089, "epss_percentile": 0.75032}, "CVE-1999-0253": {"epss_score": 0.02987, "epss_percentile": 0.86135}, "CVE-1999-0254": {"epss_score": 0.00902, "epss_percentile": 0.7519}, "CVE-1999-0255": {"epss_score": 0.01105, "epss_percentile": 0.77604}, "CVE-1999-0256": {"epss_score": 0.82403, "epss_percentile": 0.99193}, "CVE-1999-0257": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0258": {"epss_score": 0.04875, "epss_percentile": 0.8924}, "CVE-1999-0259": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0260": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-1999-0261": {"epss_score": 0.01087, "epss_percentile": 0.7743}, "CVE-1999-0262": {"epss_score": 0.05383, "epss_percentile": 0.89816}, "CVE-1999-0263": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-1999-0264": {"epss_score": 0.0343, "epss_percentile": 0.87122}, "CVE-1999-0265": {"epss_score": 0.00511, "epss_percentile": 0.65838}, "CVE-1999-0266": {"epss_score": 0.0373, "epss_percentile": 0.87641}, "CVE-1999-0267": {"epss_score": 0.06259, "epss_percentile": 0.90619}, "CVE-1999-0268": {"epss_score": 0.02816, "epss_percentile": 0.85733}, "CVE-1999-0269": {"epss_score": 0.03354, "epss_percentile": 0.8697}, "CVE-1999-0270": {"epss_score": 0.0151, "epss_percentile": 0.80771}, "CVE-1999-0271": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0272": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0273": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0274": {"epss_score": 0.04875, "epss_percentile": 0.8924}, "CVE-1999-0275": {"epss_score": 0.04875, "epss_percentile": 0.8924}, "CVE-1999-0276": {"epss_score": 0.01911, "epss_percentile": 0.82828}, "CVE-1999-0277": {"epss_score": 0.00067, "epss_percentile": 0.21112}, "CVE-1999-0278": {"epss_score": 0.76064, "epss_percentile": 0.98876}, "CVE-1999-0279": {"epss_score": 0.01171, "epss_percentile": 0.78215}, "CVE-1999-0280": {"epss_score": 0.02813, "epss_percentile": 0.85725}, "CVE-1999-0281": {"epss_score": 0.09345, "epss_percentile": 0.9251}, "CVE-1999-0283": {"epss_score": 0.04288, "epss_percentile": 0.88498}, "CVE-1999-0284": {"epss_score": 0.03442, "epss_percentile": 0.87142}, "CVE-1999-0285": {"epss_score": 0.13357, "epss_percentile": 0.93941}, "CVE-1999-0286": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0287": {"epss_score": 0.03584, "epss_percentile": 0.87388}, "CVE-1999-0288": {"epss_score": 0.26564, "epss_percentile": 0.96157}, "CVE-1999-0289": {"epss_score": 0.01293, "epss_percentile": 0.79239}, "CVE-1999-0290": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0291": {"epss_score": 0.00757, "epss_percentile": 0.72753}, "CVE-1999-0292": {"epss_score": 0.04875, "epss_percentile": 0.8924}, "CVE-1999-0293": {"epss_score": 0.00737, "epss_percentile": 0.7233}, "CVE-1999-0294": {"epss_score": 0.11373, "epss_percentile": 0.93325}, "CVE-1999-0295": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0296": {"epss_score": 0.00067, "epss_percentile": 0.21112}, "CVE-1999-0297": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0298": {"epss_score": 0.01583, "epss_percentile": 0.81154}, "CVE-1999-0299": {"epss_score": 0.00512, "epss_percentile": 0.65862}, "CVE-1999-0300": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0301": {"epss_score": 0.0041, "epss_percentile": 0.60835}, "CVE-1999-0302": {"epss_score": 0.00639, "epss_percentile": 0.69941}, "CVE-1999-0303": {"epss_score": 0.00055, "epss_percentile": 0.17462}, "CVE-1999-0304": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0305": {"epss_score": 0.0073, "epss_percentile": 0.72142}, "CVE-1999-0306": {"epss_score": 0.01023, "epss_percentile": 0.7677}, "CVE-1999-0307": {"epss_score": 0.0007, "epss_percentile": 0.21743}, "CVE-1999-0308": {"epss_score": 0.00116, "epss_percentile": 0.3107}, "CVE-1999-0309": {"epss_score": 0.0006, "epss_percentile": 0.19029}, "CVE-1999-0310": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0311": {"epss_score": 0.0006, "epss_percentile": 0.19029}, "CVE-1999-0312": {"epss_score": 0.017, "epss_percentile": 0.81831}, "CVE-1999-0313": {"epss_score": 0.00061, "epss_percentile": 0.19306}, "CVE-1999-0314": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-1999-0315": {"epss_score": 0.00329, "epss_percentile": 0.55302}, "CVE-1999-0316": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0317": {"epss_score": 0.00175, "epss_percentile": 0.3932}, "CVE-1999-0318": {"epss_score": 0.00115, "epss_percentile": 0.31017}, "CVE-1999-0319": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0320": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0321": {"epss_score": 0.00166, "epss_percentile": 0.38148}, "CVE-1999-0322": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-1999-0323": {"epss_score": 0.00482, "epss_percentile": 0.64537}, "CVE-1999-0324": {"epss_score": 0.0006, "epss_percentile": 0.19029}, "CVE-1999-0325": {"epss_score": 0.0006, "epss_percentile": 0.19029}, "CVE-1999-0326": {"epss_score": 0.00116, "epss_percentile": 0.3107}, "CVE-1999-0327": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-1999-0328": {"epss_score": 0.00287, "epss_percentile": 0.51835}, "CVE-1999-0329": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0330": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0331": {"epss_score": 0.03157, "epss_percentile": 0.86518}, "CVE-1999-0332": {"epss_score": 0.03832, "epss_percentile": 0.87809}, "CVE-1999-0333": {"epss_score": 0.01336, "epss_percentile": 0.79554}, "CVE-1999-0334": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0336": {"epss_score": 0.0007, "epss_percentile": 0.21743}, "CVE-1999-0337": {"epss_score": 0.00767, "epss_percentile": 0.72954}, "CVE-1999-0338": {"epss_score": 0.00064, "epss_percentile": 0.20133}, "CVE-1999-0339": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0340": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0341": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0342": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0343": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0344": {"epss_score": 0.00437, "epss_percentile": 0.62499}, "CVE-1999-0345": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0346": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-1999-0347": {"epss_score": 0.03186, "epss_percentile": 0.86591}, "CVE-1999-0348": {"epss_score": 0.1324, "epss_percentile": 0.93909}, "CVE-1999-0349": {"epss_score": 0.11239, "epss_percentile": 0.93276}, "CVE-1999-0350": {"epss_score": 0.0038, "epss_percentile": 0.58939}, "CVE-1999-0351": {"epss_score": 0.00724, "epss_percentile": 0.72035}, "CVE-1999-0352": {"epss_score": 0.00038, "epss_percentile": 0.111}, "CVE-1999-0353": {"epss_score": 0.00311, "epss_percentile": 0.53927}, "CVE-1999-0354": {"epss_score": 0.03068, "epss_percentile": 0.8634}, "CVE-1999-0355": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0356": {"epss_score": 0.0026, "epss_percentile": 0.49185}, "CVE-1999-0357": {"epss_score": 0.07277, "epss_percentile": 0.9138}, "CVE-1999-0358": {"epss_score": 0.00045, "epss_percentile": 0.1382}, "CVE-1999-0359": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0360": {"epss_score": 0.07766, "epss_percentile": 0.91667}, "CVE-1999-0361": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0362": {"epss_score": 0.00122, "epss_percentile": 0.32133}, "CVE-1999-0363": {"epss_score": 0.01128, "epss_percentile": 0.77826}, "CVE-1999-0364": {"epss_score": 0.11702, "epss_percentile": 0.93456}, "CVE-1999-0365": {"epss_score": 0.01488, "epss_percentile": 0.80616}, "CVE-1999-0366": {"epss_score": 0.05702, "epss_percentile": 0.90133}, "CVE-1999-0367": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-1999-0368": {"epss_score": 0.48326, "epss_percentile": 0.97631}, "CVE-1999-0369": {"epss_score": 0.00312, "epss_percentile": 0.53947}, "CVE-1999-0370": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-1999-0371": {"epss_score": 0.00077, "epss_percentile": 0.23353}, "CVE-1999-0372": {"epss_score": 0.0626, "epss_percentile": 0.90619}, "CVE-1999-0373": {"epss_score": 0.00084, "epss_percentile": 0.2486}, "CVE-1999-0374": {"epss_score": 0.00117, "epss_percentile": 0.31332}, "CVE-1999-0375": {"epss_score": 0.00966, "epss_percentile": 0.76062}, "CVE-1999-0376": {"epss_score": 0.00471, "epss_percentile": 0.63996}, "CVE-1999-0377": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0378": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0379": {"epss_score": 0.08913, "epss_percentile": 0.92315}, "CVE-1999-0380": {"epss_score": 0.00091, "epss_percentile": 0.26259}, "CVE-1999-0381": {"epss_score": 0.00453, "epss_percentile": 0.63202}, "CVE-1999-0382": {"epss_score": 0.03098, "epss_percentile": 0.86406}, "CVE-1999-0383": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0384": {"epss_score": 0.00282, "epss_percentile": 0.51213}, "CVE-1999-0385": {"epss_score": 0.08997, "epss_percentile": 0.92357}, "CVE-1999-0386": {"epss_score": 0.57816, "epss_percentile": 0.98084}, "CVE-1999-0387": {"epss_score": 0.24276, "epss_percentile": 0.95899}, "CVE-1999-0388": {"epss_score": 0.00239, "epss_percentile": 0.46864}, "CVE-1999-0389": {"epss_score": 0.00055, "epss_percentile": 0.1752}, "CVE-1999-0390": {"epss_score": 0.00071, "epss_percentile": 0.22145}, "CVE-1999-0391": {"epss_score": 0.04499, "epss_percentile": 0.88763}, "CVE-1999-0392": {"epss_score": 0.00647, "epss_percentile": 0.70185}, "CVE-1999-0393": {"epss_score": 0.0603, "epss_percentile": 0.90423}, "CVE-1999-0394": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0395": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-1999-0396": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0397": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0398": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-1999-0399": {"epss_score": 0.0083, "epss_percentile": 0.74031}, "CVE-1999-0400": {"epss_score": 0.01005, "epss_percentile": 0.76545}, "CVE-1999-0401": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-1999-0402": {"epss_score": 0.00462, "epss_percentile": 0.63583}, "CVE-1999-0403": {"epss_score": 0.00441, "epss_percentile": 0.6268}, "CVE-1999-0404": {"epss_score": 0.03983, "epss_percentile": 0.88061}, "CVE-1999-0405": {"epss_score": 0.00378, "epss_percentile": 0.58795}, "CVE-1999-0406": {"epss_score": 0.0004, "epss_percentile": 0.12015}, "CVE-1999-0407": {"epss_score": 0.29622, "epss_percentile": 0.96462}, "CVE-1999-0408": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0409": {"epss_score": 0.00333, "epss_percentile": 0.55631}, "CVE-1999-0410": {"epss_score": 0.00145, "epss_percentile": 0.35517}, "CVE-1999-0411": {"epss_score": 0.00081, "epss_percentile": 0.24218}, "CVE-1999-0412": {"epss_score": 0.27072, "epss_percentile": 0.96203}, "CVE-1999-0413": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0414": {"epss_score": 0.06683, "epss_percentile": 0.90942}, "CVE-1999-0415": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-1999-0416": {"epss_score": 0.148, "epss_percentile": 0.94288}, "CVE-1999-0417": {"epss_score": 0.00195, "epss_percentile": 0.41632}, "CVE-1999-0418": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0419": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0420": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0421": {"epss_score": 0.00346, "epss_percentile": 0.56676}, "CVE-1999-0422": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-1999-0423": {"epss_score": 0.00103, "epss_percentile": 0.28994}, "CVE-1999-0424": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-1999-0425": {"epss_score": 0.00428, "epss_percentile": 0.61945}, "CVE-1999-0426": {"epss_score": 0.04237, "epss_percentile": 0.88429}, "CVE-1999-0427": {"epss_score": 0.00556, "epss_percentile": 0.6752}, "CVE-1999-0428": {"epss_score": 0.00136, "epss_percentile": 0.34158}, "CVE-1999-0429": {"epss_score": 0.0057, "epss_percentile": 0.67942}, "CVE-1999-0430": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0431": {"epss_score": 0.09154, "epss_percentile": 0.92424}, "CVE-1999-0432": {"epss_score": 0.00103, "epss_percentile": 0.28994}, "CVE-1999-0433": {"epss_score": 0.00172, "epss_percentile": 0.38982}, "CVE-1999-0434": {"epss_score": 0.00429, "epss_percentile": 0.61974}, "CVE-1999-0435": {"epss_score": 0.0006, "epss_percentile": 0.19029}, "CVE-1999-0436": {"epss_score": 0.00103, "epss_percentile": 0.28994}, "CVE-1999-0437": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-1999-0438": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-1999-0439": {"epss_score": 0.00593, "epss_percentile": 0.68642}, "CVE-1999-0440": {"epss_score": 0.01617, "epss_percentile": 0.81362}, "CVE-1999-0441": {"epss_score": 0.03958, "epss_percentile": 0.8801}, "CVE-1999-0442": {"epss_score": 0.00154, "epss_percentile": 0.36754}, "CVE-1999-0443": {"epss_score": 0.01271, "epss_percentile": 0.79056}, "CVE-1999-0444": {"epss_score": 0.07277, "epss_percentile": 0.9138}, "CVE-1999-0445": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0446": {"epss_score": 0.00075, "epss_percentile": 0.22996}, "CVE-1999-0447": {"epss_score": 0.00103, "epss_percentile": 0.28994}, "CVE-1999-0448": {"epss_score": 0.53319, "epss_percentile": 0.97871}, "CVE-1999-0449": {"epss_score": 0.36242, "epss_percentile": 0.96963}, "CVE-1999-0450": {"epss_score": 0.31834, "epss_percentile": 0.96653}, "CVE-1999-0451": {"epss_score": 0.00367, "epss_percentile": 0.5811}, "CVE-1999-0452": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0453": {"epss_score": 0.00855, "epss_percentile": 0.74465}, "CVE-1999-0454": {"epss_score": 0.01229, "epss_percentile": 0.78717}, "CVE-1999-0455": {"epss_score": 0.09129, "epss_percentile": 0.92414}, "CVE-1999-0457": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0458": {"epss_score": 0.0013, "epss_percentile": 0.33284}, "CVE-1999-0459": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-1999-0460": {"epss_score": 0.00371, "epss_percentile": 0.58351}, "CVE-1999-0461": {"epss_score": 0.01271, "epss_percentile": 0.79056}, "CVE-1999-0462": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-1999-0463": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0464": {"epss_score": 0.00081, "epss_percentile": 0.24318}, "CVE-1999-0465": {"epss_score": 0.01271, "epss_percentile": 0.79056}, "CVE-1999-0466": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0467": {"epss_score": 0.03913, "epss_percentile": 0.87936}, "CVE-1999-0468": {"epss_score": 0.03207, "epss_percentile": 0.86636}, "CVE-1999-0469": {"epss_score": 0.11552, "epss_percentile": 0.93401}, "CVE-1999-0470": {"epss_score": 0.00836, "epss_percentile": 0.74141}, "CVE-1999-0471": {"epss_score": 0.0077, "epss_percentile": 0.72996}, "CVE-1999-0472": {"epss_score": 0.00689, "epss_percentile": 0.71225}, "CVE-1999-0473": {"epss_score": 0.00095, "epss_percentile": 0.27226}, "CVE-1999-0474": {"epss_score": 0.008, "epss_percentile": 0.73535}, "CVE-1999-0475": {"epss_score": 0.00178, "epss_percentile": 0.39706}, "CVE-1999-0476": {"epss_score": 0.00045, "epss_percentile": 0.13915}, "CVE-1999-0477": {"epss_score": 0.06853, "epss_percentile": 0.91074}, "CVE-1999-0478": {"epss_score": 0.00626, "epss_percentile": 0.6962}, "CVE-1999-0479": {"epss_score": 0.0071, "epss_percentile": 0.71718}, "CVE-1999-0480": {"epss_score": 0.00075, "epss_percentile": 0.22996}, "CVE-1999-0481": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0482": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0483": {"epss_score": 0.00084, "epss_percentile": 0.25016}, "CVE-1999-0484": {"epss_score": 0.00134, "epss_percentile": 0.33804}, "CVE-1999-0485": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0486": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0487": {"epss_score": 0.21091, "epss_percentile": 0.95462}, "CVE-1999-0488": {"epss_score": 0.03376, "epss_percentile": 0.87022}, "CVE-1999-0489": {"epss_score": 0.17107, "epss_percentile": 0.94776}, "CVE-1999-0490": {"epss_score": 0.04532, "epss_percentile": 0.88813}, "CVE-1999-0491": {"epss_score": 0.003, "epss_percentile": 0.52975}, "CVE-1999-0492": {"epss_score": 0.03425, "epss_percentile": 0.87114}, "CVE-1999-0493": {"epss_score": 0.06771, "epss_percentile": 0.91015}, "CVE-1999-0494": {"epss_score": 0.00497, "epss_percentile": 0.65187}, "CVE-1999-0495": {"epss_score": 0.01271, "epss_percentile": 0.79056}, "CVE-1999-0496": {"epss_score": 0.00311, "epss_percentile": 0.53808}, "CVE-1999-0497": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0498": {"epss_score": 0.01271, "epss_percentile": 0.79056}, "CVE-1999-0499": {"epss_score": 0.04765, "epss_percentile": 0.89122}, "CVE-1999-0501": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-1999-0502": {"epss_score": 0.38944, "epss_percentile": 0.97129}, "CVE-1999-0503": {"epss_score": 0.00644, "epss_percentile": 0.70092}, "CVE-1999-0504": {"epss_score": 0.39474, "epss_percentile": 0.97163}, "CVE-1999-0505": {"epss_score": 0.00683, "epss_percentile": 0.71091}, "CVE-1999-0506": {"epss_score": 0.07393, "epss_percentile": 0.9145}, "CVE-1999-0507": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0508": {"epss_score": 0.35839, "epss_percentile": 0.96937}, "CVE-1999-0509": {"epss_score": 0.01893, "epss_percentile": 0.82738}, "CVE-1999-0510": {"epss_score": 0.00744, "epss_percentile": 0.72509}, "CVE-1999-0511": {"epss_score": 0.08009, "epss_percentile": 0.91826}, "CVE-1999-0512": {"epss_score": 0.00427, "epss_percentile": 0.61905}, "CVE-1999-0513": {"epss_score": 0.25583, "epss_percentile": 0.96047}, "CVE-1999-0514": {"epss_score": 0.00562, "epss_percentile": 0.67691}, "CVE-1999-0515": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0516": {"epss_score": 0.73977, "epss_percentile": 0.98779}, "CVE-1999-0517": {"epss_score": 0.92333, "epss_percentile": 0.99709}, "CVE-1999-0518": {"epss_score": 0.04001, "epss_percentile": 0.88092}, "CVE-1999-0519": {"epss_score": 0.10194, "epss_percentile": 0.92887}, "CVE-1999-0520": {"epss_score": 0.01163, "epss_percentile": 0.78159}, "CVE-1999-0521": {"epss_score": 0.00067, "epss_percentile": 0.21112}, "CVE-1999-0522": {"epss_score": 0.00051, "epss_percentile": 0.16104}, "CVE-1999-0523": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0524": {"epss_score": 0.00781, "epss_percentile": 0.73194}, "CVE-1999-0525": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0526": {"epss_score": 0.66801, "epss_percentile": 0.98479}, "CVE-1999-0527": {"epss_score": 0.00353, "epss_percentile": 0.57176}, "CVE-1999-0528": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0529": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0530": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0532": {"epss_score": 0.82224, "epss_percentile": 0.99181}, "CVE-1999-0533": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0534": {"epss_score": 0.00282, "epss_percentile": 0.51213}, "CVE-1999-0535": {"epss_score": 0.11757, "epss_percentile": 0.93466}, "CVE-1999-0537": {"epss_score": 0.00932, "epss_percentile": 0.75633}, "CVE-1999-0539": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0541": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0546": {"epss_score": 0.00472, "epss_percentile": 0.64066}, "CVE-1999-0547": {"epss_score": 0.00392, "epss_percentile": 0.59694}, "CVE-1999-0548": {"epss_score": 0.00248, "epss_percentile": 0.47913}, "CVE-1999-0549": {"epss_score": 0.00411, "epss_percentile": 0.60868}, "CVE-1999-0550": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0551": {"epss_score": 0.00116, "epss_percentile": 0.3107}, "CVE-1999-0554": {"epss_score": 0.25262, "epss_percentile": 0.96006}, "CVE-1999-0555": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0556": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0559": {"epss_score": 0.00353, "epss_percentile": 0.57176}, "CVE-1999-0560": {"epss_score": 0.0257, "epss_percentile": 0.85128}, "CVE-1999-0561": {"epss_score": 0.00923, "epss_percentile": 0.7551}, "CVE-1999-0562": {"epss_score": 0.14107, "epss_percentile": 0.94133}, "CVE-1999-0564": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0565": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-1999-0566": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0568": {"epss_score": 0.00527, "epss_percentile": 0.66439}, "CVE-1999-0569": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-1999-0570": {"epss_score": 0.11702, "epss_percentile": 0.93456}, "CVE-1999-0571": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0572": {"epss_score": 0.09011, "epss_percentile": 0.92363}, "CVE-1999-0575": {"epss_score": 0.08661, "epss_percentile": 0.92176}, "CVE-1999-0576": {"epss_score": 0.06569, "epss_percentile": 0.90853}, "CVE-1999-0577": {"epss_score": 0.13357, "epss_percentile": 0.93941}, "CVE-1999-0578": {"epss_score": 0.0034, "epss_percentile": 0.56239}, "CVE-1999-0579": {"epss_score": 0.13357, "epss_percentile": 0.93941}, "CVE-1999-0580": {"epss_score": 0.00353, "epss_percentile": 0.57176}, "CVE-1999-0581": {"epss_score": 0.04008, "epss_percentile": 0.88104}, "CVE-1999-0582": {"epss_score": 0.11618, "epss_percentile": 0.93421}, "CVE-1999-0583": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0584": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0585": {"epss_score": 0.00769, "epss_percentile": 0.7298}, "CVE-1999-0586": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0587": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0588": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0589": {"epss_score": 0.00353, "epss_percentile": 0.57176}, "CVE-1999-0590": {"epss_score": 0.10341, "epss_percentile": 0.9295}, "CVE-1999-0591": {"epss_score": 0.00365, "epss_percentile": 0.58007}, "CVE-1999-0592": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0593": {"epss_score": 0.00494, "epss_percentile": 0.65095}, "CVE-1999-0594": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0595": {"epss_score": 0.00778, "epss_percentile": 0.73122}, "CVE-1999-0596": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0597": {"epss_score": 0.01271, "epss_percentile": 0.79056}, "CVE-1999-0598": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0599": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0600": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0601": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0602": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0603": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-1999-0604": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0605": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0606": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0607": {"epss_score": 0.00539, "epss_percentile": 0.66959}, "CVE-1999-0608": {"epss_score": 0.00689, "epss_percentile": 0.71225}, "CVE-1999-0609": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0610": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0611": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-1999-0612": {"epss_score": 0.25185, "epss_percentile": 0.95996}, "CVE-1999-0613": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0618": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0624": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0625": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0626": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0627": {"epss_score": 0.01612, "epss_percentile": 0.81333}, "CVE-1999-0628": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0629": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0630": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0632": {"epss_score": 0.00918, "epss_percentile": 0.7544}, "CVE-1999-0635": {"epss_score": 0.00755, "epss_percentile": 0.72718}, "CVE-1999-0636": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-1999-0637": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0638": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0639": {"epss_score": 0.00918, "epss_percentile": 0.7544}, "CVE-1999-0640": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0641": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0650": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-1999-0651": {"epss_score": 0.50061, "epss_percentile": 0.97717}, "CVE-1999-0653": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0654": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0656": {"epss_score": 0.00513, "epss_percentile": 0.65878}, "CVE-1999-0657": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0661": {"epss_score": 0.06416, "epss_percentile": 0.90745}, "CVE-1999-0662": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0663": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-1999-0664": {"epss_score": 0.00353, "epss_percentile": 0.57176}, "CVE-1999-0665": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-1999-0667": {"epss_score": 0.44366, "epss_percentile": 0.97432}, "CVE-1999-0668": {"epss_score": 0.19222, "epss_percentile": 0.95151}, "CVE-1999-0669": {"epss_score": 0.07504, "epss_percentile": 0.91508}, "CVE-1999-0670": {"epss_score": 0.07842, "epss_percentile": 0.91715}, "CVE-1999-0671": {"epss_score": 0.01619, "epss_percentile": 0.81382}, "CVE-1999-0672": {"epss_score": 0.03003, "epss_percentile": 0.86178}, "CVE-1999-0673": {"epss_score": 0.03003, "epss_percentile": 0.86178}, "CVE-1999-0674": {"epss_score": 0.00082, "epss_percentile": 0.24431}, "CVE-1999-0675": {"epss_score": 0.00569, "epss_percentile": 0.67911}, "CVE-1999-0676": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-1999-0677": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0678": {"epss_score": 0.17194, "epss_percentile": 0.94795}, "CVE-1999-0679": {"epss_score": 0.05739, "epss_percentile": 0.90166}, "CVE-1999-0680": {"epss_score": 0.04498, "epss_percentile": 0.88763}, "CVE-1999-0681": {"epss_score": 0.11039, "epss_percentile": 0.93198}, "CVE-1999-0682": {"epss_score": 0.18355, "epss_percentile": 0.95002}, "CVE-1999-0683": {"epss_score": 0.0553, "epss_percentile": 0.89965}, "CVE-1999-0684": {"epss_score": 0.0071, "epss_percentile": 0.71718}, "CVE-1999-0685": {"epss_score": 0.03003, "epss_percentile": 0.86178}, "CVE-1999-0686": {"epss_score": 0.0071, "epss_percentile": 0.71718}, "CVE-1999-0687": {"epss_score": 0.07295, "epss_percentile": 0.91388}, "CVE-1999-0688": {"epss_score": 0.00123, "epss_percentile": 0.322}, "CVE-1999-0689": {"epss_score": 0.00084, "epss_percentile": 0.24858}, "CVE-1999-0690": {"epss_score": 0.00052, "epss_percentile": 0.16514}, "CVE-1999-0691": {"epss_score": 0.00367, "epss_percentile": 0.58159}, "CVE-1999-0692": {"epss_score": 0.005, "epss_percentile": 0.65296}, "CVE-1999-0693": {"epss_score": 0.14837, "epss_percentile": 0.94299}, "CVE-1999-0694": {"epss_score": 0.00058, "epss_percentile": 0.18446}, "CVE-1999-0695": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0696": {"epss_score": 0.05576, "epss_percentile": 0.90013}, "CVE-1999-0697": {"epss_score": 0.00081, "epss_percentile": 0.24218}, "CVE-1999-0698": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-0699": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0700": {"epss_score": 0.03678, "epss_percentile": 0.87555}, "CVE-1999-0701": {"epss_score": 0.00779, "epss_percentile": 0.73143}, "CVE-1999-0702": {"epss_score": 0.35854, "epss_percentile": 0.96938}, "CVE-1999-0703": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-1999-0704": {"epss_score": 0.04185, "epss_percentile": 0.88361}, "CVE-1999-0705": {"epss_score": 0.06629, "epss_percentile": 0.90901}, "CVE-1999-0706": {"epss_score": 0.00862, "epss_percentile": 0.74569}, "CVE-1999-0707": {"epss_score": 0.0074, "epss_percentile": 0.72411}, "CVE-1999-0708": {"epss_score": 0.00145, "epss_percentile": 0.35517}, "CVE-1999-0710": {"epss_score": 0.12632, "epss_percentile": 0.93735}, "CVE-1999-0711": {"epss_score": 0.00483, "epss_percentile": 0.64615}, "CVE-1999-0712": {"epss_score": 0.0013, "epss_percentile": 0.33284}, "CVE-1999-0713": {"epss_score": 0.00038, "epss_percentile": 0.11137}, "CVE-1999-0714": {"epss_score": 0.00082, "epss_percentile": 0.24486}, "CVE-1999-0715": {"epss_score": 0.01179, "epss_percentile": 0.78295}, "CVE-1999-0716": {"epss_score": 0.0452, "epss_percentile": 0.88798}, "CVE-1999-0717": {"epss_score": 0.10165, "epss_percentile": 0.92872}, "CVE-1999-0718": {"epss_score": 0.00068, "epss_percentile": 0.21187}, "CVE-1999-0719": {"epss_score": 0.00096, "epss_percentile": 0.27416}, "CVE-1999-0720": {"epss_score": 0.00362, "epss_percentile": 0.57776}, "CVE-1999-0721": {"epss_score": 0.18906, "epss_percentile": 0.95095}, "CVE-1999-0722": {"epss_score": 0.00939, "epss_percentile": 0.75721}, "CVE-1999-0723": {"epss_score": 0.21051, "epss_percentile": 0.95457}, "CVE-1999-0724": {"epss_score": 0.00087, "epss_percentile": 0.25509}, "CVE-1999-0725": {"epss_score": 0.38532, "epss_percentile": 0.97103}, "CVE-1999-0726": {"epss_score": 0.18906, "epss_percentile": 0.95095}, "CVE-1999-0727": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0728": {"epss_score": 0.20352, "epss_percentile": 0.9533}, "CVE-1999-0729": {"epss_score": 0.00506, "epss_percentile": 0.65617}, "CVE-1999-0730": {"epss_score": 0.02085, "epss_percentile": 0.83547}, "CVE-1999-0731": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-1999-0732": {"epss_score": 0.00135, "epss_percentile": 0.33966}, "CVE-1999-0733": {"epss_score": 0.00811, "epss_percentile": 0.73728}, "CVE-1999-0734": {"epss_score": 0.00785, "epss_percentile": 0.7326}, "CVE-1999-0735": {"epss_score": 0.00266, "epss_percentile": 0.49942}, "CVE-1999-0736": {"epss_score": 0.76516, "epss_percentile": 0.98894}, "CVE-1999-0737": {"epss_score": 0.52891, "epss_percentile": 0.97845}, "CVE-1999-0738": {"epss_score": 0.464, "epss_percentile": 0.97544}, "CVE-1999-0739": {"epss_score": 0.464, "epss_percentile": 0.97544}, "CVE-1999-0740": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0741": {"epss_score": 0.00742, "epss_percentile": 0.72456}, "CVE-1999-0742": {"epss_score": 0.00636, "epss_percentile": 0.69866}, "CVE-1999-0743": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-1999-0744": {"epss_score": 0.04551, "epss_percentile": 0.88839}, "CVE-1999-0745": {"epss_score": 0.25839, "epss_percentile": 0.96077}, "CVE-1999-0746": {"epss_score": 0.0603, "epss_percentile": 0.90423}, "CVE-1999-0747": {"epss_score": 0.00084, "epss_percentile": 0.25016}, "CVE-1999-0748": {"epss_score": 0.00518, "epss_percentile": 0.66127}, "CVE-1999-0749": {"epss_score": 0.20913, "epss_percentile": 0.95441}, "CVE-1999-0750": {"epss_score": 0.02681, "epss_percentile": 0.85417}, "CVE-1999-0751": {"epss_score": 0.03382, "epss_percentile": 0.87033}, "CVE-1999-0752": {"epss_score": 0.03748, "epss_percentile": 0.87668}, "CVE-1999-0753": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-1999-0754": {"epss_score": 0.00743, "epss_percentile": 0.72477}, "CVE-1999-0755": {"epss_score": 0.65451, "epss_percentile": 0.98419}, "CVE-1999-0756": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0757": {"epss_score": 0.00374, "epss_percentile": 0.58583}, "CVE-1999-0758": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-1999-0759": {"epss_score": 0.02776, "epss_percentile": 0.85636}, "CVE-1999-0760": {"epss_score": 0.00544, "epss_percentile": 0.6715}, "CVE-1999-0761": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0762": {"epss_score": 0.00303, "epss_percentile": 0.53227}, "CVE-1999-0763": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0764": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0765": {"epss_score": 0.02085, "epss_percentile": 0.83547}, "CVE-1999-0766": {"epss_score": 0.06502, "epss_percentile": 0.90803}, "CVE-1999-0767": {"epss_score": 0.00626, "epss_percentile": 0.69599}, "CVE-1999-0768": {"epss_score": 0.06264, "epss_percentile": 0.90622}, "CVE-1999-0769": {"epss_score": 0.0038, "epss_percentile": 0.58939}, "CVE-1999-0770": {"epss_score": 0.00623, "epss_percentile": 0.69551}, "CVE-1999-0771": {"epss_score": 0.05035, "epss_percentile": 0.89419}, "CVE-1999-0772": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0773": {"epss_score": 0.00145, "epss_percentile": 0.35517}, "CVE-1999-0774": {"epss_score": 0.01128, "epss_percentile": 0.77826}, "CVE-1999-0775": {"epss_score": 0.01105, "epss_percentile": 0.77611}, "CVE-1999-0776": {"epss_score": 0.00763, "epss_percentile": 0.72882}, "CVE-1999-0777": {"epss_score": 0.0134, "epss_percentile": 0.7958}, "CVE-1999-0778": {"epss_score": 0.00453, "epss_percentile": 0.63202}, "CVE-1999-0779": {"epss_score": 0.0071, "epss_percentile": 0.71718}, "CVE-1999-0780": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-1999-0781": {"epss_score": 0.00102, "epss_percentile": 0.28809}, "CVE-1999-0782": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-1999-0783": {"epss_score": 0.00225, "epss_percentile": 0.4508}, "CVE-1999-0784": {"epss_score": 0.00604, "epss_percentile": 0.68952}, "CVE-1999-0785": {"epss_score": 0.00107, "epss_percentile": 0.29666}, "CVE-1999-0786": {"epss_score": 0.00154, "epss_percentile": 0.36754}, "CVE-1999-0787": {"epss_score": 0.00614, "epss_percentile": 0.69285}, "CVE-1999-0788": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0789": {"epss_score": 0.31585, "epss_percentile": 0.96628}, "CVE-1999-0790": {"epss_score": 0.00351, "epss_percentile": 0.57016}, "CVE-1999-0791": {"epss_score": 0.06662, "epss_percentile": 0.90924}, "CVE-1999-0792": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-0793": {"epss_score": 0.21091, "epss_percentile": 0.95462}, "CVE-1999-0794": {"epss_score": 0.00304, "epss_percentile": 0.53309}, "CVE-1999-0795": {"epss_score": 0.01045, "epss_percentile": 0.77013}, "CVE-1999-0796": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0797": {"epss_score": 0.00546, "epss_percentile": 0.6721}, "CVE-1999-0798": {"epss_score": 0.00512, "epss_percentile": 0.65862}, "CVE-1999-0799": {"epss_score": 0.00512, "epss_percentile": 0.65862}, "CVE-1999-0800": {"epss_score": 0.06958, "epss_percentile": 0.91148}, "CVE-1999-0801": {"epss_score": 0.00952, "epss_percentile": 0.75875}, "CVE-1999-0802": {"epss_score": 0.17946, "epss_percentile": 0.94932}, "CVE-1999-0803": {"epss_score": 0.0271, "epss_percentile": 0.85491}, "CVE-1999-0804": {"epss_score": 0.05411, "epss_percentile": 0.89847}, "CVE-1999-0805": {"epss_score": 0.00717, "epss_percentile": 0.71887}, "CVE-1999-0806": {"epss_score": 0.0041, "epss_percentile": 0.60835}, "CVE-1999-0807": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0808": {"epss_score": 0.01955, "epss_percentile": 0.83034}, "CVE-1999-0809": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-0810": {"epss_score": 0.00474, "epss_percentile": 0.6414}, "CVE-1999-0811": {"epss_score": 0.05844, "epss_percentile": 0.90254}, "CVE-1999-0812": {"epss_score": 0.00415, "epss_percentile": 0.61128}, "CVE-1999-0813": {"epss_score": 0.00067, "epss_percentile": 0.21128}, "CVE-1999-0814": {"epss_score": 0.00939, "epss_percentile": 0.75721}, "CVE-1999-0815": {"epss_score": 0.17101, "epss_percentile": 0.94774}, "CVE-1999-0816": {"epss_score": 0.01619, "epss_percentile": 0.8138}, "CVE-1999-0817": {"epss_score": 0.01271, "epss_percentile": 0.79056}, "CVE-1999-0818": {"epss_score": 0.0041, "epss_percentile": 0.60835}, "CVE-1999-0819": {"epss_score": 0.56476, "epss_percentile": 0.98024}, "CVE-1999-0820": {"epss_score": 0.00904, "epss_percentile": 0.75213}, "CVE-1999-0821": {"epss_score": 0.00347, "epss_percentile": 0.56788}, "CVE-1999-0822": {"epss_score": 0.0725, "epss_percentile": 0.9135}, "CVE-1999-0823": {"epss_score": 0.00431, "epss_percentile": 0.62086}, "CVE-1999-0824": {"epss_score": 0.00272, "epss_percentile": 0.50371}, "CVE-1999-0825": {"epss_score": 0.00192, "epss_percentile": 0.4135}, "CVE-1999-0826": {"epss_score": 0.00431, "epss_percentile": 0.62086}, "CVE-1999-0827": {"epss_score": 0.00877, "epss_percentile": 0.748}, "CVE-1999-0828": {"epss_score": 0.00234, "epss_percentile": 0.46093}, "CVE-1999-0829": {"epss_score": 0.00797, "epss_percentile": 0.73503}, "CVE-1999-0830": {"epss_score": 0.005, "epss_percentile": 0.65304}, "CVE-1999-0831": {"epss_score": 0.0052, "epss_percentile": 0.66212}, "CVE-1999-0832": {"epss_score": 0.01236, "epss_percentile": 0.7877}, "CVE-1999-0833": {"epss_score": 0.01515, "epss_percentile": 0.80796}, "CVE-1999-0834": {"epss_score": 0.03223, "epss_percentile": 0.86677}, "CVE-1999-0835": {"epss_score": 0.00591, "epss_percentile": 0.68589}, "CVE-1999-0836": {"epss_score": 0.01565, "epss_percentile": 0.81064}, "CVE-1999-0837": {"epss_score": 0.01145, "epss_percentile": 0.77995}, "CVE-1999-0838": {"epss_score": 0.03958, "epss_percentile": 0.8801}, "CVE-1999-0839": {"epss_score": 0.00779, "epss_percentile": 0.73143}, "CVE-1999-0840": {"epss_score": 0.00236, "epss_percentile": 0.46445}, "CVE-1999-0841": {"epss_score": 0.00343, "epss_percentile": 0.56463}, "CVE-1999-0842": {"epss_score": 0.03802, "epss_percentile": 0.87746}, "CVE-1999-0843": {"epss_score": 0.00674, "epss_percentile": 0.70878}, "CVE-1999-0844": {"epss_score": 0.04488, "epss_percentile": 0.88754}, "CVE-1999-0845": {"epss_score": 0.00239, "epss_percentile": 0.46929}, "CVE-1999-0846": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0847": {"epss_score": 0.00534, "epss_percentile": 0.66782}, "CVE-1999-0848": {"epss_score": 0.10156, "epss_percentile": 0.92868}, "CVE-1999-0849": {"epss_score": 0.01854, "epss_percentile": 0.82554}, "CVE-1999-0850": {"epss_score": 0.00085, "epss_percentile": 0.25093}, "CVE-1999-0851": {"epss_score": 0.00091, "epss_percentile": 0.26276}, "CVE-1999-0852": {"epss_score": 0.00048, "epss_percentile": 0.15123}, "CVE-1999-0853": {"epss_score": 0.00926, "epss_percentile": 0.75545}, "CVE-1999-0854": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-1999-0855": {"epss_score": 0.01128, "epss_percentile": 0.77826}, "CVE-1999-0856": {"epss_score": 0.00231, "epss_percentile": 0.45812}, "CVE-1999-0857": {"epss_score": 0.00362, "epss_percentile": 0.57776}, "CVE-1999-0858": {"epss_score": 0.11912, "epss_percentile": 0.93513}, "CVE-1999-0859": {"epss_score": 0.00175, "epss_percentile": 0.393}, "CVE-1999-0860": {"epss_score": 0.00175, "epss_percentile": 0.393}, "CVE-1999-0861": {"epss_score": 0.05457, "epss_percentile": 0.89897}, "CVE-1999-0862": {"epss_score": 0.00087, "epss_percentile": 0.25607}, "CVE-1999-0863": {"epss_score": 0.00087, "epss_percentile": 0.25509}, "CVE-1999-0864": {"epss_score": 0.00241, "epss_percentile": 0.47259}, "CVE-1999-0865": {"epss_score": 0.00602, "epss_percentile": 0.68894}, "CVE-1999-0866": {"epss_score": 0.00237, "epss_percentile": 0.46729}, "CVE-1999-0867": {"epss_score": 0.19417, "epss_percentile": 0.95179}, "CVE-1999-0868": {"epss_score": 0.00125, "epss_percentile": 0.32475}, "CVE-1999-0869": {"epss_score": 0.13005, "epss_percentile": 0.93844}, "CVE-1999-0870": {"epss_score": 0.07229, "epss_percentile": 0.91336}, "CVE-1999-0871": {"epss_score": 0.11216, "epss_percentile": 0.93268}, "CVE-1999-0872": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0873": {"epss_score": 0.03003, "epss_percentile": 0.86178}, "CVE-1999-0874": {"epss_score": 0.84474, "epss_percentile": 0.99291}, "CVE-1999-0875": {"epss_score": 0.38317, "epss_percentile": 0.97096}, "CVE-1999-0876": {"epss_score": 0.24145, "epss_percentile": 0.9588}, "CVE-1999-0877": {"epss_score": 0.20861, "epss_percentile": 0.95429}, "CVE-1999-0878": {"epss_score": 0.01346, "epss_percentile": 0.79629}, "CVE-1999-0879": {"epss_score": 0.03141, "epss_percentile": 0.86489}, "CVE-1999-0880": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-1999-0881": {"epss_score": 0.00559, "epss_percentile": 0.67618}, "CVE-1999-0882": {"epss_score": 0.00559, "epss_percentile": 0.67618}, "CVE-1999-0883": {"epss_score": 0.011, "epss_percentile": 0.77568}, "CVE-1999-0884": {"epss_score": 0.00371, "epss_percentile": 0.58386}, "CVE-1999-0885": {"epss_score": 0.00884, "epss_percentile": 0.74932}, "CVE-1999-0886": {"epss_score": 0.34254, "epss_percentile": 0.96836}, "CVE-1999-0887": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-1999-0888": {"epss_score": 0.00212, "epss_percentile": 0.43762}, "CVE-1999-0889": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-1999-0890": {"epss_score": 0.01289, "epss_percentile": 0.79211}, "CVE-1999-0891": {"epss_score": 0.601, "epss_percentile": 0.98192}, "CVE-1999-0892": {"epss_score": 0.00087, "epss_percentile": 0.25509}, "CVE-1999-0893": {"epss_score": 0.00196, "epss_percentile": 0.41785}, "CVE-1999-0894": {"epss_score": 0.00409, "epss_percentile": 0.60735}, "CVE-1999-0895": {"epss_score": 0.00552, "epss_percentile": 0.67387}, "CVE-1999-0896": {"epss_score": 0.07207, "epss_percentile": 0.91324}, "CVE-1999-0897": {"epss_score": 0.00559, "epss_percentile": 0.67618}, "CVE-1999-0898": {"epss_score": 0.03808, "epss_percentile": 0.87754}, "CVE-1999-0899": {"epss_score": 0.01934, "epss_percentile": 0.82956}, "CVE-1999-0900": {"epss_score": 0.00175, "epss_percentile": 0.3932}, "CVE-1999-0901": {"epss_score": 0.00181, "epss_percentile": 0.40126}, "CVE-1999-0902": {"epss_score": 0.00181, "epss_percentile": 0.40126}, "CVE-1999-0903": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0904": {"epss_score": 0.03958, "epss_percentile": 0.8801}, "CVE-1999-0905": {"epss_score": 0.03801, "epss_percentile": 0.87744}, "CVE-1999-0906": {"epss_score": 0.00077, "epss_percentile": 0.23382}, "CVE-1999-0907": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-1999-0908": {"epss_score": 0.03801, "epss_percentile": 0.87744}, "CVE-1999-0909": {"epss_score": 0.04278, "epss_percentile": 0.88485}, "CVE-1999-0910": {"epss_score": 0.19634, "epss_percentile": 0.95218}, "CVE-1999-0911": {"epss_score": 0.21289, "epss_percentile": 0.95496}, "CVE-1999-0912": {"epss_score": 0.00403, "epss_percentile": 0.60362}, "CVE-1999-0913": {"epss_score": 0.04286, "epss_percentile": 0.88495}, "CVE-1999-0914": {"epss_score": 0.00872, "epss_percentile": 0.74739}, "CVE-1999-0915": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-1999-0916": {"epss_score": 0.00098, "epss_percentile": 0.27798}, "CVE-1999-0917": {"epss_score": 0.06586, "epss_percentile": 0.90866}, "CVE-1999-0918": {"epss_score": 0.4741, "epss_percentile": 0.97586}, "CVE-1999-0919": {"epss_score": 0.01215, "epss_percentile": 0.78584}, "CVE-1999-0920": {"epss_score": 0.73542, "epss_percentile": 0.9876}, "CVE-1999-0921": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-1999-0922": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-1999-0923": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-1999-0924": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-1999-0925": {"epss_score": 0.04014, "epss_percentile": 0.8812}, "CVE-1999-0926": {"epss_score": 0.06662, "epss_percentile": 0.90924}, "CVE-1999-0927": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-1999-0928": {"epss_score": 0.03958, "epss_percentile": 0.8801}, "CVE-1999-0929": {"epss_score": 0.00239, "epss_percentile": 0.46939}, "CVE-1999-0930": {"epss_score": 0.00485, "epss_percentile": 0.64714}, "CVE-1999-0931": {"epss_score": 0.0431, "epss_percentile": 0.88529}, "CVE-1999-0932": {"epss_score": 0.00213, "epss_percentile": 0.43833}, "CVE-1999-0933": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-1999-0934": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-1999-0935": {"epss_score": 0.03084, "epss_percentile": 0.86378}, "CVE-1999-0936": {"epss_score": 0.0178, "epss_percentile": 0.82234}, "CVE-1999-0937": {"epss_score": 0.01229, "epss_percentile": 0.78717}, "CVE-1999-0938": {"epss_score": 0.0083, "epss_percentile": 0.74031}, "CVE-1999-0939": {"epss_score": 0.0052, "epss_percentile": 0.66212}, "CVE-1999-0940": {"epss_score": 0.00972, "epss_percentile": 0.76141}, "CVE-1999-0941": {"epss_score": 0.0083, "epss_percentile": 0.74031}, "CVE-1999-0942": {"epss_score": 0.00081, "epss_percentile": 0.24218}, "CVE-1999-0943": {"epss_score": 0.04373, "epss_percentile": 0.88613}, "CVE-1999-0944": {"epss_score": 0.0154, "epss_percentile": 0.80941}, "CVE-1999-0945": {"epss_score": 0.21304, "epss_percentile": 0.95498}, "CVE-1999-0946": {"epss_score": 0.03003, "epss_percentile": 0.86178}, "CVE-1999-0947": {"epss_score": 0.05383, "epss_percentile": 0.89816}, "CVE-1999-0948": {"epss_score": 0.00145, "epss_percentile": 0.35517}, "CVE-1999-0949": {"epss_score": 0.00145, "epss_percentile": 0.35517}, "CVE-1999-0950": {"epss_score": 0.0513, "epss_percentile": 0.89529}, "CVE-1999-0951": {"epss_score": 0.04575, "epss_percentile": 0.88868}, "CVE-1999-0952": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0953": {"epss_score": 0.03186, "epss_percentile": 0.86591}, "CVE-1999-0954": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-0955": {"epss_score": 0.01229, "epss_percentile": 0.78717}, "CVE-1999-0956": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0957": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-1999-0958": {"epss_score": 0.00083, "epss_percentile": 0.24796}, "CVE-1999-0959": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-1999-0960": {"epss_score": 0.0038, "epss_percentile": 0.58939}, "CVE-1999-0961": {"epss_score": 0.0006, "epss_percentile": 0.19029}, "CVE-1999-0962": {"epss_score": 0.0007, "epss_percentile": 0.21743}, "CVE-1999-0963": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-0964": {"epss_score": 0.0008, "epss_percentile": 0.24134}, "CVE-1999-0965": {"epss_score": 0.0019, "epss_percentile": 0.41057}, "CVE-1999-0966": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-0967": {"epss_score": 0.17916, "epss_percentile": 0.94926}, "CVE-1999-0968": {"epss_score": 0.05227, "epss_percentile": 0.89634}, "CVE-1999-0969": {"epss_score": 0.15287, "epss_percentile": 0.94401}, "CVE-1999-0970": {"epss_score": 0.04186, "epss_percentile": 0.88363}, "CVE-1999-0971": {"epss_score": 0.00145, "epss_percentile": 0.35517}, "CVE-1999-0972": {"epss_score": 0.03003, "epss_percentile": 0.86178}, "CVE-1999-0973": {"epss_score": 0.03141, "epss_percentile": 0.86489}, "CVE-1999-0974": {"epss_score": 0.0244, "epss_percentile": 0.84752}, "CVE-1999-0975": {"epss_score": 0.0025, "epss_percentile": 0.48209}, "CVE-1999-0976": {"epss_score": 0.00075, "epss_percentile": 0.22996}, "CVE-1999-0977": {"epss_score": 0.05886, "epss_percentile": 0.90294}, "CVE-1999-0978": {"epss_score": 0.0083, "epss_percentile": 0.74031}, "CVE-1999-0979": {"epss_score": 0.00243, "epss_percentile": 0.47472}, "CVE-1999-0980": {"epss_score": 0.24538, "epss_percentile": 0.9593}, "CVE-1999-0981": {"epss_score": 0.03277, "epss_percentile": 0.86805}, "CVE-1999-0982": {"epss_score": 0.00067, "epss_percentile": 0.21112}, "CVE-1999-0983": {"epss_score": 0.0083, "epss_percentile": 0.74031}, "CVE-1999-0984": {"epss_score": 0.0083, "epss_percentile": 0.74031}, "CVE-1999-0985": {"epss_score": 0.04448, "epss_percentile": 0.887}, "CVE-1999-0986": {"epss_score": 0.02358, "epss_percentile": 0.84491}, "CVE-1999-0987": {"epss_score": 0.05512, "epss_percentile": 0.89947}, "CVE-1999-0988": {"epss_score": 0.00187, "epss_percentile": 0.408}, "CVE-1999-0989": {"epss_score": 0.06211, "epss_percentile": 0.9057}, "CVE-1999-0990": {"epss_score": 0.0013, "epss_percentile": 0.33284}, "CVE-1999-0991": {"epss_score": 0.03958, "epss_percentile": 0.8801}, "CVE-1999-0992": {"epss_score": 0.00412, "epss_percentile": 0.60925}, "CVE-1999-0993": {"epss_score": 0.0867, "epss_percentile": 0.92182}, "CVE-1999-0994": {"epss_score": 0.1939, "epss_percentile": 0.95176}, "CVE-1999-0995": {"epss_score": 0.27904, "epss_percentile": 0.96294}, "CVE-1999-0996": {"epss_score": 0.05739, "epss_percentile": 0.90166}, "CVE-1999-0997": {"epss_score": 0.03822, "epss_percentile": 0.87787}, "CVE-1999-0998": {"epss_score": 0.00593, "epss_percentile": 0.6863}, "CVE-1999-0999": {"epss_score": 0.1557, "epss_percentile": 0.9446}, "CVE-1999-1000": {"epss_score": 0.00449, "epss_percentile": 0.63056}, "CVE-1999-1001": {"epss_score": 0.00316, "epss_percentile": 0.54287}, "CVE-1999-1002": {"epss_score": 0.00305, "epss_percentile": 0.53366}, "CVE-1999-1003": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1004": {"epss_score": 0.00694, "epss_percentile": 0.71361}, "CVE-1999-1005": {"epss_score": 0.01704, "epss_percentile": 0.81846}, "CVE-1999-1006": {"epss_score": 0.003, "epss_percentile": 0.52945}, "CVE-1999-1007": {"epss_score": 0.03956, "epss_percentile": 0.88006}, "CVE-1999-1008": {"epss_score": 0.00341, "epss_percentile": 0.5629}, "CVE-1999-1009": {"epss_score": 0.00351, "epss_percentile": 0.57016}, "CVE-1999-1010": {"epss_score": 0.00244, "epss_percentile": 0.47583}, "CVE-1999-1011": {"epss_score": 0.79296, "epss_percentile": 0.99029}, "CVE-1999-1012": {"epss_score": 0.0057, "epss_percentile": 0.6797}, "CVE-1999-1013": {"epss_score": 0.00055, "epss_percentile": 0.17582}, "CVE-1999-1014": {"epss_score": 0.00367, "epss_percentile": 0.58142}, "CVE-1999-1015": {"epss_score": 0.05315, "epss_percentile": 0.89722}, "CVE-1999-1016": {"epss_score": 0.08651, "epss_percentile": 0.92171}, "CVE-1999-1017": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-1999-1018": {"epss_score": 0.03226, "epss_percentile": 0.86685}, "CVE-1999-1019": {"epss_score": 0.00038, "epss_percentile": 0.11139}, "CVE-1999-1020": {"epss_score": 0.01659, "epss_percentile": 0.81612}, "CVE-1999-1021": {"epss_score": 0.00083, "epss_percentile": 0.24817}, "CVE-1999-1022": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-1999-1023": {"epss_score": 0.00069, "epss_percentile": 0.21466}, "CVE-1999-1024": {"epss_score": 0.07863, "epss_percentile": 0.91727}, "CVE-1999-1025": {"epss_score": 0.00074, "epss_percentile": 0.2281}, "CVE-1999-1026": {"epss_score": 0.00123, "epss_percentile": 0.32331}, "CVE-1999-1027": {"epss_score": 0.00038, "epss_percentile": 0.11139}, "CVE-1999-1028": {"epss_score": 0.08005, "epss_percentile": 0.91824}, "CVE-1999-1029": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-1999-1030": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-1999-1031": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-1999-1032": {"epss_score": 0.00381, "epss_percentile": 0.59011}, "CVE-1999-1033": {"epss_score": 0.08757, "epss_percentile": 0.92242}, "CVE-1999-1034": {"epss_score": 0.00085, "epss_percentile": 0.25111}, "CVE-1999-1035": {"epss_score": 0.18087, "epss_percentile": 0.94955}, "CVE-1999-1036": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-1037": {"epss_score": 0.00061, "epss_percentile": 0.19306}, "CVE-1999-1038": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-1039": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-1999-1040": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-1999-1041": {"epss_score": 0.00273, "epss_percentile": 0.50432}, "CVE-1999-1042": {"epss_score": 0.00211, "epss_percentile": 0.43704}, "CVE-1999-1043": {"epss_score": 0.06486, "epss_percentile": 0.90791}, "CVE-1999-1044": {"epss_score": 0.00046, "epss_percentile": 0.14283}, "CVE-1999-1045": {"epss_score": 0.01602, "epss_percentile": 0.81271}, "CVE-1999-1046": {"epss_score": 0.04563, "epss_percentile": 0.88855}, "CVE-1999-1047": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-1999-1048": {"epss_score": 0.00087, "epss_percentile": 0.25447}, "CVE-1999-1049": {"epss_score": 0.00456, "epss_percentile": 0.63321}, "CVE-1999-1050": {"epss_score": 0.04819, "epss_percentile": 0.89176}, "CVE-1999-1051": {"epss_score": 0.00763, "epss_percentile": 0.72882}, "CVE-1999-1052": {"epss_score": 0.3735, "epss_percentile": 0.97035}, "CVE-1999-1053": {"epss_score": 0.88552, "epss_percentile": 0.99477}, "CVE-1999-1054": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1055": {"epss_score": 0.07729, "epss_percentile": 0.91648}, "CVE-1999-1057": {"epss_score": 0.00209, "epss_percentile": 0.43321}, "CVE-1999-1058": {"epss_score": 0.01373, "epss_percentile": 0.7982}, "CVE-1999-1059": {"epss_score": 0.03179, "epss_percentile": 0.86576}, "CVE-1999-1060": {"epss_score": 0.03087, "epss_percentile": 0.86389}, "CVE-1999-1061": {"epss_score": 0.00604, "epss_percentile": 0.68958}, "CVE-1999-1062": {"epss_score": 0.00439, "epss_percentile": 0.62599}, "CVE-1999-1063": {"epss_score": 0.04425, "epss_percentile": 0.88674}, "CVE-1999-1064": {"epss_score": 0.00668, "epss_percentile": 0.70732}, "CVE-1999-1065": {"epss_score": 0.0083, "epss_percentile": 0.74031}, "CVE-1999-1066": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1067": {"epss_score": 0.00559, "epss_percentile": 0.67618}, "CVE-1999-1068": {"epss_score": 0.00469, "epss_percentile": 0.63939}, "CVE-1999-1069": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-1999-1070": {"epss_score": 0.00714, "epss_percentile": 0.71829}, "CVE-1999-1071": {"epss_score": 0.00048, "epss_percentile": 0.15137}, "CVE-1999-1072": {"epss_score": 0.0006, "epss_percentile": 0.19159}, "CVE-1999-1073": {"epss_score": 0.00067, "epss_percentile": 0.21112}, "CVE-1999-1074": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-1999-1075": {"epss_score": 0.0079, "epss_percentile": 0.73374}, "CVE-1999-1076": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-1999-1077": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-1999-1078": {"epss_score": 0.01011, "epss_percentile": 0.76616}, "CVE-1999-1079": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-1999-1080": {"epss_score": 0.00061, "epss_percentile": 0.19306}, "CVE-1999-1081": {"epss_score": 0.01771, "epss_percentile": 0.82197}, "CVE-1999-1082": {"epss_score": 0.03054, "epss_percentile": 0.86297}, "CVE-1999-1083": {"epss_score": 0.05035, "epss_percentile": 0.89419}, "CVE-1999-1084": {"epss_score": 0.00563, "epss_percentile": 0.67729}, "CVE-1999-1085": {"epss_score": 0.02954, "epss_percentile": 0.8606}, "CVE-1999-1086": {"epss_score": 0.01402, "epss_percentile": 0.80011}, "CVE-1999-1087": {"epss_score": 0.10203, "epss_percentile": 0.92891}, "CVE-1999-1088": {"epss_score": 0.00046, "epss_percentile": 0.14376}, "CVE-1999-1089": {"epss_score": 0.00055, "epss_percentile": 0.17468}, "CVE-1999-1090": {"epss_score": 0.00581, "epss_percentile": 0.68272}, "CVE-1999-1091": {"epss_score": 0.00522, "epss_percentile": 0.66282}, "CVE-1999-1092": {"epss_score": 0.00055, "epss_percentile": 0.17535}, "CVE-1999-1093": {"epss_score": 0.06267, "epss_percentile": 0.90625}, "CVE-1999-1094": {"epss_score": 0.06932, "epss_percentile": 0.91123}, "CVE-1999-1095": {"epss_score": 0.00064, "epss_percentile": 0.20431}, "CVE-1999-1096": {"epss_score": 0.00068, "epss_percentile": 0.21393}, "CVE-1999-1097": {"epss_score": 0.17466, "epss_percentile": 0.94853}, "CVE-1999-1098": {"epss_score": 0.01237, "epss_percentile": 0.78782}, "CVE-1999-1099": {"epss_score": 0.00814, "epss_percentile": 0.73777}, "CVE-1999-1100": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-1999-1101": {"epss_score": 0.00041, "epss_percentile": 0.12269}, "CVE-1999-1102": {"epss_score": 0.00121, "epss_percentile": 0.31947}, "CVE-1999-1103": {"epss_score": 0.00049, "epss_percentile": 0.15321}, "CVE-1999-1104": {"epss_score": 0.00567, "epss_percentile": 0.67846}, "CVE-1999-1105": {"epss_score": 0.48733, "epss_percentile": 0.97652}, "CVE-1999-1106": {"epss_score": 0.00184, "epss_percentile": 0.40404}, "CVE-1999-1107": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-1109": {"epss_score": 0.07749, "epss_percentile": 0.91657}, "CVE-1999-1110": {"epss_score": 0.21499, "epss_percentile": 0.95526}, "CVE-1999-1111": {"epss_score": 0.00719, "epss_percentile": 0.71948}, "CVE-1999-1112": {"epss_score": 0.0673, "epss_percentile": 0.90986}, "CVE-1999-1113": {"epss_score": 0.03958, "epss_percentile": 0.8801}, "CVE-1999-1114": {"epss_score": 0.00585, "epss_percentile": 0.68409}, "CVE-1999-1115": {"epss_score": 0.00933, "epss_percentile": 0.75639}, "CVE-1999-1116": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-1999-1117": {"epss_score": 0.00384, "epss_percentile": 0.59169}, "CVE-1999-1118": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-1999-1119": {"epss_score": 0.06936, "epss_percentile": 0.91128}, "CVE-1999-1120": {"epss_score": 0.0053, "epss_percentile": 0.66631}, "CVE-1999-1121": {"epss_score": 0.00704, "epss_percentile": 0.71562}, "CVE-1999-1122": {"epss_score": 0.00099, "epss_percentile": 0.2786}, "CVE-1999-1123": {"epss_score": 0.01101, "epss_percentile": 0.77573}, "CVE-1999-1124": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-1999-1125": {"epss_score": 0.00935, "epss_percentile": 0.75669}, "CVE-1999-1126": {"epss_score": 0.00085, "epss_percentile": 0.25156}, "CVE-1999-1127": {"epss_score": 0.3003, "epss_percentile": 0.96498}, "CVE-1999-1128": {"epss_score": 0.06077, "epss_percentile": 0.90458}, "CVE-1999-1129": {"epss_score": 0.00874, "epss_percentile": 0.74763}, "CVE-1999-1130": {"epss_score": 0.03779, "epss_percentile": 0.87717}, "CVE-1999-1131": {"epss_score": 0.00511, "epss_percentile": 0.65828}, "CVE-1999-1132": {"epss_score": 0.19456, "epss_percentile": 0.95185}, "CVE-1999-1133": {"epss_score": 0.00103, "epss_percentile": 0.28994}, "CVE-1999-1134": {"epss_score": 0.0005, "epss_percentile": 0.15727}, "CVE-1999-1135": {"epss_score": 0.0006, "epss_percentile": 0.19029}, "CVE-1999-1136": {"epss_score": 0.00126, "epss_percentile": 0.32744}, "CVE-1999-1137": {"epss_score": 0.00096, "epss_percentile": 0.27374}, "CVE-1999-1138": {"epss_score": 0.00534, "epss_percentile": 0.66788}, "CVE-1999-1139": {"epss_score": 0.00128, "epss_percentile": 0.32999}, "CVE-1999-1140": {"epss_score": 0.00122, "epss_percentile": 0.32026}, "CVE-1999-1141": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-1999-1142": {"epss_score": 0.00125, "epss_percentile": 0.32579}, "CVE-1999-1143": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-1999-1144": {"epss_score": 0.00035, "epss_percentile": 0.09984}, "CVE-1999-1145": {"epss_score": 0.0005, "epss_percentile": 0.15727}, "CVE-1999-1146": {"epss_score": 0.00046, "epss_percentile": 0.14376}, "CVE-1999-1147": {"epss_score": 0.0115, "epss_percentile": 0.78024}, "CVE-1999-1148": {"epss_score": 0.18087, "epss_percentile": 0.94955}, "CVE-1999-1149": {"epss_score": 0.00714, "epss_percentile": 0.71829}, "CVE-1999-1150": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-1999-1151": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1152": {"epss_score": 0.00717, "epss_percentile": 0.71892}, "CVE-1999-1153": {"epss_score": 0.02164, "epss_percentile": 0.83837}, "CVE-1999-1154": {"epss_score": 0.02795, "epss_percentile": 0.85679}, "CVE-1999-1155": {"epss_score": 0.02795, "epss_percentile": 0.85679}, "CVE-1999-1156": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1157": {"epss_score": 0.14459, "epss_percentile": 0.94216}, "CVE-1999-1158": {"epss_score": 0.00143, "epss_percentile": 0.35095}, "CVE-1999-1159": {"epss_score": 0.00064, "epss_percentile": 0.20366}, "CVE-1999-1160": {"epss_score": 0.0045, "epss_percentile": 0.63087}, "CVE-1999-1161": {"epss_score": 0.00047, "epss_percentile": 0.14656}, "CVE-1999-1162": {"epss_score": 0.00332, "epss_percentile": 0.55603}, "CVE-1999-1163": {"epss_score": 0.00509, "epss_percentile": 0.65747}, "CVE-1999-1164": {"epss_score": 0.06904, "epss_percentile": 0.91108}, "CVE-1999-1165": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-1999-1166": {"epss_score": 0.00161, "epss_percentile": 0.37553}, "CVE-1999-1167": {"epss_score": 0.00649, "epss_percentile": 0.70242}, "CVE-1999-1168": {"epss_score": 0.00045, "epss_percentile": 0.13957}, "CVE-1999-1169": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-1999-1170": {"epss_score": 2e-05, "epss_percentile": 0.00042}, "CVE-1999-1171": {"epss_score": 3e-05, "epss_percentile": 0.00093}, "CVE-1999-1172": {"epss_score": 0.00593, "epss_percentile": 0.6863}, "CVE-1999-1173": {"epss_score": 0.00135, "epss_percentile": 0.33971}, "CVE-1999-1174": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-1999-1175": {"epss_score": 0.00871, "epss_percentile": 0.74712}, "CVE-1999-1176": {"epss_score": 0.00068, "epss_percentile": 0.21393}, "CVE-1999-1177": {"epss_score": 0.0098, "epss_percentile": 0.7627}, "CVE-1999-1178": {"epss_score": 0.00763, "epss_percentile": 0.72882}, "CVE-1999-1179": {"epss_score": 0.0083, "epss_percentile": 0.74031}, "CVE-1999-1180": {"epss_score": 0.01552, "epss_percentile": 0.80994}, "CVE-1999-1181": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-1999-1182": {"epss_score": 0.00068, "epss_percentile": 0.21393}, "CVE-1999-1183": {"epss_score": 0.02124, "epss_percentile": 0.83689}, "CVE-1999-1184": {"epss_score": 0.00431, "epss_percentile": 0.62086}, "CVE-1999-1185": {"epss_score": 0.00239, "epss_percentile": 0.46929}, "CVE-1999-1186": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-1187": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-1999-1188": {"epss_score": 0.0012, "epss_percentile": 0.31741}, "CVE-1999-1189": {"epss_score": 0.02353, "epss_percentile": 0.84476}, "CVE-1999-1190": {"epss_score": 0.0485, "epss_percentile": 0.89214}, "CVE-1999-1191": {"epss_score": 0.00196, "epss_percentile": 0.41776}, "CVE-1999-1192": {"epss_score": 0.00053, "epss_percentile": 0.16821}, "CVE-1999-1193": {"epss_score": 0.0071, "epss_percentile": 0.71703}, "CVE-1999-1194": {"epss_score": 0.0012, "epss_percentile": 0.31772}, "CVE-1999-1195": {"epss_score": 0.00552, "epss_percentile": 0.67387}, "CVE-1999-1196": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-1999-1197": {"epss_score": 0.00537, "epss_percentile": 0.66896}, "CVE-1999-1198": {"epss_score": 0.00512, "epss_percentile": 0.65856}, "CVE-1999-1199": {"epss_score": 0.03629, "epss_percentile": 0.87471}, "CVE-1999-1200": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1201": {"epss_score": 0.19067, "epss_percentile": 0.95123}, "CVE-1999-1202": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1203": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-1999-1204": {"epss_score": 0.0057, "epss_percentile": 0.67942}, "CVE-1999-1205": {"epss_score": 0.00317, "epss_percentile": 0.54378}, "CVE-1999-1206": {"epss_score": 0.01636, "epss_percentile": 0.81474}, "CVE-1999-1207": {"epss_score": 0.0123, "epss_percentile": 0.78725}, "CVE-1999-1208": {"epss_score": 0.03775, "epss_percentile": 0.87708}, "CVE-1999-1209": {"epss_score": 0.00169, "epss_percentile": 0.386}, "CVE-1999-1210": {"epss_score": 0.00038, "epss_percentile": 0.11137}, "CVE-1999-1211": {"epss_score": 0.00085, "epss_percentile": 0.25191}, "CVE-1999-1212": {"epss_score": 0.00085, "epss_percentile": 0.25191}, "CVE-1999-1213": {"epss_score": 0.00678, "epss_percentile": 0.70983}, "CVE-1999-1214": {"epss_score": 0.00081, "epss_percentile": 0.24318}, "CVE-1999-1215": {"epss_score": 0.00047, "epss_percentile": 0.14707}, "CVE-1999-1216": {"epss_score": 0.00454, "epss_percentile": 0.63255}, "CVE-1999-1217": {"epss_score": 0.00959, "epss_percentile": 0.75958}, "CVE-1999-1218": {"epss_score": 0.00165, "epss_percentile": 0.38112}, "CVE-1999-1219": {"epss_score": 0.00212, "epss_percentile": 0.43788}, "CVE-1999-1220": {"epss_score": 0.01604, "epss_percentile": 0.81282}, "CVE-1999-1221": {"epss_score": 0.00071, "epss_percentile": 0.22044}, "CVE-1999-1222": {"epss_score": 0.09611, "epss_percentile": 0.92621}, "CVE-1999-1223": {"epss_score": 0.15527, "epss_percentile": 0.94452}, "CVE-1999-1224": {"epss_score": 0.00173, "epss_percentile": 0.39074}, "CVE-1999-1225": {"epss_score": 0.00499, "epss_percentile": 0.65282}, "CVE-1999-1226": {"epss_score": 0.00505, "epss_percentile": 0.656}, "CVE-1999-1227": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-1999-1228": {"epss_score": 0.00742, "epss_percentile": 0.72455}, "CVE-1999-1229": {"epss_score": 0.00062, "epss_percentile": 0.19784}, "CVE-1999-1230": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1231": {"epss_score": 0.00763, "epss_percentile": 0.72882}, "CVE-1999-1232": {"epss_score": 0.00096, "epss_percentile": 0.27305}, "CVE-1999-1233": {"epss_score": 0.10312, "epss_percentile": 0.92939}, "CVE-1999-1234": {"epss_score": 0.15287, "epss_percentile": 0.94401}, "CVE-1999-1235": {"epss_score": 0.00345, "epss_percentile": 0.5656}, "CVE-1999-1236": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-1999-1237": {"epss_score": 0.00572, "epss_percentile": 0.68008}, "CVE-1999-1238": {"epss_score": 0.00086, "epss_percentile": 0.25376}, "CVE-1999-1239": {"epss_score": 0.00104, "epss_percentile": 0.29202}, "CVE-1999-1240": {"epss_score": 0.01316, "epss_percentile": 0.79406}, "CVE-1999-1241": {"epss_score": 0.30276, "epss_percentile": 0.96524}, "CVE-1999-1242": {"epss_score": 0.00235, "epss_percentile": 0.46242}, "CVE-1999-1243": {"epss_score": 0.00659, "epss_percentile": 0.705}, "CVE-1999-1244": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-1999-1245": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-1999-1246": {"epss_score": 0.00915, "epss_percentile": 0.75399}, "CVE-1999-1247": {"epss_score": 0.00067, "epss_percentile": 0.21137}, "CVE-1999-1248": {"epss_score": 0.00086, "epss_percentile": 0.25376}, "CVE-1999-1249": {"epss_score": 0.0007, "epss_percentile": 0.21802}, "CVE-1999-1250": {"epss_score": 0.00559, "epss_percentile": 0.67618}, "CVE-1999-1251": {"epss_score": 0.00082, "epss_percentile": 0.24468}, "CVE-1999-1252": {"epss_score": 0.00169, "epss_percentile": 0.386}, "CVE-1999-1253": {"epss_score": 0.00169, "epss_percentile": 0.386}, "CVE-1999-1254": {"epss_score": 0.09089, "epss_percentile": 0.92397}, "CVE-1999-1255": {"epss_score": 0.00429, "epss_percentile": 0.61999}, "CVE-1999-1256": {"epss_score": 0.00265, "epss_percentile": 0.498}, "CVE-1999-1257": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-1999-1258": {"epss_score": 0.00814, "epss_percentile": 0.73777}, "CVE-1999-1259": {"epss_score": 0.01934, "epss_percentile": 0.82953}, "CVE-1999-1260": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-1999-1261": {"epss_score": 0.00751, "epss_percentile": 0.72644}, "CVE-1999-1262": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-1999-1263": {"epss_score": 0.00316, "epss_percentile": 0.54287}, "CVE-1999-1264": {"epss_score": 0.00552, "epss_percentile": 0.67387}, "CVE-1999-1265": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-1999-1266": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-1999-1267": {"epss_score": 0.00429, "epss_percentile": 0.61999}, "CVE-1999-1268": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-1269": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-1999-1270": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-1999-1271": {"epss_score": 0.00012, "epss_percentile": 0.01246}, "CVE-1999-1272": {"epss_score": 0.00049, "epss_percentile": 0.15455}, "CVE-1999-1273": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-1999-1274": {"epss_score": 0.00368, "epss_percentile": 0.58218}, "CVE-1999-1275": {"epss_score": 0.00046, "epss_percentile": 0.14328}, "CVE-1999-1276": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-1999-1277": {"epss_score": 0.00078, "epss_percentile": 0.23579}, "CVE-1999-1278": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-1999-1279": {"epss_score": 0.13585, "epss_percentile": 0.94003}, "CVE-1999-1280": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-1999-1281": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1282": {"epss_score": 0.0011, "epss_percentile": 0.30152}, "CVE-1999-1283": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1284": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-1999-1285": {"epss_score": 0.00075, "epss_percentile": 0.22996}, "CVE-1999-1286": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-1999-1287": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-1999-1288": {"epss_score": 0.0007, "epss_percentile": 0.21724}, "CVE-1999-1289": {"epss_score": 0.01244, "epss_percentile": 0.78838}, "CVE-1999-1290": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-1999-1291": {"epss_score": 0.08554, "epss_percentile": 0.92121}, "CVE-1999-1292": {"epss_score": 0.01762, "epss_percentile": 0.82153}, "CVE-1999-1293": {"epss_score": 0.01342, "epss_percentile": 0.79595}, "CVE-1999-1294": {"epss_score": 0.00641, "epss_percentile": 0.69978}, "CVE-1999-1295": {"epss_score": 0.00073, "epss_percentile": 0.22627}, "CVE-1999-1296": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-1297": {"epss_score": 0.0013, "epss_percentile": 0.33284}, "CVE-1999-1298": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-1999-1299": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-1999-1300": {"epss_score": 0.00089, "epss_percentile": 0.25893}, "CVE-1999-1301": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-1999-1302": {"epss_score": 0.00082, "epss_percentile": 0.245}, "CVE-1999-1303": {"epss_score": 0.00081, "epss_percentile": 0.24218}, "CVE-1999-1304": {"epss_score": 0.00081, "epss_percentile": 0.24218}, "CVE-1999-1305": {"epss_score": 0.00081, "epss_percentile": 0.24218}, "CVE-1999-1306": {"epss_score": 0.00179, "epss_percentile": 0.39807}, "CVE-1999-1307": {"epss_score": 0.0003, "epss_percentile": 0.08031}, "CVE-1999-1308": {"epss_score": 0.00111, "epss_percentile": 0.3028}, "CVE-1999-1309": {"epss_score": 0.00116, "epss_percentile": 0.31085}, "CVE-1999-1311": {"epss_score": 0.00114, "epss_percentile": 0.30828}, "CVE-1999-1312": {"epss_score": 0.00085, "epss_percentile": 0.25191}, "CVE-1999-1313": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-1999-1314": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-1999-1315": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-1999-1316": {"epss_score": 0.0678, "epss_percentile": 0.91022}, "CVE-1999-1317": {"epss_score": 0.00781, "epss_percentile": 0.73186}, "CVE-1999-1318": {"epss_score": 0.0006, "epss_percentile": 0.18979}, "CVE-1999-1319": {"epss_score": 0.00702, "epss_percentile": 0.71524}, "CVE-1999-1320": {"epss_score": 0.0003, "epss_percentile": 0.08012}, "CVE-1999-1321": {"epss_score": 0.00986, "epss_percentile": 0.76334}, "CVE-1999-1322": {"epss_score": 0.00599, "epss_percentile": 0.68797}, "CVE-1999-1323": {"epss_score": 0.00102, "epss_percentile": 0.28811}, "CVE-1999-1324": {"epss_score": 0.00747, "epss_percentile": 0.72563}, "CVE-1999-1325": {"epss_score": 0.00035, "epss_percentile": 0.09968}, "CVE-1999-1326": {"epss_score": 0.00919, "epss_percentile": 0.75453}, "CVE-1999-1327": {"epss_score": 0.00064, "epss_percentile": 0.20394}, "CVE-1999-1328": {"epss_score": 0.00061, "epss_percentile": 0.19306}, "CVE-1999-1329": {"epss_score": 0.00175, "epss_percentile": 0.3932}, "CVE-1999-1330": {"epss_score": 0.00239, "epss_percentile": 0.4692}, "CVE-1999-1331": {"epss_score": 0.00173, "epss_percentile": 0.39074}, "CVE-1999-1332": {"epss_score": 0.00155, "epss_percentile": 0.36778}, "CVE-1999-1333": {"epss_score": 0.01232, "epss_percentile": 0.78738}, "CVE-1999-1334": {"epss_score": 0.00918, "epss_percentile": 0.75438}, "CVE-1999-1335": {"epss_score": 0.00515, "epss_percentile": 0.66}, "CVE-1999-1336": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-1999-1337": {"epss_score": 0.00079, "epss_percentile": 0.23838}, "CVE-1999-1338": {"epss_score": 0.00448, "epss_percentile": 0.63018}, "CVE-1999-1339": {"epss_score": 0.01108, "epss_percentile": 0.77636}, "CVE-1999-1340": {"epss_score": 0.00126, "epss_percentile": 0.32643}, "CVE-1999-1341": {"epss_score": 0.00113, "epss_percentile": 0.30653}, "CVE-1999-1342": {"epss_score": 0.00975, "epss_percentile": 0.76198}, "CVE-1999-1343": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1344": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-1345": {"epss_score": 0.00055, "epss_percentile": 0.17535}, "CVE-1999-1346": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-1347": {"epss_score": 0.00086, "epss_percentile": 0.25417}, "CVE-1999-1348": {"epss_score": 0.00075, "epss_percentile": 0.22996}, "CVE-1999-1349": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1350": {"epss_score": 0.00055, "epss_percentile": 0.17535}, "CVE-1999-1351": {"epss_score": 0.01101, "epss_percentile": 0.77576}, "CVE-1999-1352": {"epss_score": 0.00181, "epss_percentile": 0.40026}, "CVE-1999-1353": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-1999-1354": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-1999-1355": {"epss_score": 0.00743, "epss_percentile": 0.72481}, "CVE-1999-1356": {"epss_score": 0.00091, "epss_percentile": 0.26388}, "CVE-1999-1357": {"epss_score": 0.01244, "epss_percentile": 0.78838}, "CVE-1999-1358": {"epss_score": 0.00167, "epss_percentile": 0.38358}, "CVE-1999-1359": {"epss_score": 0.06691, "epss_percentile": 0.9095}, "CVE-1999-1360": {"epss_score": 0.00372, "epss_percentile": 0.58448}, "CVE-1999-1361": {"epss_score": 0.05238, "epss_percentile": 0.8965}, "CVE-1999-1362": {"epss_score": 0.00244, "epss_percentile": 0.47613}, "CVE-1999-1363": {"epss_score": 0.00372, "epss_percentile": 0.58448}, "CVE-1999-1364": {"epss_score": 0.00372, "epss_percentile": 0.58448}, "CVE-1999-1365": {"epss_score": 0.0307, "epss_percentile": 0.86345}, "CVE-1999-1366": {"epss_score": 0.00063, "epss_percentile": 0.19848}, "CVE-1999-1367": {"epss_score": 0.00305, "epss_percentile": 0.53338}, "CVE-1999-1368": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-1369": {"epss_score": 0.00131, "epss_percentile": 0.33479}, "CVE-1999-1370": {"epss_score": 0.00585, "epss_percentile": 0.68411}, "CVE-1999-1371": {"epss_score": 0.00138, "epss_percentile": 0.34425}, "CVE-1999-1372": {"epss_score": 0.00073, "epss_percentile": 0.22673}, "CVE-1999-1373": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1374": {"epss_score": 0.00559, "epss_percentile": 0.67618}, "CVE-1999-1375": {"epss_score": 0.73172, "epss_percentile": 0.9874}, "CVE-1999-1376": {"epss_score": 0.47296, "epss_percentile": 0.97581}, "CVE-1999-1377": {"epss_score": 0.00763, "epss_percentile": 0.72882}, "CVE-1999-1378": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-1999-1379": {"epss_score": 0.0115, "epss_percentile": 0.78029}, "CVE-1999-1380": {"epss_score": 0.01376, "epss_percentile": 0.79837}, "CVE-1999-1381": {"epss_score": 0.00972, "epss_percentile": 0.76141}, "CVE-1999-1382": {"epss_score": 0.00228, "epss_percentile": 0.45464}, "CVE-1999-1383": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-1999-1384": {"epss_score": 0.00741, "epss_percentile": 0.72414}, "CVE-1999-1385": {"epss_score": 0.0005, "epss_percentile": 0.15721}, "CVE-1999-1386": {"epss_score": 0.00163, "epss_percentile": 0.37822}, "CVE-1999-1387": {"epss_score": 0.09831, "epss_percentile": 0.92723}, "CVE-1999-1388": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-1999-1389": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-1999-1390": {"epss_score": 0.0038, "epss_percentile": 0.58939}, "CVE-1999-1391": {"epss_score": 0.00394, "epss_percentile": 0.59793}, "CVE-1999-1392": {"epss_score": 0.00509, "epss_percentile": 0.65719}, "CVE-1999-1393": {"epss_score": 0.00095, "epss_percentile": 0.27116}, "CVE-1999-1394": {"epss_score": 0.00904, "epss_percentile": 0.75213}, "CVE-1999-1395": {"epss_score": 0.02073, "epss_percentile": 0.83493}, "CVE-1999-1396": {"epss_score": 0.00709, "epss_percentile": 0.71697}, "CVE-1999-1397": {"epss_score": 0.0265, "epss_percentile": 0.85343}, "CVE-1999-1398": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-1999-1399": {"epss_score": 0.0038, "epss_percentile": 0.58939}, "CVE-1999-1400": {"epss_score": 0.00115, "epss_percentile": 0.30975}, "CVE-1999-1401": {"epss_score": 0.00058, "epss_percentile": 0.18396}, "CVE-1999-1402": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-1999-1403": {"epss_score": 0.00037, "epss_percentile": 0.10904}, "CVE-1999-1404": {"epss_score": 0.0079, "epss_percentile": 0.73374}, "CVE-1999-1405": {"epss_score": 0.07478, "epss_percentile": 0.91494}, "CVE-1999-1406": {"epss_score": 0.00081, "epss_percentile": 0.24318}, "CVE-1999-1407": {"epss_score": 0.0032, "epss_percentile": 0.54623}, "CVE-1999-1408": {"epss_score": 0.01325, "epss_percentile": 0.7947}, "CVE-1999-1409": {"epss_score": 0.00595, "epss_percentile": 0.68684}, "CVE-1999-1410": {"epss_score": 0.00913, "epss_percentile": 0.75368}, "CVE-1999-1411": {"epss_score": 0.00749, "epss_percentile": 0.72596}, "CVE-1999-1412": {"epss_score": 0.13812, "epss_percentile": 0.94064}, "CVE-1999-1413": {"epss_score": 0.00155, "epss_percentile": 0.36783}, "CVE-1999-1414": {"epss_score": 0.01229, "epss_percentile": 0.78711}, "CVE-1999-1415": {"epss_score": 0.00041, "epss_percentile": 0.12368}, "CVE-1999-1416": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-1999-1417": {"epss_score": 0.01129, "epss_percentile": 0.77836}, "CVE-1999-1418": {"epss_score": 0.008, "epss_percentile": 0.73535}, "CVE-1999-1419": {"epss_score": 0.00053, "epss_percentile": 0.16821}, "CVE-1999-1420": {"epss_score": 0.01639, "epss_percentile": 0.8149}, "CVE-1999-1421": {"epss_score": 0.01129, "epss_percentile": 0.77839}, "CVE-1999-1422": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-1423": {"epss_score": 0.00331, "epss_percentile": 0.5554}, "CVE-1999-1424": {"epss_score": 0.0003, "epss_percentile": 0.08303}, "CVE-1999-1425": {"epss_score": 0.0003, "epss_percentile": 0.08303}, "CVE-1999-1426": {"epss_score": 0.0004, "epss_percentile": 0.12091}, "CVE-1999-1427": {"epss_score": 0.0004, "epss_percentile": 0.12091}, "CVE-1999-1428": {"epss_score": 0.0004, "epss_percentile": 0.12091}, "CVE-1999-1429": {"epss_score": 0.00085, "epss_percentile": 0.25093}, "CVE-1999-1430": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-1999-1431": {"epss_score": 0.0171, "epss_percentile": 0.81872}, "CVE-1999-1432": {"epss_score": 0.03047, "epss_percentile": 0.86284}, "CVE-1999-1433": {"epss_score": 0.006, "epss_percentile": 0.68827}, "CVE-1999-1434": {"epss_score": 0.0038, "epss_percentile": 0.58939}, "CVE-1999-1435": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-1999-1436": {"epss_score": 0.05383, "epss_percentile": 0.89816}, "CVE-1999-1437": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-1999-1438": {"epss_score": 0.00097, "epss_percentile": 0.27496}, "CVE-1999-1439": {"epss_score": 0.00125, "epss_percentile": 0.32569}, "CVE-1999-1440": {"epss_score": 0.00744, "epss_percentile": 0.72509}, "CVE-1999-1441": {"epss_score": 0.00403, "epss_percentile": 0.60362}, "CVE-1999-1442": {"epss_score": 0.00416, "epss_percentile": 0.61201}, "CVE-1999-1443": {"epss_score": 0.00079, "epss_percentile": 0.23838}, "CVE-1999-1444": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-1445": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-1999-1446": {"epss_score": 0.00755, "epss_percentile": 0.72719}, "CVE-1999-1447": {"epss_score": 0.15287, "epss_percentile": 0.94401}, "CVE-1999-1448": {"epss_score": 0.00573, "epss_percentile": 0.68051}, "CVE-1999-1449": {"epss_score": 0.00051, "epss_percentile": 0.15986}, "CVE-1999-1450": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-1999-1451": {"epss_score": 0.35589, "epss_percentile": 0.96921}, "CVE-1999-1452": {"epss_score": 0.03171, "epss_percentile": 0.86548}, "CVE-1999-1453": {"epss_score": 0.43372, "epss_percentile": 0.97383}, "CVE-1999-1454": {"epss_score": 0.00018, "epss_percentile": 0.04026}, "CVE-1999-1455": {"epss_score": 0.0678, "epss_percentile": 0.91022}, "CVE-1999-1456": {"epss_score": 0.01083, "epss_percentile": 0.77392}, "CVE-1999-1457": {"epss_score": 0.01109, "epss_percentile": 0.77648}, "CVE-1999-1458": {"epss_score": 0.00033, "epss_percentile": 0.09398}, "CVE-1999-1459": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-1999-1460": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-1999-1461": {"epss_score": 0.00913, "epss_percentile": 0.75368}, "CVE-1999-1462": {"epss_score": 0.01133, "epss_percentile": 0.77879}, "CVE-1999-1463": {"epss_score": 0.03994, "epss_percentile": 0.88082}, "CVE-1999-1464": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-1999-1465": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-1999-1466": {"epss_score": 0.00296, "epss_percentile": 0.52579}, "CVE-1999-1467": {"epss_score": 0.03168, "epss_percentile": 0.86543}, "CVE-1999-1468": {"epss_score": 0.00085, "epss_percentile": 0.25111}, "CVE-1999-1469": {"epss_score": 0.00972, "epss_percentile": 0.76141}, "CVE-1999-1470": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-1999-1471": {"epss_score": 0.00849, "epss_percentile": 0.74377}, "CVE-1999-1472": {"epss_score": 0.17722, "epss_percentile": 0.94896}, "CVE-1999-1473": {"epss_score": 0.16137, "epss_percentile": 0.94578}, "CVE-1999-1474": {"epss_score": 0.07387, "epss_percentile": 0.91446}, "CVE-1999-1475": {"epss_score": 0.001, "epss_percentile": 0.28444}, "CVE-1999-1476": {"epss_score": 0.00058, "epss_percentile": 0.18446}, "CVE-1999-1477": {"epss_score": 0.0033, "epss_percentile": 0.55452}, "CVE-1999-1478": {"epss_score": 0.20487, "epss_percentile": 0.95354}, "CVE-1999-1479": {"epss_score": 0.03931, "epss_percentile": 0.87974}, "CVE-1999-1480": {"epss_score": 0.00083, "epss_percentile": 0.24603}, "CVE-1999-1481": {"epss_score": 0.05758, "epss_percentile": 0.90181}, "CVE-1999-1482": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-1999-1483": {"epss_score": 0.00517, "epss_percentile": 0.66082}, "CVE-1999-1484": {"epss_score": 0.08053, "epss_percentile": 0.91856}, "CVE-1999-1485": {"epss_score": 0.07955, "epss_percentile": 0.91787}, "CVE-1999-1486": {"epss_score": 0.00088, "epss_percentile": 0.25745}, "CVE-1999-1487": {"epss_score": 0.00161, "epss_percentile": 0.37577}, "CVE-1999-1488": {"epss_score": 0.06312, "epss_percentile": 0.90664}, "CVE-1999-1489": {"epss_score": 0.00288, "epss_percentile": 0.51912}, "CVE-1999-1490": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-1999-1491": {"epss_score": 0.00344, "epss_percentile": 0.56492}, "CVE-1999-1492": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-1999-1493": {"epss_score": 0.01057, "epss_percentile": 0.77136}, "CVE-1999-1494": {"epss_score": 0.00666, "epss_percentile": 0.70696}, "CVE-1999-1495": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-1999-1496": {"epss_score": 0.00089, "epss_percentile": 0.25937}, "CVE-1999-1497": {"epss_score": 0.00215, "epss_percentile": 0.44036}, "CVE-1999-1498": {"epss_score": 0.00362, "epss_percentile": 0.57776}, "CVE-1999-1499": {"epss_score": 0.00538, "epss_percentile": 0.66928}, "CVE-1999-1500": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-1999-1501": {"epss_score": 0.00074, "epss_percentile": 0.22718}, "CVE-1999-1502": {"epss_score": 0.00969, "epss_percentile": 0.76099}, "CVE-1999-1503": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-1999-1504": {"epss_score": 0.05302, "epss_percentile": 0.89707}, "CVE-1999-1505": {"epss_score": 0.01226, "epss_percentile": 0.78689}, "CVE-1999-1506": {"epss_score": 0.00676, "epss_percentile": 0.70915}, "CVE-1999-1507": {"epss_score": 0.00073, "epss_percentile": 0.22598}, "CVE-1999-1508": {"epss_score": 0.02856, "epss_percentile": 0.85841}, "CVE-1999-1509": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-1999-1510": {"epss_score": 0.82522, "epss_percentile": 0.99198}, "CVE-1999-1511": {"epss_score": 0.01753, "epss_percentile": 0.82112}, "CVE-1999-1512": {"epss_score": 0.02772, "epss_percentile": 0.85623}, "CVE-1999-1513": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-1999-1514": {"epss_score": 0.01667, "epss_percentile": 0.81654}, "CVE-1999-1515": {"epss_score": 0.03205, "epss_percentile": 0.8663}, "CVE-1999-1516": {"epss_score": 0.01039, "epss_percentile": 0.76945}, "CVE-1999-1517": {"epss_score": 0.00052, "epss_percentile": 0.16474}, "CVE-1999-1518": {"epss_score": 0.02159, "epss_percentile": 0.8382}, "CVE-1999-1519": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-1999-1520": {"epss_score": 0.37127, "epss_percentile": 0.97021}, "CVE-1999-1521": {"epss_score": 0.06536, "epss_percentile": 0.90828}, "CVE-1999-1522": {"epss_score": 0.00578, "epss_percentile": 0.68198}, "CVE-1999-1523": {"epss_score": 0.01335, "epss_percentile": 0.79551}, "CVE-1999-1524": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-1999-1525": {"epss_score": 0.00127, "epss_percentile": 0.32842}, "CVE-1999-1526": {"epss_score": 0.00114, "epss_percentile": 0.30802}, "CVE-1999-1527": {"epss_score": 0.00763, "epss_percentile": 0.72859}, "CVE-1999-1528": {"epss_score": 0.00069, "epss_percentile": 0.21466}, "CVE-1999-1529": {"epss_score": 0.15019, "epss_percentile": 0.94344}, "CVE-1999-1530": {"epss_score": 0.00131, "epss_percentile": 0.33384}, "CVE-1999-1531": {"epss_score": 0.04622, "epss_percentile": 0.88935}, "CVE-1999-1532": {"epss_score": 0.04021, "epss_percentile": 0.88133}, "CVE-1999-1533": {"epss_score": 0.0977, "epss_percentile": 0.92695}, "CVE-1999-1534": {"epss_score": 0.00126, "epss_percentile": 0.32643}, "CVE-1999-1535": {"epss_score": 0.01806, "epss_percentile": 0.82351}, "CVE-1999-1536": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-1999-1537": {"epss_score": 0.01285, "epss_percentile": 0.79175}, "CVE-1999-1538": {"epss_score": 0.50259, "epss_percentile": 0.97729}, "CVE-1999-1539": {"epss_score": 0.15111, "epss_percentile": 0.94366}, "CVE-1999-1540": {"epss_score": 0.00071, "epss_percentile": 0.22039}, "CVE-1999-1541": {"epss_score": 0.00064, "epss_percentile": 0.20431}, "CVE-1999-1542": {"epss_score": 0.02323, "epss_percentile": 0.84377}, "CVE-1999-1543": {"epss_score": 0.00314, "epss_percentile": 0.54117}, "CVE-1999-1544": {"epss_score": 0.06818, "epss_percentile": 0.91045}, "CVE-1999-1545": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-1999-1546": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-1999-1547": {"epss_score": 0.00635, "epss_percentile": 0.69812}, "CVE-1999-1548": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-1999-1549": {"epss_score": 0.0021, "epss_percentile": 0.43498}, "CVE-1999-1550": {"epss_score": 0.02956, "epss_percentile": 0.86063}, "CVE-1999-1551": {"epss_score": 0.42937, "epss_percentile": 0.97363}, "CVE-1999-1552": {"epss_score": 0.00149, "epss_percentile": 0.36016}, "CVE-1999-1553": {"epss_score": 0.09203, "epss_percentile": 0.92447}, "CVE-1999-1554": {"epss_score": 0.00902, "epss_percentile": 0.75196}, "CVE-1999-1555": {"epss_score": 0.00106, "epss_percentile": 0.2944}, "CVE-1999-1556": {"epss_score": 0.00663, "epss_percentile": 0.70618}, "CVE-1999-1557": {"epss_score": 0.23669, "epss_percentile": 0.95801}, "CVE-1999-1558": {"epss_score": 0.00462, "epss_percentile": 0.63588}, "CVE-1999-1559": {"epss_score": 0.00284, "epss_percentile": 0.51498}, "CVE-1999-1560": {"epss_score": 0.00079, "epss_percentile": 0.23892}, "CVE-1999-1561": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-1999-1562": {"epss_score": 0.00074, "epss_percentile": 0.2281}, "CVE-1999-1563": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-1999-1564": {"epss_score": 0.00058, "epss_percentile": 0.18446}, "CVE-1999-1565": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-1999-1566": {"epss_score": 0.03339, "epss_percentile": 0.8694}, "CVE-1999-1567": {"epss_score": 0.00651, "epss_percentile": 0.70301}, "CVE-1999-1568": {"epss_score": 0.01684, "epss_percentile": 0.81741}, "CVE-1999-1569": {"epss_score": 0.0199, "epss_percentile": 0.83174}, "CVE-1999-1570": {"epss_score": 0.00145, "epss_percentile": 0.35449}, "CVE-1999-1571": {"epss_score": 0.00136, "epss_percentile": 0.34096}, "CVE-1999-1572": {"epss_score": 0.00139, "epss_percentile": 0.34627}, "CVE-1999-1573": {"epss_score": 0.00918, "epss_percentile": 0.7544}, "CVE-1999-1574": {"epss_score": 0.02705, "epss_percentile": 0.85466}, "CVE-1999-1575": {"epss_score": 0.22559, "epss_percentile": 0.95651}, "CVE-1999-1576": {"epss_score": 0.44692, "epss_percentile": 0.97449}, "CVE-1999-1577": {"epss_score": 0.34943, "epss_percentile": 0.96878}, "CVE-1999-1578": {"epss_score": 0.31862, "epss_percentile": 0.96655}, "CVE-1999-1579": {"epss_score": 0.27095, "epss_percentile": 0.96207}, "CVE-1999-1580": {"epss_score": 0.00778, "epss_percentile": 0.73123}, "CVE-1999-1581": {"epss_score": 0.29447, "epss_percentile": 0.96444}, "CVE-1999-1582": {"epss_score": 0.01887, "epss_percentile": 0.82716}, "CVE-1999-1583": {"epss_score": 0.00389, "epss_percentile": 0.59492}, "CVE-1999-1584": {"epss_score": 0.00477, "epss_percentile": 0.64345}, "CVE-1999-1585": {"epss_score": 0.00052, "epss_percentile": 0.16474}, "CVE-1999-1586": {"epss_score": 0.00075, "epss_percentile": 0.22981}, "CVE-1999-1587": {"epss_score": 0.00642, "epss_percentile": 0.70021}, "CVE-1999-1588": {"epss_score": 0.22453, "epss_percentile": 0.95635}, "CVE-1999-1589": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-1999-1590": {"epss_score": 0.002, "epss_percentile": 0.4222}, "CVE-1999-1591": {"epss_score": 0.10201, "epss_percentile": 0.9289}, "CVE-1999-1592": {"epss_score": 0.00323, "epss_percentile": 0.54902}, "CVE-1999-1593": {"epss_score": 0.042, "epss_percentile": 0.88387}, "CVE-2000-0001": {"epss_score": 0.03927, "epss_percentile": 0.87967}, "CVE-2000-0002": {"epss_score": 0.09288, "epss_percentile": 0.92485}, "CVE-2000-0003": {"epss_score": 0.00605, "epss_percentile": 0.68968}, "CVE-2000-0004": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-2000-0005": {"epss_score": 0.0006, "epss_percentile": 0.19029}, "CVE-2000-0006": {"epss_score": 0.00178, "epss_percentile": 0.39706}, "CVE-2000-0007": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0008": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-2000-0009": {"epss_score": 0.00132, "epss_percentile": 0.3354}, "CVE-2000-0010": {"epss_score": 0.0517, "epss_percentile": 0.89569}, "CVE-2000-0011": {"epss_score": 0.05771, "epss_percentile": 0.90193}, "CVE-2000-0012": {"epss_score": 0.04575, "epss_percentile": 0.88868}, "CVE-2000-0013": {"epss_score": 0.0038, "epss_percentile": 0.58939}, "CVE-2000-0014": {"epss_score": 0.03801, "epss_percentile": 0.87744}, "CVE-2000-0015": {"epss_score": 0.00154, "epss_percentile": 0.36754}, "CVE-2000-0016": {"epss_score": 0.05354, "epss_percentile": 0.89776}, "CVE-2000-0017": {"epss_score": 0.03362, "epss_percentile": 0.86994}, "CVE-2000-0018": {"epss_score": 0.0038, "epss_percentile": 0.58939}, "CVE-2000-0019": {"epss_score": 0.00023, "epss_percentile": 0.05413}, "CVE-2000-0020": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0021": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-2000-0022": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-2000-0023": {"epss_score": 0.00714, "epss_percentile": 0.71829}, "CVE-2000-0024": {"epss_score": 0.12045, "epss_percentile": 0.93554}, "CVE-2000-0025": {"epss_score": 0.46048, "epss_percentile": 0.97519}, "CVE-2000-0026": {"epss_score": 0.03569, "epss_percentile": 0.87368}, "CVE-2000-0027": {"epss_score": 0.01681, "epss_percentile": 0.81727}, "CVE-2000-0028": {"epss_score": 0.21836, "epss_percentile": 0.95565}, "CVE-2000-0029": {"epss_score": 0.00098, "epss_percentile": 0.27804}, "CVE-2000-0030": {"epss_score": 0.00441, "epss_percentile": 0.6268}, "CVE-2000-0031": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-2000-0032": {"epss_score": 0.01021, "epss_percentile": 0.76752}, "CVE-2000-0033": {"epss_score": 0.00593, "epss_percentile": 0.6863}, "CVE-2000-0034": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-2000-0035": {"epss_score": 0.00279, "epss_percentile": 0.50978}, "CVE-2000-0036": {"epss_score": 0.19714, "epss_percentile": 0.9523}, "CVE-2000-0037": {"epss_score": 0.00227, "epss_percentile": 0.45395}, "CVE-2000-0038": {"epss_score": 0.02979, "epss_percentile": 0.86115}, "CVE-2000-0039": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-2000-0040": {"epss_score": 0.00409, "epss_percentile": 0.60735}, "CVE-2000-0041": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-2000-0042": {"epss_score": 0.01699, "epss_percentile": 0.81822}, "CVE-2000-0043": {"epss_score": 0.04873, "epss_percentile": 0.89233}, "CVE-2000-0044": {"epss_score": 0.0178, "epss_percentile": 0.82234}, "CVE-2000-0045": {"epss_score": 0.0209, "epss_percentile": 0.83566}, "CVE-2000-0046": {"epss_score": 0.04729, "epss_percentile": 0.89067}, "CVE-2000-0047": {"epss_score": 0.00714, "epss_percentile": 0.71829}, "CVE-2000-0048": {"epss_score": 0.00355, "epss_percentile": 0.57268}, "CVE-2000-0049": {"epss_score": 0.00746, "epss_percentile": 0.72533}, "CVE-2000-0050": {"epss_score": 0.00069, "epss_percentile": 0.21466}, "CVE-2000-0051": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0052": {"epss_score": 0.003, "epss_percentile": 0.52972}, "CVE-2000-0053": {"epss_score": 0.14197, "epss_percentile": 0.94161}, "CVE-2000-0054": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-2000-0055": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-2000-0056": {"epss_score": 0.01134, "epss_percentile": 0.77885}, "CVE-2000-0057": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2000-0058": {"epss_score": 0.00799, "epss_percentile": 0.73519}, "CVE-2000-0059": {"epss_score": 0.02674, "epss_percentile": 0.85398}, "CVE-2000-0060": {"epss_score": 0.01011, "epss_percentile": 0.76617}, "CVE-2000-0061": {"epss_score": 0.16189, "epss_percentile": 0.94591}, "CVE-2000-0062": {"epss_score": 0.0092, "epss_percentile": 0.75475}, "CVE-2000-0063": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-2000-0064": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0065": {"epss_score": 0.04512, "epss_percentile": 0.88781}, "CVE-2000-0066": {"epss_score": 0.00559, "epss_percentile": 0.67618}, "CVE-2000-0067": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-2000-0068": {"epss_score": 0.0052, "epss_percentile": 0.66198}, "CVE-2000-0069": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-2000-0070": {"epss_score": 0.01781, "epss_percentile": 0.82241}, "CVE-2000-0071": {"epss_score": 0.7142, "epss_percentile": 0.98667}, "CVE-2000-0072": {"epss_score": 0.00187, "epss_percentile": 0.4072}, "CVE-2000-0073": {"epss_score": 0.34322, "epss_percentile": 0.96842}, "CVE-2000-0074": {"epss_score": 0.05523, "epss_percentile": 0.89959}, "CVE-2000-0075": {"epss_score": 0.04014, "epss_percentile": 0.8812}, "CVE-2000-0076": {"epss_score": 0.00099, "epss_percentile": 0.28368}, "CVE-2000-0077": {"epss_score": 0.00761, "epss_percentile": 0.72827}, "CVE-2000-0078": {"epss_score": 0.0006, "epss_percentile": 0.19029}, "CVE-2000-0079": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2000-0080": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2000-0081": {"epss_score": 0.29293, "epss_percentile": 0.9643}, "CVE-2000-0082": {"epss_score": 0.36563, "epss_percentile": 0.96987}, "CVE-2000-0083": {"epss_score": 0.00078, "epss_percentile": 0.23601}, "CVE-2000-0084": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2000-0085": {"epss_score": 0.12036, "epss_percentile": 0.93552}, "CVE-2000-0086": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-2000-0087": {"epss_score": 0.00814, "epss_percentile": 0.73777}, "CVE-2000-0088": {"epss_score": 0.00513, "epss_percentile": 0.65924}, "CVE-2000-0089": {"epss_score": 0.01912, "epss_percentile": 0.82835}, "CVE-2000-0090": {"epss_score": 0.00055, "epss_percentile": 0.17627}, "CVE-2000-0091": {"epss_score": 0.02492, "epss_percentile": 0.84899}, "CVE-2000-0092": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-2000-0093": {"epss_score": 0.00251, "epss_percentile": 0.48321}, "CVE-2000-0094": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-2000-0095": {"epss_score": 0.00525, "epss_percentile": 0.66369}, "CVE-2000-0096": {"epss_score": 0.00127, "epss_percentile": 0.32882}, "CVE-2000-0097": {"epss_score": 0.60867, "epss_percentile": 0.98225}, "CVE-2000-0098": {"epss_score": 0.8269, "epss_percentile": 0.99207}, "CVE-2000-0099": {"epss_score": 0.00085, "epss_percentile": 0.25225}, "CVE-2000-0100": {"epss_score": 0.01036, "epss_percentile": 0.76917}, "CVE-2000-0101": {"epss_score": 0.00553, "epss_percentile": 0.67427}, "CVE-2000-0102": {"epss_score": 0.00553, "epss_percentile": 0.67427}, "CVE-2000-0103": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2000-0104": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2000-0105": {"epss_score": 0.54815, "epss_percentile": 0.97946}, "CVE-2000-0106": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2000-0107": {"epss_score": 0.0038, "epss_percentile": 0.58939}, "CVE-2000-0108": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2000-0109": {"epss_score": 0.02179, "epss_percentile": 0.83895}, "CVE-2000-0110": {"epss_score": 0.00555, "epss_percentile": 0.67471}, "CVE-2000-0111": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2000-0112": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-2000-0113": {"epss_score": 0.01108, "epss_percentile": 0.77636}, "CVE-2000-0114": {"epss_score": 0.05458, "epss_percentile": 0.89899}, "CVE-2000-0115": {"epss_score": 0.04899, "epss_percentile": 0.89272}, "CVE-2000-0116": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2000-0117": {"epss_score": 0.00067, "epss_percentile": 0.21112}, "CVE-2000-0118": {"epss_score": 0.00148, "epss_percentile": 0.35809}, "CVE-2000-0119": {"epss_score": 0.00956, "epss_percentile": 0.7592}, "CVE-2000-0120": {"epss_score": 0.0048, "epss_percentile": 0.64466}, "CVE-2000-0121": {"epss_score": 0.01857, "epss_percentile": 0.82574}, "CVE-2000-0122": {"epss_score": 0.40318, "epss_percentile": 0.97211}, "CVE-2000-0123": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2000-0124": {"epss_score": 0.0013, "epss_percentile": 0.33284}, "CVE-2000-0125": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2000-0126": {"epss_score": 0.84722, "epss_percentile": 0.99302}, "CVE-2000-0127": {"epss_score": 0.00612, "epss_percentile": 0.69233}, "CVE-2000-0128": {"epss_score": 0.04892, "epss_percentile": 0.89265}, "CVE-2000-0129": {"epss_score": 0.00205, "epss_percentile": 0.42713}, "CVE-2000-0130": {"epss_score": 0.00405, "epss_percentile": 0.60473}, "CVE-2000-0131": {"epss_score": 0.04162, "epss_percentile": 0.88338}, "CVE-2000-0132": {"epss_score": 0.05969, "epss_percentile": 0.9037}, "CVE-2000-0133": {"epss_score": 0.06215, "epss_percentile": 0.90573}, "CVE-2000-0134": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2000-0135": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2000-0136": {"epss_score": 0.03149, "epss_percentile": 0.86501}, "CVE-2000-0137": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2000-0138": {"epss_score": 0.00973, "epss_percentile": 0.76145}, "CVE-2000-0139": {"epss_score": 0.00195, "epss_percentile": 0.41632}, "CVE-2000-0140": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0141": {"epss_score": 0.02467, "epss_percentile": 0.84837}, "CVE-2000-0142": {"epss_score": 0.05679, "epss_percentile": 0.90115}, "CVE-2000-0143": {"epss_score": 0.00073, "epss_percentile": 0.22673}, "CVE-2000-0144": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-2000-0145": {"epss_score": 0.00382, "epss_percentile": 0.59052}, "CVE-2000-0146": {"epss_score": 0.0578, "epss_percentile": 0.90201}, "CVE-2000-0147": {"epss_score": 0.0013, "epss_percentile": 0.33249}, "CVE-2000-0148": {"epss_score": 0.00443, "epss_percentile": 0.62794}, "CVE-2000-0149": {"epss_score": 0.04718, "epss_percentile": 0.89046}, "CVE-2000-0150": {"epss_score": 0.00454, "epss_percentile": 0.63255}, "CVE-2000-0151": {"epss_score": 0.00052, "epss_percentile": 0.16614}, "CVE-2000-0152": {"epss_score": 0.01894, "epss_percentile": 0.82742}, "CVE-2000-0153": {"epss_score": 0.28743, "epss_percentile": 0.9638}, "CVE-2000-0154": {"epss_score": 0.00289, "epss_percentile": 0.52026}, "CVE-2000-0155": {"epss_score": 0.01723, "epss_percentile": 0.81943}, "CVE-2000-0156": {"epss_score": 0.17466, "epss_percentile": 0.94854}, "CVE-2000-0157": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-2000-0158": {"epss_score": 0.00867, "epss_percentile": 0.7466}, "CVE-2000-0159": {"epss_score": 0.00689, "epss_percentile": 0.71233}, "CVE-2000-0160": {"epss_score": 0.10325, "epss_percentile": 0.92945}, "CVE-2000-0161": {"epss_score": 0.08393, "epss_percentile": 0.92028}, "CVE-2000-0162": {"epss_score": 0.01479, "epss_percentile": 0.8056}, "CVE-2000-0163": {"epss_score": 0.00154, "epss_percentile": 0.36754}, "CVE-2000-0164": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2000-0165": {"epss_score": 0.0847, "epss_percentile": 0.92068}, "CVE-2000-0166": {"epss_score": 0.05003, "epss_percentile": 0.8938}, "CVE-2000-0167": {"epss_score": 0.00194, "epss_percentile": 0.41596}, "CVE-2000-0168": {"epss_score": 0.16571, "epss_percentile": 0.94695}, "CVE-2000-0169": {"epss_score": 0.19271, "epss_percentile": 0.95158}, "CVE-2000-0170": {"epss_score": 0.00165, "epss_percentile": 0.38103}, "CVE-2000-0171": {"epss_score": 0.00112, "epss_percentile": 0.30412}, "CVE-2000-0172": {"epss_score": 0.00148, "epss_percentile": 0.35809}, "CVE-2000-0173": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0174": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-2000-0175": {"epss_score": 0.01189, "epss_percentile": 0.78371}, "CVE-2000-0176": {"epss_score": 0.00763, "epss_percentile": 0.72882}, "CVE-2000-0177": {"epss_score": 0.04286, "epss_percentile": 0.88495}, "CVE-2000-0178": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2000-0179": {"epss_score": 0.1048, "epss_percentile": 0.93}, "CVE-2000-0180": {"epss_score": 0.04092, "epss_percentile": 0.88241}, "CVE-2000-0181": {"epss_score": 0.0073, "epss_percentile": 0.72142}, "CVE-2000-0182": {"epss_score": 0.00209, "epss_percentile": 0.43417}, "CVE-2000-0183": {"epss_score": 0.05533, "epss_percentile": 0.89968}, "CVE-2000-0184": {"epss_score": 0.00079, "epss_percentile": 0.23855}, "CVE-2000-0185": {"epss_score": 0.0343, "epss_percentile": 0.87122}, "CVE-2000-0186": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-2000-0187": {"epss_score": 0.13385, "epss_percentile": 0.93948}, "CVE-2000-0188": {"epss_score": 0.025, "epss_percentile": 0.84918}, "CVE-2000-0189": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-2000-0190": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0191": {"epss_score": 0.02391, "epss_percentile": 0.84602}, "CVE-2000-0192": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-2000-0193": {"epss_score": 0.00138, "epss_percentile": 0.34445}, "CVE-2000-0194": {"epss_score": 0.00138, "epss_percentile": 0.34395}, "CVE-2000-0195": {"epss_score": 0.00138, "epss_percentile": 0.34395}, "CVE-2000-0196": {"epss_score": 0.01316, "epss_percentile": 0.79406}, "CVE-2000-0197": {"epss_score": 0.00363, "epss_percentile": 0.57848}, "CVE-2000-0198": {"epss_score": 0.061, "epss_percentile": 0.9048}, "CVE-2000-0199": {"epss_score": 0.00184, "epss_percentile": 0.40441}, "CVE-2000-0200": {"epss_score": 0.18433, "epss_percentile": 0.95016}, "CVE-2000-0201": {"epss_score": 0.05099, "epss_percentile": 0.89496}, "CVE-2000-0202": {"epss_score": 0.12616, "epss_percentile": 0.9373}, "CVE-2000-0203": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2000-0204": {"epss_score": 0.05219, "epss_percentile": 0.89624}, "CVE-2000-0205": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2000-0206": {"epss_score": 0.00215, "epss_percentile": 0.4412}, "CVE-2000-0207": {"epss_score": 0.05383, "epss_percentile": 0.89816}, "CVE-2000-0208": {"epss_score": 0.06683, "epss_percentile": 0.90942}, "CVE-2000-0209": {"epss_score": 0.03072, "epss_percentile": 0.8635}, "CVE-2000-0210": {"epss_score": 0.00154, "epss_percentile": 0.36754}, "CVE-2000-0211": {"epss_score": 0.26564, "epss_percentile": 0.96157}, "CVE-2000-0212": {"epss_score": 0.04014, "epss_percentile": 0.8812}, "CVE-2000-0213": {"epss_score": 0.07351, "epss_percentile": 0.91425}, "CVE-2000-0214": {"epss_score": 0.00213, "epss_percentile": 0.43909}, "CVE-2000-0215": {"epss_score": 0.00081, "epss_percentile": 0.24218}, "CVE-2000-0216": {"epss_score": 0.13016, "epss_percentile": 0.93846}, "CVE-2000-0217": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2000-0218": {"epss_score": 0.00152, "epss_percentile": 0.36439}, "CVE-2000-0219": {"epss_score": 0.00416, "epss_percentile": 0.61186}, "CVE-2000-0220": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-2000-0221": {"epss_score": 0.04014, "epss_percentile": 0.8812}, "CVE-2000-0222": {"epss_score": 0.33127, "epss_percentile": 0.96748}, "CVE-2000-0223": {"epss_score": 0.0018, "epss_percentile": 0.39868}, "CVE-2000-0224": {"epss_score": 0.00254, "epss_percentile": 0.48569}, "CVE-2000-0225": {"epss_score": 0.00861, "epss_percentile": 0.74559}, "CVE-2000-0226": {"epss_score": 0.12721, "epss_percentile": 0.93758}, "CVE-2000-0227": {"epss_score": 0.00167, "epss_percentile": 0.3835}, "CVE-2000-0228": {"epss_score": 0.18274, "epss_percentile": 0.94986}, "CVE-2000-0229": {"epss_score": 0.00113, "epss_percentile": 0.30614}, "CVE-2000-0230": {"epss_score": 0.00117, "epss_percentile": 0.31333}, "CVE-2000-0231": {"epss_score": 0.00148, "epss_percentile": 0.35809}, "CVE-2000-0232": {"epss_score": 0.0138, "epss_percentile": 0.7986}, "CVE-2000-0233": {"epss_score": 0.00324, "epss_percentile": 0.54929}, "CVE-2000-0234": {"epss_score": 0.03862, "epss_percentile": 0.87867}, "CVE-2000-0235": {"epss_score": 0.00068, "epss_percentile": 0.21393}, "CVE-2000-0236": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-2000-0237": {"epss_score": 0.00445, "epss_percentile": 0.6288}, "CVE-2000-0238": {"epss_score": 0.0088, "epss_percentile": 0.74853}, "CVE-2000-0239": {"epss_score": 0.04128, "epss_percentile": 0.88292}, "CVE-2000-0240": {"epss_score": 0.05103, "epss_percentile": 0.89503}, "CVE-2000-0241": {"epss_score": 0.00502, "epss_percentile": 0.65392}, "CVE-2000-0242": {"epss_score": 0.06334, "epss_percentile": 0.90677}, "CVE-2000-0243": {"epss_score": 0.06131, "epss_percentile": 0.90502}, "CVE-2000-0244": {"epss_score": 0.00896, "epss_percentile": 0.75118}, "CVE-2000-0245": {"epss_score": 0.05869, "epss_percentile": 0.90278}, "CVE-2000-0246": {"epss_score": 0.83616, "epss_percentile": 0.99255}, "CVE-2000-0247": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2000-0248": {"epss_score": 0.7588, "epss_percentile": 0.98868}, "CVE-2000-0249": {"epss_score": 0.00064, "epss_percentile": 0.20133}, "CVE-2000-0250": {"epss_score": 0.00061, "epss_percentile": 0.19333}, "CVE-2000-0251": {"epss_score": 0.01429, "epss_percentile": 0.80227}, "CVE-2000-0252": {"epss_score": 0.01451, "epss_percentile": 0.80362}, "CVE-2000-0253": {"epss_score": 0.01102, "epss_percentile": 0.77577}, "CVE-2000-0254": {"epss_score": 0.0363, "epss_percentile": 0.87472}, "CVE-2000-0255": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-2000-0256": {"epss_score": 0.24021, "epss_percentile": 0.95844}, "CVE-2000-0257": {"epss_score": 0.04891, "epss_percentile": 0.89264}, "CVE-2000-0258": {"epss_score": 0.20309, "epss_percentile": 0.9532}, "CVE-2000-0259": {"epss_score": 0.00374, "epss_percentile": 0.58584}, "CVE-2000-0260": {"epss_score": 0.14955, "epss_percentile": 0.94334}, "CVE-2000-0261": {"epss_score": 0.00651, "epss_percentile": 0.70298}, "CVE-2000-0262": {"epss_score": 0.04186, "epss_percentile": 0.88363}, "CVE-2000-0263": {"epss_score": 0.00479, "epss_percentile": 0.64415}, "CVE-2000-0264": {"epss_score": 0.00618, "epss_percentile": 0.69374}, "CVE-2000-0265": {"epss_score": 0.00074, "epss_percentile": 0.2281}, "CVE-2000-0266": {"epss_score": 0.01829, "epss_percentile": 0.8244}, "CVE-2000-0267": {"epss_score": 0.00285, "epss_percentile": 0.51551}, "CVE-2000-0268": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2000-0269": {"epss_score": 0.00069, "epss_percentile": 0.216}, "CVE-2000-0270": {"epss_score": 0.001, "epss_percentile": 0.28506}, "CVE-2000-0271": {"epss_score": 0.00069, "epss_percentile": 0.21466}, "CVE-2000-0272": {"epss_score": 0.08539, "epss_percentile": 0.92111}, "CVE-2000-0273": {"epss_score": 0.00852, "epss_percentile": 0.74413}, "CVE-2000-0274": {"epss_score": 0.00778, "epss_percentile": 0.73126}, "CVE-2000-0275": {"epss_score": 0.00316, "epss_percentile": 0.54283}, "CVE-2000-0276": {"epss_score": 0.00195, "epss_percentile": 0.41668}, "CVE-2000-0277": {"epss_score": 0.01667, "epss_percentile": 0.81658}, "CVE-2000-0278": {"epss_score": 0.04021, "epss_percentile": 0.88133}, "CVE-2000-0279": {"epss_score": 0.04186, "epss_percentile": 0.88363}, "CVE-2000-0280": {"epss_score": 0.03474, "epss_percentile": 0.87205}, "CVE-2000-0281": {"epss_score": 0.00242, "epss_percentile": 0.47365}, "CVE-2000-0282": {"epss_score": 0.08832, "epss_percentile": 0.92273}, "CVE-2000-0283": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-2000-0284": {"epss_score": 0.78727, "epss_percentile": 0.99001}, "CVE-2000-0285": {"epss_score": 0.00048, "epss_percentile": 0.14938}, "CVE-2000-0286": {"epss_score": 0.00483, "epss_percentile": 0.64559}, "CVE-2000-0287": {"epss_score": 0.05424, "epss_percentile": 0.89865}, "CVE-2000-0288": {"epss_score": 0.00315, "epss_percentile": 0.54186}, "CVE-2000-0289": {"epss_score": 0.00826, "epss_percentile": 0.7396}, "CVE-2000-0290": {"epss_score": 0.0071, "epss_percentile": 0.71727}, "CVE-2000-0291": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2000-0292": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0293": {"epss_score": 0.00185, "epss_percentile": 0.40574}, "CVE-2000-0294": {"epss_score": 0.00068, "epss_percentile": 0.21393}, "CVE-2000-0295": {"epss_score": 0.0456, "epss_percentile": 0.88849}, "CVE-2000-0296": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2000-0297": {"epss_score": 0.004, "epss_percentile": 0.60166}, "CVE-2000-0298": {"epss_score": 0.02304, "epss_percentile": 0.84321}, "CVE-2000-0299": {"epss_score": 0.03958, "epss_percentile": 0.8801}, "CVE-2000-0300": {"epss_score": 0.01391, "epss_percentile": 0.79948}, "CVE-2000-0301": {"epss_score": 0.01554, "epss_percentile": 0.81}, "CVE-2000-0302": {"epss_score": 0.72686, "epss_percentile": 0.98722}, "CVE-2000-0303": {"epss_score": 0.00527, "epss_percentile": 0.66466}, "CVE-2000-0304": {"epss_score": 0.51691, "epss_percentile": 0.97795}, "CVE-2000-0305": {"epss_score": 0.40969, "epss_percentile": 0.97248}, "CVE-2000-0306": {"epss_score": 0.03141, "epss_percentile": 0.86489}, "CVE-2000-0307": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2000-0308": {"epss_score": 0.00349, "epss_percentile": 0.56863}, "CVE-2000-0309": {"epss_score": 0.00075, "epss_percentile": 0.22996}, "CVE-2000-0310": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0311": {"epss_score": 0.0067, "epss_percentile": 0.70776}, "CVE-2000-0312": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-2000-0313": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-2000-0314": {"epss_score": 0.00315, "epss_percentile": 0.54169}, "CVE-2000-0315": {"epss_score": 0.00439, "epss_percentile": 0.62597}, "CVE-2000-0316": {"epss_score": 0.00128, "epss_percentile": 0.33046}, "CVE-2000-0317": {"epss_score": 0.0011, "epss_percentile": 0.30147}, "CVE-2000-0318": {"epss_score": 0.00415, "epss_percentile": 0.61136}, "CVE-2000-0319": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0320": {"epss_score": 0.00688, "epss_percentile": 0.71191}, "CVE-2000-0321": {"epss_score": 0.00622, "epss_percentile": 0.69509}, "CVE-2000-0322": {"epss_score": 0.77767, "epss_percentile": 0.98952}, "CVE-2000-0323": {"epss_score": 0.13315, "epss_percentile": 0.93931}, "CVE-2000-0324": {"epss_score": 0.07008, "epss_percentile": 0.91182}, "CVE-2000-0325": {"epss_score": 0.0705, "epss_percentile": 0.91212}, "CVE-2000-0326": {"epss_score": 0.00389, "epss_percentile": 0.59405}, "CVE-2000-0327": {"epss_score": 0.08818, "epss_percentile": 0.92269}, "CVE-2000-0328": {"epss_score": 0.2262, "epss_percentile": 0.9566}, "CVE-2000-0329": {"epss_score": 0.07321, "epss_percentile": 0.91407}, "CVE-2000-0330": {"epss_score": 0.22854, "epss_percentile": 0.957}, "CVE-2000-0331": {"epss_score": 0.17179, "epss_percentile": 0.94793}, "CVE-2000-0332": {"epss_score": 0.08189, "epss_percentile": 0.91919}, "CVE-2000-0333": {"epss_score": 0.03396, "epss_percentile": 0.87058}, "CVE-2000-0334": {"epss_score": 0.00103, "epss_percentile": 0.29048}, "CVE-2000-0335": {"epss_score": 0.01131, "epss_percentile": 0.77866}, "CVE-2000-0336": {"epss_score": 0.00042, "epss_percentile": 0.12829}, "CVE-2000-0337": {"epss_score": 0.00145, "epss_percentile": 0.35517}, "CVE-2000-0338": {"epss_score": 0.01251, "epss_percentile": 0.78898}, "CVE-2000-0339": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2000-0340": {"epss_score": 0.00189, "epss_percentile": 0.40932}, "CVE-2000-0341": {"epss_score": 0.04021, "epss_percentile": 0.88133}, "CVE-2000-0342": {"epss_score": 0.0255, "epss_percentile": 0.85074}, "CVE-2000-0343": {"epss_score": 0.07251, "epss_percentile": 0.91351}, "CVE-2000-0344": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0345": {"epss_score": 0.00117, "epss_percentile": 0.31371}, "CVE-2000-0346": {"epss_score": 0.00591, "epss_percentile": 0.6859}, "CVE-2000-0347": {"epss_score": 0.36317, "epss_percentile": 0.9697}, "CVE-2000-0348": {"epss_score": 0.00461, "epss_percentile": 0.63564}, "CVE-2000-0349": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2000-0350": {"epss_score": 0.04566, "epss_percentile": 0.88858}, "CVE-2000-0351": {"epss_score": 0.00082, "epss_percentile": 0.2456}, "CVE-2000-0352": {"epss_score": 0.02467, "epss_percentile": 0.84837}, "CVE-2000-0353": {"epss_score": 0.03361, "epss_percentile": 0.8699}, "CVE-2000-0354": {"epss_score": 0.0073, "epss_percentile": 0.72161}, "CVE-2000-0355": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-2000-0356": {"epss_score": 0.00086, "epss_percentile": 0.2531}, "CVE-2000-0357": {"epss_score": 0.00432, "epss_percentile": 0.62118}, "CVE-2000-0358": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0359": {"epss_score": 0.03504, "epss_percentile": 0.87254}, "CVE-2000-0360": {"epss_score": 0.01469, "epss_percentile": 0.8049}, "CVE-2000-0361": {"epss_score": 0.00087, "epss_percentile": 0.25607}, "CVE-2000-0362": {"epss_score": 0.00145, "epss_percentile": 0.35517}, "CVE-2000-0363": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-2000-0364": {"epss_score": 0.00073, "epss_percentile": 0.22545}, "CVE-2000-0365": {"epss_score": 0.00073, "epss_percentile": 0.22545}, "CVE-2000-0366": {"epss_score": 0.00137, "epss_percentile": 0.34326}, "CVE-2000-0367": {"epss_score": 0.00052, "epss_percentile": 0.16474}, "CVE-2000-0368": {"epss_score": 0.00102, "epss_percentile": 0.2882}, "CVE-2000-0369": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0370": {"epss_score": 0.01897, "epss_percentile": 0.82759}, "CVE-2000-0371": {"epss_score": 0.00066, "epss_percentile": 0.20675}, "CVE-2000-0372": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2000-0373": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2000-0374": {"epss_score": 0.00328, "epss_percentile": 0.55272}, "CVE-2000-0375": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2000-0376": {"epss_score": 0.02676, "epss_percentile": 0.85402}, "CVE-2000-0377": {"epss_score": 0.12082, "epss_percentile": 0.93562}, "CVE-2000-0378": {"epss_score": 0.00416, "epss_percentile": 0.61216}, "CVE-2000-0379": {"epss_score": 0.00467, "epss_percentile": 0.63838}, "CVE-2000-0380": {"epss_score": 0.85118, "epss_percentile": 0.99319}, "CVE-2000-0381": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2000-0382": {"epss_score": 0.0037, "epss_percentile": 0.58299}, "CVE-2000-0383": {"epss_score": 0.00593, "epss_percentile": 0.6863}, "CVE-2000-0384": {"epss_score": 0.09083, "epss_percentile": 0.92393}, "CVE-2000-0385": {"epss_score": 0.00314, "epss_percentile": 0.54156}, "CVE-2000-0386": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2000-0387": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2000-0388": {"epss_score": 0.00884, "epss_percentile": 0.7493}, "CVE-2000-0389": {"epss_score": 0.11008, "epss_percentile": 0.93188}, "CVE-2000-0390": {"epss_score": 0.08485, "epss_percentile": 0.92077}, "CVE-2000-0391": {"epss_score": 0.08485, "epss_percentile": 0.92077}, "CVE-2000-0392": {"epss_score": 0.00114, "epss_percentile": 0.30875}, "CVE-2000-0393": {"epss_score": 0.00731, "epss_percentile": 0.72172}, "CVE-2000-0394": {"epss_score": 0.05286, "epss_percentile": 0.89693}, "CVE-2000-0395": {"epss_score": 0.03958, "epss_percentile": 0.8801}, "CVE-2000-0396": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-2000-0397": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-2000-0398": {"epss_score": 0.02601, "epss_percentile": 0.85208}, "CVE-2000-0399": {"epss_score": 0.00714, "epss_percentile": 0.71829}, "CVE-2000-0400": {"epss_score": 0.16347, "epss_percentile": 0.94633}, "CVE-2000-0401": {"epss_score": 0.01474, "epss_percentile": 0.80521}, "CVE-2000-0402": {"epss_score": 0.78483, "epss_percentile": 0.98988}, "CVE-2000-0403": {"epss_score": 0.13213, "epss_percentile": 0.93903}, "CVE-2000-0404": {"epss_score": 0.24313, "epss_percentile": 0.95902}, "CVE-2000-0405": {"epss_score": 0.07851, "epss_percentile": 0.91719}, "CVE-2000-0406": {"epss_score": 0.00744, "epss_percentile": 0.72503}, "CVE-2000-0407": {"epss_score": 0.00212, "epss_percentile": 0.43801}, "CVE-2000-0408": {"epss_score": 0.74022, "epss_percentile": 0.98782}, "CVE-2000-0409": {"epss_score": 0.00086, "epss_percentile": 0.25403}, "CVE-2000-0410": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2000-0411": {"epss_score": 0.03779, "epss_percentile": 0.87717}, "CVE-2000-0412": {"epss_score": 0.03482, "epss_percentile": 0.87222}, "CVE-2000-0413": {"epss_score": 0.59392, "epss_percentile": 0.98162}, "CVE-2000-0414": {"epss_score": 0.00103, "epss_percentile": 0.28994}, "CVE-2000-0415": {"epss_score": 0.11722, "epss_percentile": 0.93459}, "CVE-2000-0416": {"epss_score": 0.16179, "epss_percentile": 0.94589}, "CVE-2000-0417": {"epss_score": 0.06281, "epss_percentile": 0.90638}, "CVE-2000-0418": {"epss_score": 0.04014, "epss_percentile": 0.8812}, "CVE-2000-0419": {"epss_score": 0.10948, "epss_percentile": 0.9317}, "CVE-2000-0420": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2000-0421": {"epss_score": 0.01125, "epss_percentile": 0.77803}, "CVE-2000-0422": {"epss_score": 0.01762, "epss_percentile": 0.82153}, "CVE-2000-0423": {"epss_score": 0.06472, "epss_percentile": 0.90778}, "CVE-2000-0424": {"epss_score": 0.05383, "epss_percentile": 0.89816}, "CVE-2000-0425": {"epss_score": 0.06827, "epss_percentile": 0.91051}, "CVE-2000-0426": {"epss_score": 0.0603, "epss_percentile": 0.90423}, "CVE-2000-0427": {"epss_score": 0.00351, "epss_percentile": 0.57072}, "CVE-2000-0428": {"epss_score": 0.02698, "epss_percentile": 0.85448}, "CVE-2000-0429": {"epss_score": 0.05383, "epss_percentile": 0.89816}, "CVE-2000-0430": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-2000-0431": {"epss_score": 0.0037, "epss_percentile": 0.58278}, "CVE-2000-0432": {"epss_score": 0.05383, "epss_percentile": 0.89816}, "CVE-2000-0433": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-2000-0434": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2000-0435": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2000-0436": {"epss_score": 0.03779, "epss_percentile": 0.87717}, "CVE-2000-0437": {"epss_score": 0.07187, "epss_percentile": 0.91308}, "CVE-2000-0438": {"epss_score": 0.00256, "epss_percentile": 0.48785}, "CVE-2000-0439": {"epss_score": 0.14821, "epss_percentile": 0.94292}, "CVE-2000-0440": {"epss_score": 0.06281, "epss_percentile": 0.90638}, "CVE-2000-0441": {"epss_score": 0.00519, "epss_percentile": 0.6617}, "CVE-2000-0442": {"epss_score": 0.03992, "epss_percentile": 0.88072}, "CVE-2000-0443": {"epss_score": 0.04351, "epss_percentile": 0.88585}, "CVE-2000-0444": {"epss_score": 0.05201, "epss_percentile": 0.89604}, "CVE-2000-0445": {"epss_score": 0.00262, "epss_percentile": 0.49404}, "CVE-2000-0446": {"epss_score": 0.05739, "epss_percentile": 0.90166}, "CVE-2000-0447": {"epss_score": 0.0142, "epss_percentile": 0.80165}, "CVE-2000-0448": {"epss_score": 0.00631, "epss_percentile": 0.69719}, "CVE-2000-0449": {"epss_score": 0.0154, "epss_percentile": 0.80941}, "CVE-2000-0450": {"epss_score": 0.00866, "epss_percentile": 0.7464}, "CVE-2000-0451": {"epss_score": 0.04014, "epss_percentile": 0.8812}, "CVE-2000-0452": {"epss_score": 0.04128, "epss_percentile": 0.88292}, "CVE-2000-0453": {"epss_score": 0.05761, "epss_percentile": 0.90184}, "CVE-2000-0454": {"epss_score": 0.00473, "epss_percentile": 0.64087}, "CVE-2000-0455": {"epss_score": 0.00335, "epss_percentile": 0.55847}, "CVE-2000-0456": {"epss_score": 0.00081, "epss_percentile": 0.24318}, "CVE-2000-0457": {"epss_score": 0.84385, "epss_percentile": 0.99287}, "CVE-2000-0458": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-2000-0459": {"epss_score": 0.00441, "epss_percentile": 0.6268}, "CVE-2000-0460": {"epss_score": 0.0073, "epss_percentile": 0.72142}, "CVE-2000-0461": {"epss_score": 0.00084, "epss_percentile": 0.24864}, "CVE-2000-0462": {"epss_score": 0.0014, "epss_percentile": 0.348}, "CVE-2000-0463": {"epss_score": 0.0603, "epss_percentile": 0.90423}, "CVE-2000-0464": {"epss_score": 0.20013, "epss_percentile": 0.95275}, "CVE-2000-0465": {"epss_score": 0.23714, "epss_percentile": 0.95807}, "CVE-2000-0466": {"epss_score": 0.00043, "epss_percentile": 0.13061}, "CVE-2000-0467": {"epss_score": 0.00151, "epss_percentile": 0.36189}, "CVE-2000-0468": {"epss_score": 0.01149, "epss_percentile": 0.78021}, "CVE-2000-0469": {"epss_score": 0.00626, "epss_percentile": 0.69613}, "CVE-2000-0470": {"epss_score": 0.03469, "epss_percentile": 0.87195}, "CVE-2000-0471": {"epss_score": 0.00344, "epss_percentile": 0.56497}, "CVE-2000-0472": {"epss_score": 0.04931, "epss_percentile": 0.89298}, "CVE-2000-0473": {"epss_score": 0.04278, "epss_percentile": 0.88486}, "CVE-2000-0474": {"epss_score": 0.08539, "epss_percentile": 0.92111}, "CVE-2000-0475": {"epss_score": 0.03431, "epss_percentile": 0.87124}, "CVE-2000-0476": {"epss_score": 0.11152, "epss_percentile": 0.93245}, "CVE-2000-0477": {"epss_score": 0.00837, "epss_percentile": 0.74152}, "CVE-2000-0478": {"epss_score": 0.00775, "epss_percentile": 0.73089}, "CVE-2000-0479": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2000-0480": {"epss_score": 0.03575, "epss_percentile": 0.87379}, "CVE-2000-0481": {"epss_score": 0.00806, "epss_percentile": 0.73655}, "CVE-2000-0482": {"epss_score": 0.06131, "epss_percentile": 0.90502}, "CVE-2000-0483": {"epss_score": 0.01473, "epss_percentile": 0.80515}, "CVE-2000-0484": {"epss_score": 0.07469, "epss_percentile": 0.91491}, "CVE-2000-0485": {"epss_score": 0.01274, "epss_percentile": 0.79097}, "CVE-2000-0486": {"epss_score": 0.01428, "epss_percentile": 0.80219}, "CVE-2000-0487": {"epss_score": 0.00368, "epss_percentile": 0.58192}, "CVE-2000-0488": {"epss_score": 0.01672, "epss_percentile": 0.81681}, "CVE-2000-0489": {"epss_score": 0.0105, "epss_percentile": 0.77073}, "CVE-2000-0490": {"epss_score": 0.06092, "epss_percentile": 0.90475}, "CVE-2000-0491": {"epss_score": 0.06918, "epss_percentile": 0.91116}, "CVE-2000-0492": {"epss_score": 0.01668, "epss_percentile": 0.81662}, "CVE-2000-0493": {"epss_score": 0.07752, "epss_percentile": 0.91659}, "CVE-2000-0494": {"epss_score": 0.00449, "epss_percentile": 0.63048}, "CVE-2000-0495": {"epss_score": 0.17341, "epss_percentile": 0.9483}, "CVE-2000-0497": {"epss_score": 0.00729, "epss_percentile": 0.72123}, "CVE-2000-0498": {"epss_score": 0.01619, "epss_percentile": 0.8138}, "CVE-2000-0499": {"epss_score": 0.01411, "epss_percentile": 0.8011}, "CVE-2000-0500": {"epss_score": 0.0554, "epss_percentile": 0.89978}, "CVE-2000-0501": {"epss_score": 0.02007, "epss_percentile": 0.83237}, "CVE-2000-0502": {"epss_score": 0.00089, "epss_percentile": 0.2589}, "CVE-2000-0503": {"epss_score": 0.11111, "epss_percentile": 0.93224}, "CVE-2000-0504": {"epss_score": 0.02332, "epss_percentile": 0.84408}, "CVE-2000-0505": {"epss_score": 0.46366, "epss_percentile": 0.97542}, "CVE-2000-0506": {"epss_score": 0.04368, "epss_percentile": 0.88605}, "CVE-2000-0507": {"epss_score": 0.05166, "epss_percentile": 0.89566}, "CVE-2000-0508": {"epss_score": 0.06568, "epss_percentile": 0.90851}, "CVE-2000-0509": {"epss_score": 0.01831, "epss_percentile": 0.82448}, "CVE-2000-0510": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2000-0511": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2000-0512": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2000-0513": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2000-0514": {"epss_score": 0.00928, "epss_percentile": 0.75583}, "CVE-2000-0515": {"epss_score": 0.01471, "epss_percentile": 0.80506}, "CVE-2000-0516": {"epss_score": 0.00154, "epss_percentile": 0.36727}, "CVE-2000-0517": {"epss_score": 0.00954, "epss_percentile": 0.75907}, "CVE-2000-0518": {"epss_score": 0.02187, "epss_percentile": 0.83923}, "CVE-2000-0519": {"epss_score": 0.02187, "epss_percentile": 0.83923}, "CVE-2000-0520": {"epss_score": 0.00267, "epss_percentile": 0.50013}, "CVE-2000-0521": {"epss_score": 0.08197, "epss_percentile": 0.91925}, "CVE-2000-0522": {"epss_score": 0.01198, "epss_percentile": 0.78449}, "CVE-2000-0523": {"epss_score": 0.0546, "epss_percentile": 0.899}, "CVE-2000-0524": {"epss_score": 0.1551, "epss_percentile": 0.94442}, "CVE-2000-0525": {"epss_score": 0.00709, "epss_percentile": 0.71687}, "CVE-2000-0526": {"epss_score": 0.03173, "epss_percentile": 0.86552}, "CVE-2000-0527": {"epss_score": 0.04286, "epss_percentile": 0.88495}, "CVE-2000-0528": {"epss_score": 0.00669, "epss_percentile": 0.7075}, "CVE-2000-0529": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2000-0530": {"epss_score": 0.0027, "epss_percentile": 0.50244}, "CVE-2000-0531": {"epss_score": 0.00449, "epss_percentile": 0.63051}, "CVE-2000-0532": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2000-0533": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2000-0534": {"epss_score": 0.00074, "epss_percentile": 0.22718}, "CVE-2000-0535": {"epss_score": 0.00555, "epss_percentile": 0.67495}, "CVE-2000-0536": {"epss_score": 0.00438, "epss_percentile": 0.62565}, "CVE-2000-0537": {"epss_score": 0.00146, "epss_percentile": 0.35591}, "CVE-2000-0538": {"epss_score": 0.09008, "epss_percentile": 0.92362}, "CVE-2000-0539": {"epss_score": 0.0054, "epss_percentile": 0.67021}, "CVE-2000-0540": {"epss_score": 0.00631, "epss_percentile": 0.69723}, "CVE-2000-0541": {"epss_score": 0.00078, "epss_percentile": 0.2376}, "CVE-2000-0542": {"epss_score": 0.00556, "epss_percentile": 0.6751}, "CVE-2000-0543": {"epss_score": 0.00478, "epss_percentile": 0.64406}, "CVE-2000-0544": {"epss_score": 0.14406, "epss_percentile": 0.94205}, "CVE-2000-0545": {"epss_score": 0.00202, "epss_percentile": 0.42473}, "CVE-2000-0546": {"epss_score": 0.02576, "epss_percentile": 0.85143}, "CVE-2000-0547": {"epss_score": 0.02576, "epss_percentile": 0.85143}, "CVE-2000-0548": {"epss_score": 0.03418, "epss_percentile": 0.87096}, "CVE-2000-0549": {"epss_score": 0.01332, "epss_percentile": 0.79522}, "CVE-2000-0550": {"epss_score": 0.03066, "epss_percentile": 0.86338}, "CVE-2000-0551": {"epss_score": 0.00707, "epss_percentile": 0.71653}, "CVE-2000-0552": {"epss_score": 0.00962, "epss_percentile": 0.75995}, "CVE-2000-0553": {"epss_score": 0.00441, "epss_percentile": 0.62655}, "CVE-2000-0554": {"epss_score": 0.00611, "epss_percentile": 0.69183}, "CVE-2000-0555": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2000-0556": {"epss_score": 0.00733, "epss_percentile": 0.72218}, "CVE-2000-0557": {"epss_score": 0.03349, "epss_percentile": 0.86956}, "CVE-2000-0558": {"epss_score": 0.01405, "epss_percentile": 0.80044}, "CVE-2000-0559": {"epss_score": 0.0012, "epss_percentile": 0.31786}, "CVE-2000-0561": {"epss_score": 0.02501, "epss_percentile": 0.84922}, "CVE-2000-0562": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-2000-0563": {"epss_score": 0.00474, "epss_percentile": 0.64162}, "CVE-2000-0564": {"epss_score": 0.00634, "epss_percentile": 0.69799}, "CVE-2000-0565": {"epss_score": 0.00102, "epss_percentile": 0.28834}, "CVE-2000-0566": {"epss_score": 0.00083, "epss_percentile": 0.24696}, "CVE-2000-0567": {"epss_score": 0.19902, "epss_percentile": 0.95256}, "CVE-2000-0568": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0569": {"epss_score": 0.08032, "epss_percentile": 0.91844}, "CVE-2000-0570": {"epss_score": 0.05785, "epss_percentile": 0.90206}, "CVE-2000-0571": {"epss_score": 0.03208, "epss_percentile": 0.8664}, "CVE-2000-0572": {"epss_score": 0.00075, "epss_percentile": 0.2304}, "CVE-2000-0573": {"epss_score": 0.91454, "epss_percentile": 0.99644}, "CVE-2000-0574": {"epss_score": 0.12738, "epss_percentile": 0.93762}, "CVE-2000-0575": {"epss_score": 0.00361, "epss_percentile": 0.57729}, "CVE-2000-0576": {"epss_score": 0.00756, "epss_percentile": 0.72736}, "CVE-2000-0577": {"epss_score": 0.03268, "epss_percentile": 0.86786}, "CVE-2000-0578": {"epss_score": 0.00084, "epss_percentile": 0.24969}, "CVE-2000-0579": {"epss_score": 0.00084, "epss_percentile": 0.24969}, "CVE-2000-0580": {"epss_score": 0.21284, "epss_percentile": 0.95494}, "CVE-2000-0581": {"epss_score": 0.55546, "epss_percentile": 0.97983}, "CVE-2000-0582": {"epss_score": 0.05219, "epss_percentile": 0.89624}, "CVE-2000-0583": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2000-0584": {"epss_score": 0.05328, "epss_percentile": 0.89737}, "CVE-2000-0585": {"epss_score": 0.09545, "epss_percentile": 0.92592}, "CVE-2000-0586": {"epss_score": 0.05061, "epss_percentile": 0.89453}, "CVE-2000-0587": {"epss_score": 0.00395, "epss_percentile": 0.59839}, "CVE-2000-0588": {"epss_score": 0.04092, "epss_percentile": 0.88241}, "CVE-2000-0589": {"epss_score": 0.01742, "epss_percentile": 0.82053}, "CVE-2000-0590": {"epss_score": 0.07333, "epss_percentile": 0.91415}, "CVE-2000-0591": {"epss_score": 0.00184, "epss_percentile": 0.40428}, "CVE-2000-0592": {"epss_score": 0.05163, "epss_percentile": 0.89561}, "CVE-2000-0593": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2000-0594": {"epss_score": 0.11965, "epss_percentile": 0.93527}, "CVE-2000-0595": {"epss_score": 0.00124, "epss_percentile": 0.32453}, "CVE-2000-0596": {"epss_score": 0.13009, "epss_percentile": 0.93846}, "CVE-2000-0597": {"epss_score": 0.09559, "epss_percentile": 0.92599}, "CVE-2000-0598": {"epss_score": 0.00353, "epss_percentile": 0.57187}, "CVE-2000-0599": {"epss_score": 0.02446, "epss_percentile": 0.8477}, "CVE-2000-0600": {"epss_score": 0.0115, "epss_percentile": 0.78028}, "CVE-2000-0601": {"epss_score": 0.04569, "epss_percentile": 0.88862}, "CVE-2000-0602": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-2000-0603": {"epss_score": 0.0078, "epss_percentile": 0.7317}, "CVE-2000-0604": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2000-0605": {"epss_score": 0.0013, "epss_percentile": 0.33284}, "CVE-2000-0606": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-2000-0607": {"epss_score": 0.00292, "epss_percentile": 0.52228}, "CVE-2000-0608": {"epss_score": 0.00693, "epss_percentile": 0.7132}, "CVE-2000-0609": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2000-0610": {"epss_score": 0.00942, "epss_percentile": 0.75765}, "CVE-2000-0611": {"epss_score": 0.00514, "epss_percentile": 0.65948}, "CVE-2000-0612": {"epss_score": 0.1528, "epss_percentile": 0.94398}, "CVE-2000-0613": {"epss_score": 0.17863, "epss_percentile": 0.94919}, "CVE-2000-0614": {"epss_score": 0.0096, "epss_percentile": 0.75969}, "CVE-2000-0615": {"epss_score": 0.00099, "epss_percentile": 0.28358}, "CVE-2000-0616": {"epss_score": 0.00097, "epss_percentile": 0.27576}, "CVE-2000-0617": {"epss_score": 0.00182, "epss_percentile": 0.4026}, "CVE-2000-0618": {"epss_score": 0.00077, "epss_percentile": 0.23457}, "CVE-2000-0619": {"epss_score": 0.009, "epss_percentile": 0.75165}, "CVE-2000-0620": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2000-0621": {"epss_score": 0.05844, "epss_percentile": 0.90253}, "CVE-2000-0622": {"epss_score": 0.06873, "epss_percentile": 0.91086}, "CVE-2000-0623": {"epss_score": 0.02927, "epss_percentile": 0.86008}, "CVE-2000-0624": {"epss_score": 0.07092, "epss_percentile": 0.91245}, "CVE-2000-0625": {"epss_score": 0.00197, "epss_percentile": 0.41866}, "CVE-2000-0626": {"epss_score": 0.05252, "epss_percentile": 0.89664}, "CVE-2000-0627": {"epss_score": 0.00435, "epss_percentile": 0.62325}, "CVE-2000-0628": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2000-0629": {"epss_score": 0.01516, "epss_percentile": 0.80797}, "CVE-2000-0630": {"epss_score": 0.75963, "epss_percentile": 0.98871}, "CVE-2000-0631": {"epss_score": 0.48365, "epss_percentile": 0.97634}, "CVE-2000-0632": {"epss_score": 0.01369, "epss_percentile": 0.79795}, "CVE-2000-0633": {"epss_score": 0.00063, "epss_percentile": 0.19964}, "CVE-2000-0634": {"epss_score": 0.07618, "epss_percentile": 0.91572}, "CVE-2000-0635": {"epss_score": 0.0153, "epss_percentile": 0.80884}, "CVE-2000-0636": {"epss_score": 0.31153, "epss_percentile": 0.96598}, "CVE-2000-0637": {"epss_score": 0.02732, "epss_percentile": 0.85541}, "CVE-2000-0638": {"epss_score": 0.06988, "epss_percentile": 0.91164}, "CVE-2000-0639": {"epss_score": 0.03556, "epss_percentile": 0.87347}, "CVE-2000-0640": {"epss_score": 0.04545, "epss_percentile": 0.88832}, "CVE-2000-0641": {"epss_score": 0.13305, "epss_percentile": 0.93927}, "CVE-2000-0642": {"epss_score": 0.00745, "epss_percentile": 0.7252}, "CVE-2000-0643": {"epss_score": 0.00852, "epss_percentile": 0.74422}, "CVE-2000-0644": {"epss_score": 0.07999, "epss_percentile": 0.91816}, "CVE-2000-0645": {"epss_score": 0.0398, "epss_percentile": 0.88057}, "CVE-2000-0646": {"epss_score": 0.00721, "epss_percentile": 0.71978}, "CVE-2000-0647": {"epss_score": 0.04473, "epss_percentile": 0.88736}, "CVE-2000-0648": {"epss_score": 0.01393, "epss_percentile": 0.79966}, "CVE-2000-0649": {"epss_score": 0.62987, "epss_percentile": 0.98315}, "CVE-2000-0650": {"epss_score": 0.00094, "epss_percentile": 0.26996}, "CVE-2000-0651": {"epss_score": 0.00503, "epss_percentile": 0.65448}, "CVE-2000-0652": {"epss_score": 0.04191, "epss_percentile": 0.88376}, "CVE-2000-0653": {"epss_score": 0.50286, "epss_percentile": 0.97731}, "CVE-2000-0654": {"epss_score": 0.01015, "epss_percentile": 0.76663}, "CVE-2000-0655": {"epss_score": 0.15249, "epss_percentile": 0.94392}, "CVE-2000-0656": {"epss_score": 0.06919, "epss_percentile": 0.91116}, "CVE-2000-0657": {"epss_score": 0.01194, "epss_percentile": 0.78425}, "CVE-2000-0658": {"epss_score": 0.01194, "epss_percentile": 0.78425}, "CVE-2000-0659": {"epss_score": 0.00747, "epss_percentile": 0.72554}, "CVE-2000-0660": {"epss_score": 0.04941, "epss_percentile": 0.89307}, "CVE-2000-0661": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2000-0662": {"epss_score": 0.27979, "epss_percentile": 0.963}, "CVE-2000-0663": {"epss_score": 0.00915, "epss_percentile": 0.75408}, "CVE-2000-0664": {"epss_score": 0.05526, "epss_percentile": 0.89962}, "CVE-2000-0665": {"epss_score": 0.7167, "epss_percentile": 0.98677}, "CVE-2000-0666": {"epss_score": 0.34567, "epss_percentile": 0.96857}, "CVE-2000-0667": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2000-0668": {"epss_score": 0.04092, "epss_percentile": 0.88238}, "CVE-2000-0669": {"epss_score": 0.02192, "epss_percentile": 0.83943}, "CVE-2000-0670": {"epss_score": 0.03016, "epss_percentile": 0.86214}, "CVE-2000-0671": {"epss_score": 0.05103, "epss_percentile": 0.89503}, "CVE-2000-0672": {"epss_score": 0.03158, "epss_percentile": 0.86519}, "CVE-2000-0673": {"epss_score": 0.20252, "epss_percentile": 0.95308}, "CVE-2000-0674": {"epss_score": 0.00808, "epss_percentile": 0.73688}, "CVE-2000-0675": {"epss_score": 0.09024, "epss_percentile": 0.92372}, "CVE-2000-0676": {"epss_score": 0.25173, "epss_percentile": 0.95993}, "CVE-2000-0677": {"epss_score": 0.06033, "epss_percentile": 0.90424}, "CVE-2000-0678": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2000-0679": {"epss_score": 0.0038, "epss_percentile": 0.5894}, "CVE-2000-0680": {"epss_score": 0.00363, "epss_percentile": 0.57866}, "CVE-2000-0681": {"epss_score": 0.151, "epss_percentile": 0.94361}, "CVE-2000-0682": {"epss_score": 0.00599, "epss_percentile": 0.68804}, "CVE-2000-0683": {"epss_score": 0.00599, "epss_percentile": 0.68804}, "CVE-2000-0684": {"epss_score": 0.05202, "epss_percentile": 0.89607}, "CVE-2000-0685": {"epss_score": 0.05202, "epss_percentile": 0.89607}, "CVE-2000-0686": {"epss_score": 0.00721, "epss_percentile": 0.71978}, "CVE-2000-0687": {"epss_score": 0.01005, "epss_percentile": 0.76535}, "CVE-2000-0688": {"epss_score": 0.06785, "epss_percentile": 0.91026}, "CVE-2000-0689": {"epss_score": 0.08447, "epss_percentile": 0.92055}, "CVE-2000-0690": {"epss_score": 0.05424, "epss_percentile": 0.89865}, "CVE-2000-0691": {"epss_score": 0.00248, "epss_percentile": 0.47966}, "CVE-2000-0692": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-2000-0693": {"epss_score": 0.00127, "epss_percentile": 0.32833}, "CVE-2000-0694": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2000-0695": {"epss_score": 0.00151, "epss_percentile": 0.36189}, "CVE-2000-0696": {"epss_score": 0.0938, "epss_percentile": 0.92524}, "CVE-2000-0697": {"epss_score": 0.15921, "epss_percentile": 0.94535}, "CVE-2000-0698": {"epss_score": 0.02651, "epss_percentile": 0.85345}, "CVE-2000-0699": {"epss_score": 0.04449, "epss_percentile": 0.88702}, "CVE-2000-0700": {"epss_score": 0.00434, "epss_percentile": 0.62307}, "CVE-2000-0701": {"epss_score": 0.0008, "epss_percentile": 0.24118}, "CVE-2000-0702": {"epss_score": 0.00247, "epss_percentile": 0.47847}, "CVE-2000-0703": {"epss_score": 0.00307, "epss_percentile": 0.53504}, "CVE-2000-0704": {"epss_score": 0.06312, "epss_percentile": 0.90664}, "CVE-2000-0705": {"epss_score": 0.05315, "epss_percentile": 0.89721}, "CVE-2000-0706": {"epss_score": 0.06013, "epss_percentile": 0.9041}, "CVE-2000-0707": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2000-0708": {"epss_score": 0.0551, "epss_percentile": 0.89946}, "CVE-2000-0709": {"epss_score": 0.24968, "epss_percentile": 0.95972}, "CVE-2000-0710": {"epss_score": 0.55141, "epss_percentile": 0.97963}, "CVE-2000-0711": {"epss_score": 0.06754, "epss_percentile": 0.91004}, "CVE-2000-0712": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2000-0713": {"epss_score": 0.05134, "epss_percentile": 0.89534}, "CVE-2000-0714": {"epss_score": 0.00052, "epss_percentile": 0.16474}, "CVE-2000-0715": {"epss_score": 0.00057, "epss_percentile": 0.18139}, "CVE-2000-0716": {"epss_score": 0.00417, "epss_percentile": 0.61256}, "CVE-2000-0717": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2000-0718": {"epss_score": 0.00057, "epss_percentile": 0.18127}, "CVE-2000-0719": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2000-0720": {"epss_score": 0.03638, "epss_percentile": 0.87485}, "CVE-2000-0721": {"epss_score": 0.00396, "epss_percentile": 0.5989}, "CVE-2000-0722": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2000-0723": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2000-0724": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2000-0725": {"epss_score": 0.00055, "epss_percentile": 0.17623}, "CVE-2000-0726": {"epss_score": 0.00396, "epss_percentile": 0.59904}, "CVE-2000-0727": {"epss_score": 0.00795, "epss_percentile": 0.73469}, "CVE-2000-0728": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2000-0729": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2000-0730": {"epss_score": 0.00086, "epss_percentile": 0.25376}, "CVE-2000-0731": {"epss_score": 0.00987, "epss_percentile": 0.76347}, "CVE-2000-0732": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2000-0733": {"epss_score": 0.0561, "epss_percentile": 0.90046}, "CVE-2000-0734": {"epss_score": 0.04021, "epss_percentile": 0.88133}, "CVE-2000-0735": {"epss_score": 0.00806, "epss_percentile": 0.73655}, "CVE-2000-0736": {"epss_score": 0.00806, "epss_percentile": 0.73655}, "CVE-2000-0737": {"epss_score": 0.01568, "epss_percentile": 0.81079}, "CVE-2000-0738": {"epss_score": 0.00782, "epss_percentile": 0.73197}, "CVE-2000-0739": {"epss_score": 0.04597, "epss_percentile": 0.88899}, "CVE-2000-0740": {"epss_score": 0.0856, "epss_percentile": 0.92126}, "CVE-2000-0741": {"epss_score": 0.06677, "epss_percentile": 0.90937}, "CVE-2000-0742": {"epss_score": 0.19456, "epss_percentile": 0.95185}, "CVE-2000-0743": {"epss_score": 0.05393, "epss_percentile": 0.89825}, "CVE-2000-0745": {"epss_score": 0.0011, "epss_percentile": 0.3019}, "CVE-2000-0746": {"epss_score": 0.18278, "epss_percentile": 0.94987}, "CVE-2000-0747": {"epss_score": 0.00461, "epss_percentile": 0.63564}, "CVE-2000-0748": {"epss_score": 0.00078, "epss_percentile": 0.23626}, "CVE-2000-0749": {"epss_score": 0.0005, "epss_percentile": 0.15721}, "CVE-2000-0750": {"epss_score": 0.01688, "epss_percentile": 0.81763}, "CVE-2000-0751": {"epss_score": 0.17701, "epss_percentile": 0.94892}, "CVE-2000-0752": {"epss_score": 0.00043, "epss_percentile": 0.12971}, "CVE-2000-0753": {"epss_score": 0.18497, "epss_percentile": 0.95024}, "CVE-2000-0754": {"epss_score": 0.00244, "epss_percentile": 0.47551}, "CVE-2000-0755": {"epss_score": 0.00086, "epss_percentile": 0.25376}, "CVE-2000-0756": {"epss_score": 0.11679, "epss_percentile": 0.93444}, "CVE-2000-0757": {"epss_score": 0.01912, "epss_percentile": 0.8283}, "CVE-2000-0758": {"epss_score": 0.00074, "epss_percentile": 0.2281}, "CVE-2000-0759": {"epss_score": 0.39817, "epss_percentile": 0.97181}, "CVE-2000-0760": {"epss_score": 0.38569, "epss_percentile": 0.97106}, "CVE-2000-0761": {"epss_score": 0.00891, "epss_percentile": 0.75052}, "CVE-2000-0762": {"epss_score": 0.01043, "epss_percentile": 0.76997}, "CVE-2000-0763": {"epss_score": 0.00325, "epss_percentile": 0.54984}, "CVE-2000-0764": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2000-0765": {"epss_score": 0.10691, "epss_percentile": 0.93071}, "CVE-2000-0766": {"epss_score": 0.0491, "epss_percentile": 0.8928}, "CVE-2000-0767": {"epss_score": 0.12567, "epss_percentile": 0.93717}, "CVE-2000-0768": {"epss_score": 0.16317, "epss_percentile": 0.94629}, "CVE-2000-0769": {"epss_score": 0.00569, "epss_percentile": 0.67931}, "CVE-2000-0770": {"epss_score": 0.01619, "epss_percentile": 0.81379}, "CVE-2000-0771": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2000-0772": {"epss_score": 0.00489, "epss_percentile": 0.64872}, "CVE-2000-0773": {"epss_score": 0.00223, "epss_percentile": 0.44877}, "CVE-2000-0774": {"epss_score": 0.00394, "epss_percentile": 0.59771}, "CVE-2000-0775": {"epss_score": 0.12184, "epss_percentile": 0.93597}, "CVE-2000-0776": {"epss_score": 0.09142, "epss_percentile": 0.92419}, "CVE-2000-0777": {"epss_score": 0.00365, "epss_percentile": 0.57965}, "CVE-2000-0778": {"epss_score": 0.78624, "epss_percentile": 0.98994}, "CVE-2000-0779": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-2000-0780": {"epss_score": 0.02073, "epss_percentile": 0.83495}, "CVE-2000-0781": {"epss_score": 0.00063, "epss_percentile": 0.20095}, "CVE-2000-0782": {"epss_score": 0.05103, "epss_percentile": 0.89503}, "CVE-2000-0783": {"epss_score": 0.00824, "epss_percentile": 0.73937}, "CVE-2000-0784": {"epss_score": 0.02459, "epss_percentile": 0.84817}, "CVE-2000-0785": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-2000-0786": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2000-0787": {"epss_score": 0.12341, "epss_percentile": 0.93645}, "CVE-2000-0788": {"epss_score": 0.10498, "epss_percentile": 0.9301}, "CVE-2000-0789": {"epss_score": 0.00034, "epss_percentile": 0.09696}, "CVE-2000-0790": {"epss_score": 0.01421, "epss_percentile": 0.80174}, "CVE-2000-0791": {"epss_score": 0.0004, "epss_percentile": 0.12084}, "CVE-2000-0792": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2000-0793": {"epss_score": 0.00432, "epss_percentile": 0.62101}, "CVE-2000-0794": {"epss_score": 0.00473, "epss_percentile": 0.64087}, "CVE-2000-0795": {"epss_score": 0.00426, "epss_percentile": 0.61765}, "CVE-2000-0796": {"epss_score": 0.00536, "epss_percentile": 0.66867}, "CVE-2000-0797": {"epss_score": 0.00536, "epss_percentile": 0.66867}, "CVE-2000-0798": {"epss_score": 0.02177, "epss_percentile": 0.83886}, "CVE-2000-0799": {"epss_score": 0.00453, "epss_percentile": 0.63215}, "CVE-2000-0800": {"epss_score": 0.02879, "epss_percentile": 0.85894}, "CVE-2000-0801": {"epss_score": 0.00054, "epss_percentile": 0.17232}, "CVE-2000-0802": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2000-0803": {"epss_score": 0.00837, "epss_percentile": 0.74161}, "CVE-2000-0804": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-2000-0805": {"epss_score": 0.00552, "epss_percentile": 0.67387}, "CVE-2000-0806": {"epss_score": 0.00526, "epss_percentile": 0.664}, "CVE-2000-0807": {"epss_score": 0.00856, "epss_percentile": 0.74474}, "CVE-2000-0808": {"epss_score": 0.00515, "epss_percentile": 0.65986}, "CVE-2000-0809": {"epss_score": 0.00806, "epss_percentile": 0.73655}, "CVE-2000-0810": {"epss_score": 0.00628, "epss_percentile": 0.69645}, "CVE-2000-0811": {"epss_score": 0.0073, "epss_percentile": 0.72142}, "CVE-2000-0812": {"epss_score": 0.02547, "epss_percentile": 0.85066}, "CVE-2000-0813": {"epss_score": 0.00412, "epss_percentile": 0.60938}, "CVE-2000-0816": {"epss_score": 0.00217, "epss_percentile": 0.44321}, "CVE-2000-0817": {"epss_score": 0.13402, "epss_percentile": 0.93953}, "CVE-2000-0818": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2000-0824": {"epss_score": 0.00306, "epss_percentile": 0.53445}, "CVE-2000-0825": {"epss_score": 0.02836, "epss_percentile": 0.8579}, "CVE-2000-0826": {"epss_score": 0.02326, "epss_percentile": 0.8439}, "CVE-2000-0827": {"epss_score": 0.03164, "epss_percentile": 0.86537}, "CVE-2000-0828": {"epss_score": 0.05723, "epss_percentile": 0.90154}, "CVE-2000-0829": {"epss_score": 0.00441, "epss_percentile": 0.62691}, "CVE-2000-0830": {"epss_score": 0.24555, "epss_percentile": 0.95933}, "CVE-2000-0831": {"epss_score": 0.00905, "epss_percentile": 0.75245}, "CVE-2000-0832": {"epss_score": 0.00763, "epss_percentile": 0.72882}, "CVE-2000-0833": {"epss_score": 0.04298, "epss_percentile": 0.88511}, "CVE-2000-0834": {"epss_score": 0.34051, "epss_percentile": 0.96824}, "CVE-2000-0835": {"epss_score": 0.0363, "epss_percentile": 0.87472}, "CVE-2000-0836": {"epss_score": 0.08316, "epss_percentile": 0.91988}, "CVE-2000-0837": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2000-0838": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0839": {"epss_score": 0.02073, "epss_percentile": 0.83494}, "CVE-2000-0840": {"epss_score": 0.01672, "epss_percentile": 0.81681}, "CVE-2000-0841": {"epss_score": 0.02378, "epss_percentile": 0.84559}, "CVE-2000-0842": {"epss_score": 0.00528, "epss_percentile": 0.66554}, "CVE-2000-0843": {"epss_score": 0.04026, "epss_percentile": 0.88143}, "CVE-2000-0844": {"epss_score": 0.00891, "epss_percentile": 0.75054}, "CVE-2000-0845": {"epss_score": 0.00271, "epss_percentile": 0.50304}, "CVE-2000-0846": {"epss_score": 0.09024, "epss_percentile": 0.92372}, "CVE-2000-0847": {"epss_score": 0.01433, "epss_percentile": 0.8026}, "CVE-2000-0848": {"epss_score": 0.08473, "epss_percentile": 0.92071}, "CVE-2000-0849": {"epss_score": 0.09556, "epss_percentile": 0.92597}, "CVE-2000-0850": {"epss_score": 0.00515, "epss_percentile": 0.65986}, "CVE-2000-0851": {"epss_score": 0.02852, "epss_percentile": 0.85831}, "CVE-2000-0852": {"epss_score": 0.0005, "epss_percentile": 0.15721}, "CVE-2000-0853": {"epss_score": 0.04092, "epss_percentile": 0.88241}, "CVE-2000-0854": {"epss_score": 0.28413, "epss_percentile": 0.96355}, "CVE-2000-0855": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-2000-0856": {"epss_score": 0.01226, "epss_percentile": 0.78689}, "CVE-2000-0857": {"epss_score": 0.01603, "epss_percentile": 0.81277}, "CVE-2000-0858": {"epss_score": 0.20398, "epss_percentile": 0.95338}, "CVE-2000-0859": {"epss_score": 0.00651, "epss_percentile": 0.70301}, "CVE-2000-0860": {"epss_score": 0.01107, "epss_percentile": 0.77629}, "CVE-2000-0861": {"epss_score": 0.00055, "epss_percentile": 0.17458}, "CVE-2000-0862": {"epss_score": 0.00429, "epss_percentile": 0.61999}, "CVE-2000-0863": {"epss_score": 0.00049, "epss_percentile": 0.15455}, "CVE-2000-0864": {"epss_score": 0.0005, "epss_percentile": 0.15889}, "CVE-2000-0865": {"epss_score": 0.00364, "epss_percentile": 0.57933}, "CVE-2000-0866": {"epss_score": 0.0007, "epss_percentile": 0.21978}, "CVE-2000-0867": {"epss_score": 0.00071, "epss_percentile": 0.22073}, "CVE-2000-0868": {"epss_score": 0.08808, "epss_percentile": 0.92263}, "CVE-2000-0869": {"epss_score": 0.10568, "epss_percentile": 0.9303}, "CVE-2000-0870": {"epss_score": 0.00808, "epss_percentile": 0.73685}, "CVE-2000-0871": {"epss_score": 0.00998, "epss_percentile": 0.76468}, "CVE-2000-0872": {"epss_score": 0.04092, "epss_percentile": 0.88241}, "CVE-2000-0873": {"epss_score": 0.01164, "epss_percentile": 0.78163}, "CVE-2000-0874": {"epss_score": 0.00512, "epss_percentile": 0.65851}, "CVE-2000-0875": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2000-0876": {"epss_score": 0.0073, "epss_percentile": 0.72142}, "CVE-2000-0877": {"epss_score": 0.00791, "epss_percentile": 0.73393}, "CVE-2000-0878": {"epss_score": 0.01221, "epss_percentile": 0.78648}, "CVE-2000-0879": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2000-0880": {"epss_score": 0.00133, "epss_percentile": 0.33643}, "CVE-2000-0881": {"epss_score": 0.0015, "epss_percentile": 0.36129}, "CVE-2000-0882": {"epss_score": 0.0057, "epss_percentile": 0.6797}, "CVE-2000-0883": {"epss_score": 0.05259, "epss_percentile": 0.89668}, "CVE-2000-0884": {"epss_score": 0.827, "epss_percentile": 0.99208}, "CVE-2000-0885": {"epss_score": 0.24682, "epss_percentile": 0.95946}, "CVE-2000-0886": {"epss_score": 0.89218, "epss_percentile": 0.99516}, "CVE-2000-0887": {"epss_score": 0.173, "epss_percentile": 0.94818}, "CVE-2000-0888": {"epss_score": 0.15771, "epss_percentile": 0.94507}, "CVE-2000-0889": {"epss_score": 0.00271, "epss_percentile": 0.50315}, "CVE-2000-0890": {"epss_score": 0.00167, "epss_percentile": 0.38295}, "CVE-2000-0891": {"epss_score": 0.01836, "epss_percentile": 0.8247}, "CVE-2000-0892": {"epss_score": 0.00488, "epss_percentile": 0.64859}, "CVE-2000-0893": {"epss_score": 0.01352, "epss_percentile": 0.79692}, "CVE-2000-0894": {"epss_score": 0.00411, "epss_percentile": 0.60857}, "CVE-2000-0895": {"epss_score": 0.03575, "epss_percentile": 0.87379}, "CVE-2000-0896": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2000-0897": {"epss_score": 0.05785, "epss_percentile": 0.90206}, "CVE-2000-0898": {"epss_score": 0.00583, "epss_percentile": 0.68329}, "CVE-2000-0899": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0900": {"epss_score": 0.01189, "epss_percentile": 0.78372}, "CVE-2000-0901": {"epss_score": 0.00269, "epss_percentile": 0.50185}, "CVE-2000-0902": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-2000-0903": {"epss_score": 0.03178, "epss_percentile": 0.86575}, "CVE-2000-0904": {"epss_score": 0.03178, "epss_percentile": 0.86575}, "CVE-2000-0905": {"epss_score": 0.00891, "epss_percentile": 0.75055}, "CVE-2000-0906": {"epss_score": 0.08832, "epss_percentile": 0.92273}, "CVE-2000-0907": {"epss_score": 0.02164, "epss_percentile": 0.83837}, "CVE-2000-0908": {"epss_score": 0.08939, "epss_percentile": 0.92328}, "CVE-2000-0909": {"epss_score": 0.11039, "epss_percentile": 0.93197}, "CVE-2000-0910": {"epss_score": 0.001, "epss_percentile": 0.28533}, "CVE-2000-0911": {"epss_score": 0.00515, "epss_percentile": 0.66006}, "CVE-2000-0912": {"epss_score": 0.06044, "epss_percentile": 0.90431}, "CVE-2000-0913": {"epss_score": 0.06177, "epss_percentile": 0.90535}, "CVE-2000-0914": {"epss_score": 0.07653, "epss_percentile": 0.91606}, "CVE-2000-0915": {"epss_score": 0.01094, "epss_percentile": 0.77487}, "CVE-2000-0916": {"epss_score": 0.08349, "epss_percentile": 0.92004}, "CVE-2000-0917": {"epss_score": 0.86092, "epss_percentile": 0.99365}, "CVE-2000-0918": {"epss_score": 0.00061, "epss_percentile": 0.19416}, "CVE-2000-0919": {"epss_score": 0.05103, "epss_percentile": 0.89503}, "CVE-2000-0920": {"epss_score": 0.06558, "epss_percentile": 0.90847}, "CVE-2000-0921": {"epss_score": 0.05103, "epss_percentile": 0.89503}, "CVE-2000-0922": {"epss_score": 0.05247, "epss_percentile": 0.89662}, "CVE-2000-0923": {"epss_score": 0.02126, "epss_percentile": 0.83692}, "CVE-2000-0924": {"epss_score": 0.05103, "epss_percentile": 0.89503}, "CVE-2000-0925": {"epss_score": 0.059, "epss_percentile": 0.90308}, "CVE-2000-0926": {"epss_score": 0.0681, "epss_percentile": 0.91041}, "CVE-2000-0927": {"epss_score": 0.00077, "epss_percentile": 0.23297}, "CVE-2000-0928": {"epss_score": 0.00111, "epss_percentile": 0.30393}, "CVE-2000-0929": {"epss_score": 0.21368, "epss_percentile": 0.9551}, "CVE-2000-0930": {"epss_score": 0.05103, "epss_percentile": 0.89503}, "CVE-2000-0931": {"epss_score": 0.01226, "epss_percentile": 0.78689}, "CVE-2000-0932": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-0933": {"epss_score": 0.03431, "epss_percentile": 0.87124}, "CVE-2000-0934": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2000-0935": {"epss_score": 0.00418, "epss_percentile": 0.61274}, "CVE-2000-0936": {"epss_score": 0.0075, "epss_percentile": 0.72612}, "CVE-2000-0937": {"epss_score": 0.03844, "epss_percentile": 0.87837}, "CVE-2000-0938": {"epss_score": 0.00669, "epss_percentile": 0.70767}, "CVE-2000-0939": {"epss_score": 0.00703, "epss_percentile": 0.71528}, "CVE-2000-0940": {"epss_score": 0.00612, "epss_percentile": 0.69239}, "CVE-2000-0941": {"epss_score": 0.13456, "epss_percentile": 0.93971}, "CVE-2000-0942": {"epss_score": 0.36878, "epss_percentile": 0.97007}, "CVE-2000-0943": {"epss_score": 0.02314, "epss_percentile": 0.84352}, "CVE-2000-0944": {"epss_score": 0.1071, "epss_percentile": 0.9308}, "CVE-2000-0945": {"epss_score": 0.87926, "epss_percentile": 0.9945}, "CVE-2000-0946": {"epss_score": 0.00077, "epss_percentile": 0.23297}, "CVE-2000-0947": {"epss_score": 0.00921, "epss_percentile": 0.75476}, "CVE-2000-0948": {"epss_score": 0.00064, "epss_percentile": 0.20295}, "CVE-2000-0949": {"epss_score": 0.00192, "epss_percentile": 0.41303}, "CVE-2000-0950": {"epss_score": 0.00061, "epss_percentile": 0.19416}, "CVE-2000-0951": {"epss_score": 0.49168, "epss_percentile": 0.97672}, "CVE-2000-0952": {"epss_score": 0.01633, "epss_percentile": 0.81462}, "CVE-2000-0953": {"epss_score": 0.05587, "epss_percentile": 0.90026}, "CVE-2000-0954": {"epss_score": 0.004, "epss_percentile": 0.60168}, "CVE-2000-0955": {"epss_score": 0.07495, "epss_percentile": 0.91501}, "CVE-2000-0956": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2000-0957": {"epss_score": 0.00489, "epss_percentile": 0.64868}, "CVE-2000-0958": {"epss_score": 0.0363, "epss_percentile": 0.87472}, "CVE-2000-0959": {"epss_score": 0.00089, "epss_percentile": 0.25928}, "CVE-2000-0960": {"epss_score": 0.00861, "epss_percentile": 0.74559}, "CVE-2000-0961": {"epss_score": 0.00588, "epss_percentile": 0.68489}, "CVE-2000-0962": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2000-0963": {"epss_score": 0.00156, "epss_percentile": 0.36918}, "CVE-2000-0964": {"epss_score": 0.01706, "epss_percentile": 0.81856}, "CVE-2000-0965": {"epss_score": 0.005, "epss_percentile": 0.65296}, "CVE-2000-0966": {"epss_score": 0.00117, "epss_percentile": 0.31365}, "CVE-2000-0967": {"epss_score": 0.26914, "epss_percentile": 0.96191}, "CVE-2000-0968": {"epss_score": 0.02859, "epss_percentile": 0.85848}, "CVE-2000-0969": {"epss_score": 0.02704, "epss_percentile": 0.8546}, "CVE-2000-0970": {"epss_score": 0.3846, "epss_percentile": 0.97101}, "CVE-2000-0971": {"epss_score": 0.07856, "epss_percentile": 0.91723}, "CVE-2000-0972": {"epss_score": 0.01712, "epss_percentile": 0.81886}, "CVE-2000-0973": {"epss_score": 0.27837, "epss_percentile": 0.96286}, "CVE-2000-0974": {"epss_score": 0.01825, "epss_percentile": 0.82431}, "CVE-2000-0975": {"epss_score": 0.06958, "epss_percentile": 0.91148}, "CVE-2000-0976": {"epss_score": 0.0068, "epss_percentile": 0.71033}, "CVE-2000-0977": {"epss_score": 0.04092, "epss_percentile": 0.88241}, "CVE-2000-0978": {"epss_score": 0.01221, "epss_percentile": 0.78648}, "CVE-2000-0979": {"epss_score": 0.11621, "epss_percentile": 0.93422}, "CVE-2000-0980": {"epss_score": 0.07344, "epss_percentile": 0.91421}, "CVE-2000-0981": {"epss_score": 0.0107, "epss_percentile": 0.77253}, "CVE-2000-0982": {"epss_score": 0.10205, "epss_percentile": 0.92892}, "CVE-2000-0983": {"epss_score": 0.20227, "epss_percentile": 0.95306}, "CVE-2000-0984": {"epss_score": 0.40356, "epss_percentile": 0.97214}, "CVE-2000-0985": {"epss_score": 0.05964, "epss_percentile": 0.90368}, "CVE-2000-0986": {"epss_score": 0.00287, "epss_percentile": 0.51805}, "CVE-2000-0987": {"epss_score": 0.00243, "epss_percentile": 0.47497}, "CVE-2000-0988": {"epss_score": 0.00649, "epss_percentile": 0.70229}, "CVE-2000-0989": {"epss_score": 0.1151, "epss_percentile": 0.93389}, "CVE-2000-0990": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2000-0991": {"epss_score": 0.09142, "epss_percentile": 0.92419}, "CVE-2000-0992": {"epss_score": 0.02826, "epss_percentile": 0.85765}, "CVE-2000-0993": {"epss_score": 0.0023, "epss_percentile": 0.45731}, "CVE-2000-0994": {"epss_score": 0.00139, "epss_percentile": 0.34598}, "CVE-2000-0995": {"epss_score": 0.00073, "epss_percentile": 0.22483}, "CVE-2000-0996": {"epss_score": 0.00064, "epss_percentile": 0.20431}, "CVE-2000-0997": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2000-0998": {"epss_score": 0.00258, "epss_percentile": 0.48987}, "CVE-2000-0999": {"epss_score": 0.00418, "epss_percentile": 0.61272}, "CVE-2000-1000": {"epss_score": 0.01258, "epss_percentile": 0.78952}, "CVE-2000-1001": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2000-1002": {"epss_score": 0.04092, "epss_percentile": 0.88241}, "CVE-2000-1003": {"epss_score": 0.09556, "epss_percentile": 0.92597}, "CVE-2000-1004": {"epss_score": 0.00088, "epss_percentile": 0.25714}, "CVE-2000-1005": {"epss_score": 0.06201, "epss_percentile": 0.9056}, "CVE-2000-1006": {"epss_score": 0.09991, "epss_percentile": 0.92807}, "CVE-2000-1007": {"epss_score": 0.00599, "epss_percentile": 0.68794}, "CVE-2000-1008": {"epss_score": 0.00227, "epss_percentile": 0.45371}, "CVE-2000-1009": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2000-1010": {"epss_score": 0.01633, "epss_percentile": 0.81462}, "CVE-2000-1011": {"epss_score": 0.00053, "epss_percentile": 0.16821}, "CVE-2000-1012": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2000-1013": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2000-1014": {"epss_score": 0.08695, "epss_percentile": 0.92207}, "CVE-2000-1015": {"epss_score": 0.01221, "epss_percentile": 0.78648}, "CVE-2000-1016": {"epss_score": 0.04264, "epss_percentile": 0.88467}, "CVE-2000-1017": {"epss_score": 0.00808, "epss_percentile": 0.73688}, "CVE-2000-1018": {"epss_score": 0.00102, "epss_percentile": 0.28834}, "CVE-2000-1019": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2000-1020": {"epss_score": 0.01331, "epss_percentile": 0.79515}, "CVE-2000-1021": {"epss_score": 0.09525, "epss_percentile": 0.92586}, "CVE-2000-1022": {"epss_score": 0.07181, "epss_percentile": 0.91302}, "CVE-2000-1023": {"epss_score": 0.03638, "epss_percentile": 0.87485}, "CVE-2000-1024": {"epss_score": 0.02323, "epss_percentile": 0.84377}, "CVE-2000-1025": {"epss_score": 0.05587, "epss_percentile": 0.90026}, "CVE-2000-1026": {"epss_score": 0.05328, "epss_percentile": 0.89737}, "CVE-2000-1027": {"epss_score": 0.13438, "epss_percentile": 0.93963}, "CVE-2000-1028": {"epss_score": 0.00203, "epss_percentile": 0.42553}, "CVE-2000-1029": {"epss_score": 0.09288, "epss_percentile": 0.92485}, "CVE-2000-1030": {"epss_score": 0.00631, "epss_percentile": 0.69719}, "CVE-2000-1031": {"epss_score": 0.00417, "epss_percentile": 0.61256}, "CVE-2000-1032": {"epss_score": 0.0118, "epss_percentile": 0.78304}, "CVE-2000-1033": {"epss_score": 0.03792, "epss_percentile": 0.87732}, "CVE-2000-1034": {"epss_score": 0.22076, "epss_percentile": 0.95592}, "CVE-2000-1035": {"epss_score": 0.08512, "epss_percentile": 0.92096}, "CVE-2000-1036": {"epss_score": 0.10059, "epss_percentile": 0.92835}, "CVE-2000-1037": {"epss_score": 0.09143, "epss_percentile": 0.9242}, "CVE-2000-1038": {"epss_score": 0.00786, "epss_percentile": 0.73271}, "CVE-2000-1039": {"epss_score": 0.44877, "epss_percentile": 0.97457}, "CVE-2000-1040": {"epss_score": 0.0184, "epss_percentile": 0.82492}, "CVE-2000-1041": {"epss_score": 0.00388, "epss_percentile": 0.5937}, "CVE-2000-1042": {"epss_score": 0.00498, "epss_percentile": 0.65216}, "CVE-2000-1043": {"epss_score": 0.00461, "epss_percentile": 0.63564}, "CVE-2000-1044": {"epss_score": 0.00452, "epss_percentile": 0.63176}, "CVE-2000-1045": {"epss_score": 0.00279, "epss_percentile": 0.50993}, "CVE-2000-1046": {"epss_score": 0.08176, "epss_percentile": 0.91915}, "CVE-2000-1047": {"epss_score": 0.028, "epss_percentile": 0.85696}, "CVE-2000-1048": {"epss_score": 0.01213, "epss_percentile": 0.78567}, "CVE-2000-1049": {"epss_score": 0.00783, "epss_percentile": 0.73225}, "CVE-2000-1050": {"epss_score": 0.13601, "epss_percentile": 0.94007}, "CVE-2000-1051": {"epss_score": 0.01005, "epss_percentile": 0.76545}, "CVE-2000-1052": {"epss_score": 0.00643, "epss_percentile": 0.70065}, "CVE-2000-1053": {"epss_score": 0.08849, "epss_percentile": 0.92284}, "CVE-2000-1054": {"epss_score": 0.08435, "epss_percentile": 0.92051}, "CVE-2000-1055": {"epss_score": 0.01521, "epss_percentile": 0.80832}, "CVE-2000-1056": {"epss_score": 0.00515, "epss_percentile": 0.65986}, "CVE-2000-1057": {"epss_score": 0.0007, "epss_percentile": 0.21802}, "CVE-2000-1058": {"epss_score": 0.07334, "epss_percentile": 0.91416}, "CVE-2000-1059": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2000-1060": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2000-1061": {"epss_score": 0.15121, "epss_percentile": 0.94368}, "CVE-2000-1062": {"epss_score": 0.00644, "epss_percentile": 0.70075}, "CVE-2000-1063": {"epss_score": 0.00644, "epss_percentile": 0.70075}, "CVE-2000-1064": {"epss_score": 0.00644, "epss_percentile": 0.70075}, "CVE-2000-1065": {"epss_score": 0.0059, "epss_percentile": 0.68568}, "CVE-2000-1066": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2000-1068": {"epss_score": 0.02323, "epss_percentile": 0.84377}, "CVE-2000-1069": {"epss_score": 0.06853, "epss_percentile": 0.91074}, "CVE-2000-1070": {"epss_score": 0.00559, "epss_percentile": 0.67618}, "CVE-2000-1071": {"epss_score": 0.01148, "epss_percentile": 0.78011}, "CVE-2000-1072": {"epss_score": 0.00221, "epss_percentile": 0.447}, "CVE-2000-1073": {"epss_score": 0.00062, "epss_percentile": 0.19699}, "CVE-2000-1074": {"epss_score": 0.06463, "epss_percentile": 0.90772}, "CVE-2000-1075": {"epss_score": 0.04012, "epss_percentile": 0.88113}, "CVE-2000-1076": {"epss_score": 0.00514, "epss_percentile": 0.6595}, "CVE-2000-1077": {"epss_score": 0.02445, "epss_percentile": 0.84765}, "CVE-2000-1078": {"epss_score": 0.05367, "epss_percentile": 0.89791}, "CVE-2000-1079": {"epss_score": 0.20994, "epss_percentile": 0.95448}, "CVE-2000-1080": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2000-1081": {"epss_score": 0.06835, "epss_percentile": 0.91058}, "CVE-2000-1082": {"epss_score": 0.43145, "epss_percentile": 0.97372}, "CVE-2000-1083": {"epss_score": 0.04707, "epss_percentile": 0.89034}, "CVE-2000-1084": {"epss_score": 0.43145, "epss_percentile": 0.97372}, "CVE-2000-1085": {"epss_score": 0.10685, "epss_percentile": 0.9307}, "CVE-2000-1086": {"epss_score": 0.43145, "epss_percentile": 0.97372}, "CVE-2000-1087": {"epss_score": 0.43145, "epss_percentile": 0.97372}, "CVE-2000-1088": {"epss_score": 0.27845, "epss_percentile": 0.96287}, "CVE-2000-1089": {"epss_score": 0.68838, "epss_percentile": 0.98565}, "CVE-2000-1090": {"epss_score": 0.12517, "epss_percentile": 0.93704}, "CVE-2000-1092": {"epss_score": 0.04092, "epss_percentile": 0.88241}, "CVE-2000-1093": {"epss_score": 0.08455, "epss_percentile": 0.9206}, "CVE-2000-1094": {"epss_score": 0.06007, "epss_percentile": 0.90398}, "CVE-2000-1095": {"epss_score": 0.00211, "epss_percentile": 0.43617}, "CVE-2000-1096": {"epss_score": 0.00184, "epss_percentile": 0.40374}, "CVE-2000-1097": {"epss_score": 0.00491, "epss_percentile": 0.64952}, "CVE-2000-1098": {"epss_score": 0.00388, "epss_percentile": 0.59368}, "CVE-2000-1099": {"epss_score": 0.00599, "epss_percentile": 0.68801}, "CVE-2000-1100": {"epss_score": 0.02942, "epss_percentile": 0.86034}, "CVE-2000-1101": {"epss_score": 0.00235, "epss_percentile": 0.46339}, "CVE-2000-1102": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-2000-1103": {"epss_score": 0.00317, "epss_percentile": 0.54357}, "CVE-2000-1104": {"epss_score": 0.1283, "epss_percentile": 0.93796}, "CVE-2000-1105": {"epss_score": 0.31436, "epss_percentile": 0.9662}, "CVE-2000-1106": {"epss_score": 0.00058, "epss_percentile": 0.18396}, "CVE-2000-1107": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2000-1108": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2000-1109": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2000-1110": {"epss_score": 0.0636, "epss_percentile": 0.90697}, "CVE-2000-1111": {"epss_score": 0.18539, "epss_percentile": 0.9503}, "CVE-2000-1112": {"epss_score": 0.02003, "epss_percentile": 0.83225}, "CVE-2000-1113": {"epss_score": 0.13873, "epss_percentile": 0.94082}, "CVE-2000-1114": {"epss_score": 0.0551, "epss_percentile": 0.89946}, "CVE-2000-1115": {"epss_score": 0.01378, "epss_percentile": 0.7985}, "CVE-2000-1116": {"epss_score": 0.06338, "epss_percentile": 0.9068}, "CVE-2000-1117": {"epss_score": 0.01286, "epss_percentile": 0.7918}, "CVE-2000-1118": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-2000-1119": {"epss_score": 0.00157, "epss_percentile": 0.3708}, "CVE-2000-1120": {"epss_score": 0.00209, "epss_percentile": 0.43337}, "CVE-2000-1121": {"epss_score": 0.00122, "epss_percentile": 0.32086}, "CVE-2000-1122": {"epss_score": 0.00044, "epss_percentile": 0.13649}, "CVE-2000-1123": {"epss_score": 0.00044, "epss_percentile": 0.13649}, "CVE-2000-1124": {"epss_score": 0.00172, "epss_percentile": 0.38963}, "CVE-2000-1125": {"epss_score": 0.00145, "epss_percentile": 0.35369}, "CVE-2000-1126": {"epss_score": 0.00839, "epss_percentile": 0.74188}, "CVE-2000-1127": {"epss_score": 0.01471, "epss_percentile": 0.80508}, "CVE-2000-1128": {"epss_score": 0.00098, "epss_percentile": 0.27806}, "CVE-2000-1129": {"epss_score": 0.03523, "epss_percentile": 0.87291}, "CVE-2000-1130": {"epss_score": 0.0032, "epss_percentile": 0.54596}, "CVE-2000-1131": {"epss_score": 0.01214, "epss_percentile": 0.7857}, "CVE-2000-1132": {"epss_score": 0.08226, "epss_percentile": 0.91939}, "CVE-2000-1133": {"epss_score": 0.00713, "epss_percentile": 0.71798}, "CVE-2000-1134": {"epss_score": 0.00177, "epss_percentile": 0.39587}, "CVE-2000-1135": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2000-1136": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2000-1137": {"epss_score": 0.00069, "epss_percentile": 0.21477}, "CVE-2000-1138": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-2000-1139": {"epss_score": 0.06507, "epss_percentile": 0.90807}, "CVE-2000-1140": {"epss_score": 0.00581, "epss_percentile": 0.6828}, "CVE-2000-1141": {"epss_score": 0.00115, "epss_percentile": 0.30975}, "CVE-2000-1142": {"epss_score": 0.00115, "epss_percentile": 0.30975}, "CVE-2000-1143": {"epss_score": 0.00115, "epss_percentile": 0.30975}, "CVE-2000-1144": {"epss_score": 0.00602, "epss_percentile": 0.68877}, "CVE-2000-1145": {"epss_score": 0.00077, "epss_percentile": 0.23297}, "CVE-2000-1146": {"epss_score": 0.00083, "epss_percentile": 0.24628}, "CVE-2000-1147": {"epss_score": 0.03914, "epss_percentile": 0.87938}, "CVE-2000-1148": {"epss_score": 0.00051, "epss_percentile": 0.16326}, "CVE-2000-1149": {"epss_score": 0.10228, "epss_percentile": 0.92902}, "CVE-2000-1150": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2000-1151": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2000-1152": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2000-1153": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2000-1154": {"epss_score": 0.05141, "epss_percentile": 0.89538}, "CVE-2000-1155": {"epss_score": 0.00693, "epss_percentile": 0.7132}, "CVE-2000-1156": {"epss_score": 0.00073, "epss_percentile": 0.225}, "CVE-2000-1157": {"epss_score": 0.02326, "epss_percentile": 0.84389}, "CVE-2000-1158": {"epss_score": 0.00471, "epss_percentile": 0.64006}, "CVE-2000-1159": {"epss_score": 0.00821, "epss_percentile": 0.73895}, "CVE-2000-1160": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-2000-1161": {"epss_score": 0.00654, "epss_percentile": 0.7034}, "CVE-2000-1162": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2000-1163": {"epss_score": 0.00086, "epss_percentile": 0.25298}, "CVE-2000-1164": {"epss_score": 0.00307, "epss_percentile": 0.53505}, "CVE-2000-1165": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2000-1166": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2000-1167": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2000-1168": {"epss_score": 0.03303, "epss_percentile": 0.86869}, "CVE-2000-1169": {"epss_score": 0.01841, "epss_percentile": 0.82497}, "CVE-2000-1170": {"epss_score": 0.01972, "epss_percentile": 0.83107}, "CVE-2000-1171": {"epss_score": 0.04092, "epss_percentile": 0.88241}, "CVE-2000-1172": {"epss_score": 0.018, "epss_percentile": 0.82324}, "CVE-2000-1173": {"epss_score": 0.01218, "epss_percentile": 0.78607}, "CVE-2000-1174": {"epss_score": 0.09555, "epss_percentile": 0.92597}, "CVE-2000-1175": {"epss_score": 0.00178, "epss_percentile": 0.39738}, "CVE-2000-1176": {"epss_score": 0.0237, "epss_percentile": 0.84525}, "CVE-2000-1177": {"epss_score": 0.07666, "epss_percentile": 0.91611}, "CVE-2000-1178": {"epss_score": 0.00138, "epss_percentile": 0.34504}, "CVE-2000-1179": {"epss_score": 0.0087, "epss_percentile": 0.74703}, "CVE-2000-1180": {"epss_score": 0.008, "epss_percentile": 0.73534}, "CVE-2000-1181": {"epss_score": 0.07618, "epss_percentile": 0.91572}, "CVE-2000-1182": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2000-1183": {"epss_score": 0.00077, "epss_percentile": 0.23356}, "CVE-2000-1184": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2000-1185": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-2000-1186": {"epss_score": 0.13544, "epss_percentile": 0.93991}, "CVE-2000-1187": {"epss_score": 0.01433, "epss_percentile": 0.8026}, "CVE-2000-1188": {"epss_score": 0.01964, "epss_percentile": 0.83076}, "CVE-2000-1189": {"epss_score": 0.0005, "epss_percentile": 0.15721}, "CVE-2000-1190": {"epss_score": 0.00261, "epss_percentile": 0.49313}, "CVE-2000-1191": {"epss_score": 0.0143, "epss_percentile": 0.80236}, "CVE-2000-1192": {"epss_score": 0.02281, "epss_percentile": 0.84252}, "CVE-2000-1193": {"epss_score": 0.06281, "epss_percentile": 0.90638}, "CVE-2000-1194": {"epss_score": 0.02639, "epss_percentile": 0.853}, "CVE-2000-1195": {"epss_score": 0.00348, "epss_percentile": 0.56826}, "CVE-2000-1196": {"epss_score": 0.08513, "epss_percentile": 0.92096}, "CVE-2000-1197": {"epss_score": 0.00081, "epss_percentile": 0.24318}, "CVE-2000-1198": {"epss_score": 0.00257, "epss_percentile": 0.48887}, "CVE-2000-1199": {"epss_score": 0.01129, "epss_percentile": 0.77835}, "CVE-2000-1200": {"epss_score": 0.20495, "epss_percentile": 0.95355}, "CVE-2000-1201": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2000-1202": {"epss_score": 0.00089, "epss_percentile": 0.25937}, "CVE-2000-1203": {"epss_score": 0.01108, "epss_percentile": 0.77636}, "CVE-2000-1204": {"epss_score": 0.0486, "epss_percentile": 0.89221}, "CVE-2000-1205": {"epss_score": 0.05698, "epss_percentile": 0.90129}, "CVE-2000-1206": {"epss_score": 0.0308, "epss_percentile": 0.86372}, "CVE-2000-1207": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2000-1208": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2000-1209": {"epss_score": 0.89725, "epss_percentile": 0.99539}, "CVE-2000-1210": {"epss_score": 0.03925, "epss_percentile": 0.87961}, "CVE-2000-1211": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2000-1212": {"epss_score": 0.00862, "epss_percentile": 0.74583}, "CVE-2000-1213": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2000-1214": {"epss_score": 0.00198, "epss_percentile": 0.42}, "CVE-2000-1215": {"epss_score": 0.01625, "epss_percentile": 0.81419}, "CVE-2000-1216": {"epss_score": 0.00517, "epss_percentile": 0.66086}, "CVE-2000-1217": {"epss_score": 0.01385, "epss_percentile": 0.79905}, "CVE-2000-1218": {"epss_score": 0.01705, "epss_percentile": 0.81849}, "CVE-2000-1219": {"epss_score": 0.00649, "epss_percentile": 0.70242}, "CVE-2000-1220": {"epss_score": 0.0313, "epss_percentile": 0.86464}, "CVE-2000-1221": {"epss_score": 0.10859, "epss_percentile": 0.93137}, "CVE-2000-1222": {"epss_score": 0.00196, "epss_percentile": 0.41783}, "CVE-2000-1223": {"epss_score": 0.00786, "epss_percentile": 0.73293}, "CVE-2000-1224": {"epss_score": 0.08189, "epss_percentile": 0.91919}, "CVE-2000-1225": {"epss_score": 0.00362, "epss_percentile": 0.5776}, "CVE-2000-1226": {"epss_score": 0.0057, "epss_percentile": 0.6797}, "CVE-2000-1227": {"epss_score": 0.14038, "epss_percentile": 0.9412}, "CVE-2000-1228": {"epss_score": 0.06948, "epss_percentile": 0.91135}, "CVE-2000-1229": {"epss_score": 0.00576, "epss_percentile": 0.68135}, "CVE-2000-1230": {"epss_score": 0.07345, "epss_percentile": 0.91421}, "CVE-2000-1231": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2000-1232": {"epss_score": 0.00448, "epss_percentile": 0.63026}, "CVE-2000-1233": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2000-1234": {"epss_score": 0.03963, "epss_percentile": 0.88017}, "CVE-2000-1235": {"epss_score": 0.00743, "epss_percentile": 0.72474}, "CVE-2000-1236": {"epss_score": 0.00972, "epss_percentile": 0.76139}, "CVE-2000-1237": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2000-1238": {"epss_score": 0.00603, "epss_percentile": 0.68917}, "CVE-2000-1239": {"epss_score": 0.0021, "epss_percentile": 0.435}, "CVE-2000-1240": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2000-1241": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2000-1242": {"epss_score": 0.008, "epss_percentile": 0.73542}, "CVE-2000-1243": {"epss_score": 0.00393, "epss_percentile": 0.59703}, "CVE-2000-1244": {"epss_score": 0.03857, "epss_percentile": 0.87858}, "CVE-2000-1245": {"epss_score": 0.00132, "epss_percentile": 0.33507}, "CVE-2000-1246": {"epss_score": 0.01104, "epss_percentile": 0.77599}, "CVE-2000-1247": {"epss_score": 0.00152, "epss_percentile": 0.36504}, "CVE-2000-1254": {"epss_score": 0.0068, "epss_percentile": 0.71037}, "CVE-2001-0001": {"epss_score": 0.00031, "epss_percentile": 0.08568}, "CVE-2001-0002": {"epss_score": 0.25604, "epss_percentile": 0.96049}, "CVE-2001-0003": {"epss_score": 0.28716, "epss_percentile": 0.96378}, "CVE-2001-0004": {"epss_score": 0.74228, "epss_percentile": 0.98792}, "CVE-2001-0005": {"epss_score": 0.00412, "epss_percentile": 0.60945}, "CVE-2001-0006": {"epss_score": 0.00128, "epss_percentile": 0.33051}, "CVE-2001-0007": {"epss_score": 0.05795, "epss_percentile": 0.90217}, "CVE-2001-0008": {"epss_score": 0.27517, "epss_percentile": 0.96255}, "CVE-2001-0009": {"epss_score": 0.06623, "epss_percentile": 0.90897}, "CVE-2001-0010": {"epss_score": 0.82092, "epss_percentile": 0.99172}, "CVE-2001-0011": {"epss_score": 0.07069, "epss_percentile": 0.91226}, "CVE-2001-0012": {"epss_score": 0.16734, "epss_percentile": 0.94724}, "CVE-2001-0013": {"epss_score": 0.18668, "epss_percentile": 0.9505}, "CVE-2001-0014": {"epss_score": 0.20934, "epss_percentile": 0.95445}, "CVE-2001-0015": {"epss_score": 0.02886, "epss_percentile": 0.85911}, "CVE-2001-0016": {"epss_score": 0.01043, "epss_percentile": 0.76989}, "CVE-2001-0017": {"epss_score": 0.19067, "epss_percentile": 0.95123}, "CVE-2001-0018": {"epss_score": 0.39802, "epss_percentile": 0.9718}, "CVE-2001-0019": {"epss_score": 0.00073, "epss_percentile": 0.22526}, "CVE-2001-0020": {"epss_score": 0.00158, "epss_percentile": 0.37144}, "CVE-2001-0021": {"epss_score": 0.09545, "epss_percentile": 0.92592}, "CVE-2001-0022": {"epss_score": 0.05396, "epss_percentile": 0.89828}, "CVE-2001-0023": {"epss_score": 0.03406, "epss_percentile": 0.87076}, "CVE-2001-0024": {"epss_score": 0.04685, "epss_percentile": 0.89005}, "CVE-2001-0025": {"epss_score": 0.04619, "epss_percentile": 0.88929}, "CVE-2001-0026": {"epss_score": 0.12204, "epss_percentile": 0.93601}, "CVE-2001-0027": {"epss_score": 0.0082, "epss_percentile": 0.73893}, "CVE-2001-0028": {"epss_score": 0.10802, "epss_percentile": 0.93107}, "CVE-2001-0029": {"epss_score": 0.07071, "epss_percentile": 0.91228}, "CVE-2001-0030": {"epss_score": 0.00052, "epss_percentile": 0.16508}, "CVE-2001-0031": {"epss_score": 0.00763, "epss_percentile": 0.72882}, "CVE-2001-0032": {"epss_score": 0.04382, "epss_percentile": 0.88626}, "CVE-2001-0033": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2001-0034": {"epss_score": 0.00375, "epss_percentile": 0.5862}, "CVE-2001-0035": {"epss_score": 0.00847, "epss_percentile": 0.74352}, "CVE-2001-0036": {"epss_score": 0.00061, "epss_percentile": 0.19328}, "CVE-2001-0037": {"epss_score": 0.04308, "epss_percentile": 0.88528}, "CVE-2001-0038": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2001-0039": {"epss_score": 0.00167, "epss_percentile": 0.38302}, "CVE-2001-0040": {"epss_score": 0.00378, "epss_percentile": 0.58827}, "CVE-2001-0041": {"epss_score": 0.12167, "epss_percentile": 0.93588}, "CVE-2001-0042": {"epss_score": 0.22546, "epss_percentile": 0.95649}, "CVE-2001-0043": {"epss_score": 0.01614, "epss_percentile": 0.81346}, "CVE-2001-0044": {"epss_score": 0.00053, "epss_percentile": 0.16821}, "CVE-2001-0045": {"epss_score": 0.01245, "epss_percentile": 0.78842}, "CVE-2001-0046": {"epss_score": 0.00449, "epss_percentile": 0.63038}, "CVE-2001-0047": {"epss_score": 0.01173, "epss_percentile": 0.78236}, "CVE-2001-0048": {"epss_score": 0.00368, "epss_percentile": 0.58179}, "CVE-2001-0049": {"epss_score": 0.03577, "epss_percentile": 0.87381}, "CVE-2001-0050": {"epss_score": 0.18864, "epss_percentile": 0.95081}, "CVE-2001-0051": {"epss_score": 0.07214, "epss_percentile": 0.91329}, "CVE-2001-0052": {"epss_score": 0.01573, "epss_percentile": 0.81101}, "CVE-2001-0053": {"epss_score": 0.15597, "epss_percentile": 0.94467}, "CVE-2001-0054": {"epss_score": 0.05084, "epss_percentile": 0.89476}, "CVE-2001-0055": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0056": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2001-0057": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0058": {"epss_score": 0.00651, "epss_percentile": 0.70301}, "CVE-2001-0059": {"epss_score": 0.00154, "epss_percentile": 0.36727}, "CVE-2001-0060": {"epss_score": 0.01065, "epss_percentile": 0.7721}, "CVE-2001-0061": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2001-0062": {"epss_score": 0.0007, "epss_percentile": 0.21947}, "CVE-2001-0063": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2001-0064": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2001-0065": {"epss_score": 0.03393, "epss_percentile": 0.87054}, "CVE-2001-0066": {"epss_score": 0.00262, "epss_percentile": 0.49379}, "CVE-2001-0067": {"epss_score": 0.00099, "epss_percentile": 0.28358}, "CVE-2001-0068": {"epss_score": 0.0031, "epss_percentile": 0.53769}, "CVE-2001-0069": {"epss_score": 0.00109, "epss_percentile": 0.30025}, "CVE-2001-0070": {"epss_score": 0.02757, "epss_percentile": 0.85594}, "CVE-2001-0071": {"epss_score": 0.00138, "epss_percentile": 0.34467}, "CVE-2001-0072": {"epss_score": 0.0096, "epss_percentile": 0.75962}, "CVE-2001-0073": {"epss_score": 0.00113, "epss_percentile": 0.3067}, "CVE-2001-0074": {"epss_score": 0.0447, "epss_percentile": 0.88734}, "CVE-2001-0075": {"epss_score": 0.02672, "epss_percentile": 0.85393}, "CVE-2001-0076": {"epss_score": 0.02323, "epss_percentile": 0.84377}, "CVE-2001-0077": {"epss_score": 0.00799, "epss_percentile": 0.73519}, "CVE-2001-0078": {"epss_score": 0.00099, "epss_percentile": 0.28358}, "CVE-2001-0079": {"epss_score": 0.00273, "epss_percentile": 0.50454}, "CVE-2001-0080": {"epss_score": 0.13383, "epss_percentile": 0.93948}, "CVE-2001-0081": {"epss_score": 0.00585, "epss_percentile": 0.68406}, "CVE-2001-0082": {"epss_score": 0.02711, "epss_percentile": 0.85497}, "CVE-2001-0083": {"epss_score": 0.19067, "epss_percentile": 0.95123}, "CVE-2001-0084": {"epss_score": 0.00275, "epss_percentile": 0.50648}, "CVE-2001-0085": {"epss_score": 0.00051, "epss_percentile": 0.1614}, "CVE-2001-0086": {"epss_score": 0.00741, "epss_percentile": 0.72436}, "CVE-2001-0087": {"epss_score": 0.0014, "epss_percentile": 0.34744}, "CVE-2001-0088": {"epss_score": 0.01015, "epss_percentile": 0.76663}, "CVE-2001-0089": {"epss_score": 0.38298, "epss_percentile": 0.97094}, "CVE-2001-0090": {"epss_score": 0.08049, "epss_percentile": 0.91853}, "CVE-2001-0091": {"epss_score": 0.13454, "epss_percentile": 0.9397}, "CVE-2001-0092": {"epss_score": 0.18362, "epss_percentile": 0.95005}, "CVE-2001-0093": {"epss_score": 0.0038, "epss_percentile": 0.58939}, "CVE-2001-0094": {"epss_score": 0.00053, "epss_percentile": 0.17006}, "CVE-2001-0095": {"epss_score": 0.00143, "epss_percentile": 0.35208}, "CVE-2001-0096": {"epss_score": 0.55869, "epss_percentile": 0.98001}, "CVE-2001-0097": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2001-0098": {"epss_score": 0.35137, "epss_percentile": 0.96889}, "CVE-2001-0099": {"epss_score": 0.188, "epss_percentile": 0.95071}, "CVE-2001-0100": {"epss_score": 0.09375, "epss_percentile": 0.92522}, "CVE-2001-0101": {"epss_score": 0.00437, "epss_percentile": 0.62508}, "CVE-2001-0102": {"epss_score": 0.00052, "epss_percentile": 0.16474}, "CVE-2001-0103": {"epss_score": 0.00038, "epss_percentile": 0.11409}, "CVE-2001-0104": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2001-0105": {"epss_score": 0.00273, "epss_percentile": 0.50454}, "CVE-2001-0106": {"epss_score": 0.00678, "epss_percentile": 0.70983}, "CVE-2001-0107": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0108": {"epss_score": 0.00358, "epss_percentile": 0.57508}, "CVE-2001-0109": {"epss_score": 0.00315, "epss_percentile": 0.54176}, "CVE-2001-0110": {"epss_score": 0.00448, "epss_percentile": 0.63009}, "CVE-2001-0111": {"epss_score": 0.00206, "epss_percentile": 0.43065}, "CVE-2001-0112": {"epss_score": 0.01253, "epss_percentile": 0.78912}, "CVE-2001-0113": {"epss_score": 0.07555, "epss_percentile": 0.91538}, "CVE-2001-0114": {"epss_score": 0.02711, "epss_percentile": 0.85497}, "CVE-2001-0115": {"epss_score": 0.0023, "epss_percentile": 0.45763}, "CVE-2001-0116": {"epss_score": 0.00068, "epss_percentile": 0.21261}, "CVE-2001-0117": {"epss_score": 0.00124, "epss_percentile": 0.32373}, "CVE-2001-0118": {"epss_score": 0.00068, "epss_percentile": 0.21261}, "CVE-2001-0119": {"epss_score": 0.00068, "epss_percentile": 0.21261}, "CVE-2001-0120": {"epss_score": 0.00068, "epss_percentile": 0.21261}, "CVE-2001-0121": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-0122": {"epss_score": 0.04924, "epss_percentile": 0.89293}, "CVE-2001-0123": {"epss_score": 0.05333, "epss_percentile": 0.89741}, "CVE-2001-0124": {"epss_score": 0.00053, "epss_percentile": 0.16821}, "CVE-2001-0125": {"epss_score": 0.00076, "epss_percentile": 0.23247}, "CVE-2001-0126": {"epss_score": 0.00828, "epss_percentile": 0.73992}, "CVE-2001-0127": {"epss_score": 0.13149, "epss_percentile": 0.93885}, "CVE-2001-0128": {"epss_score": 0.00055, "epss_percentile": 0.17623}, "CVE-2001-0129": {"epss_score": 0.09555, "epss_percentile": 0.92596}, "CVE-2001-0130": {"epss_score": 0.018, "epss_percentile": 0.82324}, "CVE-2001-0131": {"epss_score": 0.00114, "epss_percentile": 0.30839}, "CVE-2001-0132": {"epss_score": 0.00072, "epss_percentile": 0.22349}, "CVE-2001-0133": {"epss_score": 0.0039, "epss_percentile": 0.59546}, "CVE-2001-0134": {"epss_score": 0.02028, "epss_percentile": 0.83324}, "CVE-2001-0135": {"epss_score": 0.00067, "epss_percentile": 0.21136}, "CVE-2001-0136": {"epss_score": 0.01256, "epss_percentile": 0.78941}, "CVE-2001-0137": {"epss_score": 0.07392, "epss_percentile": 0.91449}, "CVE-2001-0138": {"epss_score": 0.00076, "epss_percentile": 0.23168}, "CVE-2001-0139": {"epss_score": 0.00069, "epss_percentile": 0.21509}, "CVE-2001-0140": {"epss_score": 0.00068, "epss_percentile": 0.21261}, "CVE-2001-0141": {"epss_score": 0.00076, "epss_percentile": 0.23247}, "CVE-2001-0142": {"epss_score": 0.00076, "epss_percentile": 0.23247}, "CVE-2001-0143": {"epss_score": 0.00061, "epss_percentile": 0.19328}, "CVE-2001-0144": {"epss_score": 0.72537, "epss_percentile": 0.98715}, "CVE-2001-0145": {"epss_score": 0.1176, "epss_percentile": 0.93467}, "CVE-2001-0146": {"epss_score": 0.12277, "epss_percentile": 0.9362}, "CVE-2001-0147": {"epss_score": 0.13931, "epss_percentile": 0.94095}, "CVE-2001-0148": {"epss_score": 0.13664, "epss_percentile": 0.94029}, "CVE-2001-0149": {"epss_score": 0.37058, "epss_percentile": 0.97017}, "CVE-2001-0150": {"epss_score": 0.14377, "epss_percentile": 0.94197}, "CVE-2001-0151": {"epss_score": 0.79998, "epss_percentile": 0.99066}, "CVE-2001-0152": {"epss_score": 0.08356, "epss_percentile": 0.92006}, "CVE-2001-0153": {"epss_score": 0.02529, "epss_percentile": 0.85021}, "CVE-2001-0154": {"epss_score": 0.16798, "epss_percentile": 0.94733}, "CVE-2001-0155": {"epss_score": 0.01125, "epss_percentile": 0.77803}, "CVE-2001-0156": {"epss_score": 0.00099, "epss_percentile": 0.28388}, "CVE-2001-0157": {"epss_score": 0.00069, "epss_percentile": 0.21466}, "CVE-2001-0160": {"epss_score": 0.0022, "epss_percentile": 0.44598}, "CVE-2001-0161": {"epss_score": 0.0022, "epss_percentile": 0.44598}, "CVE-2001-0162": {"epss_score": 0.07309, "epss_percentile": 0.91398}, "CVE-2001-0163": {"epss_score": 0.00671, "epss_percentile": 0.70791}, "CVE-2001-0164": {"epss_score": 0.02355, "epss_percentile": 0.84481}, "CVE-2001-0165": {"epss_score": 0.00138, "epss_percentile": 0.34425}, "CVE-2001-0166": {"epss_score": 0.00976, "epss_percentile": 0.76213}, "CVE-2001-0167": {"epss_score": 0.65403, "epss_percentile": 0.98416}, "CVE-2001-0168": {"epss_score": 0.67361, "epss_percentile": 0.98503}, "CVE-2001-0169": {"epss_score": 0.00142, "epss_percentile": 0.35004}, "CVE-2001-0170": {"epss_score": 0.00639, "epss_percentile": 0.69954}, "CVE-2001-0171": {"epss_score": 0.04646, "epss_percentile": 0.8896}, "CVE-2001-0172": {"epss_score": 0.00692, "epss_percentile": 0.71295}, "CVE-2001-0173": {"epss_score": 0.04061, "epss_percentile": 0.88189}, "CVE-2001-0174": {"epss_score": 0.01462, "epss_percentile": 0.80436}, "CVE-2001-0175": {"epss_score": 0.00928, "epss_percentile": 0.75578}, "CVE-2001-0176": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2001-0177": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2001-0178": {"epss_score": 0.00102, "epss_percentile": 0.28834}, "CVE-2001-0179": {"epss_score": 0.02955, "epss_percentile": 0.8606}, "CVE-2001-0180": {"epss_score": 0.02742, "epss_percentile": 0.85563}, "CVE-2001-0181": {"epss_score": 0.02323, "epss_percentile": 0.84377}, "CVE-2001-0182": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2001-0183": {"epss_score": 0.08911, "epss_percentile": 0.92315}, "CVE-2001-0184": {"epss_score": 0.04891, "epss_percentile": 0.89263}, "CVE-2001-0185": {"epss_score": 0.00544, "epss_percentile": 0.67137}, "CVE-2001-0186": {"epss_score": 0.00685, "epss_percentile": 0.71134}, "CVE-2001-0187": {"epss_score": 0.08089, "epss_percentile": 0.91875}, "CVE-2001-0188": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-0189": {"epss_score": 0.04092, "epss_percentile": 0.88241}, "CVE-2001-0190": {"epss_score": 0.00068, "epss_percentile": 0.21393}, "CVE-2001-0191": {"epss_score": 0.01188, "epss_percentile": 0.78359}, "CVE-2001-0192": {"epss_score": 0.04995, "epss_percentile": 0.89372}, "CVE-2001-0193": {"epss_score": 0.00205, "epss_percentile": 0.42729}, "CVE-2001-0194": {"epss_score": 0.02458, "epss_percentile": 0.84812}, "CVE-2001-0195": {"epss_score": 0.00083, "epss_percentile": 0.24708}, "CVE-2001-0196": {"epss_score": 0.0057, "epss_percentile": 0.67955}, "CVE-2001-0197": {"epss_score": 0.09544, "epss_percentile": 0.92591}, "CVE-2001-0198": {"epss_score": 0.05705, "epss_percentile": 0.90136}, "CVE-2001-0199": {"epss_score": 0.08397, "epss_percentile": 0.92031}, "CVE-2001-0200": {"epss_score": 0.02672, "epss_percentile": 0.85393}, "CVE-2001-0201": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2001-0202": {"epss_score": 0.02672, "epss_percentile": 0.85393}, "CVE-2001-0203": {"epss_score": 0.00386, "epss_percentile": 0.59237}, "CVE-2001-0204": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2001-0205": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2001-0206": {"epss_score": 0.02672, "epss_percentile": 0.85393}, "CVE-2001-0207": {"epss_score": 0.02101, "epss_percentile": 0.83604}, "CVE-2001-0208": {"epss_score": 0.00123, "epss_percentile": 0.32292}, "CVE-2001-0209": {"epss_score": 0.018, "epss_percentile": 0.82324}, "CVE-2001-0210": {"epss_score": 0.02672, "epss_percentile": 0.85393}, "CVE-2001-0211": {"epss_score": 0.03054, "epss_percentile": 0.86297}, "CVE-2001-0212": {"epss_score": 0.13095, "epss_percentile": 0.93873}, "CVE-2001-0213": {"epss_score": 0.02601, "epss_percentile": 0.85208}, "CVE-2001-0214": {"epss_score": 0.02672, "epss_percentile": 0.85393}, "CVE-2001-0215": {"epss_score": 0.04308, "epss_percentile": 0.88528}, "CVE-2001-0216": {"epss_score": 0.06666, "epss_percentile": 0.90928}, "CVE-2001-0217": {"epss_score": 0.05307, "epss_percentile": 0.89714}, "CVE-2001-0218": {"epss_score": 0.02323, "epss_percentile": 0.84377}, "CVE-2001-0219": {"epss_score": 0.001, "epss_percentile": 0.28431}, "CVE-2001-0220": {"epss_score": 0.00429, "epss_percentile": 0.6197}, "CVE-2001-0221": {"epss_score": 0.00429, "epss_percentile": 0.6197}, "CVE-2001-0222": {"epss_score": 0.00071, "epss_percentile": 0.22042}, "CVE-2001-0223": {"epss_score": 0.01831, "epss_percentile": 0.82448}, "CVE-2001-0224": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2001-0225": {"epss_score": 0.02102, "epss_percentile": 0.83609}, "CVE-2001-0226": {"epss_score": 0.00635, "epss_percentile": 0.69821}, "CVE-2001-0227": {"epss_score": 0.0082, "epss_percentile": 0.73885}, "CVE-2001-0228": {"epss_score": 0.03779, "epss_percentile": 0.87717}, "CVE-2001-0229": {"epss_score": 0.00052, "epss_percentile": 0.16474}, "CVE-2001-0230": {"epss_score": 0.00083, "epss_percentile": 0.24803}, "CVE-2001-0231": {"epss_score": 0.03463, "epss_percentile": 0.87186}, "CVE-2001-0232": {"epss_score": 0.00763, "epss_percentile": 0.72882}, "CVE-2001-0233": {"epss_score": 0.14821, "epss_percentile": 0.94292}, "CVE-2001-0234": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2001-0235": {"epss_score": 0.00102, "epss_percentile": 0.28834}, "CVE-2001-0236": {"epss_score": 0.69734, "epss_percentile": 0.98601}, "CVE-2001-0237": {"epss_score": 0.28717, "epss_percentile": 0.96378}, "CVE-2001-0238": {"epss_score": 0.06295, "epss_percentile": 0.90651}, "CVE-2001-0239": {"epss_score": 0.20481, "epss_percentile": 0.95353}, "CVE-2001-0240": {"epss_score": 0.00528, "epss_percentile": 0.66549}, "CVE-2001-0241": {"epss_score": 0.85785, "epss_percentile": 0.99348}, "CVE-2001-0242": {"epss_score": 0.12666, "epss_percentile": 0.93743}, "CVE-2001-0243": {"epss_score": 0.37007, "epss_percentile": 0.97013}, "CVE-2001-0244": {"epss_score": 0.11056, "epss_percentile": 0.93204}, "CVE-2001-0245": {"epss_score": 0.3735, "epss_percentile": 0.97035}, "CVE-2001-0246": {"epss_score": 0.18795, "epss_percentile": 0.9507}, "CVE-2001-0247": {"epss_score": 0.3517, "epss_percentile": 0.96892}, "CVE-2001-0248": {"epss_score": 0.05322, "epss_percentile": 0.8973}, "CVE-2001-0249": {"epss_score": 0.04703, "epss_percentile": 0.89029}, "CVE-2001-0250": {"epss_score": 0.08581, "epss_percentile": 0.92133}, "CVE-2001-0251": {"epss_score": 0.00782, "epss_percentile": 0.73197}, "CVE-2001-0252": {"epss_score": 0.00928, "epss_percentile": 0.75578}, "CVE-2001-0253": {"epss_score": 0.07778, "epss_percentile": 0.91676}, "CVE-2001-0254": {"epss_score": 0.00647, "epss_percentile": 0.70178}, "CVE-2001-0255": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2001-0256": {"epss_score": 0.01221, "epss_percentile": 0.78648}, "CVE-2001-0257": {"epss_score": 0.01911, "epss_percentile": 0.82829}, "CVE-2001-0258": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0259": {"epss_score": 0.00273, "epss_percentile": 0.50453}, "CVE-2001-0260": {"epss_score": 0.049, "epss_percentile": 0.89273}, "CVE-2001-0261": {"epss_score": 0.01222, "epss_percentile": 0.78656}, "CVE-2001-0262": {"epss_score": 0.07787, "epss_percentile": 0.91682}, "CVE-2001-0263": {"epss_score": 0.03178, "epss_percentile": 0.86575}, "CVE-2001-0264": {"epss_score": 0.03815, "epss_percentile": 0.87766}, "CVE-2001-0265": {"epss_score": 0.00642, "epss_percentile": 0.7002}, "CVE-2001-0266": {"epss_score": 0.0006, "epss_percentile": 0.19029}, "CVE-2001-0267": {"epss_score": 0.0005, "epss_percentile": 0.15727}, "CVE-2001-0268": {"epss_score": 0.00098, "epss_percentile": 0.27707}, "CVE-2001-0269": {"epss_score": 0.00607, "epss_percentile": 0.69057}, "CVE-2001-0270": {"epss_score": 0.05038, "epss_percentile": 0.89423}, "CVE-2001-0271": {"epss_score": 0.02314, "epss_percentile": 0.84351}, "CVE-2001-0272": {"epss_score": 0.05035, "epss_percentile": 0.89419}, "CVE-2001-0273": {"epss_score": 0.01521, "epss_percentile": 0.80831}, "CVE-2001-0274": {"epss_score": 0.12598, "epss_percentile": 0.93724}, "CVE-2001-0275": {"epss_score": 0.00423, "epss_percentile": 0.61602}, "CVE-2001-0276": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2001-0277": {"epss_score": 0.05268, "epss_percentile": 0.89675}, "CVE-2001-0278": {"epss_score": 0.00086, "epss_percentile": 0.25376}, "CVE-2001-0279": {"epss_score": 0.00216, "epss_percentile": 0.44141}, "CVE-2001-0280": {"epss_score": 0.04722, "epss_percentile": 0.89055}, "CVE-2001-0281": {"epss_score": 0.00466, "epss_percentile": 0.63788}, "CVE-2001-0282": {"epss_score": 0.03199, "epss_percentile": 0.86618}, "CVE-2001-0283": {"epss_score": 0.02711, "epss_percentile": 0.85497}, "CVE-2001-0284": {"epss_score": 0.01368, "epss_percentile": 0.79791}, "CVE-2001-0285": {"epss_score": 0.03157, "epss_percentile": 0.86518}, "CVE-2001-0286": {"epss_score": 0.03054, "epss_percentile": 0.86297}, "CVE-2001-0287": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2001-0288": {"epss_score": 0.03983, "epss_percentile": 0.88061}, "CVE-2001-0289": {"epss_score": 0.00246, "epss_percentile": 0.47798}, "CVE-2001-0290": {"epss_score": 0.00069, "epss_percentile": 0.21466}, "CVE-2001-0291": {"epss_score": 0.03691, "epss_percentile": 0.87577}, "CVE-2001-0292": {"epss_score": 0.00045, "epss_percentile": 0.13964}, "CVE-2001-0293": {"epss_score": 0.02672, "epss_percentile": 0.85393}, "CVE-2001-0294": {"epss_score": 0.00847, "epss_percentile": 0.74354}, "CVE-2001-0295": {"epss_score": 0.04308, "epss_percentile": 0.88528}, "CVE-2001-0296": {"epss_score": 0.06955, "epss_percentile": 0.91143}, "CVE-2001-0297": {"epss_score": 0.00339, "epss_percentile": 0.56204}, "CVE-2001-0298": {"epss_score": 0.12452, "epss_percentile": 0.93676}, "CVE-2001-0299": {"epss_score": 0.00999, "epss_percentile": 0.7648}, "CVE-2001-0300": {"epss_score": 0.00593, "epss_percentile": 0.68639}, "CVE-2001-0301": {"epss_score": 0.04972, "epss_percentile": 0.89352}, "CVE-2001-0302": {"epss_score": 0.09566, "epss_percentile": 0.92603}, "CVE-2001-0303": {"epss_score": 0.00623, "epss_percentile": 0.69554}, "CVE-2001-0304": {"epss_score": 0.03054, "epss_percentile": 0.86297}, "CVE-2001-0305": {"epss_score": 0.02672, "epss_percentile": 0.85393}, "CVE-2001-0306": {"epss_score": 0.02672, "epss_percentile": 0.85393}, "CVE-2001-0307": {"epss_score": 0.06018, "epss_percentile": 0.90414}, "CVE-2001-0308": {"epss_score": 0.07891, "epss_percentile": 0.91746}, "CVE-2001-0309": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2001-0310": {"epss_score": 0.00091, "epss_percentile": 0.26276}, "CVE-2001-0311": {"epss_score": 0.45881, "epss_percentile": 0.97505}, "CVE-2001-0312": {"epss_score": 0.00431, "epss_percentile": 0.62066}, "CVE-2001-0313": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0314": {"epss_score": 0.01226, "epss_percentile": 0.78689}, "CVE-2001-0315": {"epss_score": 0.00428, "epss_percentile": 0.61945}, "CVE-2001-0316": {"epss_score": 0.00274, "epss_percentile": 0.50526}, "CVE-2001-0317": {"epss_score": 0.00447, "epss_percentile": 0.62965}, "CVE-2001-0318": {"epss_score": 0.00833, "epss_percentile": 0.74084}, "CVE-2001-0319": {"epss_score": 0.09254, "epss_percentile": 0.92466}, "CVE-2001-0320": {"epss_score": 0.00086, "epss_percentile": 0.2529}, "CVE-2001-0321": {"epss_score": 0.0005, "epss_percentile": 0.15974}, "CVE-2001-0322": {"epss_score": 0.13452, "epss_percentile": 0.9397}, "CVE-2001-0323": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2001-0324": {"epss_score": 0.0294, "epss_percentile": 0.86032}, "CVE-2001-0325": {"epss_score": 0.03165, "epss_percentile": 0.86539}, "CVE-2001-0326": {"epss_score": 0.01525, "epss_percentile": 0.80855}, "CVE-2001-0327": {"epss_score": 0.01406, "epss_percentile": 0.80048}, "CVE-2001-0328": {"epss_score": 0.28624, "epss_percentile": 0.96373}, "CVE-2001-0329": {"epss_score": 0.06233, "epss_percentile": 0.90588}, "CVE-2001-0330": {"epss_score": 0.00626, "epss_percentile": 0.69613}, "CVE-2001-0331": {"epss_score": 0.01275, "epss_percentile": 0.79106}, "CVE-2001-0332": {"epss_score": 0.18085, "epss_percentile": 0.94954}, "CVE-2001-0333": {"epss_score": 0.8447, "epss_percentile": 0.9929}, "CVE-2001-0334": {"epss_score": 0.30559, "epss_percentile": 0.96551}, "CVE-2001-0335": {"epss_score": 0.37007, "epss_percentile": 0.97013}, "CVE-2001-0336": {"epss_score": 0.15747, "epss_percentile": 0.94498}, "CVE-2001-0337": {"epss_score": 0.04618, "epss_percentile": 0.88926}, "CVE-2001-0338": {"epss_score": 0.01673, "epss_percentile": 0.81687}, "CVE-2001-0339": {"epss_score": 0.18427, "epss_percentile": 0.95014}, "CVE-2001-0340": {"epss_score": 0.07676, "epss_percentile": 0.9162}, "CVE-2001-0341": {"epss_score": 0.19241, "epss_percentile": 0.95155}, "CVE-2001-0344": {"epss_score": 0.0077, "epss_percentile": 0.72998}, "CVE-2001-0345": {"epss_score": 0.19774, "epss_percentile": 0.95238}, "CVE-2001-0346": {"epss_score": 0.15888, "epss_percentile": 0.94526}, "CVE-2001-0347": {"epss_score": 0.30231, "epss_percentile": 0.96522}, "CVE-2001-0348": {"epss_score": 0.54929, "epss_percentile": 0.97952}, "CVE-2001-0349": {"epss_score": 0.03001, "epss_percentile": 0.86169}, "CVE-2001-0350": {"epss_score": 0.00527, "epss_percentile": 0.66441}, "CVE-2001-0351": {"epss_score": 0.00552, "epss_percentile": 0.67397}, "CVE-2001-0352": {"epss_score": 0.00348, "epss_percentile": 0.56846}, "CVE-2001-0353": {"epss_score": 0.01477, "epss_percentile": 0.80545}, "CVE-2001-0354": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-2001-0355": {"epss_score": 0.00394, "epss_percentile": 0.59781}, "CVE-2001-0357": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2001-0358": {"epss_score": 0.0321, "epss_percentile": 0.86652}, "CVE-2001-0359": {"epss_score": 0.01841, "epss_percentile": 0.82495}, "CVE-2001-0360": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2001-0361": {"epss_score": 0.01308, "epss_percentile": 0.7935}, "CVE-2001-0364": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-0365": {"epss_score": 0.04817, "epss_percentile": 0.89171}, "CVE-2001-0366": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2001-0367": {"epss_score": 0.00634, "epss_percentile": 0.69799}, "CVE-2001-0368": {"epss_score": 0.02432, "epss_percentile": 0.84729}, "CVE-2001-0369": {"epss_score": 0.00092, "epss_percentile": 0.26449}, "CVE-2001-0370": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-2001-0371": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2001-0372": {"epss_score": 0.01552, "epss_percentile": 0.80991}, "CVE-2001-0373": {"epss_score": 0.011, "epss_percentile": 0.77566}, "CVE-2001-0374": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-2001-0375": {"epss_score": 0.16076, "epss_percentile": 0.94569}, "CVE-2001-0376": {"epss_score": 0.00428, "epss_percentile": 0.61918}, "CVE-2001-0377": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-0378": {"epss_score": 0.00094, "epss_percentile": 0.27045}, "CVE-2001-0379": {"epss_score": 0.00108, "epss_percentile": 0.29884}, "CVE-2001-0380": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2001-0381": {"epss_score": 0.0009, "epss_percentile": 0.26091}, "CVE-2001-0382": {"epss_score": 0.00411, "epss_percentile": 0.60899}, "CVE-2001-0383": {"epss_score": 0.00064, "epss_percentile": 0.20281}, "CVE-2001-0384": {"epss_score": 0.00129, "epss_percentile": 0.33169}, "CVE-2001-0385": {"epss_score": 0.06714, "epss_percentile": 0.90964}, "CVE-2001-0386": {"epss_score": 0.04891, "epss_percentile": 0.89263}, "CVE-2001-0387": {"epss_score": 0.00055, "epss_percentile": 0.17492}, "CVE-2001-0388": {"epss_score": 0.00992, "epss_percentile": 0.76394}, "CVE-2001-0389": {"epss_score": 0.0066, "epss_percentile": 0.70527}, "CVE-2001-0390": {"epss_score": 0.07198, "epss_percentile": 0.91315}, "CVE-2001-0391": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0392": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0393": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0394": {"epss_score": 0.00651, "epss_percentile": 0.70301}, "CVE-2001-0395": {"epss_score": 0.01126, "epss_percentile": 0.77811}, "CVE-2001-0396": {"epss_score": 0.00721, "epss_percentile": 0.71978}, "CVE-2001-0397": {"epss_score": 0.00905, "epss_percentile": 0.75245}, "CVE-2001-0398": {"epss_score": 0.01053, "epss_percentile": 0.77103}, "CVE-2001-0399": {"epss_score": 0.03054, "epss_percentile": 0.86297}, "CVE-2001-0400": {"epss_score": 0.13095, "epss_percentile": 0.93873}, "CVE-2001-0401": {"epss_score": 0.00178, "epss_percentile": 0.39642}, "CVE-2001-0402": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2001-0403": {"epss_score": 0.00148, "epss_percentile": 0.35809}, "CVE-2001-0404": {"epss_score": 0.00576, "epss_percentile": 0.68134}, "CVE-2001-0405": {"epss_score": 0.14298, "epss_percentile": 0.94182}, "CVE-2001-0406": {"epss_score": 0.00301, "epss_percentile": 0.53082}, "CVE-2001-0407": {"epss_score": 0.00712, "epss_percentile": 0.71773}, "CVE-2001-0408": {"epss_score": 0.00866, "epss_percentile": 0.74633}, "CVE-2001-0409": {"epss_score": 0.00378, "epss_percentile": 0.58827}, "CVE-2001-0410": {"epss_score": 0.00905, "epss_percentile": 0.75245}, "CVE-2001-0411": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0412": {"epss_score": 0.00068, "epss_percentile": 0.21208}, "CVE-2001-0413": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2001-0414": {"epss_score": 0.83321, "epss_percentile": 0.99245}, "CVE-2001-0415": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2001-0416": {"epss_score": 0.00094, "epss_percentile": 0.27041}, "CVE-2001-0417": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2001-0418": {"epss_score": 0.0447, "epss_percentile": 0.88734}, "CVE-2001-0419": {"epss_score": 0.18346, "epss_percentile": 0.95001}, "CVE-2001-0420": {"epss_score": 0.00471, "epss_percentile": 0.64017}, "CVE-2001-0421": {"epss_score": 0.02445, "epss_percentile": 0.84766}, "CVE-2001-0422": {"epss_score": 0.00263, "epss_percentile": 0.49548}, "CVE-2001-0423": {"epss_score": 0.01044, "epss_percentile": 0.77008}, "CVE-2001-0424": {"epss_score": 0.00061, "epss_percentile": 0.19416}, "CVE-2001-0425": {"epss_score": 0.04587, "epss_percentile": 0.88888}, "CVE-2001-0426": {"epss_score": 0.00126, "epss_percentile": 0.32643}, "CVE-2001-0427": {"epss_score": 0.00855, "epss_percentile": 0.7446}, "CVE-2001-0428": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2001-0429": {"epss_score": 0.00503, "epss_percentile": 0.65483}, "CVE-2001-0430": {"epss_score": 0.00136, "epss_percentile": 0.34172}, "CVE-2001-0431": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-2001-0432": {"epss_score": 0.06009, "epss_percentile": 0.90402}, "CVE-2001-0433": {"epss_score": 0.00909, "epss_percentile": 0.75292}, "CVE-2001-0434": {"epss_score": 0.00672, "epss_percentile": 0.70826}, "CVE-2001-0435": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-2001-0436": {"epss_score": 0.02032, "epss_percentile": 0.83338}, "CVE-2001-0437": {"epss_score": 0.00765, "epss_percentile": 0.72913}, "CVE-2001-0438": {"epss_score": 0.00089, "epss_percentile": 0.25893}, "CVE-2001-0439": {"epss_score": 0.01341, "epss_percentile": 0.79584}, "CVE-2001-0440": {"epss_score": 0.13382, "epss_percentile": 0.93948}, "CVE-2001-0441": {"epss_score": 0.01784, "epss_percentile": 0.82251}, "CVE-2001-0442": {"epss_score": 0.07238, "epss_percentile": 0.91342}, "CVE-2001-0443": {"epss_score": 0.00905, "epss_percentile": 0.75245}, "CVE-2001-0444": {"epss_score": 0.00157, "epss_percentile": 0.37103}, "CVE-2001-0446": {"epss_score": 0.00559, "epss_percentile": 0.67618}, "CVE-2001-0447": {"epss_score": 0.01129, "epss_percentile": 0.77836}, "CVE-2001-0448": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2001-0449": {"epss_score": 0.00081, "epss_percentile": 0.24304}, "CVE-2001-0450": {"epss_score": 0.01511, "epss_percentile": 0.80773}, "CVE-2001-0451": {"epss_score": 0.00472, "epss_percentile": 0.64073}, "CVE-2001-0452": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2001-0453": {"epss_score": 0.00894, "epss_percentile": 0.75082}, "CVE-2001-0454": {"epss_score": 0.02265, "epss_percentile": 0.84195}, "CVE-2001-0455": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2001-0456": {"epss_score": 0.00782, "epss_percentile": 0.732}, "CVE-2001-0457": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-0458": {"epss_score": 0.02129, "epss_percentile": 0.83705}, "CVE-2001-0459": {"epss_score": 0.0018, "epss_percentile": 0.39868}, "CVE-2001-0460": {"epss_score": 0.03387, "epss_percentile": 0.87042}, "CVE-2001-0461": {"epss_score": 0.05487, "epss_percentile": 0.89926}, "CVE-2001-0462": {"epss_score": 0.04092, "epss_percentile": 0.88241}, "CVE-2001-0463": {"epss_score": 0.10261, "epss_percentile": 0.92918}, "CVE-2001-0464": {"epss_score": 0.06597, "epss_percentile": 0.90876}, "CVE-2001-0465": {"epss_score": 0.00079, "epss_percentile": 0.23838}, "CVE-2001-0466": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-2001-0467": {"epss_score": 0.0618, "epss_percentile": 0.90537}, "CVE-2001-0468": {"epss_score": 0.00331, "epss_percentile": 0.55514}, "CVE-2001-0469": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-0470": {"epss_score": 0.00053, "epss_percentile": 0.16821}, "CVE-2001-0471": {"epss_score": 0.02942, "epss_percentile": 0.86034}, "CVE-2001-0472": {"epss_score": 0.00932, "epss_percentile": 0.75627}, "CVE-2001-0473": {"epss_score": 0.01008, "epss_percentile": 0.76573}, "CVE-2001-0474": {"epss_score": 0.00137, "epss_percentile": 0.34326}, "CVE-2001-0475": {"epss_score": 0.0108, "epss_percentile": 0.77363}, "CVE-2001-0476": {"epss_score": 0.05298, "epss_percentile": 0.89705}, "CVE-2001-0477": {"epss_score": 0.01794, "epss_percentile": 0.82292}, "CVE-2001-0478": {"epss_score": 0.01445, "epss_percentile": 0.80321}, "CVE-2001-0479": {"epss_score": 0.01729, "epss_percentile": 0.81982}, "CVE-2001-0480": {"epss_score": 0.00471, "epss_percentile": 0.64017}, "CVE-2001-0481": {"epss_score": 0.00056, "epss_percentile": 0.17826}, "CVE-2001-0482": {"epss_score": 0.0005, "epss_percentile": 0.1596}, "CVE-2001-0483": {"epss_score": 0.01196, "epss_percentile": 0.78442}, "CVE-2001-0484": {"epss_score": 0.03438, "epss_percentile": 0.87137}, "CVE-2001-0485": {"epss_score": 0.00342, "epss_percentile": 0.56364}, "CVE-2001-0486": {"epss_score": 0.08619, "epss_percentile": 0.92155}, "CVE-2001-0487": {"epss_score": 0.00891, "epss_percentile": 0.75052}, "CVE-2001-0488": {"epss_score": 0.00069, "epss_percentile": 0.21497}, "CVE-2001-0489": {"epss_score": 0.00831, "epss_percentile": 0.7404}, "CVE-2001-0490": {"epss_score": 0.04159, "epss_percentile": 0.88333}, "CVE-2001-0491": {"epss_score": 0.0343, "epss_percentile": 0.87122}, "CVE-2001-0492": {"epss_score": 0.00684, "epss_percentile": 0.71127}, "CVE-2001-0493": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2001-0494": {"epss_score": 0.00642, "epss_percentile": 0.70028}, "CVE-2001-0495": {"epss_score": 0.06466, "epss_percentile": 0.90774}, "CVE-2001-0496": {"epss_score": 0.00067, "epss_percentile": 0.20993}, "CVE-2001-0497": {"epss_score": 0.00107, "epss_percentile": 0.29714}, "CVE-2001-0498": {"epss_score": 0.00532, "epss_percentile": 0.66697}, "CVE-2001-0499": {"epss_score": 0.74942, "epss_percentile": 0.98825}, "CVE-2001-0500": {"epss_score": 0.90865, "epss_percentile": 0.99606}, "CVE-2001-0501": {"epss_score": 0.00576, "epss_percentile": 0.68129}, "CVE-2001-0502": {"epss_score": 0.0077, "epss_percentile": 0.73}, "CVE-2001-0503": {"epss_score": 0.22391, "epss_percentile": 0.95631}, "CVE-2001-0504": {"epss_score": 0.31124, "epss_percentile": 0.96595}, "CVE-2001-0505": {"epss_score": 0.11106, "epss_percentile": 0.93222}, "CVE-2001-0506": {"epss_score": 0.77612, "epss_percentile": 0.98943}, "CVE-2001-0507": {"epss_score": 0.02121, "epss_percentile": 0.83677}, "CVE-2001-0508": {"epss_score": 0.46928, "epss_percentile": 0.97562}, "CVE-2001-0509": {"epss_score": 0.12961, "epss_percentile": 0.9383}, "CVE-2001-0513": {"epss_score": 0.00665, "epss_percentile": 0.70672}, "CVE-2001-0514": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2001-0515": {"epss_score": 0.00603, "epss_percentile": 0.68916}, "CVE-2001-0516": {"epss_score": 0.00603, "epss_percentile": 0.68916}, "CVE-2001-0517": {"epss_score": 0.00724, "epss_percentile": 0.72027}, "CVE-2001-0518": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2001-0519": {"epss_score": 0.02711, "epss_percentile": 0.85497}, "CVE-2001-0520": {"epss_score": 0.02711, "epss_percentile": 0.85497}, "CVE-2001-0521": {"epss_score": 0.02711, "epss_percentile": 0.85497}, "CVE-2001-0522": {"epss_score": 0.11135, "epss_percentile": 0.93233}, "CVE-2001-0523": {"epss_score": 0.00424, "epss_percentile": 0.61637}, "CVE-2001-0524": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2001-0525": {"epss_score": 0.0005, "epss_percentile": 0.15721}, "CVE-2001-0526": {"epss_score": 0.00132, "epss_percentile": 0.3351}, "CVE-2001-0527": {"epss_score": 0.06988, "epss_percentile": 0.91164}, "CVE-2001-0528": {"epss_score": 0.00452, "epss_percentile": 0.63159}, "CVE-2001-0529": {"epss_score": 0.00137, "epss_percentile": 0.34227}, "CVE-2001-0530": {"epss_score": 0.00502, "epss_percentile": 0.65421}, "CVE-2001-0533": {"epss_score": 0.00069, "epss_percentile": 0.21427}, "CVE-2001-0534": {"epss_score": 0.02059, "epss_percentile": 0.83435}, "CVE-2001-0535": {"epss_score": 0.00749, "epss_percentile": 0.72592}, "CVE-2001-0537": {"epss_score": 0.93696, "epss_percentile": 0.99834}, "CVE-2001-0538": {"epss_score": 0.63055, "epss_percentile": 0.98319}, "CVE-2001-0540": {"epss_score": 0.29541, "epss_percentile": 0.96451}, "CVE-2001-0541": {"epss_score": 0.09919, "epss_percentile": 0.9277}, "CVE-2001-0542": {"epss_score": 0.10361, "epss_percentile": 0.92959}, "CVE-2001-0543": {"epss_score": 0.08566, "epss_percentile": 0.92127}, "CVE-2001-0544": {"epss_score": 0.01404, "epss_percentile": 0.80037}, "CVE-2001-0545": {"epss_score": 0.16162, "epss_percentile": 0.94583}, "CVE-2001-0546": {"epss_score": 0.19067, "epss_percentile": 0.95123}, "CVE-2001-0547": {"epss_score": 0.00447, "epss_percentile": 0.6297}, "CVE-2001-0548": {"epss_score": 0.00123, "epss_percentile": 0.32204}, "CVE-2001-0549": {"epss_score": 0.001, "epss_percentile": 0.28456}, "CVE-2001-0550": {"epss_score": 0.73511, "epss_percentile": 0.98759}, "CVE-2001-0551": {"epss_score": 0.00113, "epss_percentile": 0.30643}, "CVE-2001-0552": {"epss_score": 0.03345, "epss_percentile": 0.86951}, "CVE-2001-0553": {"epss_score": 0.00224, "epss_percentile": 0.45016}, "CVE-2001-0554": {"epss_score": 0.16672, "epss_percentile": 0.94712}, "CVE-2001-0555": {"epss_score": 0.23603, "epss_percentile": 0.95795}, "CVE-2001-0556": {"epss_score": 0.00047, "epss_percentile": 0.14792}, "CVE-2001-0557": {"epss_score": 0.12651, "epss_percentile": 0.93741}, "CVE-2001-0558": {"epss_score": 0.05875, "epss_percentile": 0.90285}, "CVE-2001-0559": {"epss_score": 0.00186, "epss_percentile": 0.4061}, "CVE-2001-0560": {"epss_score": 0.00216, "epss_percentile": 0.44218}, "CVE-2001-0561": {"epss_score": 0.10512, "epss_percentile": 0.93014}, "CVE-2001-0562": {"epss_score": 0.01576, "epss_percentile": 0.81114}, "CVE-2001-0563": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2001-0564": {"epss_score": 0.04725, "epss_percentile": 0.89063}, "CVE-2001-0565": {"epss_score": 0.00175, "epss_percentile": 0.39342}, "CVE-2001-0566": {"epss_score": 0.15851, "epss_percentile": 0.94519}, "CVE-2001-0567": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2001-0568": {"epss_score": 0.00111, "epss_percentile": 0.30371}, "CVE-2001-0569": {"epss_score": 0.00131, "epss_percentile": 0.33384}, "CVE-2001-0570": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2001-0571": {"epss_score": 0.07207, "epss_percentile": 0.91324}, "CVE-2001-0572": {"epss_score": 0.24511, "epss_percentile": 0.95928}, "CVE-2001-0573": {"epss_score": 0.00077, "epss_percentile": 0.23408}, "CVE-2001-0574": {"epss_score": 0.06892, "epss_percentile": 0.91096}, "CVE-2001-0575": {"epss_score": 0.00262, "epss_percentile": 0.49353}, "CVE-2001-0576": {"epss_score": 0.00262, "epss_percentile": 0.49353}, "CVE-2001-0577": {"epss_score": 0.0025, "epss_percentile": 0.48212}, "CVE-2001-0578": {"epss_score": 0.00262, "epss_percentile": 0.49353}, "CVE-2001-0579": {"epss_score": 0.02129, "epss_percentile": 0.83706}, "CVE-2001-0580": {"epss_score": 0.03387, "epss_percentile": 0.87042}, "CVE-2001-0581": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2001-0582": {"epss_score": 0.0008, "epss_percentile": 0.24112}, "CVE-2001-0583": {"epss_score": 0.00651, "epss_percentile": 0.70301}, "CVE-2001-0584": {"epss_score": 0.00231, "epss_percentile": 0.45841}, "CVE-2001-0585": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-0586": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2001-0587": {"epss_score": 0.00067, "epss_percentile": 0.21126}, "CVE-2001-0588": {"epss_score": 0.00104, "epss_percentile": 0.29202}, "CVE-2001-0589": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2001-0590": {"epss_score": 0.21835, "epss_percentile": 0.95565}, "CVE-2001-0591": {"epss_score": 0.00918, "epss_percentile": 0.7545}, "CVE-2001-0592": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2001-0593": {"epss_score": 0.06958, "epss_percentile": 0.91148}, "CVE-2001-0594": {"epss_score": 0.00144, "epss_percentile": 0.35257}, "CVE-2001-0595": {"epss_score": 0.00373, "epss_percentile": 0.58466}, "CVE-2001-0596": {"epss_score": 0.18429, "epss_percentile": 0.95014}, "CVE-2001-0597": {"epss_score": 0.00323, "epss_percentile": 0.54919}, "CVE-2001-0598": {"epss_score": 0.01102, "epss_percentile": 0.77585}, "CVE-2001-0599": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2001-0600": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2001-0601": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2001-0602": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2001-0603": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2001-0604": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2001-0605": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2001-0606": {"epss_score": 0.00462, "epss_percentile": 0.6362}, "CVE-2001-0607": {"epss_score": 0.00065, "epss_percentile": 0.20567}, "CVE-2001-0608": {"epss_score": 0.00684, "epss_percentile": 0.71111}, "CVE-2001-0609": {"epss_score": 0.0991, "epss_percentile": 0.92768}, "CVE-2001-0610": {"epss_score": 0.00266, "epss_percentile": 0.49942}, "CVE-2001-0611": {"epss_score": 0.01008, "epss_percentile": 0.76564}, "CVE-2001-0612": {"epss_score": 0.01112, "epss_percentile": 0.77677}, "CVE-2001-0613": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2001-0614": {"epss_score": 0.05383, "epss_percentile": 0.89816}, "CVE-2001-0615": {"epss_score": 0.0618, "epss_percentile": 0.90537}, "CVE-2001-0616": {"epss_score": 0.07887, "epss_percentile": 0.91743}, "CVE-2001-0617": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2001-0618": {"epss_score": 0.00411, "epss_percentile": 0.60899}, "CVE-2001-0619": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2001-0620": {"epss_score": 0.00087, "epss_percentile": 0.25607}, "CVE-2001-0621": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2001-0622": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2001-0623": {"epss_score": 0.00143, "epss_percentile": 0.35145}, "CVE-2001-0624": {"epss_score": 0.00092, "epss_percentile": 0.26449}, "CVE-2001-0625": {"epss_score": 0.00055, "epss_percentile": 0.17444}, "CVE-2001-0626": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2001-0627": {"epss_score": 0.00117, "epss_percentile": 0.31205}, "CVE-2001-0628": {"epss_score": 0.01968, "epss_percentile": 0.83088}, "CVE-2001-0629": {"epss_score": 0.00976, "epss_percentile": 0.76212}, "CVE-2001-0630": {"epss_score": 0.07911, "epss_percentile": 0.91758}, "CVE-2001-0631": {"epss_score": 0.0057, "epss_percentile": 0.6796}, "CVE-2001-0632": {"epss_score": 0.00554, "epss_percentile": 0.67437}, "CVE-2001-0633": {"epss_score": 0.00416, "epss_percentile": 0.61216}, "CVE-2001-0634": {"epss_score": 0.00036, "epss_percentile": 0.10206}, "CVE-2001-0635": {"epss_score": 0.0005, "epss_percentile": 0.15736}, "CVE-2001-0636": {"epss_score": 0.00909, "epss_percentile": 0.75292}, "CVE-2001-0641": {"epss_score": 0.00367, "epss_percentile": 0.581}, "CVE-2001-0642": {"epss_score": 0.00125, "epss_percentile": 0.32549}, "CVE-2001-0643": {"epss_score": 0.17253, "epss_percentile": 0.9481}, "CVE-2001-0644": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2001-0645": {"epss_score": 0.01341, "epss_percentile": 0.79592}, "CVE-2001-0646": {"epss_score": 0.09, "epss_percentile": 0.92359}, "CVE-2001-0647": {"epss_score": 0.03387, "epss_percentile": 0.87042}, "CVE-2001-0648": {"epss_score": 0.00514, "epss_percentile": 0.65966}, "CVE-2001-0649": {"epss_score": 0.04014, "epss_percentile": 0.8812}, "CVE-2001-0650": {"epss_score": 0.0131, "epss_percentile": 0.79359}, "CVE-2001-0652": {"epss_score": 0.00111, "epss_percentile": 0.30331}, "CVE-2001-0653": {"epss_score": 0.00233, "epss_percentile": 0.46055}, "CVE-2001-0658": {"epss_score": 0.11669, "epss_percentile": 0.9344}, "CVE-2001-0659": {"epss_score": 0.3064, "epss_percentile": 0.96558}, "CVE-2001-0660": {"epss_score": 0.1955, "epss_percentile": 0.95205}, "CVE-2001-0662": {"epss_score": 0.18264, "epss_percentile": 0.94984}, "CVE-2001-0663": {"epss_score": 0.55002, "epss_percentile": 0.97956}, "CVE-2001-0664": {"epss_score": 0.273, "epss_percentile": 0.96234}, "CVE-2001-0665": {"epss_score": 0.10865, "epss_percentile": 0.93138}, "CVE-2001-0666": {"epss_score": 0.00255, "epss_percentile": 0.48675}, "CVE-2001-0667": {"epss_score": 0.01746, "epss_percentile": 0.8207}, "CVE-2001-0668": {"epss_score": 0.01305, "epss_percentile": 0.79325}, "CVE-2001-0669": {"epss_score": 0.41484, "epss_percentile": 0.97276}, "CVE-2001-0670": {"epss_score": 0.1616, "epss_percentile": 0.94582}, "CVE-2001-0671": {"epss_score": 0.05644, "epss_percentile": 0.90079}, "CVE-2001-0674": {"epss_score": 0.00455, "epss_percentile": 0.63281}, "CVE-2001-0675": {"epss_score": 0.04311, "epss_percentile": 0.88532}, "CVE-2001-0676": {"epss_score": 0.01059, "epss_percentile": 0.77148}, "CVE-2001-0677": {"epss_score": 0.00979, "epss_percentile": 0.76257}, "CVE-2001-0678": {"epss_score": 0.00101, "epss_percentile": 0.28712}, "CVE-2001-0679": {"epss_score": 0.11097, "epss_percentile": 0.93218}, "CVE-2001-0680": {"epss_score": 0.83167, "epss_percentile": 0.99236}, "CVE-2001-0681": {"epss_score": 0.00714, "epss_percentile": 0.71829}, "CVE-2001-0682": {"epss_score": 0.00128, "epss_percentile": 0.33047}, "CVE-2001-0683": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2001-0684": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2001-0685": {"epss_score": 0.0016, "epss_percentile": 0.37426}, "CVE-2001-0686": {"epss_score": 0.00132, "epss_percentile": 0.33607}, "CVE-2001-0687": {"epss_score": 0.00808, "epss_percentile": 0.73688}, "CVE-2001-0688": {"epss_score": 0.02964, "epss_percentile": 0.86077}, "CVE-2001-0689": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2001-0690": {"epss_score": 0.20241, "epss_percentile": 0.95308}, "CVE-2001-0691": {"epss_score": 0.00089, "epss_percentile": 0.25853}, "CVE-2001-0692": {"epss_score": 0.00428, "epss_percentile": 0.61953}, "CVE-2001-0693": {"epss_score": 0.05247, "epss_percentile": 0.89662}, "CVE-2001-0694": {"epss_score": 0.03024, "epss_percentile": 0.86232}, "CVE-2001-0695": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2001-0696": {"epss_score": 0.01112, "epss_percentile": 0.77677}, "CVE-2001-0697": {"epss_score": 0.06196, "epss_percentile": 0.90556}, "CVE-2001-0698": {"epss_score": 0.0086, "epss_percentile": 0.74528}, "CVE-2001-0699": {"epss_score": 0.00058, "epss_percentile": 0.1828}, "CVE-2001-0700": {"epss_score": 0.13306, "epss_percentile": 0.93928}, "CVE-2001-0701": {"epss_score": 0.00138, "epss_percentile": 0.34425}, "CVE-2001-0702": {"epss_score": 0.09136, "epss_percentile": 0.92417}, "CVE-2001-0703": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2001-0704": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2001-0705": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2001-0706": {"epss_score": 0.00883, "epss_percentile": 0.74915}, "CVE-2001-0707": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0708": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0709": {"epss_score": 0.26029, "epss_percentile": 0.96102}, "CVE-2001-0710": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2001-0711": {"epss_score": 0.2146, "epss_percentile": 0.95522}, "CVE-2001-0712": {"epss_score": 0.09794, "epss_percentile": 0.92705}, "CVE-2001-0713": {"epss_score": 0.00068, "epss_percentile": 0.21364}, "CVE-2001-0714": {"epss_score": 0.0006, "epss_percentile": 0.19112}, "CVE-2001-0715": {"epss_score": 0.00095, "epss_percentile": 0.27143}, "CVE-2001-0716": {"epss_score": 0.01106, "epss_percentile": 0.77614}, "CVE-2001-0717": {"epss_score": 0.14552, "epss_percentile": 0.94239}, "CVE-2001-0718": {"epss_score": 0.12682, "epss_percentile": 0.93747}, "CVE-2001-0719": {"epss_score": 0.17152, "epss_percentile": 0.94784}, "CVE-2001-0720": {"epss_score": 0.01014, "epss_percentile": 0.76646}, "CVE-2001-0721": {"epss_score": 0.19067, "epss_percentile": 0.95123}, "CVE-2001-0722": {"epss_score": 0.52781, "epss_percentile": 0.9784}, "CVE-2001-0723": {"epss_score": 0.11138, "epss_percentile": 0.93237}, "CVE-2001-0724": {"epss_score": 0.02678, "epss_percentile": 0.85409}, "CVE-2001-0726": {"epss_score": 0.09905, "epss_percentile": 0.92765}, "CVE-2001-0727": {"epss_score": 0.50664, "epss_percentile": 0.97744}, "CVE-2001-0728": {"epss_score": 0.00096, "epss_percentile": 0.27301}, "CVE-2001-0729": {"epss_score": 0.02309, "epss_percentile": 0.84332}, "CVE-2001-0730": {"epss_score": 0.07796, "epss_percentile": 0.91686}, "CVE-2001-0731": {"epss_score": 0.83398, "epss_percentile": 0.99247}, "CVE-2001-0733": {"epss_score": 0.02051, "epss_percentile": 0.83407}, "CVE-2001-0734": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2001-0735": {"epss_score": 0.002, "epss_percentile": 0.42218}, "CVE-2001-0736": {"epss_score": 0.00174, "epss_percentile": 0.39222}, "CVE-2001-0737": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2001-0738": {"epss_score": 0.00605, "epss_percentile": 0.68968}, "CVE-2001-0739": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2001-0740": {"epss_score": 0.05879, "epss_percentile": 0.90288}, "CVE-2001-0741": {"epss_score": 0.01908, "epss_percentile": 0.82816}, "CVE-2001-0742": {"epss_score": 0.00745, "epss_percentile": 0.72523}, "CVE-2001-0743": {"epss_score": 0.02964, "epss_percentile": 0.86077}, "CVE-2001-0744": {"epss_score": 0.00089, "epss_percentile": 0.25928}, "CVE-2001-0745": {"epss_score": 0.01083, "epss_percentile": 0.77392}, "CVE-2001-0746": {"epss_score": 0.35582, "epss_percentile": 0.9692}, "CVE-2001-0747": {"epss_score": 0.01345, "epss_percentile": 0.79626}, "CVE-2001-0748": {"epss_score": 0.12377, "epss_percentile": 0.93654}, "CVE-2001-0749": {"epss_score": 0.01015, "epss_percentile": 0.76663}, "CVE-2001-0750": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2001-0751": {"epss_score": 0.10307, "epss_percentile": 0.92937}, "CVE-2001-0752": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-0753": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-2001-0754": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0755": {"epss_score": 0.00873, "epss_percentile": 0.74746}, "CVE-2001-0756": {"epss_score": 0.01841, "epss_percentile": 0.82495}, "CVE-2001-0757": {"epss_score": 0.01767, "epss_percentile": 0.82174}, "CVE-2001-0758": {"epss_score": 0.4261, "epss_percentile": 0.97343}, "CVE-2001-0759": {"epss_score": 0.00365, "epss_percentile": 0.58011}, "CVE-2001-0760": {"epss_score": 0.06618, "epss_percentile": 0.90892}, "CVE-2001-0761": {"epss_score": 0.02268, "epss_percentile": 0.84202}, "CVE-2001-0762": {"epss_score": 0.00138, "epss_percentile": 0.34456}, "CVE-2001-0763": {"epss_score": 0.25353, "epss_percentile": 0.96018}, "CVE-2001-0764": {"epss_score": 0.0026, "epss_percentile": 0.49176}, "CVE-2001-0765": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2001-0766": {"epss_score": 0.11231, "epss_percentile": 0.93272}, "CVE-2001-0767": {"epss_score": 0.00898, "epss_percentile": 0.75146}, "CVE-2001-0768": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2001-0769": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0770": {"epss_score": 0.0321, "epss_percentile": 0.86652}, "CVE-2001-0771": {"epss_score": 0.01233, "epss_percentile": 0.78746}, "CVE-2001-0772": {"epss_score": 0.00123, "epss_percentile": 0.32235}, "CVE-2001-0773": {"epss_score": 0.01509, "epss_percentile": 0.80767}, "CVE-2001-0774": {"epss_score": 0.00087, "epss_percentile": 0.2548}, "CVE-2001-0775": {"epss_score": 0.25562, "epss_percentile": 0.96044}, "CVE-2001-0776": {"epss_score": 0.00806, "epss_percentile": 0.73655}, "CVE-2001-0777": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2001-0778": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2001-0779": {"epss_score": 0.74289, "epss_percentile": 0.98794}, "CVE-2001-0780": {"epss_score": 0.02338, "epss_percentile": 0.84425}, "CVE-2001-0781": {"epss_score": 0.02841, "epss_percentile": 0.85806}, "CVE-2001-0782": {"epss_score": 0.00091, "epss_percentile": 0.26231}, "CVE-2001-0783": {"epss_score": 0.01212, "epss_percentile": 0.7856}, "CVE-2001-0784": {"epss_score": 0.10683, "epss_percentile": 0.9307}, "CVE-2001-0785": {"epss_score": 0.00511, "epss_percentile": 0.65831}, "CVE-2001-0786": {"epss_score": 0.00502, "epss_percentile": 0.65392}, "CVE-2001-0787": {"epss_score": 0.00116, "epss_percentile": 0.31103}, "CVE-2001-0788": {"epss_score": 0.02672, "epss_percentile": 0.85393}, "CVE-2001-0789": {"epss_score": 0.02461, "epss_percentile": 0.84825}, "CVE-2001-0790": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-0791": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2001-0792": {"epss_score": 0.02752, "epss_percentile": 0.85583}, "CVE-2001-0794": {"epss_score": 0.00714, "epss_percentile": 0.71829}, "CVE-2001-0795": {"epss_score": 0.0092, "epss_percentile": 0.75464}, "CVE-2001-0796": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2001-0797": {"epss_score": 0.88681, "epss_percentile": 0.99483}, "CVE-2001-0799": {"epss_score": 0.02232, "epss_percentile": 0.84089}, "CVE-2001-0800": {"epss_score": 0.80189, "epss_percentile": 0.99075}, "CVE-2001-0801": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2001-0803": {"epss_score": 0.58736, "epss_percentile": 0.98134}, "CVE-2001-0804": {"epss_score": 0.08282, "epss_percentile": 0.91967}, "CVE-2001-0805": {"epss_score": 0.04308, "epss_percentile": 0.88528}, "CVE-2001-0806": {"epss_score": 0.00084, "epss_percentile": 0.25019}, "CVE-2001-0807": {"epss_score": 0.0916, "epss_percentile": 0.92427}, "CVE-2001-0808": {"epss_score": 0.03095, "epss_percentile": 0.86403}, "CVE-2001-0809": {"epss_score": 0.00273, "epss_percentile": 0.50454}, "CVE-2001-0815": {"epss_score": 0.35934, "epss_percentile": 0.96942}, "CVE-2001-0816": {"epss_score": 0.00276, "epss_percentile": 0.50757}, "CVE-2001-0817": {"epss_score": 0.03506, "epss_percentile": 0.87259}, "CVE-2001-0818": {"epss_score": 0.14782, "epss_percentile": 0.94283}, "CVE-2001-0819": {"epss_score": 0.07161, "epss_percentile": 0.91292}, "CVE-2001-0820": {"epss_score": 0.12349, "epss_percentile": 0.93646}, "CVE-2001-0821": {"epss_score": 0.11728, "epss_percentile": 0.9346}, "CVE-2001-0822": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2001-0823": {"epss_score": 0.00613, "epss_percentile": 0.69259}, "CVE-2001-0824": {"epss_score": 0.00843, "epss_percentile": 0.74253}, "CVE-2001-0825": {"epss_score": 0.03083, "epss_percentile": 0.86376}, "CVE-2001-0826": {"epss_score": 0.0115, "epss_percentile": 0.78024}, "CVE-2001-0827": {"epss_score": 0.00958, "epss_percentile": 0.75944}, "CVE-2001-0828": {"epss_score": 0.00957, "epss_percentile": 0.75939}, "CVE-2001-0829": {"epss_score": 0.00991, "epss_percentile": 0.76384}, "CVE-2001-0830": {"epss_score": 0.07224, "epss_percentile": 0.91335}, "CVE-2001-0831": {"epss_score": 0.00353, "epss_percentile": 0.57146}, "CVE-2001-0832": {"epss_score": 0.00244, "epss_percentile": 0.47527}, "CVE-2001-0833": {"epss_score": 0.00446, "epss_percentile": 0.62927}, "CVE-2001-0834": {"epss_score": 0.02512, "epss_percentile": 0.84957}, "CVE-2001-0835": {"epss_score": 0.04689, "epss_percentile": 0.8901}, "CVE-2001-0836": {"epss_score": 0.16757, "epss_percentile": 0.94729}, "CVE-2001-0837": {"epss_score": 0.00069, "epss_percentile": 0.21537}, "CVE-2001-0838": {"epss_score": 0.04453, "epss_percentile": 0.88709}, "CVE-2001-0839": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2001-0840": {"epss_score": 0.12534, "epss_percentile": 0.93709}, "CVE-2001-0841": {"epss_score": 0.01958, "epss_percentile": 0.83047}, "CVE-2001-0842": {"epss_score": 0.01958, "epss_percentile": 0.83047}, "CVE-2001-0843": {"epss_score": 0.24182, "epss_percentile": 0.95884}, "CVE-2001-0844": {"epss_score": 0.02799, "epss_percentile": 0.85693}, "CVE-2001-0845": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2001-0846": {"epss_score": 0.0357, "epss_percentile": 0.87368}, "CVE-2001-0847": {"epss_score": 0.00626, "epss_percentile": 0.69613}, "CVE-2001-0848": {"epss_score": 0.00079, "epss_percentile": 0.23838}, "CVE-2001-0849": {"epss_score": 0.01983, "epss_percentile": 0.83146}, "CVE-2001-0850": {"epss_score": 0.00744, "epss_percentile": 0.72511}, "CVE-2001-0851": {"epss_score": 0.00623, "epss_percentile": 0.69553}, "CVE-2001-0852": {"epss_score": 0.06941, "epss_percentile": 0.91131}, "CVE-2001-0853": {"epss_score": 0.03868, "epss_percentile": 0.87874}, "CVE-2001-0854": {"epss_score": 0.0002, "epss_percentile": 0.0456}, "CVE-2001-0855": {"epss_score": 0.00152, "epss_percentile": 0.36439}, "CVE-2001-0856": {"epss_score": 0.00058, "epss_percentile": 0.18396}, "CVE-2001-0857": {"epss_score": 0.10363, "epss_percentile": 0.9296}, "CVE-2001-0858": {"epss_score": 0.00239, "epss_percentile": 0.4692}, "CVE-2001-0859": {"epss_score": 0.00471, "epss_percentile": 0.6402}, "CVE-2001-0860": {"epss_score": 0.13749, "epss_percentile": 0.94048}, "CVE-2001-0861": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2001-0862": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2001-0863": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2001-0864": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2001-0865": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2001-0866": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2001-0867": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2001-0868": {"epss_score": 0.01375, "epss_percentile": 0.79831}, "CVE-2001-0869": {"epss_score": 0.02385, "epss_percentile": 0.84578}, "CVE-2001-0870": {"epss_score": 0.01095, "epss_percentile": 0.77509}, "CVE-2001-0871": {"epss_score": 0.03863, "epss_percentile": 0.87868}, "CVE-2001-0872": {"epss_score": 0.00213, "epss_percentile": 0.43896}, "CVE-2001-0873": {"epss_score": 0.00252, "epss_percentile": 0.48362}, "CVE-2001-0874": {"epss_score": 0.31686, "epss_percentile": 0.96642}, "CVE-2001-0875": {"epss_score": 0.22711, "epss_percentile": 0.95672}, "CVE-2001-0876": {"epss_score": 0.78699, "epss_percentile": 0.99}, "CVE-2001-0877": {"epss_score": 0.52801, "epss_percentile": 0.97841}, "CVE-2001-0879": {"epss_score": 0.14581, "epss_percentile": 0.94245}, "CVE-2001-0884": {"epss_score": 0.00654, "epss_percentile": 0.70351}, "CVE-2001-0886": {"epss_score": 0.00228, "epss_percentile": 0.45502}, "CVE-2001-0887": {"epss_score": 0.00076, "epss_percentile": 0.23162}, "CVE-2001-0888": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-0889": {"epss_score": 0.01153, "epss_percentile": 0.78052}, "CVE-2001-0890": {"epss_score": 0.00089, "epss_percentile": 0.25928}, "CVE-2001-0891": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2001-0892": {"epss_score": 0.00525, "epss_percentile": 0.66391}, "CVE-2001-0893": {"epss_score": 0.01079, "epss_percentile": 0.77358}, "CVE-2001-0894": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2001-0895": {"epss_score": 0.01666, "epss_percentile": 0.81652}, "CVE-2001-0896": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2001-0897": {"epss_score": 0.0117, "epss_percentile": 0.78208}, "CVE-2001-0898": {"epss_score": 0.06958, "epss_percentile": 0.91148}, "CVE-2001-0899": {"epss_score": 0.04404, "epss_percentile": 0.88651}, "CVE-2001-0900": {"epss_score": 0.00065, "epss_percentile": 0.20578}, "CVE-2001-0901": {"epss_score": 0.01484, "epss_percentile": 0.8059}, "CVE-2001-0902": {"epss_score": 0.41283, "epss_percentile": 0.97263}, "CVE-2001-0903": {"epss_score": 0.01669, "epss_percentile": 0.81667}, "CVE-2001-0904": {"epss_score": 0.17855, "epss_percentile": 0.94918}, "CVE-2001-0905": {"epss_score": 0.00047, "epss_percentile": 0.14792}, "CVE-2001-0906": {"epss_score": 0.00218, "epss_percentile": 0.44338}, "CVE-2001-0907": {"epss_score": 0.00224, "epss_percentile": 0.45048}, "CVE-2001-0908": {"epss_score": 0.0064, "epss_percentile": 0.69971}, "CVE-2001-0909": {"epss_score": 0.20753, "epss_percentile": 0.95408}, "CVE-2001-0910": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-2001-0911": {"epss_score": 0.00043, "epss_percentile": 0.12948}, "CVE-2001-0912": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2001-0913": {"epss_score": 0.01841, "epss_percentile": 0.82495}, "CVE-2001-0914": {"epss_score": 0.00058, "epss_percentile": 0.18432}, "CVE-2001-0915": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-2001-0916": {"epss_score": 0.00473, "epss_percentile": 0.64087}, "CVE-2001-0917": {"epss_score": 0.03425, "epss_percentile": 0.87112}, "CVE-2001-0918": {"epss_score": 0.00843, "epss_percentile": 0.74266}, "CVE-2001-0919": {"epss_score": 0.03287, "epss_percentile": 0.86829}, "CVE-2001-0920": {"epss_score": 0.00051, "epss_percentile": 0.16069}, "CVE-2001-0921": {"epss_score": 0.00115, "epss_percentile": 0.30975}, "CVE-2001-0922": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2001-0923": {"epss_score": 0.00067, "epss_percentile": 0.21103}, "CVE-2001-0924": {"epss_score": 0.11132, "epss_percentile": 0.93233}, "CVE-2001-0925": {"epss_score": 0.83316, "epss_percentile": 0.99245}, "CVE-2001-0926": {"epss_score": 0.03219, "epss_percentile": 0.86668}, "CVE-2001-0927": {"epss_score": 0.02051, "epss_percentile": 0.83407}, "CVE-2001-0928": {"epss_score": 0.04879, "epss_percentile": 0.89244}, "CVE-2001-0929": {"epss_score": 0.00577, "epss_percentile": 0.6817}, "CVE-2001-0930": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2001-0931": {"epss_score": 0.78846, "epss_percentile": 0.99006}, "CVE-2001-0932": {"epss_score": 0.07804, "epss_percentile": 0.9169}, "CVE-2001-0933": {"epss_score": 0.08874, "epss_percentile": 0.92297}, "CVE-2001-0934": {"epss_score": 0.05388, "epss_percentile": 0.89823}, "CVE-2001-0935": {"epss_score": 0.00334, "epss_percentile": 0.55729}, "CVE-2001-0936": {"epss_score": 0.00527, "epss_percentile": 0.66523}, "CVE-2001-0937": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2001-0938": {"epss_score": 0.01049, "epss_percentile": 0.77065}, "CVE-2001-0939": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2001-0940": {"epss_score": 0.08459, "epss_percentile": 0.92063}, "CVE-2001-0941": {"epss_score": 0.00383, "epss_percentile": 0.59093}, "CVE-2001-0942": {"epss_score": 0.00303, "epss_percentile": 0.53172}, "CVE-2001-0943": {"epss_score": 0.00799, "epss_percentile": 0.73528}, "CVE-2001-0944": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-2001-0945": {"epss_score": 0.17849, "epss_percentile": 0.94916}, "CVE-2001-0946": {"epss_score": 0.00043, "epss_percentile": 0.13178}, "CVE-2001-0947": {"epss_score": 0.00901, "epss_percentile": 0.75169}, "CVE-2001-0948": {"epss_score": 0.01822, "epss_percentile": 0.82412}, "CVE-2001-0949": {"epss_score": 0.0568, "epss_percentile": 0.90116}, "CVE-2001-0950": {"epss_score": 0.01629, "epss_percentile": 0.81439}, "CVE-2001-0951": {"epss_score": 0.5623, "epss_percentile": 0.98013}, "CVE-2001-0952": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2001-0953": {"epss_score": 0.011, "epss_percentile": 0.77568}, "CVE-2001-0954": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2001-0955": {"epss_score": 0.0008, "epss_percentile": 0.24113}, "CVE-2001-0956": {"epss_score": 0.00624, "epss_percentile": 0.69575}, "CVE-2001-0958": {"epss_score": 0.05886, "epss_percentile": 0.90293}, "CVE-2001-0959": {"epss_score": 0.01063, "epss_percentile": 0.77188}, "CVE-2001-0960": {"epss_score": 0.01155, "epss_percentile": 0.78073}, "CVE-2001-0961": {"epss_score": 0.06452, "epss_percentile": 0.90765}, "CVE-2001-0962": {"epss_score": 0.01053, "epss_percentile": 0.77102}, "CVE-2001-0963": {"epss_score": 0.01194, "epss_percentile": 0.78423}, "CVE-2001-0964": {"epss_score": 0.01427, "epss_percentile": 0.80208}, "CVE-2001-0965": {"epss_score": 0.06794, "epss_percentile": 0.91031}, "CVE-2001-0966": {"epss_score": 0.00688, "epss_percentile": 0.71206}, "CVE-2001-0967": {"epss_score": 0.00355, "epss_percentile": 0.57285}, "CVE-2001-0968": {"epss_score": 0.00952, "epss_percentile": 0.75875}, "CVE-2001-0969": {"epss_score": 0.00432, "epss_percentile": 0.62114}, "CVE-2001-0970": {"epss_score": 0.01611, "epss_percentile": 0.81325}, "CVE-2001-0971": {"epss_score": 0.00558, "epss_percentile": 0.67573}, "CVE-2001-0972": {"epss_score": 0.00933, "epss_percentile": 0.75638}, "CVE-2001-0973": {"epss_score": 0.03174, "epss_percentile": 0.86556}, "CVE-2001-0974": {"epss_score": 0.027, "epss_percentile": 0.85452}, "CVE-2001-0975": {"epss_score": 0.07157, "epss_percentile": 0.9129}, "CVE-2001-0976": {"epss_score": 0.00046, "epss_percentile": 0.14376}, "CVE-2001-0977": {"epss_score": 0.02956, "epss_percentile": 0.86063}, "CVE-2001-0978": {"epss_score": 0.0129, "epss_percentile": 0.79217}, "CVE-2001-0979": {"epss_score": 0.0017, "epss_percentile": 0.38666}, "CVE-2001-0980": {"epss_score": 0.02795, "epss_percentile": 0.85679}, "CVE-2001-0981": {"epss_score": 0.00393, "epss_percentile": 0.59737}, "CVE-2001-0982": {"epss_score": 0.02762, "epss_percentile": 0.85605}, "CVE-2001-0983": {"epss_score": 0.00072, "epss_percentile": 0.22394}, "CVE-2001-0984": {"epss_score": 0.00074, "epss_percentile": 0.2281}, "CVE-2001-0985": {"epss_score": 0.07577, "epss_percentile": 0.91549}, "CVE-2001-0986": {"epss_score": 0.7406, "epss_percentile": 0.98787}, "CVE-2001-0987": {"epss_score": 0.09551, "epss_percentile": 0.92595}, "CVE-2001-0988": {"epss_score": 0.00038, "epss_percentile": 0.11139}, "CVE-2001-0989": {"epss_score": 0.01036, "epss_percentile": 0.76908}, "CVE-2001-0990": {"epss_score": 0.00069, "epss_percentile": 0.21488}, "CVE-2001-0991": {"epss_score": 0.16578, "epss_percentile": 0.94697}, "CVE-2001-0992": {"epss_score": 0.0291, "epss_percentile": 0.85971}, "CVE-2001-0993": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2001-0994": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-0995": {"epss_score": 0.00874, "epss_percentile": 0.74763}, "CVE-2001-0996": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2001-0997": {"epss_score": 0.02885, "epss_percentile": 0.8591}, "CVE-2001-0998": {"epss_score": 0.00509, "epss_percentile": 0.65731}, "CVE-2001-0999": {"epss_score": 0.12728, "epss_percentile": 0.9376}, "CVE-2001-1000": {"epss_score": 0.00166, "epss_percentile": 0.38183}, "CVE-2001-1002": {"epss_score": 0.0489, "epss_percentile": 0.89261}, "CVE-2001-1003": {"epss_score": 0.00086, "epss_percentile": 0.25403}, "CVE-2001-1004": {"epss_score": 0.00406, "epss_percentile": 0.60516}, "CVE-2001-1005": {"epss_score": 0.00219, "epss_percentile": 0.44446}, "CVE-2001-1006": {"epss_score": 0.00437, "epss_percentile": 0.6251}, "CVE-2001-1007": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2001-1008": {"epss_score": 0.00632, "epss_percentile": 0.69749}, "CVE-2001-1009": {"epss_score": 0.13124, "epss_percentile": 0.9388}, "CVE-2001-1010": {"epss_score": 0.05053, "epss_percentile": 0.89443}, "CVE-2001-1011": {"epss_score": 0.01916, "epss_percentile": 0.82857}, "CVE-2001-1012": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-2001-1013": {"epss_score": 0.68119, "epss_percentile": 0.98531}, "CVE-2001-1014": {"epss_score": 0.03749, "epss_percentile": 0.8767}, "CVE-2001-1015": {"epss_score": 0.00125, "epss_percentile": 0.32541}, "CVE-2001-1016": {"epss_score": 0.00539, "epss_percentile": 0.66981}, "CVE-2001-1017": {"epss_score": 0.00036, "epss_percentile": 0.10206}, "CVE-2001-1018": {"epss_score": 0.00631, "epss_percentile": 0.69719}, "CVE-2001-1019": {"epss_score": 0.0156, "epss_percentile": 0.81037}, "CVE-2001-1020": {"epss_score": 0.01458, "epss_percentile": 0.80409}, "CVE-2001-1021": {"epss_score": 0.59795, "epss_percentile": 0.98181}, "CVE-2001-1022": {"epss_score": 0.21216, "epss_percentile": 0.95478}, "CVE-2001-1023": {"epss_score": 0.00684, "epss_percentile": 0.71127}, "CVE-2001-1024": {"epss_score": 0.00763, "epss_percentile": 0.72859}, "CVE-2001-1025": {"epss_score": 0.00073, "epss_percentile": 0.22614}, "CVE-2001-1026": {"epss_score": 0.00786, "epss_percentile": 0.7327}, "CVE-2001-1027": {"epss_score": 0.2372, "epss_percentile": 0.95808}, "CVE-2001-1028": {"epss_score": 0.0018, "epss_percentile": 0.39885}, "CVE-2001-1029": {"epss_score": 0.00112, "epss_percentile": 0.3049}, "CVE-2001-1030": {"epss_score": 0.00184, "epss_percentile": 0.40376}, "CVE-2001-1031": {"epss_score": 0.03464, "epss_percentile": 0.87187}, "CVE-2001-1032": {"epss_score": 0.23192, "epss_percentile": 0.95748}, "CVE-2001-1033": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-1034": {"epss_score": 0.00054, "epss_percentile": 0.17179}, "CVE-2001-1035": {"epss_score": 0.00982, "epss_percentile": 0.76295}, "CVE-2001-1036": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-2001-1037": {"epss_score": 0.00052, "epss_percentile": 0.16391}, "CVE-2001-1038": {"epss_score": 0.0027, "epss_percentile": 0.50258}, "CVE-2001-1039": {"epss_score": 0.00601, "epss_percentile": 0.68851}, "CVE-2001-1040": {"epss_score": 0.00525, "epss_percentile": 0.66369}, "CVE-2001-1041": {"epss_score": 0.00293, "epss_percentile": 0.52337}, "CVE-2001-1042": {"epss_score": 0.01581, "epss_percentile": 0.8114}, "CVE-2001-1043": {"epss_score": 0.01806, "epss_percentile": 0.8235}, "CVE-2001-1044": {"epss_score": 0.07909, "epss_percentile": 0.91756}, "CVE-2001-1045": {"epss_score": 0.08581, "epss_percentile": 0.92133}, "CVE-2001-1046": {"epss_score": 0.00957, "epss_percentile": 0.75933}, "CVE-2001-1047": {"epss_score": 0.0007, "epss_percentile": 0.21947}, "CVE-2001-1048": {"epss_score": 0.01075, "epss_percentile": 0.77308}, "CVE-2001-1049": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2001-1050": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2001-1051": {"epss_score": 0.01048, "epss_percentile": 0.77048}, "CVE-2001-1052": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2001-1053": {"epss_score": 0.00464, "epss_percentile": 0.63728}, "CVE-2001-1054": {"epss_score": 0.01075, "epss_percentile": 0.77308}, "CVE-2001-1055": {"epss_score": 0.15036, "epss_percentile": 0.94349}, "CVE-2001-1056": {"epss_score": 0.00529, "epss_percentile": 0.66584}, "CVE-2001-1057": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-1058": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-2001-1059": {"epss_score": 0.00045, "epss_percentile": 0.13727}, "CVE-2001-1060": {"epss_score": 0.00982, "epss_percentile": 0.76295}, "CVE-2001-1061": {"epss_score": 0.00564, "epss_percentile": 0.67772}, "CVE-2001-1062": {"epss_score": 0.00328, "epss_percentile": 0.55171}, "CVE-2001-1063": {"epss_score": 0.00053, "epss_percentile": 0.16821}, "CVE-2001-1064": {"epss_score": 0.12583, "epss_percentile": 0.93721}, "CVE-2001-1065": {"epss_score": 0.00475, "epss_percentile": 0.6417}, "CVE-2001-1066": {"epss_score": 0.00091, "epss_percentile": 0.26204}, "CVE-2001-1067": {"epss_score": 0.29247, "epss_percentile": 0.96427}, "CVE-2001-1068": {"epss_score": 0.01225, "epss_percentile": 0.78686}, "CVE-2001-1069": {"epss_score": 0.0009, "epss_percentile": 0.26063}, "CVE-2001-1070": {"epss_score": 0.00275, "epss_percentile": 0.50674}, "CVE-2001-1071": {"epss_score": 0.00865, "epss_percentile": 0.74617}, "CVE-2001-1072": {"epss_score": 0.00666, "epss_percentile": 0.70681}, "CVE-2001-1073": {"epss_score": 0.00808, "epss_percentile": 0.73688}, "CVE-2001-1074": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2001-1075": {"epss_score": 0.03872, "epss_percentile": 0.87882}, "CVE-2001-1076": {"epss_score": 0.00209, "epss_percentile": 0.43399}, "CVE-2001-1077": {"epss_score": 0.00293, "epss_percentile": 0.52334}, "CVE-2001-1078": {"epss_score": 0.14451, "epss_percentile": 0.94214}, "CVE-2001-1079": {"epss_score": 0.00043, "epss_percentile": 0.13351}, "CVE-2001-1080": {"epss_score": 0.03407, "epss_percentile": 0.87078}, "CVE-2001-1081": {"epss_score": 0.03364, "epss_percentile": 0.86998}, "CVE-2001-1082": {"epss_score": 0.00872, "epss_percentile": 0.74738}, "CVE-2001-1083": {"epss_score": 0.16695, "epss_percentile": 0.94716}, "CVE-2001-1084": {"epss_score": 0.00289, "epss_percentile": 0.52018}, "CVE-2001-1085": {"epss_score": 0.00378, "epss_percentile": 0.58827}, "CVE-2001-1086": {"epss_score": 0.03174, "epss_percentile": 0.8656}, "CVE-2001-1087": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2001-1088": {"epss_score": 0.35396, "epss_percentile": 0.96905}, "CVE-2001-1089": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2001-1090": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2001-1091": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-2001-1092": {"epss_score": 0.00185, "epss_percentile": 0.40482}, "CVE-2001-1093": {"epss_score": 0.00157, "epss_percentile": 0.37078}, "CVE-2001-1094": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2001-1095": {"epss_score": 0.00096, "epss_percentile": 0.27277}, "CVE-2001-1096": {"epss_score": 0.00103, "epss_percentile": 0.29008}, "CVE-2001-1097": {"epss_score": 0.1669, "epss_percentile": 0.94715}, "CVE-2001-1098": {"epss_score": 0.00114, "epss_percentile": 0.30763}, "CVE-2001-1099": {"epss_score": 0.02829, "epss_percentile": 0.85772}, "CVE-2001-1100": {"epss_score": 0.01972, "epss_percentile": 0.83108}, "CVE-2001-1101": {"epss_score": 0.00638, "epss_percentile": 0.6992}, "CVE-2001-1102": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2001-1103": {"epss_score": 0.00972, "epss_percentile": 0.76141}, "CVE-2001-1104": {"epss_score": 0.04316, "epss_percentile": 0.88538}, "CVE-2001-1105": {"epss_score": 0.00266, "epss_percentile": 0.49881}, "CVE-2001-1106": {"epss_score": 0.01461, "epss_percentile": 0.8043}, "CVE-2001-1107": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2001-1108": {"epss_score": 0.03876, "epss_percentile": 0.87888}, "CVE-2001-1109": {"epss_score": 0.05522, "epss_percentile": 0.89959}, "CVE-2001-1110": {"epss_score": 0.00814, "epss_percentile": 0.73777}, "CVE-2001-1111": {"epss_score": 0.00074, "epss_percentile": 0.2281}, "CVE-2001-1112": {"epss_score": 0.05386, "epss_percentile": 0.89821}, "CVE-2001-1113": {"epss_score": 0.01631, "epss_percentile": 0.81454}, "CVE-2001-1114": {"epss_score": 0.0286, "epss_percentile": 0.8585}, "CVE-2001-1115": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2001-1116": {"epss_score": 0.001, "epss_percentile": 0.28452}, "CVE-2001-1117": {"epss_score": 0.01511, "epss_percentile": 0.80778}, "CVE-2001-1118": {"epss_score": 0.01513, "epss_percentile": 0.80791}, "CVE-2001-1119": {"epss_score": 0.00085, "epss_percentile": 0.25111}, "CVE-2001-1120": {"epss_score": 0.01777, "epss_percentile": 0.82225}, "CVE-2001-1122": {"epss_score": 0.00257, "epss_percentile": 0.48847}, "CVE-2001-1123": {"epss_score": 0.0009, "epss_percentile": 0.26059}, "CVE-2001-1124": {"epss_score": 0.00794, "epss_percentile": 0.73455}, "CVE-2001-1125": {"epss_score": 0.03443, "epss_percentile": 0.87143}, "CVE-2001-1126": {"epss_score": 0.01153, "epss_percentile": 0.78062}, "CVE-2001-1127": {"epss_score": 0.00014, "epss_percentile": 0.0211}, "CVE-2001-1128": {"epss_score": 0.0002, "epss_percentile": 0.04548}, "CVE-2001-1129": {"epss_score": 0.00019, "epss_percentile": 0.04189}, "CVE-2001-1130": {"epss_score": 0.04404, "epss_percentile": 0.88651}, "CVE-2001-1131": {"epss_score": 0.0058, "epss_percentile": 0.68255}, "CVE-2001-1132": {"epss_score": 0.00856, "epss_percentile": 0.74474}, "CVE-2001-1133": {"epss_score": 0.00421, "epss_percentile": 0.6151}, "CVE-2001-1134": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2001-1135": {"epss_score": 0.00743, "epss_percentile": 0.72481}, "CVE-2001-1136": {"epss_score": 0.00102, "epss_percentile": 0.28876}, "CVE-2001-1137": {"epss_score": 0.04693, "epss_percentile": 0.89015}, "CVE-2001-1138": {"epss_score": 0.05461, "epss_percentile": 0.89901}, "CVE-2001-1139": {"epss_score": 0.05216, "epss_percentile": 0.8962}, "CVE-2001-1140": {"epss_score": 0.00996, "epss_percentile": 0.76446}, "CVE-2001-1141": {"epss_score": 0.01367, "epss_percentile": 0.79783}, "CVE-2001-1142": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2001-1143": {"epss_score": 0.01085, "epss_percentile": 0.77403}, "CVE-2001-1144": {"epss_score": 0.05264, "epss_percentile": 0.89671}, "CVE-2001-1145": {"epss_score": 0.00063, "epss_percentile": 0.19892}, "CVE-2001-1146": {"epss_score": 0.00109, "epss_percentile": 0.30025}, "CVE-2001-1147": {"epss_score": 0.00075, "epss_percentile": 0.23025}, "CVE-2001-1148": {"epss_score": 0.00113, "epss_percentile": 0.30597}, "CVE-2001-1149": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2001-1150": {"epss_score": 0.01014, "epss_percentile": 0.76639}, "CVE-2001-1151": {"epss_score": 0.01095, "epss_percentile": 0.77509}, "CVE-2001-1152": {"epss_score": 0.00415, "epss_percentile": 0.61121}, "CVE-2001-1153": {"epss_score": 0.00054, "epss_percentile": 0.17307}, "CVE-2001-1154": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-1155": {"epss_score": 0.00197, "epss_percentile": 0.41872}, "CVE-2001-1156": {"epss_score": 0.05875, "epss_percentile": 0.90285}, "CVE-2001-1157": {"epss_score": 0.00415, "epss_percentile": 0.61121}, "CVE-2001-1158": {"epss_score": 0.04823, "epss_percentile": 0.8918}, "CVE-2001-1159": {"epss_score": 0.02402, "epss_percentile": 0.84642}, "CVE-2001-1160": {"epss_score": 0.08785, "epss_percentile": 0.92254}, "CVE-2001-1161": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2001-1162": {"epss_score": 0.30171, "epss_percentile": 0.96516}, "CVE-2001-1163": {"epss_score": 0.04462, "epss_percentile": 0.88725}, "CVE-2001-1164": {"epss_score": 0.00055, "epss_percentile": 0.17535}, "CVE-2001-1165": {"epss_score": 0.00211, "epss_percentile": 0.43703}, "CVE-2001-1166": {"epss_score": 0.00585, "epss_percentile": 0.68406}, "CVE-2001-1168": {"epss_score": 0.00503, "epss_percentile": 0.65457}, "CVE-2001-1169": {"epss_score": 0.00471, "epss_percentile": 0.64006}, "CVE-2001-1170": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2001-1171": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2001-1172": {"epss_score": 0.00077, "epss_percentile": 0.23297}, "CVE-2001-1173": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2001-1174": {"epss_score": 0.04255, "epss_percentile": 0.88457}, "CVE-2001-1175": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2001-1176": {"epss_score": 0.02313, "epss_percentile": 0.84348}, "CVE-2001-1177": {"epss_score": 0.00265, "epss_percentile": 0.49816}, "CVE-2001-1178": {"epss_score": 0.00152, "epss_percentile": 0.36439}, "CVE-2001-1179": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-2001-1180": {"epss_score": 0.00151, "epss_percentile": 0.36214}, "CVE-2001-1181": {"epss_score": 0.00053, "epss_percentile": 0.16829}, "CVE-2001-1182": {"epss_score": 0.00052, "epss_percentile": 0.16514}, "CVE-2001-1183": {"epss_score": 0.00568, "epss_percentile": 0.67887}, "CVE-2001-1184": {"epss_score": 0.19476, "epss_percentile": 0.95191}, "CVE-2001-1185": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-2001-1186": {"epss_score": 0.25176, "epss_percentile": 0.95993}, "CVE-2001-1187": {"epss_score": 0.02324, "epss_percentile": 0.8438}, "CVE-2001-1188": {"epss_score": 0.0237, "epss_percentile": 0.84525}, "CVE-2001-1189": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2001-1190": {"epss_score": 0.00074, "epss_percentile": 0.2281}, "CVE-2001-1191": {"epss_score": 0.00607, "epss_percentile": 0.69029}, "CVE-2001-1192": {"epss_score": 0.01066, "epss_percentile": 0.77222}, "CVE-2001-1193": {"epss_score": 0.01067, "epss_percentile": 0.7723}, "CVE-2001-1194": {"epss_score": 0.05422, "epss_percentile": 0.89863}, "CVE-2001-1195": {"epss_score": 0.04702, "epss_percentile": 0.89028}, "CVE-2001-1196": {"epss_score": 0.03792, "epss_percentile": 0.87732}, "CVE-2001-1197": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2001-1198": {"epss_score": 0.00047, "epss_percentile": 0.14656}, "CVE-2001-1199": {"epss_score": 0.04669, "epss_percentile": 0.88985}, "CVE-2001-1200": {"epss_score": 0.00249, "epss_percentile": 0.48006}, "CVE-2001-1201": {"epss_score": 0.00083, "epss_percentile": 0.24758}, "CVE-2001-1202": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2001-1203": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2001-1204": {"epss_score": 0.0156, "epss_percentile": 0.81037}, "CVE-2001-1205": {"epss_score": 0.00493, "epss_percentile": 0.65031}, "CVE-2001-1206": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2001-1207": {"epss_score": 0.07256, "epss_percentile": 0.91353}, "CVE-2001-1208": {"epss_score": 0.01624, "epss_percentile": 0.81414}, "CVE-2001-1209": {"epss_score": 0.04669, "epss_percentile": 0.88985}, "CVE-2001-1210": {"epss_score": 0.00609, "epss_percentile": 0.69127}, "CVE-2001-1211": {"epss_score": 0.00096, "epss_percentile": 0.27318}, "CVE-2001-1212": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2001-1213": {"epss_score": 0.00526, "epss_percentile": 0.6641}, "CVE-2001-1214": {"epss_score": 0.0273, "epss_percentile": 0.85537}, "CVE-2001-1215": {"epss_score": 0.01983, "epss_percentile": 0.83146}, "CVE-2001-1216": {"epss_score": 0.04701, "epss_percentile": 0.89025}, "CVE-2001-1217": {"epss_score": 0.06551, "epss_percentile": 0.90843}, "CVE-2001-1218": {"epss_score": 0.00244, "epss_percentile": 0.47613}, "CVE-2001-1219": {"epss_score": 0.05218, "epss_percentile": 0.89622}, "CVE-2001-1220": {"epss_score": 0.00806, "epss_percentile": 0.73662}, "CVE-2001-1221": {"epss_score": 0.00563, "epss_percentile": 0.67734}, "CVE-2001-1222": {"epss_score": 0.02256, "epss_percentile": 0.84172}, "CVE-2001-1223": {"epss_score": 0.02316, "epss_percentile": 0.84355}, "CVE-2001-1224": {"epss_score": 0.01286, "epss_percentile": 0.79186}, "CVE-2001-1225": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2001-1226": {"epss_score": 0.00621, "epss_percentile": 0.69479}, "CVE-2001-1227": {"epss_score": 0.00702, "epss_percentile": 0.71507}, "CVE-2001-1228": {"epss_score": 0.01327, "epss_percentile": 0.79486}, "CVE-2001-1229": {"epss_score": 0.02088, "epss_percentile": 0.83555}, "CVE-2001-1230": {"epss_score": 0.02024, "epss_percentile": 0.8331}, "CVE-2001-1231": {"epss_score": 0.01659, "epss_percentile": 0.81613}, "CVE-2001-1232": {"epss_score": 0.00737, "epss_percentile": 0.72318}, "CVE-2001-1233": {"epss_score": 0.00653, "epss_percentile": 0.70326}, "CVE-2001-1234": {"epss_score": 0.03889, "epss_percentile": 0.87909}, "CVE-2001-1235": {"epss_score": 0.02972, "epss_percentile": 0.86096}, "CVE-2001-1236": {"epss_score": 0.02428, "epss_percentile": 0.84721}, "CVE-2001-1237": {"epss_score": 0.051, "epss_percentile": 0.89497}, "CVE-2001-1238": {"epss_score": 0.00514, "epss_percentile": 0.65951}, "CVE-2001-1239": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-1240": {"epss_score": 0.00461, "epss_percentile": 0.63564}, "CVE-2001-1241": {"epss_score": 0.02963, "epss_percentile": 0.86075}, "CVE-2001-1242": {"epss_score": 0.04752, "epss_percentile": 0.89104}, "CVE-2001-1243": {"epss_score": 0.19535, "epss_percentile": 0.95202}, "CVE-2001-1244": {"epss_score": 0.19586, "epss_percentile": 0.95211}, "CVE-2001-1245": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2001-1246": {"epss_score": 0.05407, "epss_percentile": 0.8984}, "CVE-2001-1247": {"epss_score": 0.01155, "epss_percentile": 0.78071}, "CVE-2001-1248": {"epss_score": 0.00808, "epss_percentile": 0.73688}, "CVE-2001-1249": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2001-1250": {"epss_score": 0.0071, "epss_percentile": 0.71727}, "CVE-2001-1251": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2001-1252": {"epss_score": 0.00824, "epss_percentile": 0.73941}, "CVE-2001-1253": {"epss_score": 0.00053, "epss_percentile": 0.16907}, "CVE-2001-1254": {"epss_score": 0.00555, "epss_percentile": 0.67471}, "CVE-2001-1255": {"epss_score": 0.00143, "epss_percentile": 0.35105}, "CVE-2001-1256": {"epss_score": 0.0034, "epss_percentile": 0.56271}, "CVE-2001-1257": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2001-1258": {"epss_score": 0.00112, "epss_percentile": 0.30445}, "CVE-2001-1259": {"epss_score": 0.02964, "epss_percentile": 0.86077}, "CVE-2001-1260": {"epss_score": 0.00518, "epss_percentile": 0.66136}, "CVE-2001-1261": {"epss_score": 0.00479, "epss_percentile": 0.64433}, "CVE-2001-1262": {"epss_score": 0.00486, "epss_percentile": 0.64748}, "CVE-2001-1263": {"epss_score": 0.04656, "epss_percentile": 0.88973}, "CVE-2001-1264": {"epss_score": 0.01336, "epss_percentile": 0.79552}, "CVE-2001-1265": {"epss_score": 0.00751, "epss_percentile": 0.72634}, "CVE-2001-1266": {"epss_score": 0.01475, "epss_percentile": 0.80526}, "CVE-2001-1267": {"epss_score": 0.00126, "epss_percentile": 0.32738}, "CVE-2001-1268": {"epss_score": 0.0073, "epss_percentile": 0.72155}, "CVE-2001-1269": {"epss_score": 0.00261, "epss_percentile": 0.49313}, "CVE-2001-1270": {"epss_score": 0.00144, "epss_percentile": 0.35331}, "CVE-2001-1271": {"epss_score": 0.00144, "epss_percentile": 0.35331}, "CVE-2001-1272": {"epss_score": 0.00059, "epss_percentile": 0.18829}, "CVE-2001-1273": {"epss_score": 0.00051, "epss_percentile": 0.15986}, "CVE-2001-1274": {"epss_score": 0.06849, "epss_percentile": 0.91072}, "CVE-2001-1275": {"epss_score": 0.00455, "epss_percentile": 0.63286}, "CVE-2001-1276": {"epss_score": 0.00092, "epss_percentile": 0.26522}, "CVE-2001-1277": {"epss_score": 0.00136, "epss_percentile": 0.34172}, "CVE-2001-1278": {"epss_score": 0.00409, "epss_percentile": 0.60761}, "CVE-2001-1279": {"epss_score": 0.17293, "epss_percentile": 0.94817}, "CVE-2001-1280": {"epss_score": 0.00172, "epss_percentile": 0.38907}, "CVE-2001-1281": {"epss_score": 0.00063, "epss_percentile": 0.19822}, "CVE-2001-1282": {"epss_score": 0.00172, "epss_percentile": 0.38907}, "CVE-2001-1283": {"epss_score": 0.00347, "epss_percentile": 0.56748}, "CVE-2001-1284": {"epss_score": 0.00147, "epss_percentile": 0.35685}, "CVE-2001-1285": {"epss_score": 0.0013, "epss_percentile": 0.33316}, "CVE-2001-1286": {"epss_score": 0.00113, "epss_percentile": 0.30703}, "CVE-2001-1287": {"epss_score": 0.0201, "epss_percentile": 0.83247}, "CVE-2001-1288": {"epss_score": 0.00776, "epss_percentile": 0.73096}, "CVE-2001-1289": {"epss_score": 0.01222, "epss_percentile": 0.78661}, "CVE-2001-1290": {"epss_score": 0.03137, "epss_percentile": 0.86481}, "CVE-2001-1291": {"epss_score": 0.07238, "epss_percentile": 0.91343}, "CVE-2001-1292": {"epss_score": 0.02752, "epss_percentile": 0.85583}, "CVE-2001-1293": {"epss_score": 0.00701, "epss_percentile": 0.71491}, "CVE-2001-1294": {"epss_score": 0.0071, "epss_percentile": 0.71727}, "CVE-2001-1295": {"epss_score": 0.01609, "epss_percentile": 0.81317}, "CVE-2001-1296": {"epss_score": 0.00656, "epss_percentile": 0.70437}, "CVE-2001-1297": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2001-1298": {"epss_score": 0.00465, "epss_percentile": 0.63755}, "CVE-2001-1299": {"epss_score": 0.02711, "epss_percentile": 0.85497}, "CVE-2001-1300": {"epss_score": 0.0041, "epss_percentile": 0.60815}, "CVE-2001-1301": {"epss_score": 0.00192, "epss_percentile": 0.41369}, "CVE-2001-1302": {"epss_score": 0.00745, "epss_percentile": 0.7253}, "CVE-2001-1303": {"epss_score": 0.0351, "epss_percentile": 0.87265}, "CVE-2001-1304": {"epss_score": 0.00622, "epss_percentile": 0.69509}, "CVE-2001-1305": {"epss_score": 0.00522, "epss_percentile": 0.66252}, "CVE-2001-1306": {"epss_score": 0.04612, "epss_percentile": 0.88916}, "CVE-2001-1307": {"epss_score": 0.07467, "epss_percentile": 0.9149}, "CVE-2001-1308": {"epss_score": 0.17524, "epss_percentile": 0.9486}, "CVE-2001-1309": {"epss_score": 0.06312, "epss_percentile": 0.90665}, "CVE-2001-1310": {"epss_score": 0.08844, "epss_percentile": 0.92282}, "CVE-2001-1311": {"epss_score": 0.15707, "epss_percentile": 0.94488}, "CVE-2001-1312": {"epss_score": 0.08844, "epss_percentile": 0.92282}, "CVE-2001-1313": {"epss_score": 0.05808, "epss_percentile": 0.90225}, "CVE-2001-1314": {"epss_score": 0.1012, "epss_percentile": 0.92857}, "CVE-2001-1315": {"epss_score": 0.06572, "epss_percentile": 0.90855}, "CVE-2001-1316": {"epss_score": 0.07467, "epss_percentile": 0.9149}, "CVE-2001-1317": {"epss_score": 0.04499, "epss_percentile": 0.88764}, "CVE-2001-1318": {"epss_score": 0.07682, "epss_percentile": 0.91623}, "CVE-2001-1319": {"epss_score": 0.11626, "epss_percentile": 0.93424}, "CVE-2001-1320": {"epss_score": 0.66694, "epss_percentile": 0.98474}, "CVE-2001-1321": {"epss_score": 0.02952, "epss_percentile": 0.86055}, "CVE-2001-1322": {"epss_score": 0.00104, "epss_percentile": 0.29128}, "CVE-2001-1323": {"epss_score": 0.0212, "epss_percentile": 0.83674}, "CVE-2001-1324": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2001-1325": {"epss_score": 0.13842, "epss_percentile": 0.94074}, "CVE-2001-1326": {"epss_score": 0.0375, "epss_percentile": 0.87673}, "CVE-2001-1327": {"epss_score": 0.00145, "epss_percentile": 0.35379}, "CVE-2001-1328": {"epss_score": 0.06209, "epss_percentile": 0.90569}, "CVE-2001-1329": {"epss_score": 0.00052, "epss_percentile": 0.16548}, "CVE-2001-1330": {"epss_score": 0.00052, "epss_percentile": 0.16548}, "CVE-2001-1331": {"epss_score": 0.00066, "epss_percentile": 0.20705}, "CVE-2001-1332": {"epss_score": 0.04255, "epss_percentile": 0.88457}, "CVE-2001-1333": {"epss_score": 0.00074, "epss_percentile": 0.22867}, "CVE-2001-1334": {"epss_score": 0.06958, "epss_percentile": 0.91148}, "CVE-2001-1335": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2001-1336": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2001-1337": {"epss_score": 0.00715, "epss_percentile": 0.7185}, "CVE-2001-1338": {"epss_score": 0.04249, "epss_percentile": 0.88449}, "CVE-2001-1339": {"epss_score": 0.24277, "epss_percentile": 0.95899}, "CVE-2001-1340": {"epss_score": 0.01786, "epss_percentile": 0.82259}, "CVE-2001-1341": {"epss_score": 0.02484, "epss_percentile": 0.84882}, "CVE-2001-1342": {"epss_score": 0.0774, "epss_percentile": 0.91653}, "CVE-2001-1343": {"epss_score": 0.05899, "epss_percentile": 0.90307}, "CVE-2001-1344": {"epss_score": 0.02142, "epss_percentile": 0.83755}, "CVE-2001-1345": {"epss_score": 0.00061, "epss_percentile": 0.19395}, "CVE-2001-1346": {"epss_score": 0.00592, "epss_percentile": 0.68609}, "CVE-2001-1347": {"epss_score": 0.00647, "epss_percentile": 0.70208}, "CVE-2001-1348": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2001-1349": {"epss_score": 0.00089, "epss_percentile": 0.2594}, "CVE-2001-1350": {"epss_score": 0.00803, "epss_percentile": 0.73595}, "CVE-2001-1351": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2001-1352": {"epss_score": 0.01243, "epss_percentile": 0.78831}, "CVE-2001-1353": {"epss_score": 0.00068, "epss_percentile": 0.21261}, "CVE-2001-1354": {"epss_score": 0.00146, "epss_percentile": 0.35544}, "CVE-2001-1355": {"epss_score": 0.01326, "epss_percentile": 0.79477}, "CVE-2001-1356": {"epss_score": 0.011, "epss_percentile": 0.77569}, "CVE-2001-1357": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-2001-1358": {"epss_score": 0.00213, "epss_percentile": 0.43833}, "CVE-2001-1359": {"epss_score": 0.00707, "epss_percentile": 0.71653}, "CVE-2001-1360": {"epss_score": 0.00052, "epss_percentile": 0.16474}, "CVE-2001-1361": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-2001-1362": {"epss_score": 0.00406, "epss_percentile": 0.60554}, "CVE-2001-1363": {"epss_score": 0.00483, "epss_percentile": 0.6461}, "CVE-2001-1364": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-2001-1365": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-2001-1366": {"epss_score": 0.00814, "epss_percentile": 0.73777}, "CVE-2001-1367": {"epss_score": 0.00933, "epss_percentile": 0.75638}, "CVE-2001-1368": {"epss_score": 0.00487, "epss_percentile": 0.64818}, "CVE-2001-1369": {"epss_score": 0.00515, "epss_percentile": 0.65986}, "CVE-2001-1370": {"epss_score": 0.30068, "epss_percentile": 0.96502}, "CVE-2001-1371": {"epss_score": 0.04432, "epss_percentile": 0.88679}, "CVE-2001-1372": {"epss_score": 0.0821, "epss_percentile": 0.91931}, "CVE-2001-1373": {"epss_score": 0.00562, "epss_percentile": 0.67692}, "CVE-2001-1374": {"epss_score": 0.00053, "epss_percentile": 0.17036}, "CVE-2001-1375": {"epss_score": 0.00136, "epss_percentile": 0.34197}, "CVE-2001-1376": {"epss_score": 0.30489, "epss_percentile": 0.96545}, "CVE-2001-1377": {"epss_score": 0.13337, "epss_percentile": 0.93936}, "CVE-2001-1378": {"epss_score": 0.00046, "epss_percentile": 0.14434}, "CVE-2001-1379": {"epss_score": 0.01272, "epss_percentile": 0.7908}, "CVE-2001-1380": {"epss_score": 0.03143, "epss_percentile": 0.86491}, "CVE-2001-1382": {"epss_score": 0.00561, "epss_percentile": 0.67667}, "CVE-2001-1383": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2001-1384": {"epss_score": 0.00324, "epss_percentile": 0.54963}, "CVE-2001-1385": {"epss_score": 0.00668, "epss_percentile": 0.70726}, "CVE-2001-1386": {"epss_score": 0.00729, "epss_percentile": 0.72134}, "CVE-2001-1387": {"epss_score": 0.00109, "epss_percentile": 0.29959}, "CVE-2001-1388": {"epss_score": 0.00422, "epss_percentile": 0.61554}, "CVE-2001-1389": {"epss_score": 0.02435, "epss_percentile": 0.84738}, "CVE-2001-1390": {"epss_score": 0.00054, "epss_percentile": 0.17253}, "CVE-2001-1391": {"epss_score": 0.00087, "epss_percentile": 0.25602}, "CVE-2001-1392": {"epss_score": 0.00071, "epss_percentile": 0.22053}, "CVE-2001-1393": {"epss_score": 0.00071, "epss_percentile": 0.22053}, "CVE-2001-1394": {"epss_score": 0.0006, "epss_percentile": 0.19163}, "CVE-2001-1395": {"epss_score": 0.00137, "epss_percentile": 0.3428}, "CVE-2001-1396": {"epss_score": 0.00137, "epss_percentile": 0.3428}, "CVE-2001-1397": {"epss_score": 0.00137, "epss_percentile": 0.3428}, "CVE-2001-1398": {"epss_score": 0.01279, "epss_percentile": 0.7913}, "CVE-2001-1399": {"epss_score": 0.00137, "epss_percentile": 0.3428}, "CVE-2001-1400": {"epss_score": 0.0006, "epss_percentile": 0.19163}, "CVE-2001-1401": {"epss_score": 0.00883, "epss_percentile": 0.74918}, "CVE-2001-1402": {"epss_score": 0.01122, "epss_percentile": 0.77782}, "CVE-2001-1403": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2001-1404": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2001-1405": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2001-1406": {"epss_score": 0.00207, "epss_percentile": 0.43188}, "CVE-2001-1407": {"epss_score": 0.00489, "epss_percentile": 0.64872}, "CVE-2001-1408": {"epss_score": 0.03779, "epss_percentile": 0.87717}, "CVE-2001-1409": {"epss_score": 0.00075, "epss_percentile": 0.22982}, "CVE-2001-1410": {"epss_score": 0.6159, "epss_percentile": 0.98254}, "CVE-2001-1411": {"epss_score": 0.00081, "epss_percentile": 0.24271}, "CVE-2001-1412": {"epss_score": 0.00231, "epss_percentile": 0.4584}, "CVE-2001-1413": {"epss_score": 0.0903, "epss_percentile": 0.92374}, "CVE-2001-1414": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2001-1415": {"epss_score": 0.00423, "epss_percentile": 0.61585}, "CVE-2001-1416": {"epss_score": 0.02327, "epss_percentile": 0.84392}, "CVE-2001-1417": {"epss_score": 0.02027, "epss_percentile": 0.8332}, "CVE-2001-1418": {"epss_score": 0.02759, "epss_percentile": 0.85596}, "CVE-2001-1419": {"epss_score": 0.05663, "epss_percentile": 0.90098}, "CVE-2001-1420": {"epss_score": 0.02348, "epss_percentile": 0.84462}, "CVE-2001-1421": {"epss_score": 0.01962, "epss_percentile": 0.83064}, "CVE-2001-1422": {"epss_score": 0.01505, "epss_percentile": 0.80741}, "CVE-2001-1423": {"epss_score": 0.02307, "epss_percentile": 0.84326}, "CVE-2001-1424": {"epss_score": 0.03432, "epss_percentile": 0.87125}, "CVE-2001-1425": {"epss_score": 0.04163, "epss_percentile": 0.88339}, "CVE-2001-1426": {"epss_score": 0.03181, "epss_percentile": 0.86578}, "CVE-2001-1427": {"epss_score": 0.14501, "epss_percentile": 0.94226}, "CVE-2001-1428": {"epss_score": 0.04025, "epss_percentile": 0.88138}, "CVE-2001-1429": {"epss_score": 0.00314, "epss_percentile": 0.54105}, "CVE-2001-1430": {"epss_score": 0.02088, "epss_percentile": 0.83556}, "CVE-2001-1431": {"epss_score": 0.00753, "epss_percentile": 0.72669}, "CVE-2001-1432": {"epss_score": 0.0057, "epss_percentile": 0.6797}, "CVE-2001-1433": {"epss_score": 0.01268, "epss_percentile": 0.79026}, "CVE-2001-1434": {"epss_score": 0.00608, "epss_percentile": 0.69071}, "CVE-2001-1435": {"epss_score": 0.01792, "epss_percentile": 0.82286}, "CVE-2001-1436": {"epss_score": 0.00343, "epss_percentile": 0.56432}, "CVE-2001-1437": {"epss_score": 0.0126, "epss_percentile": 0.78972}, "CVE-2001-1438": {"epss_score": 0.01053, "epss_percentile": 0.77099}, "CVE-2001-1439": {"epss_score": 0.01302, "epss_percentile": 0.79303}, "CVE-2001-1440": {"epss_score": 0.03098, "epss_percentile": 0.86405}, "CVE-2001-1441": {"epss_score": 0.01198, "epss_percentile": 0.78454}, "CVE-2001-1442": {"epss_score": 0.0044, "epss_percentile": 0.62636}, "CVE-2001-1443": {"epss_score": 0.0109, "epss_percentile": 0.77447}, "CVE-2001-1444": {"epss_score": 0.01039, "epss_percentile": 0.76946}, "CVE-2001-1445": {"epss_score": 0.00852, "epss_percentile": 0.7442}, "CVE-2001-1446": {"epss_score": 0.00527, "epss_percentile": 0.66446}, "CVE-2001-1447": {"epss_score": 0.00074, "epss_percentile": 0.22683}, "CVE-2001-1448": {"epss_score": 0.00121, "epss_percentile": 0.31953}, "CVE-2001-1449": {"epss_score": 0.05425, "epss_percentile": 0.89867}, "CVE-2001-1450": {"epss_score": 0.08659, "epss_percentile": 0.92176}, "CVE-2001-1451": {"epss_score": 0.13002, "epss_percentile": 0.9384}, "CVE-2001-1452": {"epss_score": 0.04026, "epss_percentile": 0.88141}, "CVE-2001-1453": {"epss_score": 0.11664, "epss_percentile": 0.93438}, "CVE-2001-1454": {"epss_score": 0.1185, "epss_percentile": 0.93495}, "CVE-2001-1455": {"epss_score": 0.00762, "epss_percentile": 0.72842}, "CVE-2001-1456": {"epss_score": 0.09057, "epss_percentile": 0.92383}, "CVE-2001-1457": {"epss_score": 0.06034, "epss_percentile": 0.90425}, "CVE-2001-1458": {"epss_score": 0.00888, "epss_percentile": 0.75001}, "CVE-2001-1459": {"epss_score": 0.0048, "epss_percentile": 0.64452}, "CVE-2001-1460": {"epss_score": 0.03984, "epss_percentile": 0.88062}, "CVE-2001-1461": {"epss_score": 0.00533, "epss_percentile": 0.66769}, "CVE-2001-1462": {"epss_score": 0.01571, "epss_percentile": 0.81095}, "CVE-2001-1463": {"epss_score": 0.07382, "epss_percentile": 0.91445}, "CVE-2001-1464": {"epss_score": 0.00695, "epss_percentile": 0.71372}, "CVE-2001-1465": {"epss_score": 0.00047, "epss_percentile": 0.14485}, "CVE-2001-1466": {"epss_score": 0.14428, "epss_percentile": 0.9421}, "CVE-2001-1467": {"epss_score": 0.00637, "epss_percentile": 0.69896}, "CVE-2001-1468": {"epss_score": 0.01711, "epss_percentile": 0.81882}, "CVE-2001-1469": {"epss_score": 0.00492, "epss_percentile": 0.64988}, "CVE-2001-1470": {"epss_score": 0.00978, "epss_percentile": 0.76243}, "CVE-2001-1471": {"epss_score": 0.01172, "epss_percentile": 0.78229}, "CVE-2001-1472": {"epss_score": 0.00835, "epss_percentile": 0.74117}, "CVE-2001-1473": {"epss_score": 0.05458, "epss_percentile": 0.89899}, "CVE-2001-1474": {"epss_score": 0.01471, "epss_percentile": 0.80499}, "CVE-2001-1475": {"epss_score": 0.01352, "epss_percentile": 0.79683}, "CVE-2001-1476": {"epss_score": 0.0042, "epss_percentile": 0.61454}, "CVE-2001-1477": {"epss_score": 0.00076, "epss_percentile": 0.23155}, "CVE-2001-1478": {"epss_score": 0.0006, "epss_percentile": 0.19092}, "CVE-2001-1479": {"epss_score": 0.00059, "epss_percentile": 0.18833}, "CVE-2001-1480": {"epss_score": 0.0054, "epss_percentile": 0.67011}, "CVE-2001-1481": {"epss_score": 0.01697, "epss_percentile": 0.81816}, "CVE-2001-1482": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2001-1483": {"epss_score": 0.01471, "epss_percentile": 0.80502}, "CVE-2001-1484": {"epss_score": 0.05859, "epss_percentile": 0.90269}, "CVE-2001-1487": {"epss_score": 0.00107, "epss_percentile": 0.29615}, "CVE-2001-1488": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2001-1489": {"epss_score": 0.13452, "epss_percentile": 0.9397}, "CVE-2001-1490": {"epss_score": 0.05024, "epss_percentile": 0.89407}, "CVE-2001-1491": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2001-1494": {"epss_score": 0.00079, "epss_percentile": 0.23872}, "CVE-2001-1495": {"epss_score": 0.00982, "epss_percentile": 0.76295}, "CVE-2001-1496": {"epss_score": 0.17762, "epss_percentile": 0.94902}, "CVE-2001-1497": {"epss_score": 0.00556, "epss_percentile": 0.67526}, "CVE-2001-1498": {"epss_score": 0.0007, "epss_percentile": 0.21775}, "CVE-2001-1499": {"epss_score": 0.00698, "epss_percentile": 0.7142}, "CVE-2001-1500": {"epss_score": 0.01085, "epss_percentile": 0.77406}, "CVE-2001-1501": {"epss_score": 0.08154, "epss_percentile": 0.91906}, "CVE-2001-1502": {"epss_score": 0.08721, "epss_percentile": 0.92227}, "CVE-2001-1503": {"epss_score": 0.00262, "epss_percentile": 0.494}, "CVE-2001-1504": {"epss_score": 0.02987, "epss_percentile": 0.86135}, "CVE-2001-1505": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2001-1506": {"epss_score": 0.00066, "epss_percentile": 0.20701}, "CVE-2001-1507": {"epss_score": 0.01048, "epss_percentile": 0.77053}, "CVE-2001-1508": {"epss_score": 0.00103, "epss_percentile": 0.29057}, "CVE-2001-1509": {"epss_score": 0.00103, "epss_percentile": 0.29067}, "CVE-2001-1510": {"epss_score": 0.03731, "epss_percentile": 0.87644}, "CVE-2001-1511": {"epss_score": 0.0059, "epss_percentile": 0.68559}, "CVE-2001-1512": {"epss_score": 0.00375, "epss_percentile": 0.58633}, "CVE-2001-1513": {"epss_score": 0.0831, "epss_percentile": 0.91984}, "CVE-2001-1514": {"epss_score": 0.00079, "epss_percentile": 0.23878}, "CVE-2001-1515": {"epss_score": 0.00888, "epss_percentile": 0.75002}, "CVE-2001-1516": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2001-1517": {"epss_score": 0.00879, "epss_percentile": 0.74841}, "CVE-2001-1518": {"epss_score": 0.01608, "epss_percentile": 0.81314}, "CVE-2001-1519": {"epss_score": 0.02797, "epss_percentile": 0.85685}, "CVE-2001-1520": {"epss_score": 0.00147, "epss_percentile": 0.35661}, "CVE-2001-1521": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2001-1522": {"epss_score": 0.00021, "epss_percentile": 0.04718}, "CVE-2001-1523": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2001-1524": {"epss_score": 0.00106, "epss_percentile": 0.29405}, "CVE-2001-1525": {"epss_score": 0.04431, "epss_percentile": 0.88679}, "CVE-2001-1526": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2001-1527": {"epss_score": 0.00065, "epss_percentile": 0.2052}, "CVE-2001-1528": {"epss_score": 0.07856, "epss_percentile": 0.91723}, "CVE-2001-1529": {"epss_score": 0.006, "epss_percentile": 0.68829}, "CVE-2001-1530": {"epss_score": 0.00047, "epss_percentile": 0.14755}, "CVE-2001-1531": {"epss_score": 0.04151, "epss_percentile": 0.88321}, "CVE-2001-1532": {"epss_score": 0.00467, "epss_percentile": 0.63851}, "CVE-2001-1533": {"epss_score": 0.26888, "epss_percentile": 0.96188}, "CVE-2001-1534": {"epss_score": 0.00108, "epss_percentile": 0.2976}, "CVE-2001-1535": {"epss_score": 0.0015, "epss_percentile": 0.36143}, "CVE-2001-1536": {"epss_score": 0.00765, "epss_percentile": 0.72926}, "CVE-2001-1537": {"epss_score": 0.00204, "epss_percentile": 0.42654}, "CVE-2001-1538": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2001-1539": {"epss_score": 0.17159, "epss_percentile": 0.94789}, "CVE-2001-1540": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-1541": {"epss_score": 0.0026, "epss_percentile": 0.4915}, "CVE-2001-1542": {"epss_score": 0.00913, "epss_percentile": 0.75367}, "CVE-2001-1543": {"epss_score": 0.00901, "epss_percentile": 0.75169}, "CVE-2001-1544": {"epss_score": 0.00376, "epss_percentile": 0.5866}, "CVE-2001-1545": {"epss_score": 0.00387, "epss_percentile": 0.59299}, "CVE-2001-1546": {"epss_score": 0.00106, "epss_percentile": 0.29469}, "CVE-2001-1547": {"epss_score": 0.21823, "epss_percentile": 0.95563}, "CVE-2001-1548": {"epss_score": 0.00054, "epss_percentile": 0.17258}, "CVE-2001-1549": {"epss_score": 0.00135, "epss_percentile": 0.33986}, "CVE-2001-1550": {"epss_score": 0.00185, "epss_percentile": 0.40513}, "CVE-2001-1551": {"epss_score": 0.00083, "epss_percentile": 0.24734}, "CVE-2001-1552": {"epss_score": 0.22391, "epss_percentile": 0.95631}, "CVE-2001-1553": {"epss_score": 0.00091, "epss_percentile": 0.2623}, "CVE-2001-1554": {"epss_score": 0.0079, "epss_percentile": 0.73374}, "CVE-2001-1555": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2001-1556": {"epss_score": 0.01768, "epss_percentile": 0.8218}, "CVE-2001-1557": {"epss_score": 0.00417, "epss_percentile": 0.61258}, "CVE-2001-1558": {"epss_score": 0.00406, "epss_percentile": 0.60529}, "CVE-2001-1559": {"epss_score": 0.00404, "epss_percentile": 0.60411}, "CVE-2001-1560": {"epss_score": 0.008, "epss_percentile": 0.73532}, "CVE-2001-1561": {"epss_score": 0.00219, "epss_percentile": 0.4451}, "CVE-2001-1562": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2001-1563": {"epss_score": 0.0498, "epss_percentile": 0.89359}, "CVE-2001-1564": {"epss_score": 0.00095, "epss_percentile": 0.27133}, "CVE-2001-1565": {"epss_score": 0.0018, "epss_percentile": 0.3988}, "CVE-2001-1566": {"epss_score": 0.02116, "epss_percentile": 0.83662}, "CVE-2001-1567": {"epss_score": 0.00394, "epss_percentile": 0.59771}, "CVE-2001-1568": {"epss_score": 0.00181, "epss_percentile": 0.40052}, "CVE-2001-1569": {"epss_score": 0.00373, "epss_percentile": 0.5848}, "CVE-2001-1570": {"epss_score": 0.00321, "epss_percentile": 0.54652}, "CVE-2001-1571": {"epss_score": 0.3026, "epss_percentile": 0.96523}, "CVE-2001-1572": {"epss_score": 0.00403, "epss_percentile": 0.60375}, "CVE-2001-1573": {"epss_score": 0.01946, "epss_percentile": 0.83003}, "CVE-2001-1574": {"epss_score": 0.02621, "epss_percentile": 0.85255}, "CVE-2001-1575": {"epss_score": 0.00926, "epss_percentile": 0.75551}, "CVE-2001-1576": {"epss_score": 0.00091, "epss_percentile": 0.2623}, "CVE-2001-1577": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2001-1578": {"epss_score": 0.00084, "epss_percentile": 0.24863}, "CVE-2001-1579": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2001-1580": {"epss_score": 0.04122, "epss_percentile": 0.88284}, "CVE-2001-1581": {"epss_score": 0.00246, "epss_percentile": 0.47732}, "CVE-2001-1582": {"epss_score": 0.00171, "epss_percentile": 0.38854}, "CVE-2001-1583": {"epss_score": 0.51992, "epss_percentile": 0.97805}, "CVE-2001-1584": {"epss_score": 0.00777, "epss_percentile": 0.73113}, "CVE-2001-1585": {"epss_score": 0.00323, "epss_percentile": 0.54891}, "CVE-2001-1586": {"epss_score": 0.035, "epss_percentile": 0.87244}, "CVE-2001-1587": {"epss_score": 0.01317, "epss_percentile": 0.79413}, "CVE-2001-1593": {"epss_score": 0.00125, "epss_percentile": 0.32566}, "CVE-2001-1594": {"epss_score": 0.00568, "epss_percentile": 0.67896}, "CVE-2002-0001": {"epss_score": 0.02091, "epss_percentile": 0.8357}, "CVE-2002-0002": {"epss_score": 0.14916, "epss_percentile": 0.94322}, "CVE-2002-0003": {"epss_score": 0.01067, "epss_percentile": 0.77226}, "CVE-2002-0004": {"epss_score": 0.00274, "epss_percentile": 0.50572}, "CVE-2002-0005": {"epss_score": 0.2793, "epss_percentile": 0.96296}, "CVE-2002-0006": {"epss_score": 0.08631, "epss_percentile": 0.92163}, "CVE-2002-0007": {"epss_score": 0.01839, "epss_percentile": 0.8249}, "CVE-2002-0008": {"epss_score": 0.02143, "epss_percentile": 0.83757}, "CVE-2002-0009": {"epss_score": 0.00862, "epss_percentile": 0.74583}, "CVE-2002-0010": {"epss_score": 0.0371, "epss_percentile": 0.87605}, "CVE-2002-0011": {"epss_score": 0.00926, "epss_percentile": 0.75548}, "CVE-2002-0012": {"epss_score": 0.48368, "epss_percentile": 0.97634}, "CVE-2002-0013": {"epss_score": 0.5757, "epss_percentile": 0.9807}, "CVE-2002-0014": {"epss_score": 0.01246, "epss_percentile": 0.78857}, "CVE-2002-0017": {"epss_score": 0.06055, "epss_percentile": 0.90438}, "CVE-2002-0018": {"epss_score": 0.36151, "epss_percentile": 0.96958}, "CVE-2002-0020": {"epss_score": 0.26362, "epss_percentile": 0.9614}, "CVE-2002-0021": {"epss_score": 0.19067, "epss_percentile": 0.95123}, "CVE-2002-0022": {"epss_score": 0.3525, "epss_percentile": 0.96896}, "CVE-2002-0023": {"epss_score": 0.34244, "epss_percentile": 0.96836}, "CVE-2002-0024": {"epss_score": 0.04487, "epss_percentile": 0.8875}, "CVE-2002-0025": {"epss_score": 0.15342, "epss_percentile": 0.94413}, "CVE-2002-0026": {"epss_score": 0.07118, "epss_percentile": 0.91261}, "CVE-2002-0027": {"epss_score": 0.11699, "epss_percentile": 0.93455}, "CVE-2002-0028": {"epss_score": 0.19075, "epss_percentile": 0.95125}, "CVE-2002-0029": {"epss_score": 0.21847, "epss_percentile": 0.95567}, "CVE-2002-0030": {"epss_score": 0.00217, "epss_percentile": 0.44278}, "CVE-2002-0031": {"epss_score": 0.21415, "epss_percentile": 0.95514}, "CVE-2002-0032": {"epss_score": 0.02942, "epss_percentile": 0.86035}, "CVE-2002-0033": {"epss_score": 0.55469, "epss_percentile": 0.97979}, "CVE-2002-0034": {"epss_score": 0.00193, "epss_percentile": 0.41396}, "CVE-2002-0036": {"epss_score": 0.1901, "epss_percentile": 0.95111}, "CVE-2002-0037": {"epss_score": 0.0044, "epss_percentile": 0.62615}, "CVE-2002-0038": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2002-0039": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2002-0040": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2002-0041": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2002-0042": {"epss_score": 0.00144, "epss_percentile": 0.35317}, "CVE-2002-0043": {"epss_score": 0.00193, "epss_percentile": 0.41443}, "CVE-2002-0044": {"epss_score": 0.00141, "epss_percentile": 0.34846}, "CVE-2002-0045": {"epss_score": 0.03236, "epss_percentile": 0.86703}, "CVE-2002-0046": {"epss_score": 0.01202, "epss_percentile": 0.78488}, "CVE-2002-0047": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-0048": {"epss_score": 0.81764, "epss_percentile": 0.99154}, "CVE-2002-0049": {"epss_score": 0.12663, "epss_percentile": 0.93743}, "CVE-2002-0050": {"epss_score": 0.12164, "epss_percentile": 0.93587}, "CVE-2002-0051": {"epss_score": 0.00959, "epss_percentile": 0.75951}, "CVE-2002-0052": {"epss_score": 0.34376, "epss_percentile": 0.96844}, "CVE-2002-0053": {"epss_score": 0.49147, "epss_percentile": 0.9767}, "CVE-2002-0054": {"epss_score": 0.12536, "epss_percentile": 0.9371}, "CVE-2002-0055": {"epss_score": 0.48421, "epss_percentile": 0.97637}, "CVE-2002-0056": {"epss_score": 0.21265, "epss_percentile": 0.95491}, "CVE-2002-0057": {"epss_score": 0.41761, "epss_percentile": 0.97293}, "CVE-2002-0058": {"epss_score": 0.02808, "epss_percentile": 0.85711}, "CVE-2002-0059": {"epss_score": 0.36552, "epss_percentile": 0.96986}, "CVE-2002-0060": {"epss_score": 0.03326, "epss_percentile": 0.86923}, "CVE-2002-0061": {"epss_score": 0.89023, "epss_percentile": 0.99506}, "CVE-2002-0062": {"epss_score": 0.00203, "epss_percentile": 0.42532}, "CVE-2002-0063": {"epss_score": 0.01938, "epss_percentile": 0.82969}, "CVE-2002-0064": {"epss_score": 0.00114, "epss_percentile": 0.30868}, "CVE-2002-0065": {"epss_score": 0.00085, "epss_percentile": 0.25044}, "CVE-2002-0066": {"epss_score": 0.01669, "epss_percentile": 0.81667}, "CVE-2002-0067": {"epss_score": 0.00223, "epss_percentile": 0.44902}, "CVE-2002-0068": {"epss_score": 0.05561, "epss_percentile": 0.89995}, "CVE-2002-0069": {"epss_score": 0.01106, "epss_percentile": 0.7762}, "CVE-2002-0070": {"epss_score": 0.3229, "epss_percentile": 0.96686}, "CVE-2002-0071": {"epss_score": 0.67642, "epss_percentile": 0.98515}, "CVE-2002-0072": {"epss_score": 0.30982, "epss_percentile": 0.96579}, "CVE-2002-0073": {"epss_score": 0.6712, "epss_percentile": 0.98495}, "CVE-2002-0074": {"epss_score": 0.67563, "epss_percentile": 0.98513}, "CVE-2002-0075": {"epss_score": 0.67563, "epss_percentile": 0.98513}, "CVE-2002-0076": {"epss_score": 0.01075, "epss_percentile": 0.77316}, "CVE-2002-0077": {"epss_score": 0.0794, "epss_percentile": 0.91778}, "CVE-2002-0078": {"epss_score": 0.20335, "epss_percentile": 0.95328}, "CVE-2002-0079": {"epss_score": 0.84917, "epss_percentile": 0.9931}, "CVE-2002-0080": {"epss_score": 0.00791, "epss_percentile": 0.73383}, "CVE-2002-0081": {"epss_score": 0.58603, "epss_percentile": 0.98126}, "CVE-2002-0082": {"epss_score": 0.02507, "epss_percentile": 0.8494}, "CVE-2002-0083": {"epss_score": 0.02062, "epss_percentile": 0.83447}, "CVE-2002-0084": {"epss_score": 0.03227, "epss_percentile": 0.86688}, "CVE-2002-0085": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2002-0086": {"epss_score": 0.00072, "epss_percentile": 0.22408}, "CVE-2002-0087": {"epss_score": 0.00125, "epss_percentile": 0.32569}, "CVE-2002-0088": {"epss_score": 0.00053, "epss_percentile": 0.16821}, "CVE-2002-0089": {"epss_score": 0.00077, "epss_percentile": 0.23403}, "CVE-2002-0090": {"epss_score": 0.00137, "epss_percentile": 0.34315}, "CVE-2002-0091": {"epss_score": 0.01014, "epss_percentile": 0.76646}, "CVE-2002-0092": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2002-0093": {"epss_score": 0.00465, "epss_percentile": 0.63769}, "CVE-2002-0094": {"epss_score": 0.01452, "epss_percentile": 0.80365}, "CVE-2002-0095": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-0096": {"epss_score": 0.00053, "epss_percentile": 0.16794}, "CVE-2002-0097": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2002-0098": {"epss_score": 0.02207, "epss_percentile": 0.84005}, "CVE-2002-0099": {"epss_score": 0.00733, "epss_percentile": 0.72218}, "CVE-2002-0100": {"epss_score": 0.00655, "epss_percentile": 0.70369}, "CVE-2002-0101": {"epss_score": 0.10619, "epss_percentile": 0.93051}, "CVE-2002-0102": {"epss_score": 0.00798, "epss_percentile": 0.73509}, "CVE-2002-0103": {"epss_score": 0.0008, "epss_percentile": 0.24126}, "CVE-2002-0104": {"epss_score": 0.00919, "epss_percentile": 0.75453}, "CVE-2002-0105": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2002-0106": {"epss_score": 0.0604, "epss_percentile": 0.90428}, "CVE-2002-0107": {"epss_score": 0.06466, "epss_percentile": 0.90774}, "CVE-2002-0108": {"epss_score": 0.00806, "epss_percentile": 0.73649}, "CVE-2002-0109": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2002-0110": {"epss_score": 0.00656, "epss_percentile": 0.7045}, "CVE-2002-0111": {"epss_score": 0.01136, "epss_percentile": 0.77915}, "CVE-2002-0112": {"epss_score": 0.07497, "epss_percentile": 0.91503}, "CVE-2002-0113": {"epss_score": 0.0005, "epss_percentile": 0.15736}, "CVE-2002-0114": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2002-0115": {"epss_score": 0.0842, "epss_percentile": 0.92043}, "CVE-2002-0116": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2002-0117": {"epss_score": 0.09557, "epss_percentile": 0.92598}, "CVE-2002-0118": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-0119": {"epss_score": 0.00866, "epss_percentile": 0.74633}, "CVE-2002-0120": {"epss_score": 0.00099, "epss_percentile": 0.28358}, "CVE-2002-0121": {"epss_score": 0.00142, "epss_percentile": 0.35046}, "CVE-2002-0122": {"epss_score": 0.01317, "epss_percentile": 0.79416}, "CVE-2002-0123": {"epss_score": 0.00986, "epss_percentile": 0.7633}, "CVE-2002-0124": {"epss_score": 0.01177, "epss_percentile": 0.78276}, "CVE-2002-0125": {"epss_score": 0.00058, "epss_percentile": 0.1828}, "CVE-2002-0126": {"epss_score": 0.03994, "epss_percentile": 0.88083}, "CVE-2002-0127": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2002-0128": {"epss_score": 0.08653, "epss_percentile": 0.92174}, "CVE-2002-0129": {"epss_score": 0.00207, "epss_percentile": 0.43188}, "CVE-2002-0130": {"epss_score": 0.00054, "epss_percentile": 0.17272}, "CVE-2002-0131": {"epss_score": 0.00661, "epss_percentile": 0.70564}, "CVE-2002-0132": {"epss_score": 0.00357, "epss_percentile": 0.57428}, "CVE-2002-0133": {"epss_score": 0.04362, "epss_percentile": 0.88597}, "CVE-2002-0134": {"epss_score": 0.01613, "epss_percentile": 0.81343}, "CVE-2002-0135": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2002-0136": {"epss_score": 0.08905, "epss_percentile": 0.92309}, "CVE-2002-0137": {"epss_score": 0.00348, "epss_percentile": 0.56843}, "CVE-2002-0138": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-2002-0139": {"epss_score": 0.01062, "epss_percentile": 0.77184}, "CVE-2002-0140": {"epss_score": 0.04802, "epss_percentile": 0.89159}, "CVE-2002-0141": {"epss_score": 0.00192, "epss_percentile": 0.41369}, "CVE-2002-0142": {"epss_score": 0.05682, "epss_percentile": 0.90118}, "CVE-2002-0143": {"epss_score": 0.00549, "epss_percentile": 0.67309}, "CVE-2002-0144": {"epss_score": 0.00785, "epss_percentile": 0.73246}, "CVE-2002-0145": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2002-0146": {"epss_score": 0.00857, "epss_percentile": 0.74497}, "CVE-2002-0147": {"epss_score": 0.37487, "epss_percentile": 0.97051}, "CVE-2002-0148": {"epss_score": 0.7335, "epss_percentile": 0.98748}, "CVE-2002-0149": {"epss_score": 0.49796, "epss_percentile": 0.97706}, "CVE-2002-0150": {"epss_score": 0.67619, "epss_percentile": 0.98515}, "CVE-2002-0151": {"epss_score": 0.02904, "epss_percentile": 0.8596}, "CVE-2002-0152": {"epss_score": 0.22554, "epss_percentile": 0.9565}, "CVE-2002-0153": {"epss_score": 0.42802, "epss_percentile": 0.97354}, "CVE-2002-0154": {"epss_score": 0.22599, "epss_percentile": 0.95655}, "CVE-2002-0155": {"epss_score": 0.19137, "epss_percentile": 0.95138}, "CVE-2002-0157": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2002-0158": {"epss_score": 0.00178, "epss_percentile": 0.39704}, "CVE-2002-0159": {"epss_score": 0.02343, "epss_percentile": 0.84442}, "CVE-2002-0160": {"epss_score": 0.00558, "epss_percentile": 0.67571}, "CVE-2002-0162": {"epss_score": 0.0031, "epss_percentile": 0.53792}, "CVE-2002-0163": {"epss_score": 0.03895, "epss_percentile": 0.87915}, "CVE-2002-0164": {"epss_score": 0.0008, "epss_percentile": 0.2405}, "CVE-2002-0165": {"epss_score": 0.00064, "epss_percentile": 0.20431}, "CVE-2002-0166": {"epss_score": 0.01414, "epss_percentile": 0.8013}, "CVE-2002-0167": {"epss_score": 0.00945, "epss_percentile": 0.75804}, "CVE-2002-0168": {"epss_score": 0.00945, "epss_percentile": 0.75804}, "CVE-2002-0169": {"epss_score": 0.0008, "epss_percentile": 0.24187}, "CVE-2002-0170": {"epss_score": 0.00743, "epss_percentile": 0.72481}, "CVE-2002-0171": {"epss_score": 0.01534, "epss_percentile": 0.80902}, "CVE-2002-0172": {"epss_score": 0.00223, "epss_percentile": 0.44885}, "CVE-2002-0173": {"epss_score": 0.0005, "epss_percentile": 0.15721}, "CVE-2002-0174": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2002-0175": {"epss_score": 0.00081, "epss_percentile": 0.24301}, "CVE-2002-0176": {"epss_score": 0.00159, "epss_percentile": 0.37385}, "CVE-2002-0177": {"epss_score": 0.23373, "epss_percentile": 0.95771}, "CVE-2002-0178": {"epss_score": 0.00127, "epss_percentile": 0.32881}, "CVE-2002-0179": {"epss_score": 0.0321, "epss_percentile": 0.86652}, "CVE-2002-0180": {"epss_score": 0.03039, "epss_percentile": 0.86269}, "CVE-2002-0181": {"epss_score": 0.01495, "epss_percentile": 0.80656}, "CVE-2002-0184": {"epss_score": 0.00212, "epss_percentile": 0.43785}, "CVE-2002-0185": {"epss_score": 0.04008, "epss_percentile": 0.88105}, "CVE-2002-0186": {"epss_score": 0.78192, "epss_percentile": 0.98972}, "CVE-2002-0187": {"epss_score": 0.14879, "epss_percentile": 0.94313}, "CVE-2002-0188": {"epss_score": 0.20209, "epss_percentile": 0.95304}, "CVE-2002-0189": {"epss_score": 0.13759, "epss_percentile": 0.94052}, "CVE-2002-0190": {"epss_score": 0.18172, "epss_percentile": 0.9497}, "CVE-2002-0191": {"epss_score": 0.15061, "epss_percentile": 0.94353}, "CVE-2002-0193": {"epss_score": 0.45776, "epss_percentile": 0.97502}, "CVE-2002-0196": {"epss_score": 0.00442, "epss_percentile": 0.62746}, "CVE-2002-0197": {"epss_score": 0.01062, "epss_percentile": 0.77184}, "CVE-2002-0198": {"epss_score": 0.05634, "epss_percentile": 0.90071}, "CVE-2002-0199": {"epss_score": 0.01816, "epss_percentile": 0.82391}, "CVE-2002-0200": {"epss_score": 0.04077, "epss_percentile": 0.88212}, "CVE-2002-0201": {"epss_score": 0.0293, "epss_percentile": 0.86015}, "CVE-2002-0202": {"epss_score": 0.00073, "epss_percentile": 0.225}, "CVE-2002-0203": {"epss_score": 0.00494, "epss_percentile": 0.65088}, "CVE-2002-0204": {"epss_score": 0.0321, "epss_percentile": 0.86652}, "CVE-2002-0205": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2002-0206": {"epss_score": 0.00588, "epss_percentile": 0.68491}, "CVE-2002-0207": {"epss_score": 0.08489, "epss_percentile": 0.92081}, "CVE-2002-0208": {"epss_score": 0.01312, "epss_percentile": 0.79378}, "CVE-2002-0209": {"epss_score": 0.07825, "epss_percentile": 0.917}, "CVE-2002-0210": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-2002-0211": {"epss_score": 0.00315, "epss_percentile": 0.5418}, "CVE-2002-0212": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2002-0213": {"epss_score": 0.00102, "epss_percentile": 0.28834}, "CVE-2002-0214": {"epss_score": 0.00075, "epss_percentile": 0.22948}, "CVE-2002-0215": {"epss_score": 0.08197, "epss_percentile": 0.91925}, "CVE-2002-0216": {"epss_score": 0.00829, "epss_percentile": 0.74009}, "CVE-2002-0217": {"epss_score": 0.01288, "epss_percentile": 0.79202}, "CVE-2002-0218": {"epss_score": 0.00105, "epss_percentile": 0.29349}, "CVE-2002-0219": {"epss_score": 0.00149, "epss_percentile": 0.35968}, "CVE-2002-0220": {"epss_score": 0.00982, "epss_percentile": 0.76295}, "CVE-2002-0221": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-0222": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2002-0223": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2002-0224": {"epss_score": 0.58255, "epss_percentile": 0.98104}, "CVE-2002-0225": {"epss_score": 0.00215, "epss_percentile": 0.44108}, "CVE-2002-0226": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2002-0227": {"epss_score": 0.05586, "epss_percentile": 0.90024}, "CVE-2002-0228": {"epss_score": 0.28613, "epss_percentile": 0.96372}, "CVE-2002-0229": {"epss_score": 0.05445, "epss_percentile": 0.89887}, "CVE-2002-0230": {"epss_score": 0.05006, "epss_percentile": 0.89386}, "CVE-2002-0231": {"epss_score": 0.01728, "epss_percentile": 0.8197}, "CVE-2002-0232": {"epss_score": 0.01324, "epss_percentile": 0.79465}, "CVE-2002-0233": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2002-0234": {"epss_score": 0.00083, "epss_percentile": 0.24628}, "CVE-2002-0235": {"epss_score": 0.00801, "epss_percentile": 0.73578}, "CVE-2002-0236": {"epss_score": 0.07281, "epss_percentile": 0.91383}, "CVE-2002-0237": {"epss_score": 0.03243, "epss_percentile": 0.86738}, "CVE-2002-0238": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2002-0239": {"epss_score": 0.00266, "epss_percentile": 0.499}, "CVE-2002-0240": {"epss_score": 0.01688, "epss_percentile": 0.81764}, "CVE-2002-0241": {"epss_score": 0.00189, "epss_percentile": 0.40932}, "CVE-2002-0242": {"epss_score": 0.03376, "epss_percentile": 0.87022}, "CVE-2002-0243": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2002-0244": {"epss_score": 0.01919, "epss_percentile": 0.82883}, "CVE-2002-0245": {"epss_score": 0.00901, "epss_percentile": 0.75169}, "CVE-2002-0246": {"epss_score": 0.00238, "epss_percentile": 0.46776}, "CVE-2002-0247": {"epss_score": 0.00053, "epss_percentile": 0.16821}, "CVE-2002-0248": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2002-0249": {"epss_score": 0.02831, "epss_percentile": 0.85776}, "CVE-2002-0250": {"epss_score": 0.07086, "epss_percentile": 0.91242}, "CVE-2002-0251": {"epss_score": 0.07306, "epss_percentile": 0.91396}, "CVE-2002-0252": {"epss_score": 0.044, "epss_percentile": 0.88645}, "CVE-2002-0253": {"epss_score": 0.00915, "epss_percentile": 0.75408}, "CVE-2002-0254": {"epss_score": 0.00975, "epss_percentile": 0.76198}, "CVE-2002-0255": {"epss_score": 0.01811, "epss_percentile": 0.82366}, "CVE-2002-0256": {"epss_score": 0.06281, "epss_percentile": 0.90638}, "CVE-2002-0257": {"epss_score": 0.06648, "epss_percentile": 0.90914}, "CVE-2002-0258": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2002-0259": {"epss_score": 0.00061, "epss_percentile": 0.19395}, "CVE-2002-0260": {"epss_score": 0.0331, "epss_percentile": 0.86887}, "CVE-2002-0261": {"epss_score": 0.03165, "epss_percentile": 0.86538}, "CVE-2002-0262": {"epss_score": 0.01172, "epss_percentile": 0.78226}, "CVE-2002-0263": {"epss_score": 0.10942, "epss_percentile": 0.93167}, "CVE-2002-0264": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2002-0265": {"epss_score": 0.00442, "epss_percentile": 0.62736}, "CVE-2002-0266": {"epss_score": 0.05247, "epss_percentile": 0.89662}, "CVE-2002-0267": {"epss_score": 0.02198, "epss_percentile": 0.83963}, "CVE-2002-0268": {"epss_score": 0.00073, "epss_percentile": 0.22483}, "CVE-2002-0269": {"epss_score": 0.04187, "epss_percentile": 0.88366}, "CVE-2002-0270": {"epss_score": 0.00281, "epss_percentile": 0.51196}, "CVE-2002-0271": {"epss_score": 0.00083, "epss_percentile": 0.24603}, "CVE-2002-0272": {"epss_score": 0.05476, "epss_percentile": 0.89914}, "CVE-2002-0273": {"epss_score": 0.00486, "epss_percentile": 0.64748}, "CVE-2002-0274": {"epss_score": 0.00086, "epss_percentile": 0.25364}, "CVE-2002-0275": {"epss_score": 0.00645, "epss_percentile": 0.70099}, "CVE-2002-0276": {"epss_score": 0.17328, "epss_percentile": 0.94824}, "CVE-2002-0277": {"epss_score": 0.01232, "epss_percentile": 0.78738}, "CVE-2002-0278": {"epss_score": 0.01957, "epss_percentile": 0.83046}, "CVE-2002-0279": {"epss_score": 0.0013, "epss_percentile": 0.33293}, "CVE-2002-0280": {"epss_score": 0.09861, "epss_percentile": 0.92741}, "CVE-2002-0281": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2002-0282": {"epss_score": 0.01395, "epss_percentile": 0.79973}, "CVE-2002-0283": {"epss_score": 0.04917, "epss_percentile": 0.89288}, "CVE-2002-0284": {"epss_score": 0.0045, "epss_percentile": 0.63074}, "CVE-2002-0285": {"epss_score": 0.06992, "epss_percentile": 0.91168}, "CVE-2002-0286": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2002-0287": {"epss_score": 0.0069, "epss_percentile": 0.71247}, "CVE-2002-0288": {"epss_score": 0.03839, "epss_percentile": 0.87827}, "CVE-2002-0289": {"epss_score": 0.04306, "epss_percentile": 0.88523}, "CVE-2002-0290": {"epss_score": 0.03736, "epss_percentile": 0.87651}, "CVE-2002-0291": {"epss_score": 0.01681, "epss_percentile": 0.81728}, "CVE-2002-0292": {"epss_score": 0.00854, "epss_percentile": 0.74453}, "CVE-2002-0293": {"epss_score": 0.00067, "epss_percentile": 0.21112}, "CVE-2002-0294": {"epss_score": 0.00075, "epss_percentile": 0.22996}, "CVE-2002-0295": {"epss_score": 0.00055, "epss_percentile": 0.17535}, "CVE-2002-0296": {"epss_score": 0.00152, "epss_percentile": 0.36466}, "CVE-2002-0297": {"epss_score": 0.01588, "epss_percentile": 0.81188}, "CVE-2002-0298": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2002-0299": {"epss_score": 0.00655, "epss_percentile": 0.70363}, "CVE-2002-0300": {"epss_score": 0.05112, "epss_percentile": 0.8951}, "CVE-2002-0301": {"epss_score": 0.00619, "epss_percentile": 0.69427}, "CVE-2002-0302": {"epss_score": 0.00707, "epss_percentile": 0.71643}, "CVE-2002-0303": {"epss_score": 0.0004, "epss_percentile": 0.11986}, "CVE-2002-0304": {"epss_score": 0.00948, "epss_percentile": 0.75831}, "CVE-2002-0305": {"epss_score": 0.00669, "epss_percentile": 0.70748}, "CVE-2002-0306": {"epss_score": 0.01005, "epss_percentile": 0.76536}, "CVE-2002-0307": {"epss_score": 0.04509, "epss_percentile": 0.88779}, "CVE-2002-0308": {"epss_score": 0.00432, "epss_percentile": 0.6216}, "CVE-2002-0309": {"epss_score": 0.01683, "epss_percentile": 0.8174}, "CVE-2002-0310": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2002-0311": {"epss_score": 0.03745, "epss_percentile": 0.8766}, "CVE-2002-0312": {"epss_score": 0.03013, "epss_percentile": 0.86205}, "CVE-2002-0313": {"epss_score": 0.10208, "epss_percentile": 0.92894}, "CVE-2002-0314": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-0315": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2002-0316": {"epss_score": 0.04572, "epss_percentile": 0.88864}, "CVE-2002-0317": {"epss_score": 0.00737, "epss_percentile": 0.72333}, "CVE-2002-0318": {"epss_score": 0.0098, "epss_percentile": 0.76275}, "CVE-2002-0319": {"epss_score": 0.08223, "epss_percentile": 0.91938}, "CVE-2002-0320": {"epss_score": 0.10307, "epss_percentile": 0.92936}, "CVE-2002-0321": {"epss_score": 0.0233, "epss_percentile": 0.844}, "CVE-2002-0322": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2002-0323": {"epss_score": 0.00379, "epss_percentile": 0.58907}, "CVE-2002-0324": {"epss_score": 0.00943, "epss_percentile": 0.75776}, "CVE-2002-0325": {"epss_score": 0.06716, "epss_percentile": 0.90964}, "CVE-2002-0326": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2002-0327": {"epss_score": 0.00335, "epss_percentile": 0.55855}, "CVE-2002-0328": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2002-0329": {"epss_score": 0.237, "epss_percentile": 0.95805}, "CVE-2002-0330": {"epss_score": 0.06965, "epss_percentile": 0.91151}, "CVE-2002-0331": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-0332": {"epss_score": 0.13595, "epss_percentile": 0.94006}, "CVE-2002-0333": {"epss_score": 0.02773, "epss_percentile": 0.8563}, "CVE-2002-0334": {"epss_score": 0.00192, "epss_percentile": 0.41369}, "CVE-2002-0335": {"epss_score": 0.11518, "epss_percentile": 0.93391}, "CVE-2002-0336": {"epss_score": 0.11473, "epss_percentile": 0.93377}, "CVE-2002-0337": {"epss_score": 0.01153, "epss_percentile": 0.78056}, "CVE-2002-0338": {"epss_score": 0.10348, "epss_percentile": 0.92953}, "CVE-2002-0339": {"epss_score": 0.02257, "epss_percentile": 0.84174}, "CVE-2002-0340": {"epss_score": 0.04001, "epss_percentile": 0.88092}, "CVE-2002-0341": {"epss_score": 0.00172, "epss_percentile": 0.38989}, "CVE-2002-0342": {"epss_score": 0.01317, "epss_percentile": 0.79416}, "CVE-2002-0343": {"epss_score": 0.00156, "epss_percentile": 0.36998}, "CVE-2002-0344": {"epss_score": 0.01853, "epss_percentile": 0.82547}, "CVE-2002-0345": {"epss_score": 0.00822, "epss_percentile": 0.73916}, "CVE-2002-0346": {"epss_score": 0.12297, "epss_percentile": 0.93625}, "CVE-2002-0347": {"epss_score": 0.07853, "epss_percentile": 0.9172}, "CVE-2002-0348": {"epss_score": 0.05588, "epss_percentile": 0.90027}, "CVE-2002-0349": {"epss_score": 0.00074, "epss_percentile": 0.2281}, "CVE-2002-0350": {"epss_score": 0.00991, "epss_percentile": 0.76385}, "CVE-2002-0351": {"epss_score": 0.01896, "epss_percentile": 0.82752}, "CVE-2002-0352": {"epss_score": 0.00579, "epss_percentile": 0.6821}, "CVE-2002-0353": {"epss_score": 0.01476, "epss_percentile": 0.8053}, "CVE-2002-0354": {"epss_score": 0.00379, "epss_percentile": 0.58907}, "CVE-2002-0355": {"epss_score": 0.00157, "epss_percentile": 0.3705}, "CVE-2002-0356": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2002-0357": {"epss_score": 0.0009, "epss_percentile": 0.2604}, "CVE-2002-0358": {"epss_score": 0.00156, "epss_percentile": 0.36998}, "CVE-2002-0359": {"epss_score": 0.05849, "epss_percentile": 0.90261}, "CVE-2002-0360": {"epss_score": 0.0385, "epss_percentile": 0.87848}, "CVE-2002-0362": {"epss_score": 0.04755, "epss_percentile": 0.89112}, "CVE-2002-0363": {"epss_score": 0.00706, "epss_percentile": 0.71615}, "CVE-2002-0364": {"epss_score": 0.65661, "epss_percentile": 0.98431}, "CVE-2002-0366": {"epss_score": 0.00477, "epss_percentile": 0.64307}, "CVE-2002-0367": {"epss_score": 0.00684, "epss_percentile": 0.71117}, "CVE-2002-0368": {"epss_score": 0.21349, "epss_percentile": 0.95505}, "CVE-2002-0369": {"epss_score": 0.19258, "epss_percentile": 0.95156}, "CVE-2002-0370": {"epss_score": 0.32271, "epss_percentile": 0.96685}, "CVE-2002-0371": {"epss_score": 0.60195, "epss_percentile": 0.98197}, "CVE-2002-0372": {"epss_score": 0.07394, "epss_percentile": 0.91451}, "CVE-2002-0373": {"epss_score": 0.01714, "epss_percentile": 0.81891}, "CVE-2002-0374": {"epss_score": 0.01473, "epss_percentile": 0.80516}, "CVE-2002-0375": {"epss_score": 0.03832, "epss_percentile": 0.87811}, "CVE-2002-0376": {"epss_score": 0.03819, "epss_percentile": 0.87774}, "CVE-2002-0377": {"epss_score": 0.00217, "epss_percentile": 0.44301}, "CVE-2002-0378": {"epss_score": 0.00546, "epss_percentile": 0.67204}, "CVE-2002-0379": {"epss_score": 0.29901, "epss_percentile": 0.96485}, "CVE-2002-0380": {"epss_score": 0.04367, "epss_percentile": 0.88605}, "CVE-2002-0381": {"epss_score": 0.00784, "epss_percentile": 0.73242}, "CVE-2002-0382": {"epss_score": 0.01079, "epss_percentile": 0.77356}, "CVE-2002-0384": {"epss_score": 0.0611, "epss_percentile": 0.90487}, "CVE-2002-0385": {"epss_score": 0.00718, "epss_percentile": 0.71931}, "CVE-2002-0386": {"epss_score": 0.31798, "epss_percentile": 0.9665}, "CVE-2002-0387": {"epss_score": 0.0385, "epss_percentile": 0.87848}, "CVE-2002-0388": {"epss_score": 0.03149, "epss_percentile": 0.86501}, "CVE-2002-0389": {"epss_score": 0.00166, "epss_percentile": 0.3816}, "CVE-2002-0391": {"epss_score": 0.07582, "epss_percentile": 0.91553}, "CVE-2002-0392": {"epss_score": 0.59304, "epss_percentile": 0.9816}, "CVE-2002-0393": {"epss_score": 0.03153, "epss_percentile": 0.8651}, "CVE-2002-0394": {"epss_score": 0.00697, "epss_percentile": 0.71406}, "CVE-2002-0395": {"epss_score": 0.01214, "epss_percentile": 0.78579}, "CVE-2002-0396": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2002-0397": {"epss_score": 0.0035, "epss_percentile": 0.56949}, "CVE-2002-0398": {"epss_score": 0.00817, "epss_percentile": 0.73839}, "CVE-2002-0399": {"epss_score": 0.01203, "epss_percentile": 0.78496}, "CVE-2002-0400": {"epss_score": 0.27728, "epss_percentile": 0.96277}, "CVE-2002-0401": {"epss_score": 0.07736, "epss_percentile": 0.91651}, "CVE-2002-0402": {"epss_score": 0.02684, "epss_percentile": 0.85423}, "CVE-2002-0403": {"epss_score": 0.01824, "epss_percentile": 0.82429}, "CVE-2002-0404": {"epss_score": 0.01824, "epss_percentile": 0.82429}, "CVE-2002-0405": {"epss_score": 0.03181, "epss_percentile": 0.86578}, "CVE-2002-0406": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2002-0407": {"epss_score": 0.01303, "epss_percentile": 0.79308}, "CVE-2002-0408": {"epss_score": 0.01083, "epss_percentile": 0.77392}, "CVE-2002-0409": {"epss_score": 0.52891, "epss_percentile": 0.97845}, "CVE-2002-0410": {"epss_score": 0.01755, "epss_percentile": 0.8212}, "CVE-2002-0411": {"epss_score": 0.0108, "epss_percentile": 0.77363}, "CVE-2002-0412": {"epss_score": 0.09035, "epss_percentile": 0.92375}, "CVE-2002-0413": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-0414": {"epss_score": 0.00743, "epss_percentile": 0.72481}, "CVE-2002-0415": {"epss_score": 0.00369, "epss_percentile": 0.58269}, "CVE-2002-0416": {"epss_score": 0.04061, "epss_percentile": 0.8819}, "CVE-2002-0417": {"epss_score": 0.01164, "epss_percentile": 0.78167}, "CVE-2002-0418": {"epss_score": 0.00263, "epss_percentile": 0.49509}, "CVE-2002-0419": {"epss_score": 0.31296, "epss_percentile": 0.96606}, "CVE-2002-0420": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2002-0421": {"epss_score": 0.23698, "epss_percentile": 0.95805}, "CVE-2002-0422": {"epss_score": 0.65658, "epss_percentile": 0.98431}, "CVE-2002-0423": {"epss_score": 0.03375, "epss_percentile": 0.87016}, "CVE-2002-0424": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2002-0425": {"epss_score": 0.00741, "epss_percentile": 0.72445}, "CVE-2002-0426": {"epss_score": 0.0072, "epss_percentile": 0.71964}, "CVE-2002-0427": {"epss_score": 0.00466, "epss_percentile": 0.63796}, "CVE-2002-0428": {"epss_score": 0.00455, "epss_percentile": 0.63291}, "CVE-2002-0429": {"epss_score": 0.00078, "epss_percentile": 0.23637}, "CVE-2002-0430": {"epss_score": 0.00166, "epss_percentile": 0.38199}, "CVE-2002-0431": {"epss_score": 0.06281, "epss_percentile": 0.90638}, "CVE-2002-0432": {"epss_score": 0.04529, "epss_percentile": 0.8881}, "CVE-2002-0433": {"epss_score": 0.00684, "epss_percentile": 0.71127}, "CVE-2002-0434": {"epss_score": 0.0273, "epss_percentile": 0.85536}, "CVE-2002-0435": {"epss_score": 0.00074, "epss_percentile": 0.22722}, "CVE-2002-0436": {"epss_score": 0.03931, "epss_percentile": 0.87974}, "CVE-2002-0437": {"epss_score": 0.02191, "epss_percentile": 0.83935}, "CVE-2002-0438": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2002-0439": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2002-0440": {"epss_score": 0.04079, "epss_percentile": 0.88215}, "CVE-2002-0441": {"epss_score": 0.03043, "epss_percentile": 0.86276}, "CVE-2002-0442": {"epss_score": 0.00145, "epss_percentile": 0.35449}, "CVE-2002-0443": {"epss_score": 0.00598, "epss_percentile": 0.68776}, "CVE-2002-0444": {"epss_score": 0.09201, "epss_percentile": 0.92446}, "CVE-2002-0445": {"epss_score": 0.0063, "epss_percentile": 0.69695}, "CVE-2002-0446": {"epss_score": 0.00808, "epss_percentile": 0.73688}, "CVE-2002-0447": {"epss_score": 0.0103, "epss_percentile": 0.76846}, "CVE-2002-0448": {"epss_score": 0.07632, "epss_percentile": 0.91586}, "CVE-2002-0449": {"epss_score": 0.13006, "epss_percentile": 0.93845}, "CVE-2002-0450": {"epss_score": 0.06333, "epss_percentile": 0.90676}, "CVE-2002-0451": {"epss_score": 0.0577, "epss_percentile": 0.90192}, "CVE-2002-0452": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2002-0453": {"epss_score": 0.01679, "epss_percentile": 0.81721}, "CVE-2002-0454": {"epss_score": 0.05479, "epss_percentile": 0.89918}, "CVE-2002-0455": {"epss_score": 0.00875, "epss_percentile": 0.74783}, "CVE-2002-0456": {"epss_score": 0.00766, "epss_percentile": 0.7294}, "CVE-2002-0457": {"epss_score": 0.01297, "epss_percentile": 0.79265}, "CVE-2002-0458": {"epss_score": 0.01284, "epss_percentile": 0.79168}, "CVE-2002-0459": {"epss_score": 0.02256, "epss_percentile": 0.84171}, "CVE-2002-0460": {"epss_score": 0.01112, "epss_percentile": 0.77677}, "CVE-2002-0461": {"epss_score": 0.10752, "epss_percentile": 0.93093}, "CVE-2002-0462": {"epss_score": 0.0173, "epss_percentile": 0.81987}, "CVE-2002-0463": {"epss_score": 0.00655, "epss_percentile": 0.70423}, "CVE-2002-0464": {"epss_score": 0.01336, "epss_percentile": 0.79556}, "CVE-2002-0465": {"epss_score": 0.03682, "epss_percentile": 0.8756}, "CVE-2002-0466": {"epss_score": 0.00769, "epss_percentile": 0.72983}, "CVE-2002-0467": {"epss_score": 0.17378, "epss_percentile": 0.94842}, "CVE-2002-0468": {"epss_score": 0.00661, "epss_percentile": 0.70567}, "CVE-2002-0469": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2002-0470": {"epss_score": 0.00169, "epss_percentile": 0.38621}, "CVE-2002-0471": {"epss_score": 0.03759, "epss_percentile": 0.87685}, "CVE-2002-0472": {"epss_score": 0.1519, "epss_percentile": 0.94381}, "CVE-2002-0473": {"epss_score": 0.14537, "epss_percentile": 0.94235}, "CVE-2002-0474": {"epss_score": 0.0144, "epss_percentile": 0.80299}, "CVE-2002-0475": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2002-0476": {"epss_score": 0.01019, "epss_percentile": 0.76721}, "CVE-2002-0477": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2002-0478": {"epss_score": 0.00621, "epss_percentile": 0.69479}, "CVE-2002-0479": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2002-0480": {"epss_score": 0.00992, "epss_percentile": 0.76394}, "CVE-2002-0481": {"epss_score": 0.06392, "epss_percentile": 0.90719}, "CVE-2002-0482": {"epss_score": 0.01371, "epss_percentile": 0.79804}, "CVE-2002-0483": {"epss_score": 0.00108, "epss_percentile": 0.29903}, "CVE-2002-0484": {"epss_score": 0.06582, "epss_percentile": 0.90861}, "CVE-2002-0485": {"epss_score": 0.00334, "epss_percentile": 0.55705}, "CVE-2002-0486": {"epss_score": 0.00075, "epss_percentile": 0.23009}, "CVE-2002-0487": {"epss_score": 0.00154, "epss_percentile": 0.367}, "CVE-2002-0488": {"epss_score": 0.05137, "epss_percentile": 0.89536}, "CVE-2002-0489": {"epss_score": 0.0355, "epss_percentile": 0.87338}, "CVE-2002-0490": {"epss_score": 0.02256, "epss_percentile": 0.84171}, "CVE-2002-0491": {"epss_score": 0.00406, "epss_percentile": 0.60512}, "CVE-2002-0492": {"epss_score": 0.05599, "epss_percentile": 0.90036}, "CVE-2002-0493": {"epss_score": 0.0144, "epss_percentile": 0.803}, "CVE-2002-0494": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2002-0495": {"epss_score": 0.15154, "epss_percentile": 0.94375}, "CVE-2002-0496": {"epss_score": 0.01317, "epss_percentile": 0.79416}, "CVE-2002-0497": {"epss_score": 0.00242, "epss_percentile": 0.4738}, "CVE-2002-0498": {"epss_score": 0.00156, "epss_percentile": 0.36998}, "CVE-2002-0499": {"epss_score": 0.00461, "epss_percentile": 0.63548}, "CVE-2002-0500": {"epss_score": 0.2039, "epss_percentile": 0.95337}, "CVE-2002-0501": {"epss_score": 0.00879, "epss_percentile": 0.74834}, "CVE-2002-0502": {"epss_score": 0.04322, "epss_percentile": 0.88549}, "CVE-2002-0503": {"epss_score": 0.01392, "epss_percentile": 0.79955}, "CVE-2002-0504": {"epss_score": 0.06163, "epss_percentile": 0.90527}, "CVE-2002-0505": {"epss_score": 0.00824, "epss_percentile": 0.73937}, "CVE-2002-0506": {"epss_score": 0.00228, "epss_percentile": 0.45516}, "CVE-2002-0507": {"epss_score": 0.00987, "epss_percentile": 0.76347}, "CVE-2002-0508": {"epss_score": 0.04426, "epss_percentile": 0.88675}, "CVE-2002-0509": {"epss_score": 0.01006, "epss_percentile": 0.76547}, "CVE-2002-0510": {"epss_score": 0.01039, "epss_percentile": 0.76948}, "CVE-2002-0511": {"epss_score": 0.0026, "epss_percentile": 0.49164}, "CVE-2002-0512": {"epss_score": 0.00156, "epss_percentile": 0.36998}, "CVE-2002-0513": {"epss_score": 0.01, "epss_percentile": 0.76487}, "CVE-2002-0514": {"epss_score": 0.02089, "epss_percentile": 0.83559}, "CVE-2002-0515": {"epss_score": 0.02089, "epss_percentile": 0.83559}, "CVE-2002-0516": {"epss_score": 0.06352, "epss_percentile": 0.90691}, "CVE-2002-0517": {"epss_score": 0.00327, "epss_percentile": 0.55105}, "CVE-2002-0518": {"epss_score": 0.01108, "epss_percentile": 0.77636}, "CVE-2002-0520": {"epss_score": 0.01075, "epss_percentile": 0.77311}, "CVE-2002-0521": {"epss_score": 0.01165, "epss_percentile": 0.78171}, "CVE-2002-0522": {"epss_score": 0.00622, "epss_percentile": 0.6953}, "CVE-2002-0523": {"epss_score": 0.01951, "epss_percentile": 0.83018}, "CVE-2002-0524": {"epss_score": 0.02295, "epss_percentile": 0.84293}, "CVE-2002-0525": {"epss_score": 0.04355, "epss_percentile": 0.88589}, "CVE-2002-0526": {"epss_score": 0.00074, "epss_percentile": 0.22867}, "CVE-2002-0527": {"epss_score": 0.01296, "epss_percentile": 0.79254}, "CVE-2002-0528": {"epss_score": 0.01412, "epss_percentile": 0.80115}, "CVE-2002-0529": {"epss_score": 0.00178, "epss_percentile": 0.39738}, "CVE-2002-0530": {"epss_score": 0.00388, "epss_percentile": 0.59359}, "CVE-2002-0531": {"epss_score": 0.02781, "epss_percentile": 0.85651}, "CVE-2002-0532": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2002-0533": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2002-0534": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2002-0535": {"epss_score": 0.0792, "epss_percentile": 0.91763}, "CVE-2002-0536": {"epss_score": 0.00817, "epss_percentile": 0.73847}, "CVE-2002-0537": {"epss_score": 0.01273, "epss_percentile": 0.79085}, "CVE-2002-0538": {"epss_score": 0.029, "epss_percentile": 0.85953}, "CVE-2002-0539": {"epss_score": 0.00697, "epss_percentile": 0.71411}, "CVE-2002-0540": {"epss_score": 0.07408, "epss_percentile": 0.91456}, "CVE-2002-0541": {"epss_score": 0.0411, "epss_percentile": 0.88271}, "CVE-2002-0542": {"epss_score": 0.00357, "epss_percentile": 0.5747}, "CVE-2002-0543": {"epss_score": 0.10261, "epss_percentile": 0.92918}, "CVE-2002-0544": {"epss_score": 0.00128, "epss_percentile": 0.33068}, "CVE-2002-0545": {"epss_score": 0.00872, "epss_percentile": 0.74731}, "CVE-2002-0546": {"epss_score": 0.01048, "epss_percentile": 0.77048}, "CVE-2002-0547": {"epss_score": 0.01662, "epss_percentile": 0.81633}, "CVE-2002-0548": {"epss_score": 0.00608, "epss_percentile": 0.69074}, "CVE-2002-0549": {"epss_score": 0.00847, "epss_percentile": 0.74344}, "CVE-2002-0550": {"epss_score": 0.01922, "epss_percentile": 0.82903}, "CVE-2002-0551": {"epss_score": 0.01922, "epss_percentile": 0.82903}, "CVE-2002-0552": {"epss_score": 0.01561, "epss_percentile": 0.81043}, "CVE-2002-0553": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-0554": {"epss_score": 0.0073, "epss_percentile": 0.72153}, "CVE-2002-0555": {"epss_score": 0.01203, "epss_percentile": 0.78497}, "CVE-2002-0556": {"epss_score": 0.00263, "epss_percentile": 0.49509}, "CVE-2002-0557": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2002-0558": {"epss_score": 0.02332, "epss_percentile": 0.84407}, "CVE-2002-0559": {"epss_score": 0.26406, "epss_percentile": 0.96144}, "CVE-2002-0560": {"epss_score": 0.0564, "epss_percentile": 0.90075}, "CVE-2002-0561": {"epss_score": 0.04288, "epss_percentile": 0.88497}, "CVE-2002-0562": {"epss_score": 0.03644, "epss_percentile": 0.87497}, "CVE-2002-0563": {"epss_score": 0.34452, "epss_percentile": 0.96847}, "CVE-2002-0564": {"epss_score": 0.00842, "epss_percentile": 0.74239}, "CVE-2002-0565": {"epss_score": 0.05915, "epss_percentile": 0.90318}, "CVE-2002-0566": {"epss_score": 0.01547, "epss_percentile": 0.8097}, "CVE-2002-0567": {"epss_score": 0.01758, "epss_percentile": 0.82135}, "CVE-2002-0568": {"epss_score": 0.04804, "epss_percentile": 0.8916}, "CVE-2002-0569": {"epss_score": 0.02177, "epss_percentile": 0.83889}, "CVE-2002-0570": {"epss_score": 0.00118, "epss_percentile": 0.31405}, "CVE-2002-0571": {"epss_score": 0.00837, "epss_percentile": 0.7415}, "CVE-2002-0572": {"epss_score": 0.00277, "epss_percentile": 0.50789}, "CVE-2002-0573": {"epss_score": 0.47418, "epss_percentile": 0.97586}, "CVE-2002-0574": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2002-0575": {"epss_score": 0.02857, "epss_percentile": 0.85842}, "CVE-2002-0576": {"epss_score": 0.0143, "epss_percentile": 0.80235}, "CVE-2002-0577": {"epss_score": 0.00099, "epss_percentile": 0.28393}, "CVE-2002-0578": {"epss_score": 0.01339, "epss_percentile": 0.79574}, "CVE-2002-0579": {"epss_score": 0.01884, "epss_percentile": 0.82704}, "CVE-2002-0580": {"epss_score": 0.00847, "epss_percentile": 0.74344}, "CVE-2002-0581": {"epss_score": 0.01652, "epss_percentile": 0.81573}, "CVE-2002-0582": {"epss_score": 0.01174, "epss_percentile": 0.78254}, "CVE-2002-0583": {"epss_score": 0.01174, "epss_percentile": 0.78254}, "CVE-2002-0584": {"epss_score": 0.02256, "epss_percentile": 0.84172}, "CVE-2002-0585": {"epss_score": 0.00708, "epss_percentile": 0.71668}, "CVE-2002-0586": {"epss_score": 0.01983, "epss_percentile": 0.83146}, "CVE-2002-0587": {"epss_score": 0.01896, "epss_percentile": 0.82752}, "CVE-2002-0588": {"epss_score": 0.05053, "epss_percentile": 0.89443}, "CVE-2002-0589": {"epss_score": 0.06411, "epss_percentile": 0.90741}, "CVE-2002-0590": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-0591": {"epss_score": 0.11077, "epss_percentile": 0.93211}, "CVE-2002-0592": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2002-0593": {"epss_score": 0.03402, "epss_percentile": 0.8707}, "CVE-2002-0594": {"epss_score": 0.01268, "epss_percentile": 0.79028}, "CVE-2002-0595": {"epss_score": 0.05386, "epss_percentile": 0.89821}, "CVE-2002-0596": {"epss_score": 0.00707, "epss_percentile": 0.7164}, "CVE-2002-0597": {"epss_score": 0.56085, "epss_percentile": 0.98007}, "CVE-2002-0598": {"epss_score": 0.04328, "epss_percentile": 0.88556}, "CVE-2002-0599": {"epss_score": 0.04746, "epss_percentile": 0.89098}, "CVE-2002-0600": {"epss_score": 0.01673, "epss_percentile": 0.81689}, "CVE-2002-0601": {"epss_score": 0.01306, "epss_percentile": 0.79332}, "CVE-2002-0602": {"epss_score": 0.01122, "epss_percentile": 0.77778}, "CVE-2002-0603": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2002-0604": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2002-0605": {"epss_score": 0.12517, "epss_percentile": 0.93705}, "CVE-2002-0606": {"epss_score": 0.05517, "epss_percentile": 0.89952}, "CVE-2002-0607": {"epss_score": 0.01297, "epss_percentile": 0.79271}, "CVE-2002-0608": {"epss_score": 0.0381, "epss_percentile": 0.87757}, "CVE-2002-0609": {"epss_score": 0.01522, "epss_percentile": 0.80838}, "CVE-2002-0610": {"epss_score": 0.02654, "epss_percentile": 0.85352}, "CVE-2002-0611": {"epss_score": 0.03313, "epss_percentile": 0.86896}, "CVE-2002-0612": {"epss_score": 0.11622, "epss_percentile": 0.93423}, "CVE-2002-0613": {"epss_score": 0.0364, "epss_percentile": 0.8749}, "CVE-2002-0614": {"epss_score": 0.00808, "epss_percentile": 0.73688}, "CVE-2002-0615": {"epss_score": 0.11402, "epss_percentile": 0.93335}, "CVE-2002-0616": {"epss_score": 0.10819, "epss_percentile": 0.93121}, "CVE-2002-0617": {"epss_score": 0.04076, "epss_percentile": 0.88212}, "CVE-2002-0618": {"epss_score": 0.17276, "epss_percentile": 0.94814}, "CVE-2002-0619": {"epss_score": 0.19687, "epss_percentile": 0.95226}, "CVE-2002-0620": {"epss_score": 0.16373, "epss_percentile": 0.94638}, "CVE-2002-0621": {"epss_score": 0.16667, "epss_percentile": 0.9471}, "CVE-2002-0622": {"epss_score": 0.10267, "epss_percentile": 0.92919}, "CVE-2002-0623": {"epss_score": 0.17282, "epss_percentile": 0.94815}, "CVE-2002-0624": {"epss_score": 0.07198, "epss_percentile": 0.91316}, "CVE-2002-0626": {"epss_score": 0.00475, "epss_percentile": 0.64175}, "CVE-2002-0627": {"epss_score": 0.00787, "epss_percentile": 0.73305}, "CVE-2002-0628": {"epss_score": 0.01713, "epss_percentile": 0.81888}, "CVE-2002-0629": {"epss_score": 0.01318, "epss_percentile": 0.79423}, "CVE-2002-0630": {"epss_score": 0.01318, "epss_percentile": 0.79423}, "CVE-2002-0631": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2002-0632": {"epss_score": 0.00711, "epss_percentile": 0.7174}, "CVE-2002-0637": {"epss_score": 0.03825, "epss_percentile": 0.87792}, "CVE-2002-0638": {"epss_score": 0.00085, "epss_percentile": 0.25051}, "CVE-2002-0639": {"epss_score": 0.29734, "epss_percentile": 0.96468}, "CVE-2002-0640": {"epss_score": 0.64836, "epss_percentile": 0.98394}, "CVE-2002-0641": {"epss_score": 0.1641, "epss_percentile": 0.94647}, "CVE-2002-0642": {"epss_score": 0.7506, "epss_percentile": 0.98829}, "CVE-2002-0643": {"epss_score": 0.00815, "epss_percentile": 0.73779}, "CVE-2002-0644": {"epss_score": 0.09073, "epss_percentile": 0.92387}, "CVE-2002-0645": {"epss_score": 0.01988, "epss_percentile": 0.83164}, "CVE-2002-0647": {"epss_score": 0.15515, "epss_percentile": 0.94443}, "CVE-2002-0648": {"epss_score": 0.59276, "epss_percentile": 0.98158}, "CVE-2002-0649": {"epss_score": 0.86685, "epss_percentile": 0.99393}, "CVE-2002-0650": {"epss_score": 0.25225, "epss_percentile": 0.96}, "CVE-2002-0651": {"epss_score": 0.05437, "epss_percentile": 0.89882}, "CVE-2002-0652": {"epss_score": 0.06841, "epss_percentile": 0.91062}, "CVE-2002-0653": {"epss_score": 0.01221, "epss_percentile": 0.78652}, "CVE-2002-0654": {"epss_score": 0.75041, "epss_percentile": 0.98829}, "CVE-2002-0655": {"epss_score": 0.00883, "epss_percentile": 0.74921}, "CVE-2002-0656": {"epss_score": 0.87757, "epss_percentile": 0.99441}, "CVE-2002-0657": {"epss_score": 0.04912, "epss_percentile": 0.89281}, "CVE-2002-0658": {"epss_score": 0.01481, "epss_percentile": 0.80571}, "CVE-2002-0659": {"epss_score": 0.10408, "epss_percentile": 0.92977}, "CVE-2002-0660": {"epss_score": 0.00957, "epss_percentile": 0.75934}, "CVE-2002-0661": {"epss_score": 0.91929, "epss_percentile": 0.99679}, "CVE-2002-0662": {"epss_score": 0.00065, "epss_percentile": 0.20623}, "CVE-2002-0663": {"epss_score": 0.02824, "epss_percentile": 0.85754}, "CVE-2002-0664": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2002-0665": {"epss_score": 0.03539, "epss_percentile": 0.87314}, "CVE-2002-0666": {"epss_score": 0.00742, "epss_percentile": 0.7245}, "CVE-2002-0667": {"epss_score": 0.02198, "epss_percentile": 0.83963}, "CVE-2002-0668": {"epss_score": 0.0049, "epss_percentile": 0.64924}, "CVE-2002-0669": {"epss_score": 0.00442, "epss_percentile": 0.62702}, "CVE-2002-0670": {"epss_score": 0.01257, "epss_percentile": 0.78946}, "CVE-2002-0671": {"epss_score": 0.00512, "epss_percentile": 0.65872}, "CVE-2002-0672": {"epss_score": 0.00158, "epss_percentile": 0.3721}, "CVE-2002-0673": {"epss_score": 0.00156, "epss_percentile": 0.36998}, "CVE-2002-0674": {"epss_score": 0.00069, "epss_percentile": 0.21541}, "CVE-2002-0675": {"epss_score": 0.00156, "epss_percentile": 0.36998}, "CVE-2002-0676": {"epss_score": 0.06424, "epss_percentile": 0.90752}, "CVE-2002-0677": {"epss_score": 0.19026, "epss_percentile": 0.95113}, "CVE-2002-0678": {"epss_score": 0.0043, "epss_percentile": 0.62011}, "CVE-2002-0679": {"epss_score": 0.70866, "epss_percentile": 0.98645}, "CVE-2002-0680": {"epss_score": 0.05241, "epss_percentile": 0.89652}, "CVE-2002-0681": {"epss_score": 0.07314, "epss_percentile": 0.91403}, "CVE-2002-0682": {"epss_score": 0.666, "epss_percentile": 0.9847}, "CVE-2002-0683": {"epss_score": 0.00734, "epss_percentile": 0.72247}, "CVE-2002-0684": {"epss_score": 0.03535, "epss_percentile": 0.8731}, "CVE-2002-0685": {"epss_score": 0.01316, "epss_percentile": 0.79407}, "CVE-2002-0686": {"epss_score": 0.04583, "epss_percentile": 0.88881}, "CVE-2002-0687": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2002-0688": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2002-0690": {"epss_score": 0.17822, "epss_percentile": 0.94913}, "CVE-2002-0691": {"epss_score": 0.15058, "epss_percentile": 0.94352}, "CVE-2002-0692": {"epss_score": 0.52164, "epss_percentile": 0.97811}, "CVE-2002-0693": {"epss_score": 0.66046, "epss_percentile": 0.98449}, "CVE-2002-0694": {"epss_score": 0.28961, "epss_percentile": 0.96405}, "CVE-2002-0695": {"epss_score": 0.13253, "epss_percentile": 0.93915}, "CVE-2002-0696": {"epss_score": 0.18251, "epss_percentile": 0.94982}, "CVE-2002-0697": {"epss_score": 0.1712, "epss_percentile": 0.94779}, "CVE-2002-0698": {"epss_score": 0.17116, "epss_percentile": 0.94778}, "CVE-2002-0699": {"epss_score": 0.05187, "epss_percentile": 0.89589}, "CVE-2002-0700": {"epss_score": 0.1345, "epss_percentile": 0.93969}, "CVE-2002-0701": {"epss_score": 0.00145, "epss_percentile": 0.35435}, "CVE-2002-0702": {"epss_score": 0.37653, "epss_percentile": 0.97062}, "CVE-2002-0703": {"epss_score": 0.00594, "epss_percentile": 0.68666}, "CVE-2002-0704": {"epss_score": 0.01084, "epss_percentile": 0.77395}, "CVE-2002-0705": {"epss_score": 0.00968, "epss_percentile": 0.76078}, "CVE-2002-0706": {"epss_score": 0.00472, "epss_percentile": 0.6403}, "CVE-2002-0707": {"epss_score": 0.01282, "epss_percentile": 0.79151}, "CVE-2002-0708": {"epss_score": 0.03779, "epss_percentile": 0.87717}, "CVE-2002-0709": {"epss_score": 0.00779, "epss_percentile": 0.7314}, "CVE-2002-0710": {"epss_score": 0.04619, "epss_percentile": 0.88928}, "CVE-2002-0711": {"epss_score": 0.01115, "epss_percentile": 0.77711}, "CVE-2002-0712": {"epss_score": 0.00203, "epss_percentile": 0.42531}, "CVE-2002-0713": {"epss_score": 0.01341, "epss_percentile": 0.79591}, "CVE-2002-0714": {"epss_score": 0.00172, "epss_percentile": 0.38962}, "CVE-2002-0715": {"epss_score": 0.00405, "epss_percentile": 0.60455}, "CVE-2002-0716": {"epss_score": 0.00196, "epss_percentile": 0.41768}, "CVE-2002-0717": {"epss_score": 0.05678, "epss_percentile": 0.90113}, "CVE-2002-0718": {"epss_score": 0.08836, "epss_percentile": 0.92276}, "CVE-2002-0719": {"epss_score": 0.06091, "epss_percentile": 0.90473}, "CVE-2002-0720": {"epss_score": 0.01903, "epss_percentile": 0.82787}, "CVE-2002-0721": {"epss_score": 0.54349, "epss_percentile": 0.97922}, "CVE-2002-0722": {"epss_score": 0.05731, "epss_percentile": 0.90162}, "CVE-2002-0723": {"epss_score": 0.21929, "epss_percentile": 0.95573}, "CVE-2002-0724": {"epss_score": 0.61536, "epss_percentile": 0.98252}, "CVE-2002-0725": {"epss_score": 0.00655, "epss_percentile": 0.70371}, "CVE-2002-0726": {"epss_score": 0.18749, "epss_percentile": 0.95063}, "CVE-2002-0727": {"epss_score": 0.09515, "epss_percentile": 0.92581}, "CVE-2002-0728": {"epss_score": 0.00542, "epss_percentile": 0.67083}, "CVE-2002-0729": {"epss_score": 0.15629, "epss_percentile": 0.94472}, "CVE-2002-0730": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-0731": {"epss_score": 0.05444, "epss_percentile": 0.89886}, "CVE-2002-0732": {"epss_score": 0.05444, "epss_percentile": 0.89886}, "CVE-2002-0733": {"epss_score": 0.09589, "epss_percentile": 0.92612}, "CVE-2002-0734": {"epss_score": 0.04826, "epss_percentile": 0.89185}, "CVE-2002-0735": {"epss_score": 0.02345, "epss_percentile": 0.84447}, "CVE-2002-0736": {"epss_score": 0.12377, "epss_percentile": 0.93654}, "CVE-2002-0737": {"epss_score": 0.10635, "epss_percentile": 0.93055}, "CVE-2002-0738": {"epss_score": 0.01141, "epss_percentile": 0.77961}, "CVE-2002-0739": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2002-0740": {"epss_score": 0.00189, "epss_percentile": 0.40966}, "CVE-2002-0741": {"epss_score": 0.12827, "epss_percentile": 0.93795}, "CVE-2002-0742": {"epss_score": 0.01322, "epss_percentile": 0.7945}, "CVE-2002-0743": {"epss_score": 0.00609, "epss_percentile": 0.69092}, "CVE-2002-0744": {"epss_score": 0.00609, "epss_percentile": 0.69092}, "CVE-2002-0745": {"epss_score": 0.01322, "epss_percentile": 0.7945}, "CVE-2002-0746": {"epss_score": 0.00866, "epss_percentile": 0.74635}, "CVE-2002-0747": {"epss_score": 0.10937, "epss_percentile": 0.93165}, "CVE-2002-0748": {"epss_score": 0.10519, "epss_percentile": 0.93017}, "CVE-2002-0749": {"epss_score": 0.0531, "epss_percentile": 0.89717}, "CVE-2002-0750": {"epss_score": 0.00908, "epss_percentile": 0.75276}, "CVE-2002-0751": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2002-0752": {"epss_score": 0.0066, "epss_percentile": 0.70527}, "CVE-2002-0753": {"epss_score": 0.07824, "epss_percentile": 0.917}, "CVE-2002-0754": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2002-0755": {"epss_score": 0.00067, "epss_percentile": 0.21121}, "CVE-2002-0756": {"epss_score": 0.01027, "epss_percentile": 0.76809}, "CVE-2002-0757": {"epss_score": 0.00612, "epss_percentile": 0.69227}, "CVE-2002-0758": {"epss_score": 0.01091, "epss_percentile": 0.7746}, "CVE-2002-0759": {"epss_score": 0.00832, "epss_percentile": 0.74072}, "CVE-2002-0760": {"epss_score": 0.00115, "epss_percentile": 0.31013}, "CVE-2002-0761": {"epss_score": 0.00157, "epss_percentile": 0.3705}, "CVE-2002-0762": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2002-0763": {"epss_score": 0.00646, "epss_percentile": 0.7015}, "CVE-2002-0764": {"epss_score": 0.20915, "epss_percentile": 0.95442}, "CVE-2002-0765": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2002-0766": {"epss_score": 0.00175, "epss_percentile": 0.39352}, "CVE-2002-0767": {"epss_score": 0.0167, "epss_percentile": 0.81669}, "CVE-2002-0768": {"epss_score": 0.01523, "epss_percentile": 0.80845}, "CVE-2002-0769": {"epss_score": 0.05453, "epss_percentile": 0.89894}, "CVE-2002-0770": {"epss_score": 0.05177, "epss_percentile": 0.89576}, "CVE-2002-0771": {"epss_score": 0.08223, "epss_percentile": 0.91938}, "CVE-2002-0772": {"epss_score": 0.01152, "epss_percentile": 0.78047}, "CVE-2002-0773": {"epss_score": 0.00995, "epss_percentile": 0.76433}, "CVE-2002-0774": {"epss_score": 0.01297, "epss_percentile": 0.79265}, "CVE-2002-0775": {"epss_score": 0.00625, "epss_percentile": 0.69593}, "CVE-2002-0776": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2002-0777": {"epss_score": 0.42289, "epss_percentile": 0.97323}, "CVE-2002-0778": {"epss_score": 0.00847, "epss_percentile": 0.74344}, "CVE-2002-0779": {"epss_score": 0.04788, "epss_percentile": 0.89146}, "CVE-2002-0780": {"epss_score": 0.00916, "epss_percentile": 0.75415}, "CVE-2002-0781": {"epss_score": 0.00676, "epss_percentile": 0.70924}, "CVE-2002-0782": {"epss_score": 0.04788, "epss_percentile": 0.89146}, "CVE-2002-0783": {"epss_score": 0.1151, "epss_percentile": 0.93388}, "CVE-2002-0784": {"epss_score": 0.02631, "epss_percentile": 0.85282}, "CVE-2002-0785": {"epss_score": 0.02238, "epss_percentile": 0.84104}, "CVE-2002-0786": {"epss_score": 0.11059, "epss_percentile": 0.93205}, "CVE-2002-0787": {"epss_score": 0.164, "epss_percentile": 0.94645}, "CVE-2002-0788": {"epss_score": 0.00154, "epss_percentile": 0.36693}, "CVE-2002-0789": {"epss_score": 0.04102, "epss_percentile": 0.88261}, "CVE-2002-0790": {"epss_score": 0.00125, "epss_percentile": 0.32551}, "CVE-2002-0791": {"epss_score": 0.01075, "epss_percentile": 0.77313}, "CVE-2002-0792": {"epss_score": 0.00997, "epss_percentile": 0.76462}, "CVE-2002-0793": {"epss_score": 0.00207, "epss_percentile": 0.43081}, "CVE-2002-0794": {"epss_score": 0.009, "epss_percentile": 0.75165}, "CVE-2002-0795": {"epss_score": 0.00101, "epss_percentile": 0.2857}, "CVE-2002-0796": {"epss_score": 0.03451, "epss_percentile": 0.87165}, "CVE-2002-0797": {"epss_score": 0.05285, "epss_percentile": 0.89692}, "CVE-2002-0798": {"epss_score": 0.00248, "epss_percentile": 0.47966}, "CVE-2002-0799": {"epss_score": 0.06007, "epss_percentile": 0.90399}, "CVE-2002-0800": {"epss_score": 0.01174, "epss_percentile": 0.78254}, "CVE-2002-0801": {"epss_score": 0.39605, "epss_percentile": 0.9717}, "CVE-2002-0802": {"epss_score": 0.00374, "epss_percentile": 0.58559}, "CVE-2002-0803": {"epss_score": 0.01395, "epss_percentile": 0.79973}, "CVE-2002-0804": {"epss_score": 0.00552, "epss_percentile": 0.67386}, "CVE-2002-0805": {"epss_score": 0.00075, "epss_percentile": 0.22884}, "CVE-2002-0806": {"epss_score": 0.00131, "epss_percentile": 0.33493}, "CVE-2002-0807": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2002-0808": {"epss_score": 0.00455, "epss_percentile": 0.63309}, "CVE-2002-0809": {"epss_score": 0.00409, "epss_percentile": 0.60719}, "CVE-2002-0810": {"epss_score": 0.00862, "epss_percentile": 0.74583}, "CVE-2002-0811": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2002-0812": {"epss_score": 0.08338, "epss_percentile": 0.91996}, "CVE-2002-0813": {"epss_score": 0.10052, "epss_percentile": 0.9283}, "CVE-2002-0814": {"epss_score": 0.14018, "epss_percentile": 0.94115}, "CVE-2002-0815": {"epss_score": 0.01433, "epss_percentile": 0.80256}, "CVE-2002-0816": {"epss_score": 0.00831, "epss_percentile": 0.74055}, "CVE-2002-0817": {"epss_score": 0.00153, "epss_percentile": 0.36581}, "CVE-2002-0818": {"epss_score": 0.03238, "epss_percentile": 0.86726}, "CVE-2002-0819": {"epss_score": 0.00064, "epss_percentile": 0.20431}, "CVE-2002-0820": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2002-0821": {"epss_score": 0.01938, "epss_percentile": 0.8297}, "CVE-2002-0822": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2002-0823": {"epss_score": 0.64565, "epss_percentile": 0.98383}, "CVE-2002-0824": {"epss_score": 0.00085, "epss_percentile": 0.25238}, "CVE-2002-0825": {"epss_score": 0.0158, "epss_percentile": 0.81133}, "CVE-2002-0826": {"epss_score": 0.12853, "epss_percentile": 0.93802}, "CVE-2002-0827": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2002-0829": {"epss_score": 0.00081, "epss_percentile": 0.24351}, "CVE-2002-0830": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2002-0831": {"epss_score": 0.00084, "epss_percentile": 0.24864}, "CVE-2002-0832": {"epss_score": 0.02334, "epss_percentile": 0.84413}, "CVE-2002-0833": {"epss_score": 0.04714, "epss_percentile": 0.8904}, "CVE-2002-0834": {"epss_score": 0.01711, "epss_percentile": 0.81879}, "CVE-2002-0835": {"epss_score": 0.02839, "epss_percentile": 0.85797}, "CVE-2002-0836": {"epss_score": 0.14129, "epss_percentile": 0.94141}, "CVE-2002-0837": {"epss_score": 0.03709, "epss_percentile": 0.87602}, "CVE-2002-0838": {"epss_score": 0.04433, "epss_percentile": 0.88682}, "CVE-2002-0839": {"epss_score": 0.00141, "epss_percentile": 0.34838}, "CVE-2002-0840": {"epss_score": 0.91333, "epss_percentile": 0.99634}, "CVE-2002-0842": {"epss_score": 0.38355, "epss_percentile": 0.97097}, "CVE-2002-0843": {"epss_score": 0.03769, "epss_percentile": 0.87699}, "CVE-2002-0844": {"epss_score": 0.0007, "epss_percentile": 0.21663}, "CVE-2002-0845": {"epss_score": 0.03398, "epss_percentile": 0.87064}, "CVE-2002-0846": {"epss_score": 0.07253, "epss_percentile": 0.91352}, "CVE-2002-0847": {"epss_score": 0.02116, "epss_percentile": 0.83662}, "CVE-2002-0848": {"epss_score": 0.00764, "epss_percentile": 0.72897}, "CVE-2002-0849": {"epss_score": 0.00257, "epss_percentile": 0.48913}, "CVE-2002-0850": {"epss_score": 0.0385, "epss_percentile": 0.87848}, "CVE-2002-0851": {"epss_score": 0.00639, "epss_percentile": 0.69938}, "CVE-2002-0852": {"epss_score": 0.00714, "epss_percentile": 0.71829}, "CVE-2002-0853": {"epss_score": 0.01637, "epss_percentile": 0.81484}, "CVE-2002-0854": {"epss_score": 0.00063, "epss_percentile": 0.20057}, "CVE-2002-0855": {"epss_score": 0.41037, "epss_percentile": 0.9725}, "CVE-2002-0856": {"epss_score": 0.00738, "epss_percentile": 0.7235}, "CVE-2002-0857": {"epss_score": 0.02776, "epss_percentile": 0.85636}, "CVE-2002-0858": {"epss_score": 0.00398, "epss_percentile": 0.60059}, "CVE-2002-0859": {"epss_score": 0.39233, "epss_percentile": 0.97147}, "CVE-2002-0860": {"epss_score": 0.24972, "epss_percentile": 0.95973}, "CVE-2002-0861": {"epss_score": 0.06153, "epss_percentile": 0.90522}, "CVE-2002-0862": {"epss_score": 0.15129, "epss_percentile": 0.94369}, "CVE-2002-0863": {"epss_score": 0.17936, "epss_percentile": 0.9493}, "CVE-2002-0864": {"epss_score": 0.23478, "epss_percentile": 0.95783}, "CVE-2002-0865": {"epss_score": 0.13126, "epss_percentile": 0.9388}, "CVE-2002-0866": {"epss_score": 0.41318, "epss_percentile": 0.97266}, "CVE-2002-0867": {"epss_score": 0.11533, "epss_percentile": 0.93397}, "CVE-2002-0869": {"epss_score": 0.29634, "epss_percentile": 0.96462}, "CVE-2002-0870": {"epss_score": 0.00455, "epss_percentile": 0.63307}, "CVE-2002-0871": {"epss_score": 0.00108, "epss_percentile": 0.29762}, "CVE-2002-0872": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2002-0873": {"epss_score": 0.00511, "epss_percentile": 0.65832}, "CVE-2002-0874": {"epss_score": 0.043, "epss_percentile": 0.88515}, "CVE-2002-0875": {"epss_score": 0.01068, "epss_percentile": 0.7724}, "CVE-2002-0876": {"epss_score": 0.05219, "epss_percentile": 0.89624}, "CVE-2002-0877": {"epss_score": 0.02475, "epss_percentile": 0.8486}, "CVE-2002-0878": {"epss_score": 0.00807, "epss_percentile": 0.73673}, "CVE-2002-0879": {"epss_score": 0.14391, "epss_percentile": 0.94201}, "CVE-2002-0880": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2002-0881": {"epss_score": 0.00127, "epss_percentile": 0.32878}, "CVE-2002-0882": {"epss_score": 0.01302, "epss_percentile": 0.79305}, "CVE-2002-0883": {"epss_score": 0.00155, "epss_percentile": 0.36803}, "CVE-2002-0884": {"epss_score": 0.02313, "epss_percentile": 0.84348}, "CVE-2002-0885": {"epss_score": 0.0385, "epss_percentile": 0.87848}, "CVE-2002-0886": {"epss_score": 0.22613, "epss_percentile": 0.95658}, "CVE-2002-0887": {"epss_score": 0.00445, "epss_percentile": 0.62862}, "CVE-2002-0888": {"epss_score": 0.0026, "epss_percentile": 0.49164}, "CVE-2002-0889": {"epss_score": 0.0008, "epss_percentile": 0.24058}, "CVE-2002-0891": {"epss_score": 0.00672, "epss_percentile": 0.70828}, "CVE-2002-0892": {"epss_score": 0.05767, "epss_percentile": 0.90189}, "CVE-2002-0893": {"epss_score": 0.07062, "epss_percentile": 0.91221}, "CVE-2002-0894": {"epss_score": 0.06495, "epss_percentile": 0.908}, "CVE-2002-0895": {"epss_score": 0.07307, "epss_percentile": 0.91397}, "CVE-2002-0896": {"epss_score": 0.00852, "epss_percentile": 0.74416}, "CVE-2002-0897": {"epss_score": 0.03174, "epss_percentile": 0.8656}, "CVE-2002-0898": {"epss_score": 0.04709, "epss_percentile": 0.89037}, "CVE-2002-0899": {"epss_score": 0.00428, "epss_percentile": 0.61953}, "CVE-2002-0900": {"epss_score": 0.15513, "epss_percentile": 0.94442}, "CVE-2002-0901": {"epss_score": 0.08257, "epss_percentile": 0.91955}, "CVE-2002-0902": {"epss_score": 0.08223, "epss_percentile": 0.91938}, "CVE-2002-0903": {"epss_score": 0.01679, "epss_percentile": 0.81721}, "CVE-2002-0904": {"epss_score": 0.0111, "epss_percentile": 0.77662}, "CVE-2002-0905": {"epss_score": 0.0059, "epss_percentile": 0.68538}, "CVE-2002-0906": {"epss_score": 0.02974, "epss_percentile": 0.86102}, "CVE-2002-0907": {"epss_score": 0.10942, "epss_percentile": 0.93167}, "CVE-2002-0908": {"epss_score": 0.16601, "epss_percentile": 0.94701}, "CVE-2002-0909": {"epss_score": 0.01094, "epss_percentile": 0.77498}, "CVE-2002-0910": {"epss_score": 0.01968, "epss_percentile": 0.83088}, "CVE-2002-0911": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2002-0912": {"epss_score": 0.00951, "epss_percentile": 0.75867}, "CVE-2002-0913": {"epss_score": 0.03938, "epss_percentile": 0.87987}, "CVE-2002-0914": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2002-0915": {"epss_score": 0.00187, "epss_percentile": 0.40736}, "CVE-2002-0916": {"epss_score": 0.02682, "epss_percentile": 0.85418}, "CVE-2002-0917": {"epss_score": 0.00626, "epss_percentile": 0.69613}, "CVE-2002-0918": {"epss_score": 0.14391, "epss_percentile": 0.94201}, "CVE-2002-0919": {"epss_score": 0.12443, "epss_percentile": 0.93673}, "CVE-2002-0920": {"epss_score": 0.00638, "epss_percentile": 0.6992}, "CVE-2002-0921": {"epss_score": 0.00814, "epss_percentile": 0.73777}, "CVE-2002-0922": {"epss_score": 0.0707, "epss_percentile": 0.91227}, "CVE-2002-0923": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-0924": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2002-0925": {"epss_score": 0.03829, "epss_percentile": 0.87801}, "CVE-2002-0926": {"epss_score": 0.18074, "epss_percentile": 0.94953}, "CVE-2002-0928": {"epss_score": 0.07307, "epss_percentile": 0.91397}, "CVE-2002-0929": {"epss_score": 0.0357, "epss_percentile": 0.8737}, "CVE-2002-0930": {"epss_score": 0.01052, "epss_percentile": 0.77087}, "CVE-2002-0931": {"epss_score": 0.04327, "epss_percentile": 0.88554}, "CVE-2002-0932": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2002-0933": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2002-0934": {"epss_score": 0.01109, "epss_percentile": 0.77643}, "CVE-2002-0935": {"epss_score": 0.02834, "epss_percentile": 0.85782}, "CVE-2002-0936": {"epss_score": 0.08273, "epss_percentile": 0.91962}, "CVE-2002-0937": {"epss_score": 0.01371, "epss_percentile": 0.79807}, "CVE-2002-0938": {"epss_score": 0.03109, "epss_percentile": 0.86423}, "CVE-2002-0939": {"epss_score": 0.00074, "epss_percentile": 0.2281}, "CVE-2002-0940": {"epss_score": 0.00088, "epss_percentile": 0.25793}, "CVE-2002-0941": {"epss_score": 0.00156, "epss_percentile": 0.36998}, "CVE-2002-0942": {"epss_score": 0.10183, "epss_percentile": 0.92882}, "CVE-2002-0943": {"epss_score": 0.00428, "epss_percentile": 0.61956}, "CVE-2002-0944": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2002-0945": {"epss_score": 0.02946, "epss_percentile": 0.86041}, "CVE-2002-0946": {"epss_score": 0.08184, "epss_percentile": 0.91918}, "CVE-2002-0947": {"epss_score": 0.08591, "epss_percentile": 0.9214}, "CVE-2002-0948": {"epss_score": 0.07497, "epss_percentile": 0.91503}, "CVE-2002-0949": {"epss_score": 0.14717, "epss_percentile": 0.94269}, "CVE-2002-0950": {"epss_score": 0.03413, "epss_percentile": 0.8709}, "CVE-2002-0951": {"epss_score": 0.01803, "epss_percentile": 0.82334}, "CVE-2002-0952": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-0953": {"epss_score": 0.05444, "epss_percentile": 0.89886}, "CVE-2002-0954": {"epss_score": 0.00263, "epss_percentile": 0.49522}, "CVE-2002-0955": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-0956": {"epss_score": 0.00322, "epss_percentile": 0.54829}, "CVE-2002-0957": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2002-0958": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2002-0959": {"epss_score": 0.03832, "epss_percentile": 0.87811}, "CVE-2002-0960": {"epss_score": 0.01679, "epss_percentile": 0.81721}, "CVE-2002-0961": {"epss_score": 0.00808, "epss_percentile": 0.73695}, "CVE-2002-0962": {"epss_score": 0.1127, "epss_percentile": 0.93287}, "CVE-2002-0963": {"epss_score": 0.00856, "epss_percentile": 0.74473}, "CVE-2002-0964": {"epss_score": 0.06281, "epss_percentile": 0.90638}, "CVE-2002-0965": {"epss_score": 0.77669, "epss_percentile": 0.98947}, "CVE-2002-0966": {"epss_score": 0.0161, "epss_percentile": 0.81323}, "CVE-2002-0967": {"epss_score": 0.03402, "epss_percentile": 0.8707}, "CVE-2002-0968": {"epss_score": 0.20641, "epss_percentile": 0.95393}, "CVE-2002-0969": {"epss_score": 0.00103, "epss_percentile": 0.29047}, "CVE-2002-0970": {"epss_score": 0.02398, "epss_percentile": 0.84623}, "CVE-2002-0971": {"epss_score": 0.00097, "epss_percentile": 0.27578}, "CVE-2002-0972": {"epss_score": 0.00099, "epss_percentile": 0.28406}, "CVE-2002-0973": {"epss_score": 0.00088, "epss_percentile": 0.25793}, "CVE-2002-0974": {"epss_score": 0.5712, "epss_percentile": 0.98049}, "CVE-2002-0975": {"epss_score": 0.09983, "epss_percentile": 0.92803}, "CVE-2002-0976": {"epss_score": 0.54997, "epss_percentile": 0.97956}, "CVE-2002-0977": {"epss_score": 0.05376, "epss_percentile": 0.89799}, "CVE-2002-0978": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2002-0979": {"epss_score": 0.02993, "epss_percentile": 0.86148}, "CVE-2002-0980": {"epss_score": 0.40449, "epss_percentile": 0.97218}, "CVE-2002-0981": {"epss_score": 0.00343, "epss_percentile": 0.56405}, "CVE-2002-0982": {"epss_score": 0.08644, "epss_percentile": 0.9217}, "CVE-2002-0983": {"epss_score": 0.00998, "epss_percentile": 0.76468}, "CVE-2002-0984": {"epss_score": 0.02562, "epss_percentile": 0.85107}, "CVE-2002-0985": {"epss_score": 0.01228, "epss_percentile": 0.7871}, "CVE-2002-0986": {"epss_score": 0.08697, "epss_percentile": 0.92207}, "CVE-2002-0987": {"epss_score": 0.00146, "epss_percentile": 0.35591}, "CVE-2002-0988": {"epss_score": 0.01, "epss_percentile": 0.76492}, "CVE-2002-0989": {"epss_score": 0.0495, "epss_percentile": 0.89323}, "CVE-2002-0990": {"epss_score": 0.01072, "epss_percentile": 0.77282}, "CVE-2002-0991": {"epss_score": 0.00856, "epss_percentile": 0.74486}, "CVE-2002-0992": {"epss_score": 0.00073, "epss_percentile": 0.2258}, "CVE-2002-0993": {"epss_score": 0.00259, "epss_percentile": 0.49049}, "CVE-2002-0994": {"epss_score": 0.0884, "epss_percentile": 0.92279}, "CVE-2002-0995": {"epss_score": 0.07134, "epss_percentile": 0.91273}, "CVE-2002-0996": {"epss_score": 0.05186, "epss_percentile": 0.89588}, "CVE-2002-0997": {"epss_score": 0.02673, "epss_percentile": 0.85395}, "CVE-2002-0998": {"epss_score": 0.02169, "epss_percentile": 0.83863}, "CVE-2002-0999": {"epss_score": 0.0124, "epss_percentile": 0.78801}, "CVE-2002-1000": {"epss_score": 0.02283, "epss_percentile": 0.84258}, "CVE-2002-1001": {"epss_score": 0.26091, "epss_percentile": 0.9611}, "CVE-2002-1002": {"epss_score": 0.0341, "epss_percentile": 0.87082}, "CVE-2002-1003": {"epss_score": 0.03624, "epss_percentile": 0.87448}, "CVE-2002-1004": {"epss_score": 0.06466, "epss_percentile": 0.90774}, "CVE-2002-1005": {"epss_score": 0.00543, "epss_percentile": 0.67099}, "CVE-2002-1006": {"epss_score": 0.00746, "epss_percentile": 0.72538}, "CVE-2002-1007": {"epss_score": 0.05383, "epss_percentile": 0.89814}, "CVE-2002-1008": {"epss_score": 0.03832, "epss_percentile": 0.87811}, "CVE-2002-1009": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-1010": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-2002-1011": {"epss_score": 0.02487, "epss_percentile": 0.84891}, "CVE-2002-1012": {"epss_score": 0.02487, "epss_percentile": 0.84891}, "CVE-2002-1013": {"epss_score": 0.00354, "epss_percentile": 0.57217}, "CVE-2002-1014": {"epss_score": 0.17024, "epss_percentile": 0.94762}, "CVE-2002-1015": {"epss_score": 0.01411, "epss_percentile": 0.80108}, "CVE-2002-1016": {"epss_score": 0.00946, "epss_percentile": 0.75804}, "CVE-2002-1017": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2002-1018": {"epss_score": 0.01387, "epss_percentile": 0.79915}, "CVE-2002-1019": {"epss_score": 0.01427, "epss_percentile": 0.80212}, "CVE-2002-1020": {"epss_score": 0.01427, "epss_percentile": 0.80212}, "CVE-2002-1021": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2002-1022": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2002-1023": {"epss_score": 0.04891, "epss_percentile": 0.89263}, "CVE-2002-1024": {"epss_score": 0.04874, "epss_percentile": 0.89235}, "CVE-2002-1025": {"epss_score": 0.00773, "epss_percentile": 0.73049}, "CVE-2002-1026": {"epss_score": 0.01742, "epss_percentile": 0.82054}, "CVE-2002-1027": {"epss_score": 0.0951, "epss_percentile": 0.92577}, "CVE-2002-1028": {"epss_score": 0.07619, "epss_percentile": 0.91573}, "CVE-2002-1029": {"epss_score": 0.04891, "epss_percentile": 0.89263}, "CVE-2002-1030": {"epss_score": 0.00682, "epss_percentile": 0.71064}, "CVE-2002-1031": {"epss_score": 0.0699, "epss_percentile": 0.91166}, "CVE-2002-1032": {"epss_score": 0.0136, "epss_percentile": 0.79747}, "CVE-2002-1033": {"epss_score": 0.08674, "epss_percentile": 0.92184}, "CVE-2002-1034": {"epss_score": 0.0871, "epss_percentile": 0.92222}, "CVE-2002-1035": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2002-1036": {"epss_score": 0.0699, "epss_percentile": 0.91166}, "CVE-2002-1037": {"epss_score": 0.00579, "epss_percentile": 0.68233}, "CVE-2002-1038": {"epss_score": 0.008, "epss_percentile": 0.73558}, "CVE-2002-1039": {"epss_score": 0.0443, "epss_percentile": 0.88678}, "CVE-2002-1040": {"epss_score": 0.00502, "epss_percentile": 0.65392}, "CVE-2002-1041": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-2002-1042": {"epss_score": 0.08581, "epss_percentile": 0.92133}, "CVE-2002-1043": {"epss_score": 0.10348, "epss_percentile": 0.92953}, "CVE-2002-1044": {"epss_score": 0.05517, "epss_percentile": 0.89952}, "CVE-2002-1045": {"epss_score": 0.01317, "epss_percentile": 0.79416}, "CVE-2002-1046": {"epss_score": 0.01317, "epss_percentile": 0.79416}, "CVE-2002-1047": {"epss_score": 0.00554, "epss_percentile": 0.67437}, "CVE-2002-1048": {"epss_score": 0.10282, "epss_percentile": 0.92925}, "CVE-2002-1049": {"epss_score": 0.01583, "epss_percentile": 0.81153}, "CVE-2002-1050": {"epss_score": 0.03748, "epss_percentile": 0.87667}, "CVE-2002-1051": {"epss_score": 0.00087, "epss_percentile": 0.25604}, "CVE-2002-1052": {"epss_score": 0.02069, "epss_percentile": 0.83469}, "CVE-2002-1053": {"epss_score": 0.01645, "epss_percentile": 0.81529}, "CVE-2002-1054": {"epss_score": 0.0377, "epss_percentile": 0.87702}, "CVE-2002-1055": {"epss_score": 0.00962, "epss_percentile": 0.75991}, "CVE-2002-1056": {"epss_score": 0.16381, "epss_percentile": 0.94641}, "CVE-2002-1057": {"epss_score": 0.05161, "epss_percentile": 0.89559}, "CVE-2002-1058": {"epss_score": 0.0648, "epss_percentile": 0.90785}, "CVE-2002-1059": {"epss_score": 0.73111, "epss_percentile": 0.98737}, "CVE-2002-1060": {"epss_score": 0.00797, "epss_percentile": 0.73493}, "CVE-2002-1061": {"epss_score": 0.0588, "epss_percentile": 0.9029}, "CVE-2002-1062": {"epss_score": 0.03413, "epss_percentile": 0.8709}, "CVE-2002-1063": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1064": {"epss_score": 0.00996, "epss_percentile": 0.76446}, "CVE-2002-1065": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2002-1066": {"epss_score": 0.01896, "epss_percentile": 0.82752}, "CVE-2002-1067": {"epss_score": 0.00962, "epss_percentile": 0.75991}, "CVE-2002-1068": {"epss_score": 0.00524, "epss_percentile": 0.66316}, "CVE-2002-1069": {"epss_score": 0.00622, "epss_percentile": 0.69516}, "CVE-2002-1070": {"epss_score": 0.03989, "epss_percentile": 0.88068}, "CVE-2002-1071": {"epss_score": 0.06377, "epss_percentile": 0.90709}, "CVE-2002-1072": {"epss_score": 0.05422, "epss_percentile": 0.89863}, "CVE-2002-1073": {"epss_score": 0.05386, "epss_percentile": 0.89821}, "CVE-2002-1075": {"epss_score": 0.11415, "epss_percentile": 0.93342}, "CVE-2002-1076": {"epss_score": 0.28492, "epss_percentile": 0.96363}, "CVE-2002-1077": {"epss_score": 0.11688, "epss_percentile": 0.9345}, "CVE-2002-1078": {"epss_score": 0.01014, "epss_percentile": 0.76639}, "CVE-2002-1079": {"epss_score": 0.1344, "epss_percentile": 0.93964}, "CVE-2002-1080": {"epss_score": 0.01048, "epss_percentile": 0.77048}, "CVE-2002-1081": {"epss_score": 0.00612, "epss_percentile": 0.69219}, "CVE-2002-1082": {"epss_score": 0.00485, "epss_percentile": 0.64714}, "CVE-2002-1083": {"epss_score": 0.00866, "epss_percentile": 0.74633}, "CVE-2002-1084": {"epss_score": 0.01306, "epss_percentile": 0.79336}, "CVE-2002-1085": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2002-1086": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2002-1087": {"epss_score": 0.00515, "epss_percentile": 0.66}, "CVE-2002-1088": {"epss_score": 0.09228, "epss_percentile": 0.92458}, "CVE-2002-1089": {"epss_score": 0.10405, "epss_percentile": 0.92976}, "CVE-2002-1090": {"epss_score": 0.00929, "epss_percentile": 0.75592}, "CVE-2002-1091": {"epss_score": 0.06469, "epss_percentile": 0.90777}, "CVE-2002-1092": {"epss_score": 0.00533, "epss_percentile": 0.66714}, "CVE-2002-1093": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1094": {"epss_score": 0.01227, "epss_percentile": 0.78703}, "CVE-2002-1095": {"epss_score": 0.00398, "epss_percentile": 0.6009}, "CVE-2002-1096": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2002-1097": {"epss_score": 0.00284, "epss_percentile": 0.51422}, "CVE-2002-1098": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2002-1099": {"epss_score": 0.00507, "epss_percentile": 0.65648}, "CVE-2002-1100": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1101": {"epss_score": 0.18274, "epss_percentile": 0.94987}, "CVE-2002-1102": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1103": {"epss_score": 0.00419, "epss_percentile": 0.6139}, "CVE-2002-1104": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1105": {"epss_score": 0.00095, "epss_percentile": 0.27142}, "CVE-2002-1106": {"epss_score": 0.00387, "epss_percentile": 0.59297}, "CVE-2002-1107": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2002-1108": {"epss_score": 0.00395, "epss_percentile": 0.59842}, "CVE-2002-1109": {"epss_score": 0.0007, "epss_percentile": 0.21978}, "CVE-2002-1110": {"epss_score": 0.00528, "epss_percentile": 0.66537}, "CVE-2002-1111": {"epss_score": 0.00524, "epss_percentile": 0.66329}, "CVE-2002-1112": {"epss_score": 0.00625, "epss_percentile": 0.69594}, "CVE-2002-1113": {"epss_score": 0.13869, "epss_percentile": 0.9408}, "CVE-2002-1114": {"epss_score": 0.02116, "epss_percentile": 0.83662}, "CVE-2002-1115": {"epss_score": 0.01132, "epss_percentile": 0.77871}, "CVE-2002-1116": {"epss_score": 0.00489, "epss_percentile": 0.64872}, "CVE-2002-1117": {"epss_score": 0.0082, "epss_percentile": 0.7388}, "CVE-2002-1118": {"epss_score": 0.01594, "epss_percentile": 0.81232}, "CVE-2002-1119": {"epss_score": 0.00144, "epss_percentile": 0.3525}, "CVE-2002-1120": {"epss_score": 0.73039, "epss_percentile": 0.98734}, "CVE-2002-1121": {"epss_score": 0.00938, "epss_percentile": 0.75704}, "CVE-2002-1122": {"epss_score": 0.06843, "epss_percentile": 0.91063}, "CVE-2002-1123": {"epss_score": 0.89144, "epss_percentile": 0.99511}, "CVE-2002-1124": {"epss_score": 0.00145, "epss_percentile": 0.35449}, "CVE-2002-1125": {"epss_score": 0.00331, "epss_percentile": 0.55512}, "CVE-2002-1126": {"epss_score": 0.00549, "epss_percentile": 0.67304}, "CVE-2002-1127": {"epss_score": 0.00154, "epss_percentile": 0.36742}, "CVE-2002-1128": {"epss_score": 0.00154, "epss_percentile": 0.36742}, "CVE-2002-1129": {"epss_score": 0.00348, "epss_percentile": 0.56815}, "CVE-2002-1131": {"epss_score": 0.03877, "epss_percentile": 0.87891}, "CVE-2002-1132": {"epss_score": 0.00619, "epss_percentile": 0.69393}, "CVE-2002-1133": {"epss_score": 0.03265, "epss_percentile": 0.86782}, "CVE-2002-1134": {"epss_score": 0.0173, "epss_percentile": 0.81989}, "CVE-2002-1135": {"epss_score": 0.05112, "epss_percentile": 0.8951}, "CVE-2002-1137": {"epss_score": 0.18742, "epss_percentile": 0.95062}, "CVE-2002-1138": {"epss_score": 0.11402, "epss_percentile": 0.93335}, "CVE-2002-1139": {"epss_score": 0.20171, "epss_percentile": 0.95297}, "CVE-2002-1140": {"epss_score": 0.18087, "epss_percentile": 0.94955}, "CVE-2002-1141": {"epss_score": 0.18087, "epss_percentile": 0.94955}, "CVE-2002-1142": {"epss_score": 0.83043, "epss_percentile": 0.99228}, "CVE-2002-1143": {"epss_score": 0.32477, "epss_percentile": 0.96703}, "CVE-2002-1145": {"epss_score": 0.02444, "epss_percentile": 0.84763}, "CVE-2002-1146": {"epss_score": 0.09717, "epss_percentile": 0.92676}, "CVE-2002-1147": {"epss_score": 0.05933, "epss_percentile": 0.90338}, "CVE-2002-1148": {"epss_score": 0.36686, "epss_percentile": 0.96995}, "CVE-2002-1149": {"epss_score": 0.00732, "epss_percentile": 0.7219}, "CVE-2002-1150": {"epss_score": 0.00762, "epss_percentile": 0.72832}, "CVE-2002-1151": {"epss_score": 0.03225, "epss_percentile": 0.86685}, "CVE-2002-1152": {"epss_score": 0.01427, "epss_percentile": 0.8021}, "CVE-2002-1153": {"epss_score": 0.0258, "epss_percentile": 0.85151}, "CVE-2002-1154": {"epss_score": 0.00672, "epss_percentile": 0.70828}, "CVE-2002-1155": {"epss_score": 0.00107, "epss_percentile": 0.29692}, "CVE-2002-1156": {"epss_score": 0.32074, "epss_percentile": 0.96671}, "CVE-2002-1157": {"epss_score": 0.03447, "epss_percentile": 0.8716}, "CVE-2002-1158": {"epss_score": 0.00083, "epss_percentile": 0.24762}, "CVE-2002-1159": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2002-1160": {"epss_score": 0.00066, "epss_percentile": 0.20961}, "CVE-2002-1165": {"epss_score": 0.029, "epss_percentile": 0.85951}, "CVE-2002-1166": {"epss_score": 0.04102, "epss_percentile": 0.88261}, "CVE-2002-1167": {"epss_score": 0.04408, "epss_percentile": 0.88653}, "CVE-2002-1168": {"epss_score": 0.01908, "epss_percentile": 0.82815}, "CVE-2002-1169": {"epss_score": 0.04265, "epss_percentile": 0.88469}, "CVE-2002-1170": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2002-1174": {"epss_score": 0.04276, "epss_percentile": 0.88483}, "CVE-2002-1175": {"epss_score": 0.01344, "epss_percentile": 0.79618}, "CVE-2002-1176": {"epss_score": 0.01911, "epss_percentile": 0.82828}, "CVE-2002-1177": {"epss_score": 0.03077, "epss_percentile": 0.86363}, "CVE-2002-1178": {"epss_score": 0.10447, "epss_percentile": 0.92989}, "CVE-2002-1179": {"epss_score": 0.50114, "epss_percentile": 0.9772}, "CVE-2002-1180": {"epss_score": 0.02108, "epss_percentile": 0.83638}, "CVE-2002-1181": {"epss_score": 0.12102, "epss_percentile": 0.93567}, "CVE-2002-1182": {"epss_score": 0.43789, "epss_percentile": 0.97404}, "CVE-2002-1183": {"epss_score": 0.11913, "epss_percentile": 0.93514}, "CVE-2002-1184": {"epss_score": 0.00883, "epss_percentile": 0.74902}, "CVE-2002-1185": {"epss_score": 0.29205, "epss_percentile": 0.96425}, "CVE-2002-1186": {"epss_score": 0.33375, "epss_percentile": 0.96767}, "CVE-2002-1187": {"epss_score": 0.26559, "epss_percentile": 0.96156}, "CVE-2002-1188": {"epss_score": 0.16205, "epss_percentile": 0.94594}, "CVE-2002-1189": {"epss_score": 0.00079, "epss_percentile": 0.23899}, "CVE-2002-1190": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2002-1191": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2002-1192": {"epss_score": 0.00367, "epss_percentile": 0.58138}, "CVE-2002-1193": {"epss_score": 0.00182, "epss_percentile": 0.40233}, "CVE-2002-1194": {"epss_score": 0.12176, "epss_percentile": 0.93593}, "CVE-2002-1195": {"epss_score": 0.00451, "epss_percentile": 0.63112}, "CVE-2002-1196": {"epss_score": 0.00434, "epss_percentile": 0.62305}, "CVE-2002-1197": {"epss_score": 0.02116, "epss_percentile": 0.83662}, "CVE-2002-1198": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2002-1199": {"epss_score": 0.02144, "epss_percentile": 0.83759}, "CVE-2002-1200": {"epss_score": 0.0653, "epss_percentile": 0.90823}, "CVE-2002-1201": {"epss_score": 0.02147, "epss_percentile": 0.83768}, "CVE-2002-1202": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2002-1203": {"epss_score": 0.01324, "epss_percentile": 0.79463}, "CVE-2002-1204": {"epss_score": 0.00852, "epss_percentile": 0.74416}, "CVE-2002-1209": {"epss_score": 0.04518, "epss_percentile": 0.88795}, "CVE-2002-1210": {"epss_score": 0.00489, "epss_percentile": 0.64896}, "CVE-2002-1211": {"epss_score": 0.03876, "epss_percentile": 0.87888}, "CVE-2002-1212": {"epss_score": 0.0071, "epss_percentile": 0.71727}, "CVE-2002-1213": {"epss_score": 0.01425, "epss_percentile": 0.80196}, "CVE-2002-1214": {"epss_score": 0.79041, "epss_percentile": 0.99017}, "CVE-2002-1215": {"epss_score": 0.15353, "epss_percentile": 0.94415}, "CVE-2002-1216": {"epss_score": 0.00669, "epss_percentile": 0.7075}, "CVE-2002-1217": {"epss_score": 0.74501, "epss_percentile": 0.98804}, "CVE-2002-1219": {"epss_score": 0.07085, "epss_percentile": 0.91241}, "CVE-2002-1220": {"epss_score": 0.32686, "epss_percentile": 0.96716}, "CVE-2002-1221": {"epss_score": 0.03661, "epss_percentile": 0.87528}, "CVE-2002-1222": {"epss_score": 0.16163, "epss_percentile": 0.94584}, "CVE-2002-1223": {"epss_score": 0.00804, "epss_percentile": 0.7361}, "CVE-2002-1224": {"epss_score": 0.11842, "epss_percentile": 0.93492}, "CVE-2002-1225": {"epss_score": 0.01481, "epss_percentile": 0.80566}, "CVE-2002-1226": {"epss_score": 0.00419, "epss_percentile": 0.61384}, "CVE-2002-1227": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2002-1228": {"epss_score": 0.00703, "epss_percentile": 0.71534}, "CVE-2002-1229": {"epss_score": 0.01341, "epss_percentile": 0.79592}, "CVE-2002-1230": {"epss_score": 0.00787, "epss_percentile": 0.73322}, "CVE-2002-1231": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2002-1232": {"epss_score": 0.06035, "epss_percentile": 0.90426}, "CVE-2002-1233": {"epss_score": 0.0013, "epss_percentile": 0.33326}, "CVE-2002-1235": {"epss_score": 0.32917, "epss_percentile": 0.96735}, "CVE-2002-1236": {"epss_score": 0.05187, "epss_percentile": 0.89591}, "CVE-2002-1238": {"epss_score": 0.04669, "epss_percentile": 0.88985}, "CVE-2002-1239": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-2002-1242": {"epss_score": 0.00088, "epss_percentile": 0.2574}, "CVE-2002-1244": {"epss_score": 0.03286, "epss_percentile": 0.86828}, "CVE-2002-1245": {"epss_score": 0.00124, "epss_percentile": 0.32444}, "CVE-2002-1247": {"epss_score": 0.00075, "epss_percentile": 0.22942}, "CVE-2002-1248": {"epss_score": 0.04891, "epss_percentile": 0.89263}, "CVE-2002-1250": {"epss_score": 0.00335, "epss_percentile": 0.55855}, "CVE-2002-1251": {"epss_score": 0.0517, "epss_percentile": 0.89568}, "CVE-2002-1252": {"epss_score": 0.00424, "epss_percentile": 0.61683}, "CVE-2002-1253": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2002-1254": {"epss_score": 0.74427, "epss_percentile": 0.98799}, "CVE-2002-1255": {"epss_score": 0.14022, "epss_percentile": 0.94116}, "CVE-2002-1256": {"epss_score": 0.31587, "epss_percentile": 0.96629}, "CVE-2002-1257": {"epss_score": 0.07143, "epss_percentile": 0.91281}, "CVE-2002-1258": {"epss_score": 0.06121, "epss_percentile": 0.90494}, "CVE-2002-1260": {"epss_score": 0.08772, "epss_percentile": 0.92247}, "CVE-2002-1262": {"epss_score": 0.1153, "epss_percentile": 0.93394}, "CVE-2002-1264": {"epss_score": 0.07387, "epss_percentile": 0.91447}, "CVE-2002-1265": {"epss_score": 0.02369, "epss_percentile": 0.84523}, "CVE-2002-1266": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2002-1267": {"epss_score": 0.00651, "epss_percentile": 0.70301}, "CVE-2002-1268": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2002-1269": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2002-1270": {"epss_score": 0.00069, "epss_percentile": 0.21537}, "CVE-2002-1271": {"epss_score": 0.01253, "epss_percentile": 0.78914}, "CVE-2002-1272": {"epss_score": 0.02674, "epss_percentile": 0.85397}, "CVE-2002-1275": {"epss_score": 0.08455, "epss_percentile": 0.9206}, "CVE-2002-1276": {"epss_score": 0.00636, "epss_percentile": 0.69869}, "CVE-2002-1277": {"epss_score": 0.05787, "epss_percentile": 0.90208}, "CVE-2002-1278": {"epss_score": 0.00664, "epss_percentile": 0.70647}, "CVE-2002-1279": {"epss_score": 0.00145, "epss_percentile": 0.35449}, "CVE-2002-1280": {"epss_score": 0.00406, "epss_percentile": 0.60529}, "CVE-2002-1281": {"epss_score": 0.0633, "epss_percentile": 0.90674}, "CVE-2002-1282": {"epss_score": 0.08119, "epss_percentile": 0.91889}, "CVE-2002-1283": {"epss_score": 0.00371, "epss_percentile": 0.58381}, "CVE-2002-1284": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2002-1285": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2002-1286": {"epss_score": 0.06953, "epss_percentile": 0.91143}, "CVE-2002-1287": {"epss_score": 0.06096, "epss_percentile": 0.90477}, "CVE-2002-1288": {"epss_score": 0.08794, "epss_percentile": 0.92257}, "CVE-2002-1289": {"epss_score": 0.06456, "epss_percentile": 0.90768}, "CVE-2002-1290": {"epss_score": 0.04833, "epss_percentile": 0.89191}, "CVE-2002-1291": {"epss_score": 0.10288, "epss_percentile": 0.92928}, "CVE-2002-1292": {"epss_score": 0.07677, "epss_percentile": 0.91621}, "CVE-2002-1293": {"epss_score": 0.02518, "epss_percentile": 0.84991}, "CVE-2002-1294": {"epss_score": 0.05586, "epss_percentile": 0.90026}, "CVE-2002-1295": {"epss_score": 0.03068, "epss_percentile": 0.8634}, "CVE-2002-1296": {"epss_score": 0.00027, "epss_percentile": 0.06824}, "CVE-2002-1306": {"epss_score": 0.05536, "epss_percentile": 0.89972}, "CVE-2002-1307": {"epss_score": 0.0629, "epss_percentile": 0.90648}, "CVE-2002-1308": {"epss_score": 0.06236, "epss_percentile": 0.90589}, "CVE-2002-1309": {"epss_score": 0.01693, "epss_percentile": 0.81799}, "CVE-2002-1310": {"epss_score": 0.03293, "epss_percentile": 0.8684}, "CVE-2002-1311": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2002-1312": {"epss_score": 0.01223, "epss_percentile": 0.78665}, "CVE-2002-1313": {"epss_score": 0.00081, "epss_percentile": 0.24318}, "CVE-2002-1315": {"epss_score": 0.01852, "epss_percentile": 0.82544}, "CVE-2002-1316": {"epss_score": 0.02002, "epss_percentile": 0.83224}, "CVE-2002-1317": {"epss_score": 0.42484, "epss_percentile": 0.97334}, "CVE-2002-1318": {"epss_score": 0.73412, "epss_percentile": 0.98752}, "CVE-2002-1319": {"epss_score": 0.00063, "epss_percentile": 0.20082}, "CVE-2002-1320": {"epss_score": 0.16373, "epss_percentile": 0.94638}, "CVE-2002-1321": {"epss_score": 0.0385, "epss_percentile": 0.87848}, "CVE-2002-1322": {"epss_score": 0.05219, "epss_percentile": 0.89624}, "CVE-2002-1323": {"epss_score": 0.00082, "epss_percentile": 0.24505}, "CVE-2002-1325": {"epss_score": 0.0852, "epss_percentile": 0.92099}, "CVE-2002-1327": {"epss_score": 0.36906, "epss_percentile": 0.97009}, "CVE-2002-1334": {"epss_score": 0.00671, "epss_percentile": 0.70791}, "CVE-2002-1335": {"epss_score": 0.01014, "epss_percentile": 0.76647}, "CVE-2002-1336": {"epss_score": 0.01074, "epss_percentile": 0.77299}, "CVE-2002-1337": {"epss_score": 0.51421, "epss_percentile": 0.97777}, "CVE-2002-1338": {"epss_score": 0.26508, "epss_percentile": 0.96152}, "CVE-2002-1339": {"epss_score": 0.18757, "epss_percentile": 0.95065}, "CVE-2002-1340": {"epss_score": 0.18757, "epss_percentile": 0.95065}, "CVE-2002-1341": {"epss_score": 0.02702, "epss_percentile": 0.85458}, "CVE-2002-1342": {"epss_score": 0.00982, "epss_percentile": 0.76295}, "CVE-2002-1344": {"epss_score": 0.00764, "epss_percentile": 0.72901}, "CVE-2002-1345": {"epss_score": 0.02126, "epss_percentile": 0.83691}, "CVE-2002-1347": {"epss_score": 0.09976, "epss_percentile": 0.928}, "CVE-2002-1348": {"epss_score": 0.01163, "epss_percentile": 0.78155}, "CVE-2002-1349": {"epss_score": 0.00299, "epss_percentile": 0.52891}, "CVE-2002-1350": {"epss_score": 0.02458, "epss_percentile": 0.84814}, "CVE-2002-1351": {"epss_score": 0.08448, "epss_percentile": 0.92056}, "CVE-2002-1352": {"epss_score": 0.00538, "epss_percentile": 0.66935}, "CVE-2002-1353": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2002-1354": {"epss_score": 0.00364, "epss_percentile": 0.57951}, "CVE-2002-1355": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1356": {"epss_score": 0.02051, "epss_percentile": 0.83407}, "CVE-2002-1357": {"epss_score": 0.18474, "epss_percentile": 0.95021}, "CVE-2002-1358": {"epss_score": 0.04128, "epss_percentile": 0.88294}, "CVE-2002-1359": {"epss_score": 0.86998, "epss_percentile": 0.99407}, "CVE-2002-1360": {"epss_score": 0.04128, "epss_percentile": 0.88294}, "CVE-2002-1361": {"epss_score": 0.20756, "epss_percentile": 0.95409}, "CVE-2002-1362": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2002-1363": {"epss_score": 0.06787, "epss_percentile": 0.91027}, "CVE-2002-1364": {"epss_score": 0.00235, "epss_percentile": 0.46311}, "CVE-2002-1365": {"epss_score": 0.04688, "epss_percentile": 0.89009}, "CVE-2002-1366": {"epss_score": 0.00089, "epss_percentile": 0.25949}, "CVE-2002-1367": {"epss_score": 0.03903, "epss_percentile": 0.87923}, "CVE-2002-1368": {"epss_score": 0.26753, "epss_percentile": 0.96173}, "CVE-2002-1369": {"epss_score": 0.09969, "epss_percentile": 0.92797}, "CVE-2002-1371": {"epss_score": 0.05872, "epss_percentile": 0.90279}, "CVE-2002-1372": {"epss_score": 0.08919, "epss_percentile": 0.92318}, "CVE-2002-1373": {"epss_score": 0.03123, "epss_percentile": 0.86452}, "CVE-2002-1374": {"epss_score": 0.25364, "epss_percentile": 0.96018}, "CVE-2002-1375": {"epss_score": 0.15031, "epss_percentile": 0.94349}, "CVE-2002-1376": {"epss_score": 0.03016, "epss_percentile": 0.86216}, "CVE-2002-1377": {"epss_score": 0.00077, "epss_percentile": 0.23367}, "CVE-2002-1378": {"epss_score": 0.09204, "epss_percentile": 0.92448}, "CVE-2002-1379": {"epss_score": 0.01232, "epss_percentile": 0.7874}, "CVE-2002-1380": {"epss_score": 0.00182, "epss_percentile": 0.4027}, "CVE-2002-1381": {"epss_score": 0.03052, "epss_percentile": 0.86291}, "CVE-2002-1382": {"epss_score": 0.15346, "epss_percentile": 0.94413}, "CVE-2002-1383": {"epss_score": 0.16212, "epss_percentile": 0.94595}, "CVE-2002-1384": {"epss_score": 0.0007, "epss_percentile": 0.21749}, "CVE-2002-1385": {"epss_score": 0.00051, "epss_percentile": 0.16069}, "CVE-2002-1386": {"epss_score": 0.00441, "epss_percentile": 0.62674}, "CVE-2002-1387": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-2002-1388": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2002-1389": {"epss_score": 0.00083, "epss_percentile": 0.24803}, "CVE-2002-1390": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2002-1391": {"epss_score": 0.03001, "epss_percentile": 0.86166}, "CVE-2002-1392": {"epss_score": 0.00078, "epss_percentile": 0.23623}, "CVE-2002-1393": {"epss_score": 0.02439, "epss_percentile": 0.8475}, "CVE-2002-1394": {"epss_score": 0.05353, "epss_percentile": 0.89776}, "CVE-2002-1395": {"epss_score": 0.00084, "epss_percentile": 0.25019}, "CVE-2002-1396": {"epss_score": 0.01946, "epss_percentile": 0.83002}, "CVE-2002-1397": {"epss_score": 0.00664, "epss_percentile": 0.70631}, "CVE-2002-1398": {"epss_score": 0.00162, "epss_percentile": 0.37654}, "CVE-2002-1399": {"epss_score": 0.00458, "epss_percentile": 0.63399}, "CVE-2002-1400": {"epss_score": 0.01601, "epss_percentile": 0.81262}, "CVE-2002-1401": {"epss_score": 0.0103, "epss_percentile": 0.76848}, "CVE-2002-1402": {"epss_score": 0.0014, "epss_percentile": 0.34688}, "CVE-2002-1403": {"epss_score": 0.00058, "epss_percentile": 0.18388}, "CVE-2002-1405": {"epss_score": 0.14084, "epss_percentile": 0.9413}, "CVE-2002-1406": {"epss_score": 0.00056, "epss_percentile": 0.17798}, "CVE-2002-1407": {"epss_score": 0.00479, "epss_percentile": 0.64443}, "CVE-2002-1408": {"epss_score": 0.00919, "epss_percentile": 0.75462}, "CVE-2002-1409": {"epss_score": 0.00103, "epss_percentile": 0.28971}, "CVE-2002-1410": {"epss_score": 0.1151, "epss_percentile": 0.93388}, "CVE-2002-1411": {"epss_score": 0.00272, "epss_percentile": 0.50403}, "CVE-2002-1412": {"epss_score": 0.16272, "epss_percentile": 0.94608}, "CVE-2002-1413": {"epss_score": 0.01692, "epss_percentile": 0.81791}, "CVE-2002-1414": {"epss_score": 0.00471, "epss_percentile": 0.64}, "CVE-2002-1415": {"epss_score": 0.01867, "epss_percentile": 0.8262}, "CVE-2002-1416": {"epss_score": 0.00625, "epss_percentile": 0.69598}, "CVE-2002-1417": {"epss_score": 0.13553, "epss_percentile": 0.93994}, "CVE-2002-1418": {"epss_score": 0.03922, "epss_percentile": 0.87954}, "CVE-2002-1419": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2002-1420": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2002-1421": {"epss_score": 0.00734, "epss_percentile": 0.72236}, "CVE-2002-1422": {"epss_score": 0.06338, "epss_percentile": 0.90681}, "CVE-2002-1423": {"epss_score": 0.0965, "epss_percentile": 0.92639}, "CVE-2002-1424": {"epss_score": 0.02168, "epss_percentile": 0.8386}, "CVE-2002-1425": {"epss_score": 0.01789, "epss_percentile": 0.82268}, "CVE-2002-1426": {"epss_score": 0.14944, "epss_percentile": 0.94331}, "CVE-2002-1427": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-1428": {"epss_score": 0.02685, "epss_percentile": 0.85424}, "CVE-2002-1429": {"epss_score": 0.05053, "epss_percentile": 0.89443}, "CVE-2002-1430": {"epss_score": 0.00517, "epss_percentile": 0.66091}, "CVE-2002-1431": {"epss_score": 0.00739, "epss_percentile": 0.72359}, "CVE-2002-1432": {"epss_score": 0.07515, "epss_percentile": 0.91513}, "CVE-2002-1433": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1434": {"epss_score": 0.00879, "epss_percentile": 0.74837}, "CVE-2002-1435": {"epss_score": 0.0577, "epss_percentile": 0.90192}, "CVE-2002-1436": {"epss_score": 0.09671, "epss_percentile": 0.92648}, "CVE-2002-1437": {"epss_score": 0.04604, "epss_percentile": 0.88906}, "CVE-2002-1438": {"epss_score": 0.00634, "epss_percentile": 0.69803}, "CVE-2002-1439": {"epss_score": 0.00104, "epss_percentile": 0.29219}, "CVE-2002-1440": {"epss_score": 0.00765, "epss_percentile": 0.72914}, "CVE-2002-1441": {"epss_score": 0.05713, "epss_percentile": 0.90143}, "CVE-2002-1442": {"epss_score": 0.00677, "epss_percentile": 0.70965}, "CVE-2002-1443": {"epss_score": 0.00382, "epss_percentile": 0.59064}, "CVE-2002-1444": {"epss_score": 0.17104, "epss_percentile": 0.94775}, "CVE-2002-1445": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2002-1446": {"epss_score": 0.00627, "epss_percentile": 0.69643}, "CVE-2002-1447": {"epss_score": 0.00409, "epss_percentile": 0.60692}, "CVE-2002-1448": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2002-1449": {"epss_score": 0.00751, "epss_percentile": 0.72647}, "CVE-2002-1450": {"epss_score": 0.00497, "epss_percentile": 0.65187}, "CVE-2002-1451": {"epss_score": 0.05784, "epss_percentile": 0.90205}, "CVE-2002-1452": {"epss_score": 0.16275, "epss_percentile": 0.94609}, "CVE-2002-1453": {"epss_score": 0.00655, "epss_percentile": 0.70428}, "CVE-2002-1454": {"epss_score": 0.00655, "epss_percentile": 0.70423}, "CVE-2002-1455": {"epss_score": 0.00448, "epss_percentile": 0.63002}, "CVE-2002-1456": {"epss_score": 0.151, "epss_percentile": 0.94362}, "CVE-2002-1457": {"epss_score": 0.01576, "epss_percentile": 0.81114}, "CVE-2002-1458": {"epss_score": 0.00874, "epss_percentile": 0.74763}, "CVE-2002-1459": {"epss_score": 0.01075, "epss_percentile": 0.77311}, "CVE-2002-1460": {"epss_score": 0.01412, "epss_percentile": 0.80115}, "CVE-2002-1461": {"epss_score": 0.02143, "epss_percentile": 0.83758}, "CVE-2002-1462": {"epss_score": 0.01148, "epss_percentile": 0.78016}, "CVE-2002-1463": {"epss_score": 0.11006, "epss_percentile": 0.93188}, "CVE-2002-1464": {"epss_score": 0.01209, "epss_percentile": 0.78542}, "CVE-2002-1465": {"epss_score": 0.00712, "epss_percentile": 0.71756}, "CVE-2002-1466": {"epss_score": 0.01185, "epss_percentile": 0.78335}, "CVE-2002-1467": {"epss_score": 0.00488, "epss_percentile": 0.64836}, "CVE-2002-1468": {"epss_score": 0.10655, "epss_percentile": 0.9306}, "CVE-2002-1469": {"epss_score": 0.03646, "epss_percentile": 0.87499}, "CVE-2002-1470": {"epss_score": 0.00099, "epss_percentile": 0.28358}, "CVE-2002-1471": {"epss_score": 0.00262, "epss_percentile": 0.4935}, "CVE-2002-1472": {"epss_score": 0.00055, "epss_percentile": 0.17517}, "CVE-2002-1473": {"epss_score": 0.09981, "epss_percentile": 0.92802}, "CVE-2002-1474": {"epss_score": 0.00712, "epss_percentile": 0.7175}, "CVE-2002-1475": {"epss_score": 0.00712, "epss_percentile": 0.7175}, "CVE-2002-1476": {"epss_score": 0.00099, "epss_percentile": 0.2831}, "CVE-2002-1477": {"epss_score": 0.02653, "epss_percentile": 0.8535}, "CVE-2002-1478": {"epss_score": 0.00591, "epss_percentile": 0.68596}, "CVE-2002-1479": {"epss_score": 0.00118, "epss_percentile": 0.31469}, "CVE-2002-1480": {"epss_score": 0.00879, "epss_percentile": 0.74837}, "CVE-2002-1481": {"epss_score": 0.06763, "epss_percentile": 0.91009}, "CVE-2002-1482": {"epss_score": 0.00688, "epss_percentile": 0.71193}, "CVE-2002-1483": {"epss_score": 0.05112, "epss_percentile": 0.8951}, "CVE-2002-1484": {"epss_score": 0.0703, "epss_percentile": 0.91197}, "CVE-2002-1485": {"epss_score": 0.0057, "epss_percentile": 0.6797}, "CVE-2002-1486": {"epss_score": 0.43974, "epss_percentile": 0.97411}, "CVE-2002-1487": {"epss_score": 0.15609, "epss_percentile": 0.94469}, "CVE-2002-1488": {"epss_score": 0.04376, "epss_percentile": 0.88617}, "CVE-2002-1489": {"epss_score": 0.0796, "epss_percentile": 0.9179}, "CVE-2002-1490": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2002-1491": {"epss_score": 0.00325, "epss_percentile": 0.55002}, "CVE-2002-1492": {"epss_score": 0.00213, "epss_percentile": 0.43927}, "CVE-2002-1493": {"epss_score": 0.00591, "epss_percentile": 0.68581}, "CVE-2002-1494": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2002-1495": {"epss_score": 0.01353, "epss_percentile": 0.79694}, "CVE-2002-1496": {"epss_score": 0.14499, "epss_percentile": 0.94225}, "CVE-2002-1497": {"epss_score": 0.00442, "epss_percentile": 0.627}, "CVE-2002-1498": {"epss_score": 0.00533, "epss_percentile": 0.66752}, "CVE-2002-1499": {"epss_score": 0.0053, "epss_percentile": 0.66607}, "CVE-2002-1500": {"epss_score": 0.00145, "epss_percentile": 0.35449}, "CVE-2002-1501": {"epss_score": 0.06794, "epss_percentile": 0.91031}, "CVE-2002-1502": {"epss_score": 0.00182, "epss_percentile": 0.40233}, "CVE-2002-1503": {"epss_score": 0.00228, "epss_percentile": 0.45542}, "CVE-2002-1504": {"epss_score": 0.0046, "epss_percentile": 0.63533}, "CVE-2002-1505": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2002-1506": {"epss_score": 0.00463, "epss_percentile": 0.63685}, "CVE-2002-1507": {"epss_score": 0.0057, "epss_percentile": 0.6797}, "CVE-2002-1508": {"epss_score": 0.00028, "epss_percentile": 0.07521}, "CVE-2002-1509": {"epss_score": 0.00075, "epss_percentile": 0.23057}, "CVE-2002-1510": {"epss_score": 0.00812, "epss_percentile": 0.73742}, "CVE-2002-1511": {"epss_score": 0.00946, "epss_percentile": 0.75807}, "CVE-2002-1512": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-2002-1513": {"epss_score": 0.00277, "epss_percentile": 0.50787}, "CVE-2002-1514": {"epss_score": 0.00397, "epss_percentile": 0.60027}, "CVE-2002-1515": {"epss_score": 0.01482, "epss_percentile": 0.80574}, "CVE-2002-1516": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2002-1517": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2002-1518": {"epss_score": 0.00054, "epss_percentile": 0.17337}, "CVE-2002-1519": {"epss_score": 0.03685, "epss_percentile": 0.87569}, "CVE-2002-1520": {"epss_score": 0.00826, "epss_percentile": 0.73965}, "CVE-2002-1521": {"epss_score": 0.00078, "epss_percentile": 0.23578}, "CVE-2002-1522": {"epss_score": 0.15278, "epss_percentile": 0.94397}, "CVE-2002-1523": {"epss_score": 0.00653, "epss_percentile": 0.70338}, "CVE-2002-1524": {"epss_score": 0.1148, "epss_percentile": 0.93379}, "CVE-2002-1525": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2002-1526": {"epss_score": 0.00556, "epss_percentile": 0.67529}, "CVE-2002-1527": {"epss_score": 0.04308, "epss_percentile": 0.88528}, "CVE-2002-1528": {"epss_score": 0.00501, "epss_percentile": 0.65356}, "CVE-2002-1529": {"epss_score": 0.00879, "epss_percentile": 0.74837}, "CVE-2002-1530": {"epss_score": 0.07133, "epss_percentile": 0.91272}, "CVE-2002-1531": {"epss_score": 0.00782, "epss_percentile": 0.73197}, "CVE-2002-1532": {"epss_score": 0.00782, "epss_percentile": 0.73197}, "CVE-2002-1533": {"epss_score": 0.05189, "epss_percentile": 0.89593}, "CVE-2002-1534": {"epss_score": 0.00568, "epss_percentile": 0.67889}, "CVE-2002-1535": {"epss_score": 0.00822, "epss_percentile": 0.7392}, "CVE-2002-1536": {"epss_score": 0.01458, "epss_percentile": 0.80409}, "CVE-2002-1537": {"epss_score": 0.00412, "epss_percentile": 0.60929}, "CVE-2002-1538": {"epss_score": 0.00501, "epss_percentile": 0.65356}, "CVE-2002-1539": {"epss_score": 0.04295, "epss_percentile": 0.88508}, "CVE-2002-1540": {"epss_score": 0.00058, "epss_percentile": 0.18608}, "CVE-2002-1541": {"epss_score": 0.00415, "epss_percentile": 0.61121}, "CVE-2002-1542": {"epss_score": 0.07353, "epss_percentile": 0.91427}, "CVE-2002-1543": {"epss_score": 0.00086, "epss_percentile": 0.25364}, "CVE-2002-1544": {"epss_score": 0.00353, "epss_percentile": 0.5718}, "CVE-2002-1545": {"epss_score": 0.00497, "epss_percentile": 0.6519}, "CVE-2002-1546": {"epss_score": 0.00428, "epss_percentile": 0.61953}, "CVE-2002-1547": {"epss_score": 0.01724, "epss_percentile": 0.8195}, "CVE-2002-1548": {"epss_score": 0.00062, "epss_percentile": 0.19658}, "CVE-2002-1549": {"epss_score": 0.07104, "epss_percentile": 0.91255}, "CVE-2002-1550": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2002-1551": {"epss_score": 0.00096, "epss_percentile": 0.27305}, "CVE-2002-1552": {"epss_score": 0.0021, "epss_percentile": 0.43446}, "CVE-2002-1553": {"epss_score": 0.00741, "epss_percentile": 0.72434}, "CVE-2002-1554": {"epss_score": 0.00107, "epss_percentile": 0.29632}, "CVE-2002-1555": {"epss_score": 0.00718, "epss_percentile": 0.71931}, "CVE-2002-1556": {"epss_score": 0.00486, "epss_percentile": 0.64762}, "CVE-2002-1557": {"epss_score": 0.00486, "epss_percentile": 0.64762}, "CVE-2002-1558": {"epss_score": 0.00925, "epss_percentile": 0.75531}, "CVE-2002-1559": {"epss_score": 0.04308, "epss_percentile": 0.88528}, "CVE-2002-1560": {"epss_score": 0.02363, "epss_percentile": 0.84505}, "CVE-2002-1561": {"epss_score": 0.62404, "epss_percentile": 0.98292}, "CVE-2002-1562": {"epss_score": 0.01951, "epss_percentile": 0.83017}, "CVE-2002-1563": {"epss_score": 0.00083, "epss_percentile": 0.24743}, "CVE-2002-1564": {"epss_score": 0.15855, "epss_percentile": 0.9452}, "CVE-2002-1565": {"epss_score": 0.00937, "epss_percentile": 0.75695}, "CVE-2002-1566": {"epss_score": 0.05816, "epss_percentile": 0.90232}, "CVE-2002-1567": {"epss_score": 0.4822, "epss_percentile": 0.97627}, "CVE-2002-1568": {"epss_score": 0.01095, "epss_percentile": 0.77512}, "CVE-2002-1569": {"epss_score": 0.02509, "epss_percentile": 0.84944}, "CVE-2002-1570": {"epss_score": 0.09702, "epss_percentile": 0.92668}, "CVE-2002-1571": {"epss_score": 0.00075, "epss_percentile": 0.22939}, "CVE-2002-1572": {"epss_score": 0.00437, "epss_percentile": 0.62508}, "CVE-2002-1573": {"epss_score": 0.00437, "epss_percentile": 0.62508}, "CVE-2002-1574": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2002-1575": {"epss_score": 0.00751, "epss_percentile": 0.72635}, "CVE-2002-1576": {"epss_score": 0.00325, "epss_percentile": 0.55035}, "CVE-2002-1577": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2002-1578": {"epss_score": 0.01257, "epss_percentile": 0.78949}, "CVE-2002-1579": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1580": {"epss_score": 0.48545, "epss_percentile": 0.97642}, "CVE-2002-1581": {"epss_score": 0.09746, "epss_percentile": 0.92689}, "CVE-2002-1582": {"epss_score": 0.01482, "epss_percentile": 0.8058}, "CVE-2002-1583": {"epss_score": 0.00273, "epss_percentile": 0.50434}, "CVE-2002-1584": {"epss_score": 0.03281, "epss_percentile": 0.86817}, "CVE-2002-1585": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1586": {"epss_score": 0.00084, "epss_percentile": 0.24864}, "CVE-2002-1587": {"epss_score": 0.00081, "epss_percentile": 0.24318}, "CVE-2002-1588": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1589": {"epss_score": 0.00081, "epss_percentile": 0.24318}, "CVE-2002-1590": {"epss_score": 0.00046, "epss_percentile": 0.14203}, "CVE-2002-1591": {"epss_score": 0.00566, "epss_percentile": 0.67834}, "CVE-2002-1592": {"epss_score": 0.05137, "epss_percentile": 0.89536}, "CVE-2002-1593": {"epss_score": 0.37375, "epss_percentile": 0.97037}, "CVE-2002-1594": {"epss_score": 0.0014, "epss_percentile": 0.34721}, "CVE-2002-1595": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2002-1596": {"epss_score": 0.00844, "epss_percentile": 0.74275}, "CVE-2002-1597": {"epss_score": 0.00997, "epss_percentile": 0.76461}, "CVE-2002-1598": {"epss_score": 0.00448, "epss_percentile": 0.63029}, "CVE-2002-1599": {"epss_score": 0.00867, "epss_percentile": 0.74656}, "CVE-2002-1600": {"epss_score": 0.01157, "epss_percentile": 0.78116}, "CVE-2002-1601": {"epss_score": 0.04694, "epss_percentile": 0.89016}, "CVE-2002-1602": {"epss_score": 0.00242, "epss_percentile": 0.4735}, "CVE-2002-1603": {"epss_score": 0.35746, "epss_percentile": 0.9693}, "CVE-2002-1604": {"epss_score": 0.53089, "epss_percentile": 0.97856}, "CVE-2002-1605": {"epss_score": 0.44008, "epss_percentile": 0.97415}, "CVE-2002-1606": {"epss_score": 0.00303, "epss_percentile": 0.53233}, "CVE-2002-1607": {"epss_score": 0.00708, "epss_percentile": 0.71679}, "CVE-2002-1608": {"epss_score": 0.00708, "epss_percentile": 0.71679}, "CVE-2002-1609": {"epss_score": 0.0086, "epss_percentile": 0.74539}, "CVE-2002-1610": {"epss_score": 0.0094, "epss_percentile": 0.7573}, "CVE-2002-1611": {"epss_score": 0.0115, "epss_percentile": 0.78031}, "CVE-2002-1612": {"epss_score": 0.0068, "epss_percentile": 0.71028}, "CVE-2002-1613": {"epss_score": 0.00708, "epss_percentile": 0.71677}, "CVE-2002-1614": {"epss_score": 0.00994, "epss_percentile": 0.76423}, "CVE-2002-1615": {"epss_score": 0.00091, "epss_percentile": 0.26268}, "CVE-2002-1616": {"epss_score": 0.00345, "epss_percentile": 0.56596}, "CVE-2002-1617": {"epss_score": 0.00247, "epss_percentile": 0.47885}, "CVE-2002-1618": {"epss_score": 0.00079, "epss_percentile": 0.23918}, "CVE-2002-1619": {"epss_score": 0.03538, "epss_percentile": 0.87313}, "CVE-2002-1620": {"epss_score": 0.01653, "epss_percentile": 0.8158}, "CVE-2002-1621": {"epss_score": 0.26372, "epss_percentile": 0.96142}, "CVE-2002-1622": {"epss_score": 0.02705, "epss_percentile": 0.85466}, "CVE-2002-1623": {"epss_score": 0.75045, "epss_percentile": 0.98829}, "CVE-2002-1624": {"epss_score": 0.05326, "epss_percentile": 0.89735}, "CVE-2002-1625": {"epss_score": 0.13159, "epss_percentile": 0.93887}, "CVE-2002-1626": {"epss_score": 0.01955, "epss_percentile": 0.83032}, "CVE-2002-1627": {"epss_score": 0.01955, "epss_percentile": 0.83032}, "CVE-2002-1628": {"epss_score": 0.00573, "epss_percentile": 0.68045}, "CVE-2002-1629": {"epss_score": 0.01268, "epss_percentile": 0.79025}, "CVE-2002-1630": {"epss_score": 0.0472, "epss_percentile": 0.89047}, "CVE-2002-1631": {"epss_score": 0.05943, "epss_percentile": 0.90352}, "CVE-2002-1632": {"epss_score": 0.01444, "epss_percentile": 0.80319}, "CVE-2002-1633": {"epss_score": 0.00348, "epss_percentile": 0.56847}, "CVE-2002-1634": {"epss_score": 0.08555, "epss_percentile": 0.92122}, "CVE-2002-1635": {"epss_score": 0.00953, "epss_percentile": 0.75886}, "CVE-2002-1636": {"epss_score": 0.00294, "epss_percentile": 0.52415}, "CVE-2002-1637": {"epss_score": 0.00118, "epss_percentile": 0.3141}, "CVE-2002-1639": {"epss_score": 0.02093, "epss_percentile": 0.83576}, "CVE-2002-1640": {"epss_score": 0.0152, "epss_percentile": 0.80823}, "CVE-2002-1641": {"epss_score": 0.13216, "epss_percentile": 0.93904}, "CVE-2002-1642": {"epss_score": 0.00065, "epss_percentile": 0.20637}, "CVE-2002-1643": {"epss_score": 0.81942, "epss_percentile": 0.99165}, "CVE-2002-1644": {"epss_score": 0.00076, "epss_percentile": 0.23129}, "CVE-2002-1645": {"epss_score": 0.14469, "epss_percentile": 0.94219}, "CVE-2002-1646": {"epss_score": 0.01976, "epss_percentile": 0.8312}, "CVE-2002-1647": {"epss_score": 0.01148, "epss_percentile": 0.78011}, "CVE-2002-1648": {"epss_score": 0.01268, "epss_percentile": 0.79026}, "CVE-2002-1649": {"epss_score": 0.0132, "epss_percentile": 0.79438}, "CVE-2002-1650": {"epss_score": 0.03172, "epss_percentile": 0.86551}, "CVE-2002-1651": {"epss_score": 0.01926, "epss_percentile": 0.82924}, "CVE-2002-1652": {"epss_score": 0.43974, "epss_percentile": 0.97411}, "CVE-2002-1653": {"epss_score": 0.0098, "epss_percentile": 0.76271}, "CVE-2002-1654": {"epss_score": 0.01854, "epss_percentile": 0.82554}, "CVE-2002-1655": {"epss_score": 0.01314, "epss_percentile": 0.79399}, "CVE-2002-1656": {"epss_score": 0.14207, "epss_percentile": 0.94163}, "CVE-2002-1657": {"epss_score": 0.00398, "epss_percentile": 0.60074}, "CVE-2002-1658": {"epss_score": 0.00149, "epss_percentile": 0.35976}, "CVE-2002-1659": {"epss_score": 0.0035, "epss_percentile": 0.56971}, "CVE-2002-1660": {"epss_score": 0.11742, "epss_percentile": 0.93464}, "CVE-2002-1661": {"epss_score": 0.02458, "epss_percentile": 0.84814}, "CVE-2002-1662": {"epss_score": 0.00855, "epss_percentile": 0.7447}, "CVE-2002-1663": {"epss_score": 0.08528, "epss_percentile": 0.92105}, "CVE-2002-1664": {"epss_score": 0.01488, "epss_percentile": 0.8062}, "CVE-2002-1665": {"epss_score": 0.134, "epss_percentile": 0.93952}, "CVE-2002-1666": {"epss_score": 0.0051, "epss_percentile": 0.65809}, "CVE-2002-1667": {"epss_score": 0.00058, "epss_percentile": 0.18446}, "CVE-2002-1668": {"epss_score": 0.00088, "epss_percentile": 0.25744}, "CVE-2002-1669": {"epss_score": 0.00051, "epss_percentile": 0.16032}, "CVE-2002-1670": {"epss_score": 0.00448, "epss_percentile": 0.63011}, "CVE-2002-1671": {"epss_score": 0.24647, "epss_percentile": 0.95943}, "CVE-2002-1672": {"epss_score": 0.00056, "epss_percentile": 0.17892}, "CVE-2002-1673": {"epss_score": 0.00113, "epss_percentile": 0.30667}, "CVE-2002-1674": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2002-1675": {"epss_score": 0.01922, "epss_percentile": 0.82903}, "CVE-2002-1676": {"epss_score": 0.00072, "epss_percentile": 0.22432}, "CVE-2002-1677": {"epss_score": 0.00421, "epss_percentile": 0.61534}, "CVE-2002-1678": {"epss_score": 0.00448, "epss_percentile": 0.63003}, "CVE-2002-1679": {"epss_score": 0.00392, "epss_percentile": 0.59666}, "CVE-2002-1680": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2002-1681": {"epss_score": 0.00855, "epss_percentile": 0.7447}, "CVE-2002-1682": {"epss_score": 0.00038, "epss_percentile": 0.11214}, "CVE-2002-1683": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2002-1684": {"epss_score": 0.00229, "epss_percentile": 0.45619}, "CVE-2002-1685": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2002-1686": {"epss_score": 0.00505, "epss_percentile": 0.65555}, "CVE-2002-1687": {"epss_score": 0.0006, "epss_percentile": 0.19084}, "CVE-2002-1688": {"epss_score": 0.36699, "epss_percentile": 0.96997}, "CVE-2002-1689": {"epss_score": 0.01421, "epss_percentile": 0.80173}, "CVE-2002-1690": {"epss_score": 0.00476, "epss_percentile": 0.64282}, "CVE-2002-1691": {"epss_score": 0.00933, "epss_percentile": 0.75638}, "CVE-2002-1692": {"epss_score": 0.00318, "epss_percentile": 0.5441}, "CVE-2002-1694": {"epss_score": 0.01603, "epss_percentile": 0.81279}, "CVE-2002-1695": {"epss_score": 0.01957, "epss_percentile": 0.83046}, "CVE-2002-1696": {"epss_score": 0.00064, "epss_percentile": 0.20308}, "CVE-2002-1697": {"epss_score": 0.00377, "epss_percentile": 0.58761}, "CVE-2002-1698": {"epss_score": 0.18866, "epss_percentile": 0.95082}, "CVE-2002-1699": {"epss_score": 0.01871, "epss_percentile": 0.82633}, "CVE-2002-1700": {"epss_score": 0.16341, "epss_percentile": 0.94632}, "CVE-2002-1702": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2002-1703": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2002-1704": {"epss_score": 0.03263, "epss_percentile": 0.86777}, "CVE-2002-1705": {"epss_score": 0.39886, "epss_percentile": 0.97186}, "CVE-2002-1706": {"epss_score": 0.00363, "epss_percentile": 0.57902}, "CVE-2002-1707": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2002-1708": {"epss_score": 0.00655, "epss_percentile": 0.70428}, "CVE-2002-1709": {"epss_score": 0.00288, "epss_percentile": 0.51883}, "CVE-2002-1710": {"epss_score": 0.0007, "epss_percentile": 0.2183}, "CVE-2002-1711": {"epss_score": 0.00153, "epss_percentile": 0.36613}, "CVE-2002-1712": {"epss_score": 0.49862, "epss_percentile": 0.97708}, "CVE-2002-1713": {"epss_score": 0.00264, "epss_percentile": 0.49723}, "CVE-2002-1714": {"epss_score": 0.19733, "epss_percentile": 0.95233}, "CVE-2002-1715": {"epss_score": 0.00108, "epss_percentile": 0.2983}, "CVE-2002-1716": {"epss_score": 0.17162, "epss_percentile": 0.9479}, "CVE-2002-1717": {"epss_score": 0.15025, "epss_percentile": 0.94348}, "CVE-2002-1718": {"epss_score": 0.25288, "epss_percentile": 0.96009}, "CVE-2002-1719": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2002-1720": {"epss_score": 0.01308, "epss_percentile": 0.79347}, "CVE-2002-1721": {"epss_score": 0.01414, "epss_percentile": 0.80126}, "CVE-2002-1722": {"epss_score": 0.00071, "epss_percentile": 0.22171}, "CVE-2002-1723": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2002-1724": {"epss_score": 0.00855, "epss_percentile": 0.7447}, "CVE-2002-1725": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2002-1726": {"epss_score": 0.00475, "epss_percentile": 0.64171}, "CVE-2002-1727": {"epss_score": 0.00655, "epss_percentile": 0.70428}, "CVE-2002-1728": {"epss_score": 0.00421, "epss_percentile": 0.61534}, "CVE-2002-1729": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2002-1730": {"epss_score": 0.00392, "epss_percentile": 0.59666}, "CVE-2002-1731": {"epss_score": 0.0076, "epss_percentile": 0.72817}, "CVE-2002-1732": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2002-1733": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2002-1734": {"epss_score": 0.01567, "epss_percentile": 0.81073}, "CVE-2002-1735": {"epss_score": 0.00055, "epss_percentile": 0.17525}, "CVE-2002-1736": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2002-1737": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2002-1738": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2002-1739": {"epss_score": 0.00022, "epss_percentile": 0.05197}, "CVE-2002-1740": {"epss_score": 0.00144, "epss_percentile": 0.35255}, "CVE-2002-1741": {"epss_score": 0.00112, "epss_percentile": 0.30564}, "CVE-2002-1742": {"epss_score": 0.00684, "epss_percentile": 0.71123}, "CVE-2002-1743": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2002-1744": {"epss_score": 0.67259, "epss_percentile": 0.985}, "CVE-2002-1745": {"epss_score": 0.10167, "epss_percentile": 0.92873}, "CVE-2002-1746": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2002-1747": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2002-1748": {"epss_score": 0.00424, "epss_percentile": 0.61642}, "CVE-2002-1749": {"epss_score": 0.00533, "epss_percentile": 0.66713}, "CVE-2002-1750": {"epss_score": 0.01439, "epss_percentile": 0.80292}, "CVE-2002-1751": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2002-1752": {"epss_score": 0.01439, "epss_percentile": 0.80292}, "CVE-2002-1753": {"epss_score": 0.05911, "epss_percentile": 0.90315}, "CVE-2002-1754": {"epss_score": 0.00054, "epss_percentile": 0.17083}, "CVE-2002-1755": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2002-1756": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2002-1757": {"epss_score": 0.04003, "epss_percentile": 0.88096}, "CVE-2002-1758": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2002-1759": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2002-1760": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2002-1761": {"epss_score": 0.00231, "epss_percentile": 0.45822}, "CVE-2002-1762": {"epss_score": 0.06185, "epss_percentile": 0.90541}, "CVE-2002-1763": {"epss_score": 0.00073, "epss_percentile": 0.22647}, "CVE-2002-1764": {"epss_score": 0.00203, "epss_percentile": 0.42528}, "CVE-2002-1765": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2002-1766": {"epss_score": 0.00157, "epss_percentile": 0.37051}, "CVE-2002-1767": {"epss_score": 0.04043, "epss_percentile": 0.88169}, "CVE-2002-1768": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2002-1769": {"epss_score": 0.18966, "epss_percentile": 0.95103}, "CVE-2002-1770": {"epss_score": 0.01186, "epss_percentile": 0.78348}, "CVE-2002-1771": {"epss_score": 0.00392, "epss_percentile": 0.59666}, "CVE-2002-1772": {"epss_score": 0.00031, "epss_percentile": 0.08411}, "CVE-2002-1773": {"epss_score": 0.28768, "epss_percentile": 0.96383}, "CVE-2002-1774": {"epss_score": 0.00214, "epss_percentile": 0.43987}, "CVE-2002-1775": {"epss_score": 0.00214, "epss_percentile": 0.43987}, "CVE-2002-1776": {"epss_score": 0.00214, "epss_percentile": 0.43987}, "CVE-2002-1777": {"epss_score": 0.00214, "epss_percentile": 0.43987}, "CVE-2002-1778": {"epss_score": 0.00452, "epss_percentile": 0.63166}, "CVE-2002-1779": {"epss_score": 0.00656, "epss_percentile": 0.70442}, "CVE-2002-1780": {"epss_score": 0.00651, "epss_percentile": 0.70301}, "CVE-2002-1781": {"epss_score": 0.0385, "epss_percentile": 0.87848}, "CVE-2002-1782": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2002-1783": {"epss_score": 0.01153, "epss_percentile": 0.78052}, "CVE-2002-1784": {"epss_score": 0.02035, "epss_percentile": 0.83351}, "CVE-2002-1785": {"epss_score": 0.00332, "epss_percentile": 0.55602}, "CVE-2002-1786": {"epss_score": 0.00144, "epss_percentile": 0.35337}, "CVE-2002-1787": {"epss_score": 0.00333, "epss_percentile": 0.5562}, "CVE-2002-1788": {"epss_score": 0.00819, "epss_percentile": 0.73865}, "CVE-2002-1789": {"epss_score": 0.00265, "epss_percentile": 0.49812}, "CVE-2002-1790": {"epss_score": 0.19725, "epss_percentile": 0.95232}, "CVE-2002-1791": {"epss_score": 0.00109, "epss_percentile": 0.30008}, "CVE-2002-1792": {"epss_score": 0.14689, "epss_percentile": 0.94266}, "CVE-2002-1793": {"epss_score": 0.00873, "epss_percentile": 0.74744}, "CVE-2002-1794": {"epss_score": 0.009, "epss_percentile": 0.75163}, "CVE-2002-1795": {"epss_score": 0.17601, "epss_percentile": 0.94873}, "CVE-2002-1796": {"epss_score": 0.00108, "epss_percentile": 0.29806}, "CVE-2002-1797": {"epss_score": 0.00253, "epss_percentile": 0.48462}, "CVE-2002-1798": {"epss_score": 0.06104, "epss_percentile": 0.90484}, "CVE-2002-1799": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2002-1800": {"epss_score": 0.00441, "epss_percentile": 0.62665}, "CVE-2002-1801": {"epss_score": 0.00585, "epss_percentile": 0.684}, "CVE-2002-1802": {"epss_score": 0.00652, "epss_percentile": 0.7031}, "CVE-2002-1803": {"epss_score": 0.00108, "epss_percentile": 0.29836}, "CVE-2002-1804": {"epss_score": 0.01549, "epss_percentile": 0.80979}, "CVE-2002-1805": {"epss_score": 0.01606, "epss_percentile": 0.813}, "CVE-2002-1806": {"epss_score": 0.02712, "epss_percentile": 0.85499}, "CVE-2002-1807": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2002-1808": {"epss_score": 0.00483, "epss_percentile": 0.64559}, "CVE-2002-1809": {"epss_score": 0.08984, "epss_percentile": 0.92351}, "CVE-2002-1810": {"epss_score": 0.00837, "epss_percentile": 0.74157}, "CVE-2002-1811": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2002-1812": {"epss_score": 0.00477, "epss_percentile": 0.64306}, "CVE-2002-1813": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-1814": {"epss_score": 0.00252, "epss_percentile": 0.484}, "CVE-2002-1815": {"epss_score": 0.00446, "epss_percentile": 0.62903}, "CVE-2002-1816": {"epss_score": 0.11483, "epss_percentile": 0.9338}, "CVE-2002-1817": {"epss_score": 0.00737, "epss_percentile": 0.72333}, "CVE-2002-1818": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2002-1819": {"epss_score": 0.00559, "epss_percentile": 0.67614}, "CVE-2002-1820": {"epss_score": 0.01529, "epss_percentile": 0.80882}, "CVE-2002-1821": {"epss_score": 0.00206, "epss_percentile": 0.42932}, "CVE-2002-1822": {"epss_score": 0.00274, "epss_percentile": 0.50572}, "CVE-2002-1823": {"epss_score": 0.05386, "epss_percentile": 0.89821}, "CVE-2002-1824": {"epss_score": 0.03009, "epss_percentile": 0.86195}, "CVE-2002-1825": {"epss_score": 0.01079, "epss_percentile": 0.77356}, "CVE-2002-1826": {"epss_score": 0.00073, "epss_percentile": 0.22499}, "CVE-2002-1827": {"epss_score": 0.00754, "epss_percentile": 0.727}, "CVE-2002-1828": {"epss_score": 0.04186, "epss_percentile": 0.88363}, "CVE-2002-1829": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2002-1830": {"epss_score": 0.04003, "epss_percentile": 0.88096}, "CVE-2002-1831": {"epss_score": 0.10369, "epss_percentile": 0.92962}, "CVE-2002-1832": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2002-1833": {"epss_score": 0.01507, "epss_percentile": 0.80755}, "CVE-2002-1834": {"epss_score": 0.00509, "epss_percentile": 0.65728}, "CVE-2002-1835": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2002-1836": {"epss_score": 0.00483, "epss_percentile": 0.64591}, "CVE-2002-1837": {"epss_score": 0.06958, "epss_percentile": 0.91148}, "CVE-2002-1838": {"epss_score": 0.00292, "epss_percentile": 0.52213}, "CVE-2002-1839": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2002-1840": {"epss_score": 0.01629, "epss_percentile": 0.81441}, "CVE-2002-1841": {"epss_score": 0.00721, "epss_percentile": 0.71977}, "CVE-2002-1842": {"epss_score": 0.0111, "epss_percentile": 0.77662}, "CVE-2002-1843": {"epss_score": 0.0111, "epss_percentile": 0.77662}, "CVE-2002-1844": {"epss_score": 0.00491, "epss_percentile": 0.64968}, "CVE-2002-1845": {"epss_score": 0.00598, "epss_percentile": 0.68756}, "CVE-2002-1846": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2002-1847": {"epss_score": 0.05575, "epss_percentile": 0.90012}, "CVE-2002-1848": {"epss_score": 0.00065, "epss_percentile": 0.2052}, "CVE-2002-1849": {"epss_score": 0.00782, "epss_percentile": 0.73197}, "CVE-2002-1850": {"epss_score": 0.02915, "epss_percentile": 0.85979}, "CVE-2002-1851": {"epss_score": 0.13829, "epss_percentile": 0.94068}, "CVE-2002-1852": {"epss_score": 0.03024, "epss_percentile": 0.86233}, "CVE-2002-1853": {"epss_score": 0.00409, "epss_percentile": 0.607}, "CVE-2002-1854": {"epss_score": 0.0196, "epss_percentile": 0.83056}, "CVE-2002-1855": {"epss_score": 0.00763, "epss_percentile": 0.72854}, "CVE-2002-1856": {"epss_score": 0.00492, "epss_percentile": 0.64995}, "CVE-2002-1857": {"epss_score": 0.0032, "epss_percentile": 0.5461}, "CVE-2002-1858": {"epss_score": 0.00368, "epss_percentile": 0.58211}, "CVE-2002-1859": {"epss_score": 0.00347, "epss_percentile": 0.56765}, "CVE-2002-1860": {"epss_score": 0.0032, "epss_percentile": 0.5461}, "CVE-2002-1861": {"epss_score": 0.00435, "epss_percentile": 0.62325}, "CVE-2002-1862": {"epss_score": 0.04779, "epss_percentile": 0.89135}, "CVE-2002-1863": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2002-1864": {"epss_score": 0.59336, "epss_percentile": 0.98161}, "CVE-2002-1865": {"epss_score": 0.057, "epss_percentile": 0.90131}, "CVE-2002-1866": {"epss_score": 0.00715, "epss_percentile": 0.7185}, "CVE-2002-1867": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2002-1868": {"epss_score": 0.12886, "epss_percentile": 0.93812}, "CVE-2002-1869": {"epss_score": 0.00119, "epss_percentile": 0.3155}, "CVE-2002-1870": {"epss_score": 0.02071, "epss_percentile": 0.83481}, "CVE-2002-1871": {"epss_score": 0.00056, "epss_percentile": 0.17826}, "CVE-2002-1872": {"epss_score": 0.01171, "epss_percentile": 0.78224}, "CVE-2002-1873": {"epss_score": 0.15142, "epss_percentile": 0.94372}, "CVE-2002-1874": {"epss_score": 0.01591, "epss_percentile": 0.81222}, "CVE-2002-1875": {"epss_score": 0.00156, "epss_percentile": 0.36998}, "CVE-2002-1876": {"epss_score": 0.00574, "epss_percentile": 0.68089}, "CVE-2002-1877": {"epss_score": 0.00134, "epss_percentile": 0.3386}, "CVE-2002-1878": {"epss_score": 0.02928, "epss_percentile": 0.86011}, "CVE-2002-1879": {"epss_score": 0.00927, "epss_percentile": 0.75561}, "CVE-2002-1880": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2002-1881": {"epss_score": 0.05448, "epss_percentile": 0.89889}, "CVE-2002-1882": {"epss_score": 0.01504, "epss_percentile": 0.80737}, "CVE-2002-1883": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2002-1884": {"epss_score": 0.05444, "epss_percentile": 0.89886}, "CVE-2002-1885": {"epss_score": 0.01937, "epss_percentile": 0.82963}, "CVE-2002-1886": {"epss_score": 0.05247, "epss_percentile": 0.89662}, "CVE-2002-1887": {"epss_score": 0.02963, "epss_percentile": 0.86074}, "CVE-2002-1888": {"epss_score": 0.00144, "epss_percentile": 0.35337}, "CVE-2002-1889": {"epss_score": 0.01961, "epss_percentile": 0.8306}, "CVE-2002-1890": {"epss_score": 0.0018, "epss_percentile": 0.39871}, "CVE-2002-1891": {"epss_score": 0.25698, "epss_percentile": 0.96057}, "CVE-2002-1892": {"epss_score": 0.00144, "epss_percentile": 0.35337}, "CVE-2002-1893": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2002-1894": {"epss_score": 0.00498, "epss_percentile": 0.65234}, "CVE-2002-1895": {"epss_score": 0.02785, "epss_percentile": 0.85656}, "CVE-2002-1896": {"epss_score": 0.00609, "epss_percentile": 0.6909}, "CVE-2002-1897": {"epss_score": 0.06666, "epss_percentile": 0.90929}, "CVE-2002-1898": {"epss_score": 0.0593, "epss_percentile": 0.90334}, "CVE-2002-1899": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2002-1900": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2002-1901": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2002-1902": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1903": {"epss_score": 0.0076, "epss_percentile": 0.72801}, "CVE-2002-1904": {"epss_score": 0.15187, "epss_percentile": 0.9438}, "CVE-2002-1905": {"epss_score": 0.04353, "epss_percentile": 0.88587}, "CVE-2002-1906": {"epss_score": 0.05121, "epss_percentile": 0.89519}, "CVE-2002-1907": {"epss_score": 0.07894, "epss_percentile": 0.9175}, "CVE-2002-1908": {"epss_score": 0.11486, "epss_percentile": 0.93381}, "CVE-2002-1909": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2002-1910": {"epss_score": 0.02573, "epss_percentile": 0.85136}, "CVE-2002-1911": {"epss_score": 0.06281, "epss_percentile": 0.90638}, "CVE-2002-1912": {"epss_score": 0.01636, "epss_percentile": 0.81476}, "CVE-2002-1913": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2002-1914": {"epss_score": 0.00053, "epss_percentile": 0.16873}, "CVE-2002-1915": {"epss_score": 0.0023, "epss_percentile": 0.4572}, "CVE-2002-1916": {"epss_score": 0.01168, "epss_percentile": 0.78195}, "CVE-2002-1917": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2002-1918": {"epss_score": 0.32483, "epss_percentile": 0.96704}, "CVE-2002-1919": {"epss_score": 0.03427, "epss_percentile": 0.87116}, "CVE-2002-1920": {"epss_score": 0.00806, "epss_percentile": 0.73655}, "CVE-2002-1921": {"epss_score": 0.00712, "epss_percentile": 0.71755}, "CVE-2002-1922": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2002-1923": {"epss_score": 0.00712, "epss_percentile": 0.71755}, "CVE-2002-1924": {"epss_score": 0.00627, "epss_percentile": 0.69643}, "CVE-2002-1925": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1926": {"epss_score": 0.00492, "epss_percentile": 0.64981}, "CVE-2002-1927": {"epss_score": 0.0007, "epss_percentile": 0.21691}, "CVE-2002-1928": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2002-1929": {"epss_score": 0.0076, "epss_percentile": 0.72812}, "CVE-2002-1930": {"epss_score": 0.23452, "epss_percentile": 0.95778}, "CVE-2002-1931": {"epss_score": 0.00409, "epss_percentile": 0.607}, "CVE-2002-1932": {"epss_score": 0.2364, "epss_percentile": 0.95797}, "CVE-2002-1933": {"epss_score": 0.01763, "epss_percentile": 0.82157}, "CVE-2002-1934": {"epss_score": 0.00595, "epss_percentile": 0.68689}, "CVE-2002-1935": {"epss_score": 0.00627, "epss_percentile": 0.69643}, "CVE-2002-1936": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2002-1937": {"epss_score": 0.00473, "epss_percentile": 0.64084}, "CVE-2002-1938": {"epss_score": 0.02096, "epss_percentile": 0.83586}, "CVE-2002-1939": {"epss_score": 0.00079, "epss_percentile": 0.23863}, "CVE-2002-1940": {"epss_score": 0.00595, "epss_percentile": 0.68689}, "CVE-2002-1941": {"epss_score": 0.0071, "epss_percentile": 0.71727}, "CVE-2002-1942": {"epss_score": 0.01317, "epss_percentile": 0.79416}, "CVE-2002-1943": {"epss_score": 0.05212, "epss_percentile": 0.89617}, "CVE-2002-1944": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2002-1945": {"epss_score": 0.07593, "epss_percentile": 0.91559}, "CVE-2002-1946": {"epss_score": 0.00015, "epss_percentile": 0.02216}, "CVE-2002-1947": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2002-1948": {"epss_score": 0.00161, "epss_percentile": 0.37575}, "CVE-2002-1949": {"epss_score": 0.0033, "epss_percentile": 0.55433}, "CVE-2002-1950": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2002-1951": {"epss_score": 0.10934, "epss_percentile": 0.93163}, "CVE-2002-1952": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2002-1953": {"epss_score": 0.02661, "epss_percentile": 0.85367}, "CVE-2002-1954": {"epss_score": 0.02811, "epss_percentile": 0.85721}, "CVE-2002-1955": {"epss_score": 0.00906, "epss_percentile": 0.7525}, "CVE-2002-1956": {"epss_score": 0.00103, "epss_percentile": 0.28924}, "CVE-2002-1957": {"epss_score": 0.01688, "epss_percentile": 0.81762}, "CVE-2002-1958": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2002-1959": {"epss_score": 0.00994, "epss_percentile": 0.76423}, "CVE-2002-1960": {"epss_score": 0.00409, "epss_percentile": 0.607}, "CVE-2002-1961": {"epss_score": 0.00216, "epss_percentile": 0.44128}, "CVE-2002-1962": {"epss_score": 0.00182, "epss_percentile": 0.40266}, "CVE-2002-1963": {"epss_score": 0.0006, "epss_percentile": 0.19227}, "CVE-2002-1964": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2002-1965": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2002-1966": {"epss_score": 0.05307, "epss_percentile": 0.89714}, "CVE-2002-1967": {"epss_score": 0.02661, "epss_percentile": 0.85367}, "CVE-2002-1968": {"epss_score": 0.00067, "epss_percentile": 0.21078}, "CVE-2002-1969": {"epss_score": 0.00975, "epss_percentile": 0.76198}, "CVE-2002-1970": {"epss_score": 0.00053, "epss_percentile": 0.1686}, "CVE-2002-1971": {"epss_score": 0.01635, "epss_percentile": 0.81472}, "CVE-2002-1972": {"epss_score": 0.00063, "epss_percentile": 0.20075}, "CVE-2002-1973": {"epss_score": 0.60233, "epss_percentile": 0.98199}, "CVE-2002-1974": {"epss_score": 0.01826, "epss_percentile": 0.82434}, "CVE-2002-1975": {"epss_score": 0.00064, "epss_percentile": 0.20308}, "CVE-2002-1976": {"epss_score": 0.00134, "epss_percentile": 0.33926}, "CVE-2002-1977": {"epss_score": 0.00081, "epss_percentile": 0.24371}, "CVE-2002-1978": {"epss_score": 0.00864, "epss_percentile": 0.74604}, "CVE-2002-1979": {"epss_score": 0.00222, "epss_percentile": 0.4472}, "CVE-2002-1980": {"epss_score": 0.0006, "epss_percentile": 0.19092}, "CVE-2002-1981": {"epss_score": 0.22456, "epss_percentile": 0.95637}, "CVE-2002-1982": {"epss_score": 0.03672, "epss_percentile": 0.87541}, "CVE-2002-1983": {"epss_score": 0.00251, "epss_percentile": 0.48289}, "CVE-2002-1984": {"epss_score": 0.1195, "epss_percentile": 0.93524}, "CVE-2002-1985": {"epss_score": 0.01475, "epss_percentile": 0.80528}, "CVE-2002-1986": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2002-1987": {"epss_score": 0.00229, "epss_percentile": 0.45619}, "CVE-2002-1988": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-1989": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2002-1990": {"epss_score": 0.00346, "epss_percentile": 0.5662}, "CVE-2002-1991": {"epss_score": 0.04539, "epss_percentile": 0.88827}, "CVE-2002-1992": {"epss_score": 0.05666, "epss_percentile": 0.90102}, "CVE-2002-1993": {"epss_score": 0.06559, "epss_percentile": 0.90847}, "CVE-2002-1994": {"epss_score": 0.00715, "epss_percentile": 0.7185}, "CVE-2002-1995": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2002-1996": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2002-1997": {"epss_score": 0.00913, "epss_percentile": 0.75367}, "CVE-2002-1998": {"epss_score": 0.02523, "epss_percentile": 0.85008}, "CVE-2002-1999": {"epss_score": 0.00457, "epss_percentile": 0.63378}, "CVE-2002-20001": {"epss_score": 0.1468, "epss_percentile": 0.94262}, "CVE-2002-20002": {"epss_score": 0.00114, "epss_percentile": 0.30818}, "CVE-2002-2000": {"epss_score": 0.00147, "epss_percentile": 0.35661}, "CVE-2002-2001": {"epss_score": 0.00147, "epss_percentile": 0.35661}, "CVE-2002-2002": {"epss_score": 0.01496, "epss_percentile": 0.80681}, "CVE-2002-2003": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2002-2004": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2002-2005": {"epss_score": 0.00728, "epss_percentile": 0.72107}, "CVE-2002-2006": {"epss_score": 0.32359, "epss_percentile": 0.96692}, "CVE-2002-2007": {"epss_score": 0.22609, "epss_percentile": 0.95658}, "CVE-2002-2008": {"epss_score": 0.07149, "epss_percentile": 0.91285}, "CVE-2002-2009": {"epss_score": 0.03215, "epss_percentile": 0.86662}, "CVE-2002-2010": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2002-2011": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2002-2012": {"epss_score": 0.07999, "epss_percentile": 0.91815}, "CVE-2002-2013": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2002-2014": {"epss_score": 0.00461, "epss_percentile": 0.63559}, "CVE-2002-2015": {"epss_score": 0.02624, "epss_percentile": 0.85259}, "CVE-2002-2016": {"epss_score": 0.00117, "epss_percentile": 0.31327}, "CVE-2002-2017": {"epss_score": 0.00818, "epss_percentile": 0.7385}, "CVE-2002-2018": {"epss_score": 0.00049, "epss_percentile": 0.1545}, "CVE-2002-2019": {"epss_score": 0.01491, "epss_percentile": 0.80633}, "CVE-2002-2020": {"epss_score": 0.01222, "epss_percentile": 0.78657}, "CVE-2002-2021": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2002-2022": {"epss_score": 0.00214, "epss_percentile": 0.43978}, "CVE-2002-2023": {"epss_score": 0.00065, "epss_percentile": 0.2052}, "CVE-2002-2024": {"epss_score": 0.00385, "epss_percentile": 0.59204}, "CVE-2002-2025": {"epss_score": 0.01434, "epss_percentile": 0.80262}, "CVE-2002-2026": {"epss_score": 0.0501, "epss_percentile": 0.89389}, "CVE-2002-2027": {"epss_score": 0.00482, "epss_percentile": 0.64547}, "CVE-2002-2028": {"epss_score": 0.00788, "epss_percentile": 0.73345}, "CVE-2002-2029": {"epss_score": 0.48121, "epss_percentile": 0.97622}, "CVE-2002-2030": {"epss_score": 0.01896, "epss_percentile": 0.82752}, "CVE-2002-2031": {"epss_score": 0.28987, "epss_percentile": 0.96407}, "CVE-2002-2032": {"epss_score": 0.00032, "epss_percentile": 0.08762}, "CVE-2002-2033": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2002-2034": {"epss_score": 0.00722, "epss_percentile": 0.71993}, "CVE-2002-2035": {"epss_score": 0.011, "epss_percentile": 0.77564}, "CVE-2002-2036": {"epss_score": 0.01507, "epss_percentile": 0.80752}, "CVE-2002-2037": {"epss_score": 0.00343, "epss_percentile": 0.56467}, "CVE-2002-2038": {"epss_score": 0.00139, "epss_percentile": 0.3463}, "CVE-2002-2039": {"epss_score": 0.00378, "epss_percentile": 0.58827}, "CVE-2002-2040": {"epss_score": 0.00309, "epss_percentile": 0.53645}, "CVE-2002-2041": {"epss_score": 0.00466, "epss_percentile": 0.63801}, "CVE-2002-2042": {"epss_score": 0.00423, "epss_percentile": 0.61584}, "CVE-2002-2043": {"epss_score": 0.04097, "epss_percentile": 0.88254}, "CVE-2002-2044": {"epss_score": 0.00613, "epss_percentile": 0.69262}, "CVE-2002-2045": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2002-2046": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2002-2047": {"epss_score": 0.02191, "epss_percentile": 0.83935}, "CVE-2002-2048": {"epss_score": 0.03445, "epss_percentile": 0.87147}, "CVE-2002-2049": {"epss_score": 0.016, "epss_percentile": 0.81259}, "CVE-2002-2050": {"epss_score": 0.00153, "epss_percentile": 0.36585}, "CVE-2002-2051": {"epss_score": 0.00147, "epss_percentile": 0.35661}, "CVE-2002-2052": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2002-2053": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2002-2054": {"epss_score": 0.01048, "epss_percentile": 0.77048}, "CVE-2002-2055": {"epss_score": 0.00722, "epss_percentile": 0.71991}, "CVE-2002-2056": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2002-2057": {"epss_score": 0.00307, "epss_percentile": 0.5349}, "CVE-2002-2058": {"epss_score": 0.00249, "epss_percentile": 0.48016}, "CVE-2002-2059": {"epss_score": 0.001, "epss_percentile": 0.28516}, "CVE-2002-2060": {"epss_score": 0.05761, "epss_percentile": 0.90183}, "CVE-2002-2061": {"epss_score": 0.03376, "epss_percentile": 0.8702}, "CVE-2002-2062": {"epss_score": 0.07189, "epss_percentile": 0.91309}, "CVE-2002-2063": {"epss_score": 0.00226, "epss_percentile": 0.4528}, "CVE-2002-2064": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2002-2065": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2002-2066": {"epss_score": 0.00692, "epss_percentile": 0.71286}, "CVE-2002-2067": {"epss_score": 0.00692, "epss_percentile": 0.71286}, "CVE-2002-2068": {"epss_score": 0.00699, "epss_percentile": 0.71453}, "CVE-2002-2069": {"epss_score": 0.00699, "epss_percentile": 0.71453}, "CVE-2002-2070": {"epss_score": 0.00699, "epss_percentile": 0.71453}, "CVE-2002-2071": {"epss_score": 0.06281, "epss_percentile": 0.90638}, "CVE-2002-2072": {"epss_score": 0.06002, "epss_percentile": 0.90394}, "CVE-2002-2073": {"epss_score": 0.03168, "epss_percentile": 0.86543}, "CVE-2002-2074": {"epss_score": 0.01392, "epss_percentile": 0.7996}, "CVE-2002-2075": {"epss_score": 0.01168, "epss_percentile": 0.78195}, "CVE-2002-2076": {"epss_score": 0.00526, "epss_percentile": 0.66436}, "CVE-2002-2077": {"epss_score": 0.22828, "epss_percentile": 0.95696}, "CVE-2002-2078": {"epss_score": 0.02283, "epss_percentile": 0.84258}, "CVE-2002-2079": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2002-2080": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2002-2081": {"epss_score": 0.14972, "epss_percentile": 0.94336}, "CVE-2002-2082": {"epss_score": 0.01035, "epss_percentile": 0.76902}, "CVE-2002-2083": {"epss_score": 0.00031, "epss_percentile": 0.08379}, "CVE-2002-2084": {"epss_score": 0.03898, "epss_percentile": 0.87919}, "CVE-2002-2085": {"epss_score": 0.00219, "epss_percentile": 0.44474}, "CVE-2002-2086": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2002-2087": {"epss_score": 0.00757, "epss_percentile": 0.72751}, "CVE-2002-2088": {"epss_score": 0.02198, "epss_percentile": 0.83963}, "CVE-2002-2089": {"epss_score": 0.00096, "epss_percentile": 0.27277}, "CVE-2002-2090": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2002-2091": {"epss_score": 0.01922, "epss_percentile": 0.82903}, "CVE-2002-2092": {"epss_score": 0.00068, "epss_percentile": 0.21407}, "CVE-2002-2093": {"epss_score": 0.00078, "epss_percentile": 0.23578}, "CVE-2002-2094": {"epss_score": 0.00519, "epss_percentile": 0.66169}, "CVE-2002-2095": {"epss_score": 0.00354, "epss_percentile": 0.57214}, "CVE-2002-2096": {"epss_score": 0.09905, "epss_percentile": 0.92764}, "CVE-2002-2097": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-2098": {"epss_score": 0.0331, "epss_percentile": 0.86887}, "CVE-2002-2099": {"epss_score": 0.00064, "epss_percentile": 0.20381}, "CVE-2002-2100": {"epss_score": 0.08148, "epss_percentile": 0.91902}, "CVE-2002-2101": {"epss_score": 0.1917, "epss_percentile": 0.95142}, "CVE-2002-2102": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2002-2103": {"epss_score": 0.01719, "epss_percentile": 0.81924}, "CVE-2002-2104": {"epss_score": 0.01317, "epss_percentile": 0.79419}, "CVE-2002-2105": {"epss_score": 0.00631, "epss_percentile": 0.69731}, "CVE-2002-2106": {"epss_score": 0.03115, "epss_percentile": 0.86433}, "CVE-2002-2107": {"epss_score": 0.00483, "epss_percentile": 0.64559}, "CVE-2002-2108": {"epss_score": 0.00443, "epss_percentile": 0.62799}, "CVE-2002-2109": {"epss_score": 0.00521, "epss_percentile": 0.66247}, "CVE-2002-2110": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2002-2111": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2002-2112": {"epss_score": 0.0076, "epss_percentile": 0.72801}, "CVE-2002-2113": {"epss_score": 0.06666, "epss_percentile": 0.90928}, "CVE-2002-2114": {"epss_score": 0.01726, "epss_percentile": 0.81961}, "CVE-2002-2115": {"epss_score": 0.00409, "epss_percentile": 0.607}, "CVE-2002-2116": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2002-2117": {"epss_score": 0.21555, "epss_percentile": 0.95532}, "CVE-2002-2118": {"epss_score": 0.01746, "epss_percentile": 0.8207}, "CVE-2002-2119": {"epss_score": 0.01094, "epss_percentile": 0.77488}, "CVE-2002-2120": {"epss_score": 0.00297, "epss_percentile": 0.52679}, "CVE-2002-2121": {"epss_score": 0.00806, "epss_percentile": 0.73655}, "CVE-2002-2122": {"epss_score": 0.00144, "epss_percentile": 0.35337}, "CVE-2002-2123": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2002-2124": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2002-2125": {"epss_score": 0.02231, "epss_percentile": 0.84086}, "CVE-2002-2126": {"epss_score": 0.0007, "epss_percentile": 0.2183}, "CVE-2002-2127": {"epss_score": 0.00076, "epss_percentile": 0.23276}, "CVE-2002-2128": {"epss_score": 0.00059, "epss_percentile": 0.18666}, "CVE-2002-2129": {"epss_score": 0.00655, "epss_percentile": 0.70428}, "CVE-2002-2130": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2002-2131": {"epss_score": 0.00859, "epss_percentile": 0.74513}, "CVE-2002-2132": {"epss_score": 0.00783, "epss_percentile": 0.73226}, "CVE-2002-2133": {"epss_score": 0.00757, "epss_percentile": 0.72759}, "CVE-2002-2134": {"epss_score": 0.04002, "epss_percentile": 0.88094}, "CVE-2002-2137": {"epss_score": 0.0049, "epss_percentile": 0.64922}, "CVE-2002-2138": {"epss_score": 0.00826, "epss_percentile": 0.73972}, "CVE-2002-2139": {"epss_score": 0.0055, "epss_percentile": 0.67328}, "CVE-2002-2140": {"epss_score": 0.02506, "epss_percentile": 0.84937}, "CVE-2002-2141": {"epss_score": 0.0072, "epss_percentile": 0.71963}, "CVE-2002-2142": {"epss_score": 0.00512, "epss_percentile": 0.65856}, "CVE-2002-2143": {"epss_score": 0.05383, "epss_percentile": 0.89814}, "CVE-2002-2144": {"epss_score": 0.00212, "epss_percentile": 0.43755}, "CVE-2002-2145": {"epss_score": 0.03253, "epss_percentile": 0.86753}, "CVE-2002-2146": {"epss_score": 0.00759, "epss_percentile": 0.72785}, "CVE-2002-2148": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2002-2149": {"epss_score": 0.09861, "epss_percentile": 0.92741}, "CVE-2002-2150": {"epss_score": 0.01918, "epss_percentile": 0.82882}, "CVE-2002-2152": {"epss_score": 0.011, "epss_percentile": 0.77568}, "CVE-2002-2153": {"epss_score": 0.02545, "epss_percentile": 0.85061}, "CVE-2002-2154": {"epss_score": 0.04017, "epss_percentile": 0.88124}, "CVE-2002-2155": {"epss_score": 0.0097, "epss_percentile": 0.76108}, "CVE-2002-2156": {"epss_score": 0.01185, "epss_percentile": 0.7834}, "CVE-2002-2158": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2002-2159": {"epss_score": 0.00933, "epss_percentile": 0.75638}, "CVE-2002-2161": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2002-2162": {"epss_score": 0.00378, "epss_percentile": 0.58827}, "CVE-2002-2163": {"epss_score": 0.00237, "epss_percentile": 0.46651}, "CVE-2002-2164": {"epss_score": 0.35768, "epss_percentile": 0.96932}, "CVE-2002-2165": {"epss_score": 0.00378, "epss_percentile": 0.58827}, "CVE-2002-2166": {"epss_score": 0.00362, "epss_percentile": 0.57779}, "CVE-2002-2167": {"epss_score": 0.00859, "epss_percentile": 0.74513}, "CVE-2002-2168": {"epss_score": 0.01035, "epss_percentile": 0.76895}, "CVE-2002-2169": {"epss_score": 0.04431, "epss_percentile": 0.88679}, "CVE-2002-2170": {"epss_score": 0.11665, "epss_percentile": 0.93438}, "CVE-2002-2171": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2002-2172": {"epss_score": 0.00134, "epss_percentile": 0.33841}, "CVE-2002-2173": {"epss_score": 0.12176, "epss_percentile": 0.93593}, "CVE-2002-2174": {"epss_score": 0.04014, "epss_percentile": 0.8812}, "CVE-2002-2175": {"epss_score": 0.00618, "epss_percentile": 0.69381}, "CVE-2002-2176": {"epss_score": 0.00688, "epss_percentile": 0.71193}, "CVE-2002-2177": {"epss_score": 0.00455, "epss_percentile": 0.6331}, "CVE-2002-2178": {"epss_score": 0.00467, "epss_percentile": 0.63833}, "CVE-2002-2179": {"epss_score": 0.01033, "epss_percentile": 0.76878}, "CVE-2002-2180": {"epss_score": 0.00144, "epss_percentile": 0.35294}, "CVE-2002-2181": {"epss_score": 0.00341, "epss_percentile": 0.5633}, "CVE-2002-2182": {"epss_score": 0.0331, "epss_percentile": 0.86887}, "CVE-2002-2183": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2002-2184": {"epss_score": 0.00343, "epss_percentile": 0.56452}, "CVE-2002-2185": {"epss_score": 0.009, "epss_percentile": 0.75161}, "CVE-2002-2186": {"epss_score": 0.0085, "epss_percentile": 0.74382}, "CVE-2002-2187": {"epss_score": 0.0013, "epss_percentile": 0.33268}, "CVE-2002-2188": {"epss_score": 0.00158, "epss_percentile": 0.37176}, "CVE-2002-2189": {"epss_score": 0.1213, "epss_percentile": 0.93575}, "CVE-2002-2190": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2002-2191": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2002-2192": {"epss_score": 0.01003, "epss_percentile": 0.76515}, "CVE-2002-2193": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2002-2195": {"epss_score": 0.20622, "epss_percentile": 0.95386}, "CVE-2002-2196": {"epss_score": 0.11194, "epss_percentile": 0.93262}, "CVE-2002-2197": {"epss_score": 0.00052, "epss_percentile": 0.16481}, "CVE-2002-2198": {"epss_score": 0.09405, "epss_percentile": 0.92533}, "CVE-2002-2199": {"epss_score": 0.00099, "epss_percentile": 0.28377}, "CVE-2002-2200": {"epss_score": 0.03346, "epss_percentile": 0.86952}, "CVE-2002-2201": {"epss_score": 0.01912, "epss_percentile": 0.82833}, "CVE-2002-2202": {"epss_score": 0.00242, "epss_percentile": 0.4738}, "CVE-2002-2203": {"epss_score": 0.0007, "epss_percentile": 0.21778}, "CVE-2002-2204": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2002-2205": {"epss_score": 0.02117, "epss_percentile": 0.83666}, "CVE-2002-2206": {"epss_score": 0.0104, "epss_percentile": 0.76958}, "CVE-2002-2207": {"epss_score": 0.11325, "epss_percentile": 0.93309}, "CVE-2002-2208": {"epss_score": 0.06321, "epss_percentile": 0.9067}, "CVE-2002-2209": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2002-2210": {"epss_score": 0.00158, "epss_percentile": 0.37176}, "CVE-2002-2211": {"epss_score": 0.03336, "epss_percentile": 0.86935}, "CVE-2002-2212": {"epss_score": 0.06912, "epss_percentile": 0.91114}, "CVE-2002-2213": {"epss_score": 0.06912, "epss_percentile": 0.91114}, "CVE-2002-2214": {"epss_score": 0.00904, "epss_percentile": 0.75216}, "CVE-2002-2215": {"epss_score": 0.00425, "epss_percentile": 0.61728}, "CVE-2002-2216": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2002-2217": {"epss_score": 0.01748, "epss_percentile": 0.82082}, "CVE-2002-2218": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2002-2219": {"epss_score": 0.08811, "epss_percentile": 0.92266}, "CVE-2002-2220": {"epss_score": 0.00049, "epss_percentile": 0.15455}, "CVE-2002-2221": {"epss_score": 0.00058, "epss_percentile": 0.18514}, "CVE-2002-2222": {"epss_score": 0.00819, "epss_percentile": 0.73872}, "CVE-2002-2223": {"epss_score": 0.01935, "epss_percentile": 0.8296}, "CVE-2002-2224": {"epss_score": 0.02606, "epss_percentile": 0.85225}, "CVE-2002-2225": {"epss_score": 0.02527, "epss_percentile": 0.85016}, "CVE-2002-2226": {"epss_score": 0.78358, "epss_percentile": 0.98982}, "CVE-2002-2227": {"epss_score": 0.022, "epss_percentile": 0.83975}, "CVE-2002-2228": {"epss_score": 0.00195, "epss_percentile": 0.41646}, "CVE-2002-2229": {"epss_score": 0.00145, "epss_percentile": 0.35378}, "CVE-2002-2230": {"epss_score": 0.00246, "epss_percentile": 0.47789}, "CVE-2002-2231": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2002-2232": {"epss_score": 0.21596, "epss_percentile": 0.95537}, "CVE-2002-2233": {"epss_score": 0.00188, "epss_percentile": 0.40855}, "CVE-2002-2234": {"epss_score": 0.00639, "epss_percentile": 0.69931}, "CVE-2002-2235": {"epss_score": 0.00546, "epss_percentile": 0.67204}, "CVE-2002-2236": {"epss_score": 0.04059, "epss_percentile": 0.88188}, "CVE-2002-2237": {"epss_score": 0.01726, "epss_percentile": 0.81962}, "CVE-2002-2238": {"epss_score": 0.0012, "epss_percentile": 0.31785}, "CVE-2002-2239": {"epss_score": 0.00585, "epss_percentile": 0.68409}, "CVE-2002-2240": {"epss_score": 0.00184, "epss_percentile": 0.40375}, "CVE-2002-2241": {"epss_score": 0.00587, "epss_percentile": 0.68473}, "CVE-2002-2242": {"epss_score": 0.00233, "epss_percentile": 0.46043}, "CVE-2002-2243": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2002-2244": {"epss_score": 0.0005, "epss_percentile": 0.15855}, "CVE-2002-2245": {"epss_score": 0.00273, "epss_percentile": 0.50458}, "CVE-2002-2246": {"epss_score": 0.01823, "epss_percentile": 0.82421}, "CVE-2002-2247": {"epss_score": 0.02877, "epss_percentile": 0.85884}, "CVE-2002-2248": {"epss_score": 0.04871, "epss_percentile": 0.89232}, "CVE-2002-2249": {"epss_score": 0.01002, "epss_percentile": 0.76509}, "CVE-2002-2250": {"epss_score": 0.16473, "epss_percentile": 0.94674}, "CVE-2002-2251": {"epss_score": 0.06417, "epss_percentile": 0.90746}, "CVE-2002-2252": {"epss_score": 0.00394, "epss_percentile": 0.59752}, "CVE-2002-2253": {"epss_score": 0.14388, "epss_percentile": 0.942}, "CVE-2002-2254": {"epss_score": 0.0009, "epss_percentile": 0.26062}, "CVE-2002-2255": {"epss_score": 0.01757, "epss_percentile": 0.82134}, "CVE-2002-2256": {"epss_score": 0.00082, "epss_percentile": 0.24404}, "CVE-2002-2257": {"epss_score": 0.05376, "epss_percentile": 0.89799}, "CVE-2002-2258": {"epss_score": 0.03177, "epss_percentile": 0.86573}, "CVE-2002-2259": {"epss_score": 0.00058, "epss_percentile": 0.18285}, "CVE-2002-2260": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2002-2261": {"epss_score": 0.00598, "epss_percentile": 0.68775}, "CVE-2002-2262": {"epss_score": 0.01199, "epss_percentile": 0.7846}, "CVE-2002-2263": {"epss_score": 0.0008, "epss_percentile": 0.242}, "CVE-2002-2264": {"epss_score": 0.01294, "epss_percentile": 0.79242}, "CVE-2002-2265": {"epss_score": 0.00401, "epss_percentile": 0.602}, "CVE-2002-2266": {"epss_score": 0.00584, "epss_percentile": 0.68382}, "CVE-2002-2267": {"epss_score": 0.0005, "epss_percentile": 0.15761}, "CVE-2002-2268": {"epss_score": 0.73066, "epss_percentile": 0.98735}, "CVE-2002-2269": {"epss_score": 0.00088, "epss_percentile": 0.25737}, "CVE-2002-2270": {"epss_score": 0.00164, "epss_percentile": 0.37866}, "CVE-2002-2271": {"epss_score": 0.00574, "epss_percentile": 0.68082}, "CVE-2002-2272": {"epss_score": 0.23163, "epss_percentile": 0.95746}, "CVE-2002-2273": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2002-2274": {"epss_score": 0.00067, "epss_percentile": 0.21165}, "CVE-2002-2275": {"epss_score": 0.00065, "epss_percentile": 0.20481}, "CVE-2002-2276": {"epss_score": 0.00309, "epss_percentile": 0.53666}, "CVE-2002-2277": {"epss_score": 0.00387, "epss_percentile": 0.59315}, "CVE-2002-2278": {"epss_score": 0.00246, "epss_percentile": 0.47789}, "CVE-2002-2279": {"epss_score": 0.00706, "epss_percentile": 0.71639}, "CVE-2002-2280": {"epss_score": 0.00073, "epss_percentile": 0.22662}, "CVE-2002-2281": {"epss_score": 0.03803, "epss_percentile": 0.87747}, "CVE-2002-2282": {"epss_score": 0.0005, "epss_percentile": 0.15761}, "CVE-2002-2283": {"epss_score": 0.01919, "epss_percentile": 0.82885}, "CVE-2002-2284": {"epss_score": 0.00321, "epss_percentile": 0.54653}, "CVE-2002-2285": {"epss_score": 0.00228, "epss_percentile": 0.45484}, "CVE-2002-2286": {"epss_score": 0.00594, "epss_percentile": 0.68663}, "CVE-2002-2287": {"epss_score": 0.00371, "epss_percentile": 0.58372}, "CVE-2002-2288": {"epss_score": 0.02553, "epss_percentile": 0.85085}, "CVE-2002-2289": {"epss_score": 0.00518, "epss_percentile": 0.66106}, "CVE-2002-2290": {"epss_score": 0.00803, "epss_percentile": 0.73603}, "CVE-2002-2291": {"epss_score": 0.00803, "epss_percentile": 0.73607}, "CVE-2002-2292": {"epss_score": 0.00091, "epss_percentile": 0.2628}, "CVE-2002-2293": {"epss_score": 0.00061, "epss_percentile": 0.1934}, "CVE-2002-2294": {"epss_score": 0.01278, "epss_percentile": 0.79125}, "CVE-2002-2295": {"epss_score": 0.2179, "epss_percentile": 0.95561}, "CVE-2002-2296": {"epss_score": 0.00564, "epss_percentile": 0.67752}, "CVE-2002-2297": {"epss_score": 0.00574, "epss_percentile": 0.68091}, "CVE-2002-2298": {"epss_score": 0.01265, "epss_percentile": 0.79002}, "CVE-2002-2299": {"epss_score": 0.00574, "epss_percentile": 0.68091}, "CVE-2002-2300": {"epss_score": 0.28738, "epss_percentile": 0.96379}, "CVE-2002-2301": {"epss_score": 0.00065, "epss_percentile": 0.20604}, "CVE-2002-2302": {"epss_score": 0.00381, "epss_percentile": 0.59027}, "CVE-2002-2303": {"epss_score": 0.00218, "epss_percentile": 0.44432}, "CVE-2002-2304": {"epss_score": 0.0029, "epss_percentile": 0.52129}, "CVE-2002-2305": {"epss_score": 0.00343, "epss_percentile": 0.56442}, "CVE-2002-2306": {"epss_score": 0.03979, "epss_percentile": 0.88056}, "CVE-2002-2307": {"epss_score": 0.003, "epss_percentile": 0.52919}, "CVE-2002-2308": {"epss_score": 0.00477, "epss_percentile": 0.64303}, "CVE-2002-2309": {"epss_score": 0.04627, "epss_percentile": 0.88939}, "CVE-2002-2310": {"epss_score": 0.00419, "epss_percentile": 0.61362}, "CVE-2002-2311": {"epss_score": 0.23509, "epss_percentile": 0.95786}, "CVE-2002-2312": {"epss_score": 0.0253, "epss_percentile": 0.85023}, "CVE-2002-2313": {"epss_score": 0.00216, "epss_percentile": 0.44199}, "CVE-2002-2314": {"epss_score": 0.12455, "epss_percentile": 0.93678}, "CVE-2002-2315": {"epss_score": 0.09775, "epss_percentile": 0.92697}, "CVE-2002-2316": {"epss_score": 0.00549, "epss_percentile": 0.67314}, "CVE-2002-2317": {"epss_score": 0.01313, "epss_percentile": 0.79379}, "CVE-2002-2318": {"epss_score": 0.00564, "epss_percentile": 0.67752}, "CVE-2002-2319": {"epss_score": 0.04241, "epss_percentile": 0.88433}, "CVE-2002-2320": {"epss_score": 0.00285, "epss_percentile": 0.51684}, "CVE-2002-2321": {"epss_score": 0.00564, "epss_percentile": 0.67752}, "CVE-2002-2322": {"epss_score": 0.00478, "epss_percentile": 0.64393}, "CVE-2002-2323": {"epss_score": 0.00113, "epss_percentile": 0.30621}, "CVE-2002-2324": {"epss_score": 0.0069, "epss_percentile": 0.71248}, "CVE-2002-2325": {"epss_score": 0.03092, "epss_percentile": 0.86397}, "CVE-2002-2326": {"epss_score": 0.00495, "epss_percentile": 0.65125}, "CVE-2002-2327": {"epss_score": 0.00054, "epss_percentile": 0.17268}, "CVE-2002-2328": {"epss_score": 0.3766, "epss_percentile": 0.97063}, "CVE-2002-2329": {"epss_score": 0.01003, "epss_percentile": 0.76521}, "CVE-2002-2330": {"epss_score": 0.004, "epss_percentile": 0.60184}, "CVE-2002-2331": {"epss_score": 0.01732, "epss_percentile": 0.81996}, "CVE-2002-2332": {"epss_score": 0.01069, "epss_percentile": 0.77244}, "CVE-2002-2333": {"epss_score": 0.01372, "epss_percentile": 0.79815}, "CVE-2002-2334": {"epss_score": 0.00144, "epss_percentile": 0.35259}, "CVE-2002-2335": {"epss_score": 0.04786, "epss_percentile": 0.89143}, "CVE-2002-2336": {"epss_score": 0.06773, "epss_percentile": 0.91016}, "CVE-2002-2337": {"epss_score": 0.00594, "epss_percentile": 0.68663}, "CVE-2002-2338": {"epss_score": 0.07417, "epss_percentile": 0.91461}, "CVE-2002-2339": {"epss_score": 0.00564, "epss_percentile": 0.67752}, "CVE-2002-2340": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2002-2341": {"epss_score": 0.0043, "epss_percentile": 0.62003}, "CVE-2002-2342": {"epss_score": 0.00318, "epss_percentile": 0.54431}, "CVE-2002-2343": {"epss_score": 0.00564, "epss_percentile": 0.67752}, "CVE-2002-2344": {"epss_score": 0.00284, "epss_percentile": 0.51496}, "CVE-2002-2345": {"epss_score": 0.00697, "epss_percentile": 0.71409}, "CVE-2002-2346": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2002-2347": {"epss_score": 0.00369, "epss_percentile": 0.58259}, "CVE-2002-2348": {"epss_score": 0.00564, "epss_percentile": 0.67752}, "CVE-2002-2349": {"epss_score": 0.01086, "epss_percentile": 0.77422}, "CVE-2002-2350": {"epss_score": 0.00246, "epss_percentile": 0.47789}, "CVE-2002-2351": {"epss_score": 0.03262, "epss_percentile": 0.86774}, "CVE-2002-2352": {"epss_score": 0.00434, "epss_percentile": 0.62324}, "CVE-2002-2353": {"epss_score": 0.04544, "epss_percentile": 0.88831}, "CVE-2002-2354": {"epss_score": 0.00981, "epss_percentile": 0.76282}, "CVE-2002-2355": {"epss_score": 0.00379, "epss_percentile": 0.58882}, "CVE-2002-2356": {"epss_score": 0.003, "epss_percentile": 0.52919}, "CVE-2002-2357": {"epss_score": 0.03354, "epss_percentile": 0.86969}, "CVE-2002-2358": {"epss_score": 0.00593, "epss_percentile": 0.68648}, "CVE-2002-2359": {"epss_score": 0.0023, "epss_percentile": 0.45665}, "CVE-2002-2360": {"epss_score": 0.03413, "epss_percentile": 0.87089}, "CVE-2002-2361": {"epss_score": 0.00434, "epss_percentile": 0.62324}, "CVE-2002-2362": {"epss_score": 0.00564, "epss_percentile": 0.67752}, "CVE-2002-2363": {"epss_score": 0.00241, "epss_percentile": 0.47325}, "CVE-2002-2364": {"epss_score": 0.00355, "epss_percentile": 0.5726}, "CVE-2002-2365": {"epss_score": 0.01937, "epss_percentile": 0.82965}, "CVE-2002-2366": {"epss_score": 0.03389, "epss_percentile": 0.87047}, "CVE-2002-2367": {"epss_score": 0.06685, "epss_percentile": 0.90945}, "CVE-2002-2368": {"epss_score": 0.16728, "epss_percentile": 0.94723}, "CVE-2002-2369": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2002-2370": {"epss_score": 0.05295, "epss_percentile": 0.89702}, "CVE-2002-2371": {"epss_score": 0.00997, "epss_percentile": 0.76463}, "CVE-2002-2372": {"epss_score": 0.01222, "epss_percentile": 0.78656}, "CVE-2002-2373": {"epss_score": 0.00784, "epss_percentile": 0.73234}, "CVE-2002-2374": {"epss_score": 0.0015, "epss_percentile": 0.36124}, "CVE-2002-2375": {"epss_score": 0.00139, "epss_percentile": 0.34546}, "CVE-2002-2376": {"epss_score": 0.00574, "epss_percentile": 0.68076}, "CVE-2002-2377": {"epss_score": 0.00407, "epss_percentile": 0.60613}, "CVE-2002-2378": {"epss_score": 0.004, "epss_percentile": 0.60184}, "CVE-2002-2379": {"epss_score": 0.40936, "epss_percentile": 0.97245}, "CVE-2002-2380": {"epss_score": 0.19577, "epss_percentile": 0.95211}, "CVE-2002-2381": {"epss_score": 0.0445, "epss_percentile": 0.88704}, "CVE-2002-2382": {"epss_score": 0.00089, "epss_percentile": 0.25954}, "CVE-2002-2383": {"epss_score": 0.00343, "epss_percentile": 0.56442}, "CVE-2002-2384": {"epss_score": 0.00144, "epss_percentile": 0.35259}, "CVE-2002-2385": {"epss_score": 0.17642, "epss_percentile": 0.94883}, "CVE-2002-2386": {"epss_score": 0.00278, "epss_percentile": 0.50885}, "CVE-2002-2387": {"epss_score": 0.00091, "epss_percentile": 0.2628}, "CVE-2002-2388": {"epss_score": 0.0052, "epss_percentile": 0.66203}, "CVE-2002-2389": {"epss_score": 0.004, "epss_percentile": 0.60193}, "CVE-2002-2390": {"epss_score": 0.13293, "epss_percentile": 0.93925}, "CVE-2002-2391": {"epss_score": 0.00372, "epss_percentile": 0.58427}, "CVE-2002-2392": {"epss_score": 0.03775, "epss_percentile": 0.87709}, "CVE-2002-2393": {"epss_score": 0.07295, "epss_percentile": 0.91389}, "CVE-2002-2394": {"epss_score": 0.01635, "epss_percentile": 0.81471}, "CVE-2002-2395": {"epss_score": 0.01117, "epss_percentile": 0.77722}, "CVE-2002-2396": {"epss_score": 0.00058, "epss_percentile": 0.18285}, "CVE-2002-2397": {"epss_score": 0.0055, "epss_percentile": 0.67348}, "CVE-2002-2398": {"epss_score": 0.00434, "epss_percentile": 0.62324}, "CVE-2002-2399": {"epss_score": 0.03435, "epss_percentile": 0.87131}, "CVE-2002-2400": {"epss_score": 0.17325, "epss_percentile": 0.94823}, "CVE-2002-2401": {"epss_score": 0.00549, "epss_percentile": 0.67303}, "CVE-2002-2402": {"epss_score": 0.0098, "epss_percentile": 0.76272}, "CVE-2002-2403": {"epss_score": 0.06622, "epss_percentile": 0.90896}, "CVE-2002-2404": {"epss_score": 0.0788, "epss_percentile": 0.91739}, "CVE-2002-2405": {"epss_score": 0.00306, "epss_percentile": 0.53432}, "CVE-2002-2406": {"epss_score": 0.01587, "epss_percentile": 0.81183}, "CVE-2002-2407": {"epss_score": 0.00122, "epss_percentile": 0.3213}, "CVE-2002-2408": {"epss_score": 0.00172, "epss_percentile": 0.38998}, "CVE-2002-2409": {"epss_score": 0.00379, "epss_percentile": 0.58858}, "CVE-2002-2410": {"epss_score": 0.00419, "epss_percentile": 0.61362}, "CVE-2002-2411": {"epss_score": 0.05641, "epss_percentile": 0.90076}, "CVE-2002-2412": {"epss_score": 0.00133, "epss_percentile": 0.33644}, "CVE-2002-2413": {"epss_score": 0.004, "epss_percentile": 0.60184}, "CVE-2002-2414": {"epss_score": 0.00098, "epss_percentile": 0.27709}, "CVE-2002-2415": {"epss_score": 0.0085, "epss_percentile": 0.74389}, "CVE-2002-2416": {"epss_score": 0.04786, "epss_percentile": 0.89142}, "CVE-2002-2417": {"epss_score": 0.04385, "epss_percentile": 0.88631}, "CVE-2002-2418": {"epss_score": 0.00421, "epss_percentile": 0.61513}, "CVE-2002-2419": {"epss_score": 0.0086, "epss_percentile": 0.74538}, "CVE-2002-2420": {"epss_score": 0.0875, "epss_percentile": 0.9224}, "CVE-2002-2421": {"epss_score": 0.00503, "epss_percentile": 0.65458}, "CVE-2002-2422": {"epss_score": 0.00388, "epss_percentile": 0.5935}, "CVE-2002-2423": {"epss_score": 0.003, "epss_percentile": 0.52919}, "CVE-2002-2424": {"epss_score": 0.00564, "epss_percentile": 0.67752}, "CVE-2002-2425": {"epss_score": 0.03231, "epss_percentile": 0.86698}, "CVE-2002-2426": {"epss_score": 0.00312, "epss_percentile": 0.53937}, "CVE-2002-2427": {"epss_score": 0.00304, "epss_percentile": 0.53288}, "CVE-2002-2428": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2002-2429": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2002-2430": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2002-2431": {"epss_score": 0.00423, "epss_percentile": 0.61634}, "CVE-2002-2432": {"epss_score": 0.00704, "epss_percentile": 0.71557}, "CVE-2002-2433": {"epss_score": 0.00383, "epss_percentile": 0.59092}, "CVE-2002-2434": {"epss_score": 0.00428, "epss_percentile": 0.61939}, "CVE-2002-2435": {"epss_score": 0.22206, "epss_percentile": 0.9561}, "CVE-2002-2436": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2002-2437": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2002-2438": {"epss_score": 0.062, "epss_percentile": 0.90559}, "CVE-2002-2439": {"epss_score": 0.00137, "epss_percentile": 0.34273}, "CVE-2002-2443": {"epss_score": 0.15333, "epss_percentile": 0.94412}, "CVE-2002-2444": {"epss_score": 0.00476, "epss_percentile": 0.64264}, "CVE-2002-2445": {"epss_score": 0.00568, "epss_percentile": 0.67896}, "CVE-2002-2446": {"epss_score": 0.00624, "epss_percentile": 0.69573}, "CVE-2003-0001": {"epss_score": 0.03731, "epss_percentile": 0.87645}, "CVE-2003-0002": {"epss_score": 0.12986, "epss_percentile": 0.93836}, "CVE-2003-0003": {"epss_score": 0.23993, "epss_percentile": 0.95841}, "CVE-2003-0004": {"epss_score": 0.0309, "epss_percentile": 0.86393}, "CVE-2003-0007": {"epss_score": 0.04999, "epss_percentile": 0.89376}, "CVE-2003-0009": {"epss_score": 0.16174, "epss_percentile": 0.94588}, "CVE-2003-0010": {"epss_score": 0.20207, "epss_percentile": 0.95304}, "CVE-2003-0011": {"epss_score": 0.18319, "epss_percentile": 0.94994}, "CVE-2003-0012": {"epss_score": 0.00059, "epss_percentile": 0.18656}, "CVE-2003-0013": {"epss_score": 0.01108, "epss_percentile": 0.77636}, "CVE-2003-0014": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2003-0015": {"epss_score": 0.37748, "epss_percentile": 0.97067}, "CVE-2003-0016": {"epss_score": 0.45031, "epss_percentile": 0.97467}, "CVE-2003-0017": {"epss_score": 0.03262, "epss_percentile": 0.86773}, "CVE-2003-0018": {"epss_score": 0.00069, "epss_percentile": 0.21477}, "CVE-2003-0019": {"epss_score": 0.00665, "epss_percentile": 0.70666}, "CVE-2003-0020": {"epss_score": 0.20267, "epss_percentile": 0.95311}, "CVE-2003-0021": {"epss_score": 0.00615, "epss_percentile": 0.69293}, "CVE-2003-0022": {"epss_score": 0.00759, "epss_percentile": 0.72783}, "CVE-2003-0023": {"epss_score": 0.00541, "epss_percentile": 0.67046}, "CVE-2003-0024": {"epss_score": 0.0067, "epss_percentile": 0.70775}, "CVE-2003-0025": {"epss_score": 0.018, "epss_percentile": 0.82317}, "CVE-2003-0026": {"epss_score": 0.12417, "epss_percentile": 0.93663}, "CVE-2003-0027": {"epss_score": 0.65152, "epss_percentile": 0.98405}, "CVE-2003-0028": {"epss_score": 0.56051, "epss_percentile": 0.98006}, "CVE-2003-0030": {"epss_score": 0.04936, "epss_percentile": 0.89302}, "CVE-2003-0031": {"epss_score": 0.00791, "epss_percentile": 0.73381}, "CVE-2003-0032": {"epss_score": 0.00787, "epss_percentile": 0.73319}, "CVE-2003-0033": {"epss_score": 0.51588, "epss_percentile": 0.97788}, "CVE-2003-0034": {"epss_score": 0.00149, "epss_percentile": 0.35936}, "CVE-2003-0035": {"epss_score": 0.00117, "epss_percentile": 0.3133}, "CVE-2003-0036": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2003-0037": {"epss_score": 0.02088, "epss_percentile": 0.83555}, "CVE-2003-0038": {"epss_score": 0.10629, "epss_percentile": 0.93054}, "CVE-2003-0039": {"epss_score": 0.03937, "epss_percentile": 0.87986}, "CVE-2003-0040": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2003-0041": {"epss_score": 0.01228, "epss_percentile": 0.78709}, "CVE-2003-0042": {"epss_score": 0.55831, "epss_percentile": 0.97999}, "CVE-2003-0043": {"epss_score": 0.02261, "epss_percentile": 0.84188}, "CVE-2003-0044": {"epss_score": 0.27285, "epss_percentile": 0.96231}, "CVE-2003-0045": {"epss_score": 0.01508, "epss_percentile": 0.80758}, "CVE-2003-0046": {"epss_score": 0.0009, "epss_percentile": 0.26091}, "CVE-2003-0047": {"epss_score": 0.00081, "epss_percentile": 0.24243}, "CVE-2003-0048": {"epss_score": 0.00077, "epss_percentile": 0.23297}, "CVE-2003-0049": {"epss_score": 0.0054, "epss_percentile": 0.67011}, "CVE-2003-0050": {"epss_score": 0.87791, "epss_percentile": 0.99444}, "CVE-2003-0051": {"epss_score": 0.00492, "epss_percentile": 0.64987}, "CVE-2003-0052": {"epss_score": 0.0076, "epss_percentile": 0.72801}, "CVE-2003-0053": {"epss_score": 0.00477, "epss_percentile": 0.64338}, "CVE-2003-0054": {"epss_score": 0.00786, "epss_percentile": 0.73298}, "CVE-2003-0055": {"epss_score": 0.02479, "epss_percentile": 0.8487}, "CVE-2003-0056": {"epss_score": 0.00211, "epss_percentile": 0.43632}, "CVE-2003-0057": {"epss_score": 0.04362, "epss_percentile": 0.88597}, "CVE-2003-0058": {"epss_score": 0.19337, "epss_percentile": 0.95165}, "CVE-2003-0059": {"epss_score": 0.03221, "epss_percentile": 0.86674}, "CVE-2003-0060": {"epss_score": 0.09128, "epss_percentile": 0.92414}, "CVE-2003-0061": {"epss_score": 0.00071, "epss_percentile": 0.22231}, "CVE-2003-0062": {"epss_score": 0.00201, "epss_percentile": 0.42348}, "CVE-2003-0063": {"epss_score": 0.01309, "epss_percentile": 0.79353}, "CVE-2003-0064": {"epss_score": 0.00871, "epss_percentile": 0.74719}, "CVE-2003-0065": {"epss_score": 0.0067, "epss_percentile": 0.70775}, "CVE-2003-0066": {"epss_score": 0.00706, "epss_percentile": 0.71615}, "CVE-2003-0067": {"epss_score": 0.00722, "epss_percentile": 0.71996}, "CVE-2003-0068": {"epss_score": 0.00667, "epss_percentile": 0.7072}, "CVE-2003-0069": {"epss_score": 0.00347, "epss_percentile": 0.56779}, "CVE-2003-0070": {"epss_score": 0.00635, "epss_percentile": 0.69821}, "CVE-2003-0071": {"epss_score": 0.00082, "epss_percentile": 0.24405}, "CVE-2003-0072": {"epss_score": 0.01252, "epss_percentile": 0.78903}, "CVE-2003-0073": {"epss_score": 0.01297, "epss_percentile": 0.79265}, "CVE-2003-0074": {"epss_score": 0.0432, "epss_percentile": 0.88542}, "CVE-2003-0075": {"epss_score": 0.03904, "epss_percentile": 0.87924}, "CVE-2003-0076": {"epss_score": 0.01292, "epss_percentile": 0.79234}, "CVE-2003-0077": {"epss_score": 0.00667, "epss_percentile": 0.7072}, "CVE-2003-0078": {"epss_score": 0.11643, "epss_percentile": 0.93426}, "CVE-2003-0079": {"epss_score": 0.00075, "epss_percentile": 0.22883}, "CVE-2003-0080": {"epss_score": 0.00438, "epss_percentile": 0.62565}, "CVE-2003-0081": {"epss_score": 0.047, "epss_percentile": 0.89023}, "CVE-2003-0082": {"epss_score": 0.02545, "epss_percentile": 0.85061}, "CVE-2003-0083": {"epss_score": 0.11117, "epss_percentile": 0.93227}, "CVE-2003-0084": {"epss_score": 0.00572, "epss_percentile": 0.68019}, "CVE-2003-0085": {"epss_score": 0.86073, "epss_percentile": 0.99365}, "CVE-2003-0086": {"epss_score": 0.0027, "epss_percentile": 0.50262}, "CVE-2003-0087": {"epss_score": 0.004, "epss_percentile": 0.60162}, "CVE-2003-0088": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2003-0089": {"epss_score": 0.0028, "epss_percentile": 0.51093}, "CVE-2003-0091": {"epss_score": 0.00077, "epss_percentile": 0.23403}, "CVE-2003-0092": {"epss_score": 0.0005, "epss_percentile": 0.15721}, "CVE-2003-0093": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2003-0094": {"epss_score": 0.00433, "epss_percentile": 0.62227}, "CVE-2003-0095": {"epss_score": 0.54405, "epss_percentile": 0.97924}, "CVE-2003-0096": {"epss_score": 0.46317, "epss_percentile": 0.97541}, "CVE-2003-0097": {"epss_score": 0.00474, "epss_percentile": 0.64147}, "CVE-2003-0098": {"epss_score": 0.06825, "epss_percentile": 0.9105}, "CVE-2003-0099": {"epss_score": 0.00122, "epss_percentile": 0.32095}, "CVE-2003-0100": {"epss_score": 0.04067, "epss_percentile": 0.88202}, "CVE-2003-0101": {"epss_score": 0.15499, "epss_percentile": 0.94439}, "CVE-2003-0102": {"epss_score": 0.08278, "epss_percentile": 0.91966}, "CVE-2003-0103": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0104": {"epss_score": 0.01388, "epss_percentile": 0.79921}, "CVE-2003-0105": {"epss_score": 0.00635, "epss_percentile": 0.69813}, "CVE-2003-0106": {"epss_score": 0.00749, "epss_percentile": 0.72607}, "CVE-2003-0107": {"epss_score": 0.23306, "epss_percentile": 0.95763}, "CVE-2003-0108": {"epss_score": 0.17043, "epss_percentile": 0.94764}, "CVE-2003-0109": {"epss_score": 0.87041, "epss_percentile": 0.9941}, "CVE-2003-0110": {"epss_score": 0.19456, "epss_percentile": 0.95185}, "CVE-2003-0111": {"epss_score": 0.35746, "epss_percentile": 0.9693}, "CVE-2003-0112": {"epss_score": 0.02569, "epss_percentile": 0.85125}, "CVE-2003-0113": {"epss_score": 0.43166, "epss_percentile": 0.97374}, "CVE-2003-0114": {"epss_score": 0.30354, "epss_percentile": 0.96534}, "CVE-2003-0115": {"epss_score": 0.14296, "epss_percentile": 0.9418}, "CVE-2003-0116": {"epss_score": 0.25468, "epss_percentile": 0.9603}, "CVE-2003-0117": {"epss_score": 0.20152, "epss_percentile": 0.95295}, "CVE-2003-0118": {"epss_score": 0.04085, "epss_percentile": 0.88225}, "CVE-2003-0119": {"epss_score": 0.02634, "epss_percentile": 0.85289}, "CVE-2003-0120": {"epss_score": 0.00182, "epss_percentile": 0.40233}, "CVE-2003-0121": {"epss_score": 0.04408, "epss_percentile": 0.88654}, "CVE-2003-0122": {"epss_score": 0.22971, "epss_percentile": 0.95711}, "CVE-2003-0123": {"epss_score": 0.04143, "epss_percentile": 0.88311}, "CVE-2003-0124": {"epss_score": 0.01887, "epss_percentile": 0.82714}, "CVE-2003-0125": {"epss_score": 0.10052, "epss_percentile": 0.9283}, "CVE-2003-0126": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-2003-0127": {"epss_score": 0.00951, "epss_percentile": 0.75866}, "CVE-2003-0128": {"epss_score": 0.24361, "epss_percentile": 0.9591}, "CVE-2003-0129": {"epss_score": 0.1935, "epss_percentile": 0.95167}, "CVE-2003-0130": {"epss_score": 0.14825, "epss_percentile": 0.94295}, "CVE-2003-0131": {"epss_score": 0.16267, "epss_percentile": 0.94606}, "CVE-2003-0132": {"epss_score": 0.82248, "epss_percentile": 0.99183}, "CVE-2003-0133": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2003-0134": {"epss_score": 0.04906, "epss_percentile": 0.89277}, "CVE-2003-0135": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2003-0136": {"epss_score": 0.00092, "epss_percentile": 0.26522}, "CVE-2003-0137": {"epss_score": 0.00587, "epss_percentile": 0.68462}, "CVE-2003-0138": {"epss_score": 0.05644, "epss_percentile": 0.90079}, "CVE-2003-0139": {"epss_score": 0.04948, "epss_percentile": 0.89321}, "CVE-2003-0140": {"epss_score": 0.02182, "epss_percentile": 0.83909}, "CVE-2003-0141": {"epss_score": 0.00511, "epss_percentile": 0.65824}, "CVE-2003-0142": {"epss_score": 0.04598, "epss_percentile": 0.88901}, "CVE-2003-0143": {"epss_score": 0.08518, "epss_percentile": 0.92098}, "CVE-2003-0144": {"epss_score": 0.0025, "epss_percentile": 0.48109}, "CVE-2003-0145": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2003-0146": {"epss_score": 0.03882, "epss_percentile": 0.87897}, "CVE-2003-0147": {"epss_score": 0.20202, "epss_percentile": 0.95303}, "CVE-2003-0148": {"epss_score": 0.0007, "epss_percentile": 0.21761}, "CVE-2003-0149": {"epss_score": 0.01411, "epss_percentile": 0.80087}, "CVE-2003-0150": {"epss_score": 0.12813, "epss_percentile": 0.93782}, "CVE-2003-0151": {"epss_score": 0.0473, "epss_percentile": 0.89069}, "CVE-2003-0152": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2003-0153": {"epss_score": 0.0471, "epss_percentile": 0.89037}, "CVE-2003-0154": {"epss_score": 0.13333, "epss_percentile": 0.93935}, "CVE-2003-0155": {"epss_score": 0.0058, "epss_percentile": 0.68248}, "CVE-2003-0156": {"epss_score": 0.00412, "epss_percentile": 0.60933}, "CVE-2003-0159": {"epss_score": 0.02414, "epss_percentile": 0.84679}, "CVE-2003-0160": {"epss_score": 0.00537, "epss_percentile": 0.66921}, "CVE-2003-0161": {"epss_score": 0.67899, "epss_percentile": 0.98524}, "CVE-2003-0162": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2003-0163": {"epss_score": 0.00398, "epss_percentile": 0.6009}, "CVE-2003-0165": {"epss_score": 0.00749, "epss_percentile": 0.72597}, "CVE-2003-0166": {"epss_score": 0.26615, "epss_percentile": 0.96162}, "CVE-2003-0167": {"epss_score": 0.00931, "epss_percentile": 0.75607}, "CVE-2003-0168": {"epss_score": 0.32791, "epss_percentile": 0.96725}, "CVE-2003-0169": {"epss_score": 0.14559, "epss_percentile": 0.94241}, "CVE-2003-0170": {"epss_score": 0.01176, "epss_percentile": 0.78273}, "CVE-2003-0171": {"epss_score": 0.00132, "epss_percentile": 0.3354}, "CVE-2003-0172": {"epss_score": 0.22394, "epss_percentile": 0.95631}, "CVE-2003-0173": {"epss_score": 0.00085, "epss_percentile": 0.25111}, "CVE-2003-0174": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2003-0175": {"epss_score": 0.00285, "epss_percentile": 0.51514}, "CVE-2003-0176": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0177": {"epss_score": 0.00069, "epss_percentile": 0.21466}, "CVE-2003-0178": {"epss_score": 0.58514, "epss_percentile": 0.98121}, "CVE-2003-0179": {"epss_score": 0.43093, "epss_percentile": 0.97369}, "CVE-2003-0180": {"epss_score": 0.14415, "epss_percentile": 0.94207}, "CVE-2003-0181": {"epss_score": 0.02839, "epss_percentile": 0.85796}, "CVE-2003-0187": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0188": {"epss_score": 0.00042, "epss_percentile": 0.12594}, "CVE-2003-0189": {"epss_score": 0.16257, "epss_percentile": 0.94604}, "CVE-2003-0190": {"epss_score": 0.1523, "epss_percentile": 0.94389}, "CVE-2003-0192": {"epss_score": 0.11824, "epss_percentile": 0.93487}, "CVE-2003-0193": {"epss_score": 0.00098, "epss_percentile": 0.27781}, "CVE-2003-0194": {"epss_score": 0.00085, "epss_percentile": 0.25228}, "CVE-2003-0195": {"epss_score": 0.16373, "epss_percentile": 0.94638}, "CVE-2003-0196": {"epss_score": 0.06782, "epss_percentile": 0.91024}, "CVE-2003-0197": {"epss_score": 0.00053, "epss_percentile": 0.16821}, "CVE-2003-0198": {"epss_score": 0.00448, "epss_percentile": 0.63018}, "CVE-2003-0201": {"epss_score": 0.83963, "epss_percentile": 0.99267}, "CVE-2003-0202": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2003-0203": {"epss_score": 0.11206, "epss_percentile": 0.93265}, "CVE-2003-0204": {"epss_score": 0.01504, "epss_percentile": 0.80738}, "CVE-2003-0205": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2003-0206": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0207": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2003-0208": {"epss_score": 0.00273, "epss_percentile": 0.50421}, "CVE-2003-0209": {"epss_score": 0.57434, "epss_percentile": 0.98062}, "CVE-2003-0210": {"epss_score": 0.02296, "epss_percentile": 0.84296}, "CVE-2003-0211": {"epss_score": 0.0929, "epss_percentile": 0.92486}, "CVE-2003-0212": {"epss_score": 0.01965, "epss_percentile": 0.83078}, "CVE-2003-0213": {"epss_score": 0.76062, "epss_percentile": 0.98875}, "CVE-2003-0214": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2003-0215": {"epss_score": 0.00918, "epss_percentile": 0.75441}, "CVE-2003-0216": {"epss_score": 0.00432, "epss_percentile": 0.62126}, "CVE-2003-0217": {"epss_score": 0.00323, "epss_percentile": 0.549}, "CVE-2003-0218": {"epss_score": 0.06683, "epss_percentile": 0.9094}, "CVE-2003-0219": {"epss_score": 0.01778, "epss_percentile": 0.82228}, "CVE-2003-0220": {"epss_score": 0.85491, "epss_percentile": 0.99335}, "CVE-2003-0221": {"epss_score": 0.00064, "epss_percentile": 0.20399}, "CVE-2003-0222": {"epss_score": 0.1251, "epss_percentile": 0.93702}, "CVE-2003-0223": {"epss_score": 0.08342, "epss_percentile": 0.92}, "CVE-2003-0224": {"epss_score": 0.13411, "epss_percentile": 0.93955}, "CVE-2003-0225": {"epss_score": 0.48639, "epss_percentile": 0.97646}, "CVE-2003-0226": {"epss_score": 0.62603, "epss_percentile": 0.98298}, "CVE-2003-0227": {"epss_score": 0.63377, "epss_percentile": 0.98331}, "CVE-2003-0228": {"epss_score": 0.75024, "epss_percentile": 0.98828}, "CVE-2003-0230": {"epss_score": 0.01396, "epss_percentile": 0.79981}, "CVE-2003-0231": {"epss_score": 0.29011, "epss_percentile": 0.9641}, "CVE-2003-0232": {"epss_score": 0.05983, "epss_percentile": 0.90381}, "CVE-2003-0233": {"epss_score": 0.13253, "epss_percentile": 0.93915}, "CVE-2003-0235": {"epss_score": 0.00905, "epss_percentile": 0.75235}, "CVE-2003-0236": {"epss_score": 0.04918, "epss_percentile": 0.89289}, "CVE-2003-0237": {"epss_score": 0.01427, "epss_percentile": 0.8021}, "CVE-2003-0238": {"epss_score": 0.01118, "epss_percentile": 0.77746}, "CVE-2003-0239": {"epss_score": 0.01282, "epss_percentile": 0.7915}, "CVE-2003-0240": {"epss_score": 0.09434, "epss_percentile": 0.92545}, "CVE-2003-0241": {"epss_score": 0.02719, "epss_percentile": 0.85515}, "CVE-2003-0242": {"epss_score": 0.01404, "epss_percentile": 0.80035}, "CVE-2003-0243": {"epss_score": 0.04213, "epss_percentile": 0.88403}, "CVE-2003-0244": {"epss_score": 0.06885, "epss_percentile": 0.91092}, "CVE-2003-0245": {"epss_score": 0.85319, "epss_percentile": 0.99328}, "CVE-2003-0246": {"epss_score": 0.00122, "epss_percentile": 0.32132}, "CVE-2003-0247": {"epss_score": 0.02282, "epss_percentile": 0.84253}, "CVE-2003-0248": {"epss_score": 0.01435, "epss_percentile": 0.80272}, "CVE-2003-0249": {"epss_score": 0.00633, "epss_percentile": 0.69774}, "CVE-2003-0251": {"epss_score": 0.02512, "epss_percentile": 0.84957}, "CVE-2003-0252": {"epss_score": 0.16108, "epss_percentile": 0.94574}, "CVE-2003-0253": {"epss_score": 0.0733, "epss_percentile": 0.91414}, "CVE-2003-0254": {"epss_score": 0.0733, "epss_percentile": 0.91414}, "CVE-2003-0255": {"epss_score": 0.05433, "epss_percentile": 0.89878}, "CVE-2003-0256": {"epss_score": 0.00982, "epss_percentile": 0.76295}, "CVE-2003-0257": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2003-0258": {"epss_score": 0.00649, "epss_percentile": 0.70224}, "CVE-2003-0259": {"epss_score": 0.00661, "epss_percentile": 0.70576}, "CVE-2003-0260": {"epss_score": 0.00661, "epss_percentile": 0.70576}, "CVE-2003-0261": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2003-0262": {"epss_score": 0.00475, "epss_percentile": 0.64243}, "CVE-2003-0263": {"epss_score": 0.20075, "epss_percentile": 0.95285}, "CVE-2003-0264": {"epss_score": 0.6681, "epss_percentile": 0.9848}, "CVE-2003-0265": {"epss_score": 0.00195, "epss_percentile": 0.41627}, "CVE-2003-0266": {"epss_score": 0.0161, "epss_percentile": 0.81323}, "CVE-2003-0267": {"epss_score": 0.00872, "epss_percentile": 0.7473}, "CVE-2003-0268": {"epss_score": 0.00496, "epss_percentile": 0.65138}, "CVE-2003-0269": {"epss_score": 0.00448, "epss_percentile": 0.63009}, "CVE-2003-0270": {"epss_score": 0.22098, "epss_percentile": 0.95595}, "CVE-2003-0271": {"epss_score": 0.04755, "epss_percentile": 0.89112}, "CVE-2003-0272": {"epss_score": 0.00952, "epss_percentile": 0.75875}, "CVE-2003-0273": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2003-0274": {"epss_score": 0.09463, "epss_percentile": 0.92559}, "CVE-2003-0275": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2003-0276": {"epss_score": 0.1612, "epss_percentile": 0.94575}, "CVE-2003-0277": {"epss_score": 0.03779, "epss_percentile": 0.87717}, "CVE-2003-0278": {"epss_score": 0.00571, "epss_percentile": 0.67991}, "CVE-2003-0279": {"epss_score": 0.0002, "epss_percentile": 0.04617}, "CVE-2003-0280": {"epss_score": 0.11155, "epss_percentile": 0.93247}, "CVE-2003-0281": {"epss_score": 0.00121, "epss_percentile": 0.31925}, "CVE-2003-0282": {"epss_score": 0.21129, "epss_percentile": 0.95466}, "CVE-2003-0283": {"epss_score": 0.00722, "epss_percentile": 0.71991}, "CVE-2003-0284": {"epss_score": 0.01224, "epss_percentile": 0.78679}, "CVE-2003-0285": {"epss_score": 0.01177, "epss_percentile": 0.78277}, "CVE-2003-0286": {"epss_score": 0.01011, "epss_percentile": 0.76608}, "CVE-2003-0287": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2003-0288": {"epss_score": 0.05634, "epss_percentile": 0.90071}, "CVE-2003-0289": {"epss_score": 0.0013, "epss_percentile": 0.33231}, "CVE-2003-0290": {"epss_score": 0.13342, "epss_percentile": 0.93937}, "CVE-2003-0291": {"epss_score": 0.00692, "epss_percentile": 0.71296}, "CVE-2003-0292": {"epss_score": 0.00641, "epss_percentile": 0.6999}, "CVE-2003-0293": {"epss_score": 0.04014, "epss_percentile": 0.8812}, "CVE-2003-0294": {"epss_score": 0.00497, "epss_percentile": 0.6519}, "CVE-2003-0295": {"epss_score": 0.00422, "epss_percentile": 0.61578}, "CVE-2003-0296": {"epss_score": 0.00954, "epss_percentile": 0.75906}, "CVE-2003-0297": {"epss_score": 0.00911, "epss_percentile": 0.75323}, "CVE-2003-0298": {"epss_score": 0.00954, "epss_percentile": 0.75906}, "CVE-2003-0299": {"epss_score": 0.00893, "epss_percentile": 0.75076}, "CVE-2003-0300": {"epss_score": 0.00845, "epss_percentile": 0.74285}, "CVE-2003-0301": {"epss_score": 0.04278, "epss_percentile": 0.88486}, "CVE-2003-0302": {"epss_score": 0.0086, "epss_percentile": 0.74538}, "CVE-2003-0303": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2003-0304": {"epss_score": 0.02856, "epss_percentile": 0.85841}, "CVE-2003-0305": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0306": {"epss_score": 0.01984, "epss_percentile": 0.83153}, "CVE-2003-0307": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2003-0308": {"epss_score": 0.00061, "epss_percentile": 0.19306}, "CVE-2003-0309": {"epss_score": 0.19156, "epss_percentile": 0.9514}, "CVE-2003-0310": {"epss_score": 0.00367, "epss_percentile": 0.58114}, "CVE-2003-0312": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-2003-0313": {"epss_score": 0.00618, "epss_percentile": 0.69371}, "CVE-2003-0314": {"epss_score": 0.04014, "epss_percentile": 0.8812}, "CVE-2003-0315": {"epss_score": 0.0486, "epss_percentile": 0.89221}, "CVE-2003-0316": {"epss_score": 0.00487, "epss_percentile": 0.64818}, "CVE-2003-0317": {"epss_score": 0.03498, "epss_percentile": 0.8724}, "CVE-2003-0318": {"epss_score": 0.00016, "epss_percentile": 0.03022}, "CVE-2003-0319": {"epss_score": 0.04561, "epss_percentile": 0.88853}, "CVE-2003-0320": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2003-0321": {"epss_score": 0.01222, "epss_percentile": 0.78654}, "CVE-2003-0322": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2003-0323": {"epss_score": 0.0101, "epss_percentile": 0.76601}, "CVE-2003-0324": {"epss_score": 0.00931, "epss_percentile": 0.75607}, "CVE-2003-0325": {"epss_score": 0.00439, "epss_percentile": 0.62583}, "CVE-2003-0326": {"epss_score": 0.00096, "epss_percentile": 0.27416}, "CVE-2003-0327": {"epss_score": 0.00806, "epss_percentile": 0.73655}, "CVE-2003-0328": {"epss_score": 0.05889, "epss_percentile": 0.90298}, "CVE-2003-0329": {"epss_score": 0.00145, "epss_percentile": 0.35379}, "CVE-2003-0330": {"epss_score": 0.00091, "epss_percentile": 0.2623}, "CVE-2003-0331": {"epss_score": 0.00638, "epss_percentile": 0.69905}, "CVE-2003-0332": {"epss_score": 0.01983, "epss_percentile": 0.83143}, "CVE-2003-0333": {"epss_score": 0.00205, "epss_percentile": 0.42726}, "CVE-2003-0334": {"epss_score": 0.00083, "epss_percentile": 0.24628}, "CVE-2003-0335": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-2003-0336": {"epss_score": 0.03186, "epss_percentile": 0.8659}, "CVE-2003-0337": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-2003-0338": {"epss_score": 0.03054, "epss_percentile": 0.86297}, "CVE-2003-0339": {"epss_score": 0.04952, "epss_percentile": 0.89324}, "CVE-2003-0340": {"epss_score": 0.00471, "epss_percentile": 0.64006}, "CVE-2003-0341": {"epss_score": 0.00734, "epss_percentile": 0.72249}, "CVE-2003-0342": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-2003-0343": {"epss_score": 0.00151, "epss_percentile": 0.36361}, "CVE-2003-0344": {"epss_score": 0.86491, "epss_percentile": 0.99384}, "CVE-2003-0345": {"epss_score": 0.55323, "epss_percentile": 0.97972}, "CVE-2003-0346": {"epss_score": 0.25679, "epss_percentile": 0.96055}, "CVE-2003-0347": {"epss_score": 0.70456, "epss_percentile": 0.98633}, "CVE-2003-0348": {"epss_score": 0.27593, "epss_percentile": 0.9626}, "CVE-2003-0349": {"epss_score": 0.88214, "epss_percentile": 0.99461}, "CVE-2003-0350": {"epss_score": 0.00491, "epss_percentile": 0.6498}, "CVE-2003-0352": {"epss_score": 0.90567, "epss_percentile": 0.99589}, "CVE-2003-0353": {"epss_score": 0.18264, "epss_percentile": 0.94984}, "CVE-2003-0354": {"epss_score": 0.0096, "epss_percentile": 0.75965}, "CVE-2003-0355": {"epss_score": 0.00353, "epss_percentile": 0.57162}, "CVE-2003-0356": {"epss_score": 0.28414, "epss_percentile": 0.96356}, "CVE-2003-0357": {"epss_score": 0.14379, "epss_percentile": 0.94198}, "CVE-2003-0358": {"epss_score": 0.00227, "epss_percentile": 0.45456}, "CVE-2003-0359": {"epss_score": 0.00046, "epss_percentile": 0.14328}, "CVE-2003-0360": {"epss_score": 0.0092, "epss_percentile": 0.75465}, "CVE-2003-0361": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2003-0362": {"epss_score": 0.00449, "epss_percentile": 0.63057}, "CVE-2003-0363": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2003-0364": {"epss_score": 0.04553, "epss_percentile": 0.88841}, "CVE-2003-0365": {"epss_score": 0.00173, "epss_percentile": 0.39074}, "CVE-2003-0366": {"epss_score": 0.01094, "epss_percentile": 0.77491}, "CVE-2003-0367": {"epss_score": 0.00141, "epss_percentile": 0.34807}, "CVE-2003-0368": {"epss_score": 0.00899, "epss_percentile": 0.75155}, "CVE-2003-0370": {"epss_score": 0.00942, "epss_percentile": 0.75759}, "CVE-2003-0371": {"epss_score": 0.04604, "epss_percentile": 0.88906}, "CVE-2003-0372": {"epss_score": 0.00172, "epss_percentile": 0.38977}, "CVE-2003-0373": {"epss_score": 0.00088, "epss_percentile": 0.25772}, "CVE-2003-0374": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-2003-0375": {"epss_score": 0.00565, "epss_percentile": 0.67797}, "CVE-2003-0376": {"epss_score": 0.04811, "epss_percentile": 0.89166}, "CVE-2003-0377": {"epss_score": 0.00895, "epss_percentile": 0.75093}, "CVE-2003-0378": {"epss_score": 0.00497, "epss_percentile": 0.65192}, "CVE-2003-0379": {"epss_score": 0.00482, "epss_percentile": 0.64549}, "CVE-2003-0380": {"epss_score": 0.17215, "epss_percentile": 0.948}, "CVE-2003-0381": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2003-0382": {"epss_score": 0.00083, "epss_percentile": 0.24803}, "CVE-2003-0385": {"epss_score": 0.00152, "epss_percentile": 0.36499}, "CVE-2003-0386": {"epss_score": 0.09637, "epss_percentile": 0.92635}, "CVE-2003-0388": {"epss_score": 0.00154, "epss_percentile": 0.36657}, "CVE-2003-0389": {"epss_score": 0.0035, "epss_percentile": 0.56952}, "CVE-2003-0390": {"epss_score": 0.0031, "epss_percentile": 0.53755}, "CVE-2003-0391": {"epss_score": 0.05551, "epss_percentile": 0.89986}, "CVE-2003-0392": {"epss_score": 0.00938, "epss_percentile": 0.75715}, "CVE-2003-0393": {"epss_score": 0.00497, "epss_percentile": 0.6519}, "CVE-2003-0394": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2003-0395": {"epss_score": 0.06003, "epss_percentile": 0.90394}, "CVE-2003-0396": {"epss_score": 0.002, "epss_percentile": 0.42215}, "CVE-2003-0397": {"epss_score": 0.0321, "epss_percentile": 0.86652}, "CVE-2003-0398": {"epss_score": 0.01983, "epss_percentile": 0.83146}, "CVE-2003-0399": {"epss_score": 0.0061, "epss_percentile": 0.69138}, "CVE-2003-0400": {"epss_score": 0.02427, "epss_percentile": 0.84718}, "CVE-2003-0401": {"epss_score": 0.00901, "epss_percentile": 0.75181}, "CVE-2003-0402": {"epss_score": 0.00741, "epss_percentile": 0.72445}, "CVE-2003-0403": {"epss_score": 0.01062, "epss_percentile": 0.77184}, "CVE-2003-0404": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2003-0405": {"epss_score": 0.00886, "epss_percentile": 0.74947}, "CVE-2003-0406": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2003-0407": {"epss_score": 0.03926, "epss_percentile": 0.87965}, "CVE-2003-0408": {"epss_score": 0.00771, "epss_percentile": 0.73018}, "CVE-2003-0409": {"epss_score": 0.08303, "epss_percentile": 0.91978}, "CVE-2003-0410": {"epss_score": 0.08388, "epss_percentile": 0.92022}, "CVE-2003-0411": {"epss_score": 0.09271, "epss_percentile": 0.92476}, "CVE-2003-0412": {"epss_score": 0.01092, "epss_percentile": 0.77465}, "CVE-2003-0413": {"epss_score": 0.01946, "epss_percentile": 0.83003}, "CVE-2003-0414": {"epss_score": 0.00048, "epss_percentile": 0.15257}, "CVE-2003-0415": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2003-0416": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2003-0417": {"epss_score": 0.01376, "epss_percentile": 0.79839}, "CVE-2003-0418": {"epss_score": 0.00934, "epss_percentile": 0.75658}, "CVE-2003-0419": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2003-0420": {"epss_score": 0.00077, "epss_percentile": 0.23537}, "CVE-2003-0421": {"epss_score": 0.01511, "epss_percentile": 0.80776}, "CVE-2003-0422": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0423": {"epss_score": 0.00587, "epss_percentile": 0.68462}, "CVE-2003-0424": {"epss_score": 0.00587, "epss_percentile": 0.68462}, "CVE-2003-0425": {"epss_score": 0.01852, "epss_percentile": 0.82544}, "CVE-2003-0426": {"epss_score": 0.00897, "epss_percentile": 0.7513}, "CVE-2003-0427": {"epss_score": 0.03265, "epss_percentile": 0.86782}, "CVE-2003-0428": {"epss_score": 0.02306, "epss_percentile": 0.84325}, "CVE-2003-0429": {"epss_score": 0.02584, "epss_percentile": 0.8516}, "CVE-2003-0430": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2003-0431": {"epss_score": 0.00553, "epss_percentile": 0.67415}, "CVE-2003-0432": {"epss_score": 0.00553, "epss_percentile": 0.67415}, "CVE-2003-0433": {"epss_score": 0.01079, "epss_percentile": 0.77357}, "CVE-2003-0434": {"epss_score": 0.29867, "epss_percentile": 0.96482}, "CVE-2003-0435": {"epss_score": 0.0328, "epss_percentile": 0.86815}, "CVE-2003-0436": {"epss_score": 0.12752, "epss_percentile": 0.93764}, "CVE-2003-0437": {"epss_score": 0.05427, "epss_percentile": 0.8987}, "CVE-2003-0438": {"epss_score": 0.00083, "epss_percentile": 0.24603}, "CVE-2003-0440": {"epss_score": 0.00061, "epss_percentile": 0.19395}, "CVE-2003-0441": {"epss_score": 0.00053, "epss_percentile": 0.16821}, "CVE-2003-0442": {"epss_score": 0.51581, "epss_percentile": 0.97787}, "CVE-2003-0444": {"epss_score": 0.03422, "epss_percentile": 0.87106}, "CVE-2003-0445": {"epss_score": 0.02307, "epss_percentile": 0.84326}, "CVE-2003-0446": {"epss_score": 0.42332, "epss_percentile": 0.97326}, "CVE-2003-0447": {"epss_score": 0.36575, "epss_percentile": 0.96988}, "CVE-2003-0448": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2003-0449": {"epss_score": 0.00425, "epss_percentile": 0.6172}, "CVE-2003-0450": {"epss_score": 0.03402, "epss_percentile": 0.8707}, "CVE-2003-0451": {"epss_score": 0.00077, "epss_percentile": 0.23457}, "CVE-2003-0452": {"epss_score": 0.00091, "epss_percentile": 0.2623}, "CVE-2003-0453": {"epss_score": 0.01128, "epss_percentile": 0.77833}, "CVE-2003-0454": {"epss_score": 0.0097, "epss_percentile": 0.76107}, "CVE-2003-0455": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2003-0456": {"epss_score": 0.00923, "epss_percentile": 0.75512}, "CVE-2003-0458": {"epss_score": 0.00086, "epss_percentile": 0.25376}, "CVE-2003-0459": {"epss_score": 0.01525, "epss_percentile": 0.80856}, "CVE-2003-0460": {"epss_score": 0.09213, "epss_percentile": 0.92451}, "CVE-2003-0461": {"epss_score": 0.00078, "epss_percentile": 0.23683}, "CVE-2003-0462": {"epss_score": 0.00267, "epss_percentile": 0.49966}, "CVE-2003-0464": {"epss_score": 0.00076, "epss_percentile": 0.23153}, "CVE-2003-0465": {"epss_score": 0.00473, "epss_percentile": 0.64089}, "CVE-2003-0466": {"epss_score": 0.90825, "epss_percentile": 0.99603}, "CVE-2003-0467": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0468": {"epss_score": 0.01821, "epss_percentile": 0.82411}, "CVE-2003-0469": {"epss_score": 0.71576, "epss_percentile": 0.98674}, "CVE-2003-0470": {"epss_score": 0.27947, "epss_percentile": 0.96297}, "CVE-2003-0471": {"epss_score": 0.68925, "epss_percentile": 0.98568}, "CVE-2003-0472": {"epss_score": 0.00928, "epss_percentile": 0.75578}, "CVE-2003-0473": {"epss_score": 0.00487, "epss_percentile": 0.64815}, "CVE-2003-0474": {"epss_score": 0.01265, "epss_percentile": 0.79004}, "CVE-2003-0475": {"epss_score": 0.01265, "epss_percentile": 0.79004}, "CVE-2003-0476": {"epss_score": 0.00154, "epss_percentile": 0.36658}, "CVE-2003-0477": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0478": {"epss_score": 0.05549, "epss_percentile": 0.89984}, "CVE-2003-0479": {"epss_score": 0.00314, "epss_percentile": 0.54107}, "CVE-2003-0480": {"epss_score": 0.00041, "epss_percentile": 0.12198}, "CVE-2003-0481": {"epss_score": 0.00399, "epss_percentile": 0.60106}, "CVE-2003-0482": {"epss_score": 0.04845, "epss_percentile": 0.89208}, "CVE-2003-0483": {"epss_score": 0.00485, "epss_percentile": 0.64727}, "CVE-2003-0484": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2003-0485": {"epss_score": 0.02323, "epss_percentile": 0.84374}, "CVE-2003-0486": {"epss_score": 0.02381, "epss_percentile": 0.84565}, "CVE-2003-0487": {"epss_score": 0.20795, "epss_percentile": 0.95413}, "CVE-2003-0488": {"epss_score": 0.00849, "epss_percentile": 0.74376}, "CVE-2003-0489": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2003-0490": {"epss_score": 0.00045, "epss_percentile": 0.13957}, "CVE-2003-0491": {"epss_score": 0.01624, "epss_percentile": 0.81414}, "CVE-2003-0492": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2003-0493": {"epss_score": 0.00461, "epss_percentile": 0.63564}, "CVE-2003-0494": {"epss_score": 0.00933, "epss_percentile": 0.75638}, "CVE-2003-0495": {"epss_score": 0.00571, "epss_percentile": 0.67991}, "CVE-2003-0496": {"epss_score": 0.02182, "epss_percentile": 0.83908}, "CVE-2003-0497": {"epss_score": 0.00112, "epss_percentile": 0.30412}, "CVE-2003-0498": {"epss_score": 0.00138, "epss_percentile": 0.34426}, "CVE-2003-0499": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2003-0500": {"epss_score": 0.01558, "epss_percentile": 0.81029}, "CVE-2003-0501": {"epss_score": 0.00366, "epss_percentile": 0.58063}, "CVE-2003-0502": {"epss_score": 0.01806, "epss_percentile": 0.8235}, "CVE-2003-0503": {"epss_score": 0.15826, "epss_percentile": 0.94515}, "CVE-2003-0504": {"epss_score": 0.00439, "epss_percentile": 0.62603}, "CVE-2003-0505": {"epss_score": 0.22271, "epss_percentile": 0.95617}, "CVE-2003-0506": {"epss_score": 0.07079, "epss_percentile": 0.91236}, "CVE-2003-0507": {"epss_score": 0.44796, "epss_percentile": 0.97453}, "CVE-2003-0508": {"epss_score": 0.24325, "epss_percentile": 0.95903}, "CVE-2003-0509": {"epss_score": 0.05791, "epss_percentile": 0.90213}, "CVE-2003-0510": {"epss_score": 0.05021, "epss_percentile": 0.89401}, "CVE-2003-0511": {"epss_score": 0.15398, "epss_percentile": 0.94423}, "CVE-2003-0512": {"epss_score": 0.01674, "epss_percentile": 0.81694}, "CVE-2003-0513": {"epss_score": 0.11064, "epss_percentile": 0.93207}, "CVE-2003-0514": {"epss_score": 0.02711, "epss_percentile": 0.85497}, "CVE-2003-0515": {"epss_score": 0.00726, "epss_percentile": 0.7208}, "CVE-2003-0516": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2003-0517": {"epss_score": 0.00055, "epss_percentile": 0.17494}, "CVE-2003-0518": {"epss_score": 0.00094, "epss_percentile": 0.26804}, "CVE-2003-0519": {"epss_score": 0.07079, "epss_percentile": 0.91236}, "CVE-2003-0520": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0521": {"epss_score": 0.00422, "epss_percentile": 0.61578}, "CVE-2003-0522": {"epss_score": 0.00461, "epss_percentile": 0.6354}, "CVE-2003-0523": {"epss_score": 0.00403, "epss_percentile": 0.6033}, "CVE-2003-0524": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-2003-0525": {"epss_score": 0.04454, "epss_percentile": 0.88711}, "CVE-2003-0526": {"epss_score": 0.45647, "epss_percentile": 0.97495}, "CVE-2003-0528": {"epss_score": 0.62082, "epss_percentile": 0.98276}, "CVE-2003-0530": {"epss_score": 0.23688, "epss_percentile": 0.95804}, "CVE-2003-0531": {"epss_score": 0.2025, "epss_percentile": 0.95308}, "CVE-2003-0532": {"epss_score": 0.23041, "epss_percentile": 0.95724}, "CVE-2003-0533": {"epss_score": 0.88967, "epss_percentile": 0.99501}, "CVE-2003-0535": {"epss_score": 0.00049, "epss_percentile": 0.15455}, "CVE-2003-0536": {"epss_score": 0.00739, "epss_percentile": 0.72351}, "CVE-2003-0537": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2003-0538": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2003-0539": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2003-0540": {"epss_score": 0.57494, "epss_percentile": 0.98066}, "CVE-2003-0541": {"epss_score": 0.01108, "epss_percentile": 0.77636}, "CVE-2003-0542": {"epss_score": 0.00523, "epss_percentile": 0.66303}, "CVE-2003-0543": {"epss_score": 0.43202, "epss_percentile": 0.97375}, "CVE-2003-0544": {"epss_score": 0.26187, "epss_percentile": 0.96121}, "CVE-2003-0545": {"epss_score": 0.74574, "epss_percentile": 0.98808}, "CVE-2003-0546": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2003-0547": {"epss_score": 0.00111, "epss_percentile": 0.30371}, "CVE-2003-0548": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2003-0549": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2003-0550": {"epss_score": 0.00712, "epss_percentile": 0.71759}, "CVE-2003-0551": {"epss_score": 0.00675, "epss_percentile": 0.70897}, "CVE-2003-0552": {"epss_score": 0.01517, "epss_percentile": 0.80806}, "CVE-2003-0553": {"epss_score": 0.0328, "epss_percentile": 0.86815}, "CVE-2003-0554": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0555": {"epss_score": 0.00954, "epss_percentile": 0.75906}, "CVE-2003-0556": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0557": {"epss_score": 0.0101, "epss_percentile": 0.76596}, "CVE-2003-0558": {"epss_score": 0.7578, "epss_percentile": 0.98864}, "CVE-2003-0559": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2003-0560": {"epss_score": 0.00586, "epss_percentile": 0.68435}, "CVE-2003-0561": {"epss_score": 0.07395, "epss_percentile": 0.91451}, "CVE-2003-0562": {"epss_score": 0.09899, "epss_percentile": 0.92762}, "CVE-2003-0564": {"epss_score": 0.3648, "epss_percentile": 0.96981}, "CVE-2003-0565": {"epss_score": 0.04879, "epss_percentile": 0.89244}, "CVE-2003-0567": {"epss_score": 0.24634, "epss_percentile": 0.95942}, "CVE-2003-0572": {"epss_score": 0.00543, "epss_percentile": 0.67099}, "CVE-2003-0573": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2003-0574": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2003-0575": {"epss_score": 0.03183, "epss_percentile": 0.86586}, "CVE-2003-0576": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0577": {"epss_score": 0.05245, "epss_percentile": 0.89657}, "CVE-2003-0578": {"epss_score": 0.00028, "epss_percentile": 0.07287}, "CVE-2003-0579": {"epss_score": 0.00283, "epss_percentile": 0.51404}, "CVE-2003-0580": {"epss_score": 0.00077, "epss_percentile": 0.23401}, "CVE-2003-0581": {"epss_score": 0.01815, "epss_percentile": 0.82386}, "CVE-2003-0583": {"epss_score": 0.00052, "epss_percentile": 0.16439}, "CVE-2003-0584": {"epss_score": 0.0031, "epss_percentile": 0.538}, "CVE-2003-0585": {"epss_score": 0.01239, "epss_percentile": 0.78795}, "CVE-2003-0586": {"epss_score": 0.04438, "epss_percentile": 0.88689}, "CVE-2003-0587": {"epss_score": 0.00137, "epss_percentile": 0.34316}, "CVE-2003-0588": {"epss_score": 0.02558, "epss_percentile": 0.851}, "CVE-2003-0589": {"epss_score": 0.02345, "epss_percentile": 0.8445}, "CVE-2003-0590": {"epss_score": 0.01251, "epss_percentile": 0.78894}, "CVE-2003-0592": {"epss_score": 0.00828, "epss_percentile": 0.73998}, "CVE-2003-0593": {"epss_score": 0.00301, "epss_percentile": 0.53067}, "CVE-2003-0594": {"epss_score": 0.02156, "epss_percentile": 0.83811}, "CVE-2003-0595": {"epss_score": 0.10086, "epss_percentile": 0.92844}, "CVE-2003-0596": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2003-0597": {"epss_score": 0.00081, "epss_percentile": 0.24218}, "CVE-2003-0599": {"epss_score": 0.00458, "epss_percentile": 0.63399}, "CVE-2003-0601": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2003-0602": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2003-0603": {"epss_score": 0.00092, "epss_percentile": 0.26428}, "CVE-2003-0604": {"epss_score": 0.08386, "epss_percentile": 0.92021}, "CVE-2003-0605": {"epss_score": 0.60638, "epss_percentile": 0.98213}, "CVE-2003-0606": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2003-0607": {"epss_score": 0.00083, "epss_percentile": 0.24803}, "CVE-2003-0609": {"epss_score": 0.00729, "epss_percentile": 0.72125}, "CVE-2003-0610": {"epss_score": 0.00863, "epss_percentile": 0.74592}, "CVE-2003-0611": {"epss_score": 0.00414, "epss_percentile": 0.61015}, "CVE-2003-0612": {"epss_score": 0.00125, "epss_percentile": 0.32575}, "CVE-2003-0613": {"epss_score": 0.00091, "epss_percentile": 0.2623}, "CVE-2003-0614": {"epss_score": 0.06043, "epss_percentile": 0.90431}, "CVE-2003-0615": {"epss_score": 0.07248, "epss_percentile": 0.91349}, "CVE-2003-0616": {"epss_score": 0.01965, "epss_percentile": 0.83078}, "CVE-2003-0617": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2003-0618": {"epss_score": 0.00078, "epss_percentile": 0.2365}, "CVE-2003-0619": {"epss_score": 0.05929, "epss_percentile": 0.90333}, "CVE-2003-0620": {"epss_score": 0.00167, "epss_percentile": 0.38308}, "CVE-2003-0621": {"epss_score": 0.0682, "epss_percentile": 0.91047}, "CVE-2003-0622": {"epss_score": 0.00776, "epss_percentile": 0.73106}, "CVE-2003-0623": {"epss_score": 0.00539, "epss_percentile": 0.66988}, "CVE-2003-0624": {"epss_score": 0.03461, "epss_percentile": 0.87182}, "CVE-2003-0625": {"epss_score": 0.06318, "epss_percentile": 0.90669}, "CVE-2003-0626": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2003-0627": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2003-0628": {"epss_score": 0.00497, "epss_percentile": 0.6519}, "CVE-2003-0629": {"epss_score": 0.00314, "epss_percentile": 0.54107}, "CVE-2003-0630": {"epss_score": 0.00049, "epss_percentile": 0.15455}, "CVE-2003-0631": {"epss_score": 0.0004, "epss_percentile": 0.1191}, "CVE-2003-0632": {"epss_score": 0.02817, "epss_percentile": 0.85737}, "CVE-2003-0633": {"epss_score": 0.00619, "epss_percentile": 0.69433}, "CVE-2003-0634": {"epss_score": 0.03259, "epss_percentile": 0.86768}, "CVE-2003-0635": {"epss_score": 0.00274, "epss_percentile": 0.50562}, "CVE-2003-0636": {"epss_score": 0.00229, "epss_percentile": 0.45617}, "CVE-2003-0637": {"epss_score": 0.00946, "epss_percentile": 0.75811}, "CVE-2003-0638": {"epss_score": 0.00554, "epss_percentile": 0.67437}, "CVE-2003-0639": {"epss_score": 0.00281, "epss_percentile": 0.51128}, "CVE-2003-0640": {"epss_score": 0.00647, "epss_percentile": 0.70185}, "CVE-2003-0641": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2003-0642": {"epss_score": 0.00102, "epss_percentile": 0.28834}, "CVE-2003-0643": {"epss_score": 0.00078, "epss_percentile": 0.23579}, "CVE-2003-0644": {"epss_score": 0.00045, "epss_percentile": 0.13769}, "CVE-2003-0645": {"epss_score": 0.00158, "epss_percentile": 0.37143}, "CVE-2003-0646": {"epss_score": 0.03077, "epss_percentile": 0.86363}, "CVE-2003-0647": {"epss_score": 0.1236, "epss_percentile": 0.93649}, "CVE-2003-0648": {"epss_score": 0.02258, "epss_percentile": 0.84178}, "CVE-2003-0649": {"epss_score": 0.00765, "epss_percentile": 0.72925}, "CVE-2003-0650": {"epss_score": 0.06027, "epss_percentile": 0.9042}, "CVE-2003-0651": {"epss_score": 0.05862, "epss_percentile": 0.90271}, "CVE-2003-0652": {"epss_score": 0.00077, "epss_percentile": 0.23457}, "CVE-2003-0653": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0654": {"epss_score": 0.02039, "epss_percentile": 0.83364}, "CVE-2003-0655": {"epss_score": 0.00293, "epss_percentile": 0.5233}, "CVE-2003-0656": {"epss_score": 0.00121, "epss_percentile": 0.31947}, "CVE-2003-0657": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2003-0658": {"epss_score": 0.00388, "epss_percentile": 0.59363}, "CVE-2003-0659": {"epss_score": 0.04131, "epss_percentile": 0.883}, "CVE-2003-0660": {"epss_score": 0.3854, "epss_percentile": 0.97104}, "CVE-2003-0661": {"epss_score": 0.33604, "epss_percentile": 0.96787}, "CVE-2003-0662": {"epss_score": 0.46114, "epss_percentile": 0.9753}, "CVE-2003-0663": {"epss_score": 0.31931, "epss_percentile": 0.9666}, "CVE-2003-0664": {"epss_score": 0.07251, "epss_percentile": 0.91351}, "CVE-2003-0665": {"epss_score": 0.42104, "epss_percentile": 0.97313}, "CVE-2003-0666": {"epss_score": 0.40134, "epss_percentile": 0.97198}, "CVE-2003-0669": {"epss_score": 0.00058, "epss_percentile": 0.18446}, "CVE-2003-0670": {"epss_score": 0.00092, "epss_percentile": 0.26449}, "CVE-2003-0671": {"epss_score": 0.00061, "epss_percentile": 0.19291}, "CVE-2003-0672": {"epss_score": 0.01882, "epss_percentile": 0.82695}, "CVE-2003-0676": {"epss_score": 0.0033, "epss_percentile": 0.55461}, "CVE-2003-0677": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2003-0679": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2003-0680": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-2003-0681": {"epss_score": 0.12435, "epss_percentile": 0.93668}, "CVE-2003-0682": {"epss_score": 0.0033, "epss_percentile": 0.55426}, "CVE-2003-0683": {"epss_score": 0.00489, "epss_percentile": 0.64872}, "CVE-2003-0685": {"epss_score": 0.0156, "epss_percentile": 0.81039}, "CVE-2003-0686": {"epss_score": 0.414, "epss_percentile": 0.97271}, "CVE-2003-0688": {"epss_score": 0.01711, "epss_percentile": 0.81881}, "CVE-2003-0689": {"epss_score": 0.00891, "epss_percentile": 0.75035}, "CVE-2003-0690": {"epss_score": 0.02079, "epss_percentile": 0.83526}, "CVE-2003-0692": {"epss_score": 0.01213, "epss_percentile": 0.78565}, "CVE-2003-0693": {"epss_score": 0.34656, "epss_percentile": 0.96864}, "CVE-2003-0694": {"epss_score": 0.7608, "epss_percentile": 0.98877}, "CVE-2003-0695": {"epss_score": 0.01015, "epss_percentile": 0.76656}, "CVE-2003-0696": {"epss_score": 0.00543, "epss_percentile": 0.67099}, "CVE-2003-0697": {"epss_score": 0.0005, "epss_percentile": 0.15824}, "CVE-2003-0699": {"epss_score": 0.00429, "epss_percentile": 0.61997}, "CVE-2003-0700": {"epss_score": 0.00576, "epss_percentile": 0.68129}, "CVE-2003-0701": {"epss_score": 0.42104, "epss_percentile": 0.97313}, "CVE-2003-0702": {"epss_score": 0.01979, "epss_percentile": 0.83131}, "CVE-2003-0703": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2003-0704": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2003-0705": {"epss_score": 0.04575, "epss_percentile": 0.88868}, "CVE-2003-0706": {"epss_score": 0.05902, "epss_percentile": 0.90311}, "CVE-2003-0707": {"epss_score": 0.02039, "epss_percentile": 0.83364}, "CVE-2003-0708": {"epss_score": 0.00911, "epss_percentile": 0.7533}, "CVE-2003-0709": {"epss_score": 0.02855, "epss_percentile": 0.85838}, "CVE-2003-0711": {"epss_score": 0.56869, "epss_percentile": 0.98039}, "CVE-2003-0712": {"epss_score": 0.18968, "epss_percentile": 0.95103}, "CVE-2003-0714": {"epss_score": 0.66997, "epss_percentile": 0.98489}, "CVE-2003-0715": {"epss_score": 0.62082, "epss_percentile": 0.98276}, "CVE-2003-0717": {"epss_score": 0.81289, "epss_percentile": 0.99131}, "CVE-2003-0718": {"epss_score": 0.81995, "epss_percentile": 0.99168}, "CVE-2003-0719": {"epss_score": 0.75258, "epss_percentile": 0.98835}, "CVE-2003-0720": {"epss_score": 0.19286, "epss_percentile": 0.9516}, "CVE-2003-0721": {"epss_score": 0.02818, "epss_percentile": 0.85739}, "CVE-2003-0722": {"epss_score": 0.87095, "epss_percentile": 0.99414}, "CVE-2003-0723": {"epss_score": 0.11725, "epss_percentile": 0.93459}, "CVE-2003-0724": {"epss_score": 0.00298, "epss_percentile": 0.52809}, "CVE-2003-0725": {"epss_score": 0.57426, "epss_percentile": 0.98061}, "CVE-2003-0726": {"epss_score": 0.09581, "epss_percentile": 0.92607}, "CVE-2003-0727": {"epss_score": 0.85761, "epss_percentile": 0.99347}, "CVE-2003-0728": {"epss_score": 0.00593, "epss_percentile": 0.6863}, "CVE-2003-0729": {"epss_score": 0.05386, "epss_percentile": 0.89821}, "CVE-2003-0730": {"epss_score": 0.05662, "epss_percentile": 0.90097}, "CVE-2003-0731": {"epss_score": 0.00382, "epss_percentile": 0.5905}, "CVE-2003-0732": {"epss_score": 0.00382, "epss_percentile": 0.5905}, "CVE-2003-0733": {"epss_score": 0.00969, "epss_percentile": 0.76098}, "CVE-2003-0734": {"epss_score": 0.00417, "epss_percentile": 0.61244}, "CVE-2003-0735": {"epss_score": 0.04601, "epss_percentile": 0.88904}, "CVE-2003-0736": {"epss_score": 0.0497, "epss_percentile": 0.89351}, "CVE-2003-0737": {"epss_score": 0.00439, "epss_percentile": 0.626}, "CVE-2003-0738": {"epss_score": 0.00599, "epss_percentile": 0.68797}, "CVE-2003-0739": {"epss_score": 0.00068, "epss_percentile": 0.21321}, "CVE-2003-0740": {"epss_score": 0.00116, "epss_percentile": 0.31103}, "CVE-2003-0742": {"epss_score": 0.00081, "epss_percentile": 0.24218}, "CVE-2003-0743": {"epss_score": 0.07018, "epss_percentile": 0.91189}, "CVE-2003-0744": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2003-0745": {"epss_score": 0.00874, "epss_percentile": 0.74764}, "CVE-2003-0746": {"epss_score": 0.06404, "epss_percentile": 0.90731}, "CVE-2003-0747": {"epss_score": 0.06855, "epss_percentile": 0.91078}, "CVE-2003-0748": {"epss_score": 0.06855, "epss_percentile": 0.91078}, "CVE-2003-0749": {"epss_score": 0.05519, "epss_percentile": 0.89956}, "CVE-2003-0750": {"epss_score": 0.00455, "epss_percentile": 0.63307}, "CVE-2003-0751": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2003-0752": {"epss_score": 0.00786, "epss_percentile": 0.73268}, "CVE-2003-0753": {"epss_score": 0.00587, "epss_percentile": 0.68462}, "CVE-2003-0754": {"epss_score": 0.00538, "epss_percentile": 0.66928}, "CVE-2003-0755": {"epss_score": 0.12645, "epss_percentile": 0.93738}, "CVE-2003-0756": {"epss_score": 0.0039, "epss_percentile": 0.59523}, "CVE-2003-0757": {"epss_score": 0.06683, "epss_percentile": 0.90942}, "CVE-2003-0758": {"epss_score": 0.00266, "epss_percentile": 0.4991}, "CVE-2003-0759": {"epss_score": 0.00266, "epss_percentile": 0.4991}, "CVE-2003-0760": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2003-0761": {"epss_score": 0.00131, "epss_percentile": 0.33402}, "CVE-2003-0762": {"epss_score": 0.04245, "epss_percentile": 0.8844}, "CVE-2003-0763": {"epss_score": 0.00403, "epss_percentile": 0.6033}, "CVE-2003-0764": {"epss_score": 0.00497, "epss_percentile": 0.6519}, "CVE-2003-0765": {"epss_score": 0.04453, "epss_percentile": 0.88709}, "CVE-2003-0766": {"epss_score": 0.06733, "epss_percentile": 0.90991}, "CVE-2003-0767": {"epss_score": 0.05062, "epss_percentile": 0.89455}, "CVE-2003-0768": {"epss_score": 0.17167, "epss_percentile": 0.94791}, "CVE-2003-0769": {"epss_score": 0.00687, "epss_percentile": 0.71177}, "CVE-2003-0770": {"epss_score": 0.1091, "epss_percentile": 0.93153}, "CVE-2003-0771": {"epss_score": 0.00086, "epss_percentile": 0.25298}, "CVE-2003-0772": {"epss_score": 0.83199, "epss_percentile": 0.99238}, "CVE-2003-0773": {"epss_score": 0.01269, "epss_percentile": 0.79039}, "CVE-2003-0774": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2003-0775": {"epss_score": 0.01583, "epss_percentile": 0.81153}, "CVE-2003-0776": {"epss_score": 0.00743, "epss_percentile": 0.72481}, "CVE-2003-0777": {"epss_score": 0.00833, "epss_percentile": 0.74081}, "CVE-2003-0778": {"epss_score": 0.00833, "epss_percentile": 0.74081}, "CVE-2003-0779": {"epss_score": 0.00032, "epss_percentile": 0.08788}, "CVE-2003-0780": {"epss_score": 0.70855, "epss_percentile": 0.98644}, "CVE-2003-0781": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-2003-0782": {"epss_score": 0.00751, "epss_percentile": 0.72643}, "CVE-2003-0783": {"epss_score": 0.00356, "epss_percentile": 0.57353}, "CVE-2003-0784": {"epss_score": 0.01195, "epss_percentile": 0.78433}, "CVE-2003-0785": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-2003-0786": {"epss_score": 0.03141, "epss_percentile": 0.86488}, "CVE-2003-0787": {"epss_score": 0.00463, "epss_percentile": 0.63687}, "CVE-2003-0788": {"epss_score": 0.01928, "epss_percentile": 0.82932}, "CVE-2003-0789": {"epss_score": 0.08237, "epss_percentile": 0.91944}, "CVE-2003-0791": {"epss_score": 0.01149, "epss_percentile": 0.78022}, "CVE-2003-0792": {"epss_score": 0.01344, "epss_percentile": 0.79618}, "CVE-2003-0793": {"epss_score": 0.00074, "epss_percentile": 0.22823}, "CVE-2003-0794": {"epss_score": 0.00083, "epss_percentile": 0.24628}, "CVE-2003-0795": {"epss_score": 0.08008, "epss_percentile": 0.91825}, "CVE-2003-0796": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2003-0797": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2003-0801": {"epss_score": 0.0031, "epss_percentile": 0.53763}, "CVE-2003-0802": {"epss_score": 0.02272, "epss_percentile": 0.84217}, "CVE-2003-0803": {"epss_score": 0.02014, "epss_percentile": 0.83269}, "CVE-2003-0804": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2003-0805": {"epss_score": 0.05562, "epss_percentile": 0.89997}, "CVE-2003-0806": {"epss_score": 0.59302, "epss_percentile": 0.98159}, "CVE-2003-0807": {"epss_score": 0.48588, "epss_percentile": 0.97644}, "CVE-2003-0809": {"epss_score": 0.45451, "epss_percentile": 0.97487}, "CVE-2003-0812": {"epss_score": 0.82063, "epss_percentile": 0.9917}, "CVE-2003-0813": {"epss_score": 0.51925, "epss_percentile": 0.97802}, "CVE-2003-0814": {"epss_score": 0.30721, "epss_percentile": 0.96562}, "CVE-2003-0815": {"epss_score": 0.13269, "epss_percentile": 0.93918}, "CVE-2003-0816": {"epss_score": 0.67219, "epss_percentile": 0.98499}, "CVE-2003-0817": {"epss_score": 0.12582, "epss_percentile": 0.93721}, "CVE-2003-0818": {"epss_score": 0.89651, "epss_percentile": 0.99536}, "CVE-2003-0819": {"epss_score": 0.58831, "epss_percentile": 0.98139}, "CVE-2003-0820": {"epss_score": 0.17469, "epss_percentile": 0.94855}, "CVE-2003-0821": {"epss_score": 0.10981, "epss_percentile": 0.93183}, "CVE-2003-0822": {"epss_score": 0.89141, "epss_percentile": 0.99511}, "CVE-2003-0823": {"epss_score": 0.30478, "epss_percentile": 0.96544}, "CVE-2003-0824": {"epss_score": 0.50484, "epss_percentile": 0.97738}, "CVE-2003-0825": {"epss_score": 0.3866, "epss_percentile": 0.97112}, "CVE-2003-0826": {"epss_score": 0.27289, "epss_percentile": 0.96232}, "CVE-2003-0827": {"epss_score": 0.0079, "epss_percentile": 0.73374}, "CVE-2003-0828": {"epss_score": 0.00083, "epss_percentile": 0.24803}, "CVE-2003-0830": {"epss_score": 0.00182, "epss_percentile": 0.4026}, "CVE-2003-0831": {"epss_score": 0.40138, "epss_percentile": 0.97199}, "CVE-2003-0832": {"epss_score": 0.00763, "epss_percentile": 0.72886}, "CVE-2003-0833": {"epss_score": 0.05025, "epss_percentile": 0.89408}, "CVE-2003-0834": {"epss_score": 0.00628, "epss_percentile": 0.69645}, "CVE-2003-0835": {"epss_score": 0.05063, "epss_percentile": 0.89455}, "CVE-2003-0836": {"epss_score": 0.01039, "epss_percentile": 0.76945}, "CVE-2003-0837": {"epss_score": 0.0149, "epss_percentile": 0.80629}, "CVE-2003-0838": {"epss_score": 0.68345, "epss_percentile": 0.98543}, "CVE-2003-0839": {"epss_score": 0.31319, "epss_percentile": 0.96608}, "CVE-2003-0840": {"epss_score": 0.00443, "epss_percentile": 0.62784}, "CVE-2003-0841": {"epss_score": 0.0032, "epss_percentile": 0.54627}, "CVE-2003-0842": {"epss_score": 0.0981, "epss_percentile": 0.92711}, "CVE-2003-0843": {"epss_score": 0.01734, "epss_percentile": 0.82001}, "CVE-2003-0844": {"epss_score": 0.00086, "epss_percentile": 0.25378}, "CVE-2003-0845": {"epss_score": 0.167, "epss_percentile": 0.94718}, "CVE-2003-0846": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-2003-0847": {"epss_score": 0.00362, "epss_percentile": 0.57776}, "CVE-2003-0848": {"epss_score": 0.0037, "epss_percentile": 0.58335}, "CVE-2003-0849": {"epss_score": 0.07684, "epss_percentile": 0.91625}, "CVE-2003-0850": {"epss_score": 0.02761, "epss_percentile": 0.85603}, "CVE-2003-0851": {"epss_score": 0.07195, "epss_percentile": 0.91313}, "CVE-2003-0852": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2003-0853": {"epss_score": 0.02438, "epss_percentile": 0.84746}, "CVE-2003-0854": {"epss_score": 0.00234, "epss_percentile": 0.46164}, "CVE-2003-0855": {"epss_score": 0.01099, "epss_percentile": 0.77548}, "CVE-2003-0856": {"epss_score": 0.00054, "epss_percentile": 0.17046}, "CVE-2003-0857": {"epss_score": 0.00051, "epss_percentile": 0.16037}, "CVE-2003-0858": {"epss_score": 0.00071, "epss_percentile": 0.22032}, "CVE-2003-0859": {"epss_score": 0.00054, "epss_percentile": 0.17263}, "CVE-2003-0860": {"epss_score": 0.00435, "epss_percentile": 0.62341}, "CVE-2003-0861": {"epss_score": 0.00619, "epss_percentile": 0.69428}, "CVE-2003-0863": {"epss_score": 0.02992, "epss_percentile": 0.86145}, "CVE-2003-0864": {"epss_score": 0.11696, "epss_percentile": 0.93452}, "CVE-2003-0865": {"epss_score": 0.19504, "epss_percentile": 0.95194}, "CVE-2003-0866": {"epss_score": 0.20413, "epss_percentile": 0.95339}, "CVE-2003-0870": {"epss_score": 0.11662, "epss_percentile": 0.93437}, "CVE-2003-0871": {"epss_score": 0.00557, "epss_percentile": 0.67535}, "CVE-2003-0872": {"epss_score": 0.00097, "epss_percentile": 0.2754}, "CVE-2003-0874": {"epss_score": 0.00762, "epss_percentile": 0.72837}, "CVE-2003-0875": {"epss_score": 0.00242, "epss_percentile": 0.47375}, "CVE-2003-0876": {"epss_score": 0.00084, "epss_percentile": 0.24993}, "CVE-2003-0877": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2003-0878": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2003-0880": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2003-0881": {"epss_score": 0.00785, "epss_percentile": 0.7326}, "CVE-2003-0882": {"epss_score": 0.00497, "epss_percentile": 0.6519}, "CVE-2003-0883": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2003-0885": {"epss_score": 0.00361, "epss_percentile": 0.57731}, "CVE-2003-0886": {"epss_score": 0.07428, "epss_percentile": 0.9147}, "CVE-2003-0887": {"epss_score": 0.00063, "epss_percentile": 0.19925}, "CVE-2003-0894": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2003-0895": {"epss_score": 0.00306, "epss_percentile": 0.53404}, "CVE-2003-0896": {"epss_score": 0.26234, "epss_percentile": 0.96126}, "CVE-2003-0897": {"epss_score": 0.00411, "epss_percentile": 0.60885}, "CVE-2003-0898": {"epss_score": 0.0118, "epss_percentile": 0.78302}, "CVE-2003-0899": {"epss_score": 0.20457, "epss_percentile": 0.95348}, "CVE-2003-0900": {"epss_score": 0.00381, "epss_percentile": 0.5898}, "CVE-2003-0901": {"epss_score": 0.05787, "epss_percentile": 0.90208}, "CVE-2003-0902": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2003-0903": {"epss_score": 0.68999, "epss_percentile": 0.98573}, "CVE-2003-0904": {"epss_score": 0.14163, "epss_percentile": 0.94147}, "CVE-2003-0905": {"epss_score": 0.27216, "epss_percentile": 0.96221}, "CVE-2003-0906": {"epss_score": 0.50849, "epss_percentile": 0.97752}, "CVE-2003-0907": {"epss_score": 0.3377, "epss_percentile": 0.96803}, "CVE-2003-0908": {"epss_score": 0.06912, "epss_percentile": 0.91113}, "CVE-2003-0909": {"epss_score": 0.21627, "epss_percentile": 0.95541}, "CVE-2003-0910": {"epss_score": 0.0601, "epss_percentile": 0.90409}, "CVE-2003-0913": {"epss_score": 0.0009, "epss_percentile": 0.26015}, "CVE-2003-0914": {"epss_score": 0.26754, "epss_percentile": 0.96173}, "CVE-2003-0924": {"epss_score": 0.00099, "epss_percentile": 0.28363}, "CVE-2003-0925": {"epss_score": 0.02752, "epss_percentile": 0.85585}, "CVE-2003-0926": {"epss_score": 0.02486, "epss_percentile": 0.84888}, "CVE-2003-0927": {"epss_score": 0.02429, "epss_percentile": 0.84725}, "CVE-2003-0928": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-2003-0929": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-2003-0930": {"epss_score": 0.00169, "epss_percentile": 0.38629}, "CVE-2003-0931": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2003-0932": {"epss_score": 0.00091, "epss_percentile": 0.2623}, "CVE-2003-0933": {"epss_score": 0.00091, "epss_percentile": 0.2623}, "CVE-2003-0934": {"epss_score": 0.00069, "epss_percentile": 0.21466}, "CVE-2003-0935": {"epss_score": 0.00862, "epss_percentile": 0.74583}, "CVE-2003-0936": {"epss_score": 0.0007, "epss_percentile": 0.21706}, "CVE-2003-0937": {"epss_score": 0.00089, "epss_percentile": 0.25884}, "CVE-2003-0938": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2003-0939": {"epss_score": 0.04561, "epss_percentile": 0.88853}, "CVE-2003-0940": {"epss_score": 0.00901, "epss_percentile": 0.7517}, "CVE-2003-0941": {"epss_score": 0.01299, "epss_percentile": 0.79282}, "CVE-2003-0942": {"epss_score": 0.03225, "epss_percentile": 0.86683}, "CVE-2003-0943": {"epss_score": 0.009, "epss_percentile": 0.75162}, "CVE-2003-0944": {"epss_score": 0.03225, "epss_percentile": 0.86683}, "CVE-2003-0945": {"epss_score": 0.009, "epss_percentile": 0.75162}, "CVE-2003-0946": {"epss_score": 0.01965, "epss_percentile": 0.83078}, "CVE-2003-0947": {"epss_score": 0.00091, "epss_percentile": 0.26241}, "CVE-2003-0948": {"epss_score": 0.00311, "epss_percentile": 0.53928}, "CVE-2003-0949": {"epss_score": 0.00059, "epss_percentile": 0.18829}, "CVE-2003-0950": {"epss_score": 0.00982, "epss_percentile": 0.76295}, "CVE-2003-0951": {"epss_score": 0.00355, "epss_percentile": 0.57265}, "CVE-2003-0954": {"epss_score": 0.00075, "epss_percentile": 0.2303}, "CVE-2003-0955": {"epss_score": 0.00443, "epss_percentile": 0.62765}, "CVE-2003-0956": {"epss_score": 0.00077, "epss_percentile": 0.2343}, "CVE-2003-0959": {"epss_score": 0.00376, "epss_percentile": 0.58674}, "CVE-2003-0960": {"epss_score": 0.00263, "epss_percentile": 0.49522}, "CVE-2003-0961": {"epss_score": 0.01301, "epss_percentile": 0.7929}, "CVE-2003-0962": {"epss_score": 0.41865, "epss_percentile": 0.97298}, "CVE-2003-0963": {"epss_score": 0.15426, "epss_percentile": 0.94429}, "CVE-2003-0965": {"epss_score": 0.03138, "epss_percentile": 0.86483}, "CVE-2003-0966": {"epss_score": 0.04102, "epss_percentile": 0.88261}, "CVE-2003-0967": {"epss_score": 0.05986, "epss_percentile": 0.90382}, "CVE-2003-0968": {"epss_score": 0.02544, "epss_percentile": 0.85059}, "CVE-2003-0969": {"epss_score": 0.02468, "epss_percentile": 0.84841}, "CVE-2003-0970": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-0971": {"epss_score": 0.02339, "epss_percentile": 0.84427}, "CVE-2003-0972": {"epss_score": 0.01208, "epss_percentile": 0.78534}, "CVE-2003-0973": {"epss_score": 0.05153, "epss_percentile": 0.89549}, "CVE-2003-0974": {"epss_score": 0.04111, "epss_percentile": 0.88272}, "CVE-2003-0975": {"epss_score": 0.00579, "epss_percentile": 0.68221}, "CVE-2003-0976": {"epss_score": 0.00265, "epss_percentile": 0.49807}, "CVE-2003-0977": {"epss_score": 0.01901, "epss_percentile": 0.8278}, "CVE-2003-0978": {"epss_score": 0.02116, "epss_percentile": 0.83662}, "CVE-2003-0979": {"epss_score": 0.00482, "epss_percentile": 0.64549}, "CVE-2003-0980": {"epss_score": 0.00314, "epss_percentile": 0.54107}, "CVE-2003-0981": {"epss_score": 0.00254, "epss_percentile": 0.48542}, "CVE-2003-0982": {"epss_score": 0.04515, "epss_percentile": 0.88789}, "CVE-2003-0983": {"epss_score": 0.00565, "epss_percentile": 0.67807}, "CVE-2003-0984": {"epss_score": 0.00113, "epss_percentile": 0.30588}, "CVE-2003-0985": {"epss_score": 0.00991, "epss_percentile": 0.76387}, "CVE-2003-0986": {"epss_score": 0.00055, "epss_percentile": 0.17562}, "CVE-2003-0987": {"epss_score": 0.19648, "epss_percentile": 0.9522}, "CVE-2003-0988": {"epss_score": 0.07323, "epss_percentile": 0.91408}, "CVE-2003-0989": {"epss_score": 0.19693, "epss_percentile": 0.95227}, "CVE-2003-0990": {"epss_score": 0.78049, "epss_percentile": 0.98966}, "CVE-2003-0991": {"epss_score": 0.01583, "epss_percentile": 0.81153}, "CVE-2003-0992": {"epss_score": 0.00553, "epss_percentile": 0.67428}, "CVE-2003-0993": {"epss_score": 0.05029, "epss_percentile": 0.89412}, "CVE-2003-0994": {"epss_score": 0.00076, "epss_percentile": 0.23097}, "CVE-2003-0995": {"epss_score": 0.13972, "epss_percentile": 0.94103}, "CVE-2003-0996": {"epss_score": 0.0006, "epss_percentile": 0.19008}, "CVE-2003-0997": {"epss_score": 0.00419, "epss_percentile": 0.61355}, "CVE-2003-0998": {"epss_score": 0.0006, "epss_percentile": 0.19008}, "CVE-2003-0999": {"epss_score": 0.00058, "epss_percentile": 0.18601}, "CVE-2003-1000": {"epss_score": 0.01114, "epss_percentile": 0.77701}, "CVE-2003-1001": {"epss_score": 0.00795, "epss_percentile": 0.73463}, "CVE-2003-1002": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-1003": {"epss_score": 0.0059, "epss_percentile": 0.68572}, "CVE-2003-1004": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-1005": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2003-1006": {"epss_score": 0.00395, "epss_percentile": 0.59844}, "CVE-2003-1007": {"epss_score": 0.00503, "epss_percentile": 0.65483}, "CVE-2003-1008": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-2003-1009": {"epss_score": 0.01079, "epss_percentile": 0.77359}, "CVE-2003-1010": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2003-1011": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2003-1012": {"epss_score": 0.03013, "epss_percentile": 0.86204}, "CVE-2003-1013": {"epss_score": 0.04459, "epss_percentile": 0.88717}, "CVE-2003-1014": {"epss_score": 0.00341, "epss_percentile": 0.5634}, "CVE-2003-1015": {"epss_score": 0.00341, "epss_percentile": 0.5634}, "CVE-2003-1016": {"epss_score": 0.00341, "epss_percentile": 0.5634}, "CVE-2003-1017": {"epss_score": 0.11638, "epss_percentile": 0.93425}, "CVE-2003-1018": {"epss_score": 0.00053, "epss_percentile": 0.16892}, "CVE-2003-1020": {"epss_score": 0.00543, "epss_percentile": 0.67099}, "CVE-2003-1021": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2003-1022": {"epss_score": 0.01267, "epss_percentile": 0.79021}, "CVE-2003-1023": {"epss_score": 0.08278, "epss_percentile": 0.91966}, "CVE-2003-1024": {"epss_score": 0.00089, "epss_percentile": 0.25905}, "CVE-2003-1025": {"epss_score": 0.64165, "epss_percentile": 0.98367}, "CVE-2003-1026": {"epss_score": 0.5582, "epss_percentile": 0.97998}, "CVE-2003-1027": {"epss_score": 0.59947, "epss_percentile": 0.98188}, "CVE-2003-1028": {"epss_score": 0.17763, "epss_percentile": 0.94902}, "CVE-2003-1029": {"epss_score": 0.21385, "epss_percentile": 0.95511}, "CVE-2003-1030": {"epss_score": 0.49315, "epss_percentile": 0.97679}, "CVE-2003-1031": {"epss_score": 0.00353, "epss_percentile": 0.57198}, "CVE-2003-1032": {"epss_score": 0.04823, "epss_percentile": 0.89181}, "CVE-2003-1033": {"epss_score": 0.00036, "epss_percentile": 0.10206}, "CVE-2003-1034": {"epss_score": 0.0005, "epss_percentile": 0.15736}, "CVE-2003-1035": {"epss_score": 0.00363, "epss_percentile": 0.57827}, "CVE-2003-1036": {"epss_score": 0.03077, "epss_percentile": 0.86363}, "CVE-2003-1037": {"epss_score": 0.01922, "epss_percentile": 0.82903}, "CVE-2003-1038": {"epss_score": 0.00497, "epss_percentile": 0.6519}, "CVE-2003-1039": {"epss_score": 0.03474, "epss_percentile": 0.87206}, "CVE-2003-1040": {"epss_score": 0.00078, "epss_percentile": 0.23637}, "CVE-2003-1041": {"epss_score": 0.70948, "epss_percentile": 0.98647}, "CVE-2003-1042": {"epss_score": 0.00569, "epss_percentile": 0.67928}, "CVE-2003-1043": {"epss_score": 0.00895, "epss_percentile": 0.75092}, "CVE-2003-1044": {"epss_score": 0.00733, "epss_percentile": 0.7221}, "CVE-2003-1045": {"epss_score": 0.00838, "epss_percentile": 0.74182}, "CVE-2003-1046": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2003-1048": {"epss_score": 0.47169, "epss_percentile": 0.97571}, "CVE-2003-1049": {"epss_score": 0.00051, "epss_percentile": 0.16326}, "CVE-2003-1050": {"epss_score": 0.00619, "epss_percentile": 0.69425}, "CVE-2003-1051": {"epss_score": 0.0005, "epss_percentile": 0.15943}, "CVE-2003-1052": {"epss_score": 0.00373, "epss_percentile": 0.58475}, "CVE-2003-1053": {"epss_score": 0.0024, "epss_percentile": 0.46952}, "CVE-2003-1054": {"epss_score": 0.07086, "epss_percentile": 0.91241}, "CVE-2003-1055": {"epss_score": 0.00249, "epss_percentile": 0.48084}, "CVE-2003-1056": {"epss_score": 0.00047, "epss_percentile": 0.14792}, "CVE-2003-1057": {"epss_score": 0.00059, "epss_percentile": 0.18798}, "CVE-2003-1058": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2003-1059": {"epss_score": 0.00047, "epss_percentile": 0.14792}, "CVE-2003-1060": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2003-1061": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2003-1062": {"epss_score": 0.00061, "epss_percentile": 0.19395}, "CVE-2003-1063": {"epss_score": 0.00428, "epss_percentile": 0.61953}, "CVE-2003-1064": {"epss_score": 0.0135, "epss_percentile": 0.79673}, "CVE-2003-1065": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2003-1066": {"epss_score": 0.02283, "epss_percentile": 0.84258}, "CVE-2003-1067": {"epss_score": 0.00092, "epss_percentile": 0.26534}, "CVE-2003-1068": {"epss_score": 0.0005, "epss_percentile": 0.15721}, "CVE-2003-1069": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2003-1070": {"epss_score": 0.009, "epss_percentile": 0.75165}, "CVE-2003-1071": {"epss_score": 0.00322, "epss_percentile": 0.54748}, "CVE-2003-1072": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2003-1073": {"epss_score": 0.00165, "epss_percentile": 0.38134}, "CVE-2003-1074": {"epss_score": 0.00053, "epss_percentile": 0.17036}, "CVE-2003-1075": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2003-1076": {"epss_score": 0.00053, "epss_percentile": 0.17036}, "CVE-2003-1077": {"epss_score": 0.0007, "epss_percentile": 0.21947}, "CVE-2003-1078": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2003-1079": {"epss_score": 0.01108, "epss_percentile": 0.77636}, "CVE-2003-1080": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2003-1081": {"epss_score": 0.022, "epss_percentile": 0.83975}, "CVE-2003-1082": {"epss_score": 0.00144, "epss_percentile": 0.35318}, "CVE-2003-1083": {"epss_score": 0.55808, "epss_percentile": 0.97997}, "CVE-2003-1084": {"epss_score": 0.05466, "epss_percentile": 0.89905}, "CVE-2003-1085": {"epss_score": 0.09682, "epss_percentile": 0.92661}, "CVE-2003-1086": {"epss_score": 0.01605, "epss_percentile": 0.81292}, "CVE-2003-1087": {"epss_score": 0.00914, "epss_percentile": 0.75386}, "CVE-2003-1088": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2003-1089": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2003-1090": {"epss_score": 0.32342, "epss_percentile": 0.96691}, "CVE-2003-1091": {"epss_score": 0.3715, "epss_percentile": 0.97023}, "CVE-2003-1092": {"epss_score": 0.20795, "epss_percentile": 0.95414}, "CVE-2003-1093": {"epss_score": 0.00453, "epss_percentile": 0.63237}, "CVE-2003-1094": {"epss_score": 0.02131, "epss_percentile": 0.83712}, "CVE-2003-1095": {"epss_score": 0.00485, "epss_percentile": 0.64725}, "CVE-2003-1096": {"epss_score": 0.58351, "epss_percentile": 0.98111}, "CVE-2003-1097": {"epss_score": 0.00815, "epss_percentile": 0.73788}, "CVE-2003-1098": {"epss_score": 0.00198, "epss_percentile": 0.42061}, "CVE-2003-1099": {"epss_score": 0.0017, "epss_percentile": 0.38681}, "CVE-2003-1100": {"epss_score": 0.02925, "epss_percentile": 0.86004}, "CVE-2003-1101": {"epss_score": 0.02038, "epss_percentile": 0.8336}, "CVE-2003-1102": {"epss_score": 0.02094, "epss_percentile": 0.8358}, "CVE-2003-1103": {"epss_score": 0.01619, "epss_percentile": 0.81378}, "CVE-2003-1104": {"epss_score": 0.14236, "epss_percentile": 0.94168}, "CVE-2003-1105": {"epss_score": 0.09233, "epss_percentile": 0.92459}, "CVE-2003-1106": {"epss_score": 0.02583, "epss_percentile": 0.85159}, "CVE-2003-1107": {"epss_score": 0.0605, "epss_percentile": 0.90434}, "CVE-2003-1108": {"epss_score": 0.13156, "epss_percentile": 0.93887}, "CVE-2003-1109": {"epss_score": 0.18227, "epss_percentile": 0.94976}, "CVE-2003-1110": {"epss_score": 0.24609, "epss_percentile": 0.95938}, "CVE-2003-1111": {"epss_score": 0.19782, "epss_percentile": 0.9524}, "CVE-2003-1112": {"epss_score": 0.14532, "epss_percentile": 0.94233}, "CVE-2003-1113": {"epss_score": 0.19782, "epss_percentile": 0.9524}, "CVE-2003-1114": {"epss_score": 0.18539, "epss_percentile": 0.9503}, "CVE-2003-1115": {"epss_score": 0.14532, "epss_percentile": 0.94233}, "CVE-2003-1116": {"epss_score": 0.01555, "epss_percentile": 0.81005}, "CVE-2003-1117": {"epss_score": 0.06602, "epss_percentile": 0.9088}, "CVE-2003-1118": {"epss_score": 0.24355, "epss_percentile": 0.95909}, "CVE-2003-1119": {"epss_score": 0.00704, "epss_percentile": 0.71572}, "CVE-2003-1120": {"epss_score": 0.00135, "epss_percentile": 0.33986}, "CVE-2003-1121": {"epss_score": 0.04998, "epss_percentile": 0.89375}, "CVE-2003-1122": {"epss_score": 0.01003, "epss_percentile": 0.76514}, "CVE-2003-1123": {"epss_score": 0.08589, "epss_percentile": 0.92137}, "CVE-2003-1124": {"epss_score": 0.0041, "epss_percentile": 0.60816}, "CVE-2003-1125": {"epss_score": 0.00564, "epss_percentile": 0.67778}, "CVE-2003-1126": {"epss_score": 0.01495, "epss_percentile": 0.80653}, "CVE-2003-1127": {"epss_score": 0.00677, "epss_percentile": 0.70956}, "CVE-2003-1128": {"epss_score": 0.02175, "epss_percentile": 0.83881}, "CVE-2003-1129": {"epss_score": 0.3355, "epss_percentile": 0.96783}, "CVE-2003-1131": {"epss_score": 0.05059, "epss_percentile": 0.89451}, "CVE-2003-1132": {"epss_score": 0.00534, "epss_percentile": 0.66798}, "CVE-2003-1133": {"epss_score": 0.00087, "epss_percentile": 0.25494}, "CVE-2003-1134": {"epss_score": 0.00144, "epss_percentile": 0.35348}, "CVE-2003-1135": {"epss_score": 0.03339, "epss_percentile": 0.8694}, "CVE-2003-1136": {"epss_score": 0.01889, "epss_percentile": 0.82722}, "CVE-2003-1137": {"epss_score": 0.06466, "epss_percentile": 0.90774}, "CVE-2003-1138": {"epss_score": 0.03178, "epss_percentile": 0.86575}, "CVE-2003-1139": {"epss_score": 0.02803, "epss_percentile": 0.85701}, "CVE-2003-1140": {"epss_score": 0.01824, "epss_percentile": 0.82423}, "CVE-2003-1141": {"epss_score": 0.78728, "epss_percentile": 0.99002}, "CVE-2003-1142": {"epss_score": 0.00851, "epss_percentile": 0.74405}, "CVE-2003-1143": {"epss_score": 0.08095, "epss_percentile": 0.91877}, "CVE-2003-1144": {"epss_score": 0.2372, "epss_percentile": 0.95808}, "CVE-2003-1145": {"epss_score": 0.0123, "epss_percentile": 0.78722}, "CVE-2003-1146": {"epss_score": 0.00464, "epss_percentile": 0.63713}, "CVE-2003-1148": {"epss_score": 0.08378, "epss_percentile": 0.92017}, "CVE-2003-1149": {"epss_score": 0.01742, "epss_percentile": 0.82054}, "CVE-2003-1150": {"epss_score": 0.02277, "epss_percentile": 0.8423}, "CVE-2003-1151": {"epss_score": 0.01124, "epss_percentile": 0.77794}, "CVE-2003-1152": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2003-1153": {"epss_score": 0.00694, "epss_percentile": 0.71348}, "CVE-2003-1154": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2003-1155": {"epss_score": 0.00074, "epss_percentile": 0.22707}, "CVE-2003-1156": {"epss_score": 0.00063, "epss_percentile": 0.20075}, "CVE-2003-1157": {"epss_score": 0.01855, "epss_percentile": 0.82559}, "CVE-2003-1158": {"epss_score": 0.04656, "epss_percentile": 0.88973}, "CVE-2003-1159": {"epss_score": 0.00996, "epss_percentile": 0.76453}, "CVE-2003-1160": {"epss_score": 0.08249, "epss_percentile": 0.91949}, "CVE-2003-1161": {"epss_score": 0.00065, "epss_percentile": 0.20465}, "CVE-2003-1162": {"epss_score": 0.04002, "epss_percentile": 0.88094}, "CVE-2003-1163": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2003-1164": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2003-1165": {"epss_score": 0.08168, "epss_percentile": 0.91913}, "CVE-2003-1166": {"epss_score": 0.04819, "epss_percentile": 0.89176}, "CVE-2003-1167": {"epss_score": 0.00205, "epss_percentile": 0.42729}, "CVE-2003-1168": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2003-1169": {"epss_score": 0.00297, "epss_percentile": 0.52686}, "CVE-2003-1170": {"epss_score": 0.00062, "epss_percentile": 0.19727}, "CVE-2003-1171": {"epss_score": 0.06854, "epss_percentile": 0.91077}, "CVE-2003-1172": {"epss_score": 0.17248, "epss_percentile": 0.94807}, "CVE-2003-1173": {"epss_score": 0.08559, "epss_percentile": 0.92125}, "CVE-2003-1174": {"epss_score": 0.00455, "epss_percentile": 0.63301}, "CVE-2003-1175": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2003-1176": {"epss_score": 0.07883, "epss_percentile": 0.91742}, "CVE-2003-1177": {"epss_score": 0.23249, "epss_percentile": 0.95757}, "CVE-2003-1178": {"epss_score": 0.01495, "epss_percentile": 0.80657}, "CVE-2003-1179": {"epss_score": 0.08311, "epss_percentile": 0.91986}, "CVE-2003-1180": {"epss_score": 0.01167, "epss_percentile": 0.78186}, "CVE-2003-1181": {"epss_score": 0.0754, "epss_percentile": 0.91526}, "CVE-2003-1182": {"epss_score": 0.00538, "epss_percentile": 0.66935}, "CVE-2003-1183": {"epss_score": 0.00272, "epss_percentile": 0.50366}, "CVE-2003-1184": {"epss_score": 0.03992, "epss_percentile": 0.88071}, "CVE-2003-1185": {"epss_score": 0.01139, "epss_percentile": 0.77945}, "CVE-2003-1186": {"epss_score": 0.05514, "epss_percentile": 0.89949}, "CVE-2003-1187": {"epss_score": 0.00655, "epss_percentile": 0.70428}, "CVE-2003-1188": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2003-1189": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2003-1190": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2003-1191": {"epss_score": 0.0522, "epss_percentile": 0.89625}, "CVE-2003-1192": {"epss_score": 0.82653, "epss_percentile": 0.99205}, "CVE-2003-1193": {"epss_score": 0.00425, "epss_percentile": 0.61707}, "CVE-2003-1194": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2003-1195": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2003-1196": {"epss_score": 0.01244, "epss_percentile": 0.78837}, "CVE-2003-1197": {"epss_score": 0.00834, "epss_percentile": 0.74112}, "CVE-2003-1198": {"epss_score": 0.00804, "epss_percentile": 0.73611}, "CVE-2003-1199": {"epss_score": 0.01448, "epss_percentile": 0.80335}, "CVE-2003-1200": {"epss_score": 0.5989, "epss_percentile": 0.98185}, "CVE-2003-1201": {"epss_score": 0.00282, "epss_percentile": 0.51204}, "CVE-2003-1202": {"epss_score": 0.0404, "epss_percentile": 0.88166}, "CVE-2003-1203": {"epss_score": 0.00524, "epss_percentile": 0.6632}, "CVE-2003-1204": {"epss_score": 0.09203, "epss_percentile": 0.92447}, "CVE-2003-1205": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2003-1206": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2003-1207": {"epss_score": 0.0445, "epss_percentile": 0.88703}, "CVE-2003-1208": {"epss_score": 0.08383, "epss_percentile": 0.92019}, "CVE-2003-1209": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2003-1210": {"epss_score": 0.00019, "epss_percentile": 0.04203}, "CVE-2003-1211": {"epss_score": 0.01535, "epss_percentile": 0.80912}, "CVE-2003-1212": {"epss_score": 0.01288, "epss_percentile": 0.79202}, "CVE-2003-1213": {"epss_score": 0.0802, "epss_percentile": 0.91834}, "CVE-2003-1214": {"epss_score": 0.00415, "epss_percentile": 0.61121}, "CVE-2003-1215": {"epss_score": 0.00062, "epss_percentile": 0.19678}, "CVE-2003-1216": {"epss_score": 0.02978, "epss_percentile": 0.86111}, "CVE-2003-1219": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2003-1220": {"epss_score": 0.00489, "epss_percentile": 0.64911}, "CVE-2003-1221": {"epss_score": 0.00383, "epss_percentile": 0.59108}, "CVE-2003-1222": {"epss_score": 0.00262, "epss_percentile": 0.49367}, "CVE-2003-1223": {"epss_score": 0.00489, "epss_percentile": 0.64911}, "CVE-2003-1224": {"epss_score": 0.00062, "epss_percentile": 0.19648}, "CVE-2003-1225": {"epss_score": 0.00055, "epss_percentile": 0.17504}, "CVE-2003-1226": {"epss_score": 0.00033, "epss_percentile": 0.09362}, "CVE-2003-1227": {"epss_score": 0.05744, "epss_percentile": 0.90173}, "CVE-2003-1228": {"epss_score": 0.12368, "epss_percentile": 0.93651}, "CVE-2003-1229": {"epss_score": 0.01293, "epss_percentile": 0.79237}, "CVE-2003-1230": {"epss_score": 0.00524, "epss_percentile": 0.66329}, "CVE-2003-1231": {"epss_score": 0.00565, "epss_percentile": 0.67806}, "CVE-2003-1232": {"epss_score": 0.06663, "epss_percentile": 0.90925}, "CVE-2003-1233": {"epss_score": 0.0015, "epss_percentile": 0.36148}, "CVE-2003-1234": {"epss_score": 0.00068, "epss_percentile": 0.21224}, "CVE-2003-1235": {"epss_score": 0.00408, "epss_percentile": 0.60677}, "CVE-2003-1236": {"epss_score": 0.27561, "epss_percentile": 0.96259}, "CVE-2003-1237": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2003-1238": {"epss_score": 0.00642, "epss_percentile": 0.70036}, "CVE-2003-1239": {"epss_score": 0.06466, "epss_percentile": 0.90774}, "CVE-2003-1240": {"epss_score": 0.01328, "epss_percentile": 0.79499}, "CVE-2003-1241": {"epss_score": 0.0043, "epss_percentile": 0.62013}, "CVE-2003-1242": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2003-1243": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2003-1244": {"epss_score": 0.01164, "epss_percentile": 0.78165}, "CVE-2003-1245": {"epss_score": 0.03668, "epss_percentile": 0.87536}, "CVE-2003-1246": {"epss_score": 0.00064, "epss_percentile": 0.20347}, "CVE-2003-1247": {"epss_score": 0.52927, "epss_percentile": 0.97847}, "CVE-2003-1248": {"epss_score": 0.01848, "epss_percentile": 0.82527}, "CVE-2003-1249": {"epss_score": 0.01373, "epss_percentile": 0.7982}, "CVE-2003-1250": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2003-1251": {"epss_score": 0.04132, "epss_percentile": 0.883}, "CVE-2003-1252": {"epss_score": 0.0552, "epss_percentile": 0.89957}, "CVE-2003-1253": {"epss_score": 0.00945, "epss_percentile": 0.75802}, "CVE-2003-1254": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2003-1255": {"epss_score": 0.00448, "epss_percentile": 0.63026}, "CVE-2003-1256": {"epss_score": 0.0577, "epss_percentile": 0.90192}, "CVE-2003-1257": {"epss_score": 0.00669, "epss_percentile": 0.70764}, "CVE-2003-1258": {"epss_score": 0.01299, "epss_percentile": 0.79282}, "CVE-2003-1259": {"epss_score": 0.12331, "epss_percentile": 0.93642}, "CVE-2003-1260": {"epss_score": 0.13906, "epss_percentile": 0.94089}, "CVE-2003-1261": {"epss_score": 0.00072, "epss_percentile": 0.22434}, "CVE-2003-1262": {"epss_score": 0.06705, "epss_percentile": 0.90957}, "CVE-2003-1263": {"epss_score": 0.08802, "epss_percentile": 0.9226}, "CVE-2003-1264": {"epss_score": 0.00765, "epss_percentile": 0.72929}, "CVE-2003-1265": {"epss_score": 0.00144, "epss_percentile": 0.35337}, "CVE-2003-1266": {"epss_score": 0.12258, "epss_percentile": 0.93613}, "CVE-2003-1267": {"epss_score": 0.01317, "epss_percentile": 0.79416}, "CVE-2003-1268": {"epss_score": 0.0139, "epss_percentile": 0.79934}, "CVE-2003-1269": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2003-1270": {"epss_score": 0.02366, "epss_percentile": 0.84514}, "CVE-2003-1271": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2003-1272": {"epss_score": 0.02501, "epss_percentile": 0.84921}, "CVE-2003-1273": {"epss_score": 0.00229, "epss_percentile": 0.4562}, "CVE-2003-1274": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2003-1275": {"epss_score": 0.125, "epss_percentile": 0.93693}, "CVE-2003-1276": {"epss_score": 0.00041, "epss_percentile": 0.12332}, "CVE-2003-1277": {"epss_score": 0.00683, "epss_percentile": 0.71098}, "CVE-2003-1278": {"epss_score": 0.00725, "epss_percentile": 0.72055}, "CVE-2003-1279": {"epss_score": 0.00159, "epss_percentile": 0.37385}, "CVE-2003-1280": {"epss_score": 0.00551, "epss_percentile": 0.67353}, "CVE-2003-1281": {"epss_score": 0.00182, "epss_percentile": 0.40233}, "CVE-2003-1282": {"epss_score": 0.00495, "epss_percentile": 0.65119}, "CVE-2003-1283": {"epss_score": 0.01922, "epss_percentile": 0.82903}, "CVE-2003-1284": {"epss_score": 0.00619, "epss_percentile": 0.69393}, "CVE-2003-1285": {"epss_score": 0.01386, "epss_percentile": 0.79912}, "CVE-2003-1286": {"epss_score": 0.111, "epss_percentile": 0.9322}, "CVE-2003-1287": {"epss_score": 0.00139, "epss_percentile": 0.34646}, "CVE-2003-1288": {"epss_score": 0.00425, "epss_percentile": 0.61716}, "CVE-2003-1289": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2003-1290": {"epss_score": 0.00486, "epss_percentile": 0.64775}, "CVE-2003-1291": {"epss_score": 0.00035, "epss_percentile": 0.09809}, "CVE-2003-1292": {"epss_score": 0.11149, "epss_percentile": 0.9324}, "CVE-2003-1293": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2003-1294": {"epss_score": 0.00099, "epss_percentile": 0.28389}, "CVE-2003-1295": {"epss_score": 0.00065, "epss_percentile": 0.206}, "CVE-2003-1296": {"epss_score": 0.00693, "epss_percentile": 0.7132}, "CVE-2003-1297": {"epss_score": 0.00408, "epss_percentile": 0.60677}, "CVE-2003-1298": {"epss_score": 0.00823, "epss_percentile": 0.73929}, "CVE-2003-1299": {"epss_score": 0.00547, "epss_percentile": 0.67254}, "CVE-2003-1300": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2003-1301": {"epss_score": 0.01171, "epss_percentile": 0.78218}, "CVE-2003-1302": {"epss_score": 0.00577, "epss_percentile": 0.68174}, "CVE-2003-1303": {"epss_score": 0.01352, "epss_percentile": 0.79684}, "CVE-2003-1304": {"epss_score": 0.07497, "epss_percentile": 0.91503}, "CVE-2003-1305": {"epss_score": 0.00693, "epss_percentile": 0.7132}, "CVE-2003-1306": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2003-1307": {"epss_score": 0.0124, "epss_percentile": 0.788}, "CVE-2003-1308": {"epss_score": 0.00645, "epss_percentile": 0.70108}, "CVE-2003-1309": {"epss_score": 0.01104, "epss_percentile": 0.77601}, "CVE-2003-1310": {"epss_score": 0.0017, "epss_percentile": 0.3874}, "CVE-2003-1311": {"epss_score": 0.01146, "epss_percentile": 0.78001}, "CVE-2003-1312": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2003-1313": {"epss_score": 0.01937, "epss_percentile": 0.82963}, "CVE-2003-1314": {"epss_score": 0.03747, "epss_percentile": 0.87666}, "CVE-2003-1315": {"epss_score": 0.00785, "epss_percentile": 0.73264}, "CVE-2003-1316": {"epss_score": 0.00504, "epss_percentile": 0.65542}, "CVE-2003-1317": {"epss_score": 0.00807, "epss_percentile": 0.7367}, "CVE-2003-1318": {"epss_score": 0.05102, "epss_percentile": 0.89498}, "CVE-2003-1319": {"epss_score": 0.27898, "epss_percentile": 0.96293}, "CVE-2003-1320": {"epss_score": 0.01232, "epss_percentile": 0.78737}, "CVE-2003-1321": {"epss_score": 0.0598, "epss_percentile": 0.90378}, "CVE-2003-1322": {"epss_score": 0.0532, "epss_percentile": 0.89727}, "CVE-2003-1323": {"epss_score": 0.00345, "epss_percentile": 0.56569}, "CVE-2003-1324": {"epss_score": 0.00059, "epss_percentile": 0.18671}, "CVE-2003-1325": {"epss_score": 0.00566, "epss_percentile": 0.67829}, "CVE-2003-1326": {"epss_score": 0.1111, "epss_percentile": 0.93224}, "CVE-2003-1327": {"epss_score": 0.01358, "epss_percentile": 0.79733}, "CVE-2003-1328": {"epss_score": 0.43563, "epss_percentile": 0.97391}, "CVE-2003-1329": {"epss_score": 0.00654, "epss_percentile": 0.70347}, "CVE-2003-1330": {"epss_score": 0.00195, "epss_percentile": 0.41683}, "CVE-2003-1331": {"epss_score": 0.01185, "epss_percentile": 0.78338}, "CVE-2003-1332": {"epss_score": 0.06834, "epss_percentile": 0.91057}, "CVE-2003-1333": {"epss_score": 0.01073, "epss_percentile": 0.77289}, "CVE-2003-1334": {"epss_score": 0.00246, "epss_percentile": 0.47789}, "CVE-2003-1335": {"epss_score": 0.00083, "epss_percentile": 0.24818}, "CVE-2003-1336": {"epss_score": 0.76578, "epss_percentile": 0.98897}, "CVE-2003-1337": {"epss_score": 0.04245, "epss_percentile": 0.8844}, "CVE-2003-1338": {"epss_score": 0.00355, "epss_percentile": 0.5726}, "CVE-2003-1339": {"epss_score": 0.20229, "epss_percentile": 0.95306}, "CVE-2003-1340": {"epss_score": 0.00309, "epss_percentile": 0.53647}, "CVE-2003-1341": {"epss_score": 0.06518, "epss_percentile": 0.90816}, "CVE-2003-1342": {"epss_score": 0.05471, "epss_percentile": 0.89909}, "CVE-2003-1343": {"epss_score": 0.02964, "epss_percentile": 0.86076}, "CVE-2003-1344": {"epss_score": 0.02956, "epss_percentile": 0.86062}, "CVE-2003-1345": {"epss_score": 0.00084, "epss_percentile": 0.24919}, "CVE-2003-1346": {"epss_score": 0.00583, "epss_percentile": 0.68348}, "CVE-2003-1347": {"epss_score": 0.00844, "epss_percentile": 0.74281}, "CVE-2003-1348": {"epss_score": 0.01823, "epss_percentile": 0.82421}, "CVE-2003-1349": {"epss_score": 0.00255, "epss_percentile": 0.48663}, "CVE-2003-1350": {"epss_score": 0.03022, "epss_percentile": 0.86227}, "CVE-2003-1351": {"epss_score": 0.00095, "epss_percentile": 0.27108}, "CVE-2003-1352": {"epss_score": 0.00309, "epss_percentile": 0.53666}, "CVE-2003-1353": {"epss_score": 0.00278, "epss_percentile": 0.50885}, "CVE-2003-1354": {"epss_score": 0.04125, "epss_percentile": 0.88287}, "CVE-2003-1355": {"epss_score": 0.05158, "epss_percentile": 0.89554}, "CVE-2003-1356": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2003-1357": {"epss_score": 0.00837, "epss_percentile": 0.74154}, "CVE-2003-1358": {"epss_score": 0.00806, "epss_percentile": 0.73658}, "CVE-2003-1359": {"epss_score": 0.00281, "epss_percentile": 0.51193}, "CVE-2003-1360": {"epss_score": 0.00059, "epss_percentile": 0.18862}, "CVE-2003-1361": {"epss_score": 0.00919, "epss_percentile": 0.75458}, "CVE-2003-1362": {"epss_score": 0.00803, "epss_percentile": 0.73602}, "CVE-2003-1363": {"epss_score": 0.004, "epss_percentile": 0.60184}, "CVE-2003-1364": {"epss_score": 0.05309, "epss_percentile": 0.89715}, "CVE-2003-1365": {"epss_score": 0.00528, "epss_percentile": 0.66552}, "CVE-2003-1366": {"epss_score": 0.0022, "epss_percentile": 0.44571}, "CVE-2003-1367": {"epss_score": 0.00343, "epss_percentile": 0.56446}, "CVE-2003-1368": {"epss_score": 0.04917, "epss_percentile": 0.89287}, "CVE-2003-1369": {"epss_score": 0.05158, "epss_percentile": 0.89554}, "CVE-2003-1370": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2003-1371": {"epss_score": 0.02155, "epss_percentile": 0.83804}, "CVE-2003-1372": {"epss_score": 0.00369, "epss_percentile": 0.58262}, "CVE-2003-1373": {"epss_score": 0.00155, "epss_percentile": 0.36857}, "CVE-2003-1374": {"epss_score": 0.0013, "epss_percentile": 0.33311}, "CVE-2003-1375": {"epss_score": 0.00355, "epss_percentile": 0.57261}, "CVE-2003-1376": {"epss_score": 0.00035, "epss_percentile": 0.10048}, "CVE-2003-1377": {"epss_score": 0.03049, "epss_percentile": 0.86287}, "CVE-2003-1378": {"epss_score": 0.38009, "epss_percentile": 0.97082}, "CVE-2003-1379": {"epss_score": 0.00273, "epss_percentile": 0.50435}, "CVE-2003-1380": {"epss_score": 0.00169, "epss_percentile": 0.38571}, "CVE-2003-1381": {"epss_score": 0.03355, "epss_percentile": 0.86973}, "CVE-2003-1382": {"epss_score": 0.0284, "epss_percentile": 0.85798}, "CVE-2003-1383": {"epss_score": 0.00656, "epss_percentile": 0.70449}, "CVE-2003-1384": {"epss_score": 0.0055, "epss_percentile": 0.67339}, "CVE-2003-1385": {"epss_score": 0.02857, "epss_percentile": 0.85844}, "CVE-2003-1386": {"epss_score": 0.04245, "epss_percentile": 0.88438}, "CVE-2003-1387": {"epss_score": 0.10577, "epss_percentile": 0.93032}, "CVE-2003-1388": {"epss_score": 0.02331, "epss_percentile": 0.84404}, "CVE-2003-1389": {"epss_score": 0.00365, "epss_percentile": 0.57981}, "CVE-2003-1390": {"epss_score": 0.00283, "epss_percentile": 0.51378}, "CVE-2003-1391": {"epss_score": 0.00196, "epss_percentile": 0.41797}, "CVE-2003-1392": {"epss_score": 0.0077, "epss_percentile": 0.72998}, "CVE-2003-1393": {"epss_score": 0.05227, "epss_percentile": 0.89635}, "CVE-2003-1394": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2003-1395": {"epss_score": 0.03366, "epss_percentile": 0.87002}, "CVE-2003-1396": {"epss_score": 0.04168, "epss_percentile": 0.88343}, "CVE-2003-1397": {"epss_score": 0.05155, "epss_percentile": 0.89552}, "CVE-2003-1398": {"epss_score": 0.00702, "epss_percentile": 0.71515}, "CVE-2003-1399": {"epss_score": 0.00061, "epss_percentile": 0.1929}, "CVE-2003-1400": {"epss_score": 0.00121, "epss_percentile": 0.31877}, "CVE-2003-1401": {"epss_score": 0.0253, "epss_percentile": 0.85023}, "CVE-2003-1402": {"epss_score": 0.00721, "epss_percentile": 0.71974}, "CVE-2003-1403": {"epss_score": 0.00595, "epss_percentile": 0.68692}, "CVE-2003-1404": {"epss_score": 0.00539, "epss_percentile": 0.66985}, "CVE-2003-1405": {"epss_score": 0.0521, "epss_percentile": 0.89614}, "CVE-2003-1406": {"epss_score": 0.01034, "epss_percentile": 0.76891}, "CVE-2003-1407": {"epss_score": 0.03663, "epss_percentile": 0.87529}, "CVE-2003-1408": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2003-1409": {"epss_score": 0.03243, "epss_percentile": 0.8674}, "CVE-2003-1410": {"epss_score": 0.02477, "epss_percentile": 0.84864}, "CVE-2003-1411": {"epss_score": 0.01486, "epss_percentile": 0.80607}, "CVE-2003-1412": {"epss_score": 0.02285, "epss_percentile": 0.84267}, "CVE-2003-1413": {"epss_score": 0.00267, "epss_percentile": 0.49959}, "CVE-2003-1414": {"epss_score": 0.02664, "epss_percentile": 0.85374}, "CVE-2003-1415": {"epss_score": 0.00674, "epss_percentile": 0.7088}, "CVE-2003-1416": {"epss_score": 0.00556, "epss_percentile": 0.67498}, "CVE-2003-1417": {"epss_score": 0.00063, "epss_percentile": 0.19886}, "CVE-2003-1418": {"epss_score": 0.00338, "epss_percentile": 0.56132}, "CVE-2003-1419": {"epss_score": 0.03177, "epss_percentile": 0.86573}, "CVE-2003-1420": {"epss_score": 0.00482, "epss_percentile": 0.64543}, "CVE-2003-1421": {"epss_score": 0.00484, "epss_percentile": 0.6465}, "CVE-2003-1422": {"epss_score": 0.00336, "epss_percentile": 0.55986}, "CVE-2003-1423": {"epss_score": 0.00252, "epss_percentile": 0.48371}, "CVE-2003-1424": {"epss_score": 0.0047, "epss_percentile": 0.63974}, "CVE-2003-1425": {"epss_score": 0.03679, "epss_percentile": 0.87557}, "CVE-2003-1426": {"epss_score": 0.00066, "epss_percentile": 0.20691}, "CVE-2003-1427": {"epss_score": 0.05562, "epss_percentile": 0.89997}, "CVE-2003-1428": {"epss_score": 0.00065, "epss_percentile": 0.20534}, "CVE-2003-1429": {"epss_score": 0.03923, "epss_percentile": 0.87957}, "CVE-2003-1430": {"epss_score": 0.02417, "epss_percentile": 0.84693}, "CVE-2003-1431": {"epss_score": 0.03974, "epss_percentile": 0.88046}, "CVE-2003-1432": {"epss_score": 0.18681, "epss_percentile": 0.95052}, "CVE-2003-1433": {"epss_score": 0.00621, "epss_percentile": 0.69479}, "CVE-2003-1434": {"epss_score": 0.00488, "epss_percentile": 0.64861}, "CVE-2003-1435": {"epss_score": 0.00017, "epss_percentile": 0.03175}, "CVE-2003-1436": {"epss_score": 0.01022, "epss_percentile": 0.76758}, "CVE-2003-1437": {"epss_score": 0.00037, "epss_percentile": 0.10923}, "CVE-2003-1438": {"epss_score": 0.00254, "epss_percentile": 0.48547}, "CVE-2003-1439": {"epss_score": 0.00287, "epss_percentile": 0.51846}, "CVE-2003-1440": {"epss_score": 0.00674, "epss_percentile": 0.7088}, "CVE-2003-1441": {"epss_score": 0.00674, "epss_percentile": 0.7088}, "CVE-2003-1442": {"epss_score": 0.0413, "epss_percentile": 0.88297}, "CVE-2003-1443": {"epss_score": 0.00056, "epss_percentile": 0.17914}, "CVE-2003-1444": {"epss_score": 0.00056, "epss_percentile": 0.17914}, "CVE-2003-1445": {"epss_score": 0.00486, "epss_percentile": 0.64749}, "CVE-2003-1446": {"epss_score": 0.00066, "epss_percentile": 0.20806}, "CVE-2003-1447": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2003-1448": {"epss_score": 0.26607, "epss_percentile": 0.96161}, "CVE-2003-1449": {"epss_score": 0.00277, "epss_percentile": 0.50821}, "CVE-2003-1450": {"epss_score": 0.11456, "epss_percentile": 0.93367}, "CVE-2003-1451": {"epss_score": 0.02872, "epss_percentile": 0.85877}, "CVE-2003-1452": {"epss_score": 0.0035, "epss_percentile": 0.5697}, "CVE-2003-1453": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2003-1454": {"epss_score": 0.00274, "epss_percentile": 0.50507}, "CVE-2003-1455": {"epss_score": 0.00054, "epss_percentile": 0.17276}, "CVE-2003-1456": {"epss_score": 0.03897, "epss_percentile": 0.87917}, "CVE-2003-1457": {"epss_score": 0.00256, "epss_percentile": 0.48803}, "CVE-2003-1458": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2003-1459": {"epss_score": 0.02899, "epss_percentile": 0.8595}, "CVE-2003-1460": {"epss_score": 0.00046, "epss_percentile": 0.14143}, "CVE-2003-1461": {"epss_score": 0.00252, "epss_percentile": 0.48364}, "CVE-2003-1462": {"epss_score": 0.00721, "epss_percentile": 0.71974}, "CVE-2003-1463": {"epss_score": 0.05427, "epss_percentile": 0.89869}, "CVE-2003-1464": {"epss_score": 0.00719, "epss_percentile": 0.71953}, "CVE-2003-1465": {"epss_score": 0.00224, "epss_percentile": 0.45004}, "CVE-2003-1466": {"epss_score": 0.00595, "epss_percentile": 0.68692}, "CVE-2003-1467": {"epss_score": 0.00792, "epss_percentile": 0.73408}, "CVE-2003-1468": {"epss_score": 0.0003, "epss_percentile": 0.08149}, "CVE-2003-1469": {"epss_score": 0.0215, "epss_percentile": 0.83783}, "CVE-2003-1470": {"epss_score": 0.01919, "epss_percentile": 0.82886}, "CVE-2003-1471": {"epss_score": 0.00525, "epss_percentile": 0.6639}, "CVE-2003-1472": {"epss_score": 0.0568, "epss_percentile": 0.90116}, "CVE-2003-1473": {"epss_score": 0.00436, "epss_percentile": 0.62472}, "CVE-2003-1474": {"epss_score": 0.00228, "epss_percentile": 0.45532}, "CVE-2003-1475": {"epss_score": 0.00635, "epss_percentile": 0.69812}, "CVE-2003-1476": {"epss_score": 0.00062, "epss_percentile": 0.19748}, "CVE-2003-1477": {"epss_score": 0.00673, "epss_percentile": 0.70843}, "CVE-2003-1478": {"epss_score": 0.02364, "epss_percentile": 0.84511}, "CVE-2003-1479": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2003-1480": {"epss_score": 0.27021, "epss_percentile": 0.96199}, "CVE-2003-1481": {"epss_score": 0.04587, "epss_percentile": 0.88888}, "CVE-2003-1482": {"epss_score": 0.0044, "epss_percentile": 0.62621}, "CVE-2003-1483": {"epss_score": 0.00171, "epss_percentile": 0.38873}, "CVE-2003-1484": {"epss_score": 0.27616, "epss_percentile": 0.96262}, "CVE-2003-1485": {"epss_score": 0.00172, "epss_percentile": 0.38987}, "CVE-2003-1486": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2003-1487": {"epss_score": 0.07641, "epss_percentile": 0.91594}, "CVE-2003-1488": {"epss_score": 0.02624, "epss_percentile": 0.8526}, "CVE-2003-1489": {"epss_score": 0.00244, "epss_percentile": 0.47609}, "CVE-2003-1490": {"epss_score": 0.00411, "epss_percentile": 0.60849}, "CVE-2003-1491": {"epss_score": 0.00271, "epss_percentile": 0.50337}, "CVE-2003-1492": {"epss_score": 0.00257, "epss_percentile": 0.48917}, "CVE-2003-1493": {"epss_score": 0.00504, "epss_percentile": 0.65541}, "CVE-2003-1494": {"epss_score": 0.00504, "epss_percentile": 0.65541}, "CVE-2003-1495": {"epss_score": 0.00715, "epss_percentile": 0.71834}, "CVE-2003-1496": {"epss_score": 0.00264, "epss_percentile": 0.4972}, "CVE-2003-1497": {"epss_score": 0.00864, "epss_percentile": 0.74602}, "CVE-2003-1498": {"epss_score": 0.00744, "epss_percentile": 0.72515}, "CVE-2003-1499": {"epss_score": 0.02242, "epss_percentile": 0.84118}, "CVE-2003-1500": {"epss_score": 0.03573, "epss_percentile": 0.87371}, "CVE-2003-1501": {"epss_score": 0.00083, "epss_percentile": 0.24807}, "CVE-2003-1502": {"epss_score": 0.00056, "epss_percentile": 0.17914}, "CVE-2003-1503": {"epss_score": 0.06262, "epss_percentile": 0.90621}, "CVE-2003-1504": {"epss_score": 0.00301, "epss_percentile": 0.53079}, "CVE-2003-1505": {"epss_score": 0.27198, "epss_percentile": 0.96219}, "CVE-2003-1506": {"epss_score": 0.00689, "epss_percentile": 0.71222}, "CVE-2003-1507": {"epss_score": 0.00837, "epss_percentile": 0.74154}, "CVE-2003-1508": {"epss_score": 0.00761, "epss_percentile": 0.72826}, "CVE-2003-1509": {"epss_score": 0.00873, "epss_percentile": 0.74744}, "CVE-2003-1510": {"epss_score": 0.00759, "epss_percentile": 0.72796}, "CVE-2003-1511": {"epss_score": 0.00388, "epss_percentile": 0.5935}, "CVE-2003-1512": {"epss_score": 0.02927, "epss_percentile": 0.86008}, "CVE-2003-1513": {"epss_score": 0.00564, "epss_percentile": 0.67752}, "CVE-2003-1514": {"epss_score": 0.0088, "epss_percentile": 0.74859}, "CVE-2003-1515": {"epss_score": 0.00671, "epss_percentile": 0.70789}, "CVE-2003-1516": {"epss_score": 0.03109, "epss_percentile": 0.86423}, "CVE-2003-1517": {"epss_score": 0.04587, "epss_percentile": 0.88888}, "CVE-2003-1518": {"epss_score": 0.03684, "epss_percentile": 0.87566}, "CVE-2003-1519": {"epss_score": 0.00564, "epss_percentile": 0.67752}, "CVE-2003-1520": {"epss_score": 0.00288, "epss_percentile": 0.51867}, "CVE-2003-1521": {"epss_score": 0.02304, "epss_percentile": 0.8432}, "CVE-2003-1522": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2003-1523": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2003-1524": {"epss_score": 0.00062, "epss_percentile": 0.19666}, "CVE-2003-1525": {"epss_score": 0.00334, "epss_percentile": 0.55717}, "CVE-2003-1526": {"epss_score": 0.00013, "epss_percentile": 0.01485}, "CVE-2003-1527": {"epss_score": 0.00925, "epss_percentile": 0.75532}, "CVE-2003-1528": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2003-1529": {"epss_score": 0.00283, "epss_percentile": 0.51403}, "CVE-2003-1530": {"epss_score": 0.00321, "epss_percentile": 0.54649}, "CVE-2003-1531": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2003-1532": {"epss_score": 0.00411, "epss_percentile": 0.60883}, "CVE-2003-1533": {"epss_score": 0.00291, "epss_percentile": 0.5221}, "CVE-2003-1534": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2003-1535": {"epss_score": 0.0366, "epss_percentile": 0.87526}, "CVE-2003-1536": {"epss_score": 0.00579, "epss_percentile": 0.68208}, "CVE-2003-1537": {"epss_score": 0.0011, "epss_percentile": 0.30176}, "CVE-2003-1538": {"epss_score": 0.00452, "epss_percentile": 0.63159}, "CVE-2003-1539": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2003-1540": {"epss_score": 0.04324, "epss_percentile": 0.88551}, "CVE-2003-1541": {"epss_score": 0.05772, "epss_percentile": 0.90193}, "CVE-2003-1542": {"epss_score": 0.00171, "epss_percentile": 0.38785}, "CVE-2003-1543": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2003-1544": {"epss_score": 0.30177, "epss_percentile": 0.96516}, "CVE-2003-1545": {"epss_score": 0.04673, "epss_percentile": 0.88989}, "CVE-2003-1546": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2003-1547": {"epss_score": 0.00028, "epss_percentile": 0.0731}, "CVE-2003-1548": {"epss_score": 0.06423, "epss_percentile": 0.90751}, "CVE-2003-1549": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2003-1550": {"epss_score": 0.06202, "epss_percentile": 0.90561}, "CVE-2003-1551": {"epss_score": 0.00406, "epss_percentile": 0.60551}, "CVE-2003-1552": {"epss_score": 0.01314, "epss_percentile": 0.79397}, "CVE-2003-1553": {"epss_score": 0.02956, "epss_percentile": 0.86062}, "CVE-2003-1554": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2003-1555": {"epss_score": 0.04209, "epss_percentile": 0.88398}, "CVE-2003-1556": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2003-1557": {"epss_score": 0.10935, "epss_percentile": 0.93164}, "CVE-2003-1558": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2003-1559": {"epss_score": 0.39879, "epss_percentile": 0.97185}, "CVE-2003-1560": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2003-1561": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2003-1562": {"epss_score": 0.00802, "epss_percentile": 0.73585}, "CVE-2003-1563": {"epss_score": 0.00066, "epss_percentile": 0.20759}, "CVE-2003-1564": {"epss_score": 0.00531, "epss_percentile": 0.66661}, "CVE-2003-1566": {"epss_score": 0.09301, "epss_percentile": 0.9249}, "CVE-2003-1567": {"epss_score": 0.68993, "epss_percentile": 0.98572}, "CVE-2003-1568": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2003-1569": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2003-1570": {"epss_score": 0.00301, "epss_percentile": 0.53001}, "CVE-2003-1571": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2003-1572": {"epss_score": 0.00401, "epss_percentile": 0.60212}, "CVE-2003-1573": {"epss_score": 0.03443, "epss_percentile": 0.87144}, "CVE-2003-1574": {"epss_score": 0.0034, "epss_percentile": 0.56214}, "CVE-2003-1575": {"epss_score": 0.00051, "epss_percentile": 0.15984}, "CVE-2003-1576": {"epss_score": 0.04673, "epss_percentile": 0.88988}, "CVE-2003-1577": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2003-1578": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2003-1579": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2003-1580": {"epss_score": 0.01178, "epss_percentile": 0.78285}, "CVE-2003-1581": {"epss_score": 0.01975, "epss_percentile": 0.83119}, "CVE-2003-1582": {"epss_score": 0.04959, "epss_percentile": 0.89332}, "CVE-2003-1583": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2003-1584": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2003-1585": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2003-1586": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2003-1587": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2003-1588": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2003-1589": {"epss_score": 0.00361, "epss_percentile": 0.57725}, "CVE-2003-1590": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2003-1591": {"epss_score": 0.004, "epss_percentile": 0.60188}, "CVE-2003-1592": {"epss_score": 0.01435, "epss_percentile": 0.8027}, "CVE-2003-1593": {"epss_score": 0.00132, "epss_percentile": 0.33507}, "CVE-2003-1594": {"epss_score": 0.00132, "epss_percentile": 0.33507}, "CVE-2003-1595": {"epss_score": 0.00291, "epss_percentile": 0.52188}, "CVE-2003-1596": {"epss_score": 0.00108, "epss_percentile": 0.2989}, "CVE-2003-1598": {"epss_score": 0.01082, "epss_percentile": 0.77384}, "CVE-2003-1599": {"epss_score": 0.00913, "epss_percentile": 0.7537}, "CVE-2003-1603": {"epss_score": 0.00615, "epss_percentile": 0.69299}, "CVE-2003-1604": {"epss_score": 0.00652, "epss_percentile": 0.70309}, "CVE-2003-1605": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2003-20001": {"epss_score": 0.01454, "epss_percentile": 0.80383}, "CVE-2003-5001": {"epss_score": 0.00311, "epss_percentile": 0.53813}, "CVE-2003-5002": {"epss_score": 0.00097, "epss_percentile": 0.27631}, "CVE-2003-5003": {"epss_score": 0.00295, "epss_percentile": 0.52447}, "CVE-2004-0001": {"epss_score": 0.00075, "epss_percentile": 0.23051}, "CVE-2004-0002": {"epss_score": 0.01271, "epss_percentile": 0.79056}, "CVE-2004-0003": {"epss_score": 0.00093, "epss_percentile": 0.26751}, "CVE-2004-0004": {"epss_score": 0.00983, "epss_percentile": 0.76301}, "CVE-2004-0005": {"epss_score": 0.22285, "epss_percentile": 0.95619}, "CVE-2004-0006": {"epss_score": 0.17269, "epss_percentile": 0.94812}, "CVE-2004-0007": {"epss_score": 0.25332, "epss_percentile": 0.96014}, "CVE-2004-0008": {"epss_score": 0.19975, "epss_percentile": 0.95269}, "CVE-2004-0009": {"epss_score": 0.00748, "epss_percentile": 0.7259}, "CVE-2004-0010": {"epss_score": 0.0008, "epss_percentile": 0.24054}, "CVE-2004-0011": {"epss_score": 0.04255, "epss_percentile": 0.88457}, "CVE-2004-0013": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2004-0014": {"epss_score": 0.01602, "epss_percentile": 0.81273}, "CVE-2004-0015": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2004-0016": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2004-0017": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2004-0028": {"epss_score": 0.00962, "epss_percentile": 0.75995}, "CVE-2004-0029": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2004-0030": {"epss_score": 0.05382, "epss_percentile": 0.89811}, "CVE-2004-0031": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2004-0032": {"epss_score": 0.00739, "epss_percentile": 0.72358}, "CVE-2004-0033": {"epss_score": 0.0707, "epss_percentile": 0.91227}, "CVE-2004-0034": {"epss_score": 0.01069, "epss_percentile": 0.77251}, "CVE-2004-0035": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2004-0036": {"epss_score": 0.00401, "epss_percentile": 0.60255}, "CVE-2004-0037": {"epss_score": 0.01079, "epss_percentile": 0.77356}, "CVE-2004-0038": {"epss_score": 0.01782, "epss_percentile": 0.82244}, "CVE-2004-0039": {"epss_score": 0.4694, "epss_percentile": 0.97563}, "CVE-2004-0040": {"epss_score": 0.25884, "epss_percentile": 0.9609}, "CVE-2004-0041": {"epss_score": 0.00528, "epss_percentile": 0.6654}, "CVE-2004-0042": {"epss_score": 0.00497, "epss_percentile": 0.6519}, "CVE-2004-0043": {"epss_score": 0.03243, "epss_percentile": 0.86738}, "CVE-2004-0044": {"epss_score": 0.00883, "epss_percentile": 0.74922}, "CVE-2004-0045": {"epss_score": 0.35328, "epss_percentile": 0.96901}, "CVE-2004-0046": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2004-0047": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2004-0049": {"epss_score": 0.00781, "epss_percentile": 0.73182}, "CVE-2004-0050": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2004-0051": {"epss_score": 0.00341, "epss_percentile": 0.5634}, "CVE-2004-0052": {"epss_score": 0.00341, "epss_percentile": 0.5634}, "CVE-2004-0053": {"epss_score": 0.00341, "epss_percentile": 0.5634}, "CVE-2004-0054": {"epss_score": 0.04624, "epss_percentile": 0.88936}, "CVE-2004-0055": {"epss_score": 0.32375, "epss_percentile": 0.96693}, "CVE-2004-0056": {"epss_score": 0.05133, "epss_percentile": 0.89533}, "CVE-2004-0057": {"epss_score": 0.26203, "epss_percentile": 0.96123}, "CVE-2004-0058": {"epss_score": 0.00154, "epss_percentile": 0.36703}, "CVE-2004-0059": {"epss_score": 0.00585, "epss_percentile": 0.6841}, "CVE-2004-0060": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2004-0061": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-2004-0062": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2004-0063": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2004-0064": {"epss_score": 0.00169, "epss_percentile": 0.38533}, "CVE-2004-0065": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2004-0066": {"epss_score": 0.00496, "epss_percentile": 0.65138}, "CVE-2004-0067": {"epss_score": 0.0148, "epss_percentile": 0.80563}, "CVE-2004-0068": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2004-0069": {"epss_score": 0.08299, "epss_percentile": 0.91977}, "CVE-2004-0070": {"epss_score": 0.019, "epss_percentile": 0.82773}, "CVE-2004-0071": {"epss_score": 0.04718, "epss_percentile": 0.89046}, "CVE-2004-0072": {"epss_score": 0.04655, "epss_percentile": 0.8897}, "CVE-2004-0073": {"epss_score": 0.05383, "epss_percentile": 0.89813}, "CVE-2004-0074": {"epss_score": 0.00142, "epss_percentile": 0.34991}, "CVE-2004-0075": {"epss_score": 0.00074, "epss_percentile": 0.22837}, "CVE-2004-0077": {"epss_score": 0.00111, "epss_percentile": 0.30307}, "CVE-2004-0078": {"epss_score": 0.05662, "epss_percentile": 0.90097}, "CVE-2004-0079": {"epss_score": 0.02168, "epss_percentile": 0.83861}, "CVE-2004-0080": {"epss_score": 0.01609, "epss_percentile": 0.81319}, "CVE-2004-0081": {"epss_score": 0.02393, "epss_percentile": 0.84607}, "CVE-2004-0082": {"epss_score": 0.02082, "epss_percentile": 0.83538}, "CVE-2004-0083": {"epss_score": 0.02405, "epss_percentile": 0.84648}, "CVE-2004-0084": {"epss_score": 0.16273, "epss_percentile": 0.94609}, "CVE-2004-0085": {"epss_score": 0.00511, "epss_percentile": 0.65829}, "CVE-2004-0086": {"epss_score": 0.0055, "epss_percentile": 0.6735}, "CVE-2004-0087": {"epss_score": 0.00125, "epss_percentile": 0.32569}, "CVE-2004-0088": {"epss_score": 0.00121, "epss_percentile": 0.31947}, "CVE-2004-0089": {"epss_score": 0.00163, "epss_percentile": 0.37791}, "CVE-2004-0090": {"epss_score": 0.00417, "epss_percentile": 0.6126}, "CVE-2004-0091": {"epss_score": 0.00439, "epss_percentile": 0.62603}, "CVE-2004-0092": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-2004-0093": {"epss_score": 0.03041, "epss_percentile": 0.86274}, "CVE-2004-0094": {"epss_score": 0.03041, "epss_percentile": 0.86274}, "CVE-2004-0095": {"epss_score": 0.05986, "epss_percentile": 0.90383}, "CVE-2004-0096": {"epss_score": 0.02698, "epss_percentile": 0.85448}, "CVE-2004-0097": {"epss_score": 0.31882, "epss_percentile": 0.96657}, "CVE-2004-0099": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2004-0103": {"epss_score": 0.00086, "epss_percentile": 0.25364}, "CVE-2004-0104": {"epss_score": 0.49055, "epss_percentile": 0.97665}, "CVE-2004-0105": {"epss_score": 0.15958, "epss_percentile": 0.94543}, "CVE-2004-0106": {"epss_score": 0.00052, "epss_percentile": 0.16397}, "CVE-2004-0107": {"epss_score": 0.00073, "epss_percentile": 0.22538}, "CVE-2004-0108": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2004-0109": {"epss_score": 0.00159, "epss_percentile": 0.3737}, "CVE-2004-0110": {"epss_score": 0.42943, "epss_percentile": 0.97363}, "CVE-2004-0111": {"epss_score": 0.01347, "epss_percentile": 0.79654}, "CVE-2004-0112": {"epss_score": 0.00704, "epss_percentile": 0.7157}, "CVE-2004-0113": {"epss_score": 0.15723, "epss_percentile": 0.94493}, "CVE-2004-0114": {"epss_score": 0.0033, "epss_percentile": 0.55498}, "CVE-2004-0115": {"epss_score": 0.01083, "epss_percentile": 0.77389}, "CVE-2004-0116": {"epss_score": 0.54228, "epss_percentile": 0.97916}, "CVE-2004-0117": {"epss_score": 0.52469, "epss_percentile": 0.97827}, "CVE-2004-0118": {"epss_score": 0.12565, "epss_percentile": 0.93717}, "CVE-2004-0119": {"epss_score": 0.23155, "epss_percentile": 0.95742}, "CVE-2004-0120": {"epss_score": 0.8306, "epss_percentile": 0.9923}, "CVE-2004-0121": {"epss_score": 0.51468, "epss_percentile": 0.9778}, "CVE-2004-0122": {"epss_score": 0.32962, "epss_percentile": 0.96738}, "CVE-2004-0123": {"epss_score": 0.59111, "epss_percentile": 0.98149}, "CVE-2004-0124": {"epss_score": 0.49512, "epss_percentile": 0.97692}, "CVE-2004-0125": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2004-0126": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2004-0127": {"epss_score": 0.01237, "epss_percentile": 0.7878}, "CVE-2004-0128": {"epss_score": 0.09543, "epss_percentile": 0.9259}, "CVE-2004-0129": {"epss_score": 0.13292, "epss_percentile": 0.93924}, "CVE-2004-0130": {"epss_score": 0.00817, "epss_percentile": 0.73838}, "CVE-2004-0131": {"epss_score": 0.04342, "epss_percentile": 0.88572}, "CVE-2004-0132": {"epss_score": 0.01437, "epss_percentile": 0.80278}, "CVE-2004-0133": {"epss_score": 0.0009, "epss_percentile": 0.26148}, "CVE-2004-0134": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2004-0135": {"epss_score": 0.00061, "epss_percentile": 0.19306}, "CVE-2004-0136": {"epss_score": 0.0007, "epss_percentile": 0.21947}, "CVE-2004-0137": {"epss_score": 0.0007, "epss_percentile": 0.21947}, "CVE-2004-0138": {"epss_score": 0.00058, "epss_percentile": 0.1848}, "CVE-2004-0139": {"epss_score": 0.00432, "epss_percentile": 0.62114}, "CVE-2004-0143": {"epss_score": 0.01207, "epss_percentile": 0.7853}, "CVE-2004-0148": {"epss_score": 0.00033, "epss_percentile": 0.09201}, "CVE-2004-0149": {"epss_score": 0.00083, "epss_percentile": 0.24803}, "CVE-2004-0150": {"epss_score": 0.07895, "epss_percentile": 0.9175}, "CVE-2004-0151": {"epss_score": 0.0006, "epss_percentile": 0.1901}, "CVE-2004-0152": {"epss_score": 0.03422, "epss_percentile": 0.87106}, "CVE-2004-0153": {"epss_score": 0.02051, "epss_percentile": 0.83407}, "CVE-2004-0154": {"epss_score": 0.01044, "epss_percentile": 0.77004}, "CVE-2004-0155": {"epss_score": 0.05189, "epss_percentile": 0.89592}, "CVE-2004-0156": {"epss_score": 0.0165, "epss_percentile": 0.8156}, "CVE-2004-0157": {"epss_score": 0.00087, "epss_percentile": 0.25588}, "CVE-2004-0158": {"epss_score": 0.0026, "epss_percentile": 0.49185}, "CVE-2004-0159": {"epss_score": 0.10286, "epss_percentile": 0.92927}, "CVE-2004-0160": {"epss_score": 0.00054, "epss_percentile": 0.17179}, "CVE-2004-0161": {"epss_score": 0.00341, "epss_percentile": 0.5634}, "CVE-2004-0162": {"epss_score": 0.00341, "epss_percentile": 0.5634}, "CVE-2004-0163": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-0164": {"epss_score": 0.12688, "epss_percentile": 0.9375}, "CVE-2004-0165": {"epss_score": 0.01781, "epss_percentile": 0.82238}, "CVE-2004-0166": {"epss_score": 0.00645, "epss_percentile": 0.70125}, "CVE-2004-0167": {"epss_score": 0.01332, "epss_percentile": 0.79521}, "CVE-2004-0168": {"epss_score": 0.01221, "epss_percentile": 0.78649}, "CVE-2004-0169": {"epss_score": 0.01913, "epss_percentile": 0.82841}, "CVE-2004-0171": {"epss_score": 0.01419, "epss_percentile": 0.80161}, "CVE-2004-0172": {"epss_score": 0.00054, "epss_percentile": 0.17135}, "CVE-2004-0173": {"epss_score": 0.44933, "epss_percentile": 0.97461}, "CVE-2004-0174": {"epss_score": 0.1992, "epss_percentile": 0.95261}, "CVE-2004-0175": {"epss_score": 0.00306, "epss_percentile": 0.534}, "CVE-2004-0176": {"epss_score": 0.71048, "epss_percentile": 0.98651}, "CVE-2004-0177": {"epss_score": 0.01766, "epss_percentile": 0.8217}, "CVE-2004-0178": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2004-0179": {"epss_score": 0.08143, "epss_percentile": 0.919}, "CVE-2004-0180": {"epss_score": 0.04165, "epss_percentile": 0.88341}, "CVE-2004-0181": {"epss_score": 0.00094, "epss_percentile": 0.26784}, "CVE-2004-0182": {"epss_score": 0.0057, "epss_percentile": 0.6797}, "CVE-2004-0183": {"epss_score": 0.30156, "epss_percentile": 0.96515}, "CVE-2004-0184": {"epss_score": 0.65309, "epss_percentile": 0.98412}, "CVE-2004-0185": {"epss_score": 0.08591, "epss_percentile": 0.92139}, "CVE-2004-0186": {"epss_score": 0.00525, "epss_percentile": 0.66381}, "CVE-2004-0188": {"epss_score": 0.00054, "epss_percentile": 0.17135}, "CVE-2004-0189": {"epss_score": 0.05083, "epss_percentile": 0.89475}, "CVE-2004-0190": {"epss_score": 0.00749, "epss_percentile": 0.72607}, "CVE-2004-0191": {"epss_score": 0.01816, "epss_percentile": 0.82393}, "CVE-2004-0192": {"epss_score": 0.00534, "epss_percentile": 0.6679}, "CVE-2004-0193": {"epss_score": 0.28449, "epss_percentile": 0.96358}, "CVE-2004-0194": {"epss_score": 0.18002, "epss_percentile": 0.94942}, "CVE-2004-0197": {"epss_score": 0.28742, "epss_percentile": 0.9638}, "CVE-2004-0199": {"epss_score": 0.39025, "epss_percentile": 0.97135}, "CVE-2004-0200": {"epss_score": 0.76686, "epss_percentile": 0.98901}, "CVE-2004-0201": {"epss_score": 0.45244, "epss_percentile": 0.97478}, "CVE-2004-0202": {"epss_score": 0.3229, "epss_percentile": 0.96686}, "CVE-2004-0203": {"epss_score": 0.25669, "epss_percentile": 0.96055}, "CVE-2004-0204": {"epss_score": 0.77622, "epss_percentile": 0.98944}, "CVE-2004-0205": {"epss_score": 0.05723, "epss_percentile": 0.90154}, "CVE-2004-0206": {"epss_score": 0.80399, "epss_percentile": 0.99086}, "CVE-2004-0207": {"epss_score": 0.03343, "epss_percentile": 0.86946}, "CVE-2004-0208": {"epss_score": 0.02765, "epss_percentile": 0.8561}, "CVE-2004-0209": {"epss_score": 0.78535, "epss_percentile": 0.98991}, "CVE-2004-0210": {"epss_score": 0.02519, "epss_percentile": 0.84996}, "CVE-2004-0211": {"epss_score": 0.0216, "epss_percentile": 0.83824}, "CVE-2004-0212": {"epss_score": 0.78952, "epss_percentile": 0.99013}, "CVE-2004-0213": {"epss_score": 0.02178, "epss_percentile": 0.83889}, "CVE-2004-0214": {"epss_score": 0.7666, "epss_percentile": 0.989}, "CVE-2004-0215": {"epss_score": 0.44462, "epss_percentile": 0.97439}, "CVE-2004-0216": {"epss_score": 0.54874, "epss_percentile": 0.97948}, "CVE-2004-0217": {"epss_score": 0.00134, "epss_percentile": 0.33818}, "CVE-2004-0218": {"epss_score": 0.0299, "epss_percentile": 0.86142}, "CVE-2004-0219": {"epss_score": 0.01327, "epss_percentile": 0.79493}, "CVE-2004-0220": {"epss_score": 0.03664, "epss_percentile": 0.87532}, "CVE-2004-0221": {"epss_score": 0.01734, "epss_percentile": 0.82003}, "CVE-2004-0222": {"epss_score": 0.01811, "epss_percentile": 0.82368}, "CVE-2004-0224": {"epss_score": 0.03685, "epss_percentile": 0.87569}, "CVE-2004-0226": {"epss_score": 0.01177, "epss_percentile": 0.78276}, "CVE-2004-0227": {"epss_score": 0.03422, "epss_percentile": 0.87106}, "CVE-2004-0228": {"epss_score": 0.00193, "epss_percentile": 0.41443}, "CVE-2004-0229": {"epss_score": 0.00081, "epss_percentile": 0.24243}, "CVE-2004-0230": {"epss_score": 0.09318, "epss_percentile": 0.92498}, "CVE-2004-0231": {"epss_score": 0.00131, "epss_percentile": 0.33493}, "CVE-2004-0232": {"epss_score": 0.01032, "epss_percentile": 0.7686}, "CVE-2004-0233": {"epss_score": 0.00213, "epss_percentile": 0.43836}, "CVE-2004-0234": {"epss_score": 0.08482, "epss_percentile": 0.92074}, "CVE-2004-0235": {"epss_score": 0.10498, "epss_percentile": 0.9301}, "CVE-2004-0236": {"epss_score": 0.01203, "epss_percentile": 0.78496}, "CVE-2004-0237": {"epss_score": 0.04669, "epss_percentile": 0.88985}, "CVE-2004-0238": {"epss_score": 0.00294, "epss_percentile": 0.52372}, "CVE-2004-0239": {"epss_score": 0.0038, "epss_percentile": 0.5894}, "CVE-2004-0240": {"epss_score": 0.02736, "epss_percentile": 0.8555}, "CVE-2004-0241": {"epss_score": 0.10297, "epss_percentile": 0.92933}, "CVE-2004-0242": {"epss_score": 0.04264, "epss_percentile": 0.88467}, "CVE-2004-0243": {"epss_score": 0.01087, "epss_percentile": 0.77426}, "CVE-2004-0244": {"epss_score": 0.01204, "epss_percentile": 0.78505}, "CVE-2004-0245": {"epss_score": 0.04457, "epss_percentile": 0.88713}, "CVE-2004-0246": {"epss_score": 0.01438, "epss_percentile": 0.80286}, "CVE-2004-0247": {"epss_score": 0.06878, "epss_percentile": 0.91087}, "CVE-2004-0248": {"epss_score": 0.01261, "epss_percentile": 0.78975}, "CVE-2004-0249": {"epss_score": 0.05662, "epss_percentile": 0.90097}, "CVE-2004-0250": {"epss_score": 0.01438, "epss_percentile": 0.80289}, "CVE-2004-0251": {"epss_score": 0.05891, "epss_percentile": 0.90299}, "CVE-2004-0252": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2004-0253": {"epss_score": 0.00477, "epss_percentile": 0.6433}, "CVE-2004-0254": {"epss_score": 0.02503, "epss_percentile": 0.84928}, "CVE-2004-0255": {"epss_score": 0.04656, "epss_percentile": 0.88973}, "CVE-2004-0256": {"epss_score": 0.00098, "epss_percentile": 0.27781}, "CVE-2004-0257": {"epss_score": 0.02029, "epss_percentile": 0.83327}, "CVE-2004-0258": {"epss_score": 0.2677, "epss_percentile": 0.96178}, "CVE-2004-0259": {"epss_score": 0.00674, "epss_percentile": 0.70876}, "CVE-2004-0260": {"epss_score": 0.00563, "epss_percentile": 0.6774}, "CVE-2004-0261": {"epss_score": 0.08662, "epss_percentile": 0.92176}, "CVE-2004-0262": {"epss_score": 0.05704, "epss_percentile": 0.90136}, "CVE-2004-0263": {"epss_score": 0.0108, "epss_percentile": 0.77364}, "CVE-2004-0264": {"epss_score": 0.05816, "epss_percentile": 0.90232}, "CVE-2004-0265": {"epss_score": 0.10468, "epss_percentile": 0.92996}, "CVE-2004-0266": {"epss_score": 0.00026, "epss_percentile": 0.0652}, "CVE-2004-0267": {"epss_score": 0.0018, "epss_percentile": 0.39988}, "CVE-2004-0268": {"epss_score": 0.04823, "epss_percentile": 0.89181}, "CVE-2004-0269": {"epss_score": 0.00102, "epss_percentile": 0.28821}, "CVE-2004-0270": {"epss_score": 0.11105, "epss_percentile": 0.93221}, "CVE-2004-0271": {"epss_score": 0.04271, "epss_percentile": 0.88476}, "CVE-2004-0272": {"epss_score": 0.0069, "epss_percentile": 0.7124}, "CVE-2004-0273": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2004-0274": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2004-0275": {"epss_score": 0.0047, "epss_percentile": 0.63987}, "CVE-2004-0276": {"epss_score": 0.09341, "epss_percentile": 0.92508}, "CVE-2004-0277": {"epss_score": 0.08066, "epss_percentile": 0.91864}, "CVE-2004-0278": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2004-0279": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2004-0280": {"epss_score": 0.00662, "epss_percentile": 0.70598}, "CVE-2004-0281": {"epss_score": 0.13388, "epss_percentile": 0.93949}, "CVE-2004-0282": {"epss_score": 0.04311, "epss_percentile": 0.88532}, "CVE-2004-0283": {"epss_score": 0.00121, "epss_percentile": 0.31947}, "CVE-2004-0284": {"epss_score": 0.08624, "epss_percentile": 0.92159}, "CVE-2004-0285": {"epss_score": 0.29934, "epss_percentile": 0.96486}, "CVE-2004-0286": {"epss_score": 0.11653, "epss_percentile": 0.93435}, "CVE-2004-0287": {"epss_score": 0.04128, "epss_percentile": 0.88292}, "CVE-2004-0288": {"epss_score": 0.0517, "epss_percentile": 0.89568}, "CVE-2004-0289": {"epss_score": 0.00062, "epss_percentile": 0.19638}, "CVE-2004-0290": {"epss_score": 0.05726, "epss_percentile": 0.90157}, "CVE-2004-0291": {"epss_score": 0.00372, "epss_percentile": 0.58441}, "CVE-2004-0292": {"epss_score": 0.0986, "epss_percentile": 0.9274}, "CVE-2004-0293": {"epss_score": 0.04864, "epss_percentile": 0.89224}, "CVE-2004-0294": {"epss_score": 0.0205, "epss_percentile": 0.83399}, "CVE-2004-0295": {"epss_score": 0.04891, "epss_percentile": 0.89263}, "CVE-2004-0296": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2004-0297": {"epss_score": 0.56961, "epss_percentile": 0.98041}, "CVE-2004-0298": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2004-0299": {"epss_score": 0.00228, "epss_percentile": 0.45497}, "CVE-2004-0300": {"epss_score": 0.02785, "epss_percentile": 0.85657}, "CVE-2004-0301": {"epss_score": 0.00834, "epss_percentile": 0.74112}, "CVE-2004-0302": {"epss_score": 0.03541, "epss_percentile": 0.87318}, "CVE-2004-0303": {"epss_score": 0.08931, "epss_percentile": 0.92325}, "CVE-2004-0304": {"epss_score": 0.0148, "epss_percentile": 0.80562}, "CVE-2004-0305": {"epss_score": 0.04426, "epss_percentile": 0.88674}, "CVE-2004-0306": {"epss_score": 0.00412, "epss_percentile": 0.60927}, "CVE-2004-0307": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2004-0308": {"epss_score": 0.00417, "epss_percentile": 0.6126}, "CVE-2004-0309": {"epss_score": 0.2669, "epss_percentile": 0.96166}, "CVE-2004-0310": {"epss_score": 0.00828, "epss_percentile": 0.74006}, "CVE-2004-0311": {"epss_score": 0.01543, "epss_percentile": 0.80953}, "CVE-2004-0312": {"epss_score": 0.03832, "epss_percentile": 0.87811}, "CVE-2004-0313": {"epss_score": 0.77835, "epss_percentile": 0.98956}, "CVE-2004-0314": {"epss_score": 0.00314, "epss_percentile": 0.54107}, "CVE-2004-0315": {"epss_score": 0.03181, "epss_percentile": 0.86578}, "CVE-2004-0316": {"epss_score": 0.01011, "epss_percentile": 0.76617}, "CVE-2004-0317": {"epss_score": 0.0284, "epss_percentile": 0.85804}, "CVE-2004-0318": {"epss_score": 0.03512, "epss_percentile": 0.87268}, "CVE-2004-0319": {"epss_score": 0.02503, "epss_percentile": 0.84928}, "CVE-2004-0320": {"epss_score": 0.00071, "epss_percentile": 0.22167}, "CVE-2004-0321": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2004-0322": {"epss_score": 0.01046, "epss_percentile": 0.7703}, "CVE-2004-0323": {"epss_score": 0.00842, "epss_percentile": 0.74238}, "CVE-2004-0324": {"epss_score": 0.01922, "epss_percentile": 0.82903}, "CVE-2004-0325": {"epss_score": 0.01172, "epss_percentile": 0.78225}, "CVE-2004-0326": {"epss_score": 0.79778, "epss_percentile": 0.99055}, "CVE-2004-0327": {"epss_score": 0.0427, "epss_percentile": 0.88473}, "CVE-2004-0328": {"epss_score": 0.00055, "epss_percentile": 0.17623}, "CVE-2004-0329": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2004-0330": {"epss_score": 0.83139, "epss_percentile": 0.99233}, "CVE-2004-0331": {"epss_score": 0.67532, "epss_percentile": 0.98511}, "CVE-2004-0332": {"epss_score": 0.00902, "epss_percentile": 0.7519}, "CVE-2004-0333": {"epss_score": 0.65353, "epss_percentile": 0.98415}, "CVE-2004-0334": {"epss_score": 0.00426, "epss_percentile": 0.61749}, "CVE-2004-0335": {"epss_score": 0.00512, "epss_percentile": 0.65857}, "CVE-2004-0336": {"epss_score": 0.00421, "epss_percentile": 0.61534}, "CVE-2004-0337": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2004-0338": {"epss_score": 0.00423, "epss_percentile": 0.61579}, "CVE-2004-0339": {"epss_score": 0.00828, "epss_percentile": 0.74006}, "CVE-2004-0340": {"epss_score": 0.00142, "epss_percentile": 0.34992}, "CVE-2004-0341": {"epss_score": 0.00147, "epss_percentile": 0.35682}, "CVE-2004-0342": {"epss_score": 0.00137, "epss_percentile": 0.34287}, "CVE-2004-0343": {"epss_score": 0.00379, "epss_percentile": 0.58894}, "CVE-2004-0344": {"epss_score": 0.02863, "epss_percentile": 0.85856}, "CVE-2004-0345": {"epss_score": 0.05378, "epss_percentile": 0.89806}, "CVE-2004-0346": {"epss_score": 0.00043, "epss_percentile": 0.13183}, "CVE-2004-0347": {"epss_score": 0.01783, "epss_percentile": 0.82247}, "CVE-2004-0348": {"epss_score": 0.00561, "epss_percentile": 0.67658}, "CVE-2004-0349": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2004-0350": {"epss_score": 0.00111, "epss_percentile": 0.30371}, "CVE-2004-0351": {"epss_score": 0.00092, "epss_percentile": 0.26444}, "CVE-2004-0352": {"epss_score": 0.00807, "epss_percentile": 0.73667}, "CVE-2004-0353": {"epss_score": 0.0404, "epss_percentile": 0.88165}, "CVE-2004-0354": {"epss_score": 0.06237, "epss_percentile": 0.9059}, "CVE-2004-0355": {"epss_score": 0.00624, "epss_percentile": 0.69568}, "CVE-2004-0356": {"epss_score": 0.07566, "epss_percentile": 0.91544}, "CVE-2004-0357": {"epss_score": 0.05868, "epss_percentile": 0.90277}, "CVE-2004-0358": {"epss_score": 0.00615, "epss_percentile": 0.69313}, "CVE-2004-0359": {"epss_score": 0.01858, "epss_percentile": 0.82578}, "CVE-2004-0360": {"epss_score": 0.00303, "epss_percentile": 0.53176}, "CVE-2004-0361": {"epss_score": 0.05875, "epss_percentile": 0.90285}, "CVE-2004-0362": {"epss_score": 0.83404, "epss_percentile": 0.99247}, "CVE-2004-0363": {"epss_score": 0.72679, "epss_percentile": 0.98722}, "CVE-2004-0364": {"epss_score": 0.03034, "epss_percentile": 0.86255}, "CVE-2004-0365": {"epss_score": 0.30858, "epss_percentile": 0.96572}, "CVE-2004-0366": {"epss_score": 0.00563, "epss_percentile": 0.67721}, "CVE-2004-0367": {"epss_score": 0.09213, "epss_percentile": 0.92451}, "CVE-2004-0368": {"epss_score": 0.5918, "epss_percentile": 0.98153}, "CVE-2004-0369": {"epss_score": 0.08501, "epss_percentile": 0.92086}, "CVE-2004-0370": {"epss_score": 0.00117, "epss_percentile": 0.31327}, "CVE-2004-0371": {"epss_score": 0.00926, "epss_percentile": 0.75548}, "CVE-2004-0372": {"epss_score": 0.0014, "epss_percentile": 0.34779}, "CVE-2004-0374": {"epss_score": 0.08308, "epss_percentile": 0.91983}, "CVE-2004-0375": {"epss_score": 0.10998, "epss_percentile": 0.93186}, "CVE-2004-0376": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-0377": {"epss_score": 0.14668, "epss_percentile": 0.9426}, "CVE-2004-0379": {"epss_score": 0.08345, "epss_percentile": 0.92001}, "CVE-2004-0380": {"epss_score": 0.81042, "epss_percentile": 0.99117}, "CVE-2004-0381": {"epss_score": 0.00132, "epss_percentile": 0.33507}, "CVE-2004-0382": {"epss_score": 0.00073, "epss_percentile": 0.22483}, "CVE-2004-0383": {"epss_score": 0.00073, "epss_percentile": 0.22483}, "CVE-2004-0385": {"epss_score": 0.44246, "epss_percentile": 0.97426}, "CVE-2004-0386": {"epss_score": 0.36771, "epss_percentile": 0.97}, "CVE-2004-0387": {"epss_score": 0.06287, "epss_percentile": 0.90645}, "CVE-2004-0388": {"epss_score": 0.0011, "epss_percentile": 0.30078}, "CVE-2004-0389": {"epss_score": 0.08061, "epss_percentile": 0.9186}, "CVE-2004-0390": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2004-0391": {"epss_score": 0.00798, "epss_percentile": 0.73517}, "CVE-2004-0392": {"epss_score": 0.00928, "epss_percentile": 0.75578}, "CVE-2004-0393": {"epss_score": 0.14629, "epss_percentile": 0.94254}, "CVE-2004-0394": {"epss_score": 0.00155, "epss_percentile": 0.36878}, "CVE-2004-0395": {"epss_score": 0.00063, "epss_percentile": 0.20095}, "CVE-2004-0396": {"epss_score": 0.86787, "epss_percentile": 0.99396}, "CVE-2004-0397": {"epss_score": 0.86588, "epss_percentile": 0.99389}, "CVE-2004-0398": {"epss_score": 0.04803, "epss_percentile": 0.89159}, "CVE-2004-0399": {"epss_score": 0.42079, "epss_percentile": 0.97311}, "CVE-2004-0400": {"epss_score": 0.06391, "epss_percentile": 0.90718}, "CVE-2004-0401": {"epss_score": 0.00864, "epss_percentile": 0.74612}, "CVE-2004-0402": {"epss_score": 0.00098, "epss_percentile": 0.2773}, "CVE-2004-0403": {"epss_score": 0.13257, "epss_percentile": 0.93916}, "CVE-2004-0404": {"epss_score": 0.00076, "epss_percentile": 0.23162}, "CVE-2004-0405": {"epss_score": 0.01406, "epss_percentile": 0.80052}, "CVE-2004-0407": {"epss_score": 0.03852, "epss_percentile": 0.87851}, "CVE-2004-0408": {"epss_score": 0.03422, "epss_percentile": 0.87106}, "CVE-2004-0409": {"epss_score": 0.26772, "epss_percentile": 0.96179}, "CVE-2004-0411": {"epss_score": 0.06491, "epss_percentile": 0.90795}, "CVE-2004-0412": {"epss_score": 0.0264, "epss_percentile": 0.85301}, "CVE-2004-0413": {"epss_score": 0.10823, "epss_percentile": 0.93123}, "CVE-2004-0414": {"epss_score": 0.05252, "epss_percentile": 0.89664}, "CVE-2004-0415": {"epss_score": 0.00299, "epss_percentile": 0.52854}, "CVE-2004-0416": {"epss_score": 0.43031, "epss_percentile": 0.97367}, "CVE-2004-0417": {"epss_score": 0.04491, "epss_percentile": 0.88757}, "CVE-2004-0418": {"epss_score": 0.14279, "epss_percentile": 0.94178}, "CVE-2004-0419": {"epss_score": 0.02796, "epss_percentile": 0.85681}, "CVE-2004-0420": {"epss_score": 0.4754, "epss_percentile": 0.97591}, "CVE-2004-0421": {"epss_score": 0.0183, "epss_percentile": 0.82446}, "CVE-2004-0422": {"epss_score": 0.00084, "epss_percentile": 0.25015}, "CVE-2004-0423": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2004-0424": {"epss_score": 0.00243, "epss_percentile": 0.47469}, "CVE-2004-0425": {"epss_score": 0.0532, "epss_percentile": 0.89727}, "CVE-2004-0426": {"epss_score": 0.03446, "epss_percentile": 0.87148}, "CVE-2004-0427": {"epss_score": 0.00164, "epss_percentile": 0.3791}, "CVE-2004-0428": {"epss_score": 0.00666, "epss_percentile": 0.70678}, "CVE-2004-0429": {"epss_score": 0.0064, "epss_percentile": 0.69962}, "CVE-2004-0430": {"epss_score": 0.80742, "epss_percentile": 0.99102}, "CVE-2004-0431": {"epss_score": 0.00955, "epss_percentile": 0.7592}, "CVE-2004-0432": {"epss_score": 0.01235, "epss_percentile": 0.78763}, "CVE-2004-0433": {"epss_score": 0.03088, "epss_percentile": 0.86391}, "CVE-2004-0434": {"epss_score": 0.22372, "epss_percentile": 0.95627}, "CVE-2004-0435": {"epss_score": 0.00081, "epss_percentile": 0.24351}, "CVE-2004-0437": {"epss_score": 0.00626, "epss_percentile": 0.69606}, "CVE-2004-0444": {"epss_score": 0.58001, "epss_percentile": 0.98094}, "CVE-2004-0445": {"epss_score": 0.35047, "epss_percentile": 0.96885}, "CVE-2004-0447": {"epss_score": 0.00045, "epss_percentile": 0.13823}, "CVE-2004-0448": {"epss_score": 0.02459, "epss_percentile": 0.84819}, "CVE-2004-0450": {"epss_score": 0.08975, "epss_percentile": 0.92346}, "CVE-2004-0451": {"epss_score": 0.03657, "epss_percentile": 0.87519}, "CVE-2004-0452": {"epss_score": 0.00052, "epss_percentile": 0.1648}, "CVE-2004-0453": {"epss_score": 0.00073, "epss_percentile": 0.22619}, "CVE-2004-0454": {"epss_score": 0.00067, "epss_percentile": 0.21114}, "CVE-2004-0455": {"epss_score": 0.00135, "epss_percentile": 0.34006}, "CVE-2004-0456": {"epss_score": 0.01293, "epss_percentile": 0.79236}, "CVE-2004-0457": {"epss_score": 0.00109, "epss_percentile": 0.2992}, "CVE-2004-0458": {"epss_score": 0.02153, "epss_percentile": 0.83794}, "CVE-2004-0459": {"epss_score": 0.04202, "epss_percentile": 0.88388}, "CVE-2004-0460": {"epss_score": 0.63054, "epss_percentile": 0.98318}, "CVE-2004-0461": {"epss_score": 0.09739, "epss_percentile": 0.92682}, "CVE-2004-0462": {"epss_score": 0.00227, "epss_percentile": 0.45397}, "CVE-2004-0465": {"epss_score": 0.22387, "epss_percentile": 0.95629}, "CVE-2004-0466": {"epss_score": 0.08687, "epss_percentile": 0.92202}, "CVE-2004-0467": {"epss_score": 0.05783, "epss_percentile": 0.90204}, "CVE-2004-0468": {"epss_score": 0.00997, "epss_percentile": 0.76461}, "CVE-2004-0469": {"epss_score": 0.06452, "epss_percentile": 0.90765}, "CVE-2004-0470": {"epss_score": 0.02326, "epss_percentile": 0.84391}, "CVE-2004-0471": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2004-0473": {"epss_score": 0.01138, "epss_percentile": 0.7793}, "CVE-2004-0474": {"epss_score": 0.18608, "epss_percentile": 0.95042}, "CVE-2004-0475": {"epss_score": 0.09895, "epss_percentile": 0.92759}, "CVE-2004-0476": {"epss_score": 0.00832, "epss_percentile": 0.74066}, "CVE-2004-0477": {"epss_score": 0.00314, "epss_percentile": 0.54108}, "CVE-2004-0478": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-0479": {"epss_score": 0.21829, "epss_percentile": 0.95564}, "CVE-2004-0480": {"epss_score": 0.19495, "epss_percentile": 0.95192}, "CVE-2004-0481": {"epss_score": 0.00054, "epss_percentile": 0.17204}, "CVE-2004-0482": {"epss_score": 0.00087, "epss_percentile": 0.2553}, "CVE-2004-0483": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-0484": {"epss_score": 0.26837, "epss_percentile": 0.96185}, "CVE-2004-0485": {"epss_score": 0.01762, "epss_percentile": 0.82153}, "CVE-2004-0486": {"epss_score": 0.12433, "epss_percentile": 0.93668}, "CVE-2004-0487": {"epss_score": 0.16484, "epss_percentile": 0.94678}, "CVE-2004-0488": {"epss_score": 0.62663, "epss_percentile": 0.98301}, "CVE-2004-0489": {"epss_score": 0.14294, "epss_percentile": 0.9418}, "CVE-2004-0490": {"epss_score": 0.00819, "epss_percentile": 0.73868}, "CVE-2004-0491": {"epss_score": 0.00108, "epss_percentile": 0.29799}, "CVE-2004-0492": {"epss_score": 0.21037, "epss_percentile": 0.95455}, "CVE-2004-0493": {"epss_score": 0.89495, "epss_percentile": 0.99529}, "CVE-2004-0494": {"epss_score": 0.00855, "epss_percentile": 0.74463}, "CVE-2004-0495": {"epss_score": 0.00056, "epss_percentile": 0.17962}, "CVE-2004-0496": {"epss_score": 0.0006, "epss_percentile": 0.19001}, "CVE-2004-0497": {"epss_score": 0.00293, "epss_percentile": 0.5233}, "CVE-2004-0498": {"epss_score": 0.0057, "epss_percentile": 0.6797}, "CVE-2004-0500": {"epss_score": 0.03264, "epss_percentile": 0.86779}, "CVE-2004-0501": {"epss_score": 0.53567, "epss_percentile": 0.97882}, "CVE-2004-0502": {"epss_score": 0.53567, "epss_percentile": 0.97882}, "CVE-2004-0503": {"epss_score": 0.1868, "epss_percentile": 0.95051}, "CVE-2004-0504": {"epss_score": 0.0378, "epss_percentile": 0.87719}, "CVE-2004-0505": {"epss_score": 0.03072, "epss_percentile": 0.86351}, "CVE-2004-0506": {"epss_score": 0.0371, "epss_percentile": 0.87604}, "CVE-2004-0507": {"epss_score": 0.03018, "epss_percentile": 0.86219}, "CVE-2004-0510": {"epss_score": 0.00535, "epss_percentile": 0.66803}, "CVE-2004-0511": {"epss_score": 0.02148, "epss_percentile": 0.83772}, "CVE-2004-0512": {"epss_score": 0.0007, "epss_percentile": 0.21978}, "CVE-2004-0513": {"epss_score": 0.00504, "epss_percentile": 0.65484}, "CVE-2004-0514": {"epss_score": 0.00057, "epss_percentile": 0.18097}, "CVE-2004-0515": {"epss_score": 0.00077, "epss_percentile": 0.23297}, "CVE-2004-0516": {"epss_score": 0.00077, "epss_percentile": 0.23297}, "CVE-2004-0517": {"epss_score": 0.00077, "epss_percentile": 0.23297}, "CVE-2004-0518": {"epss_score": 0.00552, "epss_percentile": 0.67387}, "CVE-2004-0519": {"epss_score": 0.00124, "epss_percentile": 0.32417}, "CVE-2004-0520": {"epss_score": 0.14932, "epss_percentile": 0.94327}, "CVE-2004-0521": {"epss_score": 0.04651, "epss_percentile": 0.88965}, "CVE-2004-0522": {"epss_score": 0.00545, "epss_percentile": 0.67165}, "CVE-2004-0523": {"epss_score": 0.13596, "epss_percentile": 0.94007}, "CVE-2004-0524": {"epss_score": 0.03726, "epss_percentile": 0.87633}, "CVE-2004-0525": {"epss_score": 0.008, "epss_percentile": 0.73558}, "CVE-2004-0526": {"epss_score": 0.52263, "epss_percentile": 0.97815}, "CVE-2004-0527": {"epss_score": 0.02828, "epss_percentile": 0.85769}, "CVE-2004-0528": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2004-0529": {"epss_score": 0.00553, "epss_percentile": 0.67408}, "CVE-2004-0530": {"epss_score": 0.00059, "epss_percentile": 0.18846}, "CVE-2004-0533": {"epss_score": 0.00205, "epss_percentile": 0.42699}, "CVE-2004-0534": {"epss_score": 0.00547, "epss_percentile": 0.67246}, "CVE-2004-0535": {"epss_score": 0.0009, "epss_percentile": 0.26149}, "CVE-2004-0536": {"epss_score": 0.00085, "epss_percentile": 0.25062}, "CVE-2004-0537": {"epss_score": 0.00651, "epss_percentile": 0.70286}, "CVE-2004-0538": {"epss_score": 0.00893, "epss_percentile": 0.75076}, "CVE-2004-0539": {"epss_score": 0.01144, "epss_percentile": 0.77989}, "CVE-2004-0540": {"epss_score": 0.18101, "epss_percentile": 0.94957}, "CVE-2004-0541": {"epss_score": 0.78284, "epss_percentile": 0.98977}, "CVE-2004-0542": {"epss_score": 0.11601, "epss_percentile": 0.93416}, "CVE-2004-0543": {"epss_score": 0.06033, "epss_percentile": 0.90424}, "CVE-2004-0544": {"epss_score": 0.00701, "epss_percentile": 0.71495}, "CVE-2004-0545": {"epss_score": 0.0005, "epss_percentile": 0.15824}, "CVE-2004-0547": {"epss_score": 0.00806, "epss_percentile": 0.73655}, "CVE-2004-0548": {"epss_score": 0.00184, "epss_percentile": 0.40431}, "CVE-2004-0549": {"epss_score": 0.71697, "epss_percentile": 0.98678}, "CVE-2004-0550": {"epss_score": 0.0328, "epss_percentile": 0.86815}, "CVE-2004-0551": {"epss_score": 0.00795, "epss_percentile": 0.73462}, "CVE-2004-0552": {"epss_score": 0.16369, "epss_percentile": 0.94637}, "CVE-2004-0554": {"epss_score": 0.00755, "epss_percentile": 0.72722}, "CVE-2004-0555": {"epss_score": 0.03422, "epss_percentile": 0.87106}, "CVE-2004-0557": {"epss_score": 0.4451, "epss_percentile": 0.97441}, "CVE-2004-0558": {"epss_score": 0.08769, "epss_percentile": 0.92247}, "CVE-2004-0559": {"epss_score": 0.00072, "epss_percentile": 0.22365}, "CVE-2004-0560": {"epss_score": 0.01965, "epss_percentile": 0.83078}, "CVE-2004-0561": {"epss_score": 0.01965, "epss_percentile": 0.83078}, "CVE-2004-0563": {"epss_score": 0.00048, "epss_percentile": 0.1505}, "CVE-2004-0564": {"epss_score": 0.00072, "epss_percentile": 0.22419}, "CVE-2004-0565": {"epss_score": 0.00074, "epss_percentile": 0.22832}, "CVE-2004-0566": {"epss_score": 0.57434, "epss_percentile": 0.98062}, "CVE-2004-0567": {"epss_score": 0.60552, "epss_percentile": 0.9821}, "CVE-2004-0568": {"epss_score": 0.26882, "epss_percentile": 0.96188}, "CVE-2004-0569": {"epss_score": 0.21, "epss_percentile": 0.95449}, "CVE-2004-0571": {"epss_score": 0.2584, "epss_percentile": 0.96077}, "CVE-2004-0572": {"epss_score": 0.59215, "epss_percentile": 0.98155}, "CVE-2004-0573": {"epss_score": 0.40534, "epss_percentile": 0.97222}, "CVE-2004-0574": {"epss_score": 0.85365, "epss_percentile": 0.99331}, "CVE-2004-0575": {"epss_score": 0.72439, "epss_percentile": 0.98708}, "CVE-2004-0576": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-0577": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2004-0578": {"epss_score": 0.0076, "epss_percentile": 0.72801}, "CVE-2004-0579": {"epss_score": 0.0007, "epss_percentile": 0.21769}, "CVE-2004-0580": {"epss_score": 0.07648, "epss_percentile": 0.91602}, "CVE-2004-0581": {"epss_score": 0.00079, "epss_percentile": 0.2391}, "CVE-2004-0582": {"epss_score": 0.00857, "epss_percentile": 0.74496}, "CVE-2004-0583": {"epss_score": 0.01116, "epss_percentile": 0.77721}, "CVE-2004-0584": {"epss_score": 0.01052, "epss_percentile": 0.77093}, "CVE-2004-0586": {"epss_score": 0.05622, "epss_percentile": 0.90062}, "CVE-2004-0587": {"epss_score": 0.00046, "epss_percentile": 0.14106}, "CVE-2004-0588": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2004-0589": {"epss_score": 0.01669, "epss_percentile": 0.81666}, "CVE-2004-0590": {"epss_score": 0.00579, "epss_percentile": 0.68227}, "CVE-2004-0591": {"epss_score": 0.13907, "epss_percentile": 0.9409}, "CVE-2004-0592": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-0593": {"epss_score": 0.00532, "epss_percentile": 0.66675}, "CVE-2004-0594": {"epss_score": 0.77733, "epss_percentile": 0.9895}, "CVE-2004-0595": {"epss_score": 0.54875, "epss_percentile": 0.97948}, "CVE-2004-0596": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2004-0597": {"epss_score": 0.85086, "epss_percentile": 0.99317}, "CVE-2004-0598": {"epss_score": 0.31346, "epss_percentile": 0.96613}, "CVE-2004-0599": {"epss_score": 0.31363, "epss_percentile": 0.96614}, "CVE-2004-0600": {"epss_score": 0.59614, "epss_percentile": 0.98172}, "CVE-2004-0601": {"epss_score": 0.00428, "epss_percentile": 0.61953}, "CVE-2004-0602": {"epss_score": 0.00062, "epss_percentile": 0.19732}, "CVE-2004-0603": {"epss_score": 0.02503, "epss_percentile": 0.8493}, "CVE-2004-0604": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-0605": {"epss_score": 0.05166, "epss_percentile": 0.89566}, "CVE-2004-0606": {"epss_score": 0.01958, "epss_percentile": 0.83048}, "CVE-2004-0607": {"epss_score": 0.03036, "epss_percentile": 0.86261}, "CVE-2004-0608": {"epss_score": 0.64417, "epss_percentile": 0.98377}, "CVE-2004-0609": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2004-0610": {"epss_score": 0.19171, "epss_percentile": 0.95142}, "CVE-2004-0611": {"epss_score": 0.00651, "epss_percentile": 0.70301}, "CVE-2004-0612": {"epss_score": 0.00363, "epss_percentile": 0.57827}, "CVE-2004-0613": {"epss_score": 0.0678, "epss_percentile": 0.91021}, "CVE-2004-0614": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2004-0615": {"epss_score": 0.00771, "epss_percentile": 0.73023}, "CVE-2004-0616": {"epss_score": 0.05307, "epss_percentile": 0.89714}, "CVE-2004-0617": {"epss_score": 0.01792, "epss_percentile": 0.82287}, "CVE-2004-0618": {"epss_score": 0.00421, "epss_percentile": 0.6151}, "CVE-2004-0619": {"epss_score": 0.00068, "epss_percentile": 0.21372}, "CVE-2004-0620": {"epss_score": 0.03792, "epss_percentile": 0.87732}, "CVE-2004-0621": {"epss_score": 0.03512, "epss_percentile": 0.87268}, "CVE-2004-0622": {"epss_score": 0.00115, "epss_percentile": 0.30956}, "CVE-2004-0623": {"epss_score": 0.03447, "epss_percentile": 0.8716}, "CVE-2004-0624": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2004-0625": {"epss_score": 0.00814, "epss_percentile": 0.73769}, "CVE-2004-0626": {"epss_score": 0.01738, "epss_percentile": 0.82025}, "CVE-2004-0627": {"epss_score": 0.49139, "epss_percentile": 0.9767}, "CVE-2004-0628": {"epss_score": 0.06381, "epss_percentile": 0.90712}, "CVE-2004-0629": {"epss_score": 0.20761, "epss_percentile": 0.95409}, "CVE-2004-0630": {"epss_score": 0.19519, "epss_percentile": 0.95198}, "CVE-2004-0631": {"epss_score": 0.16083, "epss_percentile": 0.94569}, "CVE-2004-0632": {"epss_score": 0.23152, "epss_percentile": 0.95741}, "CVE-2004-0633": {"epss_score": 0.37279, "epss_percentile": 0.97032}, "CVE-2004-0634": {"epss_score": 0.10554, "epss_percentile": 0.93027}, "CVE-2004-0635": {"epss_score": 0.08502, "epss_percentile": 0.92086}, "CVE-2004-0636": {"epss_score": 0.78516, "epss_percentile": 0.9899}, "CVE-2004-0637": {"epss_score": 0.19334, "epss_percentile": 0.95164}, "CVE-2004-0638": {"epss_score": 0.17247, "epss_percentile": 0.94806}, "CVE-2004-0639": {"epss_score": 0.03628, "epss_percentile": 0.87467}, "CVE-2004-0640": {"epss_score": 0.03447, "epss_percentile": 0.8716}, "CVE-2004-0641": {"epss_score": 0.07248, "epss_percentile": 0.91349}, "CVE-2004-0642": {"epss_score": 0.25795, "epss_percentile": 0.96071}, "CVE-2004-0643": {"epss_score": 0.00132, "epss_percentile": 0.33616}, "CVE-2004-0644": {"epss_score": 0.08582, "epss_percentile": 0.92134}, "CVE-2004-0645": {"epss_score": 0.10627, "epss_percentile": 0.93053}, "CVE-2004-0646": {"epss_score": 0.70947, "epss_percentile": 0.98647}, "CVE-2004-0647": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2004-0648": {"epss_score": 0.2251, "epss_percentile": 0.95646}, "CVE-2004-0649": {"epss_score": 0.05476, "epss_percentile": 0.89914}, "CVE-2004-0650": {"epss_score": 0.0138, "epss_percentile": 0.79862}, "CVE-2004-0651": {"epss_score": 0.04624, "epss_percentile": 0.88936}, "CVE-2004-0652": {"epss_score": 0.00101, "epss_percentile": 0.28715}, "CVE-2004-0653": {"epss_score": 0.00098, "epss_percentile": 0.27829}, "CVE-2004-0654": {"epss_score": 0.00128, "epss_percentile": 0.33053}, "CVE-2004-0655": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2004-0656": {"epss_score": 0.00256, "epss_percentile": 0.48796}, "CVE-2004-0657": {"epss_score": 0.04544, "epss_percentile": 0.88831}, "CVE-2004-0658": {"epss_score": 0.00067, "epss_percentile": 0.21024}, "CVE-2004-0659": {"epss_score": 0.04453, "epss_percentile": 0.88708}, "CVE-2004-0660": {"epss_score": 0.00521, "epss_percentile": 0.66241}, "CVE-2004-0661": {"epss_score": 0.01412, "epss_percentile": 0.80114}, "CVE-2004-0662": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2004-0663": {"epss_score": 0.00828, "epss_percentile": 0.74006}, "CVE-2004-0664": {"epss_score": 0.04308, "epss_percentile": 0.88528}, "CVE-2004-0665": {"epss_score": 0.05247, "epss_percentile": 0.89662}, "CVE-2004-0666": {"epss_score": 0.00994, "epss_percentile": 0.76421}, "CVE-2004-0667": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2004-0668": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2004-0669": {"epss_score": 0.00641, "epss_percentile": 0.69993}, "CVE-2004-0670": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2004-0671": {"epss_score": 0.10762, "epss_percentile": 0.93096}, "CVE-2004-0672": {"epss_score": 0.00477, "epss_percentile": 0.64334}, "CVE-2004-0673": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2004-0674": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2004-0675": {"epss_score": 0.04081, "epss_percentile": 0.88219}, "CVE-2004-0676": {"epss_score": 0.04403, "epss_percentile": 0.88649}, "CVE-2004-0677": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2004-0678": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2004-0679": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2004-0680": {"epss_score": 0.00933, "epss_percentile": 0.75638}, "CVE-2004-0681": {"epss_score": 0.00726, "epss_percentile": 0.72079}, "CVE-2004-0682": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2004-0683": {"epss_score": 0.04156, "epss_percentile": 0.88329}, "CVE-2004-0684": {"epss_score": 0.00786, "epss_percentile": 0.73271}, "CVE-2004-0685": {"epss_score": 0.00149, "epss_percentile": 0.3597}, "CVE-2004-0686": {"epss_score": 0.08492, "epss_percentile": 0.92082}, "CVE-2004-0687": {"epss_score": 0.19946, "epss_percentile": 0.95265}, "CVE-2004-0688": {"epss_score": 0.16028, "epss_percentile": 0.94562}, "CVE-2004-0689": {"epss_score": 0.00029, "epss_percentile": 0.077}, "CVE-2004-0690": {"epss_score": 0.00108, "epss_percentile": 0.29835}, "CVE-2004-0691": {"epss_score": 0.27214, "epss_percentile": 0.96221}, "CVE-2004-0692": {"epss_score": 0.02235, "epss_percentile": 0.84099}, "CVE-2004-0693": {"epss_score": 0.0156, "epss_percentile": 0.81038}, "CVE-2004-0694": {"epss_score": 0.01288, "epss_percentile": 0.79198}, "CVE-2004-0695": {"epss_score": 0.7912, "epss_percentile": 0.9902}, "CVE-2004-0696": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2004-0697": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2004-0698": {"epss_score": 0.00067, "epss_percentile": 0.21078}, "CVE-2004-0699": {"epss_score": 0.198, "epss_percentile": 0.95243}, "CVE-2004-0700": {"epss_score": 0.30648, "epss_percentile": 0.96559}, "CVE-2004-0701": {"epss_score": 0.00095, "epss_percentile": 0.27227}, "CVE-2004-0702": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2004-0703": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2004-0704": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2004-0705": {"epss_score": 0.00855, "epss_percentile": 0.7447}, "CVE-2004-0706": {"epss_score": 0.00071, "epss_percentile": 0.22167}, "CVE-2004-0707": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2004-0708": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2004-0709": {"epss_score": 0.01104, "epss_percentile": 0.77598}, "CVE-2004-0710": {"epss_score": 0.0098, "epss_percentile": 0.76269}, "CVE-2004-0711": {"epss_score": 0.00905, "epss_percentile": 0.75234}, "CVE-2004-0712": {"epss_score": 0.0011, "epss_percentile": 0.30124}, "CVE-2004-0713": {"epss_score": 0.00622, "epss_percentile": 0.69508}, "CVE-2004-0714": {"epss_score": 0.0286, "epss_percentile": 0.85849}, "CVE-2004-0715": {"epss_score": 0.02104, "epss_percentile": 0.8362}, "CVE-2004-0716": {"epss_score": 0.04293, "epss_percentile": 0.88505}, "CVE-2004-0717": {"epss_score": 0.00618, "epss_percentile": 0.69369}, "CVE-2004-0718": {"epss_score": 0.0191, "epss_percentile": 0.82824}, "CVE-2004-0719": {"epss_score": 0.15583, "epss_percentile": 0.94464}, "CVE-2004-0720": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2004-0721": {"epss_score": 0.00786, "epss_percentile": 0.7327}, "CVE-2004-0722": {"epss_score": 0.23108, "epss_percentile": 0.95736}, "CVE-2004-0723": {"epss_score": 0.03822, "epss_percentile": 0.87784}, "CVE-2004-0724": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-0725": {"epss_score": 0.0196, "epss_percentile": 0.83058}, "CVE-2004-0726": {"epss_score": 0.17376, "epss_percentile": 0.94841}, "CVE-2004-0727": {"epss_score": 0.64045, "epss_percentile": 0.98362}, "CVE-2004-0728": {"epss_score": 0.46093, "epss_percentile": 0.97524}, "CVE-2004-0729": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2004-0730": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2004-0731": {"epss_score": 0.00059, "epss_percentile": 0.18752}, "CVE-2004-0732": {"epss_score": 0.00038, "epss_percentile": 0.11144}, "CVE-2004-0733": {"epss_score": 0.44256, "epss_percentile": 0.97426}, "CVE-2004-0734": {"epss_score": 0.08691, "epss_percentile": 0.92206}, "CVE-2004-0735": {"epss_score": 0.74364, "epss_percentile": 0.98796}, "CVE-2004-0736": {"epss_score": 0.00016, "epss_percentile": 0.03023}, "CVE-2004-0737": {"epss_score": 0.00041, "epss_percentile": 0.1227}, "CVE-2004-0738": {"epss_score": 0.00025, "epss_percentile": 0.06241}, "CVE-2004-0739": {"epss_score": 0.00957, "epss_percentile": 0.75934}, "CVE-2004-0740": {"epss_score": 0.08446, "epss_percentile": 0.92055}, "CVE-2004-0741": {"epss_score": 0.00714, "epss_percentile": 0.71829}, "CVE-2004-0742": {"epss_score": 0.01302, "epss_percentile": 0.79304}, "CVE-2004-0743": {"epss_score": 0.00405, "epss_percentile": 0.60474}, "CVE-2004-0744": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-0745": {"epss_score": 0.00892, "epss_percentile": 0.75061}, "CVE-2004-0746": {"epss_score": 0.01495, "epss_percentile": 0.80656}, "CVE-2004-0747": {"epss_score": 0.01437, "epss_percentile": 0.80279}, "CVE-2004-0748": {"epss_score": 0.18763, "epss_percentile": 0.95066}, "CVE-2004-0749": {"epss_score": 0.00619, "epss_percentile": 0.69393}, "CVE-2004-0750": {"epss_score": 0.00455, "epss_percentile": 0.63309}, "CVE-2004-0751": {"epss_score": 0.47686, "epss_percentile": 0.97596}, "CVE-2004-0752": {"epss_score": 0.00061, "epss_percentile": 0.19472}, "CVE-2004-0753": {"epss_score": 0.1204, "epss_percentile": 0.93553}, "CVE-2004-0754": {"epss_score": 0.05597, "epss_percentile": 0.90034}, "CVE-2004-0755": {"epss_score": 0.00059, "epss_percentile": 0.18721}, "CVE-2004-0757": {"epss_score": 0.0448, "epss_percentile": 0.88741}, "CVE-2004-0758": {"epss_score": 0.15841, "epss_percentile": 0.94517}, "CVE-2004-0759": {"epss_score": 0.01099, "epss_percentile": 0.77546}, "CVE-2004-0760": {"epss_score": 0.15205, "epss_percentile": 0.94383}, "CVE-2004-0761": {"epss_score": 0.0103, "epss_percentile": 0.76841}, "CVE-2004-0762": {"epss_score": 0.01362, "epss_percentile": 0.79762}, "CVE-2004-0763": {"epss_score": 0.17694, "epss_percentile": 0.9489}, "CVE-2004-0764": {"epss_score": 0.0254, "epss_percentile": 0.85048}, "CVE-2004-0765": {"epss_score": 0.00766, "epss_percentile": 0.72943}, "CVE-2004-0766": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2004-0767": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2004-0768": {"epss_score": 0.04102, "epss_percentile": 0.88261}, "CVE-2004-0769": {"epss_score": 0.03058, "epss_percentile": 0.86304}, "CVE-2004-0770": {"epss_score": 0.00064, "epss_percentile": 0.20356}, "CVE-2004-0771": {"epss_score": 0.37949, "epss_percentile": 0.97078}, "CVE-2004-0772": {"epss_score": 0.17625, "epss_percentile": 0.94876}, "CVE-2004-0774": {"epss_score": 0.0068, "epss_percentile": 0.71025}, "CVE-2004-0775": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2004-0777": {"epss_score": 0.15919, "epss_percentile": 0.94535}, "CVE-2004-0778": {"epss_score": 0.04739, "epss_percentile": 0.89076}, "CVE-2004-0779": {"epss_score": 0.00786, "epss_percentile": 0.73298}, "CVE-2004-0780": {"epss_score": 0.00084, "epss_percentile": 0.2488}, "CVE-2004-0781": {"epss_score": 0.00364, "epss_percentile": 0.57938}, "CVE-2004-0782": {"epss_score": 0.30045, "epss_percentile": 0.965}, "CVE-2004-0783": {"epss_score": 0.30599, "epss_percentile": 0.96555}, "CVE-2004-0784": {"epss_score": 0.01272, "epss_percentile": 0.79075}, "CVE-2004-0785": {"epss_score": 0.06299, "epss_percentile": 0.90654}, "CVE-2004-0786": {"epss_score": 0.48362, "epss_percentile": 0.97633}, "CVE-2004-0787": {"epss_score": 0.00376, "epss_percentile": 0.58656}, "CVE-2004-0788": {"epss_score": 0.1293, "epss_percentile": 0.93821}, "CVE-2004-0789": {"epss_score": 0.01958, "epss_percentile": 0.83049}, "CVE-2004-0790": {"epss_score": 0.85133, "epss_percentile": 0.99321}, "CVE-2004-0791": {"epss_score": 0.30396, "epss_percentile": 0.96536}, "CVE-2004-0792": {"epss_score": 0.00839, "epss_percentile": 0.74184}, "CVE-2004-0793": {"epss_score": 0.00052, "epss_percentile": 0.16632}, "CVE-2004-0794": {"epss_score": 0.02185, "epss_percentile": 0.83917}, "CVE-2004-0795": {"epss_score": 0.31914, "epss_percentile": 0.96659}, "CVE-2004-0796": {"epss_score": 0.01344, "epss_percentile": 0.79618}, "CVE-2004-0797": {"epss_score": 0.02112, "epss_percentile": 0.83648}, "CVE-2004-0798": {"epss_score": 0.72637, "epss_percentile": 0.9872}, "CVE-2004-0799": {"epss_score": 0.11427, "epss_percentile": 0.93345}, "CVE-2004-0800": {"epss_score": 0.00096, "epss_percentile": 0.27388}, "CVE-2004-0801": {"epss_score": 0.02551, "epss_percentile": 0.85078}, "CVE-2004-0802": {"epss_score": 0.06287, "epss_percentile": 0.90645}, "CVE-2004-0803": {"epss_score": 0.17883, "epss_percentile": 0.94922}, "CVE-2004-0804": {"epss_score": 0.19172, "epss_percentile": 0.95143}, "CVE-2004-0805": {"epss_score": 0.05835, "epss_percentile": 0.90247}, "CVE-2004-0806": {"epss_score": 0.00443, "epss_percentile": 0.628}, "CVE-2004-0807": {"epss_score": 0.09849, "epss_percentile": 0.92734}, "CVE-2004-0808": {"epss_score": 0.07869, "epss_percentile": 0.91734}, "CVE-2004-0809": {"epss_score": 0.14022, "epss_percentile": 0.94116}, "CVE-2004-0810": {"epss_score": 0.01386, "epss_percentile": 0.7991}, "CVE-2004-0811": {"epss_score": 0.04066, "epss_percentile": 0.88201}, "CVE-2004-0812": {"epss_score": 0.00072, "epss_percentile": 0.22396}, "CVE-2004-0813": {"epss_score": 0.00133, "epss_percentile": 0.33683}, "CVE-2004-0814": {"epss_score": 0.00238, "epss_percentile": 0.4679}, "CVE-2004-0815": {"epss_score": 0.08221, "epss_percentile": 0.91937}, "CVE-2004-0816": {"epss_score": 0.07365, "epss_percentile": 0.91435}, "CVE-2004-0817": {"epss_score": 0.03598, "epss_percentile": 0.87406}, "CVE-2004-0819": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-0820": {"epss_score": 0.02148, "epss_percentile": 0.83775}, "CVE-2004-0821": {"epss_score": 0.00065, "epss_percentile": 0.20541}, "CVE-2004-0822": {"epss_score": 0.00112, "epss_percentile": 0.30421}, "CVE-2004-0823": {"epss_score": 0.00612, "epss_percentile": 0.69236}, "CVE-2004-0824": {"epss_score": 0.00325, "epss_percentile": 0.55027}, "CVE-2004-0825": {"epss_score": 0.01786, "epss_percentile": 0.82256}, "CVE-2004-0826": {"epss_score": 0.02995, "epss_percentile": 0.86154}, "CVE-2004-0827": {"epss_score": 0.03692, "epss_percentile": 0.87578}, "CVE-2004-0828": {"epss_score": 0.00078, "epss_percentile": 0.23763}, "CVE-2004-0829": {"epss_score": 0.03962, "epss_percentile": 0.88015}, "CVE-2004-0830": {"epss_score": 0.01075, "epss_percentile": 0.77311}, "CVE-2004-0831": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2004-0832": {"epss_score": 0.12288, "epss_percentile": 0.93623}, "CVE-2004-0833": {"epss_score": 0.00664, "epss_percentile": 0.70647}, "CVE-2004-0834": {"epss_score": 0.00051, "epss_percentile": 0.16069}, "CVE-2004-0835": {"epss_score": 0.03649, "epss_percentile": 0.87506}, "CVE-2004-0836": {"epss_score": 0.02726, "epss_percentile": 0.85528}, "CVE-2004-0837": {"epss_score": 0.02357, "epss_percentile": 0.84487}, "CVE-2004-0838": {"epss_score": 0.0004, "epss_percentile": 0.1199}, "CVE-2004-0839": {"epss_score": 0.42009, "epss_percentile": 0.97306}, "CVE-2004-0840": {"epss_score": 0.42549, "epss_percentile": 0.97337}, "CVE-2004-0841": {"epss_score": 0.55962, "epss_percentile": 0.98004}, "CVE-2004-0842": {"epss_score": 0.84327, "epss_percentile": 0.99284}, "CVE-2004-0843": {"epss_score": 0.42845, "epss_percentile": 0.97358}, "CVE-2004-0844": {"epss_score": 0.66746, "epss_percentile": 0.98477}, "CVE-2004-0845": {"epss_score": 0.38963, "epss_percentile": 0.97132}, "CVE-2004-0846": {"epss_score": 0.51442, "epss_percentile": 0.97778}, "CVE-2004-0847": {"epss_score": 0.52826, "epss_percentile": 0.97843}, "CVE-2004-0848": {"epss_score": 0.42122, "epss_percentile": 0.97313}, "CVE-2004-0849": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-0850": {"epss_score": 0.00066, "epss_percentile": 0.20753}, "CVE-2004-0851": {"epss_score": 0.00072, "epss_percentile": 0.22419}, "CVE-2004-0852": {"epss_score": 0.03422, "epss_percentile": 0.87106}, "CVE-2004-0866": {"epss_score": 0.03541, "epss_percentile": 0.87319}, "CVE-2004-0867": {"epss_score": 0.03644, "epss_percentile": 0.87496}, "CVE-2004-0869": {"epss_score": 0.20617, "epss_percentile": 0.95385}, "CVE-2004-0870": {"epss_score": 0.00824, "epss_percentile": 0.73936}, "CVE-2004-0871": {"epss_score": 0.00438, "epss_percentile": 0.62564}, "CVE-2004-0872": {"epss_score": 0.01144, "epss_percentile": 0.77988}, "CVE-2004-0873": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2004-0875": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2004-0880": {"epss_score": 0.00098, "epss_percentile": 0.27692}, "CVE-2004-0881": {"epss_score": 0.00088, "epss_percentile": 0.25654}, "CVE-2004-0882": {"epss_score": 0.33008, "epss_percentile": 0.9674}, "CVE-2004-0883": {"epss_score": 0.19542, "epss_percentile": 0.95204}, "CVE-2004-0884": {"epss_score": 0.0006, "epss_percentile": 0.18931}, "CVE-2004-0885": {"epss_score": 0.06144, "epss_percentile": 0.90516}, "CVE-2004-0886": {"epss_score": 0.10989, "epss_percentile": 0.93184}, "CVE-2004-0887": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2004-0888": {"epss_score": 0.04443, "epss_percentile": 0.88696}, "CVE-2004-0889": {"epss_score": 0.03388, "epss_percentile": 0.87043}, "CVE-2004-0891": {"epss_score": 0.05439, "epss_percentile": 0.89883}, "CVE-2004-0892": {"epss_score": 0.10083, "epss_percentile": 0.92843}, "CVE-2004-0893": {"epss_score": 0.01332, "epss_percentile": 0.7952}, "CVE-2004-0894": {"epss_score": 0.0107, "epss_percentile": 0.77252}, "CVE-2004-0897": {"epss_score": 0.55007, "epss_percentile": 0.97956}, "CVE-2004-0899": {"epss_score": 0.37272, "epss_percentile": 0.97032}, "CVE-2004-0900": {"epss_score": 0.41495, "epss_percentile": 0.97278}, "CVE-2004-0901": {"epss_score": 0.36171, "epss_percentile": 0.96959}, "CVE-2004-0902": {"epss_score": 0.27897, "epss_percentile": 0.96292}, "CVE-2004-0903": {"epss_score": 0.18826, "epss_percentile": 0.95075}, "CVE-2004-0904": {"epss_score": 0.31745, "epss_percentile": 0.96644}, "CVE-2004-0905": {"epss_score": 0.0661, "epss_percentile": 0.90886}, "CVE-2004-0906": {"epss_score": 0.00144, "epss_percentile": 0.35332}, "CVE-2004-0907": {"epss_score": 0.00096, "epss_percentile": 0.27375}, "CVE-2004-0908": {"epss_score": 0.04585, "epss_percentile": 0.88883}, "CVE-2004-0909": {"epss_score": 0.06561, "epss_percentile": 0.90848}, "CVE-2004-0911": {"epss_score": 0.00928, "epss_percentile": 0.75578}, "CVE-2004-0913": {"epss_score": 0.00086, "epss_percentile": 0.25389}, "CVE-2004-0914": {"epss_score": 0.02166, "epss_percentile": 0.83852}, "CVE-2004-0915": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2004-0916": {"epss_score": 0.01938, "epss_percentile": 0.82967}, "CVE-2004-0917": {"epss_score": 0.00618, "epss_percentile": 0.69366}, "CVE-2004-0918": {"epss_score": 0.68742, "epss_percentile": 0.98561}, "CVE-2004-0919": {"epss_score": 0.00113, "epss_percentile": 0.30602}, "CVE-2004-0920": {"epss_score": 0.00708, "epss_percentile": 0.71669}, "CVE-2004-0921": {"epss_score": 0.00407, "epss_percentile": 0.60609}, "CVE-2004-0922": {"epss_score": 0.00305, "epss_percentile": 0.53319}, "CVE-2004-0923": {"epss_score": 0.001, "epss_percentile": 0.2844}, "CVE-2004-0924": {"epss_score": 0.00296, "epss_percentile": 0.5254}, "CVE-2004-0925": {"epss_score": 0.00485, "epss_percentile": 0.64724}, "CVE-2004-0926": {"epss_score": 0.03657, "epss_percentile": 0.8752}, "CVE-2004-0927": {"epss_score": 0.00186, "epss_percentile": 0.40667}, "CVE-2004-0928": {"epss_score": 0.28178, "epss_percentile": 0.96329}, "CVE-2004-0929": {"epss_score": 0.08155, "epss_percentile": 0.91906}, "CVE-2004-0930": {"epss_score": 0.06058, "epss_percentile": 0.9044}, "CVE-2004-0931": {"epss_score": 0.00804, "epss_percentile": 0.73611}, "CVE-2004-0932": {"epss_score": 0.43585, "epss_percentile": 0.97392}, "CVE-2004-0933": {"epss_score": 0.30032, "epss_percentile": 0.96498}, "CVE-2004-0934": {"epss_score": 0.39948, "epss_percentile": 0.97188}, "CVE-2004-0935": {"epss_score": 0.132, "epss_percentile": 0.93899}, "CVE-2004-0936": {"epss_score": 0.132, "epss_percentile": 0.93899}, "CVE-2004-0937": {"epss_score": 0.132, "epss_percentile": 0.93899}, "CVE-2004-0938": {"epss_score": 0.05466, "epss_percentile": 0.89905}, "CVE-2004-0939": {"epss_score": 0.00712, "epss_percentile": 0.71747}, "CVE-2004-0940": {"epss_score": 0.03684, "epss_percentile": 0.87566}, "CVE-2004-0941": {"epss_score": 0.11933, "epss_percentile": 0.9352}, "CVE-2004-0942": {"epss_score": 0.79222, "epss_percentile": 0.99024}, "CVE-2004-0944": {"epss_score": 0.00443, "epss_percentile": 0.62772}, "CVE-2004-0945": {"epss_score": 0.00769, "epss_percentile": 0.72985}, "CVE-2004-0946": {"epss_score": 0.20844, "epss_percentile": 0.95427}, "CVE-2004-0947": {"epss_score": 0.12786, "epss_percentile": 0.93773}, "CVE-2004-0949": {"epss_score": 0.03733, "epss_percentile": 0.87647}, "CVE-2004-0950": {"epss_score": 0.00533, "epss_percentile": 0.66774}, "CVE-2004-0951": {"epss_score": 0.02251, "epss_percentile": 0.84158}, "CVE-2004-0952": {"epss_score": 0.01653, "epss_percentile": 0.8158}, "CVE-2004-0953": {"epss_score": 0.18487, "epss_percentile": 0.95022}, "CVE-2004-0956": {"epss_score": 0.01048, "epss_percentile": 0.77045}, "CVE-2004-0957": {"epss_score": 0.0048, "epss_percentile": 0.64455}, "CVE-2004-0958": {"epss_score": 0.08363, "epss_percentile": 0.92009}, "CVE-2004-0959": {"epss_score": 0.04807, "epss_percentile": 0.89162}, "CVE-2004-0960": {"epss_score": 0.02641, "epss_percentile": 0.85303}, "CVE-2004-0961": {"epss_score": 0.02641, "epss_percentile": 0.85303}, "CVE-2004-0962": {"epss_score": 0.01777, "epss_percentile": 0.82225}, "CVE-2004-0963": {"epss_score": 0.4414, "epss_percentile": 0.9742}, "CVE-2004-0964": {"epss_score": 0.85695, "epss_percentile": 0.99343}, "CVE-2004-0965": {"epss_score": 0.00059, "epss_percentile": 0.1874}, "CVE-2004-0966": {"epss_score": 0.00075, "epss_percentile": 0.23012}, "CVE-2004-0967": {"epss_score": 0.00032, "epss_percentile": 0.09003}, "CVE-2004-0968": {"epss_score": 0.00072, "epss_percentile": 0.22408}, "CVE-2004-0969": {"epss_score": 0.00122, "epss_percentile": 0.32146}, "CVE-2004-0970": {"epss_score": 0.00098, "epss_percentile": 0.27781}, "CVE-2004-0971": {"epss_score": 0.00108, "epss_percentile": 0.29799}, "CVE-2004-0972": {"epss_score": 0.0008, "epss_percentile": 0.24118}, "CVE-2004-0974": {"epss_score": 0.00103, "epss_percentile": 0.29089}, "CVE-2004-0975": {"epss_score": 0.00077, "epss_percentile": 0.23325}, "CVE-2004-0976": {"epss_score": 0.00112, "epss_percentile": 0.30451}, "CVE-2004-0977": {"epss_score": 0.00088, "epss_percentile": 0.25791}, "CVE-2004-0978": {"epss_score": 0.42218, "epss_percentile": 0.97319}, "CVE-2004-0979": {"epss_score": 0.08307, "epss_percentile": 0.91982}, "CVE-2004-0980": {"epss_score": 0.01578, "epss_percentile": 0.81124}, "CVE-2004-0981": {"epss_score": 0.07221, "epss_percentile": 0.91334}, "CVE-2004-0982": {"epss_score": 0.08227, "epss_percentile": 0.9194}, "CVE-2004-0983": {"epss_score": 0.01117, "epss_percentile": 0.77735}, "CVE-2004-0984": {"epss_score": 0.00054, "epss_percentile": 0.17248}, "CVE-2004-0985": {"epss_score": 0.41495, "epss_percentile": 0.97278}, "CVE-2004-0986": {"epss_score": 0.01269, "epss_percentile": 0.79039}, "CVE-2004-0987": {"epss_score": 0.05476, "epss_percentile": 0.89914}, "CVE-2004-0988": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2004-0989": {"epss_score": 0.36873, "epss_percentile": 0.97006}, "CVE-2004-0990": {"epss_score": 0.33478, "epss_percentile": 0.96776}, "CVE-2004-0991": {"epss_score": 0.05027, "epss_percentile": 0.8941}, "CVE-2004-0992": {"epss_score": 0.04588, "epss_percentile": 0.88889}, "CVE-2004-0993": {"epss_score": 0.02174, "epss_percentile": 0.83878}, "CVE-2004-0994": {"epss_score": 0.17526, "epss_percentile": 0.94861}, "CVE-2004-0996": {"epss_score": 0.00393, "epss_percentile": 0.5974}, "CVE-2004-0997": {"epss_score": 0.00067, "epss_percentile": 0.2103}, "CVE-2004-0998": {"epss_score": 0.05555, "epss_percentile": 0.89989}, "CVE-2004-0999": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-1000": {"epss_score": 0.00072, "epss_percentile": 0.22262}, "CVE-2004-1001": {"epss_score": 0.00081, "epss_percentile": 0.24351}, "CVE-2004-1002": {"epss_score": 0.02083, "epss_percentile": 0.83541}, "CVE-2004-1003": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-2004-1004": {"epss_score": 0.00949, "epss_percentile": 0.7585}, "CVE-2004-1005": {"epss_score": 0.01111, "epss_percentile": 0.77671}, "CVE-2004-1006": {"epss_score": 0.07658, "epss_percentile": 0.91608}, "CVE-2004-1007": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2004-1008": {"epss_score": 0.2119, "epss_percentile": 0.95474}, "CVE-2004-1009": {"epss_score": 0.01288, "epss_percentile": 0.79197}, "CVE-2004-1010": {"epss_score": 0.06063, "epss_percentile": 0.90445}, "CVE-2004-1011": {"epss_score": 0.16617, "epss_percentile": 0.94703}, "CVE-2004-1012": {"epss_score": 0.10245, "epss_percentile": 0.9291}, "CVE-2004-1013": {"epss_score": 0.10245, "epss_percentile": 0.9291}, "CVE-2004-1014": {"epss_score": 0.02458, "epss_percentile": 0.84814}, "CVE-2004-1015": {"epss_score": 0.05704, "epss_percentile": 0.90136}, "CVE-2004-1016": {"epss_score": 0.00407, "epss_percentile": 0.60611}, "CVE-2004-1017": {"epss_score": 0.01913, "epss_percentile": 0.82844}, "CVE-2004-1018": {"epss_score": 0.2419, "epss_percentile": 0.95884}, "CVE-2004-1019": {"epss_score": 0.06765, "epss_percentile": 0.91011}, "CVE-2004-1020": {"epss_score": 0.08011, "epss_percentile": 0.91827}, "CVE-2004-1021": {"epss_score": 0.00489, "epss_percentile": 0.64894}, "CVE-2004-1022": {"epss_score": 0.00051, "epss_percentile": 0.16037}, "CVE-2004-1023": {"epss_score": 0.00078, "epss_percentile": 0.23686}, "CVE-2004-1025": {"epss_score": 0.02707, "epss_percentile": 0.85469}, "CVE-2004-1026": {"epss_score": 0.02681, "epss_percentile": 0.85414}, "CVE-2004-1027": {"epss_score": 0.06284, "epss_percentile": 0.90641}, "CVE-2004-1028": {"epss_score": 0.00046, "epss_percentile": 0.14316}, "CVE-2004-1029": {"epss_score": 0.42558, "epss_percentile": 0.97338}, "CVE-2004-1030": {"epss_score": 0.00071, "epss_percentile": 0.22167}, "CVE-2004-1031": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2004-1032": {"epss_score": 0.00059, "epss_percentile": 0.18833}, "CVE-2004-1033": {"epss_score": 0.00071, "epss_percentile": 0.22167}, "CVE-2004-1034": {"epss_score": 0.0593, "epss_percentile": 0.90334}, "CVE-2004-1035": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2004-1036": {"epss_score": 0.03177, "epss_percentile": 0.86572}, "CVE-2004-1037": {"epss_score": 0.85829, "epss_percentile": 0.99352}, "CVE-2004-1038": {"epss_score": 0.00126, "epss_percentile": 0.32704}, "CVE-2004-1039": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2004-1043": {"epss_score": 0.74501, "epss_percentile": 0.98804}, "CVE-2004-1049": {"epss_score": 0.5939, "epss_percentile": 0.98162}, "CVE-2004-1050": {"epss_score": 0.79088, "epss_percentile": 0.99019}, "CVE-2004-1051": {"epss_score": 0.00274, "epss_percentile": 0.50547}, "CVE-2004-1052": {"epss_score": 0.01472, "epss_percentile": 0.80511}, "CVE-2004-1053": {"epss_score": 0.01224, "epss_percentile": 0.78671}, "CVE-2004-1054": {"epss_score": 0.0036, "epss_percentile": 0.57658}, "CVE-2004-1055": {"epss_score": 0.01171, "epss_percentile": 0.78224}, "CVE-2004-1056": {"epss_score": 0.03362, "epss_percentile": 0.86992}, "CVE-2004-1057": {"epss_score": 0.0006, "epss_percentile": 0.1902}, "CVE-2004-1058": {"epss_score": 0.00064, "epss_percentile": 0.20196}, "CVE-2004-1059": {"epss_score": 0.00547, "epss_percentile": 0.67246}, "CVE-2004-1060": {"epss_score": 0.59911, "epss_percentile": 0.98187}, "CVE-2004-1061": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2004-1062": {"epss_score": 0.00547, "epss_percentile": 0.67246}, "CVE-2004-1063": {"epss_score": 0.0159, "epss_percentile": 0.81201}, "CVE-2004-1064": {"epss_score": 0.01731, "epss_percentile": 0.81995}, "CVE-2004-1065": {"epss_score": 0.07162, "epss_percentile": 0.91293}, "CVE-2004-1066": {"epss_score": 0.00075, "epss_percentile": 0.22996}, "CVE-2004-1067": {"epss_score": 0.05476, "epss_percentile": 0.89914}, "CVE-2004-1068": {"epss_score": 0.00061, "epss_percentile": 0.19334}, "CVE-2004-1069": {"epss_score": 0.00075, "epss_percentile": 0.22991}, "CVE-2004-1070": {"epss_score": 0.00065, "epss_percentile": 0.20462}, "CVE-2004-1071": {"epss_score": 0.00052, "epss_percentile": 0.16639}, "CVE-2004-1072": {"epss_score": 0.0007, "epss_percentile": 0.21836}, "CVE-2004-1073": {"epss_score": 0.00231, "epss_percentile": 0.45802}, "CVE-2004-1074": {"epss_score": 0.00336, "epss_percentile": 0.5592}, "CVE-2004-1075": {"epss_score": 0.08341, "epss_percentile": 0.91998}, "CVE-2004-1076": {"epss_score": 0.00098, "epss_percentile": 0.27713}, "CVE-2004-1077": {"epss_score": 0.00493, "epss_percentile": 0.65036}, "CVE-2004-1078": {"epss_score": 0.03869, "epss_percentile": 0.87877}, "CVE-2004-1079": {"epss_score": 0.00077, "epss_percentile": 0.23403}, "CVE-2004-1080": {"epss_score": 0.89406, "epss_percentile": 0.99524}, "CVE-2004-1081": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2004-1082": {"epss_score": 0.05469, "epss_percentile": 0.89906}, "CVE-2004-1083": {"epss_score": 0.01905, "epss_percentile": 0.82796}, "CVE-2004-1084": {"epss_score": 0.00518, "epss_percentile": 0.66097}, "CVE-2004-1085": {"epss_score": 0.0007, "epss_percentile": 0.21947}, "CVE-2004-1086": {"epss_score": 0.03081, "epss_percentile": 0.86373}, "CVE-2004-1087": {"epss_score": 0.00091, "epss_percentile": 0.26268}, "CVE-2004-1088": {"epss_score": 0.01547, "epss_percentile": 0.80974}, "CVE-2004-1089": {"epss_score": 0.00093, "epss_percentile": 0.26752}, "CVE-2004-1090": {"epss_score": 0.0106, "epss_percentile": 0.77164}, "CVE-2004-1091": {"epss_score": 0.0106, "epss_percentile": 0.77164}, "CVE-2004-1092": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2004-1093": {"epss_score": 0.0106, "epss_percentile": 0.77164}, "CVE-2004-1094": {"epss_score": 0.44468, "epss_percentile": 0.97439}, "CVE-2004-1095": {"epss_score": 0.20999, "epss_percentile": 0.95449}, "CVE-2004-1096": {"epss_score": 0.20253, "epss_percentile": 0.95309}, "CVE-2004-1097": {"epss_score": 0.04101, "epss_percentile": 0.88258}, "CVE-2004-1098": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2004-1099": {"epss_score": 0.02159, "epss_percentile": 0.83821}, "CVE-2004-1100": {"epss_score": 0.01467, "epss_percentile": 0.80475}, "CVE-2004-1101": {"epss_score": 0.02696, "epss_percentile": 0.85445}, "CVE-2004-1102": {"epss_score": 0.07089, "epss_percentile": 0.91243}, "CVE-2004-1103": {"epss_score": 0.01623, "epss_percentile": 0.814}, "CVE-2004-1104": {"epss_score": 0.37165, "epss_percentile": 0.97024}, "CVE-2004-1105": {"epss_score": 0.03769, "epss_percentile": 0.877}, "CVE-2004-1106": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2004-1107": {"epss_score": 0.00072, "epss_percentile": 0.22365}, "CVE-2004-1108": {"epss_score": 0.00072, "epss_percentile": 0.22365}, "CVE-2004-1109": {"epss_score": 0.04891, "epss_percentile": 0.89263}, "CVE-2004-1110": {"epss_score": 0.00064, "epss_percentile": 0.20347}, "CVE-2004-1111": {"epss_score": 0.02789, "epss_percentile": 0.85661}, "CVE-2004-1112": {"epss_score": 0.00876, "epss_percentile": 0.74785}, "CVE-2004-1113": {"epss_score": 0.00528, "epss_percentile": 0.66537}, "CVE-2004-1114": {"epss_score": 0.14856, "epss_percentile": 0.94303}, "CVE-2004-1115": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2004-1116": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2004-1117": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2004-1118": {"epss_score": 0.13768, "epss_percentile": 0.94054}, "CVE-2004-1119": {"epss_score": 0.55441, "epss_percentile": 0.97978}, "CVE-2004-1120": {"epss_score": 0.10188, "epss_percentile": 0.92886}, "CVE-2004-1121": {"epss_score": 0.11173, "epss_percentile": 0.93253}, "CVE-2004-1122": {"epss_score": 0.00786, "epss_percentile": 0.73298}, "CVE-2004-1123": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2004-1124": {"epss_score": 0.00103, "epss_percentile": 0.29087}, "CVE-2004-1125": {"epss_score": 0.07314, "epss_percentile": 0.91403}, "CVE-2004-1127": {"epss_score": 0.07192, "epss_percentile": 0.91311}, "CVE-2004-1128": {"epss_score": 0.05634, "epss_percentile": 0.90071}, "CVE-2004-1129": {"epss_score": 0.00497, "epss_percentile": 0.65178}, "CVE-2004-1130": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2004-1131": {"epss_score": 0.00078, "epss_percentile": 0.23585}, "CVE-2004-1133": {"epss_score": 0.13944, "epss_percentile": 0.94098}, "CVE-2004-1134": {"epss_score": 0.8642, "epss_percentile": 0.99381}, "CVE-2004-1135": {"epss_score": 0.51264, "epss_percentile": 0.97771}, "CVE-2004-1136": {"epss_score": 0.00497, "epss_percentile": 0.65187}, "CVE-2004-1137": {"epss_score": 0.15821, "epss_percentile": 0.94514}, "CVE-2004-1138": {"epss_score": 0.00067, "epss_percentile": 0.21092}, "CVE-2004-1139": {"epss_score": 0.06148, "epss_percentile": 0.9052}, "CVE-2004-1140": {"epss_score": 0.04202, "epss_percentile": 0.88389}, "CVE-2004-1141": {"epss_score": 0.04202, "epss_percentile": 0.88389}, "CVE-2004-1142": {"epss_score": 0.08831, "epss_percentile": 0.92273}, "CVE-2004-1143": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-1144": {"epss_score": 0.00061, "epss_percentile": 0.19306}, "CVE-2004-1145": {"epss_score": 0.06708, "epss_percentile": 0.90961}, "CVE-2004-1146": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2004-1147": {"epss_score": 0.04568, "epss_percentile": 0.8886}, "CVE-2004-1148": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2004-1149": {"epss_score": 0.00057, "epss_percentile": 0.18073}, "CVE-2004-1150": {"epss_score": 0.06625, "epss_percentile": 0.90898}, "CVE-2004-1151": {"epss_score": 0.0015, "epss_percentile": 0.36058}, "CVE-2004-1152": {"epss_score": 0.23008, "epss_percentile": 0.95716}, "CVE-2004-1153": {"epss_score": 0.14946, "epss_percentile": 0.94331}, "CVE-2004-1154": {"epss_score": 0.27766, "epss_percentile": 0.9628}, "CVE-2004-1155": {"epss_score": 0.17393, "epss_percentile": 0.94843}, "CVE-2004-1156": {"epss_score": 0.01299, "epss_percentile": 0.79284}, "CVE-2004-1157": {"epss_score": 0.00673, "epss_percentile": 0.70834}, "CVE-2004-1158": {"epss_score": 0.03863, "epss_percentile": 0.87867}, "CVE-2004-1160": {"epss_score": 0.01048, "epss_percentile": 0.77048}, "CVE-2004-1161": {"epss_score": 0.04734, "epss_percentile": 0.89073}, "CVE-2004-1162": {"epss_score": 0.00651, "epss_percentile": 0.70302}, "CVE-2004-1163": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2004-1164": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-1165": {"epss_score": 0.11107, "epss_percentile": 0.93223}, "CVE-2004-1166": {"epss_score": 0.6609, "epss_percentile": 0.9845}, "CVE-2004-1167": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2004-1168": {"epss_score": 0.04593, "epss_percentile": 0.88893}, "CVE-2004-1169": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2004-1170": {"epss_score": 0.15592, "epss_percentile": 0.94466}, "CVE-2004-1171": {"epss_score": 0.00125, "epss_percentile": 0.32576}, "CVE-2004-1172": {"epss_score": 0.82222, "epss_percentile": 0.99181}, "CVE-2004-1173": {"epss_score": 0.07461, "epss_percentile": 0.91485}, "CVE-2004-1174": {"epss_score": 0.01138, "epss_percentile": 0.77935}, "CVE-2004-1175": {"epss_score": 0.00949, "epss_percentile": 0.7585}, "CVE-2004-1176": {"epss_score": 0.02206, "epss_percentile": 0.84004}, "CVE-2004-1177": {"epss_score": 0.01585, "epss_percentile": 0.81165}, "CVE-2004-1179": {"epss_score": 0.00096, "epss_percentile": 0.27346}, "CVE-2004-1180": {"epss_score": 0.00952, "epss_percentile": 0.75873}, "CVE-2004-1181": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2004-1182": {"epss_score": 0.00552, "epss_percentile": 0.67386}, "CVE-2004-1183": {"epss_score": 0.02991, "epss_percentile": 0.86144}, "CVE-2004-1184": {"epss_score": 0.00943, "epss_percentile": 0.75771}, "CVE-2004-1185": {"epss_score": 0.07389, "epss_percentile": 0.91448}, "CVE-2004-1186": {"epss_score": 0.0816, "epss_percentile": 0.91909}, "CVE-2004-1187": {"epss_score": 0.05704, "epss_percentile": 0.90136}, "CVE-2004-1188": {"epss_score": 0.00495, "epss_percentile": 0.6512}, "CVE-2004-1189": {"epss_score": 0.00088, "epss_percentile": 0.25751}, "CVE-2004-1190": {"epss_score": 0.00085, "epss_percentile": 0.25241}, "CVE-2004-1191": {"epss_score": 0.00073, "epss_percentile": 0.22496}, "CVE-2004-1192": {"epss_score": 0.05978, "epss_percentile": 0.90376}, "CVE-2004-1193": {"epss_score": 0.00045, "epss_percentile": 0.13763}, "CVE-2004-1194": {"epss_score": 0.04656, "epss_percentile": 0.88973}, "CVE-2004-1195": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2004-1196": {"epss_score": 0.04734, "epss_percentile": 0.89073}, "CVE-2004-1197": {"epss_score": 0.01209, "epss_percentile": 0.78542}, "CVE-2004-1198": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2004-1199": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2004-1200": {"epss_score": 0.01327, "epss_percentile": 0.79491}, "CVE-2004-1201": {"epss_score": 0.01775, "epss_percentile": 0.82213}, "CVE-2004-1202": {"epss_score": 0.01338, "epss_percentile": 0.79568}, "CVE-2004-1203": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2004-1204": {"epss_score": 0.00074, "epss_percentile": 0.22789}, "CVE-2004-1205": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2004-1206": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2004-1207": {"epss_score": 0.08122, "epss_percentile": 0.91889}, "CVE-2004-1208": {"epss_score": 0.09293, "epss_percentile": 0.92486}, "CVE-2004-1209": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2004-1210": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2004-1211": {"epss_score": 0.80539, "epss_percentile": 0.99093}, "CVE-2004-1212": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2004-1213": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2004-1214": {"epss_score": 0.06994, "epss_percentile": 0.9117}, "CVE-2004-1215": {"epss_score": 0.05816, "epss_percentile": 0.90232}, "CVE-2004-1216": {"epss_score": 0.05816, "epss_percentile": 0.90232}, "CVE-2004-1217": {"epss_score": 0.00568, "epss_percentile": 0.67886}, "CVE-2004-1218": {"epss_score": 0.03298, "epss_percentile": 0.86859}, "CVE-2004-1219": {"epss_score": 0.00587, "epss_percentile": 0.68466}, "CVE-2004-1220": {"epss_score": 0.10765, "epss_percentile": 0.93097}, "CVE-2004-1221": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2004-1222": {"epss_score": 0.03481, "epss_percentile": 0.8722}, "CVE-2004-1223": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2004-1224": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-2004-1225": {"epss_score": 0.00599, "epss_percentile": 0.68806}, "CVE-2004-1226": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2004-1227": {"epss_score": 0.04219, "epss_percentile": 0.88409}, "CVE-2004-1228": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-2004-1229": {"epss_score": 0.01075, "epss_percentile": 0.77308}, "CVE-2004-1230": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2004-1231": {"epss_score": 0.00229, "epss_percentile": 0.45619}, "CVE-2004-1232": {"epss_score": 0.0517, "epss_percentile": 0.89568}, "CVE-2004-1233": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-1234": {"epss_score": 0.00137, "epss_percentile": 0.34292}, "CVE-2004-1235": {"epss_score": 0.00084, "epss_percentile": 0.24889}, "CVE-2004-1236": {"epss_score": 0.34632, "epss_percentile": 0.96862}, "CVE-2004-1237": {"epss_score": 0.00058, "epss_percentile": 0.18446}, "CVE-2004-1244": {"epss_score": 0.42545, "epss_percentile": 0.97336}, "CVE-2004-1254": {"epss_score": 0.05202, "epss_percentile": 0.89607}, "CVE-2004-1255": {"epss_score": 0.03412, "epss_percentile": 0.87086}, "CVE-2004-1256": {"epss_score": 0.07965, "epss_percentile": 0.91794}, "CVE-2004-1257": {"epss_score": 0.05148, "epss_percentile": 0.89547}, "CVE-2004-1258": {"epss_score": 0.04896, "epss_percentile": 0.8927}, "CVE-2004-1259": {"epss_score": 0.04047, "epss_percentile": 0.88174}, "CVE-2004-1260": {"epss_score": 0.08737, "epss_percentile": 0.92232}, "CVE-2004-1261": {"epss_score": 0.06741, "epss_percentile": 0.90995}, "CVE-2004-1262": {"epss_score": 0.03412, "epss_percentile": 0.87086}, "CVE-2004-1263": {"epss_score": 0.00067, "epss_percentile": 0.21128}, "CVE-2004-1264": {"epss_score": 0.07336, "epss_percentile": 0.91417}, "CVE-2004-1265": {"epss_score": 0.03412, "epss_percentile": 0.87086}, "CVE-2004-1266": {"epss_score": 0.03412, "epss_percentile": 0.87086}, "CVE-2004-1267": {"epss_score": 0.23252, "epss_percentile": 0.95757}, "CVE-2004-1268": {"epss_score": 0.00107, "epss_percentile": 0.29616}, "CVE-2004-1269": {"epss_score": 0.08636, "epss_percentile": 0.92165}, "CVE-2004-1270": {"epss_score": 0.00107, "epss_percentile": 0.29616}, "CVE-2004-1271": {"epss_score": 0.03412, "epss_percentile": 0.87086}, "CVE-2004-1272": {"epss_score": 0.05148, "epss_percentile": 0.89547}, "CVE-2004-1273": {"epss_score": 0.04865, "epss_percentile": 0.89228}, "CVE-2004-1274": {"epss_score": 0.0324, "epss_percentile": 0.86727}, "CVE-2004-1275": {"epss_score": 0.03412, "epss_percentile": 0.87086}, "CVE-2004-1276": {"epss_score": 0.00062, "epss_percentile": 0.19691}, "CVE-2004-1277": {"epss_score": 0.00428, "epss_percentile": 0.61945}, "CVE-2004-1278": {"epss_score": 0.03412, "epss_percentile": 0.87086}, "CVE-2004-1279": {"epss_score": 0.09268, "epss_percentile": 0.92474}, "CVE-2004-1280": {"epss_score": 0.00718, "epss_percentile": 0.71916}, "CVE-2004-1281": {"epss_score": 0.00428, "epss_percentile": 0.61945}, "CVE-2004-1282": {"epss_score": 0.069, "epss_percentile": 0.91103}, "CVE-2004-1283": {"epss_score": 0.03412, "epss_percentile": 0.87086}, "CVE-2004-1284": {"epss_score": 0.05813, "epss_percentile": 0.90228}, "CVE-2004-1285": {"epss_score": 0.04439, "epss_percentile": 0.88692}, "CVE-2004-1286": {"epss_score": 0.07715, "epss_percentile": 0.91639}, "CVE-2004-1287": {"epss_score": 0.16447, "epss_percentile": 0.94662}, "CVE-2004-1288": {"epss_score": 0.08518, "epss_percentile": 0.92098}, "CVE-2004-1289": {"epss_score": 0.19278, "epss_percentile": 0.95158}, "CVE-2004-1290": {"epss_score": 0.10355, "epss_percentile": 0.92957}, "CVE-2004-1291": {"epss_score": 0.08625, "epss_percentile": 0.92159}, "CVE-2004-1292": {"epss_score": 0.06584, "epss_percentile": 0.90865}, "CVE-2004-1293": {"epss_score": 0.08636, "epss_percentile": 0.92165}, "CVE-2004-1294": {"epss_score": 0.00428, "epss_percentile": 0.61945}, "CVE-2004-1295": {"epss_score": 0.00058, "epss_percentile": 0.18446}, "CVE-2004-1296": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2004-1297": {"epss_score": 0.07758, "epss_percentile": 0.91663}, "CVE-2004-1298": {"epss_score": 0.05396, "epss_percentile": 0.89828}, "CVE-2004-1299": {"epss_score": 0.04047, "epss_percentile": 0.88174}, "CVE-2004-1300": {"epss_score": 0.02163, "epss_percentile": 0.83832}, "CVE-2004-1301": {"epss_score": 0.0503, "epss_percentile": 0.89414}, "CVE-2004-1302": {"epss_score": 0.03512, "epss_percentile": 0.87268}, "CVE-2004-1303": {"epss_score": 0.03653, "epss_percentile": 0.87511}, "CVE-2004-1304": {"epss_score": 0.0572, "epss_percentile": 0.9015}, "CVE-2004-1305": {"epss_score": 0.78473, "epss_percentile": 0.98988}, "CVE-2004-1306": {"epss_score": 0.47724, "epss_percentile": 0.97598}, "CVE-2004-1307": {"epss_score": 0.05111, "epss_percentile": 0.89509}, "CVE-2004-1308": {"epss_score": 0.12685, "epss_percentile": 0.93749}, "CVE-2004-1309": {"epss_score": 0.05476, "epss_percentile": 0.89914}, "CVE-2004-1310": {"epss_score": 0.05704, "epss_percentile": 0.90136}, "CVE-2004-1311": {"epss_score": 0.03418, "epss_percentile": 0.87095}, "CVE-2004-1312": {"epss_score": 0.00992, "epss_percentile": 0.76394}, "CVE-2004-1313": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2004-1314": {"epss_score": 0.00968, "epss_percentile": 0.76078}, "CVE-2004-1315": {"epss_score": 0.85909, "epss_percentile": 0.99355}, "CVE-2004-1316": {"epss_score": 0.04823, "epss_percentile": 0.89181}, "CVE-2004-1317": {"epss_score": 0.78963, "epss_percentile": 0.99013}, "CVE-2004-1318": {"epss_score": 0.01496, "epss_percentile": 0.80684}, "CVE-2004-1319": {"epss_score": 0.31297, "epss_percentile": 0.96607}, "CVE-2004-1320": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2004-1321": {"epss_score": 0.00758, "epss_percentile": 0.72768}, "CVE-2004-1322": {"epss_score": 0.00784, "epss_percentile": 0.73239}, "CVE-2004-1323": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2004-1324": {"epss_score": 0.16718, "epss_percentile": 0.9472}, "CVE-2004-1325": {"epss_score": 0.47768, "epss_percentile": 0.976}, "CVE-2004-1326": {"epss_score": 0.00142, "epss_percentile": 0.34992}, "CVE-2004-1327": {"epss_score": 0.0463, "epss_percentile": 0.88944}, "CVE-2004-1328": {"epss_score": 0.00061, "epss_percentile": 0.19278}, "CVE-2004-1329": {"epss_score": 0.00575, "epss_percentile": 0.68109}, "CVE-2004-1330": {"epss_score": 0.00331, "epss_percentile": 0.55535}, "CVE-2004-1331": {"epss_score": 0.20802, "epss_percentile": 0.95415}, "CVE-2004-1332": {"epss_score": 0.11894, "epss_percentile": 0.93509}, "CVE-2004-1333": {"epss_score": 0.00197, "epss_percentile": 0.41904}, "CVE-2004-1334": {"epss_score": 0.00073, "epss_percentile": 0.22486}, "CVE-2004-1335": {"epss_score": 0.00289, "epss_percentile": 0.52074}, "CVE-2004-1336": {"epss_score": 0.00064, "epss_percentile": 0.20356}, "CVE-2004-1337": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2004-1338": {"epss_score": 0.00303, "epss_percentile": 0.53225}, "CVE-2004-1339": {"epss_score": 0.00487, "epss_percentile": 0.64801}, "CVE-2004-1340": {"epss_score": 0.00058, "epss_percentile": 0.18288}, "CVE-2004-1341": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2004-1342": {"epss_score": 0.00335, "epss_percentile": 0.55859}, "CVE-2004-1343": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2004-1345": {"epss_score": 0.00065, "epss_percentile": 0.20541}, "CVE-2004-1346": {"epss_score": 0.00087, "epss_percentile": 0.25606}, "CVE-2004-1347": {"epss_score": 0.03384, "epss_percentile": 0.87037}, "CVE-2004-1348": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2004-1349": {"epss_score": 0.00109, "epss_percentile": 0.29919}, "CVE-2004-1350": {"epss_score": 0.25414, "epss_percentile": 0.96025}, "CVE-2004-1351": {"epss_score": 0.14682, "epss_percentile": 0.94263}, "CVE-2004-1352": {"epss_score": 0.00084, "epss_percentile": 0.2488}, "CVE-2004-1353": {"epss_score": 0.00058, "epss_percentile": 0.18419}, "CVE-2004-1354": {"epss_score": 0.03275, "epss_percentile": 0.86802}, "CVE-2004-1355": {"epss_score": 0.00088, "epss_percentile": 0.25771}, "CVE-2004-1356": {"epss_score": 0.00063, "epss_percentile": 0.20082}, "CVE-2004-1357": {"epss_score": 0.04977, "epss_percentile": 0.89356}, "CVE-2004-1358": {"epss_score": 0.0054, "epss_percentile": 0.67001}, "CVE-2004-1359": {"epss_score": 0.00094, "epss_percentile": 0.26798}, "CVE-2004-1360": {"epss_score": 0.00236, "epss_percentile": 0.46424}, "CVE-2004-1361": {"epss_score": 0.29105, "epss_percentile": 0.96418}, "CVE-2004-1362": {"epss_score": 0.04002, "epss_percentile": 0.88095}, "CVE-2004-1363": {"epss_score": 0.27664, "epss_percentile": 0.9627}, "CVE-2004-1364": {"epss_score": 0.15168, "epss_percentile": 0.94379}, "CVE-2004-1365": {"epss_score": 0.00329, "epss_percentile": 0.55386}, "CVE-2004-1366": {"epss_score": 0.00295, "epss_percentile": 0.52496}, "CVE-2004-1367": {"epss_score": 0.00376, "epss_percentile": 0.58666}, "CVE-2004-1368": {"epss_score": 0.05303, "epss_percentile": 0.89709}, "CVE-2004-1369": {"epss_score": 0.03775, "epss_percentile": 0.87709}, "CVE-2004-1370": {"epss_score": 0.01812, "epss_percentile": 0.82371}, "CVE-2004-1371": {"epss_score": 0.32439, "epss_percentile": 0.967}, "CVE-2004-1372": {"epss_score": 0.00051, "epss_percentile": 0.16108}, "CVE-2004-1373": {"epss_score": 0.86852, "epss_percentile": 0.99402}, "CVE-2004-1374": {"epss_score": 0.00055, "epss_percentile": 0.17535}, "CVE-2004-1375": {"epss_score": 0.00107, "epss_percentile": 0.29741}, "CVE-2004-1376": {"epss_score": 0.11239, "epss_percentile": 0.93275}, "CVE-2004-1377": {"epss_score": 0.00072, "epss_percentile": 0.22419}, "CVE-2004-1378": {"epss_score": 0.02929, "epss_percentile": 0.86014}, "CVE-2004-1379": {"epss_score": 0.0354, "epss_percentile": 0.87316}, "CVE-2004-1380": {"epss_score": 0.14501, "epss_percentile": 0.94226}, "CVE-2004-1381": {"epss_score": 0.15271, "epss_percentile": 0.94396}, "CVE-2004-1382": {"epss_score": 0.00087, "epss_percentile": 0.25576}, "CVE-2004-1383": {"epss_score": 0.01134, "epss_percentile": 0.7789}, "CVE-2004-1384": {"epss_score": 0.03206, "epss_percentile": 0.86634}, "CVE-2004-1385": {"epss_score": 0.04586, "epss_percentile": 0.88886}, "CVE-2004-1386": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2004-1387": {"epss_score": 0.00264, "epss_percentile": 0.49583}, "CVE-2004-1388": {"epss_score": 0.74545, "epss_percentile": 0.98807}, "CVE-2004-1389": {"epss_score": 0.28256, "epss_percentile": 0.96338}, "CVE-2004-1390": {"epss_score": 0.25568, "epss_percentile": 0.96044}, "CVE-2004-1391": {"epss_score": 0.0026, "epss_percentile": 0.4918}, "CVE-2004-1392": {"epss_score": 0.07585, "epss_percentile": 0.91555}, "CVE-2004-1393": {"epss_score": 0.01589, "epss_percentile": 0.81196}, "CVE-2004-1394": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2004-1395": {"epss_score": 0.1412, "epss_percentile": 0.94137}, "CVE-2004-1396": {"epss_score": 0.02613, "epss_percentile": 0.8524}, "CVE-2004-1397": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2004-1398": {"epss_score": 0.00104, "epss_percentile": 0.29195}, "CVE-2004-1399": {"epss_score": 0.00457, "epss_percentile": 0.63366}, "CVE-2004-1400": {"epss_score": 0.03044, "epss_percentile": 0.86278}, "CVE-2004-1401": {"epss_score": 0.0125, "epss_percentile": 0.78877}, "CVE-2004-1402": {"epss_score": 0.00397, "epss_percentile": 0.60029}, "CVE-2004-1403": {"epss_score": 0.01075, "epss_percentile": 0.77308}, "CVE-2004-1404": {"epss_score": 0.02468, "epss_percentile": 0.84841}, "CVE-2004-1405": {"epss_score": 0.10161, "epss_percentile": 0.9287}, "CVE-2004-1406": {"epss_score": 0.00416, "epss_percentile": 0.61167}, "CVE-2004-1407": {"epss_score": 0.00484, "epss_percentile": 0.64643}, "CVE-2004-1408": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2004-1409": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2004-1410": {"epss_score": 0.00458, "epss_percentile": 0.63449}, "CVE-2004-1411": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-1412": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2004-1413": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2004-1414": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2004-1415": {"epss_score": 0.00475, "epss_percentile": 0.64246}, "CVE-2004-1416": {"epss_score": 0.01381, "epss_percentile": 0.79871}, "CVE-2004-1417": {"epss_score": 0.00766, "epss_percentile": 0.72931}, "CVE-2004-1418": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2004-1419": {"epss_score": 0.04005, "epss_percentile": 0.881}, "CVE-2004-1420": {"epss_score": 0.01306, "epss_percentile": 0.79336}, "CVE-2004-1421": {"epss_score": 0.0765, "epss_percentile": 0.91604}, "CVE-2004-1422": {"epss_score": 0.10869, "epss_percentile": 0.9314}, "CVE-2004-1423": {"epss_score": 0.10744, "epss_percentile": 0.9309}, "CVE-2004-1424": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2004-1425": {"epss_score": 0.00539, "epss_percentile": 0.66986}, "CVE-2004-1426": {"epss_score": 0.00219, "epss_percentile": 0.44474}, "CVE-2004-1427": {"epss_score": 0.01048, "epss_percentile": 0.77048}, "CVE-2004-1428": {"epss_score": 0.01097, "epss_percentile": 0.77524}, "CVE-2004-1429": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2004-1430": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2004-1431": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2004-1432": {"epss_score": 0.03307, "epss_percentile": 0.8688}, "CVE-2004-1433": {"epss_score": 0.03307, "epss_percentile": 0.8688}, "CVE-2004-1434": {"epss_score": 0.02009, "epss_percentile": 0.83243}, "CVE-2004-1435": {"epss_score": 0.01191, "epss_percentile": 0.78394}, "CVE-2004-1436": {"epss_score": 0.01191, "epss_percentile": 0.78394}, "CVE-2004-1437": {"epss_score": 0.15387, "epss_percentile": 0.94421}, "CVE-2004-1438": {"epss_score": 0.00246, "epss_percentile": 0.47766}, "CVE-2004-1439": {"epss_score": 0.31804, "epss_percentile": 0.9665}, "CVE-2004-1440": {"epss_score": 0.03466, "epss_percentile": 0.87191}, "CVE-2004-1441": {"epss_score": 0.03296, "epss_percentile": 0.86859}, "CVE-2004-1442": {"epss_score": 0.07887, "epss_percentile": 0.91744}, "CVE-2004-1443": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2004-1444": {"epss_score": 0.16535, "epss_percentile": 0.94687}, "CVE-2004-1445": {"epss_score": 0.00091, "epss_percentile": 0.26259}, "CVE-2004-1446": {"epss_score": 0.01225, "epss_percentile": 0.78682}, "CVE-2004-1447": {"epss_score": 0.007, "epss_percentile": 0.71473}, "CVE-2004-1448": {"epss_score": 0.03243, "epss_percentile": 0.86739}, "CVE-2004-1449": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2004-1450": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2004-1451": {"epss_score": 0.00448, "epss_percentile": 0.63026}, "CVE-2004-1452": {"epss_score": 0.00058, "epss_percentile": 0.18582}, "CVE-2004-1453": {"epss_score": 0.00078, "epss_percentile": 0.23623}, "CVE-2004-1454": {"epss_score": 0.01985, "epss_percentile": 0.83153}, "CVE-2004-1455": {"epss_score": 0.04348, "epss_percentile": 0.8858}, "CVE-2004-1456": {"epss_score": 0.54209, "epss_percentile": 0.97915}, "CVE-2004-1457": {"epss_score": 0.01883, "epss_percentile": 0.82702}, "CVE-2004-1458": {"epss_score": 0.01122, "epss_percentile": 0.77778}, "CVE-2004-1459": {"epss_score": 0.00824, "epss_percentile": 0.73937}, "CVE-2004-1460": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2004-1461": {"epss_score": 0.00515, "epss_percentile": 0.65986}, "CVE-2004-1462": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-1463": {"epss_score": 0.0061, "epss_percentile": 0.69162}, "CVE-2004-1464": {"epss_score": 0.01698, "epss_percentile": 0.8182}, "CVE-2004-1465": {"epss_score": 0.02539, "epss_percentile": 0.85045}, "CVE-2004-1466": {"epss_score": 0.11985, "epss_percentile": 0.93536}, "CVE-2004-1467": {"epss_score": 0.05067, "epss_percentile": 0.89458}, "CVE-2004-1468": {"epss_score": 0.04781, "epss_percentile": 0.89136}, "CVE-2004-1469": {"epss_score": 0.00126, "epss_percentile": 0.32623}, "CVE-2004-1470": {"epss_score": 0.05863, "epss_percentile": 0.90272}, "CVE-2004-1471": {"epss_score": 0.05947, "epss_percentile": 0.90354}, "CVE-2004-1472": {"epss_score": 0.05678, "epss_percentile": 0.90114}, "CVE-2004-1473": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2004-1474": {"epss_score": 0.0452, "epss_percentile": 0.88798}, "CVE-2004-1475": {"epss_score": 0.05483, "epss_percentile": 0.89921}, "CVE-2004-1476": {"epss_score": 0.02053, "epss_percentile": 0.83415}, "CVE-2004-1477": {"epss_score": 0.03049, "epss_percentile": 0.86288}, "CVE-2004-1478": {"epss_score": 0.07163, "epss_percentile": 0.91293}, "CVE-2004-1480": {"epss_score": 0.0051, "epss_percentile": 0.65793}, "CVE-2004-1481": {"epss_score": 0.069, "epss_percentile": 0.91103}, "CVE-2004-1482": {"epss_score": 0.00808, "epss_percentile": 0.73696}, "CVE-2004-1483": {"epss_score": 0.02773, "epss_percentile": 0.85631}, "CVE-2004-1484": {"epss_score": 0.02313, "epss_percentile": 0.84345}, "CVE-2004-1485": {"epss_score": 0.01636, "epss_percentile": 0.81476}, "CVE-2004-1486": {"epss_score": 0.01117, "epss_percentile": 0.77742}, "CVE-2004-1487": {"epss_score": 0.0069, "epss_percentile": 0.71242}, "CVE-2004-1488": {"epss_score": 0.13302, "epss_percentile": 0.93927}, "CVE-2004-1489": {"epss_score": 0.00408, "epss_percentile": 0.60678}, "CVE-2004-1490": {"epss_score": 0.01133, "epss_percentile": 0.77879}, "CVE-2004-1491": {"epss_score": 0.2586, "epss_percentile": 0.96086}, "CVE-2004-1492": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2004-1493": {"epss_score": 0.05245, "epss_percentile": 0.89658}, "CVE-2004-1494": {"epss_score": 0.02237, "epss_percentile": 0.84103}, "CVE-2004-1495": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-1496": {"epss_score": 0.00185, "epss_percentile": 0.40523}, "CVE-2004-1497": {"epss_score": 0.00059, "epss_percentile": 0.18671}, "CVE-2004-1498": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2004-1499": {"epss_score": 0.00594, "epss_percentile": 0.68662}, "CVE-2004-1500": {"epss_score": 0.01347, "epss_percentile": 0.79657}, "CVE-2004-1501": {"epss_score": 0.00634, "epss_percentile": 0.69799}, "CVE-2004-1502": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2004-1503": {"epss_score": 0.00928, "epss_percentile": 0.75578}, "CVE-2004-1504": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2004-1505": {"epss_score": 0.01288, "epss_percentile": 0.79204}, "CVE-2004-1506": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2004-1507": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2004-1508": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2004-1509": {"epss_score": 0.00421, "epss_percentile": 0.61534}, "CVE-2004-1510": {"epss_score": 0.01464, "epss_percentile": 0.80448}, "CVE-2004-1511": {"epss_score": 0.00872, "epss_percentile": 0.74731}, "CVE-2004-1512": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2004-1513": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2004-1514": {"epss_score": 0.01122, "epss_percentile": 0.77778}, "CVE-2004-1515": {"epss_score": 0.00334, "epss_percentile": 0.55699}, "CVE-2004-1516": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2004-1517": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2004-1518": {"epss_score": 0.00583, "epss_percentile": 0.68325}, "CVE-2004-1519": {"epss_score": 0.00677, "epss_percentile": 0.7096}, "CVE-2004-1520": {"epss_score": 0.88797, "epss_percentile": 0.99491}, "CVE-2004-1521": {"epss_score": 0.03446, "epss_percentile": 0.87149}, "CVE-2004-1522": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2004-1523": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2004-1524": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2004-1525": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2004-1526": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2004-1527": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2004-1528": {"epss_score": 0.0059, "epss_percentile": 0.6855}, "CVE-2004-1529": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2004-1530": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2004-1531": {"epss_score": 0.0082, "epss_percentile": 0.73888}, "CVE-2004-1532": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2004-1533": {"epss_score": 0.06627, "epss_percentile": 0.909}, "CVE-2004-1534": {"epss_score": 0.00484, "epss_percentile": 0.6463}, "CVE-2004-1535": {"epss_score": 0.02238, "epss_percentile": 0.84107}, "CVE-2004-1536": {"epss_score": 0.0053, "epss_percentile": 0.66607}, "CVE-2004-1537": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2004-1538": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2004-1539": {"epss_score": 0.07074, "epss_percentile": 0.91232}, "CVE-2004-1540": {"epss_score": 0.05145, "epss_percentile": 0.89541}, "CVE-2004-1541": {"epss_score": 0.01014, "epss_percentile": 0.76646}, "CVE-2004-1542": {"epss_score": 0.05941, "epss_percentile": 0.90349}, "CVE-2004-1543": {"epss_score": 0.05935, "epss_percentile": 0.90342}, "CVE-2004-1544": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2004-1545": {"epss_score": 0.01796, "epss_percentile": 0.82307}, "CVE-2004-1546": {"epss_score": 0.49487, "epss_percentile": 0.97691}, "CVE-2004-1547": {"epss_score": 0.01632, "epss_percentile": 0.81458}, "CVE-2004-1548": {"epss_score": 0.0235, "epss_percentile": 0.84468}, "CVE-2004-1549": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2004-1550": {"epss_score": 0.39501, "epss_percentile": 0.97164}, "CVE-2004-1551": {"epss_score": 0.00547, "epss_percentile": 0.67232}, "CVE-2004-1552": {"epss_score": 0.04304, "epss_percentile": 0.88519}, "CVE-2004-1553": {"epss_score": 0.04063, "epss_percentile": 0.88193}, "CVE-2004-1554": {"epss_score": 0.04511, "epss_percentile": 0.88781}, "CVE-2004-1555": {"epss_score": 0.02342, "epss_percentile": 0.8444}, "CVE-2004-1556": {"epss_score": 0.00804, "epss_percentile": 0.73611}, "CVE-2004-1557": {"epss_score": 0.00512, "epss_percentile": 0.65855}, "CVE-2004-1558": {"epss_score": 0.86295, "epss_percentile": 0.99377}, "CVE-2004-1559": {"epss_score": 0.01332, "epss_percentile": 0.79524}, "CVE-2004-1560": {"epss_score": 0.14122, "epss_percentile": 0.94138}, "CVE-2004-1561": {"epss_score": 0.82174, "epss_percentile": 0.99178}, "CVE-2004-1562": {"epss_score": 0.00553, "epss_percentile": 0.6742}, "CVE-2004-1563": {"epss_score": 0.00578, "epss_percentile": 0.68192}, "CVE-2004-1564": {"epss_score": 0.06194, "epss_percentile": 0.90556}, "CVE-2004-1565": {"epss_score": 0.00927, "epss_percentile": 0.75561}, "CVE-2004-1566": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2004-1567": {"epss_score": 0.05708, "epss_percentile": 0.90139}, "CVE-2004-1568": {"epss_score": 0.01334, "epss_percentile": 0.79538}, "CVE-2004-1569": {"epss_score": 0.13008, "epss_percentile": 0.93845}, "CVE-2004-1570": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2004-1571": {"epss_score": 0.00896, "epss_percentile": 0.7512}, "CVE-2004-1572": {"epss_score": 0.00588, "epss_percentile": 0.68494}, "CVE-2004-1573": {"epss_score": 0.00036, "epss_percentile": 0.10206}, "CVE-2004-1574": {"epss_score": 0.07373, "epss_percentile": 0.9144}, "CVE-2004-1575": {"epss_score": 0.03686, "epss_percentile": 0.87571}, "CVE-2004-1576": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-1577": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2004-1578": {"epss_score": 0.00497, "epss_percentile": 0.65181}, "CVE-2004-1579": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2004-1580": {"epss_score": 0.00824, "epss_percentile": 0.7394}, "CVE-2004-1581": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2004-1582": {"epss_score": 0.01075, "epss_percentile": 0.77308}, "CVE-2004-1583": {"epss_score": 0.00546, "epss_percentile": 0.67217}, "CVE-2004-1584": {"epss_score": 0.16, "epss_percentile": 0.94551}, "CVE-2004-1585": {"epss_score": 0.06171, "epss_percentile": 0.9053}, "CVE-2004-1586": {"epss_score": 0.00176, "epss_percentile": 0.39433}, "CVE-2004-1587": {"epss_score": 0.12462, "epss_percentile": 0.9368}, "CVE-2004-1588": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2004-1589": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2004-1590": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2004-1591": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2004-1592": {"epss_score": 0.04846, "epss_percentile": 0.89209}, "CVE-2004-1593": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2004-1594": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2004-1595": {"epss_score": 0.79617, "epss_percentile": 0.99049}, "CVE-2004-1596": {"epss_score": 0.05471, "epss_percentile": 0.89909}, "CVE-2004-1597": {"epss_score": 0.02035, "epss_percentile": 0.83351}, "CVE-2004-1598": {"epss_score": 0.01652, "epss_percentile": 0.8157}, "CVE-2004-1599": {"epss_score": 0.00565, "epss_percentile": 0.67806}, "CVE-2004-1600": {"epss_score": 0.00517, "epss_percentile": 0.66091}, "CVE-2004-1601": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2004-1602": {"epss_score": 0.0083, "epss_percentile": 0.74024}, "CVE-2004-1603": {"epss_score": 0.00122, "epss_percentile": 0.32056}, "CVE-2004-1604": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2004-1605": {"epss_score": 0.01034, "epss_percentile": 0.76891}, "CVE-2004-1606": {"epss_score": 0.01802, "epss_percentile": 0.82331}, "CVE-2004-1607": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2004-1608": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2004-1609": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2004-1610": {"epss_score": 0.01734, "epss_percentile": 0.82001}, "CVE-2004-1611": {"epss_score": 0.01495, "epss_percentile": 0.80657}, "CVE-2004-1612": {"epss_score": 0.12809, "epss_percentile": 0.93781}, "CVE-2004-1613": {"epss_score": 0.01358, "epss_percentile": 0.79728}, "CVE-2004-1614": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2004-1615": {"epss_score": 0.01569, "epss_percentile": 0.81081}, "CVE-2004-1616": {"epss_score": 0.01302, "epss_percentile": 0.79297}, "CVE-2004-1617": {"epss_score": 0.03666, "epss_percentile": 0.87533}, "CVE-2004-1618": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2004-1619": {"epss_score": 0.06854, "epss_percentile": 0.91075}, "CVE-2004-1620": {"epss_score": 0.08354, "epss_percentile": 0.92005}, "CVE-2004-1621": {"epss_score": 0.04011, "epss_percentile": 0.88113}, "CVE-2004-1622": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2004-1623": {"epss_score": 0.38705, "epss_percentile": 0.97116}, "CVE-2004-1624": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2004-1625": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-1626": {"epss_score": 0.73355, "epss_percentile": 0.98748}, "CVE-2004-1627": {"epss_score": 0.16727, "epss_percentile": 0.94723}, "CVE-2004-1628": {"epss_score": 0.02555, "epss_percentile": 0.8509}, "CVE-2004-1629": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2004-1630": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2004-1631": {"epss_score": 0.00438, "epss_percentile": 0.62564}, "CVE-2004-1632": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2004-1633": {"epss_score": 0.00288, "epss_percentile": 0.51873}, "CVE-2004-1634": {"epss_score": 0.00438, "epss_percentile": 0.62564}, "CVE-2004-1635": {"epss_score": 0.00619, "epss_percentile": 0.69393}, "CVE-2004-1636": {"epss_score": 0.06815, "epss_percentile": 0.91043}, "CVE-2004-1637": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2004-1638": {"epss_score": 0.79074, "epss_percentile": 0.99018}, "CVE-2004-1639": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2004-1640": {"epss_score": 0.00949, "epss_percentile": 0.75844}, "CVE-2004-1641": {"epss_score": 0.00881, "epss_percentile": 0.74878}, "CVE-2004-1642": {"epss_score": 0.06022, "epss_percentile": 0.90417}, "CVE-2004-1643": {"epss_score": 0.09472, "epss_percentile": 0.92562}, "CVE-2004-1644": {"epss_score": 0.01075, "epss_percentile": 0.77311}, "CVE-2004-1645": {"epss_score": 0.00891, "epss_percentile": 0.7505}, "CVE-2004-1646": {"epss_score": 0.05112, "epss_percentile": 0.8951}, "CVE-2004-1647": {"epss_score": 0.00795, "epss_percentile": 0.73462}, "CVE-2004-1648": {"epss_score": 0.00565, "epss_percentile": 0.67806}, "CVE-2004-1649": {"epss_score": 0.01505, "epss_percentile": 0.80742}, "CVE-2004-1650": {"epss_score": 0.05292, "epss_percentile": 0.89698}, "CVE-2004-1651": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2004-1652": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2004-1653": {"epss_score": 0.00375, "epss_percentile": 0.58632}, "CVE-2004-1654": {"epss_score": 0.01135, "epss_percentile": 0.77913}, "CVE-2004-1655": {"epss_score": 0.02138, "epss_percentile": 0.8374}, "CVE-2004-1656": {"epss_score": 0.05832, "epss_percentile": 0.90244}, "CVE-2004-1657": {"epss_score": 0.00823, "epss_percentile": 0.73923}, "CVE-2004-1658": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2004-1659": {"epss_score": 0.00655, "epss_percentile": 0.70428}, "CVE-2004-1660": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2004-1661": {"epss_score": 0.04149, "epss_percentile": 0.88319}, "CVE-2004-1662": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2004-1663": {"epss_score": 0.00398, "epss_percentile": 0.60086}, "CVE-2004-1664": {"epss_score": 0.05737, "epss_percentile": 0.90165}, "CVE-2004-1665": {"epss_score": 0.00722, "epss_percentile": 0.71991}, "CVE-2004-1666": {"epss_score": 0.05973, "epss_percentile": 0.90374}, "CVE-2004-1667": {"epss_score": 0.01475, "epss_percentile": 0.80526}, "CVE-2004-1668": {"epss_score": 0.00927, "epss_percentile": 0.75561}, "CVE-2004-1669": {"epss_score": 0.00376, "epss_percentile": 0.58656}, "CVE-2004-1670": {"epss_score": 0.01031, "epss_percentile": 0.76853}, "CVE-2004-1671": {"epss_score": 0.00457, "epss_percentile": 0.63389}, "CVE-2004-1672": {"epss_score": 0.01048, "epss_percentile": 0.77048}, "CVE-2004-1673": {"epss_score": 0.01048, "epss_percentile": 0.77048}, "CVE-2004-1674": {"epss_score": 0.00876, "epss_percentile": 0.7479}, "CVE-2004-1675": {"epss_score": 0.10741, "epss_percentile": 0.93089}, "CVE-2004-1676": {"epss_score": 0.0617, "epss_percentile": 0.9053}, "CVE-2004-1677": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2004-1678": {"epss_score": 0.05103, "epss_percentile": 0.89503}, "CVE-2004-1679": {"epss_score": 0.03887, "epss_percentile": 0.87905}, "CVE-2004-1680": {"epss_score": 0.00998, "epss_percentile": 0.76468}, "CVE-2004-1681": {"epss_score": 0.00129, "epss_percentile": 0.33095}, "CVE-2004-1682": {"epss_score": 0.007, "epss_percentile": 0.71474}, "CVE-2004-1683": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2004-1684": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2004-1685": {"epss_score": 0.00935, "epss_percentile": 0.75669}, "CVE-2004-1686": {"epss_score": 0.10697, "epss_percentile": 0.93075}, "CVE-2004-1687": {"epss_score": 0.07746, "epss_percentile": 0.91656}, "CVE-2004-1688": {"epss_score": 0.10353, "epss_percentile": 0.92956}, "CVE-2004-1689": {"epss_score": 0.00167, "epss_percentile": 0.38389}, "CVE-2004-1690": {"epss_score": 0.00871, "epss_percentile": 0.74714}, "CVE-2004-1691": {"epss_score": 0.06927, "epss_percentile": 0.9112}, "CVE-2004-1692": {"epss_score": 0.00831, "epss_percentile": 0.7404}, "CVE-2004-1693": {"epss_score": 0.0952, "epss_percentile": 0.92583}, "CVE-2004-1694": {"epss_score": 0.01358, "epss_percentile": 0.79727}, "CVE-2004-1695": {"epss_score": 0.09797, "epss_percentile": 0.92706}, "CVE-2004-1696": {"epss_score": 0.0195, "epss_percentile": 0.83013}, "CVE-2004-1697": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2004-1698": {"epss_score": 0.05887, "epss_percentile": 0.90296}, "CVE-2004-1699": {"epss_score": 0.09678, "epss_percentile": 0.92655}, "CVE-2004-1700": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2004-1701": {"epss_score": 0.56761, "epss_percentile": 0.98035}, "CVE-2004-1702": {"epss_score": 0.02116, "epss_percentile": 0.83663}, "CVE-2004-1703": {"epss_score": 0.00572, "epss_percentile": 0.68008}, "CVE-2004-1704": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2004-1705": {"epss_score": 0.25908, "epss_percentile": 0.96092}, "CVE-2004-1706": {"epss_score": 0.02961, "epss_percentile": 0.86072}, "CVE-2004-1707": {"epss_score": 0.12298, "epss_percentile": 0.93626}, "CVE-2004-1708": {"epss_score": 0.00651, "epss_percentile": 0.70301}, "CVE-2004-1709": {"epss_score": 0.00065, "epss_percentile": 0.2052}, "CVE-2004-1710": {"epss_score": 0.00982, "epss_percentile": 0.76295}, "CVE-2004-1711": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2004-1712": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2004-1713": {"epss_score": 0.00168, "epss_percentile": 0.38429}, "CVE-2004-1714": {"epss_score": 0.00141, "epss_percentile": 0.3487}, "CVE-2004-1715": {"epss_score": 0.01046, "epss_percentile": 0.77026}, "CVE-2004-1716": {"epss_score": 0.07281, "epss_percentile": 0.91382}, "CVE-2004-1717": {"epss_score": 0.09375, "epss_percentile": 0.92522}, "CVE-2004-1718": {"epss_score": 0.0007, "epss_percentile": 0.21947}, "CVE-2004-1719": {"epss_score": 0.00815, "epss_percentile": 0.73794}, "CVE-2004-1720": {"epss_score": 0.09092, "epss_percentile": 0.92398}, "CVE-2004-1721": {"epss_score": 0.01001, "epss_percentile": 0.76502}, "CVE-2004-1722": {"epss_score": 0.01378, "epss_percentile": 0.79849}, "CVE-2004-1723": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2004-1724": {"epss_score": 0.03633, "epss_percentile": 0.87477}, "CVE-2004-1725": {"epss_score": 0.04755, "epss_percentile": 0.89112}, "CVE-2004-1726": {"epss_score": 0.04755, "epss_percentile": 0.89112}, "CVE-2004-1727": {"epss_score": 0.05487, "epss_percentile": 0.89926}, "CVE-2004-1728": {"epss_score": 0.07954, "epss_percentile": 0.91787}, "CVE-2004-1729": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2004-1730": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2004-1731": {"epss_score": 0.04264, "epss_percentile": 0.88467}, "CVE-2004-1732": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2004-1733": {"epss_score": 0.00401, "epss_percentile": 0.60229}, "CVE-2004-1734": {"epss_score": 0.01015, "epss_percentile": 0.76663}, "CVE-2004-1735": {"epss_score": 0.03931, "epss_percentile": 0.87972}, "CVE-2004-1736": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2004-1737": {"epss_score": 0.03848, "epss_percentile": 0.87843}, "CVE-2004-1738": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2004-1739": {"epss_score": 0.05318, "epss_percentile": 0.89725}, "CVE-2004-1740": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2004-1741": {"epss_score": 0.05651, "epss_percentile": 0.90085}, "CVE-2004-1742": {"epss_score": 0.04819, "epss_percentile": 0.89176}, "CVE-2004-1743": {"epss_score": 0.00871, "epss_percentile": 0.74714}, "CVE-2004-1744": {"epss_score": 0.09463, "epss_percentile": 0.92559}, "CVE-2004-1745": {"epss_score": 0.10289, "epss_percentile": 0.92929}, "CVE-2004-1746": {"epss_score": 0.04969, "epss_percentile": 0.89347}, "CVE-2004-1747": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2004-1748": {"epss_score": 0.00421, "epss_percentile": 0.6151}, "CVE-2004-1749": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2004-1750": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2004-1751": {"epss_score": 0.06689, "epss_percentile": 0.90947}, "CVE-2004-1752": {"epss_score": 0.25257, "epss_percentile": 0.96004}, "CVE-2004-1753": {"epss_score": 0.00868, "epss_percentile": 0.74673}, "CVE-2004-1754": {"epss_score": 0.05104, "epss_percentile": 0.89503}, "CVE-2004-1755": {"epss_score": 0.00389, "epss_percentile": 0.59401}, "CVE-2004-1756": {"epss_score": 0.01811, "epss_percentile": 0.82368}, "CVE-2004-1757": {"epss_score": 0.00109, "epss_percentile": 0.2991}, "CVE-2004-1758": {"epss_score": 0.00162, "epss_percentile": 0.37617}, "CVE-2004-1759": {"epss_score": 0.03749, "epss_percentile": 0.87672}, "CVE-2004-1760": {"epss_score": 0.11906, "epss_percentile": 0.93511}, "CVE-2004-1761": {"epss_score": 0.00705, "epss_percentile": 0.71575}, "CVE-2004-1762": {"epss_score": 0.0049, "epss_percentile": 0.64921}, "CVE-2004-1763": {"epss_score": 0.31085, "epss_percentile": 0.96587}, "CVE-2004-1764": {"epss_score": 0.00076, "epss_percentile": 0.23083}, "CVE-2004-1765": {"epss_score": 0.22301, "epss_percentile": 0.9562}, "CVE-2004-1766": {"epss_score": 0.02458, "epss_percentile": 0.84814}, "CVE-2004-1767": {"epss_score": 0.00066, "epss_percentile": 0.20753}, "CVE-2004-1768": {"epss_score": 0.03103, "epss_percentile": 0.86413}, "CVE-2004-1769": {"epss_score": 0.0439, "epss_percentile": 0.88635}, "CVE-2004-1770": {"epss_score": 0.11893, "epss_percentile": 0.93508}, "CVE-2004-1771": {"epss_score": 0.00265, "epss_percentile": 0.49785}, "CVE-2004-1772": {"epss_score": 0.001, "epss_percentile": 0.28517}, "CVE-2004-1773": {"epss_score": 0.01845, "epss_percentile": 0.8251}, "CVE-2004-1774": {"epss_score": 0.0766, "epss_percentile": 0.91609}, "CVE-2004-1775": {"epss_score": 0.04007, "epss_percentile": 0.88103}, "CVE-2004-1776": {"epss_score": 0.01045, "epss_percentile": 0.77017}, "CVE-2004-1777": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2004-1778": {"epss_score": 0.0006, "epss_percentile": 0.19195}, "CVE-2004-1779": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2004-1780": {"epss_score": 0.00059, "epss_percentile": 0.18834}, "CVE-2004-1781": {"epss_score": 0.00129, "epss_percentile": 0.33169}, "CVE-2004-1782": {"epss_score": 0.11825, "epss_percentile": 0.93487}, "CVE-2004-1783": {"epss_score": 0.03174, "epss_percentile": 0.8656}, "CVE-2004-1784": {"epss_score": 0.10007, "epss_percentile": 0.92813}, "CVE-2004-1785": {"epss_score": 0.01121, "epss_percentile": 0.77769}, "CVE-2004-1786": {"epss_score": 0.05247, "epss_percentile": 0.89662}, "CVE-2004-1787": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2004-1788": {"epss_score": 0.05035, "epss_percentile": 0.89419}, "CVE-2004-1789": {"epss_score": 0.01514, "epss_percentile": 0.80792}, "CVE-2004-1790": {"epss_score": 0.00913, "epss_percentile": 0.75366}, "CVE-2004-1791": {"epss_score": 0.01015, "epss_percentile": 0.76663}, "CVE-2004-1792": {"epss_score": 0.06466, "epss_percentile": 0.90775}, "CVE-2004-1793": {"epss_score": 0.09685, "epss_percentile": 0.92662}, "CVE-2004-1794": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2004-1795": {"epss_score": 0.00065, "epss_percentile": 0.2052}, "CVE-2004-1796": {"epss_score": 0.13241, "epss_percentile": 0.9391}, "CVE-2004-1797": {"epss_score": 0.01244, "epss_percentile": 0.78833}, "CVE-2004-1798": {"epss_score": 0.02149, "epss_percentile": 0.83777}, "CVE-2004-1799": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-2004-1800": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-1801": {"epss_score": 0.06892, "epss_percentile": 0.91096}, "CVE-2004-1802": {"epss_score": 0.00521, "epss_percentile": 0.66245}, "CVE-2004-1804": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-1805": {"epss_score": 0.12823, "epss_percentile": 0.93786}, "CVE-2004-1806": {"epss_score": 0.01278, "epss_percentile": 0.79126}, "CVE-2004-1807": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2004-1808": {"epss_score": 0.00068, "epss_percentile": 0.21314}, "CVE-2004-1809": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2004-1810": {"epss_score": 0.01172, "epss_percentile": 0.78227}, "CVE-2004-1811": {"epss_score": 0.01318, "epss_percentile": 0.79421}, "CVE-2004-1812": {"epss_score": 0.36324, "epss_percentile": 0.96971}, "CVE-2004-1813": {"epss_score": 0.03396, "epss_percentile": 0.87059}, "CVE-2004-1814": {"epss_score": 0.00271, "epss_percentile": 0.5028}, "CVE-2004-1815": {"epss_score": 0.08586, "epss_percentile": 0.92136}, "CVE-2004-1816": {"epss_score": 0.0173, "epss_percentile": 0.81987}, "CVE-2004-1817": {"epss_score": 0.05678, "epss_percentile": 0.90114}, "CVE-2004-1818": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2004-1819": {"epss_score": 0.00619, "epss_percentile": 0.69393}, "CVE-2004-1820": {"epss_score": 0.03706, "epss_percentile": 0.87598}, "CVE-2004-1821": {"epss_score": 0.00446, "epss_percentile": 0.62924}, "CVE-2004-1822": {"epss_score": 0.01433, "epss_percentile": 0.80254}, "CVE-2004-1823": {"epss_score": 0.00918, "epss_percentile": 0.75449}, "CVE-2004-1824": {"epss_score": 0.01248, "epss_percentile": 0.78867}, "CVE-2004-1825": {"epss_score": 0.01551, "epss_percentile": 0.80989}, "CVE-2004-1826": {"epss_score": 0.00678, "epss_percentile": 0.70986}, "CVE-2004-1827": {"epss_score": 0.00873, "epss_percentile": 0.74741}, "CVE-2004-1828": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2004-1829": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2004-1830": {"epss_score": 0.00051, "epss_percentile": 0.16206}, "CVE-2004-1831": {"epss_score": 0.01011, "epss_percentile": 0.76617}, "CVE-2004-1832": {"epss_score": 0.00832, "epss_percentile": 0.74066}, "CVE-2004-1833": {"epss_score": 0.00429, "epss_percentile": 0.61986}, "CVE-2004-1834": {"epss_score": 0.00212, "epss_percentile": 0.43792}, "CVE-2004-1835": {"epss_score": 0.00561, "epss_percentile": 0.67669}, "CVE-2004-1836": {"epss_score": 0.00475, "epss_percentile": 0.64241}, "CVE-2004-1837": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2004-1838": {"epss_score": 0.12872, "epss_percentile": 0.93807}, "CVE-2004-1839": {"epss_score": 0.00016, "epss_percentile": 0.02835}, "CVE-2004-1840": {"epss_score": 0.00023, "epss_percentile": 0.05463}, "CVE-2004-1841": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2004-1842": {"epss_score": 0.0059, "epss_percentile": 0.68556}, "CVE-2004-1843": {"epss_score": 0.00739, "epss_percentile": 0.72396}, "CVE-2004-1844": {"epss_score": 0.0116, "epss_percentile": 0.78137}, "CVE-2004-1845": {"epss_score": 0.01121, "epss_percentile": 0.77769}, "CVE-2004-1846": {"epss_score": 0.01533, "epss_percentile": 0.80897}, "CVE-2004-1847": {"epss_score": 0.02889, "epss_percentile": 0.85916}, "CVE-2004-1848": {"epss_score": 0.03363, "epss_percentile": 0.86994}, "CVE-2004-1849": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2004-1850": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2004-1851": {"epss_score": 0.00766, "epss_percentile": 0.72943}, "CVE-2004-1852": {"epss_score": 0.00259, "epss_percentile": 0.4909}, "CVE-2004-1853": {"epss_score": 0.02097, "epss_percentile": 0.8359}, "CVE-2004-1854": {"epss_score": 0.28382, "epss_percentile": 0.96348}, "CVE-2004-1855": {"epss_score": 0.03789, "epss_percentile": 0.87729}, "CVE-2004-1856": {"epss_score": 0.21669, "epss_percentile": 0.95546}, "CVE-2004-1857": {"epss_score": 0.801, "epss_percentile": 0.99071}, "CVE-2004-1858": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2004-1859": {"epss_score": 0.15291, "epss_percentile": 0.94402}, "CVE-2004-1860": {"epss_score": 0.02283, "epss_percentile": 0.84258}, "CVE-2004-1861": {"epss_score": 0.00082, "epss_percentile": 0.24457}, "CVE-2004-1862": {"epss_score": 0.01558, "epss_percentile": 0.81024}, "CVE-2004-1863": {"epss_score": 0.00624, "epss_percentile": 0.69574}, "CVE-2004-1864": {"epss_score": 0.01237, "epss_percentile": 0.78777}, "CVE-2004-1865": {"epss_score": 0.00419, "epss_percentile": 0.61366}, "CVE-2004-1866": {"epss_score": 0.09008, "epss_percentile": 0.92362}, "CVE-2004-1867": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2004-1868": {"epss_score": 0.233, "epss_percentile": 0.95762}, "CVE-2004-1869": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2004-1870": {"epss_score": 0.007, "epss_percentile": 0.71482}, "CVE-2004-1871": {"epss_score": 0.12116, "epss_percentile": 0.9357}, "CVE-2004-1872": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2004-1873": {"epss_score": 0.02817, "epss_percentile": 0.85736}, "CVE-2004-1874": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2004-1875": {"epss_score": 0.15324, "epss_percentile": 0.9441}, "CVE-2004-1876": {"epss_score": 0.00125, "epss_percentile": 0.32544}, "CVE-2004-1877": {"epss_score": 0.00817, "epss_percentile": 0.73849}, "CVE-2004-1878": {"epss_score": 0.05506, "epss_percentile": 0.89944}, "CVE-2004-1879": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2004-1880": {"epss_score": 0.01079, "epss_percentile": 0.77354}, "CVE-2004-1881": {"epss_score": 0.01496, "epss_percentile": 0.80683}, "CVE-2004-1882": {"epss_score": 0.09311, "epss_percentile": 0.92496}, "CVE-2004-1883": {"epss_score": 0.0254, "epss_percentile": 0.85046}, "CVE-2004-1884": {"epss_score": 0.00301, "epss_percentile": 0.53015}, "CVE-2004-1885": {"epss_score": 0.05248, "epss_percentile": 0.89662}, "CVE-2004-1887": {"epss_score": 0.10394, "epss_percentile": 0.92973}, "CVE-2004-1888": {"epss_score": 0.09254, "epss_percentile": 0.92467}, "CVE-2004-1889": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-1890": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-1891": {"epss_score": 0.00333, "epss_percentile": 0.55642}, "CVE-2004-1892": {"epss_score": 0.15378, "epss_percentile": 0.9442}, "CVE-2004-1893": {"epss_score": 0.00824, "epss_percentile": 0.73933}, "CVE-2004-1894": {"epss_score": 0.00079, "epss_percentile": 0.23853}, "CVE-2004-1895": {"epss_score": 0.00079, "epss_percentile": 0.23905}, "CVE-2004-1896": {"epss_score": 0.24909, "epss_percentile": 0.95964}, "CVE-2004-1897": {"epss_score": 0.09638, "epss_percentile": 0.92635}, "CVE-2004-1898": {"epss_score": 0.34457, "epss_percentile": 0.96848}, "CVE-2004-1899": {"epss_score": 0.00745, "epss_percentile": 0.72517}, "CVE-2004-1900": {"epss_score": 0.04188, "epss_percentile": 0.88369}, "CVE-2004-1901": {"epss_score": 0.00054, "epss_percentile": 0.17347}, "CVE-2004-1902": {"epss_score": 0.0009, "epss_percentile": 0.26031}, "CVE-2004-1903": {"epss_score": 0.05972, "epss_percentile": 0.90373}, "CVE-2004-1904": {"epss_score": 0.07073, "epss_percentile": 0.91231}, "CVE-2004-1905": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2004-1906": {"epss_score": 0.09449, "epss_percentile": 0.92553}, "CVE-2004-1907": {"epss_score": 0.08535, "epss_percentile": 0.92108}, "CVE-2004-1908": {"epss_score": 0.08486, "epss_percentile": 0.92078}, "CVE-2004-1909": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-1910": {"epss_score": 0.0521, "epss_percentile": 0.89614}, "CVE-2004-1911": {"epss_score": 0.00841, "epss_percentile": 0.74228}, "CVE-2004-1912": {"epss_score": 0.00038, "epss_percentile": 0.11279}, "CVE-2004-1913": {"epss_score": 0.00024, "epss_percentile": 0.05859}, "CVE-2004-1914": {"epss_score": 0.00019, "epss_percentile": 0.04203}, "CVE-2004-1915": {"epss_score": 0.27818, "epss_percentile": 0.96285}, "CVE-2004-1916": {"epss_score": 0.08033, "epss_percentile": 0.91844}, "CVE-2004-1917": {"epss_score": 0.04939, "epss_percentile": 0.89305}, "CVE-2004-1918": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-1919": {"epss_score": 0.06281, "epss_percentile": 0.90638}, "CVE-2004-1920": {"epss_score": 0.00901, "epss_percentile": 0.75169}, "CVE-2004-1921": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2004-1922": {"epss_score": 0.05101, "epss_percentile": 0.89497}, "CVE-2004-1923": {"epss_score": 0.06739, "epss_percentile": 0.90994}, "CVE-2004-1924": {"epss_score": 0.00544, "epss_percentile": 0.67128}, "CVE-2004-1925": {"epss_score": 0.00436, "epss_percentile": 0.62481}, "CVE-2004-1926": {"epss_score": 0.03828, "epss_percentile": 0.87795}, "CVE-2004-1927": {"epss_score": 0.05023, "epss_percentile": 0.89404}, "CVE-2004-1928": {"epss_score": 0.07475, "epss_percentile": 0.91493}, "CVE-2004-1929": {"epss_score": 0.00131, "epss_percentile": 0.3341}, "CVE-2004-1930": {"epss_score": 0.00171, "epss_percentile": 0.38873}, "CVE-2004-1932": {"epss_score": 0.00021, "epss_percentile": 0.04848}, "CVE-2004-1933": {"epss_score": 0.0007, "epss_percentile": 0.21866}, "CVE-2004-1934": {"epss_score": 0.07569, "epss_percentile": 0.91545}, "CVE-2004-1935": {"epss_score": 0.00646, "epss_percentile": 0.7015}, "CVE-2004-1936": {"epss_score": 0.00363, "epss_percentile": 0.57827}, "CVE-2004-1937": {"epss_score": 0.10434, "epss_percentile": 0.92986}, "CVE-2004-1938": {"epss_score": 0.01263, "epss_percentile": 0.7899}, "CVE-2004-1939": {"epss_score": 0.0123, "epss_percentile": 0.78721}, "CVE-2004-1940": {"epss_score": 0.12948, "epss_percentile": 0.93825}, "CVE-2004-1941": {"epss_score": 0.01431, "epss_percentile": 0.80242}, "CVE-2004-1942": {"epss_score": 0.00475, "epss_percentile": 0.64171}, "CVE-2004-1943": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2004-1944": {"epss_score": 0.03918, "epss_percentile": 0.87949}, "CVE-2004-1945": {"epss_score": 0.13118, "epss_percentile": 0.93879}, "CVE-2004-1946": {"epss_score": 0.00084, "epss_percentile": 0.24882}, "CVE-2004-1947": {"epss_score": 0.12492, "epss_percentile": 0.93691}, "CVE-2004-1948": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2004-1949": {"epss_score": 0.01887, "epss_percentile": 0.82718}, "CVE-2004-1950": {"epss_score": 0.00619, "epss_percentile": 0.69393}, "CVE-2004-1951": {"epss_score": 0.02547, "epss_percentile": 0.85065}, "CVE-2004-1952": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2004-1953": {"epss_score": 0.05018, "epss_percentile": 0.89399}, "CVE-2004-1954": {"epss_score": 0.01649, "epss_percentile": 0.81556}, "CVE-2004-1955": {"epss_score": 0.00553, "epss_percentile": 0.6742}, "CVE-2004-1956": {"epss_score": 0.00457, "epss_percentile": 0.63389}, "CVE-2004-1957": {"epss_score": 0.00477, "epss_percentile": 0.64322}, "CVE-2004-1958": {"epss_score": 0.03383, "epss_percentile": 0.87034}, "CVE-2004-1959": {"epss_score": 0.00619, "epss_percentile": 0.69393}, "CVE-2004-1960": {"epss_score": 0.03175, "epss_percentile": 0.86566}, "CVE-2004-1961": {"epss_score": 0.0029, "epss_percentile": 0.52124}, "CVE-2004-1962": {"epss_score": 0.00448, "epss_percentile": 0.62994}, "CVE-2004-1963": {"epss_score": 0.00517, "epss_percentile": 0.66091}, "CVE-2004-1964": {"epss_score": 0.00463, "epss_percentile": 0.63682}, "CVE-2004-1965": {"epss_score": 0.00265, "epss_percentile": 0.49795}, "CVE-2004-1966": {"epss_score": 0.00735, "epss_percentile": 0.72295}, "CVE-2004-1967": {"epss_score": 0.01267, "epss_percentile": 0.79015}, "CVE-2004-1968": {"epss_score": 0.03876, "epss_percentile": 0.87888}, "CVE-2004-1969": {"epss_score": 0.01075, "epss_percentile": 0.77311}, "CVE-2004-1970": {"epss_score": 0.00638, "epss_percentile": 0.6992}, "CVE-2004-1971": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2004-1972": {"epss_score": 0.00021, "epss_percentile": 0.04848}, "CVE-2004-1973": {"epss_score": 0.10459, "epss_percentile": 0.92992}, "CVE-2004-1974": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2004-1975": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2004-1976": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-1977": {"epss_score": 0.01231, "epss_percentile": 0.78733}, "CVE-2004-1978": {"epss_score": 0.03642, "epss_percentile": 0.87493}, "CVE-2004-1979": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2004-1980": {"epss_score": 0.00442, "epss_percentile": 0.62747}, "CVE-2004-1981": {"epss_score": 0.00651, "epss_percentile": 0.70301}, "CVE-2004-1982": {"epss_score": 0.0064, "epss_percentile": 0.69959}, "CVE-2004-1983": {"epss_score": 0.00211, "epss_percentile": 0.43628}, "CVE-2004-1984": {"epss_score": 0.0055, "epss_percentile": 0.67326}, "CVE-2004-1985": {"epss_score": 0.00164, "epss_percentile": 0.3788}, "CVE-2004-1986": {"epss_score": 0.00111, "epss_percentile": 0.30352}, "CVE-2004-1987": {"epss_score": 0.00283, "epss_percentile": 0.51414}, "CVE-2004-1988": {"epss_score": 0.00081, "epss_percentile": 0.24292}, "CVE-2004-1989": {"epss_score": 0.00081, "epss_percentile": 0.24292}, "CVE-2004-1990": {"epss_score": 0.00916, "epss_percentile": 0.75413}, "CVE-2004-1991": {"epss_score": 0.03154, "epss_percentile": 0.86512}, "CVE-2004-1992": {"epss_score": 0.11375, "epss_percentile": 0.93326}, "CVE-2004-1993": {"epss_score": 0.0194, "epss_percentile": 0.82981}, "CVE-2004-1994": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-1995": {"epss_score": 0.05112, "epss_percentile": 0.89511}, "CVE-2004-1996": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2004-1997": {"epss_score": 0.00126, "epss_percentile": 0.32661}, "CVE-2004-1998": {"epss_score": 0.00022, "epss_percentile": 0.04977}, "CVE-2004-1999": {"epss_score": 0.00885, "epss_percentile": 0.7494}, "CVE-2004-2000": {"epss_score": 0.02819, "epss_percentile": 0.85741}, "CVE-2004-2001": {"epss_score": 0.0006, "epss_percentile": 0.19008}, "CVE-2004-2002": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-2003": {"epss_score": 0.10045, "epss_percentile": 0.92826}, "CVE-2004-2004": {"epss_score": 0.00933, "epss_percentile": 0.75638}, "CVE-2004-2005": {"epss_score": 0.20823, "epss_percentile": 0.95419}, "CVE-2004-2006": {"epss_score": 0.00052, "epss_percentile": 0.16389}, "CVE-2004-2007": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2004-2008": {"epss_score": 0.00267, "epss_percentile": 0.5}, "CVE-2004-2009": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2004-2010": {"epss_score": 0.00968, "epss_percentile": 0.76078}, "CVE-2004-2011": {"epss_score": 0.09545, "epss_percentile": 0.92593}, "CVE-2004-2012": {"epss_score": 0.00306, "epss_percentile": 0.53461}, "CVE-2004-2013": {"epss_score": 0.00086, "epss_percentile": 0.25428}, "CVE-2004-2014": {"epss_score": 0.00118, "epss_percentile": 0.3152}, "CVE-2004-2015": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2004-2016": {"epss_score": 0.0331, "epss_percentile": 0.86887}, "CVE-2004-2017": {"epss_score": 0.08971, "epss_percentile": 0.92345}, "CVE-2004-2018": {"epss_score": 0.00084, "epss_percentile": 0.24965}, "CVE-2004-2019": {"epss_score": 0.00027, "epss_percentile": 0.06958}, "CVE-2004-2020": {"epss_score": 0.00039, "epss_percentile": 0.11711}, "CVE-2004-2021": {"epss_score": 0.06899, "epss_percentile": 0.91102}, "CVE-2004-2022": {"epss_score": 0.01757, "epss_percentile": 0.82132}, "CVE-2004-2023": {"epss_score": 0.01314, "epss_percentile": 0.79395}, "CVE-2004-2024": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-2004-2025": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2004-2026": {"epss_score": 0.24425, "epss_percentile": 0.9592}, "CVE-2004-2027": {"epss_score": 0.01632, "epss_percentile": 0.81458}, "CVE-2004-2028": {"epss_score": 0.00655, "epss_percentile": 0.7042}, "CVE-2004-2029": {"epss_score": 0.13564, "epss_percentile": 0.93997}, "CVE-2004-2030": {"epss_score": 0.01493, "epss_percentile": 0.8064}, "CVE-2004-2031": {"epss_score": 0.00565, "epss_percentile": 0.67806}, "CVE-2004-2032": {"epss_score": 0.01588, "epss_percentile": 0.81191}, "CVE-2004-2033": {"epss_score": 0.1797, "epss_percentile": 0.94935}, "CVE-2004-2034": {"epss_score": 0.09658, "epss_percentile": 0.92643}, "CVE-2004-2035": {"epss_score": 0.09189, "epss_percentile": 0.92439}, "CVE-2004-2036": {"epss_score": 0.01162, "epss_percentile": 0.78153}, "CVE-2004-2037": {"epss_score": 0.22703, "epss_percentile": 0.95671}, "CVE-2004-2038": {"epss_score": 0.11044, "epss_percentile": 0.93199}, "CVE-2004-2039": {"epss_score": 0.00985, "epss_percentile": 0.76319}, "CVE-2004-2040": {"epss_score": 0.02013, "epss_percentile": 0.83258}, "CVE-2004-2041": {"epss_score": 0.0214, "epss_percentile": 0.83746}, "CVE-2004-2042": {"epss_score": 0.03255, "epss_percentile": 0.86759}, "CVE-2004-2043": {"epss_score": 0.47461, "epss_percentile": 0.97588}, "CVE-2004-2044": {"epss_score": 0.01076, "epss_percentile": 0.77321}, "CVE-2004-2045": {"epss_score": 0.05014, "epss_percentile": 0.89393}, "CVE-2004-2046": {"epss_score": 0.0192, "epss_percentile": 0.82894}, "CVE-2004-2047": {"epss_score": 0.0754, "epss_percentile": 0.91526}, "CVE-2004-2048": {"epss_score": 0.032, "epss_percentile": 0.86622}, "CVE-2004-2049": {"epss_score": 0.00087, "epss_percentile": 0.25451}, "CVE-2004-2050": {"epss_score": 0.00121, "epss_percentile": 0.31889}, "CVE-2004-2051": {"epss_score": 0.00513, "epss_percentile": 0.65903}, "CVE-2004-2052": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2004-2053": {"epss_score": 0.02474, "epss_percentile": 0.84855}, "CVE-2004-2054": {"epss_score": 0.00563, "epss_percentile": 0.67742}, "CVE-2004-2055": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2004-2056": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2004-2057": {"epss_score": 0.01233, "epss_percentile": 0.78751}, "CVE-2004-2058": {"epss_score": 0.00806, "epss_percentile": 0.73662}, "CVE-2004-2059": {"epss_score": 0.10156, "epss_percentile": 0.92867}, "CVE-2004-2060": {"epss_score": 0.09187, "epss_percentile": 0.92437}, "CVE-2004-2061": {"epss_score": 0.15542, "epss_percentile": 0.94454}, "CVE-2004-2062": {"epss_score": 0.00416, "epss_percentile": 0.61167}, "CVE-2004-2063": {"epss_score": 0.00807, "epss_percentile": 0.7367}, "CVE-2004-2064": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2004-2065": {"epss_score": 0.00552, "epss_percentile": 0.67386}, "CVE-2004-2066": {"epss_score": 0.00967, "epss_percentile": 0.76074}, "CVE-2004-2067": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2004-2068": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-2069": {"epss_score": 0.0485, "epss_percentile": 0.89214}, "CVE-2004-2070": {"epss_score": 0.00064, "epss_percentile": 0.20136}, "CVE-2004-2071": {"epss_score": 0.04938, "epss_percentile": 0.89305}, "CVE-2004-2072": {"epss_score": 0.00524, "epss_percentile": 0.6632}, "CVE-2004-2073": {"epss_score": 0.00166, "epss_percentile": 0.38163}, "CVE-2004-2074": {"epss_score": 0.55562, "epss_percentile": 0.97984}, "CVE-2004-2075": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-2076": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2004-2077": {"epss_score": 0.11666, "epss_percentile": 0.93439}, "CVE-2004-2078": {"epss_score": 0.18247, "epss_percentile": 0.9498}, "CVE-2004-2079": {"epss_score": 0.01219, "epss_percentile": 0.78612}, "CVE-2004-2080": {"epss_score": 0.00786, "epss_percentile": 0.7327}, "CVE-2004-2081": {"epss_score": 0.02788, "epss_percentile": 0.85661}, "CVE-2004-2082": {"epss_score": 0.05875, "epss_percentile": 0.90285}, "CVE-2004-2083": {"epss_score": 0.01142, "epss_percentile": 0.77977}, "CVE-2004-2084": {"epss_score": 0.00871, "epss_percentile": 0.74714}, "CVE-2004-2085": {"epss_score": 0.03086, "epss_percentile": 0.86386}, "CVE-2004-2086": {"epss_score": 0.68835, "epss_percentile": 0.98565}, "CVE-2004-2087": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2004-2088": {"epss_score": 0.05692, "epss_percentile": 0.90125}, "CVE-2004-2089": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2004-2090": {"epss_score": 0.39409, "epss_percentile": 0.97159}, "CVE-2004-2091": {"epss_score": 0.14432, "epss_percentile": 0.94211}, "CVE-2004-2092": {"epss_score": 0.00061, "epss_percentile": 0.19259}, "CVE-2004-2093": {"epss_score": 0.0029, "epss_percentile": 0.52117}, "CVE-2004-2094": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2004-2095": {"epss_score": 0.00631, "epss_percentile": 0.69715}, "CVE-2004-2096": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2004-2097": {"epss_score": 0.00086, "epss_percentile": 0.25427}, "CVE-2004-2098": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2004-2099": {"epss_score": 0.0528, "epss_percentile": 0.89687}, "CVE-2004-2100": {"epss_score": 0.00373, "epss_percentile": 0.58465}, "CVE-2004-2101": {"epss_score": 0.00967, "epss_percentile": 0.76065}, "CVE-2004-2102": {"epss_score": 0.00558, "epss_percentile": 0.676}, "CVE-2004-2103": {"epss_score": 0.00179, "epss_percentile": 0.39822}, "CVE-2004-2104": {"epss_score": 0.06964, "epss_percentile": 0.9115}, "CVE-2004-2105": {"epss_score": 0.00127, "epss_percentile": 0.32795}, "CVE-2004-2106": {"epss_score": 0.00238, "epss_percentile": 0.46835}, "CVE-2004-2107": {"epss_score": 0.10434, "epss_percentile": 0.92986}, "CVE-2004-2108": {"epss_score": 0.03662, "epss_percentile": 0.87528}, "CVE-2004-2109": {"epss_score": 0.02089, "epss_percentile": 0.8356}, "CVE-2004-2110": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2004-2111": {"epss_score": 0.8545, "epss_percentile": 0.99333}, "CVE-2004-2112": {"epss_score": 0.04756, "epss_percentile": 0.89113}, "CVE-2004-2113": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2004-2114": {"epss_score": 0.05021, "epss_percentile": 0.89402}, "CVE-2004-2115": {"epss_score": 0.50278, "epss_percentile": 0.9773}, "CVE-2004-2116": {"epss_score": 0.1416, "epss_percentile": 0.94146}, "CVE-2004-2117": {"epss_score": 0.07667, "epss_percentile": 0.91612}, "CVE-2004-2118": {"epss_score": 0.01191, "epss_percentile": 0.78396}, "CVE-2004-2119": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2004-2120": {"epss_score": 0.0445, "epss_percentile": 0.88703}, "CVE-2004-2121": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2004-2122": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2004-2123": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2004-2124": {"epss_score": 0.06362, "epss_percentile": 0.907}, "CVE-2004-2125": {"epss_score": 0.00122, "epss_percentile": 0.32147}, "CVE-2004-2126": {"epss_score": 0.00222, "epss_percentile": 0.44784}, "CVE-2004-2127": {"epss_score": 0.10463, "epss_percentile": 0.92994}, "CVE-2004-2128": {"epss_score": 0.007, "epss_percentile": 0.7148}, "CVE-2004-2129": {"epss_score": 0.04656, "epss_percentile": 0.88973}, "CVE-2004-2130": {"epss_score": 0.07292, "epss_percentile": 0.91387}, "CVE-2004-2131": {"epss_score": 0.00199, "epss_percentile": 0.42146}, "CVE-2004-2132": {"epss_score": 0.06194, "epss_percentile": 0.90556}, "CVE-2004-2133": {"epss_score": 0.00078, "epss_percentile": 0.23568}, "CVE-2004-2134": {"epss_score": 0.03818, "epss_percentile": 0.87771}, "CVE-2004-2135": {"epss_score": 0.00456, "epss_percentile": 0.63352}, "CVE-2004-2136": {"epss_score": 0.0007, "epss_percentile": 0.21749}, "CVE-2004-2137": {"epss_score": 0.33173, "epss_percentile": 0.96751}, "CVE-2004-2138": {"epss_score": 0.01209, "epss_percentile": 0.78542}, "CVE-2004-2139": {"epss_score": 0.00954, "epss_percentile": 0.75902}, "CVE-2004-2140": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2004-2142": {"epss_score": 0.00437, "epss_percentile": 0.62508}, "CVE-2004-2143": {"epss_score": 0.0224, "epss_percentile": 0.84114}, "CVE-2004-2144": {"epss_score": 0.00636, "epss_percentile": 0.69867}, "CVE-2004-2145": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2004-2146": {"epss_score": 0.00388, "epss_percentile": 0.59371}, "CVE-2004-2147": {"epss_score": 0.00599, "epss_percentile": 0.68794}, "CVE-2004-2148": {"epss_score": 0.00055, "epss_percentile": 0.17556}, "CVE-2004-2149": {"epss_score": 0.02198, "epss_percentile": 0.83967}, "CVE-2004-2150": {"epss_score": 0.0124, "epss_percentile": 0.788}, "CVE-2004-2151": {"epss_score": 0.0562, "epss_percentile": 0.90059}, "CVE-2004-2152": {"epss_score": 0.00463, "epss_percentile": 0.63682}, "CVE-2004-2153": {"epss_score": 0.00475, "epss_percentile": 0.64175}, "CVE-2004-2154": {"epss_score": 0.00487, "epss_percentile": 0.64809}, "CVE-2004-2155": {"epss_score": 0.00644, "epss_percentile": 0.70079}, "CVE-2004-2156": {"epss_score": 0.0064, "epss_percentile": 0.69962}, "CVE-2004-2157": {"epss_score": 0.00721, "epss_percentile": 0.71978}, "CVE-2004-2158": {"epss_score": 0.02658, "epss_percentile": 0.85362}, "CVE-2004-2159": {"epss_score": 0.00433, "epss_percentile": 0.62178}, "CVE-2004-2160": {"epss_score": 0.00759, "epss_percentile": 0.72791}, "CVE-2004-2161": {"epss_score": 0.03134, "epss_percentile": 0.86477}, "CVE-2004-2162": {"epss_score": 0.10377, "epss_percentile": 0.92965}, "CVE-2004-2163": {"epss_score": 0.01153, "epss_percentile": 0.78055}, "CVE-2004-2164": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-2165": {"epss_score": 0.01524, "epss_percentile": 0.80853}, "CVE-2004-2166": {"epss_score": 0.01068, "epss_percentile": 0.77242}, "CVE-2004-2167": {"epss_score": 0.09424, "epss_percentile": 0.92541}, "CVE-2004-2168": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2004-2169": {"epss_score": 0.00229, "epss_percentile": 0.4562}, "CVE-2004-2170": {"epss_score": 0.07102, "epss_percentile": 0.91253}, "CVE-2004-2171": {"epss_score": 0.04678, "epss_percentile": 0.88998}, "CVE-2004-2172": {"epss_score": 0.05574, "epss_percentile": 0.90011}, "CVE-2004-2173": {"epss_score": 0.02041, "epss_percentile": 0.83372}, "CVE-2004-2174": {"epss_score": 0.01105, "epss_percentile": 0.77607}, "CVE-2004-2175": {"epss_score": 0.00632, "epss_percentile": 0.69739}, "CVE-2004-2176": {"epss_score": 0.006, "epss_percentile": 0.68832}, "CVE-2004-2177": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2004-2178": {"epss_score": 0.00575, "epss_percentile": 0.68101}, "CVE-2004-2179": {"epss_score": 0.11785, "epss_percentile": 0.93473}, "CVE-2004-2180": {"epss_score": 0.00427, "epss_percentile": 0.61915}, "CVE-2004-2181": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2004-2182": {"epss_score": 0.0179, "epss_percentile": 0.8228}, "CVE-2004-2183": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2004-2184": {"epss_score": 0.07882, "epss_percentile": 0.91741}, "CVE-2004-2185": {"epss_score": 0.02002, "epss_percentile": 0.83223}, "CVE-2004-2186": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2004-2187": {"epss_score": 0.00333, "epss_percentile": 0.55642}, "CVE-2004-2188": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2004-2189": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2004-2190": {"epss_score": 0.0041, "epss_percentile": 0.60836}, "CVE-2004-2191": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2004-2192": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2004-2193": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2004-2194": {"epss_score": 0.0197, "epss_percentile": 0.83094}, "CVE-2004-2195": {"epss_score": 0.00827, "epss_percentile": 0.73981}, "CVE-2004-2196": {"epss_score": 0.01281, "epss_percentile": 0.79145}, "CVE-2004-2197": {"epss_score": 0.00047, "epss_percentile": 0.14792}, "CVE-2004-2198": {"epss_score": 0.03832, "epss_percentile": 0.87811}, "CVE-2004-2199": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2004-2200": {"epss_score": 0.00498, "epss_percentile": 0.65234}, "CVE-2004-2201": {"epss_score": 0.00845, "epss_percentile": 0.74316}, "CVE-2004-2202": {"epss_score": 0.00471, "epss_percentile": 0.64019}, "CVE-2004-2203": {"epss_score": 0.00662, "epss_percentile": 0.70592}, "CVE-2004-2204": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2004-2205": {"epss_score": 0.00047, "epss_percentile": 0.14792}, "CVE-2004-2206": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2004-2207": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2004-2208": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2004-2209": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2004-2210": {"epss_score": 0.00485, "epss_percentile": 0.64726}, "CVE-2004-2211": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2004-2212": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2004-2213": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2004-2214": {"epss_score": 0.00624, "epss_percentile": 0.69567}, "CVE-2004-2215": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2004-2216": {"epss_score": 0.00796, "epss_percentile": 0.73484}, "CVE-2004-2217": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-2218": {"epss_score": 0.00817, "epss_percentile": 0.73847}, "CVE-2004-2219": {"epss_score": 0.15086, "epss_percentile": 0.94359}, "CVE-2004-2220": {"epss_score": 0.00691, "epss_percentile": 0.71268}, "CVE-2004-2221": {"epss_score": 0.77421, "epss_percentile": 0.98936}, "CVE-2004-2222": {"epss_score": 0.01284, "epss_percentile": 0.79173}, "CVE-2004-2223": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-2224": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2004-2225": {"epss_score": 0.00783, "epss_percentile": 0.73219}, "CVE-2004-2226": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2004-2227": {"epss_score": 0.00887, "epss_percentile": 0.74972}, "CVE-2004-2228": {"epss_score": 0.00048, "epss_percentile": 0.15257}, "CVE-2004-2229": {"epss_score": 0.00958, "epss_percentile": 0.7594}, "CVE-2004-2230": {"epss_score": 0.00111, "epss_percentile": 0.3037}, "CVE-2004-2231": {"epss_score": 0.00098, "epss_percentile": 0.27781}, "CVE-2004-2232": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2004-2233": {"epss_score": 0.00616, "epss_percentile": 0.69322}, "CVE-2004-2234": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2004-2235": {"epss_score": 0.00376, "epss_percentile": 0.58674}, "CVE-2004-2236": {"epss_score": 0.00376, "epss_percentile": 0.58674}, "CVE-2004-2237": {"epss_score": 0.00437, "epss_percentile": 0.62508}, "CVE-2004-2238": {"epss_score": 0.00603, "epss_percentile": 0.68934}, "CVE-2004-2239": {"epss_score": 0.00865, "epss_percentile": 0.74624}, "CVE-2004-2240": {"epss_score": 0.01233, "epss_percentile": 0.78751}, "CVE-2004-2241": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2004-2242": {"epss_score": 0.00655, "epss_percentile": 0.70428}, "CVE-2004-2243": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2004-2244": {"epss_score": 0.00847, "epss_percentile": 0.74348}, "CVE-2004-2245": {"epss_score": 0.01137, "epss_percentile": 0.77926}, "CVE-2004-2246": {"epss_score": 0.00533, "epss_percentile": 0.66759}, "CVE-2004-2247": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2004-2248": {"epss_score": 0.00384, "epss_percentile": 0.59171}, "CVE-2004-2249": {"epss_score": 0.00459, "epss_percentile": 0.63468}, "CVE-2004-2250": {"epss_score": 0.00459, "epss_percentile": 0.63468}, "CVE-2004-2251": {"epss_score": 0.0052, "epss_percentile": 0.66187}, "CVE-2004-2252": {"epss_score": 0.01992, "epss_percentile": 0.83179}, "CVE-2004-2253": {"epss_score": 0.04308, "epss_percentile": 0.88528}, "CVE-2004-2254": {"epss_score": 0.13174, "epss_percentile": 0.93893}, "CVE-2004-2255": {"epss_score": 0.04746, "epss_percentile": 0.89097}, "CVE-2004-2256": {"epss_score": 0.04746, "epss_percentile": 0.89097}, "CVE-2004-2257": {"epss_score": 0.01328, "epss_percentile": 0.79496}, "CVE-2004-2258": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2004-2259": {"epss_score": 0.01911, "epss_percentile": 0.82828}, "CVE-2004-2260": {"epss_score": 0.00917, "epss_percentile": 0.75426}, "CVE-2004-2261": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2004-2262": {"epss_score": 0.21867, "epss_percentile": 0.95568}, "CVE-2004-2263": {"epss_score": 0.00988, "epss_percentile": 0.7635}, "CVE-2004-2264": {"epss_score": 0.00686, "epss_percentile": 0.71168}, "CVE-2004-2265": {"epss_score": 0.00062, "epss_percentile": 0.19708}, "CVE-2004-2266": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2004-2267": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2004-2268": {"epss_score": 0.00773, "epss_percentile": 0.73056}, "CVE-2004-2269": {"epss_score": 0.00067, "epss_percentile": 0.21114}, "CVE-2004-2270": {"epss_score": 0.00049, "epss_percentile": 0.15632}, "CVE-2004-2271": {"epss_score": 0.81543, "epss_percentile": 0.99144}, "CVE-2004-2272": {"epss_score": 0.00994, "epss_percentile": 0.76421}, "CVE-2004-2273": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2004-2274": {"epss_score": 0.00732, "epss_percentile": 0.7219}, "CVE-2004-2275": {"epss_score": 0.07382, "epss_percentile": 0.91445}, "CVE-2004-2276": {"epss_score": 0.001, "epss_percentile": 0.28497}, "CVE-2004-2277": {"epss_score": 0.06617, "epss_percentile": 0.90891}, "CVE-2004-2278": {"epss_score": 0.0054, "epss_percentile": 0.67001}, "CVE-2004-2279": {"epss_score": 0.00442, "epss_percentile": 0.62741}, "CVE-2004-2280": {"epss_score": 0.03932, "epss_percentile": 0.87975}, "CVE-2004-2281": {"epss_score": 0.00493, "epss_percentile": 0.65026}, "CVE-2004-2282": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2004-2283": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2004-2284": {"epss_score": 0.04167, "epss_percentile": 0.88343}, "CVE-2004-2286": {"epss_score": 0.07519, "epss_percentile": 0.91515}, "CVE-2004-2287": {"epss_score": 0.03054, "epss_percentile": 0.86297}, "CVE-2004-2288": {"epss_score": 0.00353, "epss_percentile": 0.57198}, "CVE-2004-2289": {"epss_score": 0.12111, "epss_percentile": 0.93569}, "CVE-2004-2290": {"epss_score": 0.00973, "epss_percentile": 0.76156}, "CVE-2004-2291": {"epss_score": 0.15804, "epss_percentile": 0.94512}, "CVE-2004-2292": {"epss_score": 0.01542, "epss_percentile": 0.80949}, "CVE-2004-2293": {"epss_score": 0.00059, "epss_percentile": 0.18702}, "CVE-2004-2294": {"epss_score": 0.00056, "epss_percentile": 0.17715}, "CVE-2004-2295": {"epss_score": 0.00553, "epss_percentile": 0.6742}, "CVE-2004-2296": {"epss_score": 0.00035, "epss_percentile": 0.10042}, "CVE-2004-2297": {"epss_score": 0.00352, "epss_percentile": 0.57116}, "CVE-2004-2298": {"epss_score": 0.00378, "epss_percentile": 0.58798}, "CVE-2004-2299": {"epss_score": 0.06689, "epss_percentile": 0.90947}, "CVE-2004-2300": {"epss_score": 0.00249, "epss_percentile": 0.48068}, "CVE-2004-2301": {"epss_score": 0.00806, "epss_percentile": 0.73655}, "CVE-2004-2302": {"epss_score": 0.00065, "epss_percentile": 0.20602}, "CVE-2004-2303": {"epss_score": 0.00287, "epss_percentile": 0.51786}, "CVE-2004-2304": {"epss_score": 0.03243, "epss_percentile": 0.86738}, "CVE-2004-2305": {"epss_score": 0.00323, "epss_percentile": 0.54913}, "CVE-2004-2306": {"epss_score": 0.00077, "epss_percentile": 0.23297}, "CVE-2004-2307": {"epss_score": 0.09949, "epss_percentile": 0.92786}, "CVE-2004-2308": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2004-2309": {"epss_score": 0.00179, "epss_percentile": 0.39853}, "CVE-2004-2310": {"epss_score": 0.0694, "epss_percentile": 0.91131}, "CVE-2004-2311": {"epss_score": 0.00659, "epss_percentile": 0.705}, "CVE-2004-2312": {"epss_score": 0.00317, "epss_percentile": 0.5438}, "CVE-2004-2313": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2004-2314": {"epss_score": 0.00361, "epss_percentile": 0.5773}, "CVE-2004-2315": {"epss_score": 0.00782, "epss_percentile": 0.73197}, "CVE-2004-2316": {"epss_score": 0.00782, "epss_percentile": 0.73197}, "CVE-2004-2317": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2004-2318": {"epss_score": 0.01621, "epss_percentile": 0.81388}, "CVE-2004-2319": {"epss_score": 0.00077, "epss_percentile": 0.233}, "CVE-2004-2320": {"epss_score": 0.0694, "epss_percentile": 0.91131}, "CVE-2004-2321": {"epss_score": 0.00034, "epss_percentile": 0.09568}, "CVE-2004-2322": {"epss_score": 0.01462, "epss_percentile": 0.80435}, "CVE-2004-2323": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2004-2324": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2004-2325": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2004-2326": {"epss_score": 0.01073, "epss_percentile": 0.77289}, "CVE-2004-2327": {"epss_score": 0.00782, "epss_percentile": 0.73197}, "CVE-2004-2328": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2004-2329": {"epss_score": 0.0009, "epss_percentile": 0.26065}, "CVE-2004-2330": {"epss_score": 0.05382, "epss_percentile": 0.89812}, "CVE-2004-2331": {"epss_score": 0.00013, "epss_percentile": 0.01447}, "CVE-2004-2332": {"epss_score": 0.00376, "epss_percentile": 0.58656}, "CVE-2004-2333": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2004-2334": {"epss_score": 0.00951, "epss_percentile": 0.75864}, "CVE-2004-2335": {"epss_score": 0.00013, "epss_percentile": 0.01649}, "CVE-2004-2336": {"epss_score": 0.0052, "epss_percentile": 0.66186}, "CVE-2004-2337": {"epss_score": 0.00059, "epss_percentile": 0.18656}, "CVE-2004-2338": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-2004-2339": {"epss_score": 0.01309, "epss_percentile": 0.79357}, "CVE-2004-2340": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2004-2341": {"epss_score": 0.02752, "epss_percentile": 0.85583}, "CVE-2004-2342": {"epss_score": 0.01621, "epss_percentile": 0.81388}, "CVE-2004-2343": {"epss_score": 0.00165, "epss_percentile": 0.38129}, "CVE-2004-2344": {"epss_score": 0.04779, "epss_percentile": 0.89135}, "CVE-2004-2345": {"epss_score": 0.00766, "epss_percentile": 0.72935}, "CVE-2004-2346": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2004-2347": {"epss_score": 0.08979, "epss_percentile": 0.92349}, "CVE-2004-2348": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2004-2349": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2004-2350": {"epss_score": 0.00536, "epss_percentile": 0.66852}, "CVE-2004-2351": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2004-2352": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2004-2353": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2004-2354": {"epss_score": 0.00039, "epss_percentile": 0.11471}, "CVE-2004-2355": {"epss_score": 0.01044, "epss_percentile": 0.77007}, "CVE-2004-2356": {"epss_score": 0.01171, "epss_percentile": 0.78218}, "CVE-2004-2357": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2004-2358": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2004-2359": {"epss_score": 0.01227, "epss_percentile": 0.78698}, "CVE-2004-2360": {"epss_score": 0.05887, "epss_percentile": 0.90296}, "CVE-2004-2361": {"epss_score": 0.00477, "epss_percentile": 0.64334}, "CVE-2004-2362": {"epss_score": 0.00902, "epss_percentile": 0.75193}, "CVE-2004-2363": {"epss_score": 0.00646, "epss_percentile": 0.7015}, "CVE-2004-2364": {"epss_score": 0.07492, "epss_percentile": 0.915}, "CVE-2004-2365": {"epss_score": 0.00237, "epss_percentile": 0.46664}, "CVE-2004-2366": {"epss_score": 0.0091, "epss_percentile": 0.75316}, "CVE-2004-2367": {"epss_score": 0.05162, "epss_percentile": 0.89561}, "CVE-2004-2368": {"epss_score": 0.01507, "epss_percentile": 0.80753}, "CVE-2004-2369": {"epss_score": 0.00258, "epss_percentile": 0.48982}, "CVE-2004-2370": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2004-2371": {"epss_score": 0.01688, "epss_percentile": 0.81761}, "CVE-2004-2372": {"epss_score": 0.00123, "epss_percentile": 0.32181}, "CVE-2004-2373": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2004-2374": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2004-2375": {"epss_score": 0.1033, "epss_percentile": 0.92948}, "CVE-2004-2376": {"epss_score": 0.02412, "epss_percentile": 0.84668}, "CVE-2004-2377": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-2378": {"epss_score": 0.01621, "epss_percentile": 0.81388}, "CVE-2004-2379": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2004-2380": {"epss_score": 0.00256, "epss_percentile": 0.4874}, "CVE-2004-2381": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-2382": {"epss_score": 0.00948, "epss_percentile": 0.75829}, "CVE-2004-2383": {"epss_score": 0.15255, "epss_percentile": 0.94392}, "CVE-2004-2384": {"epss_score": 0.01112, "epss_percentile": 0.77677}, "CVE-2004-2385": {"epss_score": 0.04819, "epss_percentile": 0.89176}, "CVE-2004-2386": {"epss_score": 0.03829, "epss_percentile": 0.87801}, "CVE-2004-2387": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2004-2388": {"epss_score": 0.01008, "epss_percentile": 0.76569}, "CVE-2004-2389": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-2390": {"epss_score": 0.00451, "epss_percentile": 0.63129}, "CVE-2004-2391": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2004-2392": {"epss_score": 0.00956, "epss_percentile": 0.75923}, "CVE-2004-2393": {"epss_score": 0.00901, "epss_percentile": 0.75174}, "CVE-2004-2394": {"epss_score": 0.00078, "epss_percentile": 0.23605}, "CVE-2004-2395": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2004-2396": {"epss_score": 0.00053, "epss_percentile": 0.16794}, "CVE-2004-2397": {"epss_score": 0.00341, "epss_percentile": 0.563}, "CVE-2004-2398": {"epss_score": 0.00052, "epss_percentile": 0.16572}, "CVE-2004-2399": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2004-2400": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2004-2401": {"epss_score": 0.01501, "epss_percentile": 0.80714}, "CVE-2004-2402": {"epss_score": 0.00521, "epss_percentile": 0.66245}, "CVE-2004-2403": {"epss_score": 0.01453, "epss_percentile": 0.80372}, "CVE-2004-2405": {"epss_score": 0.00339, "epss_percentile": 0.56163}, "CVE-2004-2406": {"epss_score": 0.00376, "epss_percentile": 0.58674}, "CVE-2004-2407": {"epss_score": 0.00376, "epss_percentile": 0.58674}, "CVE-2004-2408": {"epss_score": 0.00065, "epss_percentile": 0.20454}, "CVE-2004-2409": {"epss_score": 0.00063, "epss_percentile": 0.19992}, "CVE-2004-2410": {"epss_score": 0.00068, "epss_percentile": 0.21315}, "CVE-2004-2411": {"epss_score": 0.01178, "epss_percentile": 0.78285}, "CVE-2004-2412": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2004-2413": {"epss_score": 0.00876, "epss_percentile": 0.74796}, "CVE-2004-2414": {"epss_score": 0.00053, "epss_percentile": 0.16888}, "CVE-2004-2415": {"epss_score": 0.00705, "epss_percentile": 0.71602}, "CVE-2004-2416": {"epss_score": 0.75321, "epss_percentile": 0.98837}, "CVE-2004-2417": {"epss_score": 0.02313, "epss_percentile": 0.84348}, "CVE-2004-2418": {"epss_score": 0.00386, "epss_percentile": 0.59282}, "CVE-2004-2419": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2004-2420": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-2421": {"epss_score": 0.00769, "epss_percentile": 0.72987}, "CVE-2004-2422": {"epss_score": 0.00337, "epss_percentile": 0.5602}, "CVE-2004-2423": {"epss_score": 0.00577, "epss_percentile": 0.68171}, "CVE-2004-2424": {"epss_score": 0.01123, "epss_percentile": 0.77791}, "CVE-2004-2425": {"epss_score": 0.25658, "epss_percentile": 0.96054}, "CVE-2004-2426": {"epss_score": 0.00959, "epss_percentile": 0.75952}, "CVE-2004-2427": {"epss_score": 0.04753, "epss_percentile": 0.89107}, "CVE-2004-2428": {"epss_score": 0.00408, "epss_percentile": 0.60677}, "CVE-2004-2429": {"epss_score": 0.04874, "epss_percentile": 0.89237}, "CVE-2004-2430": {"epss_score": 0.00064, "epss_percentile": 0.20295}, "CVE-2004-2431": {"epss_score": 0.00964, "epss_percentile": 0.76029}, "CVE-2004-2432": {"epss_score": 0.0055, "epss_percentile": 0.67337}, "CVE-2004-2433": {"epss_score": 0.06854, "epss_percentile": 0.91077}, "CVE-2004-2434": {"epss_score": 0.08625, "epss_percentile": 0.92159}, "CVE-2004-2435": {"epss_score": 0.00547, "epss_percentile": 0.67246}, "CVE-2004-2436": {"epss_score": 0.00081, "epss_percentile": 0.24323}, "CVE-2004-2437": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2004-2438": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2004-2439": {"epss_score": 0.01026, "epss_percentile": 0.76799}, "CVE-2004-2440": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2004-2441": {"epss_score": 0.00432, "epss_percentile": 0.62114}, "CVE-2004-2442": {"epss_score": 0.18899, "epss_percentile": 0.95088}, "CVE-2004-2443": {"epss_score": 0.06065, "epss_percentile": 0.90446}, "CVE-2004-2444": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2004-2445": {"epss_score": 0.10213, "epss_percentile": 0.92896}, "CVE-2004-2446": {"epss_score": 0.01029, "epss_percentile": 0.76826}, "CVE-2004-2447": {"epss_score": 0.00809, "epss_percentile": 0.73707}, "CVE-2004-2448": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2004-2449": {"epss_score": 0.03156, "epss_percentile": 0.86515}, "CVE-2004-2450": {"epss_score": 0.00517, "epss_percentile": 0.66091}, "CVE-2004-2451": {"epss_score": 0.03174, "epss_percentile": 0.8656}, "CVE-2004-2452": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2004-2453": {"epss_score": 0.00403, "epss_percentile": 0.60326}, "CVE-2004-2454": {"epss_score": 0.00085, "epss_percentile": 0.25239}, "CVE-2004-2455": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2004-2456": {"epss_score": 0.01234, "epss_percentile": 0.78758}, "CVE-2004-2457": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-2458": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2004-2459": {"epss_score": 0.00136, "epss_percentile": 0.34102}, "CVE-2004-2460": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-2461": {"epss_score": 0.0101, "epss_percentile": 0.76601}, "CVE-2004-2462": {"epss_score": 0.00068, "epss_percentile": 0.21407}, "CVE-2004-2463": {"epss_score": 0.03528, "epss_percentile": 0.87296}, "CVE-2004-2464": {"epss_score": 0.05934, "epss_percentile": 0.90339}, "CVE-2004-2465": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2004-2466": {"epss_score": 0.44511, "epss_percentile": 0.97441}, "CVE-2004-2467": {"epss_score": 0.02024, "epss_percentile": 0.83309}, "CVE-2004-2468": {"epss_score": 0.00523, "epss_percentile": 0.66313}, "CVE-2004-2469": {"epss_score": 0.00437, "epss_percentile": 0.62512}, "CVE-2004-2470": {"epss_score": 0.00403, "epss_percentile": 0.60326}, "CVE-2004-2471": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2004-2472": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-2473": {"epss_score": 0.00033, "epss_percentile": 0.09289}, "CVE-2004-2474": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2004-2475": {"epss_score": 0.00855, "epss_percentile": 0.7447}, "CVE-2004-2476": {"epss_score": 0.17245, "epss_percentile": 0.94805}, "CVE-2004-2477": {"epss_score": 0.00121, "epss_percentile": 0.31889}, "CVE-2004-2478": {"epss_score": 0.03677, "epss_percentile": 0.87554}, "CVE-2004-2479": {"epss_score": 0.0103, "epss_percentile": 0.76841}, "CVE-2004-2480": {"epss_score": 0.03672, "epss_percentile": 0.87541}, "CVE-2004-2481": {"epss_score": 0.00286, "epss_percentile": 0.51687}, "CVE-2004-2482": {"epss_score": 0.21362, "epss_percentile": 0.95507}, "CVE-2004-2483": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-2484": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2004-2485": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2004-2486": {"epss_score": 0.022, "epss_percentile": 0.83976}, "CVE-2004-2487": {"epss_score": 0.04312, "epss_percentile": 0.88533}, "CVE-2004-2488": {"epss_score": 0.00874, "epss_percentile": 0.74758}, "CVE-2004-2489": {"epss_score": 0.00087, "epss_percentile": 0.25588}, "CVE-2004-2490": {"epss_score": 0.0011, "epss_percentile": 0.30218}, "CVE-2004-2491": {"epss_score": 0.1039, "epss_percentile": 0.92972}, "CVE-2004-2492": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2004-2493": {"epss_score": 0.01219, "epss_percentile": 0.78612}, "CVE-2004-2494": {"epss_score": 0.0122, "epss_percentile": 0.78619}, "CVE-2004-2495": {"epss_score": 0.01665, "epss_percentile": 0.81649}, "CVE-2004-2496": {"epss_score": 0.07508, "epss_percentile": 0.91511}, "CVE-2004-2497": {"epss_score": 0.00463, "epss_percentile": 0.63682}, "CVE-2004-2498": {"epss_score": 0.00463, "epss_percentile": 0.63682}, "CVE-2004-2499": {"epss_score": 0.00808, "epss_percentile": 0.73693}, "CVE-2004-2500": {"epss_score": 0.00389, "epss_percentile": 0.59477}, "CVE-2004-2501": {"epss_score": 0.6101, "epss_percentile": 0.98231}, "CVE-2004-2502": {"epss_score": 0.00241, "epss_percentile": 0.47298}, "CVE-2004-2503": {"epss_score": 0.01322, "epss_percentile": 0.79451}, "CVE-2004-2504": {"epss_score": 0.00086, "epss_percentile": 0.25246}, "CVE-2004-2505": {"epss_score": 0.25578, "epss_percentile": 0.96046}, "CVE-2004-2506": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2004-2507": {"epss_score": 0.06867, "epss_percentile": 0.91083}, "CVE-2004-2508": {"epss_score": 0.00614, "epss_percentile": 0.69279}, "CVE-2004-2509": {"epss_score": 0.0138, "epss_percentile": 0.79863}, "CVE-2004-2510": {"epss_score": 0.01604, "epss_percentile": 0.81285}, "CVE-2004-2511": {"epss_score": 0.02567, "epss_percentile": 0.85119}, "CVE-2004-2512": {"epss_score": 0.09876, "epss_percentile": 0.92749}, "CVE-2004-2513": {"epss_score": 0.32413, "epss_percentile": 0.96698}, "CVE-2004-2514": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2004-2515": {"epss_score": 0.00047, "epss_percentile": 0.14859}, "CVE-2004-2516": {"epss_score": 0.10869, "epss_percentile": 0.9314}, "CVE-2004-2517": {"epss_score": 0.0627, "epss_percentile": 0.90628}, "CVE-2004-2518": {"epss_score": 0.12735, "epss_percentile": 0.93762}, "CVE-2004-2519": {"epss_score": 0.07199, "epss_percentile": 0.91316}, "CVE-2004-2520": {"epss_score": 0.05698, "epss_percentile": 0.90128}, "CVE-2004-2521": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-2522": {"epss_score": 0.01529, "epss_percentile": 0.8088}, "CVE-2004-2523": {"epss_score": 0.20644, "epss_percentile": 0.95394}, "CVE-2004-2524": {"epss_score": 0.00945, "epss_percentile": 0.75799}, "CVE-2004-2525": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2004-2526": {"epss_score": 0.06211, "epss_percentile": 0.9057}, "CVE-2004-2527": {"epss_score": 0.01, "epss_percentile": 0.76491}, "CVE-2004-2528": {"epss_score": 0.01349, "epss_percentile": 0.7967}, "CVE-2004-2529": {"epss_score": 0.00971, "epss_percentile": 0.76127}, "CVE-2004-2530": {"epss_score": 0.05778, "epss_percentile": 0.90199}, "CVE-2004-2531": {"epss_score": 0.00872, "epss_percentile": 0.74737}, "CVE-2004-2532": {"epss_score": 0.02021, "epss_percentile": 0.83294}, "CVE-2004-2533": {"epss_score": 0.05452, "epss_percentile": 0.89892}, "CVE-2004-2534": {"epss_score": 0.07361, "epss_percentile": 0.91432}, "CVE-2004-2535": {"epss_score": 0.0026, "epss_percentile": 0.49177}, "CVE-2004-2536": {"epss_score": 0.00482, "epss_percentile": 0.64534}, "CVE-2004-2537": {"epss_score": 0.00475, "epss_percentile": 0.64175}, "CVE-2004-2538": {"epss_score": 0.02814, "epss_percentile": 0.85726}, "CVE-2004-2539": {"epss_score": 0.00916, "epss_percentile": 0.75422}, "CVE-2004-2540": {"epss_score": 0.00928, "epss_percentile": 0.75578}, "CVE-2004-2541": {"epss_score": 0.01939, "epss_percentile": 0.82974}, "CVE-2004-2542": {"epss_score": 0.0069, "epss_percentile": 0.71237}, "CVE-2004-2543": {"epss_score": 0.01344, "epss_percentile": 0.79618}, "CVE-2004-2544": {"epss_score": 0.00044, "epss_percentile": 0.1354}, "CVE-2004-2545": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2004-2546": {"epss_score": 0.00694, "epss_percentile": 0.71349}, "CVE-2004-2547": {"epss_score": 0.17979, "epss_percentile": 0.94936}, "CVE-2004-2548": {"epss_score": 0.1282, "epss_percentile": 0.93784}, "CVE-2004-2549": {"epss_score": 0.07694, "epss_percentile": 0.91631}, "CVE-2004-2550": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2004-2551": {"epss_score": 0.01289, "epss_percentile": 0.79212}, "CVE-2004-2552": {"epss_score": 0.0011, "epss_percentile": 0.30076}, "CVE-2004-2553": {"epss_score": 0.01169, "epss_percentile": 0.782}, "CVE-2004-2554": {"epss_score": 0.00048, "epss_percentile": 0.15074}, "CVE-2004-2555": {"epss_score": 0.00177, "epss_percentile": 0.39498}, "CVE-2004-2556": {"epss_score": 0.0115, "epss_percentile": 0.78032}, "CVE-2004-2557": {"epss_score": 0.01181, "epss_percentile": 0.78309}, "CVE-2004-2558": {"epss_score": 0.00781, "epss_percentile": 0.73187}, "CVE-2004-2559": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2004-2560": {"epss_score": 0.02393, "epss_percentile": 0.84611}, "CVE-2004-2561": {"epss_score": 0.00464, "epss_percentile": 0.63727}, "CVE-2004-2562": {"epss_score": 0.01452, "epss_percentile": 0.80369}, "CVE-2004-2563": {"epss_score": 0.01068, "epss_percentile": 0.7724}, "CVE-2004-2564": {"epss_score": 0.01204, "epss_percentile": 0.78502}, "CVE-2004-2565": {"epss_score": 0.07652, "epss_percentile": 0.91605}, "CVE-2004-2566": {"epss_score": 0.00614, "epss_percentile": 0.69279}, "CVE-2004-2567": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2004-2568": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2004-2569": {"epss_score": 0.00079, "epss_percentile": 0.23972}, "CVE-2004-2570": {"epss_score": 0.00874, "epss_percentile": 0.74755}, "CVE-2004-2571": {"epss_score": 0.03518, "epss_percentile": 0.8728}, "CVE-2004-2572": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2004-2573": {"epss_score": 0.02086, "epss_percentile": 0.83551}, "CVE-2004-2574": {"epss_score": 0.03263, "epss_percentile": 0.86777}, "CVE-2004-2575": {"epss_score": 0.0059, "epss_percentile": 0.6855}, "CVE-2004-2576": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2004-2577": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2004-2578": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2004-2579": {"epss_score": 0.00231, "epss_percentile": 0.45772}, "CVE-2004-2580": {"epss_score": 0.006, "epss_percentile": 0.68828}, "CVE-2004-2581": {"epss_score": 0.0082, "epss_percentile": 0.73876}, "CVE-2004-2582": {"epss_score": 0.00534, "epss_percentile": 0.66791}, "CVE-2004-2583": {"epss_score": 0.00834, "epss_percentile": 0.74111}, "CVE-2004-2584": {"epss_score": 0.00267, "epss_percentile": 0.50012}, "CVE-2004-2585": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2004-2586": {"epss_score": 0.00834, "epss_percentile": 0.74105}, "CVE-2004-2587": {"epss_score": 0.00998, "epss_percentile": 0.76468}, "CVE-2004-2588": {"epss_score": 0.00661, "epss_percentile": 0.7057}, "CVE-2004-2589": {"epss_score": 0.00787, "epss_percentile": 0.73319}, "CVE-2004-2590": {"epss_score": 0.00776, "epss_percentile": 0.73106}, "CVE-2004-2591": {"epss_score": 0.00092, "epss_percentile": 0.26421}, "CVE-2004-2592": {"epss_score": 0.04333, "epss_percentile": 0.8856}, "CVE-2004-2593": {"epss_score": 0.0378, "epss_percentile": 0.87718}, "CVE-2004-2594": {"epss_score": 0.00874, "epss_percentile": 0.74771}, "CVE-2004-2595": {"epss_score": 0.0156, "epss_percentile": 0.81038}, "CVE-2004-2596": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-2597": {"epss_score": 0.0047, "epss_percentile": 0.63959}, "CVE-2004-2598": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2004-2599": {"epss_score": 0.00095, "epss_percentile": 0.27107}, "CVE-2004-2600": {"epss_score": 0.01141, "epss_percentile": 0.77961}, "CVE-2004-2601": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2004-2602": {"epss_score": 0.01764, "epss_percentile": 0.8216}, "CVE-2004-2603": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2004-2604": {"epss_score": 0.00498, "epss_percentile": 0.65234}, "CVE-2004-2605": {"epss_score": 0.00098, "epss_percentile": 0.27781}, "CVE-2004-2606": {"epss_score": 0.02585, "epss_percentile": 0.85164}, "CVE-2004-2607": {"epss_score": 0.00064, "epss_percentile": 0.20253}, "CVE-2004-2608": {"epss_score": 0.00421, "epss_percentile": 0.61534}, "CVE-2004-2609": {"epss_score": 0.00104, "epss_percentile": 0.29172}, "CVE-2004-2610": {"epss_score": 0.00065, "epss_percentile": 0.20642}, "CVE-2004-2611": {"epss_score": 0.00056, "epss_percentile": 0.17696}, "CVE-2004-2612": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-2613": {"epss_score": 0.0038, "epss_percentile": 0.58925}, "CVE-2004-2614": {"epss_score": 0.14217, "epss_percentile": 0.94165}, "CVE-2004-2615": {"epss_score": 0.00051, "epss_percentile": 0.16326}, "CVE-2004-2616": {"epss_score": 0.00416, "epss_percentile": 0.6117}, "CVE-2004-2617": {"epss_score": 0.11152, "epss_percentile": 0.93245}, "CVE-2004-2618": {"epss_score": 0.01457, "epss_percentile": 0.80403}, "CVE-2004-2619": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2004-2620": {"epss_score": 0.00333, "epss_percentile": 0.55642}, "CVE-2004-2621": {"epss_score": 0.00321, "epss_percentile": 0.54696}, "CVE-2004-2622": {"epss_score": 0.01726, "epss_percentile": 0.81959}, "CVE-2004-2623": {"epss_score": 0.00855, "epss_percentile": 0.74457}, "CVE-2004-2624": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2004-2625": {"epss_score": 0.01027, "epss_percentile": 0.76812}, "CVE-2004-2626": {"epss_score": 0.02211, "epss_percentile": 0.84015}, "CVE-2004-2627": {"epss_score": 0.11144, "epss_percentile": 0.93238}, "CVE-2004-2628": {"epss_score": 0.08486, "epss_percentile": 0.92078}, "CVE-2004-2629": {"epss_score": 0.01214, "epss_percentile": 0.7858}, "CVE-2004-2630": {"epss_score": 0.02091, "epss_percentile": 0.8357}, "CVE-2004-2631": {"epss_score": 0.14197, "epss_percentile": 0.94161}, "CVE-2004-2632": {"epss_score": 0.02951, "epss_percentile": 0.86053}, "CVE-2004-2633": {"epss_score": 0.00666, "epss_percentile": 0.70678}, "CVE-2004-2634": {"epss_score": 0.00045, "epss_percentile": 0.13783}, "CVE-2004-2635": {"epss_score": 0.02158, "epss_percentile": 0.83817}, "CVE-2004-2636": {"epss_score": 0.04147, "epss_percentile": 0.88315}, "CVE-2004-2637": {"epss_score": 0.0122, "epss_percentile": 0.78621}, "CVE-2004-2638": {"epss_score": 0.01427, "epss_percentile": 0.8021}, "CVE-2004-2639": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2004-2640": {"epss_score": 0.10463, "epss_percentile": 0.92994}, "CVE-2004-2641": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2004-2642": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2004-2643": {"epss_score": 0.00479, "epss_percentile": 0.64436}, "CVE-2004-2644": {"epss_score": 0.00619, "epss_percentile": 0.69388}, "CVE-2004-2645": {"epss_score": 0.00619, "epss_percentile": 0.69388}, "CVE-2004-2646": {"epss_score": 0.11395, "epss_percentile": 0.93333}, "CVE-2004-2647": {"epss_score": 0.11395, "epss_percentile": 0.93333}, "CVE-2004-2648": {"epss_score": 0.00093, "epss_percentile": 0.2668}, "CVE-2004-2649": {"epss_score": 0.07822, "epss_percentile": 0.91698}, "CVE-2004-2650": {"epss_score": 0.00069, "epss_percentile": 0.21484}, "CVE-2004-2651": {"epss_score": 0.00713, "epss_percentile": 0.71796}, "CVE-2004-2652": {"epss_score": 0.22655, "epss_percentile": 0.95664}, "CVE-2004-2653": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2004-2654": {"epss_score": 0.00508, "epss_percentile": 0.65712}, "CVE-2004-2655": {"epss_score": 0.01401, "epss_percentile": 0.80009}, "CVE-2004-2656": {"epss_score": 0.00871, "epss_percentile": 0.74714}, "CVE-2004-2657": {"epss_score": 0.00146, "epss_percentile": 0.35559}, "CVE-2004-2658": {"epss_score": 0.00063, "epss_percentile": 0.19925}, "CVE-2004-2659": {"epss_score": 0.00308, "epss_percentile": 0.53572}, "CVE-2004-2660": {"epss_score": 0.00047, "epss_percentile": 0.14598}, "CVE-2004-2661": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2004-2662": {"epss_score": 0.00634, "epss_percentile": 0.69799}, "CVE-2004-2663": {"epss_score": 0.01685, "epss_percentile": 0.8175}, "CVE-2004-2664": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2004-2665": {"epss_score": 0.00076, "epss_percentile": 0.23222}, "CVE-2004-2666": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2004-2667": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2004-2668": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2004-2669": {"epss_score": 0.01397, "epss_percentile": 0.79986}, "CVE-2004-2670": {"epss_score": 0.10874, "epss_percentile": 0.93142}, "CVE-2004-2671": {"epss_score": 0.00803, "epss_percentile": 0.73605}, "CVE-2004-2672": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2004-2673": {"epss_score": 0.06325, "epss_percentile": 0.90671}, "CVE-2004-2674": {"epss_score": 0.00434, "epss_percentile": 0.62305}, "CVE-2004-2675": {"epss_score": 0.0785, "epss_percentile": 0.91719}, "CVE-2004-2676": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2004-2677": {"epss_score": 0.15333, "epss_percentile": 0.94412}, "CVE-2004-2678": {"epss_score": 0.00766, "epss_percentile": 0.72945}, "CVE-2004-2679": {"epss_score": 0.00418, "epss_percentile": 0.6129}, "CVE-2004-2680": {"epss_score": 0.1009, "epss_percentile": 0.92846}, "CVE-2004-2681": {"epss_score": 0.00502, "epss_percentile": 0.65414}, "CVE-2004-2682": {"epss_score": 0.00273, "epss_percentile": 0.50458}, "CVE-2004-2683": {"epss_score": 0.0007, "epss_percentile": 0.21782}, "CVE-2004-2684": {"epss_score": 0.0007, "epss_percentile": 0.21782}, "CVE-2004-2685": {"epss_score": 0.38904, "epss_percentile": 0.97125}, "CVE-2004-2686": {"epss_score": 0.00211, "epss_percentile": 0.43622}, "CVE-2004-2687": {"epss_score": 0.90252, "epss_percentile": 0.99572}, "CVE-2004-2688": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2004-2689": {"epss_score": 0.00837, "epss_percentile": 0.74154}, "CVE-2004-2690": {"epss_score": 0.00987, "epss_percentile": 0.76341}, "CVE-2004-2691": {"epss_score": 0.77285, "epss_percentile": 0.98929}, "CVE-2004-2692": {"epss_score": 0.09857, "epss_percentile": 0.92738}, "CVE-2004-2693": {"epss_score": 0.00034, "epss_percentile": 0.09668}, "CVE-2004-2694": {"epss_score": 0.17268, "epss_percentile": 0.94812}, "CVE-2004-2695": {"epss_score": 0.00823, "epss_percentile": 0.73931}, "CVE-2004-2696": {"epss_score": 0.00582, "epss_percentile": 0.68307}, "CVE-2004-2697": {"epss_score": 0.00698, "epss_percentile": 0.7142}, "CVE-2004-2698": {"epss_score": 0.0013, "epss_percentile": 0.33226}, "CVE-2004-2699": {"epss_score": 0.06071, "epss_percentile": 0.90452}, "CVE-2004-2700": {"epss_score": 0.00395, "epss_percentile": 0.59813}, "CVE-2004-2701": {"epss_score": 0.00574, "epss_percentile": 0.68076}, "CVE-2004-2702": {"epss_score": 0.0767, "epss_percentile": 0.91613}, "CVE-2004-2703": {"epss_score": 0.00338, "epss_percentile": 0.56114}, "CVE-2004-2704": {"epss_score": 0.25149, "epss_percentile": 0.95991}, "CVE-2004-2705": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2004-2706": {"epss_score": 0.00518, "epss_percentile": 0.66094}, "CVE-2004-2707": {"epss_score": 0.00492, "epss_percentile": 0.64997}, "CVE-2004-2708": {"epss_score": 0.00281, "epss_percentile": 0.51198}, "CVE-2004-2709": {"epss_score": 0.01553, "epss_percentile": 0.80998}, "CVE-2004-2710": {"epss_score": 0.01622, "epss_percentile": 0.81397}, "CVE-2004-2711": {"epss_score": 0.01553, "epss_percentile": 0.80998}, "CVE-2004-2712": {"epss_score": 0.00565, "epss_percentile": 0.67779}, "CVE-2004-2713": {"epss_score": 0.00082, "epss_percentile": 0.2441}, "CVE-2004-2714": {"epss_score": 0.00641, "epss_percentile": 0.69997}, "CVE-2004-2715": {"epss_score": 0.05589, "epss_percentile": 0.90028}, "CVE-2004-2716": {"epss_score": 0.00571, "epss_percentile": 0.67997}, "CVE-2004-2717": {"epss_score": 0.02391, "epss_percentile": 0.846}, "CVE-2004-2718": {"epss_score": 0.02837, "epss_percentile": 0.85792}, "CVE-2004-2719": {"epss_score": 0.20111, "epss_percentile": 0.95289}, "CVE-2004-2720": {"epss_score": 0.09073, "epss_percentile": 0.92387}, "CVE-2004-2721": {"epss_score": 0.00463, "epss_percentile": 0.63633}, "CVE-2004-2722": {"epss_score": 0.00144, "epss_percentile": 0.35259}, "CVE-2004-2723": {"epss_score": 0.00076, "epss_percentile": 0.23086}, "CVE-2004-2724": {"epss_score": 0.00952, "epss_percentile": 0.75872}, "CVE-2004-2725": {"epss_score": 0.00618, "epss_percentile": 0.69377}, "CVE-2004-2726": {"epss_score": 0.01708, "epss_percentile": 0.81867}, "CVE-2004-2727": {"epss_score": 0.04616, "epss_percentile": 0.88924}, "CVE-2004-2728": {"epss_score": 0.01007, "epss_percentile": 0.76563}, "CVE-2004-2729": {"epss_score": 0.00071, "epss_percentile": 0.22212}, "CVE-2004-2730": {"epss_score": 0.00919, "epss_percentile": 0.75454}, "CVE-2004-2731": {"epss_score": 0.00136, "epss_percentile": 0.34103}, "CVE-2004-2732": {"epss_score": 0.02463, "epss_percentile": 0.8483}, "CVE-2004-2733": {"epss_score": 0.01013, "epss_percentile": 0.76631}, "CVE-2004-2734": {"epss_score": 0.01561, "epss_percentile": 0.81042}, "CVE-2004-2735": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2004-2736": {"epss_score": 0.05345, "epss_percentile": 0.89769}, "CVE-2004-2737": {"epss_score": 0.0044, "epss_percentile": 0.62627}, "CVE-2004-2738": {"epss_score": 0.00535, "epss_percentile": 0.66834}, "CVE-2004-2739": {"epss_score": 0.01173, "epss_percentile": 0.78243}, "CVE-2004-2740": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2004-2741": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2004-2742": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2004-2743": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2004-2744": {"epss_score": 0.004, "epss_percentile": 0.60196}, "CVE-2004-2745": {"epss_score": 0.02201, "epss_percentile": 0.83977}, "CVE-2004-2746": {"epss_score": 0.00749, "epss_percentile": 0.72612}, "CVE-2004-2747": {"epss_score": 0.00264, "epss_percentile": 0.49749}, "CVE-2004-2748": {"epss_score": 0.06803, "epss_percentile": 0.91036}, "CVE-2004-2749": {"epss_score": 0.00498, "epss_percentile": 0.6523}, "CVE-2004-2750": {"epss_score": 0.02948, "epss_percentile": 0.86047}, "CVE-2004-2751": {"epss_score": 0.00783, "epss_percentile": 0.73214}, "CVE-2004-2752": {"epss_score": 0.00278, "epss_percentile": 0.50885}, "CVE-2004-2753": {"epss_score": 0.00078, "epss_percentile": 0.23763}, "CVE-2004-2754": {"epss_score": 0.0189, "epss_percentile": 0.82727}, "CVE-2004-2755": {"epss_score": 0.0109, "epss_percentile": 0.77447}, "CVE-2004-2756": {"epss_score": 0.00413, "epss_percentile": 0.60991}, "CVE-2004-2757": {"epss_score": 0.00271, "epss_percentile": 0.50307}, "CVE-2004-2758": {"epss_score": 0.08489, "epss_percentile": 0.92081}, "CVE-2004-2759": {"epss_score": 0.00069, "epss_percentile": 0.21628}, "CVE-2004-2760": {"epss_score": 0.00303, "epss_percentile": 0.53182}, "CVE-2004-2761": {"epss_score": 0.08455, "epss_percentile": 0.92061}, "CVE-2004-2762": {"epss_score": 0.01169, "epss_percentile": 0.78198}, "CVE-2004-2763": {"epss_score": 0.0072, "epss_percentile": 0.71962}, "CVE-2004-2764": {"epss_score": 0.01022, "epss_percentile": 0.7676}, "CVE-2004-2765": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2004-2766": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2004-2767": {"epss_score": 0.00658, "epss_percentile": 0.70496}, "CVE-2004-2768": {"epss_score": 0.00062, "epss_percentile": 0.19704}, "CVE-2004-2769": {"epss_score": 0.00273, "epss_percentile": 0.5048}, "CVE-2004-2771": {"epss_score": 0.02007, "epss_percentile": 0.83239}, "CVE-2004-2776": {"epss_score": 0.02985, "epss_percentile": 0.86131}, "CVE-2004-2777": {"epss_score": 0.00419, "epss_percentile": 0.61354}, "CVE-2004-2778": {"epss_score": 0.00048, "epss_percentile": 0.1525}, "CVE-2004-2779": {"epss_score": 0.00288, "epss_percentile": 0.51871}, "CVE-2005-0001": {"epss_score": 0.01073, "epss_percentile": 0.7729}, "CVE-2005-0002": {"epss_score": 0.00933, "epss_percentile": 0.75638}, "CVE-2005-0003": {"epss_score": 0.00093, "epss_percentile": 0.26653}, "CVE-2005-0004": {"epss_score": 0.00045, "epss_percentile": 0.13893}, "CVE-2005-0005": {"epss_score": 0.03499, "epss_percentile": 0.87242}, "CVE-2005-0006": {"epss_score": 0.05659, "epss_percentile": 0.90095}, "CVE-2005-0007": {"epss_score": 0.01825, "epss_percentile": 0.8243}, "CVE-2005-0008": {"epss_score": 0.02533, "epss_percentile": 0.85033}, "CVE-2005-0009": {"epss_score": 0.04915, "epss_percentile": 0.89284}, "CVE-2005-0010": {"epss_score": 0.01825, "epss_percentile": 0.8243}, "CVE-2005-0011": {"epss_score": 0.04907, "epss_percentile": 0.89277}, "CVE-2005-0012": {"epss_score": 0.03601, "epss_percentile": 0.8741}, "CVE-2005-0013": {"epss_score": 0.00047, "epss_percentile": 0.14915}, "CVE-2005-0014": {"epss_score": 0.0183, "epss_percentile": 0.82445}, "CVE-2005-0015": {"epss_score": 0.01079, "epss_percentile": 0.77356}, "CVE-2005-0016": {"epss_score": 0.00057, "epss_percentile": 0.18154}, "CVE-2005-0017": {"epss_score": 0.00098, "epss_percentile": 0.27781}, "CVE-2005-0018": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2005-0019": {"epss_score": 0.00068, "epss_percentile": 0.21421}, "CVE-2005-0020": {"epss_score": 0.00082, "epss_percentile": 0.24501}, "CVE-2005-0021": {"epss_score": 0.02817, "epss_percentile": 0.85738}, "CVE-2005-0022": {"epss_score": 0.01451, "epss_percentile": 0.80358}, "CVE-2005-0023": {"epss_score": 0.00151, "epss_percentile": 0.36213}, "CVE-2005-0033": {"epss_score": 0.32012, "epss_percentile": 0.96666}, "CVE-2005-0034": {"epss_score": 0.06639, "epss_percentile": 0.90909}, "CVE-2005-0035": {"epss_score": 0.03801, "epss_percentile": 0.87744}, "CVE-2005-0036": {"epss_score": 0.00928, "epss_percentile": 0.75578}, "CVE-2005-0037": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2005-0038": {"epss_score": 0.00076, "epss_percentile": 0.2311}, "CVE-2005-0039": {"epss_score": 0.02293, "epss_percentile": 0.84287}, "CVE-2005-0040": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-0043": {"epss_score": 0.7991, "epss_percentile": 0.99062}, "CVE-2005-0044": {"epss_score": 0.50887, "epss_percentile": 0.97754}, "CVE-2005-0045": {"epss_score": 0.83852, "epss_percentile": 0.99263}, "CVE-2005-0047": {"epss_score": 0.08949, "epss_percentile": 0.92334}, "CVE-2005-0048": {"epss_score": 0.66719, "epss_percentile": 0.98475}, "CVE-2005-0049": {"epss_score": 0.24059, "epss_percentile": 0.95851}, "CVE-2005-0050": {"epss_score": 0.55494, "epss_percentile": 0.9798}, "CVE-2005-0051": {"epss_score": 0.47193, "epss_percentile": 0.97574}, "CVE-2005-0053": {"epss_score": 0.65878, "epss_percentile": 0.98442}, "CVE-2005-0054": {"epss_score": 0.35144, "epss_percentile": 0.96891}, "CVE-2005-0055": {"epss_score": 0.4812, "epss_percentile": 0.97622}, "CVE-2005-0056": {"epss_score": 0.29547, "epss_percentile": 0.96456}, "CVE-2005-0057": {"epss_score": 0.66799, "epss_percentile": 0.98479}, "CVE-2005-0058": {"epss_score": 0.26822, "epss_percentile": 0.96183}, "CVE-2005-0059": {"epss_score": 0.88938, "epss_percentile": 0.995}, "CVE-2005-0060": {"epss_score": 0.0131, "epss_percentile": 0.7936}, "CVE-2005-0061": {"epss_score": 0.02204, "epss_percentile": 0.83998}, "CVE-2005-0063": {"epss_score": 0.69788, "epss_percentile": 0.98603}, "CVE-2005-0064": {"epss_score": 0.08395, "epss_percentile": 0.92029}, "CVE-2005-0065": {"epss_score": 0.01317, "epss_percentile": 0.79417}, "CVE-2005-0066": {"epss_score": 0.01228, "epss_percentile": 0.78706}, "CVE-2005-0067": {"epss_score": 0.01228, "epss_percentile": 0.78706}, "CVE-2005-0068": {"epss_score": 0.01374, "epss_percentile": 0.79822}, "CVE-2005-0069": {"epss_score": 0.00081, "epss_percentile": 0.24211}, "CVE-2005-0070": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2005-0071": {"epss_score": 0.00732, "epss_percentile": 0.72201}, "CVE-2005-0072": {"epss_score": 0.00078, "epss_percentile": 0.23623}, "CVE-2005-0073": {"epss_score": 0.00098, "epss_percentile": 0.2773}, "CVE-2005-0074": {"epss_score": 0.00054, "epss_percentile": 0.17135}, "CVE-2005-0075": {"epss_score": 0.00826, "epss_percentile": 0.7397}, "CVE-2005-0076": {"epss_score": 0.00071, "epss_percentile": 0.22033}, "CVE-2005-0077": {"epss_score": 0.00074, "epss_percentile": 0.22698}, "CVE-2005-0078": {"epss_score": 0.00077, "epss_percentile": 0.23297}, "CVE-2005-0079": {"epss_score": 0.0008, "epss_percentile": 0.24131}, "CVE-2005-0080": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-0081": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-0082": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2005-0083": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2005-0084": {"epss_score": 0.02317, "epss_percentile": 0.84358}, "CVE-2005-0085": {"epss_score": 0.04725, "epss_percentile": 0.89062}, "CVE-2005-0086": {"epss_score": 0.00907, "epss_percentile": 0.75261}, "CVE-2005-0087": {"epss_score": 0.00078, "epss_percentile": 0.23582}, "CVE-2005-0088": {"epss_score": 0.27653, "epss_percentile": 0.96269}, "CVE-2005-0089": {"epss_score": 0.09112, "epss_percentile": 0.92405}, "CVE-2005-0090": {"epss_score": 0.00058, "epss_percentile": 0.18432}, "CVE-2005-0091": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2005-0092": {"epss_score": 0.00058, "epss_percentile": 0.18432}, "CVE-2005-0094": {"epss_score": 0.46134, "epss_percentile": 0.97532}, "CVE-2005-0095": {"epss_score": 0.75842, "epss_percentile": 0.98866}, "CVE-2005-0096": {"epss_score": 0.02283, "epss_percentile": 0.84259}, "CVE-2005-0097": {"epss_score": 0.48277, "epss_percentile": 0.97629}, "CVE-2005-0098": {"epss_score": 0.00088, "epss_percentile": 0.25759}, "CVE-2005-0099": {"epss_score": 0.00062, "epss_percentile": 0.19723}, "CVE-2005-0100": {"epss_score": 0.02845, "epss_percentile": 0.8582}, "CVE-2005-0101": {"epss_score": 0.45619, "epss_percentile": 0.97493}, "CVE-2005-0102": {"epss_score": 0.00599, "epss_percentile": 0.68789}, "CVE-2005-0103": {"epss_score": 0.03446, "epss_percentile": 0.87149}, "CVE-2005-0104": {"epss_score": 0.01372, "epss_percentile": 0.79815}, "CVE-2005-0105": {"epss_score": 0.00162, "epss_percentile": 0.37662}, "CVE-2005-0106": {"epss_score": 0.00065, "epss_percentile": 0.20642}, "CVE-2005-0107": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2005-0108": {"epss_score": 0.02327, "epss_percentile": 0.84391}, "CVE-2005-0109": {"epss_score": 0.00143, "epss_percentile": 0.35152}, "CVE-2005-0110": {"epss_score": 0.027, "epss_percentile": 0.85452}, "CVE-2005-0111": {"epss_score": 0.04963, "epss_percentile": 0.89338}, "CVE-2005-0112": {"epss_score": 0.0053, "epss_percentile": 0.66609}, "CVE-2005-0113": {"epss_score": 0.00068, "epss_percentile": 0.21335}, "CVE-2005-0114": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2005-0115": {"epss_score": 0.01602, "epss_percentile": 0.81273}, "CVE-2005-0116": {"epss_score": 0.91763, "epss_percentile": 0.99667}, "CVE-2005-0117": {"epss_score": 0.00079, "epss_percentile": 0.23907}, "CVE-2005-0118": {"epss_score": 0.00048, "epss_percentile": 0.15236}, "CVE-2005-0119": {"epss_score": 0.00081, "epss_percentile": 0.24212}, "CVE-2005-0120": {"epss_score": 0.00055, "epss_percentile": 0.17466}, "CVE-2005-0121": {"epss_score": 0.00096, "epss_percentile": 0.27277}, "CVE-2005-0124": {"epss_score": 0.00168, "epss_percentile": 0.38494}, "CVE-2005-0125": {"epss_score": 0.00045, "epss_percentile": 0.1373}, "CVE-2005-0126": {"epss_score": 0.00715, "epss_percentile": 0.71832}, "CVE-2005-0127": {"epss_score": 0.00782, "epss_percentile": 0.73195}, "CVE-2005-0129": {"epss_score": 0.14916, "epss_percentile": 0.94322}, "CVE-2005-0130": {"epss_score": 0.01639, "epss_percentile": 0.81488}, "CVE-2005-0131": {"epss_score": 0.01149, "epss_percentile": 0.78016}, "CVE-2005-0133": {"epss_score": 0.01306, "epss_percentile": 0.79332}, "CVE-2005-0134": {"epss_score": 0.00066, "epss_percentile": 0.20841}, "CVE-2005-0135": {"epss_score": 0.00068, "epss_percentile": 0.21362}, "CVE-2005-0136": {"epss_score": 0.00062, "epss_percentile": 0.1958}, "CVE-2005-0137": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2005-0138": {"epss_score": 0.00489, "epss_percentile": 0.64872}, "CVE-2005-0139": {"epss_score": 0.00489, "epss_percentile": 0.64872}, "CVE-2005-0140": {"epss_score": 0.01383, "epss_percentile": 0.79895}, "CVE-2005-0141": {"epss_score": 0.00749, "epss_percentile": 0.72599}, "CVE-2005-0142": {"epss_score": 0.00059, "epss_percentile": 0.18713}, "CVE-2005-0143": {"epss_score": 0.00774, "epss_percentile": 0.73067}, "CVE-2005-0144": {"epss_score": 0.00637, "epss_percentile": 0.69883}, "CVE-2005-0145": {"epss_score": 0.00412, "epss_percentile": 0.6095}, "CVE-2005-0146": {"epss_score": 0.00765, "epss_percentile": 0.7293}, "CVE-2005-0147": {"epss_score": 0.01128, "epss_percentile": 0.77831}, "CVE-2005-0148": {"epss_score": 0.00488, "epss_percentile": 0.64841}, "CVE-2005-0149": {"epss_score": 0.012, "epss_percentile": 0.78465}, "CVE-2005-0150": {"epss_score": 0.01433, "epss_percentile": 0.80257}, "CVE-2005-0151": {"epss_score": 0.02052, "epss_percentile": 0.83408}, "CVE-2005-0152": {"epss_score": 0.05709, "epss_percentile": 0.90139}, "CVE-2005-0155": {"epss_score": 0.00372, "epss_percentile": 0.58459}, "CVE-2005-0156": {"epss_score": 0.00386, "epss_percentile": 0.59242}, "CVE-2005-0157": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2005-0158": {"epss_score": 0.00899, "epss_percentile": 0.75152}, "CVE-2005-0159": {"epss_score": 0.00061, "epss_percentile": 0.19395}, "CVE-2005-0160": {"epss_score": 0.02189, "epss_percentile": 0.8393}, "CVE-2005-0161": {"epss_score": 0.00458, "epss_percentile": 0.63396}, "CVE-2005-0162": {"epss_score": 0.04296, "epss_percentile": 0.8851}, "CVE-2005-0173": {"epss_score": 0.01691, "epss_percentile": 0.81781}, "CVE-2005-0174": {"epss_score": 0.85951, "epss_percentile": 0.99357}, "CVE-2005-0175": {"epss_score": 0.81602, "epss_percentile": 0.99147}, "CVE-2005-0176": {"epss_score": 0.00681, "epss_percentile": 0.71041}, "CVE-2005-0177": {"epss_score": 0.00739, "epss_percentile": 0.72393}, "CVE-2005-0178": {"epss_score": 0.00048, "epss_percentile": 0.15277}, "CVE-2005-0179": {"epss_score": 0.00078, "epss_percentile": 0.23681}, "CVE-2005-0180": {"epss_score": 0.001, "epss_percentile": 0.28517}, "CVE-2005-0182": {"epss_score": 0.00619, "epss_percentile": 0.69393}, "CVE-2005-0183": {"epss_score": 0.00088, "epss_percentile": 0.25722}, "CVE-2005-0184": {"epss_score": 0.00078, "epss_percentile": 0.23586}, "CVE-2005-0185": {"epss_score": 0.04181, "epss_percentile": 0.88356}, "CVE-2005-0186": {"epss_score": 0.01327, "epss_percentile": 0.79491}, "CVE-2005-0187": {"epss_score": 0.0385, "epss_percentile": 0.87848}, "CVE-2005-0188": {"epss_score": 0.02313, "epss_percentile": 0.84348}, "CVE-2005-0189": {"epss_score": 0.22233, "epss_percentile": 0.95612}, "CVE-2005-0190": {"epss_score": 0.03112, "epss_percentile": 0.86426}, "CVE-2005-0191": {"epss_score": 0.06588, "epss_percentile": 0.90868}, "CVE-2005-0192": {"epss_score": 0.02346, "epss_percentile": 0.84452}, "CVE-2005-0193": {"epss_score": 0.00196, "epss_percentile": 0.41774}, "CVE-2005-0194": {"epss_score": 0.00656, "epss_percentile": 0.7045}, "CVE-2005-0195": {"epss_score": 0.02, "epss_percentile": 0.83214}, "CVE-2005-0196": {"epss_score": 0.03307, "epss_percentile": 0.8688}, "CVE-2005-0197": {"epss_score": 0.01157, "epss_percentile": 0.78111}, "CVE-2005-0198": {"epss_score": 0.26656, "epss_percentile": 0.96164}, "CVE-2005-0199": {"epss_score": 0.20153, "epss_percentile": 0.95296}, "CVE-2005-0200": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-0201": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2005-0202": {"epss_score": 0.02731, "epss_percentile": 0.85537}, "CVE-2005-0204": {"epss_score": 0.00085, "epss_percentile": 0.25241}, "CVE-2005-0205": {"epss_score": 0.00077, "epss_percentile": 0.23471}, "CVE-2005-0206": {"epss_score": 0.06529, "epss_percentile": 0.90823}, "CVE-2005-0207": {"epss_score": 0.00078, "epss_percentile": 0.23797}, "CVE-2005-0208": {"epss_score": 0.11987, "epss_percentile": 0.93537}, "CVE-2005-0209": {"epss_score": 0.00849, "epss_percentile": 0.7438}, "CVE-2005-0210": {"epss_score": 0.00045, "epss_percentile": 0.13828}, "CVE-2005-0211": {"epss_score": 0.41519, "epss_percentile": 0.9728}, "CVE-2005-0212": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2005-0213": {"epss_score": 0.00384, "epss_percentile": 0.59173}, "CVE-2005-0214": {"epss_score": 0.01302, "epss_percentile": 0.79306}, "CVE-2005-0215": {"epss_score": 0.00975, "epss_percentile": 0.76198}, "CVE-2005-0216": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-0217": {"epss_score": 0.0095, "epss_percentile": 0.75861}, "CVE-2005-0218": {"epss_score": 0.00592, "epss_percentile": 0.68623}, "CVE-2005-0219": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-0220": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2005-0221": {"epss_score": 0.00871, "epss_percentile": 0.74714}, "CVE-2005-0222": {"epss_score": 0.00773, "epss_percentile": 0.73056}, "CVE-2005-0223": {"epss_score": 0.00548, "epss_percentile": 0.67292}, "CVE-2005-0224": {"epss_score": 0.00712, "epss_percentile": 0.7175}, "CVE-2005-0225": {"epss_score": 0.00098, "epss_percentile": 0.27781}, "CVE-2005-0226": {"epss_score": 0.1001, "epss_percentile": 0.92816}, "CVE-2005-0227": {"epss_score": 0.00116, "epss_percentile": 0.31084}, "CVE-2005-0229": {"epss_score": 0.09876, "epss_percentile": 0.92749}, "CVE-2005-0230": {"epss_score": 0.0221, "epss_percentile": 0.84013}, "CVE-2005-0231": {"epss_score": 0.02663, "epss_percentile": 0.85373}, "CVE-2005-0232": {"epss_score": 0.01324, "epss_percentile": 0.79464}, "CVE-2005-0233": {"epss_score": 0.08584, "epss_percentile": 0.92135}, "CVE-2005-0234": {"epss_score": 0.00495, "epss_percentile": 0.65122}, "CVE-2005-0235": {"epss_score": 0.00642, "epss_percentile": 0.7004}, "CVE-2005-0236": {"epss_score": 0.00367, "epss_percentile": 0.58136}, "CVE-2005-0237": {"epss_score": 0.01025, "epss_percentile": 0.76789}, "CVE-2005-0238": {"epss_score": 0.00748, "epss_percentile": 0.7258}, "CVE-2005-0239": {"epss_score": 0.01788, "epss_percentile": 0.82267}, "CVE-2005-0240": {"epss_score": 0.00054, "epss_percentile": 0.17348}, "CVE-2005-0241": {"epss_score": 0.86221, "epss_percentile": 0.99374}, "CVE-2005-0242": {"epss_score": 0.00056, "epss_percentile": 0.17816}, "CVE-2005-0243": {"epss_score": 0.00318, "epss_percentile": 0.54398}, "CVE-2005-0244": {"epss_score": 0.00836, "epss_percentile": 0.74144}, "CVE-2005-0245": {"epss_score": 0.23114, "epss_percentile": 0.95736}, "CVE-2005-0246": {"epss_score": 0.01907, "epss_percentile": 0.8281}, "CVE-2005-0247": {"epss_score": 0.01559, "epss_percentile": 0.81035}, "CVE-2005-0248": {"epss_score": 0.00567, "epss_percentile": 0.67839}, "CVE-2005-0249": {"epss_score": 0.10603, "epss_percentile": 0.93043}, "CVE-2005-0250": {"epss_score": 0.00114, "epss_percentile": 0.30813}, "CVE-2005-0251": {"epss_score": 0.03132, "epss_percentile": 0.86476}, "CVE-2005-0252": {"epss_score": 0.00836, "epss_percentile": 0.7414}, "CVE-2005-0253": {"epss_score": 0.05516, "epss_percentile": 0.8995}, "CVE-2005-0254": {"epss_score": 0.00702, "epss_percentile": 0.71505}, "CVE-2005-0255": {"epss_score": 0.07998, "epss_percentile": 0.91814}, "CVE-2005-0256": {"epss_score": 0.26554, "epss_percentile": 0.96156}, "CVE-2005-0258": {"epss_score": 0.00473, "epss_percentile": 0.64083}, "CVE-2005-0259": {"epss_score": 0.00539, "epss_percentile": 0.66958}, "CVE-2005-0260": {"epss_score": 0.81028, "epss_percentile": 0.99117}, "CVE-2005-0261": {"epss_score": 0.0007, "epss_percentile": 0.21746}, "CVE-2005-0262": {"epss_score": 0.00432, "epss_percentile": 0.62098}, "CVE-2005-0263": {"epss_score": 0.00432, "epss_percentile": 0.62098}, "CVE-2005-0264": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-0265": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2005-0266": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-0267": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2005-0268": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-0269": {"epss_score": 0.01763, "epss_percentile": 0.82158}, "CVE-2005-0270": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2005-0271": {"epss_score": 0.00528, "epss_percentile": 0.66535}, "CVE-2005-0272": {"epss_score": 0.03482, "epss_percentile": 0.87222}, "CVE-2005-0273": {"epss_score": 0.00708, "epss_percentile": 0.71665}, "CVE-2005-0274": {"epss_score": 0.0487, "epss_percentile": 0.89231}, "CVE-2005-0275": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-0276": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2005-0277": {"epss_score": 0.79303, "epss_percentile": 0.9903}, "CVE-2005-0278": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2005-0279": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2005-0280": {"epss_score": 0.09354, "epss_percentile": 0.92514}, "CVE-2005-0281": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-0282": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-0283": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2005-0284": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-0285": {"epss_score": 0.00518, "epss_percentile": 0.66128}, "CVE-2005-0286": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-0287": {"epss_score": 0.00495, "epss_percentile": 0.65119}, "CVE-2005-0288": {"epss_score": 0.00318, "epss_percentile": 0.54427}, "CVE-2005-0289": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2005-0290": {"epss_score": 0.00706, "epss_percentile": 0.7161}, "CVE-2005-0291": {"epss_score": 0.00605, "epss_percentile": 0.6898}, "CVE-2005-0292": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2005-0293": {"epss_score": 0.00413, "epss_percentile": 0.60991}, "CVE-2005-0294": {"epss_score": 0.00964, "epss_percentile": 0.76028}, "CVE-2005-0295": {"epss_score": 0.00156, "epss_percentile": 0.36998}, "CVE-2005-0296": {"epss_score": 0.00638, "epss_percentile": 0.69913}, "CVE-2005-0297": {"epss_score": 0.00498, "epss_percentile": 0.65218}, "CVE-2005-0298": {"epss_score": 0.00337, "epss_percentile": 0.56041}, "CVE-2005-0299": {"epss_score": 0.00457, "epss_percentile": 0.63366}, "CVE-2005-0300": {"epss_score": 0.01358, "epss_percentile": 0.79732}, "CVE-2005-0301": {"epss_score": 0.00532, "epss_percentile": 0.66701}, "CVE-2005-0302": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-0303": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-0304": {"epss_score": 0.00987, "epss_percentile": 0.76347}, "CVE-2005-0305": {"epss_score": 0.08521, "epss_percentile": 0.921}, "CVE-2005-0306": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-0307": {"epss_score": 0.00442, "epss_percentile": 0.627}, "CVE-2005-0308": {"epss_score": 0.78115, "epss_percentile": 0.98969}, "CVE-2005-0309": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-0310": {"epss_score": 0.00262, "epss_percentile": 0.49405}, "CVE-2005-0311": {"epss_score": 0.00392, "epss_percentile": 0.59674}, "CVE-2005-0312": {"epss_score": 0.01334, "epss_percentile": 0.79537}, "CVE-2005-0313": {"epss_score": 0.08793, "epss_percentile": 0.92256}, "CVE-2005-0314": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-0315": {"epss_score": 0.00365, "epss_percentile": 0.58008}, "CVE-2005-0316": {"epss_score": 0.13907, "epss_percentile": 0.9409}, "CVE-2005-0317": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-0318": {"epss_score": 0.00132, "epss_percentile": 0.33518}, "CVE-2005-0319": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-0320": {"epss_score": 0.02806, "epss_percentile": 0.85707}, "CVE-2005-0321": {"epss_score": 0.00126, "epss_percentile": 0.32627}, "CVE-2005-0322": {"epss_score": 0.00033, "epss_percentile": 0.09414}, "CVE-2005-0323": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-0324": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-0325": {"epss_score": 0.11437, "epss_percentile": 0.9336}, "CVE-2005-0326": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-0327": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-0328": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-0329": {"epss_score": 0.00853, "epss_percentile": 0.74434}, "CVE-2005-0330": {"epss_score": 0.03049, "epss_percentile": 0.86286}, "CVE-2005-0331": {"epss_score": 0.00383, "epss_percentile": 0.59089}, "CVE-2005-0332": {"epss_score": 0.01626, "epss_percentile": 0.81429}, "CVE-2005-0333": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2005-0334": {"epss_score": 0.01317, "epss_percentile": 0.79416}, "CVE-2005-0335": {"epss_score": 0.0025, "epss_percentile": 0.48121}, "CVE-2005-0336": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-0337": {"epss_score": 0.00846, "epss_percentile": 0.74319}, "CVE-2005-0338": {"epss_score": 0.10484, "epss_percentile": 0.93003}, "CVE-2005-0339": {"epss_score": 0.25783, "epss_percentile": 0.96069}, "CVE-2005-0340": {"epss_score": 0.04618, "epss_percentile": 0.88927}, "CVE-2005-0341": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-0342": {"epss_score": 0.00205, "epss_percentile": 0.42743}, "CVE-2005-0343": {"epss_score": 0.01325, "epss_percentile": 0.79469}, "CVE-2005-0344": {"epss_score": 0.0511, "epss_percentile": 0.89508}, "CVE-2005-0345": {"epss_score": 0.04025, "epss_percentile": 0.88139}, "CVE-2005-0346": {"epss_score": 0.00071, "epss_percentile": 0.22167}, "CVE-2005-0347": {"epss_score": 0.03129, "epss_percentile": 0.86462}, "CVE-2005-0348": {"epss_score": 0.01216, "epss_percentile": 0.78591}, "CVE-2005-0349": {"epss_score": 0.01399, "epss_percentile": 0.79998}, "CVE-2005-0350": {"epss_score": 0.03077, "epss_percentile": 0.86363}, "CVE-2005-0351": {"epss_score": 0.00124, "epss_percentile": 0.32347}, "CVE-2005-0352": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2005-0353": {"epss_score": 0.78339, "epss_percentile": 0.98981}, "CVE-2005-0356": {"epss_score": 0.81532, "epss_percentile": 0.99143}, "CVE-2005-0357": {"epss_score": 0.17713, "epss_percentile": 0.94895}, "CVE-2005-0358": {"epss_score": 0.17887, "epss_percentile": 0.94922}, "CVE-2005-0359": {"epss_score": 0.10244, "epss_percentile": 0.9291}, "CVE-2005-0360": {"epss_score": 0.06372, "epss_percentile": 0.90706}, "CVE-2005-0362": {"epss_score": 0.00192, "epss_percentile": 0.4132}, "CVE-2005-0363": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2005-0364": {"epss_score": 0.00826, "epss_percentile": 0.73972}, "CVE-2005-0365": {"epss_score": 0.0007, "epss_percentile": 0.21832}, "CVE-2005-0366": {"epss_score": 0.07683, "epss_percentile": 0.91624}, "CVE-2005-0367": {"epss_score": 0.00534, "epss_percentile": 0.66777}, "CVE-2005-0368": {"epss_score": 0.00441, "epss_percentile": 0.62675}, "CVE-2005-0369": {"epss_score": 0.04274, "epss_percentile": 0.8848}, "CVE-2005-0370": {"epss_score": 0.03927, "epss_percentile": 0.87967}, "CVE-2005-0371": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-0372": {"epss_score": 0.04093, "epss_percentile": 0.88244}, "CVE-2005-0373": {"epss_score": 0.04758, "epss_percentile": 0.89116}, "CVE-2005-0374": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-0375": {"epss_score": 0.0057, "epss_percentile": 0.67965}, "CVE-2005-0376": {"epss_score": 0.0214, "epss_percentile": 0.83746}, "CVE-2005-0377": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2005-0378": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2005-0379": {"epss_score": 0.00279, "epss_percentile": 0.50991}, "CVE-2005-0380": {"epss_score": 0.05154, "epss_percentile": 0.89551}, "CVE-2005-0381": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-0382": {"epss_score": 0.06022, "epss_percentile": 0.90417}, "CVE-2005-0383": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2005-0384": {"epss_score": 0.12773, "epss_percentile": 0.93768}, "CVE-2005-0385": {"epss_score": 0.00148, "epss_percentile": 0.35863}, "CVE-2005-0386": {"epss_score": 0.00281, "epss_percentile": 0.51106}, "CVE-2005-0387": {"epss_score": 0.00078, "epss_percentile": 0.23686}, "CVE-2005-0388": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2005-0390": {"epss_score": 0.04102, "epss_percentile": 0.88261}, "CVE-2005-0391": {"epss_score": 0.00257, "epss_percentile": 0.48861}, "CVE-2005-0392": {"epss_score": 0.00064, "epss_percentile": 0.20136}, "CVE-2005-0393": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2005-0396": {"epss_score": 0.00077, "epss_percentile": 0.23379}, "CVE-2005-0397": {"epss_score": 0.04522, "epss_percentile": 0.88801}, "CVE-2005-0398": {"epss_score": 0.04064, "epss_percentile": 0.88194}, "CVE-2005-0399": {"epss_score": 0.41278, "epss_percentile": 0.97263}, "CVE-2005-0400": {"epss_score": 0.00087, "epss_percentile": 0.25633}, "CVE-2005-0401": {"epss_score": 0.03853, "epss_percentile": 0.87855}, "CVE-2005-0402": {"epss_score": 0.01444, "epss_percentile": 0.8032}, "CVE-2005-0403": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2005-0404": {"epss_score": 0.04466, "epss_percentile": 0.88729}, "CVE-2005-0406": {"epss_score": 0.00122, "epss_percentile": 0.3209}, "CVE-2005-0407": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2005-0408": {"epss_score": 0.0315, "epss_percentile": 0.86504}, "CVE-2005-0409": {"epss_score": 0.03516, "epss_percentile": 0.87275}, "CVE-2005-0410": {"epss_score": 0.00456, "epss_percentile": 0.63316}, "CVE-2005-0411": {"epss_score": 0.01321, "epss_percentile": 0.79443}, "CVE-2005-0412": {"epss_score": 0.01171, "epss_percentile": 0.78224}, "CVE-2005-0413": {"epss_score": 0.02129, "epss_percentile": 0.83707}, "CVE-2005-0414": {"epss_score": 0.00722, "epss_percentile": 0.71999}, "CVE-2005-0415": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2005-0416": {"epss_score": 0.56058, "epss_percentile": 0.98006}, "CVE-2005-0417": {"epss_score": 0.00553, "epss_percentile": 0.67415}, "CVE-2005-0418": {"epss_score": 0.00493, "epss_percentile": 0.65026}, "CVE-2005-0419": {"epss_score": 0.03865, "epss_percentile": 0.87871}, "CVE-2005-0420": {"epss_score": 0.74707, "epss_percentile": 0.98813}, "CVE-2005-0421": {"epss_score": 0.00146, "epss_percentile": 0.35605}, "CVE-2005-0422": {"epss_score": 0.00146, "epss_percentile": 0.35605}, "CVE-2005-0423": {"epss_score": 0.00364, "epss_percentile": 0.57946}, "CVE-2005-0424": {"epss_score": 0.00425, "epss_percentile": 0.61724}, "CVE-2005-0425": {"epss_score": 0.00352, "epss_percentile": 0.57091}, "CVE-2005-0426": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2005-0427": {"epss_score": 0.00331, "epss_percentile": 0.55544}, "CVE-2005-0428": {"epss_score": 9e-05, "epss_percentile": 0.00645}, "CVE-2005-0429": {"epss_score": 0.03395, "epss_percentile": 0.87057}, "CVE-2005-0430": {"epss_score": 0.01568, "epss_percentile": 0.81079}, "CVE-2005-0431": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2005-0432": {"epss_score": 0.00261, "epss_percentile": 0.49281}, "CVE-2005-0433": {"epss_score": 0.00032, "epss_percentile": 0.08814}, "CVE-2005-0434": {"epss_score": 0.00041, "epss_percentile": 0.12376}, "CVE-2005-0435": {"epss_score": 0.04264, "epss_percentile": 0.88467}, "CVE-2005-0436": {"epss_score": 0.04734, "epss_percentile": 0.89073}, "CVE-2005-0437": {"epss_score": 0.00597, "epss_percentile": 0.68754}, "CVE-2005-0438": {"epss_score": 0.08513, "epss_percentile": 0.92096}, "CVE-2005-0439": {"epss_score": 0.13506, "epss_percentile": 0.93984}, "CVE-2005-0440": {"epss_score": 0.00624, "epss_percentile": 0.69559}, "CVE-2005-0441": {"epss_score": 0.21283, "epss_percentile": 0.95493}, "CVE-2005-0442": {"epss_score": 0.08911, "epss_percentile": 0.92315}, "CVE-2005-0443": {"epss_score": 0.00509, "epss_percentile": 0.65727}, "CVE-2005-0444": {"epss_score": 0.00048, "epss_percentile": 0.15083}, "CVE-2005-0445": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-0446": {"epss_score": 0.65887, "epss_percentile": 0.98442}, "CVE-2005-0447": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2005-0448": {"epss_score": 0.00093, "epss_percentile": 0.26613}, "CVE-2005-0449": {"epss_score": 0.0227, "epss_percentile": 0.84208}, "CVE-2005-0450": {"epss_score": 0.00237, "epss_percentile": 0.46727}, "CVE-2005-0451": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-2005-0452": {"epss_score": 0.26611, "epss_percentile": 0.96161}, "CVE-2005-0453": {"epss_score": 0.00812, "epss_percentile": 0.7374}, "CVE-2005-0454": {"epss_score": 0.01233, "epss_percentile": 0.78751}, "CVE-2005-0455": {"epss_score": 0.75424, "epss_percentile": 0.98844}, "CVE-2005-0456": {"epss_score": 0.06168, "epss_percentile": 0.90529}, "CVE-2005-0457": {"epss_score": 0.0004, "epss_percentile": 0.12091}, "CVE-2005-0458": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-0459": {"epss_score": 0.00362, "epss_percentile": 0.5776}, "CVE-2005-0460": {"epss_score": 0.00501, "epss_percentile": 0.65356}, "CVE-2005-0461": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2005-0462": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-0463": {"epss_score": 0.00365, "epss_percentile": 0.58013}, "CVE-2005-0464": {"epss_score": 0.00337, "epss_percentile": 0.56059}, "CVE-2005-0465": {"epss_score": 0.00237, "epss_percentile": 0.46652}, "CVE-2005-0467": {"epss_score": 0.01973, "epss_percentile": 0.8311}, "CVE-2005-0468": {"epss_score": 0.58537, "epss_percentile": 0.98122}, "CVE-2005-0469": {"epss_score": 0.4782, "epss_percentile": 0.97603}, "CVE-2005-0470": {"epss_score": 0.01207, "epss_percentile": 0.7853}, "CVE-2005-0471": {"epss_score": 0.01395, "epss_percentile": 0.79975}, "CVE-2005-0472": {"epss_score": 0.08201, "epss_percentile": 0.91926}, "CVE-2005-0473": {"epss_score": 0.18522, "epss_percentile": 0.95027}, "CVE-2005-0474": {"epss_score": 0.00561, "epss_percentile": 0.67678}, "CVE-2005-0475": {"epss_score": 0.00276, "epss_percentile": 0.50755}, "CVE-2005-0476": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-0477": {"epss_score": 0.00548, "epss_percentile": 0.6729}, "CVE-2005-0478": {"epss_score": 0.65476, "epss_percentile": 0.98421}, "CVE-2005-0479": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2005-0480": {"epss_score": 0.0043, "epss_percentile": 0.62013}, "CVE-2005-0481": {"epss_score": 0.00501, "epss_percentile": 0.65356}, "CVE-2005-0482": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2005-0483": {"epss_score": 0.0069, "epss_percentile": 0.71259}, "CVE-2005-0484": {"epss_score": 0.02502, "epss_percentile": 0.84925}, "CVE-2005-0485": {"epss_score": 0.01088, "epss_percentile": 0.77436}, "CVE-2005-0486": {"epss_score": 0.00519, "epss_percentile": 0.66166}, "CVE-2005-0487": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2005-0488": {"epss_score": 0.10248, "epss_percentile": 0.92912}, "CVE-2005-0489": {"epss_score": 0.00079, "epss_percentile": 0.23855}, "CVE-2005-0490": {"epss_score": 0.02576, "epss_percentile": 0.85142}, "CVE-2005-0491": {"epss_score": 0.84329, "epss_percentile": 0.99285}, "CVE-2005-0492": {"epss_score": 0.01789, "epss_percentile": 0.82269}, "CVE-2005-0493": {"epss_score": 0.00219, "epss_percentile": 0.44501}, "CVE-2005-0494": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2005-0495": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-0496": {"epss_score": 0.02557, "epss_percentile": 0.85097}, "CVE-2005-0497": {"epss_score": 0.00289, "epss_percentile": 0.52009}, "CVE-2005-0498": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-2005-0499": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-0500": {"epss_score": 0.16735, "epss_percentile": 0.94724}, "CVE-2005-0501": {"epss_score": 0.049, "epss_percentile": 0.89273}, "CVE-2005-0502": {"epss_score": 0.01752, "epss_percentile": 0.82107}, "CVE-2005-0503": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2005-0504": {"epss_score": 0.00148, "epss_percentile": 0.3592}, "CVE-2005-0505": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-0506": {"epss_score": 0.03779, "epss_percentile": 0.87717}, "CVE-2005-0507": {"epss_score": 0.01138, "epss_percentile": 0.77935}, "CVE-2005-0508": {"epss_score": 0.00074, "epss_percentile": 0.2281}, "CVE-2005-0509": {"epss_score": 0.08187, "epss_percentile": 0.91919}, "CVE-2005-0510": {"epss_score": 0.00057, "epss_percentile": 0.18059}, "CVE-2005-0511": {"epss_score": 0.82213, "epss_percentile": 0.99179}, "CVE-2005-0512": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2005-0513": {"epss_score": 0.02238, "epss_percentile": 0.84107}, "CVE-2005-0514": {"epss_score": 0.01847, "epss_percentile": 0.82525}, "CVE-2005-0515": {"epss_score": 0.00069, "epss_percentile": 0.21558}, "CVE-2005-0516": {"epss_score": 0.02162, "epss_percentile": 0.83831}, "CVE-2005-0517": {"epss_score": 0.00175, "epss_percentile": 0.393}, "CVE-2005-0518": {"epss_score": 0.00184, "epss_percentile": 0.40427}, "CVE-2005-0519": {"epss_score": 0.01187, "epss_percentile": 0.78352}, "CVE-2005-0520": {"epss_score": 0.01475, "epss_percentile": 0.80524}, "CVE-2005-0521": {"epss_score": 0.00175, "epss_percentile": 0.393}, "CVE-2005-0522": {"epss_score": 0.00154, "epss_percentile": 0.36754}, "CVE-2005-0523": {"epss_score": 0.07202, "epss_percentile": 0.91318}, "CVE-2005-0524": {"epss_score": 0.04461, "epss_percentile": 0.88724}, "CVE-2005-0525": {"epss_score": 0.06043, "epss_percentile": 0.90429}, "CVE-2005-0526": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-0527": {"epss_score": 0.04687, "epss_percentile": 0.89008}, "CVE-2005-0529": {"epss_score": 0.00084, "epss_percentile": 0.24961}, "CVE-2005-0530": {"epss_score": 0.00068, "epss_percentile": 0.21205}, "CVE-2005-0531": {"epss_score": 0.0013, "epss_percentile": 0.33309}, "CVE-2005-0532": {"epss_score": 0.00067, "epss_percentile": 0.21059}, "CVE-2005-0533": {"epss_score": 0.06973, "epss_percentile": 0.91155}, "CVE-2005-0534": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2005-0535": {"epss_score": 0.00874, "epss_percentile": 0.74763}, "CVE-2005-0536": {"epss_score": 0.01065, "epss_percentile": 0.77204}, "CVE-2005-0537": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-0538": {"epss_score": 0.0036, "epss_percentile": 0.57679}, "CVE-2005-0539": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2005-0540": {"epss_score": 0.00438, "epss_percentile": 0.62564}, "CVE-2005-0541": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-0542": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2005-0543": {"epss_score": 0.02795, "epss_percentile": 0.8568}, "CVE-2005-0544": {"epss_score": 0.00501, "epss_percentile": 0.65356}, "CVE-2005-0545": {"epss_score": 0.00608, "epss_percentile": 0.69086}, "CVE-2005-0546": {"epss_score": 0.01818, "epss_percentile": 0.82401}, "CVE-2005-0547": {"epss_score": 0.00374, "epss_percentile": 0.58552}, "CVE-2005-0548": {"epss_score": 0.00442, "epss_percentile": 0.627}, "CVE-2005-0549": {"epss_score": 0.00442, "epss_percentile": 0.627}, "CVE-2005-0550": {"epss_score": 0.00917, "epss_percentile": 0.75433}, "CVE-2005-0551": {"epss_score": 0.34121, "epss_percentile": 0.96826}, "CVE-2005-0553": {"epss_score": 0.70074, "epss_percentile": 0.98613}, "CVE-2005-0554": {"epss_score": 0.71066, "epss_percentile": 0.98652}, "CVE-2005-0555": {"epss_score": 0.76059, "epss_percentile": 0.98875}, "CVE-2005-0558": {"epss_score": 0.26184, "epss_percentile": 0.9612}, "CVE-2005-0560": {"epss_score": 0.68274, "epss_percentile": 0.98539}, "CVE-2005-0562": {"epss_score": 0.28331, "epss_percentile": 0.96344}, "CVE-2005-0563": {"epss_score": 0.22959, "epss_percentile": 0.9571}, "CVE-2005-0564": {"epss_score": 0.33671, "epss_percentile": 0.96795}, "CVE-2005-0565": {"epss_score": 0.01288, "epss_percentile": 0.79202}, "CVE-2005-0566": {"epss_score": 0.32086, "epss_percentile": 0.96671}, "CVE-2005-0567": {"epss_score": 0.01218, "epss_percentile": 0.78601}, "CVE-2005-0568": {"epss_score": 0.05487, "epss_percentile": 0.89926}, "CVE-2005-0569": {"epss_score": 0.0223, "epss_percentile": 0.84084}, "CVE-2005-0570": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2005-0571": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-0572": {"epss_score": 0.00471, "epss_percentile": 0.64028}, "CVE-2005-0573": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-0574": {"epss_score": 0.00241, "epss_percentile": 0.47291}, "CVE-2005-0575": {"epss_score": 0.58802, "epss_percentile": 0.98137}, "CVE-2005-0576": {"epss_score": 0.00054, "epss_percentile": 0.17111}, "CVE-2005-0577": {"epss_score": 0.01699, "epss_percentile": 0.81824}, "CVE-2005-0578": {"epss_score": 0.00074, "epss_percentile": 0.22763}, "CVE-2005-0579": {"epss_score": 0.0011, "epss_percentile": 0.30148}, "CVE-2005-0580": {"epss_score": 0.00064, "epss_percentile": 0.20258}, "CVE-2005-0581": {"epss_score": 0.71664, "epss_percentile": 0.98676}, "CVE-2005-0582": {"epss_score": 0.19563, "epss_percentile": 0.9521}, "CVE-2005-0583": {"epss_score": 0.01851, "epss_percentile": 0.82538}, "CVE-2005-0584": {"epss_score": 0.00575, "epss_percentile": 0.681}, "CVE-2005-0585": {"epss_score": 0.01346, "epss_percentile": 0.79643}, "CVE-2005-0586": {"epss_score": 0.00689, "epss_percentile": 0.71215}, "CVE-2005-0587": {"epss_score": 0.01084, "epss_percentile": 0.774}, "CVE-2005-0588": {"epss_score": 0.01477, "epss_percentile": 0.80543}, "CVE-2005-0589": {"epss_score": 0.00647, "epss_percentile": 0.70189}, "CVE-2005-0590": {"epss_score": 0.01766, "epss_percentile": 0.82172}, "CVE-2005-0591": {"epss_score": 0.02392, "epss_percentile": 0.84604}, "CVE-2005-0592": {"epss_score": 0.03411, "epss_percentile": 0.87082}, "CVE-2005-0593": {"epss_score": 0.01252, "epss_percentile": 0.78899}, "CVE-2005-0594": {"epss_score": 0.00482, "epss_percentile": 0.64535}, "CVE-2005-0595": {"epss_score": 0.78362, "epss_percentile": 0.98983}, "CVE-2005-0596": {"epss_score": 0.00069, "epss_percentile": 0.2148}, "CVE-2005-0597": {"epss_score": 0.00402, "epss_percentile": 0.60296}, "CVE-2005-0598": {"epss_score": 0.03352, "epss_percentile": 0.86966}, "CVE-2005-0599": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2005-0600": {"epss_score": 0.009, "epss_percentile": 0.75165}, "CVE-2005-0601": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-0602": {"epss_score": 0.00115, "epss_percentile": 0.30986}, "CVE-2005-0603": {"epss_score": 0.0412, "epss_percentile": 0.88282}, "CVE-2005-0604": {"epss_score": 0.00069, "epss_percentile": 0.21466}, "CVE-2005-0605": {"epss_score": 0.02838, "epss_percentile": 0.85795}, "CVE-2005-0606": {"epss_score": 0.09075, "epss_percentile": 0.92388}, "CVE-2005-0607": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2005-0608": {"epss_score": 0.01345, "epss_percentile": 0.79626}, "CVE-2005-0610": {"epss_score": 0.00054, "epss_percentile": 0.17307}, "CVE-2005-0611": {"epss_score": 0.04751, "epss_percentile": 0.89103}, "CVE-2005-0612": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-0613": {"epss_score": 0.02788, "epss_percentile": 0.8566}, "CVE-2005-0614": {"epss_score": 0.05083, "epss_percentile": 0.89476}, "CVE-2005-0615": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-0616": {"epss_score": 0.00364, "epss_percentile": 0.57938}, "CVE-2005-0617": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-0618": {"epss_score": 0.00415, "epss_percentile": 0.61118}, "CVE-2005-0619": {"epss_score": 0.00357, "epss_percentile": 0.57401}, "CVE-2005-0620": {"epss_score": 0.00064, "epss_percentile": 0.20258}, "CVE-2005-0621": {"epss_score": 0.05166, "epss_percentile": 0.89566}, "CVE-2005-0622": {"epss_score": 0.00501, "epss_percentile": 0.65356}, "CVE-2005-0623": {"epss_score": 0.0321, "epss_percentile": 0.86652}, "CVE-2005-0624": {"epss_score": 0.00059, "epss_percentile": 0.18656}, "CVE-2005-0625": {"epss_score": 0.00082, "epss_percentile": 0.24499}, "CVE-2005-0626": {"epss_score": 0.00091, "epss_percentile": 0.26399}, "CVE-2005-0627": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2005-0628": {"epss_score": 0.00364, "epss_percentile": 0.57938}, "CVE-2005-0629": {"epss_score": 0.07555, "epss_percentile": 0.91538}, "CVE-2005-0630": {"epss_score": 0.00255, "epss_percentile": 0.48627}, "CVE-2005-0631": {"epss_score": 0.00284, "epss_percentile": 0.51463}, "CVE-2005-0632": {"epss_score": 0.03682, "epss_percentile": 0.87561}, "CVE-2005-0633": {"epss_score": 0.0988, "epss_percentile": 0.92751}, "CVE-2005-0634": {"epss_score": 0.10586, "epss_percentile": 0.93035}, "CVE-2005-0635": {"epss_score": 0.05741, "epss_percentile": 0.90169}, "CVE-2005-0636": {"epss_score": 0.05907, "epss_percentile": 0.90313}, "CVE-2005-0637": {"epss_score": 0.0054, "epss_percentile": 0.67001}, "CVE-2005-0638": {"epss_score": 0.02388, "epss_percentile": 0.84588}, "CVE-2005-0639": {"epss_score": 0.01955, "epss_percentile": 0.83036}, "CVE-2005-0640": {"epss_score": 0.00053, "epss_percentile": 0.16907}, "CVE-2005-0641": {"epss_score": 0.00281, "epss_percentile": 0.51106}, "CVE-2005-0642": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-0643": {"epss_score": 0.23203, "epss_percentile": 0.9575}, "CVE-2005-0644": {"epss_score": 0.23867, "epss_percentile": 0.95826}, "CVE-2005-0645": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-0646": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-0647": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2005-0648": {"epss_score": 0.00438, "epss_percentile": 0.62541}, "CVE-2005-0649": {"epss_score": 0.00438, "epss_percentile": 0.62541}, "CVE-2005-0650": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2005-0651": {"epss_score": 0.01355, "epss_percentile": 0.7971}, "CVE-2005-0652": {"epss_score": 0.0017, "epss_percentile": 0.38711}, "CVE-2005-0653": {"epss_score": 0.00156, "epss_percentile": 0.36936}, "CVE-2005-0654": {"epss_score": 0.00699, "epss_percentile": 0.71451}, "CVE-2005-0655": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2005-0656": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-0657": {"epss_score": 0.0061, "epss_percentile": 0.69144}, "CVE-2005-0658": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-0659": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2005-0660": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-0661": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-0662": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-0663": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-0664": {"epss_score": 0.03114, "epss_percentile": 0.86432}, "CVE-2005-0665": {"epss_score": 0.01738, "epss_percentile": 0.82021}, "CVE-2005-0666": {"epss_score": 0.00579, "epss_percentile": 0.68216}, "CVE-2005-0667": {"epss_score": 0.0334, "epss_percentile": 0.86942}, "CVE-2005-0668": {"epss_score": 0.00406, "epss_percentile": 0.60554}, "CVE-2005-0669": {"epss_score": 0.01233, "epss_percentile": 0.78751}, "CVE-2005-0670": {"epss_score": 0.01497, "epss_percentile": 0.80691}, "CVE-2005-0671": {"epss_score": 0.1282, "epss_percentile": 0.93785}, "CVE-2005-0672": {"epss_score": 0.02961, "epss_percentile": 0.86072}, "CVE-2005-0673": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-0674": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2005-0675": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-0676": {"epss_score": 0.00763, "epss_percentile": 0.72859}, "CVE-2005-0677": {"epss_score": 0.00397, "epss_percentile": 0.60037}, "CVE-2005-0678": {"epss_score": 0.02091, "epss_percentile": 0.83571}, "CVE-2005-0679": {"epss_score": 0.01494, "epss_percentile": 0.8065}, "CVE-2005-0680": {"epss_score": 0.02788, "epss_percentile": 0.85661}, "CVE-2005-0681": {"epss_score": 0.03517, "epss_percentile": 0.87279}, "CVE-2005-0682": {"epss_score": 0.00364, "epss_percentile": 0.57938}, "CVE-2005-0684": {"epss_score": 0.71813, "epss_percentile": 0.98682}, "CVE-2005-0685": {"epss_score": 0.01267, "epss_percentile": 0.79017}, "CVE-2005-0686": {"epss_score": 0.01584, "epss_percentile": 0.8116}, "CVE-2005-0687": {"epss_score": 0.02051, "epss_percentile": 0.83407}, "CVE-2005-0688": {"epss_score": 0.80794, "epss_percentile": 0.99106}, "CVE-2005-0689": {"epss_score": 0.07747, "epss_percentile": 0.91657}, "CVE-2005-0690": {"epss_score": 0.00086, "epss_percentile": 0.2535}, "CVE-2005-0691": {"epss_score": 0.01347, "epss_percentile": 0.7965}, "CVE-2005-0692": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-0693": {"epss_score": 0.02374, "epss_percentile": 0.84537}, "CVE-2005-0694": {"epss_score": 0.00443, "epss_percentile": 0.62772}, "CVE-2005-0695": {"epss_score": 0.00424, "epss_percentile": 0.61683}, "CVE-2005-0696": {"epss_score": 0.07218, "epss_percentile": 0.91332}, "CVE-2005-0697": {"epss_score": 0.00375, "epss_percentile": 0.58631}, "CVE-2005-0698": {"epss_score": 0.0083, "epss_percentile": 0.74017}, "CVE-2005-0699": {"epss_score": 0.04233, "epss_percentile": 0.88426}, "CVE-2005-0700": {"epss_score": 0.02672, "epss_percentile": 0.85393}, "CVE-2005-0701": {"epss_score": 0.2878, "epss_percentile": 0.96384}, "CVE-2005-0702": {"epss_score": 0.00264, "epss_percentile": 0.49678}, "CVE-2005-0703": {"epss_score": 0.00281, "epss_percentile": 0.51106}, "CVE-2005-0704": {"epss_score": 0.02231, "epss_percentile": 0.84088}, "CVE-2005-0705": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2005-0706": {"epss_score": 0.01826, "epss_percentile": 0.82434}, "CVE-2005-0707": {"epss_score": 0.06111, "epss_percentile": 0.90487}, "CVE-2005-0708": {"epss_score": 0.01229, "epss_percentile": 0.78717}, "CVE-2005-0709": {"epss_score": 0.33889, "epss_percentile": 0.96812}, "CVE-2005-0710": {"epss_score": 0.2422, "epss_percentile": 0.95889}, "CVE-2005-0711": {"epss_score": 0.00349, "epss_percentile": 0.56877}, "CVE-2005-0712": {"epss_score": 0.00044, "epss_percentile": 0.13646}, "CVE-2005-0713": {"epss_score": 0.00154, "epss_percentile": 0.36754}, "CVE-2005-0715": {"epss_score": 0.00048, "epss_percentile": 0.15236}, "CVE-2005-0716": {"epss_score": 0.00198, "epss_percentile": 0.42051}, "CVE-2005-0718": {"epss_score": 0.12597, "epss_percentile": 0.93724}, "CVE-2005-0719": {"epss_score": 0.00091, "epss_percentile": 0.26255}, "CVE-2005-0720": {"epss_score": 0.02205, "epss_percentile": 0.84}, "CVE-2005-0721": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2005-0722": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2005-0723": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-0724": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-0725": {"epss_score": 0.0033, "epss_percentile": 0.55493}, "CVE-2005-0726": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-0729": {"epss_score": 0.02961, "epss_percentile": 0.86072}, "CVE-2005-0730": {"epss_score": 0.00981, "epss_percentile": 0.76279}, "CVE-2005-0731": {"epss_score": 0.05875, "epss_percentile": 0.90285}, "CVE-2005-0732": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2005-0733": {"epss_score": 0.00421, "epss_percentile": 0.61534}, "CVE-2005-0734": {"epss_score": 0.00818, "epss_percentile": 0.73856}, "CVE-2005-0735": {"epss_score": 0.02856, "epss_percentile": 0.85841}, "CVE-2005-0736": {"epss_score": 0.00049, "epss_percentile": 0.15432}, "CVE-2005-0737": {"epss_score": 0.04788, "epss_percentile": 0.89145}, "CVE-2005-0738": {"epss_score": 0.10483, "epss_percentile": 0.93003}, "CVE-2005-0739": {"epss_score": 0.17024, "epss_percentile": 0.94762}, "CVE-2005-0740": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2005-0741": {"epss_score": 0.00486, "epss_percentile": 0.64762}, "CVE-2005-0742": {"epss_score": 0.00333, "epss_percentile": 0.55657}, "CVE-2005-0743": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2005-0744": {"epss_score": 0.00378, "epss_percentile": 0.5883}, "CVE-2005-0745": {"epss_score": 0.00053, "epss_percentile": 0.16907}, "CVE-2005-0746": {"epss_score": 0.00374, "epss_percentile": 0.58545}, "CVE-2005-0747": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-0748": {"epss_score": 0.01339, "epss_percentile": 0.7957}, "CVE-2005-0749": {"epss_score": 0.00043, "epss_percentile": 0.13102}, "CVE-2005-0750": {"epss_score": 0.00167, "epss_percentile": 0.38348}, "CVE-2005-0752": {"epss_score": 0.03515, "epss_percentile": 0.87272}, "CVE-2005-0753": {"epss_score": 0.05354, "epss_percentile": 0.89777}, "CVE-2005-0754": {"epss_score": 0.02281, "epss_percentile": 0.84253}, "CVE-2005-0755": {"epss_score": 0.08417, "epss_percentile": 0.9204}, "CVE-2005-0756": {"epss_score": 0.00064, "epss_percentile": 0.20425}, "CVE-2005-0757": {"epss_score": 0.00063, "epss_percentile": 0.20082}, "CVE-2005-0758": {"epss_score": 0.0015, "epss_percentile": 0.36077}, "CVE-2005-0759": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2005-0760": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2005-0761": {"epss_score": 0.01075, "epss_percentile": 0.77311}, "CVE-2005-0762": {"epss_score": 0.03055, "epss_percentile": 0.86299}, "CVE-2005-0763": {"epss_score": 0.00102, "epss_percentile": 0.28822}, "CVE-2005-0764": {"epss_score": 0.0328, "epss_percentile": 0.86815}, "CVE-2005-0765": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2005-0766": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2005-0767": {"epss_score": 0.00054, "epss_percentile": 0.17101}, "CVE-2005-0768": {"epss_score": 0.75364, "epss_percentile": 0.9884}, "CVE-2005-0769": {"epss_score": 0.03908, "epss_percentile": 0.8793}, "CVE-2005-0770": {"epss_score": 0.02644, "epss_percentile": 0.85318}, "CVE-2005-0771": {"epss_score": 0.81368, "epss_percentile": 0.99134}, "CVE-2005-0772": {"epss_score": 0.1127, "epss_percentile": 0.93287}, "CVE-2005-0773": {"epss_score": 0.75181, "epss_percentile": 0.98832}, "CVE-2005-0774": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-0775": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2005-0776": {"epss_score": 0.0371, "epss_percentile": 0.87603}, "CVE-2005-0777": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-0778": {"epss_score": 0.00392, "epss_percentile": 0.59666}, "CVE-2005-0779": {"epss_score": 0.04891, "epss_percentile": 0.89263}, "CVE-2005-0780": {"epss_score": 0.03624, "epss_percentile": 0.87453}, "CVE-2005-0781": {"epss_score": 0.00321, "epss_percentile": 0.54693}, "CVE-2005-0782": {"epss_score": 0.04264, "epss_percentile": 0.88468}, "CVE-2005-0783": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2005-0784": {"epss_score": 0.00483, "epss_percentile": 0.64559}, "CVE-2005-0785": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-0786": {"epss_score": 0.01042, "epss_percentile": 0.76978}, "CVE-2005-0787": {"epss_score": 0.00074, "epss_percentile": 0.22812}, "CVE-2005-0788": {"epss_score": 0.06466, "epss_percentile": 0.90774}, "CVE-2005-0789": {"epss_score": 0.02791, "epss_percentile": 0.85667}, "CVE-2005-0790": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2005-0791": {"epss_score": 0.04822, "epss_percentile": 0.89179}, "CVE-2005-0792": {"epss_score": 0.00446, "epss_percentile": 0.62924}, "CVE-2005-0793": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-0794": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-0795": {"epss_score": 0.04826, "epss_percentile": 0.89185}, "CVE-2005-0796": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2005-0797": {"epss_score": 0.00517, "epss_percentile": 0.66091}, "CVE-2005-0798": {"epss_score": 0.02131, "epss_percentile": 0.83712}, "CVE-2005-0799": {"epss_score": 0.02118, "epss_percentile": 0.83669}, "CVE-2005-0800": {"epss_score": 0.019, "epss_percentile": 0.82773}, "CVE-2005-0801": {"epss_score": 0.0021, "epss_percentile": 0.43432}, "CVE-2005-0802": {"epss_score": 0.00809, "epss_percentile": 0.7371}, "CVE-2005-0803": {"epss_score": 0.78075, "epss_percentile": 0.98968}, "CVE-2005-0804": {"epss_score": 0.0447, "epss_percentile": 0.88733}, "CVE-2005-0805": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2005-0806": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2005-0807": {"epss_score": 0.03243, "epss_percentile": 0.86738}, "CVE-2005-0808": {"epss_score": 0.17541, "epss_percentile": 0.94863}, "CVE-2005-0809": {"epss_score": 0.01171, "epss_percentile": 0.78216}, "CVE-2005-0810": {"epss_score": 0.01591, "epss_percentile": 0.81221}, "CVE-2005-0811": {"epss_score": 0.00164, "epss_percentile": 0.37937}, "CVE-2005-0812": {"epss_score": 0.02004, "epss_percentile": 0.83227}, "CVE-2005-0813": {"epss_score": 0.00768, "epss_percentile": 0.72978}, "CVE-2005-0814": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2005-0815": {"epss_score": 0.09342, "epss_percentile": 0.92509}, "CVE-2005-0816": {"epss_score": 0.0005, "epss_percentile": 0.15721}, "CVE-2005-0817": {"epss_score": 0.00742, "epss_percentile": 0.72459}, "CVE-2005-0818": {"epss_score": 0.00457, "epss_percentile": 0.63393}, "CVE-2005-0819": {"epss_score": 0.00446, "epss_percentile": 0.62919}, "CVE-2005-0820": {"epss_score": 0.00408, "epss_percentile": 0.60654}, "CVE-2005-0821": {"epss_score": 0.00438, "epss_percentile": 0.62543}, "CVE-2005-0822": {"epss_score": 0.00105, "epss_percentile": 0.29323}, "CVE-2005-0823": {"epss_score": 0.00209, "epss_percentile": 0.43375}, "CVE-2005-0824": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2005-0825": {"epss_score": 0.01197, "epss_percentile": 0.78444}, "CVE-2005-0826": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2005-0827": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-0828": {"epss_score": 0.05459, "epss_percentile": 0.899}, "CVE-2005-0829": {"epss_score": 0.00442, "epss_percentile": 0.627}, "CVE-2005-0830": {"epss_score": 0.0321, "epss_percentile": 0.86652}, "CVE-2005-0831": {"epss_score": 0.00397, "epss_percentile": 0.60037}, "CVE-2005-0832": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-0833": {"epss_score": 0.00757, "epss_percentile": 0.72753}, "CVE-2005-0834": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-0835": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-0836": {"epss_score": 0.02371, "epss_percentile": 0.84526}, "CVE-2005-0837": {"epss_score": 0.00528, "epss_percentile": 0.66538}, "CVE-2005-0838": {"epss_score": 0.04168, "epss_percentile": 0.88344}, "CVE-2005-0839": {"epss_score": 0.00052, "epss_percentile": 0.16396}, "CVE-2005-0841": {"epss_score": 0.00708, "epss_percentile": 0.71665}, "CVE-2005-0842": {"epss_score": 0.00547, "epss_percentile": 0.67232}, "CVE-2005-0843": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2005-0844": {"epss_score": 0.00108, "epss_percentile": 0.29825}, "CVE-2005-0845": {"epss_score": 0.01656, "epss_percentile": 0.81597}, "CVE-2005-0846": {"epss_score": 0.00422, "epss_percentile": 0.61545}, "CVE-2005-0847": {"epss_score": 0.06807, "epss_percentile": 0.91039}, "CVE-2005-0848": {"epss_score": 0.06022, "epss_percentile": 0.90417}, "CVE-2005-0849": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2005-0850": {"epss_score": 0.00094, "epss_percentile": 0.27062}, "CVE-2005-0851": {"epss_score": 0.00069, "epss_percentile": 0.21633}, "CVE-2005-0852": {"epss_score": 0.00163, "epss_percentile": 0.37793}, "CVE-2005-0853": {"epss_score": 0.13242, "epss_percentile": 0.93911}, "CVE-2005-0854": {"epss_score": 0.03618, "epss_percentile": 0.87439}, "CVE-2005-0855": {"epss_score": 0.01214, "epss_percentile": 0.78579}, "CVE-2005-0856": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2005-0857": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2005-0858": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2005-0859": {"epss_score": 0.17156, "epss_percentile": 0.94786}, "CVE-2005-0860": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2005-0861": {"epss_score": 0.00722, "epss_percentile": 0.72003}, "CVE-2005-0862": {"epss_score": 0.14271, "epss_percentile": 0.94177}, "CVE-2005-0863": {"epss_score": 0.00458, "epss_percentile": 0.63449}, "CVE-2005-0864": {"epss_score": 0.00443, "epss_percentile": 0.62772}, "CVE-2005-0865": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2005-0866": {"epss_score": 0.00063, "epss_percentile": 0.19925}, "CVE-2005-0867": {"epss_score": 0.0016, "epss_percentile": 0.37486}, "CVE-2005-0868": {"epss_score": 0.00973, "epss_percentile": 0.76164}, "CVE-2005-0869": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-0870": {"epss_score": 0.11707, "epss_percentile": 0.93457}, "CVE-2005-0871": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2005-0872": {"epss_score": 0.01856, "epss_percentile": 0.82569}, "CVE-2005-0873": {"epss_score": 0.67385, "epss_percentile": 0.98505}, "CVE-2005-0874": {"epss_score": 0.00506, "epss_percentile": 0.65617}, "CVE-2005-0875": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-0876": {"epss_score": 0.0222, "epss_percentile": 0.84049}, "CVE-2005-0877": {"epss_score": 0.00053, "epss_percentile": 0.1703}, "CVE-2005-0878": {"epss_score": 0.00364, "epss_percentile": 0.57938}, "CVE-2005-0879": {"epss_score": 0.08314, "epss_percentile": 0.91988}, "CVE-2005-0880": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-0881": {"epss_score": 0.00888, "epss_percentile": 0.75}, "CVE-2005-0882": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-0883": {"epss_score": 0.00445, "epss_percentile": 0.62865}, "CVE-2005-0884": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-0885": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-0886": {"epss_score": 0.00462, "epss_percentile": 0.63573}, "CVE-2005-0887": {"epss_score": 0.07111, "epss_percentile": 0.91258}, "CVE-2005-0888": {"epss_score": 0.00634, "epss_percentile": 0.69801}, "CVE-2005-0889": {"epss_score": 0.00368, "epss_percentile": 0.58174}, "CVE-2005-0890": {"epss_score": 0.0028, "epss_percentile": 0.50999}, "CVE-2005-0891": {"epss_score": 0.02026, "epss_percentile": 0.83317}, "CVE-2005-0892": {"epss_score": 0.03992, "epss_percentile": 0.88071}, "CVE-2005-0893": {"epss_score": 0.00631, "epss_percentile": 0.69717}, "CVE-2005-0894": {"epss_score": 0.00146, "epss_percentile": 0.356}, "CVE-2005-0895": {"epss_score": 0.04014, "epss_percentile": 0.8812}, "CVE-2005-0896": {"epss_score": 0.00406, "epss_percentile": 0.60555}, "CVE-2005-0897": {"epss_score": 0.01299, "epss_percentile": 0.79282}, "CVE-2005-0898": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-0899": {"epss_score": 0.00094, "epss_percentile": 0.26979}, "CVE-2005-0900": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-0901": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-0902": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-0903": {"epss_score": 0.03339, "epss_percentile": 0.8694}, "CVE-2005-0904": {"epss_score": 0.01006, "epss_percentile": 0.76546}, "CVE-2005-0905": {"epss_score": 0.07421, "epss_percentile": 0.91466}, "CVE-2005-0906": {"epss_score": 0.07073, "epss_percentile": 0.91231}, "CVE-2005-0907": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2005-0908": {"epss_score": 0.00331, "epss_percentile": 0.55548}, "CVE-2005-0909": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-0910": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-0911": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-0912": {"epss_score": 0.00406, "epss_percentile": 0.60554}, "CVE-2005-0913": {"epss_score": 0.00902, "epss_percentile": 0.75194}, "CVE-2005-0914": {"epss_score": 0.00281, "epss_percentile": 0.51106}, "CVE-2005-0915": {"epss_score": 0.00455, "epss_percentile": 0.63307}, "CVE-2005-0916": {"epss_score": 0.00146, "epss_percentile": 0.35598}, "CVE-2005-0917": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2005-0918": {"epss_score": 0.01645, "epss_percentile": 0.81529}, "CVE-2005-0919": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2005-0920": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-0921": {"epss_score": 0.00354, "epss_percentile": 0.57229}, "CVE-2005-0922": {"epss_score": 0.02307, "epss_percentile": 0.84326}, "CVE-2005-0923": {"epss_score": 0.00201, "epss_percentile": 0.42279}, "CVE-2005-0924": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2005-0925": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2005-0926": {"epss_score": 0.01711, "epss_percentile": 0.81879}, "CVE-2005-0927": {"epss_score": 0.00544, "epss_percentile": 0.6715}, "CVE-2005-0928": {"epss_score": 0.03724, "epss_percentile": 0.8763}, "CVE-2005-0929": {"epss_score": 0.02338, "epss_percentile": 0.84425}, "CVE-2005-0930": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-0931": {"epss_score": 0.01718, "epss_percentile": 0.81921}, "CVE-2005-0932": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2005-0933": {"epss_score": 0.00248, "epss_percentile": 0.47916}, "CVE-2005-0934": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-0935": {"epss_score": 0.0153, "epss_percentile": 0.80885}, "CVE-2005-0936": {"epss_score": 0.07826, "epss_percentile": 0.91701}, "CVE-2005-0937": {"epss_score": 0.00063, "epss_percentile": 0.19964}, "CVE-2005-0938": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2005-0941": {"epss_score": 0.02726, "epss_percentile": 0.85528}, "CVE-2005-0942": {"epss_score": 0.01415, "epss_percentile": 0.80137}, "CVE-2005-0943": {"epss_score": 0.00743, "epss_percentile": 0.72495}, "CVE-2005-0944": {"epss_score": 0.43935, "epss_percentile": 0.97409}, "CVE-2005-0945": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-0946": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-0947": {"epss_score": 0.00493, "epss_percentile": 0.65039}, "CVE-2005-0948": {"epss_score": 0.01729, "epss_percentile": 0.81977}, "CVE-2005-0949": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2005-0950": {"epss_score": 0.07772, "epss_percentile": 0.91674}, "CVE-2005-0952": {"epss_score": 0.04471, "epss_percentile": 0.88734}, "CVE-2005-0953": {"epss_score": 0.00094, "epss_percentile": 0.26974}, "CVE-2005-0954": {"epss_score": 0.24352, "epss_percentile": 0.95908}, "CVE-2005-0955": {"epss_score": 0.0059, "epss_percentile": 0.68567}, "CVE-2005-0956": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-0957": {"epss_score": 0.00624, "epss_percentile": 0.69559}, "CVE-2005-0958": {"epss_score": 0.05656, "epss_percentile": 0.90092}, "CVE-2005-0959": {"epss_score": 0.03966, "epss_percentile": 0.8803}, "CVE-2005-0960": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2005-0961": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-0962": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2005-0963": {"epss_score": 0.00076, "epss_percentile": 0.23127}, "CVE-2005-0964": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2005-0965": {"epss_score": 0.01928, "epss_percentile": 0.82932}, "CVE-2005-0966": {"epss_score": 0.02929, "epss_percentile": 0.86014}, "CVE-2005-0967": {"epss_score": 0.03605, "epss_percentile": 0.87415}, "CVE-2005-0968": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-0969": {"epss_score": 0.00069, "epss_percentile": 0.21457}, "CVE-2005-0970": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2005-0971": {"epss_score": 0.00079, "epss_percentile": 0.23959}, "CVE-2005-0972": {"epss_score": 0.00306, "epss_percentile": 0.53403}, "CVE-2005-0973": {"epss_score": 0.00058, "epss_percentile": 0.18446}, "CVE-2005-0974": {"epss_score": 0.00055, "epss_percentile": 0.17568}, "CVE-2005-0975": {"epss_score": 0.00099, "epss_percentile": 0.28314}, "CVE-2005-0976": {"epss_score": 0.00362, "epss_percentile": 0.5776}, "CVE-2005-0977": {"epss_score": 0.0007, "epss_percentile": 0.21714}, "CVE-2005-0978": {"epss_score": 0.04002, "epss_percentile": 0.88094}, "CVE-2005-0979": {"epss_score": 0.18453, "epss_percentile": 0.95018}, "CVE-2005-0980": {"epss_score": 0.00987, "epss_percentile": 0.76346}, "CVE-2005-0981": {"epss_score": 0.02914, "epss_percentile": 0.85977}, "CVE-2005-0982": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-0983": {"epss_score": 0.0134, "epss_percentile": 0.79576}, "CVE-2005-0984": {"epss_score": 0.1003, "epss_percentile": 0.92821}, "CVE-2005-0985": {"epss_score": 0.0006, "epss_percentile": 0.1923}, "CVE-2005-0986": {"epss_score": 0.17706, "epss_percentile": 0.94894}, "CVE-2005-0987": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-0988": {"epss_score": 0.00115, "epss_percentile": 0.30954}, "CVE-2005-0989": {"epss_score": 0.25295, "epss_percentile": 0.9601}, "CVE-2005-0990": {"epss_score": 0.00103, "epss_percentile": 0.29064}, "CVE-2005-0991": {"epss_score": 0.00063, "epss_percentile": 0.19921}, "CVE-2005-0992": {"epss_score": 0.10163, "epss_percentile": 0.9287}, "CVE-2005-0993": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2005-0994": {"epss_score": 0.0146, "epss_percentile": 0.80421}, "CVE-2005-0995": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2005-0996": {"epss_score": 0.00013, "epss_percentile": 0.01489}, "CVE-2005-0997": {"epss_score": 0.00018, "epss_percentile": 0.04012}, "CVE-2005-0998": {"epss_score": 0.00014, "epss_percentile": 0.02084}, "CVE-2005-0999": {"epss_score": 0.00019, "epss_percentile": 0.04092}, "CVE-2005-10001": {"epss_score": 0.00166, "epss_percentile": 0.38224}, "CVE-2005-10002": {"epss_score": 0.00202, "epss_percentile": 0.42468}, "CVE-2005-10003": {"epss_score": 0.00497, "epss_percentile": 0.65194}, "CVE-2005-10004": {"epss_score": 0.59269, "epss_percentile": 0.98157}, "CVE-2005-1000": {"epss_score": 0.0002, "epss_percentile": 0.04551}, "CVE-2005-1001": {"epss_score": 0.00019, "epss_percentile": 0.04174}, "CVE-2005-1002": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2005-1003": {"epss_score": 0.00235, "epss_percentile": 0.46335}, "CVE-2005-1004": {"epss_score": 0.0232, "epss_percentile": 0.84365}, "CVE-2005-1005": {"epss_score": 0.04202, "epss_percentile": 0.88388}, "CVE-2005-1006": {"epss_score": 0.01596, "epss_percentile": 0.8124}, "CVE-2005-1007": {"epss_score": 0.00345, "epss_percentile": 0.56567}, "CVE-2005-1008": {"epss_score": 0.00533, "epss_percentile": 0.66759}, "CVE-2005-1009": {"epss_score": 0.83516, "epss_percentile": 0.99251}, "CVE-2005-1010": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-1011": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2005-1012": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2005-1013": {"epss_score": 0.27159, "epss_percentile": 0.96213}, "CVE-2005-1014": {"epss_score": 0.172, "epss_percentile": 0.94799}, "CVE-2005-1015": {"epss_score": 0.01803, "epss_percentile": 0.82335}, "CVE-2005-1016": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-1017": {"epss_score": 0.00876, "epss_percentile": 0.74795}, "CVE-2005-1018": {"epss_score": 0.71743, "epss_percentile": 0.98678}, "CVE-2005-1019": {"epss_score": 0.0012, "epss_percentile": 0.31798}, "CVE-2005-1020": {"epss_score": 0.0158, "epss_percentile": 0.81135}, "CVE-2005-1021": {"epss_score": 0.01402, "epss_percentile": 0.80011}, "CVE-2005-1022": {"epss_score": 0.00232, "epss_percentile": 0.45875}, "CVE-2005-1023": {"epss_score": 0.00119, "epss_percentile": 0.31678}, "CVE-2005-1024": {"epss_score": 0.00053, "epss_percentile": 0.16731}, "CVE-2005-1025": {"epss_score": 0.00415, "epss_percentile": 0.61139}, "CVE-2005-1026": {"epss_score": 0.00517, "epss_percentile": 0.66087}, "CVE-2005-1027": {"epss_score": 0.00042, "epss_percentile": 0.12744}, "CVE-2005-1028": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-1029": {"epss_score": 0.04483, "epss_percentile": 0.88745}, "CVE-2005-1030": {"epss_score": 0.02181, "epss_percentile": 0.83901}, "CVE-2005-1031": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-1033": {"epss_score": 0.03745, "epss_percentile": 0.87661}, "CVE-2005-1034": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2005-1035": {"epss_score": 0.00438, "epss_percentile": 0.62573}, "CVE-2005-1036": {"epss_score": 0.00088, "epss_percentile": 0.25715}, "CVE-2005-1037": {"epss_score": 0.01333, "epss_percentile": 0.79531}, "CVE-2005-1038": {"epss_score": 0.00076, "epss_percentile": 0.231}, "CVE-2005-1039": {"epss_score": 0.00044, "epss_percentile": 0.13646}, "CVE-2005-1040": {"epss_score": 0.00035, "epss_percentile": 0.09884}, "CVE-2005-1041": {"epss_score": 0.0007, "epss_percentile": 0.21714}, "CVE-2005-1042": {"epss_score": 0.06096, "epss_percentile": 0.90477}, "CVE-2005-1043": {"epss_score": 0.01109, "epss_percentile": 0.77652}, "CVE-2005-1045": {"epss_score": 0.01079, "epss_percentile": 0.77356}, "CVE-2005-1046": {"epss_score": 0.07097, "epss_percentile": 0.91247}, "CVE-2005-1047": {"epss_score": 0.00982, "epss_percentile": 0.76295}, "CVE-2005-1048": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-1049": {"epss_score": 0.13244, "epss_percentile": 0.93912}, "CVE-2005-1050": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2005-1051": {"epss_score": 0.01046, "epss_percentile": 0.77028}, "CVE-2005-1052": {"epss_score": 0.07154, "epss_percentile": 0.91289}, "CVE-2005-1053": {"epss_score": 0.012, "epss_percentile": 0.78466}, "CVE-2005-1054": {"epss_score": 0.02408, "epss_percentile": 0.84657}, "CVE-2005-1055": {"epss_score": 0.01075, "epss_percentile": 0.77308}, "CVE-2005-1056": {"epss_score": 0.01289, "epss_percentile": 0.79207}, "CVE-2005-1057": {"epss_score": 0.00572, "epss_percentile": 0.6803}, "CVE-2005-1058": {"epss_score": 0.00572, "epss_percentile": 0.6803}, "CVE-2005-1059": {"epss_score": 0.00756, "epss_percentile": 0.7273}, "CVE-2005-1060": {"epss_score": 0.00456, "epss_percentile": 0.63332}, "CVE-2005-1061": {"epss_score": 0.03898, "epss_percentile": 0.87919}, "CVE-2005-1062": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-1063": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2005-1064": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2005-1065": {"epss_score": 0.00037, "epss_percentile": 0.10765}, "CVE-2005-1066": {"epss_score": 0.00084, "epss_percentile": 0.25015}, "CVE-2005-1067": {"epss_score": 0.00469, "epss_percentile": 0.63915}, "CVE-2005-1068": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-1069": {"epss_score": 0.00366, "epss_percentile": 0.58087}, "CVE-2005-1070": {"epss_score": 0.00396, "epss_percentile": 0.59882}, "CVE-2005-1071": {"epss_score": 0.00568, "epss_percentile": 0.67906}, "CVE-2005-1072": {"epss_score": 0.00281, "epss_percentile": 0.51106}, "CVE-2005-1073": {"epss_score": 0.06194, "epss_percentile": 0.90556}, "CVE-2005-1074": {"epss_score": 0.00553, "epss_percentile": 0.6742}, "CVE-2005-1075": {"epss_score": 0.00946, "epss_percentile": 0.75811}, "CVE-2005-1076": {"epss_score": 0.00412, "epss_percentile": 0.60926}, "CVE-2005-1077": {"epss_score": 0.03315, "epss_percentile": 0.86899}, "CVE-2005-1078": {"epss_score": 0.03465, "epss_percentile": 0.87188}, "CVE-2005-1079": {"epss_score": 0.00404, "epss_percentile": 0.60448}, "CVE-2005-1080": {"epss_score": 0.04135, "epss_percentile": 0.88306}, "CVE-2005-1081": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2005-1082": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2005-1083": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2005-1084": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-1085": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1086": {"epss_score": 0.07164, "epss_percentile": 0.91294}, "CVE-2005-1087": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2005-1088": {"epss_score": 0.00047, "epss_percentile": 0.14792}, "CVE-2005-1089": {"epss_score": 0.00384, "epss_percentile": 0.59124}, "CVE-2005-1090": {"epss_score": 0.01222, "epss_percentile": 0.78655}, "CVE-2005-1091": {"epss_score": 0.00428, "epss_percentile": 0.61953}, "CVE-2005-1092": {"epss_score": 0.00133, "epss_percentile": 0.33633}, "CVE-2005-1093": {"epss_score": 0.06287, "epss_percentile": 0.90645}, "CVE-2005-1094": {"epss_score": 0.0015, "epss_percentile": 0.36144}, "CVE-2005-1095": {"epss_score": 0.01121, "epss_percentile": 0.77771}, "CVE-2005-1096": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2005-1097": {"epss_score": 0.00154, "epss_percentile": 0.36754}, "CVE-2005-1098": {"epss_score": 0.00501, "epss_percentile": 0.65356}, "CVE-2005-1099": {"epss_score": 0.79026, "epss_percentile": 0.99016}, "CVE-2005-1100": {"epss_score": 0.19032, "epss_percentile": 0.95116}, "CVE-2005-1101": {"epss_score": 0.0411, "epss_percentile": 0.88271}, "CVE-2005-1102": {"epss_score": 0.01444, "epss_percentile": 0.80315}, "CVE-2005-1103": {"epss_score": 0.00059, "epss_percentile": 0.18671}, "CVE-2005-1104": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1105": {"epss_score": 0.03291, "epss_percentile": 0.86838}, "CVE-2005-1106": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-1107": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2005-1108": {"epss_score": 0.00993, "epss_percentile": 0.76401}, "CVE-2005-1109": {"epss_score": 0.03286, "epss_percentile": 0.86828}, "CVE-2005-1110": {"epss_score": 0.05161, "epss_percentile": 0.89559}, "CVE-2005-1111": {"epss_score": 0.00075, "epss_percentile": 0.22899}, "CVE-2005-1112": {"epss_score": 0.12153, "epss_percentile": 0.93585}, "CVE-2005-1113": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1114": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2005-1115": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-1116": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1117": {"epss_score": 0.01449, "epss_percentile": 0.80341}, "CVE-2005-1118": {"epss_score": 0.02308, "epss_percentile": 0.84329}, "CVE-2005-1119": {"epss_score": 0.00063, "epss_percentile": 0.19925}, "CVE-2005-1120": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-1121": {"epss_score": 0.01029, "epss_percentile": 0.76827}, "CVE-2005-1122": {"epss_score": 0.01881, "epss_percentile": 0.82693}, "CVE-2005-1123": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2005-1124": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2005-1125": {"epss_score": 0.0892, "epss_percentile": 0.9232}, "CVE-2005-1126": {"epss_score": 0.0007, "epss_percentile": 0.21698}, "CVE-2005-1127": {"epss_score": 0.05753, "epss_percentile": 0.90178}, "CVE-2005-1128": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-1129": {"epss_score": 0.00093, "epss_percentile": 0.26607}, "CVE-2005-1130": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2005-1131": {"epss_score": 0.00671, "epss_percentile": 0.70799}, "CVE-2005-1132": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2005-1133": {"epss_score": 0.00311, "epss_percentile": 0.53923}, "CVE-2005-1134": {"epss_score": 0.0297, "epss_percentile": 0.86093}, "CVE-2005-1135": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2005-1136": {"epss_score": 0.00443, "epss_percentile": 0.62772}, "CVE-2005-1137": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2005-1138": {"epss_score": 0.00503, "epss_percentile": 0.65439}, "CVE-2005-1139": {"epss_score": 0.00445, "epss_percentile": 0.62865}, "CVE-2005-1140": {"epss_score": 0.00331, "epss_percentile": 0.55548}, "CVE-2005-1141": {"epss_score": 0.14342, "epss_percentile": 0.94192}, "CVE-2005-1142": {"epss_score": 0.04226, "epss_percentile": 0.88417}, "CVE-2005-1143": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2005-1144": {"epss_score": 0.00457, "epss_percentile": 0.63389}, "CVE-2005-1145": {"epss_score": 0.00523, "epss_percentile": 0.66313}, "CVE-2005-1146": {"epss_score": 0.00443, "epss_percentile": 0.62799}, "CVE-2005-1147": {"epss_score": 0.00972, "epss_percentile": 0.76135}, "CVE-2005-1148": {"epss_score": 0.00669, "epss_percentile": 0.70764}, "CVE-2005-1149": {"epss_score": 0.01055, "epss_percentile": 0.77118}, "CVE-2005-1150": {"epss_score": 0.00543, "epss_percentile": 0.67099}, "CVE-2005-1151": {"epss_score": 0.00056, "epss_percentile": 0.17729}, "CVE-2005-1152": {"epss_score": 0.0007, "epss_percentile": 0.21834}, "CVE-2005-1153": {"epss_score": 0.07147, "epss_percentile": 0.91281}, "CVE-2005-1154": {"epss_score": 0.06584, "epss_percentile": 0.90864}, "CVE-2005-1155": {"epss_score": 0.35557, "epss_percentile": 0.96918}, "CVE-2005-1156": {"epss_score": 0.06778, "epss_percentile": 0.91019}, "CVE-2005-1157": {"epss_score": 0.08734, "epss_percentile": 0.92232}, "CVE-2005-1158": {"epss_score": 0.00857, "epss_percentile": 0.74489}, "CVE-2005-1159": {"epss_score": 0.0369, "epss_percentile": 0.87574}, "CVE-2005-1160": {"epss_score": 0.04288, "epss_percentile": 0.88498}, "CVE-2005-1161": {"epss_score": 0.03779, "epss_percentile": 0.87718}, "CVE-2005-1162": {"epss_score": 0.05846, "epss_percentile": 0.90255}, "CVE-2005-1163": {"epss_score": 0.18323, "epss_percentile": 0.94995}, "CVE-2005-1164": {"epss_score": 0.08724, "epss_percentile": 0.92228}, "CVE-2005-1165": {"epss_score": 0.05024, "epss_percentile": 0.89407}, "CVE-2005-1166": {"epss_score": 0.00081, "epss_percentile": 0.24371}, "CVE-2005-1167": {"epss_score": 0.00065, "epss_percentile": 0.2052}, "CVE-2005-1168": {"epss_score": 0.00397, "epss_percentile": 0.60037}, "CVE-2005-1169": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-1170": {"epss_score": 0.00334, "epss_percentile": 0.55699}, "CVE-2005-1171": {"epss_score": 0.00458, "epss_percentile": 0.63449}, "CVE-2005-1172": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-1173": {"epss_score": 0.07467, "epss_percentile": 0.9149}, "CVE-2005-1174": {"epss_score": 0.40925, "epss_percentile": 0.97245}, "CVE-2005-1175": {"epss_score": 0.45397, "epss_percentile": 0.97485}, "CVE-2005-1176": {"epss_score": 0.00071, "epss_percentile": 0.22055}, "CVE-2005-1177": {"epss_score": 0.00296, "epss_percentile": 0.52626}, "CVE-2005-1178": {"epss_score": 0.00487, "epss_percentile": 0.64822}, "CVE-2005-1179": {"epss_score": 0.0046, "epss_percentile": 0.63531}, "CVE-2005-1180": {"epss_score": 0.00146, "epss_percentile": 0.35541}, "CVE-2005-1181": {"epss_score": 0.05383, "epss_percentile": 0.89814}, "CVE-2005-1182": {"epss_score": 0.00458, "epss_percentile": 0.63431}, "CVE-2005-1183": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2005-1184": {"epss_score": 0.63724, "epss_percentile": 0.98346}, "CVE-2005-1185": {"epss_score": 0.00076, "epss_percentile": 0.23254}, "CVE-2005-1186": {"epss_score": 0.00459, "epss_percentile": 0.63468}, "CVE-2005-1187": {"epss_score": 0.01238, "epss_percentile": 0.78787}, "CVE-2005-1188": {"epss_score": 0.00834, "epss_percentile": 0.74112}, "CVE-2005-1189": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1190": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2005-1191": {"epss_score": 0.2557, "epss_percentile": 0.96044}, "CVE-2005-1192": {"epss_score": 0.01505, "epss_percentile": 0.80743}, "CVE-2005-1193": {"epss_score": 0.33947, "epss_percentile": 0.96818}, "CVE-2005-1194": {"epss_score": 0.00143, "epss_percentile": 0.35179}, "CVE-2005-1195": {"epss_score": 0.01744, "epss_percentile": 0.82061}, "CVE-2005-1196": {"epss_score": 0.00334, "epss_percentile": 0.55699}, "CVE-2005-1197": {"epss_score": 0.00899, "epss_percentile": 0.75152}, "CVE-2005-1198": {"epss_score": 0.0021, "epss_percentile": 0.43432}, "CVE-2005-1199": {"epss_score": 0.00475, "epss_percentile": 0.64189}, "CVE-2005-1200": {"epss_score": 0.03376, "epss_percentile": 0.87021}, "CVE-2005-1201": {"epss_score": 0.11403, "epss_percentile": 0.93335}, "CVE-2005-1202": {"epss_score": 0.07951, "epss_percentile": 0.91784}, "CVE-2005-1203": {"epss_score": 0.03538, "epss_percentile": 0.87314}, "CVE-2005-1204": {"epss_score": 0.09905, "epss_percentile": 0.92765}, "CVE-2005-1205": {"epss_score": 0.4124, "epss_percentile": 0.97261}, "CVE-2005-1206": {"epss_score": 0.46524, "epss_percentile": 0.9755}, "CVE-2005-1207": {"epss_score": 0.01255, "epss_percentile": 0.78929}, "CVE-2005-1208": {"epss_score": 0.38378, "epss_percentile": 0.97098}, "CVE-2005-1211": {"epss_score": 0.4344, "epss_percentile": 0.97386}, "CVE-2005-1212": {"epss_score": 0.3469, "epss_percentile": 0.96868}, "CVE-2005-1213": {"epss_score": 0.83908, "epss_percentile": 0.99264}, "CVE-2005-1214": {"epss_score": 0.22512, "epss_percentile": 0.95646}, "CVE-2005-1215": {"epss_score": 0.12444, "epss_percentile": 0.93674}, "CVE-2005-1216": {"epss_score": 0.33901, "epss_percentile": 0.96813}, "CVE-2005-1218": {"epss_score": 0.67055, "epss_percentile": 0.98491}, "CVE-2005-1219": {"epss_score": 0.77988, "epss_percentile": 0.98963}, "CVE-2005-1220": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-1221": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-1222": {"epss_score": 0.042, "epss_percentile": 0.88386}, "CVE-2005-1223": {"epss_score": 0.00475, "epss_percentile": 0.64189}, "CVE-2005-1224": {"epss_score": 0.02458, "epss_percentile": 0.84812}, "CVE-2005-1225": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-1226": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2005-1227": {"epss_score": 0.01048, "epss_percentile": 0.77048}, "CVE-2005-1228": {"epss_score": 0.04585, "epss_percentile": 0.88884}, "CVE-2005-1229": {"epss_score": 0.00962, "epss_percentile": 0.75999}, "CVE-2005-1230": {"epss_score": 0.00279, "epss_percentile": 0.50991}, "CVE-2005-1231": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2005-1232": {"epss_score": 0.02768, "epss_percentile": 0.85615}, "CVE-2005-1233": {"epss_score": 0.0731, "epss_percentile": 0.914}, "CVE-2005-1234": {"epss_score": 0.00995, "epss_percentile": 0.76436}, "CVE-2005-1235": {"epss_score": 0.0059, "epss_percentile": 0.6855}, "CVE-2005-1236": {"epss_score": 0.0028, "epss_percentile": 0.50999}, "CVE-2005-1237": {"epss_score": 0.04129, "epss_percentile": 0.88294}, "CVE-2005-1238": {"epss_score": 0.00445, "epss_percentile": 0.62857}, "CVE-2005-1239": {"epss_score": 0.00279, "epss_percentile": 0.50991}, "CVE-2005-1240": {"epss_score": 0.00573, "epss_percentile": 0.6806}, "CVE-2005-1241": {"epss_score": 0.00592, "epss_percentile": 0.6861}, "CVE-2005-1242": {"epss_score": 0.00271, "epss_percentile": 0.5028}, "CVE-2005-1243": {"epss_score": 0.00271, "epss_percentile": 0.5028}, "CVE-2005-1244": {"epss_score": 0.00654, "epss_percentile": 0.70352}, "CVE-2005-1245": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-1246": {"epss_score": 0.15109, "epss_percentile": 0.94365}, "CVE-2005-1247": {"epss_score": 0.00301, "epss_percentile": 0.53021}, "CVE-2005-1248": {"epss_score": 0.06283, "epss_percentile": 0.9064}, "CVE-2005-1249": {"epss_score": 0.01131, "epss_percentile": 0.77864}, "CVE-2005-1250": {"epss_score": 0.18051, "epss_percentile": 0.94949}, "CVE-2005-1252": {"epss_score": 0.0033, "epss_percentile": 0.55456}, "CVE-2005-1254": {"epss_score": 0.057, "epss_percentile": 0.90132}, "CVE-2005-1255": {"epss_score": 0.06301, "epss_percentile": 0.90656}, "CVE-2005-1256": {"epss_score": 0.81513, "epss_percentile": 0.99142}, "CVE-2005-1260": {"epss_score": 0.09796, "epss_percentile": 0.92706}, "CVE-2005-1261": {"epss_score": 0.1624, "epss_percentile": 0.946}, "CVE-2005-1262": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2005-1263": {"epss_score": 0.00058, "epss_percentile": 0.186}, "CVE-2005-1264": {"epss_score": 0.00052, "epss_percentile": 0.16629}, "CVE-2005-1265": {"epss_score": 0.00063, "epss_percentile": 0.19867}, "CVE-2005-1266": {"epss_score": 0.06726, "epss_percentile": 0.90971}, "CVE-2005-1267": {"epss_score": 0.1127, "epss_percentile": 0.93287}, "CVE-2005-1268": {"epss_score": 0.04266, "epss_percentile": 0.8847}, "CVE-2005-1269": {"epss_score": 0.02512, "epss_percentile": 0.84957}, "CVE-2005-1270": {"epss_score": 0.00079, "epss_percentile": 0.23853}, "CVE-2005-1272": {"epss_score": 0.80954, "epss_percentile": 0.99114}, "CVE-2005-1274": {"epss_score": 0.02875, "epss_percentile": 0.85882}, "CVE-2005-1275": {"epss_score": 0.16483, "epss_percentile": 0.94678}, "CVE-2005-1278": {"epss_score": 0.15422, "epss_percentile": 0.94428}, "CVE-2005-1279": {"epss_score": 0.5679, "epss_percentile": 0.98036}, "CVE-2005-1280": {"epss_score": 0.13646, "epss_percentile": 0.9402}, "CVE-2005-1281": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2005-1282": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-1283": {"epss_score": 0.01886, "epss_percentile": 0.82713}, "CVE-2005-1284": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2005-1285": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2005-1286": {"epss_score": 0.00076, "epss_percentile": 0.23221}, "CVE-2005-1287": {"epss_score": 0.02369, "epss_percentile": 0.84523}, "CVE-2005-1288": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2005-1289": {"epss_score": 0.08691, "epss_percentile": 0.92206}, "CVE-2005-1290": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-1291": {"epss_score": 0.01139, "epss_percentile": 0.77945}, "CVE-2005-1292": {"epss_score": 0.00903, "epss_percentile": 0.75205}, "CVE-2005-1293": {"epss_score": 0.01121, "epss_percentile": 0.77775}, "CVE-2005-1294": {"epss_score": 0.00088, "epss_percentile": 0.25644}, "CVE-2005-1295": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-1296": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2005-1297": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2005-1298": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-1299": {"epss_score": 0.0253, "epss_percentile": 0.85023}, "CVE-2005-1300": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2005-1301": {"epss_score": 0.00478, "epss_percentile": 0.64398}, "CVE-2005-1302": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-1303": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-1304": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-1305": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-1306": {"epss_score": 0.16058, "epss_percentile": 0.94565}, "CVE-2005-1307": {"epss_score": 0.00669, "epss_percentile": 0.70756}, "CVE-2005-1308": {"epss_score": 0.03149, "epss_percentile": 0.86501}, "CVE-2005-1309": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-1310": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-1311": {"epss_score": 0.00376, "epss_percentile": 0.58656}, "CVE-2005-1312": {"epss_score": 0.02416, "epss_percentile": 0.8469}, "CVE-2005-1313": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1314": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1315": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1316": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1317": {"epss_score": 0.00723, "epss_percentile": 0.72022}, "CVE-2005-1318": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1319": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1320": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1321": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1322": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1323": {"epss_score": 0.78183, "epss_percentile": 0.98972}, "CVE-2005-1324": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-1325": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2005-1326": {"epss_score": 0.0158, "epss_percentile": 0.81131}, "CVE-2005-1327": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-1328": {"epss_score": 0.01621, "epss_percentile": 0.81388}, "CVE-2005-1329": {"epss_score": 0.12231, "epss_percentile": 0.93608}, "CVE-2005-1330": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2005-1331": {"epss_score": 0.01126, "epss_percentile": 0.7781}, "CVE-2005-1332": {"epss_score": 0.013, "epss_percentile": 0.79286}, "CVE-2005-1333": {"epss_score": 0.04718, "epss_percentile": 0.89046}, "CVE-2005-1335": {"epss_score": 0.00478, "epss_percentile": 0.64401}, "CVE-2005-1336": {"epss_score": 0.00084, "epss_percentile": 0.25011}, "CVE-2005-1337": {"epss_score": 0.00554, "epss_percentile": 0.67437}, "CVE-2005-1338": {"epss_score": 0.00066, "epss_percentile": 0.20841}, "CVE-2005-1339": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-1340": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-1341": {"epss_score": 0.00845, "epss_percentile": 0.74285}, "CVE-2005-1342": {"epss_score": 0.17699, "epss_percentile": 0.94892}, "CVE-2005-1343": {"epss_score": 0.00069, "epss_percentile": 0.21623}, "CVE-2005-1344": {"epss_score": 0.14331, "epss_percentile": 0.94189}, "CVE-2005-1345": {"epss_score": 0.00155, "epss_percentile": 0.36809}, "CVE-2005-1346": {"epss_score": 0.00705, "epss_percentile": 0.71586}, "CVE-2005-1347": {"epss_score": 0.08233, "epss_percentile": 0.91942}, "CVE-2005-1348": {"epss_score": 0.91095, "epss_percentile": 0.9962}, "CVE-2005-1349": {"epss_score": 0.0835, "epss_percentile": 0.92004}, "CVE-2005-1350": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-1351": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2005-1352": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1353": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-1354": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2005-1355": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-1356": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1357": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-1358": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2005-1359": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1360": {"epss_score": 0.03176, "epss_percentile": 0.8657}, "CVE-2005-1361": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2005-1362": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-1363": {"epss_score": 0.00614, "epss_percentile": 0.69281}, "CVE-2005-1364": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2005-1365": {"epss_score": 0.07343, "epss_percentile": 0.9142}, "CVE-2005-1366": {"epss_score": 0.04734, "epss_percentile": 0.89073}, "CVE-2005-1367": {"epss_score": 0.00415, "epss_percentile": 0.61136}, "CVE-2005-1368": {"epss_score": 0.00073, "epss_percentile": 0.22661}, "CVE-2005-1369": {"epss_score": 0.00049, "epss_percentile": 0.15616}, "CVE-2005-1370": {"epss_score": 0.08197, "epss_percentile": 0.91925}, "CVE-2005-1371": {"epss_score": 0.00192, "epss_percentile": 0.41352}, "CVE-2005-1372": {"epss_score": 0.00186, "epss_percentile": 0.4068}, "CVE-2005-1373": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2005-1374": {"epss_score": 0.02567, "epss_percentile": 0.85119}, "CVE-2005-1375": {"epss_score": 0.01322, "epss_percentile": 0.79447}, "CVE-2005-1376": {"epss_score": 0.00934, "epss_percentile": 0.75661}, "CVE-2005-1377": {"epss_score": 0.0153, "epss_percentile": 0.80888}, "CVE-2005-1378": {"epss_score": 0.00883, "epss_percentile": 0.74922}, "CVE-2005-1379": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2005-1380": {"epss_score": 0.01285, "epss_percentile": 0.79175}, "CVE-2005-1381": {"epss_score": 0.26538, "epss_percentile": 0.96155}, "CVE-2005-1382": {"epss_score": 0.45431, "epss_percentile": 0.97487}, "CVE-2005-1383": {"epss_score": 0.60994, "epss_percentile": 0.9823}, "CVE-2005-1384": {"epss_score": 0.02448, "epss_percentile": 0.84774}, "CVE-2005-1385": {"epss_score": 0.01126, "epss_percentile": 0.7781}, "CVE-2005-1386": {"epss_score": 0.00014, "epss_percentile": 0.02084}, "CVE-2005-1387": {"epss_score": 0.00049, "epss_percentile": 0.1545}, "CVE-2005-1388": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1391": {"epss_score": 0.07762, "epss_percentile": 0.91666}, "CVE-2005-1392": {"epss_score": 0.00051, "epss_percentile": 0.16326}, "CVE-2005-1393": {"epss_score": 0.00089, "epss_percentile": 0.25813}, "CVE-2005-1394": {"epss_score": 0.00697, "epss_percentile": 0.71414}, "CVE-2005-1395": {"epss_score": 0.00052, "epss_percentile": 0.16452}, "CVE-2005-1396": {"epss_score": 0.00171, "epss_percentile": 0.38814}, "CVE-2005-1397": {"epss_score": 0.02672, "epss_percentile": 0.85394}, "CVE-2005-1398": {"epss_score": 0.11255, "epss_percentile": 0.93279}, "CVE-2005-1399": {"epss_score": 0.00046, "epss_percentile": 0.14328}, "CVE-2005-1400": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2005-1401": {"epss_score": 0.12891, "epss_percentile": 0.93813}, "CVE-2005-1402": {"epss_score": 0.05902, "epss_percentile": 0.90311}, "CVE-2005-1403": {"epss_score": 0.01918, "epss_percentile": 0.82873}, "CVE-2005-1404": {"epss_score": 0.00985, "epss_percentile": 0.76319}, "CVE-2005-1405": {"epss_score": 0.00082, "epss_percentile": 0.24545}, "CVE-2005-1406": {"epss_score": 0.0009, "epss_percentile": 0.26091}, "CVE-2005-1407": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2005-1408": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2005-1409": {"epss_score": 0.01196, "epss_percentile": 0.78435}, "CVE-2005-1410": {"epss_score": 0.001, "epss_percentile": 0.28508}, "CVE-2005-1411": {"epss_score": 0.00215, "epss_percentile": 0.44073}, "CVE-2005-1412": {"epss_score": 0.0088, "epss_percentile": 0.74856}, "CVE-2005-1413": {"epss_score": 0.02219, "epss_percentile": 0.84047}, "CVE-2005-1414": {"epss_score": 0.00152, "epss_percentile": 0.36466}, "CVE-2005-1415": {"epss_score": 0.67935, "epss_percentile": 0.98526}, "CVE-2005-1416": {"epss_score": 0.0025, "epss_percentile": 0.48121}, "CVE-2005-1417": {"epss_score": 0.00449, "epss_percentile": 0.6305}, "CVE-2005-1418": {"epss_score": 0.00177, "epss_percentile": 0.39498}, "CVE-2005-1419": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2005-1420": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2005-1421": {"epss_score": 0.00248, "epss_percentile": 0.47916}, "CVE-2005-1422": {"epss_score": 0.00763, "epss_percentile": 0.72859}, "CVE-2005-1423": {"epss_score": 0.03387, "epss_percentile": 0.87042}, "CVE-2005-1424": {"epss_score": 0.00172, "epss_percentile": 0.39007}, "CVE-2005-1425": {"epss_score": 0.00615, "epss_percentile": 0.69304}, "CVE-2005-1426": {"epss_score": 0.00433, "epss_percentile": 0.62177}, "CVE-2005-1427": {"epss_score": 0.01015, "epss_percentile": 0.76663}, "CVE-2005-1428": {"epss_score": 0.00763, "epss_percentile": 0.72859}, "CVE-2005-1429": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-1430": {"epss_score": 0.00048, "epss_percentile": 0.14967}, "CVE-2005-1431": {"epss_score": 0.01372, "epss_percentile": 0.79813}, "CVE-2005-1433": {"epss_score": 0.0011, "epss_percentile": 0.30238}, "CVE-2005-1434": {"epss_score": 0.01171, "epss_percentile": 0.78213}, "CVE-2005-1435": {"epss_score": 0.01317, "epss_percentile": 0.79419}, "CVE-2005-1436": {"epss_score": 0.02076, "epss_percentile": 0.83511}, "CVE-2005-1437": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-1438": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-1439": {"epss_score": 0.00937, "epss_percentile": 0.75692}, "CVE-2005-1440": {"epss_score": 0.02744, "epss_percentile": 0.85567}, "CVE-2005-1441": {"epss_score": 0.01434, "epss_percentile": 0.80262}, "CVE-2005-1442": {"epss_score": 0.00087, "epss_percentile": 0.25587}, "CVE-2005-1443": {"epss_score": 0.01039, "epss_percentile": 0.76947}, "CVE-2005-1444": {"epss_score": 0.02076, "epss_percentile": 0.83511}, "CVE-2005-1445": {"epss_score": 0.00712, "epss_percentile": 0.71756}, "CVE-2005-1446": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2005-1447": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2005-1448": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2005-1449": {"epss_score": 0.00376, "epss_percentile": 0.58674}, "CVE-2005-1450": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2005-1451": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-1452": {"epss_score": 0.00376, "epss_percentile": 0.58674}, "CVE-2005-1453": {"epss_score": 0.00503, "epss_percentile": 0.65483}, "CVE-2005-1454": {"epss_score": 0.00763, "epss_percentile": 0.72887}, "CVE-2005-1455": {"epss_score": 0.01494, "epss_percentile": 0.80645}, "CVE-2005-1456": {"epss_score": 0.01117, "epss_percentile": 0.77735}, "CVE-2005-1457": {"epss_score": 0.011, "epss_percentile": 0.77562}, "CVE-2005-1458": {"epss_score": 0.00705, "epss_percentile": 0.71603}, "CVE-2005-1459": {"epss_score": 0.01252, "epss_percentile": 0.78903}, "CVE-2005-1460": {"epss_score": 0.011, "epss_percentile": 0.77562}, "CVE-2005-1461": {"epss_score": 0.12335, "epss_percentile": 0.93643}, "CVE-2005-1462": {"epss_score": 0.02988, "epss_percentile": 0.8614}, "CVE-2005-1463": {"epss_score": 0.03389, "epss_percentile": 0.87046}, "CVE-2005-1464": {"epss_score": 0.01297, "epss_percentile": 0.79267}, "CVE-2005-1465": {"epss_score": 0.01252, "epss_percentile": 0.78903}, "CVE-2005-1466": {"epss_score": 0.01252, "epss_percentile": 0.78903}, "CVE-2005-1467": {"epss_score": 0.011, "epss_percentile": 0.77562}, "CVE-2005-1468": {"epss_score": 0.01475, "epss_percentile": 0.80526}, "CVE-2005-1469": {"epss_score": 0.01038, "epss_percentile": 0.76933}, "CVE-2005-1470": {"epss_score": 0.12703, "epss_percentile": 0.93753}, "CVE-2005-1471": {"epss_score": 0.03702, "epss_percentile": 0.87593}, "CVE-2005-1472": {"epss_score": 0.00048, "epss_percentile": 0.15236}, "CVE-2005-1473": {"epss_score": 0.00066, "epss_percentile": 0.20841}, "CVE-2005-1474": {"epss_score": 0.01244, "epss_percentile": 0.78838}, "CVE-2005-1475": {"epss_score": 0.00379, "epss_percentile": 0.58889}, "CVE-2005-1476": {"epss_score": 0.4976, "epss_percentile": 0.97705}, "CVE-2005-1477": {"epss_score": 0.41646, "epss_percentile": 0.97288}, "CVE-2005-1478": {"epss_score": 0.06197, "epss_percentile": 0.90557}, "CVE-2005-1479": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2005-1480": {"epss_score": 0.07942, "epss_percentile": 0.9178}, "CVE-2005-1481": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-1482": {"epss_score": 0.0153, "epss_percentile": 0.80888}, "CVE-2005-1483": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2005-1484": {"epss_score": 0.00236, "epss_percentile": 0.46458}, "CVE-2005-1485": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-1486": {"epss_score": 0.0961, "epss_percentile": 0.92621}, "CVE-2005-1487": {"epss_score": 0.02241, "epss_percentile": 0.84115}, "CVE-2005-1488": {"epss_score": 0.00054, "epss_percentile": 0.17097}, "CVE-2005-1489": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2005-1490": {"epss_score": 0.00184, "epss_percentile": 0.40436}, "CVE-2005-1491": {"epss_score": 0.00357, "epss_percentile": 0.57408}, "CVE-2005-1492": {"epss_score": 0.01916, "epss_percentile": 0.82861}, "CVE-2005-1493": {"epss_score": 0.06018, "epss_percentile": 0.90414}, "CVE-2005-1494": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2005-1495": {"epss_score": 0.01414, "epss_percentile": 0.80128}, "CVE-2005-1496": {"epss_score": 0.05207, "epss_percentile": 0.89611}, "CVE-2005-1497": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-1498": {"epss_score": 0.04969, "epss_percentile": 0.89347}, "CVE-2005-1499": {"epss_score": 0.01708, "epss_percentile": 0.81866}, "CVE-2005-1500": {"epss_score": 0.01304, "epss_percentile": 0.79314}, "CVE-2005-1501": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-1502": {"epss_score": 0.04058, "epss_percentile": 0.88188}, "CVE-2005-1503": {"epss_score": 0.01813, "epss_percentile": 0.82377}, "CVE-2005-1504": {"epss_score": 0.01031, "epss_percentile": 0.76857}, "CVE-2005-1505": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2005-1506": {"epss_score": 0.00334, "epss_percentile": 0.55699}, "CVE-2005-1507": {"epss_score": 0.07595, "epss_percentile": 0.9156}, "CVE-2005-1508": {"epss_score": 0.02467, "epss_percentile": 0.84837}, "CVE-2005-1509": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-1510": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-1511": {"epss_score": 0.00644, "epss_percentile": 0.70079}, "CVE-2005-1512": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-1513": {"epss_score": 0.09483, "epss_percentile": 0.92567}, "CVE-2005-1514": {"epss_score": 0.04981, "epss_percentile": 0.8936}, "CVE-2005-1515": {"epss_score": 0.04671, "epss_percentile": 0.88987}, "CVE-2005-1516": {"epss_score": 0.00644, "epss_percentile": 0.70079}, "CVE-2005-1517": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2005-1518": {"epss_score": 0.00058, "epss_percentile": 0.18446}, "CVE-2005-1519": {"epss_score": 0.24581, "epss_percentile": 0.95935}, "CVE-2005-1520": {"epss_score": 0.11332, "epss_percentile": 0.93312}, "CVE-2005-1521": {"epss_score": 0.04102, "epss_percentile": 0.88261}, "CVE-2005-1522": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2005-1523": {"epss_score": 0.14093, "epss_percentile": 0.94131}, "CVE-2005-1524": {"epss_score": 0.12071, "epss_percentile": 0.93559}, "CVE-2005-1525": {"epss_score": 0.01582, "epss_percentile": 0.81144}, "CVE-2005-1526": {"epss_score": 0.0868, "epss_percentile": 0.92196}, "CVE-2005-1527": {"epss_score": 0.0133, "epss_percentile": 0.7951}, "CVE-2005-1528": {"epss_score": 0.00337, "epss_percentile": 0.56008}, "CVE-2005-1530": {"epss_score": 0.05979, "epss_percentile": 0.90377}, "CVE-2005-1531": {"epss_score": 0.02198, "epss_percentile": 0.83965}, "CVE-2005-1532": {"epss_score": 0.17427, "epss_percentile": 0.94851}, "CVE-2005-1543": {"epss_score": 0.80369, "epss_percentile": 0.99084}, "CVE-2005-1544": {"epss_score": 0.15653, "epss_percentile": 0.94476}, "CVE-2005-1545": {"epss_score": 0.02908, "epss_percentile": 0.85967}, "CVE-2005-1546": {"epss_score": 0.02908, "epss_percentile": 0.85967}, "CVE-2005-1547": {"epss_score": 0.04756, "epss_percentile": 0.89113}, "CVE-2005-1548": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2005-1549": {"epss_score": 0.00279, "epss_percentile": 0.50991}, "CVE-2005-1550": {"epss_score": 0.07698, "epss_percentile": 0.91633}, "CVE-2005-1551": {"epss_score": 0.00772, "epss_percentile": 0.73037}, "CVE-2005-1552": {"epss_score": 0.05018, "epss_percentile": 0.89399}, "CVE-2005-1553": {"epss_score": 0.00479, "epss_percentile": 0.64443}, "CVE-2005-1554": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2005-1555": {"epss_score": 0.00203, "epss_percentile": 0.42572}, "CVE-2005-1556": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2005-1557": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2005-1558": {"epss_score": 0.00591, "epss_percentile": 0.68579}, "CVE-2005-1559": {"epss_score": 0.04899, "epss_percentile": 0.89271}, "CVE-2005-1560": {"epss_score": 0.02418, "epss_percentile": 0.84694}, "CVE-2005-1561": {"epss_score": 0.09589, "epss_percentile": 0.92612}, "CVE-2005-1562": {"epss_score": 0.0222, "epss_percentile": 0.84049}, "CVE-2005-1563": {"epss_score": 0.00807, "epss_percentile": 0.73678}, "CVE-2005-1564": {"epss_score": 0.01819, "epss_percentile": 0.82404}, "CVE-2005-1565": {"epss_score": 0.00804, "epss_percentile": 0.73625}, "CVE-2005-1566": {"epss_score": 0.00624, "epss_percentile": 0.69559}, "CVE-2005-1567": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-1568": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-1569": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1570": {"epss_score": 0.0034, "epss_percentile": 0.56245}, "CVE-2005-1571": {"epss_score": 0.00273, "epss_percentile": 0.50451}, "CVE-2005-1572": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-2005-1573": {"epss_score": 0.00451, "epss_percentile": 0.63116}, "CVE-2005-1574": {"epss_score": 0.04089, "epss_percentile": 0.88235}, "CVE-2005-1575": {"epss_score": 0.00486, "epss_percentile": 0.64776}, "CVE-2005-1576": {"epss_score": 0.00486, "epss_percentile": 0.64776}, "CVE-2005-1577": {"epss_score": 0.00664, "epss_percentile": 0.70649}, "CVE-2005-1578": {"epss_score": 0.0007, "epss_percentile": 0.21691}, "CVE-2005-1579": {"epss_score": 0.0281, "epss_percentile": 0.8572}, "CVE-2005-1580": {"epss_score": 0.01983, "epss_percentile": 0.83146}, "CVE-2005-1581": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1582": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-1583": {"epss_score": 0.00397, "epss_percentile": 0.60037}, "CVE-2005-1584": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2005-1585": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-1586": {"epss_score": 0.00457, "epss_percentile": 0.63389}, "CVE-2005-1587": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2005-1588": {"epss_score": 0.00716, "epss_percentile": 0.71859}, "CVE-2005-1589": {"epss_score": 0.00143, "epss_percentile": 0.35196}, "CVE-2005-1590": {"epss_score": 0.00147, "epss_percentile": 0.35653}, "CVE-2005-1591": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-1592": {"epss_score": 0.00664, "epss_percentile": 0.70649}, "CVE-2005-1593": {"epss_score": 0.05935, "epss_percentile": 0.90342}, "CVE-2005-1594": {"epss_score": 0.00765, "epss_percentile": 0.72914}, "CVE-2005-1595": {"epss_score": 0.00494, "epss_percentile": 0.65082}, "CVE-2005-1596": {"epss_score": 0.05244, "epss_percentile": 0.89656}, "CVE-2005-1597": {"epss_score": 0.0105, "epss_percentile": 0.77072}, "CVE-2005-1598": {"epss_score": 0.07777, "epss_percentile": 0.91676}, "CVE-2005-1599": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-1600": {"epss_score": 0.00698, "epss_percentile": 0.71424}, "CVE-2005-1601": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-1602": {"epss_score": 0.01035, "epss_percentile": 0.76905}, "CVE-2005-1603": {"epss_score": 0.04311, "epss_percentile": 0.88532}, "CVE-2005-1604": {"epss_score": 0.07806, "epss_percentile": 0.91692}, "CVE-2005-1605": {"epss_score": 0.02533, "epss_percentile": 0.8503}, "CVE-2005-1606": {"epss_score": 0.00333, "epss_percentile": 0.55624}, "CVE-2005-1607": {"epss_score": 0.01171, "epss_percentile": 0.78224}, "CVE-2005-1608": {"epss_score": 0.0054, "epss_percentile": 0.67001}, "CVE-2005-1609": {"epss_score": 0.04915, "epss_percentile": 0.89284}, "CVE-2005-1610": {"epss_score": 0.01472, "epss_percentile": 0.80508}, "CVE-2005-1611": {"epss_score": 0.00566, "epss_percentile": 0.67824}, "CVE-2005-1612": {"epss_score": 0.00432, "epss_percentile": 0.62096}, "CVE-2005-1613": {"epss_score": 0.00687, "epss_percentile": 0.71177}, "CVE-2005-1614": {"epss_score": 0.00687, "epss_percentile": 0.71177}, "CVE-2005-1615": {"epss_score": 0.00425, "epss_percentile": 0.61692}, "CVE-2005-1616": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-1617": {"epss_score": 0.00065, "epss_percentile": 0.2052}, "CVE-2005-1618": {"epss_score": 0.04457, "epss_percentile": 0.88713}, "CVE-2005-1619": {"epss_score": 0.03988, "epss_percentile": 0.88067}, "CVE-2005-1620": {"epss_score": 0.00926, "epss_percentile": 0.75545}, "CVE-2005-1621": {"epss_score": 0.00874, "epss_percentile": 0.74755}, "CVE-2005-1622": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1625": {"epss_score": 0.15002, "epss_percentile": 0.94339}, "CVE-2005-1626": {"epss_score": 0.01185, "epss_percentile": 0.7834}, "CVE-2005-1627": {"epss_score": 0.00093, "epss_percentile": 0.26607}, "CVE-2005-1628": {"epss_score": 0.17371, "epss_percentile": 0.9484}, "CVE-2005-1629": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2005-1630": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2005-1631": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2005-1632": {"epss_score": 0.00054, "epss_percentile": 0.17179}, "CVE-2005-1633": {"epss_score": 0.0031, "epss_percentile": 0.53743}, "CVE-2005-1634": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1635": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-1636": {"epss_score": 0.0002, "epss_percentile": 0.0456}, "CVE-2005-1637": {"epss_score": 0.00307, "epss_percentile": 0.53528}, "CVE-2005-1638": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2005-1639": {"epss_score": 0.0069, "epss_percentile": 0.7124}, "CVE-2005-1640": {"epss_score": 0.00077, "epss_percentile": 0.23412}, "CVE-2005-1641": {"epss_score": 0.00048, "epss_percentile": 0.15221}, "CVE-2005-1642": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2005-1643": {"epss_score": 0.0048, "epss_percentile": 0.64475}, "CVE-2005-1644": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2005-1645": {"epss_score": 0.05503, "epss_percentile": 0.89939}, "CVE-2005-1646": {"epss_score": 0.00428, "epss_percentile": 0.61953}, "CVE-2005-1647": {"epss_score": 0.01015, "epss_percentile": 0.76663}, "CVE-2005-1648": {"epss_score": 0.01015, "epss_percentile": 0.76663}, "CVE-2005-1649": {"epss_score": 0.15942, "epss_percentile": 0.9454}, "CVE-2005-1650": {"epss_score": 0.00841, "epss_percentile": 0.74216}, "CVE-2005-1651": {"epss_score": 0.00437, "epss_percentile": 0.62519}, "CVE-2005-1652": {"epss_score": 0.00572, "epss_percentile": 0.6803}, "CVE-2005-1653": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2005-1654": {"epss_score": 0.02121, "epss_percentile": 0.83679}, "CVE-2005-1655": {"epss_score": 0.03387, "epss_percentile": 0.87042}, "CVE-2005-1656": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2005-1657": {"epss_score": 0.00801, "epss_percentile": 0.73563}, "CVE-2005-1658": {"epss_score": 0.00219, "epss_percentile": 0.44474}, "CVE-2005-1659": {"epss_score": 0.00397, "epss_percentile": 0.60037}, "CVE-2005-1660": {"epss_score": 0.01015, "epss_percentile": 0.76663}, "CVE-2005-1661": {"epss_score": 0.0088, "epss_percentile": 0.74853}, "CVE-2005-1662": {"epss_score": 0.00395, "epss_percentile": 0.59847}, "CVE-2005-1663": {"epss_score": 0.01431, "epss_percentile": 0.80242}, "CVE-2005-1664": {"epss_score": 0.22025, "epss_percentile": 0.95585}, "CVE-2005-1665": {"epss_score": 0.34533, "epss_percentile": 0.96854}, "CVE-2005-1666": {"epss_score": 0.23906, "epss_percentile": 0.95832}, "CVE-2005-1667": {"epss_score": 0.01666, "epss_percentile": 0.8165}, "CVE-2005-1668": {"epss_score": 0.00742, "epss_percentile": 0.72455}, "CVE-2005-1669": {"epss_score": 0.00437, "epss_percentile": 0.6253}, "CVE-2005-1670": {"epss_score": 0.00261, "epss_percentile": 0.49314}, "CVE-2005-1671": {"epss_score": 0.00098, "epss_percentile": 0.27674}, "CVE-2005-1672": {"epss_score": 0.00457, "epss_percentile": 0.63393}, "CVE-2005-1673": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2005-1674": {"epss_score": 0.00689, "epss_percentile": 0.71219}, "CVE-2005-1675": {"epss_score": 0.00107, "epss_percentile": 0.29742}, "CVE-2005-1676": {"epss_score": 0.03622, "epss_percentile": 0.87444}, "CVE-2005-1677": {"epss_score": 0.01053, "epss_percentile": 0.77101}, "CVE-2005-1678": {"epss_score": 0.04254, "epss_percentile": 0.88456}, "CVE-2005-1679": {"epss_score": 0.0485, "epss_percentile": 0.89213}, "CVE-2005-1680": {"epss_score": 0.00419, "epss_percentile": 0.61353}, "CVE-2005-1681": {"epss_score": 0.04013, "epss_percentile": 0.88114}, "CVE-2005-1682": {"epss_score": 0.00222, "epss_percentile": 0.4479}, "CVE-2005-1683": {"epss_score": 0.1513, "epss_percentile": 0.9437}, "CVE-2005-1684": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1685": {"epss_score": 0.00781, "epss_percentile": 0.73179}, "CVE-2005-1686": {"epss_score": 0.02383, "epss_percentile": 0.84569}, "CVE-2005-1687": {"epss_score": 0.00837, "epss_percentile": 0.7415}, "CVE-2005-1688": {"epss_score": 0.00622, "epss_percentile": 0.69505}, "CVE-2005-1689": {"epss_score": 0.55203, "epss_percentile": 0.97965}, "CVE-2005-1691": {"epss_score": 0.00273, "epss_percentile": 0.50451}, "CVE-2005-1692": {"epss_score": 0.01962, "epss_percentile": 0.83065}, "CVE-2005-1693": {"epss_score": 0.05143, "epss_percentile": 0.8954}, "CVE-2005-1694": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-1695": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1696": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1697": {"epss_score": 0.00319, "epss_percentile": 0.54532}, "CVE-2005-1698": {"epss_score": 0.00319, "epss_percentile": 0.54532}, "CVE-2005-1699": {"epss_score": 0.00327, "epss_percentile": 0.55104}, "CVE-2005-1700": {"epss_score": 0.00267, "epss_percentile": 0.49973}, "CVE-2005-1701": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2005-1702": {"epss_score": 0.11826, "epss_percentile": 0.93488}, "CVE-2005-1703": {"epss_score": 0.05879, "epss_percentile": 0.90288}, "CVE-2005-1704": {"epss_score": 0.00222, "epss_percentile": 0.4477}, "CVE-2005-1705": {"epss_score": 0.00057, "epss_percentile": 0.18126}, "CVE-2005-1706": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-2005-1707": {"epss_score": 0.00228, "epss_percentile": 0.45465}, "CVE-2005-1708": {"epss_score": 0.00913, "epss_percentile": 0.75376}, "CVE-2005-1709": {"epss_score": 0.03775, "epss_percentile": 0.87708}, "CVE-2005-1710": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-1711": {"epss_score": 0.00036, "epss_percentile": 0.10434}, "CVE-2005-1712": {"epss_score": 0.00445, "epss_percentile": 0.62857}, "CVE-2005-1713": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-1714": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1715": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2005-1716": {"epss_score": 0.00421, "epss_percentile": 0.61534}, "CVE-2005-1717": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2005-1718": {"epss_score": 0.05132, "epss_percentile": 0.89531}, "CVE-2005-1719": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-2005-1720": {"epss_score": 0.00054, "epss_percentile": 0.17054}, "CVE-2005-1721": {"epss_score": 0.00881, "epss_percentile": 0.74863}, "CVE-2005-1722": {"epss_score": 0.00048, "epss_percentile": 0.15135}, "CVE-2005-1723": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-2005-1724": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-2005-1725": {"epss_score": 0.00161, "epss_percentile": 0.37607}, "CVE-2005-1726": {"epss_score": 0.00074, "epss_percentile": 0.22707}, "CVE-2005-1727": {"epss_score": 0.00046, "epss_percentile": 0.14328}, "CVE-2005-1728": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2005-1729": {"epss_score": 0.02526, "epss_percentile": 0.85013}, "CVE-2005-1730": {"epss_score": 0.01113, "epss_percentile": 0.77686}, "CVE-2005-1732": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2005-1733": {"epss_score": 0.00408, "epss_percentile": 0.60677}, "CVE-2005-1734": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-1735": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-1736": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2005-1737": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2005-1738": {"epss_score": 0.00886, "epss_percentile": 0.74955}, "CVE-2005-1739": {"epss_score": 0.12134, "epss_percentile": 0.93576}, "CVE-2005-1740": {"epss_score": 0.02536, "epss_percentile": 0.85039}, "CVE-2005-1741": {"epss_score": 0.08724, "epss_percentile": 0.92228}, "CVE-2005-1742": {"epss_score": 0.00413, "epss_percentile": 0.60966}, "CVE-2005-1743": {"epss_score": 0.00537, "epss_percentile": 0.66896}, "CVE-2005-1744": {"epss_score": 0.00725, "epss_percentile": 0.72058}, "CVE-2005-1745": {"epss_score": 0.00539, "epss_percentile": 0.66986}, "CVE-2005-1746": {"epss_score": 0.00856, "epss_percentile": 0.74486}, "CVE-2005-1747": {"epss_score": 0.02674, "epss_percentile": 0.85398}, "CVE-2005-1748": {"epss_score": 0.00747, "epss_percentile": 0.72553}, "CVE-2005-1749": {"epss_score": 0.00832, "epss_percentile": 0.74076}, "CVE-2005-1750": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2005-1751": {"epss_score": 0.00075, "epss_percentile": 0.22959}, "CVE-2005-1752": {"epss_score": 0.14848, "epss_percentile": 0.94301}, "CVE-2005-1753": {"epss_score": 0.00859, "epss_percentile": 0.74515}, "CVE-2005-1754": {"epss_score": 0.08852, "epss_percentile": 0.92285}, "CVE-2005-1755": {"epss_score": 0.00718, "epss_percentile": 0.71915}, "CVE-2005-1756": {"epss_score": 0.01166, "epss_percentile": 0.78181}, "CVE-2005-1757": {"epss_score": 0.02041, "epss_percentile": 0.83372}, "CVE-2005-1758": {"epss_score": 0.68403, "epss_percentile": 0.98545}, "CVE-2005-1759": {"epss_score": 0.0007, "epss_percentile": 0.21641}, "CVE-2005-1760": {"epss_score": 0.00542, "epss_percentile": 0.67081}, "CVE-2005-1761": {"epss_score": 0.00034, "epss_percentile": 0.0962}, "CVE-2005-1762": {"epss_score": 0.00064, "epss_percentile": 0.20425}, "CVE-2005-1763": {"epss_score": 0.00042, "epss_percentile": 0.12879}, "CVE-2005-1764": {"epss_score": 0.00063, "epss_percentile": 0.20082}, "CVE-2005-1765": {"epss_score": 0.00063, "epss_percentile": 0.19964}, "CVE-2005-1766": {"epss_score": 0.0509, "epss_percentile": 0.89482}, "CVE-2005-1767": {"epss_score": 0.00034, "epss_percentile": 0.0962}, "CVE-2005-1768": {"epss_score": 0.00105, "epss_percentile": 0.29344}, "CVE-2005-1769": {"epss_score": 0.01697, "epss_percentile": 0.81815}, "CVE-2005-1770": {"epss_score": 0.0006, "epss_percentile": 0.19032}, "CVE-2005-1771": {"epss_score": 0.00758, "epss_percentile": 0.72768}, "CVE-2005-1772": {"epss_score": 0.00967, "epss_percentile": 0.76065}, "CVE-2005-1773": {"epss_score": 0.01983, "epss_percentile": 0.83146}, "CVE-2005-1774": {"epss_score": 0.00052, "epss_percentile": 0.16556}, "CVE-2005-1775": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2005-1776": {"epss_score": 0.04755, "epss_percentile": 0.89112}, "CVE-2005-1777": {"epss_score": 0.00349, "epss_percentile": 0.56866}, "CVE-2005-1778": {"epss_score": 0.00412, "epss_percentile": 0.6093}, "CVE-2005-1779": {"epss_score": 0.00262, "epss_percentile": 0.49377}, "CVE-2005-1780": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-1781": {"epss_score": 0.03269, "epss_percentile": 0.86789}, "CVE-2005-1782": {"epss_score": 0.01737, "epss_percentile": 0.82019}, "CVE-2005-1783": {"epss_score": 0.00457, "epss_percentile": 0.63389}, "CVE-2005-1784": {"epss_score": 0.00443, "epss_percentile": 0.62759}, "CVE-2005-1785": {"epss_score": 0.00768, "epss_percentile": 0.7297}, "CVE-2005-1786": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2005-1787": {"epss_score": 0.06808, "epss_percentile": 0.91039}, "CVE-2005-1788": {"epss_score": 0.00293, "epss_percentile": 0.52333}, "CVE-2005-1789": {"epss_score": 0.00451, "epss_percentile": 0.63116}, "CVE-2005-1790": {"epss_score": 0.8164, "epss_percentile": 0.99148}, "CVE-2005-1791": {"epss_score": 0.09402, "epss_percentile": 0.92532}, "CVE-2005-1792": {"epss_score": 0.13081, "epss_percentile": 0.93867}, "CVE-2005-1793": {"epss_score": 0.08916, "epss_percentile": 0.92316}, "CVE-2005-1794": {"epss_score": 0.09694, "epss_percentile": 0.92665}, "CVE-2005-1795": {"epss_score": 0.02166, "epss_percentile": 0.83847}, "CVE-2005-1796": {"epss_score": 0.07878, "epss_percentile": 0.91738}, "CVE-2005-1797": {"epss_score": 0.00319, "epss_percentile": 0.54545}, "CVE-2005-1798": {"epss_score": 0.00237, "epss_percentile": 0.46727}, "CVE-2005-1799": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1800": {"epss_score": 0.00374, "epss_percentile": 0.58534}, "CVE-2005-1801": {"epss_score": 0.02835, "epss_percentile": 0.85788}, "CVE-2005-1802": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2005-1803": {"epss_score": 0.00378, "epss_percentile": 0.58799}, "CVE-2005-1804": {"epss_score": 0.00319, "epss_percentile": 0.54555}, "CVE-2005-1805": {"epss_score": 0.01055, "epss_percentile": 0.77118}, "CVE-2005-1806": {"epss_score": 0.18248, "epss_percentile": 0.94981}, "CVE-2005-1807": {"epss_score": 0.15352, "epss_percentile": 0.94414}, "CVE-2005-1808": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2005-1809": {"epss_score": 0.01037, "epss_percentile": 0.76925}, "CVE-2005-1810": {"epss_score": 0.01638, "epss_percentile": 0.81485}, "CVE-2005-1811": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-1812": {"epss_score": 0.82151, "epss_percentile": 0.99176}, "CVE-2005-1813": {"epss_score": 0.00418, "epss_percentile": 0.61268}, "CVE-2005-1814": {"epss_score": 0.02412, "epss_percentile": 0.84668}, "CVE-2005-1815": {"epss_score": 0.62867, "epss_percentile": 0.98311}, "CVE-2005-1816": {"epss_score": 0.00064, "epss_percentile": 0.20432}, "CVE-2005-1817": {"epss_score": 0.02978, "epss_percentile": 0.86114}, "CVE-2005-1818": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-1819": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-1820": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2005-1821": {"epss_score": 0.02928, "epss_percentile": 0.86011}, "CVE-2005-1822": {"epss_score": 0.00609, "epss_percentile": 0.69097}, "CVE-2005-1823": {"epss_score": 0.00777, "epss_percentile": 0.73108}, "CVE-2005-1824": {"epss_score": 0.01235, "epss_percentile": 0.78761}, "CVE-2005-1825": {"epss_score": 0.21088, "epss_percentile": 0.95461}, "CVE-2005-1826": {"epss_score": 0.05891, "epss_percentile": 0.90299}, "CVE-2005-1827": {"epss_score": 0.04723, "epss_percentile": 0.89058}, "CVE-2005-1828": {"epss_score": 0.00602, "epss_percentile": 0.68876}, "CVE-2005-1829": {"epss_score": 0.08459, "epss_percentile": 0.92063}, "CVE-2005-1830": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2005-1831": {"epss_score": 0.0025, "epss_percentile": 0.48089}, "CVE-2005-1832": {"epss_score": 0.0043, "epss_percentile": 0.62013}, "CVE-2005-1833": {"epss_score": 0.01042, "epss_percentile": 0.76978}, "CVE-2005-1834": {"epss_score": 0.01784, "epss_percentile": 0.8225}, "CVE-2005-1835": {"epss_score": 0.00676, "epss_percentile": 0.70932}, "CVE-2005-1836": {"epss_score": 0.02944, "epss_percentile": 0.86038}, "CVE-2005-1837": {"epss_score": 0.00345, "epss_percentile": 0.56569}, "CVE-2005-1838": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-1839": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-1840": {"epss_score": 0.02118, "epss_percentile": 0.83668}, "CVE-2005-1841": {"epss_score": 0.00103, "epss_percentile": 0.29049}, "CVE-2005-1842": {"epss_score": 0.00296, "epss_percentile": 0.52546}, "CVE-2005-1843": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2005-1846": {"epss_score": 0.00378, "epss_percentile": 0.58835}, "CVE-2005-1847": {"epss_score": 0.01329, "epss_percentile": 0.79504}, "CVE-2005-1848": {"epss_score": 0.00975, "epss_percentile": 0.76198}, "CVE-2005-1849": {"epss_score": 0.0514, "epss_percentile": 0.89538}, "CVE-2005-1850": {"epss_score": 0.00446, "epss_percentile": 0.62909}, "CVE-2005-1851": {"epss_score": 0.00446, "epss_percentile": 0.62909}, "CVE-2005-1852": {"epss_score": 0.05578, "epss_percentile": 0.90015}, "CVE-2005-1853": {"epss_score": 0.00046, "epss_percentile": 0.14343}, "CVE-2005-1854": {"epss_score": 0.01014, "epss_percentile": 0.76646}, "CVE-2005-1855": {"epss_score": 0.00059, "epss_percentile": 0.18721}, "CVE-2005-1856": {"epss_score": 0.00078, "epss_percentile": 0.23686}, "CVE-2005-1857": {"epss_score": 0.01552, "epss_percentile": 0.80993}, "CVE-2005-1858": {"epss_score": 0.00182, "epss_percentile": 0.40274}, "CVE-2005-1859": {"epss_score": 0.00048, "epss_percentile": 0.15135}, "CVE-2005-1864": {"epss_score": 0.00375, "epss_percentile": 0.58624}, "CVE-2005-1865": {"epss_score": 0.02041, "epss_percentile": 0.83372}, "CVE-2005-1866": {"epss_score": 0.0043, "epss_percentile": 0.62013}, "CVE-2005-1867": {"epss_score": 0.01133, "epss_percentile": 0.77881}, "CVE-2005-1868": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2005-1869": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2005-1870": {"epss_score": 0.04071, "epss_percentile": 0.88205}, "CVE-2005-1871": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-1872": {"epss_score": 0.05181, "epss_percentile": 0.8958}, "CVE-2005-1873": {"epss_score": 0.05386, "epss_percentile": 0.89821}, "CVE-2005-1874": {"epss_score": 0.01358, "epss_percentile": 0.79732}, "CVE-2005-1875": {"epss_score": 0.00731, "epss_percentile": 0.72163}, "CVE-2005-1876": {"epss_score": 0.0074, "epss_percentile": 0.72403}, "CVE-2005-1877": {"epss_score": 0.00364, "epss_percentile": 0.57938}, "CVE-2005-1878": {"epss_score": 0.0007, "epss_percentile": 0.2183}, "CVE-2005-1879": {"epss_score": 0.00044, "epss_percentile": 0.13585}, "CVE-2005-1880": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2005-1881": {"epss_score": 0.06748, "epss_percentile": 0.91}, "CVE-2005-1882": {"epss_score": 0.02256, "epss_percentile": 0.84169}, "CVE-2005-1883": {"epss_score": 0.00517, "epss_percentile": 0.66091}, "CVE-2005-1884": {"epss_score": 0.04002, "epss_percentile": 0.88094}, "CVE-2005-1885": {"epss_score": 0.00517, "epss_percentile": 0.66091}, "CVE-2005-1886": {"epss_score": 0.01649, "epss_percentile": 0.81556}, "CVE-2005-1887": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2005-1888": {"epss_score": 0.00364, "epss_percentile": 0.57938}, "CVE-2005-1889": {"epss_score": 0.0035, "epss_percentile": 0.56949}, "CVE-2005-1890": {"epss_score": 0.00305, "epss_percentile": 0.53319}, "CVE-2005-1891": {"epss_score": 0.01414, "epss_percentile": 0.80126}, "CVE-2005-1892": {"epss_score": 0.01029, "epss_percentile": 0.7683}, "CVE-2005-1893": {"epss_score": 0.06508, "epss_percentile": 0.90808}, "CVE-2005-1894": {"epss_score": 0.08916, "epss_percentile": 0.92317}, "CVE-2005-1895": {"epss_score": 0.04439, "epss_percentile": 0.88692}, "CVE-2005-1896": {"epss_score": 0.00903, "epss_percentile": 0.75198}, "CVE-2005-1897": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2005-1898": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-1899": {"epss_score": 0.04589, "epss_percentile": 0.88891}, "CVE-2005-1900": {"epss_score": 0.01034, "epss_percentile": 0.76887}, "CVE-2005-1901": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-1902": {"epss_score": 0.03096, "epss_percentile": 0.86404}, "CVE-2005-1903": {"epss_score": 0.03286, "epss_percentile": 0.86825}, "CVE-2005-1904": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-1905": {"epss_score": 0.00148, "epss_percentile": 0.35809}, "CVE-2005-1906": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-1907": {"epss_score": 0.25484, "epss_percentile": 0.96034}, "CVE-2005-1908": {"epss_score": 0.00524, "epss_percentile": 0.66339}, "CVE-2005-1909": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-1910": {"epss_score": 0.0069, "epss_percentile": 0.7124}, "CVE-2005-1911": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2005-1913": {"epss_score": 0.00063, "epss_percentile": 0.19964}, "CVE-2005-1914": {"epss_score": 0.00182, "epss_percentile": 0.40233}, "CVE-2005-1915": {"epss_score": 0.00098, "epss_percentile": 0.27781}, "CVE-2005-1916": {"epss_score": 0.00042, "epss_percentile": 0.12914}, "CVE-2005-1917": {"epss_score": 0.00078, "epss_percentile": 0.23686}, "CVE-2005-1918": {"epss_score": 0.02059, "epss_percentile": 0.83434}, "CVE-2005-1920": {"epss_score": 0.02823, "epss_percentile": 0.85749}, "CVE-2005-1921": {"epss_score": 0.86153, "epss_percentile": 0.9937}, "CVE-2005-1922": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2005-1923": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-1924": {"epss_score": 0.0949, "epss_percentile": 0.92571}, "CVE-2005-1925": {"epss_score": 0.00667, "epss_percentile": 0.70716}, "CVE-2005-1928": {"epss_score": 0.04507, "epss_percentile": 0.88775}, "CVE-2005-1929": {"epss_score": 0.04754, "epss_percentile": 0.89109}, "CVE-2005-1930": {"epss_score": 0.00873, "epss_percentile": 0.74749}, "CVE-2005-1931": {"epss_score": 0.04014, "epss_percentile": 0.8812}, "CVE-2005-1932": {"epss_score": 0.00214, "epss_percentile": 0.44004}, "CVE-2005-1933": {"epss_score": 0.01254, "epss_percentile": 0.78919}, "CVE-2005-1934": {"epss_score": 0.02458, "epss_percentile": 0.84814}, "CVE-2005-1935": {"epss_score": 0.32706, "epss_percentile": 0.96718}, "CVE-2005-1936": {"epss_score": 0.00666, "epss_percentile": 0.70678}, "CVE-2005-1937": {"epss_score": 0.00797, "epss_percentile": 0.735}, "CVE-2005-1939": {"epss_score": 0.43311, "epss_percentile": 0.97381}, "CVE-2005-1941": {"epss_score": 0.00137, "epss_percentile": 0.34307}, "CVE-2005-1942": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2005-1943": {"epss_score": 0.01073, "epss_percentile": 0.77283}, "CVE-2005-1944": {"epss_score": 0.00074, "epss_percentile": 0.22848}, "CVE-2005-1945": {"epss_score": 0.00441, "epss_percentile": 0.6268}, "CVE-2005-1946": {"epss_score": 0.0065, "epss_percentile": 0.70268}, "CVE-2005-1947": {"epss_score": 0.00974, "epss_percentile": 0.76171}, "CVE-2005-1948": {"epss_score": 0.00359, "epss_percentile": 0.57603}, "CVE-2005-1949": {"epss_score": 0.01014, "epss_percentile": 0.76646}, "CVE-2005-1950": {"epss_score": 0.11349, "epss_percentile": 0.9332}, "CVE-2005-1951": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2005-1952": {"epss_score": 0.01728, "epss_percentile": 0.81971}, "CVE-2005-1953": {"epss_score": 0.03422, "epss_percentile": 0.87106}, "CVE-2005-1954": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-1955": {"epss_score": 0.00442, "epss_percentile": 0.627}, "CVE-2005-1956": {"epss_score": 0.00219, "epss_percentile": 0.44501}, "CVE-2005-1957": {"epss_score": 0.00842, "epss_percentile": 0.74242}, "CVE-2005-1959": {"epss_score": 0.05053, "epss_percentile": 0.89445}, "CVE-2005-1960": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2005-1961": {"epss_score": 0.00053, "epss_percentile": 0.16907}, "CVE-2005-1962": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-1963": {"epss_score": 0.0059, "epss_percentile": 0.6855}, "CVE-2005-1964": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-1965": {"epss_score": 0.04415, "epss_percentile": 0.88664}, "CVE-2005-1966": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2005-1967": {"epss_score": 0.0078, "epss_percentile": 0.73175}, "CVE-2005-1968": {"epss_score": 0.00331, "epss_percentile": 0.55548}, "CVE-2005-1969": {"epss_score": 0.00364, "epss_percentile": 0.57938}, "CVE-2005-1970": {"epss_score": 0.00074, "epss_percentile": 0.2287}, "CVE-2005-1971": {"epss_score": 0.00437, "epss_percentile": 0.62519}, "CVE-2005-1972": {"epss_score": 0.00375, "epss_percentile": 0.58631}, "CVE-2005-1973": {"epss_score": 0.00408, "epss_percentile": 0.6068}, "CVE-2005-1974": {"epss_score": 0.01019, "epss_percentile": 0.76719}, "CVE-2005-1975": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-1976": {"epss_score": 0.00071, "epss_percentile": 0.2216}, "CVE-2005-1978": {"epss_score": 0.4804, "epss_percentile": 0.97615}, "CVE-2005-1979": {"epss_score": 0.78938, "epss_percentile": 0.99012}, "CVE-2005-1980": {"epss_score": 0.69839, "epss_percentile": 0.98606}, "CVE-2005-1981": {"epss_score": 0.0167, "epss_percentile": 0.81669}, "CVE-2005-1982": {"epss_score": 0.00906, "epss_percentile": 0.75252}, "CVE-2005-1983": {"epss_score": 0.87815, "epss_percentile": 0.99446}, "CVE-2005-1984": {"epss_score": 0.26328, "epss_percentile": 0.96137}, "CVE-2005-1985": {"epss_score": 0.46172, "epss_percentile": 0.97534}, "CVE-2005-1987": {"epss_score": 0.57021, "epss_percentile": 0.98045}, "CVE-2005-1988": {"epss_score": 0.83438, "epss_percentile": 0.99248}, "CVE-2005-1989": {"epss_score": 0.62784, "epss_percentile": 0.98308}, "CVE-2005-1990": {"epss_score": 0.82179, "epss_percentile": 0.99178}, "CVE-2005-1992": {"epss_score": 0.08762, "epss_percentile": 0.92244}, "CVE-2005-1993": {"epss_score": 0.0007, "epss_percentile": 0.2171}, "CVE-2005-1994": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-1995": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2005-1996": {"epss_score": 0.00684, "epss_percentile": 0.71123}, "CVE-2005-1997": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2005-1998": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2005-1999": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-2000": {"epss_score": 0.00642, "epss_percentile": 0.70028}, "CVE-2005-2001": {"epss_score": 0.00539, "epss_percentile": 0.66986}, "CVE-2005-2002": {"epss_score": 0.01342, "epss_percentile": 0.79595}, "CVE-2005-2003": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-2004": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-2005": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2005-2006": {"epss_score": 0.1459, "epss_percentile": 0.94246}, "CVE-2005-2007": {"epss_score": 0.01301, "epss_percentile": 0.7929}, "CVE-2005-2008": {"epss_score": 0.00457, "epss_percentile": 0.63389}, "CVE-2005-2009": {"epss_score": 0.00997, "epss_percentile": 0.76461}, "CVE-2005-2010": {"epss_score": 0.05403, "epss_percentile": 0.89836}, "CVE-2005-2011": {"epss_score": 0.00446, "epss_percentile": 0.62915}, "CVE-2005-2012": {"epss_score": 0.01002, "epss_percentile": 0.76507}, "CVE-2005-2013": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2005-2014": {"epss_score": 0.00206, "epss_percentile": 0.42932}, "CVE-2005-2017": {"epss_score": 0.00445, "epss_percentile": 0.6286}, "CVE-2005-2019": {"epss_score": 0.00219, "epss_percentile": 0.44501}, "CVE-2005-2020": {"epss_score": 0.0384, "epss_percentile": 0.87831}, "CVE-2005-2021": {"epss_score": 0.00337, "epss_percentile": 0.5603}, "CVE-2005-2022": {"epss_score": 0.00349, "epss_percentile": 0.5686}, "CVE-2005-2023": {"epss_score": 0.00471, "epss_percentile": 0.64007}, "CVE-2005-2024": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2005-2025": {"epss_score": 0.00501, "epss_percentile": 0.65356}, "CVE-2005-2026": {"epss_score": 0.00554, "epss_percentile": 0.67437}, "CVE-2005-2027": {"epss_score": 0.00305, "epss_percentile": 0.53319}, "CVE-2005-2028": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2005-2029": {"epss_score": 0.00654, "epss_percentile": 0.7034}, "CVE-2005-2030": {"epss_score": 0.01545, "epss_percentile": 0.80963}, "CVE-2005-2031": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2005-2032": {"epss_score": 0.00058, "epss_percentile": 0.18274}, "CVE-2005-2033": {"epss_score": 0.02822, "epss_percentile": 0.85745}, "CVE-2005-2034": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2035": {"epss_score": 0.00644, "epss_percentile": 0.70086}, "CVE-2005-2036": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2005-2037": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-2038": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2005-2039": {"epss_score": 0.00521, "epss_percentile": 0.66223}, "CVE-2005-2040": {"epss_score": 0.02015, "epss_percentile": 0.8327}, "CVE-2005-2041": {"epss_score": 0.10307, "epss_percentile": 0.92937}, "CVE-2005-2042": {"epss_score": 0.00376, "epss_percentile": 0.58656}, "CVE-2005-2043": {"epss_score": 0.00473, "epss_percentile": 0.64105}, "CVE-2005-2044": {"epss_score": 0.01232, "epss_percentile": 0.78737}, "CVE-2005-2045": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2005-2046": {"epss_score": 0.00255, "epss_percentile": 0.48696}, "CVE-2005-2047": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2005-2048": {"epss_score": 0.00354, "epss_percentile": 0.57201}, "CVE-2005-2049": {"epss_score": 0.00321, "epss_percentile": 0.54693}, "CVE-2005-2050": {"epss_score": 0.00638, "epss_percentile": 0.69905}, "CVE-2005-2051": {"epss_score": 0.04341, "epss_percentile": 0.8857}, "CVE-2005-2052": {"epss_score": 0.02908, "epss_percentile": 0.85967}, "CVE-2005-2053": {"epss_score": 0.00312, "epss_percentile": 0.54007}, "CVE-2005-2054": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-2055": {"epss_score": 0.0034, "epss_percentile": 0.56225}, "CVE-2005-2056": {"epss_score": 0.01101, "epss_percentile": 0.77574}, "CVE-2005-2057": {"epss_score": 0.01171, "epss_percentile": 0.78224}, "CVE-2005-2058": {"epss_score": 0.0054, "epss_percentile": 0.67018}, "CVE-2005-2059": {"epss_score": 0.00325, "epss_percentile": 0.55033}, "CVE-2005-2060": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-2061": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2005-2062": {"epss_score": 0.0236, "epss_percentile": 0.84493}, "CVE-2005-2063": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2064": {"epss_score": 0.04079, "epss_percentile": 0.88216}, "CVE-2005-2065": {"epss_score": 0.04111, "epss_percentile": 0.88272}, "CVE-2005-2066": {"epss_score": 0.01462, "epss_percentile": 0.80435}, "CVE-2005-2067": {"epss_score": 0.01462, "epss_percentile": 0.80435}, "CVE-2005-2068": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2005-2069": {"epss_score": 0.02839, "epss_percentile": 0.85796}, "CVE-2005-2070": {"epss_score": 0.00952, "epss_percentile": 0.75873}, "CVE-2005-2071": {"epss_score": 0.0022, "epss_percentile": 0.44566}, "CVE-2005-2072": {"epss_score": 0.00292, "epss_percentile": 0.52254}, "CVE-2005-2073": {"epss_score": 0.00056, "epss_percentile": 0.17734}, "CVE-2005-2074": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-2075": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2005-2076": {"epss_score": 0.00194, "epss_percentile": 0.41598}, "CVE-2005-2077": {"epss_score": 0.00655, "epss_percentile": 0.70428}, "CVE-2005-2078": {"epss_score": 0.00611, "epss_percentile": 0.69184}, "CVE-2005-2079": {"epss_score": 0.14495, "epss_percentile": 0.94223}, "CVE-2005-2080": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-2081": {"epss_score": 0.00347, "epss_percentile": 0.56768}, "CVE-2005-2082": {"epss_score": 0.00479, "epss_percentile": 0.64437}, "CVE-2005-2083": {"epss_score": 0.04186, "epss_percentile": 0.88363}, "CVE-2005-2084": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2085": {"epss_score": 0.0642, "epss_percentile": 0.90749}, "CVE-2005-2086": {"epss_score": 0.86512, "epss_percentile": 0.99386}, "CVE-2005-2087": {"epss_score": 0.65273, "epss_percentile": 0.9841}, "CVE-2005-2088": {"epss_score": 0.54293, "epss_percentile": 0.97918}, "CVE-2005-2089": {"epss_score": 0.35633, "epss_percentile": 0.96923}, "CVE-2005-2090": {"epss_score": 0.8199, "epss_percentile": 0.99168}, "CVE-2005-2091": {"epss_score": 0.01653, "epss_percentile": 0.81582}, "CVE-2005-2092": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2005-2093": {"epss_score": 0.02589, "epss_percentile": 0.85179}, "CVE-2005-2094": {"epss_score": 0.01559, "epss_percentile": 0.81034}, "CVE-2005-2095": {"epss_score": 0.1115, "epss_percentile": 0.9324}, "CVE-2005-2096": {"epss_score": 0.43032, "epss_percentile": 0.97368}, "CVE-2005-2097": {"epss_score": 0.00072, "epss_percentile": 0.22352}, "CVE-2005-2098": {"epss_score": 0.03007, "epss_percentile": 0.86186}, "CVE-2005-2099": {"epss_score": 0.0383, "epss_percentile": 0.87806}, "CVE-2005-2100": {"epss_score": 0.00058, "epss_percentile": 0.18432}, "CVE-2005-2101": {"epss_score": 0.00646, "epss_percentile": 0.70135}, "CVE-2005-2102": {"epss_score": 0.01252, "epss_percentile": 0.78903}, "CVE-2005-2103": {"epss_score": 0.25854, "epss_percentile": 0.96085}, "CVE-2005-2104": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2005-2105": {"epss_score": 0.00783, "epss_percentile": 0.73226}, "CVE-2005-2106": {"epss_score": 0.05241, "epss_percentile": 0.89652}, "CVE-2005-2107": {"epss_score": 0.00912, "epss_percentile": 0.7536}, "CVE-2005-2108": {"epss_score": 0.01061, "epss_percentile": 0.77173}, "CVE-2005-2109": {"epss_score": 0.01077, "epss_percentile": 0.77336}, "CVE-2005-2110": {"epss_score": 0.01227, "epss_percentile": 0.78702}, "CVE-2005-2111": {"epss_score": 0.02883, "epss_percentile": 0.85905}, "CVE-2005-2112": {"epss_score": 0.00558, "epss_percentile": 0.67575}, "CVE-2005-2113": {"epss_score": 0.00973, "epss_percentile": 0.76158}, "CVE-2005-2114": {"epss_score": 0.04323, "epss_percentile": 0.8855}, "CVE-2005-2115": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2005-2117": {"epss_score": 0.46533, "epss_percentile": 0.97551}, "CVE-2005-2118": {"epss_score": 0.4246, "epss_percentile": 0.97333}, "CVE-2005-2119": {"epss_score": 0.59348, "epss_percentile": 0.98161}, "CVE-2005-2120": {"epss_score": 0.75725, "epss_percentile": 0.98862}, "CVE-2005-2122": {"epss_score": 0.53961, "epss_percentile": 0.97905}, "CVE-2005-2123": {"epss_score": 0.696, "epss_percentile": 0.98594}, "CVE-2005-2124": {"epss_score": 0.83167, "epss_percentile": 0.99236}, "CVE-2005-2126": {"epss_score": 0.50079, "epss_percentile": 0.97719}, "CVE-2005-2127": {"epss_score": 0.44569, "epss_percentile": 0.97444}, "CVE-2005-2128": {"epss_score": 0.38603, "epss_percentile": 0.97109}, "CVE-2005-2132": {"epss_score": 0.00284, "epss_percentile": 0.51437}, "CVE-2005-2134": {"epss_score": 0.00058, "epss_percentile": 0.18446}, "CVE-2005-2135": {"epss_score": 0.00509, "epss_percentile": 0.65745}, "CVE-2005-2136": {"epss_score": 0.00153, "epss_percentile": 0.36616}, "CVE-2005-2137": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-2138": {"epss_score": 0.00331, "epss_percentile": 0.55548}, "CVE-2005-2139": {"epss_score": 0.00463, "epss_percentile": 0.63674}, "CVE-2005-2140": {"epss_score": 0.06683, "epss_percentile": 0.90942}, "CVE-2005-2141": {"epss_score": 0.04128, "epss_percentile": 0.88292}, "CVE-2005-2142": {"epss_score": 0.00147, "epss_percentile": 0.35659}, "CVE-2005-2143": {"epss_score": 0.0979, "epss_percentile": 0.92703}, "CVE-2005-2144": {"epss_score": 0.00068, "epss_percentile": 0.21332}, "CVE-2005-2145": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2005-2146": {"epss_score": 0.0004, "epss_percentile": 0.12084}, "CVE-2005-2147": {"epss_score": 0.00425, "epss_percentile": 0.61724}, "CVE-2005-2148": {"epss_score": 0.04133, "epss_percentile": 0.88302}, "CVE-2005-2149": {"epss_score": 0.01293, "epss_percentile": 0.79241}, "CVE-2005-2150": {"epss_score": 0.26809, "epss_percentile": 0.96182}, "CVE-2005-2151": {"epss_score": 0.0034, "epss_percentile": 0.56225}, "CVE-2005-2152": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-2153": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-2154": {"epss_score": 0.01521, "epss_percentile": 0.80831}, "CVE-2005-2155": {"epss_score": 0.02109, "epss_percentile": 0.83642}, "CVE-2005-2156": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-2157": {"epss_score": 0.01449, "epss_percentile": 0.80341}, "CVE-2005-2158": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-2159": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2005-2160": {"epss_score": 0.01005, "epss_percentile": 0.76543}, "CVE-2005-2161": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-2162": {"epss_score": 0.01739, "epss_percentile": 0.82041}, "CVE-2005-2163": {"epss_score": 0.02914, "epss_percentile": 0.85977}, "CVE-2005-2164": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-2165": {"epss_score": 0.02164, "epss_percentile": 0.83837}, "CVE-2005-2166": {"epss_score": 0.00312, "epss_percentile": 0.53945}, "CVE-2005-2167": {"epss_score": 0.00281, "epss_percentile": 0.51106}, "CVE-2005-2168": {"epss_score": 0.00423, "epss_percentile": 0.61602}, "CVE-2005-2169": {"epss_score": 0.00298, "epss_percentile": 0.52807}, "CVE-2005-2170": {"epss_score": 0.01688, "epss_percentile": 0.81765}, "CVE-2005-2173": {"epss_score": 0.00384, "epss_percentile": 0.59124}, "CVE-2005-2174": {"epss_score": 0.00395, "epss_percentile": 0.59842}, "CVE-2005-2175": {"epss_score": 0.13188, "epss_percentile": 0.93895}, "CVE-2005-2176": {"epss_score": 0.04325, "epss_percentile": 0.88552}, "CVE-2005-2177": {"epss_score": 0.11098, "epss_percentile": 0.93218}, "CVE-2005-2178": {"epss_score": 0.02096, "epss_percentile": 0.83586}, "CVE-2005-2179": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2005-2180": {"epss_score": 0.00068, "epss_percentile": 0.21314}, "CVE-2005-2181": {"epss_score": 0.00363, "epss_percentile": 0.57902}, "CVE-2005-2182": {"epss_score": 0.0039, "epss_percentile": 0.59549}, "CVE-2005-2183": {"epss_score": 0.0066, "epss_percentile": 0.70532}, "CVE-2005-2184": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2005-2185": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-2186": {"epss_score": 0.00107, "epss_percentile": 0.2969}, "CVE-2005-2187": {"epss_score": 0.00312, "epss_percentile": 0.53955}, "CVE-2005-2188": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-2189": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2005-2190": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-2191": {"epss_score": 0.00409, "epss_percentile": 0.607}, "CVE-2005-2192": {"epss_score": 0.03544, "epss_percentile": 0.87322}, "CVE-2005-2193": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-2194": {"epss_score": 0.00574, "epss_percentile": 0.6807}, "CVE-2005-2195": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2005-2196": {"epss_score": 0.00071, "epss_percentile": 0.22057}, "CVE-2005-2197": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2005-2198": {"epss_score": 0.02961, "epss_percentile": 0.86072}, "CVE-2005-2199": {"epss_score": 0.02887, "epss_percentile": 0.85912}, "CVE-2005-2200": {"epss_score": 0.00693, "epss_percentile": 0.7133}, "CVE-2005-2201": {"epss_score": 0.00409, "epss_percentile": 0.60753}, "CVE-2005-2202": {"epss_score": 0.00364, "epss_percentile": 0.57938}, "CVE-2005-2203": {"epss_score": 0.00572, "epss_percentile": 0.6803}, "CVE-2005-2204": {"epss_score": 0.0096, "epss_percentile": 0.75964}, "CVE-2005-2205": {"epss_score": 0.02032, "epss_percentile": 0.83338}, "CVE-2005-2206": {"epss_score": 0.00451, "epss_percentile": 0.63116}, "CVE-2005-2207": {"epss_score": 0.00331, "epss_percentile": 0.55548}, "CVE-2005-2208": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2005-2209": {"epss_score": 0.00038, "epss_percentile": 0.11287}, "CVE-2005-2210": {"epss_score": 0.04788, "epss_percentile": 0.89145}, "CVE-2005-2211": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2005-2212": {"epss_score": 0.00257, "epss_percentile": 0.48861}, "CVE-2005-2213": {"epss_score": 0.03077, "epss_percentile": 0.86363}, "CVE-2005-2214": {"epss_score": 0.0005, "epss_percentile": 0.15736}, "CVE-2005-2215": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-2216": {"epss_score": 0.02432, "epss_percentile": 0.84729}, "CVE-2005-2217": {"epss_score": 0.00362, "epss_percentile": 0.5776}, "CVE-2005-2218": {"epss_score": 0.00065, "epss_percentile": 0.20672}, "CVE-2005-2219": {"epss_score": 0.00263, "epss_percentile": 0.49507}, "CVE-2005-2220": {"epss_score": 0.00741, "epss_percentile": 0.72413}, "CVE-2005-2221": {"epss_score": 0.00917, "epss_percentile": 0.75434}, "CVE-2005-2222": {"epss_score": 0.00259, "epss_percentile": 0.49097}, "CVE-2005-2223": {"epss_score": 0.0297, "epss_percentile": 0.86093}, "CVE-2005-2224": {"epss_score": 0.08592, "epss_percentile": 0.9214}, "CVE-2005-2225": {"epss_score": 0.11115, "epss_percentile": 0.93227}, "CVE-2005-2226": {"epss_score": 0.32268, "epss_percentile": 0.96685}, "CVE-2005-2227": {"epss_score": 0.00069, "epss_percentile": 0.21475}, "CVE-2005-2228": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2005-2229": {"epss_score": 0.03263, "epss_percentile": 0.86777}, "CVE-2005-2230": {"epss_score": 0.00084, "epss_percentile": 0.25015}, "CVE-2005-2231": {"epss_score": 0.00096, "epss_percentile": 0.27289}, "CVE-2005-2232": {"epss_score": 0.00328, "epss_percentile": 0.55286}, "CVE-2005-2233": {"epss_score": 0.00049, "epss_percentile": 0.15418}, "CVE-2005-2234": {"epss_score": 0.00054, "epss_percentile": 0.17135}, "CVE-2005-2235": {"epss_score": 0.00057, "epss_percentile": 0.1818}, "CVE-2005-2236": {"epss_score": 0.00608, "epss_percentile": 0.69074}, "CVE-2005-2237": {"epss_score": 0.00054, "epss_percentile": 0.17307}, "CVE-2005-2238": {"epss_score": 0.00139, "epss_percentile": 0.34647}, "CVE-2005-2239": {"epss_score": 0.0334, "epss_percentile": 0.86941}, "CVE-2005-2240": {"epss_score": 0.00098, "epss_percentile": 0.27692}, "CVE-2005-2241": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-2242": {"epss_score": 0.06333, "epss_percentile": 0.90675}, "CVE-2005-2243": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-2244": {"epss_score": 0.01384, "epss_percentile": 0.79898}, "CVE-2005-2245": {"epss_score": 0.00846, "epss_percentile": 0.74334}, "CVE-2005-2246": {"epss_score": 0.12977, "epss_percentile": 0.93834}, "CVE-2005-2247": {"epss_score": 0.00446, "epss_percentile": 0.62909}, "CVE-2005-2248": {"epss_score": 0.00242, "epss_percentile": 0.47369}, "CVE-2005-2249": {"epss_score": 0.00461, "epss_percentile": 0.63564}, "CVE-2005-2250": {"epss_score": 0.08976, "epss_percentile": 0.92346}, "CVE-2005-2251": {"epss_score": 0.04292, "epss_percentile": 0.88503}, "CVE-2005-2252": {"epss_score": 0.00572, "epss_percentile": 0.6803}, "CVE-2005-2253": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2005-2254": {"epss_score": 0.00389, "epss_percentile": 0.59467}, "CVE-2005-2255": {"epss_score": 0.00265, "epss_percentile": 0.49797}, "CVE-2005-2256": {"epss_score": 0.12524, "epss_percentile": 0.93707}, "CVE-2005-2257": {"epss_score": 0.0119, "epss_percentile": 0.7838}, "CVE-2005-2258": {"epss_score": 0.02871, "epss_percentile": 0.85874}, "CVE-2005-2259": {"epss_score": 0.0355, "epss_percentile": 0.87338}, "CVE-2005-2260": {"epss_score": 0.03727, "epss_percentile": 0.87634}, "CVE-2005-2261": {"epss_score": 0.04644, "epss_percentile": 0.88956}, "CVE-2005-2262": {"epss_score": 0.16001, "epss_percentile": 0.94552}, "CVE-2005-2263": {"epss_score": 0.04512, "epss_percentile": 0.88781}, "CVE-2005-2264": {"epss_score": 0.03226, "epss_percentile": 0.86686}, "CVE-2005-2265": {"epss_score": 0.82043, "epss_percentile": 0.99169}, "CVE-2005-2266": {"epss_score": 0.01946, "epss_percentile": 0.83004}, "CVE-2005-2267": {"epss_score": 0.05043, "epss_percentile": 0.89429}, "CVE-2005-2268": {"epss_score": 0.02156, "epss_percentile": 0.83808}, "CVE-2005-2269": {"epss_score": 0.07514, "epss_percentile": 0.91513}, "CVE-2005-2270": {"epss_score": 0.30045, "epss_percentile": 0.965}, "CVE-2005-2271": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-2272": {"epss_score": 0.01251, "epss_percentile": 0.78895}, "CVE-2005-2273": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-2274": {"epss_score": 0.22083, "epss_percentile": 0.95593}, "CVE-2005-2276": {"epss_score": 0.01463, "epss_percentile": 0.80442}, "CVE-2005-2277": {"epss_score": 0.07219, "epss_percentile": 0.91333}, "CVE-2005-2278": {"epss_score": 0.83285, "epss_percentile": 0.99242}, "CVE-2005-2279": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2005-2280": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-2281": {"epss_score": 0.00132, "epss_percentile": 0.33592}, "CVE-2005-2282": {"epss_score": 0.00708, "epss_percentile": 0.71674}, "CVE-2005-2283": {"epss_score": 0.0047, "epss_percentile": 0.63964}, "CVE-2005-2284": {"epss_score": 0.0045, "epss_percentile": 0.63074}, "CVE-2005-2285": {"epss_score": 0.00476, "epss_percentile": 0.64268}, "CVE-2005-2286": {"epss_score": 0.01199, "epss_percentile": 0.78459}, "CVE-2005-2287": {"epss_score": 0.79843, "epss_percentile": 0.99058}, "CVE-2005-2288": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-2289": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-2290": {"epss_score": 0.03285, "epss_percentile": 0.86822}, "CVE-2005-2291": {"epss_score": 0.00798, "epss_percentile": 0.7351}, "CVE-2005-2292": {"epss_score": 0.00331, "epss_percentile": 0.55549}, "CVE-2005-2293": {"epss_score": 0.00158, "epss_percentile": 0.37227}, "CVE-2005-2294": {"epss_score": 0.00276, "epss_percentile": 0.50767}, "CVE-2005-2295": {"epss_score": 0.09341, "epss_percentile": 0.92508}, "CVE-2005-2296": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-2297": {"epss_score": 0.71529, "epss_percentile": 0.98671}, "CVE-2005-2298": {"epss_score": 0.00219, "epss_percentile": 0.44501}, "CVE-2005-2299": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2005-2300": {"epss_score": 0.00103, "epss_percentile": 0.29089}, "CVE-2005-2301": {"epss_score": 0.00074, "epss_percentile": 0.22867}, "CVE-2005-2302": {"epss_score": 7e-05, "epss_percentile": 0.00375}, "CVE-2005-2304": {"epss_score": 0.1195, "epss_percentile": 0.93524}, "CVE-2005-2305": {"epss_score": 0.07307, "epss_percentile": 0.91397}, "CVE-2005-2306": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2005-2307": {"epss_score": 0.4672, "epss_percentile": 0.97555}, "CVE-2005-2308": {"epss_score": 0.45838, "epss_percentile": 0.97504}, "CVE-2005-2309": {"epss_score": 0.01856, "epss_percentile": 0.82568}, "CVE-2005-2310": {"epss_score": 0.0772, "epss_percentile": 0.91642}, "CVE-2005-2311": {"epss_score": 0.00078, "epss_percentile": 0.23686}, "CVE-2005-2312": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-2313": {"epss_score": 0.00054, "epss_percentile": 0.17248}, "CVE-2005-2314": {"epss_score": 0.00706, "epss_percentile": 0.7161}, "CVE-2005-2315": {"epss_score": 0.049, "epss_percentile": 0.89273}, "CVE-2005-2316": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2005-2317": {"epss_score": 0.00993, "epss_percentile": 0.76411}, "CVE-2005-2318": {"epss_score": 0.00558, "epss_percentile": 0.676}, "CVE-2005-2319": {"epss_score": 0.00524, "epss_percentile": 0.66329}, "CVE-2005-2320": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2005-2321": {"epss_score": 0.01983, "epss_percentile": 0.83146}, "CVE-2005-2322": {"epss_score": 0.00731, "epss_percentile": 0.72177}, "CVE-2005-2323": {"epss_score": 0.00752, "epss_percentile": 0.72652}, "CVE-2005-2324": {"epss_score": 0.00301, "epss_percentile": 0.53046}, "CVE-2005-2325": {"epss_score": 0.00362, "epss_percentile": 0.5776}, "CVE-2005-2326": {"epss_score": 0.00337, "epss_percentile": 0.5603}, "CVE-2005-2327": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2005-2328": {"epss_score": 0.00448, "epss_percentile": 0.63026}, "CVE-2005-2329": {"epss_score": 0.00438, "epss_percentile": 0.62567}, "CVE-2005-2330": {"epss_score": 0.10018, "epss_percentile": 0.92818}, "CVE-2005-2331": {"epss_score": 0.00463, "epss_percentile": 0.63674}, "CVE-2005-2332": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-2333": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-2334": {"epss_score": 0.02459, "epss_percentile": 0.84817}, "CVE-2005-2335": {"epss_score": 0.06437, "epss_percentile": 0.90757}, "CVE-2005-2336": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-2337": {"epss_score": 0.23924, "epss_percentile": 0.95834}, "CVE-2005-2338": {"epss_score": 0.01296, "epss_percentile": 0.79256}, "CVE-2005-2339": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2340": {"epss_score": 0.63968, "epss_percentile": 0.98357}, "CVE-2005-2341": {"epss_score": 0.02385, "epss_percentile": 0.84576}, "CVE-2005-2342": {"epss_score": 0.04171, "epss_percentile": 0.88347}, "CVE-2005-2343": {"epss_score": 0.01951, "epss_percentile": 0.83017}, "CVE-2005-2344": {"epss_score": 0.02019, "epss_percentile": 0.83289}, "CVE-2005-2346": {"epss_score": 0.02053, "epss_percentile": 0.83416}, "CVE-2005-2349": {"epss_score": 0.00355, "epss_percentile": 0.57264}, "CVE-2005-2350": {"epss_score": 0.00429, "epss_percentile": 0.61969}, "CVE-2005-2351": {"epss_score": 0.00132, "epss_percentile": 0.33571}, "CVE-2005-2352": {"epss_score": 0.00324, "epss_percentile": 0.54947}, "CVE-2005-2353": {"epss_score": 0.00079, "epss_percentile": 0.23905}, "CVE-2005-2354": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2005-2357": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2005-2358": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2005-2359": {"epss_score": 0.00364, "epss_percentile": 0.57904}, "CVE-2005-2360": {"epss_score": 0.01824, "epss_percentile": 0.82429}, "CVE-2005-2361": {"epss_score": 0.01824, "epss_percentile": 0.82429}, "CVE-2005-2362": {"epss_score": 0.01344, "epss_percentile": 0.79618}, "CVE-2005-2363": {"epss_score": 0.02161, "epss_percentile": 0.83826}, "CVE-2005-2364": {"epss_score": 0.02161, "epss_percentile": 0.83826}, "CVE-2005-2365": {"epss_score": 0.01561, "epss_percentile": 0.81041}, "CVE-2005-2366": {"epss_score": 0.02115, "epss_percentile": 0.83657}, "CVE-2005-2367": {"epss_score": 0.19352, "epss_percentile": 0.95168}, "CVE-2005-2368": {"epss_score": 0.01518, "epss_percentile": 0.80813}, "CVE-2005-2369": {"epss_score": 0.01955, "epss_percentile": 0.83036}, "CVE-2005-2370": {"epss_score": 0.01928, "epss_percentile": 0.82932}, "CVE-2005-2371": {"epss_score": 0.03626, "epss_percentile": 0.8746}, "CVE-2005-2372": {"epss_score": 0.02589, "epss_percentile": 0.85177}, "CVE-2005-2373": {"epss_score": 0.37407, "epss_percentile": 0.97043}, "CVE-2005-2374": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2005-2375": {"epss_score": 0.00786, "epss_percentile": 0.73286}, "CVE-2005-2376": {"epss_score": 0.00857, "epss_percentile": 0.74491}, "CVE-2005-2377": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2005-2378": {"epss_score": 0.03517, "epss_percentile": 0.87279}, "CVE-2005-2379": {"epss_score": 0.00625, "epss_percentile": 0.69597}, "CVE-2005-2380": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2381": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-2382": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2005-2383": {"epss_score": 0.00362, "epss_percentile": 0.57797}, "CVE-2005-2384": {"epss_score": 0.02456, "epss_percentile": 0.84799}, "CVE-2005-2385": {"epss_score": 0.03994, "epss_percentile": 0.88083}, "CVE-2005-2386": {"epss_score": 0.00868, "epss_percentile": 0.74668}, "CVE-2005-2387": {"epss_score": 0.04561, "epss_percentile": 0.88853}, "CVE-2005-2388": {"epss_score": 0.01057, "epss_percentile": 0.77133}, "CVE-2005-2389": {"epss_score": 0.00419, "epss_percentile": 0.61355}, "CVE-2005-2390": {"epss_score": 0.01235, "epss_percentile": 0.78763}, "CVE-2005-2391": {"epss_score": 0.00331, "epss_percentile": 0.55544}, "CVE-2005-2392": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2005-2393": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-2394": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2005-2395": {"epss_score": 0.00794, "epss_percentile": 0.73456}, "CVE-2005-2396": {"epss_score": 0.00613, "epss_percentile": 0.69248}, "CVE-2005-2397": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2005-2398": {"epss_score": 0.02077, "epss_percentile": 0.83516}, "CVE-2005-2399": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-2400": {"epss_score": 0.00552, "epss_percentile": 0.67386}, "CVE-2005-2401": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2005-2402": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2005-2403": {"epss_score": 0.00669, "epss_percentile": 0.7076}, "CVE-2005-2404": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-2405": {"epss_score": 0.01336, "epss_percentile": 0.79553}, "CVE-2005-2406": {"epss_score": 0.00485, "epss_percentile": 0.64673}, "CVE-2005-2407": {"epss_score": 0.01113, "epss_percentile": 0.77688}, "CVE-2005-2409": {"epss_score": 0.11452, "epss_percentile": 0.93365}, "CVE-2005-2410": {"epss_score": 0.02051, "epss_percentile": 0.83407}, "CVE-2005-2411": {"epss_score": 0.00926, "epss_percentile": 0.75557}, "CVE-2005-2412": {"epss_score": 0.03198, "epss_percentile": 0.86616}, "CVE-2005-2413": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2005-2414": {"epss_score": 0.05003, "epss_percentile": 0.8938}, "CVE-2005-2415": {"epss_score": 0.01596, "epss_percentile": 0.81239}, "CVE-2005-2416": {"epss_score": 0.00903, "epss_percentile": 0.75205}, "CVE-2005-2417": {"epss_score": 0.00704, "epss_percentile": 0.71565}, "CVE-2005-2419": {"epss_score": 0.00743, "epss_percentile": 0.72465}, "CVE-2005-2420": {"epss_score": 0.06535, "epss_percentile": 0.90828}, "CVE-2005-2421": {"epss_score": 0.00593, "epss_percentile": 0.68647}, "CVE-2005-2422": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-2423": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-2424": {"epss_score": 0.01642, "epss_percentile": 0.81507}, "CVE-2005-2425": {"epss_score": 0.03783, "epss_percentile": 0.87722}, "CVE-2005-2426": {"epss_score": 0.01109, "epss_percentile": 0.77654}, "CVE-2005-2427": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-2428": {"epss_score": 0.08605, "epss_percentile": 0.92146}, "CVE-2005-2429": {"epss_score": 0.00296, "epss_percentile": 0.52605}, "CVE-2005-2430": {"epss_score": 0.01282, "epss_percentile": 0.79154}, "CVE-2005-2431": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-2432": {"epss_score": 0.00698, "epss_percentile": 0.71415}, "CVE-2005-2433": {"epss_score": 0.01364, "epss_percentile": 0.79771}, "CVE-2005-2434": {"epss_score": 0.0026, "epss_percentile": 0.49177}, "CVE-2005-2435": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-2436": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-2437": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-2438": {"epss_score": 0.00638, "epss_percentile": 0.69929}, "CVE-2005-2439": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-2440": {"epss_score": 0.00731, "epss_percentile": 0.72163}, "CVE-2005-2441": {"epss_score": 0.00919, "epss_percentile": 0.7546}, "CVE-2005-2442": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2005-2443": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2005-2444": {"epss_score": 0.0007, "epss_percentile": 0.21778}, "CVE-2005-2445": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2005-2448": {"epss_score": 0.01928, "epss_percentile": 0.82932}, "CVE-2005-2449": {"epss_score": 0.00098, "epss_percentile": 0.27781}, "CVE-2005-2450": {"epss_score": 0.03642, "epss_percentile": 0.87493}, "CVE-2005-2451": {"epss_score": 0.03036, "epss_percentile": 0.86262}, "CVE-2005-2452": {"epss_score": 0.01344, "epss_percentile": 0.79618}, "CVE-2005-2453": {"epss_score": 0.01061, "epss_percentile": 0.77175}, "CVE-2005-2454": {"epss_score": 0.00076, "epss_percentile": 0.23271}, "CVE-2005-2455": {"epss_score": 0.08545, "epss_percentile": 0.92116}, "CVE-2005-2456": {"epss_score": 0.00116, "epss_percentile": 0.31065}, "CVE-2005-2457": {"epss_score": 0.04853, "epss_percentile": 0.89216}, "CVE-2005-2458": {"epss_score": 0.12945, "epss_percentile": 0.93825}, "CVE-2005-2459": {"epss_score": 0.05311, "epss_percentile": 0.89718}, "CVE-2005-2460": {"epss_score": 0.0335, "epss_percentile": 0.86961}, "CVE-2005-2461": {"epss_score": 0.00543, "epss_percentile": 0.67113}, "CVE-2005-2462": {"epss_score": 0.00208, "epss_percentile": 0.433}, "CVE-2005-2463": {"epss_score": 0.0059, "epss_percentile": 0.6855}, "CVE-2005-2464": {"epss_score": 0.00455, "epss_percentile": 0.63307}, "CVE-2005-2465": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-2466": {"epss_score": 0.00553, "epss_percentile": 0.6742}, "CVE-2005-2467": {"epss_score": 0.0207, "epss_percentile": 0.83471}, "CVE-2005-2468": {"epss_score": 0.01277, "epss_percentile": 0.79114}, "CVE-2005-2469": {"epss_score": 0.00141, "epss_percentile": 0.34829}, "CVE-2005-2470": {"epss_score": 0.05582, "epss_percentile": 0.9002}, "CVE-2005-2471": {"epss_score": 0.02055, "epss_percentile": 0.83421}, "CVE-2005-2472": {"epss_score": 0.24624, "epss_percentile": 0.95941}, "CVE-2005-2473": {"epss_score": 0.02117, "epss_percentile": 0.83667}, "CVE-2005-2474": {"epss_score": 0.01094, "epss_percentile": 0.77489}, "CVE-2005-2475": {"epss_score": 0.00078, "epss_percentile": 0.23615}, "CVE-2005-2476": {"epss_score": 0.00565, "epss_percentile": 0.67789}, "CVE-2005-2477": {"epss_score": 0.00401, "epss_percentile": 0.60255}, "CVE-2005-2478": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2005-2479": {"epss_score": 0.05912, "epss_percentile": 0.90316}, "CVE-2005-2480": {"epss_score": 0.00398, "epss_percentile": 0.60078}, "CVE-2005-2481": {"epss_score": 0.00297, "epss_percentile": 0.52695}, "CVE-2005-2482": {"epss_score": 0.00488, "epss_percentile": 0.64841}, "CVE-2005-2483": {"epss_score": 0.07061, "epss_percentile": 0.9122}, "CVE-2005-2484": {"epss_score": 0.01412, "epss_percentile": 0.80113}, "CVE-2005-2485": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-2486": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2005-2487": {"epss_score": 0.00073, "epss_percentile": 0.22531}, "CVE-2005-2488": {"epss_score": 0.00567, "epss_percentile": 0.67839}, "CVE-2005-2489": {"epss_score": 0.01802, "epss_percentile": 0.82331}, "CVE-2005-2490": {"epss_score": 0.00186, "epss_percentile": 0.40632}, "CVE-2005-2491": {"epss_score": 0.01997, "epss_percentile": 0.83197}, "CVE-2005-2492": {"epss_score": 0.00071, "epss_percentile": 0.22155}, "CVE-2005-2494": {"epss_score": 0.00045, "epss_percentile": 0.13823}, "CVE-2005-2495": {"epss_score": 0.04263, "epss_percentile": 0.88465}, "CVE-2005-2496": {"epss_score": 0.00088, "epss_percentile": 0.25718}, "CVE-2005-2498": {"epss_score": 0.04688, "epss_percentile": 0.8901}, "CVE-2005-2499": {"epss_score": 0.00063, "epss_percentile": 0.20082}, "CVE-2005-2500": {"epss_score": 0.02584, "epss_percentile": 0.8516}, "CVE-2005-2501": {"epss_score": 0.0131, "epss_percentile": 0.79364}, "CVE-2005-2502": {"epss_score": 0.01006, "epss_percentile": 0.7655}, "CVE-2005-2503": {"epss_score": 0.00071, "epss_percentile": 0.22171}, "CVE-2005-2504": {"epss_score": 0.00069, "epss_percentile": 0.2146}, "CVE-2005-2505": {"epss_score": 0.0092, "epss_percentile": 0.75471}, "CVE-2005-2506": {"epss_score": 0.00458, "epss_percentile": 0.63431}, "CVE-2005-2507": {"epss_score": 0.03106, "epss_percentile": 0.86417}, "CVE-2005-2508": {"epss_score": 0.00193, "epss_percentile": 0.41453}, "CVE-2005-2509": {"epss_score": 0.00076, "epss_percentile": 0.23276}, "CVE-2005-2510": {"epss_score": 0.00071, "epss_percentile": 0.22171}, "CVE-2005-2511": {"epss_score": 0.00397, "epss_percentile": 0.60049}, "CVE-2005-2512": {"epss_score": 0.00063, "epss_percentile": 0.19818}, "CVE-2005-2513": {"epss_score": 0.00595, "epss_percentile": 0.68689}, "CVE-2005-2514": {"epss_score": 0.00987, "epss_percentile": 0.7634}, "CVE-2005-2515": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2005-2516": {"epss_score": 0.01074, "epss_percentile": 0.77297}, "CVE-2005-2517": {"epss_score": 0.00305, "epss_percentile": 0.53319}, "CVE-2005-2518": {"epss_score": 0.01607, "epss_percentile": 0.81306}, "CVE-2005-2519": {"epss_score": 0.0004, "epss_percentile": 0.12091}, "CVE-2005-2520": {"epss_score": 0.00078, "epss_percentile": 0.23578}, "CVE-2005-2521": {"epss_score": 0.00096, "epss_percentile": 0.27277}, "CVE-2005-2522": {"epss_score": 0.02862, "epss_percentile": 0.85854}, "CVE-2005-2523": {"epss_score": 0.00533, "epss_percentile": 0.66757}, "CVE-2005-2524": {"epss_score": 0.00396, "epss_percentile": 0.59862}, "CVE-2005-2525": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2005-2526": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2005-2527": {"epss_score": 0.00041, "epss_percentile": 0.12403}, "CVE-2005-2529": {"epss_score": 0.00682, "epss_percentile": 0.71065}, "CVE-2005-2530": {"epss_score": 0.00813, "epss_percentile": 0.73758}, "CVE-2005-2531": {"epss_score": 0.0141, "epss_percentile": 0.80082}, "CVE-2005-2532": {"epss_score": 0.01476, "epss_percentile": 0.8053}, "CVE-2005-2533": {"epss_score": 0.00269, "epss_percentile": 0.50155}, "CVE-2005-2534": {"epss_score": 0.00605, "epss_percentile": 0.68968}, "CVE-2005-2535": {"epss_score": 0.82941, "epss_percentile": 0.99222}, "CVE-2005-2536": {"epss_score": 0.01079, "epss_percentile": 0.77356}, "CVE-2005-2537": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2005-2538": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2005-2539": {"epss_score": 0.07205, "epss_percentile": 0.91322}, "CVE-2005-2540": {"epss_score": 0.0632, "epss_percentile": 0.90669}, "CVE-2005-2541": {"epss_score": 0.01762, "epss_percentile": 0.82154}, "CVE-2005-2542": {"epss_score": 0.03333, "epss_percentile": 0.86931}, "CVE-2005-2543": {"epss_score": 0.03054, "epss_percentile": 0.86297}, "CVE-2005-2544": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-2545": {"epss_score": 0.0103, "epss_percentile": 0.76841}, "CVE-2005-2546": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-2547": {"epss_score": 0.01141, "epss_percentile": 0.77959}, "CVE-2005-2548": {"epss_score": 0.01836, "epss_percentile": 0.82474}, "CVE-2005-2549": {"epss_score": 0.02934, "epss_percentile": 0.86021}, "CVE-2005-2550": {"epss_score": 0.05157, "epss_percentile": 0.89553}, "CVE-2005-2551": {"epss_score": 0.71755, "epss_percentile": 0.98679}, "CVE-2005-2552": {"epss_score": 0.00645, "epss_percentile": 0.70124}, "CVE-2005-2553": {"epss_score": 0.0009, "epss_percentile": 0.26041}, "CVE-2005-2554": {"epss_score": 0.00048, "epss_percentile": 0.14955}, "CVE-2005-2555": {"epss_score": 0.00093, "epss_percentile": 0.26612}, "CVE-2005-2556": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2005-2557": {"epss_score": 0.08432, "epss_percentile": 0.92049}, "CVE-2005-2558": {"epss_score": 0.148, "epss_percentile": 0.94288}, "CVE-2005-2559": {"epss_score": 0.01841, "epss_percentile": 0.82495}, "CVE-2005-2560": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-2561": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-2562": {"epss_score": 0.01552, "epss_percentile": 0.80991}, "CVE-2005-2563": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2005-2564": {"epss_score": 0.03149, "epss_percentile": 0.86501}, "CVE-2005-2565": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-2566": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-2567": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-2568": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-2569": {"epss_score": 0.00523, "epss_percentile": 0.66308}, "CVE-2005-2570": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-2571": {"epss_score": 0.00376, "epss_percentile": 0.5866}, "CVE-2005-2572": {"epss_score": 0.01363, "epss_percentile": 0.79768}, "CVE-2005-2573": {"epss_score": 0.00695, "epss_percentile": 0.7138}, "CVE-2005-2574": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2005-2575": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-2576": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-2577": {"epss_score": 0.05551, "epss_percentile": 0.89987}, "CVE-2005-2579": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2005-2580": {"epss_score": 0.01571, "epss_percentile": 0.81093}, "CVE-2005-2581": {"epss_score": 0.04338, "epss_percentile": 0.88565}, "CVE-2005-2582": {"epss_score": 0.00043, "epss_percentile": 0.1297}, "CVE-2005-2583": {"epss_score": 0.00345, "epss_percentile": 0.56569}, "CVE-2005-2584": {"epss_score": 0.00048, "epss_percentile": 0.15135}, "CVE-2005-2585": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-2586": {"epss_score": 0.0007, "epss_percentile": 0.21778}, "CVE-2005-2587": {"epss_score": 0.00558, "epss_percentile": 0.67587}, "CVE-2005-2588": {"epss_score": 0.01713, "epss_percentile": 0.81887}, "CVE-2005-2589": {"epss_score": 0.00288, "epss_percentile": 0.51939}, "CVE-2005-2590": {"epss_score": 0.00463, "epss_percentile": 0.63682}, "CVE-2005-2591": {"epss_score": 0.00524, "epss_percentile": 0.66329}, "CVE-2005-2592": {"epss_score": 0.00793, "epss_percentile": 0.73421}, "CVE-2005-2593": {"epss_score": 0.00255, "epss_percentile": 0.48724}, "CVE-2005-2594": {"epss_score": 0.04585, "epss_percentile": 0.88884}, "CVE-2005-2595": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2005-2596": {"epss_score": 0.0009, "epss_percentile": 0.26015}, "CVE-2005-2597": {"epss_score": 0.00048, "epss_percentile": 0.15248}, "CVE-2005-2598": {"epss_score": 0.00291, "epss_percentile": 0.52191}, "CVE-2005-2599": {"epss_score": 0.00291, "epss_percentile": 0.52159}, "CVE-2005-2600": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2005-2601": {"epss_score": 0.00927, "epss_percentile": 0.75561}, "CVE-2005-2602": {"epss_score": 0.00448, "epss_percentile": 0.63026}, "CVE-2005-2603": {"epss_score": 0.01017, "epss_percentile": 0.76689}, "CVE-2005-2604": {"epss_score": 0.00731, "epss_percentile": 0.72177}, "CVE-2005-2605": {"epss_score": 0.00506, "epss_percentile": 0.6563}, "CVE-2005-2606": {"epss_score": 0.00598, "epss_percentile": 0.68774}, "CVE-2005-2607": {"epss_score": 0.0059, "epss_percentile": 0.6855}, "CVE-2005-2608": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2005-2609": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2005-2610": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-2611": {"epss_score": 0.79629, "epss_percentile": 0.9905}, "CVE-2005-2612": {"epss_score": 0.73416, "epss_percentile": 0.98752}, "CVE-2005-2613": {"epss_score": 0.00478, "epss_percentile": 0.64398}, "CVE-2005-2614": {"epss_score": 0.02162, "epss_percentile": 0.83831}, "CVE-2005-2615": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2005-2616": {"epss_score": 0.20091, "epss_percentile": 0.95287}, "CVE-2005-2617": {"epss_score": 0.00059, "epss_percentile": 0.18671}, "CVE-2005-2618": {"epss_score": 0.49609, "epss_percentile": 0.97696}, "CVE-2005-2619": {"epss_score": 0.00966, "epss_percentile": 0.7605}, "CVE-2005-2620": {"epss_score": 0.01761, "epss_percentile": 0.82149}, "CVE-2005-2621": {"epss_score": 0.00325, "epss_percentile": 0.55014}, "CVE-2005-2622": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-2623": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2005-2624": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2005-2625": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2005-2626": {"epss_score": 0.03939, "epss_percentile": 0.87987}, "CVE-2005-2627": {"epss_score": 0.0567, "epss_percentile": 0.90103}, "CVE-2005-2628": {"epss_score": 0.32699, "epss_percentile": 0.96718}, "CVE-2005-2629": {"epss_score": 0.37387, "epss_percentile": 0.97041}, "CVE-2005-2630": {"epss_score": 0.04977, "epss_percentile": 0.89356}, "CVE-2005-2631": {"epss_score": 0.00363, "epss_percentile": 0.57827}, "CVE-2005-2632": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-2633": {"epss_score": 0.01246, "epss_percentile": 0.78846}, "CVE-2005-2634": {"epss_score": 0.05514, "epss_percentile": 0.89948}, "CVE-2005-2635": {"epss_score": 0.01182, "epss_percentile": 0.78316}, "CVE-2005-2636": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-2637": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2005-2638": {"epss_score": 0.00445, "epss_percentile": 0.62865}, "CVE-2005-2639": {"epss_score": 0.13509, "epss_percentile": 0.93985}, "CVE-2005-2640": {"epss_score": 0.05881, "epss_percentile": 0.9029}, "CVE-2005-2641": {"epss_score": 0.02197, "epss_percentile": 0.83959}, "CVE-2005-2642": {"epss_score": 0.09945, "epss_percentile": 0.92785}, "CVE-2005-2643": {"epss_score": 0.00408, "epss_percentile": 0.60654}, "CVE-2005-2644": {"epss_score": 0.05295, "epss_percentile": 0.89701}, "CVE-2005-2645": {"epss_score": 0.00777, "epss_percentile": 0.73117}, "CVE-2005-2646": {"epss_score": 0.00483, "epss_percentile": 0.6456}, "CVE-2005-2647": {"epss_score": 0.0054, "epss_percentile": 0.6702}, "CVE-2005-2648": {"epss_score": 0.09779, "epss_percentile": 0.92699}, "CVE-2005-2649": {"epss_score": 0.00655, "epss_percentile": 0.70428}, "CVE-2005-2650": {"epss_score": 0.00547, "epss_percentile": 0.67246}, "CVE-2005-2651": {"epss_score": 0.11662, "epss_percentile": 0.93437}, "CVE-2005-2652": {"epss_score": 0.00517, "epss_percentile": 0.66091}, "CVE-2005-2653": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2005-2654": {"epss_score": 0.00769, "epss_percentile": 0.72981}, "CVE-2005-2655": {"epss_score": 0.00397, "epss_percentile": 0.59935}, "CVE-2005-2656": {"epss_score": 0.00044, "epss_percentile": 0.13483}, "CVE-2005-2657": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2005-2658": {"epss_score": 0.01591, "epss_percentile": 0.81203}, "CVE-2005-2659": {"epss_score": 0.00998, "epss_percentile": 0.76469}, "CVE-2005-2660": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2005-2661": {"epss_score": 0.19677, "epss_percentile": 0.95224}, "CVE-2005-2662": {"epss_score": 0.01141, "epss_percentile": 0.77959}, "CVE-2005-2663": {"epss_score": 0.00098, "epss_percentile": 0.27781}, "CVE-2005-2664": {"epss_score": 0.00071, "epss_percentile": 0.22167}, "CVE-2005-2665": {"epss_score": 0.27779, "epss_percentile": 0.96282}, "CVE-2005-2666": {"epss_score": 0.00073, "epss_percentile": 0.22484}, "CVE-2005-2667": {"epss_score": 0.01116, "epss_percentile": 0.77718}, "CVE-2005-2668": {"epss_score": 0.82851, "epss_percentile": 0.99219}, "CVE-2005-2669": {"epss_score": 0.07095, "epss_percentile": 0.91246}, "CVE-2005-2670": {"epss_score": 0.02627, "epss_percentile": 0.85269}, "CVE-2005-2672": {"epss_score": 0.00101, "epss_percentile": 0.28632}, "CVE-2005-2673": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2005-2674": {"epss_score": 0.00936, "epss_percentile": 0.75687}, "CVE-2005-2675": {"epss_score": 0.00699, "epss_percentile": 0.71445}, "CVE-2005-2676": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-2677": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2005-2678": {"epss_score": 0.4325, "epss_percentile": 0.97378}, "CVE-2005-2679": {"epss_score": 0.01234, "epss_percentile": 0.78757}, "CVE-2005-2680": {"epss_score": 0.00216, "epss_percentile": 0.44207}, "CVE-2005-2681": {"epss_score": 0.00068, "epss_percentile": 0.21208}, "CVE-2005-2682": {"epss_score": 0.00982, "epss_percentile": 0.76295}, "CVE-2005-2683": {"epss_score": 0.00457, "epss_percentile": 0.6339}, "CVE-2005-2684": {"epss_score": 0.02164, "epss_percentile": 0.83837}, "CVE-2005-2685": {"epss_score": 0.00784, "epss_percentile": 0.73241}, "CVE-2005-2686": {"epss_score": 0.00497, "epss_percentile": 0.6518}, "CVE-2005-2687": {"epss_score": 0.01015, "epss_percentile": 0.76663}, "CVE-2005-2688": {"epss_score": 0.00331, "epss_percentile": 0.55548}, "CVE-2005-2689": {"epss_score": 0.00321, "epss_percentile": 0.54684}, "CVE-2005-2690": {"epss_score": 0.00274, "epss_percentile": 0.50483}, "CVE-2005-2691": {"epss_score": 0.01715, "epss_percentile": 0.81898}, "CVE-2005-2692": {"epss_score": 0.00959, "epss_percentile": 0.75949}, "CVE-2005-2693": {"epss_score": 0.00074, "epss_percentile": 0.22818}, "CVE-2005-2694": {"epss_score": 0.05157, "epss_percentile": 0.89553}, "CVE-2005-2695": {"epss_score": 0.00229, "epss_percentile": 0.45596}, "CVE-2005-2696": {"epss_score": 0.00199, "epss_percentile": 0.42157}, "CVE-2005-2697": {"epss_score": 0.01259, "epss_percentile": 0.78967}, "CVE-2005-2698": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2699": {"epss_score": 0.00151, "epss_percentile": 0.36361}, "CVE-2005-2700": {"epss_score": 0.15081, "epss_percentile": 0.94358}, "CVE-2005-2701": {"epss_score": 0.08677, "epss_percentile": 0.92194}, "CVE-2005-2702": {"epss_score": 0.06958, "epss_percentile": 0.91149}, "CVE-2005-2703": {"epss_score": 0.04682, "epss_percentile": 0.89001}, "CVE-2005-2704": {"epss_score": 0.02531, "epss_percentile": 0.85024}, "CVE-2005-2705": {"epss_score": 0.06958, "epss_percentile": 0.91149}, "CVE-2005-2706": {"epss_score": 0.02965, "epss_percentile": 0.8608}, "CVE-2005-2707": {"epss_score": 0.01492, "epss_percentile": 0.80635}, "CVE-2005-2708": {"epss_score": 0.00097, "epss_percentile": 0.27481}, "CVE-2005-2709": {"epss_score": 0.00219, "epss_percentile": 0.44466}, "CVE-2005-2710": {"epss_score": 0.53626, "epss_percentile": 0.97886}, "CVE-2005-2711": {"epss_score": 0.00064, "epss_percentile": 0.20295}, "CVE-2005-2712": {"epss_score": 0.0257, "epss_percentile": 0.85126}, "CVE-2005-2713": {"epss_score": 0.00183, "epss_percentile": 0.40325}, "CVE-2005-2714": {"epss_score": 0.00025, "epss_percentile": 0.06303}, "CVE-2005-2715": {"epss_score": 0.66312, "epss_percentile": 0.98459}, "CVE-2005-2716": {"epss_score": 0.01773, "epss_percentile": 0.82204}, "CVE-2005-2717": {"epss_score": 0.01495, "epss_percentile": 0.80656}, "CVE-2005-2718": {"epss_score": 0.04102, "epss_percentile": 0.88261}, "CVE-2005-2719": {"epss_score": 0.10974, "epss_percentile": 0.93181}, "CVE-2005-2720": {"epss_score": 0.04639, "epss_percentile": 0.88952}, "CVE-2005-2721": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2005-2722": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2005-2723": {"epss_score": 0.01261, "epss_percentile": 0.78977}, "CVE-2005-2724": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2005-2725": {"epss_score": 0.00133, "epss_percentile": 0.33729}, "CVE-2005-2726": {"epss_score": 0.02191, "epss_percentile": 0.83939}, "CVE-2005-2727": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2005-2728": {"epss_score": 0.61794, "epss_percentile": 0.98262}, "CVE-2005-2729": {"epss_score": 0.042, "epss_percentile": 0.88386}, "CVE-2005-2730": {"epss_score": 0.00306, "epss_percentile": 0.53443}, "CVE-2005-2731": {"epss_score": 0.00118, "epss_percentile": 0.31484}, "CVE-2005-2732": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-2733": {"epss_score": 0.79937, "epss_percentile": 0.99064}, "CVE-2005-2734": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2005-2735": {"epss_score": 0.00751, "epss_percentile": 0.72638}, "CVE-2005-2736": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-2737": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-2738": {"epss_score": 0.00529, "epss_percentile": 0.66588}, "CVE-2005-2739": {"epss_score": 0.00093, "epss_percentile": 0.2667}, "CVE-2005-2741": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2005-2742": {"epss_score": 0.00079, "epss_percentile": 0.23893}, "CVE-2005-2743": {"epss_score": 0.01732, "epss_percentile": 0.81996}, "CVE-2005-2744": {"epss_score": 0.04917, "epss_percentile": 0.89286}, "CVE-2005-2745": {"epss_score": 0.00748, "epss_percentile": 0.72578}, "CVE-2005-2746": {"epss_score": 0.0032, "epss_percentile": 0.5462}, "CVE-2005-2747": {"epss_score": 0.04005, "epss_percentile": 0.88102}, "CVE-2005-2748": {"epss_score": 0.00101, "epss_percentile": 0.28626}, "CVE-2005-2749": {"epss_score": 0.00083, "epss_percentile": 0.24785}, "CVE-2005-2750": {"epss_score": 0.00093, "epss_percentile": 0.2667}, "CVE-2005-2751": {"epss_score": 0.00093, "epss_percentile": 0.2667}, "CVE-2005-2752": {"epss_score": 0.00093, "epss_percentile": 0.2667}, "CVE-2005-2753": {"epss_score": 0.01442, "epss_percentile": 0.80308}, "CVE-2005-2754": {"epss_score": 0.01442, "epss_percentile": 0.80308}, "CVE-2005-2755": {"epss_score": 0.01388, "epss_percentile": 0.79923}, "CVE-2005-2756": {"epss_score": 0.02311, "epss_percentile": 0.84339}, "CVE-2005-2757": {"epss_score": 0.04091, "epss_percentile": 0.88237}, "CVE-2005-2758": {"epss_score": 0.23973, "epss_percentile": 0.95839}, "CVE-2005-2759": {"epss_score": 0.00058, "epss_percentile": 0.18608}, "CVE-2005-2761": {"epss_score": 0.00396, "epss_percentile": 0.59897}, "CVE-2005-2762": {"epss_score": 0.00072, "epss_percentile": 0.2235}, "CVE-2005-2763": {"epss_score": 0.02051, "epss_percentile": 0.83407}, "CVE-2005-2764": {"epss_score": 0.00772, "epss_percentile": 0.73042}, "CVE-2005-2765": {"epss_score": 0.00399, "epss_percentile": 0.60138}, "CVE-2005-2766": {"epss_score": 0.00082, "epss_percentile": 0.24481}, "CVE-2005-2767": {"epss_score": 0.15081, "epss_percentile": 0.94358}, "CVE-2005-2768": {"epss_score": 0.1203, "epss_percentile": 0.93551}, "CVE-2005-2769": {"epss_score": 0.10952, "epss_percentile": 0.93174}, "CVE-2005-2770": {"epss_score": 0.016, "epss_percentile": 0.81257}, "CVE-2005-2771": {"epss_score": 0.01848, "epss_percentile": 0.82527}, "CVE-2005-2772": {"epss_score": 0.33134, "epss_percentile": 0.96748}, "CVE-2005-2773": {"epss_score": 0.89464, "epss_percentile": 0.99528}, "CVE-2005-2774": {"epss_score": 0.02041, "epss_percentile": 0.83373}, "CVE-2005-2775": {"epss_score": 0.02256, "epss_percentile": 0.84169}, "CVE-2005-2776": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2005-2777": {"epss_score": 0.19522, "epss_percentile": 0.952}, "CVE-2005-2778": {"epss_score": 0.00812, "epss_percentile": 0.73747}, "CVE-2005-2779": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2005-2780": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2781": {"epss_score": 0.01269, "epss_percentile": 0.79039}, "CVE-2005-2782": {"epss_score": 0.01503, "epss_percentile": 0.80734}, "CVE-2005-2783": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2005-2784": {"epss_score": 0.00903, "epss_percentile": 0.75206}, "CVE-2005-2785": {"epss_score": 0.00069, "epss_percentile": 0.21537}, "CVE-2005-2786": {"epss_score": 0.00371, "epss_percentile": 0.58368}, "CVE-2005-2787": {"epss_score": 0.06481, "epss_percentile": 0.90788}, "CVE-2005-2788": {"epss_score": 0.00321, "epss_percentile": 0.54693}, "CVE-2005-2789": {"epss_score": 0.00994, "epss_percentile": 0.76422}, "CVE-2005-2790": {"epss_score": 0.00413, "epss_percentile": 0.60966}, "CVE-2005-2791": {"epss_score": 0.05487, "epss_percentile": 0.89926}, "CVE-2005-2792": {"epss_score": 0.13987, "epss_percentile": 0.94109}, "CVE-2005-2793": {"epss_score": 0.02938, "epss_percentile": 0.86029}, "CVE-2005-2794": {"epss_score": 0.12518, "epss_percentile": 0.93706}, "CVE-2005-2796": {"epss_score": 0.15104, "epss_percentile": 0.94364}, "CVE-2005-2797": {"epss_score": 0.00704, "epss_percentile": 0.71551}, "CVE-2005-2798": {"epss_score": 0.027, "epss_percentile": 0.85451}, "CVE-2005-2799": {"epss_score": 0.86739, "epss_percentile": 0.99394}, "CVE-2005-2800": {"epss_score": 0.00159, "epss_percentile": 0.3733}, "CVE-2005-2801": {"epss_score": 0.03343, "epss_percentile": 0.86947}, "CVE-2005-2803": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-2804": {"epss_score": 0.05296, "epss_percentile": 0.89703}, "CVE-2005-2805": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2005-2806": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2005-2807": {"epss_score": 0.00129, "epss_percentile": 0.33198}, "CVE-2005-2808": {"epss_score": 0.00489, "epss_percentile": 0.64872}, "CVE-2005-2809": {"epss_score": 0.00079, "epss_percentile": 0.23853}, "CVE-2005-2810": {"epss_score": 0.0005, "epss_percentile": 0.15721}, "CVE-2005-2811": {"epss_score": 0.00068, "epss_percentile": 0.21423}, "CVE-2005-2812": {"epss_score": 0.08062, "epss_percentile": 0.91861}, "CVE-2005-2813": {"epss_score": 0.07078, "epss_percentile": 0.91236}, "CVE-2005-2814": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2005-2815": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2005-2816": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2817": {"epss_score": 0.0059, "epss_percentile": 0.6855}, "CVE-2005-2818": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-2819": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-2820": {"epss_score": 0.00648, "epss_percentile": 0.70222}, "CVE-2005-2827": {"epss_score": 0.01718, "epss_percentile": 0.81919}, "CVE-2005-2829": {"epss_score": 0.2005, "epss_percentile": 0.9528}, "CVE-2005-2830": {"epss_score": 0.50732, "epss_percentile": 0.97747}, "CVE-2005-2831": {"epss_score": 0.57824, "epss_percentile": 0.98085}, "CVE-2005-2836": {"epss_score": 0.0043, "epss_percentile": 0.62013}, "CVE-2005-2837": {"epss_score": 0.00881, "epss_percentile": 0.74873}, "CVE-2005-2838": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-2839": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2840": {"epss_score": 0.00461, "epss_percentile": 0.63564}, "CVE-2005-2841": {"epss_score": 0.33877, "epss_percentile": 0.96811}, "CVE-2005-2842": {"epss_score": 0.64197, "epss_percentile": 0.98369}, "CVE-2005-2843": {"epss_score": 0.00793, "epss_percentile": 0.73421}, "CVE-2005-2844": {"epss_score": 0.0901, "epss_percentile": 0.92362}, "CVE-2005-2845": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-2846": {"epss_score": 0.02434, "epss_percentile": 0.84734}, "CVE-2005-2847": {"epss_score": 0.87047, "epss_percentile": 0.9941}, "CVE-2005-2848": {"epss_score": 0.45644, "epss_percentile": 0.97495}, "CVE-2005-2849": {"epss_score": 0.00502, "epss_percentile": 0.65411}, "CVE-2005-2850": {"epss_score": 0.04656, "epss_percentile": 0.88973}, "CVE-2005-2851": {"epss_score": 0.00078, "epss_percentile": 0.23623}, "CVE-2005-2852": {"epss_score": 0.48078, "epss_percentile": 0.97617}, "CVE-2005-2853": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-2854": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2005-2855": {"epss_score": 0.07636, "epss_percentile": 0.91591}, "CVE-2005-2856": {"epss_score": 0.21562, "epss_percentile": 0.95534}, "CVE-2005-2857": {"epss_score": 0.02028, "epss_percentile": 0.83321}, "CVE-2005-2858": {"epss_score": 0.00386, "epss_percentile": 0.59286}, "CVE-2005-2859": {"epss_score": 0.00053, "epss_percentile": 0.16907}, "CVE-2005-2860": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2005-2861": {"epss_score": 0.0043, "epss_percentile": 0.62013}, "CVE-2005-2862": {"epss_score": 0.00758, "epss_percentile": 0.72768}, "CVE-2005-2863": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-2864": {"epss_score": 0.00078, "epss_percentile": 0.23686}, "CVE-2005-2865": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-2866": {"epss_score": 0.00129, "epss_percentile": 0.33169}, "CVE-2005-2867": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-2868": {"epss_score": 0.00127, "epss_percentile": 0.32894}, "CVE-2005-2869": {"epss_score": 0.11812, "epss_percentile": 0.93484}, "CVE-2005-2870": {"epss_score": 0.01624, "epss_percentile": 0.81414}, "CVE-2005-2871": {"epss_score": 0.51583, "epss_percentile": 0.97788}, "CVE-2005-2872": {"epss_score": 0.05642, "epss_percentile": 0.90077}, "CVE-2005-2873": {"epss_score": 0.00079, "epss_percentile": 0.23867}, "CVE-2005-2874": {"epss_score": 0.01434, "epss_percentile": 0.80264}, "CVE-2005-2875": {"epss_score": 0.01495, "epss_percentile": 0.80657}, "CVE-2005-2876": {"epss_score": 0.00048, "epss_percentile": 0.15117}, "CVE-2005-2877": {"epss_score": 0.84001, "epss_percentile": 0.9927}, "CVE-2005-2878": {"epss_score": 0.57139, "epss_percentile": 0.9805}, "CVE-2005-2879": {"epss_score": 0.00036, "epss_percentile": 0.10295}, "CVE-2005-2880": {"epss_score": 0.00768, "epss_percentile": 0.7297}, "CVE-2005-2881": {"epss_score": 0.00849, "epss_percentile": 0.74372}, "CVE-2005-2882": {"epss_score": 0.00565, "epss_percentile": 0.67806}, "CVE-2005-2884": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-2885": {"epss_score": 0.09563, "epss_percentile": 0.92601}, "CVE-2005-2886": {"epss_score": 0.00565, "epss_percentile": 0.67806}, "CVE-2005-2887": {"epss_score": 0.00517, "epss_percentile": 0.66091}, "CVE-2005-2888": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-2889": {"epss_score": 0.00498, "epss_percentile": 0.65222}, "CVE-2005-2890": {"epss_score": 0.00125, "epss_percentile": 0.32578}, "CVE-2005-2891": {"epss_score": 0.00871, "epss_percentile": 0.74714}, "CVE-2005-2892": {"epss_score": 0.05242, "epss_percentile": 0.89653}, "CVE-2005-2893": {"epss_score": 0.0108, "epss_percentile": 0.77363}, "CVE-2005-2894": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-2895": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2005-2896": {"epss_score": 0.0035, "epss_percentile": 0.56921}, "CVE-2005-2897": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2005-2898": {"epss_score": 0.00199, "epss_percentile": 0.42143}, "CVE-2005-2899": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2900": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2901": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2902": {"epss_score": 0.0037, "epss_percentile": 0.58313}, "CVE-2005-2903": {"epss_score": 0.05679, "epss_percentile": 0.90115}, "CVE-2005-2904": {"epss_score": 0.06794, "epss_percentile": 0.91031}, "CVE-2005-2912": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-2914": {"epss_score": 0.00757, "epss_percentile": 0.72753}, "CVE-2005-2915": {"epss_score": 0.00184, "epss_percentile": 0.40456}, "CVE-2005-2916": {"epss_score": 0.00476, "epss_percentile": 0.64262}, "CVE-2005-2917": {"epss_score": 0.51918, "epss_percentile": 0.97802}, "CVE-2005-2918": {"epss_score": 0.00683, "epss_percentile": 0.71099}, "CVE-2005-2919": {"epss_score": 0.02907, "epss_percentile": 0.85964}, "CVE-2005-2920": {"epss_score": 0.14209, "epss_percentile": 0.94164}, "CVE-2005-2922": {"epss_score": 0.04359, "epss_percentile": 0.88594}, "CVE-2005-2923": {"epss_score": 0.0562, "epss_percentile": 0.90059}, "CVE-2005-2925": {"epss_score": 0.00199, "epss_percentile": 0.42183}, "CVE-2005-2926": {"epss_score": 0.00173, "epss_percentile": 0.39058}, "CVE-2005-2927": {"epss_score": 0.00096, "epss_percentile": 0.27327}, "CVE-2005-2929": {"epss_score": 0.06003, "epss_percentile": 0.90394}, "CVE-2005-2930": {"epss_score": 0.02078, "epss_percentile": 0.83516}, "CVE-2005-2931": {"epss_score": 0.16725, "epss_percentile": 0.94722}, "CVE-2005-2932": {"epss_score": 0.00046, "epss_percentile": 0.14473}, "CVE-2005-2933": {"epss_score": 0.35083, "epss_percentile": 0.96887}, "CVE-2005-2934": {"epss_score": 0.00539, "epss_percentile": 0.66986}, "CVE-2005-2935": {"epss_score": 0.00598, "epss_percentile": 0.68776}, "CVE-2005-2936": {"epss_score": 0.0021, "epss_percentile": 0.4343}, "CVE-2005-2938": {"epss_score": 0.00058, "epss_percentile": 0.18514}, "CVE-2005-2939": {"epss_score": 0.00039, "epss_percentile": 0.11465}, "CVE-2005-2940": {"epss_score": 0.00848, "epss_percentile": 0.74361}, "CVE-2005-2943": {"epss_score": 0.27295, "epss_percentile": 0.96233}, "CVE-2005-2944": {"epss_score": 0.00066, "epss_percentile": 0.20779}, "CVE-2005-2945": {"epss_score": 0.00059, "epss_percentile": 0.18656}, "CVE-2005-2946": {"epss_score": 0.0019, "epss_percentile": 0.41073}, "CVE-2005-2947": {"epss_score": 0.01397, "epss_percentile": 0.79986}, "CVE-2005-2948": {"epss_score": 0.00063, "epss_percentile": 0.19925}, "CVE-2005-2949": {"epss_score": 0.00951, "epss_percentile": 0.75868}, "CVE-2005-2950": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2005-2951": {"epss_score": 0.09007, "epss_percentile": 0.92361}, "CVE-2005-2952": {"epss_score": 0.13111, "epss_percentile": 0.93877}, "CVE-2005-2953": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-2954": {"epss_score": 0.01238, "epss_percentile": 0.78794}, "CVE-2005-2955": {"epss_score": 0.0009, "epss_percentile": 0.26129}, "CVE-2005-2956": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2005-2957": {"epss_score": 0.04639, "epss_percentile": 0.88952}, "CVE-2005-2958": {"epss_score": 0.01683, "epss_percentile": 0.81738}, "CVE-2005-2959": {"epss_score": 0.00128, "epss_percentile": 0.33052}, "CVE-2005-2960": {"epss_score": 0.00074, "epss_percentile": 0.22676}, "CVE-2005-2961": {"epss_score": 0.05848, "epss_percentile": 0.9026}, "CVE-2005-2962": {"epss_score": 0.00052, "epss_percentile": 0.16572}, "CVE-2005-2963": {"epss_score": 0.01486, "epss_percentile": 0.80607}, "CVE-2005-2964": {"epss_score": 0.02076, "epss_percentile": 0.83512}, "CVE-2005-2966": {"epss_score": 0.02533, "epss_percentile": 0.85031}, "CVE-2005-2967": {"epss_score": 0.11331, "epss_percentile": 0.93312}, "CVE-2005-2968": {"epss_score": 0.45887, "epss_percentile": 0.97506}, "CVE-2005-2969": {"epss_score": 0.09388, "epss_percentile": 0.92528}, "CVE-2005-2970": {"epss_score": 0.20799, "epss_percentile": 0.95414}, "CVE-2005-2971": {"epss_score": 0.06519, "epss_percentile": 0.90816}, "CVE-2005-2972": {"epss_score": 0.02704, "epss_percentile": 0.85461}, "CVE-2005-2973": {"epss_score": 0.0029, "epss_percentile": 0.52113}, "CVE-2005-2974": {"epss_score": 0.04879, "epss_percentile": 0.89243}, "CVE-2005-2975": {"epss_score": 0.1189, "epss_percentile": 0.93508}, "CVE-2005-2976": {"epss_score": 0.01719, "epss_percentile": 0.81925}, "CVE-2005-2977": {"epss_score": 0.00076, "epss_percentile": 0.23212}, "CVE-2005-2978": {"epss_score": 0.04583, "epss_percentile": 0.88879}, "CVE-2005-2979": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-2980": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2005-2981": {"epss_score": 0.00324, "epss_percentile": 0.54974}, "CVE-2005-2982": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-2983": {"epss_score": 0.01057, "epss_percentile": 0.7713}, "CVE-2005-2984": {"epss_score": 0.00211, "epss_percentile": 0.4364}, "CVE-2005-2985": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2005-2986": {"epss_score": 0.01108, "epss_percentile": 0.77636}, "CVE-2005-2987": {"epss_score": 0.02157, "epss_percentile": 0.83814}, "CVE-2005-2988": {"epss_score": 0.00825, "epss_percentile": 0.73953}, "CVE-2005-2989": {"epss_score": 0.00249, "epss_percentile": 0.48052}, "CVE-2005-2990": {"epss_score": 0.00065, "epss_percentile": 0.205}, "CVE-2005-2991": {"epss_score": 0.00092, "epss_percentile": 0.26445}, "CVE-2005-2992": {"epss_score": 0.00072, "epss_percentile": 0.22419}, "CVE-2005-2993": {"epss_score": 0.00176, "epss_percentile": 0.39492}, "CVE-2005-2994": {"epss_score": 0.01045, "epss_percentile": 0.77011}, "CVE-2005-2995": {"epss_score": 0.00079, "epss_percentile": 0.23814}, "CVE-2005-2996": {"epss_score": 0.13701, "epss_percentile": 0.94038}, "CVE-2005-2997": {"epss_score": 0.00248, "epss_percentile": 0.47916}, "CVE-2005-2998": {"epss_score": 0.00763, "epss_percentile": 0.72859}, "CVE-2005-2999": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-3000": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-3001": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2005-3002": {"epss_score": 0.02964, "epss_percentile": 0.86077}, "CVE-2005-3003": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2005-3004": {"epss_score": 0.00558, "epss_percentile": 0.67587}, "CVE-2005-3005": {"epss_score": 0.08612, "epss_percentile": 0.92152}, "CVE-2005-3006": {"epss_score": 0.01116, "epss_percentile": 0.77721}, "CVE-2005-3007": {"epss_score": 0.01454, "epss_percentile": 0.80377}, "CVE-2005-3008": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-3009": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-3010": {"epss_score": 0.02429, "epss_percentile": 0.84722}, "CVE-2005-3011": {"epss_score": 0.00043, "epss_percentile": 0.13281}, "CVE-2005-3012": {"epss_score": 0.00053, "epss_percentile": 0.1686}, "CVE-2005-3013": {"epss_score": 0.00085, "epss_percentile": 0.25225}, "CVE-2005-3014": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-3015": {"epss_score": 0.00353, "epss_percentile": 0.57158}, "CVE-2005-3016": {"epss_score": 0.00018, "epss_percentile": 0.04017}, "CVE-2005-3017": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-3018": {"epss_score": 0.0445, "epss_percentile": 0.88703}, "CVE-2005-3019": {"epss_score": 0.00646, "epss_percentile": 0.70148}, "CVE-2005-3020": {"epss_score": 0.0051, "epss_percentile": 0.65802}, "CVE-2005-3021": {"epss_score": 0.00197, "epss_percentile": 0.4195}, "CVE-2005-3022": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2005-3023": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-3024": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2005-3025": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-3026": {"epss_score": 0.0421, "epss_percentile": 0.88399}, "CVE-2005-3027": {"epss_score": 0.01268, "epss_percentile": 0.79026}, "CVE-2005-3029": {"epss_score": 0.04639, "epss_percentile": 0.88952}, "CVE-2005-3030": {"epss_score": 0.02627, "epss_percentile": 0.85269}, "CVE-2005-3031": {"epss_score": 0.04755, "epss_percentile": 0.89112}, "CVE-2005-3032": {"epss_score": 0.02922, "epss_percentile": 0.85995}, "CVE-2005-3033": {"epss_score": 0.02018, "epss_percentile": 0.83287}, "CVE-2005-3034": {"epss_score": 0.0076, "epss_percentile": 0.72809}, "CVE-2005-3035": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2005-3036": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2005-3037": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2005-3038": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-3039": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-3040": {"epss_score": 0.00763, "epss_percentile": 0.72852}, "CVE-2005-3041": {"epss_score": 0.00441, "epss_percentile": 0.62669}, "CVE-2005-3042": {"epss_score": 0.02204, "epss_percentile": 0.83997}, "CVE-2005-3043": {"epss_score": 0.02018, "epss_percentile": 0.83285}, "CVE-2005-3044": {"epss_score": 0.0012, "epss_percentile": 0.31808}, "CVE-2005-3045": {"epss_score": 0.00556, "epss_percentile": 0.67506}, "CVE-2005-3046": {"epss_score": 0.00602, "epss_percentile": 0.68897}, "CVE-2005-3047": {"epss_score": 0.00412, "epss_percentile": 0.6093}, "CVE-2005-3048": {"epss_score": 0.04265, "epss_percentile": 0.88468}, "CVE-2005-3049": {"epss_score": 0.00723, "epss_percentile": 0.72025}, "CVE-2005-3050": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2005-3051": {"epss_score": 0.14856, "epss_percentile": 0.94303}, "CVE-2005-3052": {"epss_score": 0.00425, "epss_percentile": 0.61713}, "CVE-2005-3053": {"epss_score": 0.00095, "epss_percentile": 0.27092}, "CVE-2005-3054": {"epss_score": 0.00443, "epss_percentile": 0.62768}, "CVE-2005-3055": {"epss_score": 0.0009, "epss_percentile": 0.26156}, "CVE-2005-3056": {"epss_score": 0.01218, "epss_percentile": 0.78604}, "CVE-2005-3057": {"epss_score": 0.01881, "epss_percentile": 0.82694}, "CVE-2005-3058": {"epss_score": 0.05691, "epss_percentile": 0.90124}, "CVE-2005-3059": {"epss_score": 0.00458, "epss_percentile": 0.63398}, "CVE-2005-3060": {"epss_score": 0.0013, "epss_percentile": 0.33279}, "CVE-2005-3061": {"epss_score": 0.0385, "epss_percentile": 0.87848}, "CVE-2005-3062": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2005-3063": {"epss_score": 0.00708, "epss_percentile": 0.71665}, "CVE-2005-3064": {"epss_score": 0.05464, "epss_percentile": 0.89903}, "CVE-2005-3065": {"epss_score": 0.01317, "epss_percentile": 0.79416}, "CVE-2005-3066": {"epss_score": 0.00845, "epss_percentile": 0.74282}, "CVE-2005-3067": {"epss_score": 0.00812, "epss_percentile": 0.7374}, "CVE-2005-3068": {"epss_score": 0.00692, "epss_percentile": 0.71297}, "CVE-2005-3069": {"epss_score": 0.00069, "epss_percentile": 0.21473}, "CVE-2005-3070": {"epss_score": 0.0007, "epss_percentile": 0.21803}, "CVE-2005-3071": {"epss_score": 0.00063, "epss_percentile": 0.19964}, "CVE-2005-3072": {"epss_score": 0.00753, "epss_percentile": 0.72675}, "CVE-2005-3073": {"epss_score": 0.0054, "epss_percentile": 0.67001}, "CVE-2005-3074": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-3075": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-3076": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-3077": {"epss_score": 0.14574, "epss_percentile": 0.94243}, "CVE-2005-3078": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-3079": {"epss_score": 0.00541, "epss_percentile": 0.67054}, "CVE-2005-3080": {"epss_score": 0.00673, "epss_percentile": 0.70843}, "CVE-2005-3081": {"epss_score": 0.50156, "epss_percentile": 0.97722}, "CVE-2005-3082": {"epss_score": 0.01355, "epss_percentile": 0.79706}, "CVE-2005-3083": {"epss_score": 0.00353, "epss_percentile": 0.57198}, "CVE-2005-3084": {"epss_score": 0.00747, "epss_percentile": 0.72554}, "CVE-2005-3085": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-3086": {"epss_score": 0.00256, "epss_percentile": 0.4874}, "CVE-2005-3087": {"epss_score": 0.00305, "epss_percentile": 0.53319}, "CVE-2005-3088": {"epss_score": 0.00093, "epss_percentile": 0.26683}, "CVE-2005-3089": {"epss_score": 0.00717, "epss_percentile": 0.71882}, "CVE-2005-3090": {"epss_score": 0.00362, "epss_percentile": 0.57779}, "CVE-2005-3091": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-3092": {"epss_score": 0.1332, "epss_percentile": 0.93932}, "CVE-2005-3093": {"epss_score": 0.00406, "epss_percentile": 0.60529}, "CVE-2005-3094": {"epss_score": 0.04188, "epss_percentile": 0.88369}, "CVE-2005-3095": {"epss_score": 0.01376, "epss_percentile": 0.79835}, "CVE-2005-3096": {"epss_score": 0.03811, "epss_percentile": 0.8776}, "CVE-2005-3097": {"epss_score": 0.0036, "epss_percentile": 0.57659}, "CVE-2005-3098": {"epss_score": 0.00334, "epss_percentile": 0.55694}, "CVE-2005-3099": {"epss_score": 0.00078, "epss_percentile": 0.23688}, "CVE-2005-3100": {"epss_score": 0.00452, "epss_percentile": 0.63158}, "CVE-2005-3101": {"epss_score": 0.0056, "epss_percentile": 0.67647}, "CVE-2005-3102": {"epss_score": 0.00503, "epss_percentile": 0.65456}, "CVE-2005-3103": {"epss_score": 0.00362, "epss_percentile": 0.57779}, "CVE-2005-3104": {"epss_score": 0.00399, "epss_percentile": 0.60121}, "CVE-2005-3105": {"epss_score": 0.00066, "epss_percentile": 0.2073}, "CVE-2005-3106": {"epss_score": 0.00078, "epss_percentile": 0.23627}, "CVE-2005-3107": {"epss_score": 0.00091, "epss_percentile": 0.26285}, "CVE-2005-3108": {"epss_score": 0.00066, "epss_percentile": 0.20938}, "CVE-2005-3109": {"epss_score": 0.00071, "epss_percentile": 0.22053}, "CVE-2005-3110": {"epss_score": 0.02474, "epss_percentile": 0.84855}, "CVE-2005-3111": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2005-3112": {"epss_score": 0.00018, "epss_percentile": 0.0383}, "CVE-2005-3113": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-3114": {"epss_score": 0.01956, "epss_percentile": 0.83039}, "CVE-2005-3115": {"epss_score": 0.00079, "epss_percentile": 0.23853}, "CVE-2005-3116": {"epss_score": 0.55111, "epss_percentile": 0.9796}, "CVE-2005-3118": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2005-3119": {"epss_score": 0.00114, "epss_percentile": 0.30833}, "CVE-2005-3120": {"epss_score": 0.3044, "epss_percentile": 0.96538}, "CVE-2005-3121": {"epss_score": 0.00067, "epss_percentile": 0.21078}, "CVE-2005-3123": {"epss_score": 0.01258, "epss_percentile": 0.78953}, "CVE-2005-3124": {"epss_score": 0.00103, "epss_percentile": 0.28981}, "CVE-2005-3126": {"epss_score": 0.00065, "epss_percentile": 0.20558}, "CVE-2005-3127": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2005-3128": {"epss_score": 0.01733, "epss_percentile": 0.81998}, "CVE-2005-3129": {"epss_score": 0.01679, "epss_percentile": 0.81721}, "CVE-2005-3130": {"epss_score": 0.00504, "epss_percentile": 0.65523}, "CVE-2005-3131": {"epss_score": 0.0061, "epss_percentile": 0.6915}, "CVE-2005-3132": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2005-3133": {"epss_score": 0.04728, "epss_percentile": 0.89067}, "CVE-2005-3134": {"epss_score": 0.00791, "epss_percentile": 0.73393}, "CVE-2005-3135": {"epss_score": 0.11457, "epss_percentile": 0.93368}, "CVE-2005-3136": {"epss_score": 0.01395, "epss_percentile": 0.79974}, "CVE-2005-3137": {"epss_score": 0.00072, "epss_percentile": 0.22374}, "CVE-2005-3138": {"epss_score": 0.00524, "epss_percentile": 0.66329}, "CVE-2005-3139": {"epss_score": 0.00593, "epss_percentile": 0.68642}, "CVE-2005-3140": {"epss_score": 0.0047, "epss_percentile": 0.63992}, "CVE-2005-3141": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2005-3142": {"epss_score": 0.212, "epss_percentile": 0.95475}, "CVE-2005-3143": {"epss_score": 0.00543, "epss_percentile": 0.67099}, "CVE-2005-3144": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2005-3145": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2005-3146": {"epss_score": 0.00078, "epss_percentile": 0.23623}, "CVE-2005-3147": {"epss_score": 0.00059, "epss_percentile": 0.18721}, "CVE-2005-3148": {"epss_score": 0.0009, "epss_percentile": 0.26091}, "CVE-2005-3149": {"epss_score": 0.00101, "epss_percentile": 0.28658}, "CVE-2005-3150": {"epss_score": 0.01148, "epss_percentile": 0.7801}, "CVE-2005-3151": {"epss_score": 0.01629, "epss_percentile": 0.8144}, "CVE-2005-3152": {"epss_score": 0.06398, "epss_percentile": 0.90725}, "CVE-2005-3153": {"epss_score": 0.00479, "epss_percentile": 0.64415}, "CVE-2005-3154": {"epss_score": 0.02907, "epss_percentile": 0.85966}, "CVE-2005-3155": {"epss_score": 0.86484, "epss_percentile": 0.99384}, "CVE-2005-3156": {"epss_score": 0.00408, "epss_percentile": 0.60655}, "CVE-2005-3157": {"epss_score": 0.0138, "epss_percentile": 0.79862}, "CVE-2005-3158": {"epss_score": 0.011, "epss_percentile": 0.77564}, "CVE-2005-3159": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2005-3160": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-3161": {"epss_score": 0.01139, "epss_percentile": 0.77945}, "CVE-2005-3163": {"epss_score": 0.00343, "epss_percentile": 0.56452}, "CVE-2005-3164": {"epss_score": 0.03388, "epss_percentile": 0.87045}, "CVE-2005-3165": {"epss_score": 0.00268, "epss_percentile": 0.50056}, "CVE-2005-3166": {"epss_score": 0.00811, "epss_percentile": 0.73738}, "CVE-2005-3167": {"epss_score": 0.00462, "epss_percentile": 0.63623}, "CVE-2005-3168": {"epss_score": 0.00765, "epss_percentile": 0.72921}, "CVE-2005-3169": {"epss_score": 0.12227, "epss_percentile": 0.93607}, "CVE-2005-3170": {"epss_score": 0.00689, "epss_percentile": 0.71228}, "CVE-2005-3171": {"epss_score": 0.00212, "epss_percentile": 0.43739}, "CVE-2005-3172": {"epss_score": 0.10232, "epss_percentile": 0.92904}, "CVE-2005-3173": {"epss_score": 0.00187, "epss_percentile": 0.4078}, "CVE-2005-3174": {"epss_score": 0.00212, "epss_percentile": 0.43739}, "CVE-2005-3175": {"epss_score": 0.00234, "epss_percentile": 0.46096}, "CVE-2005-3176": {"epss_score": 0.13714, "epss_percentile": 0.94041}, "CVE-2005-3177": {"epss_score": 0.01077, "epss_percentile": 0.7733}, "CVE-2005-3178": {"epss_score": 0.02208, "epss_percentile": 0.84007}, "CVE-2005-3179": {"epss_score": 0.00055, "epss_percentile": 0.17516}, "CVE-2005-3180": {"epss_score": 0.01881, "epss_percentile": 0.8269}, "CVE-2005-3181": {"epss_score": 0.00153, "epss_percentile": 0.36522}, "CVE-2005-3182": {"epss_score": 0.06287, "epss_percentile": 0.90645}, "CVE-2005-3183": {"epss_score": 0.02514, "epss_percentile": 0.84979}, "CVE-2005-3184": {"epss_score": 0.034, "epss_percentile": 0.87067}, "CVE-2005-3185": {"epss_score": 0.04852, "epss_percentile": 0.89216}, "CVE-2005-3186": {"epss_score": 0.02224, "epss_percentile": 0.84065}, "CVE-2005-3187": {"epss_score": 0.05219, "epss_percentile": 0.89624}, "CVE-2005-3188": {"epss_score": 0.27053, "epss_percentile": 0.96201}, "CVE-2005-3189": {"epss_score": 0.06634, "epss_percentile": 0.90906}, "CVE-2005-3190": {"epss_score": 0.78665, "epss_percentile": 0.98996}, "CVE-2005-3191": {"epss_score": 0.03031, "epss_percentile": 0.86249}, "CVE-2005-3192": {"epss_score": 0.12279, "epss_percentile": 0.93621}, "CVE-2005-3193": {"epss_score": 0.03031, "epss_percentile": 0.86249}, "CVE-2005-3194": {"epss_score": 0.04821, "epss_percentile": 0.89179}, "CVE-2005-3196": {"epss_score": 0.00071, "epss_percentile": 0.22171}, "CVE-2005-3197": {"epss_score": 0.00062, "epss_percentile": 0.19604}, "CVE-2005-3198": {"epss_score": 0.00073, "epss_percentile": 0.22538}, "CVE-2005-3199": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-3200": {"epss_score": 0.08978, "epss_percentile": 0.92348}, "CVE-2005-3201": {"epss_score": 0.01969, "epss_percentile": 0.83089}, "CVE-2005-3202": {"epss_score": 0.11492, "epss_percentile": 0.93383}, "CVE-2005-3203": {"epss_score": 0.00121, "epss_percentile": 0.31996}, "CVE-2005-3204": {"epss_score": 0.20829, "epss_percentile": 0.9542}, "CVE-2005-3205": {"epss_score": 0.00462, "epss_percentile": 0.63626}, "CVE-2005-3206": {"epss_score": 0.27019, "epss_percentile": 0.96199}, "CVE-2005-3207": {"epss_score": 0.39447, "epss_percentile": 0.97161}, "CVE-2005-3208": {"epss_score": 0.06539, "epss_percentile": 0.90833}, "CVE-2005-3209": {"epss_score": 0.0009, "epss_percentile": 0.26015}, "CVE-2005-3210": {"epss_score": 0.00414, "epss_percentile": 0.61027}, "CVE-2005-3211": {"epss_score": 0.00357, "epss_percentile": 0.57459}, "CVE-2005-3212": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3213": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3214": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3215": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3216": {"epss_score": 0.00868, "epss_percentile": 0.74672}, "CVE-2005-3217": {"epss_score": 0.00377, "epss_percentile": 0.58696}, "CVE-2005-3218": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3219": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3220": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3221": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3222": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3223": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3224": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3225": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3226": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3227": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3228": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3229": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3230": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3231": {"epss_score": 0.00281, "epss_percentile": 0.51142}, "CVE-2005-3232": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3233": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3234": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3235": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2005-3236": {"epss_score": 0.04305, "epss_percentile": 0.8852}, "CVE-2005-3237": {"epss_score": 0.07636, "epss_percentile": 0.91591}, "CVE-2005-3238": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2005-3239": {"epss_score": 0.04594, "epss_percentile": 0.88895}, "CVE-2005-3240": {"epss_score": 0.1023, "epss_percentile": 0.92903}, "CVE-2005-3241": {"epss_score": 0.03891, "epss_percentile": 0.8791}, "CVE-2005-3242": {"epss_score": 0.03224, "epss_percentile": 0.86679}, "CVE-2005-3243": {"epss_score": 0.20239, "epss_percentile": 0.95307}, "CVE-2005-3244": {"epss_score": 0.0707, "epss_percentile": 0.91228}, "CVE-2005-3245": {"epss_score": 0.02616, "epss_percentile": 0.85248}, "CVE-2005-3246": {"epss_score": 0.03224, "epss_percentile": 0.86679}, "CVE-2005-3247": {"epss_score": 0.03164, "epss_percentile": 0.86535}, "CVE-2005-3248": {"epss_score": 0.03224, "epss_percentile": 0.86679}, "CVE-2005-3249": {"epss_score": 0.04824, "epss_percentile": 0.89182}, "CVE-2005-3250": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2005-3251": {"epss_score": 0.01598, "epss_percentile": 0.81247}, "CVE-2005-3252": {"epss_score": 0.83778, "epss_percentile": 0.99261}, "CVE-2005-3253": {"epss_score": 0.00978, "epss_percentile": 0.76237}, "CVE-2005-3254": {"epss_score": 0.00747, "epss_percentile": 0.72567}, "CVE-2005-3255": {"epss_score": 0.0027, "epss_percentile": 0.5027}, "CVE-2005-3256": {"epss_score": 0.00633, "epss_percentile": 0.69775}, "CVE-2005-3257": {"epss_score": 0.00385, "epss_percentile": 0.59226}, "CVE-2005-3258": {"epss_score": 0.24101, "epss_percentile": 0.95869}, "CVE-2005-3259": {"epss_score": 0.04581, "epss_percentile": 0.88876}, "CVE-2005-3260": {"epss_score": 0.00731, "epss_percentile": 0.72177}, "CVE-2005-3261": {"epss_score": 0.00619, "epss_percentile": 0.69393}, "CVE-2005-3262": {"epss_score": 0.09615, "epss_percentile": 0.92623}, "CVE-2005-3263": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2005-3264": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2005-3265": {"epss_score": 0.35548, "epss_percentile": 0.96918}, "CVE-2005-3267": {"epss_score": 0.18243, "epss_percentile": 0.94979}, "CVE-2005-3268": {"epss_score": 0.00058, "epss_percentile": 0.18288}, "CVE-2005-3269": {"epss_score": 0.04526, "epss_percentile": 0.88805}, "CVE-2005-3270": {"epss_score": 0.0027, "epss_percentile": 0.50264}, "CVE-2005-3271": {"epss_score": 0.00062, "epss_percentile": 0.1958}, "CVE-2005-3272": {"epss_score": 0.01652, "epss_percentile": 0.81574}, "CVE-2005-3273": {"epss_score": 0.0337, "epss_percentile": 0.87009}, "CVE-2005-3274": {"epss_score": 0.00126, "epss_percentile": 0.32661}, "CVE-2005-3275": {"epss_score": 0.0897, "epss_percentile": 0.92344}, "CVE-2005-3276": {"epss_score": 0.0011, "epss_percentile": 0.3012}, "CVE-2005-3277": {"epss_score": 0.31745, "epss_percentile": 0.96645}, "CVE-2005-3278": {"epss_score": 0.00186, "epss_percentile": 0.40656}, "CVE-2005-3279": {"epss_score": 0.00049, "epss_percentile": 0.15455}, "CVE-2005-3280": {"epss_score": 0.02023, "epss_percentile": 0.83307}, "CVE-2005-3281": {"epss_score": 0.00504, "epss_percentile": 0.65529}, "CVE-2005-3282": {"epss_score": 0.00237, "epss_percentile": 0.46644}, "CVE-2005-3283": {"epss_score": 0.00877, "epss_percentile": 0.74802}, "CVE-2005-3284": {"epss_score": 0.13392, "epss_percentile": 0.93951}, "CVE-2005-3285": {"epss_score": 0.00726, "epss_percentile": 0.72073}, "CVE-2005-3286": {"epss_score": 0.00096, "epss_percentile": 0.27357}, "CVE-2005-3287": {"epss_score": 0.00556, "epss_percentile": 0.67513}, "CVE-2005-3288": {"epss_score": 0.00559, "epss_percentile": 0.67623}, "CVE-2005-3289": {"epss_score": 0.00134, "epss_percentile": 0.33844}, "CVE-2005-3290": {"epss_score": 0.00773, "epss_percentile": 0.73062}, "CVE-2005-3291": {"epss_score": 0.00146, "epss_percentile": 0.35591}, "CVE-2005-3292": {"epss_score": 0.00362, "epss_percentile": 0.57779}, "CVE-2005-3293": {"epss_score": 0.1387, "epss_percentile": 0.94081}, "CVE-2005-3294": {"epss_score": 0.16885, "epss_percentile": 0.9474}, "CVE-2005-3295": {"epss_score": 0.00104, "epss_percentile": 0.29127}, "CVE-2005-3296": {"epss_score": 0.19976, "epss_percentile": 0.95269}, "CVE-2005-3297": {"epss_score": 0.04892, "epss_percentile": 0.89267}, "CVE-2005-3298": {"epss_score": 0.07959, "epss_percentile": 0.9179}, "CVE-2005-3299": {"epss_score": 0.08856, "epss_percentile": 0.92287}, "CVE-2005-3300": {"epss_score": 0.0189, "epss_percentile": 0.82727}, "CVE-2005-3301": {"epss_score": 0.11794, "epss_percentile": 0.93478}, "CVE-2005-3302": {"epss_score": 0.06201, "epss_percentile": 0.9056}, "CVE-2005-3303": {"epss_score": 0.0994, "epss_percentile": 0.92783}, "CVE-2005-3304": {"epss_score": 0.03585, "epss_percentile": 0.87391}, "CVE-2005-3305": {"epss_score": 0.03373, "epss_percentile": 0.87013}, "CVE-2005-3306": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2005-3307": {"epss_score": 0.03876, "epss_percentile": 0.87888}, "CVE-2005-3308": {"epss_score": 0.00949, "epss_percentile": 0.75844}, "CVE-2005-3309": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2005-3310": {"epss_score": 0.00544, "epss_percentile": 0.67128}, "CVE-2005-3311": {"epss_score": 0.00063, "epss_percentile": 0.19921}, "CVE-2005-3312": {"epss_score": 0.20358, "epss_percentile": 0.95332}, "CVE-2005-3313": {"epss_score": 0.03891, "epss_percentile": 0.8791}, "CVE-2005-3314": {"epss_score": 0.80815, "epss_percentile": 0.99108}, "CVE-2005-3315": {"epss_score": 0.08984, "epss_percentile": 0.9235}, "CVE-2005-3316": {"epss_score": 0.00905, "epss_percentile": 0.75233}, "CVE-2005-3317": {"epss_score": 0.07181, "epss_percentile": 0.91303}, "CVE-2005-3318": {"epss_score": 0.02959, "epss_percentile": 0.86069}, "CVE-2005-3319": {"epss_score": 0.00922, "epss_percentile": 0.75494}, "CVE-2005-3320": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2005-3321": {"epss_score": 0.00031, "epss_percentile": 0.08564}, "CVE-2005-3322": {"epss_score": 0.0071, "epss_percentile": 0.71724}, "CVE-2005-3323": {"epss_score": 0.02297, "epss_percentile": 0.84297}, "CVE-2005-3324": {"epss_score": 0.01658, "epss_percentile": 0.81608}, "CVE-2005-3325": {"epss_score": 0.03071, "epss_percentile": 0.86348}, "CVE-2005-3326": {"epss_score": 0.00564, "epss_percentile": 0.67768}, "CVE-2005-3327": {"epss_score": 0.00938, "epss_percentile": 0.75711}, "CVE-2005-3328": {"epss_score": 0.01922, "epss_percentile": 0.82903}, "CVE-2005-3329": {"epss_score": 0.01026, "epss_percentile": 0.76802}, "CVE-2005-3330": {"epss_score": 0.21314, "epss_percentile": 0.95499}, "CVE-2005-3331": {"epss_score": 0.00087, "epss_percentile": 0.25576}, "CVE-2005-3332": {"epss_score": 0.02711, "epss_percentile": 0.85497}, "CVE-2005-3333": {"epss_score": 0.00963, "epss_percentile": 0.76005}, "CVE-2005-3334": {"epss_score": 0.10245, "epss_percentile": 0.9291}, "CVE-2005-3335": {"epss_score": 0.0697, "epss_percentile": 0.91153}, "CVE-2005-3336": {"epss_score": 0.01343, "epss_percentile": 0.79604}, "CVE-2005-3337": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-3338": {"epss_score": 0.00591, "epss_percentile": 0.68578}, "CVE-2005-3339": {"epss_score": 0.00065, "epss_percentile": 0.20672}, "CVE-2005-3340": {"epss_score": 0.0006, "epss_percentile": 0.19008}, "CVE-2005-3341": {"epss_score": 0.00072, "epss_percentile": 0.22419}, "CVE-2005-3342": {"epss_score": 0.00062, "epss_percentile": 0.19576}, "CVE-2005-3343": {"epss_score": 0.00073, "epss_percentile": 0.22538}, "CVE-2005-3344": {"epss_score": 0.1015, "epss_percentile": 0.92865}, "CVE-2005-3345": {"epss_score": 0.00064, "epss_percentile": 0.20295}, "CVE-2005-3346": {"epss_score": 0.00244, "epss_percentile": 0.47517}, "CVE-2005-3347": {"epss_score": 0.02637, "epss_percentile": 0.85296}, "CVE-2005-3348": {"epss_score": 0.01621, "epss_percentile": 0.81389}, "CVE-2005-3349": {"epss_score": 0.00045, "epss_percentile": 0.13763}, "CVE-2005-3350": {"epss_score": 0.03936, "epss_percentile": 0.87985}, "CVE-2005-3351": {"epss_score": 0.17898, "epss_percentile": 0.94923}, "CVE-2005-3352": {"epss_score": 0.37141, "epss_percentile": 0.97022}, "CVE-2005-3353": {"epss_score": 0.1227, "epss_percentile": 0.93618}, "CVE-2005-3354": {"epss_score": 0.01447, "epss_percentile": 0.8033}, "CVE-2005-3355": {"epss_score": 0.00678, "epss_percentile": 0.7099}, "CVE-2005-3356": {"epss_score": 0.00068, "epss_percentile": 0.21362}, "CVE-2005-3357": {"epss_score": 0.43464, "epss_percentile": 0.97388}, "CVE-2005-3358": {"epss_score": 0.00185, "epss_percentile": 0.40509}, "CVE-2005-3359": {"epss_score": 0.00045, "epss_percentile": 0.13828}, "CVE-2005-3360": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2005-3361": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-3363": {"epss_score": 0.08992, "epss_percentile": 0.92356}, "CVE-2005-3364": {"epss_score": 0.01233, "epss_percentile": 0.78751}, "CVE-2005-3365": {"epss_score": 0.02116, "epss_percentile": 0.83664}, "CVE-2005-3366": {"epss_score": 0.03833, "epss_percentile": 0.87811}, "CVE-2005-3367": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-3368": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2005-3369": {"epss_score": 0.00604, "epss_percentile": 0.68959}, "CVE-2005-3370": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2005-3371": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2005-3372": {"epss_score": 0.00521, "epss_percentile": 0.66235}, "CVE-2005-3373": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2005-3374": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2005-3375": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2005-3376": {"epss_score": 0.00578, "epss_percentile": 0.68198}, "CVE-2005-3377": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2005-3378": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2005-3379": {"epss_score": 0.00233, "epss_percentile": 0.46075}, "CVE-2005-3380": {"epss_score": 0.00787, "epss_percentile": 0.7332}, "CVE-2005-3381": {"epss_score": 0.01071, "epss_percentile": 0.77267}, "CVE-2005-3382": {"epss_score": 0.0367, "epss_percentile": 0.87538}, "CVE-2005-3383": {"epss_score": 0.02098, "epss_percentile": 0.83591}, "CVE-2005-3384": {"epss_score": 0.01398, "epss_percentile": 0.79991}, "CVE-2005-3385": {"epss_score": 0.02098, "epss_percentile": 0.83591}, "CVE-2005-3386": {"epss_score": 0.01128, "epss_percentile": 0.77827}, "CVE-2005-3387": {"epss_score": 0.00425, "epss_percentile": 0.61692}, "CVE-2005-3388": {"epss_score": 0.63293, "epss_percentile": 0.98327}, "CVE-2005-3389": {"epss_score": 0.09558, "epss_percentile": 0.92598}, "CVE-2005-3390": {"epss_score": 0.61608, "epss_percentile": 0.98254}, "CVE-2005-3391": {"epss_score": 0.14671, "epss_percentile": 0.9426}, "CVE-2005-3392": {"epss_score": 0.0864, "epss_percentile": 0.92168}, "CVE-2005-3393": {"epss_score": 0.0162, "epss_percentile": 0.81386}, "CVE-2005-3394": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2005-3395": {"epss_score": 0.00689, "epss_percentile": 0.71227}, "CVE-2005-3396": {"epss_score": 0.02352, "epss_percentile": 0.84473}, "CVE-2005-3397": {"epss_score": 0.00558, "epss_percentile": 0.676}, "CVE-2005-3398": {"epss_score": 0.39542, "epss_percentile": 0.97166}, "CVE-2005-3399": {"epss_score": 0.00217, "epss_percentile": 0.44305}, "CVE-2005-3400": {"epss_score": 0.00219, "epss_percentile": 0.44501}, "CVE-2005-3401": {"epss_score": 0.0064, "epss_percentile": 0.69955}, "CVE-2005-3402": {"epss_score": 0.00142, "epss_percentile": 0.35033}, "CVE-2005-3403": {"epss_score": 0.01281, "epss_percentile": 0.79145}, "CVE-2005-3404": {"epss_score": 0.09524, "epss_percentile": 0.92585}, "CVE-2005-3405": {"epss_score": 0.11893, "epss_percentile": 0.93509}, "CVE-2005-3406": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2005-3407": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2005-3408": {"epss_score": 0.00885, "epss_percentile": 0.74942}, "CVE-2005-3409": {"epss_score": 0.02512, "epss_percentile": 0.84957}, "CVE-2005-3411": {"epss_score": 0.00807, "epss_percentile": 0.7367}, "CVE-2005-3412": {"epss_score": 0.08591, "epss_percentile": 0.9214}, "CVE-2005-3413": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2005-3414": {"epss_score": 0.01414, "epss_percentile": 0.8013}, "CVE-2005-3415": {"epss_score": 0.00989, "epss_percentile": 0.76368}, "CVE-2005-3416": {"epss_score": 0.00842, "epss_percentile": 0.74235}, "CVE-2005-3417": {"epss_score": 0.00842, "epss_percentile": 0.74235}, "CVE-2005-3418": {"epss_score": 0.01451, "epss_percentile": 0.80363}, "CVE-2005-3419": {"epss_score": 0.01314, "epss_percentile": 0.79395}, "CVE-2005-3420": {"epss_score": 0.02323, "epss_percentile": 0.84374}, "CVE-2005-3421": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-3422": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-3423": {"epss_score": 0.01724, "epss_percentile": 0.81949}, "CVE-2005-3424": {"epss_score": 0.00605, "epss_percentile": 0.6898}, "CVE-2005-3425": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2005-3426": {"epss_score": 0.00492, "epss_percentile": 0.64997}, "CVE-2005-3427": {"epss_score": 0.00418, "epss_percentile": 0.6127}, "CVE-2005-3428": {"epss_score": 0.00921, "epss_percentile": 0.75479}, "CVE-2005-3429": {"epss_score": 0.00649, "epss_percentile": 0.70238}, "CVE-2005-3430": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2005-3431": {"epss_score": 0.00807, "epss_percentile": 0.73678}, "CVE-2005-3432": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2005-3433": {"epss_score": 0.00806, "epss_percentile": 0.73649}, "CVE-2005-3434": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2005-3435": {"epss_score": 0.00856, "epss_percentile": 0.74485}, "CVE-2005-3436": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-3437": {"epss_score": 0.0321, "epss_percentile": 0.86649}, "CVE-2005-3438": {"epss_score": 0.07741, "epss_percentile": 0.91653}, "CVE-2005-3439": {"epss_score": 0.01435, "epss_percentile": 0.80268}, "CVE-2005-3440": {"epss_score": 0.0321, "epss_percentile": 0.86649}, "CVE-2005-3441": {"epss_score": 0.03935, "epss_percentile": 0.87983}, "CVE-2005-3442": {"epss_score": 0.01435, "epss_percentile": 0.80268}, "CVE-2005-3443": {"epss_score": 0.04242, "epss_percentile": 0.88436}, "CVE-2005-3444": {"epss_score": 0.02049, "epss_percentile": 0.83395}, "CVE-2005-3445": {"epss_score": 0.02021, "epss_percentile": 0.83297}, "CVE-2005-3446": {"epss_score": 0.02049, "epss_percentile": 0.83395}, "CVE-2005-3447": {"epss_score": 0.01435, "epss_percentile": 0.80268}, "CVE-2005-3448": {"epss_score": 0.02049, "epss_percentile": 0.83395}, "CVE-2005-3449": {"epss_score": 0.01626, "epss_percentile": 0.81426}, "CVE-2005-3450": {"epss_score": 0.02049, "epss_percentile": 0.83395}, "CVE-2005-3451": {"epss_score": 0.02021, "epss_percentile": 0.83297}, "CVE-2005-3452": {"epss_score": 0.01545, "epss_percentile": 0.80961}, "CVE-2005-3453": {"epss_score": 0.01545, "epss_percentile": 0.80961}, "CVE-2005-3454": {"epss_score": 0.04242, "epss_percentile": 0.88436}, "CVE-2005-3455": {"epss_score": 0.02045, "epss_percentile": 0.83384}, "CVE-2005-3456": {"epss_score": 0.03935, "epss_percentile": 0.87983}, "CVE-2005-3457": {"epss_score": 0.04242, "epss_percentile": 0.88436}, "CVE-2005-3458": {"epss_score": 0.03935, "epss_percentile": 0.87983}, "CVE-2005-3459": {"epss_score": 0.04242, "epss_percentile": 0.88436}, "CVE-2005-3460": {"epss_score": 0.02057, "epss_percentile": 0.8343}, "CVE-2005-3461": {"epss_score": 0.02937, "epss_percentile": 0.86026}, "CVE-2005-3462": {"epss_score": 0.04242, "epss_percentile": 0.88436}, "CVE-2005-3463": {"epss_score": 0.03168, "epss_percentile": 0.86545}, "CVE-2005-3464": {"epss_score": 0.04242, "epss_percentile": 0.88436}, "CVE-2005-3465": {"epss_score": 0.04242, "epss_percentile": 0.88436}, "CVE-2005-3466": {"epss_score": 0.04242, "epss_percentile": 0.88436}, "CVE-2005-3467": {"epss_score": 0.02043, "epss_percentile": 0.83377}, "CVE-2005-3468": {"epss_score": 0.00832, "epss_percentile": 0.7407}, "CVE-2005-3469": {"epss_score": 0.00446, "epss_percentile": 0.62924}, "CVE-2005-3470": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-3471": {"epss_score": 0.00264, "epss_percentile": 0.49739}, "CVE-2005-3472": {"epss_score": 0.00568, "epss_percentile": 0.67896}, "CVE-2005-3473": {"epss_score": 0.03632, "epss_percentile": 0.87474}, "CVE-2005-3474": {"epss_score": 0.00069, "epss_percentile": 0.2146}, "CVE-2005-3475": {"epss_score": 0.05187, "epss_percentile": 0.89591}, "CVE-2005-3476": {"epss_score": 0.00071, "epss_percentile": 0.22032}, "CVE-2005-3477": {"epss_score": 0.00497, "epss_percentile": 0.65181}, "CVE-2005-3478": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2005-3479": {"epss_score": 0.00364, "epss_percentile": 0.57938}, "CVE-2005-3480": {"epss_score": 0.00424, "epss_percentile": 0.61683}, "CVE-2005-3481": {"epss_score": 0.05119, "epss_percentile": 0.89516}, "CVE-2005-3482": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2005-3483": {"epss_score": 0.19536, "epss_percentile": 0.95202}, "CVE-2005-3484": {"epss_score": 0.00835, "epss_percentile": 0.7412}, "CVE-2005-3485": {"epss_score": 0.11748, "epss_percentile": 0.93465}, "CVE-2005-3486": {"epss_score": 0.14124, "epss_percentile": 0.94139}, "CVE-2005-3487": {"epss_score": 0.18228, "epss_percentile": 0.94977}, "CVE-2005-3488": {"epss_score": 0.1011, "epss_percentile": 0.92853}, "CVE-2005-3489": {"epss_score": 0.23068, "epss_percentile": 0.95729}, "CVE-2005-3490": {"epss_score": 0.00523, "epss_percentile": 0.66309}, "CVE-2005-3491": {"epss_score": 0.07073, "epss_percentile": 0.91231}, "CVE-2005-3492": {"epss_score": 0.08724, "epss_percentile": 0.92228}, "CVE-2005-3493": {"epss_score": 0.04736, "epss_percentile": 0.89074}, "CVE-2005-3494": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2005-3495": {"epss_score": 0.00644, "epss_percentile": 0.70079}, "CVE-2005-3496": {"epss_score": 0.00553, "epss_percentile": 0.67432}, "CVE-2005-3497": {"epss_score": 0.01053, "epss_percentile": 0.77098}, "CVE-2005-3498": {"epss_score": 0.51951, "epss_percentile": 0.97803}, "CVE-2005-3499": {"epss_score": 0.0124, "epss_percentile": 0.78801}, "CVE-2005-3500": {"epss_score": 0.05935, "epss_percentile": 0.90341}, "CVE-2005-3501": {"epss_score": 0.07361, "epss_percentile": 0.91431}, "CVE-2005-3502": {"epss_score": 0.00619, "epss_percentile": 0.69393}, "CVE-2005-3503": {"epss_score": 0.00702, "epss_percentile": 0.71522}, "CVE-2005-3504": {"epss_score": 0.04466, "epss_percentile": 0.88729}, "CVE-2005-3505": {"epss_score": 0.01262, "epss_percentile": 0.78978}, "CVE-2005-3506": {"epss_score": 0.00401, "epss_percentile": 0.60213}, "CVE-2005-3507": {"epss_score": 0.05826, "epss_percentile": 0.90238}, "CVE-2005-3508": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2005-3509": {"epss_score": 0.00333, "epss_percentile": 0.55679}, "CVE-2005-3510": {"epss_score": 0.20508, "epss_percentile": 0.95359}, "CVE-2005-3511": {"epss_score": 0.00389, "epss_percentile": 0.59467}, "CVE-2005-3512": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2005-3513": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-3514": {"epss_score": 0.01035, "epss_percentile": 0.76901}, "CVE-2005-3515": {"epss_score": 0.007, "epss_percentile": 0.7148}, "CVE-2005-3516": {"epss_score": 0.007, "epss_percentile": 0.7148}, "CVE-2005-3517": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-3518": {"epss_score": 0.01501, "epss_percentile": 0.80718}, "CVE-2005-3519": {"epss_score": 0.03938, "epss_percentile": 0.87986}, "CVE-2005-3520": {"epss_score": 0.00966, "epss_percentile": 0.76053}, "CVE-2005-3521": {"epss_score": 0.01327, "epss_percentile": 0.79484}, "CVE-2005-3522": {"epss_score": 0.07035, "epss_percentile": 0.91204}, "CVE-2005-3523": {"epss_score": 0.24803, "epss_percentile": 0.95956}, "CVE-2005-3524": {"epss_score": 0.25484, "epss_percentile": 0.96033}, "CVE-2005-3525": {"epss_score": 0.37658, "epss_percentile": 0.97062}, "CVE-2005-3526": {"epss_score": 0.0087, "epss_percentile": 0.74695}, "CVE-2005-3527": {"epss_score": 0.00067, "epss_percentile": 0.21027}, "CVE-2005-3528": {"epss_score": 0.00565, "epss_percentile": 0.67806}, "CVE-2005-3529": {"epss_score": 0.00635, "epss_percentile": 0.69822}, "CVE-2005-3530": {"epss_score": 0.00714, "epss_percentile": 0.71818}, "CVE-2005-3531": {"epss_score": 0.00078, "epss_percentile": 0.23623}, "CVE-2005-3532": {"epss_score": 0.00902, "epss_percentile": 0.75194}, "CVE-2005-3533": {"epss_score": 0.00239, "epss_percentile": 0.46858}, "CVE-2005-3534": {"epss_score": 0.13886, "epss_percentile": 0.94086}, "CVE-2005-3535": {"epss_score": 0.01417, "epss_percentile": 0.80149}, "CVE-2005-3536": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-3537": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2005-3538": {"epss_score": 0.02373, "epss_percentile": 0.84534}, "CVE-2005-3539": {"epss_score": 0.31002, "epss_percentile": 0.96581}, "CVE-2005-3540": {"epss_score": 0.03528, "epss_percentile": 0.87297}, "CVE-2005-3543": {"epss_score": 0.01111, "epss_percentile": 0.77671}, "CVE-2005-3544": {"epss_score": 0.01045, "epss_percentile": 0.77023}, "CVE-2005-3545": {"epss_score": 0.00819, "epss_percentile": 0.73866}, "CVE-2005-3546": {"epss_score": 0.00303, "epss_percentile": 0.53205}, "CVE-2005-3547": {"epss_score": 0.01467, "epss_percentile": 0.80467}, "CVE-2005-3548": {"epss_score": 0.00369, "epss_percentile": 0.58246}, "CVE-2005-3549": {"epss_score": 0.01712, "epss_percentile": 0.81886}, "CVE-2005-3550": {"epss_score": 0.042, "epss_percentile": 0.88386}, "CVE-2005-3551": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2005-3552": {"epss_score": 0.01419, "epss_percentile": 0.80163}, "CVE-2005-3553": {"epss_score": 0.01887, "epss_percentile": 0.82718}, "CVE-2005-3554": {"epss_score": 0.05131, "epss_percentile": 0.8953}, "CVE-2005-3555": {"epss_score": 0.02449, "epss_percentile": 0.84775}, "CVE-2005-3556": {"epss_score": 0.05274, "epss_percentile": 0.89681}, "CVE-2005-3557": {"epss_score": 0.01076, "epss_percentile": 0.77329}, "CVE-2005-3558": {"epss_score": 0.03748, "epss_percentile": 0.87666}, "CVE-2005-3559": {"epss_score": 0.05519, "epss_percentile": 0.89955}, "CVE-2005-3560": {"epss_score": 0.09663, "epss_percentile": 0.92646}, "CVE-2005-3564": {"epss_score": 0.00061, "epss_percentile": 0.1931}, "CVE-2005-3565": {"epss_score": 0.02353, "epss_percentile": 0.84477}, "CVE-2005-3566": {"epss_score": 0.00336, "epss_percentile": 0.55947}, "CVE-2005-3567": {"epss_score": 0.00912, "epss_percentile": 0.75355}, "CVE-2005-3568": {"epss_score": 0.0007, "epss_percentile": 0.21947}, "CVE-2005-3569": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2005-3570": {"epss_score": 0.01316, "epss_percentile": 0.79407}, "CVE-2005-3571": {"epss_score": 0.08978, "epss_percentile": 0.92348}, "CVE-2005-3572": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-3573": {"epss_score": 0.05745, "epss_percentile": 0.90174}, "CVE-2005-3574": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-3575": {"epss_score": 0.01149, "epss_percentile": 0.78018}, "CVE-2005-3576": {"epss_score": 0.06958, "epss_percentile": 0.91148}, "CVE-2005-3577": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-3578": {"epss_score": 0.00808, "epss_percentile": 0.73695}, "CVE-2005-3579": {"epss_score": 0.0739, "epss_percentile": 0.91448}, "CVE-2005-3580": {"epss_score": 0.00055, "epss_percentile": 0.17461}, "CVE-2005-3581": {"epss_score": 0.00055, "epss_percentile": 0.17461}, "CVE-2005-3582": {"epss_score": 0.00055, "epss_percentile": 0.17461}, "CVE-2005-3583": {"epss_score": 0.0094, "epss_percentile": 0.75739}, "CVE-2005-3584": {"epss_score": 0.00353, "epss_percentile": 0.57198}, "CVE-2005-3585": {"epss_score": 0.0108, "epss_percentile": 0.77369}, "CVE-2005-3586": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2005-3587": {"epss_score": 0.00369, "epss_percentile": 0.58231}, "CVE-2005-3588": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-3589": {"epss_score": 0.67665, "epss_percentile": 0.98516}, "CVE-2005-3590": {"epss_score": 0.00492, "epss_percentile": 0.65002}, "CVE-2005-3591": {"epss_score": 0.364, "epss_percentile": 0.96973}, "CVE-2005-3592": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-3594": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2005-3595": {"epss_score": 0.34026, "epss_percentile": 0.96822}, "CVE-2005-3596": {"epss_score": 0.02235, "epss_percentile": 0.841}, "CVE-2005-3618": {"epss_score": 0.02133, "epss_percentile": 0.83717}, "CVE-2005-3619": {"epss_score": 0.00944, "epss_percentile": 0.7579}, "CVE-2005-3620": {"epss_score": 0.0011, "epss_percentile": 0.3008}, "CVE-2005-3621": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2005-3622": {"epss_score": 0.00631, "epss_percentile": 0.69715}, "CVE-2005-3623": {"epss_score": 0.00966, "epss_percentile": 0.76055}, "CVE-2005-3624": {"epss_score": 0.07357, "epss_percentile": 0.91429}, "CVE-2005-3625": {"epss_score": 0.11286, "epss_percentile": 0.93292}, "CVE-2005-3626": {"epss_score": 0.09332, "epss_percentile": 0.92504}, "CVE-2005-3627": {"epss_score": 0.04327, "epss_percentile": 0.88555}, "CVE-2005-3628": {"epss_score": 0.02683, "epss_percentile": 0.85421}, "CVE-2005-3629": {"epss_score": 0.00034, "epss_percentile": 0.09615}, "CVE-2005-3630": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-3631": {"epss_score": 0.00052, "epss_percentile": 0.16389}, "CVE-2005-3632": {"epss_score": 0.00245, "epss_percentile": 0.4767}, "CVE-2005-3633": {"epss_score": 0.00979, "epss_percentile": 0.76261}, "CVE-2005-3634": {"epss_score": 0.01653, "epss_percentile": 0.81581}, "CVE-2005-3635": {"epss_score": 0.2264, "epss_percentile": 0.95662}, "CVE-2005-3636": {"epss_score": 0.2264, "epss_percentile": 0.95662}, "CVE-2005-3638": {"epss_score": 0.00758, "epss_percentile": 0.72782}, "CVE-2005-3639": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2005-3640": {"epss_score": 0.08448, "epss_percentile": 0.92057}, "CVE-2005-3641": {"epss_score": 0.00654, "epss_percentile": 0.70355}, "CVE-2005-3642": {"epss_score": 0.00572, "epss_percentile": 0.6803}, "CVE-2005-3643": {"epss_score": 0.00572, "epss_percentile": 0.6803}, "CVE-2005-3644": {"epss_score": 0.5913, "epss_percentile": 0.98151}, "CVE-2005-3645": {"epss_score": 0.02009, "epss_percentile": 0.83245}, "CVE-2005-3646": {"epss_score": 0.02503, "epss_percentile": 0.8493}, "CVE-2005-3647": {"epss_score": 0.00059, "epss_percentile": 0.18671}, "CVE-2005-3648": {"epss_score": 0.01452, "epss_percentile": 0.80371}, "CVE-2005-3649": {"epss_score": 0.08387, "epss_percentile": 0.92022}, "CVE-2005-3650": {"epss_score": 0.09353, "epss_percentile": 0.92513}, "CVE-2005-3651": {"epss_score": 0.05202, "epss_percentile": 0.89605}, "CVE-2005-3652": {"epss_score": 0.11297, "epss_percentile": 0.93296}, "CVE-2005-3653": {"epss_score": 0.30442, "epss_percentile": 0.9654}, "CVE-2005-3654": {"epss_score": 0.03286, "epss_percentile": 0.86828}, "CVE-2005-3655": {"epss_score": 0.03746, "epss_percentile": 0.87664}, "CVE-2005-3656": {"epss_score": 0.49577, "epss_percentile": 0.97695}, "CVE-2005-3657": {"epss_score": 0.00693, "epss_percentile": 0.71329}, "CVE-2005-3658": {"epss_score": 0.05673, "epss_percentile": 0.90105}, "CVE-2005-3659": {"epss_score": 0.04044, "epss_percentile": 0.8817}, "CVE-2005-3660": {"epss_score": 0.00055, "epss_percentile": 0.17623}, "CVE-2005-3661": {"epss_score": 0.00861, "epss_percentile": 0.74561}, "CVE-2005-3662": {"epss_score": 0.00279, "epss_percentile": 0.5098}, "CVE-2005-3663": {"epss_score": 0.00058, "epss_percentile": 0.18514}, "CVE-2005-3664": {"epss_score": 0.07959, "epss_percentile": 0.9179}, "CVE-2005-3665": {"epss_score": 0.01116, "epss_percentile": 0.77721}, "CVE-2005-3666": {"epss_score": 0.00753, "epss_percentile": 0.72674}, "CVE-2005-3667": {"epss_score": 0.00618, "epss_percentile": 0.69386}, "CVE-2005-3668": {"epss_score": 0.01052, "epss_percentile": 0.77093}, "CVE-2005-3669": {"epss_score": 0.09461, "epss_percentile": 0.92558}, "CVE-2005-3670": {"epss_score": 0.2526, "epss_percentile": 0.96005}, "CVE-2005-3671": {"epss_score": 0.06721, "epss_percentile": 0.90968}, "CVE-2005-3672": {"epss_score": 0.06741, "epss_percentile": 0.90996}, "CVE-2005-3673": {"epss_score": 0.09317, "epss_percentile": 0.92497}, "CVE-2005-3674": {"epss_score": 0.08207, "epss_percentile": 0.9193}, "CVE-2005-3675": {"epss_score": 0.05452, "epss_percentile": 0.89892}, "CVE-2005-3676": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-3677": {"epss_score": 0.03528, "epss_percentile": 0.87297}, "CVE-2005-3678": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2005-3679": {"epss_score": 0.01621, "epss_percentile": 0.81392}, "CVE-2005-3680": {"epss_score": 0.00678, "epss_percentile": 0.71003}, "CVE-2005-3681": {"epss_score": 0.00442, "epss_percentile": 0.62735}, "CVE-2005-3682": {"epss_score": 0.04908, "epss_percentile": 0.89278}, "CVE-2005-3683": {"epss_score": 0.84662, "epss_percentile": 0.993}, "CVE-2005-3684": {"epss_score": 0.145, "epss_percentile": 0.94225}, "CVE-2005-3685": {"epss_score": 0.00809, "epss_percentile": 0.7371}, "CVE-2005-3686": {"epss_score": 0.01225, "epss_percentile": 0.78684}, "CVE-2005-3687": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2005-3688": {"epss_score": 0.00944, "epss_percentile": 0.75793}, "CVE-2005-3689": {"epss_score": 0.01001, "epss_percentile": 0.76502}, "CVE-2005-3690": {"epss_score": 0.11906, "epss_percentile": 0.93511}, "CVE-2005-3691": {"epss_score": 0.04056, "epss_percentile": 0.88185}, "CVE-2005-3692": {"epss_score": 0.00794, "epss_percentile": 0.73453}, "CVE-2005-3693": {"epss_score": 0.02052, "epss_percentile": 0.83409}, "CVE-2005-3694": {"epss_score": 0.18723, "epss_percentile": 0.95058}, "CVE-2005-3695": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2005-3696": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2005-3697": {"epss_score": 0.00572, "epss_percentile": 0.6803}, "CVE-2005-3698": {"epss_score": 0.00455, "epss_percentile": 0.63307}, "CVE-2005-3699": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2005-3700": {"epss_score": 0.00074, "epss_percentile": 0.22859}, "CVE-2005-3701": {"epss_score": 0.00064, "epss_percentile": 0.20295}, "CVE-2005-3702": {"epss_score": 0.00638, "epss_percentile": 0.69905}, "CVE-2005-3704": {"epss_score": 0.00647, "epss_percentile": 0.70189}, "CVE-2005-3705": {"epss_score": 0.05356, "epss_percentile": 0.89779}, "CVE-2005-3706": {"epss_score": 0.01488, "epss_percentile": 0.80619}, "CVE-2005-3707": {"epss_score": 0.16948, "epss_percentile": 0.94752}, "CVE-2005-3708": {"epss_score": 0.03286, "epss_percentile": 0.86828}, "CVE-2005-3709": {"epss_score": 0.04957, "epss_percentile": 0.8933}, "CVE-2005-3710": {"epss_score": 0.32161, "epss_percentile": 0.96674}, "CVE-2005-3711": {"epss_score": 0.05504, "epss_percentile": 0.89941}, "CVE-2005-3712": {"epss_score": 0.04452, "epss_percentile": 0.88706}, "CVE-2005-3713": {"epss_score": 0.39682, "epss_percentile": 0.97175}, "CVE-2005-3714": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2005-3715": {"epss_score": 0.0068, "epss_percentile": 0.71036}, "CVE-2005-3716": {"epss_score": 0.00507, "epss_percentile": 0.65651}, "CVE-2005-3717": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2005-3718": {"epss_score": 0.01606, "epss_percentile": 0.81296}, "CVE-2005-3719": {"epss_score": 0.00074, "epss_percentile": 0.2281}, "CVE-2005-3720": {"epss_score": 0.00395, "epss_percentile": 0.59842}, "CVE-2005-3721": {"epss_score": 0.00549, "epss_percentile": 0.67308}, "CVE-2005-3722": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-3723": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-3724": {"epss_score": 0.0166, "epss_percentile": 0.81619}, "CVE-2005-3725": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-3726": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-3727": {"epss_score": 0.03693, "epss_percentile": 0.87579}, "CVE-2005-3728": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2005-3729": {"epss_score": 0.00517, "epss_percentile": 0.66091}, "CVE-2005-3730": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2005-3731": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2005-3732": {"epss_score": 0.1886, "epss_percentile": 0.9508}, "CVE-2005-3733": {"epss_score": 0.06506, "epss_percentile": 0.90807}, "CVE-2005-3734": {"epss_score": 0.00714, "epss_percentile": 0.71818}, "CVE-2005-3735": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2005-3736": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2005-3737": {"epss_score": 0.28064, "epss_percentile": 0.96305}, "CVE-2005-3738": {"epss_score": 0.07523, "epss_percentile": 0.91515}, "CVE-2005-3739": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2005-3740": {"epss_score": 0.01467, "epss_percentile": 0.80473}, "CVE-2005-3741": {"epss_score": 0.00467, "epss_percentile": 0.63825}, "CVE-2005-3742": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2005-3743": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2005-3744": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-3745": {"epss_score": 0.55839, "epss_percentile": 0.97999}, "CVE-2005-3746": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2005-3747": {"epss_score": 0.17313, "epss_percentile": 0.9482}, "CVE-2005-3748": {"epss_score": 0.00533, "epss_percentile": 0.66759}, "CVE-2005-3749": {"epss_score": 0.00064, "epss_percentile": 0.20137}, "CVE-2005-3750": {"epss_score": 0.07619, "epss_percentile": 0.91574}, "CVE-2005-3751": {"epss_score": 0.0177, "epss_percentile": 0.82192}, "CVE-2005-3752": {"epss_score": 0.00376, "epss_percentile": 0.58674}, "CVE-2005-3753": {"epss_score": 0.00392, "epss_percentile": 0.59678}, "CVE-2005-3754": {"epss_score": 0.00901, "epss_percentile": 0.75171}, "CVE-2005-3755": {"epss_score": 0.04746, "epss_percentile": 0.89097}, "CVE-2005-3756": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2005-3757": {"epss_score": 0.75746, "epss_percentile": 0.98862}, "CVE-2005-3758": {"epss_score": 0.00901, "epss_percentile": 0.75171}, "CVE-2005-3759": {"epss_score": 0.00714, "epss_percentile": 0.71818}, "CVE-2005-3760": {"epss_score": 0.00546, "epss_percentile": 0.6722}, "CVE-2005-3761": {"epss_score": 0.00364, "epss_percentile": 0.57938}, "CVE-2005-3762": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2005-3763": {"epss_score": 0.00424, "epss_percentile": 0.61683}, "CVE-2005-3764": {"epss_score": 0.00402, "epss_percentile": 0.60263}, "CVE-2005-3765": {"epss_score": 0.017, "epss_percentile": 0.81824}, "CVE-2005-3766": {"epss_score": 0.00299, "epss_percentile": 0.52846}, "CVE-2005-3767": {"epss_score": 0.00524, "epss_percentile": 0.66329}, "CVE-2005-3768": {"epss_score": 0.04, "epss_percentile": 0.88091}, "CVE-2005-3769": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2005-3770": {"epss_score": 0.01081, "epss_percentile": 0.7737}, "CVE-2005-3771": {"epss_score": 0.0002, "epss_percentile": 0.04463}, "CVE-2005-3772": {"epss_score": 0.00024, "epss_percentile": 0.05978}, "CVE-2005-3773": {"epss_score": 0.0001, "epss_percentile": 0.00896}, "CVE-2005-3774": {"epss_score": 0.35143, "epss_percentile": 0.9689}, "CVE-2005-3775": {"epss_score": 0.00963, "epss_percentile": 0.76021}, "CVE-2005-3776": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-3777": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2005-3778": {"epss_score": 0.00419, "epss_percentile": 0.61355}, "CVE-2005-3779": {"epss_score": 0.00064, "epss_percentile": 0.20256}, "CVE-2005-3780": {"epss_score": 0.01602, "epss_percentile": 0.81273}, "CVE-2005-3781": {"epss_score": 0.00772, "epss_percentile": 0.73032}, "CVE-2005-3782": {"epss_score": 0.00068, "epss_percentile": 0.21315}, "CVE-2005-3783": {"epss_score": 0.00064, "epss_percentile": 0.20136}, "CVE-2005-3784": {"epss_score": 0.00062, "epss_percentile": 0.19555}, "CVE-2005-3785": {"epss_score": 0.00523, "epss_percentile": 0.66304}, "CVE-2005-3786": {"epss_score": 0.00072, "epss_percentile": 0.22307}, "CVE-2005-3787": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-3788": {"epss_score": 0.01219, "epss_percentile": 0.7861}, "CVE-2005-3789": {"epss_score": 0.04783, "epss_percentile": 0.89139}, "CVE-2005-3790": {"epss_score": 0.03691, "epss_percentile": 0.87576}, "CVE-2005-3791": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2005-3792": {"epss_score": 0.69317, "epss_percentile": 0.98583}, "CVE-2005-3793": {"epss_score": 0.01011, "epss_percentile": 0.76615}, "CVE-2005-3794": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-3795": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-3796": {"epss_score": 0.00743, "epss_percentile": 0.72481}, "CVE-2005-3797": {"epss_score": 0.03727, "epss_percentile": 0.87635}, "CVE-2005-3798": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2005-3799": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2005-3800": {"epss_score": 0.0054, "epss_percentile": 0.67001}, "CVE-2005-3801": {"epss_score": 0.00037, "epss_percentile": 0.10656}, "CVE-2005-3802": {"epss_score": 0.01351, "epss_percentile": 0.79679}, "CVE-2005-3803": {"epss_score": 0.01175, "epss_percentile": 0.78264}, "CVE-2005-3804": {"epss_score": 0.01525, "epss_percentile": 0.80858}, "CVE-2005-3805": {"epss_score": 0.00047, "epss_percentile": 0.14598}, "CVE-2005-3806": {"epss_score": 0.00165, "epss_percentile": 0.38066}, "CVE-2005-3807": {"epss_score": 0.00147, "epss_percentile": 0.35674}, "CVE-2005-3808": {"epss_score": 0.00201, "epss_percentile": 0.42351}, "CVE-2005-3809": {"epss_score": 0.00492, "epss_percentile": 0.65005}, "CVE-2005-3810": {"epss_score": 0.00392, "epss_percentile": 0.59678}, "CVE-2005-3811": {"epss_score": 0.07312, "epss_percentile": 0.91402}, "CVE-2005-3812": {"epss_score": 0.04187, "epss_percentile": 0.88364}, "CVE-2005-3813": {"epss_score": 0.06223, "epss_percentile": 0.90583}, "CVE-2005-3814": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2005-3815": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-3816": {"epss_score": 0.00542, "epss_percentile": 0.67064}, "CVE-2005-3817": {"epss_score": 0.00937, "epss_percentile": 0.75696}, "CVE-2005-3818": {"epss_score": 0.01345, "epss_percentile": 0.79621}, "CVE-2005-3819": {"epss_score": 0.01596, "epss_percentile": 0.8124}, "CVE-2005-3820": {"epss_score": 0.01164, "epss_percentile": 0.78163}, "CVE-2005-3821": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-3822": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-3823": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2005-3824": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2005-3825": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-3826": {"epss_score": 0.00677, "epss_percentile": 0.7096}, "CVE-2005-3827": {"epss_score": 0.00553, "epss_percentile": 0.6742}, "CVE-2005-3828": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-3829": {"epss_score": 0.00834, "epss_percentile": 0.74111}, "CVE-2005-3830": {"epss_score": 0.00592, "epss_percentile": 0.6862}, "CVE-2005-3831": {"epss_score": 0.01899, "epss_percentile": 0.82765}, "CVE-2005-3832": {"epss_score": 0.01346, "epss_percentile": 0.79631}, "CVE-2005-3833": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2005-3834": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2005-3835": {"epss_score": 0.01066, "epss_percentile": 0.77219}, "CVE-2005-3836": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-3837": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-3838": {"epss_score": 0.00826, "epss_percentile": 0.73974}, "CVE-2005-3839": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-3840": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-3841": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2005-3842": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2005-3843": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-3844": {"epss_score": 0.00542, "epss_percentile": 0.67064}, "CVE-2005-3845": {"epss_score": 0.00399, "epss_percentile": 0.60094}, "CVE-2005-3846": {"epss_score": 0.00677, "epss_percentile": 0.7096}, "CVE-2005-3847": {"epss_score": 0.00067, "epss_percentile": 0.21045}, "CVE-2005-3848": {"epss_score": 0.067, "epss_percentile": 0.90955}, "CVE-2005-3849": {"epss_score": 0.00945, "epss_percentile": 0.758}, "CVE-2005-3850": {"epss_score": 0.00416, "epss_percentile": 0.61177}, "CVE-2005-3851": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-3852": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-3853": {"epss_score": 0.00362, "epss_percentile": 0.57797}, "CVE-2005-3854": {"epss_score": 0.0043, "epss_percentile": 0.62013}, "CVE-2005-3855": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2005-3856": {"epss_score": 0.00355, "epss_percentile": 0.57283}, "CVE-2005-3857": {"epss_score": 0.00295, "epss_percentile": 0.52468}, "CVE-2005-3858": {"epss_score": 0.0168, "epss_percentile": 0.81724}, "CVE-2005-3859": {"epss_score": 0.05614, "epss_percentile": 0.9005}, "CVE-2005-3860": {"epss_score": 0.05163, "epss_percentile": 0.89561}, "CVE-2005-3861": {"epss_score": 0.03151, "epss_percentile": 0.86507}, "CVE-2005-3862": {"epss_score": 0.35779, "epss_percentile": 0.96934}, "CVE-2005-3863": {"epss_score": 0.0726, "epss_percentile": 0.91355}, "CVE-2005-3864": {"epss_score": 0.00446, "epss_percentile": 0.62924}, "CVE-2005-3865": {"epss_score": 0.00512, "epss_percentile": 0.65866}, "CVE-2005-3866": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2005-3867": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-3868": {"epss_score": 0.00632, "epss_percentile": 0.69734}, "CVE-2005-3869": {"epss_score": 0.00745, "epss_percentile": 0.72531}, "CVE-2005-3870": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-3871": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2005-3872": {"epss_score": 0.00583, "epss_percentile": 0.68343}, "CVE-2005-3873": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-3874": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-3875": {"epss_score": 0.00651, "epss_percentile": 0.70302}, "CVE-2005-3876": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-3877": {"epss_score": 0.00582, "epss_percentile": 0.68294}, "CVE-2005-3878": {"epss_score": 0.03482, "epss_percentile": 0.87222}, "CVE-2005-3879": {"epss_score": 0.02977, "epss_percentile": 0.86109}, "CVE-2005-3880": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-3881": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-3882": {"epss_score": 0.00558, "epss_percentile": 0.67587}, "CVE-2005-3883": {"epss_score": 0.03153, "epss_percentile": 0.86509}, "CVE-2005-3884": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2005-3885": {"epss_score": 0.00079, "epss_percentile": 0.23905}, "CVE-2005-3886": {"epss_score": 0.00064, "epss_percentile": 0.20295}, "CVE-2005-3887": {"epss_score": 0.01407, "epss_percentile": 0.80054}, "CVE-2005-3888": {"epss_score": 0.01886, "epss_percentile": 0.82712}, "CVE-2005-3889": {"epss_score": 0.01602, "epss_percentile": 0.81271}, "CVE-2005-3890": {"epss_score": 0.01602, "epss_percentile": 0.81271}, "CVE-2005-3891": {"epss_score": 0.01745, "epss_percentile": 0.82066}, "CVE-2005-3892": {"epss_score": 0.00463, "epss_percentile": 0.63682}, "CVE-2005-3893": {"epss_score": 0.12371, "epss_percentile": 0.93653}, "CVE-2005-3894": {"epss_score": 0.08211, "epss_percentile": 0.91932}, "CVE-2005-3895": {"epss_score": 0.0127, "epss_percentile": 0.79047}, "CVE-2005-3896": {"epss_score": 0.00815, "epss_percentile": 0.73792}, "CVE-2005-3897": {"epss_score": 0.0068, "epss_percentile": 0.71025}, "CVE-2005-3899": {"epss_score": 0.01147, "epss_percentile": 0.78004}, "CVE-2005-3900": {"epss_score": 0.00758, "epss_percentile": 0.72773}, "CVE-2005-3901": {"epss_score": 0.00108, "epss_percentile": 0.29875}, "CVE-2005-3902": {"epss_score": 0.01319, "epss_percentile": 0.79432}, "CVE-2005-3903": {"epss_score": 0.002, "epss_percentile": 0.42211}, "CVE-2005-3904": {"epss_score": 0.10002, "epss_percentile": 0.92811}, "CVE-2005-3905": {"epss_score": 0.11508, "epss_percentile": 0.93387}, "CVE-2005-3906": {"epss_score": 0.11508, "epss_percentile": 0.93387}, "CVE-2005-3907": {"epss_score": 0.08015, "epss_percentile": 0.9183}, "CVE-2005-3908": {"epss_score": 0.00528, "epss_percentile": 0.66544}, "CVE-2005-3909": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2005-3910": {"epss_score": 0.00457, "epss_percentile": 0.63379}, "CVE-2005-3911": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-3912": {"epss_score": 0.12453, "epss_percentile": 0.93677}, "CVE-2005-3913": {"epss_score": 0.00396, "epss_percentile": 0.59897}, "CVE-2005-3914": {"epss_score": 0.00832, "epss_percentile": 0.74065}, "CVE-2005-3915": {"epss_score": 0.01798, "epss_percentile": 0.82313}, "CVE-2005-3916": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-3917": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-3918": {"epss_score": 0.00757, "epss_percentile": 0.72756}, "CVE-2005-3919": {"epss_score": 0.02503, "epss_percentile": 0.84928}, "CVE-2005-3920": {"epss_score": 0.00411, "epss_percentile": 0.60876}, "CVE-2005-3921": {"epss_score": 0.01599, "epss_percentile": 0.81253}, "CVE-2005-3922": {"epss_score": 0.05612, "epss_percentile": 0.90048}, "CVE-2005-3923": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-3924": {"epss_score": 0.0143, "epss_percentile": 0.80236}, "CVE-2005-3925": {"epss_score": 0.00632, "epss_percentile": 0.69734}, "CVE-2005-3926": {"epss_score": 0.05605, "epss_percentile": 0.90042}, "CVE-2005-3927": {"epss_score": 0.22609, "epss_percentile": 0.95657}, "CVE-2005-3928": {"epss_score": 0.00204, "epss_percentile": 0.42645}, "CVE-2005-3929": {"epss_score": 0.09022, "epss_percentile": 0.92371}, "CVE-2005-3930": {"epss_score": 0.00795, "epss_percentile": 0.73461}, "CVE-2005-3931": {"epss_score": 0.01455, "epss_percentile": 0.80387}, "CVE-2005-3932": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-3933": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-3934": {"epss_score": 0.10267, "epss_percentile": 0.9292}, "CVE-2005-3935": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-3936": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-3937": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2005-3938": {"epss_score": 0.03474, "epss_percentile": 0.87205}, "CVE-2005-3939": {"epss_score": 0.00542, "epss_percentile": 0.67069}, "CVE-2005-3940": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2005-3941": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2005-3942": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2005-3943": {"epss_score": 0.00425, "epss_percentile": 0.61708}, "CVE-2005-3944": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2005-3945": {"epss_score": 0.17078, "epss_percentile": 0.9477}, "CVE-2005-3946": {"epss_score": 0.02419, "epss_percentile": 0.847}, "CVE-2005-3947": {"epss_score": 0.04002, "epss_percentile": 0.88094}, "CVE-2005-3948": {"epss_score": 0.04041, "epss_percentile": 0.88166}, "CVE-2005-3949": {"epss_score": 0.02623, "epss_percentile": 0.85259}, "CVE-2005-3950": {"epss_score": 0.00609, "epss_percentile": 0.69124}, "CVE-2005-3951": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-3952": {"epss_score": 0.03489, "epss_percentile": 0.87229}, "CVE-2005-3953": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2005-3954": {"epss_score": 0.01619, "epss_percentile": 0.81377}, "CVE-2005-3955": {"epss_score": 0.02564, "epss_percentile": 0.85111}, "CVE-2005-3956": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2005-3957": {"epss_score": 0.00452, "epss_percentile": 0.63176}, "CVE-2005-3958": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2005-3959": {"epss_score": 0.01874, "epss_percentile": 0.82653}, "CVE-2005-3960": {"epss_score": 0.01602, "epss_percentile": 0.81271}, "CVE-2005-3961": {"epss_score": 0.01466, "epss_percentile": 0.80461}, "CVE-2005-3962": {"epss_score": 0.00894, "epss_percentile": 0.75084}, "CVE-2005-3963": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2005-3964": {"epss_score": 0.0119, "epss_percentile": 0.78377}, "CVE-2005-3966": {"epss_score": 0.00595, "epss_percentile": 0.6869}, "CVE-2005-3967": {"epss_score": 0.00391, "epss_percentile": 0.59588}, "CVE-2005-3968": {"epss_score": 0.03088, "epss_percentile": 0.8639}, "CVE-2005-3969": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-3970": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-3971": {"epss_score": 0.00734, "epss_percentile": 0.72248}, "CVE-2005-3972": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2005-3973": {"epss_score": 0.00605, "epss_percentile": 0.6898}, "CVE-2005-3974": {"epss_score": 0.00548, "epss_percentile": 0.67268}, "CVE-2005-3975": {"epss_score": 0.00817, "epss_percentile": 0.73842}, "CVE-2005-3976": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-3977": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-3978": {"epss_score": 0.00992, "epss_percentile": 0.76398}, "CVE-2005-3979": {"epss_score": 0.00604, "epss_percentile": 0.68941}, "CVE-2005-3980": {"epss_score": 0.03174, "epss_percentile": 0.86555}, "CVE-2005-3981": {"epss_score": 0.00683, "epss_percentile": 0.71097}, "CVE-2005-3982": {"epss_score": 0.16479, "epss_percentile": 0.94676}, "CVE-2005-3983": {"epss_score": 0.01303, "epss_percentile": 0.79307}, "CVE-2005-3984": {"epss_score": 0.00862, "epss_percentile": 0.74574}, "CVE-2005-3985": {"epss_score": 0.02841, "epss_percentile": 0.85805}, "CVE-2005-3986": {"epss_score": 0.01112, "epss_percentile": 0.77672}, "CVE-2005-3987": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-3988": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-3989": {"epss_score": 0.00834, "epss_percentile": 0.74111}, "CVE-2005-3991": {"epss_score": 0.01395, "epss_percentile": 0.79977}, "CVE-2005-3992": {"epss_score": 0.10486, "epss_percentile": 0.93003}, "CVE-2005-3993": {"epss_score": 0.0049, "epss_percentile": 0.64939}, "CVE-2005-3995": {"epss_score": 0.0858, "epss_percentile": 0.92132}, "CVE-2005-3996": {"epss_score": 0.01733, "epss_percentile": 0.81998}, "CVE-2005-3997": {"epss_score": 0.00994, "epss_percentile": 0.7642}, "CVE-2005-3998": {"epss_score": 0.00783, "epss_percentile": 0.73216}, "CVE-2005-3999": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-4000": {"epss_score": 0.00783, "epss_percentile": 0.73216}, "CVE-2005-4001": {"epss_score": 0.00583, "epss_percentile": 0.68343}, "CVE-2005-4002": {"epss_score": 0.00377, "epss_percentile": 0.58694}, "CVE-2005-4003": {"epss_score": 0.00583, "epss_percentile": 0.68336}, "CVE-2005-4004": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4005": {"epss_score": 0.02055, "epss_percentile": 0.83421}, "CVE-2005-4006": {"epss_score": 0.00978, "epss_percentile": 0.76237}, "CVE-2005-4007": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2005-4008": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-4009": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2005-4010": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-4011": {"epss_score": 0.01817, "epss_percentile": 0.82396}, "CVE-2005-4012": {"epss_score": 0.01253, "epss_percentile": 0.78915}, "CVE-2005-4013": {"epss_score": 0.00714, "epss_percentile": 0.71818}, "CVE-2005-4014": {"epss_score": 0.01823, "epss_percentile": 0.82421}, "CVE-2005-4015": {"epss_score": 0.00463, "epss_percentile": 0.63682}, "CVE-2005-4016": {"epss_score": 0.00558, "epss_percentile": 0.67587}, "CVE-2005-4017": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-4018": {"epss_score": 0.00558, "epss_percentile": 0.67587}, "CVE-2005-4019": {"epss_score": 0.00677, "epss_percentile": 0.7096}, "CVE-2005-4020": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-4021": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2005-4022": {"epss_score": 0.00463, "epss_percentile": 0.63682}, "CVE-2005-4023": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2005-4024": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-4025": {"epss_score": 0.00763, "epss_percentile": 0.72859}, "CVE-2005-4026": {"epss_score": 0.00375, "epss_percentile": 0.58605}, "CVE-2005-4027": {"epss_score": 0.0049, "epss_percentile": 0.64935}, "CVE-2005-4028": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2005-4029": {"epss_score": 0.00718, "epss_percentile": 0.71935}, "CVE-2005-4030": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-4031": {"epss_score": 0.01655, "epss_percentile": 0.81592}, "CVE-2005-4032": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-4033": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2005-4034": {"epss_score": 0.00835, "epss_percentile": 0.74117}, "CVE-2005-4035": {"epss_score": 0.00762, "epss_percentile": 0.72839}, "CVE-2005-4036": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4037": {"epss_score": 0.00677, "epss_percentile": 0.7096}, "CVE-2005-4038": {"epss_score": 0.00963, "epss_percentile": 0.76005}, "CVE-2005-4039": {"epss_score": 0.04655, "epss_percentile": 0.8897}, "CVE-2005-4040": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-4041": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2005-4042": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4043": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2005-4044": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4045": {"epss_score": 0.01571, "epss_percentile": 0.81094}, "CVE-2005-4046": {"epss_score": 0.00437, "epss_percentile": 0.62506}, "CVE-2005-4047": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-4048": {"epss_score": 0.05923, "epss_percentile": 0.90324}, "CVE-2005-4049": {"epss_score": 0.01658, "epss_percentile": 0.81608}, "CVE-2005-4050": {"epss_score": 0.06287, "epss_percentile": 0.90645}, "CVE-2005-4051": {"epss_score": 0.00502, "epss_percentile": 0.65411}, "CVE-2005-4052": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2005-4053": {"epss_score": 0.01044, "epss_percentile": 0.77006}, "CVE-2005-4054": {"epss_score": 0.00446, "epss_percentile": 0.62924}, "CVE-2005-4055": {"epss_score": 0.00542, "epss_percentile": 0.67064}, "CVE-2005-4056": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-4057": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4058": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-4059": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-4060": {"epss_score": 0.00755, "epss_percentile": 0.72716}, "CVE-2005-4061": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4062": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4063": {"epss_score": 0.00594, "epss_percentile": 0.68662}, "CVE-2005-4064": {"epss_score": 0.01217, "epss_percentile": 0.786}, "CVE-2005-4065": {"epss_score": 0.03358, "epss_percentile": 0.8698}, "CVE-2005-4066": {"epss_score": 0.0004, "epss_percentile": 0.1199}, "CVE-2005-4068": {"epss_score": 0.00068, "epss_percentile": 0.21348}, "CVE-2005-4069": {"epss_score": 0.0011, "epss_percentile": 0.30133}, "CVE-2005-4071": {"epss_score": 0.01032, "epss_percentile": 0.76867}, "CVE-2005-4072": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4073": {"epss_score": 0.00824, "epss_percentile": 0.73939}, "CVE-2005-4074": {"epss_score": 0.05772, "epss_percentile": 0.90194}, "CVE-2005-4075": {"epss_score": 0.00783, "epss_percentile": 0.73216}, "CVE-2005-4076": {"epss_score": 0.00182, "epss_percentile": 0.4027}, "CVE-2005-4077": {"epss_score": 0.00266, "epss_percentile": 0.49911}, "CVE-2005-4078": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2005-4079": {"epss_score": 0.01613, "epss_percentile": 0.81342}, "CVE-2005-4080": {"epss_score": 0.01047, "epss_percentile": 0.77041}, "CVE-2005-4081": {"epss_score": 0.00886, "epss_percentile": 0.74955}, "CVE-2005-4082": {"epss_score": 0.00065, "epss_percentile": 0.20642}, "CVE-2005-4083": {"epss_score": 0.0021, "epss_percentile": 0.43432}, "CVE-2005-4084": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-4085": {"epss_score": 0.77161, "epss_percentile": 0.98924}, "CVE-2005-4086": {"epss_score": 0.12556, "epss_percentile": 0.93715}, "CVE-2005-4087": {"epss_score": 0.03602, "epss_percentile": 0.87413}, "CVE-2005-4088": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-4089": {"epss_score": 0.34505, "epss_percentile": 0.96851}, "CVE-2005-4090": {"epss_score": 0.01528, "epss_percentile": 0.80871}, "CVE-2005-4091": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-4092": {"epss_score": 0.44088, "epss_percentile": 0.97418}, "CVE-2005-4093": {"epss_score": 0.09454, "epss_percentile": 0.92555}, "CVE-2005-4094": {"epss_score": 0.01485, "epss_percentile": 0.80595}, "CVE-2005-4095": {"epss_score": 0.11257, "epss_percentile": 0.9328}, "CVE-2005-4126": {"epss_score": 0.00899, "epss_percentile": 0.75152}, "CVE-2005-4130": {"epss_score": 0.01734, "epss_percentile": 0.82001}, "CVE-2005-4131": {"epss_score": 0.69088, "epss_percentile": 0.98578}, "CVE-2005-4132": {"epss_score": 0.00566, "epss_percentile": 0.67808}, "CVE-2005-4133": {"epss_score": 0.0008, "epss_percentile": 0.24064}, "CVE-2005-4134": {"epss_score": 0.29386, "epss_percentile": 0.9644}, "CVE-2005-4135": {"epss_score": 0.14804, "epss_percentile": 0.94289}, "CVE-2005-4136": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2005-4137": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2005-4138": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2005-4139": {"epss_score": 0.02418, "epss_percentile": 0.84697}, "CVE-2005-4140": {"epss_score": 0.02392, "epss_percentile": 0.84606}, "CVE-2005-4141": {"epss_score": 0.01031, "epss_percentile": 0.76856}, "CVE-2005-4142": {"epss_score": 0.01867, "epss_percentile": 0.82618}, "CVE-2005-4143": {"epss_score": 0.00862, "epss_percentile": 0.74569}, "CVE-2005-4144": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2005-4145": {"epss_score": 0.6483, "epss_percentile": 0.98393}, "CVE-2005-4146": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2005-4147": {"epss_score": 0.01156, "epss_percentile": 0.78105}, "CVE-2005-4148": {"epss_score": 0.00762, "epss_percentile": 0.72847}, "CVE-2005-4149": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-4150": {"epss_score": 0.01054, "epss_percentile": 0.77108}, "CVE-2005-4151": {"epss_score": 0.001, "epss_percentile": 0.28441}, "CVE-2005-4152": {"epss_score": 0.01656, "epss_percentile": 0.816}, "CVE-2005-4153": {"epss_score": 0.08698, "epss_percentile": 0.92208}, "CVE-2005-4154": {"epss_score": 0.01244, "epss_percentile": 0.78832}, "CVE-2005-4155": {"epss_score": 0.03174, "epss_percentile": 0.8656}, "CVE-2005-4156": {"epss_score": 0.00877, "epss_percentile": 0.74806}, "CVE-2005-4157": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2005-4158": {"epss_score": 0.00826, "epss_percentile": 0.73964}, "CVE-2005-4159": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2005-4160": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2005-4161": {"epss_score": 0.00721, "epss_percentile": 0.71967}, "CVE-2005-4162": {"epss_score": 0.00713, "epss_percentile": 0.71796}, "CVE-2005-4163": {"epss_score": 0.00273, "epss_percentile": 0.50451}, "CVE-2005-4164": {"epss_score": 0.01035, "epss_percentile": 0.76895}, "CVE-2005-4165": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2005-4166": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-4167": {"epss_score": 0.0123, "epss_percentile": 0.78722}, "CVE-2005-4168": {"epss_score": 0.0138, "epss_percentile": 0.79859}, "CVE-2005-4169": {"epss_score": 0.01185, "epss_percentile": 0.78336}, "CVE-2005-4170": {"epss_score": 0.02394, "epss_percentile": 0.84613}, "CVE-2005-4171": {"epss_score": 0.07795, "epss_percentile": 0.91685}, "CVE-2005-4172": {"epss_score": 0.00985, "epss_percentile": 0.76319}, "CVE-2005-4173": {"epss_score": 0.00985, "epss_percentile": 0.76319}, "CVE-2005-4174": {"epss_score": 0.01819, "epss_percentile": 0.82404}, "CVE-2005-4175": {"epss_score": 0.0013, "epss_percentile": 0.33315}, "CVE-2005-4176": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2005-4177": {"epss_score": 0.00783, "epss_percentile": 0.73216}, "CVE-2005-4178": {"epss_score": 0.01719, "epss_percentile": 0.81925}, "CVE-2005-4189": {"epss_score": 0.01117, "epss_percentile": 0.77724}, "CVE-2005-4190": {"epss_score": 0.00828, "epss_percentile": 0.73999}, "CVE-2005-4191": {"epss_score": 0.00371, "epss_percentile": 0.58417}, "CVE-2005-4192": {"epss_score": 0.00439, "epss_percentile": 0.62589}, "CVE-2005-4193": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4194": {"epss_score": 0.03922, "epss_percentile": 0.87956}, "CVE-2005-4195": {"epss_score": 0.03628, "epss_percentile": 0.87467}, "CVE-2005-4196": {"epss_score": 0.04726, "epss_percentile": 0.89065}, "CVE-2005-4197": {"epss_score": 0.11243, "epss_percentile": 0.93276}, "CVE-2005-4198": {"epss_score": 0.00549, "epss_percentile": 0.67317}, "CVE-2005-4199": {"epss_score": 0.01714, "epss_percentile": 0.81891}, "CVE-2005-4200": {"epss_score": 0.00487, "epss_percentile": 0.64815}, "CVE-2005-4201": {"epss_score": 0.00708, "epss_percentile": 0.71671}, "CVE-2005-4202": {"epss_score": 0.05387, "epss_percentile": 0.89822}, "CVE-2005-4203": {"epss_score": 0.01099, "epss_percentile": 0.77548}, "CVE-2005-4204": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2005-4205": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-4206": {"epss_score": 0.04326, "epss_percentile": 0.88553}, "CVE-2005-4207": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2005-4208": {"epss_score": 0.02162, "epss_percentile": 0.83828}, "CVE-2005-4209": {"epss_score": 0.00542, "epss_percentile": 0.67082}, "CVE-2005-4210": {"epss_score": 0.0303, "epss_percentile": 0.86245}, "CVE-2005-4211": {"epss_score": 0.07349, "epss_percentile": 0.91425}, "CVE-2005-4212": {"epss_score": 0.06906, "epss_percentile": 0.91109}, "CVE-2005-4213": {"epss_score": 0.02, "epss_percentile": 0.83214}, "CVE-2005-4214": {"epss_score": 0.01041, "epss_percentile": 0.76967}, "CVE-2005-4215": {"epss_score": 0.00834, "epss_percentile": 0.74111}, "CVE-2005-4216": {"epss_score": 0.29745, "epss_percentile": 0.9647}, "CVE-2005-4217": {"epss_score": 0.01398, "epss_percentile": 0.79991}, "CVE-2005-4218": {"epss_score": 0.00589, "epss_percentile": 0.68514}, "CVE-2005-4219": {"epss_score": 0.00446, "epss_percentile": 0.62916}, "CVE-2005-4220": {"epss_score": 0.00916, "epss_percentile": 0.75422}, "CVE-2005-4221": {"epss_score": 0.00446, "epss_percentile": 0.62924}, "CVE-2005-4222": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-4223": {"epss_score": 0.01343, "epss_percentile": 0.79604}, "CVE-2005-4224": {"epss_score": 0.0139, "epss_percentile": 0.79934}, "CVE-2005-4225": {"epss_score": 0.02117, "epss_percentile": 0.83667}, "CVE-2005-4226": {"epss_score": 0.01693, "epss_percentile": 0.81792}, "CVE-2005-4227": {"epss_score": 0.03544, "epss_percentile": 0.87323}, "CVE-2005-4228": {"epss_score": 0.00951, "epss_percentile": 0.75862}, "CVE-2005-4229": {"epss_score": 0.00594, "epss_percentile": 0.68662}, "CVE-2005-4230": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-4231": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4232": {"epss_score": 0.00801, "epss_percentile": 0.73569}, "CVE-2005-4233": {"epss_score": 0.00349, "epss_percentile": 0.56866}, "CVE-2005-4234": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-4235": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4236": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4237": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4238": {"epss_score": 0.04246, "epss_percentile": 0.8844}, "CVE-2005-4239": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-4240": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2005-4241": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2005-4242": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-4243": {"epss_score": 0.0101, "epss_percentile": 0.76604}, "CVE-2005-4244": {"epss_score": 0.00726, "epss_percentile": 0.7208}, "CVE-2005-4245": {"epss_score": 0.01285, "epss_percentile": 0.79177}, "CVE-2005-4246": {"epss_score": 0.00367, "epss_percentile": 0.58157}, "CVE-2005-4247": {"epss_score": 0.0034, "epss_percentile": 0.56236}, "CVE-2005-4248": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-4249": {"epss_score": 0.00233, "epss_percentile": 0.4606}, "CVE-2005-4250": {"epss_score": 0.03917, "epss_percentile": 0.87948}, "CVE-2005-4251": {"epss_score": 0.00583, "epss_percentile": 0.68343}, "CVE-2005-4252": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4253": {"epss_score": 0.00521, "epss_percentile": 0.66245}, "CVE-2005-4254": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-4255": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2005-4256": {"epss_score": 0.00558, "epss_percentile": 0.676}, "CVE-2005-4257": {"epss_score": 0.00815, "epss_percentile": 0.73792}, "CVE-2005-4258": {"epss_score": 0.00708, "epss_percentile": 0.71682}, "CVE-2005-4259": {"epss_score": 0.00544, "epss_percentile": 0.67152}, "CVE-2005-4260": {"epss_score": 0.00024, "epss_percentile": 0.05859}, "CVE-2005-4261": {"epss_score": 0.00715, "epss_percentile": 0.71841}, "CVE-2005-4262": {"epss_score": 0.00419, "epss_percentile": 0.61379}, "CVE-2005-4263": {"epss_score": 0.00708, "epss_percentile": 0.71675}, "CVE-2005-4264": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-4266": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-4267": {"epss_score": 0.76892, "epss_percentile": 0.98911}, "CVE-2005-4268": {"epss_score": 0.00048, "epss_percentile": 0.15199}, "CVE-2005-4269": {"epss_score": 0.15934, "epss_percentile": 0.94539}, "CVE-2005-4270": {"epss_score": 0.02822, "epss_percentile": 0.85745}, "CVE-2005-4271": {"epss_score": 0.00051, "epss_percentile": 0.16132}, "CVE-2005-4272": {"epss_score": 0.31437, "epss_percentile": 0.96621}, "CVE-2005-4273": {"epss_score": 0.00063, "epss_percentile": 0.19856}, "CVE-2005-4274": {"epss_score": 0.00779, "epss_percentile": 0.73155}, "CVE-2005-4275": {"epss_score": 0.02436, "epss_percentile": 0.8474}, "CVE-2005-4276": {"epss_score": 0.03804, "epss_percentile": 0.87749}, "CVE-2005-4277": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2005-4278": {"epss_score": 0.00075, "epss_percentile": 0.22917}, "CVE-2005-4279": {"epss_score": 0.00055, "epss_percentile": 0.17461}, "CVE-2005-4280": {"epss_score": 0.00055, "epss_percentile": 0.17461}, "CVE-2005-4281": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4282": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4283": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4284": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-4285": {"epss_score": 0.00594, "epss_percentile": 0.68662}, "CVE-2005-4286": {"epss_score": 0.01035, "epss_percentile": 0.76895}, "CVE-2005-4287": {"epss_score": 0.03357, "epss_percentile": 0.86979}, "CVE-2005-4288": {"epss_score": 0.01482, "epss_percentile": 0.80572}, "CVE-2005-4289": {"epss_score": 0.00558, "epss_percentile": 0.676}, "CVE-2005-4290": {"epss_score": 0.00594, "epss_percentile": 0.68662}, "CVE-2005-4291": {"epss_score": 0.00594, "epss_percentile": 0.68662}, "CVE-2005-4292": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2005-4293": {"epss_score": 0.00864, "epss_percentile": 0.7461}, "CVE-2005-4294": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-4295": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-4296": {"epss_score": 0.03207, "epss_percentile": 0.86639}, "CVE-2005-4297": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4298": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-4299": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-4300": {"epss_score": 0.01841, "epss_percentile": 0.82495}, "CVE-2005-4301": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4302": {"epss_score": 0.03876, "epss_percentile": 0.87888}, "CVE-2005-4303": {"epss_score": 0.00349, "epss_percentile": 0.56866}, "CVE-2005-4304": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2005-4305": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2005-4306": {"epss_score": 0.00986, "epss_percentile": 0.7633}, "CVE-2005-4307": {"epss_score": 0.01509, "epss_percentile": 0.80765}, "CVE-2005-4308": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-4309": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2005-4310": {"epss_score": 0.00675, "epss_percentile": 0.70907}, "CVE-2005-4311": {"epss_score": 0.00458, "epss_percentile": 0.63449}, "CVE-2005-4312": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-4313": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-4314": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-4315": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-4316": {"epss_score": 0.164, "epss_percentile": 0.94645}, "CVE-2005-4317": {"epss_score": 0.22305, "epss_percentile": 0.95621}, "CVE-2005-4318": {"epss_score": 0.01615, "epss_percentile": 0.81352}, "CVE-2005-4319": {"epss_score": 0.14392, "epss_percentile": 0.94201}, "CVE-2005-4320": {"epss_score": 0.01041, "epss_percentile": 0.76967}, "CVE-2005-4321": {"epss_score": 0.03023, "epss_percentile": 0.86231}, "CVE-2005-4322": {"epss_score": 0.00605, "epss_percentile": 0.6898}, "CVE-2005-4323": {"epss_score": 0.01205, "epss_percentile": 0.78509}, "CVE-2005-4324": {"epss_score": 0.01365, "epss_percentile": 0.79777}, "CVE-2005-4325": {"epss_score": 0.00519, "epss_percentile": 0.66179}, "CVE-2005-4326": {"epss_score": 0.00356, "epss_percentile": 0.57329}, "CVE-2005-4327": {"epss_score": 0.03594, "epss_percentile": 0.87403}, "CVE-2005-4328": {"epss_score": 0.02279, "epss_percentile": 0.8424}, "CVE-2005-4329": {"epss_score": 0.00442, "epss_percentile": 0.62735}, "CVE-2005-4330": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-4331": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-4332": {"epss_score": 0.11055, "epss_percentile": 0.93203}, "CVE-2005-4333": {"epss_score": 0.0089, "epss_percentile": 0.75033}, "CVE-2005-4334": {"epss_score": 0.00808, "epss_percentile": 0.73695}, "CVE-2005-4335": {"epss_score": 0.00852, "epss_percentile": 0.74412}, "CVE-2005-4336": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-4337": {"epss_score": 0.00676, "epss_percentile": 0.7092}, "CVE-2005-4338": {"epss_score": 0.01172, "epss_percentile": 0.78233}, "CVE-2005-4339": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-4341": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-4342": {"epss_score": 0.00986, "epss_percentile": 0.76335}, "CVE-2005-4343": {"epss_score": 0.01472, "epss_percentile": 0.80511}, "CVE-2005-4344": {"epss_score": 0.00022, "epss_percentile": 0.05317}, "CVE-2005-4345": {"epss_score": 0.00013, "epss_percentile": 0.01499}, "CVE-2005-4346": {"epss_score": 0.00396, "epss_percentile": 0.59926}, "CVE-2005-4347": {"epss_score": 0.00946, "epss_percentile": 0.75805}, "CVE-2005-4348": {"epss_score": 0.09993, "epss_percentile": 0.92808}, "CVE-2005-4349": {"epss_score": 0.01659, "epss_percentile": 0.81616}, "CVE-2005-4350": {"epss_score": 0.01033, "epss_percentile": 0.76873}, "CVE-2005-4351": {"epss_score": 0.00126, "epss_percentile": 0.32627}, "CVE-2005-4352": {"epss_score": 0.00106, "epss_percentile": 0.29483}, "CVE-2005-4353": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-4354": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-4355": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4356": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-4357": {"epss_score": 0.01415, "epss_percentile": 0.8014}, "CVE-2005-4358": {"epss_score": 0.01262, "epss_percentile": 0.78979}, "CVE-2005-4359": {"epss_score": 0.00326, "epss_percentile": 0.55045}, "CVE-2005-4360": {"epss_score": 0.77063, "epss_percentile": 0.98919}, "CVE-2005-4361": {"epss_score": 0.00565, "epss_percentile": 0.67789}, "CVE-2005-4362": {"epss_score": 0.00326, "epss_percentile": 0.55045}, "CVE-2005-4363": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2005-4364": {"epss_score": 0.00739, "epss_percentile": 0.72358}, "CVE-2005-4365": {"epss_score": 0.00794, "epss_percentile": 0.73451}, "CVE-2005-4366": {"epss_score": 0.00824, "epss_percentile": 0.73933}, "CVE-2005-4367": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4368": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2005-4369": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4370": {"epss_score": 0.00799, "epss_percentile": 0.73528}, "CVE-2005-4371": {"epss_score": 0.05333, "epss_percentile": 0.89741}, "CVE-2005-4372": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4373": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2005-4374": {"epss_score": 0.01811, "epss_percentile": 0.82369}, "CVE-2005-4375": {"epss_score": 0.00565, "epss_percentile": 0.67789}, "CVE-2005-4376": {"epss_score": 0.0021, "epss_percentile": 0.43432}, "CVE-2005-4377": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-4378": {"epss_score": 0.01055, "epss_percentile": 0.77118}, "CVE-2005-4379": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2005-4380": {"epss_score": 0.01221, "epss_percentile": 0.78652}, "CVE-2005-4381": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2005-4382": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-4383": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4384": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-4385": {"epss_score": 0.00373, "epss_percentile": 0.58478}, "CVE-2005-4386": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4387": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4388": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-4389": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-4390": {"epss_score": 0.00558, "epss_percentile": 0.67587}, "CVE-2005-4391": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4392": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-4393": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-4394": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4395": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4396": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-4397": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-4398": {"epss_score": 0.00409, "epss_percentile": 0.607}, "CVE-2005-4399": {"epss_score": 0.00458, "epss_percentile": 0.63449}, "CVE-2005-4400": {"epss_score": 0.02381, "epss_percentile": 0.84566}, "CVE-2005-4401": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4402": {"epss_score": 0.03173, "epss_percentile": 0.86553}, "CVE-2005-4403": {"epss_score": 0.00362, "epss_percentile": 0.57797}, "CVE-2005-4404": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-4405": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-4406": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2005-4407": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-4408": {"epss_score": 0.00961, "epss_percentile": 0.75981}, "CVE-2005-4409": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-4410": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4411": {"epss_score": 0.8155, "epss_percentile": 0.99144}, "CVE-2005-4412": {"epss_score": 0.00086, "epss_percentile": 0.25391}, "CVE-2005-4413": {"epss_score": 0.00301, "epss_percentile": 0.53075}, "CVE-2005-4414": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2005-4415": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2005-4416": {"epss_score": 0.00475, "epss_percentile": 0.64189}, "CVE-2005-4417": {"epss_score": 0.03194, "epss_percentile": 0.86609}, "CVE-2005-4418": {"epss_score": 0.00459, "epss_percentile": 0.63498}, "CVE-2005-4419": {"epss_score": 0.00897, "epss_percentile": 0.75123}, "CVE-2005-4420": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4421": {"epss_score": 0.01075, "epss_percentile": 0.77308}, "CVE-2005-4422": {"epss_score": 0.0159, "epss_percentile": 0.81199}, "CVE-2005-4423": {"epss_score": 0.03925, "epss_percentile": 0.87961}, "CVE-2005-4424": {"epss_score": 0.01703, "epss_percentile": 0.81841}, "CVE-2005-4425": {"epss_score": 0.00916, "epss_percentile": 0.75422}, "CVE-2005-4426": {"epss_score": 0.00244, "epss_percentile": 0.47565}, "CVE-2005-4427": {"epss_score": 0.02653, "epss_percentile": 0.85351}, "CVE-2005-4428": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-4429": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2005-4430": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2005-4431": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-4432": {"epss_score": 0.0775, "epss_percentile": 0.91658}, "CVE-2005-4433": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4434": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4435": {"epss_score": 0.02168, "epss_percentile": 0.83859}, "CVE-2005-4436": {"epss_score": 0.01602, "epss_percentile": 0.81271}, "CVE-2005-4437": {"epss_score": 0.03471, "epss_percentile": 0.872}, "CVE-2005-4438": {"epss_score": 0.1079, "epss_percentile": 0.93104}, "CVE-2005-4439": {"epss_score": 0.08141, "epss_percentile": 0.91899}, "CVE-2005-4440": {"epss_score": 0.00247, "epss_percentile": 0.47903}, "CVE-2005-4441": {"epss_score": 0.00247, "epss_percentile": 0.47903}, "CVE-2005-4442": {"epss_score": 0.00085, "epss_percentile": 0.25069}, "CVE-2005-4443": {"epss_score": 0.00058, "epss_percentile": 0.18514}, "CVE-2005-4444": {"epss_score": 0.06287, "epss_percentile": 0.90645}, "CVE-2005-4445": {"epss_score": 0.04821, "epss_percentile": 0.89179}, "CVE-2005-4446": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2005-4447": {"epss_score": 0.01955, "epss_percentile": 0.83035}, "CVE-2005-4448": {"epss_score": 0.00617, "epss_percentile": 0.69357}, "CVE-2005-4449": {"epss_score": 0.03294, "epss_percentile": 0.86845}, "CVE-2005-4450": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-4451": {"epss_score": 0.01286, "epss_percentile": 0.79183}, "CVE-2005-4452": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2005-4453": {"epss_score": 0.00729, "epss_percentile": 0.72121}, "CVE-2005-4454": {"epss_score": 0.00467, "epss_percentile": 0.63866}, "CVE-2005-4455": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2005-4456": {"epss_score": 0.04458, "epss_percentile": 0.88715}, "CVE-2005-4457": {"epss_score": 0.08634, "epss_percentile": 0.92164}, "CVE-2005-4458": {"epss_score": 0.01719, "epss_percentile": 0.81926}, "CVE-2005-4459": {"epss_score": 0.63371, "epss_percentile": 0.9833}, "CVE-2005-4460": {"epss_score": 0.00798, "epss_percentile": 0.73505}, "CVE-2005-4461": {"epss_score": 0.01076, "epss_percentile": 0.77328}, "CVE-2005-4462": {"epss_score": 0.05808, "epss_percentile": 0.90224}, "CVE-2005-4463": {"epss_score": 0.01582, "epss_percentile": 0.81144}, "CVE-2005-4464": {"epss_score": 0.00834, "epss_percentile": 0.74111}, "CVE-2005-4465": {"epss_score": 0.01983, "epss_percentile": 0.83146}, "CVE-2005-4466": {"epss_score": 0.21559, "epss_percentile": 0.95533}, "CVE-2005-4467": {"epss_score": 0.07197, "epss_percentile": 0.91314}, "CVE-2005-4468": {"epss_score": 0.17432, "epss_percentile": 0.94851}, "CVE-2005-4469": {"epss_score": 0.02522, "epss_percentile": 0.85006}, "CVE-2005-4470": {"epss_score": 0.05971, "epss_percentile": 0.90371}, "CVE-2005-4471": {"epss_score": 0.01331, "epss_percentile": 0.79517}, "CVE-2005-4472": {"epss_score": 0.23703, "epss_percentile": 0.95806}, "CVE-2005-4473": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2005-4474": {"epss_score": 0.00722, "epss_percentile": 0.72003}, "CVE-2005-4475": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2005-4476": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2005-4477": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2005-4478": {"epss_score": 0.00706, "epss_percentile": 0.71619}, "CVE-2005-4479": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2005-4480": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2005-4481": {"epss_score": 0.0141, "epss_percentile": 0.80081}, "CVE-2005-4482": {"epss_score": 0.03247, "epss_percentile": 0.86745}, "CVE-2005-4483": {"epss_score": 0.00594, "epss_percentile": 0.68662}, "CVE-2005-4484": {"epss_score": 0.00986, "epss_percentile": 0.7633}, "CVE-2005-4485": {"epss_score": 0.00967, "epss_percentile": 0.76075}, "CVE-2005-4486": {"epss_score": 0.00757, "epss_percentile": 0.72756}, "CVE-2005-4487": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4488": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2005-4489": {"epss_score": 0.00777, "epss_percentile": 0.73111}, "CVE-2005-4490": {"epss_score": 0.00527, "epss_percentile": 0.66453}, "CVE-2005-4491": {"epss_score": 0.0115, "epss_percentile": 0.78033}, "CVE-2005-4492": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4493": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2005-4494": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-4495": {"epss_score": 0.01035, "epss_percentile": 0.76895}, "CVE-2005-4496": {"epss_score": 0.02503, "epss_percentile": 0.8493}, "CVE-2005-4497": {"epss_score": 0.00594, "epss_percentile": 0.68662}, "CVE-2005-4498": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-4499": {"epss_score": 0.01908, "epss_percentile": 0.82817}, "CVE-2005-4500": {"epss_score": 0.00679, "epss_percentile": 0.71024}, "CVE-2005-4501": {"epss_score": 0.00572, "epss_percentile": 0.68001}, "CVE-2005-4502": {"epss_score": 0.01351, "epss_percentile": 0.79679}, "CVE-2005-4503": {"epss_score": 0.09254, "epss_percentile": 0.92466}, "CVE-2005-4504": {"epss_score": 0.36798, "epss_percentile": 0.97002}, "CVE-2005-4505": {"epss_score": 0.00215, "epss_percentile": 0.44077}, "CVE-2005-4506": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2005-4507": {"epss_score": 0.00376, "epss_percentile": 0.58656}, "CVE-2005-4508": {"epss_score": 0.00424, "epss_percentile": 0.61683}, "CVE-2005-4509": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-4510": {"epss_score": 0.05955, "epss_percentile": 0.9036}, "CVE-2005-4511": {"epss_score": 0.00078, "epss_percentile": 0.23665}, "CVE-2005-4512": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-4513": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4514": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2005-4515": {"epss_score": 0.01311, "epss_percentile": 0.7937}, "CVE-2005-4516": {"epss_score": 0.07101, "epss_percentile": 0.91252}, "CVE-2005-4517": {"epss_score": 0.00726, "epss_percentile": 0.72073}, "CVE-2005-4518": {"epss_score": 0.01798, "epss_percentile": 0.82313}, "CVE-2005-4519": {"epss_score": 0.0214, "epss_percentile": 0.83745}, "CVE-2005-4520": {"epss_score": 0.01056, "epss_percentile": 0.77124}, "CVE-2005-4521": {"epss_score": 0.01046, "epss_percentile": 0.77031}, "CVE-2005-4522": {"epss_score": 0.01281, "epss_percentile": 0.79145}, "CVE-2005-4523": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2005-4524": {"epss_score": 0.00478, "epss_percentile": 0.64398}, "CVE-2005-4525": {"epss_score": 0.00108, "epss_percentile": 0.29825}, "CVE-2005-4526": {"epss_score": 0.00599, "epss_percentile": 0.68808}, "CVE-2005-4527": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2005-4528": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-4529": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2005-4530": {"epss_score": 0.02636, "epss_percentile": 0.85293}, "CVE-2005-4532": {"epss_score": 0.00058, "epss_percentile": 0.18388}, "CVE-2005-4533": {"epss_score": 0.00633, "epss_percentile": 0.69756}, "CVE-2005-4534": {"epss_score": 0.0154, "epss_percentile": 0.80943}, "CVE-2005-4536": {"epss_score": 0.00072, "epss_percentile": 0.22424}, "CVE-2005-4545": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4546": {"epss_score": 0.0103, "epss_percentile": 0.76845}, "CVE-2005-4547": {"epss_score": 0.00392, "epss_percentile": 0.59666}, "CVE-2005-4548": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-4549": {"epss_score": 0.00952, "epss_percentile": 0.75871}, "CVE-2005-4550": {"epss_score": 0.53483, "epss_percentile": 0.97879}, "CVE-2005-4551": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4552": {"epss_score": 0.00046, "epss_percentile": 0.14171}, "CVE-2005-4553": {"epss_score": 0.05161, "epss_percentile": 0.89559}, "CVE-2005-4554": {"epss_score": 0.01746, "epss_percentile": 0.82071}, "CVE-2005-4555": {"epss_score": 0.01068, "epss_percentile": 0.77241}, "CVE-2005-4556": {"epss_score": 0.11153, "epss_percentile": 0.93246}, "CVE-2005-4557": {"epss_score": 0.05936, "epss_percentile": 0.90344}, "CVE-2005-4558": {"epss_score": 0.11946, "epss_percentile": 0.93523}, "CVE-2005-4559": {"epss_score": 0.06725, "epss_percentile": 0.90971}, "CVE-2005-4560": {"epss_score": 0.90269, "epss_percentile": 0.99574}, "CVE-2005-4563": {"epss_score": 0.03967, "epss_percentile": 0.88032}, "CVE-2005-4564": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2005-4565": {"epss_score": 0.00992, "epss_percentile": 0.76394}, "CVE-2005-4566": {"epss_score": 0.00995, "epss_percentile": 0.76441}, "CVE-2005-4567": {"epss_score": 0.00713, "epss_percentile": 0.71796}, "CVE-2005-4568": {"epss_score": 0.02961, "epss_percentile": 0.86072}, "CVE-2005-4569": {"epss_score": 0.18249, "epss_percentile": 0.94981}, "CVE-2005-4570": {"epss_score": 0.00834, "epss_percentile": 0.74111}, "CVE-2005-4571": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4572": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2005-4573": {"epss_score": 0.16601, "epss_percentile": 0.947}, "CVE-2005-4574": {"epss_score": 0.0438, "epss_percentile": 0.88622}, "CVE-2005-4575": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2005-4576": {"epss_score": 0.06193, "epss_percentile": 0.90554}, "CVE-2005-4577": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-4578": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-4579": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2005-4580": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4581": {"epss_score": 0.00089, "epss_percentile": 0.25876}, "CVE-2005-4582": {"epss_score": 0.01035, "epss_percentile": 0.76902}, "CVE-2005-4583": {"epss_score": 0.016, "epss_percentile": 0.81259}, "CVE-2005-4584": {"epss_score": 0.10156, "epss_percentile": 0.92868}, "CVE-2005-4585": {"epss_score": 0.0517, "epss_percentile": 0.89569}, "CVE-2005-4586": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-4587": {"epss_score": 0.01099, "epss_percentile": 0.77548}, "CVE-2005-4588": {"epss_score": 0.00353, "epss_percentile": 0.57198}, "CVE-2005-4589": {"epss_score": 0.00078, "epss_percentile": 0.23623}, "CVE-2005-4590": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2005-4591": {"epss_score": 0.0547, "epss_percentile": 0.89908}, "CVE-2005-4592": {"epss_score": 0.04284, "epss_percentile": 0.88492}, "CVE-2005-4593": {"epss_score": 0.21131, "epss_percentile": 0.95466}, "CVE-2005-4594": {"epss_score": 0.06973, "epss_percentile": 0.91155}, "CVE-2005-4595": {"epss_score": 0.00069, "epss_percentile": 0.21514}, "CVE-2005-4596": {"epss_score": 0.04046, "epss_percentile": 0.88172}, "CVE-2005-4597": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4598": {"epss_score": 0.03315, "epss_percentile": 0.86899}, "CVE-2005-4599": {"epss_score": 0.00872, "epss_percentile": 0.74733}, "CVE-2005-4600": {"epss_score": 0.17865, "epss_percentile": 0.9492}, "CVE-2005-4601": {"epss_score": 0.11889, "epss_percentile": 0.93507}, "CVE-2005-4602": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-4603": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-4604": {"epss_score": 0.00919, "epss_percentile": 0.75452}, "CVE-2005-4605": {"epss_score": 0.00985, "epss_percentile": 0.76323}, "CVE-2005-4606": {"epss_score": 0.01135, "epss_percentile": 0.77913}, "CVE-2005-4607": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2005-4608": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-4609": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2005-4610": {"epss_score": 0.02468, "epss_percentile": 0.84841}, "CVE-2005-4611": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-4612": {"epss_score": 0.00768, "epss_percentile": 0.7297}, "CVE-2005-4613": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-4614": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2005-4615": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-4616": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-4617": {"epss_score": 0.00588, "epss_percentile": 0.68511}, "CVE-2005-4618": {"epss_score": 0.00139, "epss_percentile": 0.34662}, "CVE-2005-4619": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2005-4620": {"epss_score": 0.00196, "epss_percentile": 0.41819}, "CVE-2005-4621": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2005-4622": {"epss_score": 0.07296, "epss_percentile": 0.91389}, "CVE-2005-4623": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2005-4624": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2005-4625": {"epss_score": 0.00983, "epss_percentile": 0.76306}, "CVE-2005-4626": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2005-4627": {"epss_score": 0.0076, "epss_percentile": 0.72812}, "CVE-2005-4628": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-4629": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-4630": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2005-4631": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2005-4632": {"epss_score": 0.011, "epss_percentile": 0.77564}, "CVE-2005-4634": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2005-4635": {"epss_score": 0.01476, "epss_percentile": 0.8053}, "CVE-2005-4636": {"epss_score": 0.00071, "epss_percentile": 0.22171}, "CVE-2005-4637": {"epss_score": 0.04046, "epss_percentile": 0.88172}, "CVE-2005-4638": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-4639": {"epss_score": 0.00125, "epss_percentile": 0.32572}, "CVE-2005-4640": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-4641": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2005-4642": {"epss_score": 0.01553, "epss_percentile": 0.80996}, "CVE-2005-4643": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-4644": {"epss_score": 0.00658, "epss_percentile": 0.70494}, "CVE-2005-4645": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-4646": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2005-4647": {"epss_score": 0.00446, "epss_percentile": 0.62924}, "CVE-2005-4648": {"epss_score": 0.00795, "epss_percentile": 0.73465}, "CVE-2005-4649": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2005-4650": {"epss_score": 0.00054, "epss_percentile": 0.17271}, "CVE-2005-4651": {"epss_score": 0.00279, "epss_percentile": 0.50988}, "CVE-2005-4652": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2005-4653": {"epss_score": 0.00744, "epss_percentile": 0.72506}, "CVE-2005-4654": {"epss_score": 0.00453, "epss_percentile": 0.63209}, "CVE-2005-4655": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-4656": {"epss_score": 0.01357, "epss_percentile": 0.79723}, "CVE-2005-4657": {"epss_score": 0.02062, "epss_percentile": 0.83445}, "CVE-2005-4658": {"epss_score": 0.01278, "epss_percentile": 0.79121}, "CVE-2005-4659": {"epss_score": 0.00059, "epss_percentile": 0.18656}, "CVE-2005-4660": {"epss_score": 0.00068, "epss_percentile": 0.21314}, "CVE-2005-4661": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2005-4662": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2005-4663": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2005-4664": {"epss_score": 0.00362, "epss_percentile": 0.57797}, "CVE-2005-4665": {"epss_score": 0.01219, "epss_percentile": 0.78609}, "CVE-2005-4666": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2005-4667": {"epss_score": 0.03134, "epss_percentile": 0.86478}, "CVE-2005-4668": {"epss_score": 0.00073, "epss_percentile": 0.22647}, "CVE-2005-4669": {"epss_score": 0.00611, "epss_percentile": 0.692}, "CVE-2005-4670": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2005-4671": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2005-4672": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-4673": {"epss_score": 0.00438, "epss_percentile": 0.62564}, "CVE-2005-4674": {"epss_score": 0.00643, "epss_percentile": 0.70053}, "CVE-2005-4675": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2005-4676": {"epss_score": 0.10163, "epss_percentile": 0.92871}, "CVE-2005-4677": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2005-4678": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2005-4679": {"epss_score": 0.10546, "epss_percentile": 0.93024}, "CVE-2005-4680": {"epss_score": 0.03191, "epss_percentile": 0.86601}, "CVE-2005-4681": {"epss_score": 0.00129, "epss_percentile": 0.33191}, "CVE-2005-4682": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2005-4683": {"epss_score": 0.00091, "epss_percentile": 0.26268}, "CVE-2005-4684": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-4685": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-4686": {"epss_score": 0.00365, "epss_percentile": 0.58008}, "CVE-2005-4687": {"epss_score": 0.00438, "epss_percentile": 0.62564}, "CVE-2005-4688": {"epss_score": 0.00333, "epss_percentile": 0.55642}, "CVE-2005-4689": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-4690": {"epss_score": 0.00084, "epss_percentile": 0.25015}, "CVE-2005-4691": {"epss_score": 0.00079, "epss_percentile": 0.23905}, "CVE-2005-4692": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2005-4693": {"epss_score": 0.00594, "epss_percentile": 0.68666}, "CVE-2005-4694": {"epss_score": 0.10213, "epss_percentile": 0.92896}, "CVE-2005-4695": {"epss_score": 0.02378, "epss_percentile": 0.84559}, "CVE-2005-4696": {"epss_score": 0.0531, "epss_percentile": 0.89716}, "CVE-2005-4697": {"epss_score": 0.01258, "epss_percentile": 0.78953}, "CVE-2005-4698": {"epss_score": 0.11309, "epss_percentile": 0.93302}, "CVE-2005-4699": {"epss_score": 0.01295, "epss_percentile": 0.79253}, "CVE-2005-4700": {"epss_score": 0.0059, "epss_percentile": 0.6855}, "CVE-2005-4701": {"epss_score": 0.00072, "epss_percentile": 0.22432}, "CVE-2005-4702": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2005-4703": {"epss_score": 0.18347, "epss_percentile": 0.95001}, "CVE-2005-4704": {"epss_score": 0.00259, "epss_percentile": 0.4909}, "CVE-2005-4705": {"epss_score": 0.00229, "epss_percentile": 0.45637}, "CVE-2005-4706": {"epss_score": 0.0007, "epss_percentile": 0.21947}, "CVE-2005-4707": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2005-4708": {"epss_score": 0.00167, "epss_percentile": 0.38272}, "CVE-2005-4709": {"epss_score": 0.005, "epss_percentile": 0.653}, "CVE-2005-4710": {"epss_score": 0.00277, "epss_percentile": 0.50821}, "CVE-2005-4711": {"epss_score": 0.0066, "epss_percentile": 0.70522}, "CVE-2005-4712": {"epss_score": 0.00397, "epss_percentile": 0.60037}, "CVE-2005-4713": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2005-4714": {"epss_score": 0.06544, "epss_percentile": 0.90838}, "CVE-2005-4715": {"epss_score": 0.00232, "epss_percentile": 0.45966}, "CVE-2005-4716": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2005-4717": {"epss_score": 0.14729, "epss_percentile": 0.9427}, "CVE-2005-4718": {"epss_score": 0.1086, "epss_percentile": 0.93137}, "CVE-2005-4719": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2005-4720": {"epss_score": 0.12662, "epss_percentile": 0.93742}, "CVE-2005-4721": {"epss_score": 0.00521, "epss_percentile": 0.66245}, "CVE-2005-4722": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2005-4723": {"epss_score": 0.02438, "epss_percentile": 0.84746}, "CVE-2005-4724": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2005-4725": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-2005-4726": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-4727": {"epss_score": 0.01761, "epss_percentile": 0.82149}, "CVE-2005-4728": {"epss_score": 0.00068, "epss_percentile": 0.21423}, "CVE-2005-4729": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2005-4730": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2005-4731": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2005-4732": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2005-4733": {"epss_score": 0.00054, "epss_percentile": 0.17263}, "CVE-2005-4734": {"epss_score": 0.7409, "epss_percentile": 0.98788}, "CVE-2005-4735": {"epss_score": 0.00766, "epss_percentile": 0.72935}, "CVE-2005-4736": {"epss_score": 0.00685, "epss_percentile": 0.71151}, "CVE-2005-4737": {"epss_score": 0.00641, "epss_percentile": 0.69993}, "CVE-2005-4738": {"epss_score": 0.00546, "epss_percentile": 0.67208}, "CVE-2005-4739": {"epss_score": 0.00583, "epss_percentile": 0.68349}, "CVE-2005-4740": {"epss_score": 0.00629, "epss_percentile": 0.69685}, "CVE-2005-4741": {"epss_score": 0.00633, "epss_percentile": 0.69756}, "CVE-2005-4742": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2005-4743": {"epss_score": 0.00315, "epss_percentile": 0.54207}, "CVE-2005-4744": {"epss_score": 0.02525, "epss_percentile": 0.85012}, "CVE-2005-4745": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2005-4746": {"epss_score": 0.01745, "epss_percentile": 0.82066}, "CVE-2005-4747": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2005-4748": {"epss_score": 0.00734, "epss_percentile": 0.72249}, "CVE-2005-4749": {"epss_score": 0.01767, "epss_percentile": 0.82175}, "CVE-2005-4750": {"epss_score": 0.00727, "epss_percentile": 0.721}, "CVE-2005-4751": {"epss_score": 0.01215, "epss_percentile": 0.7859}, "CVE-2005-4752": {"epss_score": 0.00076, "epss_percentile": 0.2313}, "CVE-2005-4753": {"epss_score": 0.01132, "epss_percentile": 0.77871}, "CVE-2005-4754": {"epss_score": 0.00872, "epss_percentile": 0.74721}, "CVE-2005-4755": {"epss_score": 0.00081, "epss_percentile": 0.24228}, "CVE-2005-4756": {"epss_score": 0.01549, "epss_percentile": 0.80981}, "CVE-2005-4757": {"epss_score": 0.00226, "epss_percentile": 0.45286}, "CVE-2005-4758": {"epss_score": 0.00342, "epss_percentile": 0.56382}, "CVE-2005-4759": {"epss_score": 0.00518, "epss_percentile": 0.6614}, "CVE-2005-4760": {"epss_score": 0.0068, "epss_percentile": 0.7103}, "CVE-2005-4761": {"epss_score": 0.0011, "epss_percentile": 0.30203}, "CVE-2005-4762": {"epss_score": 0.00174, "epss_percentile": 0.39219}, "CVE-2005-4763": {"epss_score": 0.01404, "epss_percentile": 0.80037}, "CVE-2005-4764": {"epss_score": 0.00342, "epss_percentile": 0.56367}, "CVE-2005-4765": {"epss_score": 0.01754, "epss_percentile": 0.8212}, "CVE-2005-4766": {"epss_score": 0.00342, "epss_percentile": 0.56367}, "CVE-2005-4767": {"epss_score": 0.01315, "epss_percentile": 0.79401}, "CVE-2005-4768": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2005-4769": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2005-4770": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2005-4771": {"epss_score": 0.00085, "epss_percentile": 0.25138}, "CVE-2005-4772": {"epss_score": 0.00279, "epss_percentile": 0.50998}, "CVE-2005-4773": {"epss_score": 0.00047, "epss_percentile": 0.14774}, "CVE-2005-4774": {"epss_score": 0.01048, "epss_percentile": 0.77052}, "CVE-2005-4775": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2005-4776": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2005-4777": {"epss_score": 0.00071, "epss_percentile": 0.22167}, "CVE-2005-4778": {"epss_score": 0.0006, "epss_percentile": 0.1923}, "CVE-2005-4779": {"epss_score": 0.0007, "epss_percentile": 0.2183}, "CVE-2005-4780": {"epss_score": 0.01503, "epss_percentile": 0.80728}, "CVE-2005-4781": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2005-4782": {"epss_score": 0.00049, "epss_percentile": 0.15456}, "CVE-2005-4783": {"epss_score": 0.00079, "epss_percentile": 0.23905}, "CVE-2005-4784": {"epss_score": 0.00076, "epss_percentile": 0.23267}, "CVE-2005-4785": {"epss_score": 0.00659, "epss_percentile": 0.70508}, "CVE-2005-4786": {"epss_score": 0.01449, "epss_percentile": 0.80345}, "CVE-2005-4787": {"epss_score": 0.00585, "epss_percentile": 0.684}, "CVE-2005-4788": {"epss_score": 0.00058, "epss_percentile": 0.18294}, "CVE-2005-4789": {"epss_score": 0.00058, "epss_percentile": 0.18294}, "CVE-2005-4790": {"epss_score": 0.00347, "epss_percentile": 0.56755}, "CVE-2005-4791": {"epss_score": 0.00152, "epss_percentile": 0.36403}, "CVE-2005-4792": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2005-4793": {"epss_score": 0.00639, "epss_percentile": 0.69943}, "CVE-2005-4794": {"epss_score": 0.02929, "epss_percentile": 0.86014}, "CVE-2005-4795": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2005-4796": {"epss_score": 0.00073, "epss_percentile": 0.22647}, "CVE-2005-4797": {"epss_score": 0.73269, "epss_percentile": 0.98745}, "CVE-2005-4798": {"epss_score": 0.00892, "epss_percentile": 0.75064}, "CVE-2005-4799": {"epss_score": 0.02663, "epss_percentile": 0.85373}, "CVE-2005-4800": {"epss_score": 0.01925, "epss_percentile": 0.82918}, "CVE-2005-4801": {"epss_score": 0.01331, "epss_percentile": 0.7952}, "CVE-2005-4802": {"epss_score": 0.00236, "epss_percentile": 0.46449}, "CVE-2005-4803": {"epss_score": 0.00063, "epss_percentile": 0.20082}, "CVE-2005-4804": {"epss_score": 0.00708, "epss_percentile": 0.71673}, "CVE-2005-4805": {"epss_score": 0.0052, "epss_percentile": 0.66187}, "CVE-2005-4806": {"epss_score": 0.00818, "epss_percentile": 0.73856}, "CVE-2005-4807": {"epss_score": 0.13593, "epss_percentile": 0.94005}, "CVE-2005-4808": {"epss_score": 0.01131, "epss_percentile": 0.77861}, "CVE-2005-4809": {"epss_score": 0.10377, "epss_percentile": 0.92965}, "CVE-2005-4810": {"epss_score": 0.19067, "epss_percentile": 0.95123}, "CVE-2005-4811": {"epss_score": 0.00047, "epss_percentile": 0.14598}, "CVE-2005-4812": {"epss_score": 0.02632, "epss_percentile": 0.85286}, "CVE-2005-4813": {"epss_score": 0.01344, "epss_percentile": 0.79618}, "CVE-2005-4814": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2005-4815": {"epss_score": 0.02313, "epss_percentile": 0.84348}, "CVE-2005-4816": {"epss_score": 0.02842, "epss_percentile": 0.85806}, "CVE-2005-4817": {"epss_score": 0.01148, "epss_percentile": 0.7801}, "CVE-2005-4818": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2005-4819": {"epss_score": 0.01769, "epss_percentile": 0.8219}, "CVE-2005-4820": {"epss_score": 0.0063, "epss_percentile": 0.69705}, "CVE-2005-4821": {"epss_score": 0.00764, "epss_percentile": 0.72904}, "CVE-2005-4822": {"epss_score": 0.00785, "epss_percentile": 0.73264}, "CVE-2005-4823": {"epss_score": 0.07299, "epss_percentile": 0.91392}, "CVE-2005-4824": {"epss_score": 0.00722, "epss_percentile": 0.71998}, "CVE-2005-4825": {"epss_score": 0.00104, "epss_percentile": 0.29191}, "CVE-2005-4826": {"epss_score": 0.01227, "epss_percentile": 0.787}, "CVE-2005-4827": {"epss_score": 0.19029, "epss_percentile": 0.95114}, "CVE-2005-4828": {"epss_score": 0.00445, "epss_percentile": 0.62857}, "CVE-2005-4829": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2005-4830": {"epss_score": 0.0065, "epss_percentile": 0.7025}, "CVE-2005-4831": {"epss_score": 0.00377, "epss_percentile": 0.58742}, "CVE-2005-4832": {"epss_score": 0.63883, "epss_percentile": 0.98353}, "CVE-2005-4833": {"epss_score": 0.00495, "epss_percentile": 0.65101}, "CVE-2005-4834": {"epss_score": 0.00495, "epss_percentile": 0.65101}, "CVE-2005-4835": {"epss_score": 0.0158, "epss_percentile": 0.81134}, "CVE-2005-4836": {"epss_score": 0.00917, "epss_percentile": 0.75433}, "CVE-2005-4837": {"epss_score": 0.09703, "epss_percentile": 0.92669}, "CVE-2005-4838": {"epss_score": 0.08075, "epss_percentile": 0.91868}, "CVE-2005-4839": {"epss_score": 0.00184, "epss_percentile": 0.40456}, "CVE-2005-4840": {"epss_score": 0.28301, "epss_percentile": 0.9634}, "CVE-2005-4841": {"epss_score": 0.12011, "epss_percentile": 0.93547}, "CVE-2005-4842": {"epss_score": 0.12011, "epss_percentile": 0.93547}, "CVE-2005-4843": {"epss_score": 0.13105, "epss_percentile": 0.93876}, "CVE-2005-4844": {"epss_score": 0.12011, "epss_percentile": 0.93547}, "CVE-2005-4845": {"epss_score": 0.00518, "epss_percentile": 0.66094}, "CVE-2005-4846": {"epss_score": 0.00778, "epss_percentile": 0.73127}, "CVE-2005-4847": {"epss_score": 0.00341, "epss_percentile": 0.56305}, "CVE-2005-4848": {"epss_score": 0.03102, "epss_percentile": 0.8641}, "CVE-2005-4849": {"epss_score": 0.02327, "epss_percentile": 0.84392}, "CVE-2005-4850": {"epss_score": 0.00201, "epss_percentile": 0.42335}, "CVE-2005-4851": {"epss_score": 0.00119, "epss_percentile": 0.31613}, "CVE-2005-4852": {"epss_score": 0.0015, "epss_percentile": 0.36179}, "CVE-2005-4853": {"epss_score": 0.00441, "epss_percentile": 0.62653}, "CVE-2005-4854": {"epss_score": 0.00207, "epss_percentile": 0.4316}, "CVE-2005-4855": {"epss_score": 0.00163, "epss_percentile": 0.37765}, "CVE-2005-4856": {"epss_score": 0.00273, "epss_percentile": 0.50482}, "CVE-2005-4857": {"epss_score": 0.00441, "epss_percentile": 0.62652}, "CVE-2005-4858": {"epss_score": 0.00131, "epss_percentile": 0.33407}, "CVE-2005-4859": {"epss_score": 0.00681, "epss_percentile": 0.71044}, "CVE-2005-4860": {"epss_score": 0.00064, "epss_percentile": 0.20146}, "CVE-2005-4861": {"epss_score": 0.0047, "epss_percentile": 0.63976}, "CVE-2005-4862": {"epss_score": 0.00071, "epss_percentile": 0.21996}, "CVE-2005-4863": {"epss_score": 0.00049, "epss_percentile": 0.15372}, "CVE-2005-4864": {"epss_score": 0.00049, "epss_percentile": 0.15372}, "CVE-2005-4865": {"epss_score": 0.28779, "epss_percentile": 0.96383}, "CVE-2005-4866": {"epss_score": 0.01693, "epss_percentile": 0.81796}, "CVE-2005-4867": {"epss_score": 0.20526, "epss_percentile": 0.95365}, "CVE-2005-4868": {"epss_score": 0.00136, "epss_percentile": 0.34057}, "CVE-2005-4869": {"epss_score": 0.00162, "epss_percentile": 0.37739}, "CVE-2005-4870": {"epss_score": 0.02343, "epss_percentile": 0.84442}, "CVE-2005-4871": {"epss_score": 0.00343, "epss_percentile": 0.56426}, "CVE-2005-4872": {"epss_score": 0.01504, "epss_percentile": 0.80735}, "CVE-2005-4873": {"epss_score": 0.0114, "epss_percentile": 0.77947}, "CVE-2005-4874": {"epss_score": 0.00363, "epss_percentile": 0.57875}, "CVE-2005-4875": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2005-4876": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2005-4877": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2005-4878": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2005-4879": {"epss_score": 0.00189, "epss_percentile": 0.40955}, "CVE-2005-4880": {"epss_score": 0.01983, "epss_percentile": 0.83149}, "CVE-2005-4881": {"epss_score": 0.00073, "epss_percentile": 0.22618}, "CVE-2005-4882": {"epss_score": 0.0119, "epss_percentile": 0.78376}, "CVE-2005-4883": {"epss_score": 0.00343, "epss_percentile": 0.56452}, "CVE-2005-4884": {"epss_score": 0.00361, "epss_percentile": 0.57707}, "CVE-2005-4885": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2005-4886": {"epss_score": 0.00918, "epss_percentile": 0.75441}, "CVE-2005-4887": {"epss_score": 0.00138, "epss_percentile": 0.34514}, "CVE-2005-4888": {"epss_score": 0.00704, "epss_percentile": 0.71557}, "CVE-2005-4889": {"epss_score": 0.00047, "epss_percentile": 0.14694}, "CVE-2005-4890": {"epss_score": 0.00135, "epss_percentile": 0.34005}, "CVE-2005-4891": {"epss_score": 0.00368, "epss_percentile": 0.58219}, "CVE-2005-4895": {"epss_score": 0.00323, "epss_percentile": 0.54883}, "CVE-2005-4900": {"epss_score": 0.00219, "epss_percentile": 0.44442}, "CVE-2006-0001": {"epss_score": 0.73182, "epss_percentile": 0.9874}, "CVE-2006-0002": {"epss_score": 0.45632, "epss_percentile": 0.97494}, "CVE-2006-0003": {"epss_score": 0.91596, "epss_percentile": 0.99656}, "CVE-2006-0004": {"epss_score": 0.51054, "epss_percentile": 0.9776}, "CVE-2006-0005": {"epss_score": 0.75519, "epss_percentile": 0.9885}, "CVE-2006-0006": {"epss_score": 0.739, "epss_percentile": 0.98776}, "CVE-2006-0007": {"epss_score": 0.59658, "epss_percentile": 0.98174}, "CVE-2006-0008": {"epss_score": 0.0058, "epss_percentile": 0.68237}, "CVE-2006-0009": {"epss_score": 0.56293, "epss_percentile": 0.98017}, "CVE-2006-0010": {"epss_score": 0.62017, "epss_percentile": 0.98273}, "CVE-2006-0012": {"epss_score": 0.49984, "epss_percentile": 0.97712}, "CVE-2006-0013": {"epss_score": 0.6409, "epss_percentile": 0.98364}, "CVE-2006-0014": {"epss_score": 0.41401, "epss_percentile": 0.97272}, "CVE-2006-0015": {"epss_score": 0.33559, "epss_percentile": 0.96784}, "CVE-2006-0019": {"epss_score": 0.06387, "epss_percentile": 0.90716}, "CVE-2006-0020": {"epss_score": 0.42856, "epss_percentile": 0.97359}, "CVE-2006-0021": {"epss_score": 0.69661, "epss_percentile": 0.98597}, "CVE-2006-0022": {"epss_score": 0.37935, "epss_percentile": 0.97076}, "CVE-2006-0023": {"epss_score": 0.01162, "epss_percentile": 0.78152}, "CVE-2006-0024": {"epss_score": 0.14911, "epss_percentile": 0.9432}, "CVE-2006-0025": {"epss_score": 0.71517, "epss_percentile": 0.98671}, "CVE-2006-0026": {"epss_score": 0.90121, "epss_percentile": 0.99562}, "CVE-2006-0027": {"epss_score": 0.86629, "epss_percentile": 0.9939}, "CVE-2006-0028": {"epss_score": 0.45154, "epss_percentile": 0.97475}, "CVE-2006-0029": {"epss_score": 0.34042, "epss_percentile": 0.96823}, "CVE-2006-0030": {"epss_score": 0.5975, "epss_percentile": 0.98178}, "CVE-2006-0031": {"epss_score": 0.49905, "epss_percentile": 0.9771}, "CVE-2006-0032": {"epss_score": 0.68048, "epss_percentile": 0.98529}, "CVE-2006-0033": {"epss_score": 0.45773, "epss_percentile": 0.97501}, "CVE-2006-0034": {"epss_score": 0.4873, "epss_percentile": 0.97651}, "CVE-2006-0035": {"epss_score": 0.00047, "epss_percentile": 0.148}, "CVE-2006-0036": {"epss_score": 0.01221, "epss_percentile": 0.78645}, "CVE-2006-0037": {"epss_score": 0.00058, "epss_percentile": 0.18355}, "CVE-2006-0038": {"epss_score": 0.00091, "epss_percentile": 0.26411}, "CVE-2006-0039": {"epss_score": 0.00065, "epss_percentile": 0.20542}, "CVE-2006-0040": {"epss_score": 0.00795, "epss_percentile": 0.73476}, "CVE-2006-0042": {"epss_score": 0.07081, "epss_percentile": 0.91238}, "CVE-2006-0043": {"epss_score": 0.00133, "epss_percentile": 0.33633}, "CVE-2006-0044": {"epss_score": 0.01662, "epss_percentile": 0.81637}, "CVE-2006-0045": {"epss_score": 0.00111, "epss_percentile": 0.30374}, "CVE-2006-0046": {"epss_score": 0.03464, "epss_percentile": 0.87187}, "CVE-2006-0047": {"epss_score": 0.16443, "epss_percentile": 0.94661}, "CVE-2006-0048": {"epss_score": 0.00832, "epss_percentile": 0.74066}, "CVE-2006-0049": {"epss_score": 0.04481, "epss_percentile": 0.88742}, "CVE-2006-0050": {"epss_score": 0.00064, "epss_percentile": 0.20347}, "CVE-2006-0051": {"epss_score": 0.02542, "epss_percentile": 0.85051}, "CVE-2006-0052": {"epss_score": 0.06409, "epss_percentile": 0.90739}, "CVE-2006-0053": {"epss_score": 0.03998, "epss_percentile": 0.88086}, "CVE-2006-0054": {"epss_score": 0.03086, "epss_percentile": 0.86386}, "CVE-2006-0055": {"epss_score": 0.00072, "epss_percentile": 0.22419}, "CVE-2006-0056": {"epss_score": 0.22615, "epss_percentile": 0.95659}, "CVE-2006-0057": {"epss_score": 0.39623, "epss_percentile": 0.97171}, "CVE-2006-0058": {"epss_score": 0.5899, "epss_percentile": 0.98143}, "CVE-2006-0059": {"epss_score": 0.06314, "epss_percentile": 0.90666}, "CVE-2006-0061": {"epss_score": 0.00444, "epss_percentile": 0.6281}, "CVE-2006-0062": {"epss_score": 0.0013, "epss_percentile": 0.33278}, "CVE-2006-0063": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-0064": {"epss_score": 0.07178, "epss_percentile": 0.91301}, "CVE-2006-0065": {"epss_score": 0.00963, "epss_percentile": 0.76005}, "CVE-2006-0066": {"epss_score": 0.01029, "epss_percentile": 0.76825}, "CVE-2006-0067": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-0068": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-0069": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0070": {"epss_score": 0.00656, "epss_percentile": 0.70449}, "CVE-2006-0071": {"epss_score": 0.00053, "epss_percentile": 0.17014}, "CVE-2006-0072": {"epss_score": 0.05386, "epss_percentile": 0.89821}, "CVE-2006-0073": {"epss_score": 0.00442, "epss_percentile": 0.627}, "CVE-2006-0074": {"epss_score": 0.01348, "epss_percentile": 0.79659}, "CVE-2006-0075": {"epss_score": 0.07816, "epss_percentile": 0.91697}, "CVE-2006-0076": {"epss_score": 0.07826, "epss_percentile": 0.91701}, "CVE-2006-0077": {"epss_score": 0.00088, "epss_percentile": 0.25664}, "CVE-2006-0078": {"epss_score": 0.01116, "epss_percentile": 0.77721}, "CVE-2006-0079": {"epss_score": 0.00858, "epss_percentile": 0.74506}, "CVE-2006-0080": {"epss_score": 0.00658, "epss_percentile": 0.70494}, "CVE-2006-0081": {"epss_score": 0.00994, "epss_percentile": 0.76421}, "CVE-2006-0082": {"epss_score": 0.03879, "epss_percentile": 0.87894}, "CVE-2006-0083": {"epss_score": 0.00078, "epss_percentile": 0.23688}, "CVE-2006-0084": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-0085": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-0086": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-0087": {"epss_score": 0.03404, "epss_percentile": 0.87072}, "CVE-2006-0088": {"epss_score": 0.01357, "epss_percentile": 0.79723}, "CVE-2006-0089": {"epss_score": 0.02283, "epss_percentile": 0.84258}, "CVE-2006-0090": {"epss_score": 0.01138, "epss_percentile": 0.77935}, "CVE-2006-0091": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-0093": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-0094": {"epss_score": 0.00687, "epss_percentile": 0.71176}, "CVE-2006-0095": {"epss_score": 0.00132, "epss_percentile": 0.33543}, "CVE-2006-0096": {"epss_score": 0.00053, "epss_percentile": 0.16719}, "CVE-2006-0097": {"epss_score": 0.12244, "epss_percentile": 0.9361}, "CVE-2006-0098": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2006-0099": {"epss_score": 0.14015, "epss_percentile": 0.94115}, "CVE-2006-0100": {"epss_score": 0.00073, "epss_percentile": 0.22605}, "CVE-2006-0101": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0102": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2006-0103": {"epss_score": 0.10152, "epss_percentile": 0.92866}, "CVE-2006-0104": {"epss_score": 0.01664, "epss_percentile": 0.8164}, "CVE-2006-0105": {"epss_score": 0.01928, "epss_percentile": 0.82932}, "CVE-2006-0106": {"epss_score": 0.01616, "epss_percentile": 0.81357}, "CVE-2006-0107": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-0108": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-0109": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-0110": {"epss_score": 0.07636, "epss_percentile": 0.91591}, "CVE-2006-0111": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-0112": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-0113": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2006-0114": {"epss_score": 0.00059, "epss_percentile": 0.18726}, "CVE-2006-0115": {"epss_score": 0.00804, "epss_percentile": 0.73613}, "CVE-2006-0116": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-0117": {"epss_score": 0.00791, "epss_percentile": 0.73381}, "CVE-2006-0118": {"epss_score": 0.00791, "epss_percentile": 0.73381}, "CVE-2006-0119": {"epss_score": 0.13197, "epss_percentile": 0.93897}, "CVE-2006-0120": {"epss_score": 0.03437, "epss_percentile": 0.87134}, "CVE-2006-0121": {"epss_score": 0.01076, "epss_percentile": 0.7733}, "CVE-2006-0122": {"epss_score": 0.00681, "epss_percentile": 0.7106}, "CVE-2006-0123": {"epss_score": 0.01485, "epss_percentile": 0.80595}, "CVE-2006-0124": {"epss_score": 0.00731, "epss_percentile": 0.72177}, "CVE-2006-0125": {"epss_score": 0.042, "epss_percentile": 0.88386}, "CVE-2006-0126": {"epss_score": 0.00046, "epss_percentile": 0.14325}, "CVE-2006-0127": {"epss_score": 0.01299, "epss_percentile": 0.79278}, "CVE-2006-0128": {"epss_score": 0.00988, "epss_percentile": 0.76352}, "CVE-2006-0129": {"epss_score": 0.0064, "epss_percentile": 0.69959}, "CVE-2006-0130": {"epss_score": 0.00828, "epss_percentile": 0.73997}, "CVE-2006-0131": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-0132": {"epss_score": 0.00888, "epss_percentile": 0.74997}, "CVE-2006-0133": {"epss_score": 0.01363, "epss_percentile": 0.79765}, "CVE-2006-0134": {"epss_score": 0.00978, "epss_percentile": 0.76237}, "CVE-2006-0135": {"epss_score": 0.03677, "epss_percentile": 0.87554}, "CVE-2006-0136": {"epss_score": 0.03279, "epss_percentile": 0.8681}, "CVE-2006-0137": {"epss_score": 0.01225, "epss_percentile": 0.78681}, "CVE-2006-0138": {"epss_score": 0.08643, "epss_percentile": 0.9217}, "CVE-2006-0139": {"epss_score": 0.00985, "epss_percentile": 0.76319}, "CVE-2006-0140": {"epss_score": 0.00731, "epss_percentile": 0.72177}, "CVE-2006-0141": {"epss_score": 0.02574, "epss_percentile": 0.85139}, "CVE-2006-0142": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-0143": {"epss_score": 0.75521, "epss_percentile": 0.98851}, "CVE-2006-0144": {"epss_score": 0.01457, "epss_percentile": 0.80397}, "CVE-2006-0145": {"epss_score": 0.00073, "epss_percentile": 0.22538}, "CVE-2006-0146": {"epss_score": 0.07657, "epss_percentile": 0.91607}, "CVE-2006-0147": {"epss_score": 0.2117, "epss_percentile": 0.95472}, "CVE-2006-0148": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2006-0149": {"epss_score": 0.00369, "epss_percentile": 0.58247}, "CVE-2006-0150": {"epss_score": 0.10294, "epss_percentile": 0.92931}, "CVE-2006-0151": {"epss_score": 0.00127, "epss_percentile": 0.3279}, "CVE-2006-0152": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0153": {"epss_score": 0.12712, "epss_percentile": 0.93755}, "CVE-2006-0154": {"epss_score": 0.01432, "epss_percentile": 0.80248}, "CVE-2006-0155": {"epss_score": 0.00704, "epss_percentile": 0.71565}, "CVE-2006-0156": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2006-0157": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2006-0158": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-0159": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-0160": {"epss_score": 0.03968, "epss_percentile": 0.88034}, "CVE-2006-0161": {"epss_score": 0.00081, "epss_percentile": 0.24243}, "CVE-2006-0162": {"epss_score": 0.27999, "epss_percentile": 0.96301}, "CVE-2006-0163": {"epss_score": 0.17139, "epss_percentile": 0.94781}, "CVE-2006-0164": {"epss_score": 0.08939, "epss_percentile": 0.92328}, "CVE-2006-0165": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0166": {"epss_score": 0.01133, "epss_percentile": 0.77881}, "CVE-2006-0167": {"epss_score": 0.05937, "epss_percentile": 0.90345}, "CVE-2006-0168": {"epss_score": 0.00731, "epss_percentile": 0.72177}, "CVE-2006-0169": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2006-0171": {"epss_score": 0.05656, "epss_percentile": 0.90092}, "CVE-2006-0172": {"epss_score": 0.00475, "epss_percentile": 0.64242}, "CVE-2006-0173": {"epss_score": 0.04312, "epss_percentile": 0.88533}, "CVE-2006-0174": {"epss_score": 0.04822, "epss_percentile": 0.89179}, "CVE-2006-0175": {"epss_score": 0.00522, "epss_percentile": 0.6626}, "CVE-2006-0176": {"epss_score": 0.00096, "epss_percentile": 0.27271}, "CVE-2006-0177": {"epss_score": 0.00156, "epss_percentile": 0.3697}, "CVE-2006-0178": {"epss_score": 0.00052, "epss_percentile": 0.16481}, "CVE-2006-0179": {"epss_score": 0.14901, "epss_percentile": 0.94318}, "CVE-2006-0180": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-0181": {"epss_score": 0.00065, "epss_percentile": 0.20436}, "CVE-2006-0182": {"epss_score": 0.00978, "epss_percentile": 0.76237}, "CVE-2006-0183": {"epss_score": 0.01465, "epss_percentile": 0.80459}, "CVE-2006-0184": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-0185": {"epss_score": 0.03174, "epss_percentile": 0.8656}, "CVE-2006-0187": {"epss_score": 0.37398, "epss_percentile": 0.97042}, "CVE-2006-0188": {"epss_score": 0.01359, "epss_percentile": 0.79737}, "CVE-2006-0189": {"epss_score": 0.42547, "epss_percentile": 0.97337}, "CVE-2006-0190": {"epss_score": 0.00051, "epss_percentile": 0.16116}, "CVE-2006-0191": {"epss_score": 0.00051, "epss_percentile": 0.16123}, "CVE-2006-0192": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2006-0193": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-0194": {"epss_score": 0.00864, "epss_percentile": 0.7461}, "CVE-2006-0195": {"epss_score": 0.02742, "epss_percentile": 0.85564}, "CVE-2006-0196": {"epss_score": 0.00078, "epss_percentile": 0.23598}, "CVE-2006-0197": {"epss_score": 0.00406, "epss_percentile": 0.60529}, "CVE-2006-0198": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-0199": {"epss_score": 0.0295, "epss_percentile": 0.86052}, "CVE-2006-0200": {"epss_score": 0.1236, "epss_percentile": 0.9365}, "CVE-2006-0201": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2006-0202": {"epss_score": 0.00059, "epss_percentile": 0.18721}, "CVE-2006-0203": {"epss_score": 0.01425, "epss_percentile": 0.80198}, "CVE-2006-0204": {"epss_score": 0.00773, "epss_percentile": 0.73059}, "CVE-2006-0205": {"epss_score": 0.01579, "epss_percentile": 0.81126}, "CVE-2006-0206": {"epss_score": 0.10246, "epss_percentile": 0.92911}, "CVE-2006-0207": {"epss_score": 0.04282, "epss_percentile": 0.8849}, "CVE-2006-0208": {"epss_score": 0.02179, "epss_percentile": 0.83896}, "CVE-2006-0209": {"epss_score": 0.02744, "epss_percentile": 0.85567}, "CVE-2006-0210": {"epss_score": 0.007, "epss_percentile": 0.7148}, "CVE-2006-0211": {"epss_score": 0.00771, "epss_percentile": 0.73017}, "CVE-2006-0212": {"epss_score": 0.01664, "epss_percentile": 0.8164}, "CVE-2006-0213": {"epss_score": 0.00093, "epss_percentile": 0.26752}, "CVE-2006-0214": {"epss_score": 0.02787, "epss_percentile": 0.85659}, "CVE-2006-0215": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2006-0216": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2006-0217": {"epss_score": 0.00969, "epss_percentile": 0.7609}, "CVE-2006-0218": {"epss_score": 0.00313, "epss_percentile": 0.54014}, "CVE-2006-0219": {"epss_score": 0.00383, "epss_percentile": 0.59113}, "CVE-2006-0220": {"epss_score": 0.00329, "epss_percentile": 0.55403}, "CVE-2006-0221": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-0222": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-0223": {"epss_score": 0.00872, "epss_percentile": 0.74722}, "CVE-2006-0224": {"epss_score": 0.00241, "epss_percentile": 0.47267}, "CVE-2006-0225": {"epss_score": 0.00098, "epss_percentile": 0.27694}, "CVE-2006-0226": {"epss_score": 0.17279, "epss_percentile": 0.94815}, "CVE-2006-0227": {"epss_score": 0.0007, "epss_percentile": 0.21661}, "CVE-2006-0228": {"epss_score": 0.00055, "epss_percentile": 0.17556}, "CVE-2006-0229": {"epss_score": 0.00092, "epss_percentile": 0.26487}, "CVE-2006-0230": {"epss_score": 0.32694, "epss_percentile": 0.96717}, "CVE-2006-0231": {"epss_score": 0.00689, "epss_percentile": 0.71228}, "CVE-2006-0232": {"epss_score": 0.00879, "epss_percentile": 0.74838}, "CVE-2006-0233": {"epss_score": 0.00416, "epss_percentile": 0.61177}, "CVE-2006-0234": {"epss_score": 0.0173, "epss_percentile": 0.81988}, "CVE-2006-0235": {"epss_score": 0.00555, "epss_percentile": 0.67457}, "CVE-2006-0236": {"epss_score": 0.01483, "epss_percentile": 0.80587}, "CVE-2006-0237": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-0238": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-0239": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-0240": {"epss_score": 0.00721, "epss_percentile": 0.71985}, "CVE-2006-0241": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-0242": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2006-0243": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0244": {"epss_score": 0.13759, "epss_percentile": 0.94052}, "CVE-2006-0245": {"epss_score": 0.00871, "epss_percentile": 0.74714}, "CVE-2006-0246": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-0247": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-0248": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2006-0249": {"epss_score": 0.02509, "epss_percentile": 0.84946}, "CVE-2006-0250": {"epss_score": 0.03286, "epss_percentile": 0.86828}, "CVE-2006-0251": {"epss_score": 0.09979, "epss_percentile": 0.92801}, "CVE-2006-0252": {"epss_score": 0.01467, "epss_percentile": 0.80473}, "CVE-2006-0253": {"epss_score": 0.06109, "epss_percentile": 0.90486}, "CVE-2006-0254": {"epss_score": 0.45321, "epss_percentile": 0.97482}, "CVE-2006-0255": {"epss_score": 0.00057, "epss_percentile": 0.18137}, "CVE-2006-0256": {"epss_score": 0.01135, "epss_percentile": 0.77896}, "CVE-2006-0257": {"epss_score": 0.01243, "epss_percentile": 0.78825}, "CVE-2006-0258": {"epss_score": 0.02151, "epss_percentile": 0.83785}, "CVE-2006-0259": {"epss_score": 0.01199, "epss_percentile": 0.78462}, "CVE-2006-0260": {"epss_score": 0.01352, "epss_percentile": 0.79688}, "CVE-2006-0261": {"epss_score": 0.03693, "epss_percentile": 0.87581}, "CVE-2006-0262": {"epss_score": 0.02486, "epss_percentile": 0.84885}, "CVE-2006-0263": {"epss_score": 0.10615, "epss_percentile": 0.93049}, "CVE-2006-0265": {"epss_score": 0.02808, "epss_percentile": 0.85711}, "CVE-2006-0266": {"epss_score": 0.01326, "epss_percentile": 0.79479}, "CVE-2006-0267": {"epss_score": 0.01326, "epss_percentile": 0.79479}, "CVE-2006-0268": {"epss_score": 0.01326, "epss_percentile": 0.79479}, "CVE-2006-0269": {"epss_score": 0.00689, "epss_percentile": 0.71228}, "CVE-2006-0270": {"epss_score": 0.02237, "epss_percentile": 0.84104}, "CVE-2006-0271": {"epss_score": 0.01599, "epss_percentile": 0.81253}, "CVE-2006-0272": {"epss_score": 0.30906, "epss_percentile": 0.96575}, "CVE-2006-0273": {"epss_score": 0.02424, "epss_percentile": 0.84709}, "CVE-2006-0274": {"epss_score": 0.01989, "epss_percentile": 0.83169}, "CVE-2006-0275": {"epss_score": 0.02604, "epss_percentile": 0.85217}, "CVE-2006-0276": {"epss_score": 0.0302, "epss_percentile": 0.86222}, "CVE-2006-0277": {"epss_score": 0.01885, "epss_percentile": 0.82709}, "CVE-2006-0278": {"epss_score": 0.02486, "epss_percentile": 0.84885}, "CVE-2006-0279": {"epss_score": 0.01885, "epss_percentile": 0.82709}, "CVE-2006-0280": {"epss_score": 0.01885, "epss_percentile": 0.82709}, "CVE-2006-0281": {"epss_score": 0.01885, "epss_percentile": 0.82709}, "CVE-2006-0282": {"epss_score": 0.01989, "epss_percentile": 0.83169}, "CVE-2006-0283": {"epss_score": 0.02945, "epss_percentile": 0.86039}, "CVE-2006-0284": {"epss_score": 0.01989, "epss_percentile": 0.83169}, "CVE-2006-0285": {"epss_score": 0.01526, "epss_percentile": 0.80866}, "CVE-2006-0286": {"epss_score": 0.01989, "epss_percentile": 0.83169}, "CVE-2006-0287": {"epss_score": 0.53182, "epss_percentile": 0.9786}, "CVE-2006-0288": {"epss_score": 0.02945, "epss_percentile": 0.86039}, "CVE-2006-0289": {"epss_score": 0.02557, "epss_percentile": 0.85094}, "CVE-2006-0290": {"epss_score": 0.01989, "epss_percentile": 0.83169}, "CVE-2006-0291": {"epss_score": 0.01989, "epss_percentile": 0.83169}, "CVE-2006-0292": {"epss_score": 0.10389, "epss_percentile": 0.92971}, "CVE-2006-0293": {"epss_score": 0.03721, "epss_percentile": 0.87621}, "CVE-2006-0294": {"epss_score": 0.07642, "epss_percentile": 0.91595}, "CVE-2006-0295": {"epss_score": 0.82372, "epss_percentile": 0.9919}, "CVE-2006-0296": {"epss_score": 0.41202, "epss_percentile": 0.97259}, "CVE-2006-0297": {"epss_score": 0.10028, "epss_percentile": 0.9282}, "CVE-2006-0298": {"epss_score": 0.05921, "epss_percentile": 0.90321}, "CVE-2006-0299": {"epss_score": 0.01276, "epss_percentile": 0.79108}, "CVE-2006-0300": {"epss_score": 0.18808, "epss_percentile": 0.95073}, "CVE-2006-0301": {"epss_score": 0.03084, "epss_percentile": 0.86382}, "CVE-2006-0302": {"epss_score": 0.00524, "epss_percentile": 0.66329}, "CVE-2006-0303": {"epss_score": 0.0001, "epss_percentile": 0.00781}, "CVE-2006-0304": {"epss_score": 0.16602, "epss_percentile": 0.94701}, "CVE-2006-0305": {"epss_score": 0.01075, "epss_percentile": 0.77311}, "CVE-2006-0306": {"epss_score": 0.15632, "epss_percentile": 0.94473}, "CVE-2006-0307": {"epss_score": 0.01735, "epss_percentile": 0.8201}, "CVE-2006-0308": {"epss_score": 0.04963, "epss_percentile": 0.89338}, "CVE-2006-0309": {"epss_score": 0.01146, "epss_percentile": 0.78001}, "CVE-2006-0310": {"epss_score": 0.09888, "epss_percentile": 0.92755}, "CVE-2006-0311": {"epss_score": 0.02128, "epss_percentile": 0.837}, "CVE-2006-0312": {"epss_score": 0.12712, "epss_percentile": 0.93755}, "CVE-2006-0313": {"epss_score": 0.01987, "epss_percentile": 0.83163}, "CVE-2006-0314": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-0315": {"epss_score": 0.04026, "epss_percentile": 0.8814}, "CVE-2006-0316": {"epss_score": 0.37651, "epss_percentile": 0.97062}, "CVE-2006-0317": {"epss_score": 0.00584, "epss_percentile": 0.68366}, "CVE-2006-0318": {"epss_score": 0.04009, "epss_percentile": 0.88107}, "CVE-2006-0319": {"epss_score": 0.06867, "epss_percentile": 0.91083}, "CVE-2006-0320": {"epss_score": 0.0364, "epss_percentile": 0.87489}, "CVE-2006-0321": {"epss_score": 0.14329, "epss_percentile": 0.94188}, "CVE-2006-0322": {"epss_score": 0.0074, "epss_percentile": 0.72405}, "CVE-2006-0323": {"epss_score": 0.59826, "epss_percentile": 0.98182}, "CVE-2006-0324": {"epss_score": 0.01685, "epss_percentile": 0.8175}, "CVE-2006-0325": {"epss_score": 0.02595, "epss_percentile": 0.85194}, "CVE-2006-0327": {"epss_score": 0.01903, "epss_percentile": 0.82787}, "CVE-2006-0328": {"epss_score": 0.55324, "epss_percentile": 0.97972}, "CVE-2006-0329": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-0330": {"epss_score": 0.01345, "epss_percentile": 0.79625}, "CVE-2006-0331": {"epss_score": 0.00181, "epss_percentile": 0.40022}, "CVE-2006-0332": {"epss_score": 0.00647, "epss_percentile": 0.70189}, "CVE-2006-0333": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-0334": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-0335": {"epss_score": 0.0192, "epss_percentile": 0.82894}, "CVE-2006-0336": {"epss_score": 0.00828, "epss_percentile": 0.74001}, "CVE-2006-0337": {"epss_score": 0.06413, "epss_percentile": 0.90743}, "CVE-2006-0338": {"epss_score": 0.02148, "epss_percentile": 0.8377}, "CVE-2006-0339": {"epss_score": 0.07618, "epss_percentile": 0.91572}, "CVE-2006-0340": {"epss_score": 0.01641, "epss_percentile": 0.81504}, "CVE-2006-0341": {"epss_score": 0.07141, "epss_percentile": 0.91278}, "CVE-2006-0342": {"epss_score": 0.01886, "epss_percentile": 0.82712}, "CVE-2006-0343": {"epss_score": 0.00743, "epss_percentile": 0.72481}, "CVE-2006-0344": {"epss_score": 0.04056, "epss_percentile": 0.88185}, "CVE-2006-0345": {"epss_score": 0.01029, "epss_percentile": 0.76825}, "CVE-2006-0346": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-0347": {"epss_score": 0.00966, "epss_percentile": 0.76063}, "CVE-2006-0348": {"epss_score": 0.01344, "epss_percentile": 0.79618}, "CVE-2006-0349": {"epss_score": 0.017, "epss_percentile": 0.81833}, "CVE-2006-0350": {"epss_score": 0.08938, "epss_percentile": 0.92327}, "CVE-2006-0351": {"epss_score": 0.01489, "epss_percentile": 0.80625}, "CVE-2006-0352": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0353": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2006-0354": {"epss_score": 0.07828, "epss_percentile": 0.91702}, "CVE-2006-0355": {"epss_score": 0.04313, "epss_percentile": 0.88535}, "CVE-2006-0356": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2006-0357": {"epss_score": 0.03978, "epss_percentile": 0.88055}, "CVE-2006-0358": {"epss_score": 0.00676, "epss_percentile": 0.70921}, "CVE-2006-0359": {"epss_score": 0.28745, "epss_percentile": 0.96381}, "CVE-2006-0360": {"epss_score": 0.01392, "epss_percentile": 0.79958}, "CVE-2006-0361": {"epss_score": 0.11996, "epss_percentile": 0.93541}, "CVE-2006-0362": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-0363": {"epss_score": 0.01164, "epss_percentile": 0.78165}, "CVE-2006-0364": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-0365": {"epss_score": 0.00422, "epss_percentile": 0.61545}, "CVE-2006-0366": {"epss_score": 0.00756, "epss_percentile": 0.72743}, "CVE-2006-0367": {"epss_score": 0.01224, "epss_percentile": 0.78672}, "CVE-2006-0368": {"epss_score": 0.02748, "epss_percentile": 0.85577}, "CVE-2006-0369": {"epss_score": 0.0015, "epss_percentile": 0.36124}, "CVE-2006-0370": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2006-0371": {"epss_score": 0.00961, "epss_percentile": 0.75981}, "CVE-2006-0372": {"epss_score": 0.00555, "epss_percentile": 0.67457}, "CVE-2006-0373": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-0374": {"epss_score": 0.01068, "epss_percentile": 0.77242}, "CVE-2006-0375": {"epss_score": 0.00425, "epss_percentile": 0.61724}, "CVE-2006-0376": {"epss_score": 0.29308, "epss_percentile": 0.96432}, "CVE-2006-0377": {"epss_score": 0.01774, "epss_percentile": 0.82212}, "CVE-2006-0378": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-0379": {"epss_score": 0.0007, "epss_percentile": 0.21698}, "CVE-2006-0380": {"epss_score": 0.00078, "epss_percentile": 0.23623}, "CVE-2006-0381": {"epss_score": 0.05147, "epss_percentile": 0.89545}, "CVE-2006-0382": {"epss_score": 0.00066, "epss_percentile": 0.20858}, "CVE-2006-0383": {"epss_score": 0.01157, "epss_percentile": 0.78111}, "CVE-2006-0384": {"epss_score": 0.01873, "epss_percentile": 0.82641}, "CVE-2006-0386": {"epss_score": 0.00068, "epss_percentile": 0.21356}, "CVE-2006-0387": {"epss_score": 0.10601, "epss_percentile": 0.93042}, "CVE-2006-0388": {"epss_score": 0.00414, "epss_percentile": 0.61028}, "CVE-2006-0389": {"epss_score": 0.00584, "epss_percentile": 0.68358}, "CVE-2006-0391": {"epss_score": 0.00628, "epss_percentile": 0.69655}, "CVE-2006-0392": {"epss_score": 0.00876, "epss_percentile": 0.74787}, "CVE-2006-0393": {"epss_score": 0.00988, "epss_percentile": 0.76349}, "CVE-2006-0395": {"epss_score": 0.64008, "epss_percentile": 0.98359}, "CVE-2006-0396": {"epss_score": 0.2331, "epss_percentile": 0.95763}, "CVE-2006-0397": {"epss_score": 0.00794, "epss_percentile": 0.7344}, "CVE-2006-0398": {"epss_score": 0.00794, "epss_percentile": 0.7344}, "CVE-2006-0399": {"epss_score": 0.00794, "epss_percentile": 0.7344}, "CVE-2006-0400": {"epss_score": 0.00584, "epss_percentile": 0.68372}, "CVE-2006-0401": {"epss_score": 0.00081, "epss_percentile": 0.24243}, "CVE-2006-0402": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-0403": {"epss_score": 0.02475, "epss_percentile": 0.84861}, "CVE-2006-0404": {"epss_score": 0.00714, "epss_percentile": 0.71818}, "CVE-2006-0405": {"epss_score": 0.01836, "epss_percentile": 0.82474}, "CVE-2006-0406": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2006-0407": {"epss_score": 0.01339, "epss_percentile": 0.79572}, "CVE-2006-0408": {"epss_score": 0.00059, "epss_percentile": 0.18798}, "CVE-2006-0409": {"epss_score": 0.07636, "epss_percentile": 0.91591}, "CVE-2006-0410": {"epss_score": 0.01497, "epss_percentile": 0.80686}, "CVE-2006-0411": {"epss_score": 0.01089, "epss_percentile": 0.77444}, "CVE-2006-0412": {"epss_score": 0.01406, "epss_percentile": 0.80049}, "CVE-2006-0413": {"epss_score": 0.00549, "epss_percentile": 0.67317}, "CVE-2006-0414": {"epss_score": 0.01145, "epss_percentile": 0.77993}, "CVE-2006-0415": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-0416": {"epss_score": 0.00625, "epss_percentile": 0.69597}, "CVE-2006-0417": {"epss_score": 0.03021, "epss_percentile": 0.86224}, "CVE-2006-0418": {"epss_score": 0.04022, "epss_percentile": 0.88135}, "CVE-2006-0419": {"epss_score": 0.00588, "epss_percentile": 0.68487}, "CVE-2006-0420": {"epss_score": 0.00534, "epss_percentile": 0.66789}, "CVE-2006-0421": {"epss_score": 0.00093, "epss_percentile": 0.26672}, "CVE-2006-0422": {"epss_score": 0.00952, "epss_percentile": 0.75882}, "CVE-2006-0423": {"epss_score": 0.01667, "epss_percentile": 0.81657}, "CVE-2006-0424": {"epss_score": 0.00315, "epss_percentile": 0.54176}, "CVE-2006-0425": {"epss_score": 0.00525, "epss_percentile": 0.66385}, "CVE-2006-0426": {"epss_score": 0.00749, "epss_percentile": 0.72597}, "CVE-2006-0427": {"epss_score": 0.00078, "epss_percentile": 0.23566}, "CVE-2006-0428": {"epss_score": 0.01409, "epss_percentile": 0.80076}, "CVE-2006-0429": {"epss_score": 0.00105, "epss_percentile": 0.29385}, "CVE-2006-0430": {"epss_score": 0.00952, "epss_percentile": 0.75882}, "CVE-2006-0431": {"epss_score": 0.00078, "epss_percentile": 0.23566}, "CVE-2006-0432": {"epss_score": 0.00105, "epss_percentile": 0.29385}, "CVE-2006-0433": {"epss_score": 0.01362, "epss_percentile": 0.79763}, "CVE-2006-0434": {"epss_score": 0.00116, "epss_percentile": 0.31046}, "CVE-2006-0435": {"epss_score": 0.05447, "epss_percentile": 0.89889}, "CVE-2006-0436": {"epss_score": 0.00053, "epss_percentile": 0.16831}, "CVE-2006-0437": {"epss_score": 0.00747, "epss_percentile": 0.72563}, "CVE-2006-0438": {"epss_score": 0.00745, "epss_percentile": 0.72531}, "CVE-2006-0439": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2006-0440": {"epss_score": 0.0065, "epss_percentile": 0.70269}, "CVE-2006-0441": {"epss_score": 0.81125, "epss_percentile": 0.99122}, "CVE-2006-0442": {"epss_score": 0.00528, "epss_percentile": 0.66544}, "CVE-2006-0443": {"epss_score": 0.09888, "epss_percentile": 0.92755}, "CVE-2006-0444": {"epss_score": 0.01611, "epss_percentile": 0.81326}, "CVE-2006-0445": {"epss_score": 0.00297, "epss_percentile": 0.52706}, "CVE-2006-0446": {"epss_score": 0.01283, "epss_percentile": 0.79165}, "CVE-2006-0447": {"epss_score": 0.04874, "epss_percentile": 0.89237}, "CVE-2006-0448": {"epss_score": 0.01498, "epss_percentile": 0.80704}, "CVE-2006-0449": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-0450": {"epss_score": 0.09126, "epss_percentile": 0.92413}, "CVE-2006-0451": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2006-0452": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2006-0453": {"epss_score": 0.00834, "epss_percentile": 0.74111}, "CVE-2006-0454": {"epss_score": 0.06371, "epss_percentile": 0.90705}, "CVE-2006-0455": {"epss_score": 0.02209, "epss_percentile": 0.84011}, "CVE-2006-0456": {"epss_score": 0.00089, "epss_percentile": 0.25973}, "CVE-2006-0457": {"epss_score": 0.015, "epss_percentile": 0.80711}, "CVE-2006-0458": {"epss_score": 0.00928, "epss_percentile": 0.75578}, "CVE-2006-0459": {"epss_score": 0.0397, "epss_percentile": 0.88036}, "CVE-2006-0460": {"epss_score": 0.82218, "epss_percentile": 0.9918}, "CVE-2006-0461": {"epss_score": 0.08591, "epss_percentile": 0.9214}, "CVE-2006-0462": {"epss_score": 0.02998, "epss_percentile": 0.86159}, "CVE-2006-0463": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2006-0464": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2006-0465": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2006-0466": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2006-0467": {"epss_score": 0.01475, "epss_percentile": 0.80526}, "CVE-2006-0468": {"epss_score": 0.20438, "epss_percentile": 0.95345}, "CVE-2006-0469": {"epss_score": 0.00771, "epss_percentile": 0.73017}, "CVE-2006-0470": {"epss_score": 0.01248, "epss_percentile": 0.78867}, "CVE-2006-0471": {"epss_score": 0.01247, "epss_percentile": 0.7886}, "CVE-2006-0472": {"epss_score": 0.01247, "epss_percentile": 0.7886}, "CVE-2006-0473": {"epss_score": 0.1109, "epss_percentile": 0.93215}, "CVE-2006-0474": {"epss_score": 0.05504, "epss_percentile": 0.89941}, "CVE-2006-0475": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2006-0476": {"epss_score": 0.88573, "epss_percentile": 0.99478}, "CVE-2006-0477": {"epss_score": 0.06718, "epss_percentile": 0.90965}, "CVE-2006-0478": {"epss_score": 0.07607, "epss_percentile": 0.91566}, "CVE-2006-0479": {"epss_score": 0.01332, "epss_percentile": 0.79524}, "CVE-2006-0480": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2006-0481": {"epss_score": 0.02064, "epss_percentile": 0.83452}, "CVE-2006-0482": {"epss_score": 0.00066, "epss_percentile": 0.20858}, "CVE-2006-0483": {"epss_score": 0.01072, "epss_percentile": 0.77273}, "CVE-2006-0484": {"epss_score": 0.00674, "epss_percentile": 0.70875}, "CVE-2006-0485": {"epss_score": 0.00135, "epss_percentile": 0.34028}, "CVE-2006-0486": {"epss_score": 0.00099, "epss_percentile": 0.28348}, "CVE-2006-0487": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2006-0488": {"epss_score": 0.01471, "epss_percentile": 0.80501}, "CVE-2006-0489": {"epss_score": 0.00137, "epss_percentile": 0.34232}, "CVE-2006-0490": {"epss_score": 0.04084, "epss_percentile": 0.88223}, "CVE-2006-0491": {"epss_score": 0.02244, "epss_percentile": 0.84122}, "CVE-2006-0492": {"epss_score": 0.01887, "epss_percentile": 0.82718}, "CVE-2006-0493": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0494": {"epss_score": 0.00041, "epss_percentile": 0.12431}, "CVE-2006-0495": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-0496": {"epss_score": 0.11452, "epss_percentile": 0.93365}, "CVE-2006-0497": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2006-0498": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0499": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0500": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2006-0501": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-0502": {"epss_score": 0.14098, "epss_percentile": 0.94132}, "CVE-2006-0503": {"epss_score": 0.0417, "epss_percentile": 0.88346}, "CVE-2006-0504": {"epss_score": 0.01773, "epss_percentile": 0.82204}, "CVE-2006-0505": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2006-0506": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-0507": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-0508": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2006-0509": {"epss_score": 0.06618, "epss_percentile": 0.90892}, "CVE-2006-0510": {"epss_score": 0.00688, "epss_percentile": 0.71205}, "CVE-2006-0511": {"epss_score": 0.00186, "epss_percentile": 0.40682}, "CVE-2006-0512": {"epss_score": 0.0007, "epss_percentile": 0.2183}, "CVE-2006-0513": {"epss_score": 0.16714, "epss_percentile": 0.9472}, "CVE-2006-0515": {"epss_score": 0.09622, "epss_percentile": 0.92627}, "CVE-2006-0516": {"epss_score": 0.00063, "epss_percentile": 0.20082}, "CVE-2006-0517": {"epss_score": 0.03479, "epss_percentile": 0.87215}, "CVE-2006-0518": {"epss_score": 0.08059, "epss_percentile": 0.91859}, "CVE-2006-0519": {"epss_score": 0.00824, "epss_percentile": 0.73936}, "CVE-2006-0520": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2006-0521": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-0522": {"epss_score": 0.0169, "epss_percentile": 0.81773}, "CVE-2006-0523": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-0524": {"epss_score": 0.02635, "epss_percentile": 0.85291}, "CVE-2006-0525": {"epss_score": 0.00237, "epss_percentile": 0.4671}, "CVE-2006-0526": {"epss_score": 0.00069, "epss_percentile": 0.21443}, "CVE-2006-0527": {"epss_score": 0.06541, "epss_percentile": 0.90834}, "CVE-2006-0528": {"epss_score": 0.05109, "epss_percentile": 0.89507}, "CVE-2006-0529": {"epss_score": 0.01954, "epss_percentile": 0.83032}, "CVE-2006-0530": {"epss_score": 0.01362, "epss_percentile": 0.79763}, "CVE-2006-0531": {"epss_score": 0.00077, "epss_percentile": 0.23285}, "CVE-2006-0532": {"epss_score": 0.10084, "epss_percentile": 0.92843}, "CVE-2006-0533": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-0534": {"epss_score": 0.04858, "epss_percentile": 0.8922}, "CVE-2006-0535": {"epss_score": 0.00362, "epss_percentile": 0.57779}, "CVE-2006-0536": {"epss_score": 0.00491, "epss_percentile": 0.64959}, "CVE-2006-0537": {"epss_score": 0.17921, "epss_percentile": 0.94928}, "CVE-2006-0538": {"epss_score": 0.01118, "epss_percentile": 0.77746}, "CVE-2006-0539": {"epss_score": 0.00331, "epss_percentile": 0.55507}, "CVE-2006-0540": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-0541": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0542": {"epss_score": 0.01311, "epss_percentile": 0.7937}, "CVE-2006-0543": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2006-0544": {"epss_score": 0.36669, "epss_percentile": 0.96994}, "CVE-2006-0545": {"epss_score": 0.00514, "epss_percentile": 0.65942}, "CVE-2006-0546": {"epss_score": 0.01624, "epss_percentile": 0.81414}, "CVE-2006-0547": {"epss_score": 0.09005, "epss_percentile": 0.9236}, "CVE-2006-0548": {"epss_score": 0.02204, "epss_percentile": 0.83996}, "CVE-2006-0549": {"epss_score": 0.01156, "epss_percentile": 0.78081}, "CVE-2006-0550": {"epss_score": 0.06519, "epss_percentile": 0.90817}, "CVE-2006-0551": {"epss_score": 0.01489, "epss_percentile": 0.8062}, "CVE-2006-0552": {"epss_score": 0.04381, "epss_percentile": 0.88623}, "CVE-2006-0553": {"epss_score": 0.02066, "epss_percentile": 0.83458}, "CVE-2006-0554": {"epss_score": 0.00114, "epss_percentile": 0.30829}, "CVE-2006-0555": {"epss_score": 0.00097, "epss_percentile": 0.27459}, "CVE-2006-0557": {"epss_score": 0.00079, "epss_percentile": 0.23912}, "CVE-2006-0558": {"epss_score": 0.00048, "epss_percentile": 0.15005}, "CVE-2006-0559": {"epss_score": 0.19529, "epss_percentile": 0.95201}, "CVE-2006-0561": {"epss_score": 0.00049, "epss_percentile": 0.15374}, "CVE-2006-0562": {"epss_score": 0.00742, "epss_percentile": 0.7246}, "CVE-2006-0563": {"epss_score": 0.02157, "epss_percentile": 0.83813}, "CVE-2006-0564": {"epss_score": 0.72006, "epss_percentile": 0.98692}, "CVE-2006-0565": {"epss_score": 0.18103, "epss_percentile": 0.94957}, "CVE-2006-0566": {"epss_score": 0.01954, "epss_percentile": 0.83032}, "CVE-2006-0567": {"epss_score": 0.00391, "epss_percentile": 0.59584}, "CVE-2006-0568": {"epss_score": 0.0081, "epss_percentile": 0.73717}, "CVE-2006-0569": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-0570": {"epss_score": 0.00374, "epss_percentile": 0.58572}, "CVE-2006-0571": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-0572": {"epss_score": 0.00793, "epss_percentile": 0.73421}, "CVE-2006-0573": {"epss_score": 0.01067, "epss_percentile": 0.77232}, "CVE-2006-0574": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-0575": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-0576": {"epss_score": 0.00073, "epss_percentile": 0.22504}, "CVE-2006-0577": {"epss_score": 0.00049, "epss_percentile": 0.1545}, "CVE-2006-0578": {"epss_score": 0.00552, "epss_percentile": 0.67386}, "CVE-2006-0579": {"epss_score": 0.05656, "epss_percentile": 0.90093}, "CVE-2006-0580": {"epss_score": 0.07086, "epss_percentile": 0.91241}, "CVE-2006-0581": {"epss_score": 0.01118, "epss_percentile": 0.77744}, "CVE-2006-0582": {"epss_score": 0.00085, "epss_percentile": 0.25146}, "CVE-2006-0583": {"epss_score": 0.01993, "epss_percentile": 0.83185}, "CVE-2006-0584": {"epss_score": 0.0007, "epss_percentile": 0.21778}, "CVE-2006-0585": {"epss_score": 0.29854, "epss_percentile": 0.96481}, "CVE-2006-0586": {"epss_score": 0.17061, "epss_percentile": 0.94766}, "CVE-2006-0587": {"epss_score": 0.02212, "epss_percentile": 0.84016}, "CVE-2006-0588": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-0589": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2006-0590": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2006-0591": {"epss_score": 0.00091, "epss_percentile": 0.26284}, "CVE-2006-0592": {"epss_score": 0.02299, "epss_percentile": 0.84306}, "CVE-2006-0593": {"epss_score": 0.00608, "epss_percentile": 0.69078}, "CVE-2006-0597": {"epss_score": 0.00937, "epss_percentile": 0.75695}, "CVE-2006-0598": {"epss_score": 0.01412, "epss_percentile": 0.80113}, "CVE-2006-0599": {"epss_score": 0.00647, "epss_percentile": 0.70189}, "CVE-2006-0600": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-0602": {"epss_score": 0.01674, "epss_percentile": 0.81695}, "CVE-2006-0603": {"epss_score": 0.011, "epss_percentile": 0.77569}, "CVE-2006-0604": {"epss_score": 0.01861, "epss_percentile": 0.8259}, "CVE-2006-0605": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-0606": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-0607": {"epss_score": 0.01425, "epss_percentile": 0.80197}, "CVE-2006-0608": {"epss_score": 0.01408, "epss_percentile": 0.80064}, "CVE-2006-0609": {"epss_score": 0.00771, "epss_percentile": 0.73014}, "CVE-2006-0610": {"epss_score": 0.01454, "epss_percentile": 0.80377}, "CVE-2006-0611": {"epss_score": 0.01535, "epss_percentile": 0.80907}, "CVE-2006-0612": {"epss_score": 0.00159, "epss_percentile": 0.37385}, "CVE-2006-0613": {"epss_score": 0.03239, "epss_percentile": 0.86726}, "CVE-2006-0614": {"epss_score": 0.08401, "epss_percentile": 0.92033}, "CVE-2006-0615": {"epss_score": 0.07229, "epss_percentile": 0.91336}, "CVE-2006-0616": {"epss_score": 0.03722, "epss_percentile": 0.87623}, "CVE-2006-0617": {"epss_score": 0.03722, "epss_percentile": 0.87623}, "CVE-2006-0618": {"epss_score": 0.00136, "epss_percentile": 0.3413}, "CVE-2006-0619": {"epss_score": 0.00207, "epss_percentile": 0.43125}, "CVE-2006-0620": {"epss_score": 0.0041, "epss_percentile": 0.60813}, "CVE-2006-0621": {"epss_score": 0.00157, "epss_percentile": 0.37025}, "CVE-2006-0622": {"epss_score": 0.00111, "epss_percentile": 0.30374}, "CVE-2006-0623": {"epss_score": 0.0035, "epss_percentile": 0.56955}, "CVE-2006-0624": {"epss_score": 0.01134, "epss_percentile": 0.77894}, "CVE-2006-0625": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2006-0626": {"epss_score": 0.00928, "epss_percentile": 0.75575}, "CVE-2006-0627": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-0628": {"epss_score": 0.25246, "epss_percentile": 0.96002}, "CVE-2006-0629": {"epss_score": 0.0173, "epss_percentile": 0.81989}, "CVE-2006-0630": {"epss_score": 0.00704, "epss_percentile": 0.71565}, "CVE-2006-0631": {"epss_score": 0.00704, "epss_percentile": 0.71565}, "CVE-2006-0632": {"epss_score": 0.0098, "epss_percentile": 0.76274}, "CVE-2006-0633": {"epss_score": 0.00504, "epss_percentile": 0.65495}, "CVE-2006-0634": {"epss_score": 0.0008, "epss_percentile": 0.24187}, "CVE-2006-0635": {"epss_score": 0.00066, "epss_percentile": 0.20841}, "CVE-2006-0636": {"epss_score": 0.01269, "epss_percentile": 0.79039}, "CVE-2006-0637": {"epss_score": 0.03867, "epss_percentile": 0.87874}, "CVE-2006-0638": {"epss_score": 0.0082, "epss_percentile": 0.73892}, "CVE-2006-0639": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-0640": {"epss_score": 0.00054, "epss_percentile": 0.17054}, "CVE-2006-0641": {"epss_score": 0.00343, "epss_percentile": 0.56452}, "CVE-2006-0642": {"epss_score": 0.00842, "epss_percentile": 0.74235}, "CVE-2006-0643": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-0644": {"epss_score": 0.11977, "epss_percentile": 0.93532}, "CVE-2006-0645": {"epss_score": 0.03721, "epss_percentile": 0.87621}, "CVE-2006-0646": {"epss_score": 0.00075, "epss_percentile": 0.22987}, "CVE-2006-0647": {"epss_score": 0.15812, "epss_percentile": 0.94513}, "CVE-2006-0648": {"epss_score": 0.01539, "epss_percentile": 0.80936}, "CVE-2006-0649": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0650": {"epss_score": 0.01366, "epss_percentile": 0.79779}, "CVE-2006-0651": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2006-0652": {"epss_score": 0.00477, "epss_percentile": 0.64336}, "CVE-2006-0653": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-0654": {"epss_score": 0.0076, "epss_percentile": 0.72809}, "CVE-2006-0655": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2006-0656": {"epss_score": 0.09255, "epss_percentile": 0.92467}, "CVE-2006-0657": {"epss_score": 0.00393, "epss_percentile": 0.59727}, "CVE-2006-0658": {"epss_score": 0.05676, "epss_percentile": 0.90111}, "CVE-2006-0659": {"epss_score": 0.0582, "epss_percentile": 0.90234}, "CVE-2006-0660": {"epss_score": 0.10787, "epss_percentile": 0.93103}, "CVE-2006-0661": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-0662": {"epss_score": 0.00544, "epss_percentile": 0.67129}, "CVE-2006-0663": {"epss_score": 0.0137, "epss_percentile": 0.79799}, "CVE-2006-0664": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0665": {"epss_score": 0.00392, "epss_percentile": 0.59672}, "CVE-2006-0666": {"epss_score": 0.00068, "epss_percentile": 0.21357}, "CVE-2006-0667": {"epss_score": 0.00065, "epss_percentile": 0.20642}, "CVE-2006-0668": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2006-0669": {"epss_score": 0.00635, "epss_percentile": 0.69814}, "CVE-2006-0670": {"epss_score": 0.06051, "epss_percentile": 0.90435}, "CVE-2006-0671": {"epss_score": 0.12892, "epss_percentile": 0.93814}, "CVE-2006-0672": {"epss_score": 0.00311, "epss_percentile": 0.53864}, "CVE-2006-0673": {"epss_score": 0.01998, "epss_percentile": 0.83208}, "CVE-2006-0674": {"epss_score": 0.00065, "epss_percentile": 0.20572}, "CVE-2006-0675": {"epss_score": 0.007, "epss_percentile": 0.7148}, "CVE-2006-0676": {"epss_score": 0.04845, "epss_percentile": 0.89208}, "CVE-2006-0677": {"epss_score": 0.07878, "epss_percentile": 0.91739}, "CVE-2006-0678": {"epss_score": 0.0007, "epss_percentile": 0.21691}, "CVE-2006-0679": {"epss_score": 0.42554, "epss_percentile": 0.97338}, "CVE-2006-0680": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0681": {"epss_score": 0.06274, "epss_percentile": 0.90631}, "CVE-2006-0682": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0683": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-0684": {"epss_score": 0.09138, "epss_percentile": 0.92418}, "CVE-2006-0685": {"epss_score": 0.09071, "epss_percentile": 0.92386}, "CVE-2006-0686": {"epss_score": 0.02388, "epss_percentile": 0.84588}, "CVE-2006-0687": {"epss_score": 0.09088, "epss_percentile": 0.92396}, "CVE-2006-0688": {"epss_score": 0.10298, "epss_percentile": 0.92933}, "CVE-2006-0689": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-0690": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-0691": {"epss_score": 0.09894, "epss_percentile": 0.92757}, "CVE-2006-0692": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-0693": {"epss_score": 0.01011, "epss_percentile": 0.76615}, "CVE-2006-0694": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0695": {"epss_score": 0.02468, "epss_percentile": 0.84841}, "CVE-2006-0696": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-0697": {"epss_score": 0.00933, "epss_percentile": 0.75638}, "CVE-2006-0698": {"epss_score": 0.00497, "epss_percentile": 0.65178}, "CVE-2006-0699": {"epss_score": 0.00565, "epss_percentile": 0.67789}, "CVE-2006-0700": {"epss_score": 0.03699, "epss_percentile": 0.87588}, "CVE-2006-0701": {"epss_score": 0.09152, "epss_percentile": 0.92423}, "CVE-2006-0702": {"epss_score": 0.09152, "epss_percentile": 0.92423}, "CVE-2006-0703": {"epss_score": 0.13756, "epss_percentile": 0.94049}, "CVE-2006-0704": {"epss_score": 0.00387, "epss_percentile": 0.59318}, "CVE-2006-0705": {"epss_score": 0.0537, "epss_percentile": 0.89793}, "CVE-2006-0706": {"epss_score": 0.05248, "epss_percentile": 0.89663}, "CVE-2006-0707": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0708": {"epss_score": 0.16216, "epss_percentile": 0.94596}, "CVE-2006-0709": {"epss_score": 0.07887, "epss_percentile": 0.91744}, "CVE-2006-0710": {"epss_score": 0.06229, "epss_percentile": 0.90587}, "CVE-2006-0711": {"epss_score": 0.00649, "epss_percentile": 0.70225}, "CVE-2006-0712": {"epss_score": 0.00787, "epss_percentile": 0.7332}, "CVE-2006-0713": {"epss_score": 0.11979, "epss_percentile": 0.93533}, "CVE-2006-0714": {"epss_score": 0.10683, "epss_percentile": 0.9307}, "CVE-2006-0715": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-0716": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2006-0717": {"epss_score": 0.12452, "epss_percentile": 0.93676}, "CVE-2006-0718": {"epss_score": 0.02583, "epss_percentile": 0.85159}, "CVE-2006-0719": {"epss_score": 0.01073, "epss_percentile": 0.77294}, "CVE-2006-0720": {"epss_score": 0.13908, "epss_percentile": 0.9409}, "CVE-2006-0721": {"epss_score": 0.01238, "epss_percentile": 0.78794}, "CVE-2006-0722": {"epss_score": 0.00905, "epss_percentile": 0.75246}, "CVE-2006-0723": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2006-0724": {"epss_score": 0.00734, "epss_percentile": 0.72241}, "CVE-2006-0725": {"epss_score": 0.05325, "epss_percentile": 0.89733}, "CVE-2006-0726": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2006-0727": {"epss_score": 0.01462, "epss_percentile": 0.80439}, "CVE-2006-0728": {"epss_score": 0.00689, "epss_percentile": 0.71232}, "CVE-2006-0729": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-0730": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-0731": {"epss_score": 0.06019, "epss_percentile": 0.90415}, "CVE-2006-0732": {"epss_score": 0.03081, "epss_percentile": 0.86373}, "CVE-2006-0733": {"epss_score": 0.00831, "epss_percentile": 0.74054}, "CVE-2006-0734": {"epss_score": 0.0329, "epss_percentile": 0.86835}, "CVE-2006-0735": {"epss_score": 0.12107, "epss_percentile": 0.93568}, "CVE-2006-0736": {"epss_score": 0.18343, "epss_percentile": 0.94999}, "CVE-2006-0737": {"epss_score": 0.04701, "epss_percentile": 0.89025}, "CVE-2006-0738": {"epss_score": 0.04701, "epss_percentile": 0.89025}, "CVE-2006-0739": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-0741": {"epss_score": 0.00091, "epss_percentile": 0.26285}, "CVE-2006-0742": {"epss_score": 0.00058, "epss_percentile": 0.18463}, "CVE-2006-0743": {"epss_score": 0.04579, "epss_percentile": 0.88871}, "CVE-2006-0744": {"epss_score": 0.00106, "epss_percentile": 0.29431}, "CVE-2006-0745": {"epss_score": 0.00177, "epss_percentile": 0.39566}, "CVE-2006-0746": {"epss_score": 0.04379, "epss_percentile": 0.88622}, "CVE-2006-0747": {"epss_score": 0.45933, "epss_percentile": 0.97509}, "CVE-2006-0748": {"epss_score": 0.13046, "epss_percentile": 0.93856}, "CVE-2006-0749": {"epss_score": 0.40332, "epss_percentile": 0.97212}, "CVE-2006-0750": {"epss_score": 0.00878, "epss_percentile": 0.7483}, "CVE-2006-0751": {"epss_score": 0.00406, "epss_percentile": 0.6052}, "CVE-2006-0752": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-0753": {"epss_score": 0.16941, "epss_percentile": 0.9475}, "CVE-2006-0754": {"epss_score": 0.00704, "epss_percentile": 0.71565}, "CVE-2006-0755": {"epss_score": 0.11232, "epss_percentile": 0.93272}, "CVE-2006-0756": {"epss_score": 0.01021, "epss_percentile": 0.76749}, "CVE-2006-0757": {"epss_score": 0.0788, "epss_percentile": 0.91739}, "CVE-2006-0758": {"epss_score": 0.00771, "epss_percentile": 0.73017}, "CVE-2006-0759": {"epss_score": 0.01641, "epss_percentile": 0.81506}, "CVE-2006-0760": {"epss_score": 0.00353, "epss_percentile": 0.57178}, "CVE-2006-0761": {"epss_score": 0.03416, "epss_percentile": 0.87091}, "CVE-2006-0762": {"epss_score": 0.00063, "epss_percentile": 0.20075}, "CVE-2006-0763": {"epss_score": 0.00318, "epss_percentile": 0.54405}, "CVE-2006-0764": {"epss_score": 0.00811, "epss_percentile": 0.73735}, "CVE-2006-0765": {"epss_score": 0.00162, "epss_percentile": 0.3762}, "CVE-2006-0766": {"epss_score": 0.00162, "epss_percentile": 0.3762}, "CVE-2006-0767": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-0768": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2006-0769": {"epss_score": 0.00053, "epss_percentile": 0.17036}, "CVE-2006-0770": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-0771": {"epss_score": 0.03121, "epss_percentile": 0.8645}, "CVE-2006-0772": {"epss_score": 0.0079, "epss_percentile": 0.73375}, "CVE-2006-0773": {"epss_score": 0.00516, "epss_percentile": 0.66052}, "CVE-2006-0774": {"epss_score": 0.01615, "epss_percentile": 0.81352}, "CVE-2006-0775": {"epss_score": 0.01971, "epss_percentile": 0.83097}, "CVE-2006-0776": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2006-0777": {"epss_score": 0.01141, "epss_percentile": 0.77959}, "CVE-2006-0778": {"epss_score": 0.02187, "epss_percentile": 0.83925}, "CVE-2006-0779": {"epss_score": 0.00564, "epss_percentile": 0.67769}, "CVE-2006-0780": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-0781": {"epss_score": 0.00989, "epss_percentile": 0.76372}, "CVE-2006-0782": {"epss_score": 0.05504, "epss_percentile": 0.89941}, "CVE-2006-0783": {"epss_score": 0.05656, "epss_percentile": 0.90091}, "CVE-2006-0784": {"epss_score": 0.06112, "epss_percentile": 0.90488}, "CVE-2006-0785": {"epss_score": 0.00329, "epss_percentile": 0.55408}, "CVE-2006-0786": {"epss_score": 0.03383, "epss_percentile": 0.87034}, "CVE-2006-0787": {"epss_score": 0.03174, "epss_percentile": 0.8656}, "CVE-2006-0788": {"epss_score": 0.00085, "epss_percentile": 0.25074}, "CVE-2006-0789": {"epss_score": 0.00498, "epss_percentile": 0.65213}, "CVE-2006-0790": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-0791": {"epss_score": 0.11448, "epss_percentile": 0.93364}, "CVE-2006-0792": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2006-0793": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-0794": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2006-0795": {"epss_score": 0.01313, "epss_percentile": 0.79381}, "CVE-2006-0796": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0797": {"epss_score": 0.09153, "epss_percentile": 0.92423}, "CVE-2006-0798": {"epss_score": 0.01946, "epss_percentile": 0.83004}, "CVE-2006-0799": {"epss_score": 0.23546, "epss_percentile": 0.9579}, "CVE-2006-0800": {"epss_score": 0.07475, "epss_percentile": 0.91492}, "CVE-2006-0801": {"epss_score": 0.01578, "epss_percentile": 0.81124}, "CVE-2006-0802": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-0803": {"epss_score": 0.00212, "epss_percentile": 0.43795}, "CVE-2006-0804": {"epss_score": 0.01602, "epss_percentile": 0.81273}, "CVE-2006-0805": {"epss_score": 0.01759, "epss_percentile": 0.82143}, "CVE-2006-0806": {"epss_score": 0.12629, "epss_percentile": 0.93734}, "CVE-2006-0807": {"epss_score": 0.01883, "epss_percentile": 0.82701}, "CVE-2006-0808": {"epss_score": 0.00672, "epss_percentile": 0.70828}, "CVE-2006-0809": {"epss_score": 0.01525, "epss_percentile": 0.80856}, "CVE-2006-0810": {"epss_score": 0.0042, "epss_percentile": 0.61453}, "CVE-2006-0811": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-0812": {"epss_score": 0.00064, "epss_percentile": 0.20295}, "CVE-2006-0813": {"epss_score": 0.01527, "epss_percentile": 0.80869}, "CVE-2006-0814": {"epss_score": 0.0075, "epss_percentile": 0.72622}, "CVE-2006-0815": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-0816": {"epss_score": 0.0126, "epss_percentile": 0.7897}, "CVE-2006-0817": {"epss_score": 0.02211, "epss_percentile": 0.84015}, "CVE-2006-0818": {"epss_score": 0.01003, "epss_percentile": 0.76513}, "CVE-2006-0819": {"epss_score": 0.01118, "epss_percentile": 0.77744}, "CVE-2006-0820": {"epss_score": 0.00605, "epss_percentile": 0.6898}, "CVE-2006-0821": {"epss_score": 0.0131, "epss_percentile": 0.79361}, "CVE-2006-0822": {"epss_score": 0.01753, "epss_percentile": 0.82112}, "CVE-2006-0823": {"epss_score": 0.01258, "epss_percentile": 0.7896}, "CVE-2006-0824": {"epss_score": 0.03286, "epss_percentile": 0.86828}, "CVE-2006-0825": {"epss_score": 0.01078, "epss_percentile": 0.77353}, "CVE-2006-0826": {"epss_score": 0.01469, "epss_percentile": 0.80484}, "CVE-2006-0827": {"epss_score": 0.00463, "epss_percentile": 0.63682}, "CVE-2006-0828": {"epss_score": 0.00458, "epss_percentile": 0.63397}, "CVE-2006-0829": {"epss_score": 0.00903, "epss_percentile": 0.75205}, "CVE-2006-0830": {"epss_score": 0.32858, "epss_percentile": 0.96731}, "CVE-2006-0831": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-0832": {"epss_score": 0.00549, "epss_percentile": 0.67306}, "CVE-2006-0833": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0834": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2006-0835": {"epss_score": 0.00576, "epss_percentile": 0.68148}, "CVE-2006-0836": {"epss_score": 0.04489, "epss_percentile": 0.88755}, "CVE-2006-0837": {"epss_score": 0.00056, "epss_percentile": 0.17794}, "CVE-2006-0838": {"epss_score": 0.00074, "epss_percentile": 0.22779}, "CVE-2006-0839": {"epss_score": 0.00392, "epss_percentile": 0.59666}, "CVE-2006-0840": {"epss_score": 0.01666, "epss_percentile": 0.81651}, "CVE-2006-0841": {"epss_score": 0.10749, "epss_percentile": 0.93092}, "CVE-2006-0842": {"epss_score": 0.0038, "epss_percentile": 0.58954}, "CVE-2006-0843": {"epss_score": 0.00547, "epss_percentile": 0.67228}, "CVE-2006-0844": {"epss_score": 0.0047, "epss_percentile": 0.63976}, "CVE-2006-0845": {"epss_score": 0.01196, "epss_percentile": 0.7844}, "CVE-2006-0846": {"epss_score": 0.00463, "epss_percentile": 0.63682}, "CVE-2006-0847": {"epss_score": 0.00639, "epss_percentile": 0.69932}, "CVE-2006-0848": {"epss_score": 0.83055, "epss_percentile": 0.99229}, "CVE-2006-0850": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-0851": {"epss_score": 0.02016, "epss_percentile": 0.83277}, "CVE-2006-0852": {"epss_score": 0.08859, "epss_percentile": 0.92288}, "CVE-2006-0853": {"epss_score": 0.03101, "epss_percentile": 0.8641}, "CVE-2006-0854": {"epss_score": 0.01921, "epss_percentile": 0.82899}, "CVE-2006-0855": {"epss_score": 0.02219, "epss_percentile": 0.84043}, "CVE-2006-0856": {"epss_score": 0.01612, "epss_percentile": 0.81335}, "CVE-2006-0857": {"epss_score": 0.00387, "epss_percentile": 0.59327}, "CVE-2006-0858": {"epss_score": 0.00061, "epss_percentile": 0.19279}, "CVE-2006-0859": {"epss_score": 0.00647, "epss_percentile": 0.70189}, "CVE-2006-0860": {"epss_score": 0.0105, "epss_percentile": 0.77071}, "CVE-2006-0861": {"epss_score": 0.00647, "epss_percentile": 0.70189}, "CVE-2006-0862": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-0863": {"epss_score": 0.00631, "epss_percentile": 0.69715}, "CVE-2006-0864": {"epss_score": 0.03171, "epss_percentile": 0.86548}, "CVE-2006-0865": {"epss_score": 0.03838, "epss_percentile": 0.87826}, "CVE-2006-0866": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-0867": {"epss_score": 0.0063, "epss_percentile": 0.69692}, "CVE-2006-0868": {"epss_score": 0.02312, "epss_percentile": 0.84342}, "CVE-2006-0869": {"epss_score": 0.14177, "epss_percentile": 0.94154}, "CVE-2006-0870": {"epss_score": 0.01976, "epss_percentile": 0.83123}, "CVE-2006-0871": {"epss_score": 0.01154, "epss_percentile": 0.78063}, "CVE-2006-0872": {"epss_score": 0.02538, "epss_percentile": 0.85043}, "CVE-2006-0873": {"epss_score": 0.00806, "epss_percentile": 0.73662}, "CVE-2006-0874": {"epss_score": 0.00432, "epss_percentile": 0.62114}, "CVE-2006-0875": {"epss_score": 0.05605, "epss_percentile": 0.90041}, "CVE-2006-0876": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-0877": {"epss_score": 0.12698, "epss_percentile": 0.93753}, "CVE-2006-0878": {"epss_score": 0.0057, "epss_percentile": 0.67965}, "CVE-2006-0879": {"epss_score": 0.00553, "epss_percentile": 0.6742}, "CVE-2006-0880": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2006-0881": {"epss_score": 0.07081, "epss_percentile": 0.91239}, "CVE-2006-0882": {"epss_score": 0.05018, "epss_percentile": 0.89399}, "CVE-2006-0883": {"epss_score": 0.01974, "epss_percentile": 0.83113}, "CVE-2006-0884": {"epss_score": 0.35997, "epss_percentile": 0.96946}, "CVE-2006-0885": {"epss_score": 0.007, "epss_percentile": 0.7148}, "CVE-2006-0886": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0887": {"epss_score": 0.09221, "epss_percentile": 0.92456}, "CVE-2006-0888": {"epss_score": 0.07329, "epss_percentile": 0.91413}, "CVE-2006-0889": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0890": {"epss_score": 0.00475, "epss_percentile": 0.64177}, "CVE-2006-0891": {"epss_score": 0.0868, "epss_percentile": 0.92196}, "CVE-2006-0892": {"epss_score": 0.02481, "epss_percentile": 0.84873}, "CVE-2006-0893": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-0894": {"epss_score": 0.00964, "epss_percentile": 0.76028}, "CVE-2006-0895": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-0896": {"epss_score": 0.01316, "epss_percentile": 0.79407}, "CVE-2006-0897": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2006-0898": {"epss_score": 0.01439, "epss_percentile": 0.80294}, "CVE-2006-0899": {"epss_score": 0.18551, "epss_percentile": 0.95032}, "CVE-2006-0900": {"epss_score": 0.79325, "epss_percentile": 0.99032}, "CVE-2006-0901": {"epss_score": 0.00094, "epss_percentile": 0.27027}, "CVE-2006-0903": {"epss_score": 0.00318, "epss_percentile": 0.5445}, "CVE-2006-0905": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-0906": {"epss_score": 0.00814, "epss_percentile": 0.73773}, "CVE-2006-0907": {"epss_score": 0.00016, "epss_percentile": 0.02857}, "CVE-2006-0908": {"epss_score": 0.00018, "epss_percentile": 0.03848}, "CVE-2006-0909": {"epss_score": 0.00751, "epss_percentile": 0.72635}, "CVE-2006-0910": {"epss_score": 0.00628, "epss_percentile": 0.69657}, "CVE-2006-0911": {"epss_score": 0.05306, "epss_percentile": 0.89712}, "CVE-2006-0912": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-0913": {"epss_score": 0.0082, "epss_percentile": 0.73892}, "CVE-2006-0914": {"epss_score": 0.00757, "epss_percentile": 0.7275}, "CVE-2006-0915": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-0916": {"epss_score": 0.00743, "epss_percentile": 0.72481}, "CVE-2006-0917": {"epss_score": 0.00078, "epss_percentile": 0.23623}, "CVE-2006-0918": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2006-0919": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2006-0920": {"epss_score": 0.00172, "epss_percentile": 0.38941}, "CVE-2006-0921": {"epss_score": 0.00283, "epss_percentile": 0.51376}, "CVE-2006-0922": {"epss_score": 0.10821, "epss_percentile": 0.93122}, "CVE-2006-0923": {"epss_score": 0.05221, "epss_percentile": 0.89627}, "CVE-2006-0924": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-0925": {"epss_score": 0.04701, "epss_percentile": 0.89025}, "CVE-2006-0926": {"epss_score": 0.01104, "epss_percentile": 0.776}, "CVE-2006-0927": {"epss_score": 0.05784, "epss_percentile": 0.90205}, "CVE-2006-0928": {"epss_score": 0.00588, "epss_percentile": 0.68494}, "CVE-2006-0929": {"epss_score": 0.00718, "epss_percentile": 0.71924}, "CVE-2006-0930": {"epss_score": 0.00627, "epss_percentile": 0.6963}, "CVE-2006-0931": {"epss_score": 0.01438, "epss_percentile": 0.80289}, "CVE-2006-0932": {"epss_score": 0.01272, "epss_percentile": 0.79084}, "CVE-2006-0933": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-0934": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-0935": {"epss_score": 0.1028, "epss_percentile": 0.92924}, "CVE-2006-0936": {"epss_score": 0.02718, "epss_percentile": 0.85512}, "CVE-2006-0937": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-0938": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-0939": {"epss_score": 0.00617, "epss_percentile": 0.69357}, "CVE-2006-0940": {"epss_score": 0.12698, "epss_percentile": 0.93753}, "CVE-2006-0941": {"epss_score": 0.00605, "epss_percentile": 0.6898}, "CVE-2006-0942": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2006-0943": {"epss_score": 0.01076, "epss_percentile": 0.77328}, "CVE-2006-0944": {"epss_score": 0.06247, "epss_percentile": 0.90604}, "CVE-2006-0945": {"epss_score": 0.00968, "epss_percentile": 0.76085}, "CVE-2006-0946": {"epss_score": 0.00758, "epss_percentile": 0.72782}, "CVE-2006-0947": {"epss_score": 0.04002, "epss_percentile": 0.88094}, "CVE-2006-0948": {"epss_score": 0.00034, "epss_percentile": 0.09615}, "CVE-2006-0949": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2006-0950": {"epss_score": 0.00704, "epss_percentile": 0.71565}, "CVE-2006-0951": {"epss_score": 0.00051, "epss_percentile": 0.16234}, "CVE-2006-0956": {"epss_score": 0.00241, "epss_percentile": 0.47241}, "CVE-2006-0957": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-0958": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-0959": {"epss_score": 0.04582, "epss_percentile": 0.88878}, "CVE-2006-0960": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-0961": {"epss_score": 0.02546, "epss_percentile": 0.85063}, "CVE-2006-0962": {"epss_score": 0.00832, "epss_percentile": 0.74073}, "CVE-2006-0963": {"epss_score": 0.0015, "epss_percentile": 0.36173}, "CVE-2006-0964": {"epss_score": 0.00071, "epss_percentile": 0.22161}, "CVE-2006-0965": {"epss_score": 0.00078, "epss_percentile": 0.23598}, "CVE-2006-0966": {"epss_score": 0.00072, "epss_percentile": 0.22434}, "CVE-2006-0967": {"epss_score": 0.00072, "epss_percentile": 0.22434}, "CVE-2006-0968": {"epss_score": 0.0006, "epss_percentile": 0.1917}, "CVE-2006-0969": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-0970": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-0971": {"epss_score": 0.10804, "epss_percentile": 0.93108}, "CVE-2006-0972": {"epss_score": 0.0057, "epss_percentile": 0.67954}, "CVE-2006-0973": {"epss_score": 0.01501, "epss_percentile": 0.80717}, "CVE-2006-0974": {"epss_score": 0.00913, "epss_percentile": 0.75366}, "CVE-2006-0976": {"epss_score": 0.03486, "epss_percentile": 0.87227}, "CVE-2006-0977": {"epss_score": 0.0042, "epss_percentile": 0.6145}, "CVE-2006-0978": {"epss_score": 0.00648, "epss_percentile": 0.70222}, "CVE-2006-0979": {"epss_score": 0.00475, "epss_percentile": 0.64175}, "CVE-2006-0980": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-0981": {"epss_score": 0.03733, "epss_percentile": 0.87648}, "CVE-2006-0982": {"epss_score": 0.00219, "epss_percentile": 0.44501}, "CVE-2006-0983": {"epss_score": 0.06539, "epss_percentile": 0.90833}, "CVE-2006-0984": {"epss_score": 0.07101, "epss_percentile": 0.91252}, "CVE-2006-0985": {"epss_score": 0.00891, "epss_percentile": 0.75053}, "CVE-2006-0986": {"epss_score": 0.02177, "epss_percentile": 0.83888}, "CVE-2006-0987": {"epss_score": 0.36895, "epss_percentile": 0.97008}, "CVE-2006-0988": {"epss_score": 0.7179, "epss_percentile": 0.98681}, "CVE-2006-0989": {"epss_score": 0.15325, "epss_percentile": 0.9441}, "CVE-2006-0990": {"epss_score": 0.15325, "epss_percentile": 0.9441}, "CVE-2006-0991": {"epss_score": 0.29071, "epss_percentile": 0.96415}, "CVE-2006-0992": {"epss_score": 0.88808, "epss_percentile": 0.99492}, "CVE-2006-0993": {"epss_score": 0.0106, "epss_percentile": 0.77168}, "CVE-2006-0994": {"epss_score": 0.42705, "epss_percentile": 0.97347}, "CVE-2006-0995": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-0996": {"epss_score": 0.18154, "epss_percentile": 0.94967}, "CVE-2006-0997": {"epss_score": 0.00265, "epss_percentile": 0.49784}, "CVE-2006-0998": {"epss_score": 0.00557, "epss_percentile": 0.67546}, "CVE-2006-0999": {"epss_score": 0.00455, "epss_percentile": 0.63281}, "CVE-2006-10001": {"epss_score": 0.00182, "epss_percentile": 0.40239}, "CVE-2006-1000": {"epss_score": 0.02002, "epss_percentile": 0.83224}, "CVE-2006-1001": {"epss_score": 0.02042, "epss_percentile": 0.83373}, "CVE-2006-1002": {"epss_score": 0.01901, "epss_percentile": 0.82779}, "CVE-2006-1003": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-1004": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1005": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-1006": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-1007": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2006-1008": {"epss_score": 0.02096, "epss_percentile": 0.83587}, "CVE-2006-1009": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2006-1010": {"epss_score": 0.28411, "epss_percentile": 0.96354}, "CVE-2006-1011": {"epss_score": 0.00048, "epss_percentile": 0.15233}, "CVE-2006-1012": {"epss_score": 0.01865, "epss_percentile": 0.82604}, "CVE-2006-1013": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2006-1014": {"epss_score": 0.02326, "epss_percentile": 0.84391}, "CVE-2006-1015": {"epss_score": 0.08488, "epss_percentile": 0.9208}, "CVE-2006-1016": {"epss_score": 0.76517, "epss_percentile": 0.98894}, "CVE-2006-1017": {"epss_score": 0.02744, "epss_percentile": 0.85567}, "CVE-2006-1018": {"epss_score": 0.00367, "epss_percentile": 0.58157}, "CVE-2006-1019": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-1020": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2006-1021": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2006-1022": {"epss_score": 0.13759, "epss_percentile": 0.94052}, "CVE-2006-1023": {"epss_score": 0.04981, "epss_percentile": 0.89361}, "CVE-2006-1024": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-1025": {"epss_score": 0.01535, "epss_percentile": 0.80912}, "CVE-2006-1026": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-1027": {"epss_score": 0.00014, "epss_percentile": 0.01887}, "CVE-2006-1028": {"epss_score": 0.00026, "epss_percentile": 0.06486}, "CVE-2006-1029": {"epss_score": 0.0008, "epss_percentile": 0.24032}, "CVE-2006-1030": {"epss_score": 0.00011, "epss_percentile": 0.01063}, "CVE-2006-1031": {"epss_score": 0.05311, "epss_percentile": 0.89717}, "CVE-2006-1032": {"epss_score": 0.16267, "epss_percentile": 0.94606}, "CVE-2006-1033": {"epss_score": 0.00827, "epss_percentile": 0.73981}, "CVE-2006-1034": {"epss_score": 0.00268, "epss_percentile": 0.50062}, "CVE-2006-1035": {"epss_score": 0.01714, "epss_percentile": 0.81892}, "CVE-2006-1036": {"epss_score": 0.0039, "epss_percentile": 0.5952}, "CVE-2006-1037": {"epss_score": 0.00425, "epss_percentile": 0.61707}, "CVE-2006-1038": {"epss_score": 0.03331, "epss_percentile": 0.86927}, "CVE-2006-1039": {"epss_score": 0.05852, "epss_percentile": 0.90263}, "CVE-2006-1040": {"epss_score": 0.00949, "epss_percentile": 0.75844}, "CVE-2006-1041": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1042": {"epss_score": 0.00587, "epss_percentile": 0.68484}, "CVE-2006-1043": {"epss_score": 0.65612, "epss_percentile": 0.98429}, "CVE-2006-1044": {"epss_score": 0.2513, "epss_percentile": 0.95988}, "CVE-2006-1045": {"epss_score": 0.10396, "epss_percentile": 0.92974}, "CVE-2006-1046": {"epss_score": 0.12176, "epss_percentile": 0.93591}, "CVE-2006-1047": {"epss_score": 0.00064, "epss_percentile": 0.20405}, "CVE-2006-1048": {"epss_score": 0.00011, "epss_percentile": 0.01099}, "CVE-2006-1049": {"epss_score": 0.00014, "epss_percentile": 0.01873}, "CVE-2006-1050": {"epss_score": 0.00069, "epss_percentile": 0.21563}, "CVE-2006-1051": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-1052": {"epss_score": 0.00049, "epss_percentile": 0.15369}, "CVE-2006-1055": {"epss_score": 0.00064, "epss_percentile": 0.20136}, "CVE-2006-1056": {"epss_score": 0.00073, "epss_percentile": 0.22555}, "CVE-2006-1057": {"epss_score": 0.00058, "epss_percentile": 0.18297}, "CVE-2006-1058": {"epss_score": 0.00045, "epss_percentile": 0.13957}, "CVE-2006-1059": {"epss_score": 0.00456, "epss_percentile": 0.63352}, "CVE-2006-1060": {"epss_score": 0.02335, "epss_percentile": 0.84414}, "CVE-2006-1061": {"epss_score": 0.03827, "epss_percentile": 0.87794}, "CVE-2006-1062": {"epss_score": 0.00946, "epss_percentile": 0.75807}, "CVE-2006-1063": {"epss_score": 0.00986, "epss_percentile": 0.76332}, "CVE-2006-1064": {"epss_score": 0.00872, "epss_percentile": 0.74733}, "CVE-2006-1065": {"epss_score": 0.00373, "epss_percentile": 0.5847}, "CVE-2006-1066": {"epss_score": 0.0006, "epss_percentile": 0.19163}, "CVE-2006-1067": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-1068": {"epss_score": 0.00476, "epss_percentile": 0.64276}, "CVE-2006-1069": {"epss_score": 0.00381, "epss_percentile": 0.5902}, "CVE-2006-1070": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2006-1071": {"epss_score": 0.02971, "epss_percentile": 0.86094}, "CVE-2006-1072": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-1073": {"epss_score": 0.09894, "epss_percentile": 0.92757}, "CVE-2006-1074": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-1075": {"epss_score": 0.04188, "epss_percentile": 0.88369}, "CVE-2006-1076": {"epss_score": 0.00373, "epss_percentile": 0.58494}, "CVE-2006-1077": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1078": {"epss_score": 0.00228, "epss_percentile": 0.45521}, "CVE-2006-1079": {"epss_score": 0.00185, "epss_percentile": 0.4053}, "CVE-2006-1080": {"epss_score": 0.00809, "epss_percentile": 0.7371}, "CVE-2006-1081": {"epss_score": 0.01495, "epss_percentile": 0.80659}, "CVE-2006-1082": {"epss_score": 0.00613, "epss_percentile": 0.69262}, "CVE-2006-1083": {"epss_score": 0.02054, "epss_percentile": 0.8342}, "CVE-2006-1084": {"epss_score": 0.01139, "epss_percentile": 0.77945}, "CVE-2006-1085": {"epss_score": 0.03343, "epss_percentile": 0.86946}, "CVE-2006-1087": {"epss_score": 0.0154, "epss_percentile": 0.80944}, "CVE-2006-1088": {"epss_score": 0.00745, "epss_percentile": 0.72517}, "CVE-2006-1089": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1090": {"epss_score": 0.0515, "epss_percentile": 0.89549}, "CVE-2006-1091": {"epss_score": 0.0094, "epss_percentile": 0.75739}, "CVE-2006-1092": {"epss_score": 0.00067, "epss_percentile": 0.21117}, "CVE-2006-1093": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2006-1094": {"epss_score": 0.00712, "epss_percentile": 0.71752}, "CVE-2006-1095": {"epss_score": 0.00015, "epss_percentile": 0.02511}, "CVE-2006-1096": {"epss_score": 0.00491, "epss_percentile": 0.64959}, "CVE-2006-1097": {"epss_score": 0.00731, "epss_percentile": 0.72177}, "CVE-2006-1098": {"epss_score": 0.01493, "epss_percentile": 0.80644}, "CVE-2006-1099": {"epss_score": 0.02711, "epss_percentile": 0.85497}, "CVE-2006-1100": {"epss_score": 0.26279, "epss_percentile": 0.96134}, "CVE-2006-1101": {"epss_score": 0.43683, "epss_percentile": 0.97398}, "CVE-2006-1102": {"epss_score": 0.21168, "epss_percentile": 0.95471}, "CVE-2006-1103": {"epss_score": 0.06008, "epss_percentile": 0.904}, "CVE-2006-1104": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2006-1105": {"epss_score": 0.00762, "epss_percentile": 0.72847}, "CVE-2006-1106": {"epss_score": 0.008, "epss_percentile": 0.7356}, "CVE-2006-1107": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-1108": {"epss_score": 0.01546, "epss_percentile": 0.80966}, "CVE-2006-1109": {"epss_score": 0.02018, "epss_percentile": 0.83285}, "CVE-2006-1110": {"epss_score": 0.08306, "epss_percentile": 0.91981}, "CVE-2006-1111": {"epss_score": 0.00653, "epss_percentile": 0.70333}, "CVE-2006-1112": {"epss_score": 0.05283, "epss_percentile": 0.8969}, "CVE-2006-1113": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2006-1114": {"epss_score": 0.07158, "epss_percentile": 0.91291}, "CVE-2006-1115": {"epss_score": 0.0054, "epss_percentile": 0.67001}, "CVE-2006-1116": {"epss_score": 0.00815, "epss_percentile": 0.73794}, "CVE-2006-1117": {"epss_score": 0.00412, "epss_percentile": 0.60918}, "CVE-2006-1118": {"epss_score": 0.00326, "epss_percentile": 0.55045}, "CVE-2006-1119": {"epss_score": 0.00192, "epss_percentile": 0.41321}, "CVE-2006-1120": {"epss_score": 0.01554, "epss_percentile": 0.81002}, "CVE-2006-1121": {"epss_score": 0.07035, "epss_percentile": 0.91204}, "CVE-2006-1122": {"epss_score": 0.02076, "epss_percentile": 0.83511}, "CVE-2006-1123": {"epss_score": 0.02298, "epss_percentile": 0.84302}, "CVE-2006-1124": {"epss_score": 0.2454, "epss_percentile": 0.95931}, "CVE-2006-1125": {"epss_score": 0.00058, "epss_percentile": 0.18412}, "CVE-2006-1126": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2006-1127": {"epss_score": 0.04933, "epss_percentile": 0.89299}, "CVE-2006-1128": {"epss_score": 0.09702, "epss_percentile": 0.92669}, "CVE-2006-1129": {"epss_score": 0.03765, "epss_percentile": 0.87694}, "CVE-2006-1130": {"epss_score": 0.01156, "epss_percentile": 0.78083}, "CVE-2006-1131": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2006-1132": {"epss_score": 0.00345, "epss_percentile": 0.566}, "CVE-2006-1133": {"epss_score": 0.06361, "epss_percentile": 0.90699}, "CVE-2006-1134": {"epss_score": 0.01314, "epss_percentile": 0.79395}, "CVE-2006-1135": {"epss_score": 0.00814, "epss_percentile": 0.73768}, "CVE-2006-1136": {"epss_score": 0.01752, "epss_percentile": 0.82106}, "CVE-2006-1137": {"epss_score": 0.0349, "epss_percentile": 0.8723}, "CVE-2006-1138": {"epss_score": 0.02443, "epss_percentile": 0.8476}, "CVE-2006-1139": {"epss_score": 0.00809, "epss_percentile": 0.73708}, "CVE-2006-1140": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2006-1141": {"epss_score": 0.04874, "epss_percentile": 0.89237}, "CVE-2006-1142": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1143": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2006-1144": {"epss_score": 0.03305, "epss_percentile": 0.86873}, "CVE-2006-1145": {"epss_score": 0.16243, "epss_percentile": 0.946}, "CVE-2006-1146": {"epss_score": 0.17578, "epss_percentile": 0.9487}, "CVE-2006-1147": {"epss_score": 0.106, "epss_percentile": 0.93042}, "CVE-2006-1148": {"epss_score": 0.82635, "epss_percentile": 0.99203}, "CVE-2006-1149": {"epss_score": 0.16012, "epss_percentile": 0.94555}, "CVE-2006-1150": {"epss_score": 0.01198, "epss_percentile": 0.78449}, "CVE-2006-1151": {"epss_score": 0.05931, "epss_percentile": 0.90337}, "CVE-2006-1152": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-1153": {"epss_score": 0.00829, "epss_percentile": 0.74008}, "CVE-2006-1154": {"epss_score": 0.03628, "epss_percentile": 0.87467}, "CVE-2006-1155": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1156": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2006-1157": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2006-1158": {"epss_score": 0.01723, "epss_percentile": 0.81945}, "CVE-2006-1159": {"epss_score": 0.08758, "epss_percentile": 0.92243}, "CVE-2006-1160": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1161": {"epss_score": 0.03824, "epss_percentile": 0.8779}, "CVE-2006-1162": {"epss_score": 0.05605, "epss_percentile": 0.90042}, "CVE-2006-1163": {"epss_score": 0.01391, "epss_percentile": 0.79953}, "CVE-2006-1164": {"epss_score": 0.03062, "epss_percentile": 0.86316}, "CVE-2006-1165": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1166": {"epss_score": 0.00086, "epss_percentile": 0.25389}, "CVE-2006-1167": {"epss_score": 0.0007, "epss_percentile": 0.21778}, "CVE-2006-1168": {"epss_score": 0.09814, "epss_percentile": 0.92713}, "CVE-2006-1172": {"epss_score": 0.20835, "epss_percentile": 0.95421}, "CVE-2006-1173": {"epss_score": 0.21456, "epss_percentile": 0.9552}, "CVE-2006-1174": {"epss_score": 0.00096, "epss_percentile": 0.27448}, "CVE-2006-1175": {"epss_score": 0.00773, "epss_percentile": 0.73054}, "CVE-2006-1176": {"epss_score": 0.06487, "epss_percentile": 0.90791}, "CVE-2006-1178": {"epss_score": 0.01506, "epss_percentile": 0.80749}, "CVE-2006-1182": {"epss_score": 0.00181, "epss_percentile": 0.40069}, "CVE-2006-1183": {"epss_score": 0.00097, "epss_percentile": 0.27583}, "CVE-2006-1184": {"epss_score": 0.37727, "epss_percentile": 0.97065}, "CVE-2006-1185": {"epss_score": 0.63986, "epss_percentile": 0.98358}, "CVE-2006-1186": {"epss_score": 0.7482, "epss_percentile": 0.98818}, "CVE-2006-1188": {"epss_score": 0.63986, "epss_percentile": 0.98358}, "CVE-2006-1189": {"epss_score": 0.54023, "epss_percentile": 0.97907}, "CVE-2006-1190": {"epss_score": 0.78378, "epss_percentile": 0.98984}, "CVE-2006-1191": {"epss_score": 0.50278, "epss_percentile": 0.9773}, "CVE-2006-1192": {"epss_score": 0.30142, "epss_percentile": 0.96514}, "CVE-2006-1193": {"epss_score": 0.58917, "epss_percentile": 0.9814}, "CVE-2006-1194": {"epss_score": 0.155, "epss_percentile": 0.9444}, "CVE-2006-1195": {"epss_score": 0.02981, "epss_percentile": 0.86123}, "CVE-2006-1196": {"epss_score": 0.01028, "epss_percentile": 0.76823}, "CVE-2006-1197": {"epss_score": 0.00039, "epss_percentile": 0.11729}, "CVE-2006-1198": {"epss_score": 0.0006, "epss_percentile": 0.18969}, "CVE-2006-1199": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2006-1200": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2006-1201": {"epss_score": 0.01573, "epss_percentile": 0.81102}, "CVE-2006-1202": {"epss_score": 0.00864, "epss_percentile": 0.7461}, "CVE-2006-1203": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-1204": {"epss_score": 0.00984, "epss_percentile": 0.76317}, "CVE-2006-1205": {"epss_score": 0.01354, "epss_percentile": 0.79698}, "CVE-2006-1206": {"epss_score": 0.12227, "epss_percentile": 0.93607}, "CVE-2006-1207": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-1208": {"epss_score": 0.01618, "epss_percentile": 0.81369}, "CVE-2006-1209": {"epss_score": 0.08486, "epss_percentile": 0.92078}, "CVE-2006-1210": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2006-1211": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-2006-1212": {"epss_score": 0.05621, "epss_percentile": 0.9006}, "CVE-2006-1213": {"epss_score": 0.04325, "epss_percentile": 0.88553}, "CVE-2006-1214": {"epss_score": 0.06311, "epss_percentile": 0.90663}, "CVE-2006-1215": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-1216": {"epss_score": 0.08247, "epss_percentile": 0.91948}, "CVE-2006-1217": {"epss_score": 0.01347, "epss_percentile": 0.79649}, "CVE-2006-1218": {"epss_score": 0.01875, "epss_percentile": 0.82656}, "CVE-2006-1219": {"epss_score": 0.10277, "epss_percentile": 0.92923}, "CVE-2006-1220": {"epss_score": 0.00085, "epss_percentile": 0.25225}, "CVE-2006-1221": {"epss_score": 0.00085, "epss_percentile": 0.25061}, "CVE-2006-1222": {"epss_score": 0.00979, "epss_percentile": 0.76261}, "CVE-2006-1223": {"epss_score": 0.10347, "epss_percentile": 0.92952}, "CVE-2006-1224": {"epss_score": 0.10466, "epss_percentile": 0.92996}, "CVE-2006-1225": {"epss_score": 0.01075, "epss_percentile": 0.77304}, "CVE-2006-1226": {"epss_score": 0.00951, "epss_percentile": 0.75866}, "CVE-2006-1227": {"epss_score": 0.00865, "epss_percentile": 0.74621}, "CVE-2006-1228": {"epss_score": 0.02167, "epss_percentile": 0.83854}, "CVE-2006-1229": {"epss_score": 0.01035, "epss_percentile": 0.76895}, "CVE-2006-1230": {"epss_score": 0.00842, "epss_percentile": 0.74231}, "CVE-2006-1231": {"epss_score": 0.0007, "epss_percentile": 0.2183}, "CVE-2006-1232": {"epss_score": 0.03642, "epss_percentile": 0.87492}, "CVE-2006-1233": {"epss_score": 0.01053, "epss_percentile": 0.77097}, "CVE-2006-1234": {"epss_score": 0.02782, "epss_percentile": 0.85653}, "CVE-2006-1235": {"epss_score": 0.00816, "epss_percentile": 0.738}, "CVE-2006-1236": {"epss_score": 0.11517, "epss_percentile": 0.93391}, "CVE-2006-1237": {"epss_score": 0.01343, "epss_percentile": 0.79604}, "CVE-2006-1238": {"epss_score": 0.02224, "epss_percentile": 0.84066}, "CVE-2006-1239": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1240": {"epss_score": 0.00329, "epss_percentile": 0.55408}, "CVE-2006-1241": {"epss_score": 0.00052, "epss_percentile": 0.16633}, "CVE-2006-1242": {"epss_score": 0.0304, "epss_percentile": 0.86272}, "CVE-2006-1243": {"epss_score": 0.16306, "epss_percentile": 0.94615}, "CVE-2006-1244": {"epss_score": 0.03472, "epss_percentile": 0.872}, "CVE-2006-1245": {"epss_score": 0.69669, "epss_percentile": 0.98598}, "CVE-2006-1246": {"epss_score": 0.00063, "epss_percentile": 0.20069}, "CVE-2006-1247": {"epss_score": 0.00034, "epss_percentile": 0.09452}, "CVE-2006-1248": {"epss_score": 0.00088, "epss_percentile": 0.2564}, "CVE-2006-1249": {"epss_score": 0.27209, "epss_percentile": 0.9622}, "CVE-2006-1250": {"epss_score": 0.00381, "epss_percentile": 0.5902}, "CVE-2006-1251": {"epss_score": 0.00687, "epss_percentile": 0.71179}, "CVE-2006-1252": {"epss_score": 0.05789, "epss_percentile": 0.90212}, "CVE-2006-1253": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-2006-1254": {"epss_score": 0.02561, "epss_percentile": 0.85104}, "CVE-2006-1255": {"epss_score": 0.86521, "epss_percentile": 0.99386}, "CVE-2006-1256": {"epss_score": 0.0103, "epss_percentile": 0.76841}, "CVE-2006-1257": {"epss_score": 0.42308, "epss_percentile": 0.97325}, "CVE-2006-1258": {"epss_score": 0.08432, "epss_percentile": 0.92049}, "CVE-2006-1259": {"epss_score": 0.00948, "epss_percentile": 0.75833}, "CVE-2006-1260": {"epss_score": 0.25719, "epss_percentile": 0.96059}, "CVE-2006-1261": {"epss_score": 0.00605, "epss_percentile": 0.6898}, "CVE-2006-1262": {"epss_score": 0.00887, "epss_percentile": 0.74965}, "CVE-2006-1263": {"epss_score": 0.00343, "epss_percentile": 0.56468}, "CVE-2006-1264": {"epss_score": 0.00521, "epss_percentile": 0.66245}, "CVE-2006-1265": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2006-1266": {"epss_score": 0.00521, "epss_percentile": 0.66245}, "CVE-2006-1267": {"epss_score": 0.00849, "epss_percentile": 0.74372}, "CVE-2006-1268": {"epss_score": 0.02228, "epss_percentile": 0.84079}, "CVE-2006-1269": {"epss_score": 0.00253, "epss_percentile": 0.48452}, "CVE-2006-1270": {"epss_score": 0.00301, "epss_percentile": 0.53}, "CVE-2006-1271": {"epss_score": 0.006, "epss_percentile": 0.68815}, "CVE-2006-1272": {"epss_score": 0.00976, "epss_percentile": 0.76214}, "CVE-2006-1273": {"epss_score": 0.01153, "epss_percentile": 0.78056}, "CVE-2006-1274": {"epss_score": 0.00064, "epss_percentile": 0.20295}, "CVE-2006-1275": {"epss_score": 0.11672, "epss_percentile": 0.93442}, "CVE-2006-1276": {"epss_score": 0.0459, "epss_percentile": 0.88891}, "CVE-2006-1277": {"epss_score": 0.00757, "epss_percentile": 0.72751}, "CVE-2006-1278": {"epss_score": 0.02625, "epss_percentile": 0.85263}, "CVE-2006-1279": {"epss_score": 0.00476, "epss_percentile": 0.64273}, "CVE-2006-1280": {"epss_score": 0.00518, "epss_percentile": 0.6614}, "CVE-2006-1281": {"epss_score": 0.00885, "epss_percentile": 0.74932}, "CVE-2006-1282": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-1283": {"epss_score": 0.00053, "epss_percentile": 0.17036}, "CVE-2006-1284": {"epss_score": 0.00244, "epss_percentile": 0.47576}, "CVE-2006-1285": {"epss_score": 0.00162, "epss_percentile": 0.37691}, "CVE-2006-1286": {"epss_score": 0.00235, "epss_percentile": 0.46229}, "CVE-2006-1287": {"epss_score": 0.00423, "epss_percentile": 0.61586}, "CVE-2006-1288": {"epss_score": 0.00886, "epss_percentile": 0.7495}, "CVE-2006-1289": {"epss_score": 0.02936, "epss_percentile": 0.86025}, "CVE-2006-1290": {"epss_score": 0.01156, "epss_percentile": 0.78083}, "CVE-2006-1291": {"epss_score": 0.05232, "epss_percentile": 0.89643}, "CVE-2006-1292": {"epss_score": 0.07303, "epss_percentile": 0.91393}, "CVE-2006-1293": {"epss_score": 0.01018, "epss_percentile": 0.76704}, "CVE-2006-1294": {"epss_score": 0.01834, "epss_percentile": 0.82462}, "CVE-2006-1295": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1296": {"epss_score": 0.00738, "epss_percentile": 0.72338}, "CVE-2006-1297": {"epss_score": 0.00714, "epss_percentile": 0.71815}, "CVE-2006-1298": {"epss_score": 0.02444, "epss_percentile": 0.84761}, "CVE-2006-1300": {"epss_score": 0.40329, "epss_percentile": 0.97212}, "CVE-2006-1301": {"epss_score": 0.37943, "epss_percentile": 0.97077}, "CVE-2006-1302": {"epss_score": 0.40131, "epss_percentile": 0.97198}, "CVE-2006-1303": {"epss_score": 0.58944, "epss_percentile": 0.98141}, "CVE-2006-1304": {"epss_score": 0.43609, "epss_percentile": 0.97394}, "CVE-2006-1305": {"epss_score": 0.51832, "epss_percentile": 0.97799}, "CVE-2006-1306": {"epss_score": 0.42366, "epss_percentile": 0.97328}, "CVE-2006-1308": {"epss_score": 0.42366, "epss_percentile": 0.97328}, "CVE-2006-1309": {"epss_score": 0.37943, "epss_percentile": 0.97077}, "CVE-2006-1311": {"epss_score": 0.70645, "epss_percentile": 0.98639}, "CVE-2006-1313": {"epss_score": 0.55177, "epss_percentile": 0.97964}, "CVE-2006-1314": {"epss_score": 0.75837, "epss_percentile": 0.98866}, "CVE-2006-1315": {"epss_score": 0.59904, "epss_percentile": 0.98186}, "CVE-2006-1316": {"epss_score": 0.40179, "epss_percentile": 0.97205}, "CVE-2006-1318": {"epss_score": 0.18939, "epss_percentile": 0.951}, "CVE-2006-1319": {"epss_score": 0.0004, "epss_percentile": 0.12012}, "CVE-2006-1320": {"epss_score": 0.00507, "epss_percentile": 0.65673}, "CVE-2006-1321": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-1322": {"epss_score": 0.01074, "epss_percentile": 0.77296}, "CVE-2006-1323": {"epss_score": 0.04829, "epss_percentile": 0.89188}, "CVE-2006-1324": {"epss_score": 0.12774, "epss_percentile": 0.93769}, "CVE-2006-1325": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-1326": {"epss_score": 0.00685, "epss_percentile": 0.71141}, "CVE-2006-1327": {"epss_score": 0.02446, "epss_percentile": 0.84772}, "CVE-2006-1328": {"epss_score": 0.00641, "epss_percentile": 0.69985}, "CVE-2006-1329": {"epss_score": 0.0156, "epss_percentile": 0.81038}, "CVE-2006-1330": {"epss_score": 0.00805, "epss_percentile": 0.73636}, "CVE-2006-1331": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-1332": {"epss_score": 0.01365, "epss_percentile": 0.79776}, "CVE-2006-1333": {"epss_score": 0.02166, "epss_percentile": 0.83847}, "CVE-2006-1334": {"epss_score": 0.03531, "epss_percentile": 0.87304}, "CVE-2006-1335": {"epss_score": 0.00077, "epss_percentile": 0.23297}, "CVE-2006-1336": {"epss_score": 0.07648, "epss_percentile": 0.91602}, "CVE-2006-1337": {"epss_score": 0.02884, "epss_percentile": 0.85909}, "CVE-2006-1338": {"epss_score": 0.03697, "epss_percentile": 0.87586}, "CVE-2006-1339": {"epss_score": 0.01939, "epss_percentile": 0.82971}, "CVE-2006-1340": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2006-1341": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2006-1342": {"epss_score": 0.00173, "epss_percentile": 0.39088}, "CVE-2006-1343": {"epss_score": 0.00102, "epss_percentile": 0.28777}, "CVE-2006-1344": {"epss_score": 0.007, "epss_percentile": 0.7148}, "CVE-2006-1345": {"epss_score": 0.00673, "epss_percentile": 0.70843}, "CVE-2006-1346": {"epss_score": 0.08595, "epss_percentile": 0.92141}, "CVE-2006-1347": {"epss_score": 0.01358, "epss_percentile": 0.79728}, "CVE-2006-1348": {"epss_score": 0.08852, "epss_percentile": 0.92284}, "CVE-2006-1349": {"epss_score": 0.00814, "epss_percentile": 0.73768}, "CVE-2006-1350": {"epss_score": 0.01269, "epss_percentile": 0.79039}, "CVE-2006-1351": {"epss_score": 0.00485, "epss_percentile": 0.64716}, "CVE-2006-1352": {"epss_score": 0.00952, "epss_percentile": 0.75882}, "CVE-2006-1353": {"epss_score": 0.05303, "epss_percentile": 0.89709}, "CVE-2006-1354": {"epss_score": 0.04762, "epss_percentile": 0.89119}, "CVE-2006-1355": {"epss_score": 0.00048, "epss_percentile": 0.15257}, "CVE-2006-1356": {"epss_score": 0.05711, "epss_percentile": 0.90141}, "CVE-2006-1357": {"epss_score": 0.06121, "epss_percentile": 0.90495}, "CVE-2006-1358": {"epss_score": 0.00531, "epss_percentile": 0.66658}, "CVE-2006-1359": {"epss_score": 0.87602, "epss_percentile": 0.99435}, "CVE-2006-1360": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-1361": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1362": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-1363": {"epss_score": 0.05725, "epss_percentile": 0.90154}, "CVE-2006-1364": {"epss_score": 0.29481, "epss_percentile": 0.96446}, "CVE-2006-1365": {"epss_score": 0.00448, "epss_percentile": 0.63026}, "CVE-2006-1366": {"epss_score": 0.03863, "epss_percentile": 0.87869}, "CVE-2006-1367": {"epss_score": 0.05202, "epss_percentile": 0.89606}, "CVE-2006-1368": {"epss_score": 0.03102, "epss_percentile": 0.86411}, "CVE-2006-1369": {"epss_score": 0.01769, "epss_percentile": 0.82183}, "CVE-2006-1370": {"epss_score": 0.0461, "epss_percentile": 0.88914}, "CVE-2006-1371": {"epss_score": 0.08846, "epss_percentile": 0.92282}, "CVE-2006-1372": {"epss_score": 0.00671, "epss_percentile": 0.70792}, "CVE-2006-1373": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-1374": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2006-1375": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-1376": {"epss_score": 0.00047, "epss_percentile": 0.14895}, "CVE-2006-1377": {"epss_score": 0.07275, "epss_percentile": 0.91379}, "CVE-2006-1378": {"epss_score": 0.00042, "epss_percentile": 0.12661}, "CVE-2006-1379": {"epss_score": 0.00066, "epss_percentile": 0.20804}, "CVE-2006-1380": {"epss_score": 0.00069, "epss_percentile": 0.21585}, "CVE-2006-1381": {"epss_score": 0.00384, "epss_percentile": 0.59154}, "CVE-2006-1382": {"epss_score": 0.01269, "epss_percentile": 0.79039}, "CVE-2006-1383": {"epss_score": 0.00718, "epss_percentile": 0.71924}, "CVE-2006-1384": {"epss_score": 0.00794, "epss_percentile": 0.73459}, "CVE-2006-1385": {"epss_score": 0.04874, "epss_percentile": 0.89237}, "CVE-2006-1386": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-1387": {"epss_score": 0.00777, "epss_percentile": 0.73107}, "CVE-2006-1388": {"epss_score": 0.67459, "epss_percentile": 0.98509}, "CVE-2006-1389": {"epss_score": 0.04891, "epss_percentile": 0.89265}, "CVE-2006-1390": {"epss_score": 0.00219, "epss_percentile": 0.44507}, "CVE-2006-1391": {"epss_score": 0.01349, "epss_percentile": 0.79667}, "CVE-2006-1392": {"epss_score": 0.0324, "epss_percentile": 0.86731}, "CVE-2006-1393": {"epss_score": 0.04272, "epss_percentile": 0.88477}, "CVE-2006-1394": {"epss_score": 0.01934, "epss_percentile": 0.82953}, "CVE-2006-1395": {"epss_score": 0.00533, "epss_percentile": 0.66751}, "CVE-2006-1396": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-1397": {"epss_score": 0.00913, "epss_percentile": 0.75376}, "CVE-2006-1398": {"epss_score": 0.00872, "epss_percentile": 0.74733}, "CVE-2006-1399": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1400": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1401": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1402": {"epss_score": 0.04134, "epss_percentile": 0.88304}, "CVE-2006-1403": {"epss_score": 0.01304, "epss_percentile": 0.79319}, "CVE-2006-1404": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2006-1405": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1406": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1407": {"epss_score": 0.00619, "epss_percentile": 0.69425}, "CVE-2006-1408": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2006-1409": {"epss_score": 0.01191, "epss_percentile": 0.78396}, "CVE-2006-1410": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1411": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1412": {"epss_score": 0.12875, "epss_percentile": 0.93809}, "CVE-2006-1413": {"epss_score": 0.00736, "epss_percentile": 0.72307}, "CVE-2006-1414": {"epss_score": 0.00809, "epss_percentile": 0.7371}, "CVE-2006-1415": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1416": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1417": {"epss_score": 0.02035, "epss_percentile": 0.83351}, "CVE-2006-1418": {"epss_score": 0.00783, "epss_percentile": 0.73216}, "CVE-2006-1419": {"epss_score": 0.01032, "epss_percentile": 0.76866}, "CVE-2006-1420": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2006-1421": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-1422": {"epss_score": 0.00568, "epss_percentile": 0.67906}, "CVE-2006-1423": {"epss_score": 0.00281, "epss_percentile": 0.51194}, "CVE-2006-1425": {"epss_score": 0.01044, "epss_percentile": 0.77006}, "CVE-2006-1426": {"epss_score": 0.02075, "epss_percentile": 0.83502}, "CVE-2006-1427": {"epss_score": 0.00839, "epss_percentile": 0.74194}, "CVE-2006-1428": {"epss_score": 0.00943, "epss_percentile": 0.75773}, "CVE-2006-1429": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2006-1430": {"epss_score": 0.00815, "epss_percentile": 0.73791}, "CVE-2006-1431": {"epss_score": 0.02222, "epss_percentile": 0.84053}, "CVE-2006-1432": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2006-1433": {"epss_score": 0.00492, "epss_percentile": 0.64987}, "CVE-2006-1434": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-1435": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-1436": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1437": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2006-1438": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-1439": {"epss_score": 0.00085, "epss_percentile": 0.25064}, "CVE-2006-1440": {"epss_score": 0.00097, "epss_percentile": 0.27542}, "CVE-2006-1441": {"epss_score": 0.0245, "epss_percentile": 0.84779}, "CVE-2006-1442": {"epss_score": 0.00772, "epss_percentile": 0.73043}, "CVE-2006-1443": {"epss_score": 0.00694, "epss_percentile": 0.71351}, "CVE-2006-1444": {"epss_score": 0.00097, "epss_percentile": 0.27542}, "CVE-2006-1445": {"epss_score": 0.02924, "epss_percentile": 0.86002}, "CVE-2006-1446": {"epss_score": 0.00385, "epss_percentile": 0.59207}, "CVE-2006-1447": {"epss_score": 0.00761, "epss_percentile": 0.72821}, "CVE-2006-1448": {"epss_score": 0.00694, "epss_percentile": 0.71351}, "CVE-2006-1449": {"epss_score": 0.03668, "epss_percentile": 0.87536}, "CVE-2006-1450": {"epss_score": 0.03668, "epss_percentile": 0.87536}, "CVE-2006-1451": {"epss_score": 0.0007, "epss_percentile": 0.21668}, "CVE-2006-1452": {"epss_score": 0.00094, "epss_percentile": 0.26789}, "CVE-2006-1453": {"epss_score": 0.24607, "epss_percentile": 0.95938}, "CVE-2006-1454": {"epss_score": 0.24607, "epss_percentile": 0.95938}, "CVE-2006-1455": {"epss_score": 0.01382, "epss_percentile": 0.79889}, "CVE-2006-1456": {"epss_score": 0.0456, "epss_percentile": 0.88851}, "CVE-2006-1457": {"epss_score": 0.01956, "epss_percentile": 0.8304}, "CVE-2006-1458": {"epss_score": 0.03349, "epss_percentile": 0.86957}, "CVE-2006-1459": {"epss_score": 0.09746, "epss_percentile": 0.92689}, "CVE-2006-1460": {"epss_score": 0.28766, "epss_percentile": 0.96383}, "CVE-2006-1461": {"epss_score": 0.11187, "epss_percentile": 0.93259}, "CVE-2006-1462": {"epss_score": 0.09746, "epss_percentile": 0.92689}, "CVE-2006-1463": {"epss_score": 0.131, "epss_percentile": 0.93874}, "CVE-2006-1464": {"epss_score": 0.14822, "epss_percentile": 0.94293}, "CVE-2006-1465": {"epss_score": 0.11187, "epss_percentile": 0.93259}, "CVE-2006-1466": {"epss_score": 0.00678, "epss_percentile": 0.70982}, "CVE-2006-1467": {"epss_score": 0.35838, "epss_percentile": 0.96937}, "CVE-2006-1468": {"epss_score": 0.00684, "epss_percentile": 0.71123}, "CVE-2006-1469": {"epss_score": 0.02401, "epss_percentile": 0.8464}, "CVE-2006-1470": {"epss_score": 0.24399, "epss_percentile": 0.95917}, "CVE-2006-1471": {"epss_score": 0.00073, "epss_percentile": 0.22644}, "CVE-2006-1472": {"epss_score": 0.00387, "epss_percentile": 0.59297}, "CVE-2006-1473": {"epss_score": 0.0934, "epss_percentile": 0.92507}, "CVE-2006-1474": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-1475": {"epss_score": 0.0038, "epss_percentile": 0.58936}, "CVE-2006-1476": {"epss_score": 0.17199, "epss_percentile": 0.94798}, "CVE-2006-1477": {"epss_score": 0.06143, "epss_percentile": 0.90515}, "CVE-2006-1478": {"epss_score": 0.04758, "epss_percentile": 0.89116}, "CVE-2006-1479": {"epss_score": 0.02265, "epss_percentile": 0.84197}, "CVE-2006-1480": {"epss_score": 0.07405, "epss_percentile": 0.91455}, "CVE-2006-1481": {"epss_score": 0.00556, "epss_percentile": 0.67526}, "CVE-2006-1482": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2006-1483": {"epss_score": 0.00872, "epss_percentile": 0.74733}, "CVE-2006-1484": {"epss_score": 0.00049, "epss_percentile": 0.1545}, "CVE-2006-1485": {"epss_score": 0.01098, "epss_percentile": 0.77542}, "CVE-2006-1486": {"epss_score": 0.02295, "epss_percentile": 0.84294}, "CVE-2006-1487": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2006-1488": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-1489": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2006-1490": {"epss_score": 0.30649, "epss_percentile": 0.96559}, "CVE-2006-1491": {"epss_score": 0.18309, "epss_percentile": 0.94992}, "CVE-2006-1492": {"epss_score": 0.00495, "epss_percentile": 0.65117}, "CVE-2006-1493": {"epss_score": 0.00903, "epss_percentile": 0.75205}, "CVE-2006-1494": {"epss_score": 0.05835, "epss_percentile": 0.90248}, "CVE-2006-1495": {"epss_score": 0.05415, "epss_percentile": 0.8985}, "CVE-2006-1496": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2006-1497": {"epss_score": 0.0742, "epss_percentile": 0.91466}, "CVE-2006-1498": {"epss_score": 0.0103, "epss_percentile": 0.76841}, "CVE-2006-1499": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-1500": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2006-1501": {"epss_score": 0.00595, "epss_percentile": 0.68688}, "CVE-2006-1502": {"epss_score": 0.04366, "epss_percentile": 0.88602}, "CVE-2006-1503": {"epss_score": 0.01775, "epss_percentile": 0.82214}, "CVE-2006-1504": {"epss_score": 0.03222, "epss_percentile": 0.86675}, "CVE-2006-1505": {"epss_score": 0.00744, "epss_percentile": 0.72506}, "CVE-2006-1506": {"epss_score": 0.00052, "epss_percentile": 0.16481}, "CVE-2006-1507": {"epss_score": 0.01171, "epss_percentile": 0.78224}, "CVE-2006-1508": {"epss_score": 0.01121, "epss_percentile": 0.77767}, "CVE-2006-1509": {"epss_score": 0.00078, "epss_percentile": 0.23788}, "CVE-2006-1510": {"epss_score": 0.1696, "epss_percentile": 0.94753}, "CVE-2006-1511": {"epss_score": 0.28999, "epss_percentile": 0.96409}, "CVE-2006-1513": {"epss_score": 0.01747, "epss_percentile": 0.82073}, "CVE-2006-1514": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2006-1515": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2006-1516": {"epss_score": 0.81806, "epss_percentile": 0.99157}, "CVE-2006-1517": {"epss_score": 0.0919, "epss_percentile": 0.9244}, "CVE-2006-1518": {"epss_score": 0.41487, "epss_percentile": 0.97277}, "CVE-2006-1520": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2006-1522": {"epss_score": 0.00072, "epss_percentile": 0.22296}, "CVE-2006-1523": {"epss_score": 0.00611, "epss_percentile": 0.69194}, "CVE-2006-1524": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2006-1525": {"epss_score": 0.00092, "epss_percentile": 0.26515}, "CVE-2006-1526": {"epss_score": 0.00443, "epss_percentile": 0.62758}, "CVE-2006-1527": {"epss_score": 0.09301, "epss_percentile": 0.92489}, "CVE-2006-1528": {"epss_score": 0.00089, "epss_percentile": 0.25972}, "CVE-2006-1529": {"epss_score": 0.30625, "epss_percentile": 0.96557}, "CVE-2006-1530": {"epss_score": 0.25319, "epss_percentile": 0.96012}, "CVE-2006-1531": {"epss_score": 0.25319, "epss_percentile": 0.96012}, "CVE-2006-1532": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1533": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2006-1534": {"epss_score": 0.01838, "epss_percentile": 0.82486}, "CVE-2006-1535": {"epss_score": 0.00353, "epss_percentile": 0.57198}, "CVE-2006-1536": {"epss_score": 0.00313, "epss_percentile": 0.54025}, "CVE-2006-1537": {"epss_score": 0.00968, "epss_percentile": 0.76077}, "CVE-2006-1538": {"epss_score": 0.00072, "epss_percentile": 0.22432}, "CVE-2006-1539": {"epss_score": 0.00864, "epss_percentile": 0.74607}, "CVE-2006-1540": {"epss_score": 0.74659, "epss_percentile": 0.98811}, "CVE-2006-1541": {"epss_score": 0.01477, "epss_percentile": 0.80549}, "CVE-2006-1542": {"epss_score": 0.00206, "epss_percentile": 0.42775}, "CVE-2006-1543": {"epss_score": 0.01836, "epss_percentile": 0.82472}, "CVE-2006-1544": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1545": {"epss_score": 0.03351, "epss_percentile": 0.86963}, "CVE-2006-1546": {"epss_score": 0.01612, "epss_percentile": 0.81333}, "CVE-2006-1547": {"epss_score": 0.17326, "epss_percentile": 0.94824}, "CVE-2006-1548": {"epss_score": 0.08769, "epss_percentile": 0.92247}, "CVE-2006-1549": {"epss_score": 0.0018, "epss_percentile": 0.39889}, "CVE-2006-1550": {"epss_score": 0.03979, "epss_percentile": 0.88056}, "CVE-2006-1551": {"epss_score": 0.72147, "epss_percentile": 0.98696}, "CVE-2006-1552": {"epss_score": 0.03822, "epss_percentile": 0.87784}, "CVE-2006-1553": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2006-1554": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-1555": {"epss_score": 0.00415, "epss_percentile": 0.6114}, "CVE-2006-1556": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-1557": {"epss_score": 0.00555, "epss_percentile": 0.67457}, "CVE-2006-1558": {"epss_score": 0.01305, "epss_percentile": 0.79323}, "CVE-2006-1559": {"epss_score": 0.00365, "epss_percentile": 0.58012}, "CVE-2006-1560": {"epss_score": 0.01918, "epss_percentile": 0.82877}, "CVE-2006-1561": {"epss_score": 0.01355, "epss_percentile": 0.79706}, "CVE-2006-1562": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-1563": {"epss_score": 0.00667, "epss_percentile": 0.70704}, "CVE-2006-1564": {"epss_score": 0.00074, "epss_percentile": 0.22772}, "CVE-2006-1565": {"epss_score": 0.00117, "epss_percentile": 0.31364}, "CVE-2006-1566": {"epss_score": 0.00117, "epss_percentile": 0.31364}, "CVE-2006-1567": {"epss_score": 0.00783, "epss_percentile": 0.73216}, "CVE-2006-1568": {"epss_score": 0.12774, "epss_percentile": 0.93769}, "CVE-2006-1569": {"epss_score": 0.04932, "epss_percentile": 0.89299}, "CVE-2006-1570": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1571": {"epss_score": 0.01355, "epss_percentile": 0.79706}, "CVE-2006-1572": {"epss_score": 0.0061, "epss_percentile": 0.6914}, "CVE-2006-1573": {"epss_score": 0.0325, "epss_percentile": 0.86749}, "CVE-2006-1574": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1575": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-1576": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-1577": {"epss_score": 0.02028, "epss_percentile": 0.83324}, "CVE-2006-1578": {"epss_score": 0.00279, "epss_percentile": 0.50988}, "CVE-2006-1579": {"epss_score": 0.00349, "epss_percentile": 0.56866}, "CVE-2006-1580": {"epss_score": 0.01013, "epss_percentile": 0.76632}, "CVE-2006-1581": {"epss_score": 0.05096, "epss_percentile": 0.89493}, "CVE-2006-1582": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2006-1583": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-1584": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2006-1585": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2006-1586": {"epss_score": 0.00897, "epss_percentile": 0.75123}, "CVE-2006-1587": {"epss_score": 0.00059, "epss_percentile": 0.18656}, "CVE-2006-1588": {"epss_score": 0.00078, "epss_percentile": 0.23623}, "CVE-2006-1589": {"epss_score": 0.00047, "epss_percentile": 0.14695}, "CVE-2006-1590": {"epss_score": 0.09841, "epss_percentile": 0.92727}, "CVE-2006-1591": {"epss_score": 0.23932, "epss_percentile": 0.95835}, "CVE-2006-1592": {"epss_score": 0.07706, "epss_percentile": 0.91637}, "CVE-2006-1593": {"epss_score": 0.155, "epss_percentile": 0.9444}, "CVE-2006-1594": {"epss_score": 0.02625, "epss_percentile": 0.85263}, "CVE-2006-1595": {"epss_score": 0.10005, "epss_percentile": 0.92812}, "CVE-2006-1596": {"epss_score": 0.01269, "epss_percentile": 0.79039}, "CVE-2006-1598": {"epss_score": 0.00835, "epss_percentile": 0.74117}, "CVE-2006-1599": {"epss_score": 0.01253, "epss_percentile": 0.78914}, "CVE-2006-1600": {"epss_score": 0.00509, "epss_percentile": 0.65745}, "CVE-2006-1601": {"epss_score": 0.00074, "epss_percentile": 0.22803}, "CVE-2006-1602": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-1603": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1604": {"epss_score": 0.00366, "epss_percentile": 0.58087}, "CVE-2006-1605": {"epss_score": 0.02313, "epss_percentile": 0.84348}, "CVE-2006-1606": {"epss_score": 0.00365, "epss_percentile": 0.58008}, "CVE-2006-1607": {"epss_score": 0.00666, "epss_percentile": 0.70678}, "CVE-2006-1608": {"epss_score": 0.00514, "epss_percentile": 0.65959}, "CVE-2006-1609": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-1610": {"epss_score": 0.10243, "epss_percentile": 0.92909}, "CVE-2006-1611": {"epss_score": 0.01358, "epss_percentile": 0.79732}, "CVE-2006-1612": {"epss_score": 0.01032, "epss_percentile": 0.76865}, "CVE-2006-1613": {"epss_score": 0.02162, "epss_percentile": 0.83831}, "CVE-2006-1614": {"epss_score": 0.28171, "epss_percentile": 0.96329}, "CVE-2006-1615": {"epss_score": 0.36756, "epss_percentile": 0.97}, "CVE-2006-1616": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2006-1617": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2006-1618": {"epss_score": 0.26404, "epss_percentile": 0.96143}, "CVE-2006-1619": {"epss_score": 0.00811, "epss_percentile": 0.73731}, "CVE-2006-1620": {"epss_score": 0.01141, "epss_percentile": 0.77968}, "CVE-2006-1621": {"epss_score": 0.00416, "epss_percentile": 0.61185}, "CVE-2006-1622": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-1623": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-1624": {"epss_score": 0.00852, "epss_percentile": 0.74412}, "CVE-2006-1625": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-1626": {"epss_score": 0.52297, "epss_percentile": 0.97817}, "CVE-2006-1627": {"epss_score": 0.03701, "epss_percentile": 0.87591}, "CVE-2006-1628": {"epss_score": 0.03176, "epss_percentile": 0.86571}, "CVE-2006-1629": {"epss_score": 0.0356, "epss_percentile": 0.87352}, "CVE-2006-1630": {"epss_score": 0.16987, "epss_percentile": 0.94757}, "CVE-2006-1631": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-1634": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2006-1635": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2006-1636": {"epss_score": 0.01834, "epss_percentile": 0.82462}, "CVE-2006-1637": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2006-1638": {"epss_score": 0.01848, "epss_percentile": 0.82525}, "CVE-2006-1639": {"epss_score": 0.0139, "epss_percentile": 0.79934}, "CVE-2006-1640": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2006-1641": {"epss_score": 0.01294, "epss_percentile": 0.79242}, "CVE-2006-1642": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1643": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-1644": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2006-1645": {"epss_score": 0.00725, "epss_percentile": 0.72046}, "CVE-2006-1646": {"epss_score": 0.01108, "epss_percentile": 0.77636}, "CVE-2006-1647": {"epss_score": 0.01886, "epss_percentile": 0.82712}, "CVE-2006-1648": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2006-1649": {"epss_score": 0.0005, "epss_percentile": 0.15961}, "CVE-2006-1650": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2006-1651": {"epss_score": 0.10822, "epss_percentile": 0.93122}, "CVE-2006-1652": {"epss_score": 0.85939, "epss_percentile": 0.99356}, "CVE-2006-1653": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2006-1654": {"epss_score": 0.17086, "epss_percentile": 0.94772}, "CVE-2006-1655": {"epss_score": 0.00999, "epss_percentile": 0.76477}, "CVE-2006-1656": {"epss_score": 0.00049, "epss_percentile": 0.1545}, "CVE-2006-1657": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-1658": {"epss_score": 0.00743, "epss_percentile": 0.72481}, "CVE-2006-1659": {"epss_score": 0.01361, "epss_percentile": 0.79753}, "CVE-2006-1660": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-1661": {"epss_score": 0.00738, "epss_percentile": 0.72349}, "CVE-2006-1662": {"epss_score": 0.09012, "epss_percentile": 0.92364}, "CVE-2006-1664": {"epss_score": 0.07142, "epss_percentile": 0.9128}, "CVE-2006-1665": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-1666": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-1667": {"epss_score": 0.02309, "epss_percentile": 0.84331}, "CVE-2006-1668": {"epss_score": 0.09368, "epss_percentile": 0.92519}, "CVE-2006-1669": {"epss_score": 0.00938, "epss_percentile": 0.75702}, "CVE-2006-1670": {"epss_score": 0.01919, "epss_percentile": 0.82886}, "CVE-2006-1671": {"epss_score": 0.02512, "epss_percentile": 0.84957}, "CVE-2006-1672": {"epss_score": 0.03797, "epss_percentile": 0.87737}, "CVE-2006-1673": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2006-1674": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2006-1675": {"epss_score": 0.00557, "epss_percentile": 0.6754}, "CVE-2006-1676": {"epss_score": 0.0076, "epss_percentile": 0.72805}, "CVE-2006-1677": {"epss_score": 0.00647, "epss_percentile": 0.70189}, "CVE-2006-1678": {"epss_score": 0.0103, "epss_percentile": 0.76841}, "CVE-2006-1679": {"epss_score": 0.01115, "epss_percentile": 0.77712}, "CVE-2006-1680": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2006-1681": {"epss_score": 0.00299, "epss_percentile": 0.52862}, "CVE-2006-1682": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2006-1683": {"epss_score": 0.01625, "epss_percentile": 0.81423}, "CVE-2006-1684": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2006-1685": {"epss_score": 0.00446, "epss_percentile": 0.62924}, "CVE-2006-1686": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2006-1687": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-1688": {"epss_score": 0.03511, "epss_percentile": 0.87267}, "CVE-2006-1689": {"epss_score": 0.00053, "epss_percentile": 0.17004}, "CVE-2006-1690": {"epss_score": 0.01724, "epss_percentile": 0.81948}, "CVE-2006-1691": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-1692": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-1693": {"epss_score": 0.00507, "epss_percentile": 0.65673}, "CVE-2006-1694": {"epss_score": 0.00822, "epss_percentile": 0.73918}, "CVE-2006-1695": {"epss_score": 0.0007, "epss_percentile": 0.21832}, "CVE-2006-1696": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1697": {"epss_score": 0.00949, "epss_percentile": 0.75844}, "CVE-2006-1698": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-1699": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2006-1700": {"epss_score": 0.00524, "epss_percentile": 0.66339}, "CVE-2006-1701": {"epss_score": 0.00758, "epss_percentile": 0.72782}, "CVE-2006-1702": {"epss_score": 0.02086, "epss_percentile": 0.83551}, "CVE-2006-1703": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2006-1704": {"epss_score": 0.03792, "epss_percentile": 0.87732}, "CVE-2006-1705": {"epss_score": 0.01109, "epss_percentile": 0.77646}, "CVE-2006-1706": {"epss_score": 0.01902, "epss_percentile": 0.82785}, "CVE-2006-1707": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2006-1708": {"epss_score": 0.02446, "epss_percentile": 0.84772}, "CVE-2006-1709": {"epss_score": 0.02295, "epss_percentile": 0.84294}, "CVE-2006-1710": {"epss_score": 0.00862, "epss_percentile": 0.74575}, "CVE-2006-1711": {"epss_score": 0.11107, "epss_percentile": 0.93223}, "CVE-2006-1712": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-1713": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-1714": {"epss_score": 0.03174, "epss_percentile": 0.8656}, "CVE-2006-1715": {"epss_score": 0.00688, "epss_percentile": 0.71211}, "CVE-2006-1716": {"epss_score": 0.01414, "epss_percentile": 0.8013}, "CVE-2006-1717": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2006-1718": {"epss_score": 0.06194, "epss_percentile": 0.90556}, "CVE-2006-1719": {"epss_score": 0.19067, "epss_percentile": 0.95123}, "CVE-2006-1720": {"epss_score": 0.00438, "epss_percentile": 0.62561}, "CVE-2006-1721": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2006-1722": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-1723": {"epss_score": 0.17957, "epss_percentile": 0.94933}, "CVE-2006-1724": {"epss_score": 0.27339, "epss_percentile": 0.96238}, "CVE-2006-1725": {"epss_score": 0.02534, "epss_percentile": 0.85034}, "CVE-2006-1726": {"epss_score": 0.09676, "epss_percentile": 0.92649}, "CVE-2006-1727": {"epss_score": 0.05041, "epss_percentile": 0.89428}, "CVE-2006-1728": {"epss_score": 0.29804, "epss_percentile": 0.96477}, "CVE-2006-1729": {"epss_score": 0.01816, "epss_percentile": 0.8239}, "CVE-2006-1730": {"epss_score": 0.26483, "epss_percentile": 0.9615}, "CVE-2006-1731": {"epss_score": 0.02816, "epss_percentile": 0.85733}, "CVE-2006-1732": {"epss_score": 0.02208, "epss_percentile": 0.84007}, "CVE-2006-1733": {"epss_score": 0.24271, "epss_percentile": 0.95898}, "CVE-2006-1734": {"epss_score": 0.32741, "epss_percentile": 0.96722}, "CVE-2006-1735": {"epss_score": 0.39006, "epss_percentile": 0.97134}, "CVE-2006-1736": {"epss_score": 0.01623, "epss_percentile": 0.81402}, "CVE-2006-1737": {"epss_score": 0.26152, "epss_percentile": 0.96117}, "CVE-2006-1738": {"epss_score": 0.29789, "epss_percentile": 0.96476}, "CVE-2006-1739": {"epss_score": 0.33115, "epss_percentile": 0.96747}, "CVE-2006-1740": {"epss_score": 0.0219, "epss_percentile": 0.83933}, "CVE-2006-1741": {"epss_score": 0.01946, "epss_percentile": 0.83002}, "CVE-2006-1742": {"epss_score": 0.1399, "epss_percentile": 0.94111}, "CVE-2006-1743": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-1744": {"epss_score": 0.0015, "epss_percentile": 0.36107}, "CVE-2006-1745": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2006-1746": {"epss_score": 0.00871, "epss_percentile": 0.7471}, "CVE-2006-1747": {"epss_score": 0.08058, "epss_percentile": 0.91858}, "CVE-2006-1748": {"epss_score": 0.00357, "epss_percentile": 0.57434}, "CVE-2006-1749": {"epss_score": 0.04902, "epss_percentile": 0.89274}, "CVE-2006-1750": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-1751": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-1752": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1753": {"epss_score": 0.00064, "epss_percentile": 0.20347}, "CVE-2006-1754": {"epss_score": 0.01238, "epss_percentile": 0.78794}, "CVE-2006-1755": {"epss_score": 0.01102, "epss_percentile": 0.77579}, "CVE-2006-1756": {"epss_score": 0.00978, "epss_percentile": 0.76237}, "CVE-2006-1757": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2006-1758": {"epss_score": 0.00495, "epss_percentile": 0.65131}, "CVE-2006-1759": {"epss_score": 0.0076, "epss_percentile": 0.72812}, "CVE-2006-1760": {"epss_score": 0.0075, "epss_percentile": 0.72634}, "CVE-2006-1761": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-1762": {"epss_score": 0.00989, "epss_percentile": 0.7636}, "CVE-2006-1763": {"epss_score": 0.00616, "epss_percentile": 0.69325}, "CVE-2006-1764": {"epss_score": 0.00372, "epss_percentile": 0.58435}, "CVE-2006-1765": {"epss_score": 0.01859, "epss_percentile": 0.82584}, "CVE-2006-1766": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-1767": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2006-1768": {"epss_score": 0.01132, "epss_percentile": 0.77873}, "CVE-2006-1769": {"epss_score": 0.0192, "epss_percentile": 0.82891}, "CVE-2006-1770": {"epss_score": 0.04005, "epss_percentile": 0.881}, "CVE-2006-1771": {"epss_score": 0.04655, "epss_percentile": 0.8897}, "CVE-2006-1772": {"epss_score": 0.00052, "epss_percentile": 0.16481}, "CVE-2006-1773": {"epss_score": 0.00603, "epss_percentile": 0.68917}, "CVE-2006-1774": {"epss_score": 0.00311, "epss_percentile": 0.53929}, "CVE-2006-1775": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1776": {"epss_score": 0.22789, "epss_percentile": 0.95687}, "CVE-2006-1777": {"epss_score": 0.18551, "epss_percentile": 0.95032}, "CVE-2006-1778": {"epss_score": 0.04423, "epss_percentile": 0.88672}, "CVE-2006-1779": {"epss_score": 0.18694, "epss_percentile": 0.95055}, "CVE-2006-1780": {"epss_score": 0.00067, "epss_percentile": 0.21117}, "CVE-2006-1781": {"epss_score": 0.1185, "epss_percentile": 0.93495}, "CVE-2006-1782": {"epss_score": 0.00071, "epss_percentile": 0.2211}, "CVE-2006-1783": {"epss_score": 0.00353, "epss_percentile": 0.57198}, "CVE-2006-1784": {"epss_score": 0.07229, "epss_percentile": 0.91337}, "CVE-2006-1785": {"epss_score": 0.01355, "epss_percentile": 0.79706}, "CVE-2006-1786": {"epss_score": 0.05468, "epss_percentile": 0.89906}, "CVE-2006-1787": {"epss_score": 0.01773, "epss_percentile": 0.82206}, "CVE-2006-1788": {"epss_score": 0.02135, "epss_percentile": 0.83725}, "CVE-2006-1789": {"epss_score": 0.0037, "epss_percentile": 0.58311}, "CVE-2006-1790": {"epss_score": 0.15881, "epss_percentile": 0.94526}, "CVE-2006-1791": {"epss_score": 0.00592, "epss_percentile": 0.6861}, "CVE-2006-1792": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2006-1793": {"epss_score": 0.02282, "epss_percentile": 0.84256}, "CVE-2006-1794": {"epss_score": 0.01077, "epss_percentile": 0.77333}, "CVE-2006-1795": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-1796": {"epss_score": 0.00455, "epss_percentile": 0.63272}, "CVE-2006-1797": {"epss_score": 0.00064, "epss_percentile": 0.20304}, "CVE-2006-1798": {"epss_score": 0.01122, "epss_percentile": 0.77782}, "CVE-2006-1799": {"epss_score": 0.07233, "epss_percentile": 0.91338}, "CVE-2006-1800": {"epss_score": 0.05778, "epss_percentile": 0.90199}, "CVE-2006-1801": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2006-1802": {"epss_score": 0.00771, "epss_percentile": 0.73017}, "CVE-2006-1803": {"epss_score": 0.08966, "epss_percentile": 0.92342}, "CVE-2006-1804": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-1805": {"epss_score": 0.006, "epss_percentile": 0.68815}, "CVE-2006-1806": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1807": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-1808": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2006-1809": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2006-1810": {"epss_score": 0.00191, "epss_percentile": 0.41192}, "CVE-2006-1811": {"epss_score": 0.00375, "epss_percentile": 0.58595}, "CVE-2006-1812": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-1813": {"epss_score": 0.00309, "epss_percentile": 0.53667}, "CVE-2006-1814": {"epss_score": 0.00071, "epss_percentile": 0.22032}, "CVE-2006-1815": {"epss_score": 0.00416, "epss_percentile": 0.61177}, "CVE-2006-1816": {"epss_score": 0.0194, "epss_percentile": 0.82976}, "CVE-2006-1817": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2006-1818": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-1819": {"epss_score": 0.0152, "epss_percentile": 0.80825}, "CVE-2006-1820": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2006-1821": {"epss_score": 0.05096, "epss_percentile": 0.89493}, "CVE-2006-1822": {"epss_score": 0.09215, "epss_percentile": 0.92453}, "CVE-2006-1823": {"epss_score": 0.00283, "epss_percentile": 0.51376}, "CVE-2006-1824": {"epss_score": 0.00162, "epss_percentile": 0.3763}, "CVE-2006-1825": {"epss_score": 0.00458, "epss_percentile": 0.63449}, "CVE-2006-1826": {"epss_score": 0.00316, "epss_percentile": 0.54239}, "CVE-2006-1827": {"epss_score": 0.03378, "epss_percentile": 0.87025}, "CVE-2006-1828": {"epss_score": 0.038, "epss_percentile": 0.87742}, "CVE-2006-1829": {"epss_score": 0.0042, "epss_percentile": 0.61453}, "CVE-2006-1830": {"epss_score": 0.0004, "epss_percentile": 0.12035}, "CVE-2006-1831": {"epss_score": 0.19174, "epss_percentile": 0.95144}, "CVE-2006-1832": {"epss_score": 0.05128, "epss_percentile": 0.89527}, "CVE-2006-1833": {"epss_score": 0.00321, "epss_percentile": 0.54696}, "CVE-2006-1834": {"epss_score": 0.15762, "epss_percentile": 0.94506}, "CVE-2006-1835": {"epss_score": 0.007, "epss_percentile": 0.7148}, "CVE-2006-1836": {"epss_score": 0.0006, "epss_percentile": 0.19137}, "CVE-2006-1837": {"epss_score": 0.0103, "epss_percentile": 0.76849}, "CVE-2006-1838": {"epss_score": 0.03321, "epss_percentile": 0.8691}, "CVE-2006-1839": {"epss_score": 0.03748, "epss_percentile": 0.87666}, "CVE-2006-1840": {"epss_score": 0.00787, "epss_percentile": 0.73319}, "CVE-2006-1841": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1842": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1843": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-1844": {"epss_score": 0.00069, "epss_percentile": 0.21537}, "CVE-2006-1846": {"epss_score": 0.00029, "epss_percentile": 0.07926}, "CVE-2006-1847": {"epss_score": 0.00134, "epss_percentile": 0.33928}, "CVE-2006-1848": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-1849": {"epss_score": 0.00446, "epss_percentile": 0.62924}, "CVE-2006-1850": {"epss_score": 0.00565, "epss_percentile": 0.67789}, "CVE-2006-1851": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-1852": {"epss_score": 0.00349, "epss_percentile": 0.56866}, "CVE-2006-1853": {"epss_score": 0.00475, "epss_percentile": 0.64198}, "CVE-2006-1854": {"epss_score": 0.00362, "epss_percentile": 0.57779}, "CVE-2006-1855": {"epss_score": 0.00089, "epss_percentile": 0.25973}, "CVE-2006-1856": {"epss_score": 0.0231, "epss_percentile": 0.84334}, "CVE-2006-1857": {"epss_score": 0.04596, "epss_percentile": 0.88898}, "CVE-2006-1858": {"epss_score": 0.1139, "epss_percentile": 0.9333}, "CVE-2006-1859": {"epss_score": 0.00074, "epss_percentile": 0.22836}, "CVE-2006-1860": {"epss_score": 0.00107, "epss_percentile": 0.29727}, "CVE-2006-1861": {"epss_score": 0.08522, "epss_percentile": 0.921}, "CVE-2006-1862": {"epss_score": 0.00105, "epss_percentile": 0.29312}, "CVE-2006-1863": {"epss_score": 0.00173, "epss_percentile": 0.39067}, "CVE-2006-1864": {"epss_score": 0.00302, "epss_percentile": 0.53168}, "CVE-2006-1865": {"epss_score": 0.019, "epss_percentile": 0.82773}, "CVE-2006-1866": {"epss_score": 0.06627, "epss_percentile": 0.909}, "CVE-2006-1867": {"epss_score": 0.02432, "epss_percentile": 0.84728}, "CVE-2006-1868": {"epss_score": 0.18267, "epss_percentile": 0.94985}, "CVE-2006-1869": {"epss_score": 0.08925, "epss_percentile": 0.92322}, "CVE-2006-1870": {"epss_score": 0.03376, "epss_percentile": 0.87019}, "CVE-2006-1871": {"epss_score": 0.03173, "epss_percentile": 0.86554}, "CVE-2006-1872": {"epss_score": 0.02393, "epss_percentile": 0.84612}, "CVE-2006-1873": {"epss_score": 0.02179, "epss_percentile": 0.83894}, "CVE-2006-1874": {"epss_score": 0.01499, "epss_percentile": 0.80707}, "CVE-2006-1875": {"epss_score": 0.01289, "epss_percentile": 0.7921}, "CVE-2006-1876": {"epss_score": 0.01694, "epss_percentile": 0.81801}, "CVE-2006-1877": {"epss_score": 0.00334, "epss_percentile": 0.55721}, "CVE-2006-1878": {"epss_score": 0.00949, "epss_percentile": 0.75844}, "CVE-2006-1879": {"epss_score": 0.06288, "epss_percentile": 0.90646}, "CVE-2006-1880": {"epss_score": 0.02299, "epss_percentile": 0.84304}, "CVE-2006-1881": {"epss_score": 0.00977, "epss_percentile": 0.76232}, "CVE-2006-1882": {"epss_score": 0.06288, "epss_percentile": 0.90646}, "CVE-2006-1883": {"epss_score": 0.00977, "epss_percentile": 0.76232}, "CVE-2006-1884": {"epss_score": 0.01323, "epss_percentile": 0.79456}, "CVE-2006-1885": {"epss_score": 0.02299, "epss_percentile": 0.84304}, "CVE-2006-1886": {"epss_score": 0.02299, "epss_percentile": 0.84304}, "CVE-2006-1887": {"epss_score": 0.02299, "epss_percentile": 0.84304}, "CVE-2006-1888": {"epss_score": 0.01353, "epss_percentile": 0.79696}, "CVE-2006-1889": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-1890": {"epss_score": 0.04185, "epss_percentile": 0.8836}, "CVE-2006-1891": {"epss_score": 0.00877, "epss_percentile": 0.74802}, "CVE-2006-1892": {"epss_score": 0.00048, "epss_percentile": 0.15232}, "CVE-2006-1893": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-1894": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-1895": {"epss_score": 0.00365, "epss_percentile": 0.5796}, "CVE-2006-1896": {"epss_score": 0.01319, "epss_percentile": 0.79436}, "CVE-2006-1897": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-1898": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1899": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1900": {"epss_score": 0.35347, "epss_percentile": 0.96903}, "CVE-2006-1901": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2006-1902": {"epss_score": 0.00094, "epss_percentile": 0.26776}, "CVE-2006-1903": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-1904": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-1905": {"epss_score": 0.07959, "epss_percentile": 0.91789}, "CVE-2006-1906": {"epss_score": 0.06991, "epss_percentile": 0.91167}, "CVE-2006-1907": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-1908": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-1909": {"epss_score": 0.05202, "epss_percentile": 0.89606}, "CVE-2006-1910": {"epss_score": 0.00763, "epss_percentile": 0.72859}, "CVE-2006-1911": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-1912": {"epss_score": 0.00898, "epss_percentile": 0.75143}, "CVE-2006-1913": {"epss_score": 0.01444, "epss_percentile": 0.80318}, "CVE-2006-1914": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-1915": {"epss_score": 0.00384, "epss_percentile": 0.59153}, "CVE-2006-1916": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-1917": {"epss_score": 0.01615, "epss_percentile": 0.81353}, "CVE-2006-1918": {"epss_score": 0.00406, "epss_percentile": 0.60555}, "CVE-2006-1919": {"epss_score": 0.10696, "epss_percentile": 0.93074}, "CVE-2006-1920": {"epss_score": 0.00753, "epss_percentile": 0.72677}, "CVE-2006-1921": {"epss_score": 0.13486, "epss_percentile": 0.93978}, "CVE-2006-1922": {"epss_score": 0.11677, "epss_percentile": 0.93444}, "CVE-2006-1923": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1924": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2006-1925": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2006-1926": {"epss_score": 0.00558, "epss_percentile": 0.67587}, "CVE-2006-1927": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-1928": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-1929": {"epss_score": 0.12296, "epss_percentile": 0.93625}, "CVE-2006-1930": {"epss_score": 0.00661, "epss_percentile": 0.70567}, "CVE-2006-1931": {"epss_score": 0.13214, "epss_percentile": 0.93903}, "CVE-2006-1932": {"epss_score": 0.03013, "epss_percentile": 0.86204}, "CVE-2006-1933": {"epss_score": 0.03891, "epss_percentile": 0.8791}, "CVE-2006-1934": {"epss_score": 0.02643, "epss_percentile": 0.85311}, "CVE-2006-1935": {"epss_score": 0.02643, "epss_percentile": 0.85311}, "CVE-2006-1936": {"epss_score": 0.01718, "epss_percentile": 0.81922}, "CVE-2006-1937": {"epss_score": 0.0378, "epss_percentile": 0.87719}, "CVE-2006-1938": {"epss_score": 0.05902, "epss_percentile": 0.9031}, "CVE-2006-1939": {"epss_score": 0.03224, "epss_percentile": 0.86679}, "CVE-2006-1940": {"epss_score": 0.05902, "epss_percentile": 0.9031}, "CVE-2006-1941": {"epss_score": 0.07196, "epss_percentile": 0.91314}, "CVE-2006-1942": {"epss_score": 0.0294, "epss_percentile": 0.86031}, "CVE-2006-1943": {"epss_score": 0.00954, "epss_percentile": 0.75895}, "CVE-2006-1944": {"epss_score": 0.00954, "epss_percentile": 0.75895}, "CVE-2006-1945": {"epss_score": 0.03817, "epss_percentile": 0.8777}, "CVE-2006-1946": {"epss_score": 0.00974, "epss_percentile": 0.76193}, "CVE-2006-1947": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2006-1948": {"epss_score": 0.00302, "epss_percentile": 0.53127}, "CVE-2006-1949": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-1950": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2006-1951": {"epss_score": 0.03034, "epss_percentile": 0.86259}, "CVE-2006-1952": {"epss_score": 0.01626, "epss_percentile": 0.81424}, "CVE-2006-1953": {"epss_score": 0.0091, "epss_percentile": 0.75316}, "CVE-2006-1954": {"epss_score": 0.02035, "epss_percentile": 0.83349}, "CVE-2006-1955": {"epss_score": 0.00839, "epss_percentile": 0.74197}, "CVE-2006-1956": {"epss_score": 0.00012, "epss_percentile": 0.0135}, "CVE-2006-1957": {"epss_score": 0.00283, "epss_percentile": 0.51399}, "CVE-2006-1958": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2006-1959": {"epss_score": 0.1689, "epss_percentile": 0.94742}, "CVE-2006-1960": {"epss_score": 0.07079, "epss_percentile": 0.91237}, "CVE-2006-1961": {"epss_score": 0.01308, "epss_percentile": 0.79346}, "CVE-2006-1962": {"epss_score": 0.01233, "epss_percentile": 0.78751}, "CVE-2006-1963": {"epss_score": 0.01196, "epss_percentile": 0.78435}, "CVE-2006-1964": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-1965": {"epss_score": 0.00839, "epss_percentile": 0.74194}, "CVE-2006-1966": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2006-1967": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-1968": {"epss_score": 0.008, "epss_percentile": 0.7356}, "CVE-2006-1969": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1970": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1971": {"epss_score": 0.00949, "epss_percentile": 0.75844}, "CVE-2006-1972": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-1973": {"epss_score": 0.04068, "epss_percentile": 0.88202}, "CVE-2006-1974": {"epss_score": 0.00453, "epss_percentile": 0.63227}, "CVE-2006-1975": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2006-1976": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-1977": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-1978": {"epss_score": 0.00936, "epss_percentile": 0.75688}, "CVE-2006-1979": {"epss_score": 0.045, "epss_percentile": 0.88765}, "CVE-2006-1980": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2006-1981": {"epss_score": 0.00071, "epss_percentile": 0.22119}, "CVE-2006-1982": {"epss_score": 0.44857, "epss_percentile": 0.97456}, "CVE-2006-1983": {"epss_score": 0.36226, "epss_percentile": 0.96962}, "CVE-2006-1984": {"epss_score": 0.05644, "epss_percentile": 0.9008}, "CVE-2006-1985": {"epss_score": 0.2217, "epss_percentile": 0.95603}, "CVE-2006-1986": {"epss_score": 0.04517, "epss_percentile": 0.88794}, "CVE-2006-1987": {"epss_score": 0.04517, "epss_percentile": 0.88794}, "CVE-2006-1988": {"epss_score": 0.01431, "epss_percentile": 0.80242}, "CVE-2006-1989": {"epss_score": 0.04489, "epss_percentile": 0.88755}, "CVE-2006-1990": {"epss_score": 0.01234, "epss_percentile": 0.78755}, "CVE-2006-1991": {"epss_score": 0.03647, "epss_percentile": 0.87501}, "CVE-2006-1992": {"epss_score": 0.55557, "epss_percentile": 0.97983}, "CVE-2006-1993": {"epss_score": 0.57321, "epss_percentile": 0.98059}, "CVE-2006-1994": {"epss_score": 0.067, "epss_percentile": 0.90956}, "CVE-2006-1995": {"epss_score": 0.09489, "epss_percentile": 0.9257}, "CVE-2006-1996": {"epss_score": 0.00631, "epss_percentile": 0.69715}, "CVE-2006-1997": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2006-1998": {"epss_score": 0.00188, "epss_percentile": 0.40919}, "CVE-2006-1999": {"epss_score": 0.13813, "epss_percentile": 0.94065}, "CVE-2006-20001": {"epss_score": 0.00704, "epss_percentile": 0.71569}, "CVE-2006-2000": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2001": {"epss_score": 0.08732, "epss_percentile": 0.92231}, "CVE-2006-2002": {"epss_score": 0.1528, "epss_percentile": 0.94399}, "CVE-2006-2003": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-2004": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-2005": {"epss_score": 0.10615, "epss_percentile": 0.93049}, "CVE-2006-2006": {"epss_score": 0.00708, "epss_percentile": 0.71671}, "CVE-2006-2007": {"epss_score": 0.10673, "epss_percentile": 0.93065}, "CVE-2006-2008": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2006-2009": {"epss_score": 0.04039, "epss_percentile": 0.88164}, "CVE-2006-2010": {"epss_score": 0.01139, "epss_percentile": 0.77945}, "CVE-2006-2011": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-2012": {"epss_score": 0.09346, "epss_percentile": 0.92511}, "CVE-2006-2013": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-2014": {"epss_score": 0.0103, "epss_percentile": 0.76844}, "CVE-2006-2015": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-2016": {"epss_score": 0.21986, "epss_percentile": 0.95581}, "CVE-2006-2017": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-2018": {"epss_score": 0.00518, "epss_percentile": 0.66103}, "CVE-2006-2019": {"epss_score": 0.1638, "epss_percentile": 0.94641}, "CVE-2006-2020": {"epss_score": 0.10869, "epss_percentile": 0.9314}, "CVE-2006-2021": {"epss_score": 0.00713, "epss_percentile": 0.71796}, "CVE-2006-2022": {"epss_score": 0.41191, "epss_percentile": 0.97257}, "CVE-2006-2023": {"epss_score": 0.02981, "epss_percentile": 0.86123}, "CVE-2006-2024": {"epss_score": 0.14955, "epss_percentile": 0.94333}, "CVE-2006-2025": {"epss_score": 0.07433, "epss_percentile": 0.91472}, "CVE-2006-2026": {"epss_score": 0.10278, "epss_percentile": 0.92924}, "CVE-2006-2027": {"epss_score": 0.05242, "epss_percentile": 0.89653}, "CVE-2006-2028": {"epss_score": 0.08044, "epss_percentile": 0.91848}, "CVE-2006-2029": {"epss_score": 0.02234, "epss_percentile": 0.84096}, "CVE-2006-2030": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2006-2031": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-2032": {"epss_score": 0.01073, "epss_percentile": 0.77294}, "CVE-2006-2033": {"epss_score": 0.00641, "epss_percentile": 0.69991}, "CVE-2006-2034": {"epss_score": 0.00349, "epss_percentile": 0.56866}, "CVE-2006-2035": {"epss_score": 0.00065, "epss_percentile": 0.20642}, "CVE-2006-2036": {"epss_score": 0.00093, "epss_percentile": 0.2667}, "CVE-2006-2037": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2006-2038": {"epss_score": 0.01462, "epss_percentile": 0.80439}, "CVE-2006-2039": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-2040": {"epss_score": 0.02816, "epss_percentile": 0.85734}, "CVE-2006-2041": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2006-2042": {"epss_score": 0.02483, "epss_percentile": 0.84879}, "CVE-2006-2043": {"epss_score": 0.00229, "epss_percentile": 0.45617}, "CVE-2006-2044": {"epss_score": 0.00698, "epss_percentile": 0.71424}, "CVE-2006-2045": {"epss_score": 0.0006, "epss_percentile": 0.19015}, "CVE-2006-2046": {"epss_score": 0.03641, "epss_percentile": 0.87491}, "CVE-2006-2047": {"epss_score": 0.00753, "epss_percentile": 0.72677}, "CVE-2006-2048": {"epss_score": 0.0801, "epss_percentile": 0.91826}, "CVE-2006-2049": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-2050": {"epss_score": 0.00474, "epss_percentile": 0.64153}, "CVE-2006-2051": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2006-2052": {"epss_score": 0.00548, "epss_percentile": 0.67276}, "CVE-2006-2053": {"epss_score": 0.01148, "epss_percentile": 0.78011}, "CVE-2006-2054": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-2055": {"epss_score": 0.20971, "epss_percentile": 0.95447}, "CVE-2006-2056": {"epss_score": 0.21024, "epss_percentile": 0.95453}, "CVE-2006-2057": {"epss_score": 0.00724, "epss_percentile": 0.72037}, "CVE-2006-2058": {"epss_score": 0.0086, "epss_percentile": 0.74541}, "CVE-2006-2059": {"epss_score": 0.11111, "epss_percentile": 0.93225}, "CVE-2006-2060": {"epss_score": 0.03033, "epss_percentile": 0.86254}, "CVE-2006-2061": {"epss_score": 0.02224, "epss_percentile": 0.84066}, "CVE-2006-2062": {"epss_score": 0.02157, "epss_percentile": 0.83814}, "CVE-2006-2063": {"epss_score": 0.08532, "epss_percentile": 0.92107}, "CVE-2006-2064": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2006-2065": {"epss_score": 0.01146, "epss_percentile": 0.77997}, "CVE-2006-2066": {"epss_score": 0.09706, "epss_percentile": 0.9267}, "CVE-2006-2067": {"epss_score": 0.00535, "epss_percentile": 0.66829}, "CVE-2006-2068": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-2069": {"epss_score": 0.00014, "epss_percentile": 0.01794}, "CVE-2006-2070": {"epss_score": 0.08606, "epss_percentile": 0.92147}, "CVE-2006-2071": {"epss_score": 0.00107, "epss_percentile": 0.29665}, "CVE-2006-2072": {"epss_score": 0.02112, "epss_percentile": 0.83648}, "CVE-2006-2073": {"epss_score": 0.05235, "epss_percentile": 0.89645}, "CVE-2006-2074": {"epss_score": 0.02197, "epss_percentile": 0.8396}, "CVE-2006-2075": {"epss_score": 0.01172, "epss_percentile": 0.78235}, "CVE-2006-2076": {"epss_score": 0.09741, "epss_percentile": 0.92687}, "CVE-2006-2077": {"epss_score": 0.0205, "epss_percentile": 0.83396}, "CVE-2006-2078": {"epss_score": 0.07598, "epss_percentile": 0.9156}, "CVE-2006-2079": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2006-2080": {"epss_score": 0.02297, "epss_percentile": 0.843}, "CVE-2006-2081": {"epss_score": 0.64803, "epss_percentile": 0.98392}, "CVE-2006-2082": {"epss_score": 0.00953, "epss_percentile": 0.7589}, "CVE-2006-2083": {"epss_score": 0.01506, "epss_percentile": 0.80744}, "CVE-2006-2084": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-2085": {"epss_score": 0.04977, "epss_percentile": 0.89356}, "CVE-2006-2086": {"epss_score": 0.74928, "epss_percentile": 0.98824}, "CVE-2006-2087": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-2088": {"epss_score": 0.00279, "epss_percentile": 0.5094}, "CVE-2006-2089": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2006-2090": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-2091": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-2092": {"epss_score": 0.02347, "epss_percentile": 0.84455}, "CVE-2006-2093": {"epss_score": 0.01085, "epss_percentile": 0.77407}, "CVE-2006-2094": {"epss_score": 0.38219, "epss_percentile": 0.97091}, "CVE-2006-2095": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2006-2096": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-2097": {"epss_score": 0.00954, "epss_percentile": 0.75907}, "CVE-2006-2098": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-2099": {"epss_score": 0.07648, "epss_percentile": 0.91601}, "CVE-2006-2100": {"epss_score": 0.0822, "epss_percentile": 0.91936}, "CVE-2006-2101": {"epss_score": 0.07648, "epss_percentile": 0.91601}, "CVE-2006-2102": {"epss_score": 0.0822, "epss_percentile": 0.91936}, "CVE-2006-2103": {"epss_score": 0.00349, "epss_percentile": 0.569}, "CVE-2006-2104": {"epss_score": 0.02028, "epss_percentile": 0.83324}, "CVE-2006-2105": {"epss_score": 0.00326, "epss_percentile": 0.5509}, "CVE-2006-2106": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2107": {"epss_score": 0.09015, "epss_percentile": 0.92366}, "CVE-2006-2108": {"epss_score": 0.07855, "epss_percentile": 0.91722}, "CVE-2006-2109": {"epss_score": 0.07101, "epss_percentile": 0.91252}, "CVE-2006-2110": {"epss_score": 0.00093, "epss_percentile": 0.2667}, "CVE-2006-2111": {"epss_score": 0.37835, "epss_percentile": 0.97072}, "CVE-2006-2112": {"epss_score": 0.02143, "epss_percentile": 0.83757}, "CVE-2006-2113": {"epss_score": 0.02435, "epss_percentile": 0.84739}, "CVE-2006-2114": {"epss_score": 0.05514, "epss_percentile": 0.89949}, "CVE-2006-2115": {"epss_score": 0.03344, "epss_percentile": 0.8695}, "CVE-2006-2116": {"epss_score": 0.03383, "epss_percentile": 0.87034}, "CVE-2006-2117": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-2118": {"epss_score": 0.00644, "epss_percentile": 0.70079}, "CVE-2006-2119": {"epss_score": 0.09049, "epss_percentile": 0.92379}, "CVE-2006-2120": {"epss_score": 0.00321, "epss_percentile": 0.5469}, "CVE-2006-2121": {"epss_score": 0.06953, "epss_percentile": 0.91142}, "CVE-2006-2122": {"epss_score": 0.0681, "epss_percentile": 0.91041}, "CVE-2006-2123": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2006-2124": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2006-2126": {"epss_score": 0.00542, "epss_percentile": 0.67064}, "CVE-2006-2127": {"epss_score": 0.01332, "epss_percentile": 0.79522}, "CVE-2006-2128": {"epss_score": 0.01343, "epss_percentile": 0.79604}, "CVE-2006-2129": {"epss_score": 0.0042, "epss_percentile": 0.61453}, "CVE-2006-2130": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-2131": {"epss_score": 0.0064, "epss_percentile": 0.69955}, "CVE-2006-2132": {"epss_score": 0.00464, "epss_percentile": 0.63703}, "CVE-2006-2133": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-2134": {"epss_score": 0.06324, "epss_percentile": 0.90671}, "CVE-2006-2135": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-2136": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2137": {"epss_score": 0.09178, "epss_percentile": 0.92433}, "CVE-2006-2138": {"epss_score": 0.07636, "epss_percentile": 0.91591}, "CVE-2006-2139": {"epss_score": 0.00847, "epss_percentile": 0.74349}, "CVE-2006-2140": {"epss_score": 0.00943, "epss_percentile": 0.75773}, "CVE-2006-2141": {"epss_score": 0.02222, "epss_percentile": 0.84053}, "CVE-2006-2142": {"epss_score": 0.08969, "epss_percentile": 0.92344}, "CVE-2006-2143": {"epss_score": 0.07636, "epss_percentile": 0.91591}, "CVE-2006-2144": {"epss_score": 0.05878, "epss_percentile": 0.90287}, "CVE-2006-2145": {"epss_score": 0.00585, "epss_percentile": 0.68429}, "CVE-2006-2146": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2147": {"epss_score": 0.00087, "epss_percentile": 0.25495}, "CVE-2006-2148": {"epss_score": 0.0611, "epss_percentile": 0.90487}, "CVE-2006-2149": {"epss_score": 0.10831, "epss_percentile": 0.93126}, "CVE-2006-2150": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2006-2151": {"epss_score": 0.17354, "epss_percentile": 0.94833}, "CVE-2006-2152": {"epss_score": 0.12101, "epss_percentile": 0.93566}, "CVE-2006-2153": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2154": {"epss_score": 0.0004, "epss_percentile": 0.12073}, "CVE-2006-2155": {"epss_score": 0.00067, "epss_percentile": 0.2102}, "CVE-2006-2156": {"epss_score": 0.13669, "epss_percentile": 0.9403}, "CVE-2006-2157": {"epss_score": 0.00434, "epss_percentile": 0.62312}, "CVE-2006-2158": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-2159": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-2160": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2161": {"epss_score": 0.0166, "epss_percentile": 0.8162}, "CVE-2006-2162": {"epss_score": 0.01322, "epss_percentile": 0.79452}, "CVE-2006-2163": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2006-2164": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2165": {"epss_score": 0.00355, "epss_percentile": 0.57266}, "CVE-2006-2166": {"epss_score": 0.00496, "epss_percentile": 0.65176}, "CVE-2006-2167": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2168": {"epss_score": 0.00644, "epss_percentile": 0.70079}, "CVE-2006-2169": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-2170": {"epss_score": 0.06646, "epss_percentile": 0.90913}, "CVE-2006-2171": {"epss_score": 0.0372, "epss_percentile": 0.87619}, "CVE-2006-2172": {"epss_score": 0.04459, "epss_percentile": 0.88718}, "CVE-2006-2173": {"epss_score": 0.00726, "epss_percentile": 0.72072}, "CVE-2006-2174": {"epss_score": 0.07636, "epss_percentile": 0.91591}, "CVE-2006-2175": {"epss_score": 0.0803, "epss_percentile": 0.9184}, "CVE-2006-2176": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2006-2177": {"epss_score": 0.03279, "epss_percentile": 0.8681}, "CVE-2006-2178": {"epss_score": 0.0072, "epss_percentile": 0.71964}, "CVE-2006-2179": {"epss_score": 0.00961, "epss_percentile": 0.75976}, "CVE-2006-2180": {"epss_score": 0.2002, "epss_percentile": 0.95276}, "CVE-2006-2181": {"epss_score": 0.08381, "epss_percentile": 0.92018}, "CVE-2006-2182": {"epss_score": 0.07793, "epss_percentile": 0.91684}, "CVE-2006-2183": {"epss_score": 0.00086, "epss_percentile": 0.25415}, "CVE-2006-2184": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2185": {"epss_score": 0.00368, "epss_percentile": 0.58213}, "CVE-2006-2186": {"epss_score": 0.0059, "epss_percentile": 0.6855}, "CVE-2006-2187": {"epss_score": 0.00494, "epss_percentile": 0.65066}, "CVE-2006-2188": {"epss_score": 0.02347, "epss_percentile": 0.84455}, "CVE-2006-2189": {"epss_score": 0.01053, "epss_percentile": 0.77097}, "CVE-2006-2190": {"epss_score": 0.0192, "epss_percentile": 0.82891}, "CVE-2006-2191": {"epss_score": 0.00537, "epss_percentile": 0.66895}, "CVE-2006-2193": {"epss_score": 0.0064, "epss_percentile": 0.69958}, "CVE-2006-2194": {"epss_score": 0.00055, "epss_percentile": 0.17482}, "CVE-2006-2195": {"epss_score": 0.04367, "epss_percentile": 0.88605}, "CVE-2006-2196": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2006-2197": {"epss_score": 0.01403, "epss_percentile": 0.80034}, "CVE-2006-2198": {"epss_score": 0.07757, "epss_percentile": 0.91662}, "CVE-2006-2199": {"epss_score": 0.10174, "epss_percentile": 0.9288}, "CVE-2006-2200": {"epss_score": 0.03547, "epss_percentile": 0.8733}, "CVE-2006-2201": {"epss_score": 0.00095, "epss_percentile": 0.27153}, "CVE-2006-2202": {"epss_score": 0.00986, "epss_percentile": 0.76336}, "CVE-2006-2203": {"epss_score": 0.00396, "epss_percentile": 0.59897}, "CVE-2006-2204": {"epss_score": 0.00428, "epss_percentile": 0.61955}, "CVE-2006-2205": {"epss_score": 0.00067, "epss_percentile": 0.21164}, "CVE-2006-2206": {"epss_score": 0.00775, "epss_percentile": 0.73084}, "CVE-2006-2208": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2006-2209": {"epss_score": 0.00553, "epss_percentile": 0.6742}, "CVE-2006-2210": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2006-2211": {"epss_score": 0.05018, "epss_percentile": 0.89399}, "CVE-2006-2212": {"epss_score": 0.71543, "epss_percentile": 0.98673}, "CVE-2006-2213": {"epss_score": 0.02458, "epss_percentile": 0.84814}, "CVE-2006-2214": {"epss_score": 0.00858, "epss_percentile": 0.74507}, "CVE-2006-2216": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2006-2217": {"epss_score": 0.00268, "epss_percentile": 0.50101}, "CVE-2006-2218": {"epss_score": 0.62818, "epss_percentile": 0.98309}, "CVE-2006-2219": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2006-2220": {"epss_score": 0.00465, "epss_percentile": 0.63748}, "CVE-2006-2221": {"epss_score": 0.00067, "epss_percentile": 0.21117}, "CVE-2006-2222": {"epss_score": 0.05357, "epss_percentile": 0.89781}, "CVE-2006-2223": {"epss_score": 0.12798, "epss_percentile": 0.93777}, "CVE-2006-2224": {"epss_score": 0.20175, "epss_percentile": 0.95298}, "CVE-2006-2225": {"epss_score": 0.14486, "epss_percentile": 0.94221}, "CVE-2006-2226": {"epss_score": 0.085, "epss_percentile": 0.92085}, "CVE-2006-2227": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2006-2228": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2006-2229": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-2230": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-2231": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2232": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-2233": {"epss_score": 0.20919, "epss_percentile": 0.95443}, "CVE-2006-2234": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2006-2235": {"epss_score": 0.00808, "epss_percentile": 0.73685}, "CVE-2006-2236": {"epss_score": 0.04065, "epss_percentile": 0.88197}, "CVE-2006-2237": {"epss_score": 0.90596, "epss_percentile": 0.99591}, "CVE-2006-2238": {"epss_score": 0.31706, "epss_percentile": 0.96642}, "CVE-2006-2239": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2240": {"epss_score": 0.01172, "epss_percentile": 0.78235}, "CVE-2006-2241": {"epss_score": 0.04133, "epss_percentile": 0.88302}, "CVE-2006-2242": {"epss_score": 0.40236, "epss_percentile": 0.97208}, "CVE-2006-2243": {"epss_score": 0.00419, "epss_percentile": 0.61369}, "CVE-2006-2244": {"epss_score": 0.00419, "epss_percentile": 0.61369}, "CVE-2006-2245": {"epss_score": 0.09473, "epss_percentile": 0.92563}, "CVE-2006-2246": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-2247": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-2248": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-2249": {"epss_score": 0.09888, "epss_percentile": 0.92755}, "CVE-2006-2250": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-2251": {"epss_score": 0.00682, "epss_percentile": 0.71069}, "CVE-2006-2252": {"epss_score": 0.05202, "epss_percentile": 0.89606}, "CVE-2006-2253": {"epss_score": 0.11257, "epss_percentile": 0.93281}, "CVE-2006-2254": {"epss_score": 0.05147, "epss_percentile": 0.89544}, "CVE-2006-2255": {"epss_score": 0.01111, "epss_percentile": 0.77669}, "CVE-2006-2256": {"epss_score": 0.12764, "epss_percentile": 0.93767}, "CVE-2006-2257": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2258": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-2259": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2260": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2261": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-2262": {"epss_score": 0.04019, "epss_percentile": 0.88127}, "CVE-2006-2263": {"epss_score": 0.01951, "epss_percentile": 0.83019}, "CVE-2006-2264": {"epss_score": 0.00741, "epss_percentile": 0.72443}, "CVE-2006-2265": {"epss_score": 0.04454, "epss_percentile": 0.88711}, "CVE-2006-2266": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-2267": {"epss_score": 0.02898, "epss_percentile": 0.85936}, "CVE-2006-2268": {"epss_score": 0.01125, "epss_percentile": 0.77802}, "CVE-2006-2269": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-2270": {"epss_score": 0.18515, "epss_percentile": 0.95026}, "CVE-2006-2271": {"epss_score": 0.08126, "epss_percentile": 0.91892}, "CVE-2006-2272": {"epss_score": 0.08126, "epss_percentile": 0.91892}, "CVE-2006-2273": {"epss_score": 0.04237, "epss_percentile": 0.8843}, "CVE-2006-2274": {"epss_score": 0.09301, "epss_percentile": 0.92489}, "CVE-2006-2275": {"epss_score": 0.03168, "epss_percentile": 0.86544}, "CVE-2006-2276": {"epss_score": 0.0014, "epss_percentile": 0.34751}, "CVE-2006-2277": {"epss_score": 0.09523, "epss_percentile": 0.92584}, "CVE-2006-2278": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-2279": {"epss_score": 0.01462, "epss_percentile": 0.80439}, "CVE-2006-2280": {"epss_score": 0.04655, "epss_percentile": 0.8897}, "CVE-2006-2281": {"epss_score": 0.01494, "epss_percentile": 0.8065}, "CVE-2006-2282": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2283": {"epss_score": 0.01495, "epss_percentile": 0.80657}, "CVE-2006-2284": {"epss_score": 0.09381, "epss_percentile": 0.92524}, "CVE-2006-2285": {"epss_score": 0.06302, "epss_percentile": 0.90657}, "CVE-2006-2286": {"epss_score": 0.01112, "epss_percentile": 0.77674}, "CVE-2006-2287": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-2288": {"epss_score": 0.00074, "epss_percentile": 0.22707}, "CVE-2006-2289": {"epss_score": 0.00119, "epss_percentile": 0.31553}, "CVE-2006-2290": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-2291": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2292": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2006-2293": {"epss_score": 0.00897, "epss_percentile": 0.75123}, "CVE-2006-2294": {"epss_score": 0.00976, "epss_percentile": 0.76205}, "CVE-2006-2295": {"epss_score": 0.05123, "epss_percentile": 0.89522}, "CVE-2006-2296": {"epss_score": 0.00897, "epss_percentile": 0.75123}, "CVE-2006-2297": {"epss_score": 0.61954, "epss_percentile": 0.98269}, "CVE-2006-2298": {"epss_score": 0.02029, "epss_percentile": 0.83327}, "CVE-2006-2300": {"epss_score": 0.01735, "epss_percentile": 0.82008}, "CVE-2006-2301": {"epss_score": 0.01139, "epss_percentile": 0.77945}, "CVE-2006-2302": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-2303": {"epss_score": 0.00757, "epss_percentile": 0.72751}, "CVE-2006-2304": {"epss_score": 0.13229, "epss_percentile": 0.93905}, "CVE-2006-2305": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2306": {"epss_score": 0.0071, "epss_percentile": 0.71713}, "CVE-2006-2307": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2308": {"epss_score": 0.0223, "epss_percentile": 0.84085}, "CVE-2006-2309": {"epss_score": 0.00229, "epss_percentile": 0.4561}, "CVE-2006-2310": {"epss_score": 0.05553, "epss_percentile": 0.89987}, "CVE-2006-2311": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2006-2312": {"epss_score": 0.04379, "epss_percentile": 0.88622}, "CVE-2006-2313": {"epss_score": 0.02056, "epss_percentile": 0.83425}, "CVE-2006-2314": {"epss_score": 0.02417, "epss_percentile": 0.84693}, "CVE-2006-2315": {"epss_score": 0.13402, "epss_percentile": 0.93953}, "CVE-2006-2316": {"epss_score": 0.00199, "epss_percentile": 0.42145}, "CVE-2006-2317": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2006-2318": {"epss_score": 0.01119, "epss_percentile": 0.77753}, "CVE-2006-2319": {"epss_score": 0.00909, "epss_percentile": 0.75312}, "CVE-2006-2320": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-2321": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-2322": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-2323": {"epss_score": 0.11505, "epss_percentile": 0.93386}, "CVE-2006-2324": {"epss_score": 0.00626, "epss_percentile": 0.69607}, "CVE-2006-2325": {"epss_score": 0.00828, "epss_percentile": 0.73993}, "CVE-2006-2326": {"epss_score": 0.00708, "epss_percentile": 0.71671}, "CVE-2006-2327": {"epss_score": 0.20626, "epss_percentile": 0.95388}, "CVE-2006-2328": {"epss_score": 0.00326, "epss_percentile": 0.55045}, "CVE-2006-2329": {"epss_score": 0.00581, "epss_percentile": 0.68261}, "CVE-2006-2330": {"epss_score": 0.11474, "epss_percentile": 0.93378}, "CVE-2006-2331": {"epss_score": 0.1107, "epss_percentile": 0.93209}, "CVE-2006-2332": {"epss_score": 0.00804, "epss_percentile": 0.73611}, "CVE-2006-2333": {"epss_score": 0.00385, "epss_percentile": 0.59195}, "CVE-2006-2334": {"epss_score": 0.03193, "epss_percentile": 0.86605}, "CVE-2006-2335": {"epss_score": 0.0137, "epss_percentile": 0.798}, "CVE-2006-2336": {"epss_score": 0.00757, "epss_percentile": 0.72758}, "CVE-2006-2337": {"epss_score": 0.00181, "epss_percentile": 0.40022}, "CVE-2006-2338": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-2339": {"epss_score": 0.006, "epss_percentile": 0.68815}, "CVE-2006-2340": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2341": {"epss_score": 0.101, "epss_percentile": 0.92849}, "CVE-2006-2342": {"epss_score": 0.01246, "epss_percentile": 0.78856}, "CVE-2006-2343": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-2344": {"epss_score": 0.00474, "epss_percentile": 0.64153}, "CVE-2006-2345": {"epss_score": 0.00279, "epss_percentile": 0.5094}, "CVE-2006-2346": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-2347": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2006-2348": {"epss_score": 0.00641, "epss_percentile": 0.69991}, "CVE-2006-2349": {"epss_score": 0.10603, "epss_percentile": 0.93043}, "CVE-2006-2351": {"epss_score": 0.00901, "epss_percentile": 0.75167}, "CVE-2006-2352": {"epss_score": 0.00069, "epss_percentile": 0.21434}, "CVE-2006-2353": {"epss_score": 0.00154, "epss_percentile": 0.36694}, "CVE-2006-2354": {"epss_score": 0.00205, "epss_percentile": 0.42706}, "CVE-2006-2355": {"epss_score": 0.01402, "epss_percentile": 0.80014}, "CVE-2006-2356": {"epss_score": 0.00376, "epss_percentile": 0.58682}, "CVE-2006-2357": {"epss_score": 0.00298, "epss_percentile": 0.52822}, "CVE-2006-2358": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-2359": {"epss_score": 0.00558, "epss_percentile": 0.67587}, "CVE-2006-2360": {"epss_score": 0.00558, "epss_percentile": 0.67587}, "CVE-2006-2361": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-2362": {"epss_score": 0.05512, "epss_percentile": 0.89947}, "CVE-2006-2363": {"epss_score": 0.01355, "epss_percentile": 0.79709}, "CVE-2006-2364": {"epss_score": 0.00248, "epss_percentile": 0.47961}, "CVE-2006-2365": {"epss_score": 0.00412, "epss_percentile": 0.60926}, "CVE-2006-2366": {"epss_score": 0.00392, "epss_percentile": 0.59666}, "CVE-2006-2367": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-2368": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-2369": {"epss_score": 0.90872, "epss_percentile": 0.99606}, "CVE-2006-2370": {"epss_score": 0.79591, "epss_percentile": 0.99046}, "CVE-2006-2371": {"epss_score": 0.51213, "epss_percentile": 0.97769}, "CVE-2006-2372": {"epss_score": 0.87323, "epss_percentile": 0.99423}, "CVE-2006-2373": {"epss_score": 0.19122, "epss_percentile": 0.95133}, "CVE-2006-2374": {"epss_score": 0.00562, "epss_percentile": 0.67681}, "CVE-2006-2376": {"epss_score": 0.6459, "epss_percentile": 0.98385}, "CVE-2006-2378": {"epss_score": 0.62392, "epss_percentile": 0.98291}, "CVE-2006-2379": {"epss_score": 0.61702, "epss_percentile": 0.9826}, "CVE-2006-2380": {"epss_score": 0.19638, "epss_percentile": 0.95219}, "CVE-2006-2382": {"epss_score": 0.71985, "epss_percentile": 0.98691}, "CVE-2006-2383": {"epss_score": 0.68973, "epss_percentile": 0.98571}, "CVE-2006-2384": {"epss_score": 0.24782, "epss_percentile": 0.95954}, "CVE-2006-2385": {"epss_score": 0.18242, "epss_percentile": 0.94979}, "CVE-2006-2386": {"epss_score": 0.55112, "epss_percentile": 0.97961}, "CVE-2006-2387": {"epss_score": 0.3985, "epss_percentile": 0.97183}, "CVE-2006-2388": {"epss_score": 0.40206, "epss_percentile": 0.97206}, "CVE-2006-2389": {"epss_score": 0.74233, "epss_percentile": 0.98793}, "CVE-2006-2390": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2006-2391": {"epss_score": 0.32308, "epss_percentile": 0.96688}, "CVE-2006-2392": {"epss_score": 0.10831, "epss_percentile": 0.93126}, "CVE-2006-2393": {"epss_score": 0.10905, "epss_percentile": 0.9315}, "CVE-2006-2394": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-2395": {"epss_score": 0.07946, "epss_percentile": 0.91782}, "CVE-2006-2396": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2006-2397": {"epss_score": 0.01044, "epss_percentile": 0.77004}, "CVE-2006-2398": {"epss_score": 0.05931, "epss_percentile": 0.90337}, "CVE-2006-2399": {"epss_score": 0.13984, "epss_percentile": 0.94108}, "CVE-2006-2400": {"epss_score": 0.13193, "epss_percentile": 0.93896}, "CVE-2006-2401": {"epss_score": 0.10297, "epss_percentile": 0.92932}, "CVE-2006-2402": {"epss_score": 0.11118, "epss_percentile": 0.93228}, "CVE-2006-2403": {"epss_score": 0.01154, "epss_percentile": 0.78063}, "CVE-2006-2404": {"epss_score": 0.06899, "epss_percentile": 0.91102}, "CVE-2006-2405": {"epss_score": 0.17692, "epss_percentile": 0.9489}, "CVE-2006-2406": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2006-2407": {"epss_score": 0.79892, "epss_percentile": 0.99059}, "CVE-2006-2408": {"epss_score": 0.1963, "epss_percentile": 0.95217}, "CVE-2006-2409": {"epss_score": 0.00242, "epss_percentile": 0.47382}, "CVE-2006-2410": {"epss_score": 0.10256, "epss_percentile": 0.92915}, "CVE-2006-2411": {"epss_score": 0.14369, "epss_percentile": 0.94195}, "CVE-2006-2412": {"epss_score": 0.10256, "epss_percentile": 0.92915}, "CVE-2006-2413": {"epss_score": 0.13144, "epss_percentile": 0.93884}, "CVE-2006-2414": {"epss_score": 0.01086, "epss_percentile": 0.77424}, "CVE-2006-2415": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2416": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2417": {"epss_score": 0.00579, "epss_percentile": 0.68208}, "CVE-2006-2418": {"epss_score": 0.0368, "epss_percentile": 0.87558}, "CVE-2006-2419": {"epss_score": 0.00336, "epss_percentile": 0.55929}, "CVE-2006-2420": {"epss_score": 0.00687, "epss_percentile": 0.71178}, "CVE-2006-2421": {"epss_score": 0.0331, "epss_percentile": 0.86887}, "CVE-2006-2422": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-2423": {"epss_score": 0.01044, "epss_percentile": 0.77006}, "CVE-2006-2424": {"epss_score": 0.10499, "epss_percentile": 0.93011}, "CVE-2006-2425": {"epss_score": 0.01027, "epss_percentile": 0.76812}, "CVE-2006-2426": {"epss_score": 0.27895, "epss_percentile": 0.96292}, "CVE-2006-2427": {"epss_score": 0.00047, "epss_percentile": 0.14792}, "CVE-2006-2428": {"epss_score": 0.01038, "epss_percentile": 0.76937}, "CVE-2006-2429": {"epss_score": 0.00941, "epss_percentile": 0.75757}, "CVE-2006-2430": {"epss_score": 0.02068, "epss_percentile": 0.83466}, "CVE-2006-2431": {"epss_score": 0.01437, "epss_percentile": 0.80283}, "CVE-2006-2432": {"epss_score": 0.01494, "epss_percentile": 0.80648}, "CVE-2006-2433": {"epss_score": 0.00941, "epss_percentile": 0.75757}, "CVE-2006-2434": {"epss_score": 0.00549, "epss_percentile": 0.67306}, "CVE-2006-2435": {"epss_score": 0.00934, "epss_percentile": 0.75651}, "CVE-2006-2436": {"epss_score": 0.00745, "epss_percentile": 0.72528}, "CVE-2006-2437": {"epss_score": 0.05128, "epss_percentile": 0.89527}, "CVE-2006-2438": {"epss_score": 0.01669, "epss_percentile": 0.81667}, "CVE-2006-2439": {"epss_score": 0.18651, "epss_percentile": 0.95047}, "CVE-2006-2440": {"epss_score": 0.0183, "epss_percentile": 0.82447}, "CVE-2006-2441": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2006-2442": {"epss_score": 0.00055, "epss_percentile": 0.17645}, "CVE-2006-2443": {"epss_score": 0.00044, "epss_percentile": 0.13646}, "CVE-2006-2444": {"epss_score": 0.69801, "epss_percentile": 0.98604}, "CVE-2006-2445": {"epss_score": 0.00086, "epss_percentile": 0.25417}, "CVE-2006-2446": {"epss_score": 0.01942, "epss_percentile": 0.82984}, "CVE-2006-2447": {"epss_score": 0.744, "epss_percentile": 0.98798}, "CVE-2006-2448": {"epss_score": 0.00086, "epss_percentile": 0.25417}, "CVE-2006-2449": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2006-2450": {"epss_score": 0.03222, "epss_percentile": 0.86676}, "CVE-2006-2451": {"epss_score": 0.06758, "epss_percentile": 0.91007}, "CVE-2006-2452": {"epss_score": 0.00102, "epss_percentile": 0.28761}, "CVE-2006-2453": {"epss_score": 0.03931, "epss_percentile": 0.87974}, "CVE-2006-2458": {"epss_score": 0.19115, "epss_percentile": 0.95131}, "CVE-2006-2459": {"epss_score": 0.0094, "epss_percentile": 0.75738}, "CVE-2006-2460": {"epss_score": 0.06078, "epss_percentile": 0.9046}, "CVE-2006-2461": {"epss_score": 0.00478, "epss_percentile": 0.64386}, "CVE-2006-2462": {"epss_score": 0.00393, "epss_percentile": 0.59705}, "CVE-2006-2463": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2006-2464": {"epss_score": 0.00088, "epss_percentile": 0.25678}, "CVE-2006-2465": {"epss_score": 0.24283, "epss_percentile": 0.959}, "CVE-2006-2466": {"epss_score": 0.00393, "epss_percentile": 0.59705}, "CVE-2006-2467": {"epss_score": 0.00315, "epss_percentile": 0.54176}, "CVE-2006-2468": {"epss_score": 0.00315, "epss_percentile": 0.54176}, "CVE-2006-2469": {"epss_score": 0.00692, "epss_percentile": 0.71307}, "CVE-2006-2470": {"epss_score": 0.00504, "epss_percentile": 0.65547}, "CVE-2006-2471": {"epss_score": 0.00393, "epss_percentile": 0.59705}, "CVE-2006-2472": {"epss_score": 0.00077, "epss_percentile": 0.23463}, "CVE-2006-2473": {"epss_score": 0.00864, "epss_percentile": 0.7461}, "CVE-2006-2474": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2006-2475": {"epss_score": 0.0075, "epss_percentile": 0.72621}, "CVE-2006-2476": {"epss_score": 0.01008, "epss_percentile": 0.76572}, "CVE-2006-2477": {"epss_score": 0.00439, "epss_percentile": 0.62589}, "CVE-2006-2478": {"epss_score": 0.00658, "epss_percentile": 0.70494}, "CVE-2006-2479": {"epss_score": 0.0072, "epss_percentile": 0.71966}, "CVE-2006-2480": {"epss_score": 0.25823, "epss_percentile": 0.96076}, "CVE-2006-2481": {"epss_score": 0.09395, "epss_percentile": 0.9253}, "CVE-2006-2482": {"epss_score": 0.02085, "epss_percentile": 0.83546}, "CVE-2006-2483": {"epss_score": 0.11099, "epss_percentile": 0.93219}, "CVE-2006-2484": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-2485": {"epss_score": 0.11423, "epss_percentile": 0.93344}, "CVE-2006-2486": {"epss_score": 0.00326, "epss_percentile": 0.55045}, "CVE-2006-2487": {"epss_score": 0.17062, "epss_percentile": 0.94766}, "CVE-2006-2488": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-2489": {"epss_score": 0.01915, "epss_percentile": 0.82856}, "CVE-2006-2490": {"epss_score": 0.01203, "epss_percentile": 0.78495}, "CVE-2006-2491": {"epss_score": 0.10962, "epss_percentile": 0.93178}, "CVE-2006-2492": {"epss_score": 0.7722, "epss_percentile": 0.98926}, "CVE-2006-2494": {"epss_score": 0.24045, "epss_percentile": 0.95849}, "CVE-2006-2495": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-2496": {"epss_score": 0.24917, "epss_percentile": 0.95965}, "CVE-2006-2497": {"epss_score": 0.01898, "epss_percentile": 0.82761}, "CVE-2006-2498": {"epss_score": 0.01059, "epss_percentile": 0.77148}, "CVE-2006-2499": {"epss_score": 0.00879, "epss_percentile": 0.74844}, "CVE-2006-2500": {"epss_score": 0.0192, "epss_percentile": 0.82891}, "CVE-2006-2501": {"epss_score": 0.06441, "epss_percentile": 0.90759}, "CVE-2006-2502": {"epss_score": 0.71449, "epss_percentile": 0.98668}, "CVE-2006-2503": {"epss_score": 0.006, "epss_percentile": 0.68815}, "CVE-2006-2504": {"epss_score": 0.01995, "epss_percentile": 0.83193}, "CVE-2006-2505": {"epss_score": 0.01767, "epss_percentile": 0.82174}, "CVE-2006-2506": {"epss_score": 0.02192, "epss_percentile": 0.83942}, "CVE-2006-2507": {"epss_score": 0.08401, "epss_percentile": 0.92032}, "CVE-2006-2508": {"epss_score": 0.03095, "epss_percentile": 0.86403}, "CVE-2006-2509": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-2510": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2006-2511": {"epss_score": 0.00631, "epss_percentile": 0.69712}, "CVE-2006-2512": {"epss_score": 0.00695, "epss_percentile": 0.71374}, "CVE-2006-2513": {"epss_score": 0.01272, "epss_percentile": 0.79084}, "CVE-2006-2514": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-2515": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-2516": {"epss_score": 0.05235, "epss_percentile": 0.89647}, "CVE-2006-2517": {"epss_score": 0.00731, "epss_percentile": 0.72163}, "CVE-2006-2518": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-2519": {"epss_score": 0.01858, "epss_percentile": 0.8258}, "CVE-2006-2520": {"epss_score": 0.01471, "epss_percentile": 0.80505}, "CVE-2006-2521": {"epss_score": 0.06708, "epss_percentile": 0.9096}, "CVE-2006-2522": {"epss_score": 0.01666, "epss_percentile": 0.81651}, "CVE-2006-2523": {"epss_score": 0.08293, "epss_percentile": 0.91974}, "CVE-2006-2524": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-2525": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2006-2526": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-2527": {"epss_score": 0.07527, "epss_percentile": 0.91518}, "CVE-2006-2528": {"epss_score": 0.03636, "epss_percentile": 0.87483}, "CVE-2006-2529": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2006-2530": {"epss_score": 0.01471, "epss_percentile": 0.805}, "CVE-2006-2531": {"epss_score": 0.05492, "epss_percentile": 0.89931}, "CVE-2006-2532": {"epss_score": 0.00315, "epss_percentile": 0.54207}, "CVE-2006-2533": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2534": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2006-2535": {"epss_score": 0.01752, "epss_percentile": 0.82107}, "CVE-2006-2536": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2537": {"epss_score": 0.06327, "epss_percentile": 0.90672}, "CVE-2006-2538": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2006-2539": {"epss_score": 0.00065, "epss_percentile": 0.20557}, "CVE-2006-2540": {"epss_score": 0.00408, "epss_percentile": 0.60654}, "CVE-2006-2541": {"epss_score": 0.01976, "epss_percentile": 0.83123}, "CVE-2006-2542": {"epss_score": 0.00044, "epss_percentile": 0.13475}, "CVE-2006-2543": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2544": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-2545": {"epss_score": 0.00475, "epss_percentile": 0.64244}, "CVE-2006-2546": {"epss_score": 0.00371, "epss_percentile": 0.58362}, "CVE-2006-2547": {"epss_score": 0.01521, "epss_percentile": 0.80827}, "CVE-2006-2548": {"epss_score": 0.3315, "epss_percentile": 0.9675}, "CVE-2006-2549": {"epss_score": 0.04134, "epss_percentile": 0.88304}, "CVE-2006-2550": {"epss_score": 0.05249, "epss_percentile": 0.89663}, "CVE-2006-2551": {"epss_score": 0.00085, "epss_percentile": 0.25091}, "CVE-2006-2552": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2006-2553": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2554": {"epss_score": 0.18323, "epss_percentile": 0.94995}, "CVE-2006-2555": {"epss_score": 0.1638, "epss_percentile": 0.94641}, "CVE-2006-2556": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2557": {"epss_score": 0.13679, "epss_percentile": 0.94033}, "CVE-2006-2558": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2559": {"epss_score": 0.00552, "epss_percentile": 0.67386}, "CVE-2006-2560": {"epss_score": 0.00363, "epss_percentile": 0.57827}, "CVE-2006-2561": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2006-2562": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2006-2563": {"epss_score": 0.00349, "epss_percentile": 0.56857}, "CVE-2006-2564": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2565": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2006-2566": {"epss_score": 0.0076, "epss_percentile": 0.72801}, "CVE-2006-2567": {"epss_score": 0.00416, "epss_percentile": 0.61177}, "CVE-2006-2568": {"epss_score": 0.11336, "epss_percentile": 0.93314}, "CVE-2006-2569": {"epss_score": 0.0103, "epss_percentile": 0.76849}, "CVE-2006-2570": {"epss_score": 0.04945, "epss_percentile": 0.89317}, "CVE-2006-2571": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-2572": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-2573": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-2574": {"epss_score": 0.00061, "epss_percentile": 0.1931}, "CVE-2006-2575": {"epss_score": 0.12171, "epss_percentile": 0.93589}, "CVE-2006-2576": {"epss_score": 0.12836, "epss_percentile": 0.93798}, "CVE-2006-2577": {"epss_score": 0.01407, "epss_percentile": 0.80055}, "CVE-2006-2578": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-2579": {"epss_score": 0.09569, "epss_percentile": 0.92604}, "CVE-2006-2580": {"epss_score": 0.02115, "epss_percentile": 0.83658}, "CVE-2006-2581": {"epss_score": 0.00409, "epss_percentile": 0.607}, "CVE-2006-2582": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-2583": {"epss_score": 0.07115, "epss_percentile": 0.9126}, "CVE-2006-2584": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2585": {"epss_score": 0.00315, "epss_percentile": 0.54207}, "CVE-2006-2586": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-2587": {"epss_score": 0.14214, "epss_percentile": 0.94164}, "CVE-2006-2588": {"epss_score": 0.00392, "epss_percentile": 0.59666}, "CVE-2006-2589": {"epss_score": 0.00315, "epss_percentile": 0.54207}, "CVE-2006-2590": {"epss_score": 0.00326, "epss_percentile": 0.55045}, "CVE-2006-2591": {"epss_score": 0.00396, "epss_percentile": 0.59897}, "CVE-2006-2592": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-2605": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-2606": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2607": {"epss_score": 0.00044, "epss_percentile": 0.13605}, "CVE-2006-2608": {"epss_score": 0.04655, "epss_percentile": 0.8897}, "CVE-2006-2609": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-2610": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-2611": {"epss_score": 0.01413, "epss_percentile": 0.80122}, "CVE-2006-2612": {"epss_score": 0.00075, "epss_percentile": 0.2307}, "CVE-2006-2613": {"epss_score": 0.01447, "epss_percentile": 0.80329}, "CVE-2006-2614": {"epss_score": 0.00069, "epss_percentile": 0.21477}, "CVE-2006-2615": {"epss_score": 0.01079, "epss_percentile": 0.77356}, "CVE-2006-2616": {"epss_score": 0.01139, "epss_percentile": 0.77942}, "CVE-2006-2617": {"epss_score": 0.00812, "epss_percentile": 0.7375}, "CVE-2006-2618": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2629": {"epss_score": 0.00178, "epss_percentile": 0.39737}, "CVE-2006-2630": {"epss_score": 0.78935, "epss_percentile": 0.99012}, "CVE-2006-2631": {"epss_score": 0.0042, "epss_percentile": 0.61453}, "CVE-2006-2632": {"epss_score": 0.00393, "epss_percentile": 0.59727}, "CVE-2006-2633": {"epss_score": 0.00445, "epss_percentile": 0.62861}, "CVE-2006-2634": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2006-2635": {"epss_score": 0.11904, "epss_percentile": 0.9351}, "CVE-2006-2636": {"epss_score": 0.08193, "epss_percentile": 0.91923}, "CVE-2006-2637": {"epss_score": 0.0127, "epss_percentile": 0.79047}, "CVE-2006-2638": {"epss_score": 0.00897, "epss_percentile": 0.75123}, "CVE-2006-2639": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-2640": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2641": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2642": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2643": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-2644": {"epss_score": 0.01038, "epss_percentile": 0.76934}, "CVE-2006-2645": {"epss_score": 0.03326, "epss_percentile": 0.86922}, "CVE-2006-2646": {"epss_score": 0.04973, "epss_percentile": 0.89353}, "CVE-2006-2647": {"epss_score": 0.00051, "epss_percentile": 0.16233}, "CVE-2006-2648": {"epss_score": 0.08107, "epss_percentile": 0.91882}, "CVE-2006-2649": {"epss_score": 0.06089, "epss_percentile": 0.90472}, "CVE-2006-2650": {"epss_score": 0.03034, "epss_percentile": 0.86255}, "CVE-2006-2651": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-2652": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-2653": {"epss_score": 0.00695, "epss_percentile": 0.71373}, "CVE-2006-2654": {"epss_score": 0.00632, "epss_percentile": 0.69748}, "CVE-2006-2655": {"epss_score": 0.00438, "epss_percentile": 0.62569}, "CVE-2006-2656": {"epss_score": 0.15208, "epss_percentile": 0.94384}, "CVE-2006-2658": {"epss_score": 0.00666, "epss_percentile": 0.70679}, "CVE-2006-2659": {"epss_score": 0.03561, "epss_percentile": 0.87354}, "CVE-2006-2660": {"epss_score": 0.00417, "epss_percentile": 0.6125}, "CVE-2006-2661": {"epss_score": 0.12644, "epss_percentile": 0.93738}, "CVE-2006-2662": {"epss_score": 0.00071, "epss_percentile": 0.22139}, "CVE-2006-2663": {"epss_score": 0.00553, "epss_percentile": 0.67432}, "CVE-2006-2664": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2665": {"epss_score": 0.1035, "epss_percentile": 0.92954}, "CVE-2006-2666": {"epss_score": 0.15153, "epss_percentile": 0.94374}, "CVE-2006-2667": {"epss_score": 0.32191, "epss_percentile": 0.96678}, "CVE-2006-2668": {"epss_score": 0.09457, "epss_percentile": 0.92556}, "CVE-2006-2669": {"epss_score": 0.00872, "epss_percentile": 0.74733}, "CVE-2006-2670": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2671": {"epss_score": 0.00326, "epss_percentile": 0.55045}, "CVE-2006-2672": {"epss_score": 0.01886, "epss_percentile": 0.82713}, "CVE-2006-2673": {"epss_score": 0.0192, "epss_percentile": 0.82891}, "CVE-2006-2674": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-2675": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2006-2676": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-2677": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2006-2678": {"epss_score": 0.01184, "epss_percentile": 0.78328}, "CVE-2006-2679": {"epss_score": 0.0005, "epss_percentile": 0.15886}, "CVE-2006-2680": {"epss_score": 0.06183, "epss_percentile": 0.90539}, "CVE-2006-2681": {"epss_score": 0.02483, "epss_percentile": 0.8488}, "CVE-2006-2682": {"epss_score": 0.06684, "epss_percentile": 0.90943}, "CVE-2006-2683": {"epss_score": 0.05726, "epss_percentile": 0.90157}, "CVE-2006-2684": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2685": {"epss_score": 0.85605, "epss_percentile": 0.99341}, "CVE-2006-2686": {"epss_score": 0.09893, "epss_percentile": 0.92756}, "CVE-2006-2687": {"epss_score": 0.00439, "epss_percentile": 0.62589}, "CVE-2006-2688": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2006-2689": {"epss_score": 0.00726, "epss_percentile": 0.72065}, "CVE-2006-2690": {"epss_score": 0.00461, "epss_percentile": 0.63556}, "CVE-2006-2691": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2692": {"epss_score": 0.01007, "epss_percentile": 0.76561}, "CVE-2006-2693": {"epss_score": 0.01354, "epss_percentile": 0.79704}, "CVE-2006-2694": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2006-2695": {"epss_score": 0.02047, "epss_percentile": 0.8339}, "CVE-2006-2696": {"epss_score": 0.00726, "epss_percentile": 0.72079}, "CVE-2006-2697": {"epss_score": 0.00849, "epss_percentile": 0.74368}, "CVE-2006-2698": {"epss_score": 0.01066, "epss_percentile": 0.7722}, "CVE-2006-2699": {"epss_score": 0.01395, "epss_percentile": 0.79975}, "CVE-2006-2700": {"epss_score": 0.01037, "epss_percentile": 0.76921}, "CVE-2006-2701": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-2702": {"epss_score": 0.0144, "epss_percentile": 0.80295}, "CVE-2006-2703": {"epss_score": 0.00338, "epss_percentile": 0.56154}, "CVE-2006-2704": {"epss_score": 0.01506, "epss_percentile": 0.80744}, "CVE-2006-2705": {"epss_score": 0.01506, "epss_percentile": 0.80749}, "CVE-2006-2706": {"epss_score": 0.01506, "epss_percentile": 0.80749}, "CVE-2006-2707": {"epss_score": 0.00705, "epss_percentile": 0.71584}, "CVE-2006-2708": {"epss_score": 0.02377, "epss_percentile": 0.84555}, "CVE-2006-2709": {"epss_score": 0.05698, "epss_percentile": 0.9013}, "CVE-2006-2710": {"epss_score": 0.00831, "epss_percentile": 0.7404}, "CVE-2006-2711": {"epss_score": 0.02731, "epss_percentile": 0.85538}, "CVE-2006-2712": {"epss_score": 0.04725, "epss_percentile": 0.89063}, "CVE-2006-2713": {"epss_score": 0.02731, "epss_percentile": 0.85538}, "CVE-2006-2714": {"epss_score": 0.03311, "epss_percentile": 0.86889}, "CVE-2006-2715": {"epss_score": 0.02323, "epss_percentile": 0.84378}, "CVE-2006-2716": {"epss_score": 0.02323, "epss_percentile": 0.84378}, "CVE-2006-2717": {"epss_score": 0.03634, "epss_percentile": 0.87477}, "CVE-2006-2718": {"epss_score": 0.01206, "epss_percentile": 0.78522}, "CVE-2006-2719": {"epss_score": 0.00115, "epss_percentile": 0.30935}, "CVE-2006-2720": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-2721": {"epss_score": 0.00664, "epss_percentile": 0.70634}, "CVE-2006-2722": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-2723": {"epss_score": 0.08126, "epss_percentile": 0.91893}, "CVE-2006-2724": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-2725": {"epss_score": 0.0216, "epss_percentile": 0.83821}, "CVE-2006-2726": {"epss_score": 0.09484, "epss_percentile": 0.92568}, "CVE-2006-2727": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2006-2728": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2006-2729": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-2730": {"epss_score": 0.0791, "epss_percentile": 0.91758}, "CVE-2006-2731": {"epss_score": 0.0267, "epss_percentile": 0.85388}, "CVE-2006-2732": {"epss_score": 0.01976, "epss_percentile": 0.83123}, "CVE-2006-2733": {"epss_score": 0.0064, "epss_percentile": 0.69959}, "CVE-2006-2734": {"epss_score": 0.00323, "epss_percentile": 0.54884}, "CVE-2006-2735": {"epss_score": 0.1521, "epss_percentile": 0.94386}, "CVE-2006-2736": {"epss_score": 0.09441, "epss_percentile": 0.9255}, "CVE-2006-2737": {"epss_score": 0.09624, "epss_percentile": 0.92628}, "CVE-2006-2738": {"epss_score": 0.01269, "epss_percentile": 0.79039}, "CVE-2006-2739": {"epss_score": 0.06437, "epss_percentile": 0.90757}, "CVE-2006-2740": {"epss_score": 0.01344, "epss_percentile": 0.79608}, "CVE-2006-2741": {"epss_score": 0.02558, "epss_percentile": 0.85099}, "CVE-2006-2742": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-2743": {"epss_score": 0.22706, "epss_percentile": 0.95671}, "CVE-2006-2744": {"epss_score": 0.09219, "epss_percentile": 0.92454}, "CVE-2006-2745": {"epss_score": 0.09123, "epss_percentile": 0.9241}, "CVE-2006-2746": {"epss_score": 0.13536, "epss_percentile": 0.9399}, "CVE-2006-2747": {"epss_score": 0.05202, "epss_percentile": 0.89606}, "CVE-2006-2748": {"epss_score": 0.0139, "epss_percentile": 0.79934}, "CVE-2006-2749": {"epss_score": 0.00637, "epss_percentile": 0.69894}, "CVE-2006-2750": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2006-2751": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2752": {"epss_score": 0.00308, "epss_percentile": 0.5362}, "CVE-2006-2753": {"epss_score": 0.06988, "epss_percentile": 0.91164}, "CVE-2006-2754": {"epss_score": 0.00493, "epss_percentile": 0.65026}, "CVE-2006-2755": {"epss_score": 0.06091, "epss_percentile": 0.90474}, "CVE-2006-2756": {"epss_score": 0.01431, "epss_percentile": 0.80242}, "CVE-2006-2757": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2006-2758": {"epss_score": 0.01572, "epss_percentile": 0.81095}, "CVE-2006-2759": {"epss_score": 0.0041, "epss_percentile": 0.60837}, "CVE-2006-2760": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2761": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2006-2762": {"epss_score": 0.0103, "epss_percentile": 0.76841}, "CVE-2006-2763": {"epss_score": 0.09388, "epss_percentile": 0.92529}, "CVE-2006-2764": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-2765": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-2766": {"epss_score": 0.67496, "epss_percentile": 0.9851}, "CVE-2006-2767": {"epss_score": 0.20902, "epss_percentile": 0.95436}, "CVE-2006-2768": {"epss_score": 0.04759, "epss_percentile": 0.89117}, "CVE-2006-2769": {"epss_score": 0.22767, "epss_percentile": 0.95684}, "CVE-2006-2770": {"epss_score": 0.22068, "epss_percentile": 0.95591}, "CVE-2006-2771": {"epss_score": 0.0465, "epss_percentile": 0.88964}, "CVE-2006-2772": {"epss_score": 0.01209, "epss_percentile": 0.78542}, "CVE-2006-2773": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2006-2774": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-2775": {"epss_score": 0.07929, "epss_percentile": 0.91767}, "CVE-2006-2776": {"epss_score": 0.31164, "epss_percentile": 0.96599}, "CVE-2006-2777": {"epss_score": 0.35105, "epss_percentile": 0.96887}, "CVE-2006-2778": {"epss_score": 0.23254, "epss_percentile": 0.95757}, "CVE-2006-2779": {"epss_score": 0.23286, "epss_percentile": 0.9576}, "CVE-2006-2780": {"epss_score": 0.26533, "epss_percentile": 0.96154}, "CVE-2006-2781": {"epss_score": 0.07236, "epss_percentile": 0.91341}, "CVE-2006-2782": {"epss_score": 0.01435, "epss_percentile": 0.8027}, "CVE-2006-2783": {"epss_score": 0.04975, "epss_percentile": 0.89355}, "CVE-2006-2784": {"epss_score": 0.03983, "epss_percentile": 0.8806}, "CVE-2006-2785": {"epss_score": 0.02013, "epss_percentile": 0.8326}, "CVE-2006-2786": {"epss_score": 0.02439, "epss_percentile": 0.8475}, "CVE-2006-2787": {"epss_score": 0.09158, "epss_percentile": 0.92426}, "CVE-2006-2788": {"epss_score": 0.08288, "epss_percentile": 0.91971}, "CVE-2006-2789": {"epss_score": 0.00786, "epss_percentile": 0.73288}, "CVE-2006-2790": {"epss_score": 0.0004, "epss_percentile": 0.12189}, "CVE-2006-2791": {"epss_score": 0.00229, "epss_percentile": 0.45619}, "CVE-2006-2792": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-2793": {"epss_score": 0.02016, "epss_percentile": 0.83277}, "CVE-2006-2794": {"epss_score": 0.06838, "epss_percentile": 0.91059}, "CVE-2006-2795": {"epss_score": 0.01171, "epss_percentile": 0.78224}, "CVE-2006-2796": {"epss_score": 0.01278, "epss_percentile": 0.79121}, "CVE-2006-2797": {"epss_score": 0.00369, "epss_percentile": 0.58238}, "CVE-2006-2798": {"epss_score": 0.0852, "epss_percentile": 0.92099}, "CVE-2006-2799": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-2800": {"epss_score": 0.00844, "epss_percentile": 0.74272}, "CVE-2006-2801": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-2802": {"epss_score": 0.10994, "epss_percentile": 0.93185}, "CVE-2006-2803": {"epss_score": 0.07434, "epss_percentile": 0.91472}, "CVE-2006-2804": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-2805": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2006-2806": {"epss_score": 0.05405, "epss_percentile": 0.89838}, "CVE-2006-2807": {"epss_score": 0.0527, "epss_percentile": 0.89678}, "CVE-2006-2808": {"epss_score": 0.00411, "epss_percentile": 0.60852}, "CVE-2006-2809": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2006-2810": {"epss_score": 0.0192, "epss_percentile": 0.82891}, "CVE-2006-2811": {"epss_score": 0.07202, "epss_percentile": 0.91318}, "CVE-2006-2812": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-2813": {"epss_score": 0.00603, "epss_percentile": 0.68905}, "CVE-2006-2814": {"epss_score": 0.07164, "epss_percentile": 0.91294}, "CVE-2006-2815": {"epss_score": 0.01722, "epss_percentile": 0.8194}, "CVE-2006-2816": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-2817": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2006-2818": {"epss_score": 0.06242, "epss_percentile": 0.90596}, "CVE-2006-2819": {"epss_score": 0.04945, "epss_percentile": 0.89317}, "CVE-2006-2820": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-2821": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-2822": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2823": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2824": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-2825": {"epss_score": 0.00465, "epss_percentile": 0.63766}, "CVE-2006-2826": {"epss_score": 0.02561, "epss_percentile": 0.85105}, "CVE-2006-2827": {"epss_score": 0.0078, "epss_percentile": 0.73159}, "CVE-2006-2828": {"epss_score": 0.03198, "epss_percentile": 0.86616}, "CVE-2006-2829": {"epss_score": 0.00271, "epss_percentile": 0.50318}, "CVE-2006-2830": {"epss_score": 0.06884, "epss_percentile": 0.91092}, "CVE-2006-2831": {"epss_score": 0.02104, "epss_percentile": 0.83621}, "CVE-2006-2832": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2833": {"epss_score": 0.01014, "epss_percentile": 0.76643}, "CVE-2006-2834": {"epss_score": 0.11429, "epss_percentile": 0.93346}, "CVE-2006-2835": {"epss_score": 0.01032, "epss_percentile": 0.76866}, "CVE-2006-2836": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-2837": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-2838": {"epss_score": 0.07193, "epss_percentile": 0.91312}, "CVE-2006-2839": {"epss_score": 0.00808, "epss_percentile": 0.73697}, "CVE-2006-2840": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-2841": {"epss_score": 0.12567, "epss_percentile": 0.93717}, "CVE-2006-2842": {"epss_score": 0.0094, "epss_percentile": 0.75729}, "CVE-2006-2843": {"epss_score": 0.12648, "epss_percentile": 0.9374}, "CVE-2006-2844": {"epss_score": 0.12648, "epss_percentile": 0.9374}, "CVE-2006-2845": {"epss_score": 0.12648, "epss_percentile": 0.9374}, "CVE-2006-2846": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-2847": {"epss_score": 0.01951, "epss_percentile": 0.83019}, "CVE-2006-2848": {"epss_score": 0.04111, "epss_percentile": 0.88272}, "CVE-2006-2849": {"epss_score": 0.11552, "epss_percentile": 0.93402}, "CVE-2006-2850": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-2851": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-2852": {"epss_score": 0.10536, "epss_percentile": 0.93021}, "CVE-2006-2853": {"epss_score": 0.006, "epss_percentile": 0.68815}, "CVE-2006-2854": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2006-2855": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2006-2856": {"epss_score": 0.00058, "epss_percentile": 0.18307}, "CVE-2006-2857": {"epss_score": 0.00797, "epss_percentile": 0.73495}, "CVE-2006-2858": {"epss_score": 0.01445, "epss_percentile": 0.80322}, "CVE-2006-2859": {"epss_score": 0.01708, "epss_percentile": 0.81866}, "CVE-2006-2860": {"epss_score": 0.08306, "epss_percentile": 0.91981}, "CVE-2006-2861": {"epss_score": 0.01008, "epss_percentile": 0.76564}, "CVE-2006-2862": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-2863": {"epss_score": 0.0884, "epss_percentile": 0.9228}, "CVE-2006-2864": {"epss_score": 0.11231, "epss_percentile": 0.93271}, "CVE-2006-2865": {"epss_score": 0.04026, "epss_percentile": 0.88142}, "CVE-2006-2866": {"epss_score": 0.1185, "epss_percentile": 0.93494}, "CVE-2006-2867": {"epss_score": 0.01073, "epss_percentile": 0.77294}, "CVE-2006-2868": {"epss_score": 0.1465, "epss_percentile": 0.94257}, "CVE-2006-2869": {"epss_score": 0.00446, "epss_percentile": 0.62907}, "CVE-2006-2870": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-2871": {"epss_score": 0.08985, "epss_percentile": 0.92353}, "CVE-2006-2872": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-2873": {"epss_score": 0.00614, "epss_percentile": 0.69279}, "CVE-2006-2874": {"epss_score": 0.0054, "epss_percentile": 0.67001}, "CVE-2006-2875": {"epss_score": 0.04453, "epss_percentile": 0.88708}, "CVE-2006-2876": {"epss_score": 0.01039, "epss_percentile": 0.76947}, "CVE-2006-2877": {"epss_score": 0.06627, "epss_percentile": 0.90901}, "CVE-2006-2878": {"epss_score": 0.04385, "epss_percentile": 0.8863}, "CVE-2006-2879": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2880": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-2881": {"epss_score": 0.11538, "epss_percentile": 0.93399}, "CVE-2006-2882": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-2883": {"epss_score": 0.07101, "epss_percentile": 0.91252}, "CVE-2006-2884": {"epss_score": 0.01003, "epss_percentile": 0.76518}, "CVE-2006-2885": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2886": {"epss_score": 0.00627, "epss_percentile": 0.69643}, "CVE-2006-2887": {"epss_score": 0.06432, "epss_percentile": 0.90755}, "CVE-2006-2888": {"epss_score": 0.06242, "epss_percentile": 0.90596}, "CVE-2006-2889": {"epss_score": 0.0088, "epss_percentile": 0.74854}, "CVE-2006-2890": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2006-2891": {"epss_score": 0.00483, "epss_percentile": 0.64559}, "CVE-2006-2892": {"epss_score": 0.06991, "epss_percentile": 0.91167}, "CVE-2006-2893": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-2894": {"epss_score": 0.06905, "epss_percentile": 0.91108}, "CVE-2006-2895": {"epss_score": 0.00649, "epss_percentile": 0.70232}, "CVE-2006-2896": {"epss_score": 0.1288, "epss_percentile": 0.93811}, "CVE-2006-2897": {"epss_score": 0.00483, "epss_percentile": 0.64559}, "CVE-2006-2898": {"epss_score": 0.00324, "epss_percentile": 0.54953}, "CVE-2006-2899": {"epss_score": 0.07234, "epss_percentile": 0.91339}, "CVE-2006-2900": {"epss_score": 0.17395, "epss_percentile": 0.94844}, "CVE-2006-2901": {"epss_score": 0.05533, "epss_percentile": 0.89967}, "CVE-2006-2902": {"epss_score": 0.0021, "epss_percentile": 0.43432}, "CVE-2006-2903": {"epss_score": 0.00416, "epss_percentile": 0.61177}, "CVE-2006-2904": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-2905": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2006-2906": {"epss_score": 0.15275, "epss_percentile": 0.94397}, "CVE-2006-2908": {"epss_score": 0.1141, "epss_percentile": 0.9334}, "CVE-2006-2909": {"epss_score": 0.26167, "epss_percentile": 0.96119}, "CVE-2006-2910": {"epss_score": 0.01616, "epss_percentile": 0.8136}, "CVE-2006-2911": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-2912": {"epss_score": 0.02086, "epss_percentile": 0.8355}, "CVE-2006-2913": {"epss_score": 0.00739, "epss_percentile": 0.72388}, "CVE-2006-2914": {"epss_score": 0.07762, "epss_percentile": 0.91665}, "CVE-2006-2915": {"epss_score": 0.01314, "epss_percentile": 0.79395}, "CVE-2006-2916": {"epss_score": 0.00145, "epss_percentile": 0.35351}, "CVE-2006-2917": {"epss_score": 0.01717, "epss_percentile": 0.81916}, "CVE-2006-2918": {"epss_score": 0.00746, "epss_percentile": 0.72545}, "CVE-2006-2919": {"epss_score": 0.35229, "epss_percentile": 0.96894}, "CVE-2006-2920": {"epss_score": 0.01105, "epss_percentile": 0.77612}, "CVE-2006-2921": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2006-2922": {"epss_score": 0.08633, "epss_percentile": 0.92164}, "CVE-2006-2923": {"epss_score": 0.11205, "epss_percentile": 0.93264}, "CVE-2006-2924": {"epss_score": 0.01122, "epss_percentile": 0.77778}, "CVE-2006-2925": {"epss_score": 0.00695, "epss_percentile": 0.71366}, "CVE-2006-2926": {"epss_score": 0.84815, "epss_percentile": 0.99306}, "CVE-2006-2927": {"epss_score": 0.00409, "epss_percentile": 0.607}, "CVE-2006-2928": {"epss_score": 0.03012, "epss_percentile": 0.862}, "CVE-2006-2929": {"epss_score": 0.03094, "epss_percentile": 0.86402}, "CVE-2006-2930": {"epss_score": 0.00038, "epss_percentile": 0.11346}, "CVE-2006-2931": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-2932": {"epss_score": 0.0005, "epss_percentile": 0.15848}, "CVE-2006-2933": {"epss_score": 0.00081, "epss_percentile": 0.24243}, "CVE-2006-2934": {"epss_score": 0.23284, "epss_percentile": 0.95759}, "CVE-2006-2935": {"epss_score": 0.00215, "epss_percentile": 0.44088}, "CVE-2006-2936": {"epss_score": 0.10179, "epss_percentile": 0.92882}, "CVE-2006-2937": {"epss_score": 0.08835, "epss_percentile": 0.92276}, "CVE-2006-2940": {"epss_score": 0.11795, "epss_percentile": 0.93478}, "CVE-2006-2941": {"epss_score": 0.09054, "epss_percentile": 0.92381}, "CVE-2006-2942": {"epss_score": 0.01495, "epss_percentile": 0.80656}, "CVE-2006-2943": {"epss_score": 0.01414, "epss_percentile": 0.8013}, "CVE-2006-2944": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-2945": {"epss_score": 0.00284, "epss_percentile": 0.51498}, "CVE-2006-2946": {"epss_score": 0.03779, "epss_percentile": 0.87717}, "CVE-2006-2947": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2006-2948": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-2949": {"epss_score": 0.01434, "epss_percentile": 0.80264}, "CVE-2006-2950": {"epss_score": 0.01107, "epss_percentile": 0.77624}, "CVE-2006-2951": {"epss_score": 0.06108, "epss_percentile": 0.90485}, "CVE-2006-2952": {"epss_score": 0.01231, "epss_percentile": 0.7873}, "CVE-2006-2953": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-2954": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2955": {"epss_score": 0.01436, "epss_percentile": 0.80274}, "CVE-2006-2956": {"epss_score": 0.00416, "epss_percentile": 0.61177}, "CVE-2006-2957": {"epss_score": 0.00362, "epss_percentile": 0.57779}, "CVE-2006-2958": {"epss_score": 0.00986, "epss_percentile": 0.76333}, "CVE-2006-2959": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-2960": {"epss_score": 0.01289, "epss_percentile": 0.79209}, "CVE-2006-2961": {"epss_score": 0.83469, "epss_percentile": 0.99249}, "CVE-2006-2962": {"epss_score": 0.05783, "epss_percentile": 0.90204}, "CVE-2006-2963": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-2964": {"epss_score": 0.0358, "epss_percentile": 0.87384}, "CVE-2006-2965": {"epss_score": 0.00416, "epss_percentile": 0.61177}, "CVE-2006-2966": {"epss_score": 0.0091, "epss_percentile": 0.7532}, "CVE-2006-2967": {"epss_score": 0.00067, "epss_percentile": 0.21164}, "CVE-2006-2968": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-2969": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-2970": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2006-2971": {"epss_score": 0.09468, "epss_percentile": 0.9256}, "CVE-2006-2972": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2973": {"epss_score": 0.00367, "epss_percentile": 0.58157}, "CVE-2006-2974": {"epss_score": 0.00483, "epss_percentile": 0.64559}, "CVE-2006-2975": {"epss_score": 0.00683, "epss_percentile": 0.71099}, "CVE-2006-2976": {"epss_score": 0.00737, "epss_percentile": 0.72317}, "CVE-2006-2977": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2978": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-2979": {"epss_score": 0.00608, "epss_percentile": 0.69078}, "CVE-2006-2980": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-2981": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-2982": {"epss_score": 0.10316, "epss_percentile": 0.92941}, "CVE-2006-2983": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-2984": {"epss_score": 0.00464, "epss_percentile": 0.6372}, "CVE-2006-2985": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-2986": {"epss_score": 0.01811, "epss_percentile": 0.82369}, "CVE-2006-2987": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-2988": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-2989": {"epss_score": 0.00416, "epss_percentile": 0.61177}, "CVE-2006-2990": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-2991": {"epss_score": 0.00877, "epss_percentile": 0.74802}, "CVE-2006-2992": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-2993": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-2994": {"epss_score": 0.00695, "epss_percentile": 0.71366}, "CVE-2006-2995": {"epss_score": 0.13057, "epss_percentile": 0.9386}, "CVE-2006-2996": {"epss_score": 0.0791, "epss_percentile": 0.91758}, "CVE-2006-2997": {"epss_score": 0.00606, "epss_percentile": 0.69001}, "CVE-2006-2998": {"epss_score": 0.07365, "epss_percentile": 0.91435}, "CVE-2006-2999": {"epss_score": 0.00494, "epss_percentile": 0.65081}, "CVE-2006-3000": {"epss_score": 0.00494, "epss_percentile": 0.65081}, "CVE-2006-3001": {"epss_score": 0.00615, "epss_percentile": 0.693}, "CVE-2006-3002": {"epss_score": 0.00628, "epss_percentile": 0.69658}, "CVE-2006-3003": {"epss_score": 0.00669, "epss_percentile": 0.70764}, "CVE-2006-3004": {"epss_score": 0.00686, "epss_percentile": 0.71153}, "CVE-2006-3005": {"epss_score": 0.0054, "epss_percentile": 0.67011}, "CVE-2006-3006": {"epss_score": 0.01047, "epss_percentile": 0.77036}, "CVE-2006-3007": {"epss_score": 0.00562, "epss_percentile": 0.67681}, "CVE-2006-3009": {"epss_score": 0.01259, "epss_percentile": 0.78963}, "CVE-2006-3010": {"epss_score": 0.02157, "epss_percentile": 0.83814}, "CVE-2006-3011": {"epss_score": 0.00438, "epss_percentile": 0.6254}, "CVE-2006-3012": {"epss_score": 0.01596, "epss_percentile": 0.81239}, "CVE-2006-3013": {"epss_score": 0.0381, "epss_percentile": 0.87758}, "CVE-2006-3014": {"epss_score": 0.58319, "epss_percentile": 0.98108}, "CVE-2006-3015": {"epss_score": 0.1757, "epss_percentile": 0.94868}, "CVE-2006-3016": {"epss_score": 0.0674, "epss_percentile": 0.90994}, "CVE-2006-3017": {"epss_score": 0.04782, "epss_percentile": 0.89137}, "CVE-2006-3018": {"epss_score": 0.01171, "epss_percentile": 0.78214}, "CVE-2006-3019": {"epss_score": 0.03935, "epss_percentile": 0.87982}, "CVE-2006-3020": {"epss_score": 0.01717, "epss_percentile": 0.81916}, "CVE-2006-3021": {"epss_score": 0.0141, "epss_percentile": 0.80081}, "CVE-2006-3022": {"epss_score": 0.0141, "epss_percentile": 0.80081}, "CVE-2006-3023": {"epss_score": 0.00409, "epss_percentile": 0.607}, "CVE-2006-3024": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-3025": {"epss_score": 0.01251, "epss_percentile": 0.78894}, "CVE-2006-3026": {"epss_score": 0.00409, "epss_percentile": 0.607}, "CVE-2006-3027": {"epss_score": 0.02436, "epss_percentile": 0.84742}, "CVE-2006-3028": {"epss_score": 0.15153, "epss_percentile": 0.94374}, "CVE-2006-3029": {"epss_score": 0.00416, "epss_percentile": 0.61177}, "CVE-2006-3030": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3031": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-3032": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3033": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-3034": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-3035": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-3036": {"epss_score": 0.0414, "epss_percentile": 0.88311}, "CVE-2006-3037": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-3038": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-3039": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-3040": {"epss_score": 0.01427, "epss_percentile": 0.8021}, "CVE-2006-3041": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2006-3042": {"epss_score": 0.07196, "epss_percentile": 0.91314}, "CVE-2006-3043": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-3044": {"epss_score": 0.00521, "epss_percentile": 0.66245}, "CVE-2006-3045": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-3046": {"epss_score": 0.00473, "epss_percentile": 0.64107}, "CVE-2006-3047": {"epss_score": 0.00979, "epss_percentile": 0.76261}, "CVE-2006-3048": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-3049": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3050": {"epss_score": 0.05605, "epss_percentile": 0.90042}, "CVE-2006-3051": {"epss_score": 0.01171, "epss_percentile": 0.78221}, "CVE-2006-3052": {"epss_score": 0.00458, "epss_percentile": 0.63449}, "CVE-2006-3053": {"epss_score": 0.05721, "epss_percentile": 0.90151}, "CVE-2006-3054": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-3055": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2006-3056": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2006-3057": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-3059": {"epss_score": 0.75416, "epss_percentile": 0.98843}, "CVE-2006-3060": {"epss_score": 0.00164, "epss_percentile": 0.37906}, "CVE-2006-3061": {"epss_score": 0.0927, "epss_percentile": 0.92474}, "CVE-2006-3062": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3063": {"epss_score": 0.00416, "epss_percentile": 0.61177}, "CVE-2006-3064": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-3065": {"epss_score": 0.0133, "epss_percentile": 0.7951}, "CVE-2006-3066": {"epss_score": 0.01562, "epss_percentile": 0.81047}, "CVE-2006-3067": {"epss_score": 0.01628, "epss_percentile": 0.81436}, "CVE-2006-3068": {"epss_score": 0.0092, "epss_percentile": 0.75468}, "CVE-2006-3069": {"epss_score": 0.07376, "epss_percentile": 0.91441}, "CVE-2006-3070": {"epss_score": 0.01954, "epss_percentile": 0.83029}, "CVE-2006-3071": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3072": {"epss_score": 0.00077, "epss_percentile": 0.23369}, "CVE-2006-3073": {"epss_score": 0.00984, "epss_percentile": 0.76317}, "CVE-2006-3074": {"epss_score": 0.04053, "epss_percentile": 0.88178}, "CVE-2006-3075": {"epss_score": 0.01821, "epss_percentile": 0.82411}, "CVE-2006-3076": {"epss_score": 0.05273, "epss_percentile": 0.8968}, "CVE-2006-3077": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-3078": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-3079": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3080": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3081": {"epss_score": 0.12394, "epss_percentile": 0.93658}, "CVE-2006-3082": {"epss_score": 0.23123, "epss_percentile": 0.95737}, "CVE-2006-3083": {"epss_score": 0.00071, "epss_percentile": 0.2199}, "CVE-2006-3084": {"epss_score": 0.00281, "epss_percentile": 0.51141}, "CVE-2006-3085": {"epss_score": 0.0247, "epss_percentile": 0.84846}, "CVE-2006-3086": {"epss_score": 0.60912, "epss_percentile": 0.98226}, "CVE-2006-3087": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-3088": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-3089": {"epss_score": 0.01985, "epss_percentile": 0.83154}, "CVE-2006-3090": {"epss_score": 0.03032, "epss_percentile": 0.86252}, "CVE-2006-3091": {"epss_score": 0.00745, "epss_percentile": 0.72517}, "CVE-2006-3092": {"epss_score": 0.01603, "epss_percentile": 0.8128}, "CVE-2006-3093": {"epss_score": 0.03007, "epss_percentile": 0.86187}, "CVE-2006-3094": {"epss_score": 0.00803, "epss_percentile": 0.73607}, "CVE-2006-3095": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3096": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-3097": {"epss_score": 0.00063, "epss_percentile": 0.19944}, "CVE-2006-3100": {"epss_score": 0.00512, "epss_percentile": 0.65871}, "CVE-2006-3101": {"epss_score": 0.25649, "epss_percentile": 0.96053}, "CVE-2006-3102": {"epss_score": 0.07803, "epss_percentile": 0.9169}, "CVE-2006-3103": {"epss_score": 0.02965, "epss_percentile": 0.8608}, "CVE-2006-3104": {"epss_score": 0.05074, "epss_percentile": 0.89467}, "CVE-2006-3105": {"epss_score": 0.02909, "epss_percentile": 0.85968}, "CVE-2006-3106": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2006-3107": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2006-3108": {"epss_score": 0.00517, "epss_percentile": 0.66067}, "CVE-2006-3109": {"epss_score": 0.20528, "epss_percentile": 0.95365}, "CVE-2006-3110": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-3111": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3112": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-3113": {"epss_score": 0.2749, "epss_percentile": 0.96252}, "CVE-2006-3114": {"epss_score": 0.00047, "epss_percentile": 0.14576}, "CVE-2006-3115": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-3116": {"epss_score": 0.0767, "epss_percentile": 0.91614}, "CVE-2006-3117": {"epss_score": 0.04635, "epss_percentile": 0.88948}, "CVE-2006-3118": {"epss_score": 0.00065, "epss_percentile": 0.20603}, "CVE-2006-3119": {"epss_score": 0.01489, "epss_percentile": 0.80626}, "CVE-2006-3120": {"epss_score": 0.03829, "epss_percentile": 0.87801}, "CVE-2006-3121": {"epss_score": 0.20327, "epss_percentile": 0.95326}, "CVE-2006-3122": {"epss_score": 0.09777, "epss_percentile": 0.92698}, "CVE-2006-3123": {"epss_score": 0.00063, "epss_percentile": 0.20082}, "CVE-2006-3124": {"epss_score": 0.3946, "epss_percentile": 0.97162}, "CVE-2006-3125": {"epss_score": 0.05104, "epss_percentile": 0.89504}, "CVE-2006-3126": {"epss_score": 0.01639, "epss_percentile": 0.81488}, "CVE-2006-3127": {"epss_score": 0.02052, "epss_percentile": 0.83412}, "CVE-2006-3128": {"epss_score": 0.01082, "epss_percentile": 0.77383}, "CVE-2006-3129": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3130": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3131": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-3132": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-3134": {"epss_score": 0.43134, "epss_percentile": 0.9737}, "CVE-2006-3135": {"epss_score": 0.0222, "epss_percentile": 0.84049}, "CVE-2006-3136": {"epss_score": 0.02095, "epss_percentile": 0.83584}, "CVE-2006-3137": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-3138": {"epss_score": 0.00624, "epss_percentile": 0.69574}, "CVE-2006-3139": {"epss_score": 0.01314, "epss_percentile": 0.79395}, "CVE-2006-3140": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-3141": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3142": {"epss_score": 0.01016, "epss_percentile": 0.76681}, "CVE-2006-3143": {"epss_score": 0.00739, "epss_percentile": 0.72358}, "CVE-2006-3144": {"epss_score": 0.17113, "epss_percentile": 0.94777}, "CVE-2006-3145": {"epss_score": 0.03748, "epss_percentile": 0.87667}, "CVE-2006-3146": {"epss_score": 0.05226, "epss_percentile": 0.89633}, "CVE-2006-3147": {"epss_score": 0.01638, "epss_percentile": 0.81486}, "CVE-2006-3148": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3149": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3150": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3151": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2006-3152": {"epss_score": 0.02117, "epss_percentile": 0.83667}, "CVE-2006-3153": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3154": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3155": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-3156": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3157": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3158": {"epss_score": 0.05202, "epss_percentile": 0.89606}, "CVE-2006-3159": {"epss_score": 0.00079, "epss_percentile": 0.23905}, "CVE-2006-3160": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3161": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2006-3162": {"epss_score": 0.0638, "epss_percentile": 0.90711}, "CVE-2006-3163": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-3164": {"epss_score": 0.0101, "epss_percentile": 0.766}, "CVE-2006-3165": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3166": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-3167": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-3168": {"epss_score": 0.0139, "epss_percentile": 0.79934}, "CVE-2006-3169": {"epss_score": 0.00872, "epss_percentile": 0.74733}, "CVE-2006-3170": {"epss_score": 0.00807, "epss_percentile": 0.73678}, "CVE-2006-3171": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-3172": {"epss_score": 0.06793, "epss_percentile": 0.9103}, "CVE-2006-3173": {"epss_score": 0.01739, "epss_percentile": 0.82041}, "CVE-2006-3174": {"epss_score": 0.01159, "epss_percentile": 0.7813}, "CVE-2006-3175": {"epss_score": 0.07255, "epss_percentile": 0.91353}, "CVE-2006-3176": {"epss_score": 0.00542, "epss_percentile": 0.67064}, "CVE-2006-3177": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2006-3178": {"epss_score": 0.02096, "epss_percentile": 0.83588}, "CVE-2006-3179": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3180": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-3181": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3182": {"epss_score": 0.00801, "epss_percentile": 0.73563}, "CVE-2006-3183": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-3184": {"epss_score": 0.0892, "epss_percentile": 0.92319}, "CVE-2006-3185": {"epss_score": 0.067, "epss_percentile": 0.90956}, "CVE-2006-3186": {"epss_score": 0.00565, "epss_percentile": 0.67789}, "CVE-2006-3187": {"epss_score": 0.00355, "epss_percentile": 0.57266}, "CVE-2006-3188": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-3189": {"epss_score": 0.03483, "epss_percentile": 0.87224}, "CVE-2006-3190": {"epss_score": 0.01184, "epss_percentile": 0.78334}, "CVE-2006-3191": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2006-3192": {"epss_score": 0.11552, "epss_percentile": 0.93402}, "CVE-2006-3193": {"epss_score": 0.05787, "epss_percentile": 0.90209}, "CVE-2006-3194": {"epss_score": 0.08387, "epss_percentile": 0.92022}, "CVE-2006-3195": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2006-3196": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-3197": {"epss_score": 0.00614, "epss_percentile": 0.69286}, "CVE-2006-3198": {"epss_score": 0.09592, "epss_percentile": 0.92613}, "CVE-2006-3199": {"epss_score": 0.1859, "epss_percentile": 0.95038}, "CVE-2006-3200": {"epss_score": 0.29854, "epss_percentile": 0.96481}, "CVE-2006-3201": {"epss_score": 0.00075, "epss_percentile": 0.22894}, "CVE-2006-3202": {"epss_score": 0.00056, "epss_percentile": 0.17953}, "CVE-2006-3203": {"epss_score": 0.01245, "epss_percentile": 0.78841}, "CVE-2006-3204": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2006-3205": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-3206": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2006-3207": {"epss_score": 0.00276, "epss_percentile": 0.50763}, "CVE-2006-3208": {"epss_score": 0.00733, "epss_percentile": 0.72214}, "CVE-2006-3209": {"epss_score": 0.00257, "epss_percentile": 0.48894}, "CVE-2006-3210": {"epss_score": 0.05072, "epss_percentile": 0.89465}, "CVE-2006-3211": {"epss_score": 0.00709, "epss_percentile": 0.71688}, "CVE-2006-3212": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-3213": {"epss_score": 0.00553, "epss_percentile": 0.6742}, "CVE-2006-3214": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-3215": {"epss_score": 0.00552, "epss_percentile": 0.67386}, "CVE-2006-3216": {"epss_score": 0.01344, "epss_percentile": 0.79618}, "CVE-2006-3217": {"epss_score": 0.00874, "epss_percentile": 0.74771}, "CVE-2006-3218": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-3219": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-3220": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-3221": {"epss_score": 0.027, "epss_percentile": 0.8545}, "CVE-2006-3222": {"epss_score": 0.01591, "epss_percentile": 0.81202}, "CVE-2006-3223": {"epss_score": 0.0171, "epss_percentile": 0.81873}, "CVE-2006-3224": {"epss_score": 0.0068, "epss_percentile": 0.71025}, "CVE-2006-3225": {"epss_score": 0.00674, "epss_percentile": 0.70846}, "CVE-2006-3226": {"epss_score": 0.01898, "epss_percentile": 0.8276}, "CVE-2006-3227": {"epss_score": 0.30898, "epss_percentile": 0.96575}, "CVE-2006-3228": {"epss_score": 0.09103, "epss_percentile": 0.92402}, "CVE-2006-3229": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3230": {"epss_score": 0.00795, "epss_percentile": 0.73465}, "CVE-2006-3231": {"epss_score": 0.00842, "epss_percentile": 0.74246}, "CVE-2006-3232": {"epss_score": 0.00636, "epss_percentile": 0.6987}, "CVE-2006-3233": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3234": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3235": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3236": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-3237": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3238": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3239": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-3240": {"epss_score": 0.00633, "epss_percentile": 0.69768}, "CVE-2006-3241": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3242": {"epss_score": 0.07538, "epss_percentile": 0.91525}, "CVE-2006-3243": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3244": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-3245": {"epss_score": 0.00565, "epss_percentile": 0.67789}, "CVE-2006-3246": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3247": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3249": {"epss_score": 0.01053, "epss_percentile": 0.77098}, "CVE-2006-3250": {"epss_score": 0.1986, "epss_percentile": 0.95252}, "CVE-2006-3251": {"epss_score": 0.01938, "epss_percentile": 0.82969}, "CVE-2006-3252": {"epss_score": 0.80048, "epss_percentile": 0.99069}, "CVE-2006-3253": {"epss_score": 0.07459, "epss_percentile": 0.91483}, "CVE-2006-3254": {"epss_score": 0.00457, "epss_percentile": 0.6338}, "CVE-2006-3255": {"epss_score": 0.00457, "epss_percentile": 0.6338}, "CVE-2006-3256": {"epss_score": 0.00343, "epss_percentile": 0.56472}, "CVE-2006-3257": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-3258": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3259": {"epss_score": 0.09047, "epss_percentile": 0.92378}, "CVE-2006-3260": {"epss_score": 0.00714, "epss_percentile": 0.71818}, "CVE-2006-3261": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3262": {"epss_score": 0.03798, "epss_percentile": 0.87738}, "CVE-2006-3263": {"epss_score": 0.00509, "epss_percentile": 0.65745}, "CVE-2006-3264": {"epss_score": 0.00713, "epss_percentile": 0.71796}, "CVE-2006-3265": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3266": {"epss_score": 0.11738, "epss_percentile": 0.93463}, "CVE-2006-3267": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-3268": {"epss_score": 0.01425, "epss_percentile": 0.80195}, "CVE-2006-3269": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-3270": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-3271": {"epss_score": 0.00587, "epss_percentile": 0.68467}, "CVE-2006-3272": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2006-3273": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3274": {"epss_score": 0.01243, "epss_percentile": 0.78829}, "CVE-2006-3275": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-3276": {"epss_score": 0.08786, "epss_percentile": 0.92255}, "CVE-2006-3277": {"epss_score": 0.21038, "epss_percentile": 0.95456}, "CVE-2006-3278": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3279": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3280": {"epss_score": 0.62084, "epss_percentile": 0.98277}, "CVE-2006-3281": {"epss_score": 0.62708, "epss_percentile": 0.98304}, "CVE-2006-3282": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-3283": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-3284": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3285": {"epss_score": 0.0103, "epss_percentile": 0.76843}, "CVE-2006-3286": {"epss_score": 0.01393, "epss_percentile": 0.79964}, "CVE-2006-3287": {"epss_score": 0.01393, "epss_percentile": 0.79964}, "CVE-2006-3288": {"epss_score": 0.00831, "epss_percentile": 0.74045}, "CVE-2006-3289": {"epss_score": 0.00515, "epss_percentile": 0.66009}, "CVE-2006-3290": {"epss_score": 0.00542, "epss_percentile": 0.6707}, "CVE-2006-3291": {"epss_score": 0.01141, "epss_percentile": 0.77964}, "CVE-2006-3292": {"epss_score": 0.01278, "epss_percentile": 0.79123}, "CVE-2006-3293": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-3294": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-3295": {"epss_score": 0.00768, "epss_percentile": 0.72969}, "CVE-2006-3296": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2006-3297": {"epss_score": 0.00362, "epss_percentile": 0.57779}, "CVE-2006-3298": {"epss_score": 0.04913, "epss_percentile": 0.89281}, "CVE-2006-3299": {"epss_score": 0.05656, "epss_percentile": 0.90091}, "CVE-2006-3300": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2006-3301": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3302": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-3303": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3304": {"epss_score": 0.0219, "epss_percentile": 0.83933}, "CVE-2006-3305": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3306": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3307": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-3308": {"epss_score": 0.00403, "epss_percentile": 0.60326}, "CVE-2006-3309": {"epss_score": 0.01505, "epss_percentile": 0.80741}, "CVE-2006-3311": {"epss_score": 0.57875, "epss_percentile": 0.98088}, "CVE-2006-3312": {"epss_score": 0.02923, "epss_percentile": 0.86001}, "CVE-2006-3313": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-3314": {"epss_score": 0.02617, "epss_percentile": 0.85249}, "CVE-2006-3315": {"epss_score": 0.02164, "epss_percentile": 0.83842}, "CVE-2006-3316": {"epss_score": 0.0489, "epss_percentile": 0.8926}, "CVE-2006-3317": {"epss_score": 0.1617, "epss_percentile": 0.94587}, "CVE-2006-3318": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-3319": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-3320": {"epss_score": 0.01357, "epss_percentile": 0.79718}, "CVE-2006-3321": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-3322": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3323": {"epss_score": 0.12463, "epss_percentile": 0.9368}, "CVE-2006-3324": {"epss_score": 0.02225, "epss_percentile": 0.84067}, "CVE-2006-3325": {"epss_score": 0.03928, "epss_percentile": 0.87968}, "CVE-2006-3326": {"epss_score": 0.01429, "epss_percentile": 0.80226}, "CVE-2006-3327": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3328": {"epss_score": 0.00661, "epss_percentile": 0.70579}, "CVE-2006-3329": {"epss_score": 0.00587, "epss_percentile": 0.68461}, "CVE-2006-3330": {"epss_score": 0.01464, "epss_percentile": 0.80446}, "CVE-2006-3331": {"epss_score": 0.01494, "epss_percentile": 0.80652}, "CVE-2006-3332": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-3333": {"epss_score": 0.00247, "epss_percentile": 0.47839}, "CVE-2006-3334": {"epss_score": 0.01752, "epss_percentile": 0.82108}, "CVE-2006-3335": {"epss_score": 0.00061, "epss_percentile": 0.1931}, "CVE-2006-3336": {"epss_score": 0.01059, "epss_percentile": 0.77155}, "CVE-2006-3337": {"epss_score": 0.01044, "epss_percentile": 0.77006}, "CVE-2006-3338": {"epss_score": 0.00496, "epss_percentile": 0.6514}, "CVE-2006-3339": {"epss_score": 0.00454, "epss_percentile": 0.63261}, "CVE-2006-3340": {"epss_score": 0.14761, "epss_percentile": 0.94276}, "CVE-2006-3341": {"epss_score": 0.0103, "epss_percentile": 0.76849}, "CVE-2006-3342": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-3343": {"epss_score": 0.01739, "epss_percentile": 0.82041}, "CVE-2006-3344": {"epss_score": 0.00899, "epss_percentile": 0.75157}, "CVE-2006-3345": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-3346": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3347": {"epss_score": 0.01501, "epss_percentile": 0.80717}, "CVE-2006-3348": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-3349": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-3350": {"epss_score": 0.04821, "epss_percentile": 0.89179}, "CVE-2006-3351": {"epss_score": 0.25495, "epss_percentile": 0.96034}, "CVE-2006-3352": {"epss_score": 0.00733, "epss_percentile": 0.72216}, "CVE-2006-3353": {"epss_score": 0.11046, "epss_percentile": 0.93199}, "CVE-2006-3354": {"epss_score": 0.39368, "epss_percentile": 0.97157}, "CVE-2006-3355": {"epss_score": 0.06985, "epss_percentile": 0.91162}, "CVE-2006-3356": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2006-3357": {"epss_score": 0.72358, "epss_percentile": 0.98705}, "CVE-2006-3358": {"epss_score": 0.00736, "epss_percentile": 0.72304}, "CVE-2006-3359": {"epss_score": 0.00558, "epss_percentile": 0.67587}, "CVE-2006-3360": {"epss_score": 0.09364, "epss_percentile": 0.92517}, "CVE-2006-3361": {"epss_score": 0.02, "epss_percentile": 0.83216}, "CVE-2006-3362": {"epss_score": 0.1521, "epss_percentile": 0.94385}, "CVE-2006-3363": {"epss_score": 0.02, "epss_percentile": 0.83216}, "CVE-2006-3364": {"epss_score": 0.06621, "epss_percentile": 0.90894}, "CVE-2006-3365": {"epss_score": 0.00704, "epss_percentile": 0.71565}, "CVE-2006-3366": {"epss_score": 0.00485, "epss_percentile": 0.64718}, "CVE-2006-3367": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2006-3368": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-3369": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3370": {"epss_score": 0.00346, "epss_percentile": 0.56618}, "CVE-2006-3371": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3372": {"epss_score": 0.06466, "epss_percentile": 0.90775}, "CVE-2006-3373": {"epss_score": 0.00072, "epss_percentile": 0.22432}, "CVE-2006-3374": {"epss_score": 0.01503, "epss_percentile": 0.80734}, "CVE-2006-3375": {"epss_score": 0.06242, "epss_percentile": 0.90596}, "CVE-2006-3376": {"epss_score": 0.12232, "epss_percentile": 0.93608}, "CVE-2006-3377": {"epss_score": 0.0103, "epss_percentile": 0.76841}, "CVE-2006-3378": {"epss_score": 0.00056, "epss_percentile": 0.17677}, "CVE-2006-3379": {"epss_score": 0.01928, "epss_percentile": 0.82932}, "CVE-2006-3380": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-3381": {"epss_score": 0.03174, "epss_percentile": 0.8656}, "CVE-2006-3382": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-3383": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-3384": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2006-3385": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2006-3386": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2006-3387": {"epss_score": 0.06709, "epss_percentile": 0.90962}, "CVE-2006-3388": {"epss_score": 0.0103, "epss_percentile": 0.76841}, "CVE-2006-3389": {"epss_score": 0.01196, "epss_percentile": 0.78437}, "CVE-2006-3390": {"epss_score": 0.0136, "epss_percentile": 0.79739}, "CVE-2006-3391": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-3392": {"epss_score": 0.78348, "epss_percentile": 0.98982}, "CVE-2006-3393": {"epss_score": 0.01099, "epss_percentile": 0.77548}, "CVE-2006-3394": {"epss_score": 0.01501, "epss_percentile": 0.80717}, "CVE-2006-3395": {"epss_score": 0.06933, "epss_percentile": 0.91124}, "CVE-2006-3396": {"epss_score": 0.21612, "epss_percentile": 0.95539}, "CVE-2006-3397": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3398": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-3399": {"epss_score": 0.00704, "epss_percentile": 0.71565}, "CVE-2006-3400": {"epss_score": 0.11656, "epss_percentile": 0.93436}, "CVE-2006-3401": {"epss_score": 0.1, "epss_percentile": 0.9281}, "CVE-2006-3402": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2006-3403": {"epss_score": 0.29763, "epss_percentile": 0.96474}, "CVE-2006-3404": {"epss_score": 0.01905, "epss_percentile": 0.82793}, "CVE-2006-3405": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-3406": {"epss_score": 0.00203, "epss_percentile": 0.42572}, "CVE-2006-3407": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2006-3408": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-3409": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2006-3410": {"epss_score": 0.00647, "epss_percentile": 0.70189}, "CVE-2006-3411": {"epss_score": 0.00257, "epss_percentile": 0.48866}, "CVE-2006-3412": {"epss_score": 0.00351, "epss_percentile": 0.57005}, "CVE-2006-3413": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2006-3414": {"epss_score": 0.00492, "epss_percentile": 0.64987}, "CVE-2006-3415": {"epss_score": 0.00477, "epss_percentile": 0.64338}, "CVE-2006-3416": {"epss_score": 0.0078, "epss_percentile": 0.73164}, "CVE-2006-3417": {"epss_score": 0.00477, "epss_percentile": 0.64338}, "CVE-2006-3418": {"epss_score": 0.00477, "epss_percentile": 0.64338}, "CVE-2006-3419": {"epss_score": 0.0033, "epss_percentile": 0.55432}, "CVE-2006-3420": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-3421": {"epss_score": 0.07536, "epss_percentile": 0.91522}, "CVE-2006-3422": {"epss_score": 0.04945, "epss_percentile": 0.89317}, "CVE-2006-3423": {"epss_score": 0.13082, "epss_percentile": 0.93868}, "CVE-2006-3424": {"epss_score": 0.03736, "epss_percentile": 0.87651}, "CVE-2006-3425": {"epss_score": 0.03739, "epss_percentile": 0.87654}, "CVE-2006-3426": {"epss_score": 0.0202, "epss_percentile": 0.83292}, "CVE-2006-3427": {"epss_score": 0.21979, "epss_percentile": 0.9558}, "CVE-2006-3428": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3429": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3430": {"epss_score": 0.0407, "epss_percentile": 0.88204}, "CVE-2006-3431": {"epss_score": 0.72969, "epss_percentile": 0.98731}, "CVE-2006-3434": {"epss_score": 0.25388, "epss_percentile": 0.96023}, "CVE-2006-3435": {"epss_score": 0.46603, "epss_percentile": 0.97554}, "CVE-2006-3436": {"epss_score": 0.54392, "epss_percentile": 0.97923}, "CVE-2006-3438": {"epss_score": 0.53928, "epss_percentile": 0.97902}, "CVE-2006-3439": {"epss_score": 0.88959, "epss_percentile": 0.99501}, "CVE-2006-3440": {"epss_score": 0.725, "epss_percentile": 0.98713}, "CVE-2006-3441": {"epss_score": 0.73178, "epss_percentile": 0.9874}, "CVE-2006-3442": {"epss_score": 0.51446, "epss_percentile": 0.97778}, "CVE-2006-3443": {"epss_score": 0.02051, "epss_percentile": 0.83405}, "CVE-2006-3444": {"epss_score": 0.19503, "epss_percentile": 0.95194}, "CVE-2006-3445": {"epss_score": 0.64906, "epss_percentile": 0.98398}, "CVE-2006-3448": {"epss_score": 0.62544, "epss_percentile": 0.98296}, "CVE-2006-3449": {"epss_score": 0.23427, "epss_percentile": 0.95776}, "CVE-2006-3450": {"epss_score": 0.63794, "epss_percentile": 0.98349}, "CVE-2006-3451": {"epss_score": 0.64171, "epss_percentile": 0.98368}, "CVE-2006-3452": {"epss_score": 0.00151, "epss_percentile": 0.36337}, "CVE-2006-3453": {"epss_score": 0.15961, "epss_percentile": 0.94544}, "CVE-2006-3454": {"epss_score": 0.00085, "epss_percentile": 0.25036}, "CVE-2006-3455": {"epss_score": 0.00076, "epss_percentile": 0.23164}, "CVE-2006-3456": {"epss_score": 0.08227, "epss_percentile": 0.9194}, "CVE-2006-3457": {"epss_score": 0.00054, "epss_percentile": 0.17281}, "CVE-2006-3458": {"epss_score": 0.00103, "epss_percentile": 0.29011}, "CVE-2006-3459": {"epss_score": 0.67949, "epss_percentile": 0.98527}, "CVE-2006-3460": {"epss_score": 0.00835, "epss_percentile": 0.74118}, "CVE-2006-3461": {"epss_score": 0.0369, "epss_percentile": 0.87574}, "CVE-2006-3462": {"epss_score": 0.01873, "epss_percentile": 0.82645}, "CVE-2006-3463": {"epss_score": 0.03648, "epss_percentile": 0.87504}, "CVE-2006-3464": {"epss_score": 0.01257, "epss_percentile": 0.78944}, "CVE-2006-3465": {"epss_score": 0.14381, "epss_percentile": 0.94199}, "CVE-2006-3467": {"epss_score": 0.08679, "epss_percentile": 0.92195}, "CVE-2006-3468": {"epss_score": 0.26773, "epss_percentile": 0.96179}, "CVE-2006-3469": {"epss_score": 0.52837, "epss_percentile": 0.97843}, "CVE-2006-3470": {"epss_score": 0.03589, "epss_percentile": 0.87397}, "CVE-2006-3471": {"epss_score": 0.4494, "epss_percentile": 0.97462}, "CVE-2006-3472": {"epss_score": 0.33508, "epss_percentile": 0.96781}, "CVE-2006-3473": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-3474": {"epss_score": 0.00312, "epss_percentile": 0.53946}, "CVE-2006-3475": {"epss_score": 0.06242, "epss_percentile": 0.90596}, "CVE-2006-3476": {"epss_score": 0.007, "epss_percentile": 0.7148}, "CVE-2006-3477": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-3478": {"epss_score": 0.04945, "epss_percentile": 0.89317}, "CVE-2006-3479": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-3480": {"epss_score": 0.00036, "epss_percentile": 0.10394}, "CVE-2006-3481": {"epss_score": 0.00044, "epss_percentile": 0.13675}, "CVE-2006-3482": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3483": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2006-3484": {"epss_score": 0.01108, "epss_percentile": 0.77642}, "CVE-2006-3485": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2006-3486": {"epss_score": 0.00088, "epss_percentile": 0.25659}, "CVE-2006-3487": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2006-3488": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-3489": {"epss_score": 0.0134, "epss_percentile": 0.79579}, "CVE-2006-3490": {"epss_score": 0.0134, "epss_percentile": 0.79579}, "CVE-2006-3491": {"epss_score": 0.19387, "epss_percentile": 0.95175}, "CVE-2006-3492": {"epss_score": 0.02512, "epss_percentile": 0.84957}, "CVE-2006-3493": {"epss_score": 0.57694, "epss_percentile": 0.98079}, "CVE-2006-3494": {"epss_score": 0.08149, "epss_percentile": 0.91903}, "CVE-2006-3495": {"epss_score": 0.00072, "epss_percentile": 0.22422}, "CVE-2006-3496": {"epss_score": 0.02263, "epss_percentile": 0.84192}, "CVE-2006-3497": {"epss_score": 0.014, "epss_percentile": 0.80001}, "CVE-2006-3498": {"epss_score": 0.11912, "epss_percentile": 0.93512}, "CVE-2006-3499": {"epss_score": 0.00082, "epss_percentile": 0.24414}, "CVE-2006-3500": {"epss_score": 0.00066, "epss_percentile": 0.20754}, "CVE-2006-3501": {"epss_score": 0.0106, "epss_percentile": 0.77167}, "CVE-2006-3502": {"epss_score": 0.00783, "epss_percentile": 0.73213}, "CVE-2006-3503": {"epss_score": 0.0106, "epss_percentile": 0.77167}, "CVE-2006-3504": {"epss_score": 0.00421, "epss_percentile": 0.61514}, "CVE-2006-3505": {"epss_score": 0.02454, "epss_percentile": 0.84794}, "CVE-2006-3506": {"epss_score": 0.00277, "epss_percentile": 0.50811}, "CVE-2006-3507": {"epss_score": 0.00976, "epss_percentile": 0.76206}, "CVE-2006-3508": {"epss_score": 0.00195, "epss_percentile": 0.41616}, "CVE-2006-3509": {"epss_score": 0.00241, "epss_percentile": 0.4727}, "CVE-2006-3510": {"epss_score": 0.38717, "epss_percentile": 0.97117}, "CVE-2006-3511": {"epss_score": 0.20304, "epss_percentile": 0.95319}, "CVE-2006-3512": {"epss_score": 0.24754, "epss_percentile": 0.95952}, "CVE-2006-3513": {"epss_score": 0.34735, "epss_percentile": 0.9687}, "CVE-2006-3514": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3515": {"epss_score": 0.01447, "epss_percentile": 0.80329}, "CVE-2006-3516": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-3517": {"epss_score": 0.02311, "epss_percentile": 0.8434}, "CVE-2006-3518": {"epss_score": 0.01134, "epss_percentile": 0.77894}, "CVE-2006-3519": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-3520": {"epss_score": 0.04945, "epss_percentile": 0.89317}, "CVE-2006-3521": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-3522": {"epss_score": 0.01053, "epss_percentile": 0.77099}, "CVE-2006-3523": {"epss_score": 0.00672, "epss_percentile": 0.70828}, "CVE-2006-3524": {"epss_score": 0.84237, "epss_percentile": 0.9928}, "CVE-2006-3525": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-3526": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3527": {"epss_score": 0.02726, "epss_percentile": 0.85527}, "CVE-2006-3528": {"epss_score": 0.21612, "epss_percentile": 0.95539}, "CVE-2006-3529": {"epss_score": 0.02086, "epss_percentile": 0.8355}, "CVE-2006-3530": {"epss_score": 0.05499, "epss_percentile": 0.89936}, "CVE-2006-3531": {"epss_score": 0.10876, "epss_percentile": 0.93142}, "CVE-2006-3532": {"epss_score": 0.06581, "epss_percentile": 0.90861}, "CVE-2006-3533": {"epss_score": 0.11812, "epss_percentile": 0.93484}, "CVE-2006-3534": {"epss_score": 0.01252, "epss_percentile": 0.7891}, "CVE-2006-3535": {"epss_score": 0.01903, "epss_percentile": 0.82788}, "CVE-2006-3536": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-3537": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2006-3538": {"epss_score": 0.00611, "epss_percentile": 0.69205}, "CVE-2006-3539": {"epss_score": 0.01345, "epss_percentile": 0.7962}, "CVE-2006-3540": {"epss_score": 0.00034, "epss_percentile": 0.09551}, "CVE-2006-3541": {"epss_score": 0.00695, "epss_percentile": 0.71374}, "CVE-2006-3542": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-3543": {"epss_score": 0.00706, "epss_percentile": 0.7164}, "CVE-2006-3544": {"epss_score": 0.01128, "epss_percentile": 0.77824}, "CVE-2006-3545": {"epss_score": 0.21113, "epss_percentile": 0.95464}, "CVE-2006-3546": {"epss_score": 0.0987, "epss_percentile": 0.92745}, "CVE-2006-3547": {"epss_score": 0.00392, "epss_percentile": 0.59656}, "CVE-2006-3548": {"epss_score": 0.01138, "epss_percentile": 0.77931}, "CVE-2006-3549": {"epss_score": 0.01833, "epss_percentile": 0.82456}, "CVE-2006-3550": {"epss_score": 0.00712, "epss_percentile": 0.71759}, "CVE-2006-3551": {"epss_score": 0.00071, "epss_percentile": 0.22057}, "CVE-2006-3552": {"epss_score": 0.00163, "epss_percentile": 0.37759}, "CVE-2006-3553": {"epss_score": 0.06686, "epss_percentile": 0.90946}, "CVE-2006-3554": {"epss_score": 0.0153, "epss_percentile": 0.80887}, "CVE-2006-3555": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3556": {"epss_score": 0.10003, "epss_percentile": 0.92811}, "CVE-2006-3557": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2006-3558": {"epss_score": 0.00855, "epss_percentile": 0.74459}, "CVE-2006-3559": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2006-3560": {"epss_score": 0.00555, "epss_percentile": 0.67457}, "CVE-2006-3561": {"epss_score": 0.21988, "epss_percentile": 0.95582}, "CVE-2006-3562": {"epss_score": 0.04455, "epss_percentile": 0.88712}, "CVE-2006-3563": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-3564": {"epss_score": 0.0103, "epss_percentile": 0.76841}, "CVE-2006-3565": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3566": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2006-3567": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-3568": {"epss_score": 0.00845, "epss_percentile": 0.74286}, "CVE-2006-3569": {"epss_score": 0.0009, "epss_percentile": 0.26091}, "CVE-2006-3570": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3571": {"epss_score": 0.09361, "epss_percentile": 0.92516}, "CVE-2006-3572": {"epss_score": 0.02661, "epss_percentile": 0.85369}, "CVE-2006-3573": {"epss_score": 0.23841, "epss_percentile": 0.95821}, "CVE-2006-3574": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-3575": {"epss_score": 0.00066, "epss_percentile": 0.20958}, "CVE-2006-3576": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-3577": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2006-3578": {"epss_score": 0.01672, "epss_percentile": 0.81679}, "CVE-2006-3579": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3580": {"epss_score": 0.01285, "epss_percentile": 0.79179}, "CVE-2006-3581": {"epss_score": 0.22301, "epss_percentile": 0.9562}, "CVE-2006-3582": {"epss_score": 0.09029, "epss_percentile": 0.92373}, "CVE-2006-3583": {"epss_score": 0.01304, "epss_percentile": 0.79313}, "CVE-2006-3584": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-3585": {"epss_score": 0.00872, "epss_percentile": 0.74733}, "CVE-2006-3586": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3587": {"epss_score": 0.28895, "epss_percentile": 0.96399}, "CVE-2006-3588": {"epss_score": 0.27799, "epss_percentile": 0.96284}, "CVE-2006-3589": {"epss_score": 0.00066, "epss_percentile": 0.2087}, "CVE-2006-3590": {"epss_score": 0.42595, "epss_percentile": 0.97342}, "CVE-2006-3591": {"epss_score": 0.17424, "epss_percentile": 0.9485}, "CVE-2006-3592": {"epss_score": 0.00928, "epss_percentile": 0.75586}, "CVE-2006-3593": {"epss_score": 0.00581, "epss_percentile": 0.6826}, "CVE-2006-3594": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2006-3595": {"epss_score": 0.01992, "epss_percentile": 0.83179}, "CVE-2006-3596": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-3597": {"epss_score": 0.00056, "epss_percentile": 0.17826}, "CVE-2006-3598": {"epss_score": 0.01035, "epss_percentile": 0.76895}, "CVE-2006-3599": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-3600": {"epss_score": 0.06102, "epss_percentile": 0.90482}, "CVE-2006-3601": {"epss_score": 0.011, "epss_percentile": 0.77568}, "CVE-2006-3602": {"epss_score": 0.05018, "epss_percentile": 0.89399}, "CVE-2006-3603": {"epss_score": 0.00758, "epss_percentile": 0.72782}, "CVE-2006-3604": {"epss_score": 0.02736, "epss_percentile": 0.85551}, "CVE-2006-3605": {"epss_score": 0.21979, "epss_percentile": 0.9558}, "CVE-2006-3606": {"epss_score": 0.0074, "epss_percentile": 0.72405}, "CVE-2006-3607": {"epss_score": 0.00459, "epss_percentile": 0.6348}, "CVE-2006-3608": {"epss_score": 0.03609, "epss_percentile": 0.87422}, "CVE-2006-3609": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3610": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-3611": {"epss_score": 0.02718, "epss_percentile": 0.85512}, "CVE-2006-3612": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-3613": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-3614": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-3615": {"epss_score": 0.01269, "epss_percentile": 0.79039}, "CVE-2006-3616": {"epss_score": 0.00972, "epss_percentile": 0.7614}, "CVE-2006-3617": {"epss_score": 0.00435, "epss_percentile": 0.62341}, "CVE-2006-3618": {"epss_score": 0.0069, "epss_percentile": 0.7124}, "CVE-2006-3619": {"epss_score": 0.01814, "epss_percentile": 0.82379}, "CVE-2006-3620": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-3621": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2006-3622": {"epss_score": 0.0034, "epss_percentile": 0.56245}, "CVE-2006-3623": {"epss_score": 0.01401, "epss_percentile": 0.80009}, "CVE-2006-3624": {"epss_score": 0.00315, "epss_percentile": 0.54205}, "CVE-2006-3625": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-3626": {"epss_score": 0.00075, "epss_percentile": 0.2306}, "CVE-2006-3627": {"epss_score": 0.02182, "epss_percentile": 0.83908}, "CVE-2006-3628": {"epss_score": 0.05887, "epss_percentile": 0.90294}, "CVE-2006-3629": {"epss_score": 0.1052, "epss_percentile": 0.93017}, "CVE-2006-3630": {"epss_score": 0.01265, "epss_percentile": 0.79007}, "CVE-2006-3631": {"epss_score": 0.018, "epss_percentile": 0.82318}, "CVE-2006-3632": {"epss_score": 0.0501, "epss_percentile": 0.8939}, "CVE-2006-3633": {"epss_score": 0.00976, "epss_percentile": 0.76214}, "CVE-2006-3634": {"epss_score": 0.00052, "epss_percentile": 0.16597}, "CVE-2006-3635": {"epss_score": 0.00068, "epss_percentile": 0.21188}, "CVE-2006-3636": {"epss_score": 0.22719, "epss_percentile": 0.95673}, "CVE-2006-3637": {"epss_score": 0.77254, "epss_percentile": 0.98928}, "CVE-2006-3638": {"epss_score": 0.64559, "epss_percentile": 0.98382}, "CVE-2006-3639": {"epss_score": 0.45068, "epss_percentile": 0.9747}, "CVE-2006-3640": {"epss_score": 0.37459, "epss_percentile": 0.97049}, "CVE-2006-3643": {"epss_score": 0.29778, "epss_percentile": 0.96474}, "CVE-2006-3647": {"epss_score": 0.10126, "epss_percentile": 0.9286}, "CVE-2006-3648": {"epss_score": 0.6015, "epss_percentile": 0.98194}, "CVE-2006-3649": {"epss_score": 0.54431, "epss_percentile": 0.97925}, "CVE-2006-3650": {"epss_score": 0.52924, "epss_percentile": 0.97846}, "CVE-2006-3651": {"epss_score": 0.59337, "epss_percentile": 0.98161}, "CVE-2006-3652": {"epss_score": 0.19995, "epss_percentile": 0.95272}, "CVE-2006-3653": {"epss_score": 0.44359, "epss_percentile": 0.97431}, "CVE-2006-3654": {"epss_score": 0.39583, "epss_percentile": 0.97169}, "CVE-2006-3655": {"epss_score": 0.64843, "epss_percentile": 0.98395}, "CVE-2006-3656": {"epss_score": 0.6363, "epss_percentile": 0.98342}, "CVE-2006-3657": {"epss_score": 0.30922, "epss_percentile": 0.96575}, "CVE-2006-3658": {"epss_score": 0.29854, "epss_percentile": 0.96481}, "CVE-2006-3659": {"epss_score": 0.31192, "epss_percentile": 0.966}, "CVE-2006-3660": {"epss_score": 0.59598, "epss_percentile": 0.98171}, "CVE-2006-3661": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-3662": {"epss_score": 0.00826, "epss_percentile": 0.73974}, "CVE-2006-3663": {"epss_score": 0.00065, "epss_percentile": 0.20642}, "CVE-2006-3664": {"epss_score": 0.0192, "epss_percentile": 0.82894}, "CVE-2006-3665": {"epss_score": 0.00342, "epss_percentile": 0.56387}, "CVE-2006-3666": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-3667": {"epss_score": 0.00475, "epss_percentile": 0.64175}, "CVE-2006-3668": {"epss_score": 0.17902, "epss_percentile": 0.94924}, "CVE-2006-3669": {"epss_score": 0.00053, "epss_percentile": 0.1686}, "CVE-2006-3670": {"epss_score": 0.2488, "epss_percentile": 0.95962}, "CVE-2006-3671": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-3672": {"epss_score": 0.05623, "epss_percentile": 0.90062}, "CVE-2006-3673": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2006-3674": {"epss_score": 0.01886, "epss_percentile": 0.82712}, "CVE-2006-3675": {"epss_score": 0.00115, "epss_percentile": 0.31016}, "CVE-2006-3676": {"epss_score": 0.00746, "epss_percentile": 0.72547}, "CVE-2006-3677": {"epss_score": 0.81109, "epss_percentile": 0.9912}, "CVE-2006-3678": {"epss_score": 0.01344, "epss_percentile": 0.79618}, "CVE-2006-3679": {"epss_score": 0.00763, "epss_percentile": 0.72882}, "CVE-2006-3680": {"epss_score": 0.00949, "epss_percentile": 0.75844}, "CVE-2006-3681": {"epss_score": 0.00613, "epss_percentile": 0.69242}, "CVE-2006-3682": {"epss_score": 0.07923, "epss_percentile": 0.91764}, "CVE-2006-3683": {"epss_score": 0.09778, "epss_percentile": 0.92698}, "CVE-2006-3684": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2006-3685": {"epss_score": 0.06684, "epss_percentile": 0.90943}, "CVE-2006-3686": {"epss_score": 0.0154, "epss_percentile": 0.80941}, "CVE-2006-3687": {"epss_score": 0.20829, "epss_percentile": 0.9542}, "CVE-2006-3688": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-3689": {"epss_score": 0.11128, "epss_percentile": 0.93232}, "CVE-2006-3690": {"epss_score": 0.11063, "epss_percentile": 0.93207}, "CVE-2006-3691": {"epss_score": 0.0139, "epss_percentile": 0.79934}, "CVE-2006-3692": {"epss_score": 0.06656, "epss_percentile": 0.9092}, "CVE-2006-3693": {"epss_score": 0.0043, "epss_percentile": 0.62009}, "CVE-2006-3694": {"epss_score": 0.02668, "epss_percentile": 0.85382}, "CVE-2006-3695": {"epss_score": 0.03036, "epss_percentile": 0.86262}, "CVE-2006-3696": {"epss_score": 0.00299, "epss_percentile": 0.52854}, "CVE-2006-3697": {"epss_score": 0.00069, "epss_percentile": 0.21469}, "CVE-2006-3698": {"epss_score": 0.25858, "epss_percentile": 0.96085}, "CVE-2006-3699": {"epss_score": 0.02805, "epss_percentile": 0.85705}, "CVE-2006-3700": {"epss_score": 0.03608, "epss_percentile": 0.8742}, "CVE-2006-3701": {"epss_score": 0.02482, "epss_percentile": 0.84878}, "CVE-2006-3702": {"epss_score": 0.03593, "epss_percentile": 0.87402}, "CVE-2006-3703": {"epss_score": 0.02482, "epss_percentile": 0.84878}, "CVE-2006-3704": {"epss_score": 0.0311, "epss_percentile": 0.86424}, "CVE-2006-3705": {"epss_score": 0.03933, "epss_percentile": 0.87978}, "CVE-2006-3706": {"epss_score": 0.0204, "epss_percentile": 0.83367}, "CVE-2006-3707": {"epss_score": 0.0178, "epss_percentile": 0.82234}, "CVE-2006-3708": {"epss_score": 0.0423, "epss_percentile": 0.88421}, "CVE-2006-3709": {"epss_score": 0.02279, "epss_percentile": 0.84239}, "CVE-2006-3710": {"epss_score": 0.0423, "epss_percentile": 0.88421}, "CVE-2006-3711": {"epss_score": 0.02279, "epss_percentile": 0.84239}, "CVE-2006-3712": {"epss_score": 0.02794, "epss_percentile": 0.85677}, "CVE-2006-3713": {"epss_score": 0.02279, "epss_percentile": 0.84239}, "CVE-2006-3714": {"epss_score": 0.02279, "epss_percentile": 0.84239}, "CVE-2006-3715": {"epss_score": 0.03566, "epss_percentile": 0.87364}, "CVE-2006-3716": {"epss_score": 0.03037, "epss_percentile": 0.86265}, "CVE-2006-3717": {"epss_score": 0.03566, "epss_percentile": 0.87364}, "CVE-2006-3718": {"epss_score": 0.03566, "epss_percentile": 0.87364}, "CVE-2006-3719": {"epss_score": 0.01838, "epss_percentile": 0.82484}, "CVE-2006-3720": {"epss_score": 0.01838, "epss_percentile": 0.82484}, "CVE-2006-3721": {"epss_score": 0.03566, "epss_percentile": 0.87364}, "CVE-2006-3722": {"epss_score": 0.03566, "epss_percentile": 0.87364}, "CVE-2006-3723": {"epss_score": 0.03566, "epss_percentile": 0.87364}, "CVE-2006-3724": {"epss_score": 0.03566, "epss_percentile": 0.87364}, "CVE-2006-3725": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-2006-3726": {"epss_score": 0.80852, "epss_percentile": 0.9911}, "CVE-2006-3727": {"epss_score": 0.05415, "epss_percentile": 0.8985}, "CVE-2006-3728": {"epss_score": 0.01671, "epss_percentile": 0.81676}, "CVE-2006-3729": {"epss_score": 0.18898, "epss_percentile": 0.95088}, "CVE-2006-3730": {"epss_score": 0.88442, "epss_percentile": 0.99473}, "CVE-2006-3731": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2006-3732": {"epss_score": 0.0054, "epss_percentile": 0.67001}, "CVE-2006-3733": {"epss_score": 0.17901, "epss_percentile": 0.94924}, "CVE-2006-3734": {"epss_score": 0.01211, "epss_percentile": 0.78554}, "CVE-2006-3735": {"epss_score": 0.17202, "epss_percentile": 0.94799}, "CVE-2006-3736": {"epss_score": 0.08653, "epss_percentile": 0.92174}, "CVE-2006-3737": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-3738": {"epss_score": 0.32326, "epss_percentile": 0.9669}, "CVE-2006-3739": {"epss_score": 0.00176, "epss_percentile": 0.39392}, "CVE-2006-3740": {"epss_score": 0.0007, "epss_percentile": 0.21818}, "CVE-2006-3741": {"epss_score": 0.00045, "epss_percentile": 0.13828}, "CVE-2006-3742": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2006-3743": {"epss_score": 0.02086, "epss_percentile": 0.83552}, "CVE-2006-3744": {"epss_score": 0.02059, "epss_percentile": 0.83437}, "CVE-2006-3745": {"epss_score": 0.00131, "epss_percentile": 0.33383}, "CVE-2006-3746": {"epss_score": 0.33245, "epss_percentile": 0.96756}, "CVE-2006-3747": {"epss_score": 0.92739, "epss_percentile": 0.99741}, "CVE-2006-3748": {"epss_score": 0.05675, "epss_percentile": 0.90109}, "CVE-2006-3749": {"epss_score": 0.12847, "epss_percentile": 0.93801}, "CVE-2006-3750": {"epss_score": 0.07811, "epss_percentile": 0.91694}, "CVE-2006-3751": {"epss_score": 0.06343, "epss_percentile": 0.90683}, "CVE-2006-3752": {"epss_score": 0.01139, "epss_percentile": 0.77945}, "CVE-2006-3753": {"epss_score": 0.00488, "epss_percentile": 0.64841}, "CVE-2006-3754": {"epss_score": 0.0791, "epss_percentile": 0.91758}, "CVE-2006-3755": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2006-3756": {"epss_score": 0.00639, "epss_percentile": 0.69954}, "CVE-2006-3757": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-3758": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-3759": {"epss_score": 0.00437, "epss_percentile": 0.62512}, "CVE-2006-3760": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-3761": {"epss_score": 0.01328, "epss_percentile": 0.79495}, "CVE-2006-3762": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-3763": {"epss_score": 0.00555, "epss_percentile": 0.67457}, "CVE-2006-3764": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2006-3765": {"epss_score": 0.00653, "epss_percentile": 0.70329}, "CVE-2006-3766": {"epss_score": 0.00388, "epss_percentile": 0.59371}, "CVE-2006-3767": {"epss_score": 0.02028, "epss_percentile": 0.83324}, "CVE-2006-3768": {"epss_score": 0.1218, "epss_percentile": 0.93597}, "CVE-2006-3769": {"epss_score": 0.01386, "epss_percentile": 0.79912}, "CVE-2006-3770": {"epss_score": 0.0139, "epss_percentile": 0.79934}, "CVE-2006-3771": {"epss_score": 0.10989, "epss_percentile": 0.93184}, "CVE-2006-3772": {"epss_score": 0.05942, "epss_percentile": 0.9035}, "CVE-2006-3773": {"epss_score": 0.19075, "epss_percentile": 0.95125}, "CVE-2006-3774": {"epss_score": 0.62876, "epss_percentile": 0.98311}, "CVE-2006-3775": {"epss_score": 0.021, "epss_percentile": 0.83601}, "CVE-2006-3776": {"epss_score": 0.06072, "epss_percentile": 0.90453}, "CVE-2006-3777": {"epss_score": 0.03262, "epss_percentile": 0.86773}, "CVE-2006-3778": {"epss_score": 0.00513, "epss_percentile": 0.65879}, "CVE-2006-3779": {"epss_score": 0.00943, "epss_percentile": 0.7577}, "CVE-2006-3780": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2006-3781": {"epss_score": 0.00994, "epss_percentile": 0.76421}, "CVE-2006-3782": {"epss_score": 0.00054, "epss_percentile": 0.17046}, "CVE-2006-3783": {"epss_score": 0.00054, "epss_percentile": 0.17046}, "CVE-2006-3784": {"epss_score": 0.00044, "epss_percentile": 0.13589}, "CVE-2006-3785": {"epss_score": 0.00079, "epss_percentile": 0.2384}, "CVE-2006-3786": {"epss_score": 0.00096, "epss_percentile": 0.2734}, "CVE-2006-3787": {"epss_score": 0.0022, "epss_percentile": 0.44576}, "CVE-2006-3788": {"epss_score": 0.07618, "epss_percentile": 0.91572}, "CVE-2006-3789": {"epss_score": 0.05619, "epss_percentile": 0.90058}, "CVE-2006-3790": {"epss_score": 0.02512, "epss_percentile": 0.84957}, "CVE-2006-3791": {"epss_score": 0.02512, "epss_percentile": 0.84957}, "CVE-2006-3792": {"epss_score": 0.01343, "epss_percentile": 0.79604}, "CVE-2006-3793": {"epss_score": 0.07919, "epss_percentile": 0.91762}, "CVE-2006-3794": {"epss_score": 0.01119, "epss_percentile": 0.77754}, "CVE-2006-3795": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-3796": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-3797": {"epss_score": 0.01111, "epss_percentile": 0.77666}, "CVE-2006-3798": {"epss_score": 0.00392, "epss_percentile": 0.59666}, "CVE-2006-3799": {"epss_score": 0.00442, "epss_percentile": 0.62722}, "CVE-2006-3800": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-3801": {"epss_score": 0.27761, "epss_percentile": 0.9628}, "CVE-2006-3802": {"epss_score": 0.03764, "epss_percentile": 0.87694}, "CVE-2006-3803": {"epss_score": 0.23453, "epss_percentile": 0.95779}, "CVE-2006-3804": {"epss_score": 0.18151, "epss_percentile": 0.94966}, "CVE-2006-3805": {"epss_score": 0.23003, "epss_percentile": 0.95716}, "CVE-2006-3806": {"epss_score": 0.29557, "epss_percentile": 0.96456}, "CVE-2006-3807": {"epss_score": 0.2749, "epss_percentile": 0.96252}, "CVE-2006-3808": {"epss_score": 0.02341, "epss_percentile": 0.84436}, "CVE-2006-3809": {"epss_score": 0.02964, "epss_percentile": 0.86078}, "CVE-2006-3810": {"epss_score": 0.1364, "epss_percentile": 0.94019}, "CVE-2006-3811": {"epss_score": 0.18952, "epss_percentile": 0.95101}, "CVE-2006-3812": {"epss_score": 0.13369, "epss_percentile": 0.93944}, "CVE-2006-3813": {"epss_score": 0.00096, "epss_percentile": 0.27286}, "CVE-2006-3814": {"epss_score": 0.10201, "epss_percentile": 0.9289}, "CVE-2006-3815": {"epss_score": 0.00223, "epss_percentile": 0.44865}, "CVE-2006-3816": {"epss_score": 0.00459, "epss_percentile": 0.63468}, "CVE-2006-3817": {"epss_score": 0.00657, "epss_percentile": 0.70468}, "CVE-2006-3818": {"epss_score": 0.02011, "epss_percentile": 0.83251}, "CVE-2006-3819": {"epss_score": 0.07898, "epss_percentile": 0.91752}, "CVE-2006-3820": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3821": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-3822": {"epss_score": 0.00475, "epss_percentile": 0.64189}, "CVE-2006-3823": {"epss_score": 0.05201, "epss_percentile": 0.89604}, "CVE-2006-3824": {"epss_score": 0.00256, "epss_percentile": 0.48772}, "CVE-2006-3825": {"epss_score": 0.00071, "epss_percentile": 0.21999}, "CVE-2006-3826": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-3827": {"epss_score": 0.0082, "epss_percentile": 0.73892}, "CVE-2006-3828": {"epss_score": 0.00376, "epss_percentile": 0.58664}, "CVE-2006-3829": {"epss_score": 0.0057, "epss_percentile": 0.67965}, "CVE-2006-3830": {"epss_score": 0.00249, "epss_percentile": 0.4802}, "CVE-2006-3831": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-3832": {"epss_score": 0.04027, "epss_percentile": 0.88145}, "CVE-2006-3833": {"epss_score": 0.00392, "epss_percentile": 0.59666}, "CVE-2006-3834": {"epss_score": 0.00343, "epss_percentile": 0.56452}, "CVE-2006-3835": {"epss_score": 0.56443, "epss_percentile": 0.98022}, "CVE-2006-3836": {"epss_score": 0.07279, "epss_percentile": 0.91381}, "CVE-2006-3837": {"epss_score": 0.00622, "epss_percentile": 0.69515}, "CVE-2006-3838": {"epss_score": 0.7153, "epss_percentile": 0.98672}, "CVE-2006-3840": {"epss_score": 0.04123, "epss_percentile": 0.88285}, "CVE-2006-3841": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-3842": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-3843": {"epss_score": 0.02822, "epss_percentile": 0.85748}, "CVE-2006-3844": {"epss_score": 0.01374, "epss_percentile": 0.79825}, "CVE-2006-3845": {"epss_score": 0.05579, "epss_percentile": 0.90016}, "CVE-2006-3846": {"epss_score": 0.05055, "epss_percentile": 0.89447}, "CVE-2006-3847": {"epss_score": 0.1742, "epss_percentile": 0.94849}, "CVE-2006-3848": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2006-3849": {"epss_score": 0.04874, "epss_percentile": 0.89237}, "CVE-2006-3850": {"epss_score": 0.06636, "epss_percentile": 0.90907}, "CVE-2006-3851": {"epss_score": 0.00838, "epss_percentile": 0.74173}, "CVE-2006-3852": {"epss_score": 0.00631, "epss_percentile": 0.69715}, "CVE-2006-3853": {"epss_score": 0.0614, "epss_percentile": 0.90513}, "CVE-2006-3854": {"epss_score": 0.07465, "epss_percentile": 0.91488}, "CVE-2006-3855": {"epss_score": 0.01298, "epss_percentile": 0.79272}, "CVE-2006-3856": {"epss_score": 0.00067, "epss_percentile": 0.21117}, "CVE-2006-3857": {"epss_score": 0.04242, "epss_percentile": 0.88437}, "CVE-2006-3858": {"epss_score": 0.00066, "epss_percentile": 0.2096}, "CVE-2006-3859": {"epss_score": 0.00361, "epss_percentile": 0.57728}, "CVE-2006-3860": {"epss_score": 0.03199, "epss_percentile": 0.86617}, "CVE-2006-3861": {"epss_score": 0.00436, "epss_percentile": 0.62485}, "CVE-2006-3862": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2006-3864": {"epss_score": 0.45707, "epss_percentile": 0.97499}, "CVE-2006-3867": {"epss_score": 0.38938, "epss_percentile": 0.97128}, "CVE-2006-3868": {"epss_score": 0.54494, "epss_percentile": 0.97926}, "CVE-2006-3869": {"epss_score": 0.72358, "epss_percentile": 0.98705}, "CVE-2006-3873": {"epss_score": 0.4623, "epss_percentile": 0.97537}, "CVE-2006-3875": {"epss_score": 0.38938, "epss_percentile": 0.97128}, "CVE-2006-3876": {"epss_score": 0.36538, "epss_percentile": 0.96985}, "CVE-2006-3877": {"epss_score": 0.38807, "epss_percentile": 0.97121}, "CVE-2006-3878": {"epss_score": 0.0006, "epss_percentile": 0.19015}, "CVE-2006-3879": {"epss_score": 0.0702, "epss_percentile": 0.91191}, "CVE-2006-3880": {"epss_score": 0.15628, "epss_percentile": 0.94472}, "CVE-2006-3881": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-3882": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-3883": {"epss_score": 0.03512, "epss_percentile": 0.87269}, "CVE-2006-3884": {"epss_score": 0.02389, "epss_percentile": 0.84591}, "CVE-2006-3885": {"epss_score": 0.01256, "epss_percentile": 0.78937}, "CVE-2006-3886": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2006-3887": {"epss_score": 0.08555, "epss_percentile": 0.92123}, "CVE-2006-3888": {"epss_score": 0.198, "epss_percentile": 0.95243}, "CVE-2006-3890": {"epss_score": 0.49555, "epss_percentile": 0.97695}, "CVE-2006-3892": {"epss_score": 0.0979, "epss_percentile": 0.92703}, "CVE-2006-3893": {"epss_score": 0.19751, "epss_percentile": 0.95237}, "CVE-2006-3894": {"epss_score": 0.12269, "epss_percentile": 0.93617}, "CVE-2006-3896": {"epss_score": 0.0042, "epss_percentile": 0.6146}, "CVE-2006-3897": {"epss_score": 0.38314, "epss_percentile": 0.97094}, "CVE-2006-3898": {"epss_score": 0.21979, "epss_percentile": 0.9558}, "CVE-2006-3899": {"epss_score": 0.17424, "epss_percentile": 0.9485}, "CVE-2006-3900": {"epss_score": 0.01724, "epss_percentile": 0.81948}, "CVE-2006-3901": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2006-3902": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-3903": {"epss_score": 0.0082, "epss_percentile": 0.73879}, "CVE-2006-3904": {"epss_score": 0.0331, "epss_percentile": 0.86887}, "CVE-2006-3905": {"epss_score": 0.01229, "epss_percentile": 0.78714}, "CVE-2006-3906": {"epss_score": 0.04277, "epss_percentile": 0.88484}, "CVE-2006-3907": {"epss_score": 0.02545, "epss_percentile": 0.85062}, "CVE-2006-3908": {"epss_score": 0.02468, "epss_percentile": 0.84841}, "CVE-2006-3909": {"epss_score": 0.00758, "epss_percentile": 0.72782}, "CVE-2006-3910": {"epss_score": 0.39664, "epss_percentile": 0.97174}, "CVE-2006-3911": {"epss_score": 0.16699, "epss_percentile": 0.94717}, "CVE-2006-3912": {"epss_score": 0.00913, "epss_percentile": 0.75376}, "CVE-2006-3913": {"epss_score": 0.08871, "epss_percentile": 0.92295}, "CVE-2006-3914": {"epss_score": 0.00502, "epss_percentile": 0.65378}, "CVE-2006-3915": {"epss_score": 0.20304, "epss_percentile": 0.95319}, "CVE-2006-3916": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3917": {"epss_score": 0.04945, "epss_percentile": 0.89317}, "CVE-2006-3918": {"epss_score": 0.91373, "epss_percentile": 0.99637}, "CVE-2006-3919": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2006-3920": {"epss_score": 0.02029, "epss_percentile": 0.83327}, "CVE-2006-3921": {"epss_score": 0.00976, "epss_percentile": 0.76206}, "CVE-2006-3922": {"epss_score": 0.10316, "epss_percentile": 0.92941}, "CVE-2006-3923": {"epss_score": 0.00675, "epss_percentile": 0.70903}, "CVE-2006-3924": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-3925": {"epss_score": 0.01615, "epss_percentile": 0.81352}, "CVE-2006-3926": {"epss_score": 0.01321, "epss_percentile": 0.79445}, "CVE-2006-3927": {"epss_score": 0.00758, "epss_percentile": 0.72782}, "CVE-2006-3928": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-3929": {"epss_score": 0.0953, "epss_percentile": 0.92587}, "CVE-2006-3930": {"epss_score": 0.12544, "epss_percentile": 0.93712}, "CVE-2006-3931": {"epss_score": 0.00228, "epss_percentile": 0.45502}, "CVE-2006-3932": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-3933": {"epss_score": 0.00475, "epss_percentile": 0.64242}, "CVE-2006-3934": {"epss_score": 0.00435, "epss_percentile": 0.62348}, "CVE-2006-3935": {"epss_score": 0.02392, "epss_percentile": 0.84602}, "CVE-2006-3936": {"epss_score": 0.00496, "epss_percentile": 0.65175}, "CVE-2006-3937": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-3938": {"epss_score": 0.01094, "epss_percentile": 0.77489}, "CVE-2006-3939": {"epss_score": 0.01035, "epss_percentile": 0.76902}, "CVE-2006-3940": {"epss_score": 0.00481, "epss_percentile": 0.64512}, "CVE-2006-3941": {"epss_score": 0.0075, "epss_percentile": 0.72619}, "CVE-2006-3942": {"epss_score": 0.86205, "epss_percentile": 0.99373}, "CVE-2006-3943": {"epss_score": 0.33036, "epss_percentile": 0.96741}, "CVE-2006-3944": {"epss_score": 0.42977, "epss_percentile": 0.97364}, "CVE-2006-3945": {"epss_score": 0.01302, "epss_percentile": 0.793}, "CVE-2006-3946": {"epss_score": 0.04722, "epss_percentile": 0.89056}, "CVE-2006-3947": {"epss_score": 0.24944, "epss_percentile": 0.95971}, "CVE-2006-3948": {"epss_score": 0.03175, "epss_percentile": 0.86566}, "CVE-2006-3949": {"epss_score": 0.07362, "epss_percentile": 0.91433}, "CVE-2006-3950": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2006-3951": {"epss_score": 0.05783, "epss_percentile": 0.90204}, "CVE-2006-3952": {"epss_score": 0.87004, "epss_percentile": 0.99408}, "CVE-2006-3953": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2006-3954": {"epss_score": 0.00271, "epss_percentile": 0.5028}, "CVE-2006-3955": {"epss_score": 0.08013, "epss_percentile": 0.91828}, "CVE-2006-3956": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-3957": {"epss_score": 0.02067, "epss_percentile": 0.8346}, "CVE-2006-3958": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-3959": {"epss_score": 0.00553, "epss_percentile": 0.6742}, "CVE-2006-3960": {"epss_score": 0.00595, "epss_percentile": 0.68688}, "CVE-2006-3961": {"epss_score": 0.70793, "epss_percentile": 0.98642}, "CVE-2006-3962": {"epss_score": 0.02971, "epss_percentile": 0.86094}, "CVE-2006-3963": {"epss_score": 0.0036, "epss_percentile": 0.57664}, "CVE-2006-3964": {"epss_score": 0.01778, "epss_percentile": 0.82228}, "CVE-2006-3965": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2006-3966": {"epss_score": 0.13402, "epss_percentile": 0.93953}, "CVE-2006-3967": {"epss_score": 0.02164, "epss_percentile": 0.83842}, "CVE-2006-3968": {"epss_score": 0.00591, "epss_percentile": 0.68578}, "CVE-2006-3969": {"epss_score": 0.16832, "epss_percentile": 0.94736}, "CVE-2006-3970": {"epss_score": 0.07619, "epss_percentile": 0.91573}, "CVE-2006-3971": {"epss_score": 0.02076, "epss_percentile": 0.83511}, "CVE-2006-3972": {"epss_score": 0.05018, "epss_percentile": 0.89399}, "CVE-2006-3973": {"epss_score": 0.00053, "epss_percentile": 0.17036}, "CVE-2006-3974": {"epss_score": 0.00598, "epss_percentile": 0.68755}, "CVE-2006-3975": {"epss_score": 0.02739, "epss_percentile": 0.85554}, "CVE-2006-3976": {"epss_score": 0.01287, "epss_percentile": 0.79191}, "CVE-2006-3977": {"epss_score": 0.01287, "epss_percentile": 0.79191}, "CVE-2006-3978": {"epss_score": 0.00403, "epss_percentile": 0.60382}, "CVE-2006-3979": {"epss_score": 0.0002, "epss_percentile": 0.04513}, "CVE-2006-3980": {"epss_score": 0.16156, "epss_percentile": 0.9458}, "CVE-2006-3981": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-3982": {"epss_score": 0.02164, "epss_percentile": 0.83842}, "CVE-2006-3983": {"epss_score": 0.04945, "epss_percentile": 0.89317}, "CVE-2006-3984": {"epss_score": 0.12825, "epss_percentile": 0.93795}, "CVE-2006-3985": {"epss_score": 0.03643, "epss_percentile": 0.87494}, "CVE-2006-3986": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2006-3987": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2006-3988": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2006-3989": {"epss_score": 0.20843, "epss_percentile": 0.95425}, "CVE-2006-3990": {"epss_score": 0.15279, "epss_percentile": 0.94398}, "CVE-2006-3991": {"epss_score": 0.04945, "epss_percentile": 0.89317}, "CVE-2006-3992": {"epss_score": 0.04016, "epss_percentile": 0.88122}, "CVE-2006-3993": {"epss_score": 0.07926, "epss_percentile": 0.91765}, "CVE-2006-3994": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2006-3995": {"epss_score": 0.10157, "epss_percentile": 0.92868}, "CVE-2006-3996": {"epss_score": 0.03172, "epss_percentile": 0.8655}, "CVE-2006-3997": {"epss_score": 0.05797, "epss_percentile": 0.90218}, "CVE-2006-3998": {"epss_score": 0.06242, "epss_percentile": 0.90596}, "CVE-2006-3999": {"epss_score": 0.00063, "epss_percentile": 0.20075}, "CVE-2006-4000": {"epss_score": 0.04009, "epss_percentile": 0.88108}, "CVE-2006-4001": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2006-4002": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-4003": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-4004": {"epss_score": 0.09854, "epss_percentile": 0.92736}, "CVE-2006-4005": {"epss_score": 0.04269, "epss_percentile": 0.88473}, "CVE-2006-4006": {"epss_score": 0.11903, "epss_percentile": 0.9351}, "CVE-2006-4007": {"epss_score": 0.02164, "epss_percentile": 0.83842}, "CVE-2006-4008": {"epss_score": 0.02164, "epss_percentile": 0.83842}, "CVE-2006-4009": {"epss_score": 0.03175, "epss_percentile": 0.86566}, "CVE-2006-4010": {"epss_score": 0.02144, "epss_percentile": 0.8376}, "CVE-2006-4011": {"epss_score": 0.04665, "epss_percentile": 0.88979}, "CVE-2006-4012": {"epss_score": 0.13614, "epss_percentile": 0.94014}, "CVE-2006-4013": {"epss_score": 0.00678, "epss_percentile": 0.70985}, "CVE-2006-4014": {"epss_score": 0.01133, "epss_percentile": 0.77881}, "CVE-2006-4015": {"epss_score": 0.02642, "epss_percentile": 0.8531}, "CVE-2006-4016": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-4017": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-4018": {"epss_score": 0.44627, "epss_percentile": 0.97446}, "CVE-2006-4019": {"epss_score": 0.28114, "epss_percentile": 0.96312}, "CVE-2006-4020": {"epss_score": 0.0586, "epss_percentile": 0.9027}, "CVE-2006-4021": {"epss_score": 0.00263, "epss_percentile": 0.49472}, "CVE-2006-4022": {"epss_score": 0.00095, "epss_percentile": 0.27189}, "CVE-2006-4023": {"epss_score": 0.00144, "epss_percentile": 0.35289}, "CVE-2006-4024": {"epss_score": 0.05379, "epss_percentile": 0.89808}, "CVE-2006-4025": {"epss_score": 0.00858, "epss_percentile": 0.74506}, "CVE-2006-4026": {"epss_score": 0.20902, "epss_percentile": 0.95436}, "CVE-2006-4028": {"epss_score": 0.05593, "epss_percentile": 0.90032}, "CVE-2006-4029": {"epss_score": 0.34554, "epss_percentile": 0.96855}, "CVE-2006-4030": {"epss_score": 0.00647, "epss_percentile": 0.70189}, "CVE-2006-4031": {"epss_score": 0.00235, "epss_percentile": 0.46207}, "CVE-2006-4032": {"epss_score": 0.00684, "epss_percentile": 0.71123}, "CVE-2006-4033": {"epss_score": 0.07706, "epss_percentile": 0.91637}, "CVE-2006-4034": {"epss_score": 0.01503, "epss_percentile": 0.80734}, "CVE-2006-4035": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2006-4036": {"epss_score": 0.0871, "epss_percentile": 0.92221}, "CVE-2006-4037": {"epss_score": 0.0367, "epss_percentile": 0.87537}, "CVE-2006-4038": {"epss_score": 0.00694, "epss_percentile": 0.71362}, "CVE-2006-4039": {"epss_score": 0.013, "epss_percentile": 0.79287}, "CVE-2006-4040": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2006-4041": {"epss_score": 0.01775, "epss_percentile": 0.82215}, "CVE-2006-4042": {"epss_score": 0.0262, "epss_percentile": 0.85254}, "CVE-2006-4043": {"epss_score": 0.00611, "epss_percentile": 0.69202}, "CVE-2006-4044": {"epss_score": 0.04012, "epss_percentile": 0.88114}, "CVE-2006-4045": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2006-4046": {"epss_score": 0.25216, "epss_percentile": 0.95999}, "CVE-2006-4047": {"epss_score": 0.01053, "epss_percentile": 0.77098}, "CVE-2006-4048": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-4049": {"epss_score": 0.00071, "epss_percentile": 0.22072}, "CVE-2006-4050": {"epss_score": 0.06547, "epss_percentile": 0.90841}, "CVE-2006-4051": {"epss_score": 0.08799, "epss_percentile": 0.92259}, "CVE-2006-4052": {"epss_score": 0.18882, "epss_percentile": 0.95083}, "CVE-2006-4053": {"epss_score": 0.11727, "epss_percentile": 0.9346}, "CVE-2006-4054": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-4055": {"epss_score": 0.23727, "epss_percentile": 0.95811}, "CVE-2006-4056": {"epss_score": 0.02069, "epss_percentile": 0.83468}, "CVE-2006-4057": {"epss_score": 0.02435, "epss_percentile": 0.84738}, "CVE-2006-4058": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-4059": {"epss_score": 0.13909, "epss_percentile": 0.9409}, "CVE-2006-4060": {"epss_score": 0.17339, "epss_percentile": 0.9483}, "CVE-2006-4061": {"epss_score": 0.06572, "epss_percentile": 0.90855}, "CVE-2006-4062": {"epss_score": 0.06101, "epss_percentile": 0.90481}, "CVE-2006-4063": {"epss_score": 0.03866, "epss_percentile": 0.87872}, "CVE-2006-4064": {"epss_score": 0.02534, "epss_percentile": 0.85034}, "CVE-2006-4065": {"epss_score": 0.05726, "epss_percentile": 0.90157}, "CVE-2006-4066": {"epss_score": 0.22263, "epss_percentile": 0.95617}, "CVE-2006-4067": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-4068": {"epss_score": 0.04264, "epss_percentile": 0.88467}, "CVE-2006-4069": {"epss_score": 0.00681, "epss_percentile": 0.7106}, "CVE-2006-4070": {"epss_score": 0.00793, "epss_percentile": 0.73431}, "CVE-2006-4071": {"epss_score": 0.29453, "epss_percentile": 0.96444}, "CVE-2006-4072": {"epss_score": 0.00878, "epss_percentile": 0.74826}, "CVE-2006-4073": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2006-4074": {"epss_score": 0.00406, "epss_percentile": 0.60553}, "CVE-2006-4075": {"epss_score": 0.12532, "epss_percentile": 0.93709}, "CVE-2006-4076": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-4077": {"epss_score": 0.06714, "epss_percentile": 0.90963}, "CVE-2006-4078": {"epss_score": 0.00978, "epss_percentile": 0.76237}, "CVE-2006-4079": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-4080": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-4081": {"epss_score": 0.10092, "epss_percentile": 0.92846}, "CVE-2006-4082": {"epss_score": 0.00079, "epss_percentile": 0.23902}, "CVE-2006-4083": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2006-4084": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2006-4085": {"epss_score": 0.01605, "epss_percentile": 0.81292}, "CVE-2006-4086": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-4087": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-4088": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-4089": {"epss_score": 0.24803, "epss_percentile": 0.95955}, "CVE-2006-4090": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-4091": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-4092": {"epss_score": 0.00071, "epss_percentile": 0.22072}, "CVE-2006-4093": {"epss_score": 0.00062, "epss_percentile": 0.1973}, "CVE-2006-4095": {"epss_score": 0.07771, "epss_percentile": 0.91673}, "CVE-2006-4096": {"epss_score": 0.24501, "epss_percentile": 0.95927}, "CVE-2006-4097": {"epss_score": 0.01827, "epss_percentile": 0.82436}, "CVE-2006-4098": {"epss_score": 0.15801, "epss_percentile": 0.94511}, "CVE-2006-4099": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2006-4102": {"epss_score": 0.04343, "epss_percentile": 0.88573}, "CVE-2006-4103": {"epss_score": 0.20843, "epss_percentile": 0.95425}, "CVE-2006-4104": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-4105": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-4106": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-4107": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-4108": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-4109": {"epss_score": 0.00463, "epss_percentile": 0.63682}, "CVE-2006-4110": {"epss_score": 0.17318, "epss_percentile": 0.94822}, "CVE-2006-4111": {"epss_score": 0.0288, "epss_percentile": 0.85898}, "CVE-2006-4112": {"epss_score": 0.0857, "epss_percentile": 0.92129}, "CVE-2006-4113": {"epss_score": 0.12825, "epss_percentile": 0.93795}, "CVE-2006-4114": {"epss_score": 0.02661, "epss_percentile": 0.85369}, "CVE-2006-4115": {"epss_score": 0.02551, "epss_percentile": 0.85076}, "CVE-2006-4116": {"epss_score": 0.01993, "epss_percentile": 0.83185}, "CVE-2006-4117": {"epss_score": 0.00916, "epss_percentile": 0.75422}, "CVE-2006-4118": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2006-4119": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-4120": {"epss_score": 0.01666, "epss_percentile": 0.81651}, "CVE-2006-4121": {"epss_score": 0.0791, "epss_percentile": 0.91758}, "CVE-2006-4122": {"epss_score": 0.06676, "epss_percentile": 0.90936}, "CVE-2006-4123": {"epss_score": 0.04945, "epss_percentile": 0.89317}, "CVE-2006-4124": {"epss_score": 0.00121, "epss_percentile": 0.31892}, "CVE-2006-4125": {"epss_score": 0.26993, "epss_percentile": 0.96197}, "CVE-2006-4126": {"epss_score": 0.15602, "epss_percentile": 0.94468}, "CVE-2006-4127": {"epss_score": 0.01576, "epss_percentile": 0.81114}, "CVE-2006-4128": {"epss_score": 0.18258, "epss_percentile": 0.94983}, "CVE-2006-4129": {"epss_score": 0.81148, "epss_percentile": 0.99124}, "CVE-2006-4130": {"epss_score": 0.07549, "epss_percentile": 0.91532}, "CVE-2006-4131": {"epss_score": 0.29944, "epss_percentile": 0.96488}, "CVE-2006-4132": {"epss_score": 0.0238, "epss_percentile": 0.84562}, "CVE-2006-4133": {"epss_score": 0.19859, "epss_percentile": 0.95252}, "CVE-2006-4134": {"epss_score": 0.01928, "epss_percentile": 0.82932}, "CVE-2006-4135": {"epss_score": 0.0164, "epss_percentile": 0.815}, "CVE-2006-4136": {"epss_score": 0.00666, "epss_percentile": 0.70678}, "CVE-2006-4137": {"epss_score": 0.00485, "epss_percentile": 0.64722}, "CVE-2006-4138": {"epss_score": 0.45482, "epss_percentile": 0.97489}, "CVE-2006-4139": {"epss_score": 0.00919, "epss_percentile": 0.75456}, "CVE-2006-4140": {"epss_score": 0.10883, "epss_percentile": 0.93146}, "CVE-2006-4141": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-4142": {"epss_score": 0.01788, "epss_percentile": 0.82265}, "CVE-2006-4143": {"epss_score": 0.00834, "epss_percentile": 0.74111}, "CVE-2006-4144": {"epss_score": 0.22224, "epss_percentile": 0.95611}, "CVE-2006-4145": {"epss_score": 0.00122, "epss_percentile": 0.32017}, "CVE-2006-4146": {"epss_score": 0.01258, "epss_percentile": 0.78958}, "CVE-2006-4154": {"epss_score": 0.32788, "epss_percentile": 0.96724}, "CVE-2006-4155": {"epss_score": 0.00558, "epss_percentile": 0.67601}, "CVE-2006-4156": {"epss_score": 0.05783, "epss_percentile": 0.90204}, "CVE-2006-4157": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-4158": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-4159": {"epss_score": 0.0833, "epss_percentile": 0.91993}, "CVE-2006-4160": {"epss_score": 0.11341, "epss_percentile": 0.93315}, "CVE-2006-4161": {"epss_score": 0.09007, "epss_percentile": 0.92361}, "CVE-2006-4162": {"epss_score": 0.0141, "epss_percentile": 0.80081}, "CVE-2006-4163": {"epss_score": 0.06655, "epss_percentile": 0.90919}, "CVE-2006-4164": {"epss_score": 0.04504, "epss_percentile": 0.88769}, "CVE-2006-4165": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-4166": {"epss_score": 0.11189, "epss_percentile": 0.9326}, "CVE-2006-4168": {"epss_score": 0.0599, "epss_percentile": 0.90385}, "CVE-2006-4169": {"epss_score": 0.00777, "epss_percentile": 0.73112}, "CVE-2006-4172": {"epss_score": 0.0006, "epss_percentile": 0.1917}, "CVE-2006-4175": {"epss_score": 0.01768, "epss_percentile": 0.82181}, "CVE-2006-4177": {"epss_score": 0.09582, "epss_percentile": 0.92607}, "CVE-2006-4178": {"epss_score": 0.0013, "epss_percentile": 0.33224}, "CVE-2006-4181": {"epss_score": 0.22643, "epss_percentile": 0.95664}, "CVE-2006-4182": {"epss_score": 0.16623, "epss_percentile": 0.94704}, "CVE-2006-4183": {"epss_score": 0.38734, "epss_percentile": 0.97118}, "CVE-2006-4184": {"epss_score": 0.00043, "epss_percentile": 0.13101}, "CVE-2006-4185": {"epss_score": 0.00046, "epss_percentile": 0.14129}, "CVE-2006-4186": {"epss_score": 0.00064, "epss_percentile": 0.20284}, "CVE-2006-4187": {"epss_score": 0.00099, "epss_percentile": 0.27836}, "CVE-2006-4188": {"epss_score": 0.05097, "epss_percentile": 0.89495}, "CVE-2006-4189": {"epss_score": 0.05676, "epss_percentile": 0.90111}, "CVE-2006-4190": {"epss_score": 0.00149, "epss_percentile": 0.36011}, "CVE-2006-4191": {"epss_score": 0.14052, "epss_percentile": 0.94122}, "CVE-2006-4192": {"epss_score": 0.18195, "epss_percentile": 0.94973}, "CVE-2006-4193": {"epss_score": 0.39028, "epss_percentile": 0.97136}, "CVE-2006-4194": {"epss_score": 0.00905, "epss_percentile": 0.75241}, "CVE-2006-4195": {"epss_score": 0.10243, "epss_percentile": 0.92909}, "CVE-2006-4196": {"epss_score": 0.10388, "epss_percentile": 0.92971}, "CVE-2006-4197": {"epss_score": 0.34865, "epss_percentile": 0.96876}, "CVE-2006-4198": {"epss_score": 0.16568, "epss_percentile": 0.94694}, "CVE-2006-4199": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-4200": {"epss_score": 0.00541, "epss_percentile": 0.67051}, "CVE-2006-4201": {"epss_score": 0.36122, "epss_percentile": 0.96957}, "CVE-2006-4202": {"epss_score": 0.01272, "epss_percentile": 0.7908}, "CVE-2006-4203": {"epss_score": 0.0723, "epss_percentile": 0.91338}, "CVE-2006-4204": {"epss_score": 0.06222, "epss_percentile": 0.90582}, "CVE-2006-4205": {"epss_score": 0.0489, "epss_percentile": 0.89259}, "CVE-2006-4206": {"epss_score": 0.1691, "epss_percentile": 0.94747}, "CVE-2006-4207": {"epss_score": 0.08811, "epss_percentile": 0.92266}, "CVE-2006-4208": {"epss_score": 0.27172, "epss_percentile": 0.96216}, "CVE-2006-4209": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2006-4210": {"epss_score": 0.0716, "epss_percentile": 0.91292}, "CVE-2006-4211": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-4212": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-4213": {"epss_score": 0.05783, "epss_percentile": 0.90204}, "CVE-2006-4214": {"epss_score": 0.01301, "epss_percentile": 0.79289}, "CVE-2006-4215": {"epss_score": 0.04203, "epss_percentile": 0.88389}, "CVE-2006-4217": {"epss_score": 0.01605, "epss_percentile": 0.81292}, "CVE-2006-4218": {"epss_score": 0.01398, "epss_percentile": 0.7999}, "CVE-2006-4219": {"epss_score": 0.41228, "epss_percentile": 0.97261}, "CVE-2006-4220": {"epss_score": 0.00616, "epss_percentile": 0.69331}, "CVE-2006-4221": {"epss_score": 0.46308, "epss_percentile": 0.9754}, "CVE-2006-4222": {"epss_score": 0.00355, "epss_percentile": 0.57286}, "CVE-2006-4223": {"epss_score": 0.00573, "epss_percentile": 0.68049}, "CVE-2006-4224": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-4226": {"epss_score": 0.00806, "epss_percentile": 0.73646}, "CVE-2006-4227": {"epss_score": 0.12486, "epss_percentile": 0.93687}, "CVE-2006-4228": {"epss_score": 0.03975, "epss_percentile": 0.88048}, "CVE-2006-4229": {"epss_score": 0.00064, "epss_percentile": 0.20424}, "CVE-2006-4230": {"epss_score": 0.02164, "epss_percentile": 0.83842}, "CVE-2006-4231": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2006-4232": {"epss_score": 0.0007, "epss_percentile": 0.21641}, "CVE-2006-4233": {"epss_score": 0.00044, "epss_percentile": 0.13526}, "CVE-2006-4234": {"epss_score": 0.05096, "epss_percentile": 0.89492}, "CVE-2006-4235": {"epss_score": 0.10419, "epss_percentile": 0.92983}, "CVE-2006-4236": {"epss_score": 0.11055, "epss_percentile": 0.93203}, "CVE-2006-4237": {"epss_score": 0.04945, "epss_percentile": 0.89317}, "CVE-2006-4238": {"epss_score": 0.00828, "epss_percentile": 0.73996}, "CVE-2006-4239": {"epss_score": 0.0601, "epss_percentile": 0.90408}, "CVE-2006-4240": {"epss_score": 0.07387, "epss_percentile": 0.91446}, "CVE-2006-4241": {"epss_score": 0.02164, "epss_percentile": 0.83842}, "CVE-2006-4242": {"epss_score": 0.01621, "epss_percentile": 0.81389}, "CVE-2006-4243": {"epss_score": 0.00372, "epss_percentile": 0.58423}, "CVE-2006-4244": {"epss_score": 0.01636, "epss_percentile": 0.8148}, "CVE-2006-4245": {"epss_score": 0.00335, "epss_percentile": 0.55801}, "CVE-2006-4246": {"epss_score": 0.00565, "epss_percentile": 0.6778}, "CVE-2006-4247": {"epss_score": 0.00333, "epss_percentile": 0.55642}, "CVE-2006-4248": {"epss_score": 0.00049, "epss_percentile": 0.1545}, "CVE-2006-4249": {"epss_score": 0.00593, "epss_percentile": 0.68642}, "CVE-2006-4250": {"epss_score": 0.00328, "epss_percentile": 0.55271}, "CVE-2006-4251": {"epss_score": 0.00024, "epss_percentile": 0.05838}, "CVE-2006-4252": {"epss_score": 0.00012, "epss_percentile": 0.01329}, "CVE-2006-4253": {"epss_score": 0.30757, "epss_percentile": 0.96566}, "CVE-2006-4254": {"epss_score": 0.0178, "epss_percentile": 0.82233}, "CVE-2006-4255": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2006-4256": {"epss_score": 0.0103, "epss_percentile": 0.76841}, "CVE-2006-4257": {"epss_score": 0.01257, "epss_percentile": 0.78951}, "CVE-2006-4258": {"epss_score": 0.0034, "epss_percentile": 0.56269}, "CVE-2006-4259": {"epss_score": 0.00414, "epss_percentile": 0.61095}, "CVE-2006-4260": {"epss_score": 0.0035, "epss_percentile": 0.56919}, "CVE-2006-4262": {"epss_score": 0.01603, "epss_percentile": 0.81279}, "CVE-2006-4263": {"epss_score": 0.04935, "epss_percentile": 0.893}, "CVE-2006-4264": {"epss_score": 0.01323, "epss_percentile": 0.79455}, "CVE-2006-4265": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-4266": {"epss_score": 0.00087, "epss_percentile": 0.25631}, "CVE-2006-4267": {"epss_score": 0.03626, "epss_percentile": 0.87459}, "CVE-2006-4268": {"epss_score": 0.05897, "epss_percentile": 0.90305}, "CVE-2006-4269": {"epss_score": 0.00071, "epss_percentile": 0.22208}, "CVE-2006-4270": {"epss_score": 0.12761, "epss_percentile": 0.93766}, "CVE-2006-4271": {"epss_score": 0.02543, "epss_percentile": 0.85058}, "CVE-2006-4272": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2006-4273": {"epss_score": 0.00725, "epss_percentile": 0.72046}, "CVE-2006-4275": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-4276": {"epss_score": 0.12825, "epss_percentile": 0.93795}, "CVE-2006-4277": {"epss_score": 0.08053, "epss_percentile": 0.91856}, "CVE-2006-4278": {"epss_score": 0.14705, "epss_percentile": 0.94267}, "CVE-2006-4279": {"epss_score": 0.01615, "epss_percentile": 0.81352}, "CVE-2006-4280": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2006-4281": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2006-4282": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2006-4283": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-4284": {"epss_score": 0.03188, "epss_percentile": 0.86592}, "CVE-2006-4285": {"epss_score": 0.14752, "epss_percentile": 0.94274}, "CVE-2006-4286": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2006-4287": {"epss_score": 0.13516, "epss_percentile": 0.93986}, "CVE-2006-4288": {"epss_score": 0.07451, "epss_percentile": 0.91479}, "CVE-2006-4289": {"epss_score": 0.30327, "epss_percentile": 0.96529}, "CVE-2006-4290": {"epss_score": 0.01284, "epss_percentile": 0.79173}, "CVE-2006-4291": {"epss_score": 0.08686, "epss_percentile": 0.92201}, "CVE-2006-4292": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-4293": {"epss_score": 0.02132, "epss_percentile": 0.83716}, "CVE-2006-4294": {"epss_score": 0.06202, "epss_percentile": 0.90562}, "CVE-2006-4295": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-4296": {"epss_score": 0.11235, "epss_percentile": 0.93274}, "CVE-2006-4297": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-4298": {"epss_score": 0.00271, "epss_percentile": 0.5028}, "CVE-2006-4299": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-4300": {"epss_score": 0.0305, "epss_percentile": 0.86289}, "CVE-2006-4301": {"epss_score": 0.37715, "epss_percentile": 0.97065}, "CVE-2006-4302": {"epss_score": 0.01581, "epss_percentile": 0.8114}, "CVE-2006-4303": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2006-4304": {"epss_score": 0.06855, "epss_percentile": 0.91077}, "CVE-2006-4305": {"epss_score": 0.71142, "epss_percentile": 0.98656}, "CVE-2006-4306": {"epss_score": 0.00056, "epss_percentile": 0.17881}, "CVE-2006-4307": {"epss_score": 0.00053, "epss_percentile": 0.17036}, "CVE-2006-4308": {"epss_score": 0.00962, "epss_percentile": 0.75984}, "CVE-2006-4309": {"epss_score": 0.00959, "epss_percentile": 0.75957}, "CVE-2006-4310": {"epss_score": 0.15769, "epss_percentile": 0.94506}, "CVE-2006-4311": {"epss_score": 0.0325, "epss_percentile": 0.86749}, "CVE-2006-4312": {"epss_score": 0.0007, "epss_percentile": 0.21668}, "CVE-2006-4313": {"epss_score": 0.67665, "epss_percentile": 0.98517}, "CVE-2006-4314": {"epss_score": 0.01935, "epss_percentile": 0.82957}, "CVE-2006-4315": {"epss_score": 0.00055, "epss_percentile": 0.17461}, "CVE-2006-4316": {"epss_score": 0.00053, "epss_percentile": 0.17036}, "CVE-2006-4317": {"epss_score": 0.01486, "epss_percentile": 0.80601}, "CVE-2006-4318": {"epss_score": 0.7975, "epss_percentile": 0.99054}, "CVE-2006-4319": {"epss_score": 0.0007, "epss_percentile": 0.21759}, "CVE-2006-4320": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-4321": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-4322": {"epss_score": 0.01449, "epss_percentile": 0.80341}, "CVE-2006-4323": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-4324": {"epss_score": 0.0192, "epss_percentile": 0.82891}, "CVE-2006-4325": {"epss_score": 0.0192, "epss_percentile": 0.82891}, "CVE-2006-4326": {"epss_score": 0.0767, "epss_percentile": 0.91614}, "CVE-2006-4327": {"epss_score": 0.0192, "epss_percentile": 0.82891}, "CVE-2006-4328": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-4329": {"epss_score": 0.09264, "epss_percentile": 0.9247}, "CVE-2006-4330": {"epss_score": 0.11528, "epss_percentile": 0.93393}, "CVE-2006-4331": {"epss_score": 0.03927, "epss_percentile": 0.87967}, "CVE-2006-4332": {"epss_score": 0.03132, "epss_percentile": 0.86476}, "CVE-2006-4333": {"epss_score": 0.03966, "epss_percentile": 0.8803}, "CVE-2006-4334": {"epss_score": 0.08683, "epss_percentile": 0.92198}, "CVE-2006-4335": {"epss_score": 0.02039, "epss_percentile": 0.83362}, "CVE-2006-4336": {"epss_score": 0.04646, "epss_percentile": 0.88961}, "CVE-2006-4337": {"epss_score": 0.04174, "epss_percentile": 0.8835}, "CVE-2006-4338": {"epss_score": 0.06393, "epss_percentile": 0.9072}, "CVE-2006-4339": {"epss_score": 0.08526, "epss_percentile": 0.92104}, "CVE-2006-4340": {"epss_score": 0.04507, "epss_percentile": 0.88774}, "CVE-2006-4342": {"epss_score": 0.00162, "epss_percentile": 0.37635}, "CVE-2006-4343": {"epss_score": 0.06929, "epss_percentile": 0.91122}, "CVE-2006-4344": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-4345": {"epss_score": 0.05153, "epss_percentile": 0.8955}, "CVE-2006-4346": {"epss_score": 0.02329, "epss_percentile": 0.84397}, "CVE-2006-4347": {"epss_score": 0.01958, "epss_percentile": 0.83048}, "CVE-2006-4348": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2006-4349": {"epss_score": 0.05721, "epss_percentile": 0.90151}, "CVE-2006-4350": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-4351": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-4352": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2006-4353": {"epss_score": 0.00847, "epss_percentile": 0.74347}, "CVE-2006-4354": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-4355": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-4356": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-4357": {"epss_score": 0.02164, "epss_percentile": 0.83842}, "CVE-2006-4358": {"epss_score": 0.07636, "epss_percentile": 0.91591}, "CVE-2006-4359": {"epss_score": 0.11557, "epss_percentile": 0.93404}, "CVE-2006-4360": {"epss_score": 0.00301, "epss_percentile": 0.53}, "CVE-2006-4361": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-4362": {"epss_score": 0.07101, "epss_percentile": 0.91252}, "CVE-2006-4363": {"epss_score": 0.06242, "epss_percentile": 0.90596}, "CVE-2006-4364": {"epss_score": 0.69171, "epss_percentile": 0.98579}, "CVE-2006-4365": {"epss_score": 0.16523, "epss_percentile": 0.94685}, "CVE-2006-4366": {"epss_score": 0.02388, "epss_percentile": 0.84591}, "CVE-2006-4367": {"epss_score": 0.00838, "epss_percentile": 0.74173}, "CVE-2006-4368": {"epss_score": 0.08811, "epss_percentile": 0.92266}, "CVE-2006-4369": {"epss_score": 0.08369, "epss_percentile": 0.92013}, "CVE-2006-4370": {"epss_score": 0.01495, "epss_percentile": 0.80656}, "CVE-2006-4371": {"epss_score": 0.01175, "epss_percentile": 0.78265}, "CVE-2006-4372": {"epss_score": 0.06591, "epss_percentile": 0.90872}, "CVE-2006-4373": {"epss_score": 0.1218, "epss_percentile": 0.93596}, "CVE-2006-4374": {"epss_score": 0.03955, "epss_percentile": 0.88005}, "CVE-2006-4375": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2006-4376": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2006-4377": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-4378": {"epss_score": 0.01195, "epss_percentile": 0.7843}, "CVE-2006-4379": {"epss_score": 0.50537, "epss_percentile": 0.9774}, "CVE-2006-4380": {"epss_score": 0.00058, "epss_percentile": 0.18299}, "CVE-2006-4381": {"epss_score": 0.09146, "epss_percentile": 0.92421}, "CVE-2006-4382": {"epss_score": 0.28528, "epss_percentile": 0.96365}, "CVE-2006-4384": {"epss_score": 0.42613, "epss_percentile": 0.97343}, "CVE-2006-4385": {"epss_score": 0.26623, "epss_percentile": 0.96163}, "CVE-2006-4386": {"epss_score": 0.29617, "epss_percentile": 0.96461}, "CVE-2006-4387": {"epss_score": 0.0009, "epss_percentile": 0.26091}, "CVE-2006-4388": {"epss_score": 0.23838, "epss_percentile": 0.95821}, "CVE-2006-4389": {"epss_score": 0.32055, "epss_percentile": 0.96669}, "CVE-2006-4390": {"epss_score": 0.00277, "epss_percentile": 0.50814}, "CVE-2006-4391": {"epss_score": 0.14822, "epss_percentile": 0.94293}, "CVE-2006-4392": {"epss_score": 0.01086, "epss_percentile": 0.77425}, "CVE-2006-4393": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2006-4394": {"epss_score": 0.01402, "epss_percentile": 0.80013}, "CVE-2006-4395": {"epss_score": 0.01454, "epss_percentile": 0.80377}, "CVE-2006-4396": {"epss_score": 0.00089, "epss_percentile": 0.25817}, "CVE-2006-4397": {"epss_score": 0.0009, "epss_percentile": 0.26091}, "CVE-2006-4398": {"epss_score": 0.00096, "epss_percentile": 0.27356}, "CVE-2006-4399": {"epss_score": 0.00215, "epss_percentile": 0.44098}, "CVE-2006-4400": {"epss_score": 0.01347, "epss_percentile": 0.79651}, "CVE-2006-4401": {"epss_score": 0.02445, "epss_percentile": 0.84767}, "CVE-2006-4402": {"epss_score": 0.14263, "epss_percentile": 0.94175}, "CVE-2006-4403": {"epss_score": 0.03618, "epss_percentile": 0.87438}, "CVE-2006-4404": {"epss_score": 0.00545, "epss_percentile": 0.67175}, "CVE-2006-4406": {"epss_score": 0.21031, "epss_percentile": 0.95455}, "CVE-2006-4407": {"epss_score": 0.01001, "epss_percentile": 0.76495}, "CVE-2006-4408": {"epss_score": 0.00338, "epss_percentile": 0.56138}, "CVE-2006-4409": {"epss_score": 0.00861, "epss_percentile": 0.74562}, "CVE-2006-4410": {"epss_score": 0.00388, "epss_percentile": 0.59373}, "CVE-2006-4411": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2006-4412": {"epss_score": 0.10699, "epss_percentile": 0.93075}, "CVE-2006-4413": {"epss_score": 0.00036, "epss_percentile": 0.10206}, "CVE-2006-4416": {"epss_score": 0.00081, "epss_percentile": 0.2421}, "CVE-2006-4417": {"epss_score": 0.0139, "epss_percentile": 0.79934}, "CVE-2006-4418": {"epss_score": 0.12406, "epss_percentile": 0.93661}, "CVE-2006-4419": {"epss_score": 0.01121, "epss_percentile": 0.77775}, "CVE-2006-4420": {"epss_score": 0.062, "epss_percentile": 0.90559}, "CVE-2006-4421": {"epss_score": 0.0285, "epss_percentile": 0.85828}, "CVE-2006-4422": {"epss_score": 0.09054, "epss_percentile": 0.92381}, "CVE-2006-4423": {"epss_score": 0.02454, "epss_percentile": 0.84794}, "CVE-2006-4424": {"epss_score": 0.08003, "epss_percentile": 0.91822}, "CVE-2006-4425": {"epss_score": 0.04427, "epss_percentile": 0.88675}, "CVE-2006-4426": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-4427": {"epss_score": 0.09648, "epss_percentile": 0.92639}, "CVE-2006-4428": {"epss_score": 0.07331, "epss_percentile": 0.91414}, "CVE-2006-4429": {"epss_score": 0.01269, "epss_percentile": 0.79042}, "CVE-2006-4430": {"epss_score": 0.0236, "epss_percentile": 0.84494}, "CVE-2006-4431": {"epss_score": 0.04556, "epss_percentile": 0.88847}, "CVE-2006-4432": {"epss_score": 0.01415, "epss_percentile": 0.80135}, "CVE-2006-4433": {"epss_score": 0.02825, "epss_percentile": 0.85755}, "CVE-2006-4434": {"epss_score": 0.07028, "epss_percentile": 0.91196}, "CVE-2006-4435": {"epss_score": 0.00055, "epss_percentile": 0.1763}, "CVE-2006-4436": {"epss_score": 0.00669, "epss_percentile": 0.70762}, "CVE-2006-4437": {"epss_score": 0.10251, "epss_percentile": 0.92912}, "CVE-2006-4438": {"epss_score": 0.03946, "epss_percentile": 0.87997}, "CVE-2006-4439": {"epss_score": 0.0005, "epss_percentile": 0.15863}, "CVE-2006-4440": {"epss_score": 0.13057, "epss_percentile": 0.9386}, "CVE-2006-4441": {"epss_score": 0.01503, "epss_percentile": 0.80734}, "CVE-2006-4442": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-4443": {"epss_score": 0.00877, "epss_percentile": 0.74799}, "CVE-2006-4444": {"epss_score": 0.016, "epss_percentile": 0.81257}, "CVE-2006-4445": {"epss_score": 0.01507, "epss_percentile": 0.80755}, "CVE-2006-4446": {"epss_score": 0.76076, "epss_percentile": 0.98877}, "CVE-2006-4447": {"epss_score": 0.00175, "epss_percentile": 0.39344}, "CVE-2006-4448": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2006-4449": {"epss_score": 0.06539, "epss_percentile": 0.90833}, "CVE-2006-4450": {"epss_score": 0.04788, "epss_percentile": 0.89147}, "CVE-2006-4451": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-4452": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-4453": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-4454": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2006-4455": {"epss_score": 0.47508, "epss_percentile": 0.9759}, "CVE-2006-4456": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2006-4457": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-4458": {"epss_score": 0.07325, "epss_percentile": 0.9141}, "CVE-2006-4459": {"epss_score": 0.00512, "epss_percentile": 0.65873}, "CVE-2006-4460": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-4461": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2006-4462": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2006-4463": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-4464": {"epss_score": 0.04322, "epss_percentile": 0.88549}, "CVE-2006-4465": {"epss_score": 0.23355, "epss_percentile": 0.9577}, "CVE-2006-4466": {"epss_score": 0.00194, "epss_percentile": 0.41518}, "CVE-2006-4467": {"epss_score": 0.01007, "epss_percentile": 0.76562}, "CVE-2006-4468": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2006-4469": {"epss_score": 0.00211, "epss_percentile": 0.43686}, "CVE-2006-4470": {"epss_score": 0.00217, "epss_percentile": 0.44298}, "CVE-2006-4471": {"epss_score": 0.00097, "epss_percentile": 0.27494}, "CVE-2006-4472": {"epss_score": 0.00069, "epss_percentile": 0.21553}, "CVE-2006-4473": {"epss_score": 0.00018, "epss_percentile": 0.03891}, "CVE-2006-4474": {"epss_score": 0.00046, "epss_percentile": 0.14317}, "CVE-2006-4475": {"epss_score": 0.0002, "epss_percentile": 0.04518}, "CVE-2006-4476": {"epss_score": 0.00045, "epss_percentile": 0.13765}, "CVE-2006-4477": {"epss_score": 0.06025, "epss_percentile": 0.90419}, "CVE-2006-4478": {"epss_score": 0.01727, "epss_percentile": 0.81969}, "CVE-2006-4479": {"epss_score": 0.0801, "epss_percentile": 0.91826}, "CVE-2006-4480": {"epss_score": 0.00448, "epss_percentile": 0.63008}, "CVE-2006-4481": {"epss_score": 0.00063, "epss_percentile": 0.19845}, "CVE-2006-4482": {"epss_score": 0.04104, "epss_percentile": 0.88263}, "CVE-2006-4483": {"epss_score": 0.0144, "epss_percentile": 0.803}, "CVE-2006-4484": {"epss_score": 0.06436, "epss_percentile": 0.90756}, "CVE-2006-4485": {"epss_score": 0.01749, "epss_percentile": 0.82087}, "CVE-2006-4486": {"epss_score": 0.01471, "epss_percentile": 0.805}, "CVE-2006-4487": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-4488": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2006-4489": {"epss_score": 0.11035, "epss_percentile": 0.93196}, "CVE-2006-4490": {"epss_score": 0.06304, "epss_percentile": 0.90659}, "CVE-2006-4491": {"epss_score": 0.01565, "epss_percentile": 0.81063}, "CVE-2006-4492": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-4493": {"epss_score": 0.00059, "epss_percentile": 0.18656}, "CVE-2006-4494": {"epss_score": 0.52482, "epss_percentile": 0.97828}, "CVE-2006-4495": {"epss_score": 0.5457, "epss_percentile": 0.97933}, "CVE-2006-4496": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-4497": {"epss_score": 0.00475, "epss_percentile": 0.64189}, "CVE-2006-4498": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2006-4499": {"epss_score": 0.00186, "epss_percentile": 0.40667}, "CVE-2006-4500": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-4501": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-4502": {"epss_score": 0.0076, "epss_percentile": 0.72809}, "CVE-2006-4503": {"epss_score": 0.0035, "epss_percentile": 0.56919}, "CVE-2006-4504": {"epss_score": 0.01076, "epss_percentile": 0.77328}, "CVE-2006-4505": {"epss_score": 0.07942, "epss_percentile": 0.9178}, "CVE-2006-4506": {"epss_score": 0.0007, "epss_percentile": 0.21646}, "CVE-2006-4507": {"epss_score": 0.00078, "epss_percentile": 0.23665}, "CVE-2006-4508": {"epss_score": 0.01348, "epss_percentile": 0.79666}, "CVE-2006-4509": {"epss_score": 0.44869, "epss_percentile": 0.97457}, "CVE-2006-4510": {"epss_score": 0.37863, "epss_percentile": 0.97074}, "CVE-2006-4511": {"epss_score": 0.07184, "epss_percentile": 0.91305}, "CVE-2006-4513": {"epss_score": 0.08368, "epss_percentile": 0.92011}, "CVE-2006-4514": {"epss_score": 0.02208, "epss_percentile": 0.84007}, "CVE-2006-4516": {"epss_score": 0.00232, "epss_percentile": 0.45968}, "CVE-2006-4517": {"epss_score": 0.02914, "epss_percentile": 0.85977}, "CVE-2006-4518": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2006-4519": {"epss_score": 0.07393, "epss_percentile": 0.9145}, "CVE-2006-4520": {"epss_score": 0.08062, "epss_percentile": 0.91861}, "CVE-2006-4521": {"epss_score": 0.03398, "epss_percentile": 0.87063}, "CVE-2006-4522": {"epss_score": 0.00053, "epss_percentile": 0.16679}, "CVE-2006-4523": {"epss_score": 0.11065, "epss_percentile": 0.93208}, "CVE-2006-4524": {"epss_score": 0.02841, "epss_percentile": 0.85804}, "CVE-2006-4525": {"epss_score": 0.03397, "epss_percentile": 0.87061}, "CVE-2006-4526": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-4527": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-4528": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-4529": {"epss_score": 0.00948, "epss_percentile": 0.75833}, "CVE-2006-4530": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-4531": {"epss_score": 0.11634, "epss_percentile": 0.93425}, "CVE-2006-4532": {"epss_score": 0.1092, "epss_percentile": 0.93158}, "CVE-2006-4533": {"epss_score": 0.03182, "epss_percentile": 0.86582}, "CVE-2006-4534": {"epss_score": 0.46692, "epss_percentile": 0.97555}, "CVE-2006-4535": {"epss_score": 0.00093, "epss_percentile": 0.26737}, "CVE-2006-4536": {"epss_score": 0.00788, "epss_percentile": 0.73333}, "CVE-2006-4537": {"epss_score": 0.00074, "epss_percentile": 0.22779}, "CVE-2006-4538": {"epss_score": 0.00086, "epss_percentile": 0.25417}, "CVE-2006-4539": {"epss_score": 0.00584, "epss_percentile": 0.68372}, "CVE-2006-4540": {"epss_score": 0.00758, "epss_percentile": 0.72782}, "CVE-2006-4541": {"epss_score": 0.00339, "epss_percentile": 0.5617}, "CVE-2006-4542": {"epss_score": 0.02523, "epss_percentile": 0.85008}, "CVE-2006-4543": {"epss_score": 0.03022, "epss_percentile": 0.86226}, "CVE-2006-4544": {"epss_score": 0.0113, "epss_percentile": 0.77846}, "CVE-2006-4545": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2006-4546": {"epss_score": 0.01023, "epss_percentile": 0.76771}, "CVE-2006-4547": {"epss_score": 0.00428, "epss_percentile": 0.61924}, "CVE-2006-4548": {"epss_score": 0.01495, "epss_percentile": 0.8068}, "CVE-2006-4549": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-4550": {"epss_score": 0.00259, "epss_percentile": 0.49083}, "CVE-2006-4551": {"epss_score": 0.01059, "epss_percentile": 0.77158}, "CVE-2006-4552": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2006-4553": {"epss_score": 0.00273, "epss_percentile": 0.50426}, "CVE-2006-4554": {"epss_score": 0.03206, "epss_percentile": 0.86634}, "CVE-2006-4555": {"epss_score": 0.08555, "epss_percentile": 0.92123}, "CVE-2006-4556": {"epss_score": 0.00044, "epss_percentile": 0.13599}, "CVE-2006-4557": {"epss_score": 0.01059, "epss_percentile": 0.77158}, "CVE-2006-4558": {"epss_score": 0.09018, "epss_percentile": 0.92369}, "CVE-2006-4559": {"epss_score": 0.0707, "epss_percentile": 0.91227}, "CVE-2006-4560": {"epss_score": 0.21465, "epss_percentile": 0.95522}, "CVE-2006-4561": {"epss_score": 0.01048, "epss_percentile": 0.77048}, "CVE-2006-4562": {"epss_score": 0.00875, "epss_percentile": 0.74782}, "CVE-2006-4563": {"epss_score": 0.00785, "epss_percentile": 0.73251}, "CVE-2006-4564": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-4565": {"epss_score": 0.10073, "epss_percentile": 0.92839}, "CVE-2006-4566": {"epss_score": 0.18696, "epss_percentile": 0.95056}, "CVE-2006-4567": {"epss_score": 0.0227, "epss_percentile": 0.84208}, "CVE-2006-4568": {"epss_score": 0.00884, "epss_percentile": 0.74924}, "CVE-2006-4569": {"epss_score": 0.02727, "epss_percentile": 0.85529}, "CVE-2006-4570": {"epss_score": 0.01068, "epss_percentile": 0.77236}, "CVE-2006-4571": {"epss_score": 0.09634, "epss_percentile": 0.92633}, "CVE-2006-4572": {"epss_score": 0.0179, "epss_percentile": 0.8228}, "CVE-2006-4573": {"epss_score": 0.01168, "epss_percentile": 0.78193}, "CVE-2006-4574": {"epss_score": 0.06819, "epss_percentile": 0.91046}, "CVE-2006-4575": {"epss_score": 0.0119, "epss_percentile": 0.78392}, "CVE-2006-4576": {"epss_score": 0.01214, "epss_percentile": 0.78571}, "CVE-2006-4577": {"epss_score": 0.01795, "epss_percentile": 0.82301}, "CVE-2006-4578": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2006-4579": {"epss_score": 0.00703, "epss_percentile": 0.71547}, "CVE-2006-4580": {"epss_score": 0.0043, "epss_percentile": 0.62019}, "CVE-2006-4581": {"epss_score": 0.00504, "epss_percentile": 0.65542}, "CVE-2006-4582": {"epss_score": 0.00409, "epss_percentile": 0.60755}, "CVE-2006-4583": {"epss_score": 0.12689, "epss_percentile": 0.9375}, "CVE-2006-4584": {"epss_score": 0.17792, "epss_percentile": 0.94907}, "CVE-2006-4585": {"epss_score": 0.05345, "epss_percentile": 0.89767}, "CVE-2006-4586": {"epss_score": 0.10537, "epss_percentile": 0.93021}, "CVE-2006-4587": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-4588": {"epss_score": 0.00994, "epss_percentile": 0.76422}, "CVE-2006-4589": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-4590": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2006-4591": {"epss_score": 0.00583, "epss_percentile": 0.68342}, "CVE-2006-4592": {"epss_score": 0.02016, "epss_percentile": 0.83277}, "CVE-2006-4593": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2006-4594": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-4595": {"epss_score": 0.00547, "epss_percentile": 0.67246}, "CVE-2006-4596": {"epss_score": 0.04188, "epss_percentile": 0.88367}, "CVE-2006-4597": {"epss_score": 0.01081, "epss_percentile": 0.77371}, "CVE-2006-4598": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-4599": {"epss_score": 0.00685, "epss_percentile": 0.71147}, "CVE-2006-4600": {"epss_score": 0.00103, "epss_percentile": 0.28991}, "CVE-2006-4601": {"epss_score": 0.01432, "epss_percentile": 0.80248}, "CVE-2006-4602": {"epss_score": 0.83363, "epss_percentile": 0.99246}, "CVE-2006-4603": {"epss_score": 0.0087, "epss_percentile": 0.74699}, "CVE-2006-4604": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-4605": {"epss_score": 0.23727, "epss_percentile": 0.95811}, "CVE-2006-4606": {"epss_score": 0.09429, "epss_percentile": 0.92543}, "CVE-2006-4607": {"epss_score": 0.1036, "epss_percentile": 0.92959}, "CVE-2006-4608": {"epss_score": 0.13669, "epss_percentile": 0.9403}, "CVE-2006-4609": {"epss_score": 0.04337, "epss_percentile": 0.88565}, "CVE-2006-4610": {"epss_score": 0.15016, "epss_percentile": 0.94344}, "CVE-2006-4611": {"epss_score": 0.2883, "epss_percentile": 0.96391}, "CVE-2006-4612": {"epss_score": 0.00916, "epss_percentile": 0.75414}, "CVE-2006-4613": {"epss_score": 0.00868, "epss_percentile": 0.74681}, "CVE-2006-4614": {"epss_score": 0.00071, "epss_percentile": 0.22167}, "CVE-2006-4615": {"epss_score": 0.00069, "epss_percentile": 0.21537}, "CVE-2006-4616": {"epss_score": 0.0498, "epss_percentile": 0.8936}, "CVE-2006-4617": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-4618": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-4619": {"epss_score": 0.00073, "epss_percentile": 0.22647}, "CVE-2006-4620": {"epss_score": 0.01206, "epss_percentile": 0.78522}, "CVE-2006-4621": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-4622": {"epss_score": 0.03454, "epss_percentile": 0.8717}, "CVE-2006-4623": {"epss_score": 0.13987, "epss_percentile": 0.94109}, "CVE-2006-4624": {"epss_score": 0.02699, "epss_percentile": 0.85449}, "CVE-2006-4625": {"epss_score": 0.0023, "epss_percentile": 0.45738}, "CVE-2006-4626": {"epss_score": 0.05886, "epss_percentile": 0.90293}, "CVE-2006-4627": {"epss_score": 0.19067, "epss_percentile": 0.95123}, "CVE-2006-4628": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-4629": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2006-4630": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2006-4631": {"epss_score": 0.1161, "epss_percentile": 0.93419}, "CVE-2006-4632": {"epss_score": 0.02922, "epss_percentile": 0.85995}, "CVE-2006-4633": {"epss_score": 0.12875, "epss_percentile": 0.93809}, "CVE-2006-4634": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2006-4635": {"epss_score": 0.00916, "epss_percentile": 0.75416}, "CVE-2006-4636": {"epss_score": 0.0721, "epss_percentile": 0.91328}, "CVE-2006-4637": {"epss_score": 0.02689, "epss_percentile": 0.85435}, "CVE-2006-4638": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-4639": {"epss_score": 0.00783, "epss_percentile": 0.7322}, "CVE-2006-4640": {"epss_score": 0.34482, "epss_percentile": 0.96849}, "CVE-2006-4641": {"epss_score": 0.00909, "epss_percentile": 0.75296}, "CVE-2006-4642": {"epss_score": 0.00074, "epss_percentile": 0.22803}, "CVE-2006-4643": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2006-4644": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-4645": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2006-4646": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-4647": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-4648": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2006-4649": {"epss_score": 0.01682, "epss_percentile": 0.81737}, "CVE-2006-4650": {"epss_score": 0.00636, "epss_percentile": 0.69875}, "CVE-2006-4651": {"epss_score": 0.01182, "epss_percentile": 0.78319}, "CVE-2006-4652": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-4653": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-4654": {"epss_score": 0.04701, "epss_percentile": 0.89025}, "CVE-2006-4655": {"epss_score": 0.00553, "epss_percentile": 0.6743}, "CVE-2006-4656": {"epss_score": 0.08368, "epss_percentile": 0.92011}, "CVE-2006-4657": {"epss_score": 0.00048, "epss_percentile": 0.15257}, "CVE-2006-4658": {"epss_score": 0.00564, "epss_percentile": 0.67747}, "CVE-2006-4659": {"epss_score": 0.00516, "epss_percentile": 0.66052}, "CVE-2006-4660": {"epss_score": 0.00695, "epss_percentile": 0.71366}, "CVE-2006-4661": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-4662": {"epss_score": 0.19204, "epss_percentile": 0.95148}, "CVE-2006-4663": {"epss_score": 0.00107, "epss_percentile": 0.2961}, "CVE-2006-4664": {"epss_score": 0.20843, "epss_percentile": 0.95425}, "CVE-2006-4665": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-4666": {"epss_score": 0.05825, "epss_percentile": 0.90237}, "CVE-2006-4667": {"epss_score": 0.01983, "epss_percentile": 0.83149}, "CVE-2006-4668": {"epss_score": 0.01027, "epss_percentile": 0.76812}, "CVE-2006-4669": {"epss_score": 0.08702, "epss_percentile": 0.9221}, "CVE-2006-4670": {"epss_score": 0.11276, "epss_percentile": 0.9329}, "CVE-2006-4671": {"epss_score": 0.16463, "epss_percentile": 0.9467}, "CVE-2006-4672": {"epss_score": 0.1742, "epss_percentile": 0.94849}, "CVE-2006-4673": {"epss_score": 0.006, "epss_percentile": 0.68815}, "CVE-2006-4674": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2006-4675": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2006-4676": {"epss_score": 0.00435, "epss_percentile": 0.62377}, "CVE-2006-4677": {"epss_score": 0.00137, "epss_percentile": 0.3429}, "CVE-2006-4678": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2006-4679": {"epss_score": 0.00704, "epss_percentile": 0.71565}, "CVE-2006-4680": {"epss_score": 0.00541, "epss_percentile": 0.67059}, "CVE-2006-4681": {"epss_score": 0.08017, "epss_percentile": 0.91832}, "CVE-2006-4682": {"epss_score": 0.0092, "epss_percentile": 0.75468}, "CVE-2006-4683": {"epss_score": 0.00363, "epss_percentile": 0.57847}, "CVE-2006-4684": {"epss_score": 0.0087, "epss_percentile": 0.74707}, "CVE-2006-4685": {"epss_score": 0.55388, "epss_percentile": 0.97974}, "CVE-2006-4686": {"epss_score": 0.2843, "epss_percentile": 0.96357}, "CVE-2006-4687": {"epss_score": 0.62172, "epss_percentile": 0.98284}, "CVE-2006-4688": {"epss_score": 0.81399, "epss_percentile": 0.99136}, "CVE-2006-4689": {"epss_score": 0.65302, "epss_percentile": 0.98412}, "CVE-2006-4691": {"epss_score": 0.88996, "epss_percentile": 0.99504}, "CVE-2006-4692": {"epss_score": 0.66643, "epss_percentile": 0.98472}, "CVE-2006-4693": {"epss_score": 0.20808, "epss_percentile": 0.95416}, "CVE-2006-4694": {"epss_score": 0.46461, "epss_percentile": 0.97547}, "CVE-2006-4695": {"epss_score": 0.50852, "epss_percentile": 0.97752}, "CVE-2006-4696": {"epss_score": 0.70938, "epss_percentile": 0.98647}, "CVE-2006-4697": {"epss_score": 0.54816, "epss_percentile": 0.97946}, "CVE-2006-4702": {"epss_score": 0.55721, "epss_percentile": 0.97992}, "CVE-2006-4704": {"epss_score": 0.73165, "epss_percentile": 0.98739}, "CVE-2006-4705": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2006-4706": {"epss_score": 0.02151, "epss_percentile": 0.83783}, "CVE-2006-4707": {"epss_score": 0.0192, "epss_percentile": 0.82891}, "CVE-2006-4708": {"epss_score": 0.00293, "epss_percentile": 0.52355}, "CVE-2006-4709": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2006-4710": {"epss_score": 0.00903, "epss_percentile": 0.75205}, "CVE-2006-4711": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2006-4712": {"epss_score": 0.05172, "epss_percentile": 0.89571}, "CVE-2006-4713": {"epss_score": 0.1218, "epss_percentile": 0.93596}, "CVE-2006-4714": {"epss_score": 0.1225, "epss_percentile": 0.93611}, "CVE-2006-4715": {"epss_score": 0.01809, "epss_percentile": 0.82357}, "CVE-2006-4716": {"epss_score": 0.04021, "epss_percentile": 0.88132}, "CVE-2006-4717": {"epss_score": 0.00793, "epss_percentile": 0.73421}, "CVE-2006-4718": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-4719": {"epss_score": 0.12825, "epss_percentile": 0.93795}, "CVE-2006-4720": {"epss_score": 0.09988, "epss_percentile": 0.92806}, "CVE-2006-4721": {"epss_score": 0.13548, "epss_percentile": 0.93993}, "CVE-2006-4722": {"epss_score": 0.02729, "epss_percentile": 0.85535}, "CVE-2006-4723": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-4724": {"epss_score": 0.02049, "epss_percentile": 0.83393}, "CVE-2006-4725": {"epss_score": 0.00254, "epss_percentile": 0.48515}, "CVE-2006-4726": {"epss_score": 0.02117, "epss_percentile": 0.83665}, "CVE-2006-4727": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2006-4731": {"epss_score": 0.19198, "epss_percentile": 0.95147}, "CVE-2006-4732": {"epss_score": 0.1941, "epss_percentile": 0.95177}, "CVE-2006-4733": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2006-4734": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2006-4735": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-4736": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-4737": {"epss_score": 0.00593, "epss_percentile": 0.68647}, "CVE-2006-4738": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-4739": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-4740": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2006-4741": {"epss_score": 0.03762, "epss_percentile": 0.8769}, "CVE-2006-4742": {"epss_score": 0.02503, "epss_percentile": 0.84928}, "CVE-2006-4743": {"epss_score": 0.00856, "epss_percentile": 0.7448}, "CVE-2006-4744": {"epss_score": 0.00566, "epss_percentile": 0.6781}, "CVE-2006-4745": {"epss_score": 0.00181, "epss_percentile": 0.40061}, "CVE-2006-4746": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2006-4747": {"epss_score": 0.01428, "epss_percentile": 0.80218}, "CVE-2006-4748": {"epss_score": 0.01559, "epss_percentile": 0.81031}, "CVE-2006-4749": {"epss_score": 0.01605, "epss_percentile": 0.81292}, "CVE-2006-4750": {"epss_score": 0.08686, "epss_percentile": 0.92201}, "CVE-2006-4751": {"epss_score": 0.07636, "epss_percentile": 0.91591}, "CVE-2006-4752": {"epss_score": 0.00704, "epss_percentile": 0.71565}, "CVE-2006-4753": {"epss_score": 0.07495, "epss_percentile": 0.91502}, "CVE-2006-4754": {"epss_score": 0.01088, "epss_percentile": 0.77439}, "CVE-2006-4755": {"epss_score": 0.00349, "epss_percentile": 0.5686}, "CVE-2006-4756": {"epss_score": 0.00506, "epss_percentile": 0.65625}, "CVE-2006-4757": {"epss_score": 0.00414, "epss_percentile": 0.611}, "CVE-2006-4758": {"epss_score": 0.02839, "epss_percentile": 0.85797}, "CVE-2006-4759": {"epss_score": 0.03124, "epss_percentile": 0.86453}, "CVE-2006-4760": {"epss_score": 0.00622, "epss_percentile": 0.69528}, "CVE-2006-4761": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-4762": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-4763": {"epss_score": 0.0164, "epss_percentile": 0.81498}, "CVE-2006-4764": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2006-4765": {"epss_score": 0.00473, "epss_percentile": 0.6409}, "CVE-2006-4766": {"epss_score": 0.05241, "epss_percentile": 0.89652}, "CVE-2006-4767": {"epss_score": 0.00522, "epss_percentile": 0.66253}, "CVE-2006-4768": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-4769": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-4770": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-4771": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2006-4772": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2006-4773": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2006-4774": {"epss_score": 0.05698, "epss_percentile": 0.90129}, "CVE-2006-4775": {"epss_score": 0.06347, "epss_percentile": 0.90687}, "CVE-2006-4776": {"epss_score": 0.17272, "epss_percentile": 0.94813}, "CVE-2006-4777": {"epss_score": 0.87569, "epss_percentile": 0.99433}, "CVE-2006-4778": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-4779": {"epss_score": 0.06847, "epss_percentile": 0.91069}, "CVE-2006-4780": {"epss_score": 0.11284, "epss_percentile": 0.93291}, "CVE-2006-4781": {"epss_score": 0.47337, "epss_percentile": 0.97583}, "CVE-2006-4782": {"epss_score": 0.08832, "epss_percentile": 0.92275}, "CVE-2006-4783": {"epss_score": 0.00906, "epss_percentile": 0.75253}, "CVE-2006-4784": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-4785": {"epss_score": 0.01853, "epss_percentile": 0.82549}, "CVE-2006-4786": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-4787": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2006-4788": {"epss_score": 0.07406, "epss_percentile": 0.91455}, "CVE-2006-4789": {"epss_score": 0.0039, "epss_percentile": 0.59558}, "CVE-2006-4790": {"epss_score": 0.03046, "epss_percentile": 0.86283}, "CVE-2006-4793": {"epss_score": 0.01788, "epss_percentile": 0.82265}, "CVE-2006-4794": {"epss_score": 0.01255, "epss_percentile": 0.78928}, "CVE-2006-4795": {"epss_score": 0.00048, "epss_percentile": 0.15136}, "CVE-2006-4796": {"epss_score": 0.07282, "epss_percentile": 0.91383}, "CVE-2006-4797": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-4798": {"epss_score": 0.00387, "epss_percentile": 0.5933}, "CVE-2006-4799": {"epss_score": 0.01474, "epss_percentile": 0.80522}, "CVE-2006-4800": {"epss_score": 0.06299, "epss_percentile": 0.90654}, "CVE-2006-4801": {"epss_score": 0.00046, "epss_percentile": 0.14362}, "CVE-2006-4802": {"epss_score": 0.00083, "epss_percentile": 0.24743}, "CVE-2006-4803": {"epss_score": 0.00097, "epss_percentile": 0.27599}, "CVE-2006-4805": {"epss_score": 0.05006, "epss_percentile": 0.89385}, "CVE-2006-4806": {"epss_score": 0.10166, "epss_percentile": 0.92873}, "CVE-2006-4807": {"epss_score": 0.03253, "epss_percentile": 0.86756}, "CVE-2006-4808": {"epss_score": 0.04588, "epss_percentile": 0.88889}, "CVE-2006-4809": {"epss_score": 0.06102, "epss_percentile": 0.90482}, "CVE-2006-4810": {"epss_score": 0.00162, "epss_percentile": 0.37695}, "CVE-2006-4811": {"epss_score": 0.17402, "epss_percentile": 0.94846}, "CVE-2006-4812": {"epss_score": 0.39413, "epss_percentile": 0.9716}, "CVE-2006-4813": {"epss_score": 0.00088, "epss_percentile": 0.25755}, "CVE-2006-4814": {"epss_score": 0.00091, "epss_percentile": 0.26211}, "CVE-2006-4819": {"epss_score": 0.15585, "epss_percentile": 0.94465}, "CVE-2006-4820": {"epss_score": 0.00062, "epss_percentile": 0.19711}, "CVE-2006-4821": {"epss_score": 0.00295, "epss_percentile": 0.52506}, "CVE-2006-4822": {"epss_score": 0.0061, "epss_percentile": 0.69161}, "CVE-2006-4823": {"epss_score": 0.11284, "epss_percentile": 0.93291}, "CVE-2006-4824": {"epss_score": 0.12517, "epss_percentile": 0.93706}, "CVE-2006-4825": {"epss_score": 0.05492, "epss_percentile": 0.89931}, "CVE-2006-4826": {"epss_score": 0.0863, "epss_percentile": 0.92162}, "CVE-2006-4827": {"epss_score": 0.07125, "epss_percentile": 0.91266}, "CVE-2006-4828": {"epss_score": 0.03333, "epss_percentile": 0.8693}, "CVE-2006-4829": {"epss_score": 0.30756, "epss_percentile": 0.96566}, "CVE-2006-4830": {"epss_score": 0.0173, "epss_percentile": 0.8199}, "CVE-2006-4831": {"epss_score": 0.00464, "epss_percentile": 0.63706}, "CVE-2006-4832": {"epss_score": 0.16399, "epss_percentile": 0.94645}, "CVE-2006-4833": {"epss_score": 0.01764, "epss_percentile": 0.8216}, "CVE-2006-4834": {"epss_score": 0.08691, "epss_percentile": 0.92206}, "CVE-2006-4835": {"epss_score": 0.00402, "epss_percentile": 0.60304}, "CVE-2006-4836": {"epss_score": 0.00654, "epss_percentile": 0.70357}, "CVE-2006-4837": {"epss_score": 0.01343, "epss_percentile": 0.79601}, "CVE-2006-4838": {"epss_score": 0.00324, "epss_percentile": 0.54973}, "CVE-2006-4839": {"epss_score": 0.01991, "epss_percentile": 0.83176}, "CVE-2006-4842": {"epss_score": 0.12195, "epss_percentile": 0.93599}, "CVE-2006-4843": {"epss_score": 0.01448, "epss_percentile": 0.80336}, "CVE-2006-4844": {"epss_score": 0.07979, "epss_percentile": 0.91801}, "CVE-2006-4845": {"epss_score": 0.13984, "epss_percentile": 0.94108}, "CVE-2006-4846": {"epss_score": 0.05971, "epss_percentile": 0.90372}, "CVE-2006-4847": {"epss_score": 0.87436, "epss_percentile": 0.99429}, "CVE-2006-4848": {"epss_score": 0.03681, "epss_percentile": 0.87559}, "CVE-2006-4849": {"epss_score": 0.18828, "epss_percentile": 0.95077}, "CVE-2006-4850": {"epss_score": 0.18828, "epss_percentile": 0.95077}, "CVE-2006-4851": {"epss_score": 0.01059, "epss_percentile": 0.77158}, "CVE-2006-4852": {"epss_score": 0.0287, "epss_percentile": 0.85872}, "CVE-2006-4853": {"epss_score": 0.05134, "epss_percentile": 0.89534}, "CVE-2006-4855": {"epss_score": 0.0027, "epss_percentile": 0.5025}, "CVE-2006-4856": {"epss_score": 0.01246, "epss_percentile": 0.78858}, "CVE-2006-4857": {"epss_score": 0.01071, "epss_percentile": 0.77262}, "CVE-2006-4858": {"epss_score": 0.13723, "epss_percentile": 0.94043}, "CVE-2006-4859": {"epss_score": 0.01001, "epss_percentile": 0.76494}, "CVE-2006-4860": {"epss_score": 0.02609, "epss_percentile": 0.85233}, "CVE-2006-4861": {"epss_score": 0.00692, "epss_percentile": 0.71282}, "CVE-2006-4862": {"epss_score": 0.00692, "epss_percentile": 0.71282}, "CVE-2006-4863": {"epss_score": 0.01516, "epss_percentile": 0.80799}, "CVE-2006-4864": {"epss_score": 0.01775, "epss_percentile": 0.82214}, "CVE-2006-4865": {"epss_score": 0.0543, "epss_percentile": 0.89875}, "CVE-2006-4866": {"epss_score": 0.00598, "epss_percentile": 0.68769}, "CVE-2006-4867": {"epss_score": 0.01333, "epss_percentile": 0.79532}, "CVE-2006-4868": {"epss_score": 0.66431, "epss_percentile": 0.98463}, "CVE-2006-4869": {"epss_score": 0.09364, "epss_percentile": 0.92517}, "CVE-2006-4870": {"epss_score": 0.10552, "epss_percentile": 0.93026}, "CVE-2006-4871": {"epss_score": 0.01181, "epss_percentile": 0.78305}, "CVE-2006-4872": {"epss_score": 0.01181, "epss_percentile": 0.78305}, "CVE-2006-4873": {"epss_score": 0.00402, "epss_percentile": 0.60304}, "CVE-2006-4874": {"epss_score": 0.00567, "epss_percentile": 0.67857}, "CVE-2006-4875": {"epss_score": 0.0399, "epss_percentile": 0.8807}, "CVE-2006-4876": {"epss_score": 0.00855, "epss_percentile": 0.74464}, "CVE-2006-4877": {"epss_score": 0.07425, "epss_percentile": 0.91468}, "CVE-2006-4878": {"epss_score": 0.04792, "epss_percentile": 0.8915}, "CVE-2006-4879": {"epss_score": 0.00794, "epss_percentile": 0.7344}, "CVE-2006-4880": {"epss_score": 0.00614, "epss_percentile": 0.69279}, "CVE-2006-4881": {"epss_score": 0.01217, "epss_percentile": 0.78597}, "CVE-2006-4882": {"epss_score": 0.01181, "epss_percentile": 0.78305}, "CVE-2006-4883": {"epss_score": 0.00558, "epss_percentile": 0.67592}, "CVE-2006-4884": {"epss_score": 0.00456, "epss_percentile": 0.63331}, "CVE-2006-4885": {"epss_score": 0.04694, "epss_percentile": 0.89016}, "CVE-2006-4886": {"epss_score": 0.0004, "epss_percentile": 0.12154}, "CVE-2006-4887": {"epss_score": 0.00068, "epss_percentile": 0.21253}, "CVE-2006-4888": {"epss_score": 0.22248, "epss_percentile": 0.95614}, "CVE-2006-4889": {"epss_score": 0.02429, "epss_percentile": 0.84723}, "CVE-2006-4890": {"epss_score": 0.1272, "epss_percentile": 0.93758}, "CVE-2006-4891": {"epss_score": 0.02482, "epss_percentile": 0.84876}, "CVE-2006-4892": {"epss_score": 0.02482, "epss_percentile": 0.84876}, "CVE-2006-4893": {"epss_score": 0.01995, "epss_percentile": 0.83192}, "CVE-2006-4894": {"epss_score": 0.00492, "epss_percentile": 0.65004}, "CVE-2006-4895": {"epss_score": 0.01269, "epss_percentile": 0.79042}, "CVE-2006-4897": {"epss_score": 0.10917, "epss_percentile": 0.93157}, "CVE-2006-4898": {"epss_score": 0.05879, "epss_percentile": 0.90289}, "CVE-2006-4899": {"epss_score": 0.15213, "epss_percentile": 0.94386}, "CVE-2006-4900": {"epss_score": 0.09578, "epss_percentile": 0.92605}, "CVE-2006-4901": {"epss_score": 0.10258, "epss_percentile": 0.92916}, "CVE-2006-4902": {"epss_score": 0.07682, "epss_percentile": 0.91623}, "CVE-2006-4904": {"epss_score": 0.04694, "epss_percentile": 0.89016}, "CVE-2006-4905": {"epss_score": 0.01078, "epss_percentile": 0.77342}, "CVE-2006-4906": {"epss_score": 0.01333, "epss_percentile": 0.79532}, "CVE-2006-4907": {"epss_score": 0.00509, "epss_percentile": 0.65734}, "CVE-2006-4908": {"epss_score": 0.00561, "epss_percentile": 0.67674}, "CVE-2006-4909": {"epss_score": 0.0052, "epss_percentile": 0.66197}, "CVE-2006-4910": {"epss_score": 0.01935, "epss_percentile": 0.82961}, "CVE-2006-4911": {"epss_score": 0.00771, "epss_percentile": 0.7302}, "CVE-2006-4912": {"epss_score": 0.05879, "epss_percentile": 0.90289}, "CVE-2006-4913": {"epss_score": 0.07463, "epss_percentile": 0.91486}, "CVE-2006-4914": {"epss_score": 0.00839, "epss_percentile": 0.74195}, "CVE-2006-4915": {"epss_score": 0.03674, "epss_percentile": 0.87549}, "CVE-2006-4916": {"epss_score": 0.01142, "epss_percentile": 0.7797}, "CVE-2006-4917": {"epss_score": 0.00895, "epss_percentile": 0.75107}, "CVE-2006-4918": {"epss_score": 0.12517, "epss_percentile": 0.93706}, "CVE-2006-4919": {"epss_score": 0.00839, "epss_percentile": 0.74195}, "CVE-2006-4920": {"epss_score": 0.11293, "epss_percentile": 0.93295}, "CVE-2006-4921": {"epss_score": 0.06847, "epss_percentile": 0.91069}, "CVE-2006-4922": {"epss_score": 0.04248, "epss_percentile": 0.88448}, "CVE-2006-4923": {"epss_score": 0.00907, "epss_percentile": 0.7527}, "CVE-2006-4924": {"epss_score": 0.47954, "epss_percentile": 0.9761}, "CVE-2006-4925": {"epss_score": 0.03372, "epss_percentile": 0.87013}, "CVE-2006-4926": {"epss_score": 0.0028, "epss_percentile": 0.51043}, "CVE-2006-4927": {"epss_score": 0.00423, "epss_percentile": 0.61632}, "CVE-2006-4935": {"epss_score": 0.00376, "epss_percentile": 0.58674}, "CVE-2006-4936": {"epss_score": 0.00376, "epss_percentile": 0.58674}, "CVE-2006-4937": {"epss_score": 0.00244, "epss_percentile": 0.47571}, "CVE-2006-4938": {"epss_score": 0.00244, "epss_percentile": 0.47571}, "CVE-2006-4939": {"epss_score": 0.00343, "epss_percentile": 0.56452}, "CVE-2006-4940": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-4941": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-4942": {"epss_score": 0.00541, "epss_percentile": 0.67054}, "CVE-2006-4943": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-4944": {"epss_score": 0.0234, "epss_percentile": 0.84429}, "CVE-2006-4945": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-4946": {"epss_score": 0.0648, "epss_percentile": 0.90786}, "CVE-2006-4947": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-4948": {"epss_score": 0.78628, "epss_percentile": 0.98994}, "CVE-2006-4949": {"epss_score": 0.00425, "epss_percentile": 0.61705}, "CVE-2006-4950": {"epss_score": 0.03315, "epss_percentile": 0.86899}, "CVE-2006-4951": {"epss_score": 0.01199, "epss_percentile": 0.7846}, "CVE-2006-4952": {"epss_score": 0.09662, "epss_percentile": 0.92645}, "CVE-2006-4953": {"epss_score": 0.00545, "epss_percentile": 0.67168}, "CVE-2006-4954": {"epss_score": 0.07531, "epss_percentile": 0.91519}, "CVE-2006-4955": {"epss_score": 0.09662, "epss_percentile": 0.92645}, "CVE-2006-4956": {"epss_score": 0.00864, "epss_percentile": 0.74599}, "CVE-2006-4957": {"epss_score": 0.01117, "epss_percentile": 0.77739}, "CVE-2006-4958": {"epss_score": 0.02731, "epss_percentile": 0.85539}, "CVE-2006-4959": {"epss_score": 0.00574, "epss_percentile": 0.68074}, "CVE-2006-4960": {"epss_score": 0.0852, "epss_percentile": 0.92099}, "CVE-2006-4961": {"epss_score": 0.01081, "epss_percentile": 0.77371}, "CVE-2006-4962": {"epss_score": 0.21317, "epss_percentile": 0.955}, "CVE-2006-4963": {"epss_score": 0.09876, "epss_percentile": 0.92749}, "CVE-2006-4964": {"epss_score": 0.00536, "epss_percentile": 0.66869}, "CVE-2006-4965": {"epss_score": 0.07901, "epss_percentile": 0.91754}, "CVE-2006-4966": {"epss_score": 0.13614, "epss_percentile": 0.94014}, "CVE-2006-4967": {"epss_score": 0.0192, "epss_percentile": 0.82891}, "CVE-2006-4968": {"epss_score": 0.06982, "epss_percentile": 0.9116}, "CVE-2006-4969": {"epss_score": 0.09698, "epss_percentile": 0.92667}, "CVE-2006-4970": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2006-4971": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-4972": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2006-4973": {"epss_score": 0.01082, "epss_percentile": 0.77386}, "CVE-2006-4974": {"epss_score": 0.03178, "epss_percentile": 0.86573}, "CVE-2006-4975": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2006-4976": {"epss_score": 0.00334, "epss_percentile": 0.55692}, "CVE-2006-4977": {"epss_score": 0.13759, "epss_percentile": 0.94052}, "CVE-2006-4978": {"epss_score": 0.02933, "epss_percentile": 0.86019}, "CVE-2006-4979": {"epss_score": 0.13759, "epss_percentile": 0.94052}, "CVE-2006-4980": {"epss_score": 0.01059, "epss_percentile": 0.77153}, "CVE-2006-4981": {"epss_score": 0.00082, "epss_percentile": 0.24543}, "CVE-2006-4982": {"epss_score": 0.00103, "epss_percentile": 0.28959}, "CVE-2006-4983": {"epss_score": 0.00445, "epss_percentile": 0.62857}, "CVE-2006-4984": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2006-4985": {"epss_score": 0.00472, "epss_percentile": 0.64046}, "CVE-2006-4986": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2006-4987": {"epss_score": 0.02164, "epss_percentile": 0.83842}, "CVE-2006-4988": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2006-4989": {"epss_score": 0.03806, "epss_percentile": 0.8775}, "CVE-2006-4990": {"epss_score": 0.0371, "epss_percentile": 0.87605}, "CVE-2006-4991": {"epss_score": 0.00043, "epss_percentile": 0.13326}, "CVE-2006-4992": {"epss_score": 0.06234, "epss_percentile": 0.90589}, "CVE-2006-4993": {"epss_score": 0.0535, "epss_percentile": 0.89773}, "CVE-2006-4994": {"epss_score": 0.00077, "epss_percentile": 0.23361}, "CVE-2006-4995": {"epss_score": 0.00381, "epss_percentile": 0.59015}, "CVE-2006-4996": {"epss_score": 0.00026, "epss_percentile": 0.06679}, "CVE-2006-4997": {"epss_score": 0.35021, "epss_percentile": 0.96884}, "CVE-2006-5000": {"epss_score": 0.0863, "epss_percentile": 0.92162}, "CVE-2006-5001": {"epss_score": 0.14188, "epss_percentile": 0.94159}, "CVE-2006-5002": {"epss_score": 0.00596, "epss_percentile": 0.68702}, "CVE-2006-5003": {"epss_score": 0.00035, "epss_percentile": 0.09982}, "CVE-2006-5004": {"epss_score": 0.00058, "epss_percentile": 0.18524}, "CVE-2006-5005": {"epss_score": 0.00044, "epss_percentile": 0.13525}, "CVE-2006-5006": {"epss_score": 0.00066, "epss_percentile": 0.20704}, "CVE-2006-5007": {"epss_score": 0.0008, "epss_percentile": 0.24138}, "CVE-2006-5008": {"epss_score": 0.01507, "epss_percentile": 0.80754}, "CVE-2006-5009": {"epss_score": 0.00047, "epss_percentile": 0.1458}, "CVE-2006-5010": {"epss_score": 0.00054, "epss_percentile": 0.17048}, "CVE-2006-5011": {"epss_score": 0.00043, "epss_percentile": 0.13127}, "CVE-2006-5012": {"epss_score": 0.00053, "epss_percentile": 0.17036}, "CVE-2006-5013": {"epss_score": 0.02093, "epss_percentile": 0.83575}, "CVE-2006-5014": {"epss_score": 0.01482, "epss_percentile": 0.8058}, "CVE-2006-5015": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-5016": {"epss_score": 0.05206, "epss_percentile": 0.8961}, "CVE-2006-5017": {"epss_score": 0.01075, "epss_percentile": 0.77303}, "CVE-2006-5018": {"epss_score": 0.00496, "epss_percentile": 0.65175}, "CVE-2006-5019": {"epss_score": 0.05206, "epss_percentile": 0.8961}, "CVE-2006-5020": {"epss_score": 0.11044, "epss_percentile": 0.93199}, "CVE-2006-5021": {"epss_score": 0.01604, "epss_percentile": 0.81282}, "CVE-2006-5022": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5023": {"epss_score": 0.00956, "epss_percentile": 0.75924}, "CVE-2006-5024": {"epss_score": 0.00479, "epss_percentile": 0.6442}, "CVE-2006-5025": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2006-5026": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2006-5027": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-5028": {"epss_score": 0.36486, "epss_percentile": 0.96981}, "CVE-2006-5029": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-5030": {"epss_score": 0.01062, "epss_percentile": 0.77184}, "CVE-2006-5031": {"epss_score": 0.0688, "epss_percentile": 0.9109}, "CVE-2006-5032": {"epss_score": 0.06847, "epss_percentile": 0.91069}, "CVE-2006-5033": {"epss_score": 0.07737, "epss_percentile": 0.91651}, "CVE-2006-5034": {"epss_score": 0.0742, "epss_percentile": 0.91466}, "CVE-2006-5035": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2006-5036": {"epss_score": 0.01243, "epss_percentile": 0.78831}, "CVE-2006-5037": {"epss_score": 0.01222, "epss_percentile": 0.78657}, "CVE-2006-5038": {"epss_score": 0.01108, "epss_percentile": 0.77636}, "CVE-2006-5039": {"epss_score": 0.00238, "epss_percentile": 0.46743}, "CVE-2006-5040": {"epss_score": 0.00238, "epss_percentile": 0.46743}, "CVE-2006-5041": {"epss_score": 0.00238, "epss_percentile": 0.46743}, "CVE-2006-5042": {"epss_score": 0.00238, "epss_percentile": 0.46743}, "CVE-2006-5043": {"epss_score": 0.11443, "epss_percentile": 0.93362}, "CVE-2006-5044": {"epss_score": 0.00068, "epss_percentile": 0.21407}, "CVE-2006-5045": {"epss_score": 0.04674, "epss_percentile": 0.8899}, "CVE-2006-5046": {"epss_score": 0.00404, "epss_percentile": 0.60417}, "CVE-2006-5047": {"epss_score": 0.00047, "epss_percentile": 0.14666}, "CVE-2006-5048": {"epss_score": 0.14117, "epss_percentile": 0.94135}, "CVE-2006-5049": {"epss_score": 0.00404, "epss_percentile": 0.60417}, "CVE-2006-5050": {"epss_score": 0.00279, "epss_percentile": 0.50991}, "CVE-2006-5051": {"epss_score": 0.02215, "epss_percentile": 0.84028}, "CVE-2006-5052": {"epss_score": 0.14969, "epss_percentile": 0.94335}, "CVE-2006-5053": {"epss_score": 0.12825, "epss_percentile": 0.93795}, "CVE-2006-5054": {"epss_score": 0.00909, "epss_percentile": 0.75296}, "CVE-2006-5055": {"epss_score": 0.1035, "epss_percentile": 0.92954}, "CVE-2006-5056": {"epss_score": 0.03175, "epss_percentile": 0.86566}, "CVE-2006-5057": {"epss_score": 0.02668, "epss_percentile": 0.85382}, "CVE-2006-5058": {"epss_score": 0.06689, "epss_percentile": 0.90947}, "CVE-2006-5059": {"epss_score": 0.01288, "epss_percentile": 0.79202}, "CVE-2006-5060": {"epss_score": 0.06539, "epss_percentile": 0.90833}, "CVE-2006-5061": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-5062": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2006-5063": {"epss_score": 0.01414, "epss_percentile": 0.8013}, "CVE-2006-5064": {"epss_score": 0.00792, "epss_percentile": 0.73398}, "CVE-2006-5065": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5066": {"epss_score": 0.03193, "epss_percentile": 0.86605}, "CVE-2006-5067": {"epss_score": 0.01078, "epss_percentile": 0.77342}, "CVE-2006-5068": {"epss_score": 0.15911, "epss_percentile": 0.94529}, "CVE-2006-5069": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-5070": {"epss_score": 0.08686, "epss_percentile": 0.92201}, "CVE-2006-5071": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-5072": {"epss_score": 0.00061, "epss_percentile": 0.19339}, "CVE-2006-5073": {"epss_score": 0.02845, "epss_percentile": 0.85819}, "CVE-2006-5074": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2006-5075": {"epss_score": 0.02149, "epss_percentile": 0.83776}, "CVE-2006-5076": {"epss_score": 0.03717, "epss_percentile": 0.87615}, "CVE-2006-5077": {"epss_score": 0.06142, "epss_percentile": 0.90514}, "CVE-2006-5078": {"epss_score": 0.04865, "epss_percentile": 0.89226}, "CVE-2006-5079": {"epss_score": 0.04865, "epss_percentile": 0.89226}, "CVE-2006-5080": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-5081": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-5082": {"epss_score": 0.00914, "epss_percentile": 0.75383}, "CVE-2006-5083": {"epss_score": 0.01084, "epss_percentile": 0.77396}, "CVE-2006-5084": {"epss_score": 0.27937, "epss_percentile": 0.96296}, "CVE-2006-5085": {"epss_score": 0.05495, "epss_percentile": 0.89933}, "CVE-2006-5086": {"epss_score": 0.0114, "epss_percentile": 0.77952}, "CVE-2006-5087": {"epss_score": 0.04865, "epss_percentile": 0.89226}, "CVE-2006-5088": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2006-5089": {"epss_score": 0.05538, "epss_percentile": 0.89973}, "CVE-2006-5090": {"epss_score": 0.00293, "epss_percentile": 0.52355}, "CVE-2006-5091": {"epss_score": 0.00053, "epss_percentile": 0.17004}, "CVE-2006-5092": {"epss_score": 0.10696, "epss_percentile": 0.93074}, "CVE-2006-5093": {"epss_score": 0.12568, "epss_percentile": 0.93718}, "CVE-2006-5094": {"epss_score": 0.0323, "epss_percentile": 0.86695}, "CVE-2006-5095": {"epss_score": 0.01059, "epss_percentile": 0.77158}, "CVE-2006-5096": {"epss_score": 0.00785, "epss_percentile": 0.73251}, "CVE-2006-5097": {"epss_score": 0.02271, "epss_percentile": 0.84209}, "CVE-2006-5098": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2006-5099": {"epss_score": 0.02648, "epss_percentile": 0.85338}, "CVE-2006-5100": {"epss_score": 0.12648, "epss_percentile": 0.9374}, "CVE-2006-5101": {"epss_score": 0.0585, "epss_percentile": 0.90262}, "CVE-2006-5102": {"epss_score": 0.06142, "epss_percentile": 0.90514}, "CVE-2006-5103": {"epss_score": 0.01503, "epss_percentile": 0.80734}, "CVE-2006-5104": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2006-5105": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-5106": {"epss_score": 0.01075, "epss_percentile": 0.77308}, "CVE-2006-5107": {"epss_score": 0.0029, "epss_percentile": 0.52129}, "CVE-2006-5108": {"epss_score": 0.02731, "epss_percentile": 0.8554}, "CVE-2006-5109": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2006-5110": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-5111": {"epss_score": 0.01172, "epss_percentile": 0.7823}, "CVE-2006-5112": {"epss_score": 0.82279, "epss_percentile": 0.99184}, "CVE-2006-5113": {"epss_score": 0.00719, "epss_percentile": 0.7194}, "CVE-2006-5114": {"epss_score": 0.15847, "epss_percentile": 0.94518}, "CVE-2006-5115": {"epss_score": 0.07701, "epss_percentile": 0.91634}, "CVE-2006-5116": {"epss_score": 0.03863, "epss_percentile": 0.87869}, "CVE-2006-5117": {"epss_score": 0.00463, "epss_percentile": 0.63682}, "CVE-2006-5118": {"epss_score": 0.03916, "epss_percentile": 0.87947}, "CVE-2006-5119": {"epss_score": 0.00903, "epss_percentile": 0.75205}, "CVE-2006-5120": {"epss_score": 0.00557, "epss_percentile": 0.6754}, "CVE-2006-5121": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-5122": {"epss_score": 0.00288, "epss_percentile": 0.51938}, "CVE-2006-5123": {"epss_score": 0.02323, "epss_percentile": 0.84374}, "CVE-2006-5124": {"epss_score": 0.1707, "epss_percentile": 0.94769}, "CVE-2006-5125": {"epss_score": 0.25021, "epss_percentile": 0.9598}, "CVE-2006-5126": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5127": {"epss_score": 0.02193, "epss_percentile": 0.83947}, "CVE-2006-5128": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-5129": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-5130": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-5131": {"epss_score": 0.01922, "epss_percentile": 0.82903}, "CVE-2006-5132": {"epss_score": 0.01269, "epss_percentile": 0.79039}, "CVE-2006-5133": {"epss_score": 0.04102, "epss_percentile": 0.88261}, "CVE-2006-5134": {"epss_score": 0.00342, "epss_percentile": 0.56366}, "CVE-2006-5135": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5136": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2006-5137": {"epss_score": 0.03174, "epss_percentile": 0.8656}, "CVE-2006-5138": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2006-5139": {"epss_score": 0.00335, "epss_percentile": 0.55891}, "CVE-2006-5140": {"epss_score": 0.00909, "epss_percentile": 0.75296}, "CVE-2006-5141": {"epss_score": 0.01605, "epss_percentile": 0.81292}, "CVE-2006-5142": {"epss_score": 0.09504, "epss_percentile": 0.92575}, "CVE-2006-5143": {"epss_score": 0.84629, "epss_percentile": 0.99298}, "CVE-2006-5144": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-5145": {"epss_score": 0.00481, "epss_percentile": 0.64512}, "CVE-2006-5146": {"epss_score": 0.00996, "epss_percentile": 0.76451}, "CVE-2006-5147": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5148": {"epss_score": 0.06176, "epss_percentile": 0.90534}, "CVE-2006-5149": {"epss_score": 0.00705, "epss_percentile": 0.71579}, "CVE-2006-5150": {"epss_score": 0.00527, "epss_percentile": 0.66466}, "CVE-2006-5151": {"epss_score": 0.05809, "epss_percentile": 0.90225}, "CVE-2006-5152": {"epss_score": 0.27162, "epss_percentile": 0.96214}, "CVE-2006-5153": {"epss_score": 0.00768, "epss_percentile": 0.72973}, "CVE-2006-5154": {"epss_score": 0.06001, "epss_percentile": 0.90392}, "CVE-2006-5155": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-5156": {"epss_score": 0.82959, "epss_percentile": 0.99223}, "CVE-2006-5157": {"epss_score": 0.19033, "epss_percentile": 0.95116}, "CVE-2006-5158": {"epss_score": 0.04045, "epss_percentile": 0.88171}, "CVE-2006-5159": {"epss_score": 0.07261, "epss_percentile": 0.91356}, "CVE-2006-5160": {"epss_score": 0.00447, "epss_percentile": 0.62976}, "CVE-2006-5161": {"epss_score": 0.00301, "epss_percentile": 0.53075}, "CVE-2006-5162": {"epss_score": 0.19156, "epss_percentile": 0.9514}, "CVE-2006-5163": {"epss_score": 0.00075, "epss_percentile": 0.22917}, "CVE-2006-5164": {"epss_score": 0.06539, "epss_percentile": 0.90833}, "CVE-2006-5165": {"epss_score": 0.0648, "epss_percentile": 0.90786}, "CVE-2006-5166": {"epss_score": 0.02164, "epss_percentile": 0.83842}, "CVE-2006-5167": {"epss_score": 0.12825, "epss_percentile": 0.93795}, "CVE-2006-5168": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-5169": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2006-5170": {"epss_score": 0.04353, "epss_percentile": 0.88588}, "CVE-2006-5171": {"epss_score": 0.28927, "epss_percentile": 0.96401}, "CVE-2006-5172": {"epss_score": 0.23459, "epss_percentile": 0.95781}, "CVE-2006-5173": {"epss_score": 0.00065, "epss_percentile": 0.20637}, "CVE-2006-5174": {"epss_score": 0.00064, "epss_percentile": 0.20295}, "CVE-2006-5175": {"epss_score": 0.00317, "epss_percentile": 0.54378}, "CVE-2006-5176": {"epss_score": 0.12717, "epss_percentile": 0.93757}, "CVE-2006-5177": {"epss_score": 0.0541, "epss_percentile": 0.89844}, "CVE-2006-5178": {"epss_score": 0.00113, "epss_percentile": 0.3067}, "CVE-2006-5179": {"epss_score": 0.00332, "epss_percentile": 0.55591}, "CVE-2006-5180": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2006-5181": {"epss_score": 0.06847, "epss_percentile": 0.91069}, "CVE-2006-5182": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-5183": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-5184": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-5185": {"epss_score": 0.04517, "epss_percentile": 0.88794}, "CVE-2006-5186": {"epss_score": 0.12076, "epss_percentile": 0.9356}, "CVE-2006-5187": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-5188": {"epss_score": 0.01089, "epss_percentile": 0.77444}, "CVE-2006-5189": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5190": {"epss_score": 0.07581, "epss_percentile": 0.91553}, "CVE-2006-5191": {"epss_score": 0.04601, "epss_percentile": 0.88903}, "CVE-2006-5192": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5193": {"epss_score": 0.01503, "epss_percentile": 0.80734}, "CVE-2006-5194": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-5195": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-5196": {"epss_score": 0.05779, "epss_percentile": 0.902}, "CVE-2006-5197": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2006-5198": {"epss_score": 0.73442, "epss_percentile": 0.98755}, "CVE-2006-5199": {"epss_score": 0.0025, "epss_percentile": 0.48146}, "CVE-2006-5200": {"epss_score": 0.03084, "epss_percentile": 0.86377}, "CVE-2006-5201": {"epss_score": 0.04734, "epss_percentile": 0.89072}, "CVE-2006-5202": {"epss_score": 0.28692, "epss_percentile": 0.96377}, "CVE-2006-5203": {"epss_score": 0.00306, "epss_percentile": 0.5346}, "CVE-2006-5204": {"epss_score": 0.00479, "epss_percentile": 0.64441}, "CVE-2006-5205": {"epss_score": 0.05285, "epss_percentile": 0.89693}, "CVE-2006-5206": {"epss_score": 0.00781, "epss_percentile": 0.73187}, "CVE-2006-5207": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-5208": {"epss_score": 0.01285, "epss_percentile": 0.79179}, "CVE-2006-5209": {"epss_score": 0.05419, "epss_percentile": 0.89856}, "CVE-2006-5210": {"epss_score": 0.09306, "epss_percentile": 0.92492}, "CVE-2006-5211": {"epss_score": 0.01916, "epss_percentile": 0.82859}, "CVE-2006-5212": {"epss_score": 0.0081, "epss_percentile": 0.73715}, "CVE-2006-5213": {"epss_score": 0.00078, "epss_percentile": 0.23623}, "CVE-2006-5214": {"epss_score": 0.00081, "epss_percentile": 0.24284}, "CVE-2006-5215": {"epss_score": 0.00079, "epss_percentile": 0.23905}, "CVE-2006-5216": {"epss_score": 0.81799, "epss_percentile": 0.99157}, "CVE-2006-5217": {"epss_score": 0.00654, "epss_percentile": 0.70357}, "CVE-2006-5218": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2006-5219": {"epss_score": 0.01677, "epss_percentile": 0.81712}, "CVE-2006-5220": {"epss_score": 0.10047, "epss_percentile": 0.92826}, "CVE-2006-5221": {"epss_score": 0.01922, "epss_percentile": 0.82908}, "CVE-2006-5222": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-5223": {"epss_score": 0.15016, "epss_percentile": 0.94344}, "CVE-2006-5224": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-5225": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-5226": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2006-5227": {"epss_score": 0.02076, "epss_percentile": 0.83511}, "CVE-2006-5228": {"epss_score": 0.03172, "epss_percentile": 0.8655}, "CVE-2006-5229": {"epss_score": 0.56627, "epss_percentile": 0.98031}, "CVE-2006-5230": {"epss_score": 0.1218, "epss_percentile": 0.93596}, "CVE-2006-5231": {"epss_score": 0.01602, "epss_percentile": 0.81271}, "CVE-2006-5232": {"epss_score": 0.04694, "epss_percentile": 0.89016}, "CVE-2006-5233": {"epss_score": 0.00834, "epss_percentile": 0.74111}, "CVE-2006-5234": {"epss_score": 0.04765, "epss_percentile": 0.89121}, "CVE-2006-5235": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-5236": {"epss_score": 0.06204, "epss_percentile": 0.90565}, "CVE-2006-5237": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-5238": {"epss_score": 0.00381, "epss_percentile": 0.5902}, "CVE-2006-5239": {"epss_score": 0.07955, "epss_percentile": 0.91787}, "CVE-2006-5240": {"epss_score": 0.15016, "epss_percentile": 0.94344}, "CVE-2006-5241": {"epss_score": 0.10315, "epss_percentile": 0.9294}, "CVE-2006-5242": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-5243": {"epss_score": 0.07554, "epss_percentile": 0.91537}, "CVE-2006-5244": {"epss_score": 0.22455, "epss_percentile": 0.95637}, "CVE-2006-5245": {"epss_score": 0.0049, "epss_percentile": 0.64938}, "CVE-2006-5246": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2006-5247": {"epss_score": 0.0192, "epss_percentile": 0.82891}, "CVE-2006-5248": {"epss_score": 0.00544, "epss_percentile": 0.6715}, "CVE-2006-5249": {"epss_score": 0.0325, "epss_percentile": 0.86749}, "CVE-2006-5250": {"epss_score": 0.04403, "epss_percentile": 0.88648}, "CVE-2006-5251": {"epss_score": 0.01442, "epss_percentile": 0.80308}, "CVE-2006-5252": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2006-5253": {"epss_score": 0.00861, "epss_percentile": 0.74552}, "CVE-2006-5254": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5255": {"epss_score": 0.01269, "epss_percentile": 0.79042}, "CVE-2006-5256": {"epss_score": 0.16462, "epss_percentile": 0.94666}, "CVE-2006-5257": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5258": {"epss_score": 0.02628, "epss_percentile": 0.85271}, "CVE-2006-5259": {"epss_score": 0.13614, "epss_percentile": 0.94014}, "CVE-2006-5260": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-5261": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2006-5262": {"epss_score": 0.07738, "epss_percentile": 0.91652}, "CVE-2006-5263": {"epss_score": 0.07551, "epss_percentile": 0.91537}, "CVE-2006-5264": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2006-5265": {"epss_score": 0.14924, "epss_percentile": 0.94325}, "CVE-2006-5266": {"epss_score": 0.29199, "epss_percentile": 0.96424}, "CVE-2006-5268": {"epss_score": 0.18317, "epss_percentile": 0.94993}, "CVE-2006-5269": {"epss_score": 0.25623, "epss_percentile": 0.96051}, "CVE-2006-5270": {"epss_score": 0.50982, "epss_percentile": 0.97757}, "CVE-2006-5271": {"epss_score": 0.1221, "epss_percentile": 0.93603}, "CVE-2006-5272": {"epss_score": 0.06056, "epss_percentile": 0.90439}, "CVE-2006-5273": {"epss_score": 0.08923, "epss_percentile": 0.92321}, "CVE-2006-5274": {"epss_score": 0.12437, "epss_percentile": 0.93669}, "CVE-2006-5276": {"epss_score": 0.88036, "epss_percentile": 0.99455}, "CVE-2006-5277": {"epss_score": 0.05464, "epss_percentile": 0.89902}, "CVE-2006-5278": {"epss_score": 0.09727, "epss_percentile": 0.92678}, "CVE-2006-5280": {"epss_score": 0.01737, "epss_percentile": 0.8202}, "CVE-2006-5281": {"epss_score": 0.10316, "epss_percentile": 0.92941}, "CVE-2006-5282": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2006-5283": {"epss_score": 0.06847, "epss_percentile": 0.91069}, "CVE-2006-5284": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-5285": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-5286": {"epss_score": 0.0082, "epss_percentile": 0.73876}, "CVE-2006-5287": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-5288": {"epss_score": 0.01067, "epss_percentile": 0.7723}, "CVE-2006-5289": {"epss_score": 0.12101, "epss_percentile": 0.93566}, "CVE-2006-5290": {"epss_score": 0.01219, "epss_percentile": 0.78614}, "CVE-2006-5291": {"epss_score": 0.12349, "epss_percentile": 0.93646}, "CVE-2006-5292": {"epss_score": 0.04086, "epss_percentile": 0.88226}, "CVE-2006-5293": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-5294": {"epss_score": 0.123, "epss_percentile": 0.93626}, "CVE-2006-5295": {"epss_score": 0.21294, "epss_percentile": 0.95496}, "CVE-2006-5296": {"epss_score": 0.6784, "epss_percentile": 0.98522}, "CVE-2006-5297": {"epss_score": 0.00107, "epss_percentile": 0.29681}, "CVE-2006-5298": {"epss_score": 0.0006, "epss_percentile": 0.19015}, "CVE-2006-5299": {"epss_score": 0.00521, "epss_percentile": 0.66245}, "CVE-2006-5300": {"epss_score": 0.00972, "epss_percentile": 0.76137}, "CVE-2006-5301": {"epss_score": 0.01697, "epss_percentile": 0.81816}, "CVE-2006-5302": {"epss_score": 0.07313, "epss_percentile": 0.91402}, "CVE-2006-5303": {"epss_score": 0.00039, "epss_percentile": 0.11467}, "CVE-2006-5304": {"epss_score": 0.12825, "epss_percentile": 0.93795}, "CVE-2006-5305": {"epss_score": 0.04584, "epss_percentile": 0.88883}, "CVE-2006-5306": {"epss_score": 0.04335, "epss_percentile": 0.88563}, "CVE-2006-5307": {"epss_score": 0.1048, "epss_percentile": 0.93001}, "CVE-2006-5308": {"epss_score": 0.20606, "epss_percentile": 0.95384}, "CVE-2006-5309": {"epss_score": 0.04584, "epss_percentile": 0.88883}, "CVE-2006-5310": {"epss_score": 0.08904, "epss_percentile": 0.92308}, "CVE-2006-5311": {"epss_score": 0.01449, "epss_percentile": 0.80341}, "CVE-2006-5312": {"epss_score": 0.01525, "epss_percentile": 0.80856}, "CVE-2006-5313": {"epss_score": 0.01023, "epss_percentile": 0.76771}, "CVE-2006-5314": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2006-5315": {"epss_score": 0.08811, "epss_percentile": 0.92266}, "CVE-2006-5316": {"epss_score": 0.06088, "epss_percentile": 0.90471}, "CVE-2006-5317": {"epss_score": 0.08811, "epss_percentile": 0.92266}, "CVE-2006-5318": {"epss_score": 0.13614, "epss_percentile": 0.94014}, "CVE-2006-5319": {"epss_score": 0.1609, "epss_percentile": 0.94571}, "CVE-2006-5320": {"epss_score": 0.15659, "epss_percentile": 0.94478}, "CVE-2006-5321": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2006-5322": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-5323": {"epss_score": 0.00655, "epss_percentile": 0.70366}, "CVE-2006-5324": {"epss_score": 0.00484, "epss_percentile": 0.6463}, "CVE-2006-5325": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-5326": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-5327": {"epss_score": 0.00171, "epss_percentile": 0.38889}, "CVE-2006-5328": {"epss_score": 0.00099, "epss_percentile": 0.28377}, "CVE-2006-5330": {"epss_score": 0.1744, "epss_percentile": 0.94852}, "CVE-2006-5331": {"epss_score": 0.00059, "epss_percentile": 0.18708}, "CVE-2006-5332": {"epss_score": 0.03612, "epss_percentile": 0.87427}, "CVE-2006-5333": {"epss_score": 0.01944, "epss_percentile": 0.82999}, "CVE-2006-5334": {"epss_score": 0.06067, "epss_percentile": 0.90448}, "CVE-2006-5335": {"epss_score": 0.03357, "epss_percentile": 0.86977}, "CVE-2006-5336": {"epss_score": 0.03357, "epss_percentile": 0.86977}, "CVE-2006-5337": {"epss_score": 0.06547, "epss_percentile": 0.9084}, "CVE-2006-5338": {"epss_score": 0.0326, "epss_percentile": 0.86769}, "CVE-2006-5339": {"epss_score": 0.0574, "epss_percentile": 0.90167}, "CVE-2006-5340": {"epss_score": 0.05053, "epss_percentile": 0.89444}, "CVE-2006-5341": {"epss_score": 0.04073, "epss_percentile": 0.88208}, "CVE-2006-5342": {"epss_score": 0.01944, "epss_percentile": 0.82999}, "CVE-2006-5343": {"epss_score": 0.06547, "epss_percentile": 0.9084}, "CVE-2006-5344": {"epss_score": 0.10502, "epss_percentile": 0.93013}, "CVE-2006-5345": {"epss_score": 0.0574, "epss_percentile": 0.90167}, "CVE-2006-5346": {"epss_score": 0.00584, "epss_percentile": 0.68373}, "CVE-2006-5347": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5348": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5349": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5350": {"epss_score": 0.00382, "epss_percentile": 0.59036}, "CVE-2006-5351": {"epss_score": 0.00719, "epss_percentile": 0.71952}, "CVE-2006-5352": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5353": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5354": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5355": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5356": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5357": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5358": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5359": {"epss_score": 0.02548, "epss_percentile": 0.8507}, "CVE-2006-5360": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5361": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5362": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5363": {"epss_score": 0.00623, "epss_percentile": 0.69551}, "CVE-2006-5364": {"epss_score": 0.01059, "epss_percentile": 0.77159}, "CVE-2006-5365": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5366": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5367": {"epss_score": 0.01925, "epss_percentile": 0.82923}, "CVE-2006-5368": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5369": {"epss_score": 0.02284, "epss_percentile": 0.84262}, "CVE-2006-5370": {"epss_score": 0.02284, "epss_percentile": 0.84262}, "CVE-2006-5371": {"epss_score": 0.01925, "epss_percentile": 0.82923}, "CVE-2006-5372": {"epss_score": 0.01925, "epss_percentile": 0.82923}, "CVE-2006-5373": {"epss_score": 0.01925, "epss_percentile": 0.82923}, "CVE-2006-5374": {"epss_score": 0.02284, "epss_percentile": 0.84262}, "CVE-2006-5375": {"epss_score": 0.00792, "epss_percentile": 0.73404}, "CVE-2006-5376": {"epss_score": 0.01925, "epss_percentile": 0.82923}, "CVE-2006-5377": {"epss_score": 0.01925, "epss_percentile": 0.82923}, "CVE-2006-5378": {"epss_score": 0.01925, "epss_percentile": 0.82923}, "CVE-2006-5379": {"epss_score": 0.36455, "epss_percentile": 0.96979}, "CVE-2006-5380": {"epss_score": 0.01269, "epss_percentile": 0.79042}, "CVE-2006-5381": {"epss_score": 0.00306, "epss_percentile": 0.5344}, "CVE-2006-5382": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-5383": {"epss_score": 0.01117, "epss_percentile": 0.77739}, "CVE-2006-5384": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-5385": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2006-5386": {"epss_score": 0.05497, "epss_percentile": 0.89935}, "CVE-2006-5387": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2006-5388": {"epss_score": 0.00909, "epss_percentile": 0.75296}, "CVE-2006-5389": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-5390": {"epss_score": 0.05082, "epss_percentile": 0.89473}, "CVE-2006-5391": {"epss_score": 0.05489, "epss_percentile": 0.89929}, "CVE-2006-5392": {"epss_score": 0.14931, "epss_percentile": 0.94327}, "CVE-2006-5393": {"epss_score": 0.00068, "epss_percentile": 0.21341}, "CVE-2006-5394": {"epss_score": 0.00079, "epss_percentile": 0.23815}, "CVE-2006-5395": {"epss_score": 0.2934, "epss_percentile": 0.96433}, "CVE-2006-5396": {"epss_score": 0.00067, "epss_percentile": 0.21027}, "CVE-2006-5397": {"epss_score": 0.00078, "epss_percentile": 0.23623}, "CVE-2006-5398": {"epss_score": 0.01673, "epss_percentile": 0.81685}, "CVE-2006-5399": {"epss_score": 0.1133, "epss_percentile": 0.93311}, "CVE-2006-5400": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5401": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5402": {"epss_score": 0.11734, "epss_percentile": 0.93461}, "CVE-2006-5403": {"epss_score": 0.21399, "epss_percentile": 0.95513}, "CVE-2006-5404": {"epss_score": 0.00778, "epss_percentile": 0.73126}, "CVE-2006-5405": {"epss_score": 0.00077, "epss_percentile": 0.23547}, "CVE-2006-5406": {"epss_score": 0.00059, "epss_percentile": 0.18656}, "CVE-2006-5407": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-5408": {"epss_score": 0.01075, "epss_percentile": 0.77308}, "CVE-2006-5409": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-5410": {"epss_score": 0.00888, "epss_percentile": 0.75008}, "CVE-2006-5411": {"epss_score": 0.03876, "epss_percentile": 0.87888}, "CVE-2006-5412": {"epss_score": 0.0648, "epss_percentile": 0.90787}, "CVE-2006-5413": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-5414": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-5415": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2006-5416": {"epss_score": 0.0246, "epss_percentile": 0.84824}, "CVE-2006-5417": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-5418": {"epss_score": 0.01854, "epss_percentile": 0.82551}, "CVE-2006-5419": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-5420": {"epss_score": 0.0192, "epss_percentile": 0.82894}, "CVE-2006-5421": {"epss_score": 0.06847, "epss_percentile": 0.91069}, "CVE-2006-5422": {"epss_score": 0.02474, "epss_percentile": 0.84855}, "CVE-2006-5423": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2006-5424": {"epss_score": 0.04821, "epss_percentile": 0.89179}, "CVE-2006-5425": {"epss_score": 0.01344, "epss_percentile": 0.79618}, "CVE-2006-5426": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2006-5427": {"epss_score": 0.08702, "epss_percentile": 0.9221}, "CVE-2006-5428": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2006-5429": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-5430": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-5431": {"epss_score": 0.01739, "epss_percentile": 0.82041}, "CVE-2006-5432": {"epss_score": 0.11826, "epss_percentile": 0.93488}, "CVE-2006-5433": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2006-5434": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2006-5435": {"epss_score": 0.00939, "epss_percentile": 0.75723}, "CVE-2006-5436": {"epss_score": 0.01605, "epss_percentile": 0.81292}, "CVE-2006-5437": {"epss_score": 0.00335, "epss_percentile": 0.55896}, "CVE-2006-5438": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-5439": {"epss_score": 0.00783, "epss_percentile": 0.7322}, "CVE-2006-5440": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-5441": {"epss_score": 0.00874, "epss_percentile": 0.74762}, "CVE-2006-5442": {"epss_score": 0.01464, "epss_percentile": 0.80446}, "CVE-2006-5443": {"epss_score": 0.00392, "epss_percentile": 0.59666}, "CVE-2006-5444": {"epss_score": 0.87055, "epss_percentile": 0.99411}, "CVE-2006-5445": {"epss_score": 0.10034, "epss_percentile": 0.92823}, "CVE-2006-5446": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2006-5447": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-5448": {"epss_score": 0.38354, "epss_percentile": 0.97097}, "CVE-2006-5449": {"epss_score": 0.0161, "epss_percentile": 0.81321}, "CVE-2006-5450": {"epss_score": 0.0085, "epss_percentile": 0.74394}, "CVE-2006-5451": {"epss_score": 0.01682, "epss_percentile": 0.81735}, "CVE-2006-5452": {"epss_score": 0.00357, "epss_percentile": 0.57481}, "CVE-2006-5453": {"epss_score": 0.01078, "epss_percentile": 0.77344}, "CVE-2006-5454": {"epss_score": 0.01993, "epss_percentile": 0.83185}, "CVE-2006-5455": {"epss_score": 0.01297, "epss_percentile": 0.7926}, "CVE-2006-5456": {"epss_score": 0.00851, "epss_percentile": 0.744}, "CVE-2006-5457": {"epss_score": 0.00351, "epss_percentile": 0.57027}, "CVE-2006-5458": {"epss_score": 0.06251, "epss_percentile": 0.90615}, "CVE-2006-5459": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-5460": {"epss_score": 0.00939, "epss_percentile": 0.75723}, "CVE-2006-5461": {"epss_score": 0.00079, "epss_percentile": 0.23948}, "CVE-2006-5462": {"epss_score": 0.12793, "epss_percentile": 0.93774}, "CVE-2006-5463": {"epss_score": 0.09098, "epss_percentile": 0.924}, "CVE-2006-5464": {"epss_score": 0.22092, "epss_percentile": 0.95594}, "CVE-2006-5465": {"epss_score": 0.41876, "epss_percentile": 0.97299}, "CVE-2006-5466": {"epss_score": 0.01691, "epss_percentile": 0.81778}, "CVE-2006-5467": {"epss_score": 0.05038, "epss_percentile": 0.89423}, "CVE-2006-5468": {"epss_score": 0.03207, "epss_percentile": 0.86636}, "CVE-2006-5469": {"epss_score": 0.02582, "epss_percentile": 0.85157}, "CVE-2006-5471": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2006-5472": {"epss_score": 0.08969, "epss_percentile": 0.92344}, "CVE-2006-5473": {"epss_score": 0.01059, "epss_percentile": 0.77158}, "CVE-2006-5474": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2006-5475": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-5476": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-5477": {"epss_score": 0.00684, "epss_percentile": 0.71123}, "CVE-2006-5478": {"epss_score": 0.91206, "epss_percentile": 0.99628}, "CVE-2006-5479": {"epss_score": 0.00592, "epss_percentile": 0.68619}, "CVE-2006-5480": {"epss_score": 0.06503, "epss_percentile": 0.90804}, "CVE-2006-5481": {"epss_score": 0.0081, "epss_percentile": 0.7372}, "CVE-2006-5482": {"epss_score": 0.00244, "epss_percentile": 0.47563}, "CVE-2006-5483": {"epss_score": 0.00253, "epss_percentile": 0.48481}, "CVE-2006-5484": {"epss_score": 0.01748, "epss_percentile": 0.82083}, "CVE-2006-5485": {"epss_score": 0.0302, "epss_percentile": 0.86224}, "CVE-2006-5486": {"epss_score": 0.0055, "epss_percentile": 0.67331}, "CVE-2006-5487": {"epss_score": 0.01728, "epss_percentile": 0.81976}, "CVE-2006-5488": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-5489": {"epss_score": 0.00787, "epss_percentile": 0.73319}, "CVE-2006-5490": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-5491": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-5492": {"epss_score": 0.0042, "epss_percentile": 0.61453}, "CVE-2006-5493": {"epss_score": 0.1218, "epss_percentile": 0.93596}, "CVE-2006-5494": {"epss_score": 0.16463, "epss_percentile": 0.9467}, "CVE-2006-5495": {"epss_score": 0.11773, "epss_percentile": 0.9347}, "CVE-2006-5496": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-5497": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2006-5498": {"epss_score": 0.00478, "epss_percentile": 0.64355}, "CVE-2006-5499": {"epss_score": 0.03206, "epss_percentile": 0.86634}, "CVE-2006-5500": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-5501": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2006-5502": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2006-5503": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-5504": {"epss_score": 0.00425, "epss_percentile": 0.61705}, "CVE-2006-5505": {"epss_score": 0.02474, "epss_percentile": 0.84855}, "CVE-2006-5506": {"epss_score": 0.08977, "epss_percentile": 0.92347}, "CVE-2006-5507": {"epss_score": 0.02865, "epss_percentile": 0.8586}, "CVE-2006-5508": {"epss_score": 0.00562, "epss_percentile": 0.67684}, "CVE-2006-5509": {"epss_score": 0.0101, "epss_percentile": 0.76597}, "CVE-2006-5510": {"epss_score": 0.13548, "epss_percentile": 0.93993}, "CVE-2006-5511": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2006-5512": {"epss_score": 0.00635, "epss_percentile": 0.6983}, "CVE-2006-5513": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-5514": {"epss_score": 0.01347, "epss_percentile": 0.79653}, "CVE-2006-5515": {"epss_score": 0.00872, "epss_percentile": 0.74733}, "CVE-2006-5516": {"epss_score": 0.01411, "epss_percentile": 0.80087}, "CVE-2006-5517": {"epss_score": 0.07216, "epss_percentile": 0.91331}, "CVE-2006-5518": {"epss_score": 0.11276, "epss_percentile": 0.9329}, "CVE-2006-5519": {"epss_score": 0.05675, "epss_percentile": 0.90109}, "CVE-2006-5520": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-5521": {"epss_score": 0.08811, "epss_percentile": 0.92266}, "CVE-2006-5522": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5523": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5524": {"epss_score": 0.07035, "epss_percentile": 0.91204}, "CVE-2006-5525": {"epss_score": 0.02966, "epss_percentile": 0.86084}, "CVE-2006-5526": {"epss_score": 0.06847, "epss_percentile": 0.91069}, "CVE-2006-5527": {"epss_score": 0.20843, "epss_percentile": 0.95425}, "CVE-2006-5528": {"epss_score": 0.02711, "epss_percentile": 0.85497}, "CVE-2006-5529": {"epss_score": 0.00353, "epss_percentile": 0.57198}, "CVE-2006-5530": {"epss_score": 0.00428, "epss_percentile": 0.61921}, "CVE-2006-5531": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-5532": {"epss_score": 0.0192, "epss_percentile": 0.82891}, "CVE-2006-5533": {"epss_score": 0.01291, "epss_percentile": 0.79228}, "CVE-2006-5534": {"epss_score": 0.00376, "epss_percentile": 0.58656}, "CVE-2006-5535": {"epss_score": 0.00945, "epss_percentile": 0.758}, "CVE-2006-5536": {"epss_score": 0.04742, "epss_percentile": 0.8908}, "CVE-2006-5537": {"epss_score": 0.00381, "epss_percentile": 0.59011}, "CVE-2006-5538": {"epss_score": 0.00299, "epss_percentile": 0.52878}, "CVE-2006-5539": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2006-5540": {"epss_score": 0.02102, "epss_percentile": 0.83607}, "CVE-2006-5541": {"epss_score": 0.01689, "epss_percentile": 0.81767}, "CVE-2006-5542": {"epss_score": 0.02102, "epss_percentile": 0.83607}, "CVE-2006-5543": {"epss_score": 0.09386, "epss_percentile": 0.92528}, "CVE-2006-5544": {"epss_score": 0.54345, "epss_percentile": 0.97921}, "CVE-2006-5545": {"epss_score": 0.00824, "epss_percentile": 0.73935}, "CVE-2006-5546": {"epss_score": 0.13163, "epss_percentile": 0.93889}, "CVE-2006-5547": {"epss_score": 0.13163, "epss_percentile": 0.93889}, "CVE-2006-5548": {"epss_score": 0.13163, "epss_percentile": 0.93889}, "CVE-2006-5549": {"epss_score": 0.02113, "epss_percentile": 0.83652}, "CVE-2006-5550": {"epss_score": 0.00175, "epss_percentile": 0.39311}, "CVE-2006-5551": {"epss_score": 0.37443, "epss_percentile": 0.97047}, "CVE-2006-5552": {"epss_score": 0.15599, "epss_percentile": 0.94467}, "CVE-2006-5553": {"epss_score": 0.012, "epss_percentile": 0.78465}, "CVE-2006-5554": {"epss_score": 0.0721, "epss_percentile": 0.91328}, "CVE-2006-5555": {"epss_score": 0.12825, "epss_percentile": 0.93795}, "CVE-2006-5556": {"epss_score": 0.00491, "epss_percentile": 0.64951}, "CVE-2006-5557": {"epss_score": 0.00567, "epss_percentile": 0.67859}, "CVE-2006-5558": {"epss_score": 0.04075, "epss_percentile": 0.8821}, "CVE-2006-5559": {"epss_score": 0.70449, "epss_percentile": 0.98632}, "CVE-2006-5560": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-5561": {"epss_score": 0.01573, "epss_percentile": 0.811}, "CVE-2006-5562": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5563": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-5564": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2006-5565": {"epss_score": 0.00448, "epss_percentile": 0.63026}, "CVE-2006-5566": {"epss_score": 0.05241, "epss_percentile": 0.89652}, "CVE-2006-5567": {"epss_score": 0.37449, "epss_percentile": 0.97048}, "CVE-2006-5568": {"epss_score": 0.05218, "epss_percentile": 0.89622}, "CVE-2006-5569": {"epss_score": 0.00397, "epss_percentile": 0.60037}, "CVE-2006-5570": {"epss_score": 0.01098, "epss_percentile": 0.7754}, "CVE-2006-5571": {"epss_score": 0.34554, "epss_percentile": 0.96855}, "CVE-2006-5574": {"epss_score": 0.43534, "epss_percentile": 0.97391}, "CVE-2006-5577": {"epss_score": 0.52203, "epss_percentile": 0.97812}, "CVE-2006-5578": {"epss_score": 0.47867, "epss_percentile": 0.97605}, "CVE-2006-5579": {"epss_score": 0.58877, "epss_percentile": 0.9814}, "CVE-2006-5581": {"epss_score": 0.66185, "epss_percentile": 0.98455}, "CVE-2006-5583": {"epss_score": 0.68214, "epss_percentile": 0.98536}, "CVE-2006-5584": {"epss_score": 0.48067, "epss_percentile": 0.97617}, "CVE-2006-5585": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2006-5586": {"epss_score": 0.01176, "epss_percentile": 0.78266}, "CVE-2006-5587": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-5588": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2006-5589": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-5590": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2006-5591": {"epss_score": 0.00688, "epss_percentile": 0.71195}, "CVE-2006-5592": {"epss_score": 0.00715, "epss_percentile": 0.71852}, "CVE-2006-5593": {"epss_score": 0.05191, "epss_percentile": 0.89595}, "CVE-2006-5594": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-5595": {"epss_score": 0.00365, "epss_percentile": 0.57962}, "CVE-2006-5596": {"epss_score": 0.09854, "epss_percentile": 0.92736}, "CVE-2006-5597": {"epss_score": 0.07551, "epss_percentile": 0.91537}, "CVE-2006-5598": {"epss_score": 0.00521, "epss_percentile": 0.66245}, "CVE-2006-5599": {"epss_score": 0.01243, "epss_percentile": 0.78828}, "CVE-2006-5600": {"epss_score": 0.00055, "epss_percentile": 0.17429}, "CVE-2006-5601": {"epss_score": 0.09259, "epss_percentile": 0.92469}, "CVE-2006-5602": {"epss_score": 0.00708, "epss_percentile": 0.71671}, "CVE-2006-5603": {"epss_score": 0.0055, "epss_percentile": 0.67347}, "CVE-2006-5604": {"epss_score": 0.00525, "epss_percentile": 0.66374}, "CVE-2006-5605": {"epss_score": 0.00641, "epss_percentile": 0.6999}, "CVE-2006-5606": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-5607": {"epss_score": 0.00911, "epss_percentile": 0.75326}, "CVE-2006-5608": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2006-5609": {"epss_score": 0.04025, "epss_percentile": 0.88139}, "CVE-2006-5610": {"epss_score": 0.01039, "epss_percentile": 0.76949}, "CVE-2006-5611": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2006-5612": {"epss_score": 0.16463, "epss_percentile": 0.9467}, "CVE-2006-5613": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2006-5614": {"epss_score": 0.88425, "epss_percentile": 0.99471}, "CVE-2006-5615": {"epss_score": 0.02086, "epss_percentile": 0.83551}, "CVE-2006-5616": {"epss_score": 0.01051, "epss_percentile": 0.7708}, "CVE-2006-5617": {"epss_score": 0.00573, "epss_percentile": 0.6806}, "CVE-2006-5618": {"epss_score": 0.07366, "epss_percentile": 0.91437}, "CVE-2006-5619": {"epss_score": 0.0011, "epss_percentile": 0.30184}, "CVE-2006-5620": {"epss_score": 0.12648, "epss_percentile": 0.9374}, "CVE-2006-5621": {"epss_score": 0.07586, "epss_percentile": 0.91556}, "CVE-2006-5622": {"epss_score": 0.01999, "epss_percentile": 0.83211}, "CVE-2006-5623": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5624": {"epss_score": 0.02059, "epss_percentile": 0.83437}, "CVE-2006-5625": {"epss_score": 0.06176, "epss_percentile": 0.90534}, "CVE-2006-5626": {"epss_score": 0.09306, "epss_percentile": 0.92493}, "CVE-2006-5627": {"epss_score": 0.14946, "epss_percentile": 0.94332}, "CVE-2006-5628": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-5629": {"epss_score": 0.01747, "epss_percentile": 0.82077}, "CVE-2006-5630": {"epss_score": 0.0153, "epss_percentile": 0.80888}, "CVE-2006-5631": {"epss_score": 0.01209, "epss_percentile": 0.78542}, "CVE-2006-5632": {"epss_score": 0.00391, "epss_percentile": 0.59624}, "CVE-2006-5633": {"epss_score": 0.1608, "epss_percentile": 0.94569}, "CVE-2006-5634": {"epss_score": 0.12933, "epss_percentile": 0.93821}, "CVE-2006-5635": {"epss_score": 0.00707, "epss_percentile": 0.71649}, "CVE-2006-5636": {"epss_score": 0.16523, "epss_percentile": 0.94685}, "CVE-2006-5637": {"epss_score": 0.13163, "epss_percentile": 0.93889}, "CVE-2006-5638": {"epss_score": 0.01229, "epss_percentile": 0.78715}, "CVE-2006-5639": {"epss_score": 0.00582, "epss_percentile": 0.68295}, "CVE-2006-5640": {"epss_score": 0.01654, "epss_percentile": 0.81586}, "CVE-2006-5641": {"epss_score": 0.01654, "epss_percentile": 0.81586}, "CVE-2006-5642": {"epss_score": 0.00369, "epss_percentile": 0.58231}, "CVE-2006-5643": {"epss_score": 0.00947, "epss_percentile": 0.75825}, "CVE-2006-5645": {"epss_score": 0.14755, "epss_percentile": 0.94275}, "CVE-2006-5646": {"epss_score": 0.41091, "epss_percentile": 0.97253}, "CVE-2006-5647": {"epss_score": 0.188, "epss_percentile": 0.95071}, "CVE-2006-5648": {"epss_score": 0.00047, "epss_percentile": 0.148}, "CVE-2006-5649": {"epss_score": 0.00051, "epss_percentile": 0.16123}, "CVE-2006-5650": {"epss_score": 0.82608, "epss_percentile": 0.99202}, "CVE-2006-5651": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2006-5652": {"epss_score": 0.03175, "epss_percentile": 0.86566}, "CVE-2006-5653": {"epss_score": 0.0458, "epss_percentile": 0.88874}, "CVE-2006-5654": {"epss_score": 0.01253, "epss_percentile": 0.78915}, "CVE-2006-5655": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-5656": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2006-5657": {"epss_score": 0.00381, "epss_percentile": 0.5902}, "CVE-2006-5658": {"epss_score": 0.01977, "epss_percentile": 0.83128}, "CVE-2006-5659": {"epss_score": 0.00065, "epss_percentile": 0.2052}, "CVE-2006-5660": {"epss_score": 0.01731, "epss_percentile": 0.81992}, "CVE-2006-5661": {"epss_score": 0.11433, "epss_percentile": 0.9335}, "CVE-2006-5662": {"epss_score": 0.01579, "epss_percentile": 0.81126}, "CVE-2006-5663": {"epss_score": 0.00051, "epss_percentile": 0.16326}, "CVE-2006-5664": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2006-5665": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2006-5666": {"epss_score": 0.01654, "epss_percentile": 0.81586}, "CVE-2006-5667": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2006-5668": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2006-5669": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5670": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-5671": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-5672": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5673": {"epss_score": 0.11955, "epss_percentile": 0.93526}, "CVE-2006-5674": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-5675": {"epss_score": 0.00998, "epss_percentile": 0.7647}, "CVE-2006-5676": {"epss_score": 0.01573, "epss_percentile": 0.811}, "CVE-2006-5677": {"epss_score": 0.00056, "epss_percentile": 0.17729}, "CVE-2006-5678": {"epss_score": 0.01153, "epss_percentile": 0.78052}, "CVE-2006-5679": {"epss_score": 0.00169, "epss_percentile": 0.38622}, "CVE-2006-5680": {"epss_score": 0.00787, "epss_percentile": 0.73319}, "CVE-2006-5681": {"epss_score": 0.00652, "epss_percentile": 0.70318}, "CVE-2006-5701": {"epss_score": 0.00152, "epss_percentile": 0.36381}, "CVE-2006-5702": {"epss_score": 0.53418, "epss_percentile": 0.97876}, "CVE-2006-5703": {"epss_score": 0.12479, "epss_percentile": 0.93685}, "CVE-2006-5704": {"epss_score": 0.0004, "epss_percentile": 0.12171}, "CVE-2006-5705": {"epss_score": 0.04873, "epss_percentile": 0.89234}, "CVE-2006-5706": {"epss_score": 0.0005, "epss_percentile": 0.15716}, "CVE-2006-5707": {"epss_score": 0.05219, "epss_percentile": 0.89624}, "CVE-2006-5708": {"epss_score": 0.00445, "epss_percentile": 0.62885}, "CVE-2006-5709": {"epss_score": 0.00452, "epss_percentile": 0.63176}, "CVE-2006-5710": {"epss_score": 0.33593, "epss_percentile": 0.96786}, "CVE-2006-5711": {"epss_score": 0.10952, "epss_percentile": 0.93174}, "CVE-2006-5712": {"epss_score": 0.03279, "epss_percentile": 0.8681}, "CVE-2006-5713": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2006-5714": {"epss_score": 0.05315, "epss_percentile": 0.89721}, "CVE-2006-5715": {"epss_score": 0.05935, "epss_percentile": 0.90342}, "CVE-2006-5716": {"epss_score": 0.05206, "epss_percentile": 0.8961}, "CVE-2006-5717": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-5718": {"epss_score": 0.01116, "epss_percentile": 0.77721}, "CVE-2006-5719": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-5720": {"epss_score": 0.00466, "epss_percentile": 0.63805}, "CVE-2006-5721": {"epss_score": 0.0019, "epss_percentile": 0.41135}, "CVE-2006-5722": {"epss_score": 0.01605, "epss_percentile": 0.81292}, "CVE-2006-5723": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-5724": {"epss_score": 0.00167, "epss_percentile": 0.38284}, "CVE-2006-5725": {"epss_score": 0.07366, "epss_percentile": 0.91437}, "CVE-2006-5726": {"epss_score": 0.00264, "epss_percentile": 0.49576}, "CVE-2006-5727": {"epss_score": 0.20843, "epss_percentile": 0.95425}, "CVE-2006-5728": {"epss_score": 0.05469, "epss_percentile": 0.89907}, "CVE-2006-5729": {"epss_score": 0.00588, "epss_percentile": 0.68492}, "CVE-2006-5730": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2006-5731": {"epss_score": 0.06544, "epss_percentile": 0.90838}, "CVE-2006-5732": {"epss_score": 0.01141, "epss_percentile": 0.77957}, "CVE-2006-5733": {"epss_score": 0.11165, "epss_percentile": 0.93251}, "CVE-2006-5734": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-5735": {"epss_score": 0.05129, "epss_percentile": 0.89528}, "CVE-2006-5736": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2006-5737": {"epss_score": 0.00161, "epss_percentile": 0.37578}, "CVE-2006-5738": {"epss_score": 0.00177, "epss_percentile": 0.39613}, "CVE-2006-5739": {"epss_score": 0.01347, "epss_percentile": 0.7965}, "CVE-2006-5740": {"epss_score": 0.02582, "epss_percentile": 0.85157}, "CVE-2006-5741": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-5742": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-5743": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-5744": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-5745": {"epss_score": 0.87407, "epss_percentile": 0.99428}, "CVE-2006-5746": {"epss_score": 0.00321, "epss_percentile": 0.54696}, "CVE-2006-5747": {"epss_score": 0.12453, "epss_percentile": 0.93677}, "CVE-2006-5748": {"epss_score": 0.12326, "epss_percentile": 0.93641}, "CVE-2006-5749": {"epss_score": 0.00075, "epss_percentile": 0.23007}, "CVE-2006-5750": {"epss_score": 0.2275, "epss_percentile": 0.95677}, "CVE-2006-5751": {"epss_score": 0.00074, "epss_percentile": 0.22825}, "CVE-2006-5752": {"epss_score": 0.14883, "epss_percentile": 0.94313}, "CVE-2006-5753": {"epss_score": 0.00084, "epss_percentile": 0.24995}, "CVE-2006-5754": {"epss_score": 0.00046, "epss_percentile": 0.14176}, "CVE-2006-5755": {"epss_score": 0.0005, "epss_percentile": 0.15668}, "CVE-2006-5757": {"epss_score": 0.00679, "epss_percentile": 0.71008}, "CVE-2006-5758": {"epss_score": 0.00765, "epss_percentile": 0.72923}, "CVE-2006-5759": {"epss_score": 0.00421, "epss_percentile": 0.61534}, "CVE-2006-5760": {"epss_score": 0.12648, "epss_percentile": 0.9374}, "CVE-2006-5761": {"epss_score": 0.09888, "epss_percentile": 0.92755}, "CVE-2006-5762": {"epss_score": 0.12548, "epss_percentile": 0.93712}, "CVE-2006-5763": {"epss_score": 0.14648, "epss_percentile": 0.94256}, "CVE-2006-5764": {"epss_score": 0.02483, "epss_percentile": 0.8488}, "CVE-2006-5765": {"epss_score": 0.02115, "epss_percentile": 0.83656}, "CVE-2006-5766": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5767": {"epss_score": 0.16463, "epss_percentile": 0.9467}, "CVE-2006-5768": {"epss_score": 0.08438, "epss_percentile": 0.92052}, "CVE-2006-5769": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-5770": {"epss_score": 0.00948, "epss_percentile": 0.75826}, "CVE-2006-5771": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-5772": {"epss_score": 0.016, "epss_percentile": 0.81258}, "CVE-2006-5773": {"epss_score": 0.12472, "epss_percentile": 0.93683}, "CVE-2006-5774": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-5775": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-5776": {"epss_score": 0.02088, "epss_percentile": 0.83557}, "CVE-2006-5777": {"epss_score": 0.03591, "epss_percentile": 0.874}, "CVE-2006-5778": {"epss_score": 0.00066, "epss_percentile": 0.20858}, "CVE-2006-5779": {"epss_score": 0.51898, "epss_percentile": 0.97801}, "CVE-2006-5780": {"epss_score": 0.7828, "epss_percentile": 0.98977}, "CVE-2006-5781": {"epss_score": 0.06287, "epss_percentile": 0.90645}, "CVE-2006-5782": {"epss_score": 0.04687, "epss_percentile": 0.89008}, "CVE-2006-5783": {"epss_score": 0.0087, "epss_percentile": 0.747}, "CVE-2006-5784": {"epss_score": 0.03909, "epss_percentile": 0.87932}, "CVE-2006-5785": {"epss_score": 0.01186, "epss_percentile": 0.78349}, "CVE-2006-5786": {"epss_score": 0.04697, "epss_percentile": 0.89021}, "CVE-2006-5787": {"epss_score": 0.03771, "epss_percentile": 0.87702}, "CVE-2006-5788": {"epss_score": 0.1035, "epss_percentile": 0.92954}, "CVE-2006-5789": {"epss_score": 0.08204, "epss_percentile": 0.91929}, "CVE-2006-5790": {"epss_score": 0.03041, "epss_percentile": 0.86274}, "CVE-2006-5791": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2006-5792": {"epss_score": 0.71383, "epss_percentile": 0.98665}, "CVE-2006-5793": {"epss_score": 0.02329, "epss_percentile": 0.84398}, "CVE-2006-5794": {"epss_score": 0.02241, "epss_percentile": 0.84115}, "CVE-2006-5795": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2006-5796": {"epss_score": 0.20843, "epss_percentile": 0.95425}, "CVE-2006-5797": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2006-5798": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-5799": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-5800": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-5801": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2006-5802": {"epss_score": 0.01654, "epss_percentile": 0.81586}, "CVE-2006-5803": {"epss_score": 0.01269, "epss_percentile": 0.79042}, "CVE-2006-5804": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2006-5805": {"epss_score": 0.02116, "epss_percentile": 0.83663}, "CVE-2006-5806": {"epss_score": 0.00089, "epss_percentile": 0.25812}, "CVE-2006-5807": {"epss_score": 0.0011, "epss_percentile": 0.30217}, "CVE-2006-5808": {"epss_score": 0.00075, "epss_percentile": 0.22941}, "CVE-2006-5809": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2006-5810": {"epss_score": 0.00353, "epss_percentile": 0.57198}, "CVE-2006-5811": {"epss_score": 0.18585, "epss_percentile": 0.95037}, "CVE-2006-5812": {"epss_score": 0.00473, "epss_percentile": 0.6409}, "CVE-2006-5813": {"epss_score": 0.00209, "epss_percentile": 0.43392}, "CVE-2006-5814": {"epss_score": 0.02391, "epss_percentile": 0.846}, "CVE-2006-5815": {"epss_score": 0.59834, "epss_percentile": 0.98183}, "CVE-2006-5816": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2006-5817": {"epss_score": 0.00047, "epss_percentile": 0.14666}, "CVE-2006-5818": {"epss_score": 0.00067, "epss_percentile": 0.20983}, "CVE-2006-5819": {"epss_score": 0.07826, "epss_percentile": 0.91701}, "CVE-2006-5820": {"epss_score": 0.35379, "epss_percentile": 0.96904}, "CVE-2006-5821": {"epss_score": 0.09429, "epss_percentile": 0.92543}, "CVE-2006-5822": {"epss_score": 0.38656, "epss_percentile": 0.97112}, "CVE-2006-5823": {"epss_score": 0.00075, "epss_percentile": 0.22915}, "CVE-2006-5824": {"epss_score": 0.00053, "epss_percentile": 0.17012}, "CVE-2006-5825": {"epss_score": 0.03175, "epss_percentile": 0.86566}, "CVE-2006-5826": {"epss_score": 0.17447, "epss_percentile": 0.94853}, "CVE-2006-5827": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-5828": {"epss_score": 0.01654, "epss_percentile": 0.81586}, "CVE-2006-5829": {"epss_score": 0.02437, "epss_percentile": 0.84744}, "CVE-2006-5830": {"epss_score": 0.02373, "epss_percentile": 0.84533}, "CVE-2006-5831": {"epss_score": 0.02729, "epss_percentile": 0.85535}, "CVE-2006-5832": {"epss_score": 0.06094, "epss_percentile": 0.90476}, "CVE-2006-5833": {"epss_score": 0.06588, "epss_percentile": 0.9087}, "CVE-2006-5834": {"epss_score": 0.0618, "epss_percentile": 0.90537}, "CVE-2006-5835": {"epss_score": 0.02464, "epss_percentile": 0.84832}, "CVE-2006-5836": {"epss_score": 0.00315, "epss_percentile": 0.54174}, "CVE-2006-5837": {"epss_score": 0.07551, "epss_percentile": 0.91537}, "CVE-2006-5838": {"epss_score": 0.02102, "epss_percentile": 0.83608}, "CVE-2006-5839": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2006-5840": {"epss_score": 0.02689, "epss_percentile": 0.85435}, "CVE-2006-5841": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-5842": {"epss_score": 0.00059, "epss_percentile": 0.18656}, "CVE-2006-5843": {"epss_score": 0.01663, "epss_percentile": 0.81638}, "CVE-2006-5844": {"epss_score": 0.00504, "epss_percentile": 0.65537}, "CVE-2006-5845": {"epss_score": 0.01032, "epss_percentile": 0.76863}, "CVE-2006-5846": {"epss_score": 0.16252, "epss_percentile": 0.94602}, "CVE-2006-5847": {"epss_score": 0.03972, "epss_percentile": 0.88038}, "CVE-2006-5849": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2006-5850": {"epss_score": 0.38601, "epss_percentile": 0.97108}, "CVE-2006-5851": {"epss_score": 0.00342, "epss_percentile": 0.56354}, "CVE-2006-5852": {"epss_score": 0.00436, "epss_percentile": 0.62433}, "CVE-2006-5853": {"epss_score": 0.05872, "epss_percentile": 0.90281}, "CVE-2006-5854": {"epss_score": 0.88709, "epss_percentile": 0.99485}, "CVE-2006-5855": {"epss_score": 0.68193, "epss_percentile": 0.98535}, "CVE-2006-5856": {"epss_score": 0.56658, "epss_percentile": 0.98032}, "CVE-2006-5857": {"epss_score": 0.20034, "epss_percentile": 0.95278}, "CVE-2006-5858": {"epss_score": 0.06955, "epss_percentile": 0.91145}, "CVE-2006-5859": {"epss_score": 0.02346, "epss_percentile": 0.84451}, "CVE-2006-5860": {"epss_score": 0.01949, "epss_percentile": 0.83013}, "CVE-2006-5861": {"epss_score": 0.07106, "epss_percentile": 0.91256}, "CVE-2006-5862": {"epss_score": 0.00157, "epss_percentile": 0.37105}, "CVE-2006-5863": {"epss_score": 0.14505, "epss_percentile": 0.94226}, "CVE-2006-5864": {"epss_score": 0.28511, "epss_percentile": 0.96364}, "CVE-2006-5865": {"epss_score": 0.0905, "epss_percentile": 0.92379}, "CVE-2006-5866": {"epss_score": 0.12406, "epss_percentile": 0.93661}, "CVE-2006-5867": {"epss_score": 0.0669, "epss_percentile": 0.90949}, "CVE-2006-5868": {"epss_score": 0.01459, "epss_percentile": 0.80414}, "CVE-2006-5869": {"epss_score": 0.00573, "epss_percentile": 0.68039}, "CVE-2006-5870": {"epss_score": 0.18514, "epss_percentile": 0.95025}, "CVE-2006-5871": {"epss_score": 0.0007, "epss_percentile": 0.21826}, "CVE-2006-5872": {"epss_score": 0.01222, "epss_percentile": 0.78653}, "CVE-2006-5873": {"epss_score": 0.01851, "epss_percentile": 0.82541}, "CVE-2006-5874": {"epss_score": 0.01476, "epss_percentile": 0.8053}, "CVE-2006-5875": {"epss_score": 0.01131, "epss_percentile": 0.77857}, "CVE-2006-5876": {"epss_score": 0.05875, "epss_percentile": 0.90282}, "CVE-2006-5877": {"epss_score": 0.00803, "epss_percentile": 0.736}, "CVE-2006-5878": {"epss_score": 0.01821, "epss_percentile": 0.82411}, "CVE-2006-5879": {"epss_score": 0.02966, "epss_percentile": 0.86084}, "CVE-2006-5880": {"epss_score": 0.016, "epss_percentile": 0.81258}, "CVE-2006-5881": {"epss_score": 0.02605, "epss_percentile": 0.8522}, "CVE-2006-5882": {"epss_score": 0.21666, "epss_percentile": 0.95546}, "CVE-2006-5883": {"epss_score": 0.01357, "epss_percentile": 0.79724}, "CVE-2006-5884": {"epss_score": 0.14625, "epss_percentile": 0.94254}, "CVE-2006-5885": {"epss_score": 0.03477, "epss_percentile": 0.87209}, "CVE-2006-5886": {"epss_score": 0.03066, "epss_percentile": 0.86336}, "CVE-2006-5887": {"epss_score": 0.04654, "epss_percentile": 0.88967}, "CVE-2006-5888": {"epss_score": 0.016, "epss_percentile": 0.81258}, "CVE-2006-5889": {"epss_score": 0.01965, "epss_percentile": 0.83078}, "CVE-2006-5890": {"epss_score": 0.01573, "epss_percentile": 0.811}, "CVE-2006-5891": {"epss_score": 0.02968, "epss_percentile": 0.8609}, "CVE-2006-5892": {"epss_score": 0.02966, "epss_percentile": 0.86084}, "CVE-2006-5893": {"epss_score": 0.08985, "epss_percentile": 0.92353}, "CVE-2006-5894": {"epss_score": 0.09854, "epss_percentile": 0.92736}, "CVE-2006-5895": {"epss_score": 0.10419, "epss_percentile": 0.92982}, "CVE-2006-5896": {"epss_score": 0.00771, "epss_percentile": 0.73014}, "CVE-2006-5897": {"epss_score": 0.00385, "epss_percentile": 0.59226}, "CVE-2006-5898": {"epss_score": 0.00229, "epss_percentile": 0.45619}, "CVE-2006-5899": {"epss_score": 0.04257, "epss_percentile": 0.88459}, "CVE-2006-5900": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2006-5901": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2006-5902": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-5903": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-5904": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-5905": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-5906": {"epss_score": 0.01507, "epss_percentile": 0.80755}, "CVE-2006-5907": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2006-5908": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-5909": {"epss_score": 0.00684, "epss_percentile": 0.71123}, "CVE-2006-5910": {"epss_score": 0.03794, "epss_percentile": 0.87733}, "CVE-2006-5911": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2006-5912": {"epss_score": 0.00446, "epss_percentile": 0.62907}, "CVE-2006-5913": {"epss_score": 0.02641, "epss_percentile": 0.85304}, "CVE-2006-5914": {"epss_score": 0.01901, "epss_percentile": 0.82776}, "CVE-2006-5915": {"epss_score": 0.06539, "epss_percentile": 0.90833}, "CVE-2006-5916": {"epss_score": 0.00505, "epss_percentile": 0.65554}, "CVE-2006-5917": {"epss_score": 0.01596, "epss_percentile": 0.81239}, "CVE-2006-5918": {"epss_score": 0.03433, "epss_percentile": 0.87128}, "CVE-2006-5919": {"epss_score": 0.08811, "epss_percentile": 0.92266}, "CVE-2006-5920": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2006-5921": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-5922": {"epss_score": 0.00572, "epss_percentile": 0.68032}, "CVE-2006-5923": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-5924": {"epss_score": 0.00353, "epss_percentile": 0.57198}, "CVE-2006-5925": {"epss_score": 0.2051, "epss_percentile": 0.95359}, "CVE-2006-5926": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-5927": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-5928": {"epss_score": 0.15759, "epss_percentile": 0.94499}, "CVE-2006-5929": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-5930": {"epss_score": 0.16523, "epss_percentile": 0.94685}, "CVE-2006-5931": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2006-5932": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2006-5933": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-5934": {"epss_score": 0.02968, "epss_percentile": 0.8609}, "CVE-2006-5935": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-5936": {"epss_score": 0.02466, "epss_percentile": 0.84836}, "CVE-2006-5937": {"epss_score": 0.04255, "epss_percentile": 0.88457}, "CVE-2006-5938": {"epss_score": 0.00518, "epss_percentile": 0.66095}, "CVE-2006-5939": {"epss_score": 0.01033, "epss_percentile": 0.76873}, "CVE-2006-5940": {"epss_score": 0.00502, "epss_percentile": 0.65374}, "CVE-2006-5942": {"epss_score": 0.01486, "epss_percentile": 0.80601}, "CVE-2006-5943": {"epss_score": 0.01543, "epss_percentile": 0.80953}, "CVE-2006-5944": {"epss_score": 0.10422, "epss_percentile": 0.92983}, "CVE-2006-5945": {"epss_score": 0.03956, "epss_percentile": 0.88005}, "CVE-2006-5946": {"epss_score": 0.02968, "epss_percentile": 0.8609}, "CVE-2006-5947": {"epss_score": 0.00436, "epss_percentile": 0.62473}, "CVE-2006-5948": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-5949": {"epss_score": 0.01926, "epss_percentile": 0.82925}, "CVE-2006-5950": {"epss_score": 0.00438, "epss_percentile": 0.62564}, "CVE-2006-5951": {"epss_score": 0.02522, "epss_percentile": 0.85005}, "CVE-2006-5952": {"epss_score": 0.016, "epss_percentile": 0.81258}, "CVE-2006-5953": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-5954": {"epss_score": 0.04023, "epss_percentile": 0.88135}, "CVE-2006-5955": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-5956": {"epss_score": 0.00079, "epss_percentile": 0.23853}, "CVE-2006-5957": {"epss_score": 0.02478, "epss_percentile": 0.84867}, "CVE-2006-5958": {"epss_score": 0.04211, "epss_percentile": 0.884}, "CVE-2006-5959": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2006-5960": {"epss_score": 0.02484, "epss_percentile": 0.84882}, "CVE-2006-5961": {"epss_score": 0.0261, "epss_percentile": 0.85234}, "CVE-2006-5962": {"epss_score": 0.02968, "epss_percentile": 0.8609}, "CVE-2006-5963": {"epss_score": 0.02074, "epss_percentile": 0.83498}, "CVE-2006-5964": {"epss_score": 0.0113, "epss_percentile": 0.77851}, "CVE-2006-5965": {"epss_score": 0.00058, "epss_percentile": 0.18412}, "CVE-2006-5966": {"epss_score": 0.01414, "epss_percentile": 0.80135}, "CVE-2006-5967": {"epss_score": 0.02913, "epss_percentile": 0.85974}, "CVE-2006-5968": {"epss_score": 0.00087, "epss_percentile": 0.25538}, "CVE-2006-5969": {"epss_score": 0.00066, "epss_percentile": 0.20872}, "CVE-2006-5970": {"epss_score": 0.00631, "epss_percentile": 0.69715}, "CVE-2006-5971": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-5972": {"epss_score": 0.1879, "epss_percentile": 0.95069}, "CVE-2006-5973": {"epss_score": 0.02681, "epss_percentile": 0.85414}, "CVE-2006-5974": {"epss_score": 0.0951, "epss_percentile": 0.92578}, "CVE-2006-5975": {"epss_score": 0.10084, "epss_percentile": 0.92843}, "CVE-2006-5976": {"epss_score": 0.02966, "epss_percentile": 0.86084}, "CVE-2006-5977": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-5978": {"epss_score": 0.00392, "epss_percentile": 0.59672}, "CVE-2006-5979": {"epss_score": 0.00296, "epss_percentile": 0.52618}, "CVE-2006-5980": {"epss_score": 0.02114, "epss_percentile": 0.83653}, "CVE-2006-5981": {"epss_score": 0.0071, "epss_percentile": 0.71711}, "CVE-2006-5982": {"epss_score": 0.00432, "epss_percentile": 0.62114}, "CVE-2006-5983": {"epss_score": 0.00524, "epss_percentile": 0.66327}, "CVE-2006-5984": {"epss_score": 0.01724, "epss_percentile": 0.81948}, "CVE-2006-5985": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-5986": {"epss_score": 0.00843, "epss_percentile": 0.74254}, "CVE-2006-5987": {"epss_score": 0.01792, "epss_percentile": 0.82288}, "CVE-2006-5988": {"epss_score": 0.20477, "epss_percentile": 0.95352}, "CVE-2006-5989": {"epss_score": 0.04337, "epss_percentile": 0.88564}, "CVE-2006-5990": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2006-5991": {"epss_score": 0.01135, "epss_percentile": 0.77913}, "CVE-2006-5994": {"epss_score": 0.59649, "epss_percentile": 0.98174}, "CVE-2006-6007": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-6008": {"epss_score": 0.014, "epss_percentile": 0.80005}, "CVE-2006-6009": {"epss_score": 0.00417, "epss_percentile": 0.61237}, "CVE-2006-6010": {"epss_score": 0.20146, "epss_percentile": 0.95293}, "CVE-2006-6011": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2006-6012": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-6013": {"epss_score": 0.00079, "epss_percentile": 0.23948}, "CVE-2006-6014": {"epss_score": 0.00048, "epss_percentile": 0.15135}, "CVE-2006-6015": {"epss_score": 0.07022, "epss_percentile": 0.91193}, "CVE-2006-6016": {"epss_score": 0.00749, "epss_percentile": 0.72599}, "CVE-2006-6017": {"epss_score": 0.02824, "epss_percentile": 0.85755}, "CVE-2006-6018": {"epss_score": 0.01291, "epss_percentile": 0.79228}, "CVE-2006-6019": {"epss_score": 0.01209, "epss_percentile": 0.78542}, "CVE-2006-6020": {"epss_score": 0.02043, "epss_percentile": 0.83378}, "CVE-2006-6021": {"epss_score": 0.02872, "epss_percentile": 0.85875}, "CVE-2006-6022": {"epss_score": 0.05692, "epss_percentile": 0.90125}, "CVE-2006-6023": {"epss_score": 0.01059, "epss_percentile": 0.77158}, "CVE-2006-6024": {"epss_score": 0.00455, "epss_percentile": 0.6331}, "CVE-2006-6025": {"epss_score": 0.00706, "epss_percentile": 0.71618}, "CVE-2006-6026": {"epss_score": 0.30408, "epss_percentile": 0.96537}, "CVE-2006-6027": {"epss_score": 0.43072, "epss_percentile": 0.97369}, "CVE-2006-6028": {"epss_score": 0.08369, "epss_percentile": 0.92013}, "CVE-2006-6029": {"epss_score": 0.02387, "epss_percentile": 0.84582}, "CVE-2006-6030": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-6031": {"epss_score": 0.00794, "epss_percentile": 0.7344}, "CVE-2006-6032": {"epss_score": 0.0144, "epss_percentile": 0.80299}, "CVE-2006-6033": {"epss_score": 0.00706, "epss_percentile": 0.71621}, "CVE-2006-6034": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-6035": {"epss_score": 0.09574, "epss_percentile": 0.92605}, "CVE-2006-6036": {"epss_score": 0.0078, "epss_percentile": 0.73169}, "CVE-2006-6037": {"epss_score": 0.01515, "epss_percentile": 0.80795}, "CVE-2006-6038": {"epss_score": 0.01686, "epss_percentile": 0.81754}, "CVE-2006-6039": {"epss_score": 0.01411, "epss_percentile": 0.80112}, "CVE-2006-6040": {"epss_score": 0.01005, "epss_percentile": 0.76544}, "CVE-2006-6041": {"epss_score": 0.16236, "epss_percentile": 0.94599}, "CVE-2006-6042": {"epss_score": 0.16711, "epss_percentile": 0.94719}, "CVE-2006-6043": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-6044": {"epss_score": 0.18585, "epss_percentile": 0.95037}, "CVE-2006-6045": {"epss_score": 0.03063, "epss_percentile": 0.86321}, "CVE-2006-6046": {"epss_score": 0.01256, "epss_percentile": 0.78939}, "CVE-2006-6047": {"epss_score": 0.15148, "epss_percentile": 0.94373}, "CVE-2006-6048": {"epss_score": 0.01315, "epss_percentile": 0.79399}, "CVE-2006-6049": {"epss_score": 0.0153, "epss_percentile": 0.80888}, "CVE-2006-6050": {"epss_score": 0.00613, "epss_percentile": 0.69251}, "CVE-2006-6051": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-6052": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-6053": {"epss_score": 0.00061, "epss_percentile": 0.19313}, "CVE-2006-6054": {"epss_score": 0.00061, "epss_percentile": 0.19313}, "CVE-2006-6055": {"epss_score": 0.04093, "epss_percentile": 0.88244}, "CVE-2006-6056": {"epss_score": 0.00048, "epss_percentile": 0.14948}, "CVE-2006-6057": {"epss_score": 0.00064, "epss_percentile": 0.20304}, "CVE-2006-6058": {"epss_score": 0.00341, "epss_percentile": 0.56343}, "CVE-2006-6059": {"epss_score": 0.28351, "epss_percentile": 0.96346}, "CVE-2006-6060": {"epss_score": 0.00047, "epss_percentile": 0.148}, "CVE-2006-6061": {"epss_score": 0.37594, "epss_percentile": 0.97059}, "CVE-2006-6062": {"epss_score": 0.21641, "epss_percentile": 0.95542}, "CVE-2006-6063": {"epss_score": 0.79349, "epss_percentile": 0.99035}, "CVE-2006-6064": {"epss_score": 0.04388, "epss_percentile": 0.88634}, "CVE-2006-6065": {"epss_score": 0.12825, "epss_percentile": 0.93795}, "CVE-2006-6066": {"epss_score": 0.01607, "epss_percentile": 0.81309}, "CVE-2006-6067": {"epss_score": 0.00613, "epss_percentile": 0.69251}, "CVE-2006-6068": {"epss_score": 0.00661, "epss_percentile": 0.70564}, "CVE-2006-6069": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-6070": {"epss_score": 0.01417, "epss_percentile": 0.80145}, "CVE-2006-6071": {"epss_score": 0.01488, "epss_percentile": 0.80614}, "CVE-2006-6072": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-6073": {"epss_score": 0.00579, "epss_percentile": 0.68217}, "CVE-2006-6074": {"epss_score": 0.01135, "epss_percentile": 0.77913}, "CVE-2006-6075": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-6076": {"epss_score": 0.78873, "epss_percentile": 0.99008}, "CVE-2006-6077": {"epss_score": 0.03057, "epss_percentile": 0.86302}, "CVE-2006-6078": {"epss_score": 0.13614, "epss_percentile": 0.94014}, "CVE-2006-6079": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-6080": {"epss_score": 0.01417, "epss_percentile": 0.80145}, "CVE-2006-6081": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-6082": {"epss_score": 0.02207, "epss_percentile": 0.84005}, "CVE-2006-6083": {"epss_score": 0.00612, "epss_percentile": 0.69233}, "CVE-2006-6084": {"epss_score": 0.06735, "epss_percentile": 0.90993}, "CVE-2006-6085": {"epss_score": 0.00388, "epss_percentile": 0.59353}, "CVE-2006-6086": {"epss_score": 0.12866, "epss_percentile": 0.93805}, "CVE-2006-6087": {"epss_score": 0.0351, "epss_percentile": 0.87264}, "CVE-2006-6088": {"epss_score": 0.08852, "epss_percentile": 0.92284}, "CVE-2006-6089": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2006-6090": {"epss_score": 0.01233, "epss_percentile": 0.78751}, "CVE-2006-6091": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2006-6092": {"epss_score": 0.0085, "epss_percentile": 0.74394}, "CVE-2006-6093": {"epss_score": 0.0648, "epss_percentile": 0.90786}, "CVE-2006-6094": {"epss_score": 0.01877, "epss_percentile": 0.82665}, "CVE-2006-6095": {"epss_score": 0.02916, "epss_percentile": 0.8598}, "CVE-2006-6096": {"epss_score": 0.03197, "epss_percentile": 0.86614}, "CVE-2006-6097": {"epss_score": 0.10442, "epss_percentile": 0.92988}, "CVE-2006-6101": {"epss_score": 0.00045, "epss_percentile": 0.13753}, "CVE-2006-6102": {"epss_score": 0.06429, "epss_percentile": 0.90754}, "CVE-2006-6103": {"epss_score": 0.00045, "epss_percentile": 0.13936}, "CVE-2006-6104": {"epss_score": 0.17546, "epss_percentile": 0.94864}, "CVE-2006-6105": {"epss_score": 0.00076, "epss_percentile": 0.23132}, "CVE-2006-6106": {"epss_score": 0.03555, "epss_percentile": 0.87346}, "CVE-2006-6107": {"epss_score": 0.00096, "epss_percentile": 0.27246}, "CVE-2006-6108": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-6109": {"epss_score": 0.00912, "epss_percentile": 0.75359}, "CVE-2006-6110": {"epss_score": 0.00936, "epss_percentile": 0.75677}, "CVE-2006-6111": {"epss_score": 0.01153, "epss_percentile": 0.7806}, "CVE-2006-6112": {"epss_score": 0.00763, "epss_percentile": 0.72891}, "CVE-2006-6113": {"epss_score": 0.00704, "epss_percentile": 0.71565}, "CVE-2006-6115": {"epss_score": 0.01805, "epss_percentile": 0.82347}, "CVE-2006-6116": {"epss_score": 0.01805, "epss_percentile": 0.82347}, "CVE-2006-6117": {"epss_score": 0.01805, "epss_percentile": 0.82347}, "CVE-2006-6118": {"epss_score": 0.00513, "epss_percentile": 0.65913}, "CVE-2006-6119": {"epss_score": 0.00404, "epss_percentile": 0.60425}, "CVE-2006-6120": {"epss_score": 0.06088, "epss_percentile": 0.90467}, "CVE-2006-6121": {"epss_score": 0.25874, "epss_percentile": 0.96088}, "CVE-2006-6122": {"epss_score": 0.00417, "epss_percentile": 0.61258}, "CVE-2006-6123": {"epss_score": 0.01918, "epss_percentile": 0.82881}, "CVE-2006-6124": {"epss_score": 0.00442, "epss_percentile": 0.627}, "CVE-2006-6125": {"epss_score": 0.23519, "epss_percentile": 0.95788}, "CVE-2006-6126": {"epss_score": 0.00086, "epss_percentile": 0.25414}, "CVE-2006-6127": {"epss_score": 0.00516, "epss_percentile": 0.66054}, "CVE-2006-6128": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2006-6129": {"epss_score": 0.00631, "epss_percentile": 0.69733}, "CVE-2006-6130": {"epss_score": 0.00557, "epss_percentile": 0.67537}, "CVE-2006-6131": {"epss_score": 0.00152, "epss_percentile": 0.36426}, "CVE-2006-6132": {"epss_score": 0.01042, "epss_percentile": 0.76985}, "CVE-2006-6133": {"epss_score": 0.71935, "epss_percentile": 0.98688}, "CVE-2006-6134": {"epss_score": 0.73664, "epss_percentile": 0.98766}, "CVE-2006-6135": {"epss_score": 0.00987, "epss_percentile": 0.76344}, "CVE-2006-6136": {"epss_score": 0.01214, "epss_percentile": 0.78572}, "CVE-2006-6137": {"epss_score": 0.05609, "epss_percentile": 0.90045}, "CVE-2006-6138": {"epss_score": 0.06348, "epss_percentile": 0.90689}, "CVE-2006-6139": {"epss_score": 0.00231, "epss_percentile": 0.45822}, "CVE-2006-6140": {"epss_score": 0.01605, "epss_percentile": 0.81292}, "CVE-2006-6141": {"epss_score": 0.03949, "epss_percentile": 0.87999}, "CVE-2006-6142": {"epss_score": 0.11286, "epss_percentile": 0.93293}, "CVE-2006-6143": {"epss_score": 0.34902, "epss_percentile": 0.96877}, "CVE-2006-6144": {"epss_score": 0.1848, "epss_percentile": 0.95021}, "CVE-2006-6145": {"epss_score": 0.00054, "epss_percentile": 0.1717}, "CVE-2006-6146": {"epss_score": 0.0055, "epss_percentile": 0.67331}, "CVE-2006-6147": {"epss_score": 0.01357, "epss_percentile": 0.79722}, "CVE-2006-6148": {"epss_score": 0.02193, "epss_percentile": 0.83947}, "CVE-2006-6149": {"epss_score": 0.01547, "epss_percentile": 0.8097}, "CVE-2006-6150": {"epss_score": 0.06312, "epss_percentile": 0.90664}, "CVE-2006-6151": {"epss_score": 0.01449, "epss_percentile": 0.80341}, "CVE-2006-6152": {"epss_score": 0.00632, "epss_percentile": 0.69747}, "CVE-2006-6153": {"epss_score": 0.00882, "epss_percentile": 0.74883}, "CVE-2006-6154": {"epss_score": 0.15282, "epss_percentile": 0.944}, "CVE-2006-6155": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-6156": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-6157": {"epss_score": 0.04983, "epss_percentile": 0.89362}, "CVE-2006-6158": {"epss_score": 0.01463, "epss_percentile": 0.80443}, "CVE-2006-6159": {"epss_score": 0.01722, "epss_percentile": 0.8194}, "CVE-2006-6160": {"epss_score": 0.01347, "epss_percentile": 0.79653}, "CVE-2006-6161": {"epss_score": 0.0078, "epss_percentile": 0.73169}, "CVE-2006-6162": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2006-6163": {"epss_score": 0.00339, "epss_percentile": 0.56169}, "CVE-2006-6164": {"epss_score": 0.00047, "epss_percentile": 0.14594}, "CVE-2006-6165": {"epss_score": 0.00141, "epss_percentile": 0.34918}, "CVE-2006-6166": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2006-6167": {"epss_score": 0.01507, "epss_percentile": 0.80755}, "CVE-2006-6168": {"epss_score": 0.04444, "epss_percentile": 0.88697}, "CVE-2006-6169": {"epss_score": 0.02645, "epss_percentile": 0.8532}, "CVE-2006-6170": {"epss_score": 0.14379, "epss_percentile": 0.94198}, "CVE-2006-6171": {"epss_score": 0.04783, "epss_percentile": 0.89137}, "CVE-2006-6172": {"epss_score": 0.04458, "epss_percentile": 0.88716}, "CVE-2006-6173": {"epss_score": 0.00314, "epss_percentile": 0.54079}, "CVE-2006-6174": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2006-6175": {"epss_score": 0.01925, "epss_percentile": 0.82923}, "CVE-2006-6176": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-6177": {"epss_score": 0.03201, "epss_percentile": 0.86624}, "CVE-2006-6178": {"epss_score": 0.0398, "epss_percentile": 0.88059}, "CVE-2006-6179": {"epss_score": 0.0398, "epss_percentile": 0.88059}, "CVE-2006-6180": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-6181": {"epss_score": 0.00826, "epss_percentile": 0.73974}, "CVE-2006-6182": {"epss_score": 0.0007, "epss_percentile": 0.21778}, "CVE-2006-6183": {"epss_score": 0.51457, "epss_percentile": 0.97779}, "CVE-2006-6184": {"epss_score": 0.80575, "epss_percentile": 0.99095}, "CVE-2006-6185": {"epss_score": 0.13242, "epss_percentile": 0.93911}, "CVE-2006-6186": {"epss_score": 0.00396, "epss_percentile": 0.59918}, "CVE-2006-6187": {"epss_score": 0.01311, "epss_percentile": 0.7937}, "CVE-2006-6188": {"epss_score": 0.00659, "epss_percentile": 0.70508}, "CVE-2006-6189": {"epss_score": 0.00689, "epss_percentile": 0.71214}, "CVE-2006-6190": {"epss_score": 0.00907, "epss_percentile": 0.75267}, "CVE-2006-6191": {"epss_score": 0.01805, "epss_percentile": 0.82347}, "CVE-2006-6192": {"epss_score": 0.0095, "epss_percentile": 0.75859}, "CVE-2006-6193": {"epss_score": 0.01897, "epss_percentile": 0.82758}, "CVE-2006-6194": {"epss_score": 0.00952, "epss_percentile": 0.75879}, "CVE-2006-6195": {"epss_score": 0.00869, "epss_percentile": 0.74692}, "CVE-2006-6196": {"epss_score": 0.02076, "epss_percentile": 0.83511}, "CVE-2006-6197": {"epss_score": 0.01215, "epss_percentile": 0.78585}, "CVE-2006-6198": {"epss_score": 0.00602, "epss_percentile": 0.68876}, "CVE-2006-6199": {"epss_score": 0.84024, "epss_percentile": 0.99271}, "CVE-2006-6200": {"epss_score": 0.00324, "epss_percentile": 0.54956}, "CVE-2006-6201": {"epss_score": 0.05421, "epss_percentile": 0.89862}, "CVE-2006-6202": {"epss_score": 0.01535, "epss_percentile": 0.80906}, "CVE-2006-6203": {"epss_score": 0.03243, "epss_percentile": 0.86735}, "CVE-2006-6204": {"epss_score": 0.01381, "epss_percentile": 0.7987}, "CVE-2006-6205": {"epss_score": 0.01074, "epss_percentile": 0.77302}, "CVE-2006-6206": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2006-6207": {"epss_score": 0.00565, "epss_percentile": 0.67796}, "CVE-2006-6208": {"epss_score": 0.01081, "epss_percentile": 0.77378}, "CVE-2006-6209": {"epss_score": 0.00908, "epss_percentile": 0.75283}, "CVE-2006-6210": {"epss_score": 0.00499, "epss_percentile": 0.65286}, "CVE-2006-6211": {"epss_score": 0.0188, "epss_percentile": 0.82676}, "CVE-2006-6212": {"epss_score": 0.01437, "epss_percentile": 0.80282}, "CVE-2006-6213": {"epss_score": 0.03695, "epss_percentile": 0.87583}, "CVE-2006-6214": {"epss_score": 0.01897, "epss_percentile": 0.82758}, "CVE-2006-6215": {"epss_score": 0.00509, "epss_percentile": 0.65745}, "CVE-2006-6216": {"epss_score": 0.01347, "epss_percentile": 0.79653}, "CVE-2006-6217": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-6218": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2006-6219": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-6220": {"epss_score": 0.01594, "epss_percentile": 0.81233}, "CVE-2006-6221": {"epss_score": 0.01269, "epss_percentile": 0.79039}, "CVE-2006-6222": {"epss_score": 0.39126, "epss_percentile": 0.97142}, "CVE-2006-6223": {"epss_score": 0.02064, "epss_percentile": 0.83452}, "CVE-2006-6224": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-6225": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2006-6226": {"epss_score": 0.02116, "epss_percentile": 0.83662}, "CVE-2006-6227": {"epss_score": 0.01306, "epss_percentile": 0.79332}, "CVE-2006-6228": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-6229": {"epss_score": 0.00343, "epss_percentile": 0.56452}, "CVE-2006-6230": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-6231": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-6232": {"epss_score": 0.02367, "epss_percentile": 0.84517}, "CVE-2006-6233": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-6234": {"epss_score": 0.0115, "epss_percentile": 0.78032}, "CVE-2006-6235": {"epss_score": 0.08898, "epss_percentile": 0.92305}, "CVE-2006-6236": {"epss_score": 0.53394, "epss_percentile": 0.97874}, "CVE-2006-6237": {"epss_score": 0.02339, "epss_percentile": 0.84426}, "CVE-2006-6238": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2006-6239": {"epss_score": 0.02904, "epss_percentile": 0.85959}, "CVE-2006-6240": {"epss_score": 0.00603, "epss_percentile": 0.68901}, "CVE-2006-6241": {"epss_score": 0.0065, "epss_percentile": 0.70249}, "CVE-2006-6242": {"epss_score": 0.04411, "epss_percentile": 0.88661}, "CVE-2006-6243": {"epss_score": 0.02966, "epss_percentile": 0.86084}, "CVE-2006-6244": {"epss_score": 0.00739, "epss_percentile": 0.72357}, "CVE-2006-6245": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-6246": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2006-6247": {"epss_score": 0.01839, "epss_percentile": 0.82487}, "CVE-2006-6248": {"epss_score": 0.00434, "epss_percentile": 0.62317}, "CVE-2006-6249": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-6250": {"epss_score": 0.05741, "epss_percentile": 0.90172}, "CVE-2006-6251": {"epss_score": 0.78545, "epss_percentile": 0.98992}, "CVE-2006-6252": {"epss_score": 0.13289, "epss_percentile": 0.93923}, "CVE-2006-6253": {"epss_score": 0.00674, "epss_percentile": 0.7087}, "CVE-2006-6254": {"epss_score": 0.09007, "epss_percentile": 0.92361}, "CVE-2006-6255": {"epss_score": 0.06244, "epss_percentile": 0.906}, "CVE-2006-6256": {"epss_score": 0.02467, "epss_percentile": 0.84837}, "CVE-2006-6257": {"epss_score": 0.01764, "epss_percentile": 0.8216}, "CVE-2006-6258": {"epss_score": 0.02339, "epss_percentile": 0.84427}, "CVE-2006-6259": {"epss_score": 0.06413, "epss_percentile": 0.90743}, "CVE-2006-6260": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2006-6261": {"epss_score": 0.23016, "epss_percentile": 0.95718}, "CVE-2006-6262": {"epss_score": 0.05003, "epss_percentile": 0.89381}, "CVE-2006-6263": {"epss_score": 0.10146, "epss_percentile": 0.92864}, "CVE-2006-6264": {"epss_score": 0.13448, "epss_percentile": 0.93967}, "CVE-2006-6265": {"epss_score": 0.03062, "epss_percentile": 0.86318}, "CVE-2006-6266": {"epss_score": 0.17947, "epss_percentile": 0.94932}, "CVE-2006-6267": {"epss_score": 0.0057, "epss_percentile": 0.67958}, "CVE-2006-6268": {"epss_score": 0.00746, "epss_percentile": 0.7255}, "CVE-2006-6269": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-6270": {"epss_score": 0.00447, "epss_percentile": 0.62937}, "CVE-2006-6271": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2006-6272": {"epss_score": 0.00458, "epss_percentile": 0.63449}, "CVE-2006-6273": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-6274": {"epss_score": 0.01577, "epss_percentile": 0.81118}, "CVE-2006-6275": {"epss_score": 0.0005, "epss_percentile": 0.1568}, "CVE-2006-6276": {"epss_score": 0.01233, "epss_percentile": 0.78752}, "CVE-2006-6277": {"epss_score": 0.04655, "epss_percentile": 0.8897}, "CVE-2006-6278": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-6279": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2006-6280": {"epss_score": 0.00891, "epss_percentile": 0.75053}, "CVE-2006-6281": {"epss_score": 0.01739, "epss_percentile": 0.82041}, "CVE-2006-6282": {"epss_score": 0.0085, "epss_percentile": 0.74386}, "CVE-2006-6283": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2006-6284": {"epss_score": 0.04211, "epss_percentile": 0.884}, "CVE-2006-6285": {"epss_score": 0.01078, "epss_percentile": 0.77342}, "CVE-2006-6286": {"epss_score": 0.00051, "epss_percentile": 0.16269}, "CVE-2006-6287": {"epss_score": 0.07657, "epss_percentile": 0.91608}, "CVE-2006-6288": {"epss_score": 0.08311, "epss_percentile": 0.91986}, "CVE-2006-6289": {"epss_score": 0.05873, "epss_percentile": 0.90282}, "CVE-2006-6290": {"epss_score": 0.02078, "epss_percentile": 0.83521}, "CVE-2006-6291": {"epss_score": 0.01459, "epss_percentile": 0.80411}, "CVE-2006-6292": {"epss_score": 0.01208, "epss_percentile": 0.78535}, "CVE-2006-6293": {"epss_score": 0.12971, "epss_percentile": 0.93832}, "CVE-2006-6294": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2006-6295": {"epss_score": 0.02591, "epss_percentile": 0.85183}, "CVE-2006-6296": {"epss_score": 0.36523, "epss_percentile": 0.96983}, "CVE-2006-6297": {"epss_score": 0.0261, "epss_percentile": 0.85235}, "CVE-2006-6298": {"epss_score": 0.00654, "epss_percentile": 0.70357}, "CVE-2006-6299": {"epss_score": 0.17151, "epss_percentile": 0.94783}, "CVE-2006-6300": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2006-6301": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2006-6302": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2006-6303": {"epss_score": 0.04215, "epss_percentile": 0.88405}, "CVE-2006-6304": {"epss_score": 0.01396, "epss_percentile": 0.7998}, "CVE-2006-6305": {"epss_score": 0.00774, "epss_percentile": 0.73066}, "CVE-2006-6306": {"epss_score": 0.00095, "epss_percentile": 0.27092}, "CVE-2006-6307": {"epss_score": 0.01632, "epss_percentile": 0.81456}, "CVE-2006-6308": {"epss_score": 0.00101, "epss_percentile": 0.28605}, "CVE-2006-6309": {"epss_score": 0.01503, "epss_percentile": 0.80731}, "CVE-2006-6310": {"epss_score": 0.14238, "epss_percentile": 0.9417}, "CVE-2006-6311": {"epss_score": 0.4443, "epss_percentile": 0.97434}, "CVE-2006-6318": {"epss_score": 0.02393, "epss_percentile": 0.84608}, "CVE-2006-6328": {"epss_score": 0.0508, "epss_percentile": 0.89471}, "CVE-2006-6329": {"epss_score": 0.0698, "epss_percentile": 0.91159}, "CVE-2006-6330": {"epss_score": 0.03607, "epss_percentile": 0.87419}, "CVE-2006-6331": {"epss_score": 0.00747, "epss_percentile": 0.7256}, "CVE-2006-6332": {"epss_score": 0.60838, "epss_percentile": 0.98224}, "CVE-2006-6333": {"epss_score": 0.02704, "epss_percentile": 0.85461}, "CVE-2006-6334": {"epss_score": 0.20496, "epss_percentile": 0.95356}, "CVE-2006-6335": {"epss_score": 0.16291, "epss_percentile": 0.94612}, "CVE-2006-6336": {"epss_score": 0.20356, "epss_percentile": 0.95331}, "CVE-2006-6337": {"epss_score": 0.0076, "epss_percentile": 0.72805}, "CVE-2006-6338": {"epss_score": 0.04655, "epss_percentile": 0.8897}, "CVE-2006-6339": {"epss_score": 0.00492, "epss_percentile": 0.64991}, "CVE-2006-6340": {"epss_score": 0.02958, "epss_percentile": 0.86065}, "CVE-2006-6341": {"epss_score": 0.06749, "epss_percentile": 0.91001}, "CVE-2006-6342": {"epss_score": 0.00819, "epss_percentile": 0.73864}, "CVE-2006-6343": {"epss_score": 0.00542, "epss_percentile": 0.67064}, "CVE-2006-6344": {"epss_score": 0.00357, "epss_percentile": 0.57459}, "CVE-2006-6345": {"epss_score": 0.00889, "epss_percentile": 0.75012}, "CVE-2006-6346": {"epss_score": 0.01764, "epss_percentile": 0.82159}, "CVE-2006-6347": {"epss_score": 0.00611, "epss_percentile": 0.6919}, "CVE-2006-6348": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2006-6349": {"epss_score": 0.03111, "epss_percentile": 0.86425}, "CVE-2006-6350": {"epss_score": 0.01169, "epss_percentile": 0.78203}, "CVE-2006-6351": {"epss_score": 0.01169, "epss_percentile": 0.78203}, "CVE-2006-6352": {"epss_score": 0.15452, "epss_percentile": 0.94431}, "CVE-2006-6353": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-2006-6354": {"epss_score": 0.01319, "epss_percentile": 0.79433}, "CVE-2006-6355": {"epss_score": 0.01513, "epss_percentile": 0.80788}, "CVE-2006-6356": {"epss_score": 0.00798, "epss_percentile": 0.73505}, "CVE-2006-6357": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-6358": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2006-6359": {"epss_score": 0.0064, "epss_percentile": 0.69959}, "CVE-2006-6360": {"epss_score": 0.09544, "epss_percentile": 0.92591}, "CVE-2006-6361": {"epss_score": 0.0245, "epss_percentile": 0.8478}, "CVE-2006-6363": {"epss_score": 0.15993, "epss_percentile": 0.9455}, "CVE-2006-6364": {"epss_score": 0.14184, "epss_percentile": 0.94157}, "CVE-2006-6365": {"epss_score": 0.03396, "epss_percentile": 0.8706}, "CVE-2006-6366": {"epss_score": 0.00458, "epss_percentile": 0.63449}, "CVE-2006-6367": {"epss_score": 0.02927, "epss_percentile": 0.8601}, "CVE-2006-6368": {"epss_score": 0.10616, "epss_percentile": 0.9305}, "CVE-2006-6369": {"epss_score": 0.00282, "epss_percentile": 0.51216}, "CVE-2006-6370": {"epss_score": 0.00335, "epss_percentile": 0.55861}, "CVE-2006-6371": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-6372": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-6373": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2006-6374": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-6375": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2006-6376": {"epss_score": 0.15109, "epss_percentile": 0.94365}, "CVE-2006-6377": {"epss_score": 0.08387, "epss_percentile": 0.92022}, "CVE-2006-6378": {"epss_score": 0.00846, "epss_percentile": 0.74343}, "CVE-2006-6379": {"epss_score": 0.29064, "epss_percentile": 0.96415}, "CVE-2006-6380": {"epss_score": 0.05872, "epss_percentile": 0.90281}, "CVE-2006-6381": {"epss_score": 0.0721, "epss_percentile": 0.91328}, "CVE-2006-6382": {"epss_score": 0.00036, "epss_percentile": 0.1033}, "CVE-2006-6383": {"epss_score": 0.00247, "epss_percentile": 0.47856}, "CVE-2006-6384": {"epss_score": 0.00522, "epss_percentile": 0.66253}, "CVE-2006-6385": {"epss_score": 0.0018, "epss_percentile": 0.39971}, "CVE-2006-6386": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-6387": {"epss_score": 0.00317, "epss_percentile": 0.54339}, "CVE-2006-6388": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2006-6389": {"epss_score": 0.00614, "epss_percentile": 0.69277}, "CVE-2006-6390": {"epss_score": 0.07551, "epss_percentile": 0.91537}, "CVE-2006-6391": {"epss_score": 0.02711, "epss_percentile": 0.85497}, "CVE-2006-6392": {"epss_score": 0.01031, "epss_percentile": 0.76853}, "CVE-2006-6393": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-6394": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-6395": {"epss_score": 0.00459, "epss_percentile": 0.63461}, "CVE-2006-6396": {"epss_score": 0.22821, "epss_percentile": 0.95695}, "CVE-2006-6397": {"epss_score": 0.00154, "epss_percentile": 0.36657}, "CVE-2006-6398": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-6399": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-6400": {"epss_score": 0.059, "epss_percentile": 0.90308}, "CVE-2006-6401": {"epss_score": 0.01361, "epss_percentile": 0.79756}, "CVE-2006-6402": {"epss_score": 0.00792, "epss_percentile": 0.73411}, "CVE-2006-6403": {"epss_score": 0.00462, "epss_percentile": 0.63595}, "CVE-2006-6404": {"epss_score": 0.00543, "epss_percentile": 0.67123}, "CVE-2006-6405": {"epss_score": 0.00309, "epss_percentile": 0.53651}, "CVE-2006-6406": {"epss_score": 0.05758, "epss_percentile": 0.90182}, "CVE-2006-6407": {"epss_score": 0.00327, "epss_percentile": 0.55151}, "CVE-2006-6408": {"epss_score": 0.00391, "epss_percentile": 0.59613}, "CVE-2006-6409": {"epss_score": 0.00581, "epss_percentile": 0.68264}, "CVE-2006-6410": {"epss_score": 0.00211, "epss_percentile": 0.43685}, "CVE-2006-6411": {"epss_score": 0.01602, "epss_percentile": 0.81271}, "CVE-2006-6413": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2006-6414": {"epss_score": 0.00626, "epss_percentile": 0.69617}, "CVE-2006-6415": {"epss_score": 0.01059, "epss_percentile": 0.77158}, "CVE-2006-6416": {"epss_score": 0.01449, "epss_percentile": 0.80341}, "CVE-2006-6417": {"epss_score": 0.05797, "epss_percentile": 0.90218}, "CVE-2006-6418": {"epss_score": 0.00191, "epss_percentile": 0.41269}, "CVE-2006-6419": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-6420": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-6421": {"epss_score": 0.01944, "epss_percentile": 0.82998}, "CVE-2006-6422": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2006-6423": {"epss_score": 0.45762, "epss_percentile": 0.975}, "CVE-2006-6424": {"epss_score": 0.61996, "epss_percentile": 0.98272}, "CVE-2006-6425": {"epss_score": 0.76472, "epss_percentile": 0.98892}, "CVE-2006-6426": {"epss_score": 0.14902, "epss_percentile": 0.94318}, "CVE-2006-6427": {"epss_score": 0.05433, "epss_percentile": 0.89879}, "CVE-2006-6428": {"epss_score": 0.00815, "epss_percentile": 0.73779}, "CVE-2006-6429": {"epss_score": 0.00488, "epss_percentile": 0.64841}, "CVE-2006-6430": {"epss_score": 0.00459, "epss_percentile": 0.63469}, "CVE-2006-6431": {"epss_score": 0.00384, "epss_percentile": 0.59124}, "CVE-2006-6432": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-6433": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2006-6434": {"epss_score": 0.00481, "epss_percentile": 0.64496}, "CVE-2006-6435": {"epss_score": 0.0095, "epss_percentile": 0.75859}, "CVE-2006-6436": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-6437": {"epss_score": 0.00465, "epss_percentile": 0.63756}, "CVE-2006-6438": {"epss_score": 0.00064, "epss_percentile": 0.20258}, "CVE-2006-6439": {"epss_score": 0.0039, "epss_percentile": 0.59506}, "CVE-2006-6440": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-6441": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2006-6442": {"epss_score": 0.14856, "epss_percentile": 0.94303}, "CVE-2006-6443": {"epss_score": 0.00493, "epss_percentile": 0.65037}, "CVE-2006-6444": {"epss_score": 0.03372, "epss_percentile": 0.87012}, "CVE-2006-6445": {"epss_score": 0.07353, "epss_percentile": 0.91427}, "CVE-2006-6446": {"epss_score": 0.00349, "epss_percentile": 0.56866}, "CVE-2006-6447": {"epss_score": 0.01173, "epss_percentile": 0.78239}, "CVE-2006-6448": {"epss_score": 0.00431, "epss_percentile": 0.62085}, "CVE-2006-6449": {"epss_score": 0.00297, "epss_percentile": 0.5274}, "CVE-2006-6450": {"epss_score": 0.0966, "epss_percentile": 0.92644}, "CVE-2006-6451": {"epss_score": 0.00517, "epss_percentile": 0.66063}, "CVE-2006-6452": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2006-6453": {"epss_score": 0.04104, "epss_percentile": 0.88265}, "CVE-2006-6454": {"epss_score": 0.03274, "epss_percentile": 0.868}, "CVE-2006-6455": {"epss_score": 0.00816, "epss_percentile": 0.73826}, "CVE-2006-6456": {"epss_score": 0.59649, "epss_percentile": 0.98174}, "CVE-2006-6457": {"epss_score": 0.00346, "epss_percentile": 0.56731}, "CVE-2006-6458": {"epss_score": 0.0094, "epss_percentile": 0.75739}, "CVE-2006-6459": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-6460": {"epss_score": 0.01214, "epss_percentile": 0.78579}, "CVE-2006-6461": {"epss_score": 0.0046, "epss_percentile": 0.63528}, "CVE-2006-6462": {"epss_score": 0.11687, "epss_percentile": 0.93449}, "CVE-2006-6463": {"epss_score": 0.00916, "epss_percentile": 0.75416}, "CVE-2006-6464": {"epss_score": 0.0057, "epss_percentile": 0.67965}, "CVE-2006-6465": {"epss_score": 0.00601, "epss_percentile": 0.68854}, "CVE-2006-6466": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-6467": {"epss_score": 0.00202, "epss_percentile": 0.42423}, "CVE-2006-6468": {"epss_score": 0.00051, "epss_percentile": 0.16279}, "CVE-2006-6469": {"epss_score": 0.00095, "epss_percentile": 0.27221}, "CVE-2006-6470": {"epss_score": 0.00402, "epss_percentile": 0.60263}, "CVE-2006-6471": {"epss_score": 0.00304, "epss_percentile": 0.5324}, "CVE-2006-6472": {"epss_score": 0.00402, "epss_percentile": 0.60263}, "CVE-2006-6473": {"epss_score": 0.00357, "epss_percentile": 0.57454}, "CVE-2006-6474": {"epss_score": 0.00075, "epss_percentile": 0.22949}, "CVE-2006-6475": {"epss_score": 0.01194, "epss_percentile": 0.78414}, "CVE-2006-6476": {"epss_score": 0.00099, "epss_percentile": 0.28371}, "CVE-2006-6477": {"epss_score": 0.00091, "epss_percentile": 0.26407}, "CVE-2006-6478": {"epss_score": 0.0077, "epss_percentile": 0.72995}, "CVE-2006-6479": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2006-6480": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2006-6481": {"epss_score": 0.06934, "epss_percentile": 0.91124}, "CVE-2006-6482": {"epss_score": 0.0139, "epss_percentile": 0.79936}, "CVE-2006-6483": {"epss_score": 0.02078, "epss_percentile": 0.83518}, "CVE-2006-6484": {"epss_score": 0.02892, "epss_percentile": 0.85919}, "CVE-2006-6485": {"epss_score": 0.04506, "epss_percentile": 0.8877}, "CVE-2006-6486": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-6487": {"epss_score": 0.00758, "epss_percentile": 0.72782}, "CVE-2006-6488": {"epss_score": 0.29587, "epss_percentile": 0.9646}, "CVE-2006-6489": {"epss_score": 0.01506, "epss_percentile": 0.80749}, "CVE-2006-6490": {"epss_score": 0.33469, "epss_percentile": 0.96775}, "CVE-2006-6493": {"epss_score": 0.08429, "epss_percentile": 0.92047}, "CVE-2006-6494": {"epss_score": 0.00037, "epss_percentile": 0.10859}, "CVE-2006-6495": {"epss_score": 0.00057, "epss_percentile": 0.1816}, "CVE-2006-6496": {"epss_score": 0.00047, "epss_percentile": 0.14782}, "CVE-2006-6497": {"epss_score": 0.11214, "epss_percentile": 0.93267}, "CVE-2006-6498": {"epss_score": 0.11214, "epss_percentile": 0.93267}, "CVE-2006-6499": {"epss_score": 0.13714, "epss_percentile": 0.94041}, "CVE-2006-6500": {"epss_score": 0.37533, "epss_percentile": 0.97052}, "CVE-2006-6501": {"epss_score": 0.26235, "epss_percentile": 0.96127}, "CVE-2006-6502": {"epss_score": 0.20705, "epss_percentile": 0.95404}, "CVE-2006-6503": {"epss_score": 0.10286, "epss_percentile": 0.92927}, "CVE-2006-6504": {"epss_score": 0.41553, "epss_percentile": 0.97283}, "CVE-2006-6505": {"epss_score": 0.27493, "epss_percentile": 0.96253}, "CVE-2006-6506": {"epss_score": 0.02548, "epss_percentile": 0.85068}, "CVE-2006-6507": {"epss_score": 0.04308, "epss_percentile": 0.88525}, "CVE-2006-6508": {"epss_score": 0.00729, "epss_percentile": 0.72117}, "CVE-2006-6509": {"epss_score": 0.0007, "epss_percentile": 0.21799}, "CVE-2006-6510": {"epss_score": 0.00075, "epss_percentile": 0.23022}, "CVE-2006-6511": {"epss_score": 0.00855, "epss_percentile": 0.7447}, "CVE-2006-6512": {"epss_score": 0.01093, "epss_percentile": 0.77471}, "CVE-2006-6513": {"epss_score": 0.00645, "epss_percentile": 0.70104}, "CVE-2006-6514": {"epss_score": 0.00749, "epss_percentile": 0.7261}, "CVE-2006-6515": {"epss_score": 0.00376, "epss_percentile": 0.58674}, "CVE-2006-6516": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2006-6517": {"epss_score": 0.00489, "epss_percentile": 0.64909}, "CVE-2006-6518": {"epss_score": 0.01428, "epss_percentile": 0.80218}, "CVE-2006-6519": {"epss_score": 0.00595, "epss_percentile": 0.6869}, "CVE-2006-6520": {"epss_score": 0.02051, "epss_percentile": 0.83407}, "CVE-2006-6521": {"epss_score": 0.00724, "epss_percentile": 0.72039}, "CVE-2006-6522": {"epss_score": 0.00977, "epss_percentile": 0.76228}, "CVE-2006-6523": {"epss_score": 0.06091, "epss_percentile": 0.90474}, "CVE-2006-6524": {"epss_score": 0.01573, "epss_percentile": 0.811}, "CVE-2006-6525": {"epss_score": 0.00818, "epss_percentile": 0.73862}, "CVE-2006-6526": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2006-6527": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-6528": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-6529": {"epss_score": 0.00554, "epss_percentile": 0.67437}, "CVE-2006-6530": {"epss_score": 0.00502, "epss_percentile": 0.65437}, "CVE-2006-6531": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2006-6532": {"epss_score": 0.00867, "epss_percentile": 0.74647}, "CVE-2006-6533": {"epss_score": 0.00729, "epss_percentile": 0.72122}, "CVE-2006-6534": {"epss_score": 0.00396, "epss_percentile": 0.59917}, "CVE-2006-6535": {"epss_score": 0.01147, "epss_percentile": 0.78005}, "CVE-2006-6536": {"epss_score": 0.00763, "epss_percentile": 0.72882}, "CVE-2006-6537": {"epss_score": 0.00667, "epss_percentile": 0.70699}, "CVE-2006-6538": {"epss_score": 0.08766, "epss_percentile": 0.92246}, "CVE-2006-6539": {"epss_score": 0.17617, "epss_percentile": 0.94875}, "CVE-2006-6540": {"epss_score": 0.00581, "epss_percentile": 0.68263}, "CVE-2006-6541": {"epss_score": 0.01281, "epss_percentile": 0.79144}, "CVE-2006-6542": {"epss_score": 0.01347, "epss_percentile": 0.79653}, "CVE-2006-6543": {"epss_score": 0.01347, "epss_percentile": 0.79653}, "CVE-2006-6544": {"epss_score": 0.00422, "epss_percentile": 0.61578}, "CVE-2006-6545": {"epss_score": 0.0471, "epss_percentile": 0.89037}, "CVE-2006-6546": {"epss_score": 0.06847, "epss_percentile": 0.91069}, "CVE-2006-6547": {"epss_score": 0.01878, "epss_percentile": 0.82668}, "CVE-2006-6548": {"epss_score": 0.00244, "epss_percentile": 0.47565}, "CVE-2006-6549": {"epss_score": 0.01059, "epss_percentile": 0.77158}, "CVE-2006-6550": {"epss_score": 0.05419, "epss_percentile": 0.89856}, "CVE-2006-6551": {"epss_score": 0.05419, "epss_percentile": 0.89856}, "CVE-2006-6552": {"epss_score": 0.101, "epss_percentile": 0.92849}, "CVE-2006-6553": {"epss_score": 0.06847, "epss_percentile": 0.91069}, "CVE-2006-6554": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2006-6555": {"epss_score": 0.00487, "epss_percentile": 0.64799}, "CVE-2006-6556": {"epss_score": 0.01477, "epss_percentile": 0.80547}, "CVE-2006-6557": {"epss_score": 0.00445, "epss_percentile": 0.62857}, "CVE-2006-6558": {"epss_score": 0.06584, "epss_percentile": 0.90865}, "CVE-2006-6559": {"epss_score": 0.01347, "epss_percentile": 0.79653}, "CVE-2006-6560": {"epss_score": 0.05497, "epss_percentile": 0.89935}, "CVE-2006-6561": {"epss_score": 0.71425, "epss_percentile": 0.98667}, "CVE-2006-6563": {"epss_score": 0.00247, "epss_percentile": 0.47906}, "CVE-2006-6564": {"epss_score": 0.06828, "epss_percentile": 0.91053}, "CVE-2006-6565": {"epss_score": 0.66974, "epss_percentile": 0.98488}, "CVE-2006-6566": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2006-6567": {"epss_score": 0.0507, "epss_percentile": 0.89463}, "CVE-2006-6568": {"epss_score": 0.07065, "epss_percentile": 0.91223}, "CVE-2006-6569": {"epss_score": 0.04003, "epss_percentile": 0.88095}, "CVE-2006-6570": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2006-6571": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2006-6572": {"epss_score": 0.00604, "epss_percentile": 0.68953}, "CVE-2006-6573": {"epss_score": 0.01157, "epss_percentile": 0.78115}, "CVE-2006-6574": {"epss_score": 0.01193, "epss_percentile": 0.78406}, "CVE-2006-6575": {"epss_score": 0.05419, "epss_percentile": 0.89856}, "CVE-2006-6576": {"epss_score": 0.88576, "epss_percentile": 0.99479}, "CVE-2006-6577": {"epss_score": 0.00715, "epss_percentile": 0.7184}, "CVE-2006-6578": {"epss_score": 0.014, "epss_percentile": 0.8}, "CVE-2006-6579": {"epss_score": 0.00185, "epss_percentile": 0.4055}, "CVE-2006-6580": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2006-6581": {"epss_score": 0.03801, "epss_percentile": 0.87743}, "CVE-2006-6582": {"epss_score": 0.01535, "epss_percentile": 0.80912}, "CVE-2006-6583": {"epss_score": 0.00763, "epss_percentile": 0.72859}, "CVE-2006-6584": {"epss_score": 0.03166, "epss_percentile": 0.8654}, "CVE-2006-6585": {"epss_score": 0.00459, "epss_percentile": 0.63468}, "CVE-2006-6586": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-6587": {"epss_score": 0.07795, "epss_percentile": 0.91685}, "CVE-2006-6588": {"epss_score": 0.03174, "epss_percentile": 0.86557}, "CVE-2006-6589": {"epss_score": 0.07443, "epss_percentile": 0.91475}, "CVE-2006-6590": {"epss_score": 0.04642, "epss_percentile": 0.88954}, "CVE-2006-6591": {"epss_score": 0.00717, "epss_percentile": 0.71912}, "CVE-2006-6592": {"epss_score": 0.01735, "epss_percentile": 0.82007}, "CVE-2006-6593": {"epss_score": 0.00712, "epss_percentile": 0.71754}, "CVE-2006-6594": {"epss_score": 0.00743, "epss_percentile": 0.72469}, "CVE-2006-6595": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2006-6596": {"epss_score": 0.01052, "epss_percentile": 0.77093}, "CVE-2006-6597": {"epss_score": 0.03928, "epss_percentile": 0.87969}, "CVE-2006-6598": {"epss_score": 0.06221, "epss_percentile": 0.90581}, "CVE-2006-6599": {"epss_score": 0.03347, "epss_percentile": 0.86953}, "CVE-2006-6600": {"epss_score": 0.00885, "epss_percentile": 0.74946}, "CVE-2006-6601": {"epss_score": 0.43065, "epss_percentile": 0.97368}, "CVE-2006-6602": {"epss_score": 0.40308, "epss_percentile": 0.97211}, "CVE-2006-6603": {"epss_score": 0.07999, "epss_percentile": 0.91818}, "CVE-2006-6604": {"epss_score": 0.05378, "epss_percentile": 0.89805}, "CVE-2006-6605": {"epss_score": 0.51974, "epss_percentile": 0.97804}, "CVE-2006-6606": {"epss_score": 0.00596, "epss_percentile": 0.68705}, "CVE-2006-6607": {"epss_score": 0.00128, "epss_percentile": 0.33071}, "CVE-2006-6608": {"epss_score": 0.03054, "epss_percentile": 0.86294}, "CVE-2006-6609": {"epss_score": 0.01224, "epss_percentile": 0.78676}, "CVE-2006-6610": {"epss_score": 0.06317, "epss_percentile": 0.90667}, "CVE-2006-6611": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2006-6612": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2006-6613": {"epss_score": 0.06244, "epss_percentile": 0.906}, "CVE-2006-6614": {"epss_score": 0.00069, "epss_percentile": 0.21513}, "CVE-2006-6615": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2006-6616": {"epss_score": 0.00827, "epss_percentile": 0.73989}, "CVE-2006-6617": {"epss_score": 0.31715, "epss_percentile": 0.96643}, "CVE-2006-6618": {"epss_score": 0.00058, "epss_percentile": 0.18608}, "CVE-2006-6619": {"epss_score": 0.00155, "epss_percentile": 0.36827}, "CVE-2006-6620": {"epss_score": 0.00058, "epss_percentile": 0.18608}, "CVE-2006-6621": {"epss_score": 0.00058, "epss_percentile": 0.18608}, "CVE-2006-6622": {"epss_score": 0.00058, "epss_percentile": 0.18608}, "CVE-2006-6623": {"epss_score": 0.00058, "epss_percentile": 0.18608}, "CVE-2006-6624": {"epss_score": 0.08408, "epss_percentile": 0.92034}, "CVE-2006-6625": {"epss_score": 0.0052, "epss_percentile": 0.66192}, "CVE-2006-6626": {"epss_score": 0.00848, "epss_percentile": 0.74358}, "CVE-2006-6627": {"epss_score": 0.09863, "epss_percentile": 0.92742}, "CVE-2006-6628": {"epss_score": 0.10919, "epss_percentile": 0.93158}, "CVE-2006-6629": {"epss_score": 0.00445, "epss_percentile": 0.62857}, "CVE-2006-6630": {"epss_score": 0.00612, "epss_percentile": 0.69223}, "CVE-2006-6631": {"epss_score": 0.05788, "epss_percentile": 0.9021}, "CVE-2006-6632": {"epss_score": 0.05788, "epss_percentile": 0.9021}, "CVE-2006-6633": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-6634": {"epss_score": 0.03669, "epss_percentile": 0.87536}, "CVE-2006-6635": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-6636": {"epss_score": 0.01656, "epss_percentile": 0.81599}, "CVE-2006-6637": {"epss_score": 0.01012, "epss_percentile": 0.76622}, "CVE-2006-6638": {"epss_score": 0.01076, "epss_percentile": 0.77327}, "CVE-2006-6639": {"epss_score": 0.00061, "epss_percentile": 0.19408}, "CVE-2006-6640": {"epss_score": 0.09079, "epss_percentile": 0.9239}, "CVE-2006-6641": {"epss_score": 0.01235, "epss_percentile": 0.78762}, "CVE-2006-6642": {"epss_score": 0.0069, "epss_percentile": 0.71252}, "CVE-2006-6643": {"epss_score": 0.06653, "epss_percentile": 0.90917}, "CVE-2006-6644": {"epss_score": 0.09194, "epss_percentile": 0.92442}, "CVE-2006-6645": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-6646": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2006-6647": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2006-6648": {"epss_score": 0.02141, "epss_percentile": 0.83751}, "CVE-2006-6649": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2006-6650": {"epss_score": 0.09194, "epss_percentile": 0.92442}, "CVE-2006-6651": {"epss_score": 0.08089, "epss_percentile": 0.91875}, "CVE-2006-6652": {"epss_score": 0.36071, "epss_percentile": 0.96954}, "CVE-2006-6653": {"epss_score": 0.00055, "epss_percentile": 0.17564}, "CVE-2006-6654": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2006-6655": {"epss_score": 0.00055, "epss_percentile": 0.17564}, "CVE-2006-6656": {"epss_score": 0.00064, "epss_percentile": 0.20258}, "CVE-2006-6657": {"epss_score": 0.00064, "epss_percentile": 0.20258}, "CVE-2006-6658": {"epss_score": 0.00333, "epss_percentile": 0.55672}, "CVE-2006-6659": {"epss_score": 0.22968, "epss_percentile": 0.95711}, "CVE-2006-6660": {"epss_score": 0.03689, "epss_percentile": 0.87574}, "CVE-2006-6661": {"epss_score": 0.03263, "epss_percentile": 0.86777}, "CVE-2006-6662": {"epss_score": 0.00058, "epss_percentile": 0.18458}, "CVE-2006-6663": {"epss_score": 0.01224, "epss_percentile": 0.78676}, "CVE-2006-6664": {"epss_score": 0.02313, "epss_percentile": 0.84348}, "CVE-2006-6665": {"epss_score": 0.75657, "epss_percentile": 0.9886}, "CVE-2006-6666": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2006-6667": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2006-6668": {"epss_score": 0.00834, "epss_percentile": 0.74104}, "CVE-2006-6669": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2006-6670": {"epss_score": 0.00406, "epss_percentile": 0.6052}, "CVE-2006-6671": {"epss_score": 0.00775, "epss_percentile": 0.73077}, "CVE-2006-6672": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2006-6673": {"epss_score": 0.05489, "epss_percentile": 0.89929}, "CVE-2006-6674": {"epss_score": 0.00071, "epss_percentile": 0.22167}, "CVE-2006-6675": {"epss_score": 0.00832, "epss_percentile": 0.74068}, "CVE-2006-6676": {"epss_score": 0.07898, "epss_percentile": 0.91752}, "CVE-2006-6677": {"epss_score": 0.0106, "epss_percentile": 0.77163}, "CVE-2006-6678": {"epss_score": 0.00627, "epss_percentile": 0.69636}, "CVE-2006-6679": {"epss_score": 0.01612, "epss_percentile": 0.81336}, "CVE-2006-6680": {"epss_score": 0.00044, "epss_percentile": 0.13646}, "CVE-2006-6681": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2006-6682": {"epss_score": 0.00849, "epss_percentile": 0.74373}, "CVE-2006-6683": {"epss_score": 0.0018, "epss_percentile": 0.39894}, "CVE-2006-6684": {"epss_score": 0.0192, "epss_percentile": 0.82896}, "CVE-2006-6685": {"epss_score": 0.00051, "epss_percentile": 0.16128}, "CVE-2006-6686": {"epss_score": 0.05788, "epss_percentile": 0.9021}, "CVE-2006-6687": {"epss_score": 0.00288, "epss_percentile": 0.51912}, "CVE-2006-6688": {"epss_score": 0.00299, "epss_percentile": 0.52888}, "CVE-2006-6689": {"epss_score": 0.00759, "epss_percentile": 0.72784}, "CVE-2006-6690": {"epss_score": 0.17105, "epss_percentile": 0.94776}, "CVE-2006-6691": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2006-6692": {"epss_score": 0.05993, "epss_percentile": 0.90389}, "CVE-2006-6693": {"epss_score": 0.00988, "epss_percentile": 0.76349}, "CVE-2006-6694": {"epss_score": 0.06544, "epss_percentile": 0.90838}, "CVE-2006-6695": {"epss_score": 0.00834, "epss_percentile": 0.74104}, "CVE-2006-6696": {"epss_score": 0.0432, "epss_percentile": 0.88542}, "CVE-2006-6697": {"epss_score": 0.34319, "epss_percentile": 0.96841}, "CVE-2006-6698": {"epss_score": 0.00155, "epss_percentile": 0.36831}, "CVE-2006-6699": {"epss_score": 0.0032, "epss_percentile": 0.54637}, "CVE-2006-6700": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2006-6701": {"epss_score": 0.00905, "epss_percentile": 0.75239}, "CVE-2006-6702": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2006-6703": {"epss_score": 0.13774, "epss_percentile": 0.94056}, "CVE-2006-6704": {"epss_score": 0.00834, "epss_percentile": 0.74104}, "CVE-2006-6705": {"epss_score": 0.00413, "epss_percentile": 0.60967}, "CVE-2006-6706": {"epss_score": 0.00552, "epss_percentile": 0.67402}, "CVE-2006-6707": {"epss_score": 0.74943, "epss_percentile": 0.98826}, "CVE-2006-6708": {"epss_score": 0.00797, "epss_percentile": 0.73503}, "CVE-2006-6709": {"epss_score": 0.00603, "epss_percentile": 0.68904}, "CVE-2006-6710": {"epss_score": 0.02826, "epss_percentile": 0.85757}, "CVE-2006-6711": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-6712": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2006-6713": {"epss_score": 0.07617, "epss_percentile": 0.91571}, "CVE-2006-6714": {"epss_score": 0.00905, "epss_percentile": 0.7524}, "CVE-2006-6715": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2006-6716": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2006-6717": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2006-6718": {"epss_score": 0.00612, "epss_percentile": 0.69223}, "CVE-2006-6719": {"epss_score": 0.04835, "epss_percentile": 0.89193}, "CVE-2006-6720": {"epss_score": 0.0854, "epss_percentile": 0.92112}, "CVE-2006-6721": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2006-6722": {"epss_score": 0.04717, "epss_percentile": 0.89044}, "CVE-2006-6723": {"epss_score": 0.52658, "epss_percentile": 0.97834}, "CVE-2006-6724": {"epss_score": 0.05469, "epss_percentile": 0.89907}, "CVE-2006-6725": {"epss_score": 0.00102, "epss_percentile": 0.28752}, "CVE-2006-6726": {"epss_score": 0.0207, "epss_percentile": 0.83471}, "CVE-2006-6727": {"epss_score": 0.00651, "epss_percentile": 0.70304}, "CVE-2006-6728": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2006-6729": {"epss_score": 0.01024, "epss_percentile": 0.76782}, "CVE-2006-6730": {"epss_score": 0.00048, "epss_percentile": 0.15282}, "CVE-2006-6731": {"epss_score": 0.06071, "epss_percentile": 0.90453}, "CVE-2006-6732": {"epss_score": 0.05291, "epss_percentile": 0.89697}, "CVE-2006-6733": {"epss_score": 0.0034, "epss_percentile": 0.56236}, "CVE-2006-6734": {"epss_score": 0.00528, "epss_percentile": 0.66544}, "CVE-2006-6735": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2006-6736": {"epss_score": 0.01415, "epss_percentile": 0.80139}, "CVE-2006-6737": {"epss_score": 0.01415, "epss_percentile": 0.80139}, "CVE-2006-6738": {"epss_score": 0.02826, "epss_percentile": 0.85757}, "CVE-2006-6739": {"epss_score": 0.02018, "epss_percentile": 0.83288}, "CVE-2006-6740": {"epss_score": 0.11404, "epss_percentile": 0.93336}, "CVE-2006-6741": {"epss_score": 0.00279, "epss_percentile": 0.50975}, "CVE-2006-6742": {"epss_score": 0.01902, "epss_percentile": 0.82783}, "CVE-2006-6743": {"epss_score": 0.00052, "epss_percentile": 0.16561}, "CVE-2006-6744": {"epss_score": 0.00101, "epss_percentile": 0.28579}, "CVE-2006-6745": {"epss_score": 0.1982, "epss_percentile": 0.95246}, "CVE-2006-6746": {"epss_score": 0.05061, "epss_percentile": 0.89452}, "CVE-2006-6747": {"epss_score": 0.01039, "epss_percentile": 0.76943}, "CVE-2006-6748": {"epss_score": 0.00651, "epss_percentile": 0.70304}, "CVE-2006-6749": {"epss_score": 0.00916, "epss_percentile": 0.75417}, "CVE-2006-6750": {"epss_score": 0.03387, "epss_percentile": 0.87042}, "CVE-2006-6751": {"epss_score": 0.05623, "epss_percentile": 0.90062}, "CVE-2006-6752": {"epss_score": 0.03003, "epss_percentile": 0.86178}, "CVE-2006-6753": {"epss_score": 0.00629, "epss_percentile": 0.69685}, "CVE-2006-6754": {"epss_score": 0.00725, "epss_percentile": 0.72046}, "CVE-2006-6755": {"epss_score": 0.06381, "epss_percentile": 0.90712}, "CVE-2006-6756": {"epss_score": 0.07701, "epss_percentile": 0.91634}, "CVE-2006-6757": {"epss_score": 0.06088, "epss_percentile": 0.90471}, "CVE-2006-6758": {"epss_score": 0.06088, "epss_percentile": 0.90471}, "CVE-2006-6759": {"epss_score": 0.05489, "epss_percentile": 0.89929}, "CVE-2006-6760": {"epss_score": 0.07304, "epss_percentile": 0.91394}, "CVE-2006-6761": {"epss_score": 0.5672, "epss_percentile": 0.98034}, "CVE-2006-6762": {"epss_score": 0.01151, "epss_percentile": 0.78038}, "CVE-2006-6763": {"epss_score": 0.01347, "epss_percentile": 0.7965}, "CVE-2006-6764": {"epss_score": 0.06689, "epss_percentile": 0.90949}, "CVE-2006-6765": {"epss_score": 0.06689, "epss_percentile": 0.90949}, "CVE-2006-6766": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2006-6767": {"epss_score": 0.0917, "epss_percentile": 0.9243}, "CVE-2006-6768": {"epss_score": 0.00811, "epss_percentile": 0.73734}, "CVE-2006-6769": {"epss_score": 0.01255, "epss_percentile": 0.78925}, "CVE-2006-6770": {"epss_score": 0.05558, "epss_percentile": 0.89992}, "CVE-2006-6771": {"epss_score": 0.03699, "epss_percentile": 0.87587}, "CVE-2006-6772": {"epss_score": 0.13757, "epss_percentile": 0.9405}, "CVE-2006-6773": {"epss_score": 0.04788, "epss_percentile": 0.89147}, "CVE-2006-6774": {"epss_score": 0.05062, "epss_percentile": 0.89454}, "CVE-2006-6775": {"epss_score": 0.05469, "epss_percentile": 0.89907}, "CVE-2006-6776": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2006-6777": {"epss_score": 0.00544, "epss_percentile": 0.67145}, "CVE-2006-6778": {"epss_score": 0.05656, "epss_percentile": 0.90091}, "CVE-2006-6779": {"epss_score": 0.01, "epss_percentile": 0.76488}, "CVE-2006-6780": {"epss_score": 0.01294, "epss_percentile": 0.79247}, "CVE-2006-6781": {"epss_score": 0.07173, "epss_percentile": 0.91299}, "CVE-2006-6782": {"epss_score": 0.01194, "epss_percentile": 0.78421}, "CVE-2006-6783": {"epss_score": 0.00941, "epss_percentile": 0.75755}, "CVE-2006-6784": {"epss_score": 0.00468, "epss_percentile": 0.63894}, "CVE-2006-6785": {"epss_score": 0.26385, "epss_percentile": 0.96143}, "CVE-2006-6786": {"epss_score": 0.04746, "epss_percentile": 0.89096}, "CVE-2006-6787": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2006-6788": {"epss_score": 0.01503, "epss_percentile": 0.80734}, "CVE-2006-6789": {"epss_score": 0.02817, "epss_percentile": 0.85737}, "CVE-2006-6790": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2006-6791": {"epss_score": 0.00666, "epss_percentile": 0.70684}, "CVE-2006-6792": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2006-6793": {"epss_score": 0.01503, "epss_percentile": 0.80734}, "CVE-2006-6794": {"epss_score": 0.00855, "epss_percentile": 0.74464}, "CVE-2006-6795": {"epss_score": 0.04021, "epss_percentile": 0.88132}, "CVE-2006-6796": {"epss_score": 0.06689, "epss_percentile": 0.90949}, "CVE-2006-6797": {"epss_score": 0.01286, "epss_percentile": 0.79184}, "CVE-2006-6799": {"epss_score": 0.03013, "epss_percentile": 0.86204}, "CVE-2006-6800": {"epss_score": 0.16166, "epss_percentile": 0.94586}, "CVE-2006-6801": {"epss_score": 0.05062, "epss_percentile": 0.89454}, "CVE-2006-6802": {"epss_score": 0.00588, "epss_percentile": 0.6849}, "CVE-2006-6803": {"epss_score": 0.00714, "epss_percentile": 0.71813}, "CVE-2006-6804": {"epss_score": 0.00414, "epss_percentile": 0.61099}, "CVE-2006-6805": {"epss_score": 0.00793, "epss_percentile": 0.73435}, "CVE-2006-6806": {"epss_score": 0.00793, "epss_percentile": 0.73435}, "CVE-2006-6807": {"epss_score": 0.00933, "epss_percentile": 0.75644}, "CVE-2006-6808": {"epss_score": 0.03483, "epss_percentile": 0.87223}, "CVE-2006-6809": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-6810": {"epss_score": 0.13989, "epss_percentile": 0.9411}, "CVE-2006-6811": {"epss_score": 0.05621, "epss_percentile": 0.90061}, "CVE-2006-6812": {"epss_score": 0.05609, "epss_percentile": 0.90045}, "CVE-2006-6813": {"epss_score": 0.01178, "epss_percentile": 0.78283}, "CVE-2006-6814": {"epss_score": 0.00645, "epss_percentile": 0.701}, "CVE-2006-6815": {"epss_score": 0.00801, "epss_percentile": 0.73579}, "CVE-2006-6816": {"epss_score": 0.02589, "epss_percentile": 0.85175}, "CVE-2006-6817": {"epss_score": 0.00295, "epss_percentile": 0.52441}, "CVE-2006-6818": {"epss_score": 0.00504, "epss_percentile": 0.6555}, "CVE-2006-6819": {"epss_score": 0.01316, "epss_percentile": 0.7941}, "CVE-2006-6820": {"epss_score": 0.05041, "epss_percentile": 0.89428}, "CVE-2006-6821": {"epss_score": 0.05041, "epss_percentile": 0.89428}, "CVE-2006-6822": {"epss_score": 0.04348, "epss_percentile": 0.88581}, "CVE-2006-6823": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-6824": {"epss_score": 0.01851, "epss_percentile": 0.82537}, "CVE-2006-6825": {"epss_score": 0.00722, "epss_percentile": 0.71998}, "CVE-2006-6826": {"epss_score": 0.00445, "epss_percentile": 0.62857}, "CVE-2006-6827": {"epss_score": 0.21592, "epss_percentile": 0.95537}, "CVE-2006-6828": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2006-6829": {"epss_score": 0.00444, "epss_percentile": 0.62812}, "CVE-2006-6830": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-6831": {"epss_score": 0.00594, "epss_percentile": 0.68658}, "CVE-2006-6832": {"epss_score": 0.00048, "epss_percentile": 0.15243}, "CVE-2006-6833": {"epss_score": 0.00025, "epss_percentile": 0.06059}, "CVE-2006-6834": {"epss_score": 0.00028, "epss_percentile": 0.07295}, "CVE-2006-6835": {"epss_score": 0.00468, "epss_percentile": 0.63894}, "CVE-2006-6836": {"epss_score": 0.00563, "epss_percentile": 0.67721}, "CVE-2006-6837": {"epss_score": 0.10978, "epss_percentile": 0.93182}, "CVE-2006-6838": {"epss_score": 0.03383, "epss_percentile": 0.87034}, "CVE-2006-6839": {"epss_score": 0.00431, "epss_percentile": 0.62063}, "CVE-2006-6840": {"epss_score": 0.00431, "epss_percentile": 0.62063}, "CVE-2006-6841": {"epss_score": 0.00431, "epss_percentile": 0.62063}, "CVE-2006-6842": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2006-6843": {"epss_score": 0.00367, "epss_percentile": 0.58113}, "CVE-2006-6844": {"epss_score": 0.01255, "epss_percentile": 0.78925}, "CVE-2006-6845": {"epss_score": 0.00565, "epss_percentile": 0.67789}, "CVE-2006-6846": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2006-6847": {"epss_score": 0.05098, "epss_percentile": 0.89496}, "CVE-2006-6848": {"epss_score": 0.00716, "epss_percentile": 0.71863}, "CVE-2006-6849": {"epss_score": 0.08523, "epss_percentile": 0.92101}, "CVE-2006-6850": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2006-6851": {"epss_score": 0.00458, "epss_percentile": 0.63449}, "CVE-2006-6852": {"epss_score": 0.00863, "epss_percentile": 0.7459}, "CVE-2006-6853": {"epss_score": 0.38661, "epss_percentile": 0.97113}, "CVE-2006-6854": {"epss_score": 0.00742, "epss_percentile": 0.72458}, "CVE-2006-6855": {"epss_score": 0.1143, "epss_percentile": 0.93348}, "CVE-2006-6856": {"epss_score": 0.0721, "epss_percentile": 0.91328}, "CVE-2006-6857": {"epss_score": 0.00286, "epss_percentile": 0.51715}, "CVE-2006-6858": {"epss_score": 0.00797, "epss_percentile": 0.73502}, "CVE-2006-6859": {"epss_score": 0.01696, "epss_percentile": 0.81809}, "CVE-2006-6860": {"epss_score": 0.13661, "epss_percentile": 0.94029}, "CVE-2006-6861": {"epss_score": 0.008, "epss_percentile": 0.73542}, "CVE-2006-6862": {"epss_score": 0.00848, "epss_percentile": 0.74358}, "CVE-2006-6863": {"epss_score": 0.05559, "epss_percentile": 0.89992}, "CVE-2006-6864": {"epss_score": 0.06756, "epss_percentile": 0.91006}, "CVE-2006-6865": {"epss_score": 0.08867, "epss_percentile": 0.92293}, "CVE-2006-6866": {"epss_score": 0.08396, "epss_percentile": 0.9203}, "CVE-2006-6867": {"epss_score": 0.15282, "epss_percentile": 0.944}, "CVE-2006-6868": {"epss_score": 0.01194, "epss_percentile": 0.78421}, "CVE-2006-6869": {"epss_score": 0.07206, "epss_percentile": 0.91323}, "CVE-2006-6870": {"epss_score": 0.04632, "epss_percentile": 0.88945}, "CVE-2006-6871": {"epss_score": 0.06933, "epss_percentile": 0.91124}, "CVE-2006-6872": {"epss_score": 0.08652, "epss_percentile": 0.92172}, "CVE-2006-6873": {"epss_score": 0.01239, "epss_percentile": 0.78798}, "CVE-2006-6874": {"epss_score": 0.00834, "epss_percentile": 0.74104}, "CVE-2006-6875": {"epss_score": 0.03422, "epss_percentile": 0.87106}, "CVE-2006-6876": {"epss_score": 0.00956, "epss_percentile": 0.75926}, "CVE-2006-6877": {"epss_score": 0.0721, "epss_percentile": 0.91328}, "CVE-2006-6878": {"epss_score": 0.0721, "epss_percentile": 0.91328}, "CVE-2006-6879": {"epss_score": 0.07013, "epss_percentile": 0.91186}, "CVE-2006-6880": {"epss_score": 0.00442, "epss_percentile": 0.62754}, "CVE-2006-6881": {"epss_score": 0.00838, "epss_percentile": 0.74181}, "CVE-2006-6882": {"epss_score": 0.00325, "epss_percentile": 0.55016}, "CVE-2006-6883": {"epss_score": 0.01036, "epss_percentile": 0.76917}, "CVE-2006-6884": {"epss_score": 0.10813, "epss_percentile": 0.9312}, "CVE-2006-6885": {"epss_score": 0.21592, "epss_percentile": 0.95537}, "CVE-2006-6886": {"epss_score": 0.00622, "epss_percentile": 0.69497}, "CVE-2006-6887": {"epss_score": 0.02972, "epss_percentile": 0.86099}, "CVE-2006-6888": {"epss_score": 0.05379, "epss_percentile": 0.89808}, "CVE-2006-6889": {"epss_score": 0.05518, "epss_percentile": 0.89953}, "CVE-2006-6890": {"epss_score": 0.05518, "epss_percentile": 0.89953}, "CVE-2006-6891": {"epss_score": 0.05379, "epss_percentile": 0.89808}, "CVE-2006-6892": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2006-6893": {"epss_score": 0.00376, "epss_percentile": 0.58681}, "CVE-2006-6894": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2006-6895": {"epss_score": 0.00205, "epss_percentile": 0.4273}, "CVE-2006-6896": {"epss_score": 0.00379, "epss_percentile": 0.58844}, "CVE-2006-6897": {"epss_score": 0.00252, "epss_percentile": 0.48338}, "CVE-2006-6898": {"epss_score": 0.00472, "epss_percentile": 0.64058}, "CVE-2006-6899": {"epss_score": 0.09953, "epss_percentile": 0.92788}, "CVE-2006-6900": {"epss_score": 0.00381, "epss_percentile": 0.5902}, "CVE-2006-6901": {"epss_score": 0.30583, "epss_percentile": 0.96553}, "CVE-2006-6902": {"epss_score": 0.30583, "epss_percentile": 0.96553}, "CVE-2006-6903": {"epss_score": 0.00898, "epss_percentile": 0.75143}, "CVE-2006-6904": {"epss_score": 0.00483, "epss_percentile": 0.64618}, "CVE-2006-6905": {"epss_score": 0.01046, "epss_percentile": 0.77024}, "CVE-2006-6906": {"epss_score": 0.00058, "epss_percentile": 0.18581}, "CVE-2006-6907": {"epss_score": 0.00381, "epss_percentile": 0.5902}, "CVE-2006-6908": {"epss_score": 0.35624, "epss_percentile": 0.96923}, "CVE-2006-6909": {"epss_score": 0.05983, "epss_percentile": 0.9038}, "CVE-2006-6910": {"epss_score": 0.06637, "epss_percentile": 0.90908}, "CVE-2006-6911": {"epss_score": 0.00651, "epss_percentile": 0.70293}, "CVE-2006-6912": {"epss_score": 0.00399, "epss_percentile": 0.60094}, "CVE-2006-6913": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2006-6914": {"epss_score": 0.00516, "epss_percentile": 0.66036}, "CVE-2006-6915": {"epss_score": 0.00873, "epss_percentile": 0.7475}, "CVE-2006-6916": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2006-6917": {"epss_score": 0.51239, "epss_percentile": 0.97771}, "CVE-2006-6918": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2006-6919": {"epss_score": 0.04788, "epss_percentile": 0.89147}, "CVE-2006-6920": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2006-6921": {"epss_score": 0.0006, "epss_percentile": 0.19084}, "CVE-2006-6922": {"epss_score": 0.00484, "epss_percentile": 0.64627}, "CVE-2006-6923": {"epss_score": 0.00528, "epss_percentile": 0.6657}, "CVE-2006-6924": {"epss_score": 0.06542, "epss_percentile": 0.90836}, "CVE-2006-6925": {"epss_score": 0.08938, "epss_percentile": 0.92327}, "CVE-2006-6926": {"epss_score": 0.00443, "epss_percentile": 0.62774}, "CVE-2006-6927": {"epss_score": 0.02057, "epss_percentile": 0.83426}, "CVE-2006-6928": {"epss_score": 0.05484, "epss_percentile": 0.89922}, "CVE-2006-6929": {"epss_score": 0.0586, "epss_percentile": 0.9027}, "CVE-2006-6930": {"epss_score": 0.01512, "epss_percentile": 0.80785}, "CVE-2006-6931": {"epss_score": 0.03649, "epss_percentile": 0.87506}, "CVE-2006-6932": {"epss_score": 0.0071, "epss_percentile": 0.71701}, "CVE-2006-6933": {"epss_score": 0.00331, "epss_percentile": 0.55538}, "CVE-2006-6934": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2006-6935": {"epss_score": 0.00596, "epss_percentile": 0.68705}, "CVE-2006-6936": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2006-6937": {"epss_score": 0.00803, "epss_percentile": 0.73596}, "CVE-2006-6938": {"epss_score": 0.06088, "epss_percentile": 0.90471}, "CVE-2006-6939": {"epss_score": 0.00073, "epss_percentile": 0.22658}, "CVE-2006-6940": {"epss_score": 0.0532, "epss_percentile": 0.89727}, "CVE-2006-6941": {"epss_score": 0.05379, "epss_percentile": 0.89808}, "CVE-2006-6942": {"epss_score": 0.02243, "epss_percentile": 0.8412}, "CVE-2006-6943": {"epss_score": 0.1154, "epss_percentile": 0.93399}, "CVE-2006-6944": {"epss_score": 0.00349, "epss_percentile": 0.5687}, "CVE-2006-6945": {"epss_score": 0.00785, "epss_percentile": 0.73264}, "CVE-2006-6946": {"epss_score": 0.00722, "epss_percentile": 0.71998}, "CVE-2006-6947": {"epss_score": 0.00654, "epss_percentile": 0.70347}, "CVE-2006-6948": {"epss_score": 0.00654, "epss_percentile": 0.70347}, "CVE-2006-6949": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2006-6950": {"epss_score": 0.01687, "epss_percentile": 0.81756}, "CVE-2006-6951": {"epss_score": 0.03279, "epss_percentile": 0.8681}, "CVE-2006-6952": {"epss_score": 0.00285, "epss_percentile": 0.51528}, "CVE-2006-6953": {"epss_score": 0.0007, "epss_percentile": 0.21778}, "CVE-2006-6954": {"epss_score": 0.0076, "epss_percentile": 0.72808}, "CVE-2006-6955": {"epss_score": 0.00652, "epss_percentile": 0.70316}, "CVE-2006-6956": {"epss_score": 0.14407, "epss_percentile": 0.94206}, "CVE-2006-6957": {"epss_score": 0.00863, "epss_percentile": 0.7459}, "CVE-2006-6958": {"epss_score": 0.05914, "epss_percentile": 0.90317}, "CVE-2006-6959": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2006-6960": {"epss_score": 0.00349, "epss_percentile": 0.5687}, "CVE-2006-6961": {"epss_score": 0.00349, "epss_percentile": 0.5687}, "CVE-2006-6962": {"epss_score": 0.0101, "epss_percentile": 0.76594}, "CVE-2006-6963": {"epss_score": 0.01451, "epss_percentile": 0.80362}, "CVE-2006-6964": {"epss_score": 0.00151, "epss_percentile": 0.36258}, "CVE-2006-6965": {"epss_score": 0.00658, "epss_percentile": 0.70498}, "CVE-2006-6966": {"epss_score": 0.04002, "epss_percentile": 0.88094}, "CVE-2006-6968": {"epss_score": 0.00323, "epss_percentile": 0.54874}, "CVE-2006-6969": {"epss_score": 0.00667, "epss_percentile": 0.70704}, "CVE-2006-6970": {"epss_score": 0.00276, "epss_percentile": 0.50767}, "CVE-2006-6971": {"epss_score": 0.00245, "epss_percentile": 0.47648}, "CVE-2006-6972": {"epss_score": 0.0093, "epss_percentile": 0.75601}, "CVE-2006-6973": {"epss_score": 0.0074, "epss_percentile": 0.72412}, "CVE-2006-6974": {"epss_score": 0.00734, "epss_percentile": 0.72245}, "CVE-2006-6975": {"epss_score": 0.05276, "epss_percentile": 0.89682}, "CVE-2006-6976": {"epss_score": 0.14568, "epss_percentile": 0.94243}, "CVE-2006-6977": {"epss_score": 0.00368, "epss_percentile": 0.58182}, "CVE-2006-6978": {"epss_score": 0.00368, "epss_percentile": 0.58182}, "CVE-2006-6979": {"epss_score": 0.0107, "epss_percentile": 0.77258}, "CVE-2006-6980": {"epss_score": 0.00543, "epss_percentile": 0.67099}, "CVE-2006-6981": {"epss_score": 0.01192, "epss_percentile": 0.78404}, "CVE-2006-6982": {"epss_score": 0.00373, "epss_percentile": 0.58494}, "CVE-2006-6983": {"epss_score": 0.00295, "epss_percentile": 0.52441}, "CVE-2006-6984": {"epss_score": 0.00295, "epss_percentile": 0.52441}, "CVE-2006-6985": {"epss_score": 0.00333, "epss_percentile": 0.55672}, "CVE-2006-6986": {"epss_score": 0.00502, "epss_percentile": 0.65399}, "CVE-2006-6987": {"epss_score": 0.00444, "epss_percentile": 0.62812}, "CVE-2006-6988": {"epss_score": 0.00444, "epss_percentile": 0.62812}, "CVE-2006-6989": {"epss_score": 0.00502, "epss_percentile": 0.65399}, "CVE-2006-6990": {"epss_score": 0.00444, "epss_percentile": 0.62812}, "CVE-2006-6991": {"epss_score": 0.00444, "epss_percentile": 0.62812}, "CVE-2006-6992": {"epss_score": 0.00444, "epss_percentile": 0.62812}, "CVE-2006-6993": {"epss_score": 0.0049, "epss_percentile": 0.64929}, "CVE-2006-6994": {"epss_score": 0.01251, "epss_percentile": 0.78898}, "CVE-2006-6995": {"epss_score": 0.02876, "epss_percentile": 0.85883}, "CVE-2006-6996": {"epss_score": 0.00286, "epss_percentile": 0.51715}, "CVE-2006-6997": {"epss_score": 0.0052, "epss_percentile": 0.66214}, "CVE-2006-6998": {"epss_score": 0.00333, "epss_percentile": 0.55672}, "CVE-2006-6999": {"epss_score": 0.00333, "epss_percentile": 0.55672}, "CVE-2006-7000": {"epss_score": 0.00333, "epss_percentile": 0.55672}, "CVE-2006-7001": {"epss_score": 0.00257, "epss_percentile": 0.48894}, "CVE-2006-7002": {"epss_score": 0.00286, "epss_percentile": 0.51715}, "CVE-2006-7003": {"epss_score": 0.00622, "epss_percentile": 0.69505}, "CVE-2006-7004": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2006-7005": {"epss_score": 0.00288, "epss_percentile": 0.51871}, "CVE-2006-7006": {"epss_score": 0.01451, "epss_percentile": 0.80362}, "CVE-2006-7007": {"epss_score": 0.06536, "epss_percentile": 0.90829}, "CVE-2006-7008": {"epss_score": 0.00017, "epss_percentile": 0.03208}, "CVE-2006-7009": {"epss_score": 0.00013, "epss_percentile": 0.01574}, "CVE-2006-7010": {"epss_score": 9e-05, "epss_percentile": 0.0063}, "CVE-2006-7011": {"epss_score": 0.01036, "epss_percentile": 0.76917}, "CVE-2006-7012": {"epss_score": 0.08221, "epss_percentile": 0.91936}, "CVE-2006-7013": {"epss_score": 0.01019, "epss_percentile": 0.76729}, "CVE-2006-7014": {"epss_score": 0.01451, "epss_percentile": 0.80362}, "CVE-2006-7015": {"epss_score": 0.11986, "epss_percentile": 0.93537}, "CVE-2006-7016": {"epss_score": 0.00562, "epss_percentile": 0.67708}, "CVE-2006-7017": {"epss_score": 0.03706, "epss_percentile": 0.87598}, "CVE-2006-7018": {"epss_score": 0.03765, "epss_percentile": 0.87695}, "CVE-2006-7019": {"epss_score": 0.01983, "epss_percentile": 0.83146}, "CVE-2006-7020": {"epss_score": 0.00388, "epss_percentile": 0.59346}, "CVE-2006-7021": {"epss_score": 0.04187, "epss_percentile": 0.88366}, "CVE-2006-7022": {"epss_score": 0.01886, "epss_percentile": 0.82714}, "CVE-2006-7023": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2006-7024": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2006-7025": {"epss_score": 0.00785, "epss_percentile": 0.73264}, "CVE-2006-7026": {"epss_score": 0.03466, "epss_percentile": 0.8719}, "CVE-2006-7027": {"epss_score": 0.39126, "epss_percentile": 0.97142}, "CVE-2006-7028": {"epss_score": 0.00966, "epss_percentile": 0.76054}, "CVE-2006-7029": {"epss_score": 0.30441, "epss_percentile": 0.96539}, "CVE-2006-7030": {"epss_score": 0.37109, "epss_percentile": 0.9702}, "CVE-2006-7031": {"epss_score": 0.24592, "epss_percentile": 0.95936}, "CVE-2006-7032": {"epss_score": 0.10867, "epss_percentile": 0.93139}, "CVE-2006-7033": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2006-7034": {"epss_score": 0.00541, "epss_percentile": 0.67046}, "CVE-2006-7035": {"epss_score": 0.00471, "epss_percentile": 0.64028}, "CVE-2006-7036": {"epss_score": 0.0355, "epss_percentile": 0.87338}, "CVE-2006-7037": {"epss_score": 0.00064, "epss_percentile": 0.2039}, "CVE-2006-7038": {"epss_score": 0.00962, "epss_percentile": 0.75987}, "CVE-2006-7039": {"epss_score": 0.01021, "epss_percentile": 0.7675}, "CVE-2006-7040": {"epss_score": 0.00882, "epss_percentile": 0.74892}, "CVE-2006-7041": {"epss_score": 0.00882, "epss_percentile": 0.74892}, "CVE-2006-7042": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2006-7043": {"epss_score": 0.00235, "epss_percentile": 0.46208}, "CVE-2006-7044": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2006-7045": {"epss_score": 0.00612, "epss_percentile": 0.69223}, "CVE-2006-7046": {"epss_score": 0.0079, "epss_percentile": 0.73376}, "CVE-2006-7047": {"epss_score": 0.01651, "epss_percentile": 0.81566}, "CVE-2006-7048": {"epss_score": 0.04022, "epss_percentile": 0.88135}, "CVE-2006-7049": {"epss_score": 0.00531, "epss_percentile": 0.66657}, "CVE-2006-7050": {"epss_score": 0.01333, "epss_percentile": 0.79529}, "CVE-2006-7051": {"epss_score": 0.00123, "epss_percentile": 0.32334}, "CVE-2006-7052": {"epss_score": 0.04057, "epss_percentile": 0.88187}, "CVE-2006-7053": {"epss_score": 0.00349, "epss_percentile": 0.5687}, "CVE-2006-7054": {"epss_score": 0.00882, "epss_percentile": 0.74892}, "CVE-2006-7055": {"epss_score": 0.19447, "epss_percentile": 0.95182}, "CVE-2006-7056": {"epss_score": 0.01333, "epss_percentile": 0.79529}, "CVE-2006-7057": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2006-7058": {"epss_score": 0.00323, "epss_percentile": 0.54874}, "CVE-2006-7059": {"epss_score": 0.00425, "epss_percentile": 0.61695}, "CVE-2006-7060": {"epss_score": 0.00376, "epss_percentile": 0.58681}, "CVE-2006-7061": {"epss_score": 0.00878, "epss_percentile": 0.74816}, "CVE-2006-7062": {"epss_score": 0.00405, "epss_percentile": 0.60478}, "CVE-2006-7063": {"epss_score": 0.06244, "epss_percentile": 0.906}, "CVE-2006-7064": {"epss_score": 0.00829, "epss_percentile": 0.74014}, "CVE-2006-7065": {"epss_score": 0.17998, "epss_percentile": 0.94941}, "CVE-2006-7066": {"epss_score": 0.3602, "epss_percentile": 0.9695}, "CVE-2006-7067": {"epss_score": 0.02555, "epss_percentile": 0.8509}, "CVE-2006-7068": {"epss_score": 0.0474, "epss_percentile": 0.89078}, "CVE-2006-7069": {"epss_score": 0.0648, "epss_percentile": 0.90786}, "CVE-2006-7070": {"epss_score": 0.14455, "epss_percentile": 0.94216}, "CVE-2006-7071": {"epss_score": 0.01775, "epss_percentile": 0.82215}, "CVE-2006-7072": {"epss_score": 0.11605, "epss_percentile": 0.93418}, "CVE-2006-7073": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2006-7074": {"epss_score": 0.00457, "epss_percentile": 0.6336}, "CVE-2006-7075": {"epss_score": 0.0156, "epss_percentile": 0.81039}, "CVE-2006-7076": {"epss_score": 0.00341, "epss_percentile": 0.56326}, "CVE-2006-7077": {"epss_score": 0.00723, "epss_percentile": 0.72023}, "CVE-2006-7078": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2006-7079": {"epss_score": 0.14938, "epss_percentile": 0.94328}, "CVE-2006-7080": {"epss_score": 0.03897, "epss_percentile": 0.87917}, "CVE-2006-7081": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2006-7082": {"epss_score": 0.00928, "epss_percentile": 0.75575}, "CVE-2006-7083": {"epss_score": 0.0057, "epss_percentile": 0.67945}, "CVE-2006-7085": {"epss_score": 0.0034, "epss_percentile": 0.56243}, "CVE-2006-7086": {"epss_score": 0.05445, "epss_percentile": 0.89886}, "CVE-2006-7087": {"epss_score": 0.01402, "epss_percentile": 0.80021}, "CVE-2006-7088": {"epss_score": 0.00468, "epss_percentile": 0.63894}, "CVE-2006-7089": {"epss_score": 0.00418, "epss_percentile": 0.61281}, "CVE-2006-7090": {"epss_score": 0.00884, "epss_percentile": 0.74931}, "CVE-2006-7091": {"epss_score": 0.01442, "epss_percentile": 0.80308}, "CVE-2006-7092": {"epss_score": 0.00484, "epss_percentile": 0.64627}, "CVE-2006-7093": {"epss_score": 0.00362, "epss_percentile": 0.57757}, "CVE-2006-7094": {"epss_score": 0.01517, "epss_percentile": 0.80805}, "CVE-2006-7095": {"epss_score": 0.02642, "epss_percentile": 0.85309}, "CVE-2006-7096": {"epss_score": 0.02642, "epss_percentile": 0.85309}, "CVE-2006-7097": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2006-7098": {"epss_score": 0.00131, "epss_percentile": 0.33492}, "CVE-2006-7099": {"epss_score": 0.03054, "epss_percentile": 0.86297}, "CVE-2006-7100": {"epss_score": 0.01758, "epss_percentile": 0.82137}, "CVE-2006-7101": {"epss_score": 0.00793, "epss_percentile": 0.73435}, "CVE-2006-7102": {"epss_score": 0.05357, "epss_percentile": 0.8978}, "CVE-2006-7103": {"epss_score": 0.01259, "epss_percentile": 0.78964}, "CVE-2006-7104": {"epss_score": 0.04414, "epss_percentile": 0.88664}, "CVE-2006-7105": {"epss_score": 0.01153, "epss_percentile": 0.78052}, "CVE-2006-7106": {"epss_score": 0.04035, "epss_percentile": 0.88156}, "CVE-2006-7107": {"epss_score": 0.06176, "epss_percentile": 0.90534}, "CVE-2006-7108": {"epss_score": 0.00081, "epss_percentile": 0.24312}, "CVE-2006-7109": {"epss_score": 0.00607, "epss_percentile": 0.6905}, "CVE-2006-7110": {"epss_score": 0.01501, "epss_percentile": 0.80715}, "CVE-2006-7111": {"epss_score": 0.0062, "epss_percentile": 0.69439}, "CVE-2006-7112": {"epss_score": 0.04038, "epss_percentile": 0.88161}, "CVE-2006-7113": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2006-7114": {"epss_score": 0.03779, "epss_percentile": 0.87717}, "CVE-2006-7115": {"epss_score": 0.00785, "epss_percentile": 0.73264}, "CVE-2006-7116": {"epss_score": 0.00555, "epss_percentile": 0.67476}, "CVE-2006-7117": {"epss_score": 0.04702, "epss_percentile": 0.89027}, "CVE-2006-7118": {"epss_score": 0.00602, "epss_percentile": 0.68875}, "CVE-2006-7119": {"epss_score": 0.04697, "epss_percentile": 0.8902}, "CVE-2006-7120": {"epss_score": 0.03261, "epss_percentile": 0.86771}, "CVE-2006-7121": {"epss_score": 0.02205, "epss_percentile": 0.84001}, "CVE-2006-7122": {"epss_score": 0.00044, "epss_percentile": 0.13641}, "CVE-2006-7123": {"epss_score": 0.00019, "epss_percentile": 0.0411}, "CVE-2006-7124": {"epss_score": 0.00144, "epss_percentile": 0.35261}, "CVE-2006-7125": {"epss_score": 0.00044, "epss_percentile": 0.13641}, "CVE-2006-7126": {"epss_score": 0.00034, "epss_percentile": 0.09804}, "CVE-2006-7127": {"epss_score": 0.08016, "epss_percentile": 0.91831}, "CVE-2006-7128": {"epss_score": 0.05783, "epss_percentile": 0.90203}, "CVE-2006-7129": {"epss_score": 0.00235, "epss_percentile": 0.4633}, "CVE-2006-7130": {"epss_score": 0.04426, "epss_percentile": 0.88674}, "CVE-2006-7131": {"epss_score": 0.04022, "epss_percentile": 0.88134}, "CVE-2006-7132": {"epss_score": 0.05405, "epss_percentile": 0.89837}, "CVE-2006-7133": {"epss_score": 0.03876, "epss_percentile": 0.87888}, "CVE-2006-7134": {"epss_score": 0.03231, "epss_percentile": 0.86696}, "CVE-2006-7135": {"epss_score": 0.01605, "epss_percentile": 0.81292}, "CVE-2006-7136": {"epss_score": 0.0257, "epss_percentile": 0.85126}, "CVE-2006-7137": {"epss_score": 0.00323, "epss_percentile": 0.54874}, "CVE-2006-7138": {"epss_score": 0.01354, "epss_percentile": 0.79701}, "CVE-2006-7139": {"epss_score": 0.08465, "epss_percentile": 0.92067}, "CVE-2006-7140": {"epss_score": 0.00541, "epss_percentile": 0.67025}, "CVE-2006-7141": {"epss_score": 0.04525, "epss_percentile": 0.88804}, "CVE-2006-7142": {"epss_score": 0.00124, "epss_percentile": 0.3234}, "CVE-2006-7143": {"epss_score": 0.0071, "epss_percentile": 0.71719}, "CVE-2006-7144": {"epss_score": 0.01289, "epss_percentile": 0.79211}, "CVE-2006-7145": {"epss_score": 0.00522, "epss_percentile": 0.66283}, "CVE-2006-7146": {"epss_score": 0.03772, "epss_percentile": 0.87704}, "CVE-2006-7147": {"epss_score": 0.0082, "epss_percentile": 0.73878}, "CVE-2006-7148": {"epss_score": 0.00474, "epss_percentile": 0.64166}, "CVE-2006-7149": {"epss_score": 0.00446, "epss_percentile": 0.62891}, "CVE-2006-7150": {"epss_score": 0.00606, "epss_percentile": 0.68998}, "CVE-2006-7151": {"epss_score": 0.0005, "epss_percentile": 0.1585}, "CVE-2006-7152": {"epss_score": 0.05267, "epss_percentile": 0.89674}, "CVE-2006-7153": {"epss_score": 0.03447, "epss_percentile": 0.8716}, "CVE-2006-7154": {"epss_score": 0.00574, "epss_percentile": 0.68078}, "CVE-2006-7155": {"epss_score": 0.01889, "epss_percentile": 0.82722}, "CVE-2006-7156": {"epss_score": 0.08339, "epss_percentile": 0.91998}, "CVE-2006-7157": {"epss_score": 0.07015, "epss_percentile": 0.91187}, "CVE-2006-7158": {"epss_score": 0.00661, "epss_percentile": 0.70578}, "CVE-2006-7159": {"epss_score": 0.00916, "epss_percentile": 0.75412}, "CVE-2006-7160": {"epss_score": 0.00064, "epss_percentile": 0.20304}, "CVE-2006-7161": {"epss_score": 0.02051, "epss_percentile": 0.83403}, "CVE-2006-7162": {"epss_score": 0.00042, "epss_percentile": 0.12767}, "CVE-2006-7163": {"epss_score": 0.00058, "epss_percentile": 0.18385}, "CVE-2006-7164": {"epss_score": 0.00234, "epss_percentile": 0.46096}, "CVE-2006-7165": {"epss_score": 0.004, "epss_percentile": 0.60193}, "CVE-2006-7166": {"epss_score": 0.004, "epss_percentile": 0.60193}, "CVE-2006-7167": {"epss_score": 0.03498, "epss_percentile": 0.8724}, "CVE-2006-7168": {"epss_score": 0.01389, "epss_percentile": 0.79928}, "CVE-2006-7169": {"epss_score": 0.06756, "epss_percentile": 0.91005}, "CVE-2006-7170": {"epss_score": 0.00593, "epss_percentile": 0.68641}, "CVE-2006-7171": {"epss_score": 0.00333, "epss_percentile": 0.55672}, "CVE-2006-7172": {"epss_score": 0.05159, "epss_percentile": 0.89555}, "CVE-2006-7173": {"epss_score": 0.08304, "epss_percentile": 0.9198}, "CVE-2006-7174": {"epss_score": 0.00898, "epss_percentile": 0.75143}, "CVE-2006-7175": {"epss_score": 0.00243, "epss_percentile": 0.47469}, "CVE-2006-7176": {"epss_score": 0.00729, "epss_percentile": 0.72121}, "CVE-2006-7177": {"epss_score": 0.03292, "epss_percentile": 0.86838}, "CVE-2006-7178": {"epss_score": 0.06329, "epss_percentile": 0.90673}, "CVE-2006-7179": {"epss_score": 0.07729, "epss_percentile": 0.91647}, "CVE-2006-7180": {"epss_score": 0.05624, "epss_percentile": 0.90063}, "CVE-2006-7181": {"epss_score": 0.01602, "epss_percentile": 0.81276}, "CVE-2006-7182": {"epss_score": 0.00916, "epss_percentile": 0.75418}, "CVE-2006-7183": {"epss_score": 0.04273, "epss_percentile": 0.88479}, "CVE-2006-7184": {"epss_score": 0.01265, "epss_percentile": 0.79007}, "CVE-2006-7185": {"epss_score": 0.05298, "epss_percentile": 0.89705}, "CVE-2006-7186": {"epss_score": 0.00389, "epss_percentile": 0.59463}, "CVE-2006-7187": {"epss_score": 0.00286, "epss_percentile": 0.51715}, "CVE-2006-7188": {"epss_score": 0.00295, "epss_percentile": 0.52441}, "CVE-2006-7189": {"epss_score": 0.00286, "epss_percentile": 0.51715}, "CVE-2006-7190": {"epss_score": 0.00286, "epss_percentile": 0.51715}, "CVE-2006-7191": {"epss_score": 0.00065, "epss_percentile": 0.20548}, "CVE-2006-7192": {"epss_score": 0.25103, "epss_percentile": 0.95986}, "CVE-2006-7193": {"epss_score": 0.01036, "epss_percentile": 0.76917}, "CVE-2006-7194": {"epss_score": 0.08045, "epss_percentile": 0.91849}, "CVE-2006-7195": {"epss_score": 0.10881, "epss_percentile": 0.93145}, "CVE-2006-7196": {"epss_score": 0.78528, "epss_percentile": 0.9899}, "CVE-2006-7197": {"epss_score": 0.02581, "epss_percentile": 0.85155}, "CVE-2006-7198": {"epss_score": 0.01139, "epss_percentile": 0.7794}, "CVE-2006-7199": {"epss_score": 0.0117, "epss_percentile": 0.78212}, "CVE-2006-7200": {"epss_score": 0.00187, "epss_percentile": 0.40767}, "CVE-2006-7201": {"epss_score": 0.01309, "epss_percentile": 0.79351}, "CVE-2006-7202": {"epss_score": 0.00405, "epss_percentile": 0.60478}, "CVE-2006-7203": {"epss_score": 0.00086, "epss_percentile": 0.25314}, "CVE-2006-7204": {"epss_score": 0.00213, "epss_percentile": 0.4389}, "CVE-2006-7205": {"epss_score": 0.00564, "epss_percentile": 0.67773}, "CVE-2006-7206": {"epss_score": 0.4854, "epss_percentile": 0.97642}, "CVE-2006-7207": {"epss_score": 0.01136, "epss_percentile": 0.7792}, "CVE-2006-7208": {"epss_score": 0.04195, "epss_percentile": 0.8838}, "CVE-2006-7209": {"epss_score": 0.00244, "epss_percentile": 0.47623}, "CVE-2006-7210": {"epss_score": 0.37014, "epss_percentile": 0.97014}, "CVE-2006-7211": {"epss_score": 0.00036, "epss_percentile": 0.10212}, "CVE-2006-7212": {"epss_score": 0.00399, "epss_percentile": 0.60131}, "CVE-2006-7213": {"epss_score": 0.00165, "epss_percentile": 0.38039}, "CVE-2006-7214": {"epss_score": 0.0066, "epss_percentile": 0.7052}, "CVE-2006-7215": {"epss_score": 0.0008, "epss_percentile": 0.24064}, "CVE-2006-7216": {"epss_score": 0.0134, "epss_percentile": 0.79581}, "CVE-2006-7217": {"epss_score": 0.00445, "epss_percentile": 0.62871}, "CVE-2006-7218": {"epss_score": 0.0016, "epss_percentile": 0.37454}, "CVE-2006-7219": {"epss_score": 0.0016, "epss_percentile": 0.37454}, "CVE-2006-7220": {"epss_score": 0.00537, "epss_percentile": 0.66904}, "CVE-2006-7221": {"epss_score": 0.004, "epss_percentile": 0.6015}, "CVE-2006-7222": {"epss_score": 0.04808, "epss_percentile": 0.89163}, "CVE-2006-7223": {"epss_score": 0.00418, "epss_percentile": 0.61293}, "CVE-2006-7225": {"epss_score": 0.01311, "epss_percentile": 0.79371}, "CVE-2006-7226": {"epss_score": 0.0174, "epss_percentile": 0.82043}, "CVE-2006-7227": {"epss_score": 0.02173, "epss_percentile": 0.83876}, "CVE-2006-7228": {"epss_score": 0.02881, "epss_percentile": 0.859}, "CVE-2006-7229": {"epss_score": 0.01082, "epss_percentile": 0.77379}, "CVE-2006-7230": {"epss_score": 0.02816, "epss_percentile": 0.85735}, "CVE-2006-7231": {"epss_score": 0.00371, "epss_percentile": 0.58359}, "CVE-2006-7232": {"epss_score": 0.01887, "epss_percentile": 0.82716}, "CVE-2006-7233": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2006-7234": {"epss_score": 0.0014, "epss_percentile": 0.34744}, "CVE-2006-7235": {"epss_score": 0.06265, "epss_percentile": 0.90623}, "CVE-2006-7236": {"epss_score": 0.07068, "epss_percentile": 0.91225}, "CVE-2006-7237": {"epss_score": 0.00562, "epss_percentile": 0.67686}, "CVE-2006-7238": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2006-7239": {"epss_score": 0.0027, "epss_percentile": 0.50216}, "CVE-2006-7240": {"epss_score": 0.00031, "epss_percentile": 0.08434}, "CVE-2006-7241": {"epss_score": 0.00092, "epss_percentile": 0.26428}, "CVE-2006-7242": {"epss_score": 0.00121, "epss_percentile": 0.31889}, "CVE-2006-7243": {"epss_score": 0.021, "epss_percentile": 0.836}, "CVE-2006-7244": {"epss_score": 0.0042, "epss_percentile": 0.61406}, "CVE-2006-7245": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2006-7246": {"epss_score": 0.00065, "epss_percentile": 0.20562}, "CVE-2006-7247": {"epss_score": 0.00011, "epss_percentile": 0.01}, "CVE-2006-7250": {"epss_score": 0.01407, "epss_percentile": 0.80056}, "CVE-2006-7252": {"epss_score": 0.00323, "epss_percentile": 0.54883}, "CVE-2006-7253": {"epss_score": 0.00433, "epss_percentile": 0.62183}, "CVE-2006-7254": {"epss_score": 0.00042, "epss_percentile": 0.12786}, "CVE-2007-0001": {"epss_score": 0.00206, "epss_percentile": 0.42932}, "CVE-2007-0002": {"epss_score": 0.09078, "epss_percentile": 0.9239}, "CVE-2007-0003": {"epss_score": 0.00071, "epss_percentile": 0.22238}, "CVE-2007-0004": {"epss_score": 0.00048, "epss_percentile": 0.15006}, "CVE-2007-0005": {"epss_score": 0.00321, "epss_percentile": 0.54737}, "CVE-2007-0006": {"epss_score": 0.00088, "epss_percentile": 0.25752}, "CVE-2007-0007": {"epss_score": 0.0006, "epss_percentile": 0.19163}, "CVE-2007-0008": {"epss_score": 0.17415, "epss_percentile": 0.94848}, "CVE-2007-0009": {"epss_score": 0.49542, "epss_percentile": 0.97694}, "CVE-2007-0010": {"epss_score": 0.0093, "epss_percentile": 0.756}, "CVE-2007-0011": {"epss_score": 0.01247, "epss_percentile": 0.78862}, "CVE-2007-0012": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2007-0014": {"epss_score": 0.00071, "epss_percentile": 0.22171}, "CVE-2007-0015": {"epss_score": 0.8455, "epss_percentile": 0.99294}, "CVE-2007-0016": {"epss_score": 0.25508, "epss_percentile": 0.96036}, "CVE-2007-0017": {"epss_score": 0.41899, "epss_percentile": 0.973}, "CVE-2007-0018": {"epss_score": 0.7493, "epss_percentile": 0.98825}, "CVE-2007-0019": {"epss_score": 0.06881, "epss_percentile": 0.9109}, "CVE-2007-0020": {"epss_score": 0.23911, "epss_percentile": 0.95833}, "CVE-2007-0021": {"epss_score": 0.42165, "epss_percentile": 0.97316}, "CVE-2007-0022": {"epss_score": 0.00147, "epss_percentile": 0.35646}, "CVE-2007-0023": {"epss_score": 0.00232, "epss_percentile": 0.45896}, "CVE-2007-0024": {"epss_score": 0.39692, "epss_percentile": 0.97175}, "CVE-2007-0025": {"epss_score": 0.65294, "epss_percentile": 0.98411}, "CVE-2007-0026": {"epss_score": 0.47956, "epss_percentile": 0.97611}, "CVE-2007-0027": {"epss_score": 0.58437, "epss_percentile": 0.98116}, "CVE-2007-0028": {"epss_score": 0.48683, "epss_percentile": 0.97648}, "CVE-2007-0029": {"epss_score": 0.55891, "epss_percentile": 0.98002}, "CVE-2007-0030": {"epss_score": 0.58991, "epss_percentile": 0.98144}, "CVE-2007-0031": {"epss_score": 0.75763, "epss_percentile": 0.98863}, "CVE-2007-0033": {"epss_score": 0.60312, "epss_percentile": 0.98203}, "CVE-2007-0034": {"epss_score": 0.6293, "epss_percentile": 0.98313}, "CVE-2007-0035": {"epss_score": 0.58991, "epss_percentile": 0.98144}, "CVE-2007-0038": {"epss_score": 0.87916, "epss_percentile": 0.99449}, "CVE-2007-0039": {"epss_score": 0.41946, "epss_percentile": 0.97302}, "CVE-2007-0040": {"epss_score": 0.60913, "epss_percentile": 0.98226}, "CVE-2007-0041": {"epss_score": 0.61823, "epss_percentile": 0.98263}, "CVE-2007-0042": {"epss_score": 0.81765, "epss_percentile": 0.99154}, "CVE-2007-0043": {"epss_score": 0.61823, "epss_percentile": 0.98263}, "CVE-2007-0044": {"epss_score": 0.51954, "epss_percentile": 0.97803}, "CVE-2007-0045": {"epss_score": 0.61361, "epss_percentile": 0.98244}, "CVE-2007-0046": {"epss_score": 0.64856, "epss_percentile": 0.98396}, "CVE-2007-0047": {"epss_score": 0.05394, "epss_percentile": 0.89826}, "CVE-2007-0048": {"epss_score": 0.48683, "epss_percentile": 0.97649}, "CVE-2007-0049": {"epss_score": 0.07551, "epss_percentile": 0.91537}, "CVE-2007-0050": {"epss_score": 0.01036, "epss_percentile": 0.76917}, "CVE-2007-0051": {"epss_score": 0.35448, "epss_percentile": 0.96911}, "CVE-2007-0052": {"epss_score": 0.01511, "epss_percentile": 0.8078}, "CVE-2007-0053": {"epss_score": 0.02065, "epss_percentile": 0.83456}, "CVE-2007-0054": {"epss_score": 0.00458, "epss_percentile": 0.63449}, "CVE-2007-0055": {"epss_score": 0.06187, "epss_percentile": 0.90544}, "CVE-2007-0056": {"epss_score": 0.00927, "epss_percentile": 0.75568}, "CVE-2007-0057": {"epss_score": 0.03123, "epss_percentile": 0.86453}, "CVE-2007-0058": {"epss_score": 0.01623, "epss_percentile": 0.81402}, "CVE-2007-0059": {"epss_score": 0.11866, "epss_percentile": 0.935}, "CVE-2007-0060": {"epss_score": 0.21172, "epss_percentile": 0.95472}, "CVE-2007-0061": {"epss_score": 0.16318, "epss_percentile": 0.94629}, "CVE-2007-0062": {"epss_score": 0.05402, "epss_percentile": 0.89833}, "CVE-2007-0063": {"epss_score": 0.0759, "epss_percentile": 0.91558}, "CVE-2007-0064": {"epss_score": 0.70075, "epss_percentile": 0.98613}, "CVE-2007-0065": {"epss_score": 0.67271, "epss_percentile": 0.985}, "CVE-2007-0066": {"epss_score": 0.27153, "epss_percentile": 0.96213}, "CVE-2007-0067": {"epss_score": 0.02845, "epss_percentile": 0.85819}, "CVE-2007-0068": {"epss_score": 0.01769, "epss_percentile": 0.82184}, "CVE-2007-0069": {"epss_score": 0.6721, "epss_percentile": 0.98498}, "CVE-2007-0071": {"epss_score": 0.89431, "epss_percentile": 0.99526}, "CVE-2007-0072": {"epss_score": 0.29461, "epss_percentile": 0.96445}, "CVE-2007-0073": {"epss_score": 0.29461, "epss_percentile": 0.96445}, "CVE-2007-0074": {"epss_score": 0.29461, "epss_percentile": 0.96445}, "CVE-2007-0075": {"epss_score": 0.01052, "epss_percentile": 0.77089}, "CVE-2007-0076": {"epss_score": 0.01052, "epss_percentile": 0.77089}, "CVE-2007-0077": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-0078": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-0079": {"epss_score": 0.00546, "epss_percentile": 0.67203}, "CVE-2007-0080": {"epss_score": 0.00154, "epss_percentile": 0.36725}, "CVE-2007-0081": {"epss_score": 0.00145, "epss_percentile": 0.35431}, "CVE-2007-0082": {"epss_score": 0.06221, "epss_percentile": 0.90581}, "CVE-2007-0083": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2007-0084": {"epss_score": 0.01511, "epss_percentile": 0.80778}, "CVE-2007-0085": {"epss_score": 0.00216, "epss_percentile": 0.44138}, "CVE-2007-0086": {"epss_score": 0.0318, "epss_percentile": 0.86577}, "CVE-2007-0087": {"epss_score": 0.42162, "epss_percentile": 0.97315}, "CVE-2007-0088": {"epss_score": 0.00272, "epss_percentile": 0.50388}, "CVE-2007-0089": {"epss_score": 0.00855, "epss_percentile": 0.74463}, "CVE-2007-0090": {"epss_score": 0.01052, "epss_percentile": 0.77089}, "CVE-2007-0091": {"epss_score": 0.06244, "epss_percentile": 0.906}, "CVE-2007-0092": {"epss_score": 0.00807, "epss_percentile": 0.73676}, "CVE-2007-0093": {"epss_score": 0.01895, "epss_percentile": 0.82746}, "CVE-2007-0094": {"epss_score": 0.01052, "epss_percentile": 0.77089}, "CVE-2007-0095": {"epss_score": 0.00575, "epss_percentile": 0.68119}, "CVE-2007-0096": {"epss_score": 0.00855, "epss_percentile": 0.74463}, "CVE-2007-0097": {"epss_score": 0.01672, "epss_percentile": 0.81681}, "CVE-2007-0098": {"epss_score": 0.06244, "epss_percentile": 0.906}, "CVE-2007-0099": {"epss_score": 0.56538, "epss_percentile": 0.98026}, "CVE-2007-0100": {"epss_score": 0.00916, "epss_percentile": 0.75418}, "CVE-2007-0101": {"epss_score": 0.01013, "epss_percentile": 0.76631}, "CVE-2007-0102": {"epss_score": 0.06664, "epss_percentile": 0.90925}, "CVE-2007-0103": {"epss_score": 0.30541, "epss_percentile": 0.96549}, "CVE-2007-0104": {"epss_score": 0.19012, "epss_percentile": 0.95111}, "CVE-2007-0105": {"epss_score": 0.01884, "epss_percentile": 0.82703}, "CVE-2007-0106": {"epss_score": 0.01754, "epss_percentile": 0.82116}, "CVE-2007-0107": {"epss_score": 0.06857, "epss_percentile": 0.91079}, "CVE-2007-0108": {"epss_score": 0.02077, "epss_percentile": 0.83515}, "CVE-2007-0109": {"epss_score": 0.01335, "epss_percentile": 0.79551}, "CVE-2007-0110": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2007-0111": {"epss_score": 0.0552, "epss_percentile": 0.89956}, "CVE-2007-0112": {"epss_score": 0.00775, "epss_percentile": 0.73077}, "CVE-2007-0113": {"epss_score": 0.13311, "epss_percentile": 0.93928}, "CVE-2007-0114": {"epss_score": 0.0077, "epss_percentile": 0.73006}, "CVE-2007-0115": {"epss_score": 0.00907, "epss_percentile": 0.75267}, "CVE-2007-0116": {"epss_score": 0.01035, "epss_percentile": 0.76897}, "CVE-2007-0117": {"epss_score": 0.07912, "epss_percentile": 0.91759}, "CVE-2007-0118": {"epss_score": 0.14788, "epss_percentile": 0.94284}, "CVE-2007-0119": {"epss_score": 0.01942, "epss_percentile": 0.82984}, "CVE-2007-0120": {"epss_score": 0.0127, "epss_percentile": 0.79047}, "CVE-2007-0121": {"epss_score": 0.07101, "epss_percentile": 0.91252}, "CVE-2007-0122": {"epss_score": 0.01832, "epss_percentile": 0.82453}, "CVE-2007-0123": {"epss_score": 0.00338, "epss_percentile": 0.56128}, "CVE-2007-0124": {"epss_score": 0.01059, "epss_percentile": 0.77158}, "CVE-2007-0125": {"epss_score": 0.01602, "epss_percentile": 0.81272}, "CVE-2007-0126": {"epss_score": 0.15295, "epss_percentile": 0.94403}, "CVE-2007-0127": {"epss_score": 0.10076, "epss_percentile": 0.9284}, "CVE-2007-0128": {"epss_score": 0.00793, "epss_percentile": 0.73435}, "CVE-2007-0129": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-0130": {"epss_score": 0.01512, "epss_percentile": 0.80785}, "CVE-2007-0131": {"epss_score": 0.00664, "epss_percentile": 0.70644}, "CVE-2007-0132": {"epss_score": 0.02206, "epss_percentile": 0.84001}, "CVE-2007-0133": {"epss_score": 0.00334, "epss_percentile": 0.55699}, "CVE-2007-0134": {"epss_score": 0.14145, "epss_percentile": 0.94144}, "CVE-2007-0135": {"epss_score": 0.09515, "epss_percentile": 0.92581}, "CVE-2007-0136": {"epss_score": 0.0071, "epss_percentile": 0.71712}, "CVE-2007-0137": {"epss_score": 0.02428, "epss_percentile": 0.8472}, "CVE-2007-0138": {"epss_score": 0.04186, "epss_percentile": 0.88363}, "CVE-2007-0139": {"epss_score": 0.00988, "epss_percentile": 0.76357}, "CVE-2007-0140": {"epss_score": 0.01512, "epss_percentile": 0.80785}, "CVE-2007-0141": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0142": {"epss_score": 0.01512, "epss_percentile": 0.80785}, "CVE-2007-0143": {"epss_score": 0.11121, "epss_percentile": 0.93228}, "CVE-2007-0144": {"epss_score": 0.056, "epss_percentile": 0.90038}, "CVE-2007-0145": {"epss_score": 0.0069, "epss_percentile": 0.71256}, "CVE-2007-0146": {"epss_score": 0.02075, "epss_percentile": 0.83502}, "CVE-2007-0147": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-0148": {"epss_score": 0.31402, "epss_percentile": 0.96617}, "CVE-2007-0149": {"epss_score": 0.00841, "epss_percentile": 0.74221}, "CVE-2007-0150": {"epss_score": 0.01155, "epss_percentile": 0.78079}, "CVE-2007-0151": {"epss_score": 0.00815, "epss_percentile": 0.7378}, "CVE-2007-0152": {"epss_score": 0.00841, "epss_percentile": 0.74221}, "CVE-2007-0153": {"epss_score": 0.00841, "epss_percentile": 0.74221}, "CVE-2007-0154": {"epss_score": 0.00841, "epss_percentile": 0.74221}, "CVE-2007-0155": {"epss_score": 0.00841, "epss_percentile": 0.74221}, "CVE-2007-0156": {"epss_score": 0.00841, "epss_percentile": 0.74221}, "CVE-2007-0157": {"epss_score": 0.0292, "epss_percentile": 0.8599}, "CVE-2007-0158": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2007-0159": {"epss_score": 0.01609, "epss_percentile": 0.81319}, "CVE-2007-0160": {"epss_score": 0.06845, "epss_percentile": 0.91064}, "CVE-2007-0161": {"epss_score": 0.00158, "epss_percentile": 0.37205}, "CVE-2007-0162": {"epss_score": 0.00099, "epss_percentile": 0.28429}, "CVE-2007-0163": {"epss_score": 0.0231, "epss_percentile": 0.84336}, "CVE-2007-0164": {"epss_score": 0.0231, "epss_percentile": 0.84336}, "CVE-2007-0165": {"epss_score": 0.10475, "epss_percentile": 0.92999}, "CVE-2007-0166": {"epss_score": 0.00053, "epss_percentile": 0.16672}, "CVE-2007-0167": {"epss_score": 0.14931, "epss_percentile": 0.94327}, "CVE-2007-0168": {"epss_score": 0.61279, "epss_percentile": 0.98243}, "CVE-2007-0169": {"epss_score": 0.7782, "epss_percentile": 0.98956}, "CVE-2007-0170": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2007-0171": {"epss_score": 0.05579, "epss_percentile": 0.90015}, "CVE-2007-0172": {"epss_score": 0.16713, "epss_percentile": 0.94719}, "CVE-2007-0173": {"epss_score": 0.07551, "epss_percentile": 0.91537}, "CVE-2007-0174": {"epss_score": 0.06175, "epss_percentile": 0.90532}, "CVE-2007-0175": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-0176": {"epss_score": 0.03773, "epss_percentile": 0.87705}, "CVE-2007-0177": {"epss_score": 0.19871, "epss_percentile": 0.95253}, "CVE-2007-0178": {"epss_score": 0.03149, "epss_percentile": 0.86502}, "CVE-2007-0179": {"epss_score": 0.00354, "epss_percentile": 0.57216}, "CVE-2007-0180": {"epss_score": 0.01257, "epss_percentile": 0.78944}, "CVE-2007-0181": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-0182": {"epss_score": 0.04555, "epss_percentile": 0.88845}, "CVE-2007-0183": {"epss_score": 0.04497, "epss_percentile": 0.88762}, "CVE-2007-0184": {"epss_score": 0.00743, "epss_percentile": 0.72481}, "CVE-2007-0185": {"epss_score": 0.00787, "epss_percentile": 0.73319}, "CVE-2007-0186": {"epss_score": 0.03251, "epss_percentile": 0.86751}, "CVE-2007-0187": {"epss_score": 0.01212, "epss_percentile": 0.78561}, "CVE-2007-0188": {"epss_score": 0.00805, "epss_percentile": 0.73639}, "CVE-2007-0189": {"epss_score": 0.01043, "epss_percentile": 0.76994}, "CVE-2007-0190": {"epss_score": 0.03149, "epss_percentile": 0.86502}, "CVE-2007-0191": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2007-0192": {"epss_score": 0.0069, "epss_percentile": 0.71256}, "CVE-2007-0193": {"epss_score": 0.00833, "epss_percentile": 0.7409}, "CVE-2007-0194": {"epss_score": 0.00405, "epss_percentile": 0.60478}, "CVE-2007-0195": {"epss_score": 0.00703, "epss_percentile": 0.71539}, "CVE-2007-0196": {"epss_score": 0.01343, "epss_percentile": 0.796}, "CVE-2007-0197": {"epss_score": 0.55254, "epss_percentile": 0.97968}, "CVE-2007-0198": {"epss_score": 0.01224, "epss_percentile": 0.78676}, "CVE-2007-0199": {"epss_score": 0.01421, "epss_percentile": 0.80171}, "CVE-2007-0200": {"epss_score": 0.1218, "epss_percentile": 0.93596}, "CVE-2007-0201": {"epss_score": 0.06241, "epss_percentile": 0.90593}, "CVE-2007-0202": {"epss_score": 0.02358, "epss_percentile": 0.8449}, "CVE-2007-0203": {"epss_score": 0.00745, "epss_percentile": 0.72524}, "CVE-2007-0204": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0205": {"epss_score": 0.11509, "epss_percentile": 0.93388}, "CVE-2007-0206": {"epss_score": 0.00968, "epss_percentile": 0.76088}, "CVE-2007-0208": {"epss_score": 0.57997, "epss_percentile": 0.98094}, "CVE-2007-0209": {"epss_score": 0.54122, "epss_percentile": 0.97913}, "CVE-2007-0210": {"epss_score": 0.01944, "epss_percentile": 0.82997}, "CVE-2007-0211": {"epss_score": 0.02354, "epss_percentile": 0.84477}, "CVE-2007-0213": {"epss_score": 0.82313, "epss_percentile": 0.99186}, "CVE-2007-0214": {"epss_score": 0.5846, "epss_percentile": 0.98118}, "CVE-2007-0215": {"epss_score": 0.60504, "epss_percentile": 0.98209}, "CVE-2007-0216": {"epss_score": 0.71265, "epss_percentile": 0.98661}, "CVE-2007-0217": {"epss_score": 0.75423, "epss_percentile": 0.98844}, "CVE-2007-0218": {"epss_score": 0.51388, "epss_percentile": 0.97776}, "CVE-2007-0219": {"epss_score": 0.61656, "epss_percentile": 0.98257}, "CVE-2007-0220": {"epss_score": 0.43666, "epss_percentile": 0.97398}, "CVE-2007-0221": {"epss_score": 0.65014, "epss_percentile": 0.98401}, "CVE-2007-0222": {"epss_score": 0.01529, "epss_percentile": 0.80881}, "CVE-2007-0223": {"epss_score": 0.00764, "epss_percentile": 0.729}, "CVE-2007-0224": {"epss_score": 0.00793, "epss_percentile": 0.73435}, "CVE-2007-0225": {"epss_score": 0.056, "epss_percentile": 0.90038}, "CVE-2007-0226": {"epss_score": 0.01252, "epss_percentile": 0.7891}, "CVE-2007-0227": {"epss_score": 0.00449, "epss_percentile": 0.63036}, "CVE-2007-0228": {"epss_score": 0.06133, "epss_percentile": 0.90503}, "CVE-2007-0229": {"epss_score": 0.02985, "epss_percentile": 0.8613}, "CVE-2007-0230": {"epss_score": 0.01019, "epss_percentile": 0.76729}, "CVE-2007-0231": {"epss_score": 0.01194, "epss_percentile": 0.78421}, "CVE-2007-0232": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-0233": {"epss_score": 0.11179, "epss_percentile": 0.93254}, "CVE-2007-0235": {"epss_score": 0.00294, "epss_percentile": 0.52369}, "CVE-2007-0236": {"epss_score": 0.50941, "epss_percentile": 0.97756}, "CVE-2007-0237": {"epss_score": 0.00073, "epss_percentile": 0.22538}, "CVE-2007-0238": {"epss_score": 0.10123, "epss_percentile": 0.92859}, "CVE-2007-0239": {"epss_score": 0.09116, "epss_percentile": 0.92407}, "CVE-2007-0240": {"epss_score": 0.00791, "epss_percentile": 0.73387}, "CVE-2007-0242": {"epss_score": 0.01675, "epss_percentile": 0.81704}, "CVE-2007-0243": {"epss_score": 0.37763, "epss_percentile": 0.97067}, "CVE-2007-0244": {"epss_score": 0.03649, "epss_percentile": 0.87506}, "CVE-2007-0245": {"epss_score": 0.1201, "epss_percentile": 0.93546}, "CVE-2007-0246": {"epss_score": 0.00781, "epss_percentile": 0.7319}, "CVE-2007-0247": {"epss_score": 0.40081, "epss_percentile": 0.97194}, "CVE-2007-0248": {"epss_score": 0.46988, "epss_percentile": 0.97564}, "CVE-2007-0249": {"epss_score": 0.01409, "epss_percentile": 0.80075}, "CVE-2007-0250": {"epss_score": 0.00551, "epss_percentile": 0.67356}, "CVE-2007-0251": {"epss_score": 0.02834, "epss_percentile": 0.85782}, "CVE-2007-0252": {"epss_score": 0.00612, "epss_percentile": 0.69223}, "CVE-2007-0253": {"epss_score": 0.00155, "epss_percentile": 0.36783}, "CVE-2007-0254": {"epss_score": 0.02294, "epss_percentile": 0.8429}, "CVE-2007-0255": {"epss_score": 0.0249, "epss_percentile": 0.84895}, "CVE-2007-0256": {"epss_score": 0.20415, "epss_percentile": 0.9534}, "CVE-2007-0257": {"epss_score": 0.00263, "epss_percentile": 0.49507}, "CVE-2007-0258": {"epss_score": 0.02952, "epss_percentile": 0.86054}, "CVE-2007-0259": {"epss_score": 0.005, "epss_percentile": 0.65298}, "CVE-2007-0260": {"epss_score": 0.01061, "epss_percentile": 0.7717}, "CVE-2007-0261": {"epss_score": 0.0979, "epss_percentile": 0.92702}, "CVE-2007-0262": {"epss_score": 0.00928, "epss_percentile": 0.75582}, "CVE-2007-0263": {"epss_score": 0.00601, "epss_percentile": 0.68841}, "CVE-2007-0264": {"epss_score": 0.00143, "epss_percentile": 0.35101}, "CVE-2007-0265": {"epss_score": 0.02428, "epss_percentile": 0.8472}, "CVE-2007-0266": {"epss_score": 0.00927, "epss_percentile": 0.75558}, "CVE-2007-0267": {"epss_score": 0.00468, "epss_percentile": 0.63893}, "CVE-2007-0268": {"epss_score": 0.04993, "epss_percentile": 0.89369}, "CVE-2007-0269": {"epss_score": 0.00592, "epss_percentile": 0.68619}, "CVE-2007-0270": {"epss_score": 0.12872, "epss_percentile": 0.93808}, "CVE-2007-0271": {"epss_score": 0.06456, "epss_percentile": 0.90767}, "CVE-2007-0272": {"epss_score": 0.25275, "epss_percentile": 0.96007}, "CVE-2007-0273": {"epss_score": 0.00604, "epss_percentile": 0.6895}, "CVE-2007-0274": {"epss_score": 0.14234, "epss_percentile": 0.94168}, "CVE-2007-0275": {"epss_score": 0.00782, "epss_percentile": 0.73202}, "CVE-2007-0276": {"epss_score": 0.00255, "epss_percentile": 0.4869}, "CVE-2007-0277": {"epss_score": 0.00344, "epss_percentile": 0.56541}, "CVE-2007-0278": {"epss_score": 0.00256, "epss_percentile": 0.4884}, "CVE-2007-0279": {"epss_score": 0.02007, "epss_percentile": 0.8324}, "CVE-2007-0280": {"epss_score": 0.02178, "epss_percentile": 0.83891}, "CVE-2007-0281": {"epss_score": 0.00636, "epss_percentile": 0.69862}, "CVE-2007-0282": {"epss_score": 0.00309, "epss_percentile": 0.53659}, "CVE-2007-0283": {"epss_score": 0.00659, "epss_percentile": 0.70504}, "CVE-2007-0284": {"epss_score": 0.00636, "epss_percentile": 0.69862}, "CVE-2007-0285": {"epss_score": 0.00659, "epss_percentile": 0.70504}, "CVE-2007-0286": {"epss_score": 0.00659, "epss_percentile": 0.70504}, "CVE-2007-0287": {"epss_score": 0.00344, "epss_percentile": 0.56535}, "CVE-2007-0288": {"epss_score": 0.00344, "epss_percentile": 0.56535}, "CVE-2007-0289": {"epss_score": 0.01182, "epss_percentile": 0.78319}, "CVE-2007-0290": {"epss_score": 0.0147, "epss_percentile": 0.80498}, "CVE-2007-0291": {"epss_score": 0.00592, "epss_percentile": 0.68619}, "CVE-2007-0292": {"epss_score": 0.015, "epss_percentile": 0.80712}, "CVE-2007-0293": {"epss_score": 0.01182, "epss_percentile": 0.78319}, "CVE-2007-0294": {"epss_score": 0.00344, "epss_percentile": 0.56535}, "CVE-2007-0295": {"epss_score": 0.00957, "epss_percentile": 0.75936}, "CVE-2007-0296": {"epss_score": 0.00362, "epss_percentile": 0.57776}, "CVE-2007-0297": {"epss_score": 0.1463, "epss_percentile": 0.94254}, "CVE-2007-0298": {"epss_score": 0.14519, "epss_percentile": 0.94229}, "CVE-2007-0299": {"epss_score": 0.02425, "epss_percentile": 0.84715}, "CVE-2007-0300": {"epss_score": 0.13789, "epss_percentile": 0.94058}, "CVE-2007-0301": {"epss_score": 0.07016, "epss_percentile": 0.91188}, "CVE-2007-0302": {"epss_score": 0.10054, "epss_percentile": 0.92831}, "CVE-2007-0303": {"epss_score": 0.00452, "epss_percentile": 0.63176}, "CVE-2007-0304": {"epss_score": 0.00793, "epss_percentile": 0.73435}, "CVE-2007-0305": {"epss_score": 0.01512, "epss_percentile": 0.80785}, "CVE-2007-0306": {"epss_score": 0.0069, "epss_percentile": 0.71252}, "CVE-2007-0307": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2007-0308": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2007-0309": {"epss_score": 0.35404, "epss_percentile": 0.96905}, "CVE-2007-0310": {"epss_score": 0.0097, "epss_percentile": 0.76108}, "CVE-2007-0311": {"epss_score": 0.05489, "epss_percentile": 0.89929}, "CVE-2007-0312": {"epss_score": 0.00358, "epss_percentile": 0.57498}, "CVE-2007-0313": {"epss_score": 0.00601, "epss_percentile": 0.68852}, "CVE-2007-0314": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2007-0315": {"epss_score": 0.02986, "epss_percentile": 0.86134}, "CVE-2007-0316": {"epss_score": 0.02213, "epss_percentile": 0.84025}, "CVE-2007-0317": {"epss_score": 0.01955, "epss_percentile": 0.83036}, "CVE-2007-0318": {"epss_score": 0.01575, "epss_percentile": 0.8111}, "CVE-2007-0319": {"epss_score": 0.16179, "epss_percentile": 0.94589}, "CVE-2007-0320": {"epss_score": 0.09642, "epss_percentile": 0.92637}, "CVE-2007-0321": {"epss_score": 0.07566, "epss_percentile": 0.91544}, "CVE-2007-0322": {"epss_score": 0.05981, "epss_percentile": 0.90379}, "CVE-2007-0323": {"epss_score": 0.21272, "epss_percentile": 0.95492}, "CVE-2007-0324": {"epss_score": 0.2513, "epss_percentile": 0.95988}, "CVE-2007-0325": {"epss_score": 0.75675, "epss_percentile": 0.9886}, "CVE-2007-0326": {"epss_score": 0.12306, "epss_percentile": 0.93629}, "CVE-2007-0328": {"epss_score": 0.04151, "epss_percentile": 0.8832}, "CVE-2007-0329": {"epss_score": 0.07032, "epss_percentile": 0.91201}, "CVE-2007-0330": {"epss_score": 0.00826, "epss_percentile": 0.73975}, "CVE-2007-0331": {"epss_score": 0.00987, "epss_percentile": 0.76345}, "CVE-2007-0332": {"epss_score": 0.01045, "epss_percentile": 0.7702}, "CVE-2007-0333": {"epss_score": 0.00138, "epss_percentile": 0.34517}, "CVE-2007-0334": {"epss_score": 0.01662, "epss_percentile": 0.81636}, "CVE-2007-0335": {"epss_score": 0.14251, "epss_percentile": 0.94171}, "CVE-2007-0336": {"epss_score": 0.00059, "epss_percentile": 0.18671}, "CVE-2007-0337": {"epss_score": 0.10846, "epss_percentile": 0.93133}, "CVE-2007-0338": {"epss_score": 0.25508, "epss_percentile": 0.96036}, "CVE-2007-0339": {"epss_score": 0.00606, "epss_percentile": 0.68998}, "CVE-2007-0340": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-0341": {"epss_score": 0.00956, "epss_percentile": 0.75925}, "CVE-2007-0342": {"epss_score": 0.05222, "epss_percentile": 0.89627}, "CVE-2007-0343": {"epss_score": 0.01849, "epss_percentile": 0.82528}, "CVE-2007-0344": {"epss_score": 0.24208, "epss_percentile": 0.95886}, "CVE-2007-0345": {"epss_score": 0.00087, "epss_percentile": 0.25567}, "CVE-2007-0346": {"epss_score": 0.00492, "epss_percentile": 0.64983}, "CVE-2007-0347": {"epss_score": 0.02016, "epss_percentile": 0.83277}, "CVE-2007-0348": {"epss_score": 0.72302, "epss_percentile": 0.98703}, "CVE-2007-0349": {"epss_score": 0.0022, "epss_percentile": 0.44613}, "CVE-2007-0350": {"epss_score": 0.00596, "epss_percentile": 0.68705}, "CVE-2007-0351": {"epss_score": 0.00049, "epss_percentile": 0.1545}, "CVE-2007-0352": {"epss_score": 0.67511, "epss_percentile": 0.98511}, "CVE-2007-0353": {"epss_score": 0.16255, "epss_percentile": 0.94604}, "CVE-2007-0354": {"epss_score": 0.02514, "epss_percentile": 0.8498}, "CVE-2007-0355": {"epss_score": 0.01057, "epss_percentile": 0.77138}, "CVE-2007-0356": {"epss_score": 0.13425, "epss_percentile": 0.9396}, "CVE-2007-0357": {"epss_score": 0.08611, "epss_percentile": 0.92151}, "CVE-2007-0358": {"epss_score": 0.02838, "epss_percentile": 0.85794}, "CVE-2007-0359": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2007-0360": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-0361": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2007-0362": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0363": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0364": {"epss_score": 0.01986, "epss_percentile": 0.83158}, "CVE-2007-0365": {"epss_score": 0.01194, "epss_percentile": 0.78421}, "CVE-2007-0366": {"epss_score": 0.00079, "epss_percentile": 0.2399}, "CVE-2007-0367": {"epss_score": 0.0005, "epss_percentile": 0.15736}, "CVE-2007-0368": {"epss_score": 0.01773, "epss_percentile": 0.82205}, "CVE-2007-0369": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-0370": {"epss_score": 0.00599, "epss_percentile": 0.68805}, "CVE-2007-0371": {"epss_score": 0.06348, "epss_percentile": 0.90689}, "CVE-2007-0372": {"epss_score": 0.00187, "epss_percentile": 0.40773}, "CVE-2007-0373": {"epss_score": 0.00558, "epss_percentile": 0.6757}, "CVE-2007-0374": {"epss_score": 0.00014, "epss_percentile": 0.02058}, "CVE-2007-0375": {"epss_score": 0.00031, "epss_percentile": 0.08537}, "CVE-2007-0376": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0377": {"epss_score": 0.00797, "epss_percentile": 0.73496}, "CVE-2007-0378": {"epss_score": 0.00357, "epss_percentile": 0.57459}, "CVE-2007-0379": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2007-0380": {"epss_score": 0.00408, "epss_percentile": 0.60682}, "CVE-2007-0381": {"epss_score": 0.00484, "epss_percentile": 0.64627}, "CVE-2007-0382": {"epss_score": 0.00626, "epss_percentile": 0.69614}, "CVE-2007-0383": {"epss_score": 0.00597, "epss_percentile": 0.68754}, "CVE-2007-0384": {"epss_score": 0.01035, "epss_percentile": 0.76897}, "CVE-2007-0385": {"epss_score": 0.005, "epss_percentile": 0.65298}, "CVE-2007-0386": {"epss_score": 0.00381, "epss_percentile": 0.5902}, "CVE-2007-0387": {"epss_score": 0.00026, "epss_percentile": 0.0643}, "CVE-2007-0388": {"epss_score": 0.00653, "epss_percentile": 0.7033}, "CVE-2007-0389": {"epss_score": 0.03961, "epss_percentile": 0.88014}, "CVE-2007-0390": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0391": {"epss_score": 0.00112, "epss_percentile": 0.3052}, "CVE-2007-0392": {"epss_score": 0.00069, "epss_percentile": 0.2154}, "CVE-2007-0393": {"epss_score": 0.00069, "epss_percentile": 0.2154}, "CVE-2007-0394": {"epss_score": 0.00097, "epss_percentile": 0.27631}, "CVE-2007-0395": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2007-0396": {"epss_score": 0.0109, "epss_percentile": 0.77451}, "CVE-2007-0397": {"epss_score": 0.00327, "epss_percentile": 0.55123}, "CVE-2007-0398": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2007-0399": {"epss_score": 0.0152, "epss_percentile": 0.80821}, "CVE-2007-0400": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2007-0401": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2007-0402": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2007-0403": {"epss_score": 0.00596, "epss_percentile": 0.68705}, "CVE-2007-0404": {"epss_score": 0.0067, "epss_percentile": 0.70775}, "CVE-2007-0405": {"epss_score": 0.00733, "epss_percentile": 0.72208}, "CVE-2007-0406": {"epss_score": 0.00073, "epss_percentile": 0.22503}, "CVE-2007-0407": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0408": {"epss_score": 0.00848, "epss_percentile": 0.74361}, "CVE-2007-0409": {"epss_score": 0.00074, "epss_percentile": 0.2273}, "CVE-2007-0410": {"epss_score": 0.01818, "epss_percentile": 0.824}, "CVE-2007-0411": {"epss_score": 0.00979, "epss_percentile": 0.76258}, "CVE-2007-0412": {"epss_score": 0.0081, "epss_percentile": 0.73718}, "CVE-2007-0413": {"epss_score": 0.00088, "epss_percentile": 0.25743}, "CVE-2007-0414": {"epss_score": 0.00917, "epss_percentile": 0.75425}, "CVE-2007-0415": {"epss_score": 0.00511, "epss_percentile": 0.6583}, "CVE-2007-0416": {"epss_score": 0.00611, "epss_percentile": 0.69191}, "CVE-2007-0417": {"epss_score": 0.0094, "epss_percentile": 0.7573}, "CVE-2007-0418": {"epss_score": 0.01187, "epss_percentile": 0.78356}, "CVE-2007-0419": {"epss_score": 0.00917, "epss_percentile": 0.75425}, "CVE-2007-0420": {"epss_score": 0.0043, "epss_percentile": 0.62021}, "CVE-2007-0421": {"epss_score": 0.02217, "epss_percentile": 0.84038}, "CVE-2007-0422": {"epss_score": 0.00917, "epss_percentile": 0.75425}, "CVE-2007-0423": {"epss_score": 0.00254, "epss_percentile": 0.48539}, "CVE-2007-0424": {"epss_score": 0.00917, "epss_percentile": 0.75425}, "CVE-2007-0425": {"epss_score": 0.00747, "epss_percentile": 0.72565}, "CVE-2007-0426": {"epss_score": 0.00708, "epss_percentile": 0.71672}, "CVE-2007-0427": {"epss_score": 0.53645, "epss_percentile": 0.97887}, "CVE-2007-0428": {"epss_score": 0.02199, "epss_percentile": 0.8397}, "CVE-2007-0429": {"epss_score": 0.05489, "epss_percentile": 0.89929}, "CVE-2007-0430": {"epss_score": 0.00153, "epss_percentile": 0.36604}, "CVE-2007-0431": {"epss_score": 0.0272, "epss_percentile": 0.85516}, "CVE-2007-0432": {"epss_score": 0.00495, "epss_percentile": 0.65111}, "CVE-2007-0433": {"epss_score": 0.01037, "epss_percentile": 0.76922}, "CVE-2007-0434": {"epss_score": 0.00088, "epss_percentile": 0.25726}, "CVE-2007-0435": {"epss_score": 0.00995, "epss_percentile": 0.76439}, "CVE-2007-0436": {"epss_score": 0.00073, "epss_percentile": 0.22538}, "CVE-2007-0437": {"epss_score": 0.00194, "epss_percentile": 0.41587}, "CVE-2007-0441": {"epss_score": 0.01935, "epss_percentile": 0.82959}, "CVE-2007-0442": {"epss_score": 0.00356, "epss_percentile": 0.57347}, "CVE-2007-0443": {"epss_score": 0.13949, "epss_percentile": 0.94099}, "CVE-2007-0444": {"epss_score": 0.02452, "epss_percentile": 0.8479}, "CVE-2007-0445": {"epss_score": 0.20299, "epss_percentile": 0.95317}, "CVE-2007-0446": {"epss_score": 0.64475, "epss_percentile": 0.9838}, "CVE-2007-0447": {"epss_score": 0.10844, "epss_percentile": 0.93131}, "CVE-2007-0448": {"epss_score": 0.02849, "epss_percentile": 0.85826}, "CVE-2007-0449": {"epss_score": 0.82246, "epss_percentile": 0.99182}, "CVE-2007-0450": {"epss_score": 0.87828, "epss_percentile": 0.99446}, "CVE-2007-0451": {"epss_score": 0.29343, "epss_percentile": 0.96434}, "CVE-2007-0452": {"epss_score": 0.02188, "epss_percentile": 0.83926}, "CVE-2007-0453": {"epss_score": 0.00528, "epss_percentile": 0.66551}, "CVE-2007-0454": {"epss_score": 0.04407, "epss_percentile": 0.88653}, "CVE-2007-0455": {"epss_score": 0.04925, "epss_percentile": 0.89293}, "CVE-2007-0456": {"epss_score": 0.01923, "epss_percentile": 0.8291}, "CVE-2007-0457": {"epss_score": 0.01923, "epss_percentile": 0.8291}, "CVE-2007-0458": {"epss_score": 0.01923, "epss_percentile": 0.8291}, "CVE-2007-0459": {"epss_score": 0.02591, "epss_percentile": 0.85183}, "CVE-2007-0460": {"epss_score": 0.00551, "epss_percentile": 0.67372}, "CVE-2007-0461": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2007-0462": {"epss_score": 0.15607, "epss_percentile": 0.94468}, "CVE-2007-0463": {"epss_score": 0.35536, "epss_percentile": 0.96918}, "CVE-2007-0464": {"epss_score": 0.50083, "epss_percentile": 0.97719}, "CVE-2007-0465": {"epss_score": 0.30039, "epss_percentile": 0.96498}, "CVE-2007-0466": {"epss_score": 0.24766, "epss_percentile": 0.95952}, "CVE-2007-0467": {"epss_score": 0.00172, "epss_percentile": 0.39014}, "CVE-2007-0468": {"epss_score": 0.39339, "epss_percentile": 0.97154}, "CVE-2007-0469": {"epss_score": 0.02085, "epss_percentile": 0.83545}, "CVE-2007-0470": {"epss_score": 0.00056, "epss_percentile": 0.17729}, "CVE-2007-0471": {"epss_score": 0.03724, "epss_percentile": 0.87629}, "CVE-2007-0472": {"epss_score": 0.00078, "epss_percentile": 0.23633}, "CVE-2007-0473": {"epss_score": 0.0006, "epss_percentile": 0.19069}, "CVE-2007-0474": {"epss_score": 0.00072, "epss_percentile": 0.22352}, "CVE-2007-0475": {"epss_score": 0.00134, "epss_percentile": 0.33836}, "CVE-2007-0476": {"epss_score": 0.00068, "epss_percentile": 0.21407}, "CVE-2007-0477": {"epss_score": 0.0166, "epss_percentile": 0.81617}, "CVE-2007-0478": {"epss_score": 0.0254, "epss_percentile": 0.85048}, "CVE-2007-0479": {"epss_score": 0.01995, "epss_percentile": 0.83193}, "CVE-2007-0480": {"epss_score": 0.24172, "epss_percentile": 0.95882}, "CVE-2007-0481": {"epss_score": 0.03462, "epss_percentile": 0.87183}, "CVE-2007-0482": {"epss_score": 0.00066, "epss_percentile": 0.20858}, "CVE-2007-0483": {"epss_score": 0.00874, "epss_percentile": 0.74764}, "CVE-2007-0484": {"epss_score": 0.00596, "epss_percentile": 0.68705}, "CVE-2007-0485": {"epss_score": 0.07181, "epss_percentile": 0.91303}, "CVE-2007-0486": {"epss_score": 0.01451, "epss_percentile": 0.80362}, "CVE-2007-0487": {"epss_score": 0.01019, "epss_percentile": 0.76729}, "CVE-2007-0488": {"epss_score": 0.00346, "epss_percentile": 0.56632}, "CVE-2007-0489": {"epss_score": 0.12541, "epss_percentile": 0.93711}, "CVE-2007-0490": {"epss_score": 0.00333, "epss_percentile": 0.55672}, "CVE-2007-0491": {"epss_score": 0.04621, "epss_percentile": 0.88933}, "CVE-2007-0492": {"epss_score": 0.0049, "epss_percentile": 0.64929}, "CVE-2007-0493": {"epss_score": 0.1585, "epss_percentile": 0.94518}, "CVE-2007-0494": {"epss_score": 0.41543, "epss_percentile": 0.97282}, "CVE-2007-0495": {"epss_score": 0.04118, "epss_percentile": 0.8828}, "CVE-2007-0496": {"epss_score": 0.03545, "epss_percentile": 0.87326}, "CVE-2007-0497": {"epss_score": 0.08291, "epss_percentile": 0.91972}, "CVE-2007-0498": {"epss_score": 0.05419, "epss_percentile": 0.89856}, "CVE-2007-0499": {"epss_score": 0.06871, "epss_percentile": 0.91085}, "CVE-2007-0500": {"epss_score": 0.05497, "epss_percentile": 0.89935}, "CVE-2007-0501": {"epss_score": 0.05946, "epss_percentile": 0.90354}, "CVE-2007-0502": {"epss_score": 0.0069, "epss_percentile": 0.71252}, "CVE-2007-0503": {"epss_score": 0.00035, "epss_percentile": 0.10002}, "CVE-2007-0504": {"epss_score": 0.17544, "epss_percentile": 0.94864}, "CVE-2007-0505": {"epss_score": 0.0263, "epss_percentile": 0.85278}, "CVE-2007-0506": {"epss_score": 0.00452, "epss_percentile": 0.63178}, "CVE-2007-0507": {"epss_score": 0.00773, "epss_percentile": 0.73053}, "CVE-2007-0508": {"epss_score": 0.05497, "epss_percentile": 0.89935}, "CVE-2007-0509": {"epss_score": 0.00667, "epss_percentile": 0.70704}, "CVE-2007-0510": {"epss_score": 0.01302, "epss_percentile": 0.79301}, "CVE-2007-0511": {"epss_score": 0.16001, "epss_percentile": 0.94552}, "CVE-2007-0512": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2007-0513": {"epss_score": 0.00787, "epss_percentile": 0.73319}, "CVE-2007-0514": {"epss_score": 0.01194, "epss_percentile": 0.78421}, "CVE-2007-0515": {"epss_score": 0.81631, "epss_percentile": 0.99148}, "CVE-2007-0516": {"epss_score": 0.00531, "epss_percentile": 0.66645}, "CVE-2007-0517": {"epss_score": 0.01035, "epss_percentile": 0.76897}, "CVE-2007-0518": {"epss_score": 0.05241, "epss_percentile": 0.89652}, "CVE-2007-0519": {"epss_score": 0.00259, "epss_percentile": 0.49086}, "CVE-2007-0520": {"epss_score": 0.00472, "epss_percentile": 0.64042}, "CVE-2007-0521": {"epss_score": 0.00248, "epss_percentile": 0.4799}, "CVE-2007-0522": {"epss_score": 0.00248, "epss_percentile": 0.4799}, "CVE-2007-0523": {"epss_score": 0.00248, "epss_percentile": 0.4799}, "CVE-2007-0524": {"epss_score": 0.00287, "epss_percentile": 0.51837}, "CVE-2007-0525": {"epss_score": 0.00471, "epss_percentile": 0.64015}, "CVE-2007-0526": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0527": {"epss_score": 0.0107, "epss_percentile": 0.77255}, "CVE-2007-0528": {"epss_score": 0.15008, "epss_percentile": 0.9434}, "CVE-2007-0529": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-0530": {"epss_score": 0.00904, "epss_percentile": 0.75217}, "CVE-2007-0531": {"epss_score": 0.01362, "epss_percentile": 0.79758}, "CVE-2007-0532": {"epss_score": 0.00333, "epss_percentile": 0.5562}, "CVE-2007-0533": {"epss_score": 0.02924, "epss_percentile": 0.86002}, "CVE-2007-0534": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-0535": {"epss_score": 0.05568, "epss_percentile": 0.90003}, "CVE-2007-0536": {"epss_score": 0.00037, "epss_percentile": 0.10818}, "CVE-2007-0537": {"epss_score": 0.02361, "epss_percentile": 0.84495}, "CVE-2007-0538": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2007-0539": {"epss_score": 0.01329, "epss_percentile": 0.79502}, "CVE-2007-0540": {"epss_score": 0.0776, "epss_percentile": 0.91664}, "CVE-2007-0541": {"epss_score": 0.01252, "epss_percentile": 0.78911}, "CVE-2007-0542": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2007-0543": {"epss_score": 0.00318, "epss_percentile": 0.54402}, "CVE-2007-0544": {"epss_score": 0.0134, "epss_percentile": 0.79576}, "CVE-2007-0545": {"epss_score": 0.00358, "epss_percentile": 0.57498}, "CVE-2007-0546": {"epss_score": 0.00358, "epss_percentile": 0.57498}, "CVE-2007-0547": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-0548": {"epss_score": 0.18514, "epss_percentile": 0.95026}, "CVE-2007-0549": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2007-0550": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2007-0551": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2007-0552": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0553": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2007-0554": {"epss_score": 0.01993, "epss_percentile": 0.83182}, "CVE-2007-0555": {"epss_score": 0.01835, "epss_percentile": 0.82466}, "CVE-2007-0556": {"epss_score": 0.01996, "epss_percentile": 0.83195}, "CVE-2007-0557": {"epss_score": 0.00052, "epss_percentile": 0.16474}, "CVE-2007-0558": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2007-0559": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2007-0560": {"epss_score": 0.01295, "epss_percentile": 0.79252}, "CVE-2007-0561": {"epss_score": 0.10808, "epss_percentile": 0.93111}, "CVE-2007-0562": {"epss_score": 0.35722, "epss_percentile": 0.96928}, "CVE-2007-0563": {"epss_score": 0.01624, "epss_percentile": 0.81408}, "CVE-2007-0564": {"epss_score": 0.00534, "epss_percentile": 0.66792}, "CVE-2007-0565": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2007-0566": {"epss_score": 0.01252, "epss_percentile": 0.7891}, "CVE-2007-0567": {"epss_score": 0.02168, "epss_percentile": 0.83859}, "CVE-2007-0568": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2007-0569": {"epss_score": 0.00835, "epss_percentile": 0.74116}, "CVE-2007-0570": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2007-0571": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-0572": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2007-0573": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2007-0574": {"epss_score": 0.00337, "epss_percentile": 0.56019}, "CVE-2007-0575": {"epss_score": 0.0082, "epss_percentile": 0.73887}, "CVE-2007-0576": {"epss_score": 0.16523, "epss_percentile": 0.94685}, "CVE-2007-0577": {"epss_score": 0.06847, "epss_percentile": 0.91069}, "CVE-2007-0578": {"epss_score": 0.01242, "epss_percentile": 0.78822}, "CVE-2007-0579": {"epss_score": 0.01362, "epss_percentile": 0.79758}, "CVE-2007-0580": {"epss_score": 0.1758, "epss_percentile": 0.94871}, "CVE-2007-0581": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2007-0582": {"epss_score": 0.00602, "epss_percentile": 0.68875}, "CVE-2007-0583": {"epss_score": 0.005, "epss_percentile": 0.65302}, "CVE-2007-0584": {"epss_score": 0.66266, "epss_percentile": 0.98458}, "CVE-2007-0585": {"epss_score": 0.1119, "epss_percentile": 0.9326}, "CVE-2007-0588": {"epss_score": 0.30465, "epss_percentile": 0.96542}, "CVE-2007-0589": {"epss_score": 0.00594, "epss_percentile": 0.68658}, "CVE-2007-0590": {"epss_score": 0.00962, "epss_percentile": 0.75986}, "CVE-2007-0591": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2007-0592": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0593": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-0594": {"epss_score": 0.00333, "epss_percentile": 0.5562}, "CVE-2007-0595": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-0596": {"epss_score": 0.00713, "epss_percentile": 0.71791}, "CVE-2007-0597": {"epss_score": 0.00389, "epss_percentile": 0.59403}, "CVE-2007-0598": {"epss_score": 0.00354, "epss_percentile": 0.57245}, "CVE-2007-0599": {"epss_score": 0.00725, "epss_percentile": 0.72045}, "CVE-2007-0600": {"epss_score": 0.0232, "epss_percentile": 0.84365}, "CVE-2007-0601": {"epss_score": 0.00349, "epss_percentile": 0.5687}, "CVE-2007-0602": {"epss_score": 0.00233, "epss_percentile": 0.45981}, "CVE-2007-0603": {"epss_score": 0.12182, "epss_percentile": 0.93597}, "CVE-2007-0604": {"epss_score": 0.00834, "epss_percentile": 0.74104}, "CVE-2007-0605": {"epss_score": 0.10031, "epss_percentile": 0.92821}, "CVE-2007-0606": {"epss_score": 0.00574, "epss_percentile": 0.68078}, "CVE-2007-0607": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-0608": {"epss_score": 0.011, "epss_percentile": 0.77564}, "CVE-2007-0609": {"epss_score": 0.10254, "epss_percentile": 0.92914}, "CVE-2007-0610": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2007-0611": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2007-0612": {"epss_score": 0.53869, "epss_percentile": 0.97901}, "CVE-2007-0613": {"epss_score": 0.05668, "epss_percentile": 0.90102}, "CVE-2007-0614": {"epss_score": 0.10191, "epss_percentile": 0.92887}, "CVE-2007-0615": {"epss_score": 0.01542, "epss_percentile": 0.80951}, "CVE-2007-0616": {"epss_score": 0.00491, "epss_percentile": 0.64968}, "CVE-2007-0617": {"epss_score": 0.00823, "epss_percentile": 0.73928}, "CVE-2007-0618": {"epss_score": 0.01017, "epss_percentile": 0.7669}, "CVE-2007-0619": {"epss_score": 0.10593, "epss_percentile": 0.93038}, "CVE-2007-0620": {"epss_score": 0.15225, "epss_percentile": 0.94388}, "CVE-2007-0622": {"epss_score": 0.00324, "epss_percentile": 0.54925}, "CVE-2007-0623": {"epss_score": 0.01473, "epss_percentile": 0.80515}, "CVE-2007-0624": {"epss_score": 0.00389, "epss_percentile": 0.59403}, "CVE-2007-0625": {"epss_score": 0.00054, "epss_percentile": 0.17046}, "CVE-2007-0626": {"epss_score": 0.04969, "epss_percentile": 0.89346}, "CVE-2007-0627": {"epss_score": 0.00079, "epss_percentile": 0.23905}, "CVE-2007-0628": {"epss_score": 0.00765, "epss_percentile": 0.72924}, "CVE-2007-0629": {"epss_score": 0.00504, "epss_percentile": 0.65493}, "CVE-2007-0630": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2007-0631": {"epss_score": 0.02274, "epss_percentile": 0.84223}, "CVE-2007-0632": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2007-0633": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2007-0634": {"epss_score": 0.17967, "epss_percentile": 0.94935}, "CVE-2007-0635": {"epss_score": 0.09187, "epss_percentile": 0.92438}, "CVE-2007-0636": {"epss_score": 0.00081, "epss_percentile": 0.24371}, "CVE-2007-0637": {"epss_score": 0.11165, "epss_percentile": 0.93251}, "CVE-2007-0638": {"epss_score": 0.10905, "epss_percentile": 0.9315}, "CVE-2007-0639": {"epss_score": 0.10683, "epss_percentile": 0.9307}, "CVE-2007-0640": {"epss_score": 0.00924, "epss_percentile": 0.75522}, "CVE-2007-0641": {"epss_score": 0.05502, "epss_percentile": 0.89939}, "CVE-2007-0642": {"epss_score": 0.01348, "epss_percentile": 0.79662}, "CVE-2007-0643": {"epss_score": 0.22931, "epss_percentile": 0.95707}, "CVE-2007-0644": {"epss_score": 0.05223, "epss_percentile": 0.89629}, "CVE-2007-0645": {"epss_score": 0.03858, "epss_percentile": 0.87861}, "CVE-2007-0646": {"epss_score": 0.17144, "epss_percentile": 0.94782}, "CVE-2007-0647": {"epss_score": 0.05673, "epss_percentile": 0.90106}, "CVE-2007-0648": {"epss_score": 0.02334, "epss_percentile": 0.84413}, "CVE-2007-0649": {"epss_score": 0.03716, "epss_percentile": 0.87613}, "CVE-2007-0650": {"epss_score": 0.05266, "epss_percentile": 0.89674}, "CVE-2007-0651": {"epss_score": 0.0277, "epss_percentile": 0.85619}, "CVE-2007-0652": {"epss_score": 0.03049, "epss_percentile": 0.86288}, "CVE-2007-0653": {"epss_score": 0.09958, "epss_percentile": 0.92793}, "CVE-2007-0654": {"epss_score": 0.04317, "epss_percentile": 0.8854}, "CVE-2007-0655": {"epss_score": 0.01203, "epss_percentile": 0.78495}, "CVE-2007-0656": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2007-0657": {"epss_score": 0.01155, "epss_percentile": 0.78079}, "CVE-2007-0658": {"epss_score": 0.00912, "epss_percentile": 0.75363}, "CVE-2007-0659": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2007-0660": {"epss_score": 0.01194, "epss_percentile": 0.78421}, "CVE-2007-0661": {"epss_score": 0.00458, "epss_percentile": 0.63419}, "CVE-2007-0662": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2007-0663": {"epss_score": 0.00324, "epss_percentile": 0.54943}, "CVE-2007-0664": {"epss_score": 0.03008, "epss_percentile": 0.86191}, "CVE-2007-0665": {"epss_score": 0.00364, "epss_percentile": 0.57927}, "CVE-2007-0666": {"epss_score": 0.00274, "epss_percentile": 0.50484}, "CVE-2007-0667": {"epss_score": 0.01831, "epss_percentile": 0.8245}, "CVE-2007-0668": {"epss_score": 0.00051, "epss_percentile": 0.16133}, "CVE-2007-0669": {"epss_score": 0.00128, "epss_percentile": 0.33005}, "CVE-2007-0670": {"epss_score": 0.001, "epss_percentile": 0.28467}, "CVE-2007-0671": {"epss_score": 0.65249, "epss_percentile": 0.98409}, "CVE-2007-0672": {"epss_score": 0.01309, "epss_percentile": 0.79354}, "CVE-2007-0673": {"epss_score": 0.01585, "epss_percentile": 0.81166}, "CVE-2007-0674": {"epss_score": 0.39004, "epss_percentile": 0.97134}, "CVE-2007-0675": {"epss_score": 0.41573, "epss_percentile": 0.97284}, "CVE-2007-0676": {"epss_score": 0.00718, "epss_percentile": 0.7192}, "CVE-2007-0677": {"epss_score": 0.11542, "epss_percentile": 0.934}, "CVE-2007-0678": {"epss_score": 0.00714, "epss_percentile": 0.71813}, "CVE-2007-0679": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2007-0680": {"epss_score": 0.1218, "epss_percentile": 0.93596}, "CVE-2007-0681": {"epss_score": 0.07467, "epss_percentile": 0.91488}, "CVE-2007-0682": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2007-0683": {"epss_score": 0.16791, "epss_percentile": 0.94732}, "CVE-2007-0684": {"epss_score": 0.07793, "epss_percentile": 0.91684}, "CVE-2007-0685": {"epss_score": 0.2204, "epss_percentile": 0.95587}, "CVE-2007-0686": {"epss_score": 0.07003, "epss_percentile": 0.91178}, "CVE-2007-0687": {"epss_score": 0.00676, "epss_percentile": 0.70923}, "CVE-2007-0688": {"epss_score": 0.01295, "epss_percentile": 0.79252}, "CVE-2007-0689": {"epss_score": 0.00674, "epss_percentile": 0.70877}, "CVE-2007-0690": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2007-0692": {"epss_score": 0.00381, "epss_percentile": 0.59027}, "CVE-2007-0693": {"epss_score": 0.01857, "epss_percentile": 0.82577}, "CVE-2007-0694": {"epss_score": 0.09681, "epss_percentile": 0.9266}, "CVE-2007-0695": {"epss_score": 0.00596, "epss_percentile": 0.68705}, "CVE-2007-0696": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2007-0697": {"epss_score": 0.10582, "epss_percentile": 0.93034}, "CVE-2007-0698": {"epss_score": 0.00541, "epss_percentile": 0.67049}, "CVE-2007-0699": {"epss_score": 0.09077, "epss_percentile": 0.92389}, "CVE-2007-0700": {"epss_score": 0.00355, "epss_percentile": 0.57275}, "CVE-2007-0701": {"epss_score": 0.08811, "epss_percentile": 0.92266}, "CVE-2007-0702": {"epss_score": 0.12639, "epss_percentile": 0.93737}, "CVE-2007-0703": {"epss_score": 0.04913, "epss_percentile": 0.89282}, "CVE-2007-0704": {"epss_score": 0.04913, "epss_percentile": 0.89282}, "CVE-2007-0705": {"epss_score": 0.00531, "epss_percentile": 0.66657}, "CVE-2007-0706": {"epss_score": 0.00338, "epss_percentile": 0.56128}, "CVE-2007-0707": {"epss_score": 0.0506, "epss_percentile": 0.89452}, "CVE-2007-0708": {"epss_score": 0.00163, "epss_percentile": 0.37775}, "CVE-2007-0709": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2007-0710": {"epss_score": 0.01224, "epss_percentile": 0.78676}, "CVE-2007-0711": {"epss_score": 0.19823, "epss_percentile": 0.95247}, "CVE-2007-0712": {"epss_score": 0.25702, "epss_percentile": 0.96057}, "CVE-2007-0713": {"epss_score": 0.11567, "epss_percentile": 0.93406}, "CVE-2007-0714": {"epss_score": 0.53476, "epss_percentile": 0.97878}, "CVE-2007-0715": {"epss_score": 0.12346, "epss_percentile": 0.93645}, "CVE-2007-0716": {"epss_score": 0.15616, "epss_percentile": 0.9447}, "CVE-2007-0717": {"epss_score": 0.17309, "epss_percentile": 0.9482}, "CVE-2007-0718": {"epss_score": 0.36798, "epss_percentile": 0.97002}, "CVE-2007-0719": {"epss_score": 0.13524, "epss_percentile": 0.93988}, "CVE-2007-0720": {"epss_score": 0.17144, "epss_percentile": 0.94782}, "CVE-2007-0721": {"epss_score": 0.0245, "epss_percentile": 0.84779}, "CVE-2007-0722": {"epss_score": 0.10393, "epss_percentile": 0.92972}, "CVE-2007-0723": {"epss_score": 0.02449, "epss_percentile": 0.84778}, "CVE-2007-0724": {"epss_score": 0.00096, "epss_percentile": 0.2742}, "CVE-2007-0725": {"epss_score": 0.00088, "epss_percentile": 0.25718}, "CVE-2007-0726": {"epss_score": 0.01168, "epss_percentile": 0.78196}, "CVE-2007-0728": {"epss_score": 0.0008, "epss_percentile": 0.24014}, "CVE-2007-0729": {"epss_score": 0.00086, "epss_percentile": 0.25369}, "CVE-2007-0730": {"epss_score": 0.01172, "epss_percentile": 0.78231}, "CVE-2007-0731": {"epss_score": 0.03532, "epss_percentile": 0.87305}, "CVE-2007-0732": {"epss_score": 0.00056, "epss_percentile": 0.17768}, "CVE-2007-0733": {"epss_score": 0.19857, "epss_percentile": 0.95251}, "CVE-2007-0734": {"epss_score": 0.00483, "epss_percentile": 0.64564}, "CVE-2007-0735": {"epss_score": 0.01151, "epss_percentile": 0.78036}, "CVE-2007-0736": {"epss_score": 0.15253, "epss_percentile": 0.94392}, "CVE-2007-0737": {"epss_score": 0.00077, "epss_percentile": 0.2338}, "CVE-2007-0738": {"epss_score": 0.00104, "epss_percentile": 0.2911}, "CVE-2007-0739": {"epss_score": 0.00093, "epss_percentile": 0.26659}, "CVE-2007-0740": {"epss_score": 0.00709, "epss_percentile": 0.71695}, "CVE-2007-0741": {"epss_score": 0.0456, "epss_percentile": 0.88851}, "CVE-2007-0742": {"epss_score": 0.00511, "epss_percentile": 0.65824}, "CVE-2007-0743": {"epss_score": 0.00074, "epss_percentile": 0.22777}, "CVE-2007-0744": {"epss_score": 0.00069, "epss_percentile": 0.21507}, "CVE-2007-0745": {"epss_score": 0.00244, "epss_percentile": 0.47599}, "CVE-2007-0746": {"epss_score": 0.3589, "epss_percentile": 0.9694}, "CVE-2007-0747": {"epss_score": 0.00086, "epss_percentile": 0.25369}, "CVE-2007-0748": {"epss_score": 0.20299, "epss_percentile": 0.95317}, "CVE-2007-0749": {"epss_score": 0.20299, "epss_percentile": 0.95317}, "CVE-2007-0750": {"epss_score": 0.05527, "epss_percentile": 0.89963}, "CVE-2007-0751": {"epss_score": 0.00072, "epss_percentile": 0.22294}, "CVE-2007-0752": {"epss_score": 0.00227, "epss_percentile": 0.45442}, "CVE-2007-0753": {"epss_score": 0.00412, "epss_percentile": 0.60906}, "CVE-2007-0754": {"epss_score": 0.09974, "epss_percentile": 0.92798}, "CVE-2007-0756": {"epss_score": 0.10326, "epss_percentile": 0.92945}, "CVE-2007-0757": {"epss_score": 0.09386, "epss_percentile": 0.92528}, "CVE-2007-0758": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2007-0759": {"epss_score": 0.00677, "epss_percentile": 0.7096}, "CVE-2007-0760": {"epss_score": 0.06544, "epss_percentile": 0.90838}, "CVE-2007-0761": {"epss_score": 0.03168, "epss_percentile": 0.86545}, "CVE-2007-0762": {"epss_score": 0.1218, "epss_percentile": 0.93596}, "CVE-2007-0763": {"epss_score": 0.04835, "epss_percentile": 0.89193}, "CVE-2007-0764": {"epss_score": 0.05378, "epss_percentile": 0.89805}, "CVE-2007-0765": {"epss_score": 0.01294, "epss_percentile": 0.79247}, "CVE-2007-0766": {"epss_score": 0.23016, "epss_percentile": 0.95718}, "CVE-2007-0767": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2007-0768": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2007-0769": {"epss_score": 0.01411, "epss_percentile": 0.80084}, "CVE-2007-0770": {"epss_score": 0.07123, "epss_percentile": 0.91265}, "CVE-2007-0771": {"epss_score": 0.0013, "epss_percentile": 0.33266}, "CVE-2007-0772": {"epss_score": 0.02775, "epss_percentile": 0.85633}, "CVE-2007-0773": {"epss_score": 0.00043, "epss_percentile": 0.13011}, "CVE-2007-0774": {"epss_score": 0.88237, "epss_percentile": 0.99462}, "CVE-2007-0775": {"epss_score": 0.21003, "epss_percentile": 0.95449}, "CVE-2007-0776": {"epss_score": 0.30966, "epss_percentile": 0.96579}, "CVE-2007-0777": {"epss_score": 0.42764, "epss_percentile": 0.97349}, "CVE-2007-0778": {"epss_score": 0.01078, "epss_percentile": 0.77352}, "CVE-2007-0779": {"epss_score": 0.03391, "epss_percentile": 0.87051}, "CVE-2007-0780": {"epss_score": 0.02155, "epss_percentile": 0.83806}, "CVE-2007-0784": {"epss_score": 0.00803, "epss_percentile": 0.73603}, "CVE-2007-0785": {"epss_score": 0.79236, "epss_percentile": 0.99026}, "CVE-2007-0786": {"epss_score": 0.01252, "epss_percentile": 0.7891}, "CVE-2007-0787": {"epss_score": 0.01333, "epss_percentile": 0.79529}, "CVE-2007-0788": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-0789": {"epss_score": 0.00559, "epss_percentile": 0.67606}, "CVE-2007-0790": {"epss_score": 0.05041, "epss_percentile": 0.89428}, "CVE-2007-0791": {"epss_score": 0.00791, "epss_percentile": 0.73387}, "CVE-2007-0792": {"epss_score": 0.00926, "epss_percentile": 0.75555}, "CVE-2007-0793": {"epss_score": 0.0069, "epss_percentile": 0.71256}, "CVE-2007-0794": {"epss_score": 0.00751, "epss_percentile": 0.7264}, "CVE-2007-0795": {"epss_score": 0.01155, "epss_percentile": 0.78079}, "CVE-2007-0796": {"epss_score": 0.04347, "epss_percentile": 0.88578}, "CVE-2007-0797": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-0798": {"epss_score": 0.00815, "epss_percentile": 0.73783}, "CVE-2007-0799": {"epss_score": 0.00596, "epss_percentile": 0.68705}, "CVE-2007-0800": {"epss_score": 0.03834, "epss_percentile": 0.87812}, "CVE-2007-0801": {"epss_score": 0.00624, "epss_percentile": 0.69564}, "CVE-2007-0802": {"epss_score": 0.00965, "epss_percentile": 0.76041}, "CVE-2007-0803": {"epss_score": 0.07447, "epss_percentile": 0.91476}, "CVE-2007-0804": {"epss_score": 0.04941, "epss_percentile": 0.89307}, "CVE-2007-0805": {"epss_score": 0.0097, "epss_percentile": 0.76118}, "CVE-2007-0806": {"epss_score": 0.00235, "epss_percentile": 0.46224}, "CVE-2007-0807": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0808": {"epss_score": 0.0069, "epss_percentile": 0.71256}, "CVE-2007-0809": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-0810": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2007-0811": {"epss_score": 0.46917, "epss_percentile": 0.97561}, "CVE-2007-0812": {"epss_score": 0.01252, "epss_percentile": 0.7891}, "CVE-2007-0813": {"epss_score": 0.00409, "epss_percentile": 0.60724}, "CVE-2007-0814": {"epss_score": 0.00537, "epss_percentile": 0.66919}, "CVE-2007-0815": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-0816": {"epss_score": 0.14298, "epss_percentile": 0.94182}, "CVE-2007-0817": {"epss_score": 0.04251, "epss_percentile": 0.88451}, "CVE-2007-0819": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2007-0820": {"epss_score": 0.06143, "epss_percentile": 0.90516}, "CVE-2007-0821": {"epss_score": 0.04271, "epss_percentile": 0.88476}, "CVE-2007-0822": {"epss_score": 0.00064, "epss_percentile": 0.20253}, "CVE-2007-0823": {"epss_score": 0.00048, "epss_percentile": 0.15004}, "CVE-2007-0824": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2007-0825": {"epss_score": 0.05504, "epss_percentile": 0.89941}, "CVE-2007-0826": {"epss_score": 0.0069, "epss_percentile": 0.71252}, "CVE-2007-0827": {"epss_score": 0.22608, "epss_percentile": 0.95657}, "CVE-2007-0828": {"epss_score": 0.05611, "epss_percentile": 0.90046}, "CVE-2007-0829": {"epss_score": 0.00076, "epss_percentile": 0.23167}, "CVE-2007-0830": {"epss_score": 0.00288, "epss_percentile": 0.51913}, "CVE-2007-0831": {"epss_score": 0.00904, "epss_percentile": 0.75217}, "CVE-2007-0832": {"epss_score": 0.00053, "epss_percentile": 0.16673}, "CVE-2007-0833": {"epss_score": 0.00053, "epss_percentile": 0.16673}, "CVE-2007-0834": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2007-0835": {"epss_score": 0.00748, "epss_percentile": 0.72589}, "CVE-2007-0836": {"epss_score": 0.02983, "epss_percentile": 0.86126}, "CVE-2007-0837": {"epss_score": 0.09386, "epss_percentile": 0.92528}, "CVE-2007-0838": {"epss_score": 0.00946, "epss_percentile": 0.75808}, "CVE-2007-0839": {"epss_score": 0.13614, "epss_percentile": 0.94014}, "CVE-2007-0840": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2007-0841": {"epss_score": 0.00432, "epss_percentile": 0.62114}, "CVE-2007-0842": {"epss_score": 0.10504, "epss_percentile": 0.93013}, "CVE-2007-0843": {"epss_score": 0.00364, "epss_percentile": 0.57953}, "CVE-2007-0844": {"epss_score": 0.00275, "epss_percentile": 0.5067}, "CVE-2007-0845": {"epss_score": 0.06148, "epss_percentile": 0.90519}, "CVE-2007-0846": {"epss_score": 0.05872, "epss_percentile": 0.90281}, "CVE-2007-0847": {"epss_score": 0.00835, "epss_percentile": 0.74116}, "CVE-2007-0848": {"epss_score": 0.17368, "epss_percentile": 0.94838}, "CVE-2007-0849": {"epss_score": 0.00117, "epss_percentile": 0.31266}, "CVE-2007-0850": {"epss_score": 0.00898, "epss_percentile": 0.75149}, "CVE-2007-0851": {"epss_score": 0.35246, "epss_percentile": 0.96896}, "CVE-2007-0852": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2007-0853": {"epss_score": 0.00484, "epss_percentile": 0.64627}, "CVE-2007-0854": {"epss_score": 0.06709, "epss_percentile": 0.90962}, "CVE-2007-0855": {"epss_score": 0.05503, "epss_percentile": 0.8994}, "CVE-2007-0856": {"epss_score": 0.0015, "epss_percentile": 0.36053}, "CVE-2007-0857": {"epss_score": 0.00882, "epss_percentile": 0.74887}, "CVE-2007-0859": {"epss_score": 0.00121, "epss_percentile": 0.31884}, "CVE-2007-0860": {"epss_score": 0.00904, "epss_percentile": 0.75217}, "CVE-2007-0861": {"epss_score": 0.00867, "epss_percentile": 0.74652}, "CVE-2007-0862": {"epss_score": 0.01043, "epss_percentile": 0.76997}, "CVE-2007-0863": {"epss_score": 0.11986, "epss_percentile": 0.93537}, "CVE-2007-0864": {"epss_score": 0.01294, "epss_percentile": 0.79247}, "CVE-2007-0865": {"epss_score": 0.01511, "epss_percentile": 0.8078}, "CVE-2007-0866": {"epss_score": 0.00034, "epss_percentile": 0.09568}, "CVE-2007-0867": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2007-0868": {"epss_score": 0.0063, "epss_percentile": 0.69705}, "CVE-2007-0869": {"epss_score": 0.0035, "epss_percentile": 0.56958}, "CVE-2007-0870": {"epss_score": 0.57788, "epss_percentile": 0.98083}, "CVE-2007-0871": {"epss_score": 0.04756, "epss_percentile": 0.89113}, "CVE-2007-0872": {"epss_score": 0.10217, "epss_percentile": 0.92898}, "CVE-2007-0873": {"epss_score": 0.16984, "epss_percentile": 0.94756}, "CVE-2007-0874": {"epss_score": 0.00292, "epss_percentile": 0.52262}, "CVE-2007-0875": {"epss_score": 0.01077, "epss_percentile": 0.77333}, "CVE-2007-0876": {"epss_score": 0.00537, "epss_percentile": 0.66891}, "CVE-2007-0877": {"epss_score": 0.00406, "epss_percentile": 0.60529}, "CVE-2007-0878": {"epss_score": 0.31241, "epss_percentile": 0.96602}, "CVE-2007-0879": {"epss_score": 0.04301, "epss_percentile": 0.88516}, "CVE-2007-0880": {"epss_score": 0.00331, "epss_percentile": 0.55538}, "CVE-2007-0881": {"epss_score": 0.18585, "epss_percentile": 0.95037}, "CVE-2007-0882": {"epss_score": 0.91063, "epss_percentile": 0.99617}, "CVE-2007-0883": {"epss_score": 0.15659, "epss_percentile": 0.94478}, "CVE-2007-0884": {"epss_score": 0.03243, "epss_percentile": 0.86738}, "CVE-2007-0885": {"epss_score": 0.02133, "epss_percentile": 0.83717}, "CVE-2007-0886": {"epss_score": 0.26722, "epss_percentile": 0.9617}, "CVE-2007-0887": {"epss_score": 0.14029, "epss_percentile": 0.94118}, "CVE-2007-0888": {"epss_score": 0.06949, "epss_percentile": 0.91136}, "CVE-2007-0889": {"epss_score": 0.00061, "epss_percentile": 0.19541}, "CVE-2007-0890": {"epss_score": 0.05656, "epss_percentile": 0.90091}, "CVE-2007-0891": {"epss_score": 0.00575, "epss_percentile": 0.68122}, "CVE-2007-0892": {"epss_score": 0.00753, "epss_percentile": 0.72684}, "CVE-2007-0893": {"epss_score": 0.02158, "epss_percentile": 0.83817}, "CVE-2007-0894": {"epss_score": 0.00922, "epss_percentile": 0.75489}, "CVE-2007-0895": {"epss_score": 0.00072, "epss_percentile": 0.22272}, "CVE-2007-0896": {"epss_score": 0.09325, "epss_percentile": 0.925}, "CVE-2007-0897": {"epss_score": 0.06408, "epss_percentile": 0.90738}, "CVE-2007-0898": {"epss_score": 0.0129, "epss_percentile": 0.79222}, "CVE-2007-0899": {"epss_score": 0.00627, "epss_percentile": 0.69635}, "CVE-2007-0900": {"epss_score": 0.06069, "epss_percentile": 0.90451}, "CVE-2007-0901": {"epss_score": 0.005, "epss_percentile": 0.65302}, "CVE-2007-0902": {"epss_score": 0.00465, "epss_percentile": 0.63748}, "CVE-2007-0903": {"epss_score": 0.00736, "epss_percentile": 0.72317}, "CVE-2007-0904": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-0905": {"epss_score": 0.01756, "epss_percentile": 0.82123}, "CVE-2007-0906": {"epss_score": 0.02166, "epss_percentile": 0.83849}, "CVE-2007-0907": {"epss_score": 0.03091, "epss_percentile": 0.86396}, "CVE-2007-0908": {"epss_score": 0.17062, "epss_percentile": 0.94767}, "CVE-2007-0909": {"epss_score": 0.03507, "epss_percentile": 0.87261}, "CVE-2007-0910": {"epss_score": 0.08108, "epss_percentile": 0.91882}, "CVE-2007-0911": {"epss_score": 0.09711, "epss_percentile": 0.92672}, "CVE-2007-0912": {"epss_score": 0.00818, "epss_percentile": 0.73854}, "CVE-2007-0913": {"epss_score": 0.38351, "epss_percentile": 0.97096}, "CVE-2007-0914": {"epss_score": 0.01426, "epss_percentile": 0.80205}, "CVE-2007-0915": {"epss_score": 0.0327, "epss_percentile": 0.86791}, "CVE-2007-0916": {"epss_score": 0.00075, "epss_percentile": 0.23037}, "CVE-2007-0917": {"epss_score": 0.00658, "epss_percentile": 0.70492}, "CVE-2007-0918": {"epss_score": 0.02811, "epss_percentile": 0.8572}, "CVE-2007-0919": {"epss_score": 0.07857, "epss_percentile": 0.91724}, "CVE-2007-0920": {"epss_score": 0.00714, "epss_percentile": 0.71813}, "CVE-2007-0921": {"epss_score": 0.01002, "epss_percentile": 0.76507}, "CVE-2007-0922": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-0923": {"epss_score": 0.005, "epss_percentile": 0.65298}, "CVE-2007-0924": {"epss_score": 0.0062, "epss_percentile": 0.69439}, "CVE-2007-0925": {"epss_score": 0.02878, "epss_percentile": 0.85889}, "CVE-2007-0926": {"epss_score": 0.0069, "epss_percentile": 0.71256}, "CVE-2007-0927": {"epss_score": 0.43176, "epss_percentile": 0.97374}, "CVE-2007-0928": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-0929": {"epss_score": 0.00573, "epss_percentile": 0.68068}, "CVE-2007-0930": {"epss_score": 0.00445, "epss_percentile": 0.62857}, "CVE-2007-0931": {"epss_score": 0.1208, "epss_percentile": 0.93562}, "CVE-2007-0932": {"epss_score": 0.04554, "epss_percentile": 0.88842}, "CVE-2007-0933": {"epss_score": 0.3762, "epss_percentile": 0.9706}, "CVE-2007-0934": {"epss_score": 0.60754, "epss_percentile": 0.98219}, "CVE-2007-0936": {"epss_score": 0.60754, "epss_percentile": 0.98219}, "CVE-2007-0938": {"epss_score": 0.35678, "epss_percentile": 0.96926}, "CVE-2007-0939": {"epss_score": 0.15706, "epss_percentile": 0.94487}, "CVE-2007-0940": {"epss_score": 0.75174, "epss_percentile": 0.98832}, "CVE-2007-0942": {"epss_score": 0.55284, "epss_percentile": 0.9797}, "CVE-2007-0943": {"epss_score": 0.62193, "epss_percentile": 0.98284}, "CVE-2007-0944": {"epss_score": 0.63754, "epss_percentile": 0.98347}, "CVE-2007-0945": {"epss_score": 0.59488, "epss_percentile": 0.98166}, "CVE-2007-0946": {"epss_score": 0.59488, "epss_percentile": 0.98166}, "CVE-2007-0947": {"epss_score": 0.55738, "epss_percentile": 0.97992}, "CVE-2007-0948": {"epss_score": 0.57584, "epss_percentile": 0.98072}, "CVE-2007-0949": {"epss_score": 0.29199, "epss_percentile": 0.96424}, "CVE-2007-0950": {"epss_score": 0.03553, "epss_percentile": 0.87345}, "CVE-2007-0951": {"epss_score": 0.00666, "epss_percentile": 0.70684}, "CVE-2007-0952": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2007-0953": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-0954": {"epss_score": 0.00414, "epss_percentile": 0.61109}, "CVE-2007-0955": {"epss_score": 0.1459, "epss_percentile": 0.94246}, "CVE-2007-0956": {"epss_score": 0.21911, "epss_percentile": 0.95572}, "CVE-2007-0957": {"epss_score": 0.26118, "epss_percentile": 0.96114}, "CVE-2007-0958": {"epss_score": 0.00068, "epss_percentile": 0.21239}, "CVE-2007-0959": {"epss_score": 0.0272, "epss_percentile": 0.85516}, "CVE-2007-0960": {"epss_score": 0.04065, "epss_percentile": 0.882}, "CVE-2007-0961": {"epss_score": 0.07352, "epss_percentile": 0.91426}, "CVE-2007-0962": {"epss_score": 0.02938, "epss_percentile": 0.86028}, "CVE-2007-0963": {"epss_score": 0.00698, "epss_percentile": 0.71417}, "CVE-2007-0964": {"epss_score": 0.00813, "epss_percentile": 0.73764}, "CVE-2007-0965": {"epss_score": 0.0149, "epss_percentile": 0.8063}, "CVE-2007-0966": {"epss_score": 0.01542, "epss_percentile": 0.80951}, "CVE-2007-0967": {"epss_score": 0.00767, "epss_percentile": 0.7295}, "CVE-2007-0968": {"epss_score": 0.01902, "epss_percentile": 0.82784}, "CVE-2007-0969": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0970": {"epss_score": 0.01261, "epss_percentile": 0.78978}, "CVE-2007-0971": {"epss_score": 0.01563, "epss_percentile": 0.81056}, "CVE-2007-0972": {"epss_score": 0.11006, "epss_percentile": 0.93188}, "CVE-2007-0973": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-0974": {"epss_score": 0.00445, "epss_percentile": 0.62857}, "CVE-2007-0975": {"epss_score": 0.00458, "epss_percentile": 0.63431}, "CVE-2007-0976": {"epss_score": 0.40954, "epss_percentile": 0.97246}, "CVE-2007-0977": {"epss_score": 0.70115, "epss_percentile": 0.98618}, "CVE-2007-0978": {"epss_score": 0.0006, "epss_percentile": 0.19195}, "CVE-2007-0979": {"epss_score": 0.00566, "epss_percentile": 0.67814}, "CVE-2007-0980": {"epss_score": 0.01257, "epss_percentile": 0.78946}, "CVE-2007-0981": {"epss_score": 0.16075, "epss_percentile": 0.94568}, "CVE-2007-0982": {"epss_score": 0.02168, "epss_percentile": 0.83859}, "CVE-2007-0983": {"epss_score": 0.11687, "epss_percentile": 0.93449}, "CVE-2007-0984": {"epss_score": 0.01343, "epss_percentile": 0.796}, "CVE-2007-0985": {"epss_score": 0.00602, "epss_percentile": 0.68875}, "CVE-2007-0986": {"epss_score": 0.11422, "epss_percentile": 0.93343}, "CVE-2007-0987": {"epss_score": 0.10487, "epss_percentile": 0.93004}, "CVE-2007-0988": {"epss_score": 0.0188, "epss_percentile": 0.82685}, "CVE-2007-0994": {"epss_score": 0.02601, "epss_percentile": 0.85207}, "CVE-2007-0995": {"epss_score": 0.02103, "epss_percentile": 0.83615}, "CVE-2007-0996": {"epss_score": 0.02513, "epss_percentile": 0.84978}, "CVE-2007-0997": {"epss_score": 0.00036, "epss_percentile": 0.10305}, "CVE-2007-0998": {"epss_score": 0.02215, "epss_percentile": 0.84028}, "CVE-2007-0999": {"epss_score": 0.01943, "epss_percentile": 0.82993}, "CVE-2007-10001": {"epss_score": 0.00451, "epss_percentile": 0.63114}, "CVE-2007-10002": {"epss_score": 0.0007, "epss_percentile": 0.21953}, "CVE-2007-10003": {"epss_score": 0.00129, "epss_percentile": 0.3319}, "CVE-2007-1000": {"epss_score": 0.00276, "epss_percentile": 0.50748}, "CVE-2007-1001": {"epss_score": 0.12056, "epss_percentile": 0.93557}, "CVE-2007-1002": {"epss_score": 0.1249, "epss_percentile": 0.93689}, "CVE-2007-1003": {"epss_score": 0.08011, "epss_percentile": 0.91827}, "CVE-2007-1004": {"epss_score": 0.00894, "epss_percentile": 0.75091}, "CVE-2007-1005": {"epss_score": 0.03105, "epss_percentile": 0.86416}, "CVE-2007-1006": {"epss_score": 0.0389, "epss_percentile": 0.87909}, "CVE-2007-1007": {"epss_score": 0.12771, "epss_percentile": 0.93768}, "CVE-2007-1008": {"epss_score": 0.09013, "epss_percentile": 0.92365}, "CVE-2007-1009": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2007-1010": {"epss_score": 0.18619, "epss_percentile": 0.95044}, "CVE-2007-1011": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2007-1012": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-1013": {"epss_score": 0.07431, "epss_percentile": 0.91472}, "CVE-2007-1014": {"epss_score": 0.33607, "epss_percentile": 0.96788}, "CVE-2007-1015": {"epss_score": 0.00296, "epss_percentile": 0.52559}, "CVE-2007-1016": {"epss_score": 0.00818, "epss_percentile": 0.73862}, "CVE-2007-1017": {"epss_score": 0.13197, "epss_percentile": 0.93897}, "CVE-2007-1018": {"epss_score": 0.00655, "epss_percentile": 0.7042}, "CVE-2007-1019": {"epss_score": 0.0141, "epss_percentile": 0.80079}, "CVE-2007-1020": {"epss_score": 0.13034, "epss_percentile": 0.93852}, "CVE-2007-1021": {"epss_score": 0.00664, "epss_percentile": 0.70627}, "CVE-2007-1022": {"epss_score": 0.00855, "epss_percentile": 0.74464}, "CVE-2007-1023": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-1024": {"epss_score": 0.02587, "epss_percentile": 0.85171}, "CVE-2007-1025": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2007-1026": {"epss_score": 0.02275, "epss_percentile": 0.84225}, "CVE-2007-1027": {"epss_score": 0.00048, "epss_percentile": 0.15133}, "CVE-2007-1028": {"epss_score": 0.01194, "epss_percentile": 0.78421}, "CVE-2007-1029": {"epss_score": 0.22841, "epss_percentile": 0.95697}, "CVE-2007-1030": {"epss_score": 0.01535, "epss_percentile": 0.80906}, "CVE-2007-1031": {"epss_score": 0.04702, "epss_percentile": 0.89027}, "CVE-2007-1032": {"epss_score": 0.00823, "epss_percentile": 0.73928}, "CVE-2007-1033": {"epss_score": 0.00349, "epss_percentile": 0.5687}, "CVE-2007-1034": {"epss_score": 0.01532, "epss_percentile": 0.80892}, "CVE-2007-1035": {"epss_score": 0.01158, "epss_percentile": 0.7812}, "CVE-2007-1036": {"epss_score": 0.90143, "epss_percentile": 0.99565}, "CVE-2007-1037": {"epss_score": 0.10224, "epss_percentile": 0.92901}, "CVE-2007-1038": {"epss_score": 0.00734, "epss_percentile": 0.72247}, "CVE-2007-1039": {"epss_score": 0.00446, "epss_percentile": 0.62907}, "CVE-2007-1040": {"epss_score": 0.12406, "epss_percentile": 0.93661}, "CVE-2007-1041": {"epss_score": 0.37211, "epss_percentile": 0.97028}, "CVE-2007-1042": {"epss_score": 0.00125, "epss_percentile": 0.32476}, "CVE-2007-1043": {"epss_score": 0.06864, "epss_percentile": 0.91081}, "CVE-2007-1044": {"epss_score": 0.08595, "epss_percentile": 0.92141}, "CVE-2007-1045": {"epss_score": 0.01626, "epss_percentile": 0.81427}, "CVE-2007-1046": {"epss_score": 0.0056, "epss_percentile": 0.67654}, "CVE-2007-1047": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2007-1048": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2007-1049": {"epss_score": 0.06232, "epss_percentile": 0.90588}, "CVE-2007-1050": {"epss_score": 0.1292, "epss_percentile": 0.93818}, "CVE-2007-1051": {"epss_score": 0.00074, "epss_percentile": 0.22707}, "CVE-2007-1052": {"epss_score": 0.01602, "epss_percentile": 0.81276}, "CVE-2007-1053": {"epss_score": 0.01626, "epss_percentile": 0.81427}, "CVE-2007-1054": {"epss_score": 0.03188, "epss_percentile": 0.86592}, "CVE-2007-1055": {"epss_score": 0.01657, "epss_percentile": 0.81604}, "CVE-2007-1056": {"epss_score": 0.00028, "epss_percentile": 0.07503}, "CVE-2007-1057": {"epss_score": 0.00226, "epss_percentile": 0.4525}, "CVE-2007-1058": {"epss_score": 0.01026, "epss_percentile": 0.76796}, "CVE-2007-1059": {"epss_score": 0.16388, "epss_percentile": 0.94642}, "CVE-2007-1060": {"epss_score": 0.20069, "epss_percentile": 0.95284}, "CVE-2007-1061": {"epss_score": 0.59076, "epss_percentile": 0.98148}, "CVE-2007-1062": {"epss_score": 0.05729, "epss_percentile": 0.90159}, "CVE-2007-1063": {"epss_score": 0.02866, "epss_percentile": 0.85863}, "CVE-2007-1064": {"epss_score": 0.00073, "epss_percentile": 0.22636}, "CVE-2007-1065": {"epss_score": 0.00073, "epss_percentile": 0.22636}, "CVE-2007-1066": {"epss_score": 0.00073, "epss_percentile": 0.22636}, "CVE-2007-1067": {"epss_score": 0.0008, "epss_percentile": 0.24155}, "CVE-2007-1068": {"epss_score": 0.00094, "epss_percentile": 0.27048}, "CVE-2007-1069": {"epss_score": 0.01223, "epss_percentile": 0.78662}, "CVE-2007-1070": {"epss_score": 0.74756, "epss_percentile": 0.98816}, "CVE-2007-1071": {"epss_score": 0.50698, "epss_percentile": 0.97745}, "CVE-2007-1072": {"epss_score": 0.00099, "epss_percentile": 0.28395}, "CVE-2007-1073": {"epss_score": 0.01185, "epss_percentile": 0.78343}, "CVE-2007-1074": {"epss_score": 0.25118, "epss_percentile": 0.95987}, "CVE-2007-1075": {"epss_score": 0.04673, "epss_percentile": 0.88989}, "CVE-2007-1076": {"epss_score": 0.24325, "epss_percentile": 0.95904}, "CVE-2007-1077": {"epss_score": 0.00599, "epss_percentile": 0.68802}, "CVE-2007-1078": {"epss_score": 0.13657, "epss_percentile": 0.94027}, "CVE-2007-1079": {"epss_score": 0.05504, "epss_percentile": 0.89941}, "CVE-2007-1080": {"epss_score": 0.09283, "epss_percentile": 0.92483}, "CVE-2007-1081": {"epss_score": 0.00698, "epss_percentile": 0.71424}, "CVE-2007-1082": {"epss_score": 0.05263, "epss_percentile": 0.8967}, "CVE-2007-1083": {"epss_score": 0.29003, "epss_percentile": 0.9641}, "CVE-2007-1084": {"epss_score": 0.01091, "epss_percentile": 0.77461}, "CVE-2007-1085": {"epss_score": 0.10445, "epss_percentile": 0.92988}, "CVE-2007-1086": {"epss_score": 0.00065, "epss_percentile": 0.20459}, "CVE-2007-1087": {"epss_score": 0.0008, "epss_percentile": 0.24027}, "CVE-2007-1088": {"epss_score": 0.0008, "epss_percentile": 0.24027}, "CVE-2007-1089": {"epss_score": 0.00052, "epss_percentile": 0.16538}, "CVE-2007-1090": {"epss_score": 0.61344, "epss_percentile": 0.98244}, "CVE-2007-1091": {"epss_score": 0.50053, "epss_percentile": 0.97716}, "CVE-2007-1092": {"epss_score": 0.29308, "epss_percentile": 0.96431}, "CVE-2007-1093": {"epss_score": 0.10052, "epss_percentile": 0.9283}, "CVE-2007-1094": {"epss_score": 0.35114, "epss_percentile": 0.96888}, "CVE-2007-1095": {"epss_score": 0.03638, "epss_percentile": 0.87484}, "CVE-2007-1096": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2007-1097": {"epss_score": 0.00889, "epss_percentile": 0.7502}, "CVE-2007-1098": {"epss_score": 0.00492, "epss_percentile": 0.65005}, "CVE-2007-1099": {"epss_score": 0.01626, "epss_percentile": 0.81427}, "CVE-2007-1100": {"epss_score": 0.07917, "epss_percentile": 0.91762}, "CVE-2007-1101": {"epss_score": 0.00962, "epss_percentile": 0.75984}, "CVE-2007-1102": {"epss_score": 0.00574, "epss_percentile": 0.68078}, "CVE-2007-1103": {"epss_score": 0.00566, "epss_percentile": 0.67814}, "CVE-2007-1104": {"epss_score": 0.06699, "epss_percentile": 0.90955}, "CVE-2007-1105": {"epss_score": 0.06185, "epss_percentile": 0.90541}, "CVE-2007-1106": {"epss_score": 0.0642, "epss_percentile": 0.90749}, "CVE-2007-1107": {"epss_score": 0.02311, "epss_percentile": 0.84338}, "CVE-2007-1108": {"epss_score": 0.1758, "epss_percentile": 0.94871}, "CVE-2007-1109": {"epss_score": 0.00568, "epss_percentile": 0.67888}, "CVE-2007-1110": {"epss_score": 0.05691, "epss_percentile": 0.90124}, "CVE-2007-1111": {"epss_score": 0.02259, "epss_percentile": 0.8418}, "CVE-2007-1112": {"epss_score": 0.04061, "epss_percentile": 0.88189}, "CVE-2007-1114": {"epss_score": 0.20968, "epss_percentile": 0.95447}, "CVE-2007-1115": {"epss_score": 0.00832, "epss_percentile": 0.74063}, "CVE-2007-1116": {"epss_score": 0.0055, "epss_percentile": 0.67346}, "CVE-2007-1117": {"epss_score": 0.40037, "epss_percentile": 0.97191}, "CVE-2007-1118": {"epss_score": 0.11121, "epss_percentile": 0.93228}, "CVE-2007-1119": {"epss_score": 0.0127, "epss_percentile": 0.79046}, "CVE-2007-1120": {"epss_score": 0.00818, "epss_percentile": 0.73854}, "CVE-2007-1121": {"epss_score": 0.00419, "epss_percentile": 0.61374}, "CVE-2007-1122": {"epss_score": 0.0034, "epss_percentile": 0.56243}, "CVE-2007-1123": {"epss_score": 0.01155, "epss_percentile": 0.78079}, "CVE-2007-1124": {"epss_score": 0.04597, "epss_percentile": 0.88899}, "CVE-2007-1125": {"epss_score": 0.03489, "epss_percentile": 0.87229}, "CVE-2007-1126": {"epss_score": 0.07138, "epss_percentile": 0.91276}, "CVE-2007-1127": {"epss_score": 0.0599, "epss_percentile": 0.90385}, "CVE-2007-1128": {"epss_score": 0.00465, "epss_percentile": 0.63748}, "CVE-2007-1129": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2007-1130": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2007-1131": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2007-1132": {"epss_score": 0.00362, "epss_percentile": 0.57757}, "CVE-2007-1133": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2007-1134": {"epss_score": 0.00406, "epss_percentile": 0.6052}, "CVE-2007-1135": {"epss_score": 0.00812, "epss_percentile": 0.73746}, "CVE-2007-1136": {"epss_score": 0.02842, "epss_percentile": 0.85808}, "CVE-2007-1137": {"epss_score": 0.00309, "epss_percentile": 0.53676}, "CVE-2007-1138": {"epss_score": 0.04255, "epss_percentile": 0.88456}, "CVE-2007-1139": {"epss_score": 0.00879, "epss_percentile": 0.74833}, "CVE-2007-1140": {"epss_score": 0.04674, "epss_percentile": 0.8899}, "CVE-2007-1141": {"epss_score": 0.02052, "epss_percentile": 0.83409}, "CVE-2007-1142": {"epss_score": 0.01586, "epss_percentile": 0.81168}, "CVE-2007-1143": {"epss_score": 0.00235, "epss_percentile": 0.46312}, "CVE-2007-1144": {"epss_score": 0.00783, "epss_percentile": 0.73222}, "CVE-2007-1145": {"epss_score": 0.00568, "epss_percentile": 0.67888}, "CVE-2007-1146": {"epss_score": 0.00725, "epss_percentile": 0.72045}, "CVE-2007-1147": {"epss_score": 0.00735, "epss_percentile": 0.72293}, "CVE-2007-1148": {"epss_score": 0.02596, "epss_percentile": 0.85199}, "CVE-2007-1149": {"epss_score": 0.04672, "epss_percentile": 0.88988}, "CVE-2007-1150": {"epss_score": 0.00617, "epss_percentile": 0.69352}, "CVE-2007-1151": {"epss_score": 0.0052, "epss_percentile": 0.66196}, "CVE-2007-1152": {"epss_score": 0.04583, "epss_percentile": 0.8888}, "CVE-2007-1153": {"epss_score": 0.00651, "epss_percentile": 0.70304}, "CVE-2007-1154": {"epss_score": 0.00644, "epss_percentile": 0.70067}, "CVE-2007-1155": {"epss_score": 0.00694, "epss_percentile": 0.71348}, "CVE-2007-1156": {"epss_score": 0.0667, "epss_percentile": 0.90933}, "CVE-2007-1157": {"epss_score": 0.00406, "epss_percentile": 0.60517}, "CVE-2007-1158": {"epss_score": 0.10677, "epss_percentile": 0.93067}, "CVE-2007-1159": {"epss_score": 0.00433, "epss_percentile": 0.62178}, "CVE-2007-1160": {"epss_score": 0.01115, "epss_percentile": 0.77706}, "CVE-2007-1161": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-1162": {"epss_score": 0.05741, "epss_percentile": 0.90172}, "CVE-2007-1163": {"epss_score": 0.00741, "epss_percentile": 0.72414}, "CVE-2007-1164": {"epss_score": 0.09715, "epss_percentile": 0.92675}, "CVE-2007-1165": {"epss_score": 0.11498, "epss_percentile": 0.93384}, "CVE-2007-1166": {"epss_score": 0.01149, "epss_percentile": 0.78022}, "CVE-2007-1167": {"epss_score": 0.12472, "epss_percentile": 0.93683}, "CVE-2007-1168": {"epss_score": 0.01322, "epss_percentile": 0.79451}, "CVE-2007-1169": {"epss_score": 0.0026, "epss_percentile": 0.49199}, "CVE-2007-1170": {"epss_score": 0.01224, "epss_percentile": 0.78676}, "CVE-2007-1171": {"epss_score": 0.00885, "epss_percentile": 0.74941}, "CVE-2007-1172": {"epss_score": 0.0069, "epss_percentile": 0.71252}, "CVE-2007-1173": {"epss_score": 0.23215, "epss_percentile": 0.95752}, "CVE-2007-1174": {"epss_score": 0.00409, "epss_percentile": 0.60724}, "CVE-2007-1175": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-1176": {"epss_score": 0.00809, "epss_percentile": 0.73702}, "CVE-2007-1177": {"epss_score": 0.00637, "epss_percentile": 0.69894}, "CVE-2007-1178": {"epss_score": 0.00743, "epss_percentile": 0.72481}, "CVE-2007-1179": {"epss_score": 0.00488, "epss_percentile": 0.64841}, "CVE-2007-1180": {"epss_score": 0.00488, "epss_percentile": 0.64841}, "CVE-2007-1181": {"epss_score": 0.00488, "epss_percentile": 0.64841}, "CVE-2007-1182": {"epss_score": 0.00488, "epss_percentile": 0.64841}, "CVE-2007-1183": {"epss_score": 0.01035, "epss_percentile": 0.76897}, "CVE-2007-1184": {"epss_score": 0.00488, "epss_percentile": 0.64841}, "CVE-2007-1185": {"epss_score": 0.00488, "epss_percentile": 0.64841}, "CVE-2007-1186": {"epss_score": 0.00488, "epss_percentile": 0.64841}, "CVE-2007-1187": {"epss_score": 0.00357, "epss_percentile": 0.57475}, "CVE-2007-1188": {"epss_score": 0.01035, "epss_percentile": 0.76897}, "CVE-2007-1189": {"epss_score": 0.00254, "epss_percentile": 0.48574}, "CVE-2007-1190": {"epss_score": 0.0511, "epss_percentile": 0.89508}, "CVE-2007-1191": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2007-1192": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2007-1193": {"epss_score": 0.00392, "epss_percentile": 0.59672}, "CVE-2007-1194": {"epss_score": 0.00071, "epss_percentile": 0.21999}, "CVE-2007-1195": {"epss_score": 0.3619, "epss_percentile": 0.96959}, "CVE-2007-1196": {"epss_score": 0.01815, "epss_percentile": 0.82384}, "CVE-2007-1197": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2007-1198": {"epss_score": 0.00286, "epss_percentile": 0.51715}, "CVE-2007-1199": {"epss_score": 0.24664, "epss_percentile": 0.95944}, "CVE-2007-1201": {"epss_score": 0.45718, "epss_percentile": 0.97499}, "CVE-2007-1202": {"epss_score": 0.58526, "epss_percentile": 0.98122}, "CVE-2007-1203": {"epss_score": 0.61103, "epss_percentile": 0.98235}, "CVE-2007-1204": {"epss_score": 0.05987, "epss_percentile": 0.90383}, "CVE-2007-1205": {"epss_score": 0.62319, "epss_percentile": 0.98288}, "CVE-2007-1206": {"epss_score": 0.01753, "epss_percentile": 0.82115}, "CVE-2007-1209": {"epss_score": 0.02113, "epss_percentile": 0.83651}, "CVE-2007-1211": {"epss_score": 0.71652, "epss_percentile": 0.98676}, "CVE-2007-1212": {"epss_score": 0.01861, "epss_percentile": 0.82593}, "CVE-2007-1213": {"epss_score": 0.01491, "epss_percentile": 0.80632}, "CVE-2007-1214": {"epss_score": 0.57262, "epss_percentile": 0.98055}, "CVE-2007-1215": {"epss_score": 0.02495, "epss_percentile": 0.84906}, "CVE-2007-1216": {"epss_score": 0.16067, "epss_percentile": 0.94566}, "CVE-2007-1217": {"epss_score": 0.00115, "epss_percentile": 0.3097}, "CVE-2007-1218": {"epss_score": 0.20276, "epss_percentile": 0.95312}, "CVE-2007-1219": {"epss_score": 0.08511, "epss_percentile": 0.92095}, "CVE-2007-1220": {"epss_score": 0.00475, "epss_percentile": 0.64186}, "CVE-2007-1221": {"epss_score": 0.00909, "epss_percentile": 0.75292}, "CVE-2007-1222": {"epss_score": 0.00056, "epss_percentile": 0.17867}, "CVE-2007-1223": {"epss_score": 0.00627, "epss_percentile": 0.69636}, "CVE-2007-1224": {"epss_score": 0.02303, "epss_percentile": 0.84316}, "CVE-2007-1225": {"epss_score": 0.06117, "epss_percentile": 0.90491}, "CVE-2007-1226": {"epss_score": 0.00055, "epss_percentile": 0.17545}, "CVE-2007-1227": {"epss_score": 0.00123, "epss_percentile": 0.32202}, "CVE-2007-1228": {"epss_score": 0.00059, "epss_percentile": 0.1884}, "CVE-2007-1229": {"epss_score": 0.04305, "epss_percentile": 0.88521}, "CVE-2007-1230": {"epss_score": 0.0056, "epss_percentile": 0.67636}, "CVE-2007-1231": {"epss_score": 0.01923, "epss_percentile": 0.82911}, "CVE-2007-1232": {"epss_score": 0.82575, "epss_percentile": 0.992}, "CVE-2007-1233": {"epss_score": 0.11687, "epss_percentile": 0.93449}, "CVE-2007-1234": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-1235": {"epss_score": 0.00702, "epss_percentile": 0.71516}, "CVE-2007-1236": {"epss_score": 0.00377, "epss_percentile": 0.58742}, "CVE-2007-1237": {"epss_score": 0.00376, "epss_percentile": 0.58681}, "CVE-2007-1238": {"epss_score": 0.20663, "epss_percentile": 0.95396}, "CVE-2007-1239": {"epss_score": 0.16035, "epss_percentile": 0.94562}, "CVE-2007-1240": {"epss_score": 0.01854, "epss_percentile": 0.82553}, "CVE-2007-1241": {"epss_score": 0.02168, "epss_percentile": 0.83859}, "CVE-2007-1242": {"epss_score": 0.00416, "epss_percentile": 0.61183}, "CVE-2007-1243": {"epss_score": 0.04917, "epss_percentile": 0.89287}, "CVE-2007-1244": {"epss_score": 0.07986, "epss_percentile": 0.91806}, "CVE-2007-1245": {"epss_score": 0.00848, "epss_percentile": 0.74362}, "CVE-2007-1246": {"epss_score": 0.09304, "epss_percentile": 0.92492}, "CVE-2007-1247": {"epss_score": 0.06225, "epss_percentile": 0.90584}, "CVE-2007-1248": {"epss_score": 0.04887, "epss_percentile": 0.89256}, "CVE-2007-1249": {"epss_score": 0.00785, "epss_percentile": 0.73246}, "CVE-2007-1250": {"epss_score": 0.0185, "epss_percentile": 0.82534}, "CVE-2007-1251": {"epss_score": 0.11695, "epss_percentile": 0.93451}, "CVE-2007-1252": {"epss_score": 0.11468, "epss_percentile": 0.93376}, "CVE-2007-1253": {"epss_score": 0.02739, "epss_percentile": 0.85557}, "CVE-2007-1254": {"epss_score": 0.00688, "epss_percentile": 0.71193}, "CVE-2007-1255": {"epss_score": 0.00685, "epss_percentile": 0.71147}, "CVE-2007-1256": {"epss_score": 0.0081, "epss_percentile": 0.73715}, "CVE-2007-1257": {"epss_score": 0.03113, "epss_percentile": 0.86429}, "CVE-2007-1258": {"epss_score": 0.00588, "epss_percentile": 0.68489}, "CVE-2007-1259": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2007-1260": {"epss_score": 0.23405, "epss_percentile": 0.95774}, "CVE-2007-1261": {"epss_score": 0.00459, "epss_percentile": 0.63468}, "CVE-2007-1262": {"epss_score": 0.01021, "epss_percentile": 0.7675}, "CVE-2007-1263": {"epss_score": 0.18262, "epss_percentile": 0.94983}, "CVE-2007-1264": {"epss_score": 0.10128, "epss_percentile": 0.92861}, "CVE-2007-1265": {"epss_score": 0.01013, "epss_percentile": 0.76633}, "CVE-2007-1266": {"epss_score": 0.03021, "epss_percentile": 0.86226}, "CVE-2007-1267": {"epss_score": 0.01055, "epss_percentile": 0.77114}, "CVE-2007-1268": {"epss_score": 0.01225, "epss_percentile": 0.7868}, "CVE-2007-1269": {"epss_score": 0.01225, "epss_percentile": 0.7868}, "CVE-2007-1270": {"epss_score": 0.00528, "epss_percentile": 0.66543}, "CVE-2007-1271": {"epss_score": 0.00046, "epss_percentile": 0.14203}, "CVE-2007-1273": {"epss_score": 0.00052, "epss_percentile": 0.16481}, "CVE-2007-1276": {"epss_score": 0.00258, "epss_percentile": 0.49025}, "CVE-2007-1277": {"epss_score": 0.84865, "epss_percentile": 0.99308}, "CVE-2007-1278": {"epss_score": 0.04688, "epss_percentile": 0.89009}, "CVE-2007-1279": {"epss_score": 0.00174, "epss_percentile": 0.39165}, "CVE-2007-1280": {"epss_score": 0.03931, "epss_percentile": 0.87972}, "CVE-2007-1281": {"epss_score": 0.01589, "epss_percentile": 0.81193}, "CVE-2007-1282": {"epss_score": 0.03431, "epss_percentile": 0.87124}, "CVE-2007-1285": {"epss_score": 0.08632, "epss_percentile": 0.92163}, "CVE-2007-1286": {"epss_score": 0.80662, "epss_percentile": 0.991}, "CVE-2007-1287": {"epss_score": 0.2312, "epss_percentile": 0.95736}, "CVE-2007-1288": {"epss_score": 0.02075, "epss_percentile": 0.83506}, "CVE-2007-1289": {"epss_score": 0.00988, "epss_percentile": 0.76353}, "CVE-2007-1290": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2007-1291": {"epss_score": 0.06621, "epss_percentile": 0.90895}, "CVE-2007-1292": {"epss_score": 0.01462, "epss_percentile": 0.80438}, "CVE-2007-1293": {"epss_score": 0.01563, "epss_percentile": 0.81056}, "CVE-2007-1294": {"epss_score": 0.05741, "epss_percentile": 0.90172}, "CVE-2007-1295": {"epss_score": 0.01252, "epss_percentile": 0.7891}, "CVE-2007-1296": {"epss_score": 0.00714, "epss_percentile": 0.71813}, "CVE-2007-1297": {"epss_score": 0.02311, "epss_percentile": 0.84338}, "CVE-2007-1298": {"epss_score": 0.01294, "epss_percentile": 0.79247}, "CVE-2007-1299": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2007-1300": {"epss_score": 0.00358, "epss_percentile": 0.57498}, "CVE-2007-1301": {"epss_score": 0.05429, "epss_percentile": 0.89872}, "CVE-2007-1302": {"epss_score": 0.01073, "epss_percentile": 0.77294}, "CVE-2007-1303": {"epss_score": 0.10415, "epss_percentile": 0.92981}, "CVE-2007-1304": {"epss_score": 0.0107, "epss_percentile": 0.77255}, "CVE-2007-1305": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-1306": {"epss_score": 0.19292, "epss_percentile": 0.95161}, "CVE-2007-1307": {"epss_score": 0.00403, "epss_percentile": 0.60326}, "CVE-2007-1308": {"epss_score": 0.14251, "epss_percentile": 0.94171}, "CVE-2007-1309": {"epss_score": 0.00526, "epss_percentile": 0.66404}, "CVE-2007-1313": {"epss_score": 0.03332, "epss_percentile": 0.8693}, "CVE-2007-1319": {"epss_score": 0.46214, "epss_percentile": 0.97536}, "CVE-2007-1320": {"epss_score": 0.00164, "epss_percentile": 0.37993}, "CVE-2007-1321": {"epss_score": 0.00041, "epss_percentile": 0.12422}, "CVE-2007-1322": {"epss_score": 0.00119, "epss_percentile": 0.31565}, "CVE-2007-1324": {"epss_score": 0.01224, "epss_percentile": 0.78676}, "CVE-2007-1325": {"epss_score": 0.00789, "epss_percentile": 0.73346}, "CVE-2007-1326": {"epss_score": 0.00484, "epss_percentile": 0.64627}, "CVE-2007-1327": {"epss_score": 0.13083, "epss_percentile": 0.93869}, "CVE-2007-1328": {"epss_score": 0.00402, "epss_percentile": 0.60285}, "CVE-2007-1329": {"epss_score": 0.07066, "epss_percentile": 0.91224}, "CVE-2007-1330": {"epss_score": 0.00197, "epss_percentile": 0.41964}, "CVE-2007-1331": {"epss_score": 0.0264, "epss_percentile": 0.85301}, "CVE-2007-1332": {"epss_score": 0.00922, "epss_percentile": 0.75491}, "CVE-2007-1337": {"epss_score": 0.01196, "epss_percentile": 0.78439}, "CVE-2007-1338": {"epss_score": 0.00468, "epss_percentile": 0.63878}, "CVE-2007-1339": {"epss_score": 0.02233, "epss_percentile": 0.84094}, "CVE-2007-1340": {"epss_score": 0.05689, "epss_percentile": 0.90122}, "CVE-2007-1341": {"epss_score": 0.00602, "epss_percentile": 0.68896}, "CVE-2007-1342": {"epss_score": 0.00402, "epss_percentile": 0.60285}, "CVE-2007-1343": {"epss_score": 0.02109, "epss_percentile": 0.83641}, "CVE-2007-1344": {"epss_score": 0.0616, "epss_percentile": 0.90526}, "CVE-2007-1345": {"epss_score": 0.00088, "epss_percentile": 0.25696}, "CVE-2007-1346": {"epss_score": 0.00053, "epss_percentile": 0.16875}, "CVE-2007-1347": {"epss_score": 0.59437, "epss_percentile": 0.98164}, "CVE-2007-1349": {"epss_score": 0.17687, "epss_percentile": 0.94889}, "CVE-2007-1350": {"epss_score": 0.67648, "epss_percentile": 0.98516}, "CVE-2007-1351": {"epss_score": 0.07768, "epss_percentile": 0.91672}, "CVE-2007-1352": {"epss_score": 0.01378, "epss_percentile": 0.7985}, "CVE-2007-1353": {"epss_score": 0.00098, "epss_percentile": 0.27826}, "CVE-2007-1354": {"epss_score": 0.00699, "epss_percentile": 0.71441}, "CVE-2007-1355": {"epss_score": 0.833, "epss_percentile": 0.99243}, "CVE-2007-1357": {"epss_score": 0.0931, "epss_percentile": 0.92495}, "CVE-2007-1358": {"epss_score": 0.39862, "epss_percentile": 0.97184}, "CVE-2007-1359": {"epss_score": 0.23038, "epss_percentile": 0.95723}, "CVE-2007-1360": {"epss_score": 0.01488, "epss_percentile": 0.80619}, "CVE-2007-1361": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-1362": {"epss_score": 0.45036, "epss_percentile": 0.97468}, "CVE-2007-1363": {"epss_score": 0.00584, "epss_percentile": 0.68358}, "CVE-2007-1364": {"epss_score": 0.04597, "epss_percentile": 0.88899}, "CVE-2007-1365": {"epss_score": 0.43402, "epss_percentile": 0.97385}, "CVE-2007-1366": {"epss_score": 0.00092, "epss_percentile": 0.26413}, "CVE-2007-1367": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-1368": {"epss_score": 0.00404, "epss_percentile": 0.60453}, "CVE-2007-1369": {"epss_score": 0.00242, "epss_percentile": 0.47399}, "CVE-2007-1370": {"epss_score": 0.00053, "epss_percentile": 0.17036}, "CVE-2007-1371": {"epss_score": 0.00224, "epss_percentile": 0.45008}, "CVE-2007-1372": {"epss_score": 0.04826, "epss_percentile": 0.89185}, "CVE-2007-1373": {"epss_score": 0.77954, "epss_percentile": 0.98962}, "CVE-2007-1374": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-1375": {"epss_score": 0.15389, "epss_percentile": 0.94422}, "CVE-2007-1376": {"epss_score": 0.13846, "epss_percentile": 0.94075}, "CVE-2007-1377": {"epss_score": 0.17208, "epss_percentile": 0.948}, "CVE-2007-1378": {"epss_score": 0.00597, "epss_percentile": 0.68749}, "CVE-2007-1379": {"epss_score": 0.01063, "epss_percentile": 0.77192}, "CVE-2007-1380": {"epss_score": 0.12708, "epss_percentile": 0.93754}, "CVE-2007-1381": {"epss_score": 0.04731, "epss_percentile": 0.89069}, "CVE-2007-1382": {"epss_score": 0.002, "epss_percentile": 0.42271}, "CVE-2007-1383": {"epss_score": 0.02569, "epss_percentile": 0.85123}, "CVE-2007-1384": {"epss_score": 0.01206, "epss_percentile": 0.78518}, "CVE-2007-1385": {"epss_score": 0.04752, "epss_percentile": 0.89105}, "CVE-2007-1387": {"epss_score": 0.05109, "epss_percentile": 0.89508}, "CVE-2007-1388": {"epss_score": 0.00147, "epss_percentile": 0.35702}, "CVE-2007-1389": {"epss_score": 0.00235, "epss_percentile": 0.46224}, "CVE-2007-1390": {"epss_score": 0.00402, "epss_percentile": 0.60285}, "CVE-2007-1391": {"epss_score": 0.06756, "epss_percentile": 0.91006}, "CVE-2007-1392": {"epss_score": 0.07366, "epss_percentile": 0.91437}, "CVE-2007-1393": {"epss_score": 0.10911, "epss_percentile": 0.93154}, "CVE-2007-1394": {"epss_score": 0.10749, "epss_percentile": 0.93092}, "CVE-2007-1395": {"epss_score": 0.017, "epss_percentile": 0.81831}, "CVE-2007-1396": {"epss_score": 0.02036, "epss_percentile": 0.83354}, "CVE-2007-1397": {"epss_score": 0.25135, "epss_percentile": 0.95989}, "CVE-2007-1398": {"epss_score": 0.05741, "epss_percentile": 0.90172}, "CVE-2007-1399": {"epss_score": 0.3902, "epss_percentile": 0.97135}, "CVE-2007-1400": {"epss_score": 0.00058, "epss_percentile": 0.1857}, "CVE-2007-1401": {"epss_score": 0.00102, "epss_percentile": 0.28794}, "CVE-2007-1402": {"epss_score": 0.03487, "epss_percentile": 0.87228}, "CVE-2007-1403": {"epss_score": 0.21529, "epss_percentile": 0.9553}, "CVE-2007-1404": {"epss_score": 0.21067, "epss_percentile": 0.95459}, "CVE-2007-1405": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-1406": {"epss_score": 0.00507, "epss_percentile": 0.65677}, "CVE-2007-1407": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2007-1408": {"epss_score": 0.00444, "epss_percentile": 0.62837}, "CVE-2007-1409": {"epss_score": 0.00582, "epss_percentile": 0.68312}, "CVE-2007-1410": {"epss_score": 0.01039, "epss_percentile": 0.76947}, "CVE-2007-1411": {"epss_score": 0.1342, "epss_percentile": 0.93958}, "CVE-2007-1412": {"epss_score": 0.03951, "epss_percentile": 0.88001}, "CVE-2007-1413": {"epss_score": 0.15593, "epss_percentile": 0.94466}, "CVE-2007-1414": {"epss_score": 0.0527, "epss_percentile": 0.89679}, "CVE-2007-1415": {"epss_score": 0.09808, "epss_percentile": 0.92709}, "CVE-2007-1416": {"epss_score": 0.02156, "epss_percentile": 0.8381}, "CVE-2007-1417": {"epss_score": 0.01563, "epss_percentile": 0.81056}, "CVE-2007-1418": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-1419": {"epss_score": 0.00352, "epss_percentile": 0.57131}, "CVE-2007-1420": {"epss_score": 0.00067, "epss_percentile": 0.21028}, "CVE-2007-1421": {"epss_score": 0.0473, "epss_percentile": 0.89068}, "CVE-2007-1422": {"epss_score": 0.0076, "epss_percentile": 0.72804}, "CVE-2007-1423": {"epss_score": 0.05498, "epss_percentile": 0.89936}, "CVE-2007-1424": {"epss_score": 0.02238, "epss_percentile": 0.84105}, "CVE-2007-1425": {"epss_score": 0.01039, "epss_percentile": 0.76947}, "CVE-2007-1426": {"epss_score": 0.01763, "epss_percentile": 0.82156}, "CVE-2007-1427": {"epss_score": 0.06088, "epss_percentile": 0.90471}, "CVE-2007-1428": {"epss_score": 0.01005, "epss_percentile": 0.76539}, "CVE-2007-1429": {"epss_score": 0.0069, "epss_percentile": 0.71256}, "CVE-2007-1430": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2007-1431": {"epss_score": 0.00564, "epss_percentile": 0.67753}, "CVE-2007-1432": {"epss_score": 0.02661, "epss_percentile": 0.85368}, "CVE-2007-1433": {"epss_score": 0.01859, "epss_percentile": 0.82584}, "CVE-2007-1434": {"epss_score": 0.00339, "epss_percentile": 0.56178}, "CVE-2007-1435": {"epss_score": 0.6949, "epss_percentile": 0.98589}, "CVE-2007-1436": {"epss_score": 0.00869, "epss_percentile": 0.74683}, "CVE-2007-1437": {"epss_score": 0.01501, "epss_percentile": 0.80716}, "CVE-2007-1438": {"epss_score": 0.00629, "epss_percentile": 0.69667}, "CVE-2007-1439": {"epss_score": 0.10275, "epss_percentile": 0.92922}, "CVE-2007-1440": {"epss_score": 0.00714, "epss_percentile": 0.71813}, "CVE-2007-1441": {"epss_score": 0.01663, "epss_percentile": 0.81639}, "CVE-2007-1442": {"epss_score": 0.0076, "epss_percentile": 0.72815}, "CVE-2007-1443": {"epss_score": 0.00583, "epss_percentile": 0.68334}, "CVE-2007-1444": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2007-1445": {"epss_score": 0.01243, "epss_percentile": 0.78827}, "CVE-2007-1446": {"epss_score": 0.06752, "epss_percentile": 0.91003}, "CVE-2007-1447": {"epss_score": 0.41464, "epss_percentile": 0.97275}, "CVE-2007-1448": {"epss_score": 0.01406, "epss_percentile": 0.80051}, "CVE-2007-1449": {"epss_score": 0.0057, "epss_percentile": 0.67945}, "CVE-2007-1450": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2007-1451": {"epss_score": 0.00836, "epss_percentile": 0.74131}, "CVE-2007-1452": {"epss_score": 0.10158, "epss_percentile": 0.92869}, "CVE-2007-1453": {"epss_score": 0.02792, "epss_percentile": 0.8567}, "CVE-2007-1454": {"epss_score": 0.00476, "epss_percentile": 0.64263}, "CVE-2007-1455": {"epss_score": 0.03107, "epss_percentile": 0.86421}, "CVE-2007-1456": {"epss_score": 0.01019, "epss_percentile": 0.76729}, "CVE-2007-1457": {"epss_score": 0.01596, "epss_percentile": 0.8124}, "CVE-2007-1458": {"epss_score": 0.23093, "epss_percentile": 0.95733}, "CVE-2007-1459": {"epss_score": 0.09515, "epss_percentile": 0.92581}, "CVE-2007-1460": {"epss_score": 0.01052, "epss_percentile": 0.77091}, "CVE-2007-1461": {"epss_score": 0.01051, "epss_percentile": 0.77076}, "CVE-2007-1462": {"epss_score": 0.00326, "epss_percentile": 0.5508}, "CVE-2007-1463": {"epss_score": 0.11261, "epss_percentile": 0.93282}, "CVE-2007-1464": {"epss_score": 0.09163, "epss_percentile": 0.92428}, "CVE-2007-1465": {"epss_score": 0.2688, "epss_percentile": 0.96187}, "CVE-2007-1466": {"epss_score": 0.12168, "epss_percentile": 0.93589}, "CVE-2007-1467": {"epss_score": 0.00558, "epss_percentile": 0.6758}, "CVE-2007-1468": {"epss_score": 0.00482, "epss_percentile": 0.64551}, "CVE-2007-1469": {"epss_score": 0.0144, "epss_percentile": 0.80301}, "CVE-2007-1470": {"epss_score": 0.05335, "epss_percentile": 0.89742}, "CVE-2007-1471": {"epss_score": 0.0333, "epss_percentile": 0.86926}, "CVE-2007-1472": {"epss_score": 0.13557, "epss_percentile": 0.93996}, "CVE-2007-1473": {"epss_score": 0.02776, "epss_percentile": 0.85638}, "CVE-2007-1474": {"epss_score": 0.01716, "epss_percentile": 0.819}, "CVE-2007-1475": {"epss_score": 0.01698, "epss_percentile": 0.81822}, "CVE-2007-1476": {"epss_score": 0.00286, "epss_percentile": 0.51716}, "CVE-2007-1477": {"epss_score": 0.0068, "epss_percentile": 0.71026}, "CVE-2007-1478": {"epss_score": 0.06088, "epss_percentile": 0.90471}, "CVE-2007-1479": {"epss_score": 0.0393, "epss_percentile": 0.87971}, "CVE-2007-1480": {"epss_score": 0.06686, "epss_percentile": 0.90946}, "CVE-2007-1481": {"epss_score": 0.00531, "epss_percentile": 0.66653}, "CVE-2007-1482": {"epss_score": 0.04287, "epss_percentile": 0.88495}, "CVE-2007-1483": {"epss_score": 0.08443, "epss_percentile": 0.92054}, "CVE-2007-1484": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2007-1485": {"epss_score": 0.01131, "epss_percentile": 0.77856}, "CVE-2007-1486": {"epss_score": 0.02163, "epss_percentile": 0.83835}, "CVE-2007-1487": {"epss_score": 0.12122, "epss_percentile": 0.93572}, "CVE-2007-1488": {"epss_score": 0.01322, "epss_percentile": 0.79451}, "CVE-2007-1489": {"epss_score": 0.00671, "epss_percentile": 0.70795}, "CVE-2007-1490": {"epss_score": 0.03175, "epss_percentile": 0.86561}, "CVE-2007-1491": {"epss_score": 0.00106, "epss_percentile": 0.29526}, "CVE-2007-1492": {"epss_score": 0.29162, "epss_percentile": 0.96422}, "CVE-2007-1493": {"epss_score": 0.03475, "epss_percentile": 0.87206}, "CVE-2007-1494": {"epss_score": 0.00834, "epss_percentile": 0.74104}, "CVE-2007-1495": {"epss_score": 0.0007, "epss_percentile": 0.21878}, "CVE-2007-1496": {"epss_score": 0.00056, "epss_percentile": 0.17777}, "CVE-2007-1497": {"epss_score": 0.0202, "epss_percentile": 0.83291}, "CVE-2007-1498": {"epss_score": 0.2808, "epss_percentile": 0.96307}, "CVE-2007-1499": {"epss_score": 0.66332, "epss_percentile": 0.98459}, "CVE-2007-1500": {"epss_score": 0.00065, "epss_percentile": 0.20615}, "CVE-2007-1501": {"epss_score": 0.1434, "epss_percentile": 0.94191}, "CVE-2007-1502": {"epss_score": 0.05119, "epss_percentile": 0.89516}, "CVE-2007-1503": {"epss_score": 0.02369, "epss_percentile": 0.84522}, "CVE-2007-1504": {"epss_score": 0.00828, "epss_percentile": 0.73997}, "CVE-2007-1505": {"epss_score": 0.00044, "epss_percentile": 0.13382}, "CVE-2007-1506": {"epss_score": 0.18179, "epss_percentile": 0.94971}, "CVE-2007-1507": {"epss_score": 0.01381, "epss_percentile": 0.79867}, "CVE-2007-1508": {"epss_score": 0.00474, "epss_percentile": 0.64169}, "CVE-2007-1509": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2007-1510": {"epss_score": 0.03118, "epss_percentile": 0.86439}, "CVE-2007-1511": {"epss_score": 0.06849, "epss_percentile": 0.91071}, "CVE-2007-1512": {"epss_score": 0.25334, "epss_percentile": 0.96014}, "CVE-2007-1513": {"epss_score": 0.11917, "epss_percentile": 0.93516}, "CVE-2007-1514": {"epss_score": 0.03423, "epss_percentile": 0.87108}, "CVE-2007-1515": {"epss_score": 0.01187, "epss_percentile": 0.78353}, "CVE-2007-1516": {"epss_score": 0.0642, "epss_percentile": 0.90749}, "CVE-2007-1517": {"epss_score": 0.01295, "epss_percentile": 0.79252}, "CVE-2007-1518": {"epss_score": 0.00362, "epss_percentile": 0.57797}, "CVE-2007-1519": {"epss_score": 0.00425, "epss_percentile": 0.61695}, "CVE-2007-1520": {"epss_score": 0.00651, "epss_percentile": 0.70293}, "CVE-2007-1521": {"epss_score": 0.15262, "epss_percentile": 0.94394}, "CVE-2007-1522": {"epss_score": 0.08006, "epss_percentile": 0.91824}, "CVE-2007-1523": {"epss_score": 0.00469, "epss_percentile": 0.63935}, "CVE-2007-1524": {"epss_score": 0.06187, "epss_percentile": 0.90544}, "CVE-2007-1525": {"epss_score": 0.04865, "epss_percentile": 0.89227}, "CVE-2007-1526": {"epss_score": 0.00233, "epss_percentile": 0.46033}, "CVE-2007-1527": {"epss_score": 0.24522, "epss_percentile": 0.95929}, "CVE-2007-1528": {"epss_score": 0.24522, "epss_percentile": 0.95929}, "CVE-2007-1529": {"epss_score": 0.19602, "epss_percentile": 0.95213}, "CVE-2007-1530": {"epss_score": 0.30441, "epss_percentile": 0.96539}, "CVE-2007-1531": {"epss_score": 0.53038, "epss_percentile": 0.97853}, "CVE-2007-1532": {"epss_score": 0.24522, "epss_percentile": 0.95929}, "CVE-2007-1533": {"epss_score": 0.24522, "epss_percentile": 0.95929}, "CVE-2007-1534": {"epss_score": 0.39126, "epss_percentile": 0.97142}, "CVE-2007-1535": {"epss_score": 0.28127, "epss_percentile": 0.96313}, "CVE-2007-1536": {"epss_score": 0.42282, "epss_percentile": 0.97323}, "CVE-2007-1537": {"epss_score": 0.0104, "epss_percentile": 0.76957}, "CVE-2007-1538": {"epss_score": 0.0022, "epss_percentile": 0.44617}, "CVE-2007-1539": {"epss_score": 0.10593, "epss_percentile": 0.93039}, "CVE-2007-1540": {"epss_score": 0.08021, "epss_percentile": 0.91834}, "CVE-2007-1541": {"epss_score": 0.00454, "epss_percentile": 0.63254}, "CVE-2007-1542": {"epss_score": 0.20891, "epss_percentile": 0.95434}, "CVE-2007-1543": {"epss_score": 0.07991, "epss_percentile": 0.9181}, "CVE-2007-1544": {"epss_score": 0.07628, "epss_percentile": 0.91582}, "CVE-2007-1545": {"epss_score": 0.0554, "epss_percentile": 0.89978}, "CVE-2007-1546": {"epss_score": 0.06763, "epss_percentile": 0.9101}, "CVE-2007-1547": {"epss_score": 0.04052, "epss_percentile": 0.88177}, "CVE-2007-1548": {"epss_score": 0.00902, "epss_percentile": 0.75191}, "CVE-2007-1549": {"epss_score": 0.00823, "epss_percentile": 0.73928}, "CVE-2007-1550": {"epss_score": 0.01849, "epss_percentile": 0.82528}, "CVE-2007-1551": {"epss_score": 0.00791, "epss_percentile": 0.73387}, "CVE-2007-1552": {"epss_score": 0.18265, "epss_percentile": 0.94985}, "CVE-2007-1553": {"epss_score": 0.02056, "epss_percentile": 0.83425}, "CVE-2007-1554": {"epss_score": 0.00707, "epss_percentile": 0.71647}, "CVE-2007-1555": {"epss_score": 0.00407, "epss_percentile": 0.60581}, "CVE-2007-1556": {"epss_score": 0.00294, "epss_percentile": 0.52422}, "CVE-2007-1557": {"epss_score": 0.00062, "epss_percentile": 0.19756}, "CVE-2007-1558": {"epss_score": 0.1342, "epss_percentile": 0.93958}, "CVE-2007-1559": {"epss_score": 0.6571, "epss_percentile": 0.98434}, "CVE-2007-1560": {"epss_score": 0.67299, "epss_percentile": 0.985}, "CVE-2007-1561": {"epss_score": 0.20671, "epss_percentile": 0.95399}, "CVE-2007-1562": {"epss_score": 0.29809, "epss_percentile": 0.96477}, "CVE-2007-1563": {"epss_score": 0.10432, "epss_percentile": 0.92985}, "CVE-2007-1564": {"epss_score": 0.09062, "epss_percentile": 0.92384}, "CVE-2007-1565": {"epss_score": 0.00654, "epss_percentile": 0.70347}, "CVE-2007-1566": {"epss_score": 0.00604, "epss_percentile": 0.68959}, "CVE-2007-1567": {"epss_score": 0.03773, "epss_percentile": 0.87705}, "CVE-2007-1568": {"epss_score": 0.41932, "epss_percentile": 0.97302}, "CVE-2007-1569": {"epss_score": 0.28662, "epss_percentile": 0.96375}, "CVE-2007-1571": {"epss_score": 0.06135, "epss_percentile": 0.90506}, "CVE-2007-1572": {"epss_score": 0.00818, "epss_percentile": 0.73862}, "CVE-2007-1573": {"epss_score": 0.00484, "epss_percentile": 0.64631}, "CVE-2007-1574": {"epss_score": 0.00333, "epss_percentile": 0.55672}, "CVE-2007-1575": {"epss_score": 0.01219, "epss_percentile": 0.78611}, "CVE-2007-1576": {"epss_score": 0.00893, "epss_percentile": 0.75079}, "CVE-2007-1577": {"epss_score": 0.06088, "epss_percentile": 0.90471}, "CVE-2007-1578": {"epss_score": 0.47421, "epss_percentile": 0.97586}, "CVE-2007-1579": {"epss_score": 0.49931, "epss_percentile": 0.97711}, "CVE-2007-1580": {"epss_score": 0.08108, "epss_percentile": 0.91883}, "CVE-2007-1581": {"epss_score": 0.10452, "epss_percentile": 0.9299}, "CVE-2007-1582": {"epss_score": 0.0327, "epss_percentile": 0.86791}, "CVE-2007-1583": {"epss_score": 0.21389, "epss_percentile": 0.95512}, "CVE-2007-1584": {"epss_score": 0.03127, "epss_percentile": 0.86457}, "CVE-2007-1585": {"epss_score": 0.00465, "epss_percentile": 0.63748}, "CVE-2007-1586": {"epss_score": 0.04754, "epss_percentile": 0.89107}, "CVE-2007-1587": {"epss_score": 0.00916, "epss_percentile": 0.75418}, "CVE-2007-1588": {"epss_score": 0.0069, "epss_percentile": 0.71256}, "CVE-2007-1589": {"epss_score": 0.00058, "epss_percentile": 0.18432}, "CVE-2007-1590": {"epss_score": 0.07719, "epss_percentile": 0.91642}, "CVE-2007-1591": {"epss_score": 0.00994, "epss_percentile": 0.76427}, "CVE-2007-1592": {"epss_score": 0.00158, "epss_percentile": 0.37257}, "CVE-2007-1593": {"epss_score": 0.03687, "epss_percentile": 0.87572}, "CVE-2007-1594": {"epss_score": 0.04951, "epss_percentile": 0.89323}, "CVE-2007-1595": {"epss_score": 0.00816, "epss_percentile": 0.73799}, "CVE-2007-1596": {"epss_score": 0.00502, "epss_percentile": 0.65415}, "CVE-2007-1597": {"epss_score": 0.00333, "epss_percentile": 0.5562}, "CVE-2007-1598": {"epss_score": 0.05781, "epss_percentile": 0.90202}, "CVE-2007-1599": {"epss_score": 0.01385, "epss_percentile": 0.79903}, "CVE-2007-1600": {"epss_score": 0.05235, "epss_percentile": 0.89645}, "CVE-2007-1601": {"epss_score": 0.00323, "epss_percentile": 0.54876}, "CVE-2007-1602": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2007-1603": {"epss_score": 0.00551, "epss_percentile": 0.67354}, "CVE-2007-1604": {"epss_score": 0.05078, "epss_percentile": 0.89469}, "CVE-2007-1605": {"epss_score": 0.00537, "epss_percentile": 0.66891}, "CVE-2007-1606": {"epss_score": 0.00856, "epss_percentile": 0.74479}, "CVE-2007-1607": {"epss_score": 0.0059, "epss_percentile": 0.68552}, "CVE-2007-1608": {"epss_score": 0.01135, "epss_percentile": 0.77911}, "CVE-2007-1609": {"epss_score": 0.00647, "epss_percentile": 0.70204}, "CVE-2007-1610": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-1611": {"epss_score": 0.00323, "epss_percentile": 0.54874}, "CVE-2007-1612": {"epss_score": 0.01462, "epss_percentile": 0.80438}, "CVE-2007-1613": {"epss_score": 0.07551, "epss_percentile": 0.91537}, "CVE-2007-1614": {"epss_score": 0.06175, "epss_percentile": 0.90532}, "CVE-2007-1615": {"epss_score": 0.00621, "epss_percentile": 0.69481}, "CVE-2007-1616": {"epss_score": 0.01462, "epss_percentile": 0.80438}, "CVE-2007-1617": {"epss_score": 0.00793, "epss_percentile": 0.73435}, "CVE-2007-1618": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-1619": {"epss_score": 0.01252, "epss_percentile": 0.7891}, "CVE-2007-1620": {"epss_score": 0.04876, "epss_percentile": 0.8924}, "CVE-2007-1621": {"epss_score": 0.04373, "epss_percentile": 0.88612}, "CVE-2007-1622": {"epss_score": 0.03283, "epss_percentile": 0.8682}, "CVE-2007-1623": {"epss_score": 0.00286, "epss_percentile": 0.51715}, "CVE-2007-1624": {"epss_score": 0.00484, "epss_percentile": 0.64627}, "CVE-2007-1625": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-1626": {"epss_score": 0.0434, "epss_percentile": 0.88568}, "CVE-2007-1628": {"epss_score": 0.10204, "epss_percentile": 0.92892}, "CVE-2007-1629": {"epss_score": 0.00451, "epss_percentile": 0.63143}, "CVE-2007-1630": {"epss_score": 0.01294, "epss_percentile": 0.79247}, "CVE-2007-1631": {"epss_score": 0.01602, "epss_percentile": 0.81276}, "CVE-2007-1632": {"epss_score": 0.00489, "epss_percentile": 0.64872}, "CVE-2007-1633": {"epss_score": 0.06244, "epss_percentile": 0.906}, "CVE-2007-1634": {"epss_score": 0.00362, "epss_percentile": 0.57797}, "CVE-2007-1635": {"epss_score": 0.02766, "epss_percentile": 0.85611}, "CVE-2007-1636": {"epss_score": 0.06544, "epss_percentile": 0.90838}, "CVE-2007-1637": {"epss_score": 0.00973, "epss_percentile": 0.76144}, "CVE-2007-1638": {"epss_score": 0.02065, "epss_percentile": 0.83454}, "CVE-2007-1639": {"epss_score": 0.01959, "epss_percentile": 0.83055}, "CVE-2007-1640": {"epss_score": 0.07431, "epss_percentile": 0.91472}, "CVE-2007-1641": {"epss_score": 0.00714, "epss_percentile": 0.71813}, "CVE-2007-1642": {"epss_score": 0.00428, "epss_percentile": 0.61933}, "CVE-2007-1643": {"epss_score": 0.06251, "epss_percentile": 0.90615}, "CVE-2007-1644": {"epss_score": 0.31679, "epss_percentile": 0.96641}, "CVE-2007-1645": {"epss_score": 0.0517, "epss_percentile": 0.8957}, "CVE-2007-1646": {"epss_score": 0.00323, "epss_percentile": 0.54874}, "CVE-2007-1647": {"epss_score": 0.06088, "epss_percentile": 0.90471}, "CVE-2007-1648": {"epss_score": 0.05741, "epss_percentile": 0.90172}, "CVE-2007-1649": {"epss_score": 0.06794, "epss_percentile": 0.9103}, "CVE-2007-1650": {"epss_score": 0.0082, "epss_percentile": 0.73876}, "CVE-2007-1651": {"epss_score": 0.0157, "epss_percentile": 0.81091}, "CVE-2007-1652": {"epss_score": 0.01362, "epss_percentile": 0.79758}, "CVE-2007-1653": {"epss_score": 0.0075, "epss_percentile": 0.72623}, "CVE-2007-1654": {"epss_score": 0.00633, "epss_percentile": 0.69761}, "CVE-2007-1655": {"epss_score": 0.20562, "epss_percentile": 0.95377}, "CVE-2007-1656": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2007-1657": {"epss_score": 0.04928, "epss_percentile": 0.89295}, "CVE-2007-1658": {"epss_score": 0.76316, "epss_percentile": 0.98885}, "CVE-2007-1659": {"epss_score": 0.05344, "epss_percentile": 0.89765}, "CVE-2007-1660": {"epss_score": 0.05628, "epss_percentile": 0.90065}, "CVE-2007-1661": {"epss_score": 0.02716, "epss_percentile": 0.85508}, "CVE-2007-1662": {"epss_score": 0.05385, "epss_percentile": 0.89818}, "CVE-2007-1663": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2007-1664": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2007-1665": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2007-1666": {"epss_score": 0.03965, "epss_percentile": 0.88029}, "CVE-2007-1667": {"epss_score": 0.02066, "epss_percentile": 0.83457}, "CVE-2007-1669": {"epss_score": 0.15024, "epss_percentile": 0.94347}, "CVE-2007-1670": {"epss_score": 0.01589, "epss_percentile": 0.81193}, "CVE-2007-1671": {"epss_score": 0.01542, "epss_percentile": 0.80951}, "CVE-2007-1672": {"epss_score": 0.01175, "epss_percentile": 0.78263}, "CVE-2007-1673": {"epss_score": 0.01162, "epss_percentile": 0.78149}, "CVE-2007-1674": {"epss_score": 0.79901, "epss_percentile": 0.99061}, "CVE-2007-1675": {"epss_score": 0.58091, "epss_percentile": 0.98099}, "CVE-2007-1677": {"epss_score": 0.00052, "epss_percentile": 0.1645}, "CVE-2007-1678": {"epss_score": 0.03691, "epss_percentile": 0.87577}, "CVE-2007-1679": {"epss_score": 0.00473, "epss_percentile": 0.64098}, "CVE-2007-1680": {"epss_score": 0.46104, "epss_percentile": 0.97525}, "CVE-2007-1681": {"epss_score": 0.05106, "epss_percentile": 0.89506}, "CVE-2007-1682": {"epss_score": 0.65758, "epss_percentile": 0.98437}, "CVE-2007-1683": {"epss_score": 0.66592, "epss_percentile": 0.98469}, "CVE-2007-1684": {"epss_score": 0.02272, "epss_percentile": 0.84218}, "CVE-2007-1685": {"epss_score": 0.54579, "epss_percentile": 0.97934}, "CVE-2007-1687": {"epss_score": 0.32826, "epss_percentile": 0.9673}, "CVE-2007-1688": {"epss_score": 0.09866, "epss_percentile": 0.92744}, "CVE-2007-1689": {"epss_score": 0.75842, "epss_percentile": 0.98867}, "CVE-2007-1690": {"epss_score": 0.2767, "epss_percentile": 0.96271}, "CVE-2007-1691": {"epss_score": 0.2767, "epss_percentile": 0.96271}, "CVE-2007-1692": {"epss_score": 0.28218, "epss_percentile": 0.96333}, "CVE-2007-1693": {"epss_score": 0.01439, "epss_percentile": 0.80291}, "CVE-2007-1695": {"epss_score": 0.01486, "epss_percentile": 0.80603}, "CVE-2007-1696": {"epss_score": 0.01294, "epss_percentile": 0.79247}, "CVE-2007-1697": {"epss_score": 0.82098, "epss_percentile": 0.99174}, "CVE-2007-1698": {"epss_score": 0.06088, "epss_percentile": 0.90471}, "CVE-2007-1699": {"epss_score": 0.00248, "epss_percentile": 0.47972}, "CVE-2007-1700": {"epss_score": 0.04171, "epss_percentile": 0.88348}, "CVE-2007-1701": {"epss_score": 0.11353, "epss_percentile": 0.93322}, "CVE-2007-1702": {"epss_score": 0.12977, "epss_percentile": 0.93833}, "CVE-2007-1703": {"epss_score": 0.00022, "epss_percentile": 0.05283}, "CVE-2007-1704": {"epss_score": 0.00029, "epss_percentile": 0.07774}, "CVE-2007-1705": {"epss_score": 0.00504, "epss_percentile": 0.65546}, "CVE-2007-1706": {"epss_score": 0.00835, "epss_percentile": 0.74116}, "CVE-2007-1707": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2007-1708": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2007-1709": {"epss_score": 0.01124, "epss_percentile": 0.77794}, "CVE-2007-1710": {"epss_score": 0.00092, "epss_percentile": 0.26545}, "CVE-2007-1711": {"epss_score": 0.13838, "epss_percentile": 0.94073}, "CVE-2007-1712": {"epss_score": 0.00835, "epss_percentile": 0.74116}, "CVE-2007-1713": {"epss_score": 0.00574, "epss_percentile": 0.68078}, "CVE-2007-1714": {"epss_score": 0.07101, "epss_percentile": 0.91252}, "CVE-2007-1715": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2007-1716": {"epss_score": 0.00075, "epss_percentile": 0.22963}, "CVE-2007-1717": {"epss_score": 0.17626, "epss_percentile": 0.94876}, "CVE-2007-1718": {"epss_score": 0.21829, "epss_percentile": 0.95564}, "CVE-2007-1719": {"epss_score": 0.00109, "epss_percentile": 0.30037}, "CVE-2007-1720": {"epss_score": 0.10846, "epss_percentile": 0.93133}, "CVE-2007-1721": {"epss_score": 0.04841, "epss_percentile": 0.89202}, "CVE-2007-1722": {"epss_score": 0.03272, "epss_percentile": 0.86796}, "CVE-2007-1723": {"epss_score": 0.02475, "epss_percentile": 0.84857}, "CVE-2007-1724": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2007-1725": {"epss_score": 0.00731, "epss_percentile": 0.72169}, "CVE-2007-1726": {"epss_score": 0.09255, "epss_percentile": 0.92467}, "CVE-2007-1727": {"epss_score": 0.00532, "epss_percentile": 0.66673}, "CVE-2007-1728": {"epss_score": 0.00803, "epss_percentile": 0.736}, "CVE-2007-1729": {"epss_score": 0.00785, "epss_percentile": 0.73264}, "CVE-2007-1730": {"epss_score": 0.00537, "epss_percentile": 0.66922}, "CVE-2007-1731": {"epss_score": 0.05868, "epss_percentile": 0.90277}, "CVE-2007-1732": {"epss_score": 0.00439, "epss_percentile": 0.62592}, "CVE-2007-1733": {"epss_score": 0.31281, "epss_percentile": 0.96605}, "CVE-2007-1734": {"epss_score": 0.00249, "epss_percentile": 0.48079}, "CVE-2007-1735": {"epss_score": 0.16745, "epss_percentile": 0.94726}, "CVE-2007-1736": {"epss_score": 0.00132, "epss_percentile": 0.33557}, "CVE-2007-1737": {"epss_score": 0.00132, "epss_percentile": 0.33557}, "CVE-2007-1738": {"epss_score": 0.00156, "epss_percentile": 0.36965}, "CVE-2007-1739": {"epss_score": 0.15448, "epss_percentile": 0.94431}, "CVE-2007-1741": {"epss_score": 0.00093, "epss_percentile": 0.26704}, "CVE-2007-1742": {"epss_score": 0.00172, "epss_percentile": 0.3896}, "CVE-2007-1743": {"epss_score": 0.00165, "epss_percentile": 0.38117}, "CVE-2007-1744": {"epss_score": 0.00098, "epss_percentile": 0.27787}, "CVE-2007-1745": {"epss_score": 0.02229, "epss_percentile": 0.84081}, "CVE-2007-1747": {"epss_score": 0.72457, "epss_percentile": 0.98711}, "CVE-2007-1748": {"epss_score": 0.84188, "epss_percentile": 0.99278}, "CVE-2007-1749": {"epss_score": 0.7827, "epss_percentile": 0.98976}, "CVE-2007-1750": {"epss_score": 0.62692, "epss_percentile": 0.98303}, "CVE-2007-1751": {"epss_score": 0.60832, "epss_percentile": 0.98223}, "CVE-2007-1754": {"epss_score": 0.62213, "epss_percentile": 0.98285}, "CVE-2007-1756": {"epss_score": 0.67687, "epss_percentile": 0.98518}, "CVE-2007-1762": {"epss_score": 0.00238, "epss_percentile": 0.46787}, "CVE-2007-1763": {"epss_score": 0.41629, "epss_percentile": 0.97287}, "CVE-2007-1764": {"epss_score": 0.03761, "epss_percentile": 0.87689}, "CVE-2007-1765": {"epss_score": 0.60253, "epss_percentile": 0.98201}, "CVE-2007-1766": {"epss_score": 0.0738, "epss_percentile": 0.91443}, "CVE-2007-1767": {"epss_score": 0.00723, "epss_percentile": 0.72005}, "CVE-2007-1768": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-1770": {"epss_score": 0.26595, "epss_percentile": 0.9616}, "CVE-2007-1771": {"epss_score": 0.09514, "epss_percentile": 0.9258}, "CVE-2007-1772": {"epss_score": 0.07967, "epss_percentile": 0.91795}, "CVE-2007-1773": {"epss_score": 0.06695, "epss_percentile": 0.90952}, "CVE-2007-1774": {"epss_score": 0.00537, "epss_percentile": 0.66891}, "CVE-2007-1775": {"epss_score": 0.00834, "epss_percentile": 0.74104}, "CVE-2007-1776": {"epss_score": 0.0137, "epss_percentile": 0.79799}, "CVE-2007-1777": {"epss_score": 0.13862, "epss_percentile": 0.94077}, "CVE-2007-1778": {"epss_score": 0.04373, "epss_percentile": 0.88612}, "CVE-2007-1779": {"epss_score": 0.00703, "epss_percentile": 0.71543}, "CVE-2007-1780": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-1781": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2007-1782": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2007-1784": {"epss_score": 0.03857, "epss_percentile": 0.8786}, "CVE-2007-1785": {"epss_score": 0.47242, "epss_percentile": 0.97578}, "CVE-2007-1786": {"epss_score": 0.00867, "epss_percentile": 0.74657}, "CVE-2007-1787": {"epss_score": 0.10357, "epss_percentile": 0.92958}, "CVE-2007-1788": {"epss_score": 0.00139, "epss_percentile": 0.34567}, "CVE-2007-1789": {"epss_score": 0.00821, "epss_percentile": 0.73899}, "CVE-2007-1790": {"epss_score": 0.09935, "epss_percentile": 0.92779}, "CVE-2007-1791": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-1792": {"epss_score": 0.02023, "epss_percentile": 0.83306}, "CVE-2007-1793": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2007-1794": {"epss_score": 0.03447, "epss_percentile": 0.8716}, "CVE-2007-1795": {"epss_score": 0.03028, "epss_percentile": 0.86243}, "CVE-2007-1796": {"epss_score": 0.00381, "epss_percentile": 0.5902}, "CVE-2007-1797": {"epss_score": 0.13128, "epss_percentile": 0.9388}, "CVE-2007-1798": {"epss_score": 0.00063, "epss_percentile": 0.20049}, "CVE-2007-1799": {"epss_score": 0.01016, "epss_percentile": 0.76672}, "CVE-2007-1800": {"epss_score": 0.0086, "epss_percentile": 0.74535}, "CVE-2007-1801": {"epss_score": 0.0721, "epss_percentile": 0.91328}, "CVE-2007-1802": {"epss_score": 0.00968, "epss_percentile": 0.76087}, "CVE-2007-1803": {"epss_score": 0.00504, "epss_percentile": 0.65542}, "CVE-2007-1804": {"epss_score": 0.15236, "epss_percentile": 0.9439}, "CVE-2007-1805": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-1806": {"epss_score": 0.00431, "epss_percentile": 0.62057}, "CVE-2007-1807": {"epss_score": 0.0069, "epss_percentile": 0.71252}, "CVE-2007-1808": {"epss_score": 0.01252, "epss_percentile": 0.7891}, "CVE-2007-1809": {"epss_score": 0.07793, "epss_percentile": 0.91684}, "CVE-2007-1810": {"epss_score": 0.01252, "epss_percentile": 0.7891}, "CVE-2007-1811": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-1812": {"epss_score": 0.08985, "epss_percentile": 0.92353}, "CVE-2007-1813": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-1814": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-1815": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-1816": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-1817": {"epss_score": 0.00531, "epss_percentile": 0.66653}, "CVE-2007-1818": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2007-1819": {"epss_score": 0.75644, "epss_percentile": 0.98859}, "CVE-2007-1820": {"epss_score": 0.02864, "epss_percentile": 0.85858}, "CVE-2007-1821": {"epss_score": 0.01485, "epss_percentile": 0.80596}, "CVE-2007-1822": {"epss_score": 0.01134, "epss_percentile": 0.77887}, "CVE-2007-1823": {"epss_score": 0.01485, "epss_percentile": 0.80596}, "CVE-2007-1824": {"epss_score": 0.01894, "epss_percentile": 0.8274}, "CVE-2007-1825": {"epss_score": 0.05444, "epss_percentile": 0.89885}, "CVE-2007-1826": {"epss_score": 0.01314, "epss_percentile": 0.79398}, "CVE-2007-1827": {"epss_score": 0.02641, "epss_percentile": 0.85304}, "CVE-2007-1828": {"epss_score": 0.00357, "epss_percentile": 0.57475}, "CVE-2007-1829": {"epss_score": 0.00394, "epss_percentile": 0.59769}, "CVE-2007-1830": {"epss_score": 0.00323, "epss_percentile": 0.54874}, "CVE-2007-1831": {"epss_score": 0.01087, "epss_percentile": 0.7743}, "CVE-2007-1832": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-1833": {"epss_score": 0.02625, "epss_percentile": 0.85264}, "CVE-2007-1834": {"epss_score": 0.01314, "epss_percentile": 0.79398}, "CVE-2007-1835": {"epss_score": 0.00138, "epss_percentile": 0.34402}, "CVE-2007-1836": {"epss_score": 0.01062, "epss_percentile": 0.77179}, "CVE-2007-1837": {"epss_score": 0.16554, "epss_percentile": 0.94689}, "CVE-2007-1838": {"epss_score": 0.00642, "epss_percentile": 0.70036}, "CVE-2007-1839": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-1840": {"epss_score": 0.00607, "epss_percentile": 0.69052}, "CVE-2007-1841": {"epss_score": 0.07852, "epss_percentile": 0.9172}, "CVE-2007-1842": {"epss_score": 0.08576, "epss_percentile": 0.9213}, "CVE-2007-1843": {"epss_score": 0.19175, "epss_percentile": 0.95144}, "CVE-2007-1844": {"epss_score": 0.01155, "epss_percentile": 0.78079}, "CVE-2007-1845": {"epss_score": 0.00988, "epss_percentile": 0.76353}, "CVE-2007-1846": {"epss_score": 0.00504, "epss_percentile": 0.65546}, "CVE-2007-1847": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-1848": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-1849": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2007-1850": {"epss_score": 0.0022, "epss_percentile": 0.44613}, "CVE-2007-1851": {"epss_score": 0.05754, "epss_percentile": 0.90179}, "CVE-2007-1852": {"epss_score": 0.00954, "epss_percentile": 0.75904}, "CVE-2007-1853": {"epss_score": 0.00628, "epss_percentile": 0.69651}, "CVE-2007-1854": {"epss_score": 0.00602, "epss_percentile": 0.68896}, "CVE-2007-1855": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2007-1856": {"epss_score": 0.00076, "epss_percentile": 0.23133}, "CVE-2007-1858": {"epss_score": 0.05088, "epss_percentile": 0.89481}, "CVE-2007-1859": {"epss_score": 0.00055, "epss_percentile": 0.17438}, "CVE-2007-1860": {"epss_score": 0.22944, "epss_percentile": 0.95709}, "CVE-2007-1861": {"epss_score": 0.01073, "epss_percentile": 0.77285}, "CVE-2007-1862": {"epss_score": 0.09008, "epss_percentile": 0.92361}, "CVE-2007-1863": {"epss_score": 0.32302, "epss_percentile": 0.96687}, "CVE-2007-1864": {"epss_score": 0.07751, "epss_percentile": 0.91659}, "CVE-2007-1865": {"epss_score": 0.00056, "epss_percentile": 0.17866}, "CVE-2007-1866": {"epss_score": 0.22326, "epss_percentile": 0.95623}, "CVE-2007-1867": {"epss_score": 0.41868, "epss_percentile": 0.97298}, "CVE-2007-1868": {"epss_score": 0.77135, "epss_percentile": 0.98923}, "CVE-2007-1869": {"epss_score": 0.05804, "epss_percentile": 0.90222}, "CVE-2007-1870": {"epss_score": 0.01617, "epss_percentile": 0.81364}, "CVE-2007-1871": {"epss_score": 0.00537, "epss_percentile": 0.66919}, "CVE-2007-1872": {"epss_score": 0.10592, "epss_percentile": 0.93037}, "CVE-2007-1873": {"epss_score": 0.01255, "epss_percentile": 0.78927}, "CVE-2007-1874": {"epss_score": 0.0015, "epss_percentile": 0.36073}, "CVE-2007-1876": {"epss_score": 0.00078, "epss_percentile": 0.23657}, "CVE-2007-1877": {"epss_score": 0.01174, "epss_percentile": 0.78244}, "CVE-2007-1878": {"epss_score": 0.01821, "epss_percentile": 0.82409}, "CVE-2007-1879": {"epss_score": 0.01837, "epss_percentile": 0.82482}, "CVE-2007-1880": {"epss_score": 0.00073, "epss_percentile": 0.22495}, "CVE-2007-1881": {"epss_score": 0.00139, "epss_percentile": 0.34598}, "CVE-2007-1882": {"epss_score": 0.10739, "epss_percentile": 0.93088}, "CVE-2007-1883": {"epss_score": 0.00506, "epss_percentile": 0.65635}, "CVE-2007-1884": {"epss_score": 0.02129, "epss_percentile": 0.83704}, "CVE-2007-1885": {"epss_score": 0.01802, "epss_percentile": 0.8233}, "CVE-2007-1886": {"epss_score": 0.00845, "epss_percentile": 0.7429}, "CVE-2007-1887": {"epss_score": 0.0441, "epss_percentile": 0.88659}, "CVE-2007-1888": {"epss_score": 0.04753, "epss_percentile": 0.89106}, "CVE-2007-1889": {"epss_score": 0.07998, "epss_percentile": 0.91814}, "CVE-2007-1890": {"epss_score": 0.05342, "epss_percentile": 0.89763}, "CVE-2007-1891": {"epss_score": 0.16314, "epss_percentile": 0.94629}, "CVE-2007-1892": {"epss_score": 0.08873, "epss_percentile": 0.92296}, "CVE-2007-1893": {"epss_score": 0.00189, "epss_percentile": 0.40963}, "CVE-2007-1894": {"epss_score": 0.05601, "epss_percentile": 0.9004}, "CVE-2007-1895": {"epss_score": 0.05148, "epss_percentile": 0.89546}, "CVE-2007-1896": {"epss_score": 0.04128, "epss_percentile": 0.88292}, "CVE-2007-1897": {"epss_score": 0.02585, "epss_percentile": 0.85165}, "CVE-2007-1898": {"epss_score": 0.17116, "epss_percentile": 0.94778}, "CVE-2007-1899": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2007-1900": {"epss_score": 0.00882, "epss_percentile": 0.74901}, "CVE-2007-1901": {"epss_score": 0.00894, "epss_percentile": 0.75091}, "CVE-2007-1902": {"epss_score": 0.01379, "epss_percentile": 0.79856}, "CVE-2007-1903": {"epss_score": 0.01111, "epss_percentile": 0.77669}, "CVE-2007-1904": {"epss_score": 0.01423, "epss_percentile": 0.8019}, "CVE-2007-1905": {"epss_score": 0.06817, "epss_percentile": 0.91044}, "CVE-2007-1906": {"epss_score": 0.15589, "epss_percentile": 0.94465}, "CVE-2007-1907": {"epss_score": 0.0642, "epss_percentile": 0.90749}, "CVE-2007-1908": {"epss_score": 0.10967, "epss_percentile": 0.9318}, "CVE-2007-1909": {"epss_score": 0.0069, "epss_percentile": 0.71252}, "CVE-2007-1910": {"epss_score": 0.36751, "epss_percentile": 0.96999}, "CVE-2007-1911": {"epss_score": 0.16035, "epss_percentile": 0.94563}, "CVE-2007-1912": {"epss_score": 0.33824, "epss_percentile": 0.96807}, "CVE-2007-1913": {"epss_score": 0.00632, "epss_percentile": 0.69751}, "CVE-2007-1914": {"epss_score": 0.00523, "epss_percentile": 0.66286}, "CVE-2007-1915": {"epss_score": 0.04965, "epss_percentile": 0.89342}, "CVE-2007-1916": {"epss_score": 0.10051, "epss_percentile": 0.92829}, "CVE-2007-1917": {"epss_score": 0.10051, "epss_percentile": 0.92829}, "CVE-2007-1918": {"epss_score": 0.01347, "epss_percentile": 0.79657}, "CVE-2007-1919": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2007-1920": {"epss_score": 0.01343, "epss_percentile": 0.796}, "CVE-2007-1921": {"epss_score": 0.15097, "epss_percentile": 0.94361}, "CVE-2007-1922": {"epss_score": 0.15636, "epss_percentile": 0.94474}, "CVE-2007-1923": {"epss_score": 0.01489, "epss_percentile": 0.80621}, "CVE-2007-1924": {"epss_score": 0.00976, "epss_percentile": 0.76205}, "CVE-2007-1925": {"epss_score": 0.00985, "epss_percentile": 0.76322}, "CVE-2007-1926": {"epss_score": 0.01336, "epss_percentile": 0.79557}, "CVE-2007-1927": {"epss_score": 0.00537, "epss_percentile": 0.66919}, "CVE-2007-1928": {"epss_score": 0.09138, "epss_percentile": 0.92418}, "CVE-2007-1929": {"epss_score": 0.10593, "epss_percentile": 0.93039}, "CVE-2007-1930": {"epss_score": 0.12122, "epss_percentile": 0.93572}, "CVE-2007-1931": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-1932": {"epss_score": 0.06345, "epss_percentile": 0.90686}, "CVE-2007-1933": {"epss_score": 0.04969, "epss_percentile": 0.89347}, "CVE-2007-1934": {"epss_score": 0.10846, "epss_percentile": 0.93133}, "CVE-2007-1935": {"epss_score": 0.00846, "epss_percentile": 0.74325}, "CVE-2007-1936": {"epss_score": 0.00846, "epss_percentile": 0.74325}, "CVE-2007-1937": {"epss_score": 0.10967, "epss_percentile": 0.9318}, "CVE-2007-1938": {"epss_score": 0.00984, "epss_percentile": 0.76315}, "CVE-2007-1939": {"epss_score": 0.00676, "epss_percentile": 0.70921}, "CVE-2007-1940": {"epss_score": 0.0007, "epss_percentile": 0.21746}, "CVE-2007-1941": {"epss_score": 0.00335, "epss_percentile": 0.55811}, "CVE-2007-1942": {"epss_score": 0.09545, "epss_percentile": 0.92593}, "CVE-2007-1943": {"epss_score": 0.1571, "epss_percentile": 0.94489}, "CVE-2007-1944": {"epss_score": 0.00543, "epss_percentile": 0.67099}, "CVE-2007-1945": {"epss_score": 0.00764, "epss_percentile": 0.72893}, "CVE-2007-1946": {"epss_score": 0.44027, "epss_percentile": 0.97415}, "CVE-2007-1947": {"epss_score": 0.04748, "epss_percentile": 0.891}, "CVE-2007-1948": {"epss_score": 0.06227, "epss_percentile": 0.90586}, "CVE-2007-1949": {"epss_score": 0.00775, "epss_percentile": 0.73078}, "CVE-2007-1950": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-1951": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2007-1952": {"epss_score": 0.00775, "epss_percentile": 0.73078}, "CVE-2007-1953": {"epss_score": 0.0075, "epss_percentile": 0.72631}, "CVE-2007-1954": {"epss_score": 0.00584, "epss_percentile": 0.68396}, "CVE-2007-1955": {"epss_score": 0.0566, "epss_percentile": 0.90095}, "CVE-2007-1956": {"epss_score": 0.00376, "epss_percentile": 0.58641}, "CVE-2007-1957": {"epss_score": 0.00762, "epss_percentile": 0.72845}, "CVE-2007-1958": {"epss_score": 0.004, "epss_percentile": 0.60183}, "CVE-2007-1959": {"epss_score": 0.00399, "epss_percentile": 0.60107}, "CVE-2007-1960": {"epss_score": 0.00704, "epss_percentile": 0.71561}, "CVE-2007-1961": {"epss_score": 0.01501, "epss_percentile": 0.80717}, "CVE-2007-1962": {"epss_score": 0.00716, "epss_percentile": 0.71863}, "CVE-2007-1963": {"epss_score": 0.01512, "epss_percentile": 0.80785}, "CVE-2007-1964": {"epss_score": 0.0055, "epss_percentile": 0.67335}, "CVE-2007-1965": {"epss_score": 0.0035, "epss_percentile": 0.56958}, "CVE-2007-1966": {"epss_score": 0.00302, "epss_percentile": 0.53124}, "CVE-2007-1967": {"epss_score": 0.00954, "epss_percentile": 0.75904}, "CVE-2007-1968": {"epss_score": 0.1234, "epss_percentile": 0.93644}, "CVE-2007-1969": {"epss_score": 0.00286, "epss_percentile": 0.51715}, "CVE-2007-1970": {"epss_score": 0.00333, "epss_percentile": 0.55672}, "CVE-2007-1971": {"epss_score": 0.00886, "epss_percentile": 0.74953}, "CVE-2007-1972": {"epss_score": 0.06592, "epss_percentile": 0.90874}, "CVE-2007-1973": {"epss_score": 0.01407, "epss_percentile": 0.80056}, "CVE-2007-1974": {"epss_score": 0.03642, "epss_percentile": 0.87493}, "CVE-2007-1975": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2007-1976": {"epss_score": 0.01451, "epss_percentile": 0.80362}, "CVE-2007-1977": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-1978": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-1979": {"epss_score": 0.00504, "epss_percentile": 0.65546}, "CVE-2007-1980": {"epss_score": 0.0069, "epss_percentile": 0.71252}, "CVE-2007-1981": {"epss_score": 0.00803, "epss_percentile": 0.736}, "CVE-2007-1982": {"epss_score": 0.08275, "epss_percentile": 0.91964}, "CVE-2007-1983": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2007-1984": {"epss_score": 0.00612, "epss_percentile": 0.69223}, "CVE-2007-1985": {"epss_score": 0.00612, "epss_percentile": 0.69223}, "CVE-2007-1986": {"epss_score": 0.11063, "epss_percentile": 0.93207}, "CVE-2007-1987": {"epss_score": 0.01019, "epss_percentile": 0.76729}, "CVE-2007-1988": {"epss_score": 0.00323, "epss_percentile": 0.54874}, "CVE-2007-1989": {"epss_score": 0.01398, "epss_percentile": 0.79989}, "CVE-2007-1990": {"epss_score": 0.00612, "epss_percentile": 0.69223}, "CVE-2007-1991": {"epss_score": 0.00323, "epss_percentile": 0.54874}, "CVE-2007-1992": {"epss_score": 0.05096, "epss_percentile": 0.89492}, "CVE-2007-1993": {"epss_score": 0.05001, "epss_percentile": 0.89378}, "CVE-2007-1994": {"epss_score": 0.00069, "epss_percentile": 0.21502}, "CVE-2007-1995": {"epss_score": 0.01149, "epss_percentile": 0.78017}, "CVE-2007-1996": {"epss_score": 0.03674, "epss_percentile": 0.8755}, "CVE-2007-1997": {"epss_score": 0.11858, "epss_percentile": 0.93498}, "CVE-2007-1998": {"epss_score": 0.06722, "epss_percentile": 0.90968}, "CVE-2007-1999": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2007-20001": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2007-2000": {"epss_score": 0.00612, "epss_percentile": 0.69235}, "CVE-2007-2001": {"epss_score": 0.05378, "epss_percentile": 0.89805}, "CVE-2007-2002": {"epss_score": 0.06244, "epss_percentile": 0.906}, "CVE-2007-2003": {"epss_score": 0.06244, "epss_percentile": 0.906}, "CVE-2007-2004": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-2005": {"epss_score": 0.01298, "epss_percentile": 0.79274}, "CVE-2007-2006": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-2007": {"epss_score": 0.03434, "epss_percentile": 0.87129}, "CVE-2007-2008": {"epss_score": 0.06244, "epss_percentile": 0.906}, "CVE-2007-2009": {"epss_score": 0.13104, "epss_percentile": 0.93876}, "CVE-2007-2010": {"epss_score": 0.01316, "epss_percentile": 0.79406}, "CVE-2007-2011": {"epss_score": 0.07101, "epss_percentile": 0.91252}, "CVE-2007-2012": {"epss_score": 0.00502, "epss_percentile": 0.654}, "CVE-2007-2013": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2007-2014": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2007-2015": {"epss_score": 0.10708, "epss_percentile": 0.93078}, "CVE-2007-2016": {"epss_score": 0.00323, "epss_percentile": 0.54874}, "CVE-2007-2017": {"epss_score": 0.01662, "epss_percentile": 0.81636}, "CVE-2007-2018": {"epss_score": 0.00507, "epss_percentile": 0.65662}, "CVE-2007-2019": {"epss_score": 0.05773, "epss_percentile": 0.90195}, "CVE-2007-2020": {"epss_score": 0.03984, "epss_percentile": 0.88063}, "CVE-2007-2021": {"epss_score": 0.00612, "epss_percentile": 0.69223}, "CVE-2007-2022": {"epss_score": 0.13693, "epss_percentile": 0.94035}, "CVE-2007-2023": {"epss_score": 0.0007, "epss_percentile": 0.21743}, "CVE-2007-2024": {"epss_score": 0.03707, "epss_percentile": 0.876}, "CVE-2007-2025": {"epss_score": 0.01341, "epss_percentile": 0.79591}, "CVE-2007-2026": {"epss_score": 0.02808, "epss_percentile": 0.85712}, "CVE-2007-2027": {"epss_score": 0.0028, "epss_percentile": 0.51014}, "CVE-2007-2028": {"epss_score": 0.08727, "epss_percentile": 0.9223}, "CVE-2007-2029": {"epss_score": 0.01135, "epss_percentile": 0.77907}, "CVE-2007-2030": {"epss_score": 0.00043, "epss_percentile": 0.13172}, "CVE-2007-2031": {"epss_score": 0.49009, "epss_percentile": 0.97661}, "CVE-2007-2032": {"epss_score": 0.01155, "epss_percentile": 0.78079}, "CVE-2007-2033": {"epss_score": 0.00985, "epss_percentile": 0.76322}, "CVE-2007-2034": {"epss_score": 0.01428, "epss_percentile": 0.80217}, "CVE-2007-2035": {"epss_score": 0.00546, "epss_percentile": 0.67203}, "CVE-2007-2036": {"epss_score": 0.02387, "epss_percentile": 0.84583}, "CVE-2007-2037": {"epss_score": 0.00605, "epss_percentile": 0.68985}, "CVE-2007-2038": {"epss_score": 0.00591, "epss_percentile": 0.6859}, "CVE-2007-2039": {"epss_score": 0.00793, "epss_percentile": 0.73417}, "CVE-2007-2040": {"epss_score": 0.00092, "epss_percentile": 0.2649}, "CVE-2007-2041": {"epss_score": 0.00422, "epss_percentile": 0.61548}, "CVE-2007-2042": {"epss_score": 0.00646, "epss_percentile": 0.70136}, "CVE-2007-2043": {"epss_score": 0.0638, "epss_percentile": 0.90711}, "CVE-2007-2044": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2007-2045": {"epss_score": 0.01897, "epss_percentile": 0.82759}, "CVE-2007-2046": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2007-2047": {"epss_score": 0.00612, "epss_percentile": 0.69223}, "CVE-2007-2048": {"epss_score": 0.09984, "epss_percentile": 0.92804}, "CVE-2007-2049": {"epss_score": 0.07828, "epss_percentile": 0.91702}, "CVE-2007-2050": {"epss_score": 0.12122, "epss_percentile": 0.93572}, "CVE-2007-2051": {"epss_score": 0.00485, "epss_percentile": 0.64736}, "CVE-2007-2052": {"epss_score": 0.13433, "epss_percentile": 0.93961}, "CVE-2007-2053": {"epss_score": 0.15371, "epss_percentile": 0.94416}, "CVE-2007-2054": {"epss_score": 0.05312, "epss_percentile": 0.89718}, "CVE-2007-2055": {"epss_score": 0.00405, "epss_percentile": 0.60492}, "CVE-2007-2057": {"epss_score": 0.40859, "epss_percentile": 0.9724}, "CVE-2007-2058": {"epss_score": 0.00547, "epss_percentile": 0.67233}, "CVE-2007-2059": {"epss_score": 0.05843, "epss_percentile": 0.90253}, "CVE-2007-2060": {"epss_score": 0.03629, "epss_percentile": 0.87471}, "CVE-2007-2061": {"epss_score": 0.07531, "epss_percentile": 0.9152}, "CVE-2007-2062": {"epss_score": 0.22843, "epss_percentile": 0.95698}, "CVE-2007-2063": {"epss_score": 0.00058, "epss_percentile": 0.18412}, "CVE-2007-2064": {"epss_score": 0.02882, "epss_percentile": 0.85902}, "CVE-2007-2065": {"epss_score": 0.01495, "epss_percentile": 0.80654}, "CVE-2007-2066": {"epss_score": 0.00408, "epss_percentile": 0.60682}, "CVE-2007-2067": {"epss_score": 0.07793, "epss_percentile": 0.91684}, "CVE-2007-2068": {"epss_score": 0.09701, "epss_percentile": 0.92668}, "CVE-2007-2069": {"epss_score": 0.05128, "epss_percentile": 0.89527}, "CVE-2007-2070": {"epss_score": 0.22535, "epss_percentile": 0.95649}, "CVE-2007-2071": {"epss_score": 0.00763, "epss_percentile": 0.72884}, "CVE-2007-2072": {"epss_score": 0.01054, "epss_percentile": 0.77111}, "CVE-2007-2073": {"epss_score": 0.00612, "epss_percentile": 0.69223}, "CVE-2007-2074": {"epss_score": 0.00052, "epss_percentile": 0.16476}, "CVE-2007-2075": {"epss_score": 0.00048, "epss_percentile": 0.15277}, "CVE-2007-2076": {"epss_score": 0.01081, "epss_percentile": 0.77377}, "CVE-2007-2077": {"epss_score": 0.00892, "epss_percentile": 0.7506}, "CVE-2007-2078": {"epss_score": 0.016, "epss_percentile": 0.8126}, "CVE-2007-2079": {"epss_score": 0.0496, "epss_percentile": 0.89333}, "CVE-2007-2080": {"epss_score": 0.00594, "epss_percentile": 0.68658}, "CVE-2007-2081": {"epss_score": 0.0744, "epss_percentile": 0.91474}, "CVE-2007-2082": {"epss_score": 0.00973, "epss_percentile": 0.76161}, "CVE-2007-2083": {"epss_score": 0.00185, "epss_percentile": 0.40517}, "CVE-2007-2084": {"epss_score": 0.00971, "epss_percentile": 0.7612}, "CVE-2007-2085": {"epss_score": 0.01275, "epss_percentile": 0.79101}, "CVE-2007-2086": {"epss_score": 0.05959, "epss_percentile": 0.90365}, "CVE-2007-2087": {"epss_score": 0.01748, "epss_percentile": 0.82082}, "CVE-2007-2088": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2007-2089": {"epss_score": 0.06135, "epss_percentile": 0.90506}, "CVE-2007-2090": {"epss_score": 0.04046, "epss_percentile": 0.88172}, "CVE-2007-2091": {"epss_score": 0.0854, "epss_percentile": 0.92112}, "CVE-2007-2092": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2007-2093": {"epss_score": 0.56078, "epss_percentile": 0.98007}, "CVE-2007-2094": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2007-2095": {"epss_score": 0.00612, "epss_percentile": 0.69223}, "CVE-2007-2096": {"epss_score": 0.0069, "epss_percentile": 0.71256}, "CVE-2007-2097": {"epss_score": 0.01037, "epss_percentile": 0.76927}, "CVE-2007-2098": {"epss_score": 0.06183, "epss_percentile": 0.90539}, "CVE-2007-2099": {"epss_score": 0.00787, "epss_percentile": 0.7331}, "CVE-2007-2100": {"epss_score": 0.01195, "epss_percentile": 0.78432}, "CVE-2007-2101": {"epss_score": 0.01059, "epss_percentile": 0.77152}, "CVE-2007-2102": {"epss_score": 0.00968, "epss_percentile": 0.76087}, "CVE-2007-2103": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2007-2104": {"epss_score": 0.00815, "epss_percentile": 0.73791}, "CVE-2007-2105": {"epss_score": 0.00584, "epss_percentile": 0.68396}, "CVE-2007-2106": {"epss_score": 0.00459, "epss_percentile": 0.63498}, "CVE-2007-2107": {"epss_score": 0.00415, "epss_percentile": 0.61127}, "CVE-2007-2108": {"epss_score": 0.30473, "epss_percentile": 0.96543}, "CVE-2007-2109": {"epss_score": 0.04338, "epss_percentile": 0.88566}, "CVE-2007-2110": {"epss_score": 0.00153, "epss_percentile": 0.36566}, "CVE-2007-2111": {"epss_score": 0.02413, "epss_percentile": 0.84676}, "CVE-2007-2112": {"epss_score": 0.1956, "epss_percentile": 0.95209}, "CVE-2007-2113": {"epss_score": 0.0263, "epss_percentile": 0.85281}, "CVE-2007-2114": {"epss_score": 0.22478, "epss_percentile": 0.95642}, "CVE-2007-2115": {"epss_score": 0.0462, "epss_percentile": 0.8893}, "CVE-2007-2116": {"epss_score": 0.20146, "epss_percentile": 0.95294}, "CVE-2007-2117": {"epss_score": 0.00446, "epss_percentile": 0.6292}, "CVE-2007-2118": {"epss_score": 0.05122, "epss_percentile": 0.89521}, "CVE-2007-2119": {"epss_score": 0.04663, "epss_percentile": 0.88977}, "CVE-2007-2120": {"epss_score": 0.0456, "epss_percentile": 0.88849}, "CVE-2007-2121": {"epss_score": 0.01375, "epss_percentile": 0.79831}, "CVE-2007-2122": {"epss_score": 0.01375, "epss_percentile": 0.79831}, "CVE-2007-2123": {"epss_score": 0.01375, "epss_percentile": 0.79831}, "CVE-2007-2124": {"epss_score": 0.01375, "epss_percentile": 0.79831}, "CVE-2007-2125": {"epss_score": 0.01375, "epss_percentile": 0.79831}, "CVE-2007-2126": {"epss_score": 0.01296, "epss_percentile": 0.79259}, "CVE-2007-2127": {"epss_score": 0.01379, "epss_percentile": 0.79851}, "CVE-2007-2128": {"epss_score": 0.02544, "epss_percentile": 0.8506}, "CVE-2007-2129": {"epss_score": 0.01375, "epss_percentile": 0.79831}, "CVE-2007-2130": {"epss_score": 0.02544, "epss_percentile": 0.8506}, "CVE-2007-2131": {"epss_score": 0.01846, "epss_percentile": 0.82515}, "CVE-2007-2132": {"epss_score": 0.01266, "epss_percentile": 0.79011}, "CVE-2007-2133": {"epss_score": 0.01375, "epss_percentile": 0.79831}, "CVE-2007-2134": {"epss_score": 0.00322, "epss_percentile": 0.54814}, "CVE-2007-2135": {"epss_score": 0.00986, "epss_percentile": 0.76336}, "CVE-2007-2136": {"epss_score": 0.07924, "epss_percentile": 0.91765}, "CVE-2007-2137": {"epss_score": 0.28291, "epss_percentile": 0.96339}, "CVE-2007-2138": {"epss_score": 0.01146, "epss_percentile": 0.77998}, "CVE-2007-2139": {"epss_score": 0.84099, "epss_percentile": 0.99274}, "CVE-2007-2140": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2007-2141": {"epss_score": 0.08099, "epss_percentile": 0.91878}, "CVE-2007-2142": {"epss_score": 0.10119, "epss_percentile": 0.92856}, "CVE-2007-2143": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2007-2144": {"epss_score": 0.04217, "epss_percentile": 0.88407}, "CVE-2007-2145": {"epss_score": 0.05518, "epss_percentile": 0.89953}, "CVE-2007-2146": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2007-2147": {"epss_score": 0.04622, "epss_percentile": 0.88934}, "CVE-2007-2148": {"epss_score": 0.03282, "epss_percentile": 0.86817}, "CVE-2007-2149": {"epss_score": 0.01294, "epss_percentile": 0.79244}, "CVE-2007-2150": {"epss_score": 0.00388, "epss_percentile": 0.59346}, "CVE-2007-2151": {"epss_score": 0.02221, "epss_percentile": 0.8405}, "CVE-2007-2152": {"epss_score": 0.11887, "epss_percentile": 0.93505}, "CVE-2007-2153": {"epss_score": 0.00968, "epss_percentile": 0.76087}, "CVE-2007-2154": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2007-2155": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2007-2156": {"epss_score": 0.12612, "epss_percentile": 0.93729}, "CVE-2007-2157": {"epss_score": 0.10593, "epss_percentile": 0.93039}, "CVE-2007-2158": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2007-2159": {"epss_score": 0.00362, "epss_percentile": 0.57757}, "CVE-2007-2160": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2007-2161": {"epss_score": 0.28021, "epss_percentile": 0.96302}, "CVE-2007-2162": {"epss_score": 0.00723, "epss_percentile": 0.72005}, "CVE-2007-2163": {"epss_score": 0.00555, "epss_percentile": 0.67496}, "CVE-2007-2164": {"epss_score": 0.00627, "epss_percentile": 0.69633}, "CVE-2007-2165": {"epss_score": 0.02494, "epss_percentile": 0.84905}, "CVE-2007-2166": {"epss_score": 0.09701, "epss_percentile": 0.92668}, "CVE-2007-2167": {"epss_score": 0.04865, "epss_percentile": 0.89227}, "CVE-2007-2168": {"epss_score": 0.04248, "epss_percentile": 0.88446}, "CVE-2007-2169": {"epss_score": 0.04081, "epss_percentile": 0.88219}, "CVE-2007-2170": {"epss_score": 0.03042, "epss_percentile": 0.86275}, "CVE-2007-2171": {"epss_score": 0.36221, "epss_percentile": 0.96961}, "CVE-2007-2172": {"epss_score": 0.00071, "epss_percentile": 0.22142}, "CVE-2007-2173": {"epss_score": 0.03075, "epss_percentile": 0.86359}, "CVE-2007-2174": {"epss_score": 0.00069, "epss_percentile": 0.21575}, "CVE-2007-2175": {"epss_score": 0.85142, "epss_percentile": 0.99322}, "CVE-2007-2176": {"epss_score": 0.02785, "epss_percentile": 0.85656}, "CVE-2007-2177": {"epss_score": 0.05731, "epss_percentile": 0.90162}, "CVE-2007-2178": {"epss_score": 0.00882, "epss_percentile": 0.74892}, "CVE-2007-2179": {"epss_score": 0.00905, "epss_percentile": 0.7524}, "CVE-2007-2180": {"epss_score": 0.09402, "epss_percentile": 0.92532}, "CVE-2007-2181": {"epss_score": 0.10967, "epss_percentile": 0.9318}, "CVE-2007-2182": {"epss_score": 0.04969, "epss_percentile": 0.89347}, "CVE-2007-2183": {"epss_score": 0.00431, "epss_percentile": 0.62057}, "CVE-2007-2184": {"epss_score": 0.06088, "epss_percentile": 0.90471}, "CVE-2007-2185": {"epss_score": 0.1478, "epss_percentile": 0.94282}, "CVE-2007-2186": {"epss_score": 0.11866, "epss_percentile": 0.935}, "CVE-2007-2187": {"epss_score": 0.22906, "epss_percentile": 0.95705}, "CVE-2007-2188": {"epss_score": 0.00881, "epss_percentile": 0.74874}, "CVE-2007-2189": {"epss_score": 0.04051, "epss_percentile": 0.88176}, "CVE-2007-2190": {"epss_score": 0.00787, "epss_percentile": 0.7331}, "CVE-2007-2191": {"epss_score": 0.07601, "epss_percentile": 0.91562}, "CVE-2007-2192": {"epss_score": 0.23856, "epss_percentile": 0.95822}, "CVE-2007-2193": {"epss_score": 0.78364, "epss_percentile": 0.98983}, "CVE-2007-2194": {"epss_score": 0.28417, "epss_percentile": 0.96356}, "CVE-2007-2195": {"epss_score": 0.04087, "epss_percentile": 0.88229}, "CVE-2007-2196": {"epss_score": 0.00063, "epss_percentile": 0.19851}, "CVE-2007-2197": {"epss_score": 0.00389, "epss_percentile": 0.59403}, "CVE-2007-2198": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-2199": {"epss_score": 0.85705, "epss_percentile": 0.99344}, "CVE-2007-2200": {"epss_score": 0.08143, "epss_percentile": 0.919}, "CVE-2007-2201": {"epss_score": 0.08547, "epss_percentile": 0.92118}, "CVE-2007-2202": {"epss_score": 0.06081, "epss_percentile": 0.90463}, "CVE-2007-2203": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-2204": {"epss_score": 0.08985, "epss_percentile": 0.92353}, "CVE-2007-2205": {"epss_score": 0.05406, "epss_percentile": 0.89839}, "CVE-2007-2206": {"epss_score": 0.00537, "epss_percentile": 0.66891}, "CVE-2007-2207": {"epss_score": 0.01877, "epss_percentile": 0.82662}, "CVE-2007-2208": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2007-2209": {"epss_score": 0.18694, "epss_percentile": 0.95054}, "CVE-2007-2210": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2007-2211": {"epss_score": 0.0069, "epss_percentile": 0.71252}, "CVE-2007-2212": {"epss_score": 0.00334, "epss_percentile": 0.55699}, "CVE-2007-2213": {"epss_score": 0.01541, "epss_percentile": 0.80945}, "CVE-2007-2214": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2007-2216": {"epss_score": 0.68638, "epss_percentile": 0.98557}, "CVE-2007-2217": {"epss_score": 0.86832, "epss_percentile": 0.99401}, "CVE-2007-2218": {"epss_score": 0.50226, "epss_percentile": 0.97728}, "CVE-2007-2219": {"epss_score": 0.58096, "epss_percentile": 0.981}, "CVE-2007-2221": {"epss_score": 0.6912, "epss_percentile": 0.98579}, "CVE-2007-2222": {"epss_score": 0.63273, "epss_percentile": 0.98326}, "CVE-2007-2223": {"epss_score": 0.68203, "epss_percentile": 0.98535}, "CVE-2007-2224": {"epss_score": 0.70298, "epss_percentile": 0.98627}, "CVE-2007-2225": {"epss_score": 0.49446, "epss_percentile": 0.97687}, "CVE-2007-2227": {"epss_score": 0.50137, "epss_percentile": 0.97721}, "CVE-2007-2228": {"epss_score": 0.75421, "epss_percentile": 0.98844}, "CVE-2007-2229": {"epss_score": 0.00846, "epss_percentile": 0.74333}, "CVE-2007-2230": {"epss_score": 0.01432, "epss_percentile": 0.80251}, "CVE-2007-2231": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2007-2232": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2007-2233": {"epss_score": 0.05055, "epss_percentile": 0.89446}, "CVE-2007-2234": {"epss_score": 0.00596, "epss_percentile": 0.68705}, "CVE-2007-2235": {"epss_score": 0.00537, "epss_percentile": 0.66891}, "CVE-2007-2236": {"epss_score": 0.01081, "epss_percentile": 0.77377}, "CVE-2007-2237": {"epss_score": 0.60165, "epss_percentile": 0.98195}, "CVE-2007-2238": {"epss_score": 0.74778, "epss_percentile": 0.98816}, "CVE-2007-2239": {"epss_score": 0.27405, "epss_percentile": 0.96243}, "CVE-2007-2240": {"epss_score": 0.01988, "epss_percentile": 0.83164}, "CVE-2007-2241": {"epss_score": 0.10233, "epss_percentile": 0.92905}, "CVE-2007-2242": {"epss_score": 0.33385, "epss_percentile": 0.96768}, "CVE-2007-2243": {"epss_score": 0.00463, "epss_percentile": 0.63692}, "CVE-2007-2244": {"epss_score": 0.21845, "epss_percentile": 0.95566}, "CVE-2007-2245": {"epss_score": 0.01975, "epss_percentile": 0.83119}, "CVE-2007-2246": {"epss_score": 0.02597, "epss_percentile": 0.85201}, "CVE-2007-2247": {"epss_score": 0.01062, "epss_percentile": 0.77181}, "CVE-2007-2248": {"epss_score": 0.07843, "epss_percentile": 0.91715}, "CVE-2007-2249": {"epss_score": 0.15918, "epss_percentile": 0.94535}, "CVE-2007-2250": {"epss_score": 0.12584, "epss_percentile": 0.93722}, "CVE-2007-2251": {"epss_score": 0.00743, "epss_percentile": 0.72481}, "CVE-2007-2252": {"epss_score": 0.04597, "epss_percentile": 0.88899}, "CVE-2007-2253": {"epss_score": 0.00389, "epss_percentile": 0.59403}, "CVE-2007-2254": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2007-2255": {"epss_score": 0.01155, "epss_percentile": 0.78079}, "CVE-2007-2256": {"epss_score": 0.06183, "epss_percentile": 0.90539}, "CVE-2007-2257": {"epss_score": 0.02729, "epss_percentile": 0.85535}, "CVE-2007-2258": {"epss_score": 0.025, "epss_percentile": 0.8492}, "CVE-2007-2259": {"epss_score": 0.0157, "epss_percentile": 0.81084}, "CVE-2007-2260": {"epss_score": 0.02462, "epss_percentile": 0.84827}, "CVE-2007-2261": {"epss_score": 0.00867, "epss_percentile": 0.74652}, "CVE-2007-2262": {"epss_score": 0.0665, "epss_percentile": 0.90916}, "CVE-2007-2263": {"epss_score": 0.10003, "epss_percentile": 0.92812}, "CVE-2007-2264": {"epss_score": 0.12025, "epss_percentile": 0.9355}, "CVE-2007-2265": {"epss_score": 0.00968, "epss_percentile": 0.76087}, "CVE-2007-2266": {"epss_score": 0.03961, "epss_percentile": 0.88014}, "CVE-2007-2267": {"epss_score": 0.01391, "epss_percentile": 0.79953}, "CVE-2007-2268": {"epss_score": 0.05691, "epss_percentile": 0.90124}, "CVE-2007-2269": {"epss_score": 0.00291, "epss_percentile": 0.52147}, "CVE-2007-2270": {"epss_score": 0.41677, "epss_percentile": 0.97288}, "CVE-2007-2271": {"epss_score": 0.0702, "epss_percentile": 0.91191}, "CVE-2007-2272": {"epss_score": 0.05096, "epss_percentile": 0.89492}, "CVE-2007-2273": {"epss_score": 0.11649, "epss_percentile": 0.93434}, "CVE-2007-2274": {"epss_score": 0.07365, "epss_percentile": 0.91435}, "CVE-2007-2275": {"epss_score": 0.00104, "epss_percentile": 0.29127}, "CVE-2007-2276": {"epss_score": 0.00837, "epss_percentile": 0.7416}, "CVE-2007-2277": {"epss_score": 0.00775, "epss_percentile": 0.73078}, "CVE-2007-2278": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2007-2279": {"epss_score": 0.07404, "epss_percentile": 0.91454}, "CVE-2007-2280": {"epss_score": 0.71004, "epss_percentile": 0.98649}, "CVE-2007-2281": {"epss_score": 0.07118, "epss_percentile": 0.91262}, "CVE-2007-2282": {"epss_score": 0.01619, "epss_percentile": 0.81379}, "CVE-2007-2283": {"epss_score": 0.20226, "epss_percentile": 0.95306}, "CVE-2007-2284": {"epss_score": 0.20226, "epss_percentile": 0.95306}, "CVE-2007-2285": {"epss_score": 0.11266, "epss_percentile": 0.93286}, "CVE-2007-2286": {"epss_score": 0.0069, "epss_percentile": 0.71256}, "CVE-2007-2287": {"epss_score": 0.01739, "epss_percentile": 0.82041}, "CVE-2007-2288": {"epss_score": 0.01739, "epss_percentile": 0.82041}, "CVE-2007-2289": {"epss_score": 0.0069, "epss_percentile": 0.71256}, "CVE-2007-2290": {"epss_score": 0.07244, "epss_percentile": 0.91347}, "CVE-2007-2291": {"epss_score": 0.40389, "epss_percentile": 0.97216}, "CVE-2007-2292": {"epss_score": 0.01567, "epss_percentile": 0.81072}, "CVE-2007-2293": {"epss_score": 0.41573, "epss_percentile": 0.97284}, "CVE-2007-2294": {"epss_score": 0.04612, "epss_percentile": 0.88916}, "CVE-2007-2295": {"epss_score": 0.40618, "epss_percentile": 0.97226}, "CVE-2007-2296": {"epss_score": 0.28604, "epss_percentile": 0.96371}, "CVE-2007-2297": {"epss_score": 0.02101, "epss_percentile": 0.83601}, "CVE-2007-2298": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2007-2299": {"epss_score": 0.01339, "epss_percentile": 0.79571}, "CVE-2007-2300": {"epss_score": 0.02671, "epss_percentile": 0.85389}, "CVE-2007-2301": {"epss_score": 0.04086, "epss_percentile": 0.88226}, "CVE-2007-2302": {"epss_score": 0.05338, "epss_percentile": 0.89756}, "CVE-2007-2303": {"epss_score": 0.0721, "epss_percentile": 0.91328}, "CVE-2007-2304": {"epss_score": 0.08535, "epss_percentile": 0.92108}, "CVE-2007-2305": {"epss_score": 0.00714, "epss_percentile": 0.71813}, "CVE-2007-2306": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2007-2307": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2007-2308": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2007-2309": {"epss_score": 0.00286, "epss_percentile": 0.51715}, "CVE-2007-2310": {"epss_score": 0.02503, "epss_percentile": 0.84928}, "CVE-2007-2311": {"epss_score": 0.01019, "epss_percentile": 0.76729}, "CVE-2007-2312": {"epss_score": 0.00868, "epss_percentile": 0.74676}, "CVE-2007-2313": {"epss_score": 0.05096, "epss_percentile": 0.89492}, "CVE-2007-2314": {"epss_score": 0.01637, "epss_percentile": 0.81482}, "CVE-2007-2315": {"epss_score": 0.00761, "epss_percentile": 0.72822}, "CVE-2007-2316": {"epss_score": 0.01236, "epss_percentile": 0.78771}, "CVE-2007-2317": {"epss_score": 0.07643, "epss_percentile": 0.91596}, "CVE-2007-2318": {"epss_score": 0.02426, "epss_percentile": 0.84717}, "CVE-2007-2319": {"epss_score": 0.06752, "epss_percentile": 0.91003}, "CVE-2007-2320": {"epss_score": 0.01294, "epss_percentile": 0.79247}, "CVE-2007-2321": {"epss_score": 0.00475, "epss_percentile": 0.64175}, "CVE-2007-2322": {"epss_score": 0.01409, "epss_percentile": 0.80075}, "CVE-2007-2323": {"epss_score": 0.05993, "epss_percentile": 0.90389}, "CVE-2007-2324": {"epss_score": 0.06187, "epss_percentile": 0.90544}, "CVE-2007-2325": {"epss_score": 0.01507, "epss_percentile": 0.80756}, "CVE-2007-2326": {"epss_score": 0.025, "epss_percentile": 0.8492}, "CVE-2007-2327": {"epss_score": 0.03149, "epss_percentile": 0.86502}, "CVE-2007-2328": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2007-2329": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2007-2330": {"epss_score": 0.06124, "epss_percentile": 0.90497}, "CVE-2007-2331": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2007-2332": {"epss_score": 0.00566, "epss_percentile": 0.67821}, "CVE-2007-2333": {"epss_score": 0.0251, "epss_percentile": 0.8495}, "CVE-2007-2334": {"epss_score": 0.01155, "epss_percentile": 0.78079}, "CVE-2007-2335": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-2336": {"epss_score": 0.00488, "epss_percentile": 0.64864}, "CVE-2007-2337": {"epss_score": 0.02031, "epss_percentile": 0.83332}, "CVE-2007-2338": {"epss_score": 0.18081, "epss_percentile": 0.94953}, "CVE-2007-2339": {"epss_score": 0.03275, "epss_percentile": 0.86802}, "CVE-2007-2340": {"epss_score": 0.33868, "epss_percentile": 0.96811}, "CVE-2007-2341": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2007-2342": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-2343": {"epss_score": 0.06854, "epss_percentile": 0.91077}, "CVE-2007-2344": {"epss_score": 0.01542, "epss_percentile": 0.80951}, "CVE-2007-2345": {"epss_score": 0.04086, "epss_percentile": 0.88226}, "CVE-2007-2346": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2007-2347": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2007-2348": {"epss_score": 0.02889, "epss_percentile": 0.85915}, "CVE-2007-2349": {"epss_score": 0.00437, "epss_percentile": 0.6252}, "CVE-2007-2350": {"epss_score": 0.00925, "epss_percentile": 0.75528}, "CVE-2007-2351": {"epss_score": 0.00219, "epss_percentile": 0.44522}, "CVE-2007-2352": {"epss_score": 0.10593, "epss_percentile": 0.9304}, "CVE-2007-2353": {"epss_score": 0.04226, "epss_percentile": 0.88415}, "CVE-2007-2354": {"epss_score": 0.04656, "epss_percentile": 0.88971}, "CVE-2007-2355": {"epss_score": 0.08239, "epss_percentile": 0.91945}, "CVE-2007-2356": {"epss_score": 0.3327, "epss_percentile": 0.96758}, "CVE-2007-2357": {"epss_score": 0.016, "epss_percentile": 0.8126}, "CVE-2007-2358": {"epss_score": 0.01323, "epss_percentile": 0.79454}, "CVE-2007-2359": {"epss_score": 0.00205, "epss_percentile": 0.4274}, "CVE-2007-2360": {"epss_score": 0.00235, "epss_percentile": 0.46336}, "CVE-2007-2361": {"epss_score": 0.00073, "epss_percentile": 0.22643}, "CVE-2007-2362": {"epss_score": 0.28463, "epss_percentile": 0.96359}, "CVE-2007-2363": {"epss_score": 0.28642, "epss_percentile": 0.96374}, "CVE-2007-2364": {"epss_score": 0.08615, "epss_percentile": 0.92153}, "CVE-2007-2365": {"epss_score": 0.58644, "epss_percentile": 0.9813}, "CVE-2007-2366": {"epss_score": 0.64887, "epss_percentile": 0.98397}, "CVE-2007-2367": {"epss_score": 0.03416, "epss_percentile": 0.87092}, "CVE-2007-2368": {"epss_score": 0.05379, "epss_percentile": 0.89808}, "CVE-2007-2369": {"epss_score": 0.04353, "epss_percentile": 0.88588}, "CVE-2007-2370": {"epss_score": 0.00667, "epss_percentile": 0.70703}, "CVE-2007-2371": {"epss_score": 0.05024, "epss_percentile": 0.89408}, "CVE-2007-2372": {"epss_score": 0.05958, "epss_percentile": 0.90364}, "CVE-2007-2373": {"epss_score": 0.02098, "epss_percentile": 0.83591}, "CVE-2007-2374": {"epss_score": 0.43288, "epss_percentile": 0.9738}, "CVE-2007-2375": {"epss_score": 0.0803, "epss_percentile": 0.91841}, "CVE-2007-2376": {"epss_score": 0.00431, "epss_percentile": 0.62087}, "CVE-2007-2377": {"epss_score": 0.00487, "epss_percentile": 0.64803}, "CVE-2007-2378": {"epss_score": 0.00377, "epss_percentile": 0.58721}, "CVE-2007-2379": {"epss_score": 0.01316, "epss_percentile": 0.7941}, "CVE-2007-2380": {"epss_score": 0.31328, "epss_percentile": 0.96611}, "CVE-2007-2381": {"epss_score": 0.00431, "epss_percentile": 0.62087}, "CVE-2007-2382": {"epss_score": 0.00431, "epss_percentile": 0.62087}, "CVE-2007-2383": {"epss_score": 0.00495, "epss_percentile": 0.65132}, "CVE-2007-2384": {"epss_score": 0.00331, "epss_percentile": 0.55538}, "CVE-2007-2385": {"epss_score": 0.00744, "epss_percentile": 0.72509}, "CVE-2007-2386": {"epss_score": 0.71927, "epss_percentile": 0.98687}, "CVE-2007-2387": {"epss_score": 0.03273, "epss_percentile": 0.86798}, "CVE-2007-2388": {"epss_score": 0.0508, "epss_percentile": 0.89471}, "CVE-2007-2389": {"epss_score": 0.00662, "epss_percentile": 0.70594}, "CVE-2007-2390": {"epss_score": 0.28534, "epss_percentile": 0.96366}, "CVE-2007-2391": {"epss_score": 0.00537, "epss_percentile": 0.66918}, "CVE-2007-2392": {"epss_score": 0.10438, "epss_percentile": 0.92987}, "CVE-2007-2393": {"epss_score": 0.11782, "epss_percentile": 0.93473}, "CVE-2007-2394": {"epss_score": 0.48805, "epss_percentile": 0.97656}, "CVE-2007-2395": {"epss_score": 0.17103, "epss_percentile": 0.94775}, "CVE-2007-2396": {"epss_score": 0.29102, "epss_percentile": 0.96417}, "CVE-2007-2397": {"epss_score": 0.38251, "epss_percentile": 0.97092}, "CVE-2007-2398": {"epss_score": 0.01558, "epss_percentile": 0.81022}, "CVE-2007-2399": {"epss_score": 0.15085, "epss_percentile": 0.94359}, "CVE-2007-2400": {"epss_score": 0.00439, "epss_percentile": 0.62607}, "CVE-2007-2401": {"epss_score": 0.03181, "epss_percentile": 0.86581}, "CVE-2007-2402": {"epss_score": 0.01166, "epss_percentile": 0.78183}, "CVE-2007-2403": {"epss_score": 0.01039, "epss_percentile": 0.76942}, "CVE-2007-2404": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2007-2405": {"epss_score": 0.00757, "epss_percentile": 0.72755}, "CVE-2007-2406": {"epss_score": 0.03927, "epss_percentile": 0.87966}, "CVE-2007-2407": {"epss_score": 0.02849, "epss_percentile": 0.85827}, "CVE-2007-2408": {"epss_score": 0.00756, "epss_percentile": 0.72734}, "CVE-2007-2409": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-2410": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-2411": {"epss_score": 0.01901, "epss_percentile": 0.82778}, "CVE-2007-2412": {"epss_score": 0.00494, "epss_percentile": 0.65066}, "CVE-2007-2414": {"epss_score": 0.01689, "epss_percentile": 0.81769}, "CVE-2007-2415": {"epss_score": 0.00716, "epss_percentile": 0.71855}, "CVE-2007-2416": {"epss_score": 0.00825, "epss_percentile": 0.7395}, "CVE-2007-2417": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2007-2418": {"epss_score": 0.27841, "epss_percentile": 0.96287}, "CVE-2007-2419": {"epss_score": 0.21718, "epss_percentile": 0.95552}, "CVE-2007-2420": {"epss_score": 0.01114, "epss_percentile": 0.777}, "CVE-2007-2421": {"epss_score": 0.12535, "epss_percentile": 0.9371}, "CVE-2007-2422": {"epss_score": 0.01198, "epss_percentile": 0.78454}, "CVE-2007-2423": {"epss_score": 0.06345, "epss_percentile": 0.90686}, "CVE-2007-2424": {"epss_score": 0.14417, "epss_percentile": 0.94207}, "CVE-2007-2425": {"epss_score": 0.12347, "epss_percentile": 0.93646}, "CVE-2007-2426": {"epss_score": 0.04715, "epss_percentile": 0.89043}, "CVE-2007-2427": {"epss_score": 0.02168, "epss_percentile": 0.83859}, "CVE-2007-2428": {"epss_score": 0.06097, "epss_percentile": 0.90478}, "CVE-2007-2429": {"epss_score": 0.06378, "epss_percentile": 0.90709}, "CVE-2007-2430": {"epss_score": 0.08957, "epss_percentile": 0.92336}, "CVE-2007-2431": {"epss_score": 0.12966, "epss_percentile": 0.93831}, "CVE-2007-2432": {"epss_score": 0.01132, "epss_percentile": 0.77867}, "CVE-2007-2433": {"epss_score": 0.01132, "epss_percentile": 0.77867}, "CVE-2007-2434": {"epss_score": 0.11631, "epss_percentile": 0.93424}, "CVE-2007-2435": {"epss_score": 0.02917, "epss_percentile": 0.85984}, "CVE-2007-2437": {"epss_score": 0.03434, "epss_percentile": 0.87129}, "CVE-2007-2438": {"epss_score": 0.13793, "epss_percentile": 0.94058}, "CVE-2007-2439": {"epss_score": 0.01619, "epss_percentile": 0.81381}, "CVE-2007-2440": {"epss_score": 0.1041, "epss_percentile": 0.92978}, "CVE-2007-2441": {"epss_score": 0.0992, "epss_percentile": 0.92771}, "CVE-2007-2442": {"epss_score": 0.41702, "epss_percentile": 0.9729}, "CVE-2007-2443": {"epss_score": 0.31541, "epss_percentile": 0.96626}, "CVE-2007-2444": {"epss_score": 0.01051, "epss_percentile": 0.77079}, "CVE-2007-2445": {"epss_score": 0.38264, "epss_percentile": 0.97093}, "CVE-2007-2446": {"epss_score": 0.88952, "epss_percentile": 0.99501}, "CVE-2007-2447": {"epss_score": 0.7634, "epss_percentile": 0.98886}, "CVE-2007-2448": {"epss_score": 0.00254, "epss_percentile": 0.48621}, "CVE-2007-2449": {"epss_score": 0.80643, "epss_percentile": 0.99099}, "CVE-2007-2450": {"epss_score": 0.01256, "epss_percentile": 0.78933}, "CVE-2007-2451": {"epss_score": 0.00858, "epss_percentile": 0.74498}, "CVE-2007-2452": {"epss_score": 0.01613, "epss_percentile": 0.81339}, "CVE-2007-2453": {"epss_score": 0.00105, "epss_percentile": 0.29253}, "CVE-2007-2454": {"epss_score": 0.00198, "epss_percentile": 0.4209}, "CVE-2007-2455": {"epss_score": 0.00234, "epss_percentile": 0.46123}, "CVE-2007-2456": {"epss_score": 0.16126, "epss_percentile": 0.94577}, "CVE-2007-2457": {"epss_score": 0.13238, "epss_percentile": 0.93908}, "CVE-2007-2458": {"epss_score": 0.10087, "epss_percentile": 0.92845}, "CVE-2007-2459": {"epss_score": 0.06422, "epss_percentile": 0.90751}, "CVE-2007-2460": {"epss_score": 0.00909, "epss_percentile": 0.75312}, "CVE-2007-2461": {"epss_score": 0.06622, "epss_percentile": 0.90895}, "CVE-2007-2462": {"epss_score": 0.04134, "epss_percentile": 0.88304}, "CVE-2007-2463": {"epss_score": 0.01575, "epss_percentile": 0.81106}, "CVE-2007-2464": {"epss_score": 0.02419, "epss_percentile": 0.84698}, "CVE-2007-2465": {"epss_score": 0.00064, "epss_percentile": 0.20304}, "CVE-2007-2466": {"epss_score": 0.02106, "epss_percentile": 0.83632}, "CVE-2007-2467": {"epss_score": 0.00054, "epss_percentile": 0.17046}, "CVE-2007-2468": {"epss_score": 0.00161, "epss_percentile": 0.37539}, "CVE-2007-2469": {"epss_score": 0.00769, "epss_percentile": 0.7298}, "CVE-2007-2470": {"epss_score": 0.00509, "epss_percentile": 0.65741}, "CVE-2007-2471": {"epss_score": 0.07032, "epss_percentile": 0.91201}, "CVE-2007-2472": {"epss_score": 0.00402, "epss_percentile": 0.60285}, "CVE-2007-2473": {"epss_score": 0.01289, "epss_percentile": 0.79209}, "CVE-2007-2474": {"epss_score": 0.04695, "epss_percentile": 0.89016}, "CVE-2007-2475": {"epss_score": 0.00279, "epss_percentile": 0.50929}, "CVE-2007-2476": {"epss_score": 0.00741, "epss_percentile": 0.72439}, "CVE-2007-2477": {"epss_score": 0.01174, "epss_percentile": 0.78245}, "CVE-2007-2478": {"epss_score": 0.20801, "epss_percentile": 0.95414}, "CVE-2007-2479": {"epss_score": 0.01447, "epss_percentile": 0.80332}, "CVE-2007-2480": {"epss_score": 0.00142, "epss_percentile": 0.35042}, "CVE-2007-2481": {"epss_score": 0.04812, "epss_percentile": 0.89168}, "CVE-2007-2482": {"epss_score": 0.28448, "epss_percentile": 0.96358}, "CVE-2007-2483": {"epss_score": 0.1518, "epss_percentile": 0.94379}, "CVE-2007-2484": {"epss_score": 0.04383, "epss_percentile": 0.88627}, "CVE-2007-2485": {"epss_score": 0.05942, "epss_percentile": 0.90351}, "CVE-2007-2486": {"epss_score": 0.07287, "epss_percentile": 0.91384}, "CVE-2007-2487": {"epss_score": 0.12607, "epss_percentile": 0.93727}, "CVE-2007-2488": {"epss_score": 0.03192, "epss_percentile": 0.86604}, "CVE-2007-2489": {"epss_score": 0.20434, "epss_percentile": 0.95345}, "CVE-2007-2490": {"epss_score": 0.02632, "epss_percentile": 0.85286}, "CVE-2007-2491": {"epss_score": 0.0004, "epss_percentile": 0.11876}, "CVE-2007-2492": {"epss_score": 0.01563, "epss_percentile": 0.81056}, "CVE-2007-2493": {"epss_score": 0.04826, "epss_percentile": 0.89185}, "CVE-2007-2494": {"epss_score": 0.106, "epss_percentile": 0.93042}, "CVE-2007-2495": {"epss_score": 0.11992, "epss_percentile": 0.93539}, "CVE-2007-2496": {"epss_score": 0.06208, "epss_percentile": 0.90567}, "CVE-2007-2497": {"epss_score": 0.04282, "epss_percentile": 0.8849}, "CVE-2007-2498": {"epss_score": 0.09223, "epss_percentile": 0.92456}, "CVE-2007-2499": {"epss_score": 0.01275, "epss_percentile": 0.79101}, "CVE-2007-2500": {"epss_score": 0.1372, "epss_percentile": 0.94042}, "CVE-2007-2501": {"epss_score": 0.03286, "epss_percentile": 0.86828}, "CVE-2007-2502": {"epss_score": 0.02838, "epss_percentile": 0.85794}, "CVE-2007-2503": {"epss_score": 0.06117, "epss_percentile": 0.90491}, "CVE-2007-2504": {"epss_score": 0.01037, "epss_percentile": 0.76927}, "CVE-2007-2505": {"epss_score": 0.16608, "epss_percentile": 0.94702}, "CVE-2007-2506": {"epss_score": 0.01352, "epss_percentile": 0.79693}, "CVE-2007-2507": {"epss_score": 0.11595, "epss_percentile": 0.93414}, "CVE-2007-2508": {"epss_score": 0.79039, "epss_percentile": 0.99016}, "CVE-2007-2509": {"epss_score": 0.0629, "epss_percentile": 0.90648}, "CVE-2007-2510": {"epss_score": 0.04544, "epss_percentile": 0.88832}, "CVE-2007-2511": {"epss_score": 0.00088, "epss_percentile": 0.25653}, "CVE-2007-2512": {"epss_score": 0.00494, "epss_percentile": 0.65093}, "CVE-2007-2513": {"epss_score": 0.02968, "epss_percentile": 0.86088}, "CVE-2007-2514": {"epss_score": 0.1162, "epss_percentile": 0.93422}, "CVE-2007-2519": {"epss_score": 0.04347, "epss_percentile": 0.88579}, "CVE-2007-2520": {"epss_score": 0.00549, "epss_percentile": 0.67294}, "CVE-2007-2521": {"epss_score": 0.10534, "epss_percentile": 0.9302}, "CVE-2007-2522": {"epss_score": 0.45266, "epss_percentile": 0.97479}, "CVE-2007-2523": {"epss_score": 0.00536, "epss_percentile": 0.66858}, "CVE-2007-2524": {"epss_score": 0.05656, "epss_percentile": 0.9009}, "CVE-2007-2525": {"epss_score": 0.00114, "epss_percentile": 0.30805}, "CVE-2007-2526": {"epss_score": 0.19591, "epss_percentile": 0.95212}, "CVE-2007-2527": {"epss_score": 0.11063, "epss_percentile": 0.93207}, "CVE-2007-2528": {"epss_score": 0.04468, "epss_percentile": 0.88731}, "CVE-2007-2529": {"epss_score": 0.00061, "epss_percentile": 0.19338}, "CVE-2007-2530": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-2531": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-2532": {"epss_score": 0.09951, "epss_percentile": 0.92787}, "CVE-2007-2533": {"epss_score": 0.19669, "epss_percentile": 0.95223}, "CVE-2007-2534": {"epss_score": 0.00849, "epss_percentile": 0.74381}, "CVE-2007-2535": {"epss_score": 0.01011, "epss_percentile": 0.76607}, "CVE-2007-2536": {"epss_score": 0.05168, "epss_percentile": 0.89567}, "CVE-2007-2537": {"epss_score": 0.0074, "epss_percentile": 0.72401}, "CVE-2007-2538": {"epss_score": 0.02821, "epss_percentile": 0.85744}, "CVE-2007-2539": {"epss_score": 0.06865, "epss_percentile": 0.91082}, "CVE-2007-2540": {"epss_score": 0.1048, "epss_percentile": 0.93001}, "CVE-2007-2541": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2007-2542": {"epss_score": 0.06729, "epss_percentile": 0.90978}, "CVE-2007-2543": {"epss_score": 0.01511, "epss_percentile": 0.8078}, "CVE-2007-2544": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2007-2545": {"epss_score": 0.75774, "epss_percentile": 0.98863}, "CVE-2007-2546": {"epss_score": 0.01175, "epss_percentile": 0.78258}, "CVE-2007-2547": {"epss_score": 0.03175, "epss_percentile": 0.86566}, "CVE-2007-2548": {"epss_score": 0.00388, "epss_percentile": 0.59371}, "CVE-2007-2549": {"epss_score": 0.00802, "epss_percentile": 0.73583}, "CVE-2007-2550": {"epss_score": 0.00706, "epss_percentile": 0.71611}, "CVE-2007-2551": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-2552": {"epss_score": 0.00622, "epss_percentile": 0.69532}, "CVE-2007-2553": {"epss_score": 0.00387, "epss_percentile": 0.5929}, "CVE-2007-2554": {"epss_score": 0.00334, "epss_percentile": 0.55728}, "CVE-2007-2555": {"epss_score": 0.00347, "epss_percentile": 0.56782}, "CVE-2007-2556": {"epss_score": 0.05519, "epss_percentile": 0.89954}, "CVE-2007-2557": {"epss_score": 0.00235, "epss_percentile": 0.46217}, "CVE-2007-2558": {"epss_score": 0.01037, "epss_percentile": 0.76927}, "CVE-2007-2559": {"epss_score": 0.01155, "epss_percentile": 0.78079}, "CVE-2007-2560": {"epss_score": 0.06381, "epss_percentile": 0.90712}, "CVE-2007-2561": {"epss_score": 0.00775, "epss_percentile": 0.73077}, "CVE-2007-2562": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-2563": {"epss_score": 0.0726, "epss_percentile": 0.91355}, "CVE-2007-2564": {"epss_score": 0.06241, "epss_percentile": 0.90593}, "CVE-2007-2565": {"epss_score": 0.04616, "epss_percentile": 0.88924}, "CVE-2007-2566": {"epss_score": 0.05351, "epss_percentile": 0.89773}, "CVE-2007-2567": {"epss_score": 0.04089, "epss_percentile": 0.88235}, "CVE-2007-2568": {"epss_score": 0.061, "epss_percentile": 0.90481}, "CVE-2007-2569": {"epss_score": 0.07793, "epss_percentile": 0.91684}, "CVE-2007-2570": {"epss_score": 0.11257, "epss_percentile": 0.93281}, "CVE-2007-2571": {"epss_score": 0.00741, "epss_percentile": 0.72414}, "CVE-2007-2572": {"epss_score": 0.04762, "epss_percentile": 0.89119}, "CVE-2007-2573": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2007-2574": {"epss_score": 0.05379, "epss_percentile": 0.89808}, "CVE-2007-2575": {"epss_score": 0.06198, "epss_percentile": 0.90557}, "CVE-2007-2576": {"epss_score": 0.21458, "epss_percentile": 0.95521}, "CVE-2007-2577": {"epss_score": 0.0108, "epss_percentile": 0.77366}, "CVE-2007-2578": {"epss_score": 0.00867, "epss_percentile": 0.74652}, "CVE-2007-2579": {"epss_score": 0.00791, "epss_percentile": 0.73387}, "CVE-2007-2580": {"epss_score": 0.00275, "epss_percentile": 0.50679}, "CVE-2007-2581": {"epss_score": 0.73737, "epss_percentile": 0.9877}, "CVE-2007-2582": {"epss_score": 0.21428, "epss_percentile": 0.95516}, "CVE-2007-2583": {"epss_score": 0.03079, "epss_percentile": 0.86367}, "CVE-2007-2584": {"epss_score": 0.35107, "epss_percentile": 0.96887}, "CVE-2007-2585": {"epss_score": 0.08815, "epss_percentile": 0.92268}, "CVE-2007-2586": {"epss_score": 0.60748, "epss_percentile": 0.98218}, "CVE-2007-2587": {"epss_score": 0.01138, "epss_percentile": 0.77931}, "CVE-2007-2588": {"epss_score": 0.06774, "epss_percentile": 0.91018}, "CVE-2007-2589": {"epss_score": 0.01197, "epss_percentile": 0.78448}, "CVE-2007-2590": {"epss_score": 0.00622, "epss_percentile": 0.69532}, "CVE-2007-2591": {"epss_score": 0.01224, "epss_percentile": 0.78676}, "CVE-2007-2592": {"epss_score": 0.01555, "epss_percentile": 0.81014}, "CVE-2007-2593": {"epss_score": 0.04595, "epss_percentile": 0.88896}, "CVE-2007-2594": {"epss_score": 0.10574, "epss_percentile": 0.93032}, "CVE-2007-2595": {"epss_score": 0.00607, "epss_percentile": 0.6905}, "CVE-2007-2596": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-2597": {"epss_score": 0.12828, "epss_percentile": 0.93796}, "CVE-2007-2598": {"epss_score": 0.01092, "epss_percentile": 0.77469}, "CVE-2007-2599": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2007-2600": {"epss_score": 0.11577, "epss_percentile": 0.93409}, "CVE-2007-2601": {"epss_score": 0.16545, "epss_percentile": 0.94687}, "CVE-2007-2602": {"epss_score": 0.03424, "epss_percentile": 0.87111}, "CVE-2007-2603": {"epss_score": 0.00882, "epss_percentile": 0.74892}, "CVE-2007-2604": {"epss_score": 0.00803, "epss_percentile": 0.736}, "CVE-2007-2605": {"epss_score": 0.0053, "epss_percentile": 0.66612}, "CVE-2007-2606": {"epss_score": 0.0084, "epss_percentile": 0.74214}, "CVE-2007-2607": {"epss_score": 0.84412, "epss_percentile": 0.99288}, "CVE-2007-2608": {"epss_score": 0.0638, "epss_percentile": 0.90711}, "CVE-2007-2609": {"epss_score": 0.08605, "epss_percentile": 0.92146}, "CVE-2007-2610": {"epss_score": 0.00537, "epss_percentile": 0.66891}, "CVE-2007-2611": {"epss_score": 0.2126, "epss_percentile": 0.95489}, "CVE-2007-2612": {"epss_score": 0.00484, "epss_percentile": 0.64627}, "CVE-2007-2613": {"epss_score": 0.0012, "epss_percentile": 0.31781}, "CVE-2007-2614": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2007-2615": {"epss_score": 0.08985, "epss_percentile": 0.92353}, "CVE-2007-2616": {"epss_score": 0.49996, "epss_percentile": 0.97713}, "CVE-2007-2617": {"epss_score": 0.10401, "epss_percentile": 0.92975}, "CVE-2007-2618": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2007-2619": {"epss_score": 0.0011, "epss_percentile": 0.30192}, "CVE-2007-2620": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-2621": {"epss_score": 0.00932, "epss_percentile": 0.75622}, "CVE-2007-2622": {"epss_score": 0.01295, "epss_percentile": 0.79252}, "CVE-2007-2623": {"epss_score": 0.12172, "epss_percentile": 0.9359}, "CVE-2007-2624": {"epss_score": 0.01081, "epss_percentile": 0.77377}, "CVE-2007-2625": {"epss_score": 0.00762, "epss_percentile": 0.72845}, "CVE-2007-2626": {"epss_score": 0.00764, "epss_percentile": 0.729}, "CVE-2007-2627": {"epss_score": 0.00837, "epss_percentile": 0.74165}, "CVE-2007-2628": {"epss_score": 0.03149, "epss_percentile": 0.86502}, "CVE-2007-2629": {"epss_score": 0.00523, "epss_percentile": 0.66286}, "CVE-2007-2630": {"epss_score": 0.01161, "epss_percentile": 0.78145}, "CVE-2007-2631": {"epss_score": 0.00797, "epss_percentile": 0.73499}, "CVE-2007-2632": {"epss_score": 0.09088, "epss_percentile": 0.92396}, "CVE-2007-2633": {"epss_score": 0.00853, "epss_percentile": 0.74425}, "CVE-2007-2634": {"epss_score": 0.02177, "epss_percentile": 0.83887}, "CVE-2007-2635": {"epss_score": 0.02257, "epss_percentile": 0.84175}, "CVE-2007-2636": {"epss_score": 0.00667, "epss_percentile": 0.70705}, "CVE-2007-2637": {"epss_score": 0.00574, "epss_percentile": 0.68078}, "CVE-2007-2638": {"epss_score": 0.01618, "epss_percentile": 0.81372}, "CVE-2007-2639": {"epss_score": 0.0365, "epss_percentile": 0.87507}, "CVE-2007-2640": {"epss_score": 0.00539, "epss_percentile": 0.66981}, "CVE-2007-2641": {"epss_score": 0.02561, "epss_percentile": 0.85104}, "CVE-2007-2642": {"epss_score": 0.13484, "epss_percentile": 0.93978}, "CVE-2007-2643": {"epss_score": 0.11947, "epss_percentile": 0.93523}, "CVE-2007-2644": {"epss_score": 0.09004, "epss_percentile": 0.92359}, "CVE-2007-2645": {"epss_score": 0.29565, "epss_percentile": 0.96457}, "CVE-2007-2646": {"epss_score": 0.08988, "epss_percentile": 0.92354}, "CVE-2007-2647": {"epss_score": 0.12579, "epss_percentile": 0.9372}, "CVE-2007-2648": {"epss_score": 0.06548, "epss_percentile": 0.90842}, "CVE-2007-2649": {"epss_score": 0.0231, "epss_percentile": 0.84336}, "CVE-2007-2650": {"epss_score": 0.04088, "epss_percentile": 0.8823}, "CVE-2007-2651": {"epss_score": 0.03286, "epss_percentile": 0.86828}, "CVE-2007-2652": {"epss_score": 0.03528, "epss_percentile": 0.87297}, "CVE-2007-2654": {"epss_score": 0.00043, "epss_percentile": 0.12999}, "CVE-2007-2655": {"epss_score": 0.03524, "epss_percentile": 0.87291}, "CVE-2007-2656": {"epss_score": 0.17807, "epss_percentile": 0.94909}, "CVE-2007-2657": {"epss_score": 0.15991, "epss_percentile": 0.9455}, "CVE-2007-2658": {"epss_score": 0.15563, "epss_percentile": 0.94459}, "CVE-2007-2659": {"epss_score": 0.04969, "epss_percentile": 0.89347}, "CVE-2007-2660": {"epss_score": 0.13678, "epss_percentile": 0.94032}, "CVE-2007-2661": {"epss_score": 0.01462, "epss_percentile": 0.80438}, "CVE-2007-2662": {"epss_score": 0.00807, "epss_percentile": 0.73676}, "CVE-2007-2663": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2007-2664": {"epss_score": 0.06847, "epss_percentile": 0.91069}, "CVE-2007-2665": {"epss_score": 0.04745, "epss_percentile": 0.89095}, "CVE-2007-2666": {"epss_score": 0.19106, "epss_percentile": 0.9513}, "CVE-2007-2667": {"epss_score": 0.20343, "epss_percentile": 0.95328}, "CVE-2007-2668": {"epss_score": 0.17187, "epss_percentile": 0.94794}, "CVE-2007-2669": {"epss_score": 0.0077, "epss_percentile": 0.73006}, "CVE-2007-2670": {"epss_score": 0.00574, "epss_percentile": 0.68078}, "CVE-2007-2671": {"epss_score": 0.06763, "epss_percentile": 0.91011}, "CVE-2007-2672": {"epss_score": 0.00963, "epss_percentile": 0.7602}, "CVE-2007-2673": {"epss_score": 0.00921, "epss_percentile": 0.75482}, "CVE-2007-2674": {"epss_score": 0.00678, "epss_percentile": 0.70999}, "CVE-2007-2675": {"epss_score": 0.04436, "epss_percentile": 0.88688}, "CVE-2007-2676": {"epss_score": 0.66266, "epss_percentile": 0.98458}, "CVE-2007-2677": {"epss_score": 0.09131, "epss_percentile": 0.92415}, "CVE-2007-2678": {"epss_score": 0.05271, "epss_percentile": 0.89679}, "CVE-2007-2679": {"epss_score": 0.00646, "epss_percentile": 0.70136}, "CVE-2007-2680": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-2681": {"epss_score": 0.00459, "epss_percentile": 0.63498}, "CVE-2007-2682": {"epss_score": 0.0154, "epss_percentile": 0.80942}, "CVE-2007-2683": {"epss_score": 0.00131, "epss_percentile": 0.33471}, "CVE-2007-2684": {"epss_score": 0.00931, "epss_percentile": 0.7562}, "CVE-2007-2685": {"epss_score": 0.00642, "epss_percentile": 0.70034}, "CVE-2007-2686": {"epss_score": 0.03455, "epss_percentile": 0.87172}, "CVE-2007-2687": {"epss_score": 0.23041, "epss_percentile": 0.95724}, "CVE-2007-2688": {"epss_score": 0.03974, "epss_percentile": 0.88047}, "CVE-2007-2689": {"epss_score": 0.01501, "epss_percentile": 0.8072}, "CVE-2007-2690": {"epss_score": 0.01501, "epss_percentile": 0.8072}, "CVE-2007-2691": {"epss_score": 0.01086, "epss_percentile": 0.77419}, "CVE-2007-2692": {"epss_score": 0.00687, "epss_percentile": 0.71182}, "CVE-2007-2693": {"epss_score": 0.00465, "epss_percentile": 0.63783}, "CVE-2007-2694": {"epss_score": 0.00507, "epss_percentile": 0.6565}, "CVE-2007-2695": {"epss_score": 0.02302, "epss_percentile": 0.84314}, "CVE-2007-2696": {"epss_score": 0.01422, "epss_percentile": 0.80179}, "CVE-2007-2697": {"epss_score": 0.01449, "epss_percentile": 0.80343}, "CVE-2007-2698": {"epss_score": 0.00312, "epss_percentile": 0.53967}, "CVE-2007-2699": {"epss_score": 0.01337, "epss_percentile": 0.79561}, "CVE-2007-2700": {"epss_score": 0.00339, "epss_percentile": 0.56203}, "CVE-2007-2701": {"epss_score": 0.00578, "epss_percentile": 0.68204}, "CVE-2007-2702": {"epss_score": 0.00623, "epss_percentile": 0.69535}, "CVE-2007-2703": {"epss_score": 0.00527, "epss_percentile": 0.66526}, "CVE-2007-2704": {"epss_score": 0.00881, "epss_percentile": 0.74872}, "CVE-2007-2705": {"epss_score": 0.00575, "epss_percentile": 0.68104}, "CVE-2007-2706": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-2707": {"epss_score": 0.85994, "epss_percentile": 0.99361}, "CVE-2007-2708": {"epss_score": 0.73748, "epss_percentile": 0.98771}, "CVE-2007-2709": {"epss_score": 0.16413, "epss_percentile": 0.94657}, "CVE-2007-2710": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2007-2711": {"epss_score": 0.81579, "epss_percentile": 0.99145}, "CVE-2007-2712": {"epss_score": 0.0064, "epss_percentile": 0.69962}, "CVE-2007-2713": {"epss_score": 0.02703, "epss_percentile": 0.85459}, "CVE-2007-2714": {"epss_score": 0.14939, "epss_percentile": 0.94328}, "CVE-2007-2715": {"epss_score": 0.07041, "epss_percentile": 0.91207}, "CVE-2007-2716": {"epss_score": 0.03672, "epss_percentile": 0.8754}, "CVE-2007-2717": {"epss_score": 0.00341, "epss_percentile": 0.56301}, "CVE-2007-2718": {"epss_score": 0.28844, "epss_percentile": 0.96394}, "CVE-2007-2719": {"epss_score": 0.07452, "epss_percentile": 0.91479}, "CVE-2007-2720": {"epss_score": 0.00465, "epss_percentile": 0.63748}, "CVE-2007-2721": {"epss_score": 0.08418, "epss_percentile": 0.92041}, "CVE-2007-2722": {"epss_score": 0.05741, "epss_percentile": 0.90172}, "CVE-2007-2723": {"epss_score": 0.00644, "epss_percentile": 0.70087}, "CVE-2007-2724": {"epss_score": 0.00785, "epss_percentile": 0.73259}, "CVE-2007-2725": {"epss_score": 0.03961, "epss_percentile": 0.88014}, "CVE-2007-2726": {"epss_score": 0.05741, "epss_percentile": 0.90172}, "CVE-2007-2727": {"epss_score": 0.00466, "epss_percentile": 0.63799}, "CVE-2007-2728": {"epss_score": 0.01396, "epss_percentile": 0.79979}, "CVE-2007-2729": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2007-2730": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2007-2731": {"epss_score": 0.01222, "epss_percentile": 0.78653}, "CVE-2007-2732": {"epss_score": 0.11208, "epss_percentile": 0.93265}, "CVE-2007-2733": {"epss_score": 0.0067, "epss_percentile": 0.70783}, "CVE-2007-2734": {"epss_score": 0.01784, "epss_percentile": 0.8225}, "CVE-2007-2735": {"epss_score": 0.01294, "epss_percentile": 0.79247}, "CVE-2007-2736": {"epss_score": 0.04337, "epss_percentile": 0.88564}, "CVE-2007-2737": {"epss_score": 0.00334, "epss_percentile": 0.55699}, "CVE-2007-2738": {"epss_score": 0.00714, "epss_percentile": 0.71813}, "CVE-2007-2739": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-2740": {"epss_score": 0.00602, "epss_percentile": 0.68883}, "CVE-2007-2741": {"epss_score": 0.15465, "epss_percentile": 0.94434}, "CVE-2007-2742": {"epss_score": 0.00725, "epss_percentile": 0.72045}, "CVE-2007-2743": {"epss_score": 0.1146, "epss_percentile": 0.93373}, "CVE-2007-2744": {"epss_score": 0.18727, "epss_percentile": 0.95059}, "CVE-2007-2745": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-2746": {"epss_score": 0.00242, "epss_percentile": 0.47353}, "CVE-2007-2747": {"epss_score": 0.09894, "epss_percentile": 0.92757}, "CVE-2007-2748": {"epss_score": 0.00557, "epss_percentile": 0.67535}, "CVE-2007-2749": {"epss_score": 0.00555, "epss_percentile": 0.67463}, "CVE-2007-2750": {"epss_score": 0.01252, "epss_percentile": 0.7891}, "CVE-2007-2751": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2007-2752": {"epss_score": 0.01294, "epss_percentile": 0.79247}, "CVE-2007-2753": {"epss_score": 0.02987, "epss_percentile": 0.86134}, "CVE-2007-2754": {"epss_score": 0.41922, "epss_percentile": 0.97301}, "CVE-2007-2755": {"epss_score": 0.0937, "epss_percentile": 0.9252}, "CVE-2007-2756": {"epss_score": 0.07124, "epss_percentile": 0.91265}, "CVE-2007-2757": {"epss_score": 0.045, "epss_percentile": 0.88766}, "CVE-2007-2758": {"epss_score": 0.12281, "epss_percentile": 0.93622}, "CVE-2007-2759": {"epss_score": 0.00589, "epss_percentile": 0.68512}, "CVE-2007-2760": {"epss_score": 0.00566, "epss_percentile": 0.67821}, "CVE-2007-2761": {"epss_score": 0.33102, "epss_percentile": 0.96746}, "CVE-2007-2762": {"epss_score": 0.09838, "epss_percentile": 0.92726}, "CVE-2007-2763": {"epss_score": 0.07975, "epss_percentile": 0.918}, "CVE-2007-2764": {"epss_score": 0.01061, "epss_percentile": 0.77172}, "CVE-2007-2765": {"epss_score": 0.01316, "epss_percentile": 0.79406}, "CVE-2007-2766": {"epss_score": 0.00056, "epss_percentile": 0.17729}, "CVE-2007-2767": {"epss_score": 0.00935, "epss_percentile": 0.75674}, "CVE-2007-2768": {"epss_score": 0.00119, "epss_percentile": 0.31534}, "CVE-2007-2769": {"epss_score": 0.00803, "epss_percentile": 0.73608}, "CVE-2007-2770": {"epss_score": 0.0377, "epss_percentile": 0.87701}, "CVE-2007-2771": {"epss_score": 0.37495, "epss_percentile": 0.97051}, "CVE-2007-2772": {"epss_score": 0.39678, "epss_percentile": 0.97174}, "CVE-2007-2773": {"epss_score": 0.00531, "epss_percentile": 0.66653}, "CVE-2007-2774": {"epss_score": 0.1218, "epss_percentile": 0.93596}, "CVE-2007-2775": {"epss_score": 0.05352, "epss_percentile": 0.89775}, "CVE-2007-2776": {"epss_score": 0.01533, "epss_percentile": 0.809}, "CVE-2007-2777": {"epss_score": 0.01681, "epss_percentile": 0.81727}, "CVE-2007-2778": {"epss_score": 0.10593, "epss_percentile": 0.93039}, "CVE-2007-2779": {"epss_score": 0.06749, "epss_percentile": 0.91001}, "CVE-2007-2780": {"epss_score": 0.07942, "epss_percentile": 0.9178}, "CVE-2007-2781": {"epss_score": 0.01275, "epss_percentile": 0.79101}, "CVE-2007-2782": {"epss_score": 0.01155, "epss_percentile": 0.78079}, "CVE-2007-2783": {"epss_score": 0.08552, "epss_percentile": 0.9212}, "CVE-2007-2784": {"epss_score": 0.0157, "epss_percentile": 0.81084}, "CVE-2007-2785": {"epss_score": 0.00667, "epss_percentile": 0.70705}, "CVE-2007-2786": {"epss_score": 0.01224, "epss_percentile": 0.78676}, "CVE-2007-2787": {"epss_score": 0.49359, "epss_percentile": 0.9768}, "CVE-2007-2788": {"epss_score": 0.48256, "epss_percentile": 0.97628}, "CVE-2007-2789": {"epss_score": 0.04161, "epss_percentile": 0.88335}, "CVE-2007-2790": {"epss_score": 0.01975, "epss_percentile": 0.83119}, "CVE-2007-2791": {"epss_score": 0.06921, "epss_percentile": 0.91118}, "CVE-2007-2792": {"epss_score": 0.07992, "epss_percentile": 0.9181}, "CVE-2007-2793": {"epss_score": 0.84288, "epss_percentile": 0.99282}, "CVE-2007-2795": {"epss_score": 0.31767, "epss_percentile": 0.96646}, "CVE-2007-2796": {"epss_score": 0.01566, "epss_percentile": 0.81072}, "CVE-2007-2797": {"epss_score": 0.00093, "epss_percentile": 0.26699}, "CVE-2007-2798": {"epss_score": 0.31818, "epss_percentile": 0.96652}, "CVE-2007-2799": {"epss_score": 0.03354, "epss_percentile": 0.86969}, "CVE-2007-2800": {"epss_score": 0.00381, "epss_percentile": 0.59027}, "CVE-2007-2801": {"epss_score": 0.08906, "epss_percentile": 0.9231}, "CVE-2007-2802": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2007-2803": {"epss_score": 0.01327, "epss_percentile": 0.79487}, "CVE-2007-2804": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-2805": {"epss_score": 0.00458, "epss_percentile": 0.63449}, "CVE-2007-2806": {"epss_score": 0.02168, "epss_percentile": 0.83859}, "CVE-2007-2807": {"epss_score": 0.22619, "epss_percentile": 0.95659}, "CVE-2007-2808": {"epss_score": 0.00537, "epss_percentile": 0.66891}, "CVE-2007-2809": {"epss_score": 0.07417, "epss_percentile": 0.91462}, "CVE-2007-2810": {"epss_score": 0.00776, "epss_percentile": 0.731}, "CVE-2007-2811": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2007-2812": {"epss_score": 0.02075, "epss_percentile": 0.83501}, "CVE-2007-2813": {"epss_score": 0.02705, "epss_percentile": 0.85465}, "CVE-2007-2814": {"epss_score": 0.08427, "epss_percentile": 0.92045}, "CVE-2007-2815": {"epss_score": 0.85872, "epss_percentile": 0.99353}, "CVE-2007-2816": {"epss_score": 0.13899, "epss_percentile": 0.94088}, "CVE-2007-2817": {"epss_score": 0.00683, "epss_percentile": 0.71107}, "CVE-2007-2818": {"epss_score": 0.00811, "epss_percentile": 0.73725}, "CVE-2007-2819": {"epss_score": 0.00811, "epss_percentile": 0.73725}, "CVE-2007-2820": {"epss_score": 0.18225, "epss_percentile": 0.94976}, "CVE-2007-2821": {"epss_score": 0.05685, "epss_percentile": 0.90119}, "CVE-2007-2822": {"epss_score": 0.14488, "epss_percentile": 0.94222}, "CVE-2007-2823": {"epss_score": 0.04528, "epss_percentile": 0.88807}, "CVE-2007-2824": {"epss_score": 0.01286, "epss_percentile": 0.79187}, "CVE-2007-2825": {"epss_score": 0.00968, "epss_percentile": 0.76087}, "CVE-2007-2826": {"epss_score": 0.063, "epss_percentile": 0.90655}, "CVE-2007-2827": {"epss_score": 0.07919, "epss_percentile": 0.91762}, "CVE-2007-2828": {"epss_score": 0.01244, "epss_percentile": 0.78838}, "CVE-2007-2829": {"epss_score": 0.03862, "epss_percentile": 0.87866}, "CVE-2007-2830": {"epss_score": 0.03862, "epss_percentile": 0.87866}, "CVE-2007-2831": {"epss_score": 0.02089, "epss_percentile": 0.83558}, "CVE-2007-2832": {"epss_score": 0.18785, "epss_percentile": 0.95068}, "CVE-2007-2833": {"epss_score": 0.01336, "epss_percentile": 0.79555}, "CVE-2007-2834": {"epss_score": 0.14705, "epss_percentile": 0.94267}, "CVE-2007-2835": {"epss_score": 0.00049, "epss_percentile": 0.15504}, "CVE-2007-2836": {"epss_score": 0.00781, "epss_percentile": 0.73189}, "CVE-2007-2837": {"epss_score": 0.00068, "epss_percentile": 0.21291}, "CVE-2007-2838": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2007-2839": {"epss_score": 0.00101, "epss_percentile": 0.28684}, "CVE-2007-2843": {"epss_score": 0.03069, "epss_percentile": 0.86343}, "CVE-2007-2844": {"epss_score": 0.00925, "epss_percentile": 0.75539}, "CVE-2007-2845": {"epss_score": 0.17763, "epss_percentile": 0.94903}, "CVE-2007-2846": {"epss_score": 0.30428, "epss_percentile": 0.96538}, "CVE-2007-2847": {"epss_score": 0.00661, "epss_percentile": 0.70563}, "CVE-2007-2848": {"epss_score": 0.05772, "epss_percentile": 0.90194}, "CVE-2007-2849": {"epss_score": 0.0225, "epss_percentile": 0.84158}, "CVE-2007-2850": {"epss_score": 0.01853, "epss_percentile": 0.82546}, "CVE-2007-2851": {"epss_score": 0.05121, "epss_percentile": 0.8952}, "CVE-2007-2852": {"epss_score": 0.17101, "epss_percentile": 0.94774}, "CVE-2007-2853": {"epss_score": 0.0403, "epss_percentile": 0.88149}, "CVE-2007-2854": {"epss_score": 0.00996, "epss_percentile": 0.76451}, "CVE-2007-2855": {"epss_score": 0.04401, "epss_percentile": 0.88646}, "CVE-2007-2856": {"epss_score": 0.15575, "epss_percentile": 0.94462}, "CVE-2007-2857": {"epss_score": 0.05403, "epss_percentile": 0.89835}, "CVE-2007-2858": {"epss_score": 0.00338, "epss_percentile": 0.56114}, "CVE-2007-2859": {"epss_score": 0.02198, "epss_percentile": 0.83967}, "CVE-2007-2860": {"epss_score": 0.00614, "epss_percentile": 0.69271}, "CVE-2007-2861": {"epss_score": 0.0111, "epss_percentile": 0.77658}, "CVE-2007-2862": {"epss_score": 0.00489, "epss_percentile": 0.64899}, "CVE-2007-2863": {"epss_score": 0.54114, "epss_percentile": 0.97911}, "CVE-2007-2864": {"epss_score": 0.79929, "epss_percentile": 0.99063}, "CVE-2007-2865": {"epss_score": 0.03665, "epss_percentile": 0.87533}, "CVE-2007-2866": {"epss_score": 0.00384, "epss_percentile": 0.59178}, "CVE-2007-2867": {"epss_score": 0.3132, "epss_percentile": 0.96609}, "CVE-2007-2868": {"epss_score": 0.36662, "epss_percentile": 0.96993}, "CVE-2007-2869": {"epss_score": 0.15916, "epss_percentile": 0.94531}, "CVE-2007-2870": {"epss_score": 0.07998, "epss_percentile": 0.91815}, "CVE-2007-2871": {"epss_score": 0.16409, "epss_percentile": 0.94647}, "CVE-2007-2872": {"epss_score": 0.18346, "epss_percentile": 0.95}, "CVE-2007-2873": {"epss_score": 0.00061, "epss_percentile": 0.19534}, "CVE-2007-2874": {"epss_score": 0.02649, "epss_percentile": 0.85341}, "CVE-2007-2875": {"epss_score": 0.00094, "epss_percentile": 0.26766}, "CVE-2007-2876": {"epss_score": 0.02985, "epss_percentile": 0.86128}, "CVE-2007-2877": {"epss_score": 0.00048, "epss_percentile": 0.1501}, "CVE-2007-2878": {"epss_score": 0.00233, "epss_percentile": 0.46034}, "CVE-2007-2879": {"epss_score": 0.02881, "epss_percentile": 0.859}, "CVE-2007-2880": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-2881": {"epss_score": 0.68467, "epss_percentile": 0.9855}, "CVE-2007-2882": {"epss_score": 0.02573, "epss_percentile": 0.85135}, "CVE-2007-2883": {"epss_score": 0.00099, "epss_percentile": 0.28375}, "CVE-2007-2884": {"epss_score": 0.57162, "epss_percentile": 0.98051}, "CVE-2007-2885": {"epss_score": 0.10234, "epss_percentile": 0.92905}, "CVE-2007-2886": {"epss_score": 0.01243, "epss_percentile": 0.7883}, "CVE-2007-2887": {"epss_score": 0.05956, "epss_percentile": 0.90363}, "CVE-2007-2888": {"epss_score": 0.80267, "epss_percentile": 0.99079}, "CVE-2007-2889": {"epss_score": 0.00354, "epss_percentile": 0.57205}, "CVE-2007-2890": {"epss_score": 0.00996, "epss_percentile": 0.76451}, "CVE-2007-2891": {"epss_score": 0.11038, "epss_percentile": 0.93197}, "CVE-2007-2892": {"epss_score": 0.01532, "epss_percentile": 0.80892}, "CVE-2007-2893": {"epss_score": 0.00057, "epss_percentile": 0.18014}, "CVE-2007-2894": {"epss_score": 0.00109, "epss_percentile": 0.3006}, "CVE-2007-2895": {"epss_score": 0.08384, "epss_percentile": 0.92019}, "CVE-2007-2896": {"epss_score": 0.01272, "epss_percentile": 0.79076}, "CVE-2007-2897": {"epss_score": 0.5348, "epss_percentile": 0.97879}, "CVE-2007-2898": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-2899": {"epss_score": 0.04515, "epss_percentile": 0.8879}, "CVE-2007-2900": {"epss_score": 0.09287, "epss_percentile": 0.92484}, "CVE-2007-2901": {"epss_score": 0.06708, "epss_percentile": 0.90961}, "CVE-2007-2902": {"epss_score": 0.0053, "epss_percentile": 0.66623}, "CVE-2007-2903": {"epss_score": 0.42085, "epss_percentile": 0.97312}, "CVE-2007-2904": {"epss_score": 0.00274, "epss_percentile": 0.50555}, "CVE-2007-2905": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-2906": {"epss_score": 0.00477, "epss_percentile": 0.64303}, "CVE-2007-2907": {"epss_score": 0.0051, "epss_percentile": 0.65802}, "CVE-2007-2908": {"epss_score": 0.06882, "epss_percentile": 0.91091}, "CVE-2007-2909": {"epss_score": 0.00172, "epss_percentile": 0.38988}, "CVE-2007-2910": {"epss_score": 0.00246, "epss_percentile": 0.47789}, "CVE-2007-2911": {"epss_score": 0.00389, "epss_percentile": 0.59473}, "CVE-2007-2912": {"epss_score": 0.00332, "epss_percentile": 0.55561}, "CVE-2007-2913": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-2914": {"epss_score": 0.00792, "epss_percentile": 0.73408}, "CVE-2007-2915": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-2916": {"epss_score": 0.00537, "epss_percentile": 0.66918}, "CVE-2007-2917": {"epss_score": 0.09215, "epss_percentile": 0.92452}, "CVE-2007-2918": {"epss_score": 0.73156, "epss_percentile": 0.98738}, "CVE-2007-2919": {"epss_score": 0.74523, "epss_percentile": 0.98806}, "CVE-2007-2920": {"epss_score": 0.09215, "epss_percentile": 0.92452}, "CVE-2007-2921": {"epss_score": 0.0832, "epss_percentile": 0.9199}, "CVE-2007-2923": {"epss_score": 0.02986, "epss_percentile": 0.86133}, "CVE-2007-2924": {"epss_score": 0.28616, "epss_percentile": 0.96372}, "CVE-2007-2925": {"epss_score": 0.01818, "epss_percentile": 0.82399}, "CVE-2007-2926": {"epss_score": 0.19942, "epss_percentile": 0.95264}, "CVE-2007-2927": {"epss_score": 0.44553, "epss_percentile": 0.97444}, "CVE-2007-2928": {"epss_score": 0.05036, "epss_percentile": 0.89422}, "CVE-2007-2929": {"epss_score": 0.01542, "epss_percentile": 0.80953}, "CVE-2007-2930": {"epss_score": 0.17646, "epss_percentile": 0.94884}, "CVE-2007-2931": {"epss_score": 0.77979, "epss_percentile": 0.98962}, "CVE-2007-2932": {"epss_score": 0.07243, "epss_percentile": 0.91346}, "CVE-2007-2933": {"epss_score": 0.0028, "epss_percentile": 0.51007}, "CVE-2007-2934": {"epss_score": 0.05342, "epss_percentile": 0.89763}, "CVE-2007-2935": {"epss_score": 0.09144, "epss_percentile": 0.9242}, "CVE-2007-2936": {"epss_score": 0.03522, "epss_percentile": 0.87288}, "CVE-2007-2937": {"epss_score": 0.83996, "epss_percentile": 0.9927}, "CVE-2007-2938": {"epss_score": 0.5659, "epss_percentile": 0.98029}, "CVE-2007-2939": {"epss_score": 0.62679, "epss_percentile": 0.98302}, "CVE-2007-2940": {"epss_score": 0.09834, "epss_percentile": 0.92725}, "CVE-2007-2941": {"epss_score": 0.03522, "epss_percentile": 0.87288}, "CVE-2007-2942": {"epss_score": 0.01344, "epss_percentile": 0.79612}, "CVE-2007-2943": {"epss_score": 0.03687, "epss_percentile": 0.87571}, "CVE-2007-2944": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-2945": {"epss_score": 0.0056, "epss_percentile": 0.67642}, "CVE-2007-2946": {"epss_score": 0.2553, "epss_percentile": 0.96037}, "CVE-2007-2947": {"epss_score": 0.08619, "epss_percentile": 0.92156}, "CVE-2007-2948": {"epss_score": 0.12793, "epss_percentile": 0.93774}, "CVE-2007-2949": {"epss_score": 0.33942, "epss_percentile": 0.96818}, "CVE-2007-2950": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2007-2951": {"epss_score": 0.02658, "epss_percentile": 0.85361}, "CVE-2007-2952": {"epss_score": 0.14624, "epss_percentile": 0.94253}, "CVE-2007-2953": {"epss_score": 0.11918, "epss_percentile": 0.93516}, "CVE-2007-2954": {"epss_score": 0.22809, "epss_percentile": 0.95688}, "CVE-2007-2955": {"epss_score": 0.11204, "epss_percentile": 0.93263}, "CVE-2007-2956": {"epss_score": 0.05721, "epss_percentile": 0.90152}, "CVE-2007-2957": {"epss_score": 0.08123, "epss_percentile": 0.9189}, "CVE-2007-2958": {"epss_score": 0.04346, "epss_percentile": 0.88576}, "CVE-2007-2959": {"epss_score": 0.00789, "epss_percentile": 0.73347}, "CVE-2007-2960": {"epss_score": 0.0048, "epss_percentile": 0.64459}, "CVE-2007-2961": {"epss_score": 0.0111, "epss_percentile": 0.77658}, "CVE-2007-2962": {"epss_score": 0.05956, "epss_percentile": 0.90363}, "CVE-2007-2963": {"epss_score": 0.01055, "epss_percentile": 0.77117}, "CVE-2007-2964": {"epss_score": 0.06613, "epss_percentile": 0.90889}, "CVE-2007-2965": {"epss_score": 0.00061, "epss_percentile": 0.19537}, "CVE-2007-2966": {"epss_score": 0.05781, "epss_percentile": 0.90202}, "CVE-2007-2967": {"epss_score": 0.10323, "epss_percentile": 0.92944}, "CVE-2007-2968": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-2969": {"epss_score": 0.74088, "epss_percentile": 0.98788}, "CVE-2007-2970": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-2971": {"epss_score": 0.02072, "epss_percentile": 0.8349}, "CVE-2007-2972": {"epss_score": 0.0251, "epss_percentile": 0.84947}, "CVE-2007-2973": {"epss_score": 0.03491, "epss_percentile": 0.87231}, "CVE-2007-2974": {"epss_score": 0.2003, "epss_percentile": 0.95277}, "CVE-2007-2975": {"epss_score": 0.01978, "epss_percentile": 0.8313}, "CVE-2007-2976": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2007-2977": {"epss_score": 0.0079, "epss_percentile": 0.73378}, "CVE-2007-2978": {"epss_score": 0.00447, "epss_percentile": 0.62936}, "CVE-2007-2979": {"epss_score": 0.00546, "epss_percentile": 0.67216}, "CVE-2007-2980": {"epss_score": 0.08679, "epss_percentile": 0.92195}, "CVE-2007-2981": {"epss_score": 0.07634, "epss_percentile": 0.91587}, "CVE-2007-2982": {"epss_score": 0.1263, "epss_percentile": 0.93734}, "CVE-2007-2983": {"epss_score": 0.32625, "epss_percentile": 0.96713}, "CVE-2007-2984": {"epss_score": 0.08251, "epss_percentile": 0.9195}, "CVE-2007-2985": {"epss_score": 0.16236, "epss_percentile": 0.94598}, "CVE-2007-2986": {"epss_score": 0.83996, "epss_percentile": 0.9927}, "CVE-2007-2987": {"epss_score": 0.74973, "epss_percentile": 0.98827}, "CVE-2007-2988": {"epss_score": 0.08719, "epss_percentile": 0.92226}, "CVE-2007-2989": {"epss_score": 0.03788, "epss_percentile": 0.87728}, "CVE-2007-2990": {"epss_score": 0.00061, "epss_percentile": 0.19549}, "CVE-2007-2991": {"epss_score": 0.02624, "epss_percentile": 0.85262}, "CVE-2007-2992": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-2993": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-2994": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2007-2995": {"epss_score": 0.00713, "epss_percentile": 0.71803}, "CVE-2007-2996": {"epss_score": 0.00044, "epss_percentile": 0.13392}, "CVE-2007-2997": {"epss_score": 0.00759, "epss_percentile": 0.72787}, "CVE-2007-2998": {"epss_score": 0.00072, "epss_percentile": 0.22425}, "CVE-2007-2999": {"epss_score": 0.01252, "epss_percentile": 0.78907}, "CVE-2007-3000": {"epss_score": 0.01093, "epss_percentile": 0.77484}, "CVE-2007-3001": {"epss_score": 0.02568, "epss_percentile": 0.85121}, "CVE-2007-3002": {"epss_score": 0.00641, "epss_percentile": 0.69986}, "CVE-2007-3003": {"epss_score": 0.00475, "epss_percentile": 0.64195}, "CVE-2007-3006": {"epss_score": 0.23556, "epss_percentile": 0.95791}, "CVE-2007-3007": {"epss_score": 0.01308, "epss_percentile": 0.79348}, "CVE-2007-3008": {"epss_score": 0.00818, "epss_percentile": 0.73853}, "CVE-2007-3009": {"epss_score": 0.039, "epss_percentile": 0.8792}, "CVE-2007-3010": {"epss_score": 0.94007, "epss_percentile": 0.99885}, "CVE-2007-3011": {"epss_score": 0.17064, "epss_percentile": 0.94768}, "CVE-2007-3012": {"epss_score": 0.00543, "epss_percentile": 0.67093}, "CVE-2007-3013": {"epss_score": 0.01072, "epss_percentile": 0.77278}, "CVE-2007-3014": {"epss_score": 0.13618, "epss_percentile": 0.94015}, "CVE-2007-3017": {"epss_score": 0.08689, "epss_percentile": 0.92204}, "CVE-2007-3018": {"epss_score": 0.0052, "epss_percentile": 0.66197}, "CVE-2007-3021": {"epss_score": 0.00993, "epss_percentile": 0.76418}, "CVE-2007-3022": {"epss_score": 0.00914, "epss_percentile": 0.75391}, "CVE-2007-3023": {"epss_score": 0.01516, "epss_percentile": 0.80801}, "CVE-2007-3024": {"epss_score": 0.0006, "epss_percentile": 0.18933}, "CVE-2007-3025": {"epss_score": 0.00675, "epss_percentile": 0.70886}, "CVE-2007-3026": {"epss_score": 0.08923, "epss_percentile": 0.92321}, "CVE-2007-3027": {"epss_score": 0.52753, "epss_percentile": 0.97839}, "CVE-2007-3028": {"epss_score": 0.63461, "epss_percentile": 0.98334}, "CVE-2007-3029": {"epss_score": 0.60754, "epss_percentile": 0.98219}, "CVE-2007-3030": {"epss_score": 0.57804, "epss_percentile": 0.98084}, "CVE-2007-3032": {"epss_score": 0.58353, "epss_percentile": 0.98112}, "CVE-2007-3033": {"epss_score": 0.42333, "epss_percentile": 0.97327}, "CVE-2007-3034": {"epss_score": 0.79265, "epss_percentile": 0.99028}, "CVE-2007-3035": {"epss_score": 0.52084, "epss_percentile": 0.97807}, "CVE-2007-3036": {"epss_score": 0.03161, "epss_percentile": 0.86531}, "CVE-2007-3037": {"epss_score": 0.59741, "epss_percentile": 0.98178}, "CVE-2007-3038": {"epss_score": 0.30259, "epss_percentile": 0.96523}, "CVE-2007-3039": {"epss_score": 0.82786, "epss_percentile": 0.99215}, "CVE-2007-3040": {"epss_score": 0.58814, "epss_percentile": 0.98138}, "CVE-2007-3041": {"epss_score": 0.55842, "epss_percentile": 0.98}, "CVE-2007-3042": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3043": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3044": {"epss_score": 0.01176, "epss_percentile": 0.78269}, "CVE-2007-3045": {"epss_score": 0.00721, "epss_percentile": 0.71974}, "CVE-2007-3046": {"epss_score": 0.00637, "epss_percentile": 0.69891}, "CVE-2007-3047": {"epss_score": 0.00809, "epss_percentile": 0.73706}, "CVE-2007-3048": {"epss_score": 0.00296, "epss_percentile": 0.52543}, "CVE-2007-3049": {"epss_score": 0.01532, "epss_percentile": 0.80892}, "CVE-2007-3050": {"epss_score": 0.00943, "epss_percentile": 0.7577}, "CVE-2007-3051": {"epss_score": 0.00996, "epss_percentile": 0.76451}, "CVE-2007-3052": {"epss_score": 0.01046, "epss_percentile": 0.77027}, "CVE-2007-3053": {"epss_score": 0.00664, "epss_percentile": 0.70643}, "CVE-2007-3054": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3055": {"epss_score": 0.03356, "epss_percentile": 0.86975}, "CVE-2007-3056": {"epss_score": 0.00792, "epss_percentile": 0.73408}, "CVE-2007-3057": {"epss_score": 0.65489, "epss_percentile": 0.98422}, "CVE-2007-3058": {"epss_score": 0.00621, "epss_percentile": 0.69487}, "CVE-2007-3059": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2007-3060": {"epss_score": 0.02825, "epss_percentile": 0.85756}, "CVE-2007-3061": {"epss_score": 0.05177, "epss_percentile": 0.89575}, "CVE-2007-3062": {"epss_score": 0.03533, "epss_percentile": 0.87308}, "CVE-2007-3063": {"epss_score": 0.00308, "epss_percentile": 0.53638}, "CVE-2007-3064": {"epss_score": 0.00427, "epss_percentile": 0.61783}, "CVE-2007-3065": {"epss_score": 0.00641, "epss_percentile": 0.70011}, "CVE-2007-3066": {"epss_score": 0.0111, "epss_percentile": 0.77658}, "CVE-2007-3067": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-3068": {"epss_score": 0.7945, "epss_percentile": 0.99039}, "CVE-2007-3069": {"epss_score": 0.00078, "epss_percentile": 0.23554}, "CVE-2007-3070": {"epss_score": 0.05446, "epss_percentile": 0.89888}, "CVE-2007-3071": {"epss_score": 0.06282, "epss_percentile": 0.90639}, "CVE-2007-3072": {"epss_score": 0.00627, "epss_percentile": 0.69624}, "CVE-2007-3073": {"epss_score": 0.01477, "epss_percentile": 0.80548}, "CVE-2007-3074": {"epss_score": 0.00597, "epss_percentile": 0.68742}, "CVE-2007-3075": {"epss_score": 0.18282, "epss_percentile": 0.94988}, "CVE-2007-3076": {"epss_score": 0.0352, "epss_percentile": 0.87284}, "CVE-2007-3077": {"epss_score": 0.01126, "epss_percentile": 0.77817}, "CVE-2007-3078": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3079": {"epss_score": 0.00316, "epss_percentile": 0.54295}, "CVE-2007-3080": {"epss_score": 0.00521, "epss_percentile": 0.66233}, "CVE-2007-3081": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2007-3082": {"epss_score": 0.05177, "epss_percentile": 0.89575}, "CVE-2007-3083": {"epss_score": 0.00378, "epss_percentile": 0.58807}, "CVE-2007-3084": {"epss_score": 0.00522, "epss_percentile": 0.6628}, "CVE-2007-3085": {"epss_score": 0.02765, "epss_percentile": 0.8561}, "CVE-2007-3086": {"epss_score": 0.00118, "epss_percentile": 0.31389}, "CVE-2007-3087": {"epss_score": 0.00299, "epss_percentile": 0.52906}, "CVE-2007-3088": {"epss_score": 0.01302, "epss_percentile": 0.79299}, "CVE-2007-3089": {"epss_score": 0.25016, "epss_percentile": 0.95979}, "CVE-2007-3091": {"epss_score": 0.18448, "epss_percentile": 0.95018}, "CVE-2007-3092": {"epss_score": 0.05717, "epss_percentile": 0.90147}, "CVE-2007-3093": {"epss_score": 0.1406, "epss_percentile": 0.94126}, "CVE-2007-3094": {"epss_score": 0.02675, "epss_percentile": 0.854}, "CVE-2007-3095": {"epss_score": 0.00769, "epss_percentile": 0.72987}, "CVE-2007-3096": {"epss_score": 0.0988, "epss_percentile": 0.9275}, "CVE-2007-3097": {"epss_score": 0.01743, "epss_percentile": 0.82056}, "CVE-2007-3098": {"epss_score": 0.11833, "epss_percentile": 0.93489}, "CVE-2007-3099": {"epss_score": 0.00224, "epss_percentile": 0.45001}, "CVE-2007-3100": {"epss_score": 0.00053, "epss_percentile": 0.16722}, "CVE-2007-3101": {"epss_score": 0.62006, "epss_percentile": 0.98272}, "CVE-2007-3102": {"epss_score": 0.02556, "epss_percentile": 0.85092}, "CVE-2007-3103": {"epss_score": 0.00078, "epss_percentile": 0.23737}, "CVE-2007-3104": {"epss_score": 0.00139, "epss_percentile": 0.34612}, "CVE-2007-3105": {"epss_score": 0.0015, "epss_percentile": 0.36087}, "CVE-2007-3106": {"epss_score": 0.02889, "epss_percentile": 0.85916}, "CVE-2007-3107": {"epss_score": 0.00085, "epss_percentile": 0.25073}, "CVE-2007-3108": {"epss_score": 0.00149, "epss_percentile": 0.35969}, "CVE-2007-3109": {"epss_score": 0.1688, "epss_percentile": 0.9474}, "CVE-2007-3110": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3111": {"epss_score": 0.50875, "epss_percentile": 0.97754}, "CVE-2007-3112": {"epss_score": 0.02685, "epss_percentile": 0.85425}, "CVE-2007-3113": {"epss_score": 0.02022, "epss_percentile": 0.833}, "CVE-2007-3114": {"epss_score": 0.01176, "epss_percentile": 0.78269}, "CVE-2007-3115": {"epss_score": 0.02379, "epss_percentile": 0.8456}, "CVE-2007-3116": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2007-3117": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3118": {"epss_score": 0.07083, "epss_percentile": 0.9124}, "CVE-2007-3119": {"epss_score": 0.01, "epss_percentile": 0.76485}, "CVE-2007-3120": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3121": {"epss_score": 0.00695, "epss_percentile": 0.7137}, "CVE-2007-3122": {"epss_score": 0.0141, "epss_percentile": 0.80079}, "CVE-2007-3123": {"epss_score": 0.0268, "epss_percentile": 0.85413}, "CVE-2007-3124": {"epss_score": 0.00067, "epss_percentile": 0.20976}, "CVE-2007-3126": {"epss_score": 0.00859, "epss_percentile": 0.74513}, "CVE-2007-3127": {"epss_score": 0.10504, "epss_percentile": 0.93013}, "CVE-2007-3128": {"epss_score": 0.00412, "epss_percentile": 0.60919}, "CVE-2007-3129": {"epss_score": 0.00583, "epss_percentile": 0.68334}, "CVE-2007-3130": {"epss_score": 0.00299, "epss_percentile": 0.52888}, "CVE-2007-3131": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-3132": {"epss_score": 0.03278, "epss_percentile": 0.86808}, "CVE-2007-3133": {"epss_score": 0.01175, "epss_percentile": 0.78265}, "CVE-2007-3134": {"epss_score": 0.00376, "epss_percentile": 0.58676}, "CVE-2007-3135": {"epss_score": 0.00537, "epss_percentile": 0.66918}, "CVE-2007-3136": {"epss_score": 0.04163, "epss_percentile": 0.88339}, "CVE-2007-3137": {"epss_score": 0.04741, "epss_percentile": 0.8908}, "CVE-2007-3138": {"epss_score": 0.10174, "epss_percentile": 0.9288}, "CVE-2007-3139": {"epss_score": 0.14398, "epss_percentile": 0.94203}, "CVE-2007-3140": {"epss_score": 0.02472, "epss_percentile": 0.8485}, "CVE-2007-3141": {"epss_score": 0.019, "epss_percentile": 0.8277}, "CVE-2007-3142": {"epss_score": 0.0072, "epss_percentile": 0.71957}, "CVE-2007-3143": {"epss_score": 0.00592, "epss_percentile": 0.68621}, "CVE-2007-3144": {"epss_score": 0.00586, "epss_percentile": 0.68457}, "CVE-2007-3145": {"epss_score": 0.00521, "epss_percentile": 0.66246}, "CVE-2007-3146": {"epss_score": 0.00419, "epss_percentile": 0.61362}, "CVE-2007-3147": {"epss_score": 0.71214, "epss_percentile": 0.98659}, "CVE-2007-3148": {"epss_score": 0.59275, "epss_percentile": 0.98158}, "CVE-2007-3149": {"epss_score": 0.00047, "epss_percentile": 0.14799}, "CVE-2007-3150": {"epss_score": 0.00892, "epss_percentile": 0.75059}, "CVE-2007-3151": {"epss_score": 0.05907, "epss_percentile": 0.90314}, "CVE-2007-3152": {"epss_score": 0.00721, "epss_percentile": 0.71974}, "CVE-2007-3153": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2007-3154": {"epss_score": 0.01319, "epss_percentile": 0.79437}, "CVE-2007-3155": {"epss_score": 0.01319, "epss_percentile": 0.79437}, "CVE-2007-3156": {"epss_score": 0.00859, "epss_percentile": 0.74514}, "CVE-2007-3157": {"epss_score": 0.10179, "epss_percentile": 0.92881}, "CVE-2007-3158": {"epss_score": 0.05863, "epss_percentile": 0.90272}, "CVE-2007-3159": {"epss_score": 0.06821, "epss_percentile": 0.91048}, "CVE-2007-3160": {"epss_score": 0.09101, "epss_percentile": 0.92401}, "CVE-2007-3161": {"epss_score": 0.03531, "epss_percentile": 0.87302}, "CVE-2007-3162": {"epss_score": 0.34644, "epss_percentile": 0.96862}, "CVE-2007-3163": {"epss_score": 0.00583, "epss_percentile": 0.68342}, "CVE-2007-3164": {"epss_score": 0.22067, "epss_percentile": 0.95591}, "CVE-2007-3165": {"epss_score": 0.00359, "epss_percentile": 0.57599}, "CVE-2007-3166": {"epss_score": 0.03104, "epss_percentile": 0.86415}, "CVE-2007-3167": {"epss_score": 0.12049, "epss_percentile": 0.93555}, "CVE-2007-3168": {"epss_score": 0.12028, "epss_percentile": 0.9355}, "CVE-2007-3169": {"epss_score": 0.3135, "epss_percentile": 0.96614}, "CVE-2007-3170": {"epss_score": 0.01943, "epss_percentile": 0.82991}, "CVE-2007-3171": {"epss_score": 0.03022, "epss_percentile": 0.86227}, "CVE-2007-3172": {"epss_score": 0.00178, "epss_percentile": 0.39715}, "CVE-2007-3173": {"epss_score": 0.00309, "epss_percentile": 0.53666}, "CVE-2007-3174": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2007-3175": {"epss_score": 0.00545, "epss_percentile": 0.67166}, "CVE-2007-3176": {"epss_score": 0.00269, "epss_percentile": 0.50109}, "CVE-2007-3177": {"epss_score": 0.00498, "epss_percentile": 0.65224}, "CVE-2007-3178": {"epss_score": 0.00695, "epss_percentile": 0.71375}, "CVE-2007-3179": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-3180": {"epss_score": 0.01209, "epss_percentile": 0.78537}, "CVE-2007-3181": {"epss_score": 0.28186, "epss_percentile": 0.9633}, "CVE-2007-3182": {"epss_score": 0.11024, "epss_percentile": 0.93194}, "CVE-2007-3183": {"epss_score": 0.01884, "epss_percentile": 0.82705}, "CVE-2007-3184": {"epss_score": 0.001, "epss_percentile": 0.28446}, "CVE-2007-3185": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2007-3186": {"epss_score": 0.08926, "epss_percentile": 0.92322}, "CVE-2007-3187": {"epss_score": 0.02313, "epss_percentile": 0.84344}, "CVE-2007-3188": {"epss_score": 0.01164, "epss_percentile": 0.78167}, "CVE-2007-3189": {"epss_score": 0.06656, "epss_percentile": 0.9092}, "CVE-2007-3190": {"epss_score": 0.00955, "epss_percentile": 0.75914}, "CVE-2007-3191": {"epss_score": 0.05546, "epss_percentile": 0.89982}, "CVE-2007-3192": {"epss_score": 0.02857, "epss_percentile": 0.85845}, "CVE-2007-3193": {"epss_score": 0.02756, "epss_percentile": 0.85592}, "CVE-2007-3194": {"epss_score": 0.00768, "epss_percentile": 0.72967}, "CVE-2007-3195": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3196": {"epss_score": 0.0077, "epss_percentile": 0.73}, "CVE-2007-3197": {"epss_score": 0.0034, "epss_percentile": 0.56284}, "CVE-2007-3198": {"epss_score": 0.11884, "epss_percentile": 0.93504}, "CVE-2007-3199": {"epss_score": 0.10825, "epss_percentile": 0.93124}, "CVE-2007-3200": {"epss_score": 0.00063, "epss_percentile": 0.19832}, "CVE-2007-3201": {"epss_score": 0.05887, "epss_percentile": 0.90296}, "CVE-2007-3202": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3203": {"epss_score": 0.08251, "epss_percentile": 0.9195}, "CVE-2007-3204": {"epss_score": 0.00384, "epss_percentile": 0.59178}, "CVE-2007-3205": {"epss_score": 0.01973, "epss_percentile": 0.83109}, "CVE-2007-3207": {"epss_score": 0.02777, "epss_percentile": 0.85641}, "CVE-2007-3208": {"epss_score": 0.17119, "epss_percentile": 0.94778}, "CVE-2007-3209": {"epss_score": 0.0041, "epss_percentile": 0.60834}, "CVE-2007-3210": {"epss_score": 0.04139, "epss_percentile": 0.88309}, "CVE-2007-3211": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3212": {"epss_score": 0.00658, "epss_percentile": 0.70488}, "CVE-2007-3213": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3214": {"epss_score": 0.01122, "epss_percentile": 0.77781}, "CVE-2007-3215": {"epss_score": 0.03464, "epss_percentile": 0.87187}, "CVE-2007-3216": {"epss_score": 0.60166, "epss_percentile": 0.98196}, "CVE-2007-3217": {"epss_score": 0.08608, "epss_percentile": 0.92148}, "CVE-2007-3218": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3219": {"epss_score": 0.00679, "epss_percentile": 0.71023}, "CVE-2007-3220": {"epss_score": 0.29255, "epss_percentile": 0.96428}, "CVE-2007-3221": {"epss_score": 0.6516, "epss_percentile": 0.98405}, "CVE-2007-3222": {"epss_score": 0.03436, "epss_percentile": 0.87133}, "CVE-2007-3223": {"epss_score": 0.02139, "epss_percentile": 0.83743}, "CVE-2007-3224": {"epss_score": 0.0074, "epss_percentile": 0.72406}, "CVE-2007-3225": {"epss_score": 0.0094, "epss_percentile": 0.75743}, "CVE-2007-3226": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3227": {"epss_score": 0.12046, "epss_percentile": 0.93554}, "CVE-2007-3228": {"epss_score": 0.81019, "epss_percentile": 0.99116}, "CVE-2007-3229": {"epss_score": 0.0053, "epss_percentile": 0.66633}, "CVE-2007-3230": {"epss_score": 0.84733, "epss_percentile": 0.99303}, "CVE-2007-3231": {"epss_score": 0.00399, "epss_percentile": 0.60131}, "CVE-2007-3232": {"epss_score": 0.01348, "epss_percentile": 0.79665}, "CVE-2007-3233": {"epss_score": 0.07765, "epss_percentile": 0.91667}, "CVE-2007-3234": {"epss_score": 0.00548, "epss_percentile": 0.67288}, "CVE-2007-3235": {"epss_score": 0.00502, "epss_percentile": 0.65398}, "CVE-2007-3236": {"epss_score": 0.83926, "epss_percentile": 0.99265}, "CVE-2007-3237": {"epss_score": 0.62331, "epss_percentile": 0.98288}, "CVE-2007-3238": {"epss_score": 0.01212, "epss_percentile": 0.78562}, "CVE-2007-3239": {"epss_score": 0.00819, "epss_percentile": 0.73866}, "CVE-2007-3240": {"epss_score": 0.00729, "epss_percentile": 0.72123}, "CVE-2007-3241": {"epss_score": 0.00264, "epss_percentile": 0.49692}, "CVE-2007-3242": {"epss_score": 0.0092, "epss_percentile": 0.75463}, "CVE-2007-3243": {"epss_score": 0.0188, "epss_percentile": 0.82676}, "CVE-2007-3244": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-3245": {"epss_score": 0.01173, "epss_percentile": 0.78243}, "CVE-2007-3246": {"epss_score": 0.00464, "epss_percentile": 0.63734}, "CVE-2007-3247": {"epss_score": 0.00706, "epss_percentile": 0.71614}, "CVE-2007-3248": {"epss_score": 0.02139, "epss_percentile": 0.83743}, "CVE-2007-3249": {"epss_score": 0.06274, "epss_percentile": 0.90631}, "CVE-2007-3250": {"epss_score": 0.00893, "epss_percentile": 0.75078}, "CVE-2007-3251": {"epss_score": 0.13811, "epss_percentile": 0.94063}, "CVE-2007-3252": {"epss_score": 0.00316, "epss_percentile": 0.54241}, "CVE-2007-3253": {"epss_score": 0.0194, "epss_percentile": 0.82977}, "CVE-2007-3254": {"epss_score": 0.00633, "epss_percentile": 0.69775}, "CVE-2007-3255": {"epss_score": 0.01192, "epss_percentile": 0.784}, "CVE-2007-3256": {"epss_score": 0.00607, "epss_percentile": 0.6903}, "CVE-2007-3257": {"epss_score": 0.02668, "epss_percentile": 0.85379}, "CVE-2007-3258": {"epss_score": 0.00381, "epss_percentile": 0.59027}, "CVE-2007-3259": {"epss_score": 0.00662, "epss_percentile": 0.70602}, "CVE-2007-3260": {"epss_score": 0.00406, "epss_percentile": 0.60565}, "CVE-2007-3261": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3262": {"epss_score": 0.02237, "epss_percentile": 0.84103}, "CVE-2007-3263": {"epss_score": 0.01349, "epss_percentile": 0.79671}, "CVE-2007-3264": {"epss_score": 0.01003, "epss_percentile": 0.76514}, "CVE-2007-3265": {"epss_score": 0.00693, "epss_percentile": 0.71332}, "CVE-2007-3266": {"epss_score": 0.09161, "epss_percentile": 0.92427}, "CVE-2007-3267": {"epss_score": 0.10037, "epss_percentile": 0.92823}, "CVE-2007-3268": {"epss_score": 0.03217, "epss_percentile": 0.86665}, "CVE-2007-3269": {"epss_score": 0.00618, "epss_percentile": 0.69381}, "CVE-2007-3270": {"epss_score": 0.0358, "epss_percentile": 0.87383}, "CVE-2007-3271": {"epss_score": 0.08047, "epss_percentile": 0.91852}, "CVE-2007-3272": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2007-3273": {"epss_score": 0.00577, "epss_percentile": 0.68155}, "CVE-2007-3274": {"epss_score": 0.00388, "epss_percentile": 0.59375}, "CVE-2007-3275": {"epss_score": 0.00612, "epss_percentile": 0.69239}, "CVE-2007-3276": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2007-3277": {"epss_score": 0.00416, "epss_percentile": 0.61172}, "CVE-2007-3278": {"epss_score": 0.00973, "epss_percentile": 0.76158}, "CVE-2007-3279": {"epss_score": 0.02396, "epss_percentile": 0.84617}, "CVE-2007-3280": {"epss_score": 0.48052, "epss_percentile": 0.97616}, "CVE-2007-3281": {"epss_score": 0.05922, "epss_percentile": 0.90323}, "CVE-2007-3282": {"epss_score": 0.46593, "epss_percentile": 0.97552}, "CVE-2007-3283": {"epss_score": 0.00048, "epss_percentile": 0.15191}, "CVE-2007-3284": {"epss_score": 0.03548, "epss_percentile": 0.87333}, "CVE-2007-3285": {"epss_score": 0.01883, "epss_percentile": 0.827}, "CVE-2007-3286": {"epss_score": 0.02753, "epss_percentile": 0.85587}, "CVE-2007-3288": {"epss_score": 0.0037, "epss_percentile": 0.58329}, "CVE-2007-3289": {"epss_score": 0.06532, "epss_percentile": 0.90826}, "CVE-2007-3290": {"epss_score": 0.05117, "epss_percentile": 0.89516}, "CVE-2007-3291": {"epss_score": 0.04107, "epss_percentile": 0.88267}, "CVE-2007-3292": {"epss_score": 0.04882, "epss_percentile": 0.8925}, "CVE-2007-3293": {"epss_score": 0.00997, "epss_percentile": 0.76455}, "CVE-2007-3294": {"epss_score": 0.07412, "epss_percentile": 0.91459}, "CVE-2007-3295": {"epss_score": 0.01449, "epss_percentile": 0.80346}, "CVE-2007-3296": {"epss_score": 0.00621, "epss_percentile": 0.69482}, "CVE-2007-3297": {"epss_score": 0.09733, "epss_percentile": 0.9268}, "CVE-2007-3298": {"epss_score": 0.00489, "epss_percentile": 0.64899}, "CVE-2007-3299": {"epss_score": 0.00792, "epss_percentile": 0.73408}, "CVE-2007-3300": {"epss_score": 0.02345, "epss_percentile": 0.84449}, "CVE-2007-3301": {"epss_score": 0.0045, "epss_percentile": 0.63093}, "CVE-2007-3302": {"epss_score": 0.23299, "epss_percentile": 0.95762}, "CVE-2007-3303": {"epss_score": 0.00082, "epss_percentile": 0.24497}, "CVE-2007-3304": {"epss_score": 0.00094, "epss_percentile": 0.27013}, "CVE-2007-3305": {"epss_score": 0.2497, "epss_percentile": 0.95973}, "CVE-2007-3306": {"epss_score": 0.83996, "epss_percentile": 0.9927}, "CVE-2007-3307": {"epss_score": 0.00548, "epss_percentile": 0.67288}, "CVE-2007-3308": {"epss_score": 0.00721, "epss_percentile": 0.71974}, "CVE-2007-3309": {"epss_score": 0.00721, "epss_percentile": 0.71974}, "CVE-2007-3310": {"epss_score": 0.03928, "epss_percentile": 0.87969}, "CVE-2007-3311": {"epss_score": 0.00538, "epss_percentile": 0.66936}, "CVE-2007-3312": {"epss_score": 0.03646, "epss_percentile": 0.875}, "CVE-2007-3313": {"epss_score": 0.01459, "epss_percentile": 0.80411}, "CVE-2007-3314": {"epss_score": 0.76114, "epss_percentile": 0.98878}, "CVE-2007-3315": {"epss_score": 0.0144, "epss_percentile": 0.80296}, "CVE-2007-3316": {"epss_score": 0.29477, "epss_percentile": 0.96446}, "CVE-2007-3317": {"epss_score": 0.02037, "epss_percentile": 0.83356}, "CVE-2007-3318": {"epss_score": 0.01468, "epss_percentile": 0.80481}, "CVE-2007-3319": {"epss_score": 0.01597, "epss_percentile": 0.81246}, "CVE-2007-3320": {"epss_score": 0.00598, "epss_percentile": 0.68763}, "CVE-2007-3321": {"epss_score": 0.00721, "epss_percentile": 0.71974}, "CVE-2007-3322": {"epss_score": 0.00721, "epss_percentile": 0.71974}, "CVE-2007-3323": {"epss_score": 0.0053, "epss_percentile": 0.66623}, "CVE-2007-3324": {"epss_score": 0.09207, "epss_percentile": 0.92448}, "CVE-2007-3325": {"epss_score": 0.83996, "epss_percentile": 0.9927}, "CVE-2007-3326": {"epss_score": 0.00494, "epss_percentile": 0.65099}, "CVE-2007-3327": {"epss_score": 0.03419, "epss_percentile": 0.87099}, "CVE-2007-3328": {"epss_score": 0.00987, "epss_percentile": 0.76343}, "CVE-2007-3329": {"epss_score": 0.04979, "epss_percentile": 0.89358}, "CVE-2007-3330": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-3331": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2007-3332": {"epss_score": 0.03419, "epss_percentile": 0.87099}, "CVE-2007-3333": {"epss_score": 0.25498, "epss_percentile": 0.96035}, "CVE-2007-3334": {"epss_score": 0.39639, "epss_percentile": 0.97173}, "CVE-2007-3335": {"epss_score": 0.00384, "epss_percentile": 0.59178}, "CVE-2007-3336": {"epss_score": 0.28947, "epss_percentile": 0.96403}, "CVE-2007-3337": {"epss_score": 0.00074, "epss_percentile": 0.22724}, "CVE-2007-3338": {"epss_score": 0.1996, "epss_percentile": 0.95267}, "CVE-2007-3339": {"epss_score": 0.03474, "epss_percentile": 0.87206}, "CVE-2007-3340": {"epss_score": 0.12302, "epss_percentile": 0.93627}, "CVE-2007-3341": {"epss_score": 0.35643, "epss_percentile": 0.96924}, "CVE-2007-3342": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3343": {"epss_score": 0.00537, "epss_percentile": 0.66918}, "CVE-2007-3344": {"epss_score": 0.00816, "epss_percentile": 0.73798}, "CVE-2007-3345": {"epss_score": 0.00384, "epss_percentile": 0.59178}, "CVE-2007-3346": {"epss_score": 0.03243, "epss_percentile": 0.8674}, "CVE-2007-3347": {"epss_score": 0.00257, "epss_percentile": 0.48868}, "CVE-2007-3348": {"epss_score": 0.00943, "epss_percentile": 0.75775}, "CVE-2007-3349": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2007-3350": {"epss_score": 0.0066, "epss_percentile": 0.7052}, "CVE-2007-3351": {"epss_score": 0.00673, "epss_percentile": 0.70843}, "CVE-2007-3352": {"epss_score": 0.00537, "epss_percentile": 0.66918}, "CVE-2007-3353": {"epss_score": 0.00784, "epss_percentile": 0.73234}, "CVE-2007-3354": {"epss_score": 0.00578, "epss_percentile": 0.68202}, "CVE-2007-3355": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-3356": {"epss_score": 0.00711, "epss_percentile": 0.71746}, "CVE-2007-3357": {"epss_score": 0.00185, "epss_percentile": 0.40474}, "CVE-2007-3358": {"epss_score": 0.85749, "epss_percentile": 0.99346}, "CVE-2007-3359": {"epss_score": 0.00676, "epss_percentile": 0.70927}, "CVE-2007-3360": {"epss_score": 0.0984, "epss_percentile": 0.92726}, "CVE-2007-3361": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2007-3362": {"epss_score": 0.01566, "epss_percentile": 0.81072}, "CVE-2007-3363": {"epss_score": 0.00837, "epss_percentile": 0.74154}, "CVE-2007-3364": {"epss_score": 0.07813, "epss_percentile": 0.91695}, "CVE-2007-3365": {"epss_score": 0.18438, "epss_percentile": 0.95017}, "CVE-2007-3366": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3367": {"epss_score": 0.00343, "epss_percentile": 0.56446}, "CVE-2007-3368": {"epss_score": 0.00719, "epss_percentile": 0.71953}, "CVE-2007-3369": {"epss_score": 0.01614, "epss_percentile": 0.81347}, "CVE-2007-3370": {"epss_score": 0.84166, "epss_percentile": 0.99277}, "CVE-2007-3371": {"epss_score": 0.84166, "epss_percentile": 0.99277}, "CVE-2007-3372": {"epss_score": 0.00096, "epss_percentile": 0.27411}, "CVE-2007-3373": {"epss_score": 0.00278, "epss_percentile": 0.50894}, "CVE-2007-3374": {"epss_score": 0.00174, "epss_percentile": 0.39161}, "CVE-2007-3375": {"epss_score": 0.08251, "epss_percentile": 0.9195}, "CVE-2007-3376": {"epss_score": 0.0466, "epss_percentile": 0.88976}, "CVE-2007-3377": {"epss_score": 0.02766, "epss_percentile": 0.85612}, "CVE-2007-3378": {"epss_score": 0.03062, "epss_percentile": 0.86317}, "CVE-2007-3379": {"epss_score": 0.00063, "epss_percentile": 0.19847}, "CVE-2007-3380": {"epss_score": 0.03119, "epss_percentile": 0.86446}, "CVE-2007-3381": {"epss_score": 0.00076, "epss_percentile": 0.23221}, "CVE-2007-3382": {"epss_score": 0.85471, "epss_percentile": 0.99335}, "CVE-2007-3383": {"epss_score": 0.37976, "epss_percentile": 0.97079}, "CVE-2007-3384": {"epss_score": 0.06401, "epss_percentile": 0.90728}, "CVE-2007-3385": {"epss_score": 0.75882, "epss_percentile": 0.98869}, "CVE-2007-3386": {"epss_score": 0.69959, "epss_percentile": 0.9861}, "CVE-2007-3387": {"epss_score": 0.08739, "epss_percentile": 0.92234}, "CVE-2007-3388": {"epss_score": 0.08663, "epss_percentile": 0.92178}, "CVE-2007-3389": {"epss_score": 0.23654, "epss_percentile": 0.95799}, "CVE-2007-3390": {"epss_score": 0.01385, "epss_percentile": 0.79906}, "CVE-2007-3391": {"epss_score": 0.03211, "epss_percentile": 0.86655}, "CVE-2007-3392": {"epss_score": 0.01907, "epss_percentile": 0.82812}, "CVE-2007-3393": {"epss_score": 0.0287, "epss_percentile": 0.85872}, "CVE-2007-3394": {"epss_score": 0.00459, "epss_percentile": 0.63457}, "CVE-2007-3396": {"epss_score": 0.09197, "epss_percentile": 0.92443}, "CVE-2007-3397": {"epss_score": 0.00693, "epss_percentile": 0.71332}, "CVE-2007-3398": {"epss_score": 0.04153, "epss_percentile": 0.88324}, "CVE-2007-3399": {"epss_score": 0.00893, "epss_percentile": 0.75078}, "CVE-2007-3400": {"epss_score": 0.09812, "epss_percentile": 0.92712}, "CVE-2007-3401": {"epss_score": 0.84123, "epss_percentile": 0.99274}, "CVE-2007-3402": {"epss_score": 0.00964, "epss_percentile": 0.76028}, "CVE-2007-3403": {"epss_score": 0.04962, "epss_percentile": 0.89337}, "CVE-2007-3404": {"epss_score": 0.05177, "epss_percentile": 0.89575}, "CVE-2007-3405": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3406": {"epss_score": 0.29355, "epss_percentile": 0.96435}, "CVE-2007-3407": {"epss_score": 0.11147, "epss_percentile": 0.93239}, "CVE-2007-3408": {"epss_score": 0.00432, "epss_percentile": 0.62162}, "CVE-2007-3409": {"epss_score": 0.12389, "epss_percentile": 0.93657}, "CVE-2007-3410": {"epss_score": 0.29384, "epss_percentile": 0.96438}, "CVE-2007-3411": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-3412": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3413": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2007-3414": {"epss_score": 0.00771, "epss_percentile": 0.73025}, "CVE-2007-3415": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-3416": {"epss_score": 0.00134, "epss_percentile": 0.33773}, "CVE-2007-3417": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2007-3418": {"epss_score": 0.00445, "epss_percentile": 0.62857}, "CVE-2007-3419": {"epss_score": 0.00365, "epss_percentile": 0.57981}, "CVE-2007-3420": {"epss_score": 0.00365, "epss_percentile": 0.57981}, "CVE-2007-3421": {"epss_score": 0.00365, "epss_percentile": 0.57981}, "CVE-2007-3422": {"epss_score": 0.00365, "epss_percentile": 0.57981}, "CVE-2007-3423": {"epss_score": 0.00365, "epss_percentile": 0.57981}, "CVE-2007-3424": {"epss_score": 0.00365, "epss_percentile": 0.57981}, "CVE-2007-3425": {"epss_score": 0.1299, "epss_percentile": 0.93837}, "CVE-2007-3426": {"epss_score": 0.08738, "epss_percentile": 0.92233}, "CVE-2007-3427": {"epss_score": 0.01912, "epss_percentile": 0.82836}, "CVE-2007-3428": {"epss_score": 0.00567, "epss_percentile": 0.67849}, "CVE-2007-3429": {"epss_score": 0.03716, "epss_percentile": 0.87613}, "CVE-2007-3430": {"epss_score": 0.00996, "epss_percentile": 0.76451}, "CVE-2007-3431": {"epss_score": 0.83668, "epss_percentile": 0.99256}, "CVE-2007-3432": {"epss_score": 0.06743, "epss_percentile": 0.90997}, "CVE-2007-3433": {"epss_score": 0.00548, "epss_percentile": 0.67288}, "CVE-2007-3434": {"epss_score": 0.05177, "epss_percentile": 0.89575}, "CVE-2007-3435": {"epss_score": 0.77432, "epss_percentile": 0.98937}, "CVE-2007-3436": {"epss_score": 0.17255, "epss_percentile": 0.9481}, "CVE-2007-3437": {"epss_score": 0.00673, "epss_percentile": 0.70843}, "CVE-2007-3438": {"epss_score": 0.03607, "epss_percentile": 0.87419}, "CVE-2007-3439": {"epss_score": 0.00316, "epss_percentile": 0.54273}, "CVE-2007-3440": {"epss_score": 0.00656, "epss_percentile": 0.70449}, "CVE-2007-3441": {"epss_score": 0.00584, "epss_percentile": 0.68382}, "CVE-2007-3442": {"epss_score": 0.00254, "epss_percentile": 0.48625}, "CVE-2007-3443": {"epss_score": 0.00205, "epss_percentile": 0.42741}, "CVE-2007-3444": {"epss_score": 0.01969, "epss_percentile": 0.83093}, "CVE-2007-3445": {"epss_score": 0.00596, "epss_percentile": 0.68713}, "CVE-2007-3446": {"epss_score": 0.08596, "epss_percentile": 0.92143}, "CVE-2007-3447": {"epss_score": 0.01109, "epss_percentile": 0.7765}, "CVE-2007-3448": {"epss_score": 0.07657, "epss_percentile": 0.91607}, "CVE-2007-3449": {"epss_score": 0.00929, "epss_percentile": 0.7559}, "CVE-2007-3450": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2007-3451": {"epss_score": 0.05244, "epss_percentile": 0.89657}, "CVE-2007-3452": {"epss_score": 0.0062, "epss_percentile": 0.69452}, "CVE-2007-3453": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-3454": {"epss_score": 0.19743, "epss_percentile": 0.95236}, "CVE-2007-3455": {"epss_score": 0.02059, "epss_percentile": 0.83436}, "CVE-2007-3456": {"epss_score": 0.72585, "epss_percentile": 0.98717}, "CVE-2007-3457": {"epss_score": 0.05853, "epss_percentile": 0.90264}, "CVE-2007-3458": {"epss_score": 0.00061, "epss_percentile": 0.19355}, "CVE-2007-3459": {"epss_score": 0.08598, "epss_percentile": 0.92143}, "CVE-2007-3460": {"epss_score": 0.08047, "epss_percentile": 0.91852}, "CVE-2007-3461": {"epss_score": 0.0053, "epss_percentile": 0.66623}, "CVE-2007-3462": {"epss_score": 0.01112, "epss_percentile": 0.77673}, "CVE-2007-3463": {"epss_score": 0.00444, "epss_percentile": 0.6285}, "CVE-2007-3464": {"epss_score": 0.00339, "epss_percentile": 0.56196}, "CVE-2007-3465": {"epss_score": 0.00343, "epss_percentile": 0.56466}, "CVE-2007-3467": {"epss_score": 0.00989, "epss_percentile": 0.76367}, "CVE-2007-3468": {"epss_score": 0.00989, "epss_percentile": 0.76367}, "CVE-2007-3469": {"epss_score": 0.00061, "epss_percentile": 0.19549}, "CVE-2007-3470": {"epss_score": 0.03491, "epss_percentile": 0.87231}, "CVE-2007-3471": {"epss_score": 0.00094, "epss_percentile": 0.27043}, "CVE-2007-3472": {"epss_score": 0.0915, "epss_percentile": 0.92422}, "CVE-2007-3473": {"epss_score": 0.20299, "epss_percentile": 0.95316}, "CVE-2007-3474": {"epss_score": 0.06081, "epss_percentile": 0.90463}, "CVE-2007-3475": {"epss_score": 0.11683, "epss_percentile": 0.93446}, "CVE-2007-3476": {"epss_score": 0.05123, "epss_percentile": 0.89522}, "CVE-2007-3477": {"epss_score": 0.07352, "epss_percentile": 0.91426}, "CVE-2007-3478": {"epss_score": 0.11697, "epss_percentile": 0.93453}, "CVE-2007-3479": {"epss_score": 0.04582, "epss_percentile": 0.88879}, "CVE-2007-3480": {"epss_score": 0.0063, "epss_percentile": 0.69697}, "CVE-2007-3481": {"epss_score": 0.18758, "epss_percentile": 0.95065}, "CVE-2007-3482": {"epss_score": 0.00249, "epss_percentile": 0.48087}, "CVE-2007-3483": {"epss_score": 0.00334, "epss_percentile": 0.55717}, "CVE-2007-3484": {"epss_score": 0.0051, "epss_percentile": 0.65794}, "CVE-2007-3485": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2007-3486": {"epss_score": 0.00244, "epss_percentile": 0.47623}, "CVE-2007-3487": {"epss_score": 0.11797, "epss_percentile": 0.9348}, "CVE-2007-3488": {"epss_score": 0.24041, "epss_percentile": 0.95849}, "CVE-2007-3489": {"epss_score": 0.01708, "epss_percentile": 0.81864}, "CVE-2007-3490": {"epss_score": 0.39403, "epss_percentile": 0.97159}, "CVE-2007-3491": {"epss_score": 0.03429, "epss_percentile": 0.8712}, "CVE-2007-3492": {"epss_score": 0.03581, "epss_percentile": 0.87385}, "CVE-2007-3493": {"epss_score": 0.40038, "epss_percentile": 0.97192}, "CVE-2007-3494": {"epss_score": 0.00404, "epss_percentile": 0.60451}, "CVE-2007-3495": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3496": {"epss_score": 0.00587, "epss_percentile": 0.68459}, "CVE-2007-3497": {"epss_score": 0.33486, "epss_percentile": 0.96777}, "CVE-2007-3498": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3499": {"epss_score": 0.00323, "epss_percentile": 0.54902}, "CVE-2007-3500": {"epss_score": 0.00841, "epss_percentile": 0.74217}, "CVE-2007-3501": {"epss_score": 0.00388, "epss_percentile": 0.59393}, "CVE-2007-3502": {"epss_score": 0.01023, "epss_percentile": 0.76772}, "CVE-2007-3503": {"epss_score": 0.01304, "epss_percentile": 0.79314}, "CVE-2007-3504": {"epss_score": 0.05226, "epss_percentile": 0.89633}, "CVE-2007-3505": {"epss_score": 0.12848, "epss_percentile": 0.93802}, "CVE-2007-3506": {"epss_score": 0.00712, "epss_percentile": 0.71773}, "CVE-2007-3507": {"epss_score": 0.06667, "epss_percentile": 0.90929}, "CVE-2007-3508": {"epss_score": 0.00049, "epss_percentile": 0.15359}, "CVE-2007-3509": {"epss_score": 0.26491, "epss_percentile": 0.96151}, "CVE-2007-3510": {"epss_score": 0.0874, "epss_percentile": 0.92235}, "CVE-2007-3511": {"epss_score": 0.03377, "epss_percentile": 0.87023}, "CVE-2007-3512": {"epss_score": 0.09606, "epss_percentile": 0.92618}, "CVE-2007-3513": {"epss_score": 0.00126, "epss_percentile": 0.32737}, "CVE-2007-3514": {"epss_score": 0.00165, "epss_percentile": 0.38023}, "CVE-2007-3515": {"epss_score": 0.0138, "epss_percentile": 0.79863}, "CVE-2007-3516": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3517": {"epss_score": 0.00658, "epss_percentile": 0.70488}, "CVE-2007-3518": {"epss_score": 0.01126, "epss_percentile": 0.77817}, "CVE-2007-3519": {"epss_score": 0.01502, "epss_percentile": 0.80723}, "CVE-2007-3520": {"epss_score": 0.00964, "epss_percentile": 0.76028}, "CVE-2007-3521": {"epss_score": 0.0053, "epss_percentile": 0.66623}, "CVE-2007-3522": {"epss_score": 0.65559, "epss_percentile": 0.98426}, "CVE-2007-3523": {"epss_score": 0.04962, "epss_percentile": 0.89337}, "CVE-2007-3524": {"epss_score": 0.65489, "epss_percentile": 0.98422}, "CVE-2007-3525": {"epss_score": 0.00267, "epss_percentile": 0.50011}, "CVE-2007-3526": {"epss_score": 0.00895, "epss_percentile": 0.75104}, "CVE-2007-3527": {"epss_score": 0.01264, "epss_percentile": 0.78993}, "CVE-2007-3528": {"epss_score": 0.00514, "epss_percentile": 0.65951}, "CVE-2007-3529": {"epss_score": 0.04786, "epss_percentile": 0.89143}, "CVE-2007-3530": {"epss_score": 0.00419, "epss_percentile": 0.6136}, "CVE-2007-3531": {"epss_score": 0.00049, "epss_percentile": 0.15429}, "CVE-2007-3532": {"epss_score": 0.00034, "epss_percentile": 0.09732}, "CVE-2007-3533": {"epss_score": 0.01176, "epss_percentile": 0.78269}, "CVE-2007-3534": {"epss_score": 0.0053, "epss_percentile": 0.66623}, "CVE-2007-3535": {"epss_score": 0.09172, "epss_percentile": 0.92432}, "CVE-2007-3536": {"epss_score": 0.08782, "epss_percentile": 0.92253}, "CVE-2007-3537": {"epss_score": 0.00326, "epss_percentile": 0.55088}, "CVE-2007-3538": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-3539": {"epss_score": 0.01673, "epss_percentile": 0.81686}, "CVE-2007-3540": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-3541": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3542": {"epss_score": 0.03764, "epss_percentile": 0.87693}, "CVE-2007-3543": {"epss_score": 0.01203, "epss_percentile": 0.78499}, "CVE-2007-3544": {"epss_score": 0.01082, "epss_percentile": 0.77387}, "CVE-2007-3545": {"epss_score": 0.0179, "epss_percentile": 0.82279}, "CVE-2007-3546": {"epss_score": 0.00771, "epss_percentile": 0.73025}, "CVE-2007-3547": {"epss_score": 0.05992, "epss_percentile": 0.90388}, "CVE-2007-3548": {"epss_score": 0.04096, "epss_percentile": 0.88249}, "CVE-2007-3549": {"epss_score": 0.0037, "epss_percentile": 0.58324}, "CVE-2007-3550": {"epss_score": 0.36133, "epss_percentile": 0.96958}, "CVE-2007-3551": {"epss_score": 0.0079, "epss_percentile": 0.73378}, "CVE-2007-3552": {"epss_score": 0.01509, "epss_percentile": 0.80763}, "CVE-2007-3553": {"epss_score": 0.11388, "epss_percentile": 0.93329}, "CVE-2007-3554": {"epss_score": 0.35411, "epss_percentile": 0.96906}, "CVE-2007-3555": {"epss_score": 0.05012, "epss_percentile": 0.89391}, "CVE-2007-3556": {"epss_score": 0.07657, "epss_percentile": 0.91608}, "CVE-2007-3557": {"epss_score": 0.00706, "epss_percentile": 0.71614}, "CVE-2007-3558": {"epss_score": 0.00764, "epss_percentile": 0.72897}, "CVE-2007-3559": {"epss_score": 0.00247, "epss_percentile": 0.47902}, "CVE-2007-3560": {"epss_score": 0.00494, "epss_percentile": 0.65093}, "CVE-2007-3561": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3562": {"epss_score": 0.01906, "epss_percentile": 0.82797}, "CVE-2007-3563": {"epss_score": 0.01109, "epss_percentile": 0.7765}, "CVE-2007-3564": {"epss_score": 0.00609, "epss_percentile": 0.69134}, "CVE-2007-3566": {"epss_score": 0.74824, "epss_percentile": 0.98819}, "CVE-2007-3567": {"epss_score": 0.0105, "epss_percentile": 0.7707}, "CVE-2007-3568": {"epss_score": 0.00422, "epss_percentile": 0.61558}, "CVE-2007-3569": {"epss_score": 0.15974, "epss_percentile": 0.94545}, "CVE-2007-3570": {"epss_score": 0.00164, "epss_percentile": 0.37881}, "CVE-2007-3571": {"epss_score": 0.00121, "epss_percentile": 0.32016}, "CVE-2007-3572": {"epss_score": 0.11022, "epss_percentile": 0.93192}, "CVE-2007-3573": {"epss_score": 0.00359, "epss_percentile": 0.57618}, "CVE-2007-3574": {"epss_score": 0.07152, "epss_percentile": 0.91288}, "CVE-2007-3575": {"epss_score": 0.00595, "epss_percentile": 0.68693}, "CVE-2007-3576": {"epss_score": 0.21949, "epss_percentile": 0.95576}, "CVE-2007-3577": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3578": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-3579": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3580": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3581": {"epss_score": 0.00242, "epss_percentile": 0.47341}, "CVE-2007-3582": {"epss_score": 0.00925, "epss_percentile": 0.75535}, "CVE-2007-3583": {"epss_score": 0.01164, "epss_percentile": 0.78167}, "CVE-2007-3584": {"epss_score": 0.00521, "epss_percentile": 0.66233}, "CVE-2007-3585": {"epss_score": 0.04163, "epss_percentile": 0.88339}, "CVE-2007-3586": {"epss_score": 0.04515, "epss_percentile": 0.8879}, "CVE-2007-3587": {"epss_score": 0.08859, "epss_percentile": 0.92287}, "CVE-2007-3588": {"epss_score": 0.00384, "epss_percentile": 0.59178}, "CVE-2007-3589": {"epss_score": 0.00548, "epss_percentile": 0.67288}, "CVE-2007-3590": {"epss_score": 0.0338, "epss_percentile": 0.8703}, "CVE-2007-3591": {"epss_score": 0.00381, "epss_percentile": 0.59027}, "CVE-2007-3592": {"epss_score": 0.00614, "epss_percentile": 0.69271}, "CVE-2007-3593": {"epss_score": 0.01964, "epss_percentile": 0.83076}, "CVE-2007-3594": {"epss_score": 0.01082, "epss_percentile": 0.7738}, "CVE-2007-3596": {"epss_score": 0.00579, "epss_percentile": 0.68208}, "CVE-2007-3597": {"epss_score": 0.01234, "epss_percentile": 0.78759}, "CVE-2007-3598": {"epss_score": 0.00218, "epss_percentile": 0.44394}, "CVE-2007-3599": {"epss_score": 0.00181, "epss_percentile": 0.40097}, "CVE-2007-3600": {"epss_score": 0.00281, "epss_percentile": 0.51147}, "CVE-2007-3601": {"epss_score": 0.00217, "epss_percentile": 0.44332}, "CVE-2007-3602": {"epss_score": 0.00244, "epss_percentile": 0.47621}, "CVE-2007-3603": {"epss_score": 0.00507, "epss_percentile": 0.65651}, "CVE-2007-3604": {"epss_score": 0.00238, "epss_percentile": 0.46816}, "CVE-2007-3605": {"epss_score": 0.86968, "epss_percentile": 0.99405}, "CVE-2007-3606": {"epss_score": 0.19932, "epss_percentile": 0.95263}, "CVE-2007-3607": {"epss_score": 0.17321, "epss_percentile": 0.94822}, "CVE-2007-3608": {"epss_score": 0.10308, "epss_percentile": 0.92937}, "CVE-2007-3609": {"epss_score": 0.01411, "epss_percentile": 0.8011}, "CVE-2007-3610": {"epss_score": 0.00964, "epss_percentile": 0.76028}, "CVE-2007-3611": {"epss_score": 0.05501, "epss_percentile": 0.89938}, "CVE-2007-3612": {"epss_score": 0.07897, "epss_percentile": 0.91751}, "CVE-2007-3613": {"epss_score": 0.16778, "epss_percentile": 0.9473}, "CVE-2007-3614": {"epss_score": 0.7771, "epss_percentile": 0.98949}, "CVE-2007-3615": {"epss_score": 0.02239, "epss_percentile": 0.84108}, "CVE-2007-3616": {"epss_score": 0.00428, "epss_percentile": 0.61919}, "CVE-2007-3617": {"epss_score": 0.00217, "epss_percentile": 0.44332}, "CVE-2007-3618": {"epss_score": 0.19419, "epss_percentile": 0.95179}, "CVE-2007-3619": {"epss_score": 0.14014, "epss_percentile": 0.94114}, "CVE-2007-3620": {"epss_score": 0.00903, "epss_percentile": 0.75209}, "CVE-2007-3621": {"epss_score": 0.14796, "epss_percentile": 0.94286}, "CVE-2007-3622": {"epss_score": 0.01034, "epss_percentile": 0.76887}, "CVE-2007-3623": {"epss_score": 0.00771, "epss_percentile": 0.73025}, "CVE-2007-3624": {"epss_score": 0.65408, "epss_percentile": 0.98416}, "CVE-2007-3625": {"epss_score": 0.01754, "epss_percentile": 0.82115}, "CVE-2007-3626": {"epss_score": 0.01351, "epss_percentile": 0.7968}, "CVE-2007-3627": {"epss_score": 0.00341, "epss_percentile": 0.56345}, "CVE-2007-3628": {"epss_score": 0.00308, "epss_percentile": 0.53641}, "CVE-2007-3629": {"epss_score": 0.0069, "epss_percentile": 0.71259}, "CVE-2007-3630": {"epss_score": 0.06818, "epss_percentile": 0.91044}, "CVE-2007-3631": {"epss_score": 0.00964, "epss_percentile": 0.76028}, "CVE-2007-3632": {"epss_score": 0.6985, "epss_percentile": 0.98606}, "CVE-2007-3633": {"epss_score": 0.08888, "epss_percentile": 0.92302}, "CVE-2007-3634": {"epss_score": 0.00765, "epss_percentile": 0.72918}, "CVE-2007-3635": {"epss_score": 0.00053, "epss_percentile": 0.16847}, "CVE-2007-3636": {"epss_score": 0.05052, "epss_percentile": 0.89441}, "CVE-2007-3637": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-3638": {"epss_score": 0.04089, "epss_percentile": 0.88236}, "CVE-2007-3639": {"epss_score": 0.01147, "epss_percentile": 0.78005}, "CVE-2007-3640": {"epss_score": 0.02501, "epss_percentile": 0.84923}, "CVE-2007-3641": {"epss_score": 0.36313, "epss_percentile": 0.96969}, "CVE-2007-3642": {"epss_score": 0.02261, "epss_percentile": 0.84188}, "CVE-2007-3643": {"epss_score": 0.00919, "epss_percentile": 0.75458}, "CVE-2007-3644": {"epss_score": 0.13444, "epss_percentile": 0.93965}, "CVE-2007-3645": {"epss_score": 0.12016, "epss_percentile": 0.93548}, "CVE-2007-3646": {"epss_score": 0.01204, "epss_percentile": 0.78506}, "CVE-2007-3647": {"epss_score": 0.02084, "epss_percentile": 0.83543}, "CVE-2007-3648": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2007-3649": {"epss_score": 0.06615, "epss_percentile": 0.90891}, "CVE-2007-3650": {"epss_score": 0.00271, "epss_percentile": 0.50302}, "CVE-2007-3651": {"epss_score": 0.00276, "epss_percentile": 0.5075}, "CVE-2007-3652": {"epss_score": 0.00349, "epss_percentile": 0.56889}, "CVE-2007-3653": {"epss_score": 0.00294, "epss_percentile": 0.52414}, "CVE-2007-3654": {"epss_score": 0.0007, "epss_percentile": 0.21956}, "CVE-2007-3655": {"epss_score": 0.64759, "epss_percentile": 0.9839}, "CVE-2007-3656": {"epss_score": 0.0523, "epss_percentile": 0.89637}, "CVE-2007-3657": {"epss_score": 0.0078, "epss_percentile": 0.73163}, "CVE-2007-3658": {"epss_score": 0.24452, "epss_percentile": 0.95923}, "CVE-2007-3659": {"epss_score": 0.00091, "epss_percentile": 0.26271}, "CVE-2007-3660": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2007-3661": {"epss_score": 0.00584, "epss_percentile": 0.68382}, "CVE-2007-3662": {"epss_score": 0.02219, "epss_percentile": 0.84044}, "CVE-2007-3663": {"epss_score": 0.01532, "epss_percentile": 0.80894}, "CVE-2007-3664": {"epss_score": 0.00518, "epss_percentile": 0.66094}, "CVE-2007-3665": {"epss_score": 0.00942, "epss_percentile": 0.75767}, "CVE-2007-3666": {"epss_score": 0.04569, "epss_percentile": 0.88861}, "CVE-2007-3667": {"epss_score": 0.00594, "epss_percentile": 0.68663}, "CVE-2007-3668": {"epss_score": 0.00594, "epss_percentile": 0.68663}, "CVE-2007-3669": {"epss_score": 0.00376, "epss_percentile": 0.58662}, "CVE-2007-3670": {"epss_score": 0.49726, "epss_percentile": 0.97702}, "CVE-2007-3671": {"epss_score": 0.28167, "epss_percentile": 0.96328}, "CVE-2007-3672": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2007-3673": {"epss_score": 0.00171, "epss_percentile": 0.38895}, "CVE-2007-3675": {"epss_score": 0.07663, "epss_percentile": 0.91609}, "CVE-2007-3676": {"epss_score": 0.04078, "epss_percentile": 0.88214}, "CVE-2007-3677": {"epss_score": 0.01469, "epss_percentile": 0.80483}, "CVE-2007-3678": {"epss_score": 0.12503, "epss_percentile": 0.93695}, "CVE-2007-3679": {"epss_score": 0.01126, "epss_percentile": 0.77819}, "CVE-2007-3680": {"epss_score": 0.00062, "epss_percentile": 0.19636}, "CVE-2007-3681": {"epss_score": 0.00096, "epss_percentile": 0.2728}, "CVE-2007-3682": {"epss_score": 0.01126, "epss_percentile": 0.77817}, "CVE-2007-3683": {"epss_score": 0.01164, "epss_percentile": 0.78167}, "CVE-2007-3684": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-3685": {"epss_score": 0.00381, "epss_percentile": 0.59013}, "CVE-2007-3686": {"epss_score": 0.00721, "epss_percentile": 0.71974}, "CVE-2007-3687": {"epss_score": 0.00881, "epss_percentile": 0.74864}, "CVE-2007-3688": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2007-3689": {"epss_score": 0.00711, "epss_percentile": 0.71746}, "CVE-2007-3690": {"epss_score": 0.00711, "epss_percentile": 0.71746}, "CVE-2007-3691": {"epss_score": 0.00371, "epss_percentile": 0.58383}, "CVE-2007-3692": {"epss_score": 0.00512, "epss_percentile": 0.65866}, "CVE-2007-3693": {"epss_score": 0.00347, "epss_percentile": 0.56754}, "CVE-2007-3694": {"epss_score": 0.01498, "epss_percentile": 0.80703}, "CVE-2007-3695": {"epss_score": 0.01276, "epss_percentile": 0.79107}, "CVE-2007-3696": {"epss_score": 0.00785, "epss_percentile": 0.73249}, "CVE-2007-3697": {"epss_score": 0.1061, "epss_percentile": 0.93046}, "CVE-2007-3698": {"epss_score": 0.16804, "epss_percentile": 0.94734}, "CVE-2007-3699": {"epss_score": 0.02382, "epss_percentile": 0.84567}, "CVE-2007-3700": {"epss_score": 0.00058, "epss_percentile": 0.1857}, "CVE-2007-3701": {"epss_score": 0.09344, "epss_percentile": 0.92509}, "CVE-2007-3702": {"epss_score": 0.08289, "epss_percentile": 0.91972}, "CVE-2007-3703": {"epss_score": 0.15772, "epss_percentile": 0.94508}, "CVE-2007-3704": {"epss_score": 0.00904, "epss_percentile": 0.75217}, "CVE-2007-3705": {"epss_score": 0.00387, "epss_percentile": 0.59315}, "CVE-2007-3706": {"epss_score": 0.00167, "epss_percentile": 0.38273}, "CVE-2007-3707": {"epss_score": 0.00335, "epss_percentile": 0.55834}, "CVE-2007-3708": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3709": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2007-3710": {"epss_score": 0.00567, "epss_percentile": 0.67849}, "CVE-2007-3711": {"epss_score": 0.01722, "epss_percentile": 0.81939}, "CVE-2007-3712": {"epss_score": 0.00244, "epss_percentile": 0.47623}, "CVE-2007-3713": {"epss_score": 0.12876, "epss_percentile": 0.93809}, "CVE-2007-3714": {"epss_score": 0.03243, "epss_percentile": 0.8674}, "CVE-2007-3715": {"epss_score": 0.0121, "epss_percentile": 0.78547}, "CVE-2007-3716": {"epss_score": 0.04642, "epss_percentile": 0.88954}, "CVE-2007-3717": {"epss_score": 0.00047, "epss_percentile": 0.14487}, "CVE-2007-3718": {"epss_score": 0.00419, "epss_percentile": 0.61368}, "CVE-2007-3719": {"epss_score": 0.00065, "epss_percentile": 0.20445}, "CVE-2007-3720": {"epss_score": 0.00058, "epss_percentile": 0.18456}, "CVE-2007-3721": {"epss_score": 0.00068, "epss_percentile": 0.21344}, "CVE-2007-3722": {"epss_score": 0.00068, "epss_percentile": 0.21344}, "CVE-2007-3723": {"epss_score": 0.00056, "epss_percentile": 0.17758}, "CVE-2007-3724": {"epss_score": 0.00263, "epss_percentile": 0.49474}, "CVE-2007-3725": {"epss_score": 0.18886, "epss_percentile": 0.95086}, "CVE-2007-3726": {"epss_score": 0.01124, "epss_percentile": 0.77797}, "CVE-2007-3727": {"epss_score": 0.00464, "epss_percentile": 0.63729}, "CVE-2007-3728": {"epss_score": 0.01487, "epss_percentile": 0.80613}, "CVE-2007-3729": {"epss_score": 0.00692, "epss_percentile": 0.71299}, "CVE-2007-3730": {"epss_score": 0.00562, "epss_percentile": 0.67694}, "CVE-2007-3731": {"epss_score": 0.00111, "epss_percentile": 0.30405}, "CVE-2007-3732": {"epss_score": 0.00164, "epss_percentile": 0.37944}, "CVE-2007-3734": {"epss_score": 0.14401, "epss_percentile": 0.94204}, "CVE-2007-3735": {"epss_score": 0.10315, "epss_percentile": 0.9294}, "CVE-2007-3736": {"epss_score": 0.0261, "epss_percentile": 0.85235}, "CVE-2007-3737": {"epss_score": 0.09678, "epss_percentile": 0.92655}, "CVE-2007-3738": {"epss_score": 0.11994, "epss_percentile": 0.9354}, "CVE-2007-3739": {"epss_score": 0.00091, "epss_percentile": 0.26219}, "CVE-2007-3740": {"epss_score": 0.0011, "epss_percentile": 0.30194}, "CVE-2007-3741": {"epss_score": 0.01744, "epss_percentile": 0.82062}, "CVE-2007-3742": {"epss_score": 0.00614, "epss_percentile": 0.69267}, "CVE-2007-3743": {"epss_score": 0.01954, "epss_percentile": 0.8303}, "CVE-2007-3744": {"epss_score": 0.06312, "epss_percentile": 0.90665}, "CVE-2007-3745": {"epss_score": 0.03927, "epss_percentile": 0.87966}, "CVE-2007-3746": {"epss_score": 0.03927, "epss_percentile": 0.87966}, "CVE-2007-3747": {"epss_score": 0.03927, "epss_percentile": 0.87966}, "CVE-2007-3748": {"epss_score": 0.03442, "epss_percentile": 0.87142}, "CVE-2007-3749": {"epss_score": 0.00147, "epss_percentile": 0.35779}, "CVE-2007-3750": {"epss_score": 0.20708, "epss_percentile": 0.95404}, "CVE-2007-3751": {"epss_score": 0.23326, "epss_percentile": 0.95764}, "CVE-2007-3752": {"epss_score": 0.16027, "epss_percentile": 0.94561}, "CVE-2007-3753": {"epss_score": 0.01288, "epss_percentile": 0.79198}, "CVE-2007-3754": {"epss_score": 0.00721, "epss_percentile": 0.71975}, "CVE-2007-3755": {"epss_score": 0.0106, "epss_percentile": 0.77167}, "CVE-2007-3756": {"epss_score": 0.01094, "epss_percentile": 0.77493}, "CVE-2007-3757": {"epss_score": 0.0106, "epss_percentile": 0.77167}, "CVE-2007-3758": {"epss_score": 0.0153, "epss_percentile": 0.80883}, "CVE-2007-3759": {"epss_score": 0.00751, "epss_percentile": 0.72636}, "CVE-2007-3760": {"epss_score": 0.01326, "epss_percentile": 0.79484}, "CVE-2007-3761": {"epss_score": 0.00565, "epss_percentile": 0.67791}, "CVE-2007-3762": {"epss_score": 0.09844, "epss_percentile": 0.92732}, "CVE-2007-3763": {"epss_score": 0.24477, "epss_percentile": 0.95925}, "CVE-2007-3764": {"epss_score": 0.44755, "epss_percentile": 0.97452}, "CVE-2007-3765": {"epss_score": 0.00825, "epss_percentile": 0.73958}, "CVE-2007-3768": {"epss_score": 0.00955, "epss_percentile": 0.7591}, "CVE-2007-3769": {"epss_score": 0.00713, "epss_percentile": 0.71803}, "CVE-2007-3770": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2007-3771": {"epss_score": 0.00053, "epss_percentile": 0.16852}, "CVE-2007-3772": {"epss_score": 0.04882, "epss_percentile": 0.8925}, "CVE-2007-3773": {"epss_score": 0.00733, "epss_percentile": 0.72203}, "CVE-2007-3774": {"epss_score": 0.00306, "epss_percentile": 0.53428}, "CVE-2007-3775": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2007-3776": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2007-3777": {"epss_score": 0.00061, "epss_percentile": 0.19537}, "CVE-2007-3778": {"epss_score": 0.01681, "epss_percentile": 0.81731}, "CVE-2007-3779": {"epss_score": 0.00275, "epss_percentile": 0.50671}, "CVE-2007-3780": {"epss_score": 0.08532, "epss_percentile": 0.92106}, "CVE-2007-3781": {"epss_score": 0.00514, "epss_percentile": 0.65947}, "CVE-2007-3782": {"epss_score": 0.00558, "epss_percentile": 0.67574}, "CVE-2007-3783": {"epss_score": 0.00893, "epss_percentile": 0.75078}, "CVE-2007-3784": {"epss_score": 0.00537, "epss_percentile": 0.66918}, "CVE-2007-3785": {"epss_score": 0.02586, "epss_percentile": 0.85168}, "CVE-2007-3786": {"epss_score": 0.02378, "epss_percentile": 0.84555}, "CVE-2007-3787": {"epss_score": 0.00798, "epss_percentile": 0.73504}, "CVE-2007-3788": {"epss_score": 0.00497, "epss_percentile": 0.65197}, "CVE-2007-3789": {"epss_score": 0.00236, "epss_percentile": 0.46409}, "CVE-2007-3790": {"epss_score": 0.06478, "epss_percentile": 0.90783}, "CVE-2007-3791": {"epss_score": 0.04115, "epss_percentile": 0.88277}, "CVE-2007-3792": {"epss_score": 0.08257, "epss_percentile": 0.91954}, "CVE-2007-3793": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-3794": {"epss_score": 0.00461, "epss_percentile": 0.63539}, "CVE-2007-3795": {"epss_score": 0.00709, "epss_percentile": 0.71699}, "CVE-2007-3796": {"epss_score": 0.00919, "epss_percentile": 0.75458}, "CVE-2007-3798": {"epss_score": 0.72116, "epss_percentile": 0.98696}, "CVE-2007-3799": {"epss_score": 0.10317, "epss_percentile": 0.92941}, "CVE-2007-3800": {"epss_score": 0.00055, "epss_percentile": 0.17553}, "CVE-2007-3803": {"epss_score": 0.00511, "epss_percentile": 0.65832}, "CVE-2007-3804": {"epss_score": 0.00374, "epss_percentile": 0.58545}, "CVE-2007-3805": {"epss_score": 0.00391, "epss_percentile": 0.59571}, "CVE-2007-3806": {"epss_score": 0.05848, "epss_percentile": 0.90259}, "CVE-2007-3807": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3808": {"epss_score": 0.00895, "epss_percentile": 0.75104}, "CVE-2007-3809": {"epss_score": 0.00521, "epss_percentile": 0.66233}, "CVE-2007-3810": {"epss_score": 0.00964, "epss_percentile": 0.76028}, "CVE-2007-3811": {"epss_score": 0.00996, "epss_percentile": 0.76451}, "CVE-2007-3812": {"epss_score": 0.01164, "epss_percentile": 0.78167}, "CVE-2007-3813": {"epss_score": 0.21497, "epss_percentile": 0.95526}, "CVE-2007-3814": {"epss_score": 0.01849, "epss_percentile": 0.82529}, "CVE-2007-3815": {"epss_score": 0.00053, "epss_percentile": 0.16755}, "CVE-2007-3816": {"epss_score": 0.01846, "epss_percentile": 0.82514}, "CVE-2007-3817": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3818": {"epss_score": 0.00187, "epss_percentile": 0.40736}, "CVE-2007-3819": {"epss_score": 0.011, "epss_percentile": 0.77571}, "CVE-2007-3820": {"epss_score": 0.01136, "epss_percentile": 0.77915}, "CVE-2007-3821": {"epss_score": 0.00878, "epss_percentile": 0.74818}, "CVE-2007-3822": {"epss_score": 0.07506, "epss_percentile": 0.9151}, "CVE-2007-3823": {"epss_score": 0.02142, "epss_percentile": 0.83755}, "CVE-2007-3824": {"epss_score": 0.0138, "epss_percentile": 0.79863}, "CVE-2007-3825": {"epss_score": 0.27263, "epss_percentile": 0.96229}, "CVE-2007-3826": {"epss_score": 0.67067, "epss_percentile": 0.98492}, "CVE-2007-3827": {"epss_score": 0.00273, "epss_percentile": 0.50482}, "CVE-2007-3828": {"epss_score": 0.02713, "epss_percentile": 0.85503}, "CVE-2007-3829": {"epss_score": 0.29285, "epss_percentile": 0.9643}, "CVE-2007-3830": {"epss_score": 0.00596, "epss_percentile": 0.68712}, "CVE-2007-3831": {"epss_score": 0.05071, "epss_percentile": 0.89464}, "CVE-2007-3832": {"epss_score": 0.15296, "epss_percentile": 0.94404}, "CVE-2007-3833": {"epss_score": 0.0122, "epss_percentile": 0.78624}, "CVE-2007-3834": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-3835": {"epss_score": 0.00537, "epss_percentile": 0.66918}, "CVE-2007-3836": {"epss_score": 0.00673, "epss_percentile": 0.70843}, "CVE-2007-3837": {"epss_score": 0.00398, "epss_percentile": 0.60088}, "CVE-2007-3838": {"epss_score": 0.02709, "epss_percentile": 0.8548}, "CVE-2007-3839": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2007-3840": {"epss_score": 0.00521, "epss_percentile": 0.66233}, "CVE-2007-3841": {"epss_score": 0.00468, "epss_percentile": 0.6387}, "CVE-2007-3842": {"epss_score": 0.00244, "epss_percentile": 0.47623}, "CVE-2007-3843": {"epss_score": 0.01982, "epss_percentile": 0.83139}, "CVE-2007-3844": {"epss_score": 0.21632, "epss_percentile": 0.95541}, "CVE-2007-3845": {"epss_score": 0.43235, "epss_percentile": 0.97376}, "CVE-2007-3846": {"epss_score": 0.01232, "epss_percentile": 0.78738}, "CVE-2007-3847": {"epss_score": 0.22605, "epss_percentile": 0.95656}, "CVE-2007-3848": {"epss_score": 0.00082, "epss_percentile": 0.24559}, "CVE-2007-3849": {"epss_score": 0.00096, "epss_percentile": 0.27449}, "CVE-2007-3850": {"epss_score": 0.00099, "epss_percentile": 0.27866}, "CVE-2007-3851": {"epss_score": 0.00086, "epss_percentile": 0.25338}, "CVE-2007-3852": {"epss_score": 0.00142, "epss_percentile": 0.35001}, "CVE-2007-3853": {"epss_score": 0.03273, "epss_percentile": 0.86799}, "CVE-2007-3854": {"epss_score": 0.07875, "epss_percentile": 0.91738}, "CVE-2007-3855": {"epss_score": 0.34498, "epss_percentile": 0.9685}, "CVE-2007-3856": {"epss_score": 0.05938, "epss_percentile": 0.90347}, "CVE-2007-3857": {"epss_score": 0.05938, "epss_percentile": 0.90347}, "CVE-2007-3858": {"epss_score": 0.06409, "epss_percentile": 0.90739}, "CVE-2007-3859": {"epss_score": 0.02209, "epss_percentile": 0.8401}, "CVE-2007-3860": {"epss_score": 0.01689, "epss_percentile": 0.81765}, "CVE-2007-3861": {"epss_score": 0.01977, "epss_percentile": 0.83127}, "CVE-2007-3862": {"epss_score": 0.04269, "epss_percentile": 0.88472}, "CVE-2007-3863": {"epss_score": 0.01977, "epss_percentile": 0.83127}, "CVE-2007-3864": {"epss_score": 0.01977, "epss_percentile": 0.83127}, "CVE-2007-3865": {"epss_score": 0.01822, "epss_percentile": 0.82415}, "CVE-2007-3866": {"epss_score": 0.05366, "epss_percentile": 0.89789}, "CVE-2007-3867": {"epss_score": 0.01822, "epss_percentile": 0.82415}, "CVE-2007-3868": {"epss_score": 0.04008, "epss_percentile": 0.88105}, "CVE-2007-3869": {"epss_score": 0.04269, "epss_percentile": 0.88472}, "CVE-2007-3870": {"epss_score": 0.00127, "epss_percentile": 0.32841}, "CVE-2007-3871": {"epss_score": 0.01084, "epss_percentile": 0.77399}, "CVE-2007-3872": {"epss_score": 0.71103, "epss_percentile": 0.98653}, "CVE-2007-3873": {"epss_score": 0.00074, "epss_percentile": 0.22858}, "CVE-2007-3874": {"epss_score": 0.00451, "epss_percentile": 0.63143}, "CVE-2007-3875": {"epss_score": 0.02606, "epss_percentile": 0.85225}, "CVE-2007-3876": {"epss_score": 0.00274, "epss_percentile": 0.50563}, "CVE-2007-3880": {"epss_score": 0.00053, "epss_percentile": 0.16752}, "CVE-2007-3881": {"epss_score": 0.00521, "epss_percentile": 0.66233}, "CVE-2007-3882": {"epss_score": 0.00521, "epss_percentile": 0.66233}, "CVE-2007-3883": {"epss_score": 0.213, "epss_percentile": 0.95497}, "CVE-2007-3884": {"epss_score": 0.01372, "epss_percentile": 0.79811}, "CVE-2007-3885": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-3886": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-3887": {"epss_score": 0.00551, "epss_percentile": 0.67359}, "CVE-2007-3888": {"epss_score": 0.02192, "epss_percentile": 0.83941}, "CVE-2007-3889": {"epss_score": 0.01703, "epss_percentile": 0.81841}, "CVE-2007-3890": {"epss_score": 0.58977, "epss_percentile": 0.98143}, "CVE-2007-3891": {"epss_score": 0.5212, "epss_percentile": 0.97808}, "CVE-2007-3892": {"epss_score": 0.40818, "epss_percentile": 0.97239}, "CVE-2007-3893": {"epss_score": 0.40696, "epss_percentile": 0.97233}, "CVE-2007-3895": {"epss_score": 0.71161, "epss_percentile": 0.98657}, "CVE-2007-3896": {"epss_score": 0.83256, "epss_percentile": 0.99239}, "CVE-2007-3897": {"epss_score": 0.64036, "epss_percentile": 0.98361}, "CVE-2007-3898": {"epss_score": 0.83309, "epss_percentile": 0.99244}, "CVE-2007-3899": {"epss_score": 0.51546, "epss_percentile": 0.97786}, "CVE-2007-3901": {"epss_score": 0.74916, "epss_percentile": 0.98823}, "CVE-2007-3902": {"epss_score": 0.52672, "epss_percentile": 0.97835}, "CVE-2007-3903": {"epss_score": 0.48183, "epss_percentile": 0.97625}, "CVE-2007-3905": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-3906": {"epss_score": 0.00846, "epss_percentile": 0.74337}, "CVE-2007-3907": {"epss_score": 0.01813, "epss_percentile": 0.82376}, "CVE-2007-3908": {"epss_score": 0.00068, "epss_percentile": 0.21391}, "CVE-2007-3909": {"epss_score": 0.0041, "epss_percentile": 0.60789}, "CVE-2007-3910": {"epss_score": 0.00581, "epss_percentile": 0.68268}, "CVE-2007-3911": {"epss_score": 0.19743, "epss_percentile": 0.95236}, "CVE-2007-3912": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2007-3913": {"epss_score": 0.00254, "epss_percentile": 0.48561}, "CVE-2007-3915": {"epss_score": 0.00361, "epss_percentile": 0.57696}, "CVE-2007-3916": {"epss_score": 0.00039, "epss_percentile": 0.11616}, "CVE-2007-3917": {"epss_score": 0.02801, "epss_percentile": 0.85697}, "CVE-2007-3918": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-3919": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2007-3920": {"epss_score": 0.00051, "epss_percentile": 0.16242}, "CVE-2007-3921": {"epss_score": 0.00035, "epss_percentile": 0.09857}, "CVE-2007-3922": {"epss_score": 0.0398, "epss_percentile": 0.88057}, "CVE-2007-3923": {"epss_score": 0.01263, "epss_percentile": 0.78987}, "CVE-2007-3924": {"epss_score": 0.07824, "epss_percentile": 0.91699}, "CVE-2007-3925": {"epss_score": 0.90124, "epss_percentile": 0.99563}, "CVE-2007-3926": {"epss_score": 0.00285, "epss_percentile": 0.51675}, "CVE-2007-3927": {"epss_score": 0.71119, "epss_percentile": 0.98654}, "CVE-2007-3928": {"epss_score": 0.09377, "epss_percentile": 0.92522}, "CVE-2007-3929": {"epss_score": 0.07276, "epss_percentile": 0.9138}, "CVE-2007-3930": {"epss_score": 0.17174, "epss_percentile": 0.94791}, "CVE-2007-3931": {"epss_score": 0.00055, "epss_percentile": 0.17618}, "CVE-2007-3932": {"epss_score": 0.04469, "epss_percentile": 0.88733}, "CVE-2007-3933": {"epss_score": 0.0055, "epss_percentile": 0.67341}, "CVE-2007-3934": {"epss_score": 0.08651, "epss_percentile": 0.92171}, "CVE-2007-3935": {"epss_score": 0.01158, "epss_percentile": 0.78117}, "CVE-2007-3936": {"epss_score": 0.04303, "epss_percentile": 0.88518}, "CVE-2007-3937": {"epss_score": 0.00404, "epss_percentile": 0.60444}, "CVE-2007-3938": {"epss_score": 0.01073, "epss_percentile": 0.77288}, "CVE-2007-3939": {"epss_score": 0.00842, "epss_percentile": 0.74236}, "CVE-2007-3940": {"epss_score": 0.00407, "epss_percentile": 0.60613}, "CVE-2007-3941": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-3942": {"epss_score": 0.00254, "epss_percentile": 0.48624}, "CVE-2007-3943": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-3944": {"epss_score": 0.18061, "epss_percentile": 0.9495}, "CVE-2007-3945": {"epss_score": 0.00745, "epss_percentile": 0.72519}, "CVE-2007-3946": {"epss_score": 0.04518, "epss_percentile": 0.88795}, "CVE-2007-3947": {"epss_score": 0.1596, "epss_percentile": 0.94543}, "CVE-2007-3948": {"epss_score": 0.01908, "epss_percentile": 0.82818}, "CVE-2007-3949": {"epss_score": 0.00584, "epss_percentile": 0.68378}, "CVE-2007-3950": {"epss_score": 0.01761, "epss_percentile": 0.8215}, "CVE-2007-3951": {"epss_score": 0.11541, "epss_percentile": 0.934}, "CVE-2007-3952": {"epss_score": 0.00631, "epss_percentile": 0.69728}, "CVE-2007-3953": {"epss_score": 0.01605, "epss_percentile": 0.81286}, "CVE-2007-3954": {"epss_score": 0.01223, "epss_percentile": 0.78671}, "CVE-2007-3955": {"epss_score": 0.27084, "epss_percentile": 0.96205}, "CVE-2007-3956": {"epss_score": 0.05234, "epss_percentile": 0.89644}, "CVE-2007-3957": {"epss_score": 0.06022, "epss_percentile": 0.90416}, "CVE-2007-3958": {"epss_score": 0.45764, "epss_percentile": 0.97501}, "CVE-2007-3959": {"epss_score": 0.00492, "epss_percentile": 0.65011}, "CVE-2007-3960": {"epss_score": 0.00743, "epss_percentile": 0.72475}, "CVE-2007-3961": {"epss_score": 0.01824, "epss_percentile": 0.82423}, "CVE-2007-3962": {"epss_score": 0.08926, "epss_percentile": 0.92323}, "CVE-2007-3963": {"epss_score": 0.01433, "epss_percentile": 0.80255}, "CVE-2007-3964": {"epss_score": 0.00385, "epss_percentile": 0.59183}, "CVE-2007-3965": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2007-3966": {"epss_score": 0.00257, "epss_percentile": 0.48892}, "CVE-2007-3967": {"epss_score": 0.00092, "epss_percentile": 0.26579}, "CVE-2007-3968": {"epss_score": 0.0039, "epss_percentile": 0.59546}, "CVE-2007-3969": {"epss_score": 0.07844, "epss_percentile": 0.91717}, "CVE-2007-3970": {"epss_score": 0.15974, "epss_percentile": 0.94545}, "CVE-2007-3971": {"epss_score": 0.02629, "epss_percentile": 0.85275}, "CVE-2007-3972": {"epss_score": 0.02573, "epss_percentile": 0.85135}, "CVE-2007-3973": {"epss_score": 0.20078, "epss_percentile": 0.95286}, "CVE-2007-3974": {"epss_score": 0.31943, "epss_percentile": 0.96661}, "CVE-2007-3975": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2007-3976": {"epss_score": 0.00521, "epss_percentile": 0.66233}, "CVE-2007-3977": {"epss_score": 0.00681, "epss_percentile": 0.71039}, "CVE-2007-3978": {"epss_score": 0.01856, "epss_percentile": 0.82573}, "CVE-2007-3979": {"epss_score": 0.00929, "epss_percentile": 0.7559}, "CVE-2007-3980": {"epss_score": 0.03644, "epss_percentile": 0.87496}, "CVE-2007-3981": {"epss_score": 0.00996, "epss_percentile": 0.76451}, "CVE-2007-3982": {"epss_score": 0.087, "epss_percentile": 0.92208}, "CVE-2007-3983": {"epss_score": 0.02661, "epss_percentile": 0.85369}, "CVE-2007-3984": {"epss_score": 0.22158, "epss_percentile": 0.95603}, "CVE-2007-3985": {"epss_score": 0.00714, "epss_percentile": 0.71814}, "CVE-2007-3986": {"epss_score": 0.008, "epss_percentile": 0.73548}, "CVE-2007-3987": {"epss_score": 0.00738, "epss_percentile": 0.72336}, "CVE-2007-3988": {"epss_score": 0.00882, "epss_percentile": 0.74894}, "CVE-2007-3989": {"epss_score": 0.00613, "epss_percentile": 0.69243}, "CVE-2007-3990": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-3991": {"epss_score": 0.03311, "epss_percentile": 0.86889}, "CVE-2007-3992": {"epss_score": 0.0034, "epss_percentile": 0.56284}, "CVE-2007-3993": {"epss_score": 0.00806, "epss_percentile": 0.73656}, "CVE-2007-3996": {"epss_score": 0.08358, "epss_percentile": 0.92008}, "CVE-2007-3997": {"epss_score": 0.27242, "epss_percentile": 0.96224}, "CVE-2007-3998": {"epss_score": 0.07212, "epss_percentile": 0.91329}, "CVE-2007-3999": {"epss_score": 0.4568, "epss_percentile": 0.97496}, "CVE-2007-4000": {"epss_score": 0.29582, "epss_percentile": 0.96459}, "CVE-2007-4003": {"epss_score": 0.00115, "epss_percentile": 0.31036}, "CVE-2007-4004": {"epss_score": 0.00446, "epss_percentile": 0.62904}, "CVE-2007-4005": {"epss_score": 0.11484, "epss_percentile": 0.93381}, "CVE-2007-4006": {"epss_score": 0.68379, "epss_percentile": 0.98544}, "CVE-2007-4007": {"epss_score": 0.0437, "epss_percentile": 0.88608}, "CVE-2007-4008": {"epss_score": 0.07765, "epss_percentile": 0.91667}, "CVE-2007-4009": {"epss_score": 0.11102, "epss_percentile": 0.93221}, "CVE-2007-4010": {"epss_score": 0.04032, "epss_percentile": 0.88152}, "CVE-2007-4011": {"epss_score": 0.01033, "epss_percentile": 0.76875}, "CVE-2007-4012": {"epss_score": 0.01033, "epss_percentile": 0.76875}, "CVE-2007-4013": {"epss_score": 0.0117, "epss_percentile": 0.7821}, "CVE-2007-4014": {"epss_score": 0.01164, "epss_percentile": 0.78167}, "CVE-2007-4016": {"epss_score": 0.00988, "epss_percentile": 0.76352}, "CVE-2007-4017": {"epss_score": 0.02743, "epss_percentile": 0.85565}, "CVE-2007-4018": {"epss_score": 0.00821, "epss_percentile": 0.73906}, "CVE-2007-4020": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4021": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-4022": {"epss_score": 0.05446, "epss_percentile": 0.89888}, "CVE-2007-4023": {"epss_score": 0.01198, "epss_percentile": 0.78449}, "CVE-2007-4024": {"epss_score": 0.00613, "epss_percentile": 0.69243}, "CVE-2007-4025": {"epss_score": 0.00783, "epss_percentile": 0.73213}, "CVE-2007-4026": {"epss_score": 0.00548, "epss_percentile": 0.67267}, "CVE-2007-4027": {"epss_score": 0.00047, "epss_percentile": 0.14888}, "CVE-2007-4028": {"epss_score": 0.00675, "epss_percentile": 0.7091}, "CVE-2007-4029": {"epss_score": 0.01563, "epss_percentile": 0.8105}, "CVE-2007-4031": {"epss_score": 0.07516, "epss_percentile": 0.91514}, "CVE-2007-4032": {"epss_score": 0.20425, "epss_percentile": 0.95344}, "CVE-2007-4033": {"epss_score": 0.27596, "epss_percentile": 0.96261}, "CVE-2007-4034": {"epss_score": 0.30432, "epss_percentile": 0.96538}, "CVE-2007-4035": {"epss_score": 0.00837, "epss_percentile": 0.74152}, "CVE-2007-4036": {"epss_score": 0.01019, "epss_percentile": 0.76723}, "CVE-2007-4037": {"epss_score": 0.00637, "epss_percentile": 0.69879}, "CVE-2007-4038": {"epss_score": 0.00266, "epss_percentile": 0.49899}, "CVE-2007-4039": {"epss_score": 0.00479, "epss_percentile": 0.64412}, "CVE-2007-4040": {"epss_score": 0.16604, "epss_percentile": 0.94701}, "CVE-2007-4041": {"epss_score": 0.10695, "epss_percentile": 0.93073}, "CVE-2007-4042": {"epss_score": 0.04362, "epss_percentile": 0.88598}, "CVE-2007-4043": {"epss_score": 0.00548, "epss_percentile": 0.67291}, "CVE-2007-4045": {"epss_score": 0.03009, "epss_percentile": 0.86194}, "CVE-2007-4046": {"epss_score": 0.00028, "epss_percentile": 0.07529}, "CVE-2007-4047": {"epss_score": 0.21435, "epss_percentile": 0.95517}, "CVE-2007-4048": {"epss_score": 0.00537, "epss_percentile": 0.66918}, "CVE-2007-4050": {"epss_score": 0.03338, "epss_percentile": 0.86938}, "CVE-2007-4051": {"epss_score": 0.00075, "epss_percentile": 0.22969}, "CVE-2007-4052": {"epss_score": 0.00613, "epss_percentile": 0.69243}, "CVE-2007-4053": {"epss_score": 0.01046, "epss_percentile": 0.77027}, "CVE-2007-4054": {"epss_score": 0.0053, "epss_percentile": 0.66623}, "CVE-2007-4055": {"epss_score": 0.0053, "epss_percentile": 0.66623}, "CVE-2007-4056": {"epss_score": 0.0055, "epss_percentile": 0.67341}, "CVE-2007-4057": {"epss_score": 0.04194, "epss_percentile": 0.88378}, "CVE-2007-4058": {"epss_score": 0.0796, "epss_percentile": 0.9179}, "CVE-2007-4059": {"epss_score": 0.11591, "epss_percentile": 0.93413}, "CVE-2007-4060": {"epss_score": 0.22951, "epss_percentile": 0.95709}, "CVE-2007-4061": {"epss_score": 0.10617, "epss_percentile": 0.9305}, "CVE-2007-4062": {"epss_score": 0.0354, "epss_percentile": 0.87317}, "CVE-2007-4063": {"epss_score": 0.00422, "epss_percentile": 0.61535}, "CVE-2007-4064": {"epss_score": 0.00388, "epss_percentile": 0.59393}, "CVE-2007-4065": {"epss_score": 0.05346, "epss_percentile": 0.8977}, "CVE-2007-4066": {"epss_score": 0.01248, "epss_percentile": 0.78866}, "CVE-2007-4067": {"epss_score": 0.06667, "epss_percentile": 0.90929}, "CVE-2007-4068": {"epss_score": 0.00734, "epss_percentile": 0.72247}, "CVE-2007-4069": {"epss_score": 0.01282, "epss_percentile": 0.79153}, "CVE-2007-4070": {"epss_score": 0.00071, "epss_percentile": 0.22124}, "CVE-2007-4071": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4072": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2007-4073": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-4074": {"epss_score": 0.01726, "epss_percentile": 0.81966}, "CVE-2007-4075": {"epss_score": 0.00779, "epss_percentile": 0.73144}, "CVE-2007-4076": {"epss_score": 0.00477, "epss_percentile": 0.64349}, "CVE-2007-4077": {"epss_score": 0.00754, "epss_percentile": 0.72692}, "CVE-2007-4078": {"epss_score": 0.00442, "epss_percentile": 0.62753}, "CVE-2007-4079": {"epss_score": 0.01643, "epss_percentile": 0.81514}, "CVE-2007-4080": {"epss_score": 0.00485, "epss_percentile": 0.64713}, "CVE-2007-4081": {"epss_score": 0.01643, "epss_percentile": 0.81514}, "CVE-2007-4082": {"epss_score": 0.00244, "epss_percentile": 0.47623}, "CVE-2007-4083": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2007-4084": {"epss_score": 0.00342, "epss_percentile": 0.56354}, "CVE-2007-4085": {"epss_score": 0.00314, "epss_percentile": 0.54115}, "CVE-2007-4086": {"epss_score": 0.00836, "epss_percentile": 0.74136}, "CVE-2007-4087": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2007-4088": {"epss_score": 0.02896, "epss_percentile": 0.85926}, "CVE-2007-4089": {"epss_score": 0.11422, "epss_percentile": 0.93344}, "CVE-2007-4090": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-4091": {"epss_score": 0.08296, "epss_percentile": 0.91976}, "CVE-2007-4092": {"epss_score": 0.03936, "epss_percentile": 0.87984}, "CVE-2007-4093": {"epss_score": 0.00316, "epss_percentile": 0.54241}, "CVE-2007-4094": {"epss_score": 0.00797, "epss_percentile": 0.73493}, "CVE-2007-4095": {"epss_score": 0.00378, "epss_percentile": 0.58776}, "CVE-2007-4096": {"epss_score": 0.00894, "epss_percentile": 0.75091}, "CVE-2007-4097": {"epss_score": 0.00877, "epss_percentile": 0.74798}, "CVE-2007-4098": {"epss_score": 0.0082, "epss_percentile": 0.73885}, "CVE-2007-4099": {"epss_score": 0.0082, "epss_percentile": 0.73885}, "CVE-2007-4100": {"epss_score": 0.00581, "epss_percentile": 0.68275}, "CVE-2007-4101": {"epss_score": 0.05924, "epss_percentile": 0.90325}, "CVE-2007-4102": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-4103": {"epss_score": 0.02694, "epss_percentile": 0.85441}, "CVE-2007-4104": {"epss_score": 0.07046, "epss_percentile": 0.91209}, "CVE-2007-4105": {"epss_score": 0.05454, "epss_percentile": 0.89895}, "CVE-2007-4106": {"epss_score": 0.00689, "epss_percentile": 0.71229}, "CVE-2007-4107": {"epss_score": 0.00851, "epss_percentile": 0.74408}, "CVE-2007-4108": {"epss_score": 0.00695, "epss_percentile": 0.71375}, "CVE-2007-4109": {"epss_score": 0.01126, "epss_percentile": 0.77817}, "CVE-2007-4110": {"epss_score": 0.00964, "epss_percentile": 0.76028}, "CVE-2007-4111": {"epss_score": 0.01263, "epss_percentile": 0.78985}, "CVE-2007-4112": {"epss_score": 0.00326, "epss_percentile": 0.55083}, "CVE-2007-4113": {"epss_score": 0.00207, "epss_percentile": 0.43119}, "CVE-2007-4114": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-4115": {"epss_score": 0.0259, "epss_percentile": 0.85179}, "CVE-2007-4116": {"epss_score": 0.00687, "epss_percentile": 0.71184}, "CVE-2007-4117": {"epss_score": 0.00676, "epss_percentile": 0.70927}, "CVE-2007-4118": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2007-4119": {"epss_score": 0.00964, "epss_percentile": 0.76028}, "CVE-2007-4120": {"epss_score": 0.00897, "epss_percentile": 0.75131}, "CVE-2007-4121": {"epss_score": 0.0116, "epss_percentile": 0.78135}, "CVE-2007-4122": {"epss_score": 0.00892, "epss_percentile": 0.75065}, "CVE-2007-4123": {"epss_score": 0.00328, "epss_percentile": 0.55275}, "CVE-2007-4124": {"epss_score": 0.00388, "epss_percentile": 0.59396}, "CVE-2007-4125": {"epss_score": 0.00667, "epss_percentile": 0.707}, "CVE-2007-4126": {"epss_score": 0.00058, "epss_percentile": 0.18413}, "CVE-2007-4127": {"epss_score": 0.09477, "epss_percentile": 0.92565}, "CVE-2007-4128": {"epss_score": 0.00964, "epss_percentile": 0.76028}, "CVE-2007-4129": {"epss_score": 0.00036, "epss_percentile": 0.10328}, "CVE-2007-4130": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2007-4131": {"epss_score": 0.11051, "epss_percentile": 0.93202}, "CVE-2007-4132": {"epss_score": 0.02167, "epss_percentile": 0.83855}, "CVE-2007-4133": {"epss_score": 0.00096, "epss_percentile": 0.27417}, "CVE-2007-4134": {"epss_score": 0.02032, "epss_percentile": 0.83337}, "CVE-2007-4135": {"epss_score": 0.00077, "epss_percentile": 0.23358}, "CVE-2007-4136": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2007-4137": {"epss_score": 0.0355, "epss_percentile": 0.87338}, "CVE-2007-4138": {"epss_score": 0.00123, "epss_percentile": 0.32243}, "CVE-2007-4139": {"epss_score": 0.00697, "epss_percentile": 0.7141}, "CVE-2007-4140": {"epss_score": 0.19653, "epss_percentile": 0.95221}, "CVE-2007-4141": {"epss_score": 0.003, "epss_percentile": 0.52919}, "CVE-2007-4142": {"epss_score": 0.00456, "epss_percentile": 0.63348}, "CVE-2007-4143": {"epss_score": 0.02776, "epss_percentile": 0.85638}, "CVE-2007-4144": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-4145": {"epss_score": 0.10064, "epss_percentile": 0.92838}, "CVE-2007-4146": {"epss_score": 0.02709, "epss_percentile": 0.8548}, "CVE-2007-4147": {"epss_score": 0.00365, "epss_percentile": 0.57981}, "CVE-2007-4148": {"epss_score": 0.03261, "epss_percentile": 0.86772}, "CVE-2007-4149": {"epss_score": 0.05868, "epss_percentile": 0.90277}, "CVE-2007-4150": {"epss_score": 0.01078, "epss_percentile": 0.77351}, "CVE-2007-4151": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2007-4152": {"epss_score": 0.00674, "epss_percentile": 0.70873}, "CVE-2007-4153": {"epss_score": 0.00507, "epss_percentile": 0.65674}, "CVE-2007-4154": {"epss_score": 0.0073, "epss_percentile": 0.72144}, "CVE-2007-4155": {"epss_score": 0.30089, "epss_percentile": 0.96507}, "CVE-2007-4156": {"epss_score": 0.01165, "epss_percentile": 0.78173}, "CVE-2007-4157": {"epss_score": 0.00648, "epss_percentile": 0.70219}, "CVE-2007-4158": {"epss_score": 0.02615, "epss_percentile": 0.85244}, "CVE-2007-4159": {"epss_score": 0.00381, "epss_percentile": 0.59027}, "CVE-2007-4160": {"epss_score": 0.00381, "epss_percentile": 0.59027}, "CVE-2007-4161": {"epss_score": 0.00968, "epss_percentile": 0.76081}, "CVE-2007-4162": {"epss_score": 0.00391, "epss_percentile": 0.59579}, "CVE-2007-4163": {"epss_score": 0.0034, "epss_percentile": 0.56284}, "CVE-2007-4164": {"epss_score": 0.01548, "epss_percentile": 0.80976}, "CVE-2007-4165": {"epss_score": 0.01588, "epss_percentile": 0.81189}, "CVE-2007-4166": {"epss_score": 0.00639, "epss_percentile": 0.69947}, "CVE-2007-4167": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2007-4169": {"epss_score": 0.00784, "epss_percentile": 0.73234}, "CVE-2007-4170": {"epss_score": 0.00787, "epss_percentile": 0.7331}, "CVE-2007-4171": {"epss_score": 0.00733, "epss_percentile": 0.72212}, "CVE-2007-4172": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-4173": {"epss_score": 0.00679, "epss_percentile": 0.71017}, "CVE-2007-4174": {"epss_score": 0.17426, "epss_percentile": 0.9485}, "CVE-2007-4175": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2007-4176": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2007-4177": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4178": {"epss_score": 0.02192, "epss_percentile": 0.83941}, "CVE-2007-4179": {"epss_score": 0.00053, "epss_percentile": 0.16909}, "CVE-2007-4180": {"epss_score": 0.00271, "epss_percentile": 0.50306}, "CVE-2007-4181": {"epss_score": 0.00759, "epss_percentile": 0.72784}, "CVE-2007-4182": {"epss_score": 0.00539, "epss_percentile": 0.66985}, "CVE-2007-4183": {"epss_score": 0.00521, "epss_percentile": 0.66233}, "CVE-2007-4184": {"epss_score": 0.00018, "epss_percentile": 0.03654}, "CVE-2007-4185": {"epss_score": 0.00483, "epss_percentile": 0.64575}, "CVE-2007-4186": {"epss_score": 0.00582, "epss_percentile": 0.68299}, "CVE-2007-4187": {"epss_score": 0.08644, "epss_percentile": 0.9217}, "CVE-2007-4188": {"epss_score": 0.00077, "epss_percentile": 0.23346}, "CVE-2007-4189": {"epss_score": 0.00014, "epss_percentile": 0.01774}, "CVE-2007-4190": {"epss_score": 9e-05, "epss_percentile": 0.00664}, "CVE-2007-4191": {"epss_score": 0.0009, "epss_percentile": 0.26023}, "CVE-2007-4192": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4193": {"epss_score": 0.00381, "epss_percentile": 0.59027}, "CVE-2007-4194": {"epss_score": 0.00647, "epss_percentile": 0.70206}, "CVE-2007-4195": {"epss_score": 0.01124, "epss_percentile": 0.77797}, "CVE-2007-4196": {"epss_score": 0.00674, "epss_percentile": 0.7088}, "CVE-2007-4197": {"epss_score": 0.0082, "epss_percentile": 0.73885}, "CVE-2007-4198": {"epss_score": 0.00968, "epss_percentile": 0.76081}, "CVE-2007-4199": {"epss_score": 0.00968, "epss_percentile": 0.76081}, "CVE-2007-4200": {"epss_score": 0.00968, "epss_percentile": 0.76081}, "CVE-2007-4201": {"epss_score": 0.0094, "epss_percentile": 0.7573}, "CVE-2007-4202": {"epss_score": 0.00679, "epss_percentile": 0.71009}, "CVE-2007-4203": {"epss_score": 0.00588, "epss_percentile": 0.68501}, "CVE-2007-4204": {"epss_score": 0.00207, "epss_percentile": 0.43119}, "CVE-2007-4205": {"epss_score": 0.0139, "epss_percentile": 0.79937}, "CVE-2007-4206": {"epss_score": 0.00055, "epss_percentile": 0.17618}, "CVE-2007-4207": {"epss_score": 0.00967, "epss_percentile": 0.76072}, "CVE-2007-4208": {"epss_score": 0.01537, "epss_percentile": 0.80923}, "CVE-2007-4209": {"epss_score": 0.00384, "epss_percentile": 0.59178}, "CVE-2007-4210": {"epss_score": 0.02815, "epss_percentile": 0.8573}, "CVE-2007-4211": {"epss_score": 0.01376, "epss_percentile": 0.79837}, "CVE-2007-4212": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-4213": {"epss_score": 0.01832, "epss_percentile": 0.82452}, "CVE-2007-4216": {"epss_score": 0.00058, "epss_percentile": 0.18579}, "CVE-2007-4217": {"epss_score": 0.00066, "epss_percentile": 0.20801}, "CVE-2007-4218": {"epss_score": 0.58475, "epss_percentile": 0.98119}, "CVE-2007-4219": {"epss_score": 0.39624, "epss_percentile": 0.97172}, "CVE-2007-4220": {"epss_score": 0.03713, "epss_percentile": 0.8761}, "CVE-2007-4221": {"epss_score": 0.1676, "epss_percentile": 0.94729}, "CVE-2007-4222": {"epss_score": 0.18783, "epss_percentile": 0.95068}, "CVE-2007-4223": {"epss_score": 0.09407, "epss_percentile": 0.92534}, "CVE-2007-4224": {"epss_score": 0.00854, "epss_percentile": 0.74455}, "CVE-2007-4225": {"epss_score": 0.01925, "epss_percentile": 0.82919}, "CVE-2007-4226": {"epss_score": 0.02732, "epss_percentile": 0.85543}, "CVE-2007-4227": {"epss_score": 0.13284, "epss_percentile": 0.93922}, "CVE-2007-4228": {"epss_score": 0.00055, "epss_percentile": 0.17435}, "CVE-2007-4229": {"epss_score": 0.02615, "epss_percentile": 0.85245}, "CVE-2007-4230": {"epss_score": 0.01117, "epss_percentile": 0.7774}, "CVE-2007-4231": {"epss_score": 0.06669, "epss_percentile": 0.90932}, "CVE-2007-4232": {"epss_score": 0.76501, "epss_percentile": 0.98893}, "CVE-2007-4233": {"epss_score": 0.00376, "epss_percentile": 0.58662}, "CVE-2007-4234": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2007-4235": {"epss_score": 0.01713, "epss_percentile": 0.81887}, "CVE-2007-4236": {"epss_score": 0.00053, "epss_percentile": 0.16862}, "CVE-2007-4237": {"epss_score": 0.0006, "epss_percentile": 0.19203}, "CVE-2007-4238": {"epss_score": 0.00057, "epss_percentile": 0.18099}, "CVE-2007-4239": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2007-4240": {"epss_score": 0.00539, "epss_percentile": 0.66985}, "CVE-2007-4241": {"epss_score": 0.14614, "epss_percentile": 0.94252}, "CVE-2007-4242": {"epss_score": 0.00488, "epss_percentile": 0.64847}, "CVE-2007-4243": {"epss_score": 0.06015, "epss_percentile": 0.90412}, "CVE-2007-4244": {"epss_score": 0.68641, "epss_percentile": 0.98558}, "CVE-2007-4245": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4246": {"epss_score": 0.07538, "epss_percentile": 0.91525}, "CVE-2007-4247": {"epss_score": 0.28809, "epss_percentile": 0.96389}, "CVE-2007-4248": {"epss_score": 0.0052, "epss_percentile": 0.66194}, "CVE-2007-4249": {"epss_score": 0.0052, "epss_percentile": 0.66194}, "CVE-2007-4250": {"epss_score": 0.00664, "epss_percentile": 0.70643}, "CVE-2007-4251": {"epss_score": 0.00781, "epss_percentile": 0.73177}, "CVE-2007-4252": {"epss_score": 0.04882, "epss_percentile": 0.8925}, "CVE-2007-4253": {"epss_score": 0.00521, "epss_percentile": 0.66233}, "CVE-2007-4254": {"epss_score": 0.32056, "epss_percentile": 0.96669}, "CVE-2007-4255": {"epss_score": 0.09303, "epss_percentile": 0.92491}, "CVE-2007-4256": {"epss_score": 0.02949, "epss_percentile": 0.8605}, "CVE-2007-4257": {"epss_score": 0.29833, "epss_percentile": 0.96479}, "CVE-2007-4258": {"epss_score": 0.00404, "epss_percentile": 0.60444}, "CVE-2007-4259": {"epss_score": 0.00583, "epss_percentile": 0.68342}, "CVE-2007-4260": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2007-4261": {"epss_score": 0.01793, "epss_percentile": 0.8229}, "CVE-2007-4262": {"epss_score": 0.01455, "epss_percentile": 0.8039}, "CVE-2007-4263": {"epss_score": 0.02219, "epss_percentile": 0.84045}, "CVE-2007-4264": {"epss_score": 0.00376, "epss_percentile": 0.58676}, "CVE-2007-4265": {"epss_score": 0.00625, "epss_percentile": 0.69577}, "CVE-2007-4267": {"epss_score": 0.00114, "epss_percentile": 0.30768}, "CVE-2007-4268": {"epss_score": 0.00748, "epss_percentile": 0.7258}, "CVE-2007-4269": {"epss_score": 0.00114, "epss_percentile": 0.30768}, "CVE-2007-4270": {"epss_score": 0.00047, "epss_percentile": 0.14643}, "CVE-2007-4271": {"epss_score": 0.00052, "epss_percentile": 0.16614}, "CVE-2007-4272": {"epss_score": 0.0007, "epss_percentile": 0.21671}, "CVE-2007-4273": {"epss_score": 0.00084, "epss_percentile": 0.25021}, "CVE-2007-4275": {"epss_score": 0.00055, "epss_percentile": 0.17543}, "CVE-2007-4276": {"epss_score": 0.00092, "epss_percentile": 0.26518}, "CVE-2007-4277": {"epss_score": 0.00067, "epss_percentile": 0.21055}, "CVE-2007-4278": {"epss_score": 0.04692, "epss_percentile": 0.89013}, "CVE-2007-4279": {"epss_score": 0.85424, "epss_percentile": 0.99333}, "CVE-2007-4280": {"epss_score": 0.02784, "epss_percentile": 0.85656}, "CVE-2007-4281": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4282": {"epss_score": 0.00428, "epss_percentile": 0.61958}, "CVE-2007-4283": {"epss_score": 0.05837, "epss_percentile": 0.90249}, "CVE-2007-4284": {"epss_score": 0.00792, "epss_percentile": 0.73408}, "CVE-2007-4285": {"epss_score": 0.01129, "epss_percentile": 0.77838}, "CVE-2007-4286": {"epss_score": 0.6264, "epss_percentile": 0.983}, "CVE-2007-4287": {"epss_score": 0.03191, "epss_percentile": 0.866}, "CVE-2007-4288": {"epss_score": 0.5094, "epss_percentile": 0.97756}, "CVE-2007-4289": {"epss_score": 0.00799, "epss_percentile": 0.73523}, "CVE-2007-4290": {"epss_score": 0.00768, "epss_percentile": 0.72967}, "CVE-2007-4291": {"epss_score": 0.04369, "epss_percentile": 0.88607}, "CVE-2007-4292": {"epss_score": 0.07928, "epss_percentile": 0.91767}, "CVE-2007-4293": {"epss_score": 0.01832, "epss_percentile": 0.82452}, "CVE-2007-4294": {"epss_score": 0.02626, "epss_percentile": 0.85266}, "CVE-2007-4295": {"epss_score": 0.02626, "epss_percentile": 0.85266}, "CVE-2007-4296": {"epss_score": 0.00713, "epss_percentile": 0.71803}, "CVE-2007-4297": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4301": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4302": {"epss_score": 0.00119, "epss_percentile": 0.31537}, "CVE-2007-4303": {"epss_score": 0.0005, "epss_percentile": 0.15761}, "CVE-2007-4304": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2007-4305": {"epss_score": 0.00119, "epss_percentile": 0.31537}, "CVE-2007-4306": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2007-4307": {"epss_score": 0.012, "epss_percentile": 0.78469}, "CVE-2007-4308": {"epss_score": 0.00079, "epss_percentile": 0.23912}, "CVE-2007-4309": {"epss_score": 0.00195, "epss_percentile": 0.41688}, "CVE-2007-4310": {"epss_score": 0.00309, "epss_percentile": 0.53666}, "CVE-2007-4311": {"epss_score": 0.00647, "epss_percentile": 0.7019}, "CVE-2007-4312": {"epss_score": 0.00521, "epss_percentile": 0.66233}, "CVE-2007-4313": {"epss_score": 0.84733, "epss_percentile": 0.99303}, "CVE-2007-4314": {"epss_score": 0.04764, "epss_percentile": 0.8912}, "CVE-2007-4315": {"epss_score": 0.00047, "epss_percentile": 0.14694}, "CVE-2007-4316": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2007-4317": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2007-4318": {"epss_score": 0.05052, "epss_percentile": 0.89441}, "CVE-2007-4319": {"epss_score": 0.01002, "epss_percentile": 0.7651}, "CVE-2007-4320": {"epss_score": 0.83926, "epss_percentile": 0.99265}, "CVE-2007-4321": {"epss_score": 0.117, "epss_percentile": 0.93455}, "CVE-2007-4322": {"epss_score": 0.0053, "epss_percentile": 0.66633}, "CVE-2007-4323": {"epss_score": 0.01358, "epss_percentile": 0.7973}, "CVE-2007-4324": {"epss_score": 0.22239, "epss_percentile": 0.95613}, "CVE-2007-4325": {"epss_score": 0.05101, "epss_percentile": 0.89498}, "CVE-2007-4326": {"epss_score": 0.01648, "epss_percentile": 0.81555}, "CVE-2007-4327": {"epss_score": 0.10206, "epss_percentile": 0.92893}, "CVE-2007-4328": {"epss_score": 0.11019, "epss_percentile": 0.93191}, "CVE-2007-4329": {"epss_score": 0.19074, "epss_percentile": 0.95124}, "CVE-2007-4330": {"epss_score": 0.06051, "epss_percentile": 0.90435}, "CVE-2007-4331": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2007-4332": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-4333": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-4334": {"epss_score": 0.03077, "epss_percentile": 0.86364}, "CVE-2007-4335": {"epss_score": 0.02256, "epss_percentile": 0.84169}, "CVE-2007-4336": {"epss_score": 0.76333, "epss_percentile": 0.98886}, "CVE-2007-4337": {"epss_score": 0.03257, "epss_percentile": 0.86764}, "CVE-2007-4338": {"epss_score": 0.28117, "epss_percentile": 0.96312}, "CVE-2007-4339": {"epss_score": 0.01173, "epss_percentile": 0.78237}, "CVE-2007-4340": {"epss_score": 0.00567, "epss_percentile": 0.67849}, "CVE-2007-4341": {"epss_score": 0.0216, "epss_percentile": 0.83822}, "CVE-2007-4342": {"epss_score": 0.01173, "epss_percentile": 0.78237}, "CVE-2007-4343": {"epss_score": 0.04965, "epss_percentile": 0.89341}, "CVE-2007-4344": {"epss_score": 0.10347, "epss_percentile": 0.92951}, "CVE-2007-4345": {"epss_score": 0.00222, "epss_percentile": 0.44843}, "CVE-2007-4346": {"epss_score": 0.03731, "epss_percentile": 0.87643}, "CVE-2007-4347": {"epss_score": 0.01349, "epss_percentile": 0.79671}, "CVE-2007-4348": {"epss_score": 0.00463, "epss_percentile": 0.63697}, "CVE-2007-4349": {"epss_score": 0.00975, "epss_percentile": 0.76201}, "CVE-2007-4350": {"epss_score": 0.00795, "epss_percentile": 0.7346}, "CVE-2007-4351": {"epss_score": 0.23653, "epss_percentile": 0.95798}, "CVE-2007-4352": {"epss_score": 0.25469, "epss_percentile": 0.96031}, "CVE-2007-4353": {"epss_score": 0.00058, "epss_percentile": 0.18416}, "CVE-2007-4354": {"epss_score": 0.00049, "epss_percentile": 0.15304}, "CVE-2007-4355": {"epss_score": 0.0006, "epss_percentile": 0.19203}, "CVE-2007-4356": {"epss_score": 0.28282, "epss_percentile": 0.96339}, "CVE-2007-4357": {"epss_score": 0.00597, "epss_percentile": 0.68742}, "CVE-2007-4358": {"epss_score": 0.07059, "epss_percentile": 0.91218}, "CVE-2007-4359": {"epss_score": 0.00469, "epss_percentile": 0.63933}, "CVE-2007-4360": {"epss_score": 0.00784, "epss_percentile": 0.73241}, "CVE-2007-4361": {"epss_score": 0.03888, "epss_percentile": 0.87908}, "CVE-2007-4362": {"epss_score": 0.01085, "epss_percentile": 0.77407}, "CVE-2007-4363": {"epss_score": 0.012, "epss_percentile": 0.78469}, "CVE-2007-4364": {"epss_score": 0.00549, "epss_percentile": 0.6731}, "CVE-2007-4365": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-4366": {"epss_score": 0.05903, "epss_percentile": 0.90311}, "CVE-2007-4367": {"epss_score": 0.08725, "epss_percentile": 0.92229}, "CVE-2007-4368": {"epss_score": 0.04571, "epss_percentile": 0.88863}, "CVE-2007-4369": {"epss_score": 0.08951, "epss_percentile": 0.92335}, "CVE-2007-4370": {"epss_score": 0.77767, "epss_percentile": 0.98952}, "CVE-2007-4371": {"epss_score": 0.00548, "epss_percentile": 0.67267}, "CVE-2007-4372": {"epss_score": 0.00341, "epss_percentile": 0.56305}, "CVE-2007-4373": {"epss_score": 0.00257, "epss_percentile": 0.48869}, "CVE-2007-4374": {"epss_score": 0.00211, "epss_percentile": 0.43668}, "CVE-2007-4375": {"epss_score": 0.1304, "epss_percentile": 0.93853}, "CVE-2007-4376": {"epss_score": 0.00674, "epss_percentile": 0.7088}, "CVE-2007-4377": {"epss_score": 0.21437, "epss_percentile": 0.95518}, "CVE-2007-4378": {"epss_score": 0.03355, "epss_percentile": 0.86971}, "CVE-2007-4379": {"epss_score": 0.01023, "epss_percentile": 0.76774}, "CVE-2007-4380": {"epss_score": 0.00058, "epss_percentile": 0.1856}, "CVE-2007-4381": {"epss_score": 0.1643, "epss_percentile": 0.94659}, "CVE-2007-4382": {"epss_score": 0.05722, "epss_percentile": 0.90153}, "CVE-2007-4383": {"epss_score": 0.00733, "epss_percentile": 0.72217}, "CVE-2007-4384": {"epss_score": 0.01504, "epss_percentile": 0.80736}, "CVE-2007-4385": {"epss_score": 0.14706, "epss_percentile": 0.94268}, "CVE-2007-4386": {"epss_score": 0.00542, "epss_percentile": 0.6708}, "CVE-2007-4387": {"epss_score": 0.5874, "epss_percentile": 0.98134}, "CVE-2007-4388": {"epss_score": 0.00334, "epss_percentile": 0.55717}, "CVE-2007-4389": {"epss_score": 0.04801, "epss_percentile": 0.89157}, "CVE-2007-4390": {"epss_score": 0.00978, "epss_percentile": 0.76252}, "CVE-2007-4391": {"epss_score": 0.17551, "epss_percentile": 0.94866}, "CVE-2007-4392": {"epss_score": 0.01055, "epss_percentile": 0.77119}, "CVE-2007-4393": {"epss_score": 0.00071, "epss_percentile": 0.22141}, "CVE-2007-4394": {"epss_score": 0.00038, "epss_percentile": 0.11426}, "CVE-2007-4395": {"epss_score": 0.03226, "epss_percentile": 0.86687}, "CVE-2007-4396": {"epss_score": 0.01647, "epss_percentile": 0.8154}, "CVE-2007-4397": {"epss_score": 0.04094, "epss_percentile": 0.88244}, "CVE-2007-4398": {"epss_score": 0.01653, "epss_percentile": 0.81579}, "CVE-2007-4399": {"epss_score": 0.01098, "epss_percentile": 0.77544}, "CVE-2007-4400": {"epss_score": 0.01708, "epss_percentile": 0.81868}, "CVE-2007-4401": {"epss_score": 0.01206, "epss_percentile": 0.78522}, "CVE-2007-4402": {"epss_score": 0.03038, "epss_percentile": 0.86268}, "CVE-2007-4403": {"epss_score": 0.01917, "epss_percentile": 0.82872}, "CVE-2007-4404": {"epss_score": 0.02893, "epss_percentile": 0.85921}, "CVE-2007-4405": {"epss_score": 0.00725, "epss_percentile": 0.72051}, "CVE-2007-4406": {"epss_score": 0.00595, "epss_percentile": 0.68692}, "CVE-2007-4407": {"epss_score": 0.00733, "epss_percentile": 0.72208}, "CVE-2007-4408": {"epss_score": 0.00381, "epss_percentile": 0.59027}, "CVE-2007-4409": {"epss_score": 0.00733, "epss_percentile": 0.72208}, "CVE-2007-4410": {"epss_score": 0.00584, "epss_percentile": 0.68372}, "CVE-2007-4411": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2007-4412": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2007-4413": {"epss_score": 0.00211, "epss_percentile": 0.43668}, "CVE-2007-4414": {"epss_score": 0.00062, "epss_percentile": 0.1969}, "CVE-2007-4415": {"epss_score": 0.00047, "epss_percentile": 0.14665}, "CVE-2007-4416": {"epss_score": 0.0176, "epss_percentile": 0.82148}, "CVE-2007-4417": {"epss_score": 0.01147, "epss_percentile": 0.78009}, "CVE-2007-4418": {"epss_score": 0.00788, "epss_percentile": 0.73335}, "CVE-2007-4419": {"epss_score": 0.09079, "epss_percentile": 0.92391}, "CVE-2007-4420": {"epss_score": 0.03839, "epss_percentile": 0.87829}, "CVE-2007-4421": {"epss_score": 0.03097, "epss_percentile": 0.86405}, "CVE-2007-4422": {"epss_score": 0.02237, "epss_percentile": 0.84102}, "CVE-2007-4423": {"epss_score": 0.01015, "epss_percentile": 0.76656}, "CVE-2007-4424": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-4425": {"epss_score": 0.04157, "epss_percentile": 0.88331}, "CVE-2007-4426": {"epss_score": 0.01443, "epss_percentile": 0.80313}, "CVE-2007-4427": {"epss_score": 0.00218, "epss_percentile": 0.44394}, "CVE-2007-4428": {"epss_score": 0.04976, "epss_percentile": 0.89355}, "CVE-2007-4429": {"epss_score": 0.0227, "epss_percentile": 0.84207}, "CVE-2007-4430": {"epss_score": 0.26234, "epss_percentile": 0.96126}, "CVE-2007-4431": {"epss_score": 0.00365, "epss_percentile": 0.57982}, "CVE-2007-4432": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2007-4433": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-4434": {"epss_score": 0.03764, "epss_percentile": 0.87693}, "CVE-2007-4435": {"epss_score": 0.01353, "epss_percentile": 0.79693}, "CVE-2007-4436": {"epss_score": 0.00288, "epss_percentile": 0.51945}, "CVE-2007-4437": {"epss_score": 0.00836, "epss_percentile": 0.74136}, "CVE-2007-4438": {"epss_score": 0.00882, "epss_percentile": 0.74894}, "CVE-2007-4439": {"epss_score": 0.03693, "epss_percentile": 0.8758}, "CVE-2007-4440": {"epss_score": 0.81335, "epss_percentile": 0.99133}, "CVE-2007-4441": {"epss_score": 0.00434, "epss_percentile": 0.62295}, "CVE-2007-4442": {"epss_score": 0.09772, "epss_percentile": 0.92696}, "CVE-2007-4443": {"epss_score": 0.01243, "epss_percentile": 0.7883}, "CVE-2007-4444": {"epss_score": 0.24067, "epss_percentile": 0.95852}, "CVE-2007-4445": {"epss_score": 0.0227, "epss_percentile": 0.84207}, "CVE-2007-4446": {"epss_score": 0.07513, "epss_percentile": 0.91512}, "CVE-2007-4447": {"epss_score": 0.04292, "epss_percentile": 0.88503}, "CVE-2007-4448": {"epss_score": 0.01273, "epss_percentile": 0.79086}, "CVE-2007-4449": {"epss_score": 0.00758, "epss_percentile": 0.72768}, "CVE-2007-4450": {"epss_score": 0.00758, "epss_percentile": 0.72768}, "CVE-2007-4451": {"epss_score": 0.00758, "epss_percentile": 0.72768}, "CVE-2007-4452": {"epss_score": 0.01273, "epss_percentile": 0.79086}, "CVE-2007-4453": {"epss_score": 0.004, "epss_percentile": 0.60184}, "CVE-2007-4454": {"epss_score": 0.00878, "epss_percentile": 0.74826}, "CVE-2007-4455": {"epss_score": 0.05038, "epss_percentile": 0.89423}, "CVE-2007-4456": {"epss_score": 0.00726, "epss_percentile": 0.72073}, "CVE-2007-4457": {"epss_score": 0.01995, "epss_percentile": 0.83192}, "CVE-2007-4458": {"epss_score": 0.01407, "epss_percentile": 0.80057}, "CVE-2007-4459": {"epss_score": 0.75637, "epss_percentile": 0.98859}, "CVE-2007-4460": {"epss_score": 0.00046, "epss_percentile": 0.14292}, "CVE-2007-4461": {"epss_score": 0.0028, "epss_percentile": 0.51074}, "CVE-2007-4462": {"epss_score": 0.00071, "epss_percentile": 0.22039}, "CVE-2007-4463": {"epss_score": 0.07939, "epss_percentile": 0.91777}, "CVE-2007-4464": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2007-4465": {"epss_score": 0.05462, "epss_percentile": 0.89901}, "CVE-2007-4466": {"epss_score": 0.74506, "epss_percentile": 0.98805}, "CVE-2007-4467": {"epss_score": 0.33324, "epss_percentile": 0.96763}, "CVE-2007-4470": {"epss_score": 0.13574, "epss_percentile": 0.94}, "CVE-2007-4471": {"epss_score": 0.01653, "epss_percentile": 0.81578}, "CVE-2007-4472": {"epss_score": 0.10921, "epss_percentile": 0.93159}, "CVE-2007-4473": {"epss_score": 0.18274, "epss_percentile": 0.94987}, "CVE-2007-4474": {"epss_score": 0.87295, "epss_percentile": 0.99422}, "CVE-2007-4475": {"epss_score": 0.68002, "epss_percentile": 0.98528}, "CVE-2007-4476": {"epss_score": 0.11809, "epss_percentile": 0.93483}, "CVE-2007-4477": {"epss_score": 0.01176, "epss_percentile": 0.78269}, "CVE-2007-4478": {"epss_score": 0.19684, "epss_percentile": 0.95225}, "CVE-2007-4479": {"epss_score": 0.02885, "epss_percentile": 0.8591}, "CVE-2007-4480": {"epss_score": 0.0037, "epss_percentile": 0.58329}, "CVE-2007-4481": {"epss_score": 0.0024, "epss_percentile": 0.47226}, "CVE-2007-4482": {"epss_score": 0.00812, "epss_percentile": 0.73745}, "CVE-2007-4483": {"epss_score": 0.00459, "epss_percentile": 0.63479}, "CVE-2007-4484": {"epss_score": 0.0111, "epss_percentile": 0.77658}, "CVE-2007-4485": {"epss_score": 0.01039, "epss_percentile": 0.76942}, "CVE-2007-4486": {"epss_score": 0.05583, "epss_percentile": 0.90021}, "CVE-2007-4487": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-4488": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-4489": {"epss_score": 0.21348, "epss_percentile": 0.95504}, "CVE-2007-4490": {"epss_score": 0.00941, "epss_percentile": 0.75758}, "CVE-2007-4491": {"epss_score": 0.0038, "epss_percentile": 0.5895}, "CVE-2007-4492": {"epss_score": 0.00045, "epss_percentile": 0.13994}, "CVE-2007-4493": {"epss_score": 0.00554, "epss_percentile": 0.67453}, "CVE-2007-4494": {"epss_score": 0.0111, "epss_percentile": 0.77658}, "CVE-2007-4495": {"epss_score": 0.00051, "epss_percentile": 0.16305}, "CVE-2007-4496": {"epss_score": 0.00383, "epss_percentile": 0.59121}, "CVE-2007-4497": {"epss_score": 0.00363, "epss_percentile": 0.5783}, "CVE-2007-4498": {"epss_score": 0.14245, "epss_percentile": 0.9417}, "CVE-2007-4499": {"epss_score": 0.01467, "epss_percentile": 0.80468}, "CVE-2007-4500": {"epss_score": 0.00048, "epss_percentile": 0.15284}, "CVE-2007-4501": {"epss_score": 0.00057, "epss_percentile": 0.18102}, "CVE-2007-4502": {"epss_score": 0.00012, "epss_percentile": 0.01394}, "CVE-2007-4503": {"epss_score": 0.00706, "epss_percentile": 0.71618}, "CVE-2007-4504": {"epss_score": 0.00177, "epss_percentile": 0.39621}, "CVE-2007-4505": {"epss_score": 0.00603, "epss_percentile": 0.68934}, "CVE-2007-4506": {"epss_score": 0.00706, "epss_percentile": 0.71618}, "CVE-2007-4507": {"epss_score": 0.03111, "epss_percentile": 0.86425}, "CVE-2007-4508": {"epss_score": 0.21637, "epss_percentile": 0.95542}, "CVE-2007-4509": {"epss_score": 0.00012, "epss_percentile": 0.01394}, "CVE-2007-4510": {"epss_score": 0.0308, "epss_percentile": 0.8637}, "CVE-2007-4511": {"epss_score": 0.00356, "epss_percentile": 0.57331}, "CVE-2007-4512": {"epss_score": 0.00687, "epss_percentile": 0.71182}, "CVE-2007-4513": {"epss_score": 0.00179, "epss_percentile": 0.3982}, "CVE-2007-4514": {"epss_score": 0.00856, "epss_percentile": 0.74476}, "CVE-2007-4515": {"epss_score": 0.70092, "epss_percentile": 0.98615}, "CVE-2007-4516": {"epss_score": 0.0098, "epss_percentile": 0.76268}, "CVE-2007-4517": {"epss_score": 0.48149, "epss_percentile": 0.97624}, "CVE-2007-4521": {"epss_score": 0.02417, "epss_percentile": 0.84692}, "CVE-2007-4522": {"epss_score": 0.00485, "epss_percentile": 0.64726}, "CVE-2007-4523": {"epss_score": 0.0052, "epss_percentile": 0.66204}, "CVE-2007-4524": {"epss_score": 0.08047, "epss_percentile": 0.91852}, "CVE-2007-4525": {"epss_score": 0.00762, "epss_percentile": 0.72837}, "CVE-2007-4526": {"epss_score": 0.0004, "epss_percentile": 0.1201}, "CVE-2007-4527": {"epss_score": 0.04841, "epss_percentile": 0.89202}, "CVE-2007-4528": {"epss_score": 0.03331, "epss_percentile": 0.86927}, "CVE-2007-4529": {"epss_score": 0.00954, "epss_percentile": 0.75894}, "CVE-2007-4530": {"epss_score": 0.00537, "epss_percentile": 0.66918}, "CVE-2007-4531": {"epss_score": 0.07939, "epss_percentile": 0.91777}, "CVE-2007-4532": {"epss_score": 0.00725, "epss_percentile": 0.72051}, "CVE-2007-4533": {"epss_score": 0.20063, "epss_percentile": 0.95283}, "CVE-2007-4534": {"epss_score": 0.1572, "epss_percentile": 0.94493}, "CVE-2007-4535": {"epss_score": 0.10085, "epss_percentile": 0.92844}, "CVE-2007-4536": {"epss_score": 0.00063, "epss_percentile": 0.1982}, "CVE-2007-4537": {"epss_score": 0.11529, "epss_percentile": 0.93393}, "CVE-2007-4538": {"epss_score": 0.00836, "epss_percentile": 0.7414}, "CVE-2007-4539": {"epss_score": 0.00583, "epss_percentile": 0.68352}, "CVE-2007-4540": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-4541": {"epss_score": 0.00492, "epss_percentile": 0.6501}, "CVE-2007-4542": {"epss_score": 0.0081, "epss_percentile": 0.73714}, "CVE-2007-4543": {"epss_score": 0.00771, "epss_percentile": 0.73007}, "CVE-2007-4544": {"epss_score": 0.0014, "epss_percentile": 0.34714}, "CVE-2007-4545": {"epss_score": 0.02081, "epss_percentile": 0.83534}, "CVE-2007-4546": {"epss_score": 0.00434, "epss_percentile": 0.62324}, "CVE-2007-4547": {"epss_score": 0.00422, "epss_percentile": 0.61539}, "CVE-2007-4548": {"epss_score": 0.01011, "epss_percentile": 0.76607}, "CVE-2007-4549": {"epss_score": 0.09598, "epss_percentile": 0.92615}, "CVE-2007-4550": {"epss_score": 0.04345, "epss_percentile": 0.88574}, "CVE-2007-4551": {"epss_score": 0.02237, "epss_percentile": 0.84103}, "CVE-2007-4552": {"epss_score": 0.00372, "epss_percentile": 0.5842}, "CVE-2007-4553": {"epss_score": 0.21362, "epss_percentile": 0.95507}, "CVE-2007-4554": {"epss_score": 0.00407, "epss_percentile": 0.60613}, "CVE-2007-4555": {"epss_score": 0.00051, "epss_percentile": 0.16131}, "CVE-2007-4556": {"epss_score": 0.02359, "epss_percentile": 0.84492}, "CVE-2007-4557": {"epss_score": 0.00105, "epss_percentile": 0.29249}, "CVE-2007-4559": {"epss_score": 0.88929, "epss_percentile": 0.99499}, "CVE-2007-4560": {"epss_score": 0.85127, "epss_percentile": 0.9932}, "CVE-2007-4561": {"epss_score": 0.16161, "epss_percentile": 0.94582}, "CVE-2007-4562": {"epss_score": 0.00968, "epss_percentile": 0.76081}, "CVE-2007-4563": {"epss_score": 0.00055, "epss_percentile": 0.17618}, "CVE-2007-4564": {"epss_score": 0.00055, "epss_percentile": 0.17618}, "CVE-2007-4565": {"epss_score": 0.02958, "epss_percentile": 0.86067}, "CVE-2007-4566": {"epss_score": 0.54449, "epss_percentile": 0.97926}, "CVE-2007-4567": {"epss_score": 0.05055, "epss_percentile": 0.89447}, "CVE-2007-4568": {"epss_score": 0.24415, "epss_percentile": 0.95918}, "CVE-2007-4569": {"epss_score": 0.00269, "epss_percentile": 0.50149}, "CVE-2007-4570": {"epss_score": 0.00072, "epss_percentile": 0.22259}, "CVE-2007-4571": {"epss_score": 0.00192, "epss_percentile": 0.41318}, "CVE-2007-4572": {"epss_score": 0.21484, "epss_percentile": 0.95525}, "CVE-2007-4573": {"epss_score": 0.00417, "epss_percentile": 0.61222}, "CVE-2007-4574": {"epss_score": 0.00112, "epss_percentile": 0.30428}, "CVE-2007-4575": {"epss_score": 0.06316, "epss_percentile": 0.90667}, "CVE-2007-4577": {"epss_score": 0.05359, "epss_percentile": 0.89781}, "CVE-2007-4578": {"epss_score": 0.09014, "epss_percentile": 0.92366}, "CVE-2007-4580": {"epss_score": 0.00183, "epss_percentile": 0.40291}, "CVE-2007-4581": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-4582": {"epss_score": 0.05726, "epss_percentile": 0.90156}, "CVE-2007-4583": {"epss_score": 0.12696, "epss_percentile": 0.93752}, "CVE-2007-4584": {"epss_score": 0.04802, "epss_percentile": 0.89158}, "CVE-2007-4585": {"epss_score": 0.07765, "epss_percentile": 0.91667}, "CVE-2007-4586": {"epss_score": 0.04865, "epss_percentile": 0.89226}, "CVE-2007-4587": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4588": {"epss_score": 0.00908, "epss_percentile": 0.75272}, "CVE-2007-4589": {"epss_score": 0.01008, "epss_percentile": 0.76567}, "CVE-2007-4590": {"epss_score": 0.00082, "epss_percentile": 0.2456}, "CVE-2007-4591": {"epss_score": 0.0004, "epss_percentile": 0.11986}, "CVE-2007-4592": {"epss_score": 0.16226, "epss_percentile": 0.94597}, "CVE-2007-4593": {"epss_score": 0.00034, "epss_percentile": 0.09791}, "CVE-2007-4594": {"epss_score": 0.00185, "epss_percentile": 0.40516}, "CVE-2007-4595": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4596": {"epss_score": 0.03195, "epss_percentile": 0.86609}, "CVE-2007-4597": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-4598": {"epss_score": 0.00071, "epss_percentile": 0.22024}, "CVE-2007-4599": {"epss_score": 0.13061, "epss_percentile": 0.93861}, "CVE-2007-4600": {"epss_score": 0.00071, "epss_percentile": 0.22024}, "CVE-2007-4601": {"epss_score": 0.00493, "epss_percentile": 0.65064}, "CVE-2007-4602": {"epss_score": 0.00541, "epss_percentile": 0.6703}, "CVE-2007-4603": {"epss_score": 0.01431, "epss_percentile": 0.80245}, "CVE-2007-4604": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-4605": {"epss_score": 0.04242, "epss_percentile": 0.88437}, "CVE-2007-4606": {"epss_score": 0.04242, "epss_percentile": 0.88437}, "CVE-2007-4607": {"epss_score": 0.79668, "epss_percentile": 0.99051}, "CVE-2007-4608": {"epss_score": 0.00619, "epss_percentile": 0.69401}, "CVE-2007-4609": {"epss_score": 0.00584, "epss_percentile": 0.68382}, "CVE-2007-4610": {"epss_score": 0.00674, "epss_percentile": 0.7088}, "CVE-2007-4611": {"epss_score": 0.00462, "epss_percentile": 0.63622}, "CVE-2007-4612": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2007-4613": {"epss_score": 0.00653, "epss_percentile": 0.70329}, "CVE-2007-4614": {"epss_score": 0.00365, "epss_percentile": 0.57981}, "CVE-2007-4615": {"epss_score": 0.00771, "epss_percentile": 0.73025}, "CVE-2007-4616": {"epss_score": 0.00917, "epss_percentile": 0.75429}, "CVE-2007-4617": {"epss_score": 0.01865, "epss_percentile": 0.82603}, "CVE-2007-4618": {"epss_score": 0.02336, "epss_percentile": 0.84416}, "CVE-2007-4619": {"epss_score": 0.07855, "epss_percentile": 0.91723}, "CVE-2007-4620": {"epss_score": 0.75811, "epss_percentile": 0.98864}, "CVE-2007-4621": {"epss_score": 0.0006, "epss_percentile": 0.19203}, "CVE-2007-4622": {"epss_score": 0.00055, "epss_percentile": 0.17426}, "CVE-2007-4623": {"epss_score": 0.0006, "epss_percentile": 0.19113}, "CVE-2007-4624": {"epss_score": 0.00629, "epss_percentile": 0.69677}, "CVE-2007-4625": {"epss_score": 0.00494, "epss_percentile": 0.65093}, "CVE-2007-4626": {"epss_score": 0.00518, "epss_percentile": 0.66094}, "CVE-2007-4627": {"epss_score": 0.0053, "epss_percentile": 0.66623}, "CVE-2007-4628": {"epss_score": 0.01477, "epss_percentile": 0.80546}, "CVE-2007-4629": {"epss_score": 0.01309, "epss_percentile": 0.79351}, "CVE-2007-4630": {"epss_score": 0.09375, "epss_percentile": 0.9252}, "CVE-2007-4631": {"epss_score": 0.00038, "epss_percentile": 0.11334}, "CVE-2007-4632": {"epss_score": 0.00228, "epss_percentile": 0.45547}, "CVE-2007-4633": {"epss_score": 0.00551, "epss_percentile": 0.67359}, "CVE-2007-4634": {"epss_score": 0.01526, "epss_percentile": 0.80863}, "CVE-2007-4635": {"epss_score": 0.02822, "epss_percentile": 0.85749}, "CVE-2007-4636": {"epss_score": 0.81674, "epss_percentile": 0.9915}, "CVE-2007-4637": {"epss_score": 0.05436, "epss_percentile": 0.89882}, "CVE-2007-4638": {"epss_score": 0.0563, "epss_percentile": 0.90068}, "CVE-2007-4639": {"epss_score": 0.16575, "epss_percentile": 0.94696}, "CVE-2007-4640": {"epss_score": 0.06278, "epss_percentile": 0.90633}, "CVE-2007-4641": {"epss_score": 0.05029, "epss_percentile": 0.89412}, "CVE-2007-4642": {"epss_score": 0.29103, "epss_percentile": 0.96418}, "CVE-2007-4643": {"epss_score": 0.02402, "epss_percentile": 0.84641}, "CVE-2007-4644": {"epss_score": 0.01796, "epss_percentile": 0.82304}, "CVE-2007-4645": {"epss_score": 0.00855, "epss_percentile": 0.74468}, "CVE-2007-4646": {"epss_score": 0.27772, "epss_percentile": 0.96281}, "CVE-2007-4647": {"epss_score": 0.05863, "epss_percentile": 0.90272}, "CVE-2007-4648": {"epss_score": 0.00149, "epss_percentile": 0.36044}, "CVE-2007-4649": {"epss_score": 0.00332, "epss_percentile": 0.55564}, "CVE-2007-4650": {"epss_score": 0.00921, "epss_percentile": 0.75484}, "CVE-2007-4651": {"epss_score": 0.02307, "epss_percentile": 0.84325}, "CVE-2007-4652": {"epss_score": 0.0015, "epss_percentile": 0.36054}, "CVE-2007-4653": {"epss_score": 0.00162, "epss_percentile": 0.37692}, "CVE-2007-4654": {"epss_score": 0.0071, "epss_percentile": 0.71725}, "CVE-2007-4655": {"epss_score": 0.00223, "epss_percentile": 0.44869}, "CVE-2007-4656": {"epss_score": 0.00071, "epss_percentile": 0.22124}, "CVE-2007-4657": {"epss_score": 0.0195, "epss_percentile": 0.83014}, "CVE-2007-4658": {"epss_score": 0.02166, "epss_percentile": 0.83848}, "CVE-2007-4659": {"epss_score": 0.03625, "epss_percentile": 0.87456}, "CVE-2007-4660": {"epss_score": 0.04644, "epss_percentile": 0.88956}, "CVE-2007-4661": {"epss_score": 0.03353, "epss_percentile": 0.86968}, "CVE-2007-4662": {"epss_score": 0.03823, "epss_percentile": 0.87787}, "CVE-2007-4663": {"epss_score": 0.01227, "epss_percentile": 0.78701}, "CVE-2007-4664": {"epss_score": 0.01144, "epss_percentile": 0.77985}, "CVE-2007-4665": {"epss_score": 0.01824, "epss_percentile": 0.82423}, "CVE-2007-4666": {"epss_score": 0.01824, "epss_percentile": 0.82423}, "CVE-2007-4667": {"epss_score": 0.01824, "epss_percentile": 0.82423}, "CVE-2007-4668": {"epss_score": 0.00214, "epss_percentile": 0.43973}, "CVE-2007-4669": {"epss_score": 0.00388, "epss_percentile": 0.59396}, "CVE-2007-4670": {"epss_score": 0.04164, "epss_percentile": 0.8834}, "CVE-2007-4671": {"epss_score": 0.02958, "epss_percentile": 0.86066}, "CVE-2007-4672": {"epss_score": 0.3907, "epss_percentile": 0.97137}, "CVE-2007-4673": {"epss_score": 0.01381, "epss_percentile": 0.79869}, "CVE-2007-4674": {"epss_score": 0.02349, "epss_percentile": 0.84465}, "CVE-2007-4675": {"epss_score": 0.48893, "epss_percentile": 0.97658}, "CVE-2007-4676": {"epss_score": 0.6982, "epss_percentile": 0.98605}, "CVE-2007-4677": {"epss_score": 0.7011, "epss_percentile": 0.98617}, "CVE-2007-4678": {"epss_score": 0.00519, "epss_percentile": 0.66168}, "CVE-2007-4679": {"epss_score": 0.0071, "epss_percentile": 0.71716}, "CVE-2007-4680": {"epss_score": 0.01065, "epss_percentile": 0.77209}, "CVE-2007-4681": {"epss_score": 0.00103, "epss_percentile": 0.28924}, "CVE-2007-4682": {"epss_score": 0.03883, "epss_percentile": 0.87899}, "CVE-2007-4683": {"epss_score": 0.00047, "epss_percentile": 0.14687}, "CVE-2007-4684": {"epss_score": 0.00247, "epss_percentile": 0.479}, "CVE-2007-4685": {"epss_score": 0.00054, "epss_percentile": 0.17085}, "CVE-2007-4686": {"epss_score": 0.00161, "epss_percentile": 0.37523}, "CVE-2007-4687": {"epss_score": 0.00465, "epss_percentile": 0.63751}, "CVE-2007-4688": {"epss_score": 0.0045, "epss_percentile": 0.63091}, "CVE-2007-4689": {"epss_score": 0.07521, "epss_percentile": 0.91515}, "CVE-2007-4690": {"epss_score": 0.02668, "epss_percentile": 0.8538}, "CVE-2007-4691": {"epss_score": 0.00524, "epss_percentile": 0.66321}, "CVE-2007-4692": {"epss_score": 0.01126, "epss_percentile": 0.77809}, "CVE-2007-4693": {"epss_score": 0.00079, "epss_percentile": 0.23899}, "CVE-2007-4694": {"epss_score": 0.0045, "epss_percentile": 0.63091}, "CVE-2007-4695": {"epss_score": 0.0045, "epss_percentile": 0.63091}, "CVE-2007-4696": {"epss_score": 0.00269, "epss_percentile": 0.50162}, "CVE-2007-4697": {"epss_score": 0.02383, "epss_percentile": 0.84573}, "CVE-2007-4698": {"epss_score": 0.01128, "epss_percentile": 0.7783}, "CVE-2007-4699": {"epss_score": 0.00301, "epss_percentile": 0.53048}, "CVE-2007-4700": {"epss_score": 0.00647, "epss_percentile": 0.70208}, "CVE-2007-4701": {"epss_score": 0.00073, "epss_percentile": 0.22584}, "CVE-2007-4702": {"epss_score": 0.00665, "epss_percentile": 0.70663}, "CVE-2007-4703": {"epss_score": 0.00664, "epss_percentile": 0.70635}, "CVE-2007-4704": {"epss_score": 0.00806, "epss_percentile": 0.73656}, "CVE-2007-4706": {"epss_score": 0.04039, "epss_percentile": 0.88162}, "CVE-2007-4707": {"epss_score": 0.04956, "epss_percentile": 0.89329}, "CVE-2007-4708": {"epss_score": 0.02961, "epss_percentile": 0.8607}, "CVE-2007-4709": {"epss_score": 0.00141, "epss_percentile": 0.34821}, "CVE-2007-4710": {"epss_score": 0.04772, "epss_percentile": 0.89128}, "CVE-2007-4711": {"epss_score": 0.04969, "epss_percentile": 0.89345}, "CVE-2007-4712": {"epss_score": 0.79511, "epss_percentile": 0.99043}, "CVE-2007-4713": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4714": {"epss_score": 0.00486, "epss_percentile": 0.64761}, "CVE-2007-4715": {"epss_score": 0.07119, "epss_percentile": 0.91263}, "CVE-2007-4716": {"epss_score": 0.00893, "epss_percentile": 0.75078}, "CVE-2007-4717": {"epss_score": 0.01519, "epss_percentile": 0.80817}, "CVE-2007-4718": {"epss_score": 0.05642, "epss_percentile": 0.90078}, "CVE-2007-4719": {"epss_score": 0.00581, "epss_percentile": 0.68265}, "CVE-2007-4720": {"epss_score": 0.02771, "epss_percentile": 0.8562}, "CVE-2007-4722": {"epss_score": 0.38964, "epss_percentile": 0.97132}, "CVE-2007-4723": {"epss_score": 0.00162, "epss_percentile": 0.37721}, "CVE-2007-4724": {"epss_score": 0.00682, "epss_percentile": 0.71062}, "CVE-2007-4725": {"epss_score": 0.16726, "epss_percentile": 0.94722}, "CVE-2007-4726": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2007-4727": {"epss_score": 0.17743, "epss_percentile": 0.94898}, "CVE-2007-4730": {"epss_score": 0.00093, "epss_percentile": 0.26679}, "CVE-2007-4731": {"epss_score": 0.35606, "epss_percentile": 0.96922}, "CVE-2007-4732": {"epss_score": 0.00058, "epss_percentile": 0.18594}, "CVE-2007-4733": {"epss_score": 0.00661, "epss_percentile": 0.70563}, "CVE-2007-4734": {"epss_score": 0.30441, "epss_percentile": 0.96539}, "CVE-2007-4735": {"epss_score": 0.23228, "epss_percentile": 0.95753}, "CVE-2007-4736": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-4737": {"epss_score": 0.07172, "epss_percentile": 0.91299}, "CVE-2007-4738": {"epss_score": 0.04723, "epss_percentile": 0.89057}, "CVE-2007-4739": {"epss_score": 0.00583, "epss_percentile": 0.68342}, "CVE-2007-4740": {"epss_score": 0.0396, "epss_percentile": 0.88012}, "CVE-2007-4741": {"epss_score": 0.00202, "epss_percentile": 0.42452}, "CVE-2007-4742": {"epss_score": 0.00309, "epss_percentile": 0.53666}, "CVE-2007-4743": {"epss_score": 0.19637, "epss_percentile": 0.95218}, "CVE-2007-4744": {"epss_score": 0.82487, "epss_percentile": 0.99197}, "CVE-2007-4745": {"epss_score": 0.00046, "epss_percentile": 0.14129}, "CVE-2007-4746": {"epss_score": 0.01927, "epss_percentile": 0.82927}, "CVE-2007-4747": {"epss_score": 0.03085, "epss_percentile": 0.86382}, "CVE-2007-4748": {"epss_score": 0.05726, "epss_percentile": 0.90156}, "CVE-2007-4749": {"epss_score": 0.00801, "epss_percentile": 0.73577}, "CVE-2007-4750": {"epss_score": 0.15548, "epss_percentile": 0.94454}, "CVE-2007-4751": {"epss_score": 0.00076, "epss_percentile": 0.23143}, "CVE-2007-4752": {"epss_score": 0.0212, "epss_percentile": 0.83673}, "CVE-2007-4753": {"epss_score": 0.01176, "epss_percentile": 0.78269}, "CVE-2007-4754": {"epss_score": 0.12199, "epss_percentile": 0.936}, "CVE-2007-4755": {"epss_score": 0.02221, "epss_percentile": 0.84052}, "CVE-2007-4756": {"epss_score": 0.00998, "epss_percentile": 0.76473}, "CVE-2007-4757": {"epss_score": 0.74841, "epss_percentile": 0.9882}, "CVE-2007-4758": {"epss_score": 0.03688, "epss_percentile": 0.87573}, "CVE-2007-4759": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2007-4760": {"epss_score": 0.00313, "epss_percentile": 0.54037}, "CVE-2007-4761": {"epss_score": 0.01772, "epss_percentile": 0.82201}, "CVE-2007-4762": {"epss_score": 0.00541, "epss_percentile": 0.6703}, "CVE-2007-4763": {"epss_score": 0.05309, "epss_percentile": 0.89715}, "CVE-2007-4764": {"epss_score": 0.00175, "epss_percentile": 0.39311}, "CVE-2007-4766": {"epss_score": 0.05109, "epss_percentile": 0.89507}, "CVE-2007-4767": {"epss_score": 0.02611, "epss_percentile": 0.85236}, "CVE-2007-4768": {"epss_score": 0.1241, "epss_percentile": 0.93662}, "CVE-2007-4769": {"epss_score": 0.0121, "epss_percentile": 0.78546}, "CVE-2007-4770": {"epss_score": 0.0367, "epss_percentile": 0.87538}, "CVE-2007-4771": {"epss_score": 0.02332, "epss_percentile": 0.84409}, "CVE-2007-4772": {"epss_score": 0.00289, "epss_percentile": 0.52039}, "CVE-2007-4773": {"epss_score": 0.00633, "epss_percentile": 0.69772}, "CVE-2007-4774": {"epss_score": 0.00177, "epss_percentile": 0.39611}, "CVE-2007-4776": {"epss_score": 0.82373, "epss_percentile": 0.99191}, "CVE-2007-4777": {"epss_score": 0.00039, "epss_percentile": 0.11726}, "CVE-2007-4778": {"epss_score": 0.00049, "epss_percentile": 0.15514}, "CVE-2007-4779": {"epss_score": 0.00015, "epss_percentile": 0.02533}, "CVE-2007-4780": {"epss_score": 0.00025, "epss_percentile": 0.06041}, "CVE-2007-4781": {"epss_score": 0.00066, "epss_percentile": 0.20876}, "CVE-2007-4782": {"epss_score": 0.03798, "epss_percentile": 0.87738}, "CVE-2007-4783": {"epss_score": 0.01865, "epss_percentile": 0.82604}, "CVE-2007-4784": {"epss_score": 0.01638, "epss_percentile": 0.81485}, "CVE-2007-4785": {"epss_score": 0.00795, "epss_percentile": 0.7347}, "CVE-2007-4786": {"epss_score": 0.00136, "epss_percentile": 0.34157}, "CVE-2007-4787": {"epss_score": 0.01933, "epss_percentile": 0.82952}, "CVE-2007-4788": {"epss_score": 0.01263, "epss_percentile": 0.78987}, "CVE-2007-4789": {"epss_score": 0.01263, "epss_percentile": 0.78987}, "CVE-2007-4790": {"epss_score": 0.73675, "epss_percentile": 0.98767}, "CVE-2007-4791": {"epss_score": 0.00049, "epss_percentile": 0.15304}, "CVE-2007-4792": {"epss_score": 0.00051, "epss_percentile": 0.16183}, "CVE-2007-4793": {"epss_score": 0.00051, "epss_percentile": 0.16183}, "CVE-2007-4794": {"epss_score": 0.00049, "epss_percentile": 0.15304}, "CVE-2007-4795": {"epss_score": 0.00051, "epss_percentile": 0.16183}, "CVE-2007-4796": {"epss_score": 0.00051, "epss_percentile": 0.16183}, "CVE-2007-4797": {"epss_score": 0.00051, "epss_percentile": 0.16183}, "CVE-2007-4798": {"epss_score": 0.00048, "epss_percentile": 0.15176}, "CVE-2007-4799": {"epss_score": 0.00048, "epss_percentile": 0.15184}, "CVE-2007-4802": {"epss_score": 0.46725, "epss_percentile": 0.97556}, "CVE-2007-4803": {"epss_score": 0.19541, "epss_percentile": 0.95204}, "CVE-2007-4804": {"epss_score": 0.00523, "epss_percentile": 0.66287}, "CVE-2007-4805": {"epss_score": 0.10345, "epss_percentile": 0.92951}, "CVE-2007-4806": {"epss_score": 0.08388, "epss_percentile": 0.92023}, "CVE-2007-4807": {"epss_score": 0.08388, "epss_percentile": 0.92023}, "CVE-2007-4808": {"epss_score": 0.02231, "epss_percentile": 0.84088}, "CVE-2007-4809": {"epss_score": 0.82831, "epss_percentile": 0.99217}, "CVE-2007-4810": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-4811": {"epss_score": 0.00435, "epss_percentile": 0.62358}, "CVE-2007-4812": {"epss_score": 0.04095, "epss_percentile": 0.88249}, "CVE-2007-4813": {"epss_score": 0.00246, "epss_percentile": 0.47789}, "CVE-2007-4814": {"epss_score": 0.50433, "epss_percentile": 0.97736}, "CVE-2007-4815": {"epss_score": 0.16845, "epss_percentile": 0.94737}, "CVE-2007-4816": {"epss_score": 0.17155, "epss_percentile": 0.94786}, "CVE-2007-4817": {"epss_score": 0.06927, "epss_percentile": 0.91121}, "CVE-2007-4818": {"epss_score": 0.22197, "epss_percentile": 0.95608}, "CVE-2007-4819": {"epss_score": 0.03477, "epss_percentile": 0.87212}, "CVE-2007-4820": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2007-4821": {"epss_score": 0.05249, "epss_percentile": 0.89663}, "CVE-2007-4822": {"epss_score": 0.00403, "epss_percentile": 0.60369}, "CVE-2007-4823": {"epss_score": 0.00131, "epss_percentile": 0.33391}, "CVE-2007-4824": {"epss_score": 0.00123, "epss_percentile": 0.32333}, "CVE-2007-4825": {"epss_score": 0.00268, "epss_percentile": 0.50055}, "CVE-2007-4826": {"epss_score": 0.0142, "epss_percentile": 0.80169}, "CVE-2007-4827": {"epss_score": 0.15184, "epss_percentile": 0.9438}, "CVE-2007-4828": {"epss_score": 0.00537, "epss_percentile": 0.66918}, "CVE-2007-4829": {"epss_score": 0.02051, "epss_percentile": 0.83405}, "CVE-2007-4830": {"epss_score": 0.00307, "epss_percentile": 0.5349}, "CVE-2007-4831": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-4832": {"epss_score": 0.03829, "epss_percentile": 0.87801}, "CVE-2007-4833": {"epss_score": 0.00616, "epss_percentile": 0.69328}, "CVE-2007-4834": {"epss_score": 0.44907, "epss_percentile": 0.97459}, "CVE-2007-4835": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-4836": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4837": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-4838": {"epss_score": 0.17661, "epss_percentile": 0.94886}, "CVE-2007-4839": {"epss_score": 0.00323, "epss_percentile": 0.54902}, "CVE-2007-4840": {"epss_score": 0.01849, "epss_percentile": 0.82532}, "CVE-2007-4841": {"epss_score": 0.08932, "epss_percentile": 0.92325}, "CVE-2007-4842": {"epss_score": 0.00543, "epss_percentile": 0.67089}, "CVE-2007-4843": {"epss_score": 0.05379, "epss_percentile": 0.89807}, "CVE-2007-4844": {"epss_score": 0.00624, "epss_percentile": 0.69571}, "CVE-2007-4845": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-4846": {"epss_score": 0.00801, "epss_percentile": 0.73561}, "CVE-2007-4847": {"epss_score": 0.00179, "epss_percentile": 0.39779}, "CVE-2007-4848": {"epss_score": 0.2308, "epss_percentile": 0.95731}, "CVE-2007-4849": {"epss_score": 0.00069, "epss_percentile": 0.21548}, "CVE-2007-4850": {"epss_score": 0.13184, "epss_percentile": 0.93894}, "CVE-2007-4861": {"epss_score": 0.00804, "epss_percentile": 0.73627}, "CVE-2007-4862": {"epss_score": 0.02687, "epss_percentile": 0.85429}, "CVE-2007-4863": {"epss_score": 0.00407, "epss_percentile": 0.60608}, "CVE-2007-4872": {"epss_score": 0.00859, "epss_percentile": 0.74517}, "CVE-2007-4873": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4874": {"epss_score": 0.05256, "epss_percentile": 0.89667}, "CVE-2007-4879": {"epss_score": 0.01525, "epss_percentile": 0.80859}, "CVE-2007-4880": {"epss_score": 0.88938, "epss_percentile": 0.995}, "CVE-2007-4881": {"epss_score": 0.00754, "epss_percentile": 0.72708}, "CVE-2007-4882": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-4883": {"epss_score": 0.00246, "epss_percentile": 0.47789}, "CVE-2007-4884": {"epss_score": 0.00484, "epss_percentile": 0.6465}, "CVE-2007-4885": {"epss_score": 0.00484, "epss_percentile": 0.6465}, "CVE-2007-4886": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-4887": {"epss_score": 0.02345, "epss_percentile": 0.84449}, "CVE-2007-4888": {"epss_score": 0.00052, "epss_percentile": 0.16605}, "CVE-2007-4889": {"epss_score": 0.0052, "epss_percentile": 0.66195}, "CVE-2007-4890": {"epss_score": 0.2651, "epss_percentile": 0.96152}, "CVE-2007-4891": {"epss_score": 0.51667, "epss_percentile": 0.97792}, "CVE-2007-4892": {"epss_score": 0.00614, "epss_percentile": 0.69281}, "CVE-2007-4893": {"epss_score": 0.01545, "epss_percentile": 0.80963}, "CVE-2007-4894": {"epss_score": 0.0388, "epss_percentile": 0.87895}, "CVE-2007-4895": {"epss_score": 0.03363, "epss_percentile": 0.86996}, "CVE-2007-4896": {"epss_score": 0.00507, "epss_percentile": 0.65654}, "CVE-2007-4897": {"epss_score": 0.22073, "epss_percentile": 0.95592}, "CVE-2007-4898": {"epss_score": 0.00052, "epss_percentile": 0.16381}, "CVE-2007-4899": {"epss_score": 0.01456, "epss_percentile": 0.80393}, "CVE-2007-4900": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4901": {"epss_score": 0.0241, "epss_percentile": 0.84664}, "CVE-2007-4902": {"epss_score": 0.03185, "epss_percentile": 0.86588}, "CVE-2007-4903": {"epss_score": 0.07319, "epss_percentile": 0.91406}, "CVE-2007-4904": {"epss_score": 0.05722, "epss_percentile": 0.90153}, "CVE-2007-4905": {"epss_score": 0.08289, "epss_percentile": 0.91972}, "CVE-2007-4906": {"epss_score": 0.58067, "epss_percentile": 0.98098}, "CVE-2007-4907": {"epss_score": 0.07186, "epss_percentile": 0.91308}, "CVE-2007-4908": {"epss_score": 0.06732, "epss_percentile": 0.90989}, "CVE-2007-4909": {"epss_score": 0.13606, "epss_percentile": 0.94009}, "CVE-2007-4910": {"epss_score": 0.00477, "epss_percentile": 0.64307}, "CVE-2007-4911": {"epss_score": 0.13087, "epss_percentile": 0.93869}, "CVE-2007-4912": {"epss_score": 0.00302, "epss_percentile": 0.53087}, "CVE-2007-4913": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2007-4914": {"epss_score": 0.01184, "epss_percentile": 0.78329}, "CVE-2007-4915": {"epss_score": 0.81088, "epss_percentile": 0.99118}, "CVE-2007-4916": {"epss_score": 0.71291, "epss_percentile": 0.98662}, "CVE-2007-4917": {"epss_score": 0.01823, "epss_percentile": 0.82421}, "CVE-2007-4918": {"epss_score": 0.01595, "epss_percentile": 0.81234}, "CVE-2007-4919": {"epss_score": 0.00574, "epss_percentile": 0.68068}, "CVE-2007-4920": {"epss_score": 0.00884, "epss_percentile": 0.74929}, "CVE-2007-4921": {"epss_score": 0.83048, "epss_percentile": 0.99229}, "CVE-2007-4922": {"epss_score": 0.0046, "epss_percentile": 0.63528}, "CVE-2007-4923": {"epss_score": 0.00563, "epss_percentile": 0.67711}, "CVE-2007-4924": {"epss_score": 0.22462, "epss_percentile": 0.95638}, "CVE-2007-4925": {"epss_score": 0.03289, "epss_percentile": 0.86832}, "CVE-2007-4926": {"epss_score": 0.00558, "epss_percentile": 0.67596}, "CVE-2007-4927": {"epss_score": 0.00958, "epss_percentile": 0.75946}, "CVE-2007-4928": {"epss_score": 0.00063, "epss_percentile": 0.19916}, "CVE-2007-4929": {"epss_score": 0.00435, "epss_percentile": 0.62358}, "CVE-2007-4930": {"epss_score": 0.08544, "epss_percentile": 0.92115}, "CVE-2007-4931": {"epss_score": 0.00149, "epss_percentile": 0.35943}, "CVE-2007-4932": {"epss_score": 0.04962, "epss_percentile": 0.89337}, "CVE-2007-4933": {"epss_score": 0.04515, "epss_percentile": 0.8879}, "CVE-2007-4934": {"epss_score": 0.04935, "epss_percentile": 0.89301}, "CVE-2007-4935": {"epss_score": 0.02218, "epss_percentile": 0.8404}, "CVE-2007-4936": {"epss_score": 0.00323, "epss_percentile": 0.54902}, "CVE-2007-4937": {"epss_score": 0.03419, "epss_percentile": 0.87099}, "CVE-2007-4938": {"epss_score": 0.09716, "epss_percentile": 0.92675}, "CVE-2007-4939": {"epss_score": 0.23195, "epss_percentile": 0.95749}, "CVE-2007-4940": {"epss_score": 0.02589, "epss_percentile": 0.85179}, "CVE-2007-4941": {"epss_score": 0.05838, "epss_percentile": 0.90249}, "CVE-2007-4942": {"epss_score": 0.01219, "epss_percentile": 0.78616}, "CVE-2007-4943": {"epss_score": 0.10819, "epss_percentile": 0.93121}, "CVE-2007-4944": {"epss_score": 0.00566, "epss_percentile": 0.67832}, "CVE-2007-4945": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-4946": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2007-4947": {"epss_score": 0.01947, "epss_percentile": 0.83007}, "CVE-2007-4948": {"epss_score": 0.00702, "epss_percentile": 0.7152}, "CVE-2007-4949": {"epss_score": 0.00609, "epss_percentile": 0.69098}, "CVE-2007-4950": {"epss_score": 0.00733, "epss_percentile": 0.72217}, "CVE-2007-4951": {"epss_score": 0.00661, "epss_percentile": 0.70569}, "CVE-2007-4952": {"epss_score": 0.00404, "epss_percentile": 0.60444}, "CVE-2007-4953": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-4954": {"epss_score": 0.01795, "epss_percentile": 0.82296}, "CVE-2007-4955": {"epss_score": 0.00075, "epss_percentile": 0.23069}, "CVE-2007-4956": {"epss_score": 0.02624, "epss_percentile": 0.85261}, "CVE-2007-4957": {"epss_score": 0.06829, "epss_percentile": 0.91054}, "CVE-2007-4958": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-4959": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-4960": {"epss_score": 0.00381, "epss_percentile": 0.59027}, "CVE-2007-4961": {"epss_score": 0.00226, "epss_percentile": 0.4531}, "CVE-2007-4962": {"epss_score": 0.04224, "epss_percentile": 0.88413}, "CVE-2007-4963": {"epss_score": 0.00434, "epss_percentile": 0.62291}, "CVE-2007-4964": {"epss_score": 0.03808, "epss_percentile": 0.87753}, "CVE-2007-4965": {"epss_score": 0.0422, "epss_percentile": 0.8841}, "CVE-2007-4966": {"epss_score": 0.01, "epss_percentile": 0.76485}, "CVE-2007-4967": {"epss_score": 0.00063, "epss_percentile": 0.19979}, "CVE-2007-4968": {"epss_score": 0.0007, "epss_percentile": 0.21956}, "CVE-2007-4969": {"epss_score": 0.0007, "epss_percentile": 0.21956}, "CVE-2007-4970": {"epss_score": 0.0007, "epss_percentile": 0.21956}, "CVE-2007-4971": {"epss_score": 0.0007, "epss_percentile": 0.21956}, "CVE-2007-4972": {"epss_score": 0.0007, "epss_percentile": 0.21956}, "CVE-2007-4974": {"epss_score": 0.068, "epss_percentile": 0.91034}, "CVE-2007-4975": {"epss_score": 0.05407, "epss_percentile": 0.89841}, "CVE-2007-4976": {"epss_score": 0.16699, "epss_percentile": 0.94717}, "CVE-2007-4977": {"epss_score": 0.00901, "epss_percentile": 0.75166}, "CVE-2007-4978": {"epss_score": 0.03967, "epss_percentile": 0.88032}, "CVE-2007-4979": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-4980": {"epss_score": 0.05, "epss_percentile": 0.89377}, "CVE-2007-4981": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-4982": {"epss_score": 0.09351, "epss_percentile": 0.92512}, "CVE-2007-4983": {"epss_score": 0.14298, "epss_percentile": 0.94181}, "CVE-2007-4984": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-4985": {"epss_score": 0.0277, "epss_percentile": 0.85616}, "CVE-2007-4986": {"epss_score": 0.01545, "epss_percentile": 0.80964}, "CVE-2007-4987": {"epss_score": 0.03661, "epss_percentile": 0.87527}, "CVE-2007-4988": {"epss_score": 0.02298, "epss_percentile": 0.84302}, "CVE-2007-4990": {"epss_score": 0.04295, "epss_percentile": 0.88507}, "CVE-2007-4991": {"epss_score": 0.47456, "epss_percentile": 0.97588}, "CVE-2007-4992": {"epss_score": 0.19893, "epss_percentile": 0.95255}, "CVE-2007-4993": {"epss_score": 0.00162, "epss_percentile": 0.3763}, "CVE-2007-4994": {"epss_score": 0.00358, "epss_percentile": 0.575}, "CVE-2007-4995": {"epss_score": 0.10352, "epss_percentile": 0.92955}, "CVE-2007-4996": {"epss_score": 0.0163, "epss_percentile": 0.81442}, "CVE-2007-4997": {"epss_score": 0.05391, "epss_percentile": 0.89824}, "CVE-2007-4998": {"epss_score": 0.00105, "epss_percentile": 0.29316}, "CVE-2007-4999": {"epss_score": 0.0156, "epss_percentile": 0.81036}, "CVE-2007-5000": {"epss_score": 0.86401, "epss_percentile": 0.9938}, "CVE-2007-5001": {"epss_score": 0.00045, "epss_percentile": 0.13797}, "CVE-2007-5003": {"epss_score": 0.82085, "epss_percentile": 0.99172}, "CVE-2007-5004": {"epss_score": 0.13027, "epss_percentile": 0.93849}, "CVE-2007-5005": {"epss_score": 0.03654, "epss_percentile": 0.87512}, "CVE-2007-5006": {"epss_score": 0.01783, "epss_percentile": 0.82248}, "CVE-2007-5007": {"epss_score": 0.0122, "epss_percentile": 0.78626}, "CVE-2007-5008": {"epss_score": 0.01092, "epss_percentile": 0.77464}, "CVE-2007-5009": {"epss_score": 0.15812, "epss_percentile": 0.94513}, "CVE-2007-5010": {"epss_score": 0.00574, "epss_percentile": 0.68076}, "CVE-2007-5011": {"epss_score": 0.04786, "epss_percentile": 0.89143}, "CVE-2007-5012": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-5013": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-5014": {"epss_score": 0.00614, "epss_percentile": 0.69272}, "CVE-2007-5015": {"epss_score": 0.15675, "epss_percentile": 0.94483}, "CVE-2007-5016": {"epss_score": 0.00486, "epss_percentile": 0.64761}, "CVE-2007-5017": {"epss_score": 0.06732, "epss_percentile": 0.90989}, "CVE-2007-5018": {"epss_score": 0.19538, "epss_percentile": 0.95203}, "CVE-2007-5019": {"epss_score": 0.10101, "epss_percentile": 0.9285}, "CVE-2007-5020": {"epss_score": 0.36906, "epss_percentile": 0.97008}, "CVE-2007-5022": {"epss_score": 0.00789, "epss_percentile": 0.73363}, "CVE-2007-5023": {"epss_score": 0.00072, "epss_percentile": 0.22367}, "CVE-2007-5024": {"epss_score": 0.00062, "epss_percentile": 0.19748}, "CVE-2007-5025": {"epss_score": 0.0027, "epss_percentile": 0.50245}, "CVE-2007-5026": {"epss_score": 0.05992, "epss_percentile": 0.90388}, "CVE-2007-5027": {"epss_score": 0.04183, "epss_percentile": 0.88359}, "CVE-2007-5028": {"epss_score": 0.00244, "epss_percentile": 0.47601}, "CVE-2007-5029": {"epss_score": 0.01348, "epss_percentile": 0.79658}, "CVE-2007-5030": {"epss_score": 0.01176, "epss_percentile": 0.78269}, "CVE-2007-5031": {"epss_score": 0.01176, "epss_percentile": 0.78269}, "CVE-2007-5032": {"epss_score": 0.00021, "epss_percentile": 0.0474}, "CVE-2007-5033": {"epss_score": 0.00407, "epss_percentile": 0.60613}, "CVE-2007-5034": {"epss_score": 0.02146, "epss_percentile": 0.83766}, "CVE-2007-5035": {"epss_score": 0.00784, "epss_percentile": 0.73234}, "CVE-2007-5036": {"epss_score": 0.06929, "epss_percentile": 0.91122}, "CVE-2007-5037": {"epss_score": 0.01863, "epss_percentile": 0.82596}, "CVE-2007-5038": {"epss_score": 0.00994, "epss_percentile": 0.7642}, "CVE-2007-5039": {"epss_score": 0.0015, "epss_percentile": 0.36121}, "CVE-2007-5040": {"epss_score": 0.00147, "epss_percentile": 0.35795}, "CVE-2007-5041": {"epss_score": 0.0007, "epss_percentile": 0.21956}, "CVE-2007-5042": {"epss_score": 0.0007, "epss_percentile": 0.21956}, "CVE-2007-5043": {"epss_score": 0.00056, "epss_percentile": 0.17911}, "CVE-2007-5044": {"epss_score": 0.00047, "epss_percentile": 0.14694}, "CVE-2007-5045": {"epss_score": 0.02046, "epss_percentile": 0.83387}, "CVE-2007-5046": {"epss_score": 0.00381, "epss_percentile": 0.59013}, "CVE-2007-5047": {"epss_score": 0.00056, "epss_percentile": 0.17865}, "CVE-2007-5048": {"epss_score": 0.06287, "epss_percentile": 0.90646}, "CVE-2007-5050": {"epss_score": 0.06528, "epss_percentile": 0.90822}, "CVE-2007-5051": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-5052": {"epss_score": 0.02658, "epss_percentile": 0.85362}, "CVE-2007-5053": {"epss_score": 0.03978, "epss_percentile": 0.88055}, "CVE-2007-5054": {"epss_score": 0.78514, "epss_percentile": 0.9899}, "CVE-2007-5055": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2007-5056": {"epss_score": 0.81715, "epss_percentile": 0.99153}, "CVE-2007-5057": {"epss_score": 0.01918, "epss_percentile": 0.82875}, "CVE-2007-5058": {"epss_score": 0.00792, "epss_percentile": 0.73408}, "CVE-2007-5059": {"epss_score": 0.00569, "epss_percentile": 0.67913}, "CVE-2007-5060": {"epss_score": 0.00313, "epss_percentile": 0.54058}, "CVE-2007-5061": {"epss_score": 0.00884, "epss_percentile": 0.74929}, "CVE-2007-5062": {"epss_score": 0.04882, "epss_percentile": 0.8925}, "CVE-2007-5063": {"epss_score": 0.03039, "epss_percentile": 0.86268}, "CVE-2007-5064": {"epss_score": 0.05693, "epss_percentile": 0.90126}, "CVE-2007-5065": {"epss_score": 0.64909, "epss_percentile": 0.98398}, "CVE-2007-5066": {"epss_score": 0.0122, "epss_percentile": 0.7862}, "CVE-2007-5067": {"epss_score": 0.82981, "epss_percentile": 0.99224}, "CVE-2007-5068": {"epss_score": 0.0047, "epss_percentile": 0.63984}, "CVE-2007-5069": {"epss_score": 0.06528, "epss_percentile": 0.90822}, "CVE-2007-5070": {"epss_score": 0.22241, "epss_percentile": 0.95613}, "CVE-2007-5071": {"epss_score": 0.02165, "epss_percentile": 0.83843}, "CVE-2007-5072": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-5078": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-5079": {"epss_score": 0.00289, "epss_percentile": 0.52036}, "CVE-2007-5080": {"epss_score": 0.34513, "epss_percentile": 0.96852}, "CVE-2007-5081": {"epss_score": 0.08765, "epss_percentile": 0.92246}, "CVE-2007-5082": {"epss_score": 0.70512, "epss_percentile": 0.98634}, "CVE-2007-5083": {"epss_score": 0.38068, "epss_percentile": 0.97084}, "CVE-2007-5084": {"epss_score": 0.01613, "epss_percentile": 0.8134}, "CVE-2007-5085": {"epss_score": 0.00699, "epss_percentile": 0.71457}, "CVE-2007-5086": {"epss_score": 0.00061, "epss_percentile": 0.19277}, "CVE-2007-5087": {"epss_score": 0.00111, "epss_percentile": 0.3038}, "CVE-2007-5088": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-5089": {"epss_score": 0.10348, "epss_percentile": 0.92952}, "CVE-2007-5090": {"epss_score": 0.00958, "epss_percentile": 0.75943}, "CVE-2007-5091": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-5092": {"epss_score": 0.06299, "epss_percentile": 0.90654}, "CVE-2007-5093": {"epss_score": 0.00061, "epss_percentile": 0.19424}, "CVE-2007-5094": {"epss_score": 0.05266, "epss_percentile": 0.89674}, "CVE-2007-5095": {"epss_score": 0.31962, "epss_percentile": 0.96662}, "CVE-2007-5096": {"epss_score": 0.00501, "epss_percentile": 0.65352}, "CVE-2007-5097": {"epss_score": 0.00786, "epss_percentile": 0.73289}, "CVE-2007-5098": {"epss_score": 0.32475, "epss_percentile": 0.96703}, "CVE-2007-5099": {"epss_score": 0.82971, "epss_percentile": 0.99223}, "CVE-2007-5100": {"epss_score": 0.01228, "epss_percentile": 0.78709}, "CVE-2007-5101": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2007-5102": {"epss_score": 0.57876, "epss_percentile": 0.98089}, "CVE-2007-5103": {"epss_score": 0.00276, "epss_percentile": 0.50736}, "CVE-2007-5104": {"epss_score": 0.00451, "epss_percentile": 0.63145}, "CVE-2007-5105": {"epss_score": 0.01681, "epss_percentile": 0.8173}, "CVE-2007-5106": {"epss_score": 0.00357, "epss_percentile": 0.57456}, "CVE-2007-5107": {"epss_score": 0.76187, "epss_percentile": 0.98881}, "CVE-2007-5108": {"epss_score": 0.02477, "epss_percentile": 0.84864}, "CVE-2007-5109": {"epss_score": 0.00179, "epss_percentile": 0.39793}, "CVE-2007-5110": {"epss_score": 0.09389, "epss_percentile": 0.92529}, "CVE-2007-5111": {"epss_score": 0.04736, "epss_percentile": 0.89074}, "CVE-2007-5112": {"epss_score": 0.08802, "epss_percentile": 0.9226}, "CVE-2007-5113": {"epss_score": 0.04811, "epss_percentile": 0.89167}, "CVE-2007-5114": {"epss_score": 0.00661, "epss_percentile": 0.70569}, "CVE-2007-5115": {"epss_score": 0.00544, "epss_percentile": 0.6713}, "CVE-2007-5116": {"epss_score": 0.11413, "epss_percentile": 0.93341}, "CVE-2007-5117": {"epss_score": 0.04412, "epss_percentile": 0.88662}, "CVE-2007-5118": {"epss_score": 0.0006, "epss_percentile": 0.19017}, "CVE-2007-5119": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2007-5120": {"epss_score": 0.04293, "epss_percentile": 0.88504}, "CVE-2007-5121": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-5122": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-5123": {"epss_score": 0.00486, "epss_percentile": 0.64761}, "CVE-2007-5124": {"epss_score": 0.01384, "epss_percentile": 0.79899}, "CVE-2007-5126": {"epss_score": 0.00416, "epss_percentile": 0.61187}, "CVE-2007-5127": {"epss_score": 0.0622, "epss_percentile": 0.90579}, "CVE-2007-5128": {"epss_score": 0.00348, "epss_percentile": 0.56817}, "CVE-2007-5129": {"epss_score": 0.00792, "epss_percentile": 0.73408}, "CVE-2007-5130": {"epss_score": 0.00381, "epss_percentile": 0.59027}, "CVE-2007-5131": {"epss_score": 0.00884, "epss_percentile": 0.74929}, "CVE-2007-5132": {"epss_score": 0.00047, "epss_percentile": 0.14799}, "CVE-2007-5133": {"epss_score": 0.45241, "epss_percentile": 0.97478}, "CVE-2007-5134": {"epss_score": 0.00678, "epss_percentile": 0.70973}, "CVE-2007-5135": {"epss_score": 0.46897, "epss_percentile": 0.97561}, "CVE-2007-5136": {"epss_score": 0.00278, "epss_percentile": 0.50885}, "CVE-2007-5137": {"epss_score": 0.07715, "epss_percentile": 0.9164}, "CVE-2007-5138": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-5139": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-5140": {"epss_score": 0.03967, "epss_percentile": 0.88032}, "CVE-2007-5141": {"epss_score": 0.00377, "epss_percentile": 0.58763}, "CVE-2007-5142": {"epss_score": 0.00529, "epss_percentile": 0.66582}, "CVE-2007-5143": {"epss_score": 0.00075, "epss_percentile": 0.22931}, "CVE-2007-5144": {"epss_score": 0.16334, "epss_percentile": 0.94631}, "CVE-2007-5145": {"epss_score": 0.18698, "epss_percentile": 0.95056}, "CVE-2007-5146": {"epss_score": 0.01098, "epss_percentile": 0.77535}, "CVE-2007-5147": {"epss_score": 0.00461, "epss_percentile": 0.63554}, "CVE-2007-5148": {"epss_score": 0.0065, "epss_percentile": 0.70252}, "CVE-2007-5149": {"epss_score": 0.10348, "epss_percentile": 0.92952}, "CVE-2007-5150": {"epss_score": 0.00489, "epss_percentile": 0.64899}, "CVE-2007-5151": {"epss_score": 0.00489, "epss_percentile": 0.64899}, "CVE-2007-5152": {"epss_score": 0.02353, "epss_percentile": 0.84475}, "CVE-2007-5153": {"epss_score": 0.04061, "epss_percentile": 0.8819}, "CVE-2007-5154": {"epss_score": 0.00272, "epss_percentile": 0.50372}, "CVE-2007-5155": {"epss_score": 0.06103, "epss_percentile": 0.90483}, "CVE-2007-5156": {"epss_score": 0.48811, "epss_percentile": 0.97656}, "CVE-2007-5157": {"epss_score": 0.03967, "epss_percentile": 0.88032}, "CVE-2007-5158": {"epss_score": 0.1954, "epss_percentile": 0.95203}, "CVE-2007-5159": {"epss_score": 0.00044, "epss_percentile": 0.13619}, "CVE-2007-5160": {"epss_score": 0.00509, "epss_percentile": 0.65727}, "CVE-2007-5161": {"epss_score": 0.00674, "epss_percentile": 0.70881}, "CVE-2007-5162": {"epss_score": 0.00639, "epss_percentile": 0.69942}, "CVE-2007-5163": {"epss_score": 0.00661, "epss_percentile": 0.70569}, "CVE-2007-5164": {"epss_score": 0.00661, "epss_percentile": 0.70569}, "CVE-2007-5165": {"epss_score": 0.0065, "epss_percentile": 0.70252}, "CVE-2007-5166": {"epss_score": 0.00574, "epss_percentile": 0.68091}, "CVE-2007-5167": {"epss_score": 0.00509, "epss_percentile": 0.65727}, "CVE-2007-5168": {"epss_score": 0.00539, "epss_percentile": 0.66982}, "CVE-2007-5169": {"epss_score": 0.34532, "epss_percentile": 0.96853}, "CVE-2007-5170": {"epss_score": 0.00632, "epss_percentile": 0.6975}, "CVE-2007-5171": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2007-5172": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2007-5173": {"epss_score": 0.02194, "epss_percentile": 0.8395}, "CVE-2007-5174": {"epss_score": 0.11392, "epss_percentile": 0.9333}, "CVE-2007-5175": {"epss_score": 0.03564, "epss_percentile": 0.87358}, "CVE-2007-5176": {"epss_score": 0.00569, "epss_percentile": 0.67913}, "CVE-2007-5177": {"epss_score": 0.00535, "epss_percentile": 0.66831}, "CVE-2007-5178": {"epss_score": 0.10348, "epss_percentile": 0.92952}, "CVE-2007-5179": {"epss_score": 0.00287, "epss_percentile": 0.51828}, "CVE-2007-5180": {"epss_score": 0.01671, "epss_percentile": 0.81674}, "CVE-2007-5181": {"epss_score": 0.01033, "epss_percentile": 0.76881}, "CVE-2007-5182": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-5183": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-5184": {"epss_score": 0.29348, "epss_percentile": 0.96435}, "CVE-2007-5185": {"epss_score": 0.27105, "epss_percentile": 0.96207}, "CVE-2007-5186": {"epss_score": 0.53406, "epss_percentile": 0.97875}, "CVE-2007-5187": {"epss_score": 0.00655, "epss_percentile": 0.7042}, "CVE-2007-5188": {"epss_score": 0.01242, "epss_percentile": 0.7882}, "CVE-2007-5189": {"epss_score": 0.00541, "epss_percentile": 0.67041}, "CVE-2007-5190": {"epss_score": 0.05166, "epss_percentile": 0.89566}, "CVE-2007-5191": {"epss_score": 0.00097, "epss_percentile": 0.27628}, "CVE-2007-5193": {"epss_score": 0.00248, "epss_percentile": 0.4796}, "CVE-2007-5194": {"epss_score": 0.00036, "epss_percentile": 0.1021}, "CVE-2007-5195": {"epss_score": 0.0053, "epss_percentile": 0.66633}, "CVE-2007-5196": {"epss_score": 0.00567, "epss_percentile": 0.67849}, "CVE-2007-5197": {"epss_score": 0.02337, "epss_percentile": 0.84418}, "CVE-2007-5198": {"epss_score": 0.16304, "epss_percentile": 0.94614}, "CVE-2007-5199": {"epss_score": 0.00506, "epss_percentile": 0.65618}, "CVE-2007-5200": {"epss_score": 0.00046, "epss_percentile": 0.14082}, "CVE-2007-5201": {"epss_score": 0.00098, "epss_percentile": 0.27728}, "CVE-2007-5207": {"epss_score": 0.00037, "epss_percentile": 0.10743}, "CVE-2007-5208": {"epss_score": 0.73689, "epss_percentile": 0.98767}, "CVE-2007-5209": {"epss_score": 0.0443, "epss_percentile": 0.88677}, "CVE-2007-5210": {"epss_score": 0.00236, "epss_percentile": 0.46387}, "CVE-2007-5211": {"epss_score": 0.00278, "epss_percentile": 0.50885}, "CVE-2007-5212": {"epss_score": 0.00435, "epss_percentile": 0.62358}, "CVE-2007-5213": {"epss_score": 0.00752, "epss_percentile": 0.7266}, "CVE-2007-5214": {"epss_score": 0.00661, "epss_percentile": 0.70562}, "CVE-2007-5215": {"epss_score": 0.00574, "epss_percentile": 0.68091}, "CVE-2007-5216": {"epss_score": 0.00574, "epss_percentile": 0.68091}, "CVE-2007-5217": {"epss_score": 0.65697, "epss_percentile": 0.98434}, "CVE-2007-5218": {"epss_score": 0.05514, "epss_percentile": 0.89949}, "CVE-2007-5219": {"epss_score": 0.07053, "epss_percentile": 0.91214}, "CVE-2007-5220": {"epss_score": 0.00497, "epss_percentile": 0.65198}, "CVE-2007-5221": {"epss_score": 0.07868, "epss_percentile": 0.9173}, "CVE-2007-5222": {"epss_score": 0.01743, "epss_percentile": 0.82058}, "CVE-2007-5223": {"epss_score": 0.01039, "epss_percentile": 0.76942}, "CVE-2007-5224": {"epss_score": 0.01161, "epss_percentile": 0.78139}, "CVE-2007-5225": {"epss_score": 0.00267, "epss_percentile": 0.49992}, "CVE-2007-5226": {"epss_score": 0.00518, "epss_percentile": 0.66094}, "CVE-2007-5227": {"epss_score": 0.00475, "epss_percentile": 0.6419}, "CVE-2007-5228": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2007-5229": {"epss_score": 0.03272, "epss_percentile": 0.86796}, "CVE-2007-5230": {"epss_score": 0.12767, "epss_percentile": 0.93767}, "CVE-2007-5231": {"epss_score": 0.04327, "epss_percentile": 0.88555}, "CVE-2007-5232": {"epss_score": 0.13479, "epss_percentile": 0.93976}, "CVE-2007-5233": {"epss_score": 0.0047, "epss_percentile": 0.63984}, "CVE-2007-5234": {"epss_score": 0.19698, "epss_percentile": 0.95228}, "CVE-2007-5235": {"epss_score": 0.00235, "epss_percentile": 0.4634}, "CVE-2007-5236": {"epss_score": 0.01055, "epss_percentile": 0.77113}, "CVE-2007-5237": {"epss_score": 0.01067, "epss_percentile": 0.77225}, "CVE-2007-5238": {"epss_score": 0.0105, "epss_percentile": 0.7707}, "CVE-2007-5239": {"epss_score": 0.01642, "epss_percentile": 0.81507}, "CVE-2007-5240": {"epss_score": 0.03542, "epss_percentile": 0.8732}, "CVE-2007-5241": {"epss_score": 0.00799, "epss_percentile": 0.73529}, "CVE-2007-5242": {"epss_score": 0.00624, "epss_percentile": 0.6957}, "CVE-2007-5243": {"epss_score": 0.82951, "epss_percentile": 0.99222}, "CVE-2007-5244": {"epss_score": 0.76302, "epss_percentile": 0.98885}, "CVE-2007-5245": {"epss_score": 0.11303, "epss_percentile": 0.93299}, "CVE-2007-5246": {"epss_score": 0.23854, "epss_percentile": 0.95822}, "CVE-2007-5247": {"epss_score": 0.05061, "epss_percentile": 0.89453}, "CVE-2007-5248": {"epss_score": 0.07808, "epss_percentile": 0.91693}, "CVE-2007-5249": {"epss_score": 0.01142, "epss_percentile": 0.77977}, "CVE-2007-5250": {"epss_score": 0.01048, "epss_percentile": 0.7705}, "CVE-2007-5251": {"epss_score": 0.00134, "epss_percentile": 0.33773}, "CVE-2007-5252": {"epss_score": 0.01131, "epss_percentile": 0.77861}, "CVE-2007-5253": {"epss_score": 0.10252, "epss_percentile": 0.92913}, "CVE-2007-5254": {"epss_score": 0.00034, "epss_percentile": 0.09685}, "CVE-2007-5255": {"epss_score": 0.08996, "epss_percentile": 0.92356}, "CVE-2007-5256": {"epss_score": 0.41658, "epss_percentile": 0.97288}, "CVE-2007-5257": {"epss_score": 0.15975, "epss_percentile": 0.94546}, "CVE-2007-5258": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2007-5259": {"epss_score": 0.00141, "epss_percentile": 0.34809}, "CVE-2007-5260": {"epss_score": 0.00252, "epss_percentile": 0.48371}, "CVE-2007-5261": {"epss_score": 0.0031, "epss_percentile": 0.5378}, "CVE-2007-5262": {"epss_score": 0.04132, "epss_percentile": 0.88301}, "CVE-2007-5263": {"epss_score": 0.04989, "epss_percentile": 0.89366}, "CVE-2007-5264": {"epss_score": 0.08616, "epss_percentile": 0.92154}, "CVE-2007-5265": {"epss_score": 0.12303, "epss_percentile": 0.93627}, "CVE-2007-5266": {"epss_score": 0.12913, "epss_percentile": 0.93815}, "CVE-2007-5267": {"epss_score": 0.0308, "epss_percentile": 0.8637}, "CVE-2007-5268": {"epss_score": 0.15258, "epss_percentile": 0.94393}, "CVE-2007-5269": {"epss_score": 0.10462, "epss_percentile": 0.92993}, "CVE-2007-5270": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2007-5271": {"epss_score": 0.1883, "epss_percentile": 0.95078}, "CVE-2007-5272": {"epss_score": 0.0047, "epss_percentile": 0.63984}, "CVE-2007-5273": {"epss_score": 0.06917, "epss_percentile": 0.91115}, "CVE-2007-5274": {"epss_score": 0.05089, "epss_percentile": 0.89481}, "CVE-2007-5275": {"epss_score": 0.37246, "epss_percentile": 0.9703}, "CVE-2007-5276": {"epss_score": 0.00265, "epss_percentile": 0.49833}, "CVE-2007-5277": {"epss_score": 0.11463, "epss_percentile": 0.93374}, "CVE-2007-5278": {"epss_score": 0.04492, "epss_percentile": 0.88759}, "CVE-2007-5279": {"epss_score": 0.18327, "epss_percentile": 0.94996}, "CVE-2007-5280": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-5281": {"epss_score": 0.00877, "epss_percentile": 0.74798}, "CVE-2007-5282": {"epss_score": 0.00621, "epss_percentile": 0.69487}, "CVE-2007-5283": {"epss_score": 0.00494, "epss_percentile": 0.65093}, "CVE-2007-5289": {"epss_score": 0.23209, "epss_percentile": 0.95751}, "CVE-2007-5290": {"epss_score": 0.02154, "epss_percentile": 0.83798}, "CVE-2007-5291": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-5292": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-5293": {"epss_score": 0.08543, "epss_percentile": 0.92113}, "CVE-2007-5294": {"epss_score": 0.05892, "epss_percentile": 0.903}, "CVE-2007-5295": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-5296": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-5297": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-5298": {"epss_score": 0.06211, "epss_percentile": 0.90569}, "CVE-2007-5299": {"epss_score": 0.07641, "epss_percentile": 0.91594}, "CVE-2007-5300": {"epss_score": 0.14593, "epss_percentile": 0.94248}, "CVE-2007-5301": {"epss_score": 0.43349, "epss_percentile": 0.97382}, "CVE-2007-5302": {"epss_score": 0.00602, "epss_percentile": 0.68876}, "CVE-2007-5303": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-5304": {"epss_score": 0.04918, "epss_percentile": 0.89289}, "CVE-2007-5305": {"epss_score": 0.05689, "epss_percentile": 0.90121}, "CVE-2007-5306": {"epss_score": 0.02445, "epss_percentile": 0.84765}, "CVE-2007-5307": {"epss_score": 0.03073, "epss_percentile": 0.86353}, "CVE-2007-5308": {"epss_score": 0.00855, "epss_percentile": 0.74468}, "CVE-2007-5309": {"epss_score": 0.0874, "epss_percentile": 0.92235}, "CVE-2007-5310": {"epss_score": 0.00168, "epss_percentile": 0.38506}, "CVE-2007-5311": {"epss_score": 0.08034, "epss_percentile": 0.91846}, "CVE-2007-5312": {"epss_score": 0.09817, "epss_percentile": 0.92715}, "CVE-2007-5313": {"epss_score": 0.03967, "epss_percentile": 0.88032}, "CVE-2007-5314": {"epss_score": 0.04603, "epss_percentile": 0.88905}, "CVE-2007-5315": {"epss_score": 0.57876, "epss_percentile": 0.98089}, "CVE-2007-5316": {"epss_score": 0.00894, "epss_percentile": 0.7509}, "CVE-2007-5318": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2007-5319": {"epss_score": 0.00602, "epss_percentile": 0.68892}, "CVE-2007-5320": {"epss_score": 0.05701, "epss_percentile": 0.90132}, "CVE-2007-5321": {"epss_score": 0.06986, "epss_percentile": 0.91162}, "CVE-2007-5322": {"epss_score": 0.34537, "epss_percentile": 0.96854}, "CVE-2007-5323": {"epss_score": 0.11842, "epss_percentile": 0.93493}, "CVE-2007-5325": {"epss_score": 0.19335, "epss_percentile": 0.95165}, "CVE-2007-5326": {"epss_score": 0.28647, "epss_percentile": 0.96374}, "CVE-2007-5327": {"epss_score": 0.32123, "epss_percentile": 0.96672}, "CVE-2007-5328": {"epss_score": 0.05551, "epss_percentile": 0.89987}, "CVE-2007-5329": {"epss_score": 0.01086, "epss_percentile": 0.77421}, "CVE-2007-5330": {"epss_score": 0.25023, "epss_percentile": 0.9598}, "CVE-2007-5331": {"epss_score": 0.18132, "epss_percentile": 0.94962}, "CVE-2007-5332": {"epss_score": 0.18474, "epss_percentile": 0.9502}, "CVE-2007-5333": {"epss_score": 0.81599, "epss_percentile": 0.99146}, "CVE-2007-5334": {"epss_score": 0.14921, "epss_percentile": 0.94324}, "CVE-2007-5335": {"epss_score": 0.00859, "epss_percentile": 0.74517}, "CVE-2007-5337": {"epss_score": 0.02126, "epss_percentile": 0.83692}, "CVE-2007-5338": {"epss_score": 0.04998, "epss_percentile": 0.89375}, "CVE-2007-5339": {"epss_score": 0.25185, "epss_percentile": 0.95995}, "CVE-2007-5340": {"epss_score": 0.18801, "epss_percentile": 0.95072}, "CVE-2007-5341": {"epss_score": 0.01625, "epss_percentile": 0.81417}, "CVE-2007-5342": {"epss_score": 0.18121, "epss_percentile": 0.9496}, "CVE-2007-5344": {"epss_score": 0.20763, "epss_percentile": 0.9541}, "CVE-2007-5347": {"epss_score": 0.46102, "epss_percentile": 0.97525}, "CVE-2007-5348": {"epss_score": 0.82835, "epss_percentile": 0.99217}, "CVE-2007-5350": {"epss_score": 0.00846, "epss_percentile": 0.74335}, "CVE-2007-5351": {"epss_score": 0.48048, "epss_percentile": 0.97615}, "CVE-2007-5352": {"epss_score": 0.02755, "epss_percentile": 0.85589}, "CVE-2007-5355": {"epss_score": 0.45342, "epss_percentile": 0.97482}, "CVE-2007-5358": {"epss_score": 0.02356, "epss_percentile": 0.84483}, "CVE-2007-5360": {"epss_score": 0.08733, "epss_percentile": 0.92232}, "CVE-2007-5361": {"epss_score": 0.02615, "epss_percentile": 0.85244}, "CVE-2007-5362": {"epss_score": 0.00182, "epss_percentile": 0.40264}, "CVE-2007-5363": {"epss_score": 0.00059, "epss_percentile": 0.18684}, "CVE-2007-5364": {"epss_score": 0.0064, "epss_percentile": 0.69963}, "CVE-2007-5365": {"epss_score": 0.43508, "epss_percentile": 0.9739}, "CVE-2007-5366": {"epss_score": 0.00205, "epss_percentile": 0.42702}, "CVE-2007-5367": {"epss_score": 0.00064, "epss_percentile": 0.20313}, "CVE-2007-5368": {"epss_score": 0.00064, "epss_percentile": 0.20313}, "CVE-2007-5369": {"epss_score": 0.01777, "epss_percentile": 0.82224}, "CVE-2007-5370": {"epss_score": 0.00761, "epss_percentile": 0.7282}, "CVE-2007-5371": {"epss_score": 0.0054, "epss_percentile": 0.66992}, "CVE-2007-5372": {"epss_score": 0.02713, "epss_percentile": 0.85504}, "CVE-2007-5373": {"epss_score": 0.00075, "epss_percentile": 0.22931}, "CVE-2007-5374": {"epss_score": 0.04593, "epss_percentile": 0.88894}, "CVE-2007-5375": {"epss_score": 0.00417, "epss_percentile": 0.61244}, "CVE-2007-5377": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2007-5378": {"epss_score": 0.01359, "epss_percentile": 0.79738}, "CVE-2007-5379": {"epss_score": 0.10596, "epss_percentile": 0.93041}, "CVE-2007-5380": {"epss_score": 0.05845, "epss_percentile": 0.90255}, "CVE-2007-5381": {"epss_score": 0.59529, "epss_percentile": 0.98169}, "CVE-2007-5382": {"epss_score": 0.02372, "epss_percentile": 0.84528}, "CVE-2007-5383": {"epss_score": 0.0208, "epss_percentile": 0.8353}, "CVE-2007-5384": {"epss_score": 0.00111, "epss_percentile": 0.30261}, "CVE-2007-5385": {"epss_score": 0.00407, "epss_percentile": 0.60613}, "CVE-2007-5386": {"epss_score": 0.11421, "epss_percentile": 0.93343}, "CVE-2007-5387": {"epss_score": 0.1883, "epss_percentile": 0.95078}, "CVE-2007-5388": {"epss_score": 0.51465, "epss_percentile": 0.97779}, "CVE-2007-5389": {"epss_score": 0.00063, "epss_percentile": 0.19933}, "CVE-2007-5390": {"epss_score": 0.05014, "epss_percentile": 0.89393}, "CVE-2007-5391": {"epss_score": 0.04102, "epss_percentile": 0.88261}, "CVE-2007-5392": {"epss_score": 0.05195, "epss_percentile": 0.89599}, "CVE-2007-5393": {"epss_score": 0.11517, "epss_percentile": 0.9339}, "CVE-2007-5394": {"epss_score": 0.13133, "epss_percentile": 0.93882}, "CVE-2007-5395": {"epss_score": 0.09437, "epss_percentile": 0.92547}, "CVE-2007-5396": {"epss_score": 0.0264, "epss_percentile": 0.85302}, "CVE-2007-5397": {"epss_score": 0.02695, "epss_percentile": 0.85443}, "CVE-2007-5398": {"epss_score": 0.40715, "epss_percentile": 0.97235}, "CVE-2007-5399": {"epss_score": 0.27461, "epss_percentile": 0.96247}, "CVE-2007-5400": {"epss_score": 0.2762, "epss_percentile": 0.96264}, "CVE-2007-5401": {"epss_score": 0.00498, "epss_percentile": 0.65242}, "CVE-2007-5402": {"epss_score": 0.0039, "epss_percentile": 0.59504}, "CVE-2007-5403": {"epss_score": 0.00397, "epss_percentile": 0.59964}, "CVE-2007-5404": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2007-5405": {"epss_score": 0.34744, "epss_percentile": 0.96872}, "CVE-2007-5406": {"epss_score": 0.25808, "epss_percentile": 0.96074}, "CVE-2007-5407": {"epss_score": 0.29349, "epss_percentile": 0.96435}, "CVE-2007-5408": {"epss_score": 0.0047, "epss_percentile": 0.63984}, "CVE-2007-5409": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-5410": {"epss_score": 0.00329, "epss_percentile": 0.55382}, "CVE-2007-5411": {"epss_score": 0.01302, "epss_percentile": 0.79298}, "CVE-2007-5412": {"epss_score": 0.20626, "epss_percentile": 0.95388}, "CVE-2007-5413": {"epss_score": 0.00776, "epss_percentile": 0.731}, "CVE-2007-5414": {"epss_score": 0.00278, "epss_percentile": 0.50885}, "CVE-2007-5415": {"epss_score": 0.00246, "epss_percentile": 0.47789}, "CVE-2007-5416": {"epss_score": 0.05769, "epss_percentile": 0.9019}, "CVE-2007-5417": {"epss_score": 0.05298, "epss_percentile": 0.89704}, "CVE-2007-5418": {"epss_score": 0.0451, "epss_percentile": 0.8878}, "CVE-2007-5419": {"epss_score": 0.00771, "epss_percentile": 0.73025}, "CVE-2007-5420": {"epss_score": 0.00556, "epss_percentile": 0.67505}, "CVE-2007-5422": {"epss_score": 0.00058, "epss_percentile": 0.18594}, "CVE-2007-5423": {"epss_score": 0.88077, "epss_percentile": 0.99457}, "CVE-2007-5424": {"epss_score": 0.00323, "epss_percentile": 0.54909}, "CVE-2007-5425": {"epss_score": 0.00497, "epss_percentile": 0.65198}, "CVE-2007-5426": {"epss_score": 0.0246, "epss_percentile": 0.8482}, "CVE-2007-5427": {"epss_score": 0.00393, "epss_percentile": 0.59714}, "CVE-2007-5428": {"epss_score": 0.01599, "epss_percentile": 0.81252}, "CVE-2007-5429": {"epss_score": 0.00606, "epss_percentile": 0.69}, "CVE-2007-5430": {"epss_score": 0.02207, "epss_percentile": 0.84004}, "CVE-2007-5431": {"epss_score": 0.00343, "epss_percentile": 0.56446}, "CVE-2007-5432": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2007-5433": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-5434": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-5435": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2007-5436": {"epss_score": 0.05713, "epss_percentile": 0.90143}, "CVE-2007-5437": {"epss_score": 0.00219, "epss_percentile": 0.44494}, "CVE-2007-5438": {"epss_score": 0.001, "epss_percentile": 0.28474}, "CVE-2007-5439": {"epss_score": 0.00541, "epss_percentile": 0.6706}, "CVE-2007-5440": {"epss_score": 0.08047, "epss_percentile": 0.91852}, "CVE-2007-5441": {"epss_score": 0.00377, "epss_percentile": 0.58707}, "CVE-2007-5442": {"epss_score": 0.00142, "epss_percentile": 0.34955}, "CVE-2007-5443": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-5444": {"epss_score": 0.00309, "epss_percentile": 0.53666}, "CVE-2007-5445": {"epss_score": 0.0284, "epss_percentile": 0.85798}, "CVE-2007-5446": {"epss_score": 0.02006, "epss_percentile": 0.83233}, "CVE-2007-5447": {"epss_score": 0.03366, "epss_percentile": 0.87003}, "CVE-2007-5448": {"epss_score": 0.0245, "epss_percentile": 0.84781}, "CVE-2007-5449": {"epss_score": 0.0047, "epss_percentile": 0.63984}, "CVE-2007-5450": {"epss_score": 0.02749, "epss_percentile": 0.85578}, "CVE-2007-5451": {"epss_score": 0.00117, "epss_percentile": 0.31264}, "CVE-2007-5452": {"epss_score": 0.00287, "epss_percentile": 0.51848}, "CVE-2007-5453": {"epss_score": 0.10705, "epss_percentile": 0.93076}, "CVE-2007-5454": {"epss_score": 0.0017, "epss_percentile": 0.38724}, "CVE-2007-5455": {"epss_score": 0.03651, "epss_percentile": 0.87509}, "CVE-2007-5456": {"epss_score": 0.10594, "epss_percentile": 0.9304}, "CVE-2007-5457": {"epss_score": 0.00282, "epss_percentile": 0.51218}, "CVE-2007-5458": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-5459": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-5460": {"epss_score": 0.01027, "epss_percentile": 0.76805}, "CVE-2007-5461": {"epss_score": 0.06267, "epss_percentile": 0.90624}, "CVE-2007-5462": {"epss_score": 0.02532, "epss_percentile": 0.85029}, "CVE-2007-5463": {"epss_score": 0.00154, "epss_percentile": 0.36703}, "CVE-2007-5464": {"epss_score": 0.12847, "epss_percentile": 0.93801}, "CVE-2007-5465": {"epss_score": 0.03721, "epss_percentile": 0.8762}, "CVE-2007-5466": {"epss_score": 0.56846, "epss_percentile": 0.98038}, "CVE-2007-5467": {"epss_score": 0.17977, "epss_percentile": 0.94936}, "CVE-2007-5468": {"epss_score": 0.00736, "epss_percentile": 0.723}, "CVE-2007-5469": {"epss_score": 0.00811, "epss_percentile": 0.73728}, "CVE-2007-5470": {"epss_score": 0.01254, "epss_percentile": 0.7892}, "CVE-2007-5471": {"epss_score": 0.00817, "epss_percentile": 0.73845}, "CVE-2007-5472": {"epss_score": 0.00701, "epss_percentile": 0.71498}, "CVE-2007-5473": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-5474": {"epss_score": 0.01425, "epss_percentile": 0.80198}, "CVE-2007-5475": {"epss_score": 0.01244, "epss_percentile": 0.78832}, "CVE-2007-5476": {"epss_score": 0.20643, "epss_percentile": 0.95393}, "CVE-2007-5477": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2007-5478": {"epss_score": 0.01599, "epss_percentile": 0.81252}, "CVE-2007-5479": {"epss_score": 0.00278, "epss_percentile": 0.50885}, "CVE-2007-5480": {"epss_score": 0.01787, "epss_percentile": 0.8226}, "CVE-2007-5481": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2007-5482": {"epss_score": 0.01243, "epss_percentile": 0.7883}, "CVE-2007-5483": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2007-5484": {"epss_score": 0.01392, "epss_percentile": 0.79961}, "CVE-2007-5485": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-5486": {"epss_score": 0.00381, "epss_percentile": 0.59027}, "CVE-2007-5487": {"epss_score": 0.22179, "epss_percentile": 0.95604}, "CVE-2007-5488": {"epss_score": 0.0089, "epss_percentile": 0.7503}, "CVE-2007-5489": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2007-5490": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-5491": {"epss_score": 0.01055, "epss_percentile": 0.77113}, "CVE-2007-5492": {"epss_score": 0.01587, "epss_percentile": 0.81184}, "CVE-2007-5493": {"epss_score": 0.25621, "epss_percentile": 0.96051}, "CVE-2007-5494": {"epss_score": 0.0009, "epss_percentile": 0.26168}, "CVE-2007-5495": {"epss_score": 0.00036, "epss_percentile": 0.10386}, "CVE-2007-5496": {"epss_score": 0.00069, "epss_percentile": 0.21565}, "CVE-2007-5497": {"epss_score": 0.07368, "epss_percentile": 0.91438}, "CVE-2007-5498": {"epss_score": 0.0005, "epss_percentile": 0.15773}, "CVE-2007-5500": {"epss_score": 0.00081, "epss_percentile": 0.24315}, "CVE-2007-5501": {"epss_score": 0.07483, "epss_percentile": 0.91497}, "CVE-2007-5502": {"epss_score": 0.00381, "epss_percentile": 0.58984}, "CVE-2007-5503": {"epss_score": 0.10388, "epss_percentile": 0.9297}, "CVE-2007-5504": {"epss_score": 0.04129, "epss_percentile": 0.88295}, "CVE-2007-5505": {"epss_score": 0.00864, "epss_percentile": 0.74608}, "CVE-2007-5506": {"epss_score": 0.06217, "epss_percentile": 0.90575}, "CVE-2007-5507": {"epss_score": 0.0506, "epss_percentile": 0.89452}, "CVE-2007-5508": {"epss_score": 0.01698, "epss_percentile": 0.8182}, "CVE-2007-5509": {"epss_score": 0.00654, "epss_percentile": 0.70342}, "CVE-2007-5510": {"epss_score": 0.00854, "epss_percentile": 0.74446}, "CVE-2007-5511": {"epss_score": 0.63711, "epss_percentile": 0.98346}, "CVE-2007-5512": {"epss_score": 0.00864, "epss_percentile": 0.74608}, "CVE-2007-5513": {"epss_score": 0.01331, "epss_percentile": 0.79519}, "CVE-2007-5514": {"epss_score": 0.01611, "epss_percentile": 0.81329}, "CVE-2007-5515": {"epss_score": 0.00854, "epss_percentile": 0.74446}, "CVE-2007-5516": {"epss_score": 0.00772, "epss_percentile": 0.73041}, "CVE-2007-5517": {"epss_score": 0.00772, "epss_percentile": 0.73041}, "CVE-2007-5518": {"epss_score": 0.00772, "epss_percentile": 0.73041}, "CVE-2007-5519": {"epss_score": 0.00772, "epss_percentile": 0.73041}, "CVE-2007-5520": {"epss_score": 0.00864, "epss_percentile": 0.74608}, "CVE-2007-5521": {"epss_score": 0.00772, "epss_percentile": 0.73041}, "CVE-2007-5522": {"epss_score": 0.00772, "epss_percentile": 0.73041}, "CVE-2007-5523": {"epss_score": 0.00772, "epss_percentile": 0.73041}, "CVE-2007-5524": {"epss_score": 0.00772, "epss_percentile": 0.73041}, "CVE-2007-5525": {"epss_score": 0.00772, "epss_percentile": 0.73041}, "CVE-2007-5526": {"epss_score": 0.01124, "epss_percentile": 0.77795}, "CVE-2007-5527": {"epss_score": 0.00772, "epss_percentile": 0.73041}, "CVE-2007-5528": {"epss_score": 0.01124, "epss_percentile": 0.77795}, "CVE-2007-5529": {"epss_score": 0.00772, "epss_percentile": 0.73041}, "CVE-2007-5530": {"epss_score": 0.01124, "epss_percentile": 0.77795}, "CVE-2007-5531": {"epss_score": 0.02129, "epss_percentile": 0.83707}, "CVE-2007-5532": {"epss_score": 0.0144, "epss_percentile": 0.80301}, "CVE-2007-5533": {"epss_score": 0.01657, "epss_percentile": 0.81603}, "CVE-2007-5534": {"epss_score": 0.01104, "epss_percentile": 0.77596}, "CVE-2007-5535": {"epss_score": 0.00391, "epss_percentile": 0.5956}, "CVE-2007-5536": {"epss_score": 0.0005, "epss_percentile": 0.15736}, "CVE-2007-5537": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2007-5538": {"epss_score": 0.07505, "epss_percentile": 0.91509}, "CVE-2007-5539": {"epss_score": 0.01308, "epss_percentile": 0.79347}, "CVE-2007-5540": {"epss_score": 0.00924, "epss_percentile": 0.75521}, "CVE-2007-5541": {"epss_score": 0.03438, "epss_percentile": 0.87136}, "CVE-2007-5542": {"epss_score": 0.04817, "epss_percentile": 0.89172}, "CVE-2007-5543": {"epss_score": 0.04817, "epss_percentile": 0.89172}, "CVE-2007-5544": {"epss_score": 0.00089, "epss_percentile": 0.25832}, "CVE-2007-5545": {"epss_score": 0.02114, "epss_percentile": 0.83653}, "CVE-2007-5546": {"epss_score": 0.02749, "epss_percentile": 0.85579}, "CVE-2007-5547": {"epss_score": 0.00192, "epss_percentile": 0.41293}, "CVE-2007-5548": {"epss_score": 0.00068, "epss_percentile": 0.21389}, "CVE-2007-5549": {"epss_score": 0.00072, "epss_percentile": 0.22242}, "CVE-2007-5550": {"epss_score": 0.00437, "epss_percentile": 0.62499}, "CVE-2007-5551": {"epss_score": 0.02368, "epss_percentile": 0.84521}, "CVE-2007-5552": {"epss_score": 0.01883, "epss_percentile": 0.82697}, "CVE-2007-5554": {"epss_score": 0.0022, "epss_percentile": 0.44559}, "CVE-2007-5555": {"epss_score": 0.00058, "epss_percentile": 0.18475}, "CVE-2007-5556": {"epss_score": 0.00501, "epss_percentile": 0.65344}, "CVE-2007-5557": {"epss_score": 0.00501, "epss_percentile": 0.65344}, "CVE-2007-5558": {"epss_score": 0.01849, "epss_percentile": 0.82533}, "CVE-2007-5559": {"epss_score": 0.07701, "epss_percentile": 0.91635}, "CVE-2007-5560": {"epss_score": 0.04915, "epss_percentile": 0.89284}, "CVE-2007-5561": {"epss_score": 0.03651, "epss_percentile": 0.87509}, "CVE-2007-5562": {"epss_score": 0.0246, "epss_percentile": 0.8482}, "CVE-2007-5563": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2007-5564": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-5565": {"epss_score": 0.0068, "epss_percentile": 0.71038}, "CVE-2007-5566": {"epss_score": 0.00695, "epss_percentile": 0.71365}, "CVE-2007-5567": {"epss_score": 0.01759, "epss_percentile": 0.82141}, "CVE-2007-5568": {"epss_score": 0.03355, "epss_percentile": 0.86972}, "CVE-2007-5569": {"epss_score": 0.0134, "epss_percentile": 0.79575}, "CVE-2007-5570": {"epss_score": 0.02105, "epss_percentile": 0.83622}, "CVE-2007-5571": {"epss_score": 0.0054, "epss_percentile": 0.67013}, "CVE-2007-5572": {"epss_score": 0.00179, "epss_percentile": 0.39801}, "CVE-2007-5573": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-5574": {"epss_score": 0.1883, "epss_percentile": 0.95078}, "CVE-2007-5575": {"epss_score": 0.00124, "epss_percentile": 0.32462}, "CVE-2007-5576": {"epss_score": 0.00602, "epss_percentile": 0.68889}, "CVE-2007-5577": {"epss_score": 0.00043, "epss_percentile": 0.12968}, "CVE-2007-5578": {"epss_score": 0.00702, "epss_percentile": 0.71525}, "CVE-2007-5579": {"epss_score": 0.02682, "epss_percentile": 0.8542}, "CVE-2007-5580": {"epss_score": 0.16473, "epss_percentile": 0.94674}, "CVE-2007-5581": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2007-5582": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2007-5583": {"epss_score": 0.30123, "epss_percentile": 0.96512}, "CVE-2007-5584": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2007-5585": {"epss_score": 0.00348, "epss_percentile": 0.56831}, "CVE-2007-5587": {"epss_score": 0.00155, "epss_percentile": 0.3677}, "CVE-2007-5588": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-5589": {"epss_score": 0.11421, "epss_percentile": 0.93343}, "CVE-2007-5590": {"epss_score": 0.10948, "epss_percentile": 0.93171}, "CVE-2007-5591": {"epss_score": 0.02615, "epss_percentile": 0.85244}, "CVE-2007-5592": {"epss_score": 0.1883, "epss_percentile": 0.95078}, "CVE-2007-5593": {"epss_score": 0.02505, "epss_percentile": 0.84936}, "CVE-2007-5594": {"epss_score": 0.00507, "epss_percentile": 0.65677}, "CVE-2007-5595": {"epss_score": 0.02571, "epss_percentile": 0.85131}, "CVE-2007-5596": {"epss_score": 0.00576, "epss_percentile": 0.68135}, "CVE-2007-5597": {"epss_score": 0.0055, "epss_percentile": 0.67329}, "CVE-2007-5598": {"epss_score": 0.00625, "epss_percentile": 0.69586}, "CVE-2007-5599": {"epss_score": 0.00579, "epss_percentile": 0.68221}, "CVE-2007-5600": {"epss_score": 0.02734, "epss_percentile": 0.85548}, "CVE-2007-5601": {"epss_score": 0.70423, "epss_percentile": 0.98631}, "CVE-2007-5602": {"epss_score": 0.29807, "epss_percentile": 0.96477}, "CVE-2007-5603": {"epss_score": 0.72859, "epss_percentile": 0.98726}, "CVE-2007-5604": {"epss_score": 0.33633, "epss_percentile": 0.96789}, "CVE-2007-5605": {"epss_score": 0.23233, "epss_percentile": 0.95755}, "CVE-2007-5606": {"epss_score": 0.28672, "epss_percentile": 0.96376}, "CVE-2007-5607": {"epss_score": 0.3286, "epss_percentile": 0.96731}, "CVE-2007-5608": {"epss_score": 0.03293, "epss_percentile": 0.86843}, "CVE-2007-5610": {"epss_score": 0.14685, "epss_percentile": 0.94264}, "CVE-2007-5612": {"epss_score": 0.02984, "epss_percentile": 0.86127}, "CVE-2007-5613": {"epss_score": 0.05189, "epss_percentile": 0.89592}, "CVE-2007-5614": {"epss_score": 0.03491, "epss_percentile": 0.87232}, "CVE-2007-5615": {"epss_score": 0.03975, "epss_percentile": 0.88047}, "CVE-2007-5616": {"epss_score": 0.00155, "epss_percentile": 0.36774}, "CVE-2007-5617": {"epss_score": 0.00978, "epss_percentile": 0.76244}, "CVE-2007-5618": {"epss_score": 0.00051, "epss_percentile": 0.16334}, "CVE-2007-5619": {"epss_score": 0.00032, "epss_percentile": 0.09}, "CVE-2007-5620": {"epss_score": 0.03084, "epss_percentile": 0.86376}, "CVE-2007-5621": {"epss_score": 0.00175, "epss_percentile": 0.39348}, "CVE-2007-5622": {"epss_score": 0.01846, "epss_percentile": 0.82512}, "CVE-2007-5623": {"epss_score": 0.00926, "epss_percentile": 0.75552}, "CVE-2007-5624": {"epss_score": 0.00337, "epss_percentile": 0.56025}, "CVE-2007-5625": {"epss_score": 0.06045, "epss_percentile": 0.90432}, "CVE-2007-5626": {"epss_score": 0.00036, "epss_percentile": 0.10393}, "CVE-2007-5627": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-5628": {"epss_score": 0.18589, "epss_percentile": 0.95038}, "CVE-2007-5629": {"epss_score": 0.0055, "epss_percentile": 0.67339}, "CVE-2007-5630": {"epss_score": 0.00576, "epss_percentile": 0.68131}, "CVE-2007-5631": {"epss_score": 0.17008, "epss_percentile": 0.9476}, "CVE-2007-5632": {"epss_score": 0.0006, "epss_percentile": 0.19017}, "CVE-2007-5633": {"epss_score": 0.00121, "epss_percentile": 0.31958}, "CVE-2007-5634": {"epss_score": 0.00054, "epss_percentile": 0.17268}, "CVE-2007-5635": {"epss_score": 0.00461, "epss_percentile": 0.63555}, "CVE-2007-5636": {"epss_score": 0.21751, "epss_percentile": 0.95555}, "CVE-2007-5637": {"epss_score": 0.10654, "epss_percentile": 0.93059}, "CVE-2007-5638": {"epss_score": 0.00631, "epss_percentile": 0.69734}, "CVE-2007-5639": {"epss_score": 0.01265, "epss_percentile": 0.79}, "CVE-2007-5640": {"epss_score": 0.01172, "epss_percentile": 0.78232}, "CVE-2007-5641": {"epss_score": 0.19527, "epss_percentile": 0.952}, "CVE-2007-5642": {"epss_score": 0.14109, "epss_percentile": 0.94134}, "CVE-2007-5643": {"epss_score": 0.00949, "epss_percentile": 0.75846}, "CVE-2007-5644": {"epss_score": 0.04305, "epss_percentile": 0.8852}, "CVE-2007-5646": {"epss_score": 0.01676, "epss_percentile": 0.81707}, "CVE-2007-5647": {"epss_score": 0.02126, "epss_percentile": 0.83696}, "CVE-2007-5648": {"epss_score": 0.01302, "epss_percentile": 0.79298}, "CVE-2007-5649": {"epss_score": 0.0231, "epss_percentile": 0.84334}, "CVE-2007-5650": {"epss_score": 0.02081, "epss_percentile": 0.83534}, "CVE-2007-5651": {"epss_score": 0.01189, "epss_percentile": 0.78373}, "CVE-2007-5652": {"epss_score": 0.0097, "epss_percentile": 0.76116}, "CVE-2007-5653": {"epss_score": 0.0304, "epss_percentile": 0.86272}, "CVE-2007-5654": {"epss_score": 0.59125, "epss_percentile": 0.98151}, "CVE-2007-5655": {"epss_score": 0.1781, "epss_percentile": 0.94909}, "CVE-2007-5656": {"epss_score": 0.11214, "epss_percentile": 0.93268}, "CVE-2007-5657": {"epss_score": 0.11474, "epss_percentile": 0.93378}, "CVE-2007-5658": {"epss_score": 0.15936, "epss_percentile": 0.94539}, "CVE-2007-5659": {"epss_score": 0.93512, "epss_percentile": 0.99812}, "CVE-2007-5660": {"epss_score": 0.66561, "epss_percentile": 0.98468}, "CVE-2007-5661": {"epss_score": 0.01868, "epss_percentile": 0.82623}, "CVE-2007-5663": {"epss_score": 0.40716, "epss_percentile": 0.97235}, "CVE-2007-5664": {"epss_score": 0.00027, "epss_percentile": 0.06923}, "CVE-2007-5665": {"epss_score": 0.00045, "epss_percentile": 0.13906}, "CVE-2007-5666": {"epss_score": 0.00308, "epss_percentile": 0.53641}, "CVE-2007-5667": {"epss_score": 0.00035, "epss_percentile": 0.09812}, "CVE-2007-5671": {"epss_score": 0.00116, "epss_percentile": 0.31147}, "CVE-2007-5673": {"epss_score": 0.00351, "epss_percentile": 0.57068}, "CVE-2007-5674": {"epss_score": 0.05029, "epss_percentile": 0.89412}, "CVE-2007-5675": {"epss_score": 0.03029, "epss_percentile": 0.86243}, "CVE-2007-5676": {"epss_score": 0.029, "epss_percentile": 0.85953}, "CVE-2007-5677": {"epss_score": 0.01302, "epss_percentile": 0.79298}, "CVE-2007-5678": {"epss_score": 0.00511, "epss_percentile": 0.65835}, "CVE-2007-5679": {"epss_score": 0.01033, "epss_percentile": 0.76881}, "CVE-2007-5682": {"epss_score": 0.02088, "epss_percentile": 0.83558}, "CVE-2007-5683": {"epss_score": 0.00246, "epss_percentile": 0.47789}, "CVE-2007-5684": {"epss_score": 0.01935, "epss_percentile": 0.82956}, "CVE-2007-5685": {"epss_score": 0.05584, "epss_percentile": 0.90023}, "CVE-2007-5686": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2007-5687": {"epss_score": 0.17528, "epss_percentile": 0.94862}, "CVE-2007-5688": {"epss_score": 0.0037, "epss_percentile": 0.58306}, "CVE-2007-5689": {"epss_score": 0.09816, "epss_percentile": 0.92714}, "CVE-2007-5690": {"epss_score": 0.00051, "epss_percentile": 0.16047}, "CVE-2007-5691": {"epss_score": 0.00632, "epss_percentile": 0.69746}, "CVE-2007-5692": {"epss_score": 0.05279, "epss_percentile": 0.89686}, "CVE-2007-5693": {"epss_score": 0.07585, "epss_percentile": 0.91555}, "CVE-2007-5694": {"epss_score": 0.07229, "epss_percentile": 0.91336}, "CVE-2007-5695": {"epss_score": 0.00887, "epss_percentile": 0.7497}, "CVE-2007-5696": {"epss_score": 0.005, "epss_percentile": 0.6533}, "CVE-2007-5697": {"epss_score": 0.04521, "epss_percentile": 0.888}, "CVE-2007-5698": {"epss_score": 0.00324, "epss_percentile": 0.54956}, "CVE-2007-5699": {"epss_score": 0.19653, "epss_percentile": 0.95221}, "CVE-2007-5700": {"epss_score": 0.00331, "epss_percentile": 0.55543}, "CVE-2007-5701": {"epss_score": 0.00054, "epss_percentile": 0.1722}, "CVE-2007-5702": {"epss_score": 0.0092, "epss_percentile": 0.75472}, "CVE-2007-5703": {"epss_score": 0.02712, "epss_percentile": 0.85499}, "CVE-2007-5704": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2007-5705": {"epss_score": 0.00496, "epss_percentile": 0.65168}, "CVE-2007-5706": {"epss_score": 0.0232, "epss_percentile": 0.84366}, "CVE-2007-5707": {"epss_score": 0.05435, "epss_percentile": 0.8988}, "CVE-2007-5708": {"epss_score": 0.02872, "epss_percentile": 0.85875}, "CVE-2007-5709": {"epss_score": 0.10732, "epss_percentile": 0.93086}, "CVE-2007-5710": {"epss_score": 0.03134, "epss_percentile": 0.86477}, "CVE-2007-5711": {"epss_score": 0.01288, "epss_percentile": 0.79205}, "CVE-2007-5712": {"epss_score": 0.01815, "epss_percentile": 0.82384}, "CVE-2007-5713": {"epss_score": 0.00921, "epss_percentile": 0.75479}, "CVE-2007-5714": {"epss_score": 0.01352, "epss_percentile": 0.79685}, "CVE-2007-5715": {"epss_score": 0.003, "epss_percentile": 0.52919}, "CVE-2007-5716": {"epss_score": 0.01371, "epss_percentile": 0.79806}, "CVE-2007-5717": {"epss_score": 0.04528, "epss_percentile": 0.88808}, "CVE-2007-5718": {"epss_score": 0.00033, "epss_percentile": 0.09371}, "CVE-2007-5719": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-5720": {"epss_score": 0.04515, "epss_percentile": 0.8879}, "CVE-2007-5721": {"epss_score": 0.03564, "epss_percentile": 0.87358}, "CVE-2007-5722": {"epss_score": 0.06818, "epss_percentile": 0.91045}, "CVE-2007-5723": {"epss_score": 0.00796, "epss_percentile": 0.7348}, "CVE-2007-5724": {"epss_score": 0.02461, "epss_percentile": 0.84826}, "CVE-2007-5725": {"epss_score": 0.01302, "epss_percentile": 0.79298}, "CVE-2007-5726": {"epss_score": 0.01329, "epss_percentile": 0.79505}, "CVE-2007-5727": {"epss_score": 0.00532, "epss_percentile": 0.667}, "CVE-2007-5728": {"epss_score": 0.00523, "epss_percentile": 0.66302}, "CVE-2007-5729": {"epss_score": 0.00145, "epss_percentile": 0.35375}, "CVE-2007-5730": {"epss_score": 0.00143, "epss_percentile": 0.35112}, "CVE-2007-5731": {"epss_score": 0.13005, "epss_percentile": 0.93844}, "CVE-2007-5732": {"epss_score": 0.00095, "epss_percentile": 0.27108}, "CVE-2007-5733": {"epss_score": 0.03073, "epss_percentile": 0.86353}, "CVE-2007-5734": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2007-5735": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2007-5736": {"epss_score": 0.00567, "epss_percentile": 0.67849}, "CVE-2007-5737": {"epss_score": 0.03073, "epss_percentile": 0.86353}, "CVE-2007-5738": {"epss_score": 0.00286, "epss_percentile": 0.51754}, "CVE-2007-5739": {"epss_score": 0.0225, "epss_percentile": 0.84157}, "CVE-2007-5740": {"epss_score": 0.24314, "epss_percentile": 0.95902}, "CVE-2007-5741": {"epss_score": 0.03388, "epss_percentile": 0.87045}, "CVE-2007-5742": {"epss_score": 0.01496, "epss_percentile": 0.80682}, "CVE-2007-5743": {"epss_score": 0.00346, "epss_percentile": 0.56628}, "CVE-2007-5745": {"epss_score": 0.06455, "epss_percentile": 0.90767}, "CVE-2007-5746": {"epss_score": 0.07722, "epss_percentile": 0.91643}, "CVE-2007-5747": {"epss_score": 0.0577, "epss_percentile": 0.90192}, "CVE-2007-5751": {"epss_score": 0.00053, "epss_percentile": 0.16841}, "CVE-2007-5752": {"epss_score": 0.02359, "epss_percentile": 0.84492}, "CVE-2007-5753": {"epss_score": 0.00628, "epss_percentile": 0.69649}, "CVE-2007-5754": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-5755": {"epss_score": 0.55963, "epss_percentile": 0.98004}, "CVE-2007-5756": {"epss_score": 0.00043, "epss_percentile": 0.13136}, "CVE-2007-5757": {"epss_score": 0.00058, "epss_percentile": 0.18566}, "CVE-2007-5758": {"epss_score": 0.00074, "epss_percentile": 0.2271}, "CVE-2007-5760": {"epss_score": 0.03922, "epss_percentile": 0.87954}, "CVE-2007-5761": {"epss_score": 0.00046, "epss_percentile": 0.14473}, "CVE-2007-5762": {"epss_score": 0.00477, "epss_percentile": 0.64352}, "CVE-2007-5764": {"epss_score": 0.0007, "epss_percentile": 0.2183}, "CVE-2007-5766": {"epss_score": 0.0041, "epss_percentile": 0.60807}, "CVE-2007-5767": {"epss_score": 0.30839, "epss_percentile": 0.96571}, "CVE-2007-5768": {"epss_score": 0.00273, "epss_percentile": 0.50482}, "CVE-2007-5769": {"epss_score": 0.00489, "epss_percentile": 0.64908}, "CVE-2007-5770": {"epss_score": 0.07265, "epss_percentile": 0.91359}, "CVE-2007-5771": {"epss_score": 0.05121, "epss_percentile": 0.8952}, "CVE-2007-5772": {"epss_score": 0.03277, "epss_percentile": 0.86807}, "CVE-2007-5773": {"epss_score": 0.00562, "epss_percentile": 0.67699}, "CVE-2007-5774": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2007-5775": {"epss_score": 0.07636, "epss_percentile": 0.91591}, "CVE-2007-5776": {"epss_score": 0.03587, "epss_percentile": 0.87393}, "CVE-2007-5777": {"epss_score": 0.00284, "epss_percentile": 0.51496}, "CVE-2007-5778": {"epss_score": 0.00226, "epss_percentile": 0.453}, "CVE-2007-5779": {"epss_score": 0.81828, "epss_percentile": 0.9916}, "CVE-2007-5780": {"epss_score": 0.03967, "epss_percentile": 0.88032}, "CVE-2007-5781": {"epss_score": 0.57876, "epss_percentile": 0.98089}, "CVE-2007-5782": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2007-5783": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-5784": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-5785": {"epss_score": 0.0047, "epss_percentile": 0.63984}, "CVE-2007-5786": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-5787": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2007-5788": {"epss_score": 0.00673, "epss_percentile": 0.70835}, "CVE-2007-5789": {"epss_score": 0.00725, "epss_percentile": 0.72051}, "CVE-2007-5790": {"epss_score": 0.00068, "epss_percentile": 0.21414}, "CVE-2007-5791": {"epss_score": 0.03647, "epss_percentile": 0.87503}, "CVE-2007-5792": {"epss_score": 0.00316, "epss_percentile": 0.54295}, "CVE-2007-5793": {"epss_score": 0.04108, "epss_percentile": 0.88268}, "CVE-2007-5794": {"epss_score": 0.01491, "epss_percentile": 0.80632}, "CVE-2007-5795": {"epss_score": 0.01141, "epss_percentile": 0.7796}, "CVE-2007-5796": {"epss_score": 0.00395, "epss_percentile": 0.59847}, "CVE-2007-5797": {"epss_score": 0.00709, "epss_percentile": 0.71687}, "CVE-2007-5798": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2007-5799": {"epss_score": 0.002, "epss_percentile": 0.42274}, "CVE-2007-5800": {"epss_score": 0.05891, "epss_percentile": 0.90299}, "CVE-2007-5801": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2007-5802": {"epss_score": 0.22672, "epss_percentile": 0.95667}, "CVE-2007-5803": {"epss_score": 0.0048, "epss_percentile": 0.64467}, "CVE-2007-5804": {"epss_score": 0.0005, "epss_percentile": 0.15876}, "CVE-2007-5805": {"epss_score": 0.00027, "epss_percentile": 0.07137}, "CVE-2007-5806": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2007-5807": {"epss_score": 0.02638, "epss_percentile": 0.85298}, "CVE-2007-5808": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2007-5809": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2007-5810": {"epss_score": 0.00215, "epss_percentile": 0.44088}, "CVE-2007-5811": {"epss_score": 0.0022, "epss_percentile": 0.44593}, "CVE-2007-5812": {"epss_score": 0.01833, "epss_percentile": 0.8246}, "CVE-2007-5813": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2007-5814": {"epss_score": 0.07088, "epss_percentile": 0.91242}, "CVE-2007-5815": {"epss_score": 0.05719, "epss_percentile": 0.90149}, "CVE-2007-5816": {"epss_score": 0.03663, "epss_percentile": 0.8753}, "CVE-2007-5817": {"epss_score": 0.00353, "epss_percentile": 0.57168}, "CVE-2007-5818": {"epss_score": 0.00391, "epss_percentile": 0.59559}, "CVE-2007-5819": {"epss_score": 0.00047, "epss_percentile": 0.14882}, "CVE-2007-5820": {"epss_score": 0.02181, "epss_percentile": 0.83903}, "CVE-2007-5821": {"epss_score": 0.08116, "epss_percentile": 0.91888}, "CVE-2007-5822": {"epss_score": 0.10493, "epss_percentile": 0.93008}, "CVE-2007-5823": {"epss_score": 0.03842, "epss_percentile": 0.87833}, "CVE-2007-5824": {"epss_score": 0.15137, "epss_percentile": 0.94371}, "CVE-2007-5825": {"epss_score": 0.05053, "epss_percentile": 0.89442}, "CVE-2007-5826": {"epss_score": 0.05464, "epss_percentile": 0.89902}, "CVE-2007-5827": {"epss_score": 0.00053, "epss_percentile": 0.16725}, "CVE-2007-5828": {"epss_score": 0.00269, "epss_percentile": 0.50187}, "CVE-2007-5829": {"epss_score": 0.00049, "epss_percentile": 0.15473}, "CVE-2007-5830": {"epss_score": 0.0066, "epss_percentile": 0.7052}, "CVE-2007-5831": {"epss_score": 0.0011, "epss_percentile": 0.30101}, "CVE-2007-5832": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2007-5833": {"epss_score": 0.00173, "epss_percentile": 0.39122}, "CVE-2007-5834": {"epss_score": 0.00278, "epss_percentile": 0.50885}, "CVE-2007-5835": {"epss_score": 0.0074, "epss_percentile": 0.72405}, "CVE-2007-5836": {"epss_score": 0.00343, "epss_percentile": 0.56442}, "CVE-2007-5837": {"epss_score": 0.08275, "epss_percentile": 0.91964}, "CVE-2007-5838": {"epss_score": 0.0003, "epss_percentile": 0.08302}, "CVE-2007-5839": {"epss_score": 0.00034, "epss_percentile": 0.09714}, "CVE-2007-5840": {"epss_score": 0.05293, "epss_percentile": 0.89699}, "CVE-2007-5841": {"epss_score": 0.21393, "epss_percentile": 0.95512}, "CVE-2007-5842": {"epss_score": 0.55755, "epss_percentile": 0.97994}, "CVE-2007-5843": {"epss_score": 0.20626, "epss_percentile": 0.95388}, "CVE-2007-5844": {"epss_score": 0.03112, "epss_percentile": 0.86428}, "CVE-2007-5845": {"epss_score": 0.02557, "epss_percentile": 0.85095}, "CVE-2007-5846": {"epss_score": 0.69744, "epss_percentile": 0.98602}, "CVE-2007-5847": {"epss_score": 0.00044, "epss_percentile": 0.13677}, "CVE-2007-5848": {"epss_score": 0.00271, "epss_percentile": 0.50307}, "CVE-2007-5849": {"epss_score": 0.3458, "epss_percentile": 0.96858}, "CVE-2007-5850": {"epss_score": 0.00757, "epss_percentile": 0.72759}, "CVE-2007-5851": {"epss_score": 0.00203, "epss_percentile": 0.42582}, "CVE-2007-5853": {"epss_score": 0.00837, "epss_percentile": 0.74158}, "CVE-2007-5854": {"epss_score": 0.00309, "epss_percentile": 0.53666}, "CVE-2007-5855": {"epss_score": 0.00415, "epss_percentile": 0.61141}, "CVE-2007-5856": {"epss_score": 0.00292, "epss_percentile": 0.5223}, "CVE-2007-5857": {"epss_score": 0.00504, "epss_percentile": 0.6554}, "CVE-2007-5858": {"epss_score": 0.01025, "epss_percentile": 0.76789}, "CVE-2007-5859": {"epss_score": 0.19604, "epss_percentile": 0.95214}, "CVE-2007-5860": {"epss_score": 0.00064, "epss_percentile": 0.20358}, "CVE-2007-5861": {"epss_score": 0.00751, "epss_percentile": 0.72637}, "CVE-2007-5862": {"epss_score": 0.00207, "epss_percentile": 0.43085}, "CVE-2007-5863": {"epss_score": 0.74389, "epss_percentile": 0.98797}, "CVE-2007-5887": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-5888": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2007-5889": {"epss_score": 0.02282, "epss_percentile": 0.84255}, "CVE-2007-5890": {"epss_score": 0.02804, "epss_percentile": 0.85705}, "CVE-2007-5891": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-5892": {"epss_score": 0.09154, "epss_percentile": 0.92424}, "CVE-2007-5893": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2007-5894": {"epss_score": 0.02774, "epss_percentile": 0.85631}, "CVE-2007-5896": {"epss_score": 0.00617, "epss_percentile": 0.69355}, "CVE-2007-5897": {"epss_score": 0.03222, "epss_percentile": 0.86676}, "CVE-2007-5898": {"epss_score": 0.05084, "epss_percentile": 0.89476}, "CVE-2007-5899": {"epss_score": 0.01863, "epss_percentile": 0.82599}, "CVE-2007-5900": {"epss_score": 0.0007, "epss_percentile": 0.21959}, "CVE-2007-5901": {"epss_score": 0.00151, "epss_percentile": 0.36191}, "CVE-2007-5902": {"epss_score": 0.04002, "epss_percentile": 0.88094}, "CVE-2007-5904": {"epss_score": 0.01972, "epss_percentile": 0.83108}, "CVE-2007-5905": {"epss_score": 0.0543, "epss_percentile": 0.89876}, "CVE-2007-5906": {"epss_score": 0.00063, "epss_percentile": 0.19913}, "CVE-2007-5907": {"epss_score": 0.0006, "epss_percentile": 0.19023}, "CVE-2007-5909": {"epss_score": 0.25869, "epss_percentile": 0.96086}, "CVE-2007-5910": {"epss_score": 0.30959, "epss_percentile": 0.96577}, "CVE-2007-5911": {"epss_score": 0.19915, "epss_percentile": 0.95259}, "CVE-2007-5912": {"epss_score": 0.00404, "epss_percentile": 0.60444}, "CVE-2007-5913": {"epss_score": 0.15653, "epss_percentile": 0.94476}, "CVE-2007-5914": {"epss_score": 0.04827, "epss_percentile": 0.89186}, "CVE-2007-5915": {"epss_score": 0.02143, "epss_percentile": 0.83758}, "CVE-2007-5916": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-5917": {"epss_score": 0.00268, "epss_percentile": 0.50024}, "CVE-2007-5918": {"epss_score": 0.00195, "epss_percentile": 0.41643}, "CVE-2007-5919": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2007-5920": {"epss_score": 0.00083, "epss_percentile": 0.24606}, "CVE-2007-5921": {"epss_score": 0.00051, "epss_percentile": 0.1613}, "CVE-2007-5922": {"epss_score": 0.00335, "epss_percentile": 0.55814}, "CVE-2007-5923": {"epss_score": 0.01442, "epss_percentile": 0.80311}, "CVE-2007-5924": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2007-5925": {"epss_score": 0.13019, "epss_percentile": 0.93847}, "CVE-2007-5926": {"epss_score": 0.04579, "epss_percentile": 0.88872}, "CVE-2007-5927": {"epss_score": 0.00646, "epss_percentile": 0.7014}, "CVE-2007-5928": {"epss_score": 0.00603, "epss_percentile": 0.68935}, "CVE-2007-5929": {"epss_score": 0.01621, "epss_percentile": 0.81391}, "CVE-2007-5930": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2007-5931": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2007-5932": {"epss_score": 0.00532, "epss_percentile": 0.667}, "CVE-2007-5933": {"epss_score": 0.01842, "epss_percentile": 0.825}, "CVE-2007-5934": {"epss_score": 0.00938, "epss_percentile": 0.75713}, "CVE-2007-5935": {"epss_score": 0.0635, "epss_percentile": 0.90691}, "CVE-2007-5936": {"epss_score": 0.0009, "epss_percentile": 0.26097}, "CVE-2007-5937": {"epss_score": 0.01975, "epss_percentile": 0.83118}, "CVE-2007-5938": {"epss_score": 0.01423, "epss_percentile": 0.80189}, "CVE-2007-5939": {"epss_score": 0.01661, "epss_percentile": 0.81621}, "CVE-2007-5940": {"epss_score": 0.00042, "epss_percentile": 0.12648}, "CVE-2007-5941": {"epss_score": 0.23138, "epss_percentile": 0.95739}, "CVE-2007-5942": {"epss_score": 0.00193, "epss_percentile": 0.41379}, "CVE-2007-5943": {"epss_score": 0.00273, "epss_percentile": 0.50482}, "CVE-2007-5944": {"epss_score": 0.02134, "epss_percentile": 0.83723}, "CVE-2007-5945": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2007-5946": {"epss_score": 0.00053, "epss_percentile": 0.17011}, "CVE-2007-5947": {"epss_score": 0.07915, "epss_percentile": 0.91761}, "CVE-2007-5948": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2007-5949": {"epss_score": 0.00301, "epss_percentile": 0.53015}, "CVE-2007-5950": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2007-5951": {"epss_score": 0.00306, "epss_percentile": 0.53431}, "CVE-2007-5952": {"epss_score": 0.0152, "epss_percentile": 0.80822}, "CVE-2007-5953": {"epss_score": 0.00328, "epss_percentile": 0.55275}, "CVE-2007-5954": {"epss_score": 0.00156, "epss_percentile": 0.36982}, "CVE-2007-5955": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2007-5956": {"epss_score": 0.00029, "epss_percentile": 0.07765}, "CVE-2007-5957": {"epss_score": 0.00059, "epss_percentile": 0.18799}, "CVE-2007-5958": {"epss_score": 0.03599, "epss_percentile": 0.87408}, "CVE-2007-5959": {"epss_score": 0.13311, "epss_percentile": 0.93929}, "CVE-2007-5960": {"epss_score": 0.0093, "epss_percentile": 0.75605}, "CVE-2007-5961": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2007-5962": {"epss_score": 0.1715, "epss_percentile": 0.94783}, "CVE-2007-5963": {"epss_score": 0.00051, "epss_percentile": 0.16173}, "CVE-2007-5964": {"epss_score": 0.0017, "epss_percentile": 0.38667}, "CVE-2007-5965": {"epss_score": 0.01241, "epss_percentile": 0.78817}, "CVE-2007-5966": {"epss_score": 0.0009, "epss_percentile": 0.26142}, "CVE-2007-5967": {"epss_score": 0.00108, "epss_percentile": 0.29835}, "CVE-2007-5969": {"epss_score": 0.01811, "epss_percentile": 0.82369}, "CVE-2007-5970": {"epss_score": 0.0048, "epss_percentile": 0.64465}, "CVE-2007-5971": {"epss_score": 0.00109, "epss_percentile": 0.29972}, "CVE-2007-5972": {"epss_score": 0.01923, "epss_percentile": 0.82908}, "CVE-2007-5973": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-5974": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-5975": {"epss_score": 0.00601, "epss_percentile": 0.68862}, "CVE-2007-5976": {"epss_score": 0.01336, "epss_percentile": 0.79556}, "CVE-2007-5977": {"epss_score": 0.00693, "epss_percentile": 0.71327}, "CVE-2007-5978": {"epss_score": 0.00383, "epss_percentile": 0.591}, "CVE-2007-5979": {"epss_score": 0.15983, "epss_percentile": 0.94548}, "CVE-2007-5980": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2007-5981": {"epss_score": 0.00238, "epss_percentile": 0.4684}, "CVE-2007-5982": {"epss_score": 0.01834, "epss_percentile": 0.82463}, "CVE-2007-5983": {"epss_score": 0.08982, "epss_percentile": 0.9235}, "CVE-2007-5984": {"epss_score": 0.1735, "epss_percentile": 0.94832}, "CVE-2007-5985": {"epss_score": 0.00715, "epss_percentile": 0.71851}, "CVE-2007-5986": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2007-5987": {"epss_score": 0.00439, "epss_percentile": 0.62609}, "CVE-2007-5988": {"epss_score": 0.00958, "epss_percentile": 0.75942}, "CVE-2007-5989": {"epss_score": 0.0774, "epss_percentile": 0.91653}, "CVE-2007-5990": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2007-5991": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-5992": {"epss_score": 0.00674, "epss_percentile": 0.70848}, "CVE-2007-5993": {"epss_score": 0.03528, "epss_percentile": 0.87298}, "CVE-2007-5994": {"epss_score": 0.00565, "epss_percentile": 0.67786}, "CVE-2007-5995": {"epss_score": 0.03564, "epss_percentile": 0.87358}, "CVE-2007-5996": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-5997": {"epss_score": 0.00393, "epss_percentile": 0.59738}, "CVE-2007-5998": {"epss_score": 0.00393, "epss_percentile": 0.59738}, "CVE-2007-5999": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6000": {"epss_score": 0.02615, "epss_percentile": 0.85245}, "CVE-2007-6001": {"epss_score": 0.03477, "epss_percentile": 0.87212}, "CVE-2007-6002": {"epss_score": 0.00778, "epss_percentile": 0.73134}, "CVE-2007-6003": {"epss_score": 0.00319, "epss_percentile": 0.54547}, "CVE-2007-6004": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6005": {"epss_score": 0.0383, "epss_percentile": 0.87806}, "CVE-2007-6006": {"epss_score": 0.00291, "epss_percentile": 0.52148}, "CVE-2007-6007": {"epss_score": 0.04381, "epss_percentile": 0.88624}, "CVE-2007-6008": {"epss_score": 0.03632, "epss_percentile": 0.87475}, "CVE-2007-6009": {"epss_score": 0.05568, "epss_percentile": 0.90003}, "CVE-2007-6010": {"epss_score": 0.00673, "epss_percentile": 0.70843}, "CVE-2007-6011": {"epss_score": 0.0081, "epss_percentile": 0.73713}, "CVE-2007-6012": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2007-6013": {"epss_score": 0.01551, "epss_percentile": 0.8099}, "CVE-2007-6014": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2007-6015": {"epss_score": 0.56544, "epss_percentile": 0.98027}, "CVE-2007-6016": {"epss_score": 0.7098, "epss_percentile": 0.98649}, "CVE-2007-6017": {"epss_score": 0.07092, "epss_percentile": 0.91244}, "CVE-2007-6018": {"epss_score": 0.0115, "epss_percentile": 0.78031}, "CVE-2007-6019": {"epss_score": 0.66216, "epss_percentile": 0.98455}, "CVE-2007-6020": {"epss_score": 0.34744, "epss_percentile": 0.96872}, "CVE-2007-6021": {"epss_score": 0.13133, "epss_percentile": 0.93882}, "CVE-2007-6025": {"epss_score": 0.00673, "epss_percentile": 0.70835}, "CVE-2007-6026": {"epss_score": 0.77332, "epss_percentile": 0.98932}, "CVE-2007-6027": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-6028": {"epss_score": 0.05567, "epss_percentile": 0.90002}, "CVE-2007-6029": {"epss_score": 0.01859, "epss_percentile": 0.82581}, "CVE-2007-6030": {"epss_score": 0.00341, "epss_percentile": 0.56305}, "CVE-2007-6031": {"epss_score": 0.00673, "epss_percentile": 0.70843}, "CVE-2007-6032": {"epss_score": 0.0055, "epss_percentile": 0.67341}, "CVE-2007-6033": {"epss_score": 0.03193, "epss_percentile": 0.86604}, "CVE-2007-6035": {"epss_score": 0.04252, "epss_percentile": 0.88452}, "CVE-2007-6036": {"epss_score": 0.08356, "epss_percentile": 0.92006}, "CVE-2007-6037": {"epss_score": 0.10243, "epss_percentile": 0.92908}, "CVE-2007-6038": {"epss_score": 0.1883, "epss_percentile": 0.95078}, "CVE-2007-6039": {"epss_score": 0.00335, "epss_percentile": 0.55897}, "CVE-2007-6040": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2007-6041": {"epss_score": 0.12777, "epss_percentile": 0.93771}, "CVE-2007-6042": {"epss_score": 0.005, "epss_percentile": 0.6533}, "CVE-2007-6043": {"epss_score": 0.20413, "epss_percentile": 0.9534}, "CVE-2007-6044": {"epss_score": 0.00539, "epss_percentile": 0.66975}, "CVE-2007-6045": {"epss_score": 0.01206, "epss_percentile": 0.78518}, "CVE-2007-6046": {"epss_score": 0.00048, "epss_percentile": 0.15097}, "CVE-2007-6047": {"epss_score": 0.00651, "epss_percentile": 0.70286}, "CVE-2007-6048": {"epss_score": 0.0076, "epss_percentile": 0.72799}, "CVE-2007-6049": {"epss_score": 0.00064, "epss_percentile": 0.20366}, "CVE-2007-6050": {"epss_score": 0.00056, "epss_percentile": 0.1788}, "CVE-2007-6051": {"epss_score": 0.00478, "epss_percentile": 0.64378}, "CVE-2007-6052": {"epss_score": 0.00421, "epss_percentile": 0.61511}, "CVE-2007-6053": {"epss_score": 0.00435, "epss_percentile": 0.6234}, "CVE-2007-6054": {"epss_score": 0.00778, "epss_percentile": 0.73124}, "CVE-2007-6055": {"epss_score": 0.07643, "epss_percentile": 0.91596}, "CVE-2007-6056": {"epss_score": 0.02053, "epss_percentile": 0.83417}, "CVE-2007-6057": {"epss_score": 0.06025, "epss_percentile": 0.90418}, "CVE-2007-6058": {"epss_score": 0.00918, "epss_percentile": 0.75443}, "CVE-2007-6059": {"epss_score": 0.00942, "epss_percentile": 0.75763}, "CVE-2007-6060": {"epss_score": 0.11504, "epss_percentile": 0.93385}, "CVE-2007-6061": {"epss_score": 0.00908, "epss_percentile": 0.75272}, "CVE-2007-6062": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2007-6063": {"epss_score": 0.00157, "epss_percentile": 0.37132}, "CVE-2007-6067": {"epss_score": 0.00997, "epss_percentile": 0.76463}, "CVE-2007-6077": {"epss_score": 0.03262, "epss_percentile": 0.86774}, "CVE-2007-6078": {"epss_score": 0.02517, "epss_percentile": 0.84989}, "CVE-2007-6079": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2007-6080": {"epss_score": 0.01854, "epss_percentile": 0.82555}, "CVE-2007-6081": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2007-6082": {"epss_score": 0.08254, "epss_percentile": 0.91951}, "CVE-2007-6083": {"epss_score": 0.02227, "epss_percentile": 0.84072}, "CVE-2007-6084": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6085": {"epss_score": 0.03477, "epss_percentile": 0.87212}, "CVE-2007-6086": {"epss_score": 0.03839, "epss_percentile": 0.87829}, "CVE-2007-6087": {"epss_score": 0.00427, "epss_percentile": 0.61773}, "CVE-2007-6088": {"epss_score": 0.02414, "epss_percentile": 0.84678}, "CVE-2007-6089": {"epss_score": 0.06623, "epss_percentile": 0.90897}, "CVE-2007-6090": {"epss_score": 0.00246, "epss_percentile": 0.47789}, "CVE-2007-6091": {"epss_score": 0.00433, "epss_percentile": 0.62184}, "CVE-2007-6092": {"epss_score": 0.00394, "epss_percentile": 0.59798}, "CVE-2007-6093": {"epss_score": 0.00617, "epss_percentile": 0.69355}, "CVE-2007-6094": {"epss_score": 0.00564, "epss_percentile": 0.67768}, "CVE-2007-6095": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2007-6096": {"epss_score": 0.00335, "epss_percentile": 0.55814}, "CVE-2007-6097": {"epss_score": 0.00341, "epss_percentile": 0.56305}, "CVE-2007-6098": {"epss_score": 0.00323, "epss_percentile": 0.54902}, "CVE-2007-6099": {"epss_score": 0.01073, "epss_percentile": 0.77289}, "CVE-2007-6100": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2007-6101": {"epss_score": 0.01015, "epss_percentile": 0.76658}, "CVE-2007-6102": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2007-6103": {"epss_score": 0.15431, "epss_percentile": 0.9443}, "CVE-2007-6104": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2007-6105": {"epss_score": 0.13684, "epss_percentile": 0.94034}, "CVE-2007-6106": {"epss_score": 0.0159, "epss_percentile": 0.81198}, "CVE-2007-6109": {"epss_score": 0.03126, "epss_percentile": 0.86456}, "CVE-2007-6110": {"epss_score": 0.09294, "epss_percentile": 0.92487}, "CVE-2007-6111": {"epss_score": 0.0398, "epss_percentile": 0.88058}, "CVE-2007-6112": {"epss_score": 0.05068, "epss_percentile": 0.8946}, "CVE-2007-6113": {"epss_score": 0.0882, "epss_percentile": 0.9227}, "CVE-2007-6114": {"epss_score": 0.03797, "epss_percentile": 0.87736}, "CVE-2007-6115": {"epss_score": 0.05068, "epss_percentile": 0.8946}, "CVE-2007-6116": {"epss_score": 0.02505, "epss_percentile": 0.84936}, "CVE-2007-6117": {"epss_score": 0.04017, "epss_percentile": 0.88123}, "CVE-2007-6118": {"epss_score": 0.0488, "epss_percentile": 0.89246}, "CVE-2007-6119": {"epss_score": 0.03654, "epss_percentile": 0.87512}, "CVE-2007-6120": {"epss_score": 0.03173, "epss_percentile": 0.86552}, "CVE-2007-6121": {"epss_score": 0.02848, "epss_percentile": 0.85825}, "CVE-2007-6122": {"epss_score": 0.01846, "epss_percentile": 0.82512}, "CVE-2007-6123": {"epss_score": 0.00416, "epss_percentile": 0.61172}, "CVE-2007-6124": {"epss_score": 0.04114, "epss_percentile": 0.88275}, "CVE-2007-6125": {"epss_score": 0.007, "epss_percentile": 0.71466}, "CVE-2007-6126": {"epss_score": 0.04183, "epss_percentile": 0.88359}, "CVE-2007-6127": {"epss_score": 0.00486, "epss_percentile": 0.64761}, "CVE-2007-6128": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6129": {"epss_score": 0.07831, "epss_percentile": 0.91704}, "CVE-2007-6130": {"epss_score": 0.00349, "epss_percentile": 0.56874}, "CVE-2007-6131": {"epss_score": 0.00071, "epss_percentile": 0.2212}, "CVE-2007-6133": {"epss_score": 0.12553, "epss_percentile": 0.93714}, "CVE-2007-6134": {"epss_score": 0.0055, "epss_percentile": 0.67341}, "CVE-2007-6135": {"epss_score": 0.07499, "epss_percentile": 0.91506}, "CVE-2007-6136": {"epss_score": 0.00399, "epss_percentile": 0.60137}, "CVE-2007-6137": {"epss_score": 0.01, "epss_percentile": 0.76485}, "CVE-2007-6138": {"epss_score": 0.00615, "epss_percentile": 0.69316}, "CVE-2007-6139": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-6140": {"epss_score": 0.00717, "epss_percentile": 0.71882}, "CVE-2007-6141": {"epss_score": 0.00346, "epss_percentile": 0.56656}, "CVE-2007-6142": {"epss_score": 0.00324, "epss_percentile": 0.54956}, "CVE-2007-6143": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2007-6144": {"epss_score": 0.12103, "epss_percentile": 0.93567}, "CVE-2007-6145": {"epss_score": 0.00507, "epss_percentile": 0.65665}, "CVE-2007-6146": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2007-6147": {"epss_score": 0.04139, "epss_percentile": 0.8831}, "CVE-2007-6148": {"epss_score": 0.2165, "epss_percentile": 0.95543}, "CVE-2007-6149": {"epss_score": 0.31104, "epss_percentile": 0.96588}, "CVE-2007-6150": {"epss_score": 0.0007, "epss_percentile": 0.21752}, "CVE-2007-6151": {"epss_score": 0.00058, "epss_percentile": 0.1861}, "CVE-2007-6156": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2007-6157": {"epss_score": 0.01254, "epss_percentile": 0.78922}, "CVE-2007-6158": {"epss_score": 0.00265, "epss_percentile": 0.4982}, "CVE-2007-6159": {"epss_score": 0.00284, "epss_percentile": 0.51415}, "CVE-2007-6160": {"epss_score": 0.0217, "epss_percentile": 0.83871}, "CVE-2007-6161": {"epss_score": 0.00309, "epss_percentile": 0.53666}, "CVE-2007-6162": {"epss_score": 0.00399, "epss_percentile": 0.60137}, "CVE-2007-6163": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2007-6164": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6165": {"epss_score": 0.38553, "epss_percentile": 0.97104}, "CVE-2007-6166": {"epss_score": 0.83081, "epss_percentile": 0.9923}, "CVE-2007-6167": {"epss_score": 0.00057, "epss_percentile": 0.18075}, "CVE-2007-6168": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-6169": {"epss_score": 0.004, "epss_percentile": 0.6015}, "CVE-2007-6170": {"epss_score": 0.004, "epss_percentile": 0.60154}, "CVE-2007-6171": {"epss_score": 0.0024, "epss_percentile": 0.46966}, "CVE-2007-6172": {"epss_score": 0.00568, "epss_percentile": 0.67905}, "CVE-2007-6173": {"epss_score": 0.07499, "epss_percentile": 0.91506}, "CVE-2007-6174": {"epss_score": 0.0061, "epss_percentile": 0.69164}, "CVE-2007-6175": {"epss_score": 0.05279, "epss_percentile": 0.89686}, "CVE-2007-6176": {"epss_score": 0.0754, "epss_percentile": 0.91526}, "CVE-2007-6177": {"epss_score": 0.05766, "epss_percentile": 0.90188}, "CVE-2007-6178": {"epss_score": 0.03693, "epss_percentile": 0.8758}, "CVE-2007-6179": {"epss_score": 0.09633, "epss_percentile": 0.92633}, "CVE-2007-6180": {"epss_score": 0.00246, "epss_percentile": 0.47794}, "CVE-2007-6181": {"epss_score": 0.05654, "epss_percentile": 0.90086}, "CVE-2007-6182": {"epss_score": 0.00185, "epss_percentile": 0.40469}, "CVE-2007-6183": {"epss_score": 0.02542, "epss_percentile": 0.85052}, "CVE-2007-6184": {"epss_score": 0.03721, "epss_percentile": 0.8762}, "CVE-2007-6185": {"epss_score": 0.05733, "epss_percentile": 0.90163}, "CVE-2007-6186": {"epss_score": 0.00341, "epss_percentile": 0.56305}, "CVE-2007-6187": {"epss_score": 0.06804, "epss_percentile": 0.91036}, "CVE-2007-6188": {"epss_score": 0.10286, "epss_percentile": 0.92927}, "CVE-2007-6189": {"epss_score": 0.23228, "epss_percentile": 0.95753}, "CVE-2007-6190": {"epss_score": 0.00364, "epss_percentile": 0.57906}, "CVE-2007-6191": {"epss_score": 0.02033, "epss_percentile": 0.83343}, "CVE-2007-6192": {"epss_score": 0.00203, "epss_percentile": 0.42547}, "CVE-2007-6193": {"epss_score": 0.00281, "epss_percentile": 0.51186}, "CVE-2007-6194": {"epss_score": 0.0257, "epss_percentile": 0.85128}, "CVE-2007-6195": {"epss_score": 0.22849, "epss_percentile": 0.95699}, "CVE-2007-6196": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2007-6197": {"epss_score": 0.00559, "epss_percentile": 0.6761}, "CVE-2007-6198": {"epss_score": 0.05922, "epss_percentile": 0.90323}, "CVE-2007-6199": {"epss_score": 0.06572, "epss_percentile": 0.90855}, "CVE-2007-6200": {"epss_score": 0.02317, "epss_percentile": 0.8436}, "CVE-2007-6201": {"epss_score": 0.0093, "epss_percentile": 0.75599}, "CVE-2007-6202": {"epss_score": 0.00611, "epss_percentile": 0.69196}, "CVE-2007-6203": {"epss_score": 0.72212, "epss_percentile": 0.987}, "CVE-2007-6204": {"epss_score": 0.87208, "epss_percentile": 0.99419}, "CVE-2007-6205": {"epss_score": 0.00667, "epss_percentile": 0.70721}, "CVE-2007-6206": {"epss_score": 0.00076, "epss_percentile": 0.23143}, "CVE-2007-6207": {"epss_score": 0.00087, "epss_percentile": 0.25454}, "CVE-2007-6208": {"epss_score": 0.00074, "epss_percentile": 0.22877}, "CVE-2007-6209": {"epss_score": 0.00067, "epss_percentile": 0.2104}, "CVE-2007-6210": {"epss_score": 0.00184, "epss_percentile": 0.40413}, "CVE-2007-6211": {"epss_score": 0.00077, "epss_percentile": 0.23468}, "CVE-2007-6212": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2007-6213": {"epss_score": 0.02263, "epss_percentile": 0.8419}, "CVE-2007-6214": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2007-6215": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2007-6216": {"epss_score": 0.0004, "epss_percentile": 0.12047}, "CVE-2007-6217": {"epss_score": 0.01265, "epss_percentile": 0.79002}, "CVE-2007-6218": {"epss_score": 0.07563, "epss_percentile": 0.91543}, "CVE-2007-6219": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2007-6220": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2007-6221": {"epss_score": 0.02998, "epss_percentile": 0.86159}, "CVE-2007-6222": {"epss_score": 0.00244, "epss_percentile": 0.47519}, "CVE-2007-6223": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6224": {"epss_score": 0.00829, "epss_percentile": 0.74008}, "CVE-2007-6225": {"epss_score": 0.00054, "epss_percentile": 0.17322}, "CVE-2007-6226": {"epss_score": 0.00211, "epss_percentile": 0.43706}, "CVE-2007-6227": {"epss_score": 0.00323, "epss_percentile": 0.54895}, "CVE-2007-6228": {"epss_score": 0.02781, "epss_percentile": 0.8565}, "CVE-2007-6229": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-6230": {"epss_score": 0.02006, "epss_percentile": 0.83233}, "CVE-2007-6231": {"epss_score": 0.07045, "epss_percentile": 0.91209}, "CVE-2007-6232": {"epss_score": 0.03444, "epss_percentile": 0.87145}, "CVE-2007-6233": {"epss_score": 0.02221, "epss_percentile": 0.8405}, "CVE-2007-6234": {"epss_score": 0.04419, "epss_percentile": 0.88668}, "CVE-2007-6235": {"epss_score": 0.06364, "epss_percentile": 0.90701}, "CVE-2007-6236": {"epss_score": 0.33153, "epss_percentile": 0.9675}, "CVE-2007-6237": {"epss_score": 0.02021, "epss_percentile": 0.83297}, "CVE-2007-6238": {"epss_score": 0.02735, "epss_percentile": 0.85549}, "CVE-2007-6239": {"epss_score": 0.08998, "epss_percentile": 0.92358}, "CVE-2007-6240": {"epss_score": 0.00569, "epss_percentile": 0.67917}, "CVE-2007-6241": {"epss_score": 0.00383, "epss_percentile": 0.59104}, "CVE-2007-6242": {"epss_score": 0.57674, "epss_percentile": 0.98078}, "CVE-2007-6243": {"epss_score": 0.46434, "epss_percentile": 0.97545}, "CVE-2007-6244": {"epss_score": 0.58426, "epss_percentile": 0.98115}, "CVE-2007-6245": {"epss_score": 0.27062, "epss_percentile": 0.96202}, "CVE-2007-6246": {"epss_score": 0.00254, "epss_percentile": 0.48571}, "CVE-2007-6249": {"epss_score": 0.00073, "epss_percentile": 0.226}, "CVE-2007-6250": {"epss_score": 0.62711, "epss_percentile": 0.98304}, "CVE-2007-6252": {"epss_score": 0.09607, "epss_percentile": 0.92618}, "CVE-2007-6253": {"epss_score": 0.2839, "epss_percentile": 0.96349}, "CVE-2007-6254": {"epss_score": 0.32178, "epss_percentile": 0.96676}, "CVE-2007-6255": {"epss_score": 0.57951, "epss_percentile": 0.98092}, "CVE-2007-6258": {"epss_score": 0.39387, "epss_percentile": 0.97158}, "CVE-2007-6260": {"epss_score": 0.00872, "epss_percentile": 0.74721}, "CVE-2007-6261": {"epss_score": 0.00146, "epss_percentile": 0.35629}, "CVE-2007-6262": {"epss_score": 0.21728, "epss_percentile": 0.95553}, "CVE-2007-6263": {"epss_score": 0.01655, "epss_percentile": 0.81591}, "CVE-2007-6265": {"epss_score": 0.00642, "epss_percentile": 0.70025}, "CVE-2007-6266": {"epss_score": 0.0087, "epss_percentile": 0.747}, "CVE-2007-6267": {"epss_score": 0.00081, "epss_percentile": 0.2422}, "CVE-2007-6268": {"epss_score": 0.02229, "epss_percentile": 0.8408}, "CVE-2007-6269": {"epss_score": 0.00715, "epss_percentile": 0.71839}, "CVE-2007-6270": {"epss_score": 0.11473, "epss_percentile": 0.93377}, "CVE-2007-6271": {"epss_score": 0.01817, "epss_percentile": 0.82395}, "CVE-2007-6272": {"epss_score": 0.00014, "epss_percentile": 0.02111}, "CVE-2007-6273": {"epss_score": 0.06014, "epss_percentile": 0.9041}, "CVE-2007-6274": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-6275": {"epss_score": 0.00418, "epss_percentile": 0.6128}, "CVE-2007-6276": {"epss_score": 0.13999, "epss_percentile": 0.94112}, "CVE-2007-6277": {"epss_score": 0.18116, "epss_percentile": 0.94959}, "CVE-2007-6278": {"epss_score": 0.01143, "epss_percentile": 0.77984}, "CVE-2007-6279": {"epss_score": 0.03061, "epss_percentile": 0.86308}, "CVE-2007-6281": {"epss_score": 0.12626, "epss_percentile": 0.93733}, "CVE-2007-6282": {"epss_score": 0.02449, "epss_percentile": 0.84775}, "CVE-2007-6283": {"epss_score": 0.0011, "epss_percentile": 0.30215}, "CVE-2007-6284": {"epss_score": 0.04902, "epss_percentile": 0.89274}, "CVE-2007-6285": {"epss_score": 0.00113, "epss_percentile": 0.30722}, "CVE-2007-6286": {"epss_score": 0.1187, "epss_percentile": 0.93501}, "CVE-2007-6287": {"epss_score": 0.00324, "epss_percentile": 0.54956}, "CVE-2007-6288": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-6289": {"epss_score": 0.03564, "epss_percentile": 0.87358}, "CVE-2007-6290": {"epss_score": 0.0284, "epss_percentile": 0.85802}, "CVE-2007-6291": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2007-6292": {"epss_score": 0.00541, "epss_percentile": 0.6703}, "CVE-2007-6293": {"epss_score": 0.00952, "epss_percentile": 0.75884}, "CVE-2007-6294": {"epss_score": 0.00064, "epss_percentile": 0.20386}, "CVE-2007-6295": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2007-6296": {"epss_score": 0.00267, "epss_percentile": 0.50013}, "CVE-2007-6297": {"epss_score": 0.01212, "epss_percentile": 0.7856}, "CVE-2007-6298": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2007-6299": {"epss_score": 0.016, "epss_percentile": 0.81255}, "CVE-2007-6300": {"epss_score": 0.00141, "epss_percentile": 0.34809}, "CVE-2007-6301": {"epss_score": 0.05185, "epss_percentile": 0.89587}, "CVE-2007-6302": {"epss_score": 0.13535, "epss_percentile": 0.93989}, "CVE-2007-6303": {"epss_score": 0.00508, "epss_percentile": 0.65717}, "CVE-2007-6304": {"epss_score": 0.04845, "epss_percentile": 0.89208}, "CVE-2007-6305": {"epss_score": 0.00116, "epss_percentile": 0.31063}, "CVE-2007-6306": {"epss_score": 0.02027, "epss_percentile": 0.83319}, "CVE-2007-6307": {"epss_score": 0.1133, "epss_percentile": 0.93311}, "CVE-2007-6308": {"epss_score": 0.00296, "epss_percentile": 0.52541}, "CVE-2007-6309": {"epss_score": 0.02913, "epss_percentile": 0.85974}, "CVE-2007-6310": {"epss_score": 0.06199, "epss_percentile": 0.90558}, "CVE-2007-6311": {"epss_score": 0.01396, "epss_percentile": 0.79978}, "CVE-2007-6312": {"epss_score": 0.00595, "epss_percentile": 0.68687}, "CVE-2007-6313": {"epss_score": 0.00575, "epss_percentile": 0.681}, "CVE-2007-6314": {"epss_score": 0.11299, "epss_percentile": 0.93297}, "CVE-2007-6315": {"epss_score": 0.05984, "epss_percentile": 0.90382}, "CVE-2007-6316": {"epss_score": 0.05284, "epss_percentile": 0.89692}, "CVE-2007-6317": {"epss_score": 0.04032, "epss_percentile": 0.88152}, "CVE-2007-6318": {"epss_score": 0.04942, "epss_percentile": 0.89308}, "CVE-2007-6319": {"epss_score": 0.01684, "epss_percentile": 0.81746}, "CVE-2007-6320": {"epss_score": 0.00181, "epss_percentile": 0.40054}, "CVE-2007-6321": {"epss_score": 0.07557, "epss_percentile": 0.91539}, "CVE-2007-6322": {"epss_score": 0.06737, "epss_percentile": 0.90993}, "CVE-2007-6323": {"epss_score": 0.1206, "epss_percentile": 0.93557}, "CVE-2007-6324": {"epss_score": 0.04799, "epss_percentile": 0.89156}, "CVE-2007-6325": {"epss_score": 0.1145, "epss_percentile": 0.93364}, "CVE-2007-6326": {"epss_score": 0.03751, "epss_percentile": 0.87673}, "CVE-2007-6327": {"epss_score": 0.18049, "epss_percentile": 0.94948}, "CVE-2007-6328": {"epss_score": 0.00115, "epss_percentile": 0.30904}, "CVE-2007-6329": {"epss_score": 0.22475, "epss_percentile": 0.9564}, "CVE-2007-6330": {"epss_score": 0.05095, "epss_percentile": 0.8949}, "CVE-2007-6331": {"epss_score": 0.06207, "epss_percentile": 0.90566}, "CVE-2007-6332": {"epss_score": 0.17627, "epss_percentile": 0.94877}, "CVE-2007-6333": {"epss_score": 0.15514, "epss_percentile": 0.94443}, "CVE-2007-6334": {"epss_score": 0.00765, "epss_percentile": 0.72917}, "CVE-2007-6335": {"epss_score": 0.39002, "epss_percentile": 0.97133}, "CVE-2007-6336": {"epss_score": 0.08285, "epss_percentile": 0.9197}, "CVE-2007-6337": {"epss_score": 0.02522, "epss_percentile": 0.85004}, "CVE-2007-6338": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2007-6339": {"epss_score": 0.04832, "epss_percentile": 0.89191}, "CVE-2007-6340": {"epss_score": 0.00069, "epss_percentile": 0.21628}, "CVE-2007-6341": {"epss_score": 0.19139, "epss_percentile": 0.95138}, "CVE-2007-6342": {"epss_score": 0.00823, "epss_percentile": 0.73931}, "CVE-2007-6343": {"epss_score": 0.00395, "epss_percentile": 0.59804}, "CVE-2007-6344": {"epss_score": 0.12273, "epss_percentile": 0.93618}, "CVE-2007-6345": {"epss_score": 0.00587, "epss_percentile": 0.68468}, "CVE-2007-6346": {"epss_score": 0.004, "epss_percentile": 0.60185}, "CVE-2007-6347": {"epss_score": 0.13104, "epss_percentile": 0.93876}, "CVE-2007-6348": {"epss_score": 0.03307, "epss_percentile": 0.86879}, "CVE-2007-6349": {"epss_score": 0.01367, "epss_percentile": 0.79783}, "CVE-2007-6350": {"epss_score": 0.00954, "epss_percentile": 0.75905}, "CVE-2007-6351": {"epss_score": 0.04502, "epss_percentile": 0.88768}, "CVE-2007-6352": {"epss_score": 0.02771, "epss_percentile": 0.85621}, "CVE-2007-6353": {"epss_score": 0.0234, "epss_percentile": 0.84433}, "CVE-2007-6354": {"epss_score": 0.01004, "epss_percentile": 0.7653}, "CVE-2007-6355": {"epss_score": 0.0101, "epss_percentile": 0.76594}, "CVE-2007-6356": {"epss_score": 0.01012, "epss_percentile": 0.76621}, "CVE-2007-6357": {"epss_score": 0.2672, "epss_percentile": 0.96169}, "CVE-2007-6358": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2007-6359": {"epss_score": 0.00202, "epss_percentile": 0.42477}, "CVE-2007-6360": {"epss_score": 0.023, "epss_percentile": 0.8431}, "CVE-2007-6361": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2007-6362": {"epss_score": 0.00016, "epss_percentile": 0.02905}, "CVE-2007-6363": {"epss_score": 0.0017, "epss_percentile": 0.38719}, "CVE-2007-6364": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2007-6365": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2007-6366": {"epss_score": 0.00801, "epss_percentile": 0.73576}, "CVE-2007-6367": {"epss_score": 0.06121, "epss_percentile": 0.90493}, "CVE-2007-6368": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2007-6369": {"epss_score": 0.03257, "epss_percentile": 0.86765}, "CVE-2007-6371": {"epss_score": 0.00586, "epss_percentile": 0.68445}, "CVE-2007-6372": {"epss_score": 0.02907, "epss_percentile": 0.85965}, "CVE-2007-6373": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2007-6374": {"epss_score": 0.00847, "epss_percentile": 0.74348}, "CVE-2007-6375": {"epss_score": 0.00499, "epss_percentile": 0.65262}, "CVE-2007-6376": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2007-6377": {"epss_score": 0.82776, "epss_percentile": 0.99214}, "CVE-2007-6378": {"epss_score": 0.08784, "epss_percentile": 0.92254}, "CVE-2007-6379": {"epss_score": 0.08265, "epss_percentile": 0.91958}, "CVE-2007-6380": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2007-6381": {"epss_score": 0.0092, "epss_percentile": 0.75473}, "CVE-2007-6382": {"epss_score": 0.00768, "epss_percentile": 0.72972}, "CVE-2007-6383": {"epss_score": 0.00165, "epss_percentile": 0.38039}, "CVE-2007-6384": {"epss_score": 0.00883, "epss_percentile": 0.74913}, "CVE-2007-6385": {"epss_score": 0.0007, "epss_percentile": 0.21701}, "CVE-2007-6386": {"epss_score": 0.01341, "epss_percentile": 0.7959}, "CVE-2007-6387": {"epss_score": 0.57182, "epss_percentile": 0.98053}, "CVE-2007-6388": {"epss_score": 0.88343, "epss_percentile": 0.99467}, "CVE-2007-6389": {"epss_score": 0.00073, "epss_percentile": 0.22561}, "CVE-2007-6390": {"epss_score": 0.00129, "epss_percentile": 0.33087}, "CVE-2007-6391": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6392": {"epss_score": 0.00486, "epss_percentile": 0.64761}, "CVE-2007-6393": {"epss_score": 0.00414, "epss_percentile": 0.61034}, "CVE-2007-6394": {"epss_score": 0.0047, "epss_percentile": 0.63984}, "CVE-2007-6395": {"epss_score": 0.03803, "epss_percentile": 0.87748}, "CVE-2007-6396": {"epss_score": 0.04515, "epss_percentile": 0.8879}, "CVE-2007-6397": {"epss_score": 0.06528, "epss_percentile": 0.90822}, "CVE-2007-6398": {"epss_score": 0.02556, "epss_percentile": 0.85092}, "CVE-2007-6399": {"epss_score": 0.04194, "epss_percentile": 0.88378}, "CVE-2007-6400": {"epss_score": 0.04654, "epss_percentile": 0.88967}, "CVE-2007-6401": {"epss_score": 0.56243, "epss_percentile": 0.98013}, "CVE-2007-6402": {"epss_score": 0.05741, "epss_percentile": 0.90169}, "CVE-2007-6403": {"epss_score": 0.04352, "epss_percentile": 0.88586}, "CVE-2007-6404": {"epss_score": 0.10857, "epss_percentile": 0.93136}, "CVE-2007-6405": {"epss_score": 0.09437, "epss_percentile": 0.92548}, "CVE-2007-6406": {"epss_score": 0.00298, "epss_percentile": 0.52811}, "CVE-2007-6407": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2007-6408": {"epss_score": 0.00286, "epss_percentile": 0.5178}, "CVE-2007-6409": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2007-6410": {"epss_score": 0.00114, "epss_percentile": 0.30789}, "CVE-2007-6411": {"epss_score": 0.02999, "epss_percentile": 0.8616}, "CVE-2007-6412": {"epss_score": 0.01113, "epss_percentile": 0.77689}, "CVE-2007-6413": {"epss_score": 0.0074, "epss_percentile": 0.72411}, "CVE-2007-6414": {"epss_score": 0.03375, "epss_percentile": 0.87016}, "CVE-2007-6415": {"epss_score": 0.01197, "epss_percentile": 0.78443}, "CVE-2007-6416": {"epss_score": 0.00113, "epss_percentile": 0.30734}, "CVE-2007-6417": {"epss_score": 0.00046, "epss_percentile": 0.14127}, "CVE-2007-6418": {"epss_score": 0.00047, "epss_percentile": 0.14908}, "CVE-2007-6419": {"epss_score": 0.02777, "epss_percentile": 0.85639}, "CVE-2007-6420": {"epss_score": 0.05044, "epss_percentile": 0.8943}, "CVE-2007-6421": {"epss_score": 0.03015, "epss_percentile": 0.86211}, "CVE-2007-6422": {"epss_score": 0.05534, "epss_percentile": 0.89969}, "CVE-2007-6423": {"epss_score": 0.0366, "epss_percentile": 0.87526}, "CVE-2007-6424": {"epss_score": 0.00783, "epss_percentile": 0.73218}, "CVE-2007-6425": {"epss_score": 0.02822, "epss_percentile": 0.85747}, "CVE-2007-6426": {"epss_score": 0.02938, "epss_percentile": 0.86029}, "CVE-2007-6427": {"epss_score": 0.0374, "epss_percentile": 0.87656}, "CVE-2007-6428": {"epss_score": 0.02951, "epss_percentile": 0.86052}, "CVE-2007-6429": {"epss_score": 0.0227, "epss_percentile": 0.84206}, "CVE-2007-6430": {"epss_score": 0.00541, "epss_percentile": 0.67045}, "CVE-2007-6431": {"epss_score": 0.0651, "epss_percentile": 0.9081}, "CVE-2007-6432": {"epss_score": 0.34894, "epss_percentile": 0.96876}, "CVE-2007-6433": {"epss_score": 0.02004, "epss_percentile": 0.83229}, "CVE-2007-6434": {"epss_score": 0.00056, "epss_percentile": 0.17956}, "CVE-2007-6435": {"epss_score": 0.38755, "epss_percentile": 0.97118}, "CVE-2007-6436": {"epss_score": 0.10707, "epss_percentile": 0.93078}, "CVE-2007-6437": {"epss_score": 0.05183, "epss_percentile": 0.89585}, "CVE-2007-6438": {"epss_score": 0.03173, "epss_percentile": 0.86552}, "CVE-2007-6439": {"epss_score": 0.01346, "epss_percentile": 0.79646}, "CVE-2007-6441": {"epss_score": 0.01076, "epss_percentile": 0.77329}, "CVE-2007-6450": {"epss_score": 0.03173, "epss_percentile": 0.86552}, "CVE-2007-6451": {"epss_score": 0.03032, "epss_percentile": 0.86252}, "CVE-2007-6452": {"epss_score": 0.00334, "epss_percentile": 0.55741}, "CVE-2007-6453": {"epss_score": 0.20259, "epss_percentile": 0.9531}, "CVE-2007-6454": {"epss_score": 0.38626, "epss_percentile": 0.9711}, "CVE-2007-6455": {"epss_score": 0.02516, "epss_percentile": 0.84988}, "CVE-2007-6456": {"epss_score": 0.00343, "epss_percentile": 0.56466}, "CVE-2007-6457": {"epss_score": 0.06469, "epss_percentile": 0.90776}, "CVE-2007-6458": {"epss_score": 0.00284, "epss_percentile": 0.51439}, "CVE-2007-6459": {"epss_score": 0.05296, "epss_percentile": 0.89702}, "CVE-2007-6460": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-6461": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-6462": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6463": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2007-6464": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2007-6465": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2007-6466": {"epss_score": 0.01435, "epss_percentile": 0.80267}, "CVE-2007-6467": {"epss_score": 0.00308, "epss_percentile": 0.53638}, "CVE-2007-6468": {"epss_score": 0.04985, "epss_percentile": 0.89363}, "CVE-2007-6469": {"epss_score": 0.00646, "epss_percentile": 0.70142}, "CVE-2007-6470": {"epss_score": 0.02763, "epss_percentile": 0.85607}, "CVE-2007-6471": {"epss_score": 0.03739, "epss_percentile": 0.87655}, "CVE-2007-6472": {"epss_score": 0.01, "epss_percentile": 0.76485}, "CVE-2007-6473": {"epss_score": 0.04101, "epss_percentile": 0.88258}, "CVE-2007-6474": {"epss_score": 0.04039, "epss_percentile": 0.88165}, "CVE-2007-6475": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2007-6476": {"epss_score": 0.05896, "epss_percentile": 0.90303}, "CVE-2007-6477": {"epss_score": 0.00611, "epss_percentile": 0.69177}, "CVE-2007-6478": {"epss_score": 0.25786, "epss_percentile": 0.96069}, "CVE-2007-6479": {"epss_score": 0.04864, "epss_percentile": 0.89224}, "CVE-2007-6480": {"epss_score": 0.05266, "epss_percentile": 0.89674}, "CVE-2007-6481": {"epss_score": 0.01662, "epss_percentile": 0.81635}, "CVE-2007-6482": {"epss_score": 0.01897, "epss_percentile": 0.82757}, "CVE-2007-6483": {"epss_score": 0.32029, "epss_percentile": 0.96667}, "CVE-2007-6484": {"epss_score": 0.00342, "epss_percentile": 0.56371}, "CVE-2007-6485": {"epss_score": 0.01214, "epss_percentile": 0.78577}, "CVE-2007-6486": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-6487": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2007-6488": {"epss_score": 0.05814, "epss_percentile": 0.90229}, "CVE-2007-6489": {"epss_score": 0.07977, "epss_percentile": 0.918}, "CVE-2007-6490": {"epss_score": 0.00658, "epss_percentile": 0.70484}, "CVE-2007-6491": {"epss_score": 0.00373, "epss_percentile": 0.58473}, "CVE-2007-6492": {"epss_score": 0.00635, "epss_percentile": 0.69826}, "CVE-2007-6493": {"epss_score": 0.08081, "epss_percentile": 0.91872}, "CVE-2007-6494": {"epss_score": 0.02302, "epss_percentile": 0.84313}, "CVE-2007-6495": {"epss_score": 0.02166, "epss_percentile": 0.83847}, "CVE-2007-6496": {"epss_score": 0.01565, "epss_percentile": 0.81064}, "CVE-2007-6497": {"epss_score": 0.01673, "epss_percentile": 0.81685}, "CVE-2007-6498": {"epss_score": 0.00855, "epss_percentile": 0.74468}, "CVE-2007-6499": {"epss_score": 0.01292, "epss_percentile": 0.79232}, "CVE-2007-6500": {"epss_score": 0.01619, "epss_percentile": 0.8138}, "CVE-2007-6501": {"epss_score": 0.01335, "epss_percentile": 0.7955}, "CVE-2007-6502": {"epss_score": 0.01345, "epss_percentile": 0.79628}, "CVE-2007-6503": {"epss_score": 0.01427, "epss_percentile": 0.80216}, "CVE-2007-6504": {"epss_score": 0.01427, "epss_percentile": 0.80216}, "CVE-2007-6505": {"epss_score": 0.0033, "epss_percentile": 0.5546}, "CVE-2007-6506": {"epss_score": 0.28413, "epss_percentile": 0.96355}, "CVE-2007-6507": {"epss_score": 0.7136, "epss_percentile": 0.98664}, "CVE-2007-6508": {"epss_score": 0.06732, "epss_percentile": 0.90989}, "CVE-2007-6509": {"epss_score": 0.71369, "epss_percentile": 0.98664}, "CVE-2007-6510": {"epss_score": 0.06569, "epss_percentile": 0.90852}, "CVE-2007-6511": {"epss_score": 0.00519, "epss_percentile": 0.66144}, "CVE-2007-6512": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2007-6513": {"epss_score": 0.08522, "epss_percentile": 0.921}, "CVE-2007-6514": {"epss_score": 0.09678, "epss_percentile": 0.92656}, "CVE-2007-6515": {"epss_score": 0.12952, "epss_percentile": 0.93829}, "CVE-2007-6516": {"epss_score": 0.0436, "epss_percentile": 0.88595}, "CVE-2007-6517": {"epss_score": 0.00651, "epss_percentile": 0.70284}, "CVE-2007-6518": {"epss_score": 0.00506, "epss_percentile": 0.65642}, "CVE-2007-6519": {"epss_score": 0.00075, "epss_percentile": 0.23043}, "CVE-2007-6520": {"epss_score": 0.00723, "epss_percentile": 0.72018}, "CVE-2007-6521": {"epss_score": 0.14741, "epss_percentile": 0.94272}, "CVE-2007-6522": {"epss_score": 0.01361, "epss_percentile": 0.79751}, "CVE-2007-6523": {"epss_score": 0.01346, "epss_percentile": 0.79644}, "CVE-2007-6524": {"epss_score": 0.01066, "epss_percentile": 0.77222}, "CVE-2007-6525": {"epss_score": 0.01211, "epss_percentile": 0.78555}, "CVE-2007-6526": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2007-6527": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2007-6528": {"epss_score": 0.08211, "epss_percentile": 0.91931}, "CVE-2007-6529": {"epss_score": 0.00779, "epss_percentile": 0.73157}, "CVE-2007-6530": {"epss_score": 0.65752, "epss_percentile": 0.98437}, "CVE-2007-6531": {"epss_score": 0.01991, "epss_percentile": 0.83178}, "CVE-2007-6532": {"epss_score": 0.03092, "epss_percentile": 0.86398}, "CVE-2007-6533": {"epss_score": 0.16682, "epss_percentile": 0.94714}, "CVE-2007-6534": {"epss_score": 0.20831, "epss_percentile": 0.9542}, "CVE-2007-6535": {"epss_score": 0.0119, "epss_percentile": 0.78392}, "CVE-2007-6536": {"epss_score": 0.00973, "epss_percentile": 0.76161}, "CVE-2007-6537": {"epss_score": 0.16977, "epss_percentile": 0.94755}, "CVE-2007-6538": {"epss_score": 0.00809, "epss_percentile": 0.73704}, "CVE-2007-6539": {"epss_score": 0.00794, "epss_percentile": 0.73459}, "CVE-2007-6540": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2007-6541": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2007-6542": {"epss_score": 0.01774, "epss_percentile": 0.82212}, "CVE-2007-6543": {"epss_score": 0.0047, "epss_percentile": 0.63984}, "CVE-2007-6544": {"epss_score": 0.02959, "epss_percentile": 0.86069}, "CVE-2007-6545": {"epss_score": 0.07696, "epss_percentile": 0.91632}, "CVE-2007-6546": {"epss_score": 0.0652, "epss_percentile": 0.90819}, "CVE-2007-6547": {"epss_score": 0.06008, "epss_percentile": 0.90401}, "CVE-2007-6548": {"epss_score": 0.05647, "epss_percentile": 0.90081}, "CVE-2007-6549": {"epss_score": 0.00334, "epss_percentile": 0.55711}, "CVE-2007-6550": {"epss_score": 0.06521, "epss_percentile": 0.90819}, "CVE-2007-6551": {"epss_score": 0.01073, "epss_percentile": 0.77288}, "CVE-2007-6552": {"epss_score": 0.01012, "epss_percentile": 0.76628}, "CVE-2007-6553": {"epss_score": 0.10055, "epss_percentile": 0.92832}, "CVE-2007-6554": {"epss_score": 0.07185, "epss_percentile": 0.91306}, "CVE-2007-6555": {"epss_score": 0.04937, "epss_percentile": 0.89303}, "CVE-2007-6556": {"epss_score": 0.00585, "epss_percentile": 0.68427}, "CVE-2007-6557": {"epss_score": 0.01099, "epss_percentile": 0.77557}, "CVE-2007-6558": {"epss_score": 0.12703, "epss_percentile": 0.93753}, "CVE-2007-6559": {"epss_score": 0.00651, "epss_percentile": 0.70303}, "CVE-2007-6560": {"epss_score": 0.00704, "epss_percentile": 0.71558}, "CVE-2007-6561": {"epss_score": 0.03836, "epss_percentile": 0.87824}, "CVE-2007-6562": {"epss_score": 0.01401, "epss_percentile": 0.80008}, "CVE-2007-6563": {"epss_score": 0.23722, "epss_percentile": 0.95808}, "CVE-2007-6564": {"epss_score": 0.0266, "epss_percentile": 0.85364}, "CVE-2007-6565": {"epss_score": 0.01099, "epss_percentile": 0.77557}, "CVE-2007-6566": {"epss_score": 0.0118, "epss_percentile": 0.78298}, "CVE-2007-6567": {"epss_score": 0.06732, "epss_percentile": 0.90989}, "CVE-2007-6568": {"epss_score": 0.03564, "epss_percentile": 0.87358}, "CVE-2007-6569": {"epss_score": 0.00529, "epss_percentile": 0.66586}, "CVE-2007-6570": {"epss_score": 0.00723, "epss_percentile": 0.72016}, "CVE-2007-6571": {"epss_score": 0.00293, "epss_percentile": 0.5231}, "CVE-2007-6572": {"epss_score": 0.00293, "epss_percentile": 0.5231}, "CVE-2007-6573": {"epss_score": 0.00616, "epss_percentile": 0.69334}, "CVE-2007-6574": {"epss_score": 0.00654, "epss_percentile": 0.70344}, "CVE-2007-6575": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6576": {"epss_score": 0.00949, "epss_percentile": 0.75846}, "CVE-2007-6577": {"epss_score": 0.00486, "epss_percentile": 0.64761}, "CVE-2007-6578": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6579": {"epss_score": 0.01344, "epss_percentile": 0.79614}, "CVE-2007-6580": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6581": {"epss_score": 0.10619, "epss_percentile": 0.93051}, "CVE-2007-6582": {"epss_score": 0.03842, "epss_percentile": 0.87833}, "CVE-2007-6583": {"epss_score": 0.00248, "epss_percentile": 0.47975}, "CVE-2007-6584": {"epss_score": 0.09353, "epss_percentile": 0.92513}, "CVE-2007-6585": {"epss_score": 0.08004, "epss_percentile": 0.91823}, "CVE-2007-6586": {"epss_score": 0.00469, "epss_percentile": 0.63934}, "CVE-2007-6587": {"epss_score": 0.01411, "epss_percentile": 0.80109}, "CVE-2007-6588": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2007-6589": {"epss_score": 0.00546, "epss_percentile": 0.67206}, "CVE-2007-6591": {"epss_score": 0.00213, "epss_percentile": 0.43825}, "CVE-2007-6592": {"epss_score": 0.00153, "epss_percentile": 0.36611}, "CVE-2007-6593": {"epss_score": 0.16296, "epss_percentile": 0.94613}, "CVE-2007-6594": {"epss_score": 0.00037, "epss_percentile": 0.11039}, "CVE-2007-6595": {"epss_score": 0.00047, "epss_percentile": 0.14841}, "CVE-2007-6596": {"epss_score": 0.0031, "epss_percentile": 0.53753}, "CVE-2007-6597": {"epss_score": 0.04055, "epss_percentile": 0.88184}, "CVE-2007-6598": {"epss_score": 0.02083, "epss_percentile": 0.83539}, "CVE-2007-6599": {"epss_score": 0.01346, "epss_percentile": 0.79629}, "CVE-2007-6600": {"epss_score": 0.00719, "epss_percentile": 0.71953}, "CVE-2007-6601": {"epss_score": 0.00862, "epss_percentile": 0.74581}, "CVE-2007-6602": {"epss_score": 0.00699, "epss_percentile": 0.71431}, "CVE-2007-6603": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2007-6604": {"epss_score": 0.02677, "epss_percentile": 0.85405}, "CVE-2007-6605": {"epss_score": 0.02761, "epss_percentile": 0.85603}, "CVE-2007-6606": {"epss_score": 0.00256, "epss_percentile": 0.48777}, "CVE-2007-6607": {"epss_score": 0.00388, "epss_percentile": 0.59369}, "CVE-2007-6608": {"epss_score": 0.02205, "epss_percentile": 0.84}, "CVE-2007-6609": {"epss_score": 0.10216, "epss_percentile": 0.92897}, "CVE-2007-6610": {"epss_score": 0.00928, "epss_percentile": 0.75585}, "CVE-2007-6611": {"epss_score": 0.00667, "epss_percentile": 0.70702}, "CVE-2007-6612": {"epss_score": 0.02126, "epss_percentile": 0.83695}, "CVE-2007-6613": {"epss_score": 0.2318, "epss_percentile": 0.95746}, "CVE-2007-6614": {"epss_score": 0.03423, "epss_percentile": 0.87109}, "CVE-2007-6615": {"epss_score": 0.03079, "epss_percentile": 0.86369}, "CVE-2007-6616": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2007-6617": {"epss_score": 0.00447, "epss_percentile": 0.62958}, "CVE-2007-6618": {"epss_score": 0.00291, "epss_percentile": 0.52183}, "CVE-2007-6619": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2007-6620": {"epss_score": 0.01399, "epss_percentile": 0.79999}, "CVE-2007-6621": {"epss_score": 0.02081, "epss_percentile": 0.83534}, "CVE-2007-6622": {"epss_score": 0.00541, "epss_percentile": 0.6703}, "CVE-2007-6623": {"epss_score": 0.02934, "epss_percentile": 0.86022}, "CVE-2007-6624": {"epss_score": 0.03842, "epss_percentile": 0.87833}, "CVE-2007-6625": {"epss_score": 0.04013, "epss_percentile": 0.88116}, "CVE-2007-6626": {"epss_score": 0.07737, "epss_percentile": 0.91651}, "CVE-2007-6627": {"epss_score": 0.04742, "epss_percentile": 0.89082}, "CVE-2007-6628": {"epss_score": 0.03001, "epss_percentile": 0.86165}, "CVE-2007-6629": {"epss_score": 0.01362, "epss_percentile": 0.7976}, "CVE-2007-6630": {"epss_score": 0.11124, "epss_percentile": 0.9323}, "CVE-2007-6631": {"epss_score": 0.20447, "epss_percentile": 0.95346}, "CVE-2007-6632": {"epss_score": 0.04424, "epss_percentile": 0.88673}, "CVE-2007-6633": {"epss_score": 0.02461, "epss_percentile": 0.84826}, "CVE-2007-6634": {"epss_score": 0.0064, "epss_percentile": 0.69971}, "CVE-2007-6635": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2007-6636": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2007-6637": {"epss_score": 0.31497, "epss_percentile": 0.96623}, "CVE-2007-6638": {"epss_score": 0.0825, "epss_percentile": 0.91949}, "CVE-2007-6639": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6640": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-6641": {"epss_score": 0.02461, "epss_percentile": 0.84826}, "CVE-2007-6642": {"epss_score": 0.00014, "epss_percentile": 0.01803}, "CVE-2007-6643": {"epss_score": 0.00012, "epss_percentile": 0.01317}, "CVE-2007-6644": {"epss_score": 0.00083, "epss_percentile": 0.24594}, "CVE-2007-6645": {"epss_score": 0.00198, "epss_percentile": 0.4206}, "CVE-2007-6646": {"epss_score": 0.01454, "epss_percentile": 0.80382}, "CVE-2007-6647": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2007-6648": {"epss_score": 0.03475, "epss_percentile": 0.87208}, "CVE-2007-6649": {"epss_score": 0.01805, "epss_percentile": 0.82347}, "CVE-2007-6650": {"epss_score": 0.0402, "epss_percentile": 0.8813}, "CVE-2007-6651": {"epss_score": 0.05094, "epss_percentile": 0.89489}, "CVE-2007-6652": {"epss_score": 0.05793, "epss_percentile": 0.90214}, "CVE-2007-6653": {"epss_score": 0.02081, "epss_percentile": 0.83534}, "CVE-2007-6654": {"epss_score": 0.12049, "epss_percentile": 0.93555}, "CVE-2007-6655": {"epss_score": 0.0178, "epss_percentile": 0.82235}, "CVE-2007-6656": {"epss_score": 0.00874, "epss_percentile": 0.74769}, "CVE-2007-6657": {"epss_score": 0.01774, "epss_percentile": 0.82212}, "CVE-2007-6658": {"epss_score": 0.00866, "epss_percentile": 0.74629}, "CVE-2007-6659": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2007-6660": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2007-6661": {"epss_score": 0.00318, "epss_percentile": 0.54462}, "CVE-2007-6662": {"epss_score": 0.00092, "epss_percentile": 0.26518}, "CVE-2007-6663": {"epss_score": 0.0191, "epss_percentile": 0.82826}, "CVE-2007-6664": {"epss_score": 0.00289, "epss_percentile": 0.52008}, "CVE-2007-6665": {"epss_score": 0.00289, "epss_percentile": 0.52008}, "CVE-2007-6666": {"epss_score": 0.00345, "epss_percentile": 0.56552}, "CVE-2007-6667": {"epss_score": 0.00486, "epss_percentile": 0.64761}, "CVE-2007-6668": {"epss_score": 0.03928, "epss_percentile": 0.87969}, "CVE-2007-6669": {"epss_score": 0.01807, "epss_percentile": 0.82353}, "CVE-2007-6670": {"epss_score": 0.00361, "epss_percentile": 0.57721}, "CVE-2007-6671": {"epss_score": 0.00702, "epss_percentile": 0.71522}, "CVE-2007-6672": {"epss_score": 0.01109, "epss_percentile": 0.77647}, "CVE-2007-6673": {"epss_score": 0.01823, "epss_percentile": 0.82421}, "CVE-2007-6674": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2007-6675": {"epss_score": 0.00234, "epss_percentile": 0.4611}, "CVE-2007-6676": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2007-6677": {"epss_score": 0.00312, "epss_percentile": 0.53943}, "CVE-2007-6679": {"epss_score": 0.01325, "epss_percentile": 0.79477}, "CVE-2007-6680": {"epss_score": 0.00066, "epss_percentile": 0.20892}, "CVE-2007-6681": {"epss_score": 0.37649, "epss_percentile": 0.97061}, "CVE-2007-6682": {"epss_score": 0.33037, "epss_percentile": 0.96741}, "CVE-2007-6683": {"epss_score": 0.00735, "epss_percentile": 0.72295}, "CVE-2007-6684": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2007-6685": {"epss_score": 0.0063, "epss_percentile": 0.69688}, "CVE-2007-6686": {"epss_score": 0.0063, "epss_percentile": 0.69688}, "CVE-2007-6687": {"epss_score": 0.00535, "epss_percentile": 0.66834}, "CVE-2007-6688": {"epss_score": 0.01022, "epss_percentile": 0.76761}, "CVE-2007-6689": {"epss_score": 0.00817, "epss_percentile": 0.73838}, "CVE-2007-6690": {"epss_score": 0.00476, "epss_percentile": 0.64283}, "CVE-2007-6691": {"epss_score": 0.01135, "epss_percentile": 0.77909}, "CVE-2007-6692": {"epss_score": 0.0064, "epss_percentile": 0.69966}, "CVE-2007-6693": {"epss_score": 0.0063, "epss_percentile": 0.69688}, "CVE-2007-6694": {"epss_score": 0.01442, "epss_percentile": 0.80312}, "CVE-2007-6695": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-6696": {"epss_score": 0.00413, "epss_percentile": 0.6101}, "CVE-2007-6697": {"epss_score": 0.23835, "epss_percentile": 0.95821}, "CVE-2007-6698": {"epss_score": 0.05897, "epss_percentile": 0.90304}, "CVE-2007-6699": {"epss_score": 0.04725, "epss_percentile": 0.89062}, "CVE-2007-6700": {"epss_score": 0.03618, "epss_percentile": 0.87439}, "CVE-2007-6701": {"epss_score": 0.45495, "epss_percentile": 0.97489}, "CVE-2007-6702": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2007-6703": {"epss_score": 0.01029, "epss_percentile": 0.76831}, "CVE-2007-6704": {"epss_score": 0.07078, "epss_percentile": 0.91235}, "CVE-2007-6705": {"epss_score": 0.00052, "epss_percentile": 0.16466}, "CVE-2007-6706": {"epss_score": 0.03913, "epss_percentile": 0.87937}, "CVE-2007-6707": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2007-6708": {"epss_score": 0.00263, "epss_percentile": 0.49406}, "CVE-2007-6709": {"epss_score": 0.00709, "epss_percentile": 0.71697}, "CVE-2007-6711": {"epss_score": 0.00987, "epss_percentile": 0.76345}, "CVE-2007-6712": {"epss_score": 0.00044, "epss_percentile": 0.13624}, "CVE-2007-6713": {"epss_score": 0.00355, "epss_percentile": 0.57296}, "CVE-2007-6714": {"epss_score": 0.01435, "epss_percentile": 0.80268}, "CVE-2007-6715": {"epss_score": 0.0064, "epss_percentile": 0.69974}, "CVE-2007-6716": {"epss_score": 0.00042, "epss_percentile": 0.12739}, "CVE-2007-6717": {"epss_score": 0.0006, "epss_percentile": 0.19203}, "CVE-2007-6718": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2007-6719": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2007-6720": {"epss_score": 0.00968, "epss_percentile": 0.76083}, "CVE-2007-6721": {"epss_score": 0.00856, "epss_percentile": 0.74483}, "CVE-2007-6722": {"epss_score": 0.00167, "epss_percentile": 0.38347}, "CVE-2007-6723": {"epss_score": 0.00479, "epss_percentile": 0.64442}, "CVE-2007-6724": {"epss_score": 0.00167, "epss_percentile": 0.38347}, "CVE-2007-6725": {"epss_score": 0.06173, "epss_percentile": 0.90531}, "CVE-2007-6726": {"epss_score": 0.01747, "epss_percentile": 0.82075}, "CVE-2007-6727": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2007-6728": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2007-6729": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2007-6730": {"epss_score": 0.00162, "epss_percentile": 0.37649}, "CVE-2007-6731": {"epss_score": 0.06839, "epss_percentile": 0.9106}, "CVE-2007-6732": {"epss_score": 0.04776, "epss_percentile": 0.89131}, "CVE-2007-6733": {"epss_score": 0.00038, "epss_percentile": 0.11074}, "CVE-2007-6734": {"epss_score": 0.00216, "epss_percentile": 0.4416}, "CVE-2007-6735": {"epss_score": 0.00132, "epss_percentile": 0.33507}, "CVE-2007-6736": {"epss_score": 0.00337, "epss_percentile": 0.56011}, "CVE-2007-6737": {"epss_score": 0.00539, "epss_percentile": 0.66977}, "CVE-2007-6738": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2007-6739": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2007-6740": {"epss_score": 0.00513, "epss_percentile": 0.65938}, "CVE-2007-6741": {"epss_score": 0.00606, "epss_percentile": 0.69028}, "CVE-2007-6742": {"epss_score": 0.00384, "epss_percentile": 0.59152}, "CVE-2007-6743": {"epss_score": 0.0036, "epss_percentile": 0.57662}, "CVE-2007-6744": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2007-6745": {"epss_score": 0.00651, "epss_percentile": 0.70282}, "CVE-2007-6746": {"epss_score": 0.0025, "epss_percentile": 0.48103}, "CVE-2007-6750": {"epss_score": 0.8377, "epss_percentile": 0.99261}, "CVE-2007-6751": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2007-6752": {"epss_score": 0.01742, "epss_percentile": 0.8205}, "CVE-2007-6753": {"epss_score": 0.01387, "epss_percentile": 0.79918}, "CVE-2007-6754": {"epss_score": 0.00323, "epss_percentile": 0.54883}, "CVE-2007-6755": {"epss_score": 0.00328, "epss_percentile": 0.55275}, "CVE-2007-6756": {"epss_score": 0.00053, "epss_percentile": 0.16824}, "CVE-2007-6757": {"epss_score": 0.01611, "epss_percentile": 0.81326}, "CVE-2007-6758": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2007-6759": {"epss_score": 0.00789, "epss_percentile": 0.73357}, "CVE-2007-6760": {"epss_score": 0.00789, "epss_percentile": 0.73357}, "CVE-2007-6761": {"epss_score": 0.00118, "epss_percentile": 0.31426}, "CVE-2007-6762": {"epss_score": 0.008, "epss_percentile": 0.73544}, "CVE-2007-6763": {"epss_score": 0.00485, "epss_percentile": 0.64712}, "CVE-2008-0001": {"epss_score": 0.00038, "epss_percentile": 0.11213}, "CVE-2008-0002": {"epss_score": 0.04097, "epss_percentile": 0.88252}, "CVE-2008-0003": {"epss_score": 0.2951, "epss_percentile": 0.96449}, "CVE-2008-0005": {"epss_score": 0.02168, "epss_percentile": 0.83857}, "CVE-2008-0006": {"epss_score": 0.29274, "epss_percentile": 0.96429}, "CVE-2008-0007": {"epss_score": 0.00107, "epss_percentile": 0.29696}, "CVE-2008-0008": {"epss_score": 0.0005, "epss_percentile": 0.15762}, "CVE-2008-0009": {"epss_score": 0.00943, "epss_percentile": 0.75777}, "CVE-2008-0010": {"epss_score": 0.00225, "epss_percentile": 0.45151}, "CVE-2008-0011": {"epss_score": 0.62306, "epss_percentile": 0.98288}, "CVE-2008-0012": {"epss_score": 0.1801, "epss_percentile": 0.94944}, "CVE-2008-0013": {"epss_score": 0.1801, "epss_percentile": 0.94944}, "CVE-2008-0014": {"epss_score": 0.1801, "epss_percentile": 0.94944}, "CVE-2008-0015": {"epss_score": 0.87518, "epss_percentile": 0.99432}, "CVE-2008-0016": {"epss_score": 0.47313, "epss_percentile": 0.97582}, "CVE-2008-0017": {"epss_score": 0.14498, "epss_percentile": 0.94224}, "CVE-2008-0020": {"epss_score": 0.54706, "epss_percentile": 0.9794}, "CVE-2008-0026": {"epss_score": 0.00355, "epss_percentile": 0.5729}, "CVE-2008-0027": {"epss_score": 0.35513, "epss_percentile": 0.96917}, "CVE-2008-0028": {"epss_score": 0.01753, "epss_percentile": 0.82111}, "CVE-2008-0029": {"epss_score": 0.01014, "epss_percentile": 0.76649}, "CVE-2008-0031": {"epss_score": 0.02383, "epss_percentile": 0.84573}, "CVE-2008-0032": {"epss_score": 0.05357, "epss_percentile": 0.8978}, "CVE-2008-0033": {"epss_score": 0.30598, "epss_percentile": 0.96555}, "CVE-2008-0034": {"epss_score": 0.0007, "epss_percentile": 0.21689}, "CVE-2008-0035": {"epss_score": 0.29258, "epss_percentile": 0.96428}, "CVE-2008-0036": {"epss_score": 0.12973, "epss_percentile": 0.93832}, "CVE-2008-0037": {"epss_score": 0.00263, "epss_percentile": 0.49475}, "CVE-2008-0038": {"epss_score": 0.00073, "epss_percentile": 0.22638}, "CVE-2008-0039": {"epss_score": 0.00482, "epss_percentile": 0.64528}, "CVE-2008-0040": {"epss_score": 0.06034, "epss_percentile": 0.90425}, "CVE-2008-0041": {"epss_score": 0.00347, "epss_percentile": 0.56793}, "CVE-2008-0042": {"epss_score": 0.03473, "epss_percentile": 0.87202}, "CVE-2008-0043": {"epss_score": 0.04882, "epss_percentile": 0.8925}, "CVE-2008-0044": {"epss_score": 0.06246, "epss_percentile": 0.90603}, "CVE-2008-0045": {"epss_score": 0.01022, "epss_percentile": 0.76757}, "CVE-2008-0046": {"epss_score": 0.00577, "epss_percentile": 0.68154}, "CVE-2008-0047": {"epss_score": 0.25276, "epss_percentile": 0.96008}, "CVE-2008-0048": {"epss_score": 0.0223, "epss_percentile": 0.84084}, "CVE-2008-0049": {"epss_score": 0.00193, "epss_percentile": 0.41399}, "CVE-2008-0050": {"epss_score": 0.00693, "epss_percentile": 0.71314}, "CVE-2008-0051": {"epss_score": 0.00058, "epss_percentile": 0.18402}, "CVE-2008-0052": {"epss_score": 0.01581, "epss_percentile": 0.81136}, "CVE-2008-0053": {"epss_score": 0.27566, "epss_percentile": 0.96259}, "CVE-2008-0054": {"epss_score": 0.01386, "epss_percentile": 0.79911}, "CVE-2008-0055": {"epss_score": 0.00045, "epss_percentile": 0.13989}, "CVE-2008-0056": {"epss_score": 0.0219, "epss_percentile": 0.83934}, "CVE-2008-0057": {"epss_score": 0.02208, "epss_percentile": 0.84009}, "CVE-2008-0058": {"epss_score": 0.04214, "epss_percentile": 0.88404}, "CVE-2008-0059": {"epss_score": 0.00963, "epss_percentile": 0.76021}, "CVE-2008-0060": {"epss_score": 0.0167, "epss_percentile": 0.81668}, "CVE-2008-0061": {"epss_score": 0.01621, "epss_percentile": 0.81395}, "CVE-2008-0062": {"epss_score": 0.20491, "epss_percentile": 0.95355}, "CVE-2008-0063": {"epss_score": 0.05193, "epss_percentile": 0.89597}, "CVE-2008-0064": {"epss_score": 0.06939, "epss_percentile": 0.9113}, "CVE-2008-0065": {"epss_score": 0.7236, "epss_percentile": 0.98705}, "CVE-2008-0066": {"epss_score": 0.27076, "epss_percentile": 0.96204}, "CVE-2008-0067": {"epss_score": 0.81949, "epss_percentile": 0.99166}, "CVE-2008-0068": {"epss_score": 0.58678, "epss_percentile": 0.98131}, "CVE-2008-0069": {"epss_score": 0.12715, "epss_percentile": 0.93755}, "CVE-2008-0070": {"epss_score": 0.00607, "epss_percentile": 0.69031}, "CVE-2008-0071": {"epss_score": 0.2443, "epss_percentile": 0.9592}, "CVE-2008-0072": {"epss_score": 0.13415, "epss_percentile": 0.93955}, "CVE-2008-0073": {"epss_score": 0.01592, "epss_percentile": 0.81224}, "CVE-2008-0074": {"epss_score": 0.01574, "epss_percentile": 0.81103}, "CVE-2008-0075": {"epss_score": 0.68582, "epss_percentile": 0.98554}, "CVE-2008-0076": {"epss_score": 0.4845, "epss_percentile": 0.97638}, "CVE-2008-0077": {"epss_score": 0.63018, "epss_percentile": 0.98317}, "CVE-2008-0078": {"epss_score": 0.51546, "epss_percentile": 0.97786}, "CVE-2008-0080": {"epss_score": 0.44006, "epss_percentile": 0.97414}, "CVE-2008-0081": {"epss_score": 0.81775, "epss_percentile": 0.99155}, "CVE-2008-0082": {"epss_score": 0.60161, "epss_percentile": 0.98195}, "CVE-2008-0083": {"epss_score": 0.59309, "epss_percentile": 0.9816}, "CVE-2008-0084": {"epss_score": 0.76395, "epss_percentile": 0.9889}, "CVE-2008-0085": {"epss_score": 0.30428, "epss_percentile": 0.96538}, "CVE-2008-0086": {"epss_score": 0.73361, "epss_percentile": 0.98749}, "CVE-2008-0087": {"epss_score": 0.56873, "epss_percentile": 0.98039}, "CVE-2008-0088": {"epss_score": 0.69057, "epss_percentile": 0.98576}, "CVE-2008-0089": {"epss_score": 0.00618, "epss_percentile": 0.6938}, "CVE-2008-0090": {"epss_score": 0.12537, "epss_percentile": 0.93711}, "CVE-2008-0091": {"epss_score": 0.10323, "epss_percentile": 0.92944}, "CVE-2008-0092": {"epss_score": 0.04385, "epss_percentile": 0.88631}, "CVE-2008-0093": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-0094": {"epss_score": 0.09218, "epss_percentile": 0.92453}, "CVE-2008-0095": {"epss_score": 0.26778, "epss_percentile": 0.9618}, "CVE-2008-0096": {"epss_score": 0.06811, "epss_percentile": 0.91042}, "CVE-2008-0097": {"epss_score": 0.01909, "epss_percentile": 0.82819}, "CVE-2008-0098": {"epss_score": 0.06819, "epss_percentile": 0.91045}, "CVE-2008-0099": {"epss_score": 0.00404, "epss_percentile": 0.60444}, "CVE-2008-0100": {"epss_score": 0.15084, "epss_percentile": 0.94358}, "CVE-2008-0101": {"epss_score": 0.03503, "epss_percentile": 0.87252}, "CVE-2008-0102": {"epss_score": 0.59612, "epss_percentile": 0.98171}, "CVE-2008-0103": {"epss_score": 0.55516, "epss_percentile": 0.97981}, "CVE-2008-0104": {"epss_score": 0.4845, "epss_percentile": 0.97638}, "CVE-2008-0105": {"epss_score": 0.7999, "epss_percentile": 0.99065}, "CVE-2008-0106": {"epss_score": 0.70602, "epss_percentile": 0.98637}, "CVE-2008-0107": {"epss_score": 0.57271, "epss_percentile": 0.98055}, "CVE-2008-0108": {"epss_score": 0.75419, "epss_percentile": 0.98843}, "CVE-2008-0109": {"epss_score": 0.5578, "epss_percentile": 0.97995}, "CVE-2008-0110": {"epss_score": 0.54784, "epss_percentile": 0.97944}, "CVE-2008-0111": {"epss_score": 0.69696, "epss_percentile": 0.98599}, "CVE-2008-0112": {"epss_score": 0.71916, "epss_percentile": 0.98686}, "CVE-2008-0113": {"epss_score": 0.66516, "epss_percentile": 0.98466}, "CVE-2008-0114": {"epss_score": 0.66725, "epss_percentile": 0.98475}, "CVE-2008-0115": {"epss_score": 0.71916, "epss_percentile": 0.98686}, "CVE-2008-0116": {"epss_score": 0.74375, "epss_percentile": 0.98797}, "CVE-2008-0117": {"epss_score": 0.7417, "epss_percentile": 0.9879}, "CVE-2008-0118": {"epss_score": 0.79322, "epss_percentile": 0.99032}, "CVE-2008-0119": {"epss_score": 0.55858, "epss_percentile": 0.98}, "CVE-2008-0120": {"epss_score": 0.68554, "epss_percentile": 0.98553}, "CVE-2008-0121": {"epss_score": 0.57786, "epss_percentile": 0.98083}, "CVE-2008-0122": {"epss_score": 0.01616, "epss_percentile": 0.81359}, "CVE-2008-0123": {"epss_score": 0.01066, "epss_percentile": 0.7722}, "CVE-2008-0124": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2008-0125": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-0127": {"epss_score": 0.24587, "epss_percentile": 0.95936}, "CVE-2008-0128": {"epss_score": 0.03858, "epss_percentile": 0.8786}, "CVE-2008-0129": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0130": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-0131": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-0132": {"epss_score": 0.05243, "epss_percentile": 0.89653}, "CVE-2008-0133": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0134": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0135": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2008-0136": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-0137": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2008-0138": {"epss_score": 0.02701, "epss_percentile": 0.85455}, "CVE-2008-0139": {"epss_score": 0.08221, "epss_percentile": 0.91936}, "CVE-2008-0140": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2008-0141": {"epss_score": 0.0588, "epss_percentile": 0.9029}, "CVE-2008-0142": {"epss_score": 0.00404, "epss_percentile": 0.60444}, "CVE-2008-0143": {"epss_score": 0.02822, "epss_percentile": 0.85747}, "CVE-2008-0144": {"epss_score": 0.13433, "epss_percentile": 0.93961}, "CVE-2008-0145": {"epss_score": 0.00761, "epss_percentile": 0.72819}, "CVE-2008-0146": {"epss_score": 0.00334, "epss_percentile": 0.55724}, "CVE-2008-0147": {"epss_score": 0.00377, "epss_percentile": 0.58731}, "CVE-2008-0148": {"epss_score": 0.05981, "epss_percentile": 0.90379}, "CVE-2008-0149": {"epss_score": 0.06612, "epss_percentile": 0.90888}, "CVE-2008-0150": {"epss_score": 0.00306, "epss_percentile": 0.53427}, "CVE-2008-0151": {"epss_score": 0.04134, "epss_percentile": 0.88305}, "CVE-2008-0152": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2008-0153": {"epss_score": 0.04403, "epss_percentile": 0.88648}, "CVE-2008-0154": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0155": {"epss_score": 0.02108, "epss_percentile": 0.83639}, "CVE-2008-0156": {"epss_score": 0.00168, "epss_percentile": 0.38409}, "CVE-2008-0157": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0158": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2008-0159": {"epss_score": 0.00289, "epss_percentile": 0.52008}, "CVE-2008-0162": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2008-0163": {"epss_score": 0.00032, "epss_percentile": 0.09022}, "CVE-2008-0164": {"epss_score": 0.00242, "epss_percentile": 0.47381}, "CVE-2008-0165": {"epss_score": 0.00242, "epss_percentile": 0.4739}, "CVE-2008-0166": {"epss_score": 0.03966, "epss_percentile": 0.8803}, "CVE-2008-0167": {"epss_score": 0.01069, "epss_percentile": 0.77247}, "CVE-2008-0169": {"epss_score": 0.00468, "epss_percentile": 0.63881}, "CVE-2008-0171": {"epss_score": 0.03004, "epss_percentile": 0.86178}, "CVE-2008-0172": {"epss_score": 0.01929, "epss_percentile": 0.82933}, "CVE-2008-0173": {"epss_score": 0.00605, "epss_percentile": 0.68995}, "CVE-2008-0174": {"epss_score": 0.03223, "epss_percentile": 0.86677}, "CVE-2008-0175": {"epss_score": 0.33866, "epss_percentile": 0.9681}, "CVE-2008-0176": {"epss_score": 0.30007, "epss_percentile": 0.96493}, "CVE-2008-0177": {"epss_score": 0.54461, "epss_percentile": 0.97926}, "CVE-2008-0178": {"epss_score": 0.10187, "epss_percentile": 0.92885}, "CVE-2008-0179": {"epss_score": 0.03349, "epss_percentile": 0.86957}, "CVE-2008-0180": {"epss_score": 0.01442, "epss_percentile": 0.8031}, "CVE-2008-0181": {"epss_score": 0.01442, "epss_percentile": 0.8031}, "CVE-2008-0182": {"epss_score": 0.00285, "epss_percentile": 0.51661}, "CVE-2008-0184": {"epss_score": 0.01723, "epss_percentile": 0.81947}, "CVE-2008-0185": {"epss_score": 0.0055, "epss_percentile": 0.67341}, "CVE-2008-0186": {"epss_score": 0.03477, "epss_percentile": 0.87212}, "CVE-2008-0187": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0190": {"epss_score": 0.00653, "epss_percentile": 0.70323}, "CVE-2008-0191": {"epss_score": 0.00915, "epss_percentile": 0.75411}, "CVE-2008-0192": {"epss_score": 0.02202, "epss_percentile": 0.83982}, "CVE-2008-0193": {"epss_score": 0.01742, "epss_percentile": 0.82052}, "CVE-2008-0194": {"epss_score": 0.00594, "epss_percentile": 0.68672}, "CVE-2008-0195": {"epss_score": 0.02245, "epss_percentile": 0.84127}, "CVE-2008-0196": {"epss_score": 0.00202, "epss_percentile": 0.42418}, "CVE-2008-0197": {"epss_score": 0.00333, "epss_percentile": 0.55626}, "CVE-2008-0198": {"epss_score": 0.00242, "epss_percentile": 0.47352}, "CVE-2008-0199": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-0200": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-0201": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-0202": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2008-0203": {"epss_score": 0.00223, "epss_percentile": 0.44847}, "CVE-2008-0204": {"epss_score": 0.00223, "epss_percentile": 0.44847}, "CVE-2008-0205": {"epss_score": 0.00397, "epss_percentile": 0.5994}, "CVE-2008-0206": {"epss_score": 0.00223, "epss_percentile": 0.44847}, "CVE-2008-0207": {"epss_score": 0.00784, "epss_percentile": 0.73246}, "CVE-2008-0208": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2008-0209": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2008-0210": {"epss_score": 0.01876, "epss_percentile": 0.82659}, "CVE-2008-0211": {"epss_score": 0.00047, "epss_percentile": 0.14707}, "CVE-2008-0212": {"epss_score": 0.00612, "epss_percentile": 0.69237}, "CVE-2008-0213": {"epss_score": 0.04525, "epss_percentile": 0.88805}, "CVE-2008-0214": {"epss_score": 0.0134, "epss_percentile": 0.79579}, "CVE-2008-0215": {"epss_score": 0.01105, "epss_percentile": 0.77609}, "CVE-2008-0216": {"epss_score": 0.00071, "epss_percentile": 0.22041}, "CVE-2008-0217": {"epss_score": 0.00036, "epss_percentile": 0.1021}, "CVE-2008-0218": {"epss_score": 0.00401, "epss_percentile": 0.60231}, "CVE-2008-0219": {"epss_score": 0.00541, "epss_percentile": 0.6703}, "CVE-2008-0220": {"epss_score": 0.42066, "epss_percentile": 0.9731}, "CVE-2008-0221": {"epss_score": 0.02606, "epss_percentile": 0.85222}, "CVE-2008-0222": {"epss_score": 0.06228, "epss_percentile": 0.90586}, "CVE-2008-0223": {"epss_score": 0.11647, "epss_percentile": 0.93428}, "CVE-2008-0224": {"epss_score": 0.00338, "epss_percentile": 0.56139}, "CVE-2008-0225": {"epss_score": 0.0787, "epss_percentile": 0.91735}, "CVE-2008-0226": {"epss_score": 0.92107, "epss_percentile": 0.99692}, "CVE-2008-0227": {"epss_score": 0.05836, "epss_percentile": 0.90249}, "CVE-2008-0228": {"epss_score": 0.01149, "epss_percentile": 0.78023}, "CVE-2008-0229": {"epss_score": 0.00834, "epss_percentile": 0.74098}, "CVE-2008-0230": {"epss_score": 0.04521, "epss_percentile": 0.888}, "CVE-2008-0231": {"epss_score": 0.03955, "epss_percentile": 0.88003}, "CVE-2008-0232": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0233": {"epss_score": 0.02007, "epss_percentile": 0.83236}, "CVE-2008-0234": {"epss_score": 0.44519, "epss_percentile": 0.97441}, "CVE-2008-0235": {"epss_score": 0.45239, "epss_percentile": 0.97478}, "CVE-2008-0236": {"epss_score": 0.3465, "epss_percentile": 0.96863}, "CVE-2008-0237": {"epss_score": 0.33207, "epss_percentile": 0.96753}, "CVE-2008-0238": {"epss_score": 0.02418, "epss_percentile": 0.84695}, "CVE-2008-0239": {"epss_score": 0.06358, "epss_percentile": 0.90697}, "CVE-2008-0240": {"epss_score": 0.06197, "epss_percentile": 0.90557}, "CVE-2008-0241": {"epss_score": 0.01952, "epss_percentile": 0.83023}, "CVE-2008-0242": {"epss_score": 0.00048, "epss_percentile": 0.15268}, "CVE-2008-0243": {"epss_score": 0.00556, "epss_percentile": 0.67511}, "CVE-2008-0244": {"epss_score": 0.89824, "epss_percentile": 0.99544}, "CVE-2008-0245": {"epss_score": 0.04882, "epss_percentile": 0.8925}, "CVE-2008-0246": {"epss_score": 0.05117, "epss_percentile": 0.89516}, "CVE-2008-0247": {"epss_score": 0.3603, "epss_percentile": 0.96951}, "CVE-2008-0248": {"epss_score": 0.08863, "epss_percentile": 0.92292}, "CVE-2008-0249": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2008-0250": {"epss_score": 0.40863, "epss_percentile": 0.97241}, "CVE-2008-0251": {"epss_score": 0.02624, "epss_percentile": 0.85261}, "CVE-2008-0252": {"epss_score": 0.02185, "epss_percentile": 0.83918}, "CVE-2008-0253": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0254": {"epss_score": 0.00541, "epss_percentile": 0.6703}, "CVE-2008-0255": {"epss_score": 0.00338, "epss_percentile": 0.56139}, "CVE-2008-0256": {"epss_score": 0.00541, "epss_percentile": 0.6703}, "CVE-2008-0257": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-0258": {"epss_score": 0.00463, "epss_percentile": 0.63685}, "CVE-2008-0259": {"epss_score": 0.04249, "epss_percentile": 0.8845}, "CVE-2008-0260": {"epss_score": 0.04991, "epss_percentile": 0.89368}, "CVE-2008-0261": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2008-0262": {"epss_score": 0.00498, "epss_percentile": 0.65226}, "CVE-2008-0263": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-0264": {"epss_score": 0.0148, "epss_percentile": 0.80566}, "CVE-2008-0265": {"epss_score": 0.11248, "epss_percentile": 0.93278}, "CVE-2008-0266": {"epss_score": 0.00401, "epss_percentile": 0.60203}, "CVE-2008-0267": {"epss_score": 0.01702, "epss_percentile": 0.81839}, "CVE-2008-0268": {"epss_score": 0.02443, "epss_percentile": 0.84759}, "CVE-2008-0269": {"epss_score": 0.00064, "epss_percentile": 0.20313}, "CVE-2008-0270": {"epss_score": 0.00393, "epss_percentile": 0.59738}, "CVE-2008-0271": {"epss_score": 0.00145, "epss_percentile": 0.35446}, "CVE-2008-0272": {"epss_score": 0.00295, "epss_percentile": 0.52482}, "CVE-2008-0273": {"epss_score": 0.00463, "epss_percentile": 0.63627}, "CVE-2008-0274": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2008-0275": {"epss_score": 0.0019, "epss_percentile": 0.41006}, "CVE-2008-0276": {"epss_score": 0.0021, "epss_percentile": 0.43482}, "CVE-2008-0277": {"epss_score": 0.01041, "epss_percentile": 0.76968}, "CVE-2008-0278": {"epss_score": 0.00288, "epss_percentile": 0.51875}, "CVE-2008-0279": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0280": {"epss_score": 0.00884, "epss_percentile": 0.74929}, "CVE-2008-0281": {"epss_score": 0.00348, "epss_percentile": 0.56813}, "CVE-2008-0282": {"epss_score": 0.00541, "epss_percentile": 0.6703}, "CVE-2008-0283": {"epss_score": 0.04079, "epss_percentile": 0.88216}, "CVE-2008-0284": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-0285": {"epss_score": 0.01238, "epss_percentile": 0.78788}, "CVE-2008-0286": {"epss_score": 0.008, "epss_percentile": 0.73547}, "CVE-2008-0287": {"epss_score": 0.04139, "epss_percentile": 0.8831}, "CVE-2008-0288": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0289": {"epss_score": 0.02082, "epss_percentile": 0.83537}, "CVE-2008-0290": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0291": {"epss_score": 0.00884, "epss_percentile": 0.74929}, "CVE-2008-0292": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-0293": {"epss_score": 0.00235, "epss_percentile": 0.46238}, "CVE-2008-0294": {"epss_score": 0.00325, "epss_percentile": 0.55009}, "CVE-2008-0295": {"epss_score": 0.32938, "epss_percentile": 0.96737}, "CVE-2008-0296": {"epss_score": 0.11636, "epss_percentile": 0.93425}, "CVE-2008-0297": {"epss_score": 0.04492, "epss_percentile": 0.88759}, "CVE-2008-0298": {"epss_score": 0.06669, "epss_percentile": 0.9093}, "CVE-2008-0299": {"epss_score": 0.01232, "epss_percentile": 0.78741}, "CVE-2008-0300": {"epss_score": 0.04272, "epss_percentile": 0.88478}, "CVE-2008-0301": {"epss_score": 0.01409, "epss_percentile": 0.80072}, "CVE-2008-0302": {"epss_score": 0.00077, "epss_percentile": 0.23327}, "CVE-2008-0303": {"epss_score": 0.01367, "epss_percentile": 0.79781}, "CVE-2008-0304": {"epss_score": 0.30512, "epss_percentile": 0.96548}, "CVE-2008-0306": {"epss_score": 0.00051, "epss_percentile": 0.16103}, "CVE-2008-0307": {"epss_score": 0.04226, "epss_percentile": 0.88416}, "CVE-2008-0308": {"epss_score": 0.01725, "epss_percentile": 0.81953}, "CVE-2008-0309": {"epss_score": 0.05161, "epss_percentile": 0.8956}, "CVE-2008-0310": {"epss_score": 0.00414, "epss_percentile": 0.61024}, "CVE-2008-0311": {"epss_score": 0.65003, "epss_percentile": 0.984}, "CVE-2008-0312": {"epss_score": 0.18331, "epss_percentile": 0.94997}, "CVE-2008-0313": {"epss_score": 0.06221, "epss_percentile": 0.9058}, "CVE-2008-0314": {"epss_score": 0.2396, "epss_percentile": 0.95838}, "CVE-2008-0318": {"epss_score": 0.15622, "epss_percentile": 0.94471}, "CVE-2008-0320": {"epss_score": 0.82, "epss_percentile": 0.99168}, "CVE-2008-0322": {"epss_score": 0.00648, "epss_percentile": 0.7021}, "CVE-2008-0324": {"epss_score": 0.00594, "epss_percentile": 0.68672}, "CVE-2008-0325": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0326": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0327": {"epss_score": 0.00486, "epss_percentile": 0.64761}, "CVE-2008-0328": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0329": {"epss_score": 0.05654, "epss_percentile": 0.90086}, "CVE-2008-0330": {"epss_score": 0.01366, "epss_percentile": 0.79779}, "CVE-2008-0331": {"epss_score": 0.00725, "epss_percentile": 0.72051}, "CVE-2008-0332": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2008-0333": {"epss_score": 0.07038, "epss_percentile": 0.91206}, "CVE-2008-0334": {"epss_score": 0.00308, "epss_percentile": 0.53625}, "CVE-2008-0335": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0336": {"epss_score": 0.00145, "epss_percentile": 0.35446}, "CVE-2008-0337": {"epss_score": 0.22732, "epss_percentile": 0.95676}, "CVE-2008-0338": {"epss_score": 0.07533, "epss_percentile": 0.91521}, "CVE-2008-0339": {"epss_score": 0.27187, "epss_percentile": 0.96218}, "CVE-2008-0340": {"epss_score": 0.01716, "epss_percentile": 0.81903}, "CVE-2008-0341": {"epss_score": 0.023, "epss_percentile": 0.84309}, "CVE-2008-0342": {"epss_score": 0.023, "epss_percentile": 0.84309}, "CVE-2008-0343": {"epss_score": 0.01716, "epss_percentile": 0.81903}, "CVE-2008-0344": {"epss_score": 0.01716, "epss_percentile": 0.81903}, "CVE-2008-0345": {"epss_score": 0.01716, "epss_percentile": 0.81903}, "CVE-2008-0346": {"epss_score": 0.02313, "epss_percentile": 0.84345}, "CVE-2008-0347": {"epss_score": 0.0246, "epss_percentile": 0.84823}, "CVE-2008-0348": {"epss_score": 0.01716, "epss_percentile": 0.81903}, "CVE-2008-0349": {"epss_score": 0.01716, "epss_percentile": 0.81903}, "CVE-2008-0350": {"epss_score": 0.04882, "epss_percentile": 0.8925}, "CVE-2008-0351": {"epss_score": 0.01704, "epss_percentile": 0.81847}, "CVE-2008-0352": {"epss_score": 0.05889, "epss_percentile": 0.90297}, "CVE-2008-0353": {"epss_score": 0.00541, "epss_percentile": 0.6703}, "CVE-2008-0354": {"epss_score": 0.01177, "epss_percentile": 0.7828}, "CVE-2008-0355": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0356": {"epss_score": 0.71167, "epss_percentile": 0.98658}, "CVE-2008-0357": {"epss_score": 0.06012, "epss_percentile": 0.90409}, "CVE-2008-0358": {"epss_score": 0.00611, "epss_percentile": 0.69196}, "CVE-2008-0359": {"epss_score": 0.07399, "epss_percentile": 0.91452}, "CVE-2008-0360": {"epss_score": 0.00569, "epss_percentile": 0.67917}, "CVE-2008-0361": {"epss_score": 0.07847, "epss_percentile": 0.91717}, "CVE-2008-0362": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0363": {"epss_score": 0.00587, "epss_percentile": 0.68468}, "CVE-2008-0364": {"epss_score": 0.05839, "epss_percentile": 0.9025}, "CVE-2008-0365": {"epss_score": 0.00132, "epss_percentile": 0.33524}, "CVE-2008-0366": {"epss_score": 0.00068, "epss_percentile": 0.21323}, "CVE-2008-0367": {"epss_score": 0.00645, "epss_percentile": 0.7012}, "CVE-2008-0368": {"epss_score": 0.00055, "epss_percentile": 0.17426}, "CVE-2008-0369": {"epss_score": 0.00052, "epss_percentile": 0.16498}, "CVE-2008-0370": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0371": {"epss_score": 0.01109, "epss_percentile": 0.7765}, "CVE-2008-0372": {"epss_score": 0.0762, "epss_percentile": 0.91575}, "CVE-2008-0373": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2008-0374": {"epss_score": 0.01755, "epss_percentile": 0.82121}, "CVE-2008-0375": {"epss_score": 0.0219, "epss_percentile": 0.83931}, "CVE-2008-0376": {"epss_score": 0.26281, "epss_percentile": 0.96134}, "CVE-2008-0377": {"epss_score": 0.00518, "epss_percentile": 0.66098}, "CVE-2008-0378": {"epss_score": 0.01567, "epss_percentile": 0.81076}, "CVE-2008-0379": {"epss_score": 0.13447, "epss_percentile": 0.93966}, "CVE-2008-0380": {"epss_score": 0.06248, "epss_percentile": 0.90606}, "CVE-2008-0381": {"epss_score": 0.00357, "epss_percentile": 0.57398}, "CVE-2008-0382": {"epss_score": 0.73116, "epss_percentile": 0.98737}, "CVE-2008-0383": {"epss_score": 0.01179, "epss_percentile": 0.78296}, "CVE-2008-0384": {"epss_score": 0.00326, "epss_percentile": 0.55085}, "CVE-2008-0385": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-0386": {"epss_score": 0.02547, "epss_percentile": 0.85065}, "CVE-2008-0387": {"epss_score": 0.5991, "epss_percentile": 0.98187}, "CVE-2008-0388": {"epss_score": 0.02201, "epss_percentile": 0.8398}, "CVE-2008-0389": {"epss_score": 0.01377, "epss_percentile": 0.79843}, "CVE-2008-0390": {"epss_score": 0.04515, "epss_percentile": 0.8879}, "CVE-2008-0391": {"epss_score": 0.04706, "epss_percentile": 0.89031}, "CVE-2008-0392": {"epss_score": 0.50745, "epss_percentile": 0.97748}, "CVE-2008-0393": {"epss_score": 0.04249, "epss_percentile": 0.8845}, "CVE-2008-0394": {"epss_score": 0.13163, "epss_percentile": 0.93888}, "CVE-2008-0395": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-0396": {"epss_score": 0.07791, "epss_percentile": 0.91683}, "CVE-2008-0397": {"epss_score": 0.0047, "epss_percentile": 0.63984}, "CVE-2008-0398": {"epss_score": 0.03477, "epss_percentile": 0.87212}, "CVE-2008-0399": {"epss_score": 0.12551, "epss_percentile": 0.93713}, "CVE-2008-0400": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-0401": {"epss_score": 0.2575, "epss_percentile": 0.96063}, "CVE-2008-0402": {"epss_score": 0.0043, "epss_percentile": 0.6201}, "CVE-2008-0403": {"epss_score": 0.10024, "epss_percentile": 0.9282}, "CVE-2008-0404": {"epss_score": 0.00817, "epss_percentile": 0.73849}, "CVE-2008-0405": {"epss_score": 0.01262, "epss_percentile": 0.78982}, "CVE-2008-0406": {"epss_score": 0.0762, "epss_percentile": 0.91574}, "CVE-2008-0407": {"epss_score": 0.0044, "epss_percentile": 0.62646}, "CVE-2008-0408": {"epss_score": 0.00594, "epss_percentile": 0.68676}, "CVE-2008-0409": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2008-0410": {"epss_score": 0.00594, "epss_percentile": 0.68676}, "CVE-2008-0411": {"epss_score": 0.15307, "epss_percentile": 0.94406}, "CVE-2008-0412": {"epss_score": 0.08849, "epss_percentile": 0.92283}, "CVE-2008-0413": {"epss_score": 0.06094, "epss_percentile": 0.90476}, "CVE-2008-0414": {"epss_score": 0.01675, "epss_percentile": 0.817}, "CVE-2008-0415": {"epss_score": 0.01482, "epss_percentile": 0.80582}, "CVE-2008-0416": {"epss_score": 0.06627, "epss_percentile": 0.90899}, "CVE-2008-0417": {"epss_score": 0.01857, "epss_percentile": 0.82574}, "CVE-2008-0418": {"epss_score": 0.38662, "epss_percentile": 0.97113}, "CVE-2008-0419": {"epss_score": 0.18686, "epss_percentile": 0.95053}, "CVE-2008-0420": {"epss_score": 0.02102, "epss_percentile": 0.83607}, "CVE-2008-0421": {"epss_score": 0.00213, "epss_percentile": 0.43921}, "CVE-2008-0422": {"epss_score": 0.01514, "epss_percentile": 0.80793}, "CVE-2008-0423": {"epss_score": 0.09729, "epss_percentile": 0.92679}, "CVE-2008-0424": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0425": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2008-0426": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0427": {"epss_score": 0.1569, "epss_percentile": 0.94485}, "CVE-2008-0428": {"epss_score": 0.0123, "epss_percentile": 0.78726}, "CVE-2008-0429": {"epss_score": 0.01033, "epss_percentile": 0.76881}, "CVE-2008-0430": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0431": {"epss_score": 0.04654, "epss_percentile": 0.88967}, "CVE-2008-0432": {"epss_score": 0.00474, "epss_percentile": 0.64166}, "CVE-2008-0433": {"epss_score": 0.02143, "epss_percentile": 0.83756}, "CVE-2008-0434": {"epss_score": 0.19644, "epss_percentile": 0.95219}, "CVE-2008-0435": {"epss_score": 0.04508, "epss_percentile": 0.88778}, "CVE-2008-0436": {"epss_score": 0.00564, "epss_percentile": 0.67752}, "CVE-2008-0437": {"epss_score": 0.32493, "epss_percentile": 0.96705}, "CVE-2008-0438": {"epss_score": 0.06134, "epss_percentile": 0.90506}, "CVE-2008-0439": {"epss_score": 0.0217, "epss_percentile": 0.83871}, "CVE-2008-0440": {"epss_score": 0.01584, "epss_percentile": 0.81164}, "CVE-2008-0441": {"epss_score": 0.00058, "epss_percentile": 0.18429}, "CVE-2008-0442": {"epss_score": 0.00878, "epss_percentile": 0.74832}, "CVE-2008-0443": {"epss_score": 0.07508, "epss_percentile": 0.9151}, "CVE-2008-0444": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-0445": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2008-0446": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0447": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0448": {"epss_score": 0.0049, "epss_percentile": 0.64917}, "CVE-2008-0449": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2008-0450": {"epss_score": 0.0049, "epss_percentile": 0.64917}, "CVE-2008-0451": {"epss_score": 0.0093, "epss_percentile": 0.75599}, "CVE-2008-0452": {"epss_score": 0.03363, "epss_percentile": 0.86996}, "CVE-2008-0453": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0454": {"epss_score": 0.41318, "epss_percentile": 0.97266}, "CVE-2008-0455": {"epss_score": 0.2276, "epss_percentile": 0.95679}, "CVE-2008-0456": {"epss_score": 0.07575, "epss_percentile": 0.91547}, "CVE-2008-0457": {"epss_score": 0.29751, "epss_percentile": 0.9647}, "CVE-2008-0458": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2008-0459": {"epss_score": 0.04459, "epss_percentile": 0.88718}, "CVE-2008-0460": {"epss_score": 0.1566, "epss_percentile": 0.94478}, "CVE-2008-0461": {"epss_score": 0.04323, "epss_percentile": 0.88551}, "CVE-2008-0462": {"epss_score": 0.00299, "epss_percentile": 0.52862}, "CVE-2008-0463": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0464": {"epss_score": 0.12146, "epss_percentile": 0.93584}, "CVE-2008-0465": {"epss_score": 0.08621, "epss_percentile": 0.92157}, "CVE-2008-0466": {"epss_score": 0.12282, "epss_percentile": 0.93622}, "CVE-2008-0467": {"epss_score": 0.23514, "epss_percentile": 0.95787}, "CVE-2008-0468": {"epss_score": 0.00462, "epss_percentile": 0.63612}, "CVE-2008-0469": {"epss_score": 0.01073, "epss_percentile": 0.77288}, "CVE-2008-0470": {"epss_score": 0.19417, "epss_percentile": 0.95178}, "CVE-2008-0471": {"epss_score": 0.00242, "epss_percentile": 0.4739}, "CVE-2008-0472": {"epss_score": 0.00145, "epss_percentile": 0.35446}, "CVE-2008-0473": {"epss_score": 0.09437, "epss_percentile": 0.92548}, "CVE-2008-0474": {"epss_score": 0.00305, "epss_percentile": 0.53365}, "CVE-2008-0475": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2008-0476": {"epss_score": 0.00299, "epss_percentile": 0.52847}, "CVE-2008-0477": {"epss_score": 0.1485, "epss_percentile": 0.94301}, "CVE-2008-0478": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2008-0479": {"epss_score": 0.11137, "epss_percentile": 0.93236}, "CVE-2008-0480": {"epss_score": 0.08525, "epss_percentile": 0.92103}, "CVE-2008-0481": {"epss_score": 0.11137, "epss_percentile": 0.93236}, "CVE-2008-0485": {"epss_score": 0.19845, "epss_percentile": 0.9525}, "CVE-2008-0486": {"epss_score": 0.0457, "epss_percentile": 0.88862}, "CVE-2008-0487": {"epss_score": 0.0044, "epss_percentile": 0.62627}, "CVE-2008-0488": {"epss_score": 0.01951, "epss_percentile": 0.83016}, "CVE-2008-0489": {"epss_score": 0.02201, "epss_percentile": 0.83977}, "CVE-2008-0490": {"epss_score": 0.00811, "epss_percentile": 0.73732}, "CVE-2008-0491": {"epss_score": 0.0077, "epss_percentile": 0.73001}, "CVE-2008-0492": {"epss_score": 0.6666, "epss_percentile": 0.98472}, "CVE-2008-0493": {"epss_score": 0.07609, "epss_percentile": 0.91566}, "CVE-2008-0494": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-0495": {"epss_score": 0.0275, "epss_percentile": 0.8558}, "CVE-2008-0496": {"epss_score": 0.00567, "epss_percentile": 0.67845}, "CVE-2008-0497": {"epss_score": 0.00865, "epss_percentile": 0.74621}, "CVE-2008-0498": {"epss_score": 0.00486, "epss_percentile": 0.64761}, "CVE-2008-0499": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-0500": {"epss_score": 0.00416, "epss_percentile": 0.61172}, "CVE-2008-0501": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2008-0502": {"epss_score": 0.05766, "epss_percentile": 0.90188}, "CVE-2008-0503": {"epss_score": 0.11076, "epss_percentile": 0.9321}, "CVE-2008-0504": {"epss_score": 0.00672, "epss_percentile": 0.70818}, "CVE-2008-0505": {"epss_score": 0.00759, "epss_percentile": 0.72793}, "CVE-2008-0506": {"epss_score": 0.88385, "epss_percentile": 0.99469}, "CVE-2008-0507": {"epss_score": 0.01099, "epss_percentile": 0.77549}, "CVE-2008-0508": {"epss_score": 0.00367, "epss_percentile": 0.58101}, "CVE-2008-0509": {"epss_score": 0.00153, "epss_percentile": 0.36548}, "CVE-2008-0510": {"epss_score": 0.00016, "epss_percentile": 0.03026}, "CVE-2008-0511": {"epss_score": 0.00016, "epss_percentile": 0.03026}, "CVE-2008-0512": {"epss_score": 0.00026, "epss_percentile": 0.06438}, "CVE-2008-0513": {"epss_score": 0.07486, "epss_percentile": 0.91497}, "CVE-2008-0514": {"epss_score": 0.00016, "epss_percentile": 0.03026}, "CVE-2008-0515": {"epss_score": 0.00016, "epss_percentile": 0.03026}, "CVE-2008-0516": {"epss_score": 0.00836, "epss_percentile": 0.7413}, "CVE-2008-0517": {"epss_score": 0.00016, "epss_percentile": 0.03026}, "CVE-2008-0518": {"epss_score": 0.00016, "epss_percentile": 0.03026}, "CVE-2008-0519": {"epss_score": 0.00016, "epss_percentile": 0.03026}, "CVE-2008-0520": {"epss_score": 0.00591, "epss_percentile": 0.68583}, "CVE-2008-0521": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-0522": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2008-0523": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-0524": {"epss_score": 0.00286, "epss_percentile": 0.51739}, "CVE-2008-0525": {"epss_score": 0.00103, "epss_percentile": 0.28921}, "CVE-2008-0526": {"epss_score": 0.01918, "epss_percentile": 0.8288}, "CVE-2008-0527": {"epss_score": 0.01317, "epss_percentile": 0.79412}, "CVE-2008-0528": {"epss_score": 0.08907, "epss_percentile": 0.92311}, "CVE-2008-0529": {"epss_score": 0.07096, "epss_percentile": 0.91246}, "CVE-2008-0530": {"epss_score": 0.09706, "epss_percentile": 0.9267}, "CVE-2008-0531": {"epss_score": 0.01533, "epss_percentile": 0.80899}, "CVE-2008-0532": {"epss_score": 0.76775, "epss_percentile": 0.98904}, "CVE-2008-0533": {"epss_score": 0.0434, "epss_percentile": 0.88569}, "CVE-2008-0534": {"epss_score": 0.0289, "epss_percentile": 0.85917}, "CVE-2008-0535": {"epss_score": 0.0367, "epss_percentile": 0.87538}, "CVE-2008-0536": {"epss_score": 0.02668, "epss_percentile": 0.85381}, "CVE-2008-0537": {"epss_score": 0.01094, "epss_percentile": 0.77491}, "CVE-2008-0538": {"epss_score": 0.01073, "epss_percentile": 0.77288}, "CVE-2008-0539": {"epss_score": 0.01551, "epss_percentile": 0.80989}, "CVE-2008-0540": {"epss_score": 0.00358, "epss_percentile": 0.57491}, "CVE-2008-0541": {"epss_score": 0.03477, "epss_percentile": 0.87212}, "CVE-2008-0542": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-0543": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-0544": {"epss_score": 0.08673, "epss_percentile": 0.92183}, "CVE-2008-0545": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2008-0546": {"epss_score": 0.00804, "epss_percentile": 0.73615}, "CVE-2008-0547": {"epss_score": 0.06286, "epss_percentile": 0.90642}, "CVE-2008-0548": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2008-0549": {"epss_score": 0.00543, "epss_percentile": 0.67123}, "CVE-2008-0550": {"epss_score": 0.68157, "epss_percentile": 0.98533}, "CVE-2008-0551": {"epss_score": 0.55918, "epss_percentile": 0.98003}, "CVE-2008-0552": {"epss_score": 0.0641, "epss_percentile": 0.9074}, "CVE-2008-0553": {"epss_score": 0.06015, "epss_percentile": 0.90411}, "CVE-2008-0554": {"epss_score": 0.01722, "epss_percentile": 0.81936}, "CVE-2008-0555": {"epss_score": 0.00524, "epss_percentile": 0.66353}, "CVE-2008-0556": {"epss_score": 0.00212, "epss_percentile": 0.43747}, "CVE-2008-0557": {"epss_score": 0.00227, "epss_percentile": 0.45426}, "CVE-2008-0558": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-0559": {"epss_score": 0.02201, "epss_percentile": 0.83977}, "CVE-2008-0560": {"epss_score": 0.00658, "epss_percentile": 0.70481}, "CVE-2008-0561": {"epss_score": 9e-05, "epss_percentile": 0.00682}, "CVE-2008-0562": {"epss_score": 0.00602, "epss_percentile": 0.68866}, "CVE-2008-0563": {"epss_score": 0.00114, "epss_percentile": 0.30789}, "CVE-2008-0564": {"epss_score": 0.02164, "epss_percentile": 0.83842}, "CVE-2008-0565": {"epss_score": 0.00908, "epss_percentile": 0.75286}, "CVE-2008-0566": {"epss_score": 0.04739, "epss_percentile": 0.89075}, "CVE-2008-0567": {"epss_score": 0.27825, "epss_percentile": 0.96285}, "CVE-2008-0568": {"epss_score": 0.00851, "epss_percentile": 0.74404}, "CVE-2008-0569": {"epss_score": 0.01059, "epss_percentile": 0.77151}, "CVE-2008-0570": {"epss_score": 0.00397, "epss_percentile": 0.60019}, "CVE-2008-0571": {"epss_score": 0.00129, "epss_percentile": 0.33087}, "CVE-2008-0572": {"epss_score": 0.10855, "epss_percentile": 0.93135}, "CVE-2008-0573": {"epss_score": 0.00323, "epss_percentile": 0.54895}, "CVE-2008-0574": {"epss_score": 0.00334, "epss_percentile": 0.55724}, "CVE-2008-0575": {"epss_score": 0.00118, "epss_percentile": 0.31512}, "CVE-2008-0576": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-0577": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2008-0578": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2008-0579": {"epss_score": 0.00035, "epss_percentile": 0.09854}, "CVE-2008-0580": {"epss_score": 0.0008, "epss_percentile": 0.24178}, "CVE-2008-0581": {"epss_score": 0.00143, "epss_percentile": 0.35215}, "CVE-2008-0582": {"epss_score": 0.00679, "epss_percentile": 0.71009}, "CVE-2008-0583": {"epss_score": 0.00671, "epss_percentile": 0.70795}, "CVE-2008-0584": {"epss_score": 0.00058, "epss_percentile": 0.18416}, "CVE-2008-0585": {"epss_score": 0.00048, "epss_percentile": 0.14941}, "CVE-2008-0586": {"epss_score": 0.00055, "epss_percentile": 0.17566}, "CVE-2008-0587": {"epss_score": 0.00055, "epss_percentile": 0.1753}, "CVE-2008-0588": {"epss_score": 0.00051, "epss_percentile": 0.16009}, "CVE-2008-0589": {"epss_score": 0.00054, "epss_percentile": 0.17068}, "CVE-2008-0590": {"epss_score": 0.04514, "epss_percentile": 0.88788}, "CVE-2008-0591": {"epss_score": 0.05544, "epss_percentile": 0.89981}, "CVE-2008-0592": {"epss_score": 0.02533, "epss_percentile": 0.85033}, "CVE-2008-0593": {"epss_score": 0.00806, "epss_percentile": 0.73662}, "CVE-2008-0594": {"epss_score": 0.01256, "epss_percentile": 0.78936}, "CVE-2008-0595": {"epss_score": 0.00063, "epss_percentile": 0.19937}, "CVE-2008-0596": {"epss_score": 0.03849, "epss_percentile": 0.87845}, "CVE-2008-0597": {"epss_score": 0.05278, "epss_percentile": 0.89685}, "CVE-2008-0598": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2008-0599": {"epss_score": 0.49743, "epss_percentile": 0.97704}, "CVE-2008-0600": {"epss_score": 0.00215, "epss_percentile": 0.4411}, "CVE-2008-0601": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-0602": {"epss_score": 0.02898, "epss_percentile": 0.85936}, "CVE-2008-0603": {"epss_score": 0.00012, "epss_percentile": 0.01224}, "CVE-2008-0604": {"epss_score": 0.00235, "epss_percentile": 0.46238}, "CVE-2008-0605": {"epss_score": 0.00666, "epss_percentile": 0.70685}, "CVE-2008-0606": {"epss_score": 0.00015, "epss_percentile": 0.02248}, "CVE-2008-0607": {"epss_score": 0.00015, "epss_percentile": 0.02365}, "CVE-2008-0608": {"epss_score": 0.01816, "epss_percentile": 0.82394}, "CVE-2008-0609": {"epss_score": 0.0402, "epss_percentile": 0.8813}, "CVE-2008-0610": {"epss_score": 0.74834, "epss_percentile": 0.98819}, "CVE-2008-0611": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-0612": {"epss_score": 0.04577, "epss_percentile": 0.8887}, "CVE-2008-0613": {"epss_score": 0.02578, "epss_percentile": 0.85147}, "CVE-2008-0614": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-0615": {"epss_score": 0.00429, "epss_percentile": 0.61985}, "CVE-2008-0616": {"epss_score": 0.00651, "epss_percentile": 0.70281}, "CVE-2008-0617": {"epss_score": 0.00403, "epss_percentile": 0.60319}, "CVE-2008-0618": {"epss_score": 0.00358, "epss_percentile": 0.57526}, "CVE-2008-0619": {"epss_score": 0.11222, "epss_percentile": 0.9327}, "CVE-2008-0620": {"epss_score": 0.04983, "epss_percentile": 0.89362}, "CVE-2008-0621": {"epss_score": 0.88155, "epss_percentile": 0.9946}, "CVE-2008-0622": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0623": {"epss_score": 0.37192, "epss_percentile": 0.97026}, "CVE-2008-0624": {"epss_score": 0.1189, "epss_percentile": 0.93507}, "CVE-2008-0625": {"epss_score": 0.15207, "epss_percentile": 0.94384}, "CVE-2008-0628": {"epss_score": 0.06004, "epss_percentile": 0.90395}, "CVE-2008-0629": {"epss_score": 0.02652, "epss_percentile": 0.85347}, "CVE-2008-0630": {"epss_score": 0.06989, "epss_percentile": 0.91165}, "CVE-2008-0631": {"epss_score": 0.02475, "epss_percentile": 0.8486}, "CVE-2008-0632": {"epss_score": 0.13746, "epss_percentile": 0.94047}, "CVE-2008-0633": {"epss_score": 0.0368, "epss_percentile": 0.87557}, "CVE-2008-0634": {"epss_score": 0.04229, "epss_percentile": 0.8842}, "CVE-2008-0635": {"epss_score": 0.00662, "epss_percentile": 0.70597}, "CVE-2008-0636": {"epss_score": 0.03011, "epss_percentile": 0.86198}, "CVE-2008-0638": {"epss_score": 0.20169, "epss_percentile": 0.95297}, "CVE-2008-0639": {"epss_score": 0.39839, "epss_percentile": 0.97182}, "CVE-2008-0640": {"epss_score": 0.03505, "epss_percentile": 0.87256}, "CVE-2008-0642": {"epss_score": 0.02478, "epss_percentile": 0.84867}, "CVE-2008-0643": {"epss_score": 0.02799, "epss_percentile": 0.85689}, "CVE-2008-0644": {"epss_score": 0.01883, "epss_percentile": 0.827}, "CVE-2008-0645": {"epss_score": 0.01715, "epss_percentile": 0.81895}, "CVE-2008-0646": {"epss_score": 0.03558, "epss_percentile": 0.8735}, "CVE-2008-0647": {"epss_score": 0.07139, "epss_percentile": 0.91276}, "CVE-2008-0648": {"epss_score": 0.03676, "epss_percentile": 0.87553}, "CVE-2008-0649": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-0650": {"epss_score": 0.00254, "epss_percentile": 0.48553}, "CVE-2008-0651": {"epss_score": 0.00254, "epss_percentile": 0.48553}, "CVE-2008-0652": {"epss_score": 0.00012, "epss_percentile": 0.01224}, "CVE-2008-0653": {"epss_score": 0.00018, "epss_percentile": 0.0398}, "CVE-2008-0654": {"epss_score": 0.00139, "epss_percentile": 0.34629}, "CVE-2008-0655": {"epss_score": 0.68768, "epss_percentile": 0.98562}, "CVE-2008-0656": {"epss_score": 0.02498, "epss_percentile": 0.84912}, "CVE-2008-0657": {"epss_score": 0.01771, "epss_percentile": 0.82194}, "CVE-2008-0658": {"epss_score": 0.06446, "epss_percentile": 0.90762}, "CVE-2008-0659": {"epss_score": 0.4022, "epss_percentile": 0.97207}, "CVE-2008-0660": {"epss_score": 0.54394, "epss_percentile": 0.97924}, "CVE-2008-0661": {"epss_score": 0.29833, "epss_percentile": 0.96479}, "CVE-2008-0662": {"epss_score": 0.0004, "epss_percentile": 0.11978}, "CVE-2008-0663": {"epss_score": 0.00079, "epss_percentile": 0.23913}, "CVE-2008-0664": {"epss_score": 0.06837, "epss_percentile": 0.91059}, "CVE-2008-0665": {"epss_score": 0.00033, "epss_percentile": 0.09361}, "CVE-2008-0666": {"epss_score": 0.00033, "epss_percentile": 0.09361}, "CVE-2008-0667": {"epss_score": 0.40364, "epss_percentile": 0.97215}, "CVE-2008-0668": {"epss_score": 0.06661, "epss_percentile": 0.90923}, "CVE-2008-0669": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-0670": {"epss_score": 0.00018, "epss_percentile": 0.0398}, "CVE-2008-0671": {"epss_score": 0.13463, "epss_percentile": 0.93971}, "CVE-2008-0672": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-0673": {"epss_score": 0.01207, "epss_percentile": 0.78528}, "CVE-2008-0674": {"epss_score": 0.2096, "epss_percentile": 0.95446}, "CVE-2008-0675": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0676": {"epss_score": 0.0061, "epss_percentile": 0.69155}, "CVE-2008-0677": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-0678": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-0679": {"epss_score": 0.0364, "epss_percentile": 0.87488}, "CVE-2008-0680": {"epss_score": 0.06805, "epss_percentile": 0.91037}, "CVE-2008-0681": {"epss_score": 0.00326, "epss_percentile": 0.55067}, "CVE-2008-0682": {"epss_score": 0.00664, "epss_percentile": 0.7064}, "CVE-2008-0683": {"epss_score": 0.00544, "epss_percentile": 0.67129}, "CVE-2008-0684": {"epss_score": 0.00305, "epss_percentile": 0.53365}, "CVE-2008-0685": {"epss_score": 0.00248, "epss_percentile": 0.47971}, "CVE-2008-0686": {"epss_score": 0.00017, "epss_percentile": 0.03372}, "CVE-2008-0687": {"epss_score": 0.0057, "epss_percentile": 0.67959}, "CVE-2008-0688": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-0689": {"epss_score": 0.00024, "epss_percentile": 0.05805}, "CVE-2008-0690": {"epss_score": 0.00038, "epss_percentile": 0.11166}, "CVE-2008-0691": {"epss_score": 0.00516, "epss_percentile": 0.66036}, "CVE-2008-0692": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0693": {"epss_score": 0.01366, "epss_percentile": 0.79779}, "CVE-2008-0694": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2008-0695": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-0696": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2008-0697": {"epss_score": 0.00048, "epss_percentile": 0.15097}, "CVE-2008-0698": {"epss_score": 0.0064, "epss_percentile": 0.69976}, "CVE-2008-0699": {"epss_score": 0.08004, "epss_percentile": 0.91823}, "CVE-2008-0700": {"epss_score": 0.00292, "epss_percentile": 0.52238}, "CVE-2008-0701": {"epss_score": 0.00234, "epss_percentile": 0.4611}, "CVE-2008-0702": {"epss_score": 0.03827, "epss_percentile": 0.87794}, "CVE-2008-0703": {"epss_score": 0.04011, "epss_percentile": 0.88112}, "CVE-2008-0704": {"epss_score": 0.02667, "epss_percentile": 0.85378}, "CVE-2008-0706": {"epss_score": 0.00048, "epss_percentile": 0.14987}, "CVE-2008-0707": {"epss_score": 0.00051, "epss_percentile": 0.16271}, "CVE-2008-0708": {"epss_score": 0.00088, "epss_percentile": 0.25729}, "CVE-2008-0709": {"epss_score": 0.00348, "epss_percentile": 0.56821}, "CVE-2008-0711": {"epss_score": 0.02728, "epss_percentile": 0.85533}, "CVE-2008-0712": {"epss_score": 0.07361, "epss_percentile": 0.91431}, "CVE-2008-0713": {"epss_score": 0.00625, "epss_percentile": 0.69591}, "CVE-2008-0714": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-0715": {"epss_score": 0.03922, "epss_percentile": 0.87956}, "CVE-2008-0716": {"epss_score": 0.00053, "epss_percentile": 0.17013}, "CVE-2008-0717": {"epss_score": 0.00265, "epss_percentile": 0.49789}, "CVE-2008-0718": {"epss_score": 0.0004, "epss_percentile": 0.11997}, "CVE-2008-0719": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0720": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-0721": {"epss_score": 0.0042, "epss_percentile": 0.61415}, "CVE-2008-0722": {"epss_score": 0.0061, "epss_percentile": 0.69155}, "CVE-2008-0723": {"epss_score": 0.00335, "epss_percentile": 0.55843}, "CVE-2008-0724": {"epss_score": 0.04376, "epss_percentile": 0.88617}, "CVE-2008-0725": {"epss_score": 0.02116, "epss_percentile": 0.8366}, "CVE-2008-0726": {"epss_score": 0.08403, "epss_percentile": 0.92033}, "CVE-2008-0727": {"epss_score": 0.26903, "epss_percentile": 0.9619}, "CVE-2008-0728": {"epss_score": 0.01559, "epss_percentile": 0.81036}, "CVE-2008-0729": {"epss_score": 0.08181, "epss_percentile": 0.91917}, "CVE-2008-0730": {"epss_score": 0.00078, "epss_percentile": 0.23585}, "CVE-2008-0731": {"epss_score": 0.00199, "epss_percentile": 0.42132}, "CVE-2008-0732": {"epss_score": 0.00054, "epss_percentile": 0.17328}, "CVE-2008-0733": {"epss_score": 0.00266, "epss_percentile": 0.49863}, "CVE-2008-0734": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0735": {"epss_score": 0.00486, "epss_percentile": 0.6475}, "CVE-2008-0736": {"epss_score": 0.09819, "epss_percentile": 0.92716}, "CVE-2008-0737": {"epss_score": 0.00906, "epss_percentile": 0.75257}, "CVE-2008-0738": {"epss_score": 0.00388, "epss_percentile": 0.59339}, "CVE-2008-0739": {"epss_score": 0.00388, "epss_percentile": 0.59339}, "CVE-2008-0740": {"epss_score": 0.00064, "epss_percentile": 0.20198}, "CVE-2008-0741": {"epss_score": 0.01003, "epss_percentile": 0.76514}, "CVE-2008-0742": {"epss_score": 0.02517, "epss_percentile": 0.84989}, "CVE-2008-0743": {"epss_score": 0.01353, "epss_percentile": 0.79697}, "CVE-2008-0744": {"epss_score": 0.00388, "epss_percentile": 0.59339}, "CVE-2008-0745": {"epss_score": 0.02898, "epss_percentile": 0.85936}, "CVE-2008-0746": {"epss_score": 0.00015, "epss_percentile": 0.02248}, "CVE-2008-0747": {"epss_score": 0.22318, "epss_percentile": 0.95622}, "CVE-2008-0748": {"epss_score": 0.47333, "epss_percentile": 0.97583}, "CVE-2008-0749": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-0750": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2008-0751": {"epss_score": 0.00496, "epss_percentile": 0.65153}, "CVE-2008-0752": {"epss_score": 0.00015, "epss_percentile": 0.02248}, "CVE-2008-0753": {"epss_score": 0.00266, "epss_percentile": 0.49863}, "CVE-2008-0754": {"epss_score": 0.00019, "epss_percentile": 0.04357}, "CVE-2008-0755": {"epss_score": 0.10857, "epss_percentile": 0.93136}, "CVE-2008-0756": {"epss_score": 0.09782, "epss_percentile": 0.927}, "CVE-2008-0757": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0758": {"epss_score": 0.00209, "epss_percentile": 0.43314}, "CVE-2008-0759": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-0760": {"epss_score": 0.05278, "epss_percentile": 0.89684}, "CVE-2008-0761": {"epss_score": 0.00023, "epss_percentile": 0.05479}, "CVE-2008-0762": {"epss_score": 0.00039, "epss_percentile": 0.11714}, "CVE-2008-0763": {"epss_score": 0.0732, "epss_percentile": 0.91407}, "CVE-2008-0764": {"epss_score": 0.07419, "epss_percentile": 0.91465}, "CVE-2008-0765": {"epss_score": 0.00401, "epss_percentile": 0.60237}, "CVE-2008-0766": {"epss_score": 0.11626, "epss_percentile": 0.93423}, "CVE-2008-0767": {"epss_score": 0.11404, "epss_percentile": 0.93336}, "CVE-2008-0768": {"epss_score": 0.04724, "epss_percentile": 0.89059}, "CVE-2008-0769": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0770": {"epss_score": 0.00527, "epss_percentile": 0.66439}, "CVE-2008-0771": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-0772": {"epss_score": 0.00019, "epss_percentile": 0.04066}, "CVE-2008-0773": {"epss_score": 0.00019, "epss_percentile": 0.04066}, "CVE-2008-0774": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-0775": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-0776": {"epss_score": 0.00704, "epss_percentile": 0.71556}, "CVE-2008-0777": {"epss_score": 0.00068, "epss_percentile": 0.21414}, "CVE-2008-0778": {"epss_score": 0.19207, "epss_percentile": 0.95149}, "CVE-2008-0779": {"epss_score": 0.00047, "epss_percentile": 0.14599}, "CVE-2008-0780": {"epss_score": 0.00664, "epss_percentile": 0.70636}, "CVE-2008-0781": {"epss_score": 0.00664, "epss_percentile": 0.70636}, "CVE-2008-0782": {"epss_score": 0.10927, "epss_percentile": 0.93161}, "CVE-2008-0783": {"epss_score": 0.03843, "epss_percentile": 0.87836}, "CVE-2008-0784": {"epss_score": 0.01439, "epss_percentile": 0.80293}, "CVE-2008-0785": {"epss_score": 0.02085, "epss_percentile": 0.83548}, "CVE-2008-0786": {"epss_score": 0.01014, "epss_percentile": 0.76639}, "CVE-2008-0787": {"epss_score": 0.0163, "epss_percentile": 0.81443}, "CVE-2008-0788": {"epss_score": 0.00172, "epss_percentile": 0.38971}, "CVE-2008-0789": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2008-0790": {"epss_score": 0.09447, "epss_percentile": 0.92552}, "CVE-2008-0791": {"epss_score": 0.01288, "epss_percentile": 0.79205}, "CVE-2008-0792": {"epss_score": 0.00577, "epss_percentile": 0.68155}, "CVE-2008-0793": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0794": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-0795": {"epss_score": 0.00015, "epss_percentile": 0.02248}, "CVE-2008-0796": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-0797": {"epss_score": 0.00394, "epss_percentile": 0.59775}, "CVE-2008-0798": {"epss_score": 0.04508, "epss_percentile": 0.88778}, "CVE-2008-0799": {"epss_score": 0.00015, "epss_percentile": 0.02248}, "CVE-2008-0800": {"epss_score": 0.00023, "epss_percentile": 0.05479}, "CVE-2008-0801": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0802": {"epss_score": 0.00027, "epss_percentile": 0.06896}, "CVE-2008-0803": {"epss_score": 0.08446, "epss_percentile": 0.92055}, "CVE-2008-0804": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2008-0805": {"epss_score": 0.10148, "epss_percentile": 0.92865}, "CVE-2008-0806": {"epss_score": 0.00056, "epss_percentile": 0.1769}, "CVE-2008-0807": {"epss_score": 0.00556, "epss_percentile": 0.67516}, "CVE-2008-0808": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-0809": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0810": {"epss_score": 7e-05, "epss_percentile": 0.00323}, "CVE-2008-0811": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0812": {"epss_score": 0.01951, "epss_percentile": 0.83016}, "CVE-2008-0813": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-0814": {"epss_score": 0.02898, "epss_percentile": 0.85936}, "CVE-2008-0815": {"epss_score": 0.00028, "epss_percentile": 0.07437}, "CVE-2008-0816": {"epss_score": 0.00266, "epss_percentile": 0.49863}, "CVE-2008-0817": {"epss_score": 8e-05, "epss_percentile": 0.00558}, "CVE-2008-0818": {"epss_score": 0.03894, "epss_percentile": 0.87913}, "CVE-2008-0819": {"epss_score": 0.01369, "epss_percentile": 0.79796}, "CVE-2008-0820": {"epss_score": 0.0048, "epss_percentile": 0.64461}, "CVE-2008-0821": {"epss_score": 0.00449, "epss_percentile": 0.63035}, "CVE-2008-0822": {"epss_score": 0.02879, "epss_percentile": 0.85891}, "CVE-2008-0823": {"epss_score": 0.00847, "epss_percentile": 0.74347}, "CVE-2008-0824": {"epss_score": 0.00404, "epss_percentile": 0.60432}, "CVE-2008-0825": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-0826": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-0827": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0828": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-0829": {"epss_score": 0.00019, "epss_percentile": 0.04188}, "CVE-2008-0830": {"epss_score": 0.04873, "epss_percentile": 0.89234}, "CVE-2008-0831": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2008-0832": {"epss_score": 0.00027, "epss_percentile": 0.06783}, "CVE-2008-0833": {"epss_score": 0.00023, "epss_percentile": 0.05479}, "CVE-2008-0834": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2008-0835": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0836": {"epss_score": 0.0004, "epss_percentile": 0.11997}, "CVE-2008-0837": {"epss_score": 0.00437, "epss_percentile": 0.62518}, "CVE-2008-0838": {"epss_score": 0.13618, "epss_percentile": 0.94014}, "CVE-2008-0839": {"epss_score": 0.00023, "epss_percentile": 0.05479}, "CVE-2008-0840": {"epss_score": 0.03076, "epss_percentile": 0.8636}, "CVE-2008-0841": {"epss_score": 0.00012, "epss_percentile": 0.01224}, "CVE-2008-0842": {"epss_score": 0.00023, "epss_percentile": 0.05479}, "CVE-2008-0843": {"epss_score": 0.08189, "epss_percentile": 0.91921}, "CVE-2008-0844": {"epss_score": 0.00023, "epss_percentile": 0.05479}, "CVE-2008-0845": {"epss_score": 0.00378, "epss_percentile": 0.58801}, "CVE-2008-0846": {"epss_score": 6e-05, "epss_percentile": 0.00281}, "CVE-2008-0847": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0848": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-0849": {"epss_score": 0.0001, "epss_percentile": 0.00841}, "CVE-2008-0850": {"epss_score": 0.01329, "epss_percentile": 0.79506}, "CVE-2008-0851": {"epss_score": 0.02936, "epss_percentile": 0.86026}, "CVE-2008-0852": {"epss_score": 0.05379, "epss_percentile": 0.89806}, "CVE-2008-0853": {"epss_score": 7e-05, "epss_percentile": 0.00435}, "CVE-2008-0854": {"epss_score": 0.00013, "epss_percentile": 0.01693}, "CVE-2008-0855": {"epss_score": 0.00012, "epss_percentile": 0.0124}, "CVE-2008-0856": {"epss_score": 0.00254, "epss_percentile": 0.48553}, "CVE-2008-0857": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-0858": {"epss_score": 0.03105, "epss_percentile": 0.86416}, "CVE-2008-0859": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2008-0860": {"epss_score": 0.00416, "epss_percentile": 0.61172}, "CVE-2008-0861": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2008-0862": {"epss_score": 0.00489, "epss_percentile": 0.64867}, "CVE-2008-0863": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2008-0864": {"epss_score": 0.00383, "epss_percentile": 0.59109}, "CVE-2008-0865": {"epss_score": 0.00383, "epss_percentile": 0.59109}, "CVE-2008-0866": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-0867": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-0868": {"epss_score": 0.00322, "epss_percentile": 0.54751}, "CVE-2008-0869": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0870": {"epss_score": 0.00294, "epss_percentile": 0.52439}, "CVE-2008-0871": {"epss_score": 0.70217, "epss_percentile": 0.98623}, "CVE-2008-0872": {"epss_score": 0.05478, "epss_percentile": 0.89917}, "CVE-2008-0873": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0874": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0875": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2008-0876": {"epss_score": 0.00564, "epss_percentile": 0.67768}, "CVE-2008-0877": {"epss_score": 0.00489, "epss_percentile": 0.64898}, "CVE-2008-0878": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0879": {"epss_score": 0.00962, "epss_percentile": 0.76001}, "CVE-2008-0880": {"epss_score": 0.00527, "epss_percentile": 0.66439}, "CVE-2008-0881": {"epss_score": 0.00527, "epss_percentile": 0.66439}, "CVE-2008-0882": {"epss_score": 0.23075, "epss_percentile": 0.95731}, "CVE-2008-0883": {"epss_score": 0.00089, "epss_percentile": 0.25955}, "CVE-2008-0884": {"epss_score": 0.00035, "epss_percentile": 0.09814}, "CVE-2008-0887": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2008-0888": {"epss_score": 0.1904, "epss_percentile": 0.95117}, "CVE-2008-0889": {"epss_score": 0.00065, "epss_percentile": 0.2051}, "CVE-2008-0890": {"epss_score": 0.00064, "epss_percentile": 0.20321}, "CVE-2008-0891": {"epss_score": 0.12826, "epss_percentile": 0.93795}, "CVE-2008-0892": {"epss_score": 0.03013, "epss_percentile": 0.86202}, "CVE-2008-0893": {"epss_score": 0.01417, "epss_percentile": 0.80149}, "CVE-2008-0894": {"epss_score": 0.00669, "epss_percentile": 0.70763}, "CVE-2008-0895": {"epss_score": 0.00382, "epss_percentile": 0.59043}, "CVE-2008-0896": {"epss_score": 0.00286, "epss_percentile": 0.51741}, "CVE-2008-0897": {"epss_score": 0.00185, "epss_percentile": 0.40501}, "CVE-2008-0898": {"epss_score": 0.00227, "epss_percentile": 0.45432}, "CVE-2008-0899": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-0900": {"epss_score": 0.04528, "epss_percentile": 0.88809}, "CVE-2008-0901": {"epss_score": 0.0074, "epss_percentile": 0.72402}, "CVE-2008-0902": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-0903": {"epss_score": 0.0052, "epss_percentile": 0.66194}, "CVE-2008-0904": {"epss_score": 0.00384, "epss_percentile": 0.59156}, "CVE-2008-0905": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-0906": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-0907": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-0908": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-0909": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-0910": {"epss_score": 0.00705, "epss_percentile": 0.71578}, "CVE-2008-0911": {"epss_score": 0.00412, "epss_percentile": 0.60955}, "CVE-2008-0912": {"epss_score": 0.27489, "epss_percentile": 0.96251}, "CVE-2008-0913": {"epss_score": 0.00225, "epss_percentile": 0.45225}, "CVE-2008-0914": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-0915": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2008-0916": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-0917": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-0918": {"epss_score": 0.00022, "epss_percentile": 0.04962}, "CVE-2008-0919": {"epss_score": 0.07201, "epss_percentile": 0.91317}, "CVE-2008-0920": {"epss_score": 0.00675, "epss_percentile": 0.70914}, "CVE-2008-0921": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-0922": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-0923": {"epss_score": 0.00018, "epss_percentile": 0.03765}, "CVE-2008-0924": {"epss_score": 0.03886, "epss_percentile": 0.87905}, "CVE-2008-0925": {"epss_score": 0.01089, "epss_percentile": 0.77443}, "CVE-2008-0926": {"epss_score": 0.65873, "epss_percentile": 0.98441}, "CVE-2008-0927": {"epss_score": 0.77052, "epss_percentile": 0.98918}, "CVE-2008-0928": {"epss_score": 0.00103, "epss_percentile": 0.29063}, "CVE-2008-0930": {"epss_score": 0.00021, "epss_percentile": 0.048}, "CVE-2008-0931": {"epss_score": 0.00026, "epss_percentile": 0.06731}, "CVE-2008-0932": {"epss_score": 0.01688, "epss_percentile": 0.81763}, "CVE-2008-0933": {"epss_score": 0.00048, "epss_percentile": 0.14971}, "CVE-2008-0934": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-0935": {"epss_score": 0.82864, "epss_percentile": 0.9922}, "CVE-2008-0936": {"epss_score": 0.00266, "epss_percentile": 0.49863}, "CVE-2008-0937": {"epss_score": 0.00234, "epss_percentile": 0.4609}, "CVE-2008-0938": {"epss_score": 0.00045, "epss_percentile": 0.13708}, "CVE-2008-0939": {"epss_score": 0.01465, "epss_percentile": 0.8046}, "CVE-2008-0940": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-0941": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-0942": {"epss_score": 0.00301, "epss_percentile": 0.53079}, "CVE-2008-0943": {"epss_score": 0.00424, "epss_percentile": 0.61673}, "CVE-2008-0944": {"epss_score": 0.11384, "epss_percentile": 0.93328}, "CVE-2008-0945": {"epss_score": 0.01199, "epss_percentile": 0.78459}, "CVE-2008-0946": {"epss_score": 0.00058, "epss_percentile": 0.18479}, "CVE-2008-0947": {"epss_score": 0.32205, "epss_percentile": 0.96679}, "CVE-2008-0948": {"epss_score": 0.31833, "epss_percentile": 0.96653}, "CVE-2008-0949": {"epss_score": 0.04358, "epss_percentile": 0.88593}, "CVE-2008-0951": {"epss_score": 0.55653, "epss_percentile": 0.97988}, "CVE-2008-0952": {"epss_score": 0.11365, "epss_percentile": 0.93325}, "CVE-2008-0953": {"epss_score": 0.14685, "epss_percentile": 0.94264}, "CVE-2008-0955": {"epss_score": 0.73958, "epss_percentile": 0.98778}, "CVE-2008-0956": {"epss_score": 0.40272, "epss_percentile": 0.9721}, "CVE-2008-0957": {"epss_score": 0.05337, "epss_percentile": 0.89745}, "CVE-2008-0958": {"epss_score": 0.3343, "epss_percentile": 0.96774}, "CVE-2008-0959": {"epss_score": 0.30993, "epss_percentile": 0.9658}, "CVE-2008-0960": {"epss_score": 0.33188, "epss_percentile": 0.96752}, "CVE-2008-0961": {"epss_score": 0.02278, "epss_percentile": 0.84235}, "CVE-2008-0962": {"epss_score": 0.06344, "epss_percentile": 0.90685}, "CVE-2008-0963": {"epss_score": 0.03805, "epss_percentile": 0.87749}, "CVE-2008-0964": {"epss_score": 0.28553, "epss_percentile": 0.96367}, "CVE-2008-0965": {"epss_score": 0.16327, "epss_percentile": 0.9463}, "CVE-2008-0967": {"epss_score": 0.00072, "epss_percentile": 0.22314}, "CVE-2008-0971": {"epss_score": 0.00338, "epss_percentile": 0.56135}, "CVE-2008-0973": {"epss_score": 0.02008, "epss_percentile": 0.83241}, "CVE-2008-0974": {"epss_score": 0.02199, "epss_percentile": 0.83972}, "CVE-2008-0975": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-0976": {"epss_score": 0.01838, "epss_percentile": 0.82485}, "CVE-2008-0977": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-0978": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2008-0979": {"epss_score": 0.02199, "epss_percentile": 0.83972}, "CVE-2008-0980": {"epss_score": 0.0037, "epss_percentile": 0.58327}, "CVE-2008-0981": {"epss_score": 0.00154, "epss_percentile": 0.36738}, "CVE-2008-0982": {"epss_score": 0.02797, "epss_percentile": 0.85685}, "CVE-2008-0983": {"epss_score": 0.0409, "epss_percentile": 0.88236}, "CVE-2008-0984": {"epss_score": 0.26592, "epss_percentile": 0.96159}, "CVE-2008-0985": {"epss_score": 0.15528, "epss_percentile": 0.94452}, "CVE-2008-0986": {"epss_score": 0.13765, "epss_percentile": 0.94054}, "CVE-2008-0987": {"epss_score": 0.27456, "epss_percentile": 0.96246}, "CVE-2008-0988": {"epss_score": 0.00403, "epss_percentile": 0.60378}, "CVE-2008-0989": {"epss_score": 0.00066, "epss_percentile": 0.20766}, "CVE-2008-0990": {"epss_score": 0.00074, "epss_percentile": 0.22853}, "CVE-2008-0992": {"epss_score": 0.01263, "epss_percentile": 0.78988}, "CVE-2008-0993": {"epss_score": 0.00074, "epss_percentile": 0.22818}, "CVE-2008-0994": {"epss_score": 0.00347, "epss_percentile": 0.56752}, "CVE-2008-0995": {"epss_score": 0.00577, "epss_percentile": 0.68154}, "CVE-2008-0996": {"epss_score": 0.00059, "epss_percentile": 0.18831}, "CVE-2008-0997": {"epss_score": 0.02352, "epss_percentile": 0.84472}, "CVE-2008-0998": {"epss_score": 0.00057, "epss_percentile": 0.17971}, "CVE-2008-0999": {"epss_score": 0.0092, "epss_percentile": 0.75467}, "CVE-2008-10001": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2008-10002": {"epss_score": 0.00073, "epss_percentile": 0.2265}, "CVE-2008-10003": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2008-10004": {"epss_score": 0.00055, "epss_percentile": 0.17609}, "CVE-2008-1000": {"epss_score": 0.02682, "epss_percentile": 0.85419}, "CVE-2008-1001": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2008-1002": {"epss_score": 0.01656, "epss_percentile": 0.81597}, "CVE-2008-1003": {"epss_score": 0.0084, "epss_percentile": 0.74208}, "CVE-2008-1004": {"epss_score": 0.0084, "epss_percentile": 0.74208}, "CVE-2008-1005": {"epss_score": 0.00087, "epss_percentile": 0.25482}, "CVE-2008-1006": {"epss_score": 0.0084, "epss_percentile": 0.74208}, "CVE-2008-1007": {"epss_score": 0.00949, "epss_percentile": 0.75845}, "CVE-2008-1008": {"epss_score": 0.0084, "epss_percentile": 0.74208}, "CVE-2008-1009": {"epss_score": 0.0084, "epss_percentile": 0.74208}, "CVE-2008-1010": {"epss_score": 0.0672, "epss_percentile": 0.90967}, "CVE-2008-1011": {"epss_score": 0.02157, "epss_percentile": 0.83813}, "CVE-2008-1012": {"epss_score": 0.0098, "epss_percentile": 0.76268}, "CVE-2008-1013": {"epss_score": 0.02501, "epss_percentile": 0.8492}, "CVE-2008-1014": {"epss_score": 0.00528, "epss_percentile": 0.66574}, "CVE-2008-1015": {"epss_score": 0.08256, "epss_percentile": 0.91953}, "CVE-2008-1016": {"epss_score": 0.01225, "epss_percentile": 0.78681}, "CVE-2008-1017": {"epss_score": 0.23571, "epss_percentile": 0.95792}, "CVE-2008-1018": {"epss_score": 0.37369, "epss_percentile": 0.97036}, "CVE-2008-1019": {"epss_score": 0.40615, "epss_percentile": 0.97226}, "CVE-2008-1020": {"epss_score": 0.40615, "epss_percentile": 0.97226}, "CVE-2008-1021": {"epss_score": 0.18252, "epss_percentile": 0.94982}, "CVE-2008-1022": {"epss_score": 0.40615, "epss_percentile": 0.97226}, "CVE-2008-1023": {"epss_score": 0.03943, "epss_percentile": 0.87991}, "CVE-2008-1024": {"epss_score": 0.0207, "epss_percentile": 0.83472}, "CVE-2008-1025": {"epss_score": 0.00968, "epss_percentile": 0.76082}, "CVE-2008-1026": {"epss_score": 0.05274, "epss_percentile": 0.89681}, "CVE-2008-1027": {"epss_score": 0.00524, "epss_percentile": 0.66325}, "CVE-2008-1028": {"epss_score": 0.06121, "epss_percentile": 0.90495}, "CVE-2008-1030": {"epss_score": 0.01929, "epss_percentile": 0.82933}, "CVE-2008-1031": {"epss_score": 0.03194, "epss_percentile": 0.86607}, "CVE-2008-1032": {"epss_score": 0.04339, "epss_percentile": 0.88567}, "CVE-2008-1033": {"epss_score": 0.00202, "epss_percentile": 0.42422}, "CVE-2008-1034": {"epss_score": 0.20149, "epss_percentile": 0.95294}, "CVE-2008-1035": {"epss_score": 0.16532, "epss_percentile": 0.94687}, "CVE-2008-1036": {"epss_score": 0.02644, "epss_percentile": 0.85318}, "CVE-2008-1037": {"epss_score": 0.00334, "epss_percentile": 0.55724}, "CVE-2008-1038": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2008-1039": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1040": {"epss_score": 0.05161, "epss_percentile": 0.89559}, "CVE-2008-1041": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1042": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2008-1043": {"epss_score": 0.14709, "epss_percentile": 0.94268}, "CVE-2008-1044": {"epss_score": 0.25102, "epss_percentile": 0.95985}, "CVE-2008-1045": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-1046": {"epss_score": 0.06451, "epss_percentile": 0.90764}, "CVE-2008-1047": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-1048": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-1049": {"epss_score": 0.00416, "epss_percentile": 0.61172}, "CVE-2008-1050": {"epss_score": 0.00266, "epss_percentile": 0.49863}, "CVE-2008-1051": {"epss_score": 0.0805, "epss_percentile": 0.91854}, "CVE-2008-1052": {"epss_score": 0.06983, "epss_percentile": 0.9116}, "CVE-2008-1053": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1054": {"epss_score": 0.19518, "epss_percentile": 0.95197}, "CVE-2008-1055": {"epss_score": 0.21598, "epss_percentile": 0.95538}, "CVE-2008-1056": {"epss_score": 0.00048, "epss_percentile": 0.1501}, "CVE-2008-1057": {"epss_score": 0.00393, "epss_percentile": 0.59713}, "CVE-2008-1058": {"epss_score": 0.0032, "epss_percentile": 0.5464}, "CVE-2008-1059": {"epss_score": 0.00265, "epss_percentile": 0.49821}, "CVE-2008-1060": {"epss_score": 0.23757, "epss_percentile": 0.95813}, "CVE-2008-1061": {"epss_score": 0.00158, "epss_percentile": 0.37204}, "CVE-2008-1062": {"epss_score": 0.01087, "epss_percentile": 0.77427}, "CVE-2008-1063": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-1064": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-1065": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2008-1066": {"epss_score": 0.01179, "epss_percentile": 0.7829}, "CVE-2008-1067": {"epss_score": 0.12553, "epss_percentile": 0.93714}, "CVE-2008-1068": {"epss_score": 0.03259, "epss_percentile": 0.86768}, "CVE-2008-1069": {"epss_score": 0.26301, "epss_percentile": 0.96136}, "CVE-2008-1070": {"epss_score": 0.01004, "epss_percentile": 0.76526}, "CVE-2008-1071": {"epss_score": 0.00958, "epss_percentile": 0.75945}, "CVE-2008-1072": {"epss_score": 0.00109, "epss_percentile": 0.29955}, "CVE-2008-1073": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-1074": {"epss_score": 0.31434, "epss_percentile": 0.9662}, "CVE-2008-1075": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-1076": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1077": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-1078": {"epss_score": 0.00031, "epss_percentile": 0.08613}, "CVE-2008-1079": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2008-1080": {"epss_score": 0.01327, "epss_percentile": 0.79487}, "CVE-2008-1081": {"epss_score": 0.01203, "epss_percentile": 0.785}, "CVE-2008-1082": {"epss_score": 0.00371, "epss_percentile": 0.58358}, "CVE-2008-1083": {"epss_score": 0.64187, "epss_percentile": 0.98369}, "CVE-2008-1084": {"epss_score": 0.12096, "epss_percentile": 0.93565}, "CVE-2008-1085": {"epss_score": 0.4438, "epss_percentile": 0.97433}, "CVE-2008-1086": {"epss_score": 0.58752, "epss_percentile": 0.98135}, "CVE-2008-1087": {"epss_score": 0.71412, "epss_percentile": 0.98666}, "CVE-2008-1088": {"epss_score": 0.56734, "epss_percentile": 0.98035}, "CVE-2008-1089": {"epss_score": 0.5085, "epss_percentile": 0.97752}, "CVE-2008-1090": {"epss_score": 0.59441, "epss_percentile": 0.98165}, "CVE-2008-1091": {"epss_score": 0.62379, "epss_percentile": 0.9829}, "CVE-2008-1092": {"epss_score": 0.60636, "epss_percentile": 0.98213}, "CVE-2008-1093": {"epss_score": 0.00849, "epss_percentile": 0.74379}, "CVE-2008-1094": {"epss_score": 0.00541, "epss_percentile": 0.67051}, "CVE-2008-1095": {"epss_score": 0.0064, "epss_percentile": 0.69964}, "CVE-2008-1096": {"epss_score": 0.08715, "epss_percentile": 0.92223}, "CVE-2008-1097": {"epss_score": 0.06243, "epss_percentile": 0.90597}, "CVE-2008-1098": {"epss_score": 0.0081, "epss_percentile": 0.73722}, "CVE-2008-1099": {"epss_score": 0.01116, "epss_percentile": 0.77718}, "CVE-2008-1100": {"epss_score": 0.14613, "epss_percentile": 0.94251}, "CVE-2008-1101": {"epss_score": 0.23461, "epss_percentile": 0.95781}, "CVE-2008-1102": {"epss_score": 0.05407, "epss_percentile": 0.89841}, "CVE-2008-1103": {"epss_score": 0.00086, "epss_percentile": 0.2539}, "CVE-2008-1104": {"epss_score": 0.09965, "epss_percentile": 0.92796}, "CVE-2008-1105": {"epss_score": 0.88153, "epss_percentile": 0.9946}, "CVE-2008-1106": {"epss_score": 0.00161, "epss_percentile": 0.37576}, "CVE-2008-1107": {"epss_score": 0.06939, "epss_percentile": 0.9113}, "CVE-2008-1108": {"epss_score": 0.04236, "epss_percentile": 0.88428}, "CVE-2008-1109": {"epss_score": 0.04236, "epss_percentile": 0.88428}, "CVE-2008-1110": {"epss_score": 0.05835, "epss_percentile": 0.90248}, "CVE-2008-1111": {"epss_score": 0.00867, "epss_percentile": 0.7465}, "CVE-2008-1113": {"epss_score": 0.00237, "epss_percentile": 0.46705}, "CVE-2008-1114": {"epss_score": 0.00219, "epss_percentile": 0.44524}, "CVE-2008-1115": {"epss_score": 0.00112, "epss_percentile": 0.30504}, "CVE-2008-1116": {"epss_score": 0.06931, "epss_percentile": 0.91123}, "CVE-2008-1117": {"epss_score": 0.76828, "epss_percentile": 0.98907}, "CVE-2008-1118": {"epss_score": 0.09841, "epss_percentile": 0.9273}, "CVE-2008-1119": {"epss_score": 0.00611, "epss_percentile": 0.69201}, "CVE-2008-1120": {"epss_score": 0.00516, "epss_percentile": 0.6605}, "CVE-2008-1121": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1122": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-1123": {"epss_score": 0.03259, "epss_percentile": 0.86768}, "CVE-2008-1124": {"epss_score": 0.11013, "epss_percentile": 0.93189}, "CVE-2008-1125": {"epss_score": 0.03989, "epss_percentile": 0.88068}, "CVE-2008-1126": {"epss_score": 0.1107, "epss_percentile": 0.93208}, "CVE-2008-1127": {"epss_score": 0.11688, "epss_percentile": 0.93449}, "CVE-2008-1128": {"epss_score": 0.00918, "epss_percentile": 0.75439}, "CVE-2008-1129": {"epss_score": 0.00346, "epss_percentile": 0.56656}, "CVE-2008-1130": {"epss_score": 0.00062, "epss_percentile": 0.19758}, "CVE-2008-1131": {"epss_score": 0.00253, "epss_percentile": 0.48437}, "CVE-2008-1132": {"epss_score": 0.0008, "epss_percentile": 0.24194}, "CVE-2008-1133": {"epss_score": 0.00389, "epss_percentile": 0.59475}, "CVE-2008-1134": {"epss_score": 0.02204, "epss_percentile": 0.83997}, "CVE-2008-1135": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-1136": {"epss_score": 0.05572, "epss_percentile": 0.90008}, "CVE-2008-1137": {"epss_score": 0.00023, "epss_percentile": 0.05608}, "CVE-2008-1138": {"epss_score": 0.00447, "epss_percentile": 0.6297}, "CVE-2008-1139": {"epss_score": 0.00296, "epss_percentile": 0.52543}, "CVE-2008-1140": {"epss_score": 0.00439, "epss_percentile": 0.62591}, "CVE-2008-1141": {"epss_score": 0.00222, "epss_percentile": 0.44783}, "CVE-2008-1142": {"epss_score": 0.00066, "epss_percentile": 0.2085}, "CVE-2008-1144": {"epss_score": 0.01488, "epss_percentile": 0.80618}, "CVE-2008-1145": {"epss_score": 0.5985, "epss_percentile": 0.98184}, "CVE-2008-1146": {"epss_score": 0.00973, "epss_percentile": 0.76161}, "CVE-2008-1147": {"epss_score": 0.01327, "epss_percentile": 0.79487}, "CVE-2008-1148": {"epss_score": 0.00973, "epss_percentile": 0.76161}, "CVE-2008-1149": {"epss_score": 0.00764, "epss_percentile": 0.72897}, "CVE-2008-1150": {"epss_score": 0.00868, "epss_percentile": 0.74667}, "CVE-2008-1151": {"epss_score": 0.00868, "epss_percentile": 0.74667}, "CVE-2008-1152": {"epss_score": 0.01328, "epss_percentile": 0.79498}, "CVE-2008-1153": {"epss_score": 0.02987, "epss_percentile": 0.86134}, "CVE-2008-1154": {"epss_score": 0.05566, "epss_percentile": 0.90001}, "CVE-2008-1155": {"epss_score": 0.02372, "epss_percentile": 0.84528}, "CVE-2008-1156": {"epss_score": 0.00794, "epss_percentile": 0.73437}, "CVE-2008-1157": {"epss_score": 0.25268, "epss_percentile": 0.96006}, "CVE-2008-1158": {"epss_score": 0.01918, "epss_percentile": 0.8288}, "CVE-2008-1159": {"epss_score": 0.01351, "epss_percentile": 0.79682}, "CVE-2008-1160": {"epss_score": 0.29212, "epss_percentile": 0.96425}, "CVE-2008-1161": {"epss_score": 0.08926, "epss_percentile": 0.92323}, "CVE-2008-1162": {"epss_score": 0.00633, "epss_percentile": 0.69768}, "CVE-2008-1163": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-1164": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-1165": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1166": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2008-1167": {"epss_score": 0.13048, "epss_percentile": 0.93858}, "CVE-2008-1168": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2008-1169": {"epss_score": 0.02417, "epss_percentile": 0.84693}, "CVE-2008-1170": {"epss_score": 0.01624, "epss_percentile": 0.81414}, "CVE-2008-1171": {"epss_score": 0.00658, "epss_percentile": 0.70481}, "CVE-2008-1172": {"epss_score": 0.00129, "epss_percentile": 0.33087}, "CVE-2008-1173": {"epss_score": 0.00399, "epss_percentile": 0.60137}, "CVE-2008-1174": {"epss_score": 0.00505, "epss_percentile": 0.65612}, "CVE-2008-1175": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-1176": {"epss_score": 0.0061, "epss_percentile": 0.69155}, "CVE-2008-1177": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-1178": {"epss_score": 0.00828, "epss_percentile": 0.73993}, "CVE-2008-1179": {"epss_score": 0.00048, "epss_percentile": 0.1494}, "CVE-2008-1180": {"epss_score": 0.0553, "epss_percentile": 0.89966}, "CVE-2008-1181": {"epss_score": 0.0489, "epss_percentile": 0.89259}, "CVE-2008-1182": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2008-1183": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-1184": {"epss_score": 0.00573, "epss_percentile": 0.68051}, "CVE-2008-1185": {"epss_score": 0.17994, "epss_percentile": 0.94939}, "CVE-2008-1186": {"epss_score": 0.17994, "epss_percentile": 0.94939}, "CVE-2008-1187": {"epss_score": 0.21616, "epss_percentile": 0.9554}, "CVE-2008-1188": {"epss_score": 0.31494, "epss_percentile": 0.96623}, "CVE-2008-1189": {"epss_score": 0.31651, "epss_percentile": 0.9664}, "CVE-2008-1190": {"epss_score": 0.1722, "epss_percentile": 0.94801}, "CVE-2008-1191": {"epss_score": 0.09854, "epss_percentile": 0.92737}, "CVE-2008-1192": {"epss_score": 0.13064, "epss_percentile": 0.93862}, "CVE-2008-1193": {"epss_score": 0.37381, "epss_percentile": 0.97041}, "CVE-2008-1194": {"epss_score": 0.2747, "epss_percentile": 0.96247}, "CVE-2008-1195": {"epss_score": 0.14426, "epss_percentile": 0.94209}, "CVE-2008-1196": {"epss_score": 0.31252, "epss_percentile": 0.96603}, "CVE-2008-1197": {"epss_score": 0.01488, "epss_percentile": 0.80618}, "CVE-2008-1198": {"epss_score": 0.00428, "epss_percentile": 0.6195}, "CVE-2008-1199": {"epss_score": 0.00037, "epss_percentile": 0.10662}, "CVE-2008-1200": {"epss_score": 0.30041, "epss_percentile": 0.96499}, "CVE-2008-1201": {"epss_score": 0.09196, "epss_percentile": 0.92442}, "CVE-2008-1202": {"epss_score": 0.03331, "epss_percentile": 0.86927}, "CVE-2008-1203": {"epss_score": 0.07438, "epss_percentile": 0.91473}, "CVE-2008-1204": {"epss_score": 0.00293, "epss_percentile": 0.5231}, "CVE-2008-1205": {"epss_score": 0.0004, "epss_percentile": 0.11997}, "CVE-2008-1206": {"epss_score": 0.05571, "epss_percentile": 0.90007}, "CVE-2008-1207": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-1208": {"epss_score": 0.00865, "epss_percentile": 0.74621}, "CVE-2008-1209": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1210": {"epss_score": 0.02627, "epss_percentile": 0.85268}, "CVE-2008-1211": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1212": {"epss_score": 0.00171, "epss_percentile": 0.38785}, "CVE-2008-1213": {"epss_score": 0.00295, "epss_percentile": 0.52443}, "CVE-2008-1214": {"epss_score": 0.0188, "epss_percentile": 0.82676}, "CVE-2008-1215": {"epss_score": 0.0043, "epss_percentile": 0.62003}, "CVE-2008-1216": {"epss_score": 0.00854, "epss_percentile": 0.74447}, "CVE-2008-1217": {"epss_score": 0.03422, "epss_percentile": 0.87103}, "CVE-2008-1218": {"epss_score": 0.18733, "epss_percentile": 0.95061}, "CVE-2008-1219": {"epss_score": 0.00602, "epss_percentile": 0.68888}, "CVE-2008-1220": {"epss_score": 0.00254, "epss_percentile": 0.48553}, "CVE-2008-1221": {"epss_score": 0.05278, "epss_percentile": 0.89684}, "CVE-2008-1222": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-1223": {"epss_score": 0.0085, "epss_percentile": 0.74394}, "CVE-2008-1224": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1225": {"epss_score": 0.00514, "epss_percentile": 0.65949}, "CVE-2008-1226": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-1227": {"epss_score": 0.0459, "epss_percentile": 0.88892}, "CVE-2008-1228": {"epss_score": 0.00377, "epss_percentile": 0.58747}, "CVE-2008-1229": {"epss_score": 0.08585, "epss_percentile": 0.92135}, "CVE-2008-1230": {"epss_score": 0.10207, "epss_percentile": 0.92894}, "CVE-2008-1231": {"epss_score": 0.04928, "epss_percentile": 0.89295}, "CVE-2008-1232": {"epss_score": 0.38145, "epss_percentile": 0.97087}, "CVE-2008-1233": {"epss_score": 0.19859, "epss_percentile": 0.95252}, "CVE-2008-1234": {"epss_score": 0.07194, "epss_percentile": 0.91313}, "CVE-2008-1235": {"epss_score": 0.19121, "epss_percentile": 0.95133}, "CVE-2008-1236": {"epss_score": 0.26048, "epss_percentile": 0.96103}, "CVE-2008-1237": {"epss_score": 0.26048, "epss_percentile": 0.96103}, "CVE-2008-1238": {"epss_score": 0.05425, "epss_percentile": 0.89868}, "CVE-2008-1240": {"epss_score": 0.04851, "epss_percentile": 0.89215}, "CVE-2008-1241": {"epss_score": 0.03312, "epss_percentile": 0.86895}, "CVE-2008-1242": {"epss_score": 0.04229, "epss_percentile": 0.8842}, "CVE-2008-1243": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2008-1244": {"epss_score": 0.05018, "epss_percentile": 0.89399}, "CVE-2008-1245": {"epss_score": 0.0429, "epss_percentile": 0.88502}, "CVE-2008-1246": {"epss_score": 0.00122, "epss_percentile": 0.32132}, "CVE-2008-1247": {"epss_score": 0.13047, "epss_percentile": 0.93857}, "CVE-2008-1248": {"epss_score": 0.00261, "epss_percentile": 0.49311}, "CVE-2008-1249": {"epss_score": 0.00622, "epss_percentile": 0.69508}, "CVE-2008-1250": {"epss_score": 0.00308, "epss_percentile": 0.53598}, "CVE-2008-1251": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-1252": {"epss_score": 0.00995, "epss_percentile": 0.76432}, "CVE-2008-1253": {"epss_score": 0.00208, "epss_percentile": 0.43254}, "CVE-2008-1254": {"epss_score": 0.00215, "epss_percentile": 0.44085}, "CVE-2008-1255": {"epss_score": 0.00343, "epss_percentile": 0.56431}, "CVE-2008-1256": {"epss_score": 0.00761, "epss_percentile": 0.72823}, "CVE-2008-1257": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-1258": {"epss_score": 0.00208, "epss_percentile": 0.43254}, "CVE-2008-1259": {"epss_score": 0.00273, "epss_percentile": 0.50448}, "CVE-2008-1260": {"epss_score": 0.00118, "epss_percentile": 0.31512}, "CVE-2008-1261": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2008-1262": {"epss_score": 0.19586, "epss_percentile": 0.95212}, "CVE-2008-1263": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2008-1264": {"epss_score": 0.00478, "epss_percentile": 0.64375}, "CVE-2008-1265": {"epss_score": 0.00616, "epss_percentile": 0.69334}, "CVE-2008-1266": {"epss_score": 0.0034, "epss_percentile": 0.56227}, "CVE-2008-1267": {"epss_score": 0.00679, "epss_percentile": 0.71015}, "CVE-2008-1268": {"epss_score": 0.01063, "epss_percentile": 0.7719}, "CVE-2008-1269": {"epss_score": 0.00174, "epss_percentile": 0.39167}, "CVE-2008-1270": {"epss_score": 0.06276, "epss_percentile": 0.90632}, "CVE-2008-1272": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1273": {"epss_score": 0.00203, "epss_percentile": 0.42562}, "CVE-2008-1274": {"epss_score": 0.00053, "epss_percentile": 0.16981}, "CVE-2008-1275": {"epss_score": 0.33094, "epss_percentile": 0.96745}, "CVE-2008-1276": {"epss_score": 0.13145, "epss_percentile": 0.93885}, "CVE-2008-1277": {"epss_score": 0.05192, "epss_percentile": 0.89597}, "CVE-2008-1278": {"epss_score": 0.06423, "epss_percentile": 0.90751}, "CVE-2008-1279": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-1280": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2008-1281": {"epss_score": 0.00406, "epss_percentile": 0.6055}, "CVE-2008-1282": {"epss_score": 0.08947, "epss_percentile": 0.92333}, "CVE-2008-1283": {"epss_score": 0.01823, "epss_percentile": 0.82421}, "CVE-2008-1284": {"epss_score": 0.01313, "epss_percentile": 0.79382}, "CVE-2008-1285": {"epss_score": 0.00559, "epss_percentile": 0.67607}, "CVE-2008-1286": {"epss_score": 0.00308, "epss_percentile": 0.53591}, "CVE-2008-1287": {"epss_score": 0.00503, "epss_percentile": 0.65459}, "CVE-2008-1288": {"epss_score": 0.00464, "epss_percentile": 0.63705}, "CVE-2008-1289": {"epss_score": 0.28365, "epss_percentile": 0.96346}, "CVE-2008-1290": {"epss_score": 0.00718, "epss_percentile": 0.71933}, "CVE-2008-1291": {"epss_score": 0.00662, "epss_percentile": 0.70595}, "CVE-2008-1292": {"epss_score": 0.00718, "epss_percentile": 0.71933}, "CVE-2008-1293": {"epss_score": 0.00736, "epss_percentile": 0.72307}, "CVE-2008-1294": {"epss_score": 0.00039, "epss_percentile": 0.11605}, "CVE-2008-1295": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1296": {"epss_score": 0.00294, "epss_percentile": 0.52414}, "CVE-2008-1297": {"epss_score": 0.00017, "epss_percentile": 0.03372}, "CVE-2008-1298": {"epss_score": 0.00535, "epss_percentile": 0.66827}, "CVE-2008-1299": {"epss_score": 0.00217, "epss_percentile": 0.44239}, "CVE-2008-1300": {"epss_score": 0.00334, "epss_percentile": 0.55724}, "CVE-2008-1301": {"epss_score": 0.01916, "epss_percentile": 0.82857}, "CVE-2008-1302": {"epss_score": 0.01258, "epss_percentile": 0.7896}, "CVE-2008-1303": {"epss_score": 0.0651, "epss_percentile": 0.9081}, "CVE-2008-1304": {"epss_score": 0.0308, "epss_percentile": 0.86371}, "CVE-2008-1305": {"epss_score": 0.00284, "epss_percentile": 0.51439}, "CVE-2008-1306": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-1307": {"epss_score": 0.07508, "epss_percentile": 0.9151}, "CVE-2008-1308": {"epss_score": 0.00266, "epss_percentile": 0.49863}, "CVE-2008-1309": {"epss_score": 0.75196, "epss_percentile": 0.98833}, "CVE-2008-1310": {"epss_score": 0.00878, "epss_percentile": 0.74823}, "CVE-2008-1311": {"epss_score": 0.6635, "epss_percentile": 0.9846}, "CVE-2008-1312": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-1313": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1314": {"epss_score": 0.00301, "epss_percentile": 0.53079}, "CVE-2008-1315": {"epss_score": 0.00348, "epss_percentile": 0.56811}, "CVE-2008-1316": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1317": {"epss_score": 0.0004, "epss_percentile": 0.11997}, "CVE-2008-1318": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2008-1319": {"epss_score": 0.11821, "epss_percentile": 0.93486}, "CVE-2008-1320": {"epss_score": 0.28103, "epss_percentile": 0.96311}, "CVE-2008-1321": {"epss_score": 0.17371, "epss_percentile": 0.9484}, "CVE-2008-1322": {"epss_score": 0.10908, "epss_percentile": 0.93153}, "CVE-2008-1323": {"epss_score": 0.00215, "epss_percentile": 0.44085}, "CVE-2008-1324": {"epss_score": 0.02332, "epss_percentile": 0.84408}, "CVE-2008-1325": {"epss_score": 0.01763, "epss_percentile": 0.82155}, "CVE-2008-1326": {"epss_score": 0.0152, "epss_percentile": 0.80822}, "CVE-2008-1327": {"epss_score": 0.04581, "epss_percentile": 0.88876}, "CVE-2008-1328": {"epss_score": 0.16743, "epss_percentile": 0.94725}, "CVE-2008-1329": {"epss_score": 0.04732, "epss_percentile": 0.8907}, "CVE-2008-1330": {"epss_score": 0.00493, "epss_percentile": 0.65038}, "CVE-2008-1331": {"epss_score": 0.58502, "epss_percentile": 0.98121}, "CVE-2008-1332": {"epss_score": 0.01064, "epss_percentile": 0.77197}, "CVE-2008-1333": {"epss_score": 0.02578, "epss_percentile": 0.85147}, "CVE-2008-1334": {"epss_score": 0.00427, "epss_percentile": 0.61776}, "CVE-2008-1335": {"epss_score": 0.00302, "epss_percentile": 0.53137}, "CVE-2008-1336": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-1337": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-1338": {"epss_score": 0.01566, "epss_percentile": 0.81072}, "CVE-2008-1340": {"epss_score": 0.00944, "epss_percentile": 0.75795}, "CVE-2008-1341": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-1342": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-1343": {"epss_score": 0.00208, "epss_percentile": 0.43265}, "CVE-2008-1344": {"epss_score": 0.0045, "epss_percentile": 0.63073}, "CVE-2008-1345": {"epss_score": 0.02524, "epss_percentile": 0.8501}, "CVE-2008-1346": {"epss_score": 0.0045, "epss_percentile": 0.63073}, "CVE-2008-1347": {"epss_score": 0.02524, "epss_percentile": 0.8501}, "CVE-2008-1348": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-1349": {"epss_score": 0.00995, "epss_percentile": 0.76439}, "CVE-2008-1350": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-1351": {"epss_score": 0.00332, "epss_percentile": 0.55593}, "CVE-2008-1352": {"epss_score": 0.00095, "epss_percentile": 0.27112}, "CVE-2008-1353": {"epss_score": 0.05858, "epss_percentile": 0.90269}, "CVE-2008-1354": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-1355": {"epss_score": 0.00255, "epss_percentile": 0.48693}, "CVE-2008-1356": {"epss_score": 0.00038, "epss_percentile": 0.11072}, "CVE-2008-1357": {"epss_score": 0.27884, "epss_percentile": 0.96291}, "CVE-2008-1358": {"epss_score": 0.7623, "epss_percentile": 0.98883}, "CVE-2008-1359": {"epss_score": 0.00245, "epss_percentile": 0.47637}, "CVE-2008-1360": {"epss_score": 0.00304, "epss_percentile": 0.53254}, "CVE-2008-1361": {"epss_score": 0.00041, "epss_percentile": 0.12246}, "CVE-2008-1362": {"epss_score": 0.00035, "epss_percentile": 0.09943}, "CVE-2008-1363": {"epss_score": 0.00044, "epss_percentile": 0.1338}, "CVE-2008-1364": {"epss_score": 0.018, "epss_percentile": 0.82322}, "CVE-2008-1365": {"epss_score": 0.75208, "epss_percentile": 0.98833}, "CVE-2008-1366": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2008-1367": {"epss_score": 0.03467, "epss_percentile": 0.87191}, "CVE-2008-1368": {"epss_score": 0.23098, "epss_percentile": 0.95735}, "CVE-2008-1369": {"epss_score": 0.02372, "epss_percentile": 0.84528}, "CVE-2008-1370": {"epss_score": 0.00878, "epss_percentile": 0.74832}, "CVE-2008-1371": {"epss_score": 0.0142, "epss_percentile": 0.80165}, "CVE-2008-1372": {"epss_score": 0.07739, "epss_percentile": 0.91652}, "CVE-2008-1373": {"epss_score": 0.07511, "epss_percentile": 0.91512}, "CVE-2008-1374": {"epss_score": 0.02318, "epss_percentile": 0.84361}, "CVE-2008-1375": {"epss_score": 0.00069, "epss_percentile": 0.21627}, "CVE-2008-1376": {"epss_score": 0.00574, "epss_percentile": 0.6808}, "CVE-2008-1377": {"epss_score": 0.02373, "epss_percentile": 0.84532}, "CVE-2008-1379": {"epss_score": 0.00996, "epss_percentile": 0.76445}, "CVE-2008-1380": {"epss_score": 0.17011, "epss_percentile": 0.9476}, "CVE-2008-1381": {"epss_score": 0.01505, "epss_percentile": 0.80741}, "CVE-2008-1382": {"epss_score": 0.0633, "epss_percentile": 0.90674}, "CVE-2008-1383": {"epss_score": 0.00032, "epss_percentile": 0.08777}, "CVE-2008-1384": {"epss_score": 0.0237, "epss_percentile": 0.84524}, "CVE-2008-1385": {"epss_score": 0.06741, "epss_percentile": 0.90995}, "CVE-2008-1386": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2008-1387": {"epss_score": 0.0565, "epss_percentile": 0.90085}, "CVE-2008-1389": {"epss_score": 0.08606, "epss_percentile": 0.92147}, "CVE-2008-1390": {"epss_score": 0.02654, "epss_percentile": 0.85353}, "CVE-2008-1391": {"epss_score": 0.20122, "epss_percentile": 0.9529}, "CVE-2008-1392": {"epss_score": 0.00754, "epss_percentile": 0.72701}, "CVE-2008-1393": {"epss_score": 0.0167, "epss_percentile": 0.8167}, "CVE-2008-1394": {"epss_score": 0.00715, "epss_percentile": 0.71842}, "CVE-2008-1395": {"epss_score": 0.003, "epss_percentile": 0.52958}, "CVE-2008-1396": {"epss_score": 0.00327, "epss_percentile": 0.55095}, "CVE-2008-1397": {"epss_score": 0.07501, "epss_percentile": 0.91506}, "CVE-2008-1398": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1399": {"epss_score": 0.00406, "epss_percentile": 0.60557}, "CVE-2008-1400": {"epss_score": 0.04508, "epss_percentile": 0.88778}, "CVE-2008-1401": {"epss_score": 0.13342, "epss_percentile": 0.93937}, "CVE-2008-1402": {"epss_score": 0.06805, "epss_percentile": 0.91037}, "CVE-2008-1403": {"epss_score": 0.0502, "epss_percentile": 0.894}, "CVE-2008-1404": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1405": {"epss_score": 0.09174, "epss_percentile": 0.92432}, "CVE-2008-1406": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1407": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1408": {"epss_score": 0.00963, "epss_percentile": 0.76001}, "CVE-2008-1409": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-1410": {"epss_score": 0.10509, "epss_percentile": 0.93014}, "CVE-2008-1411": {"epss_score": 0.1008, "epss_percentile": 0.92842}, "CVE-2008-1412": {"epss_score": 0.27048, "epss_percentile": 0.962}, "CVE-2008-1413": {"epss_score": 0.01823, "epss_percentile": 0.82421}, "CVE-2008-1414": {"epss_score": 0.07148, "epss_percentile": 0.91284}, "CVE-2008-1415": {"epss_score": 0.04011, "epss_percentile": 0.88112}, "CVE-2008-1416": {"epss_score": 0.11913, "epss_percentile": 0.93514}, "CVE-2008-1417": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-1419": {"epss_score": 0.13143, "epss_percentile": 0.93884}, "CVE-2008-1420": {"epss_score": 0.08948, "epss_percentile": 0.92333}, "CVE-2008-1423": {"epss_score": 0.10744, "epss_percentile": 0.9309}, "CVE-2008-1425": {"epss_score": 0.00498, "epss_percentile": 0.65226}, "CVE-2008-1426": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-1427": {"epss_score": 0.00019, "epss_percentile": 0.04191}, "CVE-2008-1428": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-1429": {"epss_score": 0.01566, "epss_percentile": 0.81072}, "CVE-2008-1430": {"epss_score": 0.00473, "epss_percentile": 0.64077}, "CVE-2008-1431": {"epss_score": 0.00038, "epss_percentile": 0.1135}, "CVE-2008-1432": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-1434": {"epss_score": 0.54907, "epss_percentile": 0.97951}, "CVE-2008-1435": {"epss_score": 0.50685, "epss_percentile": 0.97745}, "CVE-2008-1436": {"epss_score": 0.5788, "epss_percentile": 0.98089}, "CVE-2008-1437": {"epss_score": 0.5026, "epss_percentile": 0.97729}, "CVE-2008-1438": {"epss_score": 0.43712, "epss_percentile": 0.97399}, "CVE-2008-1440": {"epss_score": 0.50592, "epss_percentile": 0.97741}, "CVE-2008-1441": {"epss_score": 0.63393, "epss_percentile": 0.98332}, "CVE-2008-1442": {"epss_score": 0.62851, "epss_percentile": 0.98311}, "CVE-2008-1444": {"epss_score": 0.60921, "epss_percentile": 0.98227}, "CVE-2008-1445": {"epss_score": 0.5792, "epss_percentile": 0.98091}, "CVE-2008-1446": {"epss_score": 0.67001, "epss_percentile": 0.98489}, "CVE-2008-1447": {"epss_score": 0.85892, "epss_percentile": 0.99354}, "CVE-2008-1448": {"epss_score": 0.45538, "epss_percentile": 0.9749}, "CVE-2008-1451": {"epss_score": 0.04773, "epss_percentile": 0.89129}, "CVE-2008-1453": {"epss_score": 0.01297, "epss_percentile": 0.79262}, "CVE-2008-1454": {"epss_score": 0.5456, "epss_percentile": 0.97932}, "CVE-2008-1455": {"epss_score": 0.63798, "epss_percentile": 0.98349}, "CVE-2008-1456": {"epss_score": 0.66294, "epss_percentile": 0.98459}, "CVE-2008-1457": {"epss_score": 0.54932, "epss_percentile": 0.97952}, "CVE-2008-1458": {"epss_score": 0.00334, "epss_percentile": 0.55724}, "CVE-2008-1459": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1460": {"epss_score": 0.00338, "epss_percentile": 0.56139}, "CVE-2008-1461": {"epss_score": 0.05128, "epss_percentile": 0.89527}, "CVE-2008-1462": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1463": {"epss_score": 0.00505, "epss_percentile": 0.65612}, "CVE-2008-1464": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2008-1465": {"epss_score": 0.00568, "epss_percentile": 0.67905}, "CVE-2008-1466": {"epss_score": 0.00818, "epss_percentile": 0.73857}, "CVE-2008-1467": {"epss_score": 0.03604, "epss_percentile": 0.87414}, "CVE-2008-1468": {"epss_score": 0.00651, "epss_percentile": 0.70283}, "CVE-2008-1469": {"epss_score": 0.00506, "epss_percentile": 0.65619}, "CVE-2008-1470": {"epss_score": 0.00508, "epss_percentile": 0.65702}, "CVE-2008-1471": {"epss_score": 0.00251, "epss_percentile": 0.4831}, "CVE-2008-1472": {"epss_score": 0.78088, "epss_percentile": 0.98968}, "CVE-2008-1473": {"epss_score": 0.00077, "epss_percentile": 0.23305}, "CVE-2008-1474": {"epss_score": 0.01035, "epss_percentile": 0.76903}, "CVE-2008-1475": {"epss_score": 0.0047, "epss_percentile": 0.6397}, "CVE-2008-1476": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2008-1477": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-1478": {"epss_score": 0.0549, "epss_percentile": 0.89929}, "CVE-2008-1479": {"epss_score": 0.00292, "epss_percentile": 0.52238}, "CVE-2008-1480": {"epss_score": 0.09986, "epss_percentile": 0.92804}, "CVE-2008-1481": {"epss_score": 0.01149, "epss_percentile": 0.78019}, "CVE-2008-1482": {"epss_score": 0.02123, "epss_percentile": 0.83686}, "CVE-2008-1483": {"epss_score": 0.00135, "epss_percentile": 0.34002}, "CVE-2008-1484": {"epss_score": 0.10582, "epss_percentile": 0.93034}, "CVE-2008-1485": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1486": {"epss_score": 0.00371, "epss_percentile": 0.58383}, "CVE-2008-1487": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1488": {"epss_score": 0.05521, "epss_percentile": 0.89958}, "CVE-2008-1489": {"epss_score": 0.33213, "epss_percentile": 0.96753}, "CVE-2008-1490": {"epss_score": 0.04159, "epss_percentile": 0.88333}, "CVE-2008-1491": {"epss_score": 0.88716, "epss_percentile": 0.99486}, "CVE-2008-1492": {"epss_score": 0.12084, "epss_percentile": 0.93563}, "CVE-2008-1493": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-1494": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2008-1495": {"epss_score": 0.04604, "epss_percentile": 0.88905}, "CVE-2008-1496": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-1497": {"epss_score": 0.10686, "epss_percentile": 0.9307}, "CVE-2008-1498": {"epss_score": 0.2743, "epss_percentile": 0.96245}, "CVE-2008-1499": {"epss_score": 0.01823, "epss_percentile": 0.82421}, "CVE-2008-1500": {"epss_score": 0.00292, "epss_percentile": 0.52238}, "CVE-2008-1501": {"epss_score": 0.1961, "epss_percentile": 0.95214}, "CVE-2008-1502": {"epss_score": 0.01086, "epss_percentile": 0.77423}, "CVE-2008-1503": {"epss_score": 0.0035, "epss_percentile": 0.56918}, "CVE-2008-1504": {"epss_score": 0.00244, "epss_percentile": 0.4758}, "CVE-2008-1505": {"epss_score": 0.07863, "epss_percentile": 0.91727}, "CVE-2008-1506": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2008-1507": {"epss_score": 0.04404, "epss_percentile": 0.88649}, "CVE-2008-1508": {"epss_score": 0.0036, "epss_percentile": 0.57629}, "CVE-2008-1509": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1510": {"epss_score": 0.00346, "epss_percentile": 0.56656}, "CVE-2008-1511": {"epss_score": 0.01837, "epss_percentile": 0.82481}, "CVE-2008-1512": {"epss_score": 0.0086, "epss_percentile": 0.74525}, "CVE-2008-1513": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-1514": {"epss_score": 0.00088, "epss_percentile": 0.25671}, "CVE-2008-1515": {"epss_score": 0.00709, "epss_percentile": 0.71689}, "CVE-2008-1517": {"epss_score": 0.00064, "epss_percentile": 0.20349}, "CVE-2008-1518": {"epss_score": 0.00088, "epss_percentile": 0.2579}, "CVE-2008-1521": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2008-1522": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2008-1523": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-1524": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2008-1525": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2008-1526": {"epss_score": 0.00195, "epss_percentile": 0.41636}, "CVE-2008-1527": {"epss_score": 0.00565, "epss_percentile": 0.67797}, "CVE-2008-1528": {"epss_score": 0.00202, "epss_percentile": 0.42457}, "CVE-2008-1529": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-1530": {"epss_score": 0.03697, "epss_percentile": 0.87586}, "CVE-2008-1531": {"epss_score": 0.03274, "epss_percentile": 0.868}, "CVE-2008-1532": {"epss_score": 0.01976, "epss_percentile": 0.83121}, "CVE-2008-1533": {"epss_score": 0.00012, "epss_percentile": 0.01304}, "CVE-2008-1534": {"epss_score": 0.05901, "epss_percentile": 0.90309}, "CVE-2008-1535": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1536": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-1537": {"epss_score": 0.05972, "epss_percentile": 0.90372}, "CVE-2008-1538": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-1539": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1540": {"epss_score": 6e-05, "epss_percentile": 0.00252}, "CVE-2008-1541": {"epss_score": 0.07261, "epss_percentile": 0.91356}, "CVE-2008-1542": {"epss_score": 0.02087, "epss_percentile": 0.83553}, "CVE-2008-1543": {"epss_score": 0.00423, "epss_percentile": 0.61634}, "CVE-2008-1544": {"epss_score": 0.51206, "epss_percentile": 0.97769}, "CVE-2008-1545": {"epss_score": 0.24205, "epss_percentile": 0.95886}, "CVE-2008-1546": {"epss_score": 0.00668, "epss_percentile": 0.70728}, "CVE-2008-1547": {"epss_score": 0.6311, "epss_percentile": 0.98321}, "CVE-2008-1548": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-1549": {"epss_score": 0.00394, "epss_percentile": 0.59795}, "CVE-2008-1550": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-1551": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1552": {"epss_score": 0.0673, "epss_percentile": 0.90987}, "CVE-2008-1553": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-1554": {"epss_score": 0.0013, "epss_percentile": 0.33286}, "CVE-2008-1555": {"epss_score": 0.07032, "epss_percentile": 0.912}, "CVE-2008-1556": {"epss_score": 0.06494, "epss_percentile": 0.90799}, "CVE-2008-1557": {"epss_score": 0.05992, "epss_percentile": 0.90388}, "CVE-2008-1558": {"epss_score": 0.21937, "epss_percentile": 0.95575}, "CVE-2008-1559": {"epss_score": 0.00461, "epss_percentile": 0.63553}, "CVE-2008-1560": {"epss_score": 0.00841, "epss_percentile": 0.74231}, "CVE-2008-1561": {"epss_score": 0.081, "epss_percentile": 0.91878}, "CVE-2008-1562": {"epss_score": 0.4219, "epss_percentile": 0.97317}, "CVE-2008-1563": {"epss_score": 0.07411, "epss_percentile": 0.91459}, "CVE-2008-1564": {"epss_score": 0.02242, "epss_percentile": 0.84118}, "CVE-2008-1565": {"epss_score": 0.00428, "epss_percentile": 0.61957}, "CVE-2008-1566": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1567": {"epss_score": 0.0004, "epss_percentile": 0.12153}, "CVE-2008-1568": {"epss_score": 0.00793, "epss_percentile": 0.73436}, "CVE-2008-1569": {"epss_score": 0.00054, "epss_percentile": 0.17347}, "CVE-2008-1570": {"epss_score": 0.0003, "epss_percentile": 0.08212}, "CVE-2008-1571": {"epss_score": 0.00754, "epss_percentile": 0.72692}, "CVE-2008-1572": {"epss_score": 0.00064, "epss_percentile": 0.2042}, "CVE-2008-1573": {"epss_score": 0.00784, "epss_percentile": 0.73245}, "CVE-2008-1574": {"epss_score": 0.06438, "epss_percentile": 0.90758}, "CVE-2008-1575": {"epss_score": 0.06467, "epss_percentile": 0.90775}, "CVE-2008-1576": {"epss_score": 0.01562, "epss_percentile": 0.81047}, "CVE-2008-1577": {"epss_score": 0.04311, "epss_percentile": 0.88531}, "CVE-2008-1578": {"epss_score": 0.00065, "epss_percentile": 0.20673}, "CVE-2008-1579": {"epss_score": 0.00531, "epss_percentile": 0.66668}, "CVE-2008-1580": {"epss_score": 0.0019, "epss_percentile": 0.41071}, "CVE-2008-1581": {"epss_score": 0.19593, "epss_percentile": 0.95212}, "CVE-2008-1582": {"epss_score": 0.11113, "epss_percentile": 0.93226}, "CVE-2008-1583": {"epss_score": 0.11973, "epss_percentile": 0.9353}, "CVE-2008-1584": {"epss_score": 0.19936, "epss_percentile": 0.95263}, "CVE-2008-1585": {"epss_score": 0.09415, "epss_percentile": 0.92537}, "CVE-2008-1586": {"epss_score": 0.01764, "epss_percentile": 0.8216}, "CVE-2008-1588": {"epss_score": 0.00879, "epss_percentile": 0.7484}, "CVE-2008-1589": {"epss_score": 0.00256, "epss_percentile": 0.48841}, "CVE-2008-1590": {"epss_score": 0.01884, "epss_percentile": 0.82704}, "CVE-2008-1591": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1592": {"epss_score": 0.00064, "epss_percentile": 0.20291}, "CVE-2008-1593": {"epss_score": 0.00066, "epss_percentile": 0.20895}, "CVE-2008-1594": {"epss_score": 0.00054, "epss_percentile": 0.17263}, "CVE-2008-1595": {"epss_score": 0.00046, "epss_percentile": 0.14184}, "CVE-2008-1596": {"epss_score": 0.00053, "epss_percentile": 0.16687}, "CVE-2008-1597": {"epss_score": 0.00048, "epss_percentile": 0.14999}, "CVE-2008-1598": {"epss_score": 0.00063, "epss_percentile": 0.19895}, "CVE-2008-1599": {"epss_score": 0.00065, "epss_percentile": 0.20502}, "CVE-2008-1600": {"epss_score": 0.00065, "epss_percentile": 0.20502}, "CVE-2008-1601": {"epss_score": 0.00057, "epss_percentile": 0.18203}, "CVE-2008-1602": {"epss_score": 0.76581, "epss_percentile": 0.98897}, "CVE-2008-1603": {"epss_score": 0.00401, "epss_percentile": 0.60237}, "CVE-2008-1604": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-1605": {"epss_score": 0.02849, "epss_percentile": 0.85826}, "CVE-2008-1606": {"epss_score": 0.04606, "epss_percentile": 0.8891}, "CVE-2008-1607": {"epss_score": 0.00254, "epss_percentile": 0.48553}, "CVE-2008-1608": {"epss_score": 0.00526, "epss_percentile": 0.66403}, "CVE-2008-1609": {"epss_score": 0.33459, "epss_percentile": 0.96775}, "CVE-2008-1610": {"epss_score": 0.78325, "epss_percentile": 0.9898}, "CVE-2008-1611": {"epss_score": 0.8243, "epss_percentile": 0.99195}, "CVE-2008-1612": {"epss_score": 0.11711, "epss_percentile": 0.93457}, "CVE-2008-1613": {"epss_score": 0.00905, "epss_percentile": 0.75232}, "CVE-2008-1614": {"epss_score": 0.00064, "epss_percentile": 0.20151}, "CVE-2008-1615": {"epss_score": 0.00062, "epss_percentile": 0.19585}, "CVE-2008-1617": {"epss_score": 0.02564, "epss_percentile": 0.85113}, "CVE-2008-1618": {"epss_score": 0.0061, "epss_percentile": 0.69136}, "CVE-2008-1619": {"epss_score": 0.00593, "epss_percentile": 0.68638}, "CVE-2008-1620": {"epss_score": 0.05893, "epss_percentile": 0.90301}, "CVE-2008-1621": {"epss_score": 0.00276, "epss_percentile": 0.50757}, "CVE-2008-1622": {"epss_score": 0.00458, "epss_percentile": 0.63421}, "CVE-2008-1623": {"epss_score": 0.00589, "epss_percentile": 0.68536}, "CVE-2008-1624": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-1625": {"epss_score": 0.00084, "epss_percentile": 0.24904}, "CVE-2008-1626": {"epss_score": 0.0041, "epss_percentile": 0.60845}, "CVE-2008-1627": {"epss_score": 0.00538, "epss_percentile": 0.66925}, "CVE-2008-1628": {"epss_score": 0.00448, "epss_percentile": 0.6303}, "CVE-2008-1629": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-1630": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-1631": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-1632": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2008-1633": {"epss_score": 0.00366, "epss_percentile": 0.58021}, "CVE-2008-1634": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1635": {"epss_score": 0.0376, "epss_percentile": 0.87687}, "CVE-2008-1636": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-1637": {"epss_score": 0.00027, "epss_percentile": 0.06955}, "CVE-2008-1638": {"epss_score": 0.00379, "epss_percentile": 0.58901}, "CVE-2008-1639": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1640": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1641": {"epss_score": 0.00394, "epss_percentile": 0.59792}, "CVE-2008-1642": {"epss_score": 0.00152, "epss_percentile": 0.36452}, "CVE-2008-1643": {"epss_score": 0.00283, "epss_percentile": 0.51405}, "CVE-2008-1644": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-1645": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-1646": {"epss_score": 0.00937, "epss_percentile": 0.75695}, "CVE-2008-1647": {"epss_score": 0.05958, "epss_percentile": 0.90364}, "CVE-2008-1648": {"epss_score": 0.01977, "epss_percentile": 0.83123}, "CVE-2008-1649": {"epss_score": 0.07892, "epss_percentile": 0.91748}, "CVE-2008-1650": {"epss_score": 0.01342, "epss_percentile": 0.79598}, "CVE-2008-1651": {"epss_score": 0.12397, "epss_percentile": 0.93658}, "CVE-2008-1652": {"epss_score": 0.00175, "epss_percentile": 0.39316}, "CVE-2008-1653": {"epss_score": 0.00142, "epss_percentile": 0.35044}, "CVE-2008-1654": {"epss_score": 0.27914, "epss_percentile": 0.96294}, "CVE-2008-1655": {"epss_score": 0.27257, "epss_percentile": 0.96229}, "CVE-2008-1656": {"epss_score": 0.04664, "epss_percentile": 0.88978}, "CVE-2008-1657": {"epss_score": 0.00458, "epss_percentile": 0.63425}, "CVE-2008-1658": {"epss_score": 0.00128, "epss_percentile": 0.33013}, "CVE-2008-1659": {"epss_score": 0.00064, "epss_percentile": 0.20271}, "CVE-2008-1660": {"epss_score": 0.00084, "epss_percentile": 0.24915}, "CVE-2008-1661": {"epss_score": 0.80524, "epss_percentile": 0.99093}, "CVE-2008-1662": {"epss_score": 0.0257, "epss_percentile": 0.85128}, "CVE-2008-1663": {"epss_score": 0.00387, "epss_percentile": 0.59306}, "CVE-2008-1664": {"epss_score": 0.02728, "epss_percentile": 0.85533}, "CVE-2008-1665": {"epss_score": 0.01204, "epss_percentile": 0.78503}, "CVE-2008-1666": {"epss_score": 0.00336, "epss_percentile": 0.55998}, "CVE-2008-1667": {"epss_score": 0.05586, "epss_percentile": 0.90025}, "CVE-2008-1668": {"epss_score": 0.02593, "epss_percentile": 0.85188}, "CVE-2008-1669": {"epss_score": 0.00119, "epss_percentile": 0.31672}, "CVE-2008-1670": {"epss_score": 0.04194, "epss_percentile": 0.88379}, "CVE-2008-1671": {"epss_score": 0.0013, "epss_percentile": 0.33252}, "CVE-2008-1672": {"epss_score": 0.21264, "epss_percentile": 0.9549}, "CVE-2008-1673": {"epss_score": 0.18359, "epss_percentile": 0.95003}, "CVE-2008-1675": {"epss_score": 0.00068, "epss_percentile": 0.21238}, "CVE-2008-1676": {"epss_score": 0.00257, "epss_percentile": 0.48869}, "CVE-2008-1677": {"epss_score": 0.02616, "epss_percentile": 0.85246}, "CVE-2008-1678": {"epss_score": 0.08958, "epss_percentile": 0.92337}, "CVE-2008-1679": {"epss_score": 0.00443, "epss_percentile": 0.62795}, "CVE-2008-1680": {"epss_score": 0.04492, "epss_percentile": 0.88759}, "CVE-2008-1681": {"epss_score": 0.00985, "epss_percentile": 0.76323}, "CVE-2008-1682": {"epss_score": 0.18115, "epss_percentile": 0.94959}, "CVE-2008-1684": {"epss_score": 0.00019, "epss_percentile": 0.04338}, "CVE-2008-1685": {"epss_score": 0.02013, "epss_percentile": 0.83259}, "CVE-2008-1686": {"epss_score": 0.0525, "epss_percentile": 0.89663}, "CVE-2008-1687": {"epss_score": 0.02727, "epss_percentile": 0.8553}, "CVE-2008-1688": {"epss_score": 0.02196, "epss_percentile": 0.83955}, "CVE-2008-1689": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2008-1690": {"epss_score": 0.18285, "epss_percentile": 0.94989}, "CVE-2008-1691": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2008-1692": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2008-1693": {"epss_score": 0.06879, "epss_percentile": 0.91089}, "CVE-2008-1694": {"epss_score": 0.0007, "epss_percentile": 0.21976}, "CVE-2008-1696": {"epss_score": 0.01639, "epss_percentile": 0.81489}, "CVE-2008-1697": {"epss_score": 0.8345, "epss_percentile": 0.99249}, "CVE-2008-1698": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1699": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-1700": {"epss_score": 0.00701, "epss_percentile": 0.71491}, "CVE-2008-1701": {"epss_score": 0.00889, "epss_percentile": 0.75023}, "CVE-2008-1702": {"epss_score": 0.04992, "epss_percentile": 0.89368}, "CVE-2008-1703": {"epss_score": 0.11647, "epss_percentile": 0.93428}, "CVE-2008-1704": {"epss_score": 0.12626, "epss_percentile": 0.93733}, "CVE-2008-1705": {"epss_score": 0.05222, "epss_percentile": 0.89628}, "CVE-2008-1706": {"epss_score": 0.01169, "epss_percentile": 0.78198}, "CVE-2008-1707": {"epss_score": 0.01357, "epss_percentile": 0.79718}, "CVE-2008-1708": {"epss_score": 0.01169, "epss_percentile": 0.78198}, "CVE-2008-1709": {"epss_score": 0.35453, "epss_percentile": 0.96911}, "CVE-2008-1710": {"epss_score": 0.00066, "epss_percentile": 0.20959}, "CVE-2008-1711": {"epss_score": 0.05073, "epss_percentile": 0.89466}, "CVE-2008-1712": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2008-1713": {"epss_score": 0.0651, "epss_percentile": 0.90809}, "CVE-2008-1714": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1715": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1716": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-1717": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2008-1718": {"epss_score": 0.06504, "epss_percentile": 0.90804}, "CVE-2008-1719": {"epss_score": 0.00205, "epss_percentile": 0.4276}, "CVE-2008-1720": {"epss_score": 0.08442, "epss_percentile": 0.92053}, "CVE-2008-1721": {"epss_score": 0.31083, "epss_percentile": 0.96586}, "CVE-2008-1722": {"epss_score": 0.04161, "epss_percentile": 0.88335}, "CVE-2008-1724": {"epss_score": 0.78207, "epss_percentile": 0.98973}, "CVE-2008-1725": {"epss_score": 0.05021, "epss_percentile": 0.89401}, "CVE-2008-1726": {"epss_score": 0.01455, "epss_percentile": 0.80385}, "CVE-2008-1727": {"epss_score": 0.03579, "epss_percentile": 0.87382}, "CVE-2008-1728": {"epss_score": 0.01384, "epss_percentile": 0.79897}, "CVE-2008-1729": {"epss_score": 0.00618, "epss_percentile": 0.69386}, "CVE-2008-1730": {"epss_score": 0.04508, "epss_percentile": 0.88778}, "CVE-2008-1731": {"epss_score": 0.00374, "epss_percentile": 0.58533}, "CVE-2008-1732": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1733": {"epss_score": 0.00348, "epss_percentile": 0.56813}, "CVE-2008-1734": {"epss_score": 0.00058, "epss_percentile": 0.18454}, "CVE-2008-1735": {"epss_score": 0.00058, "epss_percentile": 0.18594}, "CVE-2008-1736": {"epss_score": 0.00058, "epss_percentile": 0.18579}, "CVE-2008-1737": {"epss_score": 0.00057, "epss_percentile": 0.17988}, "CVE-2008-1738": {"epss_score": 0.00026, "epss_percentile": 0.06439}, "CVE-2008-1739": {"epss_score": 0.01258, "epss_percentile": 0.78957}, "CVE-2008-1740": {"epss_score": 0.01918, "epss_percentile": 0.8288}, "CVE-2008-1741": {"epss_score": 0.01918, "epss_percentile": 0.8288}, "CVE-2008-1742": {"epss_score": 0.00803, "epss_percentile": 0.73603}, "CVE-2008-1743": {"epss_score": 0.01626, "epss_percentile": 0.81426}, "CVE-2008-1744": {"epss_score": 0.01042, "epss_percentile": 0.76986}, "CVE-2008-1745": {"epss_score": 0.01918, "epss_percentile": 0.8288}, "CVE-2008-1746": {"epss_score": 0.01918, "epss_percentile": 0.8288}, "CVE-2008-1747": {"epss_score": 0.02174, "epss_percentile": 0.83877}, "CVE-2008-1748": {"epss_score": 0.02174, "epss_percentile": 0.83877}, "CVE-2008-1749": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2008-1750": {"epss_score": 0.00995, "epss_percentile": 0.76439}, "CVE-2008-1751": {"epss_score": 0.03433, "epss_percentile": 0.87128}, "CVE-2008-1752": {"epss_score": 0.00622, "epss_percentile": 0.69501}, "CVE-2008-1753": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2008-1754": {"epss_score": 0.00083, "epss_percentile": 0.2472}, "CVE-2008-1755": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-1756": {"epss_score": 0.00051, "epss_percentile": 0.16305}, "CVE-2008-1757": {"epss_score": 0.00346, "epss_percentile": 0.56656}, "CVE-2008-1758": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1759": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-1760": {"epss_score": 0.05207, "epss_percentile": 0.89612}, "CVE-2008-1761": {"epss_score": 0.07648, "epss_percentile": 0.91602}, "CVE-2008-1762": {"epss_score": 0.21661, "epss_percentile": 0.95545}, "CVE-2008-1763": {"epss_score": 0.00897, "epss_percentile": 0.75127}, "CVE-2008-1764": {"epss_score": 0.00686, "epss_percentile": 0.71155}, "CVE-2008-1765": {"epss_score": 0.39353, "epss_percentile": 0.97156}, "CVE-2008-1766": {"epss_score": 0.00323, "epss_percentile": 0.5488}, "CVE-2008-1767": {"epss_score": 0.2079, "epss_percentile": 0.95412}, "CVE-2008-1768": {"epss_score": 0.01879, "epss_percentile": 0.82672}, "CVE-2008-1769": {"epss_score": 0.26634, "epss_percentile": 0.96163}, "CVE-2008-1770": {"epss_score": 0.13501, "epss_percentile": 0.93981}, "CVE-2008-1771": {"epss_score": 0.0401, "epss_percentile": 0.88109}, "CVE-2008-1772": {"epss_score": 0.05073, "epss_percentile": 0.89466}, "CVE-2008-1773": {"epss_score": 0.18115, "epss_percentile": 0.94959}, "CVE-2008-1774": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1775": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2008-1776": {"epss_score": 0.18115, "epss_percentile": 0.94959}, "CVE-2008-1777": {"epss_score": 0.01169, "epss_percentile": 0.78197}, "CVE-2008-1778": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2008-1779": {"epss_score": 0.01221, "epss_percentile": 0.78646}, "CVE-2008-1780": {"epss_score": 0.00056, "epss_percentile": 0.17863}, "CVE-2008-1782": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2008-1783": {"epss_score": 0.05354, "epss_percentile": 0.89778}, "CVE-2008-1784": {"epss_score": 0.05189, "epss_percentile": 0.89593}, "CVE-2008-1785": {"epss_score": 0.03779, "epss_percentile": 0.87718}, "CVE-2008-1786": {"epss_score": 0.36719, "epss_percentile": 0.96998}, "CVE-2008-1787": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-1788": {"epss_score": 0.00424, "epss_percentile": 0.61664}, "CVE-2008-1789": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1790": {"epss_score": 0.00744, "epss_percentile": 0.72506}, "CVE-2008-1791": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1792": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2008-1793": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1794": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2008-1795": {"epss_score": 0.10913, "epss_percentile": 0.93155}, "CVE-2008-1796": {"epss_score": 0.00047, "epss_percentile": 0.14707}, "CVE-2008-1797": {"epss_score": 0.00625, "epss_percentile": 0.69585}, "CVE-2008-1798": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-1799": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-1800": {"epss_score": 0.00244, "epss_percentile": 0.4758}, "CVE-2008-1801": {"epss_score": 0.43218, "epss_percentile": 0.97376}, "CVE-2008-1802": {"epss_score": 0.35046, "epss_percentile": 0.96885}, "CVE-2008-1803": {"epss_score": 0.16371, "epss_percentile": 0.94637}, "CVE-2008-1804": {"epss_score": 0.0023, "epss_percentile": 0.45675}, "CVE-2008-1805": {"epss_score": 0.02025, "epss_percentile": 0.83313}, "CVE-2008-1806": {"epss_score": 0.03824, "epss_percentile": 0.87789}, "CVE-2008-1807": {"epss_score": 0.05336, "epss_percentile": 0.89743}, "CVE-2008-1808": {"epss_score": 0.0261, "epss_percentile": 0.85234}, "CVE-2008-1809": {"epss_score": 0.33298, "epss_percentile": 0.96761}, "CVE-2008-1810": {"epss_score": 0.00069, "epss_percentile": 0.21592}, "CVE-2008-1811": {"epss_score": 0.00771, "epss_percentile": 0.73014}, "CVE-2008-1812": {"epss_score": 0.00927, "epss_percentile": 0.75571}, "CVE-2008-1813": {"epss_score": 0.00511, "epss_percentile": 0.6583}, "CVE-2008-1814": {"epss_score": 0.01216, "epss_percentile": 0.78595}, "CVE-2008-1815": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2008-1816": {"epss_score": 0.00569, "epss_percentile": 0.67916}, "CVE-2008-1817": {"epss_score": 0.00805, "epss_percentile": 0.7363}, "CVE-2008-1818": {"epss_score": 0.01458, "epss_percentile": 0.80405}, "CVE-2008-1819": {"epss_score": 0.00237, "epss_percentile": 0.46464}, "CVE-2008-1820": {"epss_score": 0.01249, "epss_percentile": 0.78874}, "CVE-2008-1821": {"epss_score": 0.03562, "epss_percentile": 0.87356}, "CVE-2008-1822": {"epss_score": 0.00927, "epss_percentile": 0.75571}, "CVE-2008-1823": {"epss_score": 0.00927, "epss_percentile": 0.75571}, "CVE-2008-1824": {"epss_score": 0.01231, "epss_percentile": 0.78734}, "CVE-2008-1825": {"epss_score": 0.00927, "epss_percentile": 0.75571}, "CVE-2008-1826": {"epss_score": 0.01138, "epss_percentile": 0.77929}, "CVE-2008-1827": {"epss_score": 0.0278, "epss_percentile": 0.85646}, "CVE-2008-1828": {"epss_score": 0.02836, "epss_percentile": 0.8579}, "CVE-2008-1829": {"epss_score": 0.01233, "epss_percentile": 0.78748}, "CVE-2008-1830": {"epss_score": 0.0124, "epss_percentile": 0.78802}, "CVE-2008-1831": {"epss_score": 0.01138, "epss_percentile": 0.77929}, "CVE-2008-1832": {"epss_score": 0.00033, "epss_percentile": 0.09206}, "CVE-2008-1833": {"epss_score": 0.07746, "epss_percentile": 0.91656}, "CVE-2008-1834": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2008-1835": {"epss_score": 0.01807, "epss_percentile": 0.82352}, "CVE-2008-1836": {"epss_score": 0.04711, "epss_percentile": 0.89038}, "CVE-2008-1837": {"epss_score": 0.09303, "epss_percentile": 0.92491}, "CVE-2008-1838": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1839": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1840": {"epss_score": 0.00515, "epss_percentile": 0.66008}, "CVE-2008-1841": {"epss_score": 0.00566, "epss_percentile": 0.67831}, "CVE-2008-1842": {"epss_score": 0.34108, "epss_percentile": 0.96826}, "CVE-2008-1843": {"epss_score": 0.00934, "epss_percentile": 0.7566}, "CVE-2008-1844": {"epss_score": 0.00934, "epss_percentile": 0.7566}, "CVE-2008-1845": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2008-1846": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2008-1847": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1848": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-1849": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-1850": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-1851": {"epss_score": 0.02473, "epss_percentile": 0.84851}, "CVE-2008-1852": {"epss_score": 0.03354, "epss_percentile": 0.86969}, "CVE-2008-1853": {"epss_score": 0.01033, "epss_percentile": 0.76876}, "CVE-2008-1854": {"epss_score": 0.02917, "epss_percentile": 0.85983}, "CVE-2008-1855": {"epss_score": 0.23262, "epss_percentile": 0.95758}, "CVE-2008-1856": {"epss_score": 0.04024, "epss_percentile": 0.88138}, "CVE-2008-1857": {"epss_score": 0.0402, "epss_percentile": 0.8813}, "CVE-2008-1858": {"epss_score": 0.00498, "epss_percentile": 0.65226}, "CVE-2008-1859": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-1860": {"epss_score": 0.05484, "epss_percentile": 0.89922}, "CVE-2008-1861": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2008-1862": {"epss_score": 0.0112, "epss_percentile": 0.77765}, "CVE-2008-1863": {"epss_score": 0.00333, "epss_percentile": 0.55655}, "CVE-2008-1864": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1865": {"epss_score": 0.00064, "epss_percentile": 0.202}, "CVE-2008-1866": {"epss_score": 0.15112, "epss_percentile": 0.94366}, "CVE-2008-1867": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1868": {"epss_score": 0.04658, "epss_percentile": 0.88976}, "CVE-2008-1869": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-1870": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-1871": {"epss_score": 0.0042, "epss_percentile": 0.61422}, "CVE-2008-1872": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1873": {"epss_score": 0.00334, "epss_percentile": 0.55724}, "CVE-2008-1874": {"epss_score": 0.00412, "epss_percentile": 0.60955}, "CVE-2008-1875": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1876": {"epss_score": 0.23625, "epss_percentile": 0.95796}, "CVE-2008-1877": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2008-1878": {"epss_score": 0.07928, "epss_percentile": 0.91767}, "CVE-2008-1880": {"epss_score": 0.00203, "epss_percentile": 0.42556}, "CVE-2008-1881": {"epss_score": 0.53989, "epss_percentile": 0.97906}, "CVE-2008-1883": {"epss_score": 0.00611, "epss_percentile": 0.69201}, "CVE-2008-1884": {"epss_score": 0.00175, "epss_percentile": 0.39316}, "CVE-2008-1885": {"epss_score": 0.09338, "epss_percentile": 0.92505}, "CVE-2008-1886": {"epss_score": 0.0338, "epss_percentile": 0.8703}, "CVE-2008-1887": {"epss_score": 0.02752, "epss_percentile": 0.85584}, "CVE-2008-1888": {"epss_score": 0.24964, "epss_percentile": 0.95972}, "CVE-2008-1889": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-1890": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-1891": {"epss_score": 0.0029, "epss_percentile": 0.52131}, "CVE-2008-1892": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1893": {"epss_score": 0.01076, "epss_percentile": 0.77323}, "CVE-2008-1894": {"epss_score": 0.00529, "epss_percentile": 0.66586}, "CVE-2008-1895": {"epss_score": 0.00995, "epss_percentile": 0.76439}, "CVE-2008-1896": {"epss_score": 0.06697, "epss_percentile": 0.90954}, "CVE-2008-1897": {"epss_score": 0.03049, "epss_percentile": 0.86288}, "CVE-2008-1898": {"epss_score": 0.7946, "epss_percentile": 0.99039}, "CVE-2008-1900": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2008-1901": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-1902": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2008-1903": {"epss_score": 0.72364, "epss_percentile": 0.98706}, "CVE-2008-1904": {"epss_score": 0.04072, "epss_percentile": 0.88206}, "CVE-2008-1905": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2008-1906": {"epss_score": 0.05794, "epss_percentile": 0.90215}, "CVE-2008-1907": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-1908": {"epss_score": 0.07052, "epss_percentile": 0.91214}, "CVE-2008-1909": {"epss_score": 0.00583, "epss_percentile": 0.68326}, "CVE-2008-1910": {"epss_score": 0.25436, "epss_percentile": 0.96027}, "CVE-2008-1911": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-1912": {"epss_score": 0.24389, "epss_percentile": 0.95917}, "CVE-2008-1913": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-1914": {"epss_score": 0.87013, "epss_percentile": 0.99408}, "CVE-2008-1915": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-1916": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1917": {"epss_score": 0.00274, "epss_percentile": 0.50511}, "CVE-2008-1918": {"epss_score": 0.02193, "epss_percentile": 0.83945}, "CVE-2008-1919": {"epss_score": 0.00403, "epss_percentile": 0.60382}, "CVE-2008-1920": {"epss_score": 0.18477, "epss_percentile": 0.95021}, "CVE-2008-1921": {"epss_score": 0.01028, "epss_percentile": 0.76817}, "CVE-2008-1922": {"epss_score": 0.0147, "epss_percentile": 0.80497}, "CVE-2008-1923": {"epss_score": 0.01525, "epss_percentile": 0.80859}, "CVE-2008-1924": {"epss_score": 0.00175, "epss_percentile": 0.39315}, "CVE-2008-1925": {"epss_score": 0.01401, "epss_percentile": 0.80008}, "CVE-2008-1926": {"epss_score": 0.01774, "epss_percentile": 0.8221}, "CVE-2008-1927": {"epss_score": 0.02828, "epss_percentile": 0.85768}, "CVE-2008-1928": {"epss_score": 0.00674, "epss_percentile": 0.70878}, "CVE-2008-1930": {"epss_score": 0.07705, "epss_percentile": 0.91636}, "CVE-2008-1931": {"epss_score": 0.00043, "epss_percentile": 0.13209}, "CVE-2008-1932": {"epss_score": 0.00047, "epss_percentile": 0.14598}, "CVE-2008-1933": {"epss_score": 0.14482, "epss_percentile": 0.9422}, "CVE-2008-1934": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-1935": {"epss_score": 0.00023, "epss_percentile": 0.05479}, "CVE-2008-1936": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-1937": {"epss_score": 0.00897, "epss_percentile": 0.75133}, "CVE-2008-1938": {"epss_score": 0.00504, "epss_percentile": 0.65527}, "CVE-2008-1939": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1940": {"epss_score": 0.00069, "epss_percentile": 0.21501}, "CVE-2008-1941": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2008-1942": {"epss_score": 0.02765, "epss_percentile": 0.85609}, "CVE-2008-1943": {"epss_score": 0.00137, "epss_percentile": 0.34273}, "CVE-2008-1944": {"epss_score": 0.00075, "epss_percentile": 0.22991}, "CVE-2008-1945": {"epss_score": 0.0009, "epss_percentile": 0.2604}, "CVE-2008-1946": {"epss_score": 0.00069, "epss_percentile": 0.21501}, "CVE-2008-1947": {"epss_score": 0.59297, "epss_percentile": 0.98159}, "CVE-2008-1948": {"epss_score": 0.22274, "epss_percentile": 0.95618}, "CVE-2008-1949": {"epss_score": 0.15166, "epss_percentile": 0.94378}, "CVE-2008-1950": {"epss_score": 0.09427, "epss_percentile": 0.92542}, "CVE-2008-1951": {"epss_score": 0.00123, "epss_percentile": 0.32236}, "CVE-2008-1952": {"epss_score": 0.00077, "epss_percentile": 0.23361}, "CVE-2008-1953": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-1954": {"epss_score": 0.00716, "epss_percentile": 0.71861}, "CVE-2008-1955": {"epss_score": 0.00255, "epss_percentile": 0.48693}, "CVE-2008-1956": {"epss_score": 0.00346, "epss_percentile": 0.56605}, "CVE-2008-1957": {"epss_score": 0.00716, "epss_percentile": 0.71861}, "CVE-2008-1958": {"epss_score": 0.09413, "epss_percentile": 0.92537}, "CVE-2008-1959": {"epss_score": 0.03078, "epss_percentile": 0.86366}, "CVE-2008-1960": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-1961": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-1962": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-1963": {"epss_score": 0.27889, "epss_percentile": 0.96291}, "CVE-2008-1964": {"epss_score": 0.01412, "epss_percentile": 0.80113}, "CVE-2008-1965": {"epss_score": 0.4398, "epss_percentile": 0.97413}, "CVE-2008-1966": {"epss_score": 0.01605, "epss_percentile": 0.81286}, "CVE-2008-1967": {"epss_score": 0.00514, "epss_percentile": 0.65962}, "CVE-2008-1968": {"epss_score": 0.00514, "epss_percentile": 0.65957}, "CVE-2008-1969": {"epss_score": 0.00539, "epss_percentile": 0.6698}, "CVE-2008-1970": {"epss_score": 0.00052, "epss_percentile": 0.16392}, "CVE-2008-1971": {"epss_score": 0.04724, "epss_percentile": 0.8906}, "CVE-2008-1972": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-1973": {"epss_score": 0.25865, "epss_percentile": 0.96086}, "CVE-2008-1974": {"epss_score": 0.02152, "epss_percentile": 0.8379}, "CVE-2008-1975": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-1976": {"epss_score": 0.00518, "epss_percentile": 0.66138}, "CVE-2008-1977": {"epss_score": 0.00216, "epss_percentile": 0.44217}, "CVE-2008-1978": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2008-1979": {"epss_score": 0.18322, "epss_percentile": 0.94994}, "CVE-2008-1980": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-1981": {"epss_score": 0.00301, "epss_percentile": 0.53019}, "CVE-2008-1982": {"epss_score": 0.00713, "epss_percentile": 0.71801}, "CVE-2008-1983": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-1984": {"epss_score": 0.02249, "epss_percentile": 0.84142}, "CVE-2008-1985": {"epss_score": 0.00234, "epss_percentile": 0.46082}, "CVE-2008-1986": {"epss_score": 0.00255, "epss_percentile": 0.48693}, "CVE-2008-1987": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-1988": {"epss_score": 0.00395, "epss_percentile": 0.59813}, "CVE-2008-1989": {"epss_score": 0.03309, "epss_percentile": 0.86884}, "CVE-2008-1990": {"epss_score": 0.00995, "epss_percentile": 0.76439}, "CVE-2008-1991": {"epss_score": 0.07148, "epss_percentile": 0.91284}, "CVE-2008-1992": {"epss_score": 0.04258, "epss_percentile": 0.8846}, "CVE-2008-1993": {"epss_score": 0.08034, "epss_percentile": 0.91845}, "CVE-2008-1994": {"epss_score": 0.00052, "epss_percentile": 0.16371}, "CVE-2008-1995": {"epss_score": 0.00391, "epss_percentile": 0.59584}, "CVE-2008-1996": {"epss_score": 0.20307, "epss_percentile": 0.9532}, "CVE-2008-1997": {"epss_score": 0.02883, "epss_percentile": 0.85905}, "CVE-2008-1998": {"epss_score": 0.01931, "epss_percentile": 0.82941}, "CVE-2008-1999": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2008-20001": {"epss_score": 0.63848, "epss_percentile": 0.98353}, "CVE-2008-2000": {"epss_score": 0.00694, "epss_percentile": 0.71352}, "CVE-2008-2001": {"epss_score": 0.00844, "epss_percentile": 0.74279}, "CVE-2008-2002": {"epss_score": 0.00324, "epss_percentile": 0.54934}, "CVE-2008-2003": {"epss_score": 0.01499, "epss_percentile": 0.80708}, "CVE-2008-2004": {"epss_score": 0.00093, "epss_percentile": 0.2663}, "CVE-2008-2005": {"epss_score": 0.52338, "epss_percentile": 0.9782}, "CVE-2008-2006": {"epss_score": 0.19567, "epss_percentile": 0.9521}, "CVE-2008-2008": {"epss_score": 0.03086, "epss_percentile": 0.86384}, "CVE-2008-2009": {"epss_score": 0.0434, "epss_percentile": 0.88568}, "CVE-2008-2010": {"epss_score": 0.02104, "epss_percentile": 0.83619}, "CVE-2008-2011": {"epss_score": 0.00549, "epss_percentile": 0.67321}, "CVE-2008-2012": {"epss_score": 0.00602, "epss_percentile": 0.68866}, "CVE-2008-2013": {"epss_score": 0.00602, "epss_percentile": 0.68866}, "CVE-2008-2014": {"epss_score": 0.01238, "epss_percentile": 0.78788}, "CVE-2008-2015": {"epss_score": 0.04073, "epss_percentile": 0.88207}, "CVE-2008-2016": {"epss_score": 0.00368, "epss_percentile": 0.58167}, "CVE-2008-2017": {"epss_score": 0.00152, "epss_percentile": 0.36452}, "CVE-2008-2018": {"epss_score": 0.04377, "epss_percentile": 0.88618}, "CVE-2008-2019": {"epss_score": 0.04592, "epss_percentile": 0.88893}, "CVE-2008-2020": {"epss_score": 0.00519, "epss_percentile": 0.66153}, "CVE-2008-2021": {"epss_score": 0.04666, "epss_percentile": 0.8898}, "CVE-2008-2022": {"epss_score": 0.03039, "epss_percentile": 0.8627}, "CVE-2008-2023": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2024": {"epss_score": 0.03821, "epss_percentile": 0.87783}, "CVE-2008-2025": {"epss_score": 0.0322, "epss_percentile": 0.86673}, "CVE-2008-2026": {"epss_score": 0.00247, "epss_percentile": 0.47876}, "CVE-2008-2027": {"epss_score": 0.00362, "epss_percentile": 0.57772}, "CVE-2008-2028": {"epss_score": 0.05896, "epss_percentile": 0.90303}, "CVE-2008-2029": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2030": {"epss_score": 0.00391, "epss_percentile": 0.59633}, "CVE-2008-2031": {"epss_score": 0.53859, "epss_percentile": 0.979}, "CVE-2008-2032": {"epss_score": 0.05739, "epss_percentile": 0.90167}, "CVE-2008-2034": {"epss_score": 0.00446, "epss_percentile": 0.62932}, "CVE-2008-2035": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2036": {"epss_score": 0.00995, "epss_percentile": 0.76439}, "CVE-2008-2037": {"epss_score": 0.00234, "epss_percentile": 0.46149}, "CVE-2008-2038": {"epss_score": 0.00324, "epss_percentile": 0.54928}, "CVE-2008-2040": {"epss_score": 0.3325, "epss_percentile": 0.96756}, "CVE-2008-2041": {"epss_score": 0.00526, "epss_percentile": 0.664}, "CVE-2008-2042": {"epss_score": 0.04475, "epss_percentile": 0.88739}, "CVE-2008-2043": {"epss_score": 0.00468, "epss_percentile": 0.63894}, "CVE-2008-2044": {"epss_score": 0.12105, "epss_percentile": 0.93568}, "CVE-2008-2045": {"epss_score": 0.11625, "epss_percentile": 0.93423}, "CVE-2008-2046": {"epss_score": 0.00255, "epss_percentile": 0.48693}, "CVE-2008-2047": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-2048": {"epss_score": 0.03183, "epss_percentile": 0.86587}, "CVE-2008-2049": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2008-2050": {"epss_score": 0.06654, "epss_percentile": 0.90918}, "CVE-2008-2051": {"epss_score": 0.06485, "epss_percentile": 0.9079}, "CVE-2008-2052": {"epss_score": 0.01021, "epss_percentile": 0.76754}, "CVE-2008-2053": {"epss_score": 0.01061, "epss_percentile": 0.77175}, "CVE-2008-2054": {"epss_score": 0.04633, "epss_percentile": 0.88946}, "CVE-2008-2055": {"epss_score": 0.00608, "epss_percentile": 0.69076}, "CVE-2008-2056": {"epss_score": 0.01918, "epss_percentile": 0.8288}, "CVE-2008-2057": {"epss_score": 0.01581, "epss_percentile": 0.81135}, "CVE-2008-2058": {"epss_score": 0.00801, "epss_percentile": 0.73578}, "CVE-2008-2059": {"epss_score": 0.00201, "epss_percentile": 0.42331}, "CVE-2008-2060": {"epss_score": 0.00675, "epss_percentile": 0.70884}, "CVE-2008-2061": {"epss_score": 0.03307, "epss_percentile": 0.86879}, "CVE-2008-2062": {"epss_score": 0.00638, "epss_percentile": 0.69902}, "CVE-2008-2063": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2064": {"epss_score": 0.01098, "epss_percentile": 0.77544}, "CVE-2008-2065": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2066": {"epss_score": 0.00632, "epss_percentile": 0.69753}, "CVE-2008-2067": {"epss_score": 0.0108, "epss_percentile": 0.77361}, "CVE-2008-2068": {"epss_score": 0.00673, "epss_percentile": 0.70829}, "CVE-2008-2069": {"epss_score": 0.19258, "epss_percentile": 0.95156}, "CVE-2008-2070": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2008-2071": {"epss_score": 0.0018, "epss_percentile": 0.39979}, "CVE-2008-2072": {"epss_score": 0.06697, "epss_percentile": 0.90954}, "CVE-2008-2073": {"epss_score": 0.07032, "epss_percentile": 0.912}, "CVE-2008-2074": {"epss_score": 0.0373, "epss_percentile": 0.87642}, "CVE-2008-2075": {"epss_score": 0.00619, "epss_percentile": 0.69389}, "CVE-2008-2076": {"epss_score": 0.02934, "epss_percentile": 0.86022}, "CVE-2008-2077": {"epss_score": 0.00416, "epss_percentile": 0.61172}, "CVE-2008-2078": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2008-2079": {"epss_score": 0.00564, "epss_percentile": 0.67748}, "CVE-2008-2080": {"epss_score": 0.01207, "epss_percentile": 0.78525}, "CVE-2008-2081": {"epss_score": 0.03291, "epss_percentile": 0.86837}, "CVE-2008-2082": {"epss_score": 0.03173, "epss_percentile": 0.86553}, "CVE-2008-2083": {"epss_score": 0.00995, "epss_percentile": 0.76439}, "CVE-2008-2084": {"epss_score": 0.00284, "epss_percentile": 0.51439}, "CVE-2008-2085": {"epss_score": 0.03745, "epss_percentile": 0.87662}, "CVE-2008-2086": {"epss_score": 0.34564, "epss_percentile": 0.96856}, "CVE-2008-2087": {"epss_score": 0.00851, "epss_percentile": 0.74409}, "CVE-2008-2088": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2089": {"epss_score": 0.01313, "epss_percentile": 0.7938}, "CVE-2008-2090": {"epss_score": 0.01313, "epss_percentile": 0.7938}, "CVE-2008-2091": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2092": {"epss_score": 0.0894, "epss_percentile": 0.92329}, "CVE-2008-2093": {"epss_score": 0.00015, "epss_percentile": 0.02248}, "CVE-2008-2094": {"epss_score": 0.00304, "epss_percentile": 0.53262}, "CVE-2008-2095": {"epss_score": 0.00023, "epss_percentile": 0.05608}, "CVE-2008-2096": {"epss_score": 0.00633, "epss_percentile": 0.69768}, "CVE-2008-2097": {"epss_score": 0.0423, "epss_percentile": 0.88422}, "CVE-2008-2098": {"epss_score": 0.00099, "epss_percentile": 0.28349}, "CVE-2008-2099": {"epss_score": 0.00069, "epss_percentile": 0.21485}, "CVE-2008-2100": {"epss_score": 0.00153, "epss_percentile": 0.36517}, "CVE-2008-2101": {"epss_score": 0.00061, "epss_percentile": 0.19524}, "CVE-2008-2103": {"epss_score": 0.00619, "epss_percentile": 0.69389}, "CVE-2008-2104": {"epss_score": 0.00286, "epss_percentile": 0.51756}, "CVE-2008-2105": {"epss_score": 0.00497, "epss_percentile": 0.6521}, "CVE-2008-2106": {"epss_score": 0.1319, "epss_percentile": 0.93896}, "CVE-2008-2107": {"epss_score": 0.03088, "epss_percentile": 0.86391}, "CVE-2008-2108": {"epss_score": 0.05607, "epss_percentile": 0.90044}, "CVE-2008-2109": {"epss_score": 0.0632, "epss_percentile": 0.90669}, "CVE-2008-2110": {"epss_score": 0.03011, "epss_percentile": 0.86198}, "CVE-2008-2111": {"epss_score": 0.15765, "epss_percentile": 0.94506}, "CVE-2008-2112": {"epss_score": 0.00994, "epss_percentile": 0.76424}, "CVE-2008-2113": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2114": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2115": {"epss_score": 0.03288, "epss_percentile": 0.86831}, "CVE-2008-2116": {"epss_score": 0.00662, "epss_percentile": 0.70598}, "CVE-2008-2117": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-2118": {"epss_score": 0.00301, "epss_percentile": 0.53079}, "CVE-2008-2119": {"epss_score": 0.12474, "epss_percentile": 0.93684}, "CVE-2008-2120": {"epss_score": 0.00638, "epss_percentile": 0.69927}, "CVE-2008-2121": {"epss_score": 0.02977, "epss_percentile": 0.8611}, "CVE-2008-2122": {"epss_score": 0.04726, "epss_percentile": 0.89063}, "CVE-2008-2123": {"epss_score": 0.16456, "epss_percentile": 0.94665}, "CVE-2008-2124": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2125": {"epss_score": 0.00583, "epss_percentile": 0.68326}, "CVE-2008-2126": {"epss_score": 0.00346, "epss_percentile": 0.56605}, "CVE-2008-2127": {"epss_score": 0.0364, "epss_percentile": 0.87488}, "CVE-2008-2128": {"epss_score": 0.03259, "epss_percentile": 0.86768}, "CVE-2008-2129": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2130": {"epss_score": 0.00266, "epss_percentile": 0.49863}, "CVE-2008-2131": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-2132": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2133": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2134": {"epss_score": 0.00631, "epss_percentile": 0.69729}, "CVE-2008-2135": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-2136": {"epss_score": 0.23487, "epss_percentile": 0.95785}, "CVE-2008-2137": {"epss_score": 0.00088, "epss_percentile": 0.25732}, "CVE-2008-2138": {"epss_score": 0.42376, "epss_percentile": 0.97329}, "CVE-2008-2139": {"epss_score": 0.00097, "epss_percentile": 0.2763}, "CVE-2008-2140": {"epss_score": 0.00114, "epss_percentile": 0.30789}, "CVE-2008-2142": {"epss_score": 0.04364, "epss_percentile": 0.886}, "CVE-2008-2143": {"epss_score": 0.00465, "epss_percentile": 0.6377}, "CVE-2008-2144": {"epss_score": 0.20508, "epss_percentile": 0.95358}, "CVE-2008-2145": {"epss_score": 0.00052, "epss_percentile": 0.16391}, "CVE-2008-2146": {"epss_score": 0.00583, "epss_percentile": 0.68341}, "CVE-2008-2147": {"epss_score": 0.00079, "epss_percentile": 0.23814}, "CVE-2008-2148": {"epss_score": 0.00065, "epss_percentile": 0.20512}, "CVE-2008-2149": {"epss_score": 0.0146, "epss_percentile": 0.80421}, "CVE-2008-2152": {"epss_score": 0.0304, "epss_percentile": 0.86273}, "CVE-2008-2154": {"epss_score": 0.00947, "epss_percentile": 0.7582}, "CVE-2008-2157": {"epss_score": 0.84999, "epss_percentile": 0.99312}, "CVE-2008-2158": {"epss_score": 0.41437, "epss_percentile": 0.97274}, "CVE-2008-2159": {"epss_score": 0.00835, "epss_percentile": 0.74126}, "CVE-2008-2160": {"epss_score": 0.4377, "epss_percentile": 0.97402}, "CVE-2008-2161": {"epss_score": 0.78902, "epss_percentile": 0.9901}, "CVE-2008-2162": {"epss_score": 0.0022, "epss_percentile": 0.44622}, "CVE-2008-2163": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2008-2165": {"epss_score": 0.00523, "epss_percentile": 0.66292}, "CVE-2008-2166": {"epss_score": 0.00529, "epss_percentile": 0.66586}, "CVE-2008-2167": {"epss_score": 0.04989, "epss_percentile": 0.89366}, "CVE-2008-2168": {"epss_score": 0.50386, "epss_percentile": 0.97734}, "CVE-2008-2169": {"epss_score": 0.01347, "epss_percentile": 0.79648}, "CVE-2008-2170": {"epss_score": 0.01347, "epss_percentile": 0.79648}, "CVE-2008-2171": {"epss_score": 0.03727, "epss_percentile": 0.87634}, "CVE-2008-2172": {"epss_score": 0.03727, "epss_percentile": 0.87634}, "CVE-2008-2173": {"epss_score": 0.01347, "epss_percentile": 0.79648}, "CVE-2008-2174": {"epss_score": 0.00416, "epss_percentile": 0.61166}, "CVE-2008-2175": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2176": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2177": {"epss_score": 0.00897, "epss_percentile": 0.75127}, "CVE-2008-2178": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2008-2179": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-2180": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-2181": {"epss_score": 0.03701, "epss_percentile": 0.8759}, "CVE-2008-2182": {"epss_score": 0.004, "epss_percentile": 0.6016}, "CVE-2008-2183": {"epss_score": 0.00589, "epss_percentile": 0.68536}, "CVE-2008-2184": {"epss_score": 0.00265, "epss_percentile": 0.4982}, "CVE-2008-2185": {"epss_score": 0.01894, "epss_percentile": 0.82744}, "CVE-2008-2186": {"epss_score": 0.08609, "epss_percentile": 0.92149}, "CVE-2008-2187": {"epss_score": 0.00534, "epss_percentile": 0.66794}, "CVE-2008-2188": {"epss_score": 0.00265, "epss_percentile": 0.4981}, "CVE-2008-2189": {"epss_score": 0.01169, "epss_percentile": 0.78202}, "CVE-2008-2190": {"epss_score": 0.01724, "epss_percentile": 0.8195}, "CVE-2008-2191": {"epss_score": 0.0053, "epss_percentile": 0.6662}, "CVE-2008-2192": {"epss_score": 0.05484, "epss_percentile": 0.89922}, "CVE-2008-2193": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2008-2194": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2195": {"epss_score": 0.03027, "epss_percentile": 0.86242}, "CVE-2008-2196": {"epss_score": 0.00334, "epss_percentile": 0.55724}, "CVE-2008-2197": {"epss_score": 0.00583, "epss_percentile": 0.68326}, "CVE-2008-2198": {"epss_score": 0.07125, "epss_percentile": 0.91266}, "CVE-2008-2199": {"epss_score": 0.1115, "epss_percentile": 0.9324}, "CVE-2008-2200": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2201": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2202": {"epss_score": 0.00394, "epss_percentile": 0.59774}, "CVE-2008-2203": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-2204": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-2205": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-2206": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2207": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2208": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-2209": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2210": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2211": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2212": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-2213": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2214": {"epss_score": 0.22786, "epss_percentile": 0.95686}, "CVE-2008-2215": {"epss_score": 0.04435, "epss_percentile": 0.88685}, "CVE-2008-2216": {"epss_score": 0.04398, "epss_percentile": 0.88644}, "CVE-2008-2217": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2218": {"epss_score": 0.01297, "epss_percentile": 0.79269}, "CVE-2008-2219": {"epss_score": 0.00255, "epss_percentile": 0.48693}, "CVE-2008-2220": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2008-2221": {"epss_score": 0.01015, "epss_percentile": 0.76659}, "CVE-2008-2222": {"epss_score": 0.0036, "epss_percentile": 0.57636}, "CVE-2008-2223": {"epss_score": 0.00787, "epss_percentile": 0.73314}, "CVE-2008-2224": {"epss_score": 0.0373, "epss_percentile": 0.87642}, "CVE-2008-2225": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2226": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-2227": {"epss_score": 0.01926, "epss_percentile": 0.82926}, "CVE-2008-2228": {"epss_score": 0.03309, "epss_percentile": 0.86884}, "CVE-2008-2230": {"epss_score": 0.00238, "epss_percentile": 0.46817}, "CVE-2008-2231": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2008-2232": {"epss_score": 0.00065, "epss_percentile": 0.2064}, "CVE-2008-2233": {"epss_score": 0.00398, "epss_percentile": 0.60087}, "CVE-2008-2234": {"epss_score": 0.07576, "epss_percentile": 0.91548}, "CVE-2008-2235": {"epss_score": 0.00068, "epss_percentile": 0.21204}, "CVE-2008-2236": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-2237": {"epss_score": 0.08775, "epss_percentile": 0.92249}, "CVE-2008-2238": {"epss_score": 0.08775, "epss_percentile": 0.92249}, "CVE-2008-2240": {"epss_score": 0.84201, "epss_percentile": 0.99279}, "CVE-2008-2241": {"epss_score": 0.06947, "epss_percentile": 0.91134}, "CVE-2008-2242": {"epss_score": 0.12097, "epss_percentile": 0.93565}, "CVE-2008-2244": {"epss_score": 0.59834, "epss_percentile": 0.98183}, "CVE-2008-2245": {"epss_score": 0.83119, "epss_percentile": 0.99232}, "CVE-2008-2246": {"epss_score": 0.53579, "epss_percentile": 0.97883}, "CVE-2008-2247": {"epss_score": 0.23229, "epss_percentile": 0.95754}, "CVE-2008-2248": {"epss_score": 0.24335, "epss_percentile": 0.95906}, "CVE-2008-2249": {"epss_score": 0.68721, "epss_percentile": 0.98559}, "CVE-2008-2250": {"epss_score": 0.01397, "epss_percentile": 0.79986}, "CVE-2008-2251": {"epss_score": 0.00781, "epss_percentile": 0.73186}, "CVE-2008-2252": {"epss_score": 0.01054, "epss_percentile": 0.77107}, "CVE-2008-2253": {"epss_score": 0.49733, "epss_percentile": 0.97703}, "CVE-2008-2254": {"epss_score": 0.55715, "epss_percentile": 0.97991}, "CVE-2008-2255": {"epss_score": 0.57631, "epss_percentile": 0.98075}, "CVE-2008-2256": {"epss_score": 0.55715, "epss_percentile": 0.97991}, "CVE-2008-2257": {"epss_score": 0.62995, "epss_percentile": 0.98316}, "CVE-2008-2258": {"epss_score": 0.61431, "epss_percentile": 0.98248}, "CVE-2008-2259": {"epss_score": 0.54114, "epss_percentile": 0.97912}, "CVE-2008-2263": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2264": {"epss_score": 0.00325, "epss_percentile": 0.55006}, "CVE-2008-2265": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2266": {"epss_score": 0.00048, "epss_percentile": 0.14933}, "CVE-2008-2267": {"epss_score": 0.1022, "epss_percentile": 0.929}, "CVE-2008-2268": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2269": {"epss_score": 0.02365, "epss_percentile": 0.84512}, "CVE-2008-2270": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2008-2271": {"epss_score": 0.00753, "epss_percentile": 0.72671}, "CVE-2008-2272": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-2273": {"epss_score": 0.01781, "epss_percentile": 0.8224}, "CVE-2008-2274": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-2275": {"epss_score": 0.01851, "epss_percentile": 0.82538}, "CVE-2008-2276": {"epss_score": 0.01938, "epss_percentile": 0.82968}, "CVE-2008-2277": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2278": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2279": {"epss_score": 0.04567, "epss_percentile": 0.88859}, "CVE-2008-2280": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-2281": {"epss_score": 0.55918, "epss_percentile": 0.98003}, "CVE-2008-2282": {"epss_score": 0.03576, "epss_percentile": 0.8738}, "CVE-2008-2283": {"epss_score": 0.05681, "epss_percentile": 0.90117}, "CVE-2008-2284": {"epss_score": 0.00918, "epss_percentile": 0.75439}, "CVE-2008-2285": {"epss_score": 0.00356, "epss_percentile": 0.57346}, "CVE-2008-2286": {"epss_score": 0.39749, "epss_percentile": 0.97178}, "CVE-2008-2287": {"epss_score": 0.00067, "epss_percentile": 0.21011}, "CVE-2008-2288": {"epss_score": 0.00089, "epss_percentile": 0.25934}, "CVE-2008-2289": {"epss_score": 0.00067, "epss_percentile": 0.21011}, "CVE-2008-2290": {"epss_score": 0.00067, "epss_percentile": 0.21011}, "CVE-2008-2291": {"epss_score": 0.02166, "epss_percentile": 0.8385}, "CVE-2008-2292": {"epss_score": 0.20328, "epss_percentile": 0.95326}, "CVE-2008-2293": {"epss_score": 0.03576, "epss_percentile": 0.8738}, "CVE-2008-2294": {"epss_score": 0.06029, "epss_percentile": 0.90421}, "CVE-2008-2295": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2296": {"epss_score": 0.02843, "epss_percentile": 0.85812}, "CVE-2008-2297": {"epss_score": 0.02365, "epss_percentile": 0.84512}, "CVE-2008-2298": {"epss_score": 0.02326, "epss_percentile": 0.8439}, "CVE-2008-2299": {"epss_score": 0.0042, "epss_percentile": 0.61435}, "CVE-2008-2300": {"epss_score": 0.01075, "epss_percentile": 0.77314}, "CVE-2008-2301": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-2302": {"epss_score": 0.00441, "epss_percentile": 0.62654}, "CVE-2008-2303": {"epss_score": 0.19349, "epss_percentile": 0.95167}, "CVE-2008-2304": {"epss_score": 0.18481, "epss_percentile": 0.95022}, "CVE-2008-2305": {"epss_score": 0.0871, "epss_percentile": 0.92222}, "CVE-2008-2306": {"epss_score": 0.00461, "epss_percentile": 0.63564}, "CVE-2008-2307": {"epss_score": 0.10281, "epss_percentile": 0.92924}, "CVE-2008-2308": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2008-2309": {"epss_score": 0.02463, "epss_percentile": 0.84829}, "CVE-2008-2310": {"epss_score": 0.0086, "epss_percentile": 0.74544}, "CVE-2008-2311": {"epss_score": 0.02888, "epss_percentile": 0.85914}, "CVE-2008-2312": {"epss_score": 0.00073, "epss_percentile": 0.22638}, "CVE-2008-2313": {"epss_score": 0.00052, "epss_percentile": 0.16534}, "CVE-2008-2314": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2008-2315": {"epss_score": 0.00925, "epss_percentile": 0.75531}, "CVE-2008-2316": {"epss_score": 0.01692, "epss_percentile": 0.8179}, "CVE-2008-2317": {"epss_score": 0.14238, "epss_percentile": 0.94169}, "CVE-2008-2318": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-2320": {"epss_score": 0.04255, "epss_percentile": 0.88458}, "CVE-2008-2321": {"epss_score": 0.37257, "epss_percentile": 0.97031}, "CVE-2008-2322": {"epss_score": 0.09199, "epss_percentile": 0.92445}, "CVE-2008-2323": {"epss_score": 0.00956, "epss_percentile": 0.75924}, "CVE-2008-2324": {"epss_score": 0.00047, "epss_percentile": 0.14593}, "CVE-2008-2325": {"epss_score": 0.04829, "epss_percentile": 0.8919}, "CVE-2008-2326": {"epss_score": 0.06658, "epss_percentile": 0.90922}, "CVE-2008-2327": {"epss_score": 0.0137, "epss_percentile": 0.79802}, "CVE-2008-2329": {"epss_score": 0.00086, "epss_percentile": 0.25381}, "CVE-2008-2330": {"epss_score": 0.00073, "epss_percentile": 0.22638}, "CVE-2008-2331": {"epss_score": 0.00208, "epss_percentile": 0.43208}, "CVE-2008-2332": {"epss_score": 0.0477, "epss_percentile": 0.89126}, "CVE-2008-2333": {"epss_score": 0.008, "epss_percentile": 0.73549}, "CVE-2008-2334": {"epss_score": 0.00417, "epss_percentile": 0.61235}, "CVE-2008-2335": {"epss_score": 0.11402, "epss_percentile": 0.93335}, "CVE-2008-2336": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2337": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2338": {"epss_score": 0.05189, "epss_percentile": 0.89593}, "CVE-2008-2339": {"epss_score": 0.00348, "epss_percentile": 0.56813}, "CVE-2008-2340": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2341": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2008-2342": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-2343": {"epss_score": 0.02532, "epss_percentile": 0.85028}, "CVE-2008-2344": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-2345": {"epss_score": 0.00855, "epss_percentile": 0.74465}, "CVE-2008-2346": {"epss_score": 0.02259, "epss_percentile": 0.84184}, "CVE-2008-2347": {"epss_score": 0.02259, "epss_percentile": 0.84184}, "CVE-2008-2348": {"epss_score": 0.02259, "epss_percentile": 0.84184}, "CVE-2008-2349": {"epss_score": 0.05105, "epss_percentile": 0.89505}, "CVE-2008-2350": {"epss_score": 0.04267, "epss_percentile": 0.88472}, "CVE-2008-2351": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2352": {"epss_score": 0.06819, "epss_percentile": 0.91047}, "CVE-2008-2353": {"epss_score": 0.0402, "epss_percentile": 0.8813}, "CVE-2008-2354": {"epss_score": 0.00335, "epss_percentile": 0.55814}, "CVE-2008-2355": {"epss_score": 0.0402, "epss_percentile": 0.8813}, "CVE-2008-2356": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2357": {"epss_score": 0.07562, "epss_percentile": 0.91542}, "CVE-2008-2358": {"epss_score": 0.00066, "epss_percentile": 0.20704}, "CVE-2008-2359": {"epss_score": 0.00149, "epss_percentile": 0.35938}, "CVE-2008-2360": {"epss_score": 0.0192, "epss_percentile": 0.82895}, "CVE-2008-2361": {"epss_score": 0.01482, "epss_percentile": 0.8058}, "CVE-2008-2362": {"epss_score": 0.02076, "epss_percentile": 0.83511}, "CVE-2008-2363": {"epss_score": 0.0587, "epss_percentile": 0.90279}, "CVE-2008-2364": {"epss_score": 0.02091, "epss_percentile": 0.83571}, "CVE-2008-2365": {"epss_score": 0.00705, "epss_percentile": 0.71585}, "CVE-2008-2366": {"epss_score": 0.00072, "epss_percentile": 0.22375}, "CVE-2008-2367": {"epss_score": 0.00034, "epss_percentile": 0.09471}, "CVE-2008-2368": {"epss_score": 0.00034, "epss_percentile": 0.09471}, "CVE-2008-2369": {"epss_score": 0.00616, "epss_percentile": 0.69336}, "CVE-2008-2370": {"epss_score": 0.88991, "epss_percentile": 0.99503}, "CVE-2008-2371": {"epss_score": 0.04128, "epss_percentile": 0.88292}, "CVE-2008-2372": {"epss_score": 0.00048, "epss_percentile": 0.14951}, "CVE-2008-2374": {"epss_score": 0.06445, "epss_percentile": 0.90761}, "CVE-2008-2375": {"epss_score": 0.03723, "epss_percentile": 0.87629}, "CVE-2008-2376": {"epss_score": 0.11359, "epss_percentile": 0.93323}, "CVE-2008-2377": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2008-2378": {"epss_score": 0.00053, "epss_percentile": 0.16817}, "CVE-2008-2379": {"epss_score": 0.01323, "epss_percentile": 0.79455}, "CVE-2008-2380": {"epss_score": 0.00605, "epss_percentile": 0.68995}, "CVE-2008-2381": {"epss_score": 0.0108, "epss_percentile": 0.77361}, "CVE-2008-2382": {"epss_score": 0.2088, "epss_percentile": 0.95432}, "CVE-2008-2383": {"epss_score": 0.01716, "epss_percentile": 0.81906}, "CVE-2008-2384": {"epss_score": 0.04987, "epss_percentile": 0.89365}, "CVE-2008-2388": {"epss_score": 0.00341, "epss_percentile": 0.56305}, "CVE-2008-2389": {"epss_score": 0.00029, "epss_percentile": 0.07835}, "CVE-2008-2390": {"epss_score": 0.05092, "epss_percentile": 0.89484}, "CVE-2008-2391": {"epss_score": 0.00315, "epss_percentile": 0.54182}, "CVE-2008-2392": {"epss_score": 0.01929, "epss_percentile": 0.82934}, "CVE-2008-2393": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2394": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-2395": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2396": {"epss_score": 0.03307, "epss_percentile": 0.86879}, "CVE-2008-2397": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-2398": {"epss_score": 0.00437, "epss_percentile": 0.62532}, "CVE-2008-2399": {"epss_score": 0.00483, "epss_percentile": 0.6457}, "CVE-2008-2400": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2008-2401": {"epss_score": 0.01572, "epss_percentile": 0.81098}, "CVE-2008-2402": {"epss_score": 0.0039, "epss_percentile": 0.59551}, "CVE-2008-2403": {"epss_score": 0.00995, "epss_percentile": 0.76439}, "CVE-2008-2404": {"epss_score": 0.12951, "epss_percentile": 0.93828}, "CVE-2008-2405": {"epss_score": 0.01414, "epss_percentile": 0.80127}, "CVE-2008-2406": {"epss_score": 0.00958, "epss_percentile": 0.75945}, "CVE-2008-2407": {"epss_score": 0.08947, "epss_percentile": 0.92333}, "CVE-2008-2408": {"epss_score": 0.09464, "epss_percentile": 0.9256}, "CVE-2008-2409": {"epss_score": 0.17024, "epss_percentile": 0.94761}, "CVE-2008-2410": {"epss_score": 0.00463, "epss_percentile": 0.63697}, "CVE-2008-2411": {"epss_score": 0.00897, "epss_percentile": 0.75127}, "CVE-2008-2412": {"epss_score": 0.00266, "epss_percentile": 0.49863}, "CVE-2008-2413": {"epss_score": 0.00255, "epss_percentile": 0.48693}, "CVE-2008-2414": {"epss_score": 0.00305, "epss_percentile": 0.53365}, "CVE-2008-2415": {"epss_score": 0.01723, "epss_percentile": 0.81947}, "CVE-2008-2416": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2417": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-2418": {"epss_score": 0.00044, "epss_percentile": 0.13483}, "CVE-2008-2419": {"epss_score": 0.05373, "epss_percentile": 0.89796}, "CVE-2008-2420": {"epss_score": 0.00488, "epss_percentile": 0.64829}, "CVE-2008-2421": {"epss_score": 0.07699, "epss_percentile": 0.91633}, "CVE-2008-2422": {"epss_score": 0.00254, "epss_percentile": 0.48553}, "CVE-2008-2423": {"epss_score": 0.03678, "epss_percentile": 0.87556}, "CVE-2008-2424": {"epss_score": 0.00402, "epss_percentile": 0.60292}, "CVE-2008-2425": {"epss_score": 0.00224, "epss_percentile": 0.44983}, "CVE-2008-2426": {"epss_score": 0.07262, "epss_percentile": 0.91357}, "CVE-2008-2427": {"epss_score": 0.30999, "epss_percentile": 0.9658}, "CVE-2008-2428": {"epss_score": 0.00661, "epss_percentile": 0.70572}, "CVE-2008-2429": {"epss_score": 0.00318, "epss_percentile": 0.54449}, "CVE-2008-2430": {"epss_score": 0.07893, "epss_percentile": 0.91749}, "CVE-2008-2431": {"epss_score": 0.328, "epss_percentile": 0.96726}, "CVE-2008-2432": {"epss_score": 0.00858, "epss_percentile": 0.74507}, "CVE-2008-2433": {"epss_score": 0.12313, "epss_percentile": 0.93635}, "CVE-2008-2434": {"epss_score": 0.34903, "epss_percentile": 0.96877}, "CVE-2008-2435": {"epss_score": 0.33767, "epss_percentile": 0.96802}, "CVE-2008-2436": {"epss_score": 0.18615, "epss_percentile": 0.95043}, "CVE-2008-2437": {"epss_score": 0.24586, "epss_percentile": 0.95936}, "CVE-2008-2438": {"epss_score": 0.16978, "epss_percentile": 0.94756}, "CVE-2008-2439": {"epss_score": 0.44618, "epss_percentile": 0.97445}, "CVE-2008-2441": {"epss_score": 0.03198, "epss_percentile": 0.86616}, "CVE-2008-2443": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2444": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2445": {"epss_score": 0.0364, "epss_percentile": 0.87488}, "CVE-2008-2446": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2447": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2448": {"epss_score": 0.00829, "epss_percentile": 0.74006}, "CVE-2008-2449": {"epss_score": 0.00234, "epss_percentile": 0.46082}, "CVE-2008-2450": {"epss_score": 0.00367, "epss_percentile": 0.58141}, "CVE-2008-2451": {"epss_score": 0.00398, "epss_percentile": 0.60092}, "CVE-2008-2452": {"epss_score": 0.00367, "epss_percentile": 0.58141}, "CVE-2008-2453": {"epss_score": 0.00338, "epss_percentile": 0.56139}, "CVE-2008-2454": {"epss_score": 0.00023, "epss_percentile": 0.05479}, "CVE-2008-2455": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2456": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-2457": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2458": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-2459": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2008-2460": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2008-2461": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2462": {"epss_score": 0.03865, "epss_percentile": 0.8787}, "CVE-2008-2463": {"epss_score": 0.84093, "epss_percentile": 0.99273}, "CVE-2008-2464": {"epss_score": 0.03587, "epss_percentile": 0.87395}, "CVE-2008-2468": {"epss_score": 0.44143, "epss_percentile": 0.97421}, "CVE-2008-2469": {"epss_score": 0.38959, "epss_percentile": 0.97131}, "CVE-2008-2470": {"epss_score": 0.07615, "epss_percentile": 0.9157}, "CVE-2008-2474": {"epss_score": 0.31374, "epss_percentile": 0.96615}, "CVE-2008-2475": {"epss_score": 0.01409, "epss_percentile": 0.80065}, "CVE-2008-2476": {"epss_score": 0.17476, "epss_percentile": 0.94855}, "CVE-2008-2477": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-2478": {"epss_score": 0.05505, "epss_percentile": 0.89942}, "CVE-2008-2479": {"epss_score": 0.00357, "epss_percentile": 0.57434}, "CVE-2008-2480": {"epss_score": 0.04412, "epss_percentile": 0.88662}, "CVE-2008-2481": {"epss_score": 0.07304, "epss_percentile": 0.91394}, "CVE-2008-2482": {"epss_score": 0.07032, "epss_percentile": 0.912}, "CVE-2008-2483": {"epss_score": 0.0402, "epss_percentile": 0.8813}, "CVE-2008-2484": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2485": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2486": {"epss_score": 0.00402, "epss_percentile": 0.60292}, "CVE-2008-2487": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2488": {"epss_score": 0.04387, "epss_percentile": 0.88633}, "CVE-2008-2489": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-2490": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-2491": {"epss_score": 0.00266, "epss_percentile": 0.49863}, "CVE-2008-2492": {"epss_score": 0.00406, "epss_percentile": 0.60522}, "CVE-2008-2493": {"epss_score": 0.00505, "epss_percentile": 0.65612}, "CVE-2008-2494": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-2495": {"epss_score": 0.00152, "epss_percentile": 0.36452}, "CVE-2008-2496": {"epss_score": 0.0364, "epss_percentile": 0.87488}, "CVE-2008-2497": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2008-2498": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-2499": {"epss_score": 0.76393, "epss_percentile": 0.98889}, "CVE-2008-2500": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-2501": {"epss_score": 0.00558, "epss_percentile": 0.6758}, "CVE-2008-2502": {"epss_score": 0.00539, "epss_percentile": 0.66985}, "CVE-2008-2503": {"epss_score": 0.00408, "epss_percentile": 0.60667}, "CVE-2008-2504": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2505": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2506": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2507": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-2508": {"epss_score": 0.00255, "epss_percentile": 0.48693}, "CVE-2008-2509": {"epss_score": 0.00526, "epss_percentile": 0.66414}, "CVE-2008-2510": {"epss_score": 0.00234, "epss_percentile": 0.4609}, "CVE-2008-2511": {"epss_score": 0.04695, "epss_percentile": 0.89017}, "CVE-2008-2512": {"epss_score": 0.00917, "epss_percentile": 0.75432}, "CVE-2008-2513": {"epss_score": 0.00107, "epss_percentile": 0.29734}, "CVE-2008-2514": {"epss_score": 0.00065, "epss_percentile": 0.20593}, "CVE-2008-2515": {"epss_score": 0.00064, "epss_percentile": 0.20135}, "CVE-2008-2516": {"epss_score": 0.00058, "epss_percentile": 0.18564}, "CVE-2008-2517": {"epss_score": 0.00039, "epss_percentile": 0.11695}, "CVE-2008-2518": {"epss_score": 0.00529, "epss_percentile": 0.66586}, "CVE-2008-2519": {"epss_score": 0.00332, "epss_percentile": 0.55606}, "CVE-2008-2520": {"epss_score": 0.04556, "epss_percentile": 0.88846}, "CVE-2008-2521": {"epss_score": 0.00412, "epss_percentile": 0.60955}, "CVE-2008-2522": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2523": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-2524": {"epss_score": 0.00355, "epss_percentile": 0.57265}, "CVE-2008-2525": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-2526": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-2527": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2528": {"epss_score": 0.01328, "epss_percentile": 0.79498}, "CVE-2008-2529": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2530": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2531": {"epss_score": 0.00134, "epss_percentile": 0.33773}, "CVE-2008-2532": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2533": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2534": {"epss_score": 0.02898, "epss_percentile": 0.85936}, "CVE-2008-2535": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-2536": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2537": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2538": {"epss_score": 0.00032, "epss_percentile": 0.08836}, "CVE-2008-2539": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2008-2540": {"epss_score": 0.46403, "epss_percentile": 0.97544}, "CVE-2008-2541": {"epss_score": 0.24937, "epss_percentile": 0.9597}, "CVE-2008-2542": {"epss_score": 0.1231, "epss_percentile": 0.93631}, "CVE-2008-2543": {"epss_score": 0.01726, "epss_percentile": 0.81966}, "CVE-2008-2544": {"epss_score": 0.00041, "epss_percentile": 0.12428}, "CVE-2008-2545": {"epss_score": 0.01687, "epss_percentile": 0.81759}, "CVE-2008-2547": {"epss_score": 0.29781, "epss_percentile": 0.96476}, "CVE-2008-2548": {"epss_score": 0.08947, "epss_percentile": 0.92333}, "CVE-2008-2549": {"epss_score": 0.71855, "epss_percentile": 0.98684}, "CVE-2008-2550": {"epss_score": 0.00545, "epss_percentile": 0.67171}, "CVE-2008-2551": {"epss_score": 0.85104, "epss_percentile": 0.99318}, "CVE-2008-2552": {"epss_score": 0.00064, "epss_percentile": 0.20313}, "CVE-2008-2553": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2008-2554": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-2555": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2556": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-2557": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-2558": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2008-2559": {"epss_score": 0.06215, "epss_percentile": 0.90573}, "CVE-2008-2560": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2561": {"epss_score": 0.0364, "epss_percentile": 0.87488}, "CVE-2008-2562": {"epss_score": 0.00412, "epss_percentile": 0.60955}, "CVE-2008-2563": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2564": {"epss_score": 0.00023, "epss_percentile": 0.05479}, "CVE-2008-2565": {"epss_score": 0.02294, "epss_percentile": 0.84291}, "CVE-2008-2566": {"epss_score": 0.0453, "epss_percentile": 0.88811}, "CVE-2008-2567": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-2568": {"epss_score": 0.0004, "epss_percentile": 0.12085}, "CVE-2008-2569": {"epss_score": 0.00023, "epss_percentile": 0.05479}, "CVE-2008-2570": {"epss_score": 0.00402, "epss_percentile": 0.60292}, "CVE-2008-2571": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2008-2572": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2573": {"epss_score": 0.1664, "epss_percentile": 0.94706}, "CVE-2008-2574": {"epss_score": 0.06756, "epss_percentile": 0.91006}, "CVE-2008-2575": {"epss_score": 0.0099, "epss_percentile": 0.76376}, "CVE-2008-2576": {"epss_score": 0.00143, "epss_percentile": 0.3519}, "CVE-2008-2577": {"epss_score": 0.00889, "epss_percentile": 0.75021}, "CVE-2008-2578": {"epss_score": 0.00134, "epss_percentile": 0.33805}, "CVE-2008-2579": {"epss_score": 0.00874, "epss_percentile": 0.74769}, "CVE-2008-2580": {"epss_score": 0.0049, "epss_percentile": 0.6494}, "CVE-2008-2581": {"epss_score": 0.00605, "epss_percentile": 0.68984}, "CVE-2008-2582": {"epss_score": 0.00605, "epss_percentile": 0.68984}, "CVE-2008-2583": {"epss_score": 0.00469, "epss_percentile": 0.63954}, "CVE-2008-2585": {"epss_score": 0.00872, "epss_percentile": 0.74725}, "CVE-2008-2586": {"epss_score": 0.00358, "epss_percentile": 0.57493}, "CVE-2008-2587": {"epss_score": 0.00165, "epss_percentile": 0.38011}, "CVE-2008-2588": {"epss_score": 0.00178, "epss_percentile": 0.39646}, "CVE-2008-2589": {"epss_score": 0.00494, "epss_percentile": 0.65067}, "CVE-2008-2590": {"epss_score": 0.00378, "epss_percentile": 0.58836}, "CVE-2008-2591": {"epss_score": 0.00872, "epss_percentile": 0.74725}, "CVE-2008-2592": {"epss_score": 0.00599, "epss_percentile": 0.6879}, "CVE-2008-2593": {"epss_score": 0.00707, "epss_percentile": 0.71658}, "CVE-2008-2594": {"epss_score": 0.00707, "epss_percentile": 0.71658}, "CVE-2008-2595": {"epss_score": 0.16477, "epss_percentile": 0.94675}, "CVE-2008-2596": {"epss_score": 0.00872, "epss_percentile": 0.74725}, "CVE-2008-2597": {"epss_score": 0.00555, "epss_percentile": 0.67478}, "CVE-2008-2598": {"epss_score": 0.00622, "epss_percentile": 0.69498}, "CVE-2008-2599": {"epss_score": 0.00622, "epss_percentile": 0.69498}, "CVE-2008-2600": {"epss_score": 0.00872, "epss_percentile": 0.74725}, "CVE-2008-2601": {"epss_score": 0.00358, "epss_percentile": 0.57493}, "CVE-2008-2602": {"epss_score": 0.00872, "epss_percentile": 0.74725}, "CVE-2008-2603": {"epss_score": 0.00451, "epss_percentile": 0.63132}, "CVE-2008-2604": {"epss_score": 0.01005, "epss_percentile": 0.76542}, "CVE-2008-2605": {"epss_score": 0.00409, "epss_percentile": 0.60719}, "CVE-2008-2606": {"epss_score": 0.00872, "epss_percentile": 0.74725}, "CVE-2008-2607": {"epss_score": 0.04074, "epss_percentile": 0.88209}, "CVE-2008-2608": {"epss_score": 0.00872, "epss_percentile": 0.74725}, "CVE-2008-2609": {"epss_score": 0.00469, "epss_percentile": 0.63954}, "CVE-2008-2610": {"epss_score": 0.00872, "epss_percentile": 0.74725}, "CVE-2008-2611": {"epss_score": 0.00872, "epss_percentile": 0.74725}, "CVE-2008-2612": {"epss_score": 0.00469, "epss_percentile": 0.63954}, "CVE-2008-2613": {"epss_score": 0.00816, "epss_percentile": 0.73798}, "CVE-2008-2614": {"epss_score": 0.00469, "epss_percentile": 0.63954}, "CVE-2008-2615": {"epss_score": 0.00918, "epss_percentile": 0.75449}, "CVE-2008-2616": {"epss_score": 0.00918, "epss_percentile": 0.75449}, "CVE-2008-2617": {"epss_score": 0.00918, "epss_percentile": 0.75449}, "CVE-2008-2618": {"epss_score": 0.00918, "epss_percentile": 0.75449}, "CVE-2008-2619": {"epss_score": 0.00362, "epss_percentile": 0.57816}, "CVE-2008-2620": {"epss_score": 0.00918, "epss_percentile": 0.75449}, "CVE-2008-2621": {"epss_score": 0.00377, "epss_percentile": 0.58715}, "CVE-2008-2622": {"epss_score": 0.00918, "epss_percentile": 0.75449}, "CVE-2008-2623": {"epss_score": 0.0018, "epss_percentile": 0.39965}, "CVE-2008-2624": {"epss_score": 0.00565, "epss_percentile": 0.67803}, "CVE-2008-2625": {"epss_score": 0.00477, "epss_percentile": 0.64301}, "CVE-2008-2626": {"epss_score": 0.00897, "epss_percentile": 0.75127}, "CVE-2008-2627": {"epss_score": 0.00019, "epss_percentile": 0.04071}, "CVE-2008-2628": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-2629": {"epss_score": 0.00372, "epss_percentile": 0.58439}, "CVE-2008-2630": {"epss_score": 0.00034, "epss_percentile": 0.09668}, "CVE-2008-2631": {"epss_score": 0.10385, "epss_percentile": 0.92968}, "CVE-2008-2632": {"epss_score": 0.00018, "epss_percentile": 0.0398}, "CVE-2008-2633": {"epss_score": 0.00055, "epss_percentile": 0.17645}, "CVE-2008-2634": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-2635": {"epss_score": 0.00153, "epss_percentile": 0.36546}, "CVE-2008-2636": {"epss_score": 0.05067, "epss_percentile": 0.89459}, "CVE-2008-2637": {"epss_score": 0.07057, "epss_percentile": 0.91218}, "CVE-2008-2638": {"epss_score": 0.05484, "epss_percentile": 0.89922}, "CVE-2008-2639": {"epss_score": 0.85791, "epss_percentile": 0.99349}, "CVE-2008-2640": {"epss_score": 0.02799, "epss_percentile": 0.85689}, "CVE-2008-2641": {"epss_score": 0.45276, "epss_percentile": 0.97479}, "CVE-2008-2642": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-2643": {"epss_score": 0.00027, "epss_percentile": 0.06896}, "CVE-2008-2644": {"epss_score": 0.03701, "epss_percentile": 0.8759}, "CVE-2008-2645": {"epss_score": 0.28666, "epss_percentile": 0.96376}, "CVE-2008-2646": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2647": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2648": {"epss_score": 0.03014, "epss_percentile": 0.86209}, "CVE-2008-2649": {"epss_score": 0.03259, "epss_percentile": 0.86768}, "CVE-2008-2650": {"epss_score": 0.01643, "epss_percentile": 0.81516}, "CVE-2008-2651": {"epss_score": 0.00018, "epss_percentile": 0.0398}, "CVE-2008-2652": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-2654": {"epss_score": 0.0746, "epss_percentile": 0.91483}, "CVE-2008-2662": {"epss_score": 0.02771, "epss_percentile": 0.8562}, "CVE-2008-2663": {"epss_score": 0.03283, "epss_percentile": 0.86821}, "CVE-2008-2664": {"epss_score": 0.06265, "epss_percentile": 0.90623}, "CVE-2008-2665": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2008-2666": {"epss_score": 0.07274, "epss_percentile": 0.91377}, "CVE-2008-2667": {"epss_score": 0.01583, "epss_percentile": 0.81152}, "CVE-2008-2668": {"epss_score": 0.06189, "epss_percentile": 0.90547}, "CVE-2008-2669": {"epss_score": 0.00879, "epss_percentile": 0.74846}, "CVE-2008-2670": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-2671": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-2672": {"epss_score": 0.07052, "epss_percentile": 0.91214}, "CVE-2008-2673": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2674": {"epss_score": 0.0055, "epss_percentile": 0.67324}, "CVE-2008-2675": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-2676": {"epss_score": 0.00018, "epss_percentile": 0.0398}, "CVE-2008-2677": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2678": {"epss_score": 0.00284, "epss_percentile": 0.51439}, "CVE-2008-2679": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2680": {"epss_score": 0.03821, "epss_percentile": 0.87783}, "CVE-2008-2681": {"epss_score": 0.05896, "epss_percentile": 0.90303}, "CVE-2008-2682": {"epss_score": 0.02485, "epss_percentile": 0.84884}, "CVE-2008-2683": {"epss_score": 0.79398, "epss_percentile": 0.99036}, "CVE-2008-2684": {"epss_score": 0.10365, "epss_percentile": 0.9296}, "CVE-2008-2685": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2008-2686": {"epss_score": 0.04702, "epss_percentile": 0.89026}, "CVE-2008-2687": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2688": {"epss_score": 0.00304, "epss_percentile": 0.53276}, "CVE-2008-2689": {"epss_score": 0.6804, "epss_percentile": 0.98529}, "CVE-2008-2690": {"epss_score": 0.01187, "epss_percentile": 0.78352}, "CVE-2008-2691": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2692": {"epss_score": 0.00027, "epss_percentile": 0.06896}, "CVE-2008-2693": {"epss_score": 0.1216, "epss_percentile": 0.93586}, "CVE-2008-2694": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2695": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2696": {"epss_score": 0.01783, "epss_percentile": 0.82249}, "CVE-2008-2697": {"epss_score": 0.00031, "epss_percentile": 0.08545}, "CVE-2008-2698": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-2699": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2700": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2701": {"epss_score": 0.00077, "epss_percentile": 0.23389}, "CVE-2008-2702": {"epss_score": 0.06337, "epss_percentile": 0.9068}, "CVE-2008-2703": {"epss_score": 0.73339, "epss_percentile": 0.98748}, "CVE-2008-2704": {"epss_score": 0.02406, "epss_percentile": 0.84652}, "CVE-2008-2705": {"epss_score": 0.0035, "epss_percentile": 0.56947}, "CVE-2008-2706": {"epss_score": 0.00054, "epss_percentile": 0.17322}, "CVE-2008-2707": {"epss_score": 0.01313, "epss_percentile": 0.7938}, "CVE-2008-2708": {"epss_score": 0.00069, "epss_percentile": 0.2149}, "CVE-2008-2709": {"epss_score": 0.00047, "epss_percentile": 0.14888}, "CVE-2008-2710": {"epss_score": 0.00081, "epss_percentile": 0.24377}, "CVE-2008-2711": {"epss_score": 0.03347, "epss_percentile": 0.86953}, "CVE-2008-2712": {"epss_score": 0.09987, "epss_percentile": 0.92805}, "CVE-2008-2713": {"epss_score": 0.03212, "epss_percentile": 0.86657}, "CVE-2008-2714": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2008-2715": {"epss_score": 0.00705, "epss_percentile": 0.71589}, "CVE-2008-2716": {"epss_score": 0.00915, "epss_percentile": 0.75406}, "CVE-2008-2717": {"epss_score": 0.00249, "epss_percentile": 0.48056}, "CVE-2008-2718": {"epss_score": 0.00335, "epss_percentile": 0.55837}, "CVE-2008-2719": {"epss_score": 0.03568, "epss_percentile": 0.87368}, "CVE-2008-2720": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-2721": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2008-2722": {"epss_score": 0.00361, "epss_percentile": 0.57715}, "CVE-2008-2723": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2008-2724": {"epss_score": 0.00287, "epss_percentile": 0.51784}, "CVE-2008-2725": {"epss_score": 0.03164, "epss_percentile": 0.86537}, "CVE-2008-2726": {"epss_score": 0.02858, "epss_percentile": 0.85846}, "CVE-2008-2729": {"epss_score": 0.00061, "epss_percentile": 0.19308}, "CVE-2008-2730": {"epss_score": 0.00507, "epss_percentile": 0.65665}, "CVE-2008-2732": {"epss_score": 0.00584, "epss_percentile": 0.68395}, "CVE-2008-2733": {"epss_score": 0.00527, "epss_percentile": 0.66469}, "CVE-2008-2734": {"epss_score": 0.00395, "epss_percentile": 0.59815}, "CVE-2008-2735": {"epss_score": 0.00451, "epss_percentile": 0.63123}, "CVE-2008-2736": {"epss_score": 0.00278, "epss_percentile": 0.50893}, "CVE-2008-2739": {"epss_score": 0.00663, "epss_percentile": 0.70623}, "CVE-2008-2742": {"epss_score": 0.01705, "epss_percentile": 0.81851}, "CVE-2008-2743": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-2744": {"epss_score": 0.03126, "epss_percentile": 0.86457}, "CVE-2008-2745": {"epss_score": 0.26765, "epss_percentile": 0.96177}, "CVE-2008-2746": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2747": {"epss_score": 0.00053, "epss_percentile": 0.16725}, "CVE-2008-2748": {"epss_score": 0.10007, "epss_percentile": 0.92813}, "CVE-2008-2749": {"epss_score": 0.0139, "epss_percentile": 0.79937}, "CVE-2008-2750": {"epss_score": 0.09719, "epss_percentile": 0.92676}, "CVE-2008-2751": {"epss_score": 0.00374, "epss_percentile": 0.58586}, "CVE-2008-2752": {"epss_score": 0.40264, "epss_percentile": 0.97209}, "CVE-2008-2753": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-2754": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2755": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2756": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2008-2757": {"epss_score": 0.00652, "epss_percentile": 0.70305}, "CVE-2008-2758": {"epss_score": 0.00363, "epss_percentile": 0.57836}, "CVE-2008-2759": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2008-2760": {"epss_score": 0.00652, "epss_percentile": 0.70305}, "CVE-2008-2761": {"epss_score": 0.00363, "epss_percentile": 0.57836}, "CVE-2008-2762": {"epss_score": 0.0041, "epss_percentile": 0.60795}, "CVE-2008-2763": {"epss_score": 0.0041, "epss_percentile": 0.60795}, "CVE-2008-2764": {"epss_score": 0.00239, "epss_percentile": 0.46937}, "CVE-2008-2765": {"epss_score": 0.00465, "epss_percentile": 0.63773}, "CVE-2008-2766": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2008-2767": {"epss_score": 0.0041, "epss_percentile": 0.60795}, "CVE-2008-2768": {"epss_score": 0.00239, "epss_percentile": 0.46937}, "CVE-2008-2769": {"epss_score": 0.00674, "epss_percentile": 0.70854}, "CVE-2008-2770": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2771": {"epss_score": 0.00171, "epss_percentile": 0.38868}, "CVE-2008-2772": {"epss_score": 0.00619, "epss_percentile": 0.69401}, "CVE-2008-2773": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-2774": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2775": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-2776": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-2777": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-2778": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2779": {"epss_score": 0.0023, "epss_percentile": 0.45732}, "CVE-2008-2780": {"epss_score": 0.00325, "epss_percentile": 0.55009}, "CVE-2008-2781": {"epss_score": 0.00284, "epss_percentile": 0.51444}, "CVE-2008-2782": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2783": {"epss_score": 0.00246, "epss_percentile": 0.47753}, "CVE-2008-2784": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2008-2785": {"epss_score": 0.0952, "epss_percentile": 0.92584}, "CVE-2008-2786": {"epss_score": 0.00461, "epss_percentile": 0.63569}, "CVE-2008-2787": {"epss_score": 0.07297, "epss_percentile": 0.9139}, "CVE-2008-2788": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-2789": {"epss_score": 0.47292, "epss_percentile": 0.97581}, "CVE-2008-2790": {"epss_score": 0.00787, "epss_percentile": 0.73314}, "CVE-2008-2791": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2792": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2793": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2794": {"epss_score": 0.00061, "epss_percentile": 0.19345}, "CVE-2008-2795": {"epss_score": 0.02782, "epss_percentile": 0.85653}, "CVE-2008-2796": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2797": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-2798": {"epss_score": 0.09471, "epss_percentile": 0.92561}, "CVE-2008-2799": {"epss_score": 0.08431, "epss_percentile": 0.92048}, "CVE-2008-2800": {"epss_score": 0.02008, "epss_percentile": 0.83241}, "CVE-2008-2801": {"epss_score": 0.03972, "epss_percentile": 0.88037}, "CVE-2008-2802": {"epss_score": 0.06797, "epss_percentile": 0.91032}, "CVE-2008-2803": {"epss_score": 0.06393, "epss_percentile": 0.9072}, "CVE-2008-2805": {"epss_score": 0.02196, "epss_percentile": 0.83956}, "CVE-2008-2806": {"epss_score": 0.00923, "epss_percentile": 0.75512}, "CVE-2008-2807": {"epss_score": 0.01628, "epss_percentile": 0.81437}, "CVE-2008-2808": {"epss_score": 0.02079, "epss_percentile": 0.83528}, "CVE-2008-2809": {"epss_score": 0.01957, "epss_percentile": 0.83042}, "CVE-2008-2810": {"epss_score": 0.00933, "epss_percentile": 0.75638}, "CVE-2008-2811": {"epss_score": 0.26861, "epss_percentile": 0.96186}, "CVE-2008-2812": {"epss_score": 0.00098, "epss_percentile": 0.27704}, "CVE-2008-2813": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2008-2814": {"epss_score": 0.00292, "epss_percentile": 0.52238}, "CVE-2008-2815": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2816": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2817": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2818": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2819": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-2820": {"epss_score": 0.06501, "epss_percentile": 0.90802}, "CVE-2008-2821": {"epss_score": 0.02335, "epss_percentile": 0.84415}, "CVE-2008-2822": {"epss_score": 0.04612, "epss_percentile": 0.88916}, "CVE-2008-2823": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2824": {"epss_score": 0.0197, "epss_percentile": 0.83095}, "CVE-2008-2825": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-2826": {"epss_score": 0.00151, "epss_percentile": 0.36341}, "CVE-2008-2827": {"epss_score": 0.00101, "epss_percentile": 0.28628}, "CVE-2008-2828": {"epss_score": 0.03122, "epss_percentile": 0.86452}, "CVE-2008-2829": {"epss_score": 0.09637, "epss_percentile": 0.92634}, "CVE-2008-2830": {"epss_score": 0.0013, "epss_percentile": 0.33241}, "CVE-2008-2831": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2008-2832": {"epss_score": 0.06286, "epss_percentile": 0.90642}, "CVE-2008-2833": {"epss_score": 0.04419, "epss_percentile": 0.88668}, "CVE-2008-2834": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2835": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2836": {"epss_score": 0.04076, "epss_percentile": 0.88212}, "CVE-2008-2837": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2838": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-2839": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2840": {"epss_score": 0.00286, "epss_percentile": 0.51751}, "CVE-2008-2841": {"epss_score": 0.31253, "epss_percentile": 0.96603}, "CVE-2008-2842": {"epss_score": 0.03821, "epss_percentile": 0.87783}, "CVE-2008-2843": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-2844": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2845": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2846": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2847": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2848": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-2849": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2008-2850": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-2851": {"epss_score": 0.00944, "epss_percentile": 0.75788}, "CVE-2008-2852": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-2853": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2854": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2008-2855": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2856": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2857": {"epss_score": 0.01584, "epss_percentile": 0.81164}, "CVE-2008-2858": {"epss_score": 0.00224, "epss_percentile": 0.44983}, "CVE-2008-2859": {"epss_score": 0.05535, "epss_percentile": 0.8997}, "CVE-2008-2860": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2861": {"epss_score": 0.06697, "epss_percentile": 0.90954}, "CVE-2008-2862": {"epss_score": 0.01135, "epss_percentile": 0.7791}, "CVE-2008-2863": {"epss_score": 0.11313, "epss_percentile": 0.93303}, "CVE-2008-2864": {"epss_score": 0.05342, "epss_percentile": 0.89763}, "CVE-2008-2865": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2866": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2867": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2868": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-2869": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2870": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2871": {"epss_score": 0.00292, "epss_percentile": 0.52238}, "CVE-2008-2872": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2873": {"epss_score": 0.05896, "epss_percentile": 0.90303}, "CVE-2008-2874": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-2875": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2876": {"epss_score": 0.06303, "epss_percentile": 0.90658}, "CVE-2008-2877": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2008-2878": {"epss_score": 0.0762, "epss_percentile": 0.91575}, "CVE-2008-2879": {"epss_score": 0.00648, "epss_percentile": 0.70217}, "CVE-2008-2880": {"epss_score": 0.06194, "epss_percentile": 0.90554}, "CVE-2008-2881": {"epss_score": 0.03855, "epss_percentile": 0.87857}, "CVE-2008-2882": {"epss_score": 0.04658, "epss_percentile": 0.88976}, "CVE-2008-2883": {"epss_score": 0.0373, "epss_percentile": 0.87642}, "CVE-2008-2884": {"epss_score": 0.03623, "epss_percentile": 0.87446}, "CVE-2008-2885": {"epss_score": 0.02932, "epss_percentile": 0.86017}, "CVE-2008-2886": {"epss_score": 0.07306, "epss_percentile": 0.91396}, "CVE-2008-2887": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2008-2888": {"epss_score": 0.02252, "epss_percentile": 0.8416}, "CVE-2008-2889": {"epss_score": 0.06646, "epss_percentile": 0.90912}, "CVE-2008-2890": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-2891": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2892": {"epss_score": 0.00028, "epss_percentile": 0.07511}, "CVE-2008-2893": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2894": {"epss_score": 0.02484, "epss_percentile": 0.84883}, "CVE-2008-2895": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2008-2896": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2897": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2898": {"epss_score": 0.01827, "epss_percentile": 0.82437}, "CVE-2008-2899": {"epss_score": 0.00378, "epss_percentile": 0.58821}, "CVE-2008-2900": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2901": {"epss_score": 0.00412, "epss_percentile": 0.60955}, "CVE-2008-2902": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2903": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2904": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2905": {"epss_score": 0.72166, "epss_percentile": 0.98697}, "CVE-2008-2906": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2907": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2908": {"epss_score": 0.70256, "epss_percentile": 0.98625}, "CVE-2008-2909": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2910": {"epss_score": 0.07542, "epss_percentile": 0.91527}, "CVE-2008-2911": {"epss_score": 0.0364, "epss_percentile": 0.87488}, "CVE-2008-2912": {"epss_score": 0.0373, "epss_percentile": 0.87642}, "CVE-2008-2913": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2008-2914": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2915": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-2916": {"epss_score": 0.01028, "epss_percentile": 0.76817}, "CVE-2008-2917": {"epss_score": 0.01135, "epss_percentile": 0.7791}, "CVE-2008-2918": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2919": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2920": {"epss_score": 0.0608, "epss_percentile": 0.90462}, "CVE-2008-2921": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-2922": {"epss_score": 0.53059, "epss_percentile": 0.97854}, "CVE-2008-2923": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-2924": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-2925": {"epss_score": 0.00366, "epss_percentile": 0.5802}, "CVE-2008-2926": {"epss_score": 0.00057, "epss_percentile": 0.18086}, "CVE-2008-2927": {"epss_score": 0.06329, "epss_percentile": 0.90674}, "CVE-2008-2928": {"epss_score": 0.19099, "epss_percentile": 0.95129}, "CVE-2008-2929": {"epss_score": 0.00627, "epss_percentile": 0.69637}, "CVE-2008-2930": {"epss_score": 0.15226, "epss_percentile": 0.94388}, "CVE-2008-2931": {"epss_score": 0.00027, "epss_percentile": 0.06811}, "CVE-2008-2932": {"epss_score": 0.02998, "epss_percentile": 0.86158}, "CVE-2008-2933": {"epss_score": 0.07092, "epss_percentile": 0.91244}, "CVE-2008-2934": {"epss_score": 0.05575, "epss_percentile": 0.90012}, "CVE-2008-2935": {"epss_score": 0.22141, "epss_percentile": 0.956}, "CVE-2008-2936": {"epss_score": 0.0029, "epss_percentile": 0.5213}, "CVE-2008-2937": {"epss_score": 0.00075, "epss_percentile": 0.22946}, "CVE-2008-2938": {"epss_score": 0.92923, "epss_percentile": 0.9976}, "CVE-2008-2939": {"epss_score": 0.76085, "epss_percentile": 0.98878}, "CVE-2008-2940": {"epss_score": 0.00044, "epss_percentile": 0.13487}, "CVE-2008-2941": {"epss_score": 0.00036, "epss_percentile": 0.10203}, "CVE-2008-2942": {"epss_score": 0.00581, "epss_percentile": 0.68278}, "CVE-2008-2943": {"epss_score": 0.14817, "epss_percentile": 0.94291}, "CVE-2008-2944": {"epss_score": 0.00059, "epss_percentile": 0.1862}, "CVE-2008-2945": {"epss_score": 0.00895, "epss_percentile": 0.75091}, "CVE-2008-2946": {"epss_score": 0.00723, "epss_percentile": 0.72015}, "CVE-2008-2947": {"epss_score": 0.42038, "epss_percentile": 0.97306}, "CVE-2008-2948": {"epss_score": 0.43936, "epss_percentile": 0.97409}, "CVE-2008-2949": {"epss_score": 0.4035, "epss_percentile": 0.97213}, "CVE-2008-2950": {"epss_score": 0.12435, "epss_percentile": 0.93669}, "CVE-2008-2951": {"epss_score": 0.006, "epss_percentile": 0.68822}, "CVE-2008-2952": {"epss_score": 0.55284, "epss_percentile": 0.97969}, "CVE-2008-2953": {"epss_score": 0.02459, "epss_percentile": 0.84816}, "CVE-2008-2954": {"epss_score": 0.03237, "epss_percentile": 0.86708}, "CVE-2008-2955": {"epss_score": 0.17668, "epss_percentile": 0.94887}, "CVE-2008-2956": {"epss_score": 0.01006, "epss_percentile": 0.76554}, "CVE-2008-2957": {"epss_score": 0.01709, "epss_percentile": 0.8187}, "CVE-2008-2958": {"epss_score": 0.00051, "epss_percentile": 0.16018}, "CVE-2008-2959": {"epss_score": 0.34704, "epss_percentile": 0.96869}, "CVE-2008-2960": {"epss_score": 0.00676, "epss_percentile": 0.70925}, "CVE-2008-2961": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-2962": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2963": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2964": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-2965": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2966": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2967": {"epss_score": 0.06, "epss_percentile": 0.90392}, "CVE-2008-2968": {"epss_score": 0.00823, "epss_percentile": 0.7393}, "CVE-2008-2969": {"epss_score": 0.02626, "epss_percentile": 0.85266}, "CVE-2008-2970": {"epss_score": 0.01443, "epss_percentile": 0.80313}, "CVE-2008-2971": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2972": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-2973": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2974": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2975": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2976": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2977": {"epss_score": 0.02843, "epss_percentile": 0.85812}, "CVE-2008-2978": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2979": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2980": {"epss_score": 0.0061, "epss_percentile": 0.69155}, "CVE-2008-2981": {"epss_score": 0.02324, "epss_percentile": 0.84379}, "CVE-2008-2982": {"epss_score": 0.02898, "epss_percentile": 0.85936}, "CVE-2008-2983": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-2984": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2985": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-2986": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2008-2987": {"epss_score": 0.00608, "epss_percentile": 0.6907}, "CVE-2008-2988": {"epss_score": 0.00686, "epss_percentile": 0.71164}, "CVE-2008-2989": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-2990": {"epss_score": 0.00276, "epss_percentile": 0.50705}, "CVE-2008-2991": {"epss_score": 0.02997, "epss_percentile": 0.86157}, "CVE-2008-2992": {"epss_score": 0.93759, "epss_percentile": 0.9984}, "CVE-2008-2993": {"epss_score": 0.0402, "epss_percentile": 0.8813}, "CVE-2008-2994": {"epss_score": 0.01292, "epss_percentile": 0.79233}, "CVE-2008-2995": {"epss_score": 0.00299, "epss_percentile": 0.52853}, "CVE-2008-2996": {"epss_score": 0.00507, "epss_percentile": 0.65657}, "CVE-2008-2997": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-2998": {"epss_score": 0.00249, "epss_percentile": 0.48037}, "CVE-2008-2999": {"epss_score": 0.00462, "epss_percentile": 0.63623}, "CVE-2008-3000": {"epss_score": 0.00286, "epss_percentile": 0.51754}, "CVE-2008-3001": {"epss_score": 0.02199, "epss_percentile": 0.83969}, "CVE-2008-3003": {"epss_score": 0.00947, "epss_percentile": 0.7582}, "CVE-2008-3004": {"epss_score": 0.54907, "epss_percentile": 0.97951}, "CVE-2008-3005": {"epss_score": 0.54907, "epss_percentile": 0.97951}, "CVE-2008-3006": {"epss_score": 0.66668, "epss_percentile": 0.98473}, "CVE-2008-3007": {"epss_score": 0.5913, "epss_percentile": 0.98151}, "CVE-2008-3008": {"epss_score": 0.80777, "epss_percentile": 0.99104}, "CVE-2008-3009": {"epss_score": 0.52277, "epss_percentile": 0.97816}, "CVE-2008-3010": {"epss_score": 0.52277, "epss_percentile": 0.97816}, "CVE-2008-3012": {"epss_score": 0.68397, "epss_percentile": 0.98545}, "CVE-2008-3013": {"epss_score": 0.71541, "epss_percentile": 0.98672}, "CVE-2008-3014": {"epss_score": 0.73783, "epss_percentile": 0.98772}, "CVE-2008-3015": {"epss_score": 0.71538, "epss_percentile": 0.98672}, "CVE-2008-3018": {"epss_score": 0.50102, "epss_percentile": 0.97719}, "CVE-2008-3019": {"epss_score": 0.54114, "epss_percentile": 0.97912}, "CVE-2008-3020": {"epss_score": 0.54114, "epss_percentile": 0.97912}, "CVE-2008-3021": {"epss_score": 0.63101, "epss_percentile": 0.98321}, "CVE-2008-3022": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2008-3023": {"epss_score": 0.2363, "epss_percentile": 0.95797}, "CVE-2008-3024": {"epss_score": 0.01484, "epss_percentile": 0.80589}, "CVE-2008-3025": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-3026": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3027": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3028": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-3029": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-3030": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-3031": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2008-3032": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2008-3033": {"epss_score": 0.01862, "epss_percentile": 0.82594}, "CVE-2008-3034": {"epss_score": 0.00314, "epss_percentile": 0.54159}, "CVE-2008-3035": {"epss_score": 0.00352, "epss_percentile": 0.57131}, "CVE-2008-3036": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-3037": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-3038": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2008-3039": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2008-3040": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2008-3041": {"epss_score": 0.00334, "epss_percentile": 0.55711}, "CVE-2008-3042": {"epss_score": 0.00334, "epss_percentile": 0.55717}, "CVE-2008-3043": {"epss_score": 0.00784, "epss_percentile": 0.73245}, "CVE-2008-3044": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-3045": {"epss_score": 0.00509, "epss_percentile": 0.65726}, "CVE-2008-3046": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2008-3047": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2008-3048": {"epss_score": 0.00334, "epss_percentile": 0.55711}, "CVE-2008-3049": {"epss_score": 0.00291, "epss_percentile": 0.52169}, "CVE-2008-3050": {"epss_score": 0.00344, "epss_percentile": 0.56508}, "CVE-2008-3051": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2008-3052": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2008-3053": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-3054": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-3055": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2008-3056": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2008-3057": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-3058": {"epss_score": 0.00277, "epss_percentile": 0.50805}, "CVE-2008-3059": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2008-3060": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2008-3061": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2008-3063": {"epss_score": 0.00326, "epss_percentile": 0.55077}, "CVE-2008-3064": {"epss_score": 0.00709, "epss_percentile": 0.71691}, "CVE-2008-3066": {"epss_score": 0.30181, "epss_percentile": 0.96517}, "CVE-2008-3067": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2008-3068": {"epss_score": 0.12634, "epss_percentile": 0.93736}, "CVE-2008-3069": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-3070": {"epss_score": 0.00228, "epss_percentile": 0.45479}, "CVE-2008-3071": {"epss_score": 0.00177, "epss_percentile": 0.39613}, "CVE-2008-3072": {"epss_score": 0.00296, "epss_percentile": 0.52547}, "CVE-2008-3073": {"epss_score": 0.00334, "epss_percentile": 0.55711}, "CVE-2008-3074": {"epss_score": 0.0268, "epss_percentile": 0.85413}, "CVE-2008-3075": {"epss_score": 0.05056, "epss_percentile": 0.89448}, "CVE-2008-3076": {"epss_score": 0.10902, "epss_percentile": 0.93149}, "CVE-2008-3077": {"epss_score": 0.00065, "epss_percentile": 0.20605}, "CVE-2008-3078": {"epss_score": 0.00997, "epss_percentile": 0.76462}, "CVE-2008-3079": {"epss_score": 0.00746, "epss_percentile": 0.72532}, "CVE-2008-3080": {"epss_score": 0.00317, "epss_percentile": 0.54327}, "CVE-2008-3081": {"epss_score": 0.0071, "epss_percentile": 0.717}, "CVE-2008-3082": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-3083": {"epss_score": 0.00024, "epss_percentile": 0.05908}, "CVE-2008-3087": {"epss_score": 0.04435, "epss_percentile": 0.88685}, "CVE-2008-3088": {"epss_score": 0.0364, "epss_percentile": 0.87488}, "CVE-2008-3089": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-3090": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2008-3091": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2008-3092": {"epss_score": 0.00255, "epss_percentile": 0.48702}, "CVE-2008-3093": {"epss_score": 0.04123, "epss_percentile": 0.88286}, "CVE-2008-3094": {"epss_score": 0.00551, "epss_percentile": 0.67355}, "CVE-2008-3095": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2008-3096": {"epss_score": 0.00543, "epss_percentile": 0.67096}, "CVE-2008-3097": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2008-3098": {"epss_score": 0.10267, "epss_percentile": 0.9292}, "CVE-2008-3100": {"epss_score": 0.08113, "epss_percentile": 0.91886}, "CVE-2008-3101": {"epss_score": 0.07323, "epss_percentile": 0.91409}, "CVE-2008-3102": {"epss_score": 0.01248, "epss_percentile": 0.78865}, "CVE-2008-3103": {"epss_score": 0.24388, "epss_percentile": 0.95916}, "CVE-2008-3104": {"epss_score": 0.26301, "epss_percentile": 0.96136}, "CVE-2008-3105": {"epss_score": 0.25029, "epss_percentile": 0.95981}, "CVE-2008-3106": {"epss_score": 0.17799, "epss_percentile": 0.94908}, "CVE-2008-3107": {"epss_score": 0.14533, "epss_percentile": 0.94234}, "CVE-2008-3108": {"epss_score": 0.08616, "epss_percentile": 0.92154}, "CVE-2008-3109": {"epss_score": 0.06613, "epss_percentile": 0.9089}, "CVE-2008-3110": {"epss_score": 0.07177, "epss_percentile": 0.91301}, "CVE-2008-3111": {"epss_score": 0.13359, "epss_percentile": 0.93941}, "CVE-2008-3112": {"epss_score": 0.0838, "epss_percentile": 0.92017}, "CVE-2008-3113": {"epss_score": 0.22991, "epss_percentile": 0.95715}, "CVE-2008-3114": {"epss_score": 0.03332, "epss_percentile": 0.86929}, "CVE-2008-3115": {"epss_score": 0.28331, "epss_percentile": 0.96343}, "CVE-2008-3116": {"epss_score": 0.05537, "epss_percentile": 0.89972}, "CVE-2008-3117": {"epss_score": 0.03014, "epss_percentile": 0.86207}, "CVE-2008-3118": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3119": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-3121": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-3122": {"epss_score": 0.00311, "epss_percentile": 0.53858}, "CVE-2008-3123": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-3124": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-3125": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-3126": {"epss_score": 0.02479, "epss_percentile": 0.8487}, "CVE-2008-3127": {"epss_score": 0.04198, "epss_percentile": 0.88383}, "CVE-2008-3128": {"epss_score": 0.19982, "epss_percentile": 0.9527}, "CVE-2008-3129": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3130": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-3131": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3132": {"epss_score": 0.00019, "epss_percentile": 0.04182}, "CVE-2008-3133": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-3134": {"epss_score": 0.01621, "epss_percentile": 0.81395}, "CVE-2008-3135": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2008-3136": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3137": {"epss_score": 0.02919, "epss_percentile": 0.85989}, "CVE-2008-3138": {"epss_score": 0.01004, "epss_percentile": 0.76526}, "CVE-2008-3139": {"epss_score": 0.01332, "epss_percentile": 0.79525}, "CVE-2008-3140": {"epss_score": 0.053, "epss_percentile": 0.89705}, "CVE-2008-3141": {"epss_score": 0.00127, "epss_percentile": 0.32885}, "CVE-2008-3142": {"epss_score": 0.01654, "epss_percentile": 0.81584}, "CVE-2008-3143": {"epss_score": 0.01548, "epss_percentile": 0.80978}, "CVE-2008-3144": {"epss_score": 0.02991, "epss_percentile": 0.86142}, "CVE-2008-3145": {"epss_score": 0.0242, "epss_percentile": 0.84702}, "CVE-2008-3146": {"epss_score": 0.0178, "epss_percentile": 0.82232}, "CVE-2008-3147": {"epss_score": 0.0007, "epss_percentile": 0.21752}, "CVE-2008-3148": {"epss_score": 0.037, "epss_percentile": 0.87588}, "CVE-2008-3149": {"epss_score": 0.00414, "epss_percentile": 0.61018}, "CVE-2008-3150": {"epss_score": 0.085, "epss_percentile": 0.92085}, "CVE-2008-3151": {"epss_score": 0.00383, "epss_percentile": 0.59093}, "CVE-2008-3152": {"epss_score": 0.00651, "epss_percentile": 0.7029}, "CVE-2008-3153": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-3154": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3155": {"epss_score": 0.25919, "epss_percentile": 0.96094}, "CVE-2008-3156": {"epss_score": 0.12922, "epss_percentile": 0.93818}, "CVE-2008-3157": {"epss_score": 0.00766, "epss_percentile": 0.7293}, "CVE-2008-3158": {"epss_score": 0.17977, "epss_percentile": 0.94936}, "CVE-2008-3159": {"epss_score": 0.20383, "epss_percentile": 0.95337}, "CVE-2008-3160": {"epss_score": 0.0182, "epss_percentile": 0.82409}, "CVE-2008-3161": {"epss_score": 0.01162, "epss_percentile": 0.78149}, "CVE-2008-3162": {"epss_score": 0.24175, "epss_percentile": 0.95883}, "CVE-2008-3163": {"epss_score": 0.01523, "epss_percentile": 0.80841}, "CVE-2008-3164": {"epss_score": 0.12457, "epss_percentile": 0.93679}, "CVE-2008-3165": {"epss_score": 0.07032, "epss_percentile": 0.912}, "CVE-2008-3166": {"epss_score": 0.03376, "epss_percentile": 0.87021}, "CVE-2008-3167": {"epss_score": 0.05526, "epss_percentile": 0.89962}, "CVE-2008-3168": {"epss_score": 0.00328, "epss_percentile": 0.55275}, "CVE-2008-3169": {"epss_score": 0.03122, "epss_percentile": 0.86452}, "CVE-2008-3170": {"epss_score": 0.01834, "epss_percentile": 0.82463}, "CVE-2008-3171": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2008-3172": {"epss_score": 0.00582, "epss_percentile": 0.68291}, "CVE-2008-3173": {"epss_score": 0.14378, "epss_percentile": 0.94198}, "CVE-2008-3174": {"epss_score": 0.01621, "epss_percentile": 0.81395}, "CVE-2008-3175": {"epss_score": 0.24278, "epss_percentile": 0.95899}, "CVE-2008-3177": {"epss_score": 0.06048, "epss_percentile": 0.90434}, "CVE-2008-3178": {"epss_score": 0.0756, "epss_percentile": 0.91541}, "CVE-2008-3179": {"epss_score": 0.07032, "epss_percentile": 0.912}, "CVE-2008-3180": {"epss_score": 0.03701, "epss_percentile": 0.8759}, "CVE-2008-3181": {"epss_score": 0.03505, "epss_percentile": 0.87257}, "CVE-2008-3182": {"epss_score": 0.34048, "epss_percentile": 0.96824}, "CVE-2008-3183": {"epss_score": 0.06279, "epss_percentile": 0.90635}, "CVE-2008-3184": {"epss_score": 0.02903, "epss_percentile": 0.85958}, "CVE-2008-3185": {"epss_score": 0.00879, "epss_percentile": 0.74846}, "CVE-2008-3186": {"epss_score": 0.00254, "epss_percentile": 0.48517}, "CVE-2008-3187": {"epss_score": 0.00348, "epss_percentile": 0.56831}, "CVE-2008-3188": {"epss_score": 0.00711, "epss_percentile": 0.71735}, "CVE-2008-3189": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-3190": {"epss_score": 0.07032, "epss_percentile": 0.912}, "CVE-2008-3191": {"epss_score": 0.00495, "epss_percentile": 0.65125}, "CVE-2008-3192": {"epss_score": 0.0402, "epss_percentile": 0.8813}, "CVE-2008-3193": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-3194": {"epss_score": 0.09282, "epss_percentile": 0.92483}, "CVE-2008-3195": {"epss_score": 0.57505, "epss_percentile": 0.98066}, "CVE-2008-3196": {"epss_score": 0.00486, "epss_percentile": 0.64752}, "CVE-2008-3197": {"epss_score": 0.00466, "epss_percentile": 0.6381}, "CVE-2008-3198": {"epss_score": 0.01485, "epss_percentile": 0.80596}, "CVE-2008-3199": {"epss_score": 0.0066, "epss_percentile": 0.7052}, "CVE-2008-3200": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3201": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-3202": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-3203": {"epss_score": 0.04826, "epss_percentile": 0.89186}, "CVE-2008-3204": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-3205": {"epss_score": 0.04654, "epss_percentile": 0.88967}, "CVE-2008-3206": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-3207": {"epss_score": 0.04865, "epss_percentile": 0.89227}, "CVE-2008-3208": {"epss_score": 0.11414, "epss_percentile": 0.93342}, "CVE-2008-3209": {"epss_score": 0.22982, "epss_percentile": 0.95713}, "CVE-2008-3210": {"epss_score": 0.13041, "epss_percentile": 0.93853}, "CVE-2008-3211": {"epss_score": 0.05129, "epss_percentile": 0.89528}, "CVE-2008-3212": {"epss_score": 0.00234, "epss_percentile": 0.4609}, "CVE-2008-3213": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-3214": {"epss_score": 0.00242, "epss_percentile": 0.47356}, "CVE-2008-3215": {"epss_score": 0.03636, "epss_percentile": 0.87483}, "CVE-2008-3216": {"epss_score": 0.0006, "epss_percentile": 0.19232}, "CVE-2008-3217": {"epss_score": 4e-05, "epss_percentile": 0.00162}, "CVE-2008-3218": {"epss_score": 0.00518, "epss_percentile": 0.66115}, "CVE-2008-3219": {"epss_score": 0.00583, "epss_percentile": 0.68336}, "CVE-2008-3220": {"epss_score": 0.00402, "epss_percentile": 0.60306}, "CVE-2008-3221": {"epss_score": 0.00422, "epss_percentile": 0.61569}, "CVE-2008-3222": {"epss_score": 0.01059, "epss_percentile": 0.77153}, "CVE-2008-3223": {"epss_score": 0.01141, "epss_percentile": 0.77956}, "CVE-2008-3224": {"epss_score": 0.00323, "epss_percentile": 0.5488}, "CVE-2008-3225": {"epss_score": 0.00028, "epss_percentile": 0.07498}, "CVE-2008-3226": {"epss_score": 0.00133, "epss_percentile": 0.33745}, "CVE-2008-3227": {"epss_score": 0.00044, "epss_percentile": 0.13433}, "CVE-2008-3228": {"epss_score": 0.00272, "epss_percentile": 0.50412}, "CVE-2008-3229": {"epss_score": 0.0005, "epss_percentile": 0.15724}, "CVE-2008-3230": {"epss_score": 0.00124, "epss_percentile": 0.32382}, "CVE-2008-3231": {"epss_score": 0.0203, "epss_percentile": 0.83332}, "CVE-2008-3232": {"epss_score": 0.12732, "epss_percentile": 0.93761}, "CVE-2008-3233": {"epss_score": 0.0047, "epss_percentile": 0.63988}, "CVE-2008-3234": {"epss_score": 0.02871, "epss_percentile": 0.85873}, "CVE-2008-3235": {"epss_score": 0.00985, "epss_percentile": 0.76323}, "CVE-2008-3236": {"epss_score": 0.00515, "epss_percentile": 0.65983}, "CVE-2008-3237": {"epss_score": 0.06697, "epss_percentile": 0.90954}, "CVE-2008-3238": {"epss_score": 0.00897, "epss_percentile": 0.75127}, "CVE-2008-3239": {"epss_score": 0.04627, "epss_percentile": 0.88939}, "CVE-2008-3240": {"epss_score": 0.01071, "epss_percentile": 0.77264}, "CVE-2008-3241": {"epss_score": 0.00504, "epss_percentile": 0.65523}, "CVE-2008-3242": {"epss_score": 0.31738, "epss_percentile": 0.96643}, "CVE-2008-3243": {"epss_score": 0.01214, "epss_percentile": 0.78581}, "CVE-2008-3244": {"epss_score": 0.01225, "epss_percentile": 0.78684}, "CVE-2008-3245": {"epss_score": 0.00495, "epss_percentile": 0.65125}, "CVE-2008-3246": {"epss_score": 0.33847, "epss_percentile": 0.96809}, "CVE-2008-3247": {"epss_score": 0.00094, "epss_percentile": 0.27034}, "CVE-2008-3248": {"epss_score": 0.00064, "epss_percentile": 0.20166}, "CVE-2008-3249": {"epss_score": 0.01309, "epss_percentile": 0.79354}, "CVE-2008-3250": {"epss_score": 0.01923, "epss_percentile": 0.82911}, "CVE-2008-3251": {"epss_score": 0.01645, "epss_percentile": 0.8153}, "CVE-2008-3252": {"epss_score": 0.25938, "epss_percentile": 0.96096}, "CVE-2008-3253": {"epss_score": 0.00514, "epss_percentile": 0.65967}, "CVE-2008-3254": {"epss_score": 0.00959, "epss_percentile": 0.75957}, "CVE-2008-3255": {"epss_score": 0.00406, "epss_percentile": 0.60521}, "CVE-2008-3256": {"epss_score": 0.00495, "epss_percentile": 0.65125}, "CVE-2008-3257": {"epss_score": 0.81326, "epss_percentile": 0.99132}, "CVE-2008-3258": {"epss_score": 0.00517, "epss_percentile": 0.66081}, "CVE-2008-3259": {"epss_score": 0.00032, "epss_percentile": 0.08805}, "CVE-2008-3260": {"epss_score": 0.01805, "epss_percentile": 0.82347}, "CVE-2008-3261": {"epss_score": 0.06039, "epss_percentile": 0.90428}, "CVE-2008-3262": {"epss_score": 0.00312, "epss_percentile": 0.53993}, "CVE-2008-3263": {"epss_score": 0.53208, "epss_percentile": 0.97863}, "CVE-2008-3264": {"epss_score": 0.11356, "epss_percentile": 0.93322}, "CVE-2008-3265": {"epss_score": 0.00517, "epss_percentile": 0.66074}, "CVE-2008-3266": {"epss_score": 0.01071, "epss_percentile": 0.77264}, "CVE-2008-3267": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2008-3268": {"epss_score": 0.00133, "epss_percentile": 0.33623}, "CVE-2008-3269": {"epss_score": 0.17963, "epss_percentile": 0.94934}, "CVE-2008-3270": {"epss_score": 0.00302, "epss_percentile": 0.53105}, "CVE-2008-3271": {"epss_score": 0.043, "epss_percentile": 0.88513}, "CVE-2008-3272": {"epss_score": 0.00063, "epss_percentile": 0.19982}, "CVE-2008-3273": {"epss_score": 0.414, "epss_percentile": 0.97271}, "CVE-2008-3274": {"epss_score": 0.00721, "epss_percentile": 0.71982}, "CVE-2008-3275": {"epss_score": 0.00077, "epss_percentile": 0.23417}, "CVE-2008-3276": {"epss_score": 0.04445, "epss_percentile": 0.88697}, "CVE-2008-3277": {"epss_score": 0.00042, "epss_percentile": 0.12752}, "CVE-2008-3278": {"epss_score": 0.00049, "epss_percentile": 0.15471}, "CVE-2008-3279": {"epss_score": 0.00166, "epss_percentile": 0.38196}, "CVE-2008-3280": {"epss_score": 0.05925, "epss_percentile": 0.90326}, "CVE-2008-3281": {"epss_score": 0.00802, "epss_percentile": 0.73583}, "CVE-2008-3282": {"epss_score": 0.00621, "epss_percentile": 0.69488}, "CVE-2008-3283": {"epss_score": 0.07322, "epss_percentile": 0.91408}, "CVE-2008-3285": {"epss_score": 0.04665, "epss_percentile": 0.88979}, "CVE-2008-3286": {"epss_score": 0.06911, "epss_percentile": 0.91112}, "CVE-2008-3287": {"epss_score": 0.0197, "epss_percentile": 0.83094}, "CVE-2008-3288": {"epss_score": 0.00683, "epss_percentile": 0.71099}, "CVE-2008-3289": {"epss_score": 0.00733, "epss_percentile": 0.72207}, "CVE-2008-3290": {"epss_score": 0.02007, "epss_percentile": 0.83241}, "CVE-2008-3291": {"epss_score": 0.00521, "epss_percentile": 0.66238}, "CVE-2008-3292": {"epss_score": 0.04937, "epss_percentile": 0.89304}, "CVE-2008-3293": {"epss_score": 0.13483, "epss_percentile": 0.93978}, "CVE-2008-3294": {"epss_score": 0.00132, "epss_percentile": 0.33609}, "CVE-2008-3295": {"epss_score": 0.00428, "epss_percentile": 0.61924}, "CVE-2008-3296": {"epss_score": 0.02204, "epss_percentile": 0.83996}, "CVE-2008-3297": {"epss_score": 0.00738, "epss_percentile": 0.72349}, "CVE-2008-3298": {"epss_score": 0.0077, "epss_percentile": 0.73004}, "CVE-2008-3299": {"epss_score": 0.01371, "epss_percentile": 0.79803}, "CVE-2008-3300": {"epss_score": 0.01333, "epss_percentile": 0.79527}, "CVE-2008-3301": {"epss_score": 0.00509, "epss_percentile": 0.65746}, "CVE-2008-3302": {"epss_score": 0.00544, "epss_percentile": 0.67147}, "CVE-2008-3303": {"epss_score": 0.11963, "epss_percentile": 0.93527}, "CVE-2008-3304": {"epss_score": 0.05233, "epss_percentile": 0.89644}, "CVE-2008-3305": {"epss_score": 0.09345, "epss_percentile": 0.9251}, "CVE-2008-3306": {"epss_score": 0.00224, "epss_percentile": 0.44983}, "CVE-2008-3307": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-3308": {"epss_score": 0.05207, "epss_percentile": 0.89612}, "CVE-2008-3309": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-3310": {"epss_score": 0.00614, "epss_percentile": 0.69264}, "CVE-2008-3311": {"epss_score": 0.01502, "epss_percentile": 0.80724}, "CVE-2008-3312": {"epss_score": 0.01839, "epss_percentile": 0.82489}, "CVE-2008-3313": {"epss_score": 0.00939, "epss_percentile": 0.75716}, "CVE-2008-3314": {"epss_score": 0.08109, "epss_percentile": 0.91884}, "CVE-2008-3315": {"epss_score": 0.02337, "epss_percentile": 0.84421}, "CVE-2008-3316": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-3317": {"epss_score": 0.09709, "epss_percentile": 0.92672}, "CVE-2008-3318": {"epss_score": 0.08936, "epss_percentile": 0.92327}, "CVE-2008-3319": {"epss_score": 0.08966, "epss_percentile": 0.92341}, "CVE-2008-3320": {"epss_score": 0.03917, "epss_percentile": 0.87948}, "CVE-2008-3321": {"epss_score": 0.08966, "epss_percentile": 0.92341}, "CVE-2008-3322": {"epss_score": 0.04628, "epss_percentile": 0.8894}, "CVE-2008-3323": {"epss_score": 0.01227, "epss_percentile": 0.78697}, "CVE-2008-3324": {"epss_score": 0.00409, "epss_percentile": 0.60729}, "CVE-2008-3325": {"epss_score": 0.00397, "epss_percentile": 0.60048}, "CVE-2008-3326": {"epss_score": 0.00548, "epss_percentile": 0.67285}, "CVE-2008-3327": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-3328": {"epss_score": 0.00504, "epss_percentile": 0.65539}, "CVE-2008-3329": {"epss_score": 0.00183, "epss_percentile": 0.40277}, "CVE-2008-3330": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-3331": {"epss_score": 0.00789, "epss_percentile": 0.73363}, "CVE-2008-3332": {"epss_score": 0.09456, "epss_percentile": 0.92556}, "CVE-2008-3333": {"epss_score": 0.00401, "epss_percentile": 0.60237}, "CVE-2008-3334": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-3335": {"epss_score": 0.02423, "epss_percentile": 0.84708}, "CVE-2008-3336": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-3337": {"epss_score": 0.0002, "epss_percentile": 0.04637}, "CVE-2008-3338": {"epss_score": 0.05377, "epss_percentile": 0.898}, "CVE-2008-3339": {"epss_score": 0.00631, "epss_percentile": 0.69729}, "CVE-2008-3340": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-3341": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-3342": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-3343": {"epss_score": 0.00824, "epss_percentile": 0.7394}, "CVE-2008-3344": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-3345": {"epss_score": 0.0045, "epss_percentile": 0.63097}, "CVE-2008-3346": {"epss_score": 0.00897, "epss_percentile": 0.75127}, "CVE-2008-3347": {"epss_score": 0.01013, "epss_percentile": 0.76633}, "CVE-2008-3348": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-3349": {"epss_score": 0.05128, "epss_percentile": 0.89527}, "CVE-2008-3350": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-3351": {"epss_score": 0.00614, "epss_percentile": 0.69264}, "CVE-2008-3352": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-3353": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-3354": {"epss_score": 0.00883, "epss_percentile": 0.74916}, "CVE-2008-3355": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-3356": {"epss_score": 0.00045, "epss_percentile": 0.14017}, "CVE-2008-3357": {"epss_score": 0.00071, "epss_percentile": 0.22122}, "CVE-2008-3358": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2008-3359": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2008-3360": {"epss_score": 0.3202, "epss_percentile": 0.96667}, "CVE-2008-3361": {"epss_score": 0.10083, "epss_percentile": 0.92842}, "CVE-2008-3362": {"epss_score": 0.06341, "epss_percentile": 0.90681}, "CVE-2008-3363": {"epss_score": 0.07829, "epss_percentile": 0.91703}, "CVE-2008-3364": {"epss_score": 0.48652, "epss_percentile": 0.97647}, "CVE-2008-3365": {"epss_score": 0.09327, "epss_percentile": 0.92501}, "CVE-2008-3366": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3367": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-3368": {"epss_score": 0.04707, "epss_percentile": 0.89032}, "CVE-2008-3369": {"epss_score": 0.01716, "epss_percentile": 0.81905}, "CVE-2008-3370": {"epss_score": 0.00901, "epss_percentile": 0.75168}, "CVE-2008-3371": {"epss_score": 0.08373, "epss_percentile": 0.92016}, "CVE-2008-3372": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-3373": {"epss_score": 0.02175, "epss_percentile": 0.8388}, "CVE-2008-3374": {"epss_score": 0.00906, "epss_percentile": 0.75257}, "CVE-2008-3375": {"epss_score": 0.12497, "epss_percentile": 0.93693}, "CVE-2008-3376": {"epss_score": 0.00456, "epss_percentile": 0.63319}, "CVE-2008-3377": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3378": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-3379": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-3380": {"epss_score": 0.05083, "epss_percentile": 0.89475}, "CVE-2008-3381": {"epss_score": 0.0039, "epss_percentile": 0.59548}, "CVE-2008-3382": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3383": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-3384": {"epss_score": 0.09282, "epss_percentile": 0.92483}, "CVE-2008-3385": {"epss_score": 0.04949, "epss_percentile": 0.89321}, "CVE-2008-3386": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-3387": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3388": {"epss_score": 0.00411, "epss_percentile": 0.60877}, "CVE-2008-3389": {"epss_score": 0.00062, "epss_percentile": 0.19747}, "CVE-2008-3390": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-3391": {"epss_score": 0.00826, "epss_percentile": 0.73971}, "CVE-2008-3392": {"epss_score": 0.00261, "epss_percentile": 0.49311}, "CVE-2008-3393": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-3394": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-3395": {"epss_score": 0.00293, "epss_percentile": 0.52339}, "CVE-2008-3396": {"epss_score": 0.08798, "epss_percentile": 0.92258}, "CVE-2008-3397": {"epss_score": 0.00256, "epss_percentile": 0.48836}, "CVE-2008-3398": {"epss_score": 0.06494, "epss_percentile": 0.90799}, "CVE-2008-3399": {"epss_score": 0.02843, "epss_percentile": 0.85812}, "CVE-2008-3400": {"epss_score": 0.05992, "epss_percentile": 0.90388}, "CVE-2008-3401": {"epss_score": 0.06279, "epss_percentile": 0.90635}, "CVE-2008-3402": {"epss_score": 0.06279, "epss_percentile": 0.90635}, "CVE-2008-3403": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-3404": {"epss_score": 0.05185, "epss_percentile": 0.89587}, "CVE-2008-3405": {"epss_score": 0.03351, "epss_percentile": 0.86963}, "CVE-2008-3406": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3407": {"epss_score": 0.03287, "epss_percentile": 0.8683}, "CVE-2008-3408": {"epss_score": 0.44403, "epss_percentile": 0.97433}, "CVE-2008-3409": {"epss_score": 0.25815, "epss_percentile": 0.96075}, "CVE-2008-3410": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2008-3411": {"epss_score": 0.00796, "epss_percentile": 0.73478}, "CVE-2008-3412": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3413": {"epss_score": 0.00897, "epss_percentile": 0.75127}, "CVE-2008-3414": {"epss_score": 0.00767, "epss_percentile": 0.72954}, "CVE-2008-3415": {"epss_score": 0.07503, "epss_percentile": 0.91507}, "CVE-2008-3416": {"epss_score": 0.00801, "epss_percentile": 0.73576}, "CVE-2008-3417": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-3418": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-3419": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-3420": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-3421": {"epss_score": 0.00089, "epss_percentile": 0.25913}, "CVE-2008-3422": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2008-3423": {"epss_score": 0.00658, "epss_percentile": 0.70482}, "CVE-2008-3424": {"epss_score": 0.00646, "epss_percentile": 0.70148}, "CVE-2008-3425": {"epss_score": 0.0114, "epss_percentile": 0.77949}, "CVE-2008-3426": {"epss_score": 0.00069, "epss_percentile": 0.21619}, "CVE-2008-3428": {"epss_score": 0.00423, "epss_percentile": 0.61586}, "CVE-2008-3429": {"epss_score": 0.03784, "epss_percentile": 0.87723}, "CVE-2008-3430": {"epss_score": 0.05494, "epss_percentile": 0.89932}, "CVE-2008-3431": {"epss_score": 0.05378, "epss_percentile": 0.89805}, "CVE-2008-3432": {"epss_score": 0.18496, "epss_percentile": 0.95023}, "CVE-2008-3433": {"epss_score": 0.00696, "epss_percentile": 0.71388}, "CVE-2008-3434": {"epss_score": 0.00698, "epss_percentile": 0.71416}, "CVE-2008-3435": {"epss_score": 0.00651, "epss_percentile": 0.70293}, "CVE-2008-3436": {"epss_score": 0.00651, "epss_percentile": 0.70293}, "CVE-2008-3437": {"epss_score": 0.00779, "epss_percentile": 0.7315}, "CVE-2008-3438": {"epss_score": 0.0043, "epss_percentile": 0.62019}, "CVE-2008-3439": {"epss_score": 0.00696, "epss_percentile": 0.71388}, "CVE-2008-3440": {"epss_score": 0.00699, "epss_percentile": 0.71448}, "CVE-2008-3441": {"epss_score": 0.01077, "epss_percentile": 0.7734}, "CVE-2008-3442": {"epss_score": 0.00654, "epss_percentile": 0.7035}, "CVE-2008-3443": {"epss_score": 0.34188, "epss_percentile": 0.9683}, "CVE-2008-3444": {"epss_score": 0.00765, "epss_percentile": 0.72925}, "CVE-2008-3445": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-3446": {"epss_score": 0.03894, "epss_percentile": 0.87913}, "CVE-2008-3447": {"epss_score": 0.11328, "epss_percentile": 0.93311}, "CVE-2008-3448": {"epss_score": 0.04385, "epss_percentile": 0.88631}, "CVE-2008-3449": {"epss_score": 0.03423, "epss_percentile": 0.87108}, "CVE-2008-3450": {"epss_score": 0.00058, "epss_percentile": 0.18579}, "CVE-2008-3451": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2008-3452": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3453": {"epss_score": 0.00334, "epss_percentile": 0.55717}, "CVE-2008-3454": {"epss_score": 0.02485, "epss_percentile": 0.84884}, "CVE-2008-3455": {"epss_score": 0.02844, "epss_percentile": 0.85815}, "CVE-2008-3456": {"epss_score": 0.01706, "epss_percentile": 0.81857}, "CVE-2008-3457": {"epss_score": 0.00586, "epss_percentile": 0.68435}, "CVE-2008-3458": {"epss_score": 0.0099, "epss_percentile": 0.76375}, "CVE-2008-3459": {"epss_score": 0.00591, "epss_percentile": 0.68592}, "CVE-2008-3460": {"epss_score": 0.54907, "epss_percentile": 0.97951}, "CVE-2008-3464": {"epss_score": 0.01347, "epss_percentile": 0.7965}, "CVE-2008-3465": {"epss_score": 0.4575, "epss_percentile": 0.975}, "CVE-2008-3466": {"epss_score": 0.8472, "epss_percentile": 0.99302}, "CVE-2008-3471": {"epss_score": 0.70823, "epss_percentile": 0.98644}, "CVE-2008-3472": {"epss_score": 0.46045, "epss_percentile": 0.97519}, "CVE-2008-3473": {"epss_score": 0.47035, "epss_percentile": 0.97567}, "CVE-2008-3474": {"epss_score": 0.48916, "epss_percentile": 0.97659}, "CVE-2008-3475": {"epss_score": 0.59201, "epss_percentile": 0.98154}, "CVE-2008-3476": {"epss_score": 0.65051, "epss_percentile": 0.98402}, "CVE-2008-3477": {"epss_score": 0.73253, "epss_percentile": 0.98744}, "CVE-2008-3479": {"epss_score": 0.69094, "epss_percentile": 0.98579}, "CVE-2008-3480": {"epss_score": 0.1002, "epss_percentile": 0.92819}, "CVE-2008-3481": {"epss_score": 0.03584, "epss_percentile": 0.8739}, "CVE-2008-3482": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-3483": {"epss_score": 0.00399, "epss_percentile": 0.60137}, "CVE-2008-3484": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3485": {"epss_score": 0.00074, "epss_percentile": 0.22716}, "CVE-2008-3486": {"epss_score": 0.03894, "epss_percentile": 0.87914}, "CVE-2008-3487": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3488": {"epss_score": 0.00839, "epss_percentile": 0.74191}, "CVE-2008-3489": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3490": {"epss_score": 0.00371, "epss_percentile": 0.58361}, "CVE-2008-3491": {"epss_score": 0.03294, "epss_percentile": 0.86844}, "CVE-2008-3492": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-3493": {"epss_score": 0.02537, "epss_percentile": 0.85039}, "CVE-2008-3494": {"epss_score": 0.02956, "epss_percentile": 0.86062}, "CVE-2008-3495": {"epss_score": 0.00388, "epss_percentile": 0.59339}, "CVE-2008-3496": {"epss_score": 0.01168, "epss_percentile": 0.78196}, "CVE-2008-3497": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-3498": {"epss_score": 0.00877, "epss_percentile": 0.74799}, "CVE-2008-3499": {"epss_score": 0.00396, "epss_percentile": 0.59885}, "CVE-2008-3500": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-3501": {"epss_score": 0.01011, "epss_percentile": 0.76614}, "CVE-2008-3502": {"epss_score": 0.00513, "epss_percentile": 0.65938}, "CVE-2008-3503": {"epss_score": 0.00438, "epss_percentile": 0.6254}, "CVE-2008-3504": {"epss_score": 0.00308, "epss_percentile": 0.53624}, "CVE-2008-3505": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-3506": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3507": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3508": {"epss_score": 0.03287, "epss_percentile": 0.8683}, "CVE-2008-3509": {"epss_score": 0.15097, "epss_percentile": 0.94361}, "CVE-2008-3510": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-3511": {"epss_score": 0.00203, "epss_percentile": 0.42562}, "CVE-2008-3512": {"epss_score": 0.00234, "epss_percentile": 0.4609}, "CVE-2008-3513": {"epss_score": 0.01012, "epss_percentile": 0.76622}, "CVE-2008-3514": {"epss_score": 0.00475, "epss_percentile": 0.64194}, "CVE-2008-3515": {"epss_score": 0.01957, "epss_percentile": 0.83043}, "CVE-2008-3516": {"epss_score": 0.01957, "epss_percentile": 0.83043}, "CVE-2008-3519": {"epss_score": 0.00705, "epss_percentile": 0.71589}, "CVE-2008-3520": {"epss_score": 0.02999, "epss_percentile": 0.8616}, "CVE-2008-3521": {"epss_score": 0.00037, "epss_percentile": 0.10923}, "CVE-2008-3522": {"epss_score": 0.0425, "epss_percentile": 0.88451}, "CVE-2008-3524": {"epss_score": 0.00032, "epss_percentile": 0.08835}, "CVE-2008-3525": {"epss_score": 0.00061, "epss_percentile": 0.19513}, "CVE-2008-3526": {"epss_score": 0.01908, "epss_percentile": 0.82816}, "CVE-2008-3527": {"epss_score": 0.00065, "epss_percentile": 0.20523}, "CVE-2008-3528": {"epss_score": 0.00352, "epss_percentile": 0.57129}, "CVE-2008-3529": {"epss_score": 0.56626, "epss_percentile": 0.98031}, "CVE-2008-3530": {"epss_score": 0.06713, "epss_percentile": 0.90963}, "CVE-2008-3531": {"epss_score": 0.00315, "epss_percentile": 0.54195}, "CVE-2008-3532": {"epss_score": 0.03446, "epss_percentile": 0.87148}, "CVE-2008-3533": {"epss_score": 0.13368, "epss_percentile": 0.93944}, "CVE-2008-3534": {"epss_score": 0.00046, "epss_percentile": 0.14092}, "CVE-2008-3535": {"epss_score": 0.00047, "epss_percentile": 0.1448}, "CVE-2008-3536": {"epss_score": 0.04733, "epss_percentile": 0.89071}, "CVE-2008-3537": {"epss_score": 0.04733, "epss_percentile": 0.89071}, "CVE-2008-3538": {"epss_score": 0.00851, "epss_percentile": 0.74402}, "CVE-2008-3539": {"epss_score": 0.00118, "epss_percentile": 0.31476}, "CVE-2008-3542": {"epss_score": 0.01967, "epss_percentile": 0.83084}, "CVE-2008-3543": {"epss_score": 0.04733, "epss_percentile": 0.89071}, "CVE-2008-3544": {"epss_score": 0.3669, "epss_percentile": 0.96996}, "CVE-2008-3545": {"epss_score": 0.02728, "epss_percentile": 0.85533}, "CVE-2008-3546": {"epss_score": 0.01761, "epss_percentile": 0.8215}, "CVE-2008-3547": {"epss_score": 0.12671, "epss_percentile": 0.93745}, "CVE-2008-3548": {"epss_score": 0.00045, "epss_percentile": 0.13994}, "CVE-2008-3549": {"epss_score": 0.00054, "epss_percentile": 0.17322}, "CVE-2008-3550": {"epss_score": 0.00264, "epss_percentile": 0.49687}, "CVE-2008-3551": {"epss_score": 0.05429, "epss_percentile": 0.89874}, "CVE-2008-3552": {"epss_score": 0.0515, "epss_percentile": 0.89548}, "CVE-2008-3553": {"epss_score": 0.0515, "epss_percentile": 0.89548}, "CVE-2008-3554": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3555": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-3556": {"epss_score": 0.00323, "epss_percentile": 0.54862}, "CVE-2008-3557": {"epss_score": 0.02485, "epss_percentile": 0.84884}, "CVE-2008-3558": {"epss_score": 0.79896, "epss_percentile": 0.99059}, "CVE-2008-3559": {"epss_score": 0.00701, "epss_percentile": 0.71504}, "CVE-2008-3560": {"epss_score": 0.02524, "epss_percentile": 0.8501}, "CVE-2008-3561": {"epss_score": 0.00377, "epss_percentile": 0.58731}, "CVE-2008-3562": {"epss_score": 0.03064, "epss_percentile": 0.86323}, "CVE-2008-3563": {"epss_score": 0.0075, "epss_percentile": 0.72615}, "CVE-2008-3564": {"epss_score": 0.02479, "epss_percentile": 0.8487}, "CVE-2008-3565": {"epss_score": 0.00231, "epss_percentile": 0.45789}, "CVE-2008-3566": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-3567": {"epss_score": 0.00578, "epss_percentile": 0.68185}, "CVE-2008-3568": {"epss_score": 0.02081, "epss_percentile": 0.83534}, "CVE-2008-3569": {"epss_score": 0.00691, "epss_percentile": 0.71273}, "CVE-2008-3570": {"epss_score": 0.02843, "epss_percentile": 0.85812}, "CVE-2008-3571": {"epss_score": 0.13233, "epss_percentile": 0.93907}, "CVE-2008-3572": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-3573": {"epss_score": 0.02321, "epss_percentile": 0.84367}, "CVE-2008-3574": {"epss_score": 0.0217, "epss_percentile": 0.83871}, "CVE-2008-3575": {"epss_score": 0.01553, "epss_percentile": 0.80999}, "CVE-2008-3576": {"epss_score": 0.10352, "epss_percentile": 0.92955}, "CVE-2008-3577": {"epss_score": 0.0008, "epss_percentile": 0.24086}, "CVE-2008-3578": {"epss_score": 0.08839, "epss_percentile": 0.92279}, "CVE-2008-3579": {"epss_score": 0.00451, "epss_percentile": 0.63153}, "CVE-2008-3580": {"epss_score": 0.00767, "epss_percentile": 0.72954}, "CVE-2008-3581": {"epss_score": 0.03183, "epss_percentile": 0.86587}, "CVE-2008-3582": {"epss_score": 0.00323, "epss_percentile": 0.54862}, "CVE-2008-3583": {"epss_score": 0.25346, "epss_percentile": 0.96017}, "CVE-2008-3584": {"epss_score": 0.02484, "epss_percentile": 0.84881}, "CVE-2008-3585": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3586": {"epss_score": 0.00023, "epss_percentile": 0.05487}, "CVE-2008-3587": {"epss_score": 0.01823, "epss_percentile": 0.82421}, "CVE-2008-3588": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3589": {"epss_score": 0.04508, "epss_percentile": 0.88778}, "CVE-2008-3590": {"epss_score": 0.00224, "epss_percentile": 0.44983}, "CVE-2008-3591": {"epss_score": 0.00444, "epss_percentile": 0.62827}, "CVE-2008-3592": {"epss_score": 0.0609, "epss_percentile": 0.90472}, "CVE-2008-3593": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-3594": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-3595": {"epss_score": 0.02844, "epss_percentile": 0.85815}, "CVE-2008-3596": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-3597": {"epss_score": 0.03501, "epss_percentile": 0.87247}, "CVE-2008-3598": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-3599": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-3600": {"epss_score": 0.00335, "epss_percentile": 0.55851}, "CVE-2008-3601": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-3602": {"epss_score": 0.0223, "epss_percentile": 0.84084}, "CVE-2008-3603": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3604": {"epss_score": 0.02554, "epss_percentile": 0.85088}, "CVE-2008-3605": {"epss_score": 0.00973, "epss_percentile": 0.76161}, "CVE-2008-3606": {"epss_score": 0.14205, "epss_percentile": 0.94162}, "CVE-2008-3607": {"epss_score": 0.0351, "epss_percentile": 0.87265}, "CVE-2008-3608": {"epss_score": 0.0477, "epss_percentile": 0.89126}, "CVE-2008-3609": {"epss_score": 0.00058, "epss_percentile": 0.18468}, "CVE-2008-3610": {"epss_score": 0.00261, "epss_percentile": 0.49314}, "CVE-2008-3611": {"epss_score": 0.00055, "epss_percentile": 0.17435}, "CVE-2008-3612": {"epss_score": 0.02524, "epss_percentile": 0.8501}, "CVE-2008-3613": {"epss_score": 0.00295, "epss_percentile": 0.52471}, "CVE-2008-3614": {"epss_score": 0.32896, "epss_percentile": 0.96733}, "CVE-2008-3615": {"epss_score": 0.03565, "epss_percentile": 0.8736}, "CVE-2008-3616": {"epss_score": 0.01065, "epss_percentile": 0.77204}, "CVE-2008-3617": {"epss_score": 0.0032, "epss_percentile": 0.54618}, "CVE-2008-3618": {"epss_score": 0.00664, "epss_percentile": 0.70646}, "CVE-2008-3619": {"epss_score": 0.00051, "epss_percentile": 0.16135}, "CVE-2008-3621": {"epss_score": 0.03673, "epss_percentile": 0.87547}, "CVE-2008-3622": {"epss_score": 0.00453, "epss_percentile": 0.63218}, "CVE-2008-3623": {"epss_score": 0.19025, "epss_percentile": 0.95112}, "CVE-2008-3624": {"epss_score": 0.02523, "epss_percentile": 0.85008}, "CVE-2008-3625": {"epss_score": 0.17028, "epss_percentile": 0.94762}, "CVE-2008-3626": {"epss_score": 0.04008, "epss_percentile": 0.88106}, "CVE-2008-3627": {"epss_score": 0.17902, "epss_percentile": 0.94924}, "CVE-2008-3628": {"epss_score": 0.04937, "epss_percentile": 0.89303}, "CVE-2008-3629": {"epss_score": 0.01349, "epss_percentile": 0.79666}, "CVE-2008-3630": {"epss_score": 0.01104, "epss_percentile": 0.77599}, "CVE-2008-3631": {"epss_score": 0.00856, "epss_percentile": 0.74482}, "CVE-2008-3632": {"epss_score": 0.10568, "epss_percentile": 0.9303}, "CVE-2008-3634": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2008-3635": {"epss_score": 0.02414, "epss_percentile": 0.8468}, "CVE-2008-3636": {"epss_score": 0.00123, "epss_percentile": 0.3227}, "CVE-2008-3637": {"epss_score": 0.12476, "epss_percentile": 0.93684}, "CVE-2008-3638": {"epss_score": 0.01864, "epss_percentile": 0.82601}, "CVE-2008-3639": {"epss_score": 0.07958, "epss_percentile": 0.91789}, "CVE-2008-3640": {"epss_score": 0.0901, "epss_percentile": 0.92363}, "CVE-2008-3641": {"epss_score": 0.48025, "epss_percentile": 0.97615}, "CVE-2008-3642": {"epss_score": 0.20327, "epss_percentile": 0.95326}, "CVE-2008-3643": {"epss_score": 0.01028, "epss_percentile": 0.76815}, "CVE-2008-3644": {"epss_score": 0.00066, "epss_percentile": 0.20964}, "CVE-2008-3645": {"epss_score": 0.00068, "epss_percentile": 0.21349}, "CVE-2008-3646": {"epss_score": 0.00755, "epss_percentile": 0.72712}, "CVE-2008-3647": {"epss_score": 0.06607, "epss_percentile": 0.90884}, "CVE-2008-3648": {"epss_score": 0.40562, "epss_percentile": 0.97223}, "CVE-2008-3649": {"epss_score": 0.00897, "epss_percentile": 0.75127}, "CVE-2008-3650": {"epss_score": 0.00296, "epss_percentile": 0.52575}, "CVE-2008-3651": {"epss_score": 0.05064, "epss_percentile": 0.89456}, "CVE-2008-3652": {"epss_score": 0.20862, "epss_percentile": 0.9543}, "CVE-2008-3653": {"epss_score": 0.0033, "epss_percentile": 0.55416}, "CVE-2008-3654": {"epss_score": 0.00291, "epss_percentile": 0.52169}, "CVE-2008-3655": {"epss_score": 0.38828, "epss_percentile": 0.97122}, "CVE-2008-3656": {"epss_score": 0.73324, "epss_percentile": 0.98747}, "CVE-2008-3657": {"epss_score": 0.24926, "epss_percentile": 0.95965}, "CVE-2008-3658": {"epss_score": 0.10745, "epss_percentile": 0.9309}, "CVE-2008-3659": {"epss_score": 0.14232, "epss_percentile": 0.94167}, "CVE-2008-3660": {"epss_score": 0.15974, "epss_percentile": 0.94545}, "CVE-2008-3661": {"epss_score": 0.01803, "epss_percentile": 0.82342}, "CVE-2008-3662": {"epss_score": 0.00874, "epss_percentile": 0.7477}, "CVE-2008-3663": {"epss_score": 0.01255, "epss_percentile": 0.7893}, "CVE-2008-3664": {"epss_score": 0.00466, "epss_percentile": 0.638}, "CVE-2008-3666": {"epss_score": 0.00776, "epss_percentile": 0.73101}, "CVE-2008-3667": {"epss_score": 0.04469, "epss_percentile": 0.88732}, "CVE-2008-3668": {"epss_score": 0.00335, "epss_percentile": 0.55863}, "CVE-2008-3669": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-3670": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-3671": {"epss_score": 0.00221, "epss_percentile": 0.44677}, "CVE-2008-3672": {"epss_score": 0.00224, "epss_percentile": 0.44983}, "CVE-2008-3673": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-3674": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-3675": {"epss_score": 0.04508, "epss_percentile": 0.88778}, "CVE-2008-3676": {"epss_score": 0.09346, "epss_percentile": 0.9251}, "CVE-2008-3677": {"epss_score": 0.00161, "epss_percentile": 0.37609}, "CVE-2008-3678": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-3679": {"epss_score": 0.0116, "epss_percentile": 0.78133}, "CVE-2008-3680": {"epss_score": 0.1409, "epss_percentile": 0.94131}, "CVE-2008-3681": {"epss_score": 0.20835, "epss_percentile": 0.95421}, "CVE-2008-3682": {"epss_score": 0.00338, "epss_percentile": 0.56139}, "CVE-2008-3683": {"epss_score": 0.01659, "epss_percentile": 0.81616}, "CVE-2008-3684": {"epss_score": 0.03162, "epss_percentile": 0.86532}, "CVE-2008-3685": {"epss_score": 0.00704, "epss_percentile": 0.71553}, "CVE-2008-3686": {"epss_score": 0.00072, "epss_percentile": 0.22331}, "CVE-2008-3687": {"epss_score": 0.01613, "epss_percentile": 0.81341}, "CVE-2008-3688": {"epss_score": 0.02104, "epss_percentile": 0.83617}, "CVE-2008-3691": {"epss_score": 0.01635, "epss_percentile": 0.81469}, "CVE-2008-3692": {"epss_score": 0.01238, "epss_percentile": 0.78783}, "CVE-2008-3693": {"epss_score": 0.01238, "epss_percentile": 0.78783}, "CVE-2008-3694": {"epss_score": 0.01238, "epss_percentile": 0.78783}, "CVE-2008-3695": {"epss_score": 0.01238, "epss_percentile": 0.78783}, "CVE-2008-3696": {"epss_score": 0.01657, "epss_percentile": 0.81604}, "CVE-2008-3697": {"epss_score": 0.03153, "epss_percentile": 0.86509}, "CVE-2008-3698": {"epss_score": 0.00093, "epss_percentile": 0.26646}, "CVE-2008-3699": {"epss_score": 0.00034, "epss_percentile": 0.09565}, "CVE-2008-3700": {"epss_score": 0.03256, "epss_percentile": 0.86761}, "CVE-2008-3701": {"epss_score": 0.00414, "epss_percentile": 0.61106}, "CVE-2008-3702": {"epss_score": 0.05844, "epss_percentile": 0.90254}, "CVE-2008-3703": {"epss_score": 0.2454, "epss_percentile": 0.95931}, "CVE-2008-3704": {"epss_score": 0.87473, "epss_percentile": 0.9943}, "CVE-2008-3705": {"epss_score": 0.01221, "epss_percentile": 0.78647}, "CVE-2008-3706": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-3707": {"epss_score": 0.00619, "epss_percentile": 0.69401}, "CVE-2008-3708": {"epss_score": 0.03365, "epss_percentile": 0.87001}, "CVE-2008-3709": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-3710": {"epss_score": 0.00221, "epss_percentile": 0.44662}, "CVE-2008-3711": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-3712": {"epss_score": 0.04188, "epss_percentile": 0.88368}, "CVE-2008-3713": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-3714": {"epss_score": 0.04053, "epss_percentile": 0.88178}, "CVE-2008-3715": {"epss_score": 0.02903, "epss_percentile": 0.85958}, "CVE-2008-3716": {"epss_score": 0.00352, "epss_percentile": 0.57101}, "CVE-2008-3717": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2008-3718": {"epss_score": 0.00352, "epss_percentile": 0.57131}, "CVE-2008-3719": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-3720": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3721": {"epss_score": 0.02843, "epss_percentile": 0.85812}, "CVE-2008-3722": {"epss_score": 0.00388, "epss_percentile": 0.59339}, "CVE-2008-3723": {"epss_score": 0.03816, "epss_percentile": 0.87768}, "CVE-2008-3724": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2008-3725": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-3726": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2008-3727": {"epss_score": 0.005, "epss_percentile": 0.65318}, "CVE-2008-3728": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2008-3729": {"epss_score": 0.00659, "epss_percentile": 0.70498}, "CVE-2008-3730": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-3731": {"epss_score": 0.04021, "epss_percentile": 0.88131}, "CVE-2008-3732": {"epss_score": 0.32143, "epss_percentile": 0.96674}, "CVE-2008-3733": {"epss_score": 0.43029, "epss_percentile": 0.97367}, "CVE-2008-3734": {"epss_score": 0.69433, "epss_percentile": 0.98587}, "CVE-2008-3735": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-3736": {"epss_score": 0.00216, "epss_percentile": 0.44193}, "CVE-2008-3737": {"epss_score": 0.02078, "epss_percentile": 0.83519}, "CVE-2008-3738": {"epss_score": 0.00273, "epss_percentile": 0.50457}, "CVE-2008-3739": {"epss_score": 0.00705, "epss_percentile": 0.71583}, "CVE-2008-3740": {"epss_score": 0.00497, "epss_percentile": 0.65207}, "CVE-2008-3741": {"epss_score": 0.0035, "epss_percentile": 0.56977}, "CVE-2008-3742": {"epss_score": 0.02872, "epss_percentile": 0.85875}, "CVE-2008-3743": {"epss_score": 0.00433, "epss_percentile": 0.62181}, "CVE-2008-3744": {"epss_score": 0.00266, "epss_percentile": 0.49875}, "CVE-2008-3745": {"epss_score": 0.00958, "epss_percentile": 0.75949}, "CVE-2008-3746": {"epss_score": 0.01668, "epss_percentile": 0.8166}, "CVE-2008-3747": {"epss_score": 0.01436, "epss_percentile": 0.80277}, "CVE-2008-3748": {"epss_score": 0.00723, "epss_percentile": 0.72017}, "CVE-2008-3749": {"epss_score": 0.01028, "epss_percentile": 0.76817}, "CVE-2008-3750": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-3751": {"epss_score": 0.00763, "epss_percentile": 0.72892}, "CVE-2008-3752": {"epss_score": 0.00322, "epss_percentile": 0.54805}, "CVE-2008-3753": {"epss_score": 0.00481, "epss_percentile": 0.6451}, "CVE-2008-3754": {"epss_score": 0.00248, "epss_percentile": 0.47975}, "CVE-2008-3755": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-3756": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-3757": {"epss_score": 0.00763, "epss_percentile": 0.72892}, "CVE-2008-3758": {"epss_score": 0.0806, "epss_percentile": 0.9186}, "CVE-2008-3759": {"epss_score": 0.00202, "epss_percentile": 0.42404}, "CVE-2008-3760": {"epss_score": 0.00374, "epss_percentile": 0.58542}, "CVE-2008-3761": {"epss_score": 0.00181, "epss_percentile": 0.40077}, "CVE-2008-3762": {"epss_score": 0.01028, "epss_percentile": 0.76817}, "CVE-2008-3763": {"epss_score": 0.12084, "epss_percentile": 0.93563}, "CVE-2008-3764": {"epss_score": 0.10936, "epss_percentile": 0.93165}, "CVE-2008-3765": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-3766": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2008-3767": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-3768": {"epss_score": 0.01409, "epss_percentile": 0.80072}, "CVE-2008-3769": {"epss_score": 0.00667, "epss_percentile": 0.70721}, "CVE-2008-3770": {"epss_score": 0.05651, "epss_percentile": 0.90085}, "CVE-2008-3771": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-3772": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3773": {"epss_score": 0.03559, "epss_percentile": 0.87352}, "CVE-2008-3774": {"epss_score": 0.00322, "epss_percentile": 0.54805}, "CVE-2008-3775": {"epss_score": 0.00034, "epss_percentile": 0.09468}, "CVE-2008-3776": {"epss_score": 0.04565, "epss_percentile": 0.88856}, "CVE-2008-3777": {"epss_score": 0.00062, "epss_percentile": 0.19565}, "CVE-2008-3778": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2008-3779": {"epss_score": 0.03821, "epss_percentile": 0.87783}, "CVE-2008-3780": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-3781": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-3782": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2008-3783": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-3784": {"epss_score": 0.00916, "epss_percentile": 0.75415}, "CVE-2008-3785": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-3786": {"epss_score": 0.00346, "epss_percentile": 0.56656}, "CVE-2008-3787": {"epss_score": 0.00504, "epss_percentile": 0.65519}, "CVE-2008-3788": {"epss_score": 0.0053, "epss_percentile": 0.6662}, "CVE-2008-3789": {"epss_score": 0.01059, "epss_percentile": 0.77153}, "CVE-2008-3790": {"epss_score": 0.2338, "epss_percentile": 0.95772}, "CVE-2008-3791": {"epss_score": 0.00037, "epss_percentile": 0.10878}, "CVE-2008-3792": {"epss_score": 0.0444, "epss_percentile": 0.88693}, "CVE-2008-3794": {"epss_score": 0.19554, "epss_percentile": 0.95206}, "CVE-2008-3795": {"epss_score": 0.13755, "epss_percentile": 0.94049}, "CVE-2008-3796": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2008-3798": {"epss_score": 0.01255, "epss_percentile": 0.78933}, "CVE-2008-3799": {"epss_score": 0.01255, "epss_percentile": 0.78933}, "CVE-2008-3800": {"epss_score": 0.01935, "epss_percentile": 0.82958}, "CVE-2008-3801": {"epss_score": 0.01935, "epss_percentile": 0.82958}, "CVE-2008-3802": {"epss_score": 0.01004, "epss_percentile": 0.76524}, "CVE-2008-3803": {"epss_score": 0.01514, "epss_percentile": 0.80791}, "CVE-2008-3804": {"epss_score": 0.00621, "epss_percentile": 0.69459}, "CVE-2008-3805": {"epss_score": 0.01602, "epss_percentile": 0.81274}, "CVE-2008-3806": {"epss_score": 0.01255, "epss_percentile": 0.78933}, "CVE-2008-3807": {"epss_score": 0.0251, "epss_percentile": 0.8495}, "CVE-2008-3808": {"epss_score": 0.01672, "epss_percentile": 0.81677}, "CVE-2008-3809": {"epss_score": 0.0146, "epss_percentile": 0.80417}, "CVE-2008-3810": {"epss_score": 0.01918, "epss_percentile": 0.8288}, "CVE-2008-3811": {"epss_score": 0.01918, "epss_percentile": 0.8288}, "CVE-2008-3812": {"epss_score": 0.0146, "epss_percentile": 0.80417}, "CVE-2008-3813": {"epss_score": 0.01255, "epss_percentile": 0.78933}, "CVE-2008-3814": {"epss_score": 0.00481, "epss_percentile": 0.64486}, "CVE-2008-3815": {"epss_score": 0.00372, "epss_percentile": 0.58424}, "CVE-2008-3816": {"epss_score": 0.01194, "epss_percentile": 0.78413}, "CVE-2008-3817": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2008-3818": {"epss_score": 0.00864, "epss_percentile": 0.74601}, "CVE-2008-3819": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2008-3820": {"epss_score": 0.00973, "epss_percentile": 0.76161}, "CVE-2008-3821": {"epss_score": 0.10639, "epss_percentile": 0.93056}, "CVE-2008-3823": {"epss_score": 0.00802, "epss_percentile": 0.73587}, "CVE-2008-3824": {"epss_score": 0.00869, "epss_percentile": 0.74692}, "CVE-2008-3825": {"epss_score": 0.00053, "epss_percentile": 0.1694}, "CVE-2008-3826": {"epss_score": 0.00077, "epss_percentile": 0.2338}, "CVE-2008-3827": {"epss_score": 0.03588, "epss_percentile": 0.87396}, "CVE-2008-3828": {"epss_score": 0.00214, "epss_percentile": 0.43974}, "CVE-2008-3829": {"epss_score": 0.01076, "epss_percentile": 0.77327}, "CVE-2008-3830": {"epss_score": 0.00057, "epss_percentile": 0.182}, "CVE-2008-3831": {"epss_score": 0.00091, "epss_percentile": 0.26232}, "CVE-2008-3832": {"epss_score": 0.00108, "epss_percentile": 0.29788}, "CVE-2008-3833": {"epss_score": 0.00039, "epss_percentile": 0.11689}, "CVE-2008-3834": {"epss_score": 0.01853, "epss_percentile": 0.82545}, "CVE-2008-3835": {"epss_score": 0.00121, "epss_percentile": 0.32004}, "CVE-2008-3836": {"epss_score": 0.02943, "epss_percentile": 0.86036}, "CVE-2008-3837": {"epss_score": 0.03669, "epss_percentile": 0.87537}, "CVE-2008-3838": {"epss_score": 0.00056, "epss_percentile": 0.17687}, "CVE-2008-3839": {"epss_score": 0.00054, "epss_percentile": 0.17322}, "CVE-2008-3840": {"epss_score": 0.00422, "epss_percentile": 0.61539}, "CVE-2008-3841": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2008-3842": {"epss_score": 0.11493, "epss_percentile": 0.93383}, "CVE-2008-3843": {"epss_score": 0.11666, "epss_percentile": 0.93438}, "CVE-2008-3844": {"epss_score": 0.02746, "epss_percentile": 0.85574}, "CVE-2008-3845": {"epss_score": 0.01716, "epss_percentile": 0.81905}, "CVE-2008-3846": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-3847": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-3848": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3849": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-3850": {"epss_score": 0.00346, "epss_percentile": 0.56656}, "CVE-2008-3851": {"epss_score": 0.07419, "epss_percentile": 0.91464}, "CVE-2008-3852": {"epss_score": 0.03183, "epss_percentile": 0.86585}, "CVE-2008-3853": {"epss_score": 0.07984, "epss_percentile": 0.91803}, "CVE-2008-3854": {"epss_score": 0.07098, "epss_percentile": 0.91248}, "CVE-2008-3855": {"epss_score": 0.00062, "epss_percentile": 0.19613}, "CVE-2008-3856": {"epss_score": 0.00833, "epss_percentile": 0.74096}, "CVE-2008-3857": {"epss_score": 0.00059, "epss_percentile": 0.18809}, "CVE-2008-3858": {"epss_score": 0.01001, "epss_percentile": 0.76499}, "CVE-2008-3859": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2008-3860": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2008-3861": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-3862": {"epss_score": 0.34509, "epss_percentile": 0.96851}, "CVE-2008-3863": {"epss_score": 0.24697, "epss_percentile": 0.95947}, "CVE-2008-3864": {"epss_score": 0.01657, "epss_percentile": 0.81606}, "CVE-2008-3865": {"epss_score": 0.29345, "epss_percentile": 0.96434}, "CVE-2008-3866": {"epss_score": 0.00142, "epss_percentile": 0.34978}, "CVE-2008-3867": {"epss_score": 0.00661, "epss_percentile": 0.70572}, "CVE-2008-3868": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2008-3869": {"epss_score": 0.3328, "epss_percentile": 0.96759}, "CVE-2008-3870": {"epss_score": 0.3062, "epss_percentile": 0.96556}, "CVE-2008-3871": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2008-3872": {"epss_score": 0.02149, "epss_percentile": 0.83776}, "CVE-2008-3873": {"epss_score": 0.05143, "epss_percentile": 0.8954}, "CVE-2008-3874": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2008-3875": {"epss_score": 0.00057, "epss_percentile": 0.18004}, "CVE-2008-3876": {"epss_score": 0.00062, "epss_percentile": 0.19772}, "CVE-2008-3877": {"epss_score": 0.19453, "epss_percentile": 0.95184}, "CVE-2008-3878": {"epss_score": 0.7193, "epss_percentile": 0.98687}, "CVE-2008-3879": {"epss_score": 0.12164, "epss_percentile": 0.93587}, "CVE-2008-3880": {"epss_score": 0.00422, "epss_percentile": 0.61558}, "CVE-2008-3881": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-3882": {"epss_score": 0.0468, "epss_percentile": 0.88999}, "CVE-2008-3883": {"epss_score": 0.00027, "epss_percentile": 0.06882}, "CVE-2008-3884": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-3885": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2008-3886": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-3887": {"epss_score": 0.0037, "epss_percentile": 0.58337}, "CVE-2008-3888": {"epss_score": 0.00503, "epss_percentile": 0.65482}, "CVE-2008-3889": {"epss_score": 0.00064, "epss_percentile": 0.20337}, "CVE-2008-3890": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2008-3891": {"epss_score": 0.00183, "epss_percentile": 0.40292}, "CVE-2008-3892": {"epss_score": 0.66003, "epss_percentile": 0.98446}, "CVE-2008-3893": {"epss_score": 0.00822, "epss_percentile": 0.7392}, "CVE-2008-3894": {"epss_score": 0.00058, "epss_percentile": 0.18281}, "CVE-2008-3895": {"epss_score": 0.00064, "epss_percentile": 0.2031}, "CVE-2008-3896": {"epss_score": 0.00065, "epss_percentile": 0.20594}, "CVE-2008-3897": {"epss_score": 0.00064, "epss_percentile": 0.2031}, "CVE-2008-3898": {"epss_score": 0.00065, "epss_percentile": 0.20444}, "CVE-2008-3899": {"epss_score": 0.00064, "epss_percentile": 0.2031}, "CVE-2008-3900": {"epss_score": 0.00092, "epss_percentile": 0.26481}, "CVE-2008-3901": {"epss_score": 0.00048, "epss_percentile": 0.15048}, "CVE-2008-3902": {"epss_score": 0.00112, "epss_percentile": 0.30553}, "CVE-2008-3903": {"epss_score": 0.00666, "epss_percentile": 0.70682}, "CVE-2008-3904": {"epss_score": 0.00684, "epss_percentile": 0.71117}, "CVE-2008-3905": {"epss_score": 0.03225, "epss_percentile": 0.86684}, "CVE-2008-3906": {"epss_score": 0.07616, "epss_percentile": 0.9157}, "CVE-2008-3907": {"epss_score": 0.00731, "epss_percentile": 0.72184}, "CVE-2008-3908": {"epss_score": 0.02927, "epss_percentile": 0.8601}, "CVE-2008-3909": {"epss_score": 0.00358, "epss_percentile": 0.57498}, "CVE-2008-3910": {"epss_score": 0.01104, "epss_percentile": 0.776}, "CVE-2008-3911": {"epss_score": 0.00047, "epss_percentile": 0.14799}, "CVE-2008-3912": {"epss_score": 0.03454, "epss_percentile": 0.87168}, "CVE-2008-3913": {"epss_score": 0.04359, "epss_percentile": 0.88593}, "CVE-2008-3914": {"epss_score": 0.02011, "epss_percentile": 0.8325}, "CVE-2008-3915": {"epss_score": 0.0445, "epss_percentile": 0.88704}, "CVE-2008-3916": {"epss_score": 0.0467, "epss_percentile": 0.88985}, "CVE-2008-3917": {"epss_score": 0.02903, "epss_percentile": 0.85958}, "CVE-2008-3918": {"epss_score": 0.00246, "epss_percentile": 0.47758}, "CVE-2008-3919": {"epss_score": 0.06463, "epss_percentile": 0.90771}, "CVE-2008-3920": {"epss_score": 0.01449, "epss_percentile": 0.80339}, "CVE-2008-3921": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-3922": {"epss_score": 0.91414, "epss_percentile": 0.99641}, "CVE-2008-3923": {"epss_score": 0.03701, "epss_percentile": 0.8759}, "CVE-2008-3924": {"epss_score": 0.05992, "epss_percentile": 0.90388}, "CVE-2008-3925": {"epss_score": 0.00588, "epss_percentile": 0.68501}, "CVE-2008-3926": {"epss_score": 0.06949, "epss_percentile": 0.91136}, "CVE-2008-3927": {"epss_score": 0.00022, "epss_percentile": 0.05258}, "CVE-2008-3928": {"epss_score": 0.00034, "epss_percentile": 0.09715}, "CVE-2008-3929": {"epss_score": 0.00034, "epss_percentile": 0.09715}, "CVE-2008-3930": {"epss_score": 0.00027, "epss_percentile": 0.06882}, "CVE-2008-3931": {"epss_score": 0.00026, "epss_percentile": 0.06656}, "CVE-2008-3932": {"epss_score": 0.0073, "epss_percentile": 0.72152}, "CVE-2008-3933": {"epss_score": 0.0017, "epss_percentile": 0.3869}, "CVE-2008-3934": {"epss_score": 0.0017, "epss_percentile": 0.3869}, "CVE-2008-3935": {"epss_score": 0.00419, "epss_percentile": 0.61384}, "CVE-2008-3936": {"epss_score": 0.02396, "epss_percentile": 0.84619}, "CVE-2008-3937": {"epss_score": 0.00407, "epss_percentile": 0.60568}, "CVE-2008-3938": {"epss_score": 0.00269, "epss_percentile": 0.50157}, "CVE-2008-3939": {"epss_score": 0.00159, "epss_percentile": 0.37355}, "CVE-2008-3940": {"epss_score": 0.00083, "epss_percentile": 0.2475}, "CVE-2008-3941": {"epss_score": 0.01611, "epss_percentile": 0.81324}, "CVE-2008-3942": {"epss_score": 0.00284, "epss_percentile": 0.51464}, "CVE-2008-3943": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-3944": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3945": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-3946": {"epss_score": 0.00065, "epss_percentile": 0.20654}, "CVE-2008-3947": {"epss_score": 0.0005, "epss_percentile": 0.15729}, "CVE-2008-3948": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2008-3949": {"epss_score": 0.00073, "epss_percentile": 0.22674}, "CVE-2008-3950": {"epss_score": 0.06136, "epss_percentile": 0.90509}, "CVE-2008-3951": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3952": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3953": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-3954": {"epss_score": 0.01435, "epss_percentile": 0.80267}, "CVE-2008-3955": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-3956": {"epss_score": 0.43644, "epss_percentile": 0.97396}, "CVE-2008-3957": {"epss_score": 0.40104, "epss_percentile": 0.97196}, "CVE-2008-3958": {"epss_score": 0.01342, "epss_percentile": 0.79598}, "CVE-2008-3959": {"epss_score": 0.00885, "epss_percentile": 0.74935}, "CVE-2008-3960": {"epss_score": 0.01419, "epss_percentile": 0.80162}, "CVE-2008-3961": {"epss_score": 0.04896, "epss_percentile": 0.89269}, "CVE-2008-3962": {"epss_score": 0.00608, "epss_percentile": 0.69065}, "CVE-2008-3963": {"epss_score": 0.05591, "epss_percentile": 0.90029}, "CVE-2008-3964": {"epss_score": 0.01708, "epss_percentile": 0.81867}, "CVE-2008-3965": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2008-3966": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-3967": {"epss_score": 0.00628, "epss_percentile": 0.69649}, "CVE-2008-3968": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-3969": {"epss_score": 0.00814, "epss_percentile": 0.73773}, "CVE-2008-3970": {"epss_score": 0.00041, "epss_percentile": 0.12325}, "CVE-2008-3971": {"epss_score": 0.04251, "epss_percentile": 0.88451}, "CVE-2008-3972": {"epss_score": 0.00111, "epss_percentile": 0.3038}, "CVE-2008-3973": {"epss_score": 0.00082, "epss_percentile": 0.2457}, "CVE-2008-3974": {"epss_score": 0.00872, "epss_percentile": 0.74725}, "CVE-2008-3975": {"epss_score": 0.00453, "epss_percentile": 0.63225}, "CVE-2008-3976": {"epss_score": 0.00427, "epss_percentile": 0.61907}, "CVE-2008-3977": {"epss_score": 0.00453, "epss_percentile": 0.63225}, "CVE-2008-3978": {"epss_score": 0.00358, "epss_percentile": 0.57493}, "CVE-2008-3979": {"epss_score": 0.51598, "epss_percentile": 0.97788}, "CVE-2008-3980": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-3981": {"epss_score": 0.00389, "epss_percentile": 0.59472}, "CVE-2008-3982": {"epss_score": 0.53142, "epss_percentile": 0.97858}, "CVE-2008-3983": {"epss_score": 0.67346, "epss_percentile": 0.98503}, "CVE-2008-3984": {"epss_score": 0.67346, "epss_percentile": 0.98503}, "CVE-2008-3985": {"epss_score": 0.0032, "epss_percentile": 0.54573}, "CVE-2008-3986": {"epss_score": 0.00186, "epss_percentile": 0.40607}, "CVE-2008-3987": {"epss_score": 0.00186, "epss_percentile": 0.40607}, "CVE-2008-3988": {"epss_score": 0.0032, "epss_percentile": 0.54573}, "CVE-2008-3989": {"epss_score": 0.00565, "epss_percentile": 0.67803}, "CVE-2008-3990": {"epss_score": 0.00565, "epss_percentile": 0.67803}, "CVE-2008-3991": {"epss_score": 0.00801, "epss_percentile": 0.73562}, "CVE-2008-3992": {"epss_score": 0.00197, "epss_percentile": 0.41957}, "CVE-2008-3993": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-3994": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-3995": {"epss_score": 0.47398, "epss_percentile": 0.97585}, "CVE-2008-3996": {"epss_score": 0.37808, "epss_percentile": 0.97071}, "CVE-2008-3997": {"epss_score": 0.00565, "epss_percentile": 0.67803}, "CVE-2008-3998": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-3999": {"epss_score": 0.0132, "epss_percentile": 0.79441}, "CVE-2008-4000": {"epss_score": 0.01061, "epss_percentile": 0.77176}, "CVE-2008-4001": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-4002": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-4003": {"epss_score": 0.0032, "epss_percentile": 0.54573}, "CVE-2008-4004": {"epss_score": 0.00186, "epss_percentile": 0.40607}, "CVE-2008-4005": {"epss_score": 0.00604, "epss_percentile": 0.68959}, "CVE-2008-4006": {"epss_score": 0.01774, "epss_percentile": 0.82213}, "CVE-2008-4007": {"epss_score": 0.00688, "epss_percentile": 0.71203}, "CVE-2008-4008": {"epss_score": 0.85806, "epss_percentile": 0.9935}, "CVE-2008-4009": {"epss_score": 0.00858, "epss_percentile": 0.74511}, "CVE-2008-4010": {"epss_score": 0.00803, "epss_percentile": 0.73606}, "CVE-2008-4011": {"epss_score": 0.00167, "epss_percentile": 0.383}, "CVE-2008-4012": {"epss_score": 0.00858, "epss_percentile": 0.74511}, "CVE-2008-4013": {"epss_score": 0.00569, "epss_percentile": 0.67922}, "CVE-2008-4014": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-4015": {"epss_score": 0.00544, "epss_percentile": 0.6713}, "CVE-2008-4016": {"epss_score": 0.00248, "epss_percentile": 0.47925}, "CVE-2008-4017": {"epss_score": 0.0032, "epss_percentile": 0.54573}, "CVE-2008-4018": {"epss_score": 0.00048, "epss_percentile": 0.15152}, "CVE-2008-4019": {"epss_score": 0.63921, "epss_percentile": 0.98355}, "CVE-2008-4020": {"epss_score": 0.31298, "epss_percentile": 0.96607}, "CVE-2008-4023": {"epss_score": 0.62764, "epss_percentile": 0.98307}, "CVE-2008-4024": {"epss_score": 0.57487, "epss_percentile": 0.98066}, "CVE-2008-4025": {"epss_score": 0.65689, "epss_percentile": 0.98433}, "CVE-2008-4026": {"epss_score": 0.57941, "epss_percentile": 0.98091}, "CVE-2008-4027": {"epss_score": 0.6586, "epss_percentile": 0.9844}, "CVE-2008-4028": {"epss_score": 0.69893, "epss_percentile": 0.98608}, "CVE-2008-4029": {"epss_score": 0.59731, "epss_percentile": 0.98177}, "CVE-2008-4030": {"epss_score": 0.59894, "epss_percentile": 0.98186}, "CVE-2008-4031": {"epss_score": 0.59894, "epss_percentile": 0.98186}, "CVE-2008-4032": {"epss_score": 0.59434, "epss_percentile": 0.98164}, "CVE-2008-4033": {"epss_score": 0.62579, "epss_percentile": 0.98298}, "CVE-2008-4036": {"epss_score": 0.01126, "epss_percentile": 0.77817}, "CVE-2008-4037": {"epss_score": 0.7553, "epss_percentile": 0.98851}, "CVE-2008-4038": {"epss_score": 0.70091, "epss_percentile": 0.98615}, "CVE-2008-4039": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-4040": {"epss_score": 0.00256, "epss_percentile": 0.48777}, "CVE-2008-4041": {"epss_score": 0.04187, "epss_percentile": 0.88364}, "CVE-2008-4043": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4044": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4045": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-4046": {"epss_score": 0.00378, "epss_percentile": 0.58776}, "CVE-2008-4047": {"epss_score": 0.01277, "epss_percentile": 0.79115}, "CVE-2008-4048": {"epss_score": 0.08303, "epss_percentile": 0.91979}, "CVE-2008-4049": {"epss_score": 0.04641, "epss_percentile": 0.88952}, "CVE-2008-4050": {"epss_score": 0.11445, "epss_percentile": 0.93363}, "CVE-2008-4051": {"epss_score": 0.00505, "epss_percentile": 0.65612}, "CVE-2008-4052": {"epss_score": 0.00063, "epss_percentile": 0.201}, "CVE-2008-4053": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-4054": {"epss_score": 0.00499, "epss_percentile": 0.65278}, "CVE-2008-4055": {"epss_score": 0.00555, "epss_percentile": 0.67474}, "CVE-2008-4056": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-4057": {"epss_score": 0.00378, "epss_percentile": 0.58821}, "CVE-2008-4058": {"epss_score": 0.0348, "epss_percentile": 0.87218}, "CVE-2008-4059": {"epss_score": 0.0172, "epss_percentile": 0.81932}, "CVE-2008-4060": {"epss_score": 0.02018, "epss_percentile": 0.83286}, "CVE-2008-4061": {"epss_score": 0.03898, "epss_percentile": 0.87918}, "CVE-2008-4062": {"epss_score": 0.0291, "epss_percentile": 0.8597}, "CVE-2008-4063": {"epss_score": 0.02887, "epss_percentile": 0.85913}, "CVE-2008-4064": {"epss_score": 0.02287, "epss_percentile": 0.84269}, "CVE-2008-4065": {"epss_score": 0.0134, "epss_percentile": 0.79576}, "CVE-2008-4066": {"epss_score": 0.01204, "epss_percentile": 0.78505}, "CVE-2008-4067": {"epss_score": 0.02059, "epss_percentile": 0.83437}, "CVE-2008-4068": {"epss_score": 0.00268, "epss_percentile": 0.50043}, "CVE-2008-4069": {"epss_score": 0.01296, "epss_percentile": 0.79255}, "CVE-2008-4070": {"epss_score": 0.02832, "epss_percentile": 0.85778}, "CVE-2008-4071": {"epss_score": 0.06057, "epss_percentile": 0.90439}, "CVE-2008-4072": {"epss_score": 0.01112, "epss_percentile": 0.77673}, "CVE-2008-4073": {"epss_score": 0.0063, "epss_percentile": 0.69689}, "CVE-2008-4074": {"epss_score": 0.00582, "epss_percentile": 0.68305}, "CVE-2008-4075": {"epss_score": 0.03461, "epss_percentile": 0.8718}, "CVE-2008-4076": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-4077": {"epss_score": 0.01977, "epss_percentile": 0.83123}, "CVE-2008-4078": {"epss_score": 0.00694, "epss_percentile": 0.71347}, "CVE-2008-4079": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-4080": {"epss_score": 0.01336, "epss_percentile": 0.79552}, "CVE-2008-4081": {"epss_score": 0.02259, "epss_percentile": 0.84184}, "CVE-2008-4082": {"epss_score": 0.0042, "epss_percentile": 0.61422}, "CVE-2008-4083": {"epss_score": 0.00521, "epss_percentile": 0.66225}, "CVE-2008-4084": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-4085": {"epss_score": 0.00037, "epss_percentile": 0.11008}, "CVE-2008-4086": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-4087": {"epss_score": 0.04301, "epss_percentile": 0.88516}, "CVE-2008-4088": {"epss_score": 0.00767, "epss_percentile": 0.72954}, "CVE-2008-4089": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-4090": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4091": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-4092": {"epss_score": 0.00767, "epss_percentile": 0.72954}, "CVE-2008-4093": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4094": {"epss_score": 0.03119, "epss_percentile": 0.86446}, "CVE-2008-4095": {"epss_score": 0.00758, "epss_percentile": 0.72764}, "CVE-2008-4096": {"epss_score": 0.15869, "epss_percentile": 0.94523}, "CVE-2008-4097": {"epss_score": 0.00719, "epss_percentile": 0.71948}, "CVE-2008-4098": {"epss_score": 0.00346, "epss_percentile": 0.5671}, "CVE-2008-4099": {"epss_score": 0.00724, "epss_percentile": 0.72038}, "CVE-2008-4100": {"epss_score": 0.0061, "epss_percentile": 0.69141}, "CVE-2008-4101": {"epss_score": 0.11429, "epss_percentile": 0.93346}, "CVE-2008-4102": {"epss_score": 0.00072, "epss_percentile": 0.22429}, "CVE-2008-4103": {"epss_score": 0.0004, "epss_percentile": 0.12062}, "CVE-2008-4104": {"epss_score": 9e-05, "epss_percentile": 0.00644}, "CVE-2008-4105": {"epss_score": 0.00289, "epss_percentile": 0.52001}, "CVE-2008-4106": {"epss_score": 0.14591, "epss_percentile": 0.94247}, "CVE-2008-4107": {"epss_score": 0.10372, "epss_percentile": 0.92963}, "CVE-2008-4108": {"epss_score": 0.00057, "epss_percentile": 0.18107}, "CVE-2008-4109": {"epss_score": 0.01128, "epss_percentile": 0.77834}, "CVE-2008-4110": {"epss_score": 0.38292, "epss_percentile": 0.97093}, "CVE-2008-4111": {"epss_score": 0.0104, "epss_percentile": 0.76956}, "CVE-2008-4113": {"epss_score": 0.0019, "epss_percentile": 0.41059}, "CVE-2008-4114": {"epss_score": 0.73659, "epss_percentile": 0.98765}, "CVE-2008-4115": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2008-4116": {"epss_score": 0.09592, "epss_percentile": 0.92613}, "CVE-2008-4117": {"epss_score": 0.01367, "epss_percentile": 0.79783}, "CVE-2008-4118": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-4119": {"epss_score": 0.00757, "epss_percentile": 0.72763}, "CVE-2008-4120": {"epss_score": 0.05616, "epss_percentile": 0.90055}, "CVE-2008-4121": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2008-4122": {"epss_score": 0.00018, "epss_percentile": 0.0394}, "CVE-2008-4125": {"epss_score": 0.00221, "epss_percentile": 0.44677}, "CVE-2008-4126": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2008-4127": {"epss_score": 0.23583, "epss_percentile": 0.95795}, "CVE-2008-4128": {"epss_score": 0.02304, "epss_percentile": 0.8432}, "CVE-2008-4129": {"epss_score": 0.00586, "epss_percentile": 0.68436}, "CVE-2008-4130": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2008-4131": {"epss_score": 0.00227, "epss_percentile": 0.45367}, "CVE-2008-4132": {"epss_score": 0.04785, "epss_percentile": 0.89141}, "CVE-2008-4133": {"epss_score": 0.08883, "epss_percentile": 0.923}, "CVE-2008-4134": {"epss_score": 0.04529, "epss_percentile": 0.88809}, "CVE-2008-4135": {"epss_score": 0.15159, "epss_percentile": 0.94376}, "CVE-2008-4136": {"epss_score": 0.11456, "epss_percentile": 0.93367}, "CVE-2008-4137": {"epss_score": 0.04755, "epss_percentile": 0.89112}, "CVE-2008-4138": {"epss_score": 0.03623, "epss_percentile": 0.87446}, "CVE-2008-4139": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-4140": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-4141": {"epss_score": 0.07602, "epss_percentile": 0.91563}, "CVE-2008-4142": {"epss_score": 0.00879, "epss_percentile": 0.74846}, "CVE-2008-4143": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2008-4144": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-4145": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4146": {"epss_score": 0.04072, "epss_percentile": 0.88206}, "CVE-2008-4147": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-4148": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-4149": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-4150": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4151": {"epss_score": 0.03885, "epss_percentile": 0.87902}, "CVE-2008-4152": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2008-4153": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2008-4154": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4155": {"epss_score": 0.03885, "epss_percentile": 0.87902}, "CVE-2008-4156": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4157": {"epss_score": 0.04026, "epss_percentile": 0.88143}, "CVE-2008-4158": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-4159": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4160": {"epss_score": 0.00052, "epss_percentile": 0.16377}, "CVE-2008-4161": {"epss_score": 0.0039, "epss_percentile": 0.59531}, "CVE-2008-4162": {"epss_score": 0.00136, "epss_percentile": 0.34125}, "CVE-2008-4163": {"epss_score": 0.26697, "epss_percentile": 0.96167}, "CVE-2008-4164": {"epss_score": 0.05093, "epss_percentile": 0.89488}, "CVE-2008-4165": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2008-4166": {"epss_score": 0.0351, "epss_percentile": 0.87265}, "CVE-2008-4167": {"epss_score": 0.04736, "epss_percentile": 0.89074}, "CVE-2008-4168": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-4169": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-4170": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2008-4171": {"epss_score": 0.00341, "epss_percentile": 0.56296}, "CVE-2008-4172": {"epss_score": 0.00284, "epss_percentile": 0.51464}, "CVE-2008-4173": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4174": {"epss_score": 0.01918, "epss_percentile": 0.82882}, "CVE-2008-4175": {"epss_score": 0.00653, "epss_percentile": 0.70332}, "CVE-2008-4176": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4177": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4178": {"epss_score": 0.03815, "epss_percentile": 0.87767}, "CVE-2008-4179": {"epss_score": 0.02174, "epss_percentile": 0.83877}, "CVE-2008-4180": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2008-4181": {"epss_score": 0.09012, "epss_percentile": 0.92364}, "CVE-2008-4182": {"epss_score": 0.00441, "epss_percentile": 0.62654}, "CVE-2008-4183": {"epss_score": 0.10277, "epss_percentile": 0.92923}, "CVE-2008-4184": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-4185": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-4186": {"epss_score": 0.00224, "epss_percentile": 0.44983}, "CVE-2008-4187": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-4188": {"epss_score": 0.03481, "epss_percentile": 0.8722}, "CVE-2008-4190": {"epss_score": 0.00173, "epss_percentile": 0.39098}, "CVE-2008-4191": {"epss_score": 0.00057, "epss_percentile": 0.18183}, "CVE-2008-4192": {"epss_score": 0.00131, "epss_percentile": 0.33399}, "CVE-2008-4193": {"epss_score": 0.80446, "epss_percentile": 0.99088}, "CVE-2008-4194": {"epss_score": 0.11657, "epss_percentile": 0.93436}, "CVE-2008-4195": {"epss_score": 0.0068, "epss_percentile": 0.71034}, "CVE-2008-4196": {"epss_score": 0.00781, "epss_percentile": 0.73189}, "CVE-2008-4197": {"epss_score": 0.0508, "epss_percentile": 0.89471}, "CVE-2008-4198": {"epss_score": 0.00957, "epss_percentile": 0.75933}, "CVE-2008-4199": {"epss_score": 0.00827, "epss_percentile": 0.73989}, "CVE-2008-4200": {"epss_score": 0.01939, "epss_percentile": 0.82975}, "CVE-2008-4201": {"epss_score": 0.0655, "epss_percentile": 0.90843}, "CVE-2008-4202": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-4203": {"epss_score": 0.00304, "epss_percentile": 0.53276}, "CVE-2008-4204": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4205": {"epss_score": 0.00879, "epss_percentile": 0.74846}, "CVE-2008-4206": {"epss_score": 0.07602, "epss_percentile": 0.91563}, "CVE-2008-4207": {"epss_score": 0.09819, "epss_percentile": 0.92716}, "CVE-2008-4208": {"epss_score": 0.00378, "epss_percentile": 0.58821}, "CVE-2008-4210": {"epss_score": 0.113, "epss_percentile": 0.93298}, "CVE-2008-4211": {"epss_score": 0.13955, "epss_percentile": 0.941}, "CVE-2008-4212": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2008-4214": {"epss_score": 0.00069, "epss_percentile": 0.21501}, "CVE-2008-4215": {"epss_score": 0.00707, "epss_percentile": 0.71641}, "CVE-2008-4216": {"epss_score": 0.0064, "epss_percentile": 0.69977}, "CVE-2008-4217": {"epss_score": 0.05274, "epss_percentile": 0.89682}, "CVE-2008-4218": {"epss_score": 0.00054, "epss_percentile": 0.17085}, "CVE-2008-4219": {"epss_score": 0.00073, "epss_percentile": 0.22487}, "CVE-2008-4220": {"epss_score": 0.0089, "epss_percentile": 0.75034}, "CVE-2008-4221": {"epss_score": 0.0089, "epss_percentile": 0.75034}, "CVE-2008-4222": {"epss_score": 0.00242, "epss_percentile": 0.47409}, "CVE-2008-4223": {"epss_score": 0.01666, "epss_percentile": 0.81654}, "CVE-2008-4224": {"epss_score": 0.00675, "epss_percentile": 0.70884}, "CVE-2008-4225": {"epss_score": 0.01397, "epss_percentile": 0.79984}, "CVE-2008-4226": {"epss_score": 0.02789, "epss_percentile": 0.85664}, "CVE-2008-4227": {"epss_score": 0.00737, "epss_percentile": 0.7233}, "CVE-2008-4228": {"epss_score": 0.00067, "epss_percentile": 0.21069}, "CVE-2008-4229": {"epss_score": 0.00056, "epss_percentile": 0.17869}, "CVE-2008-4230": {"epss_score": 0.00066, "epss_percentile": 0.20955}, "CVE-2008-4231": {"epss_score": 0.07665, "epss_percentile": 0.9161}, "CVE-2008-4232": {"epss_score": 0.00881, "epss_percentile": 0.74862}, "CVE-2008-4233": {"epss_score": 0.01155, "epss_percentile": 0.78073}, "CVE-2008-4234": {"epss_score": 0.04966, "epss_percentile": 0.89343}, "CVE-2008-4236": {"epss_score": 0.00603, "epss_percentile": 0.68898}, "CVE-2008-4237": {"epss_score": 0.00524, "epss_percentile": 0.66321}, "CVE-2008-4241": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-4242": {"epss_score": 0.03385, "epss_percentile": 0.87039}, "CVE-2008-4243": {"epss_score": 0.17706, "epss_percentile": 0.94893}, "CVE-2008-4244": {"epss_score": 0.02413, "epss_percentile": 0.84677}, "CVE-2008-4245": {"epss_score": 0.03779, "epss_percentile": 0.87718}, "CVE-2008-4246": {"epss_score": 0.00388, "epss_percentile": 0.59375}, "CVE-2008-4247": {"epss_score": 0.1261, "epss_percentile": 0.93728}, "CVE-2008-4250": {"epss_score": 0.94038, "epss_percentile": 0.9989}, "CVE-2008-4252": {"epss_score": 0.57462, "epss_percentile": 0.98064}, "CVE-2008-4253": {"epss_score": 0.57462, "epss_percentile": 0.98064}, "CVE-2008-4254": {"epss_score": 0.55037, "epss_percentile": 0.97958}, "CVE-2008-4255": {"epss_score": 0.65731, "epss_percentile": 0.98436}, "CVE-2008-4256": {"epss_score": 0.57462, "epss_percentile": 0.98064}, "CVE-2008-4258": {"epss_score": 0.52719, "epss_percentile": 0.97837}, "CVE-2008-4259": {"epss_score": 0.58728, "epss_percentile": 0.98133}, "CVE-2008-4260": {"epss_score": 0.50947, "epss_percentile": 0.97757}, "CVE-2008-4261": {"epss_score": 0.64442, "epss_percentile": 0.98379}, "CVE-2008-4264": {"epss_score": 0.6248, "epss_percentile": 0.98294}, "CVE-2008-4265": {"epss_score": 0.6248, "epss_percentile": 0.98294}, "CVE-2008-4266": {"epss_score": 0.5929, "epss_percentile": 0.98159}, "CVE-2008-4268": {"epss_score": 0.50335, "epss_percentile": 0.97732}, "CVE-2008-4269": {"epss_score": 0.57772, "epss_percentile": 0.98082}, "CVE-2008-4278": {"epss_score": 0.00061, "epss_percentile": 0.19278}, "CVE-2008-4279": {"epss_score": 0.0007, "epss_percentile": 0.21655}, "CVE-2008-4281": {"epss_score": 0.0028, "epss_percentile": 0.51096}, "CVE-2008-4283": {"epss_score": 0.00499, "epss_percentile": 0.65286}, "CVE-2008-4284": {"epss_score": 0.00365, "epss_percentile": 0.57991}, "CVE-2008-4285": {"epss_score": 0.00408, "epss_percentile": 0.60636}, "CVE-2008-4292": {"epss_score": 0.0312, "epss_percentile": 0.86446}, "CVE-2008-4293": {"epss_score": 0.06349, "epss_percentile": 0.9069}, "CVE-2008-4294": {"epss_score": 0.00077, "epss_percentile": 0.23385}, "CVE-2008-4295": {"epss_score": 0.53782, "epss_percentile": 0.97897}, "CVE-2008-4296": {"epss_score": 0.01014, "epss_percentile": 0.76649}, "CVE-2008-4297": {"epss_score": 0.00756, "epss_percentile": 0.72728}, "CVE-2008-4298": {"epss_score": 0.02649, "epss_percentile": 0.8534}, "CVE-2008-4299": {"epss_score": 0.23156, "epss_percentile": 0.95745}, "CVE-2008-4300": {"epss_score": 0.14216, "epss_percentile": 0.94164}, "CVE-2008-4301": {"epss_score": 0.26363, "epss_percentile": 0.9614}, "CVE-2008-4302": {"epss_score": 0.00156, "epss_percentile": 0.3698}, "CVE-2008-4303": {"epss_score": 0.00661, "epss_percentile": 0.70572}, "CVE-2008-4304": {"epss_score": 0.01794, "epss_percentile": 0.82292}, "CVE-2008-4305": {"epss_score": 0.0149, "epss_percentile": 0.80629}, "CVE-2008-4306": {"epss_score": 0.04682, "epss_percentile": 0.89001}, "CVE-2008-4307": {"epss_score": 0.00084, "epss_percentile": 0.24963}, "CVE-2008-4308": {"epss_score": 0.07599, "epss_percentile": 0.91561}, "CVE-2008-4309": {"epss_score": 0.10677, "epss_percentile": 0.93068}, "CVE-2008-4310": {"epss_score": 0.05349, "epss_percentile": 0.89772}, "CVE-2008-4311": {"epss_score": 0.00044, "epss_percentile": 0.13445}, "CVE-2008-4313": {"epss_score": 0.00556, "epss_percentile": 0.6751}, "CVE-2008-4314": {"epss_score": 0.1089, "epss_percentile": 0.93147}, "CVE-2008-4315": {"epss_score": 0.01577, "epss_percentile": 0.81116}, "CVE-2008-4316": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2008-4318": {"epss_score": 0.05572, "epss_percentile": 0.90008}, "CVE-2008-4319": {"epss_score": 0.03367, "epss_percentile": 0.87005}, "CVE-2008-4320": {"epss_score": 0.01881, "epss_percentile": 0.82692}, "CVE-2008-4321": {"epss_score": 0.25729, "epss_percentile": 0.9606}, "CVE-2008-4322": {"epss_score": 0.69789, "epss_percentile": 0.98603}, "CVE-2008-4323": {"epss_score": 0.12441, "epss_percentile": 0.93672}, "CVE-2008-4324": {"epss_score": 0.0657, "epss_percentile": 0.90854}, "CVE-2008-4325": {"epss_score": 0.00897, "epss_percentile": 0.75128}, "CVE-2008-4326": {"epss_score": 0.00425, "epss_percentile": 0.61722}, "CVE-2008-4327": {"epss_score": 0.2728, "epss_percentile": 0.9623}, "CVE-2008-4328": {"epss_score": 0.00372, "epss_percentile": 0.58444}, "CVE-2008-4329": {"epss_score": 0.03777, "epss_percentile": 0.8771}, "CVE-2008-4330": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-4331": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-4332": {"epss_score": 0.00289, "epss_percentile": 0.52008}, "CVE-2008-4333": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-4334": {"epss_score": 0.01521, "epss_percentile": 0.80828}, "CVE-2008-4335": {"epss_score": 0.00651, "epss_percentile": 0.7029}, "CVE-2008-4336": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-4337": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-4338": {"epss_score": 0.00461, "epss_percentile": 0.63558}, "CVE-2008-4339": {"epss_score": 0.01665, "epss_percentile": 0.81648}, "CVE-2008-4340": {"epss_score": 0.09945, "epss_percentile": 0.92785}, "CVE-2008-4341": {"epss_score": 0.02259, "epss_percentile": 0.84184}, "CVE-2008-4342": {"epss_score": 0.26706, "epss_percentile": 0.96168}, "CVE-2008-4343": {"epss_score": 0.06532, "epss_percentile": 0.90825}, "CVE-2008-4344": {"epss_score": 0.00323, "epss_percentile": 0.54862}, "CVE-2008-4345": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4346": {"epss_score": 0.07032, "epss_percentile": 0.912}, "CVE-2008-4347": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4348": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2008-4349": {"epss_score": 0.02126, "epss_percentile": 0.83696}, "CVE-2008-4350": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-4351": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-4352": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4353": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2008-4354": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4355": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-4356": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4357": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4358": {"epss_score": 0.00851, "epss_percentile": 0.74408}, "CVE-2008-4359": {"epss_score": 0.00462, "epss_percentile": 0.63583}, "CVE-2008-4360": {"epss_score": 0.01028, "epss_percentile": 0.76814}, "CVE-2008-4361": {"epss_score": 0.03885, "epss_percentile": 0.87902}, "CVE-2008-4362": {"epss_score": 0.00489, "epss_percentile": 0.64868}, "CVE-2008-4363": {"epss_score": 0.00846, "epss_percentile": 0.74334}, "CVE-2008-4364": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-4365": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-4366": {"epss_score": 0.03014, "epss_percentile": 0.86207}, "CVE-2008-4368": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2008-4369": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4370": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-4371": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4372": {"epss_score": 0.03288, "epss_percentile": 0.86831}, "CVE-2008-4373": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4374": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-4375": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4376": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4377": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-4378": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4379": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-4380": {"epss_score": 0.15064, "epss_percentile": 0.94353}, "CVE-2008-4381": {"epss_score": 0.30084, "epss_percentile": 0.96506}, "CVE-2008-4382": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2008-4383": {"epss_score": 0.22195, "epss_percentile": 0.95608}, "CVE-2008-4384": {"epss_score": 0.65003, "epss_percentile": 0.984}, "CVE-2008-4385": {"epss_score": 0.71885, "epss_percentile": 0.98684}, "CVE-2008-4387": {"epss_score": 0.14488, "epss_percentile": 0.94222}, "CVE-2008-4388": {"epss_score": 0.63442, "epss_percentile": 0.98334}, "CVE-2008-4389": {"epss_score": 0.00571, "epss_percentile": 0.67979}, "CVE-2008-4390": {"epss_score": 0.03844, "epss_percentile": 0.87837}, "CVE-2008-4391": {"epss_score": 0.05229, "epss_percentile": 0.89636}, "CVE-2008-4392": {"epss_score": 0.00636, "epss_percentile": 0.69877}, "CVE-2008-4393": {"epss_score": 0.00736, "epss_percentile": 0.72312}, "CVE-2008-4394": {"epss_score": 0.00057, "epss_percentile": 0.18191}, "CVE-2008-4395": {"epss_score": 0.02987, "epss_percentile": 0.86136}, "CVE-2008-4396": {"epss_score": 0.04212, "epss_percentile": 0.884}, "CVE-2008-4397": {"epss_score": 0.85816, "epss_percentile": 0.99351}, "CVE-2008-4398": {"epss_score": 0.02376, "epss_percentile": 0.84545}, "CVE-2008-4399": {"epss_score": 0.02376, "epss_percentile": 0.84545}, "CVE-2008-4400": {"epss_score": 0.02553, "epss_percentile": 0.85084}, "CVE-2008-4401": {"epss_score": 0.08676, "epss_percentile": 0.92194}, "CVE-2008-4402": {"epss_score": 0.15574, "epss_percentile": 0.94461}, "CVE-2008-4403": {"epss_score": 0.03855, "epss_percentile": 0.87856}, "CVE-2008-4404": {"epss_score": 0.0153, "epss_percentile": 0.80885}, "CVE-2008-4405": {"epss_score": 0.00894, "epss_percentile": 0.75085}, "CVE-2008-4406": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4407": {"epss_score": 0.00053, "epss_percentile": 0.16908}, "CVE-2008-4408": {"epss_score": 0.00691, "epss_percentile": 0.71267}, "CVE-2008-4409": {"epss_score": 0.11297, "epss_percentile": 0.93296}, "CVE-2008-4410": {"epss_score": 0.00061, "epss_percentile": 0.19355}, "CVE-2008-4411": {"epss_score": 0.00434, "epss_percentile": 0.62321}, "CVE-2008-4412": {"epss_score": 0.00856, "epss_percentile": 0.74476}, "CVE-2008-4413": {"epss_score": 0.00039, "epss_percentile": 0.11574}, "CVE-2008-4414": {"epss_score": 0.00053, "epss_percentile": 0.17011}, "CVE-2008-4415": {"epss_score": 0.00851, "epss_percentile": 0.74402}, "CVE-2008-4416": {"epss_score": 0.00046, "epss_percentile": 0.14358}, "CVE-2008-4418": {"epss_score": 0.03265, "epss_percentile": 0.8678}, "CVE-2008-4419": {"epss_score": 0.0066, "epss_percentile": 0.70533}, "CVE-2008-4420": {"epss_score": 0.06532, "epss_percentile": 0.90825}, "CVE-2008-4421": {"epss_score": 0.08366, "epss_percentile": 0.9201}, "CVE-2008-4423": {"epss_score": 0.01221, "epss_percentile": 0.78646}, "CVE-2008-4424": {"epss_score": 0.00346, "epss_percentile": 0.56656}, "CVE-2008-4425": {"epss_score": 0.04611, "epss_percentile": 0.88915}, "CVE-2008-4426": {"epss_score": 0.01245, "epss_percentile": 0.7884}, "CVE-2008-4427": {"epss_score": 0.06074, "epss_percentile": 0.90454}, "CVE-2008-4428": {"epss_score": 0.07183, "epss_percentile": 0.91304}, "CVE-2008-4429": {"epss_score": 0.0251, "epss_percentile": 0.84947}, "CVE-2008-4431": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-4432": {"epss_score": 0.01611, "epss_percentile": 0.81324}, "CVE-2008-4433": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2008-4434": {"epss_score": 0.25805, "epss_percentile": 0.96071}, "CVE-2008-4435": {"epss_score": 0.00234, "epss_percentile": 0.46082}, "CVE-2008-4436": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4437": {"epss_score": 0.10546, "epss_percentile": 0.93024}, "CVE-2008-4438": {"epss_score": 0.00399, "epss_percentile": 0.60137}, "CVE-2008-4439": {"epss_score": 0.01316, "epss_percentile": 0.79409}, "CVE-2008-4440": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4441": {"epss_score": 0.0134, "epss_percentile": 0.79575}, "CVE-2008-4444": {"epss_score": 0.0194, "epss_percentile": 0.8298}, "CVE-2008-4445": {"epss_score": 0.00074, "epss_percentile": 0.22772}, "CVE-2008-4446": {"epss_score": 0.00861, "epss_percentile": 0.74554}, "CVE-2008-4447": {"epss_score": 0.01823, "epss_percentile": 0.82421}, "CVE-2008-4448": {"epss_score": 0.00179, "epss_percentile": 0.3982}, "CVE-2008-4449": {"epss_score": 0.80993, "epss_percentile": 0.99115}, "CVE-2008-4450": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-4451": {"epss_score": 0.00288, "epss_percentile": 0.51924}, "CVE-2008-4452": {"epss_score": 0.29308, "epss_percentile": 0.96432}, "CVE-2008-4453": {"epss_score": 0.09636, "epss_percentile": 0.92634}, "CVE-2008-4454": {"epss_score": 0.0193, "epss_percentile": 0.82937}, "CVE-2008-4455": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2008-4456": {"epss_score": 0.06318, "epss_percentile": 0.90668}, "CVE-2008-4457": {"epss_score": 0.0138, "epss_percentile": 0.79858}, "CVE-2008-4458": {"epss_score": 0.00435, "epss_percentile": 0.62378}, "CVE-2008-4459": {"epss_score": 0.00301, "epss_percentile": 0.53079}, "CVE-2008-4460": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4461": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4462": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4463": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4464": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4465": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4466": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-4467": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4468": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4469": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-4470": {"epss_score": 0.04118, "epss_percentile": 0.8828}, "CVE-2008-4471": {"epss_score": 0.06247, "epss_percentile": 0.90605}, "CVE-2008-4472": {"epss_score": 0.11319, "epss_percentile": 0.93304}, "CVE-2008-4473": {"epss_score": 0.27474, "epss_percentile": 0.9625}, "CVE-2008-4474": {"epss_score": 0.00028, "epss_percentile": 0.07332}, "CVE-2008-4475": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4476": {"epss_score": 0.00023, "epss_percentile": 0.0552}, "CVE-2008-4477": {"epss_score": 0.00027, "epss_percentile": 0.06785}, "CVE-2008-4478": {"epss_score": 0.60771, "epss_percentile": 0.9822}, "CVE-2008-4479": {"epss_score": 0.2652, "epss_percentile": 0.96153}, "CVE-2008-4480": {"epss_score": 0.2171, "epss_percentile": 0.9555}, "CVE-2008-4481": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-4482": {"epss_score": 0.01995, "epss_percentile": 0.83193}, "CVE-2008-4483": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2008-4484": {"epss_score": 0.09555, "epss_percentile": 0.92596}, "CVE-2008-4485": {"epss_score": 0.00705, "epss_percentile": 0.71583}, "CVE-2008-4486": {"epss_score": 0.15751, "epss_percentile": 0.94498}, "CVE-2008-4487": {"epss_score": 0.00386, "epss_percentile": 0.59267}, "CVE-2008-4488": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-4489": {"epss_score": 0.00295, "epss_percentile": 0.52497}, "CVE-2008-4490": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-4491": {"epss_score": 0.00531, "epss_percentile": 0.66649}, "CVE-2008-4492": {"epss_score": 0.00498, "epss_percentile": 0.65226}, "CVE-2008-4493": {"epss_score": 0.42139, "epss_percentile": 0.97314}, "CVE-2008-4494": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-4495": {"epss_score": 0.00897, "epss_percentile": 0.75127}, "CVE-2008-4496": {"epss_score": 0.00897, "epss_percentile": 0.75127}, "CVE-2008-4497": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4498": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4499": {"epss_score": 0.02846, "epss_percentile": 0.8582}, "CVE-2008-4500": {"epss_score": 0.1006, "epss_percentile": 0.92836}, "CVE-2008-4501": {"epss_score": 0.04597, "epss_percentile": 0.889}, "CVE-2008-4502": {"epss_score": 0.03116, "epss_percentile": 0.86436}, "CVE-2008-4503": {"epss_score": 0.08732, "epss_percentile": 0.92232}, "CVE-2008-4504": {"epss_score": 0.02368, "epss_percentile": 0.8452}, "CVE-2008-4505": {"epss_score": 0.00493, "epss_percentile": 0.65034}, "CVE-2008-4506": {"epss_score": 0.00463, "epss_percentile": 0.63631}, "CVE-2008-4507": {"epss_score": 0.00463, "epss_percentile": 0.63631}, "CVE-2008-4508": {"epss_score": 0.06636, "epss_percentile": 0.90907}, "CVE-2008-4509": {"epss_score": 0.14001, "epss_percentile": 0.94112}, "CVE-2008-4510": {"epss_score": 0.01072, "epss_percentile": 0.77276}, "CVE-2008-4511": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2008-4512": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2008-4513": {"epss_score": 0.00532, "epss_percentile": 0.667}, "CVE-2008-4514": {"epss_score": 0.04576, "epss_percentile": 0.88869}, "CVE-2008-4515": {"epss_score": 0.00395, "epss_percentile": 0.5983}, "CVE-2008-4516": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4517": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4518": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-4519": {"epss_score": 0.0402, "epss_percentile": 0.8813}, "CVE-2008-4520": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2008-4521": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4522": {"epss_score": 0.03894, "epss_percentile": 0.87913}, "CVE-2008-4523": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4524": {"epss_score": 0.0138, "epss_percentile": 0.79858}, "CVE-2008-4525": {"epss_score": 0.00358, "epss_percentile": 0.57485}, "CVE-2008-4526": {"epss_score": 0.03839, "epss_percentile": 0.87829}, "CVE-2008-4527": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-4528": {"epss_score": 0.05009, "epss_percentile": 0.89388}, "CVE-2008-4529": {"epss_score": 0.04076, "epss_percentile": 0.88212}, "CVE-2008-4530": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2008-4531": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-4532": {"epss_score": 0.03405, "epss_percentile": 0.87074}, "CVE-2008-4533": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-4534": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2008-4535": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-4536": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2008-4537": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2008-4539": {"epss_score": 0.00048, "epss_percentile": 0.15032}, "CVE-2008-4540": {"epss_score": 0.02333, "epss_percentile": 0.8441}, "CVE-2008-4541": {"epss_score": 0.15786, "epss_percentile": 0.94509}, "CVE-2008-4542": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2008-4543": {"epss_score": 0.01189, "epss_percentile": 0.78373}, "CVE-2008-4544": {"epss_score": 0.03429, "epss_percentile": 0.87121}, "CVE-2008-4545": {"epss_score": 0.00275, "epss_percentile": 0.50647}, "CVE-2008-4546": {"epss_score": 0.35507, "epss_percentile": 0.96916}, "CVE-2008-4547": {"epss_score": 0.10621, "epss_percentile": 0.93052}, "CVE-2008-4548": {"epss_score": 0.22982, "epss_percentile": 0.95713}, "CVE-2008-4549": {"epss_score": 0.08149, "epss_percentile": 0.91903}, "CVE-2008-4551": {"epss_score": 0.01238, "epss_percentile": 0.78788}, "CVE-2008-4552": {"epss_score": 0.01355, "epss_percentile": 0.79706}, "CVE-2008-4553": {"epss_score": 0.00034, "epss_percentile": 0.0955}, "CVE-2008-4554": {"epss_score": 0.00063, "epss_percentile": 0.19874}, "CVE-2008-4555": {"epss_score": 0.05229, "epss_percentile": 0.89636}, "CVE-2008-4556": {"epss_score": 0.79045, "epss_percentile": 0.99018}, "CVE-2008-4557": {"epss_score": 0.10668, "epss_percentile": 0.93063}, "CVE-2008-4558": {"epss_score": 0.19574, "epss_percentile": 0.95211}, "CVE-2008-4559": {"epss_score": 0.03974, "epss_percentile": 0.88046}, "CVE-2008-4560": {"epss_score": 0.00426, "epss_percentile": 0.6177}, "CVE-2008-4562": {"epss_score": 0.05571, "epss_percentile": 0.90007}, "CVE-2008-4563": {"epss_score": 0.3763, "epss_percentile": 0.97061}, "CVE-2008-4564": {"epss_score": 0.50828, "epss_percentile": 0.97751}, "CVE-2008-4569": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4570": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-4571": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2008-4572": {"epss_score": 0.7687, "epss_percentile": 0.9891}, "CVE-2008-4573": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-4574": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-4575": {"epss_score": 0.00767, "epss_percentile": 0.72949}, "CVE-2008-4576": {"epss_score": 0.04823, "epss_percentile": 0.8918}, "CVE-2008-4577": {"epss_score": 0.01099, "epss_percentile": 0.7756}, "CVE-2008-4578": {"epss_score": 0.00762, "epss_percentile": 0.72848}, "CVE-2008-4579": {"epss_score": 0.00052, "epss_percentile": 0.16378}, "CVE-2008-4580": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-4581": {"epss_score": 0.002, "epss_percentile": 0.42267}, "CVE-2008-4582": {"epss_score": 0.3558, "epss_percentile": 0.9692}, "CVE-2008-4583": {"epss_score": 0.02475, "epss_percentile": 0.8486}, "CVE-2008-4584": {"epss_score": 0.03796, "epss_percentile": 0.87735}, "CVE-2008-4585": {"epss_score": 0.00286, "epss_percentile": 0.51754}, "CVE-2008-4586": {"epss_score": 0.08905, "epss_percentile": 0.92309}, "CVE-2008-4587": {"epss_score": 0.08898, "epss_percentile": 0.92305}, "CVE-2008-4588": {"epss_score": 0.2849, "epss_percentile": 0.96362}, "CVE-2008-4589": {"epss_score": 0.00094, "epss_percentile": 0.27043}, "CVE-2008-4590": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4591": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-4592": {"epss_score": 0.06878, "epss_percentile": 0.91088}, "CVE-2008-4593": {"epss_score": 0.00062, "epss_percentile": 0.19772}, "CVE-2008-4594": {"epss_score": 0.00378, "epss_percentile": 0.58821}, "CVE-2008-4595": {"epss_score": 0.00378, "epss_percentile": 0.58821}, "CVE-2008-4596": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2008-4597": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2008-4598": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2008-4599": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-4600": {"epss_score": 0.02405, "epss_percentile": 0.84649}, "CVE-2008-4601": {"epss_score": 0.02499, "epss_percentile": 0.84913}, "CVE-2008-4602": {"epss_score": 0.02822, "epss_percentile": 0.85746}, "CVE-2008-4603": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4604": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-4605": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-4606": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-4609": {"epss_score": 0.00809, "epss_percentile": 0.73703}, "CVE-2008-4610": {"epss_score": 0.04522, "epss_percentile": 0.88801}, "CVE-2008-4611": {"epss_score": 0.00284, "epss_percentile": 0.51415}, "CVE-2008-4612": {"epss_score": 0.06767, "epss_percentile": 0.91012}, "CVE-2008-4613": {"epss_score": 0.00591, "epss_percentile": 0.68589}, "CVE-2008-4614": {"epss_score": 0.08223, "epss_percentile": 0.91938}, "CVE-2008-4615": {"epss_score": 0.00341, "epss_percentile": 0.56305}, "CVE-2008-4616": {"epss_score": 0.04001, "epss_percentile": 0.88091}, "CVE-2008-4617": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4618": {"epss_score": 0.01011, "epss_percentile": 0.76615}, "CVE-2008-4619": {"epss_score": 0.08929, "epss_percentile": 0.92324}, "CVE-2008-4620": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-4621": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-4622": {"epss_score": 0.05292, "epss_percentile": 0.89698}, "CVE-2008-4623": {"epss_score": 0.00927, "epss_percentile": 0.75567}, "CVE-2008-4624": {"epss_score": 0.09015, "epss_percentile": 0.92366}, "CVE-2008-4625": {"epss_score": 0.00486, "epss_percentile": 0.64741}, "CVE-2008-4626": {"epss_score": 0.06627, "epss_percentile": 0.909}, "CVE-2008-4627": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-4628": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-4629": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-4630": {"epss_score": 0.00378, "epss_percentile": 0.58821}, "CVE-2008-4631": {"epss_score": 0.03216, "epss_percentile": 0.86662}, "CVE-2008-4632": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-4633": {"epss_score": 0.00261, "epss_percentile": 0.49305}, "CVE-2008-4634": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2008-4635": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2008-4636": {"epss_score": 0.00191, "epss_percentile": 0.41186}, "CVE-2008-4637": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-4638": {"epss_score": 0.00067, "epss_percentile": 0.21087}, "CVE-2008-4639": {"epss_score": 0.00034, "epss_percentile": 0.09804}, "CVE-2008-4640": {"epss_score": 0.00064, "epss_percentile": 0.20153}, "CVE-2008-4641": {"epss_score": 0.02025, "epss_percentile": 0.83314}, "CVE-2008-4642": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-4643": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-4644": {"epss_score": 0.01465, "epss_percentile": 0.80452}, "CVE-2008-4645": {"epss_score": 0.0219, "epss_percentile": 0.83932}, "CVE-2008-4646": {"epss_score": 0.0007, "epss_percentile": 0.21671}, "CVE-2008-4647": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-4648": {"epss_score": 0.02529, "epss_percentile": 0.85021}, "CVE-2008-4649": {"epss_score": 0.00926, "epss_percentile": 0.75552}, "CVE-2008-4650": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4651": {"epss_score": 0.00169, "epss_percentile": 0.38632}, "CVE-2008-4652": {"epss_score": 0.11038, "epss_percentile": 0.93197}, "CVE-2008-4653": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2008-4654": {"epss_score": 0.77302, "epss_percentile": 0.9893}, "CVE-2008-4655": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-4656": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2008-4657": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-4658": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-4659": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-4660": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-4661": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-4662": {"epss_score": 0.05901, "epss_percentile": 0.90309}, "CVE-2008-4663": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-4664": {"epss_score": 0.15435, "epss_percentile": 0.9443}, "CVE-2008-4665": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-4666": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4667": {"epss_score": 0.03461, "epss_percentile": 0.8718}, "CVE-2008-4668": {"epss_score": 0.00144, "epss_percentile": 0.35253}, "CVE-2008-4669": {"epss_score": 0.00305, "epss_percentile": 0.53365}, "CVE-2008-4670": {"epss_score": 0.00255, "epss_percentile": 0.48693}, "CVE-2008-4671": {"epss_score": 0.00813, "epss_percentile": 0.73756}, "CVE-2008-4672": {"epss_score": 0.00305, "epss_percentile": 0.53365}, "CVE-2008-4673": {"epss_score": 0.07977, "epss_percentile": 0.91801}, "CVE-2008-4674": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-4675": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4676": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2008-4677": {"epss_score": 0.00748, "epss_percentile": 0.72589}, "CVE-2008-4678": {"epss_score": 0.01967, "epss_percentile": 0.83086}, "CVE-2008-4679": {"epss_score": 0.00302, "epss_percentile": 0.53129}, "CVE-2008-4680": {"epss_score": 0.0384, "epss_percentile": 0.87829}, "CVE-2008-4681": {"epss_score": 0.01047, "epss_percentile": 0.77035}, "CVE-2008-4682": {"epss_score": 0.0601, "epss_percentile": 0.90404}, "CVE-2008-4683": {"epss_score": 0.03328, "epss_percentile": 0.86925}, "CVE-2008-4684": {"epss_score": 0.01047, "epss_percentile": 0.77035}, "CVE-2008-4685": {"epss_score": 0.01097, "epss_percentile": 0.77526}, "CVE-2008-4686": {"epss_score": 0.08258, "epss_percentile": 0.91955}, "CVE-2008-4687": {"epss_score": 0.79225, "epss_percentile": 0.99025}, "CVE-2008-4688": {"epss_score": 0.05344, "epss_percentile": 0.89766}, "CVE-2008-4689": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2008-4690": {"epss_score": 0.1754, "epss_percentile": 0.94863}, "CVE-2008-4691": {"epss_score": 0.005, "epss_percentile": 0.65324}, "CVE-2008-4692": {"epss_score": 0.01487, "epss_percentile": 0.8061}, "CVE-2008-4693": {"epss_score": 0.00477, "epss_percentile": 0.64335}, "CVE-2008-4694": {"epss_score": 0.17321, "epss_percentile": 0.94823}, "CVE-2008-4695": {"epss_score": 0.03199, "epss_percentile": 0.86618}, "CVE-2008-4696": {"epss_score": 0.62121, "epss_percentile": 0.9828}, "CVE-2008-4697": {"epss_score": 0.00787, "epss_percentile": 0.73311}, "CVE-2008-4698": {"epss_score": 0.00787, "epss_percentile": 0.73311}, "CVE-2008-4699": {"epss_score": 0.3924, "epss_percentile": 0.97149}, "CVE-2008-4700": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-4701": {"epss_score": 0.00301, "epss_percentile": 0.53079}, "CVE-2008-4702": {"epss_score": 0.03295, "epss_percentile": 0.86858}, "CVE-2008-4703": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4704": {"epss_score": 0.02844, "epss_percentile": 0.85815}, "CVE-2008-4705": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4706": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-4707": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-4708": {"epss_score": 0.02259, "epss_percentile": 0.84184}, "CVE-2008-4709": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-4710": {"epss_score": 0.00231, "epss_percentile": 0.45791}, "CVE-2008-4711": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4712": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2008-4713": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4714": {"epss_score": 0.02259, "epss_percentile": 0.84184}, "CVE-2008-4715": {"epss_score": 0.00541, "epss_percentile": 0.67059}, "CVE-2008-4716": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-4717": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-4718": {"epss_score": 0.05666, "epss_percentile": 0.90102}, "CVE-2008-4719": {"epss_score": 0.02518, "epss_percentile": 0.84992}, "CVE-2008-4720": {"epss_score": 0.03445, "epss_percentile": 0.87147}, "CVE-2008-4721": {"epss_score": 0.02259, "epss_percentile": 0.84184}, "CVE-2008-4722": {"epss_score": 0.01385, "epss_percentile": 0.79902}, "CVE-2008-4723": {"epss_score": 0.00209, "epss_percentile": 0.43365}, "CVE-2008-4724": {"epss_score": 0.00146, "epss_percentile": 0.35613}, "CVE-2008-4725": {"epss_score": 0.13824, "epss_percentile": 0.94067}, "CVE-2008-4726": {"epss_score": 0.49546, "epss_percentile": 0.97694}, "CVE-2008-4727": {"epss_score": 0.05185, "epss_percentile": 0.89587}, "CVE-2008-4728": {"epss_score": 0.30123, "epss_percentile": 0.96513}, "CVE-2008-4729": {"epss_score": 0.08303, "epss_percentile": 0.91979}, "CVE-2008-4730": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-4731": {"epss_score": 0.00366, "epss_percentile": 0.58021}, "CVE-2008-4732": {"epss_score": 0.01291, "epss_percentile": 0.79229}, "CVE-2008-4733": {"epss_score": 0.00405, "epss_percentile": 0.60491}, "CVE-2008-4734": {"epss_score": 0.00396, "epss_percentile": 0.59854}, "CVE-2008-4735": {"epss_score": 0.02778, "epss_percentile": 0.85643}, "CVE-2008-4736": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4737": {"epss_score": 0.00346, "epss_percentile": 0.56605}, "CVE-2008-4738": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-4739": {"epss_score": 0.03255, "epss_percentile": 0.8676}, "CVE-2008-4740": {"epss_score": 0.06088, "epss_percentile": 0.90467}, "CVE-2008-4741": {"epss_score": 0.06303, "epss_percentile": 0.90658}, "CVE-2008-4742": {"epss_score": 0.00474, "epss_percentile": 0.64166}, "CVE-2008-4743": {"epss_score": 0.00323, "epss_percentile": 0.54862}, "CVE-2008-4744": {"epss_score": 0.00284, "epss_percentile": 0.51439}, "CVE-2008-4745": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2008-4746": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-4747": {"epss_score": 0.00066, "epss_percentile": 0.20955}, "CVE-2008-4748": {"epss_score": 0.13802, "epss_percentile": 0.9406}, "CVE-2008-4749": {"epss_score": 0.05117, "epss_percentile": 0.89516}, "CVE-2008-4750": {"epss_score": 0.20471, "epss_percentile": 0.95351}, "CVE-2008-4751": {"epss_score": 0.05957, "epss_percentile": 0.90363}, "CVE-2008-4752": {"epss_score": 0.02405, "epss_percentile": 0.84649}, "CVE-2008-4753": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4754": {"epss_score": 0.01045, "epss_percentile": 0.7702}, "CVE-2008-4755": {"epss_score": 0.00897, "epss_percentile": 0.75127}, "CVE-2008-4756": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-4757": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4758": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-4759": {"epss_score": 0.04011, "epss_percentile": 0.88112}, "CVE-2008-4760": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4761": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2008-4762": {"epss_score": 0.37027, "epss_percentile": 0.97014}, "CVE-2008-4763": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-4764": {"epss_score": 0.01041, "epss_percentile": 0.76966}, "CVE-2008-4765": {"epss_score": 0.00498, "epss_percentile": 0.65226}, "CVE-2008-4766": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2008-4767": {"epss_score": 0.03906, "epss_percentile": 0.87927}, "CVE-2008-4768": {"epss_score": 0.00266, "epss_percentile": 0.49863}, "CVE-2008-4769": {"epss_score": 0.1766, "epss_percentile": 0.94886}, "CVE-2008-4770": {"epss_score": 0.0582, "epss_percentile": 0.90233}, "CVE-2008-4771": {"epss_score": 0.16084, "epss_percentile": 0.9457}, "CVE-2008-4772": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4773": {"epss_score": 0.0382, "epss_percentile": 0.87782}, "CVE-2008-4774": {"epss_score": 0.0313, "epss_percentile": 0.86474}, "CVE-2008-4775": {"epss_score": 0.08276, "epss_percentile": 0.91965}, "CVE-2008-4776": {"epss_score": 0.00593, "epss_percentile": 0.68638}, "CVE-2008-4777": {"epss_score": 6e-05, "epss_percentile": 0.00241}, "CVE-2008-4778": {"epss_score": 0.00651, "epss_percentile": 0.7029}, "CVE-2008-4779": {"epss_score": 0.7879, "epss_percentile": 0.99003}, "CVE-2008-4780": {"epss_score": 0.03461, "epss_percentile": 0.8718}, "CVE-2008-4781": {"epss_score": 0.03461, "epss_percentile": 0.8718}, "CVE-2008-4782": {"epss_score": 0.00558, "epss_percentile": 0.6758}, "CVE-2008-4783": {"epss_score": 0.02259, "epss_percentile": 0.84184}, "CVE-2008-4784": {"epss_score": 0.02259, "epss_percentile": 0.84184}, "CVE-2008-4785": {"epss_score": 0.00503, "epss_percentile": 0.65465}, "CVE-2008-4786": {"epss_score": 0.00503, "epss_percentile": 0.65465}, "CVE-2008-4787": {"epss_score": 0.374, "epss_percentile": 0.97043}, "CVE-2008-4788": {"epss_score": 0.16475, "epss_percentile": 0.94675}, "CVE-2008-4789": {"epss_score": 0.00213, "epss_percentile": 0.43834}, "CVE-2008-4790": {"epss_score": 0.00245, "epss_percentile": 0.47704}, "CVE-2008-4791": {"epss_score": 0.00516, "epss_percentile": 0.66029}, "CVE-2008-4792": {"epss_score": 0.00424, "epss_percentile": 0.61639}, "CVE-2008-4793": {"epss_score": 0.00299, "epss_percentile": 0.52876}, "CVE-2008-4794": {"epss_score": 0.02247, "epss_percentile": 0.84135}, "CVE-2008-4795": {"epss_score": 0.11161, "epss_percentile": 0.93249}, "CVE-2008-4796": {"epss_score": 0.0109, "epss_percentile": 0.7745}, "CVE-2008-4797": {"epss_score": 0.00284, "epss_percentile": 0.51497}, "CVE-2008-4798": {"epss_score": 0.03969, "epss_percentile": 0.88034}, "CVE-2008-4799": {"epss_score": 0.00542, "epss_percentile": 0.67068}, "CVE-2008-4800": {"epss_score": 0.22016, "epss_percentile": 0.95584}, "CVE-2008-4801": {"epss_score": 0.28108, "epss_percentile": 0.96311}, "CVE-2008-4802": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-4803": {"epss_score": 0.00292, "epss_percentile": 0.52238}, "CVE-2008-4804": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2008-4805": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2008-4806": {"epss_score": 0.00353, "epss_percentile": 0.57152}, "CVE-2008-4807": {"epss_score": 0.00061, "epss_percentile": 0.19544}, "CVE-2008-4808": {"epss_score": 0.00301, "epss_percentile": 0.53011}, "CVE-2008-4809": {"epss_score": 0.00463, "epss_percentile": 0.63662}, "CVE-2008-4810": {"epss_score": 0.01407, "epss_percentile": 0.80061}, "CVE-2008-4811": {"epss_score": 0.01003, "epss_percentile": 0.76512}, "CVE-2008-4812": {"epss_score": 0.36305, "epss_percentile": 0.96968}, "CVE-2008-4813": {"epss_score": 0.21241, "epss_percentile": 0.95483}, "CVE-2008-4814": {"epss_score": 0.41422, "epss_percentile": 0.97273}, "CVE-2008-4815": {"epss_score": 0.0824, "epss_percentile": 0.91945}, "CVE-2008-4816": {"epss_score": 0.05806, "epss_percentile": 0.90223}, "CVE-2008-4817": {"epss_score": 0.28567, "epss_percentile": 0.96368}, "CVE-2008-4818": {"epss_score": 0.17674, "epss_percentile": 0.94887}, "CVE-2008-4819": {"epss_score": 0.28529, "epss_percentile": 0.96365}, "CVE-2008-4820": {"epss_score": 0.05544, "epss_percentile": 0.8998}, "CVE-2008-4821": {"epss_score": 0.05688, "epss_percentile": 0.9012}, "CVE-2008-4822": {"epss_score": 0.21364, "epss_percentile": 0.95509}, "CVE-2008-4823": {"epss_score": 0.17674, "epss_percentile": 0.94887}, "CVE-2008-4824": {"epss_score": 0.47638, "epss_percentile": 0.97594}, "CVE-2008-4825": {"epss_score": 0.01533, "epss_percentile": 0.80899}, "CVE-2008-4827": {"epss_score": 0.25203, "epss_percentile": 0.95997}, "CVE-2008-4828": {"epss_score": 0.77418, "epss_percentile": 0.98936}, "CVE-2008-4829": {"epss_score": 0.09881, "epss_percentile": 0.92752}, "CVE-2008-4830": {"epss_score": 0.62466, "epss_percentile": 0.98293}, "CVE-2008-4831": {"epss_score": 0.00261, "epss_percentile": 0.49324}, "CVE-2008-4832": {"epss_score": 0.0002, "epss_percentile": 0.04653}, "CVE-2008-4834": {"epss_score": 0.73946, "epss_percentile": 0.98778}, "CVE-2008-4835": {"epss_score": 0.66728, "epss_percentile": 0.98476}, "CVE-2008-4837": {"epss_score": 0.71941, "epss_percentile": 0.98688}, "CVE-2008-4841": {"epss_score": 0.7455, "epss_percentile": 0.98808}, "CVE-2008-4844": {"epss_score": 0.82846, "epss_percentile": 0.99218}, "CVE-2008-4863": {"epss_score": 0.00188, "epss_percentile": 0.40855}, "CVE-2008-4864": {"epss_score": 0.10929, "epss_percentile": 0.93162}, "CVE-2008-4865": {"epss_score": 0.00139, "epss_percentile": 0.34562}, "CVE-2008-4866": {"epss_score": 0.05735, "epss_percentile": 0.90164}, "CVE-2008-4867": {"epss_score": 0.02422, "epss_percentile": 0.84706}, "CVE-2008-4868": {"epss_score": 0.00728, "epss_percentile": 0.72113}, "CVE-2008-4869": {"epss_score": 0.01046, "epss_percentile": 0.77025}, "CVE-2008-4870": {"epss_score": 0.0004, "epss_percentile": 0.12184}, "CVE-2008-4871": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-4872": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-4873": {"epss_score": 0.04613, "epss_percentile": 0.8892}, "CVE-2008-4874": {"epss_score": 0.13378, "epss_percentile": 0.93946}, "CVE-2008-4875": {"epss_score": 0.08959, "epss_percentile": 0.92337}, "CVE-2008-4876": {"epss_score": 0.06494, "epss_percentile": 0.90799}, "CVE-2008-4877": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-4878": {"epss_score": 0.03972, "epss_percentile": 0.88038}, "CVE-2008-4879": {"epss_score": 0.00421, "epss_percentile": 0.61523}, "CVE-2008-4880": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-4881": {"epss_score": 0.00583, "epss_percentile": 0.68326}, "CVE-2008-4882": {"epss_score": 0.00618, "epss_percentile": 0.6938}, "CVE-2008-4883": {"epss_score": 0.00681, "epss_percentile": 0.71049}, "CVE-2008-4884": {"epss_score": 0.00498, "epss_percentile": 0.65226}, "CVE-2008-4885": {"epss_score": 0.0063, "epss_percentile": 0.69689}, "CVE-2008-4886": {"epss_score": 0.00877, "epss_percentile": 0.74799}, "CVE-2008-4887": {"epss_score": 0.00851, "epss_percentile": 0.74409}, "CVE-2008-4888": {"epss_score": 0.05794, "epss_percentile": 0.90215}, "CVE-2008-4889": {"epss_score": 0.00995, "epss_percentile": 0.76439}, "CVE-2008-4890": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2008-4891": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-4892": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-4893": {"epss_score": 0.00305, "epss_percentile": 0.53365}, "CVE-2008-4894": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2008-4895": {"epss_score": 0.00499, "epss_percentile": 0.65248}, "CVE-2008-4896": {"epss_score": 0.00305, "epss_percentile": 0.53365}, "CVE-2008-4897": {"epss_score": 0.00995, "epss_percentile": 0.76439}, "CVE-2008-4898": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-4899": {"epss_score": 0.00205, "epss_percentile": 0.4276}, "CVE-2008-4900": {"epss_score": 0.00524, "epss_percentile": 0.66361}, "CVE-2008-4901": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-4902": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-4903": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-4904": {"epss_score": 0.00364, "epss_percentile": 0.57954}, "CVE-2008-4905": {"epss_score": 0.00438, "epss_percentile": 0.62574}, "CVE-2008-4906": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-4907": {"epss_score": 0.14289, "epss_percentile": 0.94179}, "CVE-2008-4908": {"epss_score": 0.0003, "epss_percentile": 0.08157}, "CVE-2008-4909": {"epss_score": 0.00322, "epss_percentile": 0.54789}, "CVE-2008-4910": {"epss_score": 0.04307, "epss_percentile": 0.88524}, "CVE-2008-4911": {"epss_score": 0.01158, "epss_percentile": 0.78122}, "CVE-2008-4912": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-4913": {"epss_score": 0.04061, "epss_percentile": 0.8819}, "CVE-2008-4914": {"epss_score": 0.00041, "epss_percentile": 0.12293}, "CVE-2008-4915": {"epss_score": 0.00073, "epss_percentile": 0.22598}, "CVE-2008-4916": {"epss_score": 0.00038, "epss_percentile": 0.11221}, "CVE-2008-4917": {"epss_score": 0.00073, "epss_percentile": 0.22624}, "CVE-2008-4918": {"epss_score": 0.21279, "epss_percentile": 0.95493}, "CVE-2008-4919": {"epss_score": 0.05681, "epss_percentile": 0.90117}, "CVE-2008-4921": {"epss_score": 0.00396, "epss_percentile": 0.59924}, "CVE-2008-4922": {"epss_score": 0.67087, "epss_percentile": 0.98494}, "CVE-2008-4923": {"epss_score": 0.0252, "epss_percentile": 0.85002}, "CVE-2008-4924": {"epss_score": 0.0252, "epss_percentile": 0.85002}, "CVE-2008-4925": {"epss_score": 0.02571, "epss_percentile": 0.85129}, "CVE-2008-4926": {"epss_score": 0.02099, "epss_percentile": 0.83595}, "CVE-2008-4927": {"epss_score": 0.2591, "epss_percentile": 0.96093}, "CVE-2008-4928": {"epss_score": 0.00631, "epss_percentile": 0.69729}, "CVE-2008-4929": {"epss_score": 0.00725, "epss_percentile": 0.72063}, "CVE-2008-4930": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2008-4931": {"epss_score": 0.0217, "epss_percentile": 0.83871}, "CVE-2008-4932": {"epss_score": 0.11106, "epss_percentile": 0.93222}, "CVE-2008-4933": {"epss_score": 0.01173, "epss_percentile": 0.78237}, "CVE-2008-4934": {"epss_score": 0.01279, "epss_percentile": 0.79132}, "CVE-2008-4935": {"epss_score": 0.00027, "epss_percentile": 0.06785}, "CVE-2008-4936": {"epss_score": 0.00028, "epss_percentile": 0.07332}, "CVE-2008-4937": {"epss_score": 0.00042, "epss_percentile": 0.12634}, "CVE-2008-4938": {"epss_score": 0.00027, "epss_percentile": 0.07076}, "CVE-2008-4939": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4940": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4941": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4942": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4943": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-4944": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4945": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4946": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-4947": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4948": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4949": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4950": {"epss_score": 0.00089, "epss_percentile": 0.25954}, "CVE-2008-4951": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4952": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-4953": {"epss_score": 0.00049, "epss_percentile": 0.15363}, "CVE-2008-4954": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4955": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-4956": {"epss_score": 0.00026, "epss_percentile": 0.06463}, "CVE-2008-4957": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-4958": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4959": {"epss_score": 0.00059, "epss_percentile": 0.18843}, "CVE-2008-4960": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4963": {"epss_score": 0.00914, "epss_percentile": 0.75393}, "CVE-2008-4964": {"epss_score": 0.00023, "epss_percentile": 0.05512}, "CVE-2008-4965": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4966": {"epss_score": 0.00025, "epss_percentile": 0.06366}, "CVE-2008-4967": {"epss_score": 0.00025, "epss_percentile": 0.06366}, "CVE-2008-4968": {"epss_score": 0.00025, "epss_percentile": 0.06366}, "CVE-2008-4969": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-4970": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4971": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4972": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-4973": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4974": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4975": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4976": {"epss_score": 0.00026, "epss_percentile": 0.06656}, "CVE-2008-4977": {"epss_score": 0.00089, "epss_percentile": 0.25954}, "CVE-2008-4978": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4979": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4980": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4981": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4982": {"epss_score": 0.00029, "epss_percentile": 0.07925}, "CVE-2008-4983": {"epss_score": 0.00027, "epss_percentile": 0.06785}, "CVE-2008-4984": {"epss_score": 0.00027, "epss_percentile": 0.06882}, "CVE-2008-4985": {"epss_score": 0.00028, "epss_percentile": 0.0727}, "CVE-2008-4986": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-4987": {"epss_score": 0.00029, "epss_percentile": 0.0759}, "CVE-2008-4988": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-4989": {"epss_score": 0.00393, "epss_percentile": 0.59702}, "CVE-2008-4990": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-4991": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-4992": {"epss_score": 0.00105, "epss_percentile": 0.29296}, "CVE-2008-4993": {"epss_score": 0.00027, "epss_percentile": 0.06785}, "CVE-2008-4994": {"epss_score": 0.00025, "epss_percentile": 0.06366}, "CVE-2008-4995": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-4996": {"epss_score": 0.00108, "epss_percentile": 0.29768}, "CVE-2008-4997": {"epss_score": 0.00089, "epss_percentile": 0.25954}, "CVE-2008-4998": {"epss_score": 0.00117, "epss_percentile": 0.31231}, "CVE-2008-4999": {"epss_score": 0.13611, "epss_percentile": 0.94012}, "CVE-2008-5000": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-5001": {"epss_score": 0.05542, "epss_percentile": 0.89979}, "CVE-2008-5002": {"epss_score": 0.68423, "epss_percentile": 0.98547}, "CVE-2008-5003": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-5004": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-5005": {"epss_score": 0.04761, "epss_percentile": 0.89118}, "CVE-2008-5006": {"epss_score": 0.00674, "epss_percentile": 0.7085}, "CVE-2008-5007": {"epss_score": 0.00023, "epss_percentile": 0.05485}, "CVE-2008-5008": {"epss_score": 0.01036, "epss_percentile": 0.7692}, "CVE-2008-5009": {"epss_score": 0.0004, "epss_percentile": 0.11975}, "CVE-2008-5010": {"epss_score": 0.1308, "epss_percentile": 0.93867}, "CVE-2008-5011": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2008-5012": {"epss_score": 0.05969, "epss_percentile": 0.90371}, "CVE-2008-5013": {"epss_score": 0.2392, "epss_percentile": 0.95834}, "CVE-2008-5014": {"epss_score": 0.25205, "epss_percentile": 0.95998}, "CVE-2008-5015": {"epss_score": 0.05714, "epss_percentile": 0.90145}, "CVE-2008-5016": {"epss_score": 0.21255, "epss_percentile": 0.95488}, "CVE-2008-5017": {"epss_score": 0.17422, "epss_percentile": 0.94849}, "CVE-2008-5018": {"epss_score": 0.20193, "epss_percentile": 0.95301}, "CVE-2008-5019": {"epss_score": 0.12823, "epss_percentile": 0.93785}, "CVE-2008-5021": {"epss_score": 0.25259, "epss_percentile": 0.96004}, "CVE-2008-5022": {"epss_score": 0.13446, "epss_percentile": 0.93966}, "CVE-2008-5023": {"epss_score": 0.1839, "epss_percentile": 0.9501}, "CVE-2008-5024": {"epss_score": 0.07219, "epss_percentile": 0.91332}, "CVE-2008-5025": {"epss_score": 0.00907, "epss_percentile": 0.7526}, "CVE-2008-5026": {"epss_score": 0.14819, "epss_percentile": 0.94292}, "CVE-2008-5027": {"epss_score": 0.00707, "epss_percentile": 0.71661}, "CVE-2008-5028": {"epss_score": 0.01275, "epss_percentile": 0.79104}, "CVE-2008-5029": {"epss_score": 0.00081, "epss_percentile": 0.24315}, "CVE-2008-5030": {"epss_score": 0.04982, "epss_percentile": 0.89361}, "CVE-2008-5031": {"epss_score": 0.02689, "epss_percentile": 0.85434}, "CVE-2008-5032": {"epss_score": 0.18203, "epss_percentile": 0.94975}, "CVE-2008-5033": {"epss_score": 0.00557, "epss_percentile": 0.67535}, "CVE-2008-5034": {"epss_score": 0.00089, "epss_percentile": 0.25954}, "CVE-2008-5035": {"epss_score": 0.01827, "epss_percentile": 0.82437}, "CVE-2008-5036": {"epss_score": 0.66452, "epss_percentile": 0.98463}, "CVE-2008-5037": {"epss_score": 0.00332, "epss_percentile": 0.55593}, "CVE-2008-5038": {"epss_score": 0.19097, "epss_percentile": 0.95128}, "CVE-2008-5039": {"epss_score": 0.01823, "epss_percentile": 0.82421}, "CVE-2008-5040": {"epss_score": 0.02259, "epss_percentile": 0.84184}, "CVE-2008-5041": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2008-5042": {"epss_score": 0.05129, "epss_percentile": 0.89528}, "CVE-2008-5043": {"epss_score": 0.00326, "epss_percentile": 0.5506}, "CVE-2008-5044": {"epss_score": 0.00877, "epss_percentile": 0.748}, "CVE-2008-5045": {"epss_score": 0.06065, "epss_percentile": 0.90447}, "CVE-2008-5046": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-5047": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-5048": {"epss_score": 0.00224, "epss_percentile": 0.45018}, "CVE-2008-5049": {"epss_score": 0.00325, "epss_percentile": 0.54999}, "CVE-2008-5050": {"epss_score": 0.16642, "epss_percentile": 0.94707}, "CVE-2008-5051": {"epss_score": 0.00618, "epss_percentile": 0.6938}, "CVE-2008-5052": {"epss_score": 0.2301, "epss_percentile": 0.95717}, "CVE-2008-5053": {"epss_score": 0.00545, "epss_percentile": 0.67173}, "CVE-2008-5054": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2008-5055": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2008-5056": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-5057": {"epss_score": 0.00472, "epss_percentile": 0.64062}, "CVE-2008-5058": {"epss_score": 0.00801, "epss_percentile": 0.73576}, "CVE-2008-5059": {"epss_score": 0.0364, "epss_percentile": 0.87488}, "CVE-2008-5060": {"epss_score": 0.02932, "epss_percentile": 0.86017}, "CVE-2008-5061": {"epss_score": 0.06375, "epss_percentile": 0.90708}, "CVE-2008-5062": {"epss_score": 0.07419, "epss_percentile": 0.91464}, "CVE-2008-5063": {"epss_score": 0.07977, "epss_percentile": 0.91801}, "CVE-2008-5064": {"epss_score": 0.00378, "epss_percentile": 0.58776}, "CVE-2008-5065": {"epss_score": 0.02259, "epss_percentile": 0.84184}, "CVE-2008-5066": {"epss_score": 0.02844, "epss_percentile": 0.85815}, "CVE-2008-5067": {"epss_score": 0.00255, "epss_percentile": 0.48693}, "CVE-2008-5068": {"epss_score": 0.00346, "epss_percentile": 0.56656}, "CVE-2008-5069": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-5070": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-5071": {"epss_score": 0.04065, "epss_percentile": 0.88199}, "CVE-2008-5072": {"epss_score": 0.05722, "epss_percentile": 0.90153}, "CVE-2008-5073": {"epss_score": 0.04726, "epss_percentile": 0.89066}, "CVE-2008-5074": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-5075": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2008-5076": {"epss_score": 0.00067, "epss_percentile": 0.2104}, "CVE-2008-5077": {"epss_score": 0.00237, "epss_percentile": 0.46729}, "CVE-2008-5078": {"epss_score": 0.04964, "epss_percentile": 0.89339}, "CVE-2008-5079": {"epss_score": 0.00986, "epss_percentile": 0.76329}, "CVE-2008-5080": {"epss_score": 0.00396, "epss_percentile": 0.59923}, "CVE-2008-5081": {"epss_score": 0.75367, "epss_percentile": 0.98841}, "CVE-2008-5082": {"epss_score": 0.00196, "epss_percentile": 0.41733}, "CVE-2008-5083": {"epss_score": 0.00328, "epss_percentile": 0.55257}, "CVE-2008-5086": {"epss_score": 0.00047, "epss_percentile": 0.1485}, "CVE-2008-5087": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2008-5088": {"epss_score": 0.00453, "epss_percentile": 0.63212}, "CVE-2008-5089": {"epss_score": 0.00858, "epss_percentile": 0.7451}, "CVE-2008-5090": {"epss_score": 0.14269, "epss_percentile": 0.94176}, "CVE-2008-5091": {"epss_score": 0.0059, "epss_percentile": 0.68545}, "CVE-2008-5092": {"epss_score": 0.00227, "epss_percentile": 0.45401}, "CVE-2008-5093": {"epss_score": 0.00638, "epss_percentile": 0.69915}, "CVE-2008-5094": {"epss_score": 0.00227, "epss_percentile": 0.45401}, "CVE-2008-5095": {"epss_score": 0.00271, "epss_percentile": 0.50307}, "CVE-2008-5096": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2008-5097": {"epss_score": 0.00793, "epss_percentile": 0.73428}, "CVE-2008-5098": {"epss_score": 0.00496, "epss_percentile": 0.65142}, "CVE-2008-5099": {"epss_score": 0.00067, "epss_percentile": 0.2106}, "CVE-2008-5100": {"epss_score": 0.2776, "epss_percentile": 0.9628}, "CVE-2008-5101": {"epss_score": 0.02317, "epss_percentile": 0.84358}, "CVE-2008-5102": {"epss_score": 0.11194, "epss_percentile": 0.93261}, "CVE-2008-5103": {"epss_score": 0.0006, "epss_percentile": 0.192}, "CVE-2008-5104": {"epss_score": 0.0006, "epss_percentile": 0.192}, "CVE-2008-5105": {"epss_score": 0.03394, "epss_percentile": 0.87057}, "CVE-2008-5106": {"epss_score": 0.62069, "epss_percentile": 0.98275}, "CVE-2008-5107": {"epss_score": 0.00103, "epss_percentile": 0.28924}, "CVE-2008-5108": {"epss_score": 0.05429, "epss_percentile": 0.89873}, "CVE-2008-5109": {"epss_score": 0.00778, "epss_percentile": 0.73127}, "CVE-2008-5110": {"epss_score": 0.01088, "epss_percentile": 0.77434}, "CVE-2008-5111": {"epss_score": 0.00054, "epss_percentile": 0.17322}, "CVE-2008-5112": {"epss_score": 0.36452, "epss_percentile": 0.96979}, "CVE-2008-5113": {"epss_score": 0.00298, "epss_percentile": 0.52784}, "CVE-2008-5114": {"epss_score": 0.00496, "epss_percentile": 0.65142}, "CVE-2008-5115": {"epss_score": 0.00804, "epss_percentile": 0.73617}, "CVE-2008-5116": {"epss_score": 0.00724, "epss_percentile": 0.72035}, "CVE-2008-5117": {"epss_score": 0.01256, "epss_percentile": 0.78936}, "CVE-2008-5118": {"epss_score": 0.00717, "epss_percentile": 0.71889}, "CVE-2008-5119": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-5120": {"epss_score": 0.10655, "epss_percentile": 0.93059}, "CVE-2008-5121": {"epss_score": 0.0035, "epss_percentile": 0.5697}, "CVE-2008-5122": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2008-5123": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-5124": {"epss_score": 0.01306, "epss_percentile": 0.79335}, "CVE-2008-5125": {"epss_score": 0.02341, "epss_percentile": 0.84435}, "CVE-2008-5126": {"epss_score": 0.02126, "epss_percentile": 0.83696}, "CVE-2008-5127": {"epss_score": 0.00419, "epss_percentile": 0.61362}, "CVE-2008-5128": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2008-5129": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2008-5130": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2008-5131": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2008-5132": {"epss_score": 0.00906, "epss_percentile": 0.75257}, "CVE-2008-5133": {"epss_score": 0.00314, "epss_percentile": 0.54079}, "CVE-2008-5134": {"epss_score": 0.02143, "epss_percentile": 0.83757}, "CVE-2008-5135": {"epss_score": 0.00038, "epss_percentile": 0.11157}, "CVE-2008-5136": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5137": {"epss_score": 0.00029, "epss_percentile": 0.07927}, "CVE-2008-5138": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-5139": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-5140": {"epss_score": 0.00036, "epss_percentile": 0.10377}, "CVE-2008-5141": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-5142": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5143": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5144": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5145": {"epss_score": 0.00026, "epss_percentile": 0.06549}, "CVE-2008-5146": {"epss_score": 0.00012, "epss_percentile": 0.01429}, "CVE-2008-5147": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-5148": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2008-5149": {"epss_score": 0.00026, "epss_percentile": 0.06549}, "CVE-2008-5150": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-5151": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5152": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-5153": {"epss_score": 0.0003, "epss_percentile": 0.08197}, "CVE-2008-5154": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-5155": {"epss_score": 0.00157, "epss_percentile": 0.37105}, "CVE-2008-5156": {"epss_score": 0.00026, "epss_percentile": 0.06549}, "CVE-2008-5157": {"epss_score": 0.00027, "epss_percentile": 0.06882}, "CVE-2008-5158": {"epss_score": 0.00638, "epss_percentile": 0.69926}, "CVE-2008-5159": {"epss_score": 0.74971, "epss_percentile": 0.98827}, "CVE-2008-5160": {"epss_score": 0.0563, "epss_percentile": 0.90068}, "CVE-2008-5161": {"epss_score": 0.03853, "epss_percentile": 0.87855}, "CVE-2008-5162": {"epss_score": 0.00063, "epss_percentile": 0.19815}, "CVE-2008-5163": {"epss_score": 0.00184, "epss_percentile": 0.40385}, "CVE-2008-5164": {"epss_score": 0.009, "epss_percentile": 0.75165}, "CVE-2008-5165": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2008-5166": {"epss_score": 0.00397, "epss_percentile": 0.60016}, "CVE-2008-5167": {"epss_score": 0.0373, "epss_percentile": 0.87643}, "CVE-2008-5168": {"epss_score": 0.00397, "epss_percentile": 0.60016}, "CVE-2008-5169": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2008-5170": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5171": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2008-5172": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-5173": {"epss_score": 0.00524, "epss_percentile": 0.66334}, "CVE-2008-5174": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2008-5175": {"epss_score": 0.01731, "epss_percentile": 0.81994}, "CVE-2008-5176": {"epss_score": 0.08204, "epss_percentile": 0.91929}, "CVE-2008-5177": {"epss_score": 0.1037, "epss_percentile": 0.92963}, "CVE-2008-5178": {"epss_score": 0.38814, "epss_percentile": 0.97121}, "CVE-2008-5179": {"epss_score": 0.30148, "epss_percentile": 0.96514}, "CVE-2008-5180": {"epss_score": 0.82336, "epss_percentile": 0.99189}, "CVE-2008-5181": {"epss_score": 0.18248, "epss_percentile": 0.9498}, "CVE-2008-5182": {"epss_score": 0.00047, "epss_percentile": 0.14851}, "CVE-2008-5183": {"epss_score": 0.01973, "epss_percentile": 0.8311}, "CVE-2008-5184": {"epss_score": 0.00285, "epss_percentile": 0.51548}, "CVE-2008-5185": {"epss_score": 0.03632, "epss_percentile": 0.87476}, "CVE-2008-5186": {"epss_score": 0.00924, "epss_percentile": 0.75523}, "CVE-2008-5187": {"epss_score": 0.02649, "epss_percentile": 0.85339}, "CVE-2008-5188": {"epss_score": 0.00044, "epss_percentile": 0.13616}, "CVE-2008-5189": {"epss_score": 0.00169, "epss_percentile": 0.38639}, "CVE-2008-5190": {"epss_score": 0.00489, "epss_percentile": 0.64904}, "CVE-2008-5191": {"epss_score": 0.55521, "epss_percentile": 0.97982}, "CVE-2008-5192": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2008-5193": {"epss_score": 0.0291, "epss_percentile": 0.85969}, "CVE-2008-5194": {"epss_score": 0.00508, "epss_percentile": 0.65718}, "CVE-2008-5195": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2008-5196": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5197": {"epss_score": 0.00398, "epss_percentile": 0.60073}, "CVE-2008-5198": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5199": {"epss_score": 0.04224, "epss_percentile": 0.88414}, "CVE-2008-5200": {"epss_score": 0.00018, "epss_percentile": 0.0405}, "CVE-2008-5201": {"epss_score": 0.01804, "epss_percentile": 0.82345}, "CVE-2008-5202": {"epss_score": 0.02457, "epss_percentile": 0.84803}, "CVE-2008-5203": {"epss_score": 0.01101, "epss_percentile": 0.77576}, "CVE-2008-5204": {"epss_score": 0.01254, "epss_percentile": 0.78922}, "CVE-2008-5205": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-5206": {"epss_score": 0.00498, "epss_percentile": 0.65217}, "CVE-2008-5207": {"epss_score": 0.00132, "epss_percentile": 0.33603}, "CVE-2008-5208": {"epss_score": 0.00013, "epss_percentile": 0.01562}, "CVE-2008-5209": {"epss_score": 0.03467, "epss_percentile": 0.87193}, "CVE-2008-5210": {"epss_score": 0.02396, "epss_percentile": 0.84618}, "CVE-2008-5211": {"epss_score": 0.0353, "epss_percentile": 0.87301}, "CVE-2008-5212": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5213": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2008-5214": {"epss_score": 0.02457, "epss_percentile": 0.84803}, "CVE-2008-5215": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5216": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5217": {"epss_score": 0.02588, "epss_percentile": 0.85173}, "CVE-2008-5218": {"epss_score": 0.05453, "epss_percentile": 0.89893}, "CVE-2008-5219": {"epss_score": 0.0246, "epss_percentile": 0.84824}, "CVE-2008-5220": {"epss_score": 0.05105, "epss_percentile": 0.89505}, "CVE-2008-5221": {"epss_score": 0.03856, "epss_percentile": 0.87857}, "CVE-2008-5222": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2008-5223": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2008-5224": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-5225": {"epss_score": 0.03398, "epss_percentile": 0.87063}, "CVE-2008-5226": {"epss_score": 0.00373, "epss_percentile": 0.58513}, "CVE-2008-5227": {"epss_score": 0.11966, "epss_percentile": 0.93527}, "CVE-2008-5228": {"epss_score": 0.00463, "epss_percentile": 0.63697}, "CVE-2008-5229": {"epss_score": 0.01113, "epss_percentile": 0.77684}, "CVE-2008-5230": {"epss_score": 0.00889, "epss_percentile": 0.75013}, "CVE-2008-5231": {"epss_score": 0.08494, "epss_percentile": 0.92083}, "CVE-2008-5232": {"epss_score": 0.3252, "epss_percentile": 0.96706}, "CVE-2008-5233": {"epss_score": 0.01413, "epss_percentile": 0.8012}, "CVE-2008-5234": {"epss_score": 0.05523, "epss_percentile": 0.8996}, "CVE-2008-5235": {"epss_score": 0.03478, "epss_percentile": 0.87213}, "CVE-2008-5236": {"epss_score": 0.05523, "epss_percentile": 0.8996}, "CVE-2008-5237": {"epss_score": 0.05763, "epss_percentile": 0.90185}, "CVE-2008-5238": {"epss_score": 0.0316, "epss_percentile": 0.8653}, "CVE-2008-5239": {"epss_score": 0.02065, "epss_percentile": 0.83455}, "CVE-2008-5240": {"epss_score": 0.03047, "epss_percentile": 0.86285}, "CVE-2008-5241": {"epss_score": 0.01336, "epss_percentile": 0.79556}, "CVE-2008-5242": {"epss_score": 0.01051, "epss_percentile": 0.77081}, "CVE-2008-5243": {"epss_score": 0.01369, "epss_percentile": 0.79797}, "CVE-2008-5244": {"epss_score": 0.00435, "epss_percentile": 0.6238}, "CVE-2008-5245": {"epss_score": 0.01286, "epss_percentile": 0.79184}, "CVE-2008-5246": {"epss_score": 0.04348, "epss_percentile": 0.88581}, "CVE-2008-5247": {"epss_score": 0.01036, "epss_percentile": 0.76911}, "CVE-2008-5248": {"epss_score": 0.00564, "epss_percentile": 0.67768}, "CVE-2008-5249": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2008-5250": {"epss_score": 0.00354, "epss_percentile": 0.57245}, "CVE-2008-5252": {"epss_score": 0.00413, "epss_percentile": 0.61014}, "CVE-2008-5256": {"epss_score": 0.00033, "epss_percentile": 0.09166}, "CVE-2008-5257": {"epss_score": 0.00759, "epss_percentile": 0.72788}, "CVE-2008-5259": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2008-5260": {"epss_score": 0.09287, "epss_percentile": 0.92484}, "CVE-2008-5262": {"epss_score": 0.01474, "epss_percentile": 0.80523}, "CVE-2008-5263": {"epss_score": 0.01573, "epss_percentile": 0.811}, "CVE-2008-5264": {"epss_score": 0.0291, "epss_percentile": 0.85969}, "CVE-2008-5265": {"epss_score": 0.03164, "epss_percentile": 0.86536}, "CVE-2008-5266": {"epss_score": 0.00784, "epss_percentile": 0.73238}, "CVE-2008-5267": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5268": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2008-5269": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5270": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5271": {"epss_score": 0.02861, "epss_percentile": 0.85852}, "CVE-2008-5272": {"epss_score": 0.02284, "epss_percentile": 0.84264}, "CVE-2008-5273": {"epss_score": 0.00397, "epss_percentile": 0.60016}, "CVE-2008-5274": {"epss_score": 0.04171, "epss_percentile": 0.88348}, "CVE-2008-5275": {"epss_score": 0.0043, "epss_percentile": 0.62002}, "CVE-2008-5276": {"epss_score": 0.07671, "epss_percentile": 0.91615}, "CVE-2008-5277": {"epss_score": 0.0003, "epss_percentile": 0.08167}, "CVE-2008-5278": {"epss_score": 0.03157, "epss_percentile": 0.86516}, "CVE-2008-5279": {"epss_score": 0.0593, "epss_percentile": 0.90335}, "CVE-2008-5280": {"epss_score": 0.08488, "epss_percentile": 0.9208}, "CVE-2008-5281": {"epss_score": 0.0192, "epss_percentile": 0.82893}, "CVE-2008-5282": {"epss_score": 0.46083, "epss_percentile": 0.97524}, "CVE-2008-5283": {"epss_score": 0.01401, "epss_percentile": 0.8001}, "CVE-2008-5284": {"epss_score": 0.10704, "epss_percentile": 0.93076}, "CVE-2008-5285": {"epss_score": 0.0242, "epss_percentile": 0.84702}, "CVE-2008-5286": {"epss_score": 0.10607, "epss_percentile": 0.93044}, "CVE-2008-5287": {"epss_score": 0.00723, "epss_percentile": 0.72008}, "CVE-2008-5288": {"epss_score": 0.03419, "epss_percentile": 0.87097}, "CVE-2008-5289": {"epss_score": 0.01378, "epss_percentile": 0.79848}, "CVE-2008-5290": {"epss_score": 0.02861, "epss_percentile": 0.85852}, "CVE-2008-5291": {"epss_score": 0.03063, "epss_percentile": 0.8632}, "CVE-2008-5292": {"epss_score": 0.00723, "epss_percentile": 0.72008}, "CVE-2008-5293": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2008-5294": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2008-5295": {"epss_score": 0.00397, "epss_percentile": 0.60016}, "CVE-2008-5296": {"epss_score": 0.00306, "epss_percentile": 0.53427}, "CVE-2008-5297": {"epss_score": 0.14325, "epss_percentile": 0.94187}, "CVE-2008-5298": {"epss_score": 0.00061, "epss_percentile": 0.19409}, "CVE-2008-5299": {"epss_score": 0.00021, "epss_percentile": 0.0483}, "CVE-2008-5300": {"epss_score": 0.00078, "epss_percentile": 0.23606}, "CVE-2008-5301": {"epss_score": 0.00569, "epss_percentile": 0.6793}, "CVE-2008-5302": {"epss_score": 0.00047, "epss_percentile": 0.14773}, "CVE-2008-5303": {"epss_score": 0.00028, "epss_percentile": 0.07582}, "CVE-2008-5304": {"epss_score": 0.05148, "epss_percentile": 0.89546}, "CVE-2008-5305": {"epss_score": 0.03174, "epss_percentile": 0.86557}, "CVE-2008-5306": {"epss_score": 0.00723, "epss_percentile": 0.72008}, "CVE-2008-5307": {"epss_score": 0.01309, "epss_percentile": 0.79355}, "CVE-2008-5308": {"epss_score": 0.07789, "epss_percentile": 0.91682}, "CVE-2008-5309": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5310": {"epss_score": 0.00355, "epss_percentile": 0.57299}, "CVE-2008-5311": {"epss_score": 0.00328, "epss_percentile": 0.5519}, "CVE-2008-5312": {"epss_score": 0.00024, "epss_percentile": 0.05734}, "CVE-2008-5313": {"epss_score": 0.00024, "epss_percentile": 0.05734}, "CVE-2008-5314": {"epss_score": 0.26689, "epss_percentile": 0.96165}, "CVE-2008-5315": {"epss_score": 0.0015, "epss_percentile": 0.3607}, "CVE-2008-5316": {"epss_score": 0.01844, "epss_percentile": 0.82506}, "CVE-2008-5317": {"epss_score": 0.00949, "epss_percentile": 0.75847}, "CVE-2008-5318": {"epss_score": 0.00542, "epss_percentile": 0.67066}, "CVE-2008-5319": {"epss_score": 0.00542, "epss_percentile": 0.67066}, "CVE-2008-5320": {"epss_score": 0.00354, "epss_percentile": 0.57217}, "CVE-2008-5321": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5322": {"epss_score": 0.0463, "epss_percentile": 0.88944}, "CVE-2008-5323": {"epss_score": 0.03005, "epss_percentile": 0.86182}, "CVE-2008-5324": {"epss_score": 0.00202, "epss_percentile": 0.42481}, "CVE-2008-5325": {"epss_score": 0.00322, "epss_percentile": 0.54814}, "CVE-2008-5326": {"epss_score": 0.00065, "epss_percentile": 0.2061}, "CVE-2008-5327": {"epss_score": 0.00393, "epss_percentile": 0.59713}, "CVE-2008-5328": {"epss_score": 0.00533, "epss_percentile": 0.66764}, "CVE-2008-5329": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2008-5330": {"epss_score": 0.01632, "epss_percentile": 0.81455}, "CVE-2008-5331": {"epss_score": 0.00781, "epss_percentile": 0.73179}, "CVE-2008-5332": {"epss_score": 0.0212, "epss_percentile": 0.83675}, "CVE-2008-5333": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5334": {"epss_score": 0.02703, "epss_percentile": 0.85459}, "CVE-2008-5335": {"epss_score": 0.0096, "epss_percentile": 0.75963}, "CVE-2008-5336": {"epss_score": 0.00606, "epss_percentile": 0.69015}, "CVE-2008-5337": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2008-5338": {"epss_score": 0.02582, "epss_percentile": 0.85158}, "CVE-2008-5339": {"epss_score": 0.01328, "epss_percentile": 0.795}, "CVE-2008-5340": {"epss_score": 0.04012, "epss_percentile": 0.88113}, "CVE-2008-5341": {"epss_score": 0.01131, "epss_percentile": 0.77866}, "CVE-2008-5342": {"epss_score": 0.01131, "epss_percentile": 0.77866}, "CVE-2008-5343": {"epss_score": 0.05036, "epss_percentile": 0.89422}, "CVE-2008-5344": {"epss_score": 0.01474, "epss_percentile": 0.80522}, "CVE-2008-5345": {"epss_score": 0.0488, "epss_percentile": 0.89245}, "CVE-2008-5346": {"epss_score": 0.03998, "epss_percentile": 0.88089}, "CVE-2008-5347": {"epss_score": 0.02768, "epss_percentile": 0.85615}, "CVE-2008-5348": {"epss_score": 0.12172, "epss_percentile": 0.9359}, "CVE-2008-5349": {"epss_score": 0.07779, "epss_percentile": 0.91677}, "CVE-2008-5350": {"epss_score": 0.01668, "epss_percentile": 0.81663}, "CVE-2008-5351": {"epss_score": 0.03276, "epss_percentile": 0.86804}, "CVE-2008-5352": {"epss_score": 0.085, "epss_percentile": 0.92084}, "CVE-2008-5353": {"epss_score": 0.90124, "epss_percentile": 0.99562}, "CVE-2008-5354": {"epss_score": 0.21216, "epss_percentile": 0.95478}, "CVE-2008-5355": {"epss_score": 0.17772, "epss_percentile": 0.94904}, "CVE-2008-5356": {"epss_score": 0.07682, "epss_percentile": 0.91623}, "CVE-2008-5357": {"epss_score": 0.07609, "epss_percentile": 0.91567}, "CVE-2008-5358": {"epss_score": 0.26242, "epss_percentile": 0.96127}, "CVE-2008-5359": {"epss_score": 0.35129, "epss_percentile": 0.96889}, "CVE-2008-5360": {"epss_score": 0.03736, "epss_percentile": 0.87651}, "CVE-2008-5361": {"epss_score": 0.01538, "epss_percentile": 0.80933}, "CVE-2008-5362": {"epss_score": 0.01538, "epss_percentile": 0.80933}, "CVE-2008-5363": {"epss_score": 0.01834, "epss_percentile": 0.8246}, "CVE-2008-5364": {"epss_score": 0.03176, "epss_percentile": 0.86571}, "CVE-2008-5365": {"epss_score": 0.00699, "epss_percentile": 0.71444}, "CVE-2008-5366": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5367": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5368": {"epss_score": 0.00026, "epss_percentile": 0.06549}, "CVE-2008-5369": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5370": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5371": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5372": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5373": {"epss_score": 0.00034, "epss_percentile": 0.09793}, "CVE-2008-5374": {"epss_score": 0.00054, "epss_percentile": 0.17344}, "CVE-2008-5375": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-5376": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5377": {"epss_score": 0.00206, "epss_percentile": 0.42935}, "CVE-2008-5378": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5379": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2008-5380": {"epss_score": 0.00093, "epss_percentile": 0.26736}, "CVE-2008-5381": {"epss_score": 0.11647, "epss_percentile": 0.93428}, "CVE-2008-5382": {"epss_score": 0.00261, "epss_percentile": 0.49312}, "CVE-2008-5383": {"epss_score": 0.06452, "epss_percentile": 0.90765}, "CVE-2008-5384": {"epss_score": 0.00046, "epss_percentile": 0.1417}, "CVE-2008-5385": {"epss_score": 0.0004, "epss_percentile": 0.11976}, "CVE-2008-5386": {"epss_score": 0.00051, "epss_percentile": 0.16183}, "CVE-2008-5387": {"epss_score": 0.00049, "epss_percentile": 0.15304}, "CVE-2008-5393": {"epss_score": 0.0051, "epss_percentile": 0.65758}, "CVE-2008-5394": {"epss_score": 0.00077, "epss_percentile": 0.23542}, "CVE-2008-5395": {"epss_score": 0.0006, "epss_percentile": 0.19017}, "CVE-2008-5396": {"epss_score": 0.00034, "epss_percentile": 0.09564}, "CVE-2008-5397": {"epss_score": 0.00045, "epss_percentile": 0.13988}, "CVE-2008-5398": {"epss_score": 0.00838, "epss_percentile": 0.74174}, "CVE-2008-5399": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-5400": {"epss_score": 0.00437, "epss_percentile": 0.62536}, "CVE-2008-5401": {"epss_score": 0.26693, "epss_percentile": 0.96166}, "CVE-2008-5402": {"epss_score": 0.1877, "epss_percentile": 0.95066}, "CVE-2008-5403": {"epss_score": 0.25557, "epss_percentile": 0.96043}, "CVE-2008-5404": {"epss_score": 0.04078, "epss_percentile": 0.88214}, "CVE-2008-5405": {"epss_score": 0.82978, "epss_percentile": 0.99224}, "CVE-2008-5406": {"epss_score": 0.06123, "epss_percentile": 0.90497}, "CVE-2008-5407": {"epss_score": 0.01388, "epss_percentile": 0.79922}, "CVE-2008-5408": {"epss_score": 0.04959, "epss_percentile": 0.89332}, "CVE-2008-5409": {"epss_score": 0.22719, "epss_percentile": 0.95673}, "CVE-2008-5410": {"epss_score": 0.0115, "epss_percentile": 0.78028}, "CVE-2008-5411": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2008-5412": {"epss_score": 0.01349, "epss_percentile": 0.79671}, "CVE-2008-5413": {"epss_score": 0.00302, "epss_percentile": 0.53118}, "CVE-2008-5414": {"epss_score": 0.01269, "epss_percentile": 0.79034}, "CVE-2008-5415": {"epss_score": 0.15626, "epss_percentile": 0.94472}, "CVE-2008-5416": {"epss_score": 0.89069, "epss_percentile": 0.99507}, "CVE-2008-5417": {"epss_score": 0.00079, "epss_percentile": 0.23979}, "CVE-2008-5418": {"epss_score": 0.02588, "epss_percentile": 0.85173}, "CVE-2008-5419": {"epss_score": 0.24239, "epss_percentile": 0.95896}, "CVE-2008-5420": {"epss_score": 0.00762, "epss_percentile": 0.72834}, "CVE-2008-5421": {"epss_score": 0.00501, "epss_percentile": 0.6534}, "CVE-2008-5422": {"epss_score": 0.01327, "epss_percentile": 0.79485}, "CVE-2008-5423": {"epss_score": 0.00077, "epss_percentile": 0.23466}, "CVE-2008-5424": {"epss_score": 0.28809, "epss_percentile": 0.96389}, "CVE-2008-5425": {"epss_score": 0.00698, "epss_percentile": 0.71419}, "CVE-2008-5426": {"epss_score": 0.00574, "epss_percentile": 0.68069}, "CVE-2008-5427": {"epss_score": 0.00868, "epss_percentile": 0.74677}, "CVE-2008-5428": {"epss_score": 0.00469, "epss_percentile": 0.63937}, "CVE-2008-5429": {"epss_score": 0.00574, "epss_percentile": 0.68069}, "CVE-2008-5430": {"epss_score": 0.00564, "epss_percentile": 0.67768}, "CVE-2008-5431": {"epss_score": 0.03539, "epss_percentile": 0.87315}, "CVE-2008-5432": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2008-5433": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-5434": {"epss_score": 0.00601, "epss_percentile": 0.68862}, "CVE-2008-5435": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-5436": {"epss_score": 0.0132, "epss_percentile": 0.79441}, "CVE-2008-5437": {"epss_score": 0.00361, "epss_percentile": 0.57722}, "CVE-2008-5438": {"epss_score": 0.00488, "epss_percentile": 0.64837}, "CVE-2008-5439": {"epss_score": 0.00544, "epss_percentile": 0.6713}, "CVE-2008-5440": {"epss_score": 0.01952, "epss_percentile": 0.83024}, "CVE-2008-5441": {"epss_score": 0.01284, "epss_percentile": 0.7917}, "CVE-2008-5442": {"epss_score": 0.01284, "epss_percentile": 0.7917}, "CVE-2008-5443": {"epss_score": 0.01057, "epss_percentile": 0.77135}, "CVE-2008-5444": {"epss_score": 0.75864, "epss_percentile": 0.98867}, "CVE-2008-5445": {"epss_score": 0.01397, "epss_percentile": 0.79985}, "CVE-2008-5446": {"epss_score": 0.00358, "epss_percentile": 0.57493}, "CVE-2008-5447": {"epss_score": 0.00301, "epss_percentile": 0.53067}, "CVE-2008-5448": {"epss_score": 0.81775, "epss_percentile": 0.99155}, "CVE-2008-5449": {"epss_score": 0.03456, "epss_percentile": 0.87173}, "CVE-2008-5450": {"epss_score": 0.0018, "epss_percentile": 0.39965}, "CVE-2008-5451": {"epss_score": 0.00248, "epss_percentile": 0.47925}, "CVE-2008-5452": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-5454": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-5455": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-5456": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-5457": {"epss_score": 0.81836, "epss_percentile": 0.99161}, "CVE-2008-5458": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-5459": {"epss_score": 0.00294, "epss_percentile": 0.52423}, "CVE-2008-5460": {"epss_score": 0.00294, "epss_percentile": 0.52423}, "CVE-2008-5461": {"epss_score": 0.00803, "epss_percentile": 0.73606}, "CVE-2008-5462": {"epss_score": 0.00569, "epss_percentile": 0.67922}, "CVE-2008-5463": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2008-5486": {"epss_score": 0.00328, "epss_percentile": 0.5519}, "CVE-2008-5487": {"epss_score": 0.02499, "epss_percentile": 0.84914}, "CVE-2008-5488": {"epss_score": 0.00517, "epss_percentile": 0.66081}, "CVE-2008-5489": {"epss_score": 0.01121, "epss_percentile": 0.77767}, "CVE-2008-5490": {"epss_score": 0.00723, "epss_percentile": 0.72008}, "CVE-2008-5491": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5492": {"epss_score": 0.70177, "epss_percentile": 0.98621}, "CVE-2008-5493": {"epss_score": 0.00801, "epss_percentile": 0.73576}, "CVE-2008-5494": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2008-5495": {"epss_score": 0.01765, "epss_percentile": 0.82165}, "CVE-2008-5496": {"epss_score": 0.00801, "epss_percentile": 0.73576}, "CVE-2008-5497": {"epss_score": 0.01768, "epss_percentile": 0.82183}, "CVE-2008-5498": {"epss_score": 0.11101, "epss_percentile": 0.9322}, "CVE-2008-5499": {"epss_score": 0.89624, "epss_percentile": 0.99535}, "CVE-2008-5500": {"epss_score": 0.03551, "epss_percentile": 0.87341}, "CVE-2008-5501": {"epss_score": 0.04539, "epss_percentile": 0.88827}, "CVE-2008-5502": {"epss_score": 0.03767, "epss_percentile": 0.87697}, "CVE-2008-5503": {"epss_score": 0.0114, "epss_percentile": 0.77951}, "CVE-2008-5504": {"epss_score": 0.03696, "epss_percentile": 0.87585}, "CVE-2008-5505": {"epss_score": 0.00833, "epss_percentile": 0.74081}, "CVE-2008-5506": {"epss_score": 0.01236, "epss_percentile": 0.78772}, "CVE-2008-5507": {"epss_score": 0.00535, "epss_percentile": 0.66828}, "CVE-2008-5508": {"epss_score": 0.02341, "epss_percentile": 0.84436}, "CVE-2008-5510": {"epss_score": 0.01132, "epss_percentile": 0.77869}, "CVE-2008-5511": {"epss_score": 0.01798, "epss_percentile": 0.82311}, "CVE-2008-5512": {"epss_score": 0.05142, "epss_percentile": 0.89539}, "CVE-2008-5513": {"epss_score": 0.01647, "epss_percentile": 0.81539}, "CVE-2008-5514": {"epss_score": 0.01071, "epss_percentile": 0.77262}, "CVE-2008-5515": {"epss_score": 0.60688, "epss_percentile": 0.98216}, "CVE-2008-5516": {"epss_score": 0.01455, "epss_percentile": 0.80386}, "CVE-2008-5517": {"epss_score": 0.06396, "epss_percentile": 0.90723}, "CVE-2008-5518": {"epss_score": 0.15783, "epss_percentile": 0.94509}, "CVE-2008-5519": {"epss_score": 0.04557, "epss_percentile": 0.88848}, "CVE-2008-5520": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5521": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5522": {"epss_score": 0.00313, "epss_percentile": 0.54056}, "CVE-2008-5523": {"epss_score": 0.00313, "epss_percentile": 0.54056}, "CVE-2008-5524": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5525": {"epss_score": 0.00399, "epss_percentile": 0.60109}, "CVE-2008-5526": {"epss_score": 0.00313, "epss_percentile": 0.54056}, "CVE-2008-5527": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5528": {"epss_score": 0.00124, "epss_percentile": 0.32361}, "CVE-2008-5529": {"epss_score": 0.00313, "epss_percentile": 0.54056}, "CVE-2008-5530": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5531": {"epss_score": 0.00313, "epss_percentile": 0.54056}, "CVE-2008-5532": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5533": {"epss_score": 0.00313, "epss_percentile": 0.54056}, "CVE-2008-5534": {"epss_score": 0.00313, "epss_percentile": 0.54056}, "CVE-2008-5535": {"epss_score": 0.00313, "epss_percentile": 0.54056}, "CVE-2008-5536": {"epss_score": 0.00276, "epss_percentile": 0.50737}, "CVE-2008-5537": {"epss_score": 0.00313, "epss_percentile": 0.54056}, "CVE-2008-5538": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5539": {"epss_score": 0.00117, "epss_percentile": 0.31292}, "CVE-2008-5540": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5541": {"epss_score": 0.00761, "epss_percentile": 0.7283}, "CVE-2008-5542": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5543": {"epss_score": 0.00529, "epss_percentile": 0.66589}, "CVE-2008-5544": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5545": {"epss_score": 0.00313, "epss_percentile": 0.54056}, "CVE-2008-5546": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5547": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5548": {"epss_score": 0.00293, "epss_percentile": 0.52324}, "CVE-2008-5549": {"epss_score": 0.00463, "epss_percentile": 0.63698}, "CVE-2008-5550": {"epss_score": 0.00495, "epss_percentile": 0.65129}, "CVE-2008-5551": {"epss_score": 0.25856, "epss_percentile": 0.96085}, "CVE-2008-5552": {"epss_score": 0.08062, "epss_percentile": 0.91861}, "CVE-2008-5553": {"epss_score": 0.1369, "epss_percentile": 0.94035}, "CVE-2008-5554": {"epss_score": 0.1369, "epss_percentile": 0.94035}, "CVE-2008-5555": {"epss_score": 0.15465, "epss_percentile": 0.94433}, "CVE-2008-5556": {"epss_score": 0.11107, "epss_percentile": 0.93222}, "CVE-2008-5557": {"epss_score": 0.29698, "epss_percentile": 0.96467}, "CVE-2008-5558": {"epss_score": 0.02095, "epss_percentile": 0.83583}, "CVE-2008-5559": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2008-5560": {"epss_score": 0.05453, "epss_percentile": 0.89893}, "CVE-2008-5561": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5562": {"epss_score": 0.0179, "epss_percentile": 0.82279}, "CVE-2008-5563": {"epss_score": 0.01811, "epss_percentile": 0.82367}, "CVE-2008-5564": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2008-5565": {"epss_score": 0.00348, "epss_percentile": 0.56837}, "CVE-2008-5566": {"epss_score": 0.04087, "epss_percentile": 0.88228}, "CVE-2008-5567": {"epss_score": 0.00348, "epss_percentile": 0.56837}, "CVE-2008-5568": {"epss_score": 0.00348, "epss_percentile": 0.56837}, "CVE-2008-5569": {"epss_score": 0.01873, "epss_percentile": 0.82642}, "CVE-2008-5570": {"epss_score": 0.05411, "epss_percentile": 0.89846}, "CVE-2008-5571": {"epss_score": 0.00747, "epss_percentile": 0.72567}, "CVE-2008-5572": {"epss_score": 0.0437, "epss_percentile": 0.88608}, "CVE-2008-5573": {"epss_score": 0.00699, "epss_percentile": 0.71444}, "CVE-2008-5574": {"epss_score": 0.00402, "epss_percentile": 0.60301}, "CVE-2008-5575": {"epss_score": 0.00497, "epss_percentile": 0.65179}, "CVE-2008-5576": {"epss_score": 0.01768, "epss_percentile": 0.82183}, "CVE-2008-5577": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2008-5578": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5579": {"epss_score": 0.03467, "epss_percentile": 0.87193}, "CVE-2008-5580": {"epss_score": 0.02797, "epss_percentile": 0.85684}, "CVE-2008-5581": {"epss_score": 0.02428, "epss_percentile": 0.84721}, "CVE-2008-5582": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5583": {"epss_score": 0.0028, "epss_percentile": 0.51077}, "CVE-2008-5584": {"epss_score": 0.02339, "epss_percentile": 0.84426}, "CVE-2008-5585": {"epss_score": 0.02985, "epss_percentile": 0.86127}, "CVE-2008-5586": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5587": {"epss_score": 0.01986, "epss_percentile": 0.83159}, "CVE-2008-5588": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5589": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2008-5590": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5591": {"epss_score": 0.0291, "epss_percentile": 0.85969}, "CVE-2008-5592": {"epss_score": 0.05365, "epss_percentile": 0.89788}, "CVE-2008-5593": {"epss_score": 0.03012, "epss_percentile": 0.86201}, "CVE-2008-5594": {"epss_score": 0.03063, "epss_percentile": 0.8632}, "CVE-2008-5595": {"epss_score": 0.00723, "epss_percentile": 0.72008}, "CVE-2008-5596": {"epss_score": 0.05365, "epss_percentile": 0.89788}, "CVE-2008-5597": {"epss_score": 0.0463, "epss_percentile": 0.88944}, "CVE-2008-5598": {"epss_score": 0.03467, "epss_percentile": 0.87193}, "CVE-2008-5599": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2008-5600": {"epss_score": 0.05365, "epss_percentile": 0.89788}, "CVE-2008-5601": {"epss_score": 0.05365, "epss_percentile": 0.89788}, "CVE-2008-5602": {"epss_score": 0.0463, "epss_percentile": 0.88944}, "CVE-2008-5603": {"epss_score": 0.05365, "epss_percentile": 0.89788}, "CVE-2008-5604": {"epss_score": 0.05411, "epss_percentile": 0.89846}, "CVE-2008-5605": {"epss_score": 0.00167, "epss_percentile": 0.38297}, "CVE-2008-5606": {"epss_score": 0.0463, "epss_percentile": 0.88944}, "CVE-2008-5607": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5608": {"epss_score": 0.06897, "epss_percentile": 0.91101}, "CVE-2008-5609": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-5616": {"epss_score": 0.30642, "epss_percentile": 0.96558}, "CVE-2008-5617": {"epss_score": 0.00389, "epss_percentile": 0.59494}, "CVE-2008-5618": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2008-5619": {"epss_score": 0.77735, "epss_percentile": 0.9895}, "CVE-2008-5620": {"epss_score": 0.00568, "epss_percentile": 0.67883}, "CVE-2008-5621": {"epss_score": 0.00559, "epss_percentile": 0.67619}, "CVE-2008-5624": {"epss_score": 0.01502, "epss_percentile": 0.80722}, "CVE-2008-5625": {"epss_score": 0.10822, "epss_percentile": 0.93123}, "CVE-2008-5626": {"epss_score": 0.83067, "epss_percentile": 0.9923}, "CVE-2008-5627": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5628": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5629": {"epss_score": 0.00497, "epss_percentile": 0.65209}, "CVE-2008-5630": {"epss_score": 0.00699, "epss_percentile": 0.71444}, "CVE-2008-5631": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5632": {"epss_score": 0.00477, "epss_percentile": 0.64296}, "CVE-2008-5633": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5634": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5635": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5636": {"epss_score": 0.00699, "epss_percentile": 0.71444}, "CVE-2008-5637": {"epss_score": 0.00144, "epss_percentile": 0.35338}, "CVE-2008-5638": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5639": {"epss_score": 0.03467, "epss_percentile": 0.87193}, "CVE-2008-5640": {"epss_score": 0.00699, "epss_percentile": 0.71444}, "CVE-2008-5641": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5642": {"epss_score": 0.08449, "epss_percentile": 0.92057}, "CVE-2008-5643": {"epss_score": 0.00019, "epss_percentile": 0.04371}, "CVE-2008-5644": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2008-5645": {"epss_score": 0.00245, "epss_percentile": 0.47628}, "CVE-2008-5646": {"epss_score": 0.00475, "epss_percentile": 0.64198}, "CVE-2008-5647": {"epss_score": 0.00403, "epss_percentile": 0.60377}, "CVE-2008-5648": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5649": {"epss_score": 0.01109, "epss_percentile": 0.77642}, "CVE-2008-5650": {"epss_score": 0.00629, "epss_percentile": 0.69676}, "CVE-2008-5651": {"epss_score": 0.00416, "epss_percentile": 0.61179}, "CVE-2008-5652": {"epss_score": 0.0075, "epss_percentile": 0.72623}, "CVE-2008-5653": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5654": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2008-5655": {"epss_score": 0.00183, "epss_percentile": 0.40289}, "CVE-2008-5656": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-5657": {"epss_score": 0.01449, "epss_percentile": 0.80339}, "CVE-2008-5658": {"epss_score": 0.02361, "epss_percentile": 0.84495}, "CVE-2008-5659": {"epss_score": 0.01753, "epss_percentile": 0.82111}, "CVE-2008-5660": {"epss_score": 0.01374, "epss_percentile": 0.79824}, "CVE-2008-5661": {"epss_score": 0.00723, "epss_percentile": 0.72015}, "CVE-2008-5662": {"epss_score": 0.02451, "epss_percentile": 0.84782}, "CVE-2008-5663": {"epss_score": 0.10576, "epss_percentile": 0.93032}, "CVE-2008-5664": {"epss_score": 0.78207, "epss_percentile": 0.98973}, "CVE-2008-5665": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5666": {"epss_score": 0.63292, "epss_percentile": 0.98327}, "CVE-2008-5667": {"epss_score": 0.07073, "epss_percentile": 0.9123}, "CVE-2008-5668": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-5669": {"epss_score": 0.00742, "epss_percentile": 0.72452}, "CVE-2008-5670": {"epss_score": 0.00548, "epss_percentile": 0.67267}, "CVE-2008-5671": {"epss_score": 0.00095, "epss_percentile": 0.27139}, "CVE-2008-5672": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2008-5673": {"epss_score": 0.00294, "epss_percentile": 0.52399}, "CVE-2008-5674": {"epss_score": 0.21139, "epss_percentile": 0.95469}, "CVE-2008-5675": {"epss_score": 0.00509, "epss_percentile": 0.65719}, "CVE-2008-5676": {"epss_score": 0.00317, "epss_percentile": 0.5436}, "CVE-2008-5677": {"epss_score": 0.03606, "epss_percentile": 0.87417}, "CVE-2008-5678": {"epss_score": 0.04506, "epss_percentile": 0.88773}, "CVE-2008-5679": {"epss_score": 0.01199, "epss_percentile": 0.78462}, "CVE-2008-5680": {"epss_score": 0.19947, "epss_percentile": 0.95265}, "CVE-2008-5681": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2008-5682": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-5683": {"epss_score": 0.00384, "epss_percentile": 0.59156}, "CVE-2008-5684": {"epss_score": 0.01184, "epss_percentile": 0.7833}, "CVE-2008-5685": {"epss_score": 0.02419, "epss_percentile": 0.84698}, "CVE-2008-5686": {"epss_score": 0.00739, "epss_percentile": 0.72397}, "CVE-2008-5687": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2008-5688": {"epss_score": 0.00387, "epss_percentile": 0.59332}, "CVE-2008-5689": {"epss_score": 0.00213, "epss_percentile": 0.43923}, "CVE-2008-5690": {"epss_score": 0.00043, "epss_percentile": 0.13141}, "CVE-2008-5691": {"epss_score": 0.05979, "epss_percentile": 0.90377}, "CVE-2008-5692": {"epss_score": 0.01151, "epss_percentile": 0.78042}, "CVE-2008-5693": {"epss_score": 0.00091, "epss_percentile": 0.26263}, "CVE-2008-5694": {"epss_score": 0.00838, "epss_percentile": 0.74172}, "CVE-2008-5695": {"epss_score": 0.15284, "epss_percentile": 0.944}, "CVE-2008-5696": {"epss_score": 0.02493, "epss_percentile": 0.84901}, "CVE-2008-5697": {"epss_score": 0.0463, "epss_percentile": 0.88944}, "CVE-2008-5698": {"epss_score": 0.07066, "epss_percentile": 0.91224}, "CVE-2008-5699": {"epss_score": 0.00045, "epss_percentile": 0.13753}, "CVE-2008-5700": {"epss_score": 0.00083, "epss_percentile": 0.24624}, "CVE-2008-5701": {"epss_score": 0.0006, "epss_percentile": 0.18958}, "CVE-2008-5702": {"epss_score": 0.00061, "epss_percentile": 0.19311}, "CVE-2008-5703": {"epss_score": 0.00064, "epss_percentile": 0.20377}, "CVE-2008-5704": {"epss_score": 0.00309, "epss_percentile": 0.53655}, "CVE-2008-5705": {"epss_score": 0.0733, "epss_percentile": 0.91413}, "CVE-2008-5706": {"epss_score": 0.00221, "epss_percentile": 0.44704}, "CVE-2008-5707": {"epss_score": 0.00288, "epss_percentile": 0.51976}, "CVE-2008-5708": {"epss_score": 0.03673, "epss_percentile": 0.87547}, "CVE-2008-5709": {"epss_score": 0.04671, "epss_percentile": 0.88986}, "CVE-2008-5710": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2008-5711": {"epss_score": 0.55683, "epss_percentile": 0.97989}, "CVE-2008-5712": {"epss_score": 0.04166, "epss_percentile": 0.88342}, "CVE-2008-5713": {"epss_score": 0.0014, "epss_percentile": 0.34748}, "CVE-2008-5714": {"epss_score": 0.00748, "epss_percentile": 0.72589}, "CVE-2008-5715": {"epss_score": 0.07761, "epss_percentile": 0.91665}, "CVE-2008-5716": {"epss_score": 0.00064, "epss_percentile": 0.20271}, "CVE-2008-5717": {"epss_score": 0.0032, "epss_percentile": 0.5458}, "CVE-2008-5718": {"epss_score": 0.01824, "epss_percentile": 0.82425}, "CVE-2008-5719": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2008-5720": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-5721": {"epss_score": 0.00351, "epss_percentile": 0.57032}, "CVE-2008-5722": {"epss_score": 0.09306, "epss_percentile": 0.92493}, "CVE-2008-5723": {"epss_score": 0.00106, "epss_percentile": 0.29485}, "CVE-2008-5724": {"epss_score": 0.00217, "epss_percentile": 0.44302}, "CVE-2008-5725": {"epss_score": 0.00265, "epss_percentile": 0.49774}, "CVE-2008-5726": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2008-5727": {"epss_score": 0.00172, "epss_percentile": 0.39016}, "CVE-2008-5728": {"epss_score": 0.02588, "epss_percentile": 0.85173}, "CVE-2008-5729": {"epss_score": 0.02457, "epss_percentile": 0.84803}, "CVE-2008-5730": {"epss_score": 0.0347, "epss_percentile": 0.87196}, "CVE-2008-5731": {"epss_score": 0.00166, "epss_percentile": 0.38179}, "CVE-2008-5732": {"epss_score": 0.14739, "epss_percentile": 0.94272}, "CVE-2008-5733": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2008-5734": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-5735": {"epss_score": 0.31435, "epss_percentile": 0.9662}, "CVE-2008-5736": {"epss_score": 0.00366, "epss_percentile": 0.58073}, "CVE-2008-5737": {"epss_score": 0.00723, "epss_percentile": 0.72008}, "CVE-2008-5738": {"epss_score": 0.01946, "epss_percentile": 0.83004}, "CVE-2008-5739": {"epss_score": 0.00167, "epss_percentile": 0.38297}, "CVE-2008-5742": {"epss_score": 0.02588, "epss_percentile": 0.85173}, "CVE-2008-5743": {"epss_score": 0.00057, "epss_percentile": 0.17981}, "CVE-2008-5744": {"epss_score": 0.00034, "epss_percentile": 0.0962}, "CVE-2008-5745": {"epss_score": 0.3355, "epss_percentile": 0.96783}, "CVE-2008-5746": {"epss_score": 0.00032, "epss_percentile": 0.08825}, "CVE-2008-5747": {"epss_score": 0.00498, "epss_percentile": 0.6524}, "CVE-2008-5748": {"epss_score": 0.08433, "epss_percentile": 0.9205}, "CVE-2008-5749": {"epss_score": 0.04754, "epss_percentile": 0.89108}, "CVE-2008-5750": {"epss_score": 0.1432, "epss_percentile": 0.94186}, "CVE-2008-5751": {"epss_score": 0.00387, "epss_percentile": 0.5929}, "CVE-2008-5752": {"epss_score": 0.09972, "epss_percentile": 0.92798}, "CVE-2008-5753": {"epss_score": 0.27784, "epss_percentile": 0.96283}, "CVE-2008-5754": {"epss_score": 0.05014, "epss_percentile": 0.89394}, "CVE-2008-5755": {"epss_score": 0.26083, "epss_percentile": 0.96109}, "CVE-2008-5756": {"epss_score": 0.10447, "epss_percentile": 0.92989}, "CVE-2008-5757": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2008-5758": {"epss_score": 0.00205, "epss_percentile": 0.4276}, "CVE-2008-5759": {"epss_score": 0.00198, "epss_percentile": 0.41986}, "CVE-2008-5760": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2008-5761": {"epss_score": 0.05677, "epss_percentile": 0.90112}, "CVE-2008-5762": {"epss_score": 0.05365, "epss_percentile": 0.89788}, "CVE-2008-5763": {"epss_score": 0.05612, "epss_percentile": 0.90048}, "CVE-2008-5764": {"epss_score": 0.38693, "epss_percentile": 0.97116}, "CVE-2008-5765": {"epss_score": 0.03696, "epss_percentile": 0.87585}, "CVE-2008-5766": {"epss_score": 0.00144, "epss_percentile": 0.35338}, "CVE-2008-5767": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5768": {"epss_score": 0.00161, "epss_percentile": 0.37568}, "CVE-2008-5769": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2008-5770": {"epss_score": 0.0391, "epss_percentile": 0.87932}, "CVE-2008-5771": {"epss_score": 0.03012, "epss_percentile": 0.86201}, "CVE-2008-5772": {"epss_score": 0.00776, "epss_percentile": 0.73097}, "CVE-2008-5773": {"epss_score": 0.05365, "epss_percentile": 0.89788}, "CVE-2008-5774": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5775": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5776": {"epss_score": 0.02343, "epss_percentile": 0.84443}, "CVE-2008-5777": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5778": {"epss_score": 0.01433, "epss_percentile": 0.80261}, "CVE-2008-5779": {"epss_score": 0.00242, "epss_percentile": 0.4734}, "CVE-2008-5780": {"epss_score": 0.0463, "epss_percentile": 0.88944}, "CVE-2008-5781": {"epss_score": 0.00448, "epss_percentile": 0.62998}, "CVE-2008-5782": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2008-5783": {"epss_score": 0.05629, "epss_percentile": 0.90067}, "CVE-2008-5784": {"epss_score": 0.04996, "epss_percentile": 0.89373}, "CVE-2008-5785": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2008-5786": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-5787": {"epss_score": 0.07157, "epss_percentile": 0.9129}, "CVE-2008-5788": {"epss_score": 0.00723, "epss_percentile": 0.72008}, "CVE-2008-5789": {"epss_score": 0.04862, "epss_percentile": 0.89222}, "CVE-2008-5790": {"epss_score": 0.01039, "epss_percentile": 0.76943}, "CVE-2008-5791": {"epss_score": 0.00402, "epss_percentile": 0.60292}, "CVE-2008-5792": {"epss_score": 0.11272, "epss_percentile": 0.93288}, "CVE-2008-5793": {"epss_score": 0.10713, "epss_percentile": 0.93081}, "CVE-2008-5794": {"epss_score": 0.03511, "epss_percentile": 0.87266}, "CVE-2008-5795": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2008-5796": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-5797": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-5798": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-5799": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-5800": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2008-5801": {"epss_score": 0.00952, "epss_percentile": 0.75883}, "CVE-2008-5802": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2008-5803": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2008-5804": {"epss_score": 0.00397, "epss_percentile": 0.60016}, "CVE-2008-5805": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2008-5806": {"epss_score": 0.00723, "epss_percentile": 0.72008}, "CVE-2008-5807": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-5808": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-5809": {"epss_score": 0.00285, "epss_percentile": 0.51539}, "CVE-2008-5810": {"epss_score": 0.03704, "epss_percentile": 0.87595}, "CVE-2008-5811": {"epss_score": 0.00025, "epss_percentile": 0.06262}, "CVE-2008-5812": {"epss_score": 0.00366, "epss_percentile": 0.58021}, "CVE-2008-5813": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2008-5814": {"epss_score": 0.0078, "epss_percentile": 0.73167}, "CVE-2008-5815": {"epss_score": 0.00142, "epss_percentile": 0.35005}, "CVE-2008-5816": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5817": {"epss_score": 0.00997, "epss_percentile": 0.76454}, "CVE-2008-5818": {"epss_score": 0.03164, "epss_percentile": 0.86536}, "CVE-2008-5819": {"epss_score": 0.03012, "epss_percentile": 0.86201}, "CVE-2008-5820": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5821": {"epss_score": 0.11579, "epss_percentile": 0.9341}, "CVE-2008-5822": {"epss_score": 0.00501, "epss_percentile": 0.6534}, "CVE-2008-5823": {"epss_score": 0.13707, "epss_percentile": 0.94039}, "CVE-2008-5824": {"epss_score": 0.11128, "epss_percentile": 0.93232}, "CVE-2008-5825": {"epss_score": 0.00579, "epss_percentile": 0.68222}, "CVE-2008-5826": {"epss_score": 0.02595, "epss_percentile": 0.85192}, "CVE-2008-5827": {"epss_score": 0.01957, "epss_percentile": 0.83042}, "CVE-2008-5828": {"epss_score": 0.17855, "epss_percentile": 0.94917}, "CVE-2008-5838": {"epss_score": 0.00723, "epss_percentile": 0.72008}, "CVE-2008-5839": {"epss_score": 0.06584, "epss_percentile": 0.90864}, "CVE-2008-5840": {"epss_score": 0.01768, "epss_percentile": 0.82183}, "CVE-2008-5841": {"epss_score": 0.00448, "epss_percentile": 0.62998}, "CVE-2008-5842": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-5843": {"epss_score": 0.00168, "epss_percentile": 0.38422}, "CVE-2008-5844": {"epss_score": 0.00434, "epss_percentile": 0.62302}, "CVE-2008-5845": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-5846": {"epss_score": 0.00152, "epss_percentile": 0.36431}, "CVE-2008-5847": {"epss_score": 0.03499, "epss_percentile": 0.87241}, "CVE-2008-5848": {"epss_score": 0.00947, "epss_percentile": 0.75818}, "CVE-2008-5849": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2008-5851": {"epss_score": 0.00144, "epss_percentile": 0.35338}, "CVE-2008-5852": {"epss_score": 0.05365, "epss_percentile": 0.89788}, "CVE-2008-5853": {"epss_score": 0.05626, "epss_percentile": 0.90064}, "CVE-2008-5854": {"epss_score": 0.0291, "epss_percentile": 0.85969}, "CVE-2008-5855": {"epss_score": 0.05365, "epss_percentile": 0.89788}, "CVE-2008-5856": {"epss_score": 0.07037, "epss_percentile": 0.91205}, "CVE-2008-5857": {"epss_score": 0.00575, "epss_percentile": 0.681}, "CVE-2008-5858": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-5859": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5860": {"epss_score": 0.03012, "epss_percentile": 0.86201}, "CVE-2008-5861": {"epss_score": 0.04028, "epss_percentile": 0.88145}, "CVE-2008-5862": {"epss_score": 0.11516, "epss_percentile": 0.9339}, "CVE-2008-5863": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2008-5864": {"epss_score": 0.00167, "epss_percentile": 0.38335}, "CVE-2008-5865": {"epss_score": 0.00483, "epss_percentile": 0.64611}, "CVE-2008-5866": {"epss_score": 0.0081, "epss_percentile": 0.73718}, "CVE-2008-5867": {"epss_score": 0.00092, "epss_percentile": 0.26517}, "CVE-2008-5868": {"epss_score": 0.03304, "epss_percentile": 0.86871}, "CVE-2008-5869": {"epss_score": 0.01437, "epss_percentile": 0.8028}, "CVE-2008-5870": {"epss_score": 0.044, "epss_percentile": 0.88646}, "CVE-2008-5871": {"epss_score": 0.01039, "epss_percentile": 0.76952}, "CVE-2008-5872": {"epss_score": 0.01918, "epss_percentile": 0.8288}, "CVE-2008-5873": {"epss_score": 0.01883, "epss_percentile": 0.82702}, "CVE-2008-5874": {"epss_score": 0.00397, "epss_percentile": 0.60031}, "CVE-2008-5875": {"epss_score": 0.00397, "epss_percentile": 0.60031}, "CVE-2008-5876": {"epss_score": 0.02502, "epss_percentile": 0.84925}, "CVE-2008-5877": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2008-5878": {"epss_score": 0.03012, "epss_percentile": 0.86201}, "CVE-2008-5879": {"epss_score": 0.02861, "epss_percentile": 0.85852}, "CVE-2008-5880": {"epss_score": 0.01852, "epss_percentile": 0.82543}, "CVE-2008-5881": {"epss_score": 0.03418, "epss_percentile": 0.87095}, "CVE-2008-5882": {"epss_score": 0.00858, "epss_percentile": 0.74501}, "CVE-2008-5883": {"epss_score": 0.03208, "epss_percentile": 0.86642}, "CVE-2008-5884": {"epss_score": 0.04278, "epss_percentile": 0.88485}, "CVE-2008-5885": {"epss_score": 0.03425, "epss_percentile": 0.87113}, "CVE-2008-5886": {"epss_score": 0.04514, "epss_percentile": 0.88786}, "CVE-2008-5887": {"epss_score": 0.0092, "epss_percentile": 0.75474}, "CVE-2008-5888": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-5889": {"epss_score": 0.00438, "epss_percentile": 0.6256}, "CVE-2008-5890": {"epss_score": 0.00471, "epss_percentile": 0.64017}, "CVE-2008-5891": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2008-5892": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-5893": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2008-5894": {"epss_score": 0.02844, "epss_percentile": 0.85817}, "CVE-2008-5895": {"epss_score": 0.00169, "epss_percentile": 0.38555}, "CVE-2008-5896": {"epss_score": 0.03381, "epss_percentile": 0.87032}, "CVE-2008-5897": {"epss_score": 0.01923, "epss_percentile": 0.82913}, "CVE-2008-5898": {"epss_score": 0.02635, "epss_percentile": 0.8529}, "CVE-2008-5899": {"epss_score": 0.01923, "epss_percentile": 0.82913}, "CVE-2008-5900": {"epss_score": 0.02635, "epss_percentile": 0.8529}, "CVE-2008-5901": {"epss_score": 0.03381, "epss_percentile": 0.87032}, "CVE-2008-5902": {"epss_score": 0.02593, "epss_percentile": 0.85186}, "CVE-2008-5903": {"epss_score": 0.02008, "epss_percentile": 0.83242}, "CVE-2008-5904": {"epss_score": 0.03107, "epss_percentile": 0.86421}, "CVE-2008-5905": {"epss_score": 0.00117, "epss_percentile": 0.31281}, "CVE-2008-5906": {"epss_score": 0.01171, "epss_percentile": 0.78214}, "CVE-2008-5907": {"epss_score": 0.00786, "epss_percentile": 0.73291}, "CVE-2008-5908": {"epss_score": 0.00052, "epss_percentile": 0.16482}, "CVE-2008-5909": {"epss_score": 0.00056, "epss_percentile": 0.17832}, "CVE-2008-5910": {"epss_score": 0.00056, "epss_percentile": 0.17832}, "CVE-2008-5911": {"epss_score": 0.16434, "epss_percentile": 0.9466}, "CVE-2008-5912": {"epss_score": 0.17145, "epss_percentile": 0.94782}, "CVE-2008-5913": {"epss_score": 0.00468, "epss_percentile": 0.63882}, "CVE-2008-5914": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2008-5915": {"epss_score": 0.0058, "epss_percentile": 0.68246}, "CVE-2008-5916": {"epss_score": 0.00084, "epss_percentile": 0.24984}, "CVE-2008-5917": {"epss_score": 0.00521, "epss_percentile": 0.66218}, "CVE-2008-5918": {"epss_score": 0.08069, "epss_percentile": 0.91866}, "CVE-2008-5919": {"epss_score": 0.06664, "epss_percentile": 0.90926}, "CVE-2008-5920": {"epss_score": 0.03279, "epss_percentile": 0.86808}, "CVE-2008-5921": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-5922": {"epss_score": 0.01956, "epss_percentile": 0.8304}, "CVE-2008-5923": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-5924": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2008-5925": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2008-5926": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-5927": {"epss_score": 0.00538, "epss_percentile": 0.66949}, "CVE-2008-5928": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-5929": {"epss_score": 0.04514, "epss_percentile": 0.88786}, "CVE-2008-5930": {"epss_score": 0.00344, "epss_percentile": 0.56478}, "CVE-2008-5931": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2008-5932": {"epss_score": 0.02508, "epss_percentile": 0.84943}, "CVE-2008-5933": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2008-5934": {"epss_score": 0.00367, "epss_percentile": 0.58121}, "CVE-2008-5935": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2008-5936": {"epss_score": 0.04171, "epss_percentile": 0.88347}, "CVE-2008-5937": {"epss_score": 0.04267, "epss_percentile": 0.88471}, "CVE-2008-5938": {"epss_score": 0.04347, "epss_percentile": 0.88578}, "CVE-2008-5939": {"epss_score": 0.04914, "epss_percentile": 0.89283}, "CVE-2008-5940": {"epss_score": 0.00661, "epss_percentile": 0.70572}, "CVE-2008-5941": {"epss_score": 0.00175, "epss_percentile": 0.3929}, "CVE-2008-5942": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-5943": {"epss_score": 0.02224, "epss_percentile": 0.84065}, "CVE-2008-5944": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2008-5945": {"epss_score": 0.01171, "epss_percentile": 0.78219}, "CVE-2008-5946": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2008-5947": {"epss_score": 0.0083, "epss_percentile": 0.7402}, "CVE-2008-5948": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2008-5949": {"epss_score": 0.02441, "epss_percentile": 0.84755}, "CVE-2008-5950": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-5951": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2008-5952": {"epss_score": 0.00302, "epss_percentile": 0.53161}, "CVE-2008-5953": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2008-5954": {"epss_score": 0.00128, "epss_percentile": 0.32967}, "CVE-2008-5955": {"epss_score": 0.00414, "epss_percentile": 0.61027}, "CVE-2008-5956": {"epss_score": 0.04514, "epss_percentile": 0.88786}, "CVE-2008-5957": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-5958": {"epss_score": 0.00848, "epss_percentile": 0.74356}, "CVE-2008-5959": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-5960": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2008-5961": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-5962": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2008-5963": {"epss_score": 0.05655, "epss_percentile": 0.90089}, "CVE-2008-5964": {"epss_score": 0.00874, "epss_percentile": 0.74756}, "CVE-2008-5965": {"epss_score": 0.02127, "epss_percentile": 0.83699}, "CVE-2008-5966": {"epss_score": 0.03121, "epss_percentile": 0.86448}, "CVE-2008-5967": {"epss_score": 0.03683, "epss_percentile": 0.87563}, "CVE-2008-5968": {"epss_score": 0.02041, "epss_percentile": 0.8337}, "CVE-2008-5969": {"epss_score": 0.00149, "epss_percentile": 0.35955}, "CVE-2008-5970": {"epss_score": 0.00144, "epss_percentile": 0.35241}, "CVE-2008-5971": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2008-5972": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-5973": {"epss_score": 0.00367, "epss_percentile": 0.58121}, "CVE-2008-5974": {"epss_score": 0.00469, "epss_percentile": 0.63944}, "CVE-2008-5975": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2008-5976": {"epss_score": 0.01601, "epss_percentile": 0.81265}, "CVE-2008-5977": {"epss_score": 0.00138, "epss_percentile": 0.34463}, "CVE-2008-5978": {"epss_score": 0.00643, "epss_percentile": 0.70062}, "CVE-2008-5979": {"epss_score": 0.03429, "epss_percentile": 0.87119}, "CVE-2008-5980": {"epss_score": 0.06269, "epss_percentile": 0.90628}, "CVE-2008-5981": {"epss_score": 0.04783, "epss_percentile": 0.89138}, "CVE-2008-5982": {"epss_score": 0.14029, "epss_percentile": 0.94118}, "CVE-2008-5983": {"epss_score": 0.00118, "epss_percentile": 0.3151}, "CVE-2008-5984": {"epss_score": 0.00067, "epss_percentile": 0.21121}, "CVE-2008-5985": {"epss_score": 0.00068, "epss_percentile": 0.21191}, "CVE-2008-5986": {"epss_score": 0.00059, "epss_percentile": 0.18852}, "CVE-2008-5987": {"epss_score": 0.0006, "epss_percentile": 0.19025}, "CVE-2008-5988": {"epss_score": 0.0046, "epss_percentile": 0.63525}, "CVE-2008-5989": {"epss_score": 0.03516, "epss_percentile": 0.87274}, "CVE-2008-5990": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2008-5991": {"epss_score": 0.01547, "epss_percentile": 0.80972}, "CVE-2008-5992": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-5993": {"epss_score": 0.02041, "epss_percentile": 0.8337}, "CVE-2008-5994": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-5995": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2008-5996": {"epss_score": 0.00125, "epss_percentile": 0.32613}, "CVE-2008-5997": {"epss_score": 0.0499, "epss_percentile": 0.89367}, "CVE-2008-5998": {"epss_score": 0.00211, "epss_percentile": 0.43643}, "CVE-2008-5999": {"epss_score": 0.00121, "epss_percentile": 0.31894}, "CVE-2008-6000": {"epss_score": 0.00057, "epss_percentile": 0.18189}, "CVE-2008-6001": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2008-6002": {"epss_score": 0.03915, "epss_percentile": 0.87946}, "CVE-2008-6003": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6004": {"epss_score": 0.00438, "epss_percentile": 0.6256}, "CVE-2008-6005": {"epss_score": 0.03616, "epss_percentile": 0.87436}, "CVE-2008-6006": {"epss_score": 0.02103, "epss_percentile": 0.83614}, "CVE-2008-6007": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6008": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2008-6009": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2008-6010": {"epss_score": 0.03118, "epss_percentile": 0.86441}, "CVE-2008-6011": {"epss_score": 0.00381, "epss_percentile": 0.58978}, "CVE-2008-6012": {"epss_score": 0.03626, "epss_percentile": 0.87458}, "CVE-2008-6013": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6014": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6015": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2008-6016": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2008-6017": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6018": {"epss_score": 0.01313, "epss_percentile": 0.79387}, "CVE-2008-6019": {"epss_score": 0.00141, "epss_percentile": 0.34848}, "CVE-2008-6020": {"epss_score": 0.00889, "epss_percentile": 0.7501}, "CVE-2008-6021": {"epss_score": 0.00396, "epss_percentile": 0.59885}, "CVE-2008-6022": {"epss_score": 0.02103, "epss_percentile": 0.83614}, "CVE-2008-6023": {"epss_score": 0.02103, "epss_percentile": 0.83614}, "CVE-2008-6024": {"epss_score": 0.01315, "epss_percentile": 0.794}, "CVE-2008-6025": {"epss_score": 0.02443, "epss_percentile": 0.84758}, "CVE-2008-6026": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2008-6027": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-6028": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6029": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6030": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6031": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6032": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6033": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6034": {"epss_score": 0.00172, "epss_percentile": 0.38936}, "CVE-2008-6035": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-6036": {"epss_score": 0.01956, "epss_percentile": 0.8304}, "CVE-2008-6037": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6038": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2008-6039": {"epss_score": 0.00699, "epss_percentile": 0.71449}, "CVE-2008-6040": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2008-6041": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2008-6042": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6043": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2008-6044": {"epss_score": 0.00368, "epss_percentile": 0.58173}, "CVE-2008-6045": {"epss_score": 0.01282, "epss_percentile": 0.7915}, "CVE-2008-6046": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2008-6047": {"epss_score": 0.00265, "epss_percentile": 0.49763}, "CVE-2008-6048": {"epss_score": 0.00107, "epss_percentile": 0.29725}, "CVE-2008-6050": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6051": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2008-6052": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2008-6053": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2008-6054": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2008-6055": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2008-6056": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-6057": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2008-6058": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2008-6059": {"epss_score": 0.00358, "epss_percentile": 0.57494}, "CVE-2008-6060": {"epss_score": 0.00475, "epss_percentile": 0.64182}, "CVE-2008-6061": {"epss_score": 0.01225, "epss_percentile": 0.78679}, "CVE-2008-6062": {"epss_score": 0.016, "epss_percentile": 0.8126}, "CVE-2008-6063": {"epss_score": 0.17414, "epss_percentile": 0.94848}, "CVE-2008-6064": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6065": {"epss_score": 0.04218, "epss_percentile": 0.88408}, "CVE-2008-6066": {"epss_score": 0.00777, "epss_percentile": 0.73115}, "CVE-2008-6068": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6069": {"epss_score": 0.00386, "epss_percentile": 0.59267}, "CVE-2008-6070": {"epss_score": 0.03358, "epss_percentile": 0.86979}, "CVE-2008-6071": {"epss_score": 0.06081, "epss_percentile": 0.90463}, "CVE-2008-6072": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2008-6073": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2008-6074": {"epss_score": 0.02844, "epss_percentile": 0.85817}, "CVE-2008-6075": {"epss_score": 0.00243, "epss_percentile": 0.47504}, "CVE-2008-6076": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6077": {"epss_score": 0.00287, "epss_percentile": 0.51843}, "CVE-2008-6078": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6079": {"epss_score": 0.02662, "epss_percentile": 0.8537}, "CVE-2008-6080": {"epss_score": 0.06734, "epss_percentile": 0.90993}, "CVE-2008-6081": {"epss_score": 0.00351, "epss_percentile": 0.57035}, "CVE-2008-6082": {"epss_score": 0.60799, "epss_percentile": 0.98222}, "CVE-2008-6083": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2008-6084": {"epss_score": 0.03628, "epss_percentile": 0.8747}, "CVE-2008-6085": {"epss_score": 0.10472, "epss_percentile": 0.92997}, "CVE-2008-6086": {"epss_score": 0.00351, "epss_percentile": 0.57035}, "CVE-2008-6087": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-6088": {"epss_score": 0.00351, "epss_percentile": 0.57035}, "CVE-2008-6089": {"epss_score": 0.03626, "epss_percentile": 0.87458}, "CVE-2008-6090": {"epss_score": 0.03626, "epss_percentile": 0.87458}, "CVE-2008-6091": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6092": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2008-6093": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6094": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2008-6095": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-6096": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-6097": {"epss_score": 0.00313, "epss_percentile": 0.54061}, "CVE-2008-6098": {"epss_score": 0.00382, "epss_percentile": 0.59034}, "CVE-2008-6099": {"epss_score": 0.01674, "epss_percentile": 0.81691}, "CVE-2008-6100": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6101": {"epss_score": 0.0078, "epss_percentile": 0.73168}, "CVE-2008-6102": {"epss_score": 0.00538, "epss_percentile": 0.66949}, "CVE-2008-6103": {"epss_score": 0.01819, "epss_percentile": 0.82403}, "CVE-2008-6104": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2008-6105": {"epss_score": 0.00137, "epss_percentile": 0.34246}, "CVE-2008-6106": {"epss_score": 0.00059, "epss_percentile": 0.18624}, "CVE-2008-6107": {"epss_score": 0.00054, "epss_percentile": 0.17047}, "CVE-2008-6108": {"epss_score": 0.00149, "epss_percentile": 0.35985}, "CVE-2008-6109": {"epss_score": 0.00049, "epss_percentile": 0.15624}, "CVE-2008-6110": {"epss_score": 0.00297, "epss_percentile": 0.52701}, "CVE-2008-6111": {"epss_score": 0.0016, "epss_percentile": 0.37461}, "CVE-2008-6112": {"epss_score": 0.01465, "epss_percentile": 0.80454}, "CVE-2008-6113": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-6114": {"epss_score": 0.00351, "epss_percentile": 0.57035}, "CVE-2008-6115": {"epss_score": 0.00432, "epss_percentile": 0.62158}, "CVE-2008-6116": {"epss_score": 0.00351, "epss_percentile": 0.57035}, "CVE-2008-6117": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6118": {"epss_score": 0.02044, "epss_percentile": 0.8338}, "CVE-2008-6119": {"epss_score": 0.01413, "epss_percentile": 0.80122}, "CVE-2008-6120": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2008-6121": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2008-6122": {"epss_score": 0.0286, "epss_percentile": 0.85851}, "CVE-2008-6123": {"epss_score": 0.00627, "epss_percentile": 0.69628}, "CVE-2008-6124": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2008-6125": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2008-6126": {"epss_score": 0.01581, "epss_percentile": 0.81137}, "CVE-2008-6127": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2008-6128": {"epss_score": 0.00536, "epss_percentile": 0.66847}, "CVE-2008-6129": {"epss_score": 0.00827, "epss_percentile": 0.73979}, "CVE-2008-6130": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-6131": {"epss_score": 0.00704, "epss_percentile": 0.71552}, "CVE-2008-6132": {"epss_score": 0.75297, "epss_percentile": 0.98836}, "CVE-2008-6133": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6134": {"epss_score": 0.00605, "epss_percentile": 0.68989}, "CVE-2008-6135": {"epss_score": 0.00256, "epss_percentile": 0.48789}, "CVE-2008-6136": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2008-6137": {"epss_score": 0.00322, "epss_percentile": 0.54758}, "CVE-2008-6138": {"epss_score": 0.02281, "epss_percentile": 0.84252}, "CVE-2008-6139": {"epss_score": 0.03379, "epss_percentile": 0.87026}, "CVE-2008-6140": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2008-6141": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-6142": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6143": {"epss_score": 0.0102, "epss_percentile": 0.76736}, "CVE-2008-6144": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2008-6145": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6146": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6147": {"epss_score": 0.04615, "epss_percentile": 0.88923}, "CVE-2008-6148": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6149": {"epss_score": 0.01174, "epss_percentile": 0.78246}, "CVE-2008-6150": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6151": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6152": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6153": {"epss_score": 0.00367, "epss_percentile": 0.58121}, "CVE-2008-6154": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6155": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2008-6156": {"epss_score": 0.00287, "epss_percentile": 0.51843}, "CVE-2008-6157": {"epss_score": 0.02074, "epss_percentile": 0.83499}, "CVE-2008-6158": {"epss_score": 0.01805, "epss_percentile": 0.82347}, "CVE-2008-6159": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-6160": {"epss_score": 0.00421, "epss_percentile": 0.61516}, "CVE-2008-6161": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2008-6162": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2008-6163": {"epss_score": 0.00181, "epss_percentile": 0.40024}, "CVE-2008-6164": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2008-6165": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6166": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6167": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2008-6168": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-6169": {"epss_score": 0.00205, "epss_percentile": 0.4276}, "CVE-2008-6170": {"epss_score": 0.00244, "epss_percentile": 0.4756}, "CVE-2008-6171": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2008-6172": {"epss_score": 0.05386, "epss_percentile": 0.89819}, "CVE-2008-6173": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2008-6174": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2008-6175": {"epss_score": 0.03623, "epss_percentile": 0.87445}, "CVE-2008-6177": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2008-6178": {"epss_score": 0.0925, "epss_percentile": 0.92466}, "CVE-2008-6179": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6180": {"epss_score": 0.01125, "epss_percentile": 0.77804}, "CVE-2008-6181": {"epss_score": 0.0087, "epss_percentile": 0.74702}, "CVE-2008-6182": {"epss_score": 9e-05, "epss_percentile": 0.00717}, "CVE-2008-6183": {"epss_score": 0.03915, "epss_percentile": 0.87946}, "CVE-2008-6184": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6185": {"epss_score": 0.06516, "epss_percentile": 0.90814}, "CVE-2008-6186": {"epss_score": 0.34199, "epss_percentile": 0.96831}, "CVE-2008-6187": {"epss_score": 0.00378, "epss_percentile": 0.58797}, "CVE-2008-6188": {"epss_score": 0.00378, "epss_percentile": 0.58797}, "CVE-2008-6189": {"epss_score": 0.00149, "epss_percentile": 0.35955}, "CVE-2008-6190": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-6191": {"epss_score": 0.00501, "epss_percentile": 0.65351}, "CVE-2008-6192": {"epss_score": 0.00529, "epss_percentile": 0.66586}, "CVE-2008-6193": {"epss_score": 0.03147, "epss_percentile": 0.86499}, "CVE-2008-6194": {"epss_score": 0.2126, "epss_percentile": 0.95489}, "CVE-2008-6195": {"epss_score": 0.01597, "epss_percentile": 0.81245}, "CVE-2008-6196": {"epss_score": 0.00777, "epss_percentile": 0.73115}, "CVE-2008-6197": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6198": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6199": {"epss_score": 0.03411, "epss_percentile": 0.87082}, "CVE-2008-6200": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2008-6201": {"epss_score": 0.06136, "epss_percentile": 0.90509}, "CVE-2008-6202": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6203": {"epss_score": 0.00243, "epss_percentile": 0.47504}, "CVE-2008-6204": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6205": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2008-6206": {"epss_score": 0.00715, "epss_percentile": 0.7184}, "CVE-2008-6207": {"epss_score": 0.00883, "epss_percentile": 0.7492}, "CVE-2008-6208": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-6209": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6210": {"epss_score": 0.00381, "epss_percentile": 0.58978}, "CVE-2008-6211": {"epss_score": 0.00164, "epss_percentile": 0.37995}, "CVE-2008-6212": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2008-6213": {"epss_score": 0.00787, "epss_percentile": 0.73309}, "CVE-2008-6214": {"epss_score": 0.00418, "epss_percentile": 0.61293}, "CVE-2008-6215": {"epss_score": 0.0231, "epss_percentile": 0.84333}, "CVE-2008-6216": {"epss_score": 0.00761, "epss_percentile": 0.72823}, "CVE-2008-6217": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2008-6218": {"epss_score": 0.0319, "epss_percentile": 0.86594}, "CVE-2008-6219": {"epss_score": 0.01952, "epss_percentile": 0.83021}, "CVE-2008-6220": {"epss_score": 0.00411, "epss_percentile": 0.60872}, "CVE-2008-6221": {"epss_score": 0.82412, "epss_percentile": 0.99193}, "CVE-2008-6222": {"epss_score": 0.03072, "epss_percentile": 0.86351}, "CVE-2008-6223": {"epss_score": 0.02168, "epss_percentile": 0.83862}, "CVE-2008-6224": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2008-6225": {"epss_score": 0.00672, "epss_percentile": 0.70819}, "CVE-2008-6226": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6227": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6228": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2008-6229": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2008-6230": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6231": {"epss_score": 0.03039, "epss_percentile": 0.86269}, "CVE-2008-6232": {"epss_score": 0.02988, "epss_percentile": 0.86139}, "CVE-2008-6233": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6234": {"epss_score": 0.00017, "epss_percentile": 0.03433}, "CVE-2008-6235": {"epss_score": 0.02553, "epss_percentile": 0.85086}, "CVE-2008-6236": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2008-6237": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6238": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-6239": {"epss_score": 0.00232, "epss_percentile": 0.45906}, "CVE-2008-6240": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2008-6241": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6242": {"epss_score": 0.00445, "epss_percentile": 0.62885}, "CVE-2008-6243": {"epss_score": 0.00344, "epss_percentile": 0.56478}, "CVE-2008-6244": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6245": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6246": {"epss_score": 0.00367, "epss_percentile": 0.58121}, "CVE-2008-6247": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6248": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2008-6249": {"epss_score": 0.00367, "epss_percentile": 0.58121}, "CVE-2008-6250": {"epss_score": 0.00703, "epss_percentile": 0.71548}, "CVE-2008-6251": {"epss_score": 0.02281, "epss_percentile": 0.84249}, "CVE-2008-6252": {"epss_score": 0.00406, "epss_percentile": 0.60546}, "CVE-2008-6253": {"epss_score": 0.07617, "epss_percentile": 0.91571}, "CVE-2008-6254": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6255": {"epss_score": 0.00394, "epss_percentile": 0.5975}, "CVE-2008-6256": {"epss_score": 0.004, "epss_percentile": 0.60174}, "CVE-2008-6257": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6258": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6259": {"epss_score": 0.03482, "epss_percentile": 0.87222}, "CVE-2008-6260": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6261": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6262": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2008-6263": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6264": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6265": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2008-6266": {"epss_score": 0.00117, "epss_percentile": 0.31207}, "CVE-2008-6267": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-6268": {"epss_score": 0.0033, "epss_percentile": 0.55459}, "CVE-2008-6269": {"epss_score": 0.01747, "epss_percentile": 0.82074}, "CVE-2008-6270": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6271": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2008-6272": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6273": {"epss_score": 0.00327, "epss_percentile": 0.55094}, "CVE-2008-6274": {"epss_score": 0.00344, "epss_percentile": 0.56478}, "CVE-2008-6275": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2008-6276": {"epss_score": 0.0039, "epss_percentile": 0.59504}, "CVE-2008-6277": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6278": {"epss_score": 0.00734, "epss_percentile": 0.7224}, "CVE-2008-6279": {"epss_score": 0.02691, "epss_percentile": 0.85437}, "CVE-2008-6280": {"epss_score": 0.06035, "epss_percentile": 0.90425}, "CVE-2008-6281": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6282": {"epss_score": 0.00519, "epss_percentile": 0.66141}, "CVE-2008-6283": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-6284": {"epss_score": 0.00127, "epss_percentile": 0.32871}, "CVE-2008-6285": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6286": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6287": {"epss_score": 0.01245, "epss_percentile": 0.78846}, "CVE-2008-6288": {"epss_score": 0.03729, "epss_percentile": 0.87639}, "CVE-2008-6289": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6290": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2008-6291": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2008-6292": {"epss_score": 0.02842, "epss_percentile": 0.85809}, "CVE-2008-6293": {"epss_score": 0.02842, "epss_percentile": 0.85809}, "CVE-2008-6294": {"epss_score": 0.02842, "epss_percentile": 0.85809}, "CVE-2008-6295": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-6296": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2008-6297": {"epss_score": 0.01152, "epss_percentile": 0.78049}, "CVE-2008-6298": {"epss_score": 0.0044, "epss_percentile": 0.62646}, "CVE-2008-6299": {"epss_score": 7e-05, "epss_percentile": 0.00405}, "CVE-2008-6300": {"epss_score": 0.01526, "epss_percentile": 0.80864}, "CVE-2008-6301": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6302": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2008-6303": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6304": {"epss_score": 0.00484, "epss_percentile": 0.64634}, "CVE-2008-6305": {"epss_score": 0.02451, "epss_percentile": 0.84784}, "CVE-2008-6306": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2008-6307": {"epss_score": 0.0194, "epss_percentile": 0.82979}, "CVE-2008-6308": {"epss_score": 0.03266, "epss_percentile": 0.86783}, "CVE-2008-6309": {"epss_score": 0.00521, "epss_percentile": 0.66228}, "CVE-2008-6310": {"epss_score": 0.00521, "epss_percentile": 0.66228}, "CVE-2008-6311": {"epss_score": 0.00654, "epss_percentile": 0.70356}, "CVE-2008-6312": {"epss_score": 0.0046, "epss_percentile": 0.63525}, "CVE-2008-6313": {"epss_score": 0.02324, "epss_percentile": 0.84382}, "CVE-2008-6314": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6315": {"epss_score": 0.02414, "epss_percentile": 0.84685}, "CVE-2008-6316": {"epss_score": 0.02822, "epss_percentile": 0.85746}, "CVE-2008-6317": {"epss_score": 0.02822, "epss_percentile": 0.85746}, "CVE-2008-6318": {"epss_score": 0.02414, "epss_percentile": 0.84685}, "CVE-2008-6319": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6320": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6321": {"epss_score": 0.04615, "epss_percentile": 0.88923}, "CVE-2008-6322": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6323": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6324": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6325": {"epss_score": 0.00342, "epss_percentile": 0.56398}, "CVE-2008-6326": {"epss_score": 0.00128, "epss_percentile": 0.32967}, "CVE-2008-6327": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6328": {"epss_score": 0.00469, "epss_percentile": 0.63944}, "CVE-2008-6329": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6330": {"epss_score": 0.00302, "epss_percentile": 0.53161}, "CVE-2008-6331": {"epss_score": 0.00121, "epss_percentile": 0.31927}, "CVE-2008-6332": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6333": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6334": {"epss_score": 0.03729, "epss_percentile": 0.87639}, "CVE-2008-6335": {"epss_score": 0.03729, "epss_percentile": 0.87639}, "CVE-2008-6336": {"epss_score": 0.03626, "epss_percentile": 0.87458}, "CVE-2008-6337": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6338": {"epss_score": 0.00366, "epss_percentile": 0.5802}, "CVE-2008-6340": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2008-6341": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-6342": {"epss_score": 0.00282, "epss_percentile": 0.51281}, "CVE-2008-6343": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2008-6344": {"epss_score": 0.00318, "epss_percentile": 0.54449}, "CVE-2008-6345": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6346": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2008-6347": {"epss_score": 0.07758, "epss_percentile": 0.91662}, "CVE-2008-6348": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6349": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6350": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6351": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2008-6352": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6353": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6354": {"epss_score": 0.04615, "epss_percentile": 0.88923}, "CVE-2008-6355": {"epss_score": 0.04615, "epss_percentile": 0.88923}, "CVE-2008-6356": {"epss_score": 0.04514, "epss_percentile": 0.88786}, "CVE-2008-6357": {"epss_score": 0.04514, "epss_percentile": 0.88786}, "CVE-2008-6358": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6359": {"epss_score": 0.00619, "epss_percentile": 0.69389}, "CVE-2008-6360": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-6361": {"epss_score": 0.02296, "epss_percentile": 0.84295}, "CVE-2008-6362": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6363": {"epss_score": 0.11603, "epss_percentile": 0.93417}, "CVE-2008-6364": {"epss_score": 0.00181, "epss_percentile": 0.40024}, "CVE-2008-6365": {"epss_score": 0.00329, "epss_percentile": 0.5538}, "CVE-2008-6366": {"epss_score": 0.00409, "epss_percentile": 0.60693}, "CVE-2008-6367": {"epss_score": 0.02935, "epss_percentile": 0.86024}, "CVE-2008-6368": {"epss_score": 0.00481, "epss_percentile": 0.6451}, "CVE-2008-6369": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6370": {"epss_score": 0.0278, "epss_percentile": 0.85648}, "CVE-2008-6371": {"epss_score": 0.00181, "epss_percentile": 0.40024}, "CVE-2008-6372": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6373": {"epss_score": 0.00313, "epss_percentile": 0.54048}, "CVE-2008-6374": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2008-6375": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2008-6376": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6377": {"epss_score": 0.02451, "epss_percentile": 0.84784}, "CVE-2008-6378": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6379": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6380": {"epss_score": 0.00367, "epss_percentile": 0.58121}, "CVE-2008-6381": {"epss_score": 0.00116, "epss_percentile": 0.31139}, "CVE-2008-6382": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2008-6383": {"epss_score": 0.00261, "epss_percentile": 0.49305}, "CVE-2008-6384": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2008-6385": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2008-6386": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2008-6387": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2008-6388": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2008-6389": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6390": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6391": {"epss_score": 0.00316, "epss_percentile": 0.54292}, "CVE-2008-6392": {"epss_score": 0.00127, "epss_percentile": 0.32871}, "CVE-2008-6393": {"epss_score": 0.22866, "epss_percentile": 0.95701}, "CVE-2008-6394": {"epss_score": 0.00626, "epss_percentile": 0.69606}, "CVE-2008-6395": {"epss_score": 0.00753, "epss_percentile": 0.72676}, "CVE-2008-6396": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2008-6397": {"epss_score": 0.00033, "epss_percentile": 0.09206}, "CVE-2008-6398": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2008-6399": {"epss_score": 0.00409, "epss_percentile": 0.6073}, "CVE-2008-6400": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-6401": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2008-6402": {"epss_score": 0.02281, "epss_percentile": 0.84252}, "CVE-2008-6403": {"epss_score": 0.02103, "epss_percentile": 0.83614}, "CVE-2008-6404": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2008-6405": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6406": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2008-6407": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2008-6408": {"epss_score": 0.02103, "epss_percentile": 0.83614}, "CVE-2008-6409": {"epss_score": 0.00337, "epss_percentile": 0.56065}, "CVE-2008-6410": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2008-6411": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2008-6412": {"epss_score": 0.00668, "epss_percentile": 0.7073}, "CVE-2008-6413": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2008-6414": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6415": {"epss_score": 0.06389, "epss_percentile": 0.90717}, "CVE-2008-6416": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2008-6417": {"epss_score": 0.00335, "epss_percentile": 0.55814}, "CVE-2008-6418": {"epss_score": 0.00279, "epss_percentile": 0.50942}, "CVE-2008-6419": {"epss_score": 0.00672, "epss_percentile": 0.70819}, "CVE-2008-6420": {"epss_score": 0.18247, "epss_percentile": 0.9498}, "CVE-2008-6421": {"epss_score": 0.02404, "epss_percentile": 0.84645}, "CVE-2008-6422": {"epss_score": 0.00647, "epss_percentile": 0.70202}, "CVE-2008-6423": {"epss_score": 0.02399, "epss_percentile": 0.84636}, "CVE-2008-6424": {"epss_score": 0.00408, "epss_percentile": 0.60684}, "CVE-2008-6425": {"epss_score": 0.00535, "epss_percentile": 0.6683}, "CVE-2008-6427": {"epss_score": 0.01818, "epss_percentile": 0.82399}, "CVE-2008-6428": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2008-6429": {"epss_score": 0.00237, "epss_percentile": 0.46735}, "CVE-2008-6430": {"epss_score": 0.00023, "epss_percentile": 0.05327}, "CVE-2008-6431": {"epss_score": 0.00528, "epss_percentile": 0.66544}, "CVE-2008-6433": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-6434": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-6435": {"epss_score": 0.00145, "epss_percentile": 0.35399}, "CVE-2008-6436": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2008-6437": {"epss_score": 0.005, "epss_percentile": 0.65299}, "CVE-2008-6438": {"epss_score": 0.01488, "epss_percentile": 0.80619}, "CVE-2008-6439": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2008-6440": {"epss_score": 0.00282, "epss_percentile": 0.5127}, "CVE-2008-6441": {"epss_score": 0.02361, "epss_percentile": 0.84497}, "CVE-2008-6442": {"epss_score": 0.01323, "epss_percentile": 0.79459}, "CVE-2008-6443": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2008-6444": {"epss_score": 0.11284, "epss_percentile": 0.93292}, "CVE-2008-6445": {"epss_score": 0.00356, "epss_percentile": 0.57371}, "CVE-2008-6446": {"epss_score": 0.02881, "epss_percentile": 0.85899}, "CVE-2008-6447": {"epss_score": 0.20637, "epss_percentile": 0.95392}, "CVE-2008-6448": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-6449": {"epss_score": 0.00286, "epss_percentile": 0.51739}, "CVE-2008-6450": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2008-6451": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6452": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6453": {"epss_score": 0.03118, "epss_percentile": 0.86441}, "CVE-2008-6454": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6455": {"epss_score": 0.00465, "epss_percentile": 0.6374}, "CVE-2008-6456": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6457": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6458": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6459": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6460": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6461": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6462": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6463": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-6464": {"epss_score": 0.00304, "epss_percentile": 0.53239}, "CVE-2008-6465": {"epss_score": 0.01157, "epss_percentile": 0.78107}, "CVE-2008-6466": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6467": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6468": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2008-6469": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6470": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2008-6471": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6472": {"epss_score": 0.00606, "epss_percentile": 0.69025}, "CVE-2008-6473": {"epss_score": 0.03211, "epss_percentile": 0.86654}, "CVE-2008-6474": {"epss_score": 0.00483, "epss_percentile": 0.64572}, "CVE-2008-6475": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6476": {"epss_score": 0.00327, "epss_percentile": 0.55137}, "CVE-2008-6477": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6478": {"epss_score": 0.01006, "epss_percentile": 0.76548}, "CVE-2008-6479": {"epss_score": 0.01349, "epss_percentile": 0.79672}, "CVE-2008-6480": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2008-6481": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6482": {"epss_score": 0.20508, "epss_percentile": 0.95358}, "CVE-2008-6483": {"epss_score": 0.43368, "epss_percentile": 0.97383}, "CVE-2008-6484": {"epss_score": 0.00304, "epss_percentile": 0.53239}, "CVE-2008-6485": {"epss_score": 0.00346, "epss_percentile": 0.56644}, "CVE-2008-6486": {"epss_score": 0.00579, "epss_percentile": 0.68221}, "CVE-2008-6487": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6488": {"epss_score": 0.00346, "epss_percentile": 0.56644}, "CVE-2008-6489": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6490": {"epss_score": 0.03271, "epss_percentile": 0.86794}, "CVE-2008-6491": {"epss_score": 0.00586, "epss_percentile": 0.68443}, "CVE-2008-6492": {"epss_score": 0.02517, "epss_percentile": 0.84991}, "CVE-2008-6493": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2008-6494": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2008-6495": {"epss_score": 0.01199, "epss_percentile": 0.78457}, "CVE-2008-6496": {"epss_score": 0.04228, "epss_percentile": 0.88418}, "CVE-2008-6497": {"epss_score": 0.10839, "epss_percentile": 0.93129}, "CVE-2008-6498": {"epss_score": 0.00345, "epss_percentile": 0.56583}, "CVE-2008-6499": {"epss_score": 0.02228, "epss_percentile": 0.84074}, "CVE-2008-6500": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-6501": {"epss_score": 0.0278, "epss_percentile": 0.85648}, "CVE-2008-6502": {"epss_score": 0.00319, "epss_percentile": 0.54546}, "CVE-2008-6503": {"epss_score": 0.00766, "epss_percentile": 0.72943}, "CVE-2008-6504": {"epss_score": 0.65118, "epss_percentile": 0.98404}, "CVE-2008-6505": {"epss_score": 0.5752, "epss_percentile": 0.98068}, "CVE-2008-6506": {"epss_score": 0.00542, "epss_percentile": 0.67066}, "CVE-2008-6507": {"epss_score": 0.00375, "epss_percentile": 0.58608}, "CVE-2008-6508": {"epss_score": 0.77144, "epss_percentile": 0.98924}, "CVE-2008-6509": {"epss_score": 0.02124, "epss_percentile": 0.8369}, "CVE-2008-6510": {"epss_score": 0.05376, "epss_percentile": 0.89798}, "CVE-2008-6511": {"epss_score": 0.03211, "epss_percentile": 0.86654}, "CVE-2008-6512": {"epss_score": 0.00477, "epss_percentile": 0.64343}, "CVE-2008-6513": {"epss_score": 0.02621, "epss_percentile": 0.85255}, "CVE-2008-6514": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2008-6515": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2008-6516": {"epss_score": 0.01066, "epss_percentile": 0.77217}, "CVE-2008-6517": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2008-6518": {"epss_score": 0.05889, "epss_percentile": 0.90298}, "CVE-2008-6519": {"epss_score": 0.08818, "epss_percentile": 0.92269}, "CVE-2008-6520": {"epss_score": 0.03193, "epss_percentile": 0.86606}, "CVE-2008-6521": {"epss_score": 0.00281, "epss_percentile": 0.51195}, "CVE-2008-6522": {"epss_score": 0.00951, "epss_percentile": 0.75865}, "CVE-2008-6523": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2008-6524": {"epss_score": 0.0283, "epss_percentile": 0.85775}, "CVE-2008-6525": {"epss_score": 0.00127, "epss_percentile": 0.32871}, "CVE-2008-6526": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6527": {"epss_score": 0.00351, "epss_percentile": 0.57035}, "CVE-2008-6528": {"epss_score": 0.09873, "epss_percentile": 0.92747}, "CVE-2008-6529": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-6530": {"epss_score": 0.02671, "epss_percentile": 0.85389}, "CVE-2008-6531": {"epss_score": 0.00943, "epss_percentile": 0.75781}, "CVE-2008-6532": {"epss_score": 0.00329, "epss_percentile": 0.55317}, "CVE-2008-6533": {"epss_score": 0.00381, "epss_percentile": 0.59016}, "CVE-2008-6534": {"epss_score": 0.09935, "epss_percentile": 0.9278}, "CVE-2008-6535": {"epss_score": 0.0243, "epss_percentile": 0.84726}, "CVE-2008-6536": {"epss_score": 0.02261, "epss_percentile": 0.84188}, "CVE-2008-6537": {"epss_score": 0.03161, "epss_percentile": 0.86532}, "CVE-2008-6538": {"epss_score": 0.03211, "epss_percentile": 0.86654}, "CVE-2008-6539": {"epss_score": 0.02164, "epss_percentile": 0.83839}, "CVE-2008-6540": {"epss_score": 0.05198, "epss_percentile": 0.896}, "CVE-2008-6541": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2008-6542": {"epss_score": 0.01387, "epss_percentile": 0.79917}, "CVE-2008-6543": {"epss_score": 0.00715, "epss_percentile": 0.7184}, "CVE-2008-6544": {"epss_score": 0.0127, "epss_percentile": 0.7905}, "CVE-2008-6545": {"epss_score": 0.00562, "epss_percentile": 0.67689}, "CVE-2008-6546": {"epss_score": 0.00258, "epss_percentile": 0.48954}, "CVE-2008-6547": {"epss_score": 0.00707, "epss_percentile": 0.71641}, "CVE-2008-6548": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2008-6549": {"epss_score": 0.00543, "epss_percentile": 0.67123}, "CVE-2008-6550": {"epss_score": 0.00723, "epss_percentile": 0.72022}, "CVE-2008-6551": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2008-6552": {"epss_score": 0.00073, "epss_percentile": 0.22601}, "CVE-2008-6553": {"epss_score": 0.03661, "epss_percentile": 0.87528}, "CVE-2008-6554": {"epss_score": 0.03218, "epss_percentile": 0.86666}, "CVE-2008-6555": {"epss_score": 0.04895, "epss_percentile": 0.89269}, "CVE-2008-6556": {"epss_score": 0.02185, "epss_percentile": 0.83917}, "CVE-2008-6557": {"epss_score": 0.02185, "epss_percentile": 0.83917}, "CVE-2008-6558": {"epss_score": 0.0033, "epss_percentile": 0.55491}, "CVE-2008-6559": {"epss_score": 0.00446, "epss_percentile": 0.62891}, "CVE-2008-6560": {"epss_score": 0.00988, "epss_percentile": 0.76349}, "CVE-2008-6561": {"epss_score": 0.00079, "epss_percentile": 0.23864}, "CVE-2008-6562": {"epss_score": 0.00143, "epss_percentile": 0.35225}, "CVE-2008-6563": {"epss_score": 0.0784, "epss_percentile": 0.9171}, "CVE-2008-6564": {"epss_score": 0.01938, "epss_percentile": 0.82971}, "CVE-2008-6565": {"epss_score": 0.00147, "epss_percentile": 0.35777}, "CVE-2008-6566": {"epss_score": 0.00312, "epss_percentile": 0.53963}, "CVE-2008-6567": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-6568": {"epss_score": 0.01258, "epss_percentile": 0.78957}, "CVE-2008-6569": {"epss_score": 0.00874, "epss_percentile": 0.74756}, "CVE-2008-6570": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2008-6571": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2008-6572": {"epss_score": 0.00167, "epss_percentile": 0.38378}, "CVE-2008-6573": {"epss_score": 0.00723, "epss_percentile": 0.72024}, "CVE-2008-6574": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2008-6575": {"epss_score": 0.00617, "epss_percentile": 0.69358}, "CVE-2008-6576": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2008-6577": {"epss_score": 0.02285, "epss_percentile": 0.84266}, "CVE-2008-6578": {"epss_score": 0.02178, "epss_percentile": 0.8389}, "CVE-2008-6579": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-6580": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2008-6581": {"epss_score": 0.02717, "epss_percentile": 0.8551}, "CVE-2008-6582": {"epss_score": 0.00484, "epss_percentile": 0.64658}, "CVE-2008-6583": {"epss_score": 0.21759, "epss_percentile": 0.95556}, "CVE-2008-6584": {"epss_score": 0.02058, "epss_percentile": 0.83432}, "CVE-2008-6585": {"epss_score": 0.00178, "epss_percentile": 0.39699}, "CVE-2008-6586": {"epss_score": 0.00148, "epss_percentile": 0.3584}, "CVE-2008-6587": {"epss_score": 0.0014, "epss_percentile": 0.34713}, "CVE-2008-6588": {"epss_score": 0.00905, "epss_percentile": 0.75246}, "CVE-2008-6589": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2008-6590": {"epss_score": 0.0267, "epss_percentile": 0.85387}, "CVE-2008-6591": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2008-6592": {"epss_score": 0.05036, "epss_percentile": 0.89421}, "CVE-2008-6593": {"epss_score": 0.00372, "epss_percentile": 0.58457}, "CVE-2008-6594": {"epss_score": 0.00596, "epss_percentile": 0.68716}, "CVE-2008-6595": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2008-6596": {"epss_score": 0.0016, "epss_percentile": 0.37494}, "CVE-2008-6597": {"epss_score": 0.00138, "epss_percentile": 0.34408}, "CVE-2008-6598": {"epss_score": 0.00232, "epss_percentile": 0.45926}, "CVE-2008-6599": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2008-6600": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-6601": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-6602": {"epss_score": 0.00343, "epss_percentile": 0.56466}, "CVE-2008-6603": {"epss_score": 0.00211, "epss_percentile": 0.43667}, "CVE-2008-6604": {"epss_score": 0.02835, "epss_percentile": 0.85789}, "CVE-2008-6605": {"epss_score": 0.00421, "epss_percentile": 0.61475}, "CVE-2008-6606": {"epss_score": 0.00346, "epss_percentile": 0.56644}, "CVE-2008-6607": {"epss_score": 0.00438, "epss_percentile": 0.6256}, "CVE-2008-6608": {"epss_score": 0.0036, "epss_percentile": 0.57658}, "CVE-2008-6609": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2008-6610": {"epss_score": 0.00131, "epss_percentile": 0.33371}, "CVE-2008-6611": {"epss_score": 0.00647, "epss_percentile": 0.70202}, "CVE-2008-6612": {"epss_score": 0.04147, "epss_percentile": 0.88316}, "CVE-2008-6613": {"epss_score": 0.02006, "epss_percentile": 0.83232}, "CVE-2008-6614": {"epss_score": 0.01363, "epss_percentile": 0.79768}, "CVE-2008-6615": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2008-6616": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2008-6617": {"epss_score": 0.06359, "epss_percentile": 0.90697}, "CVE-2008-6618": {"epss_score": 0.0083, "epss_percentile": 0.74021}, "CVE-2008-6619": {"epss_score": 0.02674, "epss_percentile": 0.85398}, "CVE-2008-6620": {"epss_score": 0.00195, "epss_percentile": 0.41684}, "CVE-2008-6621": {"epss_score": 0.00722, "epss_percentile": 0.72003}, "CVE-2008-6622": {"epss_score": 0.00367, "epss_percentile": 0.58121}, "CVE-2008-6623": {"epss_score": 0.00386, "epss_percentile": 0.59275}, "CVE-2008-6624": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2008-6625": {"epss_score": 0.00386, "epss_percentile": 0.59275}, "CVE-2008-6626": {"epss_score": 0.00386, "epss_percentile": 0.59275}, "CVE-2008-6627": {"epss_score": 0.00374, "epss_percentile": 0.58531}, "CVE-2008-6629": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2008-6630": {"epss_score": 0.00334, "epss_percentile": 0.55739}, "CVE-2008-6631": {"epss_score": 0.00461, "epss_percentile": 0.63554}, "CVE-2008-6632": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6633": {"epss_score": 0.00647, "epss_percentile": 0.70202}, "CVE-2008-6634": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6635": {"epss_score": 0.02281, "epss_percentile": 0.84249}, "CVE-2008-6636": {"epss_score": 0.02168, "epss_percentile": 0.83862}, "CVE-2008-6637": {"epss_score": 0.00461, "epss_percentile": 0.63554}, "CVE-2008-6638": {"epss_score": 0.00724, "epss_percentile": 0.72034}, "CVE-2008-6639": {"epss_score": 0.00149, "epss_percentile": 0.35989}, "CVE-2008-6640": {"epss_score": 0.00119, "epss_percentile": 0.3154}, "CVE-2008-6641": {"epss_score": 0.00245, "epss_percentile": 0.47709}, "CVE-2008-6642": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6643": {"epss_score": 0.01499, "epss_percentile": 0.80706}, "CVE-2008-6644": {"epss_score": 0.00333, "epss_percentile": 0.55644}, "CVE-2008-6645": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-6646": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-6647": {"epss_score": 0.00553, "epss_percentile": 0.67422}, "CVE-2008-6648": {"epss_score": 0.00553, "epss_percentile": 0.67422}, "CVE-2008-6649": {"epss_score": 0.00209, "epss_percentile": 0.43336}, "CVE-2008-6650": {"epss_score": 0.03211, "epss_percentile": 0.86654}, "CVE-2008-6651": {"epss_score": 0.03984, "epss_percentile": 0.88062}, "CVE-2008-6652": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6653": {"epss_score": 0.00196, "epss_percentile": 0.41814}, "CVE-2008-6654": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-6655": {"epss_score": 0.00199, "epss_percentile": 0.42103}, "CVE-2008-6656": {"epss_score": 0.00553, "epss_percentile": 0.67427}, "CVE-2008-6657": {"epss_score": 0.01932, "epss_percentile": 0.82943}, "CVE-2008-6658": {"epss_score": 0.02383, "epss_percentile": 0.84572}, "CVE-2008-6659": {"epss_score": 0.06819, "epss_percentile": 0.91046}, "CVE-2008-6660": {"epss_score": 0.02165, "epss_percentile": 0.83844}, "CVE-2008-6661": {"epss_score": 0.04383, "epss_percentile": 0.88628}, "CVE-2008-6662": {"epss_score": 0.04004, "epss_percentile": 0.88098}, "CVE-2008-6663": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6664": {"epss_score": 0.01229, "epss_percentile": 0.78719}, "CVE-2008-6665": {"epss_score": 0.02881, "epss_percentile": 0.85899}, "CVE-2008-6666": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-6667": {"epss_score": 0.01174, "epss_percentile": 0.78247}, "CVE-2008-6668": {"epss_score": 0.00573, "epss_percentile": 0.68038}, "CVE-2008-6669": {"epss_score": 0.05565, "epss_percentile": 0.9}, "CVE-2008-6670": {"epss_score": 0.09554, "epss_percentile": 0.92596}, "CVE-2008-6671": {"epss_score": 0.01288, "epss_percentile": 0.79205}, "CVE-2008-6672": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-6673": {"epss_score": 0.01456, "epss_percentile": 0.80394}, "CVE-2008-6674": {"epss_score": 0.02496, "epss_percentile": 0.84908}, "CVE-2008-6675": {"epss_score": 0.00461, "epss_percentile": 0.63554}, "CVE-2008-6676": {"epss_score": 0.02945, "epss_percentile": 0.86039}, "CVE-2008-6677": {"epss_score": 0.02473, "epss_percentile": 0.84851}, "CVE-2008-6678": {"epss_score": 0.00238, "epss_percentile": 0.46752}, "CVE-2008-6679": {"epss_score": 0.06059, "epss_percentile": 0.90441}, "CVE-2008-6680": {"epss_score": 0.07137, "epss_percentile": 0.91274}, "CVE-2008-6681": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-6682": {"epss_score": 0.0143, "epss_percentile": 0.80234}, "CVE-2008-6683": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-6684": {"epss_score": 0.01188, "epss_percentile": 0.78358}, "CVE-2008-6685": {"epss_score": 0.00711, "epss_percentile": 0.71739}, "CVE-2008-6686": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6687": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-6688": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-6689": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2008-6690": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2008-6691": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-6692": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6693": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-6694": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6695": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2008-6696": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-6697": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6698": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-6699": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-6700": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-6701": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2008-6702": {"epss_score": 0.09011, "epss_percentile": 0.92363}, "CVE-2008-6703": {"epss_score": 0.18162, "epss_percentile": 0.94968}, "CVE-2008-6704": {"epss_score": 0.01896, "epss_percentile": 0.82754}, "CVE-2008-6705": {"epss_score": 0.04586, "epss_percentile": 0.88885}, "CVE-2008-6706": {"epss_score": 0.00795, "epss_percentile": 0.73468}, "CVE-2008-6707": {"epss_score": 0.00415, "epss_percentile": 0.61151}, "CVE-2008-6708": {"epss_score": 0.0167, "epss_percentile": 0.81672}, "CVE-2008-6709": {"epss_score": 0.00972, "epss_percentile": 0.76144}, "CVE-2008-6710": {"epss_score": 0.0167, "epss_percentile": 0.81672}, "CVE-2008-6711": {"epss_score": 0.00972, "epss_percentile": 0.76144}, "CVE-2008-6712": {"epss_score": 0.07815, "epss_percentile": 0.91696}, "CVE-2008-6713": {"epss_score": 0.05936, "epss_percentile": 0.90343}, "CVE-2008-6714": {"epss_score": 0.02375, "epss_percentile": 0.84538}, "CVE-2008-6715": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-6716": {"epss_score": 0.03305, "epss_percentile": 0.86872}, "CVE-2008-6717": {"epss_score": 0.03305, "epss_percentile": 0.86872}, "CVE-2008-6718": {"epss_score": 0.03006, "epss_percentile": 0.86184}, "CVE-2008-6719": {"epss_score": 0.03305, "epss_percentile": 0.86872}, "CVE-2008-6720": {"epss_score": 0.00346, "epss_percentile": 0.56644}, "CVE-2008-6721": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6722": {"epss_score": 0.00059, "epss_percentile": 0.18837}, "CVE-2008-6723": {"epss_score": 0.0194, "epss_percentile": 0.82979}, "CVE-2008-6724": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-6725": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2008-6726": {"epss_score": 0.05296, "epss_percentile": 0.89703}, "CVE-2008-6727": {"epss_score": 0.0278, "epss_percentile": 0.85648}, "CVE-2008-6728": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2008-6729": {"epss_score": 0.00216, "epss_percentile": 0.44226}, "CVE-2008-6730": {"epss_score": 0.00151, "epss_percentile": 0.36344}, "CVE-2008-6731": {"epss_score": 0.05655, "epss_percentile": 0.90089}, "CVE-2008-6732": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2008-6733": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2008-6734": {"epss_score": 0.04132, "epss_percentile": 0.88301}, "CVE-2008-6735": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2008-6736": {"epss_score": 0.01499, "epss_percentile": 0.80706}, "CVE-2008-6737": {"epss_score": 0.02741, "epss_percentile": 0.85561}, "CVE-2008-6738": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2008-6739": {"epss_score": 0.03006, "epss_percentile": 0.86184}, "CVE-2008-6740": {"epss_score": 0.02103, "epss_percentile": 0.83614}, "CVE-2008-6741": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6742": {"epss_score": 0.05374, "epss_percentile": 0.89797}, "CVE-2008-6743": {"epss_score": 0.0194, "epss_percentile": 0.82979}, "CVE-2008-6744": {"epss_score": 0.00334, "epss_percentile": 0.55712}, "CVE-2008-6745": {"epss_score": 0.01519, "epss_percentile": 0.80816}, "CVE-2008-6746": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-6747": {"epss_score": 0.00631, "epss_percentile": 0.69729}, "CVE-2008-6748": {"epss_score": 0.16244, "epss_percentile": 0.94601}, "CVE-2008-6749": {"epss_score": 0.00151, "epss_percentile": 0.36344}, "CVE-2008-6750": {"epss_score": 0.02475, "epss_percentile": 0.84858}, "CVE-2008-6751": {"epss_score": 0.02517, "epss_percentile": 0.84991}, "CVE-2008-6752": {"epss_score": 0.0243, "epss_percentile": 0.84726}, "CVE-2008-6753": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2008-6754": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2008-6755": {"epss_score": 0.00208, "epss_percentile": 0.43221}, "CVE-2008-6756": {"epss_score": 0.00038, "epss_percentile": 0.11351}, "CVE-2008-6757": {"epss_score": 0.00225, "epss_percentile": 0.4513}, "CVE-2008-6758": {"epss_score": 0.00162, "epss_percentile": 0.3774}, "CVE-2008-6759": {"epss_score": 0.00224, "epss_percentile": 0.45022}, "CVE-2008-6760": {"epss_score": 0.00217, "epss_percentile": 0.44257}, "CVE-2008-6761": {"epss_score": 0.03507, "epss_percentile": 0.8726}, "CVE-2008-6762": {"epss_score": 0.00287, "epss_percentile": 0.51862}, "CVE-2008-6763": {"epss_score": 0.01747, "epss_percentile": 0.82074}, "CVE-2008-6764": {"epss_score": 0.00257, "epss_percentile": 0.48844}, "CVE-2008-6765": {"epss_score": 0.01681, "epss_percentile": 0.81728}, "CVE-2008-6766": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2008-6767": {"epss_score": 0.0074, "epss_percentile": 0.72408}, "CVE-2008-6768": {"epss_score": 0.02789, "epss_percentile": 0.85664}, "CVE-2008-6769": {"epss_score": 0.05478, "epss_percentile": 0.89917}, "CVE-2008-6770": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2008-6771": {"epss_score": 0.04838, "epss_percentile": 0.89196}, "CVE-2008-6772": {"epss_score": 0.01233, "epss_percentile": 0.78745}, "CVE-2008-6773": {"epss_score": 0.0287, "epss_percentile": 0.85871}, "CVE-2008-6774": {"epss_score": 0.00508, "epss_percentile": 0.65706}, "CVE-2008-6775": {"epss_score": 0.03616, "epss_percentile": 0.87436}, "CVE-2008-6776": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6777": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6778": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6779": {"epss_score": 0.00127, "epss_percentile": 0.32871}, "CVE-2008-6780": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6781": {"epss_score": 0.01379, "epss_percentile": 0.79855}, "CVE-2008-6782": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6783": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6784": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6785": {"epss_score": 0.0722, "epss_percentile": 0.91333}, "CVE-2008-6786": {"epss_score": 0.00419, "epss_percentile": 0.61398}, "CVE-2008-6787": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6788": {"epss_score": 0.00732, "epss_percentile": 0.72193}, "CVE-2008-6789": {"epss_score": 0.00621, "epss_percentile": 0.69484}, "CVE-2008-6790": {"epss_score": 0.03121, "epss_percentile": 0.86448}, "CVE-2008-6791": {"epss_score": 0.02279, "epss_percentile": 0.8424}, "CVE-2008-6792": {"epss_score": 0.00375, "epss_percentile": 0.58608}, "CVE-2008-6793": {"epss_score": 0.0884, "epss_percentile": 0.92279}, "CVE-2008-6794": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6795": {"epss_score": 0.00346, "epss_percentile": 0.56644}, "CVE-2008-6796": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6797": {"epss_score": 0.01721, "epss_percentile": 0.81935}, "CVE-2008-6798": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6799": {"epss_score": 0.05181, "epss_percentile": 0.8958}, "CVE-2008-6801": {"epss_score": 0.0006, "epss_percentile": 0.19138}, "CVE-2008-6802": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2008-6803": {"epss_score": 0.00264, "epss_percentile": 0.49716}, "CVE-2008-6804": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2008-6805": {"epss_score": 0.00695, "epss_percentile": 0.7137}, "CVE-2008-6806": {"epss_score": 0.06184, "epss_percentile": 0.9054}, "CVE-2008-6807": {"epss_score": 0.00495, "epss_percentile": 0.65107}, "CVE-2008-6808": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6809": {"epss_score": 0.00445, "epss_percentile": 0.62885}, "CVE-2008-6810": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6811": {"epss_score": 0.0727, "epss_percentile": 0.9136}, "CVE-2008-6812": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2008-6813": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2008-6814": {"epss_score": 0.02124, "epss_percentile": 0.83687}, "CVE-2008-6815": {"epss_score": 0.04413, "epss_percentile": 0.88662}, "CVE-2008-6816": {"epss_score": 0.10618, "epss_percentile": 0.9305}, "CVE-2008-6817": {"epss_score": 0.00257, "epss_percentile": 0.48947}, "CVE-2008-6818": {"epss_score": 0.00257, "epss_percentile": 0.48947}, "CVE-2008-6819": {"epss_score": 0.00234, "epss_percentile": 0.46103}, "CVE-2008-6820": {"epss_score": 0.00751, "epss_percentile": 0.72645}, "CVE-2008-6821": {"epss_score": 0.02148, "epss_percentile": 0.83771}, "CVE-2008-6822": {"epss_score": 0.08619, "epss_percentile": 0.92155}, "CVE-2008-6823": {"epss_score": 0.02982, "epss_percentile": 0.86125}, "CVE-2008-6824": {"epss_score": 0.0431, "epss_percentile": 0.8853}, "CVE-2008-6825": {"epss_score": 0.63298, "epss_percentile": 0.98327}, "CVE-2008-6826": {"epss_score": 0.06384, "epss_percentile": 0.90714}, "CVE-2008-6827": {"epss_score": 0.01558, "epss_percentile": 0.8103}, "CVE-2008-6828": {"epss_score": 0.00043, "epss_percentile": 0.13279}, "CVE-2008-6829": {"epss_score": 0.70215, "epss_percentile": 0.98623}, "CVE-2008-6830": {"epss_score": 0.00704, "epss_percentile": 0.71553}, "CVE-2008-6831": {"epss_score": 0.00485, "epss_percentile": 0.64718}, "CVE-2008-6832": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2008-6833": {"epss_score": 0.02213, "epss_percentile": 0.84024}, "CVE-2008-6834": {"epss_score": 0.02835, "epss_percentile": 0.85789}, "CVE-2008-6835": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2008-6836": {"epss_score": 0.00147, "epss_percentile": 0.35668}, "CVE-2008-6837": {"epss_score": 0.00127, "epss_percentile": 0.32871}, "CVE-2008-6838": {"epss_score": 0.01334, "epss_percentile": 0.7954}, "CVE-2008-6839": {"epss_score": 0.00145, "epss_percentile": 0.35399}, "CVE-2008-6840": {"epss_score": 0.01191, "epss_percentile": 0.78397}, "CVE-2008-6841": {"epss_score": 0.0126, "epss_percentile": 0.78973}, "CVE-2008-6842": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2008-6843": {"epss_score": 0.00843, "epss_percentile": 0.74268}, "CVE-2008-6844": {"epss_score": 0.03809, "epss_percentile": 0.87756}, "CVE-2008-6845": {"epss_score": 0.01007, "epss_percentile": 0.76562}, "CVE-2008-6846": {"epss_score": 0.04198, "epss_percentile": 0.88384}, "CVE-2008-6847": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-6848": {"epss_score": 0.08412, "epss_percentile": 0.92037}, "CVE-2008-6849": {"epss_score": 0.06186, "epss_percentile": 0.90543}, "CVE-2008-6850": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2008-6851": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6852": {"epss_score": 0.00019, "epss_percentile": 0.04359}, "CVE-2008-6853": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6854": {"epss_score": 0.00494, "epss_percentile": 0.65075}, "CVE-2008-6855": {"epss_score": 0.00494, "epss_percentile": 0.65075}, "CVE-2008-6856": {"epss_score": 0.00494, "epss_percentile": 0.65075}, "CVE-2008-6857": {"epss_score": 0.00578, "epss_percentile": 0.68201}, "CVE-2008-6858": {"epss_score": 0.00494, "epss_percentile": 0.65075}, "CVE-2008-6859": {"epss_score": 0.00494, "epss_percentile": 0.65075}, "CVE-2008-6860": {"epss_score": 0.00471, "epss_percentile": 0.64014}, "CVE-2008-6861": {"epss_score": 0.00494, "epss_percentile": 0.65075}, "CVE-2008-6862": {"epss_score": 0.00494, "epss_percentile": 0.65075}, "CVE-2008-6863": {"epss_score": 0.00494, "epss_percentile": 0.65075}, "CVE-2008-6864": {"epss_score": 0.00494, "epss_percentile": 0.65075}, "CVE-2008-6865": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2008-6866": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2008-6867": {"epss_score": 0.00344, "epss_percentile": 0.56478}, "CVE-2008-6868": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-6869": {"epss_score": 0.02508, "epss_percentile": 0.84943}, "CVE-2008-6870": {"epss_score": 0.01923, "epss_percentile": 0.82913}, "CVE-2008-6871": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2008-6872": {"epss_score": 0.03602, "epss_percentile": 0.87413}, "CVE-2008-6873": {"epss_score": 0.00367, "epss_percentile": 0.58121}, "CVE-2008-6874": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6875": {"epss_score": 0.00308, "epss_percentile": 0.53594}, "CVE-2008-6876": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2008-6877": {"epss_score": 0.00342, "epss_percentile": 0.56383}, "CVE-2008-6878": {"epss_score": 0.00342, "epss_percentile": 0.56383}, "CVE-2008-6879": {"epss_score": 0.01734, "epss_percentile": 0.82003}, "CVE-2008-6880": {"epss_score": 0.00132, "epss_percentile": 0.33605}, "CVE-2008-6881": {"epss_score": 0.00169, "epss_percentile": 0.38555}, "CVE-2008-6882": {"epss_score": 0.03121, "epss_percentile": 0.86448}, "CVE-2008-6883": {"epss_score": 0.00202, "epss_percentile": 0.42393}, "CVE-2008-6884": {"epss_score": 0.05657, "epss_percentile": 0.90093}, "CVE-2008-6885": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2008-6886": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2008-6887": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6888": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-6889": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6890": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6891": {"epss_score": 0.00567, "epss_percentile": 0.67838}, "CVE-2008-6892": {"epss_score": 0.00151, "epss_percentile": 0.36344}, "CVE-2008-6893": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2008-6894": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2008-6895": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2008-6896": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2008-6897": {"epss_score": 0.23329, "epss_percentile": 0.95767}, "CVE-2008-6898": {"epss_score": 0.66182, "epss_percentile": 0.98454}, "CVE-2008-6899": {"epss_score": 0.10801, "epss_percentile": 0.93106}, "CVE-2008-6900": {"epss_score": 0.06805, "epss_percentile": 0.91037}, "CVE-2008-6901": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2008-6902": {"epss_score": 0.06806, "epss_percentile": 0.91038}, "CVE-2008-6903": {"epss_score": 0.04334, "epss_percentile": 0.88562}, "CVE-2008-6904": {"epss_score": 0.05964, "epss_percentile": 0.90369}, "CVE-2008-6905": {"epss_score": 0.001, "epss_percentile": 0.28432}, "CVE-2008-6906": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2008-6907": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6908": {"epss_score": 0.00658, "epss_percentile": 0.70477}, "CVE-2008-6909": {"epss_score": 0.00697, "epss_percentile": 0.71403}, "CVE-2008-6910": {"epss_score": 0.00658, "epss_percentile": 0.70477}, "CVE-2008-6911": {"epss_score": 0.00295, "epss_percentile": 0.52503}, "CVE-2008-6912": {"epss_score": 0.02651, "epss_percentile": 0.85346}, "CVE-2008-6913": {"epss_score": 0.02123, "epss_percentile": 0.83687}, "CVE-2008-6914": {"epss_score": 0.06358, "epss_percentile": 0.90696}, "CVE-2008-6915": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-6916": {"epss_score": 0.04598, "epss_percentile": 0.88902}, "CVE-2008-6917": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2008-6918": {"epss_score": 0.02881, "epss_percentile": 0.85901}, "CVE-2008-6919": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2008-6920": {"epss_score": 0.08881, "epss_percentile": 0.92299}, "CVE-2008-6921": {"epss_score": 0.08881, "epss_percentile": 0.92299}, "CVE-2008-6922": {"epss_score": 0.08024, "epss_percentile": 0.91837}, "CVE-2008-6923": {"epss_score": 0.00015, "epss_percentile": 0.02152}, "CVE-2008-6924": {"epss_score": 0.0209, "epss_percentile": 0.83565}, "CVE-2008-6925": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-6926": {"epss_score": 0.05579, "epss_percentile": 0.90017}, "CVE-2008-6927": {"epss_score": 0.04182, "epss_percentile": 0.88358}, "CVE-2008-6928": {"epss_score": 0.04275, "epss_percentile": 0.88482}, "CVE-2008-6929": {"epss_score": 0.04346, "epss_percentile": 0.88575}, "CVE-2008-6930": {"epss_score": 0.04346, "epss_percentile": 0.88575}, "CVE-2008-6931": {"epss_score": 0.04346, "epss_percentile": 0.88575}, "CVE-2008-6932": {"epss_score": 0.03929, "epss_percentile": 0.87971}, "CVE-2008-6933": {"epss_score": 0.03118, "epss_percentile": 0.86441}, "CVE-2008-6934": {"epss_score": 0.06606, "epss_percentile": 0.90883}, "CVE-2008-6935": {"epss_score": 0.28312, "epss_percentile": 0.96342}, "CVE-2008-6936": {"epss_score": 0.05618, "epss_percentile": 0.90058}, "CVE-2008-6937": {"epss_score": 0.03565, "epss_percentile": 0.8736}, "CVE-2008-6938": {"epss_score": 0.73687, "epss_percentile": 0.98767}, "CVE-2008-6939": {"epss_score": 0.04023, "epss_percentile": 0.88136}, "CVE-2008-6940": {"epss_score": 0.07205, "epss_percentile": 0.91322}, "CVE-2008-6941": {"epss_score": 0.005, "epss_percentile": 0.65315}, "CVE-2008-6942": {"epss_score": 0.02469, "epss_percentile": 0.84844}, "CVE-2008-6943": {"epss_score": 0.02469, "epss_percentile": 0.84844}, "CVE-2008-6944": {"epss_score": 0.02469, "epss_percentile": 0.84844}, "CVE-2008-6945": {"epss_score": 0.00567, "epss_percentile": 0.67854}, "CVE-2008-6946": {"epss_score": 0.03845, "epss_percentile": 0.8784}, "CVE-2008-6947": {"epss_score": 0.02762, "epss_percentile": 0.85605}, "CVE-2008-6948": {"epss_score": 0.02054, "epss_percentile": 0.83418}, "CVE-2008-6949": {"epss_score": 0.00196, "epss_percentile": 0.41764}, "CVE-2008-6950": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2008-6951": {"epss_score": 0.00616, "epss_percentile": 0.6932}, "CVE-2008-6952": {"epss_score": 0.00372, "epss_percentile": 0.58457}, "CVE-2008-6953": {"epss_score": 0.26893, "epss_percentile": 0.96189}, "CVE-2008-6954": {"epss_score": 0.01636, "epss_percentile": 0.81474}, "CVE-2008-6955": {"epss_score": 0.02249, "epss_percentile": 0.8414}, "CVE-2008-6956": {"epss_score": 0.01313, "epss_percentile": 0.79383}, "CVE-2008-6957": {"epss_score": 0.06677, "epss_percentile": 0.90937}, "CVE-2008-6958": {"epss_score": 0.03924, "epss_percentile": 0.87958}, "CVE-2008-6959": {"epss_score": 0.02867, "epss_percentile": 0.85865}, "CVE-2008-6960": {"epss_score": 0.06552, "epss_percentile": 0.90844}, "CVE-2008-6961": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2008-6962": {"epss_score": 0.00049, "epss_percentile": 0.15503}, "CVE-2008-6963": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2008-6964": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-6965": {"epss_score": 0.017, "epss_percentile": 0.81826}, "CVE-2008-6966": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2008-6967": {"epss_score": 0.00542, "epss_percentile": 0.67066}, "CVE-2008-6968": {"epss_score": 0.00128, "epss_percentile": 0.32967}, "CVE-2008-6969": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2008-6970": {"epss_score": 0.00748, "epss_percentile": 0.72577}, "CVE-2008-6971": {"epss_score": 0.05711, "epss_percentile": 0.90141}, "CVE-2008-6972": {"epss_score": 0.00156, "epss_percentile": 0.36994}, "CVE-2008-6973": {"epss_score": 0.0049, "epss_percentile": 0.64938}, "CVE-2008-6974": {"epss_score": 0.01788, "epss_percentile": 0.82264}, "CVE-2008-6975": {"epss_score": 0.00356, "epss_percentile": 0.5739}, "CVE-2008-6976": {"epss_score": 0.0928, "epss_percentile": 0.92481}, "CVE-2008-6977": {"epss_score": 0.08412, "epss_percentile": 0.92037}, "CVE-2008-6978": {"epss_score": 0.11442, "epss_percentile": 0.93362}, "CVE-2008-6979": {"epss_score": 0.0026, "epss_percentile": 0.49194}, "CVE-2008-6980": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2008-6981": {"epss_score": 0.00235, "epss_percentile": 0.46214}, "CVE-2008-6982": {"epss_score": 0.08587, "epss_percentile": 0.92136}, "CVE-2008-6983": {"epss_score": 0.01318, "epss_percentile": 0.79423}, "CVE-2008-6984": {"epss_score": 0.00243, "epss_percentile": 0.47457}, "CVE-2008-6985": {"epss_score": 0.00947, "epss_percentile": 0.75814}, "CVE-2008-6986": {"epss_score": 0.00661, "epss_percentile": 0.70572}, "CVE-2008-6987": {"epss_score": 0.01349, "epss_percentile": 0.79668}, "CVE-2008-6988": {"epss_score": 0.05893, "epss_percentile": 0.90301}, "CVE-2008-6989": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-6990": {"epss_score": 0.00174, "epss_percentile": 0.39224}, "CVE-2008-6991": {"epss_score": 0.002, "epss_percentile": 0.4225}, "CVE-2008-6992": {"epss_score": 0.00467, "epss_percentile": 0.63826}, "CVE-2008-6993": {"epss_score": 0.00792, "epss_percentile": 0.73412}, "CVE-2008-6994": {"epss_score": 0.19302, "epss_percentile": 0.95162}, "CVE-2008-6995": {"epss_score": 0.098, "epss_percentile": 0.92708}, "CVE-2008-6996": {"epss_score": 0.13335, "epss_percentile": 0.93935}, "CVE-2008-6997": {"epss_score": 0.05024, "epss_percentile": 0.89407}, "CVE-2008-6998": {"epss_score": 0.21762, "epss_percentile": 0.95558}, "CVE-2008-6999": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-7000": {"epss_score": 0.00727, "epss_percentile": 0.72086}, "CVE-2008-7001": {"epss_score": 0.06521, "epss_percentile": 0.9082}, "CVE-2008-7002": {"epss_score": 0.0005, "epss_percentile": 0.157}, "CVE-2008-7003": {"epss_score": 0.00127, "epss_percentile": 0.32871}, "CVE-2008-7004": {"epss_score": 0.00394, "epss_percentile": 0.59798}, "CVE-2008-7005": {"epss_score": 0.02663, "epss_percentile": 0.85372}, "CVE-2008-7006": {"epss_score": 0.04109, "epss_percentile": 0.88269}, "CVE-2008-7007": {"epss_score": 0.01747, "epss_percentile": 0.82074}, "CVE-2008-7008": {"epss_score": 0.06912, "epss_percentile": 0.91112}, "CVE-2008-7009": {"epss_score": 0.00223, "epss_percentile": 0.44853}, "CVE-2008-7010": {"epss_score": 0.0431, "epss_percentile": 0.8853}, "CVE-2008-7011": {"epss_score": 0.02681, "epss_percentile": 0.85416}, "CVE-2008-7012": {"epss_score": 0.04585, "epss_percentile": 0.88883}, "CVE-2008-7013": {"epss_score": 0.00305, "epss_percentile": 0.53327}, "CVE-2008-7014": {"epss_score": 0.04747, "epss_percentile": 0.891}, "CVE-2008-7015": {"epss_score": 0.0344, "epss_percentile": 0.87139}, "CVE-2008-7016": {"epss_score": 0.00232, "epss_percentile": 0.45906}, "CVE-2008-7017": {"epss_score": 0.00549, "epss_percentile": 0.67312}, "CVE-2008-7018": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-7019": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2008-7020": {"epss_score": 0.00035, "epss_percentile": 0.099}, "CVE-2008-7021": {"epss_score": 0.06336, "epss_percentile": 0.90678}, "CVE-2008-7022": {"epss_score": 0.01895, "epss_percentile": 0.82746}, "CVE-2008-7023": {"epss_score": 0.00378, "epss_percentile": 0.58833}, "CVE-2008-7024": {"epss_score": 0.02645, "epss_percentile": 0.8532}, "CVE-2008-7025": {"epss_score": 0.01948, "epss_percentile": 0.83008}, "CVE-2008-7026": {"epss_score": 0.10367, "epss_percentile": 0.92961}, "CVE-2008-7027": {"epss_score": 0.01064, "epss_percentile": 0.77203}, "CVE-2008-7028": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2008-7029": {"epss_score": 0.01186, "epss_percentile": 0.78345}, "CVE-2008-7030": {"epss_score": 0.00265, "epss_percentile": 0.49771}, "CVE-2008-7031": {"epss_score": 0.03946, "epss_percentile": 0.87996}, "CVE-2008-7032": {"epss_score": 0.00205, "epss_percentile": 0.4271}, "CVE-2008-7033": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2008-7034": {"epss_score": 0.00629, "epss_percentile": 0.6968}, "CVE-2008-7035": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2008-7036": {"epss_score": 0.00257, "epss_percentile": 0.48844}, "CVE-2008-7037": {"epss_score": 0.00522, "epss_percentile": 0.66255}, "CVE-2008-7038": {"epss_score": 0.01004, "epss_percentile": 0.76532}, "CVE-2008-7039": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2008-7040": {"epss_score": 0.00105, "epss_percentile": 0.2927}, "CVE-2008-7041": {"epss_score": 0.01174, "epss_percentile": 0.78247}, "CVE-2008-7042": {"epss_score": 0.02451, "epss_percentile": 0.84784}, "CVE-2008-7043": {"epss_score": 0.0569, "epss_percentile": 0.90123}, "CVE-2008-7044": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-7045": {"epss_score": 0.0224, "epss_percentile": 0.84115}, "CVE-2008-7046": {"epss_score": 0.01114, "epss_percentile": 0.77695}, "CVE-2008-7047": {"epss_score": 0.01174, "epss_percentile": 0.78247}, "CVE-2008-7048": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-7049": {"epss_score": 0.00381, "epss_percentile": 0.58978}, "CVE-2008-7050": {"epss_score": 0.00638, "epss_percentile": 0.69926}, "CVE-2008-7051": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2008-7052": {"epss_score": 0.02475, "epss_percentile": 0.84856}, "CVE-2008-7053": {"epss_score": 0.20489, "epss_percentile": 0.95354}, "CVE-2008-7054": {"epss_score": 0.0595, "epss_percentile": 0.90355}, "CVE-2008-7055": {"epss_score": 0.00959, "epss_percentile": 0.7596}, "CVE-2008-7056": {"epss_score": 0.04838, "epss_percentile": 0.89196}, "CVE-2008-7057": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2008-7058": {"epss_score": 0.00216, "epss_percentile": 0.44226}, "CVE-2008-7059": {"epss_score": 0.00119, "epss_percentile": 0.3154}, "CVE-2008-7060": {"epss_score": 0.00247, "epss_percentile": 0.47876}, "CVE-2008-7061": {"epss_score": 0.07511, "epss_percentile": 0.91511}, "CVE-2008-7062": {"epss_score": 0.03935, "epss_percentile": 0.87981}, "CVE-2008-7063": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2008-7064": {"epss_score": 0.03116, "epss_percentile": 0.86436}, "CVE-2008-7065": {"epss_score": 0.132, "epss_percentile": 0.93898}, "CVE-2008-7066": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2008-7067": {"epss_score": 0.02103, "epss_percentile": 0.83614}, "CVE-2008-7068": {"epss_score": 0.00409, "epss_percentile": 0.60762}, "CVE-2008-7069": {"epss_score": 0.02974, "epss_percentile": 0.86102}, "CVE-2008-7070": {"epss_score": 0.0501, "epss_percentile": 0.8939}, "CVE-2008-7071": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-7072": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-7073": {"epss_score": 0.02281, "epss_percentile": 0.84252}, "CVE-2008-7074": {"epss_score": 0.11115, "epss_percentile": 0.93227}, "CVE-2008-7075": {"epss_score": 0.03258, "epss_percentile": 0.86766}, "CVE-2008-7076": {"epss_score": 0.07457, "epss_percentile": 0.91482}, "CVE-2008-7077": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2008-7078": {"epss_score": 0.40086, "epss_percentile": 0.97195}, "CVE-2008-7079": {"epss_score": 0.26051, "epss_percentile": 0.96105}, "CVE-2008-7080": {"epss_score": 0.03425, "epss_percentile": 0.87113}, "CVE-2008-7081": {"epss_score": 0.00337, "epss_percentile": 0.56018}, "CVE-2008-7082": {"epss_score": 0.00105, "epss_percentile": 0.29378}, "CVE-2008-7083": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-7084": {"epss_score": 0.06227, "epss_percentile": 0.90585}, "CVE-2008-7085": {"epss_score": 0.00127, "epss_percentile": 0.32871}, "CVE-2008-7086": {"epss_score": 0.01767, "epss_percentile": 0.82176}, "CVE-2008-7087": {"epss_score": 0.00665, "epss_percentile": 0.70659}, "CVE-2008-7088": {"epss_score": 0.02123, "epss_percentile": 0.83687}, "CVE-2008-7089": {"epss_score": 0.04914, "epss_percentile": 0.89283}, "CVE-2008-7090": {"epss_score": 0.10831, "epss_percentile": 0.93127}, "CVE-2008-7091": {"epss_score": 0.03906, "epss_percentile": 0.87927}, "CVE-2008-7092": {"epss_score": 0.01325, "epss_percentile": 0.7947}, "CVE-2008-7093": {"epss_score": 0.00305, "epss_percentile": 0.53342}, "CVE-2008-7094": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2008-7095": {"epss_score": 0.00304, "epss_percentile": 0.53265}, "CVE-2008-7096": {"epss_score": 0.0006, "epss_percentile": 0.192}, "CVE-2008-7097": {"epss_score": 0.00175, "epss_percentile": 0.39276}, "CVE-2008-7098": {"epss_score": 0.08026, "epss_percentile": 0.91837}, "CVE-2008-7099": {"epss_score": 0.03628, "epss_percentile": 0.8747}, "CVE-2008-7100": {"epss_score": 0.00376, "epss_percentile": 0.58668}, "CVE-2008-7101": {"epss_score": 0.00387, "epss_percentile": 0.59332}, "CVE-2008-7102": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2008-7103": {"epss_score": 0.08451, "epss_percentile": 0.92059}, "CVE-2008-7104": {"epss_score": 0.02526, "epss_percentile": 0.85013}, "CVE-2008-7105": {"epss_score": 0.02526, "epss_percentile": 0.85013}, "CVE-2008-7106": {"epss_score": 0.00984, "epss_percentile": 0.7631}, "CVE-2008-7107": {"epss_score": 0.003, "epss_percentile": 0.5292}, "CVE-2008-7108": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-7109": {"epss_score": 0.03774, "epss_percentile": 0.87707}, "CVE-2008-7110": {"epss_score": 0.01408, "epss_percentile": 0.80063}, "CVE-2008-7111": {"epss_score": 0.02334, "epss_percentile": 0.84412}, "CVE-2008-7112": {"epss_score": 0.00543, "epss_percentile": 0.67123}, "CVE-2008-7113": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2008-7114": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2008-7115": {"epss_score": 0.06286, "epss_percentile": 0.90643}, "CVE-2008-7116": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2008-7117": {"epss_score": 0.02462, "epss_percentile": 0.84828}, "CVE-2008-7118": {"epss_score": 0.04514, "epss_percentile": 0.88786}, "CVE-2008-7119": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2008-7120": {"epss_score": 0.00115, "epss_percentile": 0.30982}, "CVE-2008-7121": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2008-7122": {"epss_score": 0.00825, "epss_percentile": 0.73948}, "CVE-2008-7123": {"epss_score": 0.0183, "epss_percentile": 0.82443}, "CVE-2008-7124": {"epss_score": 0.0816, "epss_percentile": 0.91909}, "CVE-2008-7125": {"epss_score": 0.00733, "epss_percentile": 0.72203}, "CVE-2008-7126": {"epss_score": 0.11387, "epss_percentile": 0.93328}, "CVE-2008-7127": {"epss_score": 0.03586, "epss_percentile": 0.87393}, "CVE-2008-7128": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2008-7129": {"epss_score": 0.00329, "epss_percentile": 0.55395}, "CVE-2008-7130": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2008-7131": {"epss_score": 0.00631, "epss_percentile": 0.69729}, "CVE-2008-7132": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-7133": {"epss_score": 0.00145, "epss_percentile": 0.35399}, "CVE-2008-7134": {"epss_score": 0.0012, "epss_percentile": 0.31757}, "CVE-2008-7135": {"epss_score": 0.04586, "epss_percentile": 0.88886}, "CVE-2008-7136": {"epss_score": 0.05374, "epss_percentile": 0.89797}, "CVE-2008-7137": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2008-7138": {"epss_score": 0.00409, "epss_percentile": 0.60752}, "CVE-2008-7139": {"epss_score": 0.00262, "epss_percentile": 0.49327}, "CVE-2008-7140": {"epss_score": 0.00164, "epss_percentile": 0.37995}, "CVE-2008-7141": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2008-7142": {"epss_score": 0.01733, "epss_percentile": 0.81998}, "CVE-2008-7143": {"epss_score": 0.0043, "epss_percentile": 0.62018}, "CVE-2008-7144": {"epss_score": 0.01134, "epss_percentile": 0.77888}, "CVE-2008-7145": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2008-7146": {"epss_score": 0.00419, "epss_percentile": 0.61357}, "CVE-2008-7147": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-7148": {"epss_score": 0.00708, "epss_percentile": 0.71664}, "CVE-2008-7149": {"epss_score": 0.0033, "epss_percentile": 0.55416}, "CVE-2008-7150": {"epss_score": 0.00231, "epss_percentile": 0.45791}, "CVE-2008-7151": {"epss_score": 0.00098, "epss_percentile": 0.27762}, "CVE-2008-7152": {"epss_score": 0.00655, "epss_percentile": 0.70421}, "CVE-2008-7153": {"epss_score": 0.00938, "epss_percentile": 0.75714}, "CVE-2008-7154": {"epss_score": 0.04838, "epss_percentile": 0.89196}, "CVE-2008-7155": {"epss_score": 0.01285, "epss_percentile": 0.79178}, "CVE-2008-7156": {"epss_score": 0.00928, "epss_percentile": 0.75582}, "CVE-2008-7157": {"epss_score": 0.02668, "epss_percentile": 0.8538}, "CVE-2008-7158": {"epss_score": 0.04536, "epss_percentile": 0.88817}, "CVE-2008-7159": {"epss_score": 0.04049, "epss_percentile": 0.88174}, "CVE-2008-7160": {"epss_score": 0.04573, "epss_percentile": 0.88864}, "CVE-2008-7161": {"epss_score": 0.01767, "epss_percentile": 0.82172}, "CVE-2008-7162": {"epss_score": 0.06897, "epss_percentile": 0.911}, "CVE-2008-7163": {"epss_score": 0.02118, "epss_percentile": 0.83667}, "CVE-2008-7164": {"epss_score": 0.00434, "epss_percentile": 0.62311}, "CVE-2008-7165": {"epss_score": 0.00131, "epss_percentile": 0.33359}, "CVE-2008-7166": {"epss_score": 0.01389, "epss_percentile": 0.79928}, "CVE-2008-7167": {"epss_score": 0.08485, "epss_percentile": 0.92078}, "CVE-2008-7168": {"epss_score": 0.02325, "epss_percentile": 0.84387}, "CVE-2008-7169": {"epss_score": 0.00111, "epss_percentile": 0.30342}, "CVE-2008-7170": {"epss_score": 0.03319, "epss_percentile": 0.86907}, "CVE-2008-7171": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2008-7172": {"epss_score": 0.03121, "epss_percentile": 0.86448}, "CVE-2008-7173": {"epss_score": 0.12594, "epss_percentile": 0.93723}, "CVE-2008-7174": {"epss_score": 0.03449, "epss_percentile": 0.87162}, "CVE-2008-7175": {"epss_score": 0.00136, "epss_percentile": 0.34104}, "CVE-2008-7176": {"epss_score": 0.02822, "epss_percentile": 0.85746}, "CVE-2008-7177": {"epss_score": 0.0162, "epss_percentile": 0.81386}, "CVE-2008-7178": {"epss_score": 0.01724, "epss_percentile": 0.81951}, "CVE-2008-7179": {"epss_score": 0.01064, "epss_percentile": 0.77203}, "CVE-2008-7180": {"epss_score": 0.02823, "epss_percentile": 0.8575}, "CVE-2008-7181": {"epss_score": 0.03121, "epss_percentile": 0.86448}, "CVE-2008-7182": {"epss_score": 0.13407, "epss_percentile": 0.93955}, "CVE-2008-7183": {"epss_score": 0.00525, "epss_percentile": 0.66395}, "CVE-2008-7184": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2008-7185": {"epss_score": 0.01028, "epss_percentile": 0.76817}, "CVE-2008-7186": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-7187": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2008-7188": {"epss_score": 0.03628, "epss_percentile": 0.8747}, "CVE-2008-7189": {"epss_score": 0.00337, "epss_percentile": 0.56054}, "CVE-2008-7190": {"epss_score": 0.00404, "epss_percentile": 0.60432}, "CVE-2008-7191": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2008-7192": {"epss_score": 0.00079, "epss_percentile": 0.23852}, "CVE-2008-7193": {"epss_score": 0.00205, "epss_percentile": 0.4276}, "CVE-2008-7194": {"epss_score": 0.005, "epss_percentile": 0.65324}, "CVE-2008-7195": {"epss_score": 0.005, "epss_percentile": 0.65324}, "CVE-2008-7196": {"epss_score": 0.00723, "epss_percentile": 0.72019}, "CVE-2008-7197": {"epss_score": 0.00341, "epss_percentile": 0.56305}, "CVE-2008-7198": {"epss_score": 0.00341, "epss_percentile": 0.56305}, "CVE-2008-7199": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2008-7200": {"epss_score": 0.00341, "epss_percentile": 0.56305}, "CVE-2008-7201": {"epss_score": 0.005, "epss_percentile": 0.65289}, "CVE-2008-7202": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2008-7203": {"epss_score": 0.04747, "epss_percentile": 0.891}, "CVE-2008-7204": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2008-7205": {"epss_score": 0.00387, "epss_percentile": 0.59332}, "CVE-2008-7206": {"epss_score": 0.00318, "epss_percentile": 0.54462}, "CVE-2008-7207": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2008-7208": {"epss_score": 0.00981, "epss_percentile": 0.7628}, "CVE-2008-7209": {"epss_score": 0.13151, "epss_percentile": 0.93886}, "CVE-2008-7210": {"epss_score": 0.00143, "epss_percentile": 0.35211}, "CVE-2008-7211": {"epss_score": 0.00102, "epss_percentile": 0.28877}, "CVE-2008-7212": {"epss_score": 0.00592, "epss_percentile": 0.68615}, "CVE-2008-7213": {"epss_score": 0.0103, "epss_percentile": 0.76848}, "CVE-2008-7214": {"epss_score": 0.003, "epss_percentile": 0.52936}, "CVE-2008-7215": {"epss_score": 0.02095, "epss_percentile": 0.83582}, "CVE-2008-7216": {"epss_score": 0.04814, "epss_percentile": 0.8917}, "CVE-2008-7217": {"epss_score": 0.00253, "epss_percentile": 0.48441}, "CVE-2008-7218": {"epss_score": 0.01854, "epss_percentile": 0.82556}, "CVE-2008-7219": {"epss_score": 0.01003, "epss_percentile": 0.76515}, "CVE-2008-7220": {"epss_score": 0.10462, "epss_percentile": 0.92993}, "CVE-2008-7221": {"epss_score": 0.00195, "epss_percentile": 0.41621}, "CVE-2008-7222": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2008-7223": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2008-7224": {"epss_score": 0.00926, "epss_percentile": 0.75555}, "CVE-2008-7225": {"epss_score": 0.0219, "epss_percentile": 0.83934}, "CVE-2008-7226": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2008-7227": {"epss_score": 0.00305, "epss_percentile": 0.53327}, "CVE-2008-7228": {"epss_score": 0.00324, "epss_percentile": 0.54958}, "CVE-2008-7229": {"epss_score": 0.00172, "epss_percentile": 0.38934}, "CVE-2008-7230": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2008-7231": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2008-7232": {"epss_score": 0.58369, "epss_percentile": 0.98112}, "CVE-2008-7233": {"epss_score": 0.06221, "epss_percentile": 0.9058}, "CVE-2008-7234": {"epss_score": 0.08828, "epss_percentile": 0.92272}, "CVE-2008-7235": {"epss_score": 0.09275, "epss_percentile": 0.92479}, "CVE-2008-7236": {"epss_score": 0.1054, "epss_percentile": 0.93022}, "CVE-2008-7237": {"epss_score": 0.06395, "epss_percentile": 0.90722}, "CVE-2008-7238": {"epss_score": 0.0184, "epss_percentile": 0.82491}, "CVE-2008-7239": {"epss_score": 0.02253, "epss_percentile": 0.84163}, "CVE-2008-7240": {"epss_score": 0.02325, "epss_percentile": 0.84389}, "CVE-2008-7241": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2008-7242": {"epss_score": 0.00189, "epss_percentile": 0.40955}, "CVE-2008-7243": {"epss_score": 0.00149, "epss_percentile": 0.35989}, "CVE-2008-7244": {"epss_score": 0.02183, "epss_percentile": 0.83911}, "CVE-2008-7245": {"epss_score": 0.02451, "epss_percentile": 0.84784}, "CVE-2008-7246": {"epss_score": 0.01677, "epss_percentile": 0.81715}, "CVE-2008-7247": {"epss_score": 0.00245, "epss_percentile": 0.47634}, "CVE-2008-7248": {"epss_score": 0.11409, "epss_percentile": 0.93339}, "CVE-2008-7249": {"epss_score": 0.03943, "epss_percentile": 0.8799}, "CVE-2008-7250": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2008-7251": {"epss_score": 0.02395, "epss_percentile": 0.84614}, "CVE-2008-7252": {"epss_score": 0.03137, "epss_percentile": 0.86481}, "CVE-2008-7253": {"epss_score": 0.01461, "epss_percentile": 0.80431}, "CVE-2008-7254": {"epss_score": 0.01469, "epss_percentile": 0.80489}, "CVE-2008-7255": {"epss_score": 0.00063, "epss_percentile": 0.19827}, "CVE-2008-7256": {"epss_score": 0.00108, "epss_percentile": 0.29821}, "CVE-2008-7257": {"epss_score": 0.20539, "epss_percentile": 0.95375}, "CVE-2008-7258": {"epss_score": 0.0007, "epss_percentile": 0.21951}, "CVE-2008-7261": {"epss_score": 0.00051, "epss_percentile": 0.16258}, "CVE-2008-7262": {"epss_score": 0.0055, "epss_percentile": 0.67349}, "CVE-2008-7263": {"epss_score": 0.00647, "epss_percentile": 0.70203}, "CVE-2008-7264": {"epss_score": 0.0081, "epss_percentile": 0.73718}, "CVE-2008-7265": {"epss_score": 0.00326, "epss_percentile": 0.55036}, "CVE-2008-7266": {"epss_score": 0.00309, "epss_percentile": 0.53721}, "CVE-2008-7267": {"epss_score": 0.01939, "epss_percentile": 0.82973}, "CVE-2008-7268": {"epss_score": 0.00457, "epss_percentile": 0.63389}, "CVE-2008-7269": {"epss_score": 0.04298, "epss_percentile": 0.88511}, "CVE-2008-7270": {"epss_score": 0.01096, "epss_percentile": 0.77518}, "CVE-2008-7271": {"epss_score": 0.00209, "epss_percentile": 0.43393}, "CVE-2008-7272": {"epss_score": 0.00218, "epss_percentile": 0.44347}, "CVE-2008-7273": {"epss_score": 0.00201, "epss_percentile": 0.4236}, "CVE-2008-7274": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2008-7275": {"epss_score": 0.0021, "epss_percentile": 0.43482}, "CVE-2008-7276": {"epss_score": 0.00036, "epss_percentile": 0.10289}, "CVE-2008-7277": {"epss_score": 0.00196, "epss_percentile": 0.41767}, "CVE-2008-7278": {"epss_score": 0.00311, "epss_percentile": 0.53818}, "CVE-2008-7279": {"epss_score": 0.00196, "epss_percentile": 0.41767}, "CVE-2008-7280": {"epss_score": 0.00589, "epss_percentile": 0.68529}, "CVE-2008-7281": {"epss_score": 0.00263, "epss_percentile": 0.49545}, "CVE-2008-7282": {"epss_score": 0.00196, "epss_percentile": 0.41767}, "CVE-2008-7283": {"epss_score": 0.00135, "epss_percentile": 0.33991}, "CVE-2008-7284": {"epss_score": 0.00337, "epss_percentile": 0.56022}, "CVE-2008-7285": {"epss_score": 0.00572, "epss_percentile": 0.68003}, "CVE-2008-7286": {"epss_score": 0.00337, "epss_percentile": 0.56022}, "CVE-2008-7287": {"epss_score": 0.0036, "epss_percentile": 0.57662}, "CVE-2008-7288": {"epss_score": 0.00572, "epss_percentile": 0.68003}, "CVE-2008-7289": {"epss_score": 0.0036, "epss_percentile": 0.57662}, "CVE-2008-7290": {"epss_score": 0.0036, "epss_percentile": 0.57662}, "CVE-2008-7291": {"epss_score": 0.00432, "epss_percentile": 0.62125}, "CVE-2008-7292": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2008-7293": {"epss_score": 0.00586, "epss_percentile": 0.68444}, "CVE-2008-7294": {"epss_score": 0.00315, "epss_percentile": 0.54175}, "CVE-2008-7295": {"epss_score": 0.22454, "epss_percentile": 0.95636}, "CVE-2008-7296": {"epss_score": 0.00435, "epss_percentile": 0.62326}, "CVE-2008-7297": {"epss_score": 0.00435, "epss_percentile": 0.62326}, "CVE-2008-7298": {"epss_score": 0.00228, "epss_percentile": 0.45494}, "CVE-2008-7299": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2008-7300": {"epss_score": 0.00273, "epss_percentile": 0.50426}, "CVE-2008-7301": {"epss_score": 0.00165, "epss_percentile": 0.38105}, "CVE-2008-7302": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2008-7303": {"epss_score": 0.03459, "epss_percentile": 0.87177}, "CVE-2008-7309": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2008-7310": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2008-7311": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2008-7312": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2008-7313": {"epss_score": 0.0146, "epss_percentile": 0.80415}, "CVE-2008-7314": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2008-7315": {"epss_score": 0.04844, "epss_percentile": 0.89205}, "CVE-2008-7316": {"epss_score": 0.00053, "epss_percentile": 0.16692}, "CVE-2008-7319": {"epss_score": 0.04134, "epss_percentile": 0.88303}, "CVE-2008-7320": {"epss_score": 0.00072, "epss_percentile": 0.22378}, "CVE-2008-7321": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2009-0001": {"epss_score": 0.06732, "epss_percentile": 0.90989}, "CVE-2009-0002": {"epss_score": 0.38566, "epss_percentile": 0.97105}, "CVE-2009-0003": {"epss_score": 0.36426, "epss_percentile": 0.96977}, "CVE-2009-0004": {"epss_score": 0.05337, "epss_percentile": 0.89744}, "CVE-2009-0005": {"epss_score": 0.04381, "epss_percentile": 0.88624}, "CVE-2009-0006": {"epss_score": 0.45665, "epss_percentile": 0.97496}, "CVE-2009-0007": {"epss_score": 0.42838, "epss_percentile": 0.97357}, "CVE-2009-0008": {"epss_score": 0.05254, "epss_percentile": 0.89665}, "CVE-2009-0009": {"epss_score": 0.02605, "epss_percentile": 0.85221}, "CVE-2009-0010": {"epss_score": 0.47898, "epss_percentile": 0.97607}, "CVE-2009-0011": {"epss_score": 0.00029, "epss_percentile": 0.07687}, "CVE-2009-0012": {"epss_score": 0.09328, "epss_percentile": 0.92502}, "CVE-2009-0013": {"epss_score": 0.0007, "epss_percentile": 0.21752}, "CVE-2009-0014": {"epss_score": 0.00068, "epss_percentile": 0.21347}, "CVE-2009-0015": {"epss_score": 0.0007, "epss_percentile": 0.21752}, "CVE-2009-0016": {"epss_score": 0.01435, "epss_percentile": 0.80266}, "CVE-2009-0017": {"epss_score": 0.0008, "epss_percentile": 0.24094}, "CVE-2009-0018": {"epss_score": 0.00553, "epss_percentile": 0.6743}, "CVE-2009-0019": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2009-0020": {"epss_score": 0.02239, "epss_percentile": 0.84109}, "CVE-2009-0021": {"epss_score": 0.02216, "epss_percentile": 0.84036}, "CVE-2009-0022": {"epss_score": 0.04433, "epss_percentile": 0.8868}, "CVE-2009-0023": {"epss_score": 0.15679, "epss_percentile": 0.94484}, "CVE-2009-0024": {"epss_score": 0.00047, "epss_percentile": 0.14694}, "CVE-2009-0025": {"epss_score": 0.05028, "epss_percentile": 0.89411}, "CVE-2009-0026": {"epss_score": 0.42073, "epss_percentile": 0.97311}, "CVE-2009-0027": {"epss_score": 0.00705, "epss_percentile": 0.71583}, "CVE-2009-0028": {"epss_score": 0.0024, "epss_percentile": 0.46941}, "CVE-2009-0029": {"epss_score": 0.00043, "epss_percentile": 0.1336}, "CVE-2009-0030": {"epss_score": 0.01048, "epss_percentile": 0.77049}, "CVE-2009-0031": {"epss_score": 0.00101, "epss_percentile": 0.28657}, "CVE-2009-0032": {"epss_score": 0.00033, "epss_percentile": 0.09153}, "CVE-2009-0033": {"epss_score": 0.13832, "epss_percentile": 0.94072}, "CVE-2009-0034": {"epss_score": 0.00049, "epss_percentile": 0.15506}, "CVE-2009-0035": {"epss_score": 0.00181, "epss_percentile": 0.40117}, "CVE-2009-0036": {"epss_score": 0.00244, "epss_percentile": 0.47515}, "CVE-2009-0037": {"epss_score": 0.0337, "epss_percentile": 0.87009}, "CVE-2009-0038": {"epss_score": 0.23675, "epss_percentile": 0.95802}, "CVE-2009-0039": {"epss_score": 0.06012, "epss_percentile": 0.9041}, "CVE-2009-0040": {"epss_score": 0.08276, "epss_percentile": 0.91965}, "CVE-2009-0041": {"epss_score": 0.0086, "epss_percentile": 0.74529}, "CVE-2009-0042": {"epss_score": 0.014, "epss_percentile": 0.80005}, "CVE-2009-0043": {"epss_score": 0.50795, "epss_percentile": 0.9775}, "CVE-2009-0046": {"epss_score": 0.00088, "epss_percentile": 0.25636}, "CVE-2009-0047": {"epss_score": 0.00088, "epss_percentile": 0.25636}, "CVE-2009-0048": {"epss_score": 0.00088, "epss_percentile": 0.25636}, "CVE-2009-0049": {"epss_score": 0.0012, "epss_percentile": 0.3179}, "CVE-2009-0050": {"epss_score": 0.00147, "epss_percentile": 0.35779}, "CVE-2009-0051": {"epss_score": 0.00088, "epss_percentile": 0.25636}, "CVE-2009-0052": {"epss_score": 0.01041, "epss_percentile": 0.76969}, "CVE-2009-0053": {"epss_score": 0.00278, "epss_percentile": 0.50856}, "CVE-2009-0054": {"epss_score": 0.00278, "epss_percentile": 0.50856}, "CVE-2009-0055": {"epss_score": 0.00251, "epss_percentile": 0.48271}, "CVE-2009-0056": {"epss_score": 0.00226, "epss_percentile": 0.45283}, "CVE-2009-0057": {"epss_score": 0.00529, "epss_percentile": 0.66597}, "CVE-2009-0058": {"epss_score": 0.00404, "epss_percentile": 0.60398}, "CVE-2009-0059": {"epss_score": 0.00985, "epss_percentile": 0.76324}, "CVE-2009-0061": {"epss_score": 0.00573, "epss_percentile": 0.68053}, "CVE-2009-0062": {"epss_score": 0.00486, "epss_percentile": 0.64745}, "CVE-2009-0063": {"epss_score": 0.00719, "epss_percentile": 0.71942}, "CVE-2009-0064": {"epss_score": 0.01326, "epss_percentile": 0.7948}, "CVE-2009-0065": {"epss_score": 0.15492, "epss_percentile": 0.94438}, "CVE-2009-0066": {"epss_score": 0.00299, "epss_percentile": 0.52845}, "CVE-2009-0068": {"epss_score": 0.01379, "epss_percentile": 0.79855}, "CVE-2009-0069": {"epss_score": 0.00054, "epss_percentile": 0.17322}, "CVE-2009-0070": {"epss_score": 0.0545, "epss_percentile": 0.89891}, "CVE-2009-0071": {"epss_score": 0.10185, "epss_percentile": 0.92885}, "CVE-2009-0072": {"epss_score": 0.10234, "epss_percentile": 0.92905}, "CVE-2009-0075": {"epss_score": 0.86932, "epss_percentile": 0.99404}, "CVE-2009-0076": {"epss_score": 0.58479, "epss_percentile": 0.9812}, "CVE-2009-0077": {"epss_score": 0.88702, "epss_percentile": 0.99484}, "CVE-2009-0078": {"epss_score": 0.01629, "epss_percentile": 0.81438}, "CVE-2009-0079": {"epss_score": 0.00646, "epss_percentile": 0.70141}, "CVE-2009-0080": {"epss_score": 0.02154, "epss_percentile": 0.83797}, "CVE-2009-0081": {"epss_score": 0.66505, "epss_percentile": 0.98465}, "CVE-2009-0082": {"epss_score": 0.01038, "epss_percentile": 0.76939}, "CVE-2009-0083": {"epss_score": 0.01156, "epss_percentile": 0.781}, "CVE-2009-0084": {"epss_score": 0.61578, "epss_percentile": 0.98253}, "CVE-2009-0085": {"epss_score": 0.24947, "epss_percentile": 0.95972}, "CVE-2009-0086": {"epss_score": 0.52494, "epss_percentile": 0.97828}, "CVE-2009-0087": {"epss_score": 0.57098, "epss_percentile": 0.98048}, "CVE-2009-0088": {"epss_score": 0.62999, "epss_percentile": 0.98316}, "CVE-2009-0089": {"epss_score": 0.12818, "epss_percentile": 0.93782}, "CVE-2009-0090": {"epss_score": 0.4466, "epss_percentile": 0.97448}, "CVE-2009-0091": {"epss_score": 0.4452, "epss_percentile": 0.97442}, "CVE-2009-0093": {"epss_score": 0.52519, "epss_percentile": 0.9783}, "CVE-2009-0094": {"epss_score": 0.60488, "epss_percentile": 0.98208}, "CVE-2009-0095": {"epss_score": 0.48815, "epss_percentile": 0.97657}, "CVE-2009-0096": {"epss_score": 0.63267, "epss_percentile": 0.98326}, "CVE-2009-0097": {"epss_score": 0.5743, "epss_percentile": 0.98062}, "CVE-2009-0098": {"epss_score": 0.62507, "epss_percentile": 0.98296}, "CVE-2009-0099": {"epss_score": 0.71059, "epss_percentile": 0.98652}, "CVE-2009-0100": {"epss_score": 0.57218, "epss_percentile": 0.98054}, "CVE-2009-0102": {"epss_score": 0.47216, "epss_percentile": 0.97576}, "CVE-2009-0103": {"epss_score": 0.0252, "epss_percentile": 0.85}, "CVE-2009-0104": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2009-0105": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2009-0106": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2009-0107": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-0108": {"epss_score": 0.0194, "epss_percentile": 0.82979}, "CVE-2009-0109": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0110": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0111": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0112": {"epss_score": 0.00236, "epss_percentile": 0.46381}, "CVE-2009-0113": {"epss_score": 0.00104, "epss_percentile": 0.29159}, "CVE-2009-0114": {"epss_score": 0.22856, "epss_percentile": 0.957}, "CVE-2009-0115": {"epss_score": 0.00084, "epss_percentile": 0.24868}, "CVE-2009-0119": {"epss_score": 0.21964, "epss_percentile": 0.95578}, "CVE-2009-0120": {"epss_score": 0.05018, "epss_percentile": 0.89396}, "CVE-2009-0121": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2009-0122": {"epss_score": 0.00053, "epss_percentile": 0.16833}, "CVE-2009-0123": {"epss_score": 0.00407, "epss_percentile": 0.60621}, "CVE-2009-0124": {"epss_score": 0.0013, "epss_percentile": 0.33342}, "CVE-2009-0125": {"epss_score": 0.00093, "epss_percentile": 0.26607}, "CVE-2009-0126": {"epss_score": 0.00502, "epss_percentile": 0.6542}, "CVE-2009-0127": {"epss_score": 0.00081, "epss_percentile": 0.24311}, "CVE-2009-0128": {"epss_score": 0.00078, "epss_percentile": 0.23552}, "CVE-2009-0129": {"epss_score": 0.00075, "epss_percentile": 0.22997}, "CVE-2009-0130": {"epss_score": 0.00056, "epss_percentile": 0.17898}, "CVE-2009-0131": {"epss_score": 0.00047, "epss_percentile": 0.14707}, "CVE-2009-0132": {"epss_score": 0.00094, "epss_percentile": 0.27071}, "CVE-2009-0133": {"epss_score": 0.70799, "epss_percentile": 0.98642}, "CVE-2009-0134": {"epss_score": 0.05637, "epss_percentile": 0.90073}, "CVE-2009-0135": {"epss_score": 0.07819, "epss_percentile": 0.91697}, "CVE-2009-0136": {"epss_score": 0.16097, "epss_percentile": 0.94572}, "CVE-2009-0137": {"epss_score": 0.00513, "epss_percentile": 0.65924}, "CVE-2009-0138": {"epss_score": 0.02498, "epss_percentile": 0.84912}, "CVE-2009-0139": {"epss_score": 0.0079, "epss_percentile": 0.73365}, "CVE-2009-0140": {"epss_score": 0.00427, "epss_percentile": 0.61778}, "CVE-2009-0141": {"epss_score": 0.00047, "epss_percentile": 0.14778}, "CVE-2009-0142": {"epss_score": 0.00055, "epss_percentile": 0.17644}, "CVE-2009-0143": {"epss_score": 0.00708, "epss_percentile": 0.71683}, "CVE-2009-0144": {"epss_score": 0.00314, "epss_percentile": 0.54123}, "CVE-2009-0145": {"epss_score": 0.08628, "epss_percentile": 0.92161}, "CVE-2009-0146": {"epss_score": 0.01745, "epss_percentile": 0.82067}, "CVE-2009-0147": {"epss_score": 0.02384, "epss_percentile": 0.84574}, "CVE-2009-0148": {"epss_score": 0.11717, "epss_percentile": 0.93458}, "CVE-2009-0149": {"epss_score": 0.00117, "epss_percentile": 0.31214}, "CVE-2009-0150": {"epss_score": 0.00164, "epss_percentile": 0.37981}, "CVE-2009-0151": {"epss_score": 0.00055, "epss_percentile": 0.17415}, "CVE-2009-0152": {"epss_score": 0.00694, "epss_percentile": 0.7135}, "CVE-2009-0153": {"epss_score": 0.07006, "epss_percentile": 0.9118}, "CVE-2009-0154": {"epss_score": 0.19859, "epss_percentile": 0.95251}, "CVE-2009-0155": {"epss_score": 0.06174, "epss_percentile": 0.90532}, "CVE-2009-0156": {"epss_score": 0.01114, "epss_percentile": 0.77698}, "CVE-2009-0157": {"epss_score": 0.01234, "epss_percentile": 0.78757}, "CVE-2009-0158": {"epss_score": 0.02104, "epss_percentile": 0.8362}, "CVE-2009-0159": {"epss_score": 0.20296, "epss_percentile": 0.95315}, "CVE-2009-0160": {"epss_score": 0.01518, "epss_percentile": 0.80812}, "CVE-2009-0161": {"epss_score": 0.002, "epss_percentile": 0.42273}, "CVE-2009-0162": {"epss_score": 0.01707, "epss_percentile": 0.81861}, "CVE-2009-0163": {"epss_score": 0.0495, "epss_percentile": 0.89322}, "CVE-2009-0164": {"epss_score": 0.05721, "epss_percentile": 0.9015}, "CVE-2009-0165": {"epss_score": 0.01757, "epss_percentile": 0.82133}, "CVE-2009-0166": {"epss_score": 0.0519, "epss_percentile": 0.89594}, "CVE-2009-0167": {"epss_score": 0.00058, "epss_percentile": 0.18594}, "CVE-2009-0168": {"epss_score": 0.00055, "epss_percentile": 0.17528}, "CVE-2009-0169": {"epss_score": 0.01436, "epss_percentile": 0.80273}, "CVE-2009-0170": {"epss_score": 0.00802, "epss_percentile": 0.73592}, "CVE-2009-0171": {"epss_score": 0.00837, "epss_percentile": 0.74154}, "CVE-2009-0172": {"epss_score": 0.05717, "epss_percentile": 0.90148}, "CVE-2009-0173": {"epss_score": 0.01961, "epss_percentile": 0.83061}, "CVE-2009-0174": {"epss_score": 0.27727, "epss_percentile": 0.96276}, "CVE-2009-0175": {"epss_score": 0.23329, "epss_percentile": 0.95767}, "CVE-2009-0176": {"epss_score": 0.06476, "epss_percentile": 0.90783}, "CVE-2009-0177": {"epss_score": 0.13672, "epss_percentile": 0.94031}, "CVE-2009-0178": {"epss_score": 0.00985, "epss_percentile": 0.76323}, "CVE-2009-0179": {"epss_score": 0.02143, "epss_percentile": 0.83755}, "CVE-2009-0180": {"epss_score": 0.00477, "epss_percentile": 0.64343}, "CVE-2009-0181": {"epss_score": 0.00342, "epss_percentile": 0.56379}, "CVE-2009-0182": {"epss_score": 0.79024, "epss_percentile": 0.99016}, "CVE-2009-0183": {"epss_score": 0.7952, "epss_percentile": 0.99043}, "CVE-2009-0184": {"epss_score": 0.65689, "epss_percentile": 0.98433}, "CVE-2009-0185": {"epss_score": 0.28197, "epss_percentile": 0.9633}, "CVE-2009-0186": {"epss_score": 0.04235, "epss_percentile": 0.88428}, "CVE-2009-0187": {"epss_score": 0.73411, "epss_percentile": 0.98752}, "CVE-2009-0188": {"epss_score": 0.09031, "epss_percentile": 0.92375}, "CVE-2009-0191": {"epss_score": 0.00961, "epss_percentile": 0.75973}, "CVE-2009-0192": {"epss_score": 0.16311, "epss_percentile": 0.94628}, "CVE-2009-0193": {"epss_score": 0.13522, "epss_percentile": 0.93988}, "CVE-2009-0194": {"epss_score": 0.01417, "epss_percentile": 0.80155}, "CVE-2009-0195": {"epss_score": 0.09017, "epss_percentile": 0.92368}, "CVE-2009-0196": {"epss_score": 0.12164, "epss_percentile": 0.93587}, "CVE-2009-0197": {"epss_score": 0.1084, "epss_percentile": 0.9313}, "CVE-2009-0198": {"epss_score": 0.0739, "epss_percentile": 0.91448}, "CVE-2009-0199": {"epss_score": 0.10861, "epss_percentile": 0.93137}, "CVE-2009-0200": {"epss_score": 0.10842, "epss_percentile": 0.93131}, "CVE-2009-0201": {"epss_score": 0.13145, "epss_percentile": 0.93884}, "CVE-2009-0202": {"epss_score": 0.45015, "epss_percentile": 0.97466}, "CVE-2009-0204": {"epss_score": 0.00775, "epss_percentile": 0.73091}, "CVE-2009-0206": {"epss_score": 0.00063, "epss_percentile": 0.20096}, "CVE-2009-0207": {"epss_score": 0.00042, "epss_percentile": 0.12569}, "CVE-2009-0208": {"epss_score": 0.04177, "epss_percentile": 0.88352}, "CVE-2009-0209": {"epss_score": 0.00139, "epss_percentile": 0.34572}, "CVE-2009-0210": {"epss_score": 0.03074, "epss_percentile": 0.86356}, "CVE-2009-0211": {"epss_score": 0.01575, "epss_percentile": 0.81108}, "CVE-2009-0212": {"epss_score": 0.01575, "epss_percentile": 0.81108}, "CVE-2009-0213": {"epss_score": 0.01575, "epss_percentile": 0.81108}, "CVE-2009-0214": {"epss_score": 0.0079, "epss_percentile": 0.73376}, "CVE-2009-0215": {"epss_score": 0.61131, "epss_percentile": 0.98236}, "CVE-2009-0216": {"epss_score": 0.08403, "epss_percentile": 0.92033}, "CVE-2009-0217": {"epss_score": 0.07568, "epss_percentile": 0.91545}, "CVE-2009-0218": {"epss_score": 0.07021, "epss_percentile": 0.91192}, "CVE-2009-0219": {"epss_score": 0.04314, "epss_percentile": 0.88536}, "CVE-2009-0220": {"epss_score": 0.70609, "epss_percentile": 0.98638}, "CVE-2009-0221": {"epss_score": 0.67679, "epss_percentile": 0.98517}, "CVE-2009-0222": {"epss_score": 0.53752, "epss_percentile": 0.97895}, "CVE-2009-0223": {"epss_score": 0.52125, "epss_percentile": 0.9781}, "CVE-2009-0224": {"epss_score": 0.51546, "epss_percentile": 0.97786}, "CVE-2009-0225": {"epss_score": 0.53752, "epss_percentile": 0.97895}, "CVE-2009-0226": {"epss_score": 0.63521, "epss_percentile": 0.98336}, "CVE-2009-0227": {"epss_score": 0.67802, "epss_percentile": 0.98521}, "CVE-2009-0228": {"epss_score": 0.4121, "epss_percentile": 0.9726}, "CVE-2009-0229": {"epss_score": 0.02994, "epss_percentile": 0.86152}, "CVE-2009-0230": {"epss_score": 0.33043, "epss_percentile": 0.96743}, "CVE-2009-0231": {"epss_score": 0.68818, "epss_percentile": 0.98564}, "CVE-2009-0232": {"epss_score": 0.60289, "epss_percentile": 0.98202}, "CVE-2009-0233": {"epss_score": 0.55572, "epss_percentile": 0.97986}, "CVE-2009-0234": {"epss_score": 0.69056, "epss_percentile": 0.98575}, "CVE-2009-0235": {"epss_score": 0.72261, "epss_percentile": 0.98702}, "CVE-2009-0237": {"epss_score": 0.41876, "epss_percentile": 0.97299}, "CVE-2009-0238": {"epss_score": 0.57177, "epss_percentile": 0.98052}, "CVE-2009-0239": {"epss_score": 0.30683, "epss_percentile": 0.96561}, "CVE-2009-0240": {"epss_score": 0.00412, "epss_percentile": 0.6094}, "CVE-2009-0241": {"epss_score": 0.08907, "epss_percentile": 0.9231}, "CVE-2009-0243": {"epss_score": 0.01276, "epss_percentile": 0.79107}, "CVE-2009-0244": {"epss_score": 0.17356, "epss_percentile": 0.94833}, "CVE-2009-0245": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-0246": {"epss_score": 0.04242, "epss_percentile": 0.88438}, "CVE-2009-0247": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2009-0248": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2009-0249": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2009-0250": {"epss_score": 0.05317, "epss_percentile": 0.89724}, "CVE-2009-0251": {"epss_score": 0.02421, "epss_percentile": 0.84705}, "CVE-2009-0252": {"epss_score": 0.00374, "epss_percentile": 0.58531}, "CVE-2009-0253": {"epss_score": 0.03046, "epss_percentile": 0.86282}, "CVE-2009-0254": {"epss_score": 0.01367, "epss_percentile": 0.79785}, "CVE-2009-0255": {"epss_score": 0.05112, "epss_percentile": 0.89511}, "CVE-2009-0256": {"epss_score": 0.00911, "epss_percentile": 0.75327}, "CVE-2009-0257": {"epss_score": 0.00705, "epss_percentile": 0.71583}, "CVE-2009-0258": {"epss_score": 0.03387, "epss_percentile": 0.87042}, "CVE-2009-0259": {"epss_score": 0.15502, "epss_percentile": 0.9444}, "CVE-2009-0260": {"epss_score": 0.03091, "epss_percentile": 0.86395}, "CVE-2009-0261": {"epss_score": 0.69517, "epss_percentile": 0.98591}, "CVE-2009-0262": {"epss_score": 0.1381, "epss_percentile": 0.94061}, "CVE-2009-0263": {"epss_score": 0.20765, "epss_percentile": 0.9541}, "CVE-2009-0264": {"epss_score": 0.00427, "epss_percentile": 0.61891}, "CVE-2009-0265": {"epss_score": 0.0039, "epss_percentile": 0.59535}, "CVE-2009-0266": {"epss_score": 0.08986, "epss_percentile": 0.92353}, "CVE-2009-0267": {"epss_score": 0.01658, "epss_percentile": 0.81609}, "CVE-2009-0268": {"epss_score": 0.00042, "epss_percentile": 0.12791}, "CVE-2009-0269": {"epss_score": 0.00157, "epss_percentile": 0.37035}, "CVE-2009-0270": {"epss_score": 0.15574, "epss_percentile": 0.94461}, "CVE-2009-0271": {"epss_score": 0.00422, "epss_percentile": 0.61563}, "CVE-2009-0272": {"epss_score": 0.00203, "epss_percentile": 0.4256}, "CVE-2009-0273": {"epss_score": 0.00888, "epss_percentile": 0.74997}, "CVE-2009-0274": {"epss_score": 0.00365, "epss_percentile": 0.57983}, "CVE-2009-0275": {"epss_score": 0.00813, "epss_percentile": 0.73762}, "CVE-2009-0276": {"epss_score": 0.00123, "epss_percentile": 0.32191}, "CVE-2009-0277": {"epss_score": 0.00374, "epss_percentile": 0.58589}, "CVE-2009-0278": {"epss_score": 0.00467, "epss_percentile": 0.63849}, "CVE-2009-0279": {"epss_score": 0.00174, "epss_percentile": 0.39139}, "CVE-2009-0280": {"epss_score": 0.02606, "epss_percentile": 0.85222}, "CVE-2009-0281": {"epss_score": 0.0046, "epss_percentile": 0.63525}, "CVE-2009-0282": {"epss_score": 0.11055, "epss_percentile": 0.93203}, "CVE-2009-0283": {"epss_score": 0.01625, "epss_percentile": 0.81417}, "CVE-2009-0284": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0285": {"epss_score": 0.01625, "epss_percentile": 0.81417}, "CVE-2009-0286": {"epss_score": 0.01472, "epss_percentile": 0.80508}, "CVE-2009-0287": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2009-0288": {"epss_score": 0.00864, "epss_percentile": 0.74611}, "CVE-2009-0289": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2009-0290": {"epss_score": 0.07349, "epss_percentile": 0.91424}, "CVE-2009-0291": {"epss_score": 0.01356, "epss_percentile": 0.79715}, "CVE-2009-0292": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0293": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0294": {"epss_score": 0.00517, "epss_percentile": 0.66073}, "CVE-2009-0295": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0296": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0297": {"epss_score": 0.00149, "epss_percentile": 0.35955}, "CVE-2009-0298": {"epss_score": 0.23155, "epss_percentile": 0.95744}, "CVE-2009-0299": {"epss_score": 0.00521, "epss_percentile": 0.66228}, "CVE-2009-0301": {"epss_score": 0.0306, "epss_percentile": 0.86307}, "CVE-2009-0302": {"epss_score": 0.0036, "epss_percentile": 0.57689}, "CVE-2009-0303": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-0304": {"epss_score": 0.11816, "epss_percentile": 0.93485}, "CVE-2009-0305": {"epss_score": 0.48109, "epss_percentile": 0.97621}, "CVE-2009-0306": {"epss_score": 0.04329, "epss_percentile": 0.88557}, "CVE-2009-0307": {"epss_score": 0.03406, "epss_percentile": 0.87076}, "CVE-2009-0310": {"epss_score": 0.00053, "epss_percentile": 0.16713}, "CVE-2009-0311": {"epss_score": 0.10291, "epss_percentile": 0.9293}, "CVE-2009-0312": {"epss_score": 0.00676, "epss_percentile": 0.70925}, "CVE-2009-0313": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2009-0314": {"epss_score": 0.00126, "epss_percentile": 0.32755}, "CVE-2009-0315": {"epss_score": 0.00057, "epss_percentile": 0.18071}, "CVE-2009-0316": {"epss_score": 0.00211, "epss_percentile": 0.4363}, "CVE-2009-0317": {"epss_score": 0.00216, "epss_percentile": 0.44233}, "CVE-2009-0318": {"epss_score": 0.00067, "epss_percentile": 0.21121}, "CVE-2009-0319": {"epss_score": 0.00039, "epss_percentile": 0.11672}, "CVE-2009-0320": {"epss_score": 0.00914, "epss_percentile": 0.75387}, "CVE-2009-0321": {"epss_score": 0.03513, "epss_percentile": 0.8727}, "CVE-2009-0322": {"epss_score": 0.00076, "epss_percentile": 0.23259}, "CVE-2009-0323": {"epss_score": 0.72459, "epss_percentile": 0.98712}, "CVE-2009-0324": {"epss_score": 0.00432, "epss_percentile": 0.62158}, "CVE-2009-0325": {"epss_score": 0.0376, "epss_percentile": 0.87687}, "CVE-2009-0326": {"epss_score": 0.00161, "epss_percentile": 0.37605}, "CVE-2009-0327": {"epss_score": 0.00432, "epss_percentile": 0.62158}, "CVE-2009-0328": {"epss_score": 0.03094, "epss_percentile": 0.86401}, "CVE-2009-0329": {"epss_score": 0.00017, "epss_percentile": 0.03433}, "CVE-2009-0330": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-0331": {"epss_score": 0.03208, "epss_percentile": 0.86642}, "CVE-2009-0332": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2009-0333": {"epss_score": 0.00022, "epss_percentile": 0.05166}, "CVE-2009-0334": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0335": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-0336": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2009-0337": {"epss_score": 0.00295, "epss_percentile": 0.52505}, "CVE-2009-0338": {"epss_score": 0.01928, "epss_percentile": 0.82929}, "CVE-2009-0339": {"epss_score": 0.00358, "epss_percentile": 0.57491}, "CVE-2009-0340": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2009-0341": {"epss_score": 0.45292, "epss_percentile": 0.97481}, "CVE-2009-0342": {"epss_score": 0.00062, "epss_percentile": 0.19704}, "CVE-2009-0343": {"epss_score": 0.00104, "epss_percentile": 0.29162}, "CVE-2009-0344": {"epss_score": 0.02295, "epss_percentile": 0.84292}, "CVE-2009-0345": {"epss_score": 0.02295, "epss_percentile": 0.84292}, "CVE-2009-0346": {"epss_score": 0.00045, "epss_percentile": 0.1406}, "CVE-2009-0347": {"epss_score": 0.03639, "epss_percentile": 0.87485}, "CVE-2009-0348": {"epss_score": 0.08468, "epss_percentile": 0.92067}, "CVE-2009-0349": {"epss_score": 0.26051, "epss_percentile": 0.96105}, "CVE-2009-0350": {"epss_score": 0.0786, "epss_percentile": 0.91726}, "CVE-2009-0351": {"epss_score": 0.2786, "epss_percentile": 0.96289}, "CVE-2009-0352": {"epss_score": 0.08533, "epss_percentile": 0.92107}, "CVE-2009-0353": {"epss_score": 0.0678, "epss_percentile": 0.91022}, "CVE-2009-0354": {"epss_score": 0.00789, "epss_percentile": 0.73354}, "CVE-2009-0355": {"epss_score": 0.02431, "epss_percentile": 0.84728}, "CVE-2009-0356": {"epss_score": 0.00909, "epss_percentile": 0.75299}, "CVE-2009-0357": {"epss_score": 0.0108, "epss_percentile": 0.77369}, "CVE-2009-0358": {"epss_score": 0.00192, "epss_percentile": 0.41364}, "CVE-2009-0359": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2009-0360": {"epss_score": 0.00127, "epss_percentile": 0.32882}, "CVE-2009-0361": {"epss_score": 0.0007, "epss_percentile": 0.21764}, "CVE-2009-0362": {"epss_score": 0.00589, "epss_percentile": 0.68537}, "CVE-2009-0363": {"epss_score": 0.04323, "epss_percentile": 0.8855}, "CVE-2009-0364": {"epss_score": 0.01625, "epss_percentile": 0.81418}, "CVE-2009-0365": {"epss_score": 0.00116, "epss_percentile": 0.31159}, "CVE-2009-0366": {"epss_score": 0.02375, "epss_percentile": 0.8454}, "CVE-2009-0367": {"epss_score": 0.07471, "epss_percentile": 0.91491}, "CVE-2009-0368": {"epss_score": 0.0031, "epss_percentile": 0.53744}, "CVE-2009-0369": {"epss_score": 0.19134, "epss_percentile": 0.95137}, "CVE-2009-0370": {"epss_score": 0.00066, "epss_percentile": 0.20895}, "CVE-2009-0371": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2009-0372": {"epss_score": 0.02475, "epss_percentile": 0.84856}, "CVE-2009-0373": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2009-0374": {"epss_score": 0.04254, "epss_percentile": 0.88455}, "CVE-2009-0375": {"epss_score": 0.14318, "epss_percentile": 0.94185}, "CVE-2009-0376": {"epss_score": 0.24836, "epss_percentile": 0.95958}, "CVE-2009-0377": {"epss_score": 0.00017, "epss_percentile": 0.03433}, "CVE-2009-0378": {"epss_score": 0.00162, "epss_percentile": 0.37644}, "CVE-2009-0379": {"epss_score": 0.00017, "epss_percentile": 0.03433}, "CVE-2009-0380": {"epss_score": 0.00379, "epss_percentile": 0.58843}, "CVE-2009-0381": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0382": {"epss_score": 0.00117, "epss_percentile": 0.31213}, "CVE-2009-0383": {"epss_score": 0.09084, "epss_percentile": 0.92393}, "CVE-2009-0384": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2009-0385": {"epss_score": 0.11552, "epss_percentile": 0.93402}, "CVE-2009-0386": {"epss_score": 0.10426, "epss_percentile": 0.92984}, "CVE-2009-0387": {"epss_score": 0.17762, "epss_percentile": 0.94901}, "CVE-2009-0388": {"epss_score": 0.48672, "epss_percentile": 0.97648}, "CVE-2009-0389": {"epss_score": 0.03878, "epss_percentile": 0.87892}, "CVE-2009-0390": {"epss_score": 0.00184, "epss_percentile": 0.4041}, "CVE-2009-0391": {"epss_score": 0.00444, "epss_percentile": 0.62844}, "CVE-2009-0392": {"epss_score": 0.02747, "epss_percentile": 0.85574}, "CVE-2009-0393": {"epss_score": 0.00314, "epss_percentile": 0.54108}, "CVE-2009-0394": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2009-0395": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2009-0396": {"epss_score": 0.00725, "epss_percentile": 0.72051}, "CVE-2009-0397": {"epss_score": 0.10426, "epss_percentile": 0.92984}, "CVE-2009-0398": {"epss_score": 0.00674, "epss_percentile": 0.70882}, "CVE-2009-0399": {"epss_score": 0.03562, "epss_percentile": 0.87355}, "CVE-2009-0400": {"epss_score": 0.00566, "epss_percentile": 0.67835}, "CVE-2009-0401": {"epss_score": 0.00526, "epss_percentile": 0.66403}, "CVE-2009-0402": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2009-0403": {"epss_score": 0.0046, "epss_percentile": 0.63525}, "CVE-2009-0404": {"epss_score": 0.00567, "epss_percentile": 0.67854}, "CVE-2009-0405": {"epss_score": 0.00174, "epss_percentile": 0.39139}, "CVE-2009-0406": {"epss_score": 0.00174, "epss_percentile": 0.39139}, "CVE-2009-0407": {"epss_score": 0.00174, "epss_percentile": 0.39139}, "CVE-2009-0408": {"epss_score": 0.00146, "epss_percentile": 0.35532}, "CVE-2009-0409": {"epss_score": 0.00566, "epss_percentile": 0.67835}, "CVE-2009-0410": {"epss_score": 0.18317, "epss_percentile": 0.94993}, "CVE-2009-0411": {"epss_score": 0.00377, "epss_percentile": 0.58693}, "CVE-2009-0412": {"epss_score": 0.00383, "epss_percentile": 0.59107}, "CVE-2009-0413": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2009-0414": {"epss_score": 0.01474, "epss_percentile": 0.80517}, "CVE-2009-0415": {"epss_score": 0.00083, "epss_percentile": 0.24801}, "CVE-2009-0416": {"epss_score": 0.00014, "epss_percentile": 0.02079}, "CVE-2009-0417": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2009-0418": {"epss_score": 0.02008, "epss_percentile": 0.83241}, "CVE-2009-0419": {"epss_score": 0.29847, "epss_percentile": 0.9648}, "CVE-2009-0420": {"epss_score": 0.00538, "epss_percentile": 0.66949}, "CVE-2009-0421": {"epss_score": 0.00025, "epss_percentile": 0.06054}, "CVE-2009-0422": {"epss_score": 0.0183, "epss_percentile": 0.82443}, "CVE-2009-0423": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2009-0424": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-0425": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2009-0426": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0427": {"epss_score": 0.01285, "epss_percentile": 0.7918}, "CVE-2009-0428": {"epss_score": 0.01285, "epss_percentile": 0.7918}, "CVE-2009-0429": {"epss_score": 0.00264, "epss_percentile": 0.49716}, "CVE-2009-0430": {"epss_score": 0.00462, "epss_percentile": 0.63581}, "CVE-2009-0431": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-0432": {"epss_score": 0.00321, "epss_percentile": 0.5474}, "CVE-2009-0433": {"epss_score": 0.00708, "epss_percentile": 0.71672}, "CVE-2009-0434": {"epss_score": 0.00057, "epss_percentile": 0.18176}, "CVE-2009-0435": {"epss_score": 0.00371, "epss_percentile": 0.58344}, "CVE-2009-0436": {"epss_score": 0.00058, "epss_percentile": 0.18484}, "CVE-2009-0437": {"epss_score": 0.00055, "epss_percentile": 0.17594}, "CVE-2009-0438": {"epss_score": 0.0021, "epss_percentile": 0.43587}, "CVE-2009-0439": {"epss_score": 0.00068, "epss_percentile": 0.21356}, "CVE-2009-0440": {"epss_score": 0.00433, "epss_percentile": 0.62226}, "CVE-2009-0441": {"epss_score": 0.01497, "epss_percentile": 0.80694}, "CVE-2009-0442": {"epss_score": 0.02144, "epss_percentile": 0.83762}, "CVE-2009-0443": {"epss_score": 0.23155, "epss_percentile": 0.95744}, "CVE-2009-0444": {"epss_score": 0.02168, "epss_percentile": 0.83862}, "CVE-2009-0445": {"epss_score": 0.00647, "epss_percentile": 0.70202}, "CVE-2009-0446": {"epss_score": 0.00274, "epss_percentile": 0.50558}, "CVE-2009-0447": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0448": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2009-0449": {"epss_score": 0.0032, "epss_percentile": 0.54638}, "CVE-2009-0450": {"epss_score": 0.08975, "epss_percentile": 0.92346}, "CVE-2009-0451": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2009-0452": {"epss_score": 0.00151, "epss_percentile": 0.36344}, "CVE-2009-0453": {"epss_score": 0.04838, "epss_percentile": 0.89196}, "CVE-2009-0454": {"epss_score": 0.00526, "epss_percentile": 0.66403}, "CVE-2009-0455": {"epss_score": 0.01104, "epss_percentile": 0.77603}, "CVE-2009-0456": {"epss_score": 0.02414, "epss_percentile": 0.84685}, "CVE-2009-0457": {"epss_score": 0.02144, "epss_percentile": 0.83762}, "CVE-2009-0458": {"epss_score": 0.00165, "epss_percentile": 0.38044}, "CVE-2009-0459": {"epss_score": 0.00173, "epss_percentile": 0.39135}, "CVE-2009-0460": {"epss_score": 0.01833, "epss_percentile": 0.82459}, "CVE-2009-0461": {"epss_score": 0.01833, "epss_percentile": 0.82459}, "CVE-2009-0462": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0463": {"epss_score": 0.02451, "epss_percentile": 0.84784}, "CVE-2009-0464": {"epss_score": 0.01323, "epss_percentile": 0.79456}, "CVE-2009-0465": {"epss_score": 0.07119, "epss_percentile": 0.91263}, "CVE-2009-0466": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-0467": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-0468": {"epss_score": 0.00228, "epss_percentile": 0.45541}, "CVE-2009-0469": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2009-0470": {"epss_score": 0.05024, "epss_percentile": 0.89407}, "CVE-2009-0471": {"epss_score": 0.00222, "epss_percentile": 0.44841}, "CVE-2009-0472": {"epss_score": 0.00029, "epss_percentile": 0.07587}, "CVE-2009-0473": {"epss_score": 0.00217, "epss_percentile": 0.44306}, "CVE-2009-0474": {"epss_score": 0.00486, "epss_percentile": 0.64746}, "CVE-2009-0475": {"epss_score": 0.02138, "epss_percentile": 0.83738}, "CVE-2009-0476": {"epss_score": 0.83257, "epss_percentile": 0.9924}, "CVE-2009-0477": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2009-0478": {"epss_score": 0.76172, "epss_percentile": 0.9888}, "CVE-2009-0479": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2009-0480": {"epss_score": 0.00052, "epss_percentile": 0.16377}, "CVE-2009-0481": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2009-0482": {"epss_score": 0.00267, "epss_percentile": 0.50014}, "CVE-2009-0483": {"epss_score": 0.00413, "epss_percentile": 0.61005}, "CVE-2009-0484": {"epss_score": 0.00413, "epss_percentile": 0.61005}, "CVE-2009-0485": {"epss_score": 0.00413, "epss_percentile": 0.61005}, "CVE-2009-0486": {"epss_score": 0.0014, "epss_percentile": 0.34685}, "CVE-2009-0487": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-0488": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2009-0489": {"epss_score": 0.00071, "epss_percentile": 0.2212}, "CVE-2009-0490": {"epss_score": 0.5806, "epss_percentile": 0.98098}, "CVE-2009-0491": {"epss_score": 0.23155, "epss_percentile": 0.95744}, "CVE-2009-0492": {"epss_score": 0.00341, "epss_percentile": 0.56344}, "CVE-2009-0493": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-0494": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2009-0495": {"epss_score": 0.02414, "epss_percentile": 0.84685}, "CVE-2009-0496": {"epss_score": 0.15022, "epss_percentile": 0.94346}, "CVE-2009-0497": {"epss_score": 0.05924, "epss_percentile": 0.90326}, "CVE-2009-0498": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2009-0499": {"epss_score": 0.00286, "epss_percentile": 0.51721}, "CVE-2009-0500": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2009-0501": {"epss_score": 0.00366, "epss_percentile": 0.58068}, "CVE-2009-0502": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2009-0503": {"epss_score": 0.00063, "epss_percentile": 0.19895}, "CVE-2009-0504": {"epss_score": 0.00054, "epss_percentile": 0.17362}, "CVE-2009-0505": {"epss_score": 0.00576, "epss_percentile": 0.68129}, "CVE-2009-0506": {"epss_score": 0.0005, "epss_percentile": 0.15827}, "CVE-2009-0507": {"epss_score": 0.00267, "epss_percentile": 0.49978}, "CVE-2009-0508": {"epss_score": 0.01719, "epss_percentile": 0.81926}, "CVE-2009-0509": {"epss_score": 0.0481, "epss_percentile": 0.89164}, "CVE-2009-0510": {"epss_score": 0.13068, "epss_percentile": 0.93864}, "CVE-2009-0511": {"epss_score": 0.13068, "epss_percentile": 0.93864}, "CVE-2009-0512": {"epss_score": 0.13068, "epss_percentile": 0.93864}, "CVE-2009-0513": {"epss_score": 0.02618, "epss_percentile": 0.85251}, "CVE-2009-0514": {"epss_score": 0.02214, "epss_percentile": 0.84026}, "CVE-2009-0515": {"epss_score": 0.02364, "epss_percentile": 0.84511}, "CVE-2009-0516": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2009-0517": {"epss_score": 0.61618, "epss_percentile": 0.98254}, "CVE-2009-0518": {"epss_score": 0.00054, "epss_percentile": 0.17294}, "CVE-2009-0519": {"epss_score": 0.29104, "epss_percentile": 0.96418}, "CVE-2009-0520": {"epss_score": 0.12502, "epss_percentile": 0.93694}, "CVE-2009-0521": {"epss_score": 0.00248, "epss_percentile": 0.47964}, "CVE-2009-0522": {"epss_score": 0.01908, "epss_percentile": 0.82815}, "CVE-2009-0523": {"epss_score": 0.01583, "epss_percentile": 0.81147}, "CVE-2009-0524": {"epss_score": 0.01583, "epss_percentile": 0.81147}, "CVE-2009-0525": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-0526": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-0527": {"epss_score": 0.01497, "epss_percentile": 0.80694}, "CVE-2009-0528": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0529": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-0530": {"epss_score": 0.02451, "epss_percentile": 0.84784}, "CVE-2009-0531": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2009-0532": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2009-0533": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2009-0534": {"epss_score": 0.00326, "epss_percentile": 0.55052}, "CVE-2009-0535": {"epss_score": 0.02041, "epss_percentile": 0.8337}, "CVE-2009-0536": {"epss_score": 0.0006, "epss_percentile": 0.19033}, "CVE-2009-0537": {"epss_score": 0.07054, "epss_percentile": 0.91215}, "CVE-2009-0538": {"epss_score": 0.00079, "epss_percentile": 0.23908}, "CVE-2009-0540": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2009-0541": {"epss_score": 0.00708, "epss_percentile": 0.71676}, "CVE-2009-0542": {"epss_score": 0.58494, "epss_percentile": 0.9812}, "CVE-2009-0543": {"epss_score": 0.00792, "epss_percentile": 0.73409}, "CVE-2009-0544": {"epss_score": 0.20425, "epss_percentile": 0.95343}, "CVE-2009-0545": {"epss_score": 0.94006, "epss_percentile": 0.99884}, "CVE-2009-0546": {"epss_score": 0.8017, "epss_percentile": 0.99074}, "CVE-2009-0547": {"epss_score": 0.03409, "epss_percentile": 0.8708}, "CVE-2009-0548": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2009-0549": {"epss_score": 0.52125, "epss_percentile": 0.9781}, "CVE-2009-0550": {"epss_score": 0.38591, "epss_percentile": 0.97108}, "CVE-2009-0551": {"epss_score": 0.52339, "epss_percentile": 0.9782}, "CVE-2009-0552": {"epss_score": 0.51039, "epss_percentile": 0.97759}, "CVE-2009-0553": {"epss_score": 0.72416, "epss_percentile": 0.98707}, "CVE-2009-0554": {"epss_score": 0.56689, "epss_percentile": 0.98033}, "CVE-2009-0555": {"epss_score": 0.31948, "epss_percentile": 0.96662}, "CVE-2009-0556": {"epss_score": 0.76763, "epss_percentile": 0.98903}, "CVE-2009-0557": {"epss_score": 0.83761, "epss_percentile": 0.99261}, "CVE-2009-0558": {"epss_score": 0.53752, "epss_percentile": 0.97895}, "CVE-2009-0559": {"epss_score": 0.53334, "epss_percentile": 0.97872}, "CVE-2009-0560": {"epss_score": 0.60605, "epss_percentile": 0.98212}, "CVE-2009-0561": {"epss_score": 0.6554, "epss_percentile": 0.98425}, "CVE-2009-0562": {"epss_score": 0.65426, "epss_percentile": 0.98417}, "CVE-2009-0563": {"epss_score": 0.80902, "epss_percentile": 0.99112}, "CVE-2009-0565": {"epss_score": 0.78689, "epss_percentile": 0.98999}, "CVE-2009-0566": {"epss_score": 0.52511, "epss_percentile": 0.97829}, "CVE-2009-0568": {"epss_score": 0.56246, "epss_percentile": 0.98014}, "CVE-2009-0569": {"epss_score": 0.08947, "epss_percentile": 0.92333}, "CVE-2009-0570": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-0571": {"epss_score": 0.04615, "epss_percentile": 0.88923}, "CVE-2009-0572": {"epss_score": 0.0399, "epss_percentile": 0.88071}, "CVE-2009-0573": {"epss_score": 0.00627, "epss_percentile": 0.69624}, "CVE-2009-0574": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-0575": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-0576": {"epss_score": 0.02025, "epss_percentile": 0.83312}, "CVE-2009-0577": {"epss_score": 0.03146, "epss_percentile": 0.86497}, "CVE-2009-0578": {"epss_score": 0.00048, "epss_percentile": 0.15013}, "CVE-2009-0579": {"epss_score": 0.00062, "epss_percentile": 0.19745}, "CVE-2009-0580": {"epss_score": 0.84451, "epss_percentile": 0.9929}, "CVE-2009-0581": {"epss_score": 0.01893, "epss_percentile": 0.82738}, "CVE-2009-0582": {"epss_score": 0.03477, "epss_percentile": 0.8721}, "CVE-2009-0583": {"epss_score": 0.04082, "epss_percentile": 0.88221}, "CVE-2009-0584": {"epss_score": 0.08952, "epss_percentile": 0.92335}, "CVE-2009-0585": {"epss_score": 0.02007, "epss_percentile": 0.8324}, "CVE-2009-0586": {"epss_score": 0.02819, "epss_percentile": 0.8574}, "CVE-2009-0587": {"epss_score": 0.01885, "epss_percentile": 0.82709}, "CVE-2009-0588": {"epss_score": 0.00461, "epss_percentile": 0.63551}, "CVE-2009-0590": {"epss_score": 0.10016, "epss_percentile": 0.92818}, "CVE-2009-0591": {"epss_score": 0.02422, "epss_percentile": 0.84706}, "CVE-2009-0592": {"epss_score": 0.49073, "epss_percentile": 0.97666}, "CVE-2009-0593": {"epss_score": 0.00287, "epss_percentile": 0.51843}, "CVE-2009-0594": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-0595": {"epss_score": 0.12219, "epss_percentile": 0.93604}, "CVE-2009-0596": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-0597": {"epss_score": 0.00181, "epss_percentile": 0.40024}, "CVE-2009-0598": {"epss_score": 0.00538, "epss_percentile": 0.66949}, "CVE-2009-0599": {"epss_score": 0.02012, "epss_percentile": 0.83254}, "CVE-2009-0600": {"epss_score": 0.02919, "epss_percentile": 0.85989}, "CVE-2009-0601": {"epss_score": 0.00041, "epss_percentile": 0.12457}, "CVE-2009-0602": {"epss_score": 0.03229, "epss_percentile": 0.86691}, "CVE-2009-0603": {"epss_score": 0.00202, "epss_percentile": 0.42456}, "CVE-2009-0604": {"epss_score": 0.0046, "epss_percentile": 0.63525}, "CVE-2009-0605": {"epss_score": 0.00175, "epss_percentile": 0.39317}, "CVE-2009-0606": {"epss_score": 0.0005, "epss_percentile": 0.15761}, "CVE-2009-0607": {"epss_score": 0.00056, "epss_percentile": 0.17832}, "CVE-2009-0608": {"epss_score": 0.00059, "epss_percentile": 0.18917}, "CVE-2009-0609": {"epss_score": 0.00744, "epss_percentile": 0.72505}, "CVE-2009-0610": {"epss_score": 0.01575, "epss_percentile": 0.81108}, "CVE-2009-0611": {"epss_score": 0.10718, "epss_percentile": 0.93082}, "CVE-2009-0612": {"epss_score": 0.0068, "epss_percentile": 0.71035}, "CVE-2009-0613": {"epss_score": 0.00443, "epss_percentile": 0.62761}, "CVE-2009-0614": {"epss_score": 0.0053, "epss_percentile": 0.66615}, "CVE-2009-0615": {"epss_score": 0.00221, "epss_percentile": 0.44651}, "CVE-2009-0616": {"epss_score": 0.00504, "epss_percentile": 0.65529}, "CVE-2009-0617": {"epss_score": 0.00796, "epss_percentile": 0.73484}, "CVE-2009-0618": {"epss_score": 0.00645, "epss_percentile": 0.70103}, "CVE-2009-0619": {"epss_score": 0.00393, "epss_percentile": 0.59713}, "CVE-2009-0620": {"epss_score": 0.00458, "epss_percentile": 0.63435}, "CVE-2009-0621": {"epss_score": 0.00458, "epss_percentile": 0.63435}, "CVE-2009-0622": {"epss_score": 0.00406, "epss_percentile": 0.60542}, "CVE-2009-0623": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2009-0624": {"epss_score": 0.00549, "epss_percentile": 0.67307}, "CVE-2009-0625": {"epss_score": 0.00799, "epss_percentile": 0.73529}, "CVE-2009-0626": {"epss_score": 0.01176, "epss_percentile": 0.78274}, "CVE-2009-0627": {"epss_score": 0.00313, "epss_percentile": 0.54032}, "CVE-2009-0628": {"epss_score": 0.01566, "epss_percentile": 0.81072}, "CVE-2009-0629": {"epss_score": 0.00927, "epss_percentile": 0.75572}, "CVE-2009-0630": {"epss_score": 0.00064, "epss_percentile": 0.20175}, "CVE-2009-0631": {"epss_score": 0.01811, "epss_percentile": 0.8237}, "CVE-2009-0632": {"epss_score": 0.01313, "epss_percentile": 0.79382}, "CVE-2009-0633": {"epss_score": 0.01469, "epss_percentile": 0.80488}, "CVE-2009-0634": {"epss_score": 0.02159, "epss_percentile": 0.83819}, "CVE-2009-0635": {"epss_score": 0.01415, "epss_percentile": 0.80136}, "CVE-2009-0636": {"epss_score": 0.015, "epss_percentile": 0.80712}, "CVE-2009-0637": {"epss_score": 0.01284, "epss_percentile": 0.79173}, "CVE-2009-0638": {"epss_score": 0.01334, "epss_percentile": 0.79532}, "CVE-2009-0639": {"epss_score": 0.02034, "epss_percentile": 0.83346}, "CVE-2009-0640": {"epss_score": 0.0348, "epss_percentile": 0.87218}, "CVE-2009-0641": {"epss_score": 0.08639, "epss_percentile": 0.92167}, "CVE-2009-0642": {"epss_score": 0.00974, "epss_percentile": 0.76171}, "CVE-2009-0643": {"epss_score": 0.03407, "epss_percentile": 0.87077}, "CVE-2009-0644": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2009-0645": {"epss_score": 0.01541, "epss_percentile": 0.80946}, "CVE-2009-0646": {"epss_score": 0.01627, "epss_percentile": 0.81429}, "CVE-2009-0647": {"epss_score": 0.18577, "epss_percentile": 0.95036}, "CVE-2009-0648": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2009-0649": {"epss_score": 0.02488, "epss_percentile": 0.84892}, "CVE-2009-0650": {"epss_score": 0.09656, "epss_percentile": 0.92642}, "CVE-2009-0651": {"epss_score": 0.03552, "epss_percentile": 0.87342}, "CVE-2009-0652": {"epss_score": 0.02133, "epss_percentile": 0.83718}, "CVE-2009-0653": {"epss_score": 0.0026, "epss_percentile": 0.49167}, "CVE-2009-0654": {"epss_score": 0.00487, "epss_percentile": 0.64778}, "CVE-2009-0655": {"epss_score": 0.0007, "epss_percentile": 0.21977}, "CVE-2009-0656": {"epss_score": 0.00063, "epss_percentile": 0.19904}, "CVE-2009-0657": {"epss_score": 0.00063, "epss_percentile": 0.19904}, "CVE-2009-0658": {"epss_score": 0.90801, "epss_percentile": 0.99601}, "CVE-2009-0659": {"epss_score": 0.03516, "epss_percentile": 0.87273}, "CVE-2009-0660": {"epss_score": 0.00467, "epss_percentile": 0.63861}, "CVE-2009-0661": {"epss_score": 0.01977, "epss_percentile": 0.83125}, "CVE-2009-0662": {"epss_score": 0.00464, "epss_percentile": 0.63722}, "CVE-2009-0663": {"epss_score": 0.06903, "epss_percentile": 0.91105}, "CVE-2009-0664": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2009-0667": {"epss_score": 0.0005, "epss_percentile": 0.15875}, "CVE-2009-0668": {"epss_score": 0.0064, "epss_percentile": 0.69957}, "CVE-2009-0669": {"epss_score": 0.0055, "epss_percentile": 0.67328}, "CVE-2009-0672": {"epss_score": 0.00752, "epss_percentile": 0.72653}, "CVE-2009-0673": {"epss_score": 0.05555, "epss_percentile": 0.89989}, "CVE-2009-0674": {"epss_score": 0.06859, "epss_percentile": 0.91079}, "CVE-2009-0675": {"epss_score": 0.00169, "epss_percentile": 0.38642}, "CVE-2009-0676": {"epss_score": 0.0018, "epss_percentile": 0.39934}, "CVE-2009-0677": {"epss_score": 0.14625, "epss_percentile": 0.94253}, "CVE-2009-0678": {"epss_score": 0.06084, "epss_percentile": 0.90464}, "CVE-2009-0679": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-0680": {"epss_score": 0.1507, "epss_percentile": 0.94354}, "CVE-2009-0681": {"epss_score": 0.00049, "epss_percentile": 0.15368}, "CVE-2009-0682": {"epss_score": 0.00061, "epss_percentile": 0.19516}, "CVE-2009-0686": {"epss_score": 0.00126, "epss_percentile": 0.32773}, "CVE-2009-0687": {"epss_score": 0.13584, "epss_percentile": 0.94002}, "CVE-2009-0688": {"epss_score": 0.33352, "epss_percentile": 0.96766}, "CVE-2009-0689": {"epss_score": 0.4176, "epss_percentile": 0.97292}, "CVE-2009-0690": {"epss_score": 0.01182, "epss_percentile": 0.78318}, "CVE-2009-0691": {"epss_score": 0.0133, "epss_percentile": 0.79511}, "CVE-2009-0692": {"epss_score": 0.28133, "epss_percentile": 0.96313}, "CVE-2009-0693": {"epss_score": 0.23452, "epss_percentile": 0.95779}, "CVE-2009-0695": {"epss_score": 0.64232, "epss_percentile": 0.98371}, "CVE-2009-0696": {"epss_score": 0.46199, "epss_percentile": 0.97535}, "CVE-2009-0698": {"epss_score": 0.02442, "epss_percentile": 0.84757}, "CVE-2009-0699": {"epss_score": 0.00318, "epss_percentile": 0.54452}, "CVE-2009-0700": {"epss_score": 0.03971, "epss_percentile": 0.88037}, "CVE-2009-0701": {"epss_score": 0.02103, "epss_percentile": 0.83614}, "CVE-2009-0702": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0703": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2009-0704": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-0705": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2009-0706": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2009-0707": {"epss_score": 0.00181, "epss_percentile": 0.40024}, "CVE-2009-0708": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2009-0709": {"epss_score": 0.00128, "epss_percentile": 0.32967}, "CVE-2009-0710": {"epss_score": 0.00225, "epss_percentile": 0.4513}, "CVE-2009-0711": {"epss_score": 0.00516, "epss_percentile": 0.66048}, "CVE-2009-0712": {"epss_score": 0.00051, "epss_percentile": 0.16271}, "CVE-2009-0713": {"epss_score": 0.00856, "epss_percentile": 0.74476}, "CVE-2009-0714": {"epss_score": 0.85299, "epss_percentile": 0.99328}, "CVE-2009-0715": {"epss_score": 0.00302, "epss_percentile": 0.53132}, "CVE-2009-0716": {"epss_score": 0.01164, "epss_percentile": 0.78165}, "CVE-2009-0717": {"epss_score": 0.01199, "epss_percentile": 0.7846}, "CVE-2009-0718": {"epss_score": 0.04619, "epss_percentile": 0.88928}, "CVE-2009-0719": {"epss_score": 0.00054, "epss_percentile": 0.17097}, "CVE-2009-0720": {"epss_score": 0.05863, "epss_percentile": 0.90272}, "CVE-2009-0721": {"epss_score": 0.143, "epss_percentile": 0.94183}, "CVE-2009-0722": {"epss_score": 0.02041, "epss_percentile": 0.8337}, "CVE-2009-0723": {"epss_score": 0.00858, "epss_percentile": 0.74499}, "CVE-2009-0726": {"epss_score": 0.00127, "epss_percentile": 0.32871}, "CVE-2009-0727": {"epss_score": 0.00304, "epss_percentile": 0.53239}, "CVE-2009-0728": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2009-0729": {"epss_score": 0.00288, "epss_percentile": 0.51922}, "CVE-2009-0730": {"epss_score": 0.00406, "epss_percentile": 0.60544}, "CVE-2009-0731": {"epss_score": 0.03748, "epss_percentile": 0.87668}, "CVE-2009-0732": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2009-0733": {"epss_score": 0.01603, "epss_percentile": 0.81279}, "CVE-2009-0734": {"epss_score": 0.04462, "epss_percentile": 0.88725}, "CVE-2009-0735": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-0736": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2009-0737": {"epss_score": 0.00506, "epss_percentile": 0.65619}, "CVE-2009-0738": {"epss_score": 0.00152, "epss_percentile": 0.3643}, "CVE-2009-0739": {"epss_score": 0.00114, "epss_percentile": 0.30735}, "CVE-2009-0740": {"epss_score": 0.00114, "epss_percentile": 0.30735}, "CVE-2009-0741": {"epss_score": 0.00323, "epss_percentile": 0.54906}, "CVE-2009-0742": {"epss_score": 0.00251, "epss_percentile": 0.48274}, "CVE-2009-0743": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2009-0744": {"epss_score": 0.05374, "epss_percentile": 0.89797}, "CVE-2009-0745": {"epss_score": 0.00096, "epss_percentile": 0.27336}, "CVE-2009-0746": {"epss_score": 0.00248, "epss_percentile": 0.47955}, "CVE-2009-0747": {"epss_score": 0.00096, "epss_percentile": 0.27336}, "CVE-2009-0748": {"epss_score": 0.00096, "epss_percentile": 0.27336}, "CVE-2009-0749": {"epss_score": 0.00408, "epss_percentile": 0.6064}, "CVE-2009-0750": {"epss_score": 0.00403, "epss_percentile": 0.60319}, "CVE-2009-0751": {"epss_score": 0.22404, "epss_percentile": 0.95632}, "CVE-2009-0752": {"epss_score": 0.00391, "epss_percentile": 0.59564}, "CVE-2009-0753": {"epss_score": 0.10202, "epss_percentile": 0.9289}, "CVE-2009-0754": {"epss_score": 0.00158, "epss_percentile": 0.3718}, "CVE-2009-0755": {"epss_score": 0.23185, "epss_percentile": 0.95747}, "CVE-2009-0756": {"epss_score": 0.13982, "epss_percentile": 0.94107}, "CVE-2009-0757": {"epss_score": 0.0084, "epss_percentile": 0.74204}, "CVE-2009-0758": {"epss_score": 0.01122, "epss_percentile": 0.77783}, "CVE-2009-0759": {"epss_score": 0.0074, "epss_percentile": 0.72407}, "CVE-2009-0760": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2009-0761": {"epss_score": 0.00438, "epss_percentile": 0.6256}, "CVE-2009-0762": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-0763": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-0764": {"epss_score": 0.00164, "epss_percentile": 0.37975}, "CVE-2009-0765": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-0766": {"epss_score": 0.01001, "epss_percentile": 0.76503}, "CVE-2009-0767": {"epss_score": 0.04615, "epss_percentile": 0.88923}, "CVE-2009-0768": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2009-0769": {"epss_score": 0.05281, "epss_percentile": 0.89689}, "CVE-2009-0770": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2009-0771": {"epss_score": 0.07679, "epss_percentile": 0.91621}, "CVE-2009-0772": {"epss_score": 0.07324, "epss_percentile": 0.9141}, "CVE-2009-0773": {"epss_score": 0.09167, "epss_percentile": 0.92429}, "CVE-2009-0774": {"epss_score": 0.0746, "epss_percentile": 0.91484}, "CVE-2009-0775": {"epss_score": 0.06585, "epss_percentile": 0.90866}, "CVE-2009-0776": {"epss_score": 0.00865, "epss_percentile": 0.74627}, "CVE-2009-0777": {"epss_score": 0.02024, "epss_percentile": 0.83311}, "CVE-2009-0778": {"epss_score": 0.01482, "epss_percentile": 0.80575}, "CVE-2009-0779": {"epss_score": 0.00063, "epss_percentile": 0.19872}, "CVE-2009-0780": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2009-0781": {"epss_score": 0.37304, "epss_percentile": 0.97033}, "CVE-2009-0783": {"epss_score": 0.00098, "epss_percentile": 0.27801}, "CVE-2009-0784": {"epss_score": 0.00039, "epss_percentile": 0.11471}, "CVE-2009-0787": {"epss_score": 0.00076, "epss_percentile": 0.23146}, "CVE-2009-0788": {"epss_score": 0.00568, "epss_percentile": 0.679}, "CVE-2009-0789": {"epss_score": 0.02727, "epss_percentile": 0.85531}, "CVE-2009-0790": {"epss_score": 0.10861, "epss_percentile": 0.93137}, "CVE-2009-0791": {"epss_score": 0.06112, "epss_percentile": 0.90489}, "CVE-2009-0792": {"epss_score": 0.01173, "epss_percentile": 0.7824}, "CVE-2009-0793": {"epss_score": 0.10609, "epss_percentile": 0.93045}, "CVE-2009-0794": {"epss_score": 0.0188, "epss_percentile": 0.82689}, "CVE-2009-0796": {"epss_score": 0.32732, "epss_percentile": 0.9672}, "CVE-2009-0798": {"epss_score": 0.08804, "epss_percentile": 0.92262}, "CVE-2009-0799": {"epss_score": 0.00968, "epss_percentile": 0.76089}, "CVE-2009-0800": {"epss_score": 0.08985, "epss_percentile": 0.92351}, "CVE-2009-0801": {"epss_score": 0.00036, "epss_percentile": 0.10394}, "CVE-2009-0802": {"epss_score": 0.00247, "epss_percentile": 0.47816}, "CVE-2009-0803": {"epss_score": 0.01218, "epss_percentile": 0.78602}, "CVE-2009-0804": {"epss_score": 0.0034, "epss_percentile": 0.56266}, "CVE-2009-0805": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2009-0806": {"epss_score": 0.00335, "epss_percentile": 0.55806}, "CVE-2009-0807": {"epss_score": 0.02744, "epss_percentile": 0.85566}, "CVE-2009-0808": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-0809": {"epss_score": 0.00186, "epss_percentile": 0.40609}, "CVE-2009-0810": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-0811": {"epss_score": 0.02093, "epss_percentile": 0.83575}, "CVE-2009-0812": {"epss_score": 0.34628, "epss_percentile": 0.96862}, "CVE-2009-0813": {"epss_score": 0.04149, "epss_percentile": 0.88318}, "CVE-2009-0814": {"epss_score": 0.01625, "epss_percentile": 0.81417}, "CVE-2009-0815": {"epss_score": 0.498, "epss_percentile": 0.97707}, "CVE-2009-0816": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-0817": {"epss_score": 0.00271, "epss_percentile": 0.50293}, "CVE-2009-0818": {"epss_score": 0.0022, "epss_percentile": 0.44538}, "CVE-2009-0819": {"epss_score": 0.03751, "epss_percentile": 0.87673}, "CVE-2009-0820": {"epss_score": 0.06415, "epss_percentile": 0.90744}, "CVE-2009-0821": {"epss_score": 0.02598, "epss_percentile": 0.85202}, "CVE-2009-0824": {"epss_score": 0.00119, "epss_percentile": 0.31566}, "CVE-2009-0825": {"epss_score": 0.0037, "epss_percentile": 0.58323}, "CVE-2009-0826": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2009-0827": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2009-0828": {"epss_score": 0.06269, "epss_percentile": 0.90628}, "CVE-2009-0829": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2009-0830": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-0831": {"epss_score": 0.00412, "epss_percentile": 0.60933}, "CVE-2009-0832": {"epss_score": 0.0046, "epss_percentile": 0.63525}, "CVE-2009-0833": {"epss_score": 0.23155, "epss_percentile": 0.95744}, "CVE-2009-0834": {"epss_score": 0.0005, "epss_percentile": 0.15937}, "CVE-2009-0835": {"epss_score": 0.00072, "epss_percentile": 0.22401}, "CVE-2009-0836": {"epss_score": 0.1077, "epss_percentile": 0.93098}, "CVE-2009-0837": {"epss_score": 0.82996, "epss_percentile": 0.99225}, "CVE-2009-0838": {"epss_score": 0.0006, "epss_percentile": 0.19017}, "CVE-2009-0839": {"epss_score": 0.08317, "epss_percentile": 0.91989}, "CVE-2009-0840": {"epss_score": 0.02704, "epss_percentile": 0.85463}, "CVE-2009-0841": {"epss_score": 0.00786, "epss_percentile": 0.73268}, "CVE-2009-0842": {"epss_score": 0.00832, "epss_percentile": 0.74072}, "CVE-2009-0843": {"epss_score": 0.01032, "epss_percentile": 0.76865}, "CVE-2009-0844": {"epss_score": 0.0459, "epss_percentile": 0.88892}, "CVE-2009-0845": {"epss_score": 0.23242, "epss_percentile": 0.95756}, "CVE-2009-0846": {"epss_score": 0.56355, "epss_percentile": 0.98019}, "CVE-2009-0847": {"epss_score": 0.20287, "epss_percentile": 0.95314}, "CVE-2009-0848": {"epss_score": 0.00189, "epss_percentile": 0.41003}, "CVE-2009-0849": {"epss_score": 0.1453, "epss_percentile": 0.94232}, "CVE-2009-0850": {"epss_score": 0.00457, "epss_percentile": 0.63395}, "CVE-2009-0851": {"epss_score": 0.0046, "epss_percentile": 0.63525}, "CVE-2009-0852": {"epss_score": 0.05013, "epss_percentile": 0.89393}, "CVE-2009-0853": {"epss_score": 0.02602, "epss_percentile": 0.85211}, "CVE-2009-0854": {"epss_score": 0.00141, "epss_percentile": 0.34937}, "CVE-2009-0855": {"epss_score": 0.19597, "epss_percentile": 0.95213}, "CVE-2009-0856": {"epss_score": 0.00463, "epss_percentile": 0.63697}, "CVE-2009-0857": {"epss_score": 0.00338, "epss_percentile": 0.56153}, "CVE-2009-0858": {"epss_score": 0.12823, "epss_percentile": 0.93786}, "CVE-2009-0859": {"epss_score": 0.00112, "epss_percentile": 0.30579}, "CVE-2009-0860": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2009-0861": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2009-0862": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2009-0863": {"epss_score": 0.0046, "epss_percentile": 0.63525}, "CVE-2009-0864": {"epss_score": 0.00838, "epss_percentile": 0.74168}, "CVE-2009-0865": {"epss_score": 0.01328, "epss_percentile": 0.79497}, "CVE-2009-0866": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2009-0867": {"epss_score": 0.00346, "epss_percentile": 0.56638}, "CVE-2009-0868": {"epss_score": 0.00614, "epss_percentile": 0.69277}, "CVE-2009-0869": {"epss_score": 0.17635, "epss_percentile": 0.94882}, "CVE-2009-0870": {"epss_score": 0.00058, "epss_percentile": 0.18594}, "CVE-2009-0871": {"epss_score": 0.02947, "epss_percentile": 0.86042}, "CVE-2009-0872": {"epss_score": 0.0079, "epss_percentile": 0.73368}, "CVE-2009-0873": {"epss_score": 0.01052, "epss_percentile": 0.77094}, "CVE-2009-0874": {"epss_score": 0.00033, "epss_percentile": 0.09171}, "CVE-2009-0875": {"epss_score": 0.00023, "epss_percentile": 0.05462}, "CVE-2009-0876": {"epss_score": 0.00297, "epss_percentile": 0.52756}, "CVE-2009-0877": {"epss_score": 0.00254, "epss_percentile": 0.48528}, "CVE-2009-0878": {"epss_score": 0.01258, "epss_percentile": 0.7896}, "CVE-2009-0879": {"epss_score": 0.18926, "epss_percentile": 0.95098}, "CVE-2009-0880": {"epss_score": 0.63552, "epss_percentile": 0.98337}, "CVE-2009-0881": {"epss_score": 0.00135, "epss_percentile": 0.34027}, "CVE-2009-0882": {"epss_score": 0.00141, "epss_percentile": 0.34848}, "CVE-2009-0883": {"epss_score": 0.00155, "epss_percentile": 0.36773}, "CVE-2009-0884": {"epss_score": 0.00332, "epss_percentile": 0.55559}, "CVE-2009-0885": {"epss_score": 0.39256, "epss_percentile": 0.97149}, "CVE-2009-0886": {"epss_score": 0.02021, "epss_percentile": 0.83295}, "CVE-2009-0887": {"epss_score": 0.00212, "epss_percentile": 0.43823}, "CVE-2009-0888": {"epss_score": 0.13173, "epss_percentile": 0.93892}, "CVE-2009-0889": {"epss_score": 0.13173, "epss_percentile": 0.93892}, "CVE-2009-0891": {"epss_score": 0.00421, "epss_percentile": 0.61525}, "CVE-2009-0892": {"epss_score": 0.00377, "epss_percentile": 0.5869}, "CVE-2009-0893": {"epss_score": 0.07102, "epss_percentile": 0.91253}, "CVE-2009-0894": {"epss_score": 0.04313, "epss_percentile": 0.88534}, "CVE-2009-0895": {"epss_score": 0.26227, "epss_percentile": 0.96125}, "CVE-2009-0896": {"epss_score": 0.22775, "epss_percentile": 0.95685}, "CVE-2009-0897": {"epss_score": 0.00165, "epss_percentile": 0.38026}, "CVE-2009-0898": {"epss_score": 0.0724, "epss_percentile": 0.91345}, "CVE-2009-0899": {"epss_score": 0.00341, "epss_percentile": 0.56307}, "CVE-2009-0900": {"epss_score": 0.00048, "epss_percentile": 0.14973}, "CVE-2009-0901": {"epss_score": 0.6425, "epss_percentile": 0.98371}, "CVE-2009-0903": {"epss_score": 0.00402, "epss_percentile": 0.60302}, "CVE-2009-0904": {"epss_score": 0.00249, "epss_percentile": 0.48016}, "CVE-2009-0905": {"epss_score": 0.00049, "epss_percentile": 0.15468}, "CVE-2009-0906": {"epss_score": 0.00336, "epss_percentile": 0.55946}, "CVE-2009-0908": {"epss_score": 0.00435, "epss_percentile": 0.62332}, "CVE-2009-0909": {"epss_score": 0.03944, "epss_percentile": 0.87993}, "CVE-2009-0910": {"epss_score": 0.04399, "epss_percentile": 0.88645}, "CVE-2009-0912": {"epss_score": 0.00051, "epss_percentile": 0.1605}, "CVE-2009-0913": {"epss_score": 0.00053, "epss_percentile": 0.16823}, "CVE-2009-0914": {"epss_score": 0.10244, "epss_percentile": 0.92909}, "CVE-2009-0915": {"epss_score": 0.01257, "epss_percentile": 0.7895}, "CVE-2009-0916": {"epss_score": 0.01638, "epss_percentile": 0.81485}, "CVE-2009-0917": {"epss_score": 0.02249, "epss_percentile": 0.84156}, "CVE-2009-0918": {"epss_score": 0.01952, "epss_percentile": 0.83023}, "CVE-2009-0919": {"epss_score": 0.01687, "epss_percentile": 0.8176}, "CVE-2009-0920": {"epss_score": 0.58773, "epss_percentile": 0.98136}, "CVE-2009-0921": {"epss_score": 0.35964, "epss_percentile": 0.96944}, "CVE-2009-0922": {"epss_score": 0.08643, "epss_percentile": 0.92169}, "CVE-2009-0923": {"epss_score": 0.023, "epss_percentile": 0.8431}, "CVE-2009-0924": {"epss_score": 0.00051, "epss_percentile": 0.16305}, "CVE-2009-0925": {"epss_score": 0.00051, "epss_percentile": 0.16305}, "CVE-2009-0926": {"epss_score": 0.00045, "epss_percentile": 0.1406}, "CVE-2009-0927": {"epss_score": 0.93673, "epss_percentile": 0.99832}, "CVE-2009-0928": {"epss_score": 0.11407, "epss_percentile": 0.93338}, "CVE-2009-0929": {"epss_score": 0.00285, "epss_percentile": 0.51643}, "CVE-2009-0930": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2009-0931": {"epss_score": 0.00467, "epss_percentile": 0.63861}, "CVE-2009-0932": {"epss_score": 0.05612, "epss_percentile": 0.90047}, "CVE-2009-0933": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-0934": {"epss_score": 0.00721, "epss_percentile": 0.71976}, "CVE-2009-0935": {"epss_score": 0.00067, "epss_percentile": 0.21044}, "CVE-2009-0936": {"epss_score": 0.00516, "epss_percentile": 0.66045}, "CVE-2009-0937": {"epss_score": 0.00516, "epss_percentile": 0.66045}, "CVE-2009-0938": {"epss_score": 0.00718, "epss_percentile": 0.71932}, "CVE-2009-0939": {"epss_score": 0.0067, "epss_percentile": 0.70778}, "CVE-2009-0940": {"epss_score": 0.00837, "epss_percentile": 0.74151}, "CVE-2009-0941": {"epss_score": 0.00928, "epss_percentile": 0.75579}, "CVE-2009-0942": {"epss_score": 0.02541, "epss_percentile": 0.8505}, "CVE-2009-0943": {"epss_score": 0.02541, "epss_percentile": 0.8505}, "CVE-2009-0944": {"epss_score": 0.01711, "epss_percentile": 0.81881}, "CVE-2009-0945": {"epss_score": 0.09118, "epss_percentile": 0.92408}, "CVE-2009-0946": {"epss_score": 0.16376, "epss_percentile": 0.94639}, "CVE-2009-0947": {"epss_score": 0.00392, "epss_percentile": 0.59687}, "CVE-2009-0948": {"epss_score": 0.00416, "epss_percentile": 0.61173}, "CVE-2009-0949": {"epss_score": 0.20572, "epss_percentile": 0.95378}, "CVE-2009-0950": {"epss_score": 0.82109, "epss_percentile": 0.99175}, "CVE-2009-0951": {"epss_score": 0.21519, "epss_percentile": 0.95528}, "CVE-2009-0952": {"epss_score": 0.07, "epss_percentile": 0.91173}, "CVE-2009-0953": {"epss_score": 0.21519, "epss_percentile": 0.95528}, "CVE-2009-0954": {"epss_score": 0.27783, "epss_percentile": 0.96282}, "CVE-2009-0955": {"epss_score": 0.23451, "epss_percentile": 0.95778}, "CVE-2009-0956": {"epss_score": 0.09866, "epss_percentile": 0.92744}, "CVE-2009-0957": {"epss_score": 0.27783, "epss_percentile": 0.96282}, "CVE-2009-0958": {"epss_score": 0.00254, "epss_percentile": 0.48574}, "CVE-2009-0959": {"epss_score": 0.01799, "epss_percentile": 0.82316}, "CVE-2009-0960": {"epss_score": 0.0065, "epss_percentile": 0.70247}, "CVE-2009-0961": {"epss_score": 0.04228, "epss_percentile": 0.88419}, "CVE-2009-0962": {"epss_score": 0.01099, "epss_percentile": 0.77556}, "CVE-2009-0963": {"epss_score": 0.01371, "epss_percentile": 0.79803}, "CVE-2009-0964": {"epss_score": 0.00865, "epss_percentile": 0.74625}, "CVE-2009-0965": {"epss_score": 0.00304, "epss_percentile": 0.53239}, "CVE-2009-0966": {"epss_score": 0.02281, "epss_percentile": 0.84249}, "CVE-2009-0967": {"epss_score": 0.04434, "epss_percentile": 0.88683}, "CVE-2009-0968": {"epss_score": 0.0168, "epss_percentile": 0.81725}, "CVE-2009-0969": {"epss_score": 0.00174, "epss_percentile": 0.39173}, "CVE-2009-0970": {"epss_score": 0.00519, "epss_percentile": 0.66175}, "CVE-2009-0971": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2009-0972": {"epss_score": 0.00756, "epss_percentile": 0.72741}, "CVE-2009-0973": {"epss_score": 0.01052, "epss_percentile": 0.7709}, "CVE-2009-0974": {"epss_score": 0.03811, "epss_percentile": 0.8776}, "CVE-2009-0975": {"epss_score": 0.02225, "epss_percentile": 0.84068}, "CVE-2009-0976": {"epss_score": 0.00864, "epss_percentile": 0.74598}, "CVE-2009-0977": {"epss_score": 0.00719, "epss_percentile": 0.71941}, "CVE-2009-0978": {"epss_score": 0.53918, "epss_percentile": 0.97902}, "CVE-2009-0979": {"epss_score": 0.01083, "epss_percentile": 0.7739}, "CVE-2009-0980": {"epss_score": 0.01074, "epss_percentile": 0.77302}, "CVE-2009-0981": {"epss_score": 0.32845, "epss_percentile": 0.96731}, "CVE-2009-0982": {"epss_score": 0.00846, "epss_percentile": 0.74332}, "CVE-2009-0983": {"epss_score": 0.03811, "epss_percentile": 0.8776}, "CVE-2009-0984": {"epss_score": 0.01044, "epss_percentile": 0.7701}, "CVE-2009-0985": {"epss_score": 0.0131, "epss_percentile": 0.79359}, "CVE-2009-0986": {"epss_score": 0.01265, "epss_percentile": 0.79001}, "CVE-2009-0987": {"epss_score": 0.00576, "epss_percentile": 0.68136}, "CVE-2009-0988": {"epss_score": 0.00846, "epss_percentile": 0.74332}, "CVE-2009-0989": {"epss_score": 0.02589, "epss_percentile": 0.85176}, "CVE-2009-0990": {"epss_score": 0.02589, "epss_percentile": 0.85176}, "CVE-2009-0991": {"epss_score": 0.50498, "epss_percentile": 0.97739}, "CVE-2009-0992": {"epss_score": 0.00647, "epss_percentile": 0.70184}, "CVE-2009-0993": {"epss_score": 0.1129, "epss_percentile": 0.93294}, "CVE-2009-0994": {"epss_score": 0.02589, "epss_percentile": 0.85176}, "CVE-2009-0995": {"epss_score": 0.00904, "epss_percentile": 0.75219}, "CVE-2009-0996": {"epss_score": 0.03352, "epss_percentile": 0.86965}, "CVE-2009-0997": {"epss_score": 0.01282, "epss_percentile": 0.79151}, "CVE-2009-0998": {"epss_score": 0.00562, "epss_percentile": 0.67696}, "CVE-2009-0999": {"epss_score": 0.01297, "epss_percentile": 0.79261}, "CVE-2009-10001": {"epss_score": 0.00095, "epss_percentile": 0.2715}, "CVE-2009-10002": {"epss_score": 0.00075, "epss_percentile": 0.2293}, "CVE-2009-10003": {"epss_score": 0.00098, "epss_percentile": 0.27688}, "CVE-2009-10004": {"epss_score": 0.00103, "epss_percentile": 0.29077}, "CVE-2009-10005": {"epss_score": 0.49405, "epss_percentile": 0.97684}, "CVE-2009-10006": {"epss_score": 0.62029, "epss_percentile": 0.98273}, "CVE-2009-1000": {"epss_score": 0.00617, "epss_percentile": 0.6935}, "CVE-2009-1001": {"epss_score": 0.00846, "epss_percentile": 0.74332}, "CVE-2009-1002": {"epss_score": 0.00904, "epss_percentile": 0.75219}, "CVE-2009-1003": {"epss_score": 0.00904, "epss_percentile": 0.75219}, "CVE-2009-1004": {"epss_score": 0.0089, "epss_percentile": 0.75028}, "CVE-2009-1005": {"epss_score": 0.00108, "epss_percentile": 0.29779}, "CVE-2009-1006": {"epss_score": 0.0255, "epss_percentile": 0.85074}, "CVE-2009-1007": {"epss_score": 0.007, "epss_percentile": 0.71469}, "CVE-2009-1008": {"epss_score": 0.00096, "epss_percentile": 0.27295}, "CVE-2009-1009": {"epss_score": 0.00096, "epss_percentile": 0.27295}, "CVE-2009-1010": {"epss_score": 0.00096, "epss_percentile": 0.27295}, "CVE-2009-1011": {"epss_score": 0.00179, "epss_percentile": 0.39817}, "CVE-2009-1012": {"epss_score": 0.07409, "epss_percentile": 0.91457}, "CVE-2009-1013": {"epss_score": 0.04376, "epss_percentile": 0.88617}, "CVE-2009-1014": {"epss_score": 0.03299, "epss_percentile": 0.86863}, "CVE-2009-1015": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2009-1016": {"epss_score": 0.04275, "epss_percentile": 0.88482}, "CVE-2009-1017": {"epss_score": 0.03352, "epss_percentile": 0.86965}, "CVE-2009-1018": {"epss_score": 0.00977, "epss_percentile": 0.76219}, "CVE-2009-1019": {"epss_score": 0.11053, "epss_percentile": 0.93202}, "CVE-2009-1020": {"epss_score": 0.03673, "epss_percentile": 0.87548}, "CVE-2009-1021": {"epss_score": 0.00411, "epss_percentile": 0.6088}, "CVE-2009-1022": {"epss_score": 0.33654, "epss_percentile": 0.96793}, "CVE-2009-1023": {"epss_score": 0.00484, "epss_percentile": 0.64653}, "CVE-2009-1024": {"epss_score": 0.01029, "epss_percentile": 0.76834}, "CVE-2009-1025": {"epss_score": 0.75756, "epss_percentile": 0.98863}, "CVE-2009-1026": {"epss_score": 0.00367, "epss_percentile": 0.58121}, "CVE-2009-1027": {"epss_score": 0.0041, "epss_percentile": 0.60845}, "CVE-2009-1028": {"epss_score": 0.67087, "epss_percentile": 0.98494}, "CVE-2009-1029": {"epss_score": 0.71963, "epss_percentile": 0.98689}, "CVE-2009-1030": {"epss_score": 0.01781, "epss_percentile": 0.82242}, "CVE-2009-1031": {"epss_score": 0.15737, "epss_percentile": 0.94496}, "CVE-2009-1032": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2009-1033": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2009-1034": {"epss_score": 0.0046, "epss_percentile": 0.6352}, "CVE-2009-1035": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2009-1036": {"epss_score": 0.00329, "epss_percentile": 0.55404}, "CVE-2009-1037": {"epss_score": 0.00377, "epss_percentile": 0.58763}, "CVE-2009-1038": {"epss_score": 0.00303, "epss_percentile": 0.53182}, "CVE-2009-1039": {"epss_score": 0.22167, "epss_percentile": 0.95603}, "CVE-2009-1040": {"epss_score": 0.23155, "epss_percentile": 0.95744}, "CVE-2009-1041": {"epss_score": 0.00091, "epss_percentile": 0.26382}, "CVE-2009-1042": {"epss_score": 0.16499, "epss_percentile": 0.9468}, "CVE-2009-1043": {"epss_score": 0.39712, "epss_percentile": 0.97176}, "CVE-2009-1044": {"epss_score": 0.07842, "epss_percentile": 0.91714}, "CVE-2009-1045": {"epss_score": 0.09983, "epss_percentile": 0.92802}, "CVE-2009-1046": {"epss_score": 0.00349, "epss_percentile": 0.56894}, "CVE-2009-1047": {"epss_score": 0.00204, "epss_percentile": 0.42663}, "CVE-2009-1048": {"epss_score": 0.0326, "epss_percentile": 0.8677}, "CVE-2009-1049": {"epss_score": 0.01883, "epss_percentile": 0.82697}, "CVE-2009-1050": {"epss_score": 0.03036, "epss_percentile": 0.86262}, "CVE-2009-1051": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2009-1052": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2009-1053": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2009-1054": {"epss_score": 0.06463, "epss_percentile": 0.90771}, "CVE-2009-1055": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2009-1056": {"epss_score": 0.00503, "epss_percentile": 0.65459}, "CVE-2009-1057": {"epss_score": 0.09695, "epss_percentile": 0.92666}, "CVE-2009-1058": {"epss_score": 0.15665, "epss_percentile": 0.94479}, "CVE-2009-1059": {"epss_score": 0.15074, "epss_percentile": 0.94355}, "CVE-2009-1060": {"epss_score": 0.13958, "epss_percentile": 0.94101}, "CVE-2009-1061": {"epss_score": 0.12274, "epss_percentile": 0.93619}, "CVE-2009-1062": {"epss_score": 0.08609, "epss_percentile": 0.92149}, "CVE-2009-1063": {"epss_score": 0.21909, "epss_percentile": 0.95571}, "CVE-2009-1064": {"epss_score": 0.01357, "epss_percentile": 0.79723}, "CVE-2009-1065": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-1066": {"epss_score": 0.00468, "epss_percentile": 0.63882}, "CVE-2009-1067": {"epss_score": 0.04077, "epss_percentile": 0.88213}, "CVE-2009-1068": {"epss_score": 0.50184, "epss_percentile": 0.97724}, "CVE-2009-1069": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-1070": {"epss_score": 0.01965, "epss_percentile": 0.83079}, "CVE-2009-1071": {"epss_score": 0.43601, "epss_percentile": 0.97393}, "CVE-2009-1072": {"epss_score": 0.00591, "epss_percentile": 0.68583}, "CVE-2009-1073": {"epss_score": 0.00382, "epss_percentile": 0.59064}, "CVE-2009-1074": {"epss_score": 0.0065, "epss_percentile": 0.70247}, "CVE-2009-1075": {"epss_score": 0.00575, "epss_percentile": 0.68114}, "CVE-2009-1076": {"epss_score": 0.00687, "epss_percentile": 0.71186}, "CVE-2009-1077": {"epss_score": 0.01929, "epss_percentile": 0.82934}, "CVE-2009-1078": {"epss_score": 0.00507, "epss_percentile": 0.65673}, "CVE-2009-1079": {"epss_score": 0.00439, "epss_percentile": 0.62592}, "CVE-2009-1080": {"epss_score": 0.00439, "epss_percentile": 0.62592}, "CVE-2009-1081": {"epss_score": 0.00439, "epss_percentile": 0.62592}, "CVE-2009-1082": {"epss_score": 0.01696, "epss_percentile": 0.81808}, "CVE-2009-1083": {"epss_score": 0.01724, "epss_percentile": 0.81948}, "CVE-2009-1084": {"epss_score": 0.00911, "epss_percentile": 0.75326}, "CVE-2009-1085": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2009-1086": {"epss_score": 0.03405, "epss_percentile": 0.87075}, "CVE-2009-1087": {"epss_score": 0.05336, "epss_percentile": 0.89743}, "CVE-2009-1088": {"epss_score": 0.08019, "epss_percentile": 0.91833}, "CVE-2009-1089": {"epss_score": 0.00193, "epss_percentile": 0.41464}, "CVE-2009-1090": {"epss_score": 0.00288, "epss_percentile": 0.51922}, "CVE-2009-1091": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2009-1092": {"epss_score": 0.05488, "epss_percentile": 0.89927}, "CVE-2009-1093": {"epss_score": 0.09448, "epss_percentile": 0.92552}, "CVE-2009-1094": {"epss_score": 0.06268, "epss_percentile": 0.90626}, "CVE-2009-1095": {"epss_score": 0.15579, "epss_percentile": 0.94463}, "CVE-2009-1096": {"epss_score": 0.12613, "epss_percentile": 0.93729}, "CVE-2009-1097": {"epss_score": 0.0474, "epss_percentile": 0.89078}, "CVE-2009-1098": {"epss_score": 0.14591, "epss_percentile": 0.94247}, "CVE-2009-1099": {"epss_score": 0.05376, "epss_percentile": 0.89799}, "CVE-2009-1100": {"epss_score": 0.07185, "epss_percentile": 0.91306}, "CVE-2009-1101": {"epss_score": 0.07185, "epss_percentile": 0.91306}, "CVE-2009-1102": {"epss_score": 0.05506, "epss_percentile": 0.89943}, "CVE-2009-1103": {"epss_score": 0.05145, "epss_percentile": 0.89541}, "CVE-2009-1104": {"epss_score": 0.01664, "epss_percentile": 0.81641}, "CVE-2009-1105": {"epss_score": 0.08032, "epss_percentile": 0.91843}, "CVE-2009-1106": {"epss_score": 0.01394, "epss_percentile": 0.7997}, "CVE-2009-1107": {"epss_score": 0.03473, "epss_percentile": 0.87205}, "CVE-2009-1119": {"epss_score": 0.11842, "epss_percentile": 0.93493}, "CVE-2009-1120": {"epss_score": 0.06097, "epss_percentile": 0.90479}, "CVE-2009-1122": {"epss_score": 0.92339, "epss_percentile": 0.9971}, "CVE-2009-1123": {"epss_score": 0.04295, "epss_percentile": 0.88508}, "CVE-2009-1124": {"epss_score": 0.00811, "epss_percentile": 0.73729}, "CVE-2009-1125": {"epss_score": 0.00631, "epss_percentile": 0.6973}, "CVE-2009-1126": {"epss_score": 0.00712, "epss_percentile": 0.71757}, "CVE-2009-1127": {"epss_score": 0.01204, "epss_percentile": 0.78502}, "CVE-2009-1128": {"epss_score": 0.52125, "epss_percentile": 0.9781}, "CVE-2009-1129": {"epss_score": 0.67802, "epss_percentile": 0.98521}, "CVE-2009-1130": {"epss_score": 0.72957, "epss_percentile": 0.9873}, "CVE-2009-1131": {"epss_score": 0.68958, "epss_percentile": 0.9857}, "CVE-2009-1132": {"epss_score": 0.45545, "epss_percentile": 0.97491}, "CVE-2009-1133": {"epss_score": 0.7109, "epss_percentile": 0.98653}, "CVE-2009-1134": {"epss_score": 0.51075, "epss_percentile": 0.97763}, "CVE-2009-1135": {"epss_score": 0.39378, "epss_percentile": 0.97158}, "CVE-2009-1136": {"epss_score": 0.85958, "epss_percentile": 0.99358}, "CVE-2009-1137": {"epss_score": 0.66841, "epss_percentile": 0.98484}, "CVE-2009-1138": {"epss_score": 0.58555, "epss_percentile": 0.98123}, "CVE-2009-1139": {"epss_score": 0.61226, "epss_percentile": 0.9824}, "CVE-2009-1140": {"epss_score": 0.5529, "epss_percentile": 0.9797}, "CVE-2009-1141": {"epss_score": 0.61735, "epss_percentile": 0.9826}, "CVE-2009-1142": {"epss_score": 0.00053, "epss_percentile": 0.1698}, "CVE-2009-1143": {"epss_score": 0.00044, "epss_percentile": 0.13508}, "CVE-2009-1144": {"epss_score": 0.0009, "epss_percentile": 0.26171}, "CVE-2009-1146": {"epss_score": 0.00074, "epss_percentile": 0.22817}, "CVE-2009-1147": {"epss_score": 0.00077, "epss_percentile": 0.23467}, "CVE-2009-1148": {"epss_score": 0.00596, "epss_percentile": 0.68721}, "CVE-2009-1149": {"epss_score": 0.00715, "epss_percentile": 0.71842}, "CVE-2009-1150": {"epss_score": 0.00749, "epss_percentile": 0.72612}, "CVE-2009-1151": {"epss_score": 0.92956, "epss_percentile": 0.99764}, "CVE-2009-1152": {"epss_score": 0.01413, "epss_percentile": 0.8012}, "CVE-2009-1154": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2009-1155": {"epss_score": 0.00862, "epss_percentile": 0.74569}, "CVE-2009-1156": {"epss_score": 0.00394, "epss_percentile": 0.59772}, "CVE-2009-1157": {"epss_score": 0.06483, "epss_percentile": 0.90789}, "CVE-2009-1158": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2009-1159": {"epss_score": 0.01482, "epss_percentile": 0.80579}, "CVE-2009-1160": {"epss_score": 0.00262, "epss_percentile": 0.49384}, "CVE-2009-1161": {"epss_score": 0.01439, "epss_percentile": 0.80294}, "CVE-2009-1162": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2009-1163": {"epss_score": 0.00573, "epss_percentile": 0.68053}, "CVE-2009-1164": {"epss_score": 0.00639, "epss_percentile": 0.69941}, "CVE-2009-1165": {"epss_score": 0.00573, "epss_percentile": 0.68053}, "CVE-2009-1166": {"epss_score": 0.00493, "epss_percentile": 0.65055}, "CVE-2009-1167": {"epss_score": 0.00504, "epss_percentile": 0.65529}, "CVE-2009-1168": {"epss_score": 0.0139, "epss_percentile": 0.79937}, "CVE-2009-1169": {"epss_score": 0.38954, "epss_percentile": 0.9713}, "CVE-2009-1170": {"epss_score": 0.00049, "epss_percentile": 0.15368}, "CVE-2009-1171": {"epss_score": 0.06307, "epss_percentile": 0.9066}, "CVE-2009-1172": {"epss_score": 0.01535, "epss_percentile": 0.80908}, "CVE-2009-1173": {"epss_score": 0.00052, "epss_percentile": 0.16458}, "CVE-2009-1174": {"epss_score": 0.01151, "epss_percentile": 0.78037}, "CVE-2009-1175": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2009-1176": {"epss_score": 0.02026, "epss_percentile": 0.83318}, "CVE-2009-1177": {"epss_score": 0.01524, "epss_percentile": 0.80853}, "CVE-2009-1178": {"epss_score": 0.00808, "epss_percentile": 0.73692}, "CVE-2009-1179": {"epss_score": 0.15998, "epss_percentile": 0.94551}, "CVE-2009-1180": {"epss_score": 0.04668, "epss_percentile": 0.88983}, "CVE-2009-1181": {"epss_score": 0.02433, "epss_percentile": 0.84731}, "CVE-2009-1182": {"epss_score": 0.07101, "epss_percentile": 0.91252}, "CVE-2009-1183": {"epss_score": 0.01703, "epss_percentile": 0.81841}, "CVE-2009-1184": {"epss_score": 0.00059, "epss_percentile": 0.1883}, "CVE-2009-1185": {"epss_score": 0.89509, "epss_percentile": 0.9953}, "CVE-2009-1186": {"epss_score": 0.00087, "epss_percentile": 0.25464}, "CVE-2009-1187": {"epss_score": 0.39915, "epss_percentile": 0.97187}, "CVE-2009-1188": {"epss_score": 0.19175, "epss_percentile": 0.95144}, "CVE-2009-1189": {"epss_score": 0.01106, "epss_percentile": 0.77618}, "CVE-2009-1190": {"epss_score": 0.01381, "epss_percentile": 0.79868}, "CVE-2009-1191": {"epss_score": 0.11998, "epss_percentile": 0.93541}, "CVE-2009-1192": {"epss_score": 0.0009, "epss_percentile": 0.26129}, "CVE-2009-1194": {"epss_score": 0.0485, "epss_percentile": 0.89212}, "CVE-2009-1195": {"epss_score": 0.00189, "epss_percentile": 0.40961}, "CVE-2009-1196": {"epss_score": 0.01184, "epss_percentile": 0.7833}, "CVE-2009-1197": {"epss_score": 0.00403, "epss_percentile": 0.60388}, "CVE-2009-1198": {"epss_score": 0.00774, "epss_percentile": 0.73074}, "CVE-2009-1201": {"epss_score": 0.04855, "epss_percentile": 0.89217}, "CVE-2009-1202": {"epss_score": 0.00316, "epss_percentile": 0.54233}, "CVE-2009-1203": {"epss_score": 0.05747, "epss_percentile": 0.90175}, "CVE-2009-1204": {"epss_score": 0.04221, "epss_percentile": 0.8841}, "CVE-2009-1206": {"epss_score": 0.01039, "epss_percentile": 0.76952}, "CVE-2009-1207": {"epss_score": 0.00035, "epss_percentile": 0.10059}, "CVE-2009-1208": {"epss_score": 0.00605, "epss_percentile": 0.68995}, "CVE-2009-1209": {"epss_score": 0.29297, "epss_percentile": 0.96431}, "CVE-2009-1210": {"epss_score": 0.34474, "epss_percentile": 0.96849}, "CVE-2009-1211": {"epss_score": 0.00185, "epss_percentile": 0.40505}, "CVE-2009-1212": {"epss_score": 0.02438, "epss_percentile": 0.84747}, "CVE-2009-1213": {"epss_score": 0.00347, "epss_percentile": 0.56793}, "CVE-2009-1214": {"epss_score": 0.00084, "epss_percentile": 0.2486}, "CVE-2009-1215": {"epss_score": 0.00086, "epss_percentile": 0.25298}, "CVE-2009-1216": {"epss_score": 0.42573, "epss_percentile": 0.97342}, "CVE-2009-1217": {"epss_score": 0.50042, "epss_percentile": 0.97715}, "CVE-2009-1218": {"epss_score": 0.02134, "epss_percentile": 0.83722}, "CVE-2009-1219": {"epss_score": 0.11059, "epss_percentile": 0.93205}, "CVE-2009-1220": {"epss_score": 0.19731, "epss_percentile": 0.95232}, "CVE-2009-1222": {"epss_score": 0.03083, "epss_percentile": 0.86376}, "CVE-2009-1223": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2009-1224": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2009-1225": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-1226": {"epss_score": 0.03674, "epss_percentile": 0.8755}, "CVE-2009-1227": {"epss_score": 0.16972, "epss_percentile": 0.94755}, "CVE-2009-1228": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-1229": {"epss_score": 0.00344, "epss_percentile": 0.56478}, "CVE-2009-1230": {"epss_score": 0.02164, "epss_percentile": 0.83839}, "CVE-2009-1231": {"epss_score": 0.00509, "epss_percentile": 0.65719}, "CVE-2009-1232": {"epss_score": 0.16996, "epss_percentile": 0.94758}, "CVE-2009-1233": {"epss_score": 0.02866, "epss_percentile": 0.85862}, "CVE-2009-1234": {"epss_score": 0.16566, "epss_percentile": 0.94693}, "CVE-2009-1235": {"epss_score": 0.00204, "epss_percentile": 0.42613}, "CVE-2009-1236": {"epss_score": 0.05055, "epss_percentile": 0.89446}, "CVE-2009-1237": {"epss_score": 0.00237, "epss_percentile": 0.46723}, "CVE-2009-1238": {"epss_score": 0.00147, "epss_percentile": 0.35667}, "CVE-2009-1239": {"epss_score": 0.00301, "epss_percentile": 0.53011}, "CVE-2009-1240": {"epss_score": 0.00919, "epss_percentile": 0.75452}, "CVE-2009-1241": {"epss_score": 0.01651, "epss_percentile": 0.81568}, "CVE-2009-1242": {"epss_score": 0.00068, "epss_percentile": 0.21304}, "CVE-2009-1243": {"epss_score": 0.00073, "epss_percentile": 0.22526}, "CVE-2009-1244": {"epss_score": 0.00588, "epss_percentile": 0.68495}, "CVE-2009-1245": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2009-1246": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2009-1247": {"epss_score": 0.31813, "epss_percentile": 0.96651}, "CVE-2009-1248": {"epss_score": 0.02168, "epss_percentile": 0.83862}, "CVE-2009-1249": {"epss_score": 0.00256, "epss_percentile": 0.48789}, "CVE-2009-1250": {"epss_score": 0.05847, "epss_percentile": 0.90259}, "CVE-2009-1251": {"epss_score": 0.12626, "epss_percentile": 0.93733}, "CVE-2009-1252": {"epss_score": 0.511, "epss_percentile": 0.97765}, "CVE-2009-1253": {"epss_score": 0.00035, "epss_percentile": 0.09857}, "CVE-2009-1254": {"epss_score": 0.0075, "epss_percentile": 0.72626}, "CVE-2009-1255": {"epss_score": 0.02078, "epss_percentile": 0.83521}, "CVE-2009-1256": {"epss_score": 0.00326, "epss_percentile": 0.55052}, "CVE-2009-1257": {"epss_score": 0.43393, "epss_percentile": 0.97384}, "CVE-2009-1258": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2009-1259": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1260": {"epss_score": 0.74522, "epss_percentile": 0.98806}, "CVE-2009-1261": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2009-1262": {"epss_score": 0.00076, "epss_percentile": 0.23257}, "CVE-2009-1263": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2009-1264": {"epss_score": 0.00364, "epss_percentile": 0.57906}, "CVE-2009-1265": {"epss_score": 0.02342, "epss_percentile": 0.8444}, "CVE-2009-1266": {"epss_score": 0.00447, "epss_percentile": 0.6294}, "CVE-2009-1267": {"epss_score": 0.01029, "epss_percentile": 0.76832}, "CVE-2009-1268": {"epss_score": 0.01334, "epss_percentile": 0.79541}, "CVE-2009-1269": {"epss_score": 0.01398, "epss_percentile": 0.79987}, "CVE-2009-1270": {"epss_score": 0.04495, "epss_percentile": 0.88761}, "CVE-2009-1271": {"epss_score": 0.10218, "epss_percentile": 0.92899}, "CVE-2009-1272": {"epss_score": 0.02169, "epss_percentile": 0.83865}, "CVE-2009-1273": {"epss_score": 0.00358, "epss_percentile": 0.57509}, "CVE-2009-1274": {"epss_score": 0.04836, "epss_percentile": 0.89194}, "CVE-2009-1275": {"epss_score": 0.01348, "epss_percentile": 0.79662}, "CVE-2009-1276": {"epss_score": 0.00058, "epss_percentile": 0.18405}, "CVE-2009-1277": {"epss_score": 0.00346, "epss_percentile": 0.56644}, "CVE-2009-1278": {"epss_score": 0.02881, "epss_percentile": 0.85899}, "CVE-2009-1279": {"epss_score": 0.00011, "epss_percentile": 0.01053}, "CVE-2009-1280": {"epss_score": 4e-05, "epss_percentile": 0.00125}, "CVE-2009-1281": {"epss_score": 0.00195, "epss_percentile": 0.41654}, "CVE-2009-1282": {"epss_score": 0.01004, "epss_percentile": 0.76531}, "CVE-2009-1283": {"epss_score": 0.01704, "epss_percentile": 0.81846}, "CVE-2009-1284": {"epss_score": 0.15978, "epss_percentile": 0.94546}, "CVE-2009-1285": {"epss_score": 0.01092, "epss_percentile": 0.77463}, "CVE-2009-1286": {"epss_score": 0.01825, "epss_percentile": 0.8243}, "CVE-2009-1287": {"epss_score": 0.0195, "epss_percentile": 0.83013}, "CVE-2009-1288": {"epss_score": 0.0485, "epss_percentile": 0.89213}, "CVE-2009-1289": {"epss_score": 0.00208, "epss_percentile": 0.43262}, "CVE-2009-1290": {"epss_score": 0.00462, "epss_percentile": 0.63622}, "CVE-2009-1291": {"epss_score": 0.3114, "epss_percentile": 0.96596}, "CVE-2009-1292": {"epss_score": 0.00051, "epss_percentile": 0.16113}, "CVE-2009-1293": {"epss_score": 0.00453, "epss_percentile": 0.63234}, "CVE-2009-1294": {"epss_score": 0.0245, "epss_percentile": 0.84778}, "CVE-2009-1295": {"epss_score": 0.00071, "epss_percentile": 0.22031}, "CVE-2009-1296": {"epss_score": 0.00068, "epss_percentile": 0.21414}, "CVE-2009-1297": {"epss_score": 0.00021, "epss_percentile": 0.04872}, "CVE-2009-1298": {"epss_score": 0.02324, "epss_percentile": 0.84381}, "CVE-2009-1299": {"epss_score": 0.0002, "epss_percentile": 0.04598}, "CVE-2009-1300": {"epss_score": 0.01035, "epss_percentile": 0.76904}, "CVE-2009-1301": {"epss_score": 0.08801, "epss_percentile": 0.92259}, "CVE-2009-1302": {"epss_score": 0.04391, "epss_percentile": 0.88635}, "CVE-2009-1303": {"epss_score": 0.02802, "epss_percentile": 0.85701}, "CVE-2009-1304": {"epss_score": 0.06664, "epss_percentile": 0.90926}, "CVE-2009-1305": {"epss_score": 0.04708, "epss_percentile": 0.89036}, "CVE-2009-1306": {"epss_score": 0.01841, "epss_percentile": 0.82497}, "CVE-2009-1307": {"epss_score": 0.01373, "epss_percentile": 0.79821}, "CVE-2009-1308": {"epss_score": 0.01099, "epss_percentile": 0.77558}, "CVE-2009-1309": {"epss_score": 0.01757, "epss_percentile": 0.82133}, "CVE-2009-1310": {"epss_score": 0.0086, "epss_percentile": 0.74543}, "CVE-2009-1311": {"epss_score": 0.01175, "epss_percentile": 0.7826}, "CVE-2009-1312": {"epss_score": 0.06172, "epss_percentile": 0.9053}, "CVE-2009-1313": {"epss_score": 0.3793, "epss_percentile": 0.97076}, "CVE-2009-1314": {"epss_score": 0.05245, "epss_percentile": 0.89658}, "CVE-2009-1315": {"epss_score": 0.04914, "epss_percentile": 0.89283}, "CVE-2009-1316": {"epss_score": 0.00304, "epss_percentile": 0.53239}, "CVE-2009-1317": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-1318": {"epss_score": 0.02316, "epss_percentile": 0.84356}, "CVE-2009-1319": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-1320": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-1321": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2009-1322": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2009-1323": {"epss_score": 0.00367, "epss_percentile": 0.58121}, "CVE-2009-1324": {"epss_score": 0.09488, "epss_percentile": 0.9257}, "CVE-2009-1325": {"epss_score": 0.28244, "epss_percentile": 0.96337}, "CVE-2009-1326": {"epss_score": 0.28244, "epss_percentile": 0.96337}, "CVE-2009-1327": {"epss_score": 0.28244, "epss_percentile": 0.96337}, "CVE-2009-1328": {"epss_score": 0.28244, "epss_percentile": 0.96337}, "CVE-2009-1329": {"epss_score": 0.28244, "epss_percentile": 0.96337}, "CVE-2009-1330": {"epss_score": 0.06455, "epss_percentile": 0.90766}, "CVE-2009-1331": {"epss_score": 0.29041, "epss_percentile": 0.96413}, "CVE-2009-1332": {"epss_score": 0.00417, "epss_percentile": 0.61235}, "CVE-2009-1333": {"epss_score": 0.00686, "epss_percentile": 0.71158}, "CVE-2009-1334": {"epss_score": 0.05896, "epss_percentile": 0.90303}, "CVE-2009-1335": {"epss_score": 0.40712, "epss_percentile": 0.97234}, "CVE-2009-1336": {"epss_score": 0.00057, "epss_percentile": 0.18096}, "CVE-2009-1337": {"epss_score": 0.00298, "epss_percentile": 0.52817}, "CVE-2009-1338": {"epss_score": 0.00083, "epss_percentile": 0.24704}, "CVE-2009-1339": {"epss_score": 0.00362, "epss_percentile": 0.57794}, "CVE-2009-1341": {"epss_score": 0.06468, "epss_percentile": 0.90776}, "CVE-2009-1342": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2009-1343": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2009-1344": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2009-1345": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1346": {"epss_score": 0.00154, "epss_percentile": 0.36726}, "CVE-2009-1347": {"epss_score": 0.00434, "epss_percentile": 0.62319}, "CVE-2009-1348": {"epss_score": 0.00399, "epss_percentile": 0.60118}, "CVE-2009-1349": {"epss_score": 0.00138, "epss_percentile": 0.34408}, "CVE-2009-1350": {"epss_score": 0.75455, "epss_percentile": 0.98846}, "CVE-2009-1351": {"epss_score": 0.23329, "epss_percentile": 0.95767}, "CVE-2009-1352": {"epss_score": 0.23329, "epss_percentile": 0.95767}, "CVE-2009-1353": {"epss_score": 0.11107, "epss_percentile": 0.93224}, "CVE-2009-1354": {"epss_score": 0.02669, "epss_percentile": 0.85385}, "CVE-2009-1355": {"epss_score": 0.00071, "epss_percentile": 0.22217}, "CVE-2009-1356": {"epss_score": 0.15074, "epss_percentile": 0.94355}, "CVE-2009-1357": {"epss_score": 0.22907, "epss_percentile": 0.95705}, "CVE-2009-1358": {"epss_score": 0.01368, "epss_percentile": 0.79787}, "CVE-2009-1359": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2009-1360": {"epss_score": 0.01773, "epss_percentile": 0.82206}, "CVE-2009-1361": {"epss_score": 0.02839, "epss_percentile": 0.85796}, "CVE-2009-1362": {"epss_score": 0.0015, "epss_percentile": 0.36127}, "CVE-2009-1364": {"epss_score": 0.03145, "epss_percentile": 0.86493}, "CVE-2009-1365": {"epss_score": 0.01956, "epss_percentile": 0.83036}, "CVE-2009-1366": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-1367": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-1368": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-1369": {"epss_score": 0.05008, "epss_percentile": 0.89387}, "CVE-2009-1370": {"epss_score": 0.24118, "epss_percentile": 0.95877}, "CVE-2009-1371": {"epss_score": 0.05343, "epss_percentile": 0.89764}, "CVE-2009-1372": {"epss_score": 0.11885, "epss_percentile": 0.93505}, "CVE-2009-1373": {"epss_score": 0.0836, "epss_percentile": 0.92009}, "CVE-2009-1374": {"epss_score": 0.04458, "epss_percentile": 0.88716}, "CVE-2009-1375": {"epss_score": 0.05278, "epss_percentile": 0.89685}, "CVE-2009-1376": {"epss_score": 0.25885, "epss_percentile": 0.9609}, "CVE-2009-1377": {"epss_score": 0.02884, "epss_percentile": 0.85907}, "CVE-2009-1378": {"epss_score": 0.13245, "epss_percentile": 0.93912}, "CVE-2009-1379": {"epss_score": 0.08556, "epss_percentile": 0.92124}, "CVE-2009-1380": {"epss_score": 0.00604, "epss_percentile": 0.68963}, "CVE-2009-1381": {"epss_score": 0.00592, "epss_percentile": 0.68622}, "CVE-2009-1382": {"epss_score": 0.11169, "epss_percentile": 0.93252}, "CVE-2009-1383": {"epss_score": 0.00987, "epss_percentile": 0.76347}, "CVE-2009-1384": {"epss_score": 0.01775, "epss_percentile": 0.82217}, "CVE-2009-1385": {"epss_score": 0.11974, "epss_percentile": 0.9353}, "CVE-2009-1386": {"epss_score": 0.47628, "epss_percentile": 0.97594}, "CVE-2009-1387": {"epss_score": 0.13464, "epss_percentile": 0.93972}, "CVE-2009-1388": {"epss_score": 0.0013, "epss_percentile": 0.33304}, "CVE-2009-1389": {"epss_score": 0.07833, "epss_percentile": 0.91704}, "CVE-2009-1390": {"epss_score": 0.00435, "epss_percentile": 0.62374}, "CVE-2009-1391": {"epss_score": 0.18375, "epss_percentile": 0.95007}, "CVE-2009-1392": {"epss_score": 0.15734, "epss_percentile": 0.94496}, "CVE-2009-1394": {"epss_score": 0.49012, "epss_percentile": 0.97662}, "CVE-2009-1403": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1404": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-1405": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-1406": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-1407": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2009-1408": {"epss_score": 0.09199, "epss_percentile": 0.92444}, "CVE-2009-1409": {"epss_score": 0.00344, "epss_percentile": 0.56478}, "CVE-2009-1410": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1411": {"epss_score": 0.00372, "epss_percentile": 0.58457}, "CVE-2009-1412": {"epss_score": 0.00288, "epss_percentile": 0.51877}, "CVE-2009-1413": {"epss_score": 0.00264, "epss_percentile": 0.49706}, "CVE-2009-1414": {"epss_score": 0.00119, "epss_percentile": 0.31646}, "CVE-2009-1415": {"epss_score": 0.17762, "epss_percentile": 0.94902}, "CVE-2009-1416": {"epss_score": 0.05344, "epss_percentile": 0.89764}, "CVE-2009-1417": {"epss_score": 0.00576, "epss_percentile": 0.68133}, "CVE-2009-1418": {"epss_score": 0.00594, "epss_percentile": 0.68653}, "CVE-2009-1419": {"epss_score": 0.00935, "epss_percentile": 0.75673}, "CVE-2009-1420": {"epss_score": 0.21452, "epss_percentile": 0.9552}, "CVE-2009-1421": {"epss_score": 0.00063, "epss_percentile": 0.20096}, "CVE-2009-1422": {"epss_score": 0.02291, "epss_percentile": 0.84284}, "CVE-2009-1423": {"epss_score": 0.0131, "epss_percentile": 0.79364}, "CVE-2009-1424": {"epss_score": 0.01225, "epss_percentile": 0.78685}, "CVE-2009-1425": {"epss_score": 0.02331, "epss_percentile": 0.84404}, "CVE-2009-1426": {"epss_score": 0.01225, "epss_percentile": 0.78685}, "CVE-2009-1427": {"epss_score": 0.00087, "epss_percentile": 0.25446}, "CVE-2009-1428": {"epss_score": 0.01241, "epss_percentile": 0.78817}, "CVE-2009-1429": {"epss_score": 0.911, "epss_percentile": 0.9962}, "CVE-2009-1430": {"epss_score": 0.65724, "epss_percentile": 0.98435}, "CVE-2009-1431": {"epss_score": 0.2966, "epss_percentile": 0.96464}, "CVE-2009-1432": {"epss_score": 0.02179, "epss_percentile": 0.83894}, "CVE-2009-1433": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2009-1434": {"epss_score": 0.00192, "epss_percentile": 0.41316}, "CVE-2009-1435": {"epss_score": 0.00364, "epss_percentile": 0.57908}, "CVE-2009-1436": {"epss_score": 0.00276, "epss_percentile": 0.50761}, "CVE-2009-1437": {"epss_score": 0.09894, "epss_percentile": 0.92758}, "CVE-2009-1438": {"epss_score": 0.0255, "epss_percentile": 0.85075}, "CVE-2009-1439": {"epss_score": 0.02344, "epss_percentile": 0.84446}, "CVE-2009-1440": {"epss_score": 0.00973, "epss_percentile": 0.76161}, "CVE-2009-1441": {"epss_score": 0.0071, "epss_percentile": 0.71725}, "CVE-2009-1442": {"epss_score": 0.04768, "epss_percentile": 0.89125}, "CVE-2009-1443": {"epss_score": 0.03071, "epss_percentile": 0.86348}, "CVE-2009-1444": {"epss_score": 0.02281, "epss_percentile": 0.84252}, "CVE-2009-1445": {"epss_score": 0.01679, "epss_percentile": 0.81722}, "CVE-2009-1446": {"epss_score": 0.02588, "epss_percentile": 0.85175}, "CVE-2009-1447": {"epss_score": 0.07341, "epss_percentile": 0.91419}, "CVE-2009-1448": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2009-1449": {"epss_score": 0.23155, "epss_percentile": 0.95744}, "CVE-2009-1450": {"epss_score": 0.01605, "epss_percentile": 0.81294}, "CVE-2009-1451": {"epss_score": 0.00323, "epss_percentile": 0.54867}, "CVE-2009-1452": {"epss_score": 0.02103, "epss_percentile": 0.83614}, "CVE-2009-1453": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-1454": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2009-1455": {"epss_score": 0.00174, "epss_percentile": 0.39171}, "CVE-2009-1456": {"epss_score": 0.00892, "epss_percentile": 0.75057}, "CVE-2009-1457": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-1458": {"epss_score": 0.02271, "epss_percentile": 0.84216}, "CVE-2009-1459": {"epss_score": 0.00269, "epss_percentile": 0.50155}, "CVE-2009-1460": {"epss_score": 0.00052, "epss_percentile": 0.16534}, "CVE-2009-1461": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2009-1462": {"epss_score": 0.00045, "epss_percentile": 0.13917}, "CVE-2009-1463": {"epss_score": 0.00725, "epss_percentile": 0.72056}, "CVE-2009-1464": {"epss_score": 0.00283, "epss_percentile": 0.51408}, "CVE-2009-1465": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2009-1466": {"epss_score": 0.00035, "epss_percentile": 0.09999}, "CVE-2009-1467": {"epss_score": 0.05404, "epss_percentile": 0.89837}, "CVE-2009-1468": {"epss_score": 0.00294, "epss_percentile": 0.52421}, "CVE-2009-1469": {"epss_score": 0.05493, "epss_percentile": 0.89931}, "CVE-2009-1472": {"epss_score": 0.00183, "epss_percentile": 0.40347}, "CVE-2009-1473": {"epss_score": 0.00943, "epss_percentile": 0.75776}, "CVE-2009-1474": {"epss_score": 0.00837, "epss_percentile": 0.74154}, "CVE-2009-1476": {"epss_score": 0.00057, "epss_percentile": 0.18027}, "CVE-2009-1477": {"epss_score": 0.00725, "epss_percentile": 0.72057}, "CVE-2009-1478": {"epss_score": 0.00172, "epss_percentile": 0.39001}, "CVE-2009-1479": {"epss_score": 0.01124, "epss_percentile": 0.77801}, "CVE-2009-1480": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1481": {"epss_score": 0.00553, "epss_percentile": 0.67423}, "CVE-2009-1482": {"epss_score": 0.01708, "epss_percentile": 0.81864}, "CVE-2009-1483": {"epss_score": 0.09149, "epss_percentile": 0.92421}, "CVE-2009-1484": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-1485": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2009-1486": {"epss_score": 0.02041, "epss_percentile": 0.8337}, "CVE-2009-1487": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2009-1488": {"epss_score": 0.02809, "epss_percentile": 0.85714}, "CVE-2009-1489": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2009-1490": {"epss_score": 0.07785, "epss_percentile": 0.91681}, "CVE-2009-1491": {"epss_score": 0.00247, "epss_percentile": 0.47851}, "CVE-2009-1492": {"epss_score": 0.68063, "epss_percentile": 0.9853}, "CVE-2009-1493": {"epss_score": 0.76196, "epss_percentile": 0.98882}, "CVE-2009-1494": {"epss_score": 0.00517, "epss_percentile": 0.66085}, "CVE-2009-1495": {"epss_score": 0.04615, "epss_percentile": 0.88923}, "CVE-2009-1496": {"epss_score": 0.01909, "epss_percentile": 0.82822}, "CVE-2009-1497": {"epss_score": 0.25914, "epss_percentile": 0.96094}, "CVE-2009-1498": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2009-1499": {"epss_score": 6e-05, "epss_percentile": 0.00301}, "CVE-2009-1500": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1501": {"epss_score": 0.00256, "epss_percentile": 0.48789}, "CVE-2009-1502": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-1503": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-1504": {"epss_score": 0.00307, "epss_percentile": 0.53483}, "CVE-2009-1505": {"epss_score": 0.00639, "epss_percentile": 0.69945}, "CVE-2009-1506": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2009-1507": {"epss_score": 0.00237, "epss_percentile": 0.46654}, "CVE-2009-1508": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1509": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-1510": {"epss_score": 0.02041, "epss_percentile": 0.8337}, "CVE-2009-1511": {"epss_score": 0.12871, "epss_percentile": 0.93807}, "CVE-2009-1512": {"epss_score": 0.02164, "epss_percentile": 0.83839}, "CVE-2009-1513": {"epss_score": 0.08341, "epss_percentile": 0.91999}, "CVE-2009-1514": {"epss_score": 0.03389, "epss_percentile": 0.87046}, "CVE-2009-1515": {"epss_score": 0.04179, "epss_percentile": 0.88355}, "CVE-2009-1516": {"epss_score": 0.04073, "epss_percentile": 0.88208}, "CVE-2009-1517": {"epss_score": 0.06719, "epss_percentile": 0.90966}, "CVE-2009-1518": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2009-1519": {"epss_score": 0.02742, "epss_percentile": 0.85563}, "CVE-2009-1520": {"epss_score": 0.011, "epss_percentile": 0.7756}, "CVE-2009-1521": {"epss_score": 0.00415, "epss_percentile": 0.61119}, "CVE-2009-1522": {"epss_score": 0.00677, "epss_percentile": 0.70951}, "CVE-2009-1523": {"epss_score": 0.1218, "epss_percentile": 0.93596}, "CVE-2009-1524": {"epss_score": 0.0044, "epss_percentile": 0.62613}, "CVE-2009-1525": {"epss_score": 0.01006, "epss_percentile": 0.76546}, "CVE-2009-1526": {"epss_score": 0.00082, "epss_percentile": 0.24558}, "CVE-2009-1527": {"epss_score": 0.00061, "epss_percentile": 0.19309}, "CVE-2009-1528": {"epss_score": 0.69513, "epss_percentile": 0.9859}, "CVE-2009-1529": {"epss_score": 0.59857, "epss_percentile": 0.98185}, "CVE-2009-1530": {"epss_score": 0.7097, "epss_percentile": 0.98648}, "CVE-2009-1531": {"epss_score": 0.69685, "epss_percentile": 0.98599}, "CVE-2009-1532": {"epss_score": 0.59432, "epss_percentile": 0.98164}, "CVE-2009-1533": {"epss_score": 0.7289, "epss_percentile": 0.98728}, "CVE-2009-1534": {"epss_score": 0.7543, "epss_percentile": 0.98845}, "CVE-2009-1535": {"epss_score": 0.91826, "epss_percentile": 0.9967}, "CVE-2009-1536": {"epss_score": 0.53089, "epss_percentile": 0.97856}, "CVE-2009-1537": {"epss_score": 0.68076, "epss_percentile": 0.9853}, "CVE-2009-1538": {"epss_score": 0.69181, "epss_percentile": 0.9858}, "CVE-2009-1539": {"epss_score": 0.57816, "epss_percentile": 0.98084}, "CVE-2009-1542": {"epss_score": 0.17999, "epss_percentile": 0.94941}, "CVE-2009-1544": {"epss_score": 0.32167, "epss_percentile": 0.96675}, "CVE-2009-1545": {"epss_score": 0.58024, "epss_percentile": 0.98096}, "CVE-2009-1546": {"epss_score": 0.66294, "epss_percentile": 0.98459}, "CVE-2009-1547": {"epss_score": 0.28373, "epss_percentile": 0.96347}, "CVE-2009-1548": {"epss_score": 0.00293, "epss_percentile": 0.52356}, "CVE-2009-1549": {"epss_score": 0.02782, "epss_percentile": 0.85652}, "CVE-2009-1550": {"epss_score": 0.03673, "epss_percentile": 0.87548}, "CVE-2009-1551": {"epss_score": 0.85244, "epss_percentile": 0.99324}, "CVE-2009-1552": {"epss_score": 0.00463, "epss_percentile": 0.63675}, "CVE-2009-1553": {"epss_score": 0.0103, "epss_percentile": 0.76842}, "CVE-2009-1554": {"epss_score": 0.01556, "epss_percentile": 0.81015}, "CVE-2009-1555": {"epss_score": 0.00346, "epss_percentile": 0.56638}, "CVE-2009-1556": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2009-1557": {"epss_score": 0.13846, "epss_percentile": 0.94075}, "CVE-2009-1558": {"epss_score": 0.09101, "epss_percentile": 0.92401}, "CVE-2009-1559": {"epss_score": 0.00186, "epss_percentile": 0.40608}, "CVE-2009-1560": {"epss_score": 0.00304, "epss_percentile": 0.53265}, "CVE-2009-1561": {"epss_score": 0.05817, "epss_percentile": 0.90232}, "CVE-2009-1564": {"epss_score": 0.17199, "epss_percentile": 0.94797}, "CVE-2009-1565": {"epss_score": 0.16916, "epss_percentile": 0.94747}, "CVE-2009-1566": {"epss_score": 0.05277, "epss_percentile": 0.89683}, "CVE-2009-1567": {"epss_score": 0.0622, "epss_percentile": 0.90578}, "CVE-2009-1568": {"epss_score": 0.61015, "epss_percentile": 0.98231}, "CVE-2009-1569": {"epss_score": 0.65451, "epss_percentile": 0.98419}, "CVE-2009-1570": {"epss_score": 0.0308, "epss_percentile": 0.8637}, "CVE-2009-1571": {"epss_score": 0.05456, "epss_percentile": 0.89897}, "CVE-2009-1572": {"epss_score": 0.11175, "epss_percentile": 0.93254}, "CVE-2009-1573": {"epss_score": 0.00068, "epss_percentile": 0.21367}, "CVE-2009-1574": {"epss_score": 0.06748, "epss_percentile": 0.91}, "CVE-2009-1575": {"epss_score": 0.00736, "epss_percentile": 0.723}, "CVE-2009-1576": {"epss_score": 0.00798, "epss_percentile": 0.73515}, "CVE-2009-1577": {"epss_score": 0.11957, "epss_percentile": 0.93526}, "CVE-2009-1578": {"epss_score": 0.02924, "epss_percentile": 0.86003}, "CVE-2009-1579": {"epss_score": 0.03503, "epss_percentile": 0.87253}, "CVE-2009-1580": {"epss_score": 0.01026, "epss_percentile": 0.76795}, "CVE-2009-1581": {"epss_score": 0.01286, "epss_percentile": 0.7919}, "CVE-2009-1582": {"epss_score": 0.01254, "epss_percentile": 0.78923}, "CVE-2009-1583": {"epss_score": 0.05432, "epss_percentile": 0.89877}, "CVE-2009-1584": {"epss_score": 0.01313, "epss_percentile": 0.7938}, "CVE-2009-1585": {"epss_score": 0.00123, "epss_percentile": 0.32187}, "CVE-2009-1586": {"epss_score": 0.43683, "epss_percentile": 0.97399}, "CVE-2009-1587": {"epss_score": 0.01747, "epss_percentile": 0.82074}, "CVE-2009-1588": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2009-1589": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2009-1590": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-1591": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-1592": {"epss_score": 0.21026, "epss_percentile": 0.95454}, "CVE-2009-1593": {"epss_score": 0.00226, "epss_percentile": 0.45268}, "CVE-2009-1594": {"epss_score": 0.00436, "epss_percentile": 0.62458}, "CVE-2009-1595": {"epss_score": 0.07857, "epss_percentile": 0.91724}, "CVE-2009-1596": {"epss_score": 0.00351, "epss_percentile": 0.57005}, "CVE-2009-1597": {"epss_score": 0.00247, "epss_percentile": 0.47851}, "CVE-2009-1598": {"epss_score": 0.00306, "epss_percentile": 0.53406}, "CVE-2009-1599": {"epss_score": 0.00242, "epss_percentile": 0.47401}, "CVE-2009-1600": {"epss_score": 0.00242, "epss_percentile": 0.47401}, "CVE-2009-1601": {"epss_score": 0.00142, "epss_percentile": 0.34985}, "CVE-2009-1602": {"epss_score": 0.05766, "epss_percentile": 0.90189}, "CVE-2009-1603": {"epss_score": 0.0105, "epss_percentile": 0.77066}, "CVE-2009-1604": {"epss_score": 0.00802, "epss_percentile": 0.73587}, "CVE-2009-1605": {"epss_score": 0.0704, "epss_percentile": 0.91206}, "CVE-2009-1606": {"epss_score": 0.11677, "epss_percentile": 0.93443}, "CVE-2009-1607": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2009-1608": {"epss_score": 0.07912, "epss_percentile": 0.9176}, "CVE-2009-1609": {"epss_score": 0.02517, "epss_percentile": 0.84991}, "CVE-2009-1610": {"epss_score": 0.02881, "epss_percentile": 0.85901}, "CVE-2009-1611": {"epss_score": 0.11247, "epss_percentile": 0.93278}, "CVE-2009-1612": {"epss_score": 0.68936, "epss_percentile": 0.98568}, "CVE-2009-1613": {"epss_score": 0.00434, "epss_percentile": 0.62319}, "CVE-2009-1614": {"epss_score": 0.00513, "epss_percentile": 0.65896}, "CVE-2009-1615": {"epss_score": 0.0491, "epss_percentile": 0.8928}, "CVE-2009-1616": {"epss_score": 0.01297, "epss_percentile": 0.79263}, "CVE-2009-1617": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2009-1618": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2009-1619": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2009-1620": {"epss_score": 0.00204, "epss_percentile": 0.42599}, "CVE-2009-1621": {"epss_score": 0.02355, "epss_percentile": 0.84481}, "CVE-2009-1622": {"epss_score": 0.00307, "epss_percentile": 0.53519}, "CVE-2009-1623": {"epss_score": 0.00438, "epss_percentile": 0.6256}, "CVE-2009-1624": {"epss_score": 0.02742, "epss_percentile": 0.85563}, "CVE-2009-1625": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-1626": {"epss_score": 0.00351, "epss_percentile": 0.57035}, "CVE-2009-1627": {"epss_score": 0.27555, "epss_percentile": 0.96258}, "CVE-2009-1628": {"epss_score": 0.03913, "epss_percentile": 0.87936}, "CVE-2009-1629": {"epss_score": 0.00989, "epss_percentile": 0.76367}, "CVE-2009-1630": {"epss_score": 0.00109, "epss_percentile": 0.30045}, "CVE-2009-1631": {"epss_score": 0.00105, "epss_percentile": 0.29298}, "CVE-2009-1632": {"epss_score": 0.04307, "epss_percentile": 0.88524}, "CVE-2009-1633": {"epss_score": 0.01839, "epss_percentile": 0.82489}, "CVE-2009-1634": {"epss_score": 0.04944, "epss_percentile": 0.89312}, "CVE-2009-1635": {"epss_score": 0.00398, "epss_percentile": 0.6006}, "CVE-2009-1636": {"epss_score": 0.68138, "epss_percentile": 0.98532}, "CVE-2009-1637": {"epss_score": 0.0347, "epss_percentile": 0.87198}, "CVE-2009-1638": {"epss_score": 0.0194, "epss_percentile": 0.82979}, "CVE-2009-1639": {"epss_score": 0.01261, "epss_percentile": 0.78976}, "CVE-2009-1640": {"epss_score": 0.01371, "epss_percentile": 0.79804}, "CVE-2009-1641": {"epss_score": 0.67765, "epss_percentile": 0.98519}, "CVE-2009-1642": {"epss_score": 0.31232, "epss_percentile": 0.96602}, "CVE-2009-1643": {"epss_score": 0.20225, "epss_percentile": 0.95305}, "CVE-2009-1644": {"epss_score": 0.26083, "epss_percentile": 0.96109}, "CVE-2009-1645": {"epss_score": 0.25604, "epss_percentile": 0.96049}, "CVE-2009-1646": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2009-1647": {"epss_score": 0.06223, "epss_percentile": 0.90583}, "CVE-2009-1648": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2009-1649": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-1650": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-1651": {"epss_score": 0.00151, "epss_percentile": 0.36344}, "CVE-2009-1652": {"epss_score": 0.0243, "epss_percentile": 0.84726}, "CVE-2009-1653": {"epss_score": 0.03729, "epss_percentile": 0.87639}, "CVE-2009-1654": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-1655": {"epss_score": 0.00129, "epss_percentile": 0.33118}, "CVE-2009-1656": {"epss_score": 0.07735, "epss_percentile": 0.9165}, "CVE-2009-1657": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2009-1658": {"epss_score": 0.00196, "epss_percentile": 0.41814}, "CVE-2009-1659": {"epss_score": 0.01233, "epss_percentile": 0.78745}, "CVE-2009-1660": {"epss_score": 0.23329, "epss_percentile": 0.95767}, "CVE-2009-1661": {"epss_score": 0.00902, "epss_percentile": 0.75187}, "CVE-2009-1662": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1663": {"epss_score": 0.0491, "epss_percentile": 0.8928}, "CVE-2009-1664": {"epss_score": 0.02532, "epss_percentile": 0.85029}, "CVE-2009-1665": {"epss_score": 0.03211, "epss_percentile": 0.86654}, "CVE-2009-1666": {"epss_score": 0.02769, "epss_percentile": 0.85616}, "CVE-2009-1667": {"epss_score": 0.05556, "epss_percentile": 0.8999}, "CVE-2009-1668": {"epss_score": 0.01948, "epss_percentile": 0.83008}, "CVE-2009-1669": {"epss_score": 0.1948, "epss_percentile": 0.95191}, "CVE-2009-1670": {"epss_score": 0.02538, "epss_percentile": 0.85042}, "CVE-2009-1671": {"epss_score": 0.06024, "epss_percentile": 0.90418}, "CVE-2009-1672": {"epss_score": 0.06538, "epss_percentile": 0.9083}, "CVE-2009-1673": {"epss_score": 0.0006, "epss_percentile": 0.19017}, "CVE-2009-1674": {"epss_score": 0.17098, "epss_percentile": 0.94773}, "CVE-2009-1675": {"epss_score": 0.62646, "epss_percentile": 0.983}, "CVE-2009-1677": {"epss_score": 0.01608, "epss_percentile": 0.81315}, "CVE-2009-1678": {"epss_score": 0.01251, "epss_percentile": 0.78893}, "CVE-2009-1679": {"epss_score": 0.00067, "epss_percentile": 0.21113}, "CVE-2009-1680": {"epss_score": 0.00066, "epss_percentile": 0.20955}, "CVE-2009-1681": {"epss_score": 0.00261, "epss_percentile": 0.4931}, "CVE-2009-1682": {"epss_score": 0.00387, "epss_percentile": 0.59311}, "CVE-2009-1683": {"epss_score": 0.01833, "epss_percentile": 0.82458}, "CVE-2009-1684": {"epss_score": 0.01963, "epss_percentile": 0.83068}, "CVE-2009-1685": {"epss_score": 0.00614, "epss_percentile": 0.69289}, "CVE-2009-1686": {"epss_score": 0.05858, "epss_percentile": 0.90268}, "CVE-2009-1687": {"epss_score": 0.0784, "epss_percentile": 0.9171}, "CVE-2009-1688": {"epss_score": 0.00614, "epss_percentile": 0.69289}, "CVE-2009-1689": {"epss_score": 0.00614, "epss_percentile": 0.69289}, "CVE-2009-1690": {"epss_score": 0.1222, "epss_percentile": 0.93605}, "CVE-2009-1691": {"epss_score": 0.00614, "epss_percentile": 0.69289}, "CVE-2009-1692": {"epss_score": 0.04271, "epss_percentile": 0.88477}, "CVE-2009-1693": {"epss_score": 0.00573, "epss_percentile": 0.68057}, "CVE-2009-1694": {"epss_score": 0.00637, "epss_percentile": 0.69881}, "CVE-2009-1695": {"epss_score": 0.00573, "epss_percentile": 0.68057}, "CVE-2009-1696": {"epss_score": 0.00953, "epss_percentile": 0.75884}, "CVE-2009-1697": {"epss_score": 0.00192, "epss_percentile": 0.41367}, "CVE-2009-1698": {"epss_score": 0.0784, "epss_percentile": 0.9171}, "CVE-2009-1699": {"epss_score": 0.09268, "epss_percentile": 0.92471}, "CVE-2009-1700": {"epss_score": 0.0088, "epss_percentile": 0.7485}, "CVE-2009-1701": {"epss_score": 0.09717, "epss_percentile": 0.92676}, "CVE-2009-1702": {"epss_score": 0.00573, "epss_percentile": 0.68057}, "CVE-2009-1703": {"epss_score": 0.00871, "epss_percentile": 0.74715}, "CVE-2009-1704": {"epss_score": 0.02364, "epss_percentile": 0.8451}, "CVE-2009-1705": {"epss_score": 0.05154, "epss_percentile": 0.89551}, "CVE-2009-1706": {"epss_score": 0.00515, "epss_percentile": 0.65998}, "CVE-2009-1707": {"epss_score": 0.0007, "epss_percentile": 0.21647}, "CVE-2009-1708": {"epss_score": 0.03272, "epss_percentile": 0.86795}, "CVE-2009-1709": {"epss_score": 0.08606, "epss_percentile": 0.92148}, "CVE-2009-1710": {"epss_score": 0.00741, "epss_percentile": 0.72446}, "CVE-2009-1711": {"epss_score": 0.064, "epss_percentile": 0.90726}, "CVE-2009-1712": {"epss_score": 0.04819, "epss_percentile": 0.89173}, "CVE-2009-1713": {"epss_score": 0.00861, "epss_percentile": 0.74561}, "CVE-2009-1714": {"epss_score": 0.00648, "epss_percentile": 0.70222}, "CVE-2009-1715": {"epss_score": 0.02163, "epss_percentile": 0.83834}, "CVE-2009-1716": {"epss_score": 0.00104, "epss_percentile": 0.2913}, "CVE-2009-1717": {"epss_score": 0.02622, "epss_percentile": 0.85257}, "CVE-2009-1718": {"epss_score": 0.00661, "epss_percentile": 0.70589}, "CVE-2009-1719": {"epss_score": 0.03868, "epss_percentile": 0.87875}, "CVE-2009-1720": {"epss_score": 0.19205, "epss_percentile": 0.95148}, "CVE-2009-1721": {"epss_score": 0.25346, "epss_percentile": 0.96017}, "CVE-2009-1722": {"epss_score": 0.10851, "epss_percentile": 0.93134}, "CVE-2009-1723": {"epss_score": 0.00552, "epss_percentile": 0.67404}, "CVE-2009-1724": {"epss_score": 0.01516, "epss_percentile": 0.80798}, "CVE-2009-1725": {"epss_score": 0.12201, "epss_percentile": 0.936}, "CVE-2009-1726": {"epss_score": 0.11304, "epss_percentile": 0.933}, "CVE-2009-1727": {"epss_score": 0.00563, "epss_percentile": 0.67735}, "CVE-2009-1728": {"epss_score": 0.08501, "epss_percentile": 0.92086}, "CVE-2009-1729": {"epss_score": 0.09115, "epss_percentile": 0.92406}, "CVE-2009-1730": {"epss_score": 0.75459, "epss_percentile": 0.98847}, "CVE-2009-1731": {"epss_score": 0.00465, "epss_percentile": 0.63773}, "CVE-2009-1732": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2009-1733": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2009-1734": {"epss_score": 0.00538, "epss_percentile": 0.66949}, "CVE-2009-1735": {"epss_score": 0.04683, "epss_percentile": 0.89002}, "CVE-2009-1736": {"epss_score": 0.00028, "epss_percentile": 0.07582}, "CVE-2009-1737": {"epss_score": 0.00286, "epss_percentile": 0.51768}, "CVE-2009-1738": {"epss_score": 0.00255, "epss_percentile": 0.48736}, "CVE-2009-1739": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2009-1740": {"epss_score": 0.02603, "epss_percentile": 0.85212}, "CVE-2009-1741": {"epss_score": 0.0041, "epss_percentile": 0.60839}, "CVE-2009-1742": {"epss_score": 0.01029, "epss_percentile": 0.76834}, "CVE-2009-1743": {"epss_score": 0.09337, "epss_percentile": 0.92505}, "CVE-2009-1744": {"epss_score": 0.03557, "epss_percentile": 0.87349}, "CVE-2009-1745": {"epss_score": 0.00674, "epss_percentile": 0.70851}, "CVE-2009-1746": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1747": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-1748": {"epss_score": 0.02521, "epss_percentile": 0.85003}, "CVE-2009-1749": {"epss_score": 0.01334, "epss_percentile": 0.7954}, "CVE-2009-1750": {"epss_score": 0.05478, "epss_percentile": 0.89917}, "CVE-2009-1751": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2009-1752": {"epss_score": 0.03628, "epss_percentile": 0.8747}, "CVE-2009-1753": {"epss_score": 0.00035, "epss_percentile": 0.09846}, "CVE-2009-1754": {"epss_score": 0.0019, "epss_percentile": 0.41102}, "CVE-2009-1755": {"epss_score": 0.01792, "epss_percentile": 0.82285}, "CVE-2009-1756": {"epss_score": 0.00067, "epss_percentile": 0.21099}, "CVE-2009-1757": {"epss_score": 0.00116, "epss_percentile": 0.31043}, "CVE-2009-1758": {"epss_score": 0.00666, "epss_percentile": 0.70691}, "CVE-2009-1759": {"epss_score": 0.46828, "epss_percentile": 0.97559}, "CVE-2009-1760": {"epss_score": 0.00843, "epss_percentile": 0.74262}, "CVE-2009-1761": {"epss_score": 0.02184, "epss_percentile": 0.83915}, "CVE-2009-1762": {"epss_score": 0.00842, "epss_percentile": 0.74243}, "CVE-2009-1763": {"epss_score": 0.00053, "epss_percentile": 0.16885}, "CVE-2009-1764": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1765": {"epss_score": 0.52013, "epss_percentile": 0.97805}, "CVE-2009-1766": {"epss_score": 0.0026, "epss_percentile": 0.49167}, "CVE-2009-1767": {"epss_score": 0.034, "epss_percentile": 0.87067}, "CVE-2009-1768": {"epss_score": 0.07604, "epss_percentile": 0.91564}, "CVE-2009-1769": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2009-1770": {"epss_score": 0.02324, "epss_percentile": 0.84386}, "CVE-2009-1771": {"epss_score": 0.03305, "epss_percentile": 0.86872}, "CVE-2009-1772": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-1773": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2009-1774": {"epss_score": 0.4656, "epss_percentile": 0.97551}, "CVE-2009-1775": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2009-1776": {"epss_score": 0.00195, "epss_percentile": 0.41654}, "CVE-2009-1777": {"epss_score": 0.01979, "epss_percentile": 0.83133}, "CVE-2009-1778": {"epss_score": 0.01211, "epss_percentile": 0.78552}, "CVE-2009-1779": {"epss_score": 0.03771, "epss_percentile": 0.87703}, "CVE-2009-1780": {"epss_score": 0.03613, "epss_percentile": 0.87429}, "CVE-2009-1781": {"epss_score": 0.03321, "epss_percentile": 0.86911}, "CVE-2009-1782": {"epss_score": 0.00645, "epss_percentile": 0.70101}, "CVE-2009-1783": {"epss_score": 0.00363, "epss_percentile": 0.57863}, "CVE-2009-1784": {"epss_score": 0.00387, "epss_percentile": 0.59302}, "CVE-2009-1785": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-1786": {"epss_score": 0.00159, "epss_percentile": 0.37325}, "CVE-2009-1787": {"epss_score": 0.00198, "epss_percentile": 0.42015}, "CVE-2009-1788": {"epss_score": 0.0857, "epss_percentile": 0.92129}, "CVE-2009-1789": {"epss_score": 0.14219, "epss_percentile": 0.94166}, "CVE-2009-1790": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2009-1791": {"epss_score": 0.08475, "epss_percentile": 0.92071}, "CVE-2009-1792": {"epss_score": 0.01437, "epss_percentile": 0.80282}, "CVE-2009-1796": {"epss_score": 0.00467, "epss_percentile": 0.63817}, "CVE-2009-1797": {"epss_score": 0.00214, "epss_percentile": 0.44019}, "CVE-2009-1798": {"epss_score": 0.04155, "epss_percentile": 0.88327}, "CVE-2009-1799": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1800": {"epss_score": 0.07891, "epss_percentile": 0.91746}, "CVE-2009-1801": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2009-1802": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2009-1803": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2009-1804": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1805": {"epss_score": 0.00083, "epss_percentile": 0.24703}, "CVE-2009-1806": {"epss_score": 0.00478, "epss_percentile": 0.64378}, "CVE-2009-1807": {"epss_score": 0.03465, "epss_percentile": 0.87189}, "CVE-2009-1808": {"epss_score": 0.00928, "epss_percentile": 0.75582}, "CVE-2009-1809": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-1810": {"epss_score": 0.00302, "epss_percentile": 0.53161}, "CVE-2009-1811": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-1812": {"epss_score": 0.00302, "epss_percentile": 0.53161}, "CVE-2009-1813": {"epss_score": 0.00372, "epss_percentile": 0.58457}, "CVE-2009-1814": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-1815": {"epss_score": 0.28472, "epss_percentile": 0.9636}, "CVE-2009-1816": {"epss_score": 0.00355, "epss_percentile": 0.5731}, "CVE-2009-1817": {"epss_score": 0.20632, "epss_percentile": 0.95391}, "CVE-2009-1818": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-1819": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-1820": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-1821": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2009-1822": {"epss_score": 0.02414, "epss_percentile": 0.84685}, "CVE-2009-1823": {"epss_score": 0.00548, "epss_percentile": 0.67275}, "CVE-2009-1824": {"epss_score": 0.00285, "epss_percentile": 0.5155}, "CVE-2009-1825": {"epss_score": 0.03787, "epss_percentile": 0.87727}, "CVE-2009-1826": {"epss_score": 0.0283, "epss_percentile": 0.85775}, "CVE-2009-1827": {"epss_score": 0.12135, "epss_percentile": 0.93581}, "CVE-2009-1828": {"epss_score": 0.16851, "epss_percentile": 0.94737}, "CVE-2009-1829": {"epss_score": 0.0242, "epss_percentile": 0.84702}, "CVE-2009-1830": {"epss_score": 0.43814, "epss_percentile": 0.97404}, "CVE-2009-1831": {"epss_score": 0.81169, "epss_percentile": 0.99126}, "CVE-2009-1832": {"epss_score": 0.1037, "epss_percentile": 0.92963}, "CVE-2009-1833": {"epss_score": 0.1037, "epss_percentile": 0.92963}, "CVE-2009-1834": {"epss_score": 0.15054, "epss_percentile": 0.94352}, "CVE-2009-1835": {"epss_score": 0.01506, "epss_percentile": 0.80747}, "CVE-2009-1836": {"epss_score": 0.02032, "epss_percentile": 0.83338}, "CVE-2009-1837": {"epss_score": 0.02184, "epss_percentile": 0.83915}, "CVE-2009-1838": {"epss_score": 0.04629, "epss_percentile": 0.88941}, "CVE-2009-1839": {"epss_score": 0.15161, "epss_percentile": 0.94377}, "CVE-2009-1840": {"epss_score": 0.01388, "epss_percentile": 0.79923}, "CVE-2009-1841": {"epss_score": 0.04241, "epss_percentile": 0.88433}, "CVE-2009-1842": {"epss_score": 0.00122, "epss_percentile": 0.32031}, "CVE-2009-1843": {"epss_score": 0.0016, "epss_percentile": 0.37479}, "CVE-2009-1844": {"epss_score": 0.00126, "epss_percentile": 0.32774}, "CVE-2009-1845": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2009-1846": {"epss_score": 0.02041, "epss_percentile": 0.8337}, "CVE-2009-1847": {"epss_score": 0.02707, "epss_percentile": 0.85477}, "CVE-2009-1848": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2009-1849": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2009-1850": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1851": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-1852": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-1853": {"epss_score": 0.00252, "epss_percentile": 0.48398}, "CVE-2009-1854": {"epss_score": 0.01039, "epss_percentile": 0.76941}, "CVE-2009-1855": {"epss_score": 0.29242, "epss_percentile": 0.96426}, "CVE-2009-1856": {"epss_score": 0.26111, "epss_percentile": 0.96113}, "CVE-2009-1857": {"epss_score": 0.10184, "epss_percentile": 0.92883}, "CVE-2009-1858": {"epss_score": 0.14385, "epss_percentile": 0.94199}, "CVE-2009-1859": {"epss_score": 0.08902, "epss_percentile": 0.92307}, "CVE-2009-1860": {"epss_score": 0.06947, "epss_percentile": 0.91134}, "CVE-2009-1861": {"epss_score": 0.15232, "epss_percentile": 0.9439}, "CVE-2009-1862": {"epss_score": 0.58566, "epss_percentile": 0.98124}, "CVE-2009-1863": {"epss_score": 0.02504, "epss_percentile": 0.84934}, "CVE-2009-1864": {"epss_score": 0.03207, "epss_percentile": 0.86637}, "CVE-2009-1865": {"epss_score": 0.02504, "epss_percentile": 0.84934}, "CVE-2009-1866": {"epss_score": 0.03207, "epss_percentile": 0.86637}, "CVE-2009-1867": {"epss_score": 0.00989, "epss_percentile": 0.76359}, "CVE-2009-1868": {"epss_score": 0.18527, "epss_percentile": 0.95028}, "CVE-2009-1869": {"epss_score": 0.21945, "epss_percentile": 0.95575}, "CVE-2009-1870": {"epss_score": 0.00188, "epss_percentile": 0.40884}, "CVE-2009-1872": {"epss_score": 0.08673, "epss_percentile": 0.92183}, "CVE-2009-1873": {"epss_score": 0.03693, "epss_percentile": 0.8758}, "CVE-2009-1874": {"epss_score": 0.00724, "epss_percentile": 0.72029}, "CVE-2009-1875": {"epss_score": 0.00667, "epss_percentile": 0.70711}, "CVE-2009-1876": {"epss_score": 0.01476, "epss_percentile": 0.80534}, "CVE-2009-1877": {"epss_score": 0.00667, "epss_percentile": 0.70711}, "CVE-2009-1878": {"epss_score": 0.00284, "epss_percentile": 0.51445}, "CVE-2009-1879": {"epss_score": 0.09753, "epss_percentile": 0.9269}, "CVE-2009-1880": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-1881": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-1882": {"epss_score": 0.03636, "epss_percentile": 0.87483}, "CVE-2009-1883": {"epss_score": 0.00077, "epss_percentile": 0.2354}, "CVE-2009-1884": {"epss_score": 0.01263, "epss_percentile": 0.7899}, "CVE-2009-1885": {"epss_score": 0.14118, "epss_percentile": 0.94136}, "CVE-2009-1886": {"epss_score": 0.24809, "epss_percentile": 0.95956}, "CVE-2009-1887": {"epss_score": 0.00703, "epss_percentile": 0.71533}, "CVE-2009-1888": {"epss_score": 0.05392, "epss_percentile": 0.89825}, "CVE-2009-1889": {"epss_score": 0.03236, "epss_percentile": 0.86703}, "CVE-2009-1890": {"epss_score": 0.2152, "epss_percentile": 0.95528}, "CVE-2009-1891": {"epss_score": 0.18812, "epss_percentile": 0.95073}, "CVE-2009-1892": {"epss_score": 0.06663, "epss_percentile": 0.90925}, "CVE-2009-1893": {"epss_score": 0.00079, "epss_percentile": 0.23854}, "CVE-2009-1894": {"epss_score": 0.00101, "epss_percentile": 0.28591}, "CVE-2009-1895": {"epss_score": 0.0006, "epss_percentile": 0.19096}, "CVE-2009-1896": {"epss_score": 0.01036, "epss_percentile": 0.76908}, "CVE-2009-1897": {"epss_score": 0.0214, "epss_percentile": 0.83748}, "CVE-2009-1898": {"epss_score": 0.00463, "epss_percentile": 0.63697}, "CVE-2009-1899": {"epss_score": 0.02533, "epss_percentile": 0.85031}, "CVE-2009-1900": {"epss_score": 0.00634, "epss_percentile": 0.69796}, "CVE-2009-1901": {"epss_score": 0.00613, "epss_percentile": 0.69241}, "CVE-2009-1902": {"epss_score": 0.13279, "epss_percentile": 0.93921}, "CVE-2009-1903": {"epss_score": 0.01916, "epss_percentile": 0.82859}, "CVE-2009-1904": {"epss_score": 0.04526, "epss_percentile": 0.88806}, "CVE-2009-1905": {"epss_score": 0.00499, "epss_percentile": 0.65277}, "CVE-2009-1906": {"epss_score": 0.01035, "epss_percentile": 0.769}, "CVE-2009-1907": {"epss_score": 0.02757, "epss_percentile": 0.85593}, "CVE-2009-1908": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2009-1909": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2009-1910": {"epss_score": 0.00755, "epss_percentile": 0.7272}, "CVE-2009-1911": {"epss_score": 0.0991, "epss_percentile": 0.92767}, "CVE-2009-1912": {"epss_score": 0.00982, "epss_percentile": 0.76289}, "CVE-2009-1913": {"epss_score": 0.0041, "epss_percentile": 0.60846}, "CVE-2009-1914": {"epss_score": 0.00082, "epss_percentile": 0.24514}, "CVE-2009-1915": {"epss_score": 0.1793, "epss_percentile": 0.94928}, "CVE-2009-1916": {"epss_score": 0.0419, "epss_percentile": 0.88376}, "CVE-2009-1917": {"epss_score": 0.67007, "epss_percentile": 0.9849}, "CVE-2009-1918": {"epss_score": 0.6571, "epss_percentile": 0.98434}, "CVE-2009-1919": {"epss_score": 0.61187, "epss_percentile": 0.98237}, "CVE-2009-1920": {"epss_score": 0.49387, "epss_percentile": 0.97683}, "CVE-2009-1922": {"epss_score": 0.01887, "epss_percentile": 0.82717}, "CVE-2009-1923": {"epss_score": 0.41972, "epss_percentile": 0.97303}, "CVE-2009-1924": {"epss_score": 0.20038, "epss_percentile": 0.95278}, "CVE-2009-1925": {"epss_score": 0.45823, "epss_percentile": 0.97503}, "CVE-2009-1926": {"epss_score": 0.72259, "epss_percentile": 0.98701}, "CVE-2009-1928": {"epss_score": 0.47858, "epss_percentile": 0.97604}, "CVE-2009-1929": {"epss_score": 0.71035, "epss_percentile": 0.9865}, "CVE-2009-1930": {"epss_score": 0.57724, "epss_percentile": 0.98081}, "CVE-2009-1932": {"epss_score": 0.08313, "epss_percentile": 0.91986}, "CVE-2009-1933": {"epss_score": 0.00049, "epss_percentile": 0.15628}, "CVE-2009-1934": {"epss_score": 0.00603, "epss_percentile": 0.68936}, "CVE-2009-1935": {"epss_score": 0.0007, "epss_percentile": 0.21752}, "CVE-2009-1936": {"epss_score": 0.08071, "epss_percentile": 0.91867}, "CVE-2009-1937": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-1938": {"epss_score": 0.00121, "epss_percentile": 0.31827}, "CVE-2009-1939": {"epss_score": 0.00015, "epss_percentile": 0.02295}, "CVE-2009-1940": {"epss_score": 0.0001, "epss_percentile": 0.00905}, "CVE-2009-1941": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2009-1942": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2009-1943": {"epss_score": 0.77723, "epss_percentile": 0.9895}, "CVE-2009-1944": {"epss_score": 0.08024, "epss_percentile": 0.91837}, "CVE-2009-1945": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2009-1946": {"epss_score": 0.02451, "epss_percentile": 0.84784}, "CVE-2009-1947": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-1948": {"epss_score": 0.02844, "epss_percentile": 0.85817}, "CVE-2009-1949": {"epss_score": 0.04289, "epss_percentile": 0.885}, "CVE-2009-1950": {"epss_score": 0.00321, "epss_percentile": 0.54694}, "CVE-2009-1951": {"epss_score": 0.00513, "epss_percentile": 0.65896}, "CVE-2009-1952": {"epss_score": 0.00295, "epss_percentile": 0.52505}, "CVE-2009-1953": {"epss_score": 0.00554, "epss_percentile": 0.67446}, "CVE-2009-1954": {"epss_score": 0.00448, "epss_percentile": 0.63027}, "CVE-2009-1955": {"epss_score": 0.03262, "epss_percentile": 0.86775}, "CVE-2009-1956": {"epss_score": 0.04274, "epss_percentile": 0.8848}, "CVE-2009-1957": {"epss_score": 0.01736, "epss_percentile": 0.82012}, "CVE-2009-1958": {"epss_score": 0.01736, "epss_percentile": 0.82012}, "CVE-2009-1959": {"epss_score": 0.06922, "epss_percentile": 0.91119}, "CVE-2009-1960": {"epss_score": 0.35191, "epss_percentile": 0.96893}, "CVE-2009-1961": {"epss_score": 0.00133, "epss_percentile": 0.33683}, "CVE-2009-1962": {"epss_score": 0.00091, "epss_percentile": 0.26205}, "CVE-2009-1963": {"epss_score": 0.05293, "epss_percentile": 0.89699}, "CVE-2009-1964": {"epss_score": 0.00977, "epss_percentile": 0.76219}, "CVE-2009-1965": {"epss_score": 0.00918, "epss_percentile": 0.75436}, "CVE-2009-1966": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2009-1967": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2009-1968": {"epss_score": 0.37515, "epss_percentile": 0.97052}, "CVE-2009-1969": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2009-1970": {"epss_score": 0.13801, "epss_percentile": 0.9406}, "CVE-2009-1971": {"epss_score": 0.0052, "epss_percentile": 0.66202}, "CVE-2009-1972": {"epss_score": 0.0044, "epss_percentile": 0.6264}, "CVE-2009-1973": {"epss_score": 0.00576, "epss_percentile": 0.68136}, "CVE-2009-1974": {"epss_score": 0.00955, "epss_percentile": 0.75913}, "CVE-2009-1975": {"epss_score": 0.33682, "epss_percentile": 0.96797}, "CVE-2009-1976": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2009-1977": {"epss_score": 0.85139, "epss_percentile": 0.99321}, "CVE-2009-1978": {"epss_score": 0.8526, "epss_percentile": 0.99325}, "CVE-2009-1979": {"epss_score": 0.85749, "epss_percentile": 0.99346}, "CVE-2009-1980": {"epss_score": 0.00864, "epss_percentile": 0.746}, "CVE-2009-1981": {"epss_score": 0.00087, "epss_percentile": 0.25598}, "CVE-2009-1982": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2009-1983": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2009-1984": {"epss_score": 0.00078, "epss_percentile": 0.23764}, "CVE-2009-1985": {"epss_score": 0.03196, "epss_percentile": 0.86613}, "CVE-2009-1986": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2009-1987": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2009-1988": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2009-1989": {"epss_score": 0.00393, "epss_percentile": 0.59745}, "CVE-2009-1990": {"epss_score": 0.0011, "epss_percentile": 0.30112}, "CVE-2009-1991": {"epss_score": 0.00688, "epss_percentile": 0.71213}, "CVE-2009-1992": {"epss_score": 0.02412, "epss_percentile": 0.84671}, "CVE-2009-1993": {"epss_score": 0.0052, "epss_percentile": 0.66202}, "CVE-2009-1994": {"epss_score": 0.007, "epss_percentile": 0.71469}, "CVE-2009-1995": {"epss_score": 0.00977, "epss_percentile": 0.76219}, "CVE-2009-1996": {"epss_score": 0.00181, "epss_percentile": 0.40021}, "CVE-2009-1997": {"epss_score": 0.00944, "epss_percentile": 0.75792}, "CVE-2009-1998": {"epss_score": 0.0052, "epss_percentile": 0.66202}, "CVE-2009-1999": {"epss_score": 0.01118, "epss_percentile": 0.77743}, "CVE-2009-20001": {"epss_score": 0.00142, "epss_percentile": 0.35021}, "CVE-2009-20002": {"epss_score": 0.27949, "epss_percentile": 0.96299}, "CVE-2009-20003": {"epss_score": 0.05428, "epss_percentile": 0.89871}, "CVE-2009-20004": {"epss_score": 0.05428, "epss_percentile": 0.89871}, "CVE-2009-20005": {"epss_score": 0.7183, "epss_percentile": 0.98683}, "CVE-2009-20006": {"epss_score": 0.65513, "epss_percentile": 0.98423}, "CVE-2009-20007": {"epss_score": 0.65933, "epss_percentile": 0.98444}, "CVE-2009-20008": {"epss_score": 0.5218, "epss_percentile": 0.97812}, "CVE-2009-20009": {"epss_score": 0.70364, "epss_percentile": 0.9863}, "CVE-2009-20010": {"epss_score": 0.73962, "epss_percentile": 0.98778}, "CVE-2009-20011": {"epss_score": 0.68092, "epss_percentile": 0.98531}, "CVE-2009-2000": {"epss_score": 0.00944, "epss_percentile": 0.75792}, "CVE-2009-2001": {"epss_score": 0.007, "epss_percentile": 0.71469}, "CVE-2009-2002": {"epss_score": 0.00882, "epss_percentile": 0.74898}, "CVE-2009-2003": {"epss_score": 0.0114, "epss_percentile": 0.77953}, "CVE-2009-2004": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2009-2005": {"epss_score": 0.00172, "epss_percentile": 0.38971}, "CVE-2009-2006": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2009-2007": {"epss_score": 0.00358, "epss_percentile": 0.57536}, "CVE-2009-2008": {"epss_score": 0.00428, "epss_percentile": 0.61943}, "CVE-2009-2009": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-2010": {"epss_score": 0.00302, "epss_percentile": 0.53161}, "CVE-2009-2011": {"epss_score": 0.74194, "epss_percentile": 0.98791}, "CVE-2009-2012": {"epss_score": 0.00055, "epss_percentile": 0.17527}, "CVE-2009-2013": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-2014": {"epss_score": 8e-05, "epss_percentile": 0.00512}, "CVE-2009-2015": {"epss_score": 0.01674, "epss_percentile": 0.81691}, "CVE-2009-2016": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-2017": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-2018": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2009-2019": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-2020": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-2021": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-2022": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2009-2023": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-2024": {"epss_score": 0.03977, "epss_percentile": 0.88054}, "CVE-2009-2025": {"epss_score": 0.01767, "epss_percentile": 0.82176}, "CVE-2009-2026": {"epss_score": 0.25557, "epss_percentile": 0.96043}, "CVE-2009-2027": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2009-2028": {"epss_score": 0.039, "epss_percentile": 0.8792}, "CVE-2009-2029": {"epss_score": 0.00899, "epss_percentile": 0.75155}, "CVE-2009-2030": {"epss_score": 0.00751, "epss_percentile": 0.72645}, "CVE-2009-2031": {"epss_score": 0.00046, "epss_percentile": 0.14178}, "CVE-2009-2032": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-2033": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2009-2034": {"epss_score": 0.00108, "epss_percentile": 0.29852}, "CVE-2009-2035": {"epss_score": 0.00387, "epss_percentile": 0.59332}, "CVE-2009-2036": {"epss_score": 0.00127, "epss_percentile": 0.3289}, "CVE-2009-2037": {"epss_score": 0.03023, "epss_percentile": 0.86231}, "CVE-2009-2038": {"epss_score": 0.00469, "epss_percentile": 0.63937}, "CVE-2009-2039": {"epss_score": 0.0042, "epss_percentile": 0.61434}, "CVE-2009-2040": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2009-2041": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2009-2042": {"epss_score": 0.03147, "epss_percentile": 0.86498}, "CVE-2009-2043": {"epss_score": 0.03735, "epss_percentile": 0.87649}, "CVE-2009-2044": {"epss_score": 0.05951, "epss_percentile": 0.90355}, "CVE-2009-2045": {"epss_score": 0.00535, "epss_percentile": 0.66836}, "CVE-2009-2046": {"epss_score": 0.00217, "epss_percentile": 0.4431}, "CVE-2009-2047": {"epss_score": 0.00557, "epss_percentile": 0.67539}, "CVE-2009-2048": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2009-2049": {"epss_score": 0.01484, "epss_percentile": 0.8059}, "CVE-2009-2050": {"epss_score": 0.01875, "epss_percentile": 0.82655}, "CVE-2009-2051": {"epss_score": 0.01875, "epss_percentile": 0.82655}, "CVE-2009-2052": {"epss_score": 0.0276, "epss_percentile": 0.85598}, "CVE-2009-2053": {"epss_score": 0.01425, "epss_percentile": 0.80194}, "CVE-2009-2054": {"epss_score": 0.02618, "epss_percentile": 0.85251}, "CVE-2009-2055": {"epss_score": 0.01671, "epss_percentile": 0.81674}, "CVE-2009-2056": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2009-2057": {"epss_score": 0.11952, "epss_percentile": 0.93525}, "CVE-2009-2058": {"epss_score": 0.00265, "epss_percentile": 0.49823}, "CVE-2009-2059": {"epss_score": 0.00235, "epss_percentile": 0.46199}, "CVE-2009-2060": {"epss_score": 0.00344, "epss_percentile": 0.56479}, "CVE-2009-2061": {"epss_score": 0.00338, "epss_percentile": 0.56125}, "CVE-2009-2062": {"epss_score": 0.00299, "epss_percentile": 0.52905}, "CVE-2009-2063": {"epss_score": 0.00269, "epss_percentile": 0.50103}, "CVE-2009-2064": {"epss_score": 0.18534, "epss_percentile": 0.95029}, "CVE-2009-2065": {"epss_score": 0.00299, "epss_percentile": 0.52905}, "CVE-2009-2066": {"epss_score": 0.00299, "epss_percentile": 0.52905}, "CVE-2009-2067": {"epss_score": 0.00265, "epss_percentile": 0.49823}, "CVE-2009-2068": {"epss_score": 0.00202, "epss_percentile": 0.42454}, "CVE-2009-2069": {"epss_score": 0.02947, "epss_percentile": 0.86043}, "CVE-2009-2070": {"epss_score": 0.00143, "epss_percentile": 0.3511}, "CVE-2009-2071": {"epss_score": 0.00313, "epss_percentile": 0.54071}, "CVE-2009-2072": {"epss_score": 0.00041, "epss_percentile": 0.12457}, "CVE-2009-2073": {"epss_score": 0.00254, "epss_percentile": 0.48535}, "CVE-2009-2074": {"epss_score": 0.00198, "epss_percentile": 0.4203}, "CVE-2009-2075": {"epss_score": 0.00503, "epss_percentile": 0.6544}, "CVE-2009-2076": {"epss_score": 0.00156, "epss_percentile": 0.36994}, "CVE-2009-2077": {"epss_score": 0.00179, "epss_percentile": 0.39808}, "CVE-2009-2078": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2009-2079": {"epss_score": 0.00262, "epss_percentile": 0.49364}, "CVE-2009-2080": {"epss_score": 0.03628, "epss_percentile": 0.8747}, "CVE-2009-2081": {"epss_score": 0.02972, "epss_percentile": 0.86096}, "CVE-2009-2082": {"epss_score": 0.00372, "epss_percentile": 0.58427}, "CVE-2009-2083": {"epss_score": 0.00207, "epss_percentile": 0.43129}, "CVE-2009-2084": {"epss_score": 0.00053, "epss_percentile": 0.16942}, "CVE-2009-2085": {"epss_score": 0.00321, "epss_percentile": 0.54685}, "CVE-2009-2087": {"epss_score": 0.00036, "epss_percentile": 0.10301}, "CVE-2009-2088": {"epss_score": 0.00554, "epss_percentile": 0.67451}, "CVE-2009-2089": {"epss_score": 0.00214, "epss_percentile": 0.44016}, "CVE-2009-2090": {"epss_score": 0.00363, "epss_percentile": 0.57848}, "CVE-2009-2091": {"epss_score": 0.00223, "epss_percentile": 0.44945}, "CVE-2009-2092": {"epss_score": 0.00304, "epss_percentile": 0.53267}, "CVE-2009-2093": {"epss_score": 0.00706, "epss_percentile": 0.71623}, "CVE-2009-2094": {"epss_score": 0.00052, "epss_percentile": 0.16455}, "CVE-2009-2095": {"epss_score": 0.00582, "epss_percentile": 0.68303}, "CVE-2009-2096": {"epss_score": 0.0013, "epss_percentile": 0.33306}, "CVE-2009-2097": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-2098": {"epss_score": 0.00127, "epss_percentile": 0.3289}, "CVE-2009-2099": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2009-2100": {"epss_score": 0.01877, "epss_percentile": 0.82663}, "CVE-2009-2101": {"epss_score": 0.01149, "epss_percentile": 0.7802}, "CVE-2009-2102": {"epss_score": 0.00151, "epss_percentile": 0.36344}, "CVE-2009-2103": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2009-2104": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-2105": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2009-2106": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2009-2107": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2009-2108": {"epss_score": 0.20514, "epss_percentile": 0.9536}, "CVE-2009-2109": {"epss_score": 0.04695, "epss_percentile": 0.89017}, "CVE-2009-2110": {"epss_score": 0.04266, "epss_percentile": 0.8847}, "CVE-2009-2111": {"epss_score": 0.02711, "epss_percentile": 0.85493}, "CVE-2009-2112": {"epss_score": 0.00908, "epss_percentile": 0.75285}, "CVE-2009-2113": {"epss_score": 0.00386, "epss_percentile": 0.59235}, "CVE-2009-2114": {"epss_score": 0.01142, "epss_percentile": 0.77973}, "CVE-2009-2115": {"epss_score": 0.00242, "epss_percentile": 0.47354}, "CVE-2009-2116": {"epss_score": 0.01404, "epss_percentile": 0.8004}, "CVE-2009-2117": {"epss_score": 0.0148, "epss_percentile": 0.80564}, "CVE-2009-2118": {"epss_score": 0.02796, "epss_percentile": 0.85682}, "CVE-2009-2119": {"epss_score": 0.01169, "epss_percentile": 0.78201}, "CVE-2009-2120": {"epss_score": 0.0011, "epss_percentile": 0.30161}, "CVE-2009-2121": {"epss_score": 0.00858, "epss_percentile": 0.74505}, "CVE-2009-2122": {"epss_score": 0.00398, "epss_percentile": 0.60053}, "CVE-2009-2123": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-2124": {"epss_score": 0.01061, "epss_percentile": 0.77177}, "CVE-2009-2125": {"epss_score": 0.00151, "epss_percentile": 0.36325}, "CVE-2009-2126": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-2127": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-2128": {"epss_score": 0.00318, "epss_percentile": 0.54449}, "CVE-2009-2129": {"epss_score": 0.00116, "epss_percentile": 0.31135}, "CVE-2009-2130": {"epss_score": 0.01606, "epss_percentile": 0.81305}, "CVE-2009-2131": {"epss_score": 0.01015, "epss_percentile": 0.76658}, "CVE-2009-2132": {"epss_score": 0.01296, "epss_percentile": 0.79256}, "CVE-2009-2133": {"epss_score": 0.08069, "epss_percentile": 0.91866}, "CVE-2009-2134": {"epss_score": 0.01984, "epss_percentile": 0.83151}, "CVE-2009-2135": {"epss_score": 0.00039, "epss_percentile": 0.11534}, "CVE-2009-2136": {"epss_score": 0.00817, "epss_percentile": 0.73845}, "CVE-2009-2137": {"epss_score": 0.0042, "epss_percentile": 0.6144}, "CVE-2009-2138": {"epss_score": 0.00209, "epss_percentile": 0.43396}, "CVE-2009-2139": {"epss_score": 0.23771, "epss_percentile": 0.95815}, "CVE-2009-2140": {"epss_score": 0.06437, "epss_percentile": 0.90757}, "CVE-2009-2141": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2009-2142": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-2143": {"epss_score": 0.01285, "epss_percentile": 0.79174}, "CVE-2009-2144": {"epss_score": 0.00632, "epss_percentile": 0.69738}, "CVE-2009-2145": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2009-2146": {"epss_score": 0.08739, "epss_percentile": 0.92234}, "CVE-2009-2147": {"epss_score": 0.00165, "epss_percentile": 0.38051}, "CVE-2009-2148": {"epss_score": 0.0013, "epss_percentile": 0.33306}, "CVE-2009-2149": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-2150": {"epss_score": 0.00116, "epss_percentile": 0.31135}, "CVE-2009-2151": {"epss_score": 0.01292, "epss_percentile": 0.79234}, "CVE-2009-2152": {"epss_score": 0.00121, "epss_percentile": 0.31914}, "CVE-2009-2153": {"epss_score": 0.00142, "epss_percentile": 0.35029}, "CVE-2009-2154": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-2155": {"epss_score": 0.00521, "epss_percentile": 0.66236}, "CVE-2009-2156": {"epss_score": 0.00726, "epss_percentile": 0.72078}, "CVE-2009-2157": {"epss_score": 0.01016, "epss_percentile": 0.76679}, "CVE-2009-2158": {"epss_score": 0.09288, "epss_percentile": 0.92485}, "CVE-2009-2159": {"epss_score": 0.05227, "epss_percentile": 0.89635}, "CVE-2009-2160": {"epss_score": 0.07338, "epss_percentile": 0.91418}, "CVE-2009-2161": {"epss_score": 0.07337, "epss_percentile": 0.91418}, "CVE-2009-2162": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2009-2163": {"epss_score": 0.01123, "epss_percentile": 0.77789}, "CVE-2009-2164": {"epss_score": 0.00141, "epss_percentile": 0.34924}, "CVE-2009-2165": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2009-2166": {"epss_score": 0.03478, "epss_percentile": 0.87213}, "CVE-2009-2167": {"epss_score": 0.0041, "epss_percentile": 0.60839}, "CVE-2009-2168": {"epss_score": 0.01104, "epss_percentile": 0.77595}, "CVE-2009-2169": {"epss_score": 0.03149, "epss_percentile": 0.86504}, "CVE-2009-2170": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-2171": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2009-2172": {"epss_score": 0.00182, "epss_percentile": 0.40256}, "CVE-2009-2173": {"epss_score": 0.00757, "epss_percentile": 0.72757}, "CVE-2009-2174": {"epss_score": 0.16561, "epss_percentile": 0.94691}, "CVE-2009-2175": {"epss_score": 0.03194, "epss_percentile": 0.86608}, "CVE-2009-2176": {"epss_score": 0.04293, "epss_percentile": 0.88504}, "CVE-2009-2177": {"epss_score": 0.01803, "epss_percentile": 0.82334}, "CVE-2009-2178": {"epss_score": 0.00193, "epss_percentile": 0.41445}, "CVE-2009-2179": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-2180": {"epss_score": 0.0119, "epss_percentile": 0.78377}, "CVE-2009-2181": {"epss_score": 0.00254, "epss_percentile": 0.48622}, "CVE-2009-2182": {"epss_score": 0.00582, "epss_percentile": 0.68303}, "CVE-2009-2183": {"epss_score": 0.00908, "epss_percentile": 0.75285}, "CVE-2009-2184": {"epss_score": 0.01698, "epss_percentile": 0.8182}, "CVE-2009-2185": {"epss_score": 0.08229, "epss_percentile": 0.91941}, "CVE-2009-2186": {"epss_score": 0.05833, "epss_percentile": 0.90245}, "CVE-2009-2187": {"epss_score": 0.00061, "epss_percentile": 0.19549}, "CVE-2009-2188": {"epss_score": 0.23054, "epss_percentile": 0.95725}, "CVE-2009-2189": {"epss_score": 0.00283, "epss_percentile": 0.51383}, "CVE-2009-2190": {"epss_score": 0.01529, "epss_percentile": 0.80874}, "CVE-2009-2191": {"epss_score": 0.00846, "epss_percentile": 0.74323}, "CVE-2009-2192": {"epss_score": 0.00347, "epss_percentile": 0.56788}, "CVE-2009-2193": {"epss_score": 0.22237, "epss_percentile": 0.95613}, "CVE-2009-2194": {"epss_score": 0.00165, "epss_percentile": 0.38059}, "CVE-2009-2195": {"epss_score": 0.29048, "epss_percentile": 0.96414}, "CVE-2009-2196": {"epss_score": 0.19509, "epss_percentile": 0.95195}, "CVE-2009-2197": {"epss_score": 0.00377, "epss_percentile": 0.58698}, "CVE-2009-2198": {"epss_score": 0.00497, "epss_percentile": 0.65182}, "CVE-2009-2199": {"epss_score": 0.0142, "epss_percentile": 0.80168}, "CVE-2009-2200": {"epss_score": 0.00417, "epss_percentile": 0.61227}, "CVE-2009-2201": {"epss_score": 0.00082, "epss_percentile": 0.24546}, "CVE-2009-2202": {"epss_score": 0.10923, "epss_percentile": 0.93159}, "CVE-2009-2203": {"epss_score": 0.07937, "epss_percentile": 0.91776}, "CVE-2009-2204": {"epss_score": 0.18687, "epss_percentile": 0.95053}, "CVE-2009-2205": {"epss_score": 0.00837, "epss_percentile": 0.7416}, "CVE-2009-2206": {"epss_score": 0.05067, "epss_percentile": 0.89459}, "CVE-2009-2207": {"epss_score": 0.00056, "epss_percentile": 0.17907}, "CVE-2009-2208": {"epss_score": 0.00043, "epss_percentile": 0.13101}, "CVE-2009-2209": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2009-2210": {"epss_score": 0.05533, "epss_percentile": 0.89967}, "CVE-2009-2211": {"epss_score": 0.00289, "epss_percentile": 0.52034}, "CVE-2009-2212": {"epss_score": 0.00267, "epss_percentile": 0.49953}, "CVE-2009-2213": {"epss_score": 0.00347, "epss_percentile": 0.56766}, "CVE-2009-2214": {"epss_score": 0.01775, "epss_percentile": 0.82214}, "CVE-2009-2215": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-2216": {"epss_score": 0.02777, "epss_percentile": 0.85642}, "CVE-2009-2217": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2009-2218": {"epss_score": 0.00238, "epss_percentile": 0.46787}, "CVE-2009-2219": {"epss_score": 0.00138, "epss_percentile": 0.34408}, "CVE-2009-2220": {"epss_score": 0.01681, "epss_percentile": 0.81726}, "CVE-2009-2221": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2009-2222": {"epss_score": 0.00255, "epss_percentile": 0.48638}, "CVE-2009-2223": {"epss_score": 0.0076, "epss_percentile": 0.72797}, "CVE-2009-2224": {"epss_score": 0.00083, "epss_percentile": 0.24816}, "CVE-2009-2225": {"epss_score": 0.05896, "epss_percentile": 0.90304}, "CVE-2009-2226": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-2227": {"epss_score": 0.75031, "epss_percentile": 0.98829}, "CVE-2009-2228": {"epss_score": 0.00846, "epss_percentile": 0.74323}, "CVE-2009-2229": {"epss_score": 0.03931, "epss_percentile": 0.87972}, "CVE-2009-2230": {"epss_score": 0.00636, "epss_percentile": 0.69863}, "CVE-2009-2231": {"epss_score": 0.01204, "epss_percentile": 0.78507}, "CVE-2009-2232": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2009-2233": {"epss_score": 0.01452, "epss_percentile": 0.80366}, "CVE-2009-2234": {"epss_score": 0.00276, "epss_percentile": 0.50749}, "CVE-2009-2235": {"epss_score": 0.00323, "epss_percentile": 0.54906}, "CVE-2009-2236": {"epss_score": 0.00323, "epss_percentile": 0.54906}, "CVE-2009-2237": {"epss_score": 0.0025, "epss_percentile": 0.48108}, "CVE-2009-2238": {"epss_score": 0.03299, "epss_percentile": 0.86863}, "CVE-2009-2239": {"epss_score": 0.00014, "epss_percentile": 0.02111}, "CVE-2009-2240": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2009-2241": {"epss_score": 0.01895, "epss_percentile": 0.82749}, "CVE-2009-2242": {"epss_score": 0.00323, "epss_percentile": 0.54906}, "CVE-2009-2243": {"epss_score": 0.00271, "epss_percentile": 0.5034}, "CVE-2009-2254": {"epss_score": 0.09565, "epss_percentile": 0.92602}, "CVE-2009-2255": {"epss_score": 0.35175, "epss_percentile": 0.96893}, "CVE-2009-2256": {"epss_score": 0.04799, "epss_percentile": 0.89156}, "CVE-2009-2257": {"epss_score": 0.04095, "epss_percentile": 0.88247}, "CVE-2009-2258": {"epss_score": 0.05428, "epss_percentile": 0.8987}, "CVE-2009-2260": {"epss_score": 0.00382, "epss_percentile": 0.59053}, "CVE-2009-2261": {"epss_score": 0.70587, "epss_percentile": 0.98636}, "CVE-2009-2262": {"epss_score": 0.0049, "epss_percentile": 0.64917}, "CVE-2009-2263": {"epss_score": 0.00428, "epss_percentile": 0.61929}, "CVE-2009-2265": {"epss_score": 0.9275, "epss_percentile": 0.99742}, "CVE-2009-2266": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2009-2267": {"epss_score": 0.02241, "epss_percentile": 0.84117}, "CVE-2009-2268": {"epss_score": 0.00245, "epss_percentile": 0.47674}, "CVE-2009-2269": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2009-2270": {"epss_score": 0.01053, "epss_percentile": 0.771}, "CVE-2009-2271": {"epss_score": 0.00343, "epss_percentile": 0.56445}, "CVE-2009-2272": {"epss_score": 0.00276, "epss_percentile": 0.50769}, "CVE-2009-2273": {"epss_score": 0.00051, "epss_percentile": 0.1602}, "CVE-2009-2274": {"epss_score": 0.0013, "epss_percentile": 0.33273}, "CVE-2009-2275": {"epss_score": 0.0087, "epss_percentile": 0.74695}, "CVE-2009-2276": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-2277": {"epss_score": 0.00365, "epss_percentile": 0.57996}, "CVE-2009-2281": {"epss_score": 0.11504, "epss_percentile": 0.93385}, "CVE-2009-2282": {"epss_score": 0.00163, "epss_percentile": 0.37773}, "CVE-2009-2283": {"epss_score": 0.00178, "epss_percentile": 0.39658}, "CVE-2009-2284": {"epss_score": 0.00521, "epss_percentile": 0.66218}, "CVE-2009-2285": {"epss_score": 0.16784, "epss_percentile": 0.94731}, "CVE-2009-2286": {"epss_score": 0.08323, "epss_percentile": 0.9199}, "CVE-2009-2287": {"epss_score": 0.0006, "epss_percentile": 0.19181}, "CVE-2009-2288": {"epss_score": 0.933, "epss_percentile": 0.99794}, "CVE-2009-2289": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2009-2290": {"epss_score": 0.00141, "epss_percentile": 0.34848}, "CVE-2009-2291": {"epss_score": 0.00469, "epss_percentile": 0.63917}, "CVE-2009-2292": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2009-2293": {"epss_score": 0.01991, "epss_percentile": 0.83177}, "CVE-2009-2294": {"epss_score": 0.01904, "epss_percentile": 0.82791}, "CVE-2009-2295": {"epss_score": 0.01223, "epss_percentile": 0.78668}, "CVE-2009-2296": {"epss_score": 0.03052, "epss_percentile": 0.86292}, "CVE-2009-2297": {"epss_score": 0.00694, "epss_percentile": 0.71359}, "CVE-2009-2298": {"epss_score": 0.02479, "epss_percentile": 0.84869}, "CVE-2009-2299": {"epss_score": 0.00879, "epss_percentile": 0.74835}, "CVE-2009-2300": {"epss_score": 0.01527, "epss_percentile": 0.8087}, "CVE-2009-2301": {"epss_score": 0.00256, "epss_percentile": 0.48769}, "CVE-2009-2302": {"epss_score": 0.01557, "epss_percentile": 0.81021}, "CVE-2009-2303": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2009-2304": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2009-2305": {"epss_score": 0.04604, "epss_percentile": 0.88907}, "CVE-2009-2306": {"epss_score": 0.02753, "epss_percentile": 0.85587}, "CVE-2009-2307": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-2308": {"epss_score": 0.00456, "epss_percentile": 0.63328}, "CVE-2009-2309": {"epss_score": 0.00264, "epss_percentile": 0.49716}, "CVE-2009-2310": {"epss_score": 0.00276, "epss_percentile": 0.50749}, "CVE-2009-2311": {"epss_score": 0.00276, "epss_percentile": 0.50749}, "CVE-2009-2312": {"epss_score": 0.00044, "epss_percentile": 0.13447}, "CVE-2009-2313": {"epss_score": 0.01888, "epss_percentile": 0.82719}, "CVE-2009-2314": {"epss_score": 0.00068, "epss_percentile": 0.21381}, "CVE-2009-2316": {"epss_score": 0.00599, "epss_percentile": 0.68804}, "CVE-2009-2317": {"epss_score": 0.00787, "epss_percentile": 0.7331}, "CVE-2009-2318": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2009-2319": {"epss_score": 0.00134, "epss_percentile": 0.33927}, "CVE-2009-2320": {"epss_score": 0.00423, "epss_percentile": 0.61634}, "CVE-2009-2321": {"epss_score": 0.00616, "epss_percentile": 0.69334}, "CVE-2009-2322": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2009-2323": {"epss_score": 0.00507, "epss_percentile": 0.65675}, "CVE-2009-2324": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2009-2325": {"epss_score": 0.02634, "epss_percentile": 0.85289}, "CVE-2009-2326": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-2327": {"epss_score": 0.00159, "epss_percentile": 0.37343}, "CVE-2009-2328": {"epss_score": 0.00201, "epss_percentile": 0.42335}, "CVE-2009-2329": {"epss_score": 0.01485, "epss_percentile": 0.80597}, "CVE-2009-2330": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2009-2331": {"epss_score": 0.01096, "epss_percentile": 0.77518}, "CVE-2009-2332": {"epss_score": 0.01901, "epss_percentile": 0.8278}, "CVE-2009-2333": {"epss_score": 0.01507, "epss_percentile": 0.80752}, "CVE-2009-2334": {"epss_score": 0.13967, "epss_percentile": 0.94102}, "CVE-2009-2335": {"epss_score": 0.85338, "epss_percentile": 0.99329}, "CVE-2009-2336": {"epss_score": 0.02303, "epss_percentile": 0.84317}, "CVE-2009-2337": {"epss_score": 0.00224, "epss_percentile": 0.4498}, "CVE-2009-2338": {"epss_score": 0.02138, "epss_percentile": 0.83737}, "CVE-2009-2339": {"epss_score": 0.0016, "epss_percentile": 0.37494}, "CVE-2009-2340": {"epss_score": 0.00145, "epss_percentile": 0.35414}, "CVE-2009-2341": {"epss_score": 0.00182, "epss_percentile": 0.40203}, "CVE-2009-2342": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-2343": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-2344": {"epss_score": 0.02785, "epss_percentile": 0.85657}, "CVE-2009-2345": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2009-2346": {"epss_score": 0.00843, "epss_percentile": 0.74266}, "CVE-2009-2347": {"epss_score": 0.01061, "epss_percentile": 0.77171}, "CVE-2009-2348": {"epss_score": 0.00046, "epss_percentile": 0.14128}, "CVE-2009-2350": {"epss_score": 0.13287, "epss_percentile": 0.93923}, "CVE-2009-2351": {"epss_score": 0.00292, "epss_percentile": 0.52283}, "CVE-2009-2352": {"epss_score": 0.00464, "epss_percentile": 0.63707}, "CVE-2009-2353": {"epss_score": 0.01171, "epss_percentile": 0.78214}, "CVE-2009-2354": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2009-2355": {"epss_score": 0.00455, "epss_percentile": 0.63299}, "CVE-2009-2356": {"epss_score": 0.06315, "epss_percentile": 0.90667}, "CVE-2009-2357": {"epss_score": 0.0058, "epss_percentile": 0.68256}, "CVE-2009-2358": {"epss_score": 0.00042, "epss_percentile": 0.12788}, "CVE-2009-2359": {"epss_score": 0.00228, "epss_percentile": 0.45479}, "CVE-2009-2360": {"epss_score": 0.01087, "epss_percentile": 0.77429}, "CVE-2009-2361": {"epss_score": 0.01279, "epss_percentile": 0.79133}, "CVE-2009-2362": {"epss_score": 0.25543, "epss_percentile": 0.96039}, "CVE-2009-2363": {"epss_score": 0.08142, "epss_percentile": 0.91899}, "CVE-2009-2364": {"epss_score": 0.11341, "epss_percentile": 0.93315}, "CVE-2009-2365": {"epss_score": 0.00284, "epss_percentile": 0.51428}, "CVE-2009-2366": {"epss_score": 0.00323, "epss_percentile": 0.54903}, "CVE-2009-2367": {"epss_score": 0.32334, "epss_percentile": 0.9669}, "CVE-2009-2368": {"epss_score": 0.00396, "epss_percentile": 0.59885}, "CVE-2009-2369": {"epss_score": 0.01557, "epss_percentile": 0.81017}, "CVE-2009-2370": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-2371": {"epss_score": 0.00642, "epss_percentile": 0.70033}, "CVE-2009-2372": {"epss_score": 0.01134, "epss_percentile": 0.77888}, "CVE-2009-2373": {"epss_score": 0.00237, "epss_percentile": 0.46709}, "CVE-2009-2374": {"epss_score": 0.00262, "epss_percentile": 0.49368}, "CVE-2009-2375": {"epss_score": 0.05938, "epss_percentile": 0.90346}, "CVE-2009-2376": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-2377": {"epss_score": 0.02781, "epss_percentile": 0.85651}, "CVE-2009-2378": {"epss_score": 0.00495, "epss_percentile": 0.65107}, "CVE-2009-2379": {"epss_score": 0.06881, "epss_percentile": 0.9109}, "CVE-2009-2380": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2009-2381": {"epss_score": 0.00145, "epss_percentile": 0.35521}, "CVE-2009-2382": {"epss_score": 0.01858, "epss_percentile": 0.82579}, "CVE-2009-2383": {"epss_score": 0.00249, "epss_percentile": 0.48015}, "CVE-2009-2384": {"epss_score": 0.06898, "epss_percentile": 0.91101}, "CVE-2009-2385": {"epss_score": 0.00162, "epss_percentile": 0.37636}, "CVE-2009-2386": {"epss_score": 0.05336, "epss_percentile": 0.89743}, "CVE-2009-2387": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2009-2388": {"epss_score": 0.00249, "epss_percentile": 0.48033}, "CVE-2009-2389": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-2390": {"epss_score": 0.0016, "epss_percentile": 0.37494}, "CVE-2009-2391": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2009-2392": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-2393": {"epss_score": 0.01096, "epss_percentile": 0.77518}, "CVE-2009-2394": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-2395": {"epss_score": 0.00135, "epss_percentile": 0.34049}, "CVE-2009-2396": {"epss_score": 0.01329, "epss_percentile": 0.79504}, "CVE-2009-2397": {"epss_score": 0.01696, "epss_percentile": 0.81813}, "CVE-2009-2398": {"epss_score": 0.01099, "epss_percentile": 0.77559}, "CVE-2009-2399": {"epss_score": 0.00495, "epss_percentile": 0.65107}, "CVE-2009-2400": {"epss_score": 0.0016, "epss_percentile": 0.37494}, "CVE-2009-2401": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2009-2402": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-2403": {"epss_score": 0.1212, "epss_percentile": 0.93571}, "CVE-2009-2404": {"epss_score": 0.21024, "epss_percentile": 0.95453}, "CVE-2009-2405": {"epss_score": 0.00776, "epss_percentile": 0.73095}, "CVE-2009-2406": {"epss_score": 0.00314, "epss_percentile": 0.54119}, "CVE-2009-2407": {"epss_score": 0.00281, "epss_percentile": 0.51142}, "CVE-2009-2408": {"epss_score": 0.01686, "epss_percentile": 0.81751}, "CVE-2009-2409": {"epss_score": 0.02241, "epss_percentile": 0.84117}, "CVE-2009-2410": {"epss_score": 0.00439, "epss_percentile": 0.62606}, "CVE-2009-2411": {"epss_score": 0.06173, "epss_percentile": 0.90531}, "CVE-2009-2412": {"epss_score": 0.06497, "epss_percentile": 0.908}, "CVE-2009-2414": {"epss_score": 0.01414, "epss_percentile": 0.80127}, "CVE-2009-2415": {"epss_score": 0.12077, "epss_percentile": 0.9356}, "CVE-2009-2416": {"epss_score": 0.00192, "epss_percentile": 0.41364}, "CVE-2009-2417": {"epss_score": 0.0733, "epss_percentile": 0.91413}, "CVE-2009-2419": {"epss_score": 0.28625, "epss_percentile": 0.96373}, "CVE-2009-2420": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2009-2421": {"epss_score": 0.01566, "epss_percentile": 0.81068}, "CVE-2009-2422": {"epss_score": 0.00403, "epss_percentile": 0.60376}, "CVE-2009-2423": {"epss_score": 0.00249, "epss_percentile": 0.48033}, "CVE-2009-2424": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-2425": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2009-2426": {"epss_score": 0.00696, "epss_percentile": 0.71384}, "CVE-2009-2427": {"epss_score": 0.0013, "epss_percentile": 0.33306}, "CVE-2009-2428": {"epss_score": 0.00172, "epss_percentile": 0.38957}, "CVE-2009-2429": {"epss_score": 0.00044, "epss_percentile": 0.13447}, "CVE-2009-2430": {"epss_score": 0.00062, "epss_percentile": 0.1969}, "CVE-2009-2431": {"epss_score": 0.01187, "epss_percentile": 0.78355}, "CVE-2009-2432": {"epss_score": 0.01072, "epss_percentile": 0.77279}, "CVE-2009-2433": {"epss_score": 0.16412, "epss_percentile": 0.94648}, "CVE-2009-2434": {"epss_score": 0.00058, "epss_percentile": 0.18416}, "CVE-2009-2435": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2009-2436": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2009-2437": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2009-2438": {"epss_score": 0.00834, "epss_percentile": 0.74108}, "CVE-2009-2439": {"epss_score": 0.00158, "epss_percentile": 0.37184}, "CVE-2009-2440": {"epss_score": 0.00997, "epss_percentile": 0.76454}, "CVE-2009-2441": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-2442": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2009-2443": {"epss_score": 0.08064, "epss_percentile": 0.91863}, "CVE-2009-2444": {"epss_score": 0.00897, "epss_percentile": 0.75128}, "CVE-2009-2445": {"epss_score": 0.00815, "epss_percentile": 0.73782}, "CVE-2009-2446": {"epss_score": 0.04623, "epss_percentile": 0.88935}, "CVE-2009-2447": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-2448": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-2449": {"epss_score": 0.00473, "epss_percentile": 0.64108}, "CVE-2009-2450": {"epss_score": 0.00315, "epss_percentile": 0.54166}, "CVE-2009-2451": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2009-2452": {"epss_score": 0.00605, "epss_percentile": 0.68975}, "CVE-2009-2453": {"epss_score": 0.00727, "epss_percentile": 0.72093}, "CVE-2009-2454": {"epss_score": 0.00414, "epss_percentile": 0.61021}, "CVE-2009-2455": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-2456": {"epss_score": 0.02234, "epss_percentile": 0.84095}, "CVE-2009-2457": {"epss_score": 0.00788, "epss_percentile": 0.73336}, "CVE-2009-2458": {"epss_score": 0.00616, "epss_percentile": 0.69334}, "CVE-2009-2459": {"epss_score": 0.00446, "epss_percentile": 0.62912}, "CVE-2009-2460": {"epss_score": 0.00941, "epss_percentile": 0.75744}, "CVE-2009-2461": {"epss_score": 0.0006, "epss_percentile": 0.192}, "CVE-2009-2462": {"epss_score": 0.03481, "epss_percentile": 0.87219}, "CVE-2009-2463": {"epss_score": 0.05526, "epss_percentile": 0.89962}, "CVE-2009-2464": {"epss_score": 0.19042, "epss_percentile": 0.95118}, "CVE-2009-2465": {"epss_score": 0.04329, "epss_percentile": 0.88558}, "CVE-2009-2466": {"epss_score": 0.04631, "epss_percentile": 0.88945}, "CVE-2009-2467": {"epss_score": 0.05189, "epss_percentile": 0.89594}, "CVE-2009-2468": {"epss_score": 0.23738, "epss_percentile": 0.95812}, "CVE-2009-2469": {"epss_score": 0.04119, "epss_percentile": 0.88281}, "CVE-2009-2470": {"epss_score": 0.0266, "epss_percentile": 0.85366}, "CVE-2009-2471": {"epss_score": 0.02113, "epss_percentile": 0.83652}, "CVE-2009-2472": {"epss_score": 0.007, "epss_percentile": 0.71483}, "CVE-2009-2473": {"epss_score": 0.07243, "epss_percentile": 0.91346}, "CVE-2009-2474": {"epss_score": 0.00439, "epss_percentile": 0.62587}, "CVE-2009-2475": {"epss_score": 0.00699, "epss_percentile": 0.71433}, "CVE-2009-2476": {"epss_score": 0.0172, "epss_percentile": 0.81929}, "CVE-2009-2477": {"epss_score": 0.83034, "epss_percentile": 0.99227}, "CVE-2009-2478": {"epss_score": 0.04071, "epss_percentile": 0.88205}, "CVE-2009-2479": {"epss_score": 0.13469, "epss_percentile": 0.93974}, "CVE-2009-2480": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2009-2481": {"epss_score": 0.00349, "epss_percentile": 0.56874}, "CVE-2009-2482": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2009-2483": {"epss_score": 0.00061, "epss_percentile": 0.19549}, "CVE-2009-2484": {"epss_score": 0.68591, "epss_percentile": 0.98555}, "CVE-2009-2485": {"epss_score": 0.80024, "epss_percentile": 0.99068}, "CVE-2009-2486": {"epss_score": 0.01667, "epss_percentile": 0.81655}, "CVE-2009-2487": {"epss_score": 0.01795, "epss_percentile": 0.82297}, "CVE-2009-2488": {"epss_score": 0.00054, "epss_percentile": 0.17322}, "CVE-2009-2489": {"epss_score": 0.0006, "epss_percentile": 0.18955}, "CVE-2009-2490": {"epss_score": 0.00061, "epss_percentile": 0.19516}, "CVE-2009-2491": {"epss_score": 0.00069, "epss_percentile": 0.21435}, "CVE-2009-2492": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-2493": {"epss_score": 0.42132, "epss_percentile": 0.97314}, "CVE-2009-2494": {"epss_score": 0.60593, "epss_percentile": 0.98212}, "CVE-2009-2495": {"epss_score": 0.42541, "epss_percentile": 0.97336}, "CVE-2009-2496": {"epss_score": 0.59016, "epss_percentile": 0.98145}, "CVE-2009-2497": {"epss_score": 0.39632, "epss_percentile": 0.97172}, "CVE-2009-2498": {"epss_score": 0.36517, "epss_percentile": 0.96982}, "CVE-2009-2499": {"epss_score": 0.37778, "epss_percentile": 0.97069}, "CVE-2009-2500": {"epss_score": 0.56766, "epss_percentile": 0.98036}, "CVE-2009-2501": {"epss_score": 0.51681, "epss_percentile": 0.97794}, "CVE-2009-2502": {"epss_score": 0.51576, "epss_percentile": 0.97787}, "CVE-2009-2503": {"epss_score": 0.43906, "epss_percentile": 0.97406}, "CVE-2009-2504": {"epss_score": 0.48801, "epss_percentile": 0.97655}, "CVE-2009-2505": {"epss_score": 0.47852, "epss_percentile": 0.97604}, "CVE-2009-2506": {"epss_score": 0.74616, "epss_percentile": 0.9881}, "CVE-2009-2507": {"epss_score": 0.4406, "epss_percentile": 0.97417}, "CVE-2009-2508": {"epss_score": 0.00766, "epss_percentile": 0.72946}, "CVE-2009-2509": {"epss_score": 0.28931, "epss_percentile": 0.96401}, "CVE-2009-2510": {"epss_score": 0.17107, "epss_percentile": 0.94776}, "CVE-2009-2511": {"epss_score": 0.14509, "epss_percentile": 0.94227}, "CVE-2009-2512": {"epss_score": 0.39904, "epss_percentile": 0.97186}, "CVE-2009-2513": {"epss_score": 0.00439, "epss_percentile": 0.62586}, "CVE-2009-2514": {"epss_score": 0.80209, "epss_percentile": 0.99076}, "CVE-2009-2515": {"epss_score": 0.01489, "epss_percentile": 0.80626}, "CVE-2009-2516": {"epss_score": 0.01947, "epss_percentile": 0.83006}, "CVE-2009-2517": {"epss_score": 0.00894, "epss_percentile": 0.7508}, "CVE-2009-2518": {"epss_score": 0.55589, "epss_percentile": 0.97986}, "CVE-2009-2519": {"epss_score": 0.40143, "epss_percentile": 0.97199}, "CVE-2009-2521": {"epss_score": 0.60775, "epss_percentile": 0.98221}, "CVE-2009-2523": {"epss_score": 0.1146, "epss_percentile": 0.93368}, "CVE-2009-2524": {"epss_score": 0.46773, "epss_percentile": 0.97558}, "CVE-2009-2525": {"epss_score": 0.36246, "epss_percentile": 0.96963}, "CVE-2009-2526": {"epss_score": 0.80775, "epss_percentile": 0.99104}, "CVE-2009-2527": {"epss_score": 0.47921, "epss_percentile": 0.97609}, "CVE-2009-2528": {"epss_score": 0.41196, "epss_percentile": 0.97258}, "CVE-2009-2529": {"epss_score": 0.24554, "epss_percentile": 0.95933}, "CVE-2009-2530": {"epss_score": 0.40116, "epss_percentile": 0.97197}, "CVE-2009-2531": {"epss_score": 0.40116, "epss_percentile": 0.97197}, "CVE-2009-2532": {"epss_score": 0.61784, "epss_percentile": 0.98261}, "CVE-2009-2533": {"epss_score": 0.10206, "epss_percentile": 0.92893}, "CVE-2009-2534": {"epss_score": 0.11172, "epss_percentile": 0.93253}, "CVE-2009-2535": {"epss_score": 0.10788, "epss_percentile": 0.93103}, "CVE-2009-2536": {"epss_score": 0.14987, "epss_percentile": 0.94337}, "CVE-2009-2537": {"epss_score": 0.03612, "epss_percentile": 0.87427}, "CVE-2009-2538": {"epss_score": 0.0139, "epss_percentile": 0.79937}, "CVE-2009-2539": {"epss_score": 0.01252, "epss_percentile": 0.78901}, "CVE-2009-2540": {"epss_score": 0.01319, "epss_percentile": 0.79435}, "CVE-2009-2541": {"epss_score": 0.0216, "epss_percentile": 0.83824}, "CVE-2009-2542": {"epss_score": 0.01176, "epss_percentile": 0.78274}, "CVE-2009-2543": {"epss_score": 0.00421, "epss_percentile": 0.61499}, "CVE-2009-2544": {"epss_score": 0.00965, "epss_percentile": 0.76043}, "CVE-2009-2545": {"epss_score": 0.00386, "epss_percentile": 0.59267}, "CVE-2009-2546": {"epss_score": 0.00092, "epss_percentile": 0.26517}, "CVE-2009-2547": {"epss_score": 0.00613, "epss_percentile": 0.69253}, "CVE-2009-2548": {"epss_score": 0.06657, "epss_percentile": 0.90921}, "CVE-2009-2549": {"epss_score": 0.00739, "epss_percentile": 0.72355}, "CVE-2009-2550": {"epss_score": 0.13579, "epss_percentile": 0.94}, "CVE-2009-2551": {"epss_score": 0.0278, "epss_percentile": 0.85648}, "CVE-2009-2552": {"epss_score": 0.00951, "epss_percentile": 0.75865}, "CVE-2009-2553": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-2554": {"epss_score": 0.00182, "epss_percentile": 0.40203}, "CVE-2009-2555": {"epss_score": 0.27184, "epss_percentile": 0.96218}, "CVE-2009-2556": {"epss_score": 0.00459, "epss_percentile": 0.63451}, "CVE-2009-2557": {"epss_score": 0.01712, "epss_percentile": 0.81885}, "CVE-2009-2558": {"epss_score": 0.01285, "epss_percentile": 0.79178}, "CVE-2009-2559": {"epss_score": 0.00656, "epss_percentile": 0.70441}, "CVE-2009-2560": {"epss_score": 0.02685, "epss_percentile": 0.85424}, "CVE-2009-2561": {"epss_score": 0.00526, "epss_percentile": 0.66409}, "CVE-2009-2562": {"epss_score": 0.01851, "epss_percentile": 0.82542}, "CVE-2009-2563": {"epss_score": 0.01296, "epss_percentile": 0.79258}, "CVE-2009-2564": {"epss_score": 0.00274, "epss_percentile": 0.50531}, "CVE-2009-2565": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-2566": {"epss_score": 0.63261, "epss_percentile": 0.98325}, "CVE-2009-2567": {"epss_score": 0.00264, "epss_percentile": 0.49716}, "CVE-2009-2568": {"epss_score": 0.29971, "epss_percentile": 0.9649}, "CVE-2009-2569": {"epss_score": 0.01763, "epss_percentile": 0.82158}, "CVE-2009-2570": {"epss_score": 0.25064, "epss_percentile": 0.95983}, "CVE-2009-2571": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-2572": {"epss_score": 0.00199, "epss_percentile": 0.42106}, "CVE-2009-2573": {"epss_score": 0.00245, "epss_percentile": 0.47709}, "CVE-2009-2574": {"epss_score": 0.02561, "epss_percentile": 0.85105}, "CVE-2009-2575": {"epss_score": 0.00423, "epss_percentile": 0.61633}, "CVE-2009-2576": {"epss_score": 0.30084, "epss_percentile": 0.96506}, "CVE-2009-2577": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2009-2578": {"epss_score": 0.0031, "epss_percentile": 0.53751}, "CVE-2009-2579": {"epss_score": 0.00185, "epss_percentile": 0.40476}, "CVE-2009-2581": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2009-2582": {"epss_score": 0.02521, "epss_percentile": 0.85003}, "CVE-2009-2583": {"epss_score": 0.01012, "epss_percentile": 0.76624}, "CVE-2009-2584": {"epss_score": 0.00068, "epss_percentile": 0.21323}, "CVE-2009-2585": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2009-2586": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-2587": {"epss_score": 0.02045, "epss_percentile": 0.83381}, "CVE-2009-2588": {"epss_score": 0.01987, "epss_percentile": 0.83162}, "CVE-2009-2589": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2009-2590": {"epss_score": 0.00429, "epss_percentile": 0.61971}, "CVE-2009-2591": {"epss_score": 0.00147, "epss_percentile": 0.35752}, "CVE-2009-2592": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2009-2593": {"epss_score": 0.00217, "epss_percentile": 0.44301}, "CVE-2009-2594": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2009-2595": {"epss_score": 0.00844, "epss_percentile": 0.74281}, "CVE-2009-2596": {"epss_score": 0.0004, "epss_percentile": 0.11997}, "CVE-2009-2597": {"epss_score": 0.00568, "epss_percentile": 0.67883}, "CVE-2009-2598": {"epss_score": 0.00174, "epss_percentile": 0.39157}, "CVE-2009-2599": {"epss_score": 0.00243, "epss_percentile": 0.47504}, "CVE-2009-2600": {"epss_score": 0.03015, "epss_percentile": 0.8621}, "CVE-2009-2601": {"epss_score": 0.00233, "epss_percentile": 0.46022}, "CVE-2009-2602": {"epss_score": 0.03686, "epss_percentile": 0.8757}, "CVE-2009-2603": {"epss_score": 0.00243, "epss_percentile": 0.47504}, "CVE-2009-2604": {"epss_score": 0.00233, "epss_percentile": 0.46022}, "CVE-2009-2605": {"epss_score": 0.00151, "epss_percentile": 0.36344}, "CVE-2009-2606": {"epss_score": 0.03686, "epss_percentile": 0.8757}, "CVE-2009-2607": {"epss_score": 0.00127, "epss_percentile": 0.3289}, "CVE-2009-2608": {"epss_score": 0.00182, "epss_percentile": 0.40203}, "CVE-2009-2609": {"epss_score": 0.00147, "epss_percentile": 0.35752}, "CVE-2009-2610": {"epss_score": 0.00262, "epss_percentile": 0.49364}, "CVE-2009-2611": {"epss_score": 0.00839, "epss_percentile": 0.74189}, "CVE-2009-2612": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-2613": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-2614": {"epss_score": 0.0036, "epss_percentile": 0.57688}, "CVE-2009-2615": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-2616": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-2617": {"epss_score": 0.06009, "epss_percentile": 0.90404}, "CVE-2009-2618": {"epss_score": 0.00147, "epss_percentile": 0.35752}, "CVE-2009-2619": {"epss_score": 0.00406, "epss_percentile": 0.60513}, "CVE-2009-2620": {"epss_score": 0.10028, "epss_percentile": 0.9282}, "CVE-2009-2621": {"epss_score": 0.23562, "epss_percentile": 0.95791}, "CVE-2009-2622": {"epss_score": 0.26189, "epss_percentile": 0.96121}, "CVE-2009-2624": {"epss_score": 0.07318, "epss_percentile": 0.91406}, "CVE-2009-2625": {"epss_score": 0.00472, "epss_percentile": 0.64036}, "CVE-2009-2626": {"epss_score": 0.08156, "epss_percentile": 0.91906}, "CVE-2009-2627": {"epss_score": 0.01199, "epss_percentile": 0.7846}, "CVE-2009-2628": {"epss_score": 0.11764, "epss_percentile": 0.93468}, "CVE-2009-2629": {"epss_score": 0.81297, "epss_percentile": 0.99131}, "CVE-2009-2631": {"epss_score": 0.01466, "epss_percentile": 0.80461}, "CVE-2009-2632": {"epss_score": 0.00127, "epss_percentile": 0.32887}, "CVE-2009-2633": {"epss_score": 0.00609, "epss_percentile": 0.69135}, "CVE-2009-2634": {"epss_score": 0.00609, "epss_percentile": 0.69135}, "CVE-2009-2635": {"epss_score": 0.0059, "epss_percentile": 0.68562}, "CVE-2009-2636": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-2637": {"epss_score": 0.00939, "epss_percentile": 0.75722}, "CVE-2009-2638": {"epss_score": 0.00141, "epss_percentile": 0.34848}, "CVE-2009-2639": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-2640": {"epss_score": 0.00344, "epss_percentile": 0.56478}, "CVE-2009-2641": {"epss_score": 0.0059, "epss_percentile": 0.68562}, "CVE-2009-2642": {"epss_score": 0.01143, "epss_percentile": 0.7798}, "CVE-2009-2643": {"epss_score": 0.06927, "epss_percentile": 0.9112}, "CVE-2009-2644": {"epss_score": 0.00048, "epss_percentile": 0.14971}, "CVE-2009-2646": {"epss_score": 0.02639, "epss_percentile": 0.85299}, "CVE-2009-2647": {"epss_score": 0.01362, "epss_percentile": 0.79758}, "CVE-2009-2648": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2009-2649": {"epss_score": 0.003, "epss_percentile": 0.5292}, "CVE-2009-2650": {"epss_score": 0.61668, "epss_percentile": 0.98258}, "CVE-2009-2651": {"epss_score": 0.00071, "epss_percentile": 0.22022}, "CVE-2009-2652": {"epss_score": 0.01234, "epss_percentile": 0.78756}, "CVE-2009-2653": {"epss_score": 0.02263, "epss_percentile": 0.84191}, "CVE-2009-2654": {"epss_score": 0.13196, "epss_percentile": 0.93897}, "CVE-2009-2655": {"epss_score": 0.2795, "epss_percentile": 0.96299}, "CVE-2009-2656": {"epss_score": 0.01192, "epss_percentile": 0.78402}, "CVE-2009-2657": {"epss_score": 0.00053, "epss_percentile": 0.16888}, "CVE-2009-2658": {"epss_score": 0.00962, "epss_percentile": 0.75994}, "CVE-2009-2659": {"epss_score": 0.01377, "epss_percentile": 0.79841}, "CVE-2009-2660": {"epss_score": 0.02258, "epss_percentile": 0.84178}, "CVE-2009-2661": {"epss_score": 0.01793, "epss_percentile": 0.82289}, "CVE-2009-2662": {"epss_score": 0.07076, "epss_percentile": 0.91233}, "CVE-2009-2663": {"epss_score": 0.02221, "epss_percentile": 0.84051}, "CVE-2009-2664": {"epss_score": 0.03012, "epss_percentile": 0.86198}, "CVE-2009-2665": {"epss_score": 0.01362, "epss_percentile": 0.7976}, "CVE-2009-2666": {"epss_score": 0.00665, "epss_percentile": 0.70667}, "CVE-2009-2667": {"epss_score": 0.00484, "epss_percentile": 0.64663}, "CVE-2009-2668": {"epss_score": 0.23209, "epss_percentile": 0.95751}, "CVE-2009-2669": {"epss_score": 0.00077, "epss_percentile": 0.23541}, "CVE-2009-2670": {"epss_score": 0.03648, "epss_percentile": 0.87505}, "CVE-2009-2671": {"epss_score": 0.06121, "epss_percentile": 0.90495}, "CVE-2009-2672": {"epss_score": 0.12989, "epss_percentile": 0.93837}, "CVE-2009-2673": {"epss_score": 0.11393, "epss_percentile": 0.93332}, "CVE-2009-2674": {"epss_score": 0.0398, "epss_percentile": 0.88057}, "CVE-2009-2675": {"epss_score": 0.06835, "epss_percentile": 0.91057}, "CVE-2009-2676": {"epss_score": 0.13091, "epss_percentile": 0.93872}, "CVE-2009-2677": {"epss_score": 0.00063, "epss_percentile": 0.19942}, "CVE-2009-2678": {"epss_score": 0.00321, "epss_percentile": 0.54741}, "CVE-2009-2679": {"epss_score": 0.01399, "epss_percentile": 0.79999}, "CVE-2009-2680": {"epss_score": 0.0243, "epss_percentile": 0.84727}, "CVE-2009-2681": {"epss_score": 0.00035, "epss_percentile": 0.09998}, "CVE-2009-2682": {"epss_score": 0.00047, "epss_percentile": 0.14663}, "CVE-2009-2683": {"epss_score": 0.00298, "epss_percentile": 0.52818}, "CVE-2009-2684": {"epss_score": 0.06501, "epss_percentile": 0.90802}, "CVE-2009-2685": {"epss_score": 0.76735, "epss_percentile": 0.98902}, "CVE-2009-2686": {"epss_score": 0.00048, "epss_percentile": 0.15023}, "CVE-2009-2687": {"epss_score": 0.12458, "epss_percentile": 0.93679}, "CVE-2009-2688": {"epss_score": 0.03662, "epss_percentile": 0.87529}, "CVE-2009-2689": {"epss_score": 0.07506, "epss_percentile": 0.91509}, "CVE-2009-2690": {"epss_score": 0.04366, "epss_percentile": 0.88603}, "CVE-2009-2691": {"epss_score": 0.00057, "epss_percentile": 0.18178}, "CVE-2009-2692": {"epss_score": 0.14608, "epss_percentile": 0.9425}, "CVE-2009-2693": {"epss_score": 0.15322, "epss_percentile": 0.94409}, "CVE-2009-2694": {"epss_score": 0.33349, "epss_percentile": 0.96765}, "CVE-2009-2695": {"epss_score": 0.00078, "epss_percentile": 0.23602}, "CVE-2009-2696": {"epss_score": 0.00882, "epss_percentile": 0.74884}, "CVE-2009-2697": {"epss_score": 0.00203, "epss_percentile": 0.42536}, "CVE-2009-2698": {"epss_score": 0.23059, "epss_percentile": 0.95727}, "CVE-2009-2699": {"epss_score": 0.08727, "epss_percentile": 0.9223}, "CVE-2009-2700": {"epss_score": 0.00285, "epss_percentile": 0.51552}, "CVE-2009-2701": {"epss_score": 0.00419, "epss_percentile": 0.61398}, "CVE-2009-2702": {"epss_score": 0.0035, "epss_percentile": 0.5696}, "CVE-2009-2703": {"epss_score": 0.00643, "epss_percentile": 0.70056}, "CVE-2009-2704": {"epss_score": 0.0017, "epss_percentile": 0.38731}, "CVE-2009-2705": {"epss_score": 0.01509, "epss_percentile": 0.80768}, "CVE-2009-2707": {"epss_score": 0.00034, "epss_percentile": 0.09458}, "CVE-2009-2711": {"epss_score": 0.0007, "epss_percentile": 0.21711}, "CVE-2009-2712": {"epss_score": 0.00057, "epss_percentile": 0.17984}, "CVE-2009-2713": {"epss_score": 0.00417, "epss_percentile": 0.61235}, "CVE-2009-2714": {"epss_score": 0.00053, "epss_percentile": 0.16864}, "CVE-2009-2715": {"epss_score": 0.00191, "epss_percentile": 0.41207}, "CVE-2009-2716": {"epss_score": 0.00302, "epss_percentile": 0.53125}, "CVE-2009-2717": {"epss_score": 0.00327, "epss_percentile": 0.55108}, "CVE-2009-2718": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2009-2719": {"epss_score": 0.00643, "epss_percentile": 0.70056}, "CVE-2009-2720": {"epss_score": 0.00643, "epss_percentile": 0.70056}, "CVE-2009-2721": {"epss_score": 0.0104, "epss_percentile": 0.76954}, "CVE-2009-2722": {"epss_score": 0.03966, "epss_percentile": 0.8803}, "CVE-2009-2723": {"epss_score": 0.04342, "epss_percentile": 0.88571}, "CVE-2009-2724": {"epss_score": 0.00517, "epss_percentile": 0.66068}, "CVE-2009-2726": {"epss_score": 0.3069, "epss_percentile": 0.96561}, "CVE-2009-2727": {"epss_score": 0.7763, "epss_percentile": 0.98944}, "CVE-2009-2730": {"epss_score": 0.02695, "epss_percentile": 0.85442}, "CVE-2009-2732": {"epss_score": 0.05006, "epss_percentile": 0.89385}, "CVE-2009-2733": {"epss_score": 0.02761, "epss_percentile": 0.85602}, "CVE-2009-2734": {"epss_score": 0.00406, "epss_percentile": 0.60556}, "CVE-2009-2735": {"epss_score": 0.00195, "epss_percentile": 0.41664}, "CVE-2009-2736": {"epss_score": 0.01511, "epss_percentile": 0.80779}, "CVE-2009-2737": {"epss_score": 0.01065, "epss_percentile": 0.77205}, "CVE-2009-2738": {"epss_score": 0.00247, "epss_percentile": 0.47876}, "CVE-2009-2739": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-2740": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2009-2741": {"epss_score": 0.02678, "epss_percentile": 0.85409}, "CVE-2009-2742": {"epss_score": 0.0023, "epss_percentile": 0.45669}, "CVE-2009-2743": {"epss_score": 0.00064, "epss_percentile": 0.20422}, "CVE-2009-2744": {"epss_score": 0.00836, "epss_percentile": 0.74132}, "CVE-2009-2746": {"epss_score": 0.00155, "epss_percentile": 0.36769}, "CVE-2009-2747": {"epss_score": 0.00207, "epss_percentile": 0.43081}, "CVE-2009-2748": {"epss_score": 0.00229, "epss_percentile": 0.45559}, "CVE-2009-2749": {"epss_score": 0.00435, "epss_percentile": 0.62326}, "CVE-2009-2750": {"epss_score": 0.0016, "epss_percentile": 0.37441}, "CVE-2009-2751": {"epss_score": 0.00139, "epss_percentile": 0.34614}, "CVE-2009-2752": {"epss_score": 0.00059, "epss_percentile": 0.18616}, "CVE-2009-2753": {"epss_score": 0.23224, "epss_percentile": 0.95753}, "CVE-2009-2754": {"epss_score": 0.30961, "epss_percentile": 0.96578}, "CVE-2009-2761": {"epss_score": 0.00053, "epss_percentile": 0.1671}, "CVE-2009-2762": {"epss_score": 0.74127, "epss_percentile": 0.98789}, "CVE-2009-2764": {"epss_score": 0.2262, "epss_percentile": 0.95659}, "CVE-2009-2765": {"epss_score": 0.9168, "epss_percentile": 0.99662}, "CVE-2009-2766": {"epss_score": 0.01411, "epss_percentile": 0.80108}, "CVE-2009-2767": {"epss_score": 0.00124, "epss_percentile": 0.3239}, "CVE-2009-2768": {"epss_score": 0.00085, "epss_percentile": 0.25142}, "CVE-2009-2769": {"epss_score": 0.00495, "epss_percentile": 0.65107}, "CVE-2009-2770": {"epss_score": 0.01281, "epss_percentile": 0.79149}, "CVE-2009-2771": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-2772": {"epss_score": 0.0377, "epss_percentile": 0.87701}, "CVE-2009-2773": {"epss_score": 0.01245, "epss_percentile": 0.78846}, "CVE-2009-2774": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-2775": {"epss_score": 0.00141, "epss_percentile": 0.34848}, "CVE-2009-2776": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2009-2777": {"epss_score": 0.00173, "epss_percentile": 0.39084}, "CVE-2009-2778": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2009-2779": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-2780": {"epss_score": 0.01639, "epss_percentile": 0.81492}, "CVE-2009-2781": {"epss_score": 0.0012, "epss_percentile": 0.31734}, "CVE-2009-2782": {"epss_score": 0.00141, "epss_percentile": 0.34848}, "CVE-2009-2783": {"epss_score": 0.07274, "epss_percentile": 0.91378}, "CVE-2009-2784": {"epss_score": 0.00835, "epss_percentile": 0.74114}, "CVE-2009-2785": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2009-2786": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2009-2787": {"epss_score": 0.02144, "epss_percentile": 0.83762}, "CVE-2009-2788": {"epss_score": 0.00141, "epss_percentile": 0.34848}, "CVE-2009-2789": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2009-2790": {"epss_score": 0.00127, "epss_percentile": 0.32871}, "CVE-2009-2791": {"epss_score": 0.00895, "epss_percentile": 0.75105}, "CVE-2009-2792": {"epss_score": 0.00908, "epss_percentile": 0.75285}, "CVE-2009-2793": {"epss_score": 0.0024, "epss_percentile": 0.46956}, "CVE-2009-2794": {"epss_score": 0.00048, "epss_percentile": 0.14965}, "CVE-2009-2795": {"epss_score": 0.0007, "epss_percentile": 0.21816}, "CVE-2009-2796": {"epss_score": 0.00066, "epss_percentile": 0.20882}, "CVE-2009-2797": {"epss_score": 0.0196, "epss_percentile": 0.83056}, "CVE-2009-2798": {"epss_score": 0.07937, "epss_percentile": 0.91776}, "CVE-2009-2799": {"epss_score": 0.07937, "epss_percentile": 0.91776}, "CVE-2009-2800": {"epss_score": 0.00963, "epss_percentile": 0.76003}, "CVE-2009-2801": {"epss_score": 0.00198, "epss_percentile": 0.42084}, "CVE-2009-2802": {"epss_score": 0.0045, "epss_percentile": 0.631}, "CVE-2009-2803": {"epss_score": 0.0089, "epss_percentile": 0.7503}, "CVE-2009-2804": {"epss_score": 0.09194, "epss_percentile": 0.92441}, "CVE-2009-2805": {"epss_score": 0.02424, "epss_percentile": 0.84713}, "CVE-2009-2807": {"epss_score": 0.00065, "epss_percentile": 0.20569}, "CVE-2009-2808": {"epss_score": 0.0008, "epss_percentile": 0.2419}, "CVE-2009-2809": {"epss_score": 0.02414, "epss_percentile": 0.84683}, "CVE-2009-2810": {"epss_score": 0.0165, "epss_percentile": 0.81566}, "CVE-2009-2811": {"epss_score": 0.02518, "epss_percentile": 0.84992}, "CVE-2009-2812": {"epss_score": 0.01744, "epss_percentile": 0.82064}, "CVE-2009-2813": {"epss_score": 0.00847, "epss_percentile": 0.7435}, "CVE-2009-2814": {"epss_score": 0.00499, "epss_percentile": 0.65274}, "CVE-2009-2815": {"epss_score": 0.00547, "epss_percentile": 0.67255}, "CVE-2009-2816": {"epss_score": 0.02154, "epss_percentile": 0.83797}, "CVE-2009-2817": {"epss_score": 0.19849, "epss_percentile": 0.9525}, "CVE-2009-2818": {"epss_score": 0.00421, "epss_percentile": 0.61516}, "CVE-2009-2819": {"epss_score": 0.00729, "epss_percentile": 0.72124}, "CVE-2009-2820": {"epss_score": 0.01995, "epss_percentile": 0.83191}, "CVE-2009-2822": {"epss_score": 0.00468, "epss_percentile": 0.63881}, "CVE-2009-2823": {"epss_score": 0.00274, "epss_percentile": 0.5058}, "CVE-2009-2824": {"epss_score": 0.02571, "epss_percentile": 0.8513}, "CVE-2009-2825": {"epss_score": 0.00134, "epss_percentile": 0.33895}, "CVE-2009-2826": {"epss_score": 0.01892, "epss_percentile": 0.82733}, "CVE-2009-2827": {"epss_score": 0.01901, "epss_percentile": 0.82779}, "CVE-2009-2828": {"epss_score": 0.02313, "epss_percentile": 0.84344}, "CVE-2009-2829": {"epss_score": 0.00747, "epss_percentile": 0.72562}, "CVE-2009-2830": {"epss_score": 0.01614, "epss_percentile": 0.81344}, "CVE-2009-2831": {"epss_score": 0.00353, "epss_percentile": 0.57162}, "CVE-2009-2832": {"epss_score": 0.0184, "epss_percentile": 0.82493}, "CVE-2009-2833": {"epss_score": 0.0067, "epss_percentile": 0.70779}, "CVE-2009-2834": {"epss_score": 0.00071, "epss_percentile": 0.22222}, "CVE-2009-2835": {"epss_score": 0.00068, "epss_percentile": 0.2137}, "CVE-2009-2836": {"epss_score": 0.0004, "epss_percentile": 0.11972}, "CVE-2009-2837": {"epss_score": 0.02777, "epss_percentile": 0.85641}, "CVE-2009-2838": {"epss_score": 0.01892, "epss_percentile": 0.82733}, "CVE-2009-2839": {"epss_score": 0.00747, "epss_percentile": 0.72568}, "CVE-2009-2840": {"epss_score": 0.00057, "epss_percentile": 0.18083}, "CVE-2009-2841": {"epss_score": 0.03879, "epss_percentile": 0.87894}, "CVE-2009-2842": {"epss_score": 0.0083, "epss_percentile": 0.74022}, "CVE-2009-2843": {"epss_score": 0.01018, "epss_percentile": 0.76705}, "CVE-2009-2844": {"epss_score": 0.01735, "epss_percentile": 0.82006}, "CVE-2009-2846": {"epss_score": 0.00314, "epss_percentile": 0.54085}, "CVE-2009-2847": {"epss_score": 0.00193, "epss_percentile": 0.41456}, "CVE-2009-2848": {"epss_score": 0.00089, "epss_percentile": 0.25835}, "CVE-2009-2849": {"epss_score": 0.00125, "epss_percentile": 0.32513}, "CVE-2009-2850": {"epss_score": 0.01515, "epss_percentile": 0.80796}, "CVE-2009-2851": {"epss_score": 0.02987, "epss_percentile": 0.86136}, "CVE-2009-2852": {"epss_score": 0.02191, "epss_percentile": 0.83938}, "CVE-2009-2853": {"epss_score": 0.01198, "epss_percentile": 0.7845}, "CVE-2009-2854": {"epss_score": 0.01415, "epss_percentile": 0.80138}, "CVE-2009-2855": {"epss_score": 0.60658, "epss_percentile": 0.98215}, "CVE-2009-2856": {"epss_score": 0.00201, "epss_percentile": 0.42353}, "CVE-2009-2857": {"epss_score": 0.00111, "epss_percentile": 0.30398}, "CVE-2009-2858": {"epss_score": 0.00371, "epss_percentile": 0.58344}, "CVE-2009-2859": {"epss_score": 0.00072, "epss_percentile": 0.22413}, "CVE-2009-2860": {"epss_score": 0.0107, "epss_percentile": 0.77254}, "CVE-2009-2861": {"epss_score": 0.00741, "epss_percentile": 0.72446}, "CVE-2009-2862": {"epss_score": 0.00521, "epss_percentile": 0.66246}, "CVE-2009-2863": {"epss_score": 0.00406, "epss_percentile": 0.60535}, "CVE-2009-2864": {"epss_score": 0.01385, "epss_percentile": 0.79904}, "CVE-2009-2865": {"epss_score": 0.03258, "epss_percentile": 0.86766}, "CVE-2009-2866": {"epss_score": 0.01683, "epss_percentile": 0.81739}, "CVE-2009-2867": {"epss_score": 0.00798, "epss_percentile": 0.73509}, "CVE-2009-2868": {"epss_score": 0.00451, "epss_percentile": 0.63148}, "CVE-2009-2869": {"epss_score": 0.01653, "epss_percentile": 0.81583}, "CVE-2009-2870": {"epss_score": 0.00726, "epss_percentile": 0.72077}, "CVE-2009-2871": {"epss_score": 0.00726, "epss_percentile": 0.72077}, "CVE-2009-2872": {"epss_score": 0.01117, "epss_percentile": 0.77736}, "CVE-2009-2873": {"epss_score": 0.00781, "epss_percentile": 0.73184}, "CVE-2009-2874": {"epss_score": 0.0276, "epss_percentile": 0.85599}, "CVE-2009-2875": {"epss_score": 0.02457, "epss_percentile": 0.84802}, "CVE-2009-2876": {"epss_score": 0.0252, "epss_percentile": 0.84999}, "CVE-2009-2877": {"epss_score": 0.02457, "epss_percentile": 0.84802}, "CVE-2009-2878": {"epss_score": 0.0252, "epss_percentile": 0.84999}, "CVE-2009-2879": {"epss_score": 0.02457, "epss_percentile": 0.84802}, "CVE-2009-2880": {"epss_score": 0.02457, "epss_percentile": 0.84802}, "CVE-2009-2881": {"epss_score": 0.00411, "epss_percentile": 0.60872}, "CVE-2009-2882": {"epss_score": 0.0022, "epss_percentile": 0.44615}, "CVE-2009-2883": {"epss_score": 0.00147, "epss_percentile": 0.35752}, "CVE-2009-2884": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-2885": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2009-2886": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2009-2887": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-2888": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2009-2889": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-2890": {"epss_score": 0.01585, "epss_percentile": 0.81164}, "CVE-2009-2891": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2009-2892": {"epss_score": 0.00202, "epss_percentile": 0.42415}, "CVE-2009-2893": {"epss_score": 0.00734, "epss_percentile": 0.7224}, "CVE-2009-2894": {"epss_score": 0.00456, "epss_percentile": 0.63328}, "CVE-2009-2895": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-2896": {"epss_score": 0.06157, "epss_percentile": 0.90525}, "CVE-2009-2897": {"epss_score": 0.00666, "epss_percentile": 0.70675}, "CVE-2009-2898": {"epss_score": 0.01268, "epss_percentile": 0.79034}, "CVE-2009-2899": {"epss_score": 0.00041, "epss_percentile": 0.12339}, "CVE-2009-2901": {"epss_score": 0.06552, "epss_percentile": 0.90844}, "CVE-2009-2902": {"epss_score": 0.1008, "epss_percentile": 0.92842}, "CVE-2009-2903": {"epss_score": 0.03773, "epss_percentile": 0.87704}, "CVE-2009-2904": {"epss_score": 0.00039, "epss_percentile": 0.11796}, "CVE-2009-2905": {"epss_score": 0.00078, "epss_percentile": 0.23633}, "CVE-2009-2906": {"epss_score": 0.00397, "epss_percentile": 0.59963}, "CVE-2009-2907": {"epss_score": 0.00238, "epss_percentile": 0.46826}, "CVE-2009-2908": {"epss_score": 0.01478, "epss_percentile": 0.80557}, "CVE-2009-2909": {"epss_score": 0.00044, "epss_percentile": 0.13524}, "CVE-2009-2910": {"epss_score": 0.00052, "epss_percentile": 0.16477}, "CVE-2009-2911": {"epss_score": 0.00082, "epss_percentile": 0.24589}, "CVE-2009-2912": {"epss_score": 0.00054, "epss_percentile": 0.17322}, "CVE-2009-2913": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-2914": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-2915": {"epss_score": 0.0013, "epss_percentile": 0.33306}, "CVE-2009-2916": {"epss_score": 0.02429, "epss_percentile": 0.84724}, "CVE-2009-2917": {"epss_score": 0.04601, "epss_percentile": 0.88904}, "CVE-2009-2918": {"epss_score": 0.00157, "epss_percentile": 0.37095}, "CVE-2009-2919": {"epss_score": 0.00179, "epss_percentile": 0.39815}, "CVE-2009-2920": {"epss_score": 0.00138, "epss_percentile": 0.34408}, "CVE-2009-2921": {"epss_score": 0.00411, "epss_percentile": 0.60872}, "CVE-2009-2922": {"epss_score": 0.01918, "epss_percentile": 0.82881}, "CVE-2009-2923": {"epss_score": 0.04128, "epss_percentile": 0.88294}, "CVE-2009-2924": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-2925": {"epss_score": 0.03404, "epss_percentile": 0.87072}, "CVE-2009-2926": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-2927": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-2928": {"epss_score": 0.00138, "epss_percentile": 0.34408}, "CVE-2009-2929": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-2930": {"epss_score": 0.00164, "epss_percentile": 0.37975}, "CVE-2009-2931": {"epss_score": 0.00417, "epss_percentile": 0.61225}, "CVE-2009-2932": {"epss_score": 0.00381, "epss_percentile": 0.58981}, "CVE-2009-2933": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-2934": {"epss_score": 0.10268, "epss_percentile": 0.9292}, "CVE-2009-2935": {"epss_score": 0.02333, "epss_percentile": 0.84411}, "CVE-2009-2936": {"epss_score": 0.6839, "epss_percentile": 0.98544}, "CVE-2009-2937": {"epss_score": 0.02622, "epss_percentile": 0.85256}, "CVE-2009-2939": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2009-2940": {"epss_score": 0.00576, "epss_percentile": 0.68122}, "CVE-2009-2942": {"epss_score": 0.0059, "epss_percentile": 0.68547}, "CVE-2009-2943": {"epss_score": 0.00441, "epss_percentile": 0.62681}, "CVE-2009-2944": {"epss_score": 0.00531, "epss_percentile": 0.66643}, "CVE-2009-2945": {"epss_score": 0.00229, "epss_percentile": 0.45572}, "CVE-2009-2946": {"epss_score": 0.00878, "epss_percentile": 0.74821}, "CVE-2009-2947": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2009-2948": {"epss_score": 0.00211, "epss_percentile": 0.43642}, "CVE-2009-2949": {"epss_score": 0.57887, "epss_percentile": 0.9809}, "CVE-2009-2950": {"epss_score": 0.24602, "epss_percentile": 0.95937}, "CVE-2009-2951": {"epss_score": 0.00159, "epss_percentile": 0.37367}, "CVE-2009-2952": {"epss_score": 0.0004, "epss_percentile": 0.11997}, "CVE-2009-2953": {"epss_score": 0.02596, "epss_percentile": 0.85194}, "CVE-2009-2954": {"epss_score": 0.13654, "epss_percentile": 0.94022}, "CVE-2009-2955": {"epss_score": 0.0031, "epss_percentile": 0.53751}, "CVE-2009-2956": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2009-2957": {"epss_score": 0.08525, "epss_percentile": 0.92103}, "CVE-2009-2958": {"epss_score": 0.01131, "epss_percentile": 0.77863}, "CVE-2009-2959": {"epss_score": 0.00467, "epss_percentile": 0.63861}, "CVE-2009-2960": {"epss_score": 0.01698, "epss_percentile": 0.81822}, "CVE-2009-2961": {"epss_score": 0.0497, "epss_percentile": 0.8935}, "CVE-2009-2963": {"epss_score": 0.02083, "epss_percentile": 0.8354}, "CVE-2009-2964": {"epss_score": 0.00612, "epss_percentile": 0.69228}, "CVE-2009-2965": {"epss_score": 0.00164, "epss_percentile": 0.37975}, "CVE-2009-2966": {"epss_score": 0.11233, "epss_percentile": 0.93273}, "CVE-2009-2967": {"epss_score": 0.00604, "epss_percentile": 0.68963}, "CVE-2009-2968": {"epss_score": 0.00423, "epss_percentile": 0.616}, "CVE-2009-2970": {"epss_score": 0.05849, "epss_percentile": 0.90261}, "CVE-2009-2972": {"epss_score": 0.01517, "epss_percentile": 0.8081}, "CVE-2009-2973": {"epss_score": 0.00116, "epss_percentile": 0.3111}, "CVE-2009-2974": {"epss_score": 0.00543, "epss_percentile": 0.67123}, "CVE-2009-2975": {"epss_score": 0.00955, "epss_percentile": 0.75916}, "CVE-2009-2976": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2009-2977": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2009-2978": {"epss_score": 0.00836, "epss_percentile": 0.74149}, "CVE-2009-2979": {"epss_score": 0.01788, "epss_percentile": 0.82268}, "CVE-2009-2980": {"epss_score": 0.48748, "epss_percentile": 0.97652}, "CVE-2009-2981": {"epss_score": 0.07238, "epss_percentile": 0.91342}, "CVE-2009-2982": {"epss_score": 0.01021, "epss_percentile": 0.76745}, "CVE-2009-2983": {"epss_score": 0.4391, "epss_percentile": 0.97407}, "CVE-2009-2984": {"epss_score": 0.45202, "epss_percentile": 0.97476}, "CVE-2009-2985": {"epss_score": 0.19987, "epss_percentile": 0.95271}, "CVE-2009-2986": {"epss_score": 0.37028, "epss_percentile": 0.97015}, "CVE-2009-2987": {"epss_score": 0.01376, "epss_percentile": 0.79834}, "CVE-2009-2988": {"epss_score": 0.01341, "epss_percentile": 0.79583}, "CVE-2009-2989": {"epss_score": 0.51724, "epss_percentile": 0.97796}, "CVE-2009-2990": {"epss_score": 0.87912, "epss_percentile": 0.99449}, "CVE-2009-2991": {"epss_score": 0.21854, "epss_percentile": 0.95568}, "CVE-2009-2992": {"epss_score": 0.02148, "epss_percentile": 0.83774}, "CVE-2009-2993": {"epss_score": 0.09132, "epss_percentile": 0.92416}, "CVE-2009-2994": {"epss_score": 0.51022, "epss_percentile": 0.97759}, "CVE-2009-2995": {"epss_score": 0.01465, "epss_percentile": 0.80455}, "CVE-2009-2996": {"epss_score": 0.19987, "epss_percentile": 0.95271}, "CVE-2009-2997": {"epss_score": 0.37028, "epss_percentile": 0.97015}, "CVE-2009-2998": {"epss_score": 0.49031, "epss_percentile": 0.97664}, "CVE-2009-2999": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2009-3000": {"epss_score": 0.00423, "epss_percentile": 0.61633}, "CVE-2009-3001": {"epss_score": 0.00087, "epss_percentile": 0.25594}, "CVE-2009-3002": {"epss_score": 0.00304, "epss_percentile": 0.53306}, "CVE-2009-3003": {"epss_score": 0.2266, "epss_percentile": 0.95666}, "CVE-2009-3004": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2009-3005": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2009-3006": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2009-3007": {"epss_score": 0.0025, "epss_percentile": 0.48105}, "CVE-2009-3008": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2009-3009": {"epss_score": 0.01632, "epss_percentile": 0.81457}, "CVE-2009-3010": {"epss_score": 0.0039, "epss_percentile": 0.59555}, "CVE-2009-3011": {"epss_score": 0.00244, "epss_percentile": 0.47573}, "CVE-2009-3012": {"epss_score": 0.00245, "epss_percentile": 0.47691}, "CVE-2009-3013": {"epss_score": 0.00276, "epss_percentile": 0.50754}, "CVE-2009-3014": {"epss_score": 0.00286, "epss_percentile": 0.51709}, "CVE-2009-3015": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2009-3016": {"epss_score": 0.00276, "epss_percentile": 0.50754}, "CVE-2009-3017": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2009-3018": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-3019": {"epss_score": 0.0716, "epss_percentile": 0.91291}, "CVE-2009-3020": {"epss_score": 0.30688, "epss_percentile": 0.96561}, "CVE-2009-3021": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-3022": {"epss_score": 0.00161, "epss_percentile": 0.37587}, "CVE-2009-3023": {"epss_score": 0.77219, "epss_percentile": 0.98926}, "CVE-2009-3024": {"epss_score": 0.00202, "epss_percentile": 0.42428}, "CVE-2009-3025": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2009-3026": {"epss_score": 0.00526, "epss_percentile": 0.66437}, "CVE-2009-3027": {"epss_score": 0.43912, "epss_percentile": 0.97408}, "CVE-2009-3028": {"epss_score": 0.70306, "epss_percentile": 0.98628}, "CVE-2009-3029": {"epss_score": 0.00507, "epss_percentile": 0.65656}, "CVE-2009-3030": {"epss_score": 0.00779, "epss_percentile": 0.73155}, "CVE-2009-3031": {"epss_score": 0.76853, "epss_percentile": 0.98908}, "CVE-2009-3032": {"epss_score": 0.019, "epss_percentile": 0.82771}, "CVE-2009-3033": {"epss_score": 0.72538, "epss_percentile": 0.98716}, "CVE-2009-3035": {"epss_score": 0.00091, "epss_percentile": 0.26406}, "CVE-2009-3036": {"epss_score": 0.00754, "epss_percentile": 0.72697}, "CVE-2009-3037": {"epss_score": 0.16842, "epss_percentile": 0.94737}, "CVE-2009-3038": {"epss_score": 0.05847, "epss_percentile": 0.90259}, "CVE-2009-3040": {"epss_score": 0.00135, "epss_percentile": 0.33946}, "CVE-2009-3041": {"epss_score": 0.03841, "epss_percentile": 0.87831}, "CVE-2009-3042": {"epss_score": 0.00207, "epss_percentile": 0.43076}, "CVE-2009-3043": {"epss_score": 0.00128, "epss_percentile": 0.33036}, "CVE-2009-3044": {"epss_score": 0.00327, "epss_percentile": 0.55101}, "CVE-2009-3045": {"epss_score": 0.0025, "epss_percentile": 0.48103}, "CVE-2009-3046": {"epss_score": 0.00143, "epss_percentile": 0.35106}, "CVE-2009-3047": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2009-3048": {"epss_score": 0.00323, "epss_percentile": 0.54863}, "CVE-2009-3049": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2009-3050": {"epss_score": 0.01493, "epss_percentile": 0.80639}, "CVE-2009-3051": {"epss_score": 0.09092, "epss_percentile": 0.92398}, "CVE-2009-3052": {"epss_score": 0.00179, "epss_percentile": 0.39751}, "CVE-2009-3053": {"epss_score": 0.01573, "epss_percentile": 0.81101}, "CVE-2009-3054": {"epss_score": 0.00147, "epss_percentile": 0.35752}, "CVE-2009-3055": {"epss_score": 0.00862, "epss_percentile": 0.74576}, "CVE-2009-3056": {"epss_score": 0.0059, "epss_percentile": 0.68562}, "CVE-2009-3057": {"epss_score": 0.00173, "epss_percentile": 0.39051}, "CVE-2009-3058": {"epss_score": 0.07689, "epss_percentile": 0.91628}, "CVE-2009-3059": {"epss_score": 0.0013, "epss_percentile": 0.33306}, "CVE-2009-3060": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-3061": {"epss_score": 0.0013, "epss_percentile": 0.33306}, "CVE-2009-3062": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3063": {"epss_score": 0.0016, "epss_percentile": 0.37494}, "CVE-2009-3064": {"epss_score": 0.00839, "epss_percentile": 0.74189}, "CVE-2009-3065": {"epss_score": 0.0085, "epss_percentile": 0.74384}, "CVE-2009-3066": {"epss_score": 0.00173, "epss_percentile": 0.39051}, "CVE-2009-3067": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-3068": {"epss_score": 0.90721, "epss_percentile": 0.99596}, "CVE-2009-3069": {"epss_score": 0.05841, "epss_percentile": 0.90251}, "CVE-2009-3070": {"epss_score": 0.04029, "epss_percentile": 0.88149}, "CVE-2009-3071": {"epss_score": 0.03163, "epss_percentile": 0.86534}, "CVE-2009-3072": {"epss_score": 0.04749, "epss_percentile": 0.89101}, "CVE-2009-3073": {"epss_score": 0.06501, "epss_percentile": 0.90801}, "CVE-2009-3074": {"epss_score": 0.06345, "epss_percentile": 0.90687}, "CVE-2009-3075": {"epss_score": 0.06395, "epss_percentile": 0.90722}, "CVE-2009-3076": {"epss_score": 0.17599, "epss_percentile": 0.94872}, "CVE-2009-3077": {"epss_score": 0.0543, "epss_percentile": 0.89875}, "CVE-2009-3078": {"epss_score": 0.01724, "epss_percentile": 0.81949}, "CVE-2009-3079": {"epss_score": 0.0151, "epss_percentile": 0.80772}, "CVE-2009-3080": {"epss_score": 0.0007, "epss_percentile": 0.21931}, "CVE-2009-3081": {"epss_score": 0.00142, "epss_percentile": 0.35081}, "CVE-2009-3082": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2009-3083": {"epss_score": 0.01284, "epss_percentile": 0.79167}, "CVE-2009-3084": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2009-3085": {"epss_score": 0.00949, "epss_percentile": 0.7584}, "CVE-2009-3086": {"epss_score": 0.00556, "epss_percentile": 0.67525}, "CVE-2009-3087": {"epss_score": 0.00711, "epss_percentile": 0.71729}, "CVE-2009-3088": {"epss_score": 0.0065, "epss_percentile": 0.7026}, "CVE-2009-3089": {"epss_score": 0.00533, "epss_percentile": 0.66775}, "CVE-2009-3090": {"epss_score": 0.00572, "epss_percentile": 0.68003}, "CVE-2009-3091": {"epss_score": 0.0033, "epss_percentile": 0.55416}, "CVE-2009-3092": {"epss_score": 0.00446, "epss_percentile": 0.62918}, "CVE-2009-3093": {"epss_score": 0.004, "epss_percentile": 0.60155}, "CVE-2009-3094": {"epss_score": 0.02833, "epss_percentile": 0.85781}, "CVE-2009-3095": {"epss_score": 0.0303, "epss_percentile": 0.86246}, "CVE-2009-3096": {"epss_score": 0.01496, "epss_percentile": 0.80685}, "CVE-2009-3097": {"epss_score": 0.00586, "epss_percentile": 0.68453}, "CVE-2009-3098": {"epss_score": 0.00943, "epss_percentile": 0.7577}, "CVE-2009-3099": {"epss_score": 0.11317, "epss_percentile": 0.93304}, "CVE-2009-3100": {"epss_score": 0.00034, "epss_percentile": 0.09627}, "CVE-2009-3101": {"epss_score": 0.00039, "epss_percentile": 0.11626}, "CVE-2009-3102": {"epss_score": 0.06449, "epss_percentile": 0.90763}, "CVE-2009-3103": {"epss_score": 0.92944, "epss_percentile": 0.99762}, "CVE-2009-3104": {"epss_score": 0.01594, "epss_percentile": 0.81231}, "CVE-2009-3105": {"epss_score": 0.00287, "epss_percentile": 0.51862}, "CVE-2009-3106": {"epss_score": 0.00112, "epss_percentile": 0.30578}, "CVE-2009-3107": {"epss_score": 0.00377, "epss_percentile": 0.58718}, "CVE-2009-3108": {"epss_score": 0.00042, "epss_percentile": 0.12935}, "CVE-2009-3109": {"epss_score": 0.00383, "epss_percentile": 0.59089}, "CVE-2009-3110": {"epss_score": 0.00662, "epss_percentile": 0.70607}, "CVE-2009-3111": {"epss_score": 0.17898, "epss_percentile": 0.94924}, "CVE-2009-3112": {"epss_score": 0.00766, "epss_percentile": 0.7294}, "CVE-2009-3113": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2009-3114": {"epss_score": 0.00772, "epss_percentile": 0.73037}, "CVE-2009-3115": {"epss_score": 0.05637, "epss_percentile": 0.90072}, "CVE-2009-3116": {"epss_score": 0.00217, "epss_percentile": 0.44301}, "CVE-2009-3117": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2009-3118": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2009-3119": {"epss_score": 0.00149, "epss_percentile": 0.35955}, "CVE-2009-3120": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-3121": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-3122": {"epss_score": 0.00595, "epss_percentile": 0.68683}, "CVE-2009-3123": {"epss_score": 0.03471, "epss_percentile": 0.87199}, "CVE-2009-3124": {"epss_score": 0.01577, "epss_percentile": 0.8112}, "CVE-2009-3125": {"epss_score": 0.00328, "epss_percentile": 0.55186}, "CVE-2009-3126": {"epss_score": 0.50941, "epss_percentile": 0.97757}, "CVE-2009-3127": {"epss_score": 0.60932, "epss_percentile": 0.98228}, "CVE-2009-3128": {"epss_score": 0.57317, "epss_percentile": 0.98058}, "CVE-2009-3129": {"epss_score": 0.91648, "epss_percentile": 0.99661}, "CVE-2009-3130": {"epss_score": 0.63952, "epss_percentile": 0.98356}, "CVE-2009-3131": {"epss_score": 0.56564, "epss_percentile": 0.98029}, "CVE-2009-3132": {"epss_score": 0.56564, "epss_percentile": 0.98029}, "CVE-2009-3133": {"epss_score": 0.56564, "epss_percentile": 0.98029}, "CVE-2009-3134": {"epss_score": 0.57317, "epss_percentile": 0.98058}, "CVE-2009-3135": {"epss_score": 0.69661, "epss_percentile": 0.98597}, "CVE-2009-3146": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-3147": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-3148": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-3149": {"epss_score": 0.0139, "epss_percentile": 0.79935}, "CVE-2009-3150": {"epss_score": 0.00117, "epss_percentile": 0.31207}, "CVE-2009-3151": {"epss_score": 0.0119, "epss_percentile": 0.78377}, "CVE-2009-3152": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-3153": {"epss_score": 0.00399, "epss_percentile": 0.60109}, "CVE-2009-3154": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3155": {"epss_score": 0.00846, "epss_percentile": 0.74323}, "CVE-2009-3156": {"epss_score": 0.00602, "epss_percentile": 0.68876}, "CVE-2009-3157": {"epss_score": 0.00262, "epss_percentile": 0.49364}, "CVE-2009-3158": {"epss_score": 0.018, "epss_percentile": 0.82317}, "CVE-2009-3159": {"epss_score": 0.00726, "epss_percentile": 0.72068}, "CVE-2009-3160": {"epss_score": 0.00656, "epss_percentile": 0.70447}, "CVE-2009-3161": {"epss_score": 0.00581, "epss_percentile": 0.68264}, "CVE-2009-3162": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-3163": {"epss_score": 0.0487, "epss_percentile": 0.89231}, "CVE-2009-3164": {"epss_score": 0.00859, "epss_percentile": 0.74515}, "CVE-2009-3165": {"epss_score": 0.00328, "epss_percentile": 0.55186}, "CVE-2009-3166": {"epss_score": 0.00357, "epss_percentile": 0.5747}, "CVE-2009-3167": {"epss_score": 0.04617, "epss_percentile": 0.88925}, "CVE-2009-3168": {"epss_score": 0.00899, "epss_percentile": 0.75153}, "CVE-2009-3169": {"epss_score": 0.03231, "epss_percentile": 0.86697}, "CVE-2009-3170": {"epss_score": 0.09927, "epss_percentile": 0.92776}, "CVE-2009-3171": {"epss_score": 0.01601, "epss_percentile": 0.81265}, "CVE-2009-3172": {"epss_score": 0.00668, "epss_percentile": 0.7073}, "CVE-2009-3173": {"epss_score": 0.02103, "epss_percentile": 0.8361}, "CVE-2009-3174": {"epss_score": 0.0059, "epss_percentile": 0.68562}, "CVE-2009-3175": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3176": {"epss_score": 0.05398, "epss_percentile": 0.89831}, "CVE-2009-3177": {"epss_score": 0.00446, "epss_percentile": 0.62897}, "CVE-2009-3178": {"epss_score": 0.00862, "epss_percentile": 0.74569}, "CVE-2009-3179": {"epss_score": 0.06633, "epss_percentile": 0.90904}, "CVE-2009-3180": {"epss_score": 0.01135, "epss_percentile": 0.77906}, "CVE-2009-3181": {"epss_score": 0.00864, "epss_percentile": 0.74604}, "CVE-2009-3182": {"epss_score": 0.0317, "epss_percentile": 0.86547}, "CVE-2009-3183": {"epss_score": 0.00042, "epss_percentile": 0.12879}, "CVE-2009-3184": {"epss_score": 0.00338, "epss_percentile": 0.56134}, "CVE-2009-3185": {"epss_score": 0.0013, "epss_percentile": 0.33306}, "CVE-2009-3186": {"epss_score": 0.00453, "epss_percentile": 0.63204}, "CVE-2009-3187": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2009-3188": {"epss_score": 0.00729, "epss_percentile": 0.72132}, "CVE-2009-3189": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2009-3190": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3191": {"epss_score": 0.00138, "epss_percentile": 0.34408}, "CVE-2009-3192": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-3193": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3194": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2009-3195": {"epss_score": 0.00804, "epss_percentile": 0.73612}, "CVE-2009-3196": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2009-3197": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-3198": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-3199": {"epss_score": 0.01612, "epss_percentile": 0.81338}, "CVE-2009-3200": {"epss_score": 0.00066, "epss_percentile": 0.20883}, "CVE-2009-3201": {"epss_score": 0.0266, "epss_percentile": 0.85365}, "CVE-2009-3202": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-3203": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2009-3204": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2009-3205": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2009-3206": {"epss_score": 0.00121, "epss_percentile": 0.31894}, "CVE-2009-3207": {"epss_score": 0.00763, "epss_percentile": 0.72854}, "CVE-2009-3208": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-3209": {"epss_score": 0.00169, "epss_percentile": 0.38555}, "CVE-2009-3210": {"epss_score": 0.00262, "epss_percentile": 0.49364}, "CVE-2009-3211": {"epss_score": 0.00908, "epss_percentile": 0.75285}, "CVE-2009-3212": {"epss_score": 0.00298, "epss_percentile": 0.52823}, "CVE-2009-3213": {"epss_score": 0.05335, "epss_percentile": 0.89742}, "CVE-2009-3214": {"epss_score": 0.64782, "epss_percentile": 0.98391}, "CVE-2009-3215": {"epss_score": 0.00243, "epss_percentile": 0.47454}, "CVE-2009-3216": {"epss_score": 0.0139, "epss_percentile": 0.79935}, "CVE-2009-3217": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-3218": {"epss_score": 0.00119, "epss_percentile": 0.31552}, "CVE-2009-3219": {"epss_score": 0.01877, "epss_percentile": 0.82666}, "CVE-2009-3220": {"epss_score": 0.00761, "epss_percentile": 0.72822}, "CVE-2009-3221": {"epss_score": 0.07676, "epss_percentile": 0.9162}, "CVE-2009-3222": {"epss_score": 0.01549, "epss_percentile": 0.8098}, "CVE-2009-3223": {"epss_score": 0.00127, "epss_percentile": 0.32808}, "CVE-2009-3224": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-3225": {"epss_score": 0.00804, "epss_percentile": 0.73612}, "CVE-2009-3226": {"epss_score": 0.00154, "epss_percentile": 0.36706}, "CVE-2009-3227": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-3228": {"epss_score": 0.00077, "epss_percentile": 0.2341}, "CVE-2009-3229": {"epss_score": 0.01327, "epss_percentile": 0.79485}, "CVE-2009-3230": {"epss_score": 0.00993, "epss_percentile": 0.76409}, "CVE-2009-3231": {"epss_score": 0.04962, "epss_percentile": 0.89335}, "CVE-2009-3232": {"epss_score": 0.00539, "epss_percentile": 0.6698}, "CVE-2009-3233": {"epss_score": 0.00226, "epss_percentile": 0.45264}, "CVE-2009-3234": {"epss_score": 0.00273, "epss_percentile": 0.50433}, "CVE-2009-3235": {"epss_score": 0.02782, "epss_percentile": 0.85654}, "CVE-2009-3236": {"epss_score": 0.00838, "epss_percentile": 0.74171}, "CVE-2009-3237": {"epss_score": 0.0076, "epss_percentile": 0.72803}, "CVE-2009-3238": {"epss_score": 0.00241, "epss_percentile": 0.47284}, "CVE-2009-3240": {"epss_score": 0.00262, "epss_percentile": 0.4936}, "CVE-2009-3241": {"epss_score": 0.05851, "epss_percentile": 0.90262}, "CVE-2009-3242": {"epss_score": 0.03885, "epss_percentile": 0.87902}, "CVE-2009-3243": {"epss_score": 0.04737, "epss_percentile": 0.89075}, "CVE-2009-3244": {"epss_score": 0.46114, "epss_percentile": 0.97529}, "CVE-2009-3245": {"epss_score": 0.19554, "epss_percentile": 0.95206}, "CVE-2009-3246": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2009-3247": {"epss_score": 0.04701, "epss_percentile": 0.89023}, "CVE-2009-3248": {"epss_score": 0.00273, "epss_percentile": 0.50473}, "CVE-2009-3249": {"epss_score": 0.25994, "epss_percentile": 0.96099}, "CVE-2009-3250": {"epss_score": 0.15858, "epss_percentile": 0.9452}, "CVE-2009-3251": {"epss_score": 0.00198, "epss_percentile": 0.42008}, "CVE-2009-3252": {"epss_score": 0.00142, "epss_percentile": 0.34996}, "CVE-2009-3253": {"epss_score": 0.05755, "epss_percentile": 0.9018}, "CVE-2009-3254": {"epss_score": 0.05086, "epss_percentile": 0.89479}, "CVE-2009-3255": {"epss_score": 0.00435, "epss_percentile": 0.62374}, "CVE-2009-3256": {"epss_score": 0.00142, "epss_percentile": 0.35029}, "CVE-2009-3257": {"epss_score": 0.00142, "epss_percentile": 0.3503}, "CVE-2009-3258": {"epss_score": 0.0044, "epss_percentile": 0.62625}, "CVE-2009-3259": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2009-3260": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-3261": {"epss_score": 0.00514, "epss_percentile": 0.65953}, "CVE-2009-3262": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2009-3263": {"epss_score": 0.0039, "epss_percentile": 0.59551}, "CVE-2009-3264": {"epss_score": 0.00177, "epss_percentile": 0.39575}, "CVE-2009-3265": {"epss_score": 0.00225, "epss_percentile": 0.45102}, "CVE-2009-3266": {"epss_score": 0.00795, "epss_percentile": 0.73463}, "CVE-2009-3267": {"epss_score": 0.13765, "epss_percentile": 0.94054}, "CVE-2009-3268": {"epss_score": 0.0031, "epss_percentile": 0.53751}, "CVE-2009-3269": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2009-3270": {"epss_score": 0.41509, "epss_percentile": 0.97279}, "CVE-2009-3271": {"epss_score": 0.05161, "epss_percentile": 0.8956}, "CVE-2009-3272": {"epss_score": 0.0444, "epss_percentile": 0.88693}, "CVE-2009-3273": {"epss_score": 0.0018, "epss_percentile": 0.39867}, "CVE-2009-3274": {"epss_score": 0.0014, "epss_percentile": 0.34693}, "CVE-2009-3275": {"epss_score": 0.09934, "epss_percentile": 0.92779}, "CVE-2009-3276": {"epss_score": 0.00305, "epss_percentile": 0.53327}, "CVE-2009-3277": {"epss_score": 0.00305, "epss_percentile": 0.53327}, "CVE-2009-3278": {"epss_score": 0.00074, "epss_percentile": 0.22745}, "CVE-2009-3279": {"epss_score": 0.00062, "epss_percentile": 0.19565}, "CVE-2009-3280": {"epss_score": 0.01823, "epss_percentile": 0.82418}, "CVE-2009-3281": {"epss_score": 0.00182, "epss_percentile": 0.40243}, "CVE-2009-3282": {"epss_score": 0.00442, "epss_percentile": 0.62709}, "CVE-2009-3283": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-3284": {"epss_score": 0.00161, "epss_percentile": 0.37569}, "CVE-2009-3286": {"epss_score": 0.00095, "epss_percentile": 0.27124}, "CVE-2009-3287": {"epss_score": 0.00478, "epss_percentile": 0.64389}, "CVE-2009-3288": {"epss_score": 0.00075, "epss_percentile": 0.22885}, "CVE-2009-3289": {"epss_score": 0.00074, "epss_percentile": 0.22728}, "CVE-2009-3290": {"epss_score": 0.0005, "epss_percentile": 0.15932}, "CVE-2009-3291": {"epss_score": 0.02209, "epss_percentile": 0.84011}, "CVE-2009-3292": {"epss_score": 0.03611, "epss_percentile": 0.87424}, "CVE-2009-3293": {"epss_score": 0.01809, "epss_percentile": 0.82359}, "CVE-2009-3294": {"epss_score": 0.01892, "epss_percentile": 0.82733}, "CVE-2009-3295": {"epss_score": 0.02737, "epss_percentile": 0.85552}, "CVE-2009-3296": {"epss_score": 0.03659, "epss_percentile": 0.87522}, "CVE-2009-3298": {"epss_score": 0.01403, "epss_percentile": 0.8003}, "CVE-2009-3299": {"epss_score": 0.00604, "epss_percentile": 0.68963}, "CVE-2009-3300": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2009-3301": {"epss_score": 0.42759, "epss_percentile": 0.97349}, "CVE-2009-3302": {"epss_score": 0.42759, "epss_percentile": 0.97349}, "CVE-2009-3303": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2009-3304": {"epss_score": 0.0003, "epss_percentile": 0.08231}, "CVE-2009-3305": {"epss_score": 0.11718, "epss_percentile": 0.93459}, "CVE-2009-3306": {"epss_score": 0.01165, "epss_percentile": 0.78173}, "CVE-2009-3307": {"epss_score": 0.00698, "epss_percentile": 0.71421}, "CVE-2009-3308": {"epss_score": 0.00149, "epss_percentile": 0.35955}, "CVE-2009-3309": {"epss_score": 0.00122, "epss_percentile": 0.32031}, "CVE-2009-3310": {"epss_score": 0.00193, "epss_percentile": 0.41411}, "CVE-2009-3311": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-3312": {"epss_score": 0.00609, "epss_percentile": 0.6909}, "CVE-2009-3313": {"epss_score": 0.00244, "epss_percentile": 0.4752}, "CVE-2009-3314": {"epss_score": 0.0014, "epss_percentile": 0.34792}, "CVE-2009-3315": {"epss_score": 0.00108, "epss_percentile": 0.29768}, "CVE-2009-3316": {"epss_score": 0.00202, "epss_percentile": 0.42393}, "CVE-2009-3317": {"epss_score": 0.00903, "epss_percentile": 0.75207}, "CVE-2009-3318": {"epss_score": 0.01442, "epss_percentile": 0.8031}, "CVE-2009-3319": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2009-3320": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-3321": {"epss_score": 0.00217, "epss_percentile": 0.44301}, "CVE-2009-3322": {"epss_score": 0.23057, "epss_percentile": 0.95726}, "CVE-2009-3323": {"epss_score": 0.00495, "epss_percentile": 0.65107}, "CVE-2009-3324": {"epss_score": 0.0059, "epss_percentile": 0.68562}, "CVE-2009-3325": {"epss_score": 0.00142, "epss_percentile": 0.35081}, "CVE-2009-3326": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3327": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3328": {"epss_score": 0.00138, "epss_percentile": 0.34408}, "CVE-2009-3329": {"epss_score": 0.05849, "epss_percentile": 0.90261}, "CVE-2009-3330": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3331": {"epss_score": 0.00495, "epss_percentile": 0.65107}, "CVE-2009-3332": {"epss_score": 0.00116, "epss_percentile": 0.31177}, "CVE-2009-3333": {"epss_score": 0.00862, "epss_percentile": 0.74576}, "CVE-2009-3334": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-3335": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3336": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-3337": {"epss_score": 0.0078, "epss_percentile": 0.73166}, "CVE-2009-3338": {"epss_score": 0.06474, "epss_percentile": 0.90781}, "CVE-2009-3339": {"epss_score": 0.0028, "epss_percentile": 0.5104}, "CVE-2009-3340": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2009-3341": {"epss_score": 0.05281, "epss_percentile": 0.89689}, "CVE-2009-3342": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-3343": {"epss_score": 0.00253, "epss_percentile": 0.48476}, "CVE-2009-3344": {"epss_score": 0.00558, "epss_percentile": 0.67593}, "CVE-2009-3345": {"epss_score": 0.00446, "epss_percentile": 0.62918}, "CVE-2009-3346": {"epss_score": 0.04068, "epss_percentile": 0.88203}, "CVE-2009-3347": {"epss_score": 0.03791, "epss_percentile": 0.8773}, "CVE-2009-3348": {"epss_score": 0.00193, "epss_percentile": 0.41445}, "CVE-2009-3349": {"epss_score": 0.00111, "epss_percentile": 0.30342}, "CVE-2009-3350": {"epss_score": 0.00345, "epss_percentile": 0.5659}, "CVE-2009-3351": {"epss_score": 0.00345, "epss_percentile": 0.5659}, "CVE-2009-3352": {"epss_score": 0.00807, "epss_percentile": 0.73669}, "CVE-2009-3353": {"epss_score": 0.00345, "epss_percentile": 0.5659}, "CVE-2009-3354": {"epss_score": 0.00345, "epss_percentile": 0.5659}, "CVE-2009-3355": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-3356": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-3357": {"epss_score": 0.00202, "epss_percentile": 0.42415}, "CVE-2009-3358": {"epss_score": 0.00124, "epss_percentile": 0.32367}, "CVE-2009-3359": {"epss_score": 0.0105, "epss_percentile": 0.77067}, "CVE-2009-3360": {"epss_score": 0.01588, "epss_percentile": 0.81189}, "CVE-2009-3361": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3362": {"epss_score": 0.0097, "epss_percentile": 0.76115}, "CVE-2009-3363": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2009-3364": {"epss_score": 0.0622, "epss_percentile": 0.90577}, "CVE-2009-3365": {"epss_score": 0.0059, "epss_percentile": 0.68562}, "CVE-2009-3366": {"epss_score": 0.01411, "epss_percentile": 0.80087}, "CVE-2009-3367": {"epss_score": 0.00172, "epss_percentile": 0.38936}, "CVE-2009-3368": {"epss_score": 0.01601, "epss_percentile": 0.81265}, "CVE-2009-3369": {"epss_score": 0.0443, "epss_percentile": 0.88678}, "CVE-2009-3370": {"epss_score": 0.00556, "epss_percentile": 0.67525}, "CVE-2009-3371": {"epss_score": 0.03183, "epss_percentile": 0.86585}, "CVE-2009-3372": {"epss_score": 0.01985, "epss_percentile": 0.83156}, "CVE-2009-3373": {"epss_score": 0.13491, "epss_percentile": 0.9398}, "CVE-2009-3374": {"epss_score": 0.00887, "epss_percentile": 0.74969}, "CVE-2009-3375": {"epss_score": 0.00462, "epss_percentile": 0.63587}, "CVE-2009-3376": {"epss_score": 0.03024, "epss_percentile": 0.86231}, "CVE-2009-3377": {"epss_score": 0.08219, "epss_percentile": 0.91934}, "CVE-2009-3378": {"epss_score": 0.03673, "epss_percentile": 0.87549}, "CVE-2009-3379": {"epss_score": 0.0515, "epss_percentile": 0.89548}, "CVE-2009-3380": {"epss_score": 0.0364, "epss_percentile": 0.87489}, "CVE-2009-3381": {"epss_score": 0.06187, "epss_percentile": 0.90543}, "CVE-2009-3382": {"epss_score": 0.18233, "epss_percentile": 0.94978}, "CVE-2009-3383": {"epss_score": 0.06615, "epss_percentile": 0.9089}, "CVE-2009-3384": {"epss_score": 0.01257, "epss_percentile": 0.7895}, "CVE-2009-3385": {"epss_score": 0.01388, "epss_percentile": 0.79922}, "CVE-2009-3386": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2009-3387": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2009-3388": {"epss_score": 0.02632, "epss_percentile": 0.85286}, "CVE-2009-3389": {"epss_score": 0.0553, "epss_percentile": 0.89966}, "CVE-2009-3390": {"epss_score": 0.00038, "epss_percentile": 0.11415}, "CVE-2009-3392": {"epss_score": 0.00863, "epss_percentile": 0.7459}, "CVE-2009-3393": {"epss_score": 0.00882, "epss_percentile": 0.74898}, "CVE-2009-3395": {"epss_score": 0.01417, "epss_percentile": 0.80151}, "CVE-2009-3396": {"epss_score": 0.00882, "epss_percentile": 0.74898}, "CVE-2009-3397": {"epss_score": 0.00909, "epss_percentile": 0.75298}, "CVE-2009-3399": {"epss_score": 0.00882, "epss_percentile": 0.74898}, "CVE-2009-3400": {"epss_score": 0.00415, "epss_percentile": 0.61146}, "CVE-2009-3401": {"epss_score": 0.00227, "epss_percentile": 0.45418}, "CVE-2009-3402": {"epss_score": 0.00362, "epss_percentile": 0.5779}, "CVE-2009-3403": {"epss_score": 0.01278, "epss_percentile": 0.79126}, "CVE-2009-3404": {"epss_score": 0.00381, "epss_percentile": 0.58995}, "CVE-2009-3405": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2009-3406": {"epss_score": 0.00417, "epss_percentile": 0.6126}, "CVE-2009-3407": {"epss_score": 0.03131, "epss_percentile": 0.86474}, "CVE-2009-3408": {"epss_score": 0.01005, "epss_percentile": 0.76543}, "CVE-2009-3409": {"epss_score": 0.00351, "epss_percentile": 0.57072}, "CVE-2009-3410": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2009-3411": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2009-3412": {"epss_score": 0.00241, "epss_percentile": 0.47248}, "CVE-2009-3413": {"epss_score": 0.00374, "epss_percentile": 0.58551}, "CVE-2009-3414": {"epss_score": 0.00318, "epss_percentile": 0.54449}, "CVE-2009-3415": {"epss_score": 0.00366, "epss_percentile": 0.58097}, "CVE-2009-3416": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2009-3417": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3418": {"epss_score": 0.00104, "epss_percentile": 0.29167}, "CVE-2009-3419": {"epss_score": 0.00153, "epss_percentile": 0.36607}, "CVE-2009-3420": {"epss_score": 0.00204, "epss_percentile": 0.42599}, "CVE-2009-3421": {"epss_score": 0.03035, "epss_percentile": 0.86259}, "CVE-2009-3422": {"epss_score": 0.01663, "epss_percentile": 0.81639}, "CVE-2009-3423": {"epss_score": 0.01883, "epss_percentile": 0.82699}, "CVE-2009-3424": {"epss_score": 0.00517, "epss_percentile": 0.66073}, "CVE-2009-3425": {"epss_score": 0.01696, "epss_percentile": 0.81813}, "CVE-2009-3426": {"epss_score": 0.0097, "epss_percentile": 0.76115}, "CVE-2009-3427": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-3428": {"epss_score": 0.09618, "epss_percentile": 0.92625}, "CVE-2009-3429": {"epss_score": 0.7195, "epss_percentile": 0.98688}, "CVE-2009-3430": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-3431": {"epss_score": 0.2555, "epss_percentile": 0.96039}, "CVE-2009-3432": {"epss_score": 0.00051, "epss_percentile": 0.16326}, "CVE-2009-3433": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2009-3434": {"epss_score": 0.00202, "epss_percentile": 0.42415}, "CVE-2009-3435": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2009-3436": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2009-3437": {"epss_score": 0.00204, "epss_percentile": 0.42663}, "CVE-2009-3438": {"epss_score": 0.00165, "epss_percentile": 0.38056}, "CVE-2009-3439": {"epss_score": 0.00155, "epss_percentile": 0.36787}, "CVE-2009-3440": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2009-3441": {"epss_score": 0.00425, "epss_percentile": 0.61708}, "CVE-2009-3442": {"epss_score": 0.0045, "epss_percentile": 0.63075}, "CVE-2009-3443": {"epss_score": 0.0013, "epss_percentile": 0.33306}, "CVE-2009-3444": {"epss_score": 0.00426, "epss_percentile": 0.61731}, "CVE-2009-3445": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2009-3446": {"epss_score": 0.00127, "epss_percentile": 0.3289}, "CVE-2009-3447": {"epss_score": 0.0126, "epss_percentile": 0.7897}, "CVE-2009-3448": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2009-3449": {"epss_score": 0.02133, "epss_percentile": 0.83722}, "CVE-2009-3450": {"epss_score": 0.00532, "epss_percentile": 0.667}, "CVE-2009-3451": {"epss_score": 0.00263, "epss_percentile": 0.49478}, "CVE-2009-3452": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-3453": {"epss_score": 0.0049, "epss_percentile": 0.64936}, "CVE-2009-3455": {"epss_score": 0.00159, "epss_percentile": 0.37367}, "CVE-2009-3456": {"epss_score": 0.00061, "epss_percentile": 0.19314}, "CVE-2009-3457": {"epss_score": 0.15594, "epss_percentile": 0.94467}, "CVE-2009-3458": {"epss_score": 0.49031, "epss_percentile": 0.97664}, "CVE-2009-3459": {"epss_score": 0.88364, "epss_percentile": 0.99468}, "CVE-2009-3460": {"epss_score": 0.22185, "epss_percentile": 0.95605}, "CVE-2009-3461": {"epss_score": 0.03252, "epss_percentile": 0.86752}, "CVE-2009-3462": {"epss_score": 0.03482, "epss_percentile": 0.8722}, "CVE-2009-3463": {"epss_score": 0.0728, "epss_percentile": 0.91381}, "CVE-2009-3464": {"epss_score": 0.11779, "epss_percentile": 0.93472}, "CVE-2009-3465": {"epss_score": 0.11779, "epss_percentile": 0.93472}, "CVE-2009-3466": {"epss_score": 0.04296, "epss_percentile": 0.8851}, "CVE-2009-3467": {"epss_score": 0.00816, "epss_percentile": 0.73803}, "CVE-2009-3468": {"epss_score": 0.00034, "epss_percentile": 0.09521}, "CVE-2009-3469": {"epss_score": 0.02564, "epss_percentile": 0.85112}, "CVE-2009-3470": {"epss_score": 0.0107, "epss_percentile": 0.77254}, "CVE-2009-3471": {"epss_score": 0.00847, "epss_percentile": 0.74345}, "CVE-2009-3472": {"epss_score": 0.00565, "epss_percentile": 0.6778}, "CVE-2009-3473": {"epss_score": 0.00599, "epss_percentile": 0.68803}, "CVE-2009-3474": {"epss_score": 0.01289, "epss_percentile": 0.79213}, "CVE-2009-3475": {"epss_score": 0.0036, "epss_percentile": 0.57653}, "CVE-2009-3476": {"epss_score": 0.01561, "epss_percentile": 0.81043}, "CVE-2009-3477": {"epss_score": 0.00249, "epss_percentile": 0.48044}, "CVE-2009-3478": {"epss_score": 0.00663, "epss_percentile": 0.70627}, "CVE-2009-3479": {"epss_score": 0.00241, "epss_percentile": 0.47267}, "CVE-2009-3480": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2009-3481": {"epss_score": 0.00305, "epss_percentile": 0.5332}, "CVE-2009-3482": {"epss_score": 0.00084, "epss_percentile": 0.24997}, "CVE-2009-3483": {"epss_score": 0.02933, "epss_percentile": 0.86018}, "CVE-2009-3484": {"epss_score": 0.07377, "epss_percentile": 0.91442}, "CVE-2009-3485": {"epss_score": 0.01895, "epss_percentile": 0.82749}, "CVE-2009-3486": {"epss_score": 0.0039, "epss_percentile": 0.59507}, "CVE-2009-3487": {"epss_score": 0.0039, "epss_percentile": 0.59507}, "CVE-2009-3488": {"epss_score": 0.00226, "epss_percentile": 0.45246}, "CVE-2009-3489": {"epss_score": 0.00231, "epss_percentile": 0.45785}, "CVE-2009-3490": {"epss_score": 0.01371, "epss_percentile": 0.79803}, "CVE-2009-3491": {"epss_score": 0.00154, "epss_percentile": 0.36706}, "CVE-2009-3492": {"epss_score": 0.00495, "epss_percentile": 0.65107}, "CVE-2009-3493": {"epss_score": 0.0142, "epss_percentile": 0.80166}, "CVE-2009-3494": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-3495": {"epss_score": 0.00162, "epss_percentile": 0.37636}, "CVE-2009-3496": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2009-3497": {"epss_score": 0.00372, "epss_percentile": 0.58433}, "CVE-2009-3498": {"epss_score": 0.00348, "epss_percentile": 0.56809}, "CVE-2009-3499": {"epss_score": 0.00323, "epss_percentile": 0.54906}, "CVE-2009-3500": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-3501": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2009-3502": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-3503": {"epss_score": 0.00338, "epss_percentile": 0.56134}, "CVE-2009-3504": {"epss_score": 0.00149, "epss_percentile": 0.35974}, "CVE-2009-3505": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2009-3506": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-3507": {"epss_score": 0.01061, "epss_percentile": 0.77177}, "CVE-2009-3508": {"epss_score": 0.00905, "epss_percentile": 0.75234}, "CVE-2009-3509": {"epss_score": 0.01549, "epss_percentile": 0.8098}, "CVE-2009-3510": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-3511": {"epss_score": 0.00582, "epss_percentile": 0.68303}, "CVE-2009-3512": {"epss_score": 0.01038, "epss_percentile": 0.76932}, "CVE-2009-3513": {"epss_score": 0.00305, "epss_percentile": 0.53389}, "CVE-2009-3514": {"epss_score": 0.00095, "epss_percentile": 0.27093}, "CVE-2009-3515": {"epss_score": 0.00774, "epss_percentile": 0.73068}, "CVE-2009-3516": {"epss_score": 0.0008, "epss_percentile": 0.24199}, "CVE-2009-3517": {"epss_score": 0.02511, "epss_percentile": 0.84951}, "CVE-2009-3518": {"epss_score": 0.0786, "epss_percentile": 0.91726}, "CVE-2009-3519": {"epss_score": 0.00196, "epss_percentile": 0.41765}, "CVE-2009-3520": {"epss_score": 0.00168, "epss_percentile": 0.38428}, "CVE-2009-3521": {"epss_score": 0.00278, "epss_percentile": 0.50874}, "CVE-2009-3522": {"epss_score": 0.00508, "epss_percentile": 0.65709}, "CVE-2009-3523": {"epss_score": 0.00158, "epss_percentile": 0.37295}, "CVE-2009-3524": {"epss_score": 0.00051, "epss_percentile": 0.1605}, "CVE-2009-3525": {"epss_score": 0.01341, "epss_percentile": 0.79587}, "CVE-2009-3527": {"epss_score": 0.00281, "epss_percentile": 0.5118}, "CVE-2009-3528": {"epss_score": 0.00155, "epss_percentile": 0.36787}, "CVE-2009-3529": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3530": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2009-3531": {"epss_score": 0.00202, "epss_percentile": 0.42415}, "CVE-2009-3532": {"epss_score": 0.00417, "epss_percentile": 0.61253}, "CVE-2009-3533": {"epss_score": 0.00356, "epss_percentile": 0.57348}, "CVE-2009-3534": {"epss_score": 0.01805, "epss_percentile": 0.82348}, "CVE-2009-3535": {"epss_score": 0.01996, "epss_percentile": 0.83196}, "CVE-2009-3536": {"epss_score": 0.07288, "epss_percentile": 0.91386}, "CVE-2009-3537": {"epss_score": 0.02041, "epss_percentile": 0.83371}, "CVE-2009-3538": {"epss_score": 0.00141, "epss_percentile": 0.34952}, "CVE-2009-3539": {"epss_score": 0.00437, "epss_percentile": 0.62496}, "CVE-2009-3540": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2009-3541": {"epss_score": 0.00495, "epss_percentile": 0.65107}, "CVE-2009-3542": {"epss_score": 0.02619, "epss_percentile": 0.85254}, "CVE-2009-3543": {"epss_score": 0.00173, "epss_percentile": 0.39084}, "CVE-2009-3544": {"epss_score": 0.01824, "epss_percentile": 0.82427}, "CVE-2009-3545": {"epss_score": 0.01999, "epss_percentile": 0.83213}, "CVE-2009-3546": {"epss_score": 0.03545, "epss_percentile": 0.87324}, "CVE-2009-3547": {"epss_score": 0.02412, "epss_percentile": 0.84672}, "CVE-2009-3548": {"epss_score": 0.86884, "epss_percentile": 0.99402}, "CVE-2009-3549": {"epss_score": 0.01296, "epss_percentile": 0.79256}, "CVE-2009-3550": {"epss_score": 0.01733, "epss_percentile": 0.82}, "CVE-2009-3551": {"epss_score": 0.007, "epss_percentile": 0.71462}, "CVE-2009-3552": {"epss_score": 0.00187, "epss_percentile": 0.40799}, "CVE-2009-3553": {"epss_score": 0.09847, "epss_percentile": 0.92734}, "CVE-2009-3554": {"epss_score": 0.00065, "epss_percentile": 0.20556}, "CVE-2009-3555": {"epss_score": 0.03076, "epss_percentile": 0.86361}, "CVE-2009-3556": {"epss_score": 0.00037, "epss_percentile": 0.10995}, "CVE-2009-3557": {"epss_score": 0.035, "epss_percentile": 0.87243}, "CVE-2009-3558": {"epss_score": 0.04443, "epss_percentile": 0.88695}, "CVE-2009-3559": {"epss_score": 0.02904, "epss_percentile": 0.85961}, "CVE-2009-3560": {"epss_score": 0.0283, "epss_percentile": 0.85774}, "CVE-2009-3561": {"epss_score": 0.01099, "epss_percentile": 0.77559}, "CVE-2009-3562": {"epss_score": 0.00846, "epss_percentile": 0.74323}, "CVE-2009-3563": {"epss_score": 0.82429, "epss_percentile": 0.99194}, "CVE-2009-3564": {"epss_score": 0.00053, "epss_percentile": 0.16996}, "CVE-2009-3565": {"epss_score": 0.05917, "epss_percentile": 0.90319}, "CVE-2009-3566": {"epss_score": 0.05123, "epss_percentile": 0.89521}, "CVE-2009-3567": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-3568": {"epss_score": 0.0045, "epss_percentile": 0.63075}, "CVE-2009-3569": {"epss_score": 0.04928, "epss_percentile": 0.89295}, "CVE-2009-3570": {"epss_score": 0.00359, "epss_percentile": 0.5757}, "CVE-2009-3571": {"epss_score": 0.00484, "epss_percentile": 0.64641}, "CVE-2009-3572": {"epss_score": 0.00045, "epss_percentile": 0.13994}, "CVE-2009-3573": {"epss_score": 0.03557, "epss_percentile": 0.87348}, "CVE-2009-3574": {"epss_score": 0.02319, "epss_percentile": 0.84363}, "CVE-2009-3575": {"epss_score": 0.03321, "epss_percentile": 0.8691}, "CVE-2009-3576": {"epss_score": 0.02001, "epss_percentile": 0.8322}, "CVE-2009-3577": {"epss_score": 0.03965, "epss_percentile": 0.88029}, "CVE-2009-3578": {"epss_score": 0.07356, "epss_percentile": 0.91429}, "CVE-2009-3579": {"epss_score": 0.0013, "epss_percentile": 0.33284}, "CVE-2009-3580": {"epss_score": 0.00126, "epss_percentile": 0.32699}, "CVE-2009-3581": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2009-3582": {"epss_score": 0.00359, "epss_percentile": 0.576}, "CVE-2009-3583": {"epss_score": 0.00217, "epss_percentile": 0.44315}, "CVE-2009-3584": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2009-3585": {"epss_score": 0.00409, "epss_percentile": 0.60736}, "CVE-2009-3586": {"epss_score": 0.0942, "epss_percentile": 0.92539}, "CVE-2009-3587": {"epss_score": 0.08216, "epss_percentile": 0.91934}, "CVE-2009-3588": {"epss_score": 0.01568, "epss_percentile": 0.81079}, "CVE-2009-3589": {"epss_score": 0.00052, "epss_percentile": 0.16352}, "CVE-2009-3590": {"epss_score": 0.00323, "epss_percentile": 0.54906}, "CVE-2009-3591": {"epss_score": 0.71287, "epss_percentile": 0.98662}, "CVE-2009-3592": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2009-3593": {"epss_score": 0.01078, "epss_percentile": 0.7735}, "CVE-2009-3594": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-3595": {"epss_score": 0.0014, "epss_percentile": 0.34792}, "CVE-2009-3596": {"epss_score": 0.01171, "epss_percentile": 0.78219}, "CVE-2009-3597": {"epss_score": 0.05261, "epss_percentile": 0.89669}, "CVE-2009-3598": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-3599": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-3600": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2009-3601": {"epss_score": 0.00471, "epss_percentile": 0.63996}, "CVE-2009-3602": {"epss_score": 0.01644, "epss_percentile": 0.81523}, "CVE-2009-3603": {"epss_score": 0.06276, "epss_percentile": 0.90632}, "CVE-2009-3604": {"epss_score": 0.09744, "epss_percentile": 0.92688}, "CVE-2009-3605": {"epss_score": 0.04336, "epss_percentile": 0.88563}, "CVE-2009-3606": {"epss_score": 0.04772, "epss_percentile": 0.89128}, "CVE-2009-3607": {"epss_score": 0.06855, "epss_percentile": 0.91077}, "CVE-2009-3608": {"epss_score": 0.1027, "epss_percentile": 0.92921}, "CVE-2009-3609": {"epss_score": 0.05999, "epss_percentile": 0.90392}, "CVE-2009-3611": {"epss_score": 0.00059, "epss_percentile": 0.18726}, "CVE-2009-3612": {"epss_score": 0.0007, "epss_percentile": 0.21642}, "CVE-2009-3613": {"epss_score": 0.05211, "epss_percentile": 0.89616}, "CVE-2009-3614": {"epss_score": 0.00115, "epss_percentile": 0.31013}, "CVE-2009-3615": {"epss_score": 0.07985, "epss_percentile": 0.91804}, "CVE-2009-3616": {"epss_score": 0.00858, "epss_percentile": 0.745}, "CVE-2009-3617": {"epss_score": 0.14031, "epss_percentile": 0.94119}, "CVE-2009-3618": {"epss_score": 0.00705, "epss_percentile": 0.71583}, "CVE-2009-3619": {"epss_score": 0.00491, "epss_percentile": 0.64956}, "CVE-2009-3620": {"epss_score": 0.00073, "epss_percentile": 0.22529}, "CVE-2009-3621": {"epss_score": 0.0004, "epss_percentile": 0.12148}, "CVE-2009-3622": {"epss_score": 0.0832, "epss_percentile": 0.9199}, "CVE-2009-3623": {"epss_score": 0.01408, "epss_percentile": 0.80062}, "CVE-2009-3624": {"epss_score": 0.00063, "epss_percentile": 0.20097}, "CVE-2009-3625": {"epss_score": 0.06216, "epss_percentile": 0.90575}, "CVE-2009-3626": {"epss_score": 0.01313, "epss_percentile": 0.79385}, "CVE-2009-3627": {"epss_score": 0.00726, "epss_percentile": 0.72079}, "CVE-2009-3628": {"epss_score": 0.00227, "epss_percentile": 0.4546}, "CVE-2009-3629": {"epss_score": 0.00287, "epss_percentile": 0.51809}, "CVE-2009-3630": {"epss_score": 0.00949, "epss_percentile": 0.75839}, "CVE-2009-3631": {"epss_score": 0.00541, "epss_percentile": 0.67042}, "CVE-2009-3632": {"epss_score": 0.00515, "epss_percentile": 0.66008}, "CVE-2009-3633": {"epss_score": 0.00382, "epss_percentile": 0.59077}, "CVE-2009-3634": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2009-3635": {"epss_score": 0.01041, "epss_percentile": 0.76965}, "CVE-2009-3636": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2009-3637": {"epss_score": 0.12449, "epss_percentile": 0.93675}, "CVE-2009-3638": {"epss_score": 0.00061, "epss_percentile": 0.19335}, "CVE-2009-3639": {"epss_score": 0.01297, "epss_percentile": 0.79266}, "CVE-2009-3640": {"epss_score": 0.00061, "epss_percentile": 0.19549}, "CVE-2009-3641": {"epss_score": 0.33241, "epss_percentile": 0.96754}, "CVE-2009-3642": {"epss_score": 0.00296, "epss_percentile": 0.52544}, "CVE-2009-3643": {"epss_score": 0.05147, "epss_percentile": 0.89545}, "CVE-2009-3644": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-3645": {"epss_score": 0.00154, "epss_percentile": 0.36706}, "CVE-2009-3646": {"epss_score": 0.03286, "epss_percentile": 0.86824}, "CVE-2009-3647": {"epss_score": 0.00204, "epss_percentile": 0.42599}, "CVE-2009-3648": {"epss_score": 0.00111, "epss_percentile": 0.30256}, "CVE-2009-3649": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2009-3650": {"epss_score": 0.00231, "epss_percentile": 0.45791}, "CVE-2009-3651": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-3652": {"epss_score": 0.00209, "epss_percentile": 0.43425}, "CVE-2009-3653": {"epss_score": 0.00166, "epss_percentile": 0.38194}, "CVE-2009-3654": {"epss_score": 0.01018, "epss_percentile": 0.76705}, "CVE-2009-3655": {"epss_score": 0.04119, "epss_percentile": 0.88282}, "CVE-2009-3656": {"epss_score": 0.0011, "epss_percentile": 0.3015}, "CVE-2009-3657": {"epss_score": 0.00181, "epss_percentile": 0.40069}, "CVE-2009-3658": {"epss_score": 0.22016, "epss_percentile": 0.95584}, "CVE-2009-3659": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3660": {"epss_score": 0.00901, "epss_percentile": 0.7517}, "CVE-2009-3661": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2009-3662": {"epss_score": 0.02713, "epss_percentile": 0.85504}, "CVE-2009-3663": {"epss_score": 0.19331, "epss_percentile": 0.95164}, "CVE-2009-3664": {"epss_score": 0.02056, "epss_percentile": 0.83422}, "CVE-2009-3665": {"epss_score": 0.00126, "epss_percentile": 0.32679}, "CVE-2009-3666": {"epss_score": 0.01336, "epss_percentile": 0.79557}, "CVE-2009-3667": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3668": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-3669": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-3670": {"epss_score": 0.05825, "epss_percentile": 0.90237}, "CVE-2009-3671": {"epss_score": 0.56494, "epss_percentile": 0.98025}, "CVE-2009-3672": {"epss_score": 0.80588, "epss_percentile": 0.99096}, "CVE-2009-3673": {"epss_score": 0.55399, "epss_percentile": 0.97976}, "CVE-2009-3674": {"epss_score": 0.59217, "epss_percentile": 0.98155}, "CVE-2009-3675": {"epss_score": 0.45401, "epss_percentile": 0.97486}, "CVE-2009-3676": {"epss_score": 0.56028, "epss_percentile": 0.98006}, "CVE-2009-3677": {"epss_score": 0.66697, "epss_percentile": 0.98474}, "CVE-2009-3678": {"epss_score": 0.52132, "epss_percentile": 0.9781}, "CVE-2009-3691": {"epss_score": 0.16154, "epss_percentile": 0.9458}, "CVE-2009-3692": {"epss_score": 0.00176, "epss_percentile": 0.39482}, "CVE-2009-3693": {"epss_score": 0.72607, "epss_percentile": 0.98719}, "CVE-2009-3694": {"epss_score": 0.01488, "epss_percentile": 0.80615}, "CVE-2009-3695": {"epss_score": 0.06201, "epss_percentile": 0.9056}, "CVE-2009-3696": {"epss_score": 0.03385, "epss_percentile": 0.87039}, "CVE-2009-3697": {"epss_score": 0.02584, "epss_percentile": 0.85161}, "CVE-2009-3698": {"epss_score": 0.0098, "epss_percentile": 0.76268}, "CVE-2009-3699": {"epss_score": 0.78892, "epss_percentile": 0.99009}, "CVE-2009-3700": {"epss_score": 0.03402, "epss_percentile": 0.8707}, "CVE-2009-3701": {"epss_score": 0.02191, "epss_percentile": 0.83938}, "CVE-2009-3702": {"epss_score": 0.00739, "epss_percentile": 0.72391}, "CVE-2009-3703": {"epss_score": 0.00603, "epss_percentile": 0.6894}, "CVE-2009-3704": {"epss_score": 0.02829, "epss_percentile": 0.85772}, "CVE-2009-3705": {"epss_score": 0.01537, "epss_percentile": 0.80923}, "CVE-2009-3706": {"epss_score": 0.00048, "epss_percentile": 0.1495}, "CVE-2009-3707": {"epss_score": 0.21257, "epss_percentile": 0.95488}, "CVE-2009-3708": {"epss_score": 0.09238, "epss_percentile": 0.92462}, "CVE-2009-3709": {"epss_score": 0.1026, "epss_percentile": 0.92916}, "CVE-2009-3710": {"epss_score": 0.02776, "epss_percentile": 0.85636}, "CVE-2009-3711": {"epss_score": 0.78944, "epss_percentile": 0.99012}, "CVE-2009-3712": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-3713": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2009-3714": {"epss_score": 0.02369, "epss_percentile": 0.84521}, "CVE-2009-3715": {"epss_score": 0.00213, "epss_percentile": 0.43836}, "CVE-2009-3716": {"epss_score": 0.02283, "epss_percentile": 0.8426}, "CVE-2009-3717": {"epss_score": 0.04571, "epss_percentile": 0.88862}, "CVE-2009-3718": {"epss_score": 0.0013, "epss_percentile": 0.33299}, "CVE-2009-3719": {"epss_score": 0.01142, "epss_percentile": 0.77973}, "CVE-2009-3720": {"epss_score": 0.01131, "epss_percentile": 0.77856}, "CVE-2009-3721": {"epss_score": 0.00781, "epss_percentile": 0.73176}, "CVE-2009-3722": {"epss_score": 0.02481, "epss_percentile": 0.84875}, "CVE-2009-3723": {"epss_score": 0.00653, "epss_percentile": 0.7033}, "CVE-2009-3724": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2009-3725": {"epss_score": 0.00046, "epss_percentile": 0.14166}, "CVE-2009-3726": {"epss_score": 0.05792, "epss_percentile": 0.90214}, "CVE-2009-3727": {"epss_score": 0.0072, "epss_percentile": 0.71956}, "CVE-2009-3728": {"epss_score": 0.00486, "epss_percentile": 0.64745}, "CVE-2009-3729": {"epss_score": 0.01583, "epss_percentile": 0.81146}, "CVE-2009-3730": {"epss_score": 0.01464, "epss_percentile": 0.80449}, "CVE-2009-3731": {"epss_score": 0.02195, "epss_percentile": 0.83953}, "CVE-2009-3732": {"epss_score": 0.30069, "epss_percentile": 0.96502}, "CVE-2009-3733": {"epss_score": 0.9006, "epss_percentile": 0.99559}, "CVE-2009-3734": {"epss_score": 0.02273, "epss_percentile": 0.8422}, "CVE-2009-3735": {"epss_score": 0.08064, "epss_percentile": 0.91863}, "CVE-2009-3736": {"epss_score": 0.00137, "epss_percentile": 0.34266}, "CVE-2009-3737": {"epss_score": 0.05985, "epss_percentile": 0.90382}, "CVE-2009-3739": {"epss_score": 0.00058, "epss_percentile": 0.18584}, "CVE-2009-3742": {"epss_score": 0.00621, "epss_percentile": 0.69475}, "CVE-2009-3743": {"epss_score": 0.0525, "epss_percentile": 0.89664}, "CVE-2009-3744": {"epss_score": 0.04304, "epss_percentile": 0.88519}, "CVE-2009-3745": {"epss_score": 0.00463, "epss_percentile": 0.63697}, "CVE-2009-3746": {"epss_score": 0.00051, "epss_percentile": 0.16111}, "CVE-2009-3747": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-3748": {"epss_score": 0.04383, "epss_percentile": 0.88628}, "CVE-2009-3749": {"epss_score": 0.13429, "epss_percentile": 0.93961}, "CVE-2009-3750": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2009-3751": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2009-3752": {"epss_score": 0.00182, "epss_percentile": 0.40203}, "CVE-2009-3753": {"epss_score": 0.03791, "epss_percentile": 0.8773}, "CVE-2009-3754": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2009-3755": {"epss_score": 0.00193, "epss_percentile": 0.41445}, "CVE-2009-3756": {"epss_score": 0.01606, "epss_percentile": 0.81305}, "CVE-2009-3757": {"epss_score": 0.06401, "epss_percentile": 0.90727}, "CVE-2009-3758": {"epss_score": 0.00799, "epss_percentile": 0.73531}, "CVE-2009-3759": {"epss_score": 0.01377, "epss_percentile": 0.7984}, "CVE-2009-3760": {"epss_score": 0.06086, "epss_percentile": 0.90466}, "CVE-2009-3762": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2009-3763": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2009-3764": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2009-3765": {"epss_score": 0.00586, "epss_percentile": 0.68445}, "CVE-2009-3766": {"epss_score": 0.01392, "epss_percentile": 0.79957}, "CVE-2009-3767": {"epss_score": 0.0193, "epss_percentile": 0.82939}, "CVE-2009-3778": {"epss_score": 0.0075, "epss_percentile": 0.72632}, "CVE-2009-3779": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-3780": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-3781": {"epss_score": 0.00989, "epss_percentile": 0.76361}, "CVE-2009-3782": {"epss_score": 0.00215, "epss_percentile": 0.44062}, "CVE-2009-3783": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2009-3784": {"epss_score": 0.00177, "epss_percentile": 0.39513}, "CVE-2009-3785": {"epss_score": 0.00147, "epss_percentile": 0.35668}, "CVE-2009-3786": {"epss_score": 0.00645, "epss_percentile": 0.70115}, "CVE-2009-3787": {"epss_score": 0.04186, "epss_percentile": 0.88364}, "CVE-2009-3788": {"epss_score": 0.00481, "epss_percentile": 0.6451}, "CVE-2009-3789": {"epss_score": 0.02595, "epss_percentile": 0.85191}, "CVE-2009-3790": {"epss_score": 0.03728, "epss_percentile": 0.87636}, "CVE-2009-3791": {"epss_score": 0.00969, "epss_percentile": 0.76105}, "CVE-2009-3792": {"epss_score": 0.00403, "epss_percentile": 0.60368}, "CVE-2009-3793": {"epss_score": 0.02671, "epss_percentile": 0.85389}, "CVE-2009-3794": {"epss_score": 0.21245, "epss_percentile": 0.95485}, "CVE-2009-3796": {"epss_score": 0.0288, "epss_percentile": 0.85894}, "CVE-2009-3797": {"epss_score": 0.04349, "epss_percentile": 0.88583}, "CVE-2009-3798": {"epss_score": 0.04349, "epss_percentile": 0.88583}, "CVE-2009-3799": {"epss_score": 0.12942, "epss_percentile": 0.93824}, "CVE-2009-3800": {"epss_score": 0.04349, "epss_percentile": 0.88583}, "CVE-2009-3801": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-3802": {"epss_score": 0.03691, "epss_percentile": 0.87576}, "CVE-2009-3803": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2009-3804": {"epss_score": 0.00099, "epss_percentile": 0.28381}, "CVE-2009-3805": {"epss_score": 0.01325, "epss_percentile": 0.79474}, "CVE-2009-3806": {"epss_score": 0.0009, "epss_percentile": 0.26036}, "CVE-2009-3807": {"epss_score": 0.0288, "epss_percentile": 0.85896}, "CVE-2009-3808": {"epss_score": 0.03419, "epss_percentile": 0.87096}, "CVE-2009-3809": {"epss_score": 0.02829, "epss_percentile": 0.85772}, "CVE-2009-3810": {"epss_score": 0.07584, "epss_percentile": 0.91554}, "CVE-2009-3811": {"epss_score": 0.07999, "epss_percentile": 0.91817}, "CVE-2009-3812": {"epss_score": 0.21217, "epss_percentile": 0.95479}, "CVE-2009-3813": {"epss_score": 0.00251, "epss_percentile": 0.48309}, "CVE-2009-3814": {"epss_score": 0.00424, "epss_percentile": 0.61641}, "CVE-2009-3815": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2009-3816": {"epss_score": 0.00289, "epss_percentile": 0.52034}, "CVE-2009-3817": {"epss_score": 0.01196, "epss_percentile": 0.78436}, "CVE-2009-3818": {"epss_score": 0.00352, "epss_percentile": 0.57083}, "CVE-2009-3819": {"epss_score": 0.02082, "epss_percentile": 0.83536}, "CVE-2009-3820": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-3821": {"epss_score": 0.0151, "epss_percentile": 0.8077}, "CVE-2009-3822": {"epss_score": 0.01775, "epss_percentile": 0.82218}, "CVE-2009-3823": {"epss_score": 0.01099, "epss_percentile": 0.77559}, "CVE-2009-3824": {"epss_score": 0.00839, "epss_percentile": 0.74189}, "CVE-2009-3825": {"epss_score": 0.00908, "epss_percentile": 0.75285}, "CVE-2009-3826": {"epss_score": 0.01712, "epss_percentile": 0.81884}, "CVE-2009-3828": {"epss_score": 0.03383, "epss_percentile": 0.87037}, "CVE-2009-3829": {"epss_score": 0.05591, "epss_percentile": 0.9003}, "CVE-2009-3830": {"epss_score": 0.64182, "epss_percentile": 0.98368}, "CVE-2009-3831": {"epss_score": 0.0734, "epss_percentile": 0.91418}, "CVE-2009-3832": {"epss_score": 0.01217, "epss_percentile": 0.78598}, "CVE-2009-3833": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-3834": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2009-3835": {"epss_score": 0.00319, "epss_percentile": 0.5448}, "CVE-2009-3836": {"epss_score": 0.0027, "epss_percentile": 0.50214}, "CVE-2009-3837": {"epss_score": 0.75174, "epss_percentile": 0.98832}, "CVE-2009-3838": {"epss_score": 0.23355, "epss_percentile": 0.9577}, "CVE-2009-3839": {"epss_score": 0.0129, "epss_percentile": 0.7922}, "CVE-2009-3840": {"epss_score": 0.17249, "epss_percentile": 0.94808}, "CVE-2009-3841": {"epss_score": 0.00394, "epss_percentile": 0.59757}, "CVE-2009-3842": {"epss_score": 0.0113, "epss_percentile": 0.77852}, "CVE-2009-3843": {"epss_score": 0.86831, "epss_percentile": 0.994}, "CVE-2009-3844": {"epss_score": 0.76606, "epss_percentile": 0.98898}, "CVE-2009-3845": {"epss_score": 0.18591, "epss_percentile": 0.95039}, "CVE-2009-3846": {"epss_score": 0.27747, "epss_percentile": 0.96279}, "CVE-2009-3847": {"epss_score": 0.06153, "epss_percentile": 0.90522}, "CVE-2009-3848": {"epss_score": 0.2138, "epss_percentile": 0.95511}, "CVE-2009-3849": {"epss_score": 0.83371, "epss_percentile": 0.99246}, "CVE-2009-3850": {"epss_score": 0.03852, "epss_percentile": 0.87852}, "CVE-2009-3851": {"epss_score": 0.00054, "epss_percentile": 0.17152}, "CVE-2009-3852": {"epss_score": 0.00415, "epss_percentile": 0.61119}, "CVE-2009-3853": {"epss_score": 0.7393, "epss_percentile": 0.98777}, "CVE-2009-3854": {"epss_score": 0.10705, "epss_percentile": 0.93077}, "CVE-2009-3855": {"epss_score": 0.0045, "epss_percentile": 0.63102}, "CVE-2009-3856": {"epss_score": 0.00326, "epss_percentile": 0.55046}, "CVE-2009-3857": {"epss_score": 0.0266, "epss_percentile": 0.85365}, "CVE-2009-3858": {"epss_score": 0.01549, "epss_percentile": 0.8098}, "CVE-2009-3859": {"epss_score": 0.16577, "epss_percentile": 0.94696}, "CVE-2009-3860": {"epss_score": 0.01498, "epss_percentile": 0.80703}, "CVE-2009-3861": {"epss_score": 0.06573, "epss_percentile": 0.90856}, "CVE-2009-3862": {"epss_score": 0.00667, "epss_percentile": 0.70699}, "CVE-2009-3863": {"epss_score": 0.03815, "epss_percentile": 0.87766}, "CVE-2009-3864": {"epss_score": 0.08556, "epss_percentile": 0.92123}, "CVE-2009-3865": {"epss_score": 0.017, "epss_percentile": 0.81832}, "CVE-2009-3866": {"epss_score": 0.05655, "epss_percentile": 0.9009}, "CVE-2009-3867": {"epss_score": 0.89141, "epss_percentile": 0.9951}, "CVE-2009-3868": {"epss_score": 0.1314, "epss_percentile": 0.93883}, "CVE-2009-3869": {"epss_score": 0.78329, "epss_percentile": 0.98981}, "CVE-2009-3871": {"epss_score": 0.12545, "epss_percentile": 0.93712}, "CVE-2009-3872": {"epss_score": 0.1173, "epss_percentile": 0.93461}, "CVE-2009-3873": {"epss_score": 0.11882, "epss_percentile": 0.93503}, "CVE-2009-3874": {"epss_score": 0.08111, "epss_percentile": 0.91884}, "CVE-2009-3875": {"epss_score": 0.02162, "epss_percentile": 0.8383}, "CVE-2009-3876": {"epss_score": 0.11696, "epss_percentile": 0.93452}, "CVE-2009-3877": {"epss_score": 0.14874, "epss_percentile": 0.94305}, "CVE-2009-3878": {"epss_score": 0.00332, "epss_percentile": 0.55613}, "CVE-2009-3879": {"epss_score": 0.00226, "epss_percentile": 0.45297}, "CVE-2009-3880": {"epss_score": 0.00484, "epss_percentile": 0.64636}, "CVE-2009-3881": {"epss_score": 0.01276, "epss_percentile": 0.7911}, "CVE-2009-3882": {"epss_score": 0.00662, "epss_percentile": 0.70594}, "CVE-2009-3883": {"epss_score": 0.00662, "epss_percentile": 0.70594}, "CVE-2009-3884": {"epss_score": 0.01349, "epss_percentile": 0.79672}, "CVE-2009-3885": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2009-3886": {"epss_score": 0.00453, "epss_percentile": 0.63237}, "CVE-2009-3887": {"epss_score": 0.00389, "epss_percentile": 0.59456}, "CVE-2009-3888": {"epss_score": 0.00122, "epss_percentile": 0.32124}, "CVE-2009-3889": {"epss_score": 0.00091, "epss_percentile": 0.26189}, "CVE-2009-3890": {"epss_score": 0.10487, "epss_percentile": 0.93004}, "CVE-2009-3891": {"epss_score": 0.01041, "epss_percentile": 0.76963}, "CVE-2009-3892": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2009-3894": {"epss_score": 0.00071, "epss_percentile": 0.22051}, "CVE-2009-3895": {"epss_score": 0.0766, "epss_percentile": 0.91609}, "CVE-2009-3896": {"epss_score": 0.02511, "epss_percentile": 0.84952}, "CVE-2009-3897": {"epss_score": 0.00079, "epss_percentile": 0.23943}, "CVE-2009-3898": {"epss_score": 0.01078, "epss_percentile": 0.77343}, "CVE-2009-3899": {"epss_score": 0.02013, "epss_percentile": 0.83256}, "CVE-2009-3900": {"epss_score": 0.00853, "epss_percentile": 0.74441}, "CVE-2009-3901": {"epss_score": 0.00513, "epss_percentile": 0.65896}, "CVE-2009-3902": {"epss_score": 0.07272, "epss_percentile": 0.91374}, "CVE-2009-3903": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2009-3904": {"epss_score": 0.0518, "epss_percentile": 0.89577}, "CVE-2009-3905": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-3909": {"epss_score": 0.05417, "epss_percentile": 0.89852}, "CVE-2009-3911": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-3912": {"epss_score": 0.03074, "epss_percentile": 0.86355}, "CVE-2009-3913": {"epss_score": 0.00184, "epss_percentile": 0.40455}, "CVE-2009-3914": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-3915": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-3916": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-3917": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2009-3918": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-3919": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-3920": {"epss_score": 0.00595, "epss_percentile": 0.68683}, "CVE-2009-3921": {"epss_score": 0.00386, "epss_percentile": 0.59276}, "CVE-2009-3922": {"epss_score": 0.00138, "epss_percentile": 0.34357}, "CVE-2009-3923": {"epss_score": 0.00624, "epss_percentile": 0.69563}, "CVE-2009-3924": {"epss_score": 0.02686, "epss_percentile": 0.85428}, "CVE-2009-3930": {"epss_score": 0.00876, "epss_percentile": 0.74784}, "CVE-2009-3931": {"epss_score": 0.04518, "epss_percentile": 0.88794}, "CVE-2009-3932": {"epss_score": 0.07105, "epss_percentile": 0.91255}, "CVE-2009-3933": {"epss_score": 0.02166, "epss_percentile": 0.83851}, "CVE-2009-3934": {"epss_score": 0.0143, "epss_percentile": 0.80238}, "CVE-2009-3935": {"epss_score": 0.00453, "epss_percentile": 0.63222}, "CVE-2009-3936": {"epss_score": 0.00338, "epss_percentile": 0.56151}, "CVE-2009-3937": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2009-3938": {"epss_score": 0.03449, "epss_percentile": 0.87161}, "CVE-2009-3939": {"epss_score": 0.00044, "epss_percentile": 0.13471}, "CVE-2009-3940": {"epss_score": 0.00062, "epss_percentile": 0.19667}, "CVE-2009-3941": {"epss_score": 0.00139, "epss_percentile": 0.34654}, "CVE-2009-3942": {"epss_score": 0.0019, "epss_percentile": 0.41008}, "CVE-2009-3943": {"epss_score": 0.11584, "epss_percentile": 0.93412}, "CVE-2009-3944": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2009-3945": {"epss_score": 0.00032, "epss_percentile": 0.09019}, "CVE-2009-3946": {"epss_score": 0.00041, "epss_percentile": 0.12263}, "CVE-2009-3947": {"epss_score": 0.0497, "epss_percentile": 0.8935}, "CVE-2009-3948": {"epss_score": 0.02133, "epss_percentile": 0.83722}, "CVE-2009-3949": {"epss_score": 0.01066, "epss_percentile": 0.77222}, "CVE-2009-3950": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2009-3951": {"epss_score": 0.06895, "epss_percentile": 0.91099}, "CVE-2009-3952": {"epss_score": 0.21931, "epss_percentile": 0.95574}, "CVE-2009-3953": {"epss_score": 0.90514, "epss_percentile": 0.99588}, "CVE-2009-3954": {"epss_score": 0.06276, "epss_percentile": 0.90633}, "CVE-2009-3955": {"epss_score": 0.36195, "epss_percentile": 0.9696}, "CVE-2009-3956": {"epss_score": 0.05446, "epss_percentile": 0.89887}, "CVE-2009-3957": {"epss_score": 0.01481, "epss_percentile": 0.80568}, "CVE-2009-3958": {"epss_score": 0.65347, "epss_percentile": 0.98414}, "CVE-2009-3959": {"epss_score": 0.16203, "epss_percentile": 0.94593}, "CVE-2009-3960": {"epss_score": 0.8874, "epss_percentile": 0.99487}, "CVE-2009-3961": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-3962": {"epss_score": 0.06246, "epss_percentile": 0.90604}, "CVE-2009-3963": {"epss_score": 0.0036, "epss_percentile": 0.57629}, "CVE-2009-3964": {"epss_score": 0.00279, "epss_percentile": 0.5095}, "CVE-2009-3965": {"epss_score": 0.01926, "epss_percentile": 0.82925}, "CVE-2009-3966": {"epss_score": 0.01171, "epss_percentile": 0.78219}, "CVE-2009-3967": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2009-3968": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-3969": {"epss_score": 0.10781, "epss_percentile": 0.93102}, "CVE-2009-3970": {"epss_score": 0.00099, "epss_percentile": 0.28375}, "CVE-2009-3971": {"epss_score": 0.00357, "epss_percentile": 0.57464}, "CVE-2009-3972": {"epss_score": 0.00357, "epss_percentile": 0.57464}, "CVE-2009-3973": {"epss_score": 0.00395, "epss_percentile": 0.59836}, "CVE-2009-3974": {"epss_score": 0.00318, "epss_percentile": 0.54449}, "CVE-2009-3975": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2009-3976": {"epss_score": 0.64448, "epss_percentile": 0.98379}, "CVE-2009-3977": {"epss_score": 0.0301, "epss_percentile": 0.86195}, "CVE-2009-3978": {"epss_score": 0.00677, "epss_percentile": 0.70964}, "CVE-2009-3979": {"epss_score": 0.05076, "epss_percentile": 0.89468}, "CVE-2009-3980": {"epss_score": 0.04407, "epss_percentile": 0.88652}, "CVE-2009-3981": {"epss_score": 0.04649, "epss_percentile": 0.88963}, "CVE-2009-3982": {"epss_score": 0.08287, "epss_percentile": 0.9197}, "CVE-2009-3983": {"epss_score": 0.01037, "epss_percentile": 0.76926}, "CVE-2009-3984": {"epss_score": 0.0205, "epss_percentile": 0.834}, "CVE-2009-3985": {"epss_score": 0.00461, "epss_percentile": 0.6357}, "CVE-2009-3986": {"epss_score": 0.01982, "epss_percentile": 0.83139}, "CVE-2009-3987": {"epss_score": 0.00812, "epss_percentile": 0.73744}, "CVE-2009-3988": {"epss_score": 0.00398, "epss_percentile": 0.60068}, "CVE-2009-3989": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2009-3994": {"epss_score": 0.16941, "epss_percentile": 0.94751}, "CVE-2009-3995": {"epss_score": 0.09808, "epss_percentile": 0.92711}, "CVE-2009-3996": {"epss_score": 0.09881, "epss_percentile": 0.92752}, "CVE-2009-3997": {"epss_score": 0.08996, "epss_percentile": 0.92357}, "CVE-2009-3999": {"epss_score": 0.70594, "epss_percentile": 0.98636}, "CVE-2009-4000": {"epss_score": 0.31575, "epss_percentile": 0.96627}, "CVE-2009-4001": {"epss_score": 0.12136, "epss_percentile": 0.93581}, "CVE-2009-4002": {"epss_score": 0.21287, "epss_percentile": 0.95495}, "CVE-2009-4003": {"epss_score": 0.17229, "epss_percentile": 0.94802}, "CVE-2009-4004": {"epss_score": 0.00052, "epss_percentile": 0.16444}, "CVE-2009-4005": {"epss_score": 0.00054, "epss_percentile": 0.17074}, "CVE-2009-4006": {"epss_score": 0.7787, "epss_percentile": 0.98957}, "CVE-2009-4007": {"epss_score": 0.01657, "epss_percentile": 0.81606}, "CVE-2009-4008": {"epss_score": 0.00256, "epss_percentile": 0.48836}, "CVE-2009-4009": {"epss_score": 0.00039, "epss_percentile": 0.11537}, "CVE-2009-4010": {"epss_score": 6e-05, "epss_percentile": 0.00268}, "CVE-2009-4011": {"epss_score": 0.00388, "epss_percentile": 0.59345}, "CVE-2009-4012": {"epss_score": 0.02259, "epss_percentile": 0.84185}, "CVE-2009-4013": {"epss_score": 0.00836, "epss_percentile": 0.74135}, "CVE-2009-4014": {"epss_score": 0.02035, "epss_percentile": 0.83352}, "CVE-2009-4015": {"epss_score": 0.01156, "epss_percentile": 0.7808}, "CVE-2009-4016": {"epss_score": 0.04008, "epss_percentile": 0.88106}, "CVE-2009-4017": {"epss_score": 0.0143, "epss_percentile": 0.80239}, "CVE-2009-4018": {"epss_score": 0.22311, "epss_percentile": 0.95621}, "CVE-2009-4019": {"epss_score": 0.07665, "epss_percentile": 0.9161}, "CVE-2009-4020": {"epss_score": 0.03814, "epss_percentile": 0.87764}, "CVE-2009-4021": {"epss_score": 0.00056, "epss_percentile": 0.17865}, "CVE-2009-4022": {"epss_score": 0.20044, "epss_percentile": 0.95279}, "CVE-2009-4023": {"epss_score": 0.03135, "epss_percentile": 0.86478}, "CVE-2009-4024": {"epss_score": 0.02811, "epss_percentile": 0.85722}, "CVE-2009-4025": {"epss_score": 0.05802, "epss_percentile": 0.9022}, "CVE-2009-4026": {"epss_score": 0.01292, "epss_percentile": 0.79234}, "CVE-2009-4027": {"epss_score": 0.01135, "epss_percentile": 0.77897}, "CVE-2009-4028": {"epss_score": 0.01585, "epss_percentile": 0.81166}, "CVE-2009-4029": {"epss_score": 0.00688, "epss_percentile": 0.71198}, "CVE-2009-4030": {"epss_score": 0.00038, "epss_percentile": 0.11184}, "CVE-2009-4031": {"epss_score": 0.02234, "epss_percentile": 0.84097}, "CVE-2009-4032": {"epss_score": 0.06761, "epss_percentile": 0.91009}, "CVE-2009-4033": {"epss_score": 0.0004, "epss_percentile": 0.12195}, "CVE-2009-4034": {"epss_score": 0.01113, "epss_percentile": 0.7769}, "CVE-2009-4035": {"epss_score": 0.0245, "epss_percentile": 0.84778}, "CVE-2009-4037": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2009-4038": {"epss_score": 0.00387, "epss_percentile": 0.59333}, "CVE-2009-4039": {"epss_score": 0.0247, "epss_percentile": 0.84846}, "CVE-2009-4040": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-4041": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2009-4042": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-4043": {"epss_score": 0.00427, "epss_percentile": 0.61883}, "CVE-2009-4044": {"epss_score": 0.00822, "epss_percentile": 0.7391}, "CVE-2009-4045": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2009-4046": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4047": {"epss_score": 0.0071, "epss_percentile": 0.71716}, "CVE-2009-4048": {"epss_score": 0.02451, "epss_percentile": 0.84785}, "CVE-2009-4049": {"epss_score": 0.00403, "epss_percentile": 0.60388}, "CVE-2009-4050": {"epss_score": 0.01889, "epss_percentile": 0.82724}, "CVE-2009-4051": {"epss_score": 0.0428, "epss_percentile": 0.88488}, "CVE-2009-4052": {"epss_score": 0.00419, "epss_percentile": 0.6139}, "CVE-2009-4053": {"epss_score": 0.04259, "epss_percentile": 0.88461}, "CVE-2009-4055": {"epss_score": 0.00524, "epss_percentile": 0.66319}, "CVE-2009-4056": {"epss_score": 0.01297, "epss_percentile": 0.79267}, "CVE-2009-4057": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2009-4058": {"epss_score": 0.00405, "epss_percentile": 0.60508}, "CVE-2009-4059": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2009-4060": {"epss_score": 0.0023, "epss_percentile": 0.45716}, "CVE-2009-4061": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-4062": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-4063": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-4064": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-4065": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-4066": {"epss_score": 0.00199, "epss_percentile": 0.42106}, "CVE-2009-4067": {"epss_score": 0.00609, "epss_percentile": 0.69124}, "CVE-2009-4069": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-4070": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4071": {"epss_score": 0.00756, "epss_percentile": 0.72728}, "CVE-2009-4072": {"epss_score": 0.01394, "epss_percentile": 0.79968}, "CVE-2009-4073": {"epss_score": 0.26655, "epss_percentile": 0.96164}, "CVE-2009-4074": {"epss_score": 0.19684, "epss_percentile": 0.95225}, "CVE-2009-4075": {"epss_score": 0.01687, "epss_percentile": 0.81758}, "CVE-2009-4076": {"epss_score": 0.00212, "epss_percentile": 0.43749}, "CVE-2009-4077": {"epss_score": 0.00212, "epss_percentile": 0.43749}, "CVE-2009-4078": {"epss_score": 0.00705, "epss_percentile": 0.71583}, "CVE-2009-4079": {"epss_score": 0.00269, "epss_percentile": 0.50113}, "CVE-2009-4080": {"epss_score": 0.00062, "epss_percentile": 0.19742}, "CVE-2009-4081": {"epss_score": 0.0006, "epss_percentile": 0.19143}, "CVE-2009-4082": {"epss_score": 0.03241, "epss_percentile": 0.86734}, "CVE-2009-4083": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4084": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2009-4085": {"epss_score": 0.00615, "epss_percentile": 0.69312}, "CVE-2009-4086": {"epss_score": 0.025, "epss_percentile": 0.84919}, "CVE-2009-4087": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2009-4088": {"epss_score": 0.1497, "epss_percentile": 0.94336}, "CVE-2009-4089": {"epss_score": 0.10773, "epss_percentile": 0.93099}, "CVE-2009-4090": {"epss_score": 0.03019, "epss_percentile": 0.86221}, "CVE-2009-4091": {"epss_score": 0.03273, "epss_percentile": 0.86799}, "CVE-2009-4092": {"epss_score": 0.00317, "epss_percentile": 0.54387}, "CVE-2009-4093": {"epss_score": 0.02083, "epss_percentile": 0.83539}, "CVE-2009-4094": {"epss_score": 0.00903, "epss_percentile": 0.75201}, "CVE-2009-4095": {"epss_score": 0.00383, "epss_percentile": 0.59107}, "CVE-2009-4096": {"epss_score": 0.02176, "epss_percentile": 0.83885}, "CVE-2009-4097": {"epss_score": 0.07999, "epss_percentile": 0.91817}, "CVE-2009-4098": {"epss_score": 0.50581, "epss_percentile": 0.97741}, "CVE-2009-4099": {"epss_score": 0.0093, "epss_percentile": 0.75596}, "CVE-2009-4100": {"epss_score": 0.02693, "epss_percentile": 0.8544}, "CVE-2009-4101": {"epss_score": 0.01456, "epss_percentile": 0.80394}, "CVE-2009-4102": {"epss_score": 0.01455, "epss_percentile": 0.80389}, "CVE-2009-4103": {"epss_score": 0.00835, "epss_percentile": 0.74125}, "CVE-2009-4104": {"epss_score": 0.00378, "epss_percentile": 0.58824}, "CVE-2009-4105": {"epss_score": 0.03159, "epss_percentile": 0.86522}, "CVE-2009-4106": {"epss_score": 0.01285, "epss_percentile": 0.79178}, "CVE-2009-4107": {"epss_score": 0.05035, "epss_percentile": 0.89417}, "CVE-2009-4108": {"epss_score": 0.04858, "epss_percentile": 0.89219}, "CVE-2009-4109": {"epss_score": 0.00346, "epss_percentile": 0.56638}, "CVE-2009-4110": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2009-4111": {"epss_score": 0.00707, "epss_percentile": 0.71657}, "CVE-2009-4112": {"epss_score": 0.0843, "epss_percentile": 0.92048}, "CVE-2009-4113": {"epss_score": 0.00478, "epss_percentile": 0.64397}, "CVE-2009-4114": {"epss_score": 0.00387, "epss_percentile": 0.59306}, "CVE-2009-4115": {"epss_score": 0.00816, "epss_percentile": 0.73798}, "CVE-2009-4116": {"epss_score": 0.00658, "epss_percentile": 0.70497}, "CVE-2009-4117": {"epss_score": 0.25631, "epss_percentile": 0.96052}, "CVE-2009-4118": {"epss_score": 0.00275, "epss_percentile": 0.5068}, "CVE-2009-4119": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-4120": {"epss_score": 0.00138, "epss_percentile": 0.34374}, "CVE-2009-4121": {"epss_score": 0.00188, "epss_percentile": 0.40906}, "CVE-2009-4123": {"epss_score": 0.00265, "epss_percentile": 0.49751}, "CVE-2009-4124": {"epss_score": 0.02052, "epss_percentile": 0.83408}, "CVE-2009-4127": {"epss_score": 0.01236, "epss_percentile": 0.7877}, "CVE-2009-4128": {"epss_score": 0.00039, "epss_percentile": 0.11799}, "CVE-2009-4129": {"epss_score": 0.00366, "epss_percentile": 0.58091}, "CVE-2009-4130": {"epss_score": 0.00513, "epss_percentile": 0.65939}, "CVE-2009-4131": {"epss_score": 0.00089, "epss_percentile": 0.25931}, "CVE-2009-4133": {"epss_score": 0.01434, "epss_percentile": 0.80264}, "CVE-2009-4134": {"epss_score": 0.02612, "epss_percentile": 0.85238}, "CVE-2009-4135": {"epss_score": 0.00032, "epss_percentile": 0.08821}, "CVE-2009-4136": {"epss_score": 0.01557, "epss_percentile": 0.81022}, "CVE-2009-4137": {"epss_score": 0.04884, "epss_percentile": 0.89252}, "CVE-2009-4138": {"epss_score": 0.00081, "epss_percentile": 0.2422}, "CVE-2009-4139": {"epss_score": 0.00173, "epss_percentile": 0.39122}, "CVE-2009-4140": {"epss_score": 0.91085, "epss_percentile": 0.99618}, "CVE-2009-4141": {"epss_score": 0.00116, "epss_percentile": 0.31107}, "CVE-2009-4142": {"epss_score": 0.16946, "epss_percentile": 0.94751}, "CVE-2009-4143": {"epss_score": 0.08138, "epss_percentile": 0.91897}, "CVE-2009-4144": {"epss_score": 0.01278, "epss_percentile": 0.79122}, "CVE-2009-4145": {"epss_score": 0.00062, "epss_percentile": 0.19557}, "CVE-2009-4146": {"epss_score": 0.1817, "epss_percentile": 0.94969}, "CVE-2009-4147": {"epss_score": 0.12579, "epss_percentile": 0.93721}, "CVE-2009-4148": {"epss_score": 0.01663, "epss_percentile": 0.81638}, "CVE-2009-4149": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4150": {"epss_score": 0.00105, "epss_percentile": 0.29366}, "CVE-2009-4151": {"epss_score": 0.00377, "epss_percentile": 0.58718}, "CVE-2009-4152": {"epss_score": 0.00321, "epss_percentile": 0.54651}, "CVE-2009-4153": {"epss_score": 0.00463, "epss_percentile": 0.63631}, "CVE-2009-4154": {"epss_score": 0.01814, "epss_percentile": 0.82382}, "CVE-2009-4155": {"epss_score": 0.00233, "epss_percentile": 0.46022}, "CVE-2009-4156": {"epss_score": 0.00607, "epss_percentile": 0.69058}, "CVE-2009-4157": {"epss_score": 0.00315, "epss_percentile": 0.54171}, "CVE-2009-4158": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2009-4159": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2009-4160": {"epss_score": 0.00307, "epss_percentile": 0.53474}, "CVE-2009-4161": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4162": {"epss_score": 0.00059, "epss_percentile": 0.18648}, "CVE-2009-4163": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4164": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4165": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4166": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4167": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2009-4168": {"epss_score": 0.05199, "epss_percentile": 0.89601}, "CVE-2009-4169": {"epss_score": 0.00254, "epss_percentile": 0.48621}, "CVE-2009-4170": {"epss_score": 0.01971, "epss_percentile": 0.83106}, "CVE-2009-4171": {"epss_score": 0.03149, "epss_percentile": 0.86503}, "CVE-2009-4172": {"epss_score": 0.00823, "epss_percentile": 0.73924}, "CVE-2009-4173": {"epss_score": 0.00159, "epss_percentile": 0.37414}, "CVE-2009-4174": {"epss_score": 0.01085, "epss_percentile": 0.77405}, "CVE-2009-4175": {"epss_score": 0.01749, "epss_percentile": 0.82088}, "CVE-2009-4176": {"epss_score": 0.25562, "epss_percentile": 0.96044}, "CVE-2009-4177": {"epss_score": 0.21286, "epss_percentile": 0.95495}, "CVE-2009-4178": {"epss_score": 0.86098, "epss_percentile": 0.99366}, "CVE-2009-4179": {"epss_score": 0.77533, "epss_percentile": 0.9894}, "CVE-2009-4180": {"epss_score": 0.33831, "epss_percentile": 0.96808}, "CVE-2009-4181": {"epss_score": 0.1869, "epss_percentile": 0.95054}, "CVE-2009-4182": {"epss_score": 0.00816, "epss_percentile": 0.73796}, "CVE-2009-4183": {"epss_score": 0.00082, "epss_percentile": 0.24578}, "CVE-2009-4184": {"epss_score": 0.00046, "epss_percentile": 0.14284}, "CVE-2009-4185": {"epss_score": 0.00644, "epss_percentile": 0.70079}, "CVE-2009-4186": {"epss_score": 0.0477, "epss_percentile": 0.89126}, "CVE-2009-4187": {"epss_score": 0.00178, "epss_percentile": 0.39658}, "CVE-2009-4188": {"epss_score": 0.85992, "epss_percentile": 0.9936}, "CVE-2009-4189": {"epss_score": 0.83488, "epss_percentile": 0.9925}, "CVE-2009-4190": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2009-4191": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2009-4192": {"epss_score": 0.01099, "epss_percentile": 0.77559}, "CVE-2009-4193": {"epss_score": 0.00031, "epss_percentile": 0.08552}, "CVE-2009-4194": {"epss_score": 0.01812, "epss_percentile": 0.82371}, "CVE-2009-4195": {"epss_score": 0.87197, "epss_percentile": 0.99419}, "CVE-2009-4196": {"epss_score": 0.00758, "epss_percentile": 0.72777}, "CVE-2009-4197": {"epss_score": 0.00137, "epss_percentile": 0.34253}, "CVE-2009-4198": {"epss_score": 0.00207, "epss_percentile": 0.43149}, "CVE-2009-4199": {"epss_score": 0.00661, "epss_percentile": 0.7058}, "CVE-2009-4200": {"epss_score": 0.00661, "epss_percentile": 0.7058}, "CVE-2009-4201": {"epss_score": 0.04914, "epss_percentile": 0.89283}, "CVE-2009-4202": {"epss_score": 0.04613, "epss_percentile": 0.88919}, "CVE-2009-4203": {"epss_score": 0.00434, "epss_percentile": 0.62287}, "CVE-2009-4204": {"epss_score": 0.00233, "epss_percentile": 0.46022}, "CVE-2009-4205": {"epss_score": 0.01888, "epss_percentile": 0.82719}, "CVE-2009-4206": {"epss_score": 0.00243, "epss_percentile": 0.47504}, "CVE-2009-4207": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2009-4208": {"epss_score": 0.00233, "epss_percentile": 0.46022}, "CVE-2009-4209": {"epss_score": 0.00204, "epss_percentile": 0.42599}, "CVE-2009-4210": {"epss_score": 0.24044, "epss_percentile": 0.95849}, "CVE-2009-4211": {"epss_score": 0.0046, "epss_percentile": 0.63518}, "CVE-2009-4212": {"epss_score": 0.16485, "epss_percentile": 0.94678}, "CVE-2009-4214": {"epss_score": 0.01632, "epss_percentile": 0.81457}, "CVE-2009-4215": {"epss_score": 0.00041, "epss_percentile": 0.12328}, "CVE-2009-4216": {"epss_score": 0.01828, "epss_percentile": 0.8244}, "CVE-2009-4217": {"epss_score": 0.00292, "epss_percentile": 0.5225}, "CVE-2009-4218": {"epss_score": 0.00661, "epss_percentile": 0.7058}, "CVE-2009-4219": {"epss_score": 0.06939, "epss_percentile": 0.9113}, "CVE-2009-4220": {"epss_score": 0.0094, "epss_percentile": 0.75742}, "CVE-2009-4221": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2009-4222": {"epss_score": 0.01387, "epss_percentile": 0.79916}, "CVE-2009-4223": {"epss_score": 0.04261, "epss_percentile": 0.88463}, "CVE-2009-4224": {"epss_score": 0.05465, "epss_percentile": 0.89903}, "CVE-2009-4225": {"epss_score": 0.65811, "epss_percentile": 0.98439}, "CVE-2009-4226": {"epss_score": 0.00616, "epss_percentile": 0.69333}, "CVE-2009-4227": {"epss_score": 0.17017, "epss_percentile": 0.9476}, "CVE-2009-4228": {"epss_score": 0.00665, "epss_percentile": 0.70672}, "CVE-2009-4229": {"epss_score": 0.00719, "epss_percentile": 0.71939}, "CVE-2009-4230": {"epss_score": 0.02695, "epss_percentile": 0.85443}, "CVE-2009-4231": {"epss_score": 0.00908, "epss_percentile": 0.75285}, "CVE-2009-4232": {"epss_score": 0.00267, "epss_percentile": 0.49999}, "CVE-2009-4233": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-4234": {"epss_score": 0.00513, "epss_percentile": 0.65896}, "CVE-2009-4235": {"epss_score": 0.00037, "epss_percentile": 0.10819}, "CVE-2009-4236": {"epss_score": 0.00592, "epss_percentile": 0.68615}, "CVE-2009-4237": {"epss_score": 0.00905, "epss_percentile": 0.75236}, "CVE-2009-4238": {"epss_score": 0.00967, "epss_percentile": 0.76072}, "CVE-2009-4239": {"epss_score": 0.00463, "epss_percentile": 0.63697}, "CVE-2009-4240": {"epss_score": 0.01371, "epss_percentile": 0.79806}, "CVE-2009-4241": {"epss_score": 0.06588, "epss_percentile": 0.90871}, "CVE-2009-4242": {"epss_score": 0.12604, "epss_percentile": 0.93727}, "CVE-2009-4243": {"epss_score": 0.00851, "epss_percentile": 0.74405}, "CVE-2009-4244": {"epss_score": 0.06588, "epss_percentile": 0.90871}, "CVE-2009-4245": {"epss_score": 0.07358, "epss_percentile": 0.91431}, "CVE-2009-4246": {"epss_score": 0.05889, "epss_percentile": 0.90297}, "CVE-2009-4247": {"epss_score": 0.0956, "epss_percentile": 0.92599}, "CVE-2009-4248": {"epss_score": 0.07358, "epss_percentile": 0.91431}, "CVE-2009-4249": {"epss_score": 0.03418, "epss_percentile": 0.87095}, "CVE-2009-4250": {"epss_score": 0.0532, "epss_percentile": 0.89728}, "CVE-2009-4251": {"epss_score": 0.07815, "epss_percentile": 0.91696}, "CVE-2009-4252": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-4253": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2009-4254": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2009-4255": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-4256": {"epss_score": 0.00357, "epss_percentile": 0.57464}, "CVE-2009-4257": {"epss_score": 0.1084, "epss_percentile": 0.93129}, "CVE-2009-4261": {"epss_score": 0.00682, "epss_percentile": 0.71068}, "CVE-2009-4262": {"epss_score": 0.00467, "epss_percentile": 0.63855}, "CVE-2009-4263": {"epss_score": 0.00292, "epss_percentile": 0.5225}, "CVE-2009-4264": {"epss_score": 0.0085, "epss_percentile": 0.74384}, "CVE-2009-4265": {"epss_score": 0.67067, "epss_percentile": 0.98492}, "CVE-2009-4266": {"epss_score": 0.00723, "epss_percentile": 0.72022}, "CVE-2009-4267": {"epss_score": 0.00206, "epss_percentile": 0.42952}, "CVE-2009-4269": {"epss_score": 0.00784, "epss_percentile": 0.7323}, "CVE-2009-4270": {"epss_score": 0.0864, "epss_percentile": 0.92168}, "CVE-2009-4271": {"epss_score": 0.00047, "epss_percentile": 0.14707}, "CVE-2009-4272": {"epss_score": 0.0181, "epss_percentile": 0.82363}, "CVE-2009-4273": {"epss_score": 0.20175, "epss_percentile": 0.95298}, "CVE-2009-4274": {"epss_score": 0.02543, "epss_percentile": 0.85055}, "CVE-2009-4292": {"epss_score": 0.0622, "epss_percentile": 0.90578}, "CVE-2009-4293": {"epss_score": 0.00918, "epss_percentile": 0.75437}, "CVE-2009-4294": {"epss_score": 0.03896, "epss_percentile": 0.87915}, "CVE-2009-4295": {"epss_score": 0.00372, "epss_percentile": 0.5845}, "CVE-2009-4296": {"epss_score": 0.0075, "epss_percentile": 0.72632}, "CVE-2009-4297": {"epss_score": 0.00404, "epss_percentile": 0.60445}, "CVE-2009-4298": {"epss_score": 0.00746, "epss_percentile": 0.72549}, "CVE-2009-4299": {"epss_score": 0.00867, "epss_percentile": 0.7466}, "CVE-2009-4300": {"epss_score": 0.0059, "epss_percentile": 0.68568}, "CVE-2009-4301": {"epss_score": 0.00877, "epss_percentile": 0.74804}, "CVE-2009-4302": {"epss_score": 0.00889, "epss_percentile": 0.75016}, "CVE-2009-4303": {"epss_score": 0.0064, "epss_percentile": 0.69961}, "CVE-2009-4304": {"epss_score": 0.01245, "epss_percentile": 0.78843}, "CVE-2009-4305": {"epss_score": 0.00839, "epss_percentile": 0.74185}, "CVE-2009-4306": {"epss_score": 0.00049, "epss_percentile": 0.15361}, "CVE-2009-4307": {"epss_score": 0.03356, "epss_percentile": 0.86974}, "CVE-2009-4308": {"epss_score": 0.03871, "epss_percentile": 0.87881}, "CVE-2009-4309": {"epss_score": 0.30584, "epss_percentile": 0.96554}, "CVE-2009-4310": {"epss_score": 0.30584, "epss_percentile": 0.96554}, "CVE-2009-4311": {"epss_score": 0.25387, "epss_percentile": 0.96023}, "CVE-2009-4312": {"epss_score": 0.25387, "epss_percentile": 0.96023}, "CVE-2009-4313": {"epss_score": 0.29084, "epss_percentile": 0.96416}, "CVE-2009-4314": {"epss_score": 0.00051, "epss_percentile": 0.16051}, "CVE-2009-4315": {"epss_score": 0.02279, "epss_percentile": 0.84239}, "CVE-2009-4316": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4317": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2009-4318": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2009-4319": {"epss_score": 0.0089, "epss_percentile": 0.75026}, "CVE-2009-4320": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-4321": {"epss_score": 0.00819, "epss_percentile": 0.73873}, "CVE-2009-4322": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2009-4323": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2009-4324": {"epss_score": 0.93013, "epss_percentile": 0.99767}, "CVE-2009-4325": {"epss_score": 0.0178, "epss_percentile": 0.82236}, "CVE-2009-4326": {"epss_score": 0.00664, "epss_percentile": 0.70629}, "CVE-2009-4327": {"epss_score": 0.01042, "epss_percentile": 0.76974}, "CVE-2009-4328": {"epss_score": 0.01108, "epss_percentile": 0.7764}, "CVE-2009-4329": {"epss_score": 0.01015, "epss_percentile": 0.76666}, "CVE-2009-4330": {"epss_score": 0.00077, "epss_percentile": 0.23385}, "CVE-2009-4331": {"epss_score": 0.00097, "epss_percentile": 0.27483}, "CVE-2009-4332": {"epss_score": 0.00923, "epss_percentile": 0.75509}, "CVE-2009-4333": {"epss_score": 0.00348, "epss_percentile": 0.56846}, "CVE-2009-4334": {"epss_score": 0.00049, "epss_percentile": 0.15487}, "CVE-2009-4335": {"epss_score": 0.0173, "epss_percentile": 0.81988}, "CVE-2009-4336": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-4337": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4338": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4339": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4340": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-4341": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4342": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4343": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-4344": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-4345": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-4346": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2009-4347": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-4348": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4349": {"epss_score": 0.01897, "epss_percentile": 0.82756}, "CVE-2009-4350": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2009-4351": {"epss_score": 0.00663, "epss_percentile": 0.70623}, "CVE-2009-4352": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2009-4353": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-4354": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4355": {"epss_score": 0.20241, "epss_percentile": 0.95307}, "CVE-2009-4356": {"epss_score": 0.0517, "epss_percentile": 0.8957}, "CVE-2009-4357": {"epss_score": 0.00337, "epss_percentile": 0.56027}, "CVE-2009-4358": {"epss_score": 0.00046, "epss_percentile": 0.14178}, "CVE-2009-4359": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2009-4360": {"epss_score": 0.0038, "epss_percentile": 0.58956}, "CVE-2009-4361": {"epss_score": 0.00047, "epss_percentile": 0.14877}, "CVE-2009-4362": {"epss_score": 0.00047, "epss_percentile": 0.14877}, "CVE-2009-4363": {"epss_score": 0.00477, "epss_percentile": 0.64348}, "CVE-2009-4364": {"epss_score": 0.00182, "epss_percentile": 0.40186}, "CVE-2009-4365": {"epss_score": 0.00146, "epss_percentile": 0.35636}, "CVE-2009-4366": {"epss_score": 0.00911, "epss_percentile": 0.75328}, "CVE-2009-4367": {"epss_score": 0.06723, "epss_percentile": 0.90968}, "CVE-2009-4368": {"epss_score": 0.00658, "epss_percentile": 0.7049}, "CVE-2009-4369": {"epss_score": 0.00256, "epss_percentile": 0.48787}, "CVE-2009-4370": {"epss_score": 0.00156, "epss_percentile": 0.36994}, "CVE-2009-4371": {"epss_score": 0.00154, "epss_percentile": 0.36756}, "CVE-2009-4372": {"epss_score": 0.08824, "epss_percentile": 0.92272}, "CVE-2009-4373": {"epss_score": 0.02379, "epss_percentile": 0.8456}, "CVE-2009-4374": {"epss_score": 0.00153, "epss_percentile": 0.36528}, "CVE-2009-4375": {"epss_score": 0.00171, "epss_percentile": 0.38767}, "CVE-2009-4376": {"epss_score": 0.03136, "epss_percentile": 0.8648}, "CVE-2009-4377": {"epss_score": 0.0151, "epss_percentile": 0.80771}, "CVE-2009-4378": {"epss_score": 0.00541, "epss_percentile": 0.67047}, "CVE-2009-4379": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-4380": {"epss_score": 0.0038, "epss_percentile": 0.58957}, "CVE-2009-4381": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2009-4382": {"epss_score": 0.01759, "epss_percentile": 0.8214}, "CVE-2009-4383": {"epss_score": 0.00422, "epss_percentile": 0.61563}, "CVE-2009-4384": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-4385": {"epss_score": 0.00114, "epss_percentile": 0.30744}, "CVE-2009-4386": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2009-4387": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2009-4388": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2009-4389": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2009-4390": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4391": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4392": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4393": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4394": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4395": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4396": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4397": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4398": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4399": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4400": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4401": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4402": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2009-4403": {"epss_score": 0.01549, "epss_percentile": 0.8098}, "CVE-2009-4404": {"epss_score": 0.00564, "epss_percentile": 0.67768}, "CVE-2009-4405": {"epss_score": 0.00572, "epss_percentile": 0.68037}, "CVE-2009-4406": {"epss_score": 0.00378, "epss_percentile": 0.58778}, "CVE-2009-4407": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2009-4408": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4409": {"epss_score": 0.0029, "epss_percentile": 0.52082}, "CVE-2009-4410": {"epss_score": 0.00066, "epss_percentile": 0.20877}, "CVE-2009-4411": {"epss_score": 0.00068, "epss_percentile": 0.21187}, "CVE-2009-4412": {"epss_score": 0.02105, "epss_percentile": 0.83622}, "CVE-2009-4413": {"epss_score": 0.12414, "epss_percentile": 0.93663}, "CVE-2009-4414": {"epss_score": 0.00783, "epss_percentile": 0.73214}, "CVE-2009-4415": {"epss_score": 0.00414, "epss_percentile": 0.61019}, "CVE-2009-4416": {"epss_score": 0.00557, "epss_percentile": 0.67549}, "CVE-2009-4417": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2009-4418": {"epss_score": 0.00398, "epss_percentile": 0.60065}, "CVE-2009-4419": {"epss_score": 0.00055, "epss_percentile": 0.17452}, "CVE-2009-4420": {"epss_score": 0.02971, "epss_percentile": 0.86095}, "CVE-2009-4421": {"epss_score": 0.01877, "epss_percentile": 0.82666}, "CVE-2009-4422": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2009-4423": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2009-4424": {"epss_score": 0.00263, "epss_percentile": 0.49472}, "CVE-2009-4425": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2009-4426": {"epss_score": 0.04746, "epss_percentile": 0.89098}, "CVE-2009-4427": {"epss_score": 0.18921, "epss_percentile": 0.95097}, "CVE-2009-4428": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2009-4429": {"epss_score": 0.00483, "epss_percentile": 0.64567}, "CVE-2009-4430": {"epss_score": 0.00292, "epss_percentile": 0.5225}, "CVE-2009-4431": {"epss_score": 0.00936, "epss_percentile": 0.7568}, "CVE-2009-4432": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2009-4433": {"epss_score": 0.02973, "epss_percentile": 0.86101}, "CVE-2009-4434": {"epss_score": 0.03471, "epss_percentile": 0.87199}, "CVE-2009-4435": {"epss_score": 0.01853, "epss_percentile": 0.82548}, "CVE-2009-4436": {"epss_score": 0.00878, "epss_percentile": 0.7482}, "CVE-2009-4437": {"epss_score": 0.00887, "epss_percentile": 0.74991}, "CVE-2009-4438": {"epss_score": 0.01007, "epss_percentile": 0.76563}, "CVE-2009-4439": {"epss_score": 0.01108, "epss_percentile": 0.7764}, "CVE-2009-4440": {"epss_score": 0.01144, "epss_percentile": 0.77987}, "CVE-2009-4441": {"epss_score": 0.01798, "epss_percentile": 0.82314}, "CVE-2009-4442": {"epss_score": 0.01331, "epss_percentile": 0.79519}, "CVE-2009-4443": {"epss_score": 0.01483, "epss_percentile": 0.80584}, "CVE-2009-4444": {"epss_score": 0.58584, "epss_percentile": 0.98125}, "CVE-2009-4445": {"epss_score": 0.10061, "epss_percentile": 0.92837}, "CVE-2009-4446": {"epss_score": 0.00723, "epss_percentile": 0.72022}, "CVE-2009-4447": {"epss_score": 0.02526, "epss_percentile": 0.85015}, "CVE-2009-4448": {"epss_score": 0.01238, "epss_percentile": 0.78788}, "CVE-2009-4449": {"epss_score": 0.00501, "epss_percentile": 0.6534}, "CVE-2009-4450": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2009-4451": {"epss_score": 0.02978, "epss_percentile": 0.86113}, "CVE-2009-4452": {"epss_score": 0.00155, "epss_percentile": 0.3676}, "CVE-2009-4453": {"epss_score": 0.02688, "epss_percentile": 0.85433}, "CVE-2009-4454": {"epss_score": 0.00061, "epss_percentile": 0.19304}, "CVE-2009-4455": {"epss_score": 0.00406, "epss_percentile": 0.60549}, "CVE-2009-4456": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-4457": {"epss_score": 0.00415, "epss_percentile": 0.61119}, "CVE-2009-4458": {"epss_score": 0.02149, "epss_percentile": 0.83776}, "CVE-2009-4459": {"epss_score": 0.00276, "epss_percentile": 0.50754}, "CVE-2009-4460": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2009-4461": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2009-4462": {"epss_score": 0.50668, "epss_percentile": 0.97744}, "CVE-2009-4463": {"epss_score": 0.01954, "epss_percentile": 0.83029}, "CVE-2009-4464": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2009-4465": {"epss_score": 0.01575, "epss_percentile": 0.81108}, "CVE-2009-4466": {"epss_score": 0.01497, "epss_percentile": 0.8069}, "CVE-2009-4467": {"epss_score": 0.00833, "epss_percentile": 0.74089}, "CVE-2009-4468": {"epss_score": 0.00723, "epss_percentile": 0.72022}, "CVE-2009-4469": {"epss_score": 0.00723, "epss_percentile": 0.72022}, "CVE-2009-4470": {"epss_score": 0.00292, "epss_percentile": 0.5225}, "CVE-2009-4471": {"epss_score": 0.00586, "epss_percentile": 0.68459}, "CVE-2009-4472": {"epss_score": 0.00517, "epss_percentile": 0.66073}, "CVE-2009-4473": {"epss_score": 0.00778, "epss_percentile": 0.73134}, "CVE-2009-4474": {"epss_score": 0.00279, "epss_percentile": 0.5095}, "CVE-2009-4475": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2009-4476": {"epss_score": 0.05781, "epss_percentile": 0.90202}, "CVE-2009-4477": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2009-4478": {"epss_score": 0.01601, "epss_percentile": 0.81265}, "CVE-2009-4479": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2009-4480": {"epss_score": 0.04084, "epss_percentile": 0.88224}, "CVE-2009-4482": {"epss_score": 0.06121, "epss_percentile": 0.90494}, "CVE-2009-4483": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2009-4484": {"epss_score": 0.74607, "epss_percentile": 0.98809}, "CVE-2009-4486": {"epss_score": 0.07601, "epss_percentile": 0.91562}, "CVE-2009-4487": {"epss_score": 0.01301, "epss_percentile": 0.7929}, "CVE-2009-4488": {"epss_score": 0.02636, "epss_percentile": 0.85294}, "CVE-2009-4489": {"epss_score": 0.08294, "epss_percentile": 0.91975}, "CVE-2009-4490": {"epss_score": 0.03901, "epss_percentile": 0.87922}, "CVE-2009-4491": {"epss_score": 0.02714, "epss_percentile": 0.85506}, "CVE-2009-4492": {"epss_score": 0.16086, "epss_percentile": 0.9457}, "CVE-2009-4493": {"epss_score": 0.03495, "epss_percentile": 0.87236}, "CVE-2009-4494": {"epss_score": 0.03435, "epss_percentile": 0.87131}, "CVE-2009-4495": {"epss_score": 0.03932, "epss_percentile": 0.87976}, "CVE-2009-4496": {"epss_score": 0.10053, "epss_percentile": 0.92831}, "CVE-2009-4497": {"epss_score": 0.00192, "epss_percentile": 0.41351}, "CVE-2009-4498": {"epss_score": 0.71776, "epss_percentile": 0.9868}, "CVE-2009-4499": {"epss_score": 0.00825, "epss_percentile": 0.73951}, "CVE-2009-4500": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2009-4501": {"epss_score": 0.04567, "epss_percentile": 0.88858}, "CVE-2009-4502": {"epss_score": 0.64138, "epss_percentile": 0.98366}, "CVE-2009-4505": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4509": {"epss_score": 0.02844, "epss_percentile": 0.85817}, "CVE-2009-4510": {"epss_score": 0.00645, "epss_percentile": 0.70113}, "CVE-2009-4511": {"epss_score": 0.01712, "epss_percentile": 0.81885}, "CVE-2009-4512": {"epss_score": 0.01747, "epss_percentile": 0.82076}, "CVE-2009-4513": {"epss_score": 0.00262, "epss_percentile": 0.49364}, "CVE-2009-4514": {"epss_score": 0.00207, "epss_percentile": 0.43129}, "CVE-2009-4515": {"epss_score": 0.0047, "epss_percentile": 0.63978}, "CVE-2009-4516": {"epss_score": 0.00256, "epss_percentile": 0.48789}, "CVE-2009-4517": {"epss_score": 0.00108, "epss_percentile": 0.29832}, "CVE-2009-4518": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2009-4519": {"epss_score": 0.00395, "epss_percentile": 0.59838}, "CVE-2009-4520": {"epss_score": 0.00188, "epss_percentile": 0.40862}, "CVE-2009-4521": {"epss_score": 0.03711, "epss_percentile": 0.87608}, "CVE-2009-4522": {"epss_score": 0.01601, "epss_percentile": 0.81265}, "CVE-2009-4523": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-4524": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-4525": {"epss_score": 0.00427, "epss_percentile": 0.61883}, "CVE-2009-4526": {"epss_score": 0.00595, "epss_percentile": 0.68683}, "CVE-2009-4527": {"epss_score": 0.00105, "epss_percentile": 0.29336}, "CVE-2009-4528": {"epss_score": 0.00356, "epss_percentile": 0.57346}, "CVE-2009-4529": {"epss_score": 0.00591, "epss_percentile": 0.68588}, "CVE-2009-4530": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2009-4531": {"epss_score": 0.07072, "epss_percentile": 0.91229}, "CVE-2009-4532": {"epss_score": 0.00262, "epss_percentile": 0.49364}, "CVE-2009-4533": {"epss_score": 0.0058, "epss_percentile": 0.6824}, "CVE-2009-4534": {"epss_score": 0.00174, "epss_percentile": 0.3919}, "CVE-2009-4535": {"epss_score": 0.02853, "epss_percentile": 0.85832}, "CVE-2009-4536": {"epss_score": 0.01586, "epss_percentile": 0.81177}, "CVE-2009-4537": {"epss_score": 0.03723, "epss_percentile": 0.87628}, "CVE-2009-4538": {"epss_score": 0.05503, "epss_percentile": 0.89939}, "CVE-2009-4539": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2009-4540": {"epss_score": 0.00319, "epss_percentile": 0.5448}, "CVE-2009-4541": {"epss_score": 0.04326, "epss_percentile": 0.88554}, "CVE-2009-4542": {"epss_score": 0.01334, "epss_percentile": 0.7954}, "CVE-2009-4543": {"epss_score": 0.011, "epss_percentile": 0.77566}, "CVE-2009-4544": {"epss_score": 0.00902, "epss_percentile": 0.75191}, "CVE-2009-4545": {"epss_score": 0.01612, "epss_percentile": 0.81338}, "CVE-2009-4546": {"epss_score": 0.01545, "epss_percentile": 0.80962}, "CVE-2009-4547": {"epss_score": 0.0239, "epss_percentile": 0.84596}, "CVE-2009-4548": {"epss_score": 0.02274, "epss_percentile": 0.84225}, "CVE-2009-4549": {"epss_score": 0.04745, "epss_percentile": 0.89088}, "CVE-2009-4550": {"epss_score": 0.00357, "epss_percentile": 0.57464}, "CVE-2009-4551": {"epss_score": 0.00317, "epss_percentile": 0.54392}, "CVE-2009-4552": {"epss_score": 0.00204, "epss_percentile": 0.42599}, "CVE-2009-4553": {"epss_score": 0.03044, "epss_percentile": 0.86279}, "CVE-2009-4554": {"epss_score": 0.01039, "epss_percentile": 0.76949}, "CVE-2009-4555": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2009-4556": {"epss_score": 0.00081, "epss_percentile": 0.24252}, "CVE-2009-4557": {"epss_score": 0.00281, "epss_percentile": 0.51152}, "CVE-2009-4558": {"epss_score": 0.0047, "epss_percentile": 0.63978}, "CVE-2009-4559": {"epss_score": 0.00162, "epss_percentile": 0.37753}, "CVE-2009-4560": {"epss_score": 0.00112, "epss_percentile": 0.30409}, "CVE-2009-4561": {"epss_score": 0.00112, "epss_percentile": 0.30409}, "CVE-2009-4562": {"epss_score": 0.0019, "epss_percentile": 0.41089}, "CVE-2009-4563": {"epss_score": 0.00981, "epss_percentile": 0.76277}, "CVE-2009-4564": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-4565": {"epss_score": 0.00771, "epss_percentile": 0.73007}, "CVE-2009-4566": {"epss_score": 0.00425, "epss_percentile": 0.61725}, "CVE-2009-4567": {"epss_score": 0.00184, "epss_percentile": 0.40395}, "CVE-2009-4568": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2009-4569": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2009-4570": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2009-4571": {"epss_score": 0.00479, "epss_percentile": 0.64446}, "CVE-2009-4572": {"epss_score": 0.00149, "epss_percentile": 0.35989}, "CVE-2009-4573": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2009-4574": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2009-4575": {"epss_score": 0.01142, "epss_percentile": 0.77973}, "CVE-2009-4576": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2009-4577": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2009-4578": {"epss_score": 0.01507, "epss_percentile": 0.80753}, "CVE-2009-4579": {"epss_score": 0.00014, "epss_percentile": 0.01908}, "CVE-2009-4580": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2009-4581": {"epss_score": 0.05453, "epss_percentile": 0.89894}, "CVE-2009-4582": {"epss_score": 0.00305, "epss_percentile": 0.53371}, "CVE-2009-4583": {"epss_score": 0.00023, "epss_percentile": 0.05423}, "CVE-2009-4584": {"epss_score": 0.00427, "epss_percentile": 0.61776}, "CVE-2009-4585": {"epss_score": 0.05486, "epss_percentile": 0.89924}, "CVE-2009-4586": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-4587": {"epss_score": 0.10869, "epss_percentile": 0.9314}, "CVE-2009-4588": {"epss_score": 0.64987, "epss_percentile": 0.98399}, "CVE-2009-4589": {"epss_score": 0.00388, "epss_percentile": 0.59344}, "CVE-2009-4590": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2009-4591": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2009-4592": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2009-4593": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2009-4594": {"epss_score": 0.0043, "epss_percentile": 0.62023}, "CVE-2009-4595": {"epss_score": 0.00104, "epss_percentile": 0.29167}, "CVE-2009-4596": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2009-4597": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2009-4598": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2009-4599": {"epss_score": 0.00375, "epss_percentile": 0.58601}, "CVE-2009-4600": {"epss_score": 0.00484, "epss_percentile": 0.64625}, "CVE-2009-4601": {"epss_score": 0.00647, "epss_percentile": 0.702}, "CVE-2009-4602": {"epss_score": 0.00246, "epss_percentile": 0.47779}, "CVE-2009-4603": {"epss_score": 0.00672, "epss_percentile": 0.70825}, "CVE-2009-4604": {"epss_score": 0.01395, "epss_percentile": 0.79974}, "CVE-2009-4605": {"epss_score": 0.0047, "epss_percentile": 0.63989}, "CVE-2009-4606": {"epss_score": 0.00272, "epss_percentile": 0.50362}, "CVE-2009-4607": {"epss_score": 0.00315, "epss_percentile": 0.54166}, "CVE-2009-4608": {"epss_score": 0.00786, "epss_percentile": 0.73292}, "CVE-2009-4609": {"epss_score": 0.00373, "epss_percentile": 0.58519}, "CVE-2009-4610": {"epss_score": 0.00389, "epss_percentile": 0.59401}, "CVE-2009-4611": {"epss_score": 0.00948, "epss_percentile": 0.7583}, "CVE-2009-4612": {"epss_score": 0.0013, "epss_percentile": 0.33325}, "CVE-2009-4613": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2009-4614": {"epss_score": 0.00495, "epss_percentile": 0.65107}, "CVE-2009-4615": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-4616": {"epss_score": 0.00238, "epss_percentile": 0.46826}, "CVE-2009-4617": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-4618": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-4619": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2009-4620": {"epss_score": 0.00718, "epss_percentile": 0.71938}, "CVE-2009-4621": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2009-4622": {"epss_score": 0.00495, "epss_percentile": 0.65107}, "CVE-2009-4623": {"epss_score": 0.0305, "epss_percentile": 0.8629}, "CVE-2009-4624": {"epss_score": 0.00405, "epss_percentile": 0.60508}, "CVE-2009-4625": {"epss_score": 0.00193, "epss_percentile": 0.4144}, "CVE-2009-4626": {"epss_score": 0.00951, "epss_percentile": 0.75865}, "CVE-2009-4627": {"epss_score": 0.01717, "epss_percentile": 0.81919}, "CVE-2009-4628": {"epss_score": 0.02336, "epss_percentile": 0.84417}, "CVE-2009-4629": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2009-4630": {"epss_score": 0.00232, "epss_percentile": 0.45907}, "CVE-2009-4631": {"epss_score": 0.03598, "epss_percentile": 0.87406}, "CVE-2009-4632": {"epss_score": 0.03478, "epss_percentile": 0.87215}, "CVE-2009-4633": {"epss_score": 0.06787, "epss_percentile": 0.91027}, "CVE-2009-4634": {"epss_score": 0.05987, "epss_percentile": 0.90383}, "CVE-2009-4635": {"epss_score": 0.09713, "epss_percentile": 0.92673}, "CVE-2009-4636": {"epss_score": 0.0318, "epss_percentile": 0.86577}, "CVE-2009-4637": {"epss_score": 0.33811, "epss_percentile": 0.96805}, "CVE-2009-4638": {"epss_score": 0.02706, "epss_percentile": 0.85467}, "CVE-2009-4639": {"epss_score": 0.04116, "epss_percentile": 0.88278}, "CVE-2009-4640": {"epss_score": 0.03623, "epss_percentile": 0.87447}, "CVE-2009-4641": {"epss_score": 0.00053, "epss_percentile": 0.16978}, "CVE-2009-4642": {"epss_score": 0.00155, "epss_percentile": 0.3679}, "CVE-2009-4643": {"epss_score": 0.04087, "epss_percentile": 0.88228}, "CVE-2009-4644": {"epss_score": 0.00432, "epss_percentile": 0.62123}, "CVE-2009-4645": {"epss_score": 0.03425, "epss_percentile": 0.87112}, "CVE-2009-4646": {"epss_score": 0.00598, "epss_percentile": 0.68785}, "CVE-2009-4647": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4648": {"epss_score": 0.00283, "epss_percentile": 0.51355}, "CVE-2009-4649": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2009-4650": {"epss_score": 0.00426, "epss_percentile": 0.61755}, "CVE-2009-4651": {"epss_score": 0.00204, "epss_percentile": 0.42599}, "CVE-2009-4652": {"epss_score": 0.01107, "epss_percentile": 0.77626}, "CVE-2009-4653": {"epss_score": 0.06039, "epss_percentile": 0.90428}, "CVE-2009-4654": {"epss_score": 0.15487, "epss_percentile": 0.94436}, "CVE-2009-4655": {"epss_score": 0.6034, "epss_percentile": 0.98205}, "CVE-2009-4656": {"epss_score": 0.68422, "epss_percentile": 0.98547}, "CVE-2009-4657": {"epss_score": 0.01411, "epss_percentile": 0.80108}, "CVE-2009-4658": {"epss_score": 0.0145, "epss_percentile": 0.80355}, "CVE-2009-4659": {"epss_score": 0.02133, "epss_percentile": 0.83722}, "CVE-2009-4660": {"epss_score": 0.80719, "epss_percentile": 0.99102}, "CVE-2009-4661": {"epss_score": 0.03759, "epss_percentile": 0.87686}, "CVE-2009-4662": {"epss_score": 0.00884, "epss_percentile": 0.74928}, "CVE-2009-4663": {"epss_score": 0.08639, "epss_percentile": 0.92167}, "CVE-2009-4664": {"epss_score": 0.00038, "epss_percentile": 0.11349}, "CVE-2009-4665": {"epss_score": 0.03118, "epss_percentile": 0.86441}, "CVE-2009-4666": {"epss_score": 0.01766, "epss_percentile": 0.82171}, "CVE-2009-4667": {"epss_score": 0.00225, "epss_percentile": 0.45146}, "CVE-2009-4668": {"epss_score": 0.23155, "epss_percentile": 0.95744}, "CVE-2009-4669": {"epss_score": 0.00233, "epss_percentile": 0.46022}, "CVE-2009-4670": {"epss_score": 0.0239, "epss_percentile": 0.84596}, "CVE-2009-4671": {"epss_score": 0.00881, "epss_percentile": 0.74879}, "CVE-2009-4672": {"epss_score": 0.03369, "epss_percentile": 0.87007}, "CVE-2009-4673": {"epss_score": 0.00844, "epss_percentile": 0.74271}, "CVE-2009-4674": {"epss_score": 0.0265, "epss_percentile": 0.85344}, "CVE-2009-4675": {"epss_score": 0.02411, "epss_percentile": 0.84666}, "CVE-2009-4676": {"epss_score": 0.05606, "epss_percentile": 0.90043}, "CVE-2009-4677": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-4678": {"epss_score": 0.01601, "epss_percentile": 0.81265}, "CVE-2009-4679": {"epss_score": 0.23302, "epss_percentile": 0.95762}, "CVE-2009-4680": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2009-4681": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-4682": {"epss_score": 0.00846, "epss_percentile": 0.74323}, "CVE-2009-4683": {"epss_score": 0.01258, "epss_percentile": 0.78958}, "CVE-2009-4684": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-4685": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-4686": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-4687": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-4688": {"epss_score": 0.00851, "epss_percentile": 0.744}, "CVE-2009-4689": {"epss_score": 0.00406, "epss_percentile": 0.60514}, "CVE-2009-4690": {"epss_score": 0.04341, "epss_percentile": 0.88569}, "CVE-2009-4691": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2009-4692": {"epss_score": 0.01142, "epss_percentile": 0.77973}, "CVE-2009-4693": {"epss_score": 0.01193, "epss_percentile": 0.78408}, "CVE-2009-4694": {"epss_score": 0.00846, "epss_percentile": 0.74323}, "CVE-2009-4695": {"epss_score": 0.00484, "epss_percentile": 0.64625}, "CVE-2009-4696": {"epss_score": 0.00484, "epss_percentile": 0.64625}, "CVE-2009-4697": {"epss_score": 0.01142, "epss_percentile": 0.77973}, "CVE-2009-4698": {"epss_score": 0.01956, "epss_percentile": 0.83038}, "CVE-2009-4699": {"epss_score": 0.02823, "epss_percentile": 0.8575}, "CVE-2009-4700": {"epss_score": 0.03502, "epss_percentile": 0.87251}, "CVE-2009-4701": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4702": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4703": {"epss_score": 0.00337, "epss_percentile": 0.56026}, "CVE-2009-4704": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2009-4705": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4706": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4707": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4708": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4709": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4710": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4711": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4712": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2009-4713": {"epss_score": 0.01142, "epss_percentile": 0.77973}, "CVE-2009-4714": {"epss_score": 0.00647, "epss_percentile": 0.702}, "CVE-2009-4715": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4716": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4717": {"epss_score": 0.00193, "epss_percentile": 0.4138}, "CVE-2009-4718": {"epss_score": 0.00337, "epss_percentile": 0.56026}, "CVE-2009-4719": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-4720": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4721": {"epss_score": 0.00265, "epss_percentile": 0.49771}, "CVE-2009-4722": {"epss_score": 0.0038, "epss_percentile": 0.58928}, "CVE-2009-4723": {"epss_score": 0.01061, "epss_percentile": 0.77177}, "CVE-2009-4724": {"epss_score": 0.00124, "epss_percentile": 0.32367}, "CVE-2009-4725": {"epss_score": 0.00951, "epss_percentile": 0.75865}, "CVE-2009-4726": {"epss_score": 0.01696, "epss_percentile": 0.81813}, "CVE-2009-4727": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-4728": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-4729": {"epss_score": 0.01615, "epss_percentile": 0.81348}, "CVE-2009-4730": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-4731": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2009-4732": {"epss_score": 0.00406, "epss_percentile": 0.60514}, "CVE-2009-4733": {"epss_score": 0.00326, "epss_percentile": 0.55082}, "CVE-2009-4734": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-4735": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2009-4736": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2009-4737": {"epss_score": 0.03, "epss_percentile": 0.86164}, "CVE-2009-4738": {"epss_score": 0.00067, "epss_percentile": 0.21166}, "CVE-2009-4739": {"epss_score": 0.02264, "epss_percentile": 0.84194}, "CVE-2009-4740": {"epss_score": 0.0013, "epss_percentile": 0.33266}, "CVE-2009-4741": {"epss_score": 0.00414, "epss_percentile": 0.61017}, "CVE-2009-4742": {"epss_score": 0.00164, "epss_percentile": 0.37937}, "CVE-2009-4743": {"epss_score": 0.0249, "epss_percentile": 0.84895}, "CVE-2009-4744": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4745": {"epss_score": 0.00147, "epss_percentile": 0.3579}, "CVE-2009-4746": {"epss_score": 0.00164, "epss_percentile": 0.37975}, "CVE-2009-4747": {"epss_score": 0.00795, "epss_percentile": 0.73468}, "CVE-2009-4748": {"epss_score": 0.00484, "epss_percentile": 0.64664}, "CVE-2009-4749": {"epss_score": 0.00362, "epss_percentile": 0.57768}, "CVE-2009-4750": {"epss_score": 0.011, "epss_percentile": 0.77566}, "CVE-2009-4751": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2009-4752": {"epss_score": 0.011, "epss_percentile": 0.77566}, "CVE-2009-4753": {"epss_score": 0.08772, "epss_percentile": 0.92248}, "CVE-2009-4754": {"epss_score": 0.28472, "epss_percentile": 0.9636}, "CVE-2009-4755": {"epss_score": 0.16564, "epss_percentile": 0.94692}, "CVE-2009-4756": {"epss_score": 0.37195, "epss_percentile": 0.97027}, "CVE-2009-4757": {"epss_score": 0.17239, "epss_percentile": 0.94804}, "CVE-2009-4758": {"epss_score": 0.23329, "epss_percentile": 0.95767}, "CVE-2009-4759": {"epss_score": 0.17239, "epss_percentile": 0.94804}, "CVE-2009-4760": {"epss_score": 0.03844, "epss_percentile": 0.87839}, "CVE-2009-4761": {"epss_score": 0.19969, "epss_percentile": 0.95267}, "CVE-2009-4762": {"epss_score": 0.0037, "epss_percentile": 0.58332}, "CVE-2009-4763": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2009-4764": {"epss_score": 0.02892, "epss_percentile": 0.85918}, "CVE-2009-4765": {"epss_score": 0.00319, "epss_percentile": 0.54483}, "CVE-2009-4766": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2009-4767": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2009-4768": {"epss_score": 0.02464, "epss_percentile": 0.84832}, "CVE-2009-4769": {"epss_score": 0.62136, "epss_percentile": 0.98282}, "CVE-2009-4770": {"epss_score": 0.00467, "epss_percentile": 0.63855}, "CVE-2009-4771": {"epss_score": 0.00433, "epss_percentile": 0.62199}, "CVE-2009-4772": {"epss_score": 0.00335, "epss_percentile": 0.55835}, "CVE-2009-4773": {"epss_score": 0.00147, "epss_percentile": 0.35668}, "CVE-2009-4774": {"epss_score": 0.0004, "epss_percentile": 0.11997}, "CVE-2009-4775": {"epss_score": 0.16155, "epss_percentile": 0.9458}, "CVE-2009-4776": {"epss_score": 0.01341, "epss_percentile": 0.79587}, "CVE-2009-4777": {"epss_score": 0.00768, "epss_percentile": 0.72974}, "CVE-2009-4778": {"epss_score": 0.02373, "epss_percentile": 0.84533}, "CVE-2009-4779": {"epss_score": 0.00727, "epss_percentile": 0.72086}, "CVE-2009-4780": {"epss_score": 0.00138, "epss_percentile": 0.34408}, "CVE-2009-4781": {"epss_score": 0.00136, "epss_percentile": 0.34139}, "CVE-2009-4782": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2009-4783": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2009-4784": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2009-4785": {"epss_score": 0.00288, "epss_percentile": 0.51976}, "CVE-2009-4786": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-4787": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2009-4788": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2009-4789": {"epss_score": 0.00936, "epss_percentile": 0.7568}, "CVE-2009-4790": {"epss_score": 0.01388, "epss_percentile": 0.79919}, "CVE-2009-4791": {"epss_score": 0.01723, "epss_percentile": 0.81941}, "CVE-2009-4792": {"epss_score": 0.00844, "epss_percentile": 0.74271}, "CVE-2009-4793": {"epss_score": 0.02522, "epss_percentile": 0.85004}, "CVE-2009-4794": {"epss_score": 0.00292, "epss_percentile": 0.5225}, "CVE-2009-4795": {"epss_score": 0.00174, "epss_percentile": 0.39222}, "CVE-2009-4796": {"epss_score": 0.00738, "epss_percentile": 0.72348}, "CVE-2009-4797": {"epss_score": 0.00844, "epss_percentile": 0.74271}, "CVE-2009-4798": {"epss_score": 0.0085, "epss_percentile": 0.74389}, "CVE-2009-4799": {"epss_score": 0.03844, "epss_percentile": 0.87839}, "CVE-2009-4800": {"epss_score": 0.02432, "epss_percentile": 0.8473}, "CVE-2009-4801": {"epss_score": 0.0239, "epss_percentile": 0.84596}, "CVE-2009-4802": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2009-4803": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4804": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2009-4805": {"epss_score": 0.00691, "epss_percentile": 0.71265}, "CVE-2009-4806": {"epss_score": 0.02411, "epss_percentile": 0.84666}, "CVE-2009-4807": {"epss_score": 0.00808, "epss_percentile": 0.73692}, "CVE-2009-4808": {"epss_score": 0.01786, "epss_percentile": 0.82255}, "CVE-2009-4809": {"epss_score": 0.03767, "epss_percentile": 0.87697}, "CVE-2009-4810": {"epss_score": 0.00458, "epss_percentile": 0.63401}, "CVE-2009-4811": {"epss_score": 0.01279, "epss_percentile": 0.79135}, "CVE-2009-4812": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2009-4813": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2009-4814": {"epss_score": 0.01493, "epss_percentile": 0.80643}, "CVE-2009-4815": {"epss_score": 0.00433, "epss_percentile": 0.62222}, "CVE-2009-4816": {"epss_score": 0.01863, "epss_percentile": 0.82598}, "CVE-2009-4817": {"epss_score": 0.03363, "epss_percentile": 0.86996}, "CVE-2009-4818": {"epss_score": 0.01455, "epss_percentile": 0.80387}, "CVE-2009-4819": {"epss_score": 0.02558, "epss_percentile": 0.851}, "CVE-2009-4820": {"epss_score": 0.05023, "epss_percentile": 0.89405}, "CVE-2009-4821": {"epss_score": 0.00193, "epss_percentile": 0.41438}, "CVE-2009-4822": {"epss_score": 0.00498, "epss_percentile": 0.65244}, "CVE-2009-4823": {"epss_score": 0.01372, "epss_percentile": 0.79814}, "CVE-2009-4824": {"epss_score": 0.00572, "epss_percentile": 0.68037}, "CVE-2009-4825": {"epss_score": 0.05023, "epss_percentile": 0.89405}, "CVE-2009-4826": {"epss_score": 0.00099, "epss_percentile": 0.27855}, "CVE-2009-4827": {"epss_score": 0.00099, "epss_percentile": 0.27855}, "CVE-2009-4828": {"epss_score": 0.00099, "epss_percentile": 0.27855}, "CVE-2009-4829": {"epss_score": 0.00262, "epss_percentile": 0.49364}, "CVE-2009-4830": {"epss_score": 0.00538, "epss_percentile": 0.66941}, "CVE-2009-4831": {"epss_score": 0.00449, "epss_percentile": 0.63052}, "CVE-2009-4832": {"epss_score": 0.00102, "epss_percentile": 0.28877}, "CVE-2009-4833": {"epss_score": 0.00428, "epss_percentile": 0.61953}, "CVE-2009-4834": {"epss_score": 0.01296, "epss_percentile": 0.79254}, "CVE-2009-4835": {"epss_score": 0.00371, "epss_percentile": 0.58344}, "CVE-2009-4836": {"epss_score": 0.01539, "epss_percentile": 0.80938}, "CVE-2009-4837": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4838": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4839": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2009-4840": {"epss_score": 0.05086, "epss_percentile": 0.89479}, "CVE-2009-4841": {"epss_score": 0.04745, "epss_percentile": 0.89088}, "CVE-2009-4842": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4843": {"epss_score": 0.01837, "epss_percentile": 0.82483}, "CVE-2009-4844": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2009-4845": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2009-4846": {"epss_score": 0.06888, "epss_percentile": 0.91093}, "CVE-2009-4847": {"epss_score": 0.00455, "epss_percentile": 0.63299}, "CVE-2009-4848": {"epss_score": 0.00235, "epss_percentile": 0.46342}, "CVE-2009-4849": {"epss_score": 0.00207, "epss_percentile": 0.43157}, "CVE-2009-4850": {"epss_score": 0.63693, "epss_percentile": 0.98344}, "CVE-2009-4851": {"epss_score": 0.00264, "epss_percentile": 0.49713}, "CVE-2009-4852": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4853": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-4854": {"epss_score": 0.05093, "epss_percentile": 0.89489}, "CVE-2009-4855": {"epss_score": 0.00721, "epss_percentile": 0.71987}, "CVE-2009-4856": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-4857": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2009-4858": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-4859": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4860": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-4861": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4862": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-4863": {"epss_score": 0.07999, "epss_percentile": 0.91817}, "CVE-2009-4864": {"epss_score": 0.00193, "epss_percentile": 0.41445}, "CVE-2009-4865": {"epss_score": 0.00377, "epss_percentile": 0.58763}, "CVE-2009-4866": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4867": {"epss_score": 0.06036, "epss_percentile": 0.90426}, "CVE-2009-4868": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-4869": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-4870": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-4871": {"epss_score": 0.00279, "epss_percentile": 0.5095}, "CVE-2009-4872": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-4873": {"epss_score": 0.60236, "epss_percentile": 0.982}, "CVE-2009-4874": {"epss_score": 0.05181, "epss_percentile": 0.8958}, "CVE-2009-4875": {"epss_score": 0.01798, "epss_percentile": 0.82314}, "CVE-2009-4876": {"epss_score": 0.01979, "epss_percentile": 0.83133}, "CVE-2009-4877": {"epss_score": 0.00151, "epss_percentile": 0.36222}, "CVE-2009-4878": {"epss_score": 0.00606, "epss_percentile": 0.69021}, "CVE-2009-4879": {"epss_score": 0.00096, "epss_percentile": 0.27302}, "CVE-2009-4880": {"epss_score": 0.13534, "epss_percentile": 0.93989}, "CVE-2009-4881": {"epss_score": 0.00674, "epss_percentile": 0.70878}, "CVE-2009-4882": {"epss_score": 0.00643, "epss_percentile": 0.70058}, "CVE-2009-4883": {"epss_score": 0.01046, "epss_percentile": 0.77027}, "CVE-2009-4884": {"epss_score": 0.00484, "epss_percentile": 0.64634}, "CVE-2009-4885": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2009-4886": {"epss_score": 0.02648, "epss_percentile": 0.85339}, "CVE-2009-4887": {"epss_score": 0.00525, "epss_percentile": 0.66395}, "CVE-2009-4888": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2009-4889": {"epss_score": 0.00691, "epss_percentile": 0.71265}, "CVE-2009-4890": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2009-4891": {"epss_score": 0.00526, "epss_percentile": 0.66403}, "CVE-2009-4892": {"epss_score": 0.00719, "epss_percentile": 0.71939}, "CVE-2009-4893": {"epss_score": 0.01674, "epss_percentile": 0.81691}, "CVE-2009-4894": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4895": {"epss_score": 0.00064, "epss_percentile": 0.20335}, "CVE-2009-4896": {"epss_score": 0.01589, "epss_percentile": 0.81194}, "CVE-2009-4897": {"epss_score": 0.08294, "epss_percentile": 0.91975}, "CVE-2009-4898": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2009-4899": {"epss_score": 0.00294, "epss_percentile": 0.52385}, "CVE-2009-4900": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2009-4901": {"epss_score": 0.0007, "epss_percentile": 0.21833}, "CVE-2009-4902": {"epss_score": 0.0005, "epss_percentile": 0.15672}, "CVE-2009-4903": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-4904": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2009-4905": {"epss_score": 0.00099, "epss_percentile": 0.27855}, "CVE-2009-4906": {"epss_score": 0.00155, "epss_percentile": 0.36859}, "CVE-2009-4907": {"epss_score": 0.00155, "epss_percentile": 0.36859}, "CVE-2009-4908": {"epss_score": 0.02062, "epss_percentile": 0.83444}, "CVE-2009-4909": {"epss_score": 0.00402, "epss_percentile": 0.60316}, "CVE-2009-4910": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2009-4911": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2009-4912": {"epss_score": 0.0028, "epss_percentile": 0.51039}, "CVE-2009-4913": {"epss_score": 0.00157, "epss_percentile": 0.37036}, "CVE-2009-4914": {"epss_score": 0.0023, "epss_percentile": 0.45665}, "CVE-2009-4915": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2009-4916": {"epss_score": 0.0043, "epss_percentile": 0.62023}, "CVE-2009-4917": {"epss_score": 0.00339, "epss_percentile": 0.5621}, "CVE-2009-4918": {"epss_score": 0.00339, "epss_percentile": 0.5621}, "CVE-2009-4919": {"epss_score": 0.00614, "epss_percentile": 0.69282}, "CVE-2009-4920": {"epss_score": 0.00339, "epss_percentile": 0.5621}, "CVE-2009-4921": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2009-4922": {"epss_score": 0.00363, "epss_percentile": 0.57874}, "CVE-2009-4923": {"epss_score": 0.00339, "epss_percentile": 0.5621}, "CVE-2009-4924": {"epss_score": 0.00245, "epss_percentile": 0.47691}, "CVE-2009-4925": {"epss_score": 0.00405, "epss_percentile": 0.60508}, "CVE-2009-4926": {"epss_score": 0.00226, "epss_percentile": 0.45352}, "CVE-2009-4927": {"epss_score": 0.01693, "epss_percentile": 0.818}, "CVE-2009-4928": {"epss_score": 0.00498, "epss_percentile": 0.65217}, "CVE-2009-4929": {"epss_score": 0.01543, "epss_percentile": 0.80956}, "CVE-2009-4930": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2009-4931": {"epss_score": 0.02087, "epss_percentile": 0.83554}, "CVE-2009-4932": {"epss_score": 0.09132, "epss_percentile": 0.92416}, "CVE-2009-4933": {"epss_score": 0.00132, "epss_percentile": 0.33605}, "CVE-2009-4934": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2009-4935": {"epss_score": 0.0033, "epss_percentile": 0.55452}, "CVE-2009-4936": {"epss_score": 0.02104, "epss_percentile": 0.83619}, "CVE-2009-4937": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2009-4938": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2009-4939": {"epss_score": 0.02906, "epss_percentile": 0.85962}, "CVE-2009-4940": {"epss_score": 0.00233, "epss_percentile": 0.46022}, "CVE-2009-4941": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4942": {"epss_score": 0.00079, "epss_percentile": 0.23881}, "CVE-2009-4943": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2009-4944": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4945": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2009-4946": {"epss_score": 0.00161, "epss_percentile": 0.37609}, "CVE-2009-4947": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2009-4948": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2009-4949": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4950": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4951": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2009-4952": {"epss_score": 0.00307, "epss_percentile": 0.53516}, "CVE-2009-4953": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4954": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4955": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2009-4956": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4957": {"epss_score": 0.01077, "epss_percentile": 0.77336}, "CVE-2009-4958": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2009-4959": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4960": {"epss_score": 0.00092, "epss_percentile": 0.26517}, "CVE-2009-4961": {"epss_score": 0.01485, "epss_percentile": 0.80597}, "CVE-2009-4962": {"epss_score": 0.67534, "epss_percentile": 0.98512}, "CVE-2009-4963": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2009-4964": {"epss_score": 0.05825, "epss_percentile": 0.90237}, "CVE-2009-4965": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4966": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4967": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4968": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4969": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4970": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4971": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4972": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2009-4973": {"epss_score": 0.00279, "epss_percentile": 0.5095}, "CVE-2009-4974": {"epss_score": 0.00908, "epss_percentile": 0.75285}, "CVE-2009-4975": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-4976": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2009-4977": {"epss_score": 0.0061, "epss_percentile": 0.69143}, "CVE-2009-4978": {"epss_score": 0.01696, "epss_percentile": 0.81813}, "CVE-2009-4979": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2009-4980": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-4981": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2009-4982": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2009-4983": {"epss_score": 0.00179, "epss_percentile": 0.39821}, "CVE-2009-4984": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-4985": {"epss_score": 0.00279, "epss_percentile": 0.5095}, "CVE-2009-4986": {"epss_score": 0.01242, "epss_percentile": 0.78824}, "CVE-2009-4987": {"epss_score": 0.02755, "epss_percentile": 0.8559}, "CVE-2009-4988": {"epss_score": 0.79681, "epss_percentile": 0.99051}, "CVE-2009-4989": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2009-4990": {"epss_score": 0.00246, "epss_percentile": 0.47779}, "CVE-2009-4991": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2009-4992": {"epss_score": 0.00279, "epss_percentile": 0.5095}, "CVE-2009-4993": {"epss_score": 0.00582, "epss_percentile": 0.68303}, "CVE-2009-4994": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-4995": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2009-4996": {"epss_score": 0.00155, "epss_percentile": 0.3679}, "CVE-2009-4997": {"epss_score": 0.00052, "epss_percentile": 0.16632}, "CVE-2009-4998": {"epss_score": 0.0016, "epss_percentile": 0.37516}, "CVE-2009-4999": {"epss_score": 0.00202, "epss_percentile": 0.42481}, "CVE-2009-5000": {"epss_score": 0.00202, "epss_percentile": 0.42481}, "CVE-2009-5001": {"epss_score": 0.00121, "epss_percentile": 0.31889}, "CVE-2009-5002": {"epss_score": 0.00218, "epss_percentile": 0.44413}, "CVE-2009-5003": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2009-5004": {"epss_score": 0.0185, "epss_percentile": 0.82534}, "CVE-2009-5005": {"epss_score": 0.01611, "epss_percentile": 0.81327}, "CVE-2009-5006": {"epss_score": 0.00469, "epss_percentile": 0.63958}, "CVE-2009-5007": {"epss_score": 0.00041, "epss_percentile": 0.12327}, "CVE-2009-5008": {"epss_score": 0.00063, "epss_percentile": 0.19922}, "CVE-2009-5009": {"epss_score": 0.00305, "epss_percentile": 0.53327}, "CVE-2009-5010": {"epss_score": 0.01038, "epss_percentile": 0.76935}, "CVE-2009-5011": {"epss_score": 0.00437, "epss_percentile": 0.62518}, "CVE-2009-5012": {"epss_score": 0.00199, "epss_percentile": 0.42159}, "CVE-2009-5013": {"epss_score": 0.00513, "epss_percentile": 0.65938}, "CVE-2009-5014": {"epss_score": 0.00304, "epss_percentile": 0.53253}, "CVE-2009-5015": {"epss_score": 0.00296, "epss_percentile": 0.52547}, "CVE-2009-5016": {"epss_score": 0.03454, "epss_percentile": 0.8717}, "CVE-2009-5017": {"epss_score": 0.00166, "epss_percentile": 0.38157}, "CVE-2009-5018": {"epss_score": 0.22062, "epss_percentile": 0.9559}, "CVE-2009-5019": {"epss_score": 0.08027, "epss_percentile": 0.91839}, "CVE-2009-5020": {"epss_score": 0.01473, "epss_percentile": 0.80516}, "CVE-2009-5021": {"epss_score": 0.00296, "epss_percentile": 0.52547}, "CVE-2009-5022": {"epss_score": 0.16073, "epss_percentile": 0.94567}, "CVE-2009-5023": {"epss_score": 0.00048, "epss_percentile": 0.15082}, "CVE-2009-5024": {"epss_score": 0.00503, "epss_percentile": 0.65443}, "CVE-2009-5025": {"epss_score": 0.0085, "epss_percentile": 0.74393}, "CVE-2009-5026": {"epss_score": 0.03152, "epss_percentile": 0.86508}, "CVE-2009-5028": {"epss_score": 0.03265, "epss_percentile": 0.86782}, "CVE-2009-5029": {"epss_score": 0.02765, "epss_percentile": 0.8561}, "CVE-2009-5030": {"epss_score": 0.04533, "epss_percentile": 0.88814}, "CVE-2009-5031": {"epss_score": 0.00795, "epss_percentile": 0.73473}, "CVE-2009-5032": {"epss_score": 0.00278, "epss_percentile": 0.50881}, "CVE-2009-5033": {"epss_score": 0.00202, "epss_percentile": 0.42412}, "CVE-2009-5034": {"epss_score": 0.00457, "epss_percentile": 0.63355}, "CVE-2009-5035": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2009-5036": {"epss_score": 0.00405, "epss_percentile": 0.6046}, "CVE-2009-5037": {"epss_score": 0.01053, "epss_percentile": 0.771}, "CVE-2009-5038": {"epss_score": 0.00851, "epss_percentile": 0.74398}, "CVE-2009-5039": {"epss_score": 0.00607, "epss_percentile": 0.69029}, "CVE-2009-5040": {"epss_score": 0.00512, "epss_percentile": 0.65869}, "CVE-2009-5041": {"epss_score": 0.00704, "epss_percentile": 0.71566}, "CVE-2009-5042": {"epss_score": 0.00372, "epss_percentile": 0.58464}, "CVE-2009-5043": {"epss_score": 0.00432, "epss_percentile": 0.62125}, "CVE-2009-5044": {"epss_score": 0.00067, "epss_percentile": 0.21096}, "CVE-2009-5045": {"epss_score": 0.0264, "epss_percentile": 0.85301}, "CVE-2009-5046": {"epss_score": 0.01046, "epss_percentile": 0.77029}, "CVE-2009-5048": {"epss_score": 0.00796, "epss_percentile": 0.73483}, "CVE-2009-5049": {"epss_score": 0.00815, "epss_percentile": 0.7378}, "CVE-2009-5050": {"epss_score": 0.00367, "epss_percentile": 0.58125}, "CVE-2009-5051": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2009-5052": {"epss_score": 0.00583, "epss_percentile": 0.68345}, "CVE-2009-5053": {"epss_score": 0.00623, "epss_percentile": 0.69538}, "CVE-2009-5054": {"epss_score": 0.00077, "epss_percentile": 0.23449}, "CVE-2009-5055": {"epss_score": 0.00105, "epss_percentile": 0.293}, "CVE-2009-5056": {"epss_score": 0.0016, "epss_percentile": 0.37492}, "CVE-2009-5057": {"epss_score": 0.00275, "epss_percentile": 0.50674}, "CVE-2009-5058": {"epss_score": 0.00335, "epss_percentile": 0.55854}, "CVE-2009-5059": {"epss_score": 0.00335, "epss_percentile": 0.55854}, "CVE-2009-5060": {"epss_score": 0.00335, "epss_percentile": 0.55854}, "CVE-2009-5061": {"epss_score": 0.00567, "epss_percentile": 0.67859}, "CVE-2009-5062": {"epss_score": 0.00335, "epss_percentile": 0.55854}, "CVE-2009-5063": {"epss_score": 0.00469, "epss_percentile": 0.63955}, "CVE-2009-5064": {"epss_score": 0.00091, "epss_percentile": 0.26209}, "CVE-2009-5065": {"epss_score": 0.07165, "epss_percentile": 0.91295}, "CVE-2009-5066": {"epss_score": 0.00072, "epss_percentile": 0.22414}, "CVE-2009-5067": {"epss_score": 0.21029, "epss_percentile": 0.95454}, "CVE-2009-5068": {"epss_score": 0.03271, "epss_percentile": 0.86793}, "CVE-2009-5071": {"epss_score": 0.00601, "epss_percentile": 0.6885}, "CVE-2009-5072": {"epss_score": 0.00358, "epss_percentile": 0.57532}, "CVE-2009-5073": {"epss_score": 0.00358, "epss_percentile": 0.57532}, "CVE-2009-5074": {"epss_score": 0.00447, "epss_percentile": 0.62988}, "CVE-2009-5075": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2009-5076": {"epss_score": 0.00229, "epss_percentile": 0.45644}, "CVE-2009-5077": {"epss_score": 0.00224, "epss_percentile": 0.44981}, "CVE-2009-5078": {"epss_score": 0.01318, "epss_percentile": 0.79421}, "CVE-2009-5079": {"epss_score": 0.00036, "epss_percentile": 0.10386}, "CVE-2009-5080": {"epss_score": 0.00139, "epss_percentile": 0.34595}, "CVE-2009-5081": {"epss_score": 0.00114, "epss_percentile": 0.30868}, "CVE-2009-5082": {"epss_score": 0.00031, "epss_percentile": 0.0843}, "CVE-2009-5083": {"epss_score": 0.00216, "epss_percentile": 0.44126}, "CVE-2009-5084": {"epss_score": 0.00051, "epss_percentile": 0.16258}, "CVE-2009-5085": {"epss_score": 0.00141, "epss_percentile": 0.34946}, "CVE-2009-5086": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2009-5087": {"epss_score": 0.07979, "epss_percentile": 0.91801}, "CVE-2009-5088": {"epss_score": 0.00743, "epss_percentile": 0.72463}, "CVE-2009-5089": {"epss_score": 0.03696, "epss_percentile": 0.87584}, "CVE-2009-5090": {"epss_score": 0.00775, "epss_percentile": 0.7309}, "CVE-2009-5091": {"epss_score": 0.00868, "epss_percentile": 0.74677}, "CVE-2009-5092": {"epss_score": 0.13984, "epss_percentile": 0.94109}, "CVE-2009-5093": {"epss_score": 0.03375, "epss_percentile": 0.87016}, "CVE-2009-5094": {"epss_score": 0.00907, "epss_percentile": 0.75259}, "CVE-2009-5095": {"epss_score": 0.0242, "epss_percentile": 0.84701}, "CVE-2009-5096": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2009-5097": {"epss_score": 0.00796, "epss_percentile": 0.73482}, "CVE-2009-5098": {"epss_score": 0.18178, "epss_percentile": 0.9497}, "CVE-2009-5099": {"epss_score": 0.00369, "epss_percentile": 0.58253}, "CVE-2009-5100": {"epss_score": 0.00083, "epss_percentile": 0.24738}, "CVE-2009-5101": {"epss_score": 0.00291, "epss_percentile": 0.52169}, "CVE-2009-5102": {"epss_score": 0.00966, "epss_percentile": 0.7605}, "CVE-2009-5103": {"epss_score": 0.00672, "epss_percentile": 0.70826}, "CVE-2009-5109": {"epss_score": 0.60159, "epss_percentile": 0.98194}, "CVE-2009-5110": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2009-5111": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2009-5112": {"epss_score": 0.04635, "epss_percentile": 0.88948}, "CVE-2009-5113": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2009-5114": {"epss_score": 0.08663, "epss_percentile": 0.92178}, "CVE-2009-5115": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2009-5116": {"epss_score": 0.0036, "epss_percentile": 0.57622}, "CVE-2009-5117": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2009-5118": {"epss_score": 0.00724, "epss_percentile": 0.72042}, "CVE-2009-5119": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2009-5120": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2009-5121": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2009-5122": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2009-5123": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2009-5124": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2009-5125": {"epss_score": 0.00507, "epss_percentile": 0.65679}, "CVE-2009-5126": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2009-5127": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2009-5128": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2009-5129": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2009-5130": {"epss_score": 0.00408, "epss_percentile": 0.60669}, "CVE-2009-5131": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2009-5132": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2009-5134": {"epss_score": 0.07703, "epss_percentile": 0.91636}, "CVE-2009-5135": {"epss_score": 0.16663, "epss_percentile": 0.94709}, "CVE-2009-5136": {"epss_score": 0.00625, "epss_percentile": 0.69585}, "CVE-2009-5137": {"epss_score": 0.13763, "epss_percentile": 0.94053}, "CVE-2009-5138": {"epss_score": 0.01369, "epss_percentile": 0.79795}, "CVE-2009-5139": {"epss_score": 0.00216, "epss_percentile": 0.44157}, "CVE-2009-5140": {"epss_score": 0.00481, "epss_percentile": 0.64511}, "CVE-2009-5141": {"epss_score": 0.09986, "epss_percentile": 0.92805}, "CVE-2009-5142": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2009-5143": {"epss_score": 0.00568, "epss_percentile": 0.67896}, "CVE-2009-5144": {"epss_score": 0.00163, "epss_percentile": 0.3786}, "CVE-2009-5145": {"epss_score": 0.00532, "epss_percentile": 0.6668}, "CVE-2009-5147": {"epss_score": 0.52002, "epss_percentile": 0.97805}, "CVE-2009-5149": {"epss_score": 0.03641, "epss_percentile": 0.87491}, "CVE-2009-5150": {"epss_score": 0.00062, "epss_percentile": 0.19682}, "CVE-2009-5151": {"epss_score": 0.00062, "epss_percentile": 0.19682}, "CVE-2009-5152": {"epss_score": 0.00052, "epss_percentile": 0.1659}, "CVE-2009-5153": {"epss_score": 0.10346, "epss_percentile": 0.92951}, "CVE-2009-5154": {"epss_score": 0.00795, "epss_percentile": 0.73468}, "CVE-2009-5155": {"epss_score": 0.01348, "epss_percentile": 0.79659}, "CVE-2009-5156": {"epss_score": 0.06878, "epss_percentile": 0.91088}, "CVE-2009-5157": {"epss_score": 0.08973, "epss_percentile": 0.92345}, "CVE-2009-5158": {"epss_score": 0.00188, "epss_percentile": 0.40883}, "CVE-2009-5159": {"epss_score": 0.00773, "epss_percentile": 0.73062}, "CVE-2010-0001": {"epss_score": 0.3819, "epss_percentile": 0.97088}, "CVE-2010-0002": {"epss_score": 0.00333, "epss_percentile": 0.55661}, "CVE-2010-0003": {"epss_score": 0.00063, "epss_percentile": 0.19904}, "CVE-2010-0004": {"epss_score": 0.0082, "epss_percentile": 0.73878}, "CVE-2010-0005": {"epss_score": 0.00477, "epss_percentile": 0.64343}, "CVE-2010-0006": {"epss_score": 0.02175, "epss_percentile": 0.83882}, "CVE-2010-0007": {"epss_score": 0.00068, "epss_percentile": 0.2138}, "CVE-2010-0008": {"epss_score": 0.04145, "epss_percentile": 0.88314}, "CVE-2010-0009": {"epss_score": 0.00643, "epss_percentile": 0.70061}, "CVE-2010-0010": {"epss_score": 0.47445, "epss_percentile": 0.97587}, "CVE-2010-0011": {"epss_score": 0.00934, "epss_percentile": 0.75653}, "CVE-2010-0012": {"epss_score": 0.00297, "epss_percentile": 0.52703}, "CVE-2010-0013": {"epss_score": 0.12845, "epss_percentile": 0.938}, "CVE-2010-0014": {"epss_score": 0.00133, "epss_percentile": 0.33732}, "CVE-2010-0015": {"epss_score": 0.01817, "epss_percentile": 0.82396}, "CVE-2010-0016": {"epss_score": 0.22755, "epss_percentile": 0.95678}, "CVE-2010-0017": {"epss_score": 0.43931, "epss_percentile": 0.97408}, "CVE-2010-0018": {"epss_score": 0.68946, "epss_percentile": 0.98569}, "CVE-2010-0019": {"epss_score": 0.21627, "epss_percentile": 0.95541}, "CVE-2010-0020": {"epss_score": 0.23025, "epss_percentile": 0.95721}, "CVE-2010-0021": {"epss_score": 0.1141, "epss_percentile": 0.9334}, "CVE-2010-0022": {"epss_score": 0.60237, "epss_percentile": 0.982}, "CVE-2010-0023": {"epss_score": 0.01451, "epss_percentile": 0.8036}, "CVE-2010-0024": {"epss_score": 0.22548, "epss_percentile": 0.9565}, "CVE-2010-0025": {"epss_score": 0.59398, "epss_percentile": 0.98163}, "CVE-2010-0026": {"epss_score": 0.00624, "epss_percentile": 0.69564}, "CVE-2010-0027": {"epss_score": 0.50105, "epss_percentile": 0.9772}, "CVE-2010-0028": {"epss_score": 0.641, "epss_percentile": 0.98365}, "CVE-2010-0029": {"epss_score": 0.63061, "epss_percentile": 0.98319}, "CVE-2010-0030": {"epss_score": 0.62128, "epss_percentile": 0.98282}, "CVE-2010-0031": {"epss_score": 0.57317, "epss_percentile": 0.98058}, "CVE-2010-0032": {"epss_score": 0.52435, "epss_percentile": 0.97825}, "CVE-2010-0033": {"epss_score": 0.79579, "epss_percentile": 0.99045}, "CVE-2010-0034": {"epss_score": 0.57681, "epss_percentile": 0.98079}, "CVE-2010-0035": {"epss_score": 0.40087, "epss_percentile": 0.97195}, "CVE-2010-0036": {"epss_score": 0.01564, "epss_percentile": 0.81062}, "CVE-2010-0037": {"epss_score": 0.04726, "epss_percentile": 0.89064}, "CVE-2010-0038": {"epss_score": 0.00078, "epss_percentile": 0.23565}, "CVE-2010-0039": {"epss_score": 0.00307, "epss_percentile": 0.53474}, "CVE-2010-0040": {"epss_score": 0.19782, "epss_percentile": 0.95239}, "CVE-2010-0041": {"epss_score": 0.01191, "epss_percentile": 0.78397}, "CVE-2010-0042": {"epss_score": 0.00957, "epss_percentile": 0.75933}, "CVE-2010-0043": {"epss_score": 0.16213, "epss_percentile": 0.94595}, "CVE-2010-0044": {"epss_score": 0.00464, "epss_percentile": 0.63719}, "CVE-2010-0045": {"epss_score": 0.02733, "epss_percentile": 0.85546}, "CVE-2010-0046": {"epss_score": 0.09029, "epss_percentile": 0.92374}, "CVE-2010-0047": {"epss_score": 0.06257, "epss_percentile": 0.90618}, "CVE-2010-0048": {"epss_score": 0.04724, "epss_percentile": 0.89059}, "CVE-2010-0049": {"epss_score": 0.36531, "epss_percentile": 0.96984}, "CVE-2010-0050": {"epss_score": 0.45126, "epss_percentile": 0.97475}, "CVE-2010-0051": {"epss_score": 0.02404, "epss_percentile": 0.84645}, "CVE-2010-0052": {"epss_score": 0.08537, "epss_percentile": 0.9211}, "CVE-2010-0053": {"epss_score": 0.06495, "epss_percentile": 0.90799}, "CVE-2010-0054": {"epss_score": 0.08537, "epss_percentile": 0.9211}, "CVE-2010-0055": {"epss_score": 0.00647, "epss_percentile": 0.702}, "CVE-2010-0056": {"epss_score": 0.01449, "epss_percentile": 0.80339}, "CVE-2010-0057": {"epss_score": 0.00225, "epss_percentile": 0.45089}, "CVE-2010-0058": {"epss_score": 0.00904, "epss_percentile": 0.7522}, "CVE-2010-0059": {"epss_score": 0.04649, "epss_percentile": 0.88964}, "CVE-2010-0060": {"epss_score": 0.01927, "epss_percentile": 0.82928}, "CVE-2010-0062": {"epss_score": 0.03588, "epss_percentile": 0.87396}, "CVE-2010-0063": {"epss_score": 0.00345, "epss_percentile": 0.56566}, "CVE-2010-0064": {"epss_score": 0.00039, "epss_percentile": 0.11462}, "CVE-2010-0065": {"epss_score": 0.01178, "epss_percentile": 0.78282}, "CVE-2010-0066": {"epss_score": 0.00643, "epss_percentile": 0.7006}, "CVE-2010-0067": {"epss_score": 0.00663, "epss_percentile": 0.70613}, "CVE-2010-0068": {"epss_score": 0.00433, "epss_percentile": 0.62175}, "CVE-2010-0069": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-0070": {"epss_score": 0.00643, "epss_percentile": 0.7006}, "CVE-2010-0071": {"epss_score": 0.12519, "epss_percentile": 0.93706}, "CVE-2010-0072": {"epss_score": 0.10259, "epss_percentile": 0.92916}, "CVE-2010-0073": {"epss_score": 0.02293, "epss_percentile": 0.84289}, "CVE-2010-0074": {"epss_score": 0.00677, "epss_percentile": 0.70968}, "CVE-2010-0075": {"epss_score": 0.00433, "epss_percentile": 0.62175}, "CVE-2010-0076": {"epss_score": 0.00265, "epss_percentile": 0.49829}, "CVE-2010-0077": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-0078": {"epss_score": 0.00677, "epss_percentile": 0.70968}, "CVE-2010-0079": {"epss_score": 0.01278, "epss_percentile": 0.79126}, "CVE-2010-0080": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-0081": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2010-0082": {"epss_score": 0.03647, "epss_percentile": 0.87503}, "CVE-2010-0083": {"epss_score": 0.01076, "epss_percentile": 0.77325}, "CVE-2010-0084": {"epss_score": 0.01941, "epss_percentile": 0.82982}, "CVE-2010-0085": {"epss_score": 0.03647, "epss_percentile": 0.87503}, "CVE-2010-0086": {"epss_score": 0.00882, "epss_percentile": 0.74898}, "CVE-2010-0087": {"epss_score": 0.02519, "epss_percentile": 0.84995}, "CVE-2010-0088": {"epss_score": 0.03421, "epss_percentile": 0.87103}, "CVE-2010-0089": {"epss_score": 0.02925, "epss_percentile": 0.86005}, "CVE-2010-0090": {"epss_score": 0.04034, "epss_percentile": 0.88155}, "CVE-2010-0091": {"epss_score": 0.01941, "epss_percentile": 0.82982}, "CVE-2010-0092": {"epss_score": 0.06156, "epss_percentile": 0.90524}, "CVE-2010-0093": {"epss_score": 0.03647, "epss_percentile": 0.87503}, "CVE-2010-0094": {"epss_score": 0.88908, "epss_percentile": 0.99498}, "CVE-2010-0095": {"epss_score": 0.03421, "epss_percentile": 0.87103}, "CVE-2010-0097": {"epss_score": 0.02817, "epss_percentile": 0.85738}, "CVE-2010-0098": {"epss_score": 0.03391, "epss_percentile": 0.87051}, "CVE-2010-0101": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2010-0103": {"epss_score": 0.76775, "epss_percentile": 0.98905}, "CVE-2010-0104": {"epss_score": 0.19436, "epss_percentile": 0.95181}, "CVE-2010-0105": {"epss_score": 0.00343, "epss_percentile": 0.56407}, "CVE-2010-0106": {"epss_score": 0.00299, "epss_percentile": 0.52872}, "CVE-2010-0107": {"epss_score": 0.27114, "epss_percentile": 0.96208}, "CVE-2010-0108": {"epss_score": 0.13172, "epss_percentile": 0.93892}, "CVE-2010-0109": {"epss_score": 0.00553, "epss_percentile": 0.6741}, "CVE-2010-0110": {"epss_score": 0.32259, "epss_percentile": 0.96683}, "CVE-2010-0111": {"epss_score": 0.60589, "epss_percentile": 0.98211}, "CVE-2010-0112": {"epss_score": 0.04622, "epss_percentile": 0.88934}, "CVE-2010-0113": {"epss_score": 0.00445, "epss_percentile": 0.62858}, "CVE-2010-0114": {"epss_score": 0.0276, "epss_percentile": 0.85598}, "CVE-2010-0115": {"epss_score": 0.01126, "epss_percentile": 0.77814}, "CVE-2010-0116": {"epss_score": 0.12525, "epss_percentile": 0.93708}, "CVE-2010-0117": {"epss_score": 0.04103, "epss_percentile": 0.88261}, "CVE-2010-0118": {"epss_score": 0.0004, "epss_percentile": 0.12005}, "CVE-2010-0119": {"epss_score": 0.00063, "epss_percentile": 0.19859}, "CVE-2010-0120": {"epss_score": 0.12525, "epss_percentile": 0.93708}, "CVE-2010-0121": {"epss_score": 0.00404, "epss_percentile": 0.60432}, "CVE-2010-0122": {"epss_score": 0.00365, "epss_percentile": 0.57964}, "CVE-2010-0123": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2010-0124": {"epss_score": 0.00063, "epss_percentile": 0.19859}, "CVE-2010-0125": {"epss_score": 0.00404, "epss_percentile": 0.60432}, "CVE-2010-0126": {"epss_score": 0.04645, "epss_percentile": 0.8896}, "CVE-2010-0127": {"epss_score": 0.12292, "epss_percentile": 0.93624}, "CVE-2010-0128": {"epss_score": 0.08216, "epss_percentile": 0.91933}, "CVE-2010-0129": {"epss_score": 0.11547, "epss_percentile": 0.93401}, "CVE-2010-0130": {"epss_score": 0.12053, "epss_percentile": 0.93556}, "CVE-2010-0131": {"epss_score": 0.0606, "epss_percentile": 0.90442}, "CVE-2010-0132": {"epss_score": 0.00604, "epss_percentile": 0.68963}, "CVE-2010-0133": {"epss_score": 0.04645, "epss_percentile": 0.8896}, "CVE-2010-0134": {"epss_score": 0.04341, "epss_percentile": 0.88571}, "CVE-2010-0135": {"epss_score": 0.04645, "epss_percentile": 0.8896}, "CVE-2010-0136": {"epss_score": 0.04524, "epss_percentile": 0.88803}, "CVE-2010-0137": {"epss_score": 0.0131, "epss_percentile": 0.79363}, "CVE-2010-0138": {"epss_score": 0.10861, "epss_percentile": 0.93138}, "CVE-2010-0139": {"epss_score": 0.00648, "epss_percentile": 0.70221}, "CVE-2010-0140": {"epss_score": 0.00643, "epss_percentile": 0.70057}, "CVE-2010-0141": {"epss_score": 0.00274, "epss_percentile": 0.50535}, "CVE-2010-0142": {"epss_score": 0.00459, "epss_percentile": 0.63465}, "CVE-2010-0143": {"epss_score": 0.00177, "epss_percentile": 0.39611}, "CVE-2010-0144": {"epss_score": 0.00163, "epss_percentile": 0.37834}, "CVE-2010-0145": {"epss_score": 0.01356, "epss_percentile": 0.79713}, "CVE-2010-0146": {"epss_score": 0.00444, "epss_percentile": 0.62832}, "CVE-2010-0147": {"epss_score": 0.00582, "epss_percentile": 0.68306}, "CVE-2010-0148": {"epss_score": 0.01334, "epss_percentile": 0.79532}, "CVE-2010-0149": {"epss_score": 0.0063, "epss_percentile": 0.69687}, "CVE-2010-0150": {"epss_score": 0.01385, "epss_percentile": 0.79904}, "CVE-2010-0151": {"epss_score": 0.01418, "epss_percentile": 0.80156}, "CVE-2010-0152": {"epss_score": 0.00202, "epss_percentile": 0.42481}, "CVE-2010-0153": {"epss_score": 0.0013, "epss_percentile": 0.33333}, "CVE-2010-0154": {"epss_score": 0.00134, "epss_percentile": 0.33904}, "CVE-2010-0155": {"epss_score": 0.00155, "epss_percentile": 0.36777}, "CVE-2010-0156": {"epss_score": 0.00042, "epss_percentile": 0.12711}, "CVE-2010-0157": {"epss_score": 0.06394, "epss_percentile": 0.90721}, "CVE-2010-0158": {"epss_score": 0.01606, "epss_percentile": 0.81302}, "CVE-2010-0159": {"epss_score": 0.02476, "epss_percentile": 0.84863}, "CVE-2010-0160": {"epss_score": 0.05179, "epss_percentile": 0.89577}, "CVE-2010-0161": {"epss_score": 0.01503, "epss_percentile": 0.80726}, "CVE-2010-0162": {"epss_score": 0.00817, "epss_percentile": 0.73838}, "CVE-2010-0163": {"epss_score": 0.05442, "epss_percentile": 0.89884}, "CVE-2010-0164": {"epss_score": 0.07524, "epss_percentile": 0.91516}, "CVE-2010-0165": {"epss_score": 0.03502, "epss_percentile": 0.8725}, "CVE-2010-0166": {"epss_score": 0.17908, "epss_percentile": 0.94925}, "CVE-2010-0167": {"epss_score": 0.22871, "epss_percentile": 0.95702}, "CVE-2010-0168": {"epss_score": 0.09931, "epss_percentile": 0.92777}, "CVE-2010-0169": {"epss_score": 0.00424, "epss_percentile": 0.61665}, "CVE-2010-0170": {"epss_score": 0.00499, "epss_percentile": 0.65285}, "CVE-2010-0171": {"epss_score": 0.00521, "epss_percentile": 0.66224}, "CVE-2010-0172": {"epss_score": 0.00535, "epss_percentile": 0.66843}, "CVE-2010-0173": {"epss_score": 0.0757, "epss_percentile": 0.91546}, "CVE-2010-0174": {"epss_score": 0.04227, "epss_percentile": 0.88417}, "CVE-2010-0175": {"epss_score": 0.06865, "epss_percentile": 0.91083}, "CVE-2010-0176": {"epss_score": 0.09816, "epss_percentile": 0.92714}, "CVE-2010-0177": {"epss_score": 0.0651, "epss_percentile": 0.90811}, "CVE-2010-0178": {"epss_score": 0.0493, "epss_percentile": 0.89297}, "CVE-2010-0179": {"epss_score": 0.00725, "epss_percentile": 0.72063}, "CVE-2010-0180": {"epss_score": 0.00053, "epss_percentile": 0.16725}, "CVE-2010-0181": {"epss_score": 0.0264, "epss_percentile": 0.85303}, "CVE-2010-0182": {"epss_score": 0.01301, "epss_percentile": 0.79292}, "CVE-2010-0183": {"epss_score": 0.0392, "epss_percentile": 0.87952}, "CVE-2010-0184": {"epss_score": 0.00034, "epss_percentile": 0.09685}, "CVE-2010-0185": {"epss_score": 0.01646, "epss_percentile": 0.81535}, "CVE-2010-0186": {"epss_score": 0.02923, "epss_percentile": 0.86}, "CVE-2010-0187": {"epss_score": 0.41655, "epss_percentile": 0.97288}, "CVE-2010-0188": {"epss_score": 0.93597, "epss_percentile": 0.99822}, "CVE-2010-0189": {"epss_score": 0.02469, "epss_percentile": 0.84844}, "CVE-2010-0190": {"epss_score": 0.0139, "epss_percentile": 0.79938}, "CVE-2010-0191": {"epss_score": 0.18131, "epss_percentile": 0.94962}, "CVE-2010-0192": {"epss_score": 0.41095, "epss_percentile": 0.97253}, "CVE-2010-0193": {"epss_score": 0.27477, "epss_percentile": 0.9625}, "CVE-2010-0194": {"epss_score": 0.09513, "epss_percentile": 0.92579}, "CVE-2010-0195": {"epss_score": 0.18131, "epss_percentile": 0.94962}, "CVE-2010-0196": {"epss_score": 0.25691, "epss_percentile": 0.96056}, "CVE-2010-0197": {"epss_score": 0.09513, "epss_percentile": 0.92579}, "CVE-2010-0198": {"epss_score": 0.26977, "epss_percentile": 0.96196}, "CVE-2010-0199": {"epss_score": 0.26977, "epss_percentile": 0.96196}, "CVE-2010-0201": {"epss_score": 0.09513, "epss_percentile": 0.92579}, "CVE-2010-0202": {"epss_score": 0.12773, "epss_percentile": 0.93768}, "CVE-2010-0203": {"epss_score": 0.26977, "epss_percentile": 0.96196}, "CVE-2010-0204": {"epss_score": 0.06582, "epss_percentile": 0.90862}, "CVE-2010-0205": {"epss_score": 0.08131, "epss_percentile": 0.91895}, "CVE-2010-0206": {"epss_score": 0.00443, "epss_percentile": 0.62798}, "CVE-2010-0207": {"epss_score": 0.00443, "epss_percentile": 0.62798}, "CVE-2010-0209": {"epss_score": 0.01256, "epss_percentile": 0.78934}, "CVE-2010-0211": {"epss_score": 0.42633, "epss_percentile": 0.97344}, "CVE-2010-0212": {"epss_score": 0.64006, "epss_percentile": 0.98358}, "CVE-2010-0213": {"epss_score": 0.01498, "epss_percentile": 0.80694}, "CVE-2010-0214": {"epss_score": 0.01475, "epss_percentile": 0.80529}, "CVE-2010-0215": {"epss_score": 0.00109, "epss_percentile": 0.3}, "CVE-2010-0216": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2010-0217": {"epss_score": 0.00694, "epss_percentile": 0.71352}, "CVE-2010-0218": {"epss_score": 0.02115, "epss_percentile": 0.83657}, "CVE-2010-0219": {"epss_score": 0.93421, "epss_percentile": 0.99805}, "CVE-2010-0220": {"epss_score": 0.00947, "epss_percentile": 0.75819}, "CVE-2010-0221": {"epss_score": 0.0008, "epss_percentile": 0.24095}, "CVE-2010-0222": {"epss_score": 0.00077, "epss_percentile": 0.2338}, "CVE-2010-0223": {"epss_score": 0.00082, "epss_percentile": 0.24466}, "CVE-2010-0224": {"epss_score": 0.00079, "epss_percentile": 0.23826}, "CVE-2010-0225": {"epss_score": 0.00033, "epss_percentile": 0.09141}, "CVE-2010-0226": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2010-0227": {"epss_score": 0.00082, "epss_percentile": 0.24508}, "CVE-2010-0228": {"epss_score": 0.00081, "epss_percentile": 0.24214}, "CVE-2010-0229": {"epss_score": 0.0006, "epss_percentile": 0.1918}, "CVE-2010-0230": {"epss_score": 0.00218, "epss_percentile": 0.44421}, "CVE-2010-0231": {"epss_score": 0.55207, "epss_percentile": 0.97966}, "CVE-2010-0232": {"epss_score": 0.75583, "epss_percentile": 0.98856}, "CVE-2010-0233": {"epss_score": 0.00383, "epss_percentile": 0.59112}, "CVE-2010-0234": {"epss_score": 0.0061, "epss_percentile": 0.69137}, "CVE-2010-0235": {"epss_score": 0.00743, "epss_percentile": 0.72501}, "CVE-2010-0236": {"epss_score": 0.01755, "epss_percentile": 0.82121}, "CVE-2010-0237": {"epss_score": 0.0255, "epss_percentile": 0.85073}, "CVE-2010-0238": {"epss_score": 0.01014, "epss_percentile": 0.76644}, "CVE-2010-0239": {"epss_score": 0.48985, "epss_percentile": 0.97661}, "CVE-2010-0240": {"epss_score": 0.36064, "epss_percentile": 0.96953}, "CVE-2010-0241": {"epss_score": 0.36064, "epss_percentile": 0.96953}, "CVE-2010-0242": {"epss_score": 0.68425, "epss_percentile": 0.98547}, "CVE-2010-0243": {"epss_score": 0.43397, "epss_percentile": 0.97385}, "CVE-2010-0244": {"epss_score": 0.35634, "epss_percentile": 0.96924}, "CVE-2010-0245": {"epss_score": 0.33809, "epss_percentile": 0.96805}, "CVE-2010-0246": {"epss_score": 0.33809, "epss_percentile": 0.96805}, "CVE-2010-0247": {"epss_score": 0.29001, "epss_percentile": 0.96409}, "CVE-2010-0248": {"epss_score": 0.78378, "epss_percentile": 0.98984}, "CVE-2010-0249": {"epss_score": 0.90904, "epss_percentile": 0.99609}, "CVE-2010-0250": {"epss_score": 0.71114, "epss_percentile": 0.98654}, "CVE-2010-0252": {"epss_score": 0.40454, "epss_percentile": 0.97219}, "CVE-2010-0254": {"epss_score": 0.20483, "epss_percentile": 0.95354}, "CVE-2010-0255": {"epss_score": 0.49262, "epss_percentile": 0.97676}, "CVE-2010-0256": {"epss_score": 0.20483, "epss_percentile": 0.95354}, "CVE-2010-0257": {"epss_score": 0.58322, "epss_percentile": 0.98109}, "CVE-2010-0258": {"epss_score": 0.7144, "epss_percentile": 0.98668}, "CVE-2010-0260": {"epss_score": 0.57588, "epss_percentile": 0.98073}, "CVE-2010-0261": {"epss_score": 0.65469, "epss_percentile": 0.9842}, "CVE-2010-0262": {"epss_score": 0.58326, "epss_percentile": 0.9811}, "CVE-2010-0263": {"epss_score": 0.60259, "epss_percentile": 0.98202}, "CVE-2010-0264": {"epss_score": 0.56564, "epss_percentile": 0.98029}, "CVE-2010-0265": {"epss_score": 0.45601, "epss_percentile": 0.97493}, "CVE-2010-0266": {"epss_score": 0.82804, "epss_percentile": 0.99216}, "CVE-2010-0267": {"epss_score": 0.66172, "epss_percentile": 0.98454}, "CVE-2010-0268": {"epss_score": 0.44907, "epss_percentile": 0.97459}, "CVE-2010-0269": {"epss_score": 0.59222, "epss_percentile": 0.98155}, "CVE-2010-0270": {"epss_score": 0.81391, "epss_percentile": 0.99135}, "CVE-2010-0271": {"epss_score": 0.00081, "epss_percentile": 0.24214}, "CVE-2010-0272": {"epss_score": 0.0057, "epss_percentile": 0.67938}, "CVE-2010-0273": {"epss_score": 0.02024, "epss_percentile": 0.83309}, "CVE-2010-0274": {"epss_score": 0.00531, "epss_percentile": 0.66666}, "CVE-2010-0275": {"epss_score": 0.00531, "epss_percentile": 0.66666}, "CVE-2010-0276": {"epss_score": 0.00531, "epss_percentile": 0.66666}, "CVE-2010-0277": {"epss_score": 0.08804, "epss_percentile": 0.92262}, "CVE-2010-0278": {"epss_score": 0.24129, "epss_percentile": 0.95879}, "CVE-2010-0279": {"epss_score": 0.0256, "epss_percentile": 0.85101}, "CVE-2010-0280": {"epss_score": 0.03892, "epss_percentile": 0.87911}, "CVE-2010-0283": {"epss_score": 0.03728, "epss_percentile": 0.87636}, "CVE-2010-0284": {"epss_score": 0.06823, "epss_percentile": 0.91049}, "CVE-2010-0285": {"epss_score": 0.00083, "epss_percentile": 0.24815}, "CVE-2010-0286": {"epss_score": 0.00294, "epss_percentile": 0.52396}, "CVE-2010-0287": {"epss_score": 0.08488, "epss_percentile": 0.9208}, "CVE-2010-0288": {"epss_score": 0.15608, "epss_percentile": 0.94469}, "CVE-2010-0289": {"epss_score": 0.00404, "epss_percentile": 0.60445}, "CVE-2010-0290": {"epss_score": 0.04877, "epss_percentile": 0.89242}, "CVE-2010-0291": {"epss_score": 0.00113, "epss_percentile": 0.30657}, "CVE-2010-0292": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2010-0293": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2010-0294": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2010-0295": {"epss_score": 0.05563, "epss_percentile": 0.89999}, "CVE-2010-0296": {"epss_score": 0.00107, "epss_percentile": 0.29648}, "CVE-2010-0297": {"epss_score": 0.00086, "epss_percentile": 0.2535}, "CVE-2010-0298": {"epss_score": 0.00611, "epss_percentile": 0.69202}, "CVE-2010-0299": {"epss_score": 0.00041, "epss_percentile": 0.12224}, "CVE-2010-0300": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2010-0301": {"epss_score": 0.00051, "epss_percentile": 0.16056}, "CVE-2010-0302": {"epss_score": 0.0529, "epss_percentile": 0.89696}, "CVE-2010-0303": {"epss_score": 0.14552, "epss_percentile": 0.94239}, "CVE-2010-0304": {"epss_score": 0.77116, "epss_percentile": 0.98922}, "CVE-2010-0305": {"epss_score": 0.0188, "epss_percentile": 0.82689}, "CVE-2010-0306": {"epss_score": 0.00124, "epss_percentile": 0.32382}, "CVE-2010-0307": {"epss_score": 0.00284, "epss_percentile": 0.51451}, "CVE-2010-0308": {"epss_score": 0.16822, "epss_percentile": 0.94734}, "CVE-2010-0309": {"epss_score": 0.00993, "epss_percentile": 0.76413}, "CVE-2010-0310": {"epss_score": 0.00043, "epss_percentile": 0.13209}, "CVE-2010-0311": {"epss_score": 0.01348, "epss_percentile": 0.7966}, "CVE-2010-0312": {"epss_score": 0.00572, "epss_percentile": 0.68003}, "CVE-2010-0313": {"epss_score": 0.08865, "epss_percentile": 0.92292}, "CVE-2010-0314": {"epss_score": 0.07847, "epss_percentile": 0.91718}, "CVE-2010-0315": {"epss_score": 0.12535, "epss_percentile": 0.9371}, "CVE-2010-0316": {"epss_score": 0.02803, "epss_percentile": 0.85701}, "CVE-2010-0317": {"epss_score": 0.08963, "epss_percentile": 0.92338}, "CVE-2010-0318": {"epss_score": 0.00034, "epss_percentile": 0.09685}, "CVE-2010-0319": {"epss_score": 0.0209, "epss_percentile": 0.83565}, "CVE-2010-0320": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2010-0321": {"epss_score": 0.0209, "epss_percentile": 0.83565}, "CVE-2010-0322": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2010-0323": {"epss_score": 0.00281, "epss_percentile": 0.51195}, "CVE-2010-0324": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0325": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2010-0326": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2010-0327": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2010-0328": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2010-0329": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-0330": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0331": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-0332": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0333": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0334": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0335": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-0336": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2010-0337": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0338": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0339": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0340": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0341": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0342": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0343": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0344": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0345": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-0346": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-0347": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-0348": {"epss_score": 0.0018, "epss_percentile": 0.39977}, "CVE-2010-0349": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2010-0350": {"epss_score": 0.0013, "epss_percentile": 0.33266}, "CVE-2010-0356": {"epss_score": 0.65175, "epss_percentile": 0.98406}, "CVE-2010-0357": {"epss_score": 0.00634, "epss_percentile": 0.69796}, "CVE-2010-0358": {"epss_score": 0.01685, "epss_percentile": 0.81751}, "CVE-2010-0359": {"epss_score": 0.44441, "epss_percentile": 0.97436}, "CVE-2010-0360": {"epss_score": 0.00801, "epss_percentile": 0.73567}, "CVE-2010-0361": {"epss_score": 0.88394, "epss_percentile": 0.9947}, "CVE-2010-0362": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2010-0363": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-0364": {"epss_score": 0.06665, "epss_percentile": 0.90926}, "CVE-2010-0365": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2010-0366": {"epss_score": 0.03687, "epss_percentile": 0.87572}, "CVE-2010-0367": {"epss_score": 0.00939, "epss_percentile": 0.75725}, "CVE-2010-0370": {"epss_score": 0.00235, "epss_percentile": 0.4622}, "CVE-2010-0371": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2010-0372": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-0373": {"epss_score": 0.00021, "epss_percentile": 0.04912}, "CVE-2010-0374": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2010-0375": {"epss_score": 0.0014, "epss_percentile": 0.34792}, "CVE-2010-0376": {"epss_score": 0.01601, "epss_percentile": 0.81265}, "CVE-2010-0377": {"epss_score": 0.00372, "epss_percentile": 0.58433}, "CVE-2010-0378": {"epss_score": 0.073, "epss_percentile": 0.91392}, "CVE-2010-0379": {"epss_score": 0.10222, "epss_percentile": 0.929}, "CVE-2010-0380": {"epss_score": 0.01264, "epss_percentile": 0.78999}, "CVE-2010-0381": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0382": {"epss_score": 0.28405, "epss_percentile": 0.96353}, "CVE-2010-0383": {"epss_score": 0.00464, "epss_percentile": 0.63719}, "CVE-2010-0384": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2010-0385": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2010-0386": {"epss_score": 0.00679, "epss_percentile": 0.7101}, "CVE-2010-0387": {"epss_score": 0.08347, "epss_percentile": 0.92003}, "CVE-2010-0388": {"epss_score": 0.01951, "epss_percentile": 0.8302}, "CVE-2010-0389": {"epss_score": 0.00444, "epss_percentile": 0.62808}, "CVE-2010-0390": {"epss_score": 0.02978, "epss_percentile": 0.86113}, "CVE-2010-0391": {"epss_score": 0.05071, "epss_percentile": 0.89464}, "CVE-2010-0392": {"epss_score": 0.18968, "epss_percentile": 0.95104}, "CVE-2010-0393": {"epss_score": 0.0008, "epss_percentile": 0.24203}, "CVE-2010-0394": {"epss_score": 0.00661, "epss_percentile": 0.7057}, "CVE-2010-0395": {"epss_score": 0.20596, "epss_percentile": 0.95383}, "CVE-2010-0396": {"epss_score": 0.00396, "epss_percentile": 0.59864}, "CVE-2010-0397": {"epss_score": 0.07996, "epss_percentile": 0.91812}, "CVE-2010-0398": {"epss_score": 0.00431, "epss_percentile": 0.62061}, "CVE-2010-0400": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2010-0401": {"epss_score": 0.00334, "epss_percentile": 0.55683}, "CVE-2010-0402": {"epss_score": 0.01404, "epss_percentile": 0.80037}, "CVE-2010-0403": {"epss_score": 0.00659, "epss_percentile": 0.7051}, "CVE-2010-0404": {"epss_score": 0.00926, "epss_percentile": 0.75554}, "CVE-2010-0405": {"epss_score": 0.0921, "epss_percentile": 0.92449}, "CVE-2010-0406": {"epss_score": 0.00455, "epss_percentile": 0.63299}, "CVE-2010-0407": {"epss_score": 0.00043, "epss_percentile": 0.13083}, "CVE-2010-0408": {"epss_score": 0.30734, "epss_percentile": 0.96564}, "CVE-2010-0409": {"epss_score": 0.00718, "epss_percentile": 0.71934}, "CVE-2010-0410": {"epss_score": 0.00146, "epss_percentile": 0.35596}, "CVE-2010-0411": {"epss_score": 0.00125, "epss_percentile": 0.32567}, "CVE-2010-0412": {"epss_score": 0.00488, "epss_percentile": 0.64842}, "CVE-2010-0414": {"epss_score": 0.00053, "epss_percentile": 0.16793}, "CVE-2010-0415": {"epss_score": 0.04441, "epss_percentile": 0.88693}, "CVE-2010-0416": {"epss_score": 0.18879, "epss_percentile": 0.95082}, "CVE-2010-0417": {"epss_score": 0.03207, "epss_percentile": 0.86638}, "CVE-2010-0418": {"epss_score": 0.02848, "epss_percentile": 0.85824}, "CVE-2010-0419": {"epss_score": 0.00075, "epss_percentile": 0.23063}, "CVE-2010-0420": {"epss_score": 0.03316, "epss_percentile": 0.86902}, "CVE-2010-0421": {"epss_score": 0.01657, "epss_percentile": 0.81603}, "CVE-2010-0422": {"epss_score": 0.00076, "epss_percentile": 0.23271}, "CVE-2010-0423": {"epss_score": 0.08804, "epss_percentile": 0.92262}, "CVE-2010-0424": {"epss_score": 0.00096, "epss_percentile": 0.27304}, "CVE-2010-0425": {"epss_score": 0.86822, "epss_percentile": 0.994}, "CVE-2010-0426": {"epss_score": 0.0076, "epss_percentile": 0.7281}, "CVE-2010-0427": {"epss_score": 0.00078, "epss_percentile": 0.23554}, "CVE-2010-0428": {"epss_score": 0.00051, "epss_percentile": 0.16261}, "CVE-2010-0429": {"epss_score": 0.00051, "epss_percentile": 0.16261}, "CVE-2010-0430": {"epss_score": 0.00231, "epss_percentile": 0.45806}, "CVE-2010-0431": {"epss_score": 0.00051, "epss_percentile": 0.16261}, "CVE-2010-0432": {"epss_score": 0.44457, "epss_percentile": 0.97438}, "CVE-2010-0433": {"epss_score": 0.17272, "epss_percentile": 0.94813}, "CVE-2010-0434": {"epss_score": 0.02554, "epss_percentile": 0.85088}, "CVE-2010-0435": {"epss_score": 0.00054, "epss_percentile": 0.17144}, "CVE-2010-0436": {"epss_score": 0.00026, "epss_percentile": 0.06431}, "CVE-2010-0437": {"epss_score": 0.03242, "epss_percentile": 0.86734}, "CVE-2010-0438": {"epss_score": 0.00856, "epss_percentile": 0.74476}, "CVE-2010-0439": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2010-0440": {"epss_score": 0.39315, "epss_percentile": 0.97154}, "CVE-2010-0441": {"epss_score": 0.03526, "epss_percentile": 0.87295}, "CVE-2010-0442": {"epss_score": 0.16189, "epss_percentile": 0.9459}, "CVE-2010-0443": {"epss_score": 0.00035, "epss_percentile": 0.09998}, "CVE-2010-0444": {"epss_score": 0.0489, "epss_percentile": 0.8926}, "CVE-2010-0445": {"epss_score": 0.01885, "epss_percentile": 0.82707}, "CVE-2010-0446": {"epss_score": 0.00452, "epss_percentile": 0.63171}, "CVE-2010-0447": {"epss_score": 0.06203, "epss_percentile": 0.90565}, "CVE-2010-0448": {"epss_score": 0.00836, "epss_percentile": 0.74142}, "CVE-2010-0449": {"epss_score": 0.00645, "epss_percentile": 0.7012}, "CVE-2010-0450": {"epss_score": 0.00158, "epss_percentile": 0.37217}, "CVE-2010-0451": {"epss_score": 0.0111, "epss_percentile": 0.77656}, "CVE-2010-0452": {"epss_score": 0.00667, "epss_percentile": 0.70718}, "CVE-2010-0453": {"epss_score": 0.00218, "epss_percentile": 0.44365}, "CVE-2010-0454": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2010-0455": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2010-0456": {"epss_score": 0.00362, "epss_percentile": 0.57768}, "CVE-2010-0457": {"epss_score": 0.00319, "epss_percentile": 0.5448}, "CVE-2010-0458": {"epss_score": 0.00431, "epss_percentile": 0.62095}, "CVE-2010-0459": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-0460": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2010-0461": {"epss_score": 0.00013, "epss_percentile": 0.01572}, "CVE-2010-0462": {"epss_score": 0.13602, "epss_percentile": 0.94008}, "CVE-2010-0463": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2010-0464": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2010-0465": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-0467": {"epss_score": 0.02939, "epss_percentile": 0.8603}, "CVE-2010-0468": {"epss_score": 0.00333, "epss_percentile": 0.55644}, "CVE-2010-0469": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2010-0470": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2010-0471": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2010-0472": {"epss_score": 0.01106, "epss_percentile": 0.77615}, "CVE-2010-0475": {"epss_score": 0.00198, "epss_percentile": 0.42088}, "CVE-2010-0476": {"epss_score": 0.48727, "epss_percentile": 0.97651}, "CVE-2010-0477": {"epss_score": 0.86378, "epss_percentile": 0.99379}, "CVE-2010-0478": {"epss_score": 0.81673, "epss_percentile": 0.9915}, "CVE-2010-0479": {"epss_score": 0.43397, "epss_percentile": 0.97385}, "CVE-2010-0480": {"epss_score": 0.83493, "epss_percentile": 0.99251}, "CVE-2010-0481": {"epss_score": 0.0067, "epss_percentile": 0.70782}, "CVE-2010-0482": {"epss_score": 0.00983, "epss_percentile": 0.76308}, "CVE-2010-0483": {"epss_score": 0.81964, "epss_percentile": 0.99167}, "CVE-2010-0484": {"epss_score": 0.02102, "epss_percentile": 0.83605}, "CVE-2010-0485": {"epss_score": 0.01059, "epss_percentile": 0.77158}, "CVE-2010-0486": {"epss_score": 0.34784, "epss_percentile": 0.96873}, "CVE-2010-0487": {"epss_score": 0.33752, "epss_percentile": 0.96801}, "CVE-2010-0488": {"epss_score": 0.15547, "epss_percentile": 0.94454}, "CVE-2010-0489": {"epss_score": 0.35424, "epss_percentile": 0.96907}, "CVE-2010-0490": {"epss_score": 0.62099, "epss_percentile": 0.98278}, "CVE-2010-0491": {"epss_score": 0.62433, "epss_percentile": 0.98293}, "CVE-2010-0492": {"epss_score": 0.62849, "epss_percentile": 0.9831}, "CVE-2010-0494": {"epss_score": 0.50183, "epss_percentile": 0.97723}, "CVE-2010-0496": {"epss_score": 0.04586, "epss_percentile": 0.88886}, "CVE-2010-0497": {"epss_score": 0.01097, "epss_percentile": 0.7753}, "CVE-2010-0498": {"epss_score": 0.00042, "epss_percentile": 0.12765}, "CVE-2010-0500": {"epss_score": 0.00428, "epss_percentile": 0.61926}, "CVE-2010-0501": {"epss_score": 0.00083, "epss_percentile": 0.24708}, "CVE-2010-0502": {"epss_score": 0.00229, "epss_percentile": 0.45651}, "CVE-2010-0503": {"epss_score": 0.01244, "epss_percentile": 0.78836}, "CVE-2010-0504": {"epss_score": 0.01241, "epss_percentile": 0.78817}, "CVE-2010-0505": {"epss_score": 0.02436, "epss_percentile": 0.84739}, "CVE-2010-0506": {"epss_score": 0.01241, "epss_percentile": 0.78815}, "CVE-2010-0507": {"epss_score": 0.01241, "epss_percentile": 0.78815}, "CVE-2010-0508": {"epss_score": 0.00352, "epss_percentile": 0.57083}, "CVE-2010-0509": {"epss_score": 0.00039, "epss_percentile": 0.11462}, "CVE-2010-0510": {"epss_score": 0.00421, "epss_percentile": 0.61502}, "CVE-2010-0511": {"epss_score": 0.00229, "epss_percentile": 0.45572}, "CVE-2010-0512": {"epss_score": 0.00414, "epss_percentile": 0.61017}, "CVE-2010-0513": {"epss_score": 0.01901, "epss_percentile": 0.82779}, "CVE-2010-0514": {"epss_score": 0.02029, "epss_percentile": 0.83328}, "CVE-2010-0515": {"epss_score": 0.02057, "epss_percentile": 0.83427}, "CVE-2010-0516": {"epss_score": 0.03478, "epss_percentile": 0.87214}, "CVE-2010-0517": {"epss_score": 0.03478, "epss_percentile": 0.87214}, "CVE-2010-0518": {"epss_score": 0.02057, "epss_percentile": 0.83427}, "CVE-2010-0519": {"epss_score": 0.05778, "epss_percentile": 0.90199}, "CVE-2010-0520": {"epss_score": 0.09154, "epss_percentile": 0.92425}, "CVE-2010-0521": {"epss_score": 0.00267, "epss_percentile": 0.49957}, "CVE-2010-0522": {"epss_score": 0.00421, "epss_percentile": 0.61502}, "CVE-2010-0523": {"epss_score": 0.00209, "epss_percentile": 0.43336}, "CVE-2010-0524": {"epss_score": 0.00379, "epss_percentile": 0.58858}, "CVE-2010-0525": {"epss_score": 0.00127, "epss_percentile": 0.32864}, "CVE-2010-0526": {"epss_score": 0.05048, "epss_percentile": 0.89437}, "CVE-2010-0527": {"epss_score": 0.01964, "epss_percentile": 0.83076}, "CVE-2010-0528": {"epss_score": 0.02372, "epss_percentile": 0.84531}, "CVE-2010-0529": {"epss_score": 0.03139, "epss_percentile": 0.86483}, "CVE-2010-0530": {"epss_score": 0.00107, "epss_percentile": 0.29684}, "CVE-2010-0531": {"epss_score": 0.00478, "epss_percentile": 0.64387}, "CVE-2010-0532": {"epss_score": 0.00031, "epss_percentile": 0.08512}, "CVE-2010-0533": {"epss_score": 0.00241, "epss_percentile": 0.47237}, "CVE-2010-0534": {"epss_score": 0.00137, "epss_percentile": 0.34267}, "CVE-2010-0535": {"epss_score": 0.00166, "epss_percentile": 0.38235}, "CVE-2010-0536": {"epss_score": 0.02107, "epss_percentile": 0.83633}, "CVE-2010-0537": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2010-0538": {"epss_score": 0.03754, "epss_percentile": 0.87679}, "CVE-2010-0539": {"epss_score": 0.02799, "epss_percentile": 0.85692}, "CVE-2010-0540": {"epss_score": 0.00401, "epss_percentile": 0.60236}, "CVE-2010-0541": {"epss_score": 0.01718, "epss_percentile": 0.81921}, "CVE-2010-0542": {"epss_score": 0.04413, "epss_percentile": 0.88663}, "CVE-2010-0543": {"epss_score": 0.02117, "epss_percentile": 0.83664}, "CVE-2010-0544": {"epss_score": 0.00745, "epss_percentile": 0.72527}, "CVE-2010-0545": {"epss_score": 0.00069, "epss_percentile": 0.21501}, "CVE-2010-0546": {"epss_score": 0.00031, "epss_percentile": 0.08396}, "CVE-2010-0547": {"epss_score": 0.01967, "epss_percentile": 0.83084}, "CVE-2010-0548": {"epss_score": 0.00207, "epss_percentile": 0.43199}, "CVE-2010-0549": {"epss_score": 0.00346, "epss_percentile": 0.56638}, "CVE-2010-0550": {"epss_score": 0.00348, "epss_percentile": 0.56835}, "CVE-2010-0551": {"epss_score": 0.00389, "epss_percentile": 0.59456}, "CVE-2010-0552": {"epss_score": 0.05599, "epss_percentile": 0.90036}, "CVE-2010-0553": {"epss_score": 0.14162, "epss_percentile": 0.94147}, "CVE-2010-0554": {"epss_score": 0.00167, "epss_percentile": 0.38353}, "CVE-2010-0555": {"epss_score": 0.31385, "epss_percentile": 0.96616}, "CVE-2010-0556": {"epss_score": 0.00314, "epss_percentile": 0.54157}, "CVE-2010-0557": {"epss_score": 0.79404, "epss_percentile": 0.99036}, "CVE-2010-0558": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2010-0559": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2010-0560": {"epss_score": 0.00096, "epss_percentile": 0.27281}, "CVE-2010-0561": {"epss_score": 0.00051, "epss_percentile": 0.16305}, "CVE-2010-0562": {"epss_score": 0.01751, "epss_percentile": 0.82098}, "CVE-2010-0563": {"epss_score": 0.00449, "epss_percentile": 0.63032}, "CVE-2010-0564": {"epss_score": 0.01389, "epss_percentile": 0.79924}, "CVE-2010-0565": {"epss_score": 0.01492, "epss_percentile": 0.80637}, "CVE-2010-0566": {"epss_score": 0.01235, "epss_percentile": 0.78764}, "CVE-2010-0567": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2010-0568": {"epss_score": 0.00432, "epss_percentile": 0.62103}, "CVE-2010-0569": {"epss_score": 0.01385, "epss_percentile": 0.79904}, "CVE-2010-0570": {"epss_score": 0.02929, "epss_percentile": 0.86012}, "CVE-2010-0571": {"epss_score": 0.01682, "epss_percentile": 0.81735}, "CVE-2010-0572": {"epss_score": 0.01377, "epss_percentile": 0.79843}, "CVE-2010-0573": {"epss_score": 0.01561, "epss_percentile": 0.81043}, "CVE-2010-0574": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2010-0575": {"epss_score": 0.0016, "epss_percentile": 0.37452}, "CVE-2010-0576": {"epss_score": 0.01653, "epss_percentile": 0.81583}, "CVE-2010-0577": {"epss_score": 0.01559, "epss_percentile": 0.81036}, "CVE-2010-0578": {"epss_score": 0.01653, "epss_percentile": 0.81583}, "CVE-2010-0579": {"epss_score": 0.00726, "epss_percentile": 0.72077}, "CVE-2010-0580": {"epss_score": 0.03857, "epss_percentile": 0.87859}, "CVE-2010-0581": {"epss_score": 0.04097, "epss_percentile": 0.88251}, "CVE-2010-0582": {"epss_score": 0.00801, "epss_percentile": 0.73578}, "CVE-2010-0583": {"epss_score": 0.01653, "epss_percentile": 0.81583}, "CVE-2010-0584": {"epss_score": 0.00798, "epss_percentile": 0.73509}, "CVE-2010-0585": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2010-0586": {"epss_score": 0.00798, "epss_percentile": 0.73509}, "CVE-2010-0587": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2010-0588": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2010-0589": {"epss_score": 0.01572, "epss_percentile": 0.81097}, "CVE-2010-0590": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2010-0591": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2010-0592": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2010-0593": {"epss_score": 0.0117, "epss_percentile": 0.78213}, "CVE-2010-0594": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-0595": {"epss_score": 0.0229, "epss_percentile": 0.84278}, "CVE-2010-0596": {"epss_score": 0.00837, "epss_percentile": 0.74163}, "CVE-2010-0597": {"epss_score": 0.0122, "epss_percentile": 0.78619}, "CVE-2010-0598": {"epss_score": 0.0075, "epss_percentile": 0.72617}, "CVE-2010-0599": {"epss_score": 0.0075, "epss_percentile": 0.72617}, "CVE-2010-0600": {"epss_score": 0.014, "epss_percentile": 0.8}, "CVE-2010-0601": {"epss_score": 0.01238, "epss_percentile": 0.78785}, "CVE-2010-0602": {"epss_score": 0.01238, "epss_percentile": 0.78785}, "CVE-2010-0603": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2010-0604": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-0605": {"epss_score": 0.00672, "epss_percentile": 0.70818}, "CVE-2010-0606": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2010-0607": {"epss_score": 0.01456, "epss_percentile": 0.80392}, "CVE-2010-0608": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2010-0609": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0610": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-0611": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-0612": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2010-0613": {"epss_score": 0.00084, "epss_percentile": 0.24967}, "CVE-2010-0614": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-0615": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2010-0616": {"epss_score": 0.00491, "epss_percentile": 0.64954}, "CVE-2010-0617": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-0618": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2010-0619": {"epss_score": 0.30829, "epss_percentile": 0.9657}, "CVE-2010-0620": {"epss_score": 0.03857, "epss_percentile": 0.8786}, "CVE-2010-0622": {"epss_score": 0.00144, "epss_percentile": 0.3528}, "CVE-2010-0623": {"epss_score": 0.00047, "epss_percentile": 0.14571}, "CVE-2010-0624": {"epss_score": 0.01989, "epss_percentile": 0.83172}, "CVE-2010-0625": {"epss_score": 0.27635, "epss_percentile": 0.96267}, "CVE-2010-0628": {"epss_score": 0.00925, "epss_percentile": 0.7553}, "CVE-2010-0629": {"epss_score": 0.02284, "epss_percentile": 0.84261}, "CVE-2010-0630": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-0631": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2010-0632": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-0633": {"epss_score": 0.00066, "epss_percentile": 0.20849}, "CVE-2010-0634": {"epss_score": 0.00323, "epss_percentile": 0.54904}, "CVE-2010-0635": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2010-0636": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-0637": {"epss_score": 0.00134, "epss_percentile": 0.33751}, "CVE-2010-0638": {"epss_score": 0.00122, "epss_percentile": 0.3216}, "CVE-2010-0639": {"epss_score": 0.49372, "epss_percentile": 0.97681}, "CVE-2010-0640": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2010-0641": {"epss_score": 0.00734, "epss_percentile": 0.72249}, "CVE-2010-0642": {"epss_score": 0.01497, "epss_percentile": 0.80688}, "CVE-2010-0643": {"epss_score": 0.00345, "epss_percentile": 0.56581}, "CVE-2010-0644": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2010-0645": {"epss_score": 0.08547, "epss_percentile": 0.92118}, "CVE-2010-0646": {"epss_score": 0.10913, "epss_percentile": 0.93154}, "CVE-2010-0647": {"epss_score": 0.10166, "epss_percentile": 0.92872}, "CVE-2010-0648": {"epss_score": 0.00441, "epss_percentile": 0.62654}, "CVE-2010-0649": {"epss_score": 0.00482, "epss_percentile": 0.64533}, "CVE-2010-0650": {"epss_score": 0.01571, "epss_percentile": 0.81094}, "CVE-2010-0651": {"epss_score": 0.02258, "epss_percentile": 0.84179}, "CVE-2010-0652": {"epss_score": 0.09306, "epss_percentile": 0.92493}, "CVE-2010-0653": {"epss_score": 0.00455, "epss_percentile": 0.633}, "CVE-2010-0654": {"epss_score": 0.00704, "epss_percentile": 0.71574}, "CVE-2010-0655": {"epss_score": 0.13859, "epss_percentile": 0.94077}, "CVE-2010-0656": {"epss_score": 0.00606, "epss_percentile": 0.69023}, "CVE-2010-0657": {"epss_score": 0.01298, "epss_percentile": 0.79275}, "CVE-2010-0658": {"epss_score": 0.03897, "epss_percentile": 0.87917}, "CVE-2010-0659": {"epss_score": 0.06977, "epss_percentile": 0.91157}, "CVE-2010-0660": {"epss_score": 0.00177, "epss_percentile": 0.39575}, "CVE-2010-0661": {"epss_score": 0.01619, "epss_percentile": 0.81378}, "CVE-2010-0662": {"epss_score": 0.00487, "epss_percentile": 0.64805}, "CVE-2010-0663": {"epss_score": 0.00384, "epss_percentile": 0.59166}, "CVE-2010-0664": {"epss_score": 0.01317, "epss_percentile": 0.79419}, "CVE-2010-0665": {"epss_score": 0.01612, "epss_percentile": 0.81338}, "CVE-2010-0666": {"epss_score": 0.00496, "epss_percentile": 0.65177}, "CVE-2010-0667": {"epss_score": 0.00765, "epss_percentile": 0.72917}, "CVE-2010-0668": {"epss_score": 0.01524, "epss_percentile": 0.80846}, "CVE-2010-0669": {"epss_score": 0.01049, "epss_percentile": 0.77062}, "CVE-2010-0670": {"epss_score": 0.00257, "epss_percentile": 0.48947}, "CVE-2010-0671": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-0672": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-0673": {"epss_score": 0.00694, "epss_percentile": 0.71344}, "CVE-2010-0674": {"epss_score": 0.02152, "epss_percentile": 0.83793}, "CVE-2010-0675": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2010-0676": {"epss_score": 0.00168, "epss_percentile": 0.38429}, "CVE-2010-0677": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2010-0678": {"epss_score": 0.01245, "epss_percentile": 0.78846}, "CVE-2010-0679": {"epss_score": 0.73238, "epss_percentile": 0.98742}, "CVE-2010-0680": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2010-0681": {"epss_score": 0.01612, "epss_percentile": 0.81338}, "CVE-2010-0682": {"epss_score": 0.25421, "epss_percentile": 0.96026}, "CVE-2010-0683": {"epss_score": 0.01298, "epss_percentile": 0.79277}, "CVE-2010-0684": {"epss_score": 0.00388, "epss_percentile": 0.59374}, "CVE-2010-0685": {"epss_score": 0.0008, "epss_percentile": 0.24186}, "CVE-2010-0686": {"epss_score": 0.0106, "epss_percentile": 0.77162}, "CVE-2010-0688": {"epss_score": 0.69652, "epss_percentile": 0.98596}, "CVE-2010-0689": {"epss_score": 0.06297, "epss_percentile": 0.90653}, "CVE-2010-0690": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2010-0691": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-0692": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-0693": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2010-0694": {"epss_score": 0.00417, "epss_percentile": 0.6125}, "CVE-2010-0695": {"epss_score": 0.0022, "epss_percentile": 0.44558}, "CVE-2010-0696": {"epss_score": 0.16031, "epss_percentile": 0.94562}, "CVE-2010-0697": {"epss_score": 0.00198, "epss_percentile": 0.4203}, "CVE-2010-0698": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-0699": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-0700": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2010-0701": {"epss_score": 0.01606, "epss_percentile": 0.81302}, "CVE-2010-0702": {"epss_score": 0.00928, "epss_percentile": 0.75575}, "CVE-2010-0703": {"epss_score": 0.05071, "epss_percentile": 0.89465}, "CVE-2010-0704": {"epss_score": 0.00223, "epss_percentile": 0.44868}, "CVE-2010-0705": {"epss_score": 0.00207, "epss_percentile": 0.43141}, "CVE-2010-0706": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2010-0707": {"epss_score": 0.00084, "epss_percentile": 0.24981}, "CVE-2010-0708": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2010-0709": {"epss_score": 0.03164, "epss_percentile": 0.86536}, "CVE-2010-0710": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-0711": {"epss_score": 0.00282, "epss_percentile": 0.51278}, "CVE-2010-0712": {"epss_score": 0.0129, "epss_percentile": 0.7922}, "CVE-2010-0713": {"epss_score": 0.02987, "epss_percentile": 0.86136}, "CVE-2010-0714": {"epss_score": 0.02768, "epss_percentile": 0.85615}, "CVE-2010-0715": {"epss_score": 0.00609, "epss_percentile": 0.69096}, "CVE-2010-0716": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2010-0717": {"epss_score": 0.00594, "epss_percentile": 0.68665}, "CVE-2010-0718": {"epss_score": 0.28822, "epss_percentile": 0.96391}, "CVE-2010-0719": {"epss_score": 0.00378, "epss_percentile": 0.58836}, "CVE-2010-0720": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-0721": {"epss_score": 0.00319, "epss_percentile": 0.5448}, "CVE-2010-0722": {"epss_score": 0.00145, "epss_percentile": 0.35456}, "CVE-2010-0723": {"epss_score": 0.02398, "epss_percentile": 0.84622}, "CVE-2010-0724": {"epss_score": 0.00844, "epss_percentile": 0.74271}, "CVE-2010-0725": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2010-0726": {"epss_score": 0.00521, "epss_percentile": 0.66218}, "CVE-2010-0727": {"epss_score": 0.00081, "epss_percentile": 0.24342}, "CVE-2010-0728": {"epss_score": 0.01618, "epss_percentile": 0.81368}, "CVE-2010-0729": {"epss_score": 0.00048, "epss_percentile": 0.15284}, "CVE-2010-0730": {"epss_score": 0.03275, "epss_percentile": 0.86801}, "CVE-2010-0731": {"epss_score": 0.01631, "epss_percentile": 0.81445}, "CVE-2010-0732": {"epss_score": 0.00041, "epss_percentile": 0.1233}, "CVE-2010-0733": {"epss_score": 0.07672, "epss_percentile": 0.91616}, "CVE-2010-0734": {"epss_score": 0.04759, "epss_percentile": 0.89117}, "CVE-2010-0736": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2010-0737": {"epss_score": 0.00139, "epss_percentile": 0.34555}, "CVE-2010-0738": {"epss_score": 0.91288, "epss_percentile": 0.99632}, "CVE-2010-0739": {"epss_score": 0.077, "epss_percentile": 0.91634}, "CVE-2010-0740": {"epss_score": 0.15469, "epss_percentile": 0.94435}, "CVE-2010-0741": {"epss_score": 0.0211, "epss_percentile": 0.83645}, "CVE-2010-0742": {"epss_score": 0.23018, "epss_percentile": 0.95719}, "CVE-2010-0743": {"epss_score": 0.06442, "epss_percentile": 0.90761}, "CVE-2010-0744": {"epss_score": 0.00386, "epss_percentile": 0.5926}, "CVE-2010-0745": {"epss_score": 0.0188, "epss_percentile": 0.82689}, "CVE-2010-0746": {"epss_score": 0.00021, "epss_percentile": 0.04911}, "CVE-2010-0747": {"epss_score": 0.00039, "epss_percentile": 0.11528}, "CVE-2010-0748": {"epss_score": 0.00856, "epss_percentile": 0.74472}, "CVE-2010-0749": {"epss_score": 0.00731, "epss_percentile": 0.72182}, "CVE-2010-0750": {"epss_score": 0.00082, "epss_percentile": 0.24589}, "CVE-2010-0751": {"epss_score": 0.03797, "epss_percentile": 0.87737}, "CVE-2010-0752": {"epss_score": 0.00595, "epss_percentile": 0.68683}, "CVE-2010-0753": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-0754": {"epss_score": 0.07551, "epss_percentile": 0.91534}, "CVE-2010-0755": {"epss_score": 0.01643, "epss_percentile": 0.81515}, "CVE-2010-0756": {"epss_score": 0.00694, "epss_percentile": 0.7136}, "CVE-2010-0757": {"epss_score": 0.04009, "epss_percentile": 0.88107}, "CVE-2010-0758": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-0759": {"epss_score": 0.06605, "epss_percentile": 0.90881}, "CVE-2010-0760": {"epss_score": 0.01046, "epss_percentile": 0.77028}, "CVE-2010-0761": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-0762": {"epss_score": 0.01081, "epss_percentile": 0.77376}, "CVE-2010-0763": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-0764": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2010-0765": {"epss_score": 0.04514, "epss_percentile": 0.88786}, "CVE-2010-0766": {"epss_score": 0.0472, "epss_percentile": 0.89047}, "CVE-2010-0768": {"epss_score": 0.0023, "epss_percentile": 0.45669}, "CVE-2010-0769": {"epss_score": 0.00054, "epss_percentile": 0.17362}, "CVE-2010-0770": {"epss_score": 0.00514, "epss_percentile": 0.65963}, "CVE-2010-0772": {"epss_score": 0.00461, "epss_percentile": 0.63547}, "CVE-2010-0774": {"epss_score": 0.00142, "epss_percentile": 0.35029}, "CVE-2010-0775": {"epss_score": 0.00527, "epss_percentile": 0.66445}, "CVE-2010-0776": {"epss_score": 0.00527, "epss_percentile": 0.66445}, "CVE-2010-0777": {"epss_score": 0.0055, "epss_percentile": 0.67325}, "CVE-2010-0778": {"epss_score": 0.00202, "epss_percentile": 0.42481}, "CVE-2010-0779": {"epss_score": 0.00202, "epss_percentile": 0.42481}, "CVE-2010-0780": {"epss_score": 0.00556, "epss_percentile": 0.67518}, "CVE-2010-0781": {"epss_score": 0.00514, "epss_percentile": 0.65963}, "CVE-2010-0782": {"epss_score": 0.00095, "epss_percentile": 0.27211}, "CVE-2010-0783": {"epss_score": 0.00475, "epss_percentile": 0.6417}, "CVE-2010-0784": {"epss_score": 0.0049, "epss_percentile": 0.64936}, "CVE-2010-0785": {"epss_score": 0.00265, "epss_percentile": 0.49779}, "CVE-2010-0786": {"epss_score": 0.00594, "epss_percentile": 0.68675}, "CVE-2010-0787": {"epss_score": 0.00419, "epss_percentile": 0.61382}, "CVE-2010-0788": {"epss_score": 0.00208, "epss_percentile": 0.43219}, "CVE-2010-0789": {"epss_score": 0.00061, "epss_percentile": 0.19339}, "CVE-2010-0790": {"epss_score": 0.00071, "epss_percentile": 0.2212}, "CVE-2010-0791": {"epss_score": 0.00064, "epss_percentile": 0.20354}, "CVE-2010-0792": {"epss_score": 0.0003, "epss_percentile": 0.08248}, "CVE-2010-0793": {"epss_score": 0.02166, "epss_percentile": 0.83848}, "CVE-2010-0795": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2010-0796": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-0797": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-0798": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-0799": {"epss_score": 0.03471, "epss_percentile": 0.87199}, "CVE-2010-0800": {"epss_score": 0.002, "epss_percentile": 0.42201}, "CVE-2010-0801": {"epss_score": 0.02195, "epss_percentile": 0.83952}, "CVE-2010-0802": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2010-0803": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-0804": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2010-0805": {"epss_score": 0.87692, "epss_percentile": 0.99439}, "CVE-2010-0806": {"epss_score": 0.90864, "epss_percentile": 0.99605}, "CVE-2010-0807": {"epss_score": 0.62099, "epss_percentile": 0.98278}, "CVE-2010-0808": {"epss_score": 0.40219, "epss_percentile": 0.97206}, "CVE-2010-0810": {"epss_score": 0.0128, "epss_percentile": 0.79138}, "CVE-2010-0811": {"epss_score": 0.56431, "epss_percentile": 0.98022}, "CVE-2010-0812": {"epss_score": 0.51292, "epss_percentile": 0.97774}, "CVE-2010-0814": {"epss_score": 0.61885, "epss_percentile": 0.98266}, "CVE-2010-0815": {"epss_score": 0.61415, "epss_percentile": 0.98247}, "CVE-2010-0816": {"epss_score": 0.35441, "epss_percentile": 0.9691}, "CVE-2010-0817": {"epss_score": 0.55316, "epss_percentile": 0.97971}, "CVE-2010-0818": {"epss_score": 0.29042, "epss_percentile": 0.96413}, "CVE-2010-0819": {"epss_score": 0.0139, "epss_percentile": 0.79932}, "CVE-2010-0820": {"epss_score": 0.25835, "epss_percentile": 0.96076}, "CVE-2010-0821": {"epss_score": 0.57582, "epss_percentile": 0.98071}, "CVE-2010-0822": {"epss_score": 0.80447, "epss_percentile": 0.99089}, "CVE-2010-0823": {"epss_score": 0.57317, "epss_percentile": 0.98058}, "CVE-2010-0824": {"epss_score": 0.61401, "epss_percentile": 0.98247}, "CVE-2010-0825": {"epss_score": 0.00118, "epss_percentile": 0.31455}, "CVE-2010-0826": {"epss_score": 0.00093, "epss_percentile": 0.2666}, "CVE-2010-0827": {"epss_score": 0.04513, "epss_percentile": 0.88783}, "CVE-2010-0828": {"epss_score": 0.00564, "epss_percentile": 0.67743}, "CVE-2010-0829": {"epss_score": 0.0504, "epss_percentile": 0.89425}, "CVE-2010-0830": {"epss_score": 0.06829, "epss_percentile": 0.91054}, "CVE-2010-0831": {"epss_score": 0.01855, "epss_percentile": 0.82567}, "CVE-2010-0832": {"epss_score": 0.00395, "epss_percentile": 0.59806}, "CVE-2010-0833": {"epss_score": 0.00914, "epss_percentile": 0.75393}, "CVE-2010-0834": {"epss_score": 0.00374, "epss_percentile": 0.58551}, "CVE-2010-0835": {"epss_score": 0.00442, "epss_percentile": 0.62729}, "CVE-2010-0836": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2010-0837": {"epss_score": 0.03647, "epss_percentile": 0.87503}, "CVE-2010-0838": {"epss_score": 0.13691, "epss_percentile": 0.94035}, "CVE-2010-0839": {"epss_score": 0.03643, "epss_percentile": 0.87495}, "CVE-2010-0840": {"epss_score": 0.92192, "epss_percentile": 0.99698}, "CVE-2010-0841": {"epss_score": 0.10009, "epss_percentile": 0.92815}, "CVE-2010-0842": {"epss_score": 0.84965, "epss_percentile": 0.99312}, "CVE-2010-0843": {"epss_score": 0.10009, "epss_percentile": 0.92815}, "CVE-2010-0844": {"epss_score": 0.06412, "epss_percentile": 0.90742}, "CVE-2010-0845": {"epss_score": 0.04133, "epss_percentile": 0.88303}, "CVE-2010-0846": {"epss_score": 0.09854, "epss_percentile": 0.92737}, "CVE-2010-0847": {"epss_score": 0.05186, "epss_percentile": 0.89589}, "CVE-2010-0848": {"epss_score": 0.03647, "epss_percentile": 0.87503}, "CVE-2010-0849": {"epss_score": 0.0567, "epss_percentile": 0.90103}, "CVE-2010-0850": {"epss_score": 0.01681, "epss_percentile": 0.81727}, "CVE-2010-0851": {"epss_score": 0.00311, "epss_percentile": 0.53926}, "CVE-2010-0852": {"epss_score": 0.00302, "epss_percentile": 0.53131}, "CVE-2010-0853": {"epss_score": 0.01376, "epss_percentile": 0.79838}, "CVE-2010-0854": {"epss_score": 0.00277, "epss_percentile": 0.50813}, "CVE-2010-0855": {"epss_score": 0.00725, "epss_percentile": 0.72065}, "CVE-2010-0856": {"epss_score": 0.01137, "epss_percentile": 0.77925}, "CVE-2010-0857": {"epss_score": 0.00381, "epss_percentile": 0.58995}, "CVE-2010-0858": {"epss_score": 0.00381, "epss_percentile": 0.58995}, "CVE-2010-0859": {"epss_score": 0.01852, "epss_percentile": 0.82543}, "CVE-2010-0860": {"epss_score": 0.00539, "epss_percentile": 0.66976}, "CVE-2010-0861": {"epss_score": 0.00909, "epss_percentile": 0.75298}, "CVE-2010-0862": {"epss_score": 0.00808, "epss_percentile": 0.73691}, "CVE-2010-0863": {"epss_score": 0.00725, "epss_percentile": 0.72065}, "CVE-2010-0864": {"epss_score": 0.00725, "epss_percentile": 0.72065}, "CVE-2010-0865": {"epss_score": 0.00909, "epss_percentile": 0.75298}, "CVE-2010-0866": {"epss_score": 0.59232, "epss_percentile": 0.98156}, "CVE-2010-0867": {"epss_score": 0.00181, "epss_percentile": 0.40021}, "CVE-2010-0868": {"epss_score": 0.00882, "epss_percentile": 0.74898}, "CVE-2010-0869": {"epss_score": 0.00909, "epss_percentile": 0.75298}, "CVE-2010-0870": {"epss_score": 0.47666, "epss_percentile": 0.97596}, "CVE-2010-0871": {"epss_score": 0.00882, "epss_percentile": 0.74898}, "CVE-2010-0872": {"epss_score": 0.03666, "epss_percentile": 0.87534}, "CVE-2010-0873": {"epss_score": 0.01076, "epss_percentile": 0.77325}, "CVE-2010-0874": {"epss_score": 0.00643, "epss_percentile": 0.7006}, "CVE-2010-0875": {"epss_score": 0.00643, "epss_percentile": 0.7006}, "CVE-2010-0876": {"epss_score": 0.00643, "epss_percentile": 0.7006}, "CVE-2010-0877": {"epss_score": 0.00643, "epss_percentile": 0.7006}, "CVE-2010-0878": {"epss_score": 0.00277, "epss_percentile": 0.50813}, "CVE-2010-0879": {"epss_score": 0.00311, "epss_percentile": 0.53926}, "CVE-2010-0880": {"epss_score": 0.00423, "epss_percentile": 0.61594}, "CVE-2010-0881": {"epss_score": 0.00808, "epss_percentile": 0.73691}, "CVE-2010-0882": {"epss_score": 0.00319, "epss_percentile": 0.54495}, "CVE-2010-0883": {"epss_score": 0.00254, "epss_percentile": 0.48501}, "CVE-2010-0884": {"epss_score": 0.00254, "epss_percentile": 0.48501}, "CVE-2010-0885": {"epss_score": 0.00249, "epss_percentile": 0.48016}, "CVE-2010-0886": {"epss_score": 0.80974, "epss_percentile": 0.99114}, "CVE-2010-0887": {"epss_score": 0.09992, "epss_percentile": 0.92808}, "CVE-2010-0888": {"epss_score": 0.02412, "epss_percentile": 0.84671}, "CVE-2010-0889": {"epss_score": 0.00257, "epss_percentile": 0.48924}, "CVE-2010-0890": {"epss_score": 0.00354, "epss_percentile": 0.57246}, "CVE-2010-0891": {"epss_score": 0.00857, "epss_percentile": 0.74489}, "CVE-2010-0892": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2010-0893": {"epss_score": 0.00857, "epss_percentile": 0.74489}, "CVE-2010-0894": {"epss_score": 0.00758, "epss_percentile": 0.72765}, "CVE-2010-0895": {"epss_score": 0.00203, "epss_percentile": 0.42541}, "CVE-2010-0896": {"epss_score": 0.00679, "epss_percentile": 0.71013}, "CVE-2010-0897": {"epss_score": 0.01137, "epss_percentile": 0.77925}, "CVE-2010-0898": {"epss_score": 0.01076, "epss_percentile": 0.77325}, "CVE-2010-0899": {"epss_score": 0.00424, "epss_percentile": 0.61665}, "CVE-2010-0900": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2010-0901": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2010-0902": {"epss_score": 0.00351, "epss_percentile": 0.5704}, "CVE-2010-0903": {"epss_score": 0.00717, "epss_percentile": 0.7189}, "CVE-2010-0904": {"epss_score": 0.88044, "epss_percentile": 0.99456}, "CVE-2010-0905": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2010-0906": {"epss_score": 0.00424, "epss_percentile": 0.61665}, "CVE-2010-0907": {"epss_score": 0.02083, "epss_percentile": 0.83539}, "CVE-2010-0908": {"epss_score": 0.00685, "epss_percentile": 0.71137}, "CVE-2010-0909": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2010-0910": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2010-0911": {"epss_score": 0.00529, "epss_percentile": 0.66587}, "CVE-2010-0912": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2010-0913": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2010-0914": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2010-0915": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2010-0916": {"epss_score": 0.00283, "epss_percentile": 0.51375}, "CVE-2010-0917": {"epss_score": 0.50143, "epss_percentile": 0.97722}, "CVE-2010-0918": {"epss_score": 0.00545, "epss_percentile": 0.67173}, "CVE-2010-0919": {"epss_score": 0.21283, "epss_percentile": 0.95494}, "CVE-2010-0920": {"epss_score": 0.00289, "epss_percentile": 0.52034}, "CVE-2010-0921": {"epss_score": 0.00134, "epss_percentile": 0.33836}, "CVE-2010-0922": {"epss_score": 0.0044, "epss_percentile": 0.6263}, "CVE-2010-0923": {"epss_score": 0.00039, "epss_percentile": 0.11725}, "CVE-2010-0924": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2010-0925": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2010-0926": {"epss_score": 0.29358, "epss_percentile": 0.96436}, "CVE-2010-0927": {"epss_score": 0.00224, "epss_percentile": 0.44978}, "CVE-2010-0928": {"epss_score": 0.00094, "epss_percentile": 0.26991}, "CVE-2010-0929": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2010-0930": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2010-0931": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2010-0932": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2010-0933": {"epss_score": 0.00128, "epss_percentile": 0.33006}, "CVE-2010-0934": {"epss_score": 0.00558, "epss_percentile": 0.67569}, "CVE-2010-0935": {"epss_score": 0.00449, "epss_percentile": 0.63047}, "CVE-2010-0936": {"epss_score": 0.00827, "epss_percentile": 0.73987}, "CVE-2010-0937": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2010-0938": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-0939": {"epss_score": 0.04514, "epss_percentile": 0.88786}, "CVE-2010-0940": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2010-0941": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2010-0942": {"epss_score": 0.1146, "epss_percentile": 0.93368}, "CVE-2010-0943": {"epss_score": 0.14795, "epss_percentile": 0.94285}, "CVE-2010-0944": {"epss_score": 0.01386, "epss_percentile": 0.79911}, "CVE-2010-0945": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-0946": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-0947": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2010-0948": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-0949": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-0950": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2010-0951": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-0952": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-0953": {"epss_score": 0.00939, "epss_percentile": 0.75717}, "CVE-2010-0954": {"epss_score": 0.00765, "epss_percentile": 0.72916}, "CVE-2010-0955": {"epss_score": 0.01307, "epss_percentile": 0.79338}, "CVE-2010-0956": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2010-0957": {"epss_score": 0.00162, "epss_percentile": 0.37688}, "CVE-2010-0958": {"epss_score": 0.01919, "epss_percentile": 0.82885}, "CVE-2010-0959": {"epss_score": 0.00259, "epss_percentile": 0.49034}, "CVE-2010-0960": {"epss_score": 0.00069, "epss_percentile": 0.21611}, "CVE-2010-0961": {"epss_score": 0.00069, "epss_percentile": 0.21611}, "CVE-2010-0962": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2010-0963": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-0964": {"epss_score": 0.01232, "epss_percentile": 0.78741}, "CVE-2010-0965": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2010-0966": {"epss_score": 0.0097, "epss_percentile": 0.76115}, "CVE-2010-0967": {"epss_score": 0.03636, "epss_percentile": 0.87482}, "CVE-2010-0968": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2010-0969": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2010-0970": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2010-0971": {"epss_score": 0.01071, "epss_percentile": 0.77265}, "CVE-2010-0972": {"epss_score": 0.04611, "epss_percentile": 0.88915}, "CVE-2010-0973": {"epss_score": 0.00145, "epss_percentile": 0.35456}, "CVE-2010-0974": {"epss_score": 0.00362, "epss_percentile": 0.57768}, "CVE-2010-0975": {"epss_score": 0.0094, "epss_percentile": 0.75742}, "CVE-2010-0976": {"epss_score": 0.04454, "epss_percentile": 0.8871}, "CVE-2010-0977": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2010-0978": {"epss_score": 0.05486, "epss_percentile": 0.89924}, "CVE-2010-0979": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2010-0980": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-0981": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-0982": {"epss_score": 0.11, "epss_percentile": 0.93187}, "CVE-2010-0983": {"epss_score": 0.02692, "epss_percentile": 0.85439}, "CVE-2010-0984": {"epss_score": 0.05486, "epss_percentile": 0.89924}, "CVE-2010-0985": {"epss_score": 0.21353, "epss_percentile": 0.95505}, "CVE-2010-0986": {"epss_score": 0.09734, "epss_percentile": 0.9268}, "CVE-2010-0987": {"epss_score": 0.11674, "epss_percentile": 0.93442}, "CVE-2010-0988": {"epss_score": 0.00927, "epss_percentile": 0.75557}, "CVE-2010-0989": {"epss_score": 0.00328, "epss_percentile": 0.55287}, "CVE-2010-0990": {"epss_score": 0.05755, "epss_percentile": 0.9018}, "CVE-2010-0991": {"epss_score": 0.01452, "epss_percentile": 0.80369}, "CVE-2010-0992": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2010-0993": {"epss_score": 0.01186, "epss_percentile": 0.78345}, "CVE-2010-0994": {"epss_score": 0.02662, "epss_percentile": 0.85371}, "CVE-2010-0995": {"epss_score": 0.07866, "epss_percentile": 0.91729}, "CVE-2010-0996": {"epss_score": 0.02777, "epss_percentile": 0.85643}, "CVE-2010-0997": {"epss_score": 0.00354, "epss_percentile": 0.57245}, "CVE-2010-0998": {"epss_score": 0.20066, "epss_percentile": 0.95284}, "CVE-2010-0999": {"epss_score": 0.00341, "epss_percentile": 0.5633}, "CVE-2010-10001": {"epss_score": 0.00201, "epss_percentile": 0.42384}, "CVE-2010-10002": {"epss_score": 0.00398, "epss_percentile": 0.60065}, "CVE-2010-10003": {"epss_score": 0.00229, "epss_percentile": 0.45561}, "CVE-2010-10004": {"epss_score": 0.00075, "epss_percentile": 0.2293}, "CVE-2010-10006": {"epss_score": 0.00156, "epss_percentile": 0.36976}, "CVE-2010-10007": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2010-10008": {"epss_score": 0.00088, "epss_percentile": 0.25769}, "CVE-2010-10009": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2010-10010": {"epss_score": 0.00066, "epss_percentile": 0.20679}, "CVE-2010-10011": {"epss_score": 0.00175, "epss_percentile": 0.39264}, "CVE-2010-10012": {"epss_score": 0.58041, "epss_percentile": 0.98097}, "CVE-2010-10013": {"epss_score": 0.60652, "epss_percentile": 0.98215}, "CVE-2010-10014": {"epss_score": 0.66263, "epss_percentile": 0.98457}, "CVE-2010-10015": {"epss_score": 0.27949, "epss_percentile": 0.96299}, "CVE-2010-10016": {"epss_score": 0.60649, "epss_percentile": 0.98214}, "CVE-2010-10017": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2010-1000": {"epss_score": 0.02539, "epss_percentile": 0.85044}, "CVE-2010-1003": {"epss_score": 0.05618, "epss_percentile": 0.90056}, "CVE-2010-1004": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2010-1005": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-1006": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-1007": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2010-1008": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-1009": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-1010": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-1011": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-1012": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-1013": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2010-1014": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-1015": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2010-1016": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2010-1017": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2010-1018": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-1019": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-1020": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-1021": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2010-1022": {"epss_score": 0.00383, "epss_percentile": 0.59107}, "CVE-2010-1023": {"epss_score": 0.00434, "epss_percentile": 0.62304}, "CVE-2010-1024": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-1025": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-1026": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2010-1027": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2010-1028": {"epss_score": 0.09896, "epss_percentile": 0.9276}, "CVE-2010-1029": {"epss_score": 0.3762, "epss_percentile": 0.9706}, "CVE-2010-1030": {"epss_score": 0.00035, "epss_percentile": 0.10125}, "CVE-2010-1031": {"epss_score": 0.00045, "epss_percentile": 0.13895}, "CVE-2010-1032": {"epss_score": 0.00063, "epss_percentile": 0.20096}, "CVE-2010-1033": {"epss_score": 0.22586, "epss_percentile": 0.95654}, "CVE-2010-1034": {"epss_score": 0.00308, "epss_percentile": 0.53597}, "CVE-2010-1035": {"epss_score": 0.00398, "epss_percentile": 0.60059}, "CVE-2010-1036": {"epss_score": 0.00534, "epss_percentile": 0.66779}, "CVE-2010-1037": {"epss_score": 0.00128, "epss_percentile": 0.33013}, "CVE-2010-1038": {"epss_score": 0.00319, "epss_percentile": 0.54547}, "CVE-2010-1039": {"epss_score": 0.2436, "epss_percentile": 0.9591}, "CVE-2010-1040": {"epss_score": 0.00241, "epss_percentile": 0.47297}, "CVE-2010-1041": {"epss_score": 0.017, "epss_percentile": 0.81825}, "CVE-2010-1042": {"epss_score": 0.41642, "epss_percentile": 0.97287}, "CVE-2010-1043": {"epss_score": 0.02264, "epss_percentile": 0.84195}, "CVE-2010-1044": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-1045": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-1046": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2010-1047": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2010-1048": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2010-1049": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-1050": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2010-1051": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2010-1052": {"epss_score": 0.00164, "epss_percentile": 0.37975}, "CVE-2010-1053": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2010-1054": {"epss_score": 0.01606, "epss_percentile": 0.81302}, "CVE-2010-1055": {"epss_score": 0.03612, "epss_percentile": 0.87426}, "CVE-2010-1056": {"epss_score": 0.04792, "epss_percentile": 0.8915}, "CVE-2010-1057": {"epss_score": 0.03566, "epss_percentile": 0.87365}, "CVE-2010-1058": {"epss_score": 0.0384, "epss_percentile": 0.87831}, "CVE-2010-1059": {"epss_score": 0.00145, "epss_percentile": 0.3536}, "CVE-2010-1060": {"epss_score": 0.01919, "epss_percentile": 0.82885}, "CVE-2010-1061": {"epss_score": 0.00132, "epss_percentile": 0.33603}, "CVE-2010-1062": {"epss_score": 0.01919, "epss_percentile": 0.82885}, "CVE-2010-1063": {"epss_score": 0.00132, "epss_percentile": 0.33603}, "CVE-2010-1064": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2010-1065": {"epss_score": 0.03844, "epss_percentile": 0.87839}, "CVE-2010-1066": {"epss_score": 0.02835, "epss_percentile": 0.85787}, "CVE-2010-1067": {"epss_score": 0.03844, "epss_percentile": 0.87839}, "CVE-2010-1068": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-1069": {"epss_score": 0.00409, "epss_percentile": 0.60764}, "CVE-2010-1070": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-1071": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-1072": {"epss_score": 0.00446, "epss_percentile": 0.62934}, "CVE-2010-1073": {"epss_score": 0.0014, "epss_percentile": 0.34792}, "CVE-2010-1074": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2010-1075": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2010-1076": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-1077": {"epss_score": 0.01355, "epss_percentile": 0.79707}, "CVE-2010-1078": {"epss_score": 0.00417, "epss_percentile": 0.6125}, "CVE-2010-1079": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-1080": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-1081": {"epss_score": 0.05904, "epss_percentile": 0.90312}, "CVE-2010-1082": {"epss_score": 0.00084, "epss_percentile": 0.24967}, "CVE-2010-1083": {"epss_score": 0.00073, "epss_percentile": 0.22596}, "CVE-2010-1084": {"epss_score": 0.01417, "epss_percentile": 0.80154}, "CVE-2010-1085": {"epss_score": 0.01508, "epss_percentile": 0.8076}, "CVE-2010-1086": {"epss_score": 0.01525, "epss_percentile": 0.80857}, "CVE-2010-1087": {"epss_score": 0.02716, "epss_percentile": 0.85508}, "CVE-2010-1088": {"epss_score": 0.01829, "epss_percentile": 0.82442}, "CVE-2010-1089": {"epss_score": 0.00326, "epss_percentile": 0.55082}, "CVE-2010-1090": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2010-1091": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2010-1092": {"epss_score": 0.002, "epss_percentile": 0.42201}, "CVE-2010-1093": {"epss_score": 0.00128, "epss_percentile": 0.32967}, "CVE-2010-1094": {"epss_score": 0.00467, "epss_percentile": 0.63865}, "CVE-2010-1095": {"epss_score": 0.00157, "epss_percentile": 0.37026}, "CVE-2010-1096": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2010-1097": {"epss_score": 0.00123, "epss_percentile": 0.32178}, "CVE-2010-1098": {"epss_score": 0.27244, "epss_percentile": 0.96224}, "CVE-2010-1099": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2010-1100": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2010-1101": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2010-1102": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2010-1103": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2010-1104": {"epss_score": 0.00443, "epss_percentile": 0.62772}, "CVE-2010-1105": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-1106": {"epss_score": 0.00727, "epss_percentile": 0.72086}, "CVE-2010-1107": {"epss_score": 0.00262, "epss_percentile": 0.49364}, "CVE-2010-1108": {"epss_score": 0.00207, "epss_percentile": 0.43129}, "CVE-2010-1109": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-1110": {"epss_score": 0.00173, "epss_percentile": 0.39062}, "CVE-2010-1111": {"epss_score": 0.00706, "epss_percentile": 0.71614}, "CVE-2010-1112": {"epss_score": 0.00226, "epss_percentile": 0.45305}, "CVE-2010-1113": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2010-1114": {"epss_score": 0.01022, "epss_percentile": 0.76755}, "CVE-2010-1115": {"epss_score": 0.0014, "epss_percentile": 0.34751}, "CVE-2010-1116": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2010-1117": {"epss_score": 0.39228, "epss_percentile": 0.97147}, "CVE-2010-1118": {"epss_score": 0.36594, "epss_percentile": 0.96989}, "CVE-2010-1119": {"epss_score": 0.24416, "epss_percentile": 0.95919}, "CVE-2010-1120": {"epss_score": 0.03026, "epss_percentile": 0.86242}, "CVE-2010-1121": {"epss_score": 0.05544, "epss_percentile": 0.89981}, "CVE-2010-1122": {"epss_score": 0.00855, "epss_percentile": 0.74461}, "CVE-2010-1123": {"epss_score": 0.00044, "epss_percentile": 0.13666}, "CVE-2010-1124": {"epss_score": 0.00372, "epss_percentile": 0.58424}, "CVE-2010-1125": {"epss_score": 0.02114, "epss_percentile": 0.83654}, "CVE-2010-1126": {"epss_score": 0.00328, "epss_percentile": 0.55259}, "CVE-2010-1127": {"epss_score": 0.26553, "epss_percentile": 0.96155}, "CVE-2010-1128": {"epss_score": 0.04795, "epss_percentile": 0.89154}, "CVE-2010-1129": {"epss_score": 0.01859, "epss_percentile": 0.82582}, "CVE-2010-1130": {"epss_score": 0.05567, "epss_percentile": 0.90003}, "CVE-2010-1131": {"epss_score": 0.01579, "epss_percentile": 0.81129}, "CVE-2010-1132": {"epss_score": 0.20316, "epss_percentile": 0.95325}, "CVE-2010-1133": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2010-1134": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2010-1135": {"epss_score": 0.00686, "epss_percentile": 0.71164}, "CVE-2010-1136": {"epss_score": 0.00477, "epss_percentile": 0.64343}, "CVE-2010-1137": {"epss_score": 0.00966, "epss_percentile": 0.7605}, "CVE-2010-1138": {"epss_score": 0.00769, "epss_percentile": 0.72981}, "CVE-2010-1139": {"epss_score": 0.00075, "epss_percentile": 0.22948}, "CVE-2010-1140": {"epss_score": 0.0009, "epss_percentile": 0.2613}, "CVE-2010-1141": {"epss_score": 0.0545, "epss_percentile": 0.89891}, "CVE-2010-1142": {"epss_score": 0.01109, "epss_percentile": 0.77643}, "CVE-2010-1143": {"epss_score": 0.0149, "epss_percentile": 0.80628}, "CVE-2010-1146": {"epss_score": 0.00171, "epss_percentile": 0.38896}, "CVE-2010-1147": {"epss_score": 0.21308, "epss_percentile": 0.95499}, "CVE-2010-1148": {"epss_score": 0.00074, "epss_percentile": 0.22691}, "CVE-2010-1149": {"epss_score": 0.00037, "epss_percentile": 0.10922}, "CVE-2010-1150": {"epss_score": 0.00413, "epss_percentile": 0.60956}, "CVE-2010-1151": {"epss_score": 0.00519, "epss_percentile": 0.66179}, "CVE-2010-1152": {"epss_score": 0.22721, "epss_percentile": 0.95674}, "CVE-2010-1153": {"epss_score": 0.00602, "epss_percentile": 0.68887}, "CVE-2010-1155": {"epss_score": 0.00788, "epss_percentile": 0.73333}, "CVE-2010-1156": {"epss_score": 0.03316, "epss_percentile": 0.86902}, "CVE-2010-1157": {"epss_score": 0.17005, "epss_percentile": 0.94759}, "CVE-2010-1158": {"epss_score": 0.00556, "epss_percentile": 0.6753}, "CVE-2010-1159": {"epss_score": 0.26396, "epss_percentile": 0.96143}, "CVE-2010-1160": {"epss_score": 0.00058, "epss_percentile": 0.18423}, "CVE-2010-1161": {"epss_score": 0.00103, "epss_percentile": 0.29034}, "CVE-2010-1162": {"epss_score": 0.00055, "epss_percentile": 0.17514}, "CVE-2010-1163": {"epss_score": 0.00045, "epss_percentile": 0.13758}, "CVE-2010-1164": {"epss_score": 0.00568, "epss_percentile": 0.67899}, "CVE-2010-1165": {"epss_score": 0.04846, "epss_percentile": 0.89209}, "CVE-2010-1166": {"epss_score": 0.03655, "epss_percentile": 0.87514}, "CVE-2010-1167": {"epss_score": 0.00773, "epss_percentile": 0.73051}, "CVE-2010-1168": {"epss_score": 0.04483, "epss_percentile": 0.88744}, "CVE-2010-1169": {"epss_score": 0.01301, "epss_percentile": 0.79294}, "CVE-2010-1170": {"epss_score": 0.00327, "epss_percentile": 0.55097}, "CVE-2010-1171": {"epss_score": 0.00958, "epss_percentile": 0.75942}, "CVE-2010-1172": {"epss_score": 0.00066, "epss_percentile": 0.20802}, "CVE-2010-1173": {"epss_score": 0.11338, "epss_percentile": 0.93315}, "CVE-2010-1174": {"epss_score": 0.10037, "epss_percentile": 0.92823}, "CVE-2010-1175": {"epss_score": 0.19225, "epss_percentile": 0.95151}, "CVE-2010-1176": {"epss_score": 0.12332, "epss_percentile": 0.93642}, "CVE-2010-1177": {"epss_score": 0.04442, "epss_percentile": 0.88694}, "CVE-2010-1178": {"epss_score": 0.0045, "epss_percentile": 0.63102}, "CVE-2010-1179": {"epss_score": 0.10846, "epss_percentile": 0.93132}, "CVE-2010-1180": {"epss_score": 0.05131, "epss_percentile": 0.8953}, "CVE-2010-1181": {"epss_score": 0.01438, "epss_percentile": 0.80286}, "CVE-2010-1182": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2010-1183": {"epss_score": 0.00061, "epss_percentile": 0.19489}, "CVE-2010-1184": {"epss_score": 0.0216, "epss_percentile": 0.83823}, "CVE-2010-1185": {"epss_score": 0.36598, "epss_percentile": 0.9699}, "CVE-2010-1186": {"epss_score": 0.00811, "epss_percentile": 0.73732}, "CVE-2010-1187": {"epss_score": 0.0013, "epss_percentile": 0.33248}, "CVE-2010-1188": {"epss_score": 0.02726, "epss_percentile": 0.85527}, "CVE-2010-1189": {"epss_score": 0.00381, "epss_percentile": 0.5901}, "CVE-2010-1190": {"epss_score": 0.00221, "epss_percentile": 0.44634}, "CVE-2010-1191": {"epss_score": 0.00396, "epss_percentile": 0.59885}, "CVE-2010-1192": {"epss_score": 0.00178, "epss_percentile": 0.39693}, "CVE-2010-1193": {"epss_score": 0.00365, "epss_percentile": 0.57996}, "CVE-2010-1194": {"epss_score": 0.00352, "epss_percentile": 0.57109}, "CVE-2010-1195": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2010-1196": {"epss_score": 0.05226, "epss_percentile": 0.89634}, "CVE-2010-1197": {"epss_score": 0.00998, "epss_percentile": 0.76471}, "CVE-2010-1198": {"epss_score": 0.06294, "epss_percentile": 0.9065}, "CVE-2010-1199": {"epss_score": 0.46743, "epss_percentile": 0.97556}, "CVE-2010-1200": {"epss_score": 0.06216, "epss_percentile": 0.90575}, "CVE-2010-1201": {"epss_score": 0.04587, "epss_percentile": 0.88888}, "CVE-2010-1202": {"epss_score": 0.07324, "epss_percentile": 0.9141}, "CVE-2010-1203": {"epss_score": 0.06216, "epss_percentile": 0.90574}, "CVE-2010-1204": {"epss_score": 0.00472, "epss_percentile": 0.64035}, "CVE-2010-1205": {"epss_score": 0.1678, "epss_percentile": 0.94731}, "CVE-2010-1206": {"epss_score": 0.00477, "epss_percentile": 0.64348}, "CVE-2010-1207": {"epss_score": 0.00262, "epss_percentile": 0.49351}, "CVE-2010-1208": {"epss_score": 0.01551, "epss_percentile": 0.8099}, "CVE-2010-1209": {"epss_score": 0.02213, "epss_percentile": 0.84023}, "CVE-2010-1210": {"epss_score": 0.00254, "epss_percentile": 0.48557}, "CVE-2010-1211": {"epss_score": 0.03796, "epss_percentile": 0.87736}, "CVE-2010-1212": {"epss_score": 0.02028, "epss_percentile": 0.83323}, "CVE-2010-1213": {"epss_score": 0.00201, "epss_percentile": 0.42325}, "CVE-2010-1214": {"epss_score": 0.04349, "epss_percentile": 0.88584}, "CVE-2010-1215": {"epss_score": 0.00484, "epss_percentile": 0.64662}, "CVE-2010-1216": {"epss_score": 0.01245, "epss_percentile": 0.78846}, "CVE-2010-1217": {"epss_score": 0.07857, "epss_percentile": 0.91724}, "CVE-2010-1218": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-1219": {"epss_score": 0.27216, "epss_percentile": 0.96222}, "CVE-2010-1221": {"epss_score": 0.00308, "epss_percentile": 0.53596}, "CVE-2010-1222": {"epss_score": 0.00308, "epss_percentile": 0.53596}, "CVE-2010-1223": {"epss_score": 0.37555, "epss_percentile": 0.97057}, "CVE-2010-1224": {"epss_score": 0.01, "epss_percentile": 0.76492}, "CVE-2010-1225": {"epss_score": 0.32735, "epss_percentile": 0.96722}, "CVE-2010-1226": {"epss_score": 0.04287, "epss_percentile": 0.88496}, "CVE-2010-1227": {"epss_score": 0.00405, "epss_percentile": 0.6048}, "CVE-2010-1228": {"epss_score": 0.00248, "epss_percentile": 0.47916}, "CVE-2010-1229": {"epss_score": 0.00431, "epss_percentile": 0.62094}, "CVE-2010-1230": {"epss_score": 0.00301, "epss_percentile": 0.5301}, "CVE-2010-1231": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2010-1232": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2010-1233": {"epss_score": 0.0183, "epss_percentile": 0.82445}, "CVE-2010-1234": {"epss_score": 0.00575, "epss_percentile": 0.68098}, "CVE-2010-1235": {"epss_score": 0.00242, "epss_percentile": 0.47388}, "CVE-2010-1236": {"epss_score": 0.00617, "epss_percentile": 0.69343}, "CVE-2010-1237": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2010-1238": {"epss_score": 0.00387, "epss_percentile": 0.59306}, "CVE-2010-1239": {"epss_score": 0.04996, "epss_percentile": 0.89372}, "CVE-2010-1240": {"epss_score": 0.91879, "epss_percentile": 0.99674}, "CVE-2010-1241": {"epss_score": 0.26201, "epss_percentile": 0.96123}, "CVE-2010-1242": {"epss_score": 0.00321, "epss_percentile": 0.54651}, "CVE-2010-1243": {"epss_score": 0.00463, "epss_percentile": 0.63631}, "CVE-2010-1244": {"epss_score": 0.00437, "epss_percentile": 0.62512}, "CVE-2010-1245": {"epss_score": 0.61401, "epss_percentile": 0.98247}, "CVE-2010-1246": {"epss_score": 0.61401, "epss_percentile": 0.98247}, "CVE-2010-1247": {"epss_score": 0.61401, "epss_percentile": 0.98247}, "CVE-2010-1248": {"epss_score": 0.6225, "epss_percentile": 0.98286}, "CVE-2010-1249": {"epss_score": 0.64885, "epss_percentile": 0.98397}, "CVE-2010-1250": {"epss_score": 0.62414, "epss_percentile": 0.98292}, "CVE-2010-1251": {"epss_score": 0.57317, "epss_percentile": 0.98058}, "CVE-2010-1252": {"epss_score": 0.57317, "epss_percentile": 0.98058}, "CVE-2010-1253": {"epss_score": 0.60976, "epss_percentile": 0.98228}, "CVE-2010-1254": {"epss_score": 0.00867, "epss_percentile": 0.7466}, "CVE-2010-1255": {"epss_score": 0.02204, "epss_percentile": 0.83998}, "CVE-2010-1256": {"epss_score": 0.33545, "epss_percentile": 0.96783}, "CVE-2010-1257": {"epss_score": 0.36865, "epss_percentile": 0.97006}, "CVE-2010-1258": {"epss_score": 0.20573, "epss_percentile": 0.95379}, "CVE-2010-1259": {"epss_score": 0.56431, "epss_percentile": 0.98022}, "CVE-2010-1260": {"epss_score": 0.48001, "epss_percentile": 0.97613}, "CVE-2010-1261": {"epss_score": 0.56431, "epss_percentile": 0.98022}, "CVE-2010-1262": {"epss_score": 0.63354, "epss_percentile": 0.98329}, "CVE-2010-1263": {"epss_score": 0.4797, "epss_percentile": 0.97612}, "CVE-2010-1264": {"epss_score": 0.58283, "epss_percentile": 0.98106}, "CVE-2010-1265": {"epss_score": 0.00409, "epss_percentile": 0.60764}, "CVE-2010-1266": {"epss_score": 0.03511, "epss_percentile": 0.87266}, "CVE-2010-1267": {"epss_score": 0.06294, "epss_percentile": 0.9065}, "CVE-2010-1268": {"epss_score": 0.0384, "epss_percentile": 0.87831}, "CVE-2010-1269": {"epss_score": 0.00583, "epss_percentile": 0.68345}, "CVE-2010-1270": {"epss_score": 0.0191, "epss_percentile": 0.82827}, "CVE-2010-1271": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-1272": {"epss_score": 0.01066, "epss_percentile": 0.77218}, "CVE-2010-1273": {"epss_score": 0.00395, "epss_percentile": 0.59838}, "CVE-2010-1274": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2010-1275": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-1276": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-1277": {"epss_score": 0.01516, "epss_percentile": 0.80797}, "CVE-2010-1278": {"epss_score": 0.13928, "epss_percentile": 0.94095}, "CVE-2010-1279": {"epss_score": 0.07458, "epss_percentile": 0.91482}, "CVE-2010-1280": {"epss_score": 0.29657, "epss_percentile": 0.96464}, "CVE-2010-1281": {"epss_score": 0.14067, "epss_percentile": 0.94128}, "CVE-2010-1282": {"epss_score": 0.01396, "epss_percentile": 0.79979}, "CVE-2010-1283": {"epss_score": 0.08605, "epss_percentile": 0.92147}, "CVE-2010-1284": {"epss_score": 0.02549, "epss_percentile": 0.85072}, "CVE-2010-1285": {"epss_score": 0.07699, "epss_percentile": 0.91633}, "CVE-2010-1286": {"epss_score": 0.04397, "epss_percentile": 0.88642}, "CVE-2010-1287": {"epss_score": 0.04397, "epss_percentile": 0.88642}, "CVE-2010-1288": {"epss_score": 0.07684, "epss_percentile": 0.91625}, "CVE-2010-1289": {"epss_score": 0.02549, "epss_percentile": 0.85072}, "CVE-2010-1290": {"epss_score": 0.02094, "epss_percentile": 0.83579}, "CVE-2010-1291": {"epss_score": 0.04397, "epss_percentile": 0.88642}, "CVE-2010-1292": {"epss_score": 0.05854, "epss_percentile": 0.90265}, "CVE-2010-1293": {"epss_score": 0.00816, "epss_percentile": 0.73803}, "CVE-2010-1294": {"epss_score": 0.00153, "epss_percentile": 0.36606}, "CVE-2010-1295": {"epss_score": 0.09617, "epss_percentile": 0.92625}, "CVE-2010-1296": {"epss_score": 0.2673, "epss_percentile": 0.96171}, "CVE-2010-1297": {"epss_score": 0.93388, "epss_percentile": 0.99802}, "CVE-2010-1298": {"epss_score": 0.00062, "epss_percentile": 0.19598}, "CVE-2010-1299": {"epss_score": 0.07649, "epss_percentile": 0.91603}, "CVE-2010-1300": {"epss_score": 0.0382, "epss_percentile": 0.87774}, "CVE-2010-1301": {"epss_score": 0.01258, "epss_percentile": 0.78955}, "CVE-2010-1302": {"epss_score": 0.13471, "epss_percentile": 0.93975}, "CVE-2010-1303": {"epss_score": 0.00165, "epss_percentile": 0.38061}, "CVE-2010-1304": {"epss_score": 0.03144, "epss_percentile": 0.86492}, "CVE-2010-1305": {"epss_score": 0.06216, "epss_percentile": 0.90574}, "CVE-2010-1306": {"epss_score": 0.05015, "epss_percentile": 0.89394}, "CVE-2010-1307": {"epss_score": 0.04579, "epss_percentile": 0.88873}, "CVE-2010-1308": {"epss_score": 0.0581, "epss_percentile": 0.90226}, "CVE-2010-1309": {"epss_score": 0.01099, "epss_percentile": 0.77559}, "CVE-2010-1310": {"epss_score": 0.00307, "epss_percentile": 0.53474}, "CVE-2010-1311": {"epss_score": 0.05061, "epss_percentile": 0.89453}, "CVE-2010-1312": {"epss_score": 0.04403, "epss_percentile": 0.88649}, "CVE-2010-1313": {"epss_score": 0.02852, "epss_percentile": 0.85831}, "CVE-2010-1314": {"epss_score": 0.01904, "epss_percentile": 0.82789}, "CVE-2010-1315": {"epss_score": 0.07172, "epss_percentile": 0.91298}, "CVE-2010-1316": {"epss_score": 0.06261, "epss_percentile": 0.9062}, "CVE-2010-1317": {"epss_score": 0.00747, "epss_percentile": 0.72564}, "CVE-2010-1318": {"epss_score": 0.77594, "epss_percentile": 0.98942}, "CVE-2010-1319": {"epss_score": 0.03626, "epss_percentile": 0.87459}, "CVE-2010-1320": {"epss_score": 0.22068, "epss_percentile": 0.95591}, "CVE-2010-1321": {"epss_score": 0.01857, "epss_percentile": 0.82577}, "CVE-2010-1322": {"epss_score": 0.01463, "epss_percentile": 0.80443}, "CVE-2010-1323": {"epss_score": 0.0417, "epss_percentile": 0.88346}, "CVE-2010-1324": {"epss_score": 0.03499, "epss_percentile": 0.87242}, "CVE-2010-1325": {"epss_score": 0.0014, "epss_percentile": 0.34778}, "CVE-2010-1326": {"epss_score": 0.0129, "epss_percentile": 0.79218}, "CVE-2010-1327": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-1328": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2010-1329": {"epss_score": 0.0029, "epss_percentile": 0.52098}, "CVE-2010-1330": {"epss_score": 0.00425, "epss_percentile": 0.61706}, "CVE-2010-1331": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-1332": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2010-1333": {"epss_score": 0.00705, "epss_percentile": 0.71583}, "CVE-2010-1334": {"epss_score": 0.01005, "epss_percentile": 0.76537}, "CVE-2010-1335": {"epss_score": 0.04696, "epss_percentile": 0.89019}, "CVE-2010-1336": {"epss_score": 0.0031, "epss_percentile": 0.53781}, "CVE-2010-1337": {"epss_score": 0.0094, "epss_percentile": 0.75742}, "CVE-2010-1338": {"epss_score": 0.02331, "epss_percentile": 0.84403}, "CVE-2010-1339": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-1340": {"epss_score": 0.03958, "epss_percentile": 0.88007}, "CVE-2010-1341": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2010-1342": {"epss_score": 0.00586, "epss_percentile": 0.68443}, "CVE-2010-1343": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-1344": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-1345": {"epss_score": 0.04019, "epss_percentile": 0.88127}, "CVE-2010-1346": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-1347": {"epss_score": 0.00049, "epss_percentile": 0.15648}, "CVE-2010-1348": {"epss_score": 0.00668, "epss_percentile": 0.7073}, "CVE-2010-1349": {"epss_score": 0.41837, "epss_percentile": 0.97296}, "CVE-2010-1350": {"epss_score": 0.01906, "epss_percentile": 0.8281}, "CVE-2010-1351": {"epss_score": 0.00517, "epss_percentile": 0.66073}, "CVE-2010-1352": {"epss_score": 0.05913, "epss_percentile": 0.90316}, "CVE-2010-1353": {"epss_score": 0.01076, "epss_percentile": 0.77322}, "CVE-2010-1354": {"epss_score": 0.06774, "epss_percentile": 0.91018}, "CVE-2010-1355": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-1356": {"epss_score": 0.02366, "epss_percentile": 0.84515}, "CVE-2010-1357": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2010-1358": {"epss_score": 0.00217, "epss_percentile": 0.44283}, "CVE-2010-1359": {"epss_score": 0.00428, "epss_percentile": 0.61958}, "CVE-2010-1360": {"epss_score": 0.01395, "epss_percentile": 0.79974}, "CVE-2010-1361": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2010-1362": {"epss_score": 0.00226, "epss_percentile": 0.45246}, "CVE-2010-1363": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-1364": {"epss_score": 0.00489, "epss_percentile": 0.64898}, "CVE-2010-1365": {"epss_score": 0.00583, "epss_percentile": 0.68345}, "CVE-2010-1366": {"epss_score": 0.00279, "epss_percentile": 0.5095}, "CVE-2010-1367": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-1368": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-1369": {"epss_score": 0.00844, "epss_percentile": 0.74271}, "CVE-2010-1370": {"epss_score": 0.00372, "epss_percentile": 0.58433}, "CVE-2010-1371": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-1372": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2010-1373": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2010-1374": {"epss_score": 0.008, "epss_percentile": 0.73548}, "CVE-2010-1375": {"epss_score": 0.00052, "epss_percentile": 0.16555}, "CVE-2010-1376": {"epss_score": 0.03702, "epss_percentile": 0.87593}, "CVE-2010-1377": {"epss_score": 0.01029, "epss_percentile": 0.76826}, "CVE-2010-1378": {"epss_score": 0.00229, "epss_percentile": 0.45585}, "CVE-2010-1379": {"epss_score": 0.01558, "epss_percentile": 0.81028}, "CVE-2010-1380": {"epss_score": 0.04151, "epss_percentile": 0.88321}, "CVE-2010-1381": {"epss_score": 0.00352, "epss_percentile": 0.57096}, "CVE-2010-1382": {"epss_score": 0.00324, "epss_percentile": 0.54954}, "CVE-2010-1383": {"epss_score": 0.00562, "epss_percentile": 0.67692}, "CVE-2010-1384": {"epss_score": 0.01276, "epss_percentile": 0.7911}, "CVE-2010-1385": {"epss_score": 0.03265, "epss_percentile": 0.86781}, "CVE-2010-1386": {"epss_score": 0.01383, "epss_percentile": 0.79892}, "CVE-2010-1387": {"epss_score": 0.08537, "epss_percentile": 0.9211}, "CVE-2010-1388": {"epss_score": 0.0084, "epss_percentile": 0.74205}, "CVE-2010-1389": {"epss_score": 0.00983, "epss_percentile": 0.76306}, "CVE-2010-1390": {"epss_score": 0.01167, "epss_percentile": 0.78187}, "CVE-2010-1391": {"epss_score": 0.00406, "epss_percentile": 0.60547}, "CVE-2010-1392": {"epss_score": 0.08588, "epss_percentile": 0.92136}, "CVE-2010-1393": {"epss_score": 0.0136, "epss_percentile": 0.79747}, "CVE-2010-1394": {"epss_score": 0.01167, "epss_percentile": 0.78187}, "CVE-2010-1395": {"epss_score": 0.01167, "epss_percentile": 0.78187}, "CVE-2010-1396": {"epss_score": 0.04831, "epss_percentile": 0.89191}, "CVE-2010-1397": {"epss_score": 0.11246, "epss_percentile": 0.93277}, "CVE-2010-1398": {"epss_score": 0.05238, "epss_percentile": 0.89649}, "CVE-2010-1399": {"epss_score": 0.03757, "epss_percentile": 0.87682}, "CVE-2010-1400": {"epss_score": 0.08749, "epss_percentile": 0.9224}, "CVE-2010-1401": {"epss_score": 0.07896, "epss_percentile": 0.91751}, "CVE-2010-1402": {"epss_score": 0.07896, "epss_percentile": 0.91751}, "CVE-2010-1403": {"epss_score": 0.11046, "epss_percentile": 0.93201}, "CVE-2010-1404": {"epss_score": 0.11246, "epss_percentile": 0.93277}, "CVE-2010-1405": {"epss_score": 0.0765, "epss_percentile": 0.91604}, "CVE-2010-1406": {"epss_score": 0.00744, "epss_percentile": 0.72505}, "CVE-2010-1407": {"epss_score": 0.00732, "epss_percentile": 0.72187}, "CVE-2010-1408": {"epss_score": 0.00737, "epss_percentile": 0.72319}, "CVE-2010-1409": {"epss_score": 0.00862, "epss_percentile": 0.74573}, "CVE-2010-1410": {"epss_score": 0.17911, "epss_percentile": 0.94925}, "CVE-2010-1411": {"epss_score": 0.00745, "epss_percentile": 0.7253}, "CVE-2010-1412": {"epss_score": 0.14679, "epss_percentile": 0.94262}, "CVE-2010-1413": {"epss_score": 0.00988, "epss_percentile": 0.7635}, "CVE-2010-1414": {"epss_score": 0.12602, "epss_percentile": 0.93725}, "CVE-2010-1415": {"epss_score": 0.31845, "epss_percentile": 0.96654}, "CVE-2010-1416": {"epss_score": 0.01364, "epss_percentile": 0.79773}, "CVE-2010-1417": {"epss_score": 0.0765, "epss_percentile": 0.91604}, "CVE-2010-1418": {"epss_score": 0.01171, "epss_percentile": 0.78216}, "CVE-2010-1419": {"epss_score": 0.09017, "epss_percentile": 0.92368}, "CVE-2010-1420": {"epss_score": 0.00183, "epss_percentile": 0.40321}, "CVE-2010-1421": {"epss_score": 0.03825, "epss_percentile": 0.87792}, "CVE-2010-1422": {"epss_score": 0.01057, "epss_percentile": 0.77131}, "CVE-2010-1423": {"epss_score": 0.68947, "epss_percentile": 0.9857}, "CVE-2010-1424": {"epss_score": 0.04866, "epss_percentile": 0.89229}, "CVE-2010-1425": {"epss_score": 0.00499, "epss_percentile": 0.65284}, "CVE-2010-1426": {"epss_score": 0.00422, "epss_percentile": 0.6154}, "CVE-2010-1427": {"epss_score": 0.00365, "epss_percentile": 0.5799}, "CVE-2010-1428": {"epss_score": 0.65338, "epss_percentile": 0.98414}, "CVE-2010-1429": {"epss_score": 0.27359, "epss_percentile": 0.9624}, "CVE-2010-1431": {"epss_score": 0.06138, "epss_percentile": 0.90512}, "CVE-2010-1432": {"epss_score": 8e-05, "epss_percentile": 0.00487}, "CVE-2010-1433": {"epss_score": 0.00017, "epss_percentile": 0.03143}, "CVE-2010-1434": {"epss_score": 6e-05, "epss_percentile": 0.00309}, "CVE-2010-1435": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2010-1436": {"epss_score": 0.00131, "epss_percentile": 0.33414}, "CVE-2010-1437": {"epss_score": 0.00242, "epss_percentile": 0.47377}, "CVE-2010-1438": {"epss_score": 0.00064, "epss_percentile": 0.20153}, "CVE-2010-1439": {"epss_score": 0.00044, "epss_percentile": 0.13424}, "CVE-2010-1440": {"epss_score": 0.02869, "epss_percentile": 0.8587}, "CVE-2010-1441": {"epss_score": 0.01795, "epss_percentile": 0.82303}, "CVE-2010-1442": {"epss_score": 0.0182, "epss_percentile": 0.82407}, "CVE-2010-1443": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2010-1444": {"epss_score": 0.019, "epss_percentile": 0.8277}, "CVE-2010-1445": {"epss_score": 0.01795, "epss_percentile": 0.82303}, "CVE-2010-1446": {"epss_score": 0.00055, "epss_percentile": 0.17382}, "CVE-2010-1447": {"epss_score": 0.00615, "epss_percentile": 0.69312}, "CVE-2010-1448": {"epss_score": 0.00562, "epss_percentile": 0.67708}, "CVE-2010-1449": {"epss_score": 0.03785, "epss_percentile": 0.87723}, "CVE-2010-1450": {"epss_score": 0.02822, "epss_percentile": 0.85749}, "CVE-2010-1451": {"epss_score": 0.00099, "epss_percentile": 0.27865}, "CVE-2010-1452": {"epss_score": 0.19501, "epss_percentile": 0.95193}, "CVE-2010-1453": {"epss_score": 0.02055, "epss_percentile": 0.8342}, "CVE-2010-1454": {"epss_score": 0.0055, "epss_percentile": 0.67334}, "CVE-2010-1455": {"epss_score": 0.00958, "epss_percentile": 0.75945}, "CVE-2010-1457": {"epss_score": 0.00134, "epss_percentile": 0.33834}, "CVE-2010-1458": {"epss_score": 0.07304, "epss_percentile": 0.91395}, "CVE-2010-1459": {"epss_score": 0.0041, "epss_percentile": 0.60806}, "CVE-2010-1460": {"epss_score": 0.04999, "epss_percentile": 0.89376}, "CVE-2010-1461": {"epss_score": 0.07132, "epss_percentile": 0.91272}, "CVE-2010-1462": {"epss_score": 0.00129, "epss_percentile": 0.33076}, "CVE-2010-1463": {"epss_score": 0.00252, "epss_percentile": 0.48376}, "CVE-2010-1464": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2010-1465": {"epss_score": 0.65175, "epss_percentile": 0.98406}, "CVE-2010-1466": {"epss_score": 0.01782, "epss_percentile": 0.82246}, "CVE-2010-1467": {"epss_score": 0.01245, "epss_percentile": 0.78846}, "CVE-2010-1468": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-1469": {"epss_score": 0.04635, "epss_percentile": 0.88949}, "CVE-2010-1470": {"epss_score": 0.06839, "epss_percentile": 0.9106}, "CVE-2010-1471": {"epss_score": 0.09698, "epss_percentile": 0.92666}, "CVE-2010-1472": {"epss_score": 0.06547, "epss_percentile": 0.90841}, "CVE-2010-1473": {"epss_score": 0.03232, "epss_percentile": 0.86699}, "CVE-2010-1474": {"epss_score": 0.01819, "epss_percentile": 0.82406}, "CVE-2010-1475": {"epss_score": 0.02403, "epss_percentile": 0.84644}, "CVE-2010-1476": {"epss_score": 0.04011, "epss_percentile": 0.88112}, "CVE-2010-1477": {"epss_score": 0.01576, "epss_percentile": 0.81116}, "CVE-2010-1478": {"epss_score": 0.02405, "epss_percentile": 0.8465}, "CVE-2010-1479": {"epss_score": 0.01576, "epss_percentile": 0.81115}, "CVE-2010-1480": {"epss_score": 0.00201, "epss_percentile": 0.42277}, "CVE-2010-1481": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2010-1482": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-1486": {"epss_score": 0.00438, "epss_percentile": 0.6256}, "CVE-2010-1487": {"epss_score": 0.00055, "epss_percentile": 0.17551}, "CVE-2010-1488": {"epss_score": 0.00147, "epss_percentile": 0.35795}, "CVE-2010-1489": {"epss_score": 0.22055, "epss_percentile": 0.95588}, "CVE-2010-1490": {"epss_score": 0.00531, "epss_percentile": 0.66666}, "CVE-2010-1491": {"epss_score": 0.04773, "epss_percentile": 0.89129}, "CVE-2010-1492": {"epss_score": 0.00092, "epss_percentile": 0.26517}, "CVE-2010-1493": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-1494": {"epss_score": 0.04579, "epss_percentile": 0.88873}, "CVE-2010-1495": {"epss_score": 0.01547, "epss_percentile": 0.8097}, "CVE-2010-1496": {"epss_score": 0.005, "epss_percentile": 0.65327}, "CVE-2010-1497": {"epss_score": 0.04812, "epss_percentile": 0.89168}, "CVE-2010-1498": {"epss_score": 0.01898, "epss_percentile": 0.82764}, "CVE-2010-1499": {"epss_score": 0.00457, "epss_percentile": 0.63392}, "CVE-2010-1500": {"epss_score": 0.00216, "epss_percentile": 0.44151}, "CVE-2010-1502": {"epss_score": 0.01298, "epss_percentile": 0.79275}, "CVE-2010-1503": {"epss_score": 0.0036, "epss_percentile": 0.57634}, "CVE-2010-1504": {"epss_score": 0.0036, "epss_percentile": 0.57634}, "CVE-2010-1505": {"epss_score": 0.00825, "epss_percentile": 0.73952}, "CVE-2010-1506": {"epss_score": 0.00514, "epss_percentile": 0.65959}, "CVE-2010-1507": {"epss_score": 0.00195, "epss_percentile": 0.41711}, "CVE-2010-1508": {"epss_score": 0.05458, "epss_percentile": 0.89898}, "CVE-2010-1509": {"epss_score": 0.03679, "epss_percentile": 0.87557}, "CVE-2010-1510": {"epss_score": 0.04765, "epss_percentile": 0.89123}, "CVE-2010-1511": {"epss_score": 0.06639, "epss_percentile": 0.90909}, "CVE-2010-1512": {"epss_score": 0.00607, "epss_percentile": 0.69051}, "CVE-2010-1513": {"epss_score": 0.03203, "epss_percentile": 0.86627}, "CVE-2010-1514": {"epss_score": 0.00466, "epss_percentile": 0.638}, "CVE-2010-1515": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2010-1516": {"epss_score": 0.02365, "epss_percentile": 0.84511}, "CVE-2010-1517": {"epss_score": 0.007, "epss_percentile": 0.7146}, "CVE-2010-1518": {"epss_score": 0.01736, "epss_percentile": 0.82014}, "CVE-2010-1519": {"epss_score": 0.01331, "epss_percentile": 0.79518}, "CVE-2010-1520": {"epss_score": 0.00499, "epss_percentile": 0.65274}, "CVE-2010-1521": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2010-1522": {"epss_score": 0.00836, "epss_percentile": 0.74149}, "CVE-2010-1523": {"epss_score": 0.02571, "epss_percentile": 0.85129}, "CVE-2010-1524": {"epss_score": 0.02503, "epss_percentile": 0.84926}, "CVE-2010-1525": {"epss_score": 0.02581, "epss_percentile": 0.85155}, "CVE-2010-1526": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2010-1527": {"epss_score": 0.61151, "epss_percentile": 0.98236}, "CVE-2010-1528": {"epss_score": 0.00785, "epss_percentile": 0.73247}, "CVE-2010-1529": {"epss_score": 0.00259, "epss_percentile": 0.49098}, "CVE-2010-1530": {"epss_score": 0.00281, "epss_percentile": 0.51152}, "CVE-2010-1531": {"epss_score": 0.15925, "epss_percentile": 0.94537}, "CVE-2010-1532": {"epss_score": 0.02396, "epss_percentile": 0.84618}, "CVE-2010-1533": {"epss_score": 0.01114, "epss_percentile": 0.77696}, "CVE-2010-1534": {"epss_score": 0.0317, "epss_percentile": 0.86546}, "CVE-2010-1535": {"epss_score": 0.03024, "epss_percentile": 0.86232}, "CVE-2010-1536": {"epss_score": 0.00281, "epss_percentile": 0.51152}, "CVE-2010-1537": {"epss_score": 0.01701, "epss_percentile": 0.81837}, "CVE-2010-1538": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-1539": {"epss_score": 0.00356, "epss_percentile": 0.57351}, "CVE-2010-1540": {"epss_score": 0.16311, "epss_percentile": 0.94628}, "CVE-2010-1541": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-1542": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2010-1543": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2010-1544": {"epss_score": 0.06217, "epss_percentile": 0.90576}, "CVE-2010-1546": {"epss_score": 0.01196, "epss_percentile": 0.78435}, "CVE-2010-1547": {"epss_score": 0.00254, "epss_percentile": 0.48535}, "CVE-2010-1548": {"epss_score": 0.00364, "epss_percentile": 0.57906}, "CVE-2010-1549": {"epss_score": 0.88807, "epss_percentile": 0.99491}, "CVE-2010-1550": {"epss_score": 0.07208, "epss_percentile": 0.91325}, "CVE-2010-1551": {"epss_score": 0.09756, "epss_percentile": 0.92692}, "CVE-2010-1552": {"epss_score": 0.79947, "epss_percentile": 0.99064}, "CVE-2010-1553": {"epss_score": 0.83929, "epss_percentile": 0.99266}, "CVE-2010-1554": {"epss_score": 0.81439, "epss_percentile": 0.99138}, "CVE-2010-1555": {"epss_score": 0.79791, "epss_percentile": 0.99055}, "CVE-2010-1556": {"epss_score": 0.01574, "epss_percentile": 0.81103}, "CVE-2010-1557": {"epss_score": 0.00472, "epss_percentile": 0.64056}, "CVE-2010-1558": {"epss_score": 0.00093, "epss_percentile": 0.26634}, "CVE-2010-1559": {"epss_score": 0.00128, "epss_percentile": 0.32967}, "CVE-2010-1560": {"epss_score": 0.01097, "epss_percentile": 0.77527}, "CVE-2010-1561": {"epss_score": 0.01238, "epss_percentile": 0.78785}, "CVE-2010-1562": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2010-1563": {"epss_score": 0.01238, "epss_percentile": 0.78785}, "CVE-2010-1565": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-1567": {"epss_score": 0.01238, "epss_percentile": 0.78785}, "CVE-2010-1568": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2010-1570": {"epss_score": 0.00726, "epss_percentile": 0.72077}, "CVE-2010-1571": {"epss_score": 0.0034, "epss_percentile": 0.56211}, "CVE-2010-1572": {"epss_score": 0.0033, "epss_percentile": 0.55486}, "CVE-2010-1573": {"epss_score": 0.11251, "epss_percentile": 0.93279}, "CVE-2010-1574": {"epss_score": 0.01355, "epss_percentile": 0.79708}, "CVE-2010-1575": {"epss_score": 0.00266, "epss_percentile": 0.49887}, "CVE-2010-1576": {"epss_score": 0.00233, "epss_percentile": 0.46051}, "CVE-2010-1577": {"epss_score": 0.0086, "epss_percentile": 0.74542}, "CVE-2010-1578": {"epss_score": 0.00839, "epss_percentile": 0.74187}, "CVE-2010-1579": {"epss_score": 0.00839, "epss_percentile": 0.74187}, "CVE-2010-1580": {"epss_score": 0.00839, "epss_percentile": 0.74187}, "CVE-2010-1581": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-1583": {"epss_score": 0.00734, "epss_percentile": 0.7224}, "CVE-2010-1584": {"epss_score": 0.00326, "epss_percentile": 0.55063}, "CVE-2010-1585": {"epss_score": 0.00879, "epss_percentile": 0.74839}, "CVE-2010-1586": {"epss_score": 0.00524, "epss_percentile": 0.66318}, "CVE-2010-1587": {"epss_score": 0.75383, "epss_percentile": 0.98841}, "CVE-2010-1588": {"epss_score": 0.00372, "epss_percentile": 0.58427}, "CVE-2010-1589": {"epss_score": 0.00175, "epss_percentile": 0.39316}, "CVE-2010-1590": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-1591": {"epss_score": 0.00071, "epss_percentile": 0.22056}, "CVE-2010-1592": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2010-1593": {"epss_score": 0.00581, "epss_percentile": 0.68262}, "CVE-2010-1594": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-1595": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2010-1596": {"epss_score": 0.00442, "epss_percentile": 0.62744}, "CVE-2010-1597": {"epss_score": 0.21967, "epss_percentile": 0.95579}, "CVE-2010-1598": {"epss_score": 0.0075, "epss_percentile": 0.72626}, "CVE-2010-1599": {"epss_score": 0.0046, "epss_percentile": 0.63532}, "CVE-2010-1600": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-1601": {"epss_score": 0.19972, "epss_percentile": 0.95268}, "CVE-2010-1602": {"epss_score": 0.02228, "epss_percentile": 0.84078}, "CVE-2010-1603": {"epss_score": 0.06069, "epss_percentile": 0.9045}, "CVE-2010-1604": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2010-1605": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-1606": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2010-1607": {"epss_score": 0.02237, "epss_percentile": 0.84104}, "CVE-2010-1608": {"epss_score": 0.10352, "epss_percentile": 0.92956}, "CVE-2010-1609": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2010-1610": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2010-1611": {"epss_score": 0.00183, "epss_percentile": 0.40362}, "CVE-2010-1612": {"epss_score": 0.01309, "epss_percentile": 0.79352}, "CVE-2010-1613": {"epss_score": 0.00447, "epss_percentile": 0.62948}, "CVE-2010-1614": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2010-1615": {"epss_score": 0.00436, "epss_percentile": 0.62482}, "CVE-2010-1616": {"epss_score": 0.00277, "epss_percentile": 0.50824}, "CVE-2010-1617": {"epss_score": 0.00273, "epss_percentile": 0.5048}, "CVE-2010-1618": {"epss_score": 0.00273, "epss_percentile": 0.50466}, "CVE-2010-1619": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2010-1620": {"epss_score": 0.00229, "epss_percentile": 0.45615}, "CVE-2010-1621": {"epss_score": 0.00433, "epss_percentile": 0.62208}, "CVE-2010-1622": {"epss_score": 0.01856, "epss_percentile": 0.82572}, "CVE-2010-1623": {"epss_score": 0.25108, "epss_percentile": 0.95986}, "CVE-2010-1624": {"epss_score": 0.03095, "epss_percentile": 0.86402}, "CVE-2010-1625": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2010-1626": {"epss_score": 0.00087, "epss_percentile": 0.25615}, "CVE-2010-1627": {"epss_score": 0.00135, "epss_percentile": 0.33946}, "CVE-2010-1628": {"epss_score": 0.0512, "epss_percentile": 0.89519}, "CVE-2010-1629": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-1630": {"epss_score": 0.00463, "epss_percentile": 0.63631}, "CVE-2010-1632": {"epss_score": 0.0881, "epss_percentile": 0.92263}, "CVE-2010-1633": {"epss_score": 0.00501, "epss_percentile": 0.65341}, "CVE-2010-1634": {"epss_score": 0.01196, "epss_percentile": 0.78441}, "CVE-2010-1635": {"epss_score": 0.12656, "epss_percentile": 0.93742}, "CVE-2010-1636": {"epss_score": 0.00244, "epss_percentile": 0.47596}, "CVE-2010-1637": {"epss_score": 0.00614, "epss_percentile": 0.69267}, "CVE-2010-1638": {"epss_score": 0.00207, "epss_percentile": 0.43199}, "CVE-2010-1639": {"epss_score": 0.03325, "epss_percentile": 0.8692}, "CVE-2010-1640": {"epss_score": 0.02005, "epss_percentile": 0.83229}, "CVE-2010-1641": {"epss_score": 0.00053, "epss_percentile": 0.16753}, "CVE-2010-1642": {"epss_score": 0.05054, "epss_percentile": 0.89445}, "CVE-2010-1643": {"epss_score": 0.00093, "epss_percentile": 0.26606}, "CVE-2010-1644": {"epss_score": 0.02039, "epss_percentile": 0.83363}, "CVE-2010-1645": {"epss_score": 0.02794, "epss_percentile": 0.85676}, "CVE-2010-1646": {"epss_score": 0.00085, "epss_percentile": 0.25164}, "CVE-2010-1647": {"epss_score": 0.00249, "epss_percentile": 0.48037}, "CVE-2010-1648": {"epss_score": 0.00124, "epss_percentile": 0.32429}, "CVE-2010-1649": {"epss_score": 0.00031, "epss_percentile": 0.08699}, "CVE-2010-1650": {"epss_score": 0.00074, "epss_percentile": 0.22689}, "CVE-2010-1651": {"epss_score": 0.00049, "epss_percentile": 0.15444}, "CVE-2010-1652": {"epss_score": 0.03535, "epss_percentile": 0.8731}, "CVE-2010-1653": {"epss_score": 0.05171, "epss_percentile": 0.89571}, "CVE-2010-1654": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-1655": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-1656": {"epss_score": 0.00145, "epss_percentile": 0.35456}, "CVE-2010-1657": {"epss_score": 0.01501, "epss_percentile": 0.80718}, "CVE-2010-1658": {"epss_score": 0.04579, "epss_percentile": 0.88873}, "CVE-2010-1659": {"epss_score": 0.04574, "epss_percentile": 0.88866}, "CVE-2010-1660": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-1661": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2010-1662": {"epss_score": 0.01601, "epss_percentile": 0.81265}, "CVE-2010-1663": {"epss_score": 0.07184, "epss_percentile": 0.91305}, "CVE-2010-1664": {"epss_score": 0.0188, "epss_percentile": 0.82689}, "CVE-2010-1665": {"epss_score": 0.0188, "epss_percentile": 0.82689}, "CVE-2010-1666": {"epss_score": 0.00692, "epss_percentile": 0.71302}, "CVE-2010-1667": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2010-1668": {"epss_score": 0.00295, "epss_percentile": 0.52518}, "CVE-2010-1669": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2010-1670": {"epss_score": 0.00442, "epss_percentile": 0.62733}, "CVE-2010-1671": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2010-1673": {"epss_score": 0.00332, "epss_percentile": 0.55583}, "CVE-2010-1674": {"epss_score": 0.03404, "epss_percentile": 0.87073}, "CVE-2010-1675": {"epss_score": 0.03404, "epss_percentile": 0.87073}, "CVE-2010-1676": {"epss_score": 0.12368, "epss_percentile": 0.93651}, "CVE-2010-1677": {"epss_score": 0.11136, "epss_percentile": 0.93234}, "CVE-2010-1678": {"epss_score": 0.00681, "epss_percentile": 0.71056}, "CVE-2010-1679": {"epss_score": 0.00793, "epss_percentile": 0.73432}, "CVE-2010-1681": {"epss_score": 0.79079, "epss_percentile": 0.99019}, "CVE-2010-1685": {"epss_score": 0.1469, "epss_percentile": 0.94266}, "CVE-2010-1686": {"epss_score": 0.05203, "epss_percentile": 0.89608}, "CVE-2010-1687": {"epss_score": 0.0703, "epss_percentile": 0.91197}, "CVE-2010-1688": {"epss_score": 0.11606, "epss_percentile": 0.93419}, "CVE-2010-1689": {"epss_score": 0.25771, "epss_percentile": 0.96067}, "CVE-2010-1690": {"epss_score": 0.20685, "epss_percentile": 0.95401}, "CVE-2010-1693": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2010-1701": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-1702": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-1703": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2010-1704": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-1705": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-1706": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-1707": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-1708": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-1709": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-1710": {"epss_score": 0.0384, "epss_percentile": 0.87831}, "CVE-2010-1711": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2010-1712": {"epss_score": 0.0073, "epss_percentile": 0.72151}, "CVE-2010-1713": {"epss_score": 0.00324, "epss_percentile": 0.54968}, "CVE-2010-1714": {"epss_score": 0.07007, "epss_percentile": 0.91181}, "CVE-2010-1715": {"epss_score": 0.02135, "epss_percentile": 0.83726}, "CVE-2010-1716": {"epss_score": 0.00216, "epss_percentile": 0.44216}, "CVE-2010-1717": {"epss_score": 0.04997, "epss_percentile": 0.89374}, "CVE-2010-1718": {"epss_score": 0.0208, "epss_percentile": 0.8353}, "CVE-2010-1719": {"epss_score": 0.02873, "epss_percentile": 0.85878}, "CVE-2010-1720": {"epss_score": 0.0028, "epss_percentile": 0.51034}, "CVE-2010-1721": {"epss_score": 0.002, "epss_percentile": 0.42201}, "CVE-2010-1722": {"epss_score": 0.01519, "epss_percentile": 0.8082}, "CVE-2010-1723": {"epss_score": 0.0469, "epss_percentile": 0.89011}, "CVE-2010-1724": {"epss_score": 0.02874, "epss_percentile": 0.8588}, "CVE-2010-1725": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-1726": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-1727": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-1728": {"epss_score": 0.11455, "epss_percentile": 0.93366}, "CVE-2010-1729": {"epss_score": 0.00643, "epss_percentile": 0.70054}, "CVE-2010-1730": {"epss_score": 0.00444, "epss_percentile": 0.62808}, "CVE-2010-1731": {"epss_score": 0.0029, "epss_percentile": 0.52097}, "CVE-2010-1732": {"epss_score": 0.00109, "epss_percentile": 0.29915}, "CVE-2010-1733": {"epss_score": 0.00371, "epss_percentile": 0.58383}, "CVE-2010-1734": {"epss_score": 0.00863, "epss_percentile": 0.74592}, "CVE-2010-1735": {"epss_score": 0.00875, "epss_percentile": 0.74779}, "CVE-2010-1736": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2010-1737": {"epss_score": 0.01917, "epss_percentile": 0.82862}, "CVE-2010-1739": {"epss_score": 0.00027, "epss_percentile": 0.06853}, "CVE-2010-1740": {"epss_score": 0.00314, "epss_percentile": 0.54085}, "CVE-2010-1741": {"epss_score": 0.00319, "epss_percentile": 0.5448}, "CVE-2010-1742": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2010-1743": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-1744": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-1746": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2010-1748": {"epss_score": 0.13402, "epss_percentile": 0.93954}, "CVE-2010-1749": {"epss_score": 0.11346, "epss_percentile": 0.93318}, "CVE-2010-1750": {"epss_score": 0.04369, "epss_percentile": 0.88606}, "CVE-2010-1751": {"epss_score": 0.00479, "epss_percentile": 0.64416}, "CVE-2010-1752": {"epss_score": 0.03299, "epss_percentile": 0.86864}, "CVE-2010-1753": {"epss_score": 0.01512, "epss_percentile": 0.8078}, "CVE-2010-1754": {"epss_score": 0.00065, "epss_percentile": 0.20531}, "CVE-2010-1755": {"epss_score": 0.00342, "epss_percentile": 0.56369}, "CVE-2010-1756": {"epss_score": 0.00338, "epss_percentile": 0.5614}, "CVE-2010-1757": {"epss_score": 0.0264, "epss_percentile": 0.85302}, "CVE-2010-1758": {"epss_score": 0.12602, "epss_percentile": 0.93725}, "CVE-2010-1759": {"epss_score": 0.39609, "epss_percentile": 0.97171}, "CVE-2010-1760": {"epss_score": 0.01219, "epss_percentile": 0.7861}, "CVE-2010-1761": {"epss_score": 0.09083, "epss_percentile": 0.92392}, "CVE-2010-1762": {"epss_score": 0.00887, "epss_percentile": 0.7497}, "CVE-2010-1763": {"epss_score": 0.00758, "epss_percentile": 0.72774}, "CVE-2010-1764": {"epss_score": 0.00884, "epss_percentile": 0.74924}, "CVE-2010-1766": {"epss_score": 0.02348, "epss_percentile": 0.84458}, "CVE-2010-1767": {"epss_score": 0.00632, "epss_percentile": 0.69742}, "CVE-2010-1768": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2010-1769": {"epss_score": 0.05534, "epss_percentile": 0.89968}, "CVE-2010-1770": {"epss_score": 0.0973, "epss_percentile": 0.9268}, "CVE-2010-1771": {"epss_score": 0.07644, "epss_percentile": 0.91598}, "CVE-2010-1772": {"epss_score": 0.01993, "epss_percentile": 0.83184}, "CVE-2010-1773": {"epss_score": 0.01781, "epss_percentile": 0.82241}, "CVE-2010-1774": {"epss_score": 0.05278, "epss_percentile": 0.89684}, "CVE-2010-1775": {"epss_score": 0.00048, "epss_percentile": 0.15171}, "CVE-2010-1776": {"epss_score": 0.00362, "epss_percentile": 0.578}, "CVE-2010-1777": {"epss_score": 0.02872, "epss_percentile": 0.85876}, "CVE-2010-1778": {"epss_score": 0.00199, "epss_percentile": 0.42107}, "CVE-2010-1780": {"epss_score": 0.07061, "epss_percentile": 0.9122}, "CVE-2010-1781": {"epss_score": 0.08002, "epss_percentile": 0.91822}, "CVE-2010-1782": {"epss_score": 0.07108, "epss_percentile": 0.91257}, "CVE-2010-1783": {"epss_score": 0.05363, "epss_percentile": 0.89784}, "CVE-2010-1784": {"epss_score": 0.05363, "epss_percentile": 0.89784}, "CVE-2010-1785": {"epss_score": 0.08203, "epss_percentile": 0.91929}, "CVE-2010-1786": {"epss_score": 0.07061, "epss_percentile": 0.9122}, "CVE-2010-1787": {"epss_score": 0.07108, "epss_percentile": 0.91257}, "CVE-2010-1788": {"epss_score": 0.07108, "epss_percentile": 0.91257}, "CVE-2010-1789": {"epss_score": 0.18379, "epss_percentile": 0.95008}, "CVE-2010-1790": {"epss_score": 0.04128, "epss_percentile": 0.88293}, "CVE-2010-1791": {"epss_score": 0.07992, "epss_percentile": 0.91811}, "CVE-2010-1792": {"epss_score": 0.07108, "epss_percentile": 0.91257}, "CVE-2010-1793": {"epss_score": 0.38533, "epss_percentile": 0.97103}, "CVE-2010-1794": {"epss_score": 0.0005, "epss_percentile": 0.15674}, "CVE-2010-1795": {"epss_score": 0.01966, "epss_percentile": 0.83083}, "CVE-2010-1796": {"epss_score": 0.00337, "epss_percentile": 0.56024}, "CVE-2010-1797": {"epss_score": 0.48438, "epss_percentile": 0.97637}, "CVE-2010-1799": {"epss_score": 0.67678, "epss_percentile": 0.98517}, "CVE-2010-1800": {"epss_score": 0.00297, "epss_percentile": 0.5269}, "CVE-2010-1801": {"epss_score": 0.01486, "epss_percentile": 0.80607}, "CVE-2010-1802": {"epss_score": 0.00119, "epss_percentile": 0.31585}, "CVE-2010-1803": {"epss_score": 0.00307, "epss_percentile": 0.53474}, "CVE-2010-1804": {"epss_score": 0.00932, "epss_percentile": 0.75627}, "CVE-2010-1805": {"epss_score": 0.00053, "epss_percentile": 0.1671}, "CVE-2010-1806": {"epss_score": 0.04936, "epss_percentile": 0.89303}, "CVE-2010-1807": {"epss_score": 0.80553, "epss_percentile": 0.99094}, "CVE-2010-1808": {"epss_score": 0.01392, "epss_percentile": 0.79956}, "CVE-2010-1809": {"epss_score": 0.00857, "epss_percentile": 0.74493}, "CVE-2010-1810": {"epss_score": 0.00125, "epss_percentile": 0.32591}, "CVE-2010-1811": {"epss_score": 0.04365, "epss_percentile": 0.88602}, "CVE-2010-1812": {"epss_score": 0.05507, "epss_percentile": 0.89945}, "CVE-2010-1813": {"epss_score": 0.17387, "epss_percentile": 0.94843}, "CVE-2010-1814": {"epss_score": 0.04602, "epss_percentile": 0.88904}, "CVE-2010-1815": {"epss_score": 0.05507, "epss_percentile": 0.89945}, "CVE-2010-1816": {"epss_score": 0.00825, "epss_percentile": 0.73952}, "CVE-2010-1817": {"epss_score": 0.01336, "epss_percentile": 0.79555}, "CVE-2010-1818": {"epss_score": 0.76511, "epss_percentile": 0.98893}, "CVE-2010-1819": {"epss_score": 0.03838, "epss_percentile": 0.87826}, "CVE-2010-1820": {"epss_score": 0.00321, "epss_percentile": 0.54685}, "CVE-2010-1821": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2010-1822": {"epss_score": 0.02967, "epss_percentile": 0.86088}, "CVE-2010-1823": {"epss_score": 0.01898, "epss_percentile": 0.82763}, "CVE-2010-1824": {"epss_score": 0.15871, "epss_percentile": 0.94524}, "CVE-2010-1825": {"epss_score": 0.01246, "epss_percentile": 0.78856}, "CVE-2010-1828": {"epss_score": 0.00975, "epss_percentile": 0.76204}, "CVE-2010-1829": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2010-1830": {"epss_score": 0.00307, "epss_percentile": 0.53474}, "CVE-2010-1831": {"epss_score": 0.01768, "epss_percentile": 0.82179}, "CVE-2010-1832": {"epss_score": 0.01768, "epss_percentile": 0.82179}, "CVE-2010-1833": {"epss_score": 0.01411, "epss_percentile": 0.80086}, "CVE-2010-1834": {"epss_score": 0.00288, "epss_percentile": 0.51911}, "CVE-2010-1836": {"epss_score": 0.01486, "epss_percentile": 0.80607}, "CVE-2010-1837": {"epss_score": 0.01927, "epss_percentile": 0.82928}, "CVE-2010-1838": {"epss_score": 0.00091, "epss_percentile": 0.26264}, "CVE-2010-1840": {"epss_score": 0.0436, "epss_percentile": 0.88595}, "CVE-2010-1841": {"epss_score": 0.0219, "epss_percentile": 0.83932}, "CVE-2010-1842": {"epss_score": 0.03178, "epss_percentile": 0.86574}, "CVE-2010-1843": {"epss_score": 0.01642, "epss_percentile": 0.81511}, "CVE-2010-1844": {"epss_score": 0.00782, "epss_percentile": 0.73202}, "CVE-2010-1845": {"epss_score": 0.01796, "epss_percentile": 0.82306}, "CVE-2010-1846": {"epss_score": 0.01392, "epss_percentile": 0.79956}, "CVE-2010-1847": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2010-1848": {"epss_score": 0.00069, "epss_percentile": 0.2143}, "CVE-2010-1849": {"epss_score": 0.024, "epss_percentile": 0.84637}, "CVE-2010-1850": {"epss_score": 0.6329, "epss_percentile": 0.98326}, "CVE-2010-1851": {"epss_score": 0.00089, "epss_percentile": 0.25814}, "CVE-2010-1852": {"epss_score": 0.10245, "epss_percentile": 0.92911}, "CVE-2010-1853": {"epss_score": 0.03007, "epss_percentile": 0.86188}, "CVE-2010-1854": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2010-1855": {"epss_score": 0.02677, "epss_percentile": 0.85405}, "CVE-2010-1856": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2010-1857": {"epss_score": 0.00538, "epss_percentile": 0.66943}, "CVE-2010-1858": {"epss_score": 0.03621, "epss_percentile": 0.87444}, "CVE-2010-1859": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2010-1860": {"epss_score": 0.00462, "epss_percentile": 0.63625}, "CVE-2010-1861": {"epss_score": 0.00362, "epss_percentile": 0.57812}, "CVE-2010-1862": {"epss_score": 0.00462, "epss_percentile": 0.63625}, "CVE-2010-1863": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2010-1864": {"epss_score": 0.00462, "epss_percentile": 0.63625}, "CVE-2010-1865": {"epss_score": 0.01458, "epss_percentile": 0.80408}, "CVE-2010-1866": {"epss_score": 0.0156, "epss_percentile": 0.81041}, "CVE-2010-1867": {"epss_score": 0.00791, "epss_percentile": 0.73382}, "CVE-2010-1868": {"epss_score": 0.01043, "epss_percentile": 0.76994}, "CVE-2010-1869": {"epss_score": 0.21202, "epss_percentile": 0.95476}, "CVE-2010-1870": {"epss_score": 0.9341, "epss_percentile": 0.99805}, "CVE-2010-1871": {"epss_score": 0.93788, "epss_percentile": 0.99846}, "CVE-2010-1872": {"epss_score": 0.00716, "epss_percentile": 0.71856}, "CVE-2010-1873": {"epss_score": 0.00819, "epss_percentile": 0.73869}, "CVE-2010-1874": {"epss_score": 0.00109, "epss_percentile": 0.3}, "CVE-2010-1875": {"epss_score": 0.01575, "epss_percentile": 0.81109}, "CVE-2010-1876": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2010-1877": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-1878": {"epss_score": 0.02797, "epss_percentile": 0.85684}, "CVE-2010-1879": {"epss_score": 0.57576, "epss_percentile": 0.98071}, "CVE-2010-1880": {"epss_score": 0.59834, "epss_percentile": 0.98184}, "CVE-2010-1881": {"epss_score": 0.56148, "epss_percentile": 0.9801}, "CVE-2010-1882": {"epss_score": 0.64558, "epss_percentile": 0.98382}, "CVE-2010-1883": {"epss_score": 0.656, "epss_percentile": 0.98428}, "CVE-2010-1885": {"epss_score": 0.91196, "epss_percentile": 0.99626}, "CVE-2010-1886": {"epss_score": 0.00735, "epss_percentile": 0.72289}, "CVE-2010-1887": {"epss_score": 0.00399, "epss_percentile": 0.60106}, "CVE-2010-1888": {"epss_score": 0.00768, "epss_percentile": 0.72971}, "CVE-2010-1889": {"epss_score": 0.00944, "epss_percentile": 0.75788}, "CVE-2010-1890": {"epss_score": 0.00484, "epss_percentile": 0.64664}, "CVE-2010-1891": {"epss_score": 0.0043, "epss_percentile": 0.62025}, "CVE-2010-1892": {"epss_score": 0.80211, "epss_percentile": 0.99076}, "CVE-2010-1893": {"epss_score": 0.00637, "epss_percentile": 0.6989}, "CVE-2010-1894": {"epss_score": 0.00726, "epss_percentile": 0.72068}, "CVE-2010-1895": {"epss_score": 0.01489, "epss_percentile": 0.80626}, "CVE-2010-1896": {"epss_score": 0.00994, "epss_percentile": 0.76427}, "CVE-2010-1897": {"epss_score": 0.00801, "epss_percentile": 0.7357}, "CVE-2010-1898": {"epss_score": 0.54698, "epss_percentile": 0.9794}, "CVE-2010-1899": {"epss_score": 0.85958, "epss_percentile": 0.99358}, "CVE-2010-1900": {"epss_score": 0.43664, "epss_percentile": 0.97397}, "CVE-2010-1901": {"epss_score": 0.47913, "epss_percentile": 0.97608}, "CVE-2010-1902": {"epss_score": 0.58304, "epss_percentile": 0.98107}, "CVE-2010-1903": {"epss_score": 0.55117, "epss_percentile": 0.97961}, "CVE-2010-1904": {"epss_score": 0.01234, "epss_percentile": 0.78757}, "CVE-2010-1905": {"epss_score": 0.03287, "epss_percentile": 0.86828}, "CVE-2010-1906": {"epss_score": 0.03147, "epss_percentile": 0.86498}, "CVE-2010-1907": {"epss_score": 0.02401, "epss_percentile": 0.84638}, "CVE-2010-1908": {"epss_score": 0.01798, "epss_percentile": 0.82312}, "CVE-2010-1909": {"epss_score": 0.11062, "epss_percentile": 0.93206}, "CVE-2010-1910": {"epss_score": 0.01102, "epss_percentile": 0.77584}, "CVE-2010-1911": {"epss_score": 0.02064, "epss_percentile": 0.83451}, "CVE-2010-1912": {"epss_score": 0.03815, "epss_percentile": 0.87767}, "CVE-2010-1913": {"epss_score": 0.02963, "epss_percentile": 0.86076}, "CVE-2010-1914": {"epss_score": 0.0056, "epss_percentile": 0.67646}, "CVE-2010-1915": {"epss_score": 0.005, "epss_percentile": 0.65316}, "CVE-2010-1916": {"epss_score": 0.00708, "epss_percentile": 0.71666}, "CVE-2010-1917": {"epss_score": 0.01661, "epss_percentile": 0.81624}, "CVE-2010-1918": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-1919": {"epss_score": 0.01659, "epss_percentile": 0.81612}, "CVE-2010-1920": {"epss_score": 0.02279, "epss_percentile": 0.84238}, "CVE-2010-1921": {"epss_score": 0.06242, "epss_percentile": 0.90596}, "CVE-2010-1922": {"epss_score": 0.01917, "epss_percentile": 0.82862}, "CVE-2010-1923": {"epss_score": 0.0046, "epss_percentile": 0.63532}, "CVE-2010-1924": {"epss_score": 0.00158, "epss_percentile": 0.37191}, "CVE-2010-1925": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-1926": {"epss_score": 0.02355, "epss_percentile": 0.8448}, "CVE-2010-1927": {"epss_score": 0.07042, "epss_percentile": 0.91207}, "CVE-2010-1928": {"epss_score": 0.01747, "epss_percentile": 0.82076}, "CVE-2010-1929": {"epss_score": 0.19471, "epss_percentile": 0.9519}, "CVE-2010-1930": {"epss_score": 0.23049, "epss_percentile": 0.95725}, "CVE-2010-1931": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-1932": {"epss_score": 0.08031, "epss_percentile": 0.91842}, "CVE-2010-1934": {"epss_score": 0.04696, "epss_percentile": 0.89019}, "CVE-2010-1935": {"epss_score": 0.01747, "epss_percentile": 0.82076}, "CVE-2010-1936": {"epss_score": 0.01747, "epss_percentile": 0.82076}, "CVE-2010-1937": {"epss_score": 0.06311, "epss_percentile": 0.90663}, "CVE-2010-1938": {"epss_score": 0.65655, "epss_percentile": 0.9843}, "CVE-2010-1939": {"epss_score": 0.50723, "epss_percentile": 0.97746}, "CVE-2010-1940": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2010-1941": {"epss_score": 0.02152, "epss_percentile": 0.8379}, "CVE-2010-1942": {"epss_score": 0.00762, "epss_percentile": 0.72848}, "CVE-2010-1943": {"epss_score": 0.01955, "epss_percentile": 0.83034}, "CVE-2010-1944": {"epss_score": 0.06909, "epss_percentile": 0.91111}, "CVE-2010-1945": {"epss_score": 0.04326, "epss_percentile": 0.88554}, "CVE-2010-1946": {"epss_score": 0.0575, "epss_percentile": 0.90178}, "CVE-2010-1947": {"epss_score": 0.02758, "epss_percentile": 0.85595}, "CVE-2010-1948": {"epss_score": 0.01782, "epss_percentile": 0.82246}, "CVE-2010-1949": {"epss_score": 0.00326, "epss_percentile": 0.55082}, "CVE-2010-1950": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2010-1951": {"epss_score": 0.02293, "epss_percentile": 0.84287}, "CVE-2010-1952": {"epss_score": 0.03339, "epss_percentile": 0.86939}, "CVE-2010-1953": {"epss_score": 0.02922, "epss_percentile": 0.85994}, "CVE-2010-1954": {"epss_score": 0.0982, "epss_percentile": 0.92717}, "CVE-2010-1955": {"epss_score": 0.02663, "epss_percentile": 0.85372}, "CVE-2010-1956": {"epss_score": 0.05092, "epss_percentile": 0.89484}, "CVE-2010-1957": {"epss_score": 0.05954, "epss_percentile": 0.9036}, "CVE-2010-1958": {"epss_score": 0.00269, "epss_percentile": 0.50158}, "CVE-2010-1959": {"epss_score": 0.00935, "epss_percentile": 0.75673}, "CVE-2010-1960": {"epss_score": 0.69253, "epss_percentile": 0.98582}, "CVE-2010-1961": {"epss_score": 0.69253, "epss_percentile": 0.98582}, "CVE-2010-1962": {"epss_score": 0.29131, "epss_percentile": 0.9642}, "CVE-2010-1963": {"epss_score": 0.00472, "epss_percentile": 0.64056}, "CVE-2010-1964": {"epss_score": 0.79492, "epss_percentile": 0.99041}, "CVE-2010-1965": {"epss_score": 0.01164, "epss_percentile": 0.78165}, "CVE-2010-1966": {"epss_score": 0.00082, "epss_percentile": 0.24578}, "CVE-2010-1967": {"epss_score": 0.00161, "epss_percentile": 0.37564}, "CVE-2010-1968": {"epss_score": 0.00098, "epss_percentile": 0.27716}, "CVE-2010-1969": {"epss_score": 0.00645, "epss_percentile": 0.7012}, "CVE-2010-1970": {"epss_score": 0.00092, "epss_percentile": 0.26501}, "CVE-2010-1971": {"epss_score": 0.00098, "epss_percentile": 0.27716}, "CVE-2010-1972": {"epss_score": 0.00868, "epss_percentile": 0.74663}, "CVE-2010-1973": {"epss_score": 0.00034, "epss_percentile": 0.09648}, "CVE-2010-1975": {"epss_score": 0.00277, "epss_percentile": 0.50841}, "CVE-2010-1976": {"epss_score": 0.00269, "epss_percentile": 0.50158}, "CVE-2010-1977": {"epss_score": 0.14139, "epss_percentile": 0.94143}, "CVE-2010-1978": {"epss_score": 0.00678, "epss_percentile": 0.71003}, "CVE-2010-1979": {"epss_score": 0.02865, "epss_percentile": 0.85859}, "CVE-2010-1980": {"epss_score": 0.06951, "epss_percentile": 0.91138}, "CVE-2010-1981": {"epss_score": 0.01654, "epss_percentile": 0.81587}, "CVE-2010-1982": {"epss_score": 0.04195, "epss_percentile": 0.88381}, "CVE-2010-1983": {"epss_score": 0.03413, "epss_percentile": 0.87088}, "CVE-2010-1984": {"epss_score": 0.00269, "epss_percentile": 0.50158}, "CVE-2010-1985": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2010-1986": {"epss_score": 0.01368, "epss_percentile": 0.7979}, "CVE-2010-1987": {"epss_score": 0.01368, "epss_percentile": 0.7979}, "CVE-2010-1988": {"epss_score": 0.07147, "epss_percentile": 0.91282}, "CVE-2010-1989": {"epss_score": 0.00543, "epss_percentile": 0.67123}, "CVE-2010-1990": {"epss_score": 0.00543, "epss_percentile": 0.67123}, "CVE-2010-1991": {"epss_score": 0.13654, "epss_percentile": 0.94022}, "CVE-2010-1992": {"epss_score": 0.00543, "epss_percentile": 0.67123}, "CVE-2010-1993": {"epss_score": 0.00746, "epss_percentile": 0.72541}, "CVE-2010-1994": {"epss_score": 0.00341, "epss_percentile": 0.56313}, "CVE-2010-1995": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2010-1996": {"epss_score": 0.00458, "epss_percentile": 0.63439}, "CVE-2010-1997": {"epss_score": 0.00459, "epss_percentile": 0.6345}, "CVE-2010-1998": {"epss_score": 0.00356, "epss_percentile": 0.57351}, "CVE-2010-1999": {"epss_score": 0.01444, "epss_percentile": 0.80317}, "CVE-2010-20007": {"epss_score": 0.20179, "epss_percentile": 0.95299}, "CVE-2010-20010": {"epss_score": 0.10696, "epss_percentile": 0.93074}, "CVE-2010-20034": {"epss_score": 0.27949, "epss_percentile": 0.96299}, "CVE-2010-20042": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2010-20045": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2010-20049": {"epss_score": 0.5977, "epss_percentile": 0.9818}, "CVE-2010-20059": {"epss_score": 0.56521, "epss_percentile": 0.98026}, "CVE-2010-20103": {"epss_score": 0.83702, "epss_percentile": 0.99259}, "CVE-2010-20107": {"epss_score": 0.27949, "epss_percentile": 0.96299}, "CVE-2010-20108": {"epss_score": 0.25188, "epss_percentile": 0.95996}, "CVE-2010-20109": {"epss_score": 0.59625, "epss_percentile": 0.98172}, "CVE-2010-20111": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2010-20112": {"epss_score": 0.57969, "epss_percentile": 0.98093}, "CVE-2010-20113": {"epss_score": 0.69916, "epss_percentile": 0.98609}, "CVE-2010-20114": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2010-20115": {"epss_score": 0.59254, "epss_percentile": 0.98157}, "CVE-2010-20119": {"epss_score": 0.57969, "epss_percentile": 0.98093}, "CVE-2010-20120": {"epss_score": 0.10696, "epss_percentile": 0.93074}, "CVE-2010-20121": {"epss_score": 0.74878, "epss_percentile": 0.98822}, "CVE-2010-20122": {"epss_score": 0.63848, "epss_percentile": 0.98353}, "CVE-2010-20123": {"epss_score": 0.05428, "epss_percentile": 0.89871}, "CVE-2010-2000": {"epss_score": 0.00232, "epss_percentile": 0.45899}, "CVE-2010-2001": {"epss_score": 0.00348, "epss_percentile": 0.56806}, "CVE-2010-2002": {"epss_score": 0.00281, "epss_percentile": 0.51152}, "CVE-2010-2003": {"epss_score": 0.06079, "epss_percentile": 0.90461}, "CVE-2010-2004": {"epss_score": 0.12704, "epss_percentile": 0.93753}, "CVE-2010-2005": {"epss_score": 0.01319, "epss_percentile": 0.79433}, "CVE-2010-2006": {"epss_score": 0.06972, "epss_percentile": 0.91154}, "CVE-2010-2007": {"epss_score": 0.00167, "epss_percentile": 0.38339}, "CVE-2010-2008": {"epss_score": 0.03606, "epss_percentile": 0.87417}, "CVE-2010-2009": {"epss_score": 0.12608, "epss_percentile": 0.93728}, "CVE-2010-2010": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2010-2011": {"epss_score": 0.25135, "epss_percentile": 0.95989}, "CVE-2010-2012": {"epss_score": 0.00517, "epss_percentile": 0.66092}, "CVE-2010-2013": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-2014": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-2015": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-2016": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-2017": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-2018": {"epss_score": 0.00334, "epss_percentile": 0.55693}, "CVE-2010-2019": {"epss_score": 0.00428, "epss_percentile": 0.61958}, "CVE-2010-2020": {"epss_score": 0.00314, "epss_percentile": 0.54143}, "CVE-2010-2021": {"epss_score": 0.01222, "epss_percentile": 0.78661}, "CVE-2010-2022": {"epss_score": 0.00142, "epss_percentile": 0.34985}, "CVE-2010-2023": {"epss_score": 0.00089, "epss_percentile": 0.25874}, "CVE-2010-2024": {"epss_score": 0.00067, "epss_percentile": 0.21116}, "CVE-2010-2025": {"epss_score": 0.00302, "epss_percentile": 0.53124}, "CVE-2010-2026": {"epss_score": 0.00294, "epss_percentile": 0.52368}, "CVE-2010-2027": {"epss_score": 0.00032, "epss_percentile": 0.08771}, "CVE-2010-2028": {"epss_score": 0.20345, "epss_percentile": 0.95328}, "CVE-2010-2029": {"epss_score": 0.00351, "epss_percentile": 0.57046}, "CVE-2010-2030": {"epss_score": 0.0024, "epss_percentile": 0.47188}, "CVE-2010-2031": {"epss_score": 0.00124, "epss_percentile": 0.32418}, "CVE-2010-2032": {"epss_score": 0.0225, "epss_percentile": 0.84156}, "CVE-2010-2033": {"epss_score": 0.01378, "epss_percentile": 0.79849}, "CVE-2010-2034": {"epss_score": 0.01646, "epss_percentile": 0.81534}, "CVE-2010-2035": {"epss_score": 0.01646, "epss_percentile": 0.81534}, "CVE-2010-2036": {"epss_score": 0.00598, "epss_percentile": 0.68777}, "CVE-2010-2037": {"epss_score": 0.01646, "epss_percentile": 0.81534}, "CVE-2010-2038": {"epss_score": 0.00288, "epss_percentile": 0.51917}, "CVE-2010-2039": {"epss_score": 0.01952, "epss_percentile": 0.83021}, "CVE-2010-2040": {"epss_score": 0.01601, "epss_percentile": 0.81265}, "CVE-2010-2041": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2010-2042": {"epss_score": 0.00409, "epss_percentile": 0.60764}, "CVE-2010-2043": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2010-2044": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-2045": {"epss_score": 0.09628, "epss_percentile": 0.9263}, "CVE-2010-2046": {"epss_score": 0.00446, "epss_percentile": 0.62934}, "CVE-2010-2047": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2010-2048": {"epss_score": 0.00207, "epss_percentile": 0.43129}, "CVE-2010-2049": {"epss_score": 0.00437, "epss_percentile": 0.6253}, "CVE-2010-2050": {"epss_score": 0.03017, "epss_percentile": 0.86218}, "CVE-2010-2051": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2010-2053": {"epss_score": 0.00032, "epss_percentile": 0.09012}, "CVE-2010-2054": {"epss_score": 0.03181, "epss_percentile": 0.86579}, "CVE-2010-2055": {"epss_score": 0.00064, "epss_percentile": 0.20403}, "CVE-2010-2056": {"epss_score": 0.00042, "epss_percentile": 0.12497}, "CVE-2010-2057": {"epss_score": 0.00802, "epss_percentile": 0.73591}, "CVE-2010-2058": {"epss_score": 0.00048, "epss_percentile": 0.1516}, "CVE-2010-2059": {"epss_score": 0.00046, "epss_percentile": 0.14176}, "CVE-2010-2060": {"epss_score": 0.01003, "epss_percentile": 0.76512}, "CVE-2010-2061": {"epss_score": 0.00061, "epss_percentile": 0.19308}, "CVE-2010-2062": {"epss_score": 0.02991, "epss_percentile": 0.86144}, "CVE-2010-2063": {"epss_score": 0.75398, "epss_percentile": 0.98842}, "CVE-2010-2064": {"epss_score": 0.00072, "epss_percentile": 0.22302}, "CVE-2010-2065": {"epss_score": 0.04787, "epss_percentile": 0.89144}, "CVE-2010-2066": {"epss_score": 0.00095, "epss_percentile": 0.27181}, "CVE-2010-2067": {"epss_score": 0.028, "epss_percentile": 0.85695}, "CVE-2010-2068": {"epss_score": 0.08537, "epss_percentile": 0.92109}, "CVE-2010-2070": {"epss_score": 0.00093, "epss_percentile": 0.26662}, "CVE-2010-2071": {"epss_score": 0.00061, "epss_percentile": 0.19279}, "CVE-2010-2072": {"epss_score": 0.00065, "epss_percentile": 0.20481}, "CVE-2010-2073": {"epss_score": 0.00932, "epss_percentile": 0.75622}, "CVE-2010-2074": {"epss_score": 0.01841, "epss_percentile": 0.82497}, "CVE-2010-2075": {"epss_score": 0.86221, "epss_percentile": 0.99374}, "CVE-2010-2076": {"epss_score": 0.11954, "epss_percentile": 0.93525}, "CVE-2010-2078": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2010-2079": {"epss_score": 0.00207, "epss_percentile": 0.43199}, "CVE-2010-2080": {"epss_score": 0.00215, "epss_percentile": 0.44109}, "CVE-2010-2082": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2010-2083": {"epss_score": 0.07347, "epss_percentile": 0.91423}, "CVE-2010-2084": {"epss_score": 0.06397, "epss_percentile": 0.90723}, "CVE-2010-2085": {"epss_score": 0.11862, "epss_percentile": 0.93499}, "CVE-2010-2086": {"epss_score": 0.02948, "epss_percentile": 0.86049}, "CVE-2010-2087": {"epss_score": 0.0025, "epss_percentile": 0.48107}, "CVE-2010-2088": {"epss_score": 0.11862, "epss_percentile": 0.93499}, "CVE-2010-2089": {"epss_score": 0.11241, "epss_percentile": 0.93276}, "CVE-2010-2090": {"epss_score": 0.01342, "epss_percentile": 0.79598}, "CVE-2010-2091": {"epss_score": 0.04459, "epss_percentile": 0.88717}, "CVE-2010-2092": {"epss_score": 0.00139, "epss_percentile": 0.34661}, "CVE-2010-2093": {"epss_score": 0.00417, "epss_percentile": 0.61247}, "CVE-2010-2094": {"epss_score": 0.03086, "epss_percentile": 0.86384}, "CVE-2010-2095": {"epss_score": 0.00466, "epss_percentile": 0.63789}, "CVE-2010-2096": {"epss_score": 0.00141, "epss_percentile": 0.34952}, "CVE-2010-2097": {"epss_score": 0.00571, "epss_percentile": 0.67997}, "CVE-2010-2098": {"epss_score": 0.00517, "epss_percentile": 0.66081}, "CVE-2010-2099": {"epss_score": 0.00838, "epss_percentile": 0.74175}, "CVE-2010-2100": {"epss_score": 0.00918, "epss_percentile": 0.7545}, "CVE-2010-2101": {"epss_score": 0.0112, "epss_percentile": 0.77764}, "CVE-2010-2102": {"epss_score": 0.12616, "epss_percentile": 0.9373}, "CVE-2010-2103": {"epss_score": 0.21768, "epss_percentile": 0.95558}, "CVE-2010-2104": {"epss_score": 0.00177, "epss_percentile": 0.39515}, "CVE-2010-2105": {"epss_score": 0.00349, "epss_percentile": 0.56915}, "CVE-2010-2106": {"epss_score": 0.00373, "epss_percentile": 0.58521}, "CVE-2010-2107": {"epss_score": 0.00349, "epss_percentile": 0.56915}, "CVE-2010-2108": {"epss_score": 0.00207, "epss_percentile": 0.43117}, "CVE-2010-2109": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2010-2110": {"epss_score": 0.00243, "epss_percentile": 0.47469}, "CVE-2010-2111": {"epss_score": 0.00122, "epss_percentile": 0.32051}, "CVE-2010-2112": {"epss_score": 0.00162, "epss_percentile": 0.37652}, "CVE-2010-2113": {"epss_score": 0.00106, "epss_percentile": 0.29492}, "CVE-2010-2114": {"epss_score": 0.00155, "epss_percentile": 0.36815}, "CVE-2010-2115": {"epss_score": 0.81786, "epss_percentile": 0.99156}, "CVE-2010-2116": {"epss_score": 0.00546, "epss_percentile": 0.67223}, "CVE-2010-2117": {"epss_score": 0.0072, "epss_percentile": 0.71955}, "CVE-2010-2118": {"epss_score": 0.16282, "epss_percentile": 0.94611}, "CVE-2010-2119": {"epss_score": 0.16282, "epss_percentile": 0.94611}, "CVE-2010-2120": {"epss_score": 0.0078, "epss_percentile": 0.73163}, "CVE-2010-2121": {"epss_score": 0.0078, "epss_percentile": 0.73163}, "CVE-2010-2122": {"epss_score": 0.01818, "epss_percentile": 0.82402}, "CVE-2010-2123": {"epss_score": 0.00267, "epss_percentile": 0.49982}, "CVE-2010-2124": {"epss_score": 0.00721, "epss_percentile": 0.71987}, "CVE-2010-2125": {"epss_score": 0.00228, "epss_percentile": 0.45482}, "CVE-2010-2126": {"epss_score": 0.01858, "epss_percentile": 0.82581}, "CVE-2010-2127": {"epss_score": 0.02103, "epss_percentile": 0.83614}, "CVE-2010-2128": {"epss_score": 0.03923, "epss_percentile": 0.87957}, "CVE-2010-2129": {"epss_score": 0.03989, "epss_percentile": 0.88067}, "CVE-2010-2130": {"epss_score": 0.09337, "epss_percentile": 0.92504}, "CVE-2010-2131": {"epss_score": 0.00526, "epss_percentile": 0.66424}, "CVE-2010-2132": {"epss_score": 0.00715, "epss_percentile": 0.71831}, "CVE-2010-2133": {"epss_score": 0.00721, "epss_percentile": 0.71987}, "CVE-2010-2134": {"epss_score": 0.00631, "epss_percentile": 0.69733}, "CVE-2010-2135": {"epss_score": 0.00721, "epss_percentile": 0.71987}, "CVE-2010-2136": {"epss_score": 0.00261, "epss_percentile": 0.493}, "CVE-2010-2137": {"epss_score": 0.02103, "epss_percentile": 0.83614}, "CVE-2010-2138": {"epss_score": 0.02296, "epss_percentile": 0.84295}, "CVE-2010-2139": {"epss_score": 0.00458, "epss_percentile": 0.63428}, "CVE-2010-2140": {"epss_score": 0.00458, "epss_percentile": 0.63428}, "CVE-2010-2141": {"epss_score": 0.00784, "epss_percentile": 0.73236}, "CVE-2010-2142": {"epss_score": 0.00945, "epss_percentile": 0.75798}, "CVE-2010-2143": {"epss_score": 0.04794, "epss_percentile": 0.89153}, "CVE-2010-2144": {"epss_score": 0.0569, "epss_percentile": 0.90123}, "CVE-2010-2145": {"epss_score": 0.00623, "epss_percentile": 0.69538}, "CVE-2010-2146": {"epss_score": 0.01319, "epss_percentile": 0.79436}, "CVE-2010-2147": {"epss_score": 0.00591, "epss_percentile": 0.68599}, "CVE-2010-2148": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2010-2149": {"epss_score": 0.00365, "epss_percentile": 0.57966}, "CVE-2010-2150": {"epss_score": 0.00396, "epss_percentile": 0.59901}, "CVE-2010-2151": {"epss_score": 0.00119, "epss_percentile": 0.31594}, "CVE-2010-2152": {"epss_score": 0.151, "epss_percentile": 0.94362}, "CVE-2010-2153": {"epss_score": 0.03929, "epss_percentile": 0.87971}, "CVE-2010-2154": {"epss_score": 0.00333, "epss_percentile": 0.55644}, "CVE-2010-2155": {"epss_score": 0.00523, "epss_percentile": 0.66292}, "CVE-2010-2156": {"epss_score": 0.8675, "epss_percentile": 0.99394}, "CVE-2010-2157": {"epss_score": 0.0007, "epss_percentile": 0.21752}, "CVE-2010-2158": {"epss_score": 0.00167, "epss_percentile": 0.38364}, "CVE-2010-2159": {"epss_score": 0.0501, "epss_percentile": 0.89389}, "CVE-2010-2160": {"epss_score": 0.00663, "epss_percentile": 0.70612}, "CVE-2010-2161": {"epss_score": 0.00493, "epss_percentile": 0.6503}, "CVE-2010-2162": {"epss_score": 0.00663, "epss_percentile": 0.70612}, "CVE-2010-2163": {"epss_score": 0.00493, "epss_percentile": 0.6503}, "CVE-2010-2164": {"epss_score": 0.00663, "epss_percentile": 0.70612}, "CVE-2010-2165": {"epss_score": 0.00901, "epss_percentile": 0.75178}, "CVE-2010-2166": {"epss_score": 0.00901, "epss_percentile": 0.75178}, "CVE-2010-2167": {"epss_score": 0.00819, "epss_percentile": 0.73872}, "CVE-2010-2168": {"epss_score": 0.13538, "epss_percentile": 0.93991}, "CVE-2010-2169": {"epss_score": 0.00491, "epss_percentile": 0.64944}, "CVE-2010-2170": {"epss_score": 0.01642, "epss_percentile": 0.81509}, "CVE-2010-2171": {"epss_score": 0.00663, "epss_percentile": 0.70612}, "CVE-2010-2172": {"epss_score": 0.08266, "epss_percentile": 0.91958}, "CVE-2010-2173": {"epss_score": 0.00901, "epss_percentile": 0.75178}, "CVE-2010-2174": {"epss_score": 0.00901, "epss_percentile": 0.75178}, "CVE-2010-2175": {"epss_score": 0.00901, "epss_percentile": 0.75178}, "CVE-2010-2176": {"epss_score": 0.00901, "epss_percentile": 0.75178}, "CVE-2010-2177": {"epss_score": 0.00901, "epss_percentile": 0.75178}, "CVE-2010-2178": {"epss_score": 0.00901, "epss_percentile": 0.75178}, "CVE-2010-2179": {"epss_score": 0.22192, "epss_percentile": 0.95607}, "CVE-2010-2180": {"epss_score": 0.00901, "epss_percentile": 0.75178}, "CVE-2010-2181": {"epss_score": 0.01642, "epss_percentile": 0.81509}, "CVE-2010-2182": {"epss_score": 0.00901, "epss_percentile": 0.75178}, "CVE-2010-2183": {"epss_score": 0.01642, "epss_percentile": 0.81509}, "CVE-2010-2184": {"epss_score": 0.00901, "epss_percentile": 0.75178}, "CVE-2010-2185": {"epss_score": 0.00823, "epss_percentile": 0.73924}, "CVE-2010-2186": {"epss_score": 0.00899, "epss_percentile": 0.75154}, "CVE-2010-2187": {"epss_score": 0.00895, "epss_percentile": 0.75106}, "CVE-2010-2188": {"epss_score": 0.01206, "epss_percentile": 0.78524}, "CVE-2010-2189": {"epss_score": 0.00929, "epss_percentile": 0.75589}, "CVE-2010-2190": {"epss_score": 0.0056, "epss_percentile": 0.67646}, "CVE-2010-2191": {"epss_score": 0.01257, "epss_percentile": 0.78951}, "CVE-2010-2192": {"epss_score": 0.00033, "epss_percentile": 0.09404}, "CVE-2010-2193": {"epss_score": 0.14097, "epss_percentile": 0.94132}, "CVE-2010-2195": {"epss_score": 0.00422, "epss_percentile": 0.61535}, "CVE-2010-2197": {"epss_score": 0.0043, "epss_percentile": 0.62018}, "CVE-2010-2198": {"epss_score": 0.00048, "epss_percentile": 0.15131}, "CVE-2010-2199": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-2201": {"epss_score": 0.13538, "epss_percentile": 0.93991}, "CVE-2010-2202": {"epss_score": 0.09617, "epss_percentile": 0.92625}, "CVE-2010-2203": {"epss_score": 0.03655, "epss_percentile": 0.87514}, "CVE-2010-2204": {"epss_score": 0.04595, "epss_percentile": 0.88897}, "CVE-2010-2205": {"epss_score": 0.07951, "epss_percentile": 0.91785}, "CVE-2010-2206": {"epss_score": 0.04429, "epss_percentile": 0.88677}, "CVE-2010-2207": {"epss_score": 0.09617, "epss_percentile": 0.92625}, "CVE-2010-2208": {"epss_score": 0.08271, "epss_percentile": 0.9196}, "CVE-2010-2209": {"epss_score": 0.09617, "epss_percentile": 0.92625}, "CVE-2010-2210": {"epss_score": 0.03517, "epss_percentile": 0.87275}, "CVE-2010-2211": {"epss_score": 0.09617, "epss_percentile": 0.92625}, "CVE-2010-2212": {"epss_score": 0.07992, "epss_percentile": 0.91811}, "CVE-2010-2213": {"epss_score": 0.01704, "epss_percentile": 0.81845}, "CVE-2010-2214": {"epss_score": 0.01087, "epss_percentile": 0.77428}, "CVE-2010-2215": {"epss_score": 0.01802, "epss_percentile": 0.82329}, "CVE-2010-2216": {"epss_score": 0.01261, "epss_percentile": 0.78975}, "CVE-2010-2217": {"epss_score": 0.05973, "epss_percentile": 0.90374}, "CVE-2010-2218": {"epss_score": 0.01042, "epss_percentile": 0.76971}, "CVE-2010-2219": {"epss_score": 0.01042, "epss_percentile": 0.76971}, "CVE-2010-2220": {"epss_score": 0.00994, "epss_percentile": 0.76424}, "CVE-2010-2221": {"epss_score": 0.06077, "epss_percentile": 0.90459}, "CVE-2010-2222": {"epss_score": 0.00436, "epss_percentile": 0.62458}, "CVE-2010-2223": {"epss_score": 0.00073, "epss_percentile": 0.22661}, "CVE-2010-2224": {"epss_score": 0.00068, "epss_percentile": 0.2136}, "CVE-2010-2225": {"epss_score": 0.02187, "epss_percentile": 0.83922}, "CVE-2010-2226": {"epss_score": 0.00108, "epss_percentile": 0.29891}, "CVE-2010-2227": {"epss_score": 0.74437, "epss_percentile": 0.988}, "CVE-2010-2228": {"epss_score": 0.0061, "epss_percentile": 0.69157}, "CVE-2010-2229": {"epss_score": 0.0061, "epss_percentile": 0.69157}, "CVE-2010-2230": {"epss_score": 0.00396, "epss_percentile": 0.59927}, "CVE-2010-2231": {"epss_score": 0.00536, "epss_percentile": 0.66885}, "CVE-2010-2232": {"epss_score": 0.01673, "epss_percentile": 0.81685}, "CVE-2010-2233": {"epss_score": 0.02374, "epss_percentile": 0.84538}, "CVE-2010-2234": {"epss_score": 0.00464, "epss_percentile": 0.63721}, "CVE-2010-2235": {"epss_score": 0.01839, "epss_percentile": 0.8249}, "CVE-2010-2236": {"epss_score": 0.02056, "epss_percentile": 0.83423}, "CVE-2010-2237": {"epss_score": 0.0007, "epss_percentile": 0.21807}, "CVE-2010-2238": {"epss_score": 0.0007, "epss_percentile": 0.21807}, "CVE-2010-2239": {"epss_score": 0.00072, "epss_percentile": 0.22301}, "CVE-2010-2240": {"epss_score": 0.00135, "epss_percentile": 0.34021}, "CVE-2010-2241": {"epss_score": 0.00047, "epss_percentile": 0.14836}, "CVE-2010-2242": {"epss_score": 0.00079, "epss_percentile": 0.23959}, "CVE-2010-2243": {"epss_score": 0.00788, "epss_percentile": 0.73344}, "CVE-2010-2244": {"epss_score": 0.01304, "epss_percentile": 0.79319}, "CVE-2010-2245": {"epss_score": 0.00302, "epss_percentile": 0.53083}, "CVE-2010-2246": {"epss_score": 0.0459, "epss_percentile": 0.88891}, "CVE-2010-2247": {"epss_score": 0.00468, "epss_percentile": 0.6391}, "CVE-2010-2248": {"epss_score": 0.02324, "epss_percentile": 0.8438}, "CVE-2010-2249": {"epss_score": 0.01567, "epss_percentile": 0.81073}, "CVE-2010-2250": {"epss_score": 0.00726, "epss_percentile": 0.72074}, "CVE-2010-2251": {"epss_score": 0.02416, "epss_percentile": 0.84687}, "CVE-2010-2252": {"epss_score": 0.0411, "epss_percentile": 0.88269}, "CVE-2010-2253": {"epss_score": 0.01125, "epss_percentile": 0.77805}, "CVE-2010-2254": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2010-2255": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-2256": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2010-2257": {"epss_score": 0.00279, "epss_percentile": 0.5095}, "CVE-2010-2258": {"epss_score": 0.00282, "epss_percentile": 0.51287}, "CVE-2010-2259": {"epss_score": 0.04029, "epss_percentile": 0.88147}, "CVE-2010-2260": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-2261": {"epss_score": 0.01689, "epss_percentile": 0.81771}, "CVE-2010-2262": {"epss_score": 0.00676, "epss_percentile": 0.70934}, "CVE-2010-2263": {"epss_score": 0.44217, "epss_percentile": 0.97425}, "CVE-2010-2264": {"epss_score": 0.00614, "epss_percentile": 0.69265}, "CVE-2010-2265": {"epss_score": 0.24813, "epss_percentile": 0.95957}, "CVE-2010-2266": {"epss_score": 0.07504, "epss_percentile": 0.91508}, "CVE-2010-2267": {"epss_score": 0.00295, "epss_percentile": 0.52503}, "CVE-2010-2268": {"epss_score": 0.00079, "epss_percentile": 0.23839}, "CVE-2010-2269": {"epss_score": 0.00159, "epss_percentile": 0.37404}, "CVE-2010-2270": {"epss_score": 0.00478, "epss_percentile": 0.64395}, "CVE-2010-2271": {"epss_score": 0.00482, "epss_percentile": 0.64529}, "CVE-2010-2272": {"epss_score": 0.0034, "epss_percentile": 0.56237}, "CVE-2010-2273": {"epss_score": 0.29352, "epss_percentile": 0.96435}, "CVE-2010-2274": {"epss_score": 0.00909, "epss_percentile": 0.753}, "CVE-2010-2275": {"epss_score": 0.16214, "epss_percentile": 0.94596}, "CVE-2010-2276": {"epss_score": 0.02639, "epss_percentile": 0.85298}, "CVE-2010-2277": {"epss_score": 0.00463, "epss_percentile": 0.63697}, "CVE-2010-2278": {"epss_score": 0.00688, "epss_percentile": 0.71198}, "CVE-2010-2279": {"epss_score": 0.00483, "epss_percentile": 0.64622}, "CVE-2010-2280": {"epss_score": 0.00246, "epss_percentile": 0.47784}, "CVE-2010-2281": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2010-2282": {"epss_score": 0.00076, "epss_percentile": 0.2309}, "CVE-2010-2283": {"epss_score": 0.01015, "epss_percentile": 0.76664}, "CVE-2010-2284": {"epss_score": 0.03044, "epss_percentile": 0.86279}, "CVE-2010-2285": {"epss_score": 0.00494, "epss_percentile": 0.65078}, "CVE-2010-2286": {"epss_score": 0.01015, "epss_percentile": 0.76664}, "CVE-2010-2287": {"epss_score": 0.03044, "epss_percentile": 0.86279}, "CVE-2010-2288": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-2289": {"epss_score": 0.00591, "epss_percentile": 0.68588}, "CVE-2010-2290": {"epss_score": 0.00666, "epss_percentile": 0.7068}, "CVE-2010-2291": {"epss_score": 0.00104, "epss_percentile": 0.29147}, "CVE-2010-2292": {"epss_score": 0.00161, "epss_percentile": 0.37541}, "CVE-2010-2293": {"epss_score": 0.00363, "epss_percentile": 0.57875}, "CVE-2010-2294": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2010-2295": {"epss_score": 0.01184, "epss_percentile": 0.7833}, "CVE-2010-2296": {"epss_score": 0.0039, "epss_percentile": 0.59549}, "CVE-2010-2297": {"epss_score": 0.07078, "epss_percentile": 0.91235}, "CVE-2010-2298": {"epss_score": 0.00435, "epss_percentile": 0.62358}, "CVE-2010-2299": {"epss_score": 0.05438, "epss_percentile": 0.89883}, "CVE-2010-2300": {"epss_score": 0.23377, "epss_percentile": 0.95771}, "CVE-2010-2301": {"epss_score": 0.00501, "epss_percentile": 0.65347}, "CVE-2010-2302": {"epss_score": 0.06106, "epss_percentile": 0.90484}, "CVE-2010-2305": {"epss_score": 0.06151, "epss_percentile": 0.90521}, "CVE-2010-2306": {"epss_score": 0.00403, "epss_percentile": 0.60319}, "CVE-2010-2307": {"epss_score": 0.0285, "epss_percentile": 0.85828}, "CVE-2010-2308": {"epss_score": 0.00083, "epss_percentile": 0.24711}, "CVE-2010-2309": {"epss_score": 0.86916, "epss_percentile": 0.99403}, "CVE-2010-2310": {"epss_score": 0.23068, "epss_percentile": 0.95728}, "CVE-2010-2311": {"epss_score": 0.07999, "epss_percentile": 0.91817}, "CVE-2010-2312": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-2313": {"epss_score": 0.05258, "epss_percentile": 0.89668}, "CVE-2010-2314": {"epss_score": 0.01983, "epss_percentile": 0.83148}, "CVE-2010-2315": {"epss_score": 0.00941, "epss_percentile": 0.75756}, "CVE-2010-2316": {"epss_score": 0.0025, "epss_percentile": 0.48091}, "CVE-2010-2317": {"epss_score": 0.00105, "epss_percentile": 0.29397}, "CVE-2010-2318": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-2319": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-2320": {"epss_score": 0.0062, "epss_percentile": 0.69453}, "CVE-2010-2321": {"epss_score": 0.33852, "epss_percentile": 0.9681}, "CVE-2010-2322": {"epss_score": 0.00745, "epss_percentile": 0.72526}, "CVE-2010-2323": {"epss_score": 0.00301, "epss_percentile": 0.53011}, "CVE-2010-2324": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2010-2325": {"epss_score": 0.00249, "epss_percentile": 0.48063}, "CVE-2010-2326": {"epss_score": 0.00487, "epss_percentile": 0.64802}, "CVE-2010-2327": {"epss_score": 0.00759, "epss_percentile": 0.72788}, "CVE-2010-2328": {"epss_score": 0.00527, "epss_percentile": 0.66445}, "CVE-2010-2329": {"epss_score": 0.10324, "epss_percentile": 0.92945}, "CVE-2010-2330": {"epss_score": 0.17558, "epss_percentile": 0.94867}, "CVE-2010-2331": {"epss_score": 0.07233, "epss_percentile": 0.91338}, "CVE-2010-2332": {"epss_score": 0.04586, "epss_percentile": 0.88886}, "CVE-2010-2333": {"epss_score": 0.76489, "epss_percentile": 0.98892}, "CVE-2010-2334": {"epss_score": 0.02168, "epss_percentile": 0.83859}, "CVE-2010-2335": {"epss_score": 0.00372, "epss_percentile": 0.58454}, "CVE-2010-2336": {"epss_score": 0.02034, "epss_percentile": 0.83345}, "CVE-2010-2337": {"epss_score": 0.00808, "epss_percentile": 0.73694}, "CVE-2010-2338": {"epss_score": 0.01743, "epss_percentile": 0.82057}, "CVE-2010-2339": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2010-2340": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2010-2341": {"epss_score": 0.01917, "epss_percentile": 0.82862}, "CVE-2010-2342": {"epss_score": 0.00233, "epss_percentile": 0.46022}, "CVE-2010-2343": {"epss_score": 0.75512, "epss_percentile": 0.98849}, "CVE-2010-2344": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2010-2345": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2010-2347": {"epss_score": 0.00341, "epss_percentile": 0.56327}, "CVE-2010-2348": {"epss_score": 0.06929, "epss_percentile": 0.91123}, "CVE-2010-2349": {"epss_score": 0.02486, "epss_percentile": 0.84885}, "CVE-2010-2350": {"epss_score": 0.01875, "epss_percentile": 0.82656}, "CVE-2010-2351": {"epss_score": 0.11314, "epss_percentile": 0.93303}, "CVE-2010-2352": {"epss_score": 0.00746, "epss_percentile": 0.72537}, "CVE-2010-2353": {"epss_score": 0.00683, "epss_percentile": 0.71088}, "CVE-2010-2354": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-2355": {"epss_score": 0.00195, "epss_percentile": 0.41654}, "CVE-2010-2356": {"epss_score": 0.01152, "epss_percentile": 0.78049}, "CVE-2010-2357": {"epss_score": 0.00145, "epss_percentile": 0.35456}, "CVE-2010-2358": {"epss_score": 0.03241, "epss_percentile": 0.86734}, "CVE-2010-2359": {"epss_score": 0.00916, "epss_percentile": 0.75423}, "CVE-2010-2360": {"epss_score": 0.04666, "epss_percentile": 0.8898}, "CVE-2010-2361": {"epss_score": 0.00349, "epss_percentile": 0.56871}, "CVE-2010-2362": {"epss_score": 0.00349, "epss_percentile": 0.56871}, "CVE-2010-2363": {"epss_score": 0.00272, "epss_percentile": 0.50394}, "CVE-2010-2364": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2010-2365": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2010-2366": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-2367": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2010-2368": {"epss_score": 0.00053, "epss_percentile": 0.1671}, "CVE-2010-2369": {"epss_score": 0.00058, "epss_percentile": 0.18521}, "CVE-2010-2370": {"epss_score": 0.1617, "epss_percentile": 0.94587}, "CVE-2010-2371": {"epss_score": 0.00068, "epss_percentile": 0.21349}, "CVE-2010-2372": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2010-2373": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2010-2374": {"epss_score": 0.00057, "epss_percentile": 0.18193}, "CVE-2010-2375": {"epss_score": 0.1617, "epss_percentile": 0.94587}, "CVE-2010-2376": {"epss_score": 0.00057, "epss_percentile": 0.18193}, "CVE-2010-2377": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2010-2378": {"epss_score": 0.00057, "epss_percentile": 0.18193}, "CVE-2010-2379": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2010-2380": {"epss_score": 0.00053, "epss_percentile": 0.17012}, "CVE-2010-2381": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2010-2382": {"epss_score": 0.00186, "epss_percentile": 0.40669}, "CVE-2010-2383": {"epss_score": 0.00186, "epss_percentile": 0.40669}, "CVE-2010-2384": {"epss_score": 0.00186, "epss_percentile": 0.40669}, "CVE-2010-2385": {"epss_score": 0.00253, "epss_percentile": 0.48481}, "CVE-2010-2386": {"epss_score": 0.00085, "epss_percentile": 0.25133}, "CVE-2010-2387": {"epss_score": 0.00091, "epss_percentile": 0.26403}, "CVE-2010-2388": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-2389": {"epss_score": 0.00107, "epss_percentile": 0.29746}, "CVE-2010-2390": {"epss_score": 0.01008, "epss_percentile": 0.76568}, "CVE-2010-2391": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-2392": {"epss_score": 0.00085, "epss_percentile": 0.25133}, "CVE-2010-2393": {"epss_score": 0.00058, "epss_percentile": 0.18472}, "CVE-2010-2394": {"epss_score": 0.00085, "epss_percentile": 0.25133}, "CVE-2010-2395": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-2396": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-2397": {"epss_score": 0.00052, "epss_percentile": 0.1638}, "CVE-2010-2398": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2010-2399": {"epss_score": 0.00058, "epss_percentile": 0.18472}, "CVE-2010-2400": {"epss_score": 0.00058, "epss_percentile": 0.18472}, "CVE-2010-2401": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2010-2402": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2010-2403": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2010-2404": {"epss_score": 0.00181, "epss_percentile": 0.40021}, "CVE-2010-2405": {"epss_score": 0.00429, "epss_percentile": 0.61962}, "CVE-2010-2406": {"epss_score": 0.00203, "epss_percentile": 0.42534}, "CVE-2010-2407": {"epss_score": 0.00309, "epss_percentile": 0.53696}, "CVE-2010-2408": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-2409": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-2410": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-2411": {"epss_score": 0.00265, "epss_percentile": 0.49829}, "CVE-2010-2412": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-2413": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-2414": {"epss_score": 0.00382, "epss_percentile": 0.59071}, "CVE-2010-2415": {"epss_score": 0.36531, "epss_percentile": 0.96985}, "CVE-2010-2416": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-2417": {"epss_score": 0.00181, "epss_percentile": 0.40021}, "CVE-2010-2418": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-2419": {"epss_score": 0.00265, "epss_percentile": 0.49829}, "CVE-2010-2420": {"epss_score": 0.01313, "epss_percentile": 0.79381}, "CVE-2010-2421": {"epss_score": 0.01134, "epss_percentile": 0.77888}, "CVE-2010-2422": {"epss_score": 0.00474, "epss_percentile": 0.64169}, "CVE-2010-2425": {"epss_score": 0.0053, "epss_percentile": 0.66641}, "CVE-2010-2426": {"epss_score": 0.31895, "epss_percentile": 0.96658}, "CVE-2010-2427": {"epss_score": 0.00047, "epss_percentile": 0.14849}, "CVE-2010-2428": {"epss_score": 0.00747, "epss_percentile": 0.7256}, "CVE-2010-2429": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2010-2431": {"epss_score": 0.0003, "epss_percentile": 0.08076}, "CVE-2010-2432": {"epss_score": 0.00829, "epss_percentile": 0.74011}, "CVE-2010-2433": {"epss_score": 0.01391, "epss_percentile": 0.79953}, "CVE-2010-2434": {"epss_score": 0.05333, "epss_percentile": 0.89739}, "CVE-2010-2435": {"epss_score": 0.03952, "epss_percentile": 0.88001}, "CVE-2010-2436": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2010-2437": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2010-2438": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2010-2439": {"epss_score": 0.0887, "epss_percentile": 0.92294}, "CVE-2010-2440": {"epss_score": 0.07689, "epss_percentile": 0.91628}, "CVE-2010-2441": {"epss_score": 0.00371, "epss_percentile": 0.58383}, "CVE-2010-2442": {"epss_score": 0.22486, "epss_percentile": 0.95643}, "CVE-2010-2443": {"epss_score": 0.02674, "epss_percentile": 0.85399}, "CVE-2010-2444": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2010-2445": {"epss_score": 0.01199, "epss_percentile": 0.78458}, "CVE-2010-2446": {"epss_score": 0.00776, "epss_percentile": 0.73094}, "CVE-2010-2447": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2010-2448": {"epss_score": 0.01247, "epss_percentile": 0.78861}, "CVE-2010-2449": {"epss_score": 0.00563, "epss_percentile": 0.67737}, "CVE-2010-2450": {"epss_score": 0.00163, "epss_percentile": 0.37858}, "CVE-2010-2451": {"epss_score": 0.02311, "epss_percentile": 0.84339}, "CVE-2010-2452": {"epss_score": 0.01018, "epss_percentile": 0.76705}, "CVE-2010-2453": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2010-2454": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2010-2455": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2010-2456": {"epss_score": 0.02088, "epss_percentile": 0.83554}, "CVE-2010-2457": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2010-2458": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2010-2459": {"epss_score": 0.00417, "epss_percentile": 0.6125}, "CVE-2010-2460": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-2461": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-2462": {"epss_score": 0.00362, "epss_percentile": 0.57768}, "CVE-2010-2463": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2010-2464": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2010-2465": {"epss_score": 0.02084, "epss_percentile": 0.83543}, "CVE-2010-2466": {"epss_score": 0.0085, "epss_percentile": 0.74386}, "CVE-2010-2467": {"epss_score": 0.00485, "epss_percentile": 0.64708}, "CVE-2010-2468": {"epss_score": 0.00406, "epss_percentile": 0.60544}, "CVE-2010-2469": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2010-2470": {"epss_score": 0.00043, "epss_percentile": 0.13217}, "CVE-2010-2471": {"epss_score": 0.0055, "epss_percentile": 0.67338}, "CVE-2010-2472": {"epss_score": 0.00586, "epss_percentile": 0.68433}, "CVE-2010-2473": {"epss_score": 0.00367, "epss_percentile": 0.58158}, "CVE-2010-2474": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2010-2476": {"epss_score": 0.00528, "epss_percentile": 0.66577}, "CVE-2010-2477": {"epss_score": 0.0052, "epss_percentile": 0.66214}, "CVE-2010-2478": {"epss_score": 0.00047, "epss_percentile": 0.14579}, "CVE-2010-2479": {"epss_score": 0.00467, "epss_percentile": 0.63861}, "CVE-2010-2480": {"epss_score": 0.00257, "epss_percentile": 0.48909}, "CVE-2010-2481": {"epss_score": 0.01608, "epss_percentile": 0.8131}, "CVE-2010-2482": {"epss_score": 0.18826, "epss_percentile": 0.95076}, "CVE-2010-2483": {"epss_score": 0.01269, "epss_percentile": 0.79044}, "CVE-2010-2484": {"epss_score": 0.00478, "epss_percentile": 0.64406}, "CVE-2010-2487": {"epss_score": 0.01289, "epss_percentile": 0.79213}, "CVE-2010-2488": {"epss_score": 0.01309, "epss_percentile": 0.79354}, "CVE-2010-2489": {"epss_score": 0.0007, "epss_percentile": 0.21835}, "CVE-2010-2490": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2010-2491": {"epss_score": 0.0061, "epss_percentile": 0.69157}, "CVE-2010-2492": {"epss_score": 0.00072, "epss_percentile": 0.22296}, "CVE-2010-2493": {"epss_score": 0.00108, "epss_percentile": 0.29824}, "CVE-2010-2494": {"epss_score": 0.04638, "epss_percentile": 0.8895}, "CVE-2010-2495": {"epss_score": 0.02308, "epss_percentile": 0.8433}, "CVE-2010-2496": {"epss_score": 0.00041, "epss_percentile": 0.12275}, "CVE-2010-2497": {"epss_score": 0.02089, "epss_percentile": 0.83561}, "CVE-2010-2498": {"epss_score": 0.02649, "epss_percentile": 0.8534}, "CVE-2010-2499": {"epss_score": 0.03379, "epss_percentile": 0.87027}, "CVE-2010-2500": {"epss_score": 0.02649, "epss_percentile": 0.8534}, "CVE-2010-2502": {"epss_score": 0.00255, "epss_percentile": 0.48673}, "CVE-2010-2503": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-2504": {"epss_score": 0.00366, "epss_percentile": 0.58066}, "CVE-2010-2505": {"epss_score": 0.0244, "epss_percentile": 0.84753}, "CVE-2010-2506": {"epss_score": 0.00162, "epss_percentile": 0.3773}, "CVE-2010-2507": {"epss_score": 0.0193, "epss_percentile": 0.82936}, "CVE-2010-2508": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-2509": {"epss_score": 0.00213, "epss_percentile": 0.43918}, "CVE-2010-2510": {"epss_score": 0.00112, "epss_percentile": 0.30409}, "CVE-2010-2511": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-2512": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2010-2513": {"epss_score": 0.00776, "epss_percentile": 0.73095}, "CVE-2010-2514": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-2515": {"epss_score": 0.00372, "epss_percentile": 0.58437}, "CVE-2010-2516": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-2517": {"epss_score": 0.0036, "epss_percentile": 0.57629}, "CVE-2010-2518": {"epss_score": 0.01173, "epss_percentile": 0.78235}, "CVE-2010-2519": {"epss_score": 0.0452, "epss_percentile": 0.88797}, "CVE-2010-2520": {"epss_score": 0.03154, "epss_percentile": 0.86511}, "CVE-2010-2521": {"epss_score": 0.01525, "epss_percentile": 0.80859}, "CVE-2010-2522": {"epss_score": 0.00064, "epss_percentile": 0.20163}, "CVE-2010-2523": {"epss_score": 0.02354, "epss_percentile": 0.84479}, "CVE-2010-2524": {"epss_score": 0.00086, "epss_percentile": 0.25388}, "CVE-2010-2525": {"epss_score": 0.00139, "epss_percentile": 0.34563}, "CVE-2010-2526": {"epss_score": 0.00087, "epss_percentile": 0.25459}, "CVE-2010-2527": {"epss_score": 0.02329, "epss_percentile": 0.84399}, "CVE-2010-2528": {"epss_score": 0.02081, "epss_percentile": 0.83532}, "CVE-2010-2529": {"epss_score": 0.00711, "epss_percentile": 0.71742}, "CVE-2010-2530": {"epss_score": 0.00042, "epss_percentile": 0.1256}, "CVE-2010-2531": {"epss_score": 0.0571, "epss_percentile": 0.9014}, "CVE-2010-2532": {"epss_score": 0.00117, "epss_percentile": 0.31369}, "CVE-2010-2534": {"epss_score": 0.04656, "epss_percentile": 0.88973}, "CVE-2010-2535": {"epss_score": 0.00019, "epss_percentile": 0.04076}, "CVE-2010-2536": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2010-2537": {"epss_score": 0.0009, "epss_percentile": 0.26145}, "CVE-2010-2538": {"epss_score": 0.00076, "epss_percentile": 0.23106}, "CVE-2010-2539": {"epss_score": 0.00063, "epss_percentile": 0.20064}, "CVE-2010-2540": {"epss_score": 0.01976, "epss_percentile": 0.83121}, "CVE-2010-2541": {"epss_score": 0.03207, "epss_percentile": 0.86637}, "CVE-2010-2542": {"epss_score": 0.02141, "epss_percentile": 0.8375}, "CVE-2010-2543": {"epss_score": 0.10513, "epss_percentile": 0.93015}, "CVE-2010-2544": {"epss_score": 0.06007, "epss_percentile": 0.90398}, "CVE-2010-2545": {"epss_score": 0.01797, "epss_percentile": 0.82308}, "CVE-2010-2546": {"epss_score": 0.06032, "epss_percentile": 0.90424}, "CVE-2010-2547": {"epss_score": 0.15103, "epss_percentile": 0.94363}, "CVE-2010-2548": {"epss_score": 0.00198, "epss_percentile": 0.42064}, "CVE-2010-2549": {"epss_score": 0.03812, "epss_percentile": 0.87763}, "CVE-2010-2550": {"epss_score": 0.7975, "epss_percentile": 0.99053}, "CVE-2010-2551": {"epss_score": 0.71086, "epss_percentile": 0.98652}, "CVE-2010-2552": {"epss_score": 0.68306, "epss_percentile": 0.98541}, "CVE-2010-2553": {"epss_score": 0.68437, "epss_percentile": 0.98548}, "CVE-2010-2554": {"epss_score": 0.03437, "epss_percentile": 0.87135}, "CVE-2010-2555": {"epss_score": 0.00765, "epss_percentile": 0.7292}, "CVE-2010-2556": {"epss_score": 0.52821, "epss_percentile": 0.97842}, "CVE-2010-2557": {"epss_score": 0.52821, "epss_percentile": 0.97842}, "CVE-2010-2558": {"epss_score": 0.20108, "epss_percentile": 0.95288}, "CVE-2010-2559": {"epss_score": 0.52821, "epss_percentile": 0.97842}, "CVE-2010-2560": {"epss_score": 0.53366, "epss_percentile": 0.97873}, "CVE-2010-2561": {"epss_score": 0.61291, "epss_percentile": 0.98243}, "CVE-2010-2562": {"epss_score": 0.56148, "epss_percentile": 0.9801}, "CVE-2010-2563": {"epss_score": 0.33809, "epss_percentile": 0.96805}, "CVE-2010-2564": {"epss_score": 0.54835, "epss_percentile": 0.97947}, "CVE-2010-2566": {"epss_score": 0.19156, "epss_percentile": 0.9514}, "CVE-2010-2567": {"epss_score": 0.18556, "epss_percentile": 0.95033}, "CVE-2010-2568": {"epss_score": 0.92789, "epss_percentile": 0.99749}, "CVE-2010-2569": {"epss_score": 0.60932, "epss_percentile": 0.98228}, "CVE-2010-2570": {"epss_score": 0.62128, "epss_percentile": 0.98282}, "CVE-2010-2571": {"epss_score": 0.61042, "epss_percentile": 0.98233}, "CVE-2010-2572": {"epss_score": 0.74724, "epss_percentile": 0.98815}, "CVE-2010-2573": {"epss_score": 0.6115, "epss_percentile": 0.98236}, "CVE-2010-2574": {"epss_score": 0.00421, "epss_percentile": 0.61524}, "CVE-2010-2575": {"epss_score": 0.05146, "epss_percentile": 0.89543}, "CVE-2010-2576": {"epss_score": 0.01869, "epss_percentile": 0.82626}, "CVE-2010-2577": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2010-2578": {"epss_score": 0.01226, "epss_percentile": 0.78688}, "CVE-2010-2579": {"epss_score": 0.00237, "epss_percentile": 0.46652}, "CVE-2010-2580": {"epss_score": 0.02175, "epss_percentile": 0.83881}, "CVE-2010-2581": {"epss_score": 0.06926, "epss_percentile": 0.9112}, "CVE-2010-2582": {"epss_score": 0.09881, "epss_percentile": 0.92751}, "CVE-2010-2583": {"epss_score": 0.07763, "epss_percentile": 0.91666}, "CVE-2010-2584": {"epss_score": 0.00493, "epss_percentile": 0.65054}, "CVE-2010-2585": {"epss_score": 0.09819, "epss_percentile": 0.92716}, "CVE-2010-2586": {"epss_score": 0.11189, "epss_percentile": 0.93259}, "CVE-2010-2587": {"epss_score": 0.07019, "epss_percentile": 0.9119}, "CVE-2010-2588": {"epss_score": 0.05153, "epss_percentile": 0.8955}, "CVE-2010-2589": {"epss_score": 0.06242, "epss_percentile": 0.90597}, "CVE-2010-2590": {"epss_score": 0.78972, "epss_percentile": 0.99013}, "CVE-2010-2594": {"epss_score": 0.00177, "epss_percentile": 0.39618}, "CVE-2010-2595": {"epss_score": 0.01634, "epss_percentile": 0.81467}, "CVE-2010-2596": {"epss_score": 0.00999, "epss_percentile": 0.76483}, "CVE-2010-2597": {"epss_score": 0.03306, "epss_percentile": 0.86877}, "CVE-2010-2598": {"epss_score": 0.00584, "epss_percentile": 0.68375}, "CVE-2010-2599": {"epss_score": 0.01252, "epss_percentile": 0.78902}, "CVE-2010-2600": {"epss_score": 0.03135, "epss_percentile": 0.86479}, "CVE-2010-2601": {"epss_score": 0.0353, "epss_percentile": 0.87299}, "CVE-2010-2602": {"epss_score": 0.02089, "epss_percentile": 0.8356}, "CVE-2010-2603": {"epss_score": 0.00062, "epss_percentile": 0.19786}, "CVE-2010-2604": {"epss_score": 0.07381, "epss_percentile": 0.91444}, "CVE-2010-2609": {"epss_score": 0.01471, "epss_percentile": 0.80499}, "CVE-2010-2610": {"epss_score": 0.0031, "epss_percentile": 0.53781}, "CVE-2010-2611": {"epss_score": 0.00438, "epss_percentile": 0.62557}, "CVE-2010-2612": {"epss_score": 0.00116, "epss_percentile": 0.31185}, "CVE-2010-2613": {"epss_score": 0.01308, "epss_percentile": 0.7935}, "CVE-2010-2614": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2010-2615": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2010-2616": {"epss_score": 0.00319, "epss_percentile": 0.5448}, "CVE-2010-2617": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2010-2618": {"epss_score": 0.01719, "epss_percentile": 0.81924}, "CVE-2010-2619": {"epss_score": 0.00094, "epss_percentile": 0.26981}, "CVE-2010-2620": {"epss_score": 0.55672, "epss_percentile": 0.97988}, "CVE-2010-2621": {"epss_score": 0.12, "epss_percentile": 0.93542}, "CVE-2010-2622": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-2623": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2010-2624": {"epss_score": 0.00216, "epss_percentile": 0.44216}, "CVE-2010-2625": {"epss_score": 0.0044, "epss_percentile": 0.62628}, "CVE-2010-2626": {"epss_score": 0.23354, "epss_percentile": 0.95769}, "CVE-2010-2627": {"epss_score": 0.00914, "epss_percentile": 0.75387}, "CVE-2010-2628": {"epss_score": 0.05728, "epss_percentile": 0.90158}, "CVE-2010-2629": {"epss_score": 0.0033, "epss_percentile": 0.55482}, "CVE-2010-2630": {"epss_score": 0.03939, "epss_percentile": 0.87987}, "CVE-2010-2631": {"epss_score": 0.05374, "epss_percentile": 0.89797}, "CVE-2010-2632": {"epss_score": 0.05543, "epss_percentile": 0.8998}, "CVE-2010-2633": {"epss_score": 0.01543, "epss_percentile": 0.80958}, "CVE-2010-2634": {"epss_score": 0.00403, "epss_percentile": 0.60368}, "CVE-2010-2635": {"epss_score": 0.0022, "epss_percentile": 0.44546}, "CVE-2010-2636": {"epss_score": 0.00202, "epss_percentile": 0.42481}, "CVE-2010-2637": {"epss_score": 0.00281, "epss_percentile": 0.51113}, "CVE-2010-2638": {"epss_score": 0.00332, "epss_percentile": 0.55554}, "CVE-2010-2639": {"epss_score": 0.00286, "epss_percentile": 0.5177}, "CVE-2010-2640": {"epss_score": 0.08161, "epss_percentile": 0.91911}, "CVE-2010-2641": {"epss_score": 0.08161, "epss_percentile": 0.91911}, "CVE-2010-2642": {"epss_score": 0.12564, "epss_percentile": 0.93716}, "CVE-2010-2643": {"epss_score": 0.07841, "epss_percentile": 0.91713}, "CVE-2010-2644": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2010-2645": {"epss_score": 0.00389, "epss_percentile": 0.59495}, "CVE-2010-2646": {"epss_score": 0.00224, "epss_percentile": 0.45046}, "CVE-2010-2647": {"epss_score": 0.01313, "epss_percentile": 0.79384}, "CVE-2010-2648": {"epss_score": 0.02136, "epss_percentile": 0.83727}, "CVE-2010-2649": {"epss_score": 0.00426, "epss_percentile": 0.61743}, "CVE-2010-2650": {"epss_score": 0.00171, "epss_percentile": 0.3881}, "CVE-2010-2651": {"epss_score": 0.00755, "epss_percentile": 0.72723}, "CVE-2010-2652": {"epss_score": 0.00159, "epss_percentile": 0.37412}, "CVE-2010-2653": {"epss_score": 0.00031, "epss_percentile": 0.08539}, "CVE-2010-2654": {"epss_score": 0.03436, "epss_percentile": 0.87134}, "CVE-2010-2655": {"epss_score": 0.19091, "epss_percentile": 0.95127}, "CVE-2010-2656": {"epss_score": 0.17218, "epss_percentile": 0.94801}, "CVE-2010-2657": {"epss_score": 0.00511, "epss_percentile": 0.65837}, "CVE-2010-2658": {"epss_score": 0.00695, "epss_percentile": 0.71378}, "CVE-2010-2659": {"epss_score": 0.00657, "epss_percentile": 0.70473}, "CVE-2010-2660": {"epss_score": 0.01003, "epss_percentile": 0.76521}, "CVE-2010-2661": {"epss_score": 0.01003, "epss_percentile": 0.76521}, "CVE-2010-2662": {"epss_score": 0.00246, "epss_percentile": 0.4774}, "CVE-2010-2663": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2010-2664": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2010-2665": {"epss_score": 0.00682, "epss_percentile": 0.71086}, "CVE-2010-2666": {"epss_score": 0.03156, "epss_percentile": 0.86514}, "CVE-2010-2667": {"epss_score": 0.01049, "epss_percentile": 0.77059}, "CVE-2010-2668": {"epss_score": 0.0043, "epss_percentile": 0.62033}, "CVE-2010-2669": {"epss_score": 0.0209, "epss_percentile": 0.83565}, "CVE-2010-2670": {"epss_score": 0.00132, "epss_percentile": 0.33605}, "CVE-2010-2671": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2010-2672": {"epss_score": 0.00836, "epss_percentile": 0.74149}, "CVE-2010-2673": {"epss_score": 0.00409, "epss_percentile": 0.60764}, "CVE-2010-2674": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-2675": {"epss_score": 0.00193, "epss_percentile": 0.41445}, "CVE-2010-2676": {"epss_score": 0.03845, "epss_percentile": 0.87841}, "CVE-2010-2677": {"epss_score": 0.03911, "epss_percentile": 0.87935}, "CVE-2010-2678": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2010-2679": {"epss_score": 0.00023, "epss_percentile": 0.05501}, "CVE-2010-2680": {"epss_score": 0.0202, "epss_percentile": 0.83292}, "CVE-2010-2681": {"epss_score": 0.00258, "epss_percentile": 0.48962}, "CVE-2010-2682": {"epss_score": 0.00584, "epss_percentile": 0.68393}, "CVE-2010-2683": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-2684": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-2685": {"epss_score": 0.02382, "epss_percentile": 0.84566}, "CVE-2010-2686": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-2687": {"epss_score": 0.0288, "epss_percentile": 0.85895}, "CVE-2010-2688": {"epss_score": 0.01723, "epss_percentile": 0.81941}, "CVE-2010-2689": {"epss_score": 0.00335, "epss_percentile": 0.55837}, "CVE-2010-2690": {"epss_score": 0.00279, "epss_percentile": 0.5095}, "CVE-2010-2691": {"epss_score": 0.02542, "epss_percentile": 0.85053}, "CVE-2010-2692": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2010-2693": {"epss_score": 0.00169, "epss_percentile": 0.38551}, "CVE-2010-2694": {"epss_score": 0.00438, "epss_percentile": 0.62571}, "CVE-2010-2695": {"epss_score": 0.00836, "epss_percentile": 0.74145}, "CVE-2010-2696": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2010-2697": {"epss_score": 0.00161, "epss_percentile": 0.37527}, "CVE-2010-2698": {"epss_score": 0.00139, "epss_percentile": 0.34633}, "CVE-2010-2699": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-2700": {"epss_score": 0.00138, "epss_percentile": 0.34408}, "CVE-2010-2701": {"epss_score": 0.07953, "epss_percentile": 0.91786}, "CVE-2010-2702": {"epss_score": 0.05344, "epss_percentile": 0.89765}, "CVE-2010-2703": {"epss_score": 0.79615, "epss_percentile": 0.99049}, "CVE-2010-2704": {"epss_score": 0.21933, "epss_percentile": 0.95574}, "CVE-2010-2705": {"epss_score": 0.00294, "epss_percentile": 0.52369}, "CVE-2010-2706": {"epss_score": 0.00415, "epss_percentile": 0.61116}, "CVE-2010-2707": {"epss_score": 0.00506, "epss_percentile": 0.65629}, "CVE-2010-2708": {"epss_score": 0.00415, "epss_percentile": 0.61116}, "CVE-2010-2709": {"epss_score": 0.8373, "epss_percentile": 0.9926}, "CVE-2010-2710": {"epss_score": 0.08717, "epss_percentile": 0.92224}, "CVE-2010-2711": {"epss_score": 0.00848, "epss_percentile": 0.74359}, "CVE-2010-2712": {"epss_score": 0.00047, "epss_percentile": 0.14579}, "CVE-2010-2713": {"epss_score": 0.00873, "epss_percentile": 0.74744}, "CVE-2010-2714": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2010-2715": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2010-2716": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-2717": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-2718": {"epss_score": 0.00545, "epss_percentile": 0.67158}, "CVE-2010-2719": {"epss_score": 0.002, "epss_percentile": 0.42201}, "CVE-2010-2720": {"epss_score": 0.002, "epss_percentile": 0.42201}, "CVE-2010-2721": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-2722": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-2723": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-2724": {"epss_score": 0.00212, "epss_percentile": 0.43818}, "CVE-2010-2725": {"epss_score": 0.015, "epss_percentile": 0.80711}, "CVE-2010-2728": {"epss_score": 0.28373, "epss_percentile": 0.96347}, "CVE-2010-2729": {"epss_score": 0.78208, "epss_percentile": 0.98974}, "CVE-2010-2730": {"epss_score": 0.08077, "epss_percentile": 0.91869}, "CVE-2010-2731": {"epss_score": 0.66776, "epss_percentile": 0.98478}, "CVE-2010-2732": {"epss_score": 0.32258, "epss_percentile": 0.96683}, "CVE-2010-2733": {"epss_score": 0.47875, "epss_percentile": 0.97606}, "CVE-2010-2734": {"epss_score": 0.47875, "epss_percentile": 0.97606}, "CVE-2010-2738": {"epss_score": 0.15844, "epss_percentile": 0.94518}, "CVE-2010-2739": {"epss_score": 0.00892, "epss_percentile": 0.75061}, "CVE-2010-2740": {"epss_score": 0.21241, "epss_percentile": 0.95483}, "CVE-2010-2741": {"epss_score": 0.07689, "epss_percentile": 0.91628}, "CVE-2010-2742": {"epss_score": 0.55735, "epss_percentile": 0.97992}, "CVE-2010-2743": {"epss_score": 0.05551, "epss_percentile": 0.89986}, "CVE-2010-2744": {"epss_score": 0.00757, "epss_percentile": 0.72754}, "CVE-2010-2745": {"epss_score": 0.59689, "epss_percentile": 0.98175}, "CVE-2010-2746": {"epss_score": 0.73718, "epss_percentile": 0.98769}, "CVE-2010-2747": {"epss_score": 0.60216, "epss_percentile": 0.98198}, "CVE-2010-2748": {"epss_score": 0.54346, "epss_percentile": 0.97922}, "CVE-2010-2750": {"epss_score": 0.57317, "epss_percentile": 0.98058}, "CVE-2010-2751": {"epss_score": 0.00254, "epss_percentile": 0.48557}, "CVE-2010-2752": {"epss_score": 0.0868, "epss_percentile": 0.92197}, "CVE-2010-2753": {"epss_score": 0.04086, "epss_percentile": 0.88227}, "CVE-2010-2754": {"epss_score": 0.00262, "epss_percentile": 0.49351}, "CVE-2010-2755": {"epss_score": 0.10163, "epss_percentile": 0.92871}, "CVE-2010-2756": {"epss_score": 0.00838, "epss_percentile": 0.74178}, "CVE-2010-2757": {"epss_score": 0.01236, "epss_percentile": 0.78769}, "CVE-2010-2758": {"epss_score": 0.00723, "epss_percentile": 0.72018}, "CVE-2010-2759": {"epss_score": 0.01641, "epss_percentile": 0.81504}, "CVE-2010-2760": {"epss_score": 0.04467, "epss_percentile": 0.88731}, "CVE-2010-2761": {"epss_score": 0.02718, "epss_percentile": 0.85512}, "CVE-2010-2762": {"epss_score": 0.0174, "epss_percentile": 0.82042}, "CVE-2010-2763": {"epss_score": 0.00528, "epss_percentile": 0.66568}, "CVE-2010-2764": {"epss_score": 0.01176, "epss_percentile": 0.78275}, "CVE-2010-2765": {"epss_score": 0.04021, "epss_percentile": 0.88132}, "CVE-2010-2766": {"epss_score": 0.05221, "epss_percentile": 0.89626}, "CVE-2010-2767": {"epss_score": 0.0476, "epss_percentile": 0.89118}, "CVE-2010-2768": {"epss_score": 0.01543, "epss_percentile": 0.80954}, "CVE-2010-2769": {"epss_score": 0.01308, "epss_percentile": 0.79347}, "CVE-2010-2770": {"epss_score": 0.03933, "epss_percentile": 0.87978}, "CVE-2010-2771": {"epss_score": 0.06723, "epss_percentile": 0.90969}, "CVE-2010-2772": {"epss_score": 0.00306, "epss_percentile": 0.53416}, "CVE-2010-2777": {"epss_score": 0.21021, "epss_percentile": 0.95452}, "CVE-2010-2778": {"epss_score": 0.0128, "epss_percentile": 0.79143}, "CVE-2010-2779": {"epss_score": 0.0128, "epss_percentile": 0.79143}, "CVE-2010-2783": {"epss_score": 0.00336, "epss_percentile": 0.56005}, "CVE-2010-2784": {"epss_score": 0.00048, "epss_percentile": 0.15191}, "CVE-2010-2785": {"epss_score": 0.11266, "epss_percentile": 0.93286}, "CVE-2010-2786": {"epss_score": 0.00507, "epss_percentile": 0.65661}, "CVE-2010-2787": {"epss_score": 0.00551, "epss_percentile": 0.67353}, "CVE-2010-2788": {"epss_score": 0.00678, "epss_percentile": 0.70984}, "CVE-2010-2789": {"epss_score": 0.00533, "epss_percentile": 0.66776}, "CVE-2010-2790": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2010-2791": {"epss_score": 0.02076, "epss_percentile": 0.83507}, "CVE-2010-2792": {"epss_score": 0.00049, "epss_percentile": 0.15321}, "CVE-2010-2793": {"epss_score": 0.00229, "epss_percentile": 0.45613}, "CVE-2010-2794": {"epss_score": 0.00031, "epss_percentile": 0.08517}, "CVE-2010-2795": {"epss_score": 0.00583, "epss_percentile": 0.68352}, "CVE-2010-2796": {"epss_score": 0.00743, "epss_percentile": 0.72476}, "CVE-2010-2797": {"epss_score": 0.00378, "epss_percentile": 0.58798}, "CVE-2010-2798": {"epss_score": 0.00053, "epss_percentile": 0.16681}, "CVE-2010-2799": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-2800": {"epss_score": 0.01203, "epss_percentile": 0.78499}, "CVE-2010-2801": {"epss_score": 0.04956, "epss_percentile": 0.89329}, "CVE-2010-2802": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2010-2803": {"epss_score": 0.00082, "epss_percentile": 0.24437}, "CVE-2010-2805": {"epss_score": 0.05634, "epss_percentile": 0.90072}, "CVE-2010-2806": {"epss_score": 0.09383, "epss_percentile": 0.92526}, "CVE-2010-2807": {"epss_score": 0.05194, "epss_percentile": 0.89598}, "CVE-2010-2808": {"epss_score": 0.07802, "epss_percentile": 0.91688}, "CVE-2010-2809": {"epss_score": 0.05768, "epss_percentile": 0.9019}, "CVE-2010-2810": {"epss_score": 0.02376, "epss_percentile": 0.84544}, "CVE-2010-2811": {"epss_score": 0.00334, "epss_percentile": 0.55729}, "CVE-2010-2812": {"epss_score": 0.02346, "epss_percentile": 0.84454}, "CVE-2010-2813": {"epss_score": 0.05297, "epss_percentile": 0.89703}, "CVE-2010-2814": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-2815": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-2816": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-2817": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-2818": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2010-2819": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2820": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2010-2821": {"epss_score": 0.00347, "epss_percentile": 0.5679}, "CVE-2010-2822": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2823": {"epss_score": 0.00153, "epss_percentile": 0.36632}, "CVE-2010-2824": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2825": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2826": {"epss_score": 0.00334, "epss_percentile": 0.55725}, "CVE-2010-2827": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2828": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2829": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2830": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2010-2831": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2832": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2833": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2834": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2010-2835": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2010-2836": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2837": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2838": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2839": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2840": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2010-2841": {"epss_score": 0.00115, "epss_percentile": 0.30952}, "CVE-2010-2842": {"epss_score": 0.00153, "epss_percentile": 0.36637}, "CVE-2010-2843": {"epss_score": 0.00153, "epss_percentile": 0.36637}, "CVE-2010-2844": {"epss_score": 0.0209, "epss_percentile": 0.83565}, "CVE-2010-2845": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-2846": {"epss_score": 0.01792, "epss_percentile": 0.82286}, "CVE-2010-2847": {"epss_score": 0.00374, "epss_percentile": 0.58559}, "CVE-2010-2848": {"epss_score": 0.04087, "epss_percentile": 0.88228}, "CVE-2010-2849": {"epss_score": 0.00656, "epss_percentile": 0.70439}, "CVE-2010-2850": {"epss_score": 0.08387, "epss_percentile": 0.92022}, "CVE-2010-2851": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2010-2852": {"epss_score": 0.00446, "epss_percentile": 0.62934}, "CVE-2010-2853": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-2854": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-2855": {"epss_score": 0.00342, "epss_percentile": 0.56371}, "CVE-2010-2856": {"epss_score": 0.01013, "epss_percentile": 0.76632}, "CVE-2010-2857": {"epss_score": 0.00997, "epss_percentile": 0.76457}, "CVE-2010-2858": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2010-2859": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2010-2860": {"epss_score": 0.09897, "epss_percentile": 0.9276}, "CVE-2010-2861": {"epss_score": 0.94233, "epss_percentile": 0.99922}, "CVE-2010-2862": {"epss_score": 0.37574, "epss_percentile": 0.97058}, "CVE-2010-2863": {"epss_score": 0.09538, "epss_percentile": 0.92589}, "CVE-2010-2864": {"epss_score": 0.07967, "epss_percentile": 0.91797}, "CVE-2010-2865": {"epss_score": 0.01068, "epss_percentile": 0.77243}, "CVE-2010-2866": {"epss_score": 0.29481, "epss_percentile": 0.96447}, "CVE-2010-2867": {"epss_score": 0.06423, "epss_percentile": 0.90752}, "CVE-2010-2868": {"epss_score": 0.07967, "epss_percentile": 0.91797}, "CVE-2010-2869": {"epss_score": 0.07967, "epss_percentile": 0.91797}, "CVE-2010-2870": {"epss_score": 0.06553, "epss_percentile": 0.90845}, "CVE-2010-2871": {"epss_score": 0.11462, "epss_percentile": 0.93373}, "CVE-2010-2872": {"epss_score": 0.11046, "epss_percentile": 0.932}, "CVE-2010-2873": {"epss_score": 0.11046, "epss_percentile": 0.932}, "CVE-2010-2874": {"epss_score": 0.10341, "epss_percentile": 0.92949}, "CVE-2010-2875": {"epss_score": 0.11905, "epss_percentile": 0.9351}, "CVE-2010-2876": {"epss_score": 0.11046, "epss_percentile": 0.932}, "CVE-2010-2877": {"epss_score": 0.13674, "epss_percentile": 0.94032}, "CVE-2010-2878": {"epss_score": 0.13674, "epss_percentile": 0.94032}, "CVE-2010-2879": {"epss_score": 0.14425, "epss_percentile": 0.94209}, "CVE-2010-2880": {"epss_score": 0.08873, "epss_percentile": 0.92296}, "CVE-2010-2881": {"epss_score": 0.08873, "epss_percentile": 0.92296}, "CVE-2010-2882": {"epss_score": 0.08873, "epss_percentile": 0.92296}, "CVE-2010-2883": {"epss_score": 0.92181, "epss_percentile": 0.99697}, "CVE-2010-2884": {"epss_score": 0.39683, "epss_percentile": 0.97175}, "CVE-2010-2885": {"epss_score": 0.00621, "epss_percentile": 0.69488}, "CVE-2010-2886": {"epss_score": 0.00785, "epss_percentile": 0.73254}, "CVE-2010-2887": {"epss_score": 0.03295, "epss_percentile": 0.86847}, "CVE-2010-2888": {"epss_score": 0.09275, "epss_percentile": 0.92479}, "CVE-2010-2889": {"epss_score": 0.02953, "epss_percentile": 0.86057}, "CVE-2010-2890": {"epss_score": 0.0373, "epss_percentile": 0.8764}, "CVE-2010-2891": {"epss_score": 0.3265, "epss_percentile": 0.96714}, "CVE-2010-2892": {"epss_score": 0.06163, "epss_percentile": 0.90527}, "CVE-2010-2896": {"epss_score": 0.00195, "epss_percentile": 0.41709}, "CVE-2010-2897": {"epss_score": 0.00402, "epss_percentile": 0.60294}, "CVE-2010-2898": {"epss_score": 0.00224, "epss_percentile": 0.45046}, "CVE-2010-2899": {"epss_score": 0.00356, "epss_percentile": 0.57327}, "CVE-2010-2900": {"epss_score": 0.00224, "epss_percentile": 0.45046}, "CVE-2010-2901": {"epss_score": 0.01235, "epss_percentile": 0.78767}, "CVE-2010-2902": {"epss_score": 0.00823, "epss_percentile": 0.73932}, "CVE-2010-2903": {"epss_score": 0.00174, "epss_percentile": 0.39171}, "CVE-2010-2904": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2010-2905": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2010-2906": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-2907": {"epss_score": 0.00314, "epss_percentile": 0.54085}, "CVE-2010-2908": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2010-2909": {"epss_score": 0.00522, "epss_percentile": 0.66253}, "CVE-2010-2910": {"epss_score": 0.00319, "epss_percentile": 0.5448}, "CVE-2010-2911": {"epss_score": 0.00556, "epss_percentile": 0.67528}, "CVE-2010-2912": {"epss_score": 0.00399, "epss_percentile": 0.60095}, "CVE-2010-2913": {"epss_score": 0.00056, "epss_percentile": 0.17864}, "CVE-2010-2914": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2010-2915": {"epss_score": 0.00319, "epss_percentile": 0.5448}, "CVE-2010-2916": {"epss_score": 0.00319, "epss_percentile": 0.5448}, "CVE-2010-2917": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2010-2918": {"epss_score": 0.01604, "epss_percentile": 0.81281}, "CVE-2010-2919": {"epss_score": 0.00319, "epss_percentile": 0.5448}, "CVE-2010-2920": {"epss_score": 0.03584, "epss_percentile": 0.8739}, "CVE-2010-2921": {"epss_score": 0.00319, "epss_percentile": 0.5448}, "CVE-2010-2922": {"epss_score": 0.00844, "epss_percentile": 0.74271}, "CVE-2010-2923": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-2924": {"epss_score": 0.01262, "epss_percentile": 0.78985}, "CVE-2010-2925": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2010-2926": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2010-2927": {"epss_score": 0.01237, "epss_percentile": 0.78781}, "CVE-2010-2928": {"epss_score": 0.0006, "epss_percentile": 0.19108}, "CVE-2010-2929": {"epss_score": 0.00059, "epss_percentile": 0.18852}, "CVE-2010-2930": {"epss_score": 0.00048, "epss_percentile": 0.1501}, "CVE-2010-2931": {"epss_score": 0.07417, "epss_percentile": 0.91461}, "CVE-2010-2932": {"epss_score": 0.29442, "epss_percentile": 0.96443}, "CVE-2010-2933": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-2934": {"epss_score": 0.01922, "epss_percentile": 0.82904}, "CVE-2010-2935": {"epss_score": 0.07486, "epss_percentile": 0.91498}, "CVE-2010-2936": {"epss_score": 0.08202, "epss_percentile": 0.91927}, "CVE-2010-2937": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2010-2938": {"epss_score": 0.00131, "epss_percentile": 0.33414}, "CVE-2010-2939": {"epss_score": 0.10272, "epss_percentile": 0.92921}, "CVE-2010-2940": {"epss_score": 0.00237, "epss_percentile": 0.46462}, "CVE-2010-2941": {"epss_score": 0.26536, "epss_percentile": 0.96154}, "CVE-2010-2942": {"epss_score": 0.00062, "epss_percentile": 0.19784}, "CVE-2010-2943": {"epss_score": 0.03818, "epss_percentile": 0.87771}, "CVE-2010-2944": {"epss_score": 0.00539, "epss_percentile": 0.66977}, "CVE-2010-2945": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2010-2946": {"epss_score": 0.00036, "epss_percentile": 0.10257}, "CVE-2010-2947": {"epss_score": 0.09197, "epss_percentile": 0.92443}, "CVE-2010-2948": {"epss_score": 0.06995, "epss_percentile": 0.91171}, "CVE-2010-2949": {"epss_score": 0.04638, "epss_percentile": 0.8895}, "CVE-2010-2950": {"epss_score": 0.00673, "epss_percentile": 0.70835}, "CVE-2010-2951": {"epss_score": 0.55183, "epss_percentile": 0.97965}, "CVE-2010-2952": {"epss_score": 0.01206, "epss_percentile": 0.78519}, "CVE-2010-2953": {"epss_score": 0.00108, "epss_percentile": 0.29764}, "CVE-2010-2954": {"epss_score": 0.00127, "epss_percentile": 0.32898}, "CVE-2010-2955": {"epss_score": 0.00095, "epss_percentile": 0.27219}, "CVE-2010-2956": {"epss_score": 0.00078, "epss_percentile": 0.2375}, "CVE-2010-2957": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-2958": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2010-2959": {"epss_score": 0.00285, "epss_percentile": 0.5165}, "CVE-2010-2960": {"epss_score": 0.001, "epss_percentile": 0.28515}, "CVE-2010-2961": {"epss_score": 0.00073, "epss_percentile": 0.22502}, "CVE-2010-2962": {"epss_score": 0.00116, "epss_percentile": 0.31088}, "CVE-2010-2963": {"epss_score": 0.00106, "epss_percentile": 0.294}, "CVE-2010-2965": {"epss_score": 0.91095, "epss_percentile": 0.9962}, "CVE-2010-2966": {"epss_score": 0.00411, "epss_percentile": 0.60888}, "CVE-2010-2967": {"epss_score": 0.0156, "epss_percentile": 0.81039}, "CVE-2010-2968": {"epss_score": 0.00278, "epss_percentile": 0.50849}, "CVE-2010-2969": {"epss_score": 0.00598, "epss_percentile": 0.68768}, "CVE-2010-2970": {"epss_score": 0.00598, "epss_percentile": 0.68768}, "CVE-2010-2971": {"epss_score": 0.01098, "epss_percentile": 0.77541}, "CVE-2010-2973": {"epss_score": 0.00136, "epss_percentile": 0.34189}, "CVE-2010-2974": {"epss_score": 0.11282, "epss_percentile": 0.93291}, "CVE-2010-2975": {"epss_score": 0.00147, "epss_percentile": 0.35662}, "CVE-2010-2976": {"epss_score": 0.01376, "epss_percentile": 0.79839}, "CVE-2010-2977": {"epss_score": 0.00403, "epss_percentile": 0.60339}, "CVE-2010-2978": {"epss_score": 0.00163, "epss_percentile": 0.37759}, "CVE-2010-2979": {"epss_score": 0.0071, "epss_percentile": 0.71723}, "CVE-2010-2980": {"epss_score": 0.0071, "epss_percentile": 0.71723}, "CVE-2010-2981": {"epss_score": 0.00665, "epss_percentile": 0.70653}, "CVE-2010-2982": {"epss_score": 0.00364, "epss_percentile": 0.57945}, "CVE-2010-2983": {"epss_score": 0.0071, "epss_percentile": 0.71723}, "CVE-2010-2984": {"epss_score": 0.00302, "epss_percentile": 0.53138}, "CVE-2010-2985": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2010-2986": {"epss_score": 0.0034, "epss_percentile": 0.56236}, "CVE-2010-2987": {"epss_score": 0.00296, "epss_percentile": 0.52563}, "CVE-2010-2988": {"epss_score": 0.00296, "epss_percentile": 0.52563}, "CVE-2010-2989": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2010-2990": {"epss_score": 0.05518, "epss_percentile": 0.89954}, "CVE-2010-2991": {"epss_score": 0.04874, "epss_percentile": 0.89237}, "CVE-2010-2992": {"epss_score": 0.01195, "epss_percentile": 0.78429}, "CVE-2010-2993": {"epss_score": 0.00926, "epss_percentile": 0.75553}, "CVE-2010-2994": {"epss_score": 0.00791, "epss_percentile": 0.7338}, "CVE-2010-2995": {"epss_score": 0.05091, "epss_percentile": 0.89483}, "CVE-2010-2996": {"epss_score": 0.07308, "epss_percentile": 0.91398}, "CVE-2010-2997": {"epss_score": 0.0373, "epss_percentile": 0.8764}, "CVE-2010-2998": {"epss_score": 0.0163, "epss_percentile": 0.81441}, "CVE-2010-2999": {"epss_score": 0.0247, "epss_percentile": 0.84845}, "CVE-2010-3000": {"epss_score": 0.35756, "epss_percentile": 0.96931}, "CVE-2010-3001": {"epss_score": 0.00842, "epss_percentile": 0.74238}, "CVE-2010-3002": {"epss_score": 0.00842, "epss_percentile": 0.74238}, "CVE-2010-3003": {"epss_score": 0.00395, "epss_percentile": 0.59805}, "CVE-2010-3004": {"epss_score": 0.05349, "epss_percentile": 0.89772}, "CVE-2010-3005": {"epss_score": 0.00051, "epss_percentile": 0.16315}, "CVE-2010-3006": {"epss_score": 0.01365, "epss_percentile": 0.79778}, "CVE-2010-3007": {"epss_score": 0.2984, "epss_percentile": 0.9648}, "CVE-2010-3008": {"epss_score": 0.00059, "epss_percentile": 0.18722}, "CVE-2010-3009": {"epss_score": 0.00366, "epss_percentile": 0.58095}, "CVE-2010-3010": {"epss_score": 0.00595, "epss_percentile": 0.68681}, "CVE-2010-3011": {"epss_score": 0.00601, "epss_percentile": 0.68853}, "CVE-2010-3012": {"epss_score": 0.0076, "epss_percentile": 0.72816}, "CVE-2010-3013": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2010-3014": {"epss_score": 0.00063, "epss_percentile": 0.19939}, "CVE-2010-3015": {"epss_score": 0.00152, "epss_percentile": 0.36464}, "CVE-2010-3017": {"epss_score": 0.00075, "epss_percentile": 0.23071}, "CVE-2010-3018": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2010-3019": {"epss_score": 0.03533, "epss_percentile": 0.87308}, "CVE-2010-3020": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2010-3021": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2010-3022": {"epss_score": 0.00359, "epss_percentile": 0.57609}, "CVE-2010-3023": {"epss_score": 0.13263, "epss_percentile": 0.93917}, "CVE-2010-3024": {"epss_score": 0.02697, "epss_percentile": 0.85446}, "CVE-2010-3025": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2010-3026": {"epss_score": 0.00675, "epss_percentile": 0.70897}, "CVE-2010-3027": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2010-3028": {"epss_score": 0.00053, "epss_percentile": 0.16725}, "CVE-2010-3029": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2010-3030": {"epss_score": 0.00079, "epss_percentile": 0.23852}, "CVE-2010-3031": {"epss_score": 0.06333, "epss_percentile": 0.90676}, "CVE-2010-3032": {"epss_score": 0.25557, "epss_percentile": 0.96043}, "CVE-2010-3033": {"epss_score": 0.00153, "epss_percentile": 0.36637}, "CVE-2010-3034": {"epss_score": 0.0016, "epss_percentile": 0.37452}, "CVE-2010-3035": {"epss_score": 0.03262, "epss_percentile": 0.86773}, "CVE-2010-3036": {"epss_score": 0.28398, "epss_percentile": 0.9635}, "CVE-2010-3037": {"epss_score": 0.02295, "epss_percentile": 0.84292}, "CVE-2010-3038": {"epss_score": 0.01734, "epss_percentile": 0.82002}, "CVE-2010-3039": {"epss_score": 0.02623, "epss_percentile": 0.85258}, "CVE-2010-3040": {"epss_score": 0.25557, "epss_percentile": 0.96043}, "CVE-2010-3041": {"epss_score": 0.10944, "epss_percentile": 0.93168}, "CVE-2010-3042": {"epss_score": 0.03101, "epss_percentile": 0.86409}, "CVE-2010-3043": {"epss_score": 0.01846, "epss_percentile": 0.82512}, "CVE-2010-3044": {"epss_score": 0.10944, "epss_percentile": 0.93168}, "CVE-2010-3048": {"epss_score": 0.00655, "epss_percentile": 0.70422}, "CVE-2010-3049": {"epss_score": 0.00058, "epss_percentile": 0.18477}, "CVE-2010-3050": {"epss_score": 0.00487, "epss_percentile": 0.64809}, "CVE-2010-3053": {"epss_score": 0.01701, "epss_percentile": 0.81834}, "CVE-2010-3054": {"epss_score": 0.03893, "epss_percentile": 0.87911}, "CVE-2010-3055": {"epss_score": 0.01717, "epss_percentile": 0.81916}, "CVE-2010-3056": {"epss_score": 0.00761, "epss_percentile": 0.72831}, "CVE-2010-3058": {"epss_score": 0.02431, "epss_percentile": 0.84727}, "CVE-2010-3059": {"epss_score": 0.00827, "epss_percentile": 0.73986}, "CVE-2010-3060": {"epss_score": 0.00885, "epss_percentile": 0.74935}, "CVE-2010-3061": {"epss_score": 0.00988, "epss_percentile": 0.76357}, "CVE-2010-3062": {"epss_score": 0.00843, "epss_percentile": 0.74257}, "CVE-2010-3063": {"epss_score": 0.00498, "epss_percentile": 0.65218}, "CVE-2010-3064": {"epss_score": 0.01089, "epss_percentile": 0.77441}, "CVE-2010-3065": {"epss_score": 0.00533, "epss_percentile": 0.66775}, "CVE-2010-3066": {"epss_score": 0.00131, "epss_percentile": 0.33414}, "CVE-2010-3067": {"epss_score": 0.00151, "epss_percentile": 0.36341}, "CVE-2010-3069": {"epss_score": 0.16564, "epss_percentile": 0.94692}, "CVE-2010-3070": {"epss_score": 0.12119, "epss_percentile": 0.9357}, "CVE-2010-3071": {"epss_score": 0.0188, "epss_percentile": 0.82689}, "CVE-2010-3072": {"epss_score": 0.72511, "epss_percentile": 0.98713}, "CVE-2010-3073": {"epss_score": 0.00159, "epss_percentile": 0.37401}, "CVE-2010-3074": {"epss_score": 0.00072, "epss_percentile": 0.2233}, "CVE-2010-3075": {"epss_score": 0.01004, "epss_percentile": 0.76528}, "CVE-2010-3076": {"epss_score": 0.00444, "epss_percentile": 0.62813}, "CVE-2010-3077": {"epss_score": 0.00737, "epss_percentile": 0.72326}, "CVE-2010-3078": {"epss_score": 0.00083, "epss_percentile": 0.24749}, "CVE-2010-3079": {"epss_score": 0.00122, "epss_percentile": 0.32077}, "CVE-2010-3080": {"epss_score": 0.00047, "epss_percentile": 0.14911}, "CVE-2010-3081": {"epss_score": 0.0407, "epss_percentile": 0.88204}, "CVE-2010-3082": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2010-3083": {"epss_score": 0.01785, "epss_percentile": 0.82255}, "CVE-2010-3084": {"epss_score": 0.00091, "epss_percentile": 0.26201}, "CVE-2010-3085": {"epss_score": 0.00854, "epss_percentile": 0.74456}, "CVE-2010-3086": {"epss_score": 0.00127, "epss_percentile": 0.32916}, "CVE-2010-3087": {"epss_score": 0.01787, "epss_percentile": 0.8226}, "CVE-2010-3088": {"epss_score": 0.00728, "epss_percentile": 0.72104}, "CVE-2010-3089": {"epss_score": 0.00393, "epss_percentile": 0.59739}, "CVE-2010-3091": {"epss_score": 0.00633, "epss_percentile": 0.69758}, "CVE-2010-3092": {"epss_score": 0.00173, "epss_percentile": 0.39104}, "CVE-2010-3093": {"epss_score": 0.00249, "epss_percentile": 0.48007}, "CVE-2010-3094": {"epss_score": 0.00218, "epss_percentile": 0.44416}, "CVE-2010-3095": {"epss_score": 0.00069, "epss_percentile": 0.21569}, "CVE-2010-3096": {"epss_score": 0.00173, "epss_percentile": 0.39107}, "CVE-2010-3097": {"epss_score": 0.00175, "epss_percentile": 0.39295}, "CVE-2010-3098": {"epss_score": 0.00175, "epss_percentile": 0.39295}, "CVE-2010-3099": {"epss_score": 0.00173, "epss_percentile": 0.39107}, "CVE-2010-3100": {"epss_score": 0.00175, "epss_percentile": 0.39295}, "CVE-2010-3101": {"epss_score": 0.00175, "epss_percentile": 0.39295}, "CVE-2010-3102": {"epss_score": 0.00147, "epss_percentile": 0.35787}, "CVE-2010-3103": {"epss_score": 0.00147, "epss_percentile": 0.35787}, "CVE-2010-3104": {"epss_score": 0.00147, "epss_percentile": 0.35787}, "CVE-2010-3105": {"epss_score": 0.05235, "epss_percentile": 0.89646}, "CVE-2010-3106": {"epss_score": 0.5577, "epss_percentile": 0.97995}, "CVE-2010-3107": {"epss_score": 0.03391, "epss_percentile": 0.87052}, "CVE-2010-3108": {"epss_score": 0.07529, "epss_percentile": 0.91519}, "CVE-2010-3109": {"epss_score": 0.07529, "epss_percentile": 0.91519}, "CVE-2010-3110": {"epss_score": 0.00043, "epss_percentile": 0.13239}, "CVE-2010-3111": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2010-3112": {"epss_score": 0.00343, "epss_percentile": 0.56425}, "CVE-2010-3113": {"epss_score": 0.02295, "epss_percentile": 0.84294}, "CVE-2010-3114": {"epss_score": 0.00464, "epss_percentile": 0.6372}, "CVE-2010-3115": {"epss_score": 0.01527, "epss_percentile": 0.80866}, "CVE-2010-3116": {"epss_score": 0.12275, "epss_percentile": 0.93619}, "CVE-2010-3117": {"epss_score": 0.01008, "epss_percentile": 0.76566}, "CVE-2010-3118": {"epss_score": 0.00227, "epss_percentile": 0.45379}, "CVE-2010-3119": {"epss_score": 0.00352, "epss_percentile": 0.57117}, "CVE-2010-3120": {"epss_score": 0.00779, "epss_percentile": 0.73151}, "CVE-2010-3121": {"epss_score": 0.04846, "epss_percentile": 0.8921}, "CVE-2010-3122": {"epss_score": 0.00681, "epss_percentile": 0.71045}, "CVE-2010-3124": {"epss_score": 0.08392, "epss_percentile": 0.92025}, "CVE-2010-3125": {"epss_score": 0.03067, "epss_percentile": 0.86339}, "CVE-2010-3126": {"epss_score": 0.01696, "epss_percentile": 0.8181}, "CVE-2010-3127": {"epss_score": 0.05329, "epss_percentile": 0.89738}, "CVE-2010-3128": {"epss_score": 0.02214, "epss_percentile": 0.84025}, "CVE-2010-3129": {"epss_score": 0.0178, "epss_percentile": 0.82237}, "CVE-2010-3130": {"epss_score": 0.05714, "epss_percentile": 0.90144}, "CVE-2010-3131": {"epss_score": 0.11238, "epss_percentile": 0.93275}, "CVE-2010-3132": {"epss_score": 0.03166, "epss_percentile": 0.8654}, "CVE-2010-3133": {"epss_score": 0.00455, "epss_percentile": 0.633}, "CVE-2010-3134": {"epss_score": 0.01469, "epss_percentile": 0.80488}, "CVE-2010-3135": {"epss_score": 0.03695, "epss_percentile": 0.87584}, "CVE-2010-3136": {"epss_score": 0.01409, "epss_percentile": 0.80077}, "CVE-2010-3137": {"epss_score": 0.04205, "epss_percentile": 0.88394}, "CVE-2010-3138": {"epss_score": 0.44265, "epss_percentile": 0.97427}, "CVE-2010-3139": {"epss_score": 0.17052, "epss_percentile": 0.94765}, "CVE-2010-3140": {"epss_score": 0.07297, "epss_percentile": 0.9139}, "CVE-2010-3141": {"epss_score": 0.0493, "epss_percentile": 0.89297}, "CVE-2010-3142": {"epss_score": 0.10332, "epss_percentile": 0.92948}, "CVE-2010-3143": {"epss_score": 0.08821, "epss_percentile": 0.9227}, "CVE-2010-3144": {"epss_score": 0.12279, "epss_percentile": 0.93621}, "CVE-2010-3145": {"epss_score": 0.13593, "epss_percentile": 0.94005}, "CVE-2010-3146": {"epss_score": 0.28594, "epss_percentile": 0.9637}, "CVE-2010-3147": {"epss_score": 0.25085, "epss_percentile": 0.95983}, "CVE-2010-3148": {"epss_score": 0.26525, "epss_percentile": 0.96153}, "CVE-2010-3149": {"epss_score": 0.04168, "epss_percentile": 0.88343}, "CVE-2010-3150": {"epss_score": 0.03485, "epss_percentile": 0.87225}, "CVE-2010-3151": {"epss_score": 0.03485, "epss_percentile": 0.87225}, "CVE-2010-3152": {"epss_score": 0.04626, "epss_percentile": 0.88938}, "CVE-2010-3153": {"epss_score": 0.03112, "epss_percentile": 0.86429}, "CVE-2010-3154": {"epss_score": 0.03342, "epss_percentile": 0.86944}, "CVE-2010-3155": {"epss_score": 0.03342, "epss_percentile": 0.86944}, "CVE-2010-3156": {"epss_score": 0.0006, "epss_percentile": 0.18986}, "CVE-2010-3157": {"epss_score": 0.00847, "epss_percentile": 0.74348}, "CVE-2010-3158": {"epss_score": 0.00053, "epss_percentile": 0.1671}, "CVE-2010-3159": {"epss_score": 0.00069, "epss_percentile": 0.21486}, "CVE-2010-3160": {"epss_score": 0.00056, "epss_percentile": 0.17771}, "CVE-2010-3161": {"epss_score": 0.00058, "epss_percentile": 0.18521}, "CVE-2010-3162": {"epss_score": 0.00058, "epss_percentile": 0.18521}, "CVE-2010-3163": {"epss_score": 0.00053, "epss_percentile": 0.1671}, "CVE-2010-3164": {"epss_score": 0.00053, "epss_percentile": 0.1671}, "CVE-2010-3165": {"epss_score": 0.0006, "epss_percentile": 0.18986}, "CVE-2010-3166": {"epss_score": 0.05962, "epss_percentile": 0.90367}, "CVE-2010-3167": {"epss_score": 0.05398, "epss_percentile": 0.8983}, "CVE-2010-3168": {"epss_score": 0.05398, "epss_percentile": 0.8983}, "CVE-2010-3169": {"epss_score": 0.03233, "epss_percentile": 0.867}, "CVE-2010-3170": {"epss_score": 0.01158, "epss_percentile": 0.78119}, "CVE-2010-3171": {"epss_score": 0.07921, "epss_percentile": 0.91763}, "CVE-2010-3172": {"epss_score": 0.00733, "epss_percentile": 0.72213}, "CVE-2010-3173": {"epss_score": 0.02346, "epss_percentile": 0.84451}, "CVE-2010-3174": {"epss_score": 0.03093, "epss_percentile": 0.864}, "CVE-2010-3175": {"epss_score": 0.02907, "epss_percentile": 0.85965}, "CVE-2010-3176": {"epss_score": 0.03853, "epss_percentile": 0.87853}, "CVE-2010-3177": {"epss_score": 0.00722, "epss_percentile": 0.7199}, "CVE-2010-3178": {"epss_score": 0.00855, "epss_percentile": 0.74471}, "CVE-2010-3179": {"epss_score": 0.27546, "epss_percentile": 0.96257}, "CVE-2010-3180": {"epss_score": 0.0543, "epss_percentile": 0.89875}, "CVE-2010-3181": {"epss_score": 0.00056, "epss_percentile": 0.17771}, "CVE-2010-3182": {"epss_score": 0.00078, "epss_percentile": 0.2375}, "CVE-2010-3183": {"epss_score": 0.08267, "epss_percentile": 0.91959}, "CVE-2010-3186": {"epss_score": 0.01418, "epss_percentile": 0.80159}, "CVE-2010-3187": {"epss_score": 0.774, "epss_percentile": 0.98935}, "CVE-2010-3188": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-3189": {"epss_score": 0.7604, "epss_percentile": 0.98874}, "CVE-2010-3190": {"epss_score": 0.46742, "epss_percentile": 0.97556}, "CVE-2010-3191": {"epss_score": 0.06236, "epss_percentile": 0.9059}, "CVE-2010-3192": {"epss_score": 0.00786, "epss_percentile": 0.73299}, "CVE-2010-3193": {"epss_score": 0.01996, "epss_percentile": 0.83194}, "CVE-2010-3194": {"epss_score": 0.0094, "epss_percentile": 0.75727}, "CVE-2010-3195": {"epss_score": 0.01042, "epss_percentile": 0.76974}, "CVE-2010-3196": {"epss_score": 0.0038, "epss_percentile": 0.58951}, "CVE-2010-3197": {"epss_score": 0.00275, "epss_percentile": 0.50693}, "CVE-2010-3198": {"epss_score": 0.0086, "epss_percentile": 0.74538}, "CVE-2010-3199": {"epss_score": 0.02719, "epss_percentile": 0.85515}, "CVE-2010-3200": {"epss_score": 0.09936, "epss_percentile": 0.92781}, "CVE-2010-3201": {"epss_score": 0.01884, "epss_percentile": 0.82703}, "CVE-2010-3202": {"epss_score": 0.01152, "epss_percentile": 0.78049}, "CVE-2010-3203": {"epss_score": 0.01836, "epss_percentile": 0.82469}, "CVE-2010-3204": {"epss_score": 0.01395, "epss_percentile": 0.79974}, "CVE-2010-3205": {"epss_score": 0.0094, "epss_percentile": 0.75742}, "CVE-2010-3206": {"epss_score": 0.0094, "epss_percentile": 0.75742}, "CVE-2010-3207": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-3208": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-3209": {"epss_score": 0.0094, "epss_percentile": 0.75742}, "CVE-2010-3210": {"epss_score": 0.0094, "epss_percentile": 0.75742}, "CVE-2010-3211": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-3212": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2010-3213": {"epss_score": 0.01777, "epss_percentile": 0.82224}, "CVE-2010-3214": {"epss_score": 0.61262, "epss_percentile": 0.98242}, "CVE-2010-3215": {"epss_score": 0.56564, "epss_percentile": 0.98029}, "CVE-2010-3216": {"epss_score": 0.57317, "epss_percentile": 0.98058}, "CVE-2010-3217": {"epss_score": 0.65657, "epss_percentile": 0.98431}, "CVE-2010-3218": {"epss_score": 0.5872, "epss_percentile": 0.98133}, "CVE-2010-3219": {"epss_score": 0.56564, "epss_percentile": 0.98029}, "CVE-2010-3220": {"epss_score": 0.54346, "epss_percentile": 0.97922}, "CVE-2010-3221": {"epss_score": 0.54346, "epss_percentile": 0.97922}, "CVE-2010-3222": {"epss_score": 0.00884, "epss_percentile": 0.74926}, "CVE-2010-3223": {"epss_score": 0.01141, "epss_percentile": 0.77968}, "CVE-2010-3225": {"epss_score": 0.44148, "epss_percentile": 0.97421}, "CVE-2010-3227": {"epss_score": 0.3549, "epss_percentile": 0.96915}, "CVE-2010-3228": {"epss_score": 0.57703, "epss_percentile": 0.9808}, "CVE-2010-3229": {"epss_score": 0.64341, "epss_percentile": 0.98374}, "CVE-2010-3230": {"epss_score": 0.68646, "epss_percentile": 0.98558}, "CVE-2010-3231": {"epss_score": 0.60735, "epss_percentile": 0.98217}, "CVE-2010-3232": {"epss_score": 0.572, "epss_percentile": 0.98053}, "CVE-2010-3233": {"epss_score": 0.63007, "epss_percentile": 0.98317}, "CVE-2010-3234": {"epss_score": 0.58806, "epss_percentile": 0.98138}, "CVE-2010-3235": {"epss_score": 0.56267, "epss_percentile": 0.98016}, "CVE-2010-3236": {"epss_score": 0.56267, "epss_percentile": 0.98016}, "CVE-2010-3237": {"epss_score": 0.56267, "epss_percentile": 0.98016}, "CVE-2010-3238": {"epss_score": 0.56267, "epss_percentile": 0.98016}, "CVE-2010-3239": {"epss_score": 0.58685, "epss_percentile": 0.98131}, "CVE-2010-3240": {"epss_score": 0.56267, "epss_percentile": 0.98016}, "CVE-2010-3241": {"epss_score": 0.50897, "epss_percentile": 0.97755}, "CVE-2010-3242": {"epss_score": 0.572, "epss_percentile": 0.98053}, "CVE-2010-3243": {"epss_score": 0.38075, "epss_percentile": 0.97084}, "CVE-2010-3244": {"epss_score": 0.00155, "epss_percentile": 0.36877}, "CVE-2010-3245": {"epss_score": 0.00206, "epss_percentile": 0.43048}, "CVE-2010-3246": {"epss_score": 0.00123, "epss_percentile": 0.32299}, "CVE-2010-3247": {"epss_score": 0.0022, "epss_percentile": 0.44588}, "CVE-2010-3248": {"epss_score": 0.00435, "epss_percentile": 0.62382}, "CVE-2010-3249": {"epss_score": 0.01023, "epss_percentile": 0.76775}, "CVE-2010-3250": {"epss_score": 0.00271, "epss_percentile": 0.50297}, "CVE-2010-3251": {"epss_score": 0.00624, "epss_percentile": 0.6957}, "CVE-2010-3252": {"epss_score": 0.00402, "epss_percentile": 0.60307}, "CVE-2010-3253": {"epss_score": 0.00149, "epss_percentile": 0.35952}, "CVE-2010-3254": {"epss_score": 0.00743, "epss_percentile": 0.72496}, "CVE-2010-3255": {"epss_score": 0.00869, "epss_percentile": 0.74694}, "CVE-2010-3256": {"epss_score": 0.00159, "epss_percentile": 0.37412}, "CVE-2010-3257": {"epss_score": 0.12151, "epss_percentile": 0.93585}, "CVE-2010-3258": {"epss_score": 0.00179, "epss_percentile": 0.39857}, "CVE-2010-3259": {"epss_score": 0.00823, "epss_percentile": 0.73932}, "CVE-2010-3260": {"epss_score": 0.00333, "epss_percentile": 0.55644}, "CVE-2010-3261": {"epss_score": 0.00063, "epss_percentile": 0.19887}, "CVE-2010-3262": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-3263": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2010-3264": {"epss_score": 0.00059, "epss_percentile": 0.18909}, "CVE-2010-3266": {"epss_score": 0.01056, "epss_percentile": 0.77121}, "CVE-2010-3267": {"epss_score": 0.00766, "epss_percentile": 0.72939}, "CVE-2010-3268": {"epss_score": 0.08746, "epss_percentile": 0.92239}, "CVE-2010-3269": {"epss_score": 0.18503, "epss_percentile": 0.95025}, "CVE-2010-3270": {"epss_score": 0.09978, "epss_percentile": 0.928}, "CVE-2010-3271": {"epss_score": 0.00678, "epss_percentile": 0.70987}, "CVE-2010-3272": {"epss_score": 0.08747, "epss_percentile": 0.92239}, "CVE-2010-3273": {"epss_score": 0.00627, "epss_percentile": 0.69621}, "CVE-2010-3274": {"epss_score": 0.1433, "epss_percentile": 0.94188}, "CVE-2010-3275": {"epss_score": 0.86225, "epss_percentile": 0.99374}, "CVE-2010-3276": {"epss_score": 0.08557, "epss_percentile": 0.92124}, "CVE-2010-3277": {"epss_score": 0.00097, "epss_percentile": 0.27629}, "CVE-2010-3279": {"epss_score": 0.0051, "epss_percentile": 0.65764}, "CVE-2010-3280": {"epss_score": 0.00549, "epss_percentile": 0.67316}, "CVE-2010-3281": {"epss_score": 0.02646, "epss_percentile": 0.85322}, "CVE-2010-3282": {"epss_score": 0.00158, "epss_percentile": 0.37254}, "CVE-2010-3283": {"epss_score": 0.00391, "epss_percentile": 0.59621}, "CVE-2010-3284": {"epss_score": 0.00594, "epss_percentile": 0.68664}, "CVE-2010-3285": {"epss_score": 0.01409, "epss_percentile": 0.80069}, "CVE-2010-3286": {"epss_score": 0.00647, "epss_percentile": 0.70173}, "CVE-2010-3287": {"epss_score": 0.01306, "epss_percentile": 0.79335}, "CVE-2010-3288": {"epss_score": 0.00119, "epss_percentile": 0.31682}, "CVE-2010-3289": {"epss_score": 0.00674, "epss_percentile": 0.70872}, "CVE-2010-3290": {"epss_score": 0.00297, "epss_percentile": 0.52712}, "CVE-2010-3291": {"epss_score": 0.00843, "epss_percentile": 0.74249}, "CVE-2010-3292": {"epss_score": 0.00029, "epss_percentile": 0.07942}, "CVE-2010-3293": {"epss_score": 0.00063, "epss_percentile": 0.19825}, "CVE-2010-3294": {"epss_score": 0.00483, "epss_percentile": 0.64563}, "CVE-2010-3296": {"epss_score": 0.00103, "epss_percentile": 0.29095}, "CVE-2010-3297": {"epss_score": 0.00101, "epss_percentile": 0.28634}, "CVE-2010-3298": {"epss_score": 0.00071, "epss_percentile": 0.21989}, "CVE-2010-3299": {"epss_score": 0.00152, "epss_percentile": 0.36492}, "CVE-2010-3300": {"epss_score": 0.00204, "epss_percentile": 0.42669}, "CVE-2010-3301": {"epss_score": 0.04727, "epss_percentile": 0.89066}, "CVE-2010-3302": {"epss_score": 0.06107, "epss_percentile": 0.90485}, "CVE-2010-3303": {"epss_score": 0.00392, "epss_percentile": 0.59667}, "CVE-2010-3304": {"epss_score": 0.01708, "epss_percentile": 0.81868}, "CVE-2010-3305": {"epss_score": 0.00502, "epss_percentile": 0.65378}, "CVE-2010-3306": {"epss_score": 0.06398, "epss_percentile": 0.90725}, "CVE-2010-3307": {"epss_score": 0.00993, "epss_percentile": 0.76413}, "CVE-2010-3308": {"epss_score": 0.04739, "epss_percentile": 0.89078}, "CVE-2010-3310": {"epss_score": 0.00125, "epss_percentile": 0.32595}, "CVE-2010-3311": {"epss_score": 0.04785, "epss_percentile": 0.8914}, "CVE-2010-3312": {"epss_score": 0.00533, "epss_percentile": 0.66713}, "CVE-2010-3313": {"epss_score": 0.023, "epss_percentile": 0.84308}, "CVE-2010-3314": {"epss_score": 0.01585, "epss_percentile": 0.81164}, "CVE-2010-3315": {"epss_score": 0.00361, "epss_percentile": 0.57693}, "CVE-2010-3316": {"epss_score": 0.00071, "epss_percentile": 0.22}, "CVE-2010-3317": {"epss_score": 0.00289, "epss_percentile": 0.52034}, "CVE-2010-3318": {"epss_score": 0.00275, "epss_percentile": 0.50693}, "CVE-2010-3319": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2010-3320": {"epss_score": 0.0054, "epss_percentile": 0.67005}, "CVE-2010-3321": {"epss_score": 0.00054, "epss_percentile": 0.17054}, "CVE-2010-3322": {"epss_score": 0.00568, "epss_percentile": 0.67889}, "CVE-2010-3323": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2010-3324": {"epss_score": 0.26442, "epss_percentile": 0.96147}, "CVE-2010-3325": {"epss_score": 0.21686, "epss_percentile": 0.95547}, "CVE-2010-3326": {"epss_score": 0.55399, "epss_percentile": 0.97976}, "CVE-2010-3327": {"epss_score": 0.25398, "epss_percentile": 0.96024}, "CVE-2010-3328": {"epss_score": 0.54758, "epss_percentile": 0.97943}, "CVE-2010-3329": {"epss_score": 0.53279, "epss_percentile": 0.97869}, "CVE-2010-3330": {"epss_score": 0.2322, "epss_percentile": 0.95752}, "CVE-2010-3331": {"epss_score": 0.55399, "epss_percentile": 0.97976}, "CVE-2010-3332": {"epss_score": 0.85142, "epss_percentile": 0.99322}, "CVE-2010-3333": {"epss_score": 0.9379, "epss_percentile": 0.99847}, "CVE-2010-3334": {"epss_score": 0.65803, "epss_percentile": 0.98439}, "CVE-2010-3335": {"epss_score": 0.69003, "epss_percentile": 0.98574}, "CVE-2010-3336": {"epss_score": 0.69003, "epss_percentile": 0.98574}, "CVE-2010-3337": {"epss_score": 0.46382, "epss_percentile": 0.97543}, "CVE-2010-3338": {"epss_score": 0.48801, "epss_percentile": 0.97655}, "CVE-2010-3340": {"epss_score": 0.55399, "epss_percentile": 0.97976}, "CVE-2010-3342": {"epss_score": 0.23572, "epss_percentile": 0.95793}, "CVE-2010-3343": {"epss_score": 0.58392, "epss_percentile": 0.98114}, "CVE-2010-3345": {"epss_score": 0.58392, "epss_percentile": 0.98114}, "CVE-2010-3346": {"epss_score": 0.58392, "epss_percentile": 0.98114}, "CVE-2010-3348": {"epss_score": 0.23572, "epss_percentile": 0.95793}, "CVE-2010-3349": {"epss_score": 0.00047, "epss_percentile": 0.14487}, "CVE-2010-3350": {"epss_score": 0.00048, "epss_percentile": 0.15284}, "CVE-2010-3351": {"epss_score": 0.00048, "epss_percentile": 0.15284}, "CVE-2010-3353": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3354": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3355": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3357": {"epss_score": 0.00054, "epss_percentile": 0.17044}, "CVE-2010-3358": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3359": {"epss_score": 0.00127, "epss_percentile": 0.32803}, "CVE-2010-3360": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3361": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3362": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3363": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3364": {"epss_score": 0.00143, "epss_percentile": 0.35215}, "CVE-2010-3365": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3366": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3369": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2010-3372": {"epss_score": 0.00056, "epss_percentile": 0.17771}, "CVE-2010-3373": {"epss_score": 0.00141, "epss_percentile": 0.34907}, "CVE-2010-3374": {"epss_score": 0.00047, "epss_percentile": 0.14487}, "CVE-2010-3375": {"epss_score": 0.0105, "epss_percentile": 0.77068}, "CVE-2010-3376": {"epss_score": 0.00061, "epss_percentile": 0.19426}, "CVE-2010-3377": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3378": {"epss_score": 0.00061, "epss_percentile": 0.19426}, "CVE-2010-3380": {"epss_score": 0.00048, "epss_percentile": 0.15047}, "CVE-2010-3381": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3382": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3383": {"epss_score": 0.00061, "epss_percentile": 0.19426}, "CVE-2010-3384": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3385": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3386": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3387": {"epss_score": 0.0015, "epss_percentile": 0.36081}, "CVE-2010-3389": {"epss_score": 0.00099, "epss_percentile": 0.28382}, "CVE-2010-3393": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3394": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-3396": {"epss_score": 0.00188, "epss_percentile": 0.40854}, "CVE-2010-3397": {"epss_score": 0.02279, "epss_percentile": 0.84237}, "CVE-2010-3398": {"epss_score": 0.00506, "epss_percentile": 0.65624}, "CVE-2010-3399": {"epss_score": 0.00635, "epss_percentile": 0.69812}, "CVE-2010-3400": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2010-3402": {"epss_score": 0.02719, "epss_percentile": 0.85515}, "CVE-2010-3403": {"epss_score": 0.01999, "epss_percentile": 0.83212}, "CVE-2010-3404": {"epss_score": 0.00243, "epss_percentile": 0.47504}, "CVE-2010-3405": {"epss_score": 0.00061, "epss_percentile": 0.1942}, "CVE-2010-3406": {"epss_score": 0.00055, "epss_percentile": 0.17406}, "CVE-2010-3407": {"epss_score": 0.77741, "epss_percentile": 0.98951}, "CVE-2010-3411": {"epss_score": 0.00159, "epss_percentile": 0.37412}, "CVE-2010-3412": {"epss_score": 0.00222, "epss_percentile": 0.44784}, "CVE-2010-3413": {"epss_score": 0.00543, "epss_percentile": 0.67123}, "CVE-2010-3414": {"epss_score": 0.00249, "epss_percentile": 0.48027}, "CVE-2010-3415": {"epss_score": 0.01201, "epss_percentile": 0.78482}, "CVE-2010-3416": {"epss_score": 0.00578, "epss_percentile": 0.68199}, "CVE-2010-3417": {"epss_score": 0.00156, "epss_percentile": 0.36989}, "CVE-2010-3418": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-3419": {"epss_score": 0.0094, "epss_percentile": 0.75742}, "CVE-2010-3420": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-3421": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2010-3422": {"epss_score": 0.00292, "epss_percentile": 0.5225}, "CVE-2010-3423": {"epss_score": 0.00555, "epss_percentile": 0.6749}, "CVE-2010-3424": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2010-3425": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2010-3426": {"epss_score": 0.00555, "epss_percentile": 0.67492}, "CVE-2010-3427": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-3428": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-3429": {"epss_score": 0.04993, "epss_percentile": 0.8937}, "CVE-2010-3430": {"epss_score": 0.00059, "epss_percentile": 0.18805}, "CVE-2010-3431": {"epss_score": 0.00078, "epss_percentile": 0.2368}, "CVE-2010-3432": {"epss_score": 0.04322, "epss_percentile": 0.8855}, "CVE-2010-3433": {"epss_score": 0.01624, "epss_percentile": 0.81405}, "CVE-2010-3434": {"epss_score": 0.09963, "epss_percentile": 0.92795}, "CVE-2010-3435": {"epss_score": 0.00085, "epss_percentile": 0.25088}, "CVE-2010-3436": {"epss_score": 0.03613, "epss_percentile": 0.87429}, "CVE-2010-3437": {"epss_score": 0.01829, "epss_percentile": 0.82441}, "CVE-2010-3438": {"epss_score": 0.00527, "epss_percentile": 0.6645}, "CVE-2010-3439": {"epss_score": 0.00568, "epss_percentile": 0.67897}, "CVE-2010-3440": {"epss_score": 0.00072, "epss_percentile": 0.22246}, "CVE-2010-3441": {"epss_score": 0.05821, "epss_percentile": 0.90234}, "CVE-2010-3442": {"epss_score": 0.00176, "epss_percentile": 0.39444}, "CVE-2010-3443": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2010-3444": {"epss_score": 0.03116, "epss_percentile": 0.86436}, "CVE-2010-3445": {"epss_score": 0.03084, "epss_percentile": 0.86382}, "CVE-2010-3447": {"epss_score": 0.00789, "epss_percentile": 0.73347}, "CVE-2010-3448": {"epss_score": 0.00049, "epss_percentile": 0.15432}, "CVE-2010-3449": {"epss_score": 0.02996, "epss_percentile": 0.86156}, "CVE-2010-3450": {"epss_score": 0.03019, "epss_percentile": 0.8622}, "CVE-2010-3451": {"epss_score": 0.10918, "epss_percentile": 0.93157}, "CVE-2010-3452": {"epss_score": 0.10918, "epss_percentile": 0.93157}, "CVE-2010-3453": {"epss_score": 0.08345, "epss_percentile": 0.92001}, "CVE-2010-3454": {"epss_score": 0.10918, "epss_percentile": 0.93157}, "CVE-2010-3455": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-3456": {"epss_score": 0.05339, "epss_percentile": 0.89757}, "CVE-2010-3457": {"epss_score": 0.01601, "epss_percentile": 0.81265}, "CVE-2010-3458": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2010-3459": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2010-3460": {"epss_score": 0.10176, "epss_percentile": 0.9288}, "CVE-2010-3461": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2010-3462": {"epss_score": 0.01134, "epss_percentile": 0.77887}, "CVE-2010-3463": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-3464": {"epss_score": 0.00149, "epss_percentile": 0.35989}, "CVE-2010-3465": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-3466": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-3467": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2010-3468": {"epss_score": 0.03289, "epss_percentile": 0.86833}, "CVE-2010-3470": {"epss_score": 0.0049, "epss_percentile": 0.64936}, "CVE-2010-3471": {"epss_score": 0.00236, "epss_percentile": 0.46377}, "CVE-2010-3472": {"epss_score": 0.00321, "epss_percentile": 0.54651}, "CVE-2010-3473": {"epss_score": 0.00321, "epss_percentile": 0.54651}, "CVE-2010-3474": {"epss_score": 0.00544, "epss_percentile": 0.67128}, "CVE-2010-3475": {"epss_score": 0.01052, "epss_percentile": 0.77091}, "CVE-2010-3476": {"epss_score": 0.0141, "epss_percentile": 0.80078}, "CVE-2010-3477": {"epss_score": 0.0008, "epss_percentile": 0.24129}, "CVE-2010-3479": {"epss_score": 0.0038, "epss_percentile": 0.58928}, "CVE-2010-3480": {"epss_score": 0.05125, "epss_percentile": 0.89523}, "CVE-2010-3481": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-3482": {"epss_score": 0.00452, "epss_percentile": 0.63179}, "CVE-2010-3483": {"epss_score": 0.02006, "epss_percentile": 0.83232}, "CVE-2010-3484": {"epss_score": 0.00519, "epss_percentile": 0.66172}, "CVE-2010-3485": {"epss_score": 0.00389, "epss_percentile": 0.59409}, "CVE-2010-3486": {"epss_score": 0.04856, "epss_percentile": 0.89218}, "CVE-2010-3487": {"epss_score": 0.0032, "epss_percentile": 0.54629}, "CVE-2010-3488": {"epss_score": 0.00443, "epss_percentile": 0.62785}, "CVE-2010-3489": {"epss_score": 0.01956, "epss_percentile": 0.83037}, "CVE-2010-3490": {"epss_score": 0.08967, "epss_percentile": 0.92342}, "CVE-2010-3491": {"epss_score": 0.0603, "epss_percentile": 0.90422}, "CVE-2010-3492": {"epss_score": 0.01151, "epss_percentile": 0.78039}, "CVE-2010-3493": {"epss_score": 0.02077, "epss_percentile": 0.83514}, "CVE-2010-3494": {"epss_score": 0.00415, "epss_percentile": 0.61149}, "CVE-2010-3495": {"epss_score": 0.01038, "epss_percentile": 0.76935}, "CVE-2010-3496": {"epss_score": 0.01472, "epss_percentile": 0.80508}, "CVE-2010-3497": {"epss_score": 0.09174, "epss_percentile": 0.92433}, "CVE-2010-3498": {"epss_score": 0.01624, "epss_percentile": 0.81409}, "CVE-2010-3499": {"epss_score": 0.01624, "epss_percentile": 0.81409}, "CVE-2010-3500": {"epss_score": 0.00429, "epss_percentile": 0.61962}, "CVE-2010-3501": {"epss_score": 0.01036, "epss_percentile": 0.76907}, "CVE-2010-3502": {"epss_score": 0.00203, "epss_percentile": 0.42534}, "CVE-2010-3503": {"epss_score": 0.00775, "epss_percentile": 0.73093}, "CVE-2010-3504": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-3505": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2010-3506": {"epss_score": 0.00117, "epss_percentile": 0.31308}, "CVE-2010-3507": {"epss_score": 0.00175, "epss_percentile": 0.39339}, "CVE-2010-3508": {"epss_score": 0.00159, "epss_percentile": 0.37395}, "CVE-2010-3509": {"epss_score": 0.01642, "epss_percentile": 0.81511}, "CVE-2010-3510": {"epss_score": 0.04289, "epss_percentile": 0.88499}, "CVE-2010-3511": {"epss_score": 0.00147, "epss_percentile": 0.35663}, "CVE-2010-3512": {"epss_score": 0.00164, "epss_percentile": 0.37993}, "CVE-2010-3513": {"epss_score": 0.001, "epss_percentile": 0.28504}, "CVE-2010-3514": {"epss_score": 0.12686, "epss_percentile": 0.93749}, "CVE-2010-3515": {"epss_score": 0.00174, "epss_percentile": 0.39175}, "CVE-2010-3516": {"epss_score": 0.00174, "epss_percentile": 0.39175}, "CVE-2010-3517": {"epss_score": 0.00174, "epss_percentile": 0.39175}, "CVE-2010-3518": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3519": {"epss_score": 0.00181, "epss_percentile": 0.40021}, "CVE-2010-3520": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3521": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3522": {"epss_score": 0.00203, "epss_percentile": 0.42534}, "CVE-2010-3523": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-3524": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3525": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3526": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3527": {"epss_score": 0.00243, "epss_percentile": 0.47505}, "CVE-2010-3528": {"epss_score": 0.00203, "epss_percentile": 0.42534}, "CVE-2010-3529": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3530": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3531": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3532": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3533": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3534": {"epss_score": 0.00292, "epss_percentile": 0.52283}, "CVE-2010-3535": {"epss_score": 0.00224, "epss_percentile": 0.45017}, "CVE-2010-3536": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3537": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3538": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3539": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3540": {"epss_score": 0.00174, "epss_percentile": 0.39175}, "CVE-2010-3541": {"epss_score": 0.01613, "epss_percentile": 0.81341}, "CVE-2010-3542": {"epss_score": 0.00139, "epss_percentile": 0.34643}, "CVE-2010-3544": {"epss_score": 0.01376, "epss_percentile": 0.79838}, "CVE-2010-3545": {"epss_score": 0.00371, "epss_percentile": 0.58369}, "CVE-2010-3546": {"epss_score": 0.00371, "epss_percentile": 0.58369}, "CVE-2010-3547": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2010-3548": {"epss_score": 0.03332, "epss_percentile": 0.86928}, "CVE-2010-3549": {"epss_score": 0.05715, "epss_percentile": 0.90145}, "CVE-2010-3550": {"epss_score": 0.07636, "epss_percentile": 0.91591}, "CVE-2010-3551": {"epss_score": 0.03332, "epss_percentile": 0.86928}, "CVE-2010-3552": {"epss_score": 0.82665, "epss_percentile": 0.99205}, "CVE-2010-3553": {"epss_score": 0.11103, "epss_percentile": 0.93221}, "CVE-2010-3554": {"epss_score": 0.07207, "epss_percentile": 0.91324}, "CVE-2010-3555": {"epss_score": 0.133, "epss_percentile": 0.93926}, "CVE-2010-3556": {"epss_score": 0.1145, "epss_percentile": 0.93365}, "CVE-2010-3557": {"epss_score": 0.05788, "epss_percentile": 0.9021}, "CVE-2010-3558": {"epss_score": 0.05156, "epss_percentile": 0.89552}, "CVE-2010-3559": {"epss_score": 0.1366, "epss_percentile": 0.94028}, "CVE-2010-3560": {"epss_score": 0.03511, "epss_percentile": 0.87266}, "CVE-2010-3561": {"epss_score": 0.04508, "epss_percentile": 0.88775}, "CVE-2010-3562": {"epss_score": 0.15698, "epss_percentile": 0.94486}, "CVE-2010-3563": {"epss_score": 0.88762, "epss_percentile": 0.99488}, "CVE-2010-3564": {"epss_score": 0.08235, "epss_percentile": 0.91943}, "CVE-2010-3565": {"epss_score": 0.08491, "epss_percentile": 0.92082}, "CVE-2010-3566": {"epss_score": 0.0676, "epss_percentile": 0.91008}, "CVE-2010-3567": {"epss_score": 0.09258, "epss_percentile": 0.92469}, "CVE-2010-3568": {"epss_score": 0.09242, "epss_percentile": 0.92464}, "CVE-2010-3569": {"epss_score": 0.16263, "epss_percentile": 0.94606}, "CVE-2010-3570": {"epss_score": 0.0644, "epss_percentile": 0.90758}, "CVE-2010-3571": {"epss_score": 0.14119, "epss_percentile": 0.94136}, "CVE-2010-3572": {"epss_score": 0.1145, "epss_percentile": 0.93365}, "CVE-2010-3573": {"epss_score": 0.07239, "epss_percentile": 0.91343}, "CVE-2010-3574": {"epss_score": 0.08577, "epss_percentile": 0.92131}, "CVE-2010-3575": {"epss_score": 0.00371, "epss_percentile": 0.58369}, "CVE-2010-3576": {"epss_score": 0.00147, "epss_percentile": 0.35663}, "CVE-2010-3577": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2010-3578": {"epss_score": 0.00843, "epss_percentile": 0.74262}, "CVE-2010-3579": {"epss_score": 0.00371, "epss_percentile": 0.58369}, "CVE-2010-3580": {"epss_score": 0.00119, "epss_percentile": 0.31565}, "CVE-2010-3581": {"epss_score": 0.0534, "epss_percentile": 0.89757}, "CVE-2010-3582": {"epss_score": 0.00366, "epss_percentile": 0.58097}, "CVE-2010-3583": {"epss_score": 0.0121, "epss_percentile": 0.78546}, "CVE-2010-3584": {"epss_score": 0.00157, "epss_percentile": 0.37058}, "CVE-2010-3585": {"epss_score": 0.63697, "epss_percentile": 0.98345}, "CVE-2010-3586": {"epss_score": 0.00057, "epss_percentile": 0.17984}, "CVE-2010-3587": {"epss_score": 0.00394, "epss_percentile": 0.59756}, "CVE-2010-3588": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2010-3589": {"epss_score": 0.00394, "epss_percentile": 0.59756}, "CVE-2010-3590": {"epss_score": 0.00441, "epss_percentile": 0.62662}, "CVE-2010-3591": {"epss_score": 0.16614, "epss_percentile": 0.94702}, "CVE-2010-3592": {"epss_score": 0.02957, "epss_percentile": 0.86064}, "CVE-2010-3593": {"epss_score": 0.01285, "epss_percentile": 0.79174}, "CVE-2010-3594": {"epss_score": 0.0055, "epss_percentile": 0.67332}, "CVE-2010-3595": {"epss_score": 0.28808, "epss_percentile": 0.96386}, "CVE-2010-3596": {"epss_score": 0.00719, "epss_percentile": 0.71945}, "CVE-2010-3597": {"epss_score": 0.00084, "epss_percentile": 0.24894}, "CVE-2010-3598": {"epss_score": 0.01267, "epss_percentile": 0.79021}, "CVE-2010-3599": {"epss_score": 0.41054, "epss_percentile": 0.97251}, "CVE-2010-3600": {"epss_score": 0.76971, "epss_percentile": 0.98913}, "CVE-2010-3601": {"epss_score": 0.00409, "epss_percentile": 0.60764}, "CVE-2010-3602": {"epss_score": 0.08045, "epss_percentile": 0.91849}, "CVE-2010-3603": {"epss_score": 0.04218, "epss_percentile": 0.88407}, "CVE-2010-3604": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2010-3605": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-3606": {"epss_score": 0.00167, "epss_percentile": 0.38344}, "CVE-2010-3607": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-3608": {"epss_score": 0.00721, "epss_percentile": 0.71987}, "CVE-2010-3609": {"epss_score": 0.3547, "epss_percentile": 0.96915}, "CVE-2010-3611": {"epss_score": 0.07632, "epss_percentile": 0.91585}, "CVE-2010-3613": {"epss_score": 0.03207, "epss_percentile": 0.86638}, "CVE-2010-3614": {"epss_score": 0.10521, "epss_percentile": 0.93018}, "CVE-2010-3615": {"epss_score": 0.0529, "epss_percentile": 0.89696}, "CVE-2010-3616": {"epss_score": 0.08435, "epss_percentile": 0.92051}, "CVE-2010-3618": {"epss_score": 0.01753, "epss_percentile": 0.82113}, "CVE-2010-3619": {"epss_score": 0.03355, "epss_percentile": 0.86972}, "CVE-2010-3620": {"epss_score": 0.03408, "epss_percentile": 0.87078}, "CVE-2010-3621": {"epss_score": 0.04487, "epss_percentile": 0.88751}, "CVE-2010-3622": {"epss_score": 0.04487, "epss_percentile": 0.88751}, "CVE-2010-3623": {"epss_score": 0.10501, "epss_percentile": 0.93012}, "CVE-2010-3624": {"epss_score": 0.22531, "epss_percentile": 0.95648}, "CVE-2010-3625": {"epss_score": 0.03742, "epss_percentile": 0.87658}, "CVE-2010-3626": {"epss_score": 0.02538, "epss_percentile": 0.85042}, "CVE-2010-3627": {"epss_score": 0.03408, "epss_percentile": 0.87078}, "CVE-2010-3628": {"epss_score": 0.04487, "epss_percentile": 0.88751}, "CVE-2010-3629": {"epss_score": 0.05958, "epss_percentile": 0.90364}, "CVE-2010-3630": {"epss_score": 0.04435, "epss_percentile": 0.88685}, "CVE-2010-3631": {"epss_score": 0.29089, "epss_percentile": 0.96417}, "CVE-2010-3632": {"epss_score": 0.04487, "epss_percentile": 0.88751}, "CVE-2010-3633": {"epss_score": 0.01174, "epss_percentile": 0.78253}, "CVE-2010-3634": {"epss_score": 0.01174, "epss_percentile": 0.78253}, "CVE-2010-3635": {"epss_score": 0.05921, "epss_percentile": 0.90322}, "CVE-2010-3636": {"epss_score": 0.02261, "epss_percentile": 0.84187}, "CVE-2010-3637": {"epss_score": 0.16413, "epss_percentile": 0.94648}, "CVE-2010-3638": {"epss_score": 0.01833, "epss_percentile": 0.82458}, "CVE-2010-3639": {"epss_score": 0.30014, "epss_percentile": 0.96493}, "CVE-2010-3640": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2010-3641": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2010-3642": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2010-3643": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2010-3644": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2010-3645": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2010-3646": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2010-3647": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2010-3648": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2010-3649": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2010-3650": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2010-3652": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2010-3653": {"epss_score": 0.77779, "epss_percentile": 0.98953}, "CVE-2010-3654": {"epss_score": 0.93558, "epss_percentile": 0.99817}, "CVE-2010-3655": {"epss_score": 0.17675, "epss_percentile": 0.94888}, "CVE-2010-3656": {"epss_score": 0.01584, "epss_percentile": 0.81156}, "CVE-2010-3657": {"epss_score": 0.01584, "epss_percentile": 0.81156}, "CVE-2010-3658": {"epss_score": 0.07451, "epss_percentile": 0.91478}, "CVE-2010-3659": {"epss_score": 0.00258, "epss_percentile": 0.48965}, "CVE-2010-3660": {"epss_score": 0.0047, "epss_percentile": 0.63978}, "CVE-2010-3661": {"epss_score": 0.0027, "epss_percentile": 0.50238}, "CVE-2010-3662": {"epss_score": 0.00556, "epss_percentile": 0.6751}, "CVE-2010-3663": {"epss_score": 0.03147, "epss_percentile": 0.86499}, "CVE-2010-3664": {"epss_score": 0.0053, "epss_percentile": 0.6661}, "CVE-2010-3665": {"epss_score": 0.0043, "epss_percentile": 0.62022}, "CVE-2010-3666": {"epss_score": 0.00325, "epss_percentile": 0.55027}, "CVE-2010-3667": {"epss_score": 0.00316, "epss_percentile": 0.54232}, "CVE-2010-3668": {"epss_score": 0.00426, "epss_percentile": 0.61768}, "CVE-2010-3669": {"epss_score": 0.00235, "epss_percentile": 0.46228}, "CVE-2010-3670": {"epss_score": 0.00131, "epss_percentile": 0.33503}, "CVE-2010-3671": {"epss_score": 0.00905, "epss_percentile": 0.75241}, "CVE-2010-3672": {"epss_score": 0.0045, "epss_percentile": 0.631}, "CVE-2010-3673": {"epss_score": 0.00456, "epss_percentile": 0.63327}, "CVE-2010-3674": {"epss_score": 0.00545, "epss_percentile": 0.6717}, "CVE-2010-3676": {"epss_score": 0.03068, "epss_percentile": 0.86342}, "CVE-2010-3677": {"epss_score": 0.0128, "epss_percentile": 0.79139}, "CVE-2010-3678": {"epss_score": 0.06053, "epss_percentile": 0.90436}, "CVE-2010-3679": {"epss_score": 0.0455, "epss_percentile": 0.88839}, "CVE-2010-3680": {"epss_score": 0.05112, "epss_percentile": 0.89511}, "CVE-2010-3681": {"epss_score": 0.05412, "epss_percentile": 0.89847}, "CVE-2010-3682": {"epss_score": 0.02058, "epss_percentile": 0.83433}, "CVE-2010-3683": {"epss_score": 0.07998, "epss_percentile": 0.91814}, "CVE-2010-3684": {"epss_score": 0.00124, "epss_percentile": 0.32416}, "CVE-2010-3685": {"epss_score": 0.00633, "epss_percentile": 0.69758}, "CVE-2010-3686": {"epss_score": 0.00633, "epss_percentile": 0.69758}, "CVE-2010-3687": {"epss_score": 0.00178, "epss_percentile": 0.39669}, "CVE-2010-3688": {"epss_score": 0.0011, "epss_percentile": 0.30082}, "CVE-2010-3689": {"epss_score": 0.00051, "epss_percentile": 0.16324}, "CVE-2010-3690": {"epss_score": 0.01041, "epss_percentile": 0.76964}, "CVE-2010-3691": {"epss_score": 0.00063, "epss_percentile": 0.1992}, "CVE-2010-3692": {"epss_score": 0.007, "epss_percentile": 0.71481}, "CVE-2010-3693": {"epss_score": 0.00684, "epss_percentile": 0.71126}, "CVE-2010-3694": {"epss_score": 0.00174, "epss_percentile": 0.39175}, "CVE-2010-3695": {"epss_score": 0.01169, "epss_percentile": 0.78203}, "CVE-2010-3696": {"epss_score": 0.00828, "epss_percentile": 0.73995}, "CVE-2010-3697": {"epss_score": 0.00828, "epss_percentile": 0.73995}, "CVE-2010-3698": {"epss_score": 0.00098, "epss_percentile": 0.27696}, "CVE-2010-3699": {"epss_score": 0.00507, "epss_percentile": 0.65676}, "CVE-2010-3700": {"epss_score": 0.00248, "epss_percentile": 0.47934}, "CVE-2010-3701": {"epss_score": 0.00625, "epss_percentile": 0.69585}, "CVE-2010-3702": {"epss_score": 0.03862, "epss_percentile": 0.87867}, "CVE-2010-3703": {"epss_score": 0.01136, "epss_percentile": 0.77919}, "CVE-2010-3704": {"epss_score": 0.01533, "epss_percentile": 0.809}, "CVE-2010-3705": {"epss_score": 0.01215, "epss_percentile": 0.7859}, "CVE-2010-3706": {"epss_score": 0.00402, "epss_percentile": 0.60303}, "CVE-2010-3707": {"epss_score": 0.00134, "epss_percentile": 0.33786}, "CVE-2010-3708": {"epss_score": 0.02416, "epss_percentile": 0.8469}, "CVE-2010-3709": {"epss_score": 0.06078, "epss_percentile": 0.9046}, "CVE-2010-3710": {"epss_score": 0.0278, "epss_percentile": 0.85649}, "CVE-2010-3711": {"epss_score": 0.01058, "epss_percentile": 0.77139}, "CVE-2010-3712": {"epss_score": 0.00039, "epss_percentile": 0.118}, "CVE-2010-3713": {"epss_score": 0.00234, "epss_percentile": 0.46154}, "CVE-2010-3714": {"epss_score": 0.32406, "epss_percentile": 0.96695}, "CVE-2010-3715": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-3716": {"epss_score": 0.00413, "epss_percentile": 0.60999}, "CVE-2010-3717": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2010-3718": {"epss_score": 0.00304, "epss_percentile": 0.53286}, "CVE-2010-3719": {"epss_score": 0.07589, "epss_percentile": 0.91558}, "CVE-2010-3729": {"epss_score": 0.04257, "epss_percentile": 0.88459}, "CVE-2010-3730": {"epss_score": 0.00513, "epss_percentile": 0.65924}, "CVE-2010-3731": {"epss_score": 0.43415, "epss_percentile": 0.97386}, "CVE-2010-3732": {"epss_score": 0.0038, "epss_percentile": 0.58951}, "CVE-2010-3733": {"epss_score": 0.0004, "epss_percentile": 0.12079}, "CVE-2010-3734": {"epss_score": 0.00233, "epss_percentile": 0.46046}, "CVE-2010-3735": {"epss_score": 0.00406, "epss_percentile": 0.60564}, "CVE-2010-3736": {"epss_score": 0.00406, "epss_percentile": 0.60564}, "CVE-2010-3737": {"epss_score": 0.0038, "epss_percentile": 0.58951}, "CVE-2010-3738": {"epss_score": 0.00246, "epss_percentile": 0.47798}, "CVE-2010-3739": {"epss_score": 0.00246, "epss_percentile": 0.4778}, "CVE-2010-3740": {"epss_score": 0.00406, "epss_percentile": 0.60564}, "CVE-2010-3741": {"epss_score": 0.00071, "epss_percentile": 0.22041}, "CVE-2010-3742": {"epss_score": 0.02063, "epss_percentile": 0.83448}, "CVE-2010-3743": {"epss_score": 0.00115, "epss_percentile": 0.31029}, "CVE-2010-3747": {"epss_score": 0.685, "epss_percentile": 0.98551}, "CVE-2010-3748": {"epss_score": 0.01461, "epss_percentile": 0.8043}, "CVE-2010-3749": {"epss_score": 0.05823, "epss_percentile": 0.90236}, "CVE-2010-3750": {"epss_score": 0.01516, "epss_percentile": 0.80797}, "CVE-2010-3751": {"epss_score": 0.05834, "epss_percentile": 0.90247}, "CVE-2010-3752": {"epss_score": 0.00649, "epss_percentile": 0.70233}, "CVE-2010-3753": {"epss_score": 0.00649, "epss_percentile": 0.70233}, "CVE-2010-3754": {"epss_score": 0.07808, "epss_percentile": 0.91693}, "CVE-2010-3755": {"epss_score": 0.00885, "epss_percentile": 0.74935}, "CVE-2010-3756": {"epss_score": 0.00728, "epss_percentile": 0.72103}, "CVE-2010-3757": {"epss_score": 0.08462, "epss_percentile": 0.92064}, "CVE-2010-3758": {"epss_score": 0.35407, "epss_percentile": 0.96906}, "CVE-2010-3759": {"epss_score": 0.08462, "epss_percentile": 0.92064}, "CVE-2010-3760": {"epss_score": 0.00752, "epss_percentile": 0.72651}, "CVE-2010-3761": {"epss_score": 0.09234, "epss_percentile": 0.92459}, "CVE-2010-3762": {"epss_score": 0.27542, "epss_percentile": 0.96256}, "CVE-2010-3763": {"epss_score": 0.00598, "epss_percentile": 0.68761}, "CVE-2010-3764": {"epss_score": 0.00846, "epss_percentile": 0.74333}, "CVE-2010-3765": {"epss_score": 0.87952, "epss_percentile": 0.99452}, "CVE-2010-3766": {"epss_score": 0.06704, "epss_percentile": 0.90957}, "CVE-2010-3767": {"epss_score": 0.04617, "epss_percentile": 0.88925}, "CVE-2010-3768": {"epss_score": 0.07326, "epss_percentile": 0.9141}, "CVE-2010-3769": {"epss_score": 0.06622, "epss_percentile": 0.90896}, "CVE-2010-3770": {"epss_score": 0.09317, "epss_percentile": 0.92498}, "CVE-2010-3771": {"epss_score": 0.02236, "epss_percentile": 0.84102}, "CVE-2010-3772": {"epss_score": 0.07195, "epss_percentile": 0.91313}, "CVE-2010-3773": {"epss_score": 0.01245, "epss_percentile": 0.78844}, "CVE-2010-3774": {"epss_score": 0.01165, "epss_percentile": 0.78176}, "CVE-2010-3775": {"epss_score": 0.03519, "epss_percentile": 0.87282}, "CVE-2010-3776": {"epss_score": 0.05142, "epss_percentile": 0.89539}, "CVE-2010-3777": {"epss_score": 0.06912, "epss_percentile": 0.91113}, "CVE-2010-3778": {"epss_score": 0.05098, "epss_percentile": 0.89496}, "CVE-2010-3779": {"epss_score": 0.00302, "epss_percentile": 0.5311}, "CVE-2010-3780": {"epss_score": 0.01062, "epss_percentile": 0.77179}, "CVE-2010-3781": {"epss_score": 0.01124, "epss_percentile": 0.77795}, "CVE-2010-3782": {"epss_score": 0.00298, "epss_percentile": 0.52825}, "CVE-2010-3783": {"epss_score": 0.00159, "epss_percentile": 0.37309}, "CVE-2010-3784": {"epss_score": 0.00408, "epss_percentile": 0.60636}, "CVE-2010-3785": {"epss_score": 0.02245, "epss_percentile": 0.84128}, "CVE-2010-3786": {"epss_score": 0.05127, "epss_percentile": 0.89525}, "CVE-2010-3787": {"epss_score": 0.01368, "epss_percentile": 0.79789}, "CVE-2010-3788": {"epss_score": 0.01058, "epss_percentile": 0.77142}, "CVE-2010-3789": {"epss_score": 0.01058, "epss_percentile": 0.77142}, "CVE-2010-3790": {"epss_score": 0.04226, "epss_percentile": 0.88417}, "CVE-2010-3791": {"epss_score": 0.01127, "epss_percentile": 0.7782}, "CVE-2010-3792": {"epss_score": 0.01058, "epss_percentile": 0.77142}, "CVE-2010-3793": {"epss_score": 0.01058, "epss_percentile": 0.77142}, "CVE-2010-3794": {"epss_score": 0.01058, "epss_percentile": 0.77142}, "CVE-2010-3795": {"epss_score": 0.01058, "epss_percentile": 0.77142}, "CVE-2010-3796": {"epss_score": 0.00209, "epss_percentile": 0.43336}, "CVE-2010-3797": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2010-3798": {"epss_score": 0.02396, "epss_percentile": 0.84616}, "CVE-2010-3800": {"epss_score": 0.08, "epss_percentile": 0.91821}, "CVE-2010-3801": {"epss_score": 0.08, "epss_percentile": 0.91821}, "CVE-2010-3802": {"epss_score": 0.08, "epss_percentile": 0.91821}, "CVE-2010-3803": {"epss_score": 0.10104, "epss_percentile": 0.9285}, "CVE-2010-3804": {"epss_score": 0.17219, "epss_percentile": 0.94801}, "CVE-2010-3805": {"epss_score": 0.07127, "epss_percentile": 0.91266}, "CVE-2010-3808": {"epss_score": 0.02577, "epss_percentile": 0.85144}, "CVE-2010-3809": {"epss_score": 0.02371, "epss_percentile": 0.84527}, "CVE-2010-3810": {"epss_score": 0.00687, "epss_percentile": 0.71187}, "CVE-2010-3811": {"epss_score": 0.08086, "epss_percentile": 0.91874}, "CVE-2010-3812": {"epss_score": 0.05476, "epss_percentile": 0.89914}, "CVE-2010-3813": {"epss_score": 0.0082, "epss_percentile": 0.73883}, "CVE-2010-3814": {"epss_score": 0.05648, "epss_percentile": 0.90082}, "CVE-2010-3816": {"epss_score": 0.08086, "epss_percentile": 0.91874}, "CVE-2010-3817": {"epss_score": 0.02246, "epss_percentile": 0.84132}, "CVE-2010-3818": {"epss_score": 0.08086, "epss_percentile": 0.91874}, "CVE-2010-3819": {"epss_score": 0.02577, "epss_percentile": 0.85144}, "CVE-2010-3820": {"epss_score": 0.02246, "epss_percentile": 0.84132}, "CVE-2010-3821": {"epss_score": 0.02415, "epss_percentile": 0.84687}, "CVE-2010-3822": {"epss_score": 0.02222, "epss_percentile": 0.84053}, "CVE-2010-3823": {"epss_score": 0.08086, "epss_percentile": 0.91874}, "CVE-2010-3824": {"epss_score": 0.06623, "epss_percentile": 0.90896}, "CVE-2010-3826": {"epss_score": 0.02246, "epss_percentile": 0.84132}, "CVE-2010-3827": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2010-3828": {"epss_score": 0.00542, "epss_percentile": 0.67066}, "CVE-2010-3829": {"epss_score": 0.00617, "epss_percentile": 0.69341}, "CVE-2010-3830": {"epss_score": 0.00298, "epss_percentile": 0.5281}, "CVE-2010-3831": {"epss_score": 0.0047, "epss_percentile": 0.63969}, "CVE-2010-3832": {"epss_score": 0.04273, "epss_percentile": 0.88478}, "CVE-2010-3833": {"epss_score": 0.09612, "epss_percentile": 0.92623}, "CVE-2010-3834": {"epss_score": 0.01043, "epss_percentile": 0.76993}, "CVE-2010-3835": {"epss_score": 0.01238, "epss_percentile": 0.78792}, "CVE-2010-3836": {"epss_score": 0.01098, "epss_percentile": 0.77533}, "CVE-2010-3837": {"epss_score": 0.00972, "epss_percentile": 0.76134}, "CVE-2010-3838": {"epss_score": 0.01238, "epss_percentile": 0.78792}, "CVE-2010-3839": {"epss_score": 0.01122, "epss_percentile": 0.77785}, "CVE-2010-3840": {"epss_score": 0.00972, "epss_percentile": 0.76134}, "CVE-2010-3841": {"epss_score": 0.00214, "epss_percentile": 0.43994}, "CVE-2010-3842": {"epss_score": 0.00898, "epss_percentile": 0.7515}, "CVE-2010-3843": {"epss_score": 0.00054, "epss_percentile": 0.17318}, "CVE-2010-3844": {"epss_score": 0.00527, "epss_percentile": 0.6645}, "CVE-2010-3845": {"epss_score": 0.00376, "epss_percentile": 0.58678}, "CVE-2010-3846": {"epss_score": 0.00129, "epss_percentile": 0.33112}, "CVE-2010-3847": {"epss_score": 0.04991, "epss_percentile": 0.89368}, "CVE-2010-3848": {"epss_score": 0.00152, "epss_percentile": 0.36438}, "CVE-2010-3849": {"epss_score": 0.00158, "epss_percentile": 0.37154}, "CVE-2010-3850": {"epss_score": 0.00102, "epss_percentile": 0.28804}, "CVE-2010-3851": {"epss_score": 0.00088, "epss_percentile": 0.25786}, "CVE-2010-3852": {"epss_score": 0.00711, "epss_percentile": 0.71735}, "CVE-2010-3853": {"epss_score": 0.00053, "epss_percentile": 0.16826}, "CVE-2010-3854": {"epss_score": 0.04547, "epss_percentile": 0.88835}, "CVE-2010-3855": {"epss_score": 0.09838, "epss_percentile": 0.92726}, "CVE-2010-3856": {"epss_score": 0.05862, "epss_percentile": 0.90271}, "CVE-2010-3857": {"epss_score": 0.00491, "epss_percentile": 0.64958}, "CVE-2010-3858": {"epss_score": 0.0014, "epss_percentile": 0.34696}, "CVE-2010-3859": {"epss_score": 0.00146, "epss_percentile": 0.35622}, "CVE-2010-3860": {"epss_score": 0.01511, "epss_percentile": 0.80778}, "CVE-2010-3861": {"epss_score": 0.00052, "epss_percentile": 0.16477}, "CVE-2010-3862": {"epss_score": 0.01675, "epss_percentile": 0.81705}, "CVE-2010-3863": {"epss_score": 0.10808, "epss_percentile": 0.9311}, "CVE-2010-3864": {"epss_score": 0.07364, "epss_percentile": 0.91434}, "CVE-2010-3865": {"epss_score": 0.0007, "epss_percentile": 0.21656}, "CVE-2010-3867": {"epss_score": 0.00187, "epss_percentile": 0.40761}, "CVE-2010-3868": {"epss_score": 0.00277, "epss_percentile": 0.50841}, "CVE-2010-3869": {"epss_score": 0.00197, "epss_percentile": 0.41959}, "CVE-2010-3870": {"epss_score": 0.0071, "epss_percentile": 0.71702}, "CVE-2010-3871": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-3872": {"epss_score": 0.00943, "epss_percentile": 0.75781}, "CVE-2010-3873": {"epss_score": 0.03368, "epss_percentile": 0.87006}, "CVE-2010-3874": {"epss_score": 0.00096, "epss_percentile": 0.27286}, "CVE-2010-3875": {"epss_score": 0.00073, "epss_percentile": 0.22652}, "CVE-2010-3876": {"epss_score": 0.00058, "epss_percentile": 0.18288}, "CVE-2010-3877": {"epss_score": 0.00108, "epss_percentile": 0.29891}, "CVE-2010-3878": {"epss_score": 0.00136, "epss_percentile": 0.34108}, "CVE-2010-3879": {"epss_score": 0.02052, "epss_percentile": 0.83409}, "CVE-2010-3880": {"epss_score": 0.00127, "epss_percentile": 0.32898}, "CVE-2010-3881": {"epss_score": 0.00073, "epss_percentile": 0.22635}, "CVE-2010-3882": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-3883": {"epss_score": 0.00087, "epss_percentile": 0.25608}, "CVE-2010-3884": {"epss_score": 0.00079, "epss_percentile": 0.23852}, "CVE-2010-3886": {"epss_score": 0.14351, "epss_percentile": 0.94192}, "CVE-2010-3887": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2010-3888": {"epss_score": 0.0103, "epss_percentile": 0.76844}, "CVE-2010-3889": {"epss_score": 0.00623, "epss_percentile": 0.69551}, "CVE-2010-3890": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2010-3891": {"epss_score": 0.02523, "epss_percentile": 0.85007}, "CVE-2010-3892": {"epss_score": 0.00609, "epss_percentile": 0.69096}, "CVE-2010-3893": {"epss_score": 0.05136, "epss_percentile": 0.89535}, "CVE-2010-3894": {"epss_score": 0.13036, "epss_percentile": 0.93852}, "CVE-2010-3895": {"epss_score": 0.00395, "epss_percentile": 0.59816}, "CVE-2010-3896": {"epss_score": 0.00769, "epss_percentile": 0.7299}, "CVE-2010-3897": {"epss_score": 0.00286, "epss_percentile": 0.5178}, "CVE-2010-3898": {"epss_score": 0.0029, "epss_percentile": 0.52125}, "CVE-2010-3899": {"epss_score": 0.10873, "epss_percentile": 0.93141}, "CVE-2010-3900": {"epss_score": 0.00483, "epss_percentile": 0.64591}, "CVE-2010-3901": {"epss_score": 0.00152, "epss_percentile": 0.364}, "CVE-2010-3902": {"epss_score": 0.0056, "epss_percentile": 0.67642}, "CVE-2010-3903": {"epss_score": 0.00305, "epss_percentile": 0.53327}, "CVE-2010-3904": {"epss_score": 0.01386, "epss_percentile": 0.79913}, "CVE-2010-3905": {"epss_score": 0.01389, "epss_percentile": 0.79927}, "CVE-2010-3906": {"epss_score": 0.13918, "epss_percentile": 0.94092}, "CVE-2010-3907": {"epss_score": 0.04744, "epss_percentile": 0.89084}, "CVE-2010-3908": {"epss_score": 0.02299, "epss_percentile": 0.84307}, "CVE-2010-3909": {"epss_score": 0.02627, "epss_percentile": 0.85268}, "CVE-2010-3910": {"epss_score": 0.01899, "epss_percentile": 0.82766}, "CVE-2010-3911": {"epss_score": 0.00365, "epss_percentile": 0.5799}, "CVE-2010-3912": {"epss_score": 0.00248, "epss_percentile": 0.47957}, "CVE-2010-3913": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2010-3914": {"epss_score": 0.03543, "epss_percentile": 0.87321}, "CVE-2010-3915": {"epss_score": 0.11605, "epss_percentile": 0.93418}, "CVE-2010-3916": {"epss_score": 0.14904, "epss_percentile": 0.94318}, "CVE-2010-3917": {"epss_score": 0.00467, "epss_percentile": 0.63813}, "CVE-2010-3918": {"epss_score": 0.00461, "epss_percentile": 0.63566}, "CVE-2010-3919": {"epss_score": 0.00277, "epss_percentile": 0.50788}, "CVE-2010-3920": {"epss_score": 0.00052, "epss_percentile": 0.16452}, "CVE-2010-3921": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2010-3922": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2010-3923": {"epss_score": 0.00053, "epss_percentile": 0.1671}, "CVE-2010-3924": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2010-3925": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2010-3926": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2010-3927": {"epss_score": 0.00057, "epss_percentile": 0.18098}, "CVE-2010-3928": {"epss_score": 0.0075, "epss_percentile": 0.72626}, "CVE-2010-3929": {"epss_score": 0.00526, "epss_percentile": 0.66424}, "CVE-2010-3930": {"epss_score": 0.00164, "epss_percentile": 0.38004}, "CVE-2010-3931": {"epss_score": 0.00639, "epss_percentile": 0.69942}, "CVE-2010-3933": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2010-3934": {"epss_score": 0.00294, "epss_percentile": 0.52413}, "CVE-2010-3936": {"epss_score": 0.42355, "epss_percentile": 0.97327}, "CVE-2010-3937": {"epss_score": 0.33663, "epss_percentile": 0.96795}, "CVE-2010-3939": {"epss_score": 0.02047, "epss_percentile": 0.83389}, "CVE-2010-3940": {"epss_score": 0.03392, "epss_percentile": 0.87053}, "CVE-2010-3941": {"epss_score": 0.03277, "epss_percentile": 0.86807}, "CVE-2010-3942": {"epss_score": 0.01786, "epss_percentile": 0.82258}, "CVE-2010-3943": {"epss_score": 0.02407, "epss_percentile": 0.84655}, "CVE-2010-3944": {"epss_score": 0.01007, "epss_percentile": 0.76563}, "CVE-2010-3945": {"epss_score": 0.62128, "epss_percentile": 0.98282}, "CVE-2010-3946": {"epss_score": 0.66914, "epss_percentile": 0.98486}, "CVE-2010-3947": {"epss_score": 0.57681, "epss_percentile": 0.98079}, "CVE-2010-3949": {"epss_score": 0.62128, "epss_percentile": 0.98282}, "CVE-2010-3950": {"epss_score": 0.61042, "epss_percentile": 0.98233}, "CVE-2010-3951": {"epss_score": 0.62128, "epss_percentile": 0.98282}, "CVE-2010-3952": {"epss_score": 0.61042, "epss_percentile": 0.98233}, "CVE-2010-3954": {"epss_score": 0.61042, "epss_percentile": 0.98233}, "CVE-2010-3955": {"epss_score": 0.58322, "epss_percentile": 0.98109}, "CVE-2010-3956": {"epss_score": 0.43144, "epss_percentile": 0.97371}, "CVE-2010-3957": {"epss_score": 0.03701, "epss_percentile": 0.87592}, "CVE-2010-3958": {"epss_score": 0.56465, "epss_percentile": 0.98023}, "CVE-2010-3959": {"epss_score": 0.33404, "epss_percentile": 0.96771}, "CVE-2010-3960": {"epss_score": 0.01477, "epss_percentile": 0.80542}, "CVE-2010-3961": {"epss_score": 0.00747, "epss_percentile": 0.72566}, "CVE-2010-3962": {"epss_score": 0.87119, "epss_percentile": 0.99416}, "CVE-2010-3963": {"epss_score": 0.00728, "epss_percentile": 0.72107}, "CVE-2010-3964": {"epss_score": 0.906, "epss_percentile": 0.99591}, "CVE-2010-3965": {"epss_score": 0.53703, "epss_percentile": 0.97894}, "CVE-2010-3966": {"epss_score": 0.47326, "epss_percentile": 0.97582}, "CVE-2010-3967": {"epss_score": 0.32664, "epss_percentile": 0.96716}, "CVE-2010-3970": {"epss_score": 0.81209, "epss_percentile": 0.99128}, "CVE-2010-3971": {"epss_score": 0.856, "epss_percentile": 0.9934}, "CVE-2010-3972": {"epss_score": 0.91689, "epss_percentile": 0.99663}, "CVE-2010-3973": {"epss_score": 0.81221, "epss_percentile": 0.99129}, "CVE-2010-3974": {"epss_score": 0.39194, "epss_percentile": 0.97145}, "CVE-2010-3975": {"epss_score": 0.06327, "epss_percentile": 0.90673}, "CVE-2010-3976": {"epss_score": 0.10042, "epss_percentile": 0.92825}, "CVE-2010-3977": {"epss_score": 0.0079, "epss_percentile": 0.73375}, "CVE-2010-3978": {"epss_score": 0.00635, "epss_percentile": 0.69812}, "CVE-2010-3979": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2010-3980": {"epss_score": 0.0041, "epss_percentile": 0.60812}, "CVE-2010-3981": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-3982": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2010-3983": {"epss_score": 0.0049, "epss_percentile": 0.64924}, "CVE-2010-3984": {"epss_score": 0.07593, "epss_percentile": 0.91559}, "CVE-2010-3985": {"epss_score": 0.00851, "epss_percentile": 0.74403}, "CVE-2010-3986": {"epss_score": 0.00873, "epss_percentile": 0.74753}, "CVE-2010-3987": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2010-3988": {"epss_score": 0.00329, "epss_percentile": 0.55382}, "CVE-2010-3989": {"epss_score": 0.0013, "epss_percentile": 0.33261}, "CVE-2010-3990": {"epss_score": 0.01059, "epss_percentile": 0.77155}, "CVE-2010-3991": {"epss_score": 0.00701, "epss_percentile": 0.71497}, "CVE-2010-3992": {"epss_score": 0.00211, "epss_percentile": 0.43696}, "CVE-2010-3993": {"epss_score": 0.00668, "epss_percentile": 0.70742}, "CVE-2010-3994": {"epss_score": 0.00756, "epss_percentile": 0.72735}, "CVE-2010-3996": {"epss_score": 0.00047, "epss_percentile": 0.14694}, "CVE-2010-3998": {"epss_score": 0.00051, "epss_percentile": 0.16123}, "CVE-2010-3999": {"epss_score": 0.00047, "epss_percentile": 0.14783}, "CVE-2010-4000": {"epss_score": 0.00046, "epss_percentile": 0.14356}, "CVE-2010-4001": {"epss_score": 0.00056, "epss_percentile": 0.17911}, "CVE-2010-4005": {"epss_score": 0.00112, "epss_percentile": 0.30493}, "CVE-2010-4006": {"epss_score": 0.01376, "epss_percentile": 0.79834}, "CVE-2010-4007": {"epss_score": 0.00328, "epss_percentile": 0.55264}, "CVE-2010-4008": {"epss_score": 0.00756, "epss_percentile": 0.72739}, "CVE-2010-4009": {"epss_score": 0.03335, "epss_percentile": 0.86933}, "CVE-2010-4010": {"epss_score": 0.01314, "epss_percentile": 0.79397}, "CVE-2010-4011": {"epss_score": 0.00153, "epss_percentile": 0.36612}, "CVE-2010-4012": {"epss_score": 0.00039, "epss_percentile": 0.11472}, "CVE-2010-4013": {"epss_score": 0.00717, "epss_percentile": 0.71877}, "CVE-2010-4015": {"epss_score": 0.0322, "epss_percentile": 0.86672}, "CVE-2010-4020": {"epss_score": 0.00535, "epss_percentile": 0.66822}, "CVE-2010-4021": {"epss_score": 0.0047, "epss_percentile": 0.63975}, "CVE-2010-4022": {"epss_score": 0.08988, "epss_percentile": 0.92354}, "CVE-2010-4023": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2010-4024": {"epss_score": 0.00119, "epss_percentile": 0.31682}, "CVE-2010-4025": {"epss_score": 0.06682, "epss_percentile": 0.90939}, "CVE-2010-4026": {"epss_score": 0.00062, "epss_percentile": 0.19643}, "CVE-2010-4027": {"epss_score": 0.00062, "epss_percentile": 0.19643}, "CVE-2010-4028": {"epss_score": 0.00984, "epss_percentile": 0.76312}, "CVE-2010-4029": {"epss_score": 0.01857, "epss_percentile": 0.82576}, "CVE-2010-4030": {"epss_score": 0.00843, "epss_percentile": 0.74249}, "CVE-2010-4031": {"epss_score": 0.00178, "epss_percentile": 0.39694}, "CVE-2010-4032": {"epss_score": 0.00169, "epss_percentile": 0.38611}, "CVE-2010-4033": {"epss_score": 0.00575, "epss_percentile": 0.68114}, "CVE-2010-4034": {"epss_score": 0.0281, "epss_percentile": 0.85716}, "CVE-2010-4035": {"epss_score": 0.0281, "epss_percentile": 0.85716}, "CVE-2010-4036": {"epss_score": 0.0113, "epss_percentile": 0.77849}, "CVE-2010-4037": {"epss_score": 0.00315, "epss_percentile": 0.5417}, "CVE-2010-4038": {"epss_score": 0.01945, "epss_percentile": 0.83}, "CVE-2010-4039": {"epss_score": 0.00681, "epss_percentile": 0.71054}, "CVE-2010-4040": {"epss_score": 0.00599, "epss_percentile": 0.68793}, "CVE-2010-4041": {"epss_score": 0.00836, "epss_percentile": 0.74142}, "CVE-2010-4042": {"epss_score": 0.01947, "epss_percentile": 0.83005}, "CVE-2010-4043": {"epss_score": 0.00917, "epss_percentile": 0.75433}, "CVE-2010-4044": {"epss_score": 0.00735, "epss_percentile": 0.72287}, "CVE-2010-4045": {"epss_score": 0.04521, "epss_percentile": 0.88799}, "CVE-2010-4046": {"epss_score": 0.00777, "epss_percentile": 0.73116}, "CVE-2010-4047": {"epss_score": 0.00501, "epss_percentile": 0.65332}, "CVE-2010-4048": {"epss_score": 0.00371, "epss_percentile": 0.58344}, "CVE-2010-4049": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2010-4050": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2010-4051": {"epss_score": 0.04658, "epss_percentile": 0.88975}, "CVE-2010-4052": {"epss_score": 0.09951, "epss_percentile": 0.92786}, "CVE-2010-4053": {"epss_score": 0.06009, "epss_percentile": 0.90402}, "CVE-2010-4054": {"epss_score": 0.00476, "epss_percentile": 0.6429}, "CVE-2010-4055": {"epss_score": 0.18912, "epss_percentile": 0.95096}, "CVE-2010-4056": {"epss_score": 0.08775, "epss_percentile": 0.9225}, "CVE-2010-4057": {"epss_score": 0.18912, "epss_percentile": 0.95096}, "CVE-2010-4068": {"epss_score": 0.00193, "epss_percentile": 0.41427}, "CVE-2010-4069": {"epss_score": 0.08687, "epss_percentile": 0.92203}, "CVE-2010-4070": {"epss_score": 0.0805, "epss_percentile": 0.91853}, "CVE-2010-4071": {"epss_score": 0.00451, "epss_percentile": 0.63125}, "CVE-2010-4072": {"epss_score": 0.00096, "epss_percentile": 0.27241}, "CVE-2010-4073": {"epss_score": 0.00277, "epss_percentile": 0.50785}, "CVE-2010-4074": {"epss_score": 0.00075, "epss_percentile": 0.23069}, "CVE-2010-4075": {"epss_score": 0.00087, "epss_percentile": 0.25456}, "CVE-2010-4076": {"epss_score": 0.0006, "epss_percentile": 0.18931}, "CVE-2010-4077": {"epss_score": 0.00482, "epss_percentile": 0.64527}, "CVE-2010-4078": {"epss_score": 0.00072, "epss_percentile": 0.22247}, "CVE-2010-4079": {"epss_score": 0.00075, "epss_percentile": 0.23069}, "CVE-2010-4080": {"epss_score": 0.00087, "epss_percentile": 0.25456}, "CVE-2010-4081": {"epss_score": 0.00087, "epss_percentile": 0.25456}, "CVE-2010-4082": {"epss_score": 0.0007, "epss_percentile": 0.21642}, "CVE-2010-4083": {"epss_score": 0.00087, "epss_percentile": 0.25456}, "CVE-2010-4084": {"epss_score": 0.0613, "epss_percentile": 0.90501}, "CVE-2010-4085": {"epss_score": 0.0613, "epss_percentile": 0.90501}, "CVE-2010-4086": {"epss_score": 0.06177, "epss_percentile": 0.90535}, "CVE-2010-4087": {"epss_score": 0.08371, "epss_percentile": 0.92015}, "CVE-2010-4088": {"epss_score": 0.06177, "epss_percentile": 0.90535}, "CVE-2010-4089": {"epss_score": 0.08371, "epss_percentile": 0.92015}, "CVE-2010-4090": {"epss_score": 0.0613, "epss_percentile": 0.90501}, "CVE-2010-4091": {"epss_score": 0.41046, "epss_percentile": 0.97251}, "CVE-2010-4092": {"epss_score": 0.03998, "epss_percentile": 0.88085}, "CVE-2010-4093": {"epss_score": 0.08015, "epss_percentile": 0.91829}, "CVE-2010-4094": {"epss_score": 0.84158, "epss_percentile": 0.99276}, "CVE-2010-4095": {"epss_score": 0.00391, "epss_percentile": 0.59586}, "CVE-2010-4096": {"epss_score": 0.0017, "epss_percentile": 0.38708}, "CVE-2010-4097": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2010-4098": {"epss_score": 0.01621, "epss_percentile": 0.81395}, "CVE-2010-4099": {"epss_score": 0.01659, "epss_percentile": 0.81615}, "CVE-2010-4100": {"epss_score": 0.01059, "epss_percentile": 0.77155}, "CVE-2010-4101": {"epss_score": 0.00843, "epss_percentile": 0.74249}, "CVE-2010-4102": {"epss_score": 0.01059, "epss_percentile": 0.77155}, "CVE-2010-4103": {"epss_score": 0.01069, "epss_percentile": 0.77251}, "CVE-2010-4104": {"epss_score": 0.00947, "epss_percentile": 0.75819}, "CVE-2010-4105": {"epss_score": 0.0046, "epss_percentile": 0.63511}, "CVE-2010-4106": {"epss_score": 0.00112, "epss_percentile": 0.30418}, "CVE-2010-4107": {"epss_score": 0.29972, "epss_percentile": 0.96491}, "CVE-2010-4108": {"epss_score": 0.00368, "epss_percentile": 0.58221}, "CVE-2010-4109": {"epss_score": 0.00701, "epss_percentile": 0.71497}, "CVE-2010-4110": {"epss_score": 0.0005, "epss_percentile": 0.15902}, "CVE-2010-4111": {"epss_score": 0.00365, "epss_percentile": 0.57964}, "CVE-2010-4112": {"epss_score": 0.01059, "epss_percentile": 0.77155}, "CVE-2010-4113": {"epss_score": 0.17568, "epss_percentile": 0.94868}, "CVE-2010-4114": {"epss_score": 0.00669, "epss_percentile": 0.70753}, "CVE-2010-4115": {"epss_score": 0.01641, "epss_percentile": 0.81506}, "CVE-2010-4116": {"epss_score": 0.17394, "epss_percentile": 0.94844}, "CVE-2010-4120": {"epss_score": 0.04034, "epss_percentile": 0.88155}, "CVE-2010-4121": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2010-4142": {"epss_score": 0.49079, "epss_percentile": 0.97666}, "CVE-2010-4143": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2010-4144": {"epss_score": 0.00887, "epss_percentile": 0.74991}, "CVE-2010-4145": {"epss_score": 0.05231, "epss_percentile": 0.89642}, "CVE-2010-4146": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2010-4147": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2010-4148": {"epss_score": 0.0038, "epss_percentile": 0.58958}, "CVE-2010-4149": {"epss_score": 0.00278, "epss_percentile": 0.50892}, "CVE-2010-4150": {"epss_score": 0.16659, "epss_percentile": 0.94709}, "CVE-2010-4151": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-4152": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2010-4153": {"epss_score": 0.00183, "epss_percentile": 0.40308}, "CVE-2010-4154": {"epss_score": 0.00513, "epss_percentile": 0.65918}, "CVE-2010-4155": {"epss_score": 0.00374, "epss_percentile": 0.5858}, "CVE-2010-4156": {"epss_score": 0.10111, "epss_percentile": 0.92854}, "CVE-2010-4157": {"epss_score": 0.00112, "epss_percentile": 0.30569}, "CVE-2010-4158": {"epss_score": 0.00212, "epss_percentile": 0.43724}, "CVE-2010-4159": {"epss_score": 0.00104, "epss_percentile": 0.29216}, "CVE-2010-4160": {"epss_score": 0.00162, "epss_percentile": 0.37703}, "CVE-2010-4161": {"epss_score": 0.0012, "epss_percentile": 0.31737}, "CVE-2010-4162": {"epss_score": 0.00082, "epss_percentile": 0.24507}, "CVE-2010-4163": {"epss_score": 0.00082, "epss_percentile": 0.24507}, "CVE-2010-4164": {"epss_score": 0.01996, "epss_percentile": 0.83194}, "CVE-2010-4165": {"epss_score": 0.00326, "epss_percentile": 0.55037}, "CVE-2010-4166": {"epss_score": 0.00024, "epss_percentile": 0.05845}, "CVE-2010-4167": {"epss_score": 0.00104, "epss_percentile": 0.29183}, "CVE-2010-4168": {"epss_score": 0.02843, "epss_percentile": 0.85813}, "CVE-2010-4169": {"epss_score": 0.00049, "epss_percentile": 0.15358}, "CVE-2010-4170": {"epss_score": 0.24078, "epss_percentile": 0.95868}, "CVE-2010-4171": {"epss_score": 0.00063, "epss_percentile": 0.19844}, "CVE-2010-4172": {"epss_score": 0.29935, "epss_percentile": 0.96486}, "CVE-2010-4173": {"epss_score": 0.00085, "epss_percentile": 0.25136}, "CVE-2010-4175": {"epss_score": 0.00072, "epss_percentile": 0.22307}, "CVE-2010-4176": {"epss_score": 0.00153, "epss_percentile": 0.36619}, "CVE-2010-4177": {"epss_score": 0.00067, "epss_percentile": 0.20974}, "CVE-2010-4178": {"epss_score": 0.00218, "epss_percentile": 0.44353}, "CVE-2010-4179": {"epss_score": 0.00487, "epss_percentile": 0.64823}, "CVE-2010-4180": {"epss_score": 0.03846, "epss_percentile": 0.87842}, "CVE-2010-4181": {"epss_score": 0.08297, "epss_percentile": 0.91976}, "CVE-2010-4182": {"epss_score": 0.34258, "epss_percentile": 0.96837}, "CVE-2010-4183": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-4184": {"epss_score": 0.00518, "epss_percentile": 0.66096}, "CVE-2010-4185": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2010-4186": {"epss_score": 0.0049, "epss_percentile": 0.64915}, "CVE-2010-4187": {"epss_score": 0.04841, "epss_percentile": 0.89201}, "CVE-2010-4188": {"epss_score": 0.07095, "epss_percentile": 0.91245}, "CVE-2010-4189": {"epss_score": 0.04333, "epss_percentile": 0.88561}, "CVE-2010-4190": {"epss_score": 0.04333, "epss_percentile": 0.88561}, "CVE-2010-4191": {"epss_score": 0.04945, "epss_percentile": 0.89317}, "CVE-2010-4192": {"epss_score": 0.04333, "epss_percentile": 0.88561}, "CVE-2010-4193": {"epss_score": 0.10209, "epss_percentile": 0.92895}, "CVE-2010-4194": {"epss_score": 0.10209, "epss_percentile": 0.92895}, "CVE-2010-4195": {"epss_score": 0.10209, "epss_percentile": 0.92895}, "CVE-2010-4196": {"epss_score": 0.10209, "epss_percentile": 0.92895}, "CVE-2010-4197": {"epss_score": 0.06283, "epss_percentile": 0.9064}, "CVE-2010-4198": {"epss_score": 0.01284, "epss_percentile": 0.79167}, "CVE-2010-4199": {"epss_score": 0.0081, "epss_percentile": 0.73716}, "CVE-2010-4201": {"epss_score": 0.00491, "epss_percentile": 0.64944}, "CVE-2010-4202": {"epss_score": 0.00888, "epss_percentile": 0.75}, "CVE-2010-4203": {"epss_score": 0.08115, "epss_percentile": 0.91887}, "CVE-2010-4204": {"epss_score": 0.04352, "epss_percentile": 0.88586}, "CVE-2010-4205": {"epss_score": 0.0086, "epss_percentile": 0.74531}, "CVE-2010-4206": {"epss_score": 0.02948, "epss_percentile": 0.86049}, "CVE-2010-4207": {"epss_score": 0.01873, "epss_percentile": 0.82644}, "CVE-2010-4208": {"epss_score": 0.01618, "epss_percentile": 0.8137}, "CVE-2010-4209": {"epss_score": 0.01868, "epss_percentile": 0.82622}, "CVE-2010-4210": {"epss_score": 0.00257, "epss_percentile": 0.4888}, "CVE-2010-4211": {"epss_score": 0.00085, "epss_percentile": 0.25125}, "CVE-2010-4212": {"epss_score": 0.00069, "epss_percentile": 0.21579}, "CVE-2010-4213": {"epss_score": 0.00291, "epss_percentile": 0.52169}, "CVE-2010-4214": {"epss_score": 0.00291, "epss_percentile": 0.52169}, "CVE-2010-4215": {"epss_score": 0.00575, "epss_percentile": 0.681}, "CVE-2010-4216": {"epss_score": 0.0088, "epss_percentile": 0.74854}, "CVE-2010-4217": {"epss_score": 0.01419, "epss_percentile": 0.80162}, "CVE-2010-4218": {"epss_score": 0.01334, "epss_percentile": 0.79537}, "CVE-2010-4219": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2010-4220": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2010-4221": {"epss_score": 0.91093, "epss_percentile": 0.99619}, "CVE-2010-4225": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2010-4226": {"epss_score": 0.00568, "epss_percentile": 0.67899}, "CVE-2010-4227": {"epss_score": 0.41379, "epss_percentile": 0.9727}, "CVE-2010-4228": {"epss_score": 0.31179, "epss_percentile": 0.96599}, "CVE-2010-4229": {"epss_score": 0.34185, "epss_percentile": 0.9683}, "CVE-2010-4230": {"epss_score": 0.20632, "epss_percentile": 0.95391}, "CVE-2010-4231": {"epss_score": 0.0406, "epss_percentile": 0.88188}, "CVE-2010-4232": {"epss_score": 0.04622, "epss_percentile": 0.88934}, "CVE-2010-4233": {"epss_score": 0.02569, "epss_percentile": 0.85124}, "CVE-2010-4234": {"epss_score": 0.04968, "epss_percentile": 0.89344}, "CVE-2010-4235": {"epss_score": 0.04348, "epss_percentile": 0.8858}, "CVE-2010-4236": {"epss_score": 0.00365, "epss_percentile": 0.57997}, "CVE-2010-4237": {"epss_score": 0.00307, "epss_percentile": 0.53562}, "CVE-2010-4238": {"epss_score": 0.00395, "epss_percentile": 0.59848}, "CVE-2010-4239": {"epss_score": 0.55795, "epss_percentile": 0.97996}, "CVE-2010-4240": {"epss_score": 0.00522, "epss_percentile": 0.66272}, "CVE-2010-4241": {"epss_score": 0.00303, "epss_percentile": 0.53215}, "CVE-2010-4242": {"epss_score": 0.00116, "epss_percentile": 0.31154}, "CVE-2010-4243": {"epss_score": 0.00158, "epss_percentile": 0.37154}, "CVE-2010-4245": {"epss_score": 0.00344, "epss_percentile": 0.56505}, "CVE-2010-4246": {"epss_score": 0.00333, "epss_percentile": 0.55644}, "CVE-2010-4247": {"epss_score": 0.00615, "epss_percentile": 0.69307}, "CVE-2010-4248": {"epss_score": 0.00037, "epss_percentile": 0.10732}, "CVE-2010-4249": {"epss_score": 0.00087, "epss_percentile": 0.25565}, "CVE-2010-4250": {"epss_score": 0.00291, "epss_percentile": 0.52188}, "CVE-2010-4251": {"epss_score": 0.0215, "epss_percentile": 0.83778}, "CVE-2010-4252": {"epss_score": 0.0164, "epss_percentile": 0.81499}, "CVE-2010-4253": {"epss_score": 0.07126, "epss_percentile": 0.91266}, "CVE-2010-4254": {"epss_score": 0.1991, "epss_percentile": 0.95258}, "CVE-2010-4255": {"epss_score": 0.00819, "epss_percentile": 0.73865}, "CVE-2010-4256": {"epss_score": 0.00058, "epss_percentile": 0.18454}, "CVE-2010-4257": {"epss_score": 0.03296, "epss_percentile": 0.86858}, "CVE-2010-4258": {"epss_score": 0.05856, "epss_percentile": 0.90267}, "CVE-2010-4259": {"epss_score": 0.23143, "epss_percentile": 0.9574}, "CVE-2010-4260": {"epss_score": 0.06315, "epss_percentile": 0.90666}, "CVE-2010-4261": {"epss_score": 0.08527, "epss_percentile": 0.92104}, "CVE-2010-4262": {"epss_score": 0.05892, "epss_percentile": 0.903}, "CVE-2010-4263": {"epss_score": 0.05083, "epss_percentile": 0.89474}, "CVE-2010-4264": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2010-4265": {"epss_score": 0.01031, "epss_percentile": 0.76851}, "CVE-2010-4266": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2010-4267": {"epss_score": 0.10217, "epss_percentile": 0.92898}, "CVE-2010-4268": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-4269": {"epss_score": 0.0033, "epss_percentile": 0.5543}, "CVE-2010-4270": {"epss_score": 0.01011, "epss_percentile": 0.76614}, "CVE-2010-4271": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-4272": {"epss_score": 0.01048, "epss_percentile": 0.77053}, "CVE-2010-4273": {"epss_score": 0.00374, "epss_percentile": 0.58574}, "CVE-2010-4274": {"epss_score": 0.00052, "epss_percentile": 0.16534}, "CVE-2010-4275": {"epss_score": 0.00144, "epss_percentile": 0.35349}, "CVE-2010-4276": {"epss_score": 0.0278, "epss_percentile": 0.85648}, "CVE-2010-4277": {"epss_score": 0.00153, "epss_percentile": 0.36619}, "CVE-2010-4278": {"epss_score": 0.0861, "epss_percentile": 0.9215}, "CVE-2010-4279": {"epss_score": 0.85037, "epss_percentile": 0.99314}, "CVE-2010-4280": {"epss_score": 0.06203, "epss_percentile": 0.90563}, "CVE-2010-4281": {"epss_score": 0.05053, "epss_percentile": 0.89444}, "CVE-2010-4282": {"epss_score": 0.04998, "epss_percentile": 0.89375}, "CVE-2010-4283": {"epss_score": 0.05639, "epss_percentile": 0.90074}, "CVE-2010-4284": {"epss_score": 0.02887, "epss_percentile": 0.85913}, "CVE-2010-4294": {"epss_score": 0.06071, "epss_percentile": 0.90452}, "CVE-2010-4295": {"epss_score": 0.00055, "epss_percentile": 0.17423}, "CVE-2010-4296": {"epss_score": 0.00065, "epss_percentile": 0.20541}, "CVE-2010-4297": {"epss_score": 0.03126, "epss_percentile": 0.86456}, "CVE-2010-4298": {"epss_score": 0.00119, "epss_percentile": 0.3154}, "CVE-2010-4299": {"epss_score": 0.0941, "epss_percentile": 0.92536}, "CVE-2010-4300": {"epss_score": 0.10159, "epss_percentile": 0.92869}, "CVE-2010-4301": {"epss_score": 0.05697, "epss_percentile": 0.90128}, "CVE-2010-4302": {"epss_score": 0.00062, "epss_percentile": 0.19731}, "CVE-2010-4303": {"epss_score": 0.00047, "epss_percentile": 0.14758}, "CVE-2010-4304": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2010-4305": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2010-4306": {"epss_score": 0.04945, "epss_percentile": 0.89317}, "CVE-2010-4307": {"epss_score": 0.06355, "epss_percentile": 0.90694}, "CVE-2010-4308": {"epss_score": 0.04418, "epss_percentile": 0.88667}, "CVE-2010-4309": {"epss_score": 0.04418, "epss_percentile": 0.88667}, "CVE-2010-4311": {"epss_score": 0.00257, "epss_percentile": 0.48947}, "CVE-2010-4312": {"epss_score": 0.01735, "epss_percentile": 0.82006}, "CVE-2010-4313": {"epss_score": 0.02739, "epss_percentile": 0.85554}, "CVE-2010-4314": {"epss_score": 0.02025, "epss_percentile": 0.83314}, "CVE-2010-4321": {"epss_score": 0.56603, "epss_percentile": 0.9803}, "CVE-2010-4322": {"epss_score": 0.00075, "epss_percentile": 0.2305}, "CVE-2010-4323": {"epss_score": 0.37156, "epss_percentile": 0.97023}, "CVE-2010-4324": {"epss_score": 0.01754, "epss_percentile": 0.82118}, "CVE-2010-4325": {"epss_score": 0.19925, "epss_percentile": 0.95263}, "CVE-2010-4326": {"epss_score": 0.28492, "epss_percentile": 0.96363}, "CVE-2010-4327": {"epss_score": 0.01287, "epss_percentile": 0.79193}, "CVE-2010-4328": {"epss_score": 0.44733, "epss_percentile": 0.97451}, "CVE-2010-4329": {"epss_score": 0.0061, "epss_percentile": 0.69157}, "CVE-2010-4330": {"epss_score": 0.06851, "epss_percentile": 0.91072}, "CVE-2010-4331": {"epss_score": 0.01371, "epss_percentile": 0.79808}, "CVE-2010-4332": {"epss_score": 0.02688, "epss_percentile": 0.85432}, "CVE-2010-4333": {"epss_score": 0.01767, "epss_percentile": 0.82176}, "CVE-2010-4334": {"epss_score": 0.00564, "epss_percentile": 0.67773}, "CVE-2010-4335": {"epss_score": 0.82639, "epss_percentile": 0.99203}, "CVE-2010-4336": {"epss_score": 0.01657, "epss_percentile": 0.81606}, "CVE-2010-4337": {"epss_score": 0.0003, "epss_percentile": 0.08145}, "CVE-2010-4338": {"epss_score": 0.00026, "epss_percentile": 0.06549}, "CVE-2010-4339": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-4340": {"epss_score": 0.00185, "epss_percentile": 0.40481}, "CVE-2010-4341": {"epss_score": 0.00166, "epss_percentile": 0.38168}, "CVE-2010-4342": {"epss_score": 0.01687, "epss_percentile": 0.8176}, "CVE-2010-4343": {"epss_score": 0.00073, "epss_percentile": 0.22488}, "CVE-2010-4344": {"epss_score": 0.61461, "epss_percentile": 0.98249}, "CVE-2010-4345": {"epss_score": 0.04024, "epss_percentile": 0.88137}, "CVE-2010-4346": {"epss_score": 0.00058, "epss_percentile": 0.18288}, "CVE-2010-4347": {"epss_score": 0.0841, "epss_percentile": 0.92036}, "CVE-2010-4348": {"epss_score": 0.11162, "epss_percentile": 0.9325}, "CVE-2010-4349": {"epss_score": 0.1183, "epss_percentile": 0.93489}, "CVE-2010-4350": {"epss_score": 0.10217, "epss_percentile": 0.92898}, "CVE-2010-4351": {"epss_score": 0.01318, "epss_percentile": 0.79422}, "CVE-2010-4352": {"epss_score": 0.00089, "epss_percentile": 0.25852}, "CVE-2010-4353": {"epss_score": 0.01187, "epss_percentile": 0.78356}, "CVE-2010-4354": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2010-4355": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2010-4356": {"epss_score": 0.00243, "epss_percentile": 0.47504}, "CVE-2010-4357": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-4358": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2010-4359": {"epss_score": 0.00145, "epss_percentile": 0.35456}, "CVE-2010-4360": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2010-4361": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-4362": {"epss_score": 0.00265, "epss_percentile": 0.49771}, "CVE-2010-4363": {"epss_score": 0.00716, "epss_percentile": 0.71856}, "CVE-2010-4364": {"epss_score": 0.00403, "epss_percentile": 0.60387}, "CVE-2010-4365": {"epss_score": 0.0013, "epss_percentile": 0.33292}, "CVE-2010-4366": {"epss_score": 0.00189, "epss_percentile": 0.40955}, "CVE-2010-4367": {"epss_score": 0.07265, "epss_percentile": 0.91358}, "CVE-2010-4368": {"epss_score": 0.01419, "epss_percentile": 0.8016}, "CVE-2010-4369": {"epss_score": 0.00179, "epss_percentile": 0.3975}, "CVE-2010-4370": {"epss_score": 0.06539, "epss_percentile": 0.90833}, "CVE-2010-4371": {"epss_score": 0.06684, "epss_percentile": 0.90942}, "CVE-2010-4372": {"epss_score": 0.00992, "epss_percentile": 0.76399}, "CVE-2010-4373": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2010-4374": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2010-4375": {"epss_score": 0.05206, "epss_percentile": 0.89609}, "CVE-2010-4376": {"epss_score": 0.05206, "epss_percentile": 0.89609}, "CVE-2010-4377": {"epss_score": 0.05834, "epss_percentile": 0.90247}, "CVE-2010-4378": {"epss_score": 0.03159, "epss_percentile": 0.86527}, "CVE-2010-4379": {"epss_score": 0.01304, "epss_percentile": 0.79318}, "CVE-2010-4380": {"epss_score": 0.01226, "epss_percentile": 0.78688}, "CVE-2010-4381": {"epss_score": 0.01226, "epss_percentile": 0.78688}, "CVE-2010-4382": {"epss_score": 0.01304, "epss_percentile": 0.79318}, "CVE-2010-4383": {"epss_score": 0.01304, "epss_percentile": 0.79318}, "CVE-2010-4384": {"epss_score": 0.0195, "epss_percentile": 0.83015}, "CVE-2010-4385": {"epss_score": 0.00992, "epss_percentile": 0.76399}, "CVE-2010-4386": {"epss_score": 0.04105, "epss_percentile": 0.88265}, "CVE-2010-4387": {"epss_score": 0.02647, "epss_percentile": 0.85337}, "CVE-2010-4388": {"epss_score": 0.00386, "epss_percentile": 0.59245}, "CVE-2010-4389": {"epss_score": 0.06898, "epss_percentile": 0.91102}, "CVE-2010-4390": {"epss_score": 0.01348, "epss_percentile": 0.79665}, "CVE-2010-4391": {"epss_score": 0.20632, "epss_percentile": 0.95391}, "CVE-2010-4392": {"epss_score": 0.05423, "epss_percentile": 0.89865}, "CVE-2010-4393": {"epss_score": 0.22458, "epss_percentile": 0.95637}, "CVE-2010-4394": {"epss_score": 0.01534, "epss_percentile": 0.80905}, "CVE-2010-4395": {"epss_score": 0.06898, "epss_percentile": 0.91102}, "CVE-2010-4396": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-4397": {"epss_score": 0.02624, "epss_percentile": 0.8526}, "CVE-2010-4398": {"epss_score": 0.11084, "epss_percentile": 0.93215}, "CVE-2010-4399": {"epss_score": 0.05629, "epss_percentile": 0.90067}, "CVE-2010-4400": {"epss_score": 0.00437, "epss_percentile": 0.62513}, "CVE-2010-4401": {"epss_score": 0.04956, "epss_percentile": 0.8933}, "CVE-2010-4402": {"epss_score": 0.00373, "epss_percentile": 0.58471}, "CVE-2010-4403": {"epss_score": 0.00285, "epss_percentile": 0.51638}, "CVE-2010-4404": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-4405": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-4406": {"epss_score": 0.01753, "epss_percentile": 0.82114}, "CVE-2010-4407": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-4408": {"epss_score": 0.01385, "epss_percentile": 0.79906}, "CVE-2010-4409": {"epss_score": 0.31591, "epss_percentile": 0.96629}, "CVE-2010-4410": {"epss_score": 0.01193, "epss_percentile": 0.78407}, "CVE-2010-4411": {"epss_score": 0.00985, "epss_percentile": 0.76321}, "CVE-2010-4412": {"epss_score": 0.00617, "epss_percentile": 0.69349}, "CVE-2010-4413": {"epss_score": 0.00971, "epss_percentile": 0.76121}, "CVE-2010-4414": {"epss_score": 0.00108, "epss_percentile": 0.29814}, "CVE-2010-4415": {"epss_score": 0.00059, "epss_percentile": 0.18683}, "CVE-2010-4416": {"epss_score": 0.02079, "epss_percentile": 0.83522}, "CVE-2010-4417": {"epss_score": 0.72458, "epss_percentile": 0.98711}, "CVE-2010-4418": {"epss_score": 0.01107, "epss_percentile": 0.77623}, "CVE-2010-4419": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2010-4420": {"epss_score": 0.00088, "epss_percentile": 0.25731}, "CVE-2010-4421": {"epss_score": 0.01203, "epss_percentile": 0.78494}, "CVE-2010-4422": {"epss_score": 0.01601, "epss_percentile": 0.81262}, "CVE-2010-4423": {"epss_score": 0.00113, "epss_percentile": 0.30617}, "CVE-2010-4424": {"epss_score": 0.01107, "epss_percentile": 0.77623}, "CVE-2010-4425": {"epss_score": 0.00406, "epss_percentile": 0.6054}, "CVE-2010-4426": {"epss_score": 0.0061, "epss_percentile": 0.69142}, "CVE-2010-4427": {"epss_score": 0.00349, "epss_percentile": 0.56881}, "CVE-2010-4428": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2010-4429": {"epss_score": 0.00349, "epss_percentile": 0.56881}, "CVE-2010-4430": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2010-4431": {"epss_score": 0.00054, "epss_percentile": 0.17147}, "CVE-2010-4432": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2010-4433": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2010-4434": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2010-4435": {"epss_score": 0.34982, "epss_percentile": 0.96882}, "CVE-2010-4436": {"epss_score": 0.00524, "epss_percentile": 0.66332}, "CVE-2010-4437": {"epss_score": 0.48894, "epss_percentile": 0.97658}, "CVE-2010-4438": {"epss_score": 0.00084, "epss_percentile": 0.24958}, "CVE-2010-4439": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2010-4440": {"epss_score": 0.00059, "epss_percentile": 0.18621}, "CVE-2010-4441": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2010-4442": {"epss_score": 0.00059, "epss_percentile": 0.18621}, "CVE-2010-4443": {"epss_score": 0.00059, "epss_percentile": 0.18621}, "CVE-2010-4444": {"epss_score": 0.01203, "epss_percentile": 0.78494}, "CVE-2010-4445": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2010-4446": {"epss_score": 0.00043, "epss_percentile": 0.13215}, "CVE-2010-4447": {"epss_score": 0.02296, "epss_percentile": 0.84297}, "CVE-2010-4448": {"epss_score": 0.02239, "epss_percentile": 0.84109}, "CVE-2010-4449": {"epss_score": 0.05813, "epss_percentile": 0.90227}, "CVE-2010-4450": {"epss_score": 0.00171, "epss_percentile": 0.38788}, "CVE-2010-4451": {"epss_score": 0.02099, "epss_percentile": 0.83596}, "CVE-2010-4452": {"epss_score": 0.82372, "epss_percentile": 0.99191}, "CVE-2010-4453": {"epss_score": 0.00483, "epss_percentile": 0.64592}, "CVE-2010-4454": {"epss_score": 0.07413, "epss_percentile": 0.9146}, "CVE-2010-4455": {"epss_score": 0.0061, "epss_percentile": 0.69142}, "CVE-2010-4456": {"epss_score": 0.00488, "epss_percentile": 0.64865}, "CVE-2010-4457": {"epss_score": 0.02031, "epss_percentile": 0.83333}, "CVE-2010-4458": {"epss_score": 0.00061, "epss_percentile": 0.19549}, "CVE-2010-4459": {"epss_score": 0.00049, "epss_percentile": 0.15442}, "CVE-2010-4460": {"epss_score": 0.00063, "epss_percentile": 0.19859}, "CVE-2010-4461": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2010-4462": {"epss_score": 0.07413, "epss_percentile": 0.9146}, "CVE-2010-4463": {"epss_score": 0.01103, "epss_percentile": 0.77592}, "CVE-2010-4464": {"epss_score": 0.00562, "epss_percentile": 0.67686}, "CVE-2010-4465": {"epss_score": 0.08472, "epss_percentile": 0.9207}, "CVE-2010-4466": {"epss_score": 0.0229, "epss_percentile": 0.84282}, "CVE-2010-4467": {"epss_score": 0.03506, "epss_percentile": 0.87259}, "CVE-2010-4468": {"epss_score": 0.02148, "epss_percentile": 0.83772}, "CVE-2010-4469": {"epss_score": 0.03598, "epss_percentile": 0.87407}, "CVE-2010-4470": {"epss_score": 0.08078, "epss_percentile": 0.9187}, "CVE-2010-4471": {"epss_score": 0.02795, "epss_percentile": 0.85677}, "CVE-2010-4472": {"epss_score": 0.06946, "epss_percentile": 0.91133}, "CVE-2010-4473": {"epss_score": 0.07413, "epss_percentile": 0.9146}, "CVE-2010-4474": {"epss_score": 0.00057, "epss_percentile": 0.17984}, "CVE-2010-4475": {"epss_score": 0.02758, "epss_percentile": 0.85594}, "CVE-2010-4476": {"epss_score": 0.45147, "epss_percentile": 0.97475}, "CVE-2010-4478": {"epss_score": 0.00805, "epss_percentile": 0.73628}, "CVE-2010-4479": {"epss_score": 0.05472, "epss_percentile": 0.8991}, "CVE-2010-4480": {"epss_score": 0.07454, "epss_percentile": 0.9148}, "CVE-2010-4481": {"epss_score": 0.00694, "epss_percentile": 0.71337}, "CVE-2010-4482": {"epss_score": 0.00203, "epss_percentile": 0.42493}, "CVE-2010-4483": {"epss_score": 0.00272, "epss_percentile": 0.50394}, "CVE-2010-4484": {"epss_score": 0.00193, "epss_percentile": 0.41394}, "CVE-2010-4485": {"epss_score": 0.00633, "epss_percentile": 0.69758}, "CVE-2010-4486": {"epss_score": 0.0198, "epss_percentile": 0.83136}, "CVE-2010-4487": {"epss_score": 0.00731, "epss_percentile": 0.72172}, "CVE-2010-4488": {"epss_score": 0.01012, "epss_percentile": 0.76623}, "CVE-2010-4489": {"epss_score": 0.00763, "epss_percentile": 0.72878}, "CVE-2010-4490": {"epss_score": 0.01797, "epss_percentile": 0.8231}, "CVE-2010-4491": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2010-4492": {"epss_score": 0.01918, "epss_percentile": 0.82876}, "CVE-2010-4493": {"epss_score": 0.01582, "epss_percentile": 0.8114}, "CVE-2010-4494": {"epss_score": 0.01264, "epss_percentile": 0.78994}, "CVE-2010-4495": {"epss_score": 0.01057, "epss_percentile": 0.77132}, "CVE-2010-4496": {"epss_score": 0.00836, "epss_percentile": 0.74149}, "CVE-2010-4497": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2010-4498": {"epss_score": 0.01099, "epss_percentile": 0.77556}, "CVE-2010-4499": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2010-4500": {"epss_score": 0.00342, "epss_percentile": 0.56371}, "CVE-2010-4502": {"epss_score": 0.00188, "epss_percentile": 0.40876}, "CVE-2010-4503": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-4504": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-4505": {"epss_score": 0.00348, "epss_percentile": 0.56809}, "CVE-2010-4506": {"epss_score": 0.0034, "epss_percentile": 0.56267}, "CVE-2010-4507": {"epss_score": 0.0019, "epss_percentile": 0.41133}, "CVE-2010-4508": {"epss_score": 0.00484, "epss_percentile": 0.64641}, "CVE-2010-4509": {"epss_score": 0.00458, "epss_percentile": 0.63423}, "CVE-2010-4511": {"epss_score": 0.00487, "epss_percentile": 0.64818}, "CVE-2010-4512": {"epss_score": 0.00117, "epss_percentile": 0.31282}, "CVE-2010-4513": {"epss_score": 0.0116, "epss_percentile": 0.78134}, "CVE-2010-4514": {"epss_score": 0.0278, "epss_percentile": 0.85648}, "CVE-2010-4515": {"epss_score": 0.00411, "epss_percentile": 0.60897}, "CVE-2010-4516": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-4517": {"epss_score": 0.00196, "epss_percentile": 0.41763}, "CVE-2010-4518": {"epss_score": 0.00476, "epss_percentile": 0.6428}, "CVE-2010-4519": {"epss_score": 0.00098, "epss_percentile": 0.27762}, "CVE-2010-4520": {"epss_score": 0.00231, "epss_percentile": 0.45791}, "CVE-2010-4521": {"epss_score": 0.00281, "epss_percentile": 0.51126}, "CVE-2010-4522": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-4523": {"epss_score": 0.00262, "epss_percentile": 0.49377}, "CVE-2010-4524": {"epss_score": 0.01156, "epss_percentile": 0.78082}, "CVE-2010-4525": {"epss_score": 0.00108, "epss_percentile": 0.29903}, "CVE-2010-4526": {"epss_score": 0.02057, "epss_percentile": 0.83428}, "CVE-2010-4527": {"epss_score": 0.0005, "epss_percentile": 0.15671}, "CVE-2010-4528": {"epss_score": 0.02691, "epss_percentile": 0.85438}, "CVE-2010-4529": {"epss_score": 0.0005, "epss_percentile": 0.15782}, "CVE-2010-4530": {"epss_score": 0.00225, "epss_percentile": 0.45228}, "CVE-2010-4531": {"epss_score": 0.00284, "epss_percentile": 0.51416}, "CVE-2010-4532": {"epss_score": 0.00231, "epss_percentile": 0.45838}, "CVE-2010-4533": {"epss_score": 0.00276, "epss_percentile": 0.50765}, "CVE-2010-4534": {"epss_score": 0.00553, "epss_percentile": 0.6742}, "CVE-2010-4535": {"epss_score": 0.04746, "epss_percentile": 0.89095}, "CVE-2010-4536": {"epss_score": 0.03881, "epss_percentile": 0.87896}, "CVE-2010-4537": {"epss_score": 0.00485, "epss_percentile": 0.64732}, "CVE-2010-4538": {"epss_score": 0.50594, "epss_percentile": 0.97741}, "CVE-2010-4539": {"epss_score": 0.01026, "epss_percentile": 0.76798}, "CVE-2010-4540": {"epss_score": 0.04891, "epss_percentile": 0.89264}, "CVE-2010-4541": {"epss_score": 0.04027, "epss_percentile": 0.88144}, "CVE-2010-4542": {"epss_score": 0.03676, "epss_percentile": 0.87553}, "CVE-2010-4543": {"epss_score": 0.22756, "epss_percentile": 0.95678}, "CVE-2010-4544": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2010-4545": {"epss_score": 0.00406, "epss_percentile": 0.60564}, "CVE-2010-4546": {"epss_score": 0.00137, "epss_percentile": 0.34208}, "CVE-2010-4547": {"epss_score": 0.00137, "epss_percentile": 0.34208}, "CVE-2010-4548": {"epss_score": 0.00406, "epss_percentile": 0.60564}, "CVE-2010-4549": {"epss_score": 0.00137, "epss_percentile": 0.34208}, "CVE-2010-4550": {"epss_score": 0.00645, "epss_percentile": 0.70112}, "CVE-2010-4551": {"epss_score": 0.00406, "epss_percentile": 0.60564}, "CVE-2010-4552": {"epss_score": 0.00645, "epss_percentile": 0.70112}, "CVE-2010-4553": {"epss_score": 0.00645, "epss_percentile": 0.70112}, "CVE-2010-4554": {"epss_score": 0.00472, "epss_percentile": 0.64062}, "CVE-2010-4555": {"epss_score": 0.00895, "epss_percentile": 0.75092}, "CVE-2010-4556": {"epss_score": 0.12682, "epss_percentile": 0.93748}, "CVE-2010-4557": {"epss_score": 0.45054, "epss_percentile": 0.9747}, "CVE-2010-4558": {"epss_score": 0.00619, "epss_percentile": 0.69401}, "CVE-2010-4562": {"epss_score": 0.08272, "epss_percentile": 0.91962}, "CVE-2010-4563": {"epss_score": 0.00254, "epss_percentile": 0.48543}, "CVE-2010-4565": {"epss_score": 0.0009, "epss_percentile": 0.26136}, "CVE-2010-4566": {"epss_score": 0.71849, "epss_percentile": 0.98683}, "CVE-2010-4567": {"epss_score": 0.0083, "epss_percentile": 0.74027}, "CVE-2010-4568": {"epss_score": 0.01868, "epss_percentile": 0.82621}, "CVE-2010-4569": {"epss_score": 0.00733, "epss_percentile": 0.72213}, "CVE-2010-4570": {"epss_score": 0.00733, "epss_percentile": 0.72213}, "CVE-2010-4572": {"epss_score": 0.0083, "epss_percentile": 0.74027}, "CVE-2010-4573": {"epss_score": 0.02037, "epss_percentile": 0.83356}, "CVE-2010-4574": {"epss_score": 0.00829, "epss_percentile": 0.74016}, "CVE-2010-4575": {"epss_score": 0.01343, "epss_percentile": 0.79607}, "CVE-2010-4576": {"epss_score": 0.02187, "epss_percentile": 0.83922}, "CVE-2010-4577": {"epss_score": 0.04266, "epss_percentile": 0.8847}, "CVE-2010-4578": {"epss_score": 0.01771, "epss_percentile": 0.82199}, "CVE-2010-4579": {"epss_score": 0.00701, "epss_percentile": 0.71497}, "CVE-2010-4580": {"epss_score": 0.00722, "epss_percentile": 0.71995}, "CVE-2010-4581": {"epss_score": 0.0046, "epss_percentile": 0.6353}, "CVE-2010-4582": {"epss_score": 0.00283, "epss_percentile": 0.51408}, "CVE-2010-4583": {"epss_score": 0.00329, "epss_percentile": 0.55384}, "CVE-2010-4584": {"epss_score": 0.00177, "epss_percentile": 0.39537}, "CVE-2010-4585": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2010-4586": {"epss_score": 0.0046, "epss_percentile": 0.6353}, "CVE-2010-4587": {"epss_score": 0.00574, "epss_percentile": 0.68085}, "CVE-2010-4588": {"epss_score": 0.6564, "epss_percentile": 0.98429}, "CVE-2010-4589": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2010-4590": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2010-4591": {"epss_score": 0.00053, "epss_percentile": 0.16889}, "CVE-2010-4592": {"epss_score": 0.00603, "epss_percentile": 0.68939}, "CVE-2010-4593": {"epss_score": 0.00406, "epss_percentile": 0.60564}, "CVE-2010-4594": {"epss_score": 0.00535, "epss_percentile": 0.66823}, "CVE-2010-4595": {"epss_score": 0.00142, "epss_percentile": 0.35029}, "CVE-2010-4596": {"epss_score": 0.05834, "epss_percentile": 0.90247}, "CVE-2010-4597": {"epss_score": 0.40922, "epss_percentile": 0.97244}, "CVE-2010-4598": {"epss_score": 0.01277, "epss_percentile": 0.7912}, "CVE-2010-4599": {"epss_score": 0.0006, "epss_percentile": 0.18986}, "CVE-2010-4600": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2010-4601": {"epss_score": 0.00494, "epss_percentile": 0.65096}, "CVE-2010-4602": {"epss_score": 0.00179, "epss_percentile": 0.398}, "CVE-2010-4603": {"epss_score": 0.00673, "epss_percentile": 0.70828}, "CVE-2010-4604": {"epss_score": 0.00305, "epss_percentile": 0.53334}, "CVE-2010-4605": {"epss_score": 0.00161, "epss_percentile": 0.37576}, "CVE-2010-4606": {"epss_score": 0.03478, "epss_percentile": 0.87214}, "CVE-2010-4607": {"epss_score": 0.0209, "epss_percentile": 0.83565}, "CVE-2010-4608": {"epss_score": 0.01984, "epss_percentile": 0.83151}, "CVE-2010-4609": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2010-4610": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2010-4611": {"epss_score": 0.01984, "epss_percentile": 0.83151}, "CVE-2010-4612": {"epss_score": 0.01186, "epss_percentile": 0.78351}, "CVE-2010-4613": {"epss_score": 0.0155, "epss_percentile": 0.80984}, "CVE-2010-4614": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2010-4615": {"epss_score": 0.00243, "epss_percentile": 0.47504}, "CVE-2010-4616": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-4617": {"epss_score": 0.0076, "epss_percentile": 0.72799}, "CVE-2010-4618": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-4619": {"epss_score": 0.00135, "epss_percentile": 0.33942}, "CVE-2010-4622": {"epss_score": 0.00369, "epss_percentile": 0.58261}, "CVE-2010-4623": {"epss_score": 0.00374, "epss_percentile": 0.58585}, "CVE-2010-4624": {"epss_score": 0.00573, "epss_percentile": 0.68067}, "CVE-2010-4625": {"epss_score": 0.00578, "epss_percentile": 0.68185}, "CVE-2010-4626": {"epss_score": 0.01334, "epss_percentile": 0.7954}, "CVE-2010-4627": {"epss_score": 0.00386, "epss_percentile": 0.59283}, "CVE-2010-4628": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2010-4629": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2010-4630": {"epss_score": 0.00316, "epss_percentile": 0.54216}, "CVE-2010-4631": {"epss_score": 0.06079, "epss_percentile": 0.90461}, "CVE-2010-4632": {"epss_score": 0.01606, "epss_percentile": 0.81302}, "CVE-2010-4633": {"epss_score": 0.00362, "epss_percentile": 0.57768}, "CVE-2010-4634": {"epss_score": 0.00183, "epss_percentile": 0.40282}, "CVE-2010-4635": {"epss_score": 0.01554, "epss_percentile": 0.81001}, "CVE-2010-4636": {"epss_score": 0.00248, "epss_percentile": 0.47922}, "CVE-2010-4637": {"epss_score": 0.0024, "epss_percentile": 0.47213}, "CVE-2010-4638": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-4639": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2010-4640": {"epss_score": 0.00104, "epss_percentile": 0.29177}, "CVE-2010-4641": {"epss_score": 0.00124, "epss_percentile": 0.32347}, "CVE-2010-4642": {"epss_score": 0.00072, "epss_percentile": 0.2236}, "CVE-2010-4643": {"epss_score": 0.04801, "epss_percentile": 0.89158}, "CVE-2010-4644": {"epss_score": 0.01955, "epss_percentile": 0.83034}, "CVE-2010-4645": {"epss_score": 0.19431, "epss_percentile": 0.9518}, "CVE-2010-4646": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-4647": {"epss_score": 0.09638, "epss_percentile": 0.92636}, "CVE-2010-4648": {"epss_score": 0.00228, "epss_percentile": 0.45541}, "CVE-2010-4649": {"epss_score": 0.00069, "epss_percentile": 0.21608}, "CVE-2010-4650": {"epss_score": 0.00083, "epss_percentile": 0.2476}, "CVE-2010-4651": {"epss_score": 0.0183, "epss_percentile": 0.82448}, "CVE-2010-4652": {"epss_score": 0.07015, "epss_percentile": 0.91188}, "CVE-2010-4653": {"epss_score": 0.00782, "epss_percentile": 0.73211}, "CVE-2010-4654": {"epss_score": 0.00468, "epss_percentile": 0.63888}, "CVE-2010-4655": {"epss_score": 0.00053, "epss_percentile": 0.16938}, "CVE-2010-4656": {"epss_score": 0.00048, "epss_percentile": 0.15113}, "CVE-2010-4657": {"epss_score": 0.0157, "epss_percentile": 0.81084}, "CVE-2010-4658": {"epss_score": 0.00238, "epss_percentile": 0.46811}, "CVE-2010-4659": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2010-4660": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2010-4661": {"epss_score": 0.00152, "epss_percentile": 0.36488}, "CVE-2010-4662": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2010-4663": {"epss_score": 0.00414, "epss_percentile": 0.61017}, "CVE-2010-4664": {"epss_score": 0.00197, "epss_percentile": 0.41886}, "CVE-2010-4665": {"epss_score": 0.02306, "epss_percentile": 0.84323}, "CVE-2010-4666": {"epss_score": 0.00426, "epss_percentile": 0.61766}, "CVE-2010-4667": {"epss_score": 0.00249, "epss_percentile": 0.48037}, "CVE-2010-4668": {"epss_score": 0.00069, "epss_percentile": 0.21523}, "CVE-2010-4669": {"epss_score": 0.03885, "epss_percentile": 0.87903}, "CVE-2010-4670": {"epss_score": 0.01448, "epss_percentile": 0.80334}, "CVE-2010-4671": {"epss_score": 0.0211, "epss_percentile": 0.83645}, "CVE-2010-4672": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-4673": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-4674": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-4675": {"epss_score": 0.00185, "epss_percentile": 0.40526}, "CVE-2010-4676": {"epss_score": 0.00925, "epss_percentile": 0.75535}, "CVE-2010-4677": {"epss_score": 0.00971, "epss_percentile": 0.76119}, "CVE-2010-4678": {"epss_score": 0.00146, "epss_percentile": 0.35598}, "CVE-2010-4679": {"epss_score": 0.0034, "epss_percentile": 0.56271}, "CVE-2010-4680": {"epss_score": 0.00185, "epss_percentile": 0.40526}, "CVE-2010-4681": {"epss_score": 0.00146, "epss_percentile": 0.35598}, "CVE-2010-4682": {"epss_score": 0.01494, "epss_percentile": 0.80649}, "CVE-2010-4683": {"epss_score": 0.00851, "epss_percentile": 0.74398}, "CVE-2010-4684": {"epss_score": 0.00679, "epss_percentile": 0.71018}, "CVE-2010-4685": {"epss_score": 0.00172, "epss_percentile": 0.38988}, "CVE-2010-4686": {"epss_score": 0.00851, "epss_percentile": 0.74398}, "CVE-2010-4687": {"epss_score": 0.00756, "epss_percentile": 0.72737}, "CVE-2010-4688": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-4689": {"epss_score": 0.00374, "epss_percentile": 0.5855}, "CVE-2010-4690": {"epss_score": 0.00496, "epss_percentile": 0.65156}, "CVE-2010-4691": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-4692": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2010-4693": {"epss_score": 0.00374, "epss_percentile": 0.58551}, "CVE-2010-4694": {"epss_score": 0.03901, "epss_percentile": 0.87922}, "CVE-2010-4695": {"epss_score": 0.00538, "epss_percentile": 0.66932}, "CVE-2010-4696": {"epss_score": 0.00074, "epss_percentile": 0.22731}, "CVE-2010-4697": {"epss_score": 0.01387, "epss_percentile": 0.79917}, "CVE-2010-4698": {"epss_score": 0.0891, "epss_percentile": 0.92312}, "CVE-2010-4699": {"epss_score": 0.00155, "epss_percentile": 0.36861}, "CVE-2010-4700": {"epss_score": 0.00242, "epss_percentile": 0.47405}, "CVE-2010-4701": {"epss_score": 0.58316, "epss_percentile": 0.98108}, "CVE-2010-4702": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-4703": {"epss_score": 0.00387, "epss_percentile": 0.59291}, "CVE-2010-4704": {"epss_score": 0.04116, "epss_percentile": 0.88278}, "CVE-2010-4705": {"epss_score": 0.00487, "epss_percentile": 0.64818}, "CVE-2010-4706": {"epss_score": 0.00049, "epss_percentile": 0.15622}, "CVE-2010-4707": {"epss_score": 0.00095, "epss_percentile": 0.27136}, "CVE-2010-4708": {"epss_score": 0.00098, "epss_percentile": 0.27691}, "CVE-2010-4709": {"epss_score": 0.47433, "epss_percentile": 0.97587}, "CVE-2010-4710": {"epss_score": 0.00234, "epss_percentile": 0.46157}, "CVE-2010-4711": {"epss_score": 0.0642, "epss_percentile": 0.90749}, "CVE-2010-4712": {"epss_score": 0.27854, "epss_percentile": 0.96288}, "CVE-2010-4713": {"epss_score": 0.1355, "epss_percentile": 0.93993}, "CVE-2010-4714": {"epss_score": 0.02518, "epss_percentile": 0.84994}, "CVE-2010-4715": {"epss_score": 0.03928, "epss_percentile": 0.87968}, "CVE-2010-4716": {"epss_score": 0.01313, "epss_percentile": 0.79385}, "CVE-2010-4717": {"epss_score": 0.19009, "epss_percentile": 0.9511}, "CVE-2010-4718": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2010-4719": {"epss_score": 0.08213, "epss_percentile": 0.91932}, "CVE-2010-4720": {"epss_score": 0.00517, "epss_percentile": 0.66081}, "CVE-2010-4721": {"epss_score": 0.01599, "epss_percentile": 0.81252}, "CVE-2010-4722": {"epss_score": 0.00435, "epss_percentile": 0.62367}, "CVE-2010-4723": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2010-4724": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2010-4725": {"epss_score": 0.00435, "epss_percentile": 0.62367}, "CVE-2010-4726": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2010-4727": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2010-4728": {"epss_score": 0.00345, "epss_percentile": 0.56577}, "CVE-2010-4729": {"epss_score": 0.00182, "epss_percentile": 0.402}, "CVE-2010-4730": {"epss_score": 0.00304, "epss_percentile": 0.53258}, "CVE-2010-4731": {"epss_score": 0.00411, "epss_percentile": 0.6087}, "CVE-2010-4732": {"epss_score": 0.01641, "epss_percentile": 0.81503}, "CVE-2010-4733": {"epss_score": 0.00717, "epss_percentile": 0.71877}, "CVE-2010-4734": {"epss_score": 0.00483, "epss_percentile": 0.64577}, "CVE-2010-4735": {"epss_score": 0.00243, "epss_percentile": 0.47504}, "CVE-2010-4736": {"epss_score": 0.00256, "epss_percentile": 0.48816}, "CVE-2010-4737": {"epss_score": 0.00279, "epss_percentile": 0.50927}, "CVE-2010-4738": {"epss_score": 0.00684, "epss_percentile": 0.71111}, "CVE-2010-4739": {"epss_score": 0.00765, "epss_percentile": 0.72916}, "CVE-2010-4740": {"epss_score": 0.58302, "epss_percentile": 0.98107}, "CVE-2010-4741": {"epss_score": 0.46107, "epss_percentile": 0.97526}, "CVE-2010-4742": {"epss_score": 0.48173, "epss_percentile": 0.97625}, "CVE-2010-4743": {"epss_score": 0.04075, "epss_percentile": 0.8821}, "CVE-2010-4744": {"epss_score": 0.01497, "epss_percentile": 0.80686}, "CVE-2010-4745": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2010-4746": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2010-4747": {"epss_score": 0.00714, "epss_percentile": 0.71818}, "CVE-2010-4748": {"epss_score": 0.00496, "epss_percentile": 0.65165}, "CVE-2010-4749": {"epss_score": 0.05253, "epss_percentile": 0.89665}, "CVE-2010-4750": {"epss_score": 0.00183, "epss_percentile": 0.40361}, "CVE-2010-4751": {"epss_score": 0.00142, "epss_percentile": 0.35051}, "CVE-2010-4752": {"epss_score": 0.00145, "epss_percentile": 0.35419}, "CVE-2010-4753": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-4754": {"epss_score": 0.01826, "epss_percentile": 0.82433}, "CVE-2010-4755": {"epss_score": 0.00147, "epss_percentile": 0.35651}, "CVE-2010-4756": {"epss_score": 0.00691, "epss_percentile": 0.71261}, "CVE-2010-4757": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2010-4758": {"epss_score": 0.0006, "epss_percentile": 0.1902}, "CVE-2010-4759": {"epss_score": 0.00501, "epss_percentile": 0.65367}, "CVE-2010-4760": {"epss_score": 0.00164, "epss_percentile": 0.3796}, "CVE-2010-4761": {"epss_score": 0.00219, "epss_percentile": 0.44516}, "CVE-2010-4762": {"epss_score": 0.00148, "epss_percentile": 0.35855}, "CVE-2010-4763": {"epss_score": 0.00196, "epss_percentile": 0.41767}, "CVE-2010-4764": {"epss_score": 0.00302, "epss_percentile": 0.53136}, "CVE-2010-4765": {"epss_score": 0.00264, "epss_percentile": 0.49713}, "CVE-2010-4766": {"epss_score": 0.00233, "epss_percentile": 0.46053}, "CVE-2010-4767": {"epss_score": 0.00589, "epss_percentile": 0.68529}, "CVE-2010-4768": {"epss_score": 0.00141, "epss_percentile": 0.34943}, "CVE-2010-4769": {"epss_score": 0.06398, "epss_percentile": 0.90725}, "CVE-2010-4770": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2010-4771": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2010-4772": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2010-4773": {"epss_score": 0.03369, "epss_percentile": 0.87008}, "CVE-2010-4774": {"epss_score": 0.00279, "epss_percentile": 0.5095}, "CVE-2010-4775": {"epss_score": 0.00595, "epss_percentile": 0.68683}, "CVE-2010-4776": {"epss_score": 0.00362, "epss_percentile": 0.57768}, "CVE-2010-4777": {"epss_score": 0.05455, "epss_percentile": 0.89895}, "CVE-2010-4778": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-4779": {"epss_score": 0.00192, "epss_percentile": 0.41376}, "CVE-2010-4780": {"epss_score": 0.02331, "epss_percentile": 0.84403}, "CVE-2010-4781": {"epss_score": 0.04771, "epss_percentile": 0.89127}, "CVE-2010-4782": {"epss_score": 0.01458, "epss_percentile": 0.80405}, "CVE-2010-4783": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2010-4784": {"epss_score": 0.01544, "epss_percentile": 0.80959}, "CVE-2010-4785": {"epss_score": 0.0036, "epss_percentile": 0.57662}, "CVE-2010-4786": {"epss_score": 0.0036, "epss_percentile": 0.57662}, "CVE-2010-4787": {"epss_score": 0.0036, "epss_percentile": 0.57662}, "CVE-2010-4788": {"epss_score": 0.0036, "epss_percentile": 0.57662}, "CVE-2010-4789": {"epss_score": 0.00459, "epss_percentile": 0.63453}, "CVE-2010-4790": {"epss_score": 0.00233, "epss_percentile": 0.45979}, "CVE-2010-4791": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-4792": {"epss_score": 0.04088, "epss_percentile": 0.88235}, "CVE-2010-4793": {"epss_score": 0.01606, "epss_percentile": 0.81302}, "CVE-2010-4794": {"epss_score": 0.0034, "epss_percentile": 0.56211}, "CVE-2010-4795": {"epss_score": 0.00216, "epss_percentile": 0.44216}, "CVE-2010-4796": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-4797": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-4798": {"epss_score": 0.01114, "epss_percentile": 0.77704}, "CVE-2010-4799": {"epss_score": 0.01135, "epss_percentile": 0.77905}, "CVE-2010-4800": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2010-4801": {"epss_score": 0.0381, "epss_percentile": 0.87757}, "CVE-2010-4802": {"epss_score": 0.00507, "epss_percentile": 0.65665}, "CVE-2010-4803": {"epss_score": 0.00458, "epss_percentile": 0.63423}, "CVE-2010-4804": {"epss_score": 0.63498, "epss_percentile": 0.98335}, "CVE-2010-4805": {"epss_score": 0.00804, "epss_percentile": 0.73614}, "CVE-2010-4806": {"epss_score": 0.00121, "epss_percentile": 0.31889}, "CVE-2010-4807": {"epss_score": 0.0024, "epss_percentile": 0.47201}, "CVE-2010-4808": {"epss_score": 0.00138, "epss_percentile": 0.34356}, "CVE-2010-4809": {"epss_score": 0.0036, "epss_percentile": 0.57666}, "CVE-2010-4810": {"epss_score": 0.00657, "epss_percentile": 0.70455}, "CVE-2010-4811": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-4812": {"epss_score": 0.0039, "epss_percentile": 0.59504}, "CVE-2010-4813": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2010-4814": {"epss_score": 0.00127, "epss_percentile": 0.3278}, "CVE-2010-4815": {"epss_score": 0.00964, "epss_percentile": 0.76036}, "CVE-2010-4816": {"epss_score": 0.01185, "epss_percentile": 0.78336}, "CVE-2010-4817": {"epss_score": 0.00249, "epss_percentile": 0.48005}, "CVE-2010-4818": {"epss_score": 0.02846, "epss_percentile": 0.85822}, "CVE-2010-4819": {"epss_score": 0.00074, "epss_percentile": 0.22836}, "CVE-2010-4820": {"epss_score": 0.00111, "epss_percentile": 0.30303}, "CVE-2010-4821": {"epss_score": 0.02214, "epss_percentile": 0.84027}, "CVE-2010-4822": {"epss_score": 0.00592, "epss_percentile": 0.68615}, "CVE-2010-4823": {"epss_score": 0.00727, "epss_percentile": 0.72089}, "CVE-2010-4824": {"epss_score": 0.01224, "epss_percentile": 0.78679}, "CVE-2010-4825": {"epss_score": 0.0024, "epss_percentile": 0.47213}, "CVE-2010-4826": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-4827": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-4828": {"epss_score": 0.02752, "epss_percentile": 0.85584}, "CVE-2010-4829": {"epss_score": 0.00262, "epss_percentile": 0.49342}, "CVE-2010-4830": {"epss_score": 0.00275, "epss_percentile": 0.50694}, "CVE-2010-4831": {"epss_score": 0.00122, "epss_percentile": 0.32041}, "CVE-2010-4832": {"epss_score": 0.00187, "epss_percentile": 0.40717}, "CVE-2010-4833": {"epss_score": 0.00304, "epss_percentile": 0.53245}, "CVE-2010-4834": {"epss_score": 0.00128, "epss_percentile": 0.33069}, "CVE-2010-4835": {"epss_score": 0.03036, "epss_percentile": 0.86263}, "CVE-2010-4836": {"epss_score": 0.00655, "epss_percentile": 0.70425}, "CVE-2010-4837": {"epss_score": 0.00332, "epss_percentile": 0.55602}, "CVE-2010-4838": {"epss_score": 0.00097, "epss_percentile": 0.27549}, "CVE-2010-4839": {"epss_score": 0.02042, "epss_percentile": 0.83377}, "CVE-2010-4840": {"epss_score": 0.01323, "epss_percentile": 0.79459}, "CVE-2010-4841": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-4842": {"epss_score": 0.00125, "epss_percentile": 0.32493}, "CVE-2010-4843": {"epss_score": 0.00523, "epss_percentile": 0.66307}, "CVE-2010-4844": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-4845": {"epss_score": 0.00142, "epss_percentile": 0.34959}, "CVE-2010-4846": {"epss_score": 0.00142, "epss_percentile": 0.34959}, "CVE-2010-4847": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-4848": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2010-4849": {"epss_score": 0.00119, "epss_percentile": 0.31651}, "CVE-2010-4850": {"epss_score": 0.05539, "epss_percentile": 0.89976}, "CVE-2010-4851": {"epss_score": 0.01778, "epss_percentile": 0.82229}, "CVE-2010-4852": {"epss_score": 0.0239, "epss_percentile": 0.84598}, "CVE-2010-4853": {"epss_score": 0.00404, "epss_percentile": 0.60401}, "CVE-2010-4854": {"epss_score": 0.00386, "epss_percentile": 0.59267}, "CVE-2010-4855": {"epss_score": 0.01022, "epss_percentile": 0.76755}, "CVE-2010-4856": {"epss_score": 0.00294, "epss_percentile": 0.52439}, "CVE-2010-4857": {"epss_score": 0.00465, "epss_percentile": 0.63782}, "CVE-2010-4858": {"epss_score": 0.0342, "epss_percentile": 0.871}, "CVE-2010-4859": {"epss_score": 0.00332, "epss_percentile": 0.55563}, "CVE-2010-4860": {"epss_score": 0.00404, "epss_percentile": 0.60401}, "CVE-2010-4861": {"epss_score": 0.01175, "epss_percentile": 0.78266}, "CVE-2010-4862": {"epss_score": 0.00539, "epss_percentile": 0.66986}, "CVE-2010-4863": {"epss_score": 0.04189, "epss_percentile": 0.88374}, "CVE-2010-4864": {"epss_score": 0.00356, "epss_percentile": 0.57331}, "CVE-2010-4865": {"epss_score": 0.00532, "epss_percentile": 0.6668}, "CVE-2010-4866": {"epss_score": 0.00465, "epss_percentile": 0.63782}, "CVE-2010-4867": {"epss_score": 0.01104, "epss_percentile": 0.77597}, "CVE-2010-4868": {"epss_score": 0.01542, "epss_percentile": 0.80949}, "CVE-2010-4869": {"epss_score": 0.00356, "epss_percentile": 0.57331}, "CVE-2010-4870": {"epss_score": 0.01357, "epss_percentile": 0.79717}, "CVE-2010-4871": {"epss_score": 0.00395, "epss_percentile": 0.59838}, "CVE-2010-4872": {"epss_score": 0.00283, "epss_percentile": 0.51384}, "CVE-2010-4873": {"epss_score": 0.05616, "epss_percentile": 0.90055}, "CVE-2010-4874": {"epss_score": 0.08332, "epss_percentile": 0.91994}, "CVE-2010-4875": {"epss_score": 0.01739, "epss_percentile": 0.82027}, "CVE-2010-4876": {"epss_score": 0.00119, "epss_percentile": 0.31651}, "CVE-2010-4877": {"epss_score": 0.01361, "epss_percentile": 0.79755}, "CVE-2010-4878": {"epss_score": 0.00657, "epss_percentile": 0.70476}, "CVE-2010-4879": {"epss_score": 0.00575, "epss_percentile": 0.68115}, "CVE-2010-4880": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2010-4881": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2010-4882": {"epss_score": 0.01361, "epss_percentile": 0.79755}, "CVE-2010-4883": {"epss_score": 0.0803, "epss_percentile": 0.9184}, "CVE-2010-4884": {"epss_score": 0.00995, "epss_percentile": 0.76441}, "CVE-2010-4885": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-4886": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2010-4887": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-4888": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2010-4889": {"epss_score": 0.0074, "epss_percentile": 0.72404}, "CVE-2010-4890": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2010-4891": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2010-4892": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2010-4893": {"epss_score": 0.01589, "epss_percentile": 0.81194}, "CVE-2010-4894": {"epss_score": 0.05348, "epss_percentile": 0.89771}, "CVE-2010-4895": {"epss_score": 0.07754, "epss_percentile": 0.9166}, "CVE-2010-4896": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2010-4897": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2010-4898": {"epss_score": 0.00163, "epss_percentile": 0.37833}, "CVE-2010-4899": {"epss_score": 0.01175, "epss_percentile": 0.78266}, "CVE-2010-4900": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-4901": {"epss_score": 0.04955, "epss_percentile": 0.89327}, "CVE-2010-4902": {"epss_score": 0.01371, "epss_percentile": 0.79805}, "CVE-2010-4903": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2010-4904": {"epss_score": 0.00472, "epss_percentile": 0.64068}, "CVE-2010-4905": {"epss_score": 0.00125, "epss_percentile": 0.32493}, "CVE-2010-4906": {"epss_score": 0.01388, "epss_percentile": 0.7992}, "CVE-2010-4907": {"epss_score": 0.04955, "epss_percentile": 0.89327}, "CVE-2010-4908": {"epss_score": 0.00481, "epss_percentile": 0.6451}, "CVE-2010-4909": {"epss_score": 0.01254, "epss_percentile": 0.78918}, "CVE-2010-4910": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-4911": {"epss_score": 0.00404, "epss_percentile": 0.60401}, "CVE-2010-4912": {"epss_score": 0.00404, "epss_percentile": 0.60401}, "CVE-2010-4913": {"epss_score": 0.02783, "epss_percentile": 0.85654}, "CVE-2010-4914": {"epss_score": 0.00551, "epss_percentile": 0.67371}, "CVE-2010-4915": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-4916": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-4917": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-4918": {"epss_score": 0.01139, "epss_percentile": 0.77947}, "CVE-2010-4919": {"epss_score": 0.00308, "epss_percentile": 0.53592}, "CVE-2010-4920": {"epss_score": 0.00308, "epss_percentile": 0.53592}, "CVE-2010-4921": {"epss_score": 0.01918, "epss_percentile": 0.82875}, "CVE-2010-4922": {"epss_score": 0.01532, "epss_percentile": 0.80895}, "CVE-2010-4923": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2010-4924": {"epss_score": 0.01468, "epss_percentile": 0.80478}, "CVE-2010-4925": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-4926": {"epss_score": 0.01584, "epss_percentile": 0.81159}, "CVE-2010-4927": {"epss_score": 0.00356, "epss_percentile": 0.57331}, "CVE-2010-4928": {"epss_score": 0.01361, "epss_percentile": 0.79755}, "CVE-2010-4929": {"epss_score": 0.00119, "epss_percentile": 0.31651}, "CVE-2010-4930": {"epss_score": 0.04708, "epss_percentile": 0.89035}, "CVE-2010-4931": {"epss_score": 0.05209, "epss_percentile": 0.89613}, "CVE-2010-4932": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-4933": {"epss_score": 0.00404, "epss_percentile": 0.60401}, "CVE-2010-4934": {"epss_score": 0.00119, "epss_percentile": 0.31651}, "CVE-2010-4935": {"epss_score": 0.00119, "epss_percentile": 0.31651}, "CVE-2010-4936": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2010-4937": {"epss_score": 0.00169, "epss_percentile": 0.38561}, "CVE-2010-4938": {"epss_score": 5e-05, "epss_percentile": 0.00223}, "CVE-2010-4939": {"epss_score": 0.00657, "epss_percentile": 0.70476}, "CVE-2010-4940": {"epss_score": 0.00481, "epss_percentile": 0.64516}, "CVE-2010-4941": {"epss_score": 0.00169, "epss_percentile": 0.38561}, "CVE-2010-4942": {"epss_score": 0.00418, "epss_percentile": 0.61266}, "CVE-2010-4943": {"epss_score": 0.00657, "epss_percentile": 0.70476}, "CVE-2010-4944": {"epss_score": 5e-05, "epss_percentile": 0.00202}, "CVE-2010-4945": {"epss_score": 0.00114, "epss_percentile": 0.3084}, "CVE-2010-4946": {"epss_score": 0.00119, "epss_percentile": 0.31651}, "CVE-2010-4947": {"epss_score": 0.00193, "epss_percentile": 0.41456}, "CVE-2010-4948": {"epss_score": 0.00657, "epss_percentile": 0.70476}, "CVE-2010-4949": {"epss_score": 0.02423, "epss_percentile": 0.84707}, "CVE-2010-4950": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2010-4951": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2010-4952": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-4953": {"epss_score": 0.05913, "epss_percentile": 0.90316}, "CVE-2010-4954": {"epss_score": 0.00404, "epss_percentile": 0.60401}, "CVE-2010-4955": {"epss_score": 0.00465, "epss_percentile": 0.63782}, "CVE-2010-4956": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2010-4957": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2010-4958": {"epss_score": 0.00765, "epss_percentile": 0.72916}, "CVE-2010-4959": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-4960": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2010-4961": {"epss_score": 0.00366, "epss_percentile": 0.5802}, "CVE-2010-4962": {"epss_score": 0.00841, "epss_percentile": 0.7423}, "CVE-2010-4963": {"epss_score": 0.01584, "epss_percentile": 0.81159}, "CVE-2010-4964": {"epss_score": 0.00727, "epss_percentile": 0.72097}, "CVE-2010-4965": {"epss_score": 0.00534, "epss_percentile": 0.66798}, "CVE-2010-4966": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2010-4967": {"epss_score": 0.00391, "epss_percentile": 0.59589}, "CVE-2010-4968": {"epss_score": 0.00424, "epss_percentile": 0.61676}, "CVE-2010-4969": {"epss_score": 0.00311, "epss_percentile": 0.53858}, "CVE-2010-4970": {"epss_score": 0.00592, "epss_percentile": 0.68613}, "CVE-2010-4971": {"epss_score": 0.02137, "epss_percentile": 0.83732}, "CVE-2010-4972": {"epss_score": 0.01584, "epss_percentile": 0.81159}, "CVE-2010-4973": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-4974": {"epss_score": 0.01584, "epss_percentile": 0.81159}, "CVE-2010-4975": {"epss_score": 0.00125, "epss_percentile": 0.32493}, "CVE-2010-4976": {"epss_score": 0.04203, "epss_percentile": 0.88392}, "CVE-2010-4977": {"epss_score": 0.01559, "epss_percentile": 0.81033}, "CVE-2010-4978": {"epss_score": 0.01542, "epss_percentile": 0.80949}, "CVE-2010-4979": {"epss_score": 0.00404, "epss_percentile": 0.60401}, "CVE-2010-4980": {"epss_score": 0.0204, "epss_percentile": 0.83365}, "CVE-2010-4981": {"epss_score": 0.00169, "epss_percentile": 0.38561}, "CVE-2010-4982": {"epss_score": 0.00416, "epss_percentile": 0.61197}, "CVE-2010-4983": {"epss_score": 0.01584, "epss_percentile": 0.81159}, "CVE-2010-4984": {"epss_score": 0.00481, "epss_percentile": 0.64516}, "CVE-2010-4985": {"epss_score": 0.01833, "epss_percentile": 0.82458}, "CVE-2010-4986": {"epss_score": 0.00119, "epss_percentile": 0.31651}, "CVE-2010-4987": {"epss_score": 0.00283, "epss_percentile": 0.51384}, "CVE-2010-4988": {"epss_score": 0.00741, "epss_percentile": 0.72435}, "CVE-2010-4989": {"epss_score": 0.00283, "epss_percentile": 0.51384}, "CVE-2010-4990": {"epss_score": 0.00142, "epss_percentile": 0.34959}, "CVE-2010-4991": {"epss_score": 0.0034, "epss_percentile": 0.56286}, "CVE-2010-4992": {"epss_score": 0.00465, "epss_percentile": 0.63782}, "CVE-2010-4993": {"epss_score": 0.00481, "epss_percentile": 0.64516}, "CVE-2010-4994": {"epss_score": 0.00465, "epss_percentile": 0.63773}, "CVE-2010-4995": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-4996": {"epss_score": 0.00179, "epss_percentile": 0.39792}, "CVE-2010-4997": {"epss_score": 0.00119, "epss_percentile": 0.31651}, "CVE-2010-4998": {"epss_score": 0.03457, "epss_percentile": 0.87174}, "CVE-2010-4999": {"epss_score": 0.00142, "epss_percentile": 0.34959}, "CVE-2010-5000": {"epss_score": 0.00545, "epss_percentile": 0.67156}, "CVE-2010-5001": {"epss_score": 0.00142, "epss_percentile": 0.34959}, "CVE-2010-5002": {"epss_score": 0.06528, "epss_percentile": 0.90822}, "CVE-2010-5003": {"epss_score": 0.02592, "epss_percentile": 0.85185}, "CVE-2010-5004": {"epss_score": 0.00119, "epss_percentile": 0.31651}, "CVE-2010-5005": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2010-5006": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2010-5007": {"epss_score": 0.04534, "epss_percentile": 0.88815}, "CVE-2010-5008": {"epss_score": 0.00989, "epss_percentile": 0.76367}, "CVE-2010-5009": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-5010": {"epss_score": 0.05616, "epss_percentile": 0.90055}, "CVE-2010-5011": {"epss_score": 0.00465, "epss_percentile": 0.63782}, "CVE-2010-5012": {"epss_score": 0.01584, "epss_percentile": 0.81159}, "CVE-2010-5013": {"epss_score": 0.01918, "epss_percentile": 0.82875}, "CVE-2010-5014": {"epss_score": 0.00142, "epss_percentile": 0.34959}, "CVE-2010-5015": {"epss_score": 0.00563, "epss_percentile": 0.67736}, "CVE-2010-5016": {"epss_score": 0.00142, "epss_percentile": 0.34959}, "CVE-2010-5017": {"epss_score": 0.00563, "epss_percentile": 0.67736}, "CVE-2010-5018": {"epss_score": 0.02346, "epss_percentile": 0.84454}, "CVE-2010-5019": {"epss_score": 0.0041, "epss_percentile": 0.60792}, "CVE-2010-5020": {"epss_score": 0.00125, "epss_percentile": 0.32493}, "CVE-2010-5021": {"epss_score": 0.01918, "epss_percentile": 0.82875}, "CVE-2010-5022": {"epss_score": 0.00119, "epss_percentile": 0.31651}, "CVE-2010-5023": {"epss_score": 0.01788, "epss_percentile": 0.82265}, "CVE-2010-5024": {"epss_score": 0.01078, "epss_percentile": 0.77348}, "CVE-2010-5025": {"epss_score": 0.04534, "epss_percentile": 0.88815}, "CVE-2010-5026": {"epss_score": 0.02592, "epss_percentile": 0.85185}, "CVE-2010-5027": {"epss_score": 0.05616, "epss_percentile": 0.90055}, "CVE-2010-5028": {"epss_score": 0.05974, "epss_percentile": 0.90375}, "CVE-2010-5029": {"epss_score": 0.01373, "epss_percentile": 0.79819}, "CVE-2010-5030": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2010-5031": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2010-5032": {"epss_score": 0.02241, "epss_percentile": 0.84116}, "CVE-2010-5033": {"epss_score": 0.00465, "epss_percentile": 0.63782}, "CVE-2010-5034": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-5035": {"epss_score": 0.05616, "epss_percentile": 0.90055}, "CVE-2010-5036": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-5037": {"epss_score": 0.00488, "epss_percentile": 0.64865}, "CVE-2010-5038": {"epss_score": 0.00629, "epss_percentile": 0.6968}, "CVE-2010-5039": {"epss_score": 0.00169, "epss_percentile": 0.38561}, "CVE-2010-5040": {"epss_score": 0.02047, "epss_percentile": 0.83389}, "CVE-2010-5041": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2010-5042": {"epss_score": 0.00536, "epss_percentile": 0.66858}, "CVE-2010-5043": {"epss_score": 0.00144, "epss_percentile": 0.35245}, "CVE-2010-5044": {"epss_score": 0.00434, "epss_percentile": 0.62298}, "CVE-2010-5045": {"epss_score": 0.00458, "epss_percentile": 0.63434}, "CVE-2010-5046": {"epss_score": 0.06129, "epss_percentile": 0.90499}, "CVE-2010-5047": {"epss_score": 0.01191, "epss_percentile": 0.78396}, "CVE-2010-5048": {"epss_score": 0.04534, "epss_percentile": 0.88815}, "CVE-2010-5049": {"epss_score": 0.00487, "epss_percentile": 0.64782}, "CVE-2010-5050": {"epss_score": 0.00325, "epss_percentile": 0.55015}, "CVE-2010-5051": {"epss_score": 0.00229, "epss_percentile": 0.45653}, "CVE-2010-5052": {"epss_score": 0.00262, "epss_percentile": 0.4933}, "CVE-2010-5053": {"epss_score": 0.00424, "epss_percentile": 0.61639}, "CVE-2010-5054": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2010-5055": {"epss_score": 0.01036, "epss_percentile": 0.76913}, "CVE-2010-5056": {"epss_score": 0.01036, "epss_percentile": 0.76913}, "CVE-2010-5057": {"epss_score": 0.01002, "epss_percentile": 0.76508}, "CVE-2010-5058": {"epss_score": 0.00165, "epss_percentile": 0.38105}, "CVE-2010-5059": {"epss_score": 0.00505, "epss_percentile": 0.65604}, "CVE-2010-5060": {"epss_score": 0.00489, "epss_percentile": 0.64867}, "CVE-2010-5061": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2010-5062": {"epss_score": 0.01036, "epss_percentile": 0.76913}, "CVE-2010-5063": {"epss_score": 0.00424, "epss_percentile": 0.6164}, "CVE-2010-5064": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-5065": {"epss_score": 0.00184, "epss_percentile": 0.40384}, "CVE-2010-5066": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2010-5067": {"epss_score": 0.00225, "epss_percentile": 0.45089}, "CVE-2010-5068": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2010-5069": {"epss_score": 0.00133, "epss_percentile": 0.33688}, "CVE-2010-5070": {"epss_score": 0.00204, "epss_percentile": 0.42595}, "CVE-2010-5071": {"epss_score": 0.10857, "epss_percentile": 0.93136}, "CVE-2010-5072": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2010-5073": {"epss_score": 0.00133, "epss_percentile": 0.33688}, "CVE-2010-5074": {"epss_score": 0.00178, "epss_percentile": 0.39724}, "CVE-2010-5075": {"epss_score": 0.00567, "epss_percentile": 0.67838}, "CVE-2010-5076": {"epss_score": 0.00495, "epss_percentile": 0.65126}, "CVE-2010-5077": {"epss_score": 0.02874, "epss_percentile": 0.85881}, "CVE-2010-5078": {"epss_score": 0.00721, "epss_percentile": 0.71976}, "CVE-2010-5079": {"epss_score": 0.00616, "epss_percentile": 0.69328}, "CVE-2010-5080": {"epss_score": 0.00658, "epss_percentile": 0.70483}, "CVE-2010-5081": {"epss_score": 0.59696, "epss_percentile": 0.98176}, "CVE-2010-5082": {"epss_score": 0.4332, "epss_percentile": 0.97381}, "CVE-2010-5083": {"epss_score": 0.00975, "epss_percentile": 0.76198}, "CVE-2010-5084": {"epss_score": 0.00121, "epss_percentile": 0.31927}, "CVE-2010-5085": {"epss_score": 0.00253, "epss_percentile": 0.48475}, "CVE-2010-5086": {"epss_score": 0.0032, "epss_percentile": 0.54629}, "CVE-2010-5087": {"epss_score": 0.0078, "epss_percentile": 0.73175}, "CVE-2010-5088": {"epss_score": 0.00526, "epss_percentile": 0.66405}, "CVE-2010-5089": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2010-5090": {"epss_score": 0.00218, "epss_percentile": 0.44394}, "CVE-2010-5091": {"epss_score": 0.00871, "epss_percentile": 0.74709}, "CVE-2010-5092": {"epss_score": 0.00064, "epss_percentile": 0.20163}, "CVE-2010-5093": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2010-5094": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2010-5095": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2010-5096": {"epss_score": 0.07189, "epss_percentile": 0.9131}, "CVE-2010-5097": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2010-5098": {"epss_score": 0.00393, "epss_percentile": 0.5971}, "CVE-2010-5099": {"epss_score": 0.05185, "epss_percentile": 0.89587}, "CVE-2010-5100": {"epss_score": 0.00354, "epss_percentile": 0.57245}, "CVE-2010-5101": {"epss_score": 0.00456, "epss_percentile": 0.63337}, "CVE-2010-5102": {"epss_score": 0.00457, "epss_percentile": 0.63386}, "CVE-2010-5103": {"epss_score": 0.00652, "epss_percentile": 0.7031}, "CVE-2010-5104": {"epss_score": 0.00765, "epss_percentile": 0.72917}, "CVE-2010-5105": {"epss_score": 0.0005, "epss_percentile": 0.15844}, "CVE-2010-5106": {"epss_score": 0.00302, "epss_percentile": 0.53136}, "CVE-2010-5107": {"epss_score": 0.01901, "epss_percentile": 0.82776}, "CVE-2010-5108": {"epss_score": 0.00311, "epss_percentile": 0.5393}, "CVE-2010-5109": {"epss_score": 0.0124, "epss_percentile": 0.78804}, "CVE-2010-5110": {"epss_score": 0.00777, "epss_percentile": 0.73118}, "CVE-2010-5111": {"epss_score": 0.02611, "epss_percentile": 0.85236}, "CVE-2010-5137": {"epss_score": 0.01317, "epss_percentile": 0.79418}, "CVE-2010-5138": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2010-5139": {"epss_score": 0.00262, "epss_percentile": 0.49337}, "CVE-2010-5140": {"epss_score": 0.00727, "epss_percentile": 0.72088}, "CVE-2010-5141": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2010-5142": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2010-5143": {"epss_score": 0.00049, "epss_percentile": 0.15648}, "CVE-2010-5144": {"epss_score": 0.00121, "epss_percentile": 0.31885}, "CVE-2010-5145": {"epss_score": 0.00422, "epss_percentile": 0.61566}, "CVE-2010-5146": {"epss_score": 0.0006, "epss_percentile": 0.19009}, "CVE-2010-5147": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2010-5148": {"epss_score": 0.00282, "epss_percentile": 0.51281}, "CVE-2010-5149": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2010-5150": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5151": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5152": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5153": {"epss_score": 0.00057, "epss_percentile": 0.18017}, "CVE-2010-5154": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5155": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5156": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5157": {"epss_score": 0.00042, "epss_percentile": 0.12895}, "CVE-2010-5158": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5159": {"epss_score": 0.00059, "epss_percentile": 0.18645}, "CVE-2010-5160": {"epss_score": 0.00058, "epss_percentile": 0.18481}, "CVE-2010-5161": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5162": {"epss_score": 0.00088, "epss_percentile": 0.25716}, "CVE-2010-5163": {"epss_score": 0.00118, "epss_percentile": 0.31444}, "CVE-2010-5164": {"epss_score": 0.00057, "epss_percentile": 0.18017}, "CVE-2010-5165": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5166": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5167": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5168": {"epss_score": 0.00072, "epss_percentile": 0.22468}, "CVE-2010-5169": {"epss_score": 0.00059, "epss_percentile": 0.18645}, "CVE-2010-5170": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5171": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2010-5172": {"epss_score": 0.00051, "epss_percentile": 0.16266}, "CVE-2010-5173": {"epss_score": 0.00041, "epss_percentile": 0.12436}, "CVE-2010-5174": {"epss_score": 0.00041, "epss_percentile": 0.12436}, "CVE-2010-5175": {"epss_score": 0.00058, "epss_percentile": 0.18512}, "CVE-2010-5176": {"epss_score": 0.00041, "epss_percentile": 0.12436}, "CVE-2010-5177": {"epss_score": 0.00063, "epss_percentile": 0.1985}, "CVE-2010-5178": {"epss_score": 0.00041, "epss_percentile": 0.12436}, "CVE-2010-5179": {"epss_score": 0.00057, "epss_percentile": 0.18227}, "CVE-2010-5180": {"epss_score": 0.00041, "epss_percentile": 0.12436}, "CVE-2010-5181": {"epss_score": 0.0003, "epss_percentile": 0.08164}, "CVE-2010-5182": {"epss_score": 0.00041, "epss_percentile": 0.12436}, "CVE-2010-5183": {"epss_score": 0.00041, "epss_percentile": 0.12436}, "CVE-2010-5184": {"epss_score": 0.00041, "epss_percentile": 0.12436}, "CVE-2010-5185": {"epss_score": 0.00178, "epss_percentile": 0.3968}, "CVE-2010-5186": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2010-5187": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2010-5188": {"epss_score": 0.00727, "epss_percentile": 0.72096}, "CVE-2010-5189": {"epss_score": 0.00567, "epss_percentile": 0.67837}, "CVE-2010-5190": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2010-5191": {"epss_score": 0.00086, "epss_percentile": 0.25372}, "CVE-2010-5192": {"epss_score": 0.0047, "epss_percentile": 0.63994}, "CVE-2010-5193": {"epss_score": 0.55762, "epss_percentile": 0.97994}, "CVE-2010-5194": {"epss_score": 0.28119, "epss_percentile": 0.96312}, "CVE-2010-5195": {"epss_score": 0.00292, "epss_percentile": 0.52266}, "CVE-2010-5196": {"epss_score": 0.00056, "epss_percentile": 0.17771}, "CVE-2010-5197": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5198": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5199": {"epss_score": 0.00154, "epss_percentile": 0.36665}, "CVE-2010-5200": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5201": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5202": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5203": {"epss_score": 0.00134, "epss_percentile": 0.33791}, "CVE-2010-5204": {"epss_score": 0.00164, "epss_percentile": 0.37882}, "CVE-2010-5205": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5206": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5207": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5208": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5209": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5210": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5211": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5212": {"epss_score": 0.00244, "epss_percentile": 0.47518}, "CVE-2010-5213": {"epss_score": 0.00162, "epss_percentile": 0.37693}, "CVE-2010-5214": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5215": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5216": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5217": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5218": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5219": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5220": {"epss_score": 0.00039, "epss_percentile": 0.11735}, "CVE-2010-5221": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5222": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5223": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5224": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5225": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5226": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5227": {"epss_score": 0.00579, "epss_percentile": 0.68213}, "CVE-2010-5228": {"epss_score": 0.00127, "epss_percentile": 0.32793}, "CVE-2010-5229": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5230": {"epss_score": 0.01097, "epss_percentile": 0.7753}, "CVE-2010-5231": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5232": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5233": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5234": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5235": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5236": {"epss_score": 0.00292, "epss_percentile": 0.52266}, "CVE-2010-5237": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5238": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5239": {"epss_score": 0.00292, "epss_percentile": 0.52266}, "CVE-2010-5240": {"epss_score": 0.0105, "epss_percentile": 0.77072}, "CVE-2010-5241": {"epss_score": 0.00406, "epss_percentile": 0.60534}, "CVE-2010-5242": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5243": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5244": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5245": {"epss_score": 0.00154, "epss_percentile": 0.36665}, "CVE-2010-5246": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5247": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5248": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5249": {"epss_score": 0.0005, "epss_percentile": 0.15891}, "CVE-2010-5250": {"epss_score": 0.00067, "epss_percentile": 0.20972}, "CVE-2010-5251": {"epss_score": 0.00075, "epss_percentile": 0.22943}, "CVE-2010-5252": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5253": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5254": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5255": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5256": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5257": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5258": {"epss_score": 0.00179, "epss_percentile": 0.39832}, "CVE-2010-5259": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5260": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5261": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5262": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5263": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5264": {"epss_score": 0.00056, "epss_percentile": 0.17771}, "CVE-2010-5265": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5266": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5267": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5268": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5269": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5270": {"epss_score": 0.00179, "epss_percentile": 0.39832}, "CVE-2010-5271": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5272": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5273": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5274": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2010-5275": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2010-5276": {"epss_score": 0.00325, "epss_percentile": 0.55009}, "CVE-2010-5277": {"epss_score": 0.00247, "epss_percentile": 0.47842}, "CVE-2010-5278": {"epss_score": 0.18602, "epss_percentile": 0.95041}, "CVE-2010-5279": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2010-5280": {"epss_score": 0.08864, "epss_percentile": 0.92292}, "CVE-2010-5281": {"epss_score": 0.04888, "epss_percentile": 0.89258}, "CVE-2010-5282": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2010-5283": {"epss_score": 0.0013, "epss_percentile": 0.33265}, "CVE-2010-5284": {"epss_score": 0.04605, "epss_percentile": 0.88907}, "CVE-2010-5285": {"epss_score": 0.00318, "epss_percentile": 0.54453}, "CVE-2010-5286": {"epss_score": 0.38443, "epss_percentile": 0.97101}, "CVE-2010-5287": {"epss_score": 0.00203, "epss_percentile": 0.42503}, "CVE-2010-5288": {"epss_score": 0.02952, "epss_percentile": 0.86056}, "CVE-2010-5289": {"epss_score": 0.06016, "epss_percentile": 0.90413}, "CVE-2010-5290": {"epss_score": 0.01616, "epss_percentile": 0.81357}, "CVE-2010-5291": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2010-5292": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2010-5293": {"epss_score": 0.00387, "epss_percentile": 0.59289}, "CVE-2010-5294": {"epss_score": 0.00713, "epss_percentile": 0.71801}, "CVE-2010-5295": {"epss_score": 0.005, "epss_percentile": 0.65316}, "CVE-2010-5296": {"epss_score": 0.00404, "epss_percentile": 0.60416}, "CVE-2010-5297": {"epss_score": 0.00231, "epss_percentile": 0.45798}, "CVE-2010-5298": {"epss_score": 0.1073, "epss_percentile": 0.93085}, "CVE-2010-5299": {"epss_score": 0.68264, "epss_percentile": 0.98538}, "CVE-2010-5300": {"epss_score": 0.15409, "epss_percentile": 0.94425}, "CVE-2010-5301": {"epss_score": 0.26889, "epss_percentile": 0.96188}, "CVE-2010-5302": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-5303": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-5304": {"epss_score": 0.03383, "epss_percentile": 0.87035}, "CVE-2010-5305": {"epss_score": 0.01854, "epss_percentile": 0.82551}, "CVE-2010-5306": {"epss_score": 0.01611, "epss_percentile": 0.81326}, "CVE-2010-5307": {"epss_score": 0.00568, "epss_percentile": 0.67896}, "CVE-2010-5308": {"epss_score": 0.0063, "epss_percentile": 0.69695}, "CVE-2010-5309": {"epss_score": 0.00568, "epss_percentile": 0.67896}, "CVE-2010-5310": {"epss_score": 0.00568, "epss_percentile": 0.67896}, "CVE-2010-5312": {"epss_score": 0.07171, "epss_percentile": 0.91297}, "CVE-2010-5313": {"epss_score": 0.00074, "epss_percentile": 0.22713}, "CVE-2010-5314": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-5315": {"epss_score": 0.0031, "epss_percentile": 0.53747}, "CVE-2010-5316": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2010-5317": {"epss_score": 0.00247, "epss_percentile": 0.47814}, "CVE-2010-5318": {"epss_score": 0.03428, "epss_percentile": 0.87119}, "CVE-2010-5319": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2010-5320": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2010-5321": {"epss_score": 0.00133, "epss_percentile": 0.33718}, "CVE-2010-5322": {"epss_score": 0.07602, "epss_percentile": 0.91563}, "CVE-2010-5323": {"epss_score": 0.18217, "epss_percentile": 0.94975}, "CVE-2010-5324": {"epss_score": 0.7407, "epss_percentile": 0.98787}, "CVE-2010-5325": {"epss_score": 0.0745, "epss_percentile": 0.91478}, "CVE-2010-5326": {"epss_score": 0.18996, "epss_percentile": 0.95109}, "CVE-2010-5327": {"epss_score": 0.0151, "epss_percentile": 0.80769}, "CVE-2010-5328": {"epss_score": 0.00078, "epss_percentile": 0.23567}, "CVE-2010-5329": {"epss_score": 0.00046, "epss_percentile": 0.14172}, "CVE-2010-5330": {"epss_score": 0.56481, "epss_percentile": 0.98024}, "CVE-2010-5331": {"epss_score": 0.00077, "epss_percentile": 0.23319}, "CVE-2010-5332": {"epss_score": 0.00105, "epss_percentile": 0.29384}, "CVE-2010-5333": {"epss_score": 0.77016, "epss_percentile": 0.98917}, "CVE-2010-5334": {"epss_score": 0.01056, "epss_percentile": 0.77126}, "CVE-2010-5335": {"epss_score": 0.01884, "epss_percentile": 0.82704}, "CVE-2010-5336": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2010-5337": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2010-5338": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2010-5339": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2010-5340": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2011-0001": {"epss_score": 0.07578, "epss_percentile": 0.91549}, "CVE-2011-0002": {"epss_score": 0.0227, "epss_percentile": 0.84208}, "CVE-2011-0003": {"epss_score": 0.00927, "epss_percentile": 0.7557}, "CVE-2011-0004": {"epss_score": 0.00705, "epss_percentile": 0.71583}, "CVE-2011-0005": {"epss_score": 0.00054, "epss_percentile": 0.17082}, "CVE-2011-0006": {"epss_score": 0.00075, "epss_percentile": 0.23061}, "CVE-2011-0007": {"epss_score": 0.0003, "epss_percentile": 0.07986}, "CVE-2011-0008": {"epss_score": 0.00047, "epss_percentile": 0.14487}, "CVE-2011-0009": {"epss_score": 0.00834, "epss_percentile": 0.74106}, "CVE-2011-0010": {"epss_score": 0.00112, "epss_percentile": 0.3049}, "CVE-2011-0011": {"epss_score": 0.00503, "epss_percentile": 0.65457}, "CVE-2011-0012": {"epss_score": 0.0003, "epss_percentile": 0.08069}, "CVE-2011-0013": {"epss_score": 0.25792, "epss_percentile": 0.96071}, "CVE-2011-0014": {"epss_score": 0.01391, "epss_percentile": 0.79951}, "CVE-2011-0015": {"epss_score": 0.02346, "epss_percentile": 0.84454}, "CVE-2011-0016": {"epss_score": 0.00063, "epss_percentile": 0.19814}, "CVE-2011-0017": {"epss_score": 0.00121, "epss_percentile": 0.31944}, "CVE-2011-0018": {"epss_score": 0.08919, "epss_percentile": 0.92319}, "CVE-2011-0019": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2011-0020": {"epss_score": 0.05692, "epss_percentile": 0.90125}, "CVE-2011-0021": {"epss_score": 0.10313, "epss_percentile": 0.92939}, "CVE-2011-0022": {"epss_score": 0.00036, "epss_percentile": 0.10212}, "CVE-2011-0024": {"epss_score": 0.01168, "epss_percentile": 0.7819}, "CVE-2011-0025": {"epss_score": 0.01318, "epss_percentile": 0.79421}, "CVE-2011-0026": {"epss_score": 0.64297, "epss_percentile": 0.98372}, "CVE-2011-0027": {"epss_score": 0.67608, "epss_percentile": 0.98515}, "CVE-2011-0028": {"epss_score": 0.54895, "epss_percentile": 0.97949}, "CVE-2011-0029": {"epss_score": 0.34739, "epss_percentile": 0.96871}, "CVE-2011-0030": {"epss_score": 0.00244, "epss_percentile": 0.47524}, "CVE-2011-0031": {"epss_score": 0.34668, "epss_percentile": 0.96865}, "CVE-2011-0032": {"epss_score": 0.47124, "epss_percentile": 0.9757}, "CVE-2011-0033": {"epss_score": 0.22056, "epss_percentile": 0.95589}, "CVE-2011-0034": {"epss_score": 0.56688, "epss_percentile": 0.98033}, "CVE-2011-0035": {"epss_score": 0.49303, "epss_percentile": 0.97678}, "CVE-2011-0036": {"epss_score": 0.49303, "epss_percentile": 0.97678}, "CVE-2011-0037": {"epss_score": 0.00358, "epss_percentile": 0.57511}, "CVE-2011-0038": {"epss_score": 0.31392, "epss_percentile": 0.96616}, "CVE-2011-0039": {"epss_score": 0.01961, "epss_percentile": 0.83063}, "CVE-2011-0040": {"epss_score": 0.40229, "epss_percentile": 0.97208}, "CVE-2011-0041": {"epss_score": 0.54243, "epss_percentile": 0.97917}, "CVE-2011-0042": {"epss_score": 0.63164, "epss_percentile": 0.98322}, "CVE-2011-0043": {"epss_score": 0.00779, "epss_percentile": 0.73151}, "CVE-2011-0045": {"epss_score": 0.0096, "epss_percentile": 0.7597}, "CVE-2011-0046": {"epss_score": 0.00434, "epss_percentile": 0.62318}, "CVE-2011-0047": {"epss_score": 0.00871, "epss_percentile": 0.74711}, "CVE-2011-0048": {"epss_score": 0.0083, "epss_percentile": 0.74027}, "CVE-2011-0049": {"epss_score": 0.91269, "epss_percentile": 0.99631}, "CVE-2011-0050": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2011-0051": {"epss_score": 0.00952, "epss_percentile": 0.75882}, "CVE-2011-0053": {"epss_score": 0.02496, "epss_percentile": 0.84907}, "CVE-2011-0054": {"epss_score": 0.08816, "epss_percentile": 0.92269}, "CVE-2011-0055": {"epss_score": 0.03014, "epss_percentile": 0.86207}, "CVE-2011-0056": {"epss_score": 0.08816, "epss_percentile": 0.92269}, "CVE-2011-0057": {"epss_score": 0.03791, "epss_percentile": 0.87729}, "CVE-2011-0058": {"epss_score": 0.07487, "epss_percentile": 0.91499}, "CVE-2011-0059": {"epss_score": 0.00229, "epss_percentile": 0.45614}, "CVE-2011-0061": {"epss_score": 0.03959, "epss_percentile": 0.8801}, "CVE-2011-0062": {"epss_score": 0.0709, "epss_percentile": 0.91243}, "CVE-2011-0063": {"epss_score": 0.89981, "epss_percentile": 0.99555}, "CVE-2011-0064": {"epss_score": 0.03093, "epss_percentile": 0.864}, "CVE-2011-0065": {"epss_score": 0.83259, "epss_percentile": 0.9924}, "CVE-2011-0066": {"epss_score": 0.05403, "epss_percentile": 0.89835}, "CVE-2011-0067": {"epss_score": 0.0052, "epss_percentile": 0.662}, "CVE-2011-0069": {"epss_score": 0.04104, "epss_percentile": 0.88264}, "CVE-2011-0070": {"epss_score": 0.04104, "epss_percentile": 0.88264}, "CVE-2011-0071": {"epss_score": 0.01674, "epss_percentile": 0.81694}, "CVE-2011-0072": {"epss_score": 0.04187, "epss_percentile": 0.88366}, "CVE-2011-0073": {"epss_score": 0.81161, "epss_percentile": 0.99125}, "CVE-2011-0074": {"epss_score": 0.04187, "epss_percentile": 0.88366}, "CVE-2011-0075": {"epss_score": 0.04104, "epss_percentile": 0.88264}, "CVE-2011-0076": {"epss_score": 0.00391, "epss_percentile": 0.59584}, "CVE-2011-0077": {"epss_score": 0.04187, "epss_percentile": 0.88366}, "CVE-2011-0078": {"epss_score": 0.04187, "epss_percentile": 0.88366}, "CVE-2011-0079": {"epss_score": 0.06803, "epss_percentile": 0.91035}, "CVE-2011-0080": {"epss_score": 0.02496, "epss_percentile": 0.84907}, "CVE-2011-0081": {"epss_score": 0.04672, "epss_percentile": 0.88987}, "CVE-2011-0082": {"epss_score": 0.00425, "epss_percentile": 0.61727}, "CVE-2011-0083": {"epss_score": 0.03293, "epss_percentile": 0.86843}, "CVE-2011-0084": {"epss_score": 0.04107, "epss_percentile": 0.88267}, "CVE-2011-0085": {"epss_score": 0.03293, "epss_percentile": 0.86843}, "CVE-2011-0086": {"epss_score": 0.01025, "epss_percentile": 0.76789}, "CVE-2011-0087": {"epss_score": 0.00629, "epss_percentile": 0.69681}, "CVE-2011-0088": {"epss_score": 0.0049, "epss_percentile": 0.64916}, "CVE-2011-0089": {"epss_score": 0.00757, "epss_percentile": 0.72749}, "CVE-2011-0090": {"epss_score": 0.00589, "epss_percentile": 0.68523}, "CVE-2011-0091": {"epss_score": 0.0235, "epss_percentile": 0.84467}, "CVE-2011-0092": {"epss_score": 0.4459, "epss_percentile": 0.97445}, "CVE-2011-0093": {"epss_score": 0.44027, "epss_percentile": 0.97416}, "CVE-2011-0094": {"epss_score": 0.59909, "epss_percentile": 0.98187}, "CVE-2011-0096": {"epss_score": 0.70144, "epss_percentile": 0.9862}, "CVE-2011-0097": {"epss_score": 0.65448, "epss_percentile": 0.98418}, "CVE-2011-0098": {"epss_score": 0.65217, "epss_percentile": 0.98408}, "CVE-2011-0101": {"epss_score": 0.71582, "epss_percentile": 0.98674}, "CVE-2011-0103": {"epss_score": 0.70084, "epss_percentile": 0.98614}, "CVE-2011-0104": {"epss_score": 0.76891, "epss_percentile": 0.9891}, "CVE-2011-0105": {"epss_score": 0.89418, "epss_percentile": 0.99525}, "CVE-2011-0107": {"epss_score": 0.51718, "epss_percentile": 0.97795}, "CVE-2011-0111": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0112": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0113": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0114": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0115": {"epss_score": 0.01007, "epss_percentile": 0.76559}, "CVE-2011-0116": {"epss_score": 0.01108, "epss_percentile": 0.77636}, "CVE-2011-0117": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0118": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0119": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0120": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0121": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0122": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0123": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0124": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0125": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0126": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0127": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0128": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0129": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0130": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0131": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0132": {"epss_score": 0.00682, "epss_percentile": 0.71074}, "CVE-2011-0133": {"epss_score": 0.0112, "epss_percentile": 0.77759}, "CVE-2011-0134": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0135": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0136": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0137": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0138": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0139": {"epss_score": 0.00762, "epss_percentile": 0.72839}, "CVE-2011-0140": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0141": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0142": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0143": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0144": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0145": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0146": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0147": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0148": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0149": {"epss_score": 0.0112, "epss_percentile": 0.77759}, "CVE-2011-0150": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0151": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0152": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0153": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0154": {"epss_score": 0.00753, "epss_percentile": 0.72673}, "CVE-2011-0155": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0156": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0157": {"epss_score": 0.01607, "epss_percentile": 0.81308}, "CVE-2011-0158": {"epss_score": 0.00683, "epss_percentile": 0.71091}, "CVE-2011-0159": {"epss_score": 0.00613, "epss_percentile": 0.69258}, "CVE-2011-0160": {"epss_score": 0.00423, "epss_percentile": 0.61604}, "CVE-2011-0161": {"epss_score": 0.00391, "epss_percentile": 0.59625}, "CVE-2011-0162": {"epss_score": 0.02288, "epss_percentile": 0.84271}, "CVE-2011-0163": {"epss_score": 0.01049, "epss_percentile": 0.77063}, "CVE-2011-0164": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0165": {"epss_score": 0.00762, "epss_percentile": 0.72839}, "CVE-2011-0166": {"epss_score": 0.00441, "epss_percentile": 0.6267}, "CVE-2011-0167": {"epss_score": 0.02045, "epss_percentile": 0.83385}, "CVE-2011-0168": {"epss_score": 0.00743, "epss_percentile": 0.72494}, "CVE-2011-0169": {"epss_score": 0.00362, "epss_percentile": 0.57768}, "CVE-2011-0170": {"epss_score": 0.08007, "epss_percentile": 0.91824}, "CVE-2011-0172": {"epss_score": 0.00217, "epss_percentile": 0.44268}, "CVE-2011-0173": {"epss_score": 0.00659, "epss_percentile": 0.70508}, "CVE-2011-0174": {"epss_score": 0.01477, "epss_percentile": 0.80546}, "CVE-2011-0175": {"epss_score": 0.01577, "epss_percentile": 0.81121}, "CVE-2011-0176": {"epss_score": 0.01577, "epss_percentile": 0.81121}, "CVE-2011-0177": {"epss_score": 0.01477, "epss_percentile": 0.80546}, "CVE-2011-0178": {"epss_score": 0.00049, "epss_percentile": 0.15429}, "CVE-2011-0179": {"epss_score": 0.01178, "epss_percentile": 0.78282}, "CVE-2011-0180": {"epss_score": 0.00083, "epss_percentile": 0.24729}, "CVE-2011-0181": {"epss_score": 0.12356, "epss_percentile": 0.93648}, "CVE-2011-0182": {"epss_score": 0.00587, "epss_percentile": 0.68476}, "CVE-2011-0183": {"epss_score": 0.00699, "epss_percentile": 0.71444}, "CVE-2011-0184": {"epss_score": 0.02428, "epss_percentile": 0.84721}, "CVE-2011-0185": {"epss_score": 0.00059, "epss_percentile": 0.18642}, "CVE-2011-0186": {"epss_score": 0.00957, "epss_percentile": 0.75933}, "CVE-2011-0187": {"epss_score": 0.00598, "epss_percentile": 0.68777}, "CVE-2011-0188": {"epss_score": 0.02608, "epss_percentile": 0.85229}, "CVE-2011-0189": {"epss_score": 0.00222, "epss_percentile": 0.44753}, "CVE-2011-0190": {"epss_score": 0.00229, "epss_percentile": 0.45651}, "CVE-2011-0191": {"epss_score": 0.1892, "epss_percentile": 0.95097}, "CVE-2011-0192": {"epss_score": 0.09355, "epss_percentile": 0.92514}, "CVE-2011-0193": {"epss_score": 0.01162, "epss_percentile": 0.78151}, "CVE-2011-0194": {"epss_score": 0.01097, "epss_percentile": 0.7753}, "CVE-2011-0195": {"epss_score": 0.00712, "epss_percentile": 0.71747}, "CVE-2011-0196": {"epss_score": 0.00428, "epss_percentile": 0.61926}, "CVE-2011-0197": {"epss_score": 0.00046, "epss_percentile": 0.14178}, "CVE-2011-0198": {"epss_score": 0.11351, "epss_percentile": 0.93321}, "CVE-2011-0199": {"epss_score": 0.00173, "epss_percentile": 0.39047}, "CVE-2011-0200": {"epss_score": 0.04475, "epss_percentile": 0.88738}, "CVE-2011-0201": {"epss_score": 0.04281, "epss_percentile": 0.88489}, "CVE-2011-0202": {"epss_score": 0.0148, "epss_percentile": 0.80566}, "CVE-2011-0203": {"epss_score": 0.0017, "epss_percentile": 0.38668}, "CVE-2011-0204": {"epss_score": 0.04475, "epss_percentile": 0.88738}, "CVE-2011-0205": {"epss_score": 0.06115, "epss_percentile": 0.9049}, "CVE-2011-0206": {"epss_score": 0.00963, "epss_percentile": 0.76003}, "CVE-2011-0207": {"epss_score": 0.00307, "epss_percentile": 0.53474}, "CVE-2011-0208": {"epss_score": 0.02057, "epss_percentile": 0.83427}, "CVE-2011-0209": {"epss_score": 0.01404, "epss_percentile": 0.80035}, "CVE-2011-0210": {"epss_score": 0.02057, "epss_percentile": 0.83427}, "CVE-2011-0211": {"epss_score": 0.01404, "epss_percentile": 0.80035}, "CVE-2011-0212": {"epss_score": 0.00624, "epss_percentile": 0.69563}, "CVE-2011-0213": {"epss_score": 0.00818, "epss_percentile": 0.73851}, "CVE-2011-0214": {"epss_score": 0.00105, "epss_percentile": 0.29297}, "CVE-2011-0215": {"epss_score": 0.01751, "epss_percentile": 0.82104}, "CVE-2011-0216": {"epss_score": 0.02963, "epss_percentile": 0.86076}, "CVE-2011-0217": {"epss_score": 0.00175, "epss_percentile": 0.39366}, "CVE-2011-0218": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-0219": {"epss_score": 0.00125, "epss_percentile": 0.32484}, "CVE-2011-0220": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2011-0221": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-0222": {"epss_score": 0.36377, "epss_percentile": 0.96972}, "CVE-2011-0223": {"epss_score": 0.02045, "epss_percentile": 0.83383}, "CVE-2011-0224": {"epss_score": 0.01405, "epss_percentile": 0.80043}, "CVE-2011-0225": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-0226": {"epss_score": 0.0845, "epss_percentile": 0.92058}, "CVE-2011-0227": {"epss_score": 0.00149, "epss_percentile": 0.35938}, "CVE-2011-0228": {"epss_score": 0.10491, "epss_percentile": 0.93008}, "CVE-2011-0229": {"epss_score": 0.01856, "epss_percentile": 0.82572}, "CVE-2011-0230": {"epss_score": 0.01486, "epss_percentile": 0.80608}, "CVE-2011-0231": {"epss_score": 0.00291, "epss_percentile": 0.52169}, "CVE-2011-0232": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-0233": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-0234": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-0235": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-0237": {"epss_score": 0.02045, "epss_percentile": 0.83383}, "CVE-2011-0238": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-0240": {"epss_score": 0.02045, "epss_percentile": 0.83383}, "CVE-2011-0241": {"epss_score": 0.05323, "epss_percentile": 0.89731}, "CVE-2011-0242": {"epss_score": 0.00199, "epss_percentile": 0.42107}, "CVE-2011-0244": {"epss_score": 0.00174, "epss_percentile": 0.3919}, "CVE-2011-0245": {"epss_score": 0.03291, "epss_percentile": 0.86836}, "CVE-2011-0246": {"epss_score": 0.03324, "epss_percentile": 0.86915}, "CVE-2011-0247": {"epss_score": 0.079, "epss_percentile": 0.91752}, "CVE-2011-0248": {"epss_score": 0.02672, "epss_percentile": 0.85393}, "CVE-2011-0249": {"epss_score": 0.04476, "epss_percentile": 0.88739}, "CVE-2011-0250": {"epss_score": 0.04476, "epss_percentile": 0.88739}, "CVE-2011-0251": {"epss_score": 0.04476, "epss_percentile": 0.88739}, "CVE-2011-0252": {"epss_score": 0.04432, "epss_percentile": 0.8868}, "CVE-2011-0253": {"epss_score": 0.02045, "epss_percentile": 0.83383}, "CVE-2011-0254": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-0255": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-0256": {"epss_score": 0.01944, "epss_percentile": 0.82997}, "CVE-2011-0257": {"epss_score": 0.83296, "epss_percentile": 0.99243}, "CVE-2011-0258": {"epss_score": 0.05629, "epss_percentile": 0.90066}, "CVE-2011-0259": {"epss_score": 0.01105, "epss_percentile": 0.77608}, "CVE-2011-0260": {"epss_score": 0.00065, "epss_percentile": 0.20563}, "CVE-2011-0261": {"epss_score": 0.43529, "epss_percentile": 0.9739}, "CVE-2011-0262": {"epss_score": 0.46768, "epss_percentile": 0.97557}, "CVE-2011-0263": {"epss_score": 0.49375, "epss_percentile": 0.97682}, "CVE-2011-0264": {"epss_score": 0.49375, "epss_percentile": 0.97682}, "CVE-2011-0265": {"epss_score": 0.49375, "epss_percentile": 0.97682}, "CVE-2011-0266": {"epss_score": 0.77535, "epss_percentile": 0.9894}, "CVE-2011-0267": {"epss_score": 0.78987, "epss_percentile": 0.99014}, "CVE-2011-0268": {"epss_score": 0.42817, "epss_percentile": 0.97356}, "CVE-2011-0269": {"epss_score": 0.49375, "epss_percentile": 0.97682}, "CVE-2011-0270": {"epss_score": 0.46024, "epss_percentile": 0.97517}, "CVE-2011-0271": {"epss_score": 0.26595, "epss_percentile": 0.9616}, "CVE-2011-0272": {"epss_score": 0.36619, "epss_percentile": 0.9699}, "CVE-2011-0273": {"epss_score": 0.13177, "epss_percentile": 0.93893}, "CVE-2011-0274": {"epss_score": 0.00851, "epss_percentile": 0.74403}, "CVE-2011-0275": {"epss_score": 0.01044, "epss_percentile": 0.77004}, "CVE-2011-0276": {"epss_score": 0.84327, "epss_percentile": 0.99284}, "CVE-2011-0277": {"epss_score": 0.00167, "epss_percentile": 0.384}, "CVE-2011-0278": {"epss_score": 0.00071, "epss_percentile": 0.21995}, "CVE-2011-0279": {"epss_score": 0.00082, "epss_percentile": 0.2442}, "CVE-2011-0280": {"epss_score": 0.00674, "epss_percentile": 0.70872}, "CVE-2011-0281": {"epss_score": 0.12614, "epss_percentile": 0.93729}, "CVE-2011-0282": {"epss_score": 0.11249, "epss_percentile": 0.93278}, "CVE-2011-0283": {"epss_score": 0.01087, "epss_percentile": 0.77434}, "CVE-2011-0284": {"epss_score": 0.2264, "epss_percentile": 0.95662}, "CVE-2011-0285": {"epss_score": 0.5683, "epss_percentile": 0.98038}, "CVE-2011-0286": {"epss_score": 0.00499, "epss_percentile": 0.65274}, "CVE-2011-0287": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-0290": {"epss_score": 0.00716, "epss_percentile": 0.71862}, "CVE-2011-0291": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2011-0310": {"epss_score": 0.0281, "epss_percentile": 0.85717}, "CVE-2011-0311": {"epss_score": 0.00788, "epss_percentile": 0.73333}, "CVE-2011-0314": {"epss_score": 0.01606, "epss_percentile": 0.81303}, "CVE-2011-0315": {"epss_score": 0.00478, "epss_percentile": 0.64405}, "CVE-2011-0316": {"epss_score": 0.00649, "epss_percentile": 0.70238}, "CVE-2011-0317": {"epss_score": 0.01534, "epss_percentile": 0.80905}, "CVE-2011-0318": {"epss_score": 0.01534, "epss_percentile": 0.80905}, "CVE-2011-0319": {"epss_score": 0.01534, "epss_percentile": 0.80905}, "CVE-2011-0320": {"epss_score": 0.01534, "epss_percentile": 0.80905}, "CVE-2011-0321": {"epss_score": 0.01348, "epss_percentile": 0.79658}, "CVE-2011-0322": {"epss_score": 0.01039, "epss_percentile": 0.76952}, "CVE-2011-0323": {"epss_score": 0.02006, "epss_percentile": 0.83234}, "CVE-2011-0324": {"epss_score": 0.12916, "epss_percentile": 0.93816}, "CVE-2011-0329": {"epss_score": 0.00255, "epss_percentile": 0.48638}, "CVE-2011-0330": {"epss_score": 0.00493, "epss_percentile": 0.65054}, "CVE-2011-0331": {"epss_score": 0.03007, "epss_percentile": 0.86187}, "CVE-2011-0332": {"epss_score": 0.02409, "epss_percentile": 0.84659}, "CVE-2011-0333": {"epss_score": 0.06126, "epss_percentile": 0.90498}, "CVE-2011-0334": {"epss_score": 0.18186, "epss_percentile": 0.94971}, "CVE-2011-0335": {"epss_score": 0.03631, "epss_percentile": 0.87474}, "CVE-2011-0340": {"epss_score": 0.47349, "epss_percentile": 0.97584}, "CVE-2011-0341": {"epss_score": 0.02979, "epss_percentile": 0.86116}, "CVE-2011-0342": {"epss_score": 0.07347, "epss_percentile": 0.91422}, "CVE-2011-0343": {"epss_score": 0.00115, "epss_percentile": 0.30928}, "CVE-2011-0344": {"epss_score": 0.00826, "epss_percentile": 0.73966}, "CVE-2011-0345": {"epss_score": 0.00296, "epss_percentile": 0.52607}, "CVE-2011-0346": {"epss_score": 0.60677, "epss_percentile": 0.98216}, "CVE-2011-0347": {"epss_score": 0.39471, "epss_percentile": 0.97163}, "CVE-2011-0348": {"epss_score": 0.00203, "epss_percentile": 0.42552}, "CVE-2011-0349": {"epss_score": 0.01213, "epss_percentile": 0.78564}, "CVE-2011-0350": {"epss_score": 0.01213, "epss_percentile": 0.78564}, "CVE-2011-0352": {"epss_score": 0.02161, "epss_percentile": 0.83825}, "CVE-2011-0354": {"epss_score": 0.11746, "epss_percentile": 0.93464}, "CVE-2011-0355": {"epss_score": 0.01786, "epss_percentile": 0.82255}, "CVE-2011-0364": {"epss_score": 0.15536, "epss_percentile": 0.94453}, "CVE-2011-0372": {"epss_score": 0.04008, "epss_percentile": 0.88104}, "CVE-2011-0373": {"epss_score": 0.0163, "epss_percentile": 0.81444}, "CVE-2011-0374": {"epss_score": 0.0163, "epss_percentile": 0.81444}, "CVE-2011-0375": {"epss_score": 0.0163, "epss_percentile": 0.81444}, "CVE-2011-0376": {"epss_score": 0.012, "epss_percentile": 0.78477}, "CVE-2011-0377": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2011-0378": {"epss_score": 0.01871, "epss_percentile": 0.82638}, "CVE-2011-0379": {"epss_score": 0.06412, "epss_percentile": 0.90742}, "CVE-2011-0380": {"epss_score": 0.00467, "epss_percentile": 0.63814}, "CVE-2011-0381": {"epss_score": 0.02493, "epss_percentile": 0.84903}, "CVE-2011-0382": {"epss_score": 0.05305, "epss_percentile": 0.89711}, "CVE-2011-0383": {"epss_score": 0.04702, "epss_percentile": 0.89027}, "CVE-2011-0384": {"epss_score": 0.0571, "epss_percentile": 0.9014}, "CVE-2011-0385": {"epss_score": 0.05026, "epss_percentile": 0.89409}, "CVE-2011-0386": {"epss_score": 0.03151, "epss_percentile": 0.86506}, "CVE-2011-0387": {"epss_score": 0.00736, "epss_percentile": 0.72301}, "CVE-2011-0388": {"epss_score": 0.01001, "epss_percentile": 0.76496}, "CVE-2011-0389": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2011-0390": {"epss_score": 0.00726, "epss_percentile": 0.72077}, "CVE-2011-0391": {"epss_score": 0.00726, "epss_percentile": 0.72077}, "CVE-2011-0392": {"epss_score": 0.00776, "epss_percentile": 0.73093}, "CVE-2011-0393": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2011-0394": {"epss_score": 0.02214, "epss_percentile": 0.84025}, "CVE-2011-0395": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2011-0396": {"epss_score": 0.00337, "epss_percentile": 0.56044}, "CVE-2011-0398": {"epss_score": 0.00262, "epss_percentile": 0.49384}, "CVE-2011-0399": {"epss_score": 0.00389, "epss_percentile": 0.59413}, "CVE-2011-0400": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2011-0401": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2011-0402": {"epss_score": 0.01293, "epss_percentile": 0.79237}, "CVE-2011-0403": {"epss_score": 0.01773, "epss_percentile": 0.82207}, "CVE-2011-0404": {"epss_score": 0.78891, "epss_percentile": 0.99009}, "CVE-2011-0405": {"epss_score": 0.09891, "epss_percentile": 0.92755}, "CVE-2011-0406": {"epss_score": 0.59814, "epss_percentile": 0.98182}, "CVE-2011-0407": {"epss_score": 0.00216, "epss_percentile": 0.44216}, "CVE-2011-0408": {"epss_score": 0.05904, "epss_percentile": 0.90312}, "CVE-2011-0410": {"epss_score": 0.00438, "epss_percentile": 0.62571}, "CVE-2011-0411": {"epss_score": 0.7206, "epss_percentile": 0.98694}, "CVE-2011-0412": {"epss_score": 0.00066, "epss_percentile": 0.20957}, "CVE-2011-0413": {"epss_score": 0.04942, "epss_percentile": 0.89308}, "CVE-2011-0414": {"epss_score": 0.05991, "epss_percentile": 0.90386}, "CVE-2011-0418": {"epss_score": 0.1463, "epss_percentile": 0.94255}, "CVE-2011-0419": {"epss_score": 0.56212, "epss_percentile": 0.98012}, "CVE-2011-0420": {"epss_score": 0.15149, "epss_percentile": 0.94373}, "CVE-2011-0421": {"epss_score": 0.09302, "epss_percentile": 0.92491}, "CVE-2011-0423": {"epss_score": 0.02349, "epss_percentile": 0.84465}, "CVE-2011-0426": {"epss_score": 0.0013, "epss_percentile": 0.33263}, "CVE-2011-0427": {"epss_score": 0.05919, "epss_percentile": 0.9032}, "CVE-2011-0428": {"epss_score": 0.00317, "epss_percentile": 0.5439}, "CVE-2011-0430": {"epss_score": 0.02959, "epss_percentile": 0.86069}, "CVE-2011-0431": {"epss_score": 0.00656, "epss_percentile": 0.70447}, "CVE-2011-0432": {"epss_score": 0.01021, "epss_percentile": 0.76746}, "CVE-2011-0433": {"epss_score": 0.01892, "epss_percentile": 0.82732}, "CVE-2011-0434": {"epss_score": 0.0108, "epss_percentile": 0.77361}, "CVE-2011-0435": {"epss_score": 0.00833, "epss_percentile": 0.74085}, "CVE-2011-0436": {"epss_score": 0.00782, "epss_percentile": 0.73206}, "CVE-2011-0437": {"epss_score": 0.01209, "epss_percentile": 0.78538}, "CVE-2011-0438": {"epss_score": 0.00442, "epss_percentile": 0.62744}, "CVE-2011-0439": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2011-0440": {"epss_score": 0.00295, "epss_percentile": 0.52518}, "CVE-2011-0441": {"epss_score": 0.0003, "epss_percentile": 0.08194}, "CVE-2011-0442": {"epss_score": 0.00385, "epss_percentile": 0.59186}, "CVE-2011-0443": {"epss_score": 0.0031, "epss_percentile": 0.53781}, "CVE-2011-0444": {"epss_score": 0.06117, "epss_percentile": 0.90492}, "CVE-2011-0445": {"epss_score": 0.00696, "epss_percentile": 0.71392}, "CVE-2011-0446": {"epss_score": 0.0067, "epss_percentile": 0.70774}, "CVE-2011-0447": {"epss_score": 0.00991, "epss_percentile": 0.76383}, "CVE-2011-0448": {"epss_score": 0.00689, "epss_percentile": 0.71224}, "CVE-2011-0449": {"epss_score": 0.00555, "epss_percentile": 0.67476}, "CVE-2011-0450": {"epss_score": 0.03648, "epss_percentile": 0.87506}, "CVE-2011-0451": {"epss_score": 0.0048, "epss_percentile": 0.64461}, "CVE-2011-0452": {"epss_score": 0.00053, "epss_percentile": 0.1671}, "CVE-2011-0453": {"epss_score": 0.00707, "epss_percentile": 0.71662}, "CVE-2011-0454": {"epss_score": 0.04952, "epss_percentile": 0.89324}, "CVE-2011-0455": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2011-0456": {"epss_score": 0.03045, "epss_percentile": 0.86282}, "CVE-2011-0457": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2011-0458": {"epss_score": 0.00034, "epss_percentile": 0.09744}, "CVE-2011-0459": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2011-0460": {"epss_score": 0.00038, "epss_percentile": 0.11337}, "CVE-2011-0461": {"epss_score": 0.00024, "epss_percentile": 0.05734}, "CVE-2011-0462": {"epss_score": 0.00096, "epss_percentile": 0.27268}, "CVE-2011-0463": {"epss_score": 0.00085, "epss_percentile": 0.25241}, "CVE-2011-0464": {"epss_score": 0.1287, "epss_percentile": 0.93806}, "CVE-2011-0465": {"epss_score": 0.099, "epss_percentile": 0.92763}, "CVE-2011-0466": {"epss_score": 0.00199, "epss_percentile": 0.42132}, "CVE-2011-0467": {"epss_score": 0.00281, "epss_percentile": 0.51145}, "CVE-2011-0468": {"epss_score": 0.00047, "epss_percentile": 0.14487}, "CVE-2011-0469": {"epss_score": 0.00538, "epss_percentile": 0.66936}, "CVE-2011-0470": {"epss_score": 0.01767, "epss_percentile": 0.82173}, "CVE-2011-0471": {"epss_score": 0.02883, "epss_percentile": 0.85906}, "CVE-2011-0472": {"epss_score": 0.05744, "epss_percentile": 0.90174}, "CVE-2011-0473": {"epss_score": 0.03351, "epss_percentile": 0.86962}, "CVE-2011-0474": {"epss_score": 0.02875, "epss_percentile": 0.85882}, "CVE-2011-0475": {"epss_score": 0.0684, "epss_percentile": 0.91061}, "CVE-2011-0476": {"epss_score": 0.02623, "epss_percentile": 0.85258}, "CVE-2011-0477": {"epss_score": 0.02681, "epss_percentile": 0.85415}, "CVE-2011-0478": {"epss_score": 0.02515, "epss_percentile": 0.84982}, "CVE-2011-0479": {"epss_score": 0.01558, "epss_percentile": 0.81023}, "CVE-2011-0480": {"epss_score": 0.01657, "epss_percentile": 0.81602}, "CVE-2011-0481": {"epss_score": 0.02638, "epss_percentile": 0.85297}, "CVE-2011-0482": {"epss_score": 0.0327, "epss_percentile": 0.8679}, "CVE-2011-0483": {"epss_score": 0.01767, "epss_percentile": 0.82173}, "CVE-2011-0484": {"epss_score": 0.01767, "epss_percentile": 0.82173}, "CVE-2011-0485": {"epss_score": 0.05114, "epss_percentile": 0.89512}, "CVE-2011-0486": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2011-0487": {"epss_score": 0.01048, "epss_percentile": 0.77053}, "CVE-2011-0488": {"epss_score": 0.18242, "epss_percentile": 0.94978}, "CVE-2011-0489": {"epss_score": 0.24624, "epss_percentile": 0.9594}, "CVE-2011-0490": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2011-0491": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2011-0492": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2011-0493": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2011-0494": {"epss_score": 0.0023, "epss_percentile": 0.45707}, "CVE-2011-0495": {"epss_score": 0.00573, "epss_percentile": 0.68065}, "CVE-2011-0496": {"epss_score": 0.11613, "epss_percentile": 0.9342}, "CVE-2011-0497": {"epss_score": 0.00805, "epss_percentile": 0.73632}, "CVE-2011-0498": {"epss_score": 0.05179, "epss_percentile": 0.89577}, "CVE-2011-0499": {"epss_score": 0.59532, "epss_percentile": 0.98169}, "CVE-2011-0500": {"epss_score": 0.64306, "epss_percentile": 0.98372}, "CVE-2011-0501": {"epss_score": 0.09671, "epss_percentile": 0.92648}, "CVE-2011-0502": {"epss_score": 0.05103, "epss_percentile": 0.895}, "CVE-2011-0503": {"epss_score": 0.00234, "epss_percentile": 0.46103}, "CVE-2011-0504": {"epss_score": 0.02032, "epss_percentile": 0.83336}, "CVE-2011-0505": {"epss_score": 0.01872, "epss_percentile": 0.82639}, "CVE-2011-0506": {"epss_score": 0.01886, "epss_percentile": 0.82712}, "CVE-2011-0507": {"epss_score": 0.04149, "epss_percentile": 0.8832}, "CVE-2011-0508": {"epss_score": 0.00499, "epss_percentile": 0.65274}, "CVE-2011-0509": {"epss_score": 0.00504, "epss_percentile": 0.6549}, "CVE-2011-0510": {"epss_score": 0.00916, "epss_percentile": 0.75423}, "CVE-2011-0511": {"epss_score": 0.0014, "epss_percentile": 0.3479}, "CVE-2011-0512": {"epss_score": 0.00858, "epss_percentile": 0.74509}, "CVE-2011-0513": {"epss_score": 0.0009, "epss_percentile": 0.26149}, "CVE-2011-0514": {"epss_score": 0.71443, "epss_percentile": 0.98668}, "CVE-2011-0515": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2011-0516": {"epss_score": 0.00145, "epss_percentile": 0.35456}, "CVE-2011-0517": {"epss_score": 0.71601, "epss_percentile": 0.98675}, "CVE-2011-0518": {"epss_score": 0.61971, "epss_percentile": 0.98269}, "CVE-2011-0519": {"epss_score": 0.00103, "epss_percentile": 0.28917}, "CVE-2011-0520": {"epss_score": 0.06838, "epss_percentile": 0.91059}, "CVE-2011-0521": {"epss_score": 0.00113, "epss_percentile": 0.30656}, "CVE-2011-0522": {"epss_score": 0.6639, "epss_percentile": 0.98462}, "CVE-2011-0523": {"epss_score": 0.00063, "epss_percentile": 0.19848}, "CVE-2011-0524": {"epss_score": 0.00088, "epss_percentile": 0.25759}, "CVE-2011-0525": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2011-0526": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2011-0527": {"epss_score": 0.00182, "epss_percentile": 0.40274}, "CVE-2011-0528": {"epss_score": 0.00265, "epss_percentile": 0.49833}, "CVE-2011-0529": {"epss_score": 0.00447, "epss_percentile": 0.62989}, "CVE-2011-0530": {"epss_score": 0.09996, "epss_percentile": 0.92809}, "CVE-2011-0531": {"epss_score": 0.7325, "epss_percentile": 0.98743}, "CVE-2011-0532": {"epss_score": 0.00047, "epss_percentile": 0.14694}, "CVE-2011-0533": {"epss_score": 0.12757, "epss_percentile": 0.93765}, "CVE-2011-0534": {"epss_score": 0.16272, "epss_percentile": 0.94608}, "CVE-2011-0535": {"epss_score": 0.00431, "epss_percentile": 0.6209}, "CVE-2011-0536": {"epss_score": 0.00282, "epss_percentile": 0.51235}, "CVE-2011-0537": {"epss_score": 0.0063, "epss_percentile": 0.69694}, "CVE-2011-0538": {"epss_score": 0.25653, "epss_percentile": 0.96053}, "CVE-2011-0539": {"epss_score": 0.01721, "epss_percentile": 0.81934}, "CVE-2011-0541": {"epss_score": 0.00042, "epss_percentile": 0.1293}, "CVE-2011-0542": {"epss_score": 0.00059, "epss_percentile": 0.18844}, "CVE-2011-0543": {"epss_score": 0.00062, "epss_percentile": 0.19719}, "CVE-2011-0544": {"epss_score": 0.00339, "epss_percentile": 0.56169}, "CVE-2011-0545": {"epss_score": 0.04066, "epss_percentile": 0.88201}, "CVE-2011-0546": {"epss_score": 0.0062, "epss_percentile": 0.69456}, "CVE-2011-0547": {"epss_score": 0.32124, "epss_percentile": 0.96673}, "CVE-2011-0548": {"epss_score": 0.07056, "epss_percentile": 0.91218}, "CVE-2011-0549": {"epss_score": 0.011, "epss_percentile": 0.77562}, "CVE-2011-0550": {"epss_score": 0.00719, "epss_percentile": 0.71942}, "CVE-2011-0551": {"epss_score": 0.00264, "epss_percentile": 0.49552}, "CVE-2011-0552": {"epss_score": 0.00525, "epss_percentile": 0.66393}, "CVE-2011-0553": {"epss_score": 0.00443, "epss_percentile": 0.62798}, "CVE-2011-0554": {"epss_score": 0.02104, "epss_percentile": 0.83619}, "CVE-2011-0555": {"epss_score": 0.1137, "epss_percentile": 0.93325}, "CVE-2011-0556": {"epss_score": 0.04333, "epss_percentile": 0.88561}, "CVE-2011-0557": {"epss_score": 0.13667, "epss_percentile": 0.9403}, "CVE-2011-0558": {"epss_score": 0.02257, "epss_percentile": 0.84175}, "CVE-2011-0559": {"epss_score": 0.05124, "epss_percentile": 0.89522}, "CVE-2011-0560": {"epss_score": 0.12485, "epss_percentile": 0.93686}, "CVE-2011-0561": {"epss_score": 0.12485, "epss_percentile": 0.93686}, "CVE-2011-0562": {"epss_score": 0.00098, "epss_percentile": 0.27703}, "CVE-2011-0563": {"epss_score": 0.05649, "epss_percentile": 0.90083}, "CVE-2011-0564": {"epss_score": 0.00885, "epss_percentile": 0.74933}, "CVE-2011-0565": {"epss_score": 0.0661, "epss_percentile": 0.90886}, "CVE-2011-0566": {"epss_score": 0.07752, "epss_percentile": 0.91659}, "CVE-2011-0567": {"epss_score": 0.14127, "epss_percentile": 0.94141}, "CVE-2011-0568": {"epss_score": 0.02775, "epss_percentile": 0.85634}, "CVE-2011-0569": {"epss_score": 0.0475, "epss_percentile": 0.89103}, "CVE-2011-0570": {"epss_score": 0.00114, "epss_percentile": 0.30754}, "CVE-2011-0571": {"epss_score": 0.02503, "epss_percentile": 0.84932}, "CVE-2011-0572": {"epss_score": 0.02503, "epss_percentile": 0.84932}, "CVE-2011-0573": {"epss_score": 0.02503, "epss_percentile": 0.84932}, "CVE-2011-0574": {"epss_score": 0.02503, "epss_percentile": 0.84932}, "CVE-2011-0575": {"epss_score": 0.0013, "epss_percentile": 0.33243}, "CVE-2011-0577": {"epss_score": 0.09825, "epss_percentile": 0.92721}, "CVE-2011-0578": {"epss_score": 0.03043, "epss_percentile": 0.86277}, "CVE-2011-0579": {"epss_score": 0.01315, "epss_percentile": 0.79402}, "CVE-2011-0580": {"epss_score": 0.01633, "epss_percentile": 0.81463}, "CVE-2011-0581": {"epss_score": 0.02386, "epss_percentile": 0.8458}, "CVE-2011-0582": {"epss_score": 0.03076, "epss_percentile": 0.8636}, "CVE-2011-0583": {"epss_score": 0.01633, "epss_percentile": 0.81463}, "CVE-2011-0584": {"epss_score": 0.02203, "epss_percentile": 0.83994}, "CVE-2011-0585": {"epss_score": 0.01682, "epss_percentile": 0.81731}, "CVE-2011-0586": {"epss_score": 0.02826, "epss_percentile": 0.85757}, "CVE-2011-0587": {"epss_score": 0.01393, "epss_percentile": 0.79963}, "CVE-2011-0588": {"epss_score": 0.00114, "epss_percentile": 0.30754}, "CVE-2011-0589": {"epss_score": 0.02584, "epss_percentile": 0.85161}, "CVE-2011-0590": {"epss_score": 0.08531, "epss_percentile": 0.92106}, "CVE-2011-0591": {"epss_score": 0.04416, "epss_percentile": 0.88665}, "CVE-2011-0592": {"epss_score": 0.04416, "epss_percentile": 0.88665}, "CVE-2011-0593": {"epss_score": 0.05606, "epss_percentile": 0.90042}, "CVE-2011-0594": {"epss_score": 0.09931, "epss_percentile": 0.92777}, "CVE-2011-0595": {"epss_score": 0.12036, "epss_percentile": 0.93552}, "CVE-2011-0596": {"epss_score": 0.11482, "epss_percentile": 0.9338}, "CVE-2011-0598": {"epss_score": 0.153, "epss_percentile": 0.94405}, "CVE-2011-0599": {"epss_score": 0.12478, "epss_percentile": 0.93685}, "CVE-2011-0600": {"epss_score": 0.04556, "epss_percentile": 0.88846}, "CVE-2011-0602": {"epss_score": 0.09931, "epss_percentile": 0.92777}, "CVE-2011-0603": {"epss_score": 0.09976, "epss_percentile": 0.92799}, "CVE-2011-0604": {"epss_score": 0.01285, "epss_percentile": 0.79176}, "CVE-2011-0605": {"epss_score": 0.04116, "epss_percentile": 0.88277}, "CVE-2011-0606": {"epss_score": 0.15802, "epss_percentile": 0.94511}, "CVE-2011-0607": {"epss_score": 0.02503, "epss_percentile": 0.84932}, "CVE-2011-0608": {"epss_score": 0.02503, "epss_percentile": 0.84932}, "CVE-2011-0609": {"epss_score": 0.92193, "epss_percentile": 0.99698}, "CVE-2011-0610": {"epss_score": 0.05781, "epss_percentile": 0.90201}, "CVE-2011-0611": {"epss_score": 0.93698, "epss_percentile": 0.99835}, "CVE-2011-0612": {"epss_score": 0.00689, "epss_percentile": 0.71227}, "CVE-2011-0613": {"epss_score": 0.00667, "epss_percentile": 0.70711}, "CVE-2011-0614": {"epss_score": 0.32864, "epss_percentile": 0.96732}, "CVE-2011-0615": {"epss_score": 0.07997, "epss_percentile": 0.91813}, "CVE-2011-0618": {"epss_score": 0.06126, "epss_percentile": 0.90498}, "CVE-2011-0619": {"epss_score": 0.05847, "epss_percentile": 0.90258}, "CVE-2011-0620": {"epss_score": 0.05847, "epss_percentile": 0.90258}, "CVE-2011-0621": {"epss_score": 0.05847, "epss_percentile": 0.90258}, "CVE-2011-0622": {"epss_score": 0.05847, "epss_percentile": 0.90258}, "CVE-2011-0623": {"epss_score": 0.04606, "epss_percentile": 0.8891}, "CVE-2011-0624": {"epss_score": 0.04606, "epss_percentile": 0.8891}, "CVE-2011-0625": {"epss_score": 0.04606, "epss_percentile": 0.8891}, "CVE-2011-0626": {"epss_score": 0.04606, "epss_percentile": 0.8891}, "CVE-2011-0627": {"epss_score": 0.0786, "epss_percentile": 0.91726}, "CVE-2011-0628": {"epss_score": 0.11154, "epss_percentile": 0.93246}, "CVE-2011-0629": {"epss_score": 0.00229, "epss_percentile": 0.45615}, "CVE-2011-0633": {"epss_score": 0.00137, "epss_percentile": 0.34222}, "CVE-2011-0635": {"epss_score": 0.03822, "epss_percentile": 0.87786}, "CVE-2011-0636": {"epss_score": 0.00059, "epss_percentile": 0.18662}, "CVE-2011-0637": {"epss_score": 0.00064, "epss_percentile": 0.20386}, "CVE-2011-0638": {"epss_score": 0.01284, "epss_percentile": 0.79169}, "CVE-2011-0639": {"epss_score": 0.00056, "epss_percentile": 0.17832}, "CVE-2011-0640": {"epss_score": 0.0007, "epss_percentile": 0.218}, "CVE-2011-0641": {"epss_score": 0.00192, "epss_percentile": 0.41376}, "CVE-2011-0642": {"epss_score": 0.00084, "epss_percentile": 0.24984}, "CVE-2011-0643": {"epss_score": 0.00084, "epss_percentile": 0.24981}, "CVE-2011-0644": {"epss_score": 0.00145, "epss_percentile": 0.35459}, "CVE-2011-0645": {"epss_score": 0.00135, "epss_percentile": 0.33942}, "CVE-2011-0646": {"epss_score": 0.0014, "epss_percentile": 0.3479}, "CVE-2011-0647": {"epss_score": 0.73163, "epss_percentile": 0.98739}, "CVE-2011-0648": {"epss_score": 0.02531, "epss_percentile": 0.85025}, "CVE-2011-0649": {"epss_score": 0.00107, "epss_percentile": 0.2964}, "CVE-2011-0650": {"epss_score": 0.00065, "epss_percentile": 0.20661}, "CVE-2011-0651": {"epss_score": 0.13831, "epss_percentile": 0.94069}, "CVE-2011-0652": {"epss_score": 0.00156, "epss_percentile": 0.37004}, "CVE-2011-0653": {"epss_score": 0.41343, "epss_percentile": 0.97268}, "CVE-2011-0654": {"epss_score": 0.79502, "epss_percentile": 0.99042}, "CVE-2011-0655": {"epss_score": 0.67766, "epss_percentile": 0.9852}, "CVE-2011-0656": {"epss_score": 0.5954, "epss_percentile": 0.9817}, "CVE-2011-0657": {"epss_score": 0.46929, "epss_percentile": 0.97563}, "CVE-2011-0658": {"epss_score": 0.35266, "epss_percentile": 0.96898}, "CVE-2011-0660": {"epss_score": 0.51628, "epss_percentile": 0.9779}, "CVE-2011-0661": {"epss_score": 0.65174, "epss_percentile": 0.98406}, "CVE-2011-0662": {"epss_score": 0.00747, "epss_percentile": 0.72559}, "CVE-2011-0663": {"epss_score": 0.27859, "epss_percentile": 0.96288}, "CVE-2011-0664": {"epss_score": 0.1119, "epss_percentile": 0.9326}, "CVE-2011-0665": {"epss_score": 0.00747, "epss_percentile": 0.72559}, "CVE-2011-0666": {"epss_score": 0.00747, "epss_percentile": 0.72559}, "CVE-2011-0667": {"epss_score": 0.00747, "epss_percentile": 0.72559}, "CVE-2011-0670": {"epss_score": 0.00747, "epss_percentile": 0.72559}, "CVE-2011-0671": {"epss_score": 0.01083, "epss_percentile": 0.77391}, "CVE-2011-0672": {"epss_score": 0.00747, "epss_percentile": 0.72559}, "CVE-2011-0673": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2011-0674": {"epss_score": 0.00747, "epss_percentile": 0.72559}, "CVE-2011-0675": {"epss_score": 0.00747, "epss_percentile": 0.72559}, "CVE-2011-0676": {"epss_score": 0.01139, "epss_percentile": 0.77946}, "CVE-2011-0677": {"epss_score": 0.0099, "epss_percentile": 0.76375}, "CVE-2011-0678": {"epss_score": 0.27886, "epss_percentile": 0.96291}, "CVE-2011-0679": {"epss_score": 0.02558, "epss_percentile": 0.85098}, "CVE-2011-0680": {"epss_score": 0.00893, "epss_percentile": 0.75072}, "CVE-2011-0681": {"epss_score": 0.00288, "epss_percentile": 0.51937}, "CVE-2011-0682": {"epss_score": 0.11212, "epss_percentile": 0.93266}, "CVE-2011-0683": {"epss_score": 0.00958, "epss_percentile": 0.7594}, "CVE-2011-0684": {"epss_score": 0.00834, "epss_percentile": 0.74099}, "CVE-2011-0685": {"epss_score": 0.0007, "epss_percentile": 0.21798}, "CVE-2011-0686": {"epss_score": 0.01347, "epss_percentile": 0.79655}, "CVE-2011-0687": {"epss_score": 0.01567, "epss_percentile": 0.81075}, "CVE-2011-0688": {"epss_score": 0.02678, "epss_percentile": 0.85411}, "CVE-2011-0694": {"epss_score": 0.06364, "epss_percentile": 0.90702}, "CVE-2011-0695": {"epss_score": 0.00442, "epss_percentile": 0.62736}, "CVE-2011-0696": {"epss_score": 0.0275, "epss_percentile": 0.85579}, "CVE-2011-0697": {"epss_score": 0.02962, "epss_percentile": 0.86073}, "CVE-2011-0698": {"epss_score": 0.00719, "epss_percentile": 0.71951}, "CVE-2011-0699": {"epss_score": 0.00046, "epss_percentile": 0.14319}, "CVE-2011-0700": {"epss_score": 0.00793, "epss_percentile": 0.73429}, "CVE-2011-0701": {"epss_score": 0.01555, "epss_percentile": 0.81004}, "CVE-2011-0702": {"epss_score": 0.0003, "epss_percentile": 0.07986}, "CVE-2011-0703": {"epss_score": 0.00432, "epss_percentile": 0.62125}, "CVE-2011-0704": {"epss_score": 0.00453, "epss_percentile": 0.63203}, "CVE-2011-0706": {"epss_score": 0.0155, "epss_percentile": 0.80987}, "CVE-2011-0707": {"epss_score": 0.0246, "epss_percentile": 0.84821}, "CVE-2011-0708": {"epss_score": 0.18361, "epss_percentile": 0.95003}, "CVE-2011-0709": {"epss_score": 0.02318, "epss_percentile": 0.84361}, "CVE-2011-0710": {"epss_score": 0.00108, "epss_percentile": 0.29843}, "CVE-2011-0711": {"epss_score": 0.00055, "epss_percentile": 0.17458}, "CVE-2011-0712": {"epss_score": 0.00056, "epss_percentile": 0.17812}, "CVE-2011-0713": {"epss_score": 0.02269, "epss_percentile": 0.84204}, "CVE-2011-0714": {"epss_score": 0.00307, "epss_percentile": 0.53504}, "CVE-2011-0715": {"epss_score": 0.11091, "epss_percentile": 0.93216}, "CVE-2011-0716": {"epss_score": 0.00068, "epss_percentile": 0.21292}, "CVE-2011-0717": {"epss_score": 0.00521, "epss_percentile": 0.66218}, "CVE-2011-0718": {"epss_score": 0.00515, "epss_percentile": 0.66003}, "CVE-2011-0719": {"epss_score": 0.12102, "epss_percentile": 0.93567}, "CVE-2011-0720": {"epss_score": 0.01407, "epss_percentile": 0.80061}, "CVE-2011-0721": {"epss_score": 0.0142, "epss_percentile": 0.80169}, "CVE-2011-0722": {"epss_score": 0.0089, "epss_percentile": 0.75031}, "CVE-2011-0723": {"epss_score": 0.01013, "epss_percentile": 0.76635}, "CVE-2011-0724": {"epss_score": 0.01189, "epss_percentile": 0.7837}, "CVE-2011-0725": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2011-0726": {"epss_score": 0.00074, "epss_percentile": 0.22866}, "CVE-2011-0727": {"epss_score": 0.00064, "epss_percentile": 0.20407}, "CVE-2011-0728": {"epss_score": 0.00421, "epss_percentile": 0.61524}, "CVE-2011-0729": {"epss_score": 0.00051, "epss_percentile": 0.16254}, "CVE-2011-0730": {"epss_score": 0.00467, "epss_percentile": 0.63818}, "CVE-2011-0731": {"epss_score": 0.09975, "epss_percentile": 0.92799}, "CVE-2011-0732": {"epss_score": 0.00627, "epss_percentile": 0.69632}, "CVE-2011-0733": {"epss_score": 0.00791, "epss_percentile": 0.73396}, "CVE-2011-0734": {"epss_score": 0.00791, "epss_percentile": 0.73396}, "CVE-2011-0735": {"epss_score": 0.00603, "epss_percentile": 0.68906}, "CVE-2011-0736": {"epss_score": 0.00821, "epss_percentile": 0.73907}, "CVE-2011-0737": {"epss_score": 0.00891, "epss_percentile": 0.7505}, "CVE-2011-0738": {"epss_score": 0.00786, "epss_percentile": 0.73294}, "CVE-2011-0739": {"epss_score": 0.0074, "epss_percentile": 0.72401}, "CVE-2011-0740": {"epss_score": 0.02392, "epss_percentile": 0.84606}, "CVE-2011-0741": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2011-0742": {"epss_score": 0.45285, "epss_percentile": 0.9748}, "CVE-2011-0745": {"epss_score": 0.07692, "epss_percentile": 0.91629}, "CVE-2011-0746": {"epss_score": 0.00079, "epss_percentile": 0.23879}, "CVE-2011-0748": {"epss_score": 0.00452, "epss_percentile": 0.63198}, "CVE-2011-0751": {"epss_score": 0.06922, "epss_percentile": 0.91118}, "CVE-2011-0752": {"epss_score": 0.00538, "epss_percentile": 0.6693}, "CVE-2011-0753": {"epss_score": 0.00526, "epss_percentile": 0.6643}, "CVE-2011-0754": {"epss_score": 0.00028, "epss_percentile": 0.07287}, "CVE-2011-0755": {"epss_score": 0.00408, "epss_percentile": 0.60626}, "CVE-2011-0756": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-0757": {"epss_score": 0.01049, "epss_percentile": 0.77061}, "CVE-2011-0758": {"epss_score": 0.22069, "epss_percentile": 0.95592}, "CVE-2011-0759": {"epss_score": 0.00126, "epss_percentile": 0.32686}, "CVE-2011-0760": {"epss_score": 0.00089, "epss_percentile": 0.25797}, "CVE-2011-0761": {"epss_score": 0.04159, "epss_percentile": 0.88332}, "CVE-2011-0762": {"epss_score": 0.45278, "epss_percentile": 0.9748}, "CVE-2011-0764": {"epss_score": 0.31187, "epss_percentile": 0.96599}, "CVE-2011-0765": {"epss_score": 0.00075, "epss_percentile": 0.22989}, "CVE-2011-0766": {"epss_score": 0.03371, "epss_percentile": 0.8701}, "CVE-2011-0767": {"epss_score": 0.00653, "epss_percentile": 0.70337}, "CVE-2011-0770": {"epss_score": 0.01329, "epss_percentile": 0.79503}, "CVE-2011-0771": {"epss_score": 0.00938, "epss_percentile": 0.75712}, "CVE-2011-0772": {"epss_score": 0.05764, "epss_percentile": 0.90187}, "CVE-2011-0773": {"epss_score": 0.07551, "epss_percentile": 0.91534}, "CVE-2011-0774": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-0775": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-0776": {"epss_score": 0.00227, "epss_percentile": 0.45379}, "CVE-2011-0777": {"epss_score": 0.01479, "epss_percentile": 0.80562}, "CVE-2011-0778": {"epss_score": 0.00542, "epss_percentile": 0.67084}, "CVE-2011-0779": {"epss_score": 0.01479, "epss_percentile": 0.80562}, "CVE-2011-0780": {"epss_score": 0.00485, "epss_percentile": 0.64732}, "CVE-2011-0781": {"epss_score": 0.00107, "epss_percentile": 0.29654}, "CVE-2011-0782": {"epss_score": 0.00455, "epss_percentile": 0.63303}, "CVE-2011-0783": {"epss_score": 0.01219, "epss_percentile": 0.7861}, "CVE-2011-0784": {"epss_score": 0.01722, "epss_percentile": 0.81939}, "CVE-2011-0785": {"epss_score": 0.00229, "epss_percentile": 0.45622}, "CVE-2011-0786": {"epss_score": 0.02091, "epss_percentile": 0.8357}, "CVE-2011-0787": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2011-0788": {"epss_score": 0.02343, "epss_percentile": 0.84443}, "CVE-2011-0789": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2011-0790": {"epss_score": 0.00053, "epss_percentile": 0.17012}, "CVE-2011-0791": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2011-0792": {"epss_score": 0.00375, "epss_percentile": 0.58637}, "CVE-2011-0793": {"epss_score": 0.00344, "epss_percentile": 0.56533}, "CVE-2011-0794": {"epss_score": 0.0015, "epss_percentile": 0.36149}, "CVE-2011-0795": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2011-0796": {"epss_score": 0.00077, "epss_percentile": 0.23298}, "CVE-2011-0797": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2011-0798": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2011-0799": {"epss_score": 0.00509, "epss_percentile": 0.65737}, "CVE-2011-0800": {"epss_score": 0.00044, "epss_percentile": 0.13634}, "CVE-2011-0801": {"epss_score": 0.00054, "epss_percentile": 0.17366}, "CVE-2011-0802": {"epss_score": 0.12941, "epss_percentile": 0.93824}, "CVE-2011-0803": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2011-0804": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2011-0805": {"epss_score": 0.00229, "epss_percentile": 0.45622}, "CVE-2011-0806": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2011-0807": {"epss_score": 0.87545, "epss_percentile": 0.99432}, "CVE-2011-0808": {"epss_score": 0.0015, "epss_percentile": 0.36149}, "CVE-2011-0809": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2011-0810": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2011-0811": {"epss_score": 0.00431, "epss_percentile": 0.6204}, "CVE-2011-0812": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2011-0813": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2011-0814": {"epss_score": 0.12941, "epss_percentile": 0.93824}, "CVE-2011-0815": {"epss_score": 0.06895, "epss_percentile": 0.91098}, "CVE-2011-0816": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2011-0817": {"epss_score": 0.02193, "epss_percentile": 0.83944}, "CVE-2011-0818": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2011-0819": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2011-0820": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2011-0821": {"epss_score": 0.00052, "epss_percentile": 0.16456}, "CVE-2011-0822": {"epss_score": 0.00695, "epss_percentile": 0.71371}, "CVE-2011-0823": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2011-0824": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2011-0825": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2011-0826": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2011-0827": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2011-0828": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2011-0829": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2011-0830": {"epss_score": 0.00309, "epss_percentile": 0.53696}, "CVE-2011-0831": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2011-0832": {"epss_score": 0.00429, "epss_percentile": 0.61962}, "CVE-2011-0833": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2011-0834": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2011-0835": {"epss_score": 0.00429, "epss_percentile": 0.61962}, "CVE-2011-0836": {"epss_score": 0.02538, "epss_percentile": 0.8504}, "CVE-2011-0837": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2011-0838": {"epss_score": 0.00265, "epss_percentile": 0.49829}, "CVE-2011-0839": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2011-0840": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2011-0841": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2011-0843": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2011-0844": {"epss_score": 0.00272, "epss_percentile": 0.50418}, "CVE-2011-0845": {"epss_score": 0.01005, "epss_percentile": 0.76543}, "CVE-2011-0846": {"epss_score": 0.0065, "epss_percentile": 0.70259}, "CVE-2011-0847": {"epss_score": 0.00172, "epss_percentile": 0.39015}, "CVE-2011-0848": {"epss_score": 0.00485, "epss_percentile": 0.64706}, "CVE-2011-0849": {"epss_score": 0.00275, "epss_percentile": 0.50661}, "CVE-2011-0850": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2011-0851": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2011-0852": {"epss_score": 0.00485, "epss_percentile": 0.64706}, "CVE-2011-0853": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2011-0854": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2011-0855": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2011-0856": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2011-0857": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2011-0858": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2011-0859": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2011-0860": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2011-0861": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2011-0862": {"epss_score": 0.12941, "epss_percentile": 0.93824}, "CVE-2011-0863": {"epss_score": 0.03598, "epss_percentile": 0.87407}, "CVE-2011-0864": {"epss_score": 0.03598, "epss_percentile": 0.87407}, "CVE-2011-0865": {"epss_score": 0.03779, "epss_percentile": 0.87712}, "CVE-2011-0866": {"epss_score": 0.02739, "epss_percentile": 0.85554}, "CVE-2011-0867": {"epss_score": 0.03815, "epss_percentile": 0.87768}, "CVE-2011-0868": {"epss_score": 0.08541, "epss_percentile": 0.92113}, "CVE-2011-0869": {"epss_score": 0.03783, "epss_percentile": 0.87722}, "CVE-2011-0870": {"epss_score": 0.00695, "epss_percentile": 0.71371}, "CVE-2011-0871": {"epss_score": 0.10579, "epss_percentile": 0.93033}, "CVE-2011-0872": {"epss_score": 0.13091, "epss_percentile": 0.93872}, "CVE-2011-0873": {"epss_score": 0.14991, "epss_percentile": 0.94337}, "CVE-2011-0875": {"epss_score": 0.00302, "epss_percentile": 0.53131}, "CVE-2011-0876": {"epss_score": 0.00309, "epss_percentile": 0.53696}, "CVE-2011-0877": {"epss_score": 0.00309, "epss_percentile": 0.53696}, "CVE-2011-0879": {"epss_score": 0.00309, "epss_percentile": 0.53696}, "CVE-2011-0880": {"epss_score": 0.00429, "epss_percentile": 0.61962}, "CVE-2011-0881": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2011-0882": {"epss_score": 0.00485, "epss_percentile": 0.64706}, "CVE-2011-0883": {"epss_score": 0.00181, "epss_percentile": 0.40021}, "CVE-2011-0884": {"epss_score": 0.00251, "epss_percentile": 0.4828}, "CVE-2011-0885": {"epss_score": 0.19822, "epss_percentile": 0.95246}, "CVE-2011-0886": {"epss_score": 0.04252, "epss_percentile": 0.88453}, "CVE-2011-0887": {"epss_score": 0.10232, "epss_percentile": 0.92904}, "CVE-2011-0889": {"epss_score": 0.36619, "epss_percentile": 0.9699}, "CVE-2011-0890": {"epss_score": 0.00741, "epss_percentile": 0.72447}, "CVE-2011-0891": {"epss_score": 0.00039, "epss_percentile": 0.11717}, "CVE-2011-0892": {"epss_score": 0.00843, "epss_percentile": 0.74249}, "CVE-2011-0893": {"epss_score": 0.00843, "epss_percentile": 0.74249}, "CVE-2011-0894": {"epss_score": 0.00198, "epss_percentile": 0.42065}, "CVE-2011-0895": {"epss_score": 0.00432, "epss_percentile": 0.62104}, "CVE-2011-0896": {"epss_score": 0.01027, "epss_percentile": 0.7681}, "CVE-2011-0897": {"epss_score": 0.00061, "epss_percentile": 0.19373}, "CVE-2011-0898": {"epss_score": 0.00929, "epss_percentile": 0.75591}, "CVE-2011-0899": {"epss_score": 0.0032, "epss_percentile": 0.54631}, "CVE-2011-0900": {"epss_score": 0.19908, "epss_percentile": 0.95258}, "CVE-2011-0901": {"epss_score": 0.12358, "epss_percentile": 0.93648}, "CVE-2011-0902": {"epss_score": 0.01105, "epss_percentile": 0.77606}, "CVE-2011-0903": {"epss_score": 0.01033, "epss_percentile": 0.76873}, "CVE-2011-0904": {"epss_score": 0.00685, "epss_percentile": 0.71138}, "CVE-2011-0905": {"epss_score": 0.01211, "epss_percentile": 0.78554}, "CVE-2011-0908": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2011-0909": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-0910": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-0911": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-0912": {"epss_score": 0.01713, "epss_percentile": 0.8189}, "CVE-2011-0913": {"epss_score": 0.10609, "epss_percentile": 0.93045}, "CVE-2011-0914": {"epss_score": 0.11112, "epss_percentile": 0.93226}, "CVE-2011-0915": {"epss_score": 0.15358, "epss_percentile": 0.94416}, "CVE-2011-0916": {"epss_score": 0.10609, "epss_percentile": 0.93045}, "CVE-2011-0917": {"epss_score": 0.18675, "epss_percentile": 0.9505}, "CVE-2011-0918": {"epss_score": 0.10609, "epss_percentile": 0.93045}, "CVE-2011-0919": {"epss_score": 0.124, "epss_percentile": 0.93659}, "CVE-2011-0920": {"epss_score": 0.03745, "epss_percentile": 0.87661}, "CVE-2011-0921": {"epss_score": 0.04712, "epss_percentile": 0.89039}, "CVE-2011-0922": {"epss_score": 0.82006, "epss_percentile": 0.99169}, "CVE-2011-0923": {"epss_score": 0.89891, "epss_percentile": 0.99547}, "CVE-2011-0924": {"epss_score": 0.13352, "epss_percentile": 0.93939}, "CVE-2011-0925": {"epss_score": 0.02361, "epss_percentile": 0.84497}, "CVE-2011-0926": {"epss_score": 0.04521, "epss_percentile": 0.88799}, "CVE-2011-0935": {"epss_score": 0.01588, "epss_percentile": 0.8119}, "CVE-2011-0939": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2011-0941": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-0943": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-0944": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2011-0945": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-0946": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2011-0949": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-0951": {"epss_score": 0.65335, "epss_percentile": 0.98413}, "CVE-2011-0959": {"epss_score": 0.45036, "epss_percentile": 0.97468}, "CVE-2011-0960": {"epss_score": 0.00297, "epss_percentile": 0.52743}, "CVE-2011-0961": {"epss_score": 0.14897, "epss_percentile": 0.94315}, "CVE-2011-0962": {"epss_score": 0.06537, "epss_percentile": 0.9083}, "CVE-2011-0963": {"epss_score": 0.00255, "epss_percentile": 0.48644}, "CVE-2011-0966": {"epss_score": 0.41998, "epss_percentile": 0.97305}, "CVE-2011-0975": {"epss_score": 0.25987, "epss_percentile": 0.96098}, "CVE-2011-0976": {"epss_score": 0.64025, "epss_percentile": 0.9836}, "CVE-2011-0977": {"epss_score": 0.62606, "epss_percentile": 0.98299}, "CVE-2011-0978": {"epss_score": 0.75919, "epss_percentile": 0.9887}, "CVE-2011-0979": {"epss_score": 0.66749, "epss_percentile": 0.98478}, "CVE-2011-0980": {"epss_score": 0.62606, "epss_percentile": 0.98299}, "CVE-2011-0981": {"epss_score": 0.02239, "epss_percentile": 0.8411}, "CVE-2011-0982": {"epss_score": 0.02994, "epss_percentile": 0.8615}, "CVE-2011-0983": {"epss_score": 0.01845, "epss_percentile": 0.82509}, "CVE-2011-0984": {"epss_score": 0.01759, "epss_percentile": 0.82143}, "CVE-2011-0985": {"epss_score": 0.00422, "epss_percentile": 0.61541}, "CVE-2011-0986": {"epss_score": 0.00546, "epss_percentile": 0.67206}, "CVE-2011-0987": {"epss_score": 0.02698, "epss_percentile": 0.85447}, "CVE-2011-0988": {"epss_score": 0.00029, "epss_percentile": 0.07607}, "CVE-2011-0989": {"epss_score": 0.00973, "epss_percentile": 0.76146}, "CVE-2011-0990": {"epss_score": 0.01167, "epss_percentile": 0.7819}, "CVE-2011-0991": {"epss_score": 0.02709, "epss_percentile": 0.85479}, "CVE-2011-0992": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2011-0993": {"epss_score": 0.00132, "epss_percentile": 0.33591}, "CVE-2011-0994": {"epss_score": 0.2944, "epss_percentile": 0.96443}, "CVE-2011-0995": {"epss_score": 0.00038, "epss_percentile": 0.11094}, "CVE-2011-0996": {"epss_score": 0.00826, "epss_percentile": 0.73963}, "CVE-2011-0997": {"epss_score": 0.81401, "epss_percentile": 0.99137}, "CVE-2011-0999": {"epss_score": 0.00113, "epss_percentile": 0.30724}, "CVE-2011-10001": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2011-10002": {"epss_score": 0.00057, "epss_percentile": 0.1815}, "CVE-2011-10003": {"epss_score": 0.00055, "epss_percentile": 0.17609}, "CVE-2011-10004": {"epss_score": 0.00181, "epss_percentile": 0.40099}, "CVE-2011-10005": {"epss_score": 0.462, "epss_percentile": 0.97536}, "CVE-2011-10006": {"epss_score": 0.00067, "epss_percentile": 0.2112}, "CVE-2011-10007": {"epss_score": 0.00055, "epss_percentile": 0.17503}, "CVE-2011-10008": {"epss_score": 0.44704, "epss_percentile": 0.9745}, "CVE-2011-10009": {"epss_score": 0.58558, "epss_percentile": 0.98123}, "CVE-2011-10010": {"epss_score": 0.63181, "epss_percentile": 0.98323}, "CVE-2011-10011": {"epss_score": 0.63606, "epss_percentile": 0.9834}, "CVE-2011-10012": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2011-10013": {"epss_score": 0.61743, "epss_percentile": 0.98261}, "CVE-2011-10014": {"epss_score": 0.03003, "epss_percentile": 0.86176}, "CVE-2011-10015": {"epss_score": 0.05428, "epss_percentile": 0.89871}, "CVE-2011-10016": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2011-10017": {"epss_score": 0.73013, "epss_percentile": 0.98732}, "CVE-2011-10018": {"epss_score": 0.51626, "epss_percentile": 0.9779}, "CVE-2011-10019": {"epss_score": 0.73616, "epss_percentile": 0.98764}, "CVE-2011-10020": {"epss_score": 0.55964, "epss_percentile": 0.98004}, "CVE-2011-10021": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2011-10022": {"epss_score": 0.5977, "epss_percentile": 0.9818}, "CVE-2011-10023": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2011-10024": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2011-10025": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2011-10026": {"epss_score": 0.67542, "epss_percentile": 0.98512}, "CVE-2011-10027": {"epss_score": 0.27949, "epss_percentile": 0.96299}, "CVE-2011-10028": {"epss_score": 0.67453, "epss_percentile": 0.98507}, "CVE-2011-10029": {"epss_score": 0.58597, "epss_percentile": 0.98126}, "CVE-2011-10030": {"epss_score": 0.04761, "epss_percentile": 0.89118}, "CVE-2011-10032": {"epss_score": 0.72632, "epss_percentile": 0.9872}, "CVE-2011-10033": {"epss_score": 0.00109, "epss_percentile": 0.29946}, "CVE-2011-10034": {"epss_score": 0.00642, "epss_percentile": 0.70022}, "CVE-2011-10035": {"epss_score": 0.00016, "epss_percentile": 0.02847}, "CVE-2011-10036": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2011-10037": {"epss_score": 0.00714, "epss_percentile": 0.71805}, "CVE-2011-10038": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2011-10039": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2011-10040": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2011-1000": {"epss_score": 0.01261, "epss_percentile": 0.78977}, "CVE-2011-1001": {"epss_score": 0.00719, "epss_percentile": 0.7195}, "CVE-2011-1002": {"epss_score": 0.71384, "epss_percentile": 0.98666}, "CVE-2011-1003": {"epss_score": 0.08355, "epss_percentile": 0.92006}, "CVE-2011-1004": {"epss_score": 0.00044, "epss_percentile": 0.13538}, "CVE-2011-1005": {"epss_score": 0.04997, "epss_percentile": 0.89374}, "CVE-2011-1006": {"epss_score": 0.00132, "epss_percentile": 0.33553}, "CVE-2011-1007": {"epss_score": 0.00088, "epss_percentile": 0.25724}, "CVE-2011-1008": {"epss_score": 0.0061, "epss_percentile": 0.69159}, "CVE-2011-1009": {"epss_score": 0.0023, "epss_percentile": 0.4571}, "CVE-2011-1010": {"epss_score": 0.0004, "epss_percentile": 0.1197}, "CVE-2011-1011": {"epss_score": 0.00044, "epss_percentile": 0.13637}, "CVE-2011-1012": {"epss_score": 0.00034, "epss_percentile": 0.09569}, "CVE-2011-1013": {"epss_score": 0.00096, "epss_percentile": 0.27347}, "CVE-2011-1015": {"epss_score": 0.00252, "epss_percentile": 0.48339}, "CVE-2011-1016": {"epss_score": 0.00053, "epss_percentile": 0.16689}, "CVE-2011-1017": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2011-1018": {"epss_score": 0.21544, "epss_percentile": 0.95531}, "CVE-2011-1019": {"epss_score": 0.00057, "epss_percentile": 0.18005}, "CVE-2011-1020": {"epss_score": 0.00424, "epss_percentile": 0.61662}, "CVE-2011-1021": {"epss_score": 0.00169, "epss_percentile": 0.38601}, "CVE-2011-1022": {"epss_score": 0.00042, "epss_percentile": 0.1281}, "CVE-2011-1023": {"epss_score": 0.00151, "epss_percentile": 0.36251}, "CVE-2011-1024": {"epss_score": 0.00247, "epss_percentile": 0.47831}, "CVE-2011-1025": {"epss_score": 0.0728, "epss_percentile": 0.91382}, "CVE-2011-1026": {"epss_score": 0.00804, "epss_percentile": 0.73608}, "CVE-2011-1027": {"epss_score": 0.05194, "epss_percentile": 0.89598}, "CVE-2011-1028": {"epss_score": 0.00517, "epss_percentile": 0.66072}, "CVE-2011-1029": {"epss_score": 0.00208, "epss_percentile": 0.43262}, "CVE-2011-1030": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2011-1031": {"epss_score": 0.00031, "epss_percentile": 0.08508}, "CVE-2011-1032": {"epss_score": 0.00415, "epss_percentile": 0.61119}, "CVE-2011-1033": {"epss_score": 0.28353, "epss_percentile": 0.96346}, "CVE-2011-1034": {"epss_score": 0.00463, "epss_percentile": 0.63697}, "CVE-2011-1035": {"epss_score": 0.03366, "epss_percentile": 0.87002}, "CVE-2011-1036": {"epss_score": 0.05056, "epss_percentile": 0.89448}, "CVE-2011-1038": {"epss_score": 0.02711, "epss_percentile": 0.85493}, "CVE-2011-1042": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2011-1044": {"epss_score": 0.00059, "epss_percentile": 0.18621}, "CVE-2011-1045": {"epss_score": 0.00762, "epss_percentile": 0.72832}, "CVE-2011-1046": {"epss_score": 0.00348, "epss_percentile": 0.5683}, "CVE-2011-1047": {"epss_score": 0.02424, "epss_percentile": 0.8471}, "CVE-2011-1048": {"epss_score": 0.00118, "epss_percentile": 0.31399}, "CVE-2011-1049": {"epss_score": 0.00517, "epss_percentile": 0.66085}, "CVE-2011-1050": {"epss_score": 0.00497, "epss_percentile": 0.65197}, "CVE-2011-1051": {"epss_score": 0.00458, "epss_percentile": 0.63423}, "CVE-2011-1052": {"epss_score": 0.00543, "epss_percentile": 0.67091}, "CVE-2011-1053": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2011-1054": {"epss_score": 0.00458, "epss_percentile": 0.63423}, "CVE-2011-1055": {"epss_score": 0.01606, "epss_percentile": 0.81302}, "CVE-2011-1056": {"epss_score": 0.00034, "epss_percentile": 0.09685}, "CVE-2011-1058": {"epss_score": 0.0061, "epss_percentile": 0.69157}, "CVE-2011-1059": {"epss_score": 0.01343, "epss_percentile": 0.79607}, "CVE-2011-1060": {"epss_score": 0.0093, "epss_percentile": 0.75596}, "CVE-2011-1061": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2011-1062": {"epss_score": 0.01166, "epss_percentile": 0.7818}, "CVE-2011-1063": {"epss_score": 0.00401, "epss_percentile": 0.60237}, "CVE-2011-1064": {"epss_score": 0.00371, "epss_percentile": 0.58383}, "CVE-2011-1065": {"epss_score": 0.04502, "epss_percentile": 0.88767}, "CVE-2011-1066": {"epss_score": 0.00241, "epss_percentile": 0.47267}, "CVE-2011-1067": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2011-1068": {"epss_score": 0.15947, "epss_percentile": 0.94541}, "CVE-2011-1069": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2011-1070": {"epss_score": 0.00132, "epss_percentile": 0.33584}, "CVE-2011-1071": {"epss_score": 0.0408, "epss_percentile": 0.88218}, "CVE-2011-1072": {"epss_score": 0.00077, "epss_percentile": 0.23321}, "CVE-2011-1073": {"epss_score": 0.00024, "epss_percentile": 0.05766}, "CVE-2011-1074": {"epss_score": 0.00011, "epss_percentile": 0.0111}, "CVE-2011-1075": {"epss_score": 0.00197, "epss_percentile": 0.41954}, "CVE-2011-1076": {"epss_score": 0.00073, "epss_percentile": 0.22655}, "CVE-2011-1077": {"epss_score": 0.04481, "epss_percentile": 0.88742}, "CVE-2011-1078": {"epss_score": 0.00029, "epss_percentile": 0.07867}, "CVE-2011-1079": {"epss_score": 0.00063, "epss_percentile": 0.19906}, "CVE-2011-1080": {"epss_score": 0.00076, "epss_percentile": 0.23117}, "CVE-2011-1081": {"epss_score": 0.03385, "epss_percentile": 0.87039}, "CVE-2011-1082": {"epss_score": 0.00234, "epss_percentile": 0.46083}, "CVE-2011-1083": {"epss_score": 0.00169, "epss_percentile": 0.38568}, "CVE-2011-1084": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2011-1085": {"epss_score": 0.00157, "epss_percentile": 0.37089}, "CVE-2011-1086": {"epss_score": 0.00601, "epss_percentile": 0.6884}, "CVE-2011-1087": {"epss_score": 0.05574, "epss_percentile": 0.9001}, "CVE-2011-1088": {"epss_score": 0.2203, "epss_percentile": 0.95585}, "CVE-2011-1089": {"epss_score": 0.00087, "epss_percentile": 0.25613}, "CVE-2011-1090": {"epss_score": 0.00068, "epss_percentile": 0.21388}, "CVE-2011-1091": {"epss_score": 0.01489, "epss_percentile": 0.80621}, "CVE-2011-1092": {"epss_score": 0.11264, "epss_percentile": 0.93283}, "CVE-2011-1093": {"epss_score": 0.01222, "epss_percentile": 0.78653}, "CVE-2011-1094": {"epss_score": 0.00813, "epss_percentile": 0.73765}, "CVE-2011-1095": {"epss_score": 0.00087, "epss_percentile": 0.25534}, "CVE-2011-1096": {"epss_score": 0.01165, "epss_percentile": 0.7817}, "CVE-2011-1097": {"epss_score": 0.01623, "epss_percentile": 0.81401}, "CVE-2011-1098": {"epss_score": 0.00054, "epss_percentile": 0.17147}, "CVE-2011-1099": {"epss_score": 0.03397, "epss_percentile": 0.87061}, "CVE-2011-1100": {"epss_score": 0.00653, "epss_percentile": 0.7033}, "CVE-2011-1101": {"epss_score": 0.01576, "epss_percentile": 0.81115}, "CVE-2011-1102": {"epss_score": 0.00441, "epss_percentile": 0.62676}, "CVE-2011-1103": {"epss_score": 0.00384, "epss_percentile": 0.59153}, "CVE-2011-1104": {"epss_score": 0.00214, "epss_percentile": 0.44019}, "CVE-2011-1105": {"epss_score": 0.00339, "epss_percentile": 0.56175}, "CVE-2011-1106": {"epss_score": 0.00699, "epss_percentile": 0.71431}, "CVE-2011-1107": {"epss_score": 0.00999, "epss_percentile": 0.76478}, "CVE-2011-1108": {"epss_score": 0.00892, "epss_percentile": 0.75058}, "CVE-2011-1109": {"epss_score": 0.02321, "epss_percentile": 0.8437}, "CVE-2011-1110": {"epss_score": 0.0187, "epss_percentile": 0.8263}, "CVE-2011-1111": {"epss_score": 0.01471, "epss_percentile": 0.80502}, "CVE-2011-1112": {"epss_score": 0.0187, "epss_percentile": 0.8263}, "CVE-2011-1113": {"epss_score": 0.01714, "epss_percentile": 0.81893}, "CVE-2011-1114": {"epss_score": 0.02823, "epss_percentile": 0.85752}, "CVE-2011-1115": {"epss_score": 0.02823, "epss_percentile": 0.85752}, "CVE-2011-1116": {"epss_score": 0.0187, "epss_percentile": 0.8263}, "CVE-2011-1117": {"epss_score": 0.02823, "epss_percentile": 0.85752}, "CVE-2011-1118": {"epss_score": 0.00892, "epss_percentile": 0.75058}, "CVE-2011-1119": {"epss_score": 0.0184, "epss_percentile": 0.82491}, "CVE-2011-1120": {"epss_score": 0.02099, "epss_percentile": 0.83594}, "CVE-2011-1121": {"epss_score": 0.02823, "epss_percentile": 0.85752}, "CVE-2011-1122": {"epss_score": 0.02099, "epss_percentile": 0.83594}, "CVE-2011-1123": {"epss_score": 0.00471, "epss_percentile": 0.64017}, "CVE-2011-1124": {"epss_score": 0.0187, "epss_percentile": 0.8263}, "CVE-2011-1125": {"epss_score": 0.0187, "epss_percentile": 0.8263}, "CVE-2011-1126": {"epss_score": 0.00069, "epss_percentile": 0.21588}, "CVE-2011-1127": {"epss_score": 0.01768, "epss_percentile": 0.82179}, "CVE-2011-1128": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2011-1129": {"epss_score": 0.00253, "epss_percentile": 0.48437}, "CVE-2011-1130": {"epss_score": 0.00517, "epss_percentile": 0.66081}, "CVE-2011-1131": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2011-1132": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2011-1133": {"epss_score": 0.00863, "epss_percentile": 0.74584}, "CVE-2011-1134": {"epss_score": 0.05004, "epss_percentile": 0.89382}, "CVE-2011-1135": {"epss_score": 0.00863, "epss_percentile": 0.74584}, "CVE-2011-1136": {"epss_score": 0.00256, "epss_percentile": 0.4883}, "CVE-2011-1137": {"epss_score": 0.02571, "epss_percentile": 0.85129}, "CVE-2011-1138": {"epss_score": 0.0381, "epss_percentile": 0.87757}, "CVE-2011-1139": {"epss_score": 0.05271, "epss_percentile": 0.8968}, "CVE-2011-1140": {"epss_score": 0.30766, "epss_percentile": 0.96567}, "CVE-2011-1141": {"epss_score": 0.0188, "epss_percentile": 0.82685}, "CVE-2011-1142": {"epss_score": 0.00746, "epss_percentile": 0.72536}, "CVE-2011-1143": {"epss_score": 0.12012, "epss_percentile": 0.93547}, "CVE-2011-1144": {"epss_score": 0.00119, "epss_percentile": 0.31591}, "CVE-2011-1145": {"epss_score": 0.00218, "epss_percentile": 0.44407}, "CVE-2011-1146": {"epss_score": 0.01556, "epss_percentile": 0.81015}, "CVE-2011-1147": {"epss_score": 0.0342, "epss_percentile": 0.871}, "CVE-2011-1148": {"epss_score": 0.03167, "epss_percentile": 0.86542}, "CVE-2011-1149": {"epss_score": 0.00035, "epss_percentile": 0.1006}, "CVE-2011-1150": {"epss_score": 0.0023, "epss_percentile": 0.4571}, "CVE-2011-1151": {"epss_score": 0.00035, "epss_percentile": 0.09942}, "CVE-2011-1153": {"epss_score": 0.01969, "epss_percentile": 0.8309}, "CVE-2011-1154": {"epss_score": 0.00051, "epss_percentile": 0.16259}, "CVE-2011-1155": {"epss_score": 0.00098, "epss_percentile": 0.27758}, "CVE-2011-1156": {"epss_score": 0.02418, "epss_percentile": 0.84696}, "CVE-2011-1157": {"epss_score": 0.00608, "epss_percentile": 0.69074}, "CVE-2011-1158": {"epss_score": 0.00618, "epss_percentile": 0.69373}, "CVE-2011-1159": {"epss_score": 0.0017, "epss_percentile": 0.387}, "CVE-2011-1160": {"epss_score": 0.00174, "epss_percentile": 0.39203}, "CVE-2011-1162": {"epss_score": 0.00119, "epss_percentile": 0.31684}, "CVE-2011-1163": {"epss_score": 0.00108, "epss_percentile": 0.29891}, "CVE-2011-1164": {"epss_score": 0.00599, "epss_percentile": 0.68786}, "CVE-2011-1165": {"epss_score": 0.00671, "epss_percentile": 0.70793}, "CVE-2011-1166": {"epss_score": 0.00105, "epss_percentile": 0.29377}, "CVE-2011-1167": {"epss_score": 0.05526, "epss_percentile": 0.89963}, "CVE-2011-1168": {"epss_score": 0.01407, "epss_percentile": 0.80055}, "CVE-2011-1169": {"epss_score": 0.00049, "epss_percentile": 0.15469}, "CVE-2011-1170": {"epss_score": 0.00085, "epss_percentile": 0.25218}, "CVE-2011-1171": {"epss_score": 0.00085, "epss_percentile": 0.25218}, "CVE-2011-1172": {"epss_score": 0.00085, "epss_percentile": 0.25139}, "CVE-2011-1173": {"epss_score": 0.0083, "epss_percentile": 0.74022}, "CVE-2011-1174": {"epss_score": 0.0029, "epss_percentile": 0.52118}, "CVE-2011-1175": {"epss_score": 0.00284, "epss_percentile": 0.515}, "CVE-2011-1176": {"epss_score": 0.01299, "epss_percentile": 0.79285}, "CVE-2011-1178": {"epss_score": 0.02208, "epss_percentile": 0.84008}, "CVE-2011-1179": {"epss_score": 0.04325, "epss_percentile": 0.88552}, "CVE-2011-1180": {"epss_score": 0.01159, "epss_percentile": 0.78127}, "CVE-2011-1182": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2011-1183": {"epss_score": 0.00793, "epss_percentile": 0.73419}, "CVE-2011-1184": {"epss_score": 0.09137, "epss_percentile": 0.92417}, "CVE-2011-1185": {"epss_score": 0.00415, "epss_percentile": 0.61115}, "CVE-2011-1186": {"epss_score": 0.07229, "epss_percentile": 0.91335}, "CVE-2011-1187": {"epss_score": 0.00891, "epss_percentile": 0.75035}, "CVE-2011-1188": {"epss_score": 0.0323, "epss_percentile": 0.86694}, "CVE-2011-1189": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1190": {"epss_score": 0.00674, "epss_percentile": 0.70848}, "CVE-2011-1191": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1192": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1193": {"epss_score": 0.00768, "epss_percentile": 0.72971}, "CVE-2011-1194": {"epss_score": 0.00476, "epss_percentile": 0.64268}, "CVE-2011-1195": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1196": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1197": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1198": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1199": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1200": {"epss_score": 0.01453, "epss_percentile": 0.80372}, "CVE-2011-1201": {"epss_score": 0.0218, "epss_percentile": 0.83896}, "CVE-2011-1202": {"epss_score": 0.00644, "epss_percentile": 0.70082}, "CVE-2011-1203": {"epss_score": 0.02103, "epss_percentile": 0.83616}, "CVE-2011-1204": {"epss_score": 0.02435, "epss_percentile": 0.84736}, "CVE-2011-1205": {"epss_score": 0.00052, "epss_percentile": 0.16672}, "CVE-2011-1206": {"epss_score": 0.38004, "epss_percentile": 0.97081}, "CVE-2011-1207": {"epss_score": 0.05337, "epss_percentile": 0.89744}, "CVE-2011-1208": {"epss_score": 0.01967, "epss_percentile": 0.83085}, "CVE-2011-1209": {"epss_score": 0.00126, "epss_percentile": 0.32642}, "CVE-2011-1213": {"epss_score": 0.78656, "epss_percentile": 0.98996}, "CVE-2011-1214": {"epss_score": 0.18606, "epss_percentile": 0.95042}, "CVE-2011-1215": {"epss_score": 0.22976, "epss_percentile": 0.95712}, "CVE-2011-1216": {"epss_score": 0.22976, "epss_percentile": 0.95712}, "CVE-2011-1217": {"epss_score": 0.11061, "epss_percentile": 0.93206}, "CVE-2011-1218": {"epss_score": 0.08458, "epss_percentile": 0.92062}, "CVE-2011-1220": {"epss_score": 0.62671, "epss_percentile": 0.98302}, "CVE-2011-1221": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-1222": {"epss_score": 0.00051, "epss_percentile": 0.16122}, "CVE-2011-1223": {"epss_score": 0.00051, "epss_percentile": 0.16122}, "CVE-2011-1224": {"epss_score": 0.0012, "epss_percentile": 0.31796}, "CVE-2011-1225": {"epss_score": 0.0099, "epss_percentile": 0.76375}, "CVE-2011-1226": {"epss_score": 0.01012, "epss_percentile": 0.7662}, "CVE-2011-1227": {"epss_score": 0.01012, "epss_percentile": 0.7662}, "CVE-2011-1228": {"epss_score": 0.01012, "epss_percentile": 0.7662}, "CVE-2011-1229": {"epss_score": 0.00749, "epss_percentile": 0.7261}, "CVE-2011-1230": {"epss_score": 0.01012, "epss_percentile": 0.7662}, "CVE-2011-1231": {"epss_score": 0.0087, "epss_percentile": 0.74708}, "CVE-2011-1232": {"epss_score": 0.01012, "epss_percentile": 0.7662}, "CVE-2011-1233": {"epss_score": 0.01012, "epss_percentile": 0.7662}, "CVE-2011-1234": {"epss_score": 0.00765, "epss_percentile": 0.72914}, "CVE-2011-1235": {"epss_score": 0.00747, "epss_percentile": 0.72559}, "CVE-2011-1236": {"epss_score": 0.01054, "epss_percentile": 0.77112}, "CVE-2011-1237": {"epss_score": 0.01439, "epss_percentile": 0.80292}, "CVE-2011-1238": {"epss_score": 0.00747, "epss_percentile": 0.72559}, "CVE-2011-1239": {"epss_score": 0.00747, "epss_percentile": 0.72559}, "CVE-2011-1240": {"epss_score": 0.00747, "epss_percentile": 0.72559}, "CVE-2011-1241": {"epss_score": 0.0073, "epss_percentile": 0.72159}, "CVE-2011-1242": {"epss_score": 0.0073, "epss_percentile": 0.72159}, "CVE-2011-1243": {"epss_score": 0.40889, "epss_percentile": 0.97242}, "CVE-2011-1244": {"epss_score": 0.0689, "epss_percentile": 0.91094}, "CVE-2011-1245": {"epss_score": 0.21068, "epss_percentile": 0.95459}, "CVE-2011-1246": {"epss_score": 0.13093, "epss_percentile": 0.93873}, "CVE-2011-1247": {"epss_score": 0.17791, "epss_percentile": 0.94907}, "CVE-2011-1248": {"epss_score": 0.69183, "epss_percentile": 0.9858}, "CVE-2011-1249": {"epss_score": 0.11568, "epss_percentile": 0.93407}, "CVE-2011-1250": {"epss_score": 0.44481, "epss_percentile": 0.9744}, "CVE-2011-1251": {"epss_score": 0.36647, "epss_percentile": 0.96992}, "CVE-2011-1252": {"epss_score": 0.18931, "epss_percentile": 0.95099}, "CVE-2011-1253": {"epss_score": 0.19501, "epss_percentile": 0.95193}, "CVE-2011-1254": {"epss_score": 0.36647, "epss_percentile": 0.96992}, "CVE-2011-1255": {"epss_score": 0.52374, "epss_percentile": 0.97822}, "CVE-2011-1256": {"epss_score": 0.41477, "epss_percentile": 0.97276}, "CVE-2011-1257": {"epss_score": 0.07637, "epss_percentile": 0.91592}, "CVE-2011-1258": {"epss_score": 0.0328, "epss_percentile": 0.86814}, "CVE-2011-1260": {"epss_score": 0.82063, "epss_percentile": 0.9917}, "CVE-2011-1261": {"epss_score": 0.36647, "epss_percentile": 0.96992}, "CVE-2011-1262": {"epss_score": 0.36647, "epss_percentile": 0.96992}, "CVE-2011-1263": {"epss_score": 0.35654, "epss_percentile": 0.96925}, "CVE-2011-1264": {"epss_score": 0.0188, "epss_percentile": 0.82674}, "CVE-2011-1265": {"epss_score": 0.00525, "epss_percentile": 0.66383}, "CVE-2011-1266": {"epss_score": 0.3562, "epss_percentile": 0.96923}, "CVE-2011-1267": {"epss_score": 0.42911, "epss_percentile": 0.97362}, "CVE-2011-1268": {"epss_score": 0.35119, "epss_percentile": 0.96888}, "CVE-2011-1269": {"epss_score": 0.49499, "epss_percentile": 0.97691}, "CVE-2011-1270": {"epss_score": 0.34369, "epss_percentile": 0.96844}, "CVE-2011-1271": {"epss_score": 0.1642, "epss_percentile": 0.94658}, "CVE-2011-1272": {"epss_score": 0.50198, "epss_percentile": 0.97725}, "CVE-2011-1273": {"epss_score": 0.50077, "epss_percentile": 0.97718}, "CVE-2011-1274": {"epss_score": 0.50125, "epss_percentile": 0.97721}, "CVE-2011-1275": {"epss_score": 0.50125, "epss_percentile": 0.97721}, "CVE-2011-1276": {"epss_score": 0.50774, "epss_percentile": 0.97749}, "CVE-2011-1277": {"epss_score": 0.50198, "epss_percentile": 0.97725}, "CVE-2011-1278": {"epss_score": 0.50077, "epss_percentile": 0.97718}, "CVE-2011-1279": {"epss_score": 0.43527, "epss_percentile": 0.9739}, "CVE-2011-1280": {"epss_score": 0.32487, "epss_percentile": 0.96704}, "CVE-2011-1281": {"epss_score": 0.00878, "epss_percentile": 0.74823}, "CVE-2011-1282": {"epss_score": 0.01105, "epss_percentile": 0.77605}, "CVE-2011-1283": {"epss_score": 0.00878, "epss_percentile": 0.74823}, "CVE-2011-1284": {"epss_score": 0.01341, "epss_percentile": 0.79584}, "CVE-2011-1285": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1286": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1288": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-1290": {"epss_score": 0.03924, "epss_percentile": 0.8796}, "CVE-2011-1291": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1292": {"epss_score": 0.01366, "epss_percentile": 0.79779}, "CVE-2011-1293": {"epss_score": 0.01451, "epss_percentile": 0.80364}, "CVE-2011-1294": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1295": {"epss_score": 0.0229, "epss_percentile": 0.84278}, "CVE-2011-1296": {"epss_score": 0.0184, "epss_percentile": 0.82492}, "CVE-2011-1298": {"epss_score": 0.00287, "epss_percentile": 0.51838}, "CVE-2011-1300": {"epss_score": 0.0723, "epss_percentile": 0.91337}, "CVE-2011-1301": {"epss_score": 0.02506, "epss_percentile": 0.84937}, "CVE-2011-1302": {"epss_score": 0.04725, "epss_percentile": 0.89061}, "CVE-2011-1303": {"epss_score": 0.00446, "epss_percentile": 0.62914}, "CVE-2011-1304": {"epss_score": 0.00123, "epss_percentile": 0.32299}, "CVE-2011-1305": {"epss_score": 0.00315, "epss_percentile": 0.54172}, "CVE-2011-1306": {"epss_score": 0.00167, "epss_percentile": 0.38294}, "CVE-2011-1307": {"epss_score": 0.00047, "epss_percentile": 0.14475}, "CVE-2011-1308": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2011-1309": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2011-1310": {"epss_score": 0.00051, "epss_percentile": 0.16258}, "CVE-2011-1311": {"epss_score": 0.00301, "epss_percentile": 0.53044}, "CVE-2011-1312": {"epss_score": 0.00121, "epss_percentile": 0.31889}, "CVE-2011-1313": {"epss_score": 0.00314, "epss_percentile": 0.54147}, "CVE-2011-1314": {"epss_score": 0.00458, "epss_percentile": 0.63445}, "CVE-2011-1315": {"epss_score": 0.00808, "epss_percentile": 0.73689}, "CVE-2011-1316": {"epss_score": 0.00527, "epss_percentile": 0.66445}, "CVE-2011-1317": {"epss_score": 0.00458, "epss_percentile": 0.63445}, "CVE-2011-1318": {"epss_score": 0.00527, "epss_percentile": 0.66445}, "CVE-2011-1319": {"epss_score": 0.00414, "epss_percentile": 0.61094}, "CVE-2011-1320": {"epss_score": 0.00478, "epss_percentile": 0.64394}, "CVE-2011-1321": {"epss_score": 0.00322, "epss_percentile": 0.54786}, "CVE-2011-1322": {"epss_score": 0.00527, "epss_percentile": 0.66445}, "CVE-2011-1323": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2011-1324": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2011-1325": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2011-1326": {"epss_score": 0.00317, "epss_percentile": 0.54331}, "CVE-2011-1327": {"epss_score": 0.00054, "epss_percentile": 0.17053}, "CVE-2011-1328": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2011-1329": {"epss_score": 0.00973, "epss_percentile": 0.76161}, "CVE-2011-1330": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2011-1331": {"epss_score": 0.02965, "epss_percentile": 0.86079}, "CVE-2011-1332": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2011-1333": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2011-1334": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2011-1335": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2011-1336": {"epss_score": 0.09938, "epss_percentile": 0.92782}, "CVE-2011-1337": {"epss_score": 0.02017, "epss_percentile": 0.83278}, "CVE-2011-1338": {"epss_score": 0.00054, "epss_percentile": 0.17301}, "CVE-2011-1339": {"epss_score": 0.00147, "epss_percentile": 0.35744}, "CVE-2011-1340": {"epss_score": 0.00286, "epss_percentile": 0.51709}, "CVE-2011-1341": {"epss_score": 0.00165, "epss_percentile": 0.38022}, "CVE-2011-1342": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2011-1343": {"epss_score": 0.00375, "epss_percentile": 0.58614}, "CVE-2011-1344": {"epss_score": 0.05324, "epss_percentile": 0.89732}, "CVE-2011-1345": {"epss_score": 0.514, "epss_percentile": 0.97776}, "CVE-2011-1346": {"epss_score": 0.2714, "epss_percentile": 0.96211}, "CVE-2011-1347": {"epss_score": 0.28337, "epss_percentile": 0.96344}, "CVE-2011-1350": {"epss_score": 0.04051, "epss_percentile": 0.88176}, "CVE-2011-1352": {"epss_score": 0.00021, "epss_percentile": 0.04738}, "CVE-2011-1353": {"epss_score": 0.00221, "epss_percentile": 0.44678}, "CVE-2011-1355": {"epss_score": 0.0054, "epss_percentile": 0.67005}, "CVE-2011-1356": {"epss_score": 0.00056, "epss_percentile": 0.17797}, "CVE-2011-1357": {"epss_score": 0.00202, "epss_percentile": 0.42481}, "CVE-2011-1359": {"epss_score": 0.00193, "epss_percentile": 0.41411}, "CVE-2011-1360": {"epss_score": 0.00167, "epss_percentile": 0.38384}, "CVE-2011-1362": {"epss_score": 0.0023, "epss_percentile": 0.45669}, "CVE-2011-1364": {"epss_score": 0.00149, "epss_percentile": 0.35989}, "CVE-2011-1366": {"epss_score": 0.00974, "epss_percentile": 0.76174}, "CVE-2011-1367": {"epss_score": 0.01186, "epss_percentile": 0.78346}, "CVE-2011-1368": {"epss_score": 0.00207, "epss_percentile": 0.43081}, "CVE-2011-1370": {"epss_score": 0.00254, "epss_percentile": 0.48506}, "CVE-2011-1371": {"epss_score": 0.00202, "epss_percentile": 0.42481}, "CVE-2011-1372": {"epss_score": 0.00101, "epss_percentile": 0.28654}, "CVE-2011-1373": {"epss_score": 0.00055, "epss_percentile": 0.17403}, "CVE-2011-1374": {"epss_score": 0.0545, "epss_percentile": 0.8989}, "CVE-2011-1375": {"epss_score": 0.00053, "epss_percentile": 0.16793}, "CVE-2011-1376": {"epss_score": 0.00044, "epss_percentile": 0.13619}, "CVE-2011-1377": {"epss_score": 0.01374, "epss_percentile": 0.79826}, "CVE-2011-1378": {"epss_score": 0.00051, "epss_percentile": 0.16286}, "CVE-2011-1381": {"epss_score": 0.0016, "epss_percentile": 0.37476}, "CVE-2011-1384": {"epss_score": 0.00024, "epss_percentile": 0.06016}, "CVE-2011-1385": {"epss_score": 0.0527, "epss_percentile": 0.89676}, "CVE-2011-1386": {"epss_score": 0.00192, "epss_percentile": 0.41333}, "CVE-2011-1388": {"epss_score": 0.0271, "epss_percentile": 0.8549}, "CVE-2011-1389": {"epss_score": 0.06538, "epss_percentile": 0.90831}, "CVE-2011-1390": {"epss_score": 0.00658, "epss_percentile": 0.70494}, "CVE-2011-1391": {"epss_score": 0.0271, "epss_percentile": 0.8549}, "CVE-2011-1392": {"epss_score": 0.0254, "epss_percentile": 0.85048}, "CVE-2011-1393": {"epss_score": 0.01605, "epss_percentile": 0.81288}, "CVE-2011-1394": {"epss_score": 0.01501, "epss_percentile": 0.80718}, "CVE-2011-1395": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2011-1396": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2011-1397": {"epss_score": 0.00237, "epss_percentile": 0.4664}, "CVE-2011-1398": {"epss_score": 0.06753, "epss_percentile": 0.91003}, "CVE-2011-1400": {"epss_score": 0.03073, "epss_percentile": 0.86353}, "CVE-2011-1401": {"epss_score": 0.00385, "epss_percentile": 0.59186}, "CVE-2011-1402": {"epss_score": 0.00837, "epss_percentile": 0.74164}, "CVE-2011-1403": {"epss_score": 0.00295, "epss_percentile": 0.52518}, "CVE-2011-1404": {"epss_score": 0.00578, "epss_percentile": 0.68206}, "CVE-2011-1405": {"epss_score": 0.00287, "epss_percentile": 0.51809}, "CVE-2011-1406": {"epss_score": 0.00277, "epss_percentile": 0.50839}, "CVE-2011-1407": {"epss_score": 0.00715, "epss_percentile": 0.71848}, "CVE-2011-1408": {"epss_score": 0.00607, "epss_percentile": 0.69032}, "CVE-2011-1409": {"epss_score": 0.00676, "epss_percentile": 0.70923}, "CVE-2011-1411": {"epss_score": 0.00281, "epss_percentile": 0.51143}, "CVE-2011-1412": {"epss_score": 0.05632, "epss_percentile": 0.90069}, "CVE-2011-1413": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2011-1414": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2011-1416": {"epss_score": 0.00373, "epss_percentile": 0.58527}, "CVE-2011-1417": {"epss_score": 0.06133, "epss_percentile": 0.90504}, "CVE-2011-1418": {"epss_score": 0.00273, "epss_percentile": 0.50474}, "CVE-2011-1419": {"epss_score": 0.16103, "epss_percentile": 0.94573}, "CVE-2011-1420": {"epss_score": 0.00112, "epss_percentile": 0.30447}, "CVE-2011-1421": {"epss_score": 0.00045, "epss_percentile": 0.13958}, "CVE-2011-1422": {"epss_score": 0.00447, "epss_percentile": 0.62979}, "CVE-2011-1423": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2011-1424": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2011-1425": {"epss_score": 0.0931, "epss_percentile": 0.92495}, "CVE-2011-1426": {"epss_score": 0.05602, "epss_percentile": 0.9004}, "CVE-2011-1427": {"epss_score": 0.00752, "epss_percentile": 0.72661}, "CVE-2011-1428": {"epss_score": 0.00165, "epss_percentile": 0.38127}, "CVE-2011-1429": {"epss_score": 0.00756, "epss_percentile": 0.72739}, "CVE-2011-1430": {"epss_score": 0.00417, "epss_percentile": 0.61229}, "CVE-2011-1431": {"epss_score": 0.06675, "epss_percentile": 0.90936}, "CVE-2011-1432": {"epss_score": 0.07716, "epss_percentile": 0.91641}, "CVE-2011-1433": {"epss_score": 0.00362, "epss_percentile": 0.57774}, "CVE-2011-1434": {"epss_score": 0.0423, "epss_percentile": 0.8842}, "CVE-2011-1435": {"epss_score": 0.00922, "epss_percentile": 0.75494}, "CVE-2011-1436": {"epss_score": 0.00455, "epss_percentile": 0.63303}, "CVE-2011-1437": {"epss_score": 0.00701, "epss_percentile": 0.71496}, "CVE-2011-1438": {"epss_score": 0.00955, "epss_percentile": 0.75917}, "CVE-2011-1439": {"epss_score": 0.00248, "epss_percentile": 0.47972}, "CVE-2011-1440": {"epss_score": 0.02475, "epss_percentile": 0.8486}, "CVE-2011-1441": {"epss_score": 0.00701, "epss_percentile": 0.71496}, "CVE-2011-1442": {"epss_score": 0.00741, "epss_percentile": 0.72438}, "CVE-2011-1443": {"epss_score": 0.00701, "epss_percentile": 0.71496}, "CVE-2011-1444": {"epss_score": 0.00692, "epss_percentile": 0.71284}, "CVE-2011-1445": {"epss_score": 0.00689, "epss_percentile": 0.71235}, "CVE-2011-1446": {"epss_score": 0.00557, "epss_percentile": 0.6755}, "CVE-2011-1447": {"epss_score": 0.00701, "epss_percentile": 0.71496}, "CVE-2011-1448": {"epss_score": 0.00701, "epss_percentile": 0.71496}, "CVE-2011-1449": {"epss_score": 0.0234, "epss_percentile": 0.8443}, "CVE-2011-1450": {"epss_score": 0.01494, "epss_percentile": 0.80648}, "CVE-2011-1451": {"epss_score": 0.02271, "epss_percentile": 0.84216}, "CVE-2011-1452": {"epss_score": 0.00492, "epss_percentile": 0.64996}, "CVE-2011-1453": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-1454": {"epss_score": 0.00741, "epss_percentile": 0.72438}, "CVE-2011-1455": {"epss_score": 0.00868, "epss_percentile": 0.74663}, "CVE-2011-1456": {"epss_score": 0.00741, "epss_percentile": 0.72438}, "CVE-2011-1457": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-1459": {"epss_score": 0.00287, "epss_percentile": 0.51838}, "CVE-2011-1460": {"epss_score": 0.00277, "epss_percentile": 0.50823}, "CVE-2011-1462": {"epss_score": 0.03002, "epss_percentile": 0.86173}, "CVE-2011-1464": {"epss_score": 0.01147, "epss_percentile": 0.78007}, "CVE-2011-1465": {"epss_score": 0.00425, "epss_percentile": 0.61688}, "CVE-2011-1466": {"epss_score": 0.26119, "epss_percentile": 0.96115}, "CVE-2011-1467": {"epss_score": 0.07142, "epss_percentile": 0.9128}, "CVE-2011-1468": {"epss_score": 0.06826, "epss_percentile": 0.9105}, "CVE-2011-1469": {"epss_score": 0.06402, "epss_percentile": 0.90729}, "CVE-2011-1470": {"epss_score": 0.0349, "epss_percentile": 0.87229}, "CVE-2011-1471": {"epss_score": 0.09096, "epss_percentile": 0.924}, "CVE-2011-1472": {"epss_score": 0.00043, "epss_percentile": 0.13139}, "CVE-2011-1473": {"epss_score": 0.81008, "epss_percentile": 0.99116}, "CVE-2011-1474": {"epss_score": 0.00145, "epss_percentile": 0.35376}, "CVE-2011-1475": {"epss_score": 0.11701, "epss_percentile": 0.93455}, "CVE-2011-1476": {"epss_score": 0.00182, "epss_percentile": 0.40255}, "CVE-2011-1477": {"epss_score": 0.00075, "epss_percentile": 0.23018}, "CVE-2011-1478": {"epss_score": 0.00911, "epss_percentile": 0.75324}, "CVE-2011-1479": {"epss_score": 0.00105, "epss_percentile": 0.29386}, "CVE-2011-1480": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2011-1481": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2011-1482": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2011-1483": {"epss_score": 0.03742, "epss_percentile": 0.87658}, "CVE-2011-1484": {"epss_score": 0.01195, "epss_percentile": 0.78427}, "CVE-2011-1485": {"epss_score": 0.10444, "epss_percentile": 0.92988}, "CVE-2011-1486": {"epss_score": 0.00859, "epss_percentile": 0.74512}, "CVE-2011-1487": {"epss_score": 0.04202, "epss_percentile": 0.88389}, "CVE-2011-1488": {"epss_score": 0.00153, "epss_percentile": 0.36582}, "CVE-2011-1489": {"epss_score": 0.00153, "epss_percentile": 0.36582}, "CVE-2011-1490": {"epss_score": 0.00153, "epss_percentile": 0.36582}, "CVE-2011-1491": {"epss_score": 0.0039, "epss_percentile": 0.59499}, "CVE-2011-1492": {"epss_score": 0.0039, "epss_percentile": 0.59499}, "CVE-2011-1493": {"epss_score": 0.01033, "epss_percentile": 0.76878}, "CVE-2011-1494": {"epss_score": 0.00145, "epss_percentile": 0.3552}, "CVE-2011-1495": {"epss_score": 0.00132, "epss_percentile": 0.33542}, "CVE-2011-1496": {"epss_score": 0.00098, "epss_percentile": 0.2783}, "CVE-2011-1497": {"epss_score": 0.00328, "epss_percentile": 0.55184}, "CVE-2011-1498": {"epss_score": 0.03634, "epss_percentile": 0.87478}, "CVE-2011-1499": {"epss_score": 0.00781, "epss_percentile": 0.7318}, "CVE-2011-1500": {"epss_score": 0.00053, "epss_percentile": 0.16841}, "CVE-2011-1502": {"epss_score": 0.00514, "epss_percentile": 0.65961}, "CVE-2011-1503": {"epss_score": 0.00657, "epss_percentile": 0.70462}, "CVE-2011-1504": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2011-1505": {"epss_score": 0.01334, "epss_percentile": 0.79537}, "CVE-2011-1506": {"epss_score": 0.04986, "epss_percentile": 0.89364}, "CVE-2011-1507": {"epss_score": 0.00147, "epss_percentile": 0.3568}, "CVE-2011-1508": {"epss_score": 0.28098, "epss_percentile": 0.9631}, "CVE-2011-1509": {"epss_score": 0.00192, "epss_percentile": 0.41323}, "CVE-2011-1510": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2011-1511": {"epss_score": 0.67861, "epss_percentile": 0.98523}, "CVE-2011-1512": {"epss_score": 0.21613, "epss_percentile": 0.9554}, "CVE-2011-1513": {"epss_score": 0.01348, "epss_percentile": 0.79666}, "CVE-2011-1514": {"epss_score": 0.00719, "epss_percentile": 0.71949}, "CVE-2011-1515": {"epss_score": 0.01318, "epss_percentile": 0.7943}, "CVE-2011-1516": {"epss_score": 0.0382, "epss_percentile": 0.87774}, "CVE-2011-1517": {"epss_score": 0.02368, "epss_percentile": 0.84518}, "CVE-2011-1518": {"epss_score": 0.00454, "epss_percentile": 0.63268}, "CVE-2011-1519": {"epss_score": 0.09065, "epss_percentile": 0.92385}, "CVE-2011-1520": {"epss_score": 0.00057, "epss_percentile": 0.18046}, "CVE-2011-1521": {"epss_score": 0.00996, "epss_percentile": 0.76446}, "CVE-2011-1522": {"epss_score": 0.00605, "epss_percentile": 0.68995}, "CVE-2011-1523": {"epss_score": 0.0067, "epss_percentile": 0.70778}, "CVE-2011-1524": {"epss_score": 0.20539, "epss_percentile": 0.95375}, "CVE-2011-1525": {"epss_score": 0.32197, "epss_percentile": 0.96678}, "CVE-2011-1526": {"epss_score": 0.00323, "epss_percentile": 0.54921}, "CVE-2011-1527": {"epss_score": 0.101, "epss_percentile": 0.92848}, "CVE-2011-1528": {"epss_score": 0.09268, "epss_percentile": 0.92473}, "CVE-2011-1529": {"epss_score": 0.0557, "epss_percentile": 0.90006}, "CVE-2011-1530": {"epss_score": 0.00934, "epss_percentile": 0.75659}, "CVE-2011-1531": {"epss_score": 0.00785, "epss_percentile": 0.73249}, "CVE-2011-1532": {"epss_score": 0.02058, "epss_percentile": 0.83433}, "CVE-2011-1533": {"epss_score": 0.00785, "epss_percentile": 0.73249}, "CVE-2011-1534": {"epss_score": 0.00343, "epss_percentile": 0.56408}, "CVE-2011-1535": {"epss_score": 0.00364, "epss_percentile": 0.57927}, "CVE-2011-1536": {"epss_score": 0.00873, "epss_percentile": 0.74753}, "CVE-2011-1537": {"epss_score": 0.00674, "epss_percentile": 0.70872}, "CVE-2011-1538": {"epss_score": 0.00209, "epss_percentile": 0.43367}, "CVE-2011-1539": {"epss_score": 0.00873, "epss_percentile": 0.74753}, "CVE-2011-1540": {"epss_score": 0.00451, "epss_percentile": 0.63122}, "CVE-2011-1541": {"epss_score": 0.06143, "epss_percentile": 0.90516}, "CVE-2011-1542": {"epss_score": 0.00674, "epss_percentile": 0.70872}, "CVE-2011-1543": {"epss_score": 0.00155, "epss_percentile": 0.36856}, "CVE-2011-1544": {"epss_score": 0.00292, "epss_percentile": 0.52217}, "CVE-2011-1545": {"epss_score": 0.00145, "epss_percentile": 0.35442}, "CVE-2011-1546": {"epss_score": 0.01015, "epss_percentile": 0.76659}, "CVE-2011-1547": {"epss_score": 0.36379, "epss_percentile": 0.96972}, "CVE-2011-1548": {"epss_score": 0.00059, "epss_percentile": 0.18632}, "CVE-2011-1549": {"epss_score": 0.00061, "epss_percentile": 0.19415}, "CVE-2011-1550": {"epss_score": 0.00045, "epss_percentile": 0.13827}, "CVE-2011-1551": {"epss_score": 0.00036, "epss_percentile": 0.10235}, "CVE-2011-1552": {"epss_score": 0.22374, "epss_percentile": 0.95627}, "CVE-2011-1553": {"epss_score": 0.04953, "epss_percentile": 0.89326}, "CVE-2011-1554": {"epss_score": 0.06576, "epss_percentile": 0.90858}, "CVE-2011-1555": {"epss_score": 0.00386, "epss_percentile": 0.59267}, "CVE-2011-1556": {"epss_score": 0.01606, "epss_percentile": 0.81302}, "CVE-2011-1557": {"epss_score": 0.00196, "epss_percentile": 0.41763}, "CVE-2011-1558": {"epss_score": 0.00278, "epss_percentile": 0.50874}, "CVE-2011-1559": {"epss_score": 0.00506, "epss_percentile": 0.65624}, "CVE-2011-1560": {"epss_score": 0.00659, "epss_percentile": 0.70507}, "CVE-2011-1561": {"epss_score": 0.00373, "epss_percentile": 0.5847}, "CVE-2011-1562": {"epss_score": 0.01033, "epss_percentile": 0.76874}, "CVE-2011-1563": {"epss_score": 0.57529, "epss_percentile": 0.98069}, "CVE-2011-1564": {"epss_score": 0.4207, "epss_percentile": 0.9731}, "CVE-2011-1565": {"epss_score": 0.67888, "epss_percentile": 0.98523}, "CVE-2011-1566": {"epss_score": 0.77663, "epss_percentile": 0.98946}, "CVE-2011-1567": {"epss_score": 0.78999, "epss_percentile": 0.99014}, "CVE-2011-1568": {"epss_score": 0.48623, "epss_percentile": 0.97645}, "CVE-2011-1569": {"epss_score": 0.10197, "epss_percentile": 0.92888}, "CVE-2011-1570": {"epss_score": 0.00646, "epss_percentile": 0.70137}, "CVE-2011-1571": {"epss_score": 0.07147, "epss_percentile": 0.91281}, "CVE-2011-1572": {"epss_score": 0.00592, "epss_percentile": 0.68604}, "CVE-2011-1573": {"epss_score": 0.00751, "epss_percentile": 0.72646}, "CVE-2011-1574": {"epss_score": 0.67035, "epss_percentile": 0.9849}, "CVE-2011-1575": {"epss_score": 0.22184, "epss_percentile": 0.95604}, "CVE-2011-1576": {"epss_score": 0.00777, "epss_percentile": 0.73107}, "CVE-2011-1577": {"epss_score": 0.00073, "epss_percentile": 0.22615}, "CVE-2011-1578": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2011-1579": {"epss_score": 0.00933, "epss_percentile": 0.75643}, "CVE-2011-1580": {"epss_score": 0.00602, "epss_percentile": 0.68885}, "CVE-2011-1581": {"epss_score": 0.01072, "epss_percentile": 0.77273}, "CVE-2011-1582": {"epss_score": 0.0153, "epss_percentile": 0.80883}, "CVE-2011-1583": {"epss_score": 0.00515, "epss_percentile": 0.6597}, "CVE-2011-1584": {"epss_score": 0.01475, "epss_percentile": 0.80528}, "CVE-2011-1585": {"epss_score": 0.00051, "epss_percentile": 0.16105}, "CVE-2011-1586": {"epss_score": 0.00847, "epss_percentile": 0.7435}, "CVE-2011-1587": {"epss_score": 0.00223, "epss_percentile": 0.44899}, "CVE-2011-1588": {"epss_score": 0.0032, "epss_percentile": 0.54625}, "CVE-2011-1589": {"epss_score": 0.02106, "epss_percentile": 0.83632}, "CVE-2011-1590": {"epss_score": 0.02472, "epss_percentile": 0.8485}, "CVE-2011-1591": {"epss_score": 0.77213, "epss_percentile": 0.98926}, "CVE-2011-1592": {"epss_score": 0.01362, "epss_percentile": 0.79762}, "CVE-2011-1593": {"epss_score": 0.00041, "epss_percentile": 0.12416}, "CVE-2011-1594": {"epss_score": 0.00274, "epss_percentile": 0.50541}, "CVE-2011-1595": {"epss_score": 0.00325, "epss_percentile": 0.55001}, "CVE-2011-1597": {"epss_score": 0.01859, "epss_percentile": 0.82583}, "CVE-2011-1598": {"epss_score": 0.00048, "epss_percentile": 0.14992}, "CVE-2011-1599": {"epss_score": 0.00338, "epss_percentile": 0.56147}, "CVE-2011-1602": {"epss_score": 0.00062, "epss_percentile": 0.19625}, "CVE-2011-1603": {"epss_score": 0.00062, "epss_percentile": 0.19625}, "CVE-2011-1604": {"epss_score": 0.02018, "epss_percentile": 0.83285}, "CVE-2011-1605": {"epss_score": 0.02138, "epss_percentile": 0.83738}, "CVE-2011-1606": {"epss_score": 0.02138, "epss_percentile": 0.83738}, "CVE-2011-1607": {"epss_score": 0.00636, "epss_percentile": 0.69866}, "CVE-2011-1609": {"epss_score": 0.01817, "epss_percentile": 0.82398}, "CVE-2011-1610": {"epss_score": 0.02518, "epss_percentile": 0.84992}, "CVE-2011-1613": {"epss_score": 0.28911, "epss_percentile": 0.964}, "CVE-2011-1623": {"epss_score": 0.00434, "epss_percentile": 0.62311}, "CVE-2011-1624": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-1625": {"epss_score": 0.0033, "epss_percentile": 0.55497}, "CVE-2011-1637": {"epss_score": 0.00105, "epss_percentile": 0.29257}, "CVE-2011-1640": {"epss_score": 0.00527, "epss_percentile": 0.66472}, "CVE-2011-1643": {"epss_score": 0.012, "epss_percentile": 0.78477}, "CVE-2011-1645": {"epss_score": 0.01649, "epss_percentile": 0.81557}, "CVE-2011-1646": {"epss_score": 0.00622, "epss_percentile": 0.695}, "CVE-2011-1647": {"epss_score": 0.0021, "epss_percentile": 0.43447}, "CVE-2011-1649": {"epss_score": 0.00393, "epss_percentile": 0.59734}, "CVE-2011-1651": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-1652": {"epss_score": 0.12305, "epss_percentile": 0.93629}, "CVE-2011-1653": {"epss_score": 0.75331, "epss_percentile": 0.98838}, "CVE-2011-1654": {"epss_score": 0.03282, "epss_percentile": 0.8682}, "CVE-2011-1655": {"epss_score": 0.0986, "epss_percentile": 0.9274}, "CVE-2011-1657": {"epss_score": 0.1067, "epss_percentile": 0.93064}, "CVE-2011-1658": {"epss_score": 0.00119, "epss_percentile": 0.31552}, "CVE-2011-1659": {"epss_score": 0.02476, "epss_percentile": 0.84863}, "CVE-2011-1660": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2011-1661": {"epss_score": 0.00297, "epss_percentile": 0.52681}, "CVE-2011-1662": {"epss_score": 0.00256, "epss_percentile": 0.48789}, "CVE-2011-1663": {"epss_score": 0.00446, "epss_percentile": 0.62911}, "CVE-2011-1664": {"epss_score": 0.00108, "epss_percentile": 0.29832}, "CVE-2011-1665": {"epss_score": 0.01824, "epss_percentile": 0.82427}, "CVE-2011-1666": {"epss_score": 0.00463, "epss_percentile": 0.63633}, "CVE-2011-1667": {"epss_score": 0.01723, "epss_percentile": 0.81941}, "CVE-2011-1668": {"epss_score": 0.02387, "epss_percentile": 0.84581}, "CVE-2011-1669": {"epss_score": 0.01195, "epss_percentile": 0.78425}, "CVE-2011-1670": {"epss_score": 0.02875, "epss_percentile": 0.85882}, "CVE-2011-1671": {"epss_score": 0.07274, "epss_percentile": 0.91378}, "CVE-2011-1672": {"epss_score": 0.00795, "epss_percentile": 0.73466}, "CVE-2011-1673": {"epss_score": 0.00524, "epss_percentile": 0.66324}, "CVE-2011-1674": {"epss_score": 0.00772, "epss_percentile": 0.73031}, "CVE-2011-1675": {"epss_score": 0.00038, "epss_percentile": 0.11237}, "CVE-2011-1676": {"epss_score": 0.00097, "epss_percentile": 0.2746}, "CVE-2011-1677": {"epss_score": 0.00045, "epss_percentile": 0.13698}, "CVE-2011-1678": {"epss_score": 0.00677, "epss_percentile": 0.70954}, "CVE-2011-1679": {"epss_score": 0.00079, "epss_percentile": 0.23983}, "CVE-2011-1680": {"epss_score": 0.00148, "epss_percentile": 0.35901}, "CVE-2011-1681": {"epss_score": 0.00088, "epss_percentile": 0.25789}, "CVE-2011-1682": {"epss_score": 0.00209, "epss_percentile": 0.43378}, "CVE-2011-1683": {"epss_score": 0.0138, "epss_percentile": 0.79859}, "CVE-2011-1684": {"epss_score": 0.0494, "epss_percentile": 0.89306}, "CVE-2011-1685": {"epss_score": 0.01122, "epss_percentile": 0.77779}, "CVE-2011-1686": {"epss_score": 0.0092, "epss_percentile": 0.75473}, "CVE-2011-1687": {"epss_score": 0.00497, "epss_percentile": 0.6521}, "CVE-2011-1688": {"epss_score": 0.00358, "epss_percentile": 0.57494}, "CVE-2011-1689": {"epss_score": 0.00557, "epss_percentile": 0.67549}, "CVE-2011-1690": {"epss_score": 0.0082, "epss_percentile": 0.73878}, "CVE-2011-1691": {"epss_score": 0.02056, "epss_percentile": 0.83425}, "CVE-2011-1696": {"epss_score": 0.00566, "epss_percentile": 0.6782}, "CVE-2011-1699": {"epss_score": 0.27114, "epss_percentile": 0.96209}, "CVE-2011-1700": {"epss_score": 0.27114, "epss_percentile": 0.96209}, "CVE-2011-1701": {"epss_score": 0.12819, "epss_percentile": 0.93784}, "CVE-2011-1702": {"epss_score": 0.0986, "epss_percentile": 0.9274}, "CVE-2011-1703": {"epss_score": 0.12819, "epss_percentile": 0.93784}, "CVE-2011-1704": {"epss_score": 0.12819, "epss_percentile": 0.93784}, "CVE-2011-1705": {"epss_score": 0.12819, "epss_percentile": 0.93784}, "CVE-2011-1706": {"epss_score": 0.12819, "epss_percentile": 0.93784}, "CVE-2011-1707": {"epss_score": 0.23457, "epss_percentile": 0.9578}, "CVE-2011-1708": {"epss_score": 0.12819, "epss_percentile": 0.93784}, "CVE-2011-1709": {"epss_score": 0.00055, "epss_percentile": 0.17578}, "CVE-2011-1710": {"epss_score": 0.02311, "epss_percentile": 0.84337}, "CVE-2011-1711": {"epss_score": 0.00677, "epss_percentile": 0.70945}, "CVE-2011-1712": {"epss_score": 0.00331, "epss_percentile": 0.55522}, "CVE-2011-1713": {"epss_score": 0.17628, "epss_percentile": 0.94878}, "CVE-2011-1714": {"epss_score": 0.07551, "epss_percentile": 0.91534}, "CVE-2011-1715": {"epss_score": 0.06869, "epss_percentile": 0.91084}, "CVE-2011-1716": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2011-1717": {"epss_score": 0.00034, "epss_percentile": 0.09481}, "CVE-2011-1718": {"epss_score": 0.00835, "epss_percentile": 0.74113}, "CVE-2011-1719": {"epss_score": 0.20402, "epss_percentile": 0.95338}, "CVE-2011-1720": {"epss_score": 0.58262, "epss_percentile": 0.98105}, "CVE-2011-1721": {"epss_score": 0.00157, "epss_percentile": 0.37139}, "CVE-2011-1722": {"epss_score": 0.00738, "epss_percentile": 0.72349}, "CVE-2011-1723": {"epss_score": 0.07068, "epss_percentile": 0.91225}, "CVE-2011-1724": {"epss_score": 0.00374, "epss_percentile": 0.5855}, "CVE-2011-1725": {"epss_score": 0.01043, "epss_percentile": 0.76991}, "CVE-2011-1726": {"epss_score": 0.01198, "epss_percentile": 0.78456}, "CVE-2011-1727": {"epss_score": 0.01071, "epss_percentile": 0.77268}, "CVE-2011-1728": {"epss_score": 0.4946, "epss_percentile": 0.9769}, "CVE-2011-1729": {"epss_score": 0.4946, "epss_percentile": 0.9769}, "CVE-2011-1730": {"epss_score": 0.4946, "epss_percentile": 0.9769}, "CVE-2011-1731": {"epss_score": 0.44523, "epss_percentile": 0.97442}, "CVE-2011-1732": {"epss_score": 0.52718, "epss_percentile": 0.97836}, "CVE-2011-1733": {"epss_score": 0.4946, "epss_percentile": 0.9769}, "CVE-2011-1734": {"epss_score": 0.44523, "epss_percentile": 0.97442}, "CVE-2011-1735": {"epss_score": 0.517, "epss_percentile": 0.97795}, "CVE-2011-1736": {"epss_score": 0.29377, "epss_percentile": 0.96437}, "CVE-2011-1737": {"epss_score": 0.00669, "epss_percentile": 0.70753}, "CVE-2011-1738": {"epss_score": 0.00072, "epss_percentile": 0.22259}, "CVE-2011-1739": {"epss_score": 0.00336, "epss_percentile": 0.56004}, "CVE-2011-1740": {"epss_score": 0.00361, "epss_percentile": 0.57711}, "CVE-2011-1741": {"epss_score": 0.24609, "epss_percentile": 0.95939}, "CVE-2011-1742": {"epss_score": 0.00075, "epss_percentile": 0.2306}, "CVE-2011-1743": {"epss_score": 0.00312, "epss_percentile": 0.54001}, "CVE-2011-1744": {"epss_score": 0.00506, "epss_percentile": 0.65633}, "CVE-2011-1745": {"epss_score": 0.00043, "epss_percentile": 0.13136}, "CVE-2011-1746": {"epss_score": 0.0004, "epss_percentile": 0.12136}, "CVE-2011-1747": {"epss_score": 0.00055, "epss_percentile": 0.17557}, "CVE-2011-1748": {"epss_score": 0.00049, "epss_percentile": 0.15629}, "CVE-2011-1749": {"epss_score": 0.00163, "epss_percentile": 0.37771}, "CVE-2011-1750": {"epss_score": 0.0047, "epss_percentile": 0.63967}, "CVE-2011-1751": {"epss_score": 0.00371, "epss_percentile": 0.58353}, "CVE-2011-1752": {"epss_score": 0.22709, "epss_percentile": 0.95671}, "CVE-2011-1753": {"epss_score": 0.01937, "epss_percentile": 0.82963}, "CVE-2011-1754": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2011-1755": {"epss_score": 0.08459, "epss_percentile": 0.92063}, "CVE-2011-1756": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2011-1757": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2011-1758": {"epss_score": 0.00048, "epss_percentile": 0.14949}, "CVE-2011-1759": {"epss_score": 0.00182, "epss_percentile": 0.40255}, "CVE-2011-1760": {"epss_score": 0.00129, "epss_percentile": 0.3313}, "CVE-2011-1761": {"epss_score": 0.22541, "epss_percentile": 0.95649}, "CVE-2011-1762": {"epss_score": 0.00415, "epss_percentile": 0.61128}, "CVE-2011-1763": {"epss_score": 0.00081, "epss_percentile": 0.24209}, "CVE-2011-1764": {"epss_score": 0.0353, "epss_percentile": 0.87302}, "CVE-2011-1765": {"epss_score": 0.00329, "epss_percentile": 0.5541}, "CVE-2011-1766": {"epss_score": 0.00331, "epss_percentile": 0.55499}, "CVE-2011-1767": {"epss_score": 0.00599, "epss_percentile": 0.68798}, "CVE-2011-1768": {"epss_score": 0.00464, "epss_percentile": 0.63723}, "CVE-2011-1769": {"epss_score": 0.00072, "epss_percentile": 0.22259}, "CVE-2011-1770": {"epss_score": 0.04958, "epss_percentile": 0.89332}, "CVE-2011-1771": {"epss_score": 0.00065, "epss_percentile": 0.20615}, "CVE-2011-1772": {"epss_score": 0.57601, "epss_percentile": 0.98074}, "CVE-2011-1773": {"epss_score": 0.00072, "epss_percentile": 0.2242}, "CVE-2011-1774": {"epss_score": 0.76747, "epss_percentile": 0.98902}, "CVE-2011-1775": {"epss_score": 0.00561, "epss_percentile": 0.67677}, "CVE-2011-1776": {"epss_score": 0.00043, "epss_percentile": 0.13003}, "CVE-2011-1777": {"epss_score": 0.03024, "epss_percentile": 0.86234}, "CVE-2011-1778": {"epss_score": 0.03024, "epss_percentile": 0.86234}, "CVE-2011-1779": {"epss_score": 0.00459, "epss_percentile": 0.63454}, "CVE-2011-1780": {"epss_score": 0.00225, "epss_percentile": 0.45097}, "CVE-2011-1781": {"epss_score": 0.00064, "epss_percentile": 0.20354}, "CVE-2011-1782": {"epss_score": 0.01531, "epss_percentile": 0.80889}, "CVE-2011-1783": {"epss_score": 0.11093, "epss_percentile": 0.93217}, "CVE-2011-1784": {"epss_score": 0.00047, "epss_percentile": 0.14595}, "CVE-2011-1785": {"epss_score": 0.05293, "epss_percentile": 0.89699}, "CVE-2011-1786": {"epss_score": 0.02766, "epss_percentile": 0.85611}, "CVE-2011-1787": {"epss_score": 0.00067, "epss_percentile": 0.21085}, "CVE-2011-1788": {"epss_score": 0.00059, "epss_percentile": 0.18916}, "CVE-2011-1789": {"epss_score": 0.00361, "epss_percentile": 0.5772}, "CVE-2011-1793": {"epss_score": 0.00478, "epss_percentile": 0.64389}, "CVE-2011-1794": {"epss_score": 0.00478, "epss_percentile": 0.64389}, "CVE-2011-1795": {"epss_score": 0.00478, "epss_percentile": 0.64389}, "CVE-2011-1796": {"epss_score": 0.00561, "epss_percentile": 0.67665}, "CVE-2011-1797": {"epss_score": 0.01482, "epss_percentile": 0.80582}, "CVE-2011-1798": {"epss_score": 0.00478, "epss_percentile": 0.64389}, "CVE-2011-1799": {"epss_score": 0.00614, "epss_percentile": 0.69277}, "CVE-2011-1800": {"epss_score": 0.00818, "epss_percentile": 0.73856}, "CVE-2011-1801": {"epss_score": 0.00203, "epss_percentile": 0.42493}, "CVE-2011-1802": {"epss_score": 0.0049, "epss_percentile": 0.64942}, "CVE-2011-1803": {"epss_score": 0.00166, "epss_percentile": 0.38152}, "CVE-2011-1804": {"epss_score": 0.01274, "epss_percentile": 0.79099}, "CVE-2011-1805": {"epss_score": 0.00354, "epss_percentile": 0.57223}, "CVE-2011-1806": {"epss_score": 0.05397, "epss_percentile": 0.89829}, "CVE-2011-1807": {"epss_score": 0.05397, "epss_percentile": 0.89829}, "CVE-2011-1808": {"epss_score": 0.0125, "epss_percentile": 0.78882}, "CVE-2011-1809": {"epss_score": 0.01182, "epss_percentile": 0.78322}, "CVE-2011-1810": {"epss_score": 0.0053, "epss_percentile": 0.66626}, "CVE-2011-1811": {"epss_score": 0.01138, "epss_percentile": 0.77933}, "CVE-2011-1812": {"epss_score": 0.00539, "epss_percentile": 0.66989}, "CVE-2011-1813": {"epss_score": 0.01182, "epss_percentile": 0.78322}, "CVE-2011-1814": {"epss_score": 0.01182, "epss_percentile": 0.78322}, "CVE-2011-1815": {"epss_score": 0.00391, "epss_percentile": 0.59563}, "CVE-2011-1816": {"epss_score": 0.01182, "epss_percentile": 0.78322}, "CVE-2011-1817": {"epss_score": 0.01182, "epss_percentile": 0.78322}, "CVE-2011-1818": {"epss_score": 0.01182, "epss_percentile": 0.78322}, "CVE-2011-1819": {"epss_score": 0.00391, "epss_percentile": 0.59563}, "CVE-2011-1820": {"epss_score": 0.00067, "epss_percentile": 0.21083}, "CVE-2011-1821": {"epss_score": 0.0036, "epss_percentile": 0.57662}, "CVE-2011-1822": {"epss_score": 0.00051, "epss_percentile": 0.16258}, "CVE-2011-1823": {"epss_score": 0.44847, "epss_percentile": 0.97455}, "CVE-2011-1824": {"epss_score": 0.07855, "epss_percentile": 0.91722}, "CVE-2011-1825": {"epss_score": 0.00436, "epss_percentile": 0.62466}, "CVE-2011-1826": {"epss_score": 0.00512, "epss_percentile": 0.65858}, "CVE-2011-1827": {"epss_score": 0.02624, "epss_percentile": 0.8526}, "CVE-2011-1828": {"epss_score": 0.00063, "epss_percentile": 0.19859}, "CVE-2011-1829": {"epss_score": 0.00184, "epss_percentile": 0.40415}, "CVE-2011-1830": {"epss_score": 0.00203, "epss_percentile": 0.42572}, "CVE-2011-1831": {"epss_score": 0.00043, "epss_percentile": 0.12973}, "CVE-2011-1832": {"epss_score": 0.00042, "epss_percentile": 0.12799}, "CVE-2011-1833": {"epss_score": 0.00013, "epss_percentile": 0.01617}, "CVE-2011-1834": {"epss_score": 0.00056, "epss_percentile": 0.1772}, "CVE-2011-1835": {"epss_score": 0.00059, "epss_percentile": 0.18642}, "CVE-2011-1836": {"epss_score": 0.00047, "epss_percentile": 0.14496}, "CVE-2011-1837": {"epss_score": 0.00054, "epss_percentile": 0.17229}, "CVE-2011-1838": {"epss_score": 0.08716, "epss_percentile": 0.92224}, "CVE-2011-1839": {"epss_score": 0.00253, "epss_percentile": 0.48483}, "CVE-2011-1840": {"epss_score": 0.00062, "epss_percentile": 0.19565}, "CVE-2011-1841": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2011-1842": {"epss_score": 0.00051, "epss_percentile": 0.16254}, "CVE-2011-1843": {"epss_score": 0.00254, "epss_percentile": 0.48504}, "CVE-2011-1844": {"epss_score": 0.19667, "epss_percentile": 0.95223}, "CVE-2011-1845": {"epss_score": 0.19667, "epss_percentile": 0.95223}, "CVE-2011-1846": {"epss_score": 0.01326, "epss_percentile": 0.79478}, "CVE-2011-1847": {"epss_score": 0.01241, "epss_percentile": 0.78816}, "CVE-2011-1848": {"epss_score": 0.2887, "epss_percentile": 0.96395}, "CVE-2011-1849": {"epss_score": 0.15653, "epss_percentile": 0.94475}, "CVE-2011-1850": {"epss_score": 0.29839, "epss_percentile": 0.96479}, "CVE-2011-1851": {"epss_score": 0.22066, "epss_percentile": 0.9559}, "CVE-2011-1852": {"epss_score": 0.46324, "epss_percentile": 0.97541}, "CVE-2011-1853": {"epss_score": 0.15653, "epss_percentile": 0.94475}, "CVE-2011-1854": {"epss_score": 0.24344, "epss_percentile": 0.95908}, "CVE-2011-1855": {"epss_score": 0.0006, "epss_percentile": 0.18961}, "CVE-2011-1856": {"epss_score": 0.00701, "epss_percentile": 0.71497}, "CVE-2011-1857": {"epss_score": 0.00723, "epss_percentile": 0.72014}, "CVE-2011-1858": {"epss_score": 0.00071, "epss_percentile": 0.22067}, "CVE-2011-1859": {"epss_score": 0.00986, "epss_percentile": 0.76337}, "CVE-2011-1860": {"epss_score": 0.00986, "epss_percentile": 0.76337}, "CVE-2011-1861": {"epss_score": 0.01372, "epss_percentile": 0.79812}, "CVE-2011-1862": {"epss_score": 0.00785, "epss_percentile": 0.73249}, "CVE-2011-1863": {"epss_score": 0.00432, "epss_percentile": 0.62162}, "CVE-2011-1864": {"epss_score": 0.10657, "epss_percentile": 0.9306}, "CVE-2011-1865": {"epss_score": 0.89159, "epss_percentile": 0.99511}, "CVE-2011-1866": {"epss_score": 0.59104, "epss_percentile": 0.98148}, "CVE-2011-1867": {"epss_score": 0.4584, "epss_percentile": 0.97504}, "CVE-2011-1868": {"epss_score": 0.36231, "epss_percentile": 0.96962}, "CVE-2011-1869": {"epss_score": 0.34785, "epss_percentile": 0.96874}, "CVE-2011-1870": {"epss_score": 0.0263, "epss_percentile": 0.85281}, "CVE-2011-1871": {"epss_score": 0.68306, "epss_percentile": 0.98541}, "CVE-2011-1872": {"epss_score": 0.02914, "epss_percentile": 0.85978}, "CVE-2011-1873": {"epss_score": 0.27013, "epss_percentile": 0.96198}, "CVE-2011-1874": {"epss_score": 0.01031, "epss_percentile": 0.76858}, "CVE-2011-1875": {"epss_score": 0.0073, "epss_percentile": 0.72159}, "CVE-2011-1876": {"epss_score": 0.0073, "epss_percentile": 0.72159}, "CVE-2011-1877": {"epss_score": 0.00331, "epss_percentile": 0.55522}, "CVE-2011-1878": {"epss_score": 0.0073, "epss_percentile": 0.72159}, "CVE-2011-1879": {"epss_score": 0.0073, "epss_percentile": 0.72159}, "CVE-2011-1880": {"epss_score": 0.0099, "epss_percentile": 0.76375}, "CVE-2011-1881": {"epss_score": 0.00851, "epss_percentile": 0.7441}, "CVE-2011-1882": {"epss_score": 0.0073, "epss_percentile": 0.72159}, "CVE-2011-1883": {"epss_score": 0.0073, "epss_percentile": 0.72159}, "CVE-2011-1884": {"epss_score": 0.0073, "epss_percentile": 0.72159}, "CVE-2011-1885": {"epss_score": 0.0099, "epss_percentile": 0.76375}, "CVE-2011-1886": {"epss_score": 0.00315, "epss_percentile": 0.5419}, "CVE-2011-1887": {"epss_score": 0.009, "epss_percentile": 0.75159}, "CVE-2011-1888": {"epss_score": 0.00948, "epss_percentile": 0.75829}, "CVE-2011-1889": {"epss_score": 0.87578, "epss_percentile": 0.99434}, "CVE-2011-1890": {"epss_score": 0.34594, "epss_percentile": 0.9686}, "CVE-2011-1891": {"epss_score": 0.47875, "epss_percentile": 0.97606}, "CVE-2011-1892": {"epss_score": 0.62106, "epss_percentile": 0.98278}, "CVE-2011-1893": {"epss_score": 0.58888, "epss_percentile": 0.9814}, "CVE-2011-1894": {"epss_score": 0.13887, "epss_percentile": 0.94086}, "CVE-2011-1895": {"epss_score": 0.2112, "epss_percentile": 0.95465}, "CVE-2011-1896": {"epss_score": 0.10694, "epss_percentile": 0.93072}, "CVE-2011-1897": {"epss_score": 0.15113, "epss_percentile": 0.94367}, "CVE-2011-1898": {"epss_score": 0.00617, "epss_percentile": 0.6936}, "CVE-2011-1899": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2011-1900": {"epss_score": 0.49258, "epss_percentile": 0.97675}, "CVE-2011-1901": {"epss_score": 0.00727, "epss_percentile": 0.72095}, "CVE-2011-1902": {"epss_score": 0.00618, "epss_percentile": 0.69366}, "CVE-2011-1903": {"epss_score": 0.01374, "epss_percentile": 0.79823}, "CVE-2011-1904": {"epss_score": 0.04388, "epss_percentile": 0.88633}, "CVE-2011-1905": {"epss_score": 0.00214, "epss_percentile": 0.44019}, "CVE-2011-1906": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-1907": {"epss_score": 0.22514, "epss_percentile": 0.95647}, "CVE-2011-1908": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2011-1910": {"epss_score": 0.3401, "epss_percentile": 0.9682}, "CVE-2011-1911": {"epss_score": 0.00505, "epss_percentile": 0.6561}, "CVE-2011-1913": {"epss_score": 0.00708, "epss_percentile": 0.71669}, "CVE-2011-1914": {"epss_score": 0.01074, "epss_percentile": 0.77299}, "CVE-2011-1915": {"epss_score": 0.00374, "epss_percentile": 0.58558}, "CVE-2011-1918": {"epss_score": 0.01463, "epss_percentile": 0.80444}, "CVE-2011-1919": {"epss_score": 0.01015, "epss_percentile": 0.76665}, "CVE-2011-1920": {"epss_score": 0.00054, "epss_percentile": 0.17245}, "CVE-2011-1921": {"epss_score": 0.04037, "epss_percentile": 0.8816}, "CVE-2011-1922": {"epss_score": 0.01218, "epss_percentile": 0.78605}, "CVE-2011-1923": {"epss_score": 0.00357, "epss_percentile": 0.57462}, "CVE-2011-1924": {"epss_score": 0.01591, "epss_percentile": 0.81223}, "CVE-2011-1925": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2011-1926": {"epss_score": 0.04867, "epss_percentile": 0.89229}, "CVE-2011-1927": {"epss_score": 0.00833, "epss_percentile": 0.74096}, "CVE-2011-1928": {"epss_score": 0.14392, "epss_percentile": 0.94202}, "CVE-2011-1929": {"epss_score": 0.06541, "epss_percentile": 0.90834}, "CVE-2011-1930": {"epss_score": 0.28991, "epss_percentile": 0.96408}, "CVE-2011-1931": {"epss_score": 0.02339, "epss_percentile": 0.84427}, "CVE-2011-1932": {"epss_score": 0.00288, "epss_percentile": 0.51923}, "CVE-2011-1933": {"epss_score": 0.0054, "epss_percentile": 0.67018}, "CVE-2011-1934": {"epss_score": 0.00297, "epss_percentile": 0.52744}, "CVE-2011-1935": {"epss_score": 0.0125, "epss_percentile": 0.78879}, "CVE-2011-1936": {"epss_score": 0.00084, "epss_percentile": 0.24873}, "CVE-2011-1937": {"epss_score": 0.00658, "epss_percentile": 0.70496}, "CVE-2011-1938": {"epss_score": 0.37264, "epss_percentile": 0.97031}, "CVE-2011-1939": {"epss_score": 0.0646, "epss_percentile": 0.90769}, "CVE-2011-1940": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2011-1941": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2011-1943": {"epss_score": 0.00042, "epss_percentile": 0.12834}, "CVE-2011-1944": {"epss_score": 0.23686, "epss_percentile": 0.95803}, "CVE-2011-1945": {"epss_score": 0.04848, "epss_percentile": 0.89211}, "CVE-2011-1946": {"epss_score": 0.00047, "epss_percentile": 0.14694}, "CVE-2011-1947": {"epss_score": 0.02444, "epss_percentile": 0.84764}, "CVE-2011-1948": {"epss_score": 0.00529, "epss_percentile": 0.66594}, "CVE-2011-1949": {"epss_score": 0.00375, "epss_percentile": 0.58624}, "CVE-2011-1950": {"epss_score": 0.00762, "epss_percentile": 0.72832}, "CVE-2011-1951": {"epss_score": 0.01548, "epss_percentile": 0.80977}, "CVE-2011-1952": {"epss_score": 0.00848, "epss_percentile": 0.74364}, "CVE-2011-1953": {"epss_score": 0.00365, "epss_percentile": 0.5799}, "CVE-2011-1954": {"epss_score": 0.00259, "epss_percentile": 0.49085}, "CVE-2011-1956": {"epss_score": 0.0647, "epss_percentile": 0.90778}, "CVE-2011-1957": {"epss_score": 0.02126, "epss_percentile": 0.83692}, "CVE-2011-1958": {"epss_score": 0.01481, "epss_percentile": 0.80569}, "CVE-2011-1959": {"epss_score": 0.01937, "epss_percentile": 0.82964}, "CVE-2011-1960": {"epss_score": 0.16302, "epss_percentile": 0.94614}, "CVE-2011-1961": {"epss_score": 0.25782, "epss_percentile": 0.96069}, "CVE-2011-1962": {"epss_score": 0.15866, "epss_percentile": 0.94522}, "CVE-2011-1963": {"epss_score": 0.41098, "epss_percentile": 0.97254}, "CVE-2011-1964": {"epss_score": 0.41098, "epss_percentile": 0.97254}, "CVE-2011-1965": {"epss_score": 0.67492, "epss_percentile": 0.9851}, "CVE-2011-1966": {"epss_score": 0.58367, "epss_percentile": 0.98112}, "CVE-2011-1967": {"epss_score": 0.00553, "epss_percentile": 0.67429}, "CVE-2011-1968": {"epss_score": 0.71962, "epss_percentile": 0.98689}, "CVE-2011-1969": {"epss_score": 0.13515, "epss_percentile": 0.93986}, "CVE-2011-1970": {"epss_score": 0.54757, "epss_percentile": 0.97942}, "CVE-2011-1971": {"epss_score": 0.01221, "epss_percentile": 0.78626}, "CVE-2011-1972": {"epss_score": 0.5526, "epss_percentile": 0.97969}, "CVE-2011-1974": {"epss_score": 0.0988, "epss_percentile": 0.9275}, "CVE-2011-1975": {"epss_score": 0.43803, "epss_percentile": 0.97404}, "CVE-2011-1976": {"epss_score": 0.66109, "epss_percentile": 0.9845}, "CVE-2011-1977": {"epss_score": 0.18997, "epss_percentile": 0.95109}, "CVE-2011-1978": {"epss_score": 0.14256, "epss_percentile": 0.94174}, "CVE-2011-1979": {"epss_score": 0.5526, "epss_percentile": 0.97969}, "CVE-2011-1980": {"epss_score": 0.59723, "epss_percentile": 0.98176}, "CVE-2011-1982": {"epss_score": 0.58519, "epss_percentile": 0.98121}, "CVE-2011-1983": {"epss_score": 0.54748, "epss_percentile": 0.97942}, "CVE-2011-1984": {"epss_score": 0.2192, "epss_percentile": 0.95572}, "CVE-2011-1985": {"epss_score": 0.04949, "epss_percentile": 0.89322}, "CVE-2011-1986": {"epss_score": 0.62366, "epss_percentile": 0.98289}, "CVE-2011-1987": {"epss_score": 0.58631, "epss_percentile": 0.98129}, "CVE-2011-1988": {"epss_score": 0.58631, "epss_percentile": 0.98129}, "CVE-2011-1989": {"epss_score": 0.56163, "epss_percentile": 0.9801}, "CVE-2011-1990": {"epss_score": 0.61102, "epss_percentile": 0.98235}, "CVE-2011-1991": {"epss_score": 0.40528, "epss_percentile": 0.97222}, "CVE-2011-1992": {"epss_score": 0.18149, "epss_percentile": 0.94966}, "CVE-2011-1993": {"epss_score": 0.37791, "epss_percentile": 0.9707}, "CVE-2011-1995": {"epss_score": 0.38249, "epss_percentile": 0.97092}, "CVE-2011-1996": {"epss_score": 0.79505, "epss_percentile": 0.99043}, "CVE-2011-1997": {"epss_score": 0.32908, "epss_percentile": 0.96733}, "CVE-2011-1998": {"epss_score": 0.40635, "epss_percentile": 0.97228}, "CVE-2011-1999": {"epss_score": 0.5111, "epss_percentile": 0.97765}, "CVE-2011-20001": {"epss_score": 0.00118, "epss_percentile": 0.31475}, "CVE-2011-20002": {"epss_score": 0.00058, "epss_percentile": 0.18419}, "CVE-2011-2000": {"epss_score": 0.37791, "epss_percentile": 0.9707}, "CVE-2011-2001": {"epss_score": 0.35959, "epss_percentile": 0.96943}, "CVE-2011-2002": {"epss_score": 0.00467, "epss_percentile": 0.63844}, "CVE-2011-2003": {"epss_score": 0.55836, "epss_percentile": 0.97999}, "CVE-2011-2004": {"epss_score": 0.47708, "epss_percentile": 0.97598}, "CVE-2011-2005": {"epss_score": 0.67089, "epss_percentile": 0.98495}, "CVE-2011-2007": {"epss_score": 0.58047, "epss_percentile": 0.98097}, "CVE-2011-2008": {"epss_score": 0.53665, "epss_percentile": 0.9789}, "CVE-2011-2009": {"epss_score": 0.26469, "epss_percentile": 0.96149}, "CVE-2011-2010": {"epss_score": 0.00503, "epss_percentile": 0.65467}, "CVE-2011-2011": {"epss_score": 0.00483, "epss_percentile": 0.64575}, "CVE-2011-2012": {"epss_score": 0.19033, "epss_percentile": 0.95116}, "CVE-2011-2013": {"epss_score": 0.49706, "epss_percentile": 0.977}, "CVE-2011-2014": {"epss_score": 0.09975, "epss_percentile": 0.92799}, "CVE-2011-2016": {"epss_score": 0.15702, "epss_percentile": 0.94487}, "CVE-2011-2018": {"epss_score": 0.02377, "epss_percentile": 0.84554}, "CVE-2011-2019": {"epss_score": 0.26606, "epss_percentile": 0.96161}, "CVE-2011-2020": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2011-2021": {"epss_score": 0.00677, "epss_percentile": 0.70962}, "CVE-2011-2022": {"epss_score": 0.00043, "epss_percentile": 0.13136}, "CVE-2011-2023": {"epss_score": 0.00434, "epss_percentile": 0.62308}, "CVE-2011-2024": {"epss_score": 0.01734, "epss_percentile": 0.82002}, "CVE-2011-2039": {"epss_score": 0.84123, "epss_percentile": 0.99275}, "CVE-2011-2040": {"epss_score": 0.02091, "epss_percentile": 0.83569}, "CVE-2011-2041": {"epss_score": 0.00065, "epss_percentile": 0.20526}, "CVE-2011-2042": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-2054": {"epss_score": 0.00169, "epss_percentile": 0.38543}, "CVE-2011-2057": {"epss_score": 0.01102, "epss_percentile": 0.77586}, "CVE-2011-2058": {"epss_score": 0.00527, "epss_percentile": 0.66472}, "CVE-2011-2059": {"epss_score": 0.00221, "epss_percentile": 0.44677}, "CVE-2011-2060": {"epss_score": 0.00066, "epss_percentile": 0.2087}, "CVE-2011-2064": {"epss_score": 0.0215, "epss_percentile": 0.83782}, "CVE-2011-2072": {"epss_score": 0.00708, "epss_percentile": 0.71668}, "CVE-2011-2074": {"epss_score": 0.05803, "epss_percentile": 0.90221}, "CVE-2011-2075": {"epss_score": 0.02977, "epss_percentile": 0.86108}, "CVE-2011-2076": {"epss_score": 0.00257, "epss_percentile": 0.48947}, "CVE-2011-2077": {"epss_score": 0.00467, "epss_percentile": 0.63855}, "CVE-2011-2078": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-2079": {"epss_score": 0.00527, "epss_percentile": 0.66532}, "CVE-2011-2080": {"epss_score": 0.00417, "epss_percentile": 0.61253}, "CVE-2011-2081": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-2082": {"epss_score": 0.00367, "epss_percentile": 0.58156}, "CVE-2011-2083": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2011-2084": {"epss_score": 0.00306, "epss_percentile": 0.53452}, "CVE-2011-2085": {"epss_score": 0.00295, "epss_percentile": 0.52518}, "CVE-2011-2087": {"epss_score": 0.01391, "epss_percentile": 0.79954}, "CVE-2011-2088": {"epss_score": 0.02556, "epss_percentile": 0.85091}, "CVE-2011-2089": {"epss_score": 0.74625, "epss_percentile": 0.9881}, "CVE-2011-2091": {"epss_score": 0.00777, "epss_percentile": 0.73117}, "CVE-2011-2092": {"epss_score": 0.02266, "epss_percentile": 0.84198}, "CVE-2011-2093": {"epss_score": 0.02803, "epss_percentile": 0.85702}, "CVE-2011-2094": {"epss_score": 0.23457, "epss_percentile": 0.9578}, "CVE-2011-2095": {"epss_score": 0.23457, "epss_percentile": 0.9578}, "CVE-2011-2096": {"epss_score": 0.13834, "epss_percentile": 0.94072}, "CVE-2011-2097": {"epss_score": 0.1091, "epss_percentile": 0.93154}, "CVE-2011-2098": {"epss_score": 0.07272, "epss_percentile": 0.91375}, "CVE-2011-2099": {"epss_score": 0.08986, "epss_percentile": 0.92353}, "CVE-2011-2100": {"epss_score": 0.00245, "epss_percentile": 0.47692}, "CVE-2011-2101": {"epss_score": 0.14874, "epss_percentile": 0.94306}, "CVE-2011-2102": {"epss_score": 0.08774, "epss_percentile": 0.92248}, "CVE-2011-2103": {"epss_score": 0.10811, "epss_percentile": 0.93118}, "CVE-2011-2104": {"epss_score": 0.02033, "epss_percentile": 0.83344}, "CVE-2011-2105": {"epss_score": 0.11647, "epss_percentile": 0.93428}, "CVE-2011-2106": {"epss_score": 0.10811, "epss_percentile": 0.93118}, "CVE-2011-2107": {"epss_score": 0.01077, "epss_percentile": 0.77337}, "CVE-2011-2108": {"epss_score": 0.08002, "epss_percentile": 0.91821}, "CVE-2011-2109": {"epss_score": 0.21949, "epss_percentile": 0.95576}, "CVE-2011-2110": {"epss_score": 0.90951, "epss_percentile": 0.99611}, "CVE-2011-2111": {"epss_score": 0.07384, "epss_percentile": 0.91446}, "CVE-2011-2112": {"epss_score": 0.18395, "epss_percentile": 0.95011}, "CVE-2011-2113": {"epss_score": 0.07733, "epss_percentile": 0.9165}, "CVE-2011-2114": {"epss_score": 0.03631, "epss_percentile": 0.87474}, "CVE-2011-2115": {"epss_score": 0.08046, "epss_percentile": 0.91851}, "CVE-2011-2116": {"epss_score": 0.07384, "epss_percentile": 0.91446}, "CVE-2011-2117": {"epss_score": 0.03631, "epss_percentile": 0.87474}, "CVE-2011-2118": {"epss_score": 0.21112, "epss_percentile": 0.95463}, "CVE-2011-2119": {"epss_score": 0.03631, "epss_percentile": 0.87474}, "CVE-2011-2120": {"epss_score": 0.07311, "epss_percentile": 0.91401}, "CVE-2011-2121": {"epss_score": 0.09529, "epss_percentile": 0.92587}, "CVE-2011-2122": {"epss_score": 0.10501, "epss_percentile": 0.93012}, "CVE-2011-2123": {"epss_score": 0.12903, "epss_percentile": 0.93815}, "CVE-2011-2124": {"epss_score": 0.08743, "epss_percentile": 0.92237}, "CVE-2011-2125": {"epss_score": 0.11153, "epss_percentile": 0.93246}, "CVE-2011-2126": {"epss_score": 0.11808, "epss_percentile": 0.93482}, "CVE-2011-2127": {"epss_score": 0.08743, "epss_percentile": 0.92237}, "CVE-2011-2128": {"epss_score": 0.08743, "epss_percentile": 0.92237}, "CVE-2011-2130": {"epss_score": 0.08393, "epss_percentile": 0.92026}, "CVE-2011-2131": {"epss_score": 0.4798, "epss_percentile": 0.97612}, "CVE-2011-2132": {"epss_score": 0.06846, "epss_percentile": 0.91065}, "CVE-2011-2133": {"epss_score": 0.01199, "epss_percentile": 0.78458}, "CVE-2011-2134": {"epss_score": 0.08393, "epss_percentile": 0.92026}, "CVE-2011-2135": {"epss_score": 0.07805, "epss_percentile": 0.91691}, "CVE-2011-2136": {"epss_score": 0.04528, "epss_percentile": 0.88809}, "CVE-2011-2137": {"epss_score": 0.08393, "epss_percentile": 0.92026}, "CVE-2011-2138": {"epss_score": 0.04528, "epss_percentile": 0.88809}, "CVE-2011-2139": {"epss_score": 0.02879, "epss_percentile": 0.85891}, "CVE-2011-2140": {"epss_score": 0.89835, "epss_percentile": 0.99546}, "CVE-2011-2141": {"epss_score": 0.00375, "epss_percentile": 0.58614}, "CVE-2011-2142": {"epss_score": 0.00231, "epss_percentile": 0.45845}, "CVE-2011-2143": {"epss_score": 0.006, "epss_percentile": 0.68822}, "CVE-2011-2144": {"epss_score": 0.00645, "epss_percentile": 0.70112}, "CVE-2011-2145": {"epss_score": 0.00077, "epss_percentile": 0.23298}, "CVE-2011-2146": {"epss_score": 0.00084, "epss_percentile": 0.24922}, "CVE-2011-2147": {"epss_score": 0.00043, "epss_percentile": 0.13162}, "CVE-2011-2148": {"epss_score": 0.09775, "epss_percentile": 0.92697}, "CVE-2011-2149": {"epss_score": 0.00626, "epss_percentile": 0.69603}, "CVE-2011-2150": {"epss_score": 0.01472, "epss_percentile": 0.80509}, "CVE-2011-2151": {"epss_score": 0.00863, "epss_percentile": 0.74594}, "CVE-2011-2152": {"epss_score": 0.00772, "epss_percentile": 0.73036}, "CVE-2011-2153": {"epss_score": 0.00617, "epss_percentile": 0.6936}, "CVE-2011-2154": {"epss_score": 0.00863, "epss_percentile": 0.74594}, "CVE-2011-2155": {"epss_score": 0.02664, "epss_percentile": 0.85375}, "CVE-2011-2156": {"epss_score": 0.00772, "epss_percentile": 0.73036}, "CVE-2011-2157": {"epss_score": 0.00772, "epss_percentile": 0.73036}, "CVE-2011-2158": {"epss_score": 0.02441, "epss_percentile": 0.84756}, "CVE-2011-2159": {"epss_score": 0.02301, "epss_percentile": 0.84312}, "CVE-2011-2160": {"epss_score": 0.00753, "epss_percentile": 0.72673}, "CVE-2011-2161": {"epss_score": 0.00469, "epss_percentile": 0.63936}, "CVE-2011-2162": {"epss_score": 0.00987, "epss_percentile": 0.76338}, "CVE-2011-2163": {"epss_score": 0.00506, "epss_percentile": 0.65624}, "CVE-2011-2164": {"epss_score": 0.01731, "epss_percentile": 0.81994}, "CVE-2011-2165": {"epss_score": 0.0708, "epss_percentile": 0.91237}, "CVE-2011-2166": {"epss_score": 0.00264, "epss_percentile": 0.49688}, "CVE-2011-2167": {"epss_score": 0.00424, "epss_percentile": 0.61674}, "CVE-2011-2168": {"epss_score": 0.00388, "epss_percentile": 0.59375}, "CVE-2011-2169": {"epss_score": 0.00018, "epss_percentile": 0.04043}, "CVE-2011-2170": {"epss_score": 0.00017, "epss_percentile": 0.03347}, "CVE-2011-2171": {"epss_score": 0.00167, "epss_percentile": 0.38294}, "CVE-2011-2172": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2011-2173": {"epss_score": 0.00374, "epss_percentile": 0.58585}, "CVE-2011-2174": {"epss_score": 0.02919, "epss_percentile": 0.85989}, "CVE-2011-2175": {"epss_score": 0.01963, "epss_percentile": 0.83073}, "CVE-2011-2176": {"epss_score": 0.00054, "epss_percentile": 0.17204}, "CVE-2011-2177": {"epss_score": 0.02367, "epss_percentile": 0.84517}, "CVE-2011-2178": {"epss_score": 0.00084, "epss_percentile": 0.24831}, "CVE-2011-2179": {"epss_score": 0.31474, "epss_percentile": 0.96623}, "CVE-2011-2180": {"epss_score": 0.00334, "epss_percentile": 0.55726}, "CVE-2011-2181": {"epss_score": 0.00348, "epss_percentile": 0.56839}, "CVE-2011-2182": {"epss_score": 0.00053, "epss_percentile": 0.16901}, "CVE-2011-2183": {"epss_score": 0.00086, "epss_percentile": 0.25378}, "CVE-2011-2184": {"epss_score": 0.00096, "epss_percentile": 0.27346}, "CVE-2011-2185": {"epss_score": 0.00032, "epss_percentile": 0.09072}, "CVE-2011-2187": {"epss_score": 0.001, "epss_percentile": 0.28452}, "CVE-2011-2188": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2011-2189": {"epss_score": 0.07252, "epss_percentile": 0.91352}, "CVE-2011-2190": {"epss_score": 0.00086, "epss_percentile": 0.2539}, "CVE-2011-2191": {"epss_score": 0.00592, "epss_percentile": 0.68627}, "CVE-2011-2192": {"epss_score": 0.02049, "epss_percentile": 0.83395}, "CVE-2011-2193": {"epss_score": 0.06208, "epss_percentile": 0.90568}, "CVE-2011-2194": {"epss_score": 0.1586, "epss_percentile": 0.94521}, "CVE-2011-2195": {"epss_score": 0.03419, "epss_percentile": 0.87098}, "CVE-2011-2196": {"epss_score": 0.01215, "epss_percentile": 0.78589}, "CVE-2011-2197": {"epss_score": 0.00442, "epss_percentile": 0.62733}, "CVE-2011-2198": {"epss_score": 0.00807, "epss_percentile": 0.73673}, "CVE-2011-2199": {"epss_score": 0.02716, "epss_percentile": 0.85508}, "CVE-2011-2200": {"epss_score": 0.00098, "epss_percentile": 0.27681}, "CVE-2011-2201": {"epss_score": 0.1316, "epss_percentile": 0.93887}, "CVE-2011-2202": {"epss_score": 0.21689, "epss_percentile": 0.95548}, "CVE-2011-2203": {"epss_score": 0.00139, "epss_percentile": 0.3462}, "CVE-2011-2204": {"epss_score": 0.00098, "epss_percentile": 0.27689}, "CVE-2011-2205": {"epss_score": 0.01621, "epss_percentile": 0.81395}, "CVE-2011-2206": {"epss_score": 0.00725, "epss_percentile": 0.72055}, "CVE-2011-2207": {"epss_score": 0.01445, "epss_percentile": 0.80321}, "CVE-2011-2208": {"epss_score": 0.0013, "epss_percentile": 0.33241}, "CVE-2011-2209": {"epss_score": 0.00058, "epss_percentile": 0.18454}, "CVE-2011-2210": {"epss_score": 0.00147, "epss_percentile": 0.35789}, "CVE-2011-2211": {"epss_score": 0.00047, "epss_percentile": 0.14694}, "CVE-2011-2212": {"epss_score": 0.00785, "epss_percentile": 0.73262}, "CVE-2011-2213": {"epss_score": 0.00063, "epss_percentile": 0.19923}, "CVE-2011-2214": {"epss_score": 0.12967, "epss_percentile": 0.93831}, "CVE-2011-2215": {"epss_score": 0.00369, "epss_percentile": 0.58259}, "CVE-2011-2216": {"epss_score": 0.03498, "epss_percentile": 0.8724}, "CVE-2011-2217": {"epss_score": 0.88252, "epss_percentile": 0.99463}, "CVE-2011-2218": {"epss_score": 0.01291, "epss_percentile": 0.79224}, "CVE-2011-2219": {"epss_score": 0.01291, "epss_percentile": 0.79224}, "CVE-2011-2220": {"epss_score": 0.28938, "epss_percentile": 0.96401}, "CVE-2011-2221": {"epss_score": 0.00437, "epss_percentile": 0.62537}, "CVE-2011-2222": {"epss_score": 0.00492, "epss_percentile": 0.64998}, "CVE-2011-2223": {"epss_score": 0.00635, "epss_percentile": 0.6982}, "CVE-2011-2224": {"epss_score": 0.00739, "epss_percentile": 0.72397}, "CVE-2011-2225": {"epss_score": 0.00238, "epss_percentile": 0.46775}, "CVE-2011-2226": {"epss_score": 0.00164, "epss_percentile": 0.38001}, "CVE-2011-2227": {"epss_score": 0.00566, "epss_percentile": 0.6782}, "CVE-2011-2230": {"epss_score": 0.00499, "epss_percentile": 0.65284}, "CVE-2011-2231": {"epss_score": 0.00499, "epss_percentile": 0.65284}, "CVE-2011-2232": {"epss_score": 0.00265, "epss_percentile": 0.49829}, "CVE-2011-2237": {"epss_score": 0.00139, "epss_percentile": 0.34537}, "CVE-2011-2238": {"epss_score": 0.00181, "epss_percentile": 0.40021}, "CVE-2011-2239": {"epss_score": 0.00366, "epss_percentile": 0.58097}, "CVE-2011-2240": {"epss_score": 0.00392, "epss_percentile": 0.59695}, "CVE-2011-2241": {"epss_score": 0.00677, "epss_percentile": 0.70968}, "CVE-2011-2242": {"epss_score": 0.00304, "epss_percentile": 0.53248}, "CVE-2011-2243": {"epss_score": 0.00181, "epss_percentile": 0.40021}, "CVE-2011-2244": {"epss_score": 0.00276, "epss_percentile": 0.50721}, "CVE-2011-2245": {"epss_score": 0.00658, "epss_percentile": 0.70479}, "CVE-2011-2246": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2011-2248": {"epss_score": 0.00658, "epss_percentile": 0.70479}, "CVE-2011-2249": {"epss_score": 0.00074, "epss_percentile": 0.22828}, "CVE-2011-2250": {"epss_score": 0.00302, "epss_percentile": 0.53131}, "CVE-2011-2251": {"epss_score": 0.0042, "epss_percentile": 0.61433}, "CVE-2011-2252": {"epss_score": 0.01058, "epss_percentile": 0.77143}, "CVE-2011-2253": {"epss_score": 0.00366, "epss_percentile": 0.58097}, "CVE-2011-2255": {"epss_score": 0.00902, "epss_percentile": 0.75183}, "CVE-2011-2257": {"epss_score": 0.00485, "epss_percentile": 0.64706}, "CVE-2011-2258": {"epss_score": 0.00059, "epss_percentile": 0.18883}, "CVE-2011-2259": {"epss_score": 0.00049, "epss_percentile": 0.15378}, "CVE-2011-2260": {"epss_score": 0.40488, "epss_percentile": 0.97221}, "CVE-2011-2261": {"epss_score": 0.0347, "epss_percentile": 0.87196}, "CVE-2011-2262": {"epss_score": 0.00773, "epss_percentile": 0.73063}, "CVE-2011-2263": {"epss_score": 0.00453, "epss_percentile": 0.63207}, "CVE-2011-2264": {"epss_score": 0.04465, "epss_percentile": 0.88728}, "CVE-2011-2267": {"epss_score": 0.00573, "epss_percentile": 0.68058}, "CVE-2011-2271": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2011-2272": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2011-2273": {"epss_score": 0.00311, "epss_percentile": 0.53926}, "CVE-2011-2274": {"epss_score": 0.00292, "epss_percentile": 0.52236}, "CVE-2011-2275": {"epss_score": 0.00677, "epss_percentile": 0.70964}, "CVE-2011-2277": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2011-2278": {"epss_score": 0.00203, "epss_percentile": 0.42534}, "CVE-2011-2279": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2011-2280": {"epss_score": 0.00292, "epss_percentile": 0.52236}, "CVE-2011-2281": {"epss_score": 0.00543, "epss_percentile": 0.67096}, "CVE-2011-2282": {"epss_score": 0.00292, "epss_percentile": 0.52236}, "CVE-2011-2283": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2011-2284": {"epss_score": 0.00203, "epss_percentile": 0.42534}, "CVE-2011-2285": {"epss_score": 0.00049, "epss_percentile": 0.15501}, "CVE-2011-2286": {"epss_score": 0.00355, "epss_percentile": 0.57273}, "CVE-2011-2287": {"epss_score": 0.00472, "epss_percentile": 0.64051}, "CVE-2011-2288": {"epss_score": 0.02185, "epss_percentile": 0.83918}, "CVE-2011-2289": {"epss_score": 0.00055, "epss_percentile": 0.17458}, "CVE-2011-2290": {"epss_score": 0.00049, "epss_percentile": 0.15378}, "CVE-2011-2291": {"epss_score": 0.00059, "epss_percentile": 0.18825}, "CVE-2011-2292": {"epss_score": 0.00138, "epss_percentile": 0.34395}, "CVE-2011-2293": {"epss_score": 0.00049, "epss_percentile": 0.15378}, "CVE-2011-2294": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2011-2295": {"epss_score": 0.00049, "epss_percentile": 0.15378}, "CVE-2011-2296": {"epss_score": 0.00049, "epss_percentile": 0.15378}, "CVE-2011-2297": {"epss_score": 0.00596, "epss_percentile": 0.68718}, "CVE-2011-2298": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2011-2299": {"epss_score": 0.00658, "epss_percentile": 0.70479}, "CVE-2011-2300": {"epss_score": 0.00151, "epss_percentile": 0.36315}, "CVE-2011-2301": {"epss_score": 0.00743, "epss_percentile": 0.72475}, "CVE-2011-2302": {"epss_score": 0.00499, "epss_percentile": 0.65259}, "CVE-2011-2303": {"epss_score": 0.0017, "epss_percentile": 0.38705}, "CVE-2011-2304": {"epss_score": 0.00516, "epss_percentile": 0.66035}, "CVE-2011-2305": {"epss_score": 0.00189, "epss_percentile": 0.41003}, "CVE-2011-2306": {"epss_score": 0.00206, "epss_percentile": 0.42938}, "CVE-2011-2307": {"epss_score": 0.00658, "epss_percentile": 0.70479}, "CVE-2011-2308": {"epss_score": 0.00442, "epss_percentile": 0.62729}, "CVE-2011-2309": {"epss_score": 0.00442, "epss_percentile": 0.62729}, "CVE-2011-2310": {"epss_score": 0.00927, "epss_percentile": 0.75559}, "CVE-2011-2311": {"epss_score": 0.00089, "epss_percentile": 0.25963}, "CVE-2011-2312": {"epss_score": 0.00146, "epss_percentile": 0.35571}, "CVE-2011-2313": {"epss_score": 0.00158, "epss_percentile": 0.37197}, "CVE-2011-2314": {"epss_score": 0.00499, "epss_percentile": 0.65259}, "CVE-2011-2315": {"epss_score": 0.00263, "epss_percentile": 0.49526}, "CVE-2011-2316": {"epss_score": 0.00442, "epss_percentile": 0.62729}, "CVE-2011-2317": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2011-2318": {"epss_score": 0.00098, "epss_percentile": 0.27825}, "CVE-2011-2319": {"epss_score": 0.00536, "epss_percentile": 0.66869}, "CVE-2011-2320": {"epss_score": 0.00536, "epss_percentile": 0.66869}, "CVE-2011-2321": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2011-2322": {"epss_score": 0.00344, "epss_percentile": 0.56533}, "CVE-2011-2323": {"epss_score": 0.00442, "epss_percentile": 0.62729}, "CVE-2011-2324": {"epss_score": 0.0108, "epss_percentile": 0.77367}, "CVE-2011-2325": {"epss_score": 0.00272, "epss_percentile": 0.50382}, "CVE-2011-2326": {"epss_score": 0.00272, "epss_percentile": 0.50382}, "CVE-2011-2327": {"epss_score": 0.00159, "epss_percentile": 0.37421}, "CVE-2011-2328": {"epss_score": 0.035, "epss_percentile": 0.87245}, "CVE-2011-2329": {"epss_score": 0.0069, "epss_percentile": 0.71237}, "CVE-2011-2330": {"epss_score": 0.01639, "epss_percentile": 0.81492}, "CVE-2011-2331": {"epss_score": 0.23864, "epss_percentile": 0.95826}, "CVE-2011-2332": {"epss_score": 0.00539, "epss_percentile": 0.66989}, "CVE-2011-2334": {"epss_score": 0.00166, "epss_percentile": 0.38152}, "CVE-2011-2335": {"epss_score": 0.00166, "epss_percentile": 0.38152}, "CVE-2011-2336": {"epss_score": 0.00303, "epss_percentile": 0.53229}, "CVE-2011-2337": {"epss_score": 0.00293, "epss_percentile": 0.52302}, "CVE-2011-2338": {"epss_score": 0.01039, "epss_percentile": 0.76944}, "CVE-2011-2339": {"epss_score": 0.01017, "epss_percentile": 0.76688}, "CVE-2011-2341": {"epss_score": 0.01224, "epss_percentile": 0.78673}, "CVE-2011-2342": {"epss_score": 0.00323, "epss_percentile": 0.54878}, "CVE-2011-2343": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2011-2344": {"epss_score": 0.0188, "epss_percentile": 0.82683}, "CVE-2011-2345": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2346": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2347": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2348": {"epss_score": 0.02905, "epss_percentile": 0.85961}, "CVE-2011-2349": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2350": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2351": {"epss_score": 0.02007, "epss_percentile": 0.83239}, "CVE-2011-2352": {"epss_score": 0.01016, "epss_percentile": 0.76678}, "CVE-2011-2353": {"epss_score": 0.00303, "epss_percentile": 0.53229}, "CVE-2011-2354": {"epss_score": 0.01016, "epss_percentile": 0.76678}, "CVE-2011-2356": {"epss_score": 0.01016, "epss_percentile": 0.76678}, "CVE-2011-2357": {"epss_score": 0.05265, "epss_percentile": 0.89673}, "CVE-2011-2358": {"epss_score": 0.00708, "epss_percentile": 0.71673}, "CVE-2011-2359": {"epss_score": 0.04396, "epss_percentile": 0.88639}, "CVE-2011-2360": {"epss_score": 0.00317, "epss_percentile": 0.54393}, "CVE-2011-2361": {"epss_score": 0.00298, "epss_percentile": 0.52792}, "CVE-2011-2362": {"epss_score": 0.01226, "epss_percentile": 0.78687}, "CVE-2011-2363": {"epss_score": 0.03293, "epss_percentile": 0.86843}, "CVE-2011-2364": {"epss_score": 0.0277, "epss_percentile": 0.85619}, "CVE-2011-2365": {"epss_score": 0.02496, "epss_percentile": 0.84907}, "CVE-2011-2366": {"epss_score": 0.00606, "epss_percentile": 0.69002}, "CVE-2011-2367": {"epss_score": 0.00676, "epss_percentile": 0.70934}, "CVE-2011-2368": {"epss_score": 0.04629, "epss_percentile": 0.88941}, "CVE-2011-2369": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2011-2370": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2011-2371": {"epss_score": 0.86212, "epss_percentile": 0.99373}, "CVE-2011-2372": {"epss_score": 0.00429, "epss_percentile": 0.61978}, "CVE-2011-2373": {"epss_score": 0.03638, "epss_percentile": 0.87484}, "CVE-2011-2374": {"epss_score": 0.04818, "epss_percentile": 0.89173}, "CVE-2011-2375": {"epss_score": 0.0285, "epss_percentile": 0.85828}, "CVE-2011-2376": {"epss_score": 0.02354, "epss_percentile": 0.84479}, "CVE-2011-2377": {"epss_score": 0.05899, "epss_percentile": 0.90307}, "CVE-2011-2378": {"epss_score": 0.0371, "epss_percentile": 0.87606}, "CVE-2011-2379": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2011-2380": {"epss_score": 0.00688, "epss_percentile": 0.71209}, "CVE-2011-2381": {"epss_score": 0.0048, "epss_percentile": 0.64448}, "CVE-2011-2382": {"epss_score": 0.33881, "epss_percentile": 0.96812}, "CVE-2011-2383": {"epss_score": 0.34763, "epss_percentile": 0.96872}, "CVE-2011-2385": {"epss_score": 0.00735, "epss_percentile": 0.72285}, "CVE-2011-2386": {"epss_score": 0.74908, "epss_percentile": 0.98822}, "CVE-2011-2391": {"epss_score": 0.01246, "epss_percentile": 0.78855}, "CVE-2011-2393": {"epss_score": 0.00434, "epss_percentile": 0.62322}, "CVE-2011-2395": {"epss_score": 0.00147, "epss_percentile": 0.3575}, "CVE-2011-2397": {"epss_score": 0.04687, "epss_percentile": 0.89008}, "CVE-2011-2398": {"epss_score": 0.0004, "epss_percentile": 0.11994}, "CVE-2011-2399": {"epss_score": 0.02687, "epss_percentile": 0.85431}, "CVE-2011-2400": {"epss_score": 0.00824, "epss_percentile": 0.73935}, "CVE-2011-2401": {"epss_score": 0.01161, "epss_percentile": 0.78139}, "CVE-2011-2402": {"epss_score": 0.00673, "epss_percentile": 0.70829}, "CVE-2011-2403": {"epss_score": 0.00785, "epss_percentile": 0.73259}, "CVE-2011-2404": {"epss_score": 0.80489, "epss_percentile": 0.99091}, "CVE-2011-2405": {"epss_score": 0.01441, "epss_percentile": 0.80305}, "CVE-2011-2406": {"epss_score": 0.00217, "epss_percentile": 0.44311}, "CVE-2011-2407": {"epss_score": 0.0205, "epss_percentile": 0.83397}, "CVE-2011-2408": {"epss_score": 0.00676, "epss_percentile": 0.7093}, "CVE-2011-2409": {"epss_score": 0.00676, "epss_percentile": 0.7093}, "CVE-2011-2410": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2011-2411": {"epss_score": 0.00315, "epss_percentile": 0.542}, "CVE-2011-2412": {"epss_score": 0.19472, "epss_percentile": 0.9519}, "CVE-2011-2414": {"epss_score": 0.13356, "epss_percentile": 0.9394}, "CVE-2011-2415": {"epss_score": 0.13356, "epss_percentile": 0.9394}, "CVE-2011-2416": {"epss_score": 0.04528, "epss_percentile": 0.88809}, "CVE-2011-2417": {"epss_score": 0.09775, "epss_percentile": 0.92697}, "CVE-2011-2419": {"epss_score": 0.07778, "epss_percentile": 0.91677}, "CVE-2011-2420": {"epss_score": 0.08259, "epss_percentile": 0.91955}, "CVE-2011-2421": {"epss_score": 0.0695, "epss_percentile": 0.91137}, "CVE-2011-2422": {"epss_score": 0.07778, "epss_percentile": 0.91677}, "CVE-2011-2423": {"epss_score": 0.12521, "epss_percentile": 0.93707}, "CVE-2011-2424": {"epss_score": 0.13758, "epss_percentile": 0.94051}, "CVE-2011-2425": {"epss_score": 0.09775, "epss_percentile": 0.92697}, "CVE-2011-2426": {"epss_score": 0.11685, "epss_percentile": 0.93447}, "CVE-2011-2427": {"epss_score": 0.02417, "epss_percentile": 0.8469}, "CVE-2011-2428": {"epss_score": 0.02882, "epss_percentile": 0.85902}, "CVE-2011-2429": {"epss_score": 0.01913, "epss_percentile": 0.82843}, "CVE-2011-2430": {"epss_score": 0.0662, "epss_percentile": 0.90893}, "CVE-2011-2431": {"epss_score": 0.08416, "epss_percentile": 0.9204}, "CVE-2011-2432": {"epss_score": 0.08391, "epss_percentile": 0.92025}, "CVE-2011-2433": {"epss_score": 0.08391, "epss_percentile": 0.92025}, "CVE-2011-2434": {"epss_score": 0.08391, "epss_percentile": 0.92025}, "CVE-2011-2435": {"epss_score": 0.08391, "epss_percentile": 0.92025}, "CVE-2011-2436": {"epss_score": 0.08675, "epss_percentile": 0.92193}, "CVE-2011-2437": {"epss_score": 0.08391, "epss_percentile": 0.92025}, "CVE-2011-2438": {"epss_score": 0.08675, "epss_percentile": 0.92193}, "CVE-2011-2439": {"epss_score": 0.08416, "epss_percentile": 0.9204}, "CVE-2011-2440": {"epss_score": 0.05967, "epss_percentile": 0.9037}, "CVE-2011-2441": {"epss_score": 0.26993, "epss_percentile": 0.96197}, "CVE-2011-2442": {"epss_score": 0.0814, "epss_percentile": 0.91899}, "CVE-2011-2443": {"epss_score": 0.34106, "epss_percentile": 0.96825}, "CVE-2011-2444": {"epss_score": 0.0092, "epss_percentile": 0.75474}, "CVE-2011-2445": {"epss_score": 0.01769, "epss_percentile": 0.82188}, "CVE-2011-2446": {"epss_score": 0.04486, "epss_percentile": 0.88749}, "CVE-2011-2447": {"epss_score": 0.04486, "epss_percentile": 0.88749}, "CVE-2011-2448": {"epss_score": 0.04486, "epss_percentile": 0.88749}, "CVE-2011-2449": {"epss_score": 0.04212, "epss_percentile": 0.88402}, "CVE-2011-2450": {"epss_score": 0.03037, "epss_percentile": 0.86264}, "CVE-2011-2451": {"epss_score": 0.01769, "epss_percentile": 0.82188}, "CVE-2011-2452": {"epss_score": 0.01769, "epss_percentile": 0.82188}, "CVE-2011-2453": {"epss_score": 0.01769, "epss_percentile": 0.82188}, "CVE-2011-2454": {"epss_score": 0.01769, "epss_percentile": 0.82188}, "CVE-2011-2455": {"epss_score": 0.01769, "epss_percentile": 0.82188}, "CVE-2011-2456": {"epss_score": 0.04753, "epss_percentile": 0.89106}, "CVE-2011-2457": {"epss_score": 0.04753, "epss_percentile": 0.89106}, "CVE-2011-2458": {"epss_score": 0.01019, "epss_percentile": 0.76725}, "CVE-2011-2459": {"epss_score": 0.01769, "epss_percentile": 0.82188}, "CVE-2011-2460": {"epss_score": 0.01769, "epss_percentile": 0.82188}, "CVE-2011-2461": {"epss_score": 0.03521, "epss_percentile": 0.87288}, "CVE-2011-2462": {"epss_score": 0.92193, "epss_percentile": 0.99698}, "CVE-2011-2463": {"epss_score": 0.00667, "epss_percentile": 0.70711}, "CVE-2011-2464": {"epss_score": 0.45023, "epss_percentile": 0.97467}, "CVE-2011-2465": {"epss_score": 0.14009, "epss_percentile": 0.94113}, "CVE-2011-2467": {"epss_score": 0.0018, "epss_percentile": 0.3992}, "CVE-2011-2468": {"epss_score": 0.00837, "epss_percentile": 0.74162}, "CVE-2011-2470": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2011-2471": {"epss_score": 0.00062, "epss_percentile": 0.19692}, "CVE-2011-2472": {"epss_score": 0.00018, "epss_percentile": 0.03958}, "CVE-2011-2473": {"epss_score": 0.00035, "epss_percentile": 0.09925}, "CVE-2011-2474": {"epss_score": 0.12124, "epss_percentile": 0.93573}, "CVE-2011-2475": {"epss_score": 0.04722, "epss_percentile": 0.89056}, "CVE-2011-2476": {"epss_score": 0.00287, "epss_percentile": 0.51829}, "CVE-2011-2477": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-2478": {"epss_score": 0.01794, "epss_percentile": 0.8229}, "CVE-2011-2479": {"epss_score": 0.00061, "epss_percentile": 0.19535}, "CVE-2011-2480": {"epss_score": 0.00416, "epss_percentile": 0.61163}, "CVE-2011-2481": {"epss_score": 0.00243, "epss_percentile": 0.47432}, "CVE-2011-2482": {"epss_score": 0.01166, "epss_percentile": 0.78183}, "CVE-2011-2483": {"epss_score": 0.06501, "epss_percentile": 0.90803}, "CVE-2011-2484": {"epss_score": 0.00045, "epss_percentile": 0.13997}, "CVE-2011-2485": {"epss_score": 0.00677, "epss_percentile": 0.70964}, "CVE-2011-2486": {"epss_score": 0.00235, "epss_percentile": 0.46345}, "CVE-2011-2487": {"epss_score": 0.0049, "epss_percentile": 0.64938}, "CVE-2011-2488": {"epss_score": 0.00011, "epss_percentile": 0.00976}, "CVE-2011-2489": {"epss_score": 0.00059, "epss_percentile": 0.18689}, "CVE-2011-2490": {"epss_score": 0.00093, "epss_percentile": 0.26606}, "CVE-2011-2491": {"epss_score": 0.0005, "epss_percentile": 0.15693}, "CVE-2011-2492": {"epss_score": 0.00055, "epss_percentile": 0.17603}, "CVE-2011-2493": {"epss_score": 0.00058, "epss_percentile": 0.18454}, "CVE-2011-2494": {"epss_score": 0.00125, "epss_percentile": 0.32591}, "CVE-2011-2495": {"epss_score": 0.00125, "epss_percentile": 0.32591}, "CVE-2011-2496": {"epss_score": 0.00151, "epss_percentile": 0.36251}, "CVE-2011-2497": {"epss_score": 0.02792, "epss_percentile": 0.85669}, "CVE-2011-2498": {"epss_score": 0.00157, "epss_percentile": 0.37104}, "CVE-2011-2499": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2011-2500": {"epss_score": 0.0062, "epss_percentile": 0.69455}, "CVE-2011-2501": {"epss_score": 0.0121, "epss_percentile": 0.78546}, "CVE-2011-2502": {"epss_score": 0.00076, "epss_percentile": 0.23141}, "CVE-2011-2503": {"epss_score": 0.00112, "epss_percentile": 0.30437}, "CVE-2011-2504": {"epss_score": 0.00173, "epss_percentile": 0.39088}, "CVE-2011-2505": {"epss_score": 0.47906, "epss_percentile": 0.97608}, "CVE-2011-2506": {"epss_score": 0.4443, "epss_percentile": 0.97435}, "CVE-2011-2507": {"epss_score": 0.03737, "epss_percentile": 0.87651}, "CVE-2011-2508": {"epss_score": 0.11174, "epss_percentile": 0.93253}, "CVE-2011-2509": {"epss_score": 0.00027, "epss_percentile": 0.06745}, "CVE-2011-2510": {"epss_score": 0.00864, "epss_percentile": 0.74612}, "CVE-2011-2511": {"epss_score": 0.02832, "epss_percentile": 0.85777}, "CVE-2011-2512": {"epss_score": 0.00602, "epss_percentile": 0.68896}, "CVE-2011-2513": {"epss_score": 0.005, "epss_percentile": 0.65304}, "CVE-2011-2514": {"epss_score": 0.00878, "epss_percentile": 0.74821}, "CVE-2011-2515": {"epss_score": 0.00165, "epss_percentile": 0.3805}, "CVE-2011-2516": {"epss_score": 0.07303, "epss_percentile": 0.91394}, "CVE-2011-2517": {"epss_score": 0.00115, "epss_percentile": 0.30997}, "CVE-2011-2518": {"epss_score": 0.00048, "epss_percentile": 0.15052}, "CVE-2011-2519": {"epss_score": 0.00137, "epss_percentile": 0.34284}, "CVE-2011-2520": {"epss_score": 0.00099, "epss_percentile": 0.28309}, "CVE-2011-2521": {"epss_score": 0.00063, "epss_percentile": 0.19984}, "CVE-2011-2522": {"epss_score": 0.19243, "epss_percentile": 0.95155}, "CVE-2011-2523": {"epss_score": 0.94265, "epss_percentile": 0.9993}, "CVE-2011-2524": {"epss_score": 0.00602, "epss_percentile": 0.68891}, "CVE-2011-2525": {"epss_score": 0.00114, "epss_percentile": 0.30784}, "CVE-2011-2526": {"epss_score": 0.0013, "epss_percentile": 0.33229}, "CVE-2011-2527": {"epss_score": 0.00088, "epss_percentile": 0.25724}, "CVE-2011-2528": {"epss_score": 0.00593, "epss_percentile": 0.68635}, "CVE-2011-2529": {"epss_score": 0.03361, "epss_percentile": 0.8699}, "CVE-2011-2530": {"epss_score": 0.00521, "epss_percentile": 0.6623}, "CVE-2011-2531": {"epss_score": 0.00767, "epss_percentile": 0.72957}, "CVE-2011-2532": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2533": {"epss_score": 0.0003, "epss_percentile": 0.08273}, "CVE-2011-2534": {"epss_score": 0.00044, "epss_percentile": 0.13506}, "CVE-2011-2535": {"epss_score": 0.0018, "epss_percentile": 0.39932}, "CVE-2011-2536": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2011-2538": {"epss_score": 0.02957, "epss_percentile": 0.86064}, "CVE-2011-2543": {"epss_score": 0.4511, "epss_percentile": 0.97474}, "CVE-2011-2544": {"epss_score": 0.04373, "epss_percentile": 0.88613}, "CVE-2011-2545": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-2546": {"epss_score": 0.00296, "epss_percentile": 0.52627}, "CVE-2011-2547": {"epss_score": 0.00632, "epss_percentile": 0.6974}, "CVE-2011-2549": {"epss_score": 0.00708, "epss_percentile": 0.71668}, "CVE-2011-2555": {"epss_score": 0.01169, "epss_percentile": 0.782}, "CVE-2011-2560": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-2561": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2011-2562": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-2563": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2011-2564": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2011-2569": {"epss_score": 0.00061, "epss_percentile": 0.19312}, "CVE-2011-2577": {"epss_score": 0.09943, "epss_percentile": 0.92784}, "CVE-2011-2578": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2011-2581": {"epss_score": 0.00207, "epss_percentile": 0.43199}, "CVE-2011-2583": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2584": {"epss_score": 0.00655, "epss_percentile": 0.70366}, "CVE-2011-2585": {"epss_score": 0.02573, "epss_percentile": 0.85137}, "CVE-2011-2586": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-2587": {"epss_score": 0.02491, "epss_percentile": 0.84897}, "CVE-2011-2588": {"epss_score": 0.02491, "epss_percentile": 0.84897}, "CVE-2011-2589": {"epss_score": 0.04948, "epss_percentile": 0.8932}, "CVE-2011-2590": {"epss_score": 0.00885, "epss_percentile": 0.74935}, "CVE-2011-2591": {"epss_score": 0.18623, "epss_percentile": 0.95045}, "CVE-2011-2592": {"epss_score": 0.1761, "epss_percentile": 0.94874}, "CVE-2011-2593": {"epss_score": 0.08358, "epss_percentile": 0.92008}, "CVE-2011-2594": {"epss_score": 0.05834, "epss_percentile": 0.90247}, "CVE-2011-2595": {"epss_score": 0.74003, "epss_percentile": 0.98782}, "CVE-2011-2597": {"epss_score": 0.01142, "epss_percentile": 0.7797}, "CVE-2011-2598": {"epss_score": 0.00111, "epss_percentile": 0.30287}, "CVE-2011-2599": {"epss_score": 0.00223, "epss_percentile": 0.44903}, "CVE-2011-2600": {"epss_score": 0.0899, "epss_percentile": 0.92355}, "CVE-2011-2601": {"epss_score": 0.00431, "epss_percentile": 0.62036}, "CVE-2011-2602": {"epss_score": 0.00667, "epss_percentile": 0.70717}, "CVE-2011-2603": {"epss_score": 0.00754, "epss_percentile": 0.72702}, "CVE-2011-2604": {"epss_score": 0.00667, "epss_percentile": 0.70717}, "CVE-2011-2605": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2011-2606": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2011-2607": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2011-2608": {"epss_score": 0.0084, "epss_percentile": 0.74213}, "CVE-2011-2609": {"epss_score": 0.00513, "epss_percentile": 0.65877}, "CVE-2011-2610": {"epss_score": 0.00549, "epss_percentile": 0.67322}, "CVE-2011-2611": {"epss_score": 0.00461, "epss_percentile": 0.63543}, "CVE-2011-2612": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-2613": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2614": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2615": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-2616": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-2617": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2618": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-2619": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2620": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2621": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2622": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-2623": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2624": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2011-2625": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2626": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2627": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-2628": {"epss_score": 0.13269, "epss_percentile": 0.93918}, "CVE-2011-2629": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-2630": {"epss_score": 0.00461, "epss_percentile": 0.63543}, "CVE-2011-2631": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-2632": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-2633": {"epss_score": 0.00288, "epss_percentile": 0.51885}, "CVE-2011-2634": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2011-2635": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2636": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-2637": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-2638": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-2639": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-2640": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2011-2641": {"epss_score": 0.06325, "epss_percentile": 0.90672}, "CVE-2011-2642": {"epss_score": 0.00667, "epss_percentile": 0.70702}, "CVE-2011-2643": {"epss_score": 0.00383, "epss_percentile": 0.59117}, "CVE-2011-2644": {"epss_score": 0.00295, "epss_percentile": 0.52502}, "CVE-2011-2645": {"epss_score": 0.02362, "epss_percentile": 0.84502}, "CVE-2011-2646": {"epss_score": 0.02362, "epss_percentile": 0.84502}, "CVE-2011-2647": {"epss_score": 0.03168, "epss_percentile": 0.86545}, "CVE-2011-2648": {"epss_score": 0.03168, "epss_percentile": 0.86545}, "CVE-2011-2649": {"epss_score": 0.00434, "epss_percentile": 0.62322}, "CVE-2011-2650": {"epss_score": 0.00295, "epss_percentile": 0.52502}, "CVE-2011-2651": {"epss_score": 0.01853, "epss_percentile": 0.8255}, "CVE-2011-2652": {"epss_score": 0.00295, "epss_percentile": 0.52502}, "CVE-2011-2653": {"epss_score": 0.84689, "epss_percentile": 0.99301}, "CVE-2011-2654": {"epss_score": 0.03508, "epss_percentile": 0.87261}, "CVE-2011-2655": {"epss_score": 0.04301, "epss_percentile": 0.88517}, "CVE-2011-2656": {"epss_score": 0.04301, "epss_percentile": 0.88517}, "CVE-2011-2657": {"epss_score": 0.74401, "epss_percentile": 0.98798}, "CVE-2011-2658": {"epss_score": 0.03292, "epss_percentile": 0.86838}, "CVE-2011-2660": {"epss_score": 0.01085, "epss_percentile": 0.77405}, "CVE-2011-2661": {"epss_score": 0.00339, "epss_percentile": 0.56194}, "CVE-2011-2662": {"epss_score": 0.13451, "epss_percentile": 0.93969}, "CVE-2011-2663": {"epss_score": 0.04154, "epss_percentile": 0.88326}, "CVE-2011-2664": {"epss_score": 0.0006, "epss_percentile": 0.19179}, "CVE-2011-2665": {"epss_score": 0.02315, "epss_percentile": 0.84354}, "CVE-2011-2666": {"epss_score": 0.0059, "epss_percentile": 0.68547}, "CVE-2011-2667": {"epss_score": 0.25244, "epss_percentile": 0.96001}, "CVE-2011-2668": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2011-2669": {"epss_score": 0.00206, "epss_percentile": 0.43062}, "CVE-2011-2670": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2011-2671": {"epss_score": 0.01039, "epss_percentile": 0.76952}, "CVE-2011-2672": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2011-2673": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2011-2674": {"epss_score": 0.00193, "epss_percentile": 0.41427}, "CVE-2011-2675": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2011-2676": {"epss_score": 0.00523, "epss_percentile": 0.66297}, "CVE-2011-2677": {"epss_score": 0.00323, "epss_percentile": 0.54863}, "CVE-2011-2678": {"epss_score": 0.00064, "epss_percentile": 0.2039}, "CVE-2011-2679": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2011-2680": {"epss_score": 0.01334, "epss_percentile": 0.79537}, "CVE-2011-2681": {"epss_score": 0.01334, "epss_percentile": 0.79537}, "CVE-2011-2682": {"epss_score": 0.00421, "epss_percentile": 0.61475}, "CVE-2011-2683": {"epss_score": 0.0034, "epss_percentile": 0.56259}, "CVE-2011-2684": {"epss_score": 0.00069, "epss_percentile": 0.21428}, "CVE-2011-2685": {"epss_score": 0.11795, "epss_percentile": 0.93479}, "CVE-2011-2686": {"epss_score": 0.00669, "epss_percentile": 0.70752}, "CVE-2011-2687": {"epss_score": 0.00774, "epss_percentile": 0.73073}, "CVE-2011-2688": {"epss_score": 0.02343, "epss_percentile": 0.84444}, "CVE-2011-2689": {"epss_score": 0.00096, "epss_percentile": 0.27269}, "CVE-2011-2690": {"epss_score": 0.00931, "epss_percentile": 0.75617}, "CVE-2011-2691": {"epss_score": 0.05813, "epss_percentile": 0.90227}, "CVE-2011-2692": {"epss_score": 0.07097, "epss_percentile": 0.91247}, "CVE-2011-2693": {"epss_score": 0.00053, "epss_percentile": 0.16908}, "CVE-2011-2694": {"epss_score": 0.03127, "epss_percentile": 0.86458}, "CVE-2011-2695": {"epss_score": 0.00067, "epss_percentile": 0.21166}, "CVE-2011-2696": {"epss_score": 0.07038, "epss_percentile": 0.91206}, "CVE-2011-2697": {"epss_score": 0.05428, "epss_percentile": 0.89872}, "CVE-2011-2698": {"epss_score": 0.0309, "epss_percentile": 0.86393}, "CVE-2011-2699": {"epss_score": 0.00752, "epss_percentile": 0.72651}, "CVE-2011-2700": {"epss_score": 0.00065, "epss_percentile": 0.20443}, "CVE-2011-2701": {"epss_score": 0.00451, "epss_percentile": 0.63141}, "CVE-2011-2702": {"epss_score": 0.04486, "epss_percentile": 0.88749}, "CVE-2011-2703": {"epss_score": 0.01573, "epss_percentile": 0.81102}, "CVE-2011-2704": {"epss_score": 0.06405, "epss_percentile": 0.90732}, "CVE-2011-2705": {"epss_score": 0.00989, "epss_percentile": 0.76361}, "CVE-2011-2706": {"epss_score": 0.00226, "epss_percentile": 0.45249}, "CVE-2011-2707": {"epss_score": 0.00097, "epss_percentile": 0.27544}, "CVE-2011-2709": {"epss_score": 0.00118, "epss_percentile": 0.31436}, "CVE-2011-2710": {"epss_score": 0.00047, "epss_percentile": 0.1465}, "CVE-2011-2711": {"epss_score": 0.00371, "epss_percentile": 0.58418}, "CVE-2011-2712": {"epss_score": 0.05367, "epss_percentile": 0.89791}, "CVE-2011-2713": {"epss_score": 0.01541, "epss_percentile": 0.80947}, "CVE-2011-2714": {"epss_score": 0.00528, "epss_percentile": 0.66536}, "CVE-2011-2715": {"epss_score": 0.00615, "epss_percentile": 0.69298}, "CVE-2011-2716": {"epss_score": 0.00707, "epss_percentile": 0.71644}, "CVE-2011-2717": {"epss_score": 0.0068, "epss_percentile": 0.71032}, "CVE-2011-2718": {"epss_score": 0.01003, "epss_percentile": 0.76512}, "CVE-2011-2719": {"epss_score": 0.01944, "epss_percentile": 0.82996}, "CVE-2011-2720": {"epss_score": 0.01024, "epss_percentile": 0.76776}, "CVE-2011-2721": {"epss_score": 0.03065, "epss_percentile": 0.86336}, "CVE-2011-2722": {"epss_score": 0.00071, "epss_percentile": 0.22164}, "CVE-2011-2723": {"epss_score": 0.00842, "epss_percentile": 0.74236}, "CVE-2011-2724": {"epss_score": 0.01165, "epss_percentile": 0.78175}, "CVE-2011-2725": {"epss_score": 0.00612, "epss_percentile": 0.69214}, "CVE-2011-2726": {"epss_score": 0.00379, "epss_percentile": 0.5889}, "CVE-2011-2727": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-2728": {"epss_score": 0.00645, "epss_percentile": 0.70101}, "CVE-2011-2729": {"epss_score": 0.08784, "epss_percentile": 0.92254}, "CVE-2011-2730": {"epss_score": 0.53573, "epss_percentile": 0.97882}, "CVE-2011-2731": {"epss_score": 0.00295, "epss_percentile": 0.52476}, "CVE-2011-2732": {"epss_score": 0.07106, "epss_percentile": 0.91256}, "CVE-2011-2733": {"epss_score": 0.00176, "epss_percentile": 0.394}, "CVE-2011-2735": {"epss_score": 0.0362, "epss_percentile": 0.87441}, "CVE-2011-2736": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-2737": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-2738": {"epss_score": 0.11327, "epss_percentile": 0.93311}, "CVE-2011-2739": {"epss_score": 0.01209, "epss_percentile": 0.78539}, "CVE-2011-2740": {"epss_score": 0.02715, "epss_percentile": 0.85506}, "CVE-2011-2741": {"epss_score": 0.00216, "epss_percentile": 0.44126}, "CVE-2011-2742": {"epss_score": 0.00216, "epss_percentile": 0.44126}, "CVE-2011-2743": {"epss_score": 0.05695, "epss_percentile": 0.90127}, "CVE-2011-2744": {"epss_score": 0.05641, "epss_percentile": 0.90076}, "CVE-2011-2745": {"epss_score": 0.02443, "epss_percentile": 0.84759}, "CVE-2011-2746": {"epss_score": 0.00432, "epss_percentile": 0.62096}, "CVE-2011-2747": {"epss_score": 0.03276, "epss_percentile": 0.86804}, "CVE-2011-2748": {"epss_score": 0.87787, "epss_percentile": 0.99443}, "CVE-2011-2749": {"epss_score": 0.7534, "epss_percentile": 0.98839}, "CVE-2011-2750": {"epss_score": 0.65376, "epss_percentile": 0.98415}, "CVE-2011-2751": {"epss_score": 0.0062, "epss_percentile": 0.69438}, "CVE-2011-2752": {"epss_score": 0.00604, "epss_percentile": 0.68951}, "CVE-2011-2753": {"epss_score": 0.00204, "epss_percentile": 0.42588}, "CVE-2011-2754": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2011-2755": {"epss_score": 0.02556, "epss_percentile": 0.85092}, "CVE-2011-2756": {"epss_score": 0.00315, "epss_percentile": 0.54164}, "CVE-2011-2757": {"epss_score": 0.66485, "epss_percentile": 0.98464}, "CVE-2011-2758": {"epss_score": 0.00342, "epss_percentile": 0.56369}, "CVE-2011-2759": {"epss_score": 0.00251, "epss_percentile": 0.48278}, "CVE-2011-2760": {"epss_score": 0.00536, "epss_percentile": 0.66849}, "CVE-2011-2761": {"epss_score": 0.01049, "epss_percentile": 0.77063}, "CVE-2011-2762": {"epss_score": 0.01508, "epss_percentile": 0.80762}, "CVE-2011-2763": {"epss_score": 0.70149, "epss_percentile": 0.9862}, "CVE-2011-2764": {"epss_score": 0.04339, "epss_percentile": 0.88568}, "CVE-2011-2765": {"epss_score": 0.00433, "epss_percentile": 0.62204}, "CVE-2011-2766": {"epss_score": 0.00261, "epss_percentile": 0.49271}, "CVE-2011-2767": {"epss_score": 0.04609, "epss_percentile": 0.88913}, "CVE-2011-2768": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2011-2769": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2011-2770": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2011-2771": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2011-2772": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2011-2773": {"epss_score": 0.002, "epss_percentile": 0.42238}, "CVE-2011-2774": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2011-2776": {"epss_score": 0.00141, "epss_percentile": 0.34818}, "CVE-2011-2777": {"epss_score": 0.00307, "epss_percentile": 0.535}, "CVE-2011-2778": {"epss_score": 0.04522, "epss_percentile": 0.88802}, "CVE-2011-2779": {"epss_score": 0.00077, "epss_percentile": 0.23362}, "CVE-2011-2780": {"epss_score": 0.0269, "epss_percentile": 0.85435}, "CVE-2011-2782": {"epss_score": 0.00221, "epss_percentile": 0.44656}, "CVE-2011-2783": {"epss_score": 0.00708, "epss_percentile": 0.71673}, "CVE-2011-2784": {"epss_score": 0.00191, "epss_percentile": 0.41187}, "CVE-2011-2785": {"epss_score": 0.00384, "epss_percentile": 0.59166}, "CVE-2011-2786": {"epss_score": 0.00343, "epss_percentile": 0.56472}, "CVE-2011-2787": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2788": {"epss_score": 0.03148, "epss_percentile": 0.865}, "CVE-2011-2789": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2790": {"epss_score": 0.02007, "epss_percentile": 0.83239}, "CVE-2011-2791": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2792": {"epss_score": 0.02007, "epss_percentile": 0.83239}, "CVE-2011-2793": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2794": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2795": {"epss_score": 0.0037, "epss_percentile": 0.58312}, "CVE-2011-2796": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2797": {"epss_score": 0.02007, "epss_percentile": 0.83239}, "CVE-2011-2798": {"epss_score": 0.00708, "epss_percentile": 0.71673}, "CVE-2011-2799": {"epss_score": 0.02007, "epss_percentile": 0.83239}, "CVE-2011-2800": {"epss_score": 0.01785, "epss_percentile": 0.82255}, "CVE-2011-2801": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2802": {"epss_score": 0.01119, "epss_percentile": 0.77757}, "CVE-2011-2803": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2804": {"epss_score": 0.02972, "epss_percentile": 0.86099}, "CVE-2011-2805": {"epss_score": 0.00575, "epss_percentile": 0.68106}, "CVE-2011-2806": {"epss_score": 0.03566, "epss_percentile": 0.87366}, "CVE-2011-2807": {"epss_score": 0.00166, "epss_percentile": 0.38152}, "CVE-2011-2808": {"epss_score": 0.0042, "epss_percentile": 0.61416}, "CVE-2011-2809": {"epss_score": 0.01016, "epss_percentile": 0.76678}, "CVE-2011-2811": {"epss_score": 0.00805, "epss_percentile": 0.73645}, "CVE-2011-2813": {"epss_score": 0.01198, "epss_percentile": 0.78452}, "CVE-2011-2814": {"epss_score": 0.01198, "epss_percentile": 0.78452}, "CVE-2011-2815": {"epss_score": 0.01198, "epss_percentile": 0.78452}, "CVE-2011-2816": {"epss_score": 0.01198, "epss_percentile": 0.78452}, "CVE-2011-2817": {"epss_score": 0.01198, "epss_percentile": 0.78452}, "CVE-2011-2818": {"epss_score": 0.03628, "epss_percentile": 0.87468}, "CVE-2011-2819": {"epss_score": 0.00738, "epss_percentile": 0.72334}, "CVE-2011-2820": {"epss_score": 0.01198, "epss_percentile": 0.78452}, "CVE-2011-2821": {"epss_score": 0.01915, "epss_percentile": 0.82852}, "CVE-2011-2822": {"epss_score": 0.00362, "epss_percentile": 0.57783}, "CVE-2011-2823": {"epss_score": 0.0229, "epss_percentile": 0.8428}, "CVE-2011-2824": {"epss_score": 0.00609, "epss_percentile": 0.69094}, "CVE-2011-2825": {"epss_score": 0.03935, "epss_percentile": 0.87981}, "CVE-2011-2826": {"epss_score": 0.00246, "epss_percentile": 0.47809}, "CVE-2011-2827": {"epss_score": 0.0229, "epss_percentile": 0.8428}, "CVE-2011-2828": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2011-2829": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2011-2830": {"epss_score": 0.02123, "epss_percentile": 0.83684}, "CVE-2011-2831": {"epss_score": 0.01198, "epss_percentile": 0.78452}, "CVE-2011-2833": {"epss_score": 0.0178, "epss_percentile": 0.82235}, "CVE-2011-2834": {"epss_score": 0.029, "epss_percentile": 0.85953}, "CVE-2011-2835": {"epss_score": 0.00103, "epss_percentile": 0.28923}, "CVE-2011-2836": {"epss_score": 0.00821, "epss_percentile": 0.73898}, "CVE-2011-2837": {"epss_score": 0.00228, "epss_percentile": 0.45494}, "CVE-2011-2838": {"epss_score": 0.00228, "epss_percentile": 0.45494}, "CVE-2011-2839": {"epss_score": 0.0222, "epss_percentile": 0.84048}, "CVE-2011-2840": {"epss_score": 0.00548, "epss_percentile": 0.67289}, "CVE-2011-2841": {"epss_score": 0.12762, "epss_percentile": 0.93766}, "CVE-2011-2842": {"epss_score": 0.00228, "epss_percentile": 0.45494}, "CVE-2011-2843": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2011-2844": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2011-2845": {"epss_score": 0.0053, "epss_percentile": 0.66626}, "CVE-2011-2846": {"epss_score": 0.02104, "epss_percentile": 0.83618}, "CVE-2011-2847": {"epss_score": 0.02455, "epss_percentile": 0.84797}, "CVE-2011-2848": {"epss_score": 0.00384, "epss_percentile": 0.59166}, "CVE-2011-2849": {"epss_score": 0.00768, "epss_percentile": 0.72968}, "CVE-2011-2850": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2011-2851": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2011-2852": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2853": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2011-2854": {"epss_score": 0.0184, "epss_percentile": 0.82493}, "CVE-2011-2855": {"epss_score": 0.01647, "epss_percentile": 0.8154}, "CVE-2011-2856": {"epss_score": 0.00157, "epss_percentile": 0.37084}, "CVE-2011-2857": {"epss_score": 0.02104, "epss_percentile": 0.83618}, "CVE-2011-2858": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2011-2859": {"epss_score": 0.00149, "epss_percentile": 0.35942}, "CVE-2011-2860": {"epss_score": 0.02121, "epss_percentile": 0.83679}, "CVE-2011-2861": {"epss_score": 0.02904, "epss_percentile": 0.8596}, "CVE-2011-2862": {"epss_score": 0.00228, "epss_percentile": 0.45494}, "CVE-2011-2863": {"epss_score": 0.00186, "epss_percentile": 0.40642}, "CVE-2011-2864": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2011-2866": {"epss_score": 0.01224, "epss_percentile": 0.78673}, "CVE-2011-2867": {"epss_score": 0.01849, "epss_percentile": 0.82532}, "CVE-2011-2868": {"epss_score": 0.01849, "epss_percentile": 0.82532}, "CVE-2011-2869": {"epss_score": 0.01849, "epss_percentile": 0.82532}, "CVE-2011-2870": {"epss_score": 0.01849, "epss_percentile": 0.82532}, "CVE-2011-2871": {"epss_score": 0.01849, "epss_percentile": 0.82532}, "CVE-2011-2872": {"epss_score": 0.01849, "epss_percentile": 0.82532}, "CVE-2011-2873": {"epss_score": 0.01849, "epss_percentile": 0.82532}, "CVE-2011-2874": {"epss_score": 0.00106, "epss_percentile": 0.29431}, "CVE-2011-2875": {"epss_score": 0.01214, "epss_percentile": 0.78573}, "CVE-2011-2876": {"epss_score": 0.00569, "epss_percentile": 0.67936}, "CVE-2011-2877": {"epss_score": 0.01611, "epss_percentile": 0.81328}, "CVE-2011-2878": {"epss_score": 0.00246, "epss_percentile": 0.47809}, "CVE-2011-2879": {"epss_score": 0.00485, "epss_percentile": 0.64732}, "CVE-2011-2880": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2011-2881": {"epss_score": 0.00534, "epss_percentile": 0.66799}, "CVE-2011-2882": {"epss_score": 0.76464, "epss_percentile": 0.98891}, "CVE-2011-2883": {"epss_score": 0.00371, "epss_percentile": 0.58358}, "CVE-2011-2884": {"epss_score": 0.02197, "epss_percentile": 0.83962}, "CVE-2011-2885": {"epss_score": 0.01283, "epss_percentile": 0.79164}, "CVE-2011-2886": {"epss_score": 0.01105, "epss_percentile": 0.7761}, "CVE-2011-2887": {"epss_score": 0.01283, "epss_percentile": 0.79164}, "CVE-2011-2888": {"epss_score": 0.01283, "epss_percentile": 0.79164}, "CVE-2011-2889": {"epss_score": 7e-05, "epss_percentile": 0.00439}, "CVE-2011-2890": {"epss_score": 0.00165, "epss_percentile": 0.38079}, "CVE-2011-2891": {"epss_score": 0.00107, "epss_percentile": 0.29656}, "CVE-2011-2892": {"epss_score": 0.00017, "epss_percentile": 0.03126}, "CVE-2011-2893": {"epss_score": 0.01105, "epss_percentile": 0.7761}, "CVE-2011-2894": {"epss_score": 0.09802, "epss_percentile": 0.92708}, "CVE-2011-2895": {"epss_score": 0.07018, "epss_percentile": 0.9119}, "CVE-2011-2896": {"epss_score": 0.07606, "epss_percentile": 0.91565}, "CVE-2011-2897": {"epss_score": 0.00985, "epss_percentile": 0.7632}, "CVE-2011-2898": {"epss_score": 0.00078, "epss_percentile": 0.23752}, "CVE-2011-2899": {"epss_score": 0.00579, "epss_percentile": 0.68231}, "CVE-2011-2900": {"epss_score": 0.51206, "epss_percentile": 0.97769}, "CVE-2011-2901": {"epss_score": 0.00119, "epss_percentile": 0.31634}, "CVE-2011-2902": {"epss_score": 0.00587, "epss_percentile": 0.6846}, "CVE-2011-2903": {"epss_score": 0.0162, "epss_percentile": 0.81385}, "CVE-2011-2904": {"epss_score": 0.00713, "epss_percentile": 0.718}, "CVE-2011-2905": {"epss_score": 0.00168, "epss_percentile": 0.38458}, "CVE-2011-2906": {"epss_score": 0.00057, "epss_percentile": 0.18206}, "CVE-2011-2907": {"epss_score": 0.00547, "epss_percentile": 0.67256}, "CVE-2011-2908": {"epss_score": 0.00837, "epss_percentile": 0.74158}, "CVE-2011-2909": {"epss_score": 0.00056, "epss_percentile": 0.17864}, "CVE-2011-2910": {"epss_score": 0.0013, "epss_percentile": 0.33327}, "CVE-2011-2911": {"epss_score": 0.03012, "epss_percentile": 0.86199}, "CVE-2011-2912": {"epss_score": 0.03012, "epss_percentile": 0.86199}, "CVE-2011-2913": {"epss_score": 0.04391, "epss_percentile": 0.88635}, "CVE-2011-2914": {"epss_score": 0.04419, "epss_percentile": 0.88667}, "CVE-2011-2915": {"epss_score": 0.08555, "epss_percentile": 0.92122}, "CVE-2011-2916": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2011-2917": {"epss_score": 0.00992, "epss_percentile": 0.7639}, "CVE-2011-2918": {"epss_score": 0.00083, "epss_percentile": 0.24764}, "CVE-2011-2919": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2011-2920": {"epss_score": 0.00389, "epss_percentile": 0.59486}, "CVE-2011-2921": {"epss_score": 0.71594, "epss_percentile": 0.98675}, "CVE-2011-2922": {"epss_score": 0.00148, "epss_percentile": 0.35802}, "CVE-2011-2923": {"epss_score": 0.0019, "epss_percentile": 0.41115}, "CVE-2011-2924": {"epss_score": 0.00126, "epss_percentile": 0.32727}, "CVE-2011-2925": {"epss_score": 0.00055, "epss_percentile": 0.17454}, "CVE-2011-2927": {"epss_score": 0.00344, "epss_percentile": 0.565}, "CVE-2011-2928": {"epss_score": 0.00078, "epss_percentile": 0.23566}, "CVE-2011-2929": {"epss_score": 0.00814, "epss_percentile": 0.73775}, "CVE-2011-2930": {"epss_score": 0.00955, "epss_percentile": 0.75915}, "CVE-2011-2931": {"epss_score": 0.00813, "epss_percentile": 0.73756}, "CVE-2011-2932": {"epss_score": 0.00813, "epss_percentile": 0.73756}, "CVE-2011-2933": {"epss_score": 0.00451, "epss_percentile": 0.63132}, "CVE-2011-2934": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2011-2935": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2011-2936": {"epss_score": 0.00322, "epss_percentile": 0.54781}, "CVE-2011-2937": {"epss_score": 0.00548, "epss_percentile": 0.67285}, "CVE-2011-2938": {"epss_score": 0.15619, "epss_percentile": 0.9447}, "CVE-2011-2939": {"epss_score": 0.06571, "epss_percentile": 0.90854}, "CVE-2011-2940": {"epss_score": 0.12759, "epss_percentile": 0.93765}, "CVE-2011-2941": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2011-2942": {"epss_score": 0.00319, "epss_percentile": 0.54564}, "CVE-2011-2943": {"epss_score": 0.03955, "epss_percentile": 0.88004}, "CVE-2011-2944": {"epss_score": 0.07428, "epss_percentile": 0.9147}, "CVE-2011-2945": {"epss_score": 0.05498, "epss_percentile": 0.89935}, "CVE-2011-2946": {"epss_score": 0.04574, "epss_percentile": 0.88866}, "CVE-2011-2947": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2011-2948": {"epss_score": 0.02647, "epss_percentile": 0.85337}, "CVE-2011-2949": {"epss_score": 0.05834, "epss_percentile": 0.90247}, "CVE-2011-2950": {"epss_score": 0.68514, "epss_percentile": 0.98552}, "CVE-2011-2951": {"epss_score": 0.05834, "epss_percentile": 0.90247}, "CVE-2011-2952": {"epss_score": 0.01652, "epss_percentile": 0.81571}, "CVE-2011-2953": {"epss_score": 0.03873, "epss_percentile": 0.87885}, "CVE-2011-2954": {"epss_score": 0.01652, "epss_percentile": 0.81571}, "CVE-2011-2955": {"epss_score": 0.01652, "epss_percentile": 0.81571}, "CVE-2011-2956": {"epss_score": 0.06173, "epss_percentile": 0.90531}, "CVE-2011-2957": {"epss_score": 0.00015, "epss_percentile": 0.02282}, "CVE-2011-2958": {"epss_score": 0.00506, "epss_percentile": 0.65629}, "CVE-2011-2959": {"epss_score": 0.02737, "epss_percentile": 0.85552}, "CVE-2011-2960": {"epss_score": 0.36178, "epss_percentile": 0.96959}, "CVE-2011-2961": {"epss_score": 0.11189, "epss_percentile": 0.9326}, "CVE-2011-2962": {"epss_score": 0.03149, "epss_percentile": 0.86504}, "CVE-2011-2963": {"epss_score": 0.08421, "epss_percentile": 0.92044}, "CVE-2011-2964": {"epss_score": 0.13071, "epss_percentile": 0.93865}, "CVE-2011-2975": {"epss_score": 0.02641, "epss_percentile": 0.85305}, "CVE-2011-2976": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2011-2977": {"epss_score": 0.00067, "epss_percentile": 0.21023}, "CVE-2011-2978": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2011-2979": {"epss_score": 0.00688, "epss_percentile": 0.71209}, "CVE-2011-2980": {"epss_score": 0.00056, "epss_percentile": 0.1785}, "CVE-2011-2981": {"epss_score": 0.01281, "epss_percentile": 0.79144}, "CVE-2011-2982": {"epss_score": 0.01852, "epss_percentile": 0.82545}, "CVE-2011-2983": {"epss_score": 0.00849, "epss_percentile": 0.7437}, "CVE-2011-2984": {"epss_score": 0.01475, "epss_percentile": 0.80525}, "CVE-2011-2985": {"epss_score": 0.03995, "epss_percentile": 0.88083}, "CVE-2011-2986": {"epss_score": 0.00379, "epss_percentile": 0.58884}, "CVE-2011-2987": {"epss_score": 0.07952, "epss_percentile": 0.91785}, "CVE-2011-2988": {"epss_score": 0.04825, "epss_percentile": 0.89183}, "CVE-2011-2989": {"epss_score": 0.05361, "epss_percentile": 0.89783}, "CVE-2011-2990": {"epss_score": 0.00542, "epss_percentile": 0.67066}, "CVE-2011-2991": {"epss_score": 0.05497, "epss_percentile": 0.89934}, "CVE-2011-2992": {"epss_score": 0.05223, "epss_percentile": 0.89628}, "CVE-2011-2993": {"epss_score": 0.00362, "epss_percentile": 0.57792}, "CVE-2011-2995": {"epss_score": 0.01877, "epss_percentile": 0.82664}, "CVE-2011-2996": {"epss_score": 0.05178, "epss_percentile": 0.89576}, "CVE-2011-2997": {"epss_score": 0.02981, "epss_percentile": 0.86123}, "CVE-2011-2998": {"epss_score": 0.02766, "epss_percentile": 0.85612}, "CVE-2011-2999": {"epss_score": 0.00722, "epss_percentile": 0.71998}, "CVE-2011-3000": {"epss_score": 0.01301, "epss_percentile": 0.79295}, "CVE-2011-3001": {"epss_score": 0.00201, "epss_percentile": 0.42286}, "CVE-2011-3002": {"epss_score": 0.0159, "epss_percentile": 0.81199}, "CVE-2011-3003": {"epss_score": 0.01512, "epss_percentile": 0.80781}, "CVE-2011-3004": {"epss_score": 0.00312, "epss_percentile": 0.54005}, "CVE-2011-3005": {"epss_score": 0.03362, "epss_percentile": 0.86993}, "CVE-2011-3006": {"epss_score": 0.00986, "epss_percentile": 0.76337}, "CVE-2011-3007": {"epss_score": 0.00579, "epss_percentile": 0.68221}, "CVE-2011-3008": {"epss_score": 0.00584, "epss_percentile": 0.68376}, "CVE-2011-3009": {"epss_score": 0.00496, "epss_percentile": 0.65176}, "CVE-2011-3010": {"epss_score": 0.17119, "epss_percentile": 0.94779}, "CVE-2011-3011": {"epss_score": 0.69278, "epss_percentile": 0.98582}, "CVE-2011-3012": {"epss_score": 0.02842, "epss_percentile": 0.85807}, "CVE-2011-3013": {"epss_score": 0.00535, "epss_percentile": 0.66825}, "CVE-2011-3014": {"epss_score": 0.00373, "epss_percentile": 0.58503}, "CVE-2011-3015": {"epss_score": 0.0062, "epss_percentile": 0.69447}, "CVE-2011-3016": {"epss_score": 0.01955, "epss_percentile": 0.83033}, "CVE-2011-3017": {"epss_score": 0.0063, "epss_percentile": 0.69706}, "CVE-2011-3018": {"epss_score": 0.00735, "epss_percentile": 0.72288}, "CVE-2011-3019": {"epss_score": 0.00676, "epss_percentile": 0.70939}, "CVE-2011-3020": {"epss_score": 0.00174, "epss_percentile": 0.39171}, "CVE-2011-3021": {"epss_score": 0.02774, "epss_percentile": 0.85632}, "CVE-2011-3022": {"epss_score": 0.00461, "epss_percentile": 0.63567}, "CVE-2011-3023": {"epss_score": 0.0062, "epss_percentile": 0.69447}, "CVE-2011-3024": {"epss_score": 0.00375, "epss_percentile": 0.58601}, "CVE-2011-3025": {"epss_score": 0.00639, "epss_percentile": 0.69935}, "CVE-2011-3026": {"epss_score": 0.28666, "epss_percentile": 0.96375}, "CVE-2011-3027": {"epss_score": 0.01656, "epss_percentile": 0.81599}, "CVE-2011-3031": {"epss_score": 0.02816, "epss_percentile": 0.85733}, "CVE-2011-3032": {"epss_score": 0.01573, "epss_percentile": 0.81099}, "CVE-2011-3033": {"epss_score": 0.02406, "epss_percentile": 0.84654}, "CVE-2011-3034": {"epss_score": 0.02363, "epss_percentile": 0.84509}, "CVE-2011-3035": {"epss_score": 0.02363, "epss_percentile": 0.84509}, "CVE-2011-3036": {"epss_score": 0.02756, "epss_percentile": 0.85592}, "CVE-2011-3037": {"epss_score": 0.02756, "epss_percentile": 0.85592}, "CVE-2011-3038": {"epss_score": 0.01029, "epss_percentile": 0.76832}, "CVE-2011-3039": {"epss_score": 0.02363, "epss_percentile": 0.84509}, "CVE-2011-3040": {"epss_score": 0.02655, "epss_percentile": 0.85354}, "CVE-2011-3041": {"epss_score": 0.02363, "epss_percentile": 0.84509}, "CVE-2011-3042": {"epss_score": 0.02363, "epss_percentile": 0.84509}, "CVE-2011-3043": {"epss_score": 0.02363, "epss_percentile": 0.84509}, "CVE-2011-3044": {"epss_score": 0.02363, "epss_percentile": 0.84509}, "CVE-2011-3045": {"epss_score": 0.07724, "epss_percentile": 0.91646}, "CVE-2011-3046": {"epss_score": 0.09708, "epss_percentile": 0.92671}, "CVE-2011-3047": {"epss_score": 0.09523, "epss_percentile": 0.92585}, "CVE-2011-3048": {"epss_score": 0.1663, "epss_percentile": 0.94705}, "CVE-2011-3049": {"epss_score": 0.01899, "epss_percentile": 0.82766}, "CVE-2011-3050": {"epss_score": 0.05574, "epss_percentile": 0.9001}, "CVE-2011-3051": {"epss_score": 0.03551, "epss_percentile": 0.8734}, "CVE-2011-3052": {"epss_score": 0.01444, "epss_percentile": 0.80317}, "CVE-2011-3053": {"epss_score": 0.04448, "epss_percentile": 0.88701}, "CVE-2011-3054": {"epss_score": 0.00656, "epss_percentile": 0.70433}, "CVE-2011-3055": {"epss_score": 0.01044, "epss_percentile": 0.77003}, "CVE-2011-3056": {"epss_score": 0.00892, "epss_percentile": 0.75062}, "CVE-2011-3057": {"epss_score": 0.02009, "epss_percentile": 0.83244}, "CVE-2011-3058": {"epss_score": 0.00753, "epss_percentile": 0.7269}, "CVE-2011-3059": {"epss_score": 0.02353, "epss_percentile": 0.84474}, "CVE-2011-3060": {"epss_score": 0.02353, "epss_percentile": 0.84474}, "CVE-2011-3061": {"epss_score": 0.00236, "epss_percentile": 0.46406}, "CVE-2011-3062": {"epss_score": 0.02392, "epss_percentile": 0.84605}, "CVE-2011-3063": {"epss_score": 0.00476, "epss_percentile": 0.64256}, "CVE-2011-3064": {"epss_score": 0.05944, "epss_percentile": 0.90352}, "CVE-2011-3065": {"epss_score": 0.01788, "epss_percentile": 0.82266}, "CVE-2011-3066": {"epss_score": 0.01466, "epss_percentile": 0.80465}, "CVE-2011-3067": {"epss_score": 0.00509, "epss_percentile": 0.65726}, "CVE-2011-3068": {"epss_score": 0.02507, "epss_percentile": 0.84941}, "CVE-2011-3069": {"epss_score": 0.02863, "epss_percentile": 0.85856}, "CVE-2011-3070": {"epss_score": 0.0241, "epss_percentile": 0.84662}, "CVE-2011-3071": {"epss_score": 0.02863, "epss_percentile": 0.85856}, "CVE-2011-3072": {"epss_score": 0.00355, "epss_percentile": 0.57323}, "CVE-2011-3073": {"epss_score": 0.02863, "epss_percentile": 0.85856}, "CVE-2011-3074": {"epss_score": 0.02128, "epss_percentile": 0.83701}, "CVE-2011-3075": {"epss_score": 0.02128, "epss_percentile": 0.83701}, "CVE-2011-3076": {"epss_score": 0.02128, "epss_percentile": 0.83701}, "CVE-2011-3077": {"epss_score": 0.01788, "epss_percentile": 0.82266}, "CVE-2011-3078": {"epss_score": 0.07354, "epss_percentile": 0.91428}, "CVE-2011-3079": {"epss_score": 0.00716, "epss_percentile": 0.7186}, "CVE-2011-3080": {"epss_score": 0.00393, "epss_percentile": 0.5973}, "CVE-2011-3081": {"epss_score": 0.07347, "epss_percentile": 0.91423}, "CVE-2011-3083": {"epss_score": 0.02166, "epss_percentile": 0.83851}, "CVE-2011-3084": {"epss_score": 0.0042, "epss_percentile": 0.61448}, "CVE-2011-3085": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2011-3086": {"epss_score": 0.07532, "epss_percentile": 0.9152}, "CVE-2011-3087": {"epss_score": 0.00854, "epss_percentile": 0.74447}, "CVE-2011-3088": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2011-3089": {"epss_score": 0.04567, "epss_percentile": 0.88858}, "CVE-2011-3090": {"epss_score": 0.02516, "epss_percentile": 0.84988}, "CVE-2011-3091": {"epss_score": 0.03454, "epss_percentile": 0.87169}, "CVE-2011-3092": {"epss_score": 0.02943, "epss_percentile": 0.86035}, "CVE-2011-3093": {"epss_score": 0.01165, "epss_percentile": 0.78176}, "CVE-2011-3094": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2011-3095": {"epss_score": 0.0302, "epss_percentile": 0.86222}, "CVE-2011-3096": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2011-3097": {"epss_score": 0.03505, "epss_percentile": 0.87257}, "CVE-2011-3098": {"epss_score": 0.00029, "epss_percentile": 0.07902}, "CVE-2011-3099": {"epss_score": 0.04004, "epss_percentile": 0.88098}, "CVE-2011-3100": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2011-3101": {"epss_score": 0.0174, "epss_percentile": 0.82045}, "CVE-2011-3102": {"epss_score": 0.01986, "epss_percentile": 0.83159}, "CVE-2011-3103": {"epss_score": 0.01764, "epss_percentile": 0.82161}, "CVE-2011-3104": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2011-3105": {"epss_score": 0.04964, "epss_percentile": 0.8934}, "CVE-2011-3106": {"epss_score": 0.07267, "epss_percentile": 0.9136}, "CVE-2011-3107": {"epss_score": 0.0188, "epss_percentile": 0.82689}, "CVE-2011-3108": {"epss_score": 0.09709, "epss_percentile": 0.92671}, "CVE-2011-3109": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2011-3110": {"epss_score": 0.02346, "epss_percentile": 0.84454}, "CVE-2011-3111": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2011-3112": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2011-3113": {"epss_score": 0.01615, "epss_percentile": 0.81353}, "CVE-2011-3114": {"epss_score": 0.01506, "epss_percentile": 0.80744}, "CVE-2011-3115": {"epss_score": 0.02269, "epss_percentile": 0.84204}, "CVE-2011-3122": {"epss_score": 0.01235, "epss_percentile": 0.78762}, "CVE-2011-3123": {"epss_score": 0.00036, "epss_percentile": 0.10513}, "CVE-2011-3124": {"epss_score": 0.00048, "epss_percentile": 0.15097}, "CVE-2011-3125": {"epss_score": 0.01125, "epss_percentile": 0.77803}, "CVE-2011-3126": {"epss_score": 0.00969, "epss_percentile": 0.76105}, "CVE-2011-3127": {"epss_score": 0.00263, "epss_percentile": 0.49549}, "CVE-2011-3128": {"epss_score": 0.01105, "epss_percentile": 0.7761}, "CVE-2011-3129": {"epss_score": 0.00612, "epss_percentile": 0.69239}, "CVE-2011-3130": {"epss_score": 0.0052, "epss_percentile": 0.6619}, "CVE-2011-3131": {"epss_score": 0.00054, "epss_percentile": 0.17299}, "CVE-2011-3132": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2011-3133": {"epss_score": 0.00377, "epss_percentile": 0.58698}, "CVE-2011-3134": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2011-3135": {"epss_score": 0.00531, "epss_percentile": 0.66666}, "CVE-2011-3136": {"epss_score": 0.00483, "epss_percentile": 0.64622}, "CVE-2011-3137": {"epss_score": 0.01334, "epss_percentile": 0.79537}, "CVE-2011-3138": {"epss_score": 0.00231, "epss_percentile": 0.45836}, "CVE-2011-3140": {"epss_score": 0.00131, "epss_percentile": 0.33481}, "CVE-2011-3141": {"epss_score": 0.0283, "epss_percentile": 0.85774}, "CVE-2011-3142": {"epss_score": 0.29326, "epss_percentile": 0.96433}, "CVE-2011-3143": {"epss_score": 0.04609, "epss_percentile": 0.88912}, "CVE-2011-3144": {"epss_score": 0.00543, "epss_percentile": 0.6712}, "CVE-2011-3145": {"epss_score": 0.00234, "epss_percentile": 0.46152}, "CVE-2011-3146": {"epss_score": 0.03439, "epss_percentile": 0.87137}, "CVE-2011-3147": {"epss_score": 0.00182, "epss_percentile": 0.40151}, "CVE-2011-3148": {"epss_score": 0.00158, "epss_percentile": 0.37293}, "CVE-2011-3149": {"epss_score": 0.00062, "epss_percentile": 0.19726}, "CVE-2011-3150": {"epss_score": 0.01042, "epss_percentile": 0.76977}, "CVE-2011-3151": {"epss_score": 0.00163, "epss_percentile": 0.37822}, "CVE-2011-3152": {"epss_score": 0.00404, "epss_percentile": 0.60409}, "CVE-2011-3153": {"epss_score": 0.00052, "epss_percentile": 0.16403}, "CVE-2011-3154": {"epss_score": 0.00133, "epss_percentile": 0.3366}, "CVE-2011-3155": {"epss_score": 0.00362, "epss_percentile": 0.57781}, "CVE-2011-3156": {"epss_score": 0.45958, "epss_percentile": 0.97514}, "CVE-2011-3157": {"epss_score": 0.45958, "epss_percentile": 0.97514}, "CVE-2011-3158": {"epss_score": 0.45958, "epss_percentile": 0.97514}, "CVE-2011-3159": {"epss_score": 0.45958, "epss_percentile": 0.97514}, "CVE-2011-3160": {"epss_score": 0.45958, "epss_percentile": 0.97514}, "CVE-2011-3161": {"epss_score": 0.45958, "epss_percentile": 0.97514}, "CVE-2011-3162": {"epss_score": 0.45958, "epss_percentile": 0.97514}, "CVE-2011-3163": {"epss_score": 0.00188, "epss_percentile": 0.4089}, "CVE-2011-3164": {"epss_score": 0.0004, "epss_percentile": 0.11994}, "CVE-2011-3165": {"epss_score": 0.42815, "epss_percentile": 0.97355}, "CVE-2011-3166": {"epss_score": 0.42815, "epss_percentile": 0.97355}, "CVE-2011-3167": {"epss_score": 0.74931, "epss_percentile": 0.98825}, "CVE-2011-3168": {"epss_score": 0.00689, "epss_percentile": 0.71218}, "CVE-2011-3169": {"epss_score": 0.01409, "epss_percentile": 0.80069}, "CVE-2011-3170": {"epss_score": 0.07686, "epss_percentile": 0.91626}, "CVE-2011-3171": {"epss_score": 0.00019, "epss_percentile": 0.04282}, "CVE-2011-3172": {"epss_score": 0.0022, "epss_percentile": 0.44608}, "CVE-2011-3173": {"epss_score": 0.13938, "epss_percentile": 0.94097}, "CVE-2011-3174": {"epss_score": 0.20272, "epss_percentile": 0.95311}, "CVE-2011-3175": {"epss_score": 0.76219, "epss_percentile": 0.98882}, "CVE-2011-3176": {"epss_score": 0.836, "epss_percentile": 0.99253}, "CVE-2011-3177": {"epss_score": 0.00034, "epss_percentile": 0.09694}, "CVE-2011-3178": {"epss_score": 0.00316, "epss_percentile": 0.5428}, "CVE-2011-3179": {"epss_score": 0.01248, "epss_percentile": 0.78864}, "CVE-2011-3180": {"epss_score": 0.01486, "epss_percentile": 0.80604}, "CVE-2011-3181": {"epss_score": 0.00604, "epss_percentile": 0.68963}, "CVE-2011-3182": {"epss_score": 0.02162, "epss_percentile": 0.83828}, "CVE-2011-3183": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2011-3184": {"epss_score": 0.02692, "epss_percentile": 0.8544}, "CVE-2011-3185": {"epss_score": 0.05087, "epss_percentile": 0.8948}, "CVE-2011-3186": {"epss_score": 0.00814, "epss_percentile": 0.73775}, "CVE-2011-3187": {"epss_score": 0.09049, "epss_percentile": 0.92379}, "CVE-2011-3188": {"epss_score": 0.01721, "epss_percentile": 0.81933}, "CVE-2011-3189": {"epss_score": 0.01272, "epss_percentile": 0.79082}, "CVE-2011-3190": {"epss_score": 0.00812, "epss_percentile": 0.73742}, "CVE-2011-3191": {"epss_score": 0.00394, "epss_percentile": 0.59771}, "CVE-2011-3192": {"epss_score": 0.92695, "epss_percentile": 0.99736}, "CVE-2011-3193": {"epss_score": 0.04637, "epss_percentile": 0.8895}, "CVE-2011-3194": {"epss_score": 0.04482, "epss_percentile": 0.88744}, "CVE-2011-3195": {"epss_score": 0.00709, "epss_percentile": 0.71686}, "CVE-2011-3196": {"epss_score": 0.00053, "epss_percentile": 0.17033}, "CVE-2011-3197": {"epss_score": 0.00601, "epss_percentile": 0.68862}, "CVE-2011-3198": {"epss_score": 0.00071, "epss_percentile": 0.22041}, "CVE-2011-3199": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2011-3200": {"epss_score": 0.6739, "epss_percentile": 0.98505}, "CVE-2011-3201": {"epss_score": 0.00808, "epss_percentile": 0.73698}, "CVE-2011-3202": {"epss_score": 0.00228, "epss_percentile": 0.45543}, "CVE-2011-3203": {"epss_score": 0.00407, "epss_percentile": 0.60578}, "CVE-2011-3204": {"epss_score": 0.00033, "epss_percentile": 0.09206}, "CVE-2011-3205": {"epss_score": 0.7604, "epss_percentile": 0.98874}, "CVE-2011-3206": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2011-3207": {"epss_score": 0.01363, "epss_percentile": 0.79767}, "CVE-2011-3208": {"epss_score": 0.08285, "epss_percentile": 0.91969}, "CVE-2011-3209": {"epss_score": 0.00204, "epss_percentile": 0.42664}, "CVE-2011-3210": {"epss_score": 0.05863, "epss_percentile": 0.90273}, "CVE-2011-3211": {"epss_score": 0.02382, "epss_percentile": 0.84567}, "CVE-2011-3212": {"epss_score": 0.00108, "epss_percentile": 0.29885}, "CVE-2011-3213": {"epss_score": 0.00222, "epss_percentile": 0.44842}, "CVE-2011-3214": {"epss_score": 0.00065, "epss_percentile": 0.20563}, "CVE-2011-3215": {"epss_score": 0.00068, "epss_percentile": 0.2136}, "CVE-2011-3216": {"epss_score": 0.00058, "epss_percentile": 0.18564}, "CVE-2011-3217": {"epss_score": 0.01411, "epss_percentile": 0.80086}, "CVE-2011-3218": {"epss_score": 0.00662, "epss_percentile": 0.706}, "CVE-2011-3219": {"epss_score": 0.02661, "epss_percentile": 0.85368}, "CVE-2011-3220": {"epss_score": 0.00735, "epss_percentile": 0.72287}, "CVE-2011-3221": {"epss_score": 0.01774, "epss_percentile": 0.82208}, "CVE-2011-3222": {"epss_score": 0.02245, "epss_percentile": 0.84128}, "CVE-2011-3223": {"epss_score": 0.02396, "epss_percentile": 0.84616}, "CVE-2011-3224": {"epss_score": 0.00534, "epss_percentile": 0.66787}, "CVE-2011-3225": {"epss_score": 0.00285, "epss_percentile": 0.51647}, "CVE-2011-3226": {"epss_score": 0.00323, "epss_percentile": 0.54891}, "CVE-2011-3227": {"epss_score": 0.0063, "epss_percentile": 0.69699}, "CVE-2011-3228": {"epss_score": 0.01383, "epss_percentile": 0.79893}, "CVE-2011-3229": {"epss_score": 0.00388, "epss_percentile": 0.59361}, "CVE-2011-3230": {"epss_score": 0.65197, "epss_percentile": 0.98408}, "CVE-2011-3231": {"epss_score": 0.00319, "epss_percentile": 0.54546}, "CVE-2011-3232": {"epss_score": 0.04655, "epss_percentile": 0.8897}, "CVE-2011-3233": {"epss_score": 0.01363, "epss_percentile": 0.79766}, "CVE-2011-3234": {"epss_score": 0.02823, "epss_percentile": 0.85752}, "CVE-2011-3235": {"epss_score": 0.01157, "epss_percentile": 0.78108}, "CVE-2011-3236": {"epss_score": 0.01157, "epss_percentile": 0.78108}, "CVE-2011-3237": {"epss_score": 0.01157, "epss_percentile": 0.78108}, "CVE-2011-3238": {"epss_score": 0.01392, "epss_percentile": 0.79962}, "CVE-2011-3239": {"epss_score": 0.01363, "epss_percentile": 0.79766}, "CVE-2011-3241": {"epss_score": 0.01363, "epss_percentile": 0.79766}, "CVE-2011-3242": {"epss_score": 0.0043, "epss_percentile": 0.62024}, "CVE-2011-3243": {"epss_score": 0.00521, "epss_percentile": 0.66218}, "CVE-2011-3244": {"epss_score": 0.01392, "epss_percentile": 0.79962}, "CVE-2011-3245": {"epss_score": 0.00142, "epss_percentile": 0.34985}, "CVE-2011-3246": {"epss_score": 0.00862, "epss_percentile": 0.74577}, "CVE-2011-3247": {"epss_score": 0.02096, "epss_percentile": 0.83589}, "CVE-2011-3248": {"epss_score": 0.02975, "epss_percentile": 0.86105}, "CVE-2011-3249": {"epss_score": 0.03498, "epss_percentile": 0.87239}, "CVE-2011-3250": {"epss_score": 0.01316, "epss_percentile": 0.79411}, "CVE-2011-3251": {"epss_score": 0.02107, "epss_percentile": 0.83633}, "CVE-2011-3252": {"epss_score": 0.04663, "epss_percentile": 0.88977}, "CVE-2011-3253": {"epss_score": 0.00123, "epss_percentile": 0.32234}, "CVE-2011-3254": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2011-3255": {"epss_score": 0.00307, "epss_percentile": 0.53474}, "CVE-2011-3256": {"epss_score": 0.02511, "epss_percentile": 0.84953}, "CVE-2011-3257": {"epss_score": 0.00053, "epss_percentile": 0.16911}, "CVE-2011-3259": {"epss_score": 0.01558, "epss_percentile": 0.81028}, "CVE-2011-3260": {"epss_score": 0.01604, "epss_percentile": 0.81281}, "CVE-2011-3261": {"epss_score": 0.01626, "epss_percentile": 0.81424}, "CVE-2011-3262": {"epss_score": 0.00096, "epss_percentile": 0.27322}, "CVE-2011-3263": {"epss_score": 0.00476, "epss_percentile": 0.64283}, "CVE-2011-3264": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2011-3265": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2011-3266": {"epss_score": 0.01019, "epss_percentile": 0.76725}, "CVE-2011-3267": {"epss_score": 0.02813, "epss_percentile": 0.85724}, "CVE-2011-3268": {"epss_score": 0.1602, "epss_percentile": 0.9456}, "CVE-2011-3269": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2011-3270": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-3271": {"epss_score": 0.25006, "epss_percentile": 0.95978}, "CVE-2011-3272": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2011-3273": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-3274": {"epss_score": 0.00182, "epss_percentile": 0.40206}, "CVE-2011-3275": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-3276": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-3277": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2011-3278": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2011-3279": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2011-3280": {"epss_score": 0.00459, "epss_percentile": 0.63461}, "CVE-2011-3281": {"epss_score": 0.00153, "epss_percentile": 0.36632}, "CVE-2011-3282": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-3283": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-3285": {"epss_score": 0.00276, "epss_percentile": 0.50754}, "CVE-2011-3287": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-3288": {"epss_score": 0.00527, "epss_percentile": 0.66472}, "CVE-2011-3289": {"epss_score": 0.00071, "epss_percentile": 0.22056}, "CVE-2011-3290": {"epss_score": 0.0154, "epss_percentile": 0.80944}, "CVE-2011-3293": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2011-3294": {"epss_score": 0.00454, "epss_percentile": 0.63243}, "CVE-2011-3295": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2011-3296": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-3297": {"epss_score": 0.00794, "epss_percentile": 0.73457}, "CVE-2011-3298": {"epss_score": 0.00226, "epss_percentile": 0.45309}, "CVE-2011-3299": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2011-3300": {"epss_score": 0.00644, "epss_percentile": 0.70082}, "CVE-2011-3301": {"epss_score": 0.00644, "epss_percentile": 0.70082}, "CVE-2011-3302": {"epss_score": 0.00644, "epss_percentile": 0.70082}, "CVE-2011-3303": {"epss_score": 0.00644, "epss_percentile": 0.70082}, "CVE-2011-3304": {"epss_score": 0.00726, "epss_percentile": 0.72077}, "CVE-2011-3305": {"epss_score": 0.42002, "epss_percentile": 0.97305}, "CVE-2011-3309": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-3310": {"epss_score": 0.27533, "epss_percentile": 0.96255}, "CVE-2011-3315": {"epss_score": 0.76355, "epss_percentile": 0.98888}, "CVE-2011-3317": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2011-3318": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-3319": {"epss_score": 0.02937, "epss_percentile": 0.86027}, "CVE-2011-3320": {"epss_score": 0.00339, "epss_percentile": 0.56175}, "CVE-2011-3321": {"epss_score": 0.02702, "epss_percentile": 0.85457}, "CVE-2011-3322": {"epss_score": 0.78209, "epss_percentile": 0.98974}, "CVE-2011-3323": {"epss_score": 0.04487, "epss_percentile": 0.88752}, "CVE-2011-3324": {"epss_score": 0.04487, "epss_percentile": 0.88752}, "CVE-2011-3325": {"epss_score": 0.05183, "epss_percentile": 0.89582}, "CVE-2011-3326": {"epss_score": 0.04228, "epss_percentile": 0.88419}, "CVE-2011-3327": {"epss_score": 0.16642, "epss_percentile": 0.94706}, "CVE-2011-3328": {"epss_score": 0.07767, "epss_percentile": 0.9167}, "CVE-2011-3330": {"epss_score": 0.0113, "epss_percentile": 0.77849}, "CVE-2011-3332": {"epss_score": 0.18232, "epss_percentile": 0.94977}, "CVE-2011-3336": {"epss_score": 0.24637, "epss_percentile": 0.95943}, "CVE-2011-3337": {"epss_score": 0.00157, "epss_percentile": 0.37039}, "CVE-2011-3339": {"epss_score": 0.00893, "epss_percentile": 0.75071}, "CVE-2011-3340": {"epss_score": 0.0094, "epss_percentile": 0.7574}, "CVE-2011-3341": {"epss_score": 0.03648, "epss_percentile": 0.87505}, "CVE-2011-3342": {"epss_score": 0.05213, "epss_percentile": 0.89617}, "CVE-2011-3343": {"epss_score": 0.0006, "epss_percentile": 0.19147}, "CVE-2011-3344": {"epss_score": 0.00389, "epss_percentile": 0.59486}, "CVE-2011-3345": {"epss_score": 0.00127, "epss_percentile": 0.32891}, "CVE-2011-3346": {"epss_score": 0.00119, "epss_percentile": 0.31642}, "CVE-2011-3347": {"epss_score": 0.00541, "epss_percentile": 0.67033}, "CVE-2011-3348": {"epss_score": 0.37038, "epss_percentile": 0.97016}, "CVE-2011-3349": {"epss_score": 0.00111, "epss_percentile": 0.30276}, "CVE-2011-3350": {"epss_score": 0.0039, "epss_percentile": 0.59537}, "CVE-2011-3351": {"epss_score": 0.00147, "epss_percentile": 0.35713}, "CVE-2011-3352": {"epss_score": 0.00302, "epss_percentile": 0.53083}, "CVE-2011-3353": {"epss_score": 0.00057, "epss_percentile": 0.18218}, "CVE-2011-3354": {"epss_score": 0.01621, "epss_percentile": 0.81395}, "CVE-2011-3355": {"epss_score": 0.00211, "epss_percentile": 0.43665}, "CVE-2011-3356": {"epss_score": 0.00825, "epss_percentile": 0.73959}, "CVE-2011-3357": {"epss_score": 0.01012, "epss_percentile": 0.76628}, "CVE-2011-3358": {"epss_score": 0.00825, "epss_percentile": 0.73959}, "CVE-2011-3359": {"epss_score": 0.0085, "epss_percentile": 0.74392}, "CVE-2011-3360": {"epss_score": 0.65771, "epss_percentile": 0.98439}, "CVE-2011-3361": {"epss_score": 0.00608, "epss_percentile": 0.69074}, "CVE-2011-3362": {"epss_score": 0.03103, "epss_percentile": 0.86413}, "CVE-2011-3363": {"epss_score": 0.00229, "epss_percentile": 0.45655}, "CVE-2011-3364": {"epss_score": 0.00087, "epss_percentile": 0.25445}, "CVE-2011-3365": {"epss_score": 0.00234, "epss_percentile": 0.46108}, "CVE-2011-3366": {"epss_score": 0.00147, "epss_percentile": 0.35781}, "CVE-2011-3367": {"epss_score": 0.00131, "epss_percentile": 0.33349}, "CVE-2011-3368": {"epss_score": 0.79132, "epss_percentile": 0.9902}, "CVE-2011-3369": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2011-3370": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2011-3371": {"epss_score": 0.00548, "epss_percentile": 0.67285}, "CVE-2011-3372": {"epss_score": 0.00748, "epss_percentile": 0.72583}, "CVE-2011-3373": {"epss_score": 0.0059, "epss_percentile": 0.68576}, "CVE-2011-3374": {"epss_score": 0.01509, "epss_percentile": 0.80765}, "CVE-2011-3375": {"epss_score": 0.02015, "epss_percentile": 0.83271}, "CVE-2011-3376": {"epss_score": 0.00299, "epss_percentile": 0.52868}, "CVE-2011-3377": {"epss_score": 0.00971, "epss_percentile": 0.7613}, "CVE-2011-3378": {"epss_score": 0.08233, "epss_percentile": 0.91942}, "CVE-2011-3379": {"epss_score": 0.01085, "epss_percentile": 0.77402}, "CVE-2011-3380": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-3381": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2011-3382": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2011-3383": {"epss_score": 0.00312, "epss_percentile": 0.54001}, "CVE-2011-3384": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-3385": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-3386": {"epss_score": 0.01107, "epss_percentile": 0.77626}, "CVE-2011-3387": {"epss_score": 0.00709, "epss_percentile": 0.7169}, "CVE-2011-3388": {"epss_score": 0.01003, "epss_percentile": 0.76521}, "CVE-2011-3389": {"epss_score": 0.04129, "epss_percentile": 0.88295}, "CVE-2011-3390": {"epss_score": 0.11569, "epss_percentile": 0.93407}, "CVE-2011-3391": {"epss_score": 0.00327, "epss_percentile": 0.55097}, "CVE-2011-3392": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2011-3393": {"epss_score": 0.00567, "epss_percentile": 0.67851}, "CVE-2011-3394": {"epss_score": 0.00679, "epss_percentile": 0.71011}, "CVE-2011-3396": {"epss_score": 0.49994, "epss_percentile": 0.97713}, "CVE-2011-3397": {"epss_score": 0.24819, "epss_percentile": 0.95957}, "CVE-2011-3400": {"epss_score": 0.85182, "epss_percentile": 0.99323}, "CVE-2011-3401": {"epss_score": 0.38836, "epss_percentile": 0.97122}, "CVE-2011-3402": {"epss_score": 0.89217, "epss_percentile": 0.99515}, "CVE-2011-3403": {"epss_score": 0.39357, "epss_percentile": 0.97157}, "CVE-2011-3404": {"epss_score": 0.1521, "epss_percentile": 0.94385}, "CVE-2011-3406": {"epss_score": 0.4348, "epss_percentile": 0.97389}, "CVE-2011-3408": {"epss_score": 0.00553, "epss_percentile": 0.67429}, "CVE-2011-3410": {"epss_score": 0.5826, "epss_percentile": 0.98105}, "CVE-2011-3411": {"epss_score": 0.55708, "epss_percentile": 0.97991}, "CVE-2011-3412": {"epss_score": 0.55708, "epss_percentile": 0.97991}, "CVE-2011-3413": {"epss_score": 0.52411, "epss_percentile": 0.97824}, "CVE-2011-3414": {"epss_score": 0.7197, "epss_percentile": 0.9869}, "CVE-2011-3415": {"epss_score": 0.44113, "epss_percentile": 0.97419}, "CVE-2011-3416": {"epss_score": 0.52829, "epss_percentile": 0.97843}, "CVE-2011-3417": {"epss_score": 0.62841, "epss_percentile": 0.9831}, "CVE-2011-3420": {"epss_score": 0.00586, "epss_percentile": 0.68433}, "CVE-2011-3421": {"epss_score": 0.00488, "epss_percentile": 0.64849}, "CVE-2011-3422": {"epss_score": 0.0032, "epss_percentile": 0.54626}, "CVE-2011-3423": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2011-3424": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2011-3426": {"epss_score": 0.00875, "epss_percentile": 0.74772}, "CVE-2011-3427": {"epss_score": 0.00282, "epss_percentile": 0.51269}, "CVE-2011-3428": {"epss_score": 0.02985, "epss_percentile": 0.8613}, "CVE-2011-3429": {"epss_score": 0.00069, "epss_percentile": 0.21531}, "CVE-2011-3430": {"epss_score": 0.00467, "epss_percentile": 0.63836}, "CVE-2011-3431": {"epss_score": 0.00069, "epss_percentile": 0.21531}, "CVE-2011-3432": {"epss_score": 0.0082, "epss_percentile": 0.73879}, "CVE-2011-3434": {"epss_score": 0.00493, "epss_percentile": 0.65054}, "CVE-2011-3435": {"epss_score": 0.00117, "epss_percentile": 0.31327}, "CVE-2011-3436": {"epss_score": 0.00103, "epss_percentile": 0.29013}, "CVE-2011-3437": {"epss_score": 0.00957, "epss_percentile": 0.75938}, "CVE-2011-3438": {"epss_score": 0.0083, "epss_percentile": 0.74028}, "CVE-2011-3439": {"epss_score": 0.06537, "epss_percentile": 0.90829}, "CVE-2011-3440": {"epss_score": 0.00055, "epss_percentile": 0.17499}, "CVE-2011-3441": {"epss_score": 0.00421, "epss_percentile": 0.61516}, "CVE-2011-3442": {"epss_score": 0.00048, "epss_percentile": 0.15047}, "CVE-2011-3443": {"epss_score": 0.01686, "epss_percentile": 0.81752}, "CVE-2011-3444": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2011-3446": {"epss_score": 0.01341, "epss_percentile": 0.7959}, "CVE-2011-3447": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2011-3448": {"epss_score": 0.01241, "epss_percentile": 0.78815}, "CVE-2011-3449": {"epss_score": 0.01285, "epss_percentile": 0.79177}, "CVE-2011-3450": {"epss_score": 0.01097, "epss_percentile": 0.7753}, "CVE-2011-3452": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2011-3453": {"epss_score": 0.03229, "epss_percentile": 0.86692}, "CVE-2011-3457": {"epss_score": 0.02057, "epss_percentile": 0.83428}, "CVE-2011-3458": {"epss_score": 0.01917, "epss_percentile": 0.82872}, "CVE-2011-3459": {"epss_score": 0.01772, "epss_percentile": 0.82203}, "CVE-2011-3460": {"epss_score": 0.02166, "epss_percentile": 0.83848}, "CVE-2011-3462": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2011-3463": {"epss_score": 0.00045, "epss_percentile": 0.13831}, "CVE-2011-3464": {"epss_score": 0.01879, "epss_percentile": 0.82671}, "CVE-2011-3477": {"epss_score": 0.00055, "epss_percentile": 0.17638}, "CVE-2011-3478": {"epss_score": 0.52904, "epss_percentile": 0.97845}, "CVE-2011-3479": {"epss_score": 0.00552, "epss_percentile": 0.674}, "CVE-2011-3481": {"epss_score": 0.01138, "epss_percentile": 0.77933}, "CVE-2011-3482": {"epss_score": 0.00946, "epss_percentile": 0.75806}, "CVE-2011-3483": {"epss_score": 0.06778, "epss_percentile": 0.91019}, "CVE-2011-3484": {"epss_score": 0.0144, "epss_percentile": 0.803}, "CVE-2011-3486": {"epss_score": 0.58999, "epss_percentile": 0.98145}, "CVE-2011-3487": {"epss_score": 0.02361, "epss_percentile": 0.84499}, "CVE-2011-3488": {"epss_score": 0.0682, "epss_percentile": 0.91047}, "CVE-2011-3489": {"epss_score": 0.00215, "epss_percentile": 0.44058}, "CVE-2011-3490": {"epss_score": 0.19938, "epss_percentile": 0.95264}, "CVE-2011-3491": {"epss_score": 0.19129, "epss_percentile": 0.95136}, "CVE-2011-3492": {"epss_score": 0.78299, "epss_percentile": 0.98978}, "CVE-2011-3493": {"epss_score": 0.06769, "epss_percentile": 0.91013}, "CVE-2011-3494": {"epss_score": 0.72445, "epss_percentile": 0.98709}, "CVE-2011-3495": {"epss_score": 0.05991, "epss_percentile": 0.90386}, "CVE-2011-3496": {"epss_score": 0.12874, "epss_percentile": 0.93808}, "CVE-2011-3497": {"epss_score": 0.72313, "epss_percentile": 0.98704}, "CVE-2011-3498": {"epss_score": 0.57038, "epss_percentile": 0.98046}, "CVE-2011-3499": {"epss_score": 0.54924, "epss_percentile": 0.97951}, "CVE-2011-3500": {"epss_score": 0.00111, "epss_percentile": 0.30333}, "CVE-2011-3501": {"epss_score": 0.13468, "epss_percentile": 0.93974}, "CVE-2011-3502": {"epss_score": 0.04534, "epss_percentile": 0.88814}, "CVE-2011-3503": {"epss_score": 0.02279, "epss_percentile": 0.84237}, "CVE-2011-3504": {"epss_score": 0.03682, "epss_percentile": 0.87561}, "CVE-2011-3506": {"epss_score": 0.00361, "epss_percentile": 0.57718}, "CVE-2011-3507": {"epss_score": 0.00234, "epss_percentile": 0.46082}, "CVE-2011-3508": {"epss_score": 0.00832, "epss_percentile": 0.74063}, "CVE-2011-3509": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2011-3510": {"epss_score": 0.00291, "epss_percentile": 0.52182}, "CVE-2011-3511": {"epss_score": 0.00344, "epss_percentile": 0.56533}, "CVE-2011-3512": {"epss_score": 0.00509, "epss_percentile": 0.65737}, "CVE-2011-3513": {"epss_score": 0.00499, "epss_percentile": 0.65259}, "CVE-2011-3514": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2011-3515": {"epss_score": 0.0014, "epss_percentile": 0.34705}, "CVE-2011-3516": {"epss_score": 0.04026, "epss_percentile": 0.88142}, "CVE-2011-3517": {"epss_score": 0.01482, "epss_percentile": 0.80574}, "CVE-2011-3518": {"epss_score": 0.00263, "epss_percentile": 0.49526}, "CVE-2011-3519": {"epss_score": 0.00191, "epss_percentile": 0.41182}, "CVE-2011-3520": {"epss_score": 0.0028, "epss_percentile": 0.51081}, "CVE-2011-3521": {"epss_score": 0.05741, "epss_percentile": 0.90168}, "CVE-2011-3522": {"epss_score": 0.00079, "epss_percentile": 0.23899}, "CVE-2011-3523": {"epss_score": 0.00177, "epss_percentile": 0.39502}, "CVE-2011-3524": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2011-3525": {"epss_score": 0.00874, "epss_percentile": 0.74767}, "CVE-2011-3526": {"epss_score": 0.00307, "epss_percentile": 0.53535}, "CVE-2011-3527": {"epss_score": 0.00263, "epss_percentile": 0.49526}, "CVE-2011-3528": {"epss_score": 0.00263, "epss_percentile": 0.49526}, "CVE-2011-3529": {"epss_score": 0.00307, "epss_percentile": 0.53535}, "CVE-2011-3530": {"epss_score": 0.00307, "epss_percentile": 0.53535}, "CVE-2011-3531": {"epss_score": 0.0065, "epss_percentile": 0.70259}, "CVE-2011-3532": {"epss_score": 0.00582, "epss_percentile": 0.68304}, "CVE-2011-3533": {"epss_score": 0.00263, "epss_percentile": 0.49526}, "CVE-2011-3534": {"epss_score": 0.01218, "epss_percentile": 0.78606}, "CVE-2011-3535": {"epss_score": 0.01218, "epss_percentile": 0.78606}, "CVE-2011-3536": {"epss_score": 0.00143, "epss_percentile": 0.35194}, "CVE-2011-3537": {"epss_score": 0.00631, "epss_percentile": 0.6973}, "CVE-2011-3538": {"epss_score": 0.00925, "epss_percentile": 0.75528}, "CVE-2011-3539": {"epss_score": 0.00098, "epss_percentile": 0.27682}, "CVE-2011-3541": {"epss_score": 0.00466, "epss_percentile": 0.63796}, "CVE-2011-3542": {"epss_score": 0.0014, "epss_percentile": 0.34705}, "CVE-2011-3543": {"epss_score": 0.0081, "epss_percentile": 0.73713}, "CVE-2011-3544": {"epss_score": 0.92955, "epss_percentile": 0.99763}, "CVE-2011-3545": {"epss_score": 0.10184, "epss_percentile": 0.92884}, "CVE-2011-3546": {"epss_score": 0.01593, "epss_percentile": 0.81228}, "CVE-2011-3547": {"epss_score": 0.01681, "epss_percentile": 0.81729}, "CVE-2011-3548": {"epss_score": 0.03056, "epss_percentile": 0.863}, "CVE-2011-3549": {"epss_score": 0.02755, "epss_percentile": 0.85589}, "CVE-2011-3550": {"epss_score": 0.04026, "epss_percentile": 0.88142}, "CVE-2011-3551": {"epss_score": 0.06348, "epss_percentile": 0.90688}, "CVE-2011-3552": {"epss_score": 0.01668, "epss_percentile": 0.81661}, "CVE-2011-3553": {"epss_score": 0.00261, "epss_percentile": 0.49264}, "CVE-2011-3554": {"epss_score": 0.03172, "epss_percentile": 0.8655}, "CVE-2011-3555": {"epss_score": 0.01619, "epss_percentile": 0.81378}, "CVE-2011-3556": {"epss_score": 0.86828, "epss_percentile": 0.994}, "CVE-2011-3557": {"epss_score": 0.04231, "epss_percentile": 0.88424}, "CVE-2011-3558": {"epss_score": 0.02102, "epss_percentile": 0.83605}, "CVE-2011-3559": {"epss_score": 0.00955, "epss_percentile": 0.75918}, "CVE-2011-3560": {"epss_score": 0.01686, "epss_percentile": 0.81753}, "CVE-2011-3561": {"epss_score": 0.00661, "epss_percentile": 0.70567}, "CVE-2011-3562": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2011-3563": {"epss_score": 0.05146, "epss_percentile": 0.89542}, "CVE-2011-3564": {"epss_score": 0.00056, "epss_percentile": 0.1785}, "CVE-2011-3565": {"epss_score": 0.00075, "epss_percentile": 0.22901}, "CVE-2011-3566": {"epss_score": 0.0065, "epss_percentile": 0.70259}, "CVE-2011-3568": {"epss_score": 0.00188, "epss_percentile": 0.40893}, "CVE-2011-3569": {"epss_score": 0.00295, "epss_percentile": 0.5251}, "CVE-2011-3570": {"epss_score": 0.00067, "epss_percentile": 0.21104}, "CVE-2011-3571": {"epss_score": 0.00256, "epss_percentile": 0.4877}, "CVE-2011-3573": {"epss_score": 0.00355, "epss_percentile": 0.57273}, "CVE-2011-3574": {"epss_score": 0.00065, "epss_percentile": 0.20574}, "CVE-2011-3575": {"epss_score": 0.26778, "epss_percentile": 0.9618}, "CVE-2011-3576": {"epss_score": 0.00202, "epss_percentile": 0.42481}, "CVE-2011-3577": {"epss_score": 0.01222, "epss_percentile": 0.78656}, "CVE-2011-3578": {"epss_score": 0.01325, "epss_percentile": 0.7947}, "CVE-2011-3579": {"epss_score": 0.10644, "epss_percentile": 0.93056}, "CVE-2011-3580": {"epss_score": 0.00387, "epss_percentile": 0.59307}, "CVE-2011-3581": {"epss_score": 0.04066, "epss_percentile": 0.882}, "CVE-2011-3582": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2011-3583": {"epss_score": 0.00472, "epss_percentile": 0.64043}, "CVE-2011-3584": {"epss_score": 0.00472, "epss_percentile": 0.64043}, "CVE-2011-3585": {"epss_score": 0.0055, "epss_percentile": 0.6733}, "CVE-2011-3587": {"epss_score": 0.90592, "epss_percentile": 0.9959}, "CVE-2011-3588": {"epss_score": 0.00168, "epss_percentile": 0.38464}, "CVE-2011-3589": {"epss_score": 0.00127, "epss_percentile": 0.32873}, "CVE-2011-3590": {"epss_score": 0.00168, "epss_percentile": 0.38464}, "CVE-2011-3591": {"epss_score": 0.0018, "epss_percentile": 0.39898}, "CVE-2011-3592": {"epss_score": 0.0018, "epss_percentile": 0.39898}, "CVE-2011-3593": {"epss_score": 0.0032, "epss_percentile": 0.54592}, "CVE-2011-3594": {"epss_score": 0.00959, "epss_percentile": 0.75958}, "CVE-2011-3595": {"epss_score": 0.00034, "epss_percentile": 0.09726}, "CVE-2011-3596": {"epss_score": 0.13877, "epss_percentile": 0.94082}, "CVE-2011-3597": {"epss_score": 0.12622, "epss_percentile": 0.93732}, "CVE-2011-3598": {"epss_score": 0.00715, "epss_percentile": 0.71838}, "CVE-2011-3599": {"epss_score": 0.00356, "epss_percentile": 0.57343}, "CVE-2011-3600": {"epss_score": 0.37264, "epss_percentile": 0.97031}, "CVE-2011-3601": {"epss_score": 0.0187, "epss_percentile": 0.82631}, "CVE-2011-3602": {"epss_score": 0.00369, "epss_percentile": 0.58274}, "CVE-2011-3603": {"epss_score": 0.00062, "epss_percentile": 0.19753}, "CVE-2011-3604": {"epss_score": 0.00498, "epss_percentile": 0.65218}, "CVE-2011-3605": {"epss_score": 0.00513, "epss_percentile": 0.65905}, "CVE-2011-3606": {"epss_score": 0.00402, "epss_percentile": 0.60282}, "CVE-2011-3607": {"epss_score": 0.00397, "epss_percentile": 0.60032}, "CVE-2011-3609": {"epss_score": 0.00509, "epss_percentile": 0.65741}, "CVE-2011-3610": {"epss_score": 0.00347, "epss_percentile": 0.56776}, "CVE-2011-3611": {"epss_score": 0.01983, "epss_percentile": 0.83147}, "CVE-2011-3612": {"epss_score": 0.00405, "epss_percentile": 0.60492}, "CVE-2011-3613": {"epss_score": 0.00745, "epss_percentile": 0.72522}, "CVE-2011-3614": {"epss_score": 0.01019, "epss_percentile": 0.76725}, "CVE-2011-3615": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2011-3616": {"epss_score": 0.00033, "epss_percentile": 0.09153}, "CVE-2011-3617": {"epss_score": 0.00277, "epss_percentile": 0.50801}, "CVE-2011-3618": {"epss_score": 0.00107, "epss_percentile": 0.29678}, "CVE-2011-3619": {"epss_score": 0.00056, "epss_percentile": 0.17911}, "CVE-2011-3620": {"epss_score": 0.02981, "epss_percentile": 0.86123}, "CVE-2011-3621": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2011-3622": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2011-3623": {"epss_score": 0.03687, "epss_percentile": 0.87572}, "CVE-2011-3624": {"epss_score": 0.00926, "epss_percentile": 0.75556}, "CVE-2011-3625": {"epss_score": 0.68101, "epss_percentile": 0.98531}, "CVE-2011-3626": {"epss_score": 0.00934, "epss_percentile": 0.75653}, "CVE-2011-3627": {"epss_score": 0.01895, "epss_percentile": 0.82745}, "CVE-2011-3628": {"epss_score": 0.00051, "epss_percentile": 0.16127}, "CVE-2011-3629": {"epss_score": 0.00013, "epss_percentile": 0.01586}, "CVE-2011-3630": {"epss_score": 0.03115, "epss_percentile": 0.86434}, "CVE-2011-3631": {"epss_score": 0.04155, "epss_percentile": 0.88328}, "CVE-2011-3632": {"epss_score": 0.00132, "epss_percentile": 0.33551}, "CVE-2011-3634": {"epss_score": 0.00163, "epss_percentile": 0.37857}, "CVE-2011-3635": {"epss_score": 0.0048, "epss_percentile": 0.64461}, "CVE-2011-3636": {"epss_score": 0.00157, "epss_percentile": 0.37076}, "CVE-2011-3637": {"epss_score": 0.00064, "epss_percentile": 0.20269}, "CVE-2011-3638": {"epss_score": 0.00153, "epss_percentile": 0.36617}, "CVE-2011-3639": {"epss_score": 0.11217, "epss_percentile": 0.93269}, "CVE-2011-3640": {"epss_score": 0.0034, "epss_percentile": 0.56218}, "CVE-2011-3642": {"epss_score": 0.089, "epss_percentile": 0.92306}, "CVE-2011-3645": {"epss_score": 0.01123, "epss_percentile": 0.77787}, "CVE-2011-3646": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2011-3647": {"epss_score": 0.00769, "epss_percentile": 0.72982}, "CVE-2011-3648": {"epss_score": 0.00338, "epss_percentile": 0.56155}, "CVE-2011-3649": {"epss_score": 0.00262, "epss_percentile": 0.49384}, "CVE-2011-3650": {"epss_score": 0.01271, "epss_percentile": 0.79074}, "CVE-2011-3651": {"epss_score": 0.02462, "epss_percentile": 0.84829}, "CVE-2011-3652": {"epss_score": 0.03926, "epss_percentile": 0.87963}, "CVE-2011-3653": {"epss_score": 0.00234, "epss_percentile": 0.46154}, "CVE-2011-3654": {"epss_score": 0.19734, "epss_percentile": 0.95233}, "CVE-2011-3655": {"epss_score": 0.00939, "epss_percentile": 0.75726}, "CVE-2011-3656": {"epss_score": 0.00273, "epss_percentile": 0.50459}, "CVE-2011-3657": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2011-3658": {"epss_score": 0.75876, "epss_percentile": 0.98868}, "CVE-2011-3659": {"epss_score": 0.76075, "epss_percentile": 0.98877}, "CVE-2011-3660": {"epss_score": 0.03749, "epss_percentile": 0.87671}, "CVE-2011-3661": {"epss_score": 0.04527, "epss_percentile": 0.88806}, "CVE-2011-3663": {"epss_score": 0.00961, "epss_percentile": 0.75977}, "CVE-2011-3664": {"epss_score": 0.01153, "epss_percentile": 0.78053}, "CVE-2011-3665": {"epss_score": 0.03707, "epss_percentile": 0.87599}, "CVE-2011-3666": {"epss_score": 0.0033, "epss_percentile": 0.55482}, "CVE-2011-3667": {"epss_score": 0.00465, "epss_percentile": 0.6374}, "CVE-2011-3668": {"epss_score": 0.00128, "epss_percentile": 0.33029}, "CVE-2011-3669": {"epss_score": 0.00128, "epss_percentile": 0.33029}, "CVE-2011-3670": {"epss_score": 0.00725, "epss_percentile": 0.72053}, "CVE-2011-3671": {"epss_score": 0.01755, "epss_percentile": 0.82121}, "CVE-2011-3684": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2011-3685": {"epss_score": 0.00051, "epss_percentile": 0.16248}, "CVE-2011-3686": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2011-3687": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2011-3688": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2011-3689": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2011-3690": {"epss_score": 0.00386, "epss_percentile": 0.59248}, "CVE-2011-3691": {"epss_score": 0.07615, "epss_percentile": 0.91569}, "CVE-2011-3692": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2011-3693": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2011-3694": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-3695": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2011-3696": {"epss_score": 0.00317, "epss_percentile": 0.54381}, "CVE-2011-3697": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3698": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3699": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3700": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3701": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3702": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3703": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3704": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3705": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3706": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3707": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3708": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3709": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3710": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3711": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3712": {"epss_score": 0.00301, "epss_percentile": 0.5302}, "CVE-2011-3713": {"epss_score": 0.06271, "epss_percentile": 0.90629}, "CVE-2011-3714": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3715": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3716": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3717": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3718": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2011-3719": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3720": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3721": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3722": {"epss_score": 0.00352, "epss_percentile": 0.57082}, "CVE-2011-3723": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3724": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3725": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3726": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3727": {"epss_score": 0.00671, "epss_percentile": 0.70804}, "CVE-2011-3728": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3729": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3730": {"epss_score": 0.01027, "epss_percentile": 0.76804}, "CVE-2011-3731": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3732": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3733": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3734": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3735": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3736": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3737": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2011-3738": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3739": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3740": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3741": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3742": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3743": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3744": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3745": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3746": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3747": {"epss_score": 0.00179, "epss_percentile": 0.39795}, "CVE-2011-3748": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3749": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3750": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3751": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3752": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3753": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3754": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3755": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2011-3756": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3757": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2011-3758": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3759": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3760": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3761": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3762": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3763": {"epss_score": 0.01117, "epss_percentile": 0.77736}, "CVE-2011-3764": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3765": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3766": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3767": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3768": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3769": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3770": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3771": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3772": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3773": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3774": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3775": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3776": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3777": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3778": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-3779": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3780": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3781": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3782": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3783": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3784": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3785": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3786": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3787": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3788": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3789": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3790": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3791": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3792": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3793": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3794": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3795": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3796": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3797": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3798": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3799": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3800": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3801": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3802": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3803": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3804": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3805": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3806": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3807": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3808": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3809": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3810": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2011-3811": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3812": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3813": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3814": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2011-3815": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2011-3816": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2011-3817": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2011-3818": {"epss_score": 0.00507, "epss_percentile": 0.65651}, "CVE-2011-3819": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3820": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3821": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3822": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3823": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3824": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3825": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3826": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-3827": {"epss_score": 0.0365, "epss_percentile": 0.87507}, "CVE-2011-3828": {"epss_score": 0.01896, "epss_percentile": 0.8275}, "CVE-2011-3829": {"epss_score": 0.36121, "epss_percentile": 0.96957}, "CVE-2011-3830": {"epss_score": 0.00396, "epss_percentile": 0.59901}, "CVE-2011-3831": {"epss_score": 0.00934, "epss_percentile": 0.7565}, "CVE-2011-3832": {"epss_score": 0.00618, "epss_percentile": 0.69367}, "CVE-2011-3833": {"epss_score": 0.21003, "epss_percentile": 0.9545}, "CVE-2011-3834": {"epss_score": 0.06374, "epss_percentile": 0.90707}, "CVE-2011-3835": {"epss_score": 0.01132, "epss_percentile": 0.7787}, "CVE-2011-3836": {"epss_score": 0.00244, "epss_percentile": 0.47519}, "CVE-2011-3837": {"epss_score": 0.00161, "epss_percentile": 0.37609}, "CVE-2011-3838": {"epss_score": 0.00836, "epss_percentile": 0.74149}, "CVE-2011-3839": {"epss_score": 0.00383, "epss_percentile": 0.59107}, "CVE-2011-3841": {"epss_score": 0.00468, "epss_percentile": 0.63874}, "CVE-2011-3844": {"epss_score": 0.00277, "epss_percentile": 0.50788}, "CVE-2011-3845": {"epss_score": 0.03228, "epss_percentile": 0.86689}, "CVE-2011-3846": {"epss_score": 0.00119, "epss_percentile": 0.31682}, "CVE-2011-3848": {"epss_score": 0.00433, "epss_percentile": 0.62226}, "CVE-2011-3849": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2011-3850": {"epss_score": 0.01123, "epss_percentile": 0.77786}, "CVE-2011-3851": {"epss_score": 0.00217, "epss_percentile": 0.44289}, "CVE-2011-3852": {"epss_score": 0.00338, "epss_percentile": 0.5615}, "CVE-2011-3853": {"epss_score": 0.00217, "epss_percentile": 0.44289}, "CVE-2011-3854": {"epss_score": 0.00186, "epss_percentile": 0.4065}, "CVE-2011-3855": {"epss_score": 0.00338, "epss_percentile": 0.5615}, "CVE-2011-3856": {"epss_score": 0.00338, "epss_percentile": 0.5615}, "CVE-2011-3857": {"epss_score": 0.00217, "epss_percentile": 0.44289}, "CVE-2011-3858": {"epss_score": 0.00338, "epss_percentile": 0.5615}, "CVE-2011-3859": {"epss_score": 0.00338, "epss_percentile": 0.5615}, "CVE-2011-3860": {"epss_score": 0.00394, "epss_percentile": 0.59781}, "CVE-2011-3861": {"epss_score": 0.00338, "epss_percentile": 0.5615}, "CVE-2011-3862": {"epss_score": 0.00394, "epss_percentile": 0.59781}, "CVE-2011-3863": {"epss_score": 0.00338, "epss_percentile": 0.5615}, "CVE-2011-3864": {"epss_score": 0.00217, "epss_percentile": 0.44289}, "CVE-2011-3865": {"epss_score": 0.00338, "epss_percentile": 0.5615}, "CVE-2011-3866": {"epss_score": 0.00418, "epss_percentile": 0.61344}, "CVE-2011-3868": {"epss_score": 0.1734, "epss_percentile": 0.9483}, "CVE-2011-3869": {"epss_score": 0.00042, "epss_percentile": 0.12731}, "CVE-2011-3870": {"epss_score": 0.00033, "epss_percentile": 0.09163}, "CVE-2011-3871": {"epss_score": 0.00042, "epss_percentile": 0.12924}, "CVE-2011-3872": {"epss_score": 0.02778, "epss_percentile": 0.85645}, "CVE-2011-3873": {"epss_score": 0.01632, "epss_percentile": 0.81456}, "CVE-2011-3874": {"epss_score": 0.2248, "epss_percentile": 0.95642}, "CVE-2011-3875": {"epss_score": 0.00333, "epss_percentile": 0.55644}, "CVE-2011-3876": {"epss_score": 0.00198, "epss_percentile": 0.41974}, "CVE-2011-3877": {"epss_score": 0.00317, "epss_percentile": 0.54352}, "CVE-2011-3878": {"epss_score": 0.00516, "epss_percentile": 0.66058}, "CVE-2011-3879": {"epss_score": 0.00198, "epss_percentile": 0.41974}, "CVE-2011-3880": {"epss_score": 0.00198, "epss_percentile": 0.41974}, "CVE-2011-3881": {"epss_score": 0.00502, "epss_percentile": 0.65412}, "CVE-2011-3882": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2011-3883": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2011-3884": {"epss_score": 0.0078, "epss_percentile": 0.73173}, "CVE-2011-3885": {"epss_score": 0.02414, "epss_percentile": 0.84685}, "CVE-2011-3886": {"epss_score": 0.00908, "epss_percentile": 0.75279}, "CVE-2011-3887": {"epss_score": 0.00515, "epss_percentile": 0.65972}, "CVE-2011-3888": {"epss_score": 0.02104, "epss_percentile": 0.83618}, "CVE-2011-3889": {"epss_score": 0.00716, "epss_percentile": 0.71858}, "CVE-2011-3890": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2011-3891": {"epss_score": 0.00784, "epss_percentile": 0.73235}, "CVE-2011-3892": {"epss_score": 0.02107, "epss_percentile": 0.83634}, "CVE-2011-3893": {"epss_score": 0.02187, "epss_percentile": 0.83923}, "CVE-2011-3894": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2011-3895": {"epss_score": 0.03439, "epss_percentile": 0.87138}, "CVE-2011-3896": {"epss_score": 0.00777, "epss_percentile": 0.7311}, "CVE-2011-3897": {"epss_score": 0.02104, "epss_percentile": 0.83618}, "CVE-2011-3898": {"epss_score": 0.01694, "epss_percentile": 0.818}, "CVE-2011-3900": {"epss_score": 0.00784, "epss_percentile": 0.73235}, "CVE-2011-3901": {"epss_score": 0.00285, "epss_percentile": 0.51675}, "CVE-2011-3903": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-3904": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2011-3905": {"epss_score": 0.01212, "epss_percentile": 0.78556}, "CVE-2011-3906": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-3907": {"epss_score": 0.00242, "epss_percentile": 0.47388}, "CVE-2011-3908": {"epss_score": 0.0234, "epss_percentile": 0.84434}, "CVE-2011-3909": {"epss_score": 0.0234, "epss_percentile": 0.84434}, "CVE-2011-3910": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-3911": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-3912": {"epss_score": 0.00609, "epss_percentile": 0.69094}, "CVE-2011-3913": {"epss_score": 0.0229, "epss_percentile": 0.8428}, "CVE-2011-3914": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2011-3915": {"epss_score": 0.00566, "epss_percentile": 0.67826}, "CVE-2011-3916": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-3917": {"epss_score": 0.00566, "epss_percentile": 0.67826}, "CVE-2011-3918": {"epss_score": 0.10066, "epss_percentile": 0.92839}, "CVE-2011-3919": {"epss_score": 0.03188, "epss_percentile": 0.86591}, "CVE-2011-3921": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2011-3922": {"epss_score": 0.01278, "epss_percentile": 0.79128}, "CVE-2011-3923": {"epss_score": 0.89729, "epss_percentile": 0.99539}, "CVE-2011-3924": {"epss_score": 0.0234, "epss_percentile": 0.84434}, "CVE-2011-3925": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2011-3926": {"epss_score": 0.02946, "epss_percentile": 0.86041}, "CVE-2011-3927": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2011-3928": {"epss_score": 0.01858, "epss_percentile": 0.8258}, "CVE-2011-3929": {"epss_score": 0.02918, "epss_percentile": 0.85985}, "CVE-2011-3934": {"epss_score": 0.00586, "epss_percentile": 0.6845}, "CVE-2011-3935": {"epss_score": 0.00586, "epss_percentile": 0.6845}, "CVE-2011-3936": {"epss_score": 0.01027, "epss_percentile": 0.76804}, "CVE-2011-3937": {"epss_score": 0.00692, "epss_percentile": 0.71295}, "CVE-2011-3940": {"epss_score": 0.01029, "epss_percentile": 0.76828}, "CVE-2011-3941": {"epss_score": 0.00627, "epss_percentile": 0.69626}, "CVE-2011-3944": {"epss_score": 0.00662, "epss_percentile": 0.70589}, "CVE-2011-3945": {"epss_score": 0.02352, "epss_percentile": 0.84474}, "CVE-2011-3946": {"epss_score": 0.00586, "epss_percentile": 0.6845}, "CVE-2011-3947": {"epss_score": 0.03024, "epss_percentile": 0.86234}, "CVE-2011-3949": {"epss_score": 0.00586, "epss_percentile": 0.6845}, "CVE-2011-3950": {"epss_score": 0.00586, "epss_percentile": 0.6845}, "CVE-2011-3951": {"epss_score": 0.02352, "epss_percentile": 0.84474}, "CVE-2011-3952": {"epss_score": 0.00957, "epss_percentile": 0.75937}, "CVE-2011-3953": {"epss_score": 0.00195, "epss_percentile": 0.41677}, "CVE-2011-3954": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-3955": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2011-3956": {"epss_score": 0.00104, "epss_percentile": 0.29193}, "CVE-2011-3957": {"epss_score": 0.02856, "epss_percentile": 0.85841}, "CVE-2011-3958": {"epss_score": 0.02292, "epss_percentile": 0.84286}, "CVE-2011-3959": {"epss_score": 0.03156, "epss_percentile": 0.86515}, "CVE-2011-3960": {"epss_score": 0.01525, "epss_percentile": 0.80858}, "CVE-2011-3961": {"epss_score": 0.03949, "epss_percentile": 0.87998}, "CVE-2011-3962": {"epss_score": 0.01862, "epss_percentile": 0.82594}, "CVE-2011-3963": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-3964": {"epss_score": 0.00242, "epss_percentile": 0.47388}, "CVE-2011-3965": {"epss_score": 0.00249, "epss_percentile": 0.48002}, "CVE-2011-3966": {"epss_score": 0.07118, "epss_percentile": 0.91261}, "CVE-2011-3967": {"epss_score": 0.00288, "epss_percentile": 0.51885}, "CVE-2011-3968": {"epss_score": 0.01891, "epss_percentile": 0.82728}, "CVE-2011-3969": {"epss_score": 0.01964, "epss_percentile": 0.83075}, "CVE-2011-3970": {"epss_score": 0.00489, "epss_percentile": 0.64895}, "CVE-2011-3971": {"epss_score": 0.01964, "epss_percentile": 0.83075}, "CVE-2011-3972": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-3973": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2011-3974": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2011-3975": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2011-3976": {"epss_score": 0.64359, "epss_percentile": 0.98375}, "CVE-2011-3977": {"epss_score": 0.00047, "epss_percentile": 0.14694}, "CVE-2011-3978": {"epss_score": 0.0035, "epss_percentile": 0.56922}, "CVE-2011-3979": {"epss_score": 0.11261, "epss_percentile": 0.93282}, "CVE-2011-3980": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2011-3981": {"epss_score": 0.03066, "epss_percentile": 0.86337}, "CVE-2011-3982": {"epss_score": 0.00069, "epss_percentile": 0.21483}, "CVE-2011-3983": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2011-3984": {"epss_score": 0.00492, "epss_percentile": 0.65004}, "CVE-2011-3985": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2011-3986": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2011-3987": {"epss_score": 0.00077, "epss_percentile": 0.23542}, "CVE-2011-3988": {"epss_score": 0.01208, "epss_percentile": 0.78532}, "CVE-2011-3989": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2011-3990": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2011-3991": {"epss_score": 0.00859, "epss_percentile": 0.74518}, "CVE-2011-3992": {"epss_score": 0.01256, "epss_percentile": 0.78936}, "CVE-2011-3993": {"epss_score": 0.00335, "epss_percentile": 0.55806}, "CVE-2011-3994": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2011-3995": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2011-3996": {"epss_score": 0.0067, "epss_percentile": 0.70786}, "CVE-2011-3997": {"epss_score": 0.00311, "epss_percentile": 0.53931}, "CVE-2011-3998": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2011-3999": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2011-4000": {"epss_score": 0.05803, "epss_percentile": 0.9022}, "CVE-2011-4001": {"epss_score": 0.00139, "epss_percentile": 0.34629}, "CVE-2011-4002": {"epss_score": 0.03463, "epss_percentile": 0.87186}, "CVE-2011-4004": {"epss_score": 0.02762, "epss_percentile": 0.85605}, "CVE-2011-4005": {"epss_score": 0.00227, "epss_percentile": 0.45382}, "CVE-2011-4006": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-4007": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-4012": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2011-4014": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2011-4015": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2011-4016": {"epss_score": 0.00503, "epss_percentile": 0.65468}, "CVE-2011-4019": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-4022": {"epss_score": 0.00661, "epss_percentile": 0.70565}, "CVE-2011-4023": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-4024": {"epss_score": 0.12693, "epss_percentile": 0.93751}, "CVE-2011-4026": {"epss_score": 0.00356, "epss_percentile": 0.57331}, "CVE-2011-4028": {"epss_score": 0.00119, "epss_percentile": 0.31593}, "CVE-2011-4029": {"epss_score": 0.00572, "epss_percentile": 0.6801}, "CVE-2011-4030": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2011-4031": {"epss_score": 0.02791, "epss_percentile": 0.85668}, "CVE-2011-4033": {"epss_score": 0.0056, "epss_percentile": 0.67643}, "CVE-2011-4034": {"epss_score": 0.55828, "epss_percentile": 0.97998}, "CVE-2011-4035": {"epss_score": 0.02092, "epss_percentile": 0.83572}, "CVE-2011-4036": {"epss_score": 0.00506, "epss_percentile": 0.65619}, "CVE-2011-4037": {"epss_score": 0.08415, "epss_percentile": 0.92038}, "CVE-2011-4038": {"epss_score": 0.02033, "epss_percentile": 0.83341}, "CVE-2011-4039": {"epss_score": 0.0332, "epss_percentile": 0.86908}, "CVE-2011-4040": {"epss_score": 0.76489, "epss_percentile": 0.98893}, "CVE-2011-4041": {"epss_score": 0.25326, "epss_percentile": 0.96013}, "CVE-2011-4042": {"epss_score": 0.23673, "epss_percentile": 0.95801}, "CVE-2011-4043": {"epss_score": 0.25259, "epss_percentile": 0.96005}, "CVE-2011-4044": {"epss_score": 0.61857, "epss_percentile": 0.98264}, "CVE-2011-4045": {"epss_score": 0.08879, "epss_percentile": 0.92298}, "CVE-2011-4046": {"epss_score": 0.00294, "epss_percentile": 0.52433}, "CVE-2011-4047": {"epss_score": 0.00638, "epss_percentile": 0.69918}, "CVE-2011-4048": {"epss_score": 0.00598, "epss_percentile": 0.68761}, "CVE-2011-4050": {"epss_score": 0.75943, "epss_percentile": 0.9887}, "CVE-2011-4051": {"epss_score": 0.7479, "epss_percentile": 0.98817}, "CVE-2011-4052": {"epss_score": 0.06917, "epss_percentile": 0.91115}, "CVE-2011-4053": {"epss_score": 0.00399, "epss_percentile": 0.60144}, "CVE-2011-4054": {"epss_score": 0.00894, "epss_percentile": 0.75089}, "CVE-2011-4055": {"epss_score": 0.0703, "epss_percentile": 0.91197}, "CVE-2011-4056": {"epss_score": 0.00317, "epss_percentile": 0.54386}, "CVE-2011-4057": {"epss_score": 0.05768, "epss_percentile": 0.9019}, "CVE-2011-4060": {"epss_score": 0.00056, "epss_percentile": 0.1767}, "CVE-2011-4061": {"epss_score": 0.00132, "epss_percentile": 0.33618}, "CVE-2011-4062": {"epss_score": 0.00779, "epss_percentile": 0.73157}, "CVE-2011-4063": {"epss_score": 0.06702, "epss_percentile": 0.90956}, "CVE-2011-4064": {"epss_score": 0.00523, "epss_percentile": 0.66292}, "CVE-2011-4066": {"epss_score": 0.00835, "epss_percentile": 0.74122}, "CVE-2011-4068": {"epss_score": 0.0048, "epss_percentile": 0.64452}, "CVE-2011-4069": {"epss_score": 0.00661, "epss_percentile": 0.70569}, "CVE-2011-4073": {"epss_score": 0.01149, "epss_percentile": 0.78021}, "CVE-2011-4074": {"epss_score": 0.1297, "epss_percentile": 0.93832}, "CVE-2011-4075": {"epss_score": 0.83233, "epss_percentile": 0.99239}, "CVE-2011-4076": {"epss_score": 0.00408, "epss_percentile": 0.6069}, "CVE-2011-4077": {"epss_score": 0.00309, "epss_percentile": 0.53659}, "CVE-2011-4078": {"epss_score": 0.00859, "epss_percentile": 0.74522}, "CVE-2011-4079": {"epss_score": 0.06754, "epss_percentile": 0.91005}, "CVE-2011-4080": {"epss_score": 0.00074, "epss_percentile": 0.22803}, "CVE-2011-4081": {"epss_score": 0.00058, "epss_percentile": 0.18524}, "CVE-2011-4082": {"epss_score": 0.00922, "epss_percentile": 0.75489}, "CVE-2011-4083": {"epss_score": 0.00205, "epss_percentile": 0.42673}, "CVE-2011-4085": {"epss_score": 0.00258, "epss_percentile": 0.49008}, "CVE-2011-4086": {"epss_score": 0.00064, "epss_percentile": 0.20384}, "CVE-2011-4087": {"epss_score": 0.00964, "epss_percentile": 0.76037}, "CVE-2011-4088": {"epss_score": 0.00745, "epss_percentile": 0.72522}, "CVE-2011-4089": {"epss_score": 0.00152, "epss_percentile": 0.36375}, "CVE-2011-4090": {"epss_score": 0.01674, "epss_percentile": 0.81693}, "CVE-2011-4091": {"epss_score": 0.00637, "epss_percentile": 0.69891}, "CVE-2011-4092": {"epss_score": 0.00147, "epss_percentile": 0.35781}, "CVE-2011-4093": {"epss_score": 0.0043, "epss_percentile": 0.6202}, "CVE-2011-4094": {"epss_score": 0.0741, "epss_percentile": 0.91458}, "CVE-2011-4095": {"epss_score": 0.00828, "epss_percentile": 0.74002}, "CVE-2011-4096": {"epss_score": 0.6249, "epss_percentile": 0.98295}, "CVE-2011-4097": {"epss_score": 0.00077, "epss_percentile": 0.23302}, "CVE-2011-4098": {"epss_score": 0.00064, "epss_percentile": 0.20305}, "CVE-2011-4099": {"epss_score": 0.00055, "epss_percentile": 0.17478}, "CVE-2011-4100": {"epss_score": 0.00954, "epss_percentile": 0.75897}, "CVE-2011-4101": {"epss_score": 0.00954, "epss_percentile": 0.75897}, "CVE-2011-4102": {"epss_score": 0.01662, "epss_percentile": 0.81637}, "CVE-2011-4103": {"epss_score": 0.00821, "epss_percentile": 0.73898}, "CVE-2011-4104": {"epss_score": 0.00821, "epss_percentile": 0.73898}, "CVE-2011-4105": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2011-4106": {"epss_score": 0.26332, "epss_percentile": 0.96138}, "CVE-2011-4107": {"epss_score": 0.12596, "epss_percentile": 0.93723}, "CVE-2011-4108": {"epss_score": 0.0125, "epss_percentile": 0.78879}, "CVE-2011-4109": {"epss_score": 0.03595, "epss_percentile": 0.87404}, "CVE-2011-4110": {"epss_score": 0.00138, "epss_percentile": 0.34343}, "CVE-2011-4111": {"epss_score": 0.00795, "epss_percentile": 0.73475}, "CVE-2011-4112": {"epss_score": 0.00062, "epss_percentile": 0.19713}, "CVE-2011-4113": {"epss_score": 0.01045, "epss_percentile": 0.77016}, "CVE-2011-4114": {"epss_score": 0.00082, "epss_percentile": 0.2441}, "CVE-2011-4115": {"epss_score": 0.00391, "epss_percentile": 0.59573}, "CVE-2011-4116": {"epss_score": 0.002, "epss_percentile": 0.4221}, "CVE-2011-4117": {"epss_score": 0.00379, "epss_percentile": 0.58898}, "CVE-2011-4118": {"epss_score": 0.01018, "epss_percentile": 0.76719}, "CVE-2011-4119": {"epss_score": 0.00528, "epss_percentile": 0.66577}, "CVE-2011-4120": {"epss_score": 0.01475, "epss_percentile": 0.80527}, "CVE-2011-4121": {"epss_score": 0.001, "epss_percentile": 0.28471}, "CVE-2011-4122": {"epss_score": 0.00557, "epss_percentile": 0.67555}, "CVE-2011-4124": {"epss_score": 0.00627, "epss_percentile": 0.69635}, "CVE-2011-4125": {"epss_score": 0.00736, "epss_percentile": 0.72308}, "CVE-2011-4126": {"epss_score": 0.00486, "epss_percentile": 0.64749}, "CVE-2011-4127": {"epss_score": 0.00044, "epss_percentile": 0.13391}, "CVE-2011-4128": {"epss_score": 0.01319, "epss_percentile": 0.79431}, "CVE-2011-4129": {"epss_score": 0.00379, "epss_percentile": 0.5889}, "CVE-2011-4130": {"epss_score": 0.01403, "epss_percentile": 0.80033}, "CVE-2011-4131": {"epss_score": 0.00355, "epss_percentile": 0.57262}, "CVE-2011-4132": {"epss_score": 0.00125, "epss_percentile": 0.32509}, "CVE-2011-4133": {"epss_score": 0.00126, "epss_percentile": 0.32707}, "CVE-2011-4134": {"epss_score": 0.09239, "epss_percentile": 0.92463}, "CVE-2011-4135": {"epss_score": 0.62213, "epss_percentile": 0.98285}, "CVE-2011-4136": {"epss_score": 0.01022, "epss_percentile": 0.76756}, "CVE-2011-4137": {"epss_score": 0.01736, "epss_percentile": 0.82012}, "CVE-2011-4138": {"epss_score": 0.00755, "epss_percentile": 0.72724}, "CVE-2011-4139": {"epss_score": 0.00567, "epss_percentile": 0.67862}, "CVE-2011-4140": {"epss_score": 0.004, "epss_percentile": 0.60167}, "CVE-2011-4141": {"epss_score": 0.00449, "epss_percentile": 0.63045}, "CVE-2011-4142": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2011-4143": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4144": {"epss_score": 0.00041, "epss_percentile": 0.12269}, "CVE-2011-4151": {"epss_score": 0.05377, "epss_percentile": 0.89804}, "CVE-2011-4153": {"epss_score": 0.06479, "epss_percentile": 0.90784}, "CVE-2011-4155": {"epss_score": 0.01756, "epss_percentile": 0.82131}, "CVE-2011-4156": {"epss_score": 0.01756, "epss_percentile": 0.82131}, "CVE-2011-4157": {"epss_score": 0.27712, "epss_percentile": 0.96275}, "CVE-2011-4158": {"epss_score": 0.00237, "epss_percentile": 0.46723}, "CVE-2011-4159": {"epss_score": 0.00045, "epss_percentile": 0.1404}, "CVE-2011-4160": {"epss_score": 0.00051, "epss_percentile": 0.16032}, "CVE-2011-4161": {"epss_score": 0.15988, "epss_percentile": 0.94549}, "CVE-2011-4162": {"epss_score": 0.16775, "epss_percentile": 0.9473}, "CVE-2011-4163": {"epss_score": 0.25556, "epss_percentile": 0.96042}, "CVE-2011-4164": {"epss_score": 0.25556, "epss_percentile": 0.96042}, "CVE-2011-4165": {"epss_score": 0.25556, "epss_percentile": 0.96042}, "CVE-2011-4166": {"epss_score": 0.66269, "epss_percentile": 0.98458}, "CVE-2011-4167": {"epss_score": 0.11091, "epss_percentile": 0.93217}, "CVE-2011-4168": {"epss_score": 0.01608, "epss_percentile": 0.81312}, "CVE-2011-4169": {"epss_score": 0.01067, "epss_percentile": 0.77229}, "CVE-2011-4170": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-4171": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2011-4172": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-4173": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2011-4181": {"epss_score": 0.00222, "epss_percentile": 0.44743}, "CVE-2011-4182": {"epss_score": 0.00544, "epss_percentile": 0.6714}, "CVE-2011-4183": {"epss_score": 0.00354, "epss_percentile": 0.57233}, "CVE-2011-4185": {"epss_score": 0.16929, "epss_percentile": 0.94748}, "CVE-2011-4186": {"epss_score": 0.16682, "epss_percentile": 0.94713}, "CVE-2011-4187": {"epss_score": 0.24012, "epss_percentile": 0.95844}, "CVE-2011-4188": {"epss_score": 0.05136, "epss_percentile": 0.89535}, "CVE-2011-4189": {"epss_score": 0.3858, "epss_percentile": 0.97107}, "CVE-2011-4190": {"epss_score": 0.00218, "epss_percentile": 0.44439}, "CVE-2011-4191": {"epss_score": 0.42447, "epss_percentile": 0.97332}, "CVE-2011-4192": {"epss_score": 0.00499, "epss_percentile": 0.65287}, "CVE-2011-4193": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-4194": {"epss_score": 0.08111, "epss_percentile": 0.91884}, "CVE-2011-4195": {"epss_score": 0.01317, "epss_percentile": 0.79418}, "CVE-2011-4197": {"epss_score": 0.00902, "epss_percentile": 0.75186}, "CVE-2011-4201": {"epss_score": 0.01017, "epss_percentile": 0.76687}, "CVE-2011-4202": {"epss_score": 0.00035, "epss_percentile": 0.09971}, "CVE-2011-4203": {"epss_score": 0.00245, "epss_percentile": 0.47633}, "CVE-2011-4211": {"epss_score": 0.00025, "epss_percentile": 0.0631}, "CVE-2011-4212": {"epss_score": 0.00025, "epss_percentile": 0.0626}, "CVE-2011-4213": {"epss_score": 0.00037, "epss_percentile": 0.10706}, "CVE-2011-4214": {"epss_score": 0.03433, "epss_percentile": 0.87126}, "CVE-2011-4215": {"epss_score": 0.01374, "epss_percentile": 0.79823}, "CVE-2011-4216": {"epss_score": 0.02152, "epss_percentile": 0.83789}, "CVE-2011-4217": {"epss_score": 0.02655, "epss_percentile": 0.85354}, "CVE-2011-4218": {"epss_score": 0.02152, "epss_percentile": 0.83789}, "CVE-2011-4219": {"epss_score": 0.02152, "epss_percentile": 0.83789}, "CVE-2011-4220": {"epss_score": 0.22137, "epss_percentile": 0.95599}, "CVE-2011-4221": {"epss_score": 0.13641, "epss_percentile": 0.9402}, "CVE-2011-4222": {"epss_score": 0.13641, "epss_percentile": 0.9402}, "CVE-2011-4223": {"epss_score": 0.02152, "epss_percentile": 0.83789}, "CVE-2011-4231": {"epss_score": 0.00303, "epss_percentile": 0.53204}, "CVE-2011-4232": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4237": {"epss_score": 0.00276, "epss_percentile": 0.50754}, "CVE-2011-4244": {"epss_score": 0.0431, "epss_percentile": 0.8853}, "CVE-2011-4245": {"epss_score": 0.04054, "epss_percentile": 0.88181}, "CVE-2011-4246": {"epss_score": 0.04054, "epss_percentile": 0.88181}, "CVE-2011-4247": {"epss_score": 0.02131, "epss_percentile": 0.83714}, "CVE-2011-4248": {"epss_score": 0.02131, "epss_percentile": 0.83714}, "CVE-2011-4249": {"epss_score": 0.03026, "epss_percentile": 0.86241}, "CVE-2011-4250": {"epss_score": 0.04054, "epss_percentile": 0.88181}, "CVE-2011-4251": {"epss_score": 0.02131, "epss_percentile": 0.83714}, "CVE-2011-4252": {"epss_score": 0.02131, "epss_percentile": 0.83714}, "CVE-2011-4253": {"epss_score": 0.04054, "epss_percentile": 0.88181}, "CVE-2011-4254": {"epss_score": 0.04969, "epss_percentile": 0.89348}, "CVE-2011-4255": {"epss_score": 0.04054, "epss_percentile": 0.88181}, "CVE-2011-4256": {"epss_score": 0.04969, "epss_percentile": 0.89348}, "CVE-2011-4257": {"epss_score": 0.02131, "epss_percentile": 0.83714}, "CVE-2011-4258": {"epss_score": 0.02131, "epss_percentile": 0.83714}, "CVE-2011-4259": {"epss_score": 0.01725, "epss_percentile": 0.81958}, "CVE-2011-4260": {"epss_score": 0.02131, "epss_percentile": 0.83714}, "CVE-2011-4261": {"epss_score": 0.0194, "epss_percentile": 0.8298}, "CVE-2011-4262": {"epss_score": 0.01337, "epss_percentile": 0.79558}, "CVE-2011-4263": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-4264": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-4265": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-4266": {"epss_score": 0.00346, "epss_percentile": 0.56644}, "CVE-2011-4273": {"epss_score": 0.00359, "epss_percentile": 0.57599}, "CVE-2011-4274": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2011-4275": {"epss_score": 0.00675, "epss_percentile": 0.70906}, "CVE-2011-4276": {"epss_score": 0.00163, "epss_percentile": 0.37863}, "CVE-2011-4277": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2011-4278": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2011-4279": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-4280": {"epss_score": 0.02789, "epss_percentile": 0.85664}, "CVE-2011-4281": {"epss_score": 0.00126, "epss_percentile": 0.32707}, "CVE-2011-4282": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2011-4283": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-4284": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2011-4285": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2011-4286": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2011-4287": {"epss_score": 0.00485, "epss_percentile": 0.64732}, "CVE-2011-4288": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2011-4289": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2011-4290": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2011-4291": {"epss_score": 0.00455, "epss_percentile": 0.63299}, "CVE-2011-4292": {"epss_score": 0.00565, "epss_percentile": 0.67779}, "CVE-2011-4293": {"epss_score": 0.00195, "epss_percentile": 0.41617}, "CVE-2011-4294": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2011-4295": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2011-4296": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2011-4297": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2011-4298": {"epss_score": 0.00126, "epss_percentile": 0.32707}, "CVE-2011-4299": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2011-4300": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2011-4301": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2011-4302": {"epss_score": 0.00133, "epss_percentile": 0.33622}, "CVE-2011-4303": {"epss_score": 0.00178, "epss_percentile": 0.39669}, "CVE-2011-4304": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2011-4305": {"epss_score": 0.00455, "epss_percentile": 0.63299}, "CVE-2011-4306": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2011-4307": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2011-4308": {"epss_score": 0.00273, "epss_percentile": 0.5048}, "CVE-2011-4309": {"epss_score": 0.00207, "epss_percentile": 0.43199}, "CVE-2011-4310": {"epss_score": 0.00233, "epss_percentile": 0.46048}, "CVE-2011-4311": {"epss_score": 0.00178, "epss_percentile": 0.39669}, "CVE-2011-4312": {"epss_score": 0.00557, "epss_percentile": 0.67549}, "CVE-2011-4313": {"epss_score": 0.15011, "epss_percentile": 0.94342}, "CVE-2011-4314": {"epss_score": 0.01136, "epss_percentile": 0.77916}, "CVE-2011-4315": {"epss_score": 0.02811, "epss_percentile": 0.85721}, "CVE-2011-4316": {"epss_score": 0.00061, "epss_percentile": 0.1954}, "CVE-2011-4317": {"epss_score": 0.84292, "epss_percentile": 0.99283}, "CVE-2011-4318": {"epss_score": 0.0038, "epss_percentile": 0.58948}, "CVE-2011-4319": {"epss_score": 0.00607, "epss_percentile": 0.69056}, "CVE-2011-4320": {"epss_score": 0.01178, "epss_percentile": 0.78288}, "CVE-2011-4321": {"epss_score": 0.00233, "epss_percentile": 0.45985}, "CVE-2011-4322": {"epss_score": 0.00254, "epss_percentile": 0.48559}, "CVE-2011-4324": {"epss_score": 0.00158, "epss_percentile": 0.37161}, "CVE-2011-4325": {"epss_score": 0.00204, "epss_percentile": 0.42664}, "CVE-2011-4326": {"epss_score": 0.01502, "epss_percentile": 0.80722}, "CVE-2011-4327": {"epss_score": 0.00064, "epss_percentile": 0.20379}, "CVE-2011-4328": {"epss_score": 0.00442, "epss_percentile": 0.62743}, "CVE-2011-4329": {"epss_score": 0.00466, "epss_percentile": 0.63798}, "CVE-2011-4330": {"epss_score": 0.00218, "epss_percentile": 0.44435}, "CVE-2011-4332": {"epss_score": 0.00022, "epss_percentile": 0.05177}, "CVE-2011-4333": {"epss_score": 0.0033, "epss_percentile": 0.55457}, "CVE-2011-4334": {"epss_score": 0.03848, "epss_percentile": 0.87843}, "CVE-2011-4335": {"epss_score": 0.00366, "epss_percentile": 0.5808}, "CVE-2011-4336": {"epss_score": 0.00927, "epss_percentile": 0.75561}, "CVE-2011-4337": {"epss_score": 0.01761, "epss_percentile": 0.82152}, "CVE-2011-4338": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2011-4339": {"epss_score": 0.00061, "epss_percentile": 0.19505}, "CVE-2011-4340": {"epss_score": 0.01539, "epss_percentile": 0.80939}, "CVE-2011-4341": {"epss_score": 0.02323, "epss_percentile": 0.84375}, "CVE-2011-4342": {"epss_score": 0.03506, "epss_percentile": 0.87258}, "CVE-2011-4343": {"epss_score": 0.00864, "epss_percentile": 0.74596}, "CVE-2011-4344": {"epss_score": 0.00383, "epss_percentile": 0.59109}, "CVE-2011-4345": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2011-4346": {"epss_score": 0.00278, "epss_percentile": 0.50891}, "CVE-2011-4347": {"epss_score": 0.00049, "epss_percentile": 0.15588}, "CVE-2011-4348": {"epss_score": 0.00481, "epss_percentile": 0.64503}, "CVE-2011-4349": {"epss_score": 0.00109, "epss_percentile": 0.30002}, "CVE-2011-4350": {"epss_score": 0.25878, "epss_percentile": 0.96089}, "CVE-2011-4351": {"epss_score": 0.02814, "epss_percentile": 0.85728}, "CVE-2011-4352": {"epss_score": 0.04525, "epss_percentile": 0.88805}, "CVE-2011-4353": {"epss_score": 0.00723, "epss_percentile": 0.7201}, "CVE-2011-4354": {"epss_score": 0.00226, "epss_percentile": 0.45252}, "CVE-2011-4355": {"epss_score": 0.00163, "epss_percentile": 0.37832}, "CVE-2011-4356": {"epss_score": 0.00047, "epss_percentile": 0.14694}, "CVE-2011-4357": {"epss_score": 0.02176, "epss_percentile": 0.83886}, "CVE-2011-4358": {"epss_score": 0.00222, "epss_percentile": 0.44767}, "CVE-2011-4360": {"epss_score": 0.00607, "epss_percentile": 0.69055}, "CVE-2011-4361": {"epss_score": 0.00176, "epss_percentile": 0.39406}, "CVE-2011-4362": {"epss_score": 0.03641, "epss_percentile": 0.87491}, "CVE-2011-4363": {"epss_score": 0.00047, "epss_percentile": 0.14887}, "CVE-2011-4364": {"epss_score": 0.0294, "epss_percentile": 0.86032}, "CVE-2011-4367": {"epss_score": 0.8592, "epss_percentile": 0.99356}, "CVE-2011-4368": {"epss_score": 0.00667, "epss_percentile": 0.70711}, "CVE-2011-4369": {"epss_score": 0.18727, "epss_percentile": 0.9506}, "CVE-2011-4370": {"epss_score": 0.02932, "epss_percentile": 0.86018}, "CVE-2011-4371": {"epss_score": 0.02932, "epss_percentile": 0.86018}, "CVE-2011-4372": {"epss_score": 0.07044, "epss_percentile": 0.91208}, "CVE-2011-4373": {"epss_score": 0.08394, "epss_percentile": 0.92028}, "CVE-2011-4374": {"epss_score": 0.05566, "epss_percentile": 0.90002}, "CVE-2011-4403": {"epss_score": 0.00393, "epss_percentile": 0.59725}, "CVE-2011-4404": {"epss_score": 0.83606, "epss_percentile": 0.99254}, "CVE-2011-4405": {"epss_score": 0.01967, "epss_percentile": 0.83086}, "CVE-2011-4406": {"epss_score": 0.00053, "epss_percentile": 0.17014}, "CVE-2011-4407": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2011-4408": {"epss_score": 0.00414, "epss_percentile": 0.61096}, "CVE-2011-4409": {"epss_score": 0.00653, "epss_percentile": 0.70327}, "CVE-2011-4415": {"epss_score": 0.00528, "epss_percentile": 0.66567}, "CVE-2011-4431": {"epss_score": 0.02417, "epss_percentile": 0.84694}, "CVE-2011-4432": {"epss_score": 0.00232, "epss_percentile": 0.45926}, "CVE-2011-4434": {"epss_score": 0.00324, "epss_percentile": 0.54953}, "CVE-2011-4435": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2011-4436": {"epss_score": 0.00501, "epss_percentile": 0.65366}, "CVE-2011-4447": {"epss_score": 0.00271, "epss_percentile": 0.50278}, "CVE-2011-4448": {"epss_score": 0.00205, "epss_percentile": 0.42744}, "CVE-2011-4449": {"epss_score": 0.04522, "epss_percentile": 0.88802}, "CVE-2011-4450": {"epss_score": 0.0859, "epss_percentile": 0.92138}, "CVE-2011-4451": {"epss_score": 0.63617, "epss_percentile": 0.98341}, "CVE-2011-4452": {"epss_score": 0.00138, "epss_percentile": 0.34374}, "CVE-2011-4453": {"epss_score": 0.84053, "epss_percentile": 0.99272}, "CVE-2011-4454": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2011-4455": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2011-4457": {"epss_score": 0.00221, "epss_percentile": 0.44677}, "CVE-2011-4458": {"epss_score": 0.01517, "epss_percentile": 0.80803}, "CVE-2011-4459": {"epss_score": 0.00259, "epss_percentile": 0.49084}, "CVE-2011-4460": {"epss_score": 0.00515, "epss_percentile": 0.66008}, "CVE-2011-4461": {"epss_score": 0.03003, "epss_percentile": 0.86175}, "CVE-2011-4462": {"epss_score": 0.00893, "epss_percentile": 0.75073}, "CVE-2011-4465": {"epss_score": 0.00229, "epss_percentile": 0.45559}, "CVE-2011-4486": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2011-4487": {"epss_score": 0.00342, "epss_percentile": 0.56371}, "CVE-2011-4496": {"epss_score": 0.64039, "epss_percentile": 0.98361}, "CVE-2011-4497": {"epss_score": 0.00165, "epss_percentile": 0.38082}, "CVE-2011-4498": {"epss_score": 0.00081, "epss_percentile": 0.24363}, "CVE-2011-4499": {"epss_score": 0.00474, "epss_percentile": 0.64149}, "CVE-2011-4500": {"epss_score": 0.00474, "epss_percentile": 0.64149}, "CVE-2011-4501": {"epss_score": 0.04531, "epss_percentile": 0.88812}, "CVE-2011-4502": {"epss_score": 0.04652, "epss_percentile": 0.88965}, "CVE-2011-4503": {"epss_score": 0.00586, "epss_percentile": 0.68446}, "CVE-2011-4504": {"epss_score": 0.00643, "epss_percentile": 0.7005}, "CVE-2011-4505": {"epss_score": 0.00509, "epss_percentile": 0.65733}, "CVE-2011-4506": {"epss_score": 0.00509, "epss_percentile": 0.65733}, "CVE-2011-4507": {"epss_score": 0.00126, "epss_percentile": 0.3264}, "CVE-2011-4508": {"epss_score": 0.00406, "epss_percentile": 0.6054}, "CVE-2011-4509": {"epss_score": 0.0116, "epss_percentile": 0.78136}, "CVE-2011-4510": {"epss_score": 0.00385, "epss_percentile": 0.59195}, "CVE-2011-4511": {"epss_score": 0.00385, "epss_percentile": 0.59195}, "CVE-2011-4512": {"epss_score": 0.00385, "epss_percentile": 0.59195}, "CVE-2011-4513": {"epss_score": 0.05008, "epss_percentile": 0.89387}, "CVE-2011-4514": {"epss_score": 0.01006, "epss_percentile": 0.76549}, "CVE-2011-4515": {"epss_score": 0.00059, "epss_percentile": 0.18883}, "CVE-2011-4516": {"epss_score": 0.47823, "epss_percentile": 0.97603}, "CVE-2011-4517": {"epss_score": 0.4213, "epss_percentile": 0.97314}, "CVE-2011-4518": {"epss_score": 0.06987, "epss_percentile": 0.91164}, "CVE-2011-4519": {"epss_score": 0.08544, "epss_percentile": 0.92114}, "CVE-2011-4520": {"epss_score": 0.08544, "epss_percentile": 0.92114}, "CVE-2011-4521": {"epss_score": 0.00163, "epss_percentile": 0.37825}, "CVE-2011-4522": {"epss_score": 0.00199, "epss_percentile": 0.42141}, "CVE-2011-4523": {"epss_score": 0.00199, "epss_percentile": 0.42141}, "CVE-2011-4524": {"epss_score": 0.01952, "epss_percentile": 0.83023}, "CVE-2011-4525": {"epss_score": 0.00344, "epss_percentile": 0.56522}, "CVE-2011-4526": {"epss_score": 0.02039, "epss_percentile": 0.83362}, "CVE-2011-4528": {"epss_score": 0.02914, "epss_percentile": 0.85978}, "CVE-2011-4529": {"epss_score": 0.19194, "epss_percentile": 0.95147}, "CVE-2011-4530": {"epss_score": 0.14944, "epss_percentile": 0.9433}, "CVE-2011-4531": {"epss_score": 0.17491, "epss_percentile": 0.94857}, "CVE-2011-4532": {"epss_score": 0.04406, "epss_percentile": 0.88651}, "CVE-2011-4533": {"epss_score": 0.01879, "epss_percentile": 0.82673}, "CVE-2011-4534": {"epss_score": 0.01425, "epss_percentile": 0.80197}, "CVE-2011-4535": {"epss_score": 0.74359, "epss_percentile": 0.98796}, "CVE-2011-4536": {"epss_score": 0.3104, "epss_percentile": 0.96584}, "CVE-2011-4537": {"epss_score": 0.02355, "epss_percentile": 0.8448}, "CVE-2011-4538": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2011-4539": {"epss_score": 0.32265, "epss_percentile": 0.96684}, "CVE-2011-4540": {"epss_score": 0.0362, "epss_percentile": 0.87441}, "CVE-2011-4541": {"epss_score": 0.01361, "epss_percentile": 0.79755}, "CVE-2011-4542": {"epss_score": 0.7386, "epss_percentile": 0.98774}, "CVE-2011-4543": {"epss_score": 0.00155, "epss_percentile": 0.36771}, "CVE-2011-4544": {"epss_score": 0.00484, "epss_percentile": 0.64661}, "CVE-2011-4545": {"epss_score": 0.01564, "epss_percentile": 0.81061}, "CVE-2011-4547": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2011-4548": {"epss_score": 0.00362, "epss_percentile": 0.57783}, "CVE-2011-4551": {"epss_score": 0.03757, "epss_percentile": 0.87683}, "CVE-2011-4552": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-4553": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2011-4554": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2011-4555": {"epss_score": 0.00403, "epss_percentile": 0.60368}, "CVE-2011-4558": {"epss_score": 0.03396, "epss_percentile": 0.87058}, "CVE-2011-4559": {"epss_score": 0.00572, "epss_percentile": 0.68034}, "CVE-2011-4560": {"epss_score": 0.00211, "epss_percentile": 0.43615}, "CVE-2011-4561": {"epss_score": 0.00265, "epss_percentile": 0.49763}, "CVE-2011-4562": {"epss_score": 0.004, "epss_percentile": 0.60195}, "CVE-2011-4563": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2011-4564": {"epss_score": 0.00458, "epss_percentile": 0.63434}, "CVE-2011-4565": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2011-4566": {"epss_score": 0.43603, "epss_percentile": 0.97393}, "CVE-2011-4567": {"epss_score": 0.00202, "epss_percentile": 0.42439}, "CVE-2011-4568": {"epss_score": 0.00192, "epss_percentile": 0.41376}, "CVE-2011-4569": {"epss_score": 0.00125, "epss_percentile": 0.32493}, "CVE-2011-4570": {"epss_score": 0.00163, "epss_percentile": 0.37832}, "CVE-2011-4571": {"epss_score": 0.00125, "epss_percentile": 0.32493}, "CVE-2011-4572": {"epss_score": 0.00274, "epss_percentile": 0.5049}, "CVE-2011-4573": {"epss_score": 0.00129, "epss_percentile": 0.33215}, "CVE-2011-4574": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2011-4575": {"epss_score": 0.01272, "epss_percentile": 0.79075}, "CVE-2011-4576": {"epss_score": 0.00717, "epss_percentile": 0.71872}, "CVE-2011-4577": {"epss_score": 0.01301, "epss_percentile": 0.79293}, "CVE-2011-4578": {"epss_score": 0.00078, "epss_percentile": 0.23604}, "CVE-2011-4579": {"epss_score": 0.02943, "epss_percentile": 0.86036}, "CVE-2011-4580": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-4581": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2011-4582": {"epss_score": 0.00161, "epss_percentile": 0.37547}, "CVE-2011-4583": {"epss_score": 0.00407, "epss_percentile": 0.60586}, "CVE-2011-4584": {"epss_score": 0.00239, "epss_percentile": 0.46887}, "CVE-2011-4585": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2011-4586": {"epss_score": 0.00377, "epss_percentile": 0.58711}, "CVE-2011-4587": {"epss_score": 0.00666, "epss_percentile": 0.70694}, "CVE-2011-4588": {"epss_score": 0.00246, "epss_percentile": 0.4774}, "CVE-2011-4589": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2011-4590": {"epss_score": 0.00139, "epss_percentile": 0.34632}, "CVE-2011-4591": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2011-4592": {"epss_score": 0.00162, "epss_percentile": 0.37644}, "CVE-2011-4593": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2011-4594": {"epss_score": 0.00171, "epss_percentile": 0.3879}, "CVE-2011-4595": {"epss_score": 0.00284, "epss_percentile": 0.51498}, "CVE-2011-4596": {"epss_score": 0.00541, "epss_percentile": 0.67027}, "CVE-2011-4597": {"epss_score": 0.00685, "epss_percentile": 0.71147}, "CVE-2011-4598": {"epss_score": 0.00634, "epss_percentile": 0.698}, "CVE-2011-4599": {"epss_score": 0.34161, "epss_percentile": 0.96828}, "CVE-2011-4600": {"epss_score": 0.00306, "epss_percentile": 0.53447}, "CVE-2011-4601": {"epss_score": 0.0379, "epss_percentile": 0.87729}, "CVE-2011-4602": {"epss_score": 0.01535, "epss_percentile": 0.8091}, "CVE-2011-4603": {"epss_score": 0.01165, "epss_percentile": 0.78176}, "CVE-2011-4604": {"epss_score": 0.00695, "epss_percentile": 0.71381}, "CVE-2011-4605": {"epss_score": 0.02416, "epss_percentile": 0.84689}, "CVE-2011-4606": {"epss_score": 0.00066, "epss_percentile": 0.20859}, "CVE-2011-4607": {"epss_score": 0.00056, "epss_percentile": 0.17784}, "CVE-2011-4608": {"epss_score": 0.00742, "epss_percentile": 0.72451}, "CVE-2011-4609": {"epss_score": 0.00727, "epss_percentile": 0.72088}, "CVE-2011-4610": {"epss_score": 0.01496, "epss_percentile": 0.80682}, "CVE-2011-4611": {"epss_score": 0.00048, "epss_percentile": 0.1498}, "CVE-2011-4612": {"epss_score": 0.00374, "epss_percentile": 0.5857}, "CVE-2011-4613": {"epss_score": 0.00081, "epss_percentile": 0.24281}, "CVE-2011-4614": {"epss_score": 0.04608, "epss_percentile": 0.88911}, "CVE-2011-4615": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2011-4616": {"epss_score": 0.0067, "epss_percentile": 0.70779}, "CVE-2011-4617": {"epss_score": 0.00038, "epss_percentile": 0.1111}, "CVE-2011-4618": {"epss_score": 0.04723, "epss_percentile": 0.89058}, "CVE-2011-4619": {"epss_score": 0.02835, "epss_percentile": 0.85788}, "CVE-2011-4620": {"epss_score": 0.40673, "epss_percentile": 0.97231}, "CVE-2011-4621": {"epss_score": 0.00064, "epss_percentile": 0.20269}, "CVE-2011-4622": {"epss_score": 0.0005, "epss_percentile": 0.15857}, "CVE-2011-4623": {"epss_score": 0.0009, "epss_percentile": 0.26086}, "CVE-2011-4624": {"epss_score": 0.05988, "epss_percentile": 0.90384}, "CVE-2011-4625": {"epss_score": 0.00274, "epss_percentile": 0.50485}, "CVE-2011-4626": {"epss_score": 0.00332, "epss_percentile": 0.55583}, "CVE-2011-4627": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2011-4628": {"epss_score": 0.0071, "epss_percentile": 0.71713}, "CVE-2011-4629": {"epss_score": 0.00195, "epss_percentile": 0.41641}, "CVE-2011-4630": {"epss_score": 0.00195, "epss_percentile": 0.41641}, "CVE-2011-4631": {"epss_score": 0.00195, "epss_percentile": 0.41641}, "CVE-2011-4632": {"epss_score": 0.00195, "epss_percentile": 0.41641}, "CVE-2011-4634": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2011-4638": {"epss_score": 0.00294, "epss_percentile": 0.52392}, "CVE-2011-4639": {"epss_score": 0.01272, "epss_percentile": 0.79077}, "CVE-2011-4640": {"epss_score": 0.12255, "epss_percentile": 0.93613}, "CVE-2011-4642": {"epss_score": 0.1923, "epss_percentile": 0.95153}, "CVE-2011-4643": {"epss_score": 0.10335, "epss_percentile": 0.92949}, "CVE-2011-4644": {"epss_score": 0.05279, "epss_percentile": 0.89686}, "CVE-2011-4646": {"epss_score": 0.00318, "epss_percentile": 0.54402}, "CVE-2011-4647": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2011-4650": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2011-4659": {"epss_score": 0.00861, "epss_percentile": 0.74555}, "CVE-2011-4661": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2011-4667": {"epss_score": 0.00151, "epss_percentile": 0.36291}, "CVE-2011-4668": {"epss_score": 0.03084, "epss_percentile": 0.86381}, "CVE-2011-4669": {"epss_score": 0.00663, "epss_percentile": 0.70613}, "CVE-2011-4670": {"epss_score": 0.17544, "epss_percentile": 0.94863}, "CVE-2011-4671": {"epss_score": 0.00375, "epss_percentile": 0.58621}, "CVE-2011-4672": {"epss_score": 0.00465, "epss_percentile": 0.63782}, "CVE-2011-4673": {"epss_score": 0.0011, "epss_percentile": 0.30147}, "CVE-2011-4674": {"epss_score": 0.00372, "epss_percentile": 0.58445}, "CVE-2011-4675": {"epss_score": 0.01336, "epss_percentile": 0.79554}, "CVE-2011-4677": {"epss_score": 0.00518, "epss_percentile": 0.66139}, "CVE-2011-4678": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4679": {"epss_score": 0.0016, "epss_percentile": 0.37509}, "CVE-2011-4680": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-4681": {"epss_score": 0.00246, "epss_percentile": 0.4774}, "CVE-2011-4682": {"epss_score": 0.00277, "epss_percentile": 0.50794}, "CVE-2011-4683": {"epss_score": 0.00445, "epss_percentile": 0.62852}, "CVE-2011-4684": {"epss_score": 0.03368, "epss_percentile": 0.87006}, "CVE-2011-4685": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-4686": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-4687": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2011-4688": {"epss_score": 0.00241, "epss_percentile": 0.47284}, "CVE-2011-4689": {"epss_score": 0.15984, "epss_percentile": 0.94548}, "CVE-2011-4690": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4691": {"epss_score": 0.0023, "epss_percentile": 0.45692}, "CVE-2011-4692": {"epss_score": 0.0023, "epss_percentile": 0.45692}, "CVE-2011-4693": {"epss_score": 0.03895, "epss_percentile": 0.87914}, "CVE-2011-4694": {"epss_score": 0.03895, "epss_percentile": 0.87914}, "CVE-2011-4695": {"epss_score": 0.00834, "epss_percentile": 0.74107}, "CVE-2011-4696": {"epss_score": 0.001, "epss_percentile": 0.28542}, "CVE-2011-4697": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4698": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4699": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4700": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4701": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4702": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4703": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4704": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4705": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4707": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2011-4708": {"epss_score": 0.00202, "epss_percentile": 0.42481}, "CVE-2011-4709": {"epss_score": 0.09648, "epss_percentile": 0.92638}, "CVE-2011-4710": {"epss_score": 0.00164, "epss_percentile": 0.37951}, "CVE-2011-4711": {"epss_score": 0.00084, "epss_percentile": 0.24967}, "CVE-2011-4712": {"epss_score": 0.02657, "epss_percentile": 0.85358}, "CVE-2011-4713": {"epss_score": 0.06504, "epss_percentile": 0.90805}, "CVE-2011-4714": {"epss_score": 0.1268, "epss_percentile": 0.93747}, "CVE-2011-4715": {"epss_score": 0.08822, "epss_percentile": 0.92271}, "CVE-2011-4716": {"epss_score": 0.04027, "epss_percentile": 0.88144}, "CVE-2011-4717": {"epss_score": 0.01588, "epss_percentile": 0.81188}, "CVE-2011-4718": {"epss_score": 0.01178, "epss_percentile": 0.78281}, "CVE-2011-4719": {"epss_score": 0.00212, "epss_percentile": 0.4382}, "CVE-2011-4720": {"epss_score": 0.10262, "epss_percentile": 0.92918}, "CVE-2011-4722": {"epss_score": 0.20793, "epss_percentile": 0.95413}, "CVE-2011-4723": {"epss_score": 0.12726, "epss_percentile": 0.93759}, "CVE-2011-4725": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2011-4726": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-4727": {"epss_score": 0.01863, "epss_percentile": 0.82598}, "CVE-2011-4728": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4729": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4730": {"epss_score": 0.01058, "epss_percentile": 0.77148}, "CVE-2011-4731": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4732": {"epss_score": 0.01751, "epss_percentile": 0.82102}, "CVE-2011-4733": {"epss_score": 0.01751, "epss_percentile": 0.82102}, "CVE-2011-4734": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2011-4735": {"epss_score": 0.00506, "epss_percentile": 0.65629}, "CVE-2011-4736": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4737": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4738": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4739": {"epss_score": 0.01058, "epss_percentile": 0.77148}, "CVE-2011-4740": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4741": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4742": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4743": {"epss_score": 0.01751, "epss_percentile": 0.82102}, "CVE-2011-4744": {"epss_score": 0.01751, "epss_percentile": 0.82102}, "CVE-2011-4745": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-4746": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4747": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4748": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4749": {"epss_score": 0.01058, "epss_percentile": 0.77148}, "CVE-2011-4750": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-4751": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4752": {"epss_score": 0.01751, "epss_percentile": 0.82102}, "CVE-2011-4753": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2011-4754": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-4755": {"epss_score": 0.01863, "epss_percentile": 0.82598}, "CVE-2011-4756": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4757": {"epss_score": 0.01058, "epss_percentile": 0.77148}, "CVE-2011-4758": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4759": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4760": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4761": {"epss_score": 0.01751, "epss_percentile": 0.82102}, "CVE-2011-4762": {"epss_score": 0.01751, "epss_percentile": 0.82102}, "CVE-2011-4763": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2011-4764": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-4765": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4766": {"epss_score": 0.00403, "epss_percentile": 0.60333}, "CVE-2011-4767": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4768": {"epss_score": 0.01751, "epss_percentile": 0.82102}, "CVE-2011-4769": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4770": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4771": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4772": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4773": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4776": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-4777": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-4778": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-4780": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2011-4782": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2011-4783": {"epss_score": 0.02171, "epss_percentile": 0.83871}, "CVE-2011-4784": {"epss_score": 0.0006, "epss_percentile": 0.19226}, "CVE-2011-4785": {"epss_score": 0.01721, "epss_percentile": 0.81936}, "CVE-2011-4786": {"epss_score": 0.63634, "epss_percentile": 0.98343}, "CVE-2011-4787": {"epss_score": 0.00592, "epss_percentile": 0.68627}, "CVE-2011-4788": {"epss_score": 0.00617, "epss_percentile": 0.69343}, "CVE-2011-4789": {"epss_score": 0.79608, "epss_percentile": 0.99048}, "CVE-2011-4790": {"epss_score": 0.05176, "epss_percentile": 0.89573}, "CVE-2011-4791": {"epss_score": 0.20688, "epss_percentile": 0.95403}, "CVE-2011-4800": {"epss_score": 0.01487, "epss_percentile": 0.8061}, "CVE-2011-4801": {"epss_score": 0.02391, "epss_percentile": 0.84601}, "CVE-2011-4802": {"epss_score": 0.02646, "epss_percentile": 0.85331}, "CVE-2011-4803": {"epss_score": 0.00885, "epss_percentile": 0.74943}, "CVE-2011-4804": {"epss_score": 0.30722, "epss_percentile": 0.96562}, "CVE-2011-4805": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2011-4806": {"epss_score": 0.00406, "epss_percentile": 0.60551}, "CVE-2011-4807": {"epss_score": 0.01829, "epss_percentile": 0.82442}, "CVE-2011-4808": {"epss_score": 0.00372, "epss_percentile": 0.58439}, "CVE-2011-4809": {"epss_score": 0.00314, "epss_percentile": 0.54146}, "CVE-2011-4810": {"epss_score": 0.02168, "epss_percentile": 0.83857}, "CVE-2011-4811": {"epss_score": 0.00164, "epss_percentile": 0.37951}, "CVE-2011-4812": {"epss_score": 0.00226, "epss_percentile": 0.45241}, "CVE-2011-4813": {"epss_score": 0.02168, "epss_percentile": 0.83857}, "CVE-2011-4814": {"epss_score": 0.0374, "epss_percentile": 0.87656}, "CVE-2011-4815": {"epss_score": 0.01962, "epss_percentile": 0.83066}, "CVE-2011-4816": {"epss_score": 0.00563, "epss_percentile": 0.6773}, "CVE-2011-4817": {"epss_score": 0.00327, "epss_percentile": 0.55097}, "CVE-2011-4818": {"epss_score": 0.00328, "epss_percentile": 0.55261}, "CVE-2011-4819": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2011-4820": {"epss_score": 0.00254, "epss_percentile": 0.48573}, "CVE-2011-4821": {"epss_score": 0.00116, "epss_percentile": 0.31187}, "CVE-2011-4822": {"epss_score": 0.00468, "epss_percentile": 0.63872}, "CVE-2011-4823": {"epss_score": 0.00363, "epss_percentile": 0.57829}, "CVE-2011-4824": {"epss_score": 0.03247, "epss_percentile": 0.86745}, "CVE-2011-4825": {"epss_score": 0.83036, "epss_percentile": 0.99228}, "CVE-2011-4826": {"epss_score": 0.00393, "epss_percentile": 0.59703}, "CVE-2011-4827": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2011-4828": {"epss_score": 0.81217, "epss_percentile": 0.99128}, "CVE-2011-4829": {"epss_score": 0.00172, "epss_percentile": 0.38909}, "CVE-2011-4830": {"epss_score": 0.00192, "epss_percentile": 0.41361}, "CVE-2011-4831": {"epss_score": 0.01691, "epss_percentile": 0.81778}, "CVE-2011-4832": {"epss_score": 0.02308, "epss_percentile": 0.8433}, "CVE-2011-4833": {"epss_score": 0.01269, "epss_percentile": 0.79044}, "CVE-2011-4834": {"epss_score": 0.0137, "epss_percentile": 0.798}, "CVE-2011-4835": {"epss_score": 0.06047, "epss_percentile": 0.90433}, "CVE-2011-4836": {"epss_score": 0.01809, "epss_percentile": 0.82358}, "CVE-2011-4837": {"epss_score": 0.00276, "epss_percentile": 0.5071}, "CVE-2011-4838": {"epss_score": 0.07274, "epss_percentile": 0.91379}, "CVE-2011-4847": {"epss_score": 0.00169, "epss_percentile": 0.38543}, "CVE-2011-4848": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4849": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4850": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4851": {"epss_score": 0.00165, "epss_percentile": 0.3804}, "CVE-2011-4852": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4853": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2011-4854": {"epss_score": 0.00731, "epss_percentile": 0.72166}, "CVE-2011-4855": {"epss_score": 0.00731, "epss_percentile": 0.72166}, "CVE-2011-4856": {"epss_score": 0.00731, "epss_percentile": 0.72166}, "CVE-2011-4857": {"epss_score": 0.09239, "epss_percentile": 0.92463}, "CVE-2011-4858": {"epss_score": 0.72158, "epss_percentile": 0.98697}, "CVE-2011-4859": {"epss_score": 0.07001, "epss_percentile": 0.91174}, "CVE-2011-4860": {"epss_score": 0.01582, "epss_percentile": 0.81143}, "CVE-2011-4861": {"epss_score": 0.01357, "epss_percentile": 0.79716}, "CVE-2011-4862": {"epss_score": 0.92585, "epss_percentile": 0.99729}, "CVE-2011-4863": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4864": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4865": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4866": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4867": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2011-4868": {"epss_score": 0.00846, "epss_percentile": 0.74318}, "CVE-2011-4869": {"epss_score": 0.02083, "epss_percentile": 0.8354}, "CVE-2011-4870": {"epss_score": 0.01703, "epss_percentile": 0.81842}, "CVE-2011-4871": {"epss_score": 0.13758, "epss_percentile": 0.9405}, "CVE-2011-4872": {"epss_score": 0.01477, "epss_percentile": 0.80548}, "CVE-2011-4873": {"epss_score": 0.00785, "epss_percentile": 0.73261}, "CVE-2011-4874": {"epss_score": 0.00292, "epss_percentile": 0.52265}, "CVE-2011-4875": {"epss_score": 0.40832, "epss_percentile": 0.9724}, "CVE-2011-4876": {"epss_score": 0.13194, "epss_percentile": 0.93897}, "CVE-2011-4877": {"epss_score": 0.26995, "epss_percentile": 0.96198}, "CVE-2011-4878": {"epss_score": 0.19077, "epss_percentile": 0.95126}, "CVE-2011-4879": {"epss_score": 0.40514, "epss_percentile": 0.97221}, "CVE-2011-4880": {"epss_score": 0.32305, "epss_percentile": 0.96687}, "CVE-2011-4881": {"epss_score": 0.51148, "epss_percentile": 0.97766}, "CVE-2011-4882": {"epss_score": 0.22218, "epss_percentile": 0.9561}, "CVE-2011-4883": {"epss_score": 0.13758, "epss_percentile": 0.9405}, "CVE-2011-4885": {"epss_score": 0.88576, "epss_percentile": 0.99479}, "CVE-2011-4887": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2011-4889": {"epss_score": 0.00814, "epss_percentile": 0.73777}, "CVE-2011-4890": {"epss_score": 0.01177, "epss_percentile": 0.78278}, "CVE-2011-4894": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4895": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4896": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4897": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-4898": {"epss_score": 0.06979, "epss_percentile": 0.91158}, "CVE-2011-4899": {"epss_score": 0.05661, "epss_percentile": 0.90096}, "CVE-2011-4900": {"epss_score": 0.00338, "epss_percentile": 0.56117}, "CVE-2011-4901": {"epss_score": 0.00249, "epss_percentile": 0.4807}, "CVE-2011-4902": {"epss_score": 0.00143, "epss_percentile": 0.35225}, "CVE-2011-4903": {"epss_score": 0.00332, "epss_percentile": 0.55583}, "CVE-2011-4904": {"epss_score": 0.00249, "epss_percentile": 0.4807}, "CVE-2011-4905": {"epss_score": 0.09813, "epss_percentile": 0.92713}, "CVE-2011-4906": {"epss_score": 0.35877, "epss_percentile": 0.96939}, "CVE-2011-4907": {"epss_score": 7e-05, "epss_percentile": 0.00362}, "CVE-2011-4908": {"epss_score": 0.61853, "epss_percentile": 0.98263}, "CVE-2011-4909": {"epss_score": 0.00075, "epss_percentile": 0.22973}, "CVE-2011-4910": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2011-4911": {"epss_score": 0.00411, "epss_percentile": 0.60881}, "CVE-2011-4912": {"epss_score": 6e-05, "epss_percentile": 0.00239}, "CVE-2011-4913": {"epss_score": 0.00953, "epss_percentile": 0.75886}, "CVE-2011-4914": {"epss_score": 0.01278, "epss_percentile": 0.79129}, "CVE-2011-4915": {"epss_score": 0.0008, "epss_percentile": 0.24164}, "CVE-2011-4916": {"epss_score": 0.00102, "epss_percentile": 0.28784}, "CVE-2011-4917": {"epss_score": 0.00058, "epss_percentile": 0.18375}, "CVE-2011-4918": {"epss_score": 0.00995, "epss_percentile": 0.76435}, "CVE-2011-4919": {"epss_score": 0.01588, "epss_percentile": 0.81191}, "CVE-2011-4920": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2011-4921": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2011-4922": {"epss_score": 0.00108, "epss_percentile": 0.29902}, "CVE-2011-4923": {"epss_score": 0.00591, "epss_percentile": 0.68588}, "CVE-2011-4924": {"epss_score": 0.0099, "epss_percentile": 0.7638}, "CVE-2011-4925": {"epss_score": 0.00236, "epss_percentile": 0.46435}, "CVE-2011-4926": {"epss_score": 0.07833, "epss_percentile": 0.91704}, "CVE-2011-4927": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2011-4928": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2011-4929": {"epss_score": 0.73607, "epss_percentile": 0.98763}, "CVE-2011-4930": {"epss_score": 0.00098, "epss_percentile": 0.27748}, "CVE-2011-4931": {"epss_score": 0.00363, "epss_percentile": 0.57868}, "CVE-2011-4932": {"epss_score": 0.03472, "epss_percentile": 0.87201}, "CVE-2011-4937": {"epss_score": 0.0001, "epss_percentile": 0.00831}, "CVE-2011-4938": {"epss_score": 0.0097, "epss_percentile": 0.76117}, "CVE-2011-4939": {"epss_score": 0.01102, "epss_percentile": 0.77582}, "CVE-2011-4940": {"epss_score": 0.00225, "epss_percentile": 0.45135}, "CVE-2011-4941": {"epss_score": 0.01404, "epss_percentile": 0.80035}, "CVE-2011-4942": {"epss_score": 0.00247, "epss_percentile": 0.47839}, "CVE-2011-4943": {"epss_score": 0.00944, "epss_percentile": 0.75788}, "CVE-2011-4944": {"epss_score": 0.00032, "epss_percentile": 0.09029}, "CVE-2011-4945": {"epss_score": 0.00084, "epss_percentile": 0.24957}, "CVE-2011-4946": {"epss_score": 0.00843, "epss_percentile": 0.74247}, "CVE-2011-4947": {"epss_score": 0.00245, "epss_percentile": 0.47651}, "CVE-2011-4948": {"epss_score": 0.00529, "epss_percentile": 0.66604}, "CVE-2011-4949": {"epss_score": 0.00836, "epss_percentile": 0.74149}, "CVE-2011-4950": {"epss_score": 0.00591, "epss_percentile": 0.68588}, "CVE-2011-4951": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2011-4952": {"epss_score": 0.00274, "epss_percentile": 0.50544}, "CVE-2011-4953": {"epss_score": 0.00706, "epss_percentile": 0.7162}, "CVE-2011-4954": {"epss_score": 0.00132, "epss_percentile": 0.33584}, "CVE-2011-4955": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2011-4956": {"epss_score": 0.008, "epss_percentile": 0.73559}, "CVE-2011-4957": {"epss_score": 0.0206, "epss_percentile": 0.83442}, "CVE-2011-4958": {"epss_score": 0.08805, "epss_percentile": 0.92262}, "CVE-2011-4959": {"epss_score": 0.00716, "epss_percentile": 0.71856}, "CVE-2011-4960": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2011-4961": {"epss_score": 0.00495, "epss_percentile": 0.65115}, "CVE-2011-4962": {"epss_score": 0.02686, "epss_percentile": 0.85429}, "CVE-2011-4963": {"epss_score": 0.0031, "epss_percentile": 0.53776}, "CVE-2011-4966": {"epss_score": 0.00624, "epss_percentile": 0.69569}, "CVE-2011-4967": {"epss_score": 0.00669, "epss_percentile": 0.70763}, "CVE-2011-4968": {"epss_score": 0.00391, "epss_percentile": 0.59575}, "CVE-2011-4969": {"epss_score": 0.04286, "epss_percentile": 0.88493}, "CVE-2011-4970": {"epss_score": 0.00605, "epss_percentile": 0.68992}, "CVE-2011-4971": {"epss_score": 0.46068, "epss_percentile": 0.97521}, "CVE-2011-4972": {"epss_score": 0.00909, "epss_percentile": 0.75294}, "CVE-2011-4973": {"epss_score": 0.00115, "epss_percentile": 0.31021}, "CVE-2011-5000": {"epss_score": 0.00698, "epss_percentile": 0.71431}, "CVE-2011-5001": {"epss_score": 0.74706, "epss_percentile": 0.98813}, "CVE-2011-5002": {"epss_score": 0.22128, "epss_percentile": 0.95597}, "CVE-2011-5003": {"epss_score": 0.74706, "epss_percentile": 0.98813}, "CVE-2011-5004": {"epss_score": 0.01387, "epss_percentile": 0.79916}, "CVE-2011-5005": {"epss_score": 0.02926, "epss_percentile": 0.86007}, "CVE-2011-5006": {"epss_score": 0.19291, "epss_percentile": 0.95161}, "CVE-2011-5007": {"epss_score": 0.81882, "epss_percentile": 0.99161}, "CVE-2011-5008": {"epss_score": 0.09304, "epss_percentile": 0.92492}, "CVE-2011-5009": {"epss_score": 0.28977, "epss_percentile": 0.96406}, "CVE-2011-5010": {"epss_score": 0.82088, "epss_percentile": 0.99172}, "CVE-2011-5011": {"epss_score": 0.00778, "epss_percentile": 0.73128}, "CVE-2011-5012": {"epss_score": 0.51487, "epss_percentile": 0.97781}, "CVE-2011-5018": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2011-5019": {"epss_score": 0.01517, "epss_percentile": 0.80804}, "CVE-2011-5020": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2011-5021": {"epss_score": 0.00239, "epss_percentile": 0.46912}, "CVE-2011-5022": {"epss_score": 0.00164, "epss_percentile": 0.37951}, "CVE-2011-5023": {"epss_score": 0.00278, "epss_percentile": 0.50873}, "CVE-2011-5024": {"epss_score": 0.0038, "epss_percentile": 0.58909}, "CVE-2011-5025": {"epss_score": 0.00398, "epss_percentile": 0.60086}, "CVE-2011-5026": {"epss_score": 0.00364, "epss_percentile": 0.5793}, "CVE-2011-5027": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2011-5028": {"epss_score": 0.12952, "epss_percentile": 0.93828}, "CVE-2011-5029": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2011-5030": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2011-5031": {"epss_score": 0.00431, "epss_percentile": 0.62042}, "CVE-2011-5032": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2011-5033": {"epss_score": 0.00553, "epss_percentile": 0.67425}, "CVE-2011-5034": {"epss_score": 0.68968, "epss_percentile": 0.98571}, "CVE-2011-5035": {"epss_score": 0.55569, "epss_percentile": 0.97985}, "CVE-2011-5036": {"epss_score": 0.01278, "epss_percentile": 0.79122}, "CVE-2011-5037": {"epss_score": 0.00764, "epss_percentile": 0.72894}, "CVE-2011-5038": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2011-5039": {"epss_score": 0.0045, "epss_percentile": 0.63106}, "CVE-2011-5040": {"epss_score": 0.01986, "epss_percentile": 0.83158}, "CVE-2011-5041": {"epss_score": 0.00315, "epss_percentile": 0.54208}, "CVE-2011-5042": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2011-5043": {"epss_score": 0.06247, "epss_percentile": 0.90604}, "CVE-2011-5044": {"epss_score": 0.00577, "epss_percentile": 0.68171}, "CVE-2011-5045": {"epss_score": 0.00278, "epss_percentile": 0.50873}, "CVE-2011-5046": {"epss_score": 0.76982, "epss_percentile": 0.98914}, "CVE-2011-5047": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2011-5048": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2011-5049": {"epss_score": 0.07975, "epss_percentile": 0.91799}, "CVE-2011-5050": {"epss_score": 0.00542, "epss_percentile": 0.67087}, "CVE-2011-5051": {"epss_score": 0.04263, "epss_percentile": 0.88465}, "CVE-2011-5052": {"epss_score": 0.52628, "epss_percentile": 0.97833}, "CVE-2011-5053": {"epss_score": 0.32232, "epss_percentile": 0.96681}, "CVE-2011-5054": {"epss_score": 0.00039, "epss_percentile": 0.11655}, "CVE-2011-5055": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2011-5056": {"epss_score": 0.00078, "epss_percentile": 0.2366}, "CVE-2011-5057": {"epss_score": 0.60127, "epss_percentile": 0.98193}, "CVE-2011-5058": {"epss_score": 0.01246, "epss_percentile": 0.78848}, "CVE-2011-5059": {"epss_score": 0.05542, "epss_percentile": 0.89979}, "CVE-2011-5060": {"epss_score": 0.00048, "epss_percentile": 0.14936}, "CVE-2011-5061": {"epss_score": 0.0188, "epss_percentile": 0.82676}, "CVE-2011-5062": {"epss_score": 0.02973, "epss_percentile": 0.861}, "CVE-2011-5063": {"epss_score": 0.01962, "epss_percentile": 0.83066}, "CVE-2011-5064": {"epss_score": 0.05319, "epss_percentile": 0.89726}, "CVE-2011-5065": {"epss_score": 0.00478, "epss_percentile": 0.64405}, "CVE-2011-5066": {"epss_score": 0.00051, "epss_percentile": 0.16258}, "CVE-2011-5067": {"epss_score": 0.00248, "epss_percentile": 0.47938}, "CVE-2011-5068": {"epss_score": 0.00105, "epss_percentile": 0.29322}, "CVE-2011-5069": {"epss_score": 0.01299, "epss_percentile": 0.79284}, "CVE-2011-5070": {"epss_score": 0.00725, "epss_percentile": 0.72059}, "CVE-2011-5071": {"epss_score": 0.00287, "epss_percentile": 0.51841}, "CVE-2011-5072": {"epss_score": 0.00158, "epss_percentile": 0.37204}, "CVE-2011-5073": {"epss_score": 0.00256, "epss_percentile": 0.48799}, "CVE-2011-5074": {"epss_score": 0.00109, "epss_percentile": 0.30069}, "CVE-2011-5075": {"epss_score": 0.04384, "epss_percentile": 0.88629}, "CVE-2011-5076": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2011-5077": {"epss_score": 0.01341, "epss_percentile": 0.7959}, "CVE-2011-5078": {"epss_score": 0.00355, "epss_percentile": 0.57264}, "CVE-2011-5079": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2011-5080": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2011-5081": {"epss_score": 0.00585, "epss_percentile": 0.68415}, "CVE-2011-5082": {"epss_score": 0.00253, "epss_percentile": 0.48483}, "CVE-2011-5083": {"epss_score": 0.02793, "epss_percentile": 0.85671}, "CVE-2011-5084": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-5085": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2011-5086": {"epss_score": 0.00928, "epss_percentile": 0.75584}, "CVE-2011-5087": {"epss_score": 0.00338, "epss_percentile": 0.56112}, "CVE-2011-5088": {"epss_score": 0.01405, "epss_percentile": 0.8004}, "CVE-2011-5089": {"epss_score": 0.0281, "epss_percentile": 0.85714}, "CVE-2011-5090": {"epss_score": 0.00527, "epss_percentile": 0.6652}, "CVE-2011-5091": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2011-5092": {"epss_score": 0.01566, "epss_percentile": 0.81069}, "CVE-2011-5093": {"epss_score": 0.00643, "epss_percentile": 0.70044}, "CVE-2011-5094": {"epss_score": 0.03441, "epss_percentile": 0.87141}, "CVE-2011-5095": {"epss_score": 0.00317, "epss_percentile": 0.54391}, "CVE-2011-5096": {"epss_score": 0.11508, "epss_percentile": 0.93387}, "CVE-2011-5097": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2011-5098": {"epss_score": 0.00191, "epss_percentile": 0.41201}, "CVE-2011-5099": {"epss_score": 0.01384, "epss_percentile": 0.79897}, "CVE-2011-5100": {"epss_score": 0.00395, "epss_percentile": 0.59801}, "CVE-2011-5101": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2011-5102": {"epss_score": 0.01194, "epss_percentile": 0.78412}, "CVE-2011-5103": {"epss_score": 0.00178, "epss_percentile": 0.39745}, "CVE-2011-5104": {"epss_score": 0.00431, "epss_percentile": 0.62064}, "CVE-2011-5105": {"epss_score": 0.00992, "epss_percentile": 0.76401}, "CVE-2011-5106": {"epss_score": 0.02815, "epss_percentile": 0.85728}, "CVE-2011-5107": {"epss_score": 0.02203, "epss_percentile": 0.83995}, "CVE-2011-5108": {"epss_score": 0.03011, "epss_percentile": 0.86197}, "CVE-2011-5109": {"epss_score": 0.0255, "epss_percentile": 0.85074}, "CVE-2011-5110": {"epss_score": 0.02608, "epss_percentile": 0.85229}, "CVE-2011-5111": {"epss_score": 0.00289, "epss_percentile": 0.52038}, "CVE-2011-5112": {"epss_score": 0.00205, "epss_percentile": 0.42744}, "CVE-2011-5113": {"epss_score": 0.0021, "epss_percentile": 0.43602}, "CVE-2011-5114": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5115": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-5116": {"epss_score": 0.00383, "epss_percentile": 0.5911}, "CVE-2011-5117": {"epss_score": 0.00103, "epss_percentile": 0.29094}, "CVE-2011-5118": {"epss_score": 0.00039, "epss_percentile": 0.11474}, "CVE-2011-5119": {"epss_score": 0.00039, "epss_percentile": 0.11474}, "CVE-2011-5120": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2011-5121": {"epss_score": 0.00178, "epss_percentile": 0.3968}, "CVE-2011-5122": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2011-5123": {"epss_score": 0.00178, "epss_percentile": 0.3968}, "CVE-2011-5124": {"epss_score": 0.70248, "epss_percentile": 0.98624}, "CVE-2011-5125": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-5126": {"epss_score": 0.00245, "epss_percentile": 0.47644}, "CVE-2011-5127": {"epss_score": 0.31265, "epss_percentile": 0.96605}, "CVE-2011-5128": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2011-5129": {"epss_score": 0.30071, "epss_percentile": 0.96502}, "CVE-2011-5130": {"epss_score": 0.74506, "epss_percentile": 0.98805}, "CVE-2011-5131": {"epss_score": 0.00334, "epss_percentile": 0.55712}, "CVE-2011-5132": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2011-5133": {"epss_score": 0.00383, "epss_percentile": 0.59122}, "CVE-2011-5134": {"epss_score": 0.00381, "epss_percentile": 0.58976}, "CVE-2011-5135": {"epss_score": 0.0041, "epss_percentile": 0.60814}, "CVE-2011-5136": {"epss_score": 0.00595, "epss_percentile": 0.68692}, "CVE-2011-5137": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2011-5138": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5139": {"epss_score": 0.00971, "epss_percentile": 0.76121}, "CVE-2011-5140": {"epss_score": 0.00576, "epss_percentile": 0.68132}, "CVE-2011-5141": {"epss_score": 0.00674, "epss_percentile": 0.70854}, "CVE-2011-5142": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2011-5143": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-5144": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2011-5145": {"epss_score": 0.00302, "epss_percentile": 0.53119}, "CVE-2011-5146": {"epss_score": 0.00047, "epss_percentile": 0.14782}, "CVE-2011-5147": {"epss_score": 0.0366, "epss_percentile": 0.87527}, "CVE-2011-5148": {"epss_score": 0.15552, "epss_percentile": 0.94457}, "CVE-2011-5149": {"epss_score": 0.03391, "epss_percentile": 0.8705}, "CVE-2011-5150": {"epss_score": 0.01305, "epss_percentile": 0.79323}, "CVE-2011-5151": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2011-5152": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2011-5153": {"epss_score": 0.0009, "epss_percentile": 0.25994}, "CVE-2011-5154": {"epss_score": 0.00053, "epss_percentile": 0.1671}, "CVE-2011-5155": {"epss_score": 0.00167, "epss_percentile": 0.38392}, "CVE-2011-5156": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2011-5157": {"epss_score": 0.00053, "epss_percentile": 0.1671}, "CVE-2011-5158": {"epss_score": 0.00557, "epss_percentile": 0.67545}, "CVE-2011-5159": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2011-5160": {"epss_score": 0.0016, "epss_percentile": 0.37476}, "CVE-2011-5161": {"epss_score": 0.018, "epss_percentile": 0.82317}, "CVE-2011-5162": {"epss_score": 0.35995, "epss_percentile": 0.96945}, "CVE-2011-5163": {"epss_score": 0.00165, "epss_percentile": 0.38126}, "CVE-2011-5164": {"epss_score": 0.55543, "epss_percentile": 0.97983}, "CVE-2011-5165": {"epss_score": 0.76441, "epss_percentile": 0.98891}, "CVE-2011-5166": {"epss_score": 0.20521, "epss_percentile": 0.95364}, "CVE-2011-5167": {"epss_score": 0.5847, "epss_percentile": 0.98119}, "CVE-2011-5168": {"epss_score": 0.00525, "epss_percentile": 0.66389}, "CVE-2011-5169": {"epss_score": 0.00612, "epss_percentile": 0.69231}, "CVE-2011-5170": {"epss_score": 0.6559, "epss_percentile": 0.98427}, "CVE-2011-5171": {"epss_score": 0.59811, "epss_percentile": 0.98182}, "CVE-2011-5172": {"epss_score": 0.40488, "epss_percentile": 0.9722}, "CVE-2011-5173": {"epss_score": 0.08545, "epss_percentile": 0.92116}, "CVE-2011-5174": {"epss_score": 0.00052, "epss_percentile": 0.16371}, "CVE-2011-5175": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2011-5176": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5177": {"epss_score": 0.00328, "epss_percentile": 0.55263}, "CVE-2011-5178": {"epss_score": 0.00666, "epss_percentile": 0.7068}, "CVE-2011-5179": {"epss_score": 0.02203, "epss_percentile": 0.83995}, "CVE-2011-5180": {"epss_score": 0.00959, "epss_percentile": 0.7595}, "CVE-2011-5181": {"epss_score": 0.01422, "epss_percentile": 0.80175}, "CVE-2011-5182": {"epss_score": 0.01556, "epss_percentile": 0.81016}, "CVE-2011-5183": {"epss_score": 0.00898, "epss_percentile": 0.75148}, "CVE-2011-5184": {"epss_score": 0.02641, "epss_percentile": 0.85306}, "CVE-2011-5185": {"epss_score": 0.00387, "epss_percentile": 0.59296}, "CVE-2011-5186": {"epss_score": 0.00421, "epss_percentile": 0.61531}, "CVE-2011-5187": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2011-5188": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2011-5189": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2011-5190": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2011-5191": {"epss_score": 0.00357, "epss_percentile": 0.5745}, "CVE-2011-5192": {"epss_score": 0.00377, "epss_percentile": 0.58717}, "CVE-2011-5193": {"epss_score": 0.00888, "epss_percentile": 0.74996}, "CVE-2011-5194": {"epss_score": 0.0054, "epss_percentile": 0.67015}, "CVE-2011-5195": {"epss_score": 0.00222, "epss_percentile": 0.44727}, "CVE-2011-5196": {"epss_score": 0.00174, "epss_percentile": 0.39167}, "CVE-2011-5197": {"epss_score": 0.0025, "epss_percentile": 0.48116}, "CVE-2011-5198": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2011-5199": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2011-5200": {"epss_score": 0.00335, "epss_percentile": 0.55804}, "CVE-2011-5201": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2011-5202": {"epss_score": 0.00062, "epss_percentile": 0.19713}, "CVE-2011-5203": {"epss_score": 0.00583, "epss_percentile": 0.6835}, "CVE-2011-5204": {"epss_score": 0.01, "epss_percentile": 0.76488}, "CVE-2011-5205": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2011-5206": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2011-5207": {"epss_score": 0.04219, "epss_percentile": 0.88408}, "CVE-2011-5208": {"epss_score": 0.00555, "epss_percentile": 0.67491}, "CVE-2011-5209": {"epss_score": 0.04189, "epss_percentile": 0.8837}, "CVE-2011-5210": {"epss_score": 0.00708, "epss_percentile": 0.71668}, "CVE-2011-5211": {"epss_score": 0.01147, "epss_percentile": 0.78009}, "CVE-2011-5212": {"epss_score": 0.00644, "epss_percentile": 0.70084}, "CVE-2011-5213": {"epss_score": 0.01796, "epss_percentile": 0.82304}, "CVE-2011-5214": {"epss_score": 0.06175, "epss_percentile": 0.90533}, "CVE-2011-5215": {"epss_score": 0.00526, "epss_percentile": 0.66403}, "CVE-2011-5216": {"epss_score": 0.00597, "epss_percentile": 0.68739}, "CVE-2011-5217": {"epss_score": 0.00462, "epss_percentile": 0.63586}, "CVE-2011-5218": {"epss_score": 0.00486, "epss_percentile": 0.64745}, "CVE-2011-5219": {"epss_score": 0.16374, "epss_percentile": 0.94639}, "CVE-2011-5220": {"epss_score": 0.00367, "epss_percentile": 0.58137}, "CVE-2011-5221": {"epss_score": 0.00647, "epss_percentile": 0.70198}, "CVE-2011-5222": {"epss_score": 0.01384, "epss_percentile": 0.79897}, "CVE-2011-5223": {"epss_score": 0.00537, "epss_percentile": 0.66888}, "CVE-2011-5224": {"epss_score": 0.00806, "epss_percentile": 0.73658}, "CVE-2011-5225": {"epss_score": 0.00469, "epss_percentile": 0.63915}, "CVE-2011-5226": {"epss_score": 0.0025, "epss_percentile": 0.48113}, "CVE-2011-5227": {"epss_score": 0.77999, "epss_percentile": 0.98964}, "CVE-2011-5228": {"epss_score": 0.05365, "epss_percentile": 0.89788}, "CVE-2011-5229": {"epss_score": 0.01139, "epss_percentile": 0.77936}, "CVE-2011-5230": {"epss_score": 0.01643, "epss_percentile": 0.81517}, "CVE-2011-5233": {"epss_score": 0.48547, "epss_percentile": 0.97643}, "CVE-2011-5234": {"epss_score": 0.00517, "epss_percentile": 0.66081}, "CVE-2011-5235": {"epss_score": 0.00526, "epss_percentile": 0.66424}, "CVE-2011-5236": {"epss_score": 0.00185, "epss_percentile": 0.40512}, "CVE-2011-5237": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2011-5238": {"epss_score": 0.00051, "epss_percentile": 0.16298}, "CVE-2011-5239": {"epss_score": 0.00185, "epss_percentile": 0.40512}, "CVE-2011-5240": {"epss_score": 0.00185, "epss_percentile": 0.40512}, "CVE-2011-5241": {"epss_score": 0.00185, "epss_percentile": 0.40512}, "CVE-2011-5242": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2011-5243": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2011-5244": {"epss_score": 0.01775, "epss_percentile": 0.82216}, "CVE-2011-5245": {"epss_score": 0.0095, "epss_percentile": 0.75856}, "CVE-2011-5247": {"epss_score": 0.00761, "epss_percentile": 0.72826}, "CVE-2011-5249": {"epss_score": 0.00199, "epss_percentile": 0.4214}, "CVE-2011-5250": {"epss_score": 0.00166, "epss_percentile": 0.38242}, "CVE-2011-5251": {"epss_score": 0.00208, "epss_percentile": 0.43308}, "CVE-2011-5252": {"epss_score": 0.26961, "epss_percentile": 0.96195}, "CVE-2011-5253": {"epss_score": 0.00285, "epss_percentile": 0.51539}, "CVE-2011-5254": {"epss_score": 0.01041, "epss_percentile": 0.76965}, "CVE-2011-5255": {"epss_score": 0.00619, "epss_percentile": 0.69389}, "CVE-2011-5256": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2011-5257": {"epss_score": 0.01827, "epss_percentile": 0.82435}, "CVE-2011-5258": {"epss_score": 0.065, "epss_percentile": 0.90801}, "CVE-2011-5259": {"epss_score": 0.01845, "epss_percentile": 0.82508}, "CVE-2011-5260": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2011-5261": {"epss_score": 0.02107, "epss_percentile": 0.83636}, "CVE-2011-5262": {"epss_score": 0.00394, "epss_percentile": 0.59783}, "CVE-2011-5263": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2011-5264": {"epss_score": 0.00522, "epss_percentile": 0.66277}, "CVE-2011-5265": {"epss_score": 0.06376, "epss_percentile": 0.90708}, "CVE-2011-5266": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2011-5267": {"epss_score": 0.0207, "epss_percentile": 0.8347}, "CVE-2011-5268": {"epss_score": 0.0086, "epss_percentile": 0.74538}, "CVE-2011-5269": {"epss_score": 0.00224, "epss_percentile": 0.45003}, "CVE-2011-5270": {"epss_score": 0.00506, "epss_percentile": 0.65641}, "CVE-2011-5271": {"epss_score": 0.0041, "epss_percentile": 0.60831}, "CVE-2011-5272": {"epss_score": 0.0039, "epss_percentile": 0.59504}, "CVE-2011-5273": {"epss_score": 0.01135, "epss_percentile": 0.77911}, "CVE-2011-5274": {"epss_score": 0.00802, "epss_percentile": 0.73587}, "CVE-2011-5275": {"epss_score": 0.00252, "epss_percentile": 0.48402}, "CVE-2011-5276": {"epss_score": 0.00338, "epss_percentile": 0.56114}, "CVE-2011-5277": {"epss_score": 0.00231, "epss_percentile": 0.45819}, "CVE-2011-5278": {"epss_score": 0.00231, "epss_percentile": 0.45819}, "CVE-2011-5279": {"epss_score": 0.08547, "epss_percentile": 0.92118}, "CVE-2011-5280": {"epss_score": 0.00583, "epss_percentile": 0.68346}, "CVE-2011-5282": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2011-5283": {"epss_score": 0.0338, "epss_percentile": 0.8703}, "CVE-2011-5284": {"epss_score": 0.00276, "epss_percentile": 0.50765}, "CVE-2011-5285": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5286": {"epss_score": 0.01741, "epss_percentile": 0.82048}, "CVE-2011-5287": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5288": {"epss_score": 0.13245, "epss_percentile": 0.93913}, "CVE-2011-5289": {"epss_score": 0.03932, "epss_percentile": 0.87978}, "CVE-2011-5290": {"epss_score": 0.00467, "epss_percentile": 0.63855}, "CVE-2011-5291": {"epss_score": 0.00467, "epss_percentile": 0.63855}, "CVE-2011-5292": {"epss_score": 0.00648, "epss_percentile": 0.70221}, "CVE-2011-5293": {"epss_score": 0.00796, "epss_percentile": 0.7349}, "CVE-2011-5294": {"epss_score": 0.00467, "epss_percentile": 0.63855}, "CVE-2011-5295": {"epss_score": 0.13245, "epss_percentile": 0.93913}, "CVE-2011-5296": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5297": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5298": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2011-5299": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5300": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2011-5301": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2011-5302": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2011-5303": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5304": {"epss_score": 0.00403, "epss_percentile": 0.60361}, "CVE-2011-5305": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5306": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2011-5307": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2011-5308": {"epss_score": 0.00422, "epss_percentile": 0.61542}, "CVE-2011-5309": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5310": {"epss_score": 0.00185, "epss_percentile": 0.40488}, "CVE-2011-5311": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2011-5312": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5313": {"epss_score": 0.00247, "epss_percentile": 0.47814}, "CVE-2011-5314": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2011-5315": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2011-5316": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2011-5317": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2011-5318": {"epss_score": 0.0031, "epss_percentile": 0.53747}, "CVE-2011-5319": {"epss_score": 0.00373, "epss_percentile": 0.58473}, "CVE-2011-5320": {"epss_score": 0.0006, "epss_percentile": 0.19083}, "CVE-2011-5321": {"epss_score": 0.00042, "epss_percentile": 0.12881}, "CVE-2011-5322": {"epss_score": 0.00419, "epss_percentile": 0.61354}, "CVE-2011-5323": {"epss_score": 0.00568, "epss_percentile": 0.67896}, "CVE-2011-5324": {"epss_score": 0.00568, "epss_percentile": 0.67896}, "CVE-2011-5325": {"epss_score": 0.03275, "epss_percentile": 0.86801}, "CVE-2011-5326": {"epss_score": 0.01098, "epss_percentile": 0.77543}, "CVE-2011-5327": {"epss_score": 0.00627, "epss_percentile": 0.69644}, "CVE-2011-5328": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2011-5329": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2011-5330": {"epss_score": 0.00381, "epss_percentile": 0.58982}, "CVE-2011-5331": {"epss_score": 0.02932, "epss_percentile": 0.86017}, "CVE-2012-0001": {"epss_score": 0.51192, "epss_percentile": 0.97768}, "CVE-2012-0002": {"epss_score": 0.85018, "epss_percentile": 0.99313}, "CVE-2012-0003": {"epss_score": 0.87848, "epss_percentile": 0.99447}, "CVE-2012-0004": {"epss_score": 0.60455, "epss_percentile": 0.98207}, "CVE-2012-0005": {"epss_score": 0.04908, "epss_percentile": 0.89278}, "CVE-2012-0006": {"epss_score": 0.62574, "epss_percentile": 0.98297}, "CVE-2012-0007": {"epss_score": 0.62209, "epss_percentile": 0.98285}, "CVE-2012-0008": {"epss_score": 0.0294, "epss_percentile": 0.86032}, "CVE-2012-0009": {"epss_score": 0.52704, "epss_percentile": 0.97836}, "CVE-2012-0010": {"epss_score": 0.1521, "epss_percentile": 0.94385}, "CVE-2012-0011": {"epss_score": 0.4233, "epss_percentile": 0.97326}, "CVE-2012-0012": {"epss_score": 0.16456, "epss_percentile": 0.94666}, "CVE-2012-0013": {"epss_score": 0.87034, "epss_percentile": 0.99409}, "CVE-2012-0014": {"epss_score": 0.52268, "epss_percentile": 0.97816}, "CVE-2012-0015": {"epss_score": 0.56278, "epss_percentile": 0.98016}, "CVE-2012-0016": {"epss_score": 0.48741, "epss_percentile": 0.97652}, "CVE-2012-0017": {"epss_score": 0.42355, "epss_percentile": 0.97327}, "CVE-2012-0018": {"epss_score": 0.53666, "epss_percentile": 0.97891}, "CVE-2012-0019": {"epss_score": 0.45098, "epss_percentile": 0.97473}, "CVE-2012-0020": {"epss_score": 0.45098, "epss_percentile": 0.97473}, "CVE-2012-0021": {"epss_score": 0.3296, "epss_percentile": 0.96738}, "CVE-2012-0022": {"epss_score": 0.23046, "epss_percentile": 0.95724}, "CVE-2012-0023": {"epss_score": 0.11852, "epss_percentile": 0.93496}, "CVE-2012-0024": {"epss_score": 0.00757, "epss_percentile": 0.72754}, "CVE-2012-0025": {"epss_score": 0.22444, "epss_percentile": 0.95634}, "CVE-2012-0027": {"epss_score": 0.00828, "epss_percentile": 0.73991}, "CVE-2012-0028": {"epss_score": 0.00046, "epss_percentile": 0.14162}, "CVE-2012-0029": {"epss_score": 0.01041, "epss_percentile": 0.76963}, "CVE-2012-0030": {"epss_score": 0.00549, "epss_percentile": 0.67307}, "CVE-2012-0031": {"epss_score": 0.01196, "epss_percentile": 0.78441}, "CVE-2012-0032": {"epss_score": 0.00041, "epss_percentile": 0.12224}, "CVE-2012-0033": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2012-0034": {"epss_score": 0.00071, "epss_percentile": 0.22143}, "CVE-2012-0035": {"epss_score": 0.0403, "epss_percentile": 0.88149}, "CVE-2012-0036": {"epss_score": 0.06535, "epss_percentile": 0.90827}, "CVE-2012-0037": {"epss_score": 0.00534, "epss_percentile": 0.66801}, "CVE-2012-0038": {"epss_score": 0.00063, "epss_percentile": 0.19915}, "CVE-2012-0039": {"epss_score": 0.00492, "epss_percentile": 0.64982}, "CVE-2012-0040": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2012-0041": {"epss_score": 0.02276, "epss_percentile": 0.84228}, "CVE-2012-0042": {"epss_score": 0.00384, "epss_percentile": 0.59162}, "CVE-2012-0043": {"epss_score": 0.01681, "epss_percentile": 0.8173}, "CVE-2012-0044": {"epss_score": 0.00091, "epss_percentile": 0.26237}, "CVE-2012-0045": {"epss_score": 0.00564, "epss_percentile": 0.67746}, "CVE-2012-0046": {"epss_score": 0.00436, "epss_percentile": 0.62447}, "CVE-2012-0047": {"epss_score": 0.0121, "epss_percentile": 0.7855}, "CVE-2012-0048": {"epss_score": 0.01203, "epss_percentile": 0.78499}, "CVE-2012-0049": {"epss_score": 0.00622, "epss_percentile": 0.69499}, "CVE-2012-0050": {"epss_score": 0.01752, "epss_percentile": 0.82107}, "CVE-2012-0051": {"epss_score": 0.01355, "epss_percentile": 0.79711}, "CVE-2012-0052": {"epss_score": 0.00298, "epss_percentile": 0.52775}, "CVE-2012-0053": {"epss_score": 0.65535, "epss_percentile": 0.98425}, "CVE-2012-0054": {"epss_score": 0.00033, "epss_percentile": 0.09206}, "CVE-2012-0055": {"epss_score": 0.00393, "epss_percentile": 0.59736}, "CVE-2012-0056": {"epss_score": 0.76758, "epss_percentile": 0.98903}, "CVE-2012-0057": {"epss_score": 0.0159, "epss_percentile": 0.81202}, "CVE-2012-0058": {"epss_score": 0.00064, "epss_percentile": 0.2019}, "CVE-2012-0059": {"epss_score": 0.00229, "epss_percentile": 0.45572}, "CVE-2012-0060": {"epss_score": 0.07615, "epss_percentile": 0.9157}, "CVE-2012-0061": {"epss_score": 0.04884, "epss_percentile": 0.89252}, "CVE-2012-0062": {"epss_score": 0.00274, "epss_percentile": 0.50526}, "CVE-2012-0063": {"epss_score": 0.02431, "epss_percentile": 0.84728}, "CVE-2012-0064": {"epss_score": 0.00081, "epss_percentile": 0.24271}, "CVE-2012-0065": {"epss_score": 0.00255, "epss_percentile": 0.4863}, "CVE-2012-0066": {"epss_score": 0.02882, "epss_percentile": 0.85903}, "CVE-2012-0067": {"epss_score": 0.11751, "epss_percentile": 0.93465}, "CVE-2012-0068": {"epss_score": 0.01599, "epss_percentile": 0.8125}, "CVE-2012-0069": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2012-0070": {"epss_score": 0.00222, "epss_percentile": 0.44724}, "CVE-2012-0071": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2012-0072": {"epss_score": 0.00874, "epss_percentile": 0.74767}, "CVE-2012-0073": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2012-0074": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2012-0075": {"epss_score": 0.00679, "epss_percentile": 0.71013}, "CVE-2012-0076": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2012-0077": {"epss_score": 0.00349, "epss_percentile": 0.56881}, "CVE-2012-0078": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2012-0079": {"epss_score": 0.00564, "epss_percentile": 0.67744}, "CVE-2012-0080": {"epss_score": 0.00185, "epss_percentile": 0.40532}, "CVE-2012-0081": {"epss_score": 0.00248, "epss_percentile": 0.47992}, "CVE-2012-0082": {"epss_score": 0.00534, "epss_percentile": 0.66793}, "CVE-2012-0083": {"epss_score": 0.00324, "epss_percentile": 0.54931}, "CVE-2012-0084": {"epss_score": 0.00156, "epss_percentile": 0.37011}, "CVE-2012-0085": {"epss_score": 0.00324, "epss_percentile": 0.54931}, "CVE-2012-0086": {"epss_score": 0.00143, "epss_percentile": 0.35149}, "CVE-2012-0087": {"epss_score": 0.00992, "epss_percentile": 0.76395}, "CVE-2012-0088": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2012-0089": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2012-0090": {"epss_score": 0.00139, "epss_percentile": 0.34537}, "CVE-2012-0091": {"epss_score": 0.00483, "epss_percentile": 0.64619}, "CVE-2012-0092": {"epss_score": 0.00139, "epss_percentile": 0.34537}, "CVE-2012-0093": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2012-0094": {"epss_score": 0.00741, "epss_percentile": 0.72442}, "CVE-2012-0095": {"epss_score": 0.00143, "epss_percentile": 0.35149}, "CVE-2012-0096": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2012-0097": {"epss_score": 0.00061, "epss_percentile": 0.19284}, "CVE-2012-0098": {"epss_score": 0.00062, "epss_percentile": 0.19713}, "CVE-2012-0099": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2012-0100": {"epss_score": 0.00164, "epss_percentile": 0.37999}, "CVE-2012-0101": {"epss_score": 0.0097, "epss_percentile": 0.76112}, "CVE-2012-0102": {"epss_score": 0.0097, "epss_percentile": 0.76112}, "CVE-2012-0103": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2012-0104": {"epss_score": 0.005, "epss_percentile": 0.65303}, "CVE-2012-0105": {"epss_score": 0.00061, "epss_percentile": 0.19354}, "CVE-2012-0106": {"epss_score": 0.00139, "epss_percentile": 0.34537}, "CVE-2012-0107": {"epss_score": 0.00608, "epss_percentile": 0.69076}, "CVE-2012-0108": {"epss_score": 0.00143, "epss_percentile": 0.35149}, "CVE-2012-0109": {"epss_score": 0.00067, "epss_percentile": 0.21147}, "CVE-2012-0110": {"epss_score": 0.00378, "epss_percentile": 0.58811}, "CVE-2012-0111": {"epss_score": 0.00059, "epss_percentile": 0.18899}, "CVE-2012-0112": {"epss_score": 0.00445, "epss_percentile": 0.62874}, "CVE-2012-0113": {"epss_score": 0.00634, "epss_percentile": 0.6981}, "CVE-2012-0114": {"epss_score": 0.00048, "epss_percentile": 0.15048}, "CVE-2012-0115": {"epss_score": 0.00634, "epss_percentile": 0.6981}, "CVE-2012-0116": {"epss_score": 0.00227, "epss_percentile": 0.45391}, "CVE-2012-0117": {"epss_score": 0.00295, "epss_percentile": 0.52516}, "CVE-2012-0118": {"epss_score": 0.00445, "epss_percentile": 0.62874}, "CVE-2012-0119": {"epss_score": 0.00634, "epss_percentile": 0.6981}, "CVE-2012-0120": {"epss_score": 0.00634, "epss_percentile": 0.6981}, "CVE-2012-0121": {"epss_score": 0.20064, "epss_percentile": 0.95284}, "CVE-2012-0122": {"epss_score": 0.20064, "epss_percentile": 0.95284}, "CVE-2012-0123": {"epss_score": 0.2206, "epss_percentile": 0.95589}, "CVE-2012-0124": {"epss_score": 0.75005, "epss_percentile": 0.98828}, "CVE-2012-0125": {"epss_score": 0.00165, "epss_percentile": 0.38106}, "CVE-2012-0126": {"epss_score": 0.00843, "epss_percentile": 0.74257}, "CVE-2012-0127": {"epss_score": 0.38636, "epss_percentile": 0.9711}, "CVE-2012-0128": {"epss_score": 0.00672, "epss_percentile": 0.70815}, "CVE-2012-0129": {"epss_score": 0.06907, "epss_percentile": 0.91111}, "CVE-2012-0130": {"epss_score": 0.01179, "epss_percentile": 0.78291}, "CVE-2012-0131": {"epss_score": 0.15128, "epss_percentile": 0.94369}, "CVE-2012-0132": {"epss_score": 0.00749, "epss_percentile": 0.72601}, "CVE-2012-0133": {"epss_score": 0.01138, "epss_percentile": 0.77934}, "CVE-2012-0134": {"epss_score": 0.00082, "epss_percentile": 0.24427}, "CVE-2012-0135": {"epss_score": 0.00243, "epss_percentile": 0.47467}, "CVE-2012-0136": {"epss_score": 0.45098, "epss_percentile": 0.97473}, "CVE-2012-0137": {"epss_score": 0.45098, "epss_percentile": 0.97473}, "CVE-2012-0138": {"epss_score": 0.45098, "epss_percentile": 0.97473}, "CVE-2012-0141": {"epss_score": 0.64174, "epss_percentile": 0.98368}, "CVE-2012-0142": {"epss_score": 0.62114, "epss_percentile": 0.9828}, "CVE-2012-0143": {"epss_score": 0.5796, "epss_percentile": 0.98092}, "CVE-2012-0144": {"epss_score": 0.35923, "epss_percentile": 0.96941}, "CVE-2012-0145": {"epss_score": 0.35923, "epss_percentile": 0.96941}, "CVE-2012-0146": {"epss_score": 0.25126, "epss_percentile": 0.95988}, "CVE-2012-0147": {"epss_score": 0.36517, "epss_percentile": 0.96982}, "CVE-2012-0148": {"epss_score": 0.01455, "epss_percentile": 0.80389}, "CVE-2012-0149": {"epss_score": 0.01182, "epss_percentile": 0.78317}, "CVE-2012-0150": {"epss_score": 0.59759, "epss_percentile": 0.9818}, "CVE-2012-0151": {"epss_score": 0.8664, "epss_percentile": 0.99391}, "CVE-2012-0152": {"epss_score": 0.85393, "epss_percentile": 0.99332}, "CVE-2012-0154": {"epss_score": 0.01288, "epss_percentile": 0.79202}, "CVE-2012-0155": {"epss_score": 0.56965, "epss_percentile": 0.98041}, "CVE-2012-0156": {"epss_score": 0.23239, "epss_percentile": 0.95756}, "CVE-2012-0157": {"epss_score": 0.01449, "epss_percentile": 0.80345}, "CVE-2012-0158": {"epss_score": 0.94295, "epss_percentile": 0.99939}, "CVE-2012-0159": {"epss_score": 0.62903, "epss_percentile": 0.98312}, "CVE-2012-0160": {"epss_score": 0.57511, "epss_percentile": 0.98067}, "CVE-2012-0161": {"epss_score": 0.55229, "epss_percentile": 0.97966}, "CVE-2012-0162": {"epss_score": 0.57604, "epss_percentile": 0.98075}, "CVE-2012-0163": {"epss_score": 0.55802, "epss_percentile": 0.97997}, "CVE-2012-0164": {"epss_score": 0.14944, "epss_percentile": 0.9433}, "CVE-2012-0165": {"epss_score": 0.62114, "epss_percentile": 0.9828}, "CVE-2012-0167": {"epss_score": 0.65939, "epss_percentile": 0.98445}, "CVE-2012-0168": {"epss_score": 0.45624, "epss_percentile": 0.97494}, "CVE-2012-0169": {"epss_score": 0.5244, "epss_percentile": 0.97826}, "CVE-2012-0170": {"epss_score": 0.5845, "epss_percentile": 0.98117}, "CVE-2012-0171": {"epss_score": 0.56103, "epss_percentile": 0.98008}, "CVE-2012-0172": {"epss_score": 0.55708, "epss_percentile": 0.97991}, "CVE-2012-0173": {"epss_score": 0.52282, "epss_percentile": 0.97817}, "CVE-2012-0174": {"epss_score": 0.00957, "epss_percentile": 0.75932}, "CVE-2012-0175": {"epss_score": 0.46756, "epss_percentile": 0.97557}, "CVE-2012-0176": {"epss_score": 0.62114, "epss_percentile": 0.9828}, "CVE-2012-0177": {"epss_score": 0.70341, "epss_percentile": 0.98629}, "CVE-2012-0178": {"epss_score": 0.00479, "epss_percentile": 0.64433}, "CVE-2012-0179": {"epss_score": 0.00423, "epss_percentile": 0.61592}, "CVE-2012-0180": {"epss_score": 0.01401, "epss_percentile": 0.80006}, "CVE-2012-0181": {"epss_score": 0.03626, "epss_percentile": 0.87456}, "CVE-2012-0182": {"epss_score": 0.50326, "epss_percentile": 0.97732}, "CVE-2012-0183": {"epss_score": 0.62114, "epss_percentile": 0.9828}, "CVE-2012-0184": {"epss_score": 0.58804, "epss_percentile": 0.98137}, "CVE-2012-0185": {"epss_score": 0.64692, "epss_percentile": 0.98388}, "CVE-2012-0186": {"epss_score": 0.00094, "epss_percentile": 0.26778}, "CVE-2012-0187": {"epss_score": 0.00566, "epss_percentile": 0.67829}, "CVE-2012-0188": {"epss_score": 0.06382, "epss_percentile": 0.90713}, "CVE-2012-0189": {"epss_score": 0.0603, "epss_percentile": 0.90421}, "CVE-2012-0190": {"epss_score": 0.0603, "epss_percentile": 0.90421}, "CVE-2012-0191": {"epss_score": 0.00201, "epss_percentile": 0.42329}, "CVE-2012-0192": {"epss_score": 0.10875, "epss_percentile": 0.93142}, "CVE-2012-0193": {"epss_score": 0.00816, "epss_percentile": 0.73795}, "CVE-2012-0194": {"epss_score": 0.01658, "epss_percentile": 0.81607}, "CVE-2012-0195": {"epss_score": 0.00478, "epss_percentile": 0.64405}, "CVE-2012-0198": {"epss_score": 0.68443, "epss_percentile": 0.98549}, "CVE-2012-0199": {"epss_score": 0.00379, "epss_percentile": 0.58859}, "CVE-2012-0200": {"epss_score": 0.09488, "epss_percentile": 0.9257}, "CVE-2012-0201": {"epss_score": 0.76345, "epss_percentile": 0.98887}, "CVE-2012-0202": {"epss_score": 0.74106, "epss_percentile": 0.98789}, "CVE-2012-0203": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2012-0204": {"epss_score": 0.00676, "epss_percentile": 0.70916}, "CVE-2012-0205": {"epss_score": 0.00191, "epss_percentile": 0.41201}, "CVE-2012-0206": {"epss_score": 5e-05, "epss_percentile": 0.00187}, "CVE-2012-0207": {"epss_score": 0.1317, "epss_percentile": 0.93891}, "CVE-2012-0208": {"epss_score": 0.00673, "epss_percentile": 0.7083}, "CVE-2012-0209": {"epss_score": 0.64772, "epss_percentile": 0.98391}, "CVE-2012-0210": {"epss_score": 0.04506, "epss_percentile": 0.88772}, "CVE-2012-0211": {"epss_score": 0.10651, "epss_percentile": 0.93058}, "CVE-2012-0212": {"epss_score": 0.10651, "epss_percentile": 0.93058}, "CVE-2012-0213": {"epss_score": 0.13063, "epss_percentile": 0.93862}, "CVE-2012-0214": {"epss_score": 0.00118, "epss_percentile": 0.31519}, "CVE-2012-0215": {"epss_score": 0.00617, "epss_percentile": 0.69341}, "CVE-2012-0216": {"epss_score": 0.00052, "epss_percentile": 0.16352}, "CVE-2012-0217": {"epss_score": 0.88004, "epss_percentile": 0.99454}, "CVE-2012-0218": {"epss_score": 0.00066, "epss_percentile": 0.20767}, "CVE-2012-0219": {"epss_score": 0.00172, "epss_percentile": 0.39012}, "CVE-2012-0220": {"epss_score": 0.00467, "epss_percentile": 0.63861}, "CVE-2012-0221": {"epss_score": 0.01046, "epss_percentile": 0.77031}, "CVE-2012-0222": {"epss_score": 0.00063, "epss_percentile": 0.1983}, "CVE-2012-0223": {"epss_score": 0.00399, "epss_percentile": 0.60144}, "CVE-2012-0224": {"epss_score": 0.00399, "epss_percentile": 0.60144}, "CVE-2012-0225": {"epss_score": 0.00535, "epss_percentile": 0.66822}, "CVE-2012-0226": {"epss_score": 0.00522, "epss_percentile": 0.66252}, "CVE-2012-0227": {"epss_score": 0.07626, "epss_percentile": 0.9158}, "CVE-2012-0228": {"epss_score": 0.00563, "epss_percentile": 0.6771}, "CVE-2012-0229": {"epss_score": 0.03539, "epss_percentile": 0.87316}, "CVE-2012-0230": {"epss_score": 0.0128, "epss_percentile": 0.79138}, "CVE-2012-0231": {"epss_score": 0.01136, "epss_percentile": 0.77918}, "CVE-2012-0232": {"epss_score": 0.00442, "epss_percentile": 0.62737}, "CVE-2012-0233": {"epss_score": 0.00228, "epss_percentile": 0.45531}, "CVE-2012-0234": {"epss_score": 0.00163, "epss_percentile": 0.37825}, "CVE-2012-0235": {"epss_score": 0.00069, "epss_percentile": 0.21498}, "CVE-2012-0236": {"epss_score": 0.00236, "epss_percentile": 0.46457}, "CVE-2012-0237": {"epss_score": 0.00241, "epss_percentile": 0.47272}, "CVE-2012-0238": {"epss_score": 0.01952, "epss_percentile": 0.83023}, "CVE-2012-0239": {"epss_score": 0.00175, "epss_percentile": 0.39283}, "CVE-2012-0240": {"epss_score": 0.00753, "epss_percentile": 0.72682}, "CVE-2012-0241": {"epss_score": 0.0921, "epss_percentile": 0.92449}, "CVE-2012-0242": {"epss_score": 0.10678, "epss_percentile": 0.93068}, "CVE-2012-0243": {"epss_score": 0.01952, "epss_percentile": 0.83023}, "CVE-2012-0244": {"epss_score": 0.00163, "epss_percentile": 0.37825}, "CVE-2012-0245": {"epss_score": 0.23775, "epss_percentile": 0.95816}, "CVE-2012-0246": {"epss_score": 0.00675, "epss_percentile": 0.70914}, "CVE-2012-0247": {"epss_score": 0.04205, "epss_percentile": 0.88395}, "CVE-2012-0248": {"epss_score": 0.00286, "epss_percentile": 0.51768}, "CVE-2012-0249": {"epss_score": 0.00529, "epss_percentile": 0.66579}, "CVE-2012-0250": {"epss_score": 0.00272, "epss_percentile": 0.50353}, "CVE-2012-0253": {"epss_score": 0.00656, "epss_percentile": 0.70447}, "CVE-2012-0254": {"epss_score": 0.02585, "epss_percentile": 0.85163}, "CVE-2012-0255": {"epss_score": 0.00925, "epss_percentile": 0.7553}, "CVE-2012-0256": {"epss_score": 0.01909, "epss_percentile": 0.8282}, "CVE-2012-0257": {"epss_score": 0.03138, "epss_percentile": 0.86482}, "CVE-2012-0258": {"epss_score": 0.03138, "epss_percentile": 0.86482}, "CVE-2012-0259": {"epss_score": 0.01434, "epss_percentile": 0.80263}, "CVE-2012-0260": {"epss_score": 0.01936, "epss_percentile": 0.82962}, "CVE-2012-0261": {"epss_score": 0.86451, "epss_percentile": 0.99383}, "CVE-2012-0262": {"epss_score": 0.91146, "epss_percentile": 0.99622}, "CVE-2012-0263": {"epss_score": 0.00745, "epss_percentile": 0.72528}, "CVE-2012-0264": {"epss_score": 0.04443, "epss_percentile": 0.88695}, "CVE-2012-0265": {"epss_score": 0.05677, "epss_percentile": 0.90112}, "CVE-2012-0266": {"epss_score": 0.73656, "epss_percentile": 0.98765}, "CVE-2012-0267": {"epss_score": 0.73275, "epss_percentile": 0.98745}, "CVE-2012-0268": {"epss_score": 0.01579, "epss_percentile": 0.81128}, "CVE-2012-0269": {"epss_score": 0.08684, "epss_percentile": 0.92199}, "CVE-2012-0270": {"epss_score": 0.75449, "epss_percentile": 0.98846}, "CVE-2012-0271": {"epss_score": 0.33258, "epss_percentile": 0.96758}, "CVE-2012-0272": {"epss_score": 0.00673, "epss_percentile": 0.70834}, "CVE-2012-0273": {"epss_score": 0.04271, "epss_percentile": 0.88476}, "CVE-2012-0275": {"epss_score": 0.2401, "epss_percentile": 0.95842}, "CVE-2012-0276": {"epss_score": 0.14934, "epss_percentile": 0.94328}, "CVE-2012-0277": {"epss_score": 0.04556, "epss_percentile": 0.88846}, "CVE-2012-0278": {"epss_score": 0.29017, "epss_percentile": 0.96411}, "CVE-2012-0279": {"epss_score": 0.00034, "epss_percentile": 0.09685}, "CVE-2012-0282": {"epss_score": 0.11251, "epss_percentile": 0.93279}, "CVE-2012-0283": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2012-0284": {"epss_score": 0.6745, "epss_percentile": 0.98507}, "CVE-2012-0285": {"epss_score": 0.00731, "epss_percentile": 0.7217}, "CVE-2012-0286": {"epss_score": 0.00306, "epss_percentile": 0.53444}, "CVE-2012-0287": {"epss_score": 0.00601, "epss_percentile": 0.68855}, "CVE-2012-0289": {"epss_score": 0.00412, "epss_percentile": 0.60939}, "CVE-2012-0290": {"epss_score": 0.02611, "epss_percentile": 0.85236}, "CVE-2012-0291": {"epss_score": 0.00665, "epss_percentile": 0.70671}, "CVE-2012-0292": {"epss_score": 0.05633, "epss_percentile": 0.9007}, "CVE-2012-0293": {"epss_score": 0.00481, "epss_percentile": 0.64495}, "CVE-2012-0294": {"epss_score": 0.00636, "epss_percentile": 0.69877}, "CVE-2012-0295": {"epss_score": 0.0636, "epss_percentile": 0.90698}, "CVE-2012-0296": {"epss_score": 0.00643, "epss_percentile": 0.70053}, "CVE-2012-0297": {"epss_score": 0.89461, "epss_percentile": 0.99527}, "CVE-2012-0298": {"epss_score": 0.10981, "epss_percentile": 0.93182}, "CVE-2012-0299": {"epss_score": 0.8227, "epss_percentile": 0.99183}, "CVE-2012-0300": {"epss_score": 0.00434, "epss_percentile": 0.62311}, "CVE-2012-0301": {"epss_score": 0.01189, "epss_percentile": 0.78371}, "CVE-2012-0302": {"epss_score": 0.01275, "epss_percentile": 0.79102}, "CVE-2012-0303": {"epss_score": 0.00283, "epss_percentile": 0.51404}, "CVE-2012-0304": {"epss_score": 0.00042, "epss_percentile": 0.12935}, "CVE-2012-0305": {"epss_score": 0.00075, "epss_percentile": 0.2297}, "CVE-2012-0306": {"epss_score": 0.02067, "epss_percentile": 0.83461}, "CVE-2012-0307": {"epss_score": 0.00609, "epss_percentile": 0.69129}, "CVE-2012-0308": {"epss_score": 0.00224, "epss_percentile": 0.45057}, "CVE-2012-0309": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2012-0310": {"epss_score": 0.01087, "epss_percentile": 0.77431}, "CVE-2012-0311": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-0312": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-0313": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-0314": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2012-0315": {"epss_score": 0.00558, "epss_percentile": 0.67578}, "CVE-2012-0316": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-0317": {"epss_score": 0.00295, "epss_percentile": 0.52518}, "CVE-2012-0318": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2012-0319": {"epss_score": 0.02674, "epss_percentile": 0.85399}, "CVE-2012-0320": {"epss_score": 0.01207, "epss_percentile": 0.78528}, "CVE-2012-0321": {"epss_score": 0.00055, "epss_percentile": 0.17527}, "CVE-2012-0322": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-0323": {"epss_score": 0.00336, "epss_percentile": 0.5594}, "CVE-2012-0324": {"epss_score": 0.00206, "epss_percentile": 0.42919}, "CVE-2012-0325": {"epss_score": 0.00206, "epss_percentile": 0.42919}, "CVE-2012-0326": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2012-0327": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2012-0328": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2012-0329": {"epss_score": 0.01609, "epss_percentile": 0.8132}, "CVE-2012-0330": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-0331": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2012-0333": {"epss_score": 0.00274, "epss_percentile": 0.50535}, "CVE-2012-0334": {"epss_score": 0.00064, "epss_percentile": 0.20348}, "CVE-2012-0335": {"epss_score": 0.00423, "epss_percentile": 0.61605}, "CVE-2012-0337": {"epss_score": 0.00246, "epss_percentile": 0.47757}, "CVE-2012-0338": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2012-0339": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2012-0340": {"epss_score": 0.00141, "epss_percentile": 0.34911}, "CVE-2012-0352": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-0353": {"epss_score": 0.02018, "epss_percentile": 0.83285}, "CVE-2012-0354": {"epss_score": 0.02018, "epss_percentile": 0.83285}, "CVE-2012-0355": {"epss_score": 0.01525, "epss_percentile": 0.80858}, "CVE-2012-0356": {"epss_score": 0.02272, "epss_percentile": 0.84217}, "CVE-2012-0358": {"epss_score": 0.0987, "epss_percentile": 0.92745}, "CVE-2012-0359": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-0360": {"epss_score": 0.00771, "epss_percentile": 0.73019}, "CVE-2012-0361": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-0362": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2012-0363": {"epss_score": 0.01922, "epss_percentile": 0.82906}, "CVE-2012-0364": {"epss_score": 0.00336, "epss_percentile": 0.55926}, "CVE-2012-0365": {"epss_score": 0.00252, "epss_percentile": 0.48351}, "CVE-2012-0366": {"epss_score": 0.00408, "epss_percentile": 0.60638}, "CVE-2012-0367": {"epss_score": 0.03552, "epss_percentile": 0.87344}, "CVE-2012-0368": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-0369": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-0370": {"epss_score": 0.00393, "epss_percentile": 0.59734}, "CVE-2012-0371": {"epss_score": 0.00484, "epss_percentile": 0.64645}, "CVE-2012-0376": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-0378": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-0381": {"epss_score": 0.03518, "epss_percentile": 0.8728}, "CVE-2012-0382": {"epss_score": 0.04545, "epss_percentile": 0.88833}, "CVE-2012-0383": {"epss_score": 0.0215, "epss_percentile": 0.83782}, "CVE-2012-0384": {"epss_score": 0.00453, "epss_percentile": 0.63216}, "CVE-2012-0385": {"epss_score": 0.02138, "epss_percentile": 0.83738}, "CVE-2012-0386": {"epss_score": 0.02138, "epss_percentile": 0.83738}, "CVE-2012-0387": {"epss_score": 0.0215, "epss_percentile": 0.83782}, "CVE-2012-0388": {"epss_score": 0.00801, "epss_percentile": 0.73578}, "CVE-2012-0389": {"epss_score": 0.33839, "epss_percentile": 0.96809}, "CVE-2012-0390": {"epss_score": 0.00262, "epss_percentile": 0.49351}, "CVE-2012-0391": {"epss_score": 0.89613, "epss_percentile": 0.99534}, "CVE-2012-0392": {"epss_score": 0.91467, "epss_percentile": 0.99646}, "CVE-2012-0393": {"epss_score": 0.79777, "epss_percentile": 0.99054}, "CVE-2012-0394": {"epss_score": 0.92749, "epss_percentile": 0.99741}, "CVE-2012-0395": {"epss_score": 0.04567, "epss_percentile": 0.88859}, "CVE-2012-0396": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2012-0397": {"epss_score": 0.04685, "epss_percentile": 0.89007}, "CVE-2012-0398": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2012-0399": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-0400": {"epss_score": 0.00961, "epss_percentile": 0.75977}, "CVE-2012-0401": {"epss_score": 0.0039, "epss_percentile": 0.59504}, "CVE-2012-0402": {"epss_score": 0.00859, "epss_percentile": 0.74516}, "CVE-2012-0403": {"epss_score": 0.00325, "epss_percentile": 0.54978}, "CVE-2012-0404": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-0406": {"epss_score": 0.14529, "epss_percentile": 0.94231}, "CVE-2012-0407": {"epss_score": 0.09609, "epss_percentile": 0.92621}, "CVE-2012-0409": {"epss_score": 0.04394, "epss_percentile": 0.88638}, "CVE-2012-0410": {"epss_score": 0.03832, "epss_percentile": 0.87808}, "CVE-2012-0411": {"epss_score": 0.07626, "epss_percentile": 0.91581}, "CVE-2012-0414": {"epss_score": 0.01148, "epss_percentile": 0.78015}, "CVE-2012-0417": {"epss_score": 0.0623, "epss_percentile": 0.90587}, "CVE-2012-0418": {"epss_score": 0.06305, "epss_percentile": 0.9066}, "CVE-2012-0419": {"epss_score": 0.78808, "epss_percentile": 0.99004}, "CVE-2012-0420": {"epss_score": 0.00054, "epss_percentile": 0.17077}, "CVE-2012-0421": {"epss_score": 0.00067, "epss_percentile": 0.21168}, "CVE-2012-0425": {"epss_score": 0.00251, "epss_percentile": 0.48274}, "CVE-2012-0426": {"epss_score": 0.00029, "epss_percentile": 0.07784}, "CVE-2012-0427": {"epss_score": 0.00047, "epss_percentile": 0.14504}, "CVE-2012-0428": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2012-0429": {"epss_score": 0.00625, "epss_percentile": 0.69585}, "CVE-2012-0430": {"epss_score": 0.00277, "epss_percentile": 0.50794}, "CVE-2012-0432": {"epss_score": 0.85177, "epss_percentile": 0.99322}, "CVE-2012-0433": {"epss_score": 0.00033, "epss_percentile": 0.09407}, "CVE-2012-0434": {"epss_score": 0.00216, "epss_percentile": 0.44127}, "CVE-2012-0435": {"epss_score": 0.0069, "epss_percentile": 0.7124}, "CVE-2012-0439": {"epss_score": 0.68302, "epss_percentile": 0.9854}, "CVE-2012-0440": {"epss_score": 0.00182, "epss_percentile": 0.40183}, "CVE-2012-0441": {"epss_score": 0.03785, "epss_percentile": 0.87724}, "CVE-2012-0442": {"epss_score": 0.01441, "epss_percentile": 0.80302}, "CVE-2012-0443": {"epss_score": 0.02624, "epss_percentile": 0.85262}, "CVE-2012-0444": {"epss_score": 0.08566, "epss_percentile": 0.92128}, "CVE-2012-0445": {"epss_score": 0.00536, "epss_percentile": 0.66844}, "CVE-2012-0446": {"epss_score": 0.00431, "epss_percentile": 0.62053}, "CVE-2012-0447": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2012-0448": {"epss_score": 0.00364, "epss_percentile": 0.57906}, "CVE-2012-0449": {"epss_score": 0.10935, "epss_percentile": 0.93164}, "CVE-2012-0450": {"epss_score": 0.00071, "epss_percentile": 0.22023}, "CVE-2012-0451": {"epss_score": 0.0021, "epss_percentile": 0.43427}, "CVE-2012-0452": {"epss_score": 0.01801, "epss_percentile": 0.82327}, "CVE-2012-0453": {"epss_score": 0.00176, "epss_percentile": 0.39384}, "CVE-2012-0454": {"epss_score": 0.025, "epss_percentile": 0.84916}, "CVE-2012-0455": {"epss_score": 0.01547, "epss_percentile": 0.80973}, "CVE-2012-0456": {"epss_score": 0.01076, "epss_percentile": 0.77324}, "CVE-2012-0457": {"epss_score": 0.09636, "epss_percentile": 0.92634}, "CVE-2012-0458": {"epss_score": 0.02782, "epss_percentile": 0.85653}, "CVE-2012-0459": {"epss_score": 0.03436, "epss_percentile": 0.87133}, "CVE-2012-0460": {"epss_score": 0.01798, "epss_percentile": 0.82313}, "CVE-2012-0461": {"epss_score": 0.0157, "epss_percentile": 0.81085}, "CVE-2012-0462": {"epss_score": 0.01977, "epss_percentile": 0.83128}, "CVE-2012-0463": {"epss_score": 0.04347, "epss_percentile": 0.88579}, "CVE-2012-0464": {"epss_score": 0.02116, "epss_percentile": 0.83659}, "CVE-2012-0465": {"epss_score": 0.00243, "epss_percentile": 0.47457}, "CVE-2012-0466": {"epss_score": 0.00319, "epss_percentile": 0.54557}, "CVE-2012-0467": {"epss_score": 0.02914, "epss_percentile": 0.85978}, "CVE-2012-0468": {"epss_score": 0.02458, "epss_percentile": 0.84815}, "CVE-2012-0469": {"epss_score": 0.28847, "epss_percentile": 0.96394}, "CVE-2012-0470": {"epss_score": 0.13594, "epss_percentile": 0.94006}, "CVE-2012-0471": {"epss_score": 0.00722, "epss_percentile": 0.7199}, "CVE-2012-0472": {"epss_score": 0.01525, "epss_percentile": 0.8086}, "CVE-2012-0473": {"epss_score": 0.00712, "epss_percentile": 0.7176}, "CVE-2012-0474": {"epss_score": 0.00685, "epss_percentile": 0.71135}, "CVE-2012-0475": {"epss_score": 0.00289, "epss_percentile": 0.52022}, "CVE-2012-0477": {"epss_score": 0.00722, "epss_percentile": 0.7199}, "CVE-2012-0478": {"epss_score": 0.00761, "epss_percentile": 0.72829}, "CVE-2012-0479": {"epss_score": 0.00775, "epss_percentile": 0.73087}, "CVE-2012-0484": {"epss_score": 0.00475, "epss_percentile": 0.64184}, "CVE-2012-0485": {"epss_score": 0.0097, "epss_percentile": 0.76112}, "CVE-2012-0486": {"epss_score": 0.00745, "epss_percentile": 0.72525}, "CVE-2012-0487": {"epss_score": 0.00634, "epss_percentile": 0.6981}, "CVE-2012-0488": {"epss_score": 0.00634, "epss_percentile": 0.6981}, "CVE-2012-0489": {"epss_score": 0.00634, "epss_percentile": 0.6981}, "CVE-2012-0490": {"epss_score": 0.00992, "epss_percentile": 0.76395}, "CVE-2012-0491": {"epss_score": 0.00634, "epss_percentile": 0.6981}, "CVE-2012-0492": {"epss_score": 0.00822, "epss_percentile": 0.73915}, "CVE-2012-0493": {"epss_score": 0.00537, "epss_percentile": 0.6692}, "CVE-2012-0494": {"epss_score": 0.00045, "epss_percentile": 0.14068}, "CVE-2012-0495": {"epss_score": 0.00634, "epss_percentile": 0.6981}, "CVE-2012-0496": {"epss_score": 0.00267, "epss_percentile": 0.4996}, "CVE-2012-0497": {"epss_score": 0.0484, "epss_percentile": 0.89201}, "CVE-2012-0498": {"epss_score": 0.08035, "epss_percentile": 0.91846}, "CVE-2012-0499": {"epss_score": 0.10203, "epss_percentile": 0.92891}, "CVE-2012-0500": {"epss_score": 0.74853, "epss_percentile": 0.98821}, "CVE-2012-0501": {"epss_score": 0.05146, "epss_percentile": 0.89542}, "CVE-2012-0502": {"epss_score": 0.01874, "epss_percentile": 0.82646}, "CVE-2012-0503": {"epss_score": 0.01983, "epss_percentile": 0.83148}, "CVE-2012-0504": {"epss_score": 0.01375, "epss_percentile": 0.79832}, "CVE-2012-0505": {"epss_score": 0.01983, "epss_percentile": 0.83148}, "CVE-2012-0506": {"epss_score": 0.01485, "epss_percentile": 0.80601}, "CVE-2012-0507": {"epss_score": 0.93653, "epss_percentile": 0.99831}, "CVE-2012-0508": {"epss_score": 0.01706, "epss_percentile": 0.81857}, "CVE-2012-0509": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2012-0510": {"epss_score": 0.00772, "epss_percentile": 0.73048}, "CVE-2012-0511": {"epss_score": 0.00351, "epss_percentile": 0.57071}, "CVE-2012-0512": {"epss_score": 0.00185, "epss_percentile": 0.40532}, "CVE-2012-0513": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2012-0514": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2012-0515": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2012-0516": {"epss_score": 0.00657, "epss_percentile": 0.70459}, "CVE-2012-0517": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2012-0518": {"epss_score": 0.24255, "epss_percentile": 0.95897}, "CVE-2012-0519": {"epss_score": 0.00668, "epss_percentile": 0.70723}, "CVE-2012-0520": {"epss_score": 0.00483, "epss_percentile": 0.64571}, "CVE-2012-0521": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2012-0522": {"epss_score": 0.0039, "epss_percentile": 0.59552}, "CVE-2012-0523": {"epss_score": 0.00159, "epss_percentile": 0.37404}, "CVE-2012-0524": {"epss_score": 0.00197, "epss_percentile": 0.4186}, "CVE-2012-0525": {"epss_score": 0.00209, "epss_percentile": 0.43394}, "CVE-2012-0526": {"epss_score": 0.00483, "epss_percentile": 0.64571}, "CVE-2012-0527": {"epss_score": 0.00483, "epss_percentile": 0.64571}, "CVE-2012-0528": {"epss_score": 0.00351, "epss_percentile": 0.57071}, "CVE-2012-0529": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2012-0530": {"epss_score": 0.00319, "epss_percentile": 0.54558}, "CVE-2012-0531": {"epss_score": 0.00319, "epss_percentile": 0.54558}, "CVE-2012-0532": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2012-0533": {"epss_score": 0.00319, "epss_percentile": 0.54558}, "CVE-2012-0534": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2012-0535": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2012-0536": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2012-0537": {"epss_score": 0.00442, "epss_percentile": 0.62721}, "CVE-2012-0538": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2012-0539": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2012-0540": {"epss_score": 0.00864, "epss_percentile": 0.74606}, "CVE-2012-0541": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2012-0542": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2012-0543": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2012-0544": {"epss_score": 0.00363, "epss_percentile": 0.5785}, "CVE-2012-0545": {"epss_score": 0.00535, "epss_percentile": 0.66837}, "CVE-2012-0546": {"epss_score": 0.00552, "epss_percentile": 0.67382}, "CVE-2012-0547": {"epss_score": 0.09871, "epss_percentile": 0.92745}, "CVE-2012-0548": {"epss_score": 0.00184, "epss_percentile": 0.40414}, "CVE-2012-0549": {"epss_score": 0.8507, "epss_percentile": 0.99315}, "CVE-2012-0550": {"epss_score": 0.15325, "epss_percentile": 0.94411}, "CVE-2012-0551": {"epss_score": 0.40661, "epss_percentile": 0.9723}, "CVE-2012-0552": {"epss_score": 0.00753, "epss_percentile": 0.7267}, "CVE-2012-0553": {"epss_score": 0.00712, "epss_percentile": 0.71774}, "CVE-2012-0554": {"epss_score": 0.00874, "epss_percentile": 0.74767}, "CVE-2012-0555": {"epss_score": 0.00874, "epss_percentile": 0.74767}, "CVE-2012-0556": {"epss_score": 0.00874, "epss_percentile": 0.74767}, "CVE-2012-0557": {"epss_score": 0.00874, "epss_percentile": 0.74767}, "CVE-2012-0558": {"epss_score": 0.00407, "epss_percentile": 0.60589}, "CVE-2012-0559": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2012-0560": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2012-0561": {"epss_score": 0.00372, "epss_percentile": 0.58437}, "CVE-2012-0562": {"epss_score": 0.00372, "epss_percentile": 0.58437}, "CVE-2012-0563": {"epss_score": 0.00064, "epss_percentile": 0.2011}, "CVE-2012-0564": {"epss_score": 0.00848, "epss_percentile": 0.74363}, "CVE-2012-0565": {"epss_score": 0.00319, "epss_percentile": 0.54558}, "CVE-2012-0566": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2012-0567": {"epss_score": 0.00535, "epss_percentile": 0.66837}, "CVE-2012-0568": {"epss_score": 0.00061, "epss_percentile": 0.19284}, "CVE-2012-0569": {"epss_score": 0.0006, "epss_percentile": 0.18955}, "CVE-2012-0570": {"epss_score": 0.00091, "epss_percentile": 0.26287}, "CVE-2012-0571": {"epss_score": 0.00535, "epss_percentile": 0.66837}, "CVE-2012-0572": {"epss_score": 0.0064, "epss_percentile": 0.69968}, "CVE-2012-0573": {"epss_score": 0.00363, "epss_percentile": 0.5785}, "CVE-2012-0574": {"epss_score": 0.00694, "epss_percentile": 0.71345}, "CVE-2012-0575": {"epss_score": 0.00894, "epss_percentile": 0.75086}, "CVE-2012-0576": {"epss_score": 0.00431, "epss_percentile": 0.62059}, "CVE-2012-0577": {"epss_score": 0.00745, "epss_percentile": 0.72527}, "CVE-2012-0578": {"epss_score": 0.0064, "epss_percentile": 0.69968}, "CVE-2012-0579": {"epss_score": 0.00363, "epss_percentile": 0.5785}, "CVE-2012-0580": {"epss_score": 0.00403, "epss_percentile": 0.6034}, "CVE-2012-0581": {"epss_score": 0.00499, "epss_percentile": 0.65259}, "CVE-2012-0582": {"epss_score": 0.00279, "epss_percentile": 0.50946}, "CVE-2012-0583": {"epss_score": 0.00586, "epss_percentile": 0.68434}, "CVE-2012-0584": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2012-0585": {"epss_score": 0.00775, "epss_percentile": 0.73087}, "CVE-2012-0586": {"epss_score": 0.00588, "epss_percentile": 0.68503}, "CVE-2012-0587": {"epss_score": 0.00588, "epss_percentile": 0.68503}, "CVE-2012-0588": {"epss_score": 0.00588, "epss_percentile": 0.68503}, "CVE-2012-0589": {"epss_score": 0.00588, "epss_percentile": 0.68503}, "CVE-2012-0590": {"epss_score": 0.00588, "epss_percentile": 0.68503}, "CVE-2012-0591": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0592": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0593": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0594": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0595": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0596": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0597": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0598": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0599": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0600": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0601": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0602": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0603": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0604": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0605": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0606": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0607": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0608": {"epss_score": 0.01764, "epss_percentile": 0.82161}, "CVE-2012-0609": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0610": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0611": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0612": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0613": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0614": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0615": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0616": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0617": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2012-0618": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0619": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0620": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0621": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0622": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0623": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0624": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0625": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0626": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0627": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0628": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0629": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0630": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0631": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0632": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0633": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0634": {"epss_score": 0.01164, "epss_percentile": 0.78168}, "CVE-2012-0635": {"epss_score": 0.01837, "epss_percentile": 0.8248}, "CVE-2012-0636": {"epss_score": 0.00948, "epss_percentile": 0.75836}, "CVE-2012-0637": {"epss_score": 0.00948, "epss_percentile": 0.75836}, "CVE-2012-0638": {"epss_score": 0.00948, "epss_percentile": 0.75836}, "CVE-2012-0639": {"epss_score": 0.00948, "epss_percentile": 0.75836}, "CVE-2012-0640": {"epss_score": 0.00291, "epss_percentile": 0.52169}, "CVE-2012-0641": {"epss_score": 0.00556, "epss_percentile": 0.67514}, "CVE-2012-0642": {"epss_score": 0.04204, "epss_percentile": 0.88393}, "CVE-2012-0643": {"epss_score": 0.01831, "epss_percentile": 0.82449}, "CVE-2012-0644": {"epss_score": 0.00053, "epss_percentile": 0.17007}, "CVE-2012-0645": {"epss_score": 0.00092, "epss_percentile": 0.26504}, "CVE-2012-0646": {"epss_score": 0.08073, "epss_percentile": 0.91867}, "CVE-2012-0647": {"epss_score": 0.00276, "epss_percentile": 0.50761}, "CVE-2012-0648": {"epss_score": 0.00948, "epss_percentile": 0.75836}, "CVE-2012-0649": {"epss_score": 0.00115, "epss_percentile": 0.3097}, "CVE-2012-0650": {"epss_score": 0.01399, "epss_percentile": 0.79998}, "CVE-2012-0651": {"epss_score": 0.00493, "epss_percentile": 0.65054}, "CVE-2012-0652": {"epss_score": 0.00104, "epss_percentile": 0.2913}, "CVE-2012-0654": {"epss_score": 0.00562, "epss_percentile": 0.67684}, "CVE-2012-0655": {"epss_score": 0.00227, "epss_percentile": 0.45444}, "CVE-2012-0656": {"epss_score": 0.00115, "epss_percentile": 0.3097}, "CVE-2012-0657": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2012-0658": {"epss_score": 0.019, "epss_percentile": 0.82772}, "CVE-2012-0659": {"epss_score": 0.01774, "epss_percentile": 0.82209}, "CVE-2012-0660": {"epss_score": 0.01774, "epss_percentile": 0.82209}, "CVE-2012-0661": {"epss_score": 0.01313, "epss_percentile": 0.79382}, "CVE-2012-0662": {"epss_score": 0.01739, "epss_percentile": 0.82039}, "CVE-2012-0663": {"epss_score": 0.74043, "epss_percentile": 0.98785}, "CVE-2012-0664": {"epss_score": 0.05677, "epss_percentile": 0.90112}, "CVE-2012-0665": {"epss_score": 0.03972, "epss_percentile": 0.88037}, "CVE-2012-0666": {"epss_score": 0.05074, "epss_percentile": 0.89466}, "CVE-2012-0667": {"epss_score": 0.04315, "epss_percentile": 0.88537}, "CVE-2012-0668": {"epss_score": 0.02504, "epss_percentile": 0.84933}, "CVE-2012-0669": {"epss_score": 0.04452, "epss_percentile": 0.88707}, "CVE-2012-0670": {"epss_score": 0.07138, "epss_percentile": 0.91275}, "CVE-2012-0671": {"epss_score": 0.07508, "epss_percentile": 0.91511}, "CVE-2012-0672": {"epss_score": 0.01074, "epss_percentile": 0.77302}, "CVE-2012-0674": {"epss_score": 0.00359, "epss_percentile": 0.57605}, "CVE-2012-0675": {"epss_score": 0.00505, "epss_percentile": 0.65603}, "CVE-2012-0676": {"epss_score": 0.00677, "epss_percentile": 0.70962}, "CVE-2012-0677": {"epss_score": 0.22736, "epss_percentile": 0.95676}, "CVE-2012-0678": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2012-0679": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2012-0680": {"epss_score": 0.00498, "epss_percentile": 0.65234}, "CVE-2012-0681": {"epss_score": 0.00493, "epss_percentile": 0.65054}, "CVE-2012-0682": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-0683": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-0684": {"epss_score": 0.02392, "epss_percentile": 0.84605}, "CVE-2012-0685": {"epss_score": 0.02392, "epss_percentile": 0.84605}, "CVE-2012-0687": {"epss_score": 0.00387, "epss_percentile": 0.59332}, "CVE-2012-0688": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2012-0689": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2012-0690": {"epss_score": 0.00218, "epss_percentile": 0.44355}, "CVE-2012-0691": {"epss_score": 0.00058, "epss_percentile": 0.18506}, "CVE-2012-0692": {"epss_score": 0.00058, "epss_percentile": 0.18506}, "CVE-2012-0693": {"epss_score": 0.00345, "epss_percentile": 0.56577}, "CVE-2012-0694": {"epss_score": 0.83749, "epss_percentile": 0.99261}, "CVE-2012-0695": {"epss_score": 0.00224, "epss_percentile": 0.45068}, "CVE-2012-0696": {"epss_score": 0.00463, "epss_percentile": 0.63697}, "CVE-2012-0697": {"epss_score": 0.01861, "epss_percentile": 0.82592}, "CVE-2012-0698": {"epss_score": 0.18868, "epss_percentile": 0.95082}, "CVE-2012-0699": {"epss_score": 0.00491, "epss_percentile": 0.64978}, "CVE-2012-0700": {"epss_score": 0.00049, "epss_percentile": 0.15466}, "CVE-2012-0701": {"epss_score": 0.00349, "epss_percentile": 0.56905}, "CVE-2012-0702": {"epss_score": 0.00146, "epss_percentile": 0.35541}, "CVE-2012-0703": {"epss_score": 0.00201, "epss_percentile": 0.42329}, "CVE-2012-0705": {"epss_score": 0.00558, "epss_percentile": 0.67561}, "CVE-2012-0706": {"epss_score": 0.00212, "epss_percentile": 0.43785}, "CVE-2012-0707": {"epss_score": 0.00229, "epss_percentile": 0.45559}, "CVE-2012-0708": {"epss_score": 0.66566, "epss_percentile": 0.98469}, "CVE-2012-0709": {"epss_score": 0.00337, "epss_percentile": 0.56046}, "CVE-2012-0710": {"epss_score": 0.01646, "epss_percentile": 0.81537}, "CVE-2012-0711": {"epss_score": 0.07098, "epss_percentile": 0.91248}, "CVE-2012-0712": {"epss_score": 0.00982, "epss_percentile": 0.76291}, "CVE-2012-0713": {"epss_score": 0.0013, "epss_percentile": 0.33316}, "CVE-2012-0714": {"epss_score": 0.00204, "epss_percentile": 0.42592}, "CVE-2012-0715": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2012-0716": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2012-0717": {"epss_score": 0.00066, "epss_percentile": 0.20751}, "CVE-2012-0718": {"epss_score": 0.00192, "epss_percentile": 0.4132}, "CVE-2012-0719": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2012-0720": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2012-0723": {"epss_score": 0.00065, "epss_percentile": 0.20661}, "CVE-2012-0724": {"epss_score": 0.01005, "epss_percentile": 0.76541}, "CVE-2012-0725": {"epss_score": 0.01005, "epss_percentile": 0.76541}, "CVE-2012-0726": {"epss_score": 0.00519, "epss_percentile": 0.66177}, "CVE-2012-0727": {"epss_score": 0.003, "epss_percentile": 0.52976}, "CVE-2012-0728": {"epss_score": 0.003, "epss_percentile": 0.52976}, "CVE-2012-0729": {"epss_score": 0.0048, "epss_percentile": 0.64471}, "CVE-2012-0730": {"epss_score": 0.00124, "epss_percentile": 0.32421}, "CVE-2012-0731": {"epss_score": 0.00275, "epss_percentile": 0.50629}, "CVE-2012-0732": {"epss_score": 0.00181, "epss_percentile": 0.40096}, "CVE-2012-0733": {"epss_score": 0.00411, "epss_percentile": 0.60872}, "CVE-2012-0734": {"epss_score": 0.00516, "epss_percentile": 0.66033}, "CVE-2012-0735": {"epss_score": 0.00516, "epss_percentile": 0.66033}, "CVE-2012-0736": {"epss_score": 0.02335, "epss_percentile": 0.84415}, "CVE-2012-0737": {"epss_score": 0.00208, "epss_percentile": 0.43262}, "CVE-2012-0738": {"epss_score": 0.00139, "epss_percentile": 0.34614}, "CVE-2012-0740": {"epss_score": 0.00478, "epss_percentile": 0.64405}, "CVE-2012-0741": {"epss_score": 0.00139, "epss_percentile": 0.34614}, "CVE-2012-0742": {"epss_score": 0.0005, "epss_percentile": 0.15971}, "CVE-2012-0743": {"epss_score": 0.01342, "epss_percentile": 0.79598}, "CVE-2012-0744": {"epss_score": 0.05964, "epss_percentile": 0.90368}, "CVE-2012-0745": {"epss_score": 0.00082, "epss_percentile": 0.24549}, "CVE-2012-0746": {"epss_score": 0.0018, "epss_percentile": 0.39969}, "CVE-2012-0747": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2012-0748": {"epss_score": 0.00126, "epss_percentile": 0.32779}, "CVE-2012-0751": {"epss_score": 0.04236, "epss_percentile": 0.88429}, "CVE-2012-0752": {"epss_score": 0.06419, "epss_percentile": 0.90747}, "CVE-2012-0753": {"epss_score": 0.0211, "epss_percentile": 0.83645}, "CVE-2012-0754": {"epss_score": 0.92787, "epss_percentile": 0.99749}, "CVE-2012-0755": {"epss_score": 0.05025, "epss_percentile": 0.89409}, "CVE-2012-0756": {"epss_score": 0.05025, "epss_percentile": 0.89409}, "CVE-2012-0757": {"epss_score": 0.05764, "epss_percentile": 0.90187}, "CVE-2012-0758": {"epss_score": 0.06827, "epss_percentile": 0.91051}, "CVE-2012-0759": {"epss_score": 0.06981, "epss_percentile": 0.91159}, "CVE-2012-0760": {"epss_score": 0.05764, "epss_percentile": 0.90187}, "CVE-2012-0761": {"epss_score": 0.10048, "epss_percentile": 0.92827}, "CVE-2012-0762": {"epss_score": 0.10048, "epss_percentile": 0.92827}, "CVE-2012-0763": {"epss_score": 0.05764, "epss_percentile": 0.90187}, "CVE-2012-0764": {"epss_score": 0.09409, "epss_percentile": 0.92535}, "CVE-2012-0765": {"epss_score": 0.01633, "epss_percentile": 0.81463}, "CVE-2012-0766": {"epss_score": 0.05764, "epss_percentile": 0.90187}, "CVE-2012-0767": {"epss_score": 0.08125, "epss_percentile": 0.91892}, "CVE-2012-0768": {"epss_score": 0.06076, "epss_percentile": 0.90457}, "CVE-2012-0769": {"epss_score": 0.02169, "epss_percentile": 0.83864}, "CVE-2012-0770": {"epss_score": 0.0147, "epss_percentile": 0.80496}, "CVE-2012-0771": {"epss_score": 0.06068, "epss_percentile": 0.90449}, "CVE-2012-0772": {"epss_score": 0.19496, "epss_percentile": 0.95193}, "CVE-2012-0773": {"epss_score": 0.01232, "epss_percentile": 0.78739}, "CVE-2012-0774": {"epss_score": 0.36793, "epss_percentile": 0.97001}, "CVE-2012-0775": {"epss_score": 0.22627, "epss_percentile": 0.95661}, "CVE-2012-0776": {"epss_score": 0.33042, "epss_percentile": 0.96742}, "CVE-2012-0777": {"epss_score": 0.08459, "epss_percentile": 0.92062}, "CVE-2012-0778": {"epss_score": 0.26892, "epss_percentile": 0.96189}, "CVE-2012-0779": {"epss_score": 0.90067, "epss_percentile": 0.9956}, "CVE-2012-0780": {"epss_score": 0.40346, "epss_percentile": 0.97213}, "CVE-2012-0781": {"epss_score": 0.03783, "epss_percentile": 0.87723}, "CVE-2012-0782": {"epss_score": 0.01187, "epss_percentile": 0.78355}, "CVE-2012-0785": {"epss_score": 0.01939, "epss_percentile": 0.82971}, "CVE-2012-0786": {"epss_score": 0.00015, "epss_percentile": 0.0242}, "CVE-2012-0787": {"epss_score": 0.00118, "epss_percentile": 0.31488}, "CVE-2012-0788": {"epss_score": 0.06865, "epss_percentile": 0.91082}, "CVE-2012-0789": {"epss_score": 0.07865, "epss_percentile": 0.91729}, "CVE-2012-0790": {"epss_score": 0.0048, "epss_percentile": 0.64461}, "CVE-2012-0791": {"epss_score": 0.00749, "epss_percentile": 0.72612}, "CVE-2012-0792": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2012-0793": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2012-0794": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-0795": {"epss_score": 0.00606, "epss_percentile": 0.69028}, "CVE-2012-0796": {"epss_score": 0.00195, "epss_percentile": 0.41688}, "CVE-2012-0797": {"epss_score": 0.00143, "epss_percentile": 0.35211}, "CVE-2012-0798": {"epss_score": 0.00193, "epss_percentile": 0.41427}, "CVE-2012-0799": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-0800": {"epss_score": 0.00068, "epss_percentile": 0.2136}, "CVE-2012-0801": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2012-0802": {"epss_score": 0.05749, "epss_percentile": 0.90177}, "CVE-2012-0803": {"epss_score": 0.00671, "epss_percentile": 0.7079}, "CVE-2012-0804": {"epss_score": 0.02507, "epss_percentile": 0.84938}, "CVE-2012-0805": {"epss_score": 0.01649, "epss_percentile": 0.81556}, "CVE-2012-0806": {"epss_score": 0.04519, "epss_percentile": 0.88797}, "CVE-2012-0807": {"epss_score": 0.04812, "epss_percentile": 0.89169}, "CVE-2012-0808": {"epss_score": 0.00035, "epss_percentile": 0.09857}, "CVE-2012-0809": {"epss_score": 0.46663, "epss_percentile": 0.97554}, "CVE-2012-0810": {"epss_score": 0.00049, "epss_percentile": 0.15457}, "CVE-2012-0811": {"epss_score": 0.00517, "epss_percentile": 0.66064}, "CVE-2012-0812": {"epss_score": 0.00579, "epss_percentile": 0.68229}, "CVE-2012-0813": {"epss_score": 0.00074, "epss_percentile": 0.22722}, "CVE-2012-0814": {"epss_score": 0.00345, "epss_percentile": 0.56582}, "CVE-2012-0815": {"epss_score": 0.06991, "epss_percentile": 0.91168}, "CVE-2012-0817": {"epss_score": 0.07502, "epss_percentile": 0.91506}, "CVE-2012-0818": {"epss_score": 0.01376, "epss_percentile": 0.79839}, "CVE-2012-0819": {"epss_score": 0.00016, "epss_percentile": 0.02738}, "CVE-2012-0820": {"epss_score": 0.00015, "epss_percentile": 0.02198}, "CVE-2012-0821": {"epss_score": 0.00016, "epss_percentile": 0.02738}, "CVE-2012-0822": {"epss_score": 0.00015, "epss_percentile": 0.02198}, "CVE-2012-0823": {"epss_score": 0.01214, "epss_percentile": 0.78577}, "CVE-2012-0824": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2012-0825": {"epss_score": 0.00447, "epss_percentile": 0.62983}, "CVE-2012-0826": {"epss_score": 0.00135, "epss_percentile": 0.34026}, "CVE-2012-0827": {"epss_score": 0.00164, "epss_percentile": 0.3796}, "CVE-2012-0828": {"epss_score": 0.05888, "epss_percentile": 0.90297}, "CVE-2012-0829": {"epss_score": 0.00222, "epss_percentile": 0.44747}, "CVE-2012-0830": {"epss_score": 0.26594, "epss_percentile": 0.9616}, "CVE-2012-0831": {"epss_score": 0.10633, "epss_percentile": 0.93055}, "CVE-2012-0833": {"epss_score": 0.00244, "epss_percentile": 0.47575}, "CVE-2012-0834": {"epss_score": 0.07465, "epss_percentile": 0.91488}, "CVE-2012-0835": {"epss_score": 0.00011, "epss_percentile": 0.01104}, "CVE-2012-0836": {"epss_score": 0.00011, "epss_percentile": 0.01104}, "CVE-2012-0837": {"epss_score": 0.00011, "epss_percentile": 0.01104}, "CVE-2012-0838": {"epss_score": 0.25898, "epss_percentile": 0.96091}, "CVE-2012-0839": {"epss_score": 0.00974, "epss_percentile": 0.7617}, "CVE-2012-0840": {"epss_score": 0.37182, "epss_percentile": 0.97025}, "CVE-2012-0841": {"epss_score": 0.00586, "epss_percentile": 0.68437}, "CVE-2012-0842": {"epss_score": 0.00105, "epss_percentile": 0.29349}, "CVE-2012-0843": {"epss_score": 0.00146, "epss_percentile": 0.35609}, "CVE-2012-0844": {"epss_score": 0.00146, "epss_percentile": 0.35609}, "CVE-2012-0845": {"epss_score": 0.03255, "epss_percentile": 0.86759}, "CVE-2012-0846": {"epss_score": 0.00643, "epss_percentile": 0.70058}, "CVE-2012-0847": {"epss_score": 0.00615, "epss_percentile": 0.69314}, "CVE-2012-0848": {"epss_score": 0.00905, "epss_percentile": 0.75246}, "CVE-2012-0849": {"epss_score": 0.0098, "epss_percentile": 0.76268}, "CVE-2012-0850": {"epss_score": 0.00781, "epss_percentile": 0.73177}, "CVE-2012-0851": {"epss_score": 0.02167, "epss_percentile": 0.83854}, "CVE-2012-0852": {"epss_score": 0.0228, "epss_percentile": 0.84241}, "CVE-2012-0853": {"epss_score": 0.01195, "epss_percentile": 0.78428}, "CVE-2012-0854": {"epss_score": 0.01307, "epss_percentile": 0.79344}, "CVE-2012-0855": {"epss_score": 0.0133, "epss_percentile": 0.79512}, "CVE-2012-0856": {"epss_score": 0.01141, "epss_percentile": 0.77963}, "CVE-2012-0857": {"epss_score": 0.00658, "epss_percentile": 0.70484}, "CVE-2012-0858": {"epss_score": 0.02795, "epss_percentile": 0.85678}, "CVE-2012-0859": {"epss_score": 0.02365, "epss_percentile": 0.84513}, "CVE-2012-0860": {"epss_score": 0.00054, "epss_percentile": 0.17301}, "CVE-2012-0861": {"epss_score": 0.0055, "epss_percentile": 0.67343}, "CVE-2012-0862": {"epss_score": 0.00535, "epss_percentile": 0.66837}, "CVE-2012-0863": {"epss_score": 0.00036, "epss_percentile": 0.10312}, "CVE-2012-0864": {"epss_score": 0.02114, "epss_percentile": 0.83652}, "CVE-2012-0865": {"epss_score": 0.09266, "epss_percentile": 0.9247}, "CVE-2012-0866": {"epss_score": 0.01067, "epss_percentile": 0.77223}, "CVE-2012-0867": {"epss_score": 0.01866, "epss_percentile": 0.82614}, "CVE-2012-0868": {"epss_score": 0.03276, "epss_percentile": 0.86804}, "CVE-2012-0869": {"epss_score": 0.17093, "epss_percentile": 0.94772}, "CVE-2012-0870": {"epss_score": 0.53353, "epss_percentile": 0.97873}, "CVE-2012-0871": {"epss_score": 0.00145, "epss_percentile": 0.35419}, "CVE-2012-0872": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2012-0873": {"epss_score": 0.08346, "epss_percentile": 0.92002}, "CVE-2012-0874": {"epss_score": 0.56633, "epss_percentile": 0.98032}, "CVE-2012-0875": {"epss_score": 0.00064, "epss_percentile": 0.20313}, "CVE-2012-0876": {"epss_score": 0.00306, "epss_percentile": 0.53462}, "CVE-2012-0877": {"epss_score": 0.00543, "epss_percentile": 0.67115}, "CVE-2012-0878": {"epss_score": 0.01239, "epss_percentile": 0.78798}, "CVE-2012-0879": {"epss_score": 0.00062, "epss_percentile": 0.19559}, "CVE-2012-0880": {"epss_score": 0.0169, "epss_percentile": 0.81776}, "CVE-2012-0881": {"epss_score": 0.00942, "epss_percentile": 0.75768}, "CVE-2012-0882": {"epss_score": 0.08884, "epss_percentile": 0.923}, "CVE-2012-0883": {"epss_score": 0.00197, "epss_percentile": 0.4187}, "CVE-2012-0884": {"epss_score": 0.02774, "epss_percentile": 0.85632}, "CVE-2012-0885": {"epss_score": 0.01057, "epss_percentile": 0.77136}, "CVE-2012-0891": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-0895": {"epss_score": 0.02711, "epss_percentile": 0.85492}, "CVE-2012-0896": {"epss_score": 0.03691, "epss_percentile": 0.87576}, "CVE-2012-0897": {"epss_score": 0.74313, "epss_percentile": 0.98795}, "CVE-2012-0898": {"epss_score": 0.00099, "epss_percentile": 0.28366}, "CVE-2012-0899": {"epss_score": 0.00226, "epss_percentile": 0.45241}, "CVE-2012-0900": {"epss_score": 0.03094, "epss_percentile": 0.86401}, "CVE-2012-0901": {"epss_score": 0.00693, "epss_percentile": 0.71325}, "CVE-2012-0902": {"epss_score": 0.10275, "epss_percentile": 0.92923}, "CVE-2012-0903": {"epss_score": 0.00366, "epss_percentile": 0.58082}, "CVE-2012-0904": {"epss_score": 0.10879, "epss_percentile": 0.93143}, "CVE-2012-0905": {"epss_score": 0.00572, "epss_percentile": 0.6802}, "CVE-2012-0906": {"epss_score": 0.00428, "epss_percentile": 0.61927}, "CVE-2012-0907": {"epss_score": 0.00131, "epss_percentile": 0.33413}, "CVE-2012-0908": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-0909": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2012-0911": {"epss_score": 0.77945, "epss_percentile": 0.98961}, "CVE-2012-0912": {"epss_score": 0.00293, "epss_percentile": 0.52333}, "CVE-2012-0913": {"epss_score": 0.00396, "epss_percentile": 0.59902}, "CVE-2012-0914": {"epss_score": 0.00776, "epss_percentile": 0.73101}, "CVE-2012-0915": {"epss_score": 0.0659, "epss_percentile": 0.90872}, "CVE-2012-0916": {"epss_score": 0.07036, "epss_percentile": 0.91205}, "CVE-2012-0917": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2012-0918": {"epss_score": 0.05521, "epss_percentile": 0.89958}, "CVE-2012-0919": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2012-0920": {"epss_score": 0.01803, "epss_percentile": 0.82335}, "CVE-2012-0922": {"epss_score": 0.03736, "epss_percentile": 0.8765}, "CVE-2012-0923": {"epss_score": 0.03582, "epss_percentile": 0.87387}, "CVE-2012-0924": {"epss_score": 0.0277, "epss_percentile": 0.85618}, "CVE-2012-0925": {"epss_score": 0.03736, "epss_percentile": 0.8765}, "CVE-2012-0926": {"epss_score": 0.0277, "epss_percentile": 0.85618}, "CVE-2012-0927": {"epss_score": 0.0277, "epss_percentile": 0.85618}, "CVE-2012-0928": {"epss_score": 0.02764, "epss_percentile": 0.85607}, "CVE-2012-0929": {"epss_score": 0.12548, "epss_percentile": 0.93713}, "CVE-2012-0930": {"epss_score": 0.01054, "epss_percentile": 0.77109}, "CVE-2012-0931": {"epss_score": 0.04149, "epss_percentile": 0.88319}, "CVE-2012-0932": {"epss_score": 0.02003, "epss_percentile": 0.83226}, "CVE-2012-0933": {"epss_score": 0.02913, "epss_percentile": 0.85975}, "CVE-2012-0934": {"epss_score": 0.01513, "epss_percentile": 0.8079}, "CVE-2012-0935": {"epss_score": 0.00316, "epss_percentile": 0.54242}, "CVE-2012-0936": {"epss_score": 0.00492, "epss_percentile": 0.64998}, "CVE-2012-0937": {"epss_score": 0.06085, "epss_percentile": 0.90465}, "CVE-2012-0938": {"epss_score": 0.29424, "epss_percentile": 0.96441}, "CVE-2012-0939": {"epss_score": 0.00601, "epss_percentile": 0.68862}, "CVE-2012-0941": {"epss_score": 0.0086, "epss_percentile": 0.7454}, "CVE-2012-0942": {"epss_score": 0.03731, "epss_percentile": 0.87645}, "CVE-2012-0943": {"epss_score": 0.00217, "epss_percentile": 0.44282}, "CVE-2012-0944": {"epss_score": 0.00475, "epss_percentile": 0.64191}, "CVE-2012-0945": {"epss_score": 0.00194, "epss_percentile": 0.41597}, "CVE-2012-0946": {"epss_score": 0.00233, "epss_percentile": 0.45987}, "CVE-2012-0947": {"epss_score": 0.03514, "epss_percentile": 0.87271}, "CVE-2012-0948": {"epss_score": 0.00053, "epss_percentile": 0.16841}, "CVE-2012-0949": {"epss_score": 0.00472, "epss_percentile": 0.64035}, "CVE-2012-0950": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-0951": {"epss_score": 0.00067, "epss_percentile": 0.21033}, "CVE-2012-0952": {"epss_score": 0.00061, "epss_percentile": 0.19318}, "CVE-2012-0953": {"epss_score": 0.00044, "epss_percentile": 0.13662}, "CVE-2012-0954": {"epss_score": 0.0037, "epss_percentile": 0.5832}, "CVE-2012-0955": {"epss_score": 0.00123, "epss_percentile": 0.32255}, "CVE-2012-0956": {"epss_score": 0.0035, "epss_percentile": 0.5698}, "CVE-2012-0957": {"epss_score": 0.00504, "epss_percentile": 0.65493}, "CVE-2012-0958": {"epss_score": 0.00319, "epss_percentile": 0.54564}, "CVE-2012-0959": {"epss_score": 0.00069, "epss_percentile": 0.21579}, "CVE-2012-0960": {"epss_score": 0.02313, "epss_percentile": 0.84344}, "CVE-2012-0961": {"epss_score": 0.00052, "epss_percentile": 0.16392}, "CVE-2012-0962": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2012-0973": {"epss_score": 0.02257, "epss_percentile": 0.84176}, "CVE-2012-0974": {"epss_score": 0.11383, "epss_percentile": 0.93327}, "CVE-2012-0975": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-0976": {"epss_score": 0.00382, "epss_percentile": 0.59056}, "CVE-2012-0977": {"epss_score": 0.08782, "epss_percentile": 0.92253}, "CVE-2012-0978": {"epss_score": 0.02366, "epss_percentile": 0.84514}, "CVE-2012-0979": {"epss_score": 0.00496, "epss_percentile": 0.65165}, "CVE-2012-0980": {"epss_score": 0.00139, "epss_percentile": 0.34631}, "CVE-2012-0981": {"epss_score": 0.08793, "epss_percentile": 0.92256}, "CVE-2012-0982": {"epss_score": 0.00139, "epss_percentile": 0.34631}, "CVE-2012-0983": {"epss_score": 0.00172, "epss_percentile": 0.38909}, "CVE-2012-0984": {"epss_score": 0.20629, "epss_percentile": 0.9539}, "CVE-2012-0985": {"epss_score": 0.48052, "epss_percentile": 0.97616}, "CVE-2012-0986": {"epss_score": 0.00727, "epss_percentile": 0.72089}, "CVE-2012-0987": {"epss_score": 0.02741, "epss_percentile": 0.8556}, "CVE-2012-0988": {"epss_score": 0.00563, "epss_percentile": 0.6772}, "CVE-2012-0989": {"epss_score": 0.00489, "epss_percentile": 0.64873}, "CVE-2012-0990": {"epss_score": 0.01512, "epss_percentile": 0.80781}, "CVE-2012-0991": {"epss_score": 0.47271, "epss_percentile": 0.9758}, "CVE-2012-0992": {"epss_score": 0.05466, "epss_percentile": 0.89905}, "CVE-2012-0993": {"epss_score": 0.01699, "epss_percentile": 0.81823}, "CVE-2012-0994": {"epss_score": 0.00722, "epss_percentile": 0.71994}, "CVE-2012-0995": {"epss_score": 0.00545, "epss_percentile": 0.67158}, "CVE-2012-0996": {"epss_score": 0.04456, "epss_percentile": 0.88712}, "CVE-2012-0997": {"epss_score": 0.00245, "epss_percentile": 0.47725}, "CVE-2012-0998": {"epss_score": 0.00311, "epss_percentile": 0.53867}, "CVE-2012-0999": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2012-10001": {"epss_score": 0.00771, "epss_percentile": 0.73029}, "CVE-2012-10002": {"epss_score": 0.004, "epss_percentile": 0.60171}, "CVE-2012-10003": {"epss_score": 0.00295, "epss_percentile": 0.52445}, "CVE-2012-10004": {"epss_score": 0.00075, "epss_percentile": 0.2293}, "CVE-2012-10005": {"epss_score": 0.00081, "epss_percentile": 0.24364}, "CVE-2012-10006": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2012-10007": {"epss_score": 0.00098, "epss_percentile": 0.27776}, "CVE-2012-10008": {"epss_score": 0.00055, "epss_percentile": 0.17609}, "CVE-2012-10009": {"epss_score": 0.00129, "epss_percentile": 0.33091}, "CVE-2012-10010": {"epss_score": 0.00065, "epss_percentile": 0.20512}, "CVE-2012-10011": {"epss_score": 0.00129, "epss_percentile": 0.3311}, "CVE-2012-10012": {"epss_score": 0.00077, "epss_percentile": 0.23319}, "CVE-2012-10013": {"epss_score": 0.00078, "epss_percentile": 0.2359}, "CVE-2012-10014": {"epss_score": 0.00078, "epss_percentile": 0.2359}, "CVE-2012-10015": {"epss_score": 0.00066, "epss_percentile": 0.20823}, "CVE-2012-10016": {"epss_score": 0.00306, "epss_percentile": 0.53396}, "CVE-2012-10017": {"epss_score": 0.00078, "epss_percentile": 0.2364}, "CVE-2012-10018": {"epss_score": 0.00428, "epss_percentile": 0.61932}, "CVE-2012-10019": {"epss_score": 0.54269, "epss_percentile": 0.97918}, "CVE-2012-10020": {"epss_score": 0.65588, "epss_percentile": 0.98427}, "CVE-2012-10021": {"epss_score": 0.55317, "epss_percentile": 0.97971}, "CVE-2012-10022": {"epss_score": 0.0138, "epss_percentile": 0.79865}, "CVE-2012-10023": {"epss_score": 0.70595, "epss_percentile": 0.98637}, "CVE-2012-10024": {"epss_score": 0.48835, "epss_percentile": 0.97657}, "CVE-2012-10025": {"epss_score": 0.45976, "epss_percentile": 0.97514}, "CVE-2012-10026": {"epss_score": 0.66533, "epss_percentile": 0.98467}, "CVE-2012-10027": {"epss_score": 0.73719, "epss_percentile": 0.9877}, "CVE-2012-10028": {"epss_score": 0.53689, "epss_percentile": 0.97891}, "CVE-2012-10029": {"epss_score": 0.46601, "epss_percentile": 0.97554}, "CVE-2012-10030": {"epss_score": 0.57149, "epss_percentile": 0.9805}, "CVE-2012-10031": {"epss_score": 0.5303, "epss_percentile": 0.97852}, "CVE-2012-10032": {"epss_score": 0.44415, "epss_percentile": 0.97434}, "CVE-2012-10033": {"epss_score": 0.60652, "epss_percentile": 0.98215}, "CVE-2012-10034": {"epss_score": 0.18431, "epss_percentile": 0.95015}, "CVE-2012-10035": {"epss_score": 0.49128, "epss_percentile": 0.97669}, "CVE-2012-10036": {"epss_score": 0.7245, "epss_percentile": 0.9871}, "CVE-2012-10037": {"epss_score": 0.62552, "epss_percentile": 0.98296}, "CVE-2012-10038": {"epss_score": 0.72201, "epss_percentile": 0.98699}, "CVE-2012-10039": {"epss_score": 0.43626, "epss_percentile": 0.97395}, "CVE-2012-10040": {"epss_score": 0.52227, "epss_percentile": 0.97814}, "CVE-2012-10041": {"epss_score": 0.53625, "epss_percentile": 0.97886}, "CVE-2012-10042": {"epss_score": 0.43365, "epss_percentile": 0.97383}, "CVE-2012-10043": {"epss_score": 0.04641, "epss_percentile": 0.88953}, "CVE-2012-10044": {"epss_score": 0.64724, "epss_percentile": 0.98389}, "CVE-2012-10045": {"epss_score": 0.66533, "epss_percentile": 0.98467}, "CVE-2012-10046": {"epss_score": 0.52946, "epss_percentile": 0.97847}, "CVE-2012-10047": {"epss_score": 0.4906, "epss_percentile": 0.97666}, "CVE-2012-10048": {"epss_score": 0.50195, "epss_percentile": 0.97724}, "CVE-2012-10049": {"epss_score": 0.66533, "epss_percentile": 0.98467}, "CVE-2012-10050": {"epss_score": 0.62126, "epss_percentile": 0.9828}, "CVE-2012-10051": {"epss_score": 0.06899, "epss_percentile": 0.91102}, "CVE-2012-10052": {"epss_score": 0.7245, "epss_percentile": 0.9871}, "CVE-2012-10053": {"epss_score": 0.64321, "epss_percentile": 0.98373}, "CVE-2012-10054": {"epss_score": 0.75188, "epss_percentile": 0.98833}, "CVE-2012-10055": {"epss_score": 0.67801, "epss_percentile": 0.98521}, "CVE-2012-10056": {"epss_score": 0.51858, "epss_percentile": 0.978}, "CVE-2012-10057": {"epss_score": 0.0304, "epss_percentile": 0.8627}, "CVE-2012-10058": {"epss_score": 0.63848, "epss_percentile": 0.98353}, "CVE-2012-10059": {"epss_score": 0.61015, "epss_percentile": 0.98232}, "CVE-2012-10060": {"epss_score": 0.75213, "epss_percentile": 0.98834}, "CVE-2012-10061": {"epss_score": 0.59962, "epss_percentile": 0.98189}, "CVE-2012-10062": {"epss_score": 0.59035, "epss_percentile": 0.98146}, "CVE-2012-10063": {"epss_score": 0.01157, "epss_percentile": 0.7811}, "CVE-2012-1000": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-1001": {"epss_score": 0.19244, "epss_percentile": 0.95155}, "CVE-2012-1002": {"epss_score": 0.02883, "epss_percentile": 0.85903}, "CVE-2012-1003": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2012-1004": {"epss_score": 0.00257, "epss_percentile": 0.4889}, "CVE-2012-1005": {"epss_score": 0.00436, "epss_percentile": 0.62487}, "CVE-2012-1006": {"epss_score": 0.80166, "epss_percentile": 0.99074}, "CVE-2012-1007": {"epss_score": 0.06984, "epss_percentile": 0.91161}, "CVE-2012-1008": {"epss_score": 0.07822, "epss_percentile": 0.91699}, "CVE-2012-1009": {"epss_score": 0.0916, "epss_percentile": 0.92427}, "CVE-2012-1010": {"epss_score": 0.09674, "epss_percentile": 0.92649}, "CVE-2012-1011": {"epss_score": 0.08546, "epss_percentile": 0.92117}, "CVE-2012-1012": {"epss_score": 0.00238, "epss_percentile": 0.46794}, "CVE-2012-1013": {"epss_score": 0.01042, "epss_percentile": 0.76976}, "CVE-2012-1014": {"epss_score": 0.04152, "epss_percentile": 0.88323}, "CVE-2012-1015": {"epss_score": 0.01234, "epss_percentile": 0.78756}, "CVE-2012-1016": {"epss_score": 0.00643, "epss_percentile": 0.70049}, "CVE-2012-1017": {"epss_score": 0.00479, "epss_percentile": 0.64431}, "CVE-2012-1018": {"epss_score": 0.01517, "epss_percentile": 0.80804}, "CVE-2012-1019": {"epss_score": 0.00062, "epss_percentile": 0.19716}, "CVE-2012-1020": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-1021": {"epss_score": 0.03094, "epss_percentile": 0.86401}, "CVE-2012-1022": {"epss_score": 0.00397, "epss_percentile": 0.60018}, "CVE-2012-1023": {"epss_score": 0.03008, "epss_percentile": 0.86191}, "CVE-2012-1024": {"epss_score": 0.04921, "epss_percentile": 0.89292}, "CVE-2012-1025": {"epss_score": 0.05306, "epss_percentile": 0.89713}, "CVE-2012-1026": {"epss_score": 0.00189, "epss_percentile": 0.40931}, "CVE-2012-1027": {"epss_score": 0.09433, "epss_percentile": 0.92544}, "CVE-2012-1028": {"epss_score": 0.00256, "epss_percentile": 0.48799}, "CVE-2012-1029": {"epss_score": 0.01695, "epss_percentile": 0.81807}, "CVE-2012-1030": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-1031": {"epss_score": 0.00372, "epss_percentile": 0.58461}, "CVE-2012-1032": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-1033": {"epss_score": 0.01607, "epss_percentile": 0.81309}, "CVE-2012-1034": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-1035": {"epss_score": 0.00556, "epss_percentile": 0.67505}, "CVE-2012-1036": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-1037": {"epss_score": 0.00607, "epss_percentile": 0.6906}, "CVE-2012-1038": {"epss_score": 0.0105, "epss_percentile": 0.77067}, "CVE-2012-1039": {"epss_score": 0.04074, "epss_percentile": 0.88208}, "CVE-2012-1046": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2012-1047": {"epss_score": 0.01666, "epss_percentile": 0.81653}, "CVE-2012-1048": {"epss_score": 0.01717, "epss_percentile": 0.81918}, "CVE-2012-1049": {"epss_score": 0.06417, "epss_percentile": 0.90746}, "CVE-2012-1050": {"epss_score": 0.00794, "epss_percentile": 0.73455}, "CVE-2012-1051": {"epss_score": 0.02662, "epss_percentile": 0.85371}, "CVE-2012-1052": {"epss_score": 0.02662, "epss_percentile": 0.85371}, "CVE-2012-1053": {"epss_score": 0.00044, "epss_percentile": 0.13425}, "CVE-2012-1054": {"epss_score": 0.00071, "epss_percentile": 0.22022}, "CVE-2012-1055": {"epss_score": 0.02662, "epss_percentile": 0.85371}, "CVE-2012-1056": {"epss_score": 0.0045, "epss_percentile": 0.63075}, "CVE-2012-1057": {"epss_score": 0.00169, "epss_percentile": 0.38568}, "CVE-2012-1058": {"epss_score": 0.00201, "epss_percentile": 0.42337}, "CVE-2012-1059": {"epss_score": 0.07745, "epss_percentile": 0.91656}, "CVE-2012-1060": {"epss_score": 0.00356, "epss_percentile": 0.57351}, "CVE-2012-1061": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2012-1062": {"epss_score": 0.0048, "epss_percentile": 0.64461}, "CVE-2012-1063": {"epss_score": 0.00526, "epss_percentile": 0.66403}, "CVE-2012-1064": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-1065": {"epss_score": 0.04337, "epss_percentile": 0.88564}, "CVE-2012-1066": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-1067": {"epss_score": 0.00509, "epss_percentile": 0.6572}, "CVE-2012-1068": {"epss_score": 0.00274, "epss_percentile": 0.50532}, "CVE-2012-1069": {"epss_score": 0.00226, "epss_percentile": 0.45241}, "CVE-2012-1070": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2012-1071": {"epss_score": 0.00738, "epss_percentile": 0.72349}, "CVE-2012-1072": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2012-1073": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-1074": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2012-1075": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2012-1076": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-1077": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2012-1078": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2012-1079": {"epss_score": 0.01392, "epss_percentile": 0.79956}, "CVE-2012-1080": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-1081": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-1082": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2012-1083": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2012-1084": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-1085": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-1086": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-1087": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-1088": {"epss_score": 0.00142, "epss_percentile": 0.3504}, "CVE-2012-1089": {"epss_score": 0.01542, "epss_percentile": 0.80949}, "CVE-2012-1090": {"epss_score": 0.00061, "epss_percentile": 0.19287}, "CVE-2012-1093": {"epss_score": 0.00135, "epss_percentile": 0.34041}, "CVE-2012-1094": {"epss_score": 0.00235, "epss_percentile": 0.46226}, "CVE-2012-1095": {"epss_score": 0.00409, "epss_percentile": 0.60725}, "CVE-2012-1096": {"epss_score": 0.00352, "epss_percentile": 0.57105}, "CVE-2012-1097": {"epss_score": 0.00122, "epss_percentile": 0.32052}, "CVE-2012-1098": {"epss_score": 0.00377, "epss_percentile": 0.58773}, "CVE-2012-1099": {"epss_score": 0.00399, "epss_percentile": 0.60133}, "CVE-2012-1100": {"epss_score": 0.00305, "epss_percentile": 0.53339}, "CVE-2012-1101": {"epss_score": 0.00153, "epss_percentile": 0.36643}, "CVE-2012-1102": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2012-1103": {"epss_score": 0.00673, "epss_percentile": 0.7083}, "CVE-2012-1104": {"epss_score": 0.00244, "epss_percentile": 0.47568}, "CVE-2012-1105": {"epss_score": 0.00152, "epss_percentile": 0.36488}, "CVE-2012-1106": {"epss_score": 0.00047, "epss_percentile": 0.14779}, "CVE-2012-1107": {"epss_score": 0.02857, "epss_percentile": 0.85843}, "CVE-2012-1108": {"epss_score": 0.04038, "epss_percentile": 0.88161}, "CVE-2012-1109": {"epss_score": 0.00681, "epss_percentile": 0.71056}, "CVE-2012-1110": {"epss_score": 0.08927, "epss_percentile": 0.92324}, "CVE-2012-1111": {"epss_score": 0.00097, "epss_percentile": 0.27537}, "CVE-2012-1112": {"epss_score": 0.09084, "epss_percentile": 0.92393}, "CVE-2012-1113": {"epss_score": 0.00665, "epss_percentile": 0.70652}, "CVE-2012-1114": {"epss_score": 0.0084, "epss_percentile": 0.74199}, "CVE-2012-1115": {"epss_score": 0.0084, "epss_percentile": 0.74199}, "CVE-2012-1116": {"epss_score": 0.00119, "epss_percentile": 0.31578}, "CVE-2012-1117": {"epss_score": 0.00011, "epss_percentile": 0.01065}, "CVE-2012-1118": {"epss_score": 0.01253, "epss_percentile": 0.78915}, "CVE-2012-1119": {"epss_score": 0.03607, "epss_percentile": 0.87418}, "CVE-2012-1120": {"epss_score": 0.00902, "epss_percentile": 0.75189}, "CVE-2012-1121": {"epss_score": 0.01244, "epss_percentile": 0.78835}, "CVE-2012-1122": {"epss_score": 0.01224, "epss_percentile": 0.78679}, "CVE-2012-1123": {"epss_score": 0.01357, "epss_percentile": 0.7972}, "CVE-2012-1124": {"epss_score": 0.03907, "epss_percentile": 0.8793}, "CVE-2012-1125": {"epss_score": 0.37883, "epss_percentile": 0.97075}, "CVE-2012-1126": {"epss_score": 0.03091, "epss_percentile": 0.86394}, "CVE-2012-1127": {"epss_score": 0.02967, "epss_percentile": 0.86087}, "CVE-2012-1128": {"epss_score": 0.02697, "epss_percentile": 0.85447}, "CVE-2012-1129": {"epss_score": 0.02967, "epss_percentile": 0.86087}, "CVE-2012-1130": {"epss_score": 0.02967, "epss_percentile": 0.86087}, "CVE-2012-1131": {"epss_score": 0.02967, "epss_percentile": 0.86087}, "CVE-2012-1132": {"epss_score": 0.02967, "epss_percentile": 0.86087}, "CVE-2012-1133": {"epss_score": 0.03525, "epss_percentile": 0.87293}, "CVE-2012-1134": {"epss_score": 0.05858, "epss_percentile": 0.90269}, "CVE-2012-1135": {"epss_score": 0.03525, "epss_percentile": 0.87293}, "CVE-2012-1136": {"epss_score": 0.04956, "epss_percentile": 0.89329}, "CVE-2012-1137": {"epss_score": 0.02967, "epss_percentile": 0.86087}, "CVE-2012-1138": {"epss_score": 0.03525, "epss_percentile": 0.87293}, "CVE-2012-1139": {"epss_score": 0.02967, "epss_percentile": 0.86087}, "CVE-2012-1140": {"epss_score": 0.02967, "epss_percentile": 0.86087}, "CVE-2012-1141": {"epss_score": 0.02967, "epss_percentile": 0.86087}, "CVE-2012-1142": {"epss_score": 0.04956, "epss_percentile": 0.89329}, "CVE-2012-1143": {"epss_score": 0.02148, "epss_percentile": 0.83771}, "CVE-2012-1144": {"epss_score": 0.03525, "epss_percentile": 0.87293}, "CVE-2012-1145": {"epss_score": 0.01791, "epss_percentile": 0.82282}, "CVE-2012-1146": {"epss_score": 0.00097, "epss_percentile": 0.27572}, "CVE-2012-1147": {"epss_score": 0.01154, "epss_percentile": 0.78067}, "CVE-2012-1148": {"epss_score": 0.01317, "epss_percentile": 0.79417}, "CVE-2012-1149": {"epss_score": 0.01193, "epss_percentile": 0.78406}, "CVE-2012-1150": {"epss_score": 0.01012, "epss_percentile": 0.76627}, "CVE-2012-1151": {"epss_score": 0.02485, "epss_percentile": 0.84884}, "CVE-2012-1152": {"epss_score": 0.03855, "epss_percentile": 0.87856}, "CVE-2012-1153": {"epss_score": 0.80715, "epss_percentile": 0.99102}, "CVE-2012-1154": {"epss_score": 0.00258, "epss_percentile": 0.49006}, "CVE-2012-1155": {"epss_score": 0.01269, "epss_percentile": 0.7904}, "CVE-2012-1156": {"epss_score": 0.01229, "epss_percentile": 0.78713}, "CVE-2012-1157": {"epss_score": 0.0058, "epss_percentile": 0.68249}, "CVE-2012-1158": {"epss_score": 0.00946, "epss_percentile": 0.75812}, "CVE-2012-1159": {"epss_score": 0.00946, "epss_percentile": 0.75812}, "CVE-2012-1160": {"epss_score": 0.0075, "epss_percentile": 0.72613}, "CVE-2012-1161": {"epss_score": 0.00946, "epss_percentile": 0.75812}, "CVE-2012-1162": {"epss_score": 0.01971, "epss_percentile": 0.83098}, "CVE-2012-1163": {"epss_score": 0.01385, "epss_percentile": 0.79907}, "CVE-2012-1164": {"epss_score": 0.12715, "epss_percentile": 0.93756}, "CVE-2012-1165": {"epss_score": 0.05121, "epss_percentile": 0.8952}, "CVE-2012-1166": {"epss_score": 0.04374, "epss_percentile": 0.88614}, "CVE-2012-1167": {"epss_score": 0.00815, "epss_percentile": 0.73788}, "CVE-2012-1168": {"epss_score": 0.02216, "epss_percentile": 0.84029}, "CVE-2012-1169": {"epss_score": 0.00991, "epss_percentile": 0.76383}, "CVE-2012-1170": {"epss_score": 0.00467, "epss_percentile": 0.63843}, "CVE-2012-1171": {"epss_score": 0.00162, "epss_percentile": 0.37621}, "CVE-2012-1172": {"epss_score": 0.1185, "epss_percentile": 0.93494}, "CVE-2012-1173": {"epss_score": 0.04011, "epss_percentile": 0.88112}, "CVE-2012-1174": {"epss_score": 0.00118, "epss_percentile": 0.31408}, "CVE-2012-1175": {"epss_score": 0.03574, "epss_percentile": 0.87376}, "CVE-2012-1176": {"epss_score": 0.03313, "epss_percentile": 0.86897}, "CVE-2012-1177": {"epss_score": 0.00933, "epss_percentile": 0.75639}, "CVE-2012-1178": {"epss_score": 0.01136, "epss_percentile": 0.77914}, "CVE-2012-1179": {"epss_score": 0.00358, "epss_percentile": 0.57514}, "CVE-2012-1180": {"epss_score": 0.03062, "epss_percentile": 0.86318}, "CVE-2012-1181": {"epss_score": 0.09726, "epss_percentile": 0.92678}, "CVE-2012-1182": {"epss_score": 0.7681, "epss_percentile": 0.98906}, "CVE-2012-1183": {"epss_score": 0.00219, "epss_percentile": 0.44472}, "CVE-2012-1184": {"epss_score": 0.41698, "epss_percentile": 0.9729}, "CVE-2012-1185": {"epss_score": 0.01292, "epss_percentile": 0.79235}, "CVE-2012-1186": {"epss_score": 0.0027, "epss_percentile": 0.50196}, "CVE-2012-1187": {"epss_score": 0.00427, "epss_percentile": 0.61913}, "CVE-2012-1188": {"epss_score": 0.1384, "epss_percentile": 0.94074}, "CVE-2012-1189": {"epss_score": 0.35744, "epss_percentile": 0.9693}, "CVE-2012-1190": {"epss_score": 0.00431, "epss_percentile": 0.62053}, "CVE-2012-1191": {"epss_score": 0.00467, "epss_percentile": 0.63855}, "CVE-2012-1192": {"epss_score": 0.00627, "epss_percentile": 0.69626}, "CVE-2012-1193": {"epss_score": 0.00021, "epss_percentile": 0.04832}, "CVE-2012-1194": {"epss_score": 0.09678, "epss_percentile": 0.92655}, "CVE-2012-1195": {"epss_score": 0.86542, "epss_percentile": 0.99387}, "CVE-2012-1196": {"epss_score": 0.7739, "epss_percentile": 0.98934}, "CVE-2012-1197": {"epss_score": 0.07389, "epss_percentile": 0.91447}, "CVE-2012-1198": {"epss_score": 0.07151, "epss_percentile": 0.91287}, "CVE-2012-1199": {"epss_score": 0.01732, "epss_percentile": 0.81997}, "CVE-2012-1200": {"epss_score": 0.01524, "epss_percentile": 0.80847}, "CVE-2012-1203": {"epss_score": 0.00228, "epss_percentile": 0.45501}, "CVE-2012-1205": {"epss_score": 0.02234, "epss_percentile": 0.84095}, "CVE-2012-1206": {"epss_score": 0.12131, "epss_percentile": 0.93576}, "CVE-2012-1207": {"epss_score": 0.00171, "epss_percentile": 0.38892}, "CVE-2012-1208": {"epss_score": 0.06778, "epss_percentile": 0.9102}, "CVE-2012-1209": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-1210": {"epss_score": 0.00446, "epss_percentile": 0.62915}, "CVE-2012-1211": {"epss_score": 0.02034, "epss_percentile": 0.83347}, "CVE-2012-1212": {"epss_score": 0.00446, "epss_percentile": 0.62934}, "CVE-2012-1213": {"epss_score": 0.03546, "epss_percentile": 0.87329}, "CVE-2012-1214": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-1215": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2012-1216": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2012-1217": {"epss_score": 0.00799, "epss_percentile": 0.73527}, "CVE-2012-1218": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2012-1219": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-1220": {"epss_score": 0.00196, "epss_percentile": 0.41738}, "CVE-2012-1221": {"epss_score": 0.06283, "epss_percentile": 0.9064}, "CVE-2012-1222": {"epss_score": 0.09934, "epss_percentile": 0.92779}, "CVE-2012-1223": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-1224": {"epss_score": 0.00482, "epss_percentile": 0.64538}, "CVE-2012-1225": {"epss_score": 0.00424, "epss_percentile": 0.61667}, "CVE-2012-1226": {"epss_score": 0.04601, "epss_percentile": 0.88903}, "CVE-2012-1227": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2012-1234": {"epss_score": 0.00228, "epss_percentile": 0.45532}, "CVE-2012-1235": {"epss_score": 0.00063, "epss_percentile": 0.19916}, "CVE-2012-1236": {"epss_score": 0.00213, "epss_percentile": 0.43889}, "CVE-2012-1237": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2012-1238": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-1239": {"epss_score": 0.13511, "epss_percentile": 0.93985}, "CVE-2012-1240": {"epss_score": 0.0047, "epss_percentile": 0.63994}, "CVE-2012-1241": {"epss_score": 0.01039, "epss_percentile": 0.76952}, "CVE-2012-1242": {"epss_score": 0.00053, "epss_percentile": 0.1671}, "CVE-2012-1243": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-1244": {"epss_score": 0.00286, "epss_percentile": 0.51707}, "CVE-2012-1245": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-1246": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2012-1247": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2012-1248": {"epss_score": 0.01244, "epss_percentile": 0.78834}, "CVE-2012-1249": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-1250": {"epss_score": 0.07475, "epss_percentile": 0.91493}, "CVE-2012-1251": {"epss_score": 0.00198, "epss_percentile": 0.41986}, "CVE-2012-1252": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-1253": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-1254": {"epss_score": 0.00312, "epss_percentile": 0.54001}, "CVE-2012-1255": {"epss_score": 0.00587, "epss_percentile": 0.6846}, "CVE-2012-1256": {"epss_score": 0.00223, "epss_percentile": 0.44903}, "CVE-2012-1257": {"epss_score": 0.00243, "epss_percentile": 0.4749}, "CVE-2012-1258": {"epss_score": 0.04776, "epss_percentile": 0.89132}, "CVE-2012-1259": {"epss_score": 0.14324, "epss_percentile": 0.94186}, "CVE-2012-1260": {"epss_score": 0.0392, "epss_percentile": 0.87951}, "CVE-2012-1261": {"epss_score": 0.05577, "epss_percentile": 0.90014}, "CVE-2012-1262": {"epss_score": 0.00849, "epss_percentile": 0.74369}, "CVE-2012-1264": {"epss_score": 0.02247, "epss_percentile": 0.84134}, "CVE-2012-1288": {"epss_score": 0.0073, "epss_percentile": 0.7214}, "CVE-2012-1289": {"epss_score": 0.00491, "epss_percentile": 0.64943}, "CVE-2012-1290": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-1291": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-1292": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2012-1293": {"epss_score": 0.0053, "epss_percentile": 0.66619}, "CVE-2012-1294": {"epss_score": 0.00549, "epss_percentile": 0.67319}, "CVE-2012-1296": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2012-1297": {"epss_score": 0.00389, "epss_percentile": 0.59464}, "CVE-2012-1301": {"epss_score": 0.03164, "epss_percentile": 0.86535}, "CVE-2012-1302": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-1303": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-1308": {"epss_score": 0.07097, "epss_percentile": 0.91247}, "CVE-2012-1310": {"epss_score": 0.00798, "epss_percentile": 0.73509}, "CVE-2012-1311": {"epss_score": 0.0215, "epss_percentile": 0.83782}, "CVE-2012-1312": {"epss_score": 0.01503, "epss_percentile": 0.80732}, "CVE-2012-1313": {"epss_score": 0.00134, "epss_percentile": 0.33832}, "CVE-2012-1314": {"epss_score": 0.0215, "epss_percentile": 0.83782}, "CVE-2012-1315": {"epss_score": 0.0215, "epss_percentile": 0.83782}, "CVE-2012-1316": {"epss_score": 0.00204, "epss_percentile": 0.42633}, "CVE-2012-1317": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-1324": {"epss_score": 0.00309, "epss_percentile": 0.53678}, "CVE-2012-1326": {"epss_score": 0.00136, "epss_percentile": 0.34115}, "CVE-2012-1327": {"epss_score": 0.00167, "epss_percentile": 0.38401}, "CVE-2012-1328": {"epss_score": 0.00178, "epss_percentile": 0.39739}, "CVE-2012-1335": {"epss_score": 0.07783, "epss_percentile": 0.9168}, "CVE-2012-1336": {"epss_score": 0.07783, "epss_percentile": 0.9168}, "CVE-2012-1337": {"epss_score": 0.24127, "epss_percentile": 0.95878}, "CVE-2012-1338": {"epss_score": 0.00293, "epss_percentile": 0.52326}, "CVE-2012-1339": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-1340": {"epss_score": 0.00677, "epss_percentile": 0.70955}, "CVE-2012-1342": {"epss_score": 0.00148, "epss_percentile": 0.35912}, "CVE-2012-1344": {"epss_score": 0.00347, "epss_percentile": 0.56786}, "CVE-2012-1346": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-1348": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-1350": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-1357": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-1361": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-1364": {"epss_score": 0.00403, "epss_percentile": 0.60368}, "CVE-2012-1365": {"epss_score": 0.00403, "epss_percentile": 0.60368}, "CVE-2012-1366": {"epss_score": 0.00182, "epss_percentile": 0.40206}, "CVE-2012-1367": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2012-1370": {"epss_score": 0.00473, "epss_percentile": 0.64095}, "CVE-2012-1380": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1381": {"epss_score": 0.00434, "epss_percentile": 0.62316}, "CVE-2012-1382": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1383": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1384": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1385": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1386": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1387": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1388": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1389": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1390": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1391": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1392": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1393": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1394": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1395": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1396": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1397": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1398": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1399": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1400": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1401": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1402": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1403": {"epss_score": 0.00433, "epss_percentile": 0.62171}, "CVE-2012-1404": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1405": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1406": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1407": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1408": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1409": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1410": {"epss_score": 0.00478, "epss_percentile": 0.64379}, "CVE-2012-1413": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-1414": {"epss_score": 0.00211, "epss_percentile": 0.43714}, "CVE-2012-1415": {"epss_score": 0.00228, "epss_percentile": 0.45501}, "CVE-2012-1416": {"epss_score": 0.00435, "epss_percentile": 0.62367}, "CVE-2012-1417": {"epss_score": 0.01088, "epss_percentile": 0.77439}, "CVE-2012-1418": {"epss_score": 0.00212, "epss_percentile": 0.4382}, "CVE-2012-1419": {"epss_score": 0.02837, "epss_percentile": 0.85793}, "CVE-2012-1420": {"epss_score": 0.16436, "epss_percentile": 0.9466}, "CVE-2012-1421": {"epss_score": 0.00191, "epss_percentile": 0.41162}, "CVE-2012-1422": {"epss_score": 0.00202, "epss_percentile": 0.42444}, "CVE-2012-1423": {"epss_score": 0.03685, "epss_percentile": 0.87569}, "CVE-2012-1424": {"epss_score": 0.04148, "epss_percentile": 0.88317}, "CVE-2012-1425": {"epss_score": 0.54236, "epss_percentile": 0.97916}, "CVE-2012-1426": {"epss_score": 0.00349, "epss_percentile": 0.56906}, "CVE-2012-1427": {"epss_score": 0.04148, "epss_percentile": 0.88317}, "CVE-2012-1428": {"epss_score": 0.04148, "epss_percentile": 0.88317}, "CVE-2012-1429": {"epss_score": 0.05051, "epss_percentile": 0.8944}, "CVE-2012-1430": {"epss_score": 0.00521, "epss_percentile": 0.6622}, "CVE-2012-1431": {"epss_score": 0.00521, "epss_percentile": 0.6622}, "CVE-2012-1432": {"epss_score": 0.05614, "epss_percentile": 0.9005}, "CVE-2012-1433": {"epss_score": 0.05614, "epss_percentile": 0.9005}, "CVE-2012-1434": {"epss_score": 0.08021, "epss_percentile": 0.91835}, "CVE-2012-1435": {"epss_score": 0.05614, "epss_percentile": 0.9005}, "CVE-2012-1436": {"epss_score": 0.05614, "epss_percentile": 0.9005}, "CVE-2012-1437": {"epss_score": 0.00369, "epss_percentile": 0.58272}, "CVE-2012-1438": {"epss_score": 0.01564, "epss_percentile": 0.81058}, "CVE-2012-1439": {"epss_score": 0.00137, "epss_percentile": 0.34261}, "CVE-2012-1440": {"epss_score": 0.00337, "epss_percentile": 0.56039}, "CVE-2012-1441": {"epss_score": 0.00288, "epss_percentile": 0.51888}, "CVE-2012-1442": {"epss_score": 0.02838, "epss_percentile": 0.85794}, "CVE-2012-1443": {"epss_score": 0.50208, "epss_percentile": 0.97726}, "CVE-2012-1444": {"epss_score": 0.00484, "epss_percentile": 0.64642}, "CVE-2012-1445": {"epss_score": 0.00137, "epss_percentile": 0.34261}, "CVE-2012-1446": {"epss_score": 0.02536, "epss_percentile": 0.85037}, "CVE-2012-1447": {"epss_score": 0.00484, "epss_percentile": 0.64642}, "CVE-2012-1448": {"epss_score": 0.08338, "epss_percentile": 0.91998}, "CVE-2012-1449": {"epss_score": 0.00138, "epss_percentile": 0.34429}, "CVE-2012-1450": {"epss_score": 0.19516, "epss_percentile": 0.95196}, "CVE-2012-1451": {"epss_score": 0.06956, "epss_percentile": 0.91146}, "CVE-2012-1452": {"epss_score": 0.05631, "epss_percentile": 0.90069}, "CVE-2012-1453": {"epss_score": 0.78477, "epss_percentile": 0.98988}, "CVE-2012-1454": {"epss_score": 0.00137, "epss_percentile": 0.34261}, "CVE-2012-1455": {"epss_score": 0.00138, "epss_percentile": 0.34429}, "CVE-2012-1456": {"epss_score": 0.18248, "epss_percentile": 0.94981}, "CVE-2012-1457": {"epss_score": 0.64882, "epss_percentile": 0.98396}, "CVE-2012-1458": {"epss_score": 0.06139, "epss_percentile": 0.90512}, "CVE-2012-1459": {"epss_score": 0.85387, "epss_percentile": 0.99332}, "CVE-2012-1460": {"epss_score": 0.00572, "epss_percentile": 0.6803}, "CVE-2012-1461": {"epss_score": 0.83893, "epss_percentile": 0.99264}, "CVE-2012-1462": {"epss_score": 0.08376, "epss_percentile": 0.92016}, "CVE-2012-1463": {"epss_score": 0.01108, "epss_percentile": 0.77631}, "CVE-2012-1464": {"epss_score": 0.15575, "epss_percentile": 0.94462}, "CVE-2012-1465": {"epss_score": 0.82771, "epss_percentile": 0.99214}, "CVE-2012-1466": {"epss_score": 0.15575, "epss_percentile": 0.94462}, "CVE-2012-1467": {"epss_score": 0.02471, "epss_percentile": 0.84847}, "CVE-2012-1468": {"epss_score": 0.04458, "epss_percentile": 0.88716}, "CVE-2012-1469": {"epss_score": 0.16268, "epss_percentile": 0.94607}, "CVE-2012-1470": {"epss_score": 0.02926, "epss_percentile": 0.86006}, "CVE-2012-1471": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2012-1472": {"epss_score": 0.00842, "epss_percentile": 0.74234}, "CVE-2012-1474": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1475": {"epss_score": 0.00289, "epss_percentile": 0.52045}, "CVE-2012-1476": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1477": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1478": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1479": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1480": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-1481": {"epss_score": 0.00406, "epss_percentile": 0.60562}, "CVE-2012-1482": {"epss_score": 0.00406, "epss_percentile": 0.60562}, "CVE-2012-1483": {"epss_score": 0.00406, "epss_percentile": 0.60562}, "CVE-2012-1484": {"epss_score": 0.00406, "epss_percentile": 0.60562}, "CVE-2012-1485": {"epss_score": 0.00447, "epss_percentile": 0.62946}, "CVE-2012-1493": {"epss_score": 0.84375, "epss_percentile": 0.99286}, "CVE-2012-1495": {"epss_score": 0.8895, "epss_percentile": 0.995}, "CVE-2012-1496": {"epss_score": 0.00795, "epss_percentile": 0.73461}, "CVE-2012-1497": {"epss_score": 0.00279, "epss_percentile": 0.5097}, "CVE-2012-1498": {"epss_score": 0.039, "epss_percentile": 0.8792}, "CVE-2012-1499": {"epss_score": 0.03847, "epss_percentile": 0.87843}, "CVE-2012-1500": {"epss_score": 0.00218, "epss_percentile": 0.44437}, "CVE-2012-1502": {"epss_score": 0.22926, "epss_percentile": 0.95706}, "CVE-2012-1503": {"epss_score": 0.07871, "epss_percentile": 0.91736}, "CVE-2012-1506": {"epss_score": 0.0232, "epss_percentile": 0.84366}, "CVE-2012-1507": {"epss_score": 0.03374, "epss_percentile": 0.87014}, "CVE-2012-1508": {"epss_score": 0.00065, "epss_percentile": 0.20548}, "CVE-2012-1509": {"epss_score": 0.00072, "epss_percentile": 0.2233}, "CVE-2012-1510": {"epss_score": 0.00096, "epss_percentile": 0.2729}, "CVE-2012-1511": {"epss_score": 0.00295, "epss_percentile": 0.52481}, "CVE-2012-1512": {"epss_score": 0.007, "epss_percentile": 0.71472}, "CVE-2012-1513": {"epss_score": 0.00373, "epss_percentile": 0.5848}, "CVE-2012-1514": {"epss_score": 0.00573, "epss_percentile": 0.68065}, "CVE-2012-1515": {"epss_score": 0.00273, "epss_percentile": 0.50472}, "CVE-2012-1516": {"epss_score": 0.01155, "epss_percentile": 0.78074}, "CVE-2012-1517": {"epss_score": 0.0128, "epss_percentile": 0.7914}, "CVE-2012-1518": {"epss_score": 0.00908, "epss_percentile": 0.75277}, "CVE-2012-1520": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-1521": {"epss_score": 0.07354, "epss_percentile": 0.91428}, "CVE-2012-1522": {"epss_score": 0.54934, "epss_percentile": 0.97953}, "CVE-2012-1523": {"epss_score": 0.52969, "epss_percentile": 0.9785}, "CVE-2012-1524": {"epss_score": 0.51863, "epss_percentile": 0.978}, "CVE-2012-1525": {"epss_score": 0.36066, "epss_percentile": 0.96953}, "CVE-2012-1526": {"epss_score": 0.53228, "epss_percentile": 0.97867}, "CVE-2012-1527": {"epss_score": 0.50502, "epss_percentile": 0.9774}, "CVE-2012-1528": {"epss_score": 0.50502, "epss_percentile": 0.9774}, "CVE-2012-1529": {"epss_score": 0.26792, "epss_percentile": 0.96181}, "CVE-2012-1530": {"epss_score": 0.10124, "epss_percentile": 0.9286}, "CVE-2012-1531": {"epss_score": 0.09279, "epss_percentile": 0.9248}, "CVE-2012-1532": {"epss_score": 0.10008, "epss_percentile": 0.92814}, "CVE-2012-1533": {"epss_score": 0.66165, "epss_percentile": 0.98453}, "CVE-2012-1535": {"epss_score": 0.92048, "epss_percentile": 0.99688}, "CVE-2012-1537": {"epss_score": 0.62187, "epss_percentile": 0.98284}, "CVE-2012-1538": {"epss_score": 0.14216, "epss_percentile": 0.94165}, "CVE-2012-1539": {"epss_score": 0.14103, "epss_percentile": 0.94133}, "CVE-2012-1541": {"epss_score": 0.09545, "epss_percentile": 0.92591}, "CVE-2012-1543": {"epss_score": 0.02436, "epss_percentile": 0.8474}, "CVE-2012-1545": {"epss_score": 0.12389, "epss_percentile": 0.93657}, "CVE-2012-1556": {"epss_score": 0.01047, "epss_percentile": 0.77032}, "CVE-2012-1557": {"epss_score": 0.01044, "epss_percentile": 0.77004}, "CVE-2012-1558": {"epss_score": 0.00396, "epss_percentile": 0.59853}, "CVE-2012-1561": {"epss_score": 0.00464, "epss_percentile": 0.6373}, "CVE-2012-1562": {"epss_score": 7e-05, "epss_percentile": 0.00343}, "CVE-2012-1563": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2012-1564": {"epss_score": 0.00374, "epss_percentile": 0.5858}, "CVE-2012-1565": {"epss_score": 0.01752, "epss_percentile": 0.82109}, "CVE-2012-1566": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2012-1567": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2012-1568": {"epss_score": 0.00046, "epss_percentile": 0.14323}, "CVE-2012-1569": {"epss_score": 0.12722, "epss_percentile": 0.93758}, "CVE-2012-1570": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2012-1571": {"epss_score": 0.00235, "epss_percentile": 0.4623}, "CVE-2012-1572": {"epss_score": 0.00416, "epss_percentile": 0.61201}, "CVE-2012-1573": {"epss_score": 0.10166, "epss_percentile": 0.92873}, "CVE-2012-1574": {"epss_score": 0.00293, "epss_percentile": 0.52339}, "CVE-2012-1575": {"epss_score": 0.00557, "epss_percentile": 0.67549}, "CVE-2012-1576": {"epss_score": 0.01374, "epss_percentile": 0.79827}, "CVE-2012-1577": {"epss_score": 0.00914, "epss_percentile": 0.75389}, "CVE-2012-1578": {"epss_score": 0.00302, "epss_percentile": 0.53159}, "CVE-2012-1579": {"epss_score": 0.00578, "epss_percentile": 0.68177}, "CVE-2012-1580": {"epss_score": 0.00302, "epss_percentile": 0.53132}, "CVE-2012-1581": {"epss_score": 0.00539, "epss_percentile": 0.66983}, "CVE-2012-1582": {"epss_score": 0.00642, "epss_percentile": 0.70037}, "CVE-2012-1583": {"epss_score": 0.01343, "epss_percentile": 0.796}, "CVE-2012-1584": {"epss_score": 0.03187, "epss_percentile": 0.86591}, "CVE-2012-1585": {"epss_score": 0.00475, "epss_percentile": 0.64187}, "CVE-2012-1586": {"epss_score": 0.00514, "epss_percentile": 0.65961}, "CVE-2012-1588": {"epss_score": 0.00628, "epss_percentile": 0.69661}, "CVE-2012-1589": {"epss_score": 0.00363, "epss_percentile": 0.579}, "CVE-2012-1590": {"epss_score": 0.0028, "epss_percentile": 0.51095}, "CVE-2012-1591": {"epss_score": 0.00463, "epss_percentile": 0.63678}, "CVE-2012-1592": {"epss_score": 0.00806, "epss_percentile": 0.73662}, "CVE-2012-1593": {"epss_score": 0.0165, "epss_percentile": 0.81563}, "CVE-2012-1594": {"epss_score": 0.00254, "epss_percentile": 0.48547}, "CVE-2012-1595": {"epss_score": 0.01047, "epss_percentile": 0.77035}, "CVE-2012-1596": {"epss_score": 0.02588, "epss_percentile": 0.85174}, "CVE-2012-1597": {"epss_score": 0.02729, "epss_percentile": 0.85534}, "CVE-2012-1598": {"epss_score": 0.01457, "epss_percentile": 0.80404}, "CVE-2012-1599": {"epss_score": 0.00451, "epss_percentile": 0.63147}, "CVE-2012-1600": {"epss_score": 0.00551, "epss_percentile": 0.67374}, "CVE-2012-1601": {"epss_score": 0.00127, "epss_percentile": 0.32916}, "CVE-2012-1602": {"epss_score": 0.00284, "epss_percentile": 0.51478}, "CVE-2012-1603": {"epss_score": 0.02438, "epss_percentile": 0.84747}, "CVE-2012-1604": {"epss_score": 0.05418, "epss_percentile": 0.89852}, "CVE-2012-1605": {"epss_score": 0.0094, "epss_percentile": 0.75738}, "CVE-2012-1606": {"epss_score": 0.00287, "epss_percentile": 0.51809}, "CVE-2012-1607": {"epss_score": 0.00701, "epss_percentile": 0.71504}, "CVE-2012-1608": {"epss_score": 0.00678, "epss_percentile": 0.7097}, "CVE-2012-1610": {"epss_score": 0.07033, "epss_percentile": 0.91202}, "CVE-2012-1611": {"epss_score": 0.00024, "epss_percentile": 0.05794}, "CVE-2012-1612": {"epss_score": 0.00011, "epss_percentile": 0.01036}, "CVE-2012-1613": {"epss_score": 0.02138, "epss_percentile": 0.83741}, "CVE-2012-1614": {"epss_score": 0.1412, "epss_percentile": 0.94137}, "CVE-2012-1615": {"epss_score": 0.00095, "epss_percentile": 0.27165}, "CVE-2012-1616": {"epss_score": 0.09672, "epss_percentile": 0.92648}, "CVE-2012-1617": {"epss_score": 0.09075, "epss_percentile": 0.92387}, "CVE-2012-1618": {"epss_score": 0.019, "epss_percentile": 0.82771}, "CVE-2012-1620": {"epss_score": 0.00097, "epss_percentile": 0.27537}, "CVE-2012-1621": {"epss_score": 0.05543, "epss_percentile": 0.8998}, "CVE-2012-1622": {"epss_score": 0.0648, "epss_percentile": 0.90787}, "CVE-2012-1623": {"epss_score": 0.00262, "epss_percentile": 0.49384}, "CVE-2012-1624": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-1625": {"epss_score": 0.00568, "epss_percentile": 0.67898}, "CVE-2012-1626": {"epss_score": 0.00563, "epss_percentile": 0.67715}, "CVE-2012-1627": {"epss_score": 0.00324, "epss_percentile": 0.54954}, "CVE-2012-1628": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2012-1629": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2012-1630": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2012-1631": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2012-1632": {"epss_score": 0.00175, "epss_percentile": 0.39319}, "CVE-2012-1633": {"epss_score": 0.00172, "epss_percentile": 0.38971}, "CVE-2012-1634": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-1635": {"epss_score": 0.00152, "epss_percentile": 0.365}, "CVE-2012-1636": {"epss_score": 0.00136, "epss_percentile": 0.34116}, "CVE-2012-1637": {"epss_score": 0.00364, "epss_percentile": 0.57918}, "CVE-2012-1638": {"epss_score": 0.00563, "epss_percentile": 0.67715}, "CVE-2012-1639": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-1640": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2012-1641": {"epss_score": 0.01638, "epss_percentile": 0.81486}, "CVE-2012-1642": {"epss_score": 0.00556, "epss_percentile": 0.67521}, "CVE-2012-1643": {"epss_score": 0.00423, "epss_percentile": 0.61623}, "CVE-2012-1644": {"epss_score": 0.00275, "epss_percentile": 0.50647}, "CVE-2012-1645": {"epss_score": 0.00592, "epss_percentile": 0.68615}, "CVE-2012-1646": {"epss_score": 0.00682, "epss_percentile": 0.71086}, "CVE-2012-1647": {"epss_score": 0.0067, "epss_percentile": 0.70779}, "CVE-2012-1648": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-1649": {"epss_score": 0.00829, "epss_percentile": 0.7401}, "CVE-2012-1650": {"epss_score": 0.00406, "epss_percentile": 0.60549}, "CVE-2012-1651": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-1652": {"epss_score": 0.00268, "epss_percentile": 0.50054}, "CVE-2012-1653": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-1654": {"epss_score": 0.00393, "epss_percentile": 0.5971}, "CVE-2012-1655": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2012-1656": {"epss_score": 0.005, "epss_percentile": 0.65305}, "CVE-2012-1657": {"epss_score": 0.00259, "epss_percentile": 0.49079}, "CVE-2012-1658": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-1659": {"epss_score": 0.00268, "epss_percentile": 0.50054}, "CVE-2012-1660": {"epss_score": 0.00458, "epss_percentile": 0.63439}, "CVE-2012-1661": {"epss_score": 0.01613, "epss_percentile": 0.81338}, "CVE-2012-1662": {"epss_score": 0.0182, "epss_percentile": 0.82409}, "CVE-2012-1663": {"epss_score": 0.01967, "epss_percentile": 0.83085}, "CVE-2012-1664": {"epss_score": 0.01325, "epss_percentile": 0.79472}, "CVE-2012-1665": {"epss_score": 0.01082, "epss_percentile": 0.77381}, "CVE-2012-1666": {"epss_score": 0.00241, "epss_percentile": 0.47237}, "CVE-2012-1667": {"epss_score": 0.56279, "epss_percentile": 0.98017}, "CVE-2012-1669": {"epss_score": 0.20055, "epss_percentile": 0.95281}, "CVE-2012-1670": {"epss_score": 0.1393, "epss_percentile": 0.94095}, "CVE-2012-1671": {"epss_score": 0.09826, "epss_percentile": 0.92721}, "CVE-2012-1672": {"epss_score": 0.00549, "epss_percentile": 0.67319}, "CVE-2012-1673": {"epss_score": 0.00549, "epss_percentile": 0.67319}, "CVE-2012-1674": {"epss_score": 0.0024, "epss_percentile": 0.47189}, "CVE-2012-1675": {"epss_score": 0.91967, "epss_percentile": 0.99681}, "CVE-2012-1676": {"epss_score": 0.00191, "epss_percentile": 0.41182}, "CVE-2012-1677": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2012-1678": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2012-1679": {"epss_score": 0.0017, "epss_percentile": 0.38705}, "CVE-2012-1680": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2012-1681": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2012-1682": {"epss_score": 0.02927, "epss_percentile": 0.86008}, "CVE-2012-1683": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2012-1684": {"epss_score": 0.00056, "epss_percentile": 0.17735}, "CVE-2012-1685": {"epss_score": 0.00618, "epss_percentile": 0.6937}, "CVE-2012-1686": {"epss_score": 0.00442, "epss_percentile": 0.62729}, "CVE-2012-1687": {"epss_score": 0.00051, "epss_percentile": 0.16305}, "CVE-2012-1688": {"epss_score": 0.00719, "epss_percentile": 0.71952}, "CVE-2012-1689": {"epss_score": 0.00864, "epss_percentile": 0.74606}, "CVE-2012-1690": {"epss_score": 0.00719, "epss_percentile": 0.71952}, "CVE-2012-1691": {"epss_score": 0.00063, "epss_percentile": 0.19927}, "CVE-2012-1692": {"epss_score": 0.00061, "epss_percentile": 0.19549}, "CVE-2012-1693": {"epss_score": 0.00924, "epss_percentile": 0.75525}, "CVE-2012-1694": {"epss_score": 0.00377, "epss_percentile": 0.58711}, "CVE-2012-1695": {"epss_score": 0.01443, "epss_percentile": 0.80312}, "CVE-2012-1696": {"epss_score": 0.00666, "epss_percentile": 0.7069}, "CVE-2012-1697": {"epss_score": 0.00674, "epss_percentile": 0.70879}, "CVE-2012-1698": {"epss_score": 0.00259, "epss_percentile": 0.49067}, "CVE-2012-1699": {"epss_score": 0.00075, "epss_percentile": 0.23054}, "CVE-2012-1700": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2012-1701": {"epss_score": 0.00295, "epss_percentile": 0.5251}, "CVE-2012-1702": {"epss_score": 0.00805, "epss_percentile": 0.73641}, "CVE-2012-1703": {"epss_score": 0.00804, "epss_percentile": 0.73624}, "CVE-2012-1704": {"epss_score": 0.004, "epss_percentile": 0.60148}, "CVE-2012-1705": {"epss_score": 0.0064, "epss_percentile": 0.69968}, "CVE-2012-1706": {"epss_score": 0.00246, "epss_percentile": 0.47749}, "CVE-2012-1707": {"epss_score": 0.00484, "epss_percentile": 0.64647}, "CVE-2012-1708": {"epss_score": 0.00323, "epss_percentile": 0.54892}, "CVE-2012-1709": {"epss_score": 0.00712, "epss_percentile": 0.71754}, "CVE-2012-1710": {"epss_score": 0.70416, "epss_percentile": 0.98631}, "CVE-2012-1711": {"epss_score": 0.00863, "epss_percentile": 0.74593}, "CVE-2012-1712": {"epss_score": 0.00678, "epss_percentile": 0.70991}, "CVE-2012-1713": {"epss_score": 0.0643, "epss_percentile": 0.90754}, "CVE-2012-1714": {"epss_score": 0.08918, "epss_percentile": 0.92317}, "CVE-2012-1715": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2012-1716": {"epss_score": 0.0484, "epss_percentile": 0.89201}, "CVE-2012-1717": {"epss_score": 0.00134, "epss_percentile": 0.33911}, "CVE-2012-1718": {"epss_score": 0.05146, "epss_percentile": 0.89542}, "CVE-2012-1719": {"epss_score": 0.02455, "epss_percentile": 0.84798}, "CVE-2012-1720": {"epss_score": 0.00061, "epss_percentile": 0.19354}, "CVE-2012-1721": {"epss_score": 0.03008, "epss_percentile": 0.86191}, "CVE-2012-1722": {"epss_score": 0.03008, "epss_percentile": 0.86191}, "CVE-2012-1723": {"epss_score": 0.94083, "epss_percentile": 0.99899}, "CVE-2012-1724": {"epss_score": 0.02488, "epss_percentile": 0.84892}, "CVE-2012-1725": {"epss_score": 0.0484, "epss_percentile": 0.89201}, "CVE-2012-1726": {"epss_score": 0.00417, "epss_percentile": 0.61223}, "CVE-2012-1727": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2012-1728": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2012-1729": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2012-1730": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2012-1731": {"epss_score": 0.00955, "epss_percentile": 0.75913}, "CVE-2012-1732": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2012-1733": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2012-1734": {"epss_score": 0.00542, "epss_percentile": 0.67067}, "CVE-2012-1735": {"epss_score": 0.01119, "epss_percentile": 0.77753}, "CVE-2012-1736": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2012-1737": {"epss_score": 0.01203, "epss_percentile": 0.78494}, "CVE-2012-1738": {"epss_score": 0.01123, "epss_percentile": 0.77792}, "CVE-2012-1739": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2012-1740": {"epss_score": 0.00523, "epss_percentile": 0.66288}, "CVE-2012-1741": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2012-1742": {"epss_score": 0.01493, "epss_percentile": 0.80642}, "CVE-2012-1743": {"epss_score": 0.00405, "epss_percentile": 0.6049}, "CVE-2012-1744": {"epss_score": 0.04637, "epss_percentile": 0.88949}, "CVE-2012-1745": {"epss_score": 0.01107, "epss_percentile": 0.77623}, "CVE-2012-1746": {"epss_score": 0.00874, "epss_percentile": 0.74767}, "CVE-2012-1747": {"epss_score": 0.00719, "epss_percentile": 0.71945}, "CVE-2012-1748": {"epss_score": 0.00397, "epss_percentile": 0.60042}, "CVE-2012-1749": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2012-1750": {"epss_score": 0.00061, "epss_percentile": 0.1954}, "CVE-2012-1751": {"epss_score": 0.00375, "epss_percentile": 0.58637}, "CVE-2012-1752": {"epss_score": 0.00061, "epss_percentile": 0.19549}, "CVE-2012-1753": {"epss_score": 0.00923, "epss_percentile": 0.75506}, "CVE-2012-1754": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2012-1755": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2012-1756": {"epss_score": 0.00576, "epss_percentile": 0.68126}, "CVE-2012-1757": {"epss_score": 0.00576, "epss_percentile": 0.68126}, "CVE-2012-1758": {"epss_score": 0.00931, "epss_percentile": 0.75616}, "CVE-2012-1759": {"epss_score": 0.00931, "epss_percentile": 0.75616}, "CVE-2012-1760": {"epss_score": 0.01043, "epss_percentile": 0.76988}, "CVE-2012-1761": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2012-1762": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2012-1763": {"epss_score": 0.00191, "epss_percentile": 0.41182}, "CVE-2012-1764": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2012-1765": {"epss_score": 0.00063, "epss_percentile": 0.19851}, "CVE-2012-1766": {"epss_score": 0.00644, "epss_percentile": 0.70072}, "CVE-2012-1767": {"epss_score": 0.00644, "epss_percentile": 0.70072}, "CVE-2012-1768": {"epss_score": 0.00644, "epss_percentile": 0.70072}, "CVE-2012-1769": {"epss_score": 0.11078, "epss_percentile": 0.93212}, "CVE-2012-1770": {"epss_score": 0.11078, "epss_percentile": 0.93212}, "CVE-2012-1771": {"epss_score": 0.00644, "epss_percentile": 0.70072}, "CVE-2012-1772": {"epss_score": 0.00644, "epss_percentile": 0.70072}, "CVE-2012-1773": {"epss_score": 0.00644, "epss_percentile": 0.70072}, "CVE-2012-1774": {"epss_score": 0.09302, "epss_percentile": 0.9249}, "CVE-2012-1775": {"epss_score": 0.72888, "epss_percentile": 0.98728}, "CVE-2012-1776": {"epss_score": 0.05886, "epss_percentile": 0.90292}, "CVE-2012-1777": {"epss_score": 0.00983, "epss_percentile": 0.76309}, "CVE-2012-1778": {"epss_score": 0.00214, "epss_percentile": 0.44011}, "CVE-2012-1779": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-1780": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2012-1781": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-1782": {"epss_score": 0.02034, "epss_percentile": 0.83347}, "CVE-2012-1783": {"epss_score": 0.06605, "epss_percentile": 0.90883}, "CVE-2012-1784": {"epss_score": 0.00721, "epss_percentile": 0.71983}, "CVE-2012-1785": {"epss_score": 0.02362, "epss_percentile": 0.84503}, "CVE-2012-1786": {"epss_score": 0.003, "epss_percentile": 0.52936}, "CVE-2012-1787": {"epss_score": 0.06571, "epss_percentile": 0.90855}, "CVE-2012-1788": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2012-1789": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-1790": {"epss_score": 0.17169, "epss_percentile": 0.94791}, "CVE-2012-1792": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-1795": {"epss_score": 0.01126, "epss_percentile": 0.77818}, "CVE-2012-1796": {"epss_score": 0.00048, "epss_percentile": 0.15097}, "CVE-2012-1797": {"epss_score": 0.00438, "epss_percentile": 0.62539}, "CVE-2012-1798": {"epss_score": 0.01412, "epss_percentile": 0.80112}, "CVE-2012-1799": {"epss_score": 0.01012, "epss_percentile": 0.76624}, "CVE-2012-1800": {"epss_score": 0.00249, "epss_percentile": 0.48081}, "CVE-2012-1801": {"epss_score": 0.00283, "epss_percentile": 0.51397}, "CVE-2012-1802": {"epss_score": 0.03886, "epss_percentile": 0.87905}, "CVE-2012-1803": {"epss_score": 0.61252, "epss_percentile": 0.98241}, "CVE-2012-1804": {"epss_score": 0.03156, "epss_percentile": 0.86515}, "CVE-2012-1805": {"epss_score": 0.06268, "epss_percentile": 0.90626}, "CVE-2012-1806": {"epss_score": 0.00406, "epss_percentile": 0.60557}, "CVE-2012-1807": {"epss_score": 0.00339, "epss_percentile": 0.56175}, "CVE-2012-1808": {"epss_score": 0.00566, "epss_percentile": 0.67817}, "CVE-2012-1809": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2012-1810": {"epss_score": 0.00785, "epss_percentile": 0.73261}, "CVE-2012-1811": {"epss_score": 0.00965, "epss_percentile": 0.76041}, "CVE-2012-1812": {"epss_score": 0.00584, "epss_percentile": 0.68376}, "CVE-2012-1813": {"epss_score": 0.00965, "epss_percentile": 0.76041}, "CVE-2012-1814": {"epss_score": 0.00567, "epss_percentile": 0.67843}, "CVE-2012-1815": {"epss_score": 0.00517, "epss_percentile": 0.66087}, "CVE-2012-1816": {"epss_score": 0.00785, "epss_percentile": 0.73261}, "CVE-2012-1817": {"epss_score": 0.02379, "epss_percentile": 0.84561}, "CVE-2012-1818": {"epss_score": 0.00562, "epss_percentile": 0.67695}, "CVE-2012-1819": {"epss_score": 0.00542, "epss_percentile": 0.67083}, "CVE-2012-1820": {"epss_score": 0.00205, "epss_percentile": 0.42681}, "CVE-2012-1821": {"epss_score": 0.01934, "epss_percentile": 0.82954}, "CVE-2012-1823": {"epss_score": 0.94386, "epss_percentile": 0.99967}, "CVE-2012-1824": {"epss_score": 0.0008, "epss_percentile": 0.24153}, "CVE-2012-1825": {"epss_score": 0.00842, "epss_percentile": 0.74242}, "CVE-2012-1826": {"epss_score": 0.0101, "epss_percentile": 0.76603}, "CVE-2012-1827": {"epss_score": 0.01184, "epss_percentile": 0.78333}, "CVE-2012-1828": {"epss_score": 0.01184, "epss_percentile": 0.78333}, "CVE-2012-1829": {"epss_score": 0.0165, "epss_percentile": 0.81564}, "CVE-2012-1830": {"epss_score": 0.14407, "epss_percentile": 0.94205}, "CVE-2012-1831": {"epss_score": 0.21986, "epss_percentile": 0.95581}, "CVE-2012-1832": {"epss_score": 0.01813, "epss_percentile": 0.82374}, "CVE-2012-1833": {"epss_score": 0.00188, "epss_percentile": 0.40838}, "CVE-2012-1834": {"epss_score": 0.00397, "epss_percentile": 0.60042}, "CVE-2012-1835": {"epss_score": 0.00975, "epss_percentile": 0.76204}, "CVE-2012-1836": {"epss_score": 0.07419, "epss_percentile": 0.91463}, "CVE-2012-1837": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2012-1838": {"epss_score": 0.00709, "epss_percentile": 0.71695}, "CVE-2012-1839": {"epss_score": 0.00698, "epss_percentile": 0.7143}, "CVE-2012-1840": {"epss_score": 0.00624, "epss_percentile": 0.6956}, "CVE-2012-1841": {"epss_score": 0.0053, "epss_percentile": 0.66632}, "CVE-2012-1842": {"epss_score": 0.00831, "epss_percentile": 0.74044}, "CVE-2012-1843": {"epss_score": 0.00262, "epss_percentile": 0.494}, "CVE-2012-1844": {"epss_score": 0.02257, "epss_percentile": 0.84177}, "CVE-2012-1845": {"epss_score": 0.02512, "epss_percentile": 0.84954}, "CVE-2012-1846": {"epss_score": 0.02056, "epss_percentile": 0.83422}, "CVE-2012-1847": {"epss_score": 0.63939, "epss_percentile": 0.98356}, "CVE-2012-1848": {"epss_score": 0.01448, "epss_percentile": 0.80337}, "CVE-2012-1849": {"epss_score": 0.59138, "epss_percentile": 0.98151}, "CVE-2012-1850": {"epss_score": 0.66144, "epss_percentile": 0.98452}, "CVE-2012-1851": {"epss_score": 0.7245, "epss_percentile": 0.9871}, "CVE-2012-1852": {"epss_score": 0.64397, "epss_percentile": 0.98377}, "CVE-2012-1853": {"epss_score": 0.64397, "epss_percentile": 0.98377}, "CVE-2012-1854": {"epss_score": 0.01951, "epss_percentile": 0.8302}, "CVE-2012-1855": {"epss_score": 0.50262, "epss_percentile": 0.97729}, "CVE-2012-1856": {"epss_score": 0.91946, "epss_percentile": 0.9968}, "CVE-2012-1857": {"epss_score": 0.42215, "epss_percentile": 0.97319}, "CVE-2012-1858": {"epss_score": 0.38107, "epss_percentile": 0.97086}, "CVE-2012-1859": {"epss_score": 0.41343, "epss_percentile": 0.97268}, "CVE-2012-1860": {"epss_score": 0.00874, "epss_percentile": 0.7477}, "CVE-2012-1861": {"epss_score": 0.38882, "epss_percentile": 0.97125}, "CVE-2012-1862": {"epss_score": 0.07026, "epss_percentile": 0.91196}, "CVE-2012-1863": {"epss_score": 0.41343, "epss_percentile": 0.97268}, "CVE-2012-1864": {"epss_score": 0.01229, "epss_percentile": 0.78719}, "CVE-2012-1865": {"epss_score": 0.00879, "epss_percentile": 0.74839}, "CVE-2012-1866": {"epss_score": 0.00731, "epss_percentile": 0.72179}, "CVE-2012-1867": {"epss_score": 0.01025, "epss_percentile": 0.76793}, "CVE-2012-1868": {"epss_score": 0.00573, "epss_percentile": 0.68066}, "CVE-2012-1870": {"epss_score": 0.13818, "epss_percentile": 0.94067}, "CVE-2012-1872": {"epss_score": 0.00926, "epss_percentile": 0.75553}, "CVE-2012-1873": {"epss_score": 0.18627, "epss_percentile": 0.95045}, "CVE-2012-1874": {"epss_score": 0.52969, "epss_percentile": 0.9785}, "CVE-2012-1875": {"epss_score": 0.82181, "epss_percentile": 0.99179}, "CVE-2012-1876": {"epss_score": 0.86119, "epss_percentile": 0.99368}, "CVE-2012-1877": {"epss_score": 0.52969, "epss_percentile": 0.9785}, "CVE-2012-1878": {"epss_score": 0.52969, "epss_percentile": 0.9785}, "CVE-2012-1879": {"epss_score": 0.27683, "epss_percentile": 0.96274}, "CVE-2012-1880": {"epss_score": 0.52969, "epss_percentile": 0.9785}, "CVE-2012-1881": {"epss_score": 0.52969, "epss_percentile": 0.9785}, "CVE-2012-1882": {"epss_score": 0.22876, "epss_percentile": 0.95703}, "CVE-2012-1885": {"epss_score": 0.65939, "epss_percentile": 0.98445}, "CVE-2012-1886": {"epss_score": 0.62114, "epss_percentile": 0.9828}, "CVE-2012-1887": {"epss_score": 0.58328, "epss_percentile": 0.9811}, "CVE-2012-1888": {"epss_score": 0.59759, "epss_percentile": 0.9818}, "CVE-2012-1889": {"epss_score": 0.92781, "epss_percentile": 0.99748}, "CVE-2012-1890": {"epss_score": 0.00731, "epss_percentile": 0.72179}, "CVE-2012-1891": {"epss_score": 0.58978, "epss_percentile": 0.98143}, "CVE-2012-1892": {"epss_score": 0.44933, "epss_percentile": 0.97461}, "CVE-2012-1893": {"epss_score": 0.00731, "epss_percentile": 0.72179}, "CVE-2012-1894": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2012-1895": {"epss_score": 0.10778, "epss_percentile": 0.931}, "CVE-2012-1896": {"epss_score": 0.52249, "epss_percentile": 0.97814}, "CVE-2012-1897": {"epss_score": 0.00252, "epss_percentile": 0.48373}, "CVE-2012-1898": {"epss_score": 0.02187, "epss_percentile": 0.83925}, "CVE-2012-1899": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-1900": {"epss_score": 0.00391, "epss_percentile": 0.59565}, "CVE-2012-1901": {"epss_score": 0.00205, "epss_percentile": 0.42756}, "CVE-2012-1902": {"epss_score": 0.00468, "epss_percentile": 0.63868}, "CVE-2012-1903": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2012-1904": {"epss_score": 0.08511, "epss_percentile": 0.92089}, "CVE-2012-1906": {"epss_score": 0.00063, "epss_percentile": 0.20101}, "CVE-2012-1907": {"epss_score": 0.00184, "epss_percentile": 0.40404}, "CVE-2012-1908": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-1909": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2012-1910": {"epss_score": 0.02991, "epss_percentile": 0.86144}, "CVE-2012-1911": {"epss_score": 0.01325, "epss_percentile": 0.79475}, "CVE-2012-1912": {"epss_score": 0.08914, "epss_percentile": 0.92316}, "CVE-2012-1915": {"epss_score": 0.00282, "epss_percentile": 0.51231}, "CVE-2012-1916": {"epss_score": 0.0241, "epss_percentile": 0.84663}, "CVE-2012-1917": {"epss_score": 0.01187, "epss_percentile": 0.78352}, "CVE-2012-1918": {"epss_score": 0.0046, "epss_percentile": 0.63521}, "CVE-2012-1919": {"epss_score": 0.01904, "epss_percentile": 0.82789}, "CVE-2012-1920": {"epss_score": 0.00524, "epss_percentile": 0.66324}, "CVE-2012-1921": {"epss_score": 0.00555, "epss_percentile": 0.6749}, "CVE-2012-1922": {"epss_score": 0.00464, "epss_percentile": 0.63733}, "CVE-2012-1923": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2012-1924": {"epss_score": 0.01216, "epss_percentile": 0.78596}, "CVE-2012-1925": {"epss_score": 0.01556, "epss_percentile": 0.81017}, "CVE-2012-1926": {"epss_score": 0.0061, "epss_percentile": 0.6914}, "CVE-2012-1927": {"epss_score": 0.01662, "epss_percentile": 0.81635}, "CVE-2012-1928": {"epss_score": 0.01662, "epss_percentile": 0.81635}, "CVE-2012-1929": {"epss_score": 0.01039, "epss_percentile": 0.76952}, "CVE-2012-1930": {"epss_score": 0.00046, "epss_percentile": 0.14473}, "CVE-2012-1931": {"epss_score": 0.00061, "epss_percentile": 0.1954}, "CVE-2012-1932": {"epss_score": 0.00151, "epss_percentile": 0.36221}, "CVE-2012-1933": {"epss_score": 0.07361, "epss_percentile": 0.91432}, "CVE-2012-1934": {"epss_score": 0.01528, "epss_percentile": 0.80872}, "CVE-2012-1935": {"epss_score": 0.08245, "epss_percentile": 0.91948}, "CVE-2012-1936": {"epss_score": 0.00587, "epss_percentile": 0.68482}, "CVE-2012-1937": {"epss_score": 0.01723, "epss_percentile": 0.81942}, "CVE-2012-1938": {"epss_score": 0.01248, "epss_percentile": 0.78868}, "CVE-2012-1939": {"epss_score": 0.03612, "epss_percentile": 0.87426}, "CVE-2012-1940": {"epss_score": 0.03035, "epss_percentile": 0.86259}, "CVE-2012-1941": {"epss_score": 0.06289, "epss_percentile": 0.90647}, "CVE-2012-1942": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2012-1943": {"epss_score": 0.00053, "epss_percentile": 0.1671}, "CVE-2012-1944": {"epss_score": 0.00696, "epss_percentile": 0.71385}, "CVE-2012-1945": {"epss_score": 0.00192, "epss_percentile": 0.41363}, "CVE-2012-1946": {"epss_score": 0.01451, "epss_percentile": 0.80364}, "CVE-2012-1947": {"epss_score": 0.06784, "epss_percentile": 0.91025}, "CVE-2012-1948": {"epss_score": 0.03749, "epss_percentile": 0.87671}, "CVE-2012-1949": {"epss_score": 0.03749, "epss_percentile": 0.87671}, "CVE-2012-1950": {"epss_score": 0.02775, "epss_percentile": 0.85635}, "CVE-2012-1951": {"epss_score": 0.03397, "epss_percentile": 0.87062}, "CVE-2012-1952": {"epss_score": 0.01557, "epss_percentile": 0.81021}, "CVE-2012-1953": {"epss_score": 0.0172, "epss_percentile": 0.81932}, "CVE-2012-1954": {"epss_score": 0.05001, "epss_percentile": 0.89378}, "CVE-2012-1955": {"epss_score": 0.02583, "epss_percentile": 0.85158}, "CVE-2012-1956": {"epss_score": 0.00743, "epss_percentile": 0.72495}, "CVE-2012-1957": {"epss_score": 0.00998, "epss_percentile": 0.76471}, "CVE-2012-1958": {"epss_score": 0.03872, "epss_percentile": 0.87882}, "CVE-2012-1959": {"epss_score": 0.0093, "epss_percentile": 0.75601}, "CVE-2012-1960": {"epss_score": 0.00542, "epss_percentile": 0.67074}, "CVE-2012-1961": {"epss_score": 0.01172, "epss_percentile": 0.78233}, "CVE-2012-1962": {"epss_score": 0.03397, "epss_percentile": 0.87062}, "CVE-2012-1963": {"epss_score": 0.01487, "epss_percentile": 0.80612}, "CVE-2012-1964": {"epss_score": 0.00901, "epss_percentile": 0.7518}, "CVE-2012-1965": {"epss_score": 0.01216, "epss_percentile": 0.78593}, "CVE-2012-1966": {"epss_score": 0.01351, "epss_percentile": 0.79678}, "CVE-2012-1967": {"epss_score": 0.03399, "epss_percentile": 0.87065}, "CVE-2012-1968": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-1969": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2012-1970": {"epss_score": 0.00873, "epss_percentile": 0.74746}, "CVE-2012-1971": {"epss_score": 0.02146, "epss_percentile": 0.83765}, "CVE-2012-1972": {"epss_score": 0.03305, "epss_percentile": 0.86874}, "CVE-2012-1973": {"epss_score": 0.04246, "epss_percentile": 0.88441}, "CVE-2012-1974": {"epss_score": 0.03305, "epss_percentile": 0.86874}, "CVE-2012-1975": {"epss_score": 0.03305, "epss_percentile": 0.86874}, "CVE-2012-1976": {"epss_score": 0.03172, "epss_percentile": 0.8655}, "CVE-2012-1977": {"epss_score": 0.0026, "epss_percentile": 0.49188}, "CVE-2012-1978": {"epss_score": 0.00686, "epss_percentile": 0.71169}, "CVE-2012-1979": {"epss_score": 0.0105, "epss_percentile": 0.77067}, "CVE-2012-1982": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2012-1984": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2012-1985": {"epss_score": 0.0022, "epss_percentile": 0.44592}, "CVE-2012-1986": {"epss_score": 0.00374, "epss_percentile": 0.58554}, "CVE-2012-1987": {"epss_score": 0.00763, "epss_percentile": 0.72883}, "CVE-2012-1988": {"epss_score": 0.00492, "epss_percentile": 0.65014}, "CVE-2012-1989": {"epss_score": 0.00094, "epss_percentile": 0.2704}, "CVE-2012-1990": {"epss_score": 0.00959, "epss_percentile": 0.7596}, "CVE-2012-1992": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2012-1993": {"epss_score": 0.00076, "epss_percentile": 0.23237}, "CVE-2012-1994": {"epss_score": 0.00478, "epss_percentile": 0.64403}, "CVE-2012-1995": {"epss_score": 0.00063, "epss_percentile": 0.19875}, "CVE-2012-1996": {"epss_score": 0.00576, "epss_percentile": 0.68146}, "CVE-2012-1997": {"epss_score": 0.01067, "epss_percentile": 0.77229}, "CVE-2012-1998": {"epss_score": 0.00468, "epss_percentile": 0.63913}, "CVE-2012-1999": {"epss_score": 0.00196, "epss_percentile": 0.41743}, "CVE-2012-20001": {"epss_score": 0.00401, "epss_percentile": 0.60208}, "CVE-2012-2000": {"epss_score": 0.06554, "epss_percentile": 0.90845}, "CVE-2012-2001": {"epss_score": 0.00636, "epss_percentile": 0.69877}, "CVE-2012-2002": {"epss_score": 0.01214, "epss_percentile": 0.78572}, "CVE-2012-2003": {"epss_score": 0.00257, "epss_percentile": 0.48916}, "CVE-2012-2004": {"epss_score": 0.0126, "epss_percentile": 0.78969}, "CVE-2012-2005": {"epss_score": 0.00747, "epss_percentile": 0.72575}, "CVE-2012-2006": {"epss_score": 0.0052, "epss_percentile": 0.66195}, "CVE-2012-2007": {"epss_score": 0.00863, "epss_percentile": 0.74585}, "CVE-2012-2008": {"epss_score": 0.00674, "epss_percentile": 0.70872}, "CVE-2012-2009": {"epss_score": 0.00236, "epss_percentile": 0.46371}, "CVE-2012-2010": {"epss_score": 0.00256, "epss_percentile": 0.48774}, "CVE-2012-2011": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2012-2012": {"epss_score": 0.04477, "epss_percentile": 0.8874}, "CVE-2012-2013": {"epss_score": 0.01302, "epss_percentile": 0.79302}, "CVE-2012-2014": {"epss_score": 0.0025, "epss_percentile": 0.48096}, "CVE-2012-2015": {"epss_score": 0.0025, "epss_percentile": 0.48096}, "CVE-2012-2016": {"epss_score": 0.00088, "epss_percentile": 0.25785}, "CVE-2012-2017": {"epss_score": 0.04621, "epss_percentile": 0.88932}, "CVE-2012-2018": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2012-2019": {"epss_score": 0.756, "epss_percentile": 0.98858}, "CVE-2012-2020": {"epss_score": 0.756, "epss_percentile": 0.98858}, "CVE-2012-2021": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2012-2022": {"epss_score": 0.01171, "epss_percentile": 0.78216}, "CVE-2012-2023": {"epss_score": 0.13371, "epss_percentile": 0.93945}, "CVE-2012-2024": {"epss_score": 0.13868, "epss_percentile": 0.9408}, "CVE-2012-2025": {"epss_score": 0.13868, "epss_percentile": 0.9408}, "CVE-2012-2026": {"epss_score": 0.13371, "epss_percentile": 0.93945}, "CVE-2012-2027": {"epss_score": 0.35441, "epss_percentile": 0.9691}, "CVE-2012-2028": {"epss_score": 0.167, "epss_percentile": 0.94717}, "CVE-2012-2029": {"epss_score": 0.15988, "epss_percentile": 0.94549}, "CVE-2012-2030": {"epss_score": 0.15988, "epss_percentile": 0.94549}, "CVE-2012-2031": {"epss_score": 0.15306, "epss_percentile": 0.94406}, "CVE-2012-2032": {"epss_score": 0.04876, "epss_percentile": 0.89241}, "CVE-2012-2033": {"epss_score": 0.13868, "epss_percentile": 0.9408}, "CVE-2012-2034": {"epss_score": 0.10712, "epss_percentile": 0.9308}, "CVE-2012-2035": {"epss_score": 0.03472, "epss_percentile": 0.87201}, "CVE-2012-2036": {"epss_score": 0.0447, "epss_percentile": 0.88733}, "CVE-2012-2037": {"epss_score": 0.04262, "epss_percentile": 0.88463}, "CVE-2012-2038": {"epss_score": 0.01362, "epss_percentile": 0.79759}, "CVE-2012-2039": {"epss_score": 0.03866, "epss_percentile": 0.87873}, "CVE-2012-2040": {"epss_score": 0.01249, "epss_percentile": 0.78869}, "CVE-2012-2041": {"epss_score": 0.00667, "epss_percentile": 0.70711}, "CVE-2012-2042": {"epss_score": 0.06603, "epss_percentile": 0.9088}, "CVE-2012-2043": {"epss_score": 0.09187, "epss_percentile": 0.92438}, "CVE-2012-2044": {"epss_score": 0.09187, "epss_percentile": 0.92438}, "CVE-2012-2045": {"epss_score": 0.09187, "epss_percentile": 0.92438}, "CVE-2012-2046": {"epss_score": 0.09187, "epss_percentile": 0.92438}, "CVE-2012-2047": {"epss_score": 0.09187, "epss_percentile": 0.92438}, "CVE-2012-2048": {"epss_score": 0.01488, "epss_percentile": 0.80617}, "CVE-2012-2049": {"epss_score": 0.31225, "epss_percentile": 0.96601}, "CVE-2012-2050": {"epss_score": 0.3039, "epss_percentile": 0.96535}, "CVE-2012-2051": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-2052": {"epss_score": 0.62741, "epss_percentile": 0.98307}, "CVE-2012-2053": {"epss_score": 0.00047, "epss_percentile": 0.14623}, "CVE-2012-2054": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2012-2055": {"epss_score": 0.01066, "epss_percentile": 0.77216}, "CVE-2012-2056": {"epss_score": 0.00173, "epss_percentile": 0.3907}, "CVE-2012-2057": {"epss_score": 0.00171, "epss_percentile": 0.38855}, "CVE-2012-2058": {"epss_score": 0.00389, "epss_percentile": 0.59495}, "CVE-2012-2059": {"epss_score": 0.00259, "epss_percentile": 0.49075}, "CVE-2012-2060": {"epss_score": 0.00259, "epss_percentile": 0.49075}, "CVE-2012-2061": {"epss_score": 0.00084, "epss_percentile": 0.24853}, "CVE-2012-2062": {"epss_score": 0.00267, "epss_percentile": 0.49976}, "CVE-2012-2063": {"epss_score": 0.00556, "epss_percentile": 0.67521}, "CVE-2012-2064": {"epss_score": 0.00499, "epss_percentile": 0.65274}, "CVE-2012-2065": {"epss_score": 0.00335, "epss_percentile": 0.55864}, "CVE-2012-2066": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2012-2067": {"epss_score": 0.01029, "epss_percentile": 0.76827}, "CVE-2012-2068": {"epss_score": 0.00343, "epss_percentile": 0.56436}, "CVE-2012-2069": {"epss_score": 0.00438, "epss_percentile": 0.62568}, "CVE-2012-2070": {"epss_score": 0.00446, "epss_percentile": 0.62908}, "CVE-2012-2071": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-2072": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-2073": {"epss_score": 0.00871, "epss_percentile": 0.74719}, "CVE-2012-2074": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2012-2075": {"epss_score": 0.00343, "epss_percentile": 0.56436}, "CVE-2012-2076": {"epss_score": 0.00259, "epss_percentile": 0.49079}, "CVE-2012-2077": {"epss_score": 0.00209, "epss_percentile": 0.43317}, "CVE-2012-2078": {"epss_score": 0.00364, "epss_percentile": 0.57918}, "CVE-2012-2079": {"epss_score": 0.00234, "epss_percentile": 0.4608}, "CVE-2012-2080": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2012-2081": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2012-2082": {"epss_score": 0.00343, "epss_percentile": 0.56436}, "CVE-2012-2083": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-2084": {"epss_score": 0.00682, "epss_percentile": 0.71086}, "CVE-2012-2085": {"epss_score": 0.00636, "epss_percentile": 0.69864}, "CVE-2012-2086": {"epss_score": 0.00717, "epss_percentile": 0.71882}, "CVE-2012-2087": {"epss_score": 0.03332, "epss_percentile": 0.86929}, "CVE-2012-2088": {"epss_score": 0.02978, "epss_percentile": 0.86113}, "CVE-2012-2089": {"epss_score": 0.05317, "epss_percentile": 0.89724}, "CVE-2012-2090": {"epss_score": 0.07467, "epss_percentile": 0.91489}, "CVE-2012-2091": {"epss_score": 0.0904, "epss_percentile": 0.92378}, "CVE-2012-2092": {"epss_score": 0.00093, "epss_percentile": 0.26647}, "CVE-2012-2093": {"epss_score": 0.00047, "epss_percentile": 0.14786}, "CVE-2012-2094": {"epss_score": 0.01332, "epss_percentile": 0.79522}, "CVE-2012-2095": {"epss_score": 0.0056, "epss_percentile": 0.67647}, "CVE-2012-2096": {"epss_score": 0.00344, "epss_percentile": 0.56483}, "CVE-2012-2097": {"epss_score": 0.00475, "epss_percentile": 0.64185}, "CVE-2012-2098": {"epss_score": 0.02865, "epss_percentile": 0.85861}, "CVE-2012-2099": {"epss_score": 0.26694, "epss_percentile": 0.96166}, "CVE-2012-2100": {"epss_score": 0.00865, "epss_percentile": 0.74624}, "CVE-2012-2101": {"epss_score": 0.00885, "epss_percentile": 0.74946}, "CVE-2012-2102": {"epss_score": 0.00466, "epss_percentile": 0.63799}, "CVE-2012-2103": {"epss_score": 0.00039, "epss_percentile": 0.11799}, "CVE-2012-2104": {"epss_score": 0.03694, "epss_percentile": 0.87583}, "CVE-2012-2105": {"epss_score": 0.00462, "epss_percentile": 0.63613}, "CVE-2012-2106": {"epss_score": 0.04789, "epss_percentile": 0.89148}, "CVE-2012-2107": {"epss_score": 0.05126, "epss_percentile": 0.89524}, "CVE-2012-2108": {"epss_score": 0.05809, "epss_percentile": 0.90226}, "CVE-2012-2109": {"epss_score": 0.02883, "epss_percentile": 0.85903}, "CVE-2012-2110": {"epss_score": 0.07525, "epss_percentile": 0.91516}, "CVE-2012-2111": {"epss_score": 0.02255, "epss_percentile": 0.84166}, "CVE-2012-2112": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2012-2113": {"epss_score": 0.0117, "epss_percentile": 0.78208}, "CVE-2012-2114": {"epss_score": 0.01028, "epss_percentile": 0.76814}, "CVE-2012-2115": {"epss_score": 0.00152, "epss_percentile": 0.36406}, "CVE-2012-2116": {"epss_score": 0.002, "epss_percentile": 0.42239}, "CVE-2012-2117": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2012-2118": {"epss_score": 0.02146, "epss_percentile": 0.83765}, "CVE-2012-2119": {"epss_score": 0.00331, "epss_percentile": 0.55545}, "CVE-2012-2120": {"epss_score": 0.00056, "epss_percentile": 0.1771}, "CVE-2012-2121": {"epss_score": 0.00127, "epss_percentile": 0.32916}, "CVE-2012-2122": {"epss_score": 0.94058, "epss_percentile": 0.99894}, "CVE-2012-2123": {"epss_score": 0.00059, "epss_percentile": 0.18718}, "CVE-2012-2124": {"epss_score": 0.00769, "epss_percentile": 0.72989}, "CVE-2012-2125": {"epss_score": 0.00638, "epss_percentile": 0.69922}, "CVE-2012-2126": {"epss_score": 0.00272, "epss_percentile": 0.50398}, "CVE-2012-2127": {"epss_score": 0.01921, "epss_percentile": 0.829}, "CVE-2012-2128": {"epss_score": 0.00375, "epss_percentile": 0.58599}, "CVE-2012-2129": {"epss_score": 0.0083, "epss_percentile": 0.74024}, "CVE-2012-2130": {"epss_score": 0.00074, "epss_percentile": 0.22739}, "CVE-2012-2131": {"epss_score": 0.07418, "epss_percentile": 0.91462}, "CVE-2012-2132": {"epss_score": 0.00257, "epss_percentile": 0.48865}, "CVE-2012-2133": {"epss_score": 0.0008, "epss_percentile": 0.24178}, "CVE-2012-2134": {"epss_score": 0.01019, "epss_percentile": 0.76723}, "CVE-2012-2135": {"epss_score": 0.01619, "epss_percentile": 0.81379}, "CVE-2012-2136": {"epss_score": 0.00104, "epss_percentile": 0.29233}, "CVE-2012-2137": {"epss_score": 0.00067, "epss_percentile": 0.21039}, "CVE-2012-2138": {"epss_score": 0.37773, "epss_percentile": 0.97068}, "CVE-2012-2139": {"epss_score": 0.02666, "epss_percentile": 0.85377}, "CVE-2012-2140": {"epss_score": 0.03667, "epss_percentile": 0.87535}, "CVE-2012-2141": {"epss_score": 0.01274, "epss_percentile": 0.7909}, "CVE-2012-2142": {"epss_score": 0.01333, "epss_percentile": 0.7953}, "CVE-2012-2143": {"epss_score": 0.03869, "epss_percentile": 0.87877}, "CVE-2012-2144": {"epss_score": 0.02937, "epss_percentile": 0.86027}, "CVE-2012-2145": {"epss_score": 0.0715, "epss_percentile": 0.91286}, "CVE-2012-2146": {"epss_score": 0.00464, "epss_percentile": 0.63707}, "CVE-2012-2147": {"epss_score": 0.01258, "epss_percentile": 0.7896}, "CVE-2012-2148": {"epss_score": 0.00102, "epss_percentile": 0.28849}, "CVE-2012-2149": {"epss_score": 0.07693, "epss_percentile": 0.9163}, "CVE-2012-2150": {"epss_score": 0.01737, "epss_percentile": 0.8202}, "CVE-2012-2151": {"epss_score": 0.00557, "epss_percentile": 0.67549}, "CVE-2012-2152": {"epss_score": 0.03884, "epss_percentile": 0.87901}, "CVE-2012-2153": {"epss_score": 0.00432, "epss_percentile": 0.62096}, "CVE-2012-2154": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-2155": {"epss_score": 0.00254, "epss_percentile": 0.48535}, "CVE-2012-2156": {"epss_score": 0.0248, "epss_percentile": 0.84871}, "CVE-2012-2159": {"epss_score": 0.00246, "epss_percentile": 0.47784}, "CVE-2012-2160": {"epss_score": 0.0015, "epss_percentile": 0.36082}, "CVE-2012-2161": {"epss_score": 0.00289, "epss_percentile": 0.52034}, "CVE-2012-2162": {"epss_score": 0.0054, "epss_percentile": 0.67005}, "CVE-2012-2163": {"epss_score": 0.00676, "epss_percentile": 0.70939}, "CVE-2012-2164": {"epss_score": 0.00154, "epss_percentile": 0.3668}, "CVE-2012-2165": {"epss_score": 0.00151, "epss_percentile": 0.36324}, "CVE-2012-2166": {"epss_score": 0.02991, "epss_percentile": 0.86144}, "CVE-2012-2167": {"epss_score": 0.01103, "epss_percentile": 0.77594}, "CVE-2012-2168": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2012-2169": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2012-2170": {"epss_score": 0.00325, "epss_percentile": 0.55}, "CVE-2012-2171": {"epss_score": 0.00975, "epss_percentile": 0.76199}, "CVE-2012-2172": {"epss_score": 0.04256, "epss_percentile": 0.88459}, "CVE-2012-2173": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2012-2174": {"epss_score": 0.64625, "epss_percentile": 0.98387}, "CVE-2012-2175": {"epss_score": 0.66496, "epss_percentile": 0.98465}, "CVE-2012-2176": {"epss_score": 0.61923, "epss_percentile": 0.98267}, "CVE-2012-2177": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2012-2179": {"epss_score": 0.00223, "epss_percentile": 0.44896}, "CVE-2012-2180": {"epss_score": 0.01001, "epss_percentile": 0.76499}, "CVE-2012-2181": {"epss_score": 0.00094, "epss_percentile": 0.27013}, "CVE-2012-2183": {"epss_score": 0.00744, "epss_percentile": 0.72508}, "CVE-2012-2184": {"epss_score": 0.00609, "epss_percentile": 0.69096}, "CVE-2012-2185": {"epss_score": 0.00226, "epss_percentile": 0.45276}, "CVE-2012-2186": {"epss_score": 0.00465, "epss_percentile": 0.63767}, "CVE-2012-2187": {"epss_score": 0.00267, "epss_percentile": 0.49953}, "CVE-2012-2188": {"epss_score": 0.00055, "epss_percentile": 0.17426}, "CVE-2012-2190": {"epss_score": 0.00594, "epss_percentile": 0.68675}, "CVE-2012-2191": {"epss_score": 0.0474, "epss_percentile": 0.8908}, "CVE-2012-2192": {"epss_score": 0.00062, "epss_percentile": 0.19735}, "CVE-2012-2193": {"epss_score": 0.00229, "epss_percentile": 0.45559}, "CVE-2012-2194": {"epss_score": 0.00651, "epss_percentile": 0.70284}, "CVE-2012-2196": {"epss_score": 0.00619, "epss_percentile": 0.69398}, "CVE-2012-2197": {"epss_score": 0.12867, "epss_percentile": 0.93805}, "CVE-2012-2199": {"epss_score": 0.00594, "epss_percentile": 0.68675}, "CVE-2012-2200": {"epss_score": 0.00114, "epss_percentile": 0.30767}, "CVE-2012-2201": {"epss_score": 0.00366, "epss_percentile": 0.58083}, "CVE-2012-2202": {"epss_score": 0.04557, "epss_percentile": 0.88848}, "CVE-2012-2203": {"epss_score": 0.00962, "epss_percentile": 0.75992}, "CVE-2012-2204": {"epss_score": 0.00055, "epss_percentile": 0.17648}, "CVE-2012-2205": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2012-2206": {"epss_score": 0.07716, "epss_percentile": 0.9164}, "CVE-2012-2208": {"epss_score": 0.19226, "epss_percentile": 0.95152}, "CVE-2012-2209": {"epss_score": 0.06652, "epss_percentile": 0.90916}, "CVE-2012-2210": {"epss_score": 0.29191, "epss_percentile": 0.96423}, "CVE-2012-2211": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-2212": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2012-2213": {"epss_score": 0.02119, "epss_percentile": 0.8367}, "CVE-2012-2214": {"epss_score": 0.00543, "epss_percentile": 0.6709}, "CVE-2012-2215": {"epss_score": 0.37034, "epss_percentile": 0.97015}, "CVE-2012-2217": {"epss_score": 0.00377, "epss_percentile": 0.58711}, "CVE-2012-2223": {"epss_score": 0.01171, "epss_percentile": 0.78225}, "CVE-2012-2224": {"epss_score": 0.01888, "epss_percentile": 0.82722}, "CVE-2012-2225": {"epss_score": 0.01521, "epss_percentile": 0.8083}, "CVE-2012-2226": {"epss_score": 0.13027, "epss_percentile": 0.93848}, "CVE-2012-2227": {"epss_score": 0.205, "epss_percentile": 0.95356}, "CVE-2012-2230": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2012-2234": {"epss_score": 0.03342, "epss_percentile": 0.86943}, "CVE-2012-2235": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-2236": {"epss_score": 0.00201, "epss_percentile": 0.42388}, "CVE-2012-2237": {"epss_score": 0.06623, "epss_percentile": 0.90897}, "CVE-2012-2238": {"epss_score": 0.00353, "epss_percentile": 0.5715}, "CVE-2012-2239": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2012-2240": {"epss_score": 0.00975, "epss_percentile": 0.762}, "CVE-2012-2241": {"epss_score": 0.00561, "epss_percentile": 0.6767}, "CVE-2012-2242": {"epss_score": 0.00644, "epss_percentile": 0.70079}, "CVE-2012-2243": {"epss_score": 0.0063, "epss_percentile": 0.69704}, "CVE-2012-2244": {"epss_score": 0.00353, "epss_percentile": 0.57192}, "CVE-2012-2246": {"epss_score": 0.00286, "epss_percentile": 0.51754}, "CVE-2012-2247": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-2248": {"epss_score": 0.0244, "epss_percentile": 0.84751}, "CVE-2012-2249": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-2250": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-2251": {"epss_score": 0.00049, "epss_percentile": 0.1533}, "CVE-2012-2252": {"epss_score": 0.0006, "epss_percentile": 0.19093}, "CVE-2012-2253": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2012-2267": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2012-2268": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2012-2269": {"epss_score": 0.00855, "epss_percentile": 0.74471}, "CVE-2012-2270": {"epss_score": 0.16512, "epss_percentile": 0.94682}, "CVE-2012-2271": {"epss_score": 0.52822, "epss_percentile": 0.97843}, "CVE-2012-2273": {"epss_score": 0.00112, "epss_percentile": 0.30504}, "CVE-2012-2274": {"epss_score": 0.00882, "epss_percentile": 0.74893}, "CVE-2012-2275": {"epss_score": 0.00386, "epss_percentile": 0.59261}, "CVE-2012-2276": {"epss_score": 0.1651, "epss_percentile": 0.94682}, "CVE-2012-2277": {"epss_score": 0.21357, "epss_percentile": 0.95506}, "CVE-2012-2278": {"epss_score": 0.00202, "epss_percentile": 0.42465}, "CVE-2012-2279": {"epss_score": 0.00662, "epss_percentile": 0.70605}, "CVE-2012-2280": {"epss_score": 0.00208, "epss_percentile": 0.43295}, "CVE-2012-2281": {"epss_score": 0.00326, "epss_percentile": 0.55042}, "CVE-2012-2282": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2012-2283": {"epss_score": 0.00171, "epss_percentile": 0.38827}, "CVE-2012-2284": {"epss_score": 0.00071, "epss_percentile": 0.22215}, "CVE-2012-2285": {"epss_score": 0.00647, "epss_percentile": 0.70179}, "CVE-2012-2286": {"epss_score": 0.0013, "epss_percentile": 0.33312}, "CVE-2012-2287": {"epss_score": 0.00228, "epss_percentile": 0.45527}, "CVE-2012-2288": {"epss_score": 0.70456, "epss_percentile": 0.98633}, "CVE-2012-2289": {"epss_score": 0.01128, "epss_percentile": 0.77826}, "CVE-2012-2290": {"epss_score": 0.04683, "epss_percentile": 0.89004}, "CVE-2012-2291": {"epss_score": 0.00032, "epss_percentile": 0.09103}, "CVE-2012-2292": {"epss_score": 0.00225, "epss_percentile": 0.45089}, "CVE-2012-2293": {"epss_score": 0.01321, "epss_percentile": 0.79443}, "CVE-2012-2294": {"epss_score": 0.00396, "epss_percentile": 0.599}, "CVE-2012-2296": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2012-2297": {"epss_score": 0.00354, "epss_percentile": 0.57245}, "CVE-2012-2298": {"epss_score": 0.00672, "epss_percentile": 0.7081}, "CVE-2012-2299": {"epss_score": 0.00082, "epss_percentile": 0.24589}, "CVE-2012-2300": {"epss_score": 0.00472, "epss_percentile": 0.64072}, "CVE-2012-2301": {"epss_score": 0.00876, "epss_percentile": 0.74791}, "CVE-2012-2302": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2012-2303": {"epss_score": 0.00833, "epss_percentile": 0.74087}, "CVE-2012-2304": {"epss_score": 0.00588, "epss_percentile": 0.68505}, "CVE-2012-2305": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2012-2306": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2012-2307": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2012-2308": {"epss_score": 0.00175, "epss_percentile": 0.39319}, "CVE-2012-2309": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2012-2310": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-2311": {"epss_score": 0.88444, "epss_percentile": 0.99473}, "CVE-2012-2312": {"epss_score": 0.00042, "epss_percentile": 0.12746}, "CVE-2012-2313": {"epss_score": 0.00224, "epss_percentile": 0.45064}, "CVE-2012-2314": {"epss_score": 0.00081, "epss_percentile": 0.24233}, "CVE-2012-2315": {"epss_score": 0.08342, "epss_percentile": 0.92}, "CVE-2012-2316": {"epss_score": 0.02419, "epss_percentile": 0.847}, "CVE-2012-2317": {"epss_score": 0.00252, "epss_percentile": 0.48343}, "CVE-2012-2318": {"epss_score": 0.00845, "epss_percentile": 0.74288}, "CVE-2012-2319": {"epss_score": 0.00131, "epss_percentile": 0.33444}, "CVE-2012-2320": {"epss_score": 0.01558, "epss_percentile": 0.81022}, "CVE-2012-2321": {"epss_score": 0.03492, "epss_percentile": 0.87233}, "CVE-2012-2322": {"epss_score": 0.01922, "epss_percentile": 0.82904}, "CVE-2012-2324": {"epss_score": 0.00275, "epss_percentile": 0.50638}, "CVE-2012-2325": {"epss_score": 0.00275, "epss_percentile": 0.50638}, "CVE-2012-2326": {"epss_score": 0.00343, "epss_percentile": 0.56428}, "CVE-2012-2327": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-2328": {"epss_score": 0.0063, "epss_percentile": 0.69691}, "CVE-2012-2329": {"epss_score": 0.79567, "epss_percentile": 0.99045}, "CVE-2012-2330": {"epss_score": 0.0062, "epss_percentile": 0.69453}, "CVE-2012-2331": {"epss_score": 0.14788, "epss_percentile": 0.94284}, "CVE-2012-2332": {"epss_score": 0.01325, "epss_percentile": 0.79475}, "CVE-2012-2333": {"epss_score": 0.06763, "epss_percentile": 0.9101}, "CVE-2012-2334": {"epss_score": 0.08516, "epss_percentile": 0.92097}, "CVE-2012-2335": {"epss_score": 0.20579, "epss_percentile": 0.9538}, "CVE-2012-2336": {"epss_score": 0.08259, "epss_percentile": 0.91956}, "CVE-2012-2337": {"epss_score": 0.00047, "epss_percentile": 0.14798}, "CVE-2012-2338": {"epss_score": 0.00287, "epss_percentile": 0.51803}, "CVE-2012-2339": {"epss_score": 0.00925, "epss_percentile": 0.75529}, "CVE-2012-2340": {"epss_score": 0.00273, "epss_percentile": 0.50429}, "CVE-2012-2341": {"epss_score": 0.00342, "epss_percentile": 0.56391}, "CVE-2012-2350": {"epss_score": 0.00425, "epss_percentile": 0.61721}, "CVE-2012-2351": {"epss_score": 0.00331, "epss_percentile": 0.55522}, "CVE-2012-2352": {"epss_score": 0.01249, "epss_percentile": 0.7887}, "CVE-2012-2353": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2012-2354": {"epss_score": 0.00156, "epss_percentile": 0.36988}, "CVE-2012-2355": {"epss_score": 0.00135, "epss_percentile": 0.33938}, "CVE-2012-2356": {"epss_score": 0.00135, "epss_percentile": 0.33938}, "CVE-2012-2357": {"epss_score": 0.00282, "epss_percentile": 0.51278}, "CVE-2012-2358": {"epss_score": 0.0017, "epss_percentile": 0.38661}, "CVE-2012-2359": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2012-2360": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2012-2361": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2012-2362": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-2363": {"epss_score": 0.00267, "epss_percentile": 0.49983}, "CVE-2012-2364": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2012-2365": {"epss_score": 0.0018, "epss_percentile": 0.39898}, "CVE-2012-2366": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2012-2367": {"epss_score": 0.00241, "epss_percentile": 0.47278}, "CVE-2012-2368": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-2369": {"epss_score": 0.02393, "epss_percentile": 0.84608}, "CVE-2012-2370": {"epss_score": 0.02266, "epss_percentile": 0.84198}, "CVE-2012-2371": {"epss_score": 0.04956, "epss_percentile": 0.89328}, "CVE-2012-2372": {"epss_score": 0.00121, "epss_percentile": 0.32001}, "CVE-2012-2373": {"epss_score": 0.00101, "epss_percentile": 0.28705}, "CVE-2012-2374": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-2375": {"epss_score": 0.00355, "epss_percentile": 0.57284}, "CVE-2012-2376": {"epss_score": 0.29254, "epss_percentile": 0.96427}, "CVE-2012-2377": {"epss_score": 0.00989, "epss_percentile": 0.76373}, "CVE-2012-2378": {"epss_score": 0.04238, "epss_percentile": 0.8843}, "CVE-2012-2379": {"epss_score": 0.03752, "epss_percentile": 0.87677}, "CVE-2012-2380": {"epss_score": 0.00181, "epss_percentile": 0.401}, "CVE-2012-2381": {"epss_score": 0.00204, "epss_percentile": 0.42614}, "CVE-2012-2383": {"epss_score": 0.00064, "epss_percentile": 0.20403}, "CVE-2012-2384": {"epss_score": 0.00064, "epss_percentile": 0.20403}, "CVE-2012-2385": {"epss_score": 0.11882, "epss_percentile": 0.93504}, "CVE-2012-2386": {"epss_score": 0.27171, "epss_percentile": 0.96215}, "CVE-2012-2387": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-2388": {"epss_score": 0.00865, "epss_percentile": 0.74625}, "CVE-2012-2389": {"epss_score": 0.00048, "epss_percentile": 0.1516}, "CVE-2012-2390": {"epss_score": 0.00017, "epss_percentile": 0.03319}, "CVE-2012-2392": {"epss_score": 0.033, "epss_percentile": 0.86865}, "CVE-2012-2393": {"epss_score": 0.01396, "epss_percentile": 0.79982}, "CVE-2012-2394": {"epss_score": 0.01824, "epss_percentile": 0.82427}, "CVE-2012-2395": {"epss_score": 0.00771, "epss_percentile": 0.7302}, "CVE-2012-2396": {"epss_score": 0.02296, "epss_percentile": 0.84295}, "CVE-2012-2397": {"epss_score": 0.002, "epss_percentile": 0.42238}, "CVE-2012-2398": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-2399": {"epss_score": 0.0606, "epss_percentile": 0.90442}, "CVE-2012-2400": {"epss_score": 0.01738, "epss_percentile": 0.82021}, "CVE-2012-2401": {"epss_score": 0.01038, "epss_percentile": 0.76932}, "CVE-2012-2402": {"epss_score": 0.00932, "epss_percentile": 0.75629}, "CVE-2012-2403": {"epss_score": 0.03128, "epss_percentile": 0.86461}, "CVE-2012-2404": {"epss_score": 0.02327, "epss_percentile": 0.84394}, "CVE-2012-2405": {"epss_score": 0.00284, "epss_percentile": 0.51419}, "CVE-2012-2406": {"epss_score": 0.04318, "epss_percentile": 0.88541}, "CVE-2012-2407": {"epss_score": 0.00501, "epss_percentile": 0.65366}, "CVE-2012-2408": {"epss_score": 0.0043, "epss_percentile": 0.62018}, "CVE-2012-2409": {"epss_score": 0.00501, "epss_percentile": 0.65366}, "CVE-2012-2410": {"epss_score": 0.00469, "epss_percentile": 0.63942}, "CVE-2012-2411": {"epss_score": 0.13386, "epss_percentile": 0.93948}, "CVE-2012-2413": {"epss_score": 0.00035, "epss_percentile": 0.09959}, "CVE-2012-2414": {"epss_score": 0.04278, "epss_percentile": 0.88485}, "CVE-2012-2415": {"epss_score": 0.10525, "epss_percentile": 0.93019}, "CVE-2012-2416": {"epss_score": 0.05048, "epss_percentile": 0.89437}, "CVE-2012-2417": {"epss_score": 0.04088, "epss_percentile": 0.8823}, "CVE-2012-2418": {"epss_score": 0.00268, "epss_percentile": 0.50092}, "CVE-2012-2419": {"epss_score": 0.00116, "epss_percentile": 0.31096}, "CVE-2012-2420": {"epss_score": 0.00163, "epss_percentile": 0.3783}, "CVE-2012-2421": {"epss_score": 0.00077, "epss_percentile": 0.23448}, "CVE-2012-2422": {"epss_score": 0.00132, "epss_percentile": 0.33613}, "CVE-2012-2423": {"epss_score": 0.00132, "epss_percentile": 0.33613}, "CVE-2012-2424": {"epss_score": 0.00178, "epss_percentile": 0.39724}, "CVE-2012-2425": {"epss_score": 0.00212, "epss_percentile": 0.43816}, "CVE-2012-2426": {"epss_score": 0.00472, "epss_percentile": 0.64051}, "CVE-2012-2427": {"epss_score": 0.03228, "epss_percentile": 0.8669}, "CVE-2012-2428": {"epss_score": 0.01894, "epss_percentile": 0.8274}, "CVE-2012-2429": {"epss_score": 0.03033, "epss_percentile": 0.86253}, "CVE-2012-2435": {"epss_score": 0.0072, "epss_percentile": 0.71965}, "CVE-2012-2436": {"epss_score": 0.0371, "epss_percentile": 0.87605}, "CVE-2012-2437": {"epss_score": 0.04434, "epss_percentile": 0.88683}, "CVE-2012-2438": {"epss_score": 0.00501, "epss_percentile": 0.6534}, "CVE-2012-2439": {"epss_score": 0.00509, "epss_percentile": 0.65733}, "CVE-2012-2440": {"epss_score": 0.00441, "epss_percentile": 0.62693}, "CVE-2012-2441": {"epss_score": 0.27541, "epss_percentile": 0.96256}, "CVE-2012-2442": {"epss_score": 0.17782, "epss_percentile": 0.94905}, "CVE-2012-2446": {"epss_score": 0.00295, "epss_percentile": 0.52503}, "CVE-2012-2447": {"epss_score": 0.00079, "epss_percentile": 0.23839}, "CVE-2012-2448": {"epss_score": 0.0252, "epss_percentile": 0.85}, "CVE-2012-2449": {"epss_score": 0.02408, "epss_percentile": 0.84658}, "CVE-2012-2450": {"epss_score": 0.01251, "epss_percentile": 0.78893}, "CVE-2012-2451": {"epss_score": 0.00091, "epss_percentile": 0.26175}, "CVE-2012-2452": {"epss_score": 0.00395, "epss_percentile": 0.59816}, "CVE-2012-2455": {"epss_score": 0.0027, "epss_percentile": 0.50195}, "CVE-2012-2459": {"epss_score": 0.02002, "epss_percentile": 0.83222}, "CVE-2012-2469": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2012-2472": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-2474": {"epss_score": 0.00371, "epss_percentile": 0.58399}, "CVE-2012-2486": {"epss_score": 0.01028, "epss_percentile": 0.76813}, "CVE-2012-2488": {"epss_score": 0.00441, "epss_percentile": 0.62694}, "CVE-2012-2490": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2012-2493": {"epss_score": 0.01576, "epss_percentile": 0.81113}, "CVE-2012-2494": {"epss_score": 0.00198, "epss_percentile": 0.41983}, "CVE-2012-2495": {"epss_score": 0.00215, "epss_percentile": 0.44023}, "CVE-2012-2496": {"epss_score": 0.01113, "epss_percentile": 0.7769}, "CVE-2012-2498": {"epss_score": 0.00103, "epss_percentile": 0.29003}, "CVE-2012-2499": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2012-2500": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2012-2511": {"epss_score": 0.21876, "epss_percentile": 0.95569}, "CVE-2012-2512": {"epss_score": 0.31601, "epss_percentile": 0.96637}, "CVE-2012-2513": {"epss_score": 0.22782, "epss_percentile": 0.95686}, "CVE-2012-2514": {"epss_score": 0.31601, "epss_percentile": 0.96637}, "CVE-2012-2515": {"epss_score": 0.64836, "epss_percentile": 0.98394}, "CVE-2012-2516": {"epss_score": 0.69414, "epss_percentile": 0.98586}, "CVE-2012-2517": {"epss_score": 0.00863, "epss_percentile": 0.74587}, "CVE-2012-2519": {"epss_score": 0.00695, "epss_percentile": 0.71364}, "CVE-2012-2520": {"epss_score": 0.24181, "epss_percentile": 0.95883}, "CVE-2012-2521": {"epss_score": 0.54934, "epss_percentile": 0.97953}, "CVE-2012-2522": {"epss_score": 0.51863, "epss_percentile": 0.978}, "CVE-2012-2523": {"epss_score": 0.64663, "epss_percentile": 0.98388}, "CVE-2012-2524": {"epss_score": 0.53228, "epss_percentile": 0.97867}, "CVE-2012-2526": {"epss_score": 0.57525, "epss_percentile": 0.98068}, "CVE-2012-2527": {"epss_score": 0.00921, "epss_percentile": 0.75481}, "CVE-2012-2528": {"epss_score": 0.5685, "epss_percentile": 0.98038}, "CVE-2012-2529": {"epss_score": 0.01174, "epss_percentile": 0.78246}, "CVE-2012-2530": {"epss_score": 0.02472, "epss_percentile": 0.84849}, "CVE-2012-2531": {"epss_score": 0.00197, "epss_percentile": 0.41846}, "CVE-2012-2532": {"epss_score": 0.19645, "epss_percentile": 0.9522}, "CVE-2012-2536": {"epss_score": 0.44363, "epss_percentile": 0.97432}, "CVE-2012-2539": {"epss_score": 0.85532, "epss_percentile": 0.99338}, "CVE-2012-2543": {"epss_score": 0.65939, "epss_percentile": 0.98445}, "CVE-2012-2546": {"epss_score": 0.26792, "epss_percentile": 0.96181}, "CVE-2012-2548": {"epss_score": 0.36887, "epss_percentile": 0.97007}, "CVE-2012-2549": {"epss_score": 0.09141, "epss_percentile": 0.92419}, "CVE-2012-2550": {"epss_score": 0.66728, "epss_percentile": 0.98476}, "CVE-2012-2551": {"epss_score": 0.61326, "epss_percentile": 0.98244}, "CVE-2012-2552": {"epss_score": 0.44363, "epss_percentile": 0.97432}, "CVE-2012-2553": {"epss_score": 0.01311, "epss_percentile": 0.79372}, "CVE-2012-2556": {"epss_score": 0.49846, "epss_percentile": 0.97707}, "CVE-2012-2557": {"epss_score": 0.36887, "epss_percentile": 0.97007}, "CVE-2012-2559": {"epss_score": 0.02691, "epss_percentile": 0.85437}, "CVE-2012-2560": {"epss_score": 0.00427, "epss_percentile": 0.61904}, "CVE-2012-2561": {"epss_score": 0.02341, "epss_percentile": 0.84436}, "CVE-2012-2562": {"epss_score": 0.01018, "epss_percentile": 0.76706}, "CVE-2012-2563": {"epss_score": 0.0155, "epss_percentile": 0.80985}, "CVE-2012-2564": {"epss_score": 0.00294, "epss_percentile": 0.52398}, "CVE-2012-2565": {"epss_score": 0.0176, "epss_percentile": 0.82144}, "CVE-2012-2566": {"epss_score": 0.00905, "epss_percentile": 0.7523}, "CVE-2012-2567": {"epss_score": 0.00653, "epss_percentile": 0.70337}, "CVE-2012-2568": {"epss_score": 0.01096, "epss_percentile": 0.77521}, "CVE-2012-2569": {"epss_score": 0.00564, "epss_percentile": 0.67778}, "CVE-2012-2570": {"epss_score": 0.02425, "epss_percentile": 0.84714}, "CVE-2012-2571": {"epss_score": 0.00387, "epss_percentile": 0.59296}, "CVE-2012-2572": {"epss_score": 0.01898, "epss_percentile": 0.8276}, "CVE-2012-2573": {"epss_score": 0.00459, "epss_percentile": 0.6346}, "CVE-2012-2574": {"epss_score": 0.01077, "epss_percentile": 0.77335}, "CVE-2012-2575": {"epss_score": 0.00387, "epss_percentile": 0.59296}, "CVE-2012-2576": {"epss_score": 0.42862, "epss_percentile": 0.97359}, "CVE-2012-2577": {"epss_score": 0.21828, "epss_percentile": 0.95564}, "CVE-2012-2578": {"epss_score": 0.00757, "epss_percentile": 0.72749}, "CVE-2012-2579": {"epss_score": 0.01883, "epss_percentile": 0.82699}, "CVE-2012-2580": {"epss_score": 0.01883, "epss_percentile": 0.82699}, "CVE-2012-2582": {"epss_score": 0.02951, "epss_percentile": 0.86053}, "CVE-2012-2583": {"epss_score": 0.01121, "epss_percentile": 0.77772}, "CVE-2012-2584": {"epss_score": 0.00432, "epss_percentile": 0.62126}, "CVE-2012-2585": {"epss_score": 0.00382, "epss_percentile": 0.59072}, "CVE-2012-2586": {"epss_score": 0.00757, "epss_percentile": 0.72749}, "CVE-2012-2587": {"epss_score": 0.00387, "epss_percentile": 0.59296}, "CVE-2012-2588": {"epss_score": 0.01623, "epss_percentile": 0.814}, "CVE-2012-2590": {"epss_score": 0.00387, "epss_percentile": 0.59296}, "CVE-2012-2591": {"epss_score": 0.06559, "epss_percentile": 0.90847}, "CVE-2012-2592": {"epss_score": 0.00436, "epss_percentile": 0.62464}, "CVE-2012-2593": {"epss_score": 0.05663, "epss_percentile": 0.90097}, "CVE-2012-2595": {"epss_score": 0.00385, "epss_percentile": 0.59195}, "CVE-2012-2596": {"epss_score": 0.00241, "epss_percentile": 0.47268}, "CVE-2012-2597": {"epss_score": 0.00181, "epss_percentile": 0.40035}, "CVE-2012-2598": {"epss_score": 0.00496, "epss_percentile": 0.65166}, "CVE-2012-2601": {"epss_score": 0.16692, "epss_percentile": 0.94715}, "CVE-2012-2602": {"epss_score": 0.07935, "epss_percentile": 0.91774}, "CVE-2012-2603": {"epss_score": 0.00513, "epss_percentile": 0.65905}, "CVE-2012-2604": {"epss_score": 0.0165, "epss_percentile": 0.81564}, "CVE-2012-2605": {"epss_score": 0.00109, "epss_percentile": 0.29962}, "CVE-2012-2606": {"epss_score": 0.05805, "epss_percentile": 0.90223}, "CVE-2012-2607": {"epss_score": 0.01599, "epss_percentile": 0.81253}, "CVE-2012-2611": {"epss_score": 0.77664, "epss_percentile": 0.98946}, "CVE-2012-2612": {"epss_score": 0.31601, "epss_percentile": 0.96637}, "CVE-2012-2614": {"epss_score": 0.11762, "epss_percentile": 0.93468}, "CVE-2012-2619": {"epss_score": 0.26529, "epss_percentile": 0.96154}, "CVE-2012-2624": {"epss_score": 0.01048, "epss_percentile": 0.77044}, "CVE-2012-2625": {"epss_score": 0.00313, "epss_percentile": 0.54051}, "CVE-2012-2626": {"epss_score": 0.75978, "epss_percentile": 0.98872}, "CVE-2012-2627": {"epss_score": 0.09545, "epss_percentile": 0.92592}, "CVE-2012-2629": {"epss_score": 0.0069, "epss_percentile": 0.71244}, "CVE-2012-2630": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-2631": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-2632": {"epss_score": 0.00179, "epss_percentile": 0.39767}, "CVE-2012-2633": {"epss_score": 0.00296, "epss_percentile": 0.52567}, "CVE-2012-2634": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-2635": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2012-2636": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-2637": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-2638": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-2640": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2012-2641": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-2642": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-2643": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-2644": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-2645": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-2646": {"epss_score": 0.00742, "epss_percentile": 0.72458}, "CVE-2012-2647": {"epss_score": 0.00192, "epss_percentile": 0.41303}, "CVE-2012-2648": {"epss_score": 0.00199, "epss_percentile": 0.4214}, "CVE-2012-2649": {"epss_score": 0.00641, "epss_percentile": 0.69986}, "CVE-2012-2652": {"epss_score": 0.00105, "epss_percentile": 0.29354}, "CVE-2012-2653": {"epss_score": 0.01826, "epss_percentile": 0.82434}, "CVE-2012-2654": {"epss_score": 0.01178, "epss_percentile": 0.78286}, "CVE-2012-2655": {"epss_score": 0.01426, "epss_percentile": 0.80204}, "CVE-2012-2656": {"epss_score": 0.01037, "epss_percentile": 0.76922}, "CVE-2012-2657": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2012-2658": {"epss_score": 0.00076, "epss_percentile": 0.2326}, "CVE-2012-2660": {"epss_score": 0.00204, "epss_percentile": 0.42655}, "CVE-2012-2661": {"epss_score": 0.01431, "epss_percentile": 0.80246}, "CVE-2012-2662": {"epss_score": 0.00238, "epss_percentile": 0.46752}, "CVE-2012-2663": {"epss_score": 0.0048, "epss_percentile": 0.64466}, "CVE-2012-2664": {"epss_score": 0.00438, "epss_percentile": 0.62546}, "CVE-2012-2665": {"epss_score": 0.05023, "epss_percentile": 0.89405}, "CVE-2012-2666": {"epss_score": 0.00513, "epss_percentile": 0.65917}, "CVE-2012-2667": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2012-2668": {"epss_score": 0.00564, "epss_percentile": 0.67745}, "CVE-2012-2669": {"epss_score": 0.00111, "epss_percentile": 0.30312}, "CVE-2012-2670": {"epss_score": 0.00275, "epss_percentile": 0.50668}, "CVE-2012-2671": {"epss_score": 0.00639, "epss_percentile": 0.69932}, "CVE-2012-2672": {"epss_score": 0.00057, "epss_percentile": 0.18004}, "CVE-2012-2673": {"epss_score": 0.01653, "epss_percentile": 0.81577}, "CVE-2012-2674": {"epss_score": 0.00177, "epss_percentile": 0.39543}, "CVE-2012-2675": {"epss_score": 0.00755, "epss_percentile": 0.7271}, "CVE-2012-2676": {"epss_score": 0.00338, "epss_percentile": 0.56068}, "CVE-2012-2677": {"epss_score": 0.01048, "epss_percentile": 0.77055}, "CVE-2012-2678": {"epss_score": 0.00238, "epss_percentile": 0.46765}, "CVE-2012-2679": {"epss_score": 0.00082, "epss_percentile": 0.2447}, "CVE-2012-2680": {"epss_score": 0.006, "epss_percentile": 0.68811}, "CVE-2012-2681": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2012-2682": {"epss_score": 0.00408, "epss_percentile": 0.60636}, "CVE-2012-2683": {"epss_score": 0.00467, "epss_percentile": 0.63861}, "CVE-2012-2684": {"epss_score": 0.00605, "epss_percentile": 0.68995}, "CVE-2012-2685": {"epss_score": 0.01178, "epss_percentile": 0.78288}, "CVE-2012-2686": {"epss_score": 0.66117, "epss_percentile": 0.98451}, "CVE-2012-2687": {"epss_score": 0.04495, "epss_percentile": 0.88762}, "CVE-2012-2688": {"epss_score": 0.27479, "epss_percentile": 0.9625}, "CVE-2012-2690": {"epss_score": 0.0005, "epss_percentile": 0.15889}, "CVE-2012-2691": {"epss_score": 0.03724, "epss_percentile": 0.87631}, "CVE-2012-2692": {"epss_score": 0.0066, "epss_percentile": 0.70531}, "CVE-2012-2693": {"epss_score": 0.00059, "epss_percentile": 0.18809}, "CVE-2012-2694": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2012-2695": {"epss_score": 0.00641, "epss_percentile": 0.69989}, "CVE-2012-2696": {"epss_score": 0.00143, "epss_percentile": 0.352}, "CVE-2012-2697": {"epss_score": 0.00149, "epss_percentile": 0.35938}, "CVE-2012-2698": {"epss_score": 0.20419, "epss_percentile": 0.95341}, "CVE-2012-2702": {"epss_score": 0.00663, "epss_percentile": 0.70619}, "CVE-2012-2703": {"epss_score": 0.00365, "epss_percentile": 0.5799}, "CVE-2012-2704": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2012-2705": {"epss_score": 0.00302, "epss_percentile": 0.53158}, "CVE-2012-2706": {"epss_score": 0.00361, "epss_percentile": 0.5771}, "CVE-2012-2707": {"epss_score": 0.00294, "epss_percentile": 0.52408}, "CVE-2012-2708": {"epss_score": 0.00255, "epss_percentile": 0.48736}, "CVE-2012-2710": {"epss_score": 0.00365, "epss_percentile": 0.5799}, "CVE-2012-2711": {"epss_score": 0.00278, "epss_percentile": 0.50923}, "CVE-2012-2712": {"epss_score": 0.00567, "epss_percentile": 0.67854}, "CVE-2012-2713": {"epss_score": 0.00293, "epss_percentile": 0.52302}, "CVE-2012-2714": {"epss_score": 0.06663, "epss_percentile": 0.90924}, "CVE-2012-2715": {"epss_score": 0.00571, "epss_percentile": 0.67972}, "CVE-2012-2716": {"epss_score": 0.00262, "epss_percentile": 0.49327}, "CVE-2012-2717": {"epss_score": 0.00702, "epss_percentile": 0.71514}, "CVE-2012-2718": {"epss_score": 0.00356, "epss_percentile": 0.57348}, "CVE-2012-2719": {"epss_score": 0.00478, "epss_percentile": 0.64392}, "CVE-2012-2720": {"epss_score": 0.00571, "epss_percentile": 0.67974}, "CVE-2012-2721": {"epss_score": 0.00215, "epss_percentile": 0.44095}, "CVE-2012-2722": {"epss_score": 0.00247, "epss_percentile": 0.479}, "CVE-2012-2723": {"epss_score": 0.00429, "epss_percentile": 0.61985}, "CVE-2012-2724": {"epss_score": 0.01383, "epss_percentile": 0.79891}, "CVE-2012-2725": {"epss_score": 0.00155, "epss_percentile": 0.36758}, "CVE-2012-2726": {"epss_score": 0.00469, "epss_percentile": 0.63939}, "CVE-2012-2727": {"epss_score": 0.00947, "epss_percentile": 0.75825}, "CVE-2012-2728": {"epss_score": 0.00254, "epss_percentile": 0.48505}, "CVE-2012-2729": {"epss_score": 0.00175, "epss_percentile": 0.39346}, "CVE-2012-2730": {"epss_score": 0.00263, "epss_percentile": 0.4941}, "CVE-2012-2731": {"epss_score": 0.0056, "epss_percentile": 0.67642}, "CVE-2012-2733": {"epss_score": 0.15769, "epss_percentile": 0.94507}, "CVE-2012-2734": {"epss_score": 0.00196, "epss_percentile": 0.41755}, "CVE-2012-2735": {"epss_score": 0.0039, "epss_percentile": 0.59499}, "CVE-2012-2736": {"epss_score": 0.00081, "epss_percentile": 0.24337}, "CVE-2012-2737": {"epss_score": 0.00071, "epss_percentile": 0.22185}, "CVE-2012-2738": {"epss_score": 0.18222, "epss_percentile": 0.94976}, "CVE-2012-2739": {"epss_score": 0.00936, "epss_percentile": 0.75677}, "CVE-2012-2740": {"epss_score": 0.06067, "epss_percentile": 0.90449}, "CVE-2012-2741": {"epss_score": 0.1132, "epss_percentile": 0.93307}, "CVE-2012-2742": {"epss_score": 0.00567, "epss_percentile": 0.67852}, "CVE-2012-2743": {"epss_score": 0.00416, "epss_percentile": 0.61181}, "CVE-2012-2744": {"epss_score": 0.00623, "epss_percentile": 0.69549}, "CVE-2012-2745": {"epss_score": 0.00116, "epss_percentile": 0.3117}, "CVE-2012-2746": {"epss_score": 0.00509, "epss_percentile": 0.65721}, "CVE-2012-2747": {"epss_score": 0.00067, "epss_percentile": 0.2103}, "CVE-2012-2748": {"epss_score": 0.0055, "epss_percentile": 0.67327}, "CVE-2012-2749": {"epss_score": 0.00515, "epss_percentile": 0.65972}, "CVE-2012-2750": {"epss_score": 0.018, "epss_percentile": 0.82318}, "CVE-2012-2751": {"epss_score": 0.01943, "epss_percentile": 0.82995}, "CVE-2012-2752": {"epss_score": 0.00041, "epss_percentile": 0.12225}, "CVE-2012-2753": {"epss_score": 0.00057, "epss_percentile": 0.18186}, "CVE-2012-2759": {"epss_score": 0.00204, "epss_percentile": 0.42624}, "CVE-2012-2760": {"epss_score": 0.00424, "epss_percentile": 0.61671}, "CVE-2012-2762": {"epss_score": 0.00717, "epss_percentile": 0.71882}, "CVE-2012-2763": {"epss_score": 0.88834, "epss_percentile": 0.99493}, "CVE-2012-2764": {"epss_score": 0.00831, "epss_percentile": 0.74044}, "CVE-2012-2768": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2012-2769": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2012-2770": {"epss_score": 0.00336, "epss_percentile": 0.55929}, "CVE-2012-2771": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2012-2772": {"epss_score": 0.00921, "epss_percentile": 0.75479}, "CVE-2012-2773": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2012-2774": {"epss_score": 0.01012, "epss_percentile": 0.76626}, "CVE-2012-2775": {"epss_score": 0.01444, "epss_percentile": 0.80317}, "CVE-2012-2776": {"epss_score": 0.01067, "epss_percentile": 0.77231}, "CVE-2012-2777": {"epss_score": 0.01352, "epss_percentile": 0.79686}, "CVE-2012-2778": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2012-2779": {"epss_score": 0.01444, "epss_percentile": 0.80317}, "CVE-2012-2780": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2012-2781": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2012-2782": {"epss_score": 0.00829, "epss_percentile": 0.74013}, "CVE-2012-2783": {"epss_score": 0.01444, "epss_percentile": 0.80317}, "CVE-2012-2784": {"epss_score": 0.01352, "epss_percentile": 0.79686}, "CVE-2012-2785": {"epss_score": 0.00759, "epss_percentile": 0.7279}, "CVE-2012-2786": {"epss_score": 0.01352, "epss_percentile": 0.79686}, "CVE-2012-2787": {"epss_score": 0.00921, "epss_percentile": 0.75479}, "CVE-2012-2788": {"epss_score": 0.01444, "epss_percentile": 0.80317}, "CVE-2012-2789": {"epss_score": 0.00921, "epss_percentile": 0.75479}, "CVE-2012-2790": {"epss_score": 0.00843, "epss_percentile": 0.74262}, "CVE-2012-2791": {"epss_score": 0.00843, "epss_percentile": 0.74262}, "CVE-2012-2792": {"epss_score": 0.00829, "epss_percentile": 0.74013}, "CVE-2012-2793": {"epss_score": 0.00921, "epss_percentile": 0.75479}, "CVE-2012-2794": {"epss_score": 0.00843, "epss_percentile": 0.74262}, "CVE-2012-2795": {"epss_score": 0.00856, "epss_percentile": 0.74474}, "CVE-2012-2796": {"epss_score": 0.00843, "epss_percentile": 0.74262}, "CVE-2012-2797": {"epss_score": 0.00856, "epss_percentile": 0.74474}, "CVE-2012-2798": {"epss_score": 0.00991, "epss_percentile": 0.76389}, "CVE-2012-2799": {"epss_score": 0.00759, "epss_percentile": 0.7279}, "CVE-2012-2800": {"epss_score": 0.00843, "epss_percentile": 0.74262}, "CVE-2012-2801": {"epss_score": 0.00991, "epss_percentile": 0.76389}, "CVE-2012-2802": {"epss_score": 0.00908, "epss_percentile": 0.75275}, "CVE-2012-2803": {"epss_score": 0.00565, "epss_percentile": 0.67786}, "CVE-2012-2804": {"epss_score": 0.00776, "epss_percentile": 0.73095}, "CVE-2012-2805": {"epss_score": 0.00499, "epss_percentile": 0.65251}, "CVE-2012-2806": {"epss_score": 0.0135, "epss_percentile": 0.79674}, "CVE-2012-2807": {"epss_score": 0.01524, "epss_percentile": 0.80846}, "CVE-2012-2808": {"epss_score": 0.00184, "epss_percentile": 0.40403}, "CVE-2012-2812": {"epss_score": 0.00928, "epss_percentile": 0.75579}, "CVE-2012-2813": {"epss_score": 0.00852, "epss_percentile": 0.74415}, "CVE-2012-2814": {"epss_score": 0.0671, "epss_percentile": 0.90963}, "CVE-2012-2815": {"epss_score": 0.00589, "epss_percentile": 0.68521}, "CVE-2012-2816": {"epss_score": 0.01159, "epss_percentile": 0.78124}, "CVE-2012-2817": {"epss_score": 0.01157, "epss_percentile": 0.78106}, "CVE-2012-2818": {"epss_score": 0.01491, "epss_percentile": 0.80631}, "CVE-2012-2819": {"epss_score": 0.00917, "epss_percentile": 0.75434}, "CVE-2012-2820": {"epss_score": 0.00941, "epss_percentile": 0.75751}, "CVE-2012-2821": {"epss_score": 0.00257, "epss_percentile": 0.4885}, "CVE-2012-2822": {"epss_score": 0.00479, "epss_percentile": 0.64418}, "CVE-2012-2823": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2012-2824": {"epss_score": 0.01062, "epss_percentile": 0.77183}, "CVE-2012-2825": {"epss_score": 0.01383, "epss_percentile": 0.79893}, "CVE-2012-2826": {"epss_score": 0.00825, "epss_percentile": 0.73949}, "CVE-2012-2827": {"epss_score": 0.00148, "epss_percentile": 0.35931}, "CVE-2012-2828": {"epss_score": 0.00775, "epss_percentile": 0.73082}, "CVE-2012-2829": {"epss_score": 0.01157, "epss_percentile": 0.78106}, "CVE-2012-2830": {"epss_score": 0.00751, "epss_percentile": 0.72639}, "CVE-2012-2831": {"epss_score": 0.01157, "epss_percentile": 0.78106}, "CVE-2012-2832": {"epss_score": 0.00775, "epss_percentile": 0.73082}, "CVE-2012-2833": {"epss_score": 0.01059, "epss_percentile": 0.77148}, "CVE-2012-2834": {"epss_score": 0.0134, "epss_percentile": 0.79575}, "CVE-2012-2836": {"epss_score": 0.04678, "epss_percentile": 0.88999}, "CVE-2012-2837": {"epss_score": 0.01256, "epss_percentile": 0.78937}, "CVE-2012-2840": {"epss_score": 0.02169, "epss_percentile": 0.83864}, "CVE-2012-2841": {"epss_score": 0.05429, "epss_percentile": 0.89872}, "CVE-2012-2842": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2012-2843": {"epss_score": 0.00693, "epss_percentile": 0.71332}, "CVE-2012-2844": {"epss_score": 0.01706, "epss_percentile": 0.81855}, "CVE-2012-2845": {"epss_score": 0.00711, "epss_percentile": 0.71742}, "CVE-2012-2846": {"epss_score": 0.0031, "epss_percentile": 0.53751}, "CVE-2012-2847": {"epss_score": 0.00461, "epss_percentile": 0.63543}, "CVE-2012-2848": {"epss_score": 0.002, "epss_percentile": 0.42247}, "CVE-2012-2849": {"epss_score": 0.01384, "epss_percentile": 0.79901}, "CVE-2012-2850": {"epss_score": 0.01839, "epss_percentile": 0.82488}, "CVE-2012-2851": {"epss_score": 0.00972, "epss_percentile": 0.76138}, "CVE-2012-2852": {"epss_score": 0.00667, "epss_percentile": 0.70716}, "CVE-2012-2853": {"epss_score": 0.00447, "epss_percentile": 0.6297}, "CVE-2012-2854": {"epss_score": 0.0023, "epss_percentile": 0.45692}, "CVE-2012-2855": {"epss_score": 0.00667, "epss_percentile": 0.70716}, "CVE-2012-2856": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2012-2857": {"epss_score": 0.01383, "epss_percentile": 0.79892}, "CVE-2012-2858": {"epss_score": 0.00488, "epss_percentile": 0.64836}, "CVE-2012-2859": {"epss_score": 0.00948, "epss_percentile": 0.75834}, "CVE-2012-2860": {"epss_score": 0.00447, "epss_percentile": 0.6297}, "CVE-2012-2862": {"epss_score": 0.00972, "epss_percentile": 0.76138}, "CVE-2012-2863": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2012-2864": {"epss_score": 0.05704, "epss_percentile": 0.90134}, "CVE-2012-2865": {"epss_score": 0.00972, "epss_percentile": 0.76138}, "CVE-2012-2866": {"epss_score": 0.01615, "epss_percentile": 0.81353}, "CVE-2012-2867": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2012-2868": {"epss_score": 0.00918, "epss_percentile": 0.75442}, "CVE-2012-2869": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2012-2870": {"epss_score": 0.01181, "epss_percentile": 0.78312}, "CVE-2012-2871": {"epss_score": 0.01052, "epss_percentile": 0.7709}, "CVE-2012-2872": {"epss_score": 0.0036, "epss_percentile": 0.57634}, "CVE-2012-2874": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2012-2875": {"epss_score": 0.02244, "epss_percentile": 0.84124}, "CVE-2012-2876": {"epss_score": 0.00968, "epss_percentile": 0.76076}, "CVE-2012-2877": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2012-2878": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2012-2879": {"epss_score": 0.00972, "epss_percentile": 0.76138}, "CVE-2012-2880": {"epss_score": 0.00688, "epss_percentile": 0.7121}, "CVE-2012-2881": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2012-2882": {"epss_score": 0.01182, "epss_percentile": 0.78322}, "CVE-2012-2883": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2012-2884": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2012-2885": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2012-2886": {"epss_score": 0.0026, "epss_percentile": 0.49242}, "CVE-2012-2887": {"epss_score": 0.0288, "epss_percentile": 0.85898}, "CVE-2012-2888": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2012-2889": {"epss_score": 0.00389, "epss_percentile": 0.59458}, "CVE-2012-2890": {"epss_score": 0.01383, "epss_percentile": 0.79892}, "CVE-2012-2891": {"epss_score": 0.00174, "epss_percentile": 0.39142}, "CVE-2012-2892": {"epss_score": 0.00234, "epss_percentile": 0.46086}, "CVE-2012-2893": {"epss_score": 0.01661, "epss_percentile": 0.81627}, "CVE-2012-2894": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2012-2895": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2012-2896": {"epss_score": 0.00656, "epss_percentile": 0.70449}, "CVE-2012-2897": {"epss_score": 0.362, "epss_percentile": 0.9696}, "CVE-2012-2898": {"epss_score": 0.0014, "epss_percentile": 0.34755}, "CVE-2012-2899": {"epss_score": 0.00117, "epss_percentile": 0.31219}, "CVE-2012-2900": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2012-2901": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2012-2902": {"epss_score": 0.006, "epss_percentile": 0.68829}, "CVE-2012-2903": {"epss_score": 0.05638, "epss_percentile": 0.90074}, "CVE-2012-2904": {"epss_score": 0.02199, "epss_percentile": 0.8397}, "CVE-2012-2905": {"epss_score": 0.09419, "epss_percentile": 0.92539}, "CVE-2012-2906": {"epss_score": 0.11018, "epss_percentile": 0.9319}, "CVE-2012-2907": {"epss_score": 0.0058, "epss_percentile": 0.6824}, "CVE-2012-2908": {"epss_score": 0.00481, "epss_percentile": 0.64488}, "CVE-2012-2909": {"epss_score": 0.02473, "epss_percentile": 0.84853}, "CVE-2012-2910": {"epss_score": 0.02373, "epss_percentile": 0.84534}, "CVE-2012-2911": {"epss_score": 0.02473, "epss_percentile": 0.84853}, "CVE-2012-2912": {"epss_score": 0.00153, "epss_percentile": 0.36619}, "CVE-2012-2913": {"epss_score": 0.00773, "epss_percentile": 0.73053}, "CVE-2012-2914": {"epss_score": 0.02678, "epss_percentile": 0.85408}, "CVE-2012-2915": {"epss_score": 0.66074, "epss_percentile": 0.98449}, "CVE-2012-2916": {"epss_score": 0.00185, "epss_percentile": 0.40475}, "CVE-2012-2917": {"epss_score": 0.00735, "epss_percentile": 0.72291}, "CVE-2012-2918": {"epss_score": 0.02187, "epss_percentile": 0.83925}, "CVE-2012-2919": {"epss_score": 0.08138, "epss_percentile": 0.91897}, "CVE-2012-2920": {"epss_score": 0.00274, "epss_percentile": 0.50532}, "CVE-2012-2921": {"epss_score": 0.01258, "epss_percentile": 0.7896}, "CVE-2012-2922": {"epss_score": 0.00499, "epss_percentile": 0.65256}, "CVE-2012-2923": {"epss_score": 0.00591, "epss_percentile": 0.68581}, "CVE-2012-2924": {"epss_score": 0.01832, "epss_percentile": 0.82454}, "CVE-2012-2925": {"epss_score": 0.00472, "epss_percentile": 0.6406}, "CVE-2012-2926": {"epss_score": 0.56379, "epss_percentile": 0.9802}, "CVE-2012-2927": {"epss_score": 0.00621, "epss_percentile": 0.69486}, "CVE-2012-2928": {"epss_score": 0.0193, "epss_percentile": 0.82937}, "CVE-2012-2930": {"epss_score": 0.00178, "epss_percentile": 0.39634}, "CVE-2012-2931": {"epss_score": 0.00939, "epss_percentile": 0.75722}, "CVE-2012-2932": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-2934": {"epss_score": 0.00168, "epss_percentile": 0.38471}, "CVE-2012-2935": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-2936": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2012-2937": {"epss_score": 0.01045, "epss_percentile": 0.77019}, "CVE-2012-2938": {"epss_score": 0.06382, "epss_percentile": 0.90713}, "CVE-2012-2939": {"epss_score": 0.10151, "epss_percentile": 0.92866}, "CVE-2012-2940": {"epss_score": 0.0884, "epss_percentile": 0.9228}, "CVE-2012-2941": {"epss_score": 0.02678, "epss_percentile": 0.85408}, "CVE-2012-2942": {"epss_score": 0.00198, "epss_percentile": 0.42008}, "CVE-2012-2943": {"epss_score": 0.00054, "epss_percentile": 0.17318}, "CVE-2012-2944": {"epss_score": 0.0608, "epss_percentile": 0.90462}, "CVE-2012-2945": {"epss_score": 0.01713, "epss_percentile": 0.8189}, "CVE-2012-2947": {"epss_score": 0.04301, "epss_percentile": 0.88515}, "CVE-2012-2948": {"epss_score": 0.03932, "epss_percentile": 0.87977}, "CVE-2012-2949": {"epss_score": 0.01925, "epss_percentile": 0.82918}, "CVE-2012-2950": {"epss_score": 0.05383, "epss_percentile": 0.89817}, "CVE-2012-2952": {"epss_score": 0.00581, "epss_percentile": 0.68272}, "CVE-2012-2953": {"epss_score": 0.83407, "epss_percentile": 0.99248}, "CVE-2012-2955": {"epss_score": 0.01809, "epss_percentile": 0.82359}, "CVE-2012-2956": {"epss_score": 0.00911, "epss_percentile": 0.75332}, "CVE-2012-2957": {"epss_score": 0.09446, "epss_percentile": 0.92551}, "CVE-2012-2959": {"epss_score": 0.00282, "epss_percentile": 0.51236}, "CVE-2012-2960": {"epss_score": 0.00743, "epss_percentile": 0.72499}, "CVE-2012-2961": {"epss_score": 0.01173, "epss_percentile": 0.78238}, "CVE-2012-2962": {"epss_score": 0.90336, "epss_percentile": 0.99578}, "CVE-2012-2963": {"epss_score": 0.01314, "epss_percentile": 0.79398}, "CVE-2012-2964": {"epss_score": 0.016, "epss_percentile": 0.81255}, "CVE-2012-2965": {"epss_score": 0.01519, "epss_percentile": 0.80816}, "CVE-2012-2966": {"epss_score": 0.01519, "epss_percentile": 0.80816}, "CVE-2012-2967": {"epss_score": 0.01519, "epss_percentile": 0.80816}, "CVE-2012-2968": {"epss_score": 0.00434, "epss_percentile": 0.62287}, "CVE-2012-2969": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2012-2970": {"epss_score": 0.00963, "epss_percentile": 0.76019}, "CVE-2012-2971": {"epss_score": 0.02894, "epss_percentile": 0.85924}, "CVE-2012-2972": {"epss_score": 0.02219, "epss_percentile": 0.84047}, "CVE-2012-2974": {"epss_score": 0.00797, "epss_percentile": 0.73498}, "CVE-2012-2975": {"epss_score": 0.00722, "epss_percentile": 0.71988}, "CVE-2012-2976": {"epss_score": 0.04381, "epss_percentile": 0.88624}, "CVE-2012-2977": {"epss_score": 0.1708, "epss_percentile": 0.94771}, "CVE-2012-2978": {"epss_score": 0.01384, "epss_percentile": 0.799}, "CVE-2012-2979": {"epss_score": 0.00746, "epss_percentile": 0.72537}, "CVE-2012-2980": {"epss_score": 0.03247, "epss_percentile": 0.86745}, "CVE-2012-2981": {"epss_score": 0.00779, "epss_percentile": 0.73151}, "CVE-2012-2982": {"epss_score": 0.82534, "epss_percentile": 0.99199}, "CVE-2012-2983": {"epss_score": 0.50929, "epss_percentile": 0.97755}, "CVE-2012-2984": {"epss_score": 0.01784, "epss_percentile": 0.8225}, "CVE-2012-2985": {"epss_score": 0.00501, "epss_percentile": 0.65366}, "CVE-2012-2986": {"epss_score": 0.05815, "epss_percentile": 0.90229}, "CVE-2012-2990": {"epss_score": 0.01238, "epss_percentile": 0.78786}, "CVE-2012-2991": {"epss_score": 0.00601, "epss_percentile": 0.68834}, "CVE-2012-2993": {"epss_score": 0.06731, "epss_percentile": 0.90987}, "CVE-2012-2994": {"epss_score": 0.08524, "epss_percentile": 0.92101}, "CVE-2012-2995": {"epss_score": 0.32698, "epss_percentile": 0.96717}, "CVE-2012-2996": {"epss_score": 0.0123, "epss_percentile": 0.7872}, "CVE-2012-2997": {"epss_score": 0.08849, "epss_percentile": 0.92284}, "CVE-2012-2998": {"epss_score": 0.09787, "epss_percentile": 0.92701}, "CVE-2012-2999": {"epss_score": 0.00081, "epss_percentile": 0.24228}, "CVE-2012-3000": {"epss_score": 0.01277, "epss_percentile": 0.79118}, "CVE-2012-3001": {"epss_score": 0.51333, "epss_percentile": 0.97775}, "CVE-2012-3002": {"epss_score": 0.01617, "epss_percentile": 0.81363}, "CVE-2012-3003": {"epss_score": 0.00328, "epss_percentile": 0.55174}, "CVE-2012-3004": {"epss_score": 0.00074, "epss_percentile": 0.22846}, "CVE-2012-3005": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2012-3006": {"epss_score": 0.0054, "epss_percentile": 0.66992}, "CVE-2012-3007": {"epss_score": 0.0056, "epss_percentile": 0.67643}, "CVE-2012-3008": {"epss_score": 0.09938, "epss_percentile": 0.92782}, "CVE-2012-3009": {"epss_score": 0.00307, "epss_percentile": 0.53518}, "CVE-2012-3010": {"epss_score": 0.03075, "epss_percentile": 0.86358}, "CVE-2012-3011": {"epss_score": 0.002, "epss_percentile": 0.42275}, "CVE-2012-3012": {"epss_score": 0.00475, "epss_percentile": 0.64244}, "CVE-2012-3013": {"epss_score": 0.00634, "epss_percentile": 0.69802}, "CVE-2012-3014": {"epss_score": 0.00077, "epss_percentile": 0.2332}, "CVE-2012-3015": {"epss_score": 0.00058, "epss_percentile": 0.18506}, "CVE-2012-3016": {"epss_score": 0.00902, "epss_percentile": 0.75185}, "CVE-2012-3017": {"epss_score": 0.00902, "epss_percentile": 0.75185}, "CVE-2012-3018": {"epss_score": 0.00031, "epss_percentile": 0.08324}, "CVE-2012-3020": {"epss_score": 0.00441, "epss_percentile": 0.62693}, "CVE-2012-3021": {"epss_score": 0.03075, "epss_percentile": 0.86358}, "CVE-2012-3022": {"epss_score": 0.0041, "epss_percentile": 0.60825}, "CVE-2012-3024": {"epss_score": 0.00266, "epss_percentile": 0.49943}, "CVE-2012-3025": {"epss_score": 0.00787, "epss_percentile": 0.73308}, "CVE-2012-3026": {"epss_score": 0.03075, "epss_percentile": 0.86358}, "CVE-2012-3028": {"epss_score": 0.0017, "epss_percentile": 0.3865}, "CVE-2012-3030": {"epss_score": 0.00518, "epss_percentile": 0.66096}, "CVE-2012-3031": {"epss_score": 0.00589, "epss_percentile": 0.68538}, "CVE-2012-3032": {"epss_score": 0.00538, "epss_percentile": 0.66943}, "CVE-2012-3034": {"epss_score": 0.00518, "epss_percentile": 0.66096}, "CVE-2012-3035": {"epss_score": 0.00738, "epss_percentile": 0.72345}, "CVE-2012-3037": {"epss_score": 0.00811, "epss_percentile": 0.7373}, "CVE-2012-3039": {"epss_score": 0.00526, "epss_percentile": 0.66397}, "CVE-2012-3040": {"epss_score": 0.01214, "epss_percentile": 0.78576}, "CVE-2012-3047": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-3051": {"epss_score": 0.00246, "epss_percentile": 0.47745}, "CVE-2012-3052": {"epss_score": 0.00143, "epss_percentile": 0.35214}, "CVE-2012-3053": {"epss_score": 0.04356, "epss_percentile": 0.88592}, "CVE-2012-3054": {"epss_score": 0.04356, "epss_percentile": 0.88592}, "CVE-2012-3055": {"epss_score": 0.04356, "epss_percentile": 0.88592}, "CVE-2012-3056": {"epss_score": 0.02927, "epss_percentile": 0.8601}, "CVE-2012-3057": {"epss_score": 0.04356, "epss_percentile": 0.88592}, "CVE-2012-3058": {"epss_score": 0.00963, "epss_percentile": 0.76003}, "CVE-2012-3060": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-3062": {"epss_score": 0.0017, "epss_percentile": 0.38729}, "CVE-2012-3063": {"epss_score": 0.00133, "epss_percentile": 0.33698}, "CVE-2012-3073": {"epss_score": 0.00475, "epss_percentile": 0.64196}, "CVE-2012-3074": {"epss_score": 0.00904, "epss_percentile": 0.75219}, "CVE-2012-3075": {"epss_score": 0.00619, "epss_percentile": 0.6943}, "CVE-2012-3076": {"epss_score": 0.00619, "epss_percentile": 0.6943}, "CVE-2012-3079": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-3088": {"epss_score": 0.00484, "epss_percentile": 0.64645}, "CVE-2012-3094": {"epss_score": 0.00119, "epss_percentile": 0.31577}, "CVE-2012-3096": {"epss_score": 0.00403, "epss_percentile": 0.60368}, "CVE-2012-3105": {"epss_score": 0.03223, "epss_percentile": 0.86678}, "CVE-2012-3106": {"epss_score": 0.00644, "epss_percentile": 0.70072}, "CVE-2012-3107": {"epss_score": 0.00619, "epss_percentile": 0.69397}, "CVE-2012-3108": {"epss_score": 0.00619, "epss_percentile": 0.69397}, "CVE-2012-3109": {"epss_score": 0.00619, "epss_percentile": 0.69397}, "CVE-2012-3110": {"epss_score": 0.00619, "epss_percentile": 0.69397}, "CVE-2012-3111": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2012-3112": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2012-3113": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2012-3114": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2012-3115": {"epss_score": 0.0061, "epss_percentile": 0.69142}, "CVE-2012-3116": {"epss_score": 0.00088, "epss_percentile": 0.25731}, "CVE-2012-3117": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2012-3118": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2012-3119": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2012-3120": {"epss_score": 0.02031, "epss_percentile": 0.83333}, "CVE-2012-3121": {"epss_score": 0.01207, "epss_percentile": 0.78528}, "CVE-2012-3122": {"epss_score": 0.0007, "epss_percentile": 0.21752}, "CVE-2012-3123": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2012-3124": {"epss_score": 0.01039, "epss_percentile": 0.76952}, "CVE-2012-3125": {"epss_score": 0.01613, "epss_percentile": 0.81339}, "CVE-2012-3126": {"epss_score": 0.00113, "epss_percentile": 0.30617}, "CVE-2012-3127": {"epss_score": 0.01722, "epss_percentile": 0.81938}, "CVE-2012-3128": {"epss_score": 0.00091, "epss_percentile": 0.26235}, "CVE-2012-3129": {"epss_score": 0.01023, "epss_percentile": 0.76774}, "CVE-2012-3130": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2012-3131": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2012-3132": {"epss_score": 0.00996, "epss_percentile": 0.76442}, "CVE-2012-3133": {"epss_score": 0.00727, "epss_percentile": 0.72092}, "CVE-2012-3134": {"epss_score": 0.00923, "epss_percentile": 0.75508}, "CVE-2012-3135": {"epss_score": 0.02628, "epss_percentile": 0.85273}, "CVE-2012-3136": {"epss_score": 0.01027, "epss_percentile": 0.76803}, "CVE-2012-3137": {"epss_score": 0.53243, "epss_percentile": 0.97868}, "CVE-2012-3138": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2012-3139": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2012-3140": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2012-3141": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2012-3142": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2012-3143": {"epss_score": 0.12617, "epss_percentile": 0.93731}, "CVE-2012-3144": {"epss_score": 0.00525, "epss_percentile": 0.66378}, "CVE-2012-3145": {"epss_score": 0.00318, "epss_percentile": 0.54441}, "CVE-2012-3146": {"epss_score": 0.0017, "epss_percentile": 0.38705}, "CVE-2012-3147": {"epss_score": 0.00773, "epss_percentile": 0.73063}, "CVE-2012-3148": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2012-3149": {"epss_score": 0.00188, "epss_percentile": 0.40807}, "CVE-2012-3150": {"epss_score": 0.00613, "epss_percentile": 0.69245}, "CVE-2012-3151": {"epss_score": 0.0025, "epss_percentile": 0.48256}, "CVE-2012-3152": {"epss_score": 0.92637, "epss_percentile": 0.99731}, "CVE-2012-3153": {"epss_score": 0.91205, "epss_percentile": 0.99627}, "CVE-2012-3154": {"epss_score": 0.00191, "epss_percentile": 0.41182}, "CVE-2012-3155": {"epss_score": 0.00605, "epss_percentile": 0.68974}, "CVE-2012-3156": {"epss_score": 0.00295, "epss_percentile": 0.52516}, "CVE-2012-3157": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2012-3158": {"epss_score": 0.02532, "epss_percentile": 0.85028}, "CVE-2012-3159": {"epss_score": 0.06826, "epss_percentile": 0.91051}, "CVE-2012-3160": {"epss_score": 0.00078, "epss_percentile": 0.23625}, "CVE-2012-3161": {"epss_score": 0.00324, "epss_percentile": 0.54931}, "CVE-2012-3162": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2012-3163": {"epss_score": 0.00955, "epss_percentile": 0.75909}, "CVE-2012-3164": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2012-3165": {"epss_score": 0.00054, "epss_percentile": 0.17366}, "CVE-2012-3166": {"epss_score": 0.00453, "epss_percentile": 0.6323}, "CVE-2012-3167": {"epss_score": 0.0043, "epss_percentile": 0.62007}, "CVE-2012-3168": {"epss_score": 0.00355, "epss_percentile": 0.57273}, "CVE-2012-3169": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2012-3170": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2012-3171": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2012-3172": {"epss_score": 0.00355, "epss_percentile": 0.57273}, "CVE-2012-3173": {"epss_score": 0.00613, "epss_percentile": 0.69245}, "CVE-2012-3174": {"epss_score": 0.01406, "epss_percentile": 0.80047}, "CVE-2012-3175": {"epss_score": 0.003, "epss_percentile": 0.5298}, "CVE-2012-3176": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2012-3177": {"epss_score": 0.00704, "epss_percentile": 0.71569}, "CVE-2012-3178": {"epss_score": 0.00051, "epss_percentile": 0.16155}, "CVE-2012-3179": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2012-3180": {"epss_score": 0.00613, "epss_percentile": 0.69245}, "CVE-2012-3181": {"epss_score": 0.00452, "epss_percentile": 0.63178}, "CVE-2012-3182": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2012-3183": {"epss_score": 0.02167, "epss_percentile": 0.83853}, "CVE-2012-3184": {"epss_score": 0.17316, "epss_percentile": 0.94821}, "CVE-2012-3185": {"epss_score": 0.02167, "epss_percentile": 0.83853}, "CVE-2012-3186": {"epss_score": 0.02167, "epss_percentile": 0.83853}, "CVE-2012-3187": {"epss_score": 0.00044, "epss_percentile": 0.13634}, "CVE-2012-3188": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2012-3189": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2012-3190": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2012-3191": {"epss_score": 0.00452, "epss_percentile": 0.63178}, "CVE-2012-3192": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2012-3193": {"epss_score": 0.00191, "epss_percentile": 0.41182}, "CVE-2012-3194": {"epss_score": 0.00351, "epss_percentile": 0.57071}, "CVE-2012-3195": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2012-3196": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2012-3197": {"epss_score": 0.0043, "epss_percentile": 0.62007}, "CVE-2012-3198": {"epss_score": 0.00452, "epss_percentile": 0.63178}, "CVE-2012-3199": {"epss_score": 0.00048, "epss_percentile": 0.15047}, "CVE-2012-3200": {"epss_score": 0.00202, "epss_percentile": 0.42412}, "CVE-2012-3201": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2012-3202": {"epss_score": 0.03516, "epss_percentile": 0.87274}, "CVE-2012-3203": {"epss_score": 0.00055, "epss_percentile": 0.17527}, "CVE-2012-3204": {"epss_score": 0.00048, "epss_percentile": 0.15047}, "CVE-2012-3205": {"epss_score": 0.00059, "epss_percentile": 0.18717}, "CVE-2012-3206": {"epss_score": 0.00409, "epss_percentile": 0.60731}, "CVE-2012-3207": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2012-3208": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2012-3209": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2012-3210": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2012-3211": {"epss_score": 0.00045, "epss_percentile": 0.13992}, "CVE-2012-3212": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2012-3213": {"epss_score": 0.10133, "epss_percentile": 0.92862}, "CVE-2012-3214": {"epss_score": 0.00789, "epss_percentile": 0.73364}, "CVE-2012-3215": {"epss_score": 0.00058, "epss_percentile": 0.18312}, "CVE-2012-3216": {"epss_score": 0.02393, "epss_percentile": 0.84608}, "CVE-2012-3217": {"epss_score": 0.00789, "epss_percentile": 0.73364}, "CVE-2012-3218": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2012-3219": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2012-3220": {"epss_score": 0.00628, "epss_percentile": 0.69649}, "CVE-2012-3221": {"epss_score": 0.00396, "epss_percentile": 0.59891}, "CVE-2012-3222": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2012-3223": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2012-3224": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2012-3225": {"epss_score": 0.00209, "epss_percentile": 0.43394}, "CVE-2012-3226": {"epss_score": 0.00185, "epss_percentile": 0.40532}, "CVE-2012-3227": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2012-3228": {"epss_score": 0.0041, "epss_percentile": 0.60838}, "CVE-2012-3229": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2012-3230": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2012-3231": {"epss_score": 0.00458, "epss_percentile": 0.6344}, "CVE-2012-3232": {"epss_score": 0.00314, "epss_percentile": 0.54111}, "CVE-2012-3233": {"epss_score": 0.00739, "epss_percentile": 0.72396}, "CVE-2012-3234": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2012-3236": {"epss_score": 0.09325, "epss_percentile": 0.92501}, "CVE-2012-3238": {"epss_score": 0.0054, "epss_percentile": 0.67002}, "CVE-2012-3240": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2012-3241": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2012-3243": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-3247": {"epss_score": 0.00071, "epss_percentile": 0.21987}, "CVE-2012-3248": {"epss_score": 0.00689, "epss_percentile": 0.71218}, "CVE-2012-3249": {"epss_score": 0.00237, "epss_percentile": 0.46723}, "CVE-2012-3250": {"epss_score": 0.01409, "epss_percentile": 0.80069}, "CVE-2012-3251": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2012-3252": {"epss_score": 0.01441, "epss_percentile": 0.80305}, "CVE-2012-3253": {"epss_score": 0.30959, "epss_percentile": 0.96578}, "CVE-2012-3254": {"epss_score": 0.30959, "epss_percentile": 0.96578}, "CVE-2012-3255": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2012-3256": {"epss_score": 0.00119, "epss_percentile": 0.31682}, "CVE-2012-3257": {"epss_score": 0.00215, "epss_percentile": 0.441}, "CVE-2012-3258": {"epss_score": 0.29115, "epss_percentile": 0.96419}, "CVE-2012-3259": {"epss_score": 0.29227, "epss_percentile": 0.96426}, "CVE-2012-3260": {"epss_score": 0.68581, "epss_percentile": 0.98554}, "CVE-2012-3261": {"epss_score": 0.68581, "epss_percentile": 0.98554}, "CVE-2012-3262": {"epss_score": 0.24213, "epss_percentile": 0.95887}, "CVE-2012-3263": {"epss_score": 0.24213, "epss_percentile": 0.95887}, "CVE-2012-3264": {"epss_score": 0.066, "epss_percentile": 0.90877}, "CVE-2012-3266": {"epss_score": 0.00689, "epss_percentile": 0.71218}, "CVE-2012-3267": {"epss_score": 0.01493, "epss_percentile": 0.8064}, "CVE-2012-3268": {"epss_score": 0.01344, "epss_percentile": 0.7961}, "CVE-2012-3269": {"epss_score": 0.0168, "epss_percentile": 0.81725}, "CVE-2012-3270": {"epss_score": 0.03308, "epss_percentile": 0.86881}, "CVE-2012-3271": {"epss_score": 0.01384, "epss_percentile": 0.799}, "CVE-2012-3272": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2012-3273": {"epss_score": 0.00689, "epss_percentile": 0.71218}, "CVE-2012-3274": {"epss_score": 0.73427, "epss_percentile": 0.98754}, "CVE-2012-3275": {"epss_score": 0.25437, "epss_percentile": 0.96028}, "CVE-2012-3276": {"epss_score": 0.00077, "epss_percentile": 0.23303}, "CVE-2012-3277": {"epss_score": 0.01409, "epss_percentile": 0.80069}, "CVE-2012-3278": {"epss_score": 0.35722, "epss_percentile": 0.96928}, "CVE-2012-3279": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2012-3280": {"epss_score": 0.00107, "epss_percentile": 0.29655}, "CVE-2012-3281": {"epss_score": 0.01441, "epss_percentile": 0.80305}, "CVE-2012-3282": {"epss_score": 0.35052, "epss_percentile": 0.96886}, "CVE-2012-3283": {"epss_score": 0.23247, "epss_percentile": 0.95756}, "CVE-2012-3284": {"epss_score": 0.26853, "epss_percentile": 0.96186}, "CVE-2012-3285": {"epss_score": 0.26853, "epss_percentile": 0.96186}, "CVE-2012-3286": {"epss_score": 0.00267, "epss_percentile": 0.49971}, "CVE-2012-3287": {"epss_score": 0.00381, "epss_percentile": 0.59004}, "CVE-2012-3288": {"epss_score": 0.02027, "epss_percentile": 0.83319}, "CVE-2012-3289": {"epss_score": 0.00561, "epss_percentile": 0.67657}, "CVE-2012-3290": {"epss_score": 0.00162, "epss_percentile": 0.37643}, "CVE-2012-3291": {"epss_score": 0.0115, "epss_percentile": 0.78024}, "CVE-2012-3292": {"epss_score": 0.0252, "epss_percentile": 0.85001}, "CVE-2012-3293": {"epss_score": 0.00265, "epss_percentile": 0.49789}, "CVE-2012-3294": {"epss_score": 0.0032, "epss_percentile": 0.54639}, "CVE-2012-3295": {"epss_score": 0.00186, "epss_percentile": 0.40678}, "CVE-2012-3296": {"epss_score": 0.00584, "epss_percentile": 0.68395}, "CVE-2012-3297": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2012-3298": {"epss_score": 0.02387, "epss_percentile": 0.84584}, "CVE-2012-3300": {"epss_score": 0.00594, "epss_percentile": 0.68675}, "CVE-2012-3301": {"epss_score": 0.00257, "epss_percentile": 0.48891}, "CVE-2012-3302": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2012-3304": {"epss_score": 0.00741, "epss_percentile": 0.72435}, "CVE-2012-3305": {"epss_score": 0.00233, "epss_percentile": 0.46022}, "CVE-2012-3306": {"epss_score": 0.00343, "epss_percentile": 0.56454}, "CVE-2012-3308": {"epss_score": 0.0023, "epss_percentile": 0.45669}, "CVE-2012-3309": {"epss_score": 0.00146, "epss_percentile": 0.35579}, "CVE-2012-3310": {"epss_score": 0.00262, "epss_percentile": 0.49395}, "CVE-2012-3311": {"epss_score": 0.00054, "epss_percentile": 0.1723}, "CVE-2012-3312": {"epss_score": 0.00349, "epss_percentile": 0.56875}, "CVE-2012-3313": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2012-3314": {"epss_score": 0.00183, "epss_percentile": 0.40331}, "CVE-2012-3315": {"epss_score": 0.00405, "epss_percentile": 0.60473}, "CVE-2012-3316": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2012-3317": {"epss_score": 0.00058, "epss_percentile": 0.18511}, "CVE-2012-3319": {"epss_score": 0.00264, "epss_percentile": 0.49687}, "CVE-2012-3321": {"epss_score": 0.00216, "epss_percentile": 0.44157}, "CVE-2012-3322": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2012-3323": {"epss_score": 0.01098, "epss_percentile": 0.77532}, "CVE-2012-3324": {"epss_score": 0.00806, "epss_percentile": 0.73647}, "CVE-2012-3325": {"epss_score": 0.00969, "epss_percentile": 0.76105}, "CVE-2012-3326": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2012-3327": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2012-3328": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2012-3329": {"epss_score": 0.00104, "epss_percentile": 0.2911}, "CVE-2012-3330": {"epss_score": 0.00594, "epss_percentile": 0.68675}, "CVE-2012-3331": {"epss_score": 0.00164, "epss_percentile": 0.37973}, "CVE-2012-3333": {"epss_score": 0.00246, "epss_percentile": 0.47798}, "CVE-2012-3334": {"epss_score": 0.08542, "epss_percentile": 0.92113}, "CVE-2012-3336": {"epss_score": 0.00456, "epss_percentile": 0.63349}, "CVE-2012-3337": {"epss_score": 0.00543, "epss_percentile": 0.67115}, "CVE-2012-3338": {"epss_score": 0.00298, "epss_percentile": 0.52837}, "CVE-2012-3340": {"epss_score": 0.002, "epss_percentile": 0.42219}, "CVE-2012-3341": {"epss_score": 0.00235, "epss_percentile": 0.46321}, "CVE-2012-3342": {"epss_score": 0.08537, "epss_percentile": 0.92109}, "CVE-2012-3343": {"epss_score": 0.00083, "epss_percentile": 0.24816}, "CVE-2012-3345": {"epss_score": 0.00033, "epss_percentile": 0.09216}, "CVE-2012-3347": {"epss_score": 0.00762, "epss_percentile": 0.72834}, "CVE-2012-3350": {"epss_score": 0.01919, "epss_percentile": 0.82883}, "CVE-2012-3351": {"epss_score": 0.01776, "epss_percentile": 0.82219}, "CVE-2012-3353": {"epss_score": 0.00321, "epss_percentile": 0.54645}, "CVE-2012-3354": {"epss_score": 0.00546, "epss_percentile": 0.67206}, "CVE-2012-3355": {"epss_score": 0.00093, "epss_percentile": 0.26654}, "CVE-2012-3356": {"epss_score": 0.00436, "epss_percentile": 0.62469}, "CVE-2012-3357": {"epss_score": 0.00705, "epss_percentile": 0.71589}, "CVE-2012-3358": {"epss_score": 0.04464, "epss_percentile": 0.88726}, "CVE-2012-3359": {"epss_score": 0.00142, "epss_percentile": 0.35015}, "CVE-2012-3360": {"epss_score": 0.02565, "epss_percentile": 0.85114}, "CVE-2012-3361": {"epss_score": 0.01377, "epss_percentile": 0.79845}, "CVE-2012-3362": {"epss_score": 0.00107, "epss_percentile": 0.29588}, "CVE-2012-3363": {"epss_score": 0.60484, "epss_percentile": 0.98208}, "CVE-2012-3364": {"epss_score": 0.01565, "epss_percentile": 0.81063}, "CVE-2012-3365": {"epss_score": 0.00917, "epss_percentile": 0.75427}, "CVE-2012-3366": {"epss_score": 0.01624, "epss_percentile": 0.81407}, "CVE-2012-3367": {"epss_score": 0.004, "epss_percentile": 0.60152}, "CVE-2012-3368": {"epss_score": 0.00444, "epss_percentile": 0.62805}, "CVE-2012-3369": {"epss_score": 0.0131, "epss_percentile": 0.7936}, "CVE-2012-3370": {"epss_score": 0.01673, "epss_percentile": 0.8169}, "CVE-2012-3371": {"epss_score": 0.00881, "epss_percentile": 0.74861}, "CVE-2012-3372": {"epss_score": 0.00071, "epss_percentile": 0.22116}, "CVE-2012-3373": {"epss_score": 0.01795, "epss_percentile": 0.82297}, "CVE-2012-3374": {"epss_score": 0.04706, "epss_percentile": 0.8903}, "CVE-2012-3375": {"epss_score": 0.00137, "epss_percentile": 0.34304}, "CVE-2012-3376": {"epss_score": 0.01302, "epss_percentile": 0.79297}, "CVE-2012-3377": {"epss_score": 0.03905, "epss_percentile": 0.87926}, "CVE-2012-3378": {"epss_score": 0.00063, "epss_percentile": 0.19886}, "CVE-2012-3380": {"epss_score": 0.00166, "epss_percentile": 0.38174}, "CVE-2012-3381": {"epss_score": 0.00158, "epss_percentile": 0.37253}, "CVE-2012-3382": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2012-3383": {"epss_score": 0.00154, "epss_percentile": 0.3667}, "CVE-2012-3384": {"epss_score": 0.00179, "epss_percentile": 0.39799}, "CVE-2012-3385": {"epss_score": 0.00669, "epss_percentile": 0.70747}, "CVE-2012-3386": {"epss_score": 0.00138, "epss_percentile": 0.34357}, "CVE-2012-3387": {"epss_score": 0.00198, "epss_percentile": 0.42027}, "CVE-2012-3388": {"epss_score": 0.00198, "epss_percentile": 0.42027}, "CVE-2012-3389": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2012-3390": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2012-3391": {"epss_score": 0.00223, "epss_percentile": 0.44896}, "CVE-2012-3392": {"epss_score": 0.00304, "epss_percentile": 0.5325}, "CVE-2012-3393": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2012-3394": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2012-3395": {"epss_score": 0.00349, "epss_percentile": 0.56899}, "CVE-2012-3396": {"epss_score": 0.00208, "epss_percentile": 0.43213}, "CVE-2012-3397": {"epss_score": 0.00198, "epss_percentile": 0.42027}, "CVE-2012-3398": {"epss_score": 0.00621, "epss_percentile": 0.69486}, "CVE-2012-3399": {"epss_score": 0.85193, "epss_percentile": 0.99323}, "CVE-2012-3400": {"epss_score": 0.0748, "epss_percentile": 0.91495}, "CVE-2012-3401": {"epss_score": 0.00916, "epss_percentile": 0.75414}, "CVE-2012-3402": {"epss_score": 0.01043, "epss_percentile": 0.76988}, "CVE-2012-3403": {"epss_score": 0.04289, "epss_percentile": 0.885}, "CVE-2012-3404": {"epss_score": 0.00604, "epss_percentile": 0.6896}, "CVE-2012-3405": {"epss_score": 0.00666, "epss_percentile": 0.70691}, "CVE-2012-3406": {"epss_score": 0.00869, "epss_percentile": 0.74686}, "CVE-2012-3407": {"epss_score": 0.00217, "epss_percentile": 0.44308}, "CVE-2012-3408": {"epss_score": 0.00257, "epss_percentile": 0.48916}, "CVE-2012-3409": {"epss_score": 0.00075, "epss_percentile": 0.22962}, "CVE-2012-3410": {"epss_score": 0.00083, "epss_percentile": 0.24806}, "CVE-2012-3411": {"epss_score": 0.00633, "epss_percentile": 0.69763}, "CVE-2012-3412": {"epss_score": 0.11798, "epss_percentile": 0.9348}, "CVE-2012-3413": {"epss_score": 0.00828, "epss_percentile": 0.74}, "CVE-2012-3414": {"epss_score": 0.06259, "epss_percentile": 0.90619}, "CVE-2012-3416": {"epss_score": 0.01876, "epss_percentile": 0.82657}, "CVE-2012-3417": {"epss_score": 0.00196, "epss_percentile": 0.41807}, "CVE-2012-3418": {"epss_score": 0.06054, "epss_percentile": 0.90438}, "CVE-2012-3419": {"epss_score": 0.014, "epss_percentile": 0.80002}, "CVE-2012-3420": {"epss_score": 0.035, "epss_percentile": 0.87244}, "CVE-2012-3421": {"epss_score": 0.02459, "epss_percentile": 0.84818}, "CVE-2012-3422": {"epss_score": 0.01173, "epss_percentile": 0.7824}, "CVE-2012-3423": {"epss_score": 0.0278, "epss_percentile": 0.85648}, "CVE-2012-3424": {"epss_score": 0.00981, "epss_percentile": 0.76279}, "CVE-2012-3425": {"epss_score": 0.01252, "epss_percentile": 0.78907}, "CVE-2012-3426": {"epss_score": 0.00208, "epss_percentile": 0.43305}, "CVE-2012-3427": {"epss_score": 0.00109, "epss_percentile": 0.29978}, "CVE-2012-3428": {"epss_score": 0.00546, "epss_percentile": 0.67206}, "CVE-2012-3429": {"epss_score": 0.0127, "epss_percentile": 0.79046}, "CVE-2012-3430": {"epss_score": 0.00177, "epss_percentile": 0.39625}, "CVE-2012-3431": {"epss_score": 0.00343, "epss_percentile": 0.56453}, "CVE-2012-3432": {"epss_score": 0.0142, "epss_percentile": 0.80167}, "CVE-2012-3433": {"epss_score": 0.00075, "epss_percentile": 0.2296}, "CVE-2012-3434": {"epss_score": 0.00544, "epss_percentile": 0.67149}, "CVE-2012-3435": {"epss_score": 0.02759, "epss_percentile": 0.85597}, "CVE-2012-3436": {"epss_score": 0.0234, "epss_percentile": 0.84434}, "CVE-2012-3437": {"epss_score": 0.03344, "epss_percentile": 0.86949}, "CVE-2012-3438": {"epss_score": 0.01138, "epss_percentile": 0.77933}, "CVE-2012-3440": {"epss_score": 0.00121, "epss_percentile": 0.31819}, "CVE-2012-3441": {"epss_score": 0.00588, "epss_percentile": 0.68508}, "CVE-2012-3442": {"epss_score": 0.00442, "epss_percentile": 0.62733}, "CVE-2012-3443": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2012-3444": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2012-3445": {"epss_score": 0.01323, "epss_percentile": 0.79457}, "CVE-2012-3446": {"epss_score": 0.00336, "epss_percentile": 0.55949}, "CVE-2012-3447": {"epss_score": 0.00925, "epss_percentile": 0.75529}, "CVE-2012-3448": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-3449": {"epss_score": 0.00045, "epss_percentile": 0.13811}, "CVE-2012-3450": {"epss_score": 0.12009, "epss_percentile": 0.93545}, "CVE-2012-3451": {"epss_score": 0.09969, "epss_percentile": 0.92797}, "CVE-2012-3452": {"epss_score": 0.00067, "epss_percentile": 0.21119}, "CVE-2012-3453": {"epss_score": 0.00042, "epss_percentile": 0.12788}, "CVE-2012-3454": {"epss_score": 0.00039, "epss_percentile": 0.11628}, "CVE-2012-3455": {"epss_score": 0.0661, "epss_percentile": 0.90886}, "CVE-2012-3456": {"epss_score": 0.46505, "epss_percentile": 0.97549}, "CVE-2012-3457": {"epss_score": 0.00054, "epss_percentile": 0.17102}, "CVE-2012-3458": {"epss_score": 0.00603, "epss_percentile": 0.68936}, "CVE-2012-3459": {"epss_score": 0.00423, "epss_percentile": 0.61598}, "CVE-2012-3460": {"epss_score": 0.00389, "epss_percentile": 0.59471}, "CVE-2012-3461": {"epss_score": 0.04291, "epss_percentile": 0.88502}, "CVE-2012-3462": {"epss_score": 0.00333, "epss_percentile": 0.55674}, "CVE-2012-3463": {"epss_score": 0.00333, "epss_percentile": 0.55619}, "CVE-2012-3464": {"epss_score": 0.00333, "epss_percentile": 0.55619}, "CVE-2012-3465": {"epss_score": 0.00333, "epss_percentile": 0.55619}, "CVE-2012-3466": {"epss_score": 0.00096, "epss_percentile": 0.27413}, "CVE-2012-3467": {"epss_score": 0.01158, "epss_percentile": 0.78119}, "CVE-2012-3468": {"epss_score": 0.0039, "epss_percentile": 0.59536}, "CVE-2012-3469": {"epss_score": 0.00465, "epss_percentile": 0.63773}, "CVE-2012-3470": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2012-3471": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2012-3472": {"epss_score": 0.00527, "epss_percentile": 0.6652}, "CVE-2012-3473": {"epss_score": 0.00299, "epss_percentile": 0.52847}, "CVE-2012-3474": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-3475": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2012-3476": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2012-3477": {"epss_score": 0.00466, "epss_percentile": 0.63789}, "CVE-2012-3478": {"epss_score": 0.0006, "epss_percentile": 0.18974}, "CVE-2012-3479": {"epss_score": 0.0229, "epss_percentile": 0.84277}, "CVE-2012-3480": {"epss_score": 0.00203, "epss_percentile": 0.42495}, "CVE-2012-3481": {"epss_score": 0.03809, "epss_percentile": 0.87756}, "CVE-2012-3482": {"epss_score": 0.00721, "epss_percentile": 0.71976}, "CVE-2012-3483": {"epss_score": 0.00235, "epss_percentile": 0.46243}, "CVE-2012-3484": {"epss_score": 0.00025, "epss_percentile": 0.06256}, "CVE-2012-3485": {"epss_score": 0.2587, "epss_percentile": 0.96087}, "CVE-2012-3486": {"epss_score": 0.00033, "epss_percentile": 0.09281}, "CVE-2012-3487": {"epss_score": 0.00023, "epss_percentile": 0.0541}, "CVE-2012-3488": {"epss_score": 0.00267, "epss_percentile": 0.50017}, "CVE-2012-3489": {"epss_score": 0.01042, "epss_percentile": 0.76975}, "CVE-2012-3490": {"epss_score": 0.01956, "epss_percentile": 0.8304}, "CVE-2012-3491": {"epss_score": 0.0112, "epss_percentile": 0.7776}, "CVE-2012-3492": {"epss_score": 0.00698, "epss_percentile": 0.71417}, "CVE-2012-3493": {"epss_score": 0.00765, "epss_percentile": 0.72917}, "CVE-2012-3494": {"epss_score": 0.00112, "epss_percentile": 0.30415}, "CVE-2012-3495": {"epss_score": 0.00081, "epss_percentile": 0.24238}, "CVE-2012-3496": {"epss_score": 0.00093, "epss_percentile": 0.26759}, "CVE-2012-3497": {"epss_score": 0.00107, "epss_percentile": 0.29589}, "CVE-2012-3498": {"epss_score": 0.00068, "epss_percentile": 0.21205}, "CVE-2012-3499": {"epss_score": 0.08411, "epss_percentile": 0.92036}, "CVE-2012-3500": {"epss_score": 0.00055, "epss_percentile": 0.17547}, "CVE-2012-3501": {"epss_score": 0.0229, "epss_percentile": 0.8428}, "CVE-2012-3502": {"epss_score": 0.03787, "epss_percentile": 0.87727}, "CVE-2012-3503": {"epss_score": 0.01303, "epss_percentile": 0.79307}, "CVE-2012-3504": {"epss_score": 0.00147, "epss_percentile": 0.35795}, "CVE-2012-3505": {"epss_score": 0.03355, "epss_percentile": 0.86973}, "CVE-2012-3506": {"epss_score": 0.0416, "epss_percentile": 0.88334}, "CVE-2012-3507": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2012-3508": {"epss_score": 0.09998, "epss_percentile": 0.92809}, "CVE-2012-3509": {"epss_score": 0.01748, "epss_percentile": 0.82079}, "CVE-2012-3510": {"epss_score": 0.00122, "epss_percentile": 0.32107}, "CVE-2012-3511": {"epss_score": 0.0009, "epss_percentile": 0.26085}, "CVE-2012-3512": {"epss_score": 0.00082, "epss_percentile": 0.24415}, "CVE-2012-3513": {"epss_score": 0.00792, "epss_percentile": 0.73399}, "CVE-2012-3514": {"epss_score": 0.0049, "epss_percentile": 0.64937}, "CVE-2012-3515": {"epss_score": 0.00122, "epss_percentile": 0.321}, "CVE-2012-3516": {"epss_score": 0.00081, "epss_percentile": 0.24337}, "CVE-2012-3517": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2012-3518": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2012-3519": {"epss_score": 0.00635, "epss_percentile": 0.69812}, "CVE-2012-3520": {"epss_score": 0.00085, "epss_percentile": 0.25071}, "CVE-2012-3521": {"epss_score": 0.00639, "epss_percentile": 0.69934}, "CVE-2012-3522": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-3523": {"epss_score": 0.18812, "epss_percentile": 0.95074}, "CVE-2012-3524": {"epss_score": 0.50386, "epss_percentile": 0.97735}, "CVE-2012-3525": {"epss_score": 0.02925, "epss_percentile": 0.86005}, "CVE-2012-3526": {"epss_score": 0.02596, "epss_percentile": 0.85199}, "CVE-2012-3527": {"epss_score": 0.02065, "epss_percentile": 0.83454}, "CVE-2012-3528": {"epss_score": 0.00522, "epss_percentile": 0.66283}, "CVE-2012-3529": {"epss_score": 0.00374, "epss_percentile": 0.58577}, "CVE-2012-3530": {"epss_score": 0.00573, "epss_percentile": 0.68045}, "CVE-2012-3531": {"epss_score": 0.00248, "epss_percentile": 0.47942}, "CVE-2012-3532": {"epss_score": 0.00142, "epss_percentile": 0.35052}, "CVE-2012-3533": {"epss_score": 0.00294, "epss_percentile": 0.52391}, "CVE-2012-3534": {"epss_score": 0.01691, "epss_percentile": 0.8178}, "CVE-2012-3535": {"epss_score": 0.04645, "epss_percentile": 0.88957}, "CVE-2012-3536": {"epss_score": 0.01349, "epss_percentile": 0.7967}, "CVE-2012-3537": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2012-3538": {"epss_score": 0.00191, "epss_percentile": 0.41194}, "CVE-2012-3540": {"epss_score": 0.01917, "epss_percentile": 0.82871}, "CVE-2012-3542": {"epss_score": 0.01757, "epss_percentile": 0.82133}, "CVE-2012-3543": {"epss_score": 0.01005, "epss_percentile": 0.76534}, "CVE-2012-3544": {"epss_score": 0.44479, "epss_percentile": 0.9744}, "CVE-2012-3546": {"epss_score": 0.0223, "epss_percentile": 0.84083}, "CVE-2012-3547": {"epss_score": 0.16889, "epss_percentile": 0.94742}, "CVE-2012-3548": {"epss_score": 0.00493, "epss_percentile": 0.65037}, "CVE-2012-3549": {"epss_score": 0.12208, "epss_percentile": 0.93602}, "CVE-2012-3551": {"epss_score": 0.03541, "epss_percentile": 0.87319}, "CVE-2012-3552": {"epss_score": 0.02043, "epss_percentile": 0.83379}, "CVE-2012-3553": {"epss_score": 0.00069, "epss_percentile": 0.21442}, "CVE-2012-3554": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2012-3555": {"epss_score": 0.05584, "epss_percentile": 0.90023}, "CVE-2012-3556": {"epss_score": 0.02869, "epss_percentile": 0.85871}, "CVE-2012-3557": {"epss_score": 0.00377, "epss_percentile": 0.5876}, "CVE-2012-3558": {"epss_score": 0.00339, "epss_percentile": 0.56178}, "CVE-2012-3559": {"epss_score": 0.00331, "epss_percentile": 0.55521}, "CVE-2012-3560": {"epss_score": 0.00722, "epss_percentile": 0.71995}, "CVE-2012-3561": {"epss_score": 0.10215, "epss_percentile": 0.92897}, "CVE-2012-3562": {"epss_score": 0.00408, "epss_percentile": 0.60669}, "CVE-2012-3563": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2012-3564": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-3565": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-3566": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2012-3567": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-3568": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2012-3569": {"epss_score": 0.80635, "epss_percentile": 0.99098}, "CVE-2012-3570": {"epss_score": 0.04048, "epss_percentile": 0.88174}, "CVE-2012-3571": {"epss_score": 0.22137, "epss_percentile": 0.95599}, "CVE-2012-3572": {"epss_score": 0.00429, "epss_percentile": 0.61982}, "CVE-2012-3574": {"epss_score": 0.21784, "epss_percentile": 0.95559}, "CVE-2012-3575": {"epss_score": 0.43906, "epss_percentile": 0.97407}, "CVE-2012-3576": {"epss_score": 0.48708, "epss_percentile": 0.9765}, "CVE-2012-3577": {"epss_score": 0.25553, "epss_percentile": 0.9604}, "CVE-2012-3578": {"epss_score": 0.17845, "epss_percentile": 0.94916}, "CVE-2012-3579": {"epss_score": 0.36373, "epss_percentile": 0.96972}, "CVE-2012-3580": {"epss_score": 0.00897, "epss_percentile": 0.75124}, "CVE-2012-3581": {"epss_score": 0.00153, "epss_percentile": 0.36577}, "CVE-2012-3582": {"epss_score": 0.00225, "epss_percentile": 0.45095}, "CVE-2012-3585": {"epss_score": 0.27546, "epss_percentile": 0.96257}, "CVE-2012-3587": {"epss_score": 0.00156, "epss_percentile": 0.36934}, "CVE-2012-3588": {"epss_score": 0.17644, "epss_percentile": 0.94883}, "CVE-2012-3589": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3590": {"epss_score": 0.0124, "epss_percentile": 0.78802}, "CVE-2012-3591": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3592": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3593": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3594": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3595": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3596": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3597": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3598": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3599": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3600": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3601": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3602": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3603": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3604": {"epss_score": 0.02013, "epss_percentile": 0.83258}, "CVE-2012-3605": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3606": {"epss_score": 0.01664, "epss_percentile": 0.81644}, "CVE-2012-3607": {"epss_score": 0.01664, "epss_percentile": 0.81644}, "CVE-2012-3608": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3609": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3610": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3611": {"epss_score": 0.02013, "epss_percentile": 0.83258}, "CVE-2012-3612": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3613": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3614": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3615": {"epss_score": 0.0197, "epss_percentile": 0.83095}, "CVE-2012-3616": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3617": {"epss_score": 0.01258, "epss_percentile": 0.78954}, "CVE-2012-3618": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3620": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3621": {"epss_score": 0.01664, "epss_percentile": 0.81644}, "CVE-2012-3622": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3623": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3624": {"epss_score": 0.01272, "epss_percentile": 0.79079}, "CVE-2012-3625": {"epss_score": 0.021, "epss_percentile": 0.836}, "CVE-2012-3626": {"epss_score": 0.02013, "epss_percentile": 0.83258}, "CVE-2012-3627": {"epss_score": 0.021, "epss_percentile": 0.836}, "CVE-2012-3628": {"epss_score": 0.02013, "epss_percentile": 0.83258}, "CVE-2012-3629": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3630": {"epss_score": 0.02653, "epss_percentile": 0.8535}, "CVE-2012-3631": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3632": {"epss_score": 0.017, "epss_percentile": 0.81832}, "CVE-2012-3633": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3634": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3635": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3636": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3637": {"epss_score": 0.02653, "epss_percentile": 0.8535}, "CVE-2012-3638": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3639": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3640": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3641": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3642": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3643": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3644": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3645": {"epss_score": 0.021, "epss_percentile": 0.836}, "CVE-2012-3646": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3647": {"epss_score": 0.00786, "epss_percentile": 0.73293}, "CVE-2012-3648": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3649": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3650": {"epss_score": 0.00454, "epss_percentile": 0.6325}, "CVE-2012-3651": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3652": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3653": {"epss_score": 0.0271, "epss_percentile": 0.85489}, "CVE-2012-3654": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3655": {"epss_score": 0.021, "epss_percentile": 0.836}, "CVE-2012-3656": {"epss_score": 0.021, "epss_percentile": 0.836}, "CVE-2012-3657": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3658": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3659": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3660": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3661": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3663": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3664": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3665": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3666": {"epss_score": 0.02767, "epss_percentile": 0.85614}, "CVE-2012-3667": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3668": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3669": {"epss_score": 0.021, "epss_percentile": 0.836}, "CVE-2012-3670": {"epss_score": 0.021, "epss_percentile": 0.836}, "CVE-2012-3671": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3672": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3673": {"epss_score": 0.0146, "epss_percentile": 0.80421}, "CVE-2012-3674": {"epss_score": 0.021, "epss_percentile": 0.836}, "CVE-2012-3675": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3676": {"epss_score": 0.01272, "epss_percentile": 0.79079}, "CVE-2012-3677": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3678": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3679": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3680": {"epss_score": 0.021, "epss_percentile": 0.836}, "CVE-2012-3681": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3682": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3683": {"epss_score": 0.02767, "epss_percentile": 0.85614}, "CVE-2012-3684": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3685": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3686": {"epss_score": 0.02826, "epss_percentile": 0.85764}, "CVE-2012-3687": {"epss_score": 0.01664, "epss_percentile": 0.81644}, "CVE-2012-3688": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3689": {"epss_score": 0.00155, "epss_percentile": 0.36824}, "CVE-2012-3690": {"epss_score": 0.00211, "epss_percentile": 0.43685}, "CVE-2012-3691": {"epss_score": 0.00227, "epss_percentile": 0.45432}, "CVE-2012-3692": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3693": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2012-3694": {"epss_score": 0.00277, "epss_percentile": 0.50798}, "CVE-2012-3695": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2012-3696": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2012-3697": {"epss_score": 0.00138, "epss_percentile": 0.34378}, "CVE-2012-3698": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-3699": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3700": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3701": {"epss_score": 0.01664, "epss_percentile": 0.81644}, "CVE-2012-3702": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3703": {"epss_score": 0.01408, "epss_percentile": 0.80063}, "CVE-2012-3704": {"epss_score": 0.01272, "epss_percentile": 0.79079}, "CVE-2012-3705": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3706": {"epss_score": 0.01272, "epss_percentile": 0.79079}, "CVE-2012-3707": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3708": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3709": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3710": {"epss_score": 0.01476, "epss_percentile": 0.80541}, "CVE-2012-3711": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3712": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2012-3713": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2012-3714": {"epss_score": 0.00319, "epss_percentile": 0.54557}, "CVE-2012-3715": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2012-3716": {"epss_score": 0.40626, "epss_percentile": 0.97227}, "CVE-2012-3718": {"epss_score": 0.00061, "epss_percentile": 0.19284}, "CVE-2012-3719": {"epss_score": 0.00447, "epss_percentile": 0.6297}, "CVE-2012-3720": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2012-3721": {"epss_score": 0.00228, "epss_percentile": 0.45531}, "CVE-2012-3722": {"epss_score": 0.02122, "epss_percentile": 0.83683}, "CVE-2012-3723": {"epss_score": 0.00075, "epss_percentile": 0.22916}, "CVE-2012-3724": {"epss_score": 0.00346, "epss_percentile": 0.56638}, "CVE-2012-3725": {"epss_score": 0.00144, "epss_percentile": 0.35268}, "CVE-2012-3726": {"epss_score": 0.01314, "epss_percentile": 0.79397}, "CVE-2012-3727": {"epss_score": 0.01877, "epss_percentile": 0.82665}, "CVE-2012-3728": {"epss_score": 0.00048, "epss_percentile": 0.15047}, "CVE-2012-3729": {"epss_score": 0.00068, "epss_percentile": 0.21414}, "CVE-2012-3730": {"epss_score": 0.00409, "epss_percentile": 0.6073}, "CVE-2012-3731": {"epss_score": 0.00068, "epss_percentile": 0.2136}, "CVE-2012-3732": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2012-3733": {"epss_score": 0.00346, "epss_percentile": 0.56638}, "CVE-2012-3734": {"epss_score": 0.00038, "epss_percentile": 0.1135}, "CVE-2012-3735": {"epss_score": 0.00077, "epss_percentile": 0.234}, "CVE-2012-3736": {"epss_score": 0.00052, "epss_percentile": 0.16667}, "CVE-2012-3737": {"epss_score": 0.00068, "epss_percentile": 0.2136}, "CVE-2012-3738": {"epss_score": 0.00066, "epss_percentile": 0.20881}, "CVE-2012-3739": {"epss_score": 0.00053, "epss_percentile": 0.16986}, "CVE-2012-3740": {"epss_score": 0.00053, "epss_percentile": 0.16986}, "CVE-2012-3741": {"epss_score": 0.00052, "epss_percentile": 0.16372}, "CVE-2012-3742": {"epss_score": 0.00377, "epss_percentile": 0.58698}, "CVE-2012-3743": {"epss_score": 0.00421, "epss_percentile": 0.61516}, "CVE-2012-3744": {"epss_score": 0.00409, "epss_percentile": 0.6073}, "CVE-2012-3745": {"epss_score": 0.00583, "epss_percentile": 0.68346}, "CVE-2012-3746": {"epss_score": 0.00335, "epss_percentile": 0.55814}, "CVE-2012-3747": {"epss_score": 0.01795, "epss_percentile": 0.823}, "CVE-2012-3748": {"epss_score": 0.19165, "epss_percentile": 0.95142}, "CVE-2012-3749": {"epss_score": 0.00498, "epss_percentile": 0.65237}, "CVE-2012-3750": {"epss_score": 0.00073, "epss_percentile": 0.22661}, "CVE-2012-3751": {"epss_score": 0.05303, "epss_percentile": 0.8971}, "CVE-2012-3752": {"epss_score": 0.79074, "epss_percentile": 0.99018}, "CVE-2012-3753": {"epss_score": 0.78056, "epss_percentile": 0.98967}, "CVE-2012-3754": {"epss_score": 0.05303, "epss_percentile": 0.8971}, "CVE-2012-3755": {"epss_score": 0.44525, "epss_percentile": 0.97443}, "CVE-2012-3756": {"epss_score": 0.08336, "epss_percentile": 0.91996}, "CVE-2012-3757": {"epss_score": 0.07138, "epss_percentile": 0.91275}, "CVE-2012-3758": {"epss_score": 0.05677, "epss_percentile": 0.90112}, "CVE-2012-3789": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-3790": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-3791": {"epss_score": 0.01325, "epss_percentile": 0.79475}, "CVE-2012-3792": {"epss_score": 0.09396, "epss_percentile": 0.92531}, "CVE-2012-3793": {"epss_score": 0.07544, "epss_percentile": 0.91528}, "CVE-2012-3794": {"epss_score": 0.20007, "epss_percentile": 0.95274}, "CVE-2012-3795": {"epss_score": 0.20007, "epss_percentile": 0.95274}, "CVE-2012-3796": {"epss_score": 0.24544, "epss_percentile": 0.95931}, "CVE-2012-3797": {"epss_score": 0.49199, "epss_percentile": 0.97673}, "CVE-2012-3798": {"epss_score": 0.00388, "epss_percentile": 0.59341}, "CVE-2012-3799": {"epss_score": 0.00284, "epss_percentile": 0.51451}, "CVE-2012-3800": {"epss_score": 0.00368, "epss_percentile": 0.58219}, "CVE-2012-3802": {"epss_score": 0.00322, "epss_percentile": 0.54815}, "CVE-2012-3805": {"epss_score": 0.00747, "epss_percentile": 0.72566}, "CVE-2012-3806": {"epss_score": 0.02373, "epss_percentile": 0.84534}, "CVE-2012-3807": {"epss_score": 0.3486, "epss_percentile": 0.96875}, "CVE-2012-3808": {"epss_score": 0.25873, "epss_percentile": 0.96088}, "CVE-2012-3809": {"epss_score": 0.25873, "epss_percentile": 0.96088}, "CVE-2012-3810": {"epss_score": 0.25873, "epss_percentile": 0.96088}, "CVE-2012-3811": {"epss_score": 0.77369, "epss_percentile": 0.98933}, "CVE-2012-3812": {"epss_score": 0.07186, "epss_percentile": 0.91307}, "CVE-2012-3814": {"epss_score": 0.08345, "epss_percentile": 0.92002}, "CVE-2012-3815": {"epss_score": 0.80822, "epss_percentile": 0.99108}, "CVE-2012-3816": {"epss_score": 0.13925, "epss_percentile": 0.94094}, "CVE-2012-3817": {"epss_score": 0.08416, "epss_percentile": 0.92039}, "CVE-2012-3818": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2012-3819": {"epss_score": 0.09654, "epss_percentile": 0.92641}, "CVE-2012-3820": {"epss_score": 0.00535, "epss_percentile": 0.66828}, "CVE-2012-3821": {"epss_score": 0.0039, "epss_percentile": 0.59505}, "CVE-2012-3822": {"epss_score": 0.01298, "epss_percentile": 0.79272}, "CVE-2012-3823": {"epss_score": 0.00276, "epss_percentile": 0.50724}, "CVE-2012-3824": {"epss_score": 0.00635, "epss_percentile": 0.69819}, "CVE-2012-3825": {"epss_score": 0.0205, "epss_percentile": 0.83399}, "CVE-2012-3826": {"epss_score": 0.01202, "epss_percentile": 0.78485}, "CVE-2012-3828": {"epss_score": 0.00022, "epss_percentile": 0.04983}, "CVE-2012-3829": {"epss_score": 0.00162, "epss_percentile": 0.37648}, "CVE-2012-3830": {"epss_score": 0.05002, "epss_percentile": 0.89379}, "CVE-2012-3831": {"epss_score": 0.00715, "epss_percentile": 0.71835}, "CVE-2012-3832": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-3833": {"epss_score": 0.00374, "epss_percentile": 0.5858}, "CVE-2012-3834": {"epss_score": 0.00656, "epss_percentile": 0.70454}, "CVE-2012-3835": {"epss_score": 0.07316, "epss_percentile": 0.91404}, "CVE-2012-3836": {"epss_score": 0.03547, "epss_percentile": 0.87332}, "CVE-2012-3837": {"epss_score": 0.03547, "epss_percentile": 0.87332}, "CVE-2012-3838": {"epss_score": 0.06721, "epss_percentile": 0.90967}, "CVE-2012-3839": {"epss_score": 0.01191, "epss_percentile": 0.78394}, "CVE-2012-3840": {"epss_score": 0.02704, "epss_percentile": 0.85462}, "CVE-2012-3841": {"epss_score": 0.01067, "epss_percentile": 0.77224}, "CVE-2012-3842": {"epss_score": 0.0024, "epss_percentile": 0.47208}, "CVE-2012-3843": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-3844": {"epss_score": 0.00249, "epss_percentile": 0.48037}, "CVE-2012-3845": {"epss_score": 0.12179, "epss_percentile": 0.93593}, "CVE-2012-3846": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-3847": {"epss_score": 0.00335, "epss_percentile": 0.55833}, "CVE-2012-3848": {"epss_score": 0.00566, "epss_percentile": 0.67816}, "CVE-2012-3859": {"epss_score": 0.1275, "epss_percentile": 0.93764}, "CVE-2012-3863": {"epss_score": 0.07186, "epss_percentile": 0.91307}, "CVE-2012-3864": {"epss_score": 0.00314, "epss_percentile": 0.5414}, "CVE-2012-3865": {"epss_score": 0.0215, "epss_percentile": 0.8378}, "CVE-2012-3866": {"epss_score": 0.0005, "epss_percentile": 0.15956}, "CVE-2012-3867": {"epss_score": 0.01418, "epss_percentile": 0.80156}, "CVE-2012-3868": {"epss_score": 0.02175, "epss_percentile": 0.83882}, "CVE-2012-3869": {"epss_score": 0.00446, "epss_percentile": 0.62934}, "CVE-2012-3870": {"epss_score": 0.00224, "epss_percentile": 0.45003}, "CVE-2012-3871": {"epss_score": 0.00224, "epss_percentile": 0.45003}, "CVE-2012-3872": {"epss_score": 0.00754, "epss_percentile": 0.72695}, "CVE-2012-3873": {"epss_score": 0.00938, "epss_percentile": 0.75714}, "CVE-2012-3881": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2012-3884": {"epss_score": 0.00314, "epss_percentile": 0.54148}, "CVE-2012-3885": {"epss_score": 0.0043, "epss_percentile": 0.62026}, "CVE-2012-3886": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-3887": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-3888": {"epss_score": 0.00167, "epss_percentile": 0.38347}, "CVE-2012-3889": {"epss_score": 0.00666, "epss_percentile": 0.70694}, "CVE-2012-3890": {"epss_score": 0.00666, "epss_percentile": 0.70694}, "CVE-2012-3893": {"epss_score": 0.0034, "epss_percentile": 0.56224}, "CVE-2012-3895": {"epss_score": 0.0034, "epss_percentile": 0.56224}, "CVE-2012-3899": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-3901": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-3908": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2012-3913": {"epss_score": 0.00403, "epss_percentile": 0.60378}, "CVE-2012-3915": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-3918": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2012-3919": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-3923": {"epss_score": 0.00377, "epss_percentile": 0.5872}, "CVE-2012-3924": {"epss_score": 0.00377, "epss_percentile": 0.5872}, "CVE-2012-3935": {"epss_score": 0.00798, "epss_percentile": 0.73509}, "CVE-2012-3936": {"epss_score": 0.06247, "epss_percentile": 0.90605}, "CVE-2012-3937": {"epss_score": 0.03713, "epss_percentile": 0.8761}, "CVE-2012-3938": {"epss_score": 0.06247, "epss_percentile": 0.90605}, "CVE-2012-3939": {"epss_score": 0.02107, "epss_percentile": 0.83633}, "CVE-2012-3940": {"epss_score": 0.03713, "epss_percentile": 0.8761}, "CVE-2012-3941": {"epss_score": 0.03713, "epss_percentile": 0.8761}, "CVE-2012-3946": {"epss_score": 0.00213, "epss_percentile": 0.43849}, "CVE-2012-3949": {"epss_score": 0.00932, "epss_percentile": 0.75627}, "CVE-2012-3950": {"epss_score": 0.00662, "epss_percentile": 0.70599}, "CVE-2012-3951": {"epss_score": 0.79501, "epss_percentile": 0.99042}, "CVE-2012-3952": {"epss_score": 0.0661, "epss_percentile": 0.90885}, "CVE-2012-3953": {"epss_score": 0.00605, "epss_percentile": 0.68992}, "CVE-2012-3954": {"epss_score": 0.06481, "epss_percentile": 0.90788}, "CVE-2012-3955": {"epss_score": 0.12095, "epss_percentile": 0.93564}, "CVE-2012-3956": {"epss_score": 0.02314, "epss_percentile": 0.84353}, "CVE-2012-3957": {"epss_score": 0.02961, "epss_percentile": 0.86072}, "CVE-2012-3958": {"epss_score": 0.02127, "epss_percentile": 0.83697}, "CVE-2012-3959": {"epss_score": 0.03932, "epss_percentile": 0.87976}, "CVE-2012-3960": {"epss_score": 0.02314, "epss_percentile": 0.84353}, "CVE-2012-3961": {"epss_score": 0.02093, "epss_percentile": 0.83576}, "CVE-2012-3962": {"epss_score": 0.04219, "epss_percentile": 0.88409}, "CVE-2012-3963": {"epss_score": 0.02314, "epss_percentile": 0.84353}, "CVE-2012-3964": {"epss_score": 0.02127, "epss_percentile": 0.83697}, "CVE-2012-3965": {"epss_score": 0.01126, "epss_percentile": 0.77818}, "CVE-2012-3966": {"epss_score": 0.03664, "epss_percentile": 0.87531}, "CVE-2012-3967": {"epss_score": 0.00593, "epss_percentile": 0.6863}, "CVE-2012-3968": {"epss_score": 0.01852, "epss_percentile": 0.82545}, "CVE-2012-3969": {"epss_score": 0.05074, "epss_percentile": 0.89467}, "CVE-2012-3970": {"epss_score": 0.02745, "epss_percentile": 0.85568}, "CVE-2012-3971": {"epss_score": 0.03136, "epss_percentile": 0.86481}, "CVE-2012-3972": {"epss_score": 0.04549, "epss_percentile": 0.88837}, "CVE-2012-3973": {"epss_score": 0.03046, "epss_percentile": 0.86283}, "CVE-2012-3974": {"epss_score": 0.00119, "epss_percentile": 0.3167}, "CVE-2012-3975": {"epss_score": 0.00923, "epss_percentile": 0.75506}, "CVE-2012-3976": {"epss_score": 0.00776, "epss_percentile": 0.73096}, "CVE-2012-3978": {"epss_score": 0.01292, "epss_percentile": 0.79234}, "CVE-2012-3979": {"epss_score": 0.01477, "epss_percentile": 0.80542}, "CVE-2012-3980": {"epss_score": 0.02199, "epss_percentile": 0.8397}, "CVE-2012-3981": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2012-3982": {"epss_score": 0.01275, "epss_percentile": 0.79103}, "CVE-2012-3983": {"epss_score": 0.00771, "epss_percentile": 0.73022}, "CVE-2012-3984": {"epss_score": 0.01951, "epss_percentile": 0.83015}, "CVE-2012-3985": {"epss_score": 0.00924, "epss_percentile": 0.75524}, "CVE-2012-3986": {"epss_score": 0.0084, "epss_percentile": 0.74201}, "CVE-2012-3987": {"epss_score": 0.0023, "epss_percentile": 0.45736}, "CVE-2012-3988": {"epss_score": 0.0399, "epss_percentile": 0.8807}, "CVE-2012-3989": {"epss_score": 0.00854, "epss_percentile": 0.74451}, "CVE-2012-3990": {"epss_score": 0.06071, "epss_percentile": 0.90452}, "CVE-2012-3991": {"epss_score": 0.01419, "epss_percentile": 0.8016}, "CVE-2012-3992": {"epss_score": 0.01138, "epss_percentile": 0.7793}, "CVE-2012-3993": {"epss_score": 0.8084, "epss_percentile": 0.99109}, "CVE-2012-3994": {"epss_score": 0.00927, "epss_percentile": 0.7556}, "CVE-2012-3995": {"epss_score": 0.02016, "epss_percentile": 0.83274}, "CVE-2012-3996": {"epss_score": 0.17231, "epss_percentile": 0.94803}, "CVE-2012-3997": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2012-3998": {"epss_score": 0.00362, "epss_percentile": 0.57771}, "CVE-2012-3999": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-4000": {"epss_score": 0.04195, "epss_percentile": 0.88381}, "CVE-2012-4001": {"epss_score": 0.00308, "epss_percentile": 0.5363}, "CVE-2012-4002": {"epss_score": 0.002, "epss_percentile": 0.42238}, "CVE-2012-4003": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2012-4004": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-4005": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-4006": {"epss_score": 0.00218, "epss_percentile": 0.44355}, "CVE-2012-4007": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-4008": {"epss_score": 0.00638, "epss_percentile": 0.69912}, "CVE-2012-4009": {"epss_score": 0.00476, "epss_percentile": 0.64281}, "CVE-2012-4010": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2012-4011": {"epss_score": 0.0212, "epss_percentile": 0.83676}, "CVE-2012-4012": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2012-4013": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2012-4014": {"epss_score": 0.00453, "epss_percentile": 0.63206}, "CVE-2012-4015": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-4016": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-4017": {"epss_score": 0.00262, "epss_percentile": 0.49381}, "CVE-2012-4018": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-4019": {"epss_score": 0.00367, "epss_percentile": 0.58137}, "CVE-2012-4020": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2012-4021": {"epss_score": 0.00196, "epss_percentile": 0.41789}, "CVE-2012-4022": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2012-4023": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2012-4024": {"epss_score": 0.02288, "epss_percentile": 0.8427}, "CVE-2012-4025": {"epss_score": 0.02345, "epss_percentile": 0.84448}, "CVE-2012-4026": {"epss_score": 0.02085, "epss_percentile": 0.83547}, "CVE-2012-4027": {"epss_score": 0.00173, "epss_percentile": 0.39117}, "CVE-2012-4028": {"epss_score": 0.00119, "epss_percentile": 0.31603}, "CVE-2012-4029": {"epss_score": 0.0053, "epss_percentile": 0.66631}, "CVE-2012-4030": {"epss_score": 0.00532, "epss_percentile": 0.66698}, "CVE-2012-4031": {"epss_score": 0.75586, "epss_percentile": 0.98856}, "CVE-2012-4032": {"epss_score": 0.13504, "epss_percentile": 0.93983}, "CVE-2012-4033": {"epss_score": 0.01399, "epss_percentile": 0.79994}, "CVE-2012-4034": {"epss_score": 0.00311, "epss_percentile": 0.53809}, "CVE-2012-4035": {"epss_score": 0.05224, "epss_percentile": 0.89631}, "CVE-2012-4036": {"epss_score": 0.05206, "epss_percentile": 0.89611}, "CVE-2012-4037": {"epss_score": 0.00545, "epss_percentile": 0.67158}, "CVE-2012-4043": {"epss_score": 0.00199, "epss_percentile": 0.4214}, "CVE-2012-4045": {"epss_score": 0.03564, "epss_percentile": 0.87359}, "CVE-2012-4046": {"epss_score": 0.00053, "epss_percentile": 0.16683}, "CVE-2012-4048": {"epss_score": 0.00209, "epss_percentile": 0.43423}, "CVE-2012-4049": {"epss_score": 0.00575, "epss_percentile": 0.6812}, "CVE-2012-4050": {"epss_score": 0.00162, "epss_percentile": 0.37643}, "CVE-2012-4051": {"epss_score": 0.01652, "epss_percentile": 0.81573}, "CVE-2012-4052": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-4053": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2012-4054": {"epss_score": 0.01035, "epss_percentile": 0.76895}, "CVE-2012-4055": {"epss_score": 0.00438, "epss_percentile": 0.62561}, "CVE-2012-4056": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2012-4057": {"epss_score": 0.33144, "epss_percentile": 0.96749}, "CVE-2012-4058": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-4059": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2012-4060": {"epss_score": 0.00926, "epss_percentile": 0.75555}, "CVE-2012-4061": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2012-4063": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-4064": {"epss_score": 0.0036, "epss_percentile": 0.57686}, "CVE-2012-4065": {"epss_score": 0.00135, "epss_percentile": 0.33938}, "CVE-2012-4066": {"epss_score": 0.00196, "epss_percentile": 0.41754}, "CVE-2012-4067": {"epss_score": 0.00386, "epss_percentile": 0.59238}, "CVE-2012-4068": {"epss_score": 0.05287, "epss_percentile": 0.89694}, "CVE-2012-4069": {"epss_score": 0.00371, "epss_percentile": 0.58366}, "CVE-2012-4070": {"epss_score": 0.00606, "epss_percentile": 0.69007}, "CVE-2012-4071": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-4072": {"epss_score": 0.00181, "epss_percentile": 0.40088}, "CVE-2012-4073": {"epss_score": 0.00176, "epss_percentile": 0.39394}, "CVE-2012-4074": {"epss_score": 0.00327, "epss_percentile": 0.55109}, "CVE-2012-4075": {"epss_score": 0.00219, "epss_percentile": 0.44476}, "CVE-2012-4076": {"epss_score": 0.00123, "epss_percentile": 0.32312}, "CVE-2012-4077": {"epss_score": 0.00123, "epss_percentile": 0.32312}, "CVE-2012-4078": {"epss_score": 0.0092, "epss_percentile": 0.75464}, "CVE-2012-4079": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-4081": {"epss_score": 0.00121, "epss_percentile": 0.31814}, "CVE-2012-4082": {"epss_score": 0.00127, "epss_percentile": 0.32936}, "CVE-2012-4083": {"epss_score": 0.00685, "epss_percentile": 0.7115}, "CVE-2012-4084": {"epss_score": 0.00152, "epss_percentile": 0.36404}, "CVE-2012-4085": {"epss_score": 0.00363, "epss_percentile": 0.57896}, "CVE-2012-4086": {"epss_score": 0.00637, "epss_percentile": 0.69892}, "CVE-2012-4087": {"epss_score": 0.00514, "epss_percentile": 0.65946}, "CVE-2012-4088": {"epss_score": 0.00337, "epss_percentile": 0.5605}, "CVE-2012-4089": {"epss_score": 0.00127, "epss_percentile": 0.32936}, "CVE-2012-4090": {"epss_score": 0.00505, "epss_percentile": 0.65584}, "CVE-2012-4091": {"epss_score": 0.01141, "epss_percentile": 0.77955}, "CVE-2012-4092": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2012-4093": {"epss_score": 0.00121, "epss_percentile": 0.31814}, "CVE-2012-4094": {"epss_score": 0.00843, "epss_percentile": 0.74256}, "CVE-2012-4095": {"epss_score": 0.0006, "epss_percentile": 0.18952}, "CVE-2012-4096": {"epss_score": 0.0006, "epss_percentile": 0.18952}, "CVE-2012-4097": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2012-4098": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2012-4099": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2012-4102": {"epss_score": 0.0008, "epss_percentile": 0.24167}, "CVE-2012-4103": {"epss_score": 0.00084, "epss_percentile": 0.24859}, "CVE-2012-4104": {"epss_score": 0.00058, "epss_percentile": 0.18391}, "CVE-2012-4105": {"epss_score": 0.0013, "epss_percentile": 0.33295}, "CVE-2012-4106": {"epss_score": 0.00112, "epss_percentile": 0.30513}, "CVE-2012-4107": {"epss_score": 0.00067, "epss_percentile": 0.21171}, "CVE-2012-4108": {"epss_score": 0.00301, "epss_percentile": 0.5305}, "CVE-2012-4109": {"epss_score": 0.0008, "epss_percentile": 0.24167}, "CVE-2012-4110": {"epss_score": 0.0008, "epss_percentile": 0.24167}, "CVE-2012-4111": {"epss_score": 0.0008, "epss_percentile": 0.24167}, "CVE-2012-4112": {"epss_score": 0.00083, "epss_percentile": 0.2482}, "CVE-2012-4113": {"epss_score": 0.00061, "epss_percentile": 0.1933}, "CVE-2012-4114": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2012-4115": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2012-4116": {"epss_score": 0.00265, "epss_percentile": 0.4983}, "CVE-2012-4117": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2012-4121": {"epss_score": 0.0008, "epss_percentile": 0.24167}, "CVE-2012-4122": {"epss_score": 0.00123, "epss_percentile": 0.32302}, "CVE-2012-4131": {"epss_score": 0.00025, "epss_percentile": 0.06263}, "CVE-2012-4135": {"epss_score": 0.00027, "epss_percentile": 0.06885}, "CVE-2012-4136": {"epss_score": 0.0043, "epss_percentile": 0.62018}, "CVE-2012-4141": {"epss_score": 0.00229, "epss_percentile": 0.45637}, "CVE-2012-4142": {"epss_score": 0.00418, "epss_percentile": 0.61346}, "CVE-2012-4143": {"epss_score": 0.00667, "epss_percentile": 0.70721}, "CVE-2012-4144": {"epss_score": 0.00403, "epss_percentile": 0.60387}, "CVE-2012-4145": {"epss_score": 0.00406, "epss_percentile": 0.60562}, "CVE-2012-4146": {"epss_score": 0.00461, "epss_percentile": 0.63543}, "CVE-2012-4147": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-4148": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-4149": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-4150": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-4151": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-4152": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-4153": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-4154": {"epss_score": 0.06549, "epss_percentile": 0.90842}, "CVE-2012-4155": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-4156": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-4157": {"epss_score": 0.05846, "epss_percentile": 0.90257}, "CVE-2012-4158": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-4159": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-4160": {"epss_score": 0.19383, "epss_percentile": 0.95175}, "CVE-2012-4161": {"epss_score": 0.05018, "epss_percentile": 0.89396}, "CVE-2012-4162": {"epss_score": 0.05018, "epss_percentile": 0.89396}, "CVE-2012-4163": {"epss_score": 0.07934, "epss_percentile": 0.91774}, "CVE-2012-4164": {"epss_score": 0.07934, "epss_percentile": 0.91774}, "CVE-2012-4165": {"epss_score": 0.07934, "epss_percentile": 0.91774}, "CVE-2012-4167": {"epss_score": 0.12998, "epss_percentile": 0.93839}, "CVE-2012-4168": {"epss_score": 0.00786, "epss_percentile": 0.733}, "CVE-2012-4170": {"epss_score": 0.5463, "epss_percentile": 0.97936}, "CVE-2012-4171": {"epss_score": 0.01747, "epss_percentile": 0.82075}, "CVE-2012-4172": {"epss_score": 0.05244, "epss_percentile": 0.89656}, "CVE-2012-4173": {"epss_score": 0.05244, "epss_percentile": 0.89656}, "CVE-2012-4174": {"epss_score": 0.05244, "epss_percentile": 0.89656}, "CVE-2012-4175": {"epss_score": 0.05244, "epss_percentile": 0.89656}, "CVE-2012-4176": {"epss_score": 0.05081, "epss_percentile": 0.89472}, "CVE-2012-4177": {"epss_score": 0.78817, "epss_percentile": 0.99005}, "CVE-2012-4178": {"epss_score": 0.00736, "epss_percentile": 0.72316}, "CVE-2012-4179": {"epss_score": 0.06071, "epss_percentile": 0.90452}, "CVE-2012-4180": {"epss_score": 0.09485, "epss_percentile": 0.92568}, "CVE-2012-4181": {"epss_score": 0.03504, "epss_percentile": 0.87254}, "CVE-2012-4182": {"epss_score": 0.04752, "epss_percentile": 0.89105}, "CVE-2012-4183": {"epss_score": 0.02721, "epss_percentile": 0.85519}, "CVE-2012-4184": {"epss_score": 0.01102, "epss_percentile": 0.77578}, "CVE-2012-4185": {"epss_score": 0.05225, "epss_percentile": 0.89633}, "CVE-2012-4186": {"epss_score": 0.55611, "epss_percentile": 0.97987}, "CVE-2012-4187": {"epss_score": 0.24843, "epss_percentile": 0.95959}, "CVE-2012-4188": {"epss_score": 0.55611, "epss_percentile": 0.97987}, "CVE-2012-4189": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-4190": {"epss_score": 0.08531, "epss_percentile": 0.92106}, "CVE-2012-4191": {"epss_score": 0.01678, "epss_percentile": 0.81719}, "CVE-2012-4192": {"epss_score": 0.00868, "epss_percentile": 0.74665}, "CVE-2012-4193": {"epss_score": 0.01406, "epss_percentile": 0.80051}, "CVE-2012-4194": {"epss_score": 0.01358, "epss_percentile": 0.79727}, "CVE-2012-4195": {"epss_score": 0.00962, "epss_percentile": 0.75985}, "CVE-2012-4196": {"epss_score": 0.00964, "epss_percentile": 0.76036}, "CVE-2012-4197": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-4198": {"epss_score": 0.00183, "epss_percentile": 0.40335}, "CVE-2012-4199": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-4201": {"epss_score": 0.02609, "epss_percentile": 0.85233}, "CVE-2012-4202": {"epss_score": 0.06753, "epss_percentile": 0.91004}, "CVE-2012-4203": {"epss_score": 0.02473, "epss_percentile": 0.8485}, "CVE-2012-4204": {"epss_score": 0.03013, "epss_percentile": 0.86203}, "CVE-2012-4205": {"epss_score": 0.00875, "epss_percentile": 0.74772}, "CVE-2012-4206": {"epss_score": 0.00174, "epss_percentile": 0.39137}, "CVE-2012-4207": {"epss_score": 0.01708, "epss_percentile": 0.81864}, "CVE-2012-4208": {"epss_score": 0.00367, "epss_percentile": 0.58098}, "CVE-2012-4209": {"epss_score": 0.02185, "epss_percentile": 0.83918}, "CVE-2012-4210": {"epss_score": 0.04052, "epss_percentile": 0.88177}, "CVE-2012-4212": {"epss_score": 0.02155, "epss_percentile": 0.83807}, "CVE-2012-4213": {"epss_score": 0.02868, "epss_percentile": 0.85867}, "CVE-2012-4214": {"epss_score": 0.04317, "epss_percentile": 0.88539}, "CVE-2012-4215": {"epss_score": 0.04317, "epss_percentile": 0.88539}, "CVE-2012-4216": {"epss_score": 0.0639, "epss_percentile": 0.90717}, "CVE-2012-4217": {"epss_score": 0.02868, "epss_percentile": 0.85867}, "CVE-2012-4218": {"epss_score": 0.02155, "epss_percentile": 0.83807}, "CVE-2012-4219": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-4220": {"epss_score": 0.17842, "epss_percentile": 0.94915}, "CVE-2012-4221": {"epss_score": 0.00592, "epss_percentile": 0.68625}, "CVE-2012-4222": {"epss_score": 0.00219, "epss_percentile": 0.44524}, "CVE-2012-4225": {"epss_score": 0.00048, "epss_percentile": 0.15131}, "CVE-2012-4226": {"epss_score": 0.00233, "epss_percentile": 0.46}, "CVE-2012-4230": {"epss_score": 0.00621, "epss_percentile": 0.69485}, "CVE-2012-4231": {"epss_score": 0.03159, "epss_percentile": 0.86521}, "CVE-2012-4232": {"epss_score": 0.00556, "epss_percentile": 0.67533}, "CVE-2012-4233": {"epss_score": 0.02511, "epss_percentile": 0.84952}, "CVE-2012-4234": {"epss_score": 0.08831, "epss_percentile": 0.92273}, "CVE-2012-4235": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-4236": {"epss_score": 0.02704, "epss_percentile": 0.85462}, "CVE-2012-4237": {"epss_score": 0.00416, "epss_percentile": 0.6116}, "CVE-2012-4238": {"epss_score": 0.00181, "epss_percentile": 0.40073}, "CVE-2012-4240": {"epss_score": 0.02183, "epss_percentile": 0.83911}, "CVE-2012-4241": {"epss_score": 0.00496, "epss_percentile": 0.65165}, "CVE-2012-4242": {"epss_score": 0.08022, "epss_percentile": 0.91835}, "CVE-2012-4244": {"epss_score": 0.68505, "epss_percentile": 0.98551}, "CVE-2012-4245": {"epss_score": 0.01077, "epss_percentile": 0.77333}, "CVE-2012-4246": {"epss_score": 0.0567, "epss_percentile": 0.90103}, "CVE-2012-4247": {"epss_score": 0.04779, "epss_percentile": 0.89134}, "CVE-2012-4248": {"epss_score": 0.02311, "epss_percentile": 0.84341}, "CVE-2012-4249": {"epss_score": 0.02901, "epss_percentile": 0.85954}, "CVE-2012-4250": {"epss_score": 0.34713, "epss_percentile": 0.96869}, "CVE-2012-4251": {"epss_score": 0.027, "epss_percentile": 0.85451}, "CVE-2012-4252": {"epss_score": 0.00227, "epss_percentile": 0.45458}, "CVE-2012-4253": {"epss_score": 0.62719, "epss_percentile": 0.98305}, "CVE-2012-4254": {"epss_score": 0.06598, "epss_percentile": 0.90876}, "CVE-2012-4255": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-4256": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-4257": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-4258": {"epss_score": 0.00523, "epss_percentile": 0.66312}, "CVE-2012-4259": {"epss_score": 0.09462, "epss_percentile": 0.92558}, "CVE-2012-4260": {"epss_score": 0.02139, "epss_percentile": 0.83744}, "CVE-2012-4261": {"epss_score": 0.00402, "epss_percentile": 0.60298}, "CVE-2012-4262": {"epss_score": 0.09297, "epss_percentile": 0.92489}, "CVE-2012-4263": {"epss_score": 0.0028, "epss_percentile": 0.51015}, "CVE-2012-4264": {"epss_score": 0.00239, "epss_percentile": 0.46871}, "CVE-2012-4265": {"epss_score": 0.00472, "epss_percentile": 0.6406}, "CVE-2012-4266": {"epss_score": 0.02926, "epss_percentile": 0.86006}, "CVE-2012-4267": {"epss_score": 0.04325, "epss_percentile": 0.88552}, "CVE-2012-4268": {"epss_score": 0.00233, "epss_percentile": 0.46}, "CVE-2012-4269": {"epss_score": 0.01582, "epss_percentile": 0.81142}, "CVE-2012-4270": {"epss_score": 0.00179, "epss_percentile": 0.39815}, "CVE-2012-4271": {"epss_score": 0.00198, "epss_percentile": 0.42023}, "CVE-2012-4272": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2012-4273": {"epss_score": 0.01303, "epss_percentile": 0.7931}, "CVE-2012-4274": {"epss_score": 0.07112, "epss_percentile": 0.91259}, "CVE-2012-4275": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2012-4276": {"epss_score": 0.00314, "epss_percentile": 0.54147}, "CVE-2012-4277": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-4278": {"epss_score": 0.03305, "epss_percentile": 0.86873}, "CVE-2012-4279": {"epss_score": 0.00699, "epss_percentile": 0.71432}, "CVE-2012-4280": {"epss_score": 0.00259, "epss_percentile": 0.49078}, "CVE-2012-4281": {"epss_score": 0.0332, "epss_percentile": 0.86908}, "CVE-2012-4282": {"epss_score": 0.0054, "epss_percentile": 0.6699}, "CVE-2012-4283": {"epss_score": 0.00403, "epss_percentile": 0.60361}, "CVE-2012-4284": {"epss_score": 0.49444, "epss_percentile": 0.97687}, "CVE-2012-4285": {"epss_score": 0.02439, "epss_percentile": 0.84749}, "CVE-2012-4286": {"epss_score": 0.02186, "epss_percentile": 0.83921}, "CVE-2012-4287": {"epss_score": 0.02866, "epss_percentile": 0.85862}, "CVE-2012-4288": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2012-4289": {"epss_score": 0.01104, "epss_percentile": 0.776}, "CVE-2012-4290": {"epss_score": 0.01765, "epss_percentile": 0.82163}, "CVE-2012-4291": {"epss_score": 0.01765, "epss_percentile": 0.82163}, "CVE-2012-4292": {"epss_score": 0.0113, "epss_percentile": 0.77842}, "CVE-2012-4293": {"epss_score": 0.00971, "epss_percentile": 0.76126}, "CVE-2012-4294": {"epss_score": 0.03416, "epss_percentile": 0.87092}, "CVE-2012-4295": {"epss_score": 0.01081, "epss_percentile": 0.77374}, "CVE-2012-4296": {"epss_score": 0.01461, "epss_percentile": 0.80423}, "CVE-2012-4297": {"epss_score": 0.08501, "epss_percentile": 0.92085}, "CVE-2012-4298": {"epss_score": 0.00919, "epss_percentile": 0.75451}, "CVE-2012-4301": {"epss_score": 0.04961, "epss_percentile": 0.89335}, "CVE-2012-4303": {"epss_score": 0.00143, "epss_percentile": 0.35149}, "CVE-2012-4305": {"epss_score": 0.05045, "epss_percentile": 0.89431}, "CVE-2012-4324": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2012-4325": {"epss_score": 0.00172, "epss_percentile": 0.38925}, "CVE-2012-4326": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2012-4327": {"epss_score": 0.00864, "epss_percentile": 0.74608}, "CVE-2012-4328": {"epss_score": 0.0147, "epss_percentile": 0.80493}, "CVE-2012-4329": {"epss_score": 0.53654, "epss_percentile": 0.97888}, "CVE-2012-4330": {"epss_score": 0.52168, "epss_percentile": 0.97812}, "CVE-2012-4331": {"epss_score": 0.00434, "epss_percentile": 0.62316}, "CVE-2012-4332": {"epss_score": 0.00396, "epss_percentile": 0.59922}, "CVE-2012-4333": {"epss_score": 0.69428, "epss_percentile": 0.98586}, "CVE-2012-4334": {"epss_score": 0.35693, "epss_percentile": 0.96927}, "CVE-2012-4335": {"epss_score": 0.15245, "epss_percentile": 0.94391}, "CVE-2012-4336": {"epss_score": 0.00633, "epss_percentile": 0.69756}, "CVE-2012-4337": {"epss_score": 0.00543, "epss_percentile": 0.67096}, "CVE-2012-4340": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-4341": {"epss_score": 0.17331, "epss_percentile": 0.94824}, "CVE-2012-4342": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-4343": {"epss_score": 0.00334, "epss_percentile": 0.55711}, "CVE-2012-4344": {"epss_score": 0.09158, "epss_percentile": 0.92425}, "CVE-2012-4345": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2012-4347": {"epss_score": 0.69707, "epss_percentile": 0.986}, "CVE-2012-4348": {"epss_score": 0.00719, "epss_percentile": 0.71941}, "CVE-2012-4349": {"epss_score": 0.00073, "epss_percentile": 0.22481}, "CVE-2012-4350": {"epss_score": 0.00073, "epss_percentile": 0.22481}, "CVE-2012-4351": {"epss_score": 0.00118, "epss_percentile": 0.31433}, "CVE-2012-4352": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2012-4353": {"epss_score": 0.14776, "epss_percentile": 0.94282}, "CVE-2012-4354": {"epss_score": 0.30755, "epss_percentile": 0.96566}, "CVE-2012-4355": {"epss_score": 0.30755, "epss_percentile": 0.96566}, "CVE-2012-4356": {"epss_score": 0.66302, "epss_percentile": 0.98459}, "CVE-2012-4357": {"epss_score": 0.23452, "epss_percentile": 0.95778}, "CVE-2012-4358": {"epss_score": 0.01677, "epss_percentile": 0.81715}, "CVE-2012-4359": {"epss_score": 0.01677, "epss_percentile": 0.81715}, "CVE-2012-4360": {"epss_score": 0.0049, "epss_percentile": 0.64933}, "CVE-2012-4361": {"epss_score": 0.4475, "epss_percentile": 0.97451}, "CVE-2012-4362": {"epss_score": 0.24105, "epss_percentile": 0.9587}, "CVE-2012-4363": {"epss_score": 0.13477, "epss_percentile": 0.93976}, "CVE-2012-4366": {"epss_score": 0.1327, "epss_percentile": 0.93918}, "CVE-2012-4377": {"epss_score": 0.00998, "epss_percentile": 0.76469}, "CVE-2012-4378": {"epss_score": 0.00507, "epss_percentile": 0.65673}, "CVE-2012-4379": {"epss_score": 0.00429, "epss_percentile": 0.61991}, "CVE-2012-4380": {"epss_score": 0.00552, "epss_percentile": 0.67388}, "CVE-2012-4381": {"epss_score": 0.03103, "epss_percentile": 0.86414}, "CVE-2012-4382": {"epss_score": 0.00288, "epss_percentile": 0.51889}, "CVE-2012-4383": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2012-4384": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2012-4385": {"epss_score": 0.00226, "epss_percentile": 0.45281}, "CVE-2012-4386": {"epss_score": 0.03235, "epss_percentile": 0.86703}, "CVE-2012-4387": {"epss_score": 0.12943, "epss_percentile": 0.93824}, "CVE-2012-4388": {"epss_score": 0.01043, "epss_percentile": 0.76996}, "CVE-2012-4389": {"epss_score": 0.01745, "epss_percentile": 0.8207}, "CVE-2012-4390": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2012-4391": {"epss_score": 0.00126, "epss_percentile": 0.32707}, "CVE-2012-4392": {"epss_score": 0.0034, "epss_percentile": 0.56214}, "CVE-2012-4393": {"epss_score": 0.00159, "epss_percentile": 0.37362}, "CVE-2012-4394": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-4395": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-4396": {"epss_score": 0.0076, "epss_percentile": 0.72813}, "CVE-2012-4397": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2012-4398": {"epss_score": 0.0009, "epss_percentile": 0.26056}, "CVE-2012-4399": {"epss_score": 0.24917, "epss_percentile": 0.95965}, "CVE-2012-4400": {"epss_score": 0.00152, "epss_percentile": 0.36431}, "CVE-2012-4401": {"epss_score": 0.00151, "epss_percentile": 0.36325}, "CVE-2012-4402": {"epss_score": 0.00178, "epss_percentile": 0.3967}, "CVE-2012-4403": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-4404": {"epss_score": 0.0099, "epss_percentile": 0.76379}, "CVE-2012-4405": {"epss_score": 0.3537, "epss_percentile": 0.96903}, "CVE-2012-4406": {"epss_score": 0.04125, "epss_percentile": 0.88289}, "CVE-2012-4407": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-4408": {"epss_score": 0.00171, "epss_percentile": 0.38872}, "CVE-2012-4409": {"epss_score": 0.58743, "epss_percentile": 0.98135}, "CVE-2012-4411": {"epss_score": 0.00085, "epss_percentile": 0.25043}, "CVE-2012-4412": {"epss_score": 0.18703, "epss_percentile": 0.95056}, "CVE-2012-4413": {"epss_score": 0.00428, "epss_percentile": 0.61938}, "CVE-2012-4414": {"epss_score": 0.00441, "epss_percentile": 0.62692}, "CVE-2012-4415": {"epss_score": 0.38643, "epss_percentile": 0.97111}, "CVE-2012-4416": {"epss_score": 0.02727, "epss_percentile": 0.8553}, "CVE-2012-4417": {"epss_score": 0.0015, "epss_percentile": 0.36121}, "CVE-2012-4418": {"epss_score": 0.00406, "epss_percentile": 0.60527}, "CVE-2012-4419": {"epss_score": 0.01621, "epss_percentile": 0.81395}, "CVE-2012-4420": {"epss_score": 0.01067, "epss_percentile": 0.77234}, "CVE-2012-4421": {"epss_score": 0.00204, "epss_percentile": 0.42661}, "CVE-2012-4422": {"epss_score": 0.0024, "epss_percentile": 0.47222}, "CVE-2012-4423": {"epss_score": 0.02833, "epss_percentile": 0.85779}, "CVE-2012-4424": {"epss_score": 0.00608, "epss_percentile": 0.69081}, "CVE-2012-4425": {"epss_score": 0.00517, "epss_percentile": 0.66075}, "CVE-2012-4426": {"epss_score": 0.14864, "epss_percentile": 0.94304}, "CVE-2012-4427": {"epss_score": 0.01026, "epss_percentile": 0.768}, "CVE-2012-4428": {"epss_score": 0.33319, "epss_percentile": 0.96763}, "CVE-2012-4429": {"epss_score": 0.00608, "epss_percentile": 0.69065}, "CVE-2012-4430": {"epss_score": 0.00607, "epss_percentile": 0.69042}, "CVE-2012-4431": {"epss_score": 0.09824, "epss_percentile": 0.92719}, "CVE-2012-4432": {"epss_score": 0.03636, "epss_percentile": 0.87481}, "CVE-2012-4433": {"epss_score": 0.12268, "epss_percentile": 0.93617}, "CVE-2012-4434": {"epss_score": 0.05489, "epss_percentile": 0.89929}, "CVE-2012-4435": {"epss_score": 0.01251, "epss_percentile": 0.78897}, "CVE-2012-4436": {"epss_score": 0.0018, "epss_percentile": 0.39866}, "CVE-2012-4437": {"epss_score": 0.0057, "epss_percentile": 0.67938}, "CVE-2012-4438": {"epss_score": 0.01121, "epss_percentile": 0.77772}, "CVE-2012-4439": {"epss_score": 0.00659, "epss_percentile": 0.70514}, "CVE-2012-4440": {"epss_score": 0.01757, "epss_percentile": 0.82135}, "CVE-2012-4441": {"epss_score": 0.01757, "epss_percentile": 0.82135}, "CVE-2012-4442": {"epss_score": 0.00062, "epss_percentile": 0.19565}, "CVE-2012-4443": {"epss_score": 0.00054, "epss_percentile": 0.17182}, "CVE-2012-4444": {"epss_score": 0.01262, "epss_percentile": 0.78978}, "CVE-2012-4445": {"epss_score": 0.05318, "epss_percentile": 0.89725}, "CVE-2012-4446": {"epss_score": 0.00233, "epss_percentile": 0.45982}, "CVE-2012-4447": {"epss_score": 0.01189, "epss_percentile": 0.78374}, "CVE-2012-4448": {"epss_score": 0.00153, "epss_percentile": 0.36537}, "CVE-2012-4449": {"epss_score": 0.00403, "epss_percentile": 0.60354}, "CVE-2012-4450": {"epss_score": 0.00378, "epss_percentile": 0.58809}, "CVE-2012-4451": {"epss_score": 0.01779, "epss_percentile": 0.82229}, "CVE-2012-4452": {"epss_score": 0.00063, "epss_percentile": 0.19996}, "CVE-2012-4453": {"epss_score": 0.00039, "epss_percentile": 0.11455}, "CVE-2012-4454": {"epss_score": 0.00655, "epss_percentile": 0.70412}, "CVE-2012-4455": {"epss_score": 0.00024, "epss_percentile": 0.0596}, "CVE-2012-4456": {"epss_score": 0.0395, "epss_percentile": 0.88}, "CVE-2012-4457": {"epss_score": 0.00561, "epss_percentile": 0.67677}, "CVE-2012-4458": {"epss_score": 0.02636, "epss_percentile": 0.85293}, "CVE-2012-4459": {"epss_score": 0.01187, "epss_percentile": 0.78355}, "CVE-2012-4460": {"epss_score": 0.03602, "epss_percentile": 0.87413}, "CVE-2012-4461": {"epss_score": 0.00121, "epss_percentile": 0.31923}, "CVE-2012-4462": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2012-4463": {"epss_score": 0.00638, "epss_percentile": 0.6993}, "CVE-2012-4464": {"epss_score": 0.00513, "epss_percentile": 0.65896}, "CVE-2012-4465": {"epss_score": 0.03459, "epss_percentile": 0.87177}, "CVE-2012-4466": {"epss_score": 0.01606, "epss_percentile": 0.81295}, "CVE-2012-4467": {"epss_score": 0.00049, "epss_percentile": 0.15486}, "CVE-2012-4468": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-4469": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2012-4470": {"epss_score": 0.00303, "epss_percentile": 0.53223}, "CVE-2012-4471": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2012-4472": {"epss_score": 0.00686, "epss_percentile": 0.71164}, "CVE-2012-4473": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2012-4474": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-4475": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2012-4476": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-4477": {"epss_score": 0.00157, "epss_percentile": 0.37134}, "CVE-2012-4478": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2012-4479": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2012-4480": {"epss_score": 0.00132, "epss_percentile": 0.33584}, "CVE-2012-4481": {"epss_score": 0.00583, "epss_percentile": 0.68349}, "CVE-2012-4482": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2012-4483": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2012-4484": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2012-4485": {"epss_score": 0.00359, "epss_percentile": 0.57609}, "CVE-2012-4486": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2012-4487": {"epss_score": 0.00165, "epss_percentile": 0.38039}, "CVE-2012-4488": {"epss_score": 0.0027, "epss_percentile": 0.50219}, "CVE-2012-4489": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2012-4490": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-4491": {"epss_score": 0.00234, "epss_percentile": 0.4611}, "CVE-2012-4492": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2012-4493": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2012-4494": {"epss_score": 0.00357, "epss_percentile": 0.5747}, "CVE-2012-4495": {"epss_score": 0.00364, "epss_percentile": 0.57906}, "CVE-2012-4496": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-4497": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-4498": {"epss_score": 0.00286, "epss_percentile": 0.51754}, "CVE-2012-4499": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2012-4500": {"epss_score": 0.00259, "epss_percentile": 0.49084}, "CVE-2012-4501": {"epss_score": 0.02729, "epss_percentile": 0.85534}, "CVE-2012-4502": {"epss_score": 0.00838, "epss_percentile": 0.74179}, "CVE-2012-4503": {"epss_score": 0.00403, "epss_percentile": 0.60354}, "CVE-2012-4504": {"epss_score": 0.05628, "epss_percentile": 0.90066}, "CVE-2012-4505": {"epss_score": 0.04366, "epss_percentile": 0.88603}, "CVE-2012-4506": {"epss_score": 0.00557, "epss_percentile": 0.67538}, "CVE-2012-4507": {"epss_score": 0.02224, "epss_percentile": 0.84066}, "CVE-2012-4508": {"epss_score": 0.00078, "epss_percentile": 0.23759}, "CVE-2012-4510": {"epss_score": 0.00361, "epss_percentile": 0.57719}, "CVE-2012-4511": {"epss_score": 0.00724, "epss_percentile": 0.72036}, "CVE-2012-4512": {"epss_score": 0.12763, "epss_percentile": 0.93767}, "CVE-2012-4513": {"epss_score": 0.15124, "epss_percentile": 0.94368}, "CVE-2012-4514": {"epss_score": 0.0487, "epss_percentile": 0.8923}, "CVE-2012-4515": {"epss_score": 0.09906, "epss_percentile": 0.92765}, "CVE-2012-4516": {"epss_score": 0.00493, "epss_percentile": 0.65057}, "CVE-2012-4517": {"epss_score": 0.01355, "epss_percentile": 0.79712}, "CVE-2012-4518": {"epss_score": 0.00113, "epss_percentile": 0.30717}, "CVE-2012-4519": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2012-4520": {"epss_score": 0.03893, "epss_percentile": 0.87912}, "CVE-2012-4522": {"epss_score": 0.00411, "epss_percentile": 0.609}, "CVE-2012-4523": {"epss_score": 0.00185, "epss_percentile": 0.40478}, "CVE-2012-4524": {"epss_score": 0.00668, "epss_percentile": 0.70725}, "CVE-2012-4525": {"epss_score": 0.00427, "epss_percentile": 0.61825}, "CVE-2012-4526": {"epss_score": 0.00427, "epss_percentile": 0.61825}, "CVE-2012-4527": {"epss_score": 0.281, "epss_percentile": 0.9631}, "CVE-2012-4528": {"epss_score": 0.11456, "epss_percentile": 0.93367}, "CVE-2012-4529": {"epss_score": 0.00563, "epss_percentile": 0.67735}, "CVE-2012-4530": {"epss_score": 0.00427, "epss_percentile": 0.61782}, "CVE-2012-4531": {"epss_score": 0.00011, "epss_percentile": 0.00978}, "CVE-2012-4532": {"epss_score": 0.00022, "epss_percentile": 0.05287}, "CVE-2012-4533": {"epss_score": 0.01286, "epss_percentile": 0.79182}, "CVE-2012-4534": {"epss_score": 0.2277, "epss_percentile": 0.95685}, "CVE-2012-4535": {"epss_score": 0.00106, "epss_percentile": 0.29411}, "CVE-2012-4536": {"epss_score": 0.00083, "epss_percentile": 0.24712}, "CVE-2012-4537": {"epss_score": 0.00106, "epss_percentile": 0.29411}, "CVE-2012-4538": {"epss_score": 0.00054, "epss_percentile": 0.17084}, "CVE-2012-4539": {"epss_score": 0.00074, "epss_percentile": 0.2285}, "CVE-2012-4540": {"epss_score": 0.01487, "epss_percentile": 0.80612}, "CVE-2012-4541": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-4542": {"epss_score": 0.00051, "epss_percentile": 0.16057}, "CVE-2012-4543": {"epss_score": 0.00238, "epss_percentile": 0.46752}, "CVE-2012-4544": {"epss_score": 0.00109, "epss_percentile": 0.29912}, "CVE-2012-4545": {"epss_score": 0.00473, "epss_percentile": 0.64106}, "CVE-2012-4546": {"epss_score": 0.00253, "epss_percentile": 0.48477}, "CVE-2012-4547": {"epss_score": 0.37906, "epss_percentile": 0.97075}, "CVE-2012-4548": {"epss_score": 0.00676, "epss_percentile": 0.70938}, "CVE-2012-4549": {"epss_score": 0.00263, "epss_percentile": 0.49471}, "CVE-2012-4550": {"epss_score": 0.00273, "epss_percentile": 0.50453}, "CVE-2012-4551": {"epss_score": 0.02002, "epss_percentile": 0.83222}, "CVE-2012-4552": {"epss_score": 0.22098, "epss_percentile": 0.95595}, "CVE-2012-4553": {"epss_score": 0.00671, "epss_percentile": 0.708}, "CVE-2012-4554": {"epss_score": 0.54623, "epss_percentile": 0.97936}, "CVE-2012-4555": {"epss_score": 0.00376, "epss_percentile": 0.5864}, "CVE-2012-4556": {"epss_score": 0.00376, "epss_percentile": 0.5864}, "CVE-2012-4557": {"epss_score": 0.29065, "epss_percentile": 0.96415}, "CVE-2012-4558": {"epss_score": 0.28235, "epss_percentile": 0.96335}, "CVE-2012-4559": {"epss_score": 0.05036, "epss_percentile": 0.89421}, "CVE-2012-4560": {"epss_score": 0.0661, "epss_percentile": 0.90886}, "CVE-2012-4561": {"epss_score": 0.03707, "epss_percentile": 0.87599}, "CVE-2012-4562": {"epss_score": 0.06733, "epss_percentile": 0.9099}, "CVE-2012-4563": {"epss_score": 0.00236, "epss_percentile": 0.46383}, "CVE-2012-4564": {"epss_score": 0.27173, "epss_percentile": 0.96216}, "CVE-2012-4565": {"epss_score": 0.00058, "epss_percentile": 0.18366}, "CVE-2012-4566": {"epss_score": 0.00175, "epss_percentile": 0.39266}, "CVE-2012-4567": {"epss_score": 0.00255, "epss_percentile": 0.48722}, "CVE-2012-4568": {"epss_score": 0.00147, "epss_percentile": 0.35706}, "CVE-2012-4569": {"epss_score": 0.00343, "epss_percentile": 0.56473}, "CVE-2012-4570": {"epss_score": 0.00567, "epss_percentile": 0.67836}, "CVE-2012-4571": {"epss_score": 0.00065, "epss_percentile": 0.20671}, "CVE-2012-4572": {"epss_score": 0.00058, "epss_percentile": 0.18407}, "CVE-2012-4573": {"epss_score": 0.00993, "epss_percentile": 0.76409}, "CVE-2012-4574": {"epss_score": 0.00082, "epss_percentile": 0.2447}, "CVE-2012-4575": {"epss_score": 0.01517, "epss_percentile": 0.80802}, "CVE-2012-4576": {"epss_score": 0.00101, "epss_percentile": 0.2859}, "CVE-2012-4577": {"epss_score": 0.0252, "epss_percentile": 0.85001}, "CVE-2012-4578": {"epss_score": 0.00031, "epss_percentile": 0.08329}, "CVE-2012-4579": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2012-4580": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-4581": {"epss_score": 0.00365, "epss_percentile": 0.57965}, "CVE-2012-4582": {"epss_score": 0.00157, "epss_percentile": 0.37136}, "CVE-2012-4583": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2012-4584": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2012-4585": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2012-4586": {"epss_score": 0.00156, "epss_percentile": 0.36988}, "CVE-2012-4587": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2012-4588": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2012-4589": {"epss_score": 0.00117, "epss_percentile": 0.31207}, "CVE-2012-4590": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-4591": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-4592": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-4593": {"epss_score": 0.00232, "epss_percentile": 0.45931}, "CVE-2012-4594": {"epss_score": 0.00156, "epss_percentile": 0.36988}, "CVE-2012-4595": {"epss_score": 0.0035, "epss_percentile": 0.56943}, "CVE-2012-4596": {"epss_score": 0.0026, "epss_percentile": 0.49153}, "CVE-2012-4597": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-4598": {"epss_score": 0.67903, "epss_percentile": 0.98524}, "CVE-2012-4599": {"epss_score": 0.06686, "epss_percentile": 0.90945}, "CVE-2012-4600": {"epss_score": 0.01226, "epss_percentile": 0.78687}, "CVE-2012-4601": {"epss_score": 0.00251, "epss_percentile": 0.48301}, "CVE-2012-4602": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2012-4603": {"epss_score": 0.05777, "epss_percentile": 0.90197}, "CVE-2012-4604": {"epss_score": 0.00176, "epss_percentile": 0.39462}, "CVE-2012-4605": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2012-4606": {"epss_score": 0.00044, "epss_percentile": 0.13507}, "CVE-2012-4607": {"epss_score": 0.08122, "epss_percentile": 0.9189}, "CVE-2012-4608": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2012-4609": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2012-4610": {"epss_score": 0.0018, "epss_percentile": 0.39932}, "CVE-2012-4611": {"epss_score": 0.00412, "epss_percentile": 0.60942}, "CVE-2012-4612": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-4613": {"epss_score": 0.00063, "epss_percentile": 0.19873}, "CVE-2012-4614": {"epss_score": 0.00578, "epss_percentile": 0.68188}, "CVE-2012-4615": {"epss_score": 0.0004, "epss_percentile": 0.11954}, "CVE-2012-4616": {"epss_score": 0.00106, "epss_percentile": 0.29436}, "CVE-2012-4617": {"epss_score": 0.00563, "epss_percentile": 0.67723}, "CVE-2012-4618": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2012-4619": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2012-4620": {"epss_score": 0.00726, "epss_percentile": 0.72077}, "CVE-2012-4621": {"epss_score": 0.00452, "epss_percentile": 0.63176}, "CVE-2012-4622": {"epss_score": 0.00662, "epss_percentile": 0.70599}, "CVE-2012-4623": {"epss_score": 0.00798, "epss_percentile": 0.73509}, "CVE-2012-4629": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-4638": {"epss_score": 0.0009, "epss_percentile": 0.26047}, "CVE-2012-4643": {"epss_score": 0.00563, "epss_percentile": 0.67723}, "CVE-2012-4651": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2012-4655": {"epss_score": 0.02399, "epss_percentile": 0.84634}, "CVE-2012-4658": {"epss_score": 0.00402, "epss_percentile": 0.6028}, "CVE-2012-4659": {"epss_score": 0.00562, "epss_percentile": 0.67684}, "CVE-2012-4660": {"epss_score": 0.00602, "epss_percentile": 0.68872}, "CVE-2012-4661": {"epss_score": 0.09665, "epss_percentile": 0.92647}, "CVE-2012-4662": {"epss_score": 0.01503, "epss_percentile": 0.80732}, "CVE-2012-4663": {"epss_score": 0.01503, "epss_percentile": 0.80732}, "CVE-2012-4667": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2012-4668": {"epss_score": 0.05064, "epss_percentile": 0.89456}, "CVE-2012-4669": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2012-4670": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2012-4671": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2012-4672": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2012-4673": {"epss_score": 0.00526, "epss_percentile": 0.66403}, "CVE-2012-4674": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-4675": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-4676": {"epss_score": 0.00036, "epss_percentile": 0.10293}, "CVE-2012-4677": {"epss_score": 0.00017, "epss_percentile": 0.03148}, "CVE-2012-4678": {"epss_score": 0.01937, "epss_percentile": 0.82963}, "CVE-2012-4679": {"epss_score": 0.07096, "epss_percentile": 0.91246}, "CVE-2012-4680": {"epss_score": 0.0854, "epss_percentile": 0.92112}, "CVE-2012-4681": {"epss_score": 0.9414, "epss_percentile": 0.99908}, "CVE-2012-4682": {"epss_score": 0.00361, "epss_percentile": 0.57725}, "CVE-2012-4683": {"epss_score": 0.005, "epss_percentile": 0.65303}, "CVE-2012-4684": {"epss_score": 0.0086, "epss_percentile": 0.74538}, "CVE-2012-4685": {"epss_score": 0.01417, "epss_percentile": 0.80146}, "CVE-2012-4686": {"epss_score": 0.00274, "epss_percentile": 0.50519}, "CVE-2012-4687": {"epss_score": 0.00354, "epss_percentile": 0.57211}, "CVE-2012-4688": {"epss_score": 0.00492, "epss_percentile": 0.65017}, "CVE-2012-4689": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2012-4690": {"epss_score": 0.01835, "epss_percentile": 0.82467}, "CVE-2012-4691": {"epss_score": 0.00104, "epss_percentile": 0.29148}, "CVE-2012-4693": {"epss_score": 0.00077, "epss_percentile": 0.2332}, "CVE-2012-4694": {"epss_score": 0.00385, "epss_percentile": 0.59211}, "CVE-2012-4695": {"epss_score": 0.00018, "epss_percentile": 0.04048}, "CVE-2012-4696": {"epss_score": 0.00067, "epss_percentile": 0.21181}, "CVE-2012-4697": {"epss_score": 0.00617, "epss_percentile": 0.69359}, "CVE-2012-4698": {"epss_score": 0.00484, "epss_percentile": 0.64665}, "CVE-2012-4700": {"epss_score": 0.08983, "epss_percentile": 0.9235}, "CVE-2012-4701": {"epss_score": 0.00868, "epss_percentile": 0.74673}, "CVE-2012-4702": {"epss_score": 0.03033, "epss_percentile": 0.86253}, "CVE-2012-4703": {"epss_score": 0.00238, "epss_percentile": 0.46789}, "CVE-2012-4704": {"epss_score": 0.12079, "epss_percentile": 0.93561}, "CVE-2012-4705": {"epss_score": 0.70393, "epss_percentile": 0.9863}, "CVE-2012-4706": {"epss_score": 0.00608, "epss_percentile": 0.69085}, "CVE-2012-4707": {"epss_score": 0.06705, "epss_percentile": 0.90959}, "CVE-2012-4708": {"epss_score": 0.07471, "epss_percentile": 0.91492}, "CVE-2012-4709": {"epss_score": 0.00152, "epss_percentile": 0.36376}, "CVE-2012-4710": {"epss_score": 0.00467, "epss_percentile": 0.63836}, "CVE-2012-4711": {"epss_score": 0.52097, "epss_percentile": 0.97807}, "CVE-2012-4712": {"epss_score": 0.00829, "epss_percentile": 0.74015}, "CVE-2012-4713": {"epss_score": 0.00048, "epss_percentile": 0.15273}, "CVE-2012-4714": {"epss_score": 0.00048, "epss_percentile": 0.15273}, "CVE-2012-4715": {"epss_score": 0.00343, "epss_percentile": 0.56428}, "CVE-2012-4716": {"epss_score": 0.0046, "epss_percentile": 0.63533}, "CVE-2012-4728": {"epss_score": 0.00686, "epss_percentile": 0.71166}, "CVE-2012-4729": {"epss_score": 0.00737, "epss_percentile": 0.72329}, "CVE-2012-4730": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2012-4731": {"epss_score": 0.00306, "epss_percentile": 0.53452}, "CVE-2012-4732": {"epss_score": 0.00116, "epss_percentile": 0.31043}, "CVE-2012-4733": {"epss_score": 0.00567, "epss_percentile": 0.67861}, "CVE-2012-4734": {"epss_score": 0.00158, "epss_percentile": 0.37233}, "CVE-2012-4736": {"epss_score": 0.00051, "epss_percentile": 0.16247}, "CVE-2012-4737": {"epss_score": 0.01504, "epss_percentile": 0.80739}, "CVE-2012-4739": {"epss_score": 0.0575, "epss_percentile": 0.90177}, "CVE-2012-4740": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-4741": {"epss_score": 0.00299, "epss_percentile": 0.52847}, "CVE-2012-4742": {"epss_score": 0.02024, "epss_percentile": 0.83309}, "CVE-2012-4743": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2012-4744": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-4745": {"epss_score": 0.03577, "epss_percentile": 0.8738}, "CVE-2012-4746": {"epss_score": 0.00642, "epss_percentile": 0.70027}, "CVE-2012-4747": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2012-4750": {"epss_score": 0.27991, "epss_percentile": 0.96301}, "CVE-2012-4751": {"epss_score": 0.09862, "epss_percentile": 0.92742}, "CVE-2012-4752": {"epss_score": 0.0063, "epss_percentile": 0.69703}, "CVE-2012-4753": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-2012-4754": {"epss_score": 0.0009, "epss_percentile": 0.25994}, "CVE-2012-4755": {"epss_score": 0.00056, "epss_percentile": 0.17771}, "CVE-2012-4756": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2012-4757": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2012-4758": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2012-4759": {"epss_score": 0.01556, "epss_percentile": 0.81015}, "CVE-2012-4760": {"epss_score": 0.00066, "epss_percentile": 0.2076}, "CVE-2012-4761": {"epss_score": 0.00066, "epss_percentile": 0.2076}, "CVE-2012-4767": {"epss_score": 0.00101, "epss_percentile": 0.28644}, "CVE-2012-4768": {"epss_score": 0.01936, "epss_percentile": 0.82962}, "CVE-2012-4771": {"epss_score": 0.07843, "epss_percentile": 0.91716}, "CVE-2012-4772": {"epss_score": 0.0327, "epss_percentile": 0.86792}, "CVE-2012-4773": {"epss_score": 0.06505, "epss_percentile": 0.90806}, "CVE-2012-4774": {"epss_score": 0.60082, "epss_percentile": 0.98192}, "CVE-2012-4775": {"epss_score": 0.14806, "epss_percentile": 0.94289}, "CVE-2012-4776": {"epss_score": 0.48628, "epss_percentile": 0.97646}, "CVE-2012-4777": {"epss_score": 0.11735, "epss_percentile": 0.93461}, "CVE-2012-4781": {"epss_score": 0.49415, "epss_percentile": 0.97684}, "CVE-2012-4782": {"epss_score": 0.5145, "epss_percentile": 0.97779}, "CVE-2012-4786": {"epss_score": 0.58628, "epss_percentile": 0.98127}, "CVE-2012-4787": {"epss_score": 0.36178, "epss_percentile": 0.96959}, "CVE-2012-4791": {"epss_score": 0.367, "epss_percentile": 0.96997}, "CVE-2012-4792": {"epss_score": 0.9183, "epss_percentile": 0.99671}, "CVE-2012-4816": {"epss_score": 0.00225, "epss_percentile": 0.45089}, "CVE-2012-4817": {"epss_score": 0.02437, "epss_percentile": 0.84743}, "CVE-2012-4818": {"epss_score": 0.00195, "epss_percentile": 0.41649}, "CVE-2012-4819": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2012-4820": {"epss_score": 0.09366, "epss_percentile": 0.92518}, "CVE-2012-4821": {"epss_score": 0.06647, "epss_percentile": 0.90913}, "CVE-2012-4822": {"epss_score": 0.11284, "epss_percentile": 0.93292}, "CVE-2012-4823": {"epss_score": 0.1445, "epss_percentile": 0.94213}, "CVE-2012-4824": {"epss_score": 0.00201, "epss_percentile": 0.42329}, "CVE-2012-4825": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2012-4826": {"epss_score": 0.18365, "epss_percentile": 0.95005}, "CVE-2012-4829": {"epss_score": 0.0011, "epss_percentile": 0.30178}, "CVE-2012-4830": {"epss_score": 0.00264, "epss_percentile": 0.49687}, "CVE-2012-4832": {"epss_score": 0.00084, "epss_percentile": 0.24957}, "CVE-2012-4833": {"epss_score": 0.00054, "epss_percentile": 0.17259}, "CVE-2012-4834": {"epss_score": 0.01686, "epss_percentile": 0.81752}, "CVE-2012-4835": {"epss_score": 0.00229, "epss_percentile": 0.45559}, "CVE-2012-4836": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2012-4837": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2012-4838": {"epss_score": 0.0008, "epss_percentile": 0.24113}, "CVE-2012-4839": {"epss_score": 0.00227, "epss_percentile": 0.45394}, "CVE-2012-4840": {"epss_score": 0.00248, "epss_percentile": 0.47965}, "CVE-2012-4841": {"epss_score": 0.00645, "epss_percentile": 0.70112}, "CVE-2012-4842": {"epss_score": 0.00201, "epss_percentile": 0.42329}, "CVE-2012-4844": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2012-4845": {"epss_score": 0.00439, "epss_percentile": 0.62602}, "CVE-2012-4846": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2012-4847": {"epss_score": 0.0036, "epss_percentile": 0.57662}, "CVE-2012-4848": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2012-4850": {"epss_score": 0.00792, "epss_percentile": 0.73397}, "CVE-2012-4851": {"epss_score": 0.0023, "epss_percentile": 0.45669}, "CVE-2012-4853": {"epss_score": 0.00163, "epss_percentile": 0.37829}, "CVE-2012-4855": {"epss_score": 0.00627, "epss_percentile": 0.69639}, "CVE-2012-4856": {"epss_score": 0.00422, "epss_percentile": 0.61561}, "CVE-2012-4857": {"epss_score": 0.07643, "epss_percentile": 0.91597}, "CVE-2012-4858": {"epss_score": 0.02, "epss_percentile": 0.83215}, "CVE-2012-4859": {"epss_score": 0.00051, "epss_percentile": 0.16148}, "CVE-2012-4861": {"epss_score": 0.00146, "epss_percentile": 0.35552}, "CVE-2012-4862": {"epss_score": 0.00036, "epss_percentile": 0.10219}, "CVE-2012-4863": {"epss_score": 0.00432, "epss_percentile": 0.62098}, "CVE-2012-4864": {"epss_score": 0.21459, "epss_percentile": 0.95521}, "CVE-2012-4865": {"epss_score": 0.2876, "epss_percentile": 0.96382}, "CVE-2012-4866": {"epss_score": 0.00098, "epss_percentile": 0.27713}, "CVE-2012-4867": {"epss_score": 0.05058, "epss_percentile": 0.8945}, "CVE-2012-4868": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2012-4869": {"epss_score": 0.84867, "epss_percentile": 0.99308}, "CVE-2012-4870": {"epss_score": 0.07984, "epss_percentile": 0.91804}, "CVE-2012-4871": {"epss_score": 0.02704, "epss_percentile": 0.85462}, "CVE-2012-4872": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-4873": {"epss_score": 0.00349, "epss_percentile": 0.56862}, "CVE-2012-4874": {"epss_score": 0.01399, "epss_percentile": 0.79994}, "CVE-2012-4875": {"epss_score": 0.09321, "epss_percentile": 0.92499}, "CVE-2012-4876": {"epss_score": 0.81162, "epss_percentile": 0.99126}, "CVE-2012-4877": {"epss_score": 0.03313, "epss_percentile": 0.86896}, "CVE-2012-4878": {"epss_score": 0.14501, "epss_percentile": 0.94225}, "CVE-2012-4879": {"epss_score": 0.00634, "epss_percentile": 0.69802}, "CVE-2012-4880": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2012-4881": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2012-4882": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2012-4883": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2012-4884": {"epss_score": 0.00245, "epss_percentile": 0.47633}, "CVE-2012-4885": {"epss_score": 0.01182, "epss_percentile": 0.78318}, "CVE-2012-4886": {"epss_score": 0.53436, "epss_percentile": 0.97877}, "CVE-2012-4889": {"epss_score": 0.03763, "epss_percentile": 0.87691}, "CVE-2012-4890": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2012-4891": {"epss_score": 0.04011, "epss_percentile": 0.88112}, "CVE-2012-4892": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-4893": {"epss_score": 0.00603, "epss_percentile": 0.68906}, "CVE-2012-4894": {"epss_score": 0.06825, "epss_percentile": 0.91049}, "CVE-2012-4895": {"epss_score": 0.0845, "epss_percentile": 0.92058}, "CVE-2012-4896": {"epss_score": 0.0845, "epss_percentile": 0.92058}, "CVE-2012-4897": {"epss_score": 0.00164, "epss_percentile": 0.37988}, "CVE-2012-4898": {"epss_score": 0.00148, "epss_percentile": 0.35873}, "CVE-2012-4899": {"epss_score": 0.00062, "epss_percentile": 0.19722}, "CVE-2012-4900": {"epss_score": 0.00737, "epss_percentile": 0.72332}, "CVE-2012-4901": {"epss_score": 0.04848, "epss_percentile": 0.89211}, "CVE-2012-4902": {"epss_score": 0.0046, "epss_percentile": 0.63522}, "CVE-2012-4903": {"epss_score": 0.00233, "epss_percentile": 0.45981}, "CVE-2012-4904": {"epss_score": 0.00152, "epss_percentile": 0.36378}, "CVE-2012-4905": {"epss_score": 0.00852, "epss_percentile": 0.74417}, "CVE-2012-4906": {"epss_score": 0.08153, "epss_percentile": 0.91905}, "CVE-2012-4907": {"epss_score": 0.00438, "epss_percentile": 0.62575}, "CVE-2012-4908": {"epss_score": 0.03624, "epss_percentile": 0.87454}, "CVE-2012-4909": {"epss_score": 0.04642, "epss_percentile": 0.88955}, "CVE-2012-4912": {"epss_score": 0.01433, "epss_percentile": 0.80261}, "CVE-2012-4914": {"epss_score": 0.65917, "epss_percentile": 0.98443}, "CVE-2012-4915": {"epss_score": 0.77356, "epss_percentile": 0.98933}, "CVE-2012-4917": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-4918": {"epss_score": 0.00203, "epss_percentile": 0.42508}, "CVE-2012-4919": {"epss_score": 0.01872, "epss_percentile": 0.8264}, "CVE-2012-4920": {"epss_score": 0.01273, "epss_percentile": 0.79088}, "CVE-2012-4921": {"epss_score": 0.00125, "epss_percentile": 0.32539}, "CVE-2012-4922": {"epss_score": 0.05586, "epss_percentile": 0.90025}, "CVE-2012-4923": {"epss_score": 0.03192, "epss_percentile": 0.86601}, "CVE-2012-4924": {"epss_score": 0.79899, "epss_percentile": 0.9906}, "CVE-2012-4925": {"epss_score": 0.01485, "epss_percentile": 0.806}, "CVE-2012-4926": {"epss_score": 0.02626, "epss_percentile": 0.85267}, "CVE-2012-4927": {"epss_score": 0.02139, "epss_percentile": 0.83744}, "CVE-2012-4928": {"epss_score": 0.03217, "epss_percentile": 0.86665}, "CVE-2012-4929": {"epss_score": 0.14186, "epss_percentile": 0.94158}, "CVE-2012-4930": {"epss_score": 0.00236, "epss_percentile": 0.46384}, "CVE-2012-4932": {"epss_score": 0.00387, "epss_percentile": 0.59296}, "CVE-2012-4933": {"epss_score": 0.75707, "epss_percentile": 0.9886}, "CVE-2012-4934": {"epss_score": 0.00291, "epss_percentile": 0.5219}, "CVE-2012-4935": {"epss_score": 0.00091, "epss_percentile": 0.26248}, "CVE-2012-4936": {"epss_score": 0.00762, "epss_percentile": 0.72848}, "CVE-2012-4937": {"epss_score": 0.00927, "epss_percentile": 0.75568}, "CVE-2012-4938": {"epss_score": 0.00355, "epss_percentile": 0.57316}, "CVE-2012-4939": {"epss_score": 0.09769, "epss_percentile": 0.92695}, "CVE-2012-4940": {"epss_score": 0.8485, "epss_percentile": 0.99307}, "CVE-2012-4941": {"epss_score": 0.00374, "epss_percentile": 0.58558}, "CVE-2012-4942": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2012-4943": {"epss_score": 0.00061, "epss_percentile": 0.1938}, "CVE-2012-4944": {"epss_score": 0.05671, "epss_percentile": 0.90104}, "CVE-2012-4945": {"epss_score": 0.01171, "epss_percentile": 0.78217}, "CVE-2012-4946": {"epss_score": 0.00717, "epss_percentile": 0.71876}, "CVE-2012-4947": {"epss_score": 0.00518, "epss_percentile": 0.66096}, "CVE-2012-4948": {"epss_score": 0.0009, "epss_percentile": 0.26165}, "CVE-2012-4949": {"epss_score": 0.00964, "epss_percentile": 0.76035}, "CVE-2012-4950": {"epss_score": 0.00653, "epss_percentile": 0.70337}, "CVE-2012-4951": {"epss_score": 0.01333, "epss_percentile": 0.7953}, "CVE-2012-4952": {"epss_score": 0.016, "epss_percentile": 0.81255}, "CVE-2012-4953": {"epss_score": 0.09486, "epss_percentile": 0.92569}, "CVE-2012-4954": {"epss_score": 0.00315, "epss_percentile": 0.54179}, "CVE-2012-4955": {"epss_score": 0.00638, "epss_percentile": 0.69924}, "CVE-2012-4956": {"epss_score": 0.68577, "epss_percentile": 0.98553}, "CVE-2012-4957": {"epss_score": 0.75558, "epss_percentile": 0.98853}, "CVE-2012-4958": {"epss_score": 0.73561, "epss_percentile": 0.98762}, "CVE-2012-4959": {"epss_score": 0.73924, "epss_percentile": 0.98777}, "CVE-2012-4960": {"epss_score": 0.0802, "epss_percentile": 0.91834}, "CVE-2012-4964": {"epss_score": 0.00931, "epss_percentile": 0.75622}, "CVE-2012-4968": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2012-4969": {"epss_score": 0.91843, "epss_percentile": 0.99672}, "CVE-2012-4970": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-4971": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2012-4972": {"epss_score": 0.00326, "epss_percentile": 0.55074}, "CVE-2012-4974": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2012-4975": {"epss_score": 0.00171, "epss_percentile": 0.38827}, "CVE-2012-4976": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-4977": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-4980": {"epss_score": 0.0093, "epss_percentile": 0.756}, "CVE-2012-4981": {"epss_score": 0.05741, "epss_percentile": 0.90169}, "CVE-2012-4982": {"epss_score": 0.1931, "epss_percentile": 0.95162}, "CVE-2012-4983": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-4985": {"epss_score": 0.00572, "epss_percentile": 0.68016}, "CVE-2012-4987": {"epss_score": 0.04009, "epss_percentile": 0.88108}, "CVE-2012-4988": {"epss_score": 0.40043, "epss_percentile": 0.97192}, "CVE-2012-4989": {"epss_score": 0.00974, "epss_percentile": 0.76194}, "CVE-2012-4990": {"epss_score": 0.00763, "epss_percentile": 0.72892}, "CVE-2012-4991": {"epss_score": 0.0436, "epss_percentile": 0.88595}, "CVE-2012-4992": {"epss_score": 0.52515, "epss_percentile": 0.97829}, "CVE-2012-4993": {"epss_score": 0.03352, "epss_percentile": 0.86965}, "CVE-2012-4994": {"epss_score": 0.0039, "epss_percentile": 0.59504}, "CVE-2012-4995": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-4996": {"epss_score": 0.00391, "epss_percentile": 0.59593}, "CVE-2012-4997": {"epss_score": 0.03544, "epss_percentile": 0.87323}, "CVE-2012-4998": {"epss_score": 0.02473, "epss_percentile": 0.84853}, "CVE-2012-4999": {"epss_score": 0.09756, "epss_percentile": 0.92691}, "CVE-2012-5000": {"epss_score": 0.00663, "epss_percentile": 0.70617}, "CVE-2012-5001": {"epss_score": 0.0248, "epss_percentile": 0.84872}, "CVE-2012-5002": {"epss_score": 0.34146, "epss_percentile": 0.96827}, "CVE-2012-5003": {"epss_score": 0.01469, "epss_percentile": 0.8049}, "CVE-2012-5004": {"epss_score": 0.00289, "epss_percentile": 0.52018}, "CVE-2012-5005": {"epss_score": 0.00171, "epss_percentile": 0.38901}, "CVE-2012-5006": {"epss_score": 0.0785, "epss_percentile": 0.91718}, "CVE-2012-5007": {"epss_score": 0.00387, "epss_percentile": 0.59332}, "CVE-2012-5010": {"epss_score": 0.0032, "epss_percentile": 0.54636}, "CVE-2012-5014": {"epss_score": 0.0034, "epss_percentile": 0.56224}, "CVE-2012-5017": {"epss_score": 0.00363, "epss_percentile": 0.57874}, "CVE-2012-5030": {"epss_score": 0.00454, "epss_percentile": 0.63251}, "CVE-2012-5032": {"epss_score": 0.00506, "epss_percentile": 0.65619}, "CVE-2012-5036": {"epss_score": 0.00363, "epss_percentile": 0.57874}, "CVE-2012-5037": {"epss_score": 0.00085, "epss_percentile": 0.25237}, "CVE-2012-5039": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2012-5044": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2012-5048": {"epss_score": 0.11582, "epss_percentile": 0.9341}, "CVE-2012-5049": {"epss_score": 0.13124, "epss_percentile": 0.93879}, "CVE-2012-5050": {"epss_score": 0.00394, "epss_percentile": 0.59749}, "CVE-2012-5051": {"epss_score": 0.00204, "epss_percentile": 0.42612}, "CVE-2012-5053": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2012-5054": {"epss_score": 0.76609, "epss_percentile": 0.98898}, "CVE-2012-5055": {"epss_score": 0.00361, "epss_percentile": 0.57716}, "CVE-2012-5056": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-5057": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2012-5058": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2012-5059": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2012-5060": {"epss_score": 0.00722, "epss_percentile": 0.71992}, "CVE-2012-5061": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2012-5062": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2012-5063": {"epss_score": 0.00351, "epss_percentile": 0.57071}, "CVE-2012-5064": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2012-5065": {"epss_score": 0.00217, "epss_percentile": 0.44243}, "CVE-2012-5066": {"epss_score": 0.00723, "epss_percentile": 0.72014}, "CVE-2012-5067": {"epss_score": 0.56361, "epss_percentile": 0.98019}, "CVE-2012-5068": {"epss_score": 0.06826, "epss_percentile": 0.91051}, "CVE-2012-5069": {"epss_score": 0.03119, "epss_percentile": 0.86444}, "CVE-2012-5070": {"epss_score": 0.01378, "epss_percentile": 0.79847}, "CVE-2012-5071": {"epss_score": 0.03119, "epss_percentile": 0.86444}, "CVE-2012-5072": {"epss_score": 0.02321, "epss_percentile": 0.84368}, "CVE-2012-5073": {"epss_score": 0.03772, "epss_percentile": 0.87704}, "CVE-2012-5074": {"epss_score": 0.01861, "epss_percentile": 0.82591}, "CVE-2012-5075": {"epss_score": 0.02321, "epss_percentile": 0.84368}, "CVE-2012-5076": {"epss_score": 0.92229, "epss_percentile": 0.99701}, "CVE-2012-5077": {"epss_score": 0.01972, "epss_percentile": 0.83108}, "CVE-2012-5078": {"epss_score": 0.01718, "epss_percentile": 0.81923}, "CVE-2012-5079": {"epss_score": 0.03772, "epss_percentile": 0.87704}, "CVE-2012-5080": {"epss_score": 0.01311, "epss_percentile": 0.79371}, "CVE-2012-5081": {"epss_score": 0.82678, "epss_percentile": 0.99206}, "CVE-2012-5082": {"epss_score": 0.00832, "epss_percentile": 0.74072}, "CVE-2012-5083": {"epss_score": 0.10123, "epss_percentile": 0.92859}, "CVE-2012-5084": {"epss_score": 0.10927, "epss_percentile": 0.93161}, "CVE-2012-5085": {"epss_score": 0.00234, "epss_percentile": 0.46107}, "CVE-2012-5086": {"epss_score": 0.10008, "epss_percentile": 0.92814}, "CVE-2012-5087": {"epss_score": 0.06096, "epss_percentile": 0.90476}, "CVE-2012-5088": {"epss_score": 0.79264, "epss_percentile": 0.99027}, "CVE-2012-5089": {"epss_score": 0.10927, "epss_percentile": 0.93161}, "CVE-2012-5090": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2012-5091": {"epss_score": 0.00409, "epss_percentile": 0.60696}, "CVE-2012-5092": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2012-5093": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2012-5094": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2012-5095": {"epss_score": 0.00054, "epss_percentile": 0.17077}, "CVE-2012-5096": {"epss_score": 0.00449, "epss_percentile": 0.63045}, "CVE-2012-5097": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2012-5098": {"epss_score": 0.0022, "epss_percentile": 0.44577}, "CVE-2012-5099": {"epss_score": 0.00328, "epss_percentile": 0.55263}, "CVE-2012-5100": {"epss_score": 0.07453, "epss_percentile": 0.9148}, "CVE-2012-5101": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2012-5102": {"epss_score": 0.00763, "epss_percentile": 0.72884}, "CVE-2012-5103": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2012-5104": {"epss_score": 0.07099, "epss_percentile": 0.91249}, "CVE-2012-5105": {"epss_score": 0.10548, "epss_percentile": 0.93025}, "CVE-2012-5106": {"epss_score": 0.31047, "epss_percentile": 0.96585}, "CVE-2012-5108": {"epss_score": 0.07243, "epss_percentile": 0.91347}, "CVE-2012-5109": {"epss_score": 0.00774, "epss_percentile": 0.73065}, "CVE-2012-5110": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2012-5111": {"epss_score": 0.00198, "epss_percentile": 0.41974}, "CVE-2012-5112": {"epss_score": 0.04595, "epss_percentile": 0.88897}, "CVE-2012-5115": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2012-5116": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2012-5117": {"epss_score": 0.00228, "epss_percentile": 0.45494}, "CVE-2012-5118": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2012-5119": {"epss_score": 0.00918, "epss_percentile": 0.75442}, "CVE-2012-5120": {"epss_score": 0.01004, "epss_percentile": 0.76525}, "CVE-2012-5121": {"epss_score": 0.03358, "epss_percentile": 0.86981}, "CVE-2012-5122": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2012-5123": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2012-5124": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2012-5125": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2012-5126": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2012-5127": {"epss_score": 0.01274, "epss_percentile": 0.79099}, "CVE-2012-5128": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2012-5129": {"epss_score": 0.00443, "epss_percentile": 0.62801}, "CVE-2012-5130": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2012-5131": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2012-5132": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2012-5133": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2012-5134": {"epss_score": 0.02065, "epss_percentile": 0.83455}, "CVE-2012-5135": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2012-5136": {"epss_score": 0.0125, "epss_percentile": 0.78882}, "CVE-2012-5137": {"epss_score": 0.04004, "epss_percentile": 0.88098}, "CVE-2012-5138": {"epss_score": 0.00781, "epss_percentile": 0.73186}, "CVE-2012-5139": {"epss_score": 0.01869, "epss_percentile": 0.82625}, "CVE-2012-5140": {"epss_score": 0.01869, "epss_percentile": 0.82625}, "CVE-2012-5141": {"epss_score": 0.00422, "epss_percentile": 0.61538}, "CVE-2012-5142": {"epss_score": 0.05601, "epss_percentile": 0.90039}, "CVE-2012-5143": {"epss_score": 0.01696, "epss_percentile": 0.81813}, "CVE-2012-5144": {"epss_score": 0.03505, "epss_percentile": 0.87257}, "CVE-2012-5145": {"epss_score": 0.02201, "epss_percentile": 0.83981}, "CVE-2012-5146": {"epss_score": 0.00203, "epss_percentile": 0.42493}, "CVE-2012-5147": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2012-5148": {"epss_score": 0.00198, "epss_percentile": 0.41974}, "CVE-2012-5149": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2012-5150": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2012-5151": {"epss_score": 0.00485, "epss_percentile": 0.64732}, "CVE-2012-5152": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2012-5153": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2012-5154": {"epss_score": 0.0023, "epss_percentile": 0.45732}, "CVE-2012-5155": {"epss_score": 0.00085, "epss_percentile": 0.25163}, "CVE-2012-5156": {"epss_score": 0.00569, "epss_percentile": 0.67936}, "CVE-2012-5157": {"epss_score": 0.00804, "epss_percentile": 0.73614}, "CVE-2012-5158": {"epss_score": 0.00157, "epss_percentile": 0.37124}, "CVE-2012-5159": {"epss_score": 0.8794, "epss_percentile": 0.99452}, "CVE-2012-5161": {"epss_score": 0.07361, "epss_percentile": 0.91431}, "CVE-2012-5162": {"epss_score": 0.0039, "epss_percentile": 0.59504}, "CVE-2012-5163": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2012-5164": {"epss_score": 0.00446, "epss_percentile": 0.62934}, "CVE-2012-5166": {"epss_score": 0.53689, "epss_percentile": 0.97891}, "CVE-2012-5167": {"epss_score": 0.02153, "epss_percentile": 0.83794}, "CVE-2012-5168": {"epss_score": 0.03732, "epss_percentile": 0.87646}, "CVE-2012-5169": {"epss_score": 0.00528, "epss_percentile": 0.6654}, "CVE-2012-5170": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-5171": {"epss_score": 0.00715, "epss_percentile": 0.71832}, "CVE-2012-5172": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-5173": {"epss_score": 0.00505, "epss_percentile": 0.65552}, "CVE-2012-5174": {"epss_score": 0.00099, "epss_percentile": 0.284}, "CVE-2012-5175": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-5176": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-5177": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2012-5178": {"epss_score": 0.00102, "epss_percentile": 0.28822}, "CVE-2012-5179": {"epss_score": 0.00064, "epss_percentile": 0.20317}, "CVE-2012-5180": {"epss_score": 0.00257, "epss_percentile": 0.48947}, "CVE-2012-5181": {"epss_score": 0.00493, "epss_percentile": 0.65038}, "CVE-2012-5182": {"epss_score": 0.00291, "epss_percentile": 0.52169}, "CVE-2012-5183": {"epss_score": 0.00291, "epss_percentile": 0.52169}, "CVE-2012-5184": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-5185": {"epss_score": 0.0041, "epss_percentile": 0.60843}, "CVE-2012-5186": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-5187": {"epss_score": 0.00229, "epss_percentile": 0.45572}, "CVE-2012-5188": {"epss_score": 0.01726, "epss_percentile": 0.81965}, "CVE-2012-5190": {"epss_score": 0.10746, "epss_percentile": 0.93091}, "CVE-2012-5192": {"epss_score": 0.5826, "epss_percentile": 0.98105}, "CVE-2012-5193": {"epss_score": 0.00791, "epss_percentile": 0.73394}, "CVE-2012-5195": {"epss_score": 0.0645, "epss_percentile": 0.90764}, "CVE-2012-5196": {"epss_score": 0.0078, "epss_percentile": 0.73167}, "CVE-2012-5197": {"epss_score": 0.00723, "epss_percentile": 0.72022}, "CVE-2012-5198": {"epss_score": 0.01529, "epss_percentile": 0.80881}, "CVE-2012-5199": {"epss_score": 0.00114, "epss_percentile": 0.30749}, "CVE-2012-5200": {"epss_score": 0.00193, "epss_percentile": 0.4142}, "CVE-2012-5201": {"epss_score": 0.74878, "epss_percentile": 0.98821}, "CVE-2012-5202": {"epss_score": 0.67455, "epss_percentile": 0.98508}, "CVE-2012-5203": {"epss_score": 0.67455, "epss_percentile": 0.98508}, "CVE-2012-5204": {"epss_score": 0.6939, "epss_percentile": 0.98585}, "CVE-2012-5205": {"epss_score": 0.01067, "epss_percentile": 0.77229}, "CVE-2012-5206": {"epss_score": 0.01067, "epss_percentile": 0.77229}, "CVE-2012-5207": {"epss_score": 0.01598, "epss_percentile": 0.81248}, "CVE-2012-5208": {"epss_score": 0.01067, "epss_percentile": 0.77229}, "CVE-2012-5209": {"epss_score": 0.24213, "epss_percentile": 0.95887}, "CVE-2012-5210": {"epss_score": 0.0152, "epss_percentile": 0.80824}, "CVE-2012-5211": {"epss_score": 0.01067, "epss_percentile": 0.77229}, "CVE-2012-5212": {"epss_score": 0.00468, "epss_percentile": 0.63913}, "CVE-2012-5213": {"epss_score": 0.01034, "epss_percentile": 0.76891}, "CVE-2012-5214": {"epss_score": 0.01067, "epss_percentile": 0.77229}, "CVE-2012-5215": {"epss_score": 0.02037, "epss_percentile": 0.83357}, "CVE-2012-5216": {"epss_score": 0.00132, "epss_percentile": 0.33512}, "CVE-2012-5217": {"epss_score": 0.00373, "epss_percentile": 0.58481}, "CVE-2012-5218": {"epss_score": 0.00056, "epss_percentile": 0.1778}, "CVE-2012-5219": {"epss_score": 0.00595, "epss_percentile": 0.68681}, "CVE-2012-5220": {"epss_score": 0.00073, "epss_percentile": 0.22651}, "CVE-2012-5221": {"epss_score": 0.02058, "epss_percentile": 0.83432}, "CVE-2012-5222": {"epss_score": 0.00789, "epss_percentile": 0.73351}, "CVE-2012-5223": {"epss_score": 0.79642, "epss_percentile": 0.99051}, "CVE-2012-5224": {"epss_score": 0.01192, "epss_percentile": 0.78399}, "CVE-2012-5225": {"epss_score": 0.04177, "epss_percentile": 0.88353}, "CVE-2012-5226": {"epss_score": 0.00328, "epss_percentile": 0.55263}, "CVE-2012-5227": {"epss_score": 0.00178, "epss_percentile": 0.39745}, "CVE-2012-5228": {"epss_score": 0.04189, "epss_percentile": 0.8837}, "CVE-2012-5229": {"epss_score": 0.00512, "epss_percentile": 0.65873}, "CVE-2012-5230": {"epss_score": 0.00463, "epss_percentile": 0.63631}, "CVE-2012-5231": {"epss_score": 0.02651, "epss_percentile": 0.85345}, "CVE-2012-5232": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-5233": {"epss_score": 0.00324, "epss_percentile": 0.54954}, "CVE-2012-5234": {"epss_score": 0.00211, "epss_percentile": 0.4368}, "CVE-2012-5237": {"epss_score": 0.00963, "epss_percentile": 0.76022}, "CVE-2012-5238": {"epss_score": 0.00851, "epss_percentile": 0.74409}, "CVE-2012-5240": {"epss_score": 0.00976, "epss_percentile": 0.76206}, "CVE-2012-5242": {"epss_score": 0.0512, "epss_percentile": 0.89519}, "CVE-2012-5243": {"epss_score": 0.11563, "epss_percentile": 0.93405}, "CVE-2012-5244": {"epss_score": 0.03544, "epss_percentile": 0.87321}, "CVE-2012-5248": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5249": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5250": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5251": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5252": {"epss_score": 0.0789, "epss_percentile": 0.91745}, "CVE-2012-5253": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5254": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5255": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5256": {"epss_score": 0.06135, "epss_percentile": 0.90508}, "CVE-2012-5257": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5258": {"epss_score": 0.06135, "epss_percentile": 0.90508}, "CVE-2012-5259": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5260": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5261": {"epss_score": 0.06135, "epss_percentile": 0.90508}, "CVE-2012-5262": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5263": {"epss_score": 0.06135, "epss_percentile": 0.90508}, "CVE-2012-5264": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5265": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5266": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5267": {"epss_score": 0.08103, "epss_percentile": 0.9188}, "CVE-2012-5268": {"epss_score": 0.06135, "epss_percentile": 0.90508}, "CVE-2012-5269": {"epss_score": 0.08103, "epss_percentile": 0.9188}, "CVE-2012-5270": {"epss_score": 0.05955, "epss_percentile": 0.90361}, "CVE-2012-5271": {"epss_score": 0.08103, "epss_percentile": 0.9188}, "CVE-2012-5272": {"epss_score": 0.09943, "epss_percentile": 0.92784}, "CVE-2012-5273": {"epss_score": 0.03713, "epss_percentile": 0.87611}, "CVE-2012-5274": {"epss_score": 0.0263, "epss_percentile": 0.8528}, "CVE-2012-5275": {"epss_score": 0.0263, "epss_percentile": 0.8528}, "CVE-2012-5276": {"epss_score": 0.0263, "epss_percentile": 0.8528}, "CVE-2012-5277": {"epss_score": 0.0263, "epss_percentile": 0.8528}, "CVE-2012-5278": {"epss_score": 0.02703, "epss_percentile": 0.85459}, "CVE-2012-5279": {"epss_score": 0.033, "epss_percentile": 0.86865}, "CVE-2012-5280": {"epss_score": 0.03431, "epss_percentile": 0.87125}, "CVE-2012-5285": {"epss_score": 0.08262, "epss_percentile": 0.91956}, "CVE-2012-5286": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5287": {"epss_score": 0.06407, "epss_percentile": 0.90738}, "CVE-2012-5288": {"epss_score": 0.00215, "epss_percentile": 0.44029}, "CVE-2012-5289": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2012-5290": {"epss_score": 0.00294, "epss_percentile": 0.52392}, "CVE-2012-5291": {"epss_score": 0.00196, "epss_percentile": 0.41759}, "CVE-2012-5292": {"epss_score": 0.00289, "epss_percentile": 0.52038}, "CVE-2012-5293": {"epss_score": 0.02472, "epss_percentile": 0.84849}, "CVE-2012-5294": {"epss_score": 0.00476, "epss_percentile": 0.64276}, "CVE-2012-5295": {"epss_score": 0.00463, "epss_percentile": 0.63632}, "CVE-2012-5296": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-5297": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2012-5298": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2012-5299": {"epss_score": 0.00595, "epss_percentile": 0.68692}, "CVE-2012-5300": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2012-5301": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-5302": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2012-5303": {"epss_score": 0.00036, "epss_percentile": 0.10198}, "CVE-2012-5304": {"epss_score": 0.0049, "epss_percentile": 0.64917}, "CVE-2012-5305": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-5306": {"epss_score": 0.2764, "epss_percentile": 0.96268}, "CVE-2012-5307": {"epss_score": 0.00202, "epss_percentile": 0.42481}, "CVE-2012-5308": {"epss_score": 0.00106, "epss_percentile": 0.29443}, "CVE-2012-5309": {"epss_score": 0.0055, "epss_percentile": 0.67349}, "CVE-2012-5310": {"epss_score": 0.00506, "epss_percentile": 0.65627}, "CVE-2012-5312": {"epss_score": 0.00178, "epss_percentile": 0.39745}, "CVE-2012-5313": {"epss_score": 0.00926, "epss_percentile": 0.75555}, "CVE-2012-5314": {"epss_score": 0.00374, "epss_percentile": 0.5858}, "CVE-2012-5315": {"epss_score": 0.00328, "epss_percentile": 0.55263}, "CVE-2012-5316": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2012-5317": {"epss_score": 0.00481, "epss_percentile": 0.6451}, "CVE-2012-5318": {"epss_score": 0.10957, "epss_percentile": 0.93177}, "CVE-2012-5319": {"epss_score": 0.01171, "epss_percentile": 0.78218}, "CVE-2012-5320": {"epss_score": 0.00311, "epss_percentile": 0.53866}, "CVE-2012-5321": {"epss_score": 0.23135, "epss_percentile": 0.95738}, "CVE-2012-5322": {"epss_score": 0.09338, "epss_percentile": 0.92505}, "CVE-2012-5323": {"epss_score": 0.00402, "epss_percentile": 0.60301}, "CVE-2012-5324": {"epss_score": 0.26922, "epss_percentile": 0.96193}, "CVE-2012-5325": {"epss_score": 0.0011, "epss_percentile": 0.3018}, "CVE-2012-5326": {"epss_score": 0.00211, "epss_percentile": 0.43714}, "CVE-2012-5327": {"epss_score": 0.00361, "epss_percentile": 0.57691}, "CVE-2012-5328": {"epss_score": 0.00294, "epss_percentile": 0.52401}, "CVE-2012-5329": {"epss_score": 0.05923, "epss_percentile": 0.90324}, "CVE-2012-5330": {"epss_score": 0.00372, "epss_percentile": 0.58456}, "CVE-2012-5331": {"epss_score": 0.03325, "epss_percentile": 0.86922}, "CVE-2012-5332": {"epss_score": 0.00746, "epss_percentile": 0.72541}, "CVE-2012-5333": {"epss_score": 0.0107, "epss_percentile": 0.77258}, "CVE-2012-5334": {"epss_score": 0.01685, "epss_percentile": 0.81749}, "CVE-2012-5335": {"epss_score": 0.07317, "epss_percentile": 0.91405}, "CVE-2012-5336": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2012-5337": {"epss_score": 0.00371, "epss_percentile": 0.58354}, "CVE-2012-5338": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2012-5339": {"epss_score": 0.00257, "epss_percentile": 0.4889}, "CVE-2012-5340": {"epss_score": 0.03366, "epss_percentile": 0.87002}, "CVE-2012-5341": {"epss_score": 0.03217, "epss_percentile": 0.86665}, "CVE-2012-5342": {"epss_score": 0.00454, "epss_percentile": 0.63256}, "CVE-2012-5343": {"epss_score": 0.0631, "epss_percentile": 0.90663}, "CVE-2012-5344": {"epss_score": 0.06646, "epss_percentile": 0.90912}, "CVE-2012-5345": {"epss_score": 0.09654, "epss_percentile": 0.92641}, "CVE-2012-5346": {"epss_score": 0.00942, "epss_percentile": 0.75763}, "CVE-2012-5347": {"epss_score": 0.07914, "epss_percentile": 0.91761}, "CVE-2012-5348": {"epss_score": 0.00622, "epss_percentile": 0.69516}, "CVE-2012-5349": {"epss_score": 0.04554, "epss_percentile": 0.88844}, "CVE-2012-5350": {"epss_score": 0.01469, "epss_percentile": 0.80489}, "CVE-2012-5351": {"epss_score": 0.0031, "epss_percentile": 0.53731}, "CVE-2012-5352": {"epss_score": 0.00232, "epss_percentile": 0.4596}, "CVE-2012-5353": {"epss_score": 0.00155, "epss_percentile": 0.36808}, "CVE-2012-5354": {"epss_score": 0.00885, "epss_percentile": 0.74942}, "CVE-2012-5355": {"epss_score": 0.00045, "epss_percentile": 0.13985}, "CVE-2012-5356": {"epss_score": 0.00666, "epss_percentile": 0.70694}, "CVE-2012-5357": {"epss_score": 0.82595, "epss_percentile": 0.99201}, "CVE-2012-5358": {"epss_score": 0.00577, "epss_percentile": 0.68173}, "CVE-2012-5359": {"epss_score": 0.00571, "epss_percentile": 0.67984}, "CVE-2012-5360": {"epss_score": 0.00788, "epss_percentile": 0.73332}, "CVE-2012-5361": {"epss_score": 0.01861, "epss_percentile": 0.8259}, "CVE-2012-5362": {"epss_score": 0.23175, "epss_percentile": 0.95746}, "CVE-2012-5363": {"epss_score": 0.00941, "epss_percentile": 0.75752}, "CVE-2012-5364": {"epss_score": 0.23175, "epss_percentile": 0.95746}, "CVE-2012-5365": {"epss_score": 0.00941, "epss_percentile": 0.75752}, "CVE-2012-5366": {"epss_score": 0.00941, "epss_percentile": 0.75752}, "CVE-2012-5367": {"epss_score": 0.01194, "epss_percentile": 0.78413}, "CVE-2012-5368": {"epss_score": 0.00428, "epss_percentile": 0.61931}, "CVE-2012-5370": {"epss_score": 0.00604, "epss_percentile": 0.6896}, "CVE-2012-5371": {"epss_score": 0.0281, "epss_percentile": 0.85715}, "CVE-2012-5372": {"epss_score": 0.00501, "epss_percentile": 0.65357}, "CVE-2012-5373": {"epss_score": 0.00512, "epss_percentile": 0.65868}, "CVE-2012-5374": {"epss_score": 0.00043, "epss_percentile": 0.13326}, "CVE-2012-5375": {"epss_score": 0.0008, "epss_percentile": 0.2403}, "CVE-2012-5376": {"epss_score": 0.0037, "epss_percentile": 0.58285}, "CVE-2012-5377": {"epss_score": 0.00266, "epss_percentile": 0.49877}, "CVE-2012-5378": {"epss_score": 0.00309, "epss_percentile": 0.53698}, "CVE-2012-5379": {"epss_score": 0.00321, "epss_percentile": 0.54735}, "CVE-2012-5380": {"epss_score": 0.0037, "epss_percentile": 0.58341}, "CVE-2012-5381": {"epss_score": 0.00402, "epss_percentile": 0.60271}, "CVE-2012-5382": {"epss_score": 0.00268, "epss_percentile": 0.5002}, "CVE-2012-5383": {"epss_score": 0.00343, "epss_percentile": 0.56465}, "CVE-2012-5384": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-5385": {"epss_score": 0.0127, "epss_percentile": 0.79048}, "CVE-2012-5386": {"epss_score": 0.0403, "epss_percentile": 0.8815}, "CVE-2012-5387": {"epss_score": 0.02033, "epss_percentile": 0.83342}, "CVE-2012-5388": {"epss_score": 0.00471, "epss_percentile": 0.63998}, "CVE-2012-5389": {"epss_score": 0.0474, "epss_percentile": 0.89079}, "CVE-2012-5390": {"epss_score": 0.01874, "epss_percentile": 0.82654}, "CVE-2012-5391": {"epss_score": 0.00758, "epss_percentile": 0.72774}, "CVE-2012-5394": {"epss_score": 0.00171, "epss_percentile": 0.38855}, "CVE-2012-5395": {"epss_score": 0.00537, "epss_percentile": 0.66902}, "CVE-2012-5409": {"epss_score": 0.35376, "epss_percentile": 0.96903}, "CVE-2012-5415": {"epss_score": 0.0033, "epss_percentile": 0.55497}, "CVE-2012-5416": {"epss_score": 0.00605, "epss_percentile": 0.68974}, "CVE-2012-5417": {"epss_score": 0.0246, "epss_percentile": 0.84821}, "CVE-2012-5419": {"epss_score": 0.0071, "epss_percentile": 0.71723}, "CVE-2012-5422": {"epss_score": 0.00363, "epss_percentile": 0.57874}, "CVE-2012-5424": {"epss_score": 0.00169, "epss_percentile": 0.38627}, "CVE-2012-5427": {"epss_score": 0.00403, "epss_percentile": 0.60368}, "CVE-2012-5429": {"epss_score": 0.00107, "epss_percentile": 0.29638}, "CVE-2012-5444": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2012-5445": {"epss_score": 0.00362, "epss_percentile": 0.57814}, "CVE-2012-5450": {"epss_score": 0.00275, "epss_percentile": 0.50662}, "CVE-2012-5451": {"epss_score": 0.09127, "epss_percentile": 0.92413}, "CVE-2012-5452": {"epss_score": 0.13096, "epss_percentile": 0.93874}, "CVE-2012-5453": {"epss_score": 0.00506, "epss_percentile": 0.6562}, "CVE-2012-5454": {"epss_score": 0.00612, "epss_percentile": 0.69232}, "CVE-2012-5455": {"epss_score": 0.00011, "epss_percentile": 0.01087}, "CVE-2012-5456": {"epss_score": 0.00258, "epss_percentile": 0.48988}, "CVE-2012-5458": {"epss_score": 0.00144, "epss_percentile": 0.35262}, "CVE-2012-5459": {"epss_score": 0.00213, "epss_percentile": 0.43848}, "CVE-2012-5460": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-5468": {"epss_score": 0.0608, "epss_percentile": 0.90462}, "CVE-2012-5469": {"epss_score": 0.01827, "epss_percentile": 0.82436}, "CVE-2012-5470": {"epss_score": 0.143, "epss_percentile": 0.94182}, "CVE-2012-5471": {"epss_score": 0.00498, "epss_percentile": 0.65242}, "CVE-2012-5472": {"epss_score": 0.00172, "epss_percentile": 0.3891}, "CVE-2012-5473": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2012-5474": {"epss_score": 0.00067, "epss_percentile": 0.21122}, "CVE-2012-5476": {"epss_score": 0.00146, "epss_percentile": 0.35609}, "CVE-2012-5477": {"epss_score": 0.00131, "epss_percentile": 0.33424}, "CVE-2012-5478": {"epss_score": 0.00518, "epss_percentile": 0.66138}, "CVE-2012-5479": {"epss_score": 0.00575, "epss_percentile": 0.681}, "CVE-2012-5480": {"epss_score": 0.00295, "epss_percentile": 0.52478}, "CVE-2012-5481": {"epss_score": 0.0015, "epss_percentile": 0.36184}, "CVE-2012-5482": {"epss_score": 0.01403, "epss_percentile": 0.80028}, "CVE-2012-5483": {"epss_score": 0.00111, "epss_percentile": 0.30254}, "CVE-2012-5484": {"epss_score": 0.00462, "epss_percentile": 0.6357}, "CVE-2012-5485": {"epss_score": 0.00599, "epss_percentile": 0.6879}, "CVE-2012-5486": {"epss_score": 0.00821, "epss_percentile": 0.73898}, "CVE-2012-5487": {"epss_score": 0.00788, "epss_percentile": 0.73342}, "CVE-2012-5488": {"epss_score": 0.0064, "epss_percentile": 0.69964}, "CVE-2012-5489": {"epss_score": 0.00575, "epss_percentile": 0.681}, "CVE-2012-5490": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-5491": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-5492": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-5493": {"epss_score": 0.00492, "epss_percentile": 0.65007}, "CVE-2012-5494": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-5495": {"epss_score": 0.00638, "epss_percentile": 0.69901}, "CVE-2012-5496": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2012-5497": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2012-5498": {"epss_score": 0.01001, "epss_percentile": 0.765}, "CVE-2012-5499": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2012-5500": {"epss_score": 0.00343, "epss_percentile": 0.56463}, "CVE-2012-5501": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-5502": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2012-5503": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-5504": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-5505": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-5506": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2012-5507": {"epss_score": 0.00276, "epss_percentile": 0.50766}, "CVE-2012-5508": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2012-5509": {"epss_score": 0.00099, "epss_percentile": 0.28374}, "CVE-2012-5510": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2012-5511": {"epss_score": 0.00093, "epss_percentile": 0.26701}, "CVE-2012-5512": {"epss_score": 0.00083, "epss_percentile": 0.24822}, "CVE-2012-5513": {"epss_score": 0.00143, "epss_percentile": 0.35096}, "CVE-2012-5514": {"epss_score": 0.0007, "epss_percentile": 0.21636}, "CVE-2012-5515": {"epss_score": 0.00141, "epss_percentile": 0.34862}, "CVE-2012-5516": {"epss_score": 0.00068, "epss_percentile": 0.21414}, "CVE-2012-5517": {"epss_score": 0.00058, "epss_percentile": 0.18366}, "CVE-2012-5518": {"epss_score": 0.0022, "epss_percentile": 0.4458}, "CVE-2012-5519": {"epss_score": 0.10228, "epss_percentile": 0.92902}, "CVE-2012-5520": {"epss_score": 0.02129, "epss_percentile": 0.83708}, "CVE-2012-5521": {"epss_score": 0.00331, "epss_percentile": 0.55531}, "CVE-2012-5522": {"epss_score": 0.00177, "epss_percentile": 0.39584}, "CVE-2012-5523": {"epss_score": 0.00447, "epss_percentile": 0.62985}, "CVE-2012-5524": {"epss_score": 0.00203, "epss_percentile": 0.42508}, "CVE-2012-5525": {"epss_score": 0.06889, "epss_percentile": 0.91094}, "CVE-2012-5526": {"epss_score": 0.0172, "epss_percentile": 0.81929}, "CVE-2012-5527": {"epss_score": 0.0271, "epss_percentile": 0.85491}, "CVE-2012-5529": {"epss_score": 0.0097, "epss_percentile": 0.7611}, "CVE-2012-5530": {"epss_score": 0.00144, "epss_percentile": 0.35259}, "CVE-2012-5531": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2012-5532": {"epss_score": 0.00127, "epss_percentile": 0.32916}, "CVE-2012-5533": {"epss_score": 0.42692, "epss_percentile": 0.97347}, "CVE-2012-5534": {"epss_score": 0.01972, "epss_percentile": 0.83108}, "CVE-2012-5535": {"epss_score": 0.00477, "epss_percentile": 0.6435}, "CVE-2012-5536": {"epss_score": 0.0005, "epss_percentile": 0.15761}, "CVE-2012-5537": {"epss_score": 0.00513, "epss_percentile": 0.65878}, "CVE-2012-5538": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2012-5539": {"epss_score": 0.00193, "epss_percentile": 0.41427}, "CVE-2012-5540": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-5541": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-5542": {"epss_score": 0.00254, "epss_percentile": 0.48535}, "CVE-2012-5543": {"epss_score": 0.00208, "epss_percentile": 0.43221}, "CVE-2012-5544": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2012-5545": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2012-5547": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2012-5548": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-5549": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2012-5550": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2012-5551": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-5552": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2012-5553": {"epss_score": 0.00257, "epss_percentile": 0.4889}, "CVE-2012-5554": {"epss_score": 0.00222, "epss_percentile": 0.4477}, "CVE-2012-5556": {"epss_score": 0.00151, "epss_percentile": 0.36223}, "CVE-2012-5557": {"epss_score": 0.00171, "epss_percentile": 0.3889}, "CVE-2012-5558": {"epss_score": 0.00188, "epss_percentile": 0.40842}, "CVE-2012-5559": {"epss_score": 0.00193, "epss_percentile": 0.4144}, "CVE-2012-5560": {"epss_score": 0.0006, "epss_percentile": 0.19009}, "CVE-2012-5561": {"epss_score": 0.00109, "epss_percentile": 0.29929}, "CVE-2012-5562": {"epss_score": 0.00098, "epss_percentile": 0.27675}, "CVE-2012-5563": {"epss_score": 0.00467, "epss_percentile": 0.63857}, "CVE-2012-5564": {"epss_score": 0.00025, "epss_percentile": 0.06137}, "CVE-2012-5565": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2012-5566": {"epss_score": 0.00648, "epss_percentile": 0.70223}, "CVE-2012-5567": {"epss_score": 0.00618, "epss_percentile": 0.69373}, "CVE-2012-5568": {"epss_score": 0.1383, "epss_percentile": 0.94069}, "CVE-2012-5569": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2012-5570": {"epss_score": 0.0025, "epss_percentile": 0.48126}, "CVE-2012-5571": {"epss_score": 0.00173, "epss_percentile": 0.39119}, "CVE-2012-5572": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2012-5573": {"epss_score": 0.01009, "epss_percentile": 0.76583}, "CVE-2012-5574": {"epss_score": 0.00408, "epss_percentile": 0.6065}, "CVE-2012-5575": {"epss_score": 0.09505, "epss_percentile": 0.92576}, "CVE-2012-5576": {"epss_score": 0.06336, "epss_percentile": 0.90677}, "CVE-2012-5577": {"epss_score": 0.00326, "epss_percentile": 0.55061}, "CVE-2012-5578": {"epss_score": 0.00039, "epss_percentile": 0.11618}, "CVE-2012-5580": {"epss_score": 0.00802, "epss_percentile": 0.73582}, "CVE-2012-5581": {"epss_score": 0.01642, "epss_percentile": 0.81511}, "CVE-2012-5582": {"epss_score": 0.00557, "epss_percentile": 0.67556}, "CVE-2012-5583": {"epss_score": 0.00152, "epss_percentile": 0.364}, "CVE-2012-5584": {"epss_score": 0.00214, "epss_percentile": 0.43993}, "CVE-2012-5585": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-5586": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2012-5587": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-5588": {"epss_score": 0.00208, "epss_percentile": 0.43221}, "CVE-2012-5589": {"epss_score": 0.0017, "epss_percentile": 0.38671}, "CVE-2012-5590": {"epss_score": 0.0038, "epss_percentile": 0.58957}, "CVE-2012-5591": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-5603": {"epss_score": 0.00253, "epss_percentile": 0.48454}, "CVE-2012-5604": {"epss_score": 0.00586, "epss_percentile": 0.68447}, "CVE-2012-5605": {"epss_score": 0.00082, "epss_percentile": 0.2447}, "CVE-2012-5606": {"epss_score": 0.00521, "epss_percentile": 0.66218}, "CVE-2012-5607": {"epss_score": 0.00377, "epss_percentile": 0.58711}, "CVE-2012-5608": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2012-5609": {"epss_score": 0.01029, "epss_percentile": 0.76833}, "CVE-2012-5610": {"epss_score": 0.01088, "epss_percentile": 0.77437}, "CVE-2012-5611": {"epss_score": 0.66648, "epss_percentile": 0.98472}, "CVE-2012-5612": {"epss_score": 0.66845, "epss_percentile": 0.98484}, "CVE-2012-5613": {"epss_score": 0.88831, "epss_percentile": 0.99492}, "CVE-2012-5614": {"epss_score": 0.08515, "epss_percentile": 0.92097}, "CVE-2012-5615": {"epss_score": 0.20664, "epss_percentile": 0.95397}, "CVE-2012-5616": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2012-5617": {"epss_score": 0.00095, "epss_percentile": 0.27165}, "CVE-2012-5618": {"epss_score": 0.00305, "epss_percentile": 0.53383}, "CVE-2012-5619": {"epss_score": 0.00105, "epss_percentile": 0.29291}, "CVE-2012-5621": {"epss_score": 0.01165, "epss_percentile": 0.78176}, "CVE-2012-5622": {"epss_score": 0.00164, "epss_percentile": 0.37957}, "CVE-2012-5623": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2012-5624": {"epss_score": 0.01869, "epss_percentile": 0.82626}, "CVE-2012-5625": {"epss_score": 0.01057, "epss_percentile": 0.77138}, "CVE-2012-5626": {"epss_score": 0.00176, "epss_percentile": 0.39401}, "CVE-2012-5627": {"epss_score": 0.03901, "epss_percentile": 0.87921}, "CVE-2012-5628": {"epss_score": 0.00038, "epss_percentile": 0.11209}, "CVE-2012-5629": {"epss_score": 0.00788, "epss_percentile": 0.73342}, "CVE-2012-5630": {"epss_score": 0.00119, "epss_percentile": 0.31614}, "CVE-2012-5631": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2012-5633": {"epss_score": 0.02299, "epss_percentile": 0.84305}, "CVE-2012-5634": {"epss_score": 0.00363, "epss_percentile": 0.579}, "CVE-2012-5635": {"epss_score": 0.0006, "epss_percentile": 0.1902}, "CVE-2012-5636": {"epss_score": 0.01624, "epss_percentile": 0.81408}, "CVE-2012-5638": {"epss_score": 0.00041, "epss_percentile": 0.12333}, "CVE-2012-5639": {"epss_score": 0.00607, "epss_percentile": 0.69056}, "CVE-2012-5640": {"epss_score": 0.00078, "epss_percentile": 0.23603}, "CVE-2012-5641": {"epss_score": 0.04379, "epss_percentile": 0.88621}, "CVE-2012-5642": {"epss_score": 0.01644, "epss_percentile": 0.81523}, "CVE-2012-5643": {"epss_score": 0.35413, "epss_percentile": 0.96907}, "CVE-2012-5644": {"epss_score": 0.00066, "epss_percentile": 0.20935}, "CVE-2012-5645": {"epss_score": 0.06123, "epss_percentile": 0.90497}, "CVE-2012-5646": {"epss_score": 0.00934, "epss_percentile": 0.75653}, "CVE-2012-5647": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-5648": {"epss_score": 0.00738, "epss_percentile": 0.72349}, "CVE-2012-5649": {"epss_score": 0.01836, "epss_percentile": 0.82468}, "CVE-2012-5650": {"epss_score": 0.00895, "epss_percentile": 0.75109}, "CVE-2012-5651": {"epss_score": 0.00813, "epss_percentile": 0.73759}, "CVE-2012-5652": {"epss_score": 0.00749, "epss_percentile": 0.72611}, "CVE-2012-5653": {"epss_score": 0.00829, "epss_percentile": 0.74007}, "CVE-2012-5654": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-5655": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2012-5656": {"epss_score": 0.00052, "epss_percentile": 0.16462}, "CVE-2012-5657": {"epss_score": 0.00719, "epss_percentile": 0.71946}, "CVE-2012-5658": {"epss_score": 0.00063, "epss_percentile": 0.19977}, "CVE-2012-5659": {"epss_score": 0.00065, "epss_percentile": 0.20539}, "CVE-2012-5660": {"epss_score": 0.00029, "epss_percentile": 0.07901}, "CVE-2012-5662": {"epss_score": 0.00197, "epss_percentile": 0.41964}, "CVE-2012-5663": {"epss_score": 0.00371, "epss_percentile": 0.58399}, "CVE-2012-5665": {"epss_score": 0.00431, "epss_percentile": 0.62053}, "CVE-2012-5666": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2012-5667": {"epss_score": 0.02243, "epss_percentile": 0.84121}, "CVE-2012-5668": {"epss_score": 0.02815, "epss_percentile": 0.85731}, "CVE-2012-5669": {"epss_score": 0.01687, "epss_percentile": 0.81758}, "CVE-2012-5670": {"epss_score": 0.02977, "epss_percentile": 0.8611}, "CVE-2012-5671": {"epss_score": 0.35729, "epss_percentile": 0.96928}, "CVE-2012-5672": {"epss_score": 0.19845, "epss_percentile": 0.95249}, "CVE-2012-5673": {"epss_score": 0.01347, "epss_percentile": 0.79648}, "CVE-2012-5674": {"epss_score": 0.01923, "epss_percentile": 0.82912}, "CVE-2012-5675": {"epss_score": 0.00108, "epss_percentile": 0.29845}, "CVE-2012-5676": {"epss_score": 0.04494, "epss_percentile": 0.88761}, "CVE-2012-5677": {"epss_score": 0.07927, "epss_percentile": 0.91766}, "CVE-2012-5678": {"epss_score": 0.07574, "epss_percentile": 0.91547}, "CVE-2012-5679": {"epss_score": 0.13327, "epss_percentile": 0.93934}, "CVE-2012-5680": {"epss_score": 0.24319, "epss_percentile": 0.95903}, "CVE-2012-5683": {"epss_score": 0.02577, "epss_percentile": 0.85145}, "CVE-2012-5684": {"epss_score": 0.09115, "epss_percentile": 0.92406}, "CVE-2012-5685": {"epss_score": 0.00546, "epss_percentile": 0.67223}, "CVE-2012-5686": {"epss_score": 0.14443, "epss_percentile": 0.94212}, "CVE-2012-5687": {"epss_score": 0.6748, "epss_percentile": 0.98509}, "CVE-2012-5688": {"epss_score": 0.0762, "epss_percentile": 0.91575}, "CVE-2012-5689": {"epss_score": 0.0381, "epss_percentile": 0.87759}, "CVE-2012-5690": {"epss_score": 0.03378, "epss_percentile": 0.87025}, "CVE-2012-5691": {"epss_score": 0.76917, "epss_percentile": 0.98911}, "CVE-2012-5692": {"epss_score": 0.83034, "epss_percentile": 0.99227}, "CVE-2012-5693": {"epss_score": 0.0089, "epss_percentile": 0.75032}, "CVE-2012-5694": {"epss_score": 0.00435, "epss_percentile": 0.62374}, "CVE-2012-5695": {"epss_score": 0.00463, "epss_percentile": 0.6367}, "CVE-2012-5696": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-5697": {"epss_score": 0.00044, "epss_percentile": 0.13447}, "CVE-2012-5698": {"epss_score": 0.0048, "epss_percentile": 0.64454}, "CVE-2012-5699": {"epss_score": 0.07803, "epss_percentile": 0.9169}, "CVE-2012-5700": {"epss_score": 0.05491, "epss_percentile": 0.8993}, "CVE-2012-5701": {"epss_score": 0.03389, "epss_percentile": 0.87047}, "CVE-2012-5702": {"epss_score": 0.01135, "epss_percentile": 0.77912}, "CVE-2012-5703": {"epss_score": 0.01277, "epss_percentile": 0.79117}, "CVE-2012-5704": {"epss_score": 0.00591, "epss_percentile": 0.68592}, "CVE-2012-5705": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2012-5717": {"epss_score": 0.0034, "epss_percentile": 0.56224}, "CVE-2012-5723": {"epss_score": 0.00182, "epss_percentile": 0.40206}, "CVE-2012-5744": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-5756": {"epss_score": 0.00463, "epss_percentile": 0.63697}, "CVE-2012-5757": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2012-5758": {"epss_score": 0.03043, "epss_percentile": 0.86277}, "CVE-2012-5759": {"epss_score": 0.00776, "epss_percentile": 0.73094}, "CVE-2012-5760": {"epss_score": 0.00256, "epss_percentile": 0.48791}, "CVE-2012-5761": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2012-5762": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2012-5763": {"epss_score": 0.00109, "epss_percentile": 0.2996}, "CVE-2012-5765": {"epss_score": 0.00254, "epss_percentile": 0.48513}, "CVE-2012-5766": {"epss_score": 0.00302, "epss_percentile": 0.5309}, "CVE-2012-5767": {"epss_score": 0.00322, "epss_percentile": 0.54786}, "CVE-2012-5769": {"epss_score": 0.00616, "epss_percentile": 0.69323}, "CVE-2012-5770": {"epss_score": 0.00259, "epss_percentile": 0.49037}, "CVE-2012-5776": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2012-5777": {"epss_score": 0.00629, "epss_percentile": 0.69684}, "CVE-2012-5780": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5781": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5782": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5783": {"epss_score": 0.00649, "epss_percentile": 0.70232}, "CVE-2012-5784": {"epss_score": 0.01203, "epss_percentile": 0.785}, "CVE-2012-5785": {"epss_score": 0.00493, "epss_percentile": 0.65056}, "CVE-2012-5786": {"epss_score": 0.00096, "epss_percentile": 0.27261}, "CVE-2012-5787": {"epss_score": 0.0016, "epss_percentile": 0.37431}, "CVE-2012-5788": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5789": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5790": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5791": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5792": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5793": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5794": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5795": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5796": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5797": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5798": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5799": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5800": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5801": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5802": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5803": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5804": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5805": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5806": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5807": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5808": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5809": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5810": {"epss_score": 0.00111, "epss_percentile": 0.30245}, "CVE-2012-5811": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5812": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5813": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5814": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5815": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5816": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5817": {"epss_score": 0.00132, "epss_percentile": 0.33552}, "CVE-2012-5818": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5819": {"epss_score": 0.00146, "epss_percentile": 0.35627}, "CVE-2012-5820": {"epss_score": 0.00051, "epss_percentile": 0.16298}, "CVE-2012-5821": {"epss_score": 0.00237, "epss_percentile": 0.46662}, "CVE-2012-5822": {"epss_score": 0.00146, "epss_percentile": 0.35627}, "CVE-2012-5823": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2012-5824": {"epss_score": 0.00154, "epss_percentile": 0.36686}, "CVE-2012-5825": {"epss_score": 0.00147, "epss_percentile": 0.35691}, "CVE-2012-5827": {"epss_score": 0.00012, "epss_percentile": 0.0126}, "CVE-2012-5828": {"epss_score": 0.01877, "epss_percentile": 0.82663}, "CVE-2012-5829": {"epss_score": 0.06844, "epss_percentile": 0.91064}, "CVE-2012-5830": {"epss_score": 0.01446, "epss_percentile": 0.80329}, "CVE-2012-5833": {"epss_score": 0.02301, "epss_percentile": 0.8431}, "CVE-2012-5835": {"epss_score": 0.02068, "epss_percentile": 0.83464}, "CVE-2012-5836": {"epss_score": 0.01871, "epss_percentile": 0.82637}, "CVE-2012-5837": {"epss_score": 0.01642, "epss_percentile": 0.81508}, "CVE-2012-5838": {"epss_score": 0.02018, "epss_percentile": 0.83286}, "CVE-2012-5839": {"epss_score": 0.05209, "epss_percentile": 0.89613}, "CVE-2012-5840": {"epss_score": 0.04317, "epss_percentile": 0.88539}, "CVE-2012-5841": {"epss_score": 0.01544, "epss_percentile": 0.8096}, "CVE-2012-5842": {"epss_score": 0.0178, "epss_percentile": 0.82234}, "CVE-2012-5843": {"epss_score": 0.0299, "epss_percentile": 0.86141}, "CVE-2012-5849": {"epss_score": 0.05145, "epss_percentile": 0.89541}, "CVE-2012-5851": {"epss_score": 0.00344, "epss_percentile": 0.56504}, "CVE-2012-5853": {"epss_score": 0.00383, "epss_percentile": 0.59118}, "CVE-2012-5854": {"epss_score": 0.0661, "epss_percentile": 0.90886}, "CVE-2012-5855": {"epss_score": 0.00344, "epss_percentile": 0.56508}, "CVE-2012-5856": {"epss_score": 0.0027, "epss_percentile": 0.50203}, "CVE-2012-5858": {"epss_score": 0.11474, "epss_percentile": 0.93378}, "CVE-2012-5859": {"epss_score": 0.00996, "epss_percentile": 0.76444}, "CVE-2012-5860": {"epss_score": 0.00071, "epss_percentile": 0.22218}, "CVE-2012-5861": {"epss_score": 0.03685, "epss_percentile": 0.87568}, "CVE-2012-5862": {"epss_score": 0.18795, "epss_percentile": 0.9507}, "CVE-2012-5863": {"epss_score": 0.05711, "epss_percentile": 0.90141}, "CVE-2012-5864": {"epss_score": 0.15425, "epss_percentile": 0.94429}, "CVE-2012-5865": {"epss_score": 0.01008, "epss_percentile": 0.76573}, "CVE-2012-5866": {"epss_score": 0.00374, "epss_percentile": 0.5858}, "CVE-2012-5867": {"epss_score": 0.01079, "epss_percentile": 0.77359}, "CVE-2012-5868": {"epss_score": 0.01342, "epss_percentile": 0.79596}, "CVE-2012-5872": {"epss_score": 0.00056, "epss_percentile": 0.17748}, "CVE-2012-5873": {"epss_score": 0.00057, "epss_percentile": 0.18016}, "CVE-2012-5874": {"epss_score": 0.01191, "epss_percentile": 0.78394}, "CVE-2012-5875": {"epss_score": 0.27106, "epss_percentile": 0.96208}, "CVE-2012-5876": {"epss_score": 0.21872, "epss_percentile": 0.95569}, "CVE-2012-5877": {"epss_score": 0.1475, "epss_percentile": 0.94274}, "CVE-2012-5878": {"epss_score": 0.10613, "epss_percentile": 0.93048}, "CVE-2012-5879": {"epss_score": 0.11937, "epss_percentile": 0.93521}, "CVE-2012-5881": {"epss_score": 0.00256, "epss_percentile": 0.48819}, "CVE-2012-5882": {"epss_score": 0.00333, "epss_percentile": 0.55674}, "CVE-2012-5883": {"epss_score": 0.01197, "epss_percentile": 0.78446}, "CVE-2012-5884": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2012-5885": {"epss_score": 0.01688, "epss_percentile": 0.81762}, "CVE-2012-5886": {"epss_score": 0.00516, "epss_percentile": 0.66033}, "CVE-2012-5887": {"epss_score": 0.00845, "epss_percentile": 0.74282}, "CVE-2012-5888": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2012-5889": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-5890": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2012-5891": {"epss_score": 0.00185, "epss_percentile": 0.40572}, "CVE-2012-5892": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2012-5893": {"epss_score": 0.02219, "epss_percentile": 0.84044}, "CVE-2012-5894": {"epss_score": 0.00699, "epss_percentile": 0.71432}, "CVE-2012-5895": {"epss_score": 0.00383, "epss_percentile": 0.59122}, "CVE-2012-5896": {"epss_score": 0.82297, "epss_percentile": 0.99186}, "CVE-2012-5897": {"epss_score": 0.10666, "epss_percentile": 0.93062}, "CVE-2012-5898": {"epss_score": 0.00328, "epss_percentile": 0.55188}, "CVE-2012-5899": {"epss_score": 0.03547, "epss_percentile": 0.87332}, "CVE-2012-5900": {"epss_score": 0.01485, "epss_percentile": 0.806}, "CVE-2012-5901": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-5902": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-5903": {"epss_score": 0.02473, "epss_percentile": 0.84853}, "CVE-2012-5904": {"epss_score": 0.0842, "epss_percentile": 0.92042}, "CVE-2012-5905": {"epss_score": 0.16338, "epss_percentile": 0.94631}, "CVE-2012-5906": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2012-5907": {"epss_score": 0.14277, "epss_percentile": 0.94177}, "CVE-2012-5908": {"epss_score": 0.03025, "epss_percentile": 0.86239}, "CVE-2012-5909": {"epss_score": 0.00497, "epss_percentile": 0.65198}, "CVE-2012-5910": {"epss_score": 0.00601, "epss_percentile": 0.68862}, "CVE-2012-5911": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-5912": {"epss_score": 0.01062, "epss_percentile": 0.77178}, "CVE-2012-5913": {"epss_score": 0.01458, "epss_percentile": 0.80406}, "CVE-2012-5914": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-5915": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-5916": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-5917": {"epss_score": 0.14605, "epss_percentile": 0.94249}, "CVE-2012-5918": {"epss_score": 0.02154, "epss_percentile": 0.838}, "CVE-2012-5919": {"epss_score": 0.07096, "epss_percentile": 0.91246}, "CVE-2012-5920": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2012-5930": {"epss_score": 0.04537, "epss_percentile": 0.88818}, "CVE-2012-5931": {"epss_score": 0.04713, "epss_percentile": 0.8904}, "CVE-2012-5932": {"epss_score": 0.49753, "epss_percentile": 0.97704}, "CVE-2012-5936": {"epss_score": 0.00275, "epss_percentile": 0.50693}, "CVE-2012-5937": {"epss_score": 0.01532, "epss_percentile": 0.80893}, "CVE-2012-5938": {"epss_score": 0.00037, "epss_percentile": 0.10909}, "CVE-2012-5939": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2012-5940": {"epss_score": 0.00186, "epss_percentile": 0.40616}, "CVE-2012-5941": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2012-5942": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2012-5943": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2012-5945": {"epss_score": 0.22902, "epss_percentile": 0.95704}, "CVE-2012-5946": {"epss_score": 0.6617, "epss_percentile": 0.98453}, "CVE-2012-5947": {"epss_score": 0.22902, "epss_percentile": 0.95704}, "CVE-2012-5948": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2012-5949": {"epss_score": 0.00289, "epss_percentile": 0.52034}, "CVE-2012-5950": {"epss_score": 0.00103, "epss_percentile": 0.28976}, "CVE-2012-5951": {"epss_score": 0.00107, "epss_percentile": 0.29682}, "CVE-2012-5952": {"epss_score": 0.00216, "epss_percentile": 0.44139}, "CVE-2012-5953": {"epss_score": 0.00556, "epss_percentile": 0.67518}, "CVE-2012-5954": {"epss_score": 0.00278, "epss_percentile": 0.50881}, "CVE-2012-5955": {"epss_score": 0.06948, "epss_percentile": 0.91135}, "CVE-2012-5956": {"epss_score": 0.01508, "epss_percentile": 0.80761}, "CVE-2012-5958": {"epss_score": 0.88128, "epss_percentile": 0.99459}, "CVE-2012-5959": {"epss_score": 0.8239, "epss_percentile": 0.99192}, "CVE-2012-5960": {"epss_score": 0.55993, "epss_percentile": 0.98005}, "CVE-2012-5961": {"epss_score": 0.70128, "epss_percentile": 0.98619}, "CVE-2012-5962": {"epss_score": 0.70128, "epss_percentile": 0.98619}, "CVE-2012-5963": {"epss_score": 0.70128, "epss_percentile": 0.98619}, "CVE-2012-5964": {"epss_score": 0.70128, "epss_percentile": 0.98619}, "CVE-2012-5965": {"epss_score": 0.69491, "epss_percentile": 0.98589}, "CVE-2012-5966": {"epss_score": 0.00102, "epss_percentile": 0.28751}, "CVE-2012-5967": {"epss_score": 0.00218, "epss_percentile": 0.44359}, "CVE-2012-5968": {"epss_score": 0.00076, "epss_percentile": 0.2323}, "CVE-2012-5969": {"epss_score": 0.00068, "epss_percentile": 0.21418}, "CVE-2012-5970": {"epss_score": 0.00286, "epss_percentile": 0.51723}, "CVE-2012-5972": {"epss_score": 0.07614, "epss_percentile": 0.91568}, "CVE-2012-5973": {"epss_score": 0.01876, "epss_percentile": 0.8266}, "CVE-2012-5975": {"epss_score": 0.25747, "epss_percentile": 0.96062}, "CVE-2012-5976": {"epss_score": 0.29742, "epss_percentile": 0.9647}, "CVE-2012-5977": {"epss_score": 0.01103, "epss_percentile": 0.7759}, "CVE-2012-5978": {"epss_score": 0.00182, "epss_percentile": 0.40256}, "CVE-2012-5990": {"epss_score": 0.00249, "epss_percentile": 0.48078}, "CVE-2012-5991": {"epss_score": 0.14063, "epss_percentile": 0.94127}, "CVE-2012-5992": {"epss_score": 0.00592, "epss_percentile": 0.6862}, "CVE-2012-6007": {"epss_score": 0.03485, "epss_percentile": 0.87226}, "CVE-2012-6026": {"epss_score": 0.00121, "epss_percentile": 0.31831}, "CVE-2012-6029": {"epss_score": 0.00236, "epss_percentile": 0.46381}, "CVE-2012-6030": {"epss_score": 0.00059, "epss_percentile": 0.18662}, "CVE-2012-6031": {"epss_score": 0.00059, "epss_percentile": 0.18672}, "CVE-2012-6032": {"epss_score": 0.00109, "epss_percentile": 0.29927}, "CVE-2012-6033": {"epss_score": 0.0007, "epss_percentile": 0.21985}, "CVE-2012-6034": {"epss_score": 0.00127, "epss_percentile": 0.3294}, "CVE-2012-6035": {"epss_score": 0.00107, "epss_percentile": 0.29606}, "CVE-2012-6036": {"epss_score": 0.00129, "epss_percentile": 0.33182}, "CVE-2012-6037": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-6038": {"epss_score": 0.04543, "epss_percentile": 0.8883}, "CVE-2012-6039": {"epss_score": 0.00424, "epss_percentile": 0.6164}, "CVE-2012-6040": {"epss_score": 0.00328, "epss_percentile": 0.55263}, "CVE-2012-6041": {"epss_score": 0.04873, "epss_percentile": 0.89235}, "CVE-2012-6042": {"epss_score": 0.07967, "epss_percentile": 0.91796}, "CVE-2012-6043": {"epss_score": 0.00404, "epss_percentile": 0.60434}, "CVE-2012-6044": {"epss_score": 0.0884, "epss_percentile": 0.9228}, "CVE-2012-6045": {"epss_score": 0.02187, "epss_percentile": 0.83925}, "CVE-2012-6046": {"epss_score": 0.12629, "epss_percentile": 0.93733}, "CVE-2012-6047": {"epss_score": 0.00211, "epss_percentile": 0.43714}, "CVE-2012-6048": {"epss_score": 0.07375, "epss_percentile": 0.91441}, "CVE-2012-6049": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-6050": {"epss_score": 0.08619, "epss_percentile": 0.92155}, "CVE-2012-6051": {"epss_score": 0.00248, "epss_percentile": 0.47971}, "CVE-2012-6052": {"epss_score": 0.00266, "epss_percentile": 0.49869}, "CVE-2012-6053": {"epss_score": 0.0064, "epss_percentile": 0.69972}, "CVE-2012-6054": {"epss_score": 0.00636, "epss_percentile": 0.69874}, "CVE-2012-6055": {"epss_score": 0.00658, "epss_percentile": 0.70489}, "CVE-2012-6056": {"epss_score": 0.00693, "epss_percentile": 0.71328}, "CVE-2012-6057": {"epss_score": 0.00636, "epss_percentile": 0.69874}, "CVE-2012-6058": {"epss_score": 0.00721, "epss_percentile": 0.71981}, "CVE-2012-6059": {"epss_score": 0.00726, "epss_percentile": 0.72078}, "CVE-2012-6060": {"epss_score": 0.00693, "epss_percentile": 0.71328}, "CVE-2012-6061": {"epss_score": 0.00721, "epss_percentile": 0.71981}, "CVE-2012-6062": {"epss_score": 0.00275, "epss_percentile": 0.5064}, "CVE-2012-6063": {"epss_score": 0.02138, "epss_percentile": 0.83733}, "CVE-2012-6064": {"epss_score": 0.00903, "epss_percentile": 0.752}, "CVE-2012-6065": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2012-6066": {"epss_score": 0.71244, "epss_percentile": 0.9866}, "CVE-2012-6067": {"epss_score": 0.01012, "epss_percentile": 0.76622}, "CVE-2012-6068": {"epss_score": 0.04384, "epss_percentile": 0.88629}, "CVE-2012-6069": {"epss_score": 0.02234, "epss_percentile": 0.84096}, "CVE-2012-6070": {"epss_score": 0.00639, "epss_percentile": 0.69953}, "CVE-2012-6071": {"epss_score": 0.00363, "epss_percentile": 0.57868}, "CVE-2012-6072": {"epss_score": 0.00113, "epss_percentile": 0.30614}, "CVE-2012-6073": {"epss_score": 0.0026, "epss_percentile": 0.49198}, "CVE-2012-6074": {"epss_score": 0.00225, "epss_percentile": 0.45226}, "CVE-2012-6075": {"epss_score": 0.07525, "epss_percentile": 0.91517}, "CVE-2012-6076": {"epss_score": 0.00113, "epss_percentile": 0.30734}, "CVE-2012-6077": {"epss_score": 0.41506, "epss_percentile": 0.97278}, "CVE-2012-6078": {"epss_score": 0.0102, "epss_percentile": 0.76738}, "CVE-2012-6079": {"epss_score": 0.0102, "epss_percentile": 0.76738}, "CVE-2012-6080": {"epss_score": 0.01547, "epss_percentile": 0.80973}, "CVE-2012-6081": {"epss_score": 0.79136, "epss_percentile": 0.9902}, "CVE-2012-6082": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2012-6083": {"epss_score": 0.09076, "epss_percentile": 0.92388}, "CVE-2012-6084": {"epss_score": 0.00463, "epss_percentile": 0.63686}, "CVE-2012-6085": {"epss_score": 0.02306, "epss_percentile": 0.84324}, "CVE-2012-6086": {"epss_score": 0.00194, "epss_percentile": 0.41556}, "CVE-2012-6087": {"epss_score": 0.00155, "epss_percentile": 0.36786}, "CVE-2012-6088": {"epss_score": 0.00198, "epss_percentile": 0.42003}, "CVE-2012-6089": {"epss_score": 0.02548, "epss_percentile": 0.85069}, "CVE-2012-6090": {"epss_score": 0.02104, "epss_percentile": 0.83621}, "CVE-2012-6091": {"epss_score": 0.01577, "epss_percentile": 0.8112}, "CVE-2012-6092": {"epss_score": 0.02524, "epss_percentile": 0.85009}, "CVE-2012-6093": {"epss_score": 0.02277, "epss_percentile": 0.84229}, "CVE-2012-6094": {"epss_score": 0.00685, "epss_percentile": 0.71133}, "CVE-2012-6095": {"epss_score": 0.00042, "epss_percentile": 0.12622}, "CVE-2012-6096": {"epss_score": 0.799, "epss_percentile": 0.9906}, "CVE-2012-6097": {"epss_score": 0.00319, "epss_percentile": 0.54463}, "CVE-2012-6098": {"epss_score": 0.00193, "epss_percentile": 0.41427}, "CVE-2012-6099": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2012-6100": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2012-6101": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2012-6102": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2012-6103": {"epss_score": 0.00126, "epss_percentile": 0.32707}, "CVE-2012-6104": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-6105": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-6106": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2012-6107": {"epss_score": 0.03383, "epss_percentile": 0.87036}, "CVE-2012-6108": {"epss_score": 0.00057, "epss_percentile": 0.18187}, "CVE-2012-6109": {"epss_score": 0.00828, "epss_percentile": 0.73995}, "CVE-2012-6110": {"epss_score": 0.00067, "epss_percentile": 0.21165}, "CVE-2012-6111": {"epss_score": 0.0039, "epss_percentile": 0.59544}, "CVE-2012-6112": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2012-6113": {"epss_score": 0.00405, "epss_percentile": 0.60454}, "CVE-2012-6114": {"epss_score": 0.0018, "epss_percentile": 0.39881}, "CVE-2012-6115": {"epss_score": 0.00064, "epss_percentile": 0.20163}, "CVE-2012-6116": {"epss_score": 0.0007, "epss_percentile": 0.21815}, "CVE-2012-6117": {"epss_score": 0.00099, "epss_percentile": 0.28374}, "CVE-2012-6118": {"epss_score": 0.00201, "epss_percentile": 0.42285}, "CVE-2012-6119": {"epss_score": 0.00057, "epss_percentile": 0.18076}, "CVE-2012-6120": {"epss_score": 0.00042, "epss_percentile": 0.12932}, "CVE-2012-6121": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2012-6122": {"epss_score": 0.02127, "epss_percentile": 0.83698}, "CVE-2012-6123": {"epss_score": 0.00425, "epss_percentile": 0.61721}, "CVE-2012-6124": {"epss_score": 0.0042, "epss_percentile": 0.61404}, "CVE-2012-6125": {"epss_score": 0.00635, "epss_percentile": 0.69817}, "CVE-2012-6128": {"epss_score": 0.00971, "epss_percentile": 0.76129}, "CVE-2012-6129": {"epss_score": 0.02677, "epss_percentile": 0.85405}, "CVE-2012-6130": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2012-6131": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2012-6132": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2012-6133": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2012-6134": {"epss_score": 0.00072, "epss_percentile": 0.22325}, "CVE-2012-6135": {"epss_score": 0.01273, "epss_percentile": 0.79087}, "CVE-2012-6136": {"epss_score": 0.00026, "epss_percentile": 0.06538}, "CVE-2012-6137": {"epss_score": 0.00188, "epss_percentile": 0.4081}, "CVE-2012-6139": {"epss_score": 0.10825, "epss_percentile": 0.93125}, "CVE-2012-6140": {"epss_score": 0.00026, "epss_percentile": 0.06485}, "CVE-2012-6141": {"epss_score": 0.01618, "epss_percentile": 0.81371}, "CVE-2012-6142": {"epss_score": 0.0169, "epss_percentile": 0.81772}, "CVE-2012-6143": {"epss_score": 0.02016, "epss_percentile": 0.83274}, "CVE-2012-6144": {"epss_score": 0.00595, "epss_percentile": 0.68679}, "CVE-2012-6145": {"epss_score": 0.00196, "epss_percentile": 0.41776}, "CVE-2012-6146": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2012-6147": {"epss_score": 0.00196, "epss_percentile": 0.41776}, "CVE-2012-6148": {"epss_score": 0.00224, "epss_percentile": 0.45056}, "CVE-2012-6149": {"epss_score": 0.00252, "epss_percentile": 0.48343}, "CVE-2012-6150": {"epss_score": 0.00139, "epss_percentile": 0.34584}, "CVE-2012-6151": {"epss_score": 0.27425, "epss_percentile": 0.96244}, "CVE-2012-6152": {"epss_score": 0.01147, "epss_percentile": 0.78008}, "CVE-2012-6153": {"epss_score": 0.00957, "epss_percentile": 0.75938}, "CVE-2012-6270": {"epss_score": 0.01984, "epss_percentile": 0.83151}, "CVE-2012-6271": {"epss_score": 0.00852, "epss_percentile": 0.74422}, "CVE-2012-6272": {"epss_score": 0.01112, "epss_percentile": 0.77675}, "CVE-2012-6273": {"epss_score": 0.00374, "epss_percentile": 0.58558}, "CVE-2012-6274": {"epss_score": 0.75339, "epss_percentile": 0.98839}, "CVE-2012-6275": {"epss_score": 0.76513, "epss_percentile": 0.98894}, "CVE-2012-6276": {"epss_score": 0.0944, "epss_percentile": 0.92549}, "CVE-2012-6277": {"epss_score": 0.0325, "epss_percentile": 0.8675}, "CVE-2012-6290": {"epss_score": 0.02907, "epss_percentile": 0.85964}, "CVE-2012-6297": {"epss_score": 0.00653, "epss_percentile": 0.70328}, "CVE-2012-6298": {"epss_score": 0.02664, "epss_percentile": 0.85375}, "CVE-2012-6299": {"epss_score": 0.0057, "epss_percentile": 0.67939}, "CVE-2012-6301": {"epss_score": 0.43028, "epss_percentile": 0.97367}, "CVE-2012-6302": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2012-6303": {"epss_score": 0.22611, "epss_percentile": 0.95658}, "CVE-2012-6306": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2012-6307": {"epss_score": 0.04354, "epss_percentile": 0.88589}, "CVE-2012-6309": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2012-6312": {"epss_score": 0.01143, "epss_percentile": 0.77984}, "CVE-2012-6313": {"epss_score": 0.06944, "epss_percentile": 0.91132}, "CVE-2012-6314": {"epss_score": 0.00675, "epss_percentile": 0.70896}, "CVE-2012-6316": {"epss_score": 0.00252, "epss_percentile": 0.48354}, "CVE-2012-6324": {"epss_score": 0.00121, "epss_percentile": 0.31996}, "CVE-2012-6325": {"epss_score": 0.00144, "epss_percentile": 0.3533}, "CVE-2012-6326": {"epss_score": 0.00403, "epss_percentile": 0.60363}, "CVE-2012-6329": {"epss_score": 0.83349, "epss_percentile": 0.99246}, "CVE-2012-6330": {"epss_score": 0.73251, "epss_percentile": 0.98744}, "CVE-2012-6333": {"epss_score": 0.0007, "epss_percentile": 0.21835}, "CVE-2012-6334": {"epss_score": 0.00098, "epss_percentile": 0.27723}, "CVE-2012-6335": {"epss_score": 0.00074, "epss_percentile": 0.22729}, "CVE-2012-6336": {"epss_score": 0.00082, "epss_percentile": 0.24457}, "CVE-2012-6337": {"epss_score": 0.00101, "epss_percentile": 0.28634}, "CVE-2012-6339": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2012-6340": {"epss_score": 0.00243, "epss_percentile": 0.47426}, "CVE-2012-6341": {"epss_score": 0.00474, "epss_percentile": 0.64152}, "CVE-2012-6342": {"epss_score": 0.0018, "epss_percentile": 0.39972}, "CVE-2012-6344": {"epss_score": 0.00229, "epss_percentile": 0.45638}, "CVE-2012-6345": {"epss_score": 0.00512, "epss_percentile": 0.65867}, "CVE-2012-6346": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2012-6347": {"epss_score": 0.0023, "epss_percentile": 0.4571}, "CVE-2012-6348": {"epss_score": 0.00085, "epss_percentile": 0.25192}, "CVE-2012-6349": {"epss_score": 0.07953, "epss_percentile": 0.91785}, "CVE-2012-6350": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2012-6352": {"epss_score": 0.00645, "epss_percentile": 0.70112}, "CVE-2012-6354": {"epss_score": 0.00139, "epss_percentile": 0.34608}, "CVE-2012-6355": {"epss_score": 0.00394, "epss_percentile": 0.59797}, "CVE-2012-6356": {"epss_score": 0.00394, "epss_percentile": 0.59797}, "CVE-2012-6357": {"epss_score": 0.00216, "epss_percentile": 0.44157}, "CVE-2012-6359": {"epss_score": 0.00515, "epss_percentile": 0.65983}, "CVE-2012-6360": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2012-6369": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-6371": {"epss_score": 0.00123, "epss_percentile": 0.32214}, "CVE-2012-6392": {"epss_score": 0.04287, "epss_percentile": 0.88496}, "CVE-2012-6395": {"epss_score": 0.00988, "epss_percentile": 0.76348}, "CVE-2012-6396": {"epss_score": 0.00363, "epss_percentile": 0.57874}, "CVE-2012-6397": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-6399": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2012-6422": {"epss_score": 0.06612, "epss_percentile": 0.90888}, "CVE-2012-6426": {"epss_score": 0.00254, "epss_percentile": 0.48504}, "CVE-2012-6427": {"epss_score": 0.00238, "epss_percentile": 0.46745}, "CVE-2012-6428": {"epss_score": 0.00242, "epss_percentile": 0.47378}, "CVE-2012-6429": {"epss_score": 0.49934, "epss_percentile": 0.97711}, "CVE-2012-6430": {"epss_score": 0.10931, "epss_percentile": 0.93163}, "CVE-2012-6431": {"epss_score": 0.0022, "epss_percentile": 0.44559}, "CVE-2012-6432": {"epss_score": 0.0043, "epss_percentile": 0.62018}, "CVE-2012-6433": {"epss_score": 0.00343, "epss_percentile": 0.56455}, "CVE-2012-6434": {"epss_score": 0.00195, "epss_percentile": 0.41691}, "CVE-2012-6435": {"epss_score": 0.06991, "epss_percentile": 0.91167}, "CVE-2012-6436": {"epss_score": 0.1339, "epss_percentile": 0.9395}, "CVE-2012-6437": {"epss_score": 0.11818, "epss_percentile": 0.93485}, "CVE-2012-6438": {"epss_score": 0.1339, "epss_percentile": 0.9395}, "CVE-2012-6439": {"epss_score": 0.00596, "epss_percentile": 0.68712}, "CVE-2012-6440": {"epss_score": 0.01169, "epss_percentile": 0.782}, "CVE-2012-6441": {"epss_score": 0.00999, "epss_percentile": 0.76476}, "CVE-2012-6442": {"epss_score": 0.10272, "epss_percentile": 0.92921}, "CVE-2012-6447": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2012-6448": {"epss_score": 0.00258, "epss_percentile": 0.49016}, "CVE-2012-6449": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2012-6451": {"epss_score": 0.018, "epss_percentile": 0.82323}, "CVE-2012-6452": {"epss_score": 0.00348, "epss_percentile": 0.56802}, "CVE-2012-6453": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-6458": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-6459": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2012-6460": {"epss_score": 0.00696, "epss_percentile": 0.71392}, "CVE-2012-6461": {"epss_score": 0.00131, "epss_percentile": 0.33349}, "CVE-2012-6462": {"epss_score": 0.00184, "epss_percentile": 0.40384}, "CVE-2012-6463": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-6464": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-6465": {"epss_score": 0.03795, "epss_percentile": 0.87734}, "CVE-2012-6466": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2012-6467": {"epss_score": 0.00245, "epss_percentile": 0.47683}, "CVE-2012-6468": {"epss_score": 0.06417, "epss_percentile": 0.90746}, "CVE-2012-6469": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2012-6470": {"epss_score": 0.31322, "epss_percentile": 0.9661}, "CVE-2012-6471": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2012-6472": {"epss_score": 0.00041, "epss_percentile": 0.12224}, "CVE-2012-6493": {"epss_score": 0.00385, "epss_percentile": 0.59227}, "CVE-2012-6494": {"epss_score": 0.00369, "epss_percentile": 0.58269}, "CVE-2012-6495": {"epss_score": 0.09865, "epss_percentile": 0.92743}, "CVE-2012-6496": {"epss_score": 0.02213, "epss_percentile": 0.84024}, "CVE-2012-6497": {"epss_score": 0.004, "epss_percentile": 0.60158}, "CVE-2012-6498": {"epss_score": 0.02487, "epss_percentile": 0.8489}, "CVE-2012-6499": {"epss_score": 0.52894, "epss_percentile": 0.97845}, "CVE-2012-6500": {"epss_score": 0.07453, "epss_percentile": 0.9148}, "CVE-2012-6501": {"epss_score": 0.0058, "epss_percentile": 0.68256}, "CVE-2012-6502": {"epss_score": 0.06501, "epss_percentile": 0.90803}, "CVE-2012-6503": {"epss_score": 0.00422, "epss_percentile": 0.61536}, "CVE-2012-6504": {"epss_score": 0.00641, "epss_percentile": 0.69994}, "CVE-2012-6505": {"epss_score": 0.06963, "epss_percentile": 0.9115}, "CVE-2012-6506": {"epss_score": 0.04745, "epss_percentile": 0.89087}, "CVE-2012-6507": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2012-6508": {"epss_score": 0.00228, "epss_percentile": 0.45529}, "CVE-2012-6509": {"epss_score": 0.04887, "epss_percentile": 0.89256}, "CVE-2012-6510": {"epss_score": 0.02678, "epss_percentile": 0.85408}, "CVE-2012-6511": {"epss_score": 0.00318, "epss_percentile": 0.5446}, "CVE-2012-6512": {"epss_score": 0.00852, "epss_percentile": 0.74421}, "CVE-2012-6513": {"epss_score": 0.00307, "epss_percentile": 0.53529}, "CVE-2012-6514": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-6515": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2012-6516": {"epss_score": 0.00481, "epss_percentile": 0.64488}, "CVE-2012-6517": {"epss_score": 0.05937, "epss_percentile": 0.90345}, "CVE-2012-6518": {"epss_score": 0.00713, "epss_percentile": 0.71803}, "CVE-2012-6519": {"epss_score": 0.02203, "epss_percentile": 0.83986}, "CVE-2012-6520": {"epss_score": 0.01325, "epss_percentile": 0.79475}, "CVE-2012-6521": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-6522": {"epss_score": 0.24113, "epss_percentile": 0.95876}, "CVE-2012-6523": {"epss_score": 0.00867, "epss_percentile": 0.74655}, "CVE-2012-6524": {"epss_score": 0.00223, "epss_percentile": 0.44964}, "CVE-2012-6525": {"epss_score": 0.00203, "epss_percentile": 0.42503}, "CVE-2012-6526": {"epss_score": 0.00438, "epss_percentile": 0.62561}, "CVE-2012-6527": {"epss_score": 0.00355, "epss_percentile": 0.57258}, "CVE-2012-6528": {"epss_score": 0.0631, "epss_percentile": 0.90663}, "CVE-2012-6529": {"epss_score": 0.00289, "epss_percentile": 0.52038}, "CVE-2012-6530": {"epss_score": 0.63819, "epss_percentile": 0.98351}, "CVE-2012-6531": {"epss_score": 0.00905, "epss_percentile": 0.75242}, "CVE-2012-6532": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2012-6533": {"epss_score": 0.00092, "epss_percentile": 0.2646}, "CVE-2012-6534": {"epss_score": 0.10056, "epss_percentile": 0.92832}, "CVE-2012-6535": {"epss_score": 0.05355, "epss_percentile": 0.89778}, "CVE-2012-6536": {"epss_score": 0.00055, "epss_percentile": 0.17376}, "CVE-2012-6537": {"epss_score": 0.0008, "epss_percentile": 0.24155}, "CVE-2012-6538": {"epss_score": 0.00058, "epss_percentile": 0.1843}, "CVE-2012-6539": {"epss_score": 0.00058, "epss_percentile": 0.18268}, "CVE-2012-6540": {"epss_score": 0.00058, "epss_percentile": 0.18268}, "CVE-2012-6541": {"epss_score": 0.00056, "epss_percentile": 0.17884}, "CVE-2012-6542": {"epss_score": 0.00088, "epss_percentile": 0.2571}, "CVE-2012-6543": {"epss_score": 0.00057, "epss_percentile": 0.18192}, "CVE-2012-6544": {"epss_score": 0.00076, "epss_percentile": 0.23151}, "CVE-2012-6545": {"epss_score": 0.00076, "epss_percentile": 0.23151}, "CVE-2012-6546": {"epss_score": 0.00013, "epss_percentile": 0.01545}, "CVE-2012-6547": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2012-6548": {"epss_score": 0.00027, "epss_percentile": 0.07085}, "CVE-2012-6549": {"epss_score": 0.00025, "epss_percentile": 0.06279}, "CVE-2012-6550": {"epss_score": 0.0408, "epss_percentile": 0.88216}, "CVE-2012-6551": {"epss_score": 0.0528, "epss_percentile": 0.89687}, "CVE-2012-6552": {"epss_score": 0.00322, "epss_percentile": 0.54801}, "CVE-2012-6553": {"epss_score": 0.09781, "epss_percentile": 0.927}, "CVE-2012-6554": {"epss_score": 0.65518, "epss_percentile": 0.98424}, "CVE-2012-6555": {"epss_score": 0.00341, "epss_percentile": 0.56318}, "CVE-2012-6556": {"epss_score": 0.0043, "epss_percentile": 0.62004}, "CVE-2012-6557": {"epss_score": 0.00349, "epss_percentile": 0.56862}, "CVE-2012-6558": {"epss_score": 0.09781, "epss_percentile": 0.927}, "CVE-2012-6559": {"epss_score": 0.00372, "epss_percentile": 0.58456}, "CVE-2012-6560": {"epss_score": 0.00277, "epss_percentile": 0.50776}, "CVE-2012-6561": {"epss_score": 0.00396, "epss_percentile": 0.59901}, "CVE-2012-6562": {"epss_score": 0.00478, "epss_percentile": 0.64371}, "CVE-2012-6563": {"epss_score": 0.00387, "epss_percentile": 0.59332}, "CVE-2012-6564": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-6565": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2012-6566": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-6567": {"epss_score": 0.00501, "epss_percentile": 0.65365}, "CVE-2012-6568": {"epss_score": 0.0014, "epss_percentile": 0.34776}, "CVE-2012-6569": {"epss_score": 0.03038, "epss_percentile": 0.86267}, "CVE-2012-6570": {"epss_score": 0.0085, "epss_percentile": 0.74385}, "CVE-2012-6571": {"epss_score": 0.00196, "epss_percentile": 0.41744}, "CVE-2012-6572": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-6573": {"epss_score": 0.00567, "epss_percentile": 0.67854}, "CVE-2012-6574": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-6575": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2012-6576": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2012-6577": {"epss_score": 0.00249, "epss_percentile": 0.48042}, "CVE-2012-6578": {"epss_score": 0.00258, "epss_percentile": 0.48952}, "CVE-2012-6579": {"epss_score": 0.00247, "epss_percentile": 0.47894}, "CVE-2012-6580": {"epss_score": 0.00131, "epss_percentile": 0.33349}, "CVE-2012-6581": {"epss_score": 0.00395, "epss_percentile": 0.59816}, "CVE-2012-6582": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2012-6583": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2012-6584": {"epss_score": 0.0021, "epss_percentile": 0.43602}, "CVE-2012-6585": {"epss_score": 0.00403, "epss_percentile": 0.60356}, "CVE-2012-6586": {"epss_score": 0.00472, "epss_percentile": 0.6406}, "CVE-2012-6587": {"epss_score": 0.00382, "epss_percentile": 0.59072}, "CVE-2012-6588": {"epss_score": 0.0021, "epss_percentile": 0.43602}, "CVE-2012-6589": {"epss_score": 0.00387, "epss_percentile": 0.59296}, "CVE-2012-6590": {"epss_score": 0.00204, "epss_percentile": 0.42595}, "CVE-2012-6591": {"epss_score": 0.00856, "epss_percentile": 0.74484}, "CVE-2012-6592": {"epss_score": 0.04065, "epss_percentile": 0.88198}, "CVE-2012-6593": {"epss_score": 0.04065, "epss_percentile": 0.88198}, "CVE-2012-6594": {"epss_score": 0.00856, "epss_percentile": 0.74484}, "CVE-2012-6595": {"epss_score": 0.00703, "epss_percentile": 0.71543}, "CVE-2012-6596": {"epss_score": 0.00232, "epss_percentile": 0.45926}, "CVE-2012-6597": {"epss_score": 0.00351, "epss_percentile": 0.57049}, "CVE-2012-6598": {"epss_score": 0.00703, "epss_percentile": 0.71543}, "CVE-2012-6599": {"epss_score": 0.00703, "epss_percentile": 0.71543}, "CVE-2012-6600": {"epss_score": 0.00703, "epss_percentile": 0.71543}, "CVE-2012-6601": {"epss_score": 0.11257, "epss_percentile": 0.93281}, "CVE-2012-6602": {"epss_score": 0.00856, "epss_percentile": 0.74484}, "CVE-2012-6603": {"epss_score": 0.02349, "epss_percentile": 0.84464}, "CVE-2012-6604": {"epss_score": 0.0241, "epss_percentile": 0.84662}, "CVE-2012-6605": {"epss_score": 0.0241, "epss_percentile": 0.84662}, "CVE-2012-6606": {"epss_score": 0.00229, "epss_percentile": 0.45556}, "CVE-2012-6607": {"epss_score": 0.00046, "epss_percentile": 0.14411}, "CVE-2012-6608": {"epss_score": 0.00748, "epss_percentile": 0.72587}, "CVE-2012-6609": {"epss_score": 0.00413, "epss_percentile": 0.61004}, "CVE-2012-6610": {"epss_score": 0.56094, "epss_percentile": 0.98007}, "CVE-2012-6611": {"epss_score": 0.01008, "epss_percentile": 0.76568}, "CVE-2012-6612": {"epss_score": 0.01186, "epss_percentile": 0.78348}, "CVE-2012-6613": {"epss_score": 0.0098, "epss_percentile": 0.7627}, "CVE-2012-6614": {"epss_score": 0.06109, "epss_percentile": 0.90486}, "CVE-2012-6615": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2012-6616": {"epss_score": 0.00767, "epss_percentile": 0.72955}, "CVE-2012-6617": {"epss_score": 0.00707, "epss_percentile": 0.71641}, "CVE-2012-6618": {"epss_score": 0.01047, "epss_percentile": 0.77036}, "CVE-2012-6619": {"epss_score": 0.02533, "epss_percentile": 0.8503}, "CVE-2012-6620": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2012-6621": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2012-6622": {"epss_score": 0.04086, "epss_percentile": 0.88227}, "CVE-2012-6623": {"epss_score": 0.00377, "epss_percentile": 0.58717}, "CVE-2012-6624": {"epss_score": 0.01795, "epss_percentile": 0.82303}, "CVE-2012-6625": {"epss_score": 0.05326, "epss_percentile": 0.89735}, "CVE-2012-6626": {"epss_score": 0.01085, "epss_percentile": 0.77403}, "CVE-2012-6627": {"epss_score": 0.00357, "epss_percentile": 0.5745}, "CVE-2012-6628": {"epss_score": 0.00306, "epss_percentile": 0.53464}, "CVE-2012-6629": {"epss_score": 0.00128, "epss_percentile": 0.32945}, "CVE-2012-6630": {"epss_score": 0.00357, "epss_percentile": 0.5745}, "CVE-2012-6631": {"epss_score": 0.00178, "epss_percentile": 0.39675}, "CVE-2012-6632": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2012-6633": {"epss_score": 0.00392, "epss_percentile": 0.5967}, "CVE-2012-6634": {"epss_score": 0.00807, "epss_percentile": 0.73667}, "CVE-2012-6635": {"epss_score": 0.00688, "epss_percentile": 0.71191}, "CVE-2012-6636": {"epss_score": 0.63616, "epss_percentile": 0.98341}, "CVE-2012-6637": {"epss_score": 0.01268, "epss_percentile": 0.79028}, "CVE-2012-6638": {"epss_score": 0.01107, "epss_percentile": 0.77626}, "CVE-2012-6639": {"epss_score": 0.01199, "epss_percentile": 0.78464}, "CVE-2012-6640": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2012-6641": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2012-6642": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2012-6643": {"epss_score": 0.0564, "epss_percentile": 0.90075}, "CVE-2012-6644": {"epss_score": 0.02519, "epss_percentile": 0.84995}, "CVE-2012-6645": {"epss_score": 0.00946, "epss_percentile": 0.7581}, "CVE-2012-6646": {"epss_score": 0.00054, "epss_percentile": 0.17366}, "CVE-2012-6647": {"epss_score": 0.00046, "epss_percentile": 0.14175}, "CVE-2012-6648": {"epss_score": 0.00059, "epss_percentile": 0.18714}, "CVE-2012-6649": {"epss_score": 0.4494, "epss_percentile": 0.97462}, "CVE-2012-6651": {"epss_score": 0.00401, "epss_percentile": 0.6023}, "CVE-2012-6652": {"epss_score": 0.0226, "epss_percentile": 0.84187}, "CVE-2012-6653": {"epss_score": 0.03727, "epss_percentile": 0.87635}, "CVE-2012-6654": {"epss_score": 0.00526, "epss_percentile": 0.66403}, "CVE-2012-6655": {"epss_score": 0.00034, "epss_percentile": 0.09741}, "CVE-2012-6656": {"epss_score": 0.0141, "epss_percentile": 0.80079}, "CVE-2012-6657": {"epss_score": 0.00122, "epss_percentile": 0.32124}, "CVE-2012-6658": {"epss_score": 0.01446, "epss_percentile": 0.80326}, "CVE-2012-6659": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2012-6660": {"epss_score": 0.00568, "epss_percentile": 0.67896}, "CVE-2012-6661": {"epss_score": 0.00403, "epss_percentile": 0.60354}, "CVE-2012-6662": {"epss_score": 0.07349, "epss_percentile": 0.91424}, "CVE-2012-6663": {"epss_score": 0.2314, "epss_percentile": 0.95739}, "CVE-2012-6664": {"epss_score": 0.73279, "epss_percentile": 0.98745}, "CVE-2012-6665": {"epss_score": 0.064, "epss_percentile": 0.90727}, "CVE-2012-6666": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2012-6667": {"epss_score": 0.00683, "epss_percentile": 0.71095}, "CVE-2012-6668": {"epss_score": 0.00272, "epss_percentile": 0.50396}, "CVE-2012-6670": {"epss_score": 0.00272, "epss_percentile": 0.50396}, "CVE-2012-6671": {"epss_score": 0.00272, "epss_percentile": 0.50396}, "CVE-2012-6682": {"epss_score": 0.00291, "epss_percentile": 0.52159}, "CVE-2012-6684": {"epss_score": 0.00441, "epss_percentile": 0.62679}, "CVE-2012-6685": {"epss_score": 0.00323, "epss_percentile": 0.54879}, "CVE-2012-6687": {"epss_score": 0.2551, "epss_percentile": 0.96036}, "CVE-2012-6689": {"epss_score": 0.00064, "epss_percentile": 0.20345}, "CVE-2012-6691": {"epss_score": 0.00244, "epss_percentile": 0.47525}, "CVE-2012-6692": {"epss_score": 0.00625, "epss_percentile": 0.6959}, "CVE-2012-6693": {"epss_score": 0.00624, "epss_percentile": 0.69573}, "CVE-2012-6694": {"epss_score": 0.00624, "epss_percentile": 0.69573}, "CVE-2012-6695": {"epss_score": 0.00624, "epss_percentile": 0.69573}, "CVE-2012-6696": {"epss_score": 0.0065, "epss_percentile": 0.70247}, "CVE-2012-6697": {"epss_score": 0.01098, "epss_percentile": 0.77545}, "CVE-2012-6698": {"epss_score": 0.00562, "epss_percentile": 0.67686}, "CVE-2012-6699": {"epss_score": 0.00562, "epss_percentile": 0.67686}, "CVE-2012-6700": {"epss_score": 0.00514, "epss_percentile": 0.6595}, "CVE-2012-6701": {"epss_score": 0.0008, "epss_percentile": 0.24065}, "CVE-2012-6702": {"epss_score": 0.00642, "epss_percentile": 0.70034}, "CVE-2012-6703": {"epss_score": 0.00085, "epss_percentile": 0.25098}, "CVE-2012-6704": {"epss_score": 0.00125, "epss_percentile": 0.32531}, "CVE-2012-6705": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2012-6706": {"epss_score": 0.02429, "epss_percentile": 0.84723}, "CVE-2012-6707": {"epss_score": 0.00182, "epss_percentile": 0.40148}, "CVE-2012-6708": {"epss_score": 0.00902, "epss_percentile": 0.75183}, "CVE-2012-6709": {"epss_score": 0.00191, "epss_percentile": 0.41215}, "CVE-2012-6710": {"epss_score": 0.76484, "epss_percentile": 0.98892}, "CVE-2012-6711": {"epss_score": 0.00139, "epss_percentile": 0.34639}, "CVE-2012-6712": {"epss_score": 0.00736, "epss_percentile": 0.72306}, "CVE-2012-6713": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2012-6714": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2012-6715": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2012-6716": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2012-6717": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2012-6718": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2012-6719": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2012-6720": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2012-6721": {"epss_score": 0.00113, "epss_percentile": 0.30638}, "CVE-2013-0001": {"epss_score": 0.17144, "epss_percentile": 0.94781}, "CVE-2013-0002": {"epss_score": 0.61214, "epss_percentile": 0.98239}, "CVE-2013-0003": {"epss_score": 0.61322, "epss_percentile": 0.98243}, "CVE-2013-0004": {"epss_score": 0.10047, "epss_percentile": 0.92827}, "CVE-2013-0005": {"epss_score": 0.68156, "epss_percentile": 0.98533}, "CVE-2013-0006": {"epss_score": 0.65084, "epss_percentile": 0.98403}, "CVE-2013-0007": {"epss_score": 0.27196, "epss_percentile": 0.96219}, "CVE-2013-0008": {"epss_score": 0.17562, "epss_percentile": 0.94867}, "CVE-2013-0009": {"epss_score": 0.24926, "epss_percentile": 0.95966}, "CVE-2013-0010": {"epss_score": 0.24926, "epss_percentile": 0.95966}, "CVE-2013-0011": {"epss_score": 0.36315, "epss_percentile": 0.96969}, "CVE-2013-0013": {"epss_score": 0.15832, "epss_percentile": 0.94516}, "CVE-2013-0015": {"epss_score": 0.12679, "epss_percentile": 0.93747}, "CVE-2013-0018": {"epss_score": 0.4569, "epss_percentile": 0.97498}, "CVE-2013-0019": {"epss_score": 0.34063, "epss_percentile": 0.96825}, "CVE-2013-0020": {"epss_score": 0.39006, "epss_percentile": 0.97134}, "CVE-2013-0021": {"epss_score": 0.37408, "epss_percentile": 0.97044}, "CVE-2013-0022": {"epss_score": 0.31014, "epss_percentile": 0.96583}, "CVE-2013-0023": {"epss_score": 0.55123, "epss_percentile": 0.97962}, "CVE-2013-0024": {"epss_score": 0.4844, "epss_percentile": 0.97637}, "CVE-2013-0025": {"epss_score": 0.86052, "epss_percentile": 0.99364}, "CVE-2013-0026": {"epss_score": 0.4569, "epss_percentile": 0.97498}, "CVE-2013-0027": {"epss_score": 0.4569, "epss_percentile": 0.97498}, "CVE-2013-0028": {"epss_score": 0.4569, "epss_percentile": 0.97498}, "CVE-2013-0029": {"epss_score": 0.54129, "epss_percentile": 0.97913}, "CVE-2013-0030": {"epss_score": 0.34996, "epss_percentile": 0.96882}, "CVE-2013-0073": {"epss_score": 0.59169, "epss_percentile": 0.98152}, "CVE-2013-0074": {"epss_score": 0.93054, "epss_percentile": 0.99771}, "CVE-2013-0075": {"epss_score": 0.81532, "epss_percentile": 0.99142}, "CVE-2013-0076": {"epss_score": 0.00872, "epss_percentile": 0.74737}, "CVE-2013-0077": {"epss_score": 0.53392, "epss_percentile": 0.97874}, "CVE-2013-0078": {"epss_score": 0.00872, "epss_percentile": 0.74737}, "CVE-2013-0079": {"epss_score": 0.59512, "epss_percentile": 0.98168}, "CVE-2013-0080": {"epss_score": 0.50324, "epss_percentile": 0.97732}, "CVE-2013-0081": {"epss_score": 0.68919, "epss_percentile": 0.98567}, "CVE-2013-0082": {"epss_score": 0.53228, "epss_percentile": 0.97867}, "CVE-2013-0083": {"epss_score": 0.44121, "epss_percentile": 0.97419}, "CVE-2013-0084": {"epss_score": 0.33007, "epss_percentile": 0.9674}, "CVE-2013-0085": {"epss_score": 0.70109, "epss_percentile": 0.98617}, "CVE-2013-0086": {"epss_score": 0.34206, "epss_percentile": 0.96832}, "CVE-2013-0087": {"epss_score": 0.59114, "epss_percentile": 0.9815}, "CVE-2013-0088": {"epss_score": 0.39533, "epss_percentile": 0.97166}, "CVE-2013-0089": {"epss_score": 0.59114, "epss_percentile": 0.9815}, "CVE-2013-0090": {"epss_score": 0.18796, "epss_percentile": 0.95071}, "CVE-2013-0091": {"epss_score": 0.39533, "epss_percentile": 0.97166}, "CVE-2013-0092": {"epss_score": 0.33061, "epss_percentile": 0.96743}, "CVE-2013-0093": {"epss_score": 0.59114, "epss_percentile": 0.9815}, "CVE-2013-0094": {"epss_score": 0.59114, "epss_percentile": 0.9815}, "CVE-2013-0095": {"epss_score": 0.29252, "epss_percentile": 0.96427}, "CVE-2013-0096": {"epss_score": 0.41251, "epss_percentile": 0.97262}, "CVE-2013-0107": {"epss_score": 0.00597, "epss_percentile": 0.68752}, "CVE-2013-0108": {"epss_score": 0.61426, "epss_percentile": 0.98248}, "CVE-2013-0109": {"epss_score": 0.05765, "epss_percentile": 0.90187}, "CVE-2013-0110": {"epss_score": 0.00149, "epss_percentile": 0.35991}, "CVE-2013-0111": {"epss_score": 0.00149, "epss_percentile": 0.35991}, "CVE-2013-0113": {"epss_score": 0.02674, "epss_percentile": 0.85397}, "CVE-2013-0118": {"epss_score": 0.00328, "epss_percentile": 0.55174}, "CVE-2013-0120": {"epss_score": 0.00963, "epss_percentile": 0.76019}, "CVE-2013-0122": {"epss_score": 0.00206, "epss_percentile": 0.43064}, "CVE-2013-0123": {"epss_score": 0.01163, "epss_percentile": 0.78162}, "CVE-2013-0124": {"epss_score": 0.00708, "epss_percentile": 0.71681}, "CVE-2013-0125": {"epss_score": 0.0243, "epss_percentile": 0.84727}, "CVE-2013-0126": {"epss_score": 0.00938, "epss_percentile": 0.75706}, "CVE-2013-0127": {"epss_score": 0.01074, "epss_percentile": 0.77298}, "CVE-2013-0128": {"epss_score": 0.00338, "epss_percentile": 0.56112}, "CVE-2013-0129": {"epss_score": 0.00212, "epss_percentile": 0.43796}, "CVE-2013-0130": {"epss_score": 0.00771, "epss_percentile": 0.73029}, "CVE-2013-0131": {"epss_score": 0.05221, "epss_percentile": 0.89626}, "CVE-2013-0132": {"epss_score": 0.00509, "epss_percentile": 0.65733}, "CVE-2013-0133": {"epss_score": 0.00176, "epss_percentile": 0.394}, "CVE-2013-0134": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2013-0135": {"epss_score": 0.03456, "epss_percentile": 0.87173}, "CVE-2013-0136": {"epss_score": 0.49421, "epss_percentile": 0.97685}, "CVE-2013-0137": {"epss_score": 0.62938, "epss_percentile": 0.98313}, "CVE-2013-0138": {"epss_score": 0.05003, "epss_percentile": 0.89381}, "CVE-2013-0139": {"epss_score": 0.00963, "epss_percentile": 0.76019}, "CVE-2013-0140": {"epss_score": 0.03811, "epss_percentile": 0.87763}, "CVE-2013-0141": {"epss_score": 0.00421, "epss_percentile": 0.61498}, "CVE-2013-0142": {"epss_score": 0.00396, "epss_percentile": 0.59876}, "CVE-2013-0143": {"epss_score": 0.07179, "epss_percentile": 0.91301}, "CVE-2013-0144": {"epss_score": 0.00081, "epss_percentile": 0.24363}, "CVE-2013-0145": {"epss_score": 0.314, "epss_percentile": 0.96617}, "CVE-2013-0148": {"epss_score": 0.00205, "epss_percentile": 0.42725}, "CVE-2013-0149": {"epss_score": 0.00998, "epss_percentile": 0.76474}, "CVE-2013-0150": {"epss_score": 0.01064, "epss_percentile": 0.77202}, "CVE-2013-0151": {"epss_score": 0.00127, "epss_percentile": 0.32843}, "CVE-2013-0152": {"epss_score": 0.00053, "epss_percentile": 0.16824}, "CVE-2013-0153": {"epss_score": 0.00119, "epss_percentile": 0.31603}, "CVE-2013-0154": {"epss_score": 0.00073, "epss_percentile": 0.22642}, "CVE-2013-0155": {"epss_score": 0.18174, "epss_percentile": 0.9497}, "CVE-2013-0156": {"epss_score": 0.91907, "epss_percentile": 0.99677}, "CVE-2013-0157": {"epss_score": 0.00058, "epss_percentile": 0.18415}, "CVE-2013-0158": {"epss_score": 0.00653, "epss_percentile": 0.70329}, "CVE-2013-0159": {"epss_score": 0.00039, "epss_percentile": 0.11629}, "CVE-2013-0160": {"epss_score": 0.00196, "epss_percentile": 0.41792}, "CVE-2013-0161": {"epss_score": 0.00298, "epss_percentile": 0.52823}, "CVE-2013-0162": {"epss_score": 0.00151, "epss_percentile": 0.36332}, "CVE-2013-0163": {"epss_score": 0.00122, "epss_percentile": 0.32057}, "CVE-2013-0164": {"epss_score": 0.00056, "epss_percentile": 0.17911}, "CVE-2013-0165": {"epss_score": 0.00345, "epss_percentile": 0.5655}, "CVE-2013-0166": {"epss_score": 0.11012, "epss_percentile": 0.93189}, "CVE-2013-0167": {"epss_score": 0.00096, "epss_percentile": 0.2737}, "CVE-2013-0168": {"epss_score": 0.00572, "epss_percentile": 0.68025}, "CVE-2013-0169": {"epss_score": 0.00773, "epss_percentile": 0.73059}, "CVE-2013-0170": {"epss_score": 0.2022, "epss_percentile": 0.95305}, "CVE-2013-0171": {"epss_score": 0.0322, "epss_percentile": 0.86673}, "CVE-2013-0172": {"epss_score": 0.00283, "epss_percentile": 0.51293}, "CVE-2013-0173": {"epss_score": 0.00351, "epss_percentile": 0.57031}, "CVE-2013-0174": {"epss_score": 0.00403, "epss_percentile": 0.60333}, "CVE-2013-0175": {"epss_score": 0.01272, "epss_percentile": 0.79082}, "CVE-2013-0176": {"epss_score": 0.01019, "epss_percentile": 0.76723}, "CVE-2013-0177": {"epss_score": 0.02354, "epss_percentile": 0.8448}, "CVE-2013-0178": {"epss_score": 0.0014, "epss_percentile": 0.347}, "CVE-2013-0179": {"epss_score": 0.01337, "epss_percentile": 0.79558}, "CVE-2013-0180": {"epss_score": 0.00045, "epss_percentile": 0.13721}, "CVE-2013-0181": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2013-0182": {"epss_score": 0.00463, "epss_percentile": 0.63633}, "CVE-2013-0183": {"epss_score": 0.01824, "epss_percentile": 0.82427}, "CVE-2013-0184": {"epss_score": 0.00677, "epss_percentile": 0.70964}, "CVE-2013-0185": {"epss_score": 0.0019, "epss_percentile": 0.4112}, "CVE-2013-0186": {"epss_score": 0.00401, "epss_percentile": 0.60246}, "CVE-2013-0187": {"epss_score": 0.0053, "epss_percentile": 0.66631}, "CVE-2013-0189": {"epss_score": 0.72194, "epss_percentile": 0.98699}, "CVE-2013-0190": {"epss_score": 0.00048, "epss_percentile": 0.151}, "CVE-2013-0191": {"epss_score": 0.00996, "epss_percentile": 0.76447}, "CVE-2013-0192": {"epss_score": 0.05924, "epss_percentile": 0.90325}, "CVE-2013-0193": {"epss_score": 0.00472, "epss_percentile": 0.64042}, "CVE-2013-0194": {"epss_score": 0.00472, "epss_percentile": 0.64042}, "CVE-2013-0195": {"epss_score": 0.00472, "epss_percentile": 0.64042}, "CVE-2013-0196": {"epss_score": 0.0011, "epss_percentile": 0.30107}, "CVE-2013-0197": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2013-0198": {"epss_score": 0.00051, "epss_percentile": 0.1614}, "CVE-2013-0199": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2013-0200": {"epss_score": 0.00076, "epss_percentile": 0.23225}, "CVE-2013-0201": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2013-0202": {"epss_score": 0.00402, "epss_percentile": 0.60275}, "CVE-2013-0203": {"epss_score": 0.00236, "epss_percentile": 0.46379}, "CVE-2013-0204": {"epss_score": 0.00485, "epss_percentile": 0.64739}, "CVE-2013-0205": {"epss_score": 0.00171, "epss_percentile": 0.38821}, "CVE-2013-0206": {"epss_score": 0.0149, "epss_percentile": 0.80631}, "CVE-2013-0207": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2013-0208": {"epss_score": 0.00953, "epss_percentile": 0.75885}, "CVE-2013-0209": {"epss_score": 0.80627, "epss_percentile": 0.99097}, "CVE-2013-0210": {"epss_score": 0.00502, "epss_percentile": 0.65404}, "CVE-2013-0211": {"epss_score": 0.01196, "epss_percentile": 0.78438}, "CVE-2013-0212": {"epss_score": 0.01203, "epss_percentile": 0.78494}, "CVE-2013-0213": {"epss_score": 0.11126, "epss_percentile": 0.93231}, "CVE-2013-0214": {"epss_score": 0.04872, "epss_percentile": 0.89233}, "CVE-2013-0215": {"epss_score": 0.00218, "epss_percentile": 0.44376}, "CVE-2013-0216": {"epss_score": 0.00079, "epss_percentile": 0.23801}, "CVE-2013-0217": {"epss_score": 0.00232, "epss_percentile": 0.4589}, "CVE-2013-0218": {"epss_score": 0.00047, "epss_percentile": 0.14916}, "CVE-2013-0219": {"epss_score": 0.00074, "epss_percentile": 0.22813}, "CVE-2013-0220": {"epss_score": 0.01922, "epss_percentile": 0.82904}, "CVE-2013-0221": {"epss_score": 0.06006, "epss_percentile": 0.90396}, "CVE-2013-0222": {"epss_score": 0.00143, "epss_percentile": 0.35106}, "CVE-2013-0223": {"epss_score": 0.00141, "epss_percentile": 0.3491}, "CVE-2013-0224": {"epss_score": 0.00058, "epss_percentile": 0.18407}, "CVE-2013-0225": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2013-0226": {"epss_score": 0.00366, "epss_percentile": 0.58066}, "CVE-2013-0227": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2013-0228": {"epss_score": 0.00069, "epss_percentile": 0.21566}, "CVE-2013-0229": {"epss_score": 0.77988, "epss_percentile": 0.98963}, "CVE-2013-0230": {"epss_score": 0.60172, "epss_percentile": 0.98196}, "CVE-2013-0231": {"epss_score": 0.00087, "epss_percentile": 0.25608}, "CVE-2013-0232": {"epss_score": 0.7823, "epss_percentile": 0.98975}, "CVE-2013-0233": {"epss_score": 0.68821, "epss_percentile": 0.98564}, "CVE-2013-0234": {"epss_score": 0.00545, "epss_percentile": 0.67158}, "CVE-2013-0235": {"epss_score": 0.65276, "epss_percentile": 0.98411}, "CVE-2013-0236": {"epss_score": 0.00418, "epss_percentile": 0.6127}, "CVE-2013-0237": {"epss_score": 0.0043, "epss_percentile": 0.62001}, "CVE-2013-0238": {"epss_score": 0.39225, "epss_percentile": 0.97147}, "CVE-2013-0239": {"epss_score": 0.04757, "epss_percentile": 0.89114}, "CVE-2013-0240": {"epss_score": 0.00476, "epss_percentile": 0.64279}, "CVE-2013-0241": {"epss_score": 0.00059, "epss_percentile": 0.18635}, "CVE-2013-0242": {"epss_score": 0.02113, "epss_percentile": 0.8365}, "CVE-2013-0243": {"epss_score": 0.00367, "epss_percentile": 0.58115}, "CVE-2013-0244": {"epss_score": 0.00443, "epss_percentile": 0.62804}, "CVE-2013-0245": {"epss_score": 0.00412, "epss_percentile": 0.60953}, "CVE-2013-0246": {"epss_score": 0.00405, "epss_percentile": 0.60465}, "CVE-2013-0247": {"epss_score": 0.0296, "epss_percentile": 0.8607}, "CVE-2013-0248": {"epss_score": 0.00068, "epss_percentile": 0.21342}, "CVE-2013-0249": {"epss_score": 0.44202, "epss_percentile": 0.97424}, "CVE-2013-0250": {"epss_score": 0.00943, "epss_percentile": 0.75774}, "CVE-2013-0251": {"epss_score": 0.08014, "epss_percentile": 0.91828}, "CVE-2013-0252": {"epss_score": 0.01679, "epss_percentile": 0.81722}, "CVE-2013-0253": {"epss_score": 0.00746, "epss_percentile": 0.7255}, "CVE-2013-0254": {"epss_score": 0.00086, "epss_percentile": 0.25373}, "CVE-2013-0255": {"epss_score": 0.03086, "epss_percentile": 0.86386}, "CVE-2013-0256": {"epss_score": 0.03584, "epss_percentile": 0.87389}, "CVE-2013-0257": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-0258": {"epss_score": 0.00265, "epss_percentile": 0.49816}, "CVE-2013-0259": {"epss_score": 0.00175, "epss_percentile": 0.39319}, "CVE-2013-0260": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2013-0261": {"epss_score": 0.00054, "epss_percentile": 0.17077}, "CVE-2013-0262": {"epss_score": 0.00826, "epss_percentile": 0.73972}, "CVE-2013-0263": {"epss_score": 0.05283, "epss_percentile": 0.89691}, "CVE-2013-0264": {"epss_score": 0.00144, "epss_percentile": 0.3526}, "CVE-2013-0265": {"epss_score": 0.00072, "epss_percentile": 0.22275}, "CVE-2013-0266": {"epss_score": 0.00043, "epss_percentile": 0.13168}, "CVE-2013-0267": {"epss_score": 0.00328, "epss_percentile": 0.55186}, "CVE-2013-0268": {"epss_score": 0.0152, "epss_percentile": 0.80826}, "CVE-2013-0269": {"epss_score": 0.14955, "epss_percentile": 0.94333}, "CVE-2013-0270": {"epss_score": 0.01809, "epss_percentile": 0.82362}, "CVE-2013-0271": {"epss_score": 0.00556, "epss_percentile": 0.67525}, "CVE-2013-0272": {"epss_score": 0.01896, "epss_percentile": 0.8275}, "CVE-2013-0273": {"epss_score": 0.02107, "epss_percentile": 0.83634}, "CVE-2013-0274": {"epss_score": 0.00474, "epss_percentile": 0.64151}, "CVE-2013-0275": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2013-0276": {"epss_score": 0.01439, "epss_percentile": 0.80293}, "CVE-2013-0277": {"epss_score": 0.06742, "epss_percentile": 0.90997}, "CVE-2013-0281": {"epss_score": 0.00665, "epss_percentile": 0.70672}, "CVE-2013-0282": {"epss_score": 0.00467, "epss_percentile": 0.63833}, "CVE-2013-0283": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2013-0284": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-0285": {"epss_score": 0.015, "epss_percentile": 0.80711}, "CVE-2013-0286": {"epss_score": 0.00078, "epss_percentile": 0.23555}, "CVE-2013-0287": {"epss_score": 0.00464, "epss_percentile": 0.63719}, "CVE-2013-0288": {"epss_score": 0.02899, "epss_percentile": 0.85949}, "CVE-2013-0289": {"epss_score": 0.00476, "epss_percentile": 0.64279}, "CVE-2013-0290": {"epss_score": 0.00056, "epss_percentile": 0.17807}, "CVE-2013-0291": {"epss_score": 0.20425, "epss_percentile": 0.95343}, "CVE-2013-0292": {"epss_score": 0.00265, "epss_percentile": 0.49819}, "CVE-2013-0293": {"epss_score": 0.00132, "epss_percentile": 0.33584}, "CVE-2013-0294": {"epss_score": 0.01875, "epss_percentile": 0.82657}, "CVE-2013-0296": {"epss_score": 0.00045, "epss_percentile": 0.13753}, "CVE-2013-0297": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-0298": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-0299": {"epss_score": 0.00118, "epss_percentile": 0.3146}, "CVE-2013-0300": {"epss_score": 0.00074, "epss_percentile": 0.22826}, "CVE-2013-0301": {"epss_score": 0.00118, "epss_percentile": 0.3146}, "CVE-2013-0302": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-0303": {"epss_score": 0.11282, "epss_percentile": 0.93291}, "CVE-2013-0304": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2013-0305": {"epss_score": 0.00245, "epss_percentile": 0.47673}, "CVE-2013-0306": {"epss_score": 0.00363, "epss_percentile": 0.57833}, "CVE-2013-0307": {"epss_score": 0.00284, "epss_percentile": 0.51425}, "CVE-2013-0308": {"epss_score": 0.02677, "epss_percentile": 0.85406}, "CVE-2013-0309": {"epss_score": 0.00048, "epss_percentile": 0.15045}, "CVE-2013-0310": {"epss_score": 0.00044, "epss_percentile": 0.13398}, "CVE-2013-0311": {"epss_score": 0.00216, "epss_percentile": 0.44136}, "CVE-2013-0312": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2013-0313": {"epss_score": 0.00044, "epss_percentile": 0.13669}, "CVE-2013-0314": {"epss_score": 0.00638, "epss_percentile": 0.699}, "CVE-2013-0315": {"epss_score": 0.00346, "epss_percentile": 0.56638}, "CVE-2013-0316": {"epss_score": 0.00629, "epss_percentile": 0.69668}, "CVE-2013-0317": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-0318": {"epss_score": 0.01416, "epss_percentile": 0.80141}, "CVE-2013-0319": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2013-0320": {"epss_score": 0.00197, "epss_percentile": 0.41904}, "CVE-2013-0321": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-0322": {"epss_score": 0.00365, "epss_percentile": 0.5799}, "CVE-2013-0323": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2013-0324": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2013-0325": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2013-0326": {"epss_score": 0.00112, "epss_percentile": 0.30543}, "CVE-2013-0327": {"epss_score": 0.00216, "epss_percentile": 0.44154}, "CVE-2013-0328": {"epss_score": 0.00224, "epss_percentile": 0.45056}, "CVE-2013-0329": {"epss_score": 0.00083, "epss_percentile": 0.24627}, "CVE-2013-0330": {"epss_score": 0.003, "epss_percentile": 0.52907}, "CVE-2013-0331": {"epss_score": 0.00395, "epss_percentile": 0.59808}, "CVE-2013-0332": {"epss_score": 0.31131, "epss_percentile": 0.96595}, "CVE-2013-0333": {"epss_score": 0.9119, "epss_percentile": 0.99625}, "CVE-2013-0334": {"epss_score": 0.00498, "epss_percentile": 0.65227}, "CVE-2013-0335": {"epss_score": 0.01036, "epss_percentile": 0.76917}, "CVE-2013-0336": {"epss_score": 0.01286, "epss_percentile": 0.79185}, "CVE-2013-0337": {"epss_score": 0.00655, "epss_percentile": 0.70363}, "CVE-2013-0338": {"epss_score": 0.00299, "epss_percentile": 0.52866}, "CVE-2013-0339": {"epss_score": 0.02394, "epss_percentile": 0.84613}, "CVE-2013-0340": {"epss_score": 0.00051, "epss_percentile": 0.16009}, "CVE-2013-0342": {"epss_score": 0.0129, "epss_percentile": 0.79216}, "CVE-2013-0343": {"epss_score": 0.00385, "epss_percentile": 0.59202}, "CVE-2013-0345": {"epss_score": 0.00047, "epss_percentile": 0.14779}, "CVE-2013-0346": {"epss_score": 0.0049, "epss_percentile": 0.64923}, "CVE-2013-0347": {"epss_score": 0.00083, "epss_percentile": 0.2471}, "CVE-2013-0348": {"epss_score": 0.00037, "epss_percentile": 0.10957}, "CVE-2013-0349": {"epss_score": 0.00058, "epss_percentile": 0.18268}, "CVE-2013-0350": {"epss_score": 0.00041, "epss_percentile": 0.12311}, "CVE-2013-0351": {"epss_score": 0.12334, "epss_percentile": 0.93643}, "CVE-2013-0352": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2013-0353": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0354": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2013-0355": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0356": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0357": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0358": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0359": {"epss_score": 0.00685, "epss_percentile": 0.71137}, "CVE-2013-0360": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0361": {"epss_score": 0.02954, "epss_percentile": 0.86059}, "CVE-2013-0362": {"epss_score": 0.00483, "epss_percentile": 0.64577}, "CVE-2013-0363": {"epss_score": 0.00588, "epss_percentile": 0.68505}, "CVE-2013-0364": {"epss_score": 0.00588, "epss_percentile": 0.68505}, "CVE-2013-0365": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-0366": {"epss_score": 0.02954, "epss_percentile": 0.86059}, "CVE-2013-0367": {"epss_score": 0.0064, "epss_percentile": 0.69968}, "CVE-2013-0368": {"epss_score": 0.0064, "epss_percentile": 0.69968}, "CVE-2013-0369": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2013-0370": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-0371": {"epss_score": 0.0064, "epss_percentile": 0.69968}, "CVE-2013-0372": {"epss_score": 0.00442, "epss_percentile": 0.62721}, "CVE-2013-0373": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0374": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0375": {"epss_score": 0.00396, "epss_percentile": 0.59851}, "CVE-2013-0376": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0377": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0378": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0379": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0380": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0381": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2013-0382": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0383": {"epss_score": 0.00565, "epss_percentile": 0.678}, "CVE-2013-0384": {"epss_score": 0.01415, "epss_percentile": 0.80137}, "CVE-2013-0385": {"epss_score": 0.00071, "epss_percentile": 0.22033}, "CVE-2013-0386": {"epss_score": 0.01415, "epss_percentile": 0.80137}, "CVE-2013-0387": {"epss_score": 0.00193, "epss_percentile": 0.41401}, "CVE-2013-0388": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0389": {"epss_score": 0.01415, "epss_percentile": 0.80137}, "CVE-2013-0390": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-0391": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2013-0392": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0393": {"epss_score": 0.00781, "epss_percentile": 0.73178}, "CVE-2013-0394": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2013-0395": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-0396": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-0397": {"epss_score": 0.2994, "epss_percentile": 0.96488}, "CVE-2013-0398": {"epss_score": 0.00891, "epss_percentile": 0.75048}, "CVE-2013-0399": {"epss_score": 0.00043, "epss_percentile": 0.13098}, "CVE-2013-0400": {"epss_score": 0.00043, "epss_percentile": 0.13098}, "CVE-2013-0401": {"epss_score": 0.1295, "epss_percentile": 0.93827}, "CVE-2013-0402": {"epss_score": 0.0753, "epss_percentile": 0.91519}, "CVE-2013-0403": {"epss_score": 0.00055, "epss_percentile": 0.17527}, "CVE-2013-0404": {"epss_score": 0.00058, "epss_percentile": 0.18407}, "CVE-2013-0405": {"epss_score": 0.00242, "epss_percentile": 0.47388}, "CVE-2013-0406": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2013-0407": {"epss_score": 0.00043, "epss_percentile": 0.13124}, "CVE-2013-0408": {"epss_score": 0.00363, "epss_percentile": 0.57821}, "CVE-2013-0409": {"epss_score": 0.04346, "epss_percentile": 0.88576}, "CVE-2013-0410": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2013-0411": {"epss_score": 0.00172, "epss_percentile": 0.38992}, "CVE-2013-0412": {"epss_score": 0.00053, "epss_percentile": 0.17014}, "CVE-2013-0413": {"epss_score": 0.00234, "epss_percentile": 0.46171}, "CVE-2013-0414": {"epss_score": 0.00049, "epss_percentile": 0.15648}, "CVE-2013-0415": {"epss_score": 0.00043, "epss_percentile": 0.13098}, "CVE-2013-0416": {"epss_score": 0.00194, "epss_percentile": 0.4156}, "CVE-2013-0417": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2013-0418": {"epss_score": 0.25098, "epss_percentile": 0.95985}, "CVE-2013-0419": {"epss_score": 0.08026, "epss_percentile": 0.91838}, "CVE-2013-0420": {"epss_score": 0.00112, "epss_percentile": 0.30448}, "CVE-2013-0422": {"epss_score": 0.93768, "epss_percentile": 0.99842}, "CVE-2013-0423": {"epss_score": 0.08026, "epss_percentile": 0.91838}, "CVE-2013-0424": {"epss_score": 0.01099, "epss_percentile": 0.77546}, "CVE-2013-0425": {"epss_score": 0.01516, "epss_percentile": 0.808}, "CVE-2013-0426": {"epss_score": 0.01516, "epss_percentile": 0.808}, "CVE-2013-0427": {"epss_score": 0.00848, "epss_percentile": 0.74367}, "CVE-2013-0428": {"epss_score": 0.01172, "epss_percentile": 0.78227}, "CVE-2013-0429": {"epss_score": 0.00801, "epss_percentile": 0.73564}, "CVE-2013-0430": {"epss_score": 0.00181, "epss_percentile": 0.40051}, "CVE-2013-0431": {"epss_score": 0.91587, "epss_percentile": 0.99654}, "CVE-2013-0432": {"epss_score": 0.00821, "epss_percentile": 0.73905}, "CVE-2013-0433": {"epss_score": 0.0084, "epss_percentile": 0.74203}, "CVE-2013-0434": {"epss_score": 0.00326, "epss_percentile": 0.55053}, "CVE-2013-0435": {"epss_score": 0.00571, "epss_percentile": 0.67998}, "CVE-2013-0436": {"epss_score": 0.01471, "epss_percentile": 0.80504}, "CVE-2013-0437": {"epss_score": 0.01533, "epss_percentile": 0.80901}, "CVE-2013-0438": {"epss_score": 0.05451, "epss_percentile": 0.89891}, "CVE-2013-0439": {"epss_score": 0.01471, "epss_percentile": 0.80504}, "CVE-2013-0440": {"epss_score": 0.0094, "epss_percentile": 0.75729}, "CVE-2013-0441": {"epss_score": 0.01617, "epss_percentile": 0.81365}, "CVE-2013-0442": {"epss_score": 0.01617, "epss_percentile": 0.81365}, "CVE-2013-0443": {"epss_score": 0.00345, "epss_percentile": 0.56593}, "CVE-2013-0444": {"epss_score": 0.08026, "epss_percentile": 0.91838}, "CVE-2013-0445": {"epss_score": 0.01617, "epss_percentile": 0.81365}, "CVE-2013-0446": {"epss_score": 0.08537, "epss_percentile": 0.92109}, "CVE-2013-0447": {"epss_score": 0.01471, "epss_percentile": 0.80504}, "CVE-2013-0448": {"epss_score": 0.01003, "epss_percentile": 0.76523}, "CVE-2013-0449": {"epss_score": 0.00726, "epss_percentile": 0.72069}, "CVE-2013-0450": {"epss_score": 0.01172, "epss_percentile": 0.78227}, "CVE-2013-0451": {"epss_score": 0.00348, "epss_percentile": 0.56824}, "CVE-2013-0452": {"epss_score": 0.00119, "epss_percentile": 0.31563}, "CVE-2013-0453": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2013-0454": {"epss_score": 0.01878, "epss_percentile": 0.82668}, "CVE-2013-0455": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-0456": {"epss_score": 0.00154, "epss_percentile": 0.36652}, "CVE-2013-0457": {"epss_score": 0.00161, "epss_percentile": 0.37546}, "CVE-2013-0458": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0459": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0460": {"epss_score": 0.00119, "epss_percentile": 0.31563}, "CVE-2013-0461": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0462": {"epss_score": 0.00464, "epss_percentile": 0.63711}, "CVE-2013-0463": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2013-0464": {"epss_score": 0.00328, "epss_percentile": 0.55261}, "CVE-2013-0465": {"epss_score": 0.00329, "epss_percentile": 0.55407}, "CVE-2013-0466": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0467": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2013-0468": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-0470": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2013-0471": {"epss_score": 0.00603, "epss_percentile": 0.68939}, "CVE-2013-0472": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2013-0473": {"epss_score": 0.00289, "epss_percentile": 0.52034}, "CVE-2013-0474": {"epss_score": 0.00214, "epss_percentile": 0.43948}, "CVE-2013-0475": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2013-0476": {"epss_score": 0.00218, "epss_percentile": 0.44413}, "CVE-2013-0477": {"epss_score": 0.00406, "epss_percentile": 0.60517}, "CVE-2013-0478": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-0479": {"epss_score": 0.00121, "epss_percentile": 0.31889}, "CVE-2013-0481": {"epss_score": 0.00275, "epss_percentile": 0.50693}, "CVE-2013-0482": {"epss_score": 0.00609, "epss_percentile": 0.69091}, "CVE-2013-0483": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2013-0484": {"epss_score": 0.00535, "epss_percentile": 0.66823}, "CVE-2013-0485": {"epss_score": 0.01205, "epss_percentile": 0.78509}, "CVE-2013-0486": {"epss_score": 0.00681, "epss_percentile": 0.71042}, "CVE-2013-0487": {"epss_score": 0.00606, "epss_percentile": 0.69007}, "CVE-2013-0488": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-0489": {"epss_score": 0.00093, "epss_percentile": 0.26681}, "CVE-2013-0490": {"epss_score": 0.00049, "epss_percentile": 0.15546}, "CVE-2013-0492": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-0494": {"epss_score": 0.0178, "epss_percentile": 0.82235}, "CVE-2013-0499": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2013-0500": {"epss_score": 0.00384, "epss_percentile": 0.59158}, "CVE-2013-0501": {"epss_score": 0.00774, "epss_percentile": 0.73074}, "CVE-2013-0502": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0503": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0504": {"epss_score": 0.05093, "epss_percentile": 0.89489}, "CVE-2013-0505": {"epss_score": 0.00173, "epss_percentile": 0.3913}, "CVE-2013-0506": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0507": {"epss_score": 0.00232, "epss_percentile": 0.45886}, "CVE-2013-0508": {"epss_score": 0.00449, "epss_percentile": 0.63056}, "CVE-2013-0509": {"epss_score": 0.08503, "epss_percentile": 0.92087}, "CVE-2013-0510": {"epss_score": 0.00236, "epss_percentile": 0.46422}, "CVE-2013-0511": {"epss_score": 0.00238, "epss_percentile": 0.46825}, "CVE-2013-0512": {"epss_score": 0.00607, "epss_percentile": 0.6903}, "CVE-2013-0513": {"epss_score": 0.00051, "epss_percentile": 0.16148}, "CVE-2013-0517": {"epss_score": 0.00121, "epss_percentile": 0.3188}, "CVE-2013-0518": {"epss_score": 0.00195, "epss_percentile": 0.4166}, "CVE-2013-0519": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2013-0520": {"epss_score": 0.0014, "epss_percentile": 0.34709}, "CVE-2013-0522": {"epss_score": 0.00042, "epss_percentile": 0.12815}, "CVE-2013-0523": {"epss_score": 0.00159, "epss_percentile": 0.37354}, "CVE-2013-0525": {"epss_score": 0.00086, "epss_percentile": 0.25328}, "CVE-2013-0526": {"epss_score": 0.07112, "epss_percentile": 0.91259}, "CVE-2013-0527": {"epss_score": 0.00061, "epss_percentile": 0.19493}, "CVE-2013-0529": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2013-0531": {"epss_score": 0.00121, "epss_percentile": 0.31881}, "CVE-2013-0532": {"epss_score": 0.00142, "epss_percentile": 0.35046}, "CVE-2013-0533": {"epss_score": 0.00142, "epss_percentile": 0.35088}, "CVE-2013-0534": {"epss_score": 0.0005, "epss_percentile": 0.15971}, "CVE-2013-0535": {"epss_score": 0.00161, "epss_percentile": 0.37546}, "CVE-2013-0536": {"epss_score": 0.00048, "epss_percentile": 0.15042}, "CVE-2013-0537": {"epss_score": 0.00154, "epss_percentile": 0.36652}, "CVE-2013-0538": {"epss_score": 0.0053, "epss_percentile": 0.66613}, "CVE-2013-0539": {"epss_score": 0.00275, "epss_percentile": 0.50693}, "CVE-2013-0540": {"epss_score": 0.00122, "epss_percentile": 0.32133}, "CVE-2013-0541": {"epss_score": 0.0005, "epss_percentile": 0.15728}, "CVE-2013-0542": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0543": {"epss_score": 0.00292, "epss_percentile": 0.5224}, "CVE-2013-0544": {"epss_score": 0.01061, "epss_percentile": 0.77172}, "CVE-2013-0548": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2013-0549": {"epss_score": 0.00322, "epss_percentile": 0.54826}, "CVE-2013-0551": {"epss_score": 0.01342, "epss_percentile": 0.79598}, "CVE-2013-0553": {"epss_score": 0.00141, "epss_percentile": 0.34947}, "CVE-2013-0558": {"epss_score": 0.00275, "epss_percentile": 0.50693}, "CVE-2013-0559": {"epss_score": 0.00246, "epss_percentile": 0.47798}, "CVE-2013-0560": {"epss_score": 0.00278, "epss_percentile": 0.50869}, "CVE-2013-0565": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0566": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0567": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2013-0568": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2013-0569": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0570": {"epss_score": 0.00175, "epss_percentile": 0.39357}, "CVE-2013-0571": {"epss_score": 0.00191, "epss_percentile": 0.41274}, "CVE-2013-0572": {"epss_score": 0.00146, "epss_percentile": 0.35625}, "CVE-2013-0576": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0577": {"epss_score": 0.00089, "epss_percentile": 0.25838}, "CVE-2013-0578": {"epss_score": 0.00164, "epss_percentile": 0.38004}, "CVE-2013-0579": {"epss_score": 0.00196, "epss_percentile": 0.41743}, "CVE-2013-0580": {"epss_score": 0.00091, "epss_percentile": 0.26198}, "CVE-2013-0581": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2013-0582": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2013-0584": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2013-0585": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-0586": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-0587": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0589": {"epss_score": 0.00171, "epss_percentile": 0.38828}, "CVE-2013-0590": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-0591": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-0592": {"epss_score": 0.00133, "epss_percentile": 0.33636}, "CVE-2013-0593": {"epss_score": 0.07348, "epss_percentile": 0.91424}, "CVE-2013-0594": {"epss_score": 0.00154, "epss_percentile": 0.36723}, "CVE-2013-0595": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0596": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-0597": {"epss_score": 0.00162, "epss_percentile": 0.37634}, "CVE-2013-0598": {"epss_score": 0.00119, "epss_percentile": 0.31563}, "CVE-2013-0599": {"epss_score": 0.00254, "epss_percentile": 0.48524}, "CVE-2013-0600": {"epss_score": 0.00375, "epss_percentile": 0.58596}, "CVE-2013-0601": {"epss_score": 0.10106, "epss_percentile": 0.92851}, "CVE-2013-0602": {"epss_score": 0.06987, "epss_percentile": 0.91163}, "CVE-2013-0603": {"epss_score": 0.07911, "epss_percentile": 0.91759}, "CVE-2013-0604": {"epss_score": 0.18037, "epss_percentile": 0.94948}, "CVE-2013-0605": {"epss_score": 0.07241, "epss_percentile": 0.91345}, "CVE-2013-0606": {"epss_score": 0.18037, "epss_percentile": 0.94948}, "CVE-2013-0607": {"epss_score": 0.07638, "epss_percentile": 0.91592}, "CVE-2013-0608": {"epss_score": 0.08482, "epss_percentile": 0.92075}, "CVE-2013-0609": {"epss_score": 0.07968, "epss_percentile": 0.91797}, "CVE-2013-0610": {"epss_score": 0.18037, "epss_percentile": 0.94948}, "CVE-2013-0611": {"epss_score": 0.05853, "epss_percentile": 0.90263}, "CVE-2013-0612": {"epss_score": 0.07911, "epss_percentile": 0.91759}, "CVE-2013-0613": {"epss_score": 0.15024, "epss_percentile": 0.94346}, "CVE-2013-0614": {"epss_score": 0.07638, "epss_percentile": 0.91592}, "CVE-2013-0615": {"epss_score": 0.18037, "epss_percentile": 0.94948}, "CVE-2013-0616": {"epss_score": 0.09791, "epss_percentile": 0.92703}, "CVE-2013-0617": {"epss_score": 0.18037, "epss_percentile": 0.94948}, "CVE-2013-0618": {"epss_score": 0.08482, "epss_percentile": 0.92075}, "CVE-2013-0619": {"epss_score": 0.05618, "epss_percentile": 0.90057}, "CVE-2013-0620": {"epss_score": 0.05618, "epss_percentile": 0.90057}, "CVE-2013-0621": {"epss_score": 0.07911, "epss_percentile": 0.91759}, "CVE-2013-0622": {"epss_score": 0.02972, "epss_percentile": 0.861}, "CVE-2013-0623": {"epss_score": 0.10663, "epss_percentile": 0.93062}, "CVE-2013-0624": {"epss_score": 0.07051, "epss_percentile": 0.91213}, "CVE-2013-0625": {"epss_score": 0.8656, "epss_percentile": 0.99388}, "CVE-2013-0626": {"epss_score": 0.07438, "epss_percentile": 0.91473}, "CVE-2013-0627": {"epss_score": 0.00327, "epss_percentile": 0.55125}, "CVE-2013-0629": {"epss_score": 0.80909, "epss_percentile": 0.99112}, "CVE-2013-0630": {"epss_score": 0.07171, "epss_percentile": 0.91297}, "CVE-2013-0631": {"epss_score": 0.75297, "epss_percentile": 0.98836}, "CVE-2013-0632": {"epss_score": 0.92372, "epss_percentile": 0.99711}, "CVE-2013-0633": {"epss_score": 0.58929, "epss_percentile": 0.98141}, "CVE-2013-0634": {"epss_score": 0.89954, "epss_percentile": 0.99552}, "CVE-2013-0635": {"epss_score": 0.17086, "epss_percentile": 0.94772}, "CVE-2013-0636": {"epss_score": 0.26062, "epss_percentile": 0.96106}, "CVE-2013-0637": {"epss_score": 0.02734, "epss_percentile": 0.85548}, "CVE-2013-0638": {"epss_score": 0.04783, "epss_percentile": 0.89138}, "CVE-2013-0639": {"epss_score": 0.12991, "epss_percentile": 0.93838}, "CVE-2013-0640": {"epss_score": 0.92545, "epss_percentile": 0.99725}, "CVE-2013-0641": {"epss_score": 0.88385, "epss_percentile": 0.99469}, "CVE-2013-0642": {"epss_score": 0.04189, "epss_percentile": 0.88374}, "CVE-2013-0643": {"epss_score": 0.65348, "epss_percentile": 0.98414}, "CVE-2013-0644": {"epss_score": 0.04685, "epss_percentile": 0.89006}, "CVE-2013-0645": {"epss_score": 0.04189, "epss_percentile": 0.88374}, "CVE-2013-0646": {"epss_score": 0.03908, "epss_percentile": 0.87931}, "CVE-2013-0647": {"epss_score": 0.04783, "epss_percentile": 0.89138}, "CVE-2013-0648": {"epss_score": 0.6587, "epss_percentile": 0.98441}, "CVE-2013-0649": {"epss_score": 0.04685, "epss_percentile": 0.89006}, "CVE-2013-0650": {"epss_score": 0.03647, "epss_percentile": 0.87504}, "CVE-2013-0651": {"epss_score": 0.00338, "epss_percentile": 0.56112}, "CVE-2013-0652": {"epss_score": 0.00298, "epss_percentile": 0.52824}, "CVE-2013-0653": {"epss_score": 0.13166, "epss_percentile": 0.9389}, "CVE-2013-0654": {"epss_score": 0.00748, "epss_percentile": 0.72586}, "CVE-2013-0655": {"epss_score": 0.01347, "epss_percentile": 0.79651}, "CVE-2013-0656": {"epss_score": 0.02133, "epss_percentile": 0.83721}, "CVE-2013-0657": {"epss_score": 0.61438, "epss_percentile": 0.98249}, "CVE-2013-0658": {"epss_score": 0.65471, "epss_percentile": 0.9842}, "CVE-2013-0659": {"epss_score": 0.02104, "epss_percentile": 0.83618}, "CVE-2013-0662": {"epss_score": 0.50704, "epss_percentile": 0.97746}, "CVE-2013-0663": {"epss_score": 0.00365, "epss_percentile": 0.57975}, "CVE-2013-0664": {"epss_score": 0.01159, "epss_percentile": 0.78128}, "CVE-2013-0665": {"epss_score": 0.00039, "epss_percentile": 0.11535}, "CVE-2013-0666": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2013-0667": {"epss_score": 0.00385, "epss_percentile": 0.59195}, "CVE-2013-0668": {"epss_score": 0.00385, "epss_percentile": 0.59195}, "CVE-2013-0669": {"epss_score": 0.00166, "epss_percentile": 0.38146}, "CVE-2013-0670": {"epss_score": 0.00328, "epss_percentile": 0.55174}, "CVE-2013-0671": {"epss_score": 0.00181, "epss_percentile": 0.40035}, "CVE-2013-0672": {"epss_score": 0.00241, "epss_percentile": 0.47268}, "CVE-2013-0673": {"epss_score": 0.0031, "epss_percentile": 0.53762}, "CVE-2013-0674": {"epss_score": 0.02707, "epss_percentile": 0.85468}, "CVE-2013-0675": {"epss_score": 0.00064, "epss_percentile": 0.20348}, "CVE-2013-0676": {"epss_score": 0.00211, "epss_percentile": 0.43718}, "CVE-2013-0677": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2013-0678": {"epss_score": 0.00211, "epss_percentile": 0.43718}, "CVE-2013-0679": {"epss_score": 0.00334, "epss_percentile": 0.55693}, "CVE-2013-0680": {"epss_score": 0.51667, "epss_percentile": 0.97792}, "CVE-2013-0681": {"epss_score": 0.00566, "epss_percentile": 0.67815}, "CVE-2013-0682": {"epss_score": 0.0157, "epss_percentile": 0.81082}, "CVE-2013-0683": {"epss_score": 0.00337, "epss_percentile": 0.56013}, "CVE-2013-0684": {"epss_score": 0.00222, "epss_percentile": 0.44736}, "CVE-2013-0685": {"epss_score": 0.02476, "epss_percentile": 0.84863}, "CVE-2013-0686": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2013-0687": {"epss_score": 0.00032, "epss_percentile": 0.08748}, "CVE-2013-0688": {"epss_score": 0.00249, "epss_percentile": 0.48078}, "CVE-2013-0689": {"epss_score": 0.03261, "epss_percentile": 0.86771}, "CVE-2013-0692": {"epss_score": 0.04111, "epss_percentile": 0.88271}, "CVE-2013-0693": {"epss_score": 0.00617, "epss_percentile": 0.69359}, "CVE-2013-0694": {"epss_score": 0.00526, "epss_percentile": 0.66397}, "CVE-2013-0699": {"epss_score": 0.16464, "epss_percentile": 0.94673}, "CVE-2013-0700": {"epss_score": 0.00342, "epss_percentile": 0.56361}, "CVE-2013-0701": {"epss_score": 0.00282, "epss_percentile": 0.51234}, "CVE-2013-0702": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-0703": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-0704": {"epss_score": 0.00158, "epss_percentile": 0.37294}, "CVE-2013-0705": {"epss_score": 0.00125, "epss_percentile": 0.3262}, "CVE-2013-0706": {"epss_score": 0.00547, "epss_percentile": 0.67255}, "CVE-2013-0707": {"epss_score": 0.03504, "epss_percentile": 0.87255}, "CVE-2013-0708": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-0709": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-0710": {"epss_score": 0.11004, "epss_percentile": 0.93187}, "CVE-2013-0711": {"epss_score": 0.0186, "epss_percentile": 0.82588}, "CVE-2013-0712": {"epss_score": 0.00838, "epss_percentile": 0.74166}, "CVE-2013-0713": {"epss_score": 0.00712, "epss_percentile": 0.71751}, "CVE-2013-0714": {"epss_score": 0.09324, "epss_percentile": 0.925}, "CVE-2013-0715": {"epss_score": 0.00576, "epss_percentile": 0.68128}, "CVE-2013-0716": {"epss_score": 0.00676, "epss_percentile": 0.70934}, "CVE-2013-0717": {"epss_score": 0.00184, "epss_percentile": 0.40381}, "CVE-2013-0718": {"epss_score": 0.00195, "epss_percentile": 0.41616}, "CVE-2013-0719": {"epss_score": 0.00195, "epss_percentile": 0.41616}, "CVE-2013-0720": {"epss_score": 0.00195, "epss_percentile": 0.41616}, "CVE-2013-0721": {"epss_score": 0.00297, "epss_percentile": 0.52753}, "CVE-2013-0722": {"epss_score": 0.00169, "epss_percentile": 0.38643}, "CVE-2013-0723": {"epss_score": 0.07612, "epss_percentile": 0.91568}, "CVE-2013-0724": {"epss_score": 0.00694, "epss_percentile": 0.71359}, "CVE-2013-0725": {"epss_score": 0.00065, "epss_percentile": 0.20501}, "CVE-2013-0726": {"epss_score": 0.65422, "epss_percentile": 0.98417}, "CVE-2013-0727": {"epss_score": 0.00068, "epss_percentile": 0.21404}, "CVE-2013-0728": {"epss_score": 0.08946, "epss_percentile": 0.92331}, "CVE-2013-0729": {"epss_score": 0.08742, "epss_percentile": 0.92236}, "CVE-2013-0730": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-0731": {"epss_score": 0.00585, "epss_percentile": 0.68407}, "CVE-2013-0732": {"epss_score": 0.12929, "epss_percentile": 0.9382}, "CVE-2013-0733": {"epss_score": 0.07444, "epss_percentile": 0.91475}, "CVE-2013-0734": {"epss_score": 0.00431, "epss_percentile": 0.62064}, "CVE-2013-0735": {"epss_score": 0.00602, "epss_percentile": 0.68898}, "CVE-2013-0736": {"epss_score": 0.00187, "epss_percentile": 0.40792}, "CVE-2013-0737": {"epss_score": 0.00195, "epss_percentile": 0.41666}, "CVE-2013-0738": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2013-0739": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2013-0740": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2013-0741": {"epss_score": 0.00336, "epss_percentile": 0.5594}, "CVE-2013-0742": {"epss_score": 0.7606, "epss_percentile": 0.98875}, "CVE-2013-0744": {"epss_score": 0.13449, "epss_percentile": 0.93968}, "CVE-2013-0745": {"epss_score": 0.03154, "epss_percentile": 0.86511}, "CVE-2013-0746": {"epss_score": 0.02632, "epss_percentile": 0.85285}, "CVE-2013-0747": {"epss_score": 0.02298, "epss_percentile": 0.84301}, "CVE-2013-0748": {"epss_score": 0.00321, "epss_percentile": 0.54689}, "CVE-2013-0749": {"epss_score": 0.01222, "epss_percentile": 0.7866}, "CVE-2013-0750": {"epss_score": 0.0381, "epss_percentile": 0.87758}, "CVE-2013-0751": {"epss_score": 0.00521, "epss_percentile": 0.66224}, "CVE-2013-0752": {"epss_score": 0.02834, "epss_percentile": 0.85787}, "CVE-2013-0753": {"epss_score": 0.8806, "epss_percentile": 0.99456}, "CVE-2013-0754": {"epss_score": 0.0283, "epss_percentile": 0.85773}, "CVE-2013-0755": {"epss_score": 0.02674, "epss_percentile": 0.85399}, "CVE-2013-0756": {"epss_score": 0.01375, "epss_percentile": 0.79828}, "CVE-2013-0757": {"epss_score": 0.74572, "epss_percentile": 0.98808}, "CVE-2013-0758": {"epss_score": 0.87365, "epss_percentile": 0.99425}, "CVE-2013-0759": {"epss_score": 0.01368, "epss_percentile": 0.79789}, "CVE-2013-0760": {"epss_score": 0.03151, "epss_percentile": 0.86507}, "CVE-2013-0761": {"epss_score": 0.01711, "epss_percentile": 0.81883}, "CVE-2013-0762": {"epss_score": 0.02669, "epss_percentile": 0.85384}, "CVE-2013-0763": {"epss_score": 0.01107, "epss_percentile": 0.77628}, "CVE-2013-0764": {"epss_score": 0.01497, "epss_percentile": 0.80688}, "CVE-2013-0765": {"epss_score": 0.01424, "epss_percentile": 0.80192}, "CVE-2013-0766": {"epss_score": 0.02851, "epss_percentile": 0.85829}, "CVE-2013-0767": {"epss_score": 0.01909, "epss_percentile": 0.82819}, "CVE-2013-0768": {"epss_score": 0.04815, "epss_percentile": 0.8917}, "CVE-2013-0769": {"epss_score": 0.01145, "epss_percentile": 0.77994}, "CVE-2013-0770": {"epss_score": 0.00939, "epss_percentile": 0.75716}, "CVE-2013-0771": {"epss_score": 0.03151, "epss_percentile": 0.86507}, "CVE-2013-0772": {"epss_score": 0.01287, "epss_percentile": 0.79197}, "CVE-2013-0773": {"epss_score": 0.01519, "epss_percentile": 0.80817}, "CVE-2013-0774": {"epss_score": 0.00552, "epss_percentile": 0.67397}, "CVE-2013-0775": {"epss_score": 0.00914, "epss_percentile": 0.7539}, "CVE-2013-0776": {"epss_score": 0.00653, "epss_percentile": 0.70327}, "CVE-2013-0777": {"epss_score": 0.01397, "epss_percentile": 0.79983}, "CVE-2013-0778": {"epss_score": 0.01558, "epss_percentile": 0.81026}, "CVE-2013-0779": {"epss_score": 0.02362, "epss_percentile": 0.84503}, "CVE-2013-0780": {"epss_score": 0.02146, "epss_percentile": 0.83765}, "CVE-2013-0781": {"epss_score": 0.01558, "epss_percentile": 0.81026}, "CVE-2013-0782": {"epss_score": 0.02889, "epss_percentile": 0.85915}, "CVE-2013-0783": {"epss_score": 0.01206, "epss_percentile": 0.78517}, "CVE-2013-0784": {"epss_score": 0.00903, "epss_percentile": 0.75202}, "CVE-2013-0785": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-0786": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2013-0787": {"epss_score": 0.05374, "epss_percentile": 0.89797}, "CVE-2013-0788": {"epss_score": 0.01877, "epss_percentile": 0.82664}, "CVE-2013-0789": {"epss_score": 0.01877, "epss_percentile": 0.82664}, "CVE-2013-0790": {"epss_score": 0.05016, "epss_percentile": 0.89395}, "CVE-2013-0791": {"epss_score": 0.01024, "epss_percentile": 0.76778}, "CVE-2013-0792": {"epss_score": 0.00935, "epss_percentile": 0.75673}, "CVE-2013-0793": {"epss_score": 0.01503, "epss_percentile": 0.80727}, "CVE-2013-0794": {"epss_score": 0.00625, "epss_percentile": 0.69585}, "CVE-2013-0795": {"epss_score": 0.02013, "epss_percentile": 0.83259}, "CVE-2013-0796": {"epss_score": 0.04533, "epss_percentile": 0.88813}, "CVE-2013-0797": {"epss_score": 0.00166, "epss_percentile": 0.38196}, "CVE-2013-0798": {"epss_score": 0.003, "epss_percentile": 0.52908}, "CVE-2013-0799": {"epss_score": 0.00199, "epss_percentile": 0.42149}, "CVE-2013-0800": {"epss_score": 0.02798, "epss_percentile": 0.85687}, "CVE-2013-0801": {"epss_score": 0.01556, "epss_percentile": 0.81014}, "CVE-2013-0803": {"epss_score": 0.83939, "epss_percentile": 0.99266}, "CVE-2013-0804": {"epss_score": 0.33192, "epss_percentile": 0.96752}, "CVE-2013-0805": {"epss_score": 0.00424, "epss_percentile": 0.61666}, "CVE-2013-0807": {"epss_score": 0.09874, "epss_percentile": 0.92747}, "CVE-2013-0809": {"epss_score": 0.08193, "epss_percentile": 0.91923}, "CVE-2013-0810": {"epss_score": 0.82217, "epss_percentile": 0.9918}, "CVE-2013-0811": {"epss_score": 0.4096, "epss_percentile": 0.97248}, "CVE-2013-0828": {"epss_score": 0.00569, "epss_percentile": 0.67915}, "CVE-2013-0829": {"epss_score": 0.00172, "epss_percentile": 0.38927}, "CVE-2013-0830": {"epss_score": 0.0023, "epss_percentile": 0.45732}, "CVE-2013-0831": {"epss_score": 0.00288, "epss_percentile": 0.51928}, "CVE-2013-0832": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2013-0833": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2013-0834": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2013-0835": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2013-0836": {"epss_score": 0.00666, "epss_percentile": 0.70694}, "CVE-2013-0837": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2013-0838": {"epss_score": 0.00147, "epss_percentile": 0.35796}, "CVE-2013-0839": {"epss_score": 0.00609, "epss_percentile": 0.69094}, "CVE-2013-0840": {"epss_score": 0.00351, "epss_percentile": 0.57056}, "CVE-2013-0841": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2013-0842": {"epss_score": 0.00351, "epss_percentile": 0.57056}, "CVE-2013-0843": {"epss_score": 0.00818, "epss_percentile": 0.73856}, "CVE-2013-0844": {"epss_score": 0.00774, "epss_percentile": 0.73071}, "CVE-2013-0845": {"epss_score": 0.00879, "epss_percentile": 0.74848}, "CVE-2013-0846": {"epss_score": 0.00938, "epss_percentile": 0.75709}, "CVE-2013-0847": {"epss_score": 0.00711, "epss_percentile": 0.71745}, "CVE-2013-0848": {"epss_score": 0.00714, "epss_percentile": 0.71825}, "CVE-2013-0849": {"epss_score": 0.00938, "epss_percentile": 0.75709}, "CVE-2013-0850": {"epss_score": 0.00938, "epss_percentile": 0.75709}, "CVE-2013-0851": {"epss_score": 0.00541, "epss_percentile": 0.67053}, "CVE-2013-0852": {"epss_score": 0.00835, "epss_percentile": 0.74117}, "CVE-2013-0853": {"epss_score": 0.00714, "epss_percentile": 0.71825}, "CVE-2013-0854": {"epss_score": 0.00938, "epss_percentile": 0.75709}, "CVE-2013-0855": {"epss_score": 0.0077, "epss_percentile": 0.73003}, "CVE-2013-0856": {"epss_score": 0.00541, "epss_percentile": 0.67053}, "CVE-2013-0857": {"epss_score": 0.00714, "epss_percentile": 0.71825}, "CVE-2013-0858": {"epss_score": 0.01154, "epss_percentile": 0.78067}, "CVE-2013-0859": {"epss_score": 0.00541, "epss_percentile": 0.67053}, "CVE-2013-0860": {"epss_score": 0.00891, "epss_percentile": 0.75035}, "CVE-2013-0861": {"epss_score": 0.00377, "epss_percentile": 0.58711}, "CVE-2013-0862": {"epss_score": 0.00938, "epss_percentile": 0.75709}, "CVE-2013-0863": {"epss_score": 0.01346, "epss_percentile": 0.79642}, "CVE-2013-0864": {"epss_score": 0.01432, "epss_percentile": 0.80251}, "CVE-2013-0865": {"epss_score": 0.0085, "epss_percentile": 0.74392}, "CVE-2013-0866": {"epss_score": 0.00958, "epss_percentile": 0.75947}, "CVE-2013-0867": {"epss_score": 0.00714, "epss_percentile": 0.71825}, "CVE-2013-0868": {"epss_score": 0.00889, "epss_percentile": 0.7502}, "CVE-2013-0869": {"epss_score": 0.00541, "epss_percentile": 0.67053}, "CVE-2013-0870": {"epss_score": 0.00464, "epss_percentile": 0.63729}, "CVE-2013-0871": {"epss_score": 0.00056, "epss_percentile": 0.17828}, "CVE-2013-0872": {"epss_score": 0.01432, "epss_percentile": 0.80251}, "CVE-2013-0873": {"epss_score": 0.02012, "epss_percentile": 0.83254}, "CVE-2013-0874": {"epss_score": 0.00714, "epss_percentile": 0.71825}, "CVE-2013-0875": {"epss_score": 0.00714, "epss_percentile": 0.71825}, "CVE-2013-0876": {"epss_score": 0.00714, "epss_percentile": 0.71825}, "CVE-2013-0877": {"epss_score": 0.00714, "epss_percentile": 0.71825}, "CVE-2013-0878": {"epss_score": 0.00714, "epss_percentile": 0.71825}, "CVE-2013-0879": {"epss_score": 0.01678, "epss_percentile": 0.81717}, "CVE-2013-0880": {"epss_score": 0.00613, "epss_percentile": 0.69258}, "CVE-2013-0881": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2013-0882": {"epss_score": 0.00668, "epss_percentile": 0.70729}, "CVE-2013-0883": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2013-0884": {"epss_score": 0.00194, "epss_percentile": 0.41517}, "CVE-2013-0885": {"epss_score": 0.00167, "epss_percentile": 0.38351}, "CVE-2013-0886": {"epss_score": 0.00195, "epss_percentile": 0.41677}, "CVE-2013-0887": {"epss_score": 0.00213, "epss_percentile": 0.43839}, "CVE-2013-0888": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2013-0889": {"epss_score": 0.01294, "epss_percentile": 0.79244}, "CVE-2013-0890": {"epss_score": 0.00781, "epss_percentile": 0.73183}, "CVE-2013-0891": {"epss_score": 0.00606, "epss_percentile": 0.69005}, "CVE-2013-0892": {"epss_score": 0.0162, "epss_percentile": 0.81383}, "CVE-2013-0893": {"epss_score": 0.00439, "epss_percentile": 0.62602}, "CVE-2013-0894": {"epss_score": 0.00469, "epss_percentile": 0.63956}, "CVE-2013-0895": {"epss_score": 0.00362, "epss_percentile": 0.57793}, "CVE-2013-0896": {"epss_score": 0.00606, "epss_percentile": 0.69005}, "CVE-2013-0897": {"epss_score": 0.00684, "epss_percentile": 0.71115}, "CVE-2013-0898": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2013-0899": {"epss_score": 0.01102, "epss_percentile": 0.77585}, "CVE-2013-0900": {"epss_score": 0.00934, "epss_percentile": 0.75658}, "CVE-2013-0902": {"epss_score": 0.00609, "epss_percentile": 0.69094}, "CVE-2013-0903": {"epss_score": 0.00561, "epss_percentile": 0.67665}, "CVE-2013-0904": {"epss_score": 0.00656, "epss_percentile": 0.70449}, "CVE-2013-0905": {"epss_score": 0.00609, "epss_percentile": 0.69094}, "CVE-2013-0906": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2013-0907": {"epss_score": 0.00402, "epss_percentile": 0.60293}, "CVE-2013-0908": {"epss_score": 0.00195, "epss_percentile": 0.41677}, "CVE-2013-0909": {"epss_score": 0.0025, "epss_percentile": 0.48094}, "CVE-2013-0910": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2013-0911": {"epss_score": 0.00283, "epss_percentile": 0.51393}, "CVE-2013-0912": {"epss_score": 0.01824, "epss_percentile": 0.82426}, "CVE-2013-0913": {"epss_score": 0.00028, "epss_percentile": 0.07264}, "CVE-2013-0914": {"epss_score": 7e-05, "epss_percentile": 0.00343}, "CVE-2013-0915": {"epss_score": 0.00223, "epss_percentile": 0.44963}, "CVE-2013-0916": {"epss_score": 0.00561, "epss_percentile": 0.67665}, "CVE-2013-0917": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2013-0918": {"epss_score": 0.00447, "epss_percentile": 0.6297}, "CVE-2013-0919": {"epss_score": 0.00353, "epss_percentile": 0.57161}, "CVE-2013-0920": {"epss_score": 0.00609, "epss_percentile": 0.69094}, "CVE-2013-0921": {"epss_score": 0.00246, "epss_percentile": 0.47809}, "CVE-2013-0922": {"epss_score": 0.00185, "epss_percentile": 0.40579}, "CVE-2013-0923": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2013-0924": {"epss_score": 0.00147, "epss_percentile": 0.35796}, "CVE-2013-0925": {"epss_score": 0.00195, "epss_percentile": 0.41677}, "CVE-2013-0926": {"epss_score": 0.01242, "epss_percentile": 0.78823}, "CVE-2013-0927": {"epss_score": 0.00192, "epss_percentile": 0.41353}, "CVE-2013-0928": {"epss_score": 0.78669, "epss_percentile": 0.98997}, "CVE-2013-0929": {"epss_score": 0.12004, "epss_percentile": 0.93544}, "CVE-2013-0930": {"epss_score": 0.07703, "epss_percentile": 0.91635}, "CVE-2013-0931": {"epss_score": 0.00087, "epss_percentile": 0.25535}, "CVE-2013-0932": {"epss_score": 0.00183, "epss_percentile": 0.40304}, "CVE-2013-0933": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-0934": {"epss_score": 0.00183, "epss_percentile": 0.40304}, "CVE-2013-0935": {"epss_score": 0.01792, "epss_percentile": 0.82288}, "CVE-2013-0936": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-0937": {"epss_score": 0.00206, "epss_percentile": 0.42934}, "CVE-2013-0938": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-0939": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2013-0940": {"epss_score": 0.00032, "epss_percentile": 0.08748}, "CVE-2013-0941": {"epss_score": 0.00039, "epss_percentile": 0.11577}, "CVE-2013-0942": {"epss_score": 0.00496, "epss_percentile": 0.6514}, "CVE-2013-0943": {"epss_score": 0.00054, "epss_percentile": 0.17279}, "CVE-2013-0944": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2013-0945": {"epss_score": 0.00201, "epss_percentile": 0.42384}, "CVE-2013-0946": {"epss_score": 0.56445, "epss_percentile": 0.98022}, "CVE-2013-0947": {"epss_score": 0.00053, "epss_percentile": 0.16903}, "CVE-2013-0948": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2013-0949": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2013-0950": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2013-0951": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2013-0952": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2013-0953": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2013-0954": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2013-0955": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2013-0956": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2013-0957": {"epss_score": 0.00288, "epss_percentile": 0.51911}, "CVE-2013-0958": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2013-0959": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2013-0960": {"epss_score": 0.01189, "epss_percentile": 0.78371}, "CVE-2013-0961": {"epss_score": 0.01189, "epss_percentile": 0.78371}, "CVE-2013-0962": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2013-0963": {"epss_score": 0.00035, "epss_percentile": 0.1014}, "CVE-2013-0964": {"epss_score": 0.00063, "epss_percentile": 0.19859}, "CVE-2013-0966": {"epss_score": 0.00241, "epss_percentile": 0.4728}, "CVE-2013-0967": {"epss_score": 0.00327, "epss_percentile": 0.55135}, "CVE-2013-0968": {"epss_score": 0.01096, "epss_percentile": 0.77523}, "CVE-2013-0969": {"epss_score": 0.00065, "epss_percentile": 0.20552}, "CVE-2013-0970": {"epss_score": 0.00397, "epss_percentile": 0.59967}, "CVE-2013-0971": {"epss_score": 0.0147, "epss_percentile": 0.80498}, "CVE-2013-0973": {"epss_score": 0.0035, "epss_percentile": 0.5698}, "CVE-2013-0974": {"epss_score": 0.00254, "epss_percentile": 0.48504}, "CVE-2013-0975": {"epss_score": 0.00892, "epss_percentile": 0.75057}, "CVE-2013-0976": {"epss_score": 0.01256, "epss_percentile": 0.78935}, "CVE-2013-0977": {"epss_score": 0.00059, "epss_percentile": 0.18642}, "CVE-2013-0978": {"epss_score": 0.00061, "epss_percentile": 0.19511}, "CVE-2013-0979": {"epss_score": 0.00036, "epss_percentile": 0.10329}, "CVE-2013-0980": {"epss_score": 0.00053, "epss_percentile": 0.16986}, "CVE-2013-0981": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2013-0982": {"epss_score": 0.00047, "epss_percentile": 0.14667}, "CVE-2013-0983": {"epss_score": 0.00751, "epss_percentile": 0.72642}, "CVE-2013-0984": {"epss_score": 0.09856, "epss_percentile": 0.92738}, "CVE-2013-0985": {"epss_score": 0.00054, "epss_percentile": 0.17212}, "CVE-2013-0986": {"epss_score": 0.03663, "epss_percentile": 0.8753}, "CVE-2013-0987": {"epss_score": 0.05433, "epss_percentile": 0.89879}, "CVE-2013-0988": {"epss_score": 0.06096, "epss_percentile": 0.90478}, "CVE-2013-0989": {"epss_score": 0.06096, "epss_percentile": 0.90478}, "CVE-2013-0990": {"epss_score": 0.00432, "epss_percentile": 0.62117}, "CVE-2013-0991": {"epss_score": 0.0063, "epss_percentile": 0.69709}, "CVE-2013-0992": {"epss_score": 0.18192, "epss_percentile": 0.94973}, "CVE-2013-0993": {"epss_score": 0.0063, "epss_percentile": 0.69709}, "CVE-2013-0994": {"epss_score": 0.0063, "epss_percentile": 0.69709}, "CVE-2013-0995": {"epss_score": 0.0063, "epss_percentile": 0.69709}, "CVE-2013-0996": {"epss_score": 0.0063, "epss_percentile": 0.69709}, "CVE-2013-0997": {"epss_score": 0.01007, "epss_percentile": 0.7656}, "CVE-2013-0998": {"epss_score": 0.0063, "epss_percentile": 0.69709}, "CVE-2013-0999": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2013-10001": {"epss_score": 0.00267, "epss_percentile": 0.49962}, "CVE-2013-10002": {"epss_score": 0.00216, "epss_percentile": 0.44184}, "CVE-2013-10003": {"epss_score": 0.00111, "epss_percentile": 0.30264}, "CVE-2013-10004": {"epss_score": 0.00406, "epss_percentile": 0.60534}, "CVE-2013-10005": {"epss_score": 0.00858, "epss_percentile": 0.74503}, "CVE-2013-10006": {"epss_score": 0.0034, "epss_percentile": 0.56232}, "CVE-2013-10007": {"epss_score": 0.00476, "epss_percentile": 0.6426}, "CVE-2013-10008": {"epss_score": 0.00053, "epss_percentile": 0.16711}, "CVE-2013-10009": {"epss_score": 0.0005, "epss_percentile": 0.15847}, "CVE-2013-10010": {"epss_score": 0.00111, "epss_percentile": 0.3031}, "CVE-2013-10011": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2013-10012": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2013-10013": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2013-10014": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2013-10015": {"epss_score": 0.00059, "epss_percentile": 0.18712}, "CVE-2013-10016": {"epss_score": 0.00059, "epss_percentile": 0.18712}, "CVE-2013-10017": {"epss_score": 0.00059, "epss_percentile": 0.18712}, "CVE-2013-10018": {"epss_score": 0.00059, "epss_percentile": 0.18712}, "CVE-2013-10019": {"epss_score": 0.00211, "epss_percentile": 0.43646}, "CVE-2013-10020": {"epss_score": 0.00128, "epss_percentile": 0.33062}, "CVE-2013-10021": {"epss_score": 0.00128, "epss_percentile": 0.33062}, "CVE-2013-10022": {"epss_score": 0.00095, "epss_percentile": 0.27145}, "CVE-2013-10023": {"epss_score": 0.00129, "epss_percentile": 0.3311}, "CVE-2013-10024": {"epss_score": 0.00354, "epss_percentile": 0.57203}, "CVE-2013-10025": {"epss_score": 0.00108, "epss_percentile": 0.29817}, "CVE-2013-10026": {"epss_score": 0.00102, "epss_percentile": 0.28723}, "CVE-2013-10027": {"epss_score": 0.00086, "epss_percentile": 0.25397}, "CVE-2013-10028": {"epss_score": 0.00078, "epss_percentile": 0.2359}, "CVE-2013-10029": {"epss_score": 0.00066, "epss_percentile": 0.20823}, "CVE-2013-10030": {"epss_score": 0.00338, "epss_percentile": 0.56133}, "CVE-2013-10031": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2013-10032": {"epss_score": 0.56803, "epss_percentile": 0.98037}, "CVE-2013-10033": {"epss_score": 0.42942, "epss_percentile": 0.97363}, "CVE-2013-10034": {"epss_score": 0.40488, "epss_percentile": 0.9722}, "CVE-2013-10035": {"epss_score": 0.37732, "epss_percentile": 0.97066}, "CVE-2013-10036": {"epss_score": 0.0365, "epss_percentile": 0.87508}, "CVE-2013-10037": {"epss_score": 0.67205, "epss_percentile": 0.98498}, "CVE-2013-10038": {"epss_score": 0.64021, "epss_percentile": 0.98359}, "CVE-2013-10039": {"epss_score": 0.56462, "epss_percentile": 0.98023}, "CVE-2013-10040": {"epss_score": 0.60661, "epss_percentile": 0.98215}, "CVE-2013-10042": {"epss_score": 0.55251, "epss_percentile": 0.97967}, "CVE-2013-10043": {"epss_score": 0.58652, "epss_percentile": 0.9813}, "CVE-2013-10044": {"epss_score": 0.04263, "epss_percentile": 0.88465}, "CVE-2013-10046": {"epss_score": 0.0102, "epss_percentile": 0.76737}, "CVE-2013-10047": {"epss_score": 0.61801, "epss_percentile": 0.98262}, "CVE-2013-10048": {"epss_score": 0.5984, "epss_percentile": 0.98184}, "CVE-2013-10049": {"epss_score": 0.51369, "epss_percentile": 0.97776}, "CVE-2013-10050": {"epss_score": 0.61919, "epss_percentile": 0.98267}, "CVE-2013-10051": {"epss_score": 0.75811, "epss_percentile": 0.98865}, "CVE-2013-10052": {"epss_score": 0.01577, "epss_percentile": 0.81118}, "CVE-2013-10053": {"epss_score": 0.59564, "epss_percentile": 0.98171}, "CVE-2013-10054": {"epss_score": 0.73719, "epss_percentile": 0.9877}, "CVE-2013-10055": {"epss_score": 0.73481, "epss_percentile": 0.98758}, "CVE-2013-10057": {"epss_score": 0.61089, "epss_percentile": 0.98234}, "CVE-2013-10058": {"epss_score": 0.46601, "epss_percentile": 0.97554}, "CVE-2013-10059": {"epss_score": 0.50834, "epss_percentile": 0.97751}, "CVE-2013-10060": {"epss_score": 0.61009, "epss_percentile": 0.9823}, "CVE-2013-10061": {"epss_score": 0.7314, "epss_percentile": 0.98738}, "CVE-2013-10062": {"epss_score": 0.42709, "epss_percentile": 0.97348}, "CVE-2013-10063": {"epss_score": 0.47848, "epss_percentile": 0.97604}, "CVE-2013-10064": {"epss_score": 0.63827, "epss_percentile": 0.98351}, "CVE-2013-10065": {"epss_score": 0.48914, "epss_percentile": 0.97659}, "CVE-2013-10066": {"epss_score": 0.73719, "epss_percentile": 0.9877}, "CVE-2013-10067": {"epss_score": 0.28314, "epss_percentile": 0.96342}, "CVE-2013-10068": {"epss_score": 0.54698, "epss_percentile": 0.97939}, "CVE-2013-10069": {"epss_score": 0.7168, "epss_percentile": 0.98677}, "CVE-2013-10070": {"epss_score": 0.58784, "epss_percentile": 0.98137}, "CVE-2013-10071": {"epss_score": 0.00508, "epss_percentile": 0.65685}, "CVE-2013-10072": {"epss_score": 0.00133, "epss_percentile": 0.33736}, "CVE-2013-10073": {"epss_score": 0.0183, "epss_percentile": 0.82447}, "CVE-2013-10074": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2013-1000": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2013-1001": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2013-1002": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2013-1003": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2013-1004": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2013-1005": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2013-1006": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2013-1007": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2013-1008": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2013-1009": {"epss_score": 0.00665, "epss_percentile": 0.70665}, "CVE-2013-1010": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2013-1011": {"epss_score": 0.00764, "epss_percentile": 0.72903}, "CVE-2013-1012": {"epss_score": 0.0049, "epss_percentile": 0.64918}, "CVE-2013-1013": {"epss_score": 0.003, "epss_percentile": 0.52954}, "CVE-2013-1014": {"epss_score": 0.00036, "epss_percentile": 0.10337}, "CVE-2013-1015": {"epss_score": 0.06538, "epss_percentile": 0.9083}, "CVE-2013-1016": {"epss_score": 0.04902, "epss_percentile": 0.89273}, "CVE-2013-1017": {"epss_score": 0.81301, "epss_percentile": 0.99132}, "CVE-2013-1018": {"epss_score": 0.04593, "epss_percentile": 0.88895}, "CVE-2013-1019": {"epss_score": 0.03632, "epss_percentile": 0.87474}, "CVE-2013-1020": {"epss_score": 0.05846, "epss_percentile": 0.90256}, "CVE-2013-1021": {"epss_score": 0.06239, "epss_percentile": 0.90591}, "CVE-2013-1022": {"epss_score": 0.05854, "epss_percentile": 0.90264}, "CVE-2013-1023": {"epss_score": 0.00665, "epss_percentile": 0.70665}, "CVE-2013-1024": {"epss_score": 0.00901, "epss_percentile": 0.75169}, "CVE-2013-1025": {"epss_score": 0.01127, "epss_percentile": 0.7782}, "CVE-2013-1026": {"epss_score": 0.01, "epss_percentile": 0.76488}, "CVE-2013-1027": {"epss_score": 0.00489, "epss_percentile": 0.64901}, "CVE-2013-1028": {"epss_score": 0.00217, "epss_percentile": 0.44277}, "CVE-2013-1029": {"epss_score": 0.00474, "epss_percentile": 0.64154}, "CVE-2013-1030": {"epss_score": 0.00114, "epss_percentile": 0.30836}, "CVE-2013-1031": {"epss_score": 0.00055, "epss_percentile": 0.17654}, "CVE-2013-1032": {"epss_score": 0.0104, "epss_percentile": 0.76954}, "CVE-2013-1033": {"epss_score": 0.00211, "epss_percentile": 0.43646}, "CVE-2013-1034": {"epss_score": 0.00384, "epss_percentile": 0.59182}, "CVE-2013-1035": {"epss_score": 0.03476, "epss_percentile": 0.87208}, "CVE-2013-1036": {"epss_score": 0.02238, "epss_percentile": 0.84105}, "CVE-2013-1037": {"epss_score": 0.02313, "epss_percentile": 0.8435}, "CVE-2013-1038": {"epss_score": 0.02313, "epss_percentile": 0.8435}, "CVE-2013-1039": {"epss_score": 0.02313, "epss_percentile": 0.8435}, "CVE-2013-1040": {"epss_score": 0.02313, "epss_percentile": 0.8435}, "CVE-2013-1041": {"epss_score": 0.02313, "epss_percentile": 0.8435}, "CVE-2013-1042": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2013-1043": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2013-1044": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2013-1045": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2013-1046": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2013-1047": {"epss_score": 0.02313, "epss_percentile": 0.8435}, "CVE-2013-1048": {"epss_score": 0.00054, "epss_percentile": 0.17077}, "CVE-2013-1049": {"epss_score": 0.01562, "epss_percentile": 0.81048}, "CVE-2013-1050": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2013-1051": {"epss_score": 0.00125, "epss_percentile": 0.32535}, "CVE-2013-1052": {"epss_score": 0.00073, "epss_percentile": 0.22487}, "CVE-2013-1053": {"epss_score": 0.00024, "epss_percentile": 0.06028}, "CVE-2013-1054": {"epss_score": 0.00345, "epss_percentile": 0.56602}, "CVE-2013-1055": {"epss_score": 0.00336, "epss_percentile": 0.56006}, "CVE-2013-1056": {"epss_score": 0.00054, "epss_percentile": 0.17072}, "CVE-2013-1057": {"epss_score": 0.00097, "epss_percentile": 0.27539}, "CVE-2013-1058": {"epss_score": 0.00666, "epss_percentile": 0.70694}, "CVE-2013-1059": {"epss_score": 0.01788, "epss_percentile": 0.82263}, "CVE-2013-1060": {"epss_score": 0.00058, "epss_percentile": 0.18368}, "CVE-2013-1061": {"epss_score": 0.00062, "epss_percentile": 0.19613}, "CVE-2013-1062": {"epss_score": 0.00047, "epss_percentile": 0.14584}, "CVE-2013-1063": {"epss_score": 0.00061, "epss_percentile": 0.1954}, "CVE-2013-1064": {"epss_score": 0.00061, "epss_percentile": 0.1954}, "CVE-2013-1065": {"epss_score": 0.00058, "epss_percentile": 0.18407}, "CVE-2013-1066": {"epss_score": 0.00062, "epss_percentile": 0.19613}, "CVE-2013-1067": {"epss_score": 0.00042, "epss_percentile": 0.12932}, "CVE-2013-1068": {"epss_score": 0.00222, "epss_percentile": 0.44753}, "CVE-2013-1069": {"epss_score": 0.00047, "epss_percentile": 0.14474}, "CVE-2013-1070": {"epss_score": 0.00336, "epss_percentile": 0.5594}, "CVE-2013-1079": {"epss_score": 0.01173, "epss_percentile": 0.78236}, "CVE-2013-1080": {"epss_score": 0.72916, "epss_percentile": 0.98729}, "CVE-2013-1081": {"epss_score": 0.80561, "epss_percentile": 0.99095}, "CVE-2013-1082": {"epss_score": 0.04789, "epss_percentile": 0.89148}, "CVE-2013-1083": {"epss_score": 0.00259, "epss_percentile": 0.49076}, "CVE-2013-1084": {"epss_score": 0.05, "epss_percentile": 0.89377}, "CVE-2013-1085": {"epss_score": 0.20584, "epss_percentile": 0.95381}, "CVE-2013-1086": {"epss_score": 0.00765, "epss_percentile": 0.72911}, "CVE-2013-1087": {"epss_score": 0.01912, "epss_percentile": 0.82835}, "CVE-2013-1088": {"epss_score": 0.00264, "epss_percentile": 0.49551}, "CVE-2013-1090": {"epss_score": 0.00049, "epss_percentile": 0.15303}, "CVE-2013-1091": {"epss_score": 0.14038, "epss_percentile": 0.9412}, "CVE-2013-1092": {"epss_score": 0.00044, "epss_percentile": 0.13368}, "CVE-2013-1093": {"epss_score": 0.00881, "epss_percentile": 0.74865}, "CVE-2013-1094": {"epss_score": 0.01032, "epss_percentile": 0.76867}, "CVE-2013-1095": {"epss_score": 0.00762, "epss_percentile": 0.72841}, "CVE-2013-1096": {"epss_score": 0.01461, "epss_percentile": 0.80433}, "CVE-2013-1097": {"epss_score": 0.00762, "epss_percentile": 0.72841}, "CVE-2013-1100": {"epss_score": 0.00633, "epss_percentile": 0.69768}, "CVE-2013-1102": {"epss_score": 0.00644, "epss_percentile": 0.70082}, "CVE-2013-1103": {"epss_score": 0.00708, "epss_percentile": 0.71668}, "CVE-2013-1104": {"epss_score": 0.01184, "epss_percentile": 0.78328}, "CVE-2013-1105": {"epss_score": 0.00604, "epss_percentile": 0.68965}, "CVE-2013-1107": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2013-1108": {"epss_score": 0.00157, "epss_percentile": 0.37136}, "CVE-2013-1109": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2013-1110": {"epss_score": 0.00152, "epss_percentile": 0.36431}, "CVE-2013-1111": {"epss_score": 0.00523, "epss_percentile": 0.66289}, "CVE-2013-1112": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2013-1113": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-1114": {"epss_score": 0.1338, "epss_percentile": 0.93947}, "CVE-2013-1115": {"epss_score": 0.01512, "epss_percentile": 0.80783}, "CVE-2013-1116": {"epss_score": 0.01512, "epss_percentile": 0.80783}, "CVE-2013-1117": {"epss_score": 0.02202, "epss_percentile": 0.83985}, "CVE-2013-1118": {"epss_score": 0.03294, "epss_percentile": 0.86844}, "CVE-2013-1119": {"epss_score": 0.02202, "epss_percentile": 0.83985}, "CVE-2013-1120": {"epss_score": 0.00577, "epss_percentile": 0.68162}, "CVE-2013-1121": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1122": {"epss_score": 0.00708, "epss_percentile": 0.71674}, "CVE-2013-1123": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2013-1124": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2013-1125": {"epss_score": 0.00086, "epss_percentile": 0.25343}, "CVE-2013-1128": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2013-1129": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-1130": {"epss_score": 0.00152, "epss_percentile": 0.36468}, "CVE-2013-1131": {"epss_score": 0.00209, "epss_percentile": 0.43319}, "CVE-2013-1132": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-1133": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1134": {"epss_score": 0.00515, "epss_percentile": 0.66002}, "CVE-2013-1135": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2013-1136": {"epss_score": 0.00046, "epss_percentile": 0.14181}, "CVE-2013-1137": {"epss_score": 0.0023, "epss_percentile": 0.45714}, "CVE-2013-1138": {"epss_score": 0.00545, "epss_percentile": 0.67152}, "CVE-2013-1139": {"epss_score": 0.00153, "epss_percentile": 0.36612}, "CVE-2013-1140": {"epss_score": 0.00379, "epss_percentile": 0.58848}, "CVE-2013-1141": {"epss_score": 0.00158, "epss_percentile": 0.37258}, "CVE-2013-1142": {"epss_score": 0.00288, "epss_percentile": 0.51868}, "CVE-2013-1143": {"epss_score": 0.00187, "epss_percentile": 0.40747}, "CVE-2013-1144": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1145": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1146": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1147": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1148": {"epss_score": 0.00313, "epss_percentile": 0.54032}, "CVE-2013-1149": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2013-1150": {"epss_score": 0.00692, "epss_percentile": 0.71294}, "CVE-2013-1151": {"epss_score": 0.00215, "epss_percentile": 0.44037}, "CVE-2013-1152": {"epss_score": 0.0071, "epss_percentile": 0.71723}, "CVE-2013-1153": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2013-1154": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2013-1155": {"epss_score": 0.00393, "epss_percentile": 0.5972}, "CVE-2013-1156": {"epss_score": 0.00156, "epss_percentile": 0.36961}, "CVE-2013-1157": {"epss_score": 0.00232, "epss_percentile": 0.45911}, "CVE-2013-1158": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-1159": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-1160": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-1161": {"epss_score": 0.0034, "epss_percentile": 0.56224}, "CVE-2013-1162": {"epss_score": 0.00658, "epss_percentile": 0.70495}, "CVE-2013-1163": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2013-1164": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1165": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1166": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1167": {"epss_score": 0.00277, "epss_percentile": 0.50811}, "CVE-2013-1168": {"epss_score": 0.01075, "epss_percentile": 0.77304}, "CVE-2013-1169": {"epss_score": 0.00446, "epss_percentile": 0.62908}, "CVE-2013-1170": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2013-1171": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-1172": {"epss_score": 0.00082, "epss_percentile": 0.24591}, "CVE-2013-1173": {"epss_score": 0.00087, "epss_percentile": 0.25617}, "CVE-2013-1174": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-1176": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2013-1177": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2013-1178": {"epss_score": 0.01639, "epss_percentile": 0.81489}, "CVE-2013-1179": {"epss_score": 0.04423, "epss_percentile": 0.88672}, "CVE-2013-1180": {"epss_score": 0.04423, "epss_percentile": 0.88672}, "CVE-2013-1181": {"epss_score": 0.00811, "epss_percentile": 0.73724}, "CVE-2013-1182": {"epss_score": 0.00884, "epss_percentile": 0.74927}, "CVE-2013-1183": {"epss_score": 0.10568, "epss_percentile": 0.93029}, "CVE-2013-1184": {"epss_score": 0.00811, "epss_percentile": 0.73724}, "CVE-2013-1185": {"epss_score": 0.00587, "epss_percentile": 0.68464}, "CVE-2013-1186": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2013-1187": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-1188": {"epss_score": 0.00661, "epss_percentile": 0.70565}, "CVE-2013-1189": {"epss_score": 0.0017, "epss_percentile": 0.38729}, "CVE-2013-1190": {"epss_score": 0.00438, "epss_percentile": 0.62545}, "CVE-2013-1191": {"epss_score": 0.00891, "epss_percentile": 0.75035}, "CVE-2013-1192": {"epss_score": 0.00815, "epss_percentile": 0.73781}, "CVE-2013-1193": {"epss_score": 0.00677, "epss_percentile": 0.70955}, "CVE-2013-1194": {"epss_score": 0.00375, "epss_percentile": 0.58619}, "CVE-2013-1195": {"epss_score": 0.00156, "epss_percentile": 0.36949}, "CVE-2013-1196": {"epss_score": 0.0008, "epss_percentile": 0.24167}, "CVE-2013-1197": {"epss_score": 0.00363, "epss_percentile": 0.57874}, "CVE-2013-1198": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-1199": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2013-1200": {"epss_score": 0.00365, "epss_percentile": 0.57965}, "CVE-2013-1202": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2013-1203": {"epss_score": 0.00586, "epss_percentile": 0.68444}, "CVE-2013-1204": {"epss_score": 0.00658, "epss_percentile": 0.70495}, "CVE-2013-1205": {"epss_score": 0.0031, "epss_percentile": 0.53777}, "CVE-2013-1208": {"epss_score": 0.00173, "epss_percentile": 0.39059}, "CVE-2013-1209": {"epss_score": 0.00071, "epss_percentile": 0.2216}, "CVE-2013-1210": {"epss_score": 0.0071, "epss_percentile": 0.71723}, "CVE-2013-1211": {"epss_score": 0.00353, "epss_percentile": 0.57195}, "CVE-2013-1212": {"epss_score": 0.00176, "epss_percentile": 0.39392}, "CVE-2013-1213": {"epss_score": 0.00677, "epss_percentile": 0.70955}, "CVE-2013-1214": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-1215": {"epss_score": 0.00324, "epss_percentile": 0.54963}, "CVE-2013-1216": {"epss_score": 0.00413, "epss_percentile": 0.60993}, "CVE-2013-1217": {"epss_score": 0.00363, "epss_percentile": 0.57874}, "CVE-2013-1218": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1219": {"epss_score": 0.00082, "epss_percentile": 0.24488}, "CVE-2013-1220": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1221": {"epss_score": 0.06261, "epss_percentile": 0.9062}, "CVE-2013-1222": {"epss_score": 0.00301, "epss_percentile": 0.53044}, "CVE-2013-1223": {"epss_score": 0.00377, "epss_percentile": 0.5872}, "CVE-2013-1224": {"epss_score": 0.0029, "epss_percentile": 0.52112}, "CVE-2013-1225": {"epss_score": 0.0057, "epss_percentile": 0.67954}, "CVE-2013-1226": {"epss_score": 0.0052, "epss_percentile": 0.66195}, "CVE-2013-1227": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-1228": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2013-1229": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-1230": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-1231": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2013-1232": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2013-1234": {"epss_score": 0.00413, "epss_percentile": 0.60993}, "CVE-2013-1235": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-1236": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1240": {"epss_score": 0.00061, "epss_percentile": 0.1933}, "CVE-2013-1241": {"epss_score": 0.00366, "epss_percentile": 0.58089}, "CVE-2013-1242": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2013-1243": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-1244": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-1245": {"epss_score": 0.00183, "epss_percentile": 0.40304}, "CVE-2013-1246": {"epss_score": 0.00605, "epss_percentile": 0.68983}, "CVE-2013-1247": {"epss_score": 0.00296, "epss_percentile": 0.52563}, "CVE-2013-1248": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1249": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1250": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1251": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1252": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1253": {"epss_score": 0.00269, "epss_percentile": 0.50112}, "CVE-2013-1254": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1255": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1256": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1257": {"epss_score": 0.00753, "epss_percentile": 0.72671}, "CVE-2013-1258": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1259": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1260": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1261": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1262": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1263": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1264": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1265": {"epss_score": 0.00269, "epss_percentile": 0.50112}, "CVE-2013-1266": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1267": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1268": {"epss_score": 0.00568, "epss_percentile": 0.67908}, "CVE-2013-1269": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1270": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1271": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1272": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1273": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1274": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2013-1275": {"epss_score": 0.00269, "epss_percentile": 0.50112}, "CVE-2013-1276": {"epss_score": 0.00453, "epss_percentile": 0.63204}, "CVE-2013-1277": {"epss_score": 0.00453, "epss_percentile": 0.63204}, "CVE-2013-1278": {"epss_score": 0.00372, "epss_percentile": 0.5846}, "CVE-2013-1279": {"epss_score": 0.0047, "epss_percentile": 0.63966}, "CVE-2013-1280": {"epss_score": 0.00991, "epss_percentile": 0.76384}, "CVE-2013-1281": {"epss_score": 0.68543, "epss_percentile": 0.98552}, "CVE-2013-1282": {"epss_score": 0.45222, "epss_percentile": 0.97477}, "CVE-2013-1283": {"epss_score": 0.00645, "epss_percentile": 0.70104}, "CVE-2013-1284": {"epss_score": 0.00284, "epss_percentile": 0.51467}, "CVE-2013-1285": {"epss_score": 0.00502, "epss_percentile": 0.65371}, "CVE-2013-1286": {"epss_score": 0.00502, "epss_percentile": 0.65371}, "CVE-2013-1287": {"epss_score": 0.00502, "epss_percentile": 0.65371}, "CVE-2013-1288": {"epss_score": 0.59114, "epss_percentile": 0.9815}, "CVE-2013-1289": {"epss_score": 0.44955, "epss_percentile": 0.97463}, "CVE-2013-1290": {"epss_score": 0.13302, "epss_percentile": 0.93927}, "CVE-2013-1291": {"epss_score": 0.17215, "epss_percentile": 0.948}, "CVE-2013-1292": {"epss_score": 0.00471, "epss_percentile": 0.64023}, "CVE-2013-1293": {"epss_score": 0.00775, "epss_percentile": 0.73083}, "CVE-2013-1294": {"epss_score": 0.00226, "epss_percentile": 0.45342}, "CVE-2013-1295": {"epss_score": 0.0076, "epss_percentile": 0.7281}, "CVE-2013-1296": {"epss_score": 0.53982, "epss_percentile": 0.97906}, "CVE-2013-1297": {"epss_score": 0.15065, "epss_percentile": 0.94354}, "CVE-2013-1299": {"epss_score": 0.17837, "epss_percentile": 0.94914}, "CVE-2013-1300": {"epss_score": 0.27221, "epss_percentile": 0.96222}, "CVE-2013-1301": {"epss_score": 0.27835, "epss_percentile": 0.96286}, "CVE-2013-1302": {"epss_score": 0.44406, "epss_percentile": 0.97433}, "CVE-2013-1303": {"epss_score": 0.33491, "epss_percentile": 0.96778}, "CVE-2013-1304": {"epss_score": 0.36834, "epss_percentile": 0.97003}, "CVE-2013-1305": {"epss_score": 0.83169, "epss_percentile": 0.99237}, "CVE-2013-1306": {"epss_score": 0.16933, "epss_percentile": 0.94749}, "CVE-2013-1307": {"epss_score": 0.4096, "epss_percentile": 0.97248}, "CVE-2013-1308": {"epss_score": 0.24836, "epss_percentile": 0.95958}, "CVE-2013-1309": {"epss_score": 0.37985, "epss_percentile": 0.9708}, "CVE-2013-1310": {"epss_score": 0.4096, "epss_percentile": 0.97248}, "CVE-2013-1311": {"epss_score": 0.46068, "epss_percentile": 0.9752}, "CVE-2013-1312": {"epss_score": 0.4096, "epss_percentile": 0.97248}, "CVE-2013-1313": {"epss_score": 0.64092, "epss_percentile": 0.98364}, "CVE-2013-1315": {"epss_score": 0.73678, "epss_percentile": 0.98767}, "CVE-2013-1316": {"epss_score": 0.58631, "epss_percentile": 0.98129}, "CVE-2013-1317": {"epss_score": 0.64763, "epss_percentile": 0.9839}, "CVE-2013-1318": {"epss_score": 0.60978, "epss_percentile": 0.98229}, "CVE-2013-1319": {"epss_score": 0.60978, "epss_percentile": 0.98229}, "CVE-2013-1320": {"epss_score": 0.62065, "epss_percentile": 0.98275}, "CVE-2013-1321": {"epss_score": 0.53314, "epss_percentile": 0.9787}, "CVE-2013-1322": {"epss_score": 0.60978, "epss_percentile": 0.98229}, "CVE-2013-1323": {"epss_score": 0.54934, "epss_percentile": 0.97953}, "CVE-2013-1324": {"epss_score": 0.59759, "epss_percentile": 0.9818}, "CVE-2013-1325": {"epss_score": 0.59759, "epss_percentile": 0.9818}, "CVE-2013-1327": {"epss_score": 0.58631, "epss_percentile": 0.98129}, "CVE-2013-1328": {"epss_score": 0.58631, "epss_percentile": 0.98129}, "CVE-2013-1329": {"epss_score": 0.58631, "epss_percentile": 0.98129}, "CVE-2013-1330": {"epss_score": 0.67143, "epss_percentile": 0.98497}, "CVE-2013-1331": {"epss_score": 0.85807, "epss_percentile": 0.9935}, "CVE-2013-1332": {"epss_score": 0.03922, "epss_percentile": 0.87954}, "CVE-2013-1333": {"epss_score": 0.03523, "epss_percentile": 0.8729}, "CVE-2013-1334": {"epss_score": 0.03392, "epss_percentile": 0.87053}, "CVE-2013-1335": {"epss_score": 0.54934, "epss_percentile": 0.97953}, "CVE-2013-1336": {"epss_score": 0.60243, "epss_percentile": 0.982}, "CVE-2013-1337": {"epss_score": 0.22765, "epss_percentile": 0.95684}, "CVE-2013-1338": {"epss_score": 0.33491, "epss_percentile": 0.96778}, "CVE-2013-1339": {"epss_score": 0.26434, "epss_percentile": 0.96147}, "CVE-2013-1340": {"epss_score": 0.00881, "epss_percentile": 0.74877}, "CVE-2013-1341": {"epss_score": 0.0067, "epss_percentile": 0.70787}, "CVE-2013-1342": {"epss_score": 0.00858, "epss_percentile": 0.74503}, "CVE-2013-1343": {"epss_score": 0.00954, "epss_percentile": 0.75908}, "CVE-2013-1344": {"epss_score": 0.00954, "epss_percentile": 0.75908}, "CVE-2013-1345": {"epss_score": 0.02845, "epss_percentile": 0.8582}, "CVE-2013-1346": {"epss_score": 0.18263, "epss_percentile": 0.94984}, "CVE-2013-1347": {"epss_score": 0.8925, "epss_percentile": 0.99516}, "CVE-2013-1348": {"epss_score": 0.00619, "epss_percentile": 0.69401}, "CVE-2013-1349": {"epss_score": 0.70857, "epss_percentile": 0.98645}, "CVE-2013-1350": {"epss_score": 0.00606, "epss_percentile": 0.69017}, "CVE-2013-1351": {"epss_score": 0.00844, "epss_percentile": 0.74277}, "CVE-2013-1352": {"epss_score": 0.00881, "epss_percentile": 0.74864}, "CVE-2013-1353": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2013-1359": {"epss_score": 0.89468, "epss_percentile": 0.99528}, "CVE-2013-1360": {"epss_score": 0.57719, "epss_percentile": 0.9808}, "CVE-2013-1361": {"epss_score": 0.0429, "epss_percentile": 0.88501}, "CVE-2013-1362": {"epss_score": 0.76437, "epss_percentile": 0.9889}, "CVE-2013-1364": {"epss_score": 0.00441, "epss_percentile": 0.62695}, "CVE-2013-1365": {"epss_score": 0.04189, "epss_percentile": 0.88374}, "CVE-2013-1366": {"epss_score": 0.04189, "epss_percentile": 0.88374}, "CVE-2013-1367": {"epss_score": 0.04189, "epss_percentile": 0.88374}, "CVE-2013-1368": {"epss_score": 0.04189, "epss_percentile": 0.88374}, "CVE-2013-1369": {"epss_score": 0.04189, "epss_percentile": 0.88374}, "CVE-2013-1370": {"epss_score": 0.04189, "epss_percentile": 0.88374}, "CVE-2013-1371": {"epss_score": 0.03725, "epss_percentile": 0.87631}, "CVE-2013-1372": {"epss_score": 0.04189, "epss_percentile": 0.88374}, "CVE-2013-1373": {"epss_score": 0.04189, "epss_percentile": 0.88374}, "CVE-2013-1374": {"epss_score": 0.04685, "epss_percentile": 0.89006}, "CVE-2013-1375": {"epss_score": 0.10638, "epss_percentile": 0.93055}, "CVE-2013-1376": {"epss_score": 0.23023, "epss_percentile": 0.9572}, "CVE-2013-1377": {"epss_score": 0.11434, "epss_percentile": 0.93352}, "CVE-2013-1378": {"epss_score": 0.07028, "epss_percentile": 0.91196}, "CVE-2013-1379": {"epss_score": 0.05703, "epss_percentile": 0.90134}, "CVE-2013-1380": {"epss_score": 0.09513, "epss_percentile": 0.9258}, "CVE-2013-1383": {"epss_score": 0.11427, "epss_percentile": 0.93345}, "CVE-2013-1384": {"epss_score": 0.12308, "epss_percentile": 0.9363}, "CVE-2013-1385": {"epss_score": 0.01878, "epss_percentile": 0.82669}, "CVE-2013-1386": {"epss_score": 0.12308, "epss_percentile": 0.9363}, "CVE-2013-1387": {"epss_score": 0.01848, "epss_percentile": 0.82526}, "CVE-2013-1388": {"epss_score": 0.01848, "epss_percentile": 0.82526}, "CVE-2013-1389": {"epss_score": 0.21562, "epss_percentile": 0.95534}, "CVE-2013-1391": {"epss_score": 0.87146, "epss_percentile": 0.99418}, "CVE-2013-1393": {"epss_score": 0.00469, "epss_percentile": 0.63939}, "CVE-2013-1397": {"epss_score": 0.00619, "epss_percentile": 0.69401}, "CVE-2013-1398": {"epss_score": 0.00616, "epss_percentile": 0.69328}, "CVE-2013-1399": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2013-1400": {"epss_score": 0.02312, "epss_percentile": 0.84342}, "CVE-2013-1401": {"epss_score": 0.04561, "epss_percentile": 0.88852}, "CVE-2013-1402": {"epss_score": 0.06061, "epss_percentile": 0.90443}, "CVE-2013-1405": {"epss_score": 0.00902, "epss_percentile": 0.75192}, "CVE-2013-1406": {"epss_score": 0.00743, "epss_percentile": 0.72502}, "CVE-2013-1407": {"epss_score": 0.00306, "epss_percentile": 0.53464}, "CVE-2013-1408": {"epss_score": 0.02578, "epss_percentile": 0.85147}, "CVE-2013-1409": {"epss_score": 0.03377, "epss_percentile": 0.87024}, "CVE-2013-1410": {"epss_score": 0.00756, "epss_percentile": 0.72725}, "CVE-2013-1412": {"epss_score": 0.8524, "epss_percentile": 0.99324}, "CVE-2013-1413": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2013-1414": {"epss_score": 0.00384, "epss_percentile": 0.5917}, "CVE-2013-1415": {"epss_score": 0.01588, "epss_percentile": 0.81189}, "CVE-2013-1416": {"epss_score": 0.02637, "epss_percentile": 0.85296}, "CVE-2013-1417": {"epss_score": 0.00543, "epss_percentile": 0.6709}, "CVE-2013-1418": {"epss_score": 0.07674, "epss_percentile": 0.91618}, "CVE-2013-1420": {"epss_score": 0.00417, "epss_percentile": 0.61231}, "CVE-2013-1421": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-1422": {"epss_score": 0.00319, "epss_percentile": 0.54465}, "CVE-2013-1423": {"epss_score": 0.00031, "epss_percentile": 0.08455}, "CVE-2013-1424": {"epss_score": 0.00079, "epss_percentile": 0.23975}, "CVE-2013-1425": {"epss_score": 0.00097, "epss_percentile": 0.27549}, "CVE-2013-1426": {"epss_score": 0.00414, "epss_percentile": 0.61026}, "CVE-2013-1427": {"epss_score": 0.0004, "epss_percentile": 0.12083}, "CVE-2013-1428": {"epss_score": 0.65516, "epss_percentile": 0.98424}, "CVE-2013-1429": {"epss_score": 0.00998, "epss_percentile": 0.7647}, "CVE-2013-1430": {"epss_score": 0.00349, "epss_percentile": 0.56884}, "CVE-2013-1431": {"epss_score": 0.00434, "epss_percentile": 0.62312}, "CVE-2013-1432": {"epss_score": 0.0041, "epss_percentile": 0.60817}, "CVE-2013-1434": {"epss_score": 0.01147, "epss_percentile": 0.78007}, "CVE-2013-1435": {"epss_score": 0.01044, "epss_percentile": 0.77003}, "CVE-2013-1436": {"epss_score": 0.08161, "epss_percentile": 0.9191}, "CVE-2013-1437": {"epss_score": 0.00945, "epss_percentile": 0.758}, "CVE-2013-1438": {"epss_score": 0.00479, "epss_percentile": 0.64419}, "CVE-2013-1439": {"epss_score": 0.00476, "epss_percentile": 0.64271}, "CVE-2013-1441": {"epss_score": 0.00344, "epss_percentile": 0.56508}, "CVE-2013-1442": {"epss_score": 0.0011, "epss_percentile": 0.3022}, "CVE-2013-1443": {"epss_score": 0.01041, "epss_percentile": 0.76968}, "CVE-2013-1444": {"epss_score": 0.0004, "epss_percentile": 0.1215}, "CVE-2013-1445": {"epss_score": 0.00424, "epss_percentile": 0.61659}, "CVE-2013-1447": {"epss_score": 0.00724, "epss_percentile": 0.72033}, "CVE-2013-1450": {"epss_score": 0.16551, "epss_percentile": 0.94688}, "CVE-2013-1451": {"epss_score": 0.09626, "epss_percentile": 0.92629}, "CVE-2013-1453": {"epss_score": 0.00051, "epss_percentile": 0.16142}, "CVE-2013-1454": {"epss_score": 0.00287, "epss_percentile": 0.51826}, "CVE-2013-1455": {"epss_score": 0.00287, "epss_percentile": 0.51826}, "CVE-2013-1461": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2013-1462": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2013-1463": {"epss_score": 0.06117, "epss_percentile": 0.90491}, "CVE-2013-1464": {"epss_score": 0.0352, "epss_percentile": 0.87287}, "CVE-2013-1465": {"epss_score": 0.3101, "epss_percentile": 0.96582}, "CVE-2013-1466": {"epss_score": 0.08713, "epss_percentile": 0.92223}, "CVE-2013-1468": {"epss_score": 0.18848, "epss_percentile": 0.9508}, "CVE-2013-1469": {"epss_score": 0.51633, "epss_percentile": 0.97791}, "CVE-2013-1470": {"epss_score": 0.004, "epss_percentile": 0.60191}, "CVE-2013-1471": {"epss_score": 0.04896, "epss_percentile": 0.8927}, "CVE-2013-1472": {"epss_score": 0.01293, "epss_percentile": 0.79237}, "CVE-2013-1473": {"epss_score": 0.05083, "epss_percentile": 0.89475}, "CVE-2013-1474": {"epss_score": 0.01179, "epss_percentile": 0.7829}, "CVE-2013-1475": {"epss_score": 0.01025, "epss_percentile": 0.76785}, "CVE-2013-1476": {"epss_score": 0.01278, "epss_percentile": 0.79128}, "CVE-2013-1477": {"epss_score": 0.01178, "epss_percentile": 0.78286}, "CVE-2013-1478": {"epss_score": 0.01082, "epss_percentile": 0.77382}, "CVE-2013-1479": {"epss_score": 0.01992, "epss_percentile": 0.83179}, "CVE-2013-1480": {"epss_score": 0.02018, "epss_percentile": 0.83284}, "CVE-2013-1481": {"epss_score": 0.08537, "epss_percentile": 0.92109}, "CVE-2013-1482": {"epss_score": 0.01471, "epss_percentile": 0.80504}, "CVE-2013-1483": {"epss_score": 0.01471, "epss_percentile": 0.80504}, "CVE-2013-1484": {"epss_score": 0.00869, "epss_percentile": 0.74685}, "CVE-2013-1485": {"epss_score": 0.00575, "epss_percentile": 0.68116}, "CVE-2013-1486": {"epss_score": 0.01171, "epss_percentile": 0.78221}, "CVE-2013-1487": {"epss_score": 0.03052, "epss_percentile": 0.86293}, "CVE-2013-1488": {"epss_score": 0.85092, "epss_percentile": 0.99317}, "CVE-2013-1489": {"epss_score": 0.15258, "epss_percentile": 0.94393}, "CVE-2013-1490": {"epss_score": 0.01316, "epss_percentile": 0.79411}, "CVE-2013-1491": {"epss_score": 0.19623, "epss_percentile": 0.95215}, "CVE-2013-1492": {"epss_score": 0.01065, "epss_percentile": 0.77205}, "CVE-2013-1493": {"epss_score": 0.92647, "epss_percentile": 0.99733}, "CVE-2013-1494": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2013-1495": {"epss_score": 0.00116, "epss_percentile": 0.31181}, "CVE-2013-1496": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2013-1497": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2013-1498": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2013-1499": {"epss_score": 0.00049, "epss_percentile": 0.15292}, "CVE-2013-1500": {"epss_score": 0.00088, "epss_percentile": 0.25698}, "CVE-2013-1501": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-1502": {"epss_score": 0.00101, "epss_percentile": 0.28664}, "CVE-2013-1503": {"epss_score": 0.00139, "epss_percentile": 0.34537}, "CVE-2013-1504": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2013-1505": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2013-1506": {"epss_score": 0.00444, "epss_percentile": 0.62826}, "CVE-2013-1507": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2013-1508": {"epss_score": 0.00165, "epss_percentile": 0.38046}, "CVE-2013-1509": {"epss_score": 0.16013, "epss_percentile": 0.94559}, "CVE-2013-1510": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2013-1511": {"epss_score": 0.00362, "epss_percentile": 0.57765}, "CVE-2013-1512": {"epss_score": 0.00459, "epss_percentile": 0.63463}, "CVE-2013-1513": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-1514": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-1515": {"epss_score": 0.00291, "epss_percentile": 0.52209}, "CVE-2013-1516": {"epss_score": 0.00444, "epss_percentile": 0.62817}, "CVE-2013-1517": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2013-1518": {"epss_score": 0.07462, "epss_percentile": 0.91486}, "CVE-2013-1519": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2013-1520": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2013-1521": {"epss_score": 0.0053, "epss_percentile": 0.66608}, "CVE-2013-1522": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2013-1523": {"epss_score": 0.00357, "epss_percentile": 0.57409}, "CVE-2013-1524": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-1525": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-1526": {"epss_score": 0.00459, "epss_percentile": 0.63463}, "CVE-2013-1527": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-1528": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-1529": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2013-1530": {"epss_score": 0.00045, "epss_percentile": 0.13992}, "CVE-2013-1531": {"epss_score": 0.00539, "epss_percentile": 0.66972}, "CVE-2013-1532": {"epss_score": 0.00479, "epss_percentile": 0.64445}, "CVE-2013-1533": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2013-1534": {"epss_score": 0.01899, "epss_percentile": 0.82767}, "CVE-2013-1535": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2013-1536": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-1537": {"epss_score": 0.10465, "epss_percentile": 0.92995}, "CVE-2013-1538": {"epss_score": 0.00897, "epss_percentile": 0.75135}, "CVE-2013-1539": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-1540": {"epss_score": 0.05795, "epss_percentile": 0.90216}, "CVE-2013-1541": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-1542": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-1543": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-1544": {"epss_score": 0.00471, "epss_percentile": 0.64015}, "CVE-2013-1545": {"epss_score": 0.0065, "epss_percentile": 0.70259}, "CVE-2013-1546": {"epss_score": 0.00107, "epss_percentile": 0.29739}, "CVE-2013-1547": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-1548": {"epss_score": 0.00684, "epss_percentile": 0.71112}, "CVE-2013-1549": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-1550": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-1551": {"epss_score": 0.00351, "epss_percentile": 0.5704}, "CVE-2013-1552": {"epss_score": 0.00539, "epss_percentile": 0.66972}, "CVE-2013-1553": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2013-1554": {"epss_score": 0.00897, "epss_percentile": 0.75135}, "CVE-2013-1555": {"epss_score": 0.00324, "epss_percentile": 0.54947}, "CVE-2013-1556": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-1557": {"epss_score": 0.11182, "epss_percentile": 0.93255}, "CVE-2013-1558": {"epss_score": 0.0652, "epss_percentile": 0.90818}, "CVE-2013-1559": {"epss_score": 0.69453, "epss_percentile": 0.98587}, "CVE-2013-1560": {"epss_score": 0.00191, "epss_percentile": 0.41182}, "CVE-2013-1561": {"epss_score": 0.00584, "epss_percentile": 0.68379}, "CVE-2013-1562": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-1563": {"epss_score": 0.03922, "epss_percentile": 0.87955}, "CVE-2013-1564": {"epss_score": 0.00769, "epss_percentile": 0.72986}, "CVE-2013-1565": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2013-1566": {"epss_score": 0.00295, "epss_percentile": 0.52516}, "CVE-2013-1567": {"epss_score": 0.00295, "epss_percentile": 0.52516}, "CVE-2013-1568": {"epss_score": 0.00355, "epss_percentile": 0.57273}, "CVE-2013-1569": {"epss_score": 0.05558, "epss_percentile": 0.89991}, "CVE-2013-1570": {"epss_score": 0.00514, "epss_percentile": 0.6596}, "CVE-2013-1571": {"epss_score": 0.21514, "epss_percentile": 0.95527}, "CVE-2013-1572": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1573": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1574": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1575": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1576": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1577": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1578": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1579": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1580": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1581": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1582": {"epss_score": 0.00294, "epss_percentile": 0.52421}, "CVE-2013-1583": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1584": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1585": {"epss_score": 0.00265, "epss_percentile": 0.49818}, "CVE-2013-1586": {"epss_score": 0.00335, "epss_percentile": 0.55797}, "CVE-2013-1587": {"epss_score": 0.00228, "epss_percentile": 0.45509}, "CVE-2013-1588": {"epss_score": 0.00509, "epss_percentile": 0.65738}, "CVE-2013-1589": {"epss_score": 0.00265, "epss_percentile": 0.49818}, "CVE-2013-1590": {"epss_score": 0.00286, "epss_percentile": 0.51763}, "CVE-2013-1591": {"epss_score": 0.01394, "epss_percentile": 0.79969}, "CVE-2013-1592": {"epss_score": 0.68888, "epss_percentile": 0.98567}, "CVE-2013-1593": {"epss_score": 0.02657, "epss_percentile": 0.8536}, "CVE-2013-1594": {"epss_score": 0.22437, "epss_percentile": 0.95634}, "CVE-2013-1595": {"epss_score": 0.03877, "epss_percentile": 0.87889}, "CVE-2013-1596": {"epss_score": 0.2341, "epss_percentile": 0.95774}, "CVE-2013-1597": {"epss_score": 0.10881, "epss_percentile": 0.93145}, "CVE-2013-1598": {"epss_score": 0.32164, "epss_percentile": 0.96674}, "CVE-2013-1599": {"epss_score": 0.92105, "epss_percentile": 0.99691}, "CVE-2013-1600": {"epss_score": 0.72694, "epss_percentile": 0.98723}, "CVE-2013-1601": {"epss_score": 0.3742, "epss_percentile": 0.97045}, "CVE-2013-1602": {"epss_score": 0.48319, "epss_percentile": 0.9763}, "CVE-2013-1603": {"epss_score": 0.57383, "epss_percentile": 0.9806}, "CVE-2013-1604": {"epss_score": 0.12794, "epss_percentile": 0.93774}, "CVE-2013-1605": {"epss_score": 0.20322, "epss_percentile": 0.95325}, "CVE-2013-1606": {"epss_score": 0.14298, "epss_percentile": 0.94181}, "CVE-2013-1607": {"epss_score": 0.01263, "epss_percentile": 0.78989}, "CVE-2013-1608": {"epss_score": 0.00212, "epss_percentile": 0.43797}, "CVE-2013-1609": {"epss_score": 0.00244, "epss_percentile": 0.47602}, "CVE-2013-1610": {"epss_score": 0.00047, "epss_percentile": 0.14833}, "CVE-2013-1611": {"epss_score": 0.0028, "epss_percentile": 0.51073}, "CVE-2013-1612": {"epss_score": 0.03444, "epss_percentile": 0.87144}, "CVE-2013-1613": {"epss_score": 0.00516, "epss_percentile": 0.66012}, "CVE-2013-1614": {"epss_score": 0.00349, "epss_percentile": 0.56876}, "CVE-2013-1615": {"epss_score": 0.00114, "epss_percentile": 0.30865}, "CVE-2013-1616": {"epss_score": 0.19278, "epss_percentile": 0.95159}, "CVE-2013-1617": {"epss_score": 0.01332, "epss_percentile": 0.79523}, "CVE-2013-1618": {"epss_score": 0.00526, "epss_percentile": 0.66431}, "CVE-2013-1619": {"epss_score": 0.00998, "epss_percentile": 0.7647}, "CVE-2013-1620": {"epss_score": 0.00808, "epss_percentile": 0.73698}, "CVE-2013-1621": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2013-1623": {"epss_score": 0.00935, "epss_percentile": 0.75668}, "CVE-2013-1624": {"epss_score": 0.00387, "epss_percentile": 0.593}, "CVE-2013-1627": {"epss_score": 0.08978, "epss_percentile": 0.92349}, "CVE-2013-1629": {"epss_score": 0.39922, "epss_percentile": 0.97188}, "CVE-2013-1630": {"epss_score": 0.00531, "epss_percentile": 0.66658}, "CVE-2013-1631": {"epss_score": 0.00209, "epss_percentile": 0.43325}, "CVE-2013-1633": {"epss_score": 0.00765, "epss_percentile": 0.72911}, "CVE-2013-1634": {"epss_score": 0.07175, "epss_percentile": 0.913}, "CVE-2013-1635": {"epss_score": 0.04953, "epss_percentile": 0.89325}, "CVE-2013-1636": {"epss_score": 0.1032, "epss_percentile": 0.92943}, "CVE-2013-1637": {"epss_score": 0.04554, "epss_percentile": 0.88843}, "CVE-2013-1638": {"epss_score": 0.25416, "epss_percentile": 0.96026}, "CVE-2013-1639": {"epss_score": 0.00107, "epss_percentile": 0.29718}, "CVE-2013-1640": {"epss_score": 0.01948, "epss_percentile": 0.83009}, "CVE-2013-1641": {"epss_score": 0.00978, "epss_percentile": 0.76243}, "CVE-2013-1642": {"epss_score": 0.00566, "epss_percentile": 0.6781}, "CVE-2013-1643": {"epss_score": 0.01216, "epss_percentile": 0.78597}, "CVE-2013-1645": {"epss_score": 0.02186, "epss_percentile": 0.8392}, "CVE-2013-1646": {"epss_score": 0.00878, "epss_percentile": 0.74827}, "CVE-2013-1647": {"epss_score": 0.01463, "epss_percentile": 0.80445}, "CVE-2013-1648": {"epss_score": 0.00806, "epss_percentile": 0.73663}, "CVE-2013-1649": {"epss_score": 0.01953, "epss_percentile": 0.83026}, "CVE-2013-1650": {"epss_score": 0.00587, "epss_percentile": 0.68482}, "CVE-2013-1651": {"epss_score": 0.00628, "epss_percentile": 0.69664}, "CVE-2013-1652": {"epss_score": 0.00396, "epss_percentile": 0.59886}, "CVE-2013-1653": {"epss_score": 0.02231, "epss_percentile": 0.84089}, "CVE-2013-1654": {"epss_score": 0.00458, "epss_percentile": 0.63429}, "CVE-2013-1655": {"epss_score": 0.00721, "epss_percentile": 0.71987}, "CVE-2013-1656": {"epss_score": 0.00305, "epss_percentile": 0.53368}, "CVE-2013-1659": {"epss_score": 0.0088, "epss_percentile": 0.7486}, "CVE-2013-1661": {"epss_score": 0.00364, "epss_percentile": 0.57957}, "CVE-2013-1662": {"epss_score": 0.05774, "epss_percentile": 0.90196}, "CVE-2013-1664": {"epss_score": 0.03049, "epss_percentile": 0.86286}, "CVE-2013-1665": {"epss_score": 0.02312, "epss_percentile": 0.84341}, "CVE-2013-1666": {"epss_score": 0.04126, "epss_percentile": 0.88289}, "CVE-2013-1667": {"epss_score": 0.03606, "epss_percentile": 0.87418}, "CVE-2013-1668": {"epss_score": 0.09112, "epss_percentile": 0.92405}, "CVE-2013-1669": {"epss_score": 0.03289, "epss_percentile": 0.86833}, "CVE-2013-1670": {"epss_score": 0.44789, "epss_percentile": 0.97453}, "CVE-2013-1671": {"epss_score": 0.00575, "epss_percentile": 0.68117}, "CVE-2013-1672": {"epss_score": 0.00032, "epss_percentile": 0.08794}, "CVE-2013-1673": {"epss_score": 0.00047, "epss_percentile": 0.14504}, "CVE-2013-1674": {"epss_score": 0.04031, "epss_percentile": 0.8815}, "CVE-2013-1675": {"epss_score": 0.04742, "epss_percentile": 0.89081}, "CVE-2013-1676": {"epss_score": 0.01594, "epss_percentile": 0.8123}, "CVE-2013-1677": {"epss_score": 0.01396, "epss_percentile": 0.79981}, "CVE-2013-1678": {"epss_score": 0.03732, "epss_percentile": 0.87647}, "CVE-2013-1679": {"epss_score": 0.02169, "epss_percentile": 0.83865}, "CVE-2013-1680": {"epss_score": 0.03184, "epss_percentile": 0.86587}, "CVE-2013-1681": {"epss_score": 0.02797, "epss_percentile": 0.85686}, "CVE-2013-1682": {"epss_score": 0.0176, "epss_percentile": 0.82146}, "CVE-2013-1683": {"epss_score": 0.0176, "epss_percentile": 0.82146}, "CVE-2013-1684": {"epss_score": 0.00782, "epss_percentile": 0.73205}, "CVE-2013-1685": {"epss_score": 0.00782, "epss_percentile": 0.73205}, "CVE-2013-1686": {"epss_score": 0.02451, "epss_percentile": 0.84788}, "CVE-2013-1687": {"epss_score": 0.02642, "epss_percentile": 0.85308}, "CVE-2013-1688": {"epss_score": 0.01199, "epss_percentile": 0.78462}, "CVE-2013-1689": {"epss_score": 0.00359, "epss_percentile": 0.57569}, "CVE-2013-1690": {"epss_score": 0.49616, "epss_percentile": 0.97697}, "CVE-2013-1692": {"epss_score": 0.01015, "epss_percentile": 0.76663}, "CVE-2013-1693": {"epss_score": 0.00616, "epss_percentile": 0.69326}, "CVE-2013-1694": {"epss_score": 0.02922, "epss_percentile": 0.85994}, "CVE-2013-1695": {"epss_score": 0.00161, "epss_percentile": 0.3755}, "CVE-2013-1696": {"epss_score": 0.00432, "epss_percentile": 0.6211}, "CVE-2013-1697": {"epss_score": 0.02642, "epss_percentile": 0.85308}, "CVE-2013-1698": {"epss_score": 0.00328, "epss_percentile": 0.55295}, "CVE-2013-1699": {"epss_score": 0.00367, "epss_percentile": 0.58142}, "CVE-2013-1700": {"epss_score": 0.00149, "epss_percentile": 0.35938}, "CVE-2013-1701": {"epss_score": 0.03551, "epss_percentile": 0.8734}, "CVE-2013-1702": {"epss_score": 0.01241, "epss_percentile": 0.78818}, "CVE-2013-1704": {"epss_score": 0.04703, "epss_percentile": 0.89029}, "CVE-2013-1705": {"epss_score": 0.05283, "epss_percentile": 0.89691}, "CVE-2013-1706": {"epss_score": 0.00049, "epss_percentile": 0.15619}, "CVE-2013-1707": {"epss_score": 0.00049, "epss_percentile": 0.15619}, "CVE-2013-1708": {"epss_score": 0.05278, "epss_percentile": 0.89684}, "CVE-2013-1709": {"epss_score": 0.00521, "epss_percentile": 0.66224}, "CVE-2013-1710": {"epss_score": 0.79223, "epss_percentile": 0.99024}, "CVE-2013-1711": {"epss_score": 0.01865, "epss_percentile": 0.82602}, "CVE-2013-1712": {"epss_score": 0.00166, "epss_percentile": 0.38196}, "CVE-2013-1713": {"epss_score": 0.00466, "epss_percentile": 0.6379}, "CVE-2013-1714": {"epss_score": 0.01083, "epss_percentile": 0.77391}, "CVE-2013-1715": {"epss_score": 0.00166, "epss_percentile": 0.38196}, "CVE-2013-1717": {"epss_score": 0.0057, "epss_percentile": 0.67946}, "CVE-2013-1718": {"epss_score": 0.01556, "epss_percentile": 0.81014}, "CVE-2013-1719": {"epss_score": 0.02381, "epss_percentile": 0.84565}, "CVE-2013-1720": {"epss_score": 0.0194, "epss_percentile": 0.82981}, "CVE-2013-1721": {"epss_score": 0.00638, "epss_percentile": 0.69902}, "CVE-2013-1722": {"epss_score": 0.03865, "epss_percentile": 0.87871}, "CVE-2013-1723": {"epss_score": 0.01795, "epss_percentile": 0.82294}, "CVE-2013-1724": {"epss_score": 0.03159, "epss_percentile": 0.86521}, "CVE-2013-1725": {"epss_score": 0.02856, "epss_percentile": 0.85841}, "CVE-2013-1726": {"epss_score": 0.00107, "epss_percentile": 0.2964}, "CVE-2013-1727": {"epss_score": 0.0224, "epss_percentile": 0.84112}, "CVE-2013-1728": {"epss_score": 0.00769, "epss_percentile": 0.72987}, "CVE-2013-1729": {"epss_score": 0.00426, "epss_percentile": 0.6176}, "CVE-2013-1730": {"epss_score": 0.00729, "epss_percentile": 0.72124}, "CVE-2013-1731": {"epss_score": 0.01004, "epss_percentile": 0.76531}, "CVE-2013-1732": {"epss_score": 0.33161, "epss_percentile": 0.9675}, "CVE-2013-1733": {"epss_score": 0.00117, "epss_percentile": 0.31381}, "CVE-2013-1734": {"epss_score": 0.00117, "epss_percentile": 0.31381}, "CVE-2013-1735": {"epss_score": 0.04502, "epss_percentile": 0.88767}, "CVE-2013-1736": {"epss_score": 0.03732, "epss_percentile": 0.87647}, "CVE-2013-1737": {"epss_score": 0.00418, "epss_percentile": 0.61275}, "CVE-2013-1738": {"epss_score": 0.03359, "epss_percentile": 0.86989}, "CVE-2013-1739": {"epss_score": 0.02647, "epss_percentile": 0.85338}, "CVE-2013-1740": {"epss_score": 0.01047, "epss_percentile": 0.77033}, "CVE-2013-1741": {"epss_score": 0.02604, "epss_percentile": 0.85217}, "CVE-2013-1742": {"epss_score": 0.00748, "epss_percentile": 0.72587}, "CVE-2013-1743": {"epss_score": 0.00903, "epss_percentile": 0.75202}, "CVE-2013-1744": {"epss_score": 0.19516, "epss_percentile": 0.95197}, "CVE-2013-1747": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2013-1748": {"epss_score": 0.00171, "epss_percentile": 0.38801}, "CVE-2013-1749": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-1750": {"epss_score": 0.07088, "epss_percentile": 0.91242}, "CVE-2013-1751": {"epss_score": 0.04692, "epss_percentile": 0.89012}, "CVE-2013-1753": {"epss_score": 0.00455, "epss_percentile": 0.63285}, "CVE-2013-1756": {"epss_score": 0.01982, "epss_percentile": 0.83141}, "CVE-2013-1758": {"epss_score": 0.00347, "epss_percentile": 0.56792}, "CVE-2013-1759": {"epss_score": 0.00235, "epss_percentile": 0.46205}, "CVE-2013-1760": {"epss_score": 0.00347, "epss_percentile": 0.56776}, "CVE-2013-1762": {"epss_score": 0.0201, "epss_percentile": 0.83245}, "CVE-2013-1763": {"epss_score": 0.1636, "epss_percentile": 0.94635}, "CVE-2013-1764": {"epss_score": 0.00063, "epss_percentile": 0.2006}, "CVE-2013-1765": {"epss_score": 0.0112, "epss_percentile": 0.77763}, "CVE-2013-1766": {"epss_score": 0.00056, "epss_percentile": 0.17869}, "CVE-2013-1767": {"epss_score": 0.00043, "epss_percentile": 0.12961}, "CVE-2013-1768": {"epss_score": 0.10569, "epss_percentile": 0.9303}, "CVE-2013-1769": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2013-1770": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2013-1771": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2013-1772": {"epss_score": 0.00045, "epss_percentile": 0.13965}, "CVE-2013-1773": {"epss_score": 0.00185, "epss_percentile": 0.40515}, "CVE-2013-1774": {"epss_score": 0.00042, "epss_percentile": 0.12602}, "CVE-2013-1775": {"epss_score": 0.0813, "epss_percentile": 0.91895}, "CVE-2013-1776": {"epss_score": 0.0005, "epss_percentile": 0.15772}, "CVE-2013-1777": {"epss_score": 0.04819, "epss_percentile": 0.89173}, "CVE-2013-1778": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2013-1779": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2013-1780": {"epss_score": 0.00354, "epss_percentile": 0.57245}, "CVE-2013-1781": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2013-1782": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2013-1783": {"epss_score": 0.00354, "epss_percentile": 0.57245}, "CVE-2013-1784": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2013-1785": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2013-1786": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2013-1787": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2013-1788": {"epss_score": 0.04145, "epss_percentile": 0.88313}, "CVE-2013-1789": {"epss_score": 0.02846, "epss_percentile": 0.85822}, "CVE-2013-1790": {"epss_score": 0.02981, "epss_percentile": 0.86122}, "CVE-2013-1792": {"epss_score": 0.00033, "epss_percentile": 0.09284}, "CVE-2013-1793": {"epss_score": 0.00277, "epss_percentile": 0.50793}, "CVE-2013-1794": {"epss_score": 0.02802, "epss_percentile": 0.857}, "CVE-2013-1795": {"epss_score": 0.02115, "epss_percentile": 0.83656}, "CVE-2013-1796": {"epss_score": 0.00778, "epss_percentile": 0.73123}, "CVE-2013-1797": {"epss_score": 0.00458, "epss_percentile": 0.63417}, "CVE-2013-1798": {"epss_score": 0.00251, "epss_percentile": 0.4833}, "CVE-2013-1799": {"epss_score": 0.00556, "epss_percentile": 0.67508}, "CVE-2013-1800": {"epss_score": 0.01653, "epss_percentile": 0.8158}, "CVE-2013-1801": {"epss_score": 0.02991, "epss_percentile": 0.86144}, "CVE-2013-1802": {"epss_score": 0.01686, "epss_percentile": 0.81753}, "CVE-2013-1803": {"epss_score": 0.04778, "epss_percentile": 0.89134}, "CVE-2013-1804": {"epss_score": 0.0871, "epss_percentile": 0.92222}, "CVE-2013-1806": {"epss_score": 0.16703, "epss_percentile": 0.94718}, "CVE-2013-1807": {"epss_score": 0.18032, "epss_percentile": 0.94946}, "CVE-2013-1808": {"epss_score": 0.01856, "epss_percentile": 0.82573}, "CVE-2013-1809": {"epss_score": 0.01701, "epss_percentile": 0.81835}, "CVE-2013-1810": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2013-1811": {"epss_score": 0.00325, "epss_percentile": 0.5502}, "CVE-2013-1812": {"epss_score": 0.00531, "epss_percentile": 0.66651}, "CVE-2013-1813": {"epss_score": 0.00093, "epss_percentile": 0.2663}, "CVE-2013-1814": {"epss_score": 0.85269, "epss_percentile": 0.99326}, "CVE-2013-1815": {"epss_score": 0.00153, "epss_percentile": 0.36627}, "CVE-2013-1816": {"epss_score": 0.04103, "epss_percentile": 0.88262}, "CVE-2013-1817": {"epss_score": 0.01553, "epss_percentile": 0.80997}, "CVE-2013-1818": {"epss_score": 0.00333, "epss_percentile": 0.55655}, "CVE-2013-1819": {"epss_score": 0.0004, "epss_percentile": 0.1204}, "CVE-2013-1820": {"epss_score": 0.00135, "epss_percentile": 0.3397}, "CVE-2013-1821": {"epss_score": 0.20672, "epss_percentile": 0.954}, "CVE-2013-1822": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-1823": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2013-1824": {"epss_score": 0.02064, "epss_percentile": 0.83452}, "CVE-2013-1826": {"epss_score": 0.00098, "epss_percentile": 0.2768}, "CVE-2013-1827": {"epss_score": 0.0005, "epss_percentile": 0.15938}, "CVE-2013-1828": {"epss_score": 0.00181, "epss_percentile": 0.40026}, "CVE-2013-1829": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2013-1830": {"epss_score": 0.00401, "epss_percentile": 0.60214}, "CVE-2013-1831": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2013-1832": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2013-1833": {"epss_score": 0.00208, "epss_percentile": 0.43213}, "CVE-2013-1834": {"epss_score": 0.00306, "epss_percentile": 0.53452}, "CVE-2013-1835": {"epss_score": 0.00306, "epss_percentile": 0.53452}, "CVE-2013-1836": {"epss_score": 0.00644, "epss_percentile": 0.70088}, "CVE-2013-1838": {"epss_score": 0.01427, "epss_percentile": 0.80212}, "CVE-2013-1839": {"epss_score": 0.36541, "epss_percentile": 0.96986}, "CVE-2013-1840": {"epss_score": 0.00344, "epss_percentile": 0.56475}, "CVE-2013-1841": {"epss_score": 0.00147, "epss_percentile": 0.35645}, "CVE-2013-1842": {"epss_score": 0.03325, "epss_percentile": 0.86921}, "CVE-2013-1843": {"epss_score": 0.00634, "epss_percentile": 0.69804}, "CVE-2013-1844": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-1845": {"epss_score": 0.01837, "epss_percentile": 0.82481}, "CVE-2013-1846": {"epss_score": 0.01917, "epss_percentile": 0.82861}, "CVE-2013-1847": {"epss_score": 0.44297, "epss_percentile": 0.97429}, "CVE-2013-1848": {"epss_score": 0.00034, "epss_percentile": 0.09755}, "CVE-2013-1849": {"epss_score": 0.15287, "epss_percentile": 0.944}, "CVE-2013-1850": {"epss_score": 0.00485, "epss_percentile": 0.64739}, "CVE-2013-1851": {"epss_score": 0.00171, "epss_percentile": 0.38827}, "CVE-2013-1852": {"epss_score": 0.01492, "epss_percentile": 0.80636}, "CVE-2013-1853": {"epss_score": 0.00063, "epss_percentile": 0.2009}, "CVE-2013-1854": {"epss_score": 0.01795, "epss_percentile": 0.82296}, "CVE-2013-1855": {"epss_score": 0.00536, "epss_percentile": 0.66846}, "CVE-2013-1856": {"epss_score": 0.00773, "epss_percentile": 0.73051}, "CVE-2013-1857": {"epss_score": 0.00625, "epss_percentile": 0.69587}, "CVE-2013-1858": {"epss_score": 0.00646, "epss_percentile": 0.70147}, "CVE-2013-1859": {"epss_score": 0.00277, "epss_percentile": 0.50797}, "CVE-2013-1860": {"epss_score": 0.0009, "epss_percentile": 0.26079}, "CVE-2013-1861": {"epss_score": 0.20756, "epss_percentile": 0.95409}, "CVE-2013-1862": {"epss_score": 0.4176, "epss_percentile": 0.97292}, "CVE-2013-1863": {"epss_score": 0.00283, "epss_percentile": 0.51411}, "CVE-2013-1864": {"epss_score": 0.02732, "epss_percentile": 0.85544}, "CVE-2013-1865": {"epss_score": 0.01162, "epss_percentile": 0.78153}, "CVE-2013-1866": {"epss_score": 0.00149, "epss_percentile": 0.35998}, "CVE-2013-1867": {"epss_score": 0.00149, "epss_percentile": 0.35998}, "CVE-2013-1868": {"epss_score": 0.50657, "epss_percentile": 0.97744}, "CVE-2013-1869": {"epss_score": 0.00417, "epss_percentile": 0.61235}, "CVE-2013-1871": {"epss_score": 0.00287, "epss_percentile": 0.51809}, "CVE-2013-1872": {"epss_score": 0.01134, "epss_percentile": 0.7789}, "CVE-2013-1874": {"epss_score": 0.00088, "epss_percentile": 0.25649}, "CVE-2013-1875": {"epss_score": 0.00731, "epss_percentile": 0.72181}, "CVE-2013-1879": {"epss_score": 0.05475, "epss_percentile": 0.89911}, "CVE-2013-1880": {"epss_score": 0.01367, "epss_percentile": 0.79782}, "CVE-2013-1881": {"epss_score": 0.07767, "epss_percentile": 0.91671}, "CVE-2013-1883": {"epss_score": 0.01428, "epss_percentile": 0.80221}, "CVE-2013-1884": {"epss_score": 0.31605, "epss_percentile": 0.96638}, "CVE-2013-1885": {"epss_score": 0.00238, "epss_percentile": 0.46752}, "CVE-2013-1886": {"epss_score": 0.01671, "epss_percentile": 0.81676}, "CVE-2013-1887": {"epss_score": 0.00282, "epss_percentile": 0.51282}, "CVE-2013-1888": {"epss_score": 0.00085, "epss_percentile": 0.25114}, "CVE-2013-1889": {"epss_score": 0.00591, "epss_percentile": 0.68578}, "CVE-2013-1890": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-1891": {"epss_score": 0.04021, "epss_percentile": 0.88134}, "CVE-2013-1892": {"epss_score": 0.52332, "epss_percentile": 0.9782}, "CVE-2013-1893": {"epss_score": 0.00351, "epss_percentile": 0.57053}, "CVE-2013-1895": {"epss_score": 0.00279, "epss_percentile": 0.50925}, "CVE-2013-1896": {"epss_score": 0.38555, "epss_percentile": 0.97105}, "CVE-2013-1897": {"epss_score": 0.0041, "epss_percentile": 0.60806}, "CVE-2013-1898": {"epss_score": 0.00977, "epss_percentile": 0.76217}, "CVE-2013-1899": {"epss_score": 0.71644, "epss_percentile": 0.98675}, "CVE-2013-1900": {"epss_score": 0.00802, "epss_percentile": 0.73584}, "CVE-2013-1901": {"epss_score": 0.00242, "epss_percentile": 0.47372}, "CVE-2013-1902": {"epss_score": 0.0055, "epss_percentile": 0.67326}, "CVE-2013-1903": {"epss_score": 0.0055, "epss_percentile": 0.67326}, "CVE-2013-1904": {"epss_score": 0.00402, "epss_percentile": 0.603}, "CVE-2013-1905": {"epss_score": 0.00467, "epss_percentile": 0.63861}, "CVE-2013-1906": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-1907": {"epss_score": 0.00748, "epss_percentile": 0.72588}, "CVE-2013-1908": {"epss_score": 0.00608, "epss_percentile": 0.69084}, "CVE-2013-1909": {"epss_score": 0.006, "epss_percentile": 0.68827}, "CVE-2013-1910": {"epss_score": 0.00854, "epss_percentile": 0.74456}, "CVE-2013-1911": {"epss_score": 0.005, "epss_percentile": 0.6532}, "CVE-2013-1912": {"epss_score": 0.00143, "epss_percentile": 0.35149}, "CVE-2013-1913": {"epss_score": 0.02017, "epss_percentile": 0.83281}, "CVE-2013-1914": {"epss_score": 0.03398, "epss_percentile": 0.87062}, "CVE-2013-1915": {"epss_score": 0.04848, "epss_percentile": 0.89211}, "CVE-2013-1916": {"epss_score": 0.26475, "epss_percentile": 0.9615}, "CVE-2013-1917": {"epss_score": 0.00074, "epss_percentile": 0.22859}, "CVE-2013-1918": {"epss_score": 0.00097, "epss_percentile": 0.27493}, "CVE-2013-1919": {"epss_score": 0.00096, "epss_percentile": 0.27296}, "CVE-2013-1920": {"epss_score": 0.00064, "epss_percentile": 0.20131}, "CVE-2013-1921": {"epss_score": 0.00049, "epss_percentile": 0.15316}, "CVE-2013-1922": {"epss_score": 0.00079, "epss_percentile": 0.23854}, "CVE-2013-1923": {"epss_score": 0.00395, "epss_percentile": 0.59839}, "CVE-2013-1924": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2013-1925": {"epss_score": 0.00423, "epss_percentile": 0.61598}, "CVE-2013-1926": {"epss_score": 0.00883, "epss_percentile": 0.74915}, "CVE-2013-1927": {"epss_score": 0.02232, "epss_percentile": 0.84091}, "CVE-2013-1928": {"epss_score": 0.00055, "epss_percentile": 0.17424}, "CVE-2013-1929": {"epss_score": 0.00122, "epss_percentile": 0.32077}, "CVE-2013-1930": {"epss_score": 0.00701, "epss_percentile": 0.71503}, "CVE-2013-1931": {"epss_score": 0.01434, "epss_percentile": 0.80263}, "CVE-2013-1932": {"epss_score": 0.00691, "epss_percentile": 0.71272}, "CVE-2013-1933": {"epss_score": 0.02836, "epss_percentile": 0.8579}, "CVE-2013-1934": {"epss_score": 0.00347, "epss_percentile": 0.56758}, "CVE-2013-1935": {"epss_score": 0.00226, "epss_percentile": 0.45273}, "CVE-2013-1937": {"epss_score": 0.08106, "epss_percentile": 0.91882}, "CVE-2013-1938": {"epss_score": 0.02279, "epss_percentile": 0.8424}, "CVE-2013-1939": {"epss_score": 0.00287, "epss_percentile": 0.51815}, "CVE-2013-1940": {"epss_score": 0.00111, "epss_percentile": 0.30276}, "CVE-2013-1941": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2013-1942": {"epss_score": 0.08796, "epss_percentile": 0.92258}, "CVE-2013-1943": {"epss_score": 0.00124, "epss_percentile": 0.32452}, "CVE-2013-1944": {"epss_score": 0.02482, "epss_percentile": 0.84877}, "CVE-2013-1945": {"epss_score": 0.00112, "epss_percentile": 0.30579}, "CVE-2013-1946": {"epss_score": 0.00476, "epss_percentile": 0.64272}, "CVE-2013-1947": {"epss_score": 0.02449, "epss_percentile": 0.84777}, "CVE-2013-1948": {"epss_score": 0.01745, "epss_percentile": 0.82067}, "CVE-2013-1949": {"epss_score": 0.00397, "epss_percentile": 0.5994}, "CVE-2013-1950": {"epss_score": 0.08839, "epss_percentile": 0.92278}, "CVE-2013-1951": {"epss_score": 0.0198, "epss_percentile": 0.83136}, "CVE-2013-1952": {"epss_score": 0.00071, "epss_percentile": 0.22206}, "CVE-2013-1953": {"epss_score": 0.00347, "epss_percentile": 0.56753}, "CVE-2013-1954": {"epss_score": 0.02271, "epss_percentile": 0.84216}, "CVE-2013-1955": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-1956": {"epss_score": 0.0003, "epss_percentile": 0.08202}, "CVE-2013-1957": {"epss_score": 0.00039, "epss_percentile": 0.11839}, "CVE-2013-1958": {"epss_score": 0.00039, "epss_percentile": 0.11839}, "CVE-2013-1959": {"epss_score": 0.01052, "epss_percentile": 0.77097}, "CVE-2013-1960": {"epss_score": 0.04531, "epss_percentile": 0.88811}, "CVE-2013-1961": {"epss_score": 0.01867, "epss_percentile": 0.82618}, "CVE-2013-1962": {"epss_score": 0.03779, "epss_percentile": 0.87712}, "CVE-2013-1963": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2013-1964": {"epss_score": 0.00076, "epss_percentile": 0.23223}, "CVE-2013-1965": {"epss_score": 0.91333, "epss_percentile": 0.99635}, "CVE-2013-1966": {"epss_score": 0.90954, "epss_percentile": 0.99611}, "CVE-2013-1967": {"epss_score": 0.00567, "epss_percentile": 0.67854}, "CVE-2013-1968": {"epss_score": 0.00644, "epss_percentile": 0.70088}, "CVE-2013-1969": {"epss_score": 0.00954, "epss_percentile": 0.75902}, "CVE-2013-1971": {"epss_score": 0.00158, "epss_percentile": 0.37221}, "CVE-2013-1972": {"epss_score": 0.0045, "epss_percentile": 0.63095}, "CVE-2013-1973": {"epss_score": 0.00246, "epss_percentile": 0.47792}, "CVE-2013-1976": {"epss_score": 0.00033, "epss_percentile": 0.09385}, "CVE-2013-1977": {"epss_score": 0.00114, "epss_percentile": 0.30856}, "CVE-2013-1978": {"epss_score": 0.03438, "epss_percentile": 0.87136}, "CVE-2013-1979": {"epss_score": 0.00041, "epss_percentile": 0.12326}, "CVE-2013-1980": {"epss_score": 0.04893, "epss_percentile": 0.89267}, "CVE-2013-1981": {"epss_score": 0.00894, "epss_percentile": 0.75086}, "CVE-2013-1982": {"epss_score": 0.00489, "epss_percentile": 0.64903}, "CVE-2013-1983": {"epss_score": 0.00909, "epss_percentile": 0.75311}, "CVE-2013-1984": {"epss_score": 0.00904, "epss_percentile": 0.75216}, "CVE-2013-1985": {"epss_score": 0.00836, "epss_percentile": 0.74129}, "CVE-2013-1986": {"epss_score": 0.00904, "epss_percentile": 0.75216}, "CVE-2013-1987": {"epss_score": 0.00894, "epss_percentile": 0.75086}, "CVE-2013-1988": {"epss_score": 0.00826, "epss_percentile": 0.73973}, "CVE-2013-1989": {"epss_score": 0.00904, "epss_percentile": 0.75216}, "CVE-2013-1990": {"epss_score": 0.00904, "epss_percentile": 0.75216}, "CVE-2013-1991": {"epss_score": 0.00683, "epss_percentile": 0.71108}, "CVE-2013-1992": {"epss_score": 0.00974, "epss_percentile": 0.76192}, "CVE-2013-1993": {"epss_score": 0.02022, "epss_percentile": 0.83301}, "CVE-2013-1994": {"epss_score": 0.00419, "epss_percentile": 0.61399}, "CVE-2013-1995": {"epss_score": 0.00826, "epss_percentile": 0.73973}, "CVE-2013-1996": {"epss_score": 0.00683, "epss_percentile": 0.71108}, "CVE-2013-1997": {"epss_score": 0.00727, "epss_percentile": 0.72096}, "CVE-2013-1998": {"epss_score": 0.00896, "epss_percentile": 0.75118}, "CVE-2013-1999": {"epss_score": 0.00906, "epss_percentile": 0.75256}, "CVE-2013-20001": {"epss_score": 0.00201, "epss_percentile": 0.42388}, "CVE-2013-20002": {"epss_score": 0.02797, "epss_percentile": 0.85685}, "CVE-2013-20003": {"epss_score": 0.00141, "epss_percentile": 0.34828}, "CVE-2013-20004": {"epss_score": 0.00472, "epss_percentile": 0.64045}, "CVE-2013-2000": {"epss_score": 0.00727, "epss_percentile": 0.72096}, "CVE-2013-2001": {"epss_score": 0.0115, "epss_percentile": 0.78025}, "CVE-2013-2002": {"epss_score": 0.00902, "epss_percentile": 0.75184}, "CVE-2013-2003": {"epss_score": 0.00899, "epss_percentile": 0.75155}, "CVE-2013-2004": {"epss_score": 0.00393, "epss_percentile": 0.59732}, "CVE-2013-2005": {"epss_score": 0.00679, "epss_percentile": 0.71005}, "CVE-2013-2006": {"epss_score": 0.00041, "epss_percentile": 0.12307}, "CVE-2013-2007": {"epss_score": 0.00034, "epss_percentile": 0.09533}, "CVE-2013-2008": {"epss_score": 0.00258, "epss_percentile": 0.48994}, "CVE-2013-2009": {"epss_score": 0.2601, "epss_percentile": 0.961}, "CVE-2013-2010": {"epss_score": 0.83164, "epss_percentile": 0.99235}, "CVE-2013-2011": {"epss_score": 0.05908, "epss_percentile": 0.90314}, "CVE-2013-2012": {"epss_score": 0.00095, "epss_percentile": 0.27165}, "CVE-2013-2013": {"epss_score": 0.00065, "epss_percentile": 0.2048}, "CVE-2013-2014": {"epss_score": 0.02372, "epss_percentile": 0.8453}, "CVE-2013-2015": {"epss_score": 0.00092, "epss_percentile": 0.26488}, "CVE-2013-2016": {"epss_score": 0.00074, "epss_percentile": 0.22766}, "CVE-2013-2017": {"epss_score": 0.00877, "epss_percentile": 0.74807}, "CVE-2013-2018": {"epss_score": 0.00586, "epss_percentile": 0.68439}, "CVE-2013-2019": {"epss_score": 0.01744, "epss_percentile": 0.82063}, "CVE-2013-2020": {"epss_score": 0.07627, "epss_percentile": 0.91581}, "CVE-2013-2021": {"epss_score": 0.14515, "epss_percentile": 0.94228}, "CVE-2013-2022": {"epss_score": 0.0063, "epss_percentile": 0.69693}, "CVE-2013-2023": {"epss_score": 0.00676, "epss_percentile": 0.70925}, "CVE-2013-2024": {"epss_score": 0.03116, "epss_percentile": 0.86435}, "CVE-2013-2025": {"epss_score": 0.00365, "epss_percentile": 0.5799}, "CVE-2013-2027": {"epss_score": 0.00021, "epss_percentile": 0.04898}, "CVE-2013-2028": {"epss_score": 0.92556, "epss_percentile": 0.99726}, "CVE-2013-2029": {"epss_score": 0.00031, "epss_percentile": 0.08448}, "CVE-2013-2030": {"epss_score": 0.00035, "epss_percentile": 0.1012}, "CVE-2013-2031": {"epss_score": 0.01605, "epss_percentile": 0.81287}, "CVE-2013-2032": {"epss_score": 0.0101, "epss_percentile": 0.76598}, "CVE-2013-2033": {"epss_score": 0.00178, "epss_percentile": 0.39663}, "CVE-2013-2034": {"epss_score": 0.00745, "epss_percentile": 0.72523}, "CVE-2013-2035": {"epss_score": 0.00043, "epss_percentile": 0.13212}, "CVE-2013-2036": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2013-2037": {"epss_score": 0.00492, "epss_percentile": 0.65006}, "CVE-2013-2038": {"epss_score": 0.0201, "epss_percentile": 0.83247}, "CVE-2013-2039": {"epss_score": 0.00139, "epss_percentile": 0.34565}, "CVE-2013-2040": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-2041": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-2042": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-2043": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2013-2044": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2013-2045": {"epss_score": 0.00351, "epss_percentile": 0.57053}, "CVE-2013-2046": {"epss_score": 0.00303, "epss_percentile": 0.53196}, "CVE-2013-2047": {"epss_score": 0.00061, "epss_percentile": 0.19495}, "CVE-2013-2048": {"epss_score": 0.00296, "epss_percentile": 0.52626}, "CVE-2013-2049": {"epss_score": 0.0016, "epss_percentile": 0.37443}, "CVE-2013-2050": {"epss_score": 0.54161, "epss_percentile": 0.97914}, "CVE-2013-2051": {"epss_score": 0.00338, "epss_percentile": 0.56157}, "CVE-2013-2052": {"epss_score": 0.00849, "epss_percentile": 0.74382}, "CVE-2013-2053": {"epss_score": 0.01646, "epss_percentile": 0.81536}, "CVE-2013-2054": {"epss_score": 0.01817, "epss_percentile": 0.82398}, "CVE-2013-2055": {"epss_score": 0.01627, "epss_percentile": 0.81433}, "CVE-2013-2056": {"epss_score": 0.00334, "epss_percentile": 0.55719}, "CVE-2013-2057": {"epss_score": 0.02017, "epss_percentile": 0.83282}, "CVE-2013-2058": {"epss_score": 0.00044, "epss_percentile": 0.13669}, "CVE-2013-2059": {"epss_score": 0.00908, "epss_percentile": 0.75275}, "CVE-2013-2060": {"epss_score": 0.2201, "epss_percentile": 0.95583}, "CVE-2013-2061": {"epss_score": 0.0145, "epss_percentile": 0.80354}, "CVE-2013-2062": {"epss_score": 0.00546, "epss_percentile": 0.67219}, "CVE-2013-2063": {"epss_score": 0.00974, "epss_percentile": 0.76192}, "CVE-2013-2064": {"epss_score": 0.00943, "epss_percentile": 0.75772}, "CVE-2013-2065": {"epss_score": 0.00499, "epss_percentile": 0.65286}, "CVE-2013-2066": {"epss_score": 0.00906, "epss_percentile": 0.75256}, "CVE-2013-2067": {"epss_score": 0.04253, "epss_percentile": 0.88455}, "CVE-2013-2068": {"epss_score": 0.78437, "epss_percentile": 0.98986}, "CVE-2013-2069": {"epss_score": 0.00063, "epss_percentile": 0.19833}, "CVE-2013-2070": {"epss_score": 0.04601, "epss_percentile": 0.88902}, "CVE-2013-2071": {"epss_score": 0.06868, "epss_percentile": 0.91084}, "CVE-2013-2072": {"epss_score": 0.00363, "epss_percentile": 0.57822}, "CVE-2013-2073": {"epss_score": 0.00152, "epss_percentile": 0.364}, "CVE-2013-2074": {"epss_score": 0.01467, "epss_percentile": 0.80476}, "CVE-2013-2075": {"epss_score": 0.00822, "epss_percentile": 0.73915}, "CVE-2013-2076": {"epss_score": 0.00182, "epss_percentile": 0.40221}, "CVE-2013-2077": {"epss_score": 0.00119, "epss_percentile": 0.31634}, "CVE-2013-2078": {"epss_score": 0.00055, "epss_percentile": 0.17566}, "CVE-2013-2079": {"epss_score": 0.00364, "epss_percentile": 0.57906}, "CVE-2013-2080": {"epss_score": 0.00423, "epss_percentile": 0.61598}, "CVE-2013-2081": {"epss_score": 0.00464, "epss_percentile": 0.63719}, "CVE-2013-2082": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2013-2083": {"epss_score": 0.00605, "epss_percentile": 0.68975}, "CVE-2013-2085": {"epss_score": 0.00256, "epss_percentile": 0.48821}, "CVE-2013-2086": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-2087": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2013-2088": {"epss_score": 0.06485, "epss_percentile": 0.9079}, "CVE-2013-2089": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2013-2090": {"epss_score": 0.01445, "epss_percentile": 0.80323}, "CVE-2013-2091": {"epss_score": 0.00737, "epss_percentile": 0.72328}, "CVE-2013-2092": {"epss_score": 0.00779, "epss_percentile": 0.73139}, "CVE-2013-2093": {"epss_score": 0.0381, "epss_percentile": 0.87758}, "CVE-2013-2094": {"epss_score": 0.62259, "epss_percentile": 0.98287}, "CVE-2013-2095": {"epss_score": 0.0267, "epss_percentile": 0.85387}, "CVE-2013-2096": {"epss_score": 0.00062, "epss_percentile": 0.19589}, "CVE-2013-2097": {"epss_score": 0.62954, "epss_percentile": 0.98314}, "CVE-2013-2099": {"epss_score": 0.04072, "epss_percentile": 0.88205}, "CVE-2013-2100": {"epss_score": 0.00593, "epss_percentile": 0.6864}, "CVE-2013-2101": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2013-2102": {"epss_score": 0.00139, "epss_percentile": 0.34545}, "CVE-2013-2103": {"epss_score": 0.00305, "epss_percentile": 0.5339}, "CVE-2013-2104": {"epss_score": 0.00769, "epss_percentile": 0.72979}, "CVE-2013-2105": {"epss_score": 0.00138, "epss_percentile": 0.34459}, "CVE-2013-2106": {"epss_score": 0.00397, "epss_percentile": 0.60035}, "CVE-2013-2107": {"epss_score": 0.00603, "epss_percentile": 0.68903}, "CVE-2013-2108": {"epss_score": 0.00234, "epss_percentile": 0.46194}, "CVE-2013-2109": {"epss_score": 0.00224, "epss_percentile": 0.44985}, "CVE-2013-2110": {"epss_score": 0.08454, "epss_percentile": 0.92059}, "CVE-2013-2111": {"epss_score": 0.00769, "epss_percentile": 0.72984}, "CVE-2013-2112": {"epss_score": 0.03697, "epss_percentile": 0.87586}, "CVE-2013-2113": {"epss_score": 0.47448, "epss_percentile": 0.97588}, "CVE-2013-2114": {"epss_score": 0.01399, "epss_percentile": 0.79993}, "CVE-2013-2115": {"epss_score": 0.91303, "epss_percentile": 0.99632}, "CVE-2013-2116": {"epss_score": 0.08652, "epss_percentile": 0.92172}, "CVE-2013-2117": {"epss_score": 0.00462, "epss_percentile": 0.63613}, "CVE-2013-2118": {"epss_score": 0.11956, "epss_percentile": 0.93526}, "CVE-2013-2119": {"epss_score": 0.00056, "epss_percentile": 0.17743}, "CVE-2013-2120": {"epss_score": 0.00069, "epss_percentile": 0.21521}, "CVE-2013-2121": {"epss_score": 0.60925, "epss_percentile": 0.98227}, "CVE-2013-2122": {"epss_score": 0.00592, "epss_percentile": 0.68615}, "CVE-2013-2123": {"epss_score": 0.00548, "epss_percentile": 0.67267}, "CVE-2013-2124": {"epss_score": 0.00907, "epss_percentile": 0.75266}, "CVE-2013-2125": {"epss_score": 0.01428, "epss_percentile": 0.80221}, "CVE-2013-2126": {"epss_score": 0.03225, "epss_percentile": 0.86683}, "CVE-2013-2127": {"epss_score": 0.00923, "epss_percentile": 0.7551}, "CVE-2013-2128": {"epss_score": 0.00102, "epss_percentile": 0.28739}, "CVE-2013-2129": {"epss_score": 0.0039, "epss_percentile": 0.59527}, "CVE-2013-2130": {"epss_score": 0.01087, "epss_percentile": 0.77427}, "CVE-2013-2131": {"epss_score": 0.12307, "epss_percentile": 0.9363}, "CVE-2013-2132": {"epss_score": 0.02228, "epss_percentile": 0.84074}, "CVE-2013-2133": {"epss_score": 0.00326, "epss_percentile": 0.55072}, "CVE-2013-2134": {"epss_score": 0.92196, "epss_percentile": 0.99699}, "CVE-2013-2135": {"epss_score": 0.83459, "epss_percentile": 0.99249}, "CVE-2013-2136": {"epss_score": 0.06724, "epss_percentile": 0.90969}, "CVE-2013-2137": {"epss_score": 0.03806, "epss_percentile": 0.87751}, "CVE-2013-2138": {"epss_score": 0.01207, "epss_percentile": 0.78528}, "CVE-2013-2139": {"epss_score": 0.01807, "epss_percentile": 0.82352}, "CVE-2013-2140": {"epss_score": 0.0013, "epss_percentile": 0.33261}, "CVE-2013-2141": {"epss_score": 0.00037, "epss_percentile": 0.10904}, "CVE-2013-2142": {"epss_score": 0.00022, "epss_percentile": 0.05267}, "CVE-2013-2143": {"epss_score": 0.6343, "epss_percentile": 0.98333}, "CVE-2013-2144": {"epss_score": 0.0038, "epss_percentile": 0.58962}, "CVE-2013-2145": {"epss_score": 0.00198, "epss_percentile": 0.42026}, "CVE-2013-2146": {"epss_score": 0.00029, "epss_percentile": 0.07698}, "CVE-2013-2147": {"epss_score": 0.00076, "epss_percentile": 0.2324}, "CVE-2013-2148": {"epss_score": 0.00081, "epss_percentile": 0.24221}, "CVE-2013-2149": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-2150": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-2151": {"epss_score": 0.00073, "epss_percentile": 0.22562}, "CVE-2013-2152": {"epss_score": 0.00071, "epss_percentile": 0.21994}, "CVE-2013-2153": {"epss_score": 0.00835, "epss_percentile": 0.74118}, "CVE-2013-2154": {"epss_score": 0.01673, "epss_percentile": 0.81683}, "CVE-2013-2155": {"epss_score": 0.01566, "epss_percentile": 0.81068}, "CVE-2013-2156": {"epss_score": 0.03204, "epss_percentile": 0.86629}, "CVE-2013-2157": {"epss_score": 0.00288, "epss_percentile": 0.51924}, "CVE-2013-2158": {"epss_score": 0.00269, "epss_percentile": 0.50114}, "CVE-2013-2159": {"epss_score": 0.00459, "epss_percentile": 0.63456}, "CVE-2013-2160": {"epss_score": 0.203, "epss_percentile": 0.95318}, "CVE-2013-2161": {"epss_score": 0.00329, "epss_percentile": 0.55402}, "CVE-2013-2162": {"epss_score": 0.00034, "epss_percentile": 0.09436}, "CVE-2013-2163": {"epss_score": 0.00746, "epss_percentile": 0.72541}, "CVE-2013-2164": {"epss_score": 0.00073, "epss_percentile": 0.22572}, "CVE-2013-2165": {"epss_score": 0.25714, "epss_percentile": 0.96059}, "CVE-2013-2166": {"epss_score": 0.00087, "epss_percentile": 0.25633}, "CVE-2013-2167": {"epss_score": 0.00826, "epss_percentile": 0.73969}, "CVE-2013-2168": {"epss_score": 0.00091, "epss_percentile": 0.26283}, "CVE-2013-2171": {"epss_score": 0.2417, "epss_percentile": 0.95882}, "CVE-2013-2172": {"epss_score": 0.05394, "epss_percentile": 0.89826}, "CVE-2013-2173": {"epss_score": 0.01677, "epss_percentile": 0.81713}, "CVE-2013-2174": {"epss_score": 0.03181, "epss_percentile": 0.86581}, "CVE-2013-2175": {"epss_score": 0.00076, "epss_percentile": 0.23183}, "CVE-2013-2176": {"epss_score": 0.00068, "epss_percentile": 0.21404}, "CVE-2013-2177": {"epss_score": 0.00249, "epss_percentile": 0.48002}, "CVE-2013-2178": {"epss_score": 0.00828, "epss_percentile": 0.74001}, "CVE-2013-2179": {"epss_score": 0.00758, "epss_percentile": 0.72773}, "CVE-2013-2181": {"epss_score": 0.00252, "epss_percentile": 0.48354}, "CVE-2013-2182": {"epss_score": 0.11529, "epss_percentile": 0.93393}, "CVE-2013-2183": {"epss_score": 0.00052, "epss_percentile": 0.16606}, "CVE-2013-2184": {"epss_score": 0.03196, "epss_percentile": 0.86613}, "CVE-2013-2185": {"epss_score": 0.05286, "epss_percentile": 0.89693}, "CVE-2013-2186": {"epss_score": 0.9045, "epss_percentile": 0.99584}, "CVE-2013-2187": {"epss_score": 0.0114, "epss_percentile": 0.77949}, "CVE-2013-2188": {"epss_score": 0.00039, "epss_percentile": 0.11437}, "CVE-2013-2189": {"epss_score": 0.01221, "epss_percentile": 0.78649}, "CVE-2013-2190": {"epss_score": 0.00078, "epss_percentile": 0.23562}, "CVE-2013-2191": {"epss_score": 0.00245, "epss_percentile": 0.47645}, "CVE-2013-2192": {"epss_score": 0.00125, "epss_percentile": 0.32503}, "CVE-2013-2193": {"epss_score": 0.00155, "epss_percentile": 0.36853}, "CVE-2013-2194": {"epss_score": 0.00039, "epss_percentile": 0.11736}, "CVE-2013-2195": {"epss_score": 0.00039, "epss_percentile": 0.11736}, "CVE-2013-2196": {"epss_score": 0.00039, "epss_percentile": 0.11736}, "CVE-2013-2197": {"epss_score": 0.00564, "epss_percentile": 0.67768}, "CVE-2013-2198": {"epss_score": 0.00531, "epss_percentile": 0.66647}, "CVE-2013-2199": {"epss_score": 0.00831, "epss_percentile": 0.74041}, "CVE-2013-2200": {"epss_score": 0.01395, "epss_percentile": 0.79977}, "CVE-2013-2201": {"epss_score": 0.00749, "epss_percentile": 0.72611}, "CVE-2013-2202": {"epss_score": 0.01357, "epss_percentile": 0.79724}, "CVE-2013-2203": {"epss_score": 0.00901, "epss_percentile": 0.7518}, "CVE-2013-2204": {"epss_score": 0.00658, "epss_percentile": 0.70481}, "CVE-2013-2205": {"epss_score": 0.0059, "epss_percentile": 0.68566}, "CVE-2013-2206": {"epss_score": 0.03209, "epss_percentile": 0.86642}, "CVE-2013-2207": {"epss_score": 0.00071, "epss_percentile": 0.22071}, "CVE-2013-2208": {"epss_score": 0.00611, "epss_percentile": 0.6918}, "CVE-2013-2209": {"epss_score": 0.00407, "epss_percentile": 0.60596}, "CVE-2013-2210": {"epss_score": 0.01564, "epss_percentile": 0.81061}, "CVE-2013-2211": {"epss_score": 0.00233, "epss_percentile": 0.46}, "CVE-2013-2212": {"epss_score": 0.00178, "epss_percentile": 0.39643}, "CVE-2013-2213": {"epss_score": 0.00065, "epss_percentile": 0.20514}, "CVE-2013-2214": {"epss_score": 0.02677, "epss_percentile": 0.85406}, "CVE-2013-2217": {"epss_score": 0.00141, "epss_percentile": 0.34913}, "CVE-2013-2218": {"epss_score": 0.10811, "epss_percentile": 0.93118}, "CVE-2013-2219": {"epss_score": 0.00173, "epss_percentile": 0.39063}, "CVE-2013-2220": {"epss_score": 0.02798, "epss_percentile": 0.85687}, "CVE-2013-2221": {"epss_score": 0.03241, "epss_percentile": 0.86734}, "CVE-2013-2222": {"epss_score": 0.03514, "epss_percentile": 0.87271}, "CVE-2013-2223": {"epss_score": 0.04146, "epss_percentile": 0.88314}, "CVE-2013-2224": {"epss_score": 0.00183, "epss_percentile": 0.40286}, "CVE-2013-2225": {"epss_score": 0.13151, "epss_percentile": 0.93886}, "CVE-2013-2226": {"epss_score": 0.02593, "epss_percentile": 0.85187}, "CVE-2013-2227": {"epss_score": 0.31192, "epss_percentile": 0.966}, "CVE-2013-2228": {"epss_score": 0.01018, "epss_percentile": 0.76707}, "CVE-2013-2230": {"epss_score": 0.0058, "epss_percentile": 0.68253}, "CVE-2013-2231": {"epss_score": 0.00054, "epss_percentile": 0.17329}, "CVE-2013-2232": {"epss_score": 0.00091, "epss_percentile": 0.26198}, "CVE-2013-2233": {"epss_score": 0.0035, "epss_percentile": 0.56951}, "CVE-2013-2234": {"epss_score": 0.0008, "epss_percentile": 0.24088}, "CVE-2013-2236": {"epss_score": 0.00962, "epss_percentile": 0.75988}, "CVE-2013-2237": {"epss_score": 0.0008, "epss_percentile": 0.24088}, "CVE-2013-2238": {"epss_score": 0.02359, "epss_percentile": 0.84492}, "CVE-2013-2239": {"epss_score": 0.00163, "epss_percentile": 0.37811}, "CVE-2013-2240": {"epss_score": 0.00686, "epss_percentile": 0.71164}, "CVE-2013-2241": {"epss_score": 0.00379, "epss_percentile": 0.58884}, "CVE-2013-2242": {"epss_score": 0.00156, "epss_percentile": 0.36988}, "CVE-2013-2243": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2013-2244": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-2245": {"epss_score": 0.00162, "epss_percentile": 0.37692}, "CVE-2013-2246": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2013-2247": {"epss_score": 0.00443, "epss_percentile": 0.62765}, "CVE-2013-2248": {"epss_score": 0.93524, "epss_percentile": 0.99815}, "CVE-2013-2249": {"epss_score": 0.33663, "epss_percentile": 0.96795}, "CVE-2013-2250": {"epss_score": 0.12628, "epss_percentile": 0.93733}, "CVE-2013-2251": {"epss_score": 0.94328, "epss_percentile": 0.99949}, "CVE-2013-2254": {"epss_score": 0.03651, "epss_percentile": 0.87509}, "CVE-2013-2255": {"epss_score": 0.00414, "epss_percentile": 0.61098}, "CVE-2013-2256": {"epss_score": 0.00472, "epss_percentile": 0.64067}, "CVE-2013-2257": {"epss_score": 0.00415, "epss_percentile": 0.61121}, "CVE-2013-2258": {"epss_score": 0.0042, "epss_percentile": 0.61436}, "CVE-2013-2259": {"epss_score": 0.00715, "epss_percentile": 0.71836}, "CVE-2013-2260": {"epss_score": 0.005, "epss_percentile": 0.65305}, "CVE-2013-2261": {"epss_score": 0.10294, "epss_percentile": 0.92932}, "CVE-2013-2262": {"epss_score": 0.00468, "epss_percentile": 0.6391}, "CVE-2013-2263": {"epss_score": 0.00498, "epss_percentile": 0.65222}, "CVE-2013-2264": {"epss_score": 0.00171, "epss_percentile": 0.38833}, "CVE-2013-2266": {"epss_score": 0.5461, "epss_percentile": 0.97935}, "CVE-2013-2267": {"epss_score": 0.12802, "epss_percentile": 0.93778}, "CVE-2013-2268": {"epss_score": 0.00133, "epss_percentile": 0.33699}, "CVE-2013-2269": {"epss_score": 0.00448, "epss_percentile": 0.63001}, "CVE-2013-2270": {"epss_score": 0.00365, "epss_percentile": 0.5799}, "CVE-2013-2271": {"epss_score": 0.38691, "epss_percentile": 0.97115}, "CVE-2013-2272": {"epss_score": 0.00221, "epss_percentile": 0.44677}, "CVE-2013-2273": {"epss_score": 0.00221, "epss_percentile": 0.44677}, "CVE-2013-2274": {"epss_score": 0.01851, "epss_percentile": 0.82536}, "CVE-2013-2275": {"epss_score": 0.00378, "epss_percentile": 0.588}, "CVE-2013-2276": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2013-2277": {"epss_score": 0.00623, "epss_percentile": 0.69538}, "CVE-2013-2278": {"epss_score": 0.08915, "epss_percentile": 0.92316}, "CVE-2013-2279": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2013-2287": {"epss_score": 0.09211, "epss_percentile": 0.9245}, "CVE-2013-2289": {"epss_score": 0.00379, "epss_percentile": 0.58841}, "CVE-2013-2290": {"epss_score": 0.00425, "epss_percentile": 0.61699}, "CVE-2013-2292": {"epss_score": 0.02939, "epss_percentile": 0.8603}, "CVE-2013-2293": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2013-2294": {"epss_score": 0.04742, "epss_percentile": 0.89081}, "CVE-2013-2296": {"epss_score": 0.00132, "epss_percentile": 0.33555}, "CVE-2013-2297": {"epss_score": 0.00043, "epss_percentile": 0.13237}, "CVE-2013-2298": {"epss_score": 0.01879, "epss_percentile": 0.82671}, "CVE-2013-2299": {"epss_score": 0.00493, "epss_percentile": 0.65063}, "CVE-2013-2300": {"epss_score": 0.00195, "epss_percentile": 0.41616}, "CVE-2013-2301": {"epss_score": 0.00248, "epss_percentile": 0.47953}, "CVE-2013-2302": {"epss_score": 0.00062, "epss_percentile": 0.19565}, "CVE-2013-2303": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2013-2304": {"epss_score": 0.00217, "epss_percentile": 0.44296}, "CVE-2013-2305": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2013-2306": {"epss_score": 0.00245, "epss_percentile": 0.47683}, "CVE-2013-2307": {"epss_score": 0.00348, "epss_percentile": 0.56839}, "CVE-2013-2308": {"epss_score": 0.00176, "epss_percentile": 0.39487}, "CVE-2013-2309": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-2310": {"epss_score": 0.00199, "epss_percentile": 0.42175}, "CVE-2013-2311": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-2312": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2013-2313": {"epss_score": 0.00312, "epss_percentile": 0.53959}, "CVE-2013-2314": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2013-2315": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2013-2316": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2013-2317": {"epss_score": 0.00345, "epss_percentile": 0.56577}, "CVE-2013-2318": {"epss_score": 0.00422, "epss_percentile": 0.61539}, "CVE-2013-2319": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2013-2321": {"epss_score": 0.00581, "epss_percentile": 0.68274}, "CVE-2013-2322": {"epss_score": 0.00184, "epss_percentile": 0.40403}, "CVE-2013-2323": {"epss_score": 0.00179, "epss_percentile": 0.39773}, "CVE-2013-2324": {"epss_score": 0.70513, "epss_percentile": 0.98635}, "CVE-2013-2325": {"epss_score": 0.53182, "epss_percentile": 0.97862}, "CVE-2013-2326": {"epss_score": 0.53182, "epss_percentile": 0.97862}, "CVE-2013-2327": {"epss_score": 0.53182, "epss_percentile": 0.97862}, "CVE-2013-2328": {"epss_score": 0.53182, "epss_percentile": 0.97862}, "CVE-2013-2329": {"epss_score": 0.53182, "epss_percentile": 0.97862}, "CVE-2013-2330": {"epss_score": 0.53182, "epss_percentile": 0.97862}, "CVE-2013-2331": {"epss_score": 0.53182, "epss_percentile": 0.97862}, "CVE-2013-2332": {"epss_score": 0.57201, "epss_percentile": 0.98054}, "CVE-2013-2333": {"epss_score": 0.81827, "epss_percentile": 0.9916}, "CVE-2013-2334": {"epss_score": 0.67366, "epss_percentile": 0.98504}, "CVE-2013-2335": {"epss_score": 0.53182, "epss_percentile": 0.97862}, "CVE-2013-2336": {"epss_score": 0.00689, "epss_percentile": 0.71218}, "CVE-2013-2337": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2013-2338": {"epss_score": 0.26454, "epss_percentile": 0.96148}, "CVE-2013-2339": {"epss_score": 0.00086, "epss_percentile": 0.25312}, "CVE-2013-2340": {"epss_score": 0.22349, "epss_percentile": 0.95625}, "CVE-2013-2341": {"epss_score": 0.00568, "epss_percentile": 0.67897}, "CVE-2013-2342": {"epss_score": 0.00116, "epss_percentile": 0.31145}, "CVE-2013-2343": {"epss_score": 0.756, "epss_percentile": 0.98858}, "CVE-2013-2344": {"epss_score": 0.27671, "epss_percentile": 0.96273}, "CVE-2013-2345": {"epss_score": 0.27671, "epss_percentile": 0.96273}, "CVE-2013-2346": {"epss_score": 0.27671, "epss_percentile": 0.96273}, "CVE-2013-2347": {"epss_score": 0.7679, "epss_percentile": 0.98905}, "CVE-2013-2348": {"epss_score": 0.27671, "epss_percentile": 0.96273}, "CVE-2013-2349": {"epss_score": 0.27671, "epss_percentile": 0.96273}, "CVE-2013-2350": {"epss_score": 0.27671, "epss_percentile": 0.96273}, "CVE-2013-2351": {"epss_score": 0.01115, "epss_percentile": 0.77714}, "CVE-2013-2352": {"epss_score": 0.02217, "epss_percentile": 0.84038}, "CVE-2013-2353": {"epss_score": 0.01441, "epss_percentile": 0.80305}, "CVE-2013-2355": {"epss_score": 0.00373, "epss_percentile": 0.58481}, "CVE-2013-2356": {"epss_score": 0.00689, "epss_percentile": 0.71218}, "CVE-2013-2357": {"epss_score": 0.00241, "epss_percentile": 0.47257}, "CVE-2013-2358": {"epss_score": 0.00241, "epss_percentile": 0.47257}, "CVE-2013-2359": {"epss_score": 0.00241, "epss_percentile": 0.47257}, "CVE-2013-2360": {"epss_score": 0.00241, "epss_percentile": 0.47257}, "CVE-2013-2361": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2013-2362": {"epss_score": 0.00082, "epss_percentile": 0.24414}, "CVE-2013-2363": {"epss_score": 0.00689, "epss_percentile": 0.71218}, "CVE-2013-2364": {"epss_score": 0.00193, "epss_percentile": 0.4142}, "CVE-2013-2365": {"epss_score": 0.00274, "epss_percentile": 0.50486}, "CVE-2013-2366": {"epss_score": 0.09917, "epss_percentile": 0.9277}, "CVE-2013-2367": {"epss_score": 0.83849, "epss_percentile": 0.99262}, "CVE-2013-2368": {"epss_score": 0.02378, "epss_percentile": 0.84558}, "CVE-2013-2369": {"epss_score": 0.05869, "epss_percentile": 0.90278}, "CVE-2013-2370": {"epss_score": 0.81983, "epss_percentile": 0.99168}, "CVE-2013-2371": {"epss_score": 0.00454, "epss_percentile": 0.63268}, "CVE-2013-2372": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2013-2373": {"epss_score": 0.00274, "epss_percentile": 0.50541}, "CVE-2013-2374": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-2375": {"epss_score": 0.0053, "epss_percentile": 0.66608}, "CVE-2013-2376": {"epss_score": 0.00525, "epss_percentile": 0.66378}, "CVE-2013-2377": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-2378": {"epss_score": 0.00539, "epss_percentile": 0.66972}, "CVE-2013-2379": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-2380": {"epss_score": 0.02534, "epss_percentile": 0.85035}, "CVE-2013-2381": {"epss_score": 0.0015, "epss_percentile": 0.3618}, "CVE-2013-2382": {"epss_score": 0.00146, "epss_percentile": 0.35571}, "CVE-2013-2383": {"epss_score": 0.08191, "epss_percentile": 0.91922}, "CVE-2013-2384": {"epss_score": 0.08191, "epss_percentile": 0.91922}, "CVE-2013-2385": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-2386": {"epss_score": 0.00322, "epss_percentile": 0.548}, "CVE-2013-2387": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2013-2388": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2013-2389": {"epss_score": 0.00539, "epss_percentile": 0.66972}, "CVE-2013-2390": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2013-2391": {"epss_score": 0.00116, "epss_percentile": 0.31192}, "CVE-2013-2392": {"epss_score": 0.00539, "epss_percentile": 0.66972}, "CVE-2013-2393": {"epss_score": 0.00472, "epss_percentile": 0.64031}, "CVE-2013-2394": {"epss_score": 0.06119, "epss_percentile": 0.90493}, "CVE-2013-2395": {"epss_score": 0.00486, "epss_percentile": 0.64744}, "CVE-2013-2396": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-2397": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2013-2398": {"epss_score": 0.00351, "epss_percentile": 0.5704}, "CVE-2013-2399": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-2400": {"epss_score": 0.03708, "epss_percentile": 0.87601}, "CVE-2013-2401": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-2402": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-2403": {"epss_score": 0.00143, "epss_percentile": 0.35149}, "CVE-2013-2404": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-2405": {"epss_score": 0.00188, "epss_percentile": 0.40893}, "CVE-2013-2406": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-2407": {"epss_score": 0.05415, "epss_percentile": 0.89849}, "CVE-2013-2408": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-2409": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2013-2410": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-2411": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2013-2412": {"epss_score": 0.03809, "epss_percentile": 0.87754}, "CVE-2013-2413": {"epss_score": 0.00156, "epss_percentile": 0.36899}, "CVE-2013-2414": {"epss_score": 0.01262, "epss_percentile": 0.78981}, "CVE-2013-2415": {"epss_score": 0.00058, "epss_percentile": 0.18424}, "CVE-2013-2416": {"epss_score": 0.26734, "epss_percentile": 0.96171}, "CVE-2013-2417": {"epss_score": 0.08554, "epss_percentile": 0.92122}, "CVE-2013-2418": {"epss_score": 0.00087, "epss_percentile": 0.25558}, "CVE-2013-2419": {"epss_score": 0.19823, "epss_percentile": 0.95247}, "CVE-2013-2420": {"epss_score": 0.08554, "epss_percentile": 0.9212}, "CVE-2013-2421": {"epss_score": 0.2118, "epss_percentile": 0.95473}, "CVE-2013-2422": {"epss_score": 0.11822, "epss_percentile": 0.93487}, "CVE-2013-2423": {"epss_score": 0.91522, "epss_percentile": 0.9965}, "CVE-2013-2424": {"epss_score": 0.05454, "epss_percentile": 0.89895}, "CVE-2013-2425": {"epss_score": 0.01262, "epss_percentile": 0.78981}, "CVE-2013-2426": {"epss_score": 0.2118, "epss_percentile": 0.95473}, "CVE-2013-2427": {"epss_score": 0.01262, "epss_percentile": 0.78981}, "CVE-2013-2428": {"epss_score": 0.01262, "epss_percentile": 0.78981}, "CVE-2013-2429": {"epss_score": 0.14304, "epss_percentile": 0.94184}, "CVE-2013-2430": {"epss_score": 0.09909, "epss_percentile": 0.92767}, "CVE-2013-2431": {"epss_score": 0.12445, "epss_percentile": 0.93674}, "CVE-2013-2432": {"epss_score": 0.0652, "epss_percentile": 0.90818}, "CVE-2013-2433": {"epss_score": 0.04625, "epss_percentile": 0.88938}, "CVE-2013-2434": {"epss_score": 0.01487, "epss_percentile": 0.80612}, "CVE-2013-2435": {"epss_score": 0.0652, "epss_percentile": 0.90818}, "CVE-2013-2436": {"epss_score": 0.06119, "epss_percentile": 0.90493}, "CVE-2013-2437": {"epss_score": 0.03853, "epss_percentile": 0.87854}, "CVE-2013-2438": {"epss_score": 0.00769, "epss_percentile": 0.72986}, "CVE-2013-2439": {"epss_score": 0.00106, "epss_percentile": 0.29558}, "CVE-2013-2440": {"epss_score": 0.0652, "epss_percentile": 0.90818}, "CVE-2013-2441": {"epss_score": 0.00133, "epss_percentile": 0.33668}, "CVE-2013-2442": {"epss_score": 0.08316, "epss_percentile": 0.91989}, "CVE-2013-2443": {"epss_score": 0.03853, "epss_percentile": 0.87854}, "CVE-2013-2444": {"epss_score": 0.04906, "epss_percentile": 0.89277}, "CVE-2013-2445": {"epss_score": 0.06734, "epss_percentile": 0.90991}, "CVE-2013-2446": {"epss_score": 0.03483, "epss_percentile": 0.87224}, "CVE-2013-2447": {"epss_score": 0.03853, "epss_percentile": 0.87854}, "CVE-2013-2448": {"epss_score": 0.05124, "epss_percentile": 0.89523}, "CVE-2013-2449": {"epss_score": 0.02499, "epss_percentile": 0.84915}, "CVE-2013-2450": {"epss_score": 0.05225, "epss_percentile": 0.89632}, "CVE-2013-2451": {"epss_score": 0.0014, "epss_percentile": 0.34703}, "CVE-2013-2452": {"epss_score": 0.03853, "epss_percentile": 0.87854}, "CVE-2013-2453": {"epss_score": 0.04452, "epss_percentile": 0.88707}, "CVE-2013-2454": {"epss_score": 0.08637, "epss_percentile": 0.92166}, "CVE-2013-2455": {"epss_score": 0.03853, "epss_percentile": 0.87854}, "CVE-2013-2456": {"epss_score": 0.0344, "epss_percentile": 0.8714}, "CVE-2013-2457": {"epss_score": 0.08637, "epss_percentile": 0.92166}, "CVE-2013-2458": {"epss_score": 0.12219, "epss_percentile": 0.93605}, "CVE-2013-2459": {"epss_score": 0.15043, "epss_percentile": 0.9435}, "CVE-2013-2460": {"epss_score": 0.91578, "epss_percentile": 0.99653}, "CVE-2013-2461": {"epss_score": 0.64059, "epss_percentile": 0.98362}, "CVE-2013-2462": {"epss_score": 0.03922, "epss_percentile": 0.87955}, "CVE-2013-2463": {"epss_score": 0.44665, "epss_percentile": 0.97448}, "CVE-2013-2464": {"epss_score": 0.06854, "epss_percentile": 0.91075}, "CVE-2013-2465": {"epss_score": 0.9356, "epss_percentile": 0.99818}, "CVE-2013-2466": {"epss_score": 0.07544, "epss_percentile": 0.91528}, "CVE-2013-2467": {"epss_score": 0.00128, "epss_percentile": 0.33052}, "CVE-2013-2468": {"epss_score": 0.07462, "epss_percentile": 0.91486}, "CVE-2013-2469": {"epss_score": 0.27318, "epss_percentile": 0.96237}, "CVE-2013-2470": {"epss_score": 0.54412, "epss_percentile": 0.97925}, "CVE-2013-2471": {"epss_score": 0.40067, "epss_percentile": 0.97193}, "CVE-2013-2472": {"epss_score": 0.54412, "epss_percentile": 0.97925}, "CVE-2013-2473": {"epss_score": 0.27318, "epss_percentile": 0.96237}, "CVE-2013-2474": {"epss_score": 0.34234, "epss_percentile": 0.96834}, "CVE-2013-2475": {"epss_score": 0.00363, "epss_percentile": 0.57897}, "CVE-2013-2476": {"epss_score": 0.00783, "epss_percentile": 0.73226}, "CVE-2013-2477": {"epss_score": 0.00359, "epss_percentile": 0.57605}, "CVE-2013-2478": {"epss_score": 0.01454, "epss_percentile": 0.80384}, "CVE-2013-2479": {"epss_score": 0.01122, "epss_percentile": 0.7778}, "CVE-2013-2480": {"epss_score": 0.01423, "epss_percentile": 0.80189}, "CVE-2013-2481": {"epss_score": 0.01198, "epss_percentile": 0.78453}, "CVE-2013-2482": {"epss_score": 0.0059, "epss_percentile": 0.68558}, "CVE-2013-2483": {"epss_score": 0.01454, "epss_percentile": 0.80384}, "CVE-2013-2484": {"epss_score": 0.01423, "epss_percentile": 0.80189}, "CVE-2013-2485": {"epss_score": 0.0059, "epss_percentile": 0.68558}, "CVE-2013-2486": {"epss_score": 0.01648, "epss_percentile": 0.81544}, "CVE-2013-2487": {"epss_score": 0.03557, "epss_percentile": 0.87349}, "CVE-2013-2488": {"epss_score": 0.03866, "epss_percentile": 0.87872}, "CVE-2013-2492": {"epss_score": 0.85258, "epss_percentile": 0.99325}, "CVE-2013-2493": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2013-2494": {"epss_score": 0.01036, "epss_percentile": 0.76909}, "CVE-2013-2495": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2013-2496": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2013-2498": {"epss_score": 0.0022, "epss_percentile": 0.44577}, "CVE-2013-2499": {"epss_score": 0.01163, "epss_percentile": 0.78161}, "CVE-2013-2501": {"epss_score": 0.06215, "epss_percentile": 0.90573}, "CVE-2013-2503": {"epss_score": 0.03483, "epss_percentile": 0.87223}, "CVE-2013-2504": {"epss_score": 0.00598, "epss_percentile": 0.6876}, "CVE-2013-2506": {"epss_score": 0.00171, "epss_percentile": 0.38827}, "CVE-2013-2507": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2013-2512": {"epss_score": 0.02838, "epss_percentile": 0.85794}, "CVE-2013-2513": {"epss_score": 0.00594, "epss_percentile": 0.68678}, "CVE-2013-2516": {"epss_score": 0.02376, "epss_percentile": 0.84544}, "CVE-2013-2546": {"epss_score": 0.00054, "epss_percentile": 0.17058}, "CVE-2013-2547": {"epss_score": 0.00074, "epss_percentile": 0.22835}, "CVE-2013-2548": {"epss_score": 0.00054, "epss_percentile": 0.17058}, "CVE-2013-2549": {"epss_score": 0.05436, "epss_percentile": 0.89881}, "CVE-2013-2550": {"epss_score": 0.03064, "epss_percentile": 0.86322}, "CVE-2013-2551": {"epss_score": 0.91987, "epss_percentile": 0.99683}, "CVE-2013-2552": {"epss_score": 0.12978, "epss_percentile": 0.93834}, "CVE-2013-2553": {"epss_score": 0.00835, "epss_percentile": 0.74118}, "CVE-2013-2554": {"epss_score": 0.16192, "epss_percentile": 0.94591}, "CVE-2013-2555": {"epss_score": 0.05981, "epss_percentile": 0.90378}, "CVE-2013-2556": {"epss_score": 0.34526, "epss_percentile": 0.96852}, "CVE-2013-2557": {"epss_score": 0.17174, "epss_percentile": 0.94792}, "CVE-2013-2558": {"epss_score": 0.23779, "epss_percentile": 0.95816}, "CVE-2013-2559": {"epss_score": 0.01153, "epss_percentile": 0.7806}, "CVE-2013-2560": {"epss_score": 0.09018, "epss_percentile": 0.92369}, "CVE-2013-2561": {"epss_score": 0.00074, "epss_percentile": 0.22708}, "CVE-2013-2562": {"epss_score": 0.00074, "epss_percentile": 0.22734}, "CVE-2013-2563": {"epss_score": 0.00056, "epss_percentile": 0.17757}, "CVE-2013-2564": {"epss_score": 0.00543, "epss_percentile": 0.67123}, "CVE-2013-2565": {"epss_score": 0.00264, "epss_percentile": 0.49569}, "CVE-2013-2566": {"epss_score": 0.90324, "epss_percentile": 0.99577}, "CVE-2013-2567": {"epss_score": 0.54674, "epss_percentile": 0.97938}, "CVE-2013-2568": {"epss_score": 0.57514, "epss_percentile": 0.98068}, "CVE-2013-2569": {"epss_score": 0.68037, "epss_percentile": 0.98529}, "CVE-2013-2570": {"epss_score": 0.29423, "epss_percentile": 0.9644}, "CVE-2013-2571": {"epss_score": 0.62054, "epss_percentile": 0.98274}, "CVE-2013-2572": {"epss_score": 0.49292, "epss_percentile": 0.97678}, "CVE-2013-2573": {"epss_score": 0.22391, "epss_percentile": 0.95631}, "CVE-2013-2574": {"epss_score": 0.3051, "epss_percentile": 0.96547}, "CVE-2013-2576": {"epss_score": 0.44775, "epss_percentile": 0.97452}, "CVE-2013-2577": {"epss_score": 0.31793, "epss_percentile": 0.96649}, "CVE-2013-2578": {"epss_score": 0.7228, "epss_percentile": 0.98703}, "CVE-2013-2579": {"epss_score": 0.1778, "epss_percentile": 0.94905}, "CVE-2013-2580": {"epss_score": 0.07822, "epss_percentile": 0.91699}, "CVE-2013-2581": {"epss_score": 0.16477, "epss_percentile": 0.94675}, "CVE-2013-2582": {"epss_score": 0.00245, "epss_percentile": 0.47633}, "CVE-2013-2583": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-2585": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-2586": {"epss_score": 0.13895, "epss_percentile": 0.94088}, "CVE-2013-2594": {"epss_score": 0.0594, "epss_percentile": 0.90349}, "CVE-2013-2595": {"epss_score": 0.00912, "epss_percentile": 0.75357}, "CVE-2013-2596": {"epss_score": 0.02, "epss_percentile": 0.83215}, "CVE-2013-2597": {"epss_score": 0.06744, "epss_percentile": 0.90998}, "CVE-2013-2598": {"epss_score": 0.00049, "epss_percentile": 0.15303}, "CVE-2013-2599": {"epss_score": 0.00127, "epss_percentile": 0.32913}, "CVE-2013-2600": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2013-2601": {"epss_score": 0.0075, "epss_percentile": 0.72633}, "CVE-2013-2602": {"epss_score": 0.03694, "epss_percentile": 0.87581}, "CVE-2013-2603": {"epss_score": 0.13713, "epss_percentile": 0.9404}, "CVE-2013-2604": {"epss_score": 0.00066, "epss_percentile": 0.20866}, "CVE-2013-2612": {"epss_score": 0.05717, "epss_percentile": 0.90147}, "CVE-2013-2615": {"epss_score": 0.01752, "epss_percentile": 0.8211}, "CVE-2013-2616": {"epss_score": 0.00876, "epss_percentile": 0.74797}, "CVE-2013-2617": {"epss_score": 0.01405, "epss_percentile": 0.80045}, "CVE-2013-2618": {"epss_score": 0.09991, "epss_percentile": 0.92807}, "CVE-2013-2619": {"epss_score": 0.13366, "epss_percentile": 0.93943}, "CVE-2013-2621": {"epss_score": 0.1019, "epss_percentile": 0.92886}, "CVE-2013-2622": {"epss_score": 0.00297, "epss_percentile": 0.52689}, "CVE-2013-2623": {"epss_score": 0.02631, "epss_percentile": 0.85284}, "CVE-2013-2624": {"epss_score": 0.08662, "epss_percentile": 0.92177}, "CVE-2013-2625": {"epss_score": 0.00179, "epss_percentile": 0.39856}, "CVE-2013-2627": {"epss_score": 0.00203, "epss_percentile": 0.42503}, "CVE-2013-2628": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2013-2629": {"epss_score": 0.00397, "epss_percentile": 0.59967}, "CVE-2013-2630": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-2631": {"epss_score": 0.00286, "epss_percentile": 0.51691}, "CVE-2013-2632": {"epss_score": 0.00493, "epss_percentile": 0.65062}, "CVE-2013-2633": {"epss_score": 0.00257, "epss_percentile": 0.48947}, "CVE-2013-2634": {"epss_score": 0.00016, "epss_percentile": 0.02737}, "CVE-2013-2635": {"epss_score": 0.00016, "epss_percentile": 0.02737}, "CVE-2013-2636": {"epss_score": 0.0011, "epss_percentile": 0.3022}, "CVE-2013-2637": {"epss_score": 0.01433, "epss_percentile": 0.80255}, "CVE-2013-2639": {"epss_score": 0.00387, "epss_percentile": 0.59296}, "CVE-2013-2640": {"epss_score": 0.00389, "epss_percentile": 0.59476}, "CVE-2013-2641": {"epss_score": 0.81816, "epss_percentile": 0.99158}, "CVE-2013-2642": {"epss_score": 0.15964, "epss_percentile": 0.94544}, "CVE-2013-2643": {"epss_score": 0.0058, "epss_percentile": 0.68259}, "CVE-2013-2645": {"epss_score": 0.00476, "epss_percentile": 0.6428}, "CVE-2013-2646": {"epss_score": 0.00322, "epss_percentile": 0.54783}, "CVE-2013-2651": {"epss_score": 0.00261, "epss_percentile": 0.49272}, "CVE-2013-2652": {"epss_score": 0.00499, "epss_percentile": 0.6526}, "CVE-2013-2653": {"epss_score": 0.05747, "epss_percentile": 0.90175}, "CVE-2013-2670": {"epss_score": 0.00572, "epss_percentile": 0.68}, "CVE-2013-2671": {"epss_score": 0.00496, "epss_percentile": 0.65165}, "CVE-2013-2672": {"epss_score": 0.00685, "epss_percentile": 0.71139}, "CVE-2013-2673": {"epss_score": 0.00088, "epss_percentile": 0.2578}, "CVE-2013-2674": {"epss_score": 0.02311, "epss_percentile": 0.8434}, "CVE-2013-2675": {"epss_score": 0.02069, "epss_percentile": 0.83468}, "CVE-2013-2676": {"epss_score": 0.0186, "epss_percentile": 0.82587}, "CVE-2013-2678": {"epss_score": 0.71301, "epss_percentile": 0.98662}, "CVE-2013-2679": {"epss_score": 0.00607, "epss_percentile": 0.69031}, "CVE-2013-2680": {"epss_score": 0.1567, "epss_percentile": 0.9448}, "CVE-2013-2681": {"epss_score": 0.43166, "epss_percentile": 0.97373}, "CVE-2013-2682": {"epss_score": 0.05404, "epss_percentile": 0.89836}, "CVE-2013-2683": {"epss_score": 0.12514, "epss_percentile": 0.93703}, "CVE-2013-2684": {"epss_score": 0.04452, "epss_percentile": 0.88707}, "CVE-2013-2685": {"epss_score": 0.08932, "epss_percentile": 0.92325}, "CVE-2013-2686": {"epss_score": 0.02448, "epss_percentile": 0.84773}, "CVE-2013-2687": {"epss_score": 0.0368, "epss_percentile": 0.87558}, "CVE-2013-2688": {"epss_score": 0.0368, "epss_percentile": 0.87558}, "CVE-2013-2690": {"epss_score": 0.02171, "epss_percentile": 0.83871}, "CVE-2013-2691": {"epss_score": 0.11004, "epss_percentile": 0.93187}, "CVE-2013-2692": {"epss_score": 0.00181, "epss_percentile": 0.40104}, "CVE-2013-2693": {"epss_score": 0.00179, "epss_percentile": 0.39847}, "CVE-2013-2694": {"epss_score": 0.00354, "epss_percentile": 0.57242}, "CVE-2013-2695": {"epss_score": 0.00271, "epss_percentile": 0.50338}, "CVE-2013-2696": {"epss_score": 0.00132, "epss_percentile": 0.33601}, "CVE-2013-2697": {"epss_score": 0.00125, "epss_percentile": 0.32539}, "CVE-2013-2698": {"epss_score": 0.00141, "epss_percentile": 0.34802}, "CVE-2013-2699": {"epss_score": 0.00179, "epss_percentile": 0.39847}, "CVE-2013-2700": {"epss_score": 0.00251, "epss_percentile": 0.48279}, "CVE-2013-2701": {"epss_score": 0.00125, "epss_percentile": 0.32539}, "CVE-2013-2702": {"epss_score": 0.00128, "epss_percentile": 0.32945}, "CVE-2013-2703": {"epss_score": 0.00164, "epss_percentile": 0.38008}, "CVE-2013-2704": {"epss_score": 0.00146, "epss_percentile": 0.35602}, "CVE-2013-2705": {"epss_score": 0.00136, "epss_percentile": 0.34156}, "CVE-2013-2706": {"epss_score": 0.00164, "epss_percentile": 0.38008}, "CVE-2013-2707": {"epss_score": 0.00125, "epss_percentile": 0.32539}, "CVE-2013-2708": {"epss_score": 0.00164, "epss_percentile": 0.38008}, "CVE-2013-2709": {"epss_score": 0.00125, "epss_percentile": 0.32539}, "CVE-2013-2710": {"epss_score": 0.0014, "epss_percentile": 0.34796}, "CVE-2013-2712": {"epss_score": 0.04593, "epss_percentile": 0.88894}, "CVE-2013-2713": {"epss_score": 0.00656, "epss_percentile": 0.70444}, "CVE-2013-2714": {"epss_score": 0.00221, "epss_percentile": 0.44657}, "CVE-2013-2715": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2013-2716": {"epss_score": 0.00298, "epss_percentile": 0.52775}, "CVE-2013-2717": {"epss_score": 0.00385, "epss_percentile": 0.59196}, "CVE-2013-2718": {"epss_score": 0.17157, "epss_percentile": 0.94789}, "CVE-2013-2719": {"epss_score": 0.17157, "epss_percentile": 0.94789}, "CVE-2013-2720": {"epss_score": 0.1375, "epss_percentile": 0.94048}, "CVE-2013-2721": {"epss_score": 0.17157, "epss_percentile": 0.94789}, "CVE-2013-2722": {"epss_score": 0.17157, "epss_percentile": 0.94789}, "CVE-2013-2723": {"epss_score": 0.17157, "epss_percentile": 0.94789}, "CVE-2013-2724": {"epss_score": 0.32731, "epss_percentile": 0.9672}, "CVE-2013-2725": {"epss_score": 0.17157, "epss_percentile": 0.94789}, "CVE-2013-2726": {"epss_score": 0.18885, "epss_percentile": 0.95086}, "CVE-2013-2727": {"epss_score": 0.03012, "epss_percentile": 0.86202}, "CVE-2013-2728": {"epss_score": 0.03998, "epss_percentile": 0.88089}, "CVE-2013-2729": {"epss_score": 0.89132, "epss_percentile": 0.9951}, "CVE-2013-2730": {"epss_score": 0.79575, "epss_percentile": 0.99045}, "CVE-2013-2731": {"epss_score": 0.17157, "epss_percentile": 0.94789}, "CVE-2013-2732": {"epss_score": 0.18885, "epss_percentile": 0.95086}, "CVE-2013-2733": {"epss_score": 0.02736, "epss_percentile": 0.8555}, "CVE-2013-2734": {"epss_score": 0.18885, "epss_percentile": 0.95086}, "CVE-2013-2735": {"epss_score": 0.18885, "epss_percentile": 0.95086}, "CVE-2013-2736": {"epss_score": 0.18885, "epss_percentile": 0.95086}, "CVE-2013-2737": {"epss_score": 0.01908, "epss_percentile": 0.82816}, "CVE-2013-2738": {"epss_score": 0.00375, "epss_percentile": 0.58611}, "CVE-2013-2739": {"epss_score": 0.09462, "epss_percentile": 0.92559}, "CVE-2013-2741": {"epss_score": 0.00664, "epss_percentile": 0.7064}, "CVE-2013-2742": {"epss_score": 0.00515, "epss_percentile": 0.6597}, "CVE-2013-2743": {"epss_score": 0.00281, "epss_percentile": 0.51179}, "CVE-2013-2744": {"epss_score": 0.00261, "epss_percentile": 0.49324}, "CVE-2013-2745": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2013-2747": {"epss_score": 0.00245, "epss_percentile": 0.47678}, "CVE-2013-2748": {"epss_score": 0.43777, "epss_percentile": 0.97403}, "CVE-2013-2750": {"epss_score": 0.00533, "epss_percentile": 0.66716}, "CVE-2013-2751": {"epss_score": 0.83489, "epss_percentile": 0.9925}, "CVE-2013-2752": {"epss_score": 0.00178, "epss_percentile": 0.39691}, "CVE-2013-2754": {"epss_score": 0.00267, "epss_percentile": 0.49958}, "CVE-2013-2756": {"epss_score": 0.03054, "epss_percentile": 0.86294}, "CVE-2013-2757": {"epss_score": 0.01904, "epss_percentile": 0.8279}, "CVE-2013-2758": {"epss_score": 0.02796, "epss_percentile": 0.85681}, "CVE-2013-2760": {"epss_score": 0.06751, "epss_percentile": 0.91001}, "CVE-2013-2761": {"epss_score": 0.00351, "epss_percentile": 0.57014}, "CVE-2013-2762": {"epss_score": 0.00084, "epss_percentile": 0.24837}, "CVE-2013-2763": {"epss_score": 0.00878, "epss_percentile": 0.74819}, "CVE-2013-2764": {"epss_score": 0.00298, "epss_percentile": 0.52819}, "CVE-2013-2765": {"epss_score": 0.05375, "epss_percentile": 0.89798}, "CVE-2013-2766": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2013-2767": {"epss_score": 0.00452, "epss_percentile": 0.63192}, "CVE-2013-2770": {"epss_score": 0.00143, "epss_percentile": 0.35095}, "CVE-2013-2773": {"epss_score": 0.00028, "epss_percentile": 0.07539}, "CVE-2013-2776": {"epss_score": 0.00076, "epss_percentile": 0.23111}, "CVE-2013-2777": {"epss_score": 0.00047, "epss_percentile": 0.14929}, "CVE-2013-2778": {"epss_score": 0.00128, "epss_percentile": 0.33052}, "CVE-2013-2779": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-2780": {"epss_score": 0.00342, "epss_percentile": 0.56361}, "CVE-2013-2781": {"epss_score": 0.04321, "epss_percentile": 0.88543}, "CVE-2013-2782": {"epss_score": 0.00252, "epss_percentile": 0.48405}, "CVE-2013-2783": {"epss_score": 0.00472, "epss_percentile": 0.64051}, "CVE-2013-2784": {"epss_score": 0.21827, "epss_percentile": 0.95563}, "CVE-2013-2785": {"epss_score": 0.06635, "epss_percentile": 0.90906}, "CVE-2013-2786": {"epss_score": 0.00033, "epss_percentile": 0.09212}, "CVE-2013-2787": {"epss_score": 0.00472, "epss_percentile": 0.64051}, "CVE-2013-2788": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2013-2789": {"epss_score": 0.00459, "epss_percentile": 0.63451}, "CVE-2013-2790": {"epss_score": 0.00472, "epss_percentile": 0.64051}, "CVE-2013-2791": {"epss_score": 0.00475, "epss_percentile": 0.64244}, "CVE-2013-2792": {"epss_score": 0.00472, "epss_percentile": 0.64051}, "CVE-2013-2793": {"epss_score": 0.00475, "epss_percentile": 0.64244}, "CVE-2013-2794": {"epss_score": 0.00053, "epss_percentile": 0.16792}, "CVE-2013-2796": {"epss_score": 0.0015, "epss_percentile": 0.36177}, "CVE-2013-2798": {"epss_score": 0.00052, "epss_percentile": 0.16628}, "CVE-2013-2800": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2013-2801": {"epss_score": 0.00458, "epss_percentile": 0.63432}, "CVE-2013-2802": {"epss_score": 0.04096, "epss_percentile": 0.8825}, "CVE-2013-2803": {"epss_score": 0.00469, "epss_percentile": 0.6394}, "CVE-2013-2804": {"epss_score": 0.00472, "epss_percentile": 0.64051}, "CVE-2013-2805": {"epss_score": 0.00034, "epss_percentile": 0.09463}, "CVE-2013-2806": {"epss_score": 0.00048, "epss_percentile": 0.14969}, "CVE-2013-2807": {"epss_score": 0.00034, "epss_percentile": 0.09463}, "CVE-2013-2808": {"epss_score": 0.08476, "epss_percentile": 0.92072}, "CVE-2013-2809": {"epss_score": 0.00648, "epss_percentile": 0.70215}, "CVE-2013-2810": {"epss_score": 0.0302, "epss_percentile": 0.86223}, "CVE-2013-2811": {"epss_score": 0.01298, "epss_percentile": 0.79271}, "CVE-2013-2813": {"epss_score": 0.00472, "epss_percentile": 0.64051}, "CVE-2013-2814": {"epss_score": 0.00472, "epss_percentile": 0.64051}, "CVE-2013-2816": {"epss_score": 0.00052, "epss_percentile": 0.16628}, "CVE-2013-2817": {"epss_score": 0.24841, "epss_percentile": 0.95958}, "CVE-2013-2818": {"epss_score": 0.00052, "epss_percentile": 0.16628}, "CVE-2013-2819": {"epss_score": 0.0001, "epss_percentile": 0.00794}, "CVE-2013-2820": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2013-2821": {"epss_score": 0.00472, "epss_percentile": 0.64051}, "CVE-2013-2822": {"epss_score": 0.00052, "epss_percentile": 0.16628}, "CVE-2013-2823": {"epss_score": 0.00122, "epss_percentile": 0.32128}, "CVE-2013-2824": {"epss_score": 0.00234, "epss_percentile": 0.46169}, "CVE-2013-2825": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2013-2826": {"epss_score": 0.00272, "epss_percentile": 0.50366}, "CVE-2013-2827": {"epss_score": 0.60519, "epss_percentile": 0.9821}, "CVE-2013-2828": {"epss_score": 0.00052, "epss_percentile": 0.16628}, "CVE-2013-2829": {"epss_score": 0.00472, "epss_percentile": 0.64051}, "CVE-2013-2830": {"epss_score": 0.01002, "epss_percentile": 0.76504}, "CVE-2013-2832": {"epss_score": 0.0025, "epss_percentile": 0.48094}, "CVE-2013-2833": {"epss_score": 0.014, "epss_percentile": 0.80003}, "CVE-2013-2834": {"epss_score": 0.00147, "epss_percentile": 0.3575}, "CVE-2013-2835": {"epss_score": 0.00085, "epss_percentile": 0.25163}, "CVE-2013-2836": {"epss_score": 0.00684, "epss_percentile": 0.71115}, "CVE-2013-2837": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2013-2838": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2013-2839": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2013-2840": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2013-2841": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2013-2842": {"epss_score": 0.21099, "epss_percentile": 0.95462}, "CVE-2013-2843": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2013-2844": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2013-2845": {"epss_score": 0.01274, "epss_percentile": 0.79099}, "CVE-2013-2846": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2013-2847": {"epss_score": 0.00516, "epss_percentile": 0.66058}, "CVE-2013-2848": {"epss_score": 0.00561, "epss_percentile": 0.67663}, "CVE-2013-2849": {"epss_score": 0.00226, "epss_percentile": 0.4527}, "CVE-2013-2850": {"epss_score": 0.09996, "epss_percentile": 0.92809}, "CVE-2013-2851": {"epss_score": 0.00083, "epss_percentile": 0.24744}, "CVE-2013-2852": {"epss_score": 0.00237, "epss_percentile": 0.46646}, "CVE-2013-2853": {"epss_score": 0.00315, "epss_percentile": 0.54175}, "CVE-2013-2854": {"epss_score": 0.0061, "epss_percentile": 0.6914}, "CVE-2013-2855": {"epss_score": 0.00344, "epss_percentile": 0.56521}, "CVE-2013-2856": {"epss_score": 0.0061, "epss_percentile": 0.6914}, "CVE-2013-2857": {"epss_score": 0.0061, "epss_percentile": 0.6914}, "CVE-2013-2858": {"epss_score": 0.0061, "epss_percentile": 0.6914}, "CVE-2013-2859": {"epss_score": 0.00119, "epss_percentile": 0.31595}, "CVE-2013-2860": {"epss_score": 0.0061, "epss_percentile": 0.6914}, "CVE-2013-2861": {"epss_score": 0.0061, "epss_percentile": 0.6914}, "CVE-2013-2862": {"epss_score": 0.00622, "epss_percentile": 0.69493}, "CVE-2013-2863": {"epss_score": 0.03175, "epss_percentile": 0.86561}, "CVE-2013-2864": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2013-2865": {"epss_score": 0.00432, "epss_percentile": 0.6212}, "CVE-2013-2866": {"epss_score": 0.0053, "epss_percentile": 0.66626}, "CVE-2013-2867": {"epss_score": 0.00656, "epss_percentile": 0.70449}, "CVE-2013-2868": {"epss_score": 0.00384, "epss_percentile": 0.59166}, "CVE-2013-2869": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2013-2870": {"epss_score": 0.01324, "epss_percentile": 0.79465}, "CVE-2013-2871": {"epss_score": 0.01513, "epss_percentile": 0.80789}, "CVE-2013-2872": {"epss_score": 0.0025, "epss_percentile": 0.48094}, "CVE-2013-2873": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2013-2874": {"epss_score": 0.00055, "epss_percentile": 0.17496}, "CVE-2013-2875": {"epss_score": 0.01436, "epss_percentile": 0.80276}, "CVE-2013-2876": {"epss_score": 0.00354, "epss_percentile": 0.57213}, "CVE-2013-2877": {"epss_score": 0.00647, "epss_percentile": 0.70203}, "CVE-2013-2878": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2013-2879": {"epss_score": 0.00474, "epss_percentile": 0.64158}, "CVE-2013-2880": {"epss_score": 0.00504, "epss_percentile": 0.65539}, "CVE-2013-2881": {"epss_score": 0.0037, "epss_percentile": 0.58312}, "CVE-2013-2882": {"epss_score": 0.01931, "epss_percentile": 0.82942}, "CVE-2013-2883": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2013-2884": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2013-2885": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2013-2886": {"epss_score": 0.00395, "epss_percentile": 0.59808}, "CVE-2013-2887": {"epss_score": 0.00556, "epss_percentile": 0.67527}, "CVE-2013-2888": {"epss_score": 0.001, "epss_percentile": 0.28542}, "CVE-2013-2889": {"epss_score": 0.00068, "epss_percentile": 0.21288}, "CVE-2013-2890": {"epss_score": 0.00068, "epss_percentile": 0.21408}, "CVE-2013-2891": {"epss_score": 0.00066, "epss_percentile": 0.20911}, "CVE-2013-2892": {"epss_score": 0.00068, "epss_percentile": 0.21288}, "CVE-2013-2893": {"epss_score": 0.00068, "epss_percentile": 0.21288}, "CVE-2013-2894": {"epss_score": 0.0007, "epss_percentile": 0.2176}, "CVE-2013-2895": {"epss_score": 0.00069, "epss_percentile": 0.21566}, "CVE-2013-2896": {"epss_score": 0.00069, "epss_percentile": 0.21566}, "CVE-2013-2897": {"epss_score": 0.00028, "epss_percentile": 0.07348}, "CVE-2013-2898": {"epss_score": 0.00063, "epss_percentile": 0.20047}, "CVE-2013-2899": {"epss_score": 0.00021, "epss_percentile": 0.04781}, "CVE-2013-2900": {"epss_score": 0.01726, "epss_percentile": 0.81961}, "CVE-2013-2901": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2013-2902": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2013-2903": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2013-2904": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2013-2905": {"epss_score": 0.00135, "epss_percentile": 0.34054}, "CVE-2013-2906": {"epss_score": 0.01103, "epss_percentile": 0.77593}, "CVE-2013-2907": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2013-2908": {"epss_score": 0.00561, "epss_percentile": 0.67663}, "CVE-2013-2909": {"epss_score": 0.02346, "epss_percentile": 0.84454}, "CVE-2013-2910": {"epss_score": 0.01347, "epss_percentile": 0.79655}, "CVE-2013-2911": {"epss_score": 0.0125, "epss_percentile": 0.78882}, "CVE-2013-2912": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2013-2913": {"epss_score": 0.0125, "epss_percentile": 0.78882}, "CVE-2013-2914": {"epss_score": 0.00836, "epss_percentile": 0.74129}, "CVE-2013-2915": {"epss_score": 0.00561, "epss_percentile": 0.67663}, "CVE-2013-2916": {"epss_score": 0.00561, "epss_percentile": 0.67663}, "CVE-2013-2917": {"epss_score": 0.01347, "epss_percentile": 0.79655}, "CVE-2013-2918": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2013-2919": {"epss_score": 0.02329, "epss_percentile": 0.84398}, "CVE-2013-2920": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2013-2921": {"epss_score": 0.0125, "epss_percentile": 0.78882}, "CVE-2013-2922": {"epss_score": 0.0125, "epss_percentile": 0.78882}, "CVE-2013-2923": {"epss_score": 0.00656, "epss_percentile": 0.70454}, "CVE-2013-2924": {"epss_score": 0.01521, "epss_percentile": 0.8083}, "CVE-2013-2925": {"epss_score": 0.01611, "epss_percentile": 0.81328}, "CVE-2013-2926": {"epss_score": 0.01509, "epss_percentile": 0.80766}, "CVE-2013-2927": {"epss_score": 0.02705, "epss_percentile": 0.85466}, "CVE-2013-2928": {"epss_score": 0.00556, "epss_percentile": 0.67527}, "CVE-2013-2929": {"epss_score": 0.00015, "epss_percentile": 0.02228}, "CVE-2013-2930": {"epss_score": 0.00028, "epss_percentile": 0.07246}, "CVE-2013-2931": {"epss_score": 0.01781, "epss_percentile": 0.82239}, "CVE-2013-2933": {"epss_score": 0.00421, "epss_percentile": 0.61463}, "CVE-2013-2934": {"epss_score": 0.00421, "epss_percentile": 0.61463}, "CVE-2013-2935": {"epss_score": 0.00421, "epss_percentile": 0.61463}, "CVE-2013-2936": {"epss_score": 0.00421, "epss_percentile": 0.61463}, "CVE-2013-2937": {"epss_score": 0.00421, "epss_percentile": 0.61463}, "CVE-2013-2938": {"epss_score": 0.00421, "epss_percentile": 0.61463}, "CVE-2013-2939": {"epss_score": 0.00421, "epss_percentile": 0.61463}, "CVE-2013-2940": {"epss_score": 0.00421, "epss_percentile": 0.61463}, "CVE-2013-2944": {"epss_score": 0.00319, "epss_percentile": 0.54503}, "CVE-2013-2945": {"epss_score": 0.01346, "epss_percentile": 0.79642}, "CVE-2013-2950": {"epss_score": 0.00227, "epss_percentile": 0.454}, "CVE-2013-2951": {"epss_score": 0.00048, "epss_percentile": 0.15275}, "CVE-2013-2953": {"epss_score": 0.00123, "epss_percentile": 0.32272}, "CVE-2013-2954": {"epss_score": 0.00254, "epss_percentile": 0.48506}, "CVE-2013-2955": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-2956": {"epss_score": 0.00325, "epss_percentile": 0.55014}, "CVE-2013-2957": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-2959": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2013-2960": {"epss_score": 0.02902, "epss_percentile": 0.85956}, "CVE-2013-2961": {"epss_score": 0.00286, "epss_percentile": 0.51756}, "CVE-2013-2962": {"epss_score": 0.00046, "epss_percentile": 0.14391}, "CVE-2013-2964": {"epss_score": 0.00053, "epss_percentile": 0.167}, "CVE-2013-2967": {"epss_score": 0.00212, "epss_percentile": 0.43813}, "CVE-2013-2968": {"epss_score": 0.00427, "epss_percentile": 0.61779}, "CVE-2013-2969": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-2970": {"epss_score": 0.01327, "epss_percentile": 0.79486}, "CVE-2013-2972": {"epss_score": 0.00431, "epss_percentile": 0.6204}, "CVE-2013-2974": {"epss_score": 0.00152, "epss_percentile": 0.36446}, "CVE-2013-2976": {"epss_score": 0.00054, "epss_percentile": 0.17362}, "CVE-2013-2977": {"epss_score": 0.16142, "epss_percentile": 0.94578}, "CVE-2013-2978": {"epss_score": 0.00135, "epss_percentile": 0.33932}, "CVE-2013-2979": {"epss_score": 0.00202, "epss_percentile": 0.42457}, "CVE-2013-2980": {"epss_score": 0.00109, "epss_percentile": 0.2996}, "CVE-2013-2981": {"epss_score": 0.00086, "epss_percentile": 0.25397}, "CVE-2013-2982": {"epss_score": 0.00349, "epss_percentile": 0.56905}, "CVE-2013-2983": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-2984": {"epss_score": 0.00469, "epss_percentile": 0.6392}, "CVE-2013-2985": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2013-2987": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2013-2988": {"epss_score": 0.00191, "epss_percentile": 0.41205}, "CVE-2013-2989": {"epss_score": 0.00036, "epss_percentile": 0.10491}, "CVE-2013-2992": {"epss_score": 0.01078, "epss_percentile": 0.77343}, "CVE-2013-2993": {"epss_score": 0.00197, "epss_percentile": 0.41844}, "CVE-2013-2994": {"epss_score": 0.00227, "epss_percentile": 0.45394}, "CVE-2013-2997": {"epss_score": 0.0008, "epss_percentile": 0.242}, "CVE-2013-2998": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2013-2999": {"epss_score": 0.00212, "epss_percentile": 0.43813}, "CVE-2013-3000": {"epss_score": 0.00575, "epss_percentile": 0.68117}, "CVE-2013-3001": {"epss_score": 0.00162, "epss_percentile": 0.37699}, "CVE-2013-3003": {"epss_score": 0.02119, "epss_percentile": 0.83671}, "CVE-2013-3004": {"epss_score": 0.00142, "epss_percentile": 0.34983}, "CVE-2013-3005": {"epss_score": 0.01244, "epss_percentile": 0.78834}, "CVE-2013-3006": {"epss_score": 0.03537, "epss_percentile": 0.87312}, "CVE-2013-3007": {"epss_score": 0.02635, "epss_percentile": 0.8529}, "CVE-2013-3008": {"epss_score": 0.03537, "epss_percentile": 0.87312}, "CVE-2013-3009": {"epss_score": 0.03238, "epss_percentile": 0.86726}, "CVE-2013-3010": {"epss_score": 0.03537, "epss_percentile": 0.87312}, "CVE-2013-3011": {"epss_score": 0.0745, "epss_percentile": 0.91477}, "CVE-2013-3012": {"epss_score": 0.0745, "epss_percentile": 0.91477}, "CVE-2013-3016": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2013-3017": {"epss_score": 0.00253, "epss_percentile": 0.48446}, "CVE-2013-3018": {"epss_score": 0.00139, "epss_percentile": 0.34588}, "CVE-2013-3020": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2013-3023": {"epss_score": 0.00273, "epss_percentile": 0.50438}, "CVE-2013-3024": {"epss_score": 0.00038, "epss_percentile": 0.11169}, "CVE-2013-3025": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-3026": {"epss_score": 0.12193, "epss_percentile": 0.93599}, "CVE-2013-3027": {"epss_score": 0.04399, "epss_percentile": 0.88644}, "CVE-2013-3028": {"epss_score": 0.00073, "epss_percentile": 0.22625}, "CVE-2013-3029": {"epss_score": 0.00119, "epss_percentile": 0.31563}, "CVE-2013-3030": {"epss_score": 0.01207, "epss_percentile": 0.78525}, "CVE-2013-3031": {"epss_score": 0.00698, "epss_percentile": 0.71427}, "CVE-2013-3032": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-3033": {"epss_score": 0.00278, "epss_percentile": 0.50869}, "CVE-2013-3034": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2013-3035": {"epss_score": 0.06657, "epss_percentile": 0.90921}, "CVE-2013-3036": {"epss_score": 0.00141, "epss_percentile": 0.34947}, "CVE-2013-3037": {"epss_score": 0.00054, "epss_percentile": 0.17077}, "CVE-2013-3038": {"epss_score": 0.00221, "epss_percentile": 0.44708}, "CVE-2013-3039": {"epss_score": 0.0008, "epss_percentile": 0.24017}, "CVE-2013-3040": {"epss_score": 0.00254, "epss_percentile": 0.48524}, "CVE-2013-3041": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2013-3042": {"epss_score": 0.00019, "epss_percentile": 0.04398}, "CVE-2013-3043": {"epss_score": 0.00019, "epss_percentile": 0.04398}, "CVE-2013-3044": {"epss_score": 0.00154, "epss_percentile": 0.36652}, "CVE-2013-3045": {"epss_score": 0.00154, "epss_percentile": 0.36652}, "CVE-2013-3046": {"epss_score": 0.00061, "epss_percentile": 0.19525}, "CVE-2013-3047": {"epss_score": 0.00445, "epss_percentile": 0.62877}, "CVE-2013-3048": {"epss_score": 0.00208, "epss_percentile": 0.43262}, "CVE-2013-3049": {"epss_score": 0.00179, "epss_percentile": 0.398}, "CVE-2013-3050": {"epss_score": 0.0254, "epss_percentile": 0.85046}, "CVE-2013-3051": {"epss_score": 0.0004, "epss_percentile": 0.12173}, "CVE-2013-3055": {"epss_score": 0.03495, "epss_percentile": 0.87235}, "CVE-2013-3056": {"epss_score": 0.00016, "epss_percentile": 0.02956}, "CVE-2013-3057": {"epss_score": 5e-05, "epss_percentile": 0.00209}, "CVE-2013-3058": {"epss_score": 0.00021, "epss_percentile": 0.04873}, "CVE-2013-3059": {"epss_score": 0.00018, "epss_percentile": 0.03896}, "CVE-2013-3060": {"epss_score": 0.01019, "epss_percentile": 0.7673}, "CVE-2013-3061": {"epss_score": 0.0031, "epss_percentile": 0.53755}, "CVE-2013-3062": {"epss_score": 0.00392, "epss_percentile": 0.59645}, "CVE-2013-3063": {"epss_score": 0.00493, "epss_percentile": 0.65055}, "CVE-2013-3064": {"epss_score": 0.00403, "epss_percentile": 0.60334}, "CVE-2013-3065": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2013-3066": {"epss_score": 0.00391, "epss_percentile": 0.59592}, "CVE-2013-3067": {"epss_score": 0.00258, "epss_percentile": 0.49004}, "CVE-2013-3068": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2013-3069": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2013-3070": {"epss_score": 0.02029, "epss_percentile": 0.83328}, "CVE-2013-3071": {"epss_score": 0.01235, "epss_percentile": 0.78768}, "CVE-2013-3072": {"epss_score": 0.01584, "epss_percentile": 0.81154}, "CVE-2013-3073": {"epss_score": 0.0669, "epss_percentile": 0.9095}, "CVE-2013-3074": {"epss_score": 0.00515, "epss_percentile": 0.66003}, "CVE-2013-3075": {"epss_score": 0.34686, "epss_percentile": 0.96868}, "CVE-2013-3076": {"epss_score": 0.00058, "epss_percentile": 0.18268}, "CVE-2013-3077": {"epss_score": 0.00043, "epss_percentile": 0.13237}, "CVE-2013-3079": {"epss_score": 0.00572, "epss_percentile": 0.68}, "CVE-2013-3080": {"epss_score": 0.01195, "epss_percentile": 0.78434}, "CVE-2013-3081": {"epss_score": 0.00904, "epss_percentile": 0.7521}, "CVE-2013-3082": {"epss_score": 0.02373, "epss_percentile": 0.84531}, "CVE-2013-3083": {"epss_score": 0.00258, "epss_percentile": 0.49026}, "CVE-2013-3084": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-3085": {"epss_score": 0.00137, "epss_percentile": 0.3431}, "CVE-2013-3086": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2013-3087": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-3088": {"epss_score": 0.00184, "epss_percentile": 0.40385}, "CVE-2013-3089": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2013-3090": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-3091": {"epss_score": 0.0503, "epss_percentile": 0.89414}, "CVE-2013-3092": {"epss_score": 0.00668, "epss_percentile": 0.70732}, "CVE-2013-3093": {"epss_score": 0.00162, "epss_percentile": 0.37732}, "CVE-2013-3095": {"epss_score": 0.01105, "epss_percentile": 0.77607}, "CVE-2013-3096": {"epss_score": 0.00479, "epss_percentile": 0.6441}, "CVE-2013-3097": {"epss_score": 0.00394, "epss_percentile": 0.59796}, "CVE-2013-3098": {"epss_score": 0.00347, "epss_percentile": 0.56783}, "CVE-2013-3106": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-3107": {"epss_score": 0.00288, "epss_percentile": 0.51886}, "CVE-2013-3110": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3111": {"epss_score": 0.41036, "epss_percentile": 0.9725}, "CVE-2013-3112": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3113": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3114": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3115": {"epss_score": 0.26115, "epss_percentile": 0.96114}, "CVE-2013-3116": {"epss_score": 0.27247, "epss_percentile": 0.96228}, "CVE-2013-3117": {"epss_score": 0.27247, "epss_percentile": 0.96228}, "CVE-2013-3118": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3119": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3120": {"epss_score": 0.22095, "epss_percentile": 0.95594}, "CVE-2013-3121": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3122": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3123": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3124": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3125": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3126": {"epss_score": 0.10842, "epss_percentile": 0.9313}, "CVE-2013-3127": {"epss_score": 0.35507, "epss_percentile": 0.96917}, "CVE-2013-3128": {"epss_score": 0.57836, "epss_percentile": 0.98085}, "CVE-2013-3129": {"epss_score": 0.51653, "epss_percentile": 0.97791}, "CVE-2013-3131": {"epss_score": 0.54668, "epss_percentile": 0.97937}, "CVE-2013-3132": {"epss_score": 0.07064, "epss_percentile": 0.91222}, "CVE-2013-3133": {"epss_score": 0.0861, "epss_percentile": 0.9215}, "CVE-2013-3134": {"epss_score": 0.57687, "epss_percentile": 0.98079}, "CVE-2013-3136": {"epss_score": 0.01236, "epss_percentile": 0.78769}, "CVE-2013-3137": {"epss_score": 0.13696, "epss_percentile": 0.94037}, "CVE-2013-3138": {"epss_score": 0.8835, "epss_percentile": 0.99467}, "CVE-2013-3139": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3140": {"epss_score": 0.26132, "epss_percentile": 0.96116}, "CVE-2013-3141": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3142": {"epss_score": 0.26943, "epss_percentile": 0.96194}, "CVE-2013-3143": {"epss_score": 0.57512, "epss_percentile": 0.98067}, "CVE-2013-3144": {"epss_score": 0.10945, "epss_percentile": 0.93169}, "CVE-2013-3145": {"epss_score": 0.10951, "epss_percentile": 0.93173}, "CVE-2013-3146": {"epss_score": 0.15374, "epss_percentile": 0.94417}, "CVE-2013-3147": {"epss_score": 0.10951, "epss_percentile": 0.93173}, "CVE-2013-3148": {"epss_score": 0.10951, "epss_percentile": 0.93173}, "CVE-2013-3149": {"epss_score": 0.10951, "epss_percentile": 0.93173}, "CVE-2013-3150": {"epss_score": 0.10951, "epss_percentile": 0.93173}, "CVE-2013-3151": {"epss_score": 0.10945, "epss_percentile": 0.93169}, "CVE-2013-3152": {"epss_score": 0.15374, "epss_percentile": 0.94417}, "CVE-2013-3153": {"epss_score": 0.10951, "epss_percentile": 0.93173}, "CVE-2013-3154": {"epss_score": 0.07544, "epss_percentile": 0.91528}, "CVE-2013-3155": {"epss_score": 0.58017, "epss_percentile": 0.98095}, "CVE-2013-3156": {"epss_score": 0.53228, "epss_percentile": 0.97867}, "CVE-2013-3157": {"epss_score": 0.53228, "epss_percentile": 0.97867}, "CVE-2013-3158": {"epss_score": 0.53228, "epss_percentile": 0.97867}, "CVE-2013-3159": {"epss_score": 0.25439, "epss_percentile": 0.96028}, "CVE-2013-3160": {"epss_score": 0.28558, "epss_percentile": 0.96367}, "CVE-2013-3161": {"epss_score": 0.0994, "epss_percentile": 0.92783}, "CVE-2013-3162": {"epss_score": 0.10951, "epss_percentile": 0.93173}, "CVE-2013-3163": {"epss_score": 0.85003, "epss_percentile": 0.99313}, "CVE-2013-3164": {"epss_score": 0.15374, "epss_percentile": 0.94417}, "CVE-2013-3166": {"epss_score": 0.14767, "epss_percentile": 0.94279}, "CVE-2013-3167": {"epss_score": 0.01701, "epss_percentile": 0.81838}, "CVE-2013-3171": {"epss_score": 0.0861, "epss_percentile": 0.9215}, "CVE-2013-3172": {"epss_score": 0.00385, "epss_percentile": 0.59185}, "CVE-2013-3173": {"epss_score": 0.02625, "epss_percentile": 0.85263}, "CVE-2013-3174": {"epss_score": 0.34922, "epss_percentile": 0.96878}, "CVE-2013-3175": {"epss_score": 0.66218, "epss_percentile": 0.98455}, "CVE-2013-3178": {"epss_score": 0.5895, "epss_percentile": 0.98141}, "CVE-2013-3179": {"epss_score": 0.10604, "epss_percentile": 0.93044}, "CVE-2013-3180": {"epss_score": 0.44955, "epss_percentile": 0.97463}, "CVE-2013-3181": {"epss_score": 0.44472, "epss_percentile": 0.97439}, "CVE-2013-3182": {"epss_score": 0.80586, "epss_percentile": 0.99096}, "CVE-2013-3183": {"epss_score": 0.81532, "epss_percentile": 0.99142}, "CVE-2013-3184": {"epss_score": 0.78922, "epss_percentile": 0.99011}, "CVE-2013-3185": {"epss_score": 0.27551, "epss_percentile": 0.96258}, "CVE-2013-3186": {"epss_score": 0.16021, "epss_percentile": 0.9456}, "CVE-2013-3187": {"epss_score": 0.27247, "epss_percentile": 0.96228}, "CVE-2013-3188": {"epss_score": 0.25138, "epss_percentile": 0.9599}, "CVE-2013-3189": {"epss_score": 0.26943, "epss_percentile": 0.96194}, "CVE-2013-3190": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3191": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3192": {"epss_score": 0.18187, "epss_percentile": 0.94972}, "CVE-2013-3193": {"epss_score": 0.27247, "epss_percentile": 0.96228}, "CVE-2013-3194": {"epss_score": 0.27247, "epss_percentile": 0.96228}, "CVE-2013-3195": {"epss_score": 0.62976, "epss_percentile": 0.98315}, "CVE-2013-3196": {"epss_score": 0.01175, "epss_percentile": 0.78262}, "CVE-2013-3197": {"epss_score": 0.01175, "epss_percentile": 0.78262}, "CVE-2013-3198": {"epss_score": 0.01175, "epss_percentile": 0.78262}, "CVE-2013-3199": {"epss_score": 0.27247, "epss_percentile": 0.96228}, "CVE-2013-3200": {"epss_score": 0.00509, "epss_percentile": 0.65728}, "CVE-2013-3201": {"epss_score": 0.27247, "epss_percentile": 0.96228}, "CVE-2013-3202": {"epss_score": 0.27247, "epss_percentile": 0.96228}, "CVE-2013-3203": {"epss_score": 0.40642, "epss_percentile": 0.97229}, "CVE-2013-3204": {"epss_score": 0.27247, "epss_percentile": 0.96228}, "CVE-2013-3205": {"epss_score": 0.81239, "epss_percentile": 0.99129}, "CVE-2013-3206": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3207": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3208": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3209": {"epss_score": 0.27247, "epss_percentile": 0.96228}, "CVE-2013-3210": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2013-3211": {"epss_score": 0.00423, "epss_percentile": 0.61594}, "CVE-2013-3212": {"epss_score": 0.23052, "epss_percentile": 0.95725}, "CVE-2013-3213": {"epss_score": 0.00211, "epss_percentile": 0.43669}, "CVE-2013-3214": {"epss_score": 0.88538, "epss_percentile": 0.99476}, "CVE-2013-3215": {"epss_score": 0.73669, "epss_percentile": 0.98766}, "CVE-2013-3219": {"epss_score": 0.01095, "epss_percentile": 0.77511}, "CVE-2013-3220": {"epss_score": 0.01533, "epss_percentile": 0.80899}, "CVE-2013-3221": {"epss_score": 0.00483, "epss_percentile": 0.64574}, "CVE-2013-3222": {"epss_score": 0.00078, "epss_percentile": 0.23611}, "CVE-2013-3223": {"epss_score": 0.00054, "epss_percentile": 0.17268}, "CVE-2013-3224": {"epss_score": 0.00078, "epss_percentile": 0.23611}, "CVE-2013-3225": {"epss_score": 0.00076, "epss_percentile": 0.23151}, "CVE-2013-3226": {"epss_score": 0.00058, "epss_percentile": 0.18268}, "CVE-2013-3227": {"epss_score": 0.00052, "epss_percentile": 0.16579}, "CVE-2013-3228": {"epss_score": 0.00053, "epss_percentile": 0.16998}, "CVE-2013-3229": {"epss_score": 0.00052, "epss_percentile": 0.16579}, "CVE-2013-3230": {"epss_score": 0.00055, "epss_percentile": 0.17493}, "CVE-2013-3231": {"epss_score": 0.00075, "epss_percentile": 0.22942}, "CVE-2013-3232": {"epss_score": 0.00057, "epss_percentile": 0.18102}, "CVE-2013-3233": {"epss_score": 0.00052, "epss_percentile": 0.16579}, "CVE-2013-3234": {"epss_score": 0.00053, "epss_percentile": 0.16998}, "CVE-2013-3235": {"epss_score": 0.00073, "epss_percentile": 0.22603}, "CVE-2013-3236": {"epss_score": 0.00053, "epss_percentile": 0.16998}, "CVE-2013-3237": {"epss_score": 0.00054, "epss_percentile": 0.17103}, "CVE-2013-3238": {"epss_score": 0.64584, "epss_percentile": 0.98384}, "CVE-2013-3239": {"epss_score": 0.12333, "epss_percentile": 0.93643}, "CVE-2013-3240": {"epss_score": 0.04055, "epss_percentile": 0.88184}, "CVE-2013-3241": {"epss_score": 0.03369, "epss_percentile": 0.87007}, "CVE-2013-3242": {"epss_score": 0.00175, "epss_percentile": 0.39309}, "CVE-2013-3243": {"epss_score": 0.00437, "epss_percentile": 0.62522}, "CVE-2013-3244": {"epss_score": 0.0112, "epss_percentile": 0.77761}, "CVE-2013-3245": {"epss_score": 0.01865, "epss_percentile": 0.82602}, "CVE-2013-3246": {"epss_score": 0.01652, "epss_percentile": 0.81572}, "CVE-2013-3247": {"epss_score": 0.01198, "epss_percentile": 0.78448}, "CVE-2013-3248": {"epss_score": 0.59529, "epss_percentile": 0.98169}, "CVE-2013-3249": {"epss_score": 0.02917, "epss_percentile": 0.85983}, "CVE-2013-3250": {"epss_score": 0.00094, "epss_percentile": 0.26787}, "CVE-2013-3251": {"epss_score": 0.00165, "epss_percentile": 0.38027}, "CVE-2013-3252": {"epss_score": 0.00179, "epss_percentile": 0.39847}, "CVE-2013-3253": {"epss_score": 0.00251, "epss_percentile": 0.48279}, "CVE-2013-3254": {"epss_score": 0.00271, "epss_percentile": 0.50338}, "CVE-2013-3256": {"epss_score": 0.00187, "epss_percentile": 0.40792}, "CVE-2013-3257": {"epss_score": 0.0014, "epss_percentile": 0.34796}, "CVE-2013-3258": {"epss_score": 0.0014, "epss_percentile": 0.34796}, "CVE-2013-3259": {"epss_score": 0.05893, "epss_percentile": 0.90301}, "CVE-2013-3260": {"epss_score": 0.03425, "epss_percentile": 0.87113}, "CVE-2013-3261": {"epss_score": 0.00319, "epss_percentile": 0.54471}, "CVE-2013-3262": {"epss_score": 0.00347, "epss_percentile": 0.56792}, "CVE-2013-3263": {"epss_score": 0.00271, "epss_percentile": 0.50338}, "CVE-2013-3264": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2013-3266": {"epss_score": 0.02313, "epss_percentile": 0.84344}, "CVE-2013-3267": {"epss_score": 0.00021, "epss_percentile": 0.04873}, "CVE-2013-3268": {"epss_score": 0.00188, "epss_percentile": 0.40881}, "CVE-2013-3269": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2013-3270": {"epss_score": 0.0004, "epss_percentile": 0.11923}, "CVE-2013-3271": {"epss_score": 0.00275, "epss_percentile": 0.50686}, "CVE-2013-3272": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2013-3273": {"epss_score": 0.00053, "epss_percentile": 0.16903}, "CVE-2013-3274": {"epss_score": 0.01424, "epss_percentile": 0.80194}, "CVE-2013-3275": {"epss_score": 0.00285, "epss_percentile": 0.51513}, "CVE-2013-3276": {"epss_score": 0.00191, "epss_percentile": 0.41201}, "CVE-2013-3277": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2013-3278": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2013-3279": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-3280": {"epss_score": 0.00304, "epss_percentile": 0.53253}, "CVE-2013-3281": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2013-3285": {"epss_score": 0.0019, "epss_percentile": 0.4109}, "CVE-2013-3286": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-3287": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2013-3288": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-3294": {"epss_score": 0.01132, "epss_percentile": 0.77868}, "CVE-2013-3295": {"epss_score": 0.00424, "epss_percentile": 0.61655}, "CVE-2013-3299": {"epss_score": 0.06217, "epss_percentile": 0.90576}, "CVE-2013-3300": {"epss_score": 0.00161, "epss_percentile": 0.37592}, "CVE-2013-3301": {"epss_score": 0.00373, "epss_percentile": 0.58497}, "CVE-2013-3302": {"epss_score": 0.00047, "epss_percentile": 0.14757}, "CVE-2013-3304": {"epss_score": 0.13617, "epss_percentile": 0.94014}, "CVE-2013-3307": {"epss_score": 0.03254, "epss_percentile": 0.86757}, "CVE-2013-3311": {"epss_score": 0.01839, "epss_percentile": 0.82487}, "CVE-2013-3312": {"epss_score": 0.00182, "epss_percentile": 0.40145}, "CVE-2013-3313": {"epss_score": 0.01733, "epss_percentile": 0.81998}, "CVE-2013-3314": {"epss_score": 0.24633, "epss_percentile": 0.95942}, "CVE-2013-3315": {"epss_score": 0.00536, "epss_percentile": 0.66858}, "CVE-2013-3316": {"epss_score": 0.01208, "epss_percentile": 0.78532}, "CVE-2013-3317": {"epss_score": 0.01208, "epss_percentile": 0.78532}, "CVE-2013-3319": {"epss_score": 0.11698, "epss_percentile": 0.93454}, "CVE-2013-3320": {"epss_score": 0.00339, "epss_percentile": 0.56182}, "CVE-2013-3321": {"epss_score": 0.00906, "epss_percentile": 0.75248}, "CVE-2013-3322": {"epss_score": 0.03541, "epss_percentile": 0.87318}, "CVE-2013-3323": {"epss_score": 0.00534, "epss_percentile": 0.66794}, "CVE-2013-3324": {"epss_score": 0.03998, "epss_percentile": 0.88089}, "CVE-2013-3325": {"epss_score": 0.03998, "epss_percentile": 0.88089}, "CVE-2013-3326": {"epss_score": 0.03998, "epss_percentile": 0.88089}, "CVE-2013-3327": {"epss_score": 0.03998, "epss_percentile": 0.88089}, "CVE-2013-3328": {"epss_score": 0.03998, "epss_percentile": 0.88089}, "CVE-2013-3329": {"epss_score": 0.03998, "epss_percentile": 0.88089}, "CVE-2013-3330": {"epss_score": 0.03998, "epss_percentile": 0.88089}, "CVE-2013-3331": {"epss_score": 0.02028, "epss_percentile": 0.83325}, "CVE-2013-3332": {"epss_score": 0.02028, "epss_percentile": 0.83325}, "CVE-2013-3333": {"epss_score": 0.02028, "epss_percentile": 0.83325}, "CVE-2013-3334": {"epss_score": 0.03998, "epss_percentile": 0.88089}, "CVE-2013-3335": {"epss_score": 0.03998, "epss_percentile": 0.88089}, "CVE-2013-3336": {"epss_score": 0.85888, "epss_percentile": 0.99353}, "CVE-2013-3337": {"epss_score": 0.18885, "epss_percentile": 0.95086}, "CVE-2013-3338": {"epss_score": 0.18885, "epss_percentile": 0.95086}, "CVE-2013-3339": {"epss_score": 0.18885, "epss_percentile": 0.95086}, "CVE-2013-3340": {"epss_score": 0.17157, "epss_percentile": 0.94789}, "CVE-2013-3341": {"epss_score": 0.18885, "epss_percentile": 0.95086}, "CVE-2013-3342": {"epss_score": 0.02693, "epss_percentile": 0.85441}, "CVE-2013-3343": {"epss_score": 0.05301, "epss_percentile": 0.89707}, "CVE-2013-3344": {"epss_score": 0.09879, "epss_percentile": 0.9275}, "CVE-2013-3345": {"epss_score": 0.09427, "epss_percentile": 0.92542}, "CVE-2013-3346": {"epss_score": 0.89914, "epss_percentile": 0.99549}, "CVE-2013-3347": {"epss_score": 0.0999, "epss_percentile": 0.92806}, "CVE-2013-3348": {"epss_score": 0.11434, "epss_percentile": 0.93352}, "CVE-2013-3349": {"epss_score": 0.00689, "epss_percentile": 0.71227}, "CVE-2013-3350": {"epss_score": 0.01608, "epss_percentile": 0.81311}, "CVE-2013-3351": {"epss_score": 0.42548, "epss_percentile": 0.97337}, "CVE-2013-3352": {"epss_score": 0.26105, "epss_percentile": 0.96112}, "CVE-2013-3353": {"epss_score": 0.4398, "epss_percentile": 0.97413}, "CVE-2013-3354": {"epss_score": 0.26105, "epss_percentile": 0.96112}, "CVE-2013-3355": {"epss_score": 0.26105, "epss_percentile": 0.96112}, "CVE-2013-3356": {"epss_score": 0.4398, "epss_percentile": 0.97413}, "CVE-2013-3357": {"epss_score": 0.37538, "epss_percentile": 0.97053}, "CVE-2013-3358": {"epss_score": 0.37538, "epss_percentile": 0.97053}, "CVE-2013-3359": {"epss_score": 0.11434, "epss_percentile": 0.93352}, "CVE-2013-3360": {"epss_score": 0.26105, "epss_percentile": 0.96112}, "CVE-2013-3361": {"epss_score": 0.11531, "epss_percentile": 0.93396}, "CVE-2013-3362": {"epss_score": 0.11531, "epss_percentile": 0.93396}, "CVE-2013-3363": {"epss_score": 0.11531, "epss_percentile": 0.93396}, "CVE-2013-3365": {"epss_score": 0.06761, "epss_percentile": 0.91008}, "CVE-2013-3366": {"epss_score": 0.00242, "epss_percentile": 0.47366}, "CVE-2013-3367": {"epss_score": 0.00509, "epss_percentile": 0.65743}, "CVE-2013-3368": {"epss_score": 0.00042, "epss_percentile": 0.12925}, "CVE-2013-3369": {"epss_score": 0.00628, "epss_percentile": 0.69648}, "CVE-2013-3370": {"epss_score": 0.0113, "epss_percentile": 0.77849}, "CVE-2013-3371": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2013-3372": {"epss_score": 0.0048, "epss_percentile": 0.64448}, "CVE-2013-3373": {"epss_score": 0.0048, "epss_percentile": 0.64448}, "CVE-2013-3374": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2013-3375": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-3376": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2013-3377": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-3378": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-3379": {"epss_score": 0.00232, "epss_percentile": 0.45962}, "CVE-2013-3380": {"epss_score": 0.00143, "epss_percentile": 0.3521}, "CVE-2013-3381": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-3382": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-3383": {"epss_score": 0.00746, "epss_percentile": 0.72548}, "CVE-2013-3384": {"epss_score": 0.00615, "epss_percentile": 0.69295}, "CVE-2013-3385": {"epss_score": 0.00554, "epss_percentile": 0.67454}, "CVE-2013-3386": {"epss_score": 0.00393, "epss_percentile": 0.59734}, "CVE-2013-3387": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-3388": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-3389": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-3390": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-3392": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2013-3393": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-3394": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2013-3395": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2013-3396": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-3397": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2013-3398": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2013-3399": {"epss_score": 0.00069, "epss_percentile": 0.21481}, "CVE-2013-3400": {"epss_score": 0.00288, "epss_percentile": 0.51869}, "CVE-2013-3401": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2013-3402": {"epss_score": 0.00622, "epss_percentile": 0.69505}, "CVE-2013-3403": {"epss_score": 0.00127, "epss_percentile": 0.32924}, "CVE-2013-3404": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2013-3405": {"epss_score": 0.00368, "epss_percentile": 0.5819}, "CVE-2013-3406": {"epss_score": 0.00195, "epss_percentile": 0.41636}, "CVE-2013-3407": {"epss_score": 0.00214, "epss_percentile": 0.44001}, "CVE-2013-3408": {"epss_score": 0.00061, "epss_percentile": 0.19303}, "CVE-2013-3409": {"epss_score": 0.00056, "epss_percentile": 0.17671}, "CVE-2013-3410": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-3411": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-3412": {"epss_score": 0.00311, "epss_percentile": 0.5386}, "CVE-2013-3413": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-3414": {"epss_score": 0.00521, "epss_percentile": 0.66225}, "CVE-2013-3415": {"epss_score": 0.00619, "epss_percentile": 0.69394}, "CVE-2013-3416": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-3417": {"epss_score": 0.00215, "epss_percentile": 0.44035}, "CVE-2013-3418": {"epss_score": 0.00363, "epss_percentile": 0.57874}, "CVE-2013-3419": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-3420": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2013-3421": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-3422": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-3423": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-3424": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2013-3425": {"epss_score": 0.00183, "epss_percentile": 0.40335}, "CVE-2013-3426": {"epss_score": 0.00375, "epss_percentile": 0.58619}, "CVE-2013-3428": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2013-3429": {"epss_score": 0.11667, "epss_percentile": 0.93439}, "CVE-2013-3430": {"epss_score": 0.02194, "epss_percentile": 0.83949}, "CVE-2013-3431": {"epss_score": 0.04097, "epss_percentile": 0.88252}, "CVE-2013-3433": {"epss_score": 0.00098, "epss_percentile": 0.27717}, "CVE-2013-3434": {"epss_score": 0.00098, "epss_percentile": 0.27717}, "CVE-2013-3435": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2013-3436": {"epss_score": 0.00197, "epss_percentile": 0.41951}, "CVE-2013-3437": {"epss_score": 0.00351, "epss_percentile": 0.57053}, "CVE-2013-3438": {"epss_score": 0.00207, "epss_percentile": 0.43199}, "CVE-2013-3439": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2013-3440": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2013-3441": {"epss_score": 0.00708, "epss_percentile": 0.71668}, "CVE-2013-3442": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2013-3443": {"epss_score": 0.07922, "epss_percentile": 0.91763}, "CVE-2013-3444": {"epss_score": 0.02636, "epss_percentile": 0.85293}, "CVE-2013-3445": {"epss_score": 0.01558, "epss_percentile": 0.81028}, "CVE-2013-3446": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2013-3448": {"epss_score": 0.00256, "epss_percentile": 0.48822}, "CVE-2013-3450": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2013-3451": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2013-3453": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-3454": {"epss_score": 0.00838, "epss_percentile": 0.74176}, "CVE-2013-3455": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2013-3457": {"epss_score": 0.00211, "epss_percentile": 0.43629}, "CVE-2013-3458": {"epss_score": 0.00486, "epss_percentile": 0.64761}, "CVE-2013-3459": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-3460": {"epss_score": 0.00547, "epss_percentile": 0.67232}, "CVE-2013-3461": {"epss_score": 0.00511, "epss_percentile": 0.65844}, "CVE-2013-3462": {"epss_score": 0.08764, "epss_percentile": 0.92245}, "CVE-2013-3463": {"epss_score": 0.01166, "epss_percentile": 0.78183}, "CVE-2013-3464": {"epss_score": 0.0013, "epss_percentile": 0.33295}, "CVE-2013-3466": {"epss_score": 0.00722, "epss_percentile": 0.71996}, "CVE-2013-3467": {"epss_score": 0.00112, "epss_percentile": 0.30516}, "CVE-2013-3468": {"epss_score": 0.00914, "epss_percentile": 0.75391}, "CVE-2013-3469": {"epss_score": 0.00547, "epss_percentile": 0.67259}, "CVE-2013-3470": {"epss_score": 0.01565, "epss_percentile": 0.81063}, "CVE-2013-3471": {"epss_score": 0.00394, "epss_percentile": 0.5979}, "CVE-2013-3472": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2013-3473": {"epss_score": 0.00272, "epss_percentile": 0.50404}, "CVE-2013-3474": {"epss_score": 0.00519, "epss_percentile": 0.66182}, "CVE-2013-3475": {"epss_score": 0.00086, "epss_percentile": 0.25421}, "CVE-2013-3476": {"epss_score": 0.0014, "epss_percentile": 0.34796}, "CVE-2013-3477": {"epss_score": 0.0014, "epss_percentile": 0.34796}, "CVE-2013-3478": {"epss_score": 0.00587, "epss_percentile": 0.68465}, "CVE-2013-3479": {"epss_score": 0.00153, "epss_percentile": 0.36572}, "CVE-2013-3480": {"epss_score": 0.10521, "epss_percentile": 0.93018}, "CVE-2013-3481": {"epss_score": 0.18794, "epss_percentile": 0.9507}, "CVE-2013-3482": {"epss_score": 0.6574, "epss_percentile": 0.98436}, "CVE-2013-3483": {"epss_score": 0.07612, "epss_percentile": 0.91568}, "CVE-2013-3484": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2013-3485": {"epss_score": 0.00068, "epss_percentile": 0.21404}, "CVE-2013-3486": {"epss_score": 0.00849, "epss_percentile": 0.74371}, "CVE-2013-3487": {"epss_score": 0.00522, "epss_percentile": 0.66277}, "CVE-2013-3488": {"epss_score": 0.03754, "epss_percentile": 0.87679}, "CVE-2013-3489": {"epss_score": 0.03754, "epss_percentile": 0.87679}, "CVE-2013-3491": {"epss_score": 0.00136, "epss_percentile": 0.34166}, "CVE-2013-3492": {"epss_score": 0.00436, "epss_percentile": 0.62483}, "CVE-2013-3493": {"epss_score": 0.00412, "epss_percentile": 0.60924}, "CVE-2013-3494": {"epss_score": 0.00211, "epss_percentile": 0.43626}, "CVE-2013-3495": {"epss_score": 0.00076, "epss_percentile": 0.2327}, "CVE-2013-3496": {"epss_score": 0.00034, "epss_percentile": 0.0966}, "CVE-2013-3497": {"epss_score": 0.00077, "epss_percentile": 0.234}, "CVE-2013-3498": {"epss_score": 0.00266, "epss_percentile": 0.49876}, "CVE-2013-3499": {"epss_score": 0.00856, "epss_percentile": 0.74475}, "CVE-2013-3500": {"epss_score": 0.00475, "epss_percentile": 0.64189}, "CVE-2013-3501": {"epss_score": 0.02815, "epss_percentile": 0.85729}, "CVE-2013-3502": {"epss_score": 0.4221, "epss_percentile": 0.97318}, "CVE-2013-3503": {"epss_score": 0.00802, "epss_percentile": 0.73588}, "CVE-2013-3504": {"epss_score": 0.00665, "epss_percentile": 0.70671}, "CVE-2013-3505": {"epss_score": 0.00289, "epss_percentile": 0.52046}, "CVE-2013-3506": {"epss_score": 0.01448, "epss_percentile": 0.80338}, "CVE-2013-3507": {"epss_score": 0.00675, "epss_percentile": 0.70898}, "CVE-2013-3508": {"epss_score": 0.00606, "epss_percentile": 0.69006}, "CVE-2013-3509": {"epss_score": 0.00606, "epss_percentile": 0.69006}, "CVE-2013-3510": {"epss_score": 0.00638, "epss_percentile": 0.69922}, "CVE-2013-3511": {"epss_score": 0.01452, "epss_percentile": 0.8037}, "CVE-2013-3512": {"epss_score": 0.00867, "epss_percentile": 0.74653}, "CVE-2013-3513": {"epss_score": 0.00214, "epss_percentile": 0.44019}, "CVE-2013-3514": {"epss_score": 0.07727, "epss_percentile": 0.91646}, "CVE-2013-3515": {"epss_score": 0.06006, "epss_percentile": 0.90397}, "CVE-2013-3516": {"epss_score": 0.00217, "epss_percentile": 0.44292}, "CVE-2013-3517": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2013-3519": {"epss_score": 0.0017, "epss_percentile": 0.38728}, "CVE-2013-3520": {"epss_score": 0.81911, "epss_percentile": 0.99164}, "CVE-2013-3522": {"epss_score": 0.54117, "epss_percentile": 0.97912}, "CVE-2013-3523": {"epss_score": 0.00229, "epss_percentile": 0.45595}, "CVE-2013-3524": {"epss_score": 0.01609, "epss_percentile": 0.81319}, "CVE-2013-3525": {"epss_score": 0.01525, "epss_percentile": 0.8086}, "CVE-2013-3526": {"epss_score": 0.08185, "epss_percentile": 0.91918}, "CVE-2013-3527": {"epss_score": 0.03643, "epss_percentile": 0.87495}, "CVE-2013-3528": {"epss_score": 0.04513, "epss_percentile": 0.88783}, "CVE-2013-3529": {"epss_score": 0.04745, "epss_percentile": 0.89087}, "CVE-2013-3530": {"epss_score": 0.00905, "epss_percentile": 0.75235}, "CVE-2013-3531": {"epss_score": 0.00446, "epss_percentile": 0.62906}, "CVE-2013-3532": {"epss_score": 0.03329, "epss_percentile": 0.86926}, "CVE-2013-3533": {"epss_score": 0.00458, "epss_percentile": 0.63424}, "CVE-2013-3534": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2013-3535": {"epss_score": 0.12306, "epss_percentile": 0.93629}, "CVE-2013-3536": {"epss_score": 0.00509, "epss_percentile": 0.6574}, "CVE-2013-3537": {"epss_score": 0.00549, "epss_percentile": 0.67309}, "CVE-2013-3538": {"epss_score": 0.03547, "epss_percentile": 0.87331}, "CVE-2013-3539": {"epss_score": 0.0143, "epss_percentile": 0.80236}, "CVE-2013-3540": {"epss_score": 0.00375, "epss_percentile": 0.58638}, "CVE-2013-3541": {"epss_score": 0.12976, "epss_percentile": 0.93833}, "CVE-2013-3542": {"epss_score": 0.0324, "epss_percentile": 0.86731}, "CVE-2013-3543": {"epss_score": 0.07865, "epss_percentile": 0.91728}, "CVE-2013-3551": {"epss_score": 0.00479, "epss_percentile": 0.64444}, "CVE-2013-3552": {"epss_score": 0.0056, "epss_percentile": 0.67653}, "CVE-2013-3553": {"epss_score": 0.0056, "epss_percentile": 0.67653}, "CVE-2013-3555": {"epss_score": 0.03399, "epss_percentile": 0.87067}, "CVE-2013-3556": {"epss_score": 0.01538, "epss_percentile": 0.80932}, "CVE-2013-3557": {"epss_score": 0.0418, "epss_percentile": 0.88355}, "CVE-2013-3558": {"epss_score": 0.03264, "epss_percentile": 0.86779}, "CVE-2013-3559": {"epss_score": 0.05039, "epss_percentile": 0.89424}, "CVE-2013-3560": {"epss_score": 0.0345, "epss_percentile": 0.87164}, "CVE-2013-3561": {"epss_score": 0.01522, "epss_percentile": 0.80838}, "CVE-2013-3562": {"epss_score": 0.0344, "epss_percentile": 0.87139}, "CVE-2013-3563": {"epss_score": 0.67188, "epss_percentile": 0.98497}, "CVE-2013-3564": {"epss_score": 0.00233, "epss_percentile": 0.45987}, "CVE-2013-3565": {"epss_score": 0.00396, "epss_percentile": 0.59906}, "CVE-2013-3567": {"epss_score": 0.11139, "epss_percentile": 0.93238}, "CVE-2013-3568": {"epss_score": 0.41064, "epss_percentile": 0.97252}, "CVE-2013-3571": {"epss_score": 0.0082, "epss_percentile": 0.73879}, "CVE-2013-3572": {"epss_score": 0.00504, "epss_percentile": 0.65486}, "CVE-2013-3573": {"epss_score": 0.01114, "epss_percentile": 0.77696}, "CVE-2013-3574": {"epss_score": 0.23025, "epss_percentile": 0.95721}, "CVE-2013-3575": {"epss_score": 0.25, "epss_percentile": 0.95977}, "CVE-2013-3576": {"epss_score": 0.46318, "epss_percentile": 0.97541}, "CVE-2013-3577": {"epss_score": 0.00374, "epss_percentile": 0.58558}, "CVE-2013-3578": {"epss_score": 0.00863, "epss_percentile": 0.74589}, "CVE-2013-3579": {"epss_score": 0.00431, "epss_percentile": 0.62091}, "CVE-2013-3580": {"epss_score": 0.00396, "epss_percentile": 0.59929}, "CVE-2013-3581": {"epss_score": 0.00354, "epss_percentile": 0.57211}, "CVE-2013-3582": {"epss_score": 0.00843, "epss_percentile": 0.74254}, "CVE-2013-3583": {"epss_score": 0.00081, "epss_percentile": 0.24363}, "CVE-2013-3584": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2013-3585": {"epss_score": 0.10793, "epss_percentile": 0.93105}, "CVE-2013-3586": {"epss_score": 0.0779, "epss_percentile": 0.91682}, "CVE-2013-3587": {"epss_score": 0.25301, "epss_percentile": 0.9601}, "CVE-2013-3588": {"epss_score": 0.00599, "epss_percentile": 0.68805}, "CVE-2013-3589": {"epss_score": 0.01039, "epss_percentile": 0.7695}, "CVE-2013-3590": {"epss_score": 0.03762, "epss_percentile": 0.8769}, "CVE-2013-3591": {"epss_score": 0.799, "epss_percentile": 0.99061}, "CVE-2013-3593": {"epss_score": 0.00375, "epss_percentile": 0.58594}, "CVE-2013-3594": {"epss_score": 0.05033, "epss_percentile": 0.89417}, "CVE-2013-3595": {"epss_score": 0.00477, "epss_percentile": 0.64353}, "CVE-2013-3596": {"epss_score": 0.00248, "epss_percentile": 0.47938}, "CVE-2013-3597": {"epss_score": 0.32125, "epss_percentile": 0.96673}, "CVE-2013-3598": {"epss_score": 0.00943, "epss_percentile": 0.75777}, "CVE-2013-3599": {"epss_score": 0.00555, "epss_percentile": 0.67457}, "CVE-2013-3600": {"epss_score": 0.00348, "epss_percentile": 0.56806}, "CVE-2013-3601": {"epss_score": 0.00319, "epss_percentile": 0.54534}, "CVE-2013-3602": {"epss_score": 0.00275, "epss_percentile": 0.50687}, "CVE-2013-3603": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2013-3604": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2013-3605": {"epss_score": 0.00081, "epss_percentile": 0.24363}, "CVE-2013-3606": {"epss_score": 0.00761, "epss_percentile": 0.7282}, "CVE-2013-3607": {"epss_score": 0.14296, "epss_percentile": 0.9418}, "CVE-2013-3608": {"epss_score": 0.03077, "epss_percentile": 0.86363}, "CVE-2013-3609": {"epss_score": 0.03052, "epss_percentile": 0.86292}, "CVE-2013-3610": {"epss_score": 0.00154, "epss_percentile": 0.36671}, "CVE-2013-3612": {"epss_score": 0.09226, "epss_percentile": 0.92457}, "CVE-2013-3613": {"epss_score": 0.08487, "epss_percentile": 0.92079}, "CVE-2013-3614": {"epss_score": 0.11615, "epss_percentile": 0.93421}, "CVE-2013-3615": {"epss_score": 0.0652, "epss_percentile": 0.90818}, "CVE-2013-3616": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2013-3617": {"epss_score": 0.5674, "epss_percentile": 0.98035}, "CVE-2013-3619": {"epss_score": 0.0946, "epss_percentile": 0.92557}, "CVE-2013-3620": {"epss_score": 0.01711, "epss_percentile": 0.81879}, "CVE-2013-3622": {"epss_score": 0.05505, "epss_percentile": 0.89942}, "CVE-2013-3623": {"epss_score": 0.87341, "epss_percentile": 0.99425}, "CVE-2013-3624": {"epss_score": 0.00439, "epss_percentile": 0.62593}, "CVE-2013-3625": {"epss_score": 0.00205, "epss_percentile": 0.42725}, "CVE-2013-3626": {"epss_score": 0.00352, "epss_percentile": 0.57103}, "CVE-2013-3627": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2013-3628": {"epss_score": 0.89622, "epss_percentile": 0.99535}, "CVE-2013-3629": {"epss_score": 0.77052, "epss_percentile": 0.98918}, "CVE-2013-3630": {"epss_score": 0.64521, "epss_percentile": 0.98381}, "CVE-2013-3631": {"epss_score": 0.49365, "epss_percentile": 0.97681}, "CVE-2013-3632": {"epss_score": 0.7891, "epss_percentile": 0.9901}, "CVE-2013-3633": {"epss_score": 0.00369, "epss_percentile": 0.58238}, "CVE-2013-3634": {"epss_score": 0.00389, "epss_percentile": 0.59406}, "CVE-2013-3635": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2013-3636": {"epss_score": 0.00235, "epss_percentile": 0.46215}, "CVE-2013-3637": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2013-3638": {"epss_score": 0.0039, "epss_percentile": 0.59537}, "CVE-2013-3639": {"epss_score": 0.06262, "epss_percentile": 0.90622}, "CVE-2013-3640": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-3641": {"epss_score": 0.00152, "epss_percentile": 0.364}, "CVE-2013-3642": {"epss_score": 0.00257, "epss_percentile": 0.48947}, "CVE-2013-3643": {"epss_score": 0.00257, "epss_percentile": 0.48947}, "CVE-2013-3644": {"epss_score": 0.1165, "epss_percentile": 0.93434}, "CVE-2013-3645": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-3646": {"epss_score": 0.00599, "epss_percentile": 0.688}, "CVE-2013-3647": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2013-3648": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-3649": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-3650": {"epss_score": 0.0032, "epss_percentile": 0.54581}, "CVE-2013-3651": {"epss_score": 0.08897, "epss_percentile": 0.92305}, "CVE-2013-3652": {"epss_score": 0.00388, "epss_percentile": 0.59339}, "CVE-2013-3653": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2013-3654": {"epss_score": 0.0032, "epss_percentile": 0.54581}, "CVE-2013-3655": {"epss_score": 0.01056, "epss_percentile": 0.77125}, "CVE-2013-3656": {"epss_score": 0.00256, "epss_percentile": 0.48834}, "CVE-2013-3657": {"epss_score": 0.01263, "epss_percentile": 0.78987}, "CVE-2013-3658": {"epss_score": 0.00584, "epss_percentile": 0.68384}, "CVE-2013-3659": {"epss_score": 0.00199, "epss_percentile": 0.42175}, "CVE-2013-3660": {"epss_score": 0.69191, "epss_percentile": 0.98581}, "CVE-2013-3661": {"epss_score": 0.01762, "epss_percentile": 0.82154}, "CVE-2013-3662": {"epss_score": 0.15912, "epss_percentile": 0.9453}, "CVE-2013-3663": {"epss_score": 0.15912, "epss_percentile": 0.9453}, "CVE-2013-3664": {"epss_score": 0.18974, "epss_percentile": 0.95104}, "CVE-2013-3665": {"epss_score": 0.01097, "epss_percentile": 0.7753}, "CVE-2013-3666": {"epss_score": 0.00078, "epss_percentile": 0.23791}, "CVE-2013-3667": {"epss_score": 0.00452, "epss_percentile": 0.63198}, "CVE-2013-3670": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2013-3671": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2013-3672": {"epss_score": 0.00875, "epss_percentile": 0.74781}, "CVE-2013-3673": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2013-3674": {"epss_score": 0.01113, "epss_percentile": 0.77687}, "CVE-2013-3675": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2013-3678": {"epss_score": 0.02173, "epss_percentile": 0.83875}, "CVE-2013-3684": {"epss_score": 0.4263, "epss_percentile": 0.97344}, "CVE-2013-3685": {"epss_score": 0.00078, "epss_percentile": 0.23554}, "CVE-2013-3686": {"epss_score": 0.39574, "epss_percentile": 0.97168}, "CVE-2013-3687": {"epss_score": 0.10723, "epss_percentile": 0.93083}, "CVE-2013-3688": {"epss_score": 0.00625, "epss_percentile": 0.69597}, "CVE-2013-3689": {"epss_score": 0.00319, "epss_percentile": 0.54549}, "CVE-2013-3690": {"epss_score": 0.01389, "epss_percentile": 0.79931}, "CVE-2013-3691": {"epss_score": 0.1441, "epss_percentile": 0.94206}, "CVE-2013-3692": {"epss_score": 0.00038, "epss_percentile": 0.1118}, "CVE-2013-3693": {"epss_score": 0.00268, "epss_percentile": 0.50044}, "CVE-2013-3694": {"epss_score": 0.0012, "epss_percentile": 0.31695}, "CVE-2013-3697": {"epss_score": 0.00024, "epss_percentile": 0.05847}, "CVE-2013-3703": {"epss_score": 0.00283, "epss_percentile": 0.51391}, "CVE-2013-3704": {"epss_score": 0.00641, "epss_percentile": 0.70012}, "CVE-2013-3705": {"epss_score": 0.00037, "epss_percentile": 0.10646}, "CVE-2013-3706": {"epss_score": 0.4755, "epss_percentile": 0.97592}, "CVE-2013-3707": {"epss_score": 0.02972, "epss_percentile": 0.86096}, "CVE-2013-3708": {"epss_score": 0.05651, "epss_percentile": 0.90085}, "CVE-2013-3709": {"epss_score": 0.00029, "epss_percentile": 0.077}, "CVE-2013-3710": {"epss_score": 0.01415, "epss_percentile": 0.80138}, "CVE-2013-3712": {"epss_score": 0.00332, "epss_percentile": 0.55595}, "CVE-2013-3713": {"epss_score": 0.00052, "epss_percentile": 0.16352}, "CVE-2013-3718": {"epss_score": 0.00518, "epss_percentile": 0.66105}, "CVE-2013-3719": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2013-3720": {"epss_score": 0.00333, "epss_percentile": 0.55668}, "CVE-2013-3721": {"epss_score": 0.00438, "epss_percentile": 0.62561}, "CVE-2013-3722": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2013-3724": {"epss_score": 0.08867, "epss_percentile": 0.92293}, "CVE-2013-3725": {"epss_score": 0.00884, "epss_percentile": 0.74923}, "CVE-2013-3727": {"epss_score": 0.02169, "epss_percentile": 0.83866}, "CVE-2013-3728": {"epss_score": 0.00918, "epss_percentile": 0.75436}, "CVE-2013-3729": {"epss_score": 0.03457, "epss_percentile": 0.87175}, "CVE-2013-3734": {"epss_score": 0.00779, "epss_percentile": 0.73141}, "CVE-2013-3735": {"epss_score": 0.00684, "epss_percentile": 0.71128}, "CVE-2013-3736": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2013-3737": {"epss_score": 0.00348, "epss_percentile": 0.56802}, "CVE-2013-3738": {"epss_score": 0.02855, "epss_percentile": 0.85839}, "CVE-2013-3739": {"epss_score": 0.08087, "epss_percentile": 0.91874}, "CVE-2013-3742": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-3743": {"epss_score": 0.07303, "epss_percentile": 0.91393}, "CVE-2013-3744": {"epss_score": 0.05795, "epss_percentile": 0.90216}, "CVE-2013-3745": {"epss_score": 0.00051, "epss_percentile": 0.16155}, "CVE-2013-3746": {"epss_score": 0.00201, "epss_percentile": 0.42281}, "CVE-2013-3747": {"epss_score": 0.00191, "epss_percentile": 0.41182}, "CVE-2013-3748": {"epss_score": 0.00836, "epss_percentile": 0.74128}, "CVE-2013-3749": {"epss_score": 0.00748, "epss_percentile": 0.72588}, "CVE-2013-3750": {"epss_score": 0.00043, "epss_percentile": 0.13237}, "CVE-2013-3751": {"epss_score": 0.04884, "epss_percentile": 0.89252}, "CVE-2013-3752": {"epss_score": 0.00377, "epss_percentile": 0.58711}, "CVE-2013-3753": {"epss_score": 0.00836, "epss_percentile": 0.74128}, "CVE-2013-3754": {"epss_score": 0.00227, "epss_percentile": 0.45438}, "CVE-2013-3755": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2013-3756": {"epss_score": 0.00441, "epss_percentile": 0.62662}, "CVE-2013-3757": {"epss_score": 0.00959, "epss_percentile": 0.75958}, "CVE-2013-3758": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2013-3759": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2013-3760": {"epss_score": 0.00113, "epss_percentile": 0.30617}, "CVE-2013-3761": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2013-3762": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-3763": {"epss_score": 0.7218, "epss_percentile": 0.98698}, "CVE-2013-3764": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2013-3765": {"epss_score": 0.0014, "epss_percentile": 0.34705}, "CVE-2013-3766": {"epss_score": 0.00188, "epss_percentile": 0.40893}, "CVE-2013-3767": {"epss_score": 0.0061, "epss_percentile": 0.69142}, "CVE-2013-3768": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2013-3769": {"epss_score": 0.00483, "epss_percentile": 0.64592}, "CVE-2013-3770": {"epss_score": 0.00254, "epss_percentile": 0.48546}, "CVE-2013-3771": {"epss_score": 0.00135, "epss_percentile": 0.33991}, "CVE-2013-3772": {"epss_score": 0.00483, "epss_percentile": 0.64592}, "CVE-2013-3773": {"epss_score": 0.00719, "epss_percentile": 0.71945}, "CVE-2013-3774": {"epss_score": 0.0404, "epss_percentile": 0.88165}, "CVE-2013-3775": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2013-3776": {"epss_score": 0.00988, "epss_percentile": 0.76357}, "CVE-2013-3777": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2013-3778": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2013-3779": {"epss_score": 0.00662, "epss_percentile": 0.70605}, "CVE-2013-3780": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2013-3781": {"epss_score": 0.00743, "epss_percentile": 0.725}, "CVE-2013-3782": {"epss_score": 0.00483, "epss_percentile": 0.64592}, "CVE-2013-3783": {"epss_score": 0.00543, "epss_percentile": 0.671}, "CVE-2013-3784": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2013-3785": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-3786": {"epss_score": 0.00133, "epss_percentile": 0.3368}, "CVE-2013-3787": {"epss_score": 0.00734, "epss_percentile": 0.72253}, "CVE-2013-3788": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2013-3789": {"epss_score": 0.00729, "epss_percentile": 0.7212}, "CVE-2013-3790": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2013-3791": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2013-3792": {"epss_score": 0.00169, "epss_percentile": 0.3854}, "CVE-2013-3793": {"epss_score": 0.0057, "epss_percentile": 0.67943}, "CVE-2013-3794": {"epss_score": 0.00694, "epss_percentile": 0.71348}, "CVE-2013-3795": {"epss_score": 0.00854, "epss_percentile": 0.7445}, "CVE-2013-3796": {"epss_score": 0.00854, "epss_percentile": 0.7445}, "CVE-2013-3797": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2013-3798": {"epss_score": 0.00539, "epss_percentile": 0.66967}, "CVE-2013-3799": {"epss_score": 0.00066, "epss_percentile": 0.20887}, "CVE-2013-3800": {"epss_score": 0.00442, "epss_percentile": 0.62721}, "CVE-2013-3801": {"epss_score": 0.00841, "epss_percentile": 0.74219}, "CVE-2013-3802": {"epss_score": 0.00502, "epss_percentile": 0.65378}, "CVE-2013-3803": {"epss_score": 0.20369, "epss_percentile": 0.95334}, "CVE-2013-3804": {"epss_score": 0.0057, "epss_percentile": 0.67943}, "CVE-2013-3805": {"epss_score": 0.00868, "epss_percentile": 0.74665}, "CVE-2013-3806": {"epss_score": 0.00854, "epss_percentile": 0.7445}, "CVE-2013-3807": {"epss_score": 0.00443, "epss_percentile": 0.62794}, "CVE-2013-3808": {"epss_score": 0.00575, "epss_percentile": 0.68118}, "CVE-2013-3809": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2013-3810": {"epss_score": 0.00442, "epss_percentile": 0.62711}, "CVE-2013-3811": {"epss_score": 0.00442, "epss_percentile": 0.62711}, "CVE-2013-3812": {"epss_score": 0.00374, "epss_percentile": 0.58556}, "CVE-2013-3813": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2013-3814": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2013-3816": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2013-3818": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2013-3819": {"epss_score": 0.00719, "epss_percentile": 0.71945}, "CVE-2013-3820": {"epss_score": 0.00719, "epss_percentile": 0.71945}, "CVE-2013-3821": {"epss_score": 0.01373, "epss_percentile": 0.79821}, "CVE-2013-3822": {"epss_score": 0.00483, "epss_percentile": 0.64592}, "CVE-2013-3823": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2013-3824": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2013-3825": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2013-3826": {"epss_score": 0.00362, "epss_percentile": 0.57786}, "CVE-2013-3827": {"epss_score": 0.91635, "epss_percentile": 0.99659}, "CVE-2013-3828": {"epss_score": 0.00295, "epss_percentile": 0.5251}, "CVE-2013-3829": {"epss_score": 0.02075, "epss_percentile": 0.83505}, "CVE-2013-3830": {"epss_score": 0.00898, "epss_percentile": 0.75141}, "CVE-2013-3831": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2013-3832": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-3833": {"epss_score": 0.00308, "epss_percentile": 0.53636}, "CVE-2013-3834": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2013-3835": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2013-3836": {"epss_score": 0.00143, "epss_percentile": 0.35149}, "CVE-2013-3837": {"epss_score": 0.0066, "epss_percentile": 0.70526}, "CVE-2013-3838": {"epss_score": 0.00077, "epss_percentile": 0.23357}, "CVE-2013-3839": {"epss_score": 0.00461, "epss_percentile": 0.63561}, "CVE-2013-3840": {"epss_score": 0.00194, "epss_percentile": 0.4156}, "CVE-2013-3841": {"epss_score": 0.00295, "epss_percentile": 0.5251}, "CVE-2013-3842": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2013-3843": {"epss_score": 0.4015, "epss_percentile": 0.972}, "CVE-2013-3845": {"epss_score": 0.31113, "epss_percentile": 0.96595}, "CVE-2013-3846": {"epss_score": 0.53954, "epss_percentile": 0.97904}, "CVE-2013-3847": {"epss_score": 0.66894, "epss_percentile": 0.98485}, "CVE-2013-3848": {"epss_score": 0.63582, "epss_percentile": 0.98339}, "CVE-2013-3849": {"epss_score": 0.63582, "epss_percentile": 0.98339}, "CVE-2013-3850": {"epss_score": 0.53657, "epss_percentile": 0.9789}, "CVE-2013-3851": {"epss_score": 0.53657, "epss_percentile": 0.9789}, "CVE-2013-3852": {"epss_score": 0.53657, "epss_percentile": 0.9789}, "CVE-2013-3853": {"epss_score": 0.53657, "epss_percentile": 0.9789}, "CVE-2013-3854": {"epss_score": 0.53657, "epss_percentile": 0.9789}, "CVE-2013-3855": {"epss_score": 0.53657, "epss_percentile": 0.9789}, "CVE-2013-3856": {"epss_score": 0.53657, "epss_percentile": 0.9789}, "CVE-2013-3857": {"epss_score": 0.63582, "epss_percentile": 0.98339}, "CVE-2013-3858": {"epss_score": 0.63582, "epss_percentile": 0.98339}, "CVE-2013-3859": {"epss_score": 0.00461, "epss_percentile": 0.63562}, "CVE-2013-3860": {"epss_score": 0.63818, "epss_percentile": 0.9835}, "CVE-2013-3861": {"epss_score": 0.77062, "epss_percentile": 0.98919}, "CVE-2013-3862": {"epss_score": 0.00461, "epss_percentile": 0.63562}, "CVE-2013-3863": {"epss_score": 0.52223, "epss_percentile": 0.97814}, "CVE-2013-3864": {"epss_score": 0.00954, "epss_percentile": 0.75908}, "CVE-2013-3865": {"epss_score": 0.00954, "epss_percentile": 0.75908}, "CVE-2013-3866": {"epss_score": 0.0067, "epss_percentile": 0.70787}, "CVE-2013-3868": {"epss_score": 0.47113, "epss_percentile": 0.9757}, "CVE-2013-3869": {"epss_score": 0.09519, "epss_percentile": 0.92583}, "CVE-2013-3870": {"epss_score": 0.36716, "epss_percentile": 0.96998}, "CVE-2013-3871": {"epss_score": 0.25772, "epss_percentile": 0.96068}, "CVE-2013-3872": {"epss_score": 0.20201, "epss_percentile": 0.95302}, "CVE-2013-3873": {"epss_score": 0.24625, "epss_percentile": 0.95942}, "CVE-2013-3874": {"epss_score": 0.24625, "epss_percentile": 0.95942}, "CVE-2013-3875": {"epss_score": 0.22259, "epss_percentile": 0.95616}, "CVE-2013-3876": {"epss_score": 0.0201, "epss_percentile": 0.83246}, "CVE-2013-3878": {"epss_score": 0.01157, "epss_percentile": 0.78109}, "CVE-2013-3879": {"epss_score": 0.005, "epss_percentile": 0.65299}, "CVE-2013-3880": {"epss_score": 0.20319, "epss_percentile": 0.95325}, "CVE-2013-3881": {"epss_score": 0.16159, "epss_percentile": 0.94581}, "CVE-2013-3882": {"epss_score": 0.22259, "epss_percentile": 0.95616}, "CVE-2013-3885": {"epss_score": 0.22259, "epss_percentile": 0.95616}, "CVE-2013-3886": {"epss_score": 0.22259, "epss_percentile": 0.95616}, "CVE-2013-3887": {"epss_score": 0.00468, "epss_percentile": 0.63874}, "CVE-2013-3888": {"epss_score": 0.00559, "epss_percentile": 0.67611}, "CVE-2013-3889": {"epss_score": 0.64993, "epss_percentile": 0.984}, "CVE-2013-3890": {"epss_score": 0.53228, "epss_percentile": 0.97867}, "CVE-2013-3891": {"epss_score": 0.53228, "epss_percentile": 0.97867}, "CVE-2013-3892": {"epss_score": 0.53228, "epss_percentile": 0.97867}, "CVE-2013-3893": {"epss_score": 0.81212, "epss_percentile": 0.99128}, "CVE-2013-3894": {"epss_score": 0.27036, "epss_percentile": 0.96199}, "CVE-2013-3895": {"epss_score": 0.20751, "epss_percentile": 0.95407}, "CVE-2013-3896": {"epss_score": 0.8159, "epss_percentile": 0.99146}, "CVE-2013-3897": {"epss_score": 0.90548, "epss_percentile": 0.99589}, "CVE-2013-3898": {"epss_score": 0.00252, "epss_percentile": 0.48363}, "CVE-2013-3899": {"epss_score": 0.00491, "epss_percentile": 0.64952}, "CVE-2013-3900": {"epss_score": 0.80228, "epss_percentile": 0.99078}, "CVE-2013-3902": {"epss_score": 0.00363, "epss_percentile": 0.57867}, "CVE-2013-3903": {"epss_score": 0.00987, "epss_percentile": 0.7634}, "CVE-2013-3905": {"epss_score": 0.14651, "epss_percentile": 0.94257}, "CVE-2013-3906": {"epss_score": 0.92546, "epss_percentile": 0.99725}, "CVE-2013-3907": {"epss_score": 0.01105, "epss_percentile": 0.77608}, "CVE-2013-3908": {"epss_score": 0.47188, "epss_percentile": 0.97573}, "CVE-2013-3909": {"epss_score": 0.22494, "epss_percentile": 0.95644}, "CVE-2013-3910": {"epss_score": 0.27206, "epss_percentile": 0.96219}, "CVE-2013-3911": {"epss_score": 0.20253, "epss_percentile": 0.95309}, "CVE-2013-3912": {"epss_score": 0.20253, "epss_percentile": 0.95309}, "CVE-2013-3914": {"epss_score": 0.27919, "epss_percentile": 0.96295}, "CVE-2013-3915": {"epss_score": 0.27919, "epss_percentile": 0.96295}, "CVE-2013-3916": {"epss_score": 0.31141, "epss_percentile": 0.96597}, "CVE-2013-3917": {"epss_score": 0.31141, "epss_percentile": 0.96597}, "CVE-2013-3918": {"epss_score": 0.87059, "epss_percentile": 0.99412}, "CVE-2013-3919": {"epss_score": 0.07665, "epss_percentile": 0.9161}, "CVE-2013-3920": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2013-3921": {"epss_score": 0.00115, "epss_percentile": 0.30939}, "CVE-2013-3922": {"epss_score": 0.00235, "epss_percentile": 0.46332}, "CVE-2013-3923": {"epss_score": 0.00115, "epss_percentile": 0.30939}, "CVE-2013-3925": {"epss_score": 0.00346, "epss_percentile": 0.56604}, "CVE-2013-3926": {"epss_score": 0.01027, "epss_percentile": 0.7681}, "CVE-2013-3927": {"epss_score": 0.00054, "epss_percentile": 0.17077}, "CVE-2013-3928": {"epss_score": 0.76868, "epss_percentile": 0.9891}, "CVE-2013-3929": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-3930": {"epss_score": 0.02013, "epss_percentile": 0.83256}, "CVE-2013-3931": {"epss_score": 0.00264, "epss_percentile": 0.49723}, "CVE-2013-3932": {"epss_score": 0.01341, "epss_percentile": 0.79591}, "CVE-2013-3933": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-3934": {"epss_score": 0.43565, "epss_percentile": 0.97391}, "CVE-2013-3935": {"epss_score": 0.0013, "epss_percentile": 0.33328}, "CVE-2013-3936": {"epss_score": 0.00278, "epss_percentile": 0.50862}, "CVE-2013-3937": {"epss_score": 0.01155, "epss_percentile": 0.78071}, "CVE-2013-3938": {"epss_score": 0.09951, "epss_percentile": 0.92787}, "CVE-2013-3939": {"epss_score": 0.01006, "epss_percentile": 0.76556}, "CVE-2013-3940": {"epss_score": 0.71777, "epss_percentile": 0.9868}, "CVE-2013-3941": {"epss_score": 0.05321, "epss_percentile": 0.89729}, "CVE-2013-3942": {"epss_score": 0.00232, "epss_percentile": 0.45964}, "CVE-2013-3943": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2013-3944": {"epss_score": 0.10833, "epss_percentile": 0.93128}, "CVE-2013-3945": {"epss_score": 0.01788, "epss_percentile": 0.82264}, "CVE-2013-3946": {"epss_score": 0.04922, "epss_percentile": 0.89292}, "CVE-2013-3947": {"epss_score": 0.00053, "epss_percentile": 0.16791}, "CVE-2013-3948": {"epss_score": 0.00389, "epss_percentile": 0.59495}, "CVE-2013-3949": {"epss_score": 0.00048, "epss_percentile": 0.14979}, "CVE-2013-3950": {"epss_score": 0.0084, "epss_percentile": 0.74214}, "CVE-2013-3951": {"epss_score": 0.00061, "epss_percentile": 0.19497}, "CVE-2013-3952": {"epss_score": 0.00133, "epss_percentile": 0.33709}, "CVE-2013-3953": {"epss_score": 0.00146, "epss_percentile": 0.35632}, "CVE-2013-3954": {"epss_score": 0.00111, "epss_percentile": 0.3038}, "CVE-2013-3955": {"epss_score": 0.00182, "epss_percentile": 0.40255}, "CVE-2013-3956": {"epss_score": 0.02153, "epss_percentile": 0.83795}, "CVE-2013-3957": {"epss_score": 0.00337, "epss_percentile": 0.56026}, "CVE-2013-3958": {"epss_score": 0.00423, "epss_percentile": 0.61634}, "CVE-2013-3959": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2013-3960": {"epss_score": 0.00679, "epss_percentile": 0.71006}, "CVE-2013-3961": {"epss_score": 0.04484, "epss_percentile": 0.88747}, "CVE-2013-3962": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-3963": {"epss_score": 0.00365, "epss_percentile": 0.57963}, "CVE-2013-3964": {"epss_score": 0.0027, "epss_percentile": 0.502}, "CVE-2013-3969": {"epss_score": 0.08237, "epss_percentile": 0.91945}, "CVE-2013-3970": {"epss_score": 0.00185, "epss_percentile": 0.40578}, "CVE-2013-3971": {"epss_score": 0.00179, "epss_percentile": 0.398}, "CVE-2013-3972": {"epss_score": 0.00202, "epss_percentile": 0.42412}, "CVE-2013-3973": {"epss_score": 0.00302, "epss_percentile": 0.5309}, "CVE-2013-3975": {"epss_score": 0.51751, "epss_percentile": 0.97796}, "CVE-2013-3976": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2013-3977": {"epss_score": 0.29135, "epss_percentile": 0.9642}, "CVE-2013-3978": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2013-3979": {"epss_score": 0.00208, "epss_percentile": 0.43262}, "CVE-2013-3980": {"epss_score": 0.00572, "epss_percentile": 0.68003}, "CVE-2013-3981": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2013-3982": {"epss_score": 0.37245, "epss_percentile": 0.9703}, "CVE-2013-3983": {"epss_score": 0.0035, "epss_percentile": 0.5698}, "CVE-2013-3984": {"epss_score": 0.0011, "epss_percentile": 0.30208}, "CVE-2013-3985": {"epss_score": 0.0011, "epss_percentile": 0.30208}, "CVE-2013-3986": {"epss_score": 0.39225, "epss_percentile": 0.97146}, "CVE-2013-3988": {"epss_score": 0.00519, "epss_percentile": 0.66168}, "CVE-2013-3989": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2013-3990": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-3992": {"epss_score": 0.0018, "epss_percentile": 0.39978}, "CVE-2013-3993": {"epss_score": 0.16966, "epss_percentile": 0.94755}, "CVE-2013-3995": {"epss_score": 0.00208, "epss_percentile": 0.43262}, "CVE-2013-3996": {"epss_score": 0.00246, "epss_percentile": 0.47761}, "CVE-2013-3997": {"epss_score": 0.0016, "epss_percentile": 0.37441}, "CVE-2013-3998": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-3999": {"epss_score": 0.00289, "epss_percentile": 0.52034}, "CVE-2013-4000": {"epss_score": 0.00103, "epss_percentile": 0.28976}, "CVE-2013-4001": {"epss_score": 0.00185, "epss_percentile": 0.40506}, "CVE-2013-4002": {"epss_score": 0.0164, "epss_percentile": 0.81502}, "CVE-2013-4003": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2013-4004": {"epss_score": 0.00162, "epss_percentile": 0.37634}, "CVE-2013-4005": {"epss_score": 0.00162, "epss_percentile": 0.37634}, "CVE-2013-4006": {"epss_score": 0.00179, "epss_percentile": 0.39809}, "CVE-2013-4007": {"epss_score": 0.00201, "epss_percentile": 0.42333}, "CVE-2013-4011": {"epss_score": 0.08468, "epss_percentile": 0.92068}, "CVE-2013-4012": {"epss_score": 0.0034, "epss_percentile": 0.56234}, "CVE-2013-4013": {"epss_score": 0.00348, "epss_percentile": 0.5683}, "CVE-2013-4014": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2013-4015": {"epss_score": 0.04416, "epss_percentile": 0.88666}, "CVE-2013-4016": {"epss_score": 0.00314, "epss_percentile": 0.54095}, "CVE-2013-4017": {"epss_score": 0.003, "epss_percentile": 0.52976}, "CVE-2013-4018": {"epss_score": 0.0048, "epss_percentile": 0.64471}, "CVE-2013-4019": {"epss_score": 0.00208, "epss_percentile": 0.43262}, "CVE-2013-4020": {"epss_score": 0.002, "epss_percentile": 0.42267}, "CVE-2013-4021": {"epss_score": 0.00513, "epss_percentile": 0.65929}, "CVE-2013-4022": {"epss_score": 0.00135, "epss_percentile": 0.33968}, "CVE-2013-4024": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2013-4025": {"epss_score": 0.00078, "epss_percentile": 0.23556}, "CVE-2013-4027": {"epss_score": 0.00281, "epss_percentile": 0.51143}, "CVE-2013-4030": {"epss_score": 0.00218, "epss_percentile": 0.44413}, "CVE-2013-4031": {"epss_score": 0.02507, "epss_percentile": 0.84939}, "CVE-2013-4032": {"epss_score": 0.00653, "epss_percentile": 0.70324}, "CVE-2013-4033": {"epss_score": 0.00952, "epss_percentile": 0.75881}, "CVE-2013-4034": {"epss_score": 0.0543, "epss_percentile": 0.89875}, "CVE-2013-4035": {"epss_score": 0.00062, "epss_percentile": 0.19693}, "CVE-2013-4036": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-4037": {"epss_score": 0.00218, "epss_percentile": 0.44413}, "CVE-2013-4038": {"epss_score": 0.00212, "epss_percentile": 0.43785}, "CVE-2013-4039": {"epss_score": 0.00381, "epss_percentile": 0.59}, "CVE-2013-4040": {"epss_score": 0.00035, "epss_percentile": 0.09895}, "CVE-2013-4041": {"epss_score": 0.0186, "epss_percentile": 0.82586}, "CVE-2013-4042": {"epss_score": 0.1922, "epss_percentile": 0.9515}, "CVE-2013-4043": {"epss_score": 0.00254, "epss_percentile": 0.48524}, "CVE-2013-4044": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2013-4045": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-4046": {"epss_score": 0.00227, "epss_percentile": 0.45394}, "CVE-2013-4047": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-4048": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-4049": {"epss_score": 0.02554, "epss_percentile": 0.85087}, "CVE-2013-4050": {"epss_score": 0.00093, "epss_percentile": 0.26681}, "CVE-2013-4051": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-4052": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-4053": {"epss_score": 0.00399, "epss_percentile": 0.60134}, "CVE-2013-4054": {"epss_score": 0.00102, "epss_percentile": 0.28814}, "CVE-2013-4055": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-4056": {"epss_score": 0.00103, "epss_percentile": 0.28976}, "CVE-2013-4057": {"epss_score": 0.00211, "epss_percentile": 0.43675}, "CVE-2013-4058": {"epss_score": 0.00501, "epss_percentile": 0.65331}, "CVE-2013-4059": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2013-4061": {"epss_score": 0.00143, "epss_percentile": 0.35197}, "CVE-2013-4062": {"epss_score": 0.00159, "epss_percentile": 0.37367}, "CVE-2013-4063": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-4064": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-4065": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-4066": {"epss_score": 0.00227, "epss_percentile": 0.45394}, "CVE-2013-4067": {"epss_score": 0.00246, "epss_percentile": 0.47798}, "CVE-2013-4068": {"epss_score": 0.08997, "epss_percentile": 0.92357}, "CVE-2013-4069": {"epss_score": 0.00331, "epss_percentile": 0.55529}, "CVE-2013-4070": {"epss_score": 0.00254, "epss_percentile": 0.48524}, "CVE-2013-4073": {"epss_score": 0.02664, "epss_percentile": 0.85374}, "CVE-2013-4074": {"epss_score": 0.33476, "epss_percentile": 0.96776}, "CVE-2013-4075": {"epss_score": 0.00566, "epss_percentile": 0.67822}, "CVE-2013-4076": {"epss_score": 0.01047, "epss_percentile": 0.77038}, "CVE-2013-4077": {"epss_score": 0.01061, "epss_percentile": 0.77173}, "CVE-2013-4078": {"epss_score": 0.01429, "epss_percentile": 0.80227}, "CVE-2013-4079": {"epss_score": 0.00836, "epss_percentile": 0.74134}, "CVE-2013-4080": {"epss_score": 0.00836, "epss_percentile": 0.74134}, "CVE-2013-4081": {"epss_score": 0.01262, "epss_percentile": 0.78983}, "CVE-2013-4082": {"epss_score": 0.01535, "epss_percentile": 0.80908}, "CVE-2013-4083": {"epss_score": 0.00583, "epss_percentile": 0.68337}, "CVE-2013-4088": {"epss_score": 0.01928, "epss_percentile": 0.82929}, "CVE-2013-4090": {"epss_score": 0.00351, "epss_percentile": 0.57031}, "CVE-2013-4091": {"epss_score": 0.03489, "epss_percentile": 0.87228}, "CVE-2013-4092": {"epss_score": 0.05995, "epss_percentile": 0.9039}, "CVE-2013-4093": {"epss_score": 0.05043, "epss_percentile": 0.89429}, "CVE-2013-4094": {"epss_score": 0.0286, "epss_percentile": 0.85848}, "CVE-2013-4095": {"epss_score": 0.0373, "epss_percentile": 0.87643}, "CVE-2013-4096": {"epss_score": 0.03932, "epss_percentile": 0.87976}, "CVE-2013-4097": {"epss_score": 0.05304, "epss_percentile": 0.8971}, "CVE-2013-4098": {"epss_score": 0.04879, "epss_percentile": 0.89243}, "CVE-2013-4099": {"epss_score": 0.01256, "epss_percentile": 0.78934}, "CVE-2013-4100": {"epss_score": 0.01129, "epss_percentile": 0.7784}, "CVE-2013-4101": {"epss_score": 0.00412, "epss_percentile": 0.60916}, "CVE-2013-4102": {"epss_score": 0.0044, "epss_percentile": 0.62617}, "CVE-2013-4103": {"epss_score": 0.07142, "epss_percentile": 0.9128}, "CVE-2013-4104": {"epss_score": 0.00139, "epss_percentile": 0.34583}, "CVE-2013-4105": {"epss_score": 0.00252, "epss_percentile": 0.48377}, "CVE-2013-4106": {"epss_score": 0.00795, "epss_percentile": 0.73476}, "CVE-2013-4107": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2013-4108": {"epss_score": 0.0064, "epss_percentile": 0.69964}, "CVE-2013-4109": {"epss_score": 0.008, "epss_percentile": 0.73546}, "CVE-2013-4110": {"epss_score": 0.00552, "epss_percentile": 0.67396}, "CVE-2013-4111": {"epss_score": 0.00285, "epss_percentile": 0.51552}, "CVE-2013-4112": {"epss_score": 0.00622, "epss_percentile": 0.695}, "CVE-2013-4113": {"epss_score": 0.19022, "epss_percentile": 0.95112}, "CVE-2013-4114": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2013-4115": {"epss_score": 0.75061, "epss_percentile": 0.9883}, "CVE-2013-4116": {"epss_score": 0.00104, "epss_percentile": 0.29132}, "CVE-2013-4117": {"epss_score": 0.11755, "epss_percentile": 0.93465}, "CVE-2013-4118": {"epss_score": 0.01902, "epss_percentile": 0.82784}, "CVE-2013-4119": {"epss_score": 0.01144, "epss_percentile": 0.77987}, "CVE-2013-4120": {"epss_score": 0.00551, "epss_percentile": 0.67372}, "CVE-2013-4122": {"epss_score": 0.01179, "epss_percentile": 0.78292}, "CVE-2013-4123": {"epss_score": 0.74312, "epss_percentile": 0.98795}, "CVE-2013-4124": {"epss_score": 0.86808, "epss_percentile": 0.99398}, "CVE-2013-4125": {"epss_score": 0.01428, "epss_percentile": 0.80222}, "CVE-2013-4127": {"epss_score": 0.00044, "epss_percentile": 0.13669}, "CVE-2013-4128": {"epss_score": 0.00688, "epss_percentile": 0.71209}, "CVE-2013-4129": {"epss_score": 0.00046, "epss_percentile": 0.14297}, "CVE-2013-4130": {"epss_score": 0.01102, "epss_percentile": 0.77582}, "CVE-2013-4131": {"epss_score": 0.00902, "epss_percentile": 0.75188}, "CVE-2013-4132": {"epss_score": 0.00832, "epss_percentile": 0.74075}, "CVE-2013-4133": {"epss_score": 0.01993, "epss_percentile": 0.83184}, "CVE-2013-4134": {"epss_score": 0.00152, "epss_percentile": 0.36421}, "CVE-2013-4135": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2013-4136": {"epss_score": 0.00044, "epss_percentile": 0.13498}, "CVE-2013-4137": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2013-4138": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2013-4139": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2013-4140": {"epss_score": 0.00354, "epss_percentile": 0.57245}, "CVE-2013-4143": {"epss_score": 0.00062, "epss_percentile": 0.19667}, "CVE-2013-4144": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2013-4147": {"epss_score": 0.10566, "epss_percentile": 0.93029}, "CVE-2013-4148": {"epss_score": 0.03127, "epss_percentile": 0.86457}, "CVE-2013-4149": {"epss_score": 0.04083, "epss_percentile": 0.88223}, "CVE-2013-4150": {"epss_score": 0.02456, "epss_percentile": 0.848}, "CVE-2013-4151": {"epss_score": 0.01385, "epss_percentile": 0.79907}, "CVE-2013-4152": {"epss_score": 0.89008, "epss_percentile": 0.99505}, "CVE-2013-4153": {"epss_score": 0.00642, "epss_percentile": 0.70026}, "CVE-2013-4154": {"epss_score": 0.00731, "epss_percentile": 0.72164}, "CVE-2013-4155": {"epss_score": 0.01015, "epss_percentile": 0.76669}, "CVE-2013-4156": {"epss_score": 0.01221, "epss_percentile": 0.78649}, "CVE-2013-4157": {"epss_score": 0.00032, "epss_percentile": 0.08853}, "CVE-2013-4158": {"epss_score": 0.00631, "epss_percentile": 0.69722}, "CVE-2013-4159": {"epss_score": 0.00624, "epss_percentile": 0.69562}, "CVE-2013-4160": {"epss_score": 0.01102, "epss_percentile": 0.77582}, "CVE-2013-4161": {"epss_score": 0.00051, "epss_percentile": 0.16062}, "CVE-2013-4162": {"epss_score": 0.00109, "epss_percentile": 0.2999}, "CVE-2013-4163": {"epss_score": 0.00087, "epss_percentile": 0.25605}, "CVE-2013-4164": {"epss_score": 0.11281, "epss_percentile": 0.9329}, "CVE-2013-4165": {"epss_score": 0.00153, "epss_percentile": 0.36627}, "CVE-2013-4166": {"epss_score": 0.01005, "epss_percentile": 0.76535}, "CVE-2013-4167": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-4168": {"epss_score": 0.00579, "epss_percentile": 0.68229}, "CVE-2013-4169": {"epss_score": 0.00026, "epss_percentile": 0.06681}, "CVE-2013-4170": {"epss_score": 0.00336, "epss_percentile": 0.55914}, "CVE-2013-4171": {"epss_score": 0.02006, "epss_percentile": 0.83232}, "CVE-2013-4172": {"epss_score": 0.00673, "epss_percentile": 0.7083}, "CVE-2013-4173": {"epss_score": 0.0071, "epss_percentile": 0.71703}, "CVE-2013-4174": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2013-4175": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2013-4176": {"epss_score": 0.00061, "epss_percentile": 0.19469}, "CVE-2013-4177": {"epss_score": 0.01352, "epss_percentile": 0.79687}, "CVE-2013-4178": {"epss_score": 0.00294, "epss_percentile": 0.52356}, "CVE-2013-4179": {"epss_score": 0.00669, "epss_percentile": 0.70767}, "CVE-2013-4180": {"epss_score": 0.00935, "epss_percentile": 0.7567}, "CVE-2013-4181": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-4182": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2013-4183": {"epss_score": 0.00156, "epss_percentile": 0.36911}, "CVE-2013-4184": {"epss_score": 0.00038, "epss_percentile": 0.11078}, "CVE-2013-4185": {"epss_score": 0.00583, "epss_percentile": 0.68332}, "CVE-2013-4187": {"epss_score": 0.0068, "epss_percentile": 0.71027}, "CVE-2013-4188": {"epss_score": 0.00564, "epss_percentile": 0.67768}, "CVE-2013-4189": {"epss_score": 0.00498, "epss_percentile": 0.65242}, "CVE-2013-4190": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2013-4191": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2013-4192": {"epss_score": 0.00218, "epss_percentile": 0.44394}, "CVE-2013-4193": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2013-4194": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2013-4195": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-4196": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2013-4197": {"epss_score": 0.00498, "epss_percentile": 0.65242}, "CVE-2013-4198": {"epss_score": 0.00305, "epss_percentile": 0.53385}, "CVE-2013-4199": {"epss_score": 0.0048, "epss_percentile": 0.64473}, "CVE-2013-4200": {"epss_score": 0.05302, "epss_percentile": 0.89708}, "CVE-2013-4201": {"epss_score": 0.0012, "epss_percentile": 0.31773}, "CVE-2013-4202": {"epss_score": 0.00841, "epss_percentile": 0.74227}, "CVE-2013-4203": {"epss_score": 0.01422, "epss_percentile": 0.80176}, "CVE-2013-4204": {"epss_score": 0.00333, "epss_percentile": 0.55619}, "CVE-2013-4205": {"epss_score": 0.00097, "epss_percentile": 0.27617}, "CVE-2013-4206": {"epss_score": 0.01136, "epss_percentile": 0.7792}, "CVE-2013-4207": {"epss_score": 0.00579, "epss_percentile": 0.68224}, "CVE-2013-4208": {"epss_score": 0.00063, "epss_percentile": 0.19859}, "CVE-2013-4209": {"epss_score": 0.0004, "epss_percentile": 0.12114}, "CVE-2013-4210": {"epss_score": 0.01274, "epss_percentile": 0.79099}, "CVE-2013-4211": {"epss_score": 0.88604, "epss_percentile": 0.9948}, "CVE-2013-4212": {"epss_score": 0.87107, "epss_percentile": 0.99416}, "CVE-2013-4213": {"epss_score": 0.00587, "epss_percentile": 0.68482}, "CVE-2013-4214": {"epss_score": 0.00047, "epss_percentile": 0.14698}, "CVE-2013-4215": {"epss_score": 0.00087, "epss_percentile": 0.2563}, "CVE-2013-4216": {"epss_score": 0.0004, "epss_percentile": 0.12084}, "CVE-2013-4217": {"epss_score": 0.00051, "epss_percentile": 0.16305}, "CVE-2013-4218": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2013-4219": {"epss_score": 0.01602, "epss_percentile": 0.81274}, "CVE-2013-4220": {"epss_score": 0.00047, "epss_percentile": 0.14774}, "CVE-2013-4221": {"epss_score": 0.01452, "epss_percentile": 0.80369}, "CVE-2013-4222": {"epss_score": 0.0058, "epss_percentile": 0.68245}, "CVE-2013-4223": {"epss_score": 0.00433, "epss_percentile": 0.62208}, "CVE-2013-4225": {"epss_score": 0.00547, "epss_percentile": 0.67251}, "CVE-2013-4226": {"epss_score": 0.00235, "epss_percentile": 0.4623}, "CVE-2013-4227": {"epss_score": 0.00204, "epss_percentile": 0.42652}, "CVE-2013-4228": {"epss_score": 0.00234, "epss_percentile": 0.46107}, "CVE-2013-4229": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2013-4230": {"epss_score": 0.00764, "epss_percentile": 0.72899}, "CVE-2013-4231": {"epss_score": 0.18385, "epss_percentile": 0.95008}, "CVE-2013-4232": {"epss_score": 0.01331, "epss_percentile": 0.79516}, "CVE-2013-4233": {"epss_score": 0.03846, "epss_percentile": 0.87842}, "CVE-2013-4234": {"epss_score": 0.03086, "epss_percentile": 0.86385}, "CVE-2013-4235": {"epss_score": 0.00066, "epss_percentile": 0.20887}, "CVE-2013-4236": {"epss_score": 0.00096, "epss_percentile": 0.2737}, "CVE-2013-4237": {"epss_score": 0.01422, "epss_percentile": 0.80187}, "CVE-2013-4238": {"epss_score": 0.04274, "epss_percentile": 0.88481}, "CVE-2013-4239": {"epss_score": 0.0058, "epss_percentile": 0.68253}, "CVE-2013-4240": {"epss_score": 0.00825, "epss_percentile": 0.73951}, "CVE-2013-4241": {"epss_score": 0.00525, "epss_percentile": 0.66383}, "CVE-2013-4242": {"epss_score": 0.00157, "epss_percentile": 0.37095}, "CVE-2013-4243": {"epss_score": 0.18712, "epss_percentile": 0.95057}, "CVE-2013-4244": {"epss_score": 0.00646, "epss_percentile": 0.70131}, "CVE-2013-4245": {"epss_score": 0.00153, "epss_percentile": 0.36617}, "CVE-2013-4246": {"epss_score": 0.00387, "epss_percentile": 0.59336}, "CVE-2013-4247": {"epss_score": 0.01234, "epss_percentile": 0.78752}, "CVE-2013-4248": {"epss_score": 0.09892, "epss_percentile": 0.92756}, "CVE-2013-4249": {"epss_score": 0.00313, "epss_percentile": 0.54029}, "CVE-2013-4250": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2013-4251": {"epss_score": 0.00086, "epss_percentile": 0.25347}, "CVE-2013-4253": {"epss_score": 0.00231, "epss_percentile": 0.4583}, "CVE-2013-4254": {"epss_score": 0.00057, "epss_percentile": 0.1804}, "CVE-2013-4255": {"epss_score": 0.00707, "epss_percentile": 0.71661}, "CVE-2013-4256": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2013-4258": {"epss_score": 0.01226, "epss_percentile": 0.78691}, "CVE-2013-4259": {"epss_score": 0.00051, "epss_percentile": 0.16071}, "CVE-2013-4260": {"epss_score": 0.00082, "epss_percentile": 0.24568}, "CVE-2013-4261": {"epss_score": 0.00596, "epss_percentile": 0.6872}, "CVE-2013-4262": {"epss_score": 0.00261, "epss_percentile": 0.49278}, "CVE-2013-4263": {"epss_score": 0.00377, "epss_percentile": 0.58702}, "CVE-2013-4264": {"epss_score": 0.00844, "epss_percentile": 0.74279}, "CVE-2013-4265": {"epss_score": 0.00399, "epss_percentile": 0.60113}, "CVE-2013-4267": {"epss_score": 0.07064, "epss_percentile": 0.91222}, "CVE-2013-4270": {"epss_score": 0.00044, "epss_percentile": 0.13399}, "CVE-2013-4271": {"epss_score": 0.00497, "epss_percentile": 0.6518}, "CVE-2013-4272": {"epss_score": 0.00375, "epss_percentile": 0.58608}, "CVE-2013-4273": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2013-4274": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2013-4275": {"epss_score": 0.00407, "epss_percentile": 0.60618}, "CVE-2013-4276": {"epss_score": 0.02338, "epss_percentile": 0.84425}, "CVE-2013-4277": {"epss_score": 0.00208, "epss_percentile": 0.4325}, "CVE-2013-4278": {"epss_score": 0.00201, "epss_percentile": 0.42358}, "CVE-2013-4279": {"epss_score": 0.00422, "epss_percentile": 0.61539}, "CVE-2013-4280": {"epss_score": 0.00133, "epss_percentile": 0.33628}, "CVE-2013-4281": {"epss_score": 0.00033, "epss_percentile": 0.09328}, "CVE-2013-4282": {"epss_score": 0.01509, "epss_percentile": 0.80767}, "CVE-2013-4283": {"epss_score": 0.00755, "epss_percentile": 0.72718}, "CVE-2013-4284": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2013-4285": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2013-4286": {"epss_score": 0.26065, "epss_percentile": 0.96107}, "CVE-2013-4287": {"epss_score": 0.02017, "epss_percentile": 0.83278}, "CVE-2013-4288": {"epss_score": 0.00033, "epss_percentile": 0.0917}, "CVE-2013-4289": {"epss_score": 0.01929, "epss_percentile": 0.82933}, "CVE-2013-4290": {"epss_score": 0.0143, "epss_percentile": 0.80235}, "CVE-2013-4291": {"epss_score": 0.00046, "epss_percentile": 0.14388}, "CVE-2013-4292": {"epss_score": 0.00068, "epss_percentile": 0.21334}, "CVE-2013-4293": {"epss_score": 0.00049, "epss_percentile": 0.15429}, "CVE-2013-4294": {"epss_score": 0.008, "epss_percentile": 0.73533}, "CVE-2013-4295": {"epss_score": 0.47748, "epss_percentile": 0.97599}, "CVE-2013-4296": {"epss_score": 0.03294, "epss_percentile": 0.86844}, "CVE-2013-4297": {"epss_score": 0.0058, "epss_percentile": 0.68253}, "CVE-2013-4298": {"epss_score": 0.00943, "epss_percentile": 0.75777}, "CVE-2013-4299": {"epss_score": 0.00804, "epss_percentile": 0.73609}, "CVE-2013-4300": {"epss_score": 0.00042, "epss_percentile": 0.12728}, "CVE-2013-4301": {"epss_score": 0.00713, "epss_percentile": 0.71803}, "CVE-2013-4302": {"epss_score": 0.00697, "epss_percentile": 0.71408}, "CVE-2013-4303": {"epss_score": 0.00566, "epss_percentile": 0.67827}, "CVE-2013-4304": {"epss_score": 0.00332, "epss_percentile": 0.5556}, "CVE-2013-4305": {"epss_score": 0.00186, "epss_percentile": 0.4063}, "CVE-2013-4306": {"epss_score": 0.00228, "epss_percentile": 0.45482}, "CVE-2013-4307": {"epss_score": 0.0042, "epss_percentile": 0.61447}, "CVE-2013-4308": {"epss_score": 0.0042, "epss_percentile": 0.61447}, "CVE-2013-4310": {"epss_score": 0.11397, "epss_percentile": 0.93334}, "CVE-2013-4311": {"epss_score": 0.00024, "epss_percentile": 0.05907}, "CVE-2013-4312": {"epss_score": 0.00027, "epss_percentile": 0.0688}, "CVE-2013-4313": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2013-4314": {"epss_score": 0.0025, "epss_percentile": 0.48089}, "CVE-2013-4315": {"epss_score": 0.00983, "epss_percentile": 0.76306}, "CVE-2013-4316": {"epss_score": 0.06168, "epss_percentile": 0.90529}, "CVE-2013-4317": {"epss_score": 0.00459, "epss_percentile": 0.63465}, "CVE-2013-4318": {"epss_score": 0.00244, "epss_percentile": 0.47568}, "CVE-2013-4319": {"epss_score": 0.008, "epss_percentile": 0.73536}, "CVE-2013-4320": {"epss_score": 0.00129, "epss_percentile": 0.33215}, "CVE-2013-4321": {"epss_score": 0.00485, "epss_percentile": 0.64739}, "CVE-2013-4322": {"epss_score": 0.70702, "epss_percentile": 0.9864}, "CVE-2013-4324": {"epss_score": 0.00065, "epss_percentile": 0.20458}, "CVE-2013-4325": {"epss_score": 0.00065, "epss_percentile": 0.20512}, "CVE-2013-4326": {"epss_score": 0.00062, "epss_percentile": 0.19719}, "CVE-2013-4327": {"epss_score": 0.00042, "epss_percentile": 0.1279}, "CVE-2013-4329": {"epss_score": 0.00162, "epss_percentile": 0.37652}, "CVE-2013-4330": {"epss_score": 0.26192, "epss_percentile": 0.96122}, "CVE-2013-4331": {"epss_score": 0.00043, "epss_percentile": 0.13217}, "CVE-2013-4332": {"epss_score": 0.01762, "epss_percentile": 0.82154}, "CVE-2013-4333": {"epss_score": 0.02158, "epss_percentile": 0.83817}, "CVE-2013-4334": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2013-4335": {"epss_score": 0.02097, "epss_percentile": 0.8359}, "CVE-2013-4338": {"epss_score": 0.09588, "epss_percentile": 0.92611}, "CVE-2013-4339": {"epss_score": 0.00882, "epss_percentile": 0.74899}, "CVE-2013-4340": {"epss_score": 0.00977, "epss_percentile": 0.76229}, "CVE-2013-4341": {"epss_score": 0.13058, "epss_percentile": 0.9386}, "CVE-2013-4342": {"epss_score": 0.15271, "epss_percentile": 0.94395}, "CVE-2013-4343": {"epss_score": 0.00091, "epss_percentile": 0.26223}, "CVE-2013-4344": {"epss_score": 0.00068, "epss_percentile": 0.21285}, "CVE-2013-4345": {"epss_score": 0.00963, "epss_percentile": 0.76015}, "CVE-2013-4346": {"epss_score": 0.003, "epss_percentile": 0.52924}, "CVE-2013-4347": {"epss_score": 0.00269, "epss_percentile": 0.50113}, "CVE-2013-4348": {"epss_score": 0.04267, "epss_percentile": 0.88471}, "CVE-2013-4350": {"epss_score": 0.00332, "epss_percentile": 0.55565}, "CVE-2013-4351": {"epss_score": 0.01303, "epss_percentile": 0.79309}, "CVE-2013-4352": {"epss_score": 0.24352, "epss_percentile": 0.95909}, "CVE-2013-4353": {"epss_score": 0.34592, "epss_percentile": 0.96859}, "CVE-2013-4354": {"epss_score": 0.0006, "epss_percentile": 0.19009}, "CVE-2013-4355": {"epss_score": 0.00094, "epss_percentile": 0.2707}, "CVE-2013-4356": {"epss_score": 0.00094, "epss_percentile": 0.27071}, "CVE-2013-4357": {"epss_score": 0.01185, "epss_percentile": 0.78335}, "CVE-2013-4358": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-4359": {"epss_score": 0.01894, "epss_percentile": 0.82739}, "CVE-2013-4361": {"epss_score": 0.0011, "epss_percentile": 0.30156}, "CVE-2013-4362": {"epss_score": 0.0081, "epss_percentile": 0.73716}, "CVE-2013-4363": {"epss_score": 0.00588, "epss_percentile": 0.685}, "CVE-2013-4364": {"epss_score": 0.00031, "epss_percentile": 0.08502}, "CVE-2013-4365": {"epss_score": 0.06656, "epss_percentile": 0.90919}, "CVE-2013-4366": {"epss_score": 0.0129, "epss_percentile": 0.79223}, "CVE-2013-4367": {"epss_score": 0.00105, "epss_percentile": 0.29379}, "CVE-2013-4368": {"epss_score": 0.00094, "epss_percentile": 0.27041}, "CVE-2013-4369": {"epss_score": 0.00057, "epss_percentile": 0.18199}, "CVE-2013-4370": {"epss_score": 0.00086, "epss_percentile": 0.25383}, "CVE-2013-4371": {"epss_score": 0.00082, "epss_percentile": 0.24581}, "CVE-2013-4372": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2013-4373": {"epss_score": 0.00051, "epss_percentile": 0.16119}, "CVE-2013-4374": {"epss_score": 0.00099, "epss_percentile": 0.28365}, "CVE-2013-4375": {"epss_score": 0.00092, "epss_percentile": 0.26496}, "CVE-2013-4376": {"epss_score": 0.02016, "epss_percentile": 0.83274}, "CVE-2013-4377": {"epss_score": 0.001, "epss_percentile": 0.2855}, "CVE-2013-4378": {"epss_score": 0.01246, "epss_percentile": 0.78856}, "CVE-2013-4379": {"epss_score": 0.00227, "epss_percentile": 0.45432}, "CVE-2013-4380": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2013-4383": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2013-4384": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2013-4385": {"epss_score": 0.02706, "epss_percentile": 0.85467}, "CVE-2013-4386": {"epss_score": 0.00517, "epss_percentile": 0.66081}, "CVE-2013-4387": {"epss_score": 0.00835, "epss_percentile": 0.74116}, "CVE-2013-4388": {"epss_score": 0.03905, "epss_percentile": 0.87926}, "CVE-2013-4389": {"epss_score": 0.01333, "epss_percentile": 0.7953}, "CVE-2013-4390": {"epss_score": 0.01325, "epss_percentile": 0.79469}, "CVE-2013-4391": {"epss_score": 0.037, "epss_percentile": 0.87589}, "CVE-2013-4392": {"epss_score": 0.00057, "epss_percentile": 0.18051}, "CVE-2013-4393": {"epss_score": 0.0015, "epss_percentile": 0.36143}, "CVE-2013-4394": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2013-4395": {"epss_score": 0.00272, "epss_percentile": 0.50359}, "CVE-2013-4396": {"epss_score": 0.01572, "epss_percentile": 0.81097}, "CVE-2013-4397": {"epss_score": 0.04261, "epss_percentile": 0.88463}, "CVE-2013-4399": {"epss_score": 0.00677, "epss_percentile": 0.70964}, "CVE-2013-4400": {"epss_score": 0.00053, "epss_percentile": 0.16735}, "CVE-2013-4401": {"epss_score": 0.01463, "epss_percentile": 0.80446}, "CVE-2013-4402": {"epss_score": 0.04702, "epss_percentile": 0.89026}, "CVE-2013-4404": {"epss_score": 0.00216, "epss_percentile": 0.44157}, "CVE-2013-4405": {"epss_score": 0.00134, "epss_percentile": 0.33756}, "CVE-2013-4406": {"epss_score": 0.0039, "epss_percentile": 0.59536}, "CVE-2013-4407": {"epss_score": 0.0083, "epss_percentile": 0.7402}, "CVE-2013-4408": {"epss_score": 0.04493, "epss_percentile": 0.8876}, "CVE-2013-4409": {"epss_score": 0.01166, "epss_percentile": 0.78179}, "CVE-2013-4410": {"epss_score": 0.00968, "epss_percentile": 0.76084}, "CVE-2013-4411": {"epss_score": 0.00514, "epss_percentile": 0.65945}, "CVE-2013-4412": {"epss_score": 0.00938, "epss_percentile": 0.75707}, "CVE-2013-4413": {"epss_score": 0.00964, "epss_percentile": 0.76037}, "CVE-2013-4414": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-4415": {"epss_score": 0.0033, "epss_percentile": 0.55489}, "CVE-2013-4416": {"epss_score": 0.00279, "epss_percentile": 0.50969}, "CVE-2013-4419": {"epss_score": 0.00083, "epss_percentile": 0.24622}, "CVE-2013-4420": {"epss_score": 0.00604, "epss_percentile": 0.68955}, "CVE-2013-4421": {"epss_score": 0.25913, "epss_percentile": 0.96094}, "CVE-2013-4422": {"epss_score": 0.00671, "epss_percentile": 0.70798}, "CVE-2013-4423": {"epss_score": 0.00104, "epss_percentile": 0.29222}, "CVE-2013-4424": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-4425": {"epss_score": 0.00056, "epss_percentile": 0.17864}, "CVE-2013-4426": {"epss_score": 0.00074, "epss_percentile": 0.22747}, "CVE-2013-4427": {"epss_score": 0.00069, "epss_percentile": 0.21579}, "CVE-2013-4428": {"epss_score": 0.00282, "epss_percentile": 0.51265}, "CVE-2013-4429": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2013-4430": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-4431": {"epss_score": 0.00621, "epss_percentile": 0.69486}, "CVE-2013-4432": {"epss_score": 0.0019, "epss_percentile": 0.4108}, "CVE-2013-4433": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-4434": {"epss_score": 0.01912, "epss_percentile": 0.82832}, "CVE-2013-4435": {"epss_score": 0.00324, "epss_percentile": 0.54958}, "CVE-2013-4436": {"epss_score": 0.00711, "epss_percentile": 0.71745}, "CVE-2013-4437": {"epss_score": 0.00675, "epss_percentile": 0.7091}, "CVE-2013-4438": {"epss_score": 0.0057, "epss_percentile": 0.67964}, "CVE-2013-4439": {"epss_score": 0.00193, "epss_percentile": 0.41427}, "CVE-2013-4440": {"epss_score": 0.00491, "epss_percentile": 0.64956}, "CVE-2013-4441": {"epss_score": 0.00434, "epss_percentile": 0.62304}, "CVE-2013-4442": {"epss_score": 0.00654, "epss_percentile": 0.70341}, "CVE-2013-4444": {"epss_score": 0.20286, "epss_percentile": 0.95313}, "CVE-2013-4445": {"epss_score": 0.00553, "epss_percentile": 0.67412}, "CVE-2013-4446": {"epss_score": 0.01087, "epss_percentile": 0.77431}, "CVE-2013-4447": {"epss_score": 0.00799, "epss_percentile": 0.73531}, "CVE-2013-4449": {"epss_score": 0.68747, "epss_percentile": 0.98561}, "CVE-2013-4450": {"epss_score": 0.68714, "epss_percentile": 0.98559}, "CVE-2013-4451": {"epss_score": 0.01386, "epss_percentile": 0.79914}, "CVE-2013-4452": {"epss_score": 0.00054, "epss_percentile": 0.17171}, "CVE-2013-4453": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2013-4454": {"epss_score": 0.00634, "epss_percentile": 0.69807}, "CVE-2013-4455": {"epss_score": 0.00043, "epss_percentile": 0.13217}, "CVE-2013-4457": {"epss_score": 0.00376, "epss_percentile": 0.5867}, "CVE-2013-4458": {"epss_score": 0.01239, "epss_percentile": 0.78795}, "CVE-2013-4459": {"epss_score": 0.0006, "epss_percentile": 0.19228}, "CVE-2013-4460": {"epss_score": 0.00208, "epss_percentile": 0.43213}, "CVE-2013-4461": {"epss_score": 0.0038, "epss_percentile": 0.58957}, "CVE-2013-4462": {"epss_score": 0.01191, "epss_percentile": 0.78393}, "CVE-2013-4463": {"epss_score": 0.00061, "epss_percentile": 0.1941}, "CVE-2013-4465": {"epss_score": 0.01085, "epss_percentile": 0.77406}, "CVE-2013-4466": {"epss_score": 0.00571, "epss_percentile": 0.67982}, "CVE-2013-4467": {"epss_score": 0.69952, "epss_percentile": 0.98609}, "CVE-2013-4468": {"epss_score": 0.82435, "epss_percentile": 0.99195}, "CVE-2013-4469": {"epss_score": 0.0006, "epss_percentile": 0.19184}, "CVE-2013-4470": {"epss_score": 0.00122, "epss_percentile": 0.32097}, "CVE-2013-4471": {"epss_score": 0.00181, "epss_percentile": 0.40072}, "CVE-2013-4472": {"epss_score": 0.0007, "epss_percentile": 0.21767}, "CVE-2013-4473": {"epss_score": 0.02273, "epss_percentile": 0.84221}, "CVE-2013-4474": {"epss_score": 0.29757, "epss_percentile": 0.96471}, "CVE-2013-4475": {"epss_score": 0.03559, "epss_percentile": 0.87351}, "CVE-2013-4476": {"epss_score": 0.00226, "epss_percentile": 0.45258}, "CVE-2013-4477": {"epss_score": 0.00151, "epss_percentile": 0.36332}, "CVE-2013-4478": {"epss_score": 0.004, "epss_percentile": 0.60195}, "CVE-2013-4479": {"epss_score": 0.00509, "epss_percentile": 0.65731}, "CVE-2013-4480": {"epss_score": 0.00704, "epss_percentile": 0.71567}, "CVE-2013-4481": {"epss_score": 0.00033, "epss_percentile": 0.09176}, "CVE-2013-4482": {"epss_score": 0.00051, "epss_percentile": 0.16127}, "CVE-2013-4483": {"epss_score": 0.00092, "epss_percentile": 0.26442}, "CVE-2013-4484": {"epss_score": 0.01554, "epss_percentile": 0.81003}, "CVE-2013-4485": {"epss_score": 0.00422, "epss_percentile": 0.61574}, "CVE-2013-4486": {"epss_score": 0.00597, "epss_percentile": 0.68739}, "CVE-2013-4487": {"epss_score": 0.00337, "epss_percentile": 0.56043}, "CVE-2013-4488": {"epss_score": 0.00279, "epss_percentile": 0.50989}, "CVE-2013-4489": {"epss_score": 0.00202, "epss_percentile": 0.42429}, "CVE-2013-4490": {"epss_score": 0.48021, "epss_percentile": 0.97614}, "CVE-2013-4491": {"epss_score": 0.00713, "epss_percentile": 0.71791}, "CVE-2013-4492": {"epss_score": 0.00377, "epss_percentile": 0.58773}, "CVE-2013-4494": {"epss_score": 0.00305, "epss_percentile": 0.53348}, "CVE-2013-4495": {"epss_score": 0.05416, "epss_percentile": 0.89851}, "CVE-2013-4496": {"epss_score": 0.0555, "epss_percentile": 0.89986}, "CVE-2013-4497": {"epss_score": 0.00106, "epss_percentile": 0.29468}, "CVE-2013-4498": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2013-4499": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-4500": {"epss_score": 0.00413, "epss_percentile": 0.60999}, "CVE-2013-4501": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2013-4502": {"epss_score": 0.0017, "epss_percentile": 0.38671}, "CVE-2013-4503": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-4504": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2013-4505": {"epss_score": 0.0164, "epss_percentile": 0.81501}, "CVE-2013-4507": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-4508": {"epss_score": 0.02907, "epss_percentile": 0.85964}, "CVE-2013-4509": {"epss_score": 0.0008, "epss_percentile": 0.24015}, "CVE-2013-4510": {"epss_score": 0.00754, "epss_percentile": 0.72697}, "CVE-2013-4511": {"epss_score": 0.0007, "epss_percentile": 0.21692}, "CVE-2013-4512": {"epss_score": 0.00131, "epss_percentile": 0.3336}, "CVE-2013-4513": {"epss_score": 0.00013, "epss_percentile": 0.01535}, "CVE-2013-4514": {"epss_score": 0.00037, "epss_percentile": 0.10934}, "CVE-2013-4515": {"epss_score": 0.00032, "epss_percentile": 0.09076}, "CVE-2013-4516": {"epss_score": 0.00034, "epss_percentile": 0.09797}, "CVE-2013-4517": {"epss_score": 0.11948, "epss_percentile": 0.93523}, "CVE-2013-4518": {"epss_score": 0.00078, "epss_percentile": 0.23626}, "CVE-2013-4519": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2013-4520": {"epss_score": 0.01432, "epss_percentile": 0.80252}, "CVE-2013-4521": {"epss_score": 0.02548, "epss_percentile": 0.85067}, "CVE-2013-4522": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2013-4523": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2013-4524": {"epss_score": 0.0028, "epss_percentile": 0.51044}, "CVE-2013-4525": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2013-4526": {"epss_score": 0.02548, "epss_percentile": 0.85069}, "CVE-2013-4527": {"epss_score": 0.04083, "epss_percentile": 0.88223}, "CVE-2013-4529": {"epss_score": 0.02104, "epss_percentile": 0.83621}, "CVE-2013-4530": {"epss_score": 0.02424, "epss_percentile": 0.84711}, "CVE-2013-4531": {"epss_score": 0.02001, "epss_percentile": 0.83221}, "CVE-2013-4532": {"epss_score": 0.0017, "epss_percentile": 0.38667}, "CVE-2013-4533": {"epss_score": 0.02001, "epss_percentile": 0.83221}, "CVE-2013-4534": {"epss_score": 0.02001, "epss_percentile": 0.83221}, "CVE-2013-4535": {"epss_score": 0.0038, "epss_percentile": 0.58944}, "CVE-2013-4536": {"epss_score": 0.00044, "epss_percentile": 0.13425}, "CVE-2013-4537": {"epss_score": 0.01904, "epss_percentile": 0.82791}, "CVE-2013-4538": {"epss_score": 0.02548, "epss_percentile": 0.85069}, "CVE-2013-4539": {"epss_score": 0.04287, "epss_percentile": 0.88497}, "CVE-2013-4540": {"epss_score": 0.03838, "epss_percentile": 0.87827}, "CVE-2013-4541": {"epss_score": 0.01728, "epss_percentile": 0.81976}, "CVE-2013-4542": {"epss_score": 0.02095, "epss_percentile": 0.83585}, "CVE-2013-4544": {"epss_score": 0.00151, "epss_percentile": 0.36221}, "CVE-2013-4545": {"epss_score": 0.00838, "epss_percentile": 0.74166}, "CVE-2013-4546": {"epss_score": 0.00219, "epss_percentile": 0.44535}, "CVE-2013-4547": {"epss_score": 0.91842, "epss_percentile": 0.99672}, "CVE-2013-4548": {"epss_score": 0.00305, "epss_percentile": 0.53391}, "CVE-2013-4549": {"epss_score": 0.05217, "epss_percentile": 0.89621}, "CVE-2013-4550": {"epss_score": 0.01003, "epss_percentile": 0.76512}, "CVE-2013-4551": {"epss_score": 0.00433, "epss_percentile": 0.62176}, "CVE-2013-4552": {"epss_score": 0.00478, "epss_percentile": 0.64375}, "CVE-2013-4553": {"epss_score": 0.00328, "epss_percentile": 0.55286}, "CVE-2013-4554": {"epss_score": 0.00209, "epss_percentile": 0.43335}, "CVE-2013-4555": {"epss_score": 0.00226, "epss_percentile": 0.4526}, "CVE-2013-4556": {"epss_score": 0.00329, "epss_percentile": 0.5541}, "CVE-2013-4557": {"epss_score": 0.69494, "epss_percentile": 0.9859}, "CVE-2013-4558": {"epss_score": 0.01783, "epss_percentile": 0.82247}, "CVE-2013-4559": {"epss_score": 0.13983, "epss_percentile": 0.94108}, "CVE-2013-4560": {"epss_score": 0.07805, "epss_percentile": 0.91691}, "CVE-2013-4561": {"epss_score": 0.00313, "epss_percentile": 0.54044}, "CVE-2013-4562": {"epss_score": 0.00481, "epss_percentile": 0.64484}, "CVE-2013-4563": {"epss_score": 0.01558, "epss_percentile": 0.81029}, "CVE-2013-4564": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2013-4565": {"epss_score": 0.03479, "epss_percentile": 0.87217}, "CVE-2013-4566": {"epss_score": 0.00124, "epss_percentile": 0.32426}, "CVE-2013-4567": {"epss_score": 0.00456, "epss_percentile": 0.63338}, "CVE-2013-4568": {"epss_score": 0.00497, "epss_percentile": 0.65195}, "CVE-2013-4569": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2013-4570": {"epss_score": 0.00727, "epss_percentile": 0.72088}, "CVE-2013-4571": {"epss_score": 0.00514, "epss_percentile": 0.65966}, "CVE-2013-4572": {"epss_score": 0.01288, "epss_percentile": 0.79202}, "CVE-2013-4573": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2013-4574": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2013-4575": {"epss_score": 0.01665, "epss_percentile": 0.81646}, "CVE-2013-4576": {"epss_score": 0.00108, "epss_percentile": 0.29828}, "CVE-2013-4577": {"epss_score": 0.00156, "epss_percentile": 0.36904}, "CVE-2013-4578": {"epss_score": 0.0029, "epss_percentile": 0.52078}, "CVE-2013-4579": {"epss_score": 0.19361, "epss_percentile": 0.95169}, "CVE-2013-4580": {"epss_score": 0.00096, "epss_percentile": 0.27309}, "CVE-2013-4581": {"epss_score": 0.00742, "epss_percentile": 0.7245}, "CVE-2013-4582": {"epss_score": 0.00164, "epss_percentile": 0.37954}, "CVE-2013-4583": {"epss_score": 0.00291, "epss_percentile": 0.52197}, "CVE-2013-4584": {"epss_score": 0.00579, "epss_percentile": 0.68234}, "CVE-2013-4587": {"epss_score": 0.00052, "epss_percentile": 0.1663}, "CVE-2013-4588": {"epss_score": 0.00051, "epss_percentile": 0.15995}, "CVE-2013-4589": {"epss_score": 0.02351, "epss_percentile": 0.8447}, "CVE-2013-4590": {"epss_score": 0.00216, "epss_percentile": 0.44227}, "CVE-2013-4591": {"epss_score": 0.00062, "epss_percentile": 0.19674}, "CVE-2013-4592": {"epss_score": 0.00043, "epss_percentile": 0.13138}, "CVE-2013-4593": {"epss_score": 0.00352, "epss_percentile": 0.57079}, "CVE-2013-4594": {"epss_score": 0.0025, "epss_percentile": 0.48097}, "CVE-2013-4595": {"epss_score": 0.00331, "epss_percentile": 0.5553}, "CVE-2013-4596": {"epss_score": 0.00172, "epss_percentile": 0.38932}, "CVE-2013-4597": {"epss_score": 0.00151, "epss_percentile": 0.36203}, "CVE-2013-4598": {"epss_score": 0.0066, "epss_percentile": 0.70522}, "CVE-2013-4599": {"epss_score": 0.00683, "epss_percentile": 0.71091}, "CVE-2013-4600": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2013-4602": {"epss_score": 0.00258, "epss_percentile": 0.49005}, "CVE-2013-4604": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2013-4608": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-4609": {"epss_score": 0.00191, "epss_percentile": 0.41201}, "CVE-2013-4610": {"epss_score": 0.00322, "epss_percentile": 0.54801}, "CVE-2013-4611": {"epss_score": 0.01305, "epss_percentile": 0.79322}, "CVE-2013-4612": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-4613": {"epss_score": 0.00518, "epss_percentile": 0.66139}, "CVE-2013-4614": {"epss_score": 0.08011, "epss_percentile": 0.91827}, "CVE-2013-4615": {"epss_score": 0.63316, "epss_percentile": 0.98328}, "CVE-2013-4616": {"epss_score": 0.00568, "epss_percentile": 0.67898}, "CVE-2013-4617": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-4619": {"epss_score": 0.00019, "epss_percentile": 0.04246}, "CVE-2013-4620": {"epss_score": 0.01099, "epss_percentile": 0.77547}, "CVE-2013-4621": {"epss_score": 0.00125, "epss_percentile": 0.32587}, "CVE-2013-4622": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2013-4623": {"epss_score": 0.00659, "epss_percentile": 0.70513}, "CVE-2013-4624": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2013-4625": {"epss_score": 0.08892, "epss_percentile": 0.92304}, "CVE-2013-4626": {"epss_score": 0.00498, "epss_percentile": 0.6522}, "CVE-2013-4627": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-4628": {"epss_score": 0.00081, "epss_percentile": 0.2437}, "CVE-2013-4629": {"epss_score": 0.00217, "epss_percentile": 0.44303}, "CVE-2013-4630": {"epss_score": 0.1485, "epss_percentile": 0.94302}, "CVE-2013-4631": {"epss_score": 0.04159, "epss_percentile": 0.88332}, "CVE-2013-4632": {"epss_score": 0.00227, "epss_percentile": 0.45437}, "CVE-2013-4633": {"epss_score": 0.00211, "epss_percentile": 0.43702}, "CVE-2013-4634": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2013-4635": {"epss_score": 0.13058, "epss_percentile": 0.93861}, "CVE-2013-4636": {"epss_score": 0.00326, "epss_percentile": 0.55045}, "CVE-2013-4649": {"epss_score": 0.00269, "epss_percentile": 0.50164}, "CVE-2013-4650": {"epss_score": 0.00497, "epss_percentile": 0.65203}, "CVE-2013-4651": {"epss_score": 0.00352, "epss_percentile": 0.57121}, "CVE-2013-4652": {"epss_score": 0.11122, "epss_percentile": 0.93229}, "CVE-2013-4653": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2013-4654": {"epss_score": 0.00911, "epss_percentile": 0.75354}, "CVE-2013-4655": {"epss_score": 0.00639, "epss_percentile": 0.69945}, "CVE-2013-4656": {"epss_score": 0.00738, "epss_percentile": 0.72348}, "CVE-2013-4657": {"epss_score": 0.00521, "epss_percentile": 0.66235}, "CVE-2013-4658": {"epss_score": 0.00612, "epss_percentile": 0.69238}, "CVE-2013-4659": {"epss_score": 0.11534, "epss_percentile": 0.93398}, "CVE-2013-4660": {"epss_score": 0.64507, "epss_percentile": 0.98381}, "CVE-2013-4661": {"epss_score": 0.00171, "epss_percentile": 0.38872}, "CVE-2013-4662": {"epss_score": 0.00132, "epss_percentile": 0.33585}, "CVE-2013-4663": {"epss_score": 0.01027, "epss_percentile": 0.7681}, "CVE-2013-4664": {"epss_score": 0.02678, "epss_percentile": 0.85412}, "CVE-2013-4665": {"epss_score": 0.00196, "epss_percentile": 0.4176}, "CVE-2013-4668": {"epss_score": 0.03981, "epss_percentile": 0.8806}, "CVE-2013-4669": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2013-4670": {"epss_score": 0.01015, "epss_percentile": 0.76656}, "CVE-2013-4671": {"epss_score": 0.00771, "epss_percentile": 0.73017}, "CVE-2013-4672": {"epss_score": 0.00177, "epss_percentile": 0.3954}, "CVE-2013-4673": {"epss_score": 0.00828, "epss_percentile": 0.73998}, "CVE-2013-4674": {"epss_score": 0.00387, "epss_percentile": 0.59332}, "CVE-2013-4676": {"epss_score": 0.00525, "epss_percentile": 0.66393}, "CVE-2013-4677": {"epss_score": 0.00052, "epss_percentile": 0.16463}, "CVE-2013-4678": {"epss_score": 0.00108, "epss_percentile": 0.29793}, "CVE-2013-4679": {"epss_score": 0.00198, "epss_percentile": 0.42066}, "CVE-2013-4680": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-4681": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2013-4682": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2013-4683": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2013-4684": {"epss_score": 0.00836, "epss_percentile": 0.74128}, "CVE-2013-4685": {"epss_score": 0.09374, "epss_percentile": 0.9252}, "CVE-2013-4686": {"epss_score": 0.00648, "epss_percentile": 0.70215}, "CVE-2013-4687": {"epss_score": 0.02368, "epss_percentile": 0.84519}, "CVE-2013-4688": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2013-4689": {"epss_score": 0.0009, "epss_percentile": 0.26157}, "CVE-2013-4690": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2013-4691": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2013-4692": {"epss_score": 0.04008, "epss_percentile": 0.88106}, "CVE-2013-4693": {"epss_score": 0.00259, "epss_percentile": 0.49095}, "CVE-2013-4694": {"epss_score": 0.48448, "epss_percentile": 0.97638}, "CVE-2013-4695": {"epss_score": 0.03501, "epss_percentile": 0.87246}, "CVE-2013-4697": {"epss_score": 0.00495, "epss_percentile": 0.65119}, "CVE-2013-4698": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2013-4699": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2013-4700": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2013-4701": {"epss_score": 0.00881, "epss_percentile": 0.74865}, "CVE-2013-4702": {"epss_score": 0.0063, "epss_percentile": 0.69692}, "CVE-2013-4703": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-4704": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-4705": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-4706": {"epss_score": 0.00104, "epss_percentile": 0.29179}, "CVE-2013-4707": {"epss_score": 0.00104, "epss_percentile": 0.29179}, "CVE-2013-4708": {"epss_score": 0.00202, "epss_percentile": 0.42461}, "CVE-2013-4709": {"epss_score": 0.02791, "epss_percentile": 0.85668}, "CVE-2013-4710": {"epss_score": 0.75993, "epss_percentile": 0.98873}, "CVE-2013-4711": {"epss_score": 0.00226, "epss_percentile": 0.4527}, "CVE-2013-4712": {"epss_score": 0.00666, "epss_percentile": 0.70694}, "CVE-2013-4713": {"epss_score": 0.00179, "epss_percentile": 0.39815}, "CVE-2013-4714": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-4715": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2013-4716": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-4717": {"epss_score": 0.00897, "epss_percentile": 0.75136}, "CVE-2013-4718": {"epss_score": 0.00179, "epss_percentile": 0.39832}, "CVE-2013-4719": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2013-4720": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2013-4721": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2013-4722": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-4723": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2013-4724": {"epss_score": 0.00403, "epss_percentile": 0.60333}, "CVE-2013-4725": {"epss_score": 0.00403, "epss_percentile": 0.60333}, "CVE-2013-4726": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2013-4727": {"epss_score": 0.12485, "epss_percentile": 0.93687}, "CVE-2013-4728": {"epss_score": 0.00403, "epss_percentile": 0.60333}, "CVE-2013-4729": {"epss_score": 0.00367, "epss_percentile": 0.58112}, "CVE-2013-4730": {"epss_score": 0.74482, "epss_percentile": 0.98801}, "CVE-2013-4731": {"epss_score": 0.00527, "epss_percentile": 0.66523}, "CVE-2013-4732": {"epss_score": 0.02784, "epss_percentile": 0.85655}, "CVE-2013-4733": {"epss_score": 0.01464, "epss_percentile": 0.80448}, "CVE-2013-4734": {"epss_score": 0.0265, "epss_percentile": 0.85344}, "CVE-2013-4735": {"epss_score": 0.01351, "epss_percentile": 0.7968}, "CVE-2013-4736": {"epss_score": 0.00525, "epss_percentile": 0.66373}, "CVE-2013-4737": {"epss_score": 0.00631, "epss_percentile": 0.69726}, "CVE-2013-4738": {"epss_score": 0.00112, "epss_percentile": 0.30413}, "CVE-2013-4739": {"epss_score": 0.00091, "epss_percentile": 0.26258}, "CVE-2013-4740": {"epss_score": 0.00123, "epss_percentile": 0.32307}, "CVE-2013-4742": {"epss_score": 0.03708, "epss_percentile": 0.876}, "CVE-2013-4743": {"epss_score": 0.0805, "epss_percentile": 0.91854}, "CVE-2013-4744": {"epss_score": 0.00367, "epss_percentile": 0.58103}, "CVE-2013-4745": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2013-4746": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-4747": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-4748": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2013-4749": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-4751": {"epss_score": 0.00598, "epss_percentile": 0.6876}, "CVE-2013-4752": {"epss_score": 0.00928, "epss_percentile": 0.75573}, "CVE-2013-4753": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2013-4754": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2013-4758": {"epss_score": 0.01216, "epss_percentile": 0.78595}, "CVE-2013-4759": {"epss_score": 0.10299, "epss_percentile": 0.92933}, "CVE-2013-4761": {"epss_score": 0.0062, "epss_percentile": 0.69455}, "CVE-2013-4762": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2013-4763": {"epss_score": 0.00176, "epss_percentile": 0.39443}, "CVE-2013-4764": {"epss_score": 0.0016, "epss_percentile": 0.37498}, "CVE-2013-4766": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-4767": {"epss_score": 0.00501, "epss_percentile": 0.65351}, "CVE-2013-4768": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2013-4769": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2013-4770": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2013-4772": {"epss_score": 0.0015, "epss_percentile": 0.3618}, "CVE-2013-4775": {"epss_score": 0.11577, "epss_percentile": 0.93408}, "CVE-2013-4776": {"epss_score": 0.37969, "epss_percentile": 0.97079}, "CVE-2013-4777": {"epss_score": 0.0002, "epss_percentile": 0.04463}, "CVE-2013-4778": {"epss_score": 0.00377, "epss_percentile": 0.5872}, "CVE-2013-4779": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-4780": {"epss_score": 0.00377, "epss_percentile": 0.5872}, "CVE-2013-4781": {"epss_score": 0.045, "epss_percentile": 0.88766}, "CVE-2013-4782": {"epss_score": 0.64078, "epss_percentile": 0.98363}, "CVE-2013-4783": {"epss_score": 0.04825, "epss_percentile": 0.89183}, "CVE-2013-4784": {"epss_score": 0.49712, "epss_percentile": 0.97701}, "CVE-2013-4785": {"epss_score": 0.02007, "epss_percentile": 0.83239}, "CVE-2013-4786": {"epss_score": 0.73191, "epss_percentile": 0.98741}, "CVE-2013-4787": {"epss_score": 0.52603, "epss_percentile": 0.97832}, "CVE-2013-4788": {"epss_score": 0.0756, "epss_percentile": 0.91541}, "CVE-2013-4789": {"epss_score": 0.01022, "epss_percentile": 0.76756}, "CVE-2013-4790": {"epss_score": 0.00284, "epss_percentile": 0.51423}, "CVE-2013-4791": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2013-4792": {"epss_score": 0.00096, "epss_percentile": 0.27328}, "CVE-2013-4793": {"epss_score": 0.00395, "epss_percentile": 0.59801}, "CVE-2013-4795": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2013-4796": {"epss_score": 0.0063, "epss_percentile": 0.697}, "CVE-2013-4797": {"epss_score": 0.07647, "epss_percentile": 0.916}, "CVE-2013-4798": {"epss_score": 0.83193, "epss_percentile": 0.99237}, "CVE-2013-4799": {"epss_score": 0.29172, "epss_percentile": 0.96422}, "CVE-2013-4800": {"epss_score": 0.71373, "epss_percentile": 0.98665}, "CVE-2013-4801": {"epss_score": 0.07579, "epss_percentile": 0.91551}, "CVE-2013-4802": {"epss_score": 0.00785, "epss_percentile": 0.73249}, "CVE-2013-4804": {"epss_score": 0.09917, "epss_percentile": 0.9277}, "CVE-2013-4805": {"epss_score": 0.00602, "epss_percentile": 0.68894}, "CVE-2013-4806": {"epss_score": 0.00242, "epss_percentile": 0.47403}, "CVE-2013-4807": {"epss_score": 0.01465, "epss_percentile": 0.80457}, "CVE-2013-4808": {"epss_score": 0.04203, "epss_percentile": 0.88392}, "CVE-2013-4809": {"epss_score": 0.00863, "epss_percentile": 0.74585}, "CVE-2013-4810": {"epss_score": 0.8588, "epss_percentile": 0.99353}, "CVE-2013-4811": {"epss_score": 0.83544, "epss_percentile": 0.99252}, "CVE-2013-4812": {"epss_score": 0.73996, "epss_percentile": 0.98781}, "CVE-2013-4813": {"epss_score": 0.06402, "epss_percentile": 0.90729}, "CVE-2013-4814": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2013-4815": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-4817": {"epss_score": 0.00689, "epss_percentile": 0.71218}, "CVE-2013-4818": {"epss_score": 0.00689, "epss_percentile": 0.71218}, "CVE-2013-4819": {"epss_score": 0.00184, "epss_percentile": 0.40403}, "CVE-2013-4820": {"epss_score": 0.00188, "epss_percentile": 0.40919}, "CVE-2013-4821": {"epss_score": 0.00275, "epss_percentile": 0.50655}, "CVE-2013-4822": {"epss_score": 0.74063, "epss_percentile": 0.98787}, "CVE-2013-4823": {"epss_score": 0.77228, "epss_percentile": 0.98927}, "CVE-2013-4824": {"epss_score": 0.777, "epss_percentile": 0.98948}, "CVE-2013-4825": {"epss_score": 0.0036, "epss_percentile": 0.57624}, "CVE-2013-4826": {"epss_score": 0.77228, "epss_percentile": 0.98927}, "CVE-2013-4827": {"epss_score": 0.00889, "epss_percentile": 0.75014}, "CVE-2013-4828": {"epss_score": 0.00594, "epss_percentile": 0.68664}, "CVE-2013-4829": {"epss_score": 0.00056, "epss_percentile": 0.17741}, "CVE-2013-4830": {"epss_score": 0.06732, "epss_percentile": 0.90989}, "CVE-2013-4831": {"epss_score": 0.00207, "epss_percentile": 0.4315}, "CVE-2013-4832": {"epss_score": 0.00213, "epss_percentile": 0.43931}, "CVE-2013-4833": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2013-4834": {"epss_score": 0.05517, "epss_percentile": 0.89951}, "CVE-2013-4835": {"epss_score": 0.78003, "epss_percentile": 0.98965}, "CVE-2013-4836": {"epss_score": 0.05517, "epss_percentile": 0.89951}, "CVE-2013-4837": {"epss_score": 0.756, "epss_percentile": 0.98858}, "CVE-2013-4838": {"epss_score": 0.3292, "epss_percentile": 0.96736}, "CVE-2013-4839": {"epss_score": 0.01251, "epss_percentile": 0.78895}, "CVE-2013-4840": {"epss_score": 0.01441, "epss_percentile": 0.80305}, "CVE-2013-4841": {"epss_score": 0.28401, "epss_percentile": 0.96353}, "CVE-2013-4842": {"epss_score": 0.00865, "epss_percentile": 0.74618}, "CVE-2013-4843": {"epss_score": 0.00272, "epss_percentile": 0.50365}, "CVE-2013-4844": {"epss_score": 0.06377, "epss_percentile": 0.90708}, "CVE-2013-4845": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2013-4846": {"epss_score": 0.00647, "epss_percentile": 0.70173}, "CVE-2013-4848": {"epss_score": 0.00227, "epss_percentile": 0.45447}, "CVE-2013-4851": {"epss_score": 0.00207, "epss_percentile": 0.43092}, "CVE-2013-4852": {"epss_score": 0.01751, "epss_percentile": 0.82102}, "CVE-2013-4854": {"epss_score": 0.53697, "epss_percentile": 0.97893}, "CVE-2013-4855": {"epss_score": 0.00248, "epss_percentile": 0.47925}, "CVE-2013-4856": {"epss_score": 0.00189, "epss_percentile": 0.40986}, "CVE-2013-4857": {"epss_score": 0.01172, "epss_percentile": 0.78226}, "CVE-2013-4858": {"epss_score": 0.25398, "epss_percentile": 0.96024}, "CVE-2013-4859": {"epss_score": 0.08601, "epss_percentile": 0.92144}, "CVE-2013-4860": {"epss_score": 0.00401, "epss_percentile": 0.60202}, "CVE-2013-4861": {"epss_score": 0.14561, "epss_percentile": 0.94241}, "CVE-2013-4862": {"epss_score": 0.07944, "epss_percentile": 0.91781}, "CVE-2013-4863": {"epss_score": 0.29409, "epss_percentile": 0.9644}, "CVE-2013-4864": {"epss_score": 0.30461, "epss_percentile": 0.96542}, "CVE-2013-4865": {"epss_score": 0.00157, "epss_percentile": 0.37125}, "CVE-2013-4866": {"epss_score": 0.00145, "epss_percentile": 0.35398}, "CVE-2013-4867": {"epss_score": 0.01032, "epss_percentile": 0.76858}, "CVE-2013-4868": {"epss_score": 0.22154, "epss_percentile": 0.95602}, "CVE-2013-4869": {"epss_score": 0.00139, "epss_percentile": 0.34616}, "CVE-2013-4870": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2013-4871": {"epss_score": 0.00254, "epss_percentile": 0.48535}, "CVE-2013-4872": {"epss_score": 0.00022, "epss_percentile": 0.05169}, "CVE-2013-4873": {"epss_score": 0.00384, "epss_percentile": 0.59166}, "CVE-2013-4874": {"epss_score": 0.00579, "epss_percentile": 0.68212}, "CVE-2013-4875": {"epss_score": 0.00193, "epss_percentile": 0.41457}, "CVE-2013-4876": {"epss_score": 0.00257, "epss_percentile": 0.48922}, "CVE-2013-4877": {"epss_score": 0.00896, "epss_percentile": 0.75116}, "CVE-2013-4878": {"epss_score": 0.17235, "epss_percentile": 0.94803}, "CVE-2013-4879": {"epss_score": 0.01114, "epss_percentile": 0.77701}, "CVE-2013-4880": {"epss_score": 0.04522, "epss_percentile": 0.88802}, "CVE-2013-4881": {"epss_score": 0.00332, "epss_percentile": 0.55598}, "CVE-2013-4882": {"epss_score": 0.01098, "epss_percentile": 0.7754}, "CVE-2013-4883": {"epss_score": 0.03424, "epss_percentile": 0.87111}, "CVE-2013-4884": {"epss_score": 0.02637, "epss_percentile": 0.85296}, "CVE-2013-4885": {"epss_score": 0.06429, "epss_percentile": 0.90754}, "CVE-2013-4887": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2013-4888": {"epss_score": 0.00387, "epss_percentile": 0.59296}, "CVE-2013-4889": {"epss_score": 0.00229, "epss_percentile": 0.45653}, "CVE-2013-4890": {"epss_score": 0.13481, "epss_percentile": 0.93977}, "CVE-2013-4891": {"epss_score": 0.00266, "epss_percentile": 0.49872}, "CVE-2013-4898": {"epss_score": 0.04262, "epss_percentile": 0.88464}, "CVE-2013-4899": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2013-4900": {"epss_score": 0.20351, "epss_percentile": 0.95329}, "CVE-2013-4911": {"epss_score": 0.00285, "epss_percentile": 0.51501}, "CVE-2013-4912": {"epss_score": 0.00532, "epss_percentile": 0.667}, "CVE-2013-4920": {"epss_score": 0.00349, "epss_percentile": 0.56867}, "CVE-2013-4921": {"epss_score": 0.01075, "epss_percentile": 0.77312}, "CVE-2013-4922": {"epss_score": 0.00739, "epss_percentile": 0.72393}, "CVE-2013-4923": {"epss_score": 0.00739, "epss_percentile": 0.72393}, "CVE-2013-4924": {"epss_score": 0.01075, "epss_percentile": 0.77312}, "CVE-2013-4925": {"epss_score": 0.01075, "epss_percentile": 0.77312}, "CVE-2013-4926": {"epss_score": 0.01075, "epss_percentile": 0.77312}, "CVE-2013-4927": {"epss_score": 0.01815, "epss_percentile": 0.82382}, "CVE-2013-4928": {"epss_score": 0.0129, "epss_percentile": 0.79215}, "CVE-2013-4929": {"epss_score": 0.01779, "epss_percentile": 0.82231}, "CVE-2013-4930": {"epss_score": 0.0115, "epss_percentile": 0.78023}, "CVE-2013-4931": {"epss_score": 0.01503, "epss_percentile": 0.80729}, "CVE-2013-4932": {"epss_score": 0.01503, "epss_percentile": 0.80729}, "CVE-2013-4933": {"epss_score": 0.01503, "epss_percentile": 0.80729}, "CVE-2013-4934": {"epss_score": 0.01435, "epss_percentile": 0.80271}, "CVE-2013-4935": {"epss_score": 0.01435, "epss_percentile": 0.80271}, "CVE-2013-4936": {"epss_score": 0.01075, "epss_percentile": 0.77312}, "CVE-2013-4937": {"epss_score": 0.00532, "epss_percentile": 0.66694}, "CVE-2013-4938": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-4939": {"epss_score": 0.0031, "epss_percentile": 0.53805}, "CVE-2013-4940": {"epss_score": 0.00344, "epss_percentile": 0.56529}, "CVE-2013-4941": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2013-4942": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2013-4943": {"epss_score": 0.00043, "epss_percentile": 0.13237}, "CVE-2013-4944": {"epss_score": 0.00264, "epss_percentile": 0.49713}, "CVE-2013-4945": {"epss_score": 0.00379, "epss_percentile": 0.58859}, "CVE-2013-4946": {"epss_score": 0.00642, "epss_percentile": 0.7004}, "CVE-2013-4947": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2013-4948": {"epss_score": 0.00519, "epss_percentile": 0.66169}, "CVE-2013-4949": {"epss_score": 0.08912, "epss_percentile": 0.92315}, "CVE-2013-4950": {"epss_score": 0.0373, "epss_percentile": 0.87641}, "CVE-2013-4951": {"epss_score": 0.00634, "epss_percentile": 0.698}, "CVE-2013-4952": {"epss_score": 0.00472, "epss_percentile": 0.6406}, "CVE-2013-4953": {"epss_score": 0.00205, "epss_percentile": 0.42744}, "CVE-2013-4954": {"epss_score": 0.04917, "epss_percentile": 0.89288}, "CVE-2013-4955": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2013-4956": {"epss_score": 0.00108, "epss_percentile": 0.29834}, "CVE-2013-4957": {"epss_score": 0.00429, "epss_percentile": 0.61971}, "CVE-2013-4958": {"epss_score": 0.00041, "epss_percentile": 0.12374}, "CVE-2013-4959": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2013-4961": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-4962": {"epss_score": 0.0035, "epss_percentile": 0.5698}, "CVE-2013-4963": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2013-4964": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2013-4965": {"epss_score": 0.00721, "epss_percentile": 0.71979}, "CVE-2013-4966": {"epss_score": 0.00223, "epss_percentile": 0.44967}, "CVE-2013-4967": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-4968": {"epss_score": 0.00327, "epss_percentile": 0.551}, "CVE-2013-4969": {"epss_score": 0.00038, "epss_percentile": 0.11302}, "CVE-2013-4971": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-4973": {"epss_score": 0.11834, "epss_percentile": 0.9349}, "CVE-2013-4974": {"epss_score": 0.04931, "epss_percentile": 0.89298}, "CVE-2013-4975": {"epss_score": 0.14469, "epss_percentile": 0.94219}, "CVE-2013-4976": {"epss_score": 0.08264, "epss_percentile": 0.91957}, "CVE-2013-4977": {"epss_score": 0.50213, "epss_percentile": 0.97727}, "CVE-2013-4978": {"epss_score": 0.33144, "epss_percentile": 0.96749}, "CVE-2013-4979": {"epss_score": 0.11711, "epss_percentile": 0.93457}, "CVE-2013-4980": {"epss_score": 0.26801, "epss_percentile": 0.96182}, "CVE-2013-4981": {"epss_score": 0.26801, "epss_percentile": 0.96182}, "CVE-2013-4982": {"epss_score": 0.39617, "epss_percentile": 0.97171}, "CVE-2013-4983": {"epss_score": 0.92719, "epss_percentile": 0.99738}, "CVE-2013-4984": {"epss_score": 0.07766, "epss_percentile": 0.9167}, "CVE-2013-4985": {"epss_score": 0.08757, "epss_percentile": 0.92243}, "CVE-2013-4986": {"epss_score": 0.08036, "epss_percentile": 0.91846}, "CVE-2013-4987": {"epss_score": 0.11231, "epss_percentile": 0.93271}, "CVE-2013-4988": {"epss_score": 0.81145, "epss_percentile": 0.99123}, "CVE-2013-4995": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2013-4996": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2013-4997": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-4998": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-4999": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-5000": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-5001": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-5002": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2013-5003": {"epss_score": 0.00374, "epss_percentile": 0.58529}, "CVE-2013-5005": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-5006": {"epss_score": 0.08274, "epss_percentile": 0.91963}, "CVE-2013-5008": {"epss_score": 0.00037, "epss_percentile": 0.10983}, "CVE-2013-5009": {"epss_score": 0.00302, "epss_percentile": 0.53157}, "CVE-2013-5010": {"epss_score": 0.00072, "epss_percentile": 0.22389}, "CVE-2013-5011": {"epss_score": 0.00048, "epss_percentile": 0.15174}, "CVE-2013-5012": {"epss_score": 0.00434, "epss_percentile": 0.62297}, "CVE-2013-5013": {"epss_score": 0.00606, "epss_percentile": 0.69004}, "CVE-2013-5014": {"epss_score": 0.86196, "epss_percentile": 0.99372}, "CVE-2013-5015": {"epss_score": 0.74049, "epss_percentile": 0.98786}, "CVE-2013-5016": {"epss_score": 0.01379, "epss_percentile": 0.79851}, "CVE-2013-5017": {"epss_score": 0.2387, "epss_percentile": 0.95827}, "CVE-2013-5018": {"epss_score": 0.02902, "epss_percentile": 0.85955}, "CVE-2013-5019": {"epss_score": 0.81769, "epss_percentile": 0.99155}, "CVE-2013-5020": {"epss_score": 0.00795, "epss_percentile": 0.73477}, "CVE-2013-5021": {"epss_score": 0.00739, "epss_percentile": 0.72393}, "CVE-2013-5022": {"epss_score": 0.01404, "epss_percentile": 0.80039}, "CVE-2013-5023": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2013-5024": {"epss_score": 0.00307, "epss_percentile": 0.53474}, "CVE-2013-5025": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2013-5026": {"epss_score": 0.04422, "epss_percentile": 0.88671}, "CVE-2013-5027": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2013-5028": {"epss_score": 0.00459, "epss_percentile": 0.63459}, "CVE-2013-5029": {"epss_score": 0.01725, "epss_percentile": 0.81957}, "CVE-2013-5030": {"epss_score": 0.00984, "epss_percentile": 0.76311}, "CVE-2013-5031": {"epss_score": 0.00382, "epss_percentile": 0.59042}, "CVE-2013-5032": {"epss_score": 0.00382, "epss_percentile": 0.59042}, "CVE-2013-5033": {"epss_score": 0.00382, "epss_percentile": 0.59042}, "CVE-2013-5034": {"epss_score": 0.00382, "epss_percentile": 0.59042}, "CVE-2013-5035": {"epss_score": 0.00132, "epss_percentile": 0.33601}, "CVE-2013-5036": {"epss_score": 0.80499, "epss_percentile": 0.99092}, "CVE-2013-5037": {"epss_score": 0.01573, "epss_percentile": 0.81098}, "CVE-2013-5038": {"epss_score": 0.00461, "epss_percentile": 0.63537}, "CVE-2013-5039": {"epss_score": 0.00241, "epss_percentile": 0.47276}, "CVE-2013-5042": {"epss_score": 0.10414, "epss_percentile": 0.9298}, "CVE-2013-5045": {"epss_score": 0.24226, "epss_percentile": 0.95894}, "CVE-2013-5046": {"epss_score": 0.02565, "epss_percentile": 0.85116}, "CVE-2013-5047": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2013-5048": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2013-5049": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2013-5051": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2013-5052": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2013-5054": {"epss_score": 0.11415, "epss_percentile": 0.93342}, "CVE-2013-5056": {"epss_score": 0.33612, "epss_percentile": 0.96788}, "CVE-2013-5057": {"epss_score": 0.14803, "epss_percentile": 0.94288}, "CVE-2013-5058": {"epss_score": 0.02345, "epss_percentile": 0.8445}, "CVE-2013-5059": {"epss_score": 0.122, "epss_percentile": 0.936}, "CVE-2013-5065": {"epss_score": 0.63758, "epss_percentile": 0.98348}, "CVE-2013-5072": {"epss_score": 0.06639, "epss_percentile": 0.9091}, "CVE-2013-5091": {"epss_score": 0.00353, "epss_percentile": 0.57157}, "CVE-2013-5092": {"epss_score": 0.03547, "epss_percentile": 0.87331}, "CVE-2013-5093": {"epss_score": 0.83612, "epss_percentile": 0.99255}, "CVE-2013-5094": {"epss_score": 0.03752, "epss_percentile": 0.87677}, "CVE-2013-5095": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-5096": {"epss_score": 0.00193, "epss_percentile": 0.41427}, "CVE-2013-5097": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2013-5098": {"epss_score": 0.00287, "epss_percentile": 0.51792}, "CVE-2013-5099": {"epss_score": 0.02811, "epss_percentile": 0.85723}, "CVE-2013-5100": {"epss_score": 0.00521, "epss_percentile": 0.66218}, "CVE-2013-5106": {"epss_score": 0.00591, "epss_percentile": 0.68595}, "CVE-2013-5107": {"epss_score": 0.00115, "epss_percentile": 0.30939}, "CVE-2013-5108": {"epss_score": 0.00938, "epss_percentile": 0.75704}, "CVE-2013-5112": {"epss_score": 0.00103, "epss_percentile": 0.28978}, "CVE-2013-5113": {"epss_score": 0.00117, "epss_percentile": 0.31342}, "CVE-2013-5114": {"epss_score": 0.0011, "epss_percentile": 0.30179}, "CVE-2013-5116": {"epss_score": 0.00087, "epss_percentile": 0.25484}, "CVE-2013-5117": {"epss_score": 0.01444, "epss_percentile": 0.8032}, "CVE-2013-5118": {"epss_score": 0.00406, "epss_percentile": 0.6055}, "CVE-2013-5119": {"epss_score": 0.00265, "epss_percentile": 0.49823}, "CVE-2013-5120": {"epss_score": 0.00497, "epss_percentile": 0.65198}, "CVE-2013-5121": {"epss_score": 0.00497, "epss_percentile": 0.65198}, "CVE-2013-5122": {"epss_score": 0.04105, "epss_percentile": 0.88266}, "CVE-2013-5123": {"epss_score": 0.14196, "epss_percentile": 0.9416}, "CVE-2013-5125": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2013-5126": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2013-5127": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2013-5128": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2013-5129": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2013-5130": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2013-5131": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2013-5132": {"epss_score": 0.00428, "epss_percentile": 0.61926}, "CVE-2013-5133": {"epss_score": 0.00559, "epss_percentile": 0.67602}, "CVE-2013-5135": {"epss_score": 0.03044, "epss_percentile": 0.86278}, "CVE-2013-5136": {"epss_score": 0.00265, "epss_percentile": 0.4983}, "CVE-2013-5137": {"epss_score": 0.00371, "epss_percentile": 0.58344}, "CVE-2013-5138": {"epss_score": 0.00051, "epss_percentile": 0.16054}, "CVE-2013-5139": {"epss_score": 0.01166, "epss_percentile": 0.78181}, "CVE-2013-5140": {"epss_score": 0.0066, "epss_percentile": 0.70534}, "CVE-2013-5141": {"epss_score": 0.00496, "epss_percentile": 0.65169}, "CVE-2013-5142": {"epss_score": 0.00061, "epss_percentile": 0.19511}, "CVE-2013-5143": {"epss_score": 0.00188, "epss_percentile": 0.40917}, "CVE-2013-5144": {"epss_score": 0.00055, "epss_percentile": 0.17575}, "CVE-2013-5145": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2013-5147": {"epss_score": 0.0048, "epss_percentile": 0.64468}, "CVE-2013-5148": {"epss_score": 0.00049, "epss_percentile": 0.15303}, "CVE-2013-5149": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2013-5150": {"epss_score": 0.00073, "epss_percentile": 0.22661}, "CVE-2013-5151": {"epss_score": 0.00301, "epss_percentile": 0.53047}, "CVE-2013-5152": {"epss_score": 0.00366, "epss_percentile": 0.58049}, "CVE-2013-5153": {"epss_score": 0.00069, "epss_percentile": 0.21531}, "CVE-2013-5154": {"epss_score": 0.00291, "epss_percentile": 0.52207}, "CVE-2013-5155": {"epss_score": 0.00458, "epss_percentile": 0.63398}, "CVE-2013-5156": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2013-5157": {"epss_score": 0.00291, "epss_percentile": 0.52207}, "CVE-2013-5158": {"epss_score": 0.00068, "epss_percentile": 0.2136}, "CVE-2013-5159": {"epss_score": 0.00285, "epss_percentile": 0.51647}, "CVE-2013-5160": {"epss_score": 0.00048, "epss_percentile": 0.1513}, "CVE-2013-5161": {"epss_score": 0.00052, "epss_percentile": 0.16667}, "CVE-2013-5162": {"epss_score": 0.00057, "epss_percentile": 0.18088}, "CVE-2013-5163": {"epss_score": 0.00041, "epss_percentile": 0.1226}, "CVE-2013-5164": {"epss_score": 0.00047, "epss_percentile": 0.14927}, "CVE-2013-5165": {"epss_score": 0.00178, "epss_percentile": 0.39713}, "CVE-2013-5166": {"epss_score": 0.00057, "epss_percentile": 0.18203}, "CVE-2013-5167": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2013-5168": {"epss_score": 0.0043, "epss_percentile": 0.62018}, "CVE-2013-5169": {"epss_score": 0.00063, "epss_percentile": 0.19977}, "CVE-2013-5170": {"epss_score": 0.01418, "epss_percentile": 0.80159}, "CVE-2013-5171": {"epss_score": 0.00054, "epss_percentile": 0.17366}, "CVE-2013-5172": {"epss_score": 0.00349, "epss_percentile": 0.56879}, "CVE-2013-5173": {"epss_score": 0.00051, "epss_percentile": 0.16155}, "CVE-2013-5174": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2013-5175": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2013-5176": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2013-5177": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2013-5178": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2013-5179": {"epss_score": 0.0035, "epss_percentile": 0.5698}, "CVE-2013-5180": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2013-5181": {"epss_score": 0.00265, "epss_percentile": 0.4983}, "CVE-2013-5182": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2013-5183": {"epss_score": 0.00275, "epss_percentile": 0.50686}, "CVE-2013-5184": {"epss_score": 0.00196, "epss_percentile": 0.41771}, "CVE-2013-5185": {"epss_score": 0.00134, "epss_percentile": 0.33927}, "CVE-2013-5186": {"epss_score": 0.00063, "epss_percentile": 0.19977}, "CVE-2013-5187": {"epss_score": 0.00063, "epss_percentile": 0.19977}, "CVE-2013-5188": {"epss_score": 0.00063, "epss_percentile": 0.19977}, "CVE-2013-5189": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2013-5190": {"epss_score": 0.00238, "epss_percentile": 0.4682}, "CVE-2013-5191": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2013-5192": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2013-5193": {"epss_score": 0.00048, "epss_percentile": 0.1504}, "CVE-2013-5195": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2013-5196": {"epss_score": 0.02121, "epss_percentile": 0.83678}, "CVE-2013-5197": {"epss_score": 0.02121, "epss_percentile": 0.83678}, "CVE-2013-5198": {"epss_score": 0.02121, "epss_percentile": 0.83678}, "CVE-2013-5199": {"epss_score": 0.02764, "epss_percentile": 0.85608}, "CVE-2013-5200": {"epss_score": 0.00514, "epss_percentile": 0.65953}, "CVE-2013-5208": {"epss_score": 0.0004, "epss_percentile": 0.12182}, "CVE-2013-5209": {"epss_score": 0.00626, "epss_percentile": 0.69604}, "CVE-2013-5210": {"epss_score": 0.00232, "epss_percentile": 0.45908}, "CVE-2013-5211": {"epss_score": 0.92177, "epss_percentile": 0.99696}, "CVE-2013-5212": {"epss_score": 0.00297, "epss_percentile": 0.52689}, "CVE-2013-5215": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2013-5216": {"epss_score": 0.00529, "epss_percentile": 0.66583}, "CVE-2013-5218": {"epss_score": 0.01129, "epss_percentile": 0.77838}, "CVE-2013-5219": {"epss_score": 0.03615, "epss_percentile": 0.87435}, "CVE-2013-5220": {"epss_score": 0.01208, "epss_percentile": 0.78531}, "CVE-2013-5221": {"epss_score": 0.00187, "epss_percentile": 0.40721}, "CVE-2013-5222": {"epss_score": 0.00173, "epss_percentile": 0.3909}, "CVE-2013-5223": {"epss_score": 0.35461, "epss_percentile": 0.96911}, "CVE-2013-5225": {"epss_score": 0.02121, "epss_percentile": 0.83678}, "CVE-2013-5227": {"epss_score": 0.00576, "epss_percentile": 0.6814}, "CVE-2013-5228": {"epss_score": 0.02121, "epss_percentile": 0.83678}, "CVE-2013-5229": {"epss_score": 0.00066, "epss_percentile": 0.20768}, "CVE-2013-5300": {"epss_score": 0.00686, "epss_percentile": 0.71164}, "CVE-2013-5301": {"epss_score": 0.0023, "epss_percentile": 0.45763}, "CVE-2013-5302": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2013-5303": {"epss_score": 0.01093, "epss_percentile": 0.77478}, "CVE-2013-5304": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2013-5305": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2013-5306": {"epss_score": 0.00422, "epss_percentile": 0.6154}, "CVE-2013-5307": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2013-5308": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-5309": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-5310": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2013-5311": {"epss_score": 0.00501, "epss_percentile": 0.65335}, "CVE-2013-5312": {"epss_score": 0.06262, "epss_percentile": 0.90622}, "CVE-2013-5313": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2013-5314": {"epss_score": 0.00421, "epss_percentile": 0.61531}, "CVE-2013-5315": {"epss_score": 0.00727, "epss_percentile": 0.72089}, "CVE-2013-5316": {"epss_score": 0.00256, "epss_percentile": 0.48832}, "CVE-2013-5317": {"epss_score": 0.00405, "epss_percentile": 0.60457}, "CVE-2013-5318": {"epss_score": 0.00215, "epss_percentile": 0.44029}, "CVE-2013-5319": {"epss_score": 0.00508, "epss_percentile": 0.65715}, "CVE-2013-5320": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2013-5321": {"epss_score": 0.00367, "epss_percentile": 0.58103}, "CVE-2013-5322": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2013-5323": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2013-5324": {"epss_score": 0.11531, "epss_percentile": 0.93396}, "CVE-2013-5325": {"epss_score": 0.00832, "epss_percentile": 0.74066}, "CVE-2013-5326": {"epss_score": 0.00493, "epss_percentile": 0.65033}, "CVE-2013-5327": {"epss_score": 0.10796, "epss_percentile": 0.93106}, "CVE-2013-5328": {"epss_score": 0.00955, "epss_percentile": 0.75915}, "CVE-2013-5329": {"epss_score": 0.11531, "epss_percentile": 0.93396}, "CVE-2013-5330": {"epss_score": 0.02947, "epss_percentile": 0.86043}, "CVE-2013-5331": {"epss_score": 0.8737, "epss_percentile": 0.99426}, "CVE-2013-5332": {"epss_score": 0.07428, "epss_percentile": 0.9147}, "CVE-2013-5333": {"epss_score": 0.08291, "epss_percentile": 0.91974}, "CVE-2013-5334": {"epss_score": 0.08291, "epss_percentile": 0.91974}, "CVE-2013-5349": {"epss_score": 0.02556, "epss_percentile": 0.85094}, "CVE-2013-5350": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2013-5351": {"epss_score": 0.05519, "epss_percentile": 0.89955}, "CVE-2013-5352": {"epss_score": 0.01028, "epss_percentile": 0.76822}, "CVE-2013-5353": {"epss_score": 0.01621, "epss_percentile": 0.81387}, "CVE-2013-5354": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2013-5355": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2013-5356": {"epss_score": 0.00499, "epss_percentile": 0.6527}, "CVE-2013-5357": {"epss_score": 0.02556, "epss_percentile": 0.85094}, "CVE-2013-5358": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2013-5359": {"epss_score": 0.02556, "epss_percentile": 0.85094}, "CVE-2013-5364": {"epss_score": 0.00065, "epss_percentile": 0.20617}, "CVE-2013-5365": {"epss_score": 0.06184, "epss_percentile": 0.90541}, "CVE-2013-5369": {"epss_score": 0.08918, "epss_percentile": 0.92318}, "CVE-2013-5370": {"epss_score": 0.16618, "epss_percentile": 0.94704}, "CVE-2013-5371": {"epss_score": 0.00041, "epss_percentile": 0.12389}, "CVE-2013-5372": {"epss_score": 0.01728, "epss_percentile": 0.81973}, "CVE-2013-5373": {"epss_score": 0.00035, "epss_percentile": 0.09904}, "CVE-2013-5375": {"epss_score": 0.0186, "epss_percentile": 0.82586}, "CVE-2013-5376": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-5378": {"epss_score": 0.00208, "epss_percentile": 0.43262}, "CVE-2013-5379": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2013-5380": {"epss_score": 0.00063, "epss_percentile": 0.19828}, "CVE-2013-5381": {"epss_score": 0.00513, "epss_percentile": 0.65929}, "CVE-2013-5382": {"epss_score": 0.00226, "epss_percentile": 0.45276}, "CVE-2013-5383": {"epss_score": 0.00226, "epss_percentile": 0.45276}, "CVE-2013-5385": {"epss_score": 0.06492, "epss_percentile": 0.90797}, "CVE-2013-5387": {"epss_score": 0.00658, "epss_percentile": 0.70493}, "CVE-2013-5388": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-5389": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-5390": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2013-5391": {"epss_score": 0.00197, "epss_percentile": 0.419}, "CVE-2013-5393": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2013-5394": {"epss_score": 0.0016, "epss_percentile": 0.37441}, "CVE-2013-5395": {"epss_score": 0.0033, "epss_percentile": 0.55482}, "CVE-2013-5397": {"epss_score": 0.0011, "epss_percentile": 0.30174}, "CVE-2013-5398": {"epss_score": 0.0011, "epss_percentile": 0.30174}, "CVE-2013-5400": {"epss_score": 0.02665, "epss_percentile": 0.85376}, "CVE-2013-5401": {"epss_score": 0.00527, "epss_percentile": 0.66445}, "CVE-2013-5402": {"epss_score": 0.0018, "epss_percentile": 0.39969}, "CVE-2013-5403": {"epss_score": 0.01888, "epss_percentile": 0.82719}, "CVE-2013-5404": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-5405": {"epss_score": 0.0018, "epss_percentile": 0.39969}, "CVE-2013-5406": {"epss_score": 0.0018, "epss_percentile": 0.39969}, "CVE-2013-5407": {"epss_score": 0.00154, "epss_percentile": 0.3668}, "CVE-2013-5409": {"epss_score": 0.00314, "epss_percentile": 0.54095}, "CVE-2013-5411": {"epss_score": 0.00246, "epss_percentile": 0.47798}, "CVE-2013-5413": {"epss_score": 0.00265, "epss_percentile": 0.4984}, "CVE-2013-5414": {"epss_score": 0.0016, "epss_percentile": 0.37441}, "CVE-2013-5415": {"epss_score": 0.00049, "epss_percentile": 0.15356}, "CVE-2013-5416": {"epss_score": 0.00046, "epss_percentile": 0.14273}, "CVE-2013-5417": {"epss_score": 0.00265, "epss_percentile": 0.49789}, "CVE-2013-5418": {"epss_score": 0.00162, "epss_percentile": 0.37634}, "CVE-2013-5419": {"epss_score": 0.00052, "epss_percentile": 0.16672}, "CVE-2013-5420": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2013-5421": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-5422": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2013-5423": {"epss_score": 0.00321, "epss_percentile": 0.54677}, "CVE-2013-5424": {"epss_score": 0.00254, "epss_percentile": 0.48504}, "CVE-2013-5425": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2013-5426": {"epss_score": 0.00118, "epss_percentile": 0.31462}, "CVE-2013-5427": {"epss_score": 0.00103, "epss_percentile": 0.28976}, "CVE-2013-5428": {"epss_score": 0.00603, "epss_percentile": 0.68902}, "CVE-2013-5429": {"epss_score": 0.0018, "epss_percentile": 0.39924}, "CVE-2013-5430": {"epss_score": 0.00154, "epss_percentile": 0.36652}, "CVE-2013-5431": {"epss_score": 0.00509, "epss_percentile": 0.65754}, "CVE-2013-5433": {"epss_score": 0.00255, "epss_percentile": 0.48652}, "CVE-2013-5438": {"epss_score": 0.00289, "epss_percentile": 0.52034}, "CVE-2013-5440": {"epss_score": 0.00054, "epss_percentile": 0.17362}, "CVE-2013-5442": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-5443": {"epss_score": 0.00103, "epss_percentile": 0.28976}, "CVE-2013-5444": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2013-5445": {"epss_score": 0.0021, "epss_percentile": 0.43453}, "CVE-2013-5446": {"epss_score": 0.00469, "epss_percentile": 0.63946}, "CVE-2013-5447": {"epss_score": 0.69326, "epss_percentile": 0.98583}, "CVE-2013-5448": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2013-5449": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2013-5450": {"epss_score": 0.00198, "epss_percentile": 0.41983}, "CVE-2013-5452": {"epss_score": 0.00295, "epss_percentile": 0.52446}, "CVE-2013-5453": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2013-5454": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2013-5455": {"epss_score": 0.00327, "epss_percentile": 0.55108}, "CVE-2013-5456": {"epss_score": 0.01804, "epss_percentile": 0.82343}, "CVE-2013-5457": {"epss_score": 0.06261, "epss_percentile": 0.9062}, "CVE-2013-5458": {"epss_score": 0.05606, "epss_percentile": 0.90043}, "CVE-2013-5459": {"epss_score": 0.00349, "epss_percentile": 0.56905}, "CVE-2013-5460": {"epss_score": 0.00159, "epss_percentile": 0.37303}, "CVE-2013-5461": {"epss_score": 0.00322, "epss_percentile": 0.54792}, "CVE-2013-5462": {"epss_score": 0.00246, "epss_percentile": 0.47798}, "CVE-2013-5463": {"epss_score": 0.00205, "epss_percentile": 0.42672}, "CVE-2013-5464": {"epss_score": 0.00216, "epss_percentile": 0.44157}, "CVE-2013-5465": {"epss_score": 0.00394, "epss_percentile": 0.59797}, "CVE-2013-5466": {"epss_score": 0.01038, "epss_percentile": 0.7694}, "CVE-2013-5467": {"epss_score": 0.00337, "epss_percentile": 0.56012}, "CVE-2013-5468": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2013-5469": {"epss_score": 0.00746, "epss_percentile": 0.72552}, "CVE-2013-5470": {"epss_score": 0.00687, "epss_percentile": 0.71179}, "CVE-2013-5471": {"epss_score": 0.00184, "epss_percentile": 0.40381}, "CVE-2013-5472": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2013-5473": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-5474": {"epss_score": 0.0033, "epss_percentile": 0.55497}, "CVE-2013-5475": {"epss_score": 0.00316, "epss_percentile": 0.54277}, "CVE-2013-5476": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-5477": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-5478": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-5479": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-5480": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-5481": {"epss_score": 0.00548, "epss_percentile": 0.6729}, "CVE-2013-5482": {"epss_score": 0.00217, "epss_percentile": 0.44296}, "CVE-2013-5483": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2013-5486": {"epss_score": 0.88677, "epss_percentile": 0.99483}, "CVE-2013-5487": {"epss_score": 0.00377, "epss_percentile": 0.5872}, "CVE-2013-5488": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2013-5489": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2013-5490": {"epss_score": 0.00615, "epss_percentile": 0.69315}, "CVE-2013-5492": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-5493": {"epss_score": 0.00084, "epss_percentile": 0.24908}, "CVE-2013-5494": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2013-5495": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-5496": {"epss_score": 0.002, "epss_percentile": 0.42212}, "CVE-2013-5497": {"epss_score": 0.01185, "epss_percentile": 0.78341}, "CVE-2013-5498": {"epss_score": 0.01289, "epss_percentile": 0.79212}, "CVE-2013-5499": {"epss_score": 0.0017, "epss_percentile": 0.38729}, "CVE-2013-5500": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-5501": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-5502": {"epss_score": 0.00282, "epss_percentile": 0.51281}, "CVE-2013-5503": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-5504": {"epss_score": 0.00561, "epss_percentile": 0.67676}, "CVE-2013-5505": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2013-5506": {"epss_score": 0.0008, "epss_percentile": 0.24167}, "CVE-2013-5507": {"epss_score": 0.00579, "epss_percentile": 0.68215}, "CVE-2013-5508": {"epss_score": 0.00444, "epss_percentile": 0.62847}, "CVE-2013-5509": {"epss_score": 0.01392, "epss_percentile": 0.79961}, "CVE-2013-5510": {"epss_score": 0.00153, "epss_percentile": 0.3662}, "CVE-2013-5511": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2013-5512": {"epss_score": 0.00111, "epss_percentile": 0.30335}, "CVE-2013-5513": {"epss_score": 0.00191, "epss_percentile": 0.41173}, "CVE-2013-5515": {"epss_score": 0.00283, "epss_percentile": 0.51402}, "CVE-2013-5516": {"epss_score": 0.00479, "epss_percentile": 0.64437}, "CVE-2013-5517": {"epss_score": 0.00359, "epss_percentile": 0.57592}, "CVE-2013-5519": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2013-5521": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-5522": {"epss_score": 0.0008, "epss_percentile": 0.24167}, "CVE-2013-5523": {"epss_score": 0.00545, "epss_percentile": 0.67161}, "CVE-2013-5524": {"epss_score": 0.00561, "epss_percentile": 0.67676}, "CVE-2013-5525": {"epss_score": 0.0076, "epss_percentile": 0.72803}, "CVE-2013-5526": {"epss_score": 0.00774, "epss_percentile": 0.7307}, "CVE-2013-5527": {"epss_score": 0.00474, "epss_percentile": 0.64148}, "CVE-2013-5528": {"epss_score": 0.61502, "epss_percentile": 0.98251}, "CVE-2013-5529": {"epss_score": 0.00396, "epss_percentile": 0.599}, "CVE-2013-5530": {"epss_score": 0.00163, "epss_percentile": 0.37859}, "CVE-2013-5531": {"epss_score": 0.00248, "epss_percentile": 0.47997}, "CVE-2013-5532": {"epss_score": 0.0081, "epss_percentile": 0.73713}, "CVE-2013-5533": {"epss_score": 0.00258, "epss_percentile": 0.48966}, "CVE-2013-5534": {"epss_score": 0.00223, "epss_percentile": 0.44856}, "CVE-2013-5535": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2013-5536": {"epss_score": 0.00438, "epss_percentile": 0.62545}, "CVE-2013-5537": {"epss_score": 0.00393, "epss_percentile": 0.59734}, "CVE-2013-5538": {"epss_score": 0.0019, "epss_percentile": 0.41006}, "CVE-2013-5539": {"epss_score": 0.00366, "epss_percentile": 0.58066}, "CVE-2013-5540": {"epss_score": 0.00363, "epss_percentile": 0.57874}, "CVE-2013-5541": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2013-5542": {"epss_score": 0.00826, "epss_percentile": 0.7396}, "CVE-2013-5543": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-5544": {"epss_score": 0.01339, "epss_percentile": 0.79572}, "CVE-2013-5545": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-5546": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-5547": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-5548": {"epss_score": 0.00397, "epss_percentile": 0.59967}, "CVE-2013-5549": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2013-5550": {"epss_score": 0.00082, "epss_percentile": 0.24488}, "CVE-2013-5551": {"epss_score": 0.01179, "epss_percentile": 0.7829}, "CVE-2013-5552": {"epss_score": 0.00155, "epss_percentile": 0.36824}, "CVE-2013-5553": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2013-5554": {"epss_score": 0.00239, "epss_percentile": 0.46856}, "CVE-2013-5555": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2013-5556": {"epss_score": 0.00083, "epss_percentile": 0.2482}, "CVE-2013-5557": {"epss_score": 0.00345, "epss_percentile": 0.56601}, "CVE-2013-5558": {"epss_score": 0.01135, "epss_percentile": 0.77908}, "CVE-2013-5559": {"epss_score": 0.01865, "epss_percentile": 0.82604}, "CVE-2013-5560": {"epss_score": 0.00218, "epss_percentile": 0.44436}, "CVE-2013-5561": {"epss_score": 0.00184, "epss_percentile": 0.40384}, "CVE-2013-5562": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2013-5563": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-5564": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-5565": {"epss_score": 0.00386, "epss_percentile": 0.59238}, "CVE-2013-5566": {"epss_score": 0.01141, "epss_percentile": 0.77958}, "CVE-2013-5567": {"epss_score": 0.01251, "epss_percentile": 0.78896}, "CVE-2013-5568": {"epss_score": 0.00347, "epss_percentile": 0.5679}, "CVE-2013-5569": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2013-5570": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2013-5571": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2013-5572": {"epss_score": 0.07821, "epss_percentile": 0.91698}, "CVE-2013-5573": {"epss_score": 0.02602, "epss_percentile": 0.85209}, "CVE-2013-5576": {"epss_score": 0.5212, "epss_percentile": 0.97808}, "CVE-2013-5578": {"epss_score": 0.34019, "epss_percentile": 0.96821}, "CVE-2013-5580": {"epss_score": 0.0084, "epss_percentile": 0.74211}, "CVE-2013-5582": {"epss_score": 0.03845, "epss_percentile": 0.8784}, "CVE-2013-5583": {"epss_score": 0.00023, "epss_percentile": 0.05333}, "CVE-2013-5586": {"epss_score": 0.00984, "epss_percentile": 0.76312}, "CVE-2013-5587": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2013-5588": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-5589": {"epss_score": 0.00417, "epss_percentile": 0.61233}, "CVE-2013-5590": {"epss_score": 0.02058, "epss_percentile": 0.83433}, "CVE-2013-5591": {"epss_score": 0.03454, "epss_percentile": 0.87171}, "CVE-2013-5592": {"epss_score": 0.02659, "epss_percentile": 0.85363}, "CVE-2013-5593": {"epss_score": 0.00483, "epss_percentile": 0.64574}, "CVE-2013-5594": {"epss_score": 0.00264, "epss_percentile": 0.4973}, "CVE-2013-5595": {"epss_score": 0.02577, "epss_percentile": 0.85146}, "CVE-2013-5596": {"epss_score": 0.01775, "epss_percentile": 0.82216}, "CVE-2013-5597": {"epss_score": 0.03629, "epss_percentile": 0.8747}, "CVE-2013-5598": {"epss_score": 0.00781, "epss_percentile": 0.73177}, "CVE-2013-5599": {"epss_score": 0.02688, "epss_percentile": 0.85434}, "CVE-2013-5600": {"epss_score": 0.02688, "epss_percentile": 0.85434}, "CVE-2013-5601": {"epss_score": 0.02688, "epss_percentile": 0.85434}, "CVE-2013-5602": {"epss_score": 0.03229, "epss_percentile": 0.86693}, "CVE-2013-5603": {"epss_score": 0.0527, "epss_percentile": 0.89679}, "CVE-2013-5604": {"epss_score": 0.06864, "epss_percentile": 0.91081}, "CVE-2013-5605": {"epss_score": 0.0279, "epss_percentile": 0.85666}, "CVE-2013-5606": {"epss_score": 0.00661, "epss_percentile": 0.70588}, "CVE-2013-5607": {"epss_score": 0.01591, "epss_percentile": 0.81222}, "CVE-2013-5609": {"epss_score": 0.02752, "epss_percentile": 0.85586}, "CVE-2013-5610": {"epss_score": 0.00881, "epss_percentile": 0.74865}, "CVE-2013-5611": {"epss_score": 0.01187, "epss_percentile": 0.78354}, "CVE-2013-5612": {"epss_score": 0.00739, "epss_percentile": 0.72392}, "CVE-2013-5613": {"epss_score": 0.11056, "epss_percentile": 0.93204}, "CVE-2013-5614": {"epss_score": 0.00279, "epss_percentile": 0.50982}, "CVE-2013-5615": {"epss_score": 0.02013, "epss_percentile": 0.83255}, "CVE-2013-5616": {"epss_score": 0.02874, "epss_percentile": 0.85881}, "CVE-2013-5618": {"epss_score": 0.10378, "epss_percentile": 0.92966}, "CVE-2013-5619": {"epss_score": 0.0173, "epss_percentile": 0.81989}, "CVE-2013-5634": {"epss_score": 0.00175, "epss_percentile": 0.39347}, "CVE-2013-5635": {"epss_score": 0.00035, "epss_percentile": 0.09917}, "CVE-2013-5636": {"epss_score": 0.00034, "epss_percentile": 0.09749}, "CVE-2013-5637": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2013-5638": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2013-5639": {"epss_score": 0.04589, "epss_percentile": 0.8889}, "CVE-2013-5640": {"epss_score": 0.0122, "epss_percentile": 0.7862}, "CVE-2013-5641": {"epss_score": 0.04098, "epss_percentile": 0.88256}, "CVE-2013-5642": {"epss_score": 0.05078, "epss_percentile": 0.8947}, "CVE-2013-5645": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2013-5646": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2013-5647": {"epss_score": 0.02724, "epss_percentile": 0.85525}, "CVE-2013-5648": {"epss_score": 0.006, "epss_percentile": 0.68812}, "CVE-2013-5649": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-5650": {"epss_score": 0.0069, "epss_percentile": 0.71238}, "CVE-2013-5651": {"epss_score": 0.00639, "epss_percentile": 0.6995}, "CVE-2013-5653": {"epss_score": 0.00253, "epss_percentile": 0.4849}, "CVE-2013-5654": {"epss_score": 0.00781, "epss_percentile": 0.73185}, "CVE-2013-5655": {"epss_score": 0.00203, "epss_percentile": 0.42515}, "CVE-2013-5656": {"epss_score": 0.00218, "epss_percentile": 0.44421}, "CVE-2013-5657": {"epss_score": 0.25591, "epss_percentile": 0.96048}, "CVE-2013-5658": {"epss_score": 0.01458, "epss_percentile": 0.80407}, "CVE-2013-5659": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2013-5660": {"epss_score": 0.33674, "epss_percentile": 0.96796}, "CVE-2013-5661": {"epss_score": 0.01066, "epss_percentile": 0.77216}, "CVE-2013-5663": {"epss_score": 0.00606, "epss_percentile": 0.69014}, "CVE-2013-5664": {"epss_score": 0.00638, "epss_percentile": 0.69911}, "CVE-2013-5666": {"epss_score": 0.00068, "epss_percentile": 0.21414}, "CVE-2013-5667": {"epss_score": 0.02505, "epss_percentile": 0.84936}, "CVE-2013-5668": {"epss_score": 0.01202, "epss_percentile": 0.78486}, "CVE-2013-5669": {"epss_score": 0.01787, "epss_percentile": 0.82262}, "CVE-2013-5670": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-5671": {"epss_score": 0.02165, "epss_percentile": 0.83845}, "CVE-2013-5672": {"epss_score": 0.01663, "epss_percentile": 0.81638}, "CVE-2013-5673": {"epss_score": 0.03012, "epss_percentile": 0.86199}, "CVE-2013-5674": {"epss_score": 0.0057, "epss_percentile": 0.67964}, "CVE-2013-5676": {"epss_score": 0.05307, "epss_percentile": 0.89713}, "CVE-2013-5679": {"epss_score": 0.00098, "epss_percentile": 0.27722}, "CVE-2013-5680": {"epss_score": 0.3279, "epss_percentile": 0.96725}, "CVE-2013-5687": {"epss_score": 0.003, "epss_percentile": 0.52973}, "CVE-2013-5688": {"epss_score": 0.03043, "epss_percentile": 0.86277}, "CVE-2013-5690": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2013-5691": {"epss_score": 0.00059, "epss_percentile": 0.18672}, "CVE-2013-5692": {"epss_score": 0.09328, "epss_percentile": 0.92502}, "CVE-2013-5693": {"epss_score": 0.00432, "epss_percentile": 0.62126}, "CVE-2013-5694": {"epss_score": 0.01939, "epss_percentile": 0.82972}, "CVE-2013-5695": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-5696": {"epss_score": 0.63954, "epss_percentile": 0.98356}, "CVE-2013-5697": {"epss_score": 0.01103, "epss_percentile": 0.77591}, "CVE-2013-5698": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2013-5700": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-5701": {"epss_score": 0.00142, "epss_percentile": 0.35047}, "CVE-2013-5702": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-5703": {"epss_score": 0.00509, "epss_percentile": 0.65733}, "CVE-2013-5704": {"epss_score": 0.75572, "epss_percentile": 0.98854}, "CVE-2013-5705": {"epss_score": 0.00842, "epss_percentile": 0.7424}, "CVE-2013-5706": {"epss_score": 0.00708, "epss_percentile": 0.71681}, "CVE-2013-5707": {"epss_score": 0.00708, "epss_percentile": 0.71681}, "CVE-2013-5708": {"epss_score": 0.00167, "epss_percentile": 0.38363}, "CVE-2013-5709": {"epss_score": 0.02177, "epss_percentile": 0.83887}, "CVE-2013-5710": {"epss_score": 0.00052, "epss_percentile": 0.16452}, "CVE-2013-5711": {"epss_score": 0.00239, "epss_percentile": 0.46871}, "CVE-2013-5714": {"epss_score": 0.00414, "epss_percentile": 0.61107}, "CVE-2013-5715": {"epss_score": 0.00341, "epss_percentile": 0.56329}, "CVE-2013-5716": {"epss_score": 0.09268, "epss_percentile": 0.92473}, "CVE-2013-5717": {"epss_score": 0.00205, "epss_percentile": 0.42758}, "CVE-2013-5718": {"epss_score": 0.00883, "epss_percentile": 0.74919}, "CVE-2013-5719": {"epss_score": 0.00314, "epss_percentile": 0.54159}, "CVE-2013-5720": {"epss_score": 0.00381, "epss_percentile": 0.58979}, "CVE-2013-5721": {"epss_score": 0.00286, "epss_percentile": 0.51737}, "CVE-2013-5722": {"epss_score": 0.0027, "epss_percentile": 0.50256}, "CVE-2013-5723": {"epss_score": 0.00791, "epss_percentile": 0.73382}, "CVE-2013-5724": {"epss_score": 0.0004, "epss_percentile": 0.12068}, "CVE-2013-5725": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2013-5726": {"epss_score": 0.00292, "epss_percentile": 0.52239}, "CVE-2013-5730": {"epss_score": 0.10773, "epss_percentile": 0.93099}, "CVE-2013-5738": {"epss_score": 0.00715, "epss_percentile": 0.71836}, "CVE-2013-5739": {"epss_score": 0.0025, "epss_percentile": 0.48209}, "CVE-2013-5740": {"epss_score": 0.00064, "epss_percentile": 0.20161}, "CVE-2013-5741": {"epss_score": 0.0133, "epss_percentile": 0.79511}, "CVE-2013-5743": {"epss_score": 0.82373, "epss_percentile": 0.99191}, "CVE-2013-5744": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2013-5745": {"epss_score": 0.20105, "epss_percentile": 0.95288}, "CVE-2013-5748": {"epss_score": 0.0025, "epss_percentile": 0.48116}, "CVE-2013-5749": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-5750": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-5751": {"epss_score": 0.00426, "epss_percentile": 0.61744}, "CVE-2013-5754": {"epss_score": 0.02818, "epss_percentile": 0.85739}, "CVE-2013-5755": {"epss_score": 0.16353, "epss_percentile": 0.94634}, "CVE-2013-5756": {"epss_score": 0.08427, "epss_percentile": 0.92046}, "CVE-2013-5757": {"epss_score": 0.10163, "epss_percentile": 0.9287}, "CVE-2013-5758": {"epss_score": 0.10706, "epss_percentile": 0.93077}, "CVE-2013-5760": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-5761": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-5762": {"epss_score": 0.00054, "epss_percentile": 0.17145}, "CVE-2013-5763": {"epss_score": 0.00164, "epss_percentile": 0.37909}, "CVE-2013-5764": {"epss_score": 0.00864, "epss_percentile": 0.746}, "CVE-2013-5765": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2013-5766": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-5767": {"epss_score": 0.004, "epss_percentile": 0.60157}, "CVE-2013-5768": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2013-5769": {"epss_score": 0.00444, "epss_percentile": 0.62817}, "CVE-2013-5770": {"epss_score": 0.004, "epss_percentile": 0.60157}, "CVE-2013-5771": {"epss_score": 0.00796, "epss_percentile": 0.73481}, "CVE-2013-5772": {"epss_score": 0.02075, "epss_percentile": 0.83505}, "CVE-2013-5773": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-5774": {"epss_score": 0.02075, "epss_percentile": 0.83505}, "CVE-2013-5775": {"epss_score": 0.00592, "epss_percentile": 0.68616}, "CVE-2013-5776": {"epss_score": 0.01834, "epss_percentile": 0.82465}, "CVE-2013-5777": {"epss_score": 0.00912, "epss_percentile": 0.75364}, "CVE-2013-5778": {"epss_score": 0.0228, "epss_percentile": 0.84243}, "CVE-2013-5779": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-5780": {"epss_score": 0.0228, "epss_percentile": 0.84243}, "CVE-2013-5781": {"epss_score": 0.00075, "epss_percentile": 0.23008}, "CVE-2013-5782": {"epss_score": 0.06362, "epss_percentile": 0.90701}, "CVE-2013-5783": {"epss_score": 0.0264, "epss_percentile": 0.85302}, "CVE-2013-5784": {"epss_score": 0.02075, "epss_percentile": 0.83505}, "CVE-2013-5785": {"epss_score": 0.01716, "epss_percentile": 0.81903}, "CVE-2013-5786": {"epss_score": 0.00623, "epss_percentile": 0.69536}, "CVE-2013-5787": {"epss_score": 0.0484, "epss_percentile": 0.89201}, "CVE-2013-5788": {"epss_score": 0.01094, "epss_percentile": 0.77494}, "CVE-2013-5789": {"epss_score": 0.0484, "epss_percentile": 0.89201}, "CVE-2013-5790": {"epss_score": 0.0228, "epss_percentile": 0.84243}, "CVE-2013-5791": {"epss_score": 0.2245, "epss_percentile": 0.95634}, "CVE-2013-5792": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2013-5793": {"epss_score": 0.00437, "epss_percentile": 0.62502}, "CVE-2013-5794": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2013-5795": {"epss_score": 0.75952, "epss_percentile": 0.9887}, "CVE-2013-5796": {"epss_score": 0.00608, "epss_percentile": 0.69076}, "CVE-2013-5797": {"epss_score": 0.00222, "epss_percentile": 0.44843}, "CVE-2013-5798": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-5799": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-5800": {"epss_score": 0.02227, "epss_percentile": 0.84073}, "CVE-2013-5801": {"epss_score": 0.02321, "epss_percentile": 0.84368}, "CVE-2013-5802": {"epss_score": 0.04507, "epss_percentile": 0.88773}, "CVE-2013-5803": {"epss_score": 0.04936, "epss_percentile": 0.89302}, "CVE-2013-5804": {"epss_score": 0.02075, "epss_percentile": 0.83505}, "CVE-2013-5805": {"epss_score": 0.01375, "epss_percentile": 0.79832}, "CVE-2013-5806": {"epss_score": 0.01375, "epss_percentile": 0.79832}, "CVE-2013-5807": {"epss_score": 0.00231, "epss_percentile": 0.45837}, "CVE-2013-5808": {"epss_score": 0.00334, "epss_percentile": 0.55733}, "CVE-2013-5809": {"epss_score": 0.07797, "epss_percentile": 0.91687}, "CVE-2013-5810": {"epss_score": 0.01045, "epss_percentile": 0.77015}, "CVE-2013-5811": {"epss_score": 0.00143, "epss_percentile": 0.35149}, "CVE-2013-5812": {"epss_score": 0.04198, "epss_percentile": 0.88383}, "CVE-2013-5813": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2013-5814": {"epss_score": 0.06362, "epss_percentile": 0.90701}, "CVE-2013-5815": {"epss_score": 0.00685, "epss_percentile": 0.71137}, "CVE-2013-5816": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2013-5817": {"epss_score": 0.06362, "epss_percentile": 0.90701}, "CVE-2013-5818": {"epss_score": 0.01834, "epss_percentile": 0.82465}, "CVE-2013-5819": {"epss_score": 0.01834, "epss_percentile": 0.82465}, "CVE-2013-5820": {"epss_score": 0.02075, "epss_percentile": 0.83505}, "CVE-2013-5821": {"epss_score": 0.00137, "epss_percentile": 0.34257}, "CVE-2013-5822": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2013-5823": {"epss_score": 0.04936, "epss_percentile": 0.89302}, "CVE-2013-5824": {"epss_score": 0.0484, "epss_percentile": 0.89201}, "CVE-2013-5825": {"epss_score": 0.04936, "epss_percentile": 0.89302}, "CVE-2013-5826": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2013-5827": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-5828": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-5829": {"epss_score": 0.06966, "epss_percentile": 0.91152}, "CVE-2013-5830": {"epss_score": 0.06966, "epss_percentile": 0.91152}, "CVE-2013-5831": {"epss_score": 0.01834, "epss_percentile": 0.82465}, "CVE-2013-5832": {"epss_score": 0.05159, "epss_percentile": 0.89556}, "CVE-2013-5833": {"epss_score": 0.0006, "epss_percentile": 0.1915}, "CVE-2013-5834": {"epss_score": 0.0006, "epss_percentile": 0.19142}, "CVE-2013-5835": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2013-5836": {"epss_score": 0.00362, "epss_percentile": 0.57786}, "CVE-2013-5837": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2013-5838": {"epss_score": 0.03468, "epss_percentile": 0.87195}, "CVE-2013-5839": {"epss_score": 0.00299, "epss_percentile": 0.5284}, "CVE-2013-5840": {"epss_score": 0.0228, "epss_percentile": 0.84243}, "CVE-2013-5841": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2013-5842": {"epss_score": 0.20269, "epss_percentile": 0.95311}, "CVE-2013-5843": {"epss_score": 0.04897, "epss_percentile": 0.89271}, "CVE-2013-5844": {"epss_score": 0.01602, "epss_percentile": 0.81275}, "CVE-2013-5845": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2013-5846": {"epss_score": 0.01602, "epss_percentile": 0.81275}, "CVE-2013-5847": {"epss_score": 0.00191, "epss_percentile": 0.41182}, "CVE-2013-5848": {"epss_score": 0.02455, "epss_percentile": 0.84798}, "CVE-2013-5849": {"epss_score": 0.0228, "epss_percentile": 0.84243}, "CVE-2013-5850": {"epss_score": 0.06689, "epss_percentile": 0.90948}, "CVE-2013-5851": {"epss_score": 0.02355, "epss_percentile": 0.84482}, "CVE-2013-5852": {"epss_score": 0.01503, "epss_percentile": 0.8073}, "CVE-2013-5853": {"epss_score": 0.01107, "epss_percentile": 0.77623}, "CVE-2013-5854": {"epss_score": 0.00381, "epss_percentile": 0.59014}, "CVE-2013-5855": {"epss_score": 0.02752, "epss_percentile": 0.85584}, "CVE-2013-5856": {"epss_score": 0.00156, "epss_percentile": 0.37011}, "CVE-2013-5857": {"epss_score": 0.00156, "epss_percentile": 0.37011}, "CVE-2013-5858": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2013-5859": {"epss_score": 0.00409, "epss_percentile": 0.60696}, "CVE-2013-5860": {"epss_score": 0.01077, "epss_percentile": 0.77331}, "CVE-2013-5861": {"epss_score": 0.00745, "epss_percentile": 0.72518}, "CVE-2013-5862": {"epss_score": 0.0023, "epss_percentile": 0.45734}, "CVE-2013-5863": {"epss_score": 0.00483, "epss_percentile": 0.64571}, "CVE-2013-5864": {"epss_score": 0.00205, "epss_percentile": 0.42724}, "CVE-2013-5865": {"epss_score": 0.00127, "epss_percentile": 0.32786}, "CVE-2013-5866": {"epss_score": 0.00207, "epss_percentile": 0.43118}, "CVE-2013-5867": {"epss_score": 0.01218, "epss_percentile": 0.78606}, "CVE-2013-5868": {"epss_score": 0.00349, "epss_percentile": 0.56881}, "CVE-2013-5869": {"epss_score": 0.00562, "epss_percentile": 0.67686}, "CVE-2013-5870": {"epss_score": 0.00978, "epss_percentile": 0.76233}, "CVE-2013-5871": {"epss_score": 0.00349, "epss_percentile": 0.56881}, "CVE-2013-5872": {"epss_score": 0.00104, "epss_percentile": 0.29129}, "CVE-2013-5873": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2013-5874": {"epss_score": 0.00081, "epss_percentile": 0.24267}, "CVE-2013-5875": {"epss_score": 0.00104, "epss_percentile": 0.29134}, "CVE-2013-5876": {"epss_score": 0.00139, "epss_percentile": 0.3466}, "CVE-2013-5877": {"epss_score": 0.80401, "epss_percentile": 0.99087}, "CVE-2013-5878": {"epss_score": 0.04507, "epss_percentile": 0.88773}, "CVE-2013-5879": {"epss_score": 0.0162, "epss_percentile": 0.81382}, "CVE-2013-5880": {"epss_score": 0.79539, "epss_percentile": 0.99044}, "CVE-2013-5881": {"epss_score": 0.00867, "epss_percentile": 0.74662}, "CVE-2013-5882": {"epss_score": 0.01077, "epss_percentile": 0.77331}, "CVE-2013-5883": {"epss_score": 0.00072, "epss_percentile": 0.22378}, "CVE-2013-5884": {"epss_score": 0.01735, "epss_percentile": 0.82011}, "CVE-2013-5885": {"epss_score": 0.00116, "epss_percentile": 0.31164}, "CVE-2013-5886": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2013-5887": {"epss_score": 0.05586, "epss_percentile": 0.90024}, "CVE-2013-5888": {"epss_score": 0.00102, "epss_percentile": 0.2881}, "CVE-2013-5889": {"epss_score": 0.05954, "epss_percentile": 0.90359}, "CVE-2013-5890": {"epss_score": 0.00393, "epss_percentile": 0.59745}, "CVE-2013-5891": {"epss_score": 0.00413, "epss_percentile": 0.60965}, "CVE-2013-5892": {"epss_score": 0.00064, "epss_percentile": 0.20162}, "CVE-2013-5893": {"epss_score": 0.0698, "epss_percentile": 0.91159}, "CVE-2013-5894": {"epss_score": 0.00867, "epss_percentile": 0.74662}, "CVE-2013-5895": {"epss_score": 0.02407, "epss_percentile": 0.84654}, "CVE-2013-5896": {"epss_score": 0.04936, "epss_percentile": 0.89302}, "CVE-2013-5897": {"epss_score": 0.00393, "epss_percentile": 0.59745}, "CVE-2013-5898": {"epss_score": 0.02361, "epss_percentile": 0.84499}, "CVE-2013-5899": {"epss_score": 0.02593, "epss_percentile": 0.85189}, "CVE-2013-5900": {"epss_score": 0.00561, "epss_percentile": 0.67666}, "CVE-2013-5901": {"epss_score": 0.00561, "epss_percentile": 0.67666}, "CVE-2013-5902": {"epss_score": 0.04163, "epss_percentile": 0.8834}, "CVE-2013-5904": {"epss_score": 0.00957, "epss_percentile": 0.75938}, "CVE-2013-5905": {"epss_score": 0.04163, "epss_percentile": 0.8834}, "CVE-2013-5906": {"epss_score": 0.02598, "epss_percentile": 0.85202}, "CVE-2013-5907": {"epss_score": 0.14151, "epss_percentile": 0.94145}, "CVE-2013-5908": {"epss_score": 0.05278, "epss_percentile": 0.89683}, "CVE-2013-5909": {"epss_score": 0.00393, "epss_percentile": 0.59715}, "CVE-2013-5910": {"epss_score": 0.02075, "epss_percentile": 0.83505}, "CVE-2013-5911": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2013-5912": {"epss_score": 0.34623, "epss_percentile": 0.96861}, "CVE-2013-5913": {"epss_score": 0.00434, "epss_percentile": 0.62304}, "CVE-2013-5914": {"epss_score": 0.02853, "epss_percentile": 0.85833}, "CVE-2013-5915": {"epss_score": 0.00688, "epss_percentile": 0.71209}, "CVE-2013-5916": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2013-5917": {"epss_score": 0.01563, "epss_percentile": 0.81057}, "CVE-2013-5918": {"epss_score": 0.00161, "epss_percentile": 0.37532}, "CVE-2013-5919": {"epss_score": 0.00935, "epss_percentile": 0.7567}, "CVE-2013-5930": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2013-5931": {"epss_score": 0.00466, "epss_percentile": 0.63789}, "CVE-2013-5932": {"epss_score": 0.01425, "epss_percentile": 0.80194}, "CVE-2013-5933": {"epss_score": 0.00074, "epss_percentile": 0.22775}, "CVE-2013-5934": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2013-5935": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-5936": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-5937": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2013-5938": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-5939": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-5942": {"epss_score": 0.01535, "epss_percentile": 0.80908}, "CVE-2013-5943": {"epss_score": 0.00253, "epss_percentile": 0.48492}, "CVE-2013-5944": {"epss_score": 0.01486, "epss_percentile": 0.80605}, "CVE-2013-5945": {"epss_score": 0.10453, "epss_percentile": 0.9299}, "CVE-2013-5946": {"epss_score": 0.06252, "epss_percentile": 0.90616}, "CVE-2013-5948": {"epss_score": 0.36085, "epss_percentile": 0.96954}, "CVE-2013-5951": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2013-5952": {"epss_score": 0.00378, "epss_percentile": 0.58778}, "CVE-2013-5953": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2013-5954": {"epss_score": 0.04231, "epss_percentile": 0.88425}, "CVE-2013-5955": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2013-5956": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2013-5957": {"epss_score": 0.00362, "epss_percentile": 0.57771}, "CVE-2013-5958": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-5959": {"epss_score": 0.00693, "epss_percentile": 0.71335}, "CVE-2013-5960": {"epss_score": 0.00174, "epss_percentile": 0.39163}, "CVE-2013-5961": {"epss_score": 0.06983, "epss_percentile": 0.91161}, "CVE-2013-5962": {"epss_score": 0.26577, "epss_percentile": 0.96159}, "CVE-2013-5963": {"epss_score": 0.02656, "epss_percentile": 0.85358}, "CVE-2013-5964": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2013-5965": {"epss_score": 0.00293, "epss_percentile": 0.52301}, "CVE-2013-5966": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2013-5967": {"epss_score": 0.35251, "epss_percentile": 0.96896}, "CVE-2013-5968": {"epss_score": 0.00298, "epss_percentile": 0.52791}, "CVE-2013-5970": {"epss_score": 0.00769, "epss_percentile": 0.72985}, "CVE-2013-5971": {"epss_score": 0.00504, "epss_percentile": 0.65521}, "CVE-2013-5972": {"epss_score": 0.00046, "epss_percentile": 0.14283}, "CVE-2013-5973": {"epss_score": 0.00033, "epss_percentile": 0.09432}, "CVE-2013-5975": {"epss_score": 0.00495, "epss_percentile": 0.6513}, "CVE-2013-5976": {"epss_score": 0.00462, "epss_percentile": 0.6358}, "CVE-2013-5977": {"epss_score": 0.00575, "epss_percentile": 0.68112}, "CVE-2013-5978": {"epss_score": 0.0248, "epss_percentile": 0.84871}, "CVE-2013-5979": {"epss_score": 0.48856, "epss_percentile": 0.97658}, "CVE-2013-5983": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2013-5984": {"epss_score": 0.02178, "epss_percentile": 0.83891}, "CVE-2013-5986": {"epss_score": 0.00633, "epss_percentile": 0.69773}, "CVE-2013-5987": {"epss_score": 0.00099, "epss_percentile": 0.28379}, "CVE-2013-5988": {"epss_score": 0.00171, "epss_percentile": 0.38897}, "CVE-2013-5990": {"epss_score": 0.05133, "epss_percentile": 0.89533}, "CVE-2013-5991": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2013-5992": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-5993": {"epss_score": 0.00182, "epss_percentile": 0.40144}, "CVE-2013-5994": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2013-5995": {"epss_score": 0.00218, "epss_percentile": 0.44394}, "CVE-2013-5996": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2013-5997": {"epss_score": 0.00111, "epss_percentile": 0.30364}, "CVE-2013-5998": {"epss_score": 0.01782, "epss_percentile": 0.82243}, "CVE-2013-5999": {"epss_score": 0.00152, "epss_percentile": 0.364}, "CVE-2013-6000": {"epss_score": 0.00125, "epss_percentile": 0.3262}, "CVE-2013-6001": {"epss_score": 0.0039, "epss_percentile": 0.59504}, "CVE-2013-6002": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2013-6003": {"epss_score": 0.00218, "epss_percentile": 0.44394}, "CVE-2013-6004": {"epss_score": 0.00505, "epss_percentile": 0.65552}, "CVE-2013-6005": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2013-6006": {"epss_score": 0.00127, "epss_percentile": 0.32935}, "CVE-2013-6009": {"epss_score": 0.00245, "epss_percentile": 0.47633}, "CVE-2013-6010": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2013-6011": {"epss_score": 0.0064, "epss_percentile": 0.69965}, "CVE-2013-6012": {"epss_score": 0.00149, "epss_percentile": 0.36036}, "CVE-2013-6013": {"epss_score": 0.05942, "epss_percentile": 0.90351}, "CVE-2013-6014": {"epss_score": 0.00485, "epss_percentile": 0.64725}, "CVE-2013-6015": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2013-6016": {"epss_score": 0.01276, "epss_percentile": 0.79109}, "CVE-2013-6017": {"epss_score": 0.24202, "epss_percentile": 0.95885}, "CVE-2013-6018": {"epss_score": 0.00081, "epss_percentile": 0.24363}, "CVE-2013-6019": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2013-6020": {"epss_score": 0.005, "epss_percentile": 0.65315}, "CVE-2013-6021": {"epss_score": 0.54035, "epss_percentile": 0.97908}, "CVE-2013-6022": {"epss_score": 0.0021, "epss_percentile": 0.43474}, "CVE-2013-6023": {"epss_score": 0.1945, "epss_percentile": 0.95183}, "CVE-2013-6024": {"epss_score": 0.00075, "epss_percentile": 0.23005}, "CVE-2013-6025": {"epss_score": 0.08463, "epss_percentile": 0.92066}, "CVE-2013-6026": {"epss_score": 0.11409, "epss_percentile": 0.93339}, "CVE-2013-6027": {"epss_score": 0.02777, "epss_percentile": 0.85642}, "CVE-2013-6028": {"epss_score": 0.00307, "epss_percentile": 0.53523}, "CVE-2013-6029": {"epss_score": 0.05855, "epss_percentile": 0.90266}, "CVE-2013-6030": {"epss_score": 0.00214, "epss_percentile": 0.43996}, "CVE-2013-6031": {"epss_score": 0.03938, "epss_percentile": 0.87986}, "CVE-2013-6032": {"epss_score": 0.0083, "epss_percentile": 0.74026}, "CVE-2013-6033": {"epss_score": 0.00319, "epss_percentile": 0.5447}, "CVE-2013-6034": {"epss_score": 0.00664, "epss_percentile": 0.70651}, "CVE-2013-6035": {"epss_score": 0.03699, "epss_percentile": 0.87588}, "CVE-2013-6037": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2013-6038": {"epss_score": 0.08056, "epss_percentile": 0.91857}, "CVE-2013-6039": {"epss_score": 0.01354, "epss_percentile": 0.79703}, "CVE-2013-6040": {"epss_score": 0.07133, "epss_percentile": 0.91272}, "CVE-2013-6041": {"epss_score": 0.0969, "epss_percentile": 0.92664}, "CVE-2013-6042": {"epss_score": 0.00634, "epss_percentile": 0.698}, "CVE-2013-6043": {"epss_score": 0.07414, "epss_percentile": 0.9146}, "CVE-2013-6044": {"epss_score": 0.04123, "epss_percentile": 0.88286}, "CVE-2013-6045": {"epss_score": 0.07841, "epss_percentile": 0.9171}, "CVE-2013-6047": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-6048": {"epss_score": 0.00541, "epss_percentile": 0.67045}, "CVE-2013-6049": {"epss_score": 0.00065, "epss_percentile": 0.20561}, "CVE-2013-6050": {"epss_score": 0.00377, "epss_percentile": 0.58693}, "CVE-2013-6051": {"epss_score": 0.00425, "epss_percentile": 0.61717}, "CVE-2013-6052": {"epss_score": 0.00421, "epss_percentile": 0.61528}, "CVE-2013-6053": {"epss_score": 0.00403, "epss_percentile": 0.60354}, "CVE-2013-6054": {"epss_score": 0.00763, "epss_percentile": 0.72883}, "CVE-2013-6056": {"epss_score": 0.004, "epss_percentile": 0.60162}, "CVE-2013-6058": {"epss_score": 0.02569, "epss_percentile": 0.85122}, "CVE-2013-6074": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2013-6075": {"epss_score": 0.00228, "epss_percentile": 0.45464}, "CVE-2013-6076": {"epss_score": 0.00403, "epss_percentile": 0.60328}, "CVE-2013-6077": {"epss_score": 0.00151, "epss_percentile": 0.3622}, "CVE-2013-6078": {"epss_score": 0.00318, "epss_percentile": 0.54462}, "CVE-2013-6079": {"epss_score": 0.01637, "epss_percentile": 0.81483}, "CVE-2013-6111": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-6114": {"epss_score": 0.08074, "epss_percentile": 0.91868}, "CVE-2013-6117": {"epss_score": 0.89731, "epss_percentile": 0.99539}, "CVE-2013-6122": {"epss_score": 0.00055, "epss_percentile": 0.17557}, "CVE-2013-6123": {"epss_score": 0.00044, "epss_percentile": 0.13631}, "CVE-2013-6124": {"epss_score": 0.00032, "epss_percentile": 0.08745}, "CVE-2013-6127": {"epss_score": 0.04222, "epss_percentile": 0.88411}, "CVE-2013-6128": {"epss_score": 0.09981, "epss_percentile": 0.92802}, "CVE-2013-6129": {"epss_score": 0.74425, "epss_percentile": 0.98798}, "CVE-2013-6141": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2013-6142": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2013-6143": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2013-6162": {"epss_score": 0.00519, "epss_percentile": 0.6617}, "CVE-2013-6163": {"epss_score": 0.00665, "epss_percentile": 0.70663}, "CVE-2013-6164": {"epss_score": 0.02848, "epss_percentile": 0.85824}, "CVE-2013-6166": {"epss_score": 0.00634, "epss_percentile": 0.69791}, "CVE-2013-6167": {"epss_score": 0.00379, "epss_percentile": 0.58846}, "CVE-2013-6168": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2013-6169": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2013-6170": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2013-6171": {"epss_score": 0.00245, "epss_percentile": 0.47624}, "CVE-2013-6172": {"epss_score": 0.01114, "epss_percentile": 0.77693}, "CVE-2013-6173": {"epss_score": 0.00122, "epss_percentile": 0.32055}, "CVE-2013-6174": {"epss_score": 0.00735, "epss_percentile": 0.72289}, "CVE-2013-6175": {"epss_score": 0.0047, "epss_percentile": 0.6397}, "CVE-2013-6176": {"epss_score": 0.00269, "epss_percentile": 0.50112}, "CVE-2013-6177": {"epss_score": 0.00343, "epss_percentile": 0.56435}, "CVE-2013-6178": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-6180": {"epss_score": 0.00225, "epss_percentile": 0.45089}, "CVE-2013-6181": {"epss_score": 0.00144, "epss_percentile": 0.35259}, "CVE-2013-6182": {"epss_score": 0.00201, "epss_percentile": 0.4235}, "CVE-2013-6188": {"epss_score": 0.0014, "epss_percentile": 0.34692}, "CVE-2013-6189": {"epss_score": 0.42815, "epss_percentile": 0.97355}, "CVE-2013-6191": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2013-6192": {"epss_score": 0.00119, "epss_percentile": 0.31655}, "CVE-2013-6193": {"epss_score": 0.01333, "epss_percentile": 0.79531}, "CVE-2013-6194": {"epss_score": 0.77324, "epss_percentile": 0.98931}, "CVE-2013-6195": {"epss_score": 0.27671, "epss_percentile": 0.96273}, "CVE-2013-6196": {"epss_score": 0.0033, "epss_percentile": 0.5546}, "CVE-2013-6197": {"epss_score": 0.00284, "epss_percentile": 0.51414}, "CVE-2013-6198": {"epss_score": 0.00934, "epss_percentile": 0.75647}, "CVE-2013-6200": {"epss_score": 0.00054, "epss_percentile": 0.17273}, "CVE-2013-6201": {"epss_score": 0.05517, "epss_percentile": 0.89951}, "CVE-2013-6202": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2013-6203": {"epss_score": 0.04572, "epss_percentile": 0.88863}, "CVE-2013-6204": {"epss_score": 0.04572, "epss_percentile": 0.88863}, "CVE-2013-6205": {"epss_score": 0.00048, "epss_percentile": 0.1499}, "CVE-2013-6206": {"epss_score": 0.01598, "epss_percentile": 0.81248}, "CVE-2013-6207": {"epss_score": 0.02464, "epss_percentile": 0.84833}, "CVE-2013-6208": {"epss_score": 0.00056, "epss_percentile": 0.1778}, "CVE-2013-6209": {"epss_score": 0.00457, "epss_percentile": 0.63377}, "CVE-2013-6210": {"epss_score": 0.05021, "epss_percentile": 0.89402}, "CVE-2013-6211": {"epss_score": 0.00494, "epss_percentile": 0.65082}, "CVE-2013-6212": {"epss_score": 0.00234, "epss_percentile": 0.46094}, "CVE-2013-6213": {"epss_score": 0.27671, "epss_percentile": 0.96273}, "CVE-2013-6214": {"epss_score": 0.00213, "epss_percentile": 0.43931}, "CVE-2013-6215": {"epss_score": 0.00546, "epss_percentile": 0.6722}, "CVE-2013-6216": {"epss_score": 0.00116, "epss_percentile": 0.31136}, "CVE-2013-6218": {"epss_score": 0.31623, "epss_percentile": 0.96639}, "CVE-2013-6219": {"epss_score": 0.0004, "epss_percentile": 0.12012}, "CVE-2013-6220": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2013-6221": {"epss_score": 0.84144, "epss_percentile": 0.99276}, "CVE-2013-6222": {"epss_score": 0.00878, "epss_percentile": 0.74829}, "CVE-2013-6223": {"epss_score": 0.00061, "epss_percentile": 0.19511}, "CVE-2013-6224": {"epss_score": 0.00445, "epss_percentile": 0.6289}, "CVE-2013-6225": {"epss_score": 0.54061, "epss_percentile": 0.9791}, "CVE-2013-6226": {"epss_score": 0.01265, "epss_percentile": 0.79}, "CVE-2013-6227": {"epss_score": 0.09501, "epss_percentile": 0.92574}, "CVE-2013-6229": {"epss_score": 0.00355, "epss_percentile": 0.57283}, "CVE-2013-6230": {"epss_score": 0.01057, "epss_percentile": 0.77136}, "CVE-2013-6231": {"epss_score": 0.35652, "epss_percentile": 0.96925}, "CVE-2013-6232": {"epss_score": 0.00871, "epss_percentile": 0.74719}, "CVE-2013-6233": {"epss_score": 0.04862, "epss_percentile": 0.89222}, "CVE-2013-6234": {"epss_score": 0.02181, "epss_percentile": 0.83904}, "CVE-2013-6235": {"epss_score": 0.00395, "epss_percentile": 0.59812}, "CVE-2013-6236": {"epss_score": 0.43571, "epss_percentile": 0.97392}, "CVE-2013-6237": {"epss_score": 0.00437, "epss_percentile": 0.62529}, "CVE-2013-6239": {"epss_score": 0.00818, "epss_percentile": 0.73858}, "CVE-2013-6241": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2013-6242": {"epss_score": 0.00748, "epss_percentile": 0.72585}, "CVE-2013-6243": {"epss_score": 0.01168, "epss_percentile": 0.78196}, "CVE-2013-6244": {"epss_score": 0.00718, "epss_percentile": 0.7193}, "CVE-2013-6245": {"epss_score": 0.08934, "epss_percentile": 0.92326}, "CVE-2013-6246": {"epss_score": 0.08045, "epss_percentile": 0.91849}, "CVE-2013-6267": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2013-6271": {"epss_score": 0.20646, "epss_percentile": 0.95394}, "CVE-2013-6272": {"epss_score": 0.00139, "epss_percentile": 0.34612}, "CVE-2013-6275": {"epss_score": 0.01945, "epss_percentile": 0.83}, "CVE-2013-6276": {"epss_score": 0.00369, "epss_percentile": 0.58276}, "CVE-2013-6277": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2013-6280": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2013-6281": {"epss_score": 0.08709, "epss_percentile": 0.92221}, "CVE-2013-6282": {"epss_score": 0.55078, "epss_percentile": 0.97959}, "CVE-2013-6283": {"epss_score": 0.09811, "epss_percentile": 0.92712}, "CVE-2013-6284": {"epss_score": 0.00612, "epss_percentile": 0.6921}, "CVE-2013-6285": {"epss_score": 0.005, "epss_percentile": 0.65315}, "CVE-2013-6288": {"epss_score": 0.00497, "epss_percentile": 0.65197}, "CVE-2013-6289": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2013-6295": {"epss_score": 0.0032, "epss_percentile": 0.54615}, "CVE-2013-6299": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-6300": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-6301": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-6302": {"epss_score": 0.00219, "epss_percentile": 0.44444}, "CVE-2013-6303": {"epss_score": 0.00221, "epss_percentile": 0.44631}, "CVE-2013-6304": {"epss_score": 0.00611, "epss_percentile": 0.69192}, "CVE-2013-6305": {"epss_score": 0.00143, "epss_percentile": 0.35209}, "CVE-2013-6306": {"epss_score": 0.00054, "epss_percentile": 0.17077}, "CVE-2013-6307": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2013-6308": {"epss_score": 0.00154, "epss_percentile": 0.36652}, "CVE-2013-6309": {"epss_score": 0.00406, "epss_percentile": 0.60517}, "CVE-2013-6310": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-6311": {"epss_score": 0.00278, "epss_percentile": 0.50869}, "CVE-2013-6312": {"epss_score": 0.00275, "epss_percentile": 0.50693}, "CVE-2013-6314": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2013-6315": {"epss_score": 0.00195, "epss_percentile": 0.4166}, "CVE-2013-6316": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2013-6318": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-6319": {"epss_score": 0.00121, "epss_percentile": 0.31889}, "CVE-2013-6320": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-6321": {"epss_score": 0.00367, "epss_percentile": 0.58116}, "CVE-2013-6322": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2013-6323": {"epss_score": 0.00291, "epss_percentile": 0.52197}, "CVE-2013-6325": {"epss_score": 0.00923, "epss_percentile": 0.755}, "CVE-2013-6327": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-6328": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2013-6329": {"epss_score": 0.02439, "epss_percentile": 0.8475}, "CVE-2013-6330": {"epss_score": 0.00165, "epss_percentile": 0.38026}, "CVE-2013-6331": {"epss_score": 0.00255, "epss_percentile": 0.48645}, "CVE-2013-6332": {"epss_score": 0.02554, "epss_percentile": 0.85087}, "CVE-2013-6333": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-6334": {"epss_score": 0.00181, "epss_percentile": 0.40054}, "CVE-2013-6335": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2013-6336": {"epss_score": 0.00883, "epss_percentile": 0.74919}, "CVE-2013-6337": {"epss_score": 0.0027, "epss_percentile": 0.50256}, "CVE-2013-6338": {"epss_score": 0.00883, "epss_percentile": 0.74919}, "CVE-2013-6339": {"epss_score": 0.01135, "epss_percentile": 0.77896}, "CVE-2013-6340": {"epss_score": 0.00883, "epss_percentile": 0.74919}, "CVE-2013-6341": {"epss_score": 0.01684, "epss_percentile": 0.81744}, "CVE-2013-6342": {"epss_score": 0.00347, "epss_percentile": 0.56792}, "CVE-2013-6343": {"epss_score": 0.35019, "epss_percentile": 0.96883}, "CVE-2013-6344": {"epss_score": 0.00589, "epss_percentile": 0.68524}, "CVE-2013-6345": {"epss_score": 0.0024, "epss_percentile": 0.47228}, "CVE-2013-6346": {"epss_score": 0.00896, "epss_percentile": 0.75114}, "CVE-2013-6347": {"epss_score": 0.02398, "epss_percentile": 0.84624}, "CVE-2013-6348": {"epss_score": 0.06815, "epss_percentile": 0.91042}, "CVE-2013-6349": {"epss_score": 0.00722, "epss_percentile": 0.7199}, "CVE-2013-6357": {"epss_score": 0.01262, "epss_percentile": 0.7898}, "CVE-2013-6358": {"epss_score": 0.03157, "epss_percentile": 0.86516}, "CVE-2013-6359": {"epss_score": 0.00719, "epss_percentile": 0.71947}, "CVE-2013-6360": {"epss_score": 0.00206, "epss_percentile": 0.42918}, "CVE-2013-6362": {"epss_score": 0.00451, "epss_percentile": 0.63153}, "CVE-2013-6364": {"epss_score": 0.02293, "epss_percentile": 0.84288}, "CVE-2013-6365": {"epss_score": 0.00334, "epss_percentile": 0.55704}, "CVE-2013-6366": {"epss_score": 0.0352, "epss_percentile": 0.87286}, "CVE-2013-6367": {"epss_score": 0.00693, "epss_percentile": 0.71329}, "CVE-2013-6368": {"epss_score": 0.00066, "epss_percentile": 0.20939}, "CVE-2013-6369": {"epss_score": 0.02388, "epss_percentile": 0.84589}, "CVE-2013-6370": {"epss_score": 0.00755, "epss_percentile": 0.72714}, "CVE-2013-6371": {"epss_score": 0.00571, "epss_percentile": 0.67996}, "CVE-2013-6372": {"epss_score": 0.00061, "epss_percentile": 0.19457}, "CVE-2013-6373": {"epss_score": 0.00403, "epss_percentile": 0.60368}, "CVE-2013-6374": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2013-6375": {"epss_score": 0.00628, "epss_percentile": 0.69656}, "CVE-2013-6376": {"epss_score": 0.00116, "epss_percentile": 0.31067}, "CVE-2013-6378": {"epss_score": 0.00074, "epss_percentile": 0.22713}, "CVE-2013-6380": {"epss_score": 0.00048, "epss_percentile": 0.14949}, "CVE-2013-6381": {"epss_score": 0.00094, "epss_percentile": 0.26981}, "CVE-2013-6382": {"epss_score": 0.00012, "epss_percentile": 0.01319}, "CVE-2013-6383": {"epss_score": 0.00025, "epss_percentile": 0.0606}, "CVE-2013-6384": {"epss_score": 0.00057, "epss_percentile": 0.18101}, "CVE-2013-6385": {"epss_score": 0.02471, "epss_percentile": 0.84847}, "CVE-2013-6386": {"epss_score": 0.00375, "epss_percentile": 0.58606}, "CVE-2013-6387": {"epss_score": 0.0021, "epss_percentile": 0.4349}, "CVE-2013-6388": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2013-6389": {"epss_score": 0.00251, "epss_percentile": 0.48318}, "CVE-2013-6391": {"epss_score": 0.00498, "epss_percentile": 0.65215}, "CVE-2013-6392": {"epss_score": 0.00111, "epss_percentile": 0.30362}, "CVE-2013-6393": {"epss_score": 0.0806, "epss_percentile": 0.91859}, "CVE-2013-6394": {"epss_score": 0.0006, "epss_percentile": 0.18955}, "CVE-2013-6395": {"epss_score": 0.00573, "epss_percentile": 0.68055}, "CVE-2013-6396": {"epss_score": 0.00137, "epss_percentile": 0.34265}, "CVE-2013-6397": {"epss_score": 0.93346, "epss_percentile": 0.99798}, "CVE-2013-6398": {"epss_score": 0.00989, "epss_percentile": 0.76368}, "CVE-2013-6399": {"epss_score": 0.01542, "epss_percentile": 0.8095}, "CVE-2013-6400": {"epss_score": 0.00392, "epss_percentile": 0.59644}, "CVE-2013-6401": {"epss_score": 0.00341, "epss_percentile": 0.56318}, "CVE-2013-6402": {"epss_score": 0.00058, "epss_percentile": 0.18384}, "CVE-2013-6403": {"epss_score": 0.00349, "epss_percentile": 0.56856}, "CVE-2013-6404": {"epss_score": 0.00447, "epss_percentile": 0.62985}, "CVE-2013-6407": {"epss_score": 0.06719, "epss_percentile": 0.90966}, "CVE-2013-6408": {"epss_score": 0.06719, "epss_percentile": 0.90966}, "CVE-2013-6409": {"epss_score": 0.00049, "epss_percentile": 0.15309}, "CVE-2013-6410": {"epss_score": 0.0032, "epss_percentile": 0.54597}, "CVE-2013-6411": {"epss_score": 0.0229, "epss_percentile": 0.8428}, "CVE-2013-6412": {"epss_score": 0.00044, "epss_percentile": 0.13398}, "CVE-2013-6413": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2013-6414": {"epss_score": 0.70843, "epss_percentile": 0.98644}, "CVE-2013-6415": {"epss_score": 0.01506, "epss_percentile": 0.80746}, "CVE-2013-6416": {"epss_score": 0.00236, "epss_percentile": 0.46383}, "CVE-2013-6417": {"epss_score": 0.00512, "epss_percentile": 0.65875}, "CVE-2013-6418": {"epss_score": 0.0021, "epss_percentile": 0.43455}, "CVE-2013-6419": {"epss_score": 0.00563, "epss_percentile": 0.67739}, "CVE-2013-6420": {"epss_score": 0.47198, "epss_percentile": 0.97575}, "CVE-2013-6421": {"epss_score": 0.01228, "epss_percentile": 0.78705}, "CVE-2013-6422": {"epss_score": 0.00253, "epss_percentile": 0.48494}, "CVE-2013-6424": {"epss_score": 0.0684, "epss_percentile": 0.91061}, "CVE-2013-6425": {"epss_score": 0.02998, "epss_percentile": 0.86159}, "CVE-2013-6426": {"epss_score": 0.0033, "epss_percentile": 0.55434}, "CVE-2013-6427": {"epss_score": 0.0078, "epss_percentile": 0.73172}, "CVE-2013-6428": {"epss_score": 0.0017, "epss_percentile": 0.38713}, "CVE-2013-6429": {"epss_score": 0.4436, "epss_percentile": 0.97431}, "CVE-2013-6430": {"epss_score": 0.00326, "epss_percentile": 0.55042}, "CVE-2013-6431": {"epss_score": 0.00045, "epss_percentile": 0.13732}, "CVE-2013-6432": {"epss_score": 0.00042, "epss_percentile": 0.12935}, "CVE-2013-6433": {"epss_score": 0.01893, "epss_percentile": 0.82737}, "CVE-2013-6434": {"epss_score": 0.00288, "epss_percentile": 0.51911}, "CVE-2013-6435": {"epss_score": 0.05085, "epss_percentile": 0.89478}, "CVE-2013-6436": {"epss_score": 0.00068, "epss_percentile": 0.21189}, "CVE-2013-6437": {"epss_score": 0.00434, "epss_percentile": 0.62283}, "CVE-2013-6438": {"epss_score": 0.47139, "epss_percentile": 0.9757}, "CVE-2013-6439": {"epss_score": 0.00409, "epss_percentile": 0.60719}, "CVE-2013-6440": {"epss_score": 0.0075, "epss_percentile": 0.72613}, "CVE-2013-6441": {"epss_score": 0.00035, "epss_percentile": 0.0999}, "CVE-2013-6442": {"epss_score": 0.01273, "epss_percentile": 0.79087}, "CVE-2013-6443": {"epss_score": 0.00095, "epss_percentile": 0.27149}, "CVE-2013-6444": {"epss_score": 0.00285, "epss_percentile": 0.51552}, "CVE-2013-6445": {"epss_score": 0.00297, "epss_percentile": 0.5269}, "CVE-2013-6446": {"epss_score": 0.00209, "epss_percentile": 0.43321}, "CVE-2013-6447": {"epss_score": 0.0137, "epss_percentile": 0.79801}, "CVE-2013-6448": {"epss_score": 0.00262, "epss_percentile": 0.49384}, "CVE-2013-6449": {"epss_score": 0.49053, "epss_percentile": 0.97665}, "CVE-2013-6450": {"epss_score": 0.24612, "epss_percentile": 0.95939}, "CVE-2013-6451": {"epss_score": 0.00303, "epss_percentile": 0.53187}, "CVE-2013-6452": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2013-6453": {"epss_score": 0.00623, "epss_percentile": 0.69538}, "CVE-2013-6454": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2013-6455": {"epss_score": 0.00389, "epss_percentile": 0.59496}, "CVE-2013-6456": {"epss_score": 0.00281, "epss_percentile": 0.51103}, "CVE-2013-6457": {"epss_score": 0.00135, "epss_percentile": 0.33991}, "CVE-2013-6458": {"epss_score": 0.00892, "epss_percentile": 0.75066}, "CVE-2013-6459": {"epss_score": 0.00292, "epss_percentile": 0.5227}, "CVE-2013-6460": {"epss_score": 0.02521, "epss_percentile": 0.85003}, "CVE-2013-6461": {"epss_score": 0.02046, "epss_percentile": 0.83386}, "CVE-2013-6462": {"epss_score": 0.1007, "epss_percentile": 0.92839}, "CVE-2013-6465": {"epss_score": 0.00159, "epss_percentile": 0.3736}, "CVE-2013-6466": {"epss_score": 0.01006, "epss_percentile": 0.76554}, "CVE-2013-6467": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2013-6468": {"epss_score": 0.00473, "epss_percentile": 0.64074}, "CVE-2013-6469": {"epss_score": 0.00485, "epss_percentile": 0.64739}, "CVE-2013-6470": {"epss_score": 0.0028, "epss_percentile": 0.51019}, "CVE-2013-6472": {"epss_score": 0.00403, "epss_percentile": 0.60333}, "CVE-2013-6473": {"epss_score": 0.13715, "epss_percentile": 0.94042}, "CVE-2013-6474": {"epss_score": 0.20771, "epss_percentile": 0.95411}, "CVE-2013-6475": {"epss_score": 0.20679, "epss_percentile": 0.95401}, "CVE-2013-6476": {"epss_score": 0.00293, "epss_percentile": 0.52318}, "CVE-2013-6477": {"epss_score": 0.01006, "epss_percentile": 0.76554}, "CVE-2013-6478": {"epss_score": 0.03105, "epss_percentile": 0.86416}, "CVE-2013-6479": {"epss_score": 0.00683, "epss_percentile": 0.71087}, "CVE-2013-6480": {"epss_score": 0.00565, "epss_percentile": 0.67804}, "CVE-2013-6481": {"epss_score": 0.01006, "epss_percentile": 0.76554}, "CVE-2013-6482": {"epss_score": 0.00743, "epss_percentile": 0.72502}, "CVE-2013-6483": {"epss_score": 0.00863, "epss_percentile": 0.74589}, "CVE-2013-6484": {"epss_score": 0.00683, "epss_percentile": 0.71087}, "CVE-2013-6485": {"epss_score": 0.00694, "epss_percentile": 0.71363}, "CVE-2013-6486": {"epss_score": 0.01267, "epss_percentile": 0.7902}, "CVE-2013-6487": {"epss_score": 0.04082, "epss_percentile": 0.8822}, "CVE-2013-6489": {"epss_score": 0.00584, "epss_percentile": 0.6837}, "CVE-2013-6490": {"epss_score": 0.45375, "epss_percentile": 0.97485}, "CVE-2013-6491": {"epss_score": 0.00389, "epss_percentile": 0.59493}, "CVE-2013-6492": {"epss_score": 0.02748, "epss_percentile": 0.85576}, "CVE-2013-6493": {"epss_score": 0.00059, "epss_percentile": 0.18922}, "CVE-2013-6494": {"epss_score": 0.00062, "epss_percentile": 0.19589}, "CVE-2013-6495": {"epss_score": 0.00341, "epss_percentile": 0.56288}, "CVE-2013-6496": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-6497": {"epss_score": 0.00405, "epss_percentile": 0.60491}, "CVE-2013-6501": {"epss_score": 0.00093, "epss_percentile": 0.26604}, "CVE-2013-6617": {"epss_score": 0.01705, "epss_percentile": 0.8185}, "CVE-2013-6618": {"epss_score": 0.10389, "epss_percentile": 0.92971}, "CVE-2013-6621": {"epss_score": 0.01481, "epss_percentile": 0.80567}, "CVE-2013-6622": {"epss_score": 0.01611, "epss_percentile": 0.81328}, "CVE-2013-6623": {"epss_score": 0.01551, "epss_percentile": 0.80988}, "CVE-2013-6624": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2013-6625": {"epss_score": 0.01509, "epss_percentile": 0.80766}, "CVE-2013-6626": {"epss_score": 0.00649, "epss_percentile": 0.70224}, "CVE-2013-6627": {"epss_score": 0.05544, "epss_percentile": 0.89981}, "CVE-2013-6628": {"epss_score": 0.00435, "epss_percentile": 0.62352}, "CVE-2013-6629": {"epss_score": 0.0021, "epss_percentile": 0.43501}, "CVE-2013-6630": {"epss_score": 0.0183, "epss_percentile": 0.82446}, "CVE-2013-6631": {"epss_score": 0.01735, "epss_percentile": 0.82009}, "CVE-2013-6632": {"epss_score": 0.13216, "epss_percentile": 0.93904}, "CVE-2013-6634": {"epss_score": 0.01309, "epss_percentile": 0.79356}, "CVE-2013-6635": {"epss_score": 0.01163, "epss_percentile": 0.78158}, "CVE-2013-6636": {"epss_score": 0.00725, "epss_percentile": 0.72053}, "CVE-2013-6637": {"epss_score": 0.00527, "epss_percentile": 0.66448}, "CVE-2013-6638": {"epss_score": 0.04074, "epss_percentile": 0.88209}, "CVE-2013-6639": {"epss_score": 0.02842, "epss_percentile": 0.85807}, "CVE-2013-6640": {"epss_score": 0.02718, "epss_percentile": 0.85512}, "CVE-2013-6641": {"epss_score": 0.00721, "epss_percentile": 0.71984}, "CVE-2013-6642": {"epss_score": 0.0014, "epss_percentile": 0.34755}, "CVE-2013-6643": {"epss_score": 0.00186, "epss_percentile": 0.40593}, "CVE-2013-6644": {"epss_score": 0.01698, "epss_percentile": 0.81819}, "CVE-2013-6645": {"epss_score": 0.01406, "epss_percentile": 0.8005}, "CVE-2013-6646": {"epss_score": 0.01763, "epss_percentile": 0.82157}, "CVE-2013-6647": {"epss_score": 0.00117, "epss_percentile": 0.31261}, "CVE-2013-6648": {"epss_score": 0.00378, "epss_percentile": 0.58809}, "CVE-2013-6649": {"epss_score": 0.00926, "epss_percentile": 0.75548}, "CVE-2013-6650": {"epss_score": 0.02383, "epss_percentile": 0.8457}, "CVE-2013-6652": {"epss_score": 0.00388, "epss_percentile": 0.59379}, "CVE-2013-6653": {"epss_score": 0.00818, "epss_percentile": 0.73856}, "CVE-2013-6654": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2013-6655": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2013-6656": {"epss_score": 0.00384, "epss_percentile": 0.59166}, "CVE-2013-6657": {"epss_score": 0.00272, "epss_percentile": 0.50394}, "CVE-2013-6658": {"epss_score": 0.01485, "epss_percentile": 0.80599}, "CVE-2013-6659": {"epss_score": 0.00095, "epss_percentile": 0.27195}, "CVE-2013-6660": {"epss_score": 0.00343, "epss_percentile": 0.56472}, "CVE-2013-6661": {"epss_score": 0.00583, "epss_percentile": 0.6834}, "CVE-2013-6662": {"epss_score": 0.00063, "epss_percentile": 0.19855}, "CVE-2013-6663": {"epss_score": 0.02053, "epss_percentile": 0.83417}, "CVE-2013-6664": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2013-6665": {"epss_score": 0.00968, "epss_percentile": 0.76076}, "CVE-2013-6666": {"epss_score": 0.00272, "epss_percentile": 0.50394}, "CVE-2013-6667": {"epss_score": 0.00527, "epss_percentile": 0.66448}, "CVE-2013-6668": {"epss_score": 0.1282, "epss_percentile": 0.93785}, "CVE-2013-6671": {"epss_score": 0.10399, "epss_percentile": 0.92975}, "CVE-2013-6672": {"epss_score": 0.00931, "epss_percentile": 0.75615}, "CVE-2013-6673": {"epss_score": 0.00545, "epss_percentile": 0.67159}, "CVE-2013-6674": {"epss_score": 0.37265, "epss_percentile": 0.97031}, "CVE-2013-6681": {"epss_score": 0.00665, "epss_percentile": 0.7066}, "CVE-2013-6682": {"epss_score": 0.00215, "epss_percentile": 0.44097}, "CVE-2013-6683": {"epss_score": 0.00182, "epss_percentile": 0.40206}, "CVE-2013-6684": {"epss_score": 0.00115, "epss_percentile": 0.30952}, "CVE-2013-6685": {"epss_score": 0.00061, "epss_percentile": 0.19303}, "CVE-2013-6686": {"epss_score": 0.00316, "epss_percentile": 0.54276}, "CVE-2013-6687": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2013-6688": {"epss_score": 0.00327, "epss_percentile": 0.5513}, "CVE-2013-6689": {"epss_score": 0.00056, "epss_percentile": 0.17669}, "CVE-2013-6690": {"epss_score": 0.00371, "epss_percentile": 0.58367}, "CVE-2013-6691": {"epss_score": 0.00604, "epss_percentile": 0.68966}, "CVE-2013-6692": {"epss_score": 0.00296, "epss_percentile": 0.52539}, "CVE-2013-6693": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2013-6694": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2013-6695": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2013-6696": {"epss_score": 0.00758, "epss_percentile": 0.72779}, "CVE-2013-6698": {"epss_score": 0.00217, "epss_percentile": 0.44296}, "CVE-2013-6699": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2013-6700": {"epss_score": 0.00658, "epss_percentile": 0.70495}, "CVE-2013-6701": {"epss_score": 0.00687, "epss_percentile": 0.71179}, "CVE-2013-6702": {"epss_score": 0.00691, "epss_percentile": 0.71268}, "CVE-2013-6703": {"epss_score": 0.00511, "epss_percentile": 0.65844}, "CVE-2013-6704": {"epss_score": 0.00511, "epss_percentile": 0.65844}, "CVE-2013-6705": {"epss_score": 0.00349, "epss_percentile": 0.56915}, "CVE-2013-6706": {"epss_score": 0.01745, "epss_percentile": 0.82069}, "CVE-2013-6707": {"epss_score": 0.01349, "epss_percentile": 0.79666}, "CVE-2013-6708": {"epss_score": 0.00968, "epss_percentile": 0.76082}, "CVE-2013-6709": {"epss_score": 0.00267, "epss_percentile": 0.49976}, "CVE-2013-6710": {"epss_score": 0.00128, "epss_percentile": 0.33025}, "CVE-2013-6711": {"epss_score": 0.0043, "epss_percentile": 0.62031}, "CVE-2013-6712": {"epss_score": 0.17303, "epss_percentile": 0.94819}, "CVE-2013-6713": {"epss_score": 0.00051, "epss_percentile": 0.16167}, "CVE-2013-6714": {"epss_score": 0.00051, "epss_percentile": 0.16167}, "CVE-2013-6717": {"epss_score": 0.01744, "epss_percentile": 0.8206}, "CVE-2013-6718": {"epss_score": 0.00321, "epss_percentile": 0.54677}, "CVE-2013-6719": {"epss_score": 0.06372, "epss_percentile": 0.90706}, "CVE-2013-6720": {"epss_score": 0.02536, "epss_percentile": 0.85038}, "CVE-2013-6721": {"epss_score": 0.00253, "epss_percentile": 0.48476}, "CVE-2013-6722": {"epss_score": 0.0054, "epss_percentile": 0.67005}, "CVE-2013-6723": {"epss_score": 0.0036, "epss_percentile": 0.57619}, "CVE-2013-6724": {"epss_score": 0.04535, "epss_percentile": 0.88816}, "CVE-2013-6725": {"epss_score": 0.00291, "epss_percentile": 0.52197}, "CVE-2013-6726": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2013-6727": {"epss_score": 0.00199, "epss_percentile": 0.42101}, "CVE-2013-6728": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2013-6729": {"epss_score": 0.0018, "epss_percentile": 0.39969}, "CVE-2013-6730": {"epss_score": 0.00186, "epss_percentile": 0.40678}, "CVE-2013-6731": {"epss_score": 0.00154, "epss_percentile": 0.36652}, "CVE-2013-6732": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-6733": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2013-6734": {"epss_score": 0.00165, "epss_percentile": 0.38026}, "CVE-2013-6735": {"epss_score": 0.01022, "epss_percentile": 0.76757}, "CVE-2013-6737": {"epss_score": 0.00289, "epss_percentile": 0.52078}, "CVE-2013-6738": {"epss_score": 0.00478, "epss_percentile": 0.64405}, "CVE-2013-6739": {"epss_score": 0.0008, "epss_percentile": 0.24175}, "CVE-2013-6741": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2013-6742": {"epss_score": 0.00555, "epss_percentile": 0.67469}, "CVE-2013-6743": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2013-6744": {"epss_score": 0.02069, "epss_percentile": 0.83469}, "CVE-2013-6745": {"epss_score": 0.0018, "epss_percentile": 0.39969}, "CVE-2013-6746": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2013-6747": {"epss_score": 0.02767, "epss_percentile": 0.85613}, "CVE-2013-6748": {"epss_score": 0.05235, "epss_percentile": 0.89646}, "CVE-2013-6749": {"epss_score": 0.06283, "epss_percentile": 0.9064}, "CVE-2013-6763": {"epss_score": 0.00064, "epss_percentile": 0.20328}, "CVE-2013-6765": {"epss_score": 0.04543, "epss_percentile": 0.8883}, "CVE-2013-6766": {"epss_score": 0.00383, "epss_percentile": 0.59119}, "CVE-2013-6767": {"epss_score": 0.00178, "epss_percentile": 0.39707}, "CVE-2013-6768": {"epss_score": 0.0039, "epss_percentile": 0.59548}, "CVE-2013-6769": {"epss_score": 0.00338, "epss_percentile": 0.56135}, "CVE-2013-6770": {"epss_score": 0.00175, "epss_percentile": 0.39262}, "CVE-2013-6771": {"epss_score": 0.04064, "epss_percentile": 0.88193}, "CVE-2013-6772": {"epss_score": 0.00206, "epss_percentile": 0.43072}, "CVE-2013-6773": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2013-6774": {"epss_score": 0.00371, "epss_percentile": 0.5841}, "CVE-2013-6775": {"epss_score": 0.00338, "epss_percentile": 0.56135}, "CVE-2013-6780": {"epss_score": 0.00777, "epss_percentile": 0.73112}, "CVE-2013-6785": {"epss_score": 0.31473, "epss_percentile": 0.96622}, "CVE-2013-6786": {"epss_score": 0.00269, "epss_percentile": 0.50114}, "CVE-2013-6787": {"epss_score": 0.00382, "epss_percentile": 0.59031}, "CVE-2013-6788": {"epss_score": 0.00433, "epss_percentile": 0.62179}, "CVE-2013-6789": {"epss_score": 0.00279, "epss_percentile": 0.50947}, "CVE-2013-6791": {"epss_score": 0.18333, "epss_percentile": 0.94997}, "CVE-2013-6792": {"epss_score": 0.02773, "epss_percentile": 0.8563}, "CVE-2013-6793": {"epss_score": 0.08266, "epss_percentile": 0.91959}, "CVE-2013-6794": {"epss_score": 0.00918, "epss_percentile": 0.75446}, "CVE-2013-6795": {"epss_score": 0.0492, "epss_percentile": 0.89291}, "CVE-2013-6796": {"epss_score": 0.14691, "epss_percentile": 0.94266}, "CVE-2013-6797": {"epss_score": 0.0027, "epss_percentile": 0.50251}, "CVE-2013-6798": {"epss_score": 0.00454, "epss_percentile": 0.63246}, "CVE-2013-6799": {"epss_score": 0.00937, "epss_percentile": 0.75696}, "CVE-2013-6800": {"epss_score": 0.00768, "epss_percentile": 0.72964}, "CVE-2013-6801": {"epss_score": 0.21356, "epss_percentile": 0.95506}, "CVE-2013-6802": {"epss_score": 0.00379, "epss_percentile": 0.58847}, "CVE-2013-6804": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-6805": {"epss_score": 0.0012, "epss_percentile": 0.31695}, "CVE-2013-6806": {"epss_score": 0.00229, "epss_percentile": 0.45641}, "CVE-2013-6807": {"epss_score": 0.00159, "epss_percentile": 0.37367}, "CVE-2013-6808": {"epss_score": 0.00232, "epss_percentile": 0.45908}, "CVE-2013-6809": {"epss_score": 0.00902, "epss_percentile": 0.75188}, "CVE-2013-6810": {"epss_score": 0.66429, "epss_percentile": 0.98462}, "CVE-2013-6811": {"epss_score": 0.00158, "epss_percentile": 0.37298}, "CVE-2013-6812": {"epss_score": 0.00297, "epss_percentile": 0.52766}, "CVE-2013-6814": {"epss_score": 0.00307, "epss_percentile": 0.53489}, "CVE-2013-6815": {"epss_score": 0.00704, "epss_percentile": 0.71555}, "CVE-2013-6816": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-6817": {"epss_score": 0.01645, "epss_percentile": 0.81525}, "CVE-2013-6818": {"epss_score": 0.00201, "epss_percentile": 0.42354}, "CVE-2013-6819": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-6820": {"epss_score": 0.03778, "epss_percentile": 0.87711}, "CVE-2013-6821": {"epss_score": 0.00125, "epss_percentile": 0.3262}, "CVE-2013-6822": {"epss_score": 0.0152, "epss_percentile": 0.8082}, "CVE-2013-6823": {"epss_score": 0.00178, "epss_percentile": 0.39713}, "CVE-2013-6824": {"epss_score": 0.01469, "epss_percentile": 0.80492}, "CVE-2013-6825": {"epss_score": 0.00051, "epss_percentile": 0.16007}, "CVE-2013-6826": {"epss_score": 0.00214, "epss_percentile": 0.4397}, "CVE-2013-6827": {"epss_score": 0.00203, "epss_percentile": 0.42496}, "CVE-2013-6828": {"epss_score": 0.00241, "epss_percentile": 0.4728}, "CVE-2013-6829": {"epss_score": 0.71912, "epss_percentile": 0.98685}, "CVE-2013-6830": {"epss_score": 0.07926, "epss_percentile": 0.91766}, "CVE-2013-6831": {"epss_score": 0.00243, "epss_percentile": 0.47507}, "CVE-2013-6832": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2013-6833": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2013-6834": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2013-6835": {"epss_score": 0.19476, "epss_percentile": 0.95191}, "CVE-2013-6836": {"epss_score": 0.01156, "epss_percentile": 0.78102}, "CVE-2013-6837": {"epss_score": 0.00596, "epss_percentile": 0.6872}, "CVE-2013-6838": {"epss_score": 0.01305, "epss_percentile": 0.79322}, "CVE-2013-6839": {"epss_score": 0.00231, "epss_percentile": 0.45819}, "CVE-2013-6840": {"epss_score": 0.00047, "epss_percentile": 0.14504}, "CVE-2013-6852": {"epss_score": 0.00293, "epss_percentile": 0.52316}, "CVE-2013-6853": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2013-6858": {"epss_score": 0.00755, "epss_percentile": 0.72723}, "CVE-2013-6859": {"epss_score": 0.00613, "epss_percentile": 0.69259}, "CVE-2013-6860": {"epss_score": 0.00273, "epss_percentile": 0.50442}, "CVE-2013-6861": {"epss_score": 0.00068, "epss_percentile": 0.21414}, "CVE-2013-6862": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2013-6863": {"epss_score": 0.00541, "epss_percentile": 0.67044}, "CVE-2013-6864": {"epss_score": 0.00727, "epss_percentile": 0.72094}, "CVE-2013-6865": {"epss_score": 0.023, "epss_percentile": 0.84309}, "CVE-2013-6866": {"epss_score": 0.01917, "epss_percentile": 0.82871}, "CVE-2013-6867": {"epss_score": 0.00693, "epss_percentile": 0.71335}, "CVE-2013-6868": {"epss_score": 0.00223, "epss_percentile": 0.44876}, "CVE-2013-6869": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2013-6870": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2013-6872": {"epss_score": 0.03074, "epss_percentile": 0.86355}, "CVE-2013-6873": {"epss_score": 0.01151, "epss_percentile": 0.78035}, "CVE-2013-6874": {"epss_score": 0.35149, "epss_percentile": 0.96891}, "CVE-2013-6875": {"epss_score": 0.1974, "epss_percentile": 0.95235}, "CVE-2013-6876": {"epss_score": 0.00043, "epss_percentile": 0.13129}, "CVE-2013-6877": {"epss_score": 0.34977, "epss_percentile": 0.96881}, "CVE-2013-6878": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2013-6879": {"epss_score": 0.00413, "epss_percentile": 0.60994}, "CVE-2013-6880": {"epss_score": 0.00664, "epss_percentile": 0.70646}, "CVE-2013-6881": {"epss_score": 0.37864, "epss_percentile": 0.97074}, "CVE-2013-6882": {"epss_score": 0.07855, "epss_percentile": 0.91722}, "CVE-2013-6883": {"epss_score": 0.03718, "epss_percentile": 0.87616}, "CVE-2013-6884": {"epss_score": 0.38682, "epss_percentile": 0.97114}, "CVE-2013-6885": {"epss_score": 0.01285, "epss_percentile": 0.79176}, "CVE-2013-6886": {"epss_score": 0.00143, "epss_percentile": 0.35215}, "CVE-2013-6887": {"epss_score": 0.00244, "epss_percentile": 0.47526}, "CVE-2013-6888": {"epss_score": 0.02873, "epss_percentile": 0.85878}, "CVE-2013-6889": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2013-6890": {"epss_score": 0.12171, "epss_percentile": 0.93589}, "CVE-2013-6891": {"epss_score": 0.00054, "epss_percentile": 0.17337}, "CVE-2013-6892": {"epss_score": 0.0017, "epss_percentile": 0.38736}, "CVE-2013-6900": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-6901": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-6902": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-6903": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-6904": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-6905": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-6906": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-6907": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-6908": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-6909": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-6910": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-6911": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2013-6912": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2013-6913": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2013-6914": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2013-6915": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2013-6916": {"epss_score": 0.0026, "epss_percentile": 0.49242}, "CVE-2013-6918": {"epss_score": 0.00171, "epss_percentile": 0.38839}, "CVE-2013-6919": {"epss_score": 0.00234, "epss_percentile": 0.46168}, "CVE-2013-6920": {"epss_score": 0.01309, "epss_percentile": 0.79356}, "CVE-2013-6922": {"epss_score": 0.0063, "epss_percentile": 0.69705}, "CVE-2013-6923": {"epss_score": 0.02855, "epss_percentile": 0.85839}, "CVE-2013-6924": {"epss_score": 0.48357, "epss_percentile": 0.97633}, "CVE-2013-6925": {"epss_score": 0.00562, "epss_percentile": 0.67683}, "CVE-2013-6926": {"epss_score": 0.00265, "epss_percentile": 0.49792}, "CVE-2013-6927": {"epss_score": 0.00056, "epss_percentile": 0.17895}, "CVE-2013-6929": {"epss_score": 0.00522, "epss_percentile": 0.66262}, "CVE-2013-6930": {"epss_score": 0.0039, "epss_percentile": 0.59504}, "CVE-2013-6931": {"epss_score": 0.0039, "epss_percentile": 0.59504}, "CVE-2013-6932": {"epss_score": 0.09879, "epss_percentile": 0.92749}, "CVE-2013-6933": {"epss_score": 0.03355, "epss_percentile": 0.86972}, "CVE-2013-6934": {"epss_score": 0.03978, "epss_percentile": 0.88055}, "CVE-2013-6935": {"epss_score": 0.66125, "epss_percentile": 0.98452}, "CVE-2013-6936": {"epss_score": 0.01939, "epss_percentile": 0.82972}, "CVE-2013-6937": {"epss_score": 0.06613, "epss_percentile": 0.90889}, "CVE-2013-6938": {"epss_score": 0.0041, "epss_percentile": 0.60798}, "CVE-2013-6939": {"epss_score": 0.00556, "epss_percentile": 0.6752}, "CVE-2013-6940": {"epss_score": 0.00293, "epss_percentile": 0.52347}, "CVE-2013-6941": {"epss_score": 0.00421, "epss_percentile": 0.61463}, "CVE-2013-6942": {"epss_score": 0.00122, "epss_percentile": 0.32104}, "CVE-2013-6943": {"epss_score": 0.00293, "epss_percentile": 0.52338}, "CVE-2013-6944": {"epss_score": 0.00293, "epss_percentile": 0.52338}, "CVE-2013-6945": {"epss_score": 0.00382, "epss_percentile": 0.5907}, "CVE-2013-6948": {"epss_score": 0.00522, "epss_percentile": 0.66258}, "CVE-2013-6949": {"epss_score": 0.00467, "epss_percentile": 0.63865}, "CVE-2013-6950": {"epss_score": 0.00457, "epss_percentile": 0.63361}, "CVE-2013-6951": {"epss_score": 0.00264, "epss_percentile": 0.49741}, "CVE-2013-6952": {"epss_score": 0.04834, "epss_percentile": 0.89192}, "CVE-2013-6953": {"epss_score": 0.00396, "epss_percentile": 0.59876}, "CVE-2013-6954": {"epss_score": 0.03546, "epss_percentile": 0.87328}, "CVE-2013-6955": {"epss_score": 0.83314, "epss_percentile": 0.99245}, "CVE-2013-6956": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2013-6957": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-6958": {"epss_score": 0.00709, "epss_percentile": 0.71691}, "CVE-2013-6959": {"epss_score": 0.00528, "epss_percentile": 0.66574}, "CVE-2013-6960": {"epss_score": 0.00499, "epss_percentile": 0.65274}, "CVE-2013-6961": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2013-6962": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2013-6963": {"epss_score": 0.00359, "epss_percentile": 0.57568}, "CVE-2013-6964": {"epss_score": 0.00376, "epss_percentile": 0.5868}, "CVE-2013-6965": {"epss_score": 0.005, "epss_percentile": 0.65316}, "CVE-2013-6966": {"epss_score": 0.00528, "epss_percentile": 0.66574}, "CVE-2013-6967": {"epss_score": 0.00464, "epss_percentile": 0.63728}, "CVE-2013-6968": {"epss_score": 0.00528, "epss_percentile": 0.66574}, "CVE-2013-6969": {"epss_score": 0.00347, "epss_percentile": 0.56781}, "CVE-2013-6970": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2013-6971": {"epss_score": 0.00528, "epss_percentile": 0.66574}, "CVE-2013-6972": {"epss_score": 0.00657, "epss_percentile": 0.7046}, "CVE-2013-6973": {"epss_score": 0.00928, "epss_percentile": 0.75574}, "CVE-2013-6974": {"epss_score": 0.0042, "epss_percentile": 0.61405}, "CVE-2013-6975": {"epss_score": 0.00033, "epss_percentile": 0.09364}, "CVE-2013-6976": {"epss_score": 0.0083, "epss_percentile": 0.74018}, "CVE-2013-6978": {"epss_score": 0.00501, "epss_percentile": 0.65345}, "CVE-2013-6979": {"epss_score": 0.00325, "epss_percentile": 0.5501}, "CVE-2013-6981": {"epss_score": 0.02018, "epss_percentile": 0.83287}, "CVE-2013-6982": {"epss_score": 0.01292, "epss_percentile": 0.79236}, "CVE-2013-6983": {"epss_score": 0.01056, "epss_percentile": 0.77124}, "CVE-2013-6985": {"epss_score": 0.00362, "epss_percentile": 0.5782}, "CVE-2013-6986": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2013-6987": {"epss_score": 0.27731, "epss_percentile": 0.96277}, "CVE-2013-6990": {"epss_score": 0.00343, "epss_percentile": 0.56443}, "CVE-2013-6991": {"epss_score": 0.00473, "epss_percentile": 0.64092}, "CVE-2013-6992": {"epss_score": 0.00137, "epss_percentile": 0.34237}, "CVE-2013-6993": {"epss_score": 0.0027, "epss_percentile": 0.50203}, "CVE-2013-6994": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2013-6997": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2013-6999": {"epss_score": 0.00527, "epss_percentile": 0.66525}, "CVE-2013-7000": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2013-7001": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2013-7002": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2013-7003": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2013-7004": {"epss_score": 0.00333, "epss_percentile": 0.55628}, "CVE-2013-7005": {"epss_score": 0.00036, "epss_percentile": 0.10527}, "CVE-2013-7008": {"epss_score": 0.01407, "epss_percentile": 0.80059}, "CVE-2013-7009": {"epss_score": 0.01407, "epss_percentile": 0.80059}, "CVE-2013-7010": {"epss_score": 0.00942, "epss_percentile": 0.75768}, "CVE-2013-7011": {"epss_score": 0.01407, "epss_percentile": 0.80059}, "CVE-2013-7012": {"epss_score": 0.01407, "epss_percentile": 0.80059}, "CVE-2013-7013": {"epss_score": 0.01199, "epss_percentile": 0.78461}, "CVE-2013-7014": {"epss_score": 0.01375, "epss_percentile": 0.79827}, "CVE-2013-7015": {"epss_score": 0.01222, "epss_percentile": 0.78659}, "CVE-2013-7016": {"epss_score": 0.01222, "epss_percentile": 0.78659}, "CVE-2013-7017": {"epss_score": 0.00844, "epss_percentile": 0.74279}, "CVE-2013-7018": {"epss_score": 0.01222, "epss_percentile": 0.78659}, "CVE-2013-7019": {"epss_score": 0.01407, "epss_percentile": 0.80059}, "CVE-2013-7020": {"epss_score": 0.01472, "epss_percentile": 0.80509}, "CVE-2013-7021": {"epss_score": 0.01407, "epss_percentile": 0.80059}, "CVE-2013-7022": {"epss_score": 0.01298, "epss_percentile": 0.79274}, "CVE-2013-7023": {"epss_score": 0.00975, "epss_percentile": 0.76201}, "CVE-2013-7024": {"epss_score": 0.01222, "epss_percentile": 0.78659}, "CVE-2013-7025": {"epss_score": 0.0202, "epss_percentile": 0.83294}, "CVE-2013-7026": {"epss_score": 9e-05, "epss_percentile": 0.00742}, "CVE-2013-7027": {"epss_score": 0.0032, "epss_percentile": 0.54596}, "CVE-2013-7030": {"epss_score": 0.16953, "epss_percentile": 0.94753}, "CVE-2013-7032": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2013-7033": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-7034": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2013-7038": {"epss_score": 0.00949, "epss_percentile": 0.7584}, "CVE-2013-7039": {"epss_score": 0.02385, "epss_percentile": 0.84578}, "CVE-2013-7040": {"epss_score": 0.00724, "epss_percentile": 0.7204}, "CVE-2013-7041": {"epss_score": 0.02605, "epss_percentile": 0.85218}, "CVE-2013-7042": {"epss_score": 0.00119, "epss_percentile": 0.31639}, "CVE-2013-7043": {"epss_score": 0.00797, "epss_percentile": 0.73493}, "CVE-2013-7048": {"epss_score": 0.00055, "epss_percentile": 0.17489}, "CVE-2013-7049": {"epss_score": 0.01068, "epss_percentile": 0.77241}, "CVE-2013-7050": {"epss_score": 0.00839, "epss_percentile": 0.74187}, "CVE-2013-7051": {"epss_score": 0.05477, "epss_percentile": 0.89915}, "CVE-2013-7052": {"epss_score": 0.427, "epss_percentile": 0.97347}, "CVE-2013-7053": {"epss_score": 0.01306, "epss_percentile": 0.79333}, "CVE-2013-7054": {"epss_score": 0.14463, "epss_percentile": 0.94217}, "CVE-2013-7055": {"epss_score": 0.49259, "epss_percentile": 0.97676}, "CVE-2013-7057": {"epss_score": 0.00414, "epss_percentile": 0.61101}, "CVE-2013-7060": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2013-7061": {"epss_score": 0.00259, "epss_percentile": 0.49034}, "CVE-2013-7062": {"epss_score": 0.00763, "epss_percentile": 0.72885}, "CVE-2013-7063": {"epss_score": 0.00214, "epss_percentile": 0.43993}, "CVE-2013-7064": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2013-7065": {"epss_score": 0.00227, "epss_percentile": 0.45432}, "CVE-2013-7066": {"epss_score": 0.0019, "epss_percentile": 0.41006}, "CVE-2013-7067": {"epss_score": 0.00262, "epss_percentile": 0.49384}, "CVE-2013-7068": {"epss_score": 0.00193, "epss_percentile": 0.41459}, "CVE-2013-7069": {"epss_score": 0.01517, "epss_percentile": 0.80803}, "CVE-2013-7070": {"epss_score": 0.04627, "epss_percentile": 0.88939}, "CVE-2013-7071": {"epss_score": 0.00581, "epss_percentile": 0.68277}, "CVE-2013-7073": {"epss_score": 0.00275, "epss_percentile": 0.50647}, "CVE-2013-7074": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2013-7075": {"epss_score": 0.00414, "epss_percentile": 0.61102}, "CVE-2013-7076": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2013-7077": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-7078": {"epss_score": 0.00486, "epss_percentile": 0.64774}, "CVE-2013-7079": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2013-7080": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2013-7081": {"epss_score": 0.00171, "epss_percentile": 0.38872}, "CVE-2013-7082": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2013-7085": {"epss_score": 0.00995, "epss_percentile": 0.76434}, "CVE-2013-7086": {"epss_score": 0.02072, "epss_percentile": 0.83491}, "CVE-2013-7087": {"epss_score": 0.00486, "epss_percentile": 0.64756}, "CVE-2013-7088": {"epss_score": 0.00505, "epss_percentile": 0.65599}, "CVE-2013-7089": {"epss_score": 0.00467, "epss_percentile": 0.63843}, "CVE-2013-7091": {"epss_score": 0.93748, "epss_percentile": 0.99839}, "CVE-2013-7092": {"epss_score": 0.00474, "epss_percentile": 0.6414}, "CVE-2013-7093": {"epss_score": 0.00246, "epss_percentile": 0.47742}, "CVE-2013-7094": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2013-7095": {"epss_score": 0.01273, "epss_percentile": 0.79089}, "CVE-2013-7096": {"epss_score": 0.0041, "epss_percentile": 0.60845}, "CVE-2013-7097": {"epss_score": 0.14658, "epss_percentile": 0.94259}, "CVE-2013-7098": {"epss_score": 0.00682, "epss_percentile": 0.71062}, "CVE-2013-7100": {"epss_score": 0.02551, "epss_percentile": 0.85076}, "CVE-2013-7102": {"epss_score": 0.61369, "epss_percentile": 0.98245}, "CVE-2013-7103": {"epss_score": 0.00745, "epss_percentile": 0.72521}, "CVE-2013-7104": {"epss_score": 0.00745, "epss_percentile": 0.72521}, "CVE-2013-7105": {"epss_score": 0.00422, "epss_percentile": 0.61537}, "CVE-2013-7106": {"epss_score": 0.01937, "epss_percentile": 0.82965}, "CVE-2013-7107": {"epss_score": 0.00128, "epss_percentile": 0.33056}, "CVE-2013-7108": {"epss_score": 0.52734, "epss_percentile": 0.97837}, "CVE-2013-7110": {"epss_score": 0.00164, "epss_percentile": 0.37916}, "CVE-2013-7111": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2013-7112": {"epss_score": 0.01071, "epss_percentile": 0.77265}, "CVE-2013-7113": {"epss_score": 0.00969, "epss_percentile": 0.761}, "CVE-2013-7114": {"epss_score": 0.00984, "epss_percentile": 0.76311}, "CVE-2013-7127": {"epss_score": 0.00121, "epss_percentile": 0.31826}, "CVE-2013-7128": {"epss_score": 0.00057, "epss_percentile": 0.18119}, "CVE-2013-7129": {"epss_score": 0.0027, "epss_percentile": 0.50203}, "CVE-2013-7130": {"epss_score": 0.02539, "epss_percentile": 0.85045}, "CVE-2013-7134": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2013-7135": {"epss_score": 0.00036, "epss_percentile": 0.1021}, "CVE-2013-7136": {"epss_score": 0.15493, "epss_percentile": 0.94438}, "CVE-2013-7137": {"epss_score": 0.10885, "epss_percentile": 0.93146}, "CVE-2013-7138": {"epss_score": 0.00115, "epss_percentile": 0.30939}, "CVE-2013-7139": {"epss_score": 0.00161, "epss_percentile": 0.37573}, "CVE-2013-7140": {"epss_score": 0.00454, "epss_percentile": 0.6326}, "CVE-2013-7141": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2013-7142": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2013-7143": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2013-7144": {"epss_score": 0.00129, "epss_percentile": 0.33149}, "CVE-2013-7149": {"epss_score": 0.00517, "epss_percentile": 0.66081}, "CVE-2013-7171": {"epss_score": 0.04066, "epss_percentile": 0.88201}, "CVE-2013-7172": {"epss_score": 0.00126, "epss_percentile": 0.32682}, "CVE-2013-7173": {"epss_score": 0.00451, "epss_percentile": 0.6313}, "CVE-2013-7174": {"epss_score": 0.01392, "epss_percentile": 0.79957}, "CVE-2013-7175": {"epss_score": 0.00984, "epss_percentile": 0.76314}, "CVE-2013-7176": {"epss_score": 0.00843, "epss_percentile": 0.74267}, "CVE-2013-7177": {"epss_score": 0.00843, "epss_percentile": 0.74267}, "CVE-2013-7179": {"epss_score": 0.01874, "epss_percentile": 0.82651}, "CVE-2013-7180": {"epss_score": 0.00386, "epss_percentile": 0.59241}, "CVE-2013-7181": {"epss_score": 0.00812, "epss_percentile": 0.73747}, "CVE-2013-7182": {"epss_score": 0.00812, "epss_percentile": 0.73747}, "CVE-2013-7183": {"epss_score": 0.09879, "epss_percentile": 0.92749}, "CVE-2013-7184": {"epss_score": 0.07579, "epss_percentile": 0.91552}, "CVE-2013-7185": {"epss_score": 0.01642, "epss_percentile": 0.81508}, "CVE-2013-7186": {"epss_score": 0.33674, "epss_percentile": 0.96796}, "CVE-2013-7187": {"epss_score": 0.03839, "epss_percentile": 0.87827}, "CVE-2013-7188": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2013-7189": {"epss_score": 0.00672, "epss_percentile": 0.70813}, "CVE-2013-7190": {"epss_score": 0.08806, "epss_percentile": 0.92263}, "CVE-2013-7191": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-7192": {"epss_score": 0.0094, "epss_percentile": 0.75727}, "CVE-2013-7193": {"epss_score": 0.0353, "epss_percentile": 0.873}, "CVE-2013-7194": {"epss_score": 0.00398, "epss_percentile": 0.60051}, "CVE-2013-7195": {"epss_score": 0.00171, "epss_percentile": 0.38872}, "CVE-2013-7196": {"epss_score": 0.03308, "epss_percentile": 0.86882}, "CVE-2013-7201": {"epss_score": 0.00854, "epss_percentile": 0.74456}, "CVE-2013-7202": {"epss_score": 0.01332, "epss_percentile": 0.79521}, "CVE-2013-7203": {"epss_score": 0.00068, "epss_percentile": 0.21304}, "CVE-2013-7204": {"epss_score": 0.0119, "epss_percentile": 0.78374}, "CVE-2013-7205": {"epss_score": 0.02808, "epss_percentile": 0.85711}, "CVE-2013-7209": {"epss_score": 0.00348, "epss_percentile": 0.56807}, "CVE-2013-7216": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2013-7217": {"epss_score": 0.01517, "epss_percentile": 0.80803}, "CVE-2013-7219": {"epss_score": 0.00224, "epss_percentile": 0.45016}, "CVE-2013-7220": {"epss_score": 0.00097, "epss_percentile": 0.27563}, "CVE-2013-7221": {"epss_score": 0.00067, "epss_percentile": 0.21022}, "CVE-2013-7222": {"epss_score": 0.00873, "epss_percentile": 0.74745}, "CVE-2013-7223": {"epss_score": 0.00522, "epss_percentile": 0.66273}, "CVE-2013-7224": {"epss_score": 0.0059, "epss_percentile": 0.6855}, "CVE-2013-7225": {"epss_score": 0.01147, "epss_percentile": 0.78004}, "CVE-2013-7226": {"epss_score": 0.10311, "epss_percentile": 0.92939}, "CVE-2013-7231": {"epss_score": 0.00173, "epss_percentile": 0.3909}, "CVE-2013-7232": {"epss_score": 0.00461, "epss_percentile": 0.63548}, "CVE-2013-7233": {"epss_score": 0.00692, "epss_percentile": 0.71298}, "CVE-2013-7234": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2013-7235": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2013-7236": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2013-7239": {"epss_score": 0.00337, "epss_percentile": 0.56057}, "CVE-2013-7240": {"epss_score": 0.73626, "epss_percentile": 0.98764}, "CVE-2013-7241": {"epss_score": 0.00593, "epss_percentile": 0.6865}, "CVE-2013-7242": {"epss_score": 0.0088, "epss_percentile": 0.74851}, "CVE-2013-7243": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2013-7245": {"epss_score": 0.00254, "epss_percentile": 0.485}, "CVE-2013-7246": {"epss_score": 0.33674, "epss_percentile": 0.96796}, "CVE-2013-7247": {"epss_score": 0.17247, "epss_percentile": 0.94806}, "CVE-2013-7248": {"epss_score": 0.15399, "epss_percentile": 0.94424}, "CVE-2013-7249": {"epss_score": 0.00667, "epss_percentile": 0.70705}, "CVE-2013-7250": {"epss_score": 0.00253, "epss_percentile": 0.48437}, "CVE-2013-7251": {"epss_score": 0.00355, "epss_percentile": 0.57263}, "CVE-2013-7252": {"epss_score": 0.00535, "epss_percentile": 0.66824}, "CVE-2013-7254": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2013-7255": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2013-7256": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2013-7257": {"epss_score": 0.00365, "epss_percentile": 0.5799}, "CVE-2013-7258": {"epss_score": 0.00381, "epss_percentile": 0.5899}, "CVE-2013-7259": {"epss_score": 0.00422, "epss_percentile": 0.61573}, "CVE-2013-7260": {"epss_score": 0.78256, "epss_percentile": 0.98975}, "CVE-2013-7262": {"epss_score": 0.0025, "epss_percentile": 0.48127}, "CVE-2013-7263": {"epss_score": 0.00048, "epss_percentile": 0.14967}, "CVE-2013-7264": {"epss_score": 0.00046, "epss_percentile": 0.14086}, "CVE-2013-7265": {"epss_score": 0.00046, "epss_percentile": 0.14086}, "CVE-2013-7266": {"epss_score": 0.00046, "epss_percentile": 0.14086}, "CVE-2013-7267": {"epss_score": 0.00046, "epss_percentile": 0.14086}, "CVE-2013-7268": {"epss_score": 0.00048, "epss_percentile": 0.14967}, "CVE-2013-7269": {"epss_score": 0.00048, "epss_percentile": 0.14967}, "CVE-2013-7270": {"epss_score": 0.00048, "epss_percentile": 0.14967}, "CVE-2013-7271": {"epss_score": 0.00048, "epss_percentile": 0.14967}, "CVE-2013-7273": {"epss_score": 0.00067, "epss_percentile": 0.21127}, "CVE-2013-7274": {"epss_score": 0.0027, "epss_percentile": 0.50247}, "CVE-2013-7275": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2013-7276": {"epss_score": 0.00342, "epss_percentile": 0.56363}, "CVE-2013-7277": {"epss_score": 0.00352, "epss_percentile": 0.57086}, "CVE-2013-7278": {"epss_score": 0.01031, "epss_percentile": 0.76855}, "CVE-2013-7279": {"epss_score": 0.00435, "epss_percentile": 0.62346}, "CVE-2013-7280": {"epss_score": 0.10062, "epss_percentile": 0.92838}, "CVE-2013-7281": {"epss_score": 0.00048, "epss_percentile": 0.1498}, "CVE-2013-7282": {"epss_score": 0.04658, "epss_percentile": 0.88975}, "CVE-2013-7283": {"epss_score": 0.00329, "epss_percentile": 0.55379}, "CVE-2013-7284": {"epss_score": 0.0217, "epss_percentile": 0.83868}, "CVE-2013-7285": {"epss_score": 0.15054, "epss_percentile": 0.94351}, "CVE-2013-7286": {"epss_score": 0.00338, "epss_percentile": 0.56159}, "CVE-2013-7287": {"epss_score": 0.00293, "epss_percentile": 0.5231}, "CVE-2013-7288": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2013-7289": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2013-7290": {"epss_score": 0.00207, "epss_percentile": 0.4314}, "CVE-2013-7291": {"epss_score": 0.00207, "epss_percentile": 0.4314}, "CVE-2013-7292": {"epss_score": 0.00131, "epss_percentile": 0.33482}, "CVE-2013-7293": {"epss_score": 0.00834, "epss_percentile": 0.74108}, "CVE-2013-7294": {"epss_score": 0.00902, "epss_percentile": 0.75192}, "CVE-2013-7295": {"epss_score": 0.00134, "epss_percentile": 0.33748}, "CVE-2013-7296": {"epss_score": 0.02482, "epss_percentile": 0.84878}, "CVE-2013-7298": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2013-7299": {"epss_score": 0.00635, "epss_percentile": 0.69812}, "CVE-2013-7300": {"epss_score": 0.00273, "epss_percentile": 0.50475}, "CVE-2013-7301": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2013-7302": {"epss_score": 0.00412, "epss_percentile": 0.60916}, "CVE-2013-7303": {"epss_score": 0.00426, "epss_percentile": 0.61756}, "CVE-2013-7304": {"epss_score": 0.00202, "epss_percentile": 0.42402}, "CVE-2013-7305": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2013-7306": {"epss_score": 0.00413, "epss_percentile": 0.61014}, "CVE-2013-7307": {"epss_score": 0.00398, "epss_percentile": 0.60058}, "CVE-2013-7308": {"epss_score": 0.00077, "epss_percentile": 0.23387}, "CVE-2013-7309": {"epss_score": 0.00398, "epss_percentile": 0.60058}, "CVE-2013-7310": {"epss_score": 0.00946, "epss_percentile": 0.75804}, "CVE-2013-7311": {"epss_score": 0.01101, "epss_percentile": 0.77574}, "CVE-2013-7312": {"epss_score": 0.0128, "epss_percentile": 0.79137}, "CVE-2013-7313": {"epss_score": 0.00162, "epss_percentile": 0.3764}, "CVE-2013-7314": {"epss_score": 0.02526, "epss_percentile": 0.85014}, "CVE-2013-7315": {"epss_score": 0.00524, "epss_percentile": 0.66323}, "CVE-2013-7316": {"epss_score": 0.0076, "epss_percentile": 0.72806}, "CVE-2013-7317": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2013-7318": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2013-7319": {"epss_score": 0.04544, "epss_percentile": 0.88831}, "CVE-2013-7320": {"epss_score": 0.0008, "epss_percentile": 0.24056}, "CVE-2013-7321": {"epss_score": 0.00196, "epss_percentile": 0.4173}, "CVE-2013-7322": {"epss_score": 0.00379, "epss_percentile": 0.58895}, "CVE-2013-7323": {"epss_score": 0.01162, "epss_percentile": 0.78155}, "CVE-2013-7324": {"epss_score": 0.00424, "epss_percentile": 0.61658}, "CVE-2013-7325": {"epss_score": 0.00541, "epss_percentile": 0.67059}, "CVE-2013-7326": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2013-7327": {"epss_score": 0.00506, "epss_percentile": 0.65638}, "CVE-2013-7328": {"epss_score": 0.0071, "epss_percentile": 0.71715}, "CVE-2013-7329": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2013-7330": {"epss_score": 0.00068, "epss_percentile": 0.21398}, "CVE-2013-7331": {"epss_score": 0.81812, "epss_percentile": 0.99158}, "CVE-2013-7332": {"epss_score": 0.13917, "epss_percentile": 0.94092}, "CVE-2013-7333": {"epss_score": 0.00446, "epss_percentile": 0.629}, "CVE-2013-7334": {"epss_score": 0.00268, "epss_percentile": 0.50098}, "CVE-2013-7335": {"epss_score": 0.00274, "epss_percentile": 0.50541}, "CVE-2013-7336": {"epss_score": 0.00068, "epss_percentile": 0.21189}, "CVE-2013-7338": {"epss_score": 0.05918, "epss_percentile": 0.9032}, "CVE-2013-7339": {"epss_score": 0.00094, "epss_percentile": 0.26786}, "CVE-2013-7340": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2013-7341": {"epss_score": 0.00258, "epss_percentile": 0.49027}, "CVE-2013-7342": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2013-7343": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2013-7344": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2013-7345": {"epss_score": 0.01525, "epss_percentile": 0.80861}, "CVE-2013-7346": {"epss_score": 0.0014, "epss_percentile": 0.34737}, "CVE-2013-7347": {"epss_score": 0.00142, "epss_percentile": 0.35015}, "CVE-2013-7348": {"epss_score": 0.00053, "epss_percentile": 0.16969}, "CVE-2013-7349": {"epss_score": 0.10329, "epss_percentile": 0.92947}, "CVE-2013-7350": {"epss_score": 0.00322, "epss_percentile": 0.54801}, "CVE-2013-7351": {"epss_score": 0.00958, "epss_percentile": 0.75946}, "CVE-2013-7352": {"epss_score": 0.00281, "epss_percentile": 0.51147}, "CVE-2013-7353": {"epss_score": 0.00412, "epss_percentile": 0.60956}, "CVE-2013-7354": {"epss_score": 0.00567, "epss_percentile": 0.67862}, "CVE-2013-7355": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2013-7356": {"epss_score": 0.00257, "epss_percentile": 0.48947}, "CVE-2013-7357": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-7358": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-7359": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2013-7360": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2013-7361": {"epss_score": 0.00328, "epss_percentile": 0.55284}, "CVE-2013-7362": {"epss_score": 0.00977, "epss_percentile": 0.76217}, "CVE-2013-7363": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2013-7364": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2013-7365": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2013-7366": {"epss_score": 0.01135, "epss_percentile": 0.77907}, "CVE-2013-7367": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2013-7368": {"epss_score": 0.0377, "epss_percentile": 0.877}, "CVE-2013-7369": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2013-7370": {"epss_score": 0.01082, "epss_percentile": 0.77382}, "CVE-2013-7371": {"epss_score": 0.00579, "epss_percentile": 0.68229}, "CVE-2013-7372": {"epss_score": 0.00715, "epss_percentile": 0.71853}, "CVE-2013-7373": {"epss_score": 0.00228, "epss_percentile": 0.45494}, "CVE-2013-7374": {"epss_score": 0.00061, "epss_percentile": 0.1954}, "CVE-2013-7375": {"epss_score": 0.04986, "epss_percentile": 0.89364}, "CVE-2013-7376": {"epss_score": 0.00185, "epss_percentile": 0.40572}, "CVE-2013-7377": {"epss_score": 0.01272, "epss_percentile": 0.79075}, "CVE-2013-7378": {"epss_score": 0.02011, "epss_percentile": 0.83248}, "CVE-2013-7379": {"epss_score": 0.0036, "epss_percentile": 0.57629}, "CVE-2013-7380": {"epss_score": 0.01624, "epss_percentile": 0.81412}, "CVE-2013-7381": {"epss_score": 0.02011, "epss_percentile": 0.83248}, "CVE-2013-7382": {"epss_score": 0.05881, "epss_percentile": 0.90291}, "CVE-2013-7383": {"epss_score": 0.00879, "epss_percentile": 0.74834}, "CVE-2013-7384": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2013-7385": {"epss_score": 0.00437, "epss_percentile": 0.62522}, "CVE-2013-7386": {"epss_score": 0.02686, "epss_percentile": 0.85428}, "CVE-2013-7387": {"epss_score": 0.02198, "epss_percentile": 0.83964}, "CVE-2013-7388": {"epss_score": 0.12105, "epss_percentile": 0.93568}, "CVE-2013-7389": {"epss_score": 0.92669, "epss_percentile": 0.99733}, "CVE-2013-7390": {"epss_score": 0.6678, "epss_percentile": 0.98478}, "CVE-2013-7391": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2013-7392": {"epss_score": 0.09308, "epss_percentile": 0.92494}, "CVE-2013-7393": {"epss_score": 0.00174, "epss_percentile": 0.39195}, "CVE-2013-7394": {"epss_score": 0.00818, "epss_percentile": 0.73863}, "CVE-2013-7395": {"epss_score": 0.00052, "epss_percentile": 0.1637}, "CVE-2013-7397": {"epss_score": 0.0106, "epss_percentile": 0.77162}, "CVE-2013-7398": {"epss_score": 0.01231, "epss_percentile": 0.78735}, "CVE-2013-7400": {"epss_score": 0.00449, "epss_percentile": 0.63037}, "CVE-2013-7401": {"epss_score": 0.01612, "epss_percentile": 0.81332}, "CVE-2013-7402": {"epss_score": 0.01612, "epss_percentile": 0.81332}, "CVE-2013-7404": {"epss_score": 0.00568, "epss_percentile": 0.67896}, "CVE-2013-7405": {"epss_score": 0.00433, "epss_percentile": 0.62183}, "CVE-2013-7406": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2013-7407": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2013-7408": {"epss_score": 0.00642, "epss_percentile": 0.70025}, "CVE-2013-7409": {"epss_score": 0.82136, "epss_percentile": 0.99176}, "CVE-2013-7416": {"epss_score": 0.01213, "epss_percentile": 0.78566}, "CVE-2013-7417": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2013-7418": {"epss_score": 0.0389, "epss_percentile": 0.87909}, "CVE-2013-7419": {"epss_score": 0.00152, "epss_percentile": 0.36456}, "CVE-2013-7420": {"epss_score": 0.05579, "epss_percentile": 0.90017}, "CVE-2013-7421": {"epss_score": 0.00033, "epss_percentile": 0.09356}, "CVE-2013-7422": {"epss_score": 0.00749, "epss_percentile": 0.72608}, "CVE-2013-7423": {"epss_score": 0.04669, "epss_percentile": 0.88984}, "CVE-2013-7424": {"epss_score": 0.00831, "epss_percentile": 0.74042}, "CVE-2013-7426": {"epss_score": 0.014, "epss_percentile": 0.80006}, "CVE-2013-7428": {"epss_score": 0.01403, "epss_percentile": 0.80033}, "CVE-2013-7429": {"epss_score": 0.01584, "epss_percentile": 0.81161}, "CVE-2013-7430": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2013-7431": {"epss_score": 0.00281, "epss_percentile": 0.51122}, "CVE-2013-7432": {"epss_score": 0.00263, "epss_percentile": 0.49534}, "CVE-2013-7433": {"epss_score": 0.00356, "epss_percentile": 0.57393}, "CVE-2013-7435": {"epss_score": 0.00192, "epss_percentile": 0.41328}, "CVE-2013-7436": {"epss_score": 0.00614, "epss_percentile": 0.69276}, "CVE-2013-7437": {"epss_score": 0.00729, "epss_percentile": 0.72135}, "CVE-2013-7438": {"epss_score": 0.01875, "epss_percentile": 0.82654}, "CVE-2013-7439": {"epss_score": 0.01877, "epss_percentile": 0.82662}, "CVE-2013-7440": {"epss_score": 0.00358, "epss_percentile": 0.57505}, "CVE-2013-7441": {"epss_score": 0.03636, "epss_percentile": 0.87481}, "CVE-2013-7442": {"epss_score": 0.00624, "epss_percentile": 0.69573}, "CVE-2013-7443": {"epss_score": 0.01273, "epss_percentile": 0.79089}, "CVE-2013-7444": {"epss_score": 0.00451, "epss_percentile": 0.63143}, "CVE-2013-7445": {"epss_score": 0.00608, "epss_percentile": 0.69082}, "CVE-2013-7446": {"epss_score": 0.00015, "epss_percentile": 0.02243}, "CVE-2013-7447": {"epss_score": 0.07505, "epss_percentile": 0.91508}, "CVE-2013-7448": {"epss_score": 0.0055, "epss_percentile": 0.67324}, "CVE-2013-7449": {"epss_score": 0.00149, "epss_percentile": 0.36004}, "CVE-2013-7450": {"epss_score": 0.00324, "epss_percentile": 0.54968}, "CVE-2013-7451": {"epss_score": 0.00768, "epss_percentile": 0.72968}, "CVE-2013-7452": {"epss_score": 0.00676, "epss_percentile": 0.70921}, "CVE-2013-7453": {"epss_score": 0.00655, "epss_percentile": 0.70365}, "CVE-2013-7454": {"epss_score": 0.00655, "epss_percentile": 0.70365}, "CVE-2013-7455": {"epss_score": 0.15231, "epss_percentile": 0.94389}, "CVE-2013-7456": {"epss_score": 0.01897, "epss_percentile": 0.82757}, "CVE-2013-7457": {"epss_score": 0.00058, "epss_percentile": 0.18532}, "CVE-2013-7458": {"epss_score": 0.00031, "epss_percentile": 0.08658}, "CVE-2013-7459": {"epss_score": 0.14532, "epss_percentile": 0.94232}, "CVE-2013-7460": {"epss_score": 0.00038, "epss_percentile": 0.11133}, "CVE-2013-7461": {"epss_score": 0.00038, "epss_percentile": 0.11133}, "CVE-2013-7462": {"epss_score": 0.02324, "epss_percentile": 0.84379}, "CVE-2013-7463": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2013-7464": {"epss_score": 0.00189, "epss_percentile": 0.40958}, "CVE-2013-7465": {"epss_score": 0.09239, "epss_percentile": 0.92463}, "CVE-2013-7466": {"epss_score": 0.01401, "epss_percentile": 0.8001}, "CVE-2013-7467": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2013-7468": {"epss_score": 0.00487, "epss_percentile": 0.64812}, "CVE-2013-7469": {"epss_score": 0.00159, "epss_percentile": 0.37397}, "CVE-2013-7470": {"epss_score": 0.01266, "epss_percentile": 0.7901}, "CVE-2013-7471": {"epss_score": 0.29652, "epss_percentile": 0.96464}, "CVE-2013-7472": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2013-7473": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2013-7474": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2013-7475": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2013-7476": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2013-7477": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2013-7478": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2013-7479": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2013-7480": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2013-7481": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2013-7482": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2013-7483": {"epss_score": 0.00841, "epss_percentile": 0.74226}, "CVE-2013-7484": {"epss_score": 0.00212, "epss_percentile": 0.4374}, "CVE-2013-7485": {"epss_score": 0.00947, "epss_percentile": 0.75821}, "CVE-2013-7486": {"epss_score": 0.00922, "epss_percentile": 0.75489}, "CVE-2013-7487": {"epss_score": 0.02918, "epss_percentile": 0.85987}, "CVE-2013-7488": {"epss_score": 0.01006, "epss_percentile": 0.76551}, "CVE-2013-7489": {"epss_score": 0.00049, "epss_percentile": 0.15561}, "CVE-2013-7490": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2013-7491": {"epss_score": 0.00173, "epss_percentile": 0.39041}, "CVE-2014-0001": {"epss_score": 0.20688, "epss_percentile": 0.95403}, "CVE-2014-0002": {"epss_score": 0.28739, "epss_percentile": 0.96379}, "CVE-2014-0003": {"epss_score": 0.28969, "epss_percentile": 0.96405}, "CVE-2014-0004": {"epss_score": 0.00057, "epss_percentile": 0.18081}, "CVE-2014-0005": {"epss_score": 0.00207, "epss_percentile": 0.43131}, "CVE-2014-0006": {"epss_score": 0.00421, "epss_percentile": 0.61528}, "CVE-2014-0007": {"epss_score": 0.06848, "epss_percentile": 0.91071}, "CVE-2014-0008": {"epss_score": 0.00423, "epss_percentile": 0.61598}, "CVE-2014-0009": {"epss_score": 0.00364, "epss_percentile": 0.57906}, "CVE-2014-0010": {"epss_score": 0.00295, "epss_percentile": 0.52518}, "CVE-2014-0011": {"epss_score": 0.00549, "epss_percentile": 0.67299}, "CVE-2014-0012": {"epss_score": 0.00101, "epss_percentile": 0.28663}, "CVE-2014-0013": {"epss_score": 0.00203, "epss_percentile": 0.42571}, "CVE-2014-0014": {"epss_score": 0.00301, "epss_percentile": 0.5308}, "CVE-2014-0015": {"epss_score": 0.00972, "epss_percentile": 0.76134}, "CVE-2014-0016": {"epss_score": 0.00312, "epss_percentile": 0.53998}, "CVE-2014-0017": {"epss_score": 0.00088, "epss_percentile": 0.25643}, "CVE-2014-0018": {"epss_score": 0.00062, "epss_percentile": 0.19786}, "CVE-2014-0019": {"epss_score": 0.00086, "epss_percentile": 0.25425}, "CVE-2014-0020": {"epss_score": 0.03531, "epss_percentile": 0.87303}, "CVE-2014-0021": {"epss_score": 0.02365, "epss_percentile": 0.84513}, "CVE-2014-0022": {"epss_score": 0.00551, "epss_percentile": 0.67363}, "CVE-2014-0023": {"epss_score": 0.00121, "epss_percentile": 0.31893}, "CVE-2014-0026": {"epss_score": 0.0015, "epss_percentile": 0.36123}, "CVE-2014-0027": {"epss_score": 0.00069, "epss_percentile": 0.2159}, "CVE-2014-0028": {"epss_score": 0.00104, "epss_percentile": 0.29157}, "CVE-2014-0029": {"epss_score": 0.00233, "epss_percentile": 0.46002}, "CVE-2014-0030": {"epss_score": 0.29063, "epss_percentile": 0.96414}, "CVE-2014-0031": {"epss_score": 0.00323, "epss_percentile": 0.54914}, "CVE-2014-0032": {"epss_score": 0.27105, "epss_percentile": 0.96207}, "CVE-2014-0033": {"epss_score": 0.15133, "epss_percentile": 0.9437}, "CVE-2014-0034": {"epss_score": 0.01861, "epss_percentile": 0.82593}, "CVE-2014-0035": {"epss_score": 0.00956, "epss_percentile": 0.75922}, "CVE-2014-0036": {"epss_score": 0.00658, "epss_percentile": 0.70481}, "CVE-2014-0037": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2014-0038": {"epss_score": 0.51521, "epss_percentile": 0.97784}, "CVE-2014-0039": {"epss_score": 0.00088, "epss_percentile": 0.25727}, "CVE-2014-0040": {"epss_score": 0.00357, "epss_percentile": 0.57462}, "CVE-2014-0041": {"epss_score": 0.00357, "epss_percentile": 0.57462}, "CVE-2014-0042": {"epss_score": 0.00357, "epss_percentile": 0.57462}, "CVE-2014-0043": {"epss_score": 0.01514, "epss_percentile": 0.80793}, "CVE-2014-0044": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2014-0045": {"epss_score": 0.02655, "epss_percentile": 0.85355}, "CVE-2014-0046": {"epss_score": 0.00433, "epss_percentile": 0.62177}, "CVE-2014-0047": {"epss_score": 0.00106, "epss_percentile": 0.29426}, "CVE-2014-0048": {"epss_score": 0.03322, "epss_percentile": 0.86913}, "CVE-2014-0049": {"epss_score": 0.00197, "epss_percentile": 0.4186}, "CVE-2014-0050": {"epss_score": 0.92691, "epss_percentile": 0.99735}, "CVE-2014-0053": {"epss_score": 0.0069, "epss_percentile": 0.71243}, "CVE-2014-0054": {"epss_score": 0.34582, "epss_percentile": 0.96859}, "CVE-2014-0055": {"epss_score": 0.00309, "epss_percentile": 0.53697}, "CVE-2014-0056": {"epss_score": 0.00216, "epss_percentile": 0.44136}, "CVE-2014-0057": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2014-0058": {"epss_score": 0.00061, "epss_percentile": 0.19511}, "CVE-2014-0059": {"epss_score": 0.00053, "epss_percentile": 0.16841}, "CVE-2014-0060": {"epss_score": 0.00954, "epss_percentile": 0.75904}, "CVE-2014-0061": {"epss_score": 0.01436, "epss_percentile": 0.80278}, "CVE-2014-0062": {"epss_score": 0.00671, "epss_percentile": 0.70804}, "CVE-2014-0063": {"epss_score": 0.1004, "epss_percentile": 0.92824}, "CVE-2014-0064": {"epss_score": 0.11019, "epss_percentile": 0.93191}, "CVE-2014-0065": {"epss_score": 0.03867, "epss_percentile": 0.87873}, "CVE-2014-0066": {"epss_score": 0.01402, "epss_percentile": 0.80012}, "CVE-2014-0067": {"epss_score": 0.00096, "epss_percentile": 0.27318}, "CVE-2014-0068": {"epss_score": 0.0004, "epss_percentile": 0.11876}, "CVE-2014-0069": {"epss_score": 0.00049, "epss_percentile": 0.15547}, "CVE-2014-0071": {"epss_score": 0.0019, "epss_percentile": 0.41056}, "CVE-2014-0072": {"epss_score": 0.01489, "epss_percentile": 0.80626}, "CVE-2014-0073": {"epss_score": 0.11445, "epss_percentile": 0.93363}, "CVE-2014-0074": {"epss_score": 0.00267, "epss_percentile": 0.50006}, "CVE-2014-0075": {"epss_score": 0.79487, "epss_percentile": 0.99041}, "CVE-2014-0076": {"epss_score": 0.00396, "epss_percentile": 0.59864}, "CVE-2014-0077": {"epss_score": 0.00169, "epss_percentile": 0.38554}, "CVE-2014-0078": {"epss_score": 0.00619, "epss_percentile": 0.69402}, "CVE-2014-0079": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-0080": {"epss_score": 0.00248, "epss_percentile": 0.47938}, "CVE-2014-0081": {"epss_score": 0.00885, "epss_percentile": 0.74945}, "CVE-2014-0082": {"epss_score": 0.06456, "epss_percentile": 0.90767}, "CVE-2014-0083": {"epss_score": 0.00066, "epss_percentile": 0.20691}, "CVE-2014-0084": {"epss_score": 0.00131, "epss_percentile": 0.3338}, "CVE-2014-0085": {"epss_score": 0.00118, "epss_percentile": 0.31412}, "CVE-2014-0086": {"epss_score": 0.0064, "epss_percentile": 0.69956}, "CVE-2014-0087": {"epss_score": 0.00095, "epss_percentile": 0.27127}, "CVE-2014-0088": {"epss_score": 0.02642, "epss_percentile": 0.85307}, "CVE-2014-0089": {"epss_score": 0.00389, "epss_percentile": 0.59486}, "CVE-2014-0090": {"epss_score": 0.00558, "epss_percentile": 0.67576}, "CVE-2014-0091": {"epss_score": 0.00514, "epss_percentile": 0.65966}, "CVE-2014-0092": {"epss_score": 0.04785, "epss_percentile": 0.8914}, "CVE-2014-0093": {"epss_score": 0.0028, "epss_percentile": 0.51003}, "CVE-2014-0094": {"epss_score": 0.93242, "epss_percentile": 0.99787}, "CVE-2014-0095": {"epss_score": 0.09656, "epss_percentile": 0.92641}, "CVE-2014-0096": {"epss_score": 0.05795, "epss_percentile": 0.90215}, "CVE-2014-0097": {"epss_score": 0.00314, "epss_percentile": 0.5411}, "CVE-2014-0098": {"epss_score": 0.47397, "epss_percentile": 0.97585}, "CVE-2014-0099": {"epss_score": 0.70609, "epss_percentile": 0.98638}, "CVE-2014-0100": {"epss_score": 0.00496, "epss_percentile": 0.6516}, "CVE-2014-0101": {"epss_score": 0.03091, "epss_percentile": 0.86396}, "CVE-2014-0102": {"epss_score": 0.00172, "epss_percentile": 0.38987}, "CVE-2014-0103": {"epss_score": 0.00075, "epss_percentile": 0.22951}, "CVE-2014-0104": {"epss_score": 0.00301, "epss_percentile": 0.53065}, "CVE-2014-0105": {"epss_score": 0.00371, "epss_percentile": 0.58388}, "CVE-2014-0106": {"epss_score": 0.00052, "epss_percentile": 0.16459}, "CVE-2014-0107": {"epss_score": 0.06467, "epss_percentile": 0.90775}, "CVE-2014-0109": {"epss_score": 0.06069, "epss_percentile": 0.9045}, "CVE-2014-0110": {"epss_score": 0.06069, "epss_percentile": 0.9045}, "CVE-2014-0111": {"epss_score": 0.01067, "epss_percentile": 0.77225}, "CVE-2014-0112": {"epss_score": 0.92026, "epss_percentile": 0.99686}, "CVE-2014-0113": {"epss_score": 0.87939, "epss_percentile": 0.99451}, "CVE-2014-0114": {"epss_score": 0.92739, "epss_percentile": 0.99741}, "CVE-2014-0115": {"epss_score": 0.0073, "epss_percentile": 0.7216}, "CVE-2014-0116": {"epss_score": 0.04887, "epss_percentile": 0.89257}, "CVE-2014-0117": {"epss_score": 0.56996, "epss_percentile": 0.98045}, "CVE-2014-0118": {"epss_score": 0.41327, "epss_percentile": 0.97266}, "CVE-2014-0119": {"epss_score": 0.07063, "epss_percentile": 0.91221}, "CVE-2014-0120": {"epss_score": 0.00109, "epss_percentile": 0.29933}, "CVE-2014-0121": {"epss_score": 0.01533, "epss_percentile": 0.80897}, "CVE-2014-0122": {"epss_score": 0.00171, "epss_percentile": 0.38872}, "CVE-2014-0123": {"epss_score": 0.00193, "epss_percentile": 0.41427}, "CVE-2014-0124": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2014-0125": {"epss_score": 0.00201, "epss_percentile": 0.42354}, "CVE-2014-0126": {"epss_score": 0.00126, "epss_percentile": 0.32699}, "CVE-2014-0127": {"epss_score": 0.00171, "epss_percentile": 0.38872}, "CVE-2014-0128": {"epss_score": 0.54968, "epss_percentile": 0.97955}, "CVE-2014-0129": {"epss_score": 0.00193, "epss_percentile": 0.41427}, "CVE-2014-0130": {"epss_score": 0.45374, "epss_percentile": 0.97484}, "CVE-2014-0131": {"epss_score": 0.00104, "epss_percentile": 0.29206}, "CVE-2014-0132": {"epss_score": 0.00573, "epss_percentile": 0.68041}, "CVE-2014-0133": {"epss_score": 0.20913, "epss_percentile": 0.95441}, "CVE-2014-0134": {"epss_score": 0.00201, "epss_percentile": 0.42358}, "CVE-2014-0135": {"epss_score": 0.00099, "epss_percentile": 0.28374}, "CVE-2014-0136": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2014-0137": {"epss_score": 0.0039, "epss_percentile": 0.59523}, "CVE-2014-0138": {"epss_score": 0.00676, "epss_percentile": 0.70934}, "CVE-2014-0139": {"epss_score": 0.01203, "epss_percentile": 0.78494}, "CVE-2014-0140": {"epss_score": 0.00171, "epss_percentile": 0.38827}, "CVE-2014-0141": {"epss_score": 0.0028, "epss_percentile": 0.51042}, "CVE-2014-0142": {"epss_score": 0.00111, "epss_percentile": 0.30306}, "CVE-2014-0143": {"epss_score": 0.00106, "epss_percentile": 0.29481}, "CVE-2014-0144": {"epss_score": 0.00642, "epss_percentile": 0.70021}, "CVE-2014-0145": {"epss_score": 0.00131, "epss_percentile": 0.33395}, "CVE-2014-0146": {"epss_score": 0.00114, "epss_percentile": 0.30801}, "CVE-2014-0147": {"epss_score": 0.00121, "epss_percentile": 0.31842}, "CVE-2014-0148": {"epss_score": 0.00118, "epss_percentile": 0.31385}, "CVE-2014-0149": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-0150": {"epss_score": 0.00551, "epss_percentile": 0.67362}, "CVE-2014-0151": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2014-0152": {"epss_score": 0.00396, "epss_percentile": 0.599}, "CVE-2014-0153": {"epss_score": 0.00217, "epss_percentile": 0.44302}, "CVE-2014-0154": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2014-0155": {"epss_score": 0.00066, "epss_percentile": 0.20754}, "CVE-2014-0156": {"epss_score": 0.01367, "epss_percentile": 0.79781}, "CVE-2014-0157": {"epss_score": 0.00264, "epss_percentile": 0.49721}, "CVE-2014-0158": {"epss_score": 0.00481, "epss_percentile": 0.64488}, "CVE-2014-0159": {"epss_score": 0.01389, "epss_percentile": 0.79929}, "CVE-2014-0160": {"epss_score": 0.94464, "epss_percentile": 0.99995}, "CVE-2014-0161": {"epss_score": 0.00104, "epss_percentile": 0.29131}, "CVE-2014-0162": {"epss_score": 0.00557, "epss_percentile": 0.67557}, "CVE-2014-0163": {"epss_score": 0.01787, "epss_percentile": 0.82261}, "CVE-2014-0164": {"epss_score": 0.00037, "epss_percentile": 0.10795}, "CVE-2014-0165": {"epss_score": 0.00706, "epss_percentile": 0.71621}, "CVE-2014-0166": {"epss_score": 0.31592, "epss_percentile": 0.9663}, "CVE-2014-0167": {"epss_score": 0.00383, "epss_percentile": 0.59115}, "CVE-2014-0168": {"epss_score": 0.00124, "epss_percentile": 0.32459}, "CVE-2014-0169": {"epss_score": 0.0018, "epss_percentile": 0.39873}, "CVE-2014-0170": {"epss_score": 0.00529, "epss_percentile": 0.66578}, "CVE-2014-0171": {"epss_score": 0.00379, "epss_percentile": 0.58848}, "CVE-2014-0172": {"epss_score": 0.01832, "epss_percentile": 0.8245}, "CVE-2014-0173": {"epss_score": 0.00669, "epss_percentile": 0.70756}, "CVE-2014-0174": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2014-0175": {"epss_score": 0.00601, "epss_percentile": 0.68834}, "CVE-2014-0176": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2014-0177": {"epss_score": 0.00137, "epss_percentile": 0.34211}, "CVE-2014-0178": {"epss_score": 0.01917, "epss_percentile": 0.82861}, "CVE-2014-0179": {"epss_score": 0.00106, "epss_percentile": 0.29503}, "CVE-2014-0180": {"epss_score": 0.00727, "epss_percentile": 0.72088}, "CVE-2014-0181": {"epss_score": 0.00027, "epss_percentile": 0.06936}, "CVE-2014-0182": {"epss_score": 0.03495, "epss_percentile": 0.87234}, "CVE-2014-0183": {"epss_score": 0.0029, "epss_percentile": 0.52143}, "CVE-2014-0184": {"epss_score": 0.00131, "epss_percentile": 0.33468}, "CVE-2014-0185": {"epss_score": 0.00109, "epss_percentile": 0.29913}, "CVE-2014-0186": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2014-0187": {"epss_score": 0.0049, "epss_percentile": 0.64942}, "CVE-2014-0188": {"epss_score": 0.00383, "epss_percentile": 0.59119}, "CVE-2014-0189": {"epss_score": 0.00074, "epss_percentile": 0.22781}, "CVE-2014-0190": {"epss_score": 0.01081, "epss_percentile": 0.7737}, "CVE-2014-0191": {"epss_score": 0.02057, "epss_percentile": 0.8343}, "CVE-2014-0192": {"epss_score": 0.00493, "epss_percentile": 0.65054}, "CVE-2014-0193": {"epss_score": 0.05055, "epss_percentile": 0.89447}, "CVE-2014-0195": {"epss_score": 0.92418, "epss_percentile": 0.99714}, "CVE-2014-0196": {"epss_score": 0.63842, "epss_percentile": 0.98352}, "CVE-2014-0197": {"epss_score": 0.00356, "epss_percentile": 0.57344}, "CVE-2014-0198": {"epss_score": 0.30893, "epss_percentile": 0.96574}, "CVE-2014-0199": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2014-0200": {"epss_score": 0.00042, "epss_percentile": 0.12932}, "CVE-2014-0201": {"epss_score": 0.00042, "epss_percentile": 0.12932}, "CVE-2014-0202": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2014-0203": {"epss_score": 0.00066, "epss_percentile": 0.20854}, "CVE-2014-0204": {"epss_score": 0.00353, "epss_percentile": 0.57142}, "CVE-2014-0205": {"epss_score": 0.00041, "epss_percentile": 0.12426}, "CVE-2014-0206": {"epss_score": 0.00056, "epss_percentile": 0.17755}, "CVE-2014-0207": {"epss_score": 0.0686, "epss_percentile": 0.9108}, "CVE-2014-0208": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2014-0209": {"epss_score": 0.00169, "epss_percentile": 0.38567}, "CVE-2014-0210": {"epss_score": 0.02105, "epss_percentile": 0.83622}, "CVE-2014-0211": {"epss_score": 0.02432, "epss_percentile": 0.8473}, "CVE-2014-0212": {"epss_score": 0.02587, "epss_percentile": 0.85169}, "CVE-2014-0213": {"epss_score": 0.00126, "epss_percentile": 0.32699}, "CVE-2014-0214": {"epss_score": 0.00466, "epss_percentile": 0.63806}, "CVE-2014-0215": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2014-0216": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2014-0217": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2014-0218": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-0219": {"epss_score": 0.00081, "epss_percentile": 0.24269}, "CVE-2014-0220": {"epss_score": 0.0032, "epss_percentile": 0.5463}, "CVE-2014-0221": {"epss_score": 0.83021, "epss_percentile": 0.99226}, "CVE-2014-0222": {"epss_score": 0.00886, "epss_percentile": 0.74954}, "CVE-2014-0223": {"epss_score": 0.00093, "epss_percentile": 0.26688}, "CVE-2014-0224": {"epss_score": 0.93182, "epss_percentile": 0.99781}, "CVE-2014-0225": {"epss_score": 0.00231, "epss_percentile": 0.45858}, "CVE-2014-0226": {"epss_score": 0.75444, "epss_percentile": 0.98845}, "CVE-2014-0227": {"epss_score": 0.82097, "epss_percentile": 0.99173}, "CVE-2014-0228": {"epss_score": 0.00322, "epss_percentile": 0.5479}, "CVE-2014-0229": {"epss_score": 0.0037, "epss_percentile": 0.58341}, "CVE-2014-0230": {"epss_score": 0.06203, "epss_percentile": 0.90564}, "CVE-2014-0231": {"epss_score": 0.44151, "epss_percentile": 0.97421}, "CVE-2014-0232": {"epss_score": 0.08691, "epss_percentile": 0.92205}, "CVE-2014-0233": {"epss_score": 0.01365, "epss_percentile": 0.79778}, "CVE-2014-0234": {"epss_score": 0.01422, "epss_percentile": 0.8018}, "CVE-2014-0236": {"epss_score": 0.00582, "epss_percentile": 0.6831}, "CVE-2014-0237": {"epss_score": 0.23087, "epss_percentile": 0.95732}, "CVE-2014-0238": {"epss_score": 0.26161, "epss_percentile": 0.96119}, "CVE-2014-0239": {"epss_score": 0.05345, "epss_percentile": 0.89769}, "CVE-2014-0240": {"epss_score": 0.00311, "epss_percentile": 0.53829}, "CVE-2014-0241": {"epss_score": 0.00104, "epss_percentile": 0.29222}, "CVE-2014-0242": {"epss_score": 0.08583, "epss_percentile": 0.92134}, "CVE-2014-0243": {"epss_score": 0.00049, "epss_percentile": 0.15569}, "CVE-2014-0244": {"epss_score": 0.20011, "epss_percentile": 0.95274}, "CVE-2014-0245": {"epss_score": 0.00407, "epss_percentile": 0.60618}, "CVE-2014-0246": {"epss_score": 0.00344, "epss_percentile": 0.5652}, "CVE-2014-0247": {"epss_score": 0.06607, "epss_percentile": 0.90884}, "CVE-2014-0248": {"epss_score": 0.02348, "epss_percentile": 0.84459}, "CVE-2014-0249": {"epss_score": 0.00054, "epss_percentile": 0.1728}, "CVE-2014-0250": {"epss_score": 0.03073, "epss_percentile": 0.86354}, "CVE-2014-0251": {"epss_score": 0.19647, "epss_percentile": 0.9522}, "CVE-2014-0253": {"epss_score": 0.18722, "epss_percentile": 0.95058}, "CVE-2014-0254": {"epss_score": 0.45037, "epss_percentile": 0.97469}, "CVE-2014-0255": {"epss_score": 0.4153, "epss_percentile": 0.97282}, "CVE-2014-0256": {"epss_score": 0.4153, "epss_percentile": 0.97282}, "CVE-2014-0257": {"epss_score": 0.74737, "epss_percentile": 0.98815}, "CVE-2014-0258": {"epss_score": 0.33405, "epss_percentile": 0.96771}, "CVE-2014-0259": {"epss_score": 0.30304, "epss_percentile": 0.96526}, "CVE-2014-0260": {"epss_score": 0.37235, "epss_percentile": 0.97028}, "CVE-2014-0261": {"epss_score": 0.13262, "epss_percentile": 0.93917}, "CVE-2014-0262": {"epss_score": 0.01591, "epss_percentile": 0.81203}, "CVE-2014-0263": {"epss_score": 0.4649, "epss_percentile": 0.97549}, "CVE-2014-0266": {"epss_score": 0.31859, "epss_percentile": 0.96655}, "CVE-2014-0267": {"epss_score": 0.25169, "epss_percentile": 0.95992}, "CVE-2014-0268": {"epss_score": 0.08125, "epss_percentile": 0.91891}, "CVE-2014-0269": {"epss_score": 0.32615, "epss_percentile": 0.96712}, "CVE-2014-0270": {"epss_score": 0.39746, "epss_percentile": 0.97178}, "CVE-2014-0271": {"epss_score": 0.43181, "epss_percentile": 0.97375}, "CVE-2014-0272": {"epss_score": 0.32615, "epss_percentile": 0.96712}, "CVE-2014-0273": {"epss_score": 0.23811, "epss_percentile": 0.9582}, "CVE-2014-0274": {"epss_score": 0.23811, "epss_percentile": 0.9582}, "CVE-2014-0275": {"epss_score": 0.23811, "epss_percentile": 0.9582}, "CVE-2014-0276": {"epss_score": 0.23811, "epss_percentile": 0.9582}, "CVE-2014-0277": {"epss_score": 0.21015, "epss_percentile": 0.95451}, "CVE-2014-0278": {"epss_score": 0.32615, "epss_percentile": 0.96712}, "CVE-2014-0279": {"epss_score": 0.23811, "epss_percentile": 0.9582}, "CVE-2014-0280": {"epss_score": 0.32615, "epss_percentile": 0.96712}, "CVE-2014-0281": {"epss_score": 0.23811, "epss_percentile": 0.9582}, "CVE-2014-0282": {"epss_score": 0.68814, "epss_percentile": 0.98564}, "CVE-2014-0283": {"epss_score": 0.23811, "epss_percentile": 0.9582}, "CVE-2014-0284": {"epss_score": 0.23811, "epss_percentile": 0.9582}, "CVE-2014-0285": {"epss_score": 0.23811, "epss_percentile": 0.9582}, "CVE-2014-0286": {"epss_score": 0.23811, "epss_percentile": 0.9582}, "CVE-2014-0287": {"epss_score": 0.23811, "epss_percentile": 0.9582}, "CVE-2014-0288": {"epss_score": 0.23811, "epss_percentile": 0.9582}, "CVE-2014-0289": {"epss_score": 0.23662, "epss_percentile": 0.95799}, "CVE-2014-0290": {"epss_score": 0.2102, "epss_percentile": 0.95452}, "CVE-2014-0293": {"epss_score": 0.3004, "epss_percentile": 0.96499}, "CVE-2014-0294": {"epss_score": 0.27212, "epss_percentile": 0.96221}, "CVE-2014-0295": {"epss_score": 0.19786, "epss_percentile": 0.95241}, "CVE-2014-0296": {"epss_score": 0.29869, "epss_percentile": 0.96483}, "CVE-2014-0297": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-0298": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2014-0299": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-0300": {"epss_score": 0.00627, "epss_percentile": 0.69641}, "CVE-2014-0301": {"epss_score": 0.21349, "epss_percentile": 0.95504}, "CVE-2014-0302": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-0303": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-0304": {"epss_score": 0.16517, "epss_percentile": 0.94683}, "CVE-2014-0305": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2014-0306": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2014-0307": {"epss_score": 0.86385, "epss_percentile": 0.99379}, "CVE-2014-0308": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2014-0309": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-0310": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-0311": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2014-0312": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-0313": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-0314": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2014-0315": {"epss_score": 0.22572, "epss_percentile": 0.95652}, "CVE-2014-0316": {"epss_score": 0.08989, "epss_percentile": 0.92355}, "CVE-2014-0317": {"epss_score": 0.12471, "epss_percentile": 0.93682}, "CVE-2014-0318": {"epss_score": 0.01034, "epss_percentile": 0.76886}, "CVE-2014-0319": {"epss_score": 0.10088, "epss_percentile": 0.92845}, "CVE-2014-0321": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2014-0322": {"epss_score": 0.93203, "epss_percentile": 0.99783}, "CVE-2014-0323": {"epss_score": 0.00898, "epss_percentile": 0.75142}, "CVE-2014-0324": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-0325": {"epss_score": 0.35949, "epss_percentile": 0.96942}, "CVE-2014-0326": {"epss_score": 0.00382, "epss_percentile": 0.59063}, "CVE-2014-0327": {"epss_score": 0.01279, "epss_percentile": 0.7913}, "CVE-2014-0328": {"epss_score": 0.00504, "epss_percentile": 0.6552}, "CVE-2014-0329": {"epss_score": 0.25021, "epss_percentile": 0.95979}, "CVE-2014-0330": {"epss_score": 0.01434, "epss_percentile": 0.80265}, "CVE-2014-0331": {"epss_score": 0.00365, "epss_percentile": 0.5799}, "CVE-2014-0332": {"epss_score": 0.01771, "epss_percentile": 0.82197}, "CVE-2014-0333": {"epss_score": 0.00764, "epss_percentile": 0.72894}, "CVE-2014-0334": {"epss_score": 0.0085, "epss_percentile": 0.74386}, "CVE-2014-0335": {"epss_score": 0.00708, "epss_percentile": 0.71681}, "CVE-2014-0336": {"epss_score": 0.00117, "epss_percentile": 0.312}, "CVE-2014-0337": {"epss_score": 0.00328, "epss_percentile": 0.55272}, "CVE-2014-0338": {"epss_score": 0.02148, "epss_percentile": 0.83775}, "CVE-2014-0339": {"epss_score": 0.01181, "epss_percentile": 0.78309}, "CVE-2014-0341": {"epss_score": 0.0064, "epss_percentile": 0.69965}, "CVE-2014-0342": {"epss_score": 0.01127, "epss_percentile": 0.77819}, "CVE-2014-0343": {"epss_score": 0.00069, "epss_percentile": 0.21621}, "CVE-2014-0344": {"epss_score": 0.01279, "epss_percentile": 0.79135}, "CVE-2014-0347": {"epss_score": 0.00211, "epss_percentile": 0.43718}, "CVE-2014-0348": {"epss_score": 0.00272, "epss_percentile": 0.50363}, "CVE-2014-0349": {"epss_score": 0.03192, "epss_percentile": 0.86602}, "CVE-2014-0350": {"epss_score": 0.002, "epss_percentile": 0.42266}, "CVE-2014-0351": {"epss_score": 0.00071, "epss_percentile": 0.22225}, "CVE-2014-0353": {"epss_score": 0.00123, "epss_percentile": 0.32235}, "CVE-2014-0354": {"epss_score": 0.00184, "epss_percentile": 0.40375}, "CVE-2014-0355": {"epss_score": 0.00148, "epss_percentile": 0.35826}, "CVE-2014-0356": {"epss_score": 0.00612, "epss_percentile": 0.69211}, "CVE-2014-0357": {"epss_score": 0.01384, "epss_percentile": 0.79899}, "CVE-2014-0358": {"epss_score": 0.08726, "epss_percentile": 0.92229}, "CVE-2014-0359": {"epss_score": 0.01224, "epss_percentile": 0.78671}, "CVE-2014-0361": {"epss_score": 0.00114, "epss_percentile": 0.30838}, "CVE-2014-0362": {"epss_score": 0.00902, "epss_percentile": 0.75195}, "CVE-2014-0363": {"epss_score": 0.00786, "epss_percentile": 0.733}, "CVE-2014-0364": {"epss_score": 0.00434, "epss_percentile": 0.62309}, "CVE-2014-0366": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2014-0367": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2014-0368": {"epss_score": 0.0228, "epss_percentile": 0.84243}, "CVE-2014-0369": {"epss_score": 0.00539, "epss_percentile": 0.66971}, "CVE-2014-0370": {"epss_score": 0.00923, "epss_percentile": 0.75506}, "CVE-2014-0371": {"epss_score": 0.00441, "epss_percentile": 0.62662}, "CVE-2014-0372": {"epss_score": 0.20481, "epss_percentile": 0.95352}, "CVE-2014-0373": {"epss_score": 0.03341, "epss_percentile": 0.86942}, "CVE-2014-0374": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2014-0375": {"epss_score": 0.02361, "epss_percentile": 0.84499}, "CVE-2014-0376": {"epss_score": 0.01578, "epss_percentile": 0.81125}, "CVE-2014-0377": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2014-0378": {"epss_score": 0.00071, "epss_percentile": 0.22177}, "CVE-2014-0379": {"epss_score": 0.36094, "epss_percentile": 0.96955}, "CVE-2014-0380": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2014-0381": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2014-0382": {"epss_score": 0.02209, "epss_percentile": 0.84011}, "CVE-2014-0383": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2014-0384": {"epss_score": 0.00912, "epss_percentile": 0.75359}, "CVE-2014-0385": {"epss_score": 0.01602, "epss_percentile": 0.81275}, "CVE-2014-0386": {"epss_score": 0.00406, "epss_percentile": 0.60549}, "CVE-2014-0387": {"epss_score": 0.05954, "epss_percentile": 0.90359}, "CVE-2014-0388": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2014-0389": {"epss_score": 0.00652, "epss_percentile": 0.70311}, "CVE-2014-0390": {"epss_score": 0.00511, "epss_percentile": 0.65846}, "CVE-2014-0391": {"epss_score": 0.00754, "epss_percentile": 0.72698}, "CVE-2014-0392": {"epss_score": 0.00393, "epss_percentile": 0.59745}, "CVE-2014-0393": {"epss_score": 0.00468, "epss_percentile": 0.63908}, "CVE-2014-0394": {"epss_score": 0.00754, "epss_percentile": 0.72698}, "CVE-2014-0395": {"epss_score": 0.00754, "epss_percentile": 0.72698}, "CVE-2014-0396": {"epss_score": 0.00848, "epss_percentile": 0.74364}, "CVE-2014-0397": {"epss_score": 0.00964, "epss_percentile": 0.76034}, "CVE-2014-0398": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2014-0399": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2014-0400": {"epss_score": 0.00607, "epss_percentile": 0.69029}, "CVE-2014-0401": {"epss_score": 0.00413, "epss_percentile": 0.60965}, "CVE-2014-0402": {"epss_score": 0.00406, "epss_percentile": 0.60549}, "CVE-2014-0403": {"epss_score": 0.02361, "epss_percentile": 0.84499}, "CVE-2014-0404": {"epss_score": 0.00059, "epss_percentile": 0.18702}, "CVE-2014-0405": {"epss_score": 0.00064, "epss_percentile": 0.20162}, "CVE-2014-0406": {"epss_score": 0.00059, "epss_percentile": 0.18702}, "CVE-2014-0407": {"epss_score": 0.00076, "epss_percentile": 0.23252}, "CVE-2014-0408": {"epss_score": 0.04299, "epss_percentile": 0.88512}, "CVE-2014-0410": {"epss_score": 0.0542, "epss_percentile": 0.89857}, "CVE-2014-0411": {"epss_score": 0.01988, "epss_percentile": 0.83163}, "CVE-2014-0412": {"epss_score": 0.00406, "epss_percentile": 0.60549}, "CVE-2014-0413": {"epss_score": 0.00442, "epss_percentile": 0.62729}, "CVE-2014-0414": {"epss_score": 0.00516, "epss_percentile": 0.66035}, "CVE-2014-0415": {"epss_score": 0.0542, "epss_percentile": 0.89857}, "CVE-2014-0416": {"epss_score": 0.02055, "epss_percentile": 0.8342}, "CVE-2014-0417": {"epss_score": 0.09186, "epss_percentile": 0.92436}, "CVE-2014-0418": {"epss_score": 0.02598, "epss_percentile": 0.85202}, "CVE-2014-0419": {"epss_score": 0.0102, "epss_percentile": 0.76741}, "CVE-2014-0420": {"epss_score": 0.00635, "epss_percentile": 0.69829}, "CVE-2014-0421": {"epss_score": 0.00134, "epss_percentile": 0.33759}, "CVE-2014-0422": {"epss_score": 0.0813, "epss_percentile": 0.91894}, "CVE-2014-0423": {"epss_score": 0.00352, "epss_percentile": 0.57091}, "CVE-2014-0424": {"epss_score": 0.05104, "epss_percentile": 0.89504}, "CVE-2014-0425": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2014-0426": {"epss_score": 0.00442, "epss_percentile": 0.62729}, "CVE-2014-0427": {"epss_score": 0.00445, "epss_percentile": 0.62874}, "CVE-2014-0428": {"epss_score": 0.0813, "epss_percentile": 0.91894}, "CVE-2014-0429": {"epss_score": 0.10266, "epss_percentile": 0.92919}, "CVE-2014-0430": {"epss_score": 0.00523, "epss_percentile": 0.66293}, "CVE-2014-0431": {"epss_score": 0.00445, "epss_percentile": 0.62874}, "CVE-2014-0432": {"epss_score": 0.01925, "epss_percentile": 0.8292}, "CVE-2014-0433": {"epss_score": 0.00543, "epss_percentile": 0.67099}, "CVE-2014-0434": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2014-0435": {"epss_score": 0.00599, "epss_percentile": 0.68795}, "CVE-2014-0436": {"epss_score": 0.00488, "epss_percentile": 0.64831}, "CVE-2014-0437": {"epss_score": 0.0038, "epss_percentile": 0.58943}, "CVE-2014-0438": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2014-0439": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2014-0440": {"epss_score": 0.00923, "epss_percentile": 0.75508}, "CVE-2014-0441": {"epss_score": 0.01107, "epss_percentile": 0.77623}, "CVE-2014-0442": {"epss_score": 0.00175, "epss_percentile": 0.39324}, "CVE-2014-0443": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2014-0444": {"epss_score": 0.00349, "epss_percentile": 0.56881}, "CVE-2014-0445": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2014-0446": {"epss_score": 0.0584, "epss_percentile": 0.90251}, "CVE-2014-0447": {"epss_score": 0.00219, "epss_percentile": 0.44469}, "CVE-2014-0448": {"epss_score": 0.01392, "epss_percentile": 0.79958}, "CVE-2014-0449": {"epss_score": 0.00562, "epss_percentile": 0.67693}, "CVE-2014-0450": {"epss_score": 0.00295, "epss_percentile": 0.5251}, "CVE-2014-0451": {"epss_score": 0.04322, "epss_percentile": 0.88548}, "CVE-2014-0452": {"epss_score": 0.04322, "epss_percentile": 0.88548}, "CVE-2014-0453": {"epss_score": 0.02202, "epss_percentile": 0.83985}, "CVE-2014-0454": {"epss_score": 0.03533, "epss_percentile": 0.87305}, "CVE-2014-0455": {"epss_score": 0.04751, "epss_percentile": 0.89104}, "CVE-2014-0456": {"epss_score": 0.05825, "epss_percentile": 0.90237}, "CVE-2014-0457": {"epss_score": 0.07815, "epss_percentile": 0.91696}, "CVE-2014-0458": {"epss_score": 0.04322, "epss_percentile": 0.88548}, "CVE-2014-0459": {"epss_score": 0.02988, "epss_percentile": 0.86137}, "CVE-2014-0460": {"epss_score": 0.02353, "epss_percentile": 0.84475}, "CVE-2014-0461": {"epss_score": 0.10053, "epss_percentile": 0.92831}, "CVE-2014-0462": {"epss_score": 0.00609, "epss_percentile": 0.69132}, "CVE-2014-0463": {"epss_score": 0.00233, "epss_percentile": 0.45983}, "CVE-2014-0464": {"epss_score": 0.00233, "epss_percentile": 0.45983}, "CVE-2014-0465": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2014-0466": {"epss_score": 0.00312, "epss_percentile": 0.53998}, "CVE-2014-0467": {"epss_score": 0.01816, "epss_percentile": 0.82392}, "CVE-2014-0468": {"epss_score": 0.00127, "epss_percentile": 0.32789}, "CVE-2014-0469": {"epss_score": 0.03735, "epss_percentile": 0.87649}, "CVE-2014-0470": {"epss_score": 0.00045, "epss_percentile": 0.13833}, "CVE-2014-0471": {"epss_score": 0.00291, "epss_percentile": 0.52146}, "CVE-2014-0472": {"epss_score": 0.06894, "epss_percentile": 0.91098}, "CVE-2014-0473": {"epss_score": 0.00298, "epss_percentile": 0.52777}, "CVE-2014-0474": {"epss_score": 0.03963, "epss_percentile": 0.88016}, "CVE-2014-0475": {"epss_score": 0.00307, "epss_percentile": 0.5349}, "CVE-2014-0476": {"epss_score": 0.11441, "epss_percentile": 0.93362}, "CVE-2014-0477": {"epss_score": 0.01423, "epss_percentile": 0.80189}, "CVE-2014-0478": {"epss_score": 0.0023, "epss_percentile": 0.45696}, "CVE-2014-0479": {"epss_score": 0.0068, "epss_percentile": 0.71032}, "CVE-2014-0480": {"epss_score": 0.00556, "epss_percentile": 0.67525}, "CVE-2014-0481": {"epss_score": 0.01121, "epss_percentile": 0.77771}, "CVE-2014-0482": {"epss_score": 0.00711, "epss_percentile": 0.71729}, "CVE-2014-0483": {"epss_score": 0.00428, "epss_percentile": 0.61938}, "CVE-2014-0484": {"epss_score": 0.00045, "epss_percentile": 0.13833}, "CVE-2014-0485": {"epss_score": 0.01602, "epss_percentile": 0.81268}, "CVE-2014-0486": {"epss_score": 0.01335, "epss_percentile": 0.7955}, "CVE-2014-0487": {"epss_score": 0.00121, "epss_percentile": 0.31831}, "CVE-2014-0488": {"epss_score": 0.00202, "epss_percentile": 0.4241}, "CVE-2014-0489": {"epss_score": 0.00688, "epss_percentile": 0.71205}, "CVE-2014-0490": {"epss_score": 0.00688, "epss_percentile": 0.71205}, "CVE-2014-0491": {"epss_score": 0.02208, "epss_percentile": 0.84008}, "CVE-2014-0492": {"epss_score": 0.03215, "epss_percentile": 0.86661}, "CVE-2014-0493": {"epss_score": 0.12554, "epss_percentile": 0.93715}, "CVE-2014-0494": {"epss_score": 0.04156, "epss_percentile": 0.88328}, "CVE-2014-0495": {"epss_score": 0.04851, "epss_percentile": 0.89215}, "CVE-2014-0496": {"epss_score": 0.7737, "epss_percentile": 0.98934}, "CVE-2014-0497": {"epss_score": 0.93303, "epss_percentile": 0.99795}, "CVE-2014-0498": {"epss_score": 0.01162, "epss_percentile": 0.78148}, "CVE-2014-0499": {"epss_score": 0.00879, "epss_percentile": 0.74843}, "CVE-2014-0500": {"epss_score": 0.24476, "epss_percentile": 0.95925}, "CVE-2014-0501": {"epss_score": 0.24476, "epss_percentile": 0.95925}, "CVE-2014-0502": {"epss_score": 0.90131, "epss_percentile": 0.99564}, "CVE-2014-0503": {"epss_score": 0.00502, "epss_percentile": 0.65413}, "CVE-2014-0504": {"epss_score": 0.01253, "epss_percentile": 0.78915}, "CVE-2014-0505": {"epss_score": 0.1754, "epss_percentile": 0.94863}, "CVE-2014-0506": {"epss_score": 0.19859, "epss_percentile": 0.95251}, "CVE-2014-0507": {"epss_score": 0.03976, "epss_percentile": 0.88049}, "CVE-2014-0508": {"epss_score": 0.01204, "epss_percentile": 0.78503}, "CVE-2014-0509": {"epss_score": 0.00583, "epss_percentile": 0.68356}, "CVE-2014-0510": {"epss_score": 0.18929, "epss_percentile": 0.95099}, "CVE-2014-0511": {"epss_score": 0.24695, "epss_percentile": 0.95946}, "CVE-2014-0512": {"epss_score": 0.02793, "epss_percentile": 0.85672}, "CVE-2014-0513": {"epss_score": 0.0786, "epss_percentile": 0.91727}, "CVE-2014-0514": {"epss_score": 0.9029, "epss_percentile": 0.99575}, "CVE-2014-0515": {"epss_score": 0.92952, "epss_percentile": 0.99763}, "CVE-2014-0516": {"epss_score": 0.01299, "epss_percentile": 0.79281}, "CVE-2014-0517": {"epss_score": 0.02029, "epss_percentile": 0.8333}, "CVE-2014-0518": {"epss_score": 0.02029, "epss_percentile": 0.8333}, "CVE-2014-0519": {"epss_score": 0.02029, "epss_percentile": 0.8333}, "CVE-2014-0520": {"epss_score": 0.02029, "epss_percentile": 0.8333}, "CVE-2014-0521": {"epss_score": 0.18302, "epss_percentile": 0.94991}, "CVE-2014-0522": {"epss_score": 0.08291, "epss_percentile": 0.91974}, "CVE-2014-0523": {"epss_score": 0.08291, "epss_percentile": 0.91974}, "CVE-2014-0524": {"epss_score": 0.08291, "epss_percentile": 0.91974}, "CVE-2014-0525": {"epss_score": 0.31313, "epss_percentile": 0.96608}, "CVE-2014-0526": {"epss_score": 0.12467, "epss_percentile": 0.93681}, "CVE-2014-0527": {"epss_score": 0.08113, "epss_percentile": 0.91886}, "CVE-2014-0528": {"epss_score": 0.14838, "epss_percentile": 0.94301}, "CVE-2014-0529": {"epss_score": 0.14798, "epss_percentile": 0.94287}, "CVE-2014-0531": {"epss_score": 0.01011, "epss_percentile": 0.76612}, "CVE-2014-0532": {"epss_score": 0.03593, "epss_percentile": 0.87402}, "CVE-2014-0533": {"epss_score": 0.01011, "epss_percentile": 0.76612}, "CVE-2014-0534": {"epss_score": 0.02391, "epss_percentile": 0.84601}, "CVE-2014-0535": {"epss_score": 0.06138, "epss_percentile": 0.90512}, "CVE-2014-0536": {"epss_score": 0.04236, "epss_percentile": 0.88429}, "CVE-2014-0537": {"epss_score": 0.01962, "epss_percentile": 0.83067}, "CVE-2014-0538": {"epss_score": 0.04728, "epss_percentile": 0.89067}, "CVE-2014-0539": {"epss_score": 0.01962, "epss_percentile": 0.83067}, "CVE-2014-0540": {"epss_score": 0.00664, "epss_percentile": 0.70638}, "CVE-2014-0541": {"epss_score": 0.02091, "epss_percentile": 0.83572}, "CVE-2014-0542": {"epss_score": 0.00664, "epss_percentile": 0.70638}, "CVE-2014-0543": {"epss_score": 0.00664, "epss_percentile": 0.70638}, "CVE-2014-0544": {"epss_score": 0.00664, "epss_percentile": 0.70638}, "CVE-2014-0545": {"epss_score": 0.00664, "epss_percentile": 0.70638}, "CVE-2014-0546": {"epss_score": 0.44068, "epss_percentile": 0.97417}, "CVE-2014-0547": {"epss_score": 0.0558, "epss_percentile": 0.9002}, "CVE-2014-0548": {"epss_score": 0.00999, "epss_percentile": 0.76479}, "CVE-2014-0549": {"epss_score": 0.0558, "epss_percentile": 0.9002}, "CVE-2014-0550": {"epss_score": 0.0558, "epss_percentile": 0.9002}, "CVE-2014-0551": {"epss_score": 0.0558, "epss_percentile": 0.9002}, "CVE-2014-0552": {"epss_score": 0.0558, "epss_percentile": 0.9002}, "CVE-2014-0553": {"epss_score": 0.01621, "epss_percentile": 0.81392}, "CVE-2014-0554": {"epss_score": 0.10196, "epss_percentile": 0.92888}, "CVE-2014-0555": {"epss_score": 0.0558, "epss_percentile": 0.9002}, "CVE-2014-0556": {"epss_score": 0.84518, "epss_percentile": 0.99293}, "CVE-2014-0557": {"epss_score": 0.02702, "epss_percentile": 0.85456}, "CVE-2014-0558": {"epss_score": 0.15429, "epss_percentile": 0.94429}, "CVE-2014-0559": {"epss_score": 0.19325, "epss_percentile": 0.95164}, "CVE-2014-0560": {"epss_score": 0.15201, "epss_percentile": 0.94383}, "CVE-2014-0561": {"epss_score": 0.41354, "epss_percentile": 0.97268}, "CVE-2014-0562": {"epss_score": 0.00567, "epss_percentile": 0.6785}, "CVE-2014-0563": {"epss_score": 0.01352, "epss_percentile": 0.79689}, "CVE-2014-0564": {"epss_score": 0.07547, "epss_percentile": 0.91531}, "CVE-2014-0565": {"epss_score": 0.21346, "epss_percentile": 0.95504}, "CVE-2014-0566": {"epss_score": 0.04493, "epss_percentile": 0.8876}, "CVE-2014-0567": {"epss_score": 0.33987, "epss_percentile": 0.96819}, "CVE-2014-0568": {"epss_score": 0.06357, "epss_percentile": 0.90695}, "CVE-2014-0569": {"epss_score": 0.89007, "epss_percentile": 0.99505}, "CVE-2014-0570": {"epss_score": 0.00229, "epss_percentile": 0.45615}, "CVE-2014-0571": {"epss_score": 0.00667, "epss_percentile": 0.70711}, "CVE-2014-0572": {"epss_score": 0.00181, "epss_percentile": 0.40118}, "CVE-2014-0573": {"epss_score": 0.08236, "epss_percentile": 0.91944}, "CVE-2014-0574": {"epss_score": 0.11795, "epss_percentile": 0.93479}, "CVE-2014-0576": {"epss_score": 0.11983, "epss_percentile": 0.93535}, "CVE-2014-0577": {"epss_score": 0.12312, "epss_percentile": 0.93634}, "CVE-2014-0578": {"epss_score": 0.00363, "epss_percentile": 0.57901}, "CVE-2014-0580": {"epss_score": 0.02655, "epss_percentile": 0.85355}, "CVE-2014-0581": {"epss_score": 0.11983, "epss_percentile": 0.93535}, "CVE-2014-0582": {"epss_score": 0.23401, "epss_percentile": 0.95773}, "CVE-2014-0583": {"epss_score": 0.04006, "epss_percentile": 0.88103}, "CVE-2014-0584": {"epss_score": 0.12312, "epss_percentile": 0.93634}, "CVE-2014-0585": {"epss_score": 0.08046, "epss_percentile": 0.91851}, "CVE-2014-0586": {"epss_score": 0.12312, "epss_percentile": 0.93634}, "CVE-2014-0587": {"epss_score": 0.10803, "epss_percentile": 0.93107}, "CVE-2014-0588": {"epss_score": 0.08167, "epss_percentile": 0.91912}, "CVE-2014-0589": {"epss_score": 0.09661, "epss_percentile": 0.92644}, "CVE-2014-0590": {"epss_score": 0.15077, "epss_percentile": 0.94357}, "CVE-2014-0591": {"epss_score": 0.37852, "epss_percentile": 0.97073}, "CVE-2014-0592": {"epss_score": 0.00352, "epss_percentile": 0.57103}, "CVE-2014-0593": {"epss_score": 0.0047, "epss_percentile": 0.63979}, "CVE-2014-0594": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2014-0595": {"epss_score": 0.00125, "epss_percentile": 0.32617}, "CVE-2014-0598": {"epss_score": 0.00681, "epss_percentile": 0.71059}, "CVE-2014-0599": {"epss_score": 0.00815, "epss_percentile": 0.73794}, "CVE-2014-0600": {"epss_score": 0.05716, "epss_percentile": 0.90147}, "CVE-2014-0602": {"epss_score": 0.00912, "epss_percentile": 0.75362}, "CVE-2014-0603": {"epss_score": 0.1138, "epss_percentile": 0.93327}, "CVE-2014-0604": {"epss_score": 0.08157, "epss_percentile": 0.91907}, "CVE-2014-0605": {"epss_score": 0.0685, "epss_percentile": 0.91072}, "CVE-2014-0607": {"epss_score": 0.06843, "epss_percentile": 0.91063}, "CVE-2014-0609": {"epss_score": 0.00207, "epss_percentile": 0.43162}, "CVE-2014-0610": {"epss_score": 0.07006, "epss_percentile": 0.91179}, "CVE-2014-0611": {"epss_score": 0.02418, "epss_percentile": 0.84697}, "CVE-2014-0612": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2014-0613": {"epss_score": 0.00648, "epss_percentile": 0.70215}, "CVE-2014-0614": {"epss_score": 0.00693, "epss_percentile": 0.71335}, "CVE-2014-0615": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2014-0616": {"epss_score": 0.00606, "epss_percentile": 0.69016}, "CVE-2014-0617": {"epss_score": 0.00782, "epss_percentile": 0.73202}, "CVE-2014-0618": {"epss_score": 0.00462, "epss_percentile": 0.63617}, "CVE-2014-0619": {"epss_score": 0.00092, "epss_percentile": 0.26512}, "CVE-2014-0620": {"epss_score": 0.00824, "epss_percentile": 0.73941}, "CVE-2014-0621": {"epss_score": 0.00375, "epss_percentile": 0.58638}, "CVE-2014-0622": {"epss_score": 0.00447, "epss_percentile": 0.62989}, "CVE-2014-0623": {"epss_score": 0.00202, "epss_percentile": 0.42465}, "CVE-2014-0624": {"epss_score": 0.00077, "epss_percentile": 0.23355}, "CVE-2014-0625": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-0626": {"epss_score": 0.00184, "epss_percentile": 0.40384}, "CVE-2014-0627": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2014-0628": {"epss_score": 0.00255, "epss_percentile": 0.48653}, "CVE-2014-0629": {"epss_score": 0.00546, "epss_percentile": 0.67209}, "CVE-2014-0630": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2014-0632": {"epss_score": 0.02702, "epss_percentile": 0.85457}, "CVE-2014-0633": {"epss_score": 0.00276, "epss_percentile": 0.50715}, "CVE-2014-0634": {"epss_score": 0.00366, "epss_percentile": 0.58066}, "CVE-2014-0635": {"epss_score": 0.00301, "epss_percentile": 0.53068}, "CVE-2014-0636": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2014-0637": {"epss_score": 0.00202, "epss_percentile": 0.42465}, "CVE-2014-0638": {"epss_score": 0.00202, "epss_percentile": 0.42465}, "CVE-2014-0639": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-0640": {"epss_score": 0.00199, "epss_percentile": 0.42159}, "CVE-2014-0641": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2014-0642": {"epss_score": 0.00152, "epss_percentile": 0.36385}, "CVE-2014-0643": {"epss_score": 0.0095, "epss_percentile": 0.75852}, "CVE-2014-0644": {"epss_score": 0.74022, "epss_percentile": 0.98782}, "CVE-2014-0645": {"epss_score": 0.00069, "epss_percentile": 0.21579}, "CVE-2014-0646": {"epss_score": 0.00052, "epss_percentile": 0.16604}, "CVE-2014-0647": {"epss_score": 0.00079, "epss_percentile": 0.23975}, "CVE-2014-0648": {"epss_score": 0.08672, "epss_percentile": 0.92183}, "CVE-2014-0649": {"epss_score": 0.03423, "epss_percentile": 0.87109}, "CVE-2014-0650": {"epss_score": 0.06622, "epss_percentile": 0.90895}, "CVE-2014-0651": {"epss_score": 0.00425, "epss_percentile": 0.61711}, "CVE-2014-0652": {"epss_score": 0.00543, "epss_percentile": 0.67111}, "CVE-2014-0653": {"epss_score": 0.0067, "epss_percentile": 0.70777}, "CVE-2014-0654": {"epss_score": 0.00769, "epss_percentile": 0.72988}, "CVE-2014-0655": {"epss_score": 0.0056, "epss_percentile": 0.67635}, "CVE-2014-0656": {"epss_score": 0.00377, "epss_percentile": 0.58703}, "CVE-2014-0657": {"epss_score": 0.00445, "epss_percentile": 0.62851}, "CVE-2014-0658": {"epss_score": 0.01745, "epss_percentile": 0.82069}, "CVE-2014-0659": {"epss_score": 0.65604, "epss_percentile": 0.98428}, "CVE-2014-0660": {"epss_score": 0.01513, "epss_percentile": 0.8079}, "CVE-2014-0661": {"epss_score": 0.04042, "epss_percentile": 0.88168}, "CVE-2014-0662": {"epss_score": 0.01513, "epss_percentile": 0.8079}, "CVE-2014-0663": {"epss_score": 0.00561, "epss_percentile": 0.67676}, "CVE-2014-0664": {"epss_score": 0.01842, "epss_percentile": 0.82499}, "CVE-2014-0665": {"epss_score": 0.00381, "epss_percentile": 0.59009}, "CVE-2014-0666": {"epss_score": 0.10364, "epss_percentile": 0.9296}, "CVE-2014-0667": {"epss_score": 0.00623, "epss_percentile": 0.69539}, "CVE-2014-0668": {"epss_score": 0.00561, "epss_percentile": 0.67676}, "CVE-2014-0669": {"epss_score": 0.00702, "epss_percentile": 0.71505}, "CVE-2014-0670": {"epss_score": 0.00543, "epss_percentile": 0.67111}, "CVE-2014-0671": {"epss_score": 0.00737, "epss_percentile": 0.7232}, "CVE-2014-0672": {"epss_score": 0.00501, "epss_percentile": 0.65345}, "CVE-2014-0673": {"epss_score": 0.00543, "epss_percentile": 0.67111}, "CVE-2014-0674": {"epss_score": 0.01683, "epss_percentile": 0.81738}, "CVE-2014-0675": {"epss_score": 0.00448, "epss_percentile": 0.63027}, "CVE-2014-0676": {"epss_score": 0.00084, "epss_percentile": 0.24969}, "CVE-2014-0677": {"epss_score": 0.01295, "epss_percentile": 0.79249}, "CVE-2014-0678": {"epss_score": 0.00381, "epss_percentile": 0.59009}, "CVE-2014-0679": {"epss_score": 0.00613, "epss_percentile": 0.6924}, "CVE-2014-0680": {"epss_score": 0.00532, "epss_percentile": 0.667}, "CVE-2014-0681": {"epss_score": 0.00707, "epss_percentile": 0.71652}, "CVE-2014-0682": {"epss_score": 0.00814, "epss_percentile": 0.73771}, "CVE-2014-0683": {"epss_score": 0.29437, "epss_percentile": 0.96442}, "CVE-2014-0684": {"epss_score": 0.00208, "epss_percentile": 0.43219}, "CVE-2014-0685": {"epss_score": 0.0016, "epss_percentile": 0.37452}, "CVE-2014-0686": {"epss_score": 0.00065, "epss_percentile": 0.20656}, "CVE-2014-0691": {"epss_score": 0.00164, "epss_percentile": 0.37987}, "CVE-2014-0694": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-0701": {"epss_score": 0.00393, "epss_percentile": 0.59734}, "CVE-2014-0703": {"epss_score": 0.00931, "epss_percentile": 0.75621}, "CVE-2014-0704": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2014-0705": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2014-0706": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-0707": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-0708": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2014-0709": {"epss_score": 0.00471, "epss_percentile": 0.64014}, "CVE-2014-0710": {"epss_score": 0.00309, "epss_percentile": 0.53678}, "CVE-2014-0718": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2014-0719": {"epss_score": 0.0023, "epss_percentile": 0.45714}, "CVE-2014-0720": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2014-0721": {"epss_score": 0.01135, "epss_percentile": 0.77908}, "CVE-2014-0722": {"epss_score": 0.00737, "epss_percentile": 0.7232}, "CVE-2014-0723": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-0724": {"epss_score": 0.00282, "epss_percentile": 0.51273}, "CVE-2014-0725": {"epss_score": 0.00275, "epss_percentile": 0.50686}, "CVE-2014-0726": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2014-0727": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2014-0728": {"epss_score": 0.00482, "epss_percentile": 0.64524}, "CVE-2014-0729": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2014-0730": {"epss_score": 0.0007, "epss_percentile": 0.21719}, "CVE-2014-0731": {"epss_score": 0.0022, "epss_percentile": 0.44555}, "CVE-2014-0732": {"epss_score": 0.00214, "epss_percentile": 0.44001}, "CVE-2014-0733": {"epss_score": 0.00301, "epss_percentile": 0.53048}, "CVE-2014-0734": {"epss_score": 0.00222, "epss_percentile": 0.44776}, "CVE-2014-0735": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2014-0736": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2014-0737": {"epss_score": 0.00191, "epss_percentile": 0.41218}, "CVE-2014-0738": {"epss_score": 0.00098, "epss_percentile": 0.27831}, "CVE-2014-0739": {"epss_score": 0.00184, "epss_percentile": 0.40397}, "CVE-2014-0740": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2014-0741": {"epss_score": 0.00036, "epss_percentile": 0.10374}, "CVE-2014-0742": {"epss_score": 0.00036, "epss_percentile": 0.10374}, "CVE-2014-0743": {"epss_score": 0.00462, "epss_percentile": 0.6362}, "CVE-2014-0745": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2014-0746": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2014-0747": {"epss_score": 0.00049, "epss_percentile": 0.15289}, "CVE-2014-0748": {"epss_score": 0.00045, "epss_percentile": 0.13833}, "CVE-2014-0749": {"epss_score": 0.62247, "epss_percentile": 0.98286}, "CVE-2014-0750": {"epss_score": 0.37562, "epss_percentile": 0.97058}, "CVE-2014-0751": {"epss_score": 0.01283, "epss_percentile": 0.79161}, "CVE-2014-0752": {"epss_score": 0.00648, "epss_percentile": 0.7022}, "CVE-2014-0753": {"epss_score": 0.01022, "epss_percentile": 0.76761}, "CVE-2014-0754": {"epss_score": 0.16667, "epss_percentile": 0.9471}, "CVE-2014-0755": {"epss_score": 4e-05, "epss_percentile": 0.00147}, "CVE-2014-0757": {"epss_score": 0.00905, "epss_percentile": 0.75231}, "CVE-2014-0758": {"epss_score": 0.00635, "epss_percentile": 0.69828}, "CVE-2014-0759": {"epss_score": 0.00654, "epss_percentile": 0.70349}, "CVE-2014-0760": {"epss_score": 0.02701, "epss_percentile": 0.85453}, "CVE-2014-0761": {"epss_score": 0.01235, "epss_percentile": 0.78764}, "CVE-2014-0762": {"epss_score": 0.0008, "epss_percentile": 0.24111}, "CVE-2014-0763": {"epss_score": 0.53336, "epss_percentile": 0.97872}, "CVE-2014-0764": {"epss_score": 0.0118, "epss_percentile": 0.783}, "CVE-2014-0765": {"epss_score": 0.0118, "epss_percentile": 0.783}, "CVE-2014-0766": {"epss_score": 0.0118, "epss_percentile": 0.783}, "CVE-2014-0767": {"epss_score": 0.0118, "epss_percentile": 0.783}, "CVE-2014-0768": {"epss_score": 0.0118, "epss_percentile": 0.783}, "CVE-2014-0769": {"epss_score": 0.0044, "epss_percentile": 0.62634}, "CVE-2014-0770": {"epss_score": 0.01077, "epss_percentile": 0.77335}, "CVE-2014-0771": {"epss_score": 0.00339, "epss_percentile": 0.56203}, "CVE-2014-0772": {"epss_score": 0.0035, "epss_percentile": 0.56924}, "CVE-2014-0773": {"epss_score": 0.00381, "epss_percentile": 0.58979}, "CVE-2014-0774": {"epss_score": 0.00063, "epss_percentile": 0.19836}, "CVE-2014-0777": {"epss_score": 0.01974, "epss_percentile": 0.83112}, "CVE-2014-0778": {"epss_score": 0.00593, "epss_percentile": 0.68644}, "CVE-2014-0779": {"epss_score": 0.00676, "epss_percentile": 0.70932}, "CVE-2014-0780": {"epss_score": 0.89247, "epss_percentile": 0.99516}, "CVE-2014-0781": {"epss_score": 0.07956, "epss_percentile": 0.91788}, "CVE-2014-0782": {"epss_score": 0.43441, "epss_percentile": 0.97387}, "CVE-2014-0783": {"epss_score": 0.07807, "epss_percentile": 0.91692}, "CVE-2014-0784": {"epss_score": 0.03519, "epss_percentile": 0.87282}, "CVE-2014-0786": {"epss_score": 0.00889, "epss_percentile": 0.75019}, "CVE-2014-0787": {"epss_score": 0.50859, "epss_percentile": 0.97753}, "CVE-2014-0789": {"epss_score": 0.01052, "epss_percentile": 0.77088}, "CVE-2014-0791": {"epss_score": 0.01529, "epss_percentile": 0.80882}, "CVE-2014-0792": {"epss_score": 0.02095, "epss_percentile": 0.83581}, "CVE-2014-0793": {"epss_score": 0.00482, "epss_percentile": 0.64543}, "CVE-2014-0794": {"epss_score": 0.0001, "epss_percentile": 0.00897}, "CVE-2014-0802": {"epss_score": 0.00277, "epss_percentile": 0.5082}, "CVE-2014-0803": {"epss_score": 0.00344, "epss_percentile": 0.56495}, "CVE-2014-0804": {"epss_score": 0.00344, "epss_percentile": 0.56495}, "CVE-2014-0805": {"epss_score": 0.00573, "epss_percentile": 0.68052}, "CVE-2014-0806": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2014-0807": {"epss_score": 0.00527, "epss_percentile": 0.66532}, "CVE-2014-0808": {"epss_score": 0.00388, "epss_percentile": 0.59342}, "CVE-2014-0809": {"epss_score": 0.00203, "epss_percentile": 0.42515}, "CVE-2014-0810": {"epss_score": 0.04968, "epss_percentile": 0.89345}, "CVE-2014-0811": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2014-0812": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2014-0813": {"epss_score": 0.00386, "epss_percentile": 0.59283}, "CVE-2014-0814": {"epss_score": 0.00532, "epss_percentile": 0.667}, "CVE-2014-0815": {"epss_score": 0.00375, "epss_percentile": 0.58608}, "CVE-2014-0816": {"epss_score": 0.00545, "epss_percentile": 0.67188}, "CVE-2014-0817": {"epss_score": 0.00218, "epss_percentile": 0.44394}, "CVE-2014-0818": {"epss_score": 0.00779, "epss_percentile": 0.73157}, "CVE-2014-0819": {"epss_score": 0.00073, "epss_percentile": 0.22658}, "CVE-2014-0820": {"epss_score": 0.00244, "epss_percentile": 0.4755}, "CVE-2014-0821": {"epss_score": 0.0039, "epss_percentile": 0.59504}, "CVE-2014-0822": {"epss_score": 0.01089, "epss_percentile": 0.77446}, "CVE-2014-0823": {"epss_score": 0.0039, "epss_percentile": 0.59554}, "CVE-2014-0824": {"epss_score": 0.00161, "epss_percentile": 0.37546}, "CVE-2014-0825": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-0827": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2014-0828": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2014-0829": {"epss_score": 0.00518, "epss_percentile": 0.66141}, "CVE-2014-0830": {"epss_score": 0.00239, "epss_percentile": 0.4693}, "CVE-2014-0831": {"epss_score": 0.00112, "epss_percentile": 0.30512}, "CVE-2014-0832": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-0833": {"epss_score": 0.00154, "epss_percentile": 0.3668}, "CVE-2014-0834": {"epss_score": 0.00688, "epss_percentile": 0.71207}, "CVE-2014-0835": {"epss_score": 0.00211, "epss_percentile": 0.43675}, "CVE-2014-0836": {"epss_score": 0.00427, "epss_percentile": 0.61897}, "CVE-2014-0837": {"epss_score": 0.00262, "epss_percentile": 0.49361}, "CVE-2014-0838": {"epss_score": 0.00706, "epss_percentile": 0.71622}, "CVE-2014-0839": {"epss_score": 0.00154, "epss_percentile": 0.36652}, "CVE-2014-0840": {"epss_score": 0.00251, "epss_percentile": 0.48294}, "CVE-2014-0841": {"epss_score": 0.00023, "epss_percentile": 0.05388}, "CVE-2014-0842": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2014-0843": {"epss_score": 0.00251, "epss_percentile": 0.48294}, "CVE-2014-0844": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2014-0845": {"epss_score": 0.0016, "epss_percentile": 0.37441}, "CVE-2014-0846": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-0848": {"epss_score": 0.00255, "epss_percentile": 0.48652}, "CVE-2014-0849": {"epss_score": 0.00369, "epss_percentile": 0.58249}, "CVE-2014-0850": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-0852": {"epss_score": 0.00408, "epss_percentile": 0.60681}, "CVE-2014-0853": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-0854": {"epss_score": 0.00217, "epss_percentile": 0.44299}, "CVE-2014-0855": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2014-0857": {"epss_score": 0.00253, "epss_percentile": 0.48493}, "CVE-2014-0858": {"epss_score": 0.00121, "epss_percentile": 0.31889}, "CVE-2014-0859": {"epss_score": 0.0162, "epss_percentile": 0.81384}, "CVE-2014-0860": {"epss_score": 0.00236, "epss_percentile": 0.46422}, "CVE-2014-0861": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-0862": {"epss_score": 0.17369, "epss_percentile": 0.94839}, "CVE-2014-0863": {"epss_score": 0.00202, "epss_percentile": 0.42412}, "CVE-2014-0864": {"epss_score": 0.03286, "epss_percentile": 0.86826}, "CVE-2014-0865": {"epss_score": 0.1001, "epss_percentile": 0.92817}, "CVE-2014-0866": {"epss_score": 0.16888, "epss_percentile": 0.94741}, "CVE-2014-0867": {"epss_score": 0.14028, "epss_percentile": 0.94117}, "CVE-2014-0868": {"epss_score": 0.11298, "epss_percentile": 0.93297}, "CVE-2014-0869": {"epss_score": 0.16888, "epss_percentile": 0.94741}, "CVE-2014-0870": {"epss_score": 0.08468, "epss_percentile": 0.92067}, "CVE-2014-0871": {"epss_score": 0.14308, "epss_percentile": 0.94184}, "CVE-2014-0872": {"epss_score": 0.00042, "epss_percentile": 0.12811}, "CVE-2014-0873": {"epss_score": 0.00103, "epss_percentile": 0.28976}, "CVE-2014-0874": {"epss_score": 0.00186, "epss_percentile": 0.40694}, "CVE-2014-0875": {"epss_score": 0.0014, "epss_percentile": 0.34785}, "CVE-2014-0876": {"epss_score": 0.00056, "epss_percentile": 0.17877}, "CVE-2014-0877": {"epss_score": 0.00261, "epss_percentile": 0.49292}, "CVE-2014-0878": {"epss_score": 0.00559, "epss_percentile": 0.67604}, "CVE-2014-0879": {"epss_score": 0.22902, "epss_percentile": 0.95704}, "CVE-2014-0880": {"epss_score": 0.00751, "epss_percentile": 0.72648}, "CVE-2014-0881": {"epss_score": 0.00975, "epss_percentile": 0.76203}, "CVE-2014-0882": {"epss_score": 0.00228, "epss_percentile": 0.4547}, "CVE-2014-0883": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2014-0884": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-0885": {"epss_score": 0.00109, "epss_percentile": 0.30039}, "CVE-2014-0886": {"epss_score": 0.00444, "epss_percentile": 0.62831}, "CVE-2014-0887": {"epss_score": 0.0064, "epss_percentile": 0.69958}, "CVE-2014-0888": {"epss_score": 0.0017, "epss_percentile": 0.38661}, "CVE-2014-0889": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2014-0890": {"epss_score": 0.0005, "epss_percentile": 0.15971}, "CVE-2014-0891": {"epss_score": 0.0039, "epss_percentile": 0.59554}, "CVE-2014-0892": {"epss_score": 0.01315, "epss_percentile": 0.79401}, "CVE-2014-0893": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2014-0894": {"epss_score": 0.10745, "epss_percentile": 0.93091}, "CVE-2014-0895": {"epss_score": 0.12815, "epss_percentile": 0.93782}, "CVE-2014-0896": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2014-0897": {"epss_score": 0.00093, "epss_percentile": 0.26716}, "CVE-2014-0899": {"epss_score": 0.00297, "epss_percentile": 0.52691}, "CVE-2014-0900": {"epss_score": 0.00146, "epss_percentile": 0.35532}, "CVE-2014-0901": {"epss_score": 0.0018, "epss_percentile": 0.39969}, "CVE-2014-0904": {"epss_score": 0.12208, "epss_percentile": 0.93602}, "CVE-2014-0905": {"epss_score": 0.0011, "epss_percentile": 0.30208}, "CVE-2014-0906": {"epss_score": 0.00218, "epss_percentile": 0.44413}, "CVE-2014-0907": {"epss_score": 0.00073, "epss_percentile": 0.22535}, "CVE-2014-0908": {"epss_score": 0.005, "epss_percentile": 0.6532}, "CVE-2014-0909": {"epss_score": 0.00349, "epss_percentile": 0.56875}, "CVE-2014-0910": {"epss_score": 0.0128, "epss_percentile": 0.79138}, "CVE-2014-0911": {"epss_score": 0.00556, "epss_percentile": 0.67518}, "CVE-2014-0912": {"epss_score": 0.00172, "epss_percentile": 0.38961}, "CVE-2014-0913": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2014-0914": {"epss_score": 0.00301, "epss_percentile": 0.53015}, "CVE-2014-0915": {"epss_score": 0.00301, "epss_percentile": 0.53015}, "CVE-2014-0917": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2014-0918": {"epss_score": 0.0019, "epss_percentile": 0.41137}, "CVE-2014-0919": {"epss_score": 0.00355, "epss_percentile": 0.57295}, "CVE-2014-0920": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2014-0921": {"epss_score": 0.00556, "epss_percentile": 0.67518}, "CVE-2014-0922": {"epss_score": 0.00556, "epss_percentile": 0.67518}, "CVE-2014-0923": {"epss_score": 0.01035, "epss_percentile": 0.76902}, "CVE-2014-0924": {"epss_score": 0.00216, "epss_percentile": 0.44157}, "CVE-2014-0925": {"epss_score": 0.00141, "epss_percentile": 0.34947}, "CVE-2014-0927": {"epss_score": 0.00345, "epss_percentile": 0.56547}, "CVE-2014-0929": {"epss_score": 0.00108, "epss_percentile": 0.2984}, "CVE-2014-0930": {"epss_score": 0.00112, "epss_percentile": 0.30473}, "CVE-2014-0931": {"epss_score": 0.0073, "epss_percentile": 0.72161}, "CVE-2014-0932": {"epss_score": 0.0018, "epss_percentile": 0.39969}, "CVE-2014-0933": {"epss_score": 0.00112, "epss_percentile": 0.30512}, "CVE-2014-0935": {"epss_score": 0.0028, "epss_percentile": 0.51039}, "CVE-2014-0936": {"epss_score": 0.00237, "epss_percentile": 0.46651}, "CVE-2014-0940": {"epss_score": 0.00321, "epss_percentile": 0.54651}, "CVE-2014-0941": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-0942": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-0943": {"epss_score": 0.01163, "epss_percentile": 0.78159}, "CVE-2014-0944": {"epss_score": 0.00222, "epss_percentile": 0.44757}, "CVE-2014-0945": {"epss_score": 0.00441, "epss_percentile": 0.62693}, "CVE-2014-0946": {"epss_score": 0.00751, "epss_percentile": 0.72635}, "CVE-2014-0947": {"epss_score": 0.0252, "epss_percentile": 0.85}, "CVE-2014-0948": {"epss_score": 0.0252, "epss_percentile": 0.85}, "CVE-2014-0949": {"epss_score": 0.00594, "epss_percentile": 0.68675}, "CVE-2014-0950": {"epss_score": 0.00452, "epss_percentile": 0.63168}, "CVE-2014-0951": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2014-0952": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2014-0953": {"epss_score": 0.00322, "epss_percentile": 0.54826}, "CVE-2014-0954": {"epss_score": 0.00254, "epss_percentile": 0.48504}, "CVE-2014-0955": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2014-0956": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2014-0957": {"epss_score": 0.00278, "epss_percentile": 0.50874}, "CVE-2014-0958": {"epss_score": 0.00227, "epss_percentile": 0.45394}, "CVE-2014-0959": {"epss_score": 0.00373, "epss_percentile": 0.58474}, "CVE-2014-0960": {"epss_score": 0.00127, "epss_percentile": 0.32866}, "CVE-2014-0961": {"epss_score": 0.00108, "epss_percentile": 0.2984}, "CVE-2014-0963": {"epss_score": 0.02106, "epss_percentile": 0.83632}, "CVE-2014-0964": {"epss_score": 0.0195, "epss_percentile": 0.83015}, "CVE-2014-0965": {"epss_score": 0.00609, "epss_percentile": 0.69091}, "CVE-2014-0966": {"epss_score": 0.00348, "epss_percentile": 0.56824}, "CVE-2014-0967": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-0968": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-0969": {"epss_score": 0.00212, "epss_percentile": 0.43793}, "CVE-2014-0970": {"epss_score": 0.00154, "epss_percentile": 0.36652}, "CVE-2014-0972": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2014-0973": {"epss_score": 0.00055, "epss_percentile": 0.17562}, "CVE-2014-0974": {"epss_score": 0.00056, "epss_percentile": 0.1783}, "CVE-2014-0977": {"epss_score": 0.00604, "epss_percentile": 0.68963}, "CVE-2014-0978": {"epss_score": 0.06542, "epss_percentile": 0.90835}, "CVE-2014-0979": {"epss_score": 0.00077, "epss_percentile": 0.23536}, "CVE-2014-0980": {"epss_score": 0.8216, "epss_percentile": 0.99177}, "CVE-2014-0981": {"epss_score": 0.04887, "epss_percentile": 0.89257}, "CVE-2014-0983": {"epss_score": 0.12015, "epss_percentile": 0.93547}, "CVE-2014-0984": {"epss_score": 0.08968, "epss_percentile": 0.92343}, "CVE-2014-0985": {"epss_score": 0.01693, "epss_percentile": 0.81799}, "CVE-2014-0986": {"epss_score": 0.01693, "epss_percentile": 0.81799}, "CVE-2014-0987": {"epss_score": 0.01693, "epss_percentile": 0.81799}, "CVE-2014-0988": {"epss_score": 0.01693, "epss_percentile": 0.81799}, "CVE-2014-0989": {"epss_score": 0.01693, "epss_percentile": 0.81799}, "CVE-2014-0990": {"epss_score": 0.01693, "epss_percentile": 0.81799}, "CVE-2014-0991": {"epss_score": 0.01693, "epss_percentile": 0.81799}, "CVE-2014-0992": {"epss_score": 0.01693, "epss_percentile": 0.81799}, "CVE-2014-0993": {"epss_score": 0.029, "epss_percentile": 0.85952}, "CVE-2014-0994": {"epss_score": 0.01734, "epss_percentile": 0.82}, "CVE-2014-0995": {"epss_score": 0.29647, "epss_percentile": 0.96463}, "CVE-2014-0997": {"epss_score": 0.17257, "epss_percentile": 0.94811}, "CVE-2014-0998": {"epss_score": 0.00851, "epss_percentile": 0.74396}, "CVE-2014-0999": {"epss_score": 0.14481, "epss_percentile": 0.9422}, "CVE-2014-100001": {"epss_score": 0.00179, "epss_percentile": 0.39844}, "CVE-2014-100002": {"epss_score": 0.77036, "epss_percentile": 0.98917}, "CVE-2014-100003": {"epss_score": 0.01533, "epss_percentile": 0.809}, "CVE-2014-100004": {"epss_score": 0.00385, "epss_percentile": 0.59189}, "CVE-2014-100005": {"epss_score": 0.35431, "epss_percentile": 0.96909}, "CVE-2014-100006": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-100007": {"epss_score": 0.00306, "epss_percentile": 0.53464}, "CVE-2014-100008": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2014-100009": {"epss_score": 0.00263, "epss_percentile": 0.49541}, "CVE-2014-100010": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2014-100011": {"epss_score": 0.00293, "epss_percentile": 0.52286}, "CVE-2014-100012": {"epss_score": 0.00247, "epss_percentile": 0.47814}, "CVE-2014-100013": {"epss_score": 0.00453, "epss_percentile": 0.63212}, "CVE-2014-100014": {"epss_score": 0.10079, "epss_percentile": 0.92841}, "CVE-2014-100015": {"epss_score": 0.77303, "epss_percentile": 0.98931}, "CVE-2014-100016": {"epss_score": 0.00233, "epss_percentile": 0.46}, "CVE-2014-100017": {"epss_score": 0.0338, "epss_percentile": 0.8703}, "CVE-2014-100018": {"epss_score": 0.00198, "epss_percentile": 0.42023}, "CVE-2014-100019": {"epss_score": 0.0041, "epss_percentile": 0.60845}, "CVE-2014-100020": {"epss_score": 0.01069, "epss_percentile": 0.7725}, "CVE-2014-100021": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-100022": {"epss_score": 0.00424, "epss_percentile": 0.6164}, "CVE-2014-100023": {"epss_score": 0.00227, "epss_percentile": 0.45388}, "CVE-2014-100024": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-100025": {"epss_score": 0.00306, "epss_percentile": 0.53398}, "CVE-2014-100026": {"epss_score": 0.00225, "epss_percentile": 0.45138}, "CVE-2014-100027": {"epss_score": 0.00198, "epss_percentile": 0.42023}, "CVE-2014-100028": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-100029": {"epss_score": 0.07167, "epss_percentile": 0.91296}, "CVE-2014-100030": {"epss_score": 0.04055, "epss_percentile": 0.88184}, "CVE-2014-100031": {"epss_score": 0.0116, "epss_percentile": 0.78131}, "CVE-2014-100032": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-100033": {"epss_score": 0.00223, "epss_percentile": 0.44872}, "CVE-2014-100034": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-100035": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2014-100036": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-100037": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-100038": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-100039": {"epss_score": 0.00193, "epss_percentile": 0.41465}, "CVE-2014-10001": {"epss_score": 0.01285, "epss_percentile": 0.7918}, "CVE-2014-10002": {"epss_score": 3e-05, "epss_percentile": 0.00114}, "CVE-2014-10003": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-10004": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2014-10005": {"epss_score": 0.00356, "epss_percentile": 0.57346}, "CVE-2014-10006": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2014-10007": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-10008": {"epss_score": 0.00818, "epss_percentile": 0.7386}, "CVE-2014-10009": {"epss_score": 0.02882, "epss_percentile": 0.85903}, "CVE-2014-10010": {"epss_score": 0.07214, "epss_percentile": 0.9133}, "CVE-2014-10011": {"epss_score": 0.20817, "epss_percentile": 0.95418}, "CVE-2014-10012": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-10013": {"epss_score": 0.019, "epss_percentile": 0.82769}, "CVE-2014-10014": {"epss_score": 0.00853, "epss_percentile": 0.7443}, "CVE-2014-10015": {"epss_score": 0.01016, "epss_percentile": 0.76676}, "CVE-2014-10016": {"epss_score": 0.00198, "epss_percentile": 0.42023}, "CVE-2014-10017": {"epss_score": 0.00422, "epss_percentile": 0.61542}, "CVE-2014-10018": {"epss_score": 0.00752, "epss_percentile": 0.72655}, "CVE-2014-10019": {"epss_score": 0.00559, "epss_percentile": 0.67615}, "CVE-2014-10020": {"epss_score": 0.0096, "epss_percentile": 0.75967}, "CVE-2014-10021": {"epss_score": 0.77231, "epss_percentile": 0.98927}, "CVE-2014-10022": {"epss_score": 0.02709, "epss_percentile": 0.8548}, "CVE-2014-10023": {"epss_score": 0.0408, "epss_percentile": 0.88217}, "CVE-2014-10024": {"epss_score": 0.03377, "epss_percentile": 0.87023}, "CVE-2014-10025": {"epss_score": 0.00442, "epss_percentile": 0.62745}, "CVE-2014-10026": {"epss_score": 0.00328, "epss_percentile": 0.55174}, "CVE-2014-10027": {"epss_score": 0.00442, "epss_percentile": 0.62745}, "CVE-2014-10028": {"epss_score": 0.00481, "epss_percentile": 0.64514}, "CVE-2014-10029": {"epss_score": 0.04276, "epss_percentile": 0.88482}, "CVE-2014-10030": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2014-10031": {"epss_score": 0.09874, "epss_percentile": 0.92748}, "CVE-2014-10032": {"epss_score": 0.00178, "epss_percentile": 0.39718}, "CVE-2014-10033": {"epss_score": 0.00912, "epss_percentile": 0.75355}, "CVE-2014-10034": {"epss_score": 0.01858, "epss_percentile": 0.8258}, "CVE-2014-10035": {"epss_score": 0.09843, "epss_percentile": 0.92732}, "CVE-2014-10036": {"epss_score": 4e-05, "epss_percentile": 0.00155}, "CVE-2014-10037": {"epss_score": 0.72691, "epss_percentile": 0.98723}, "CVE-2014-10038": {"epss_score": 0.0096, "epss_percentile": 0.75967}, "CVE-2014-10039": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2014-10043": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2014-10044": {"epss_score": 0.00203, "epss_percentile": 0.42539}, "CVE-2014-10045": {"epss_score": 0.00267, "epss_percentile": 0.49958}, "CVE-2014-10046": {"epss_score": 0.00242, "epss_percentile": 0.47371}, "CVE-2014-10047": {"epss_score": 0.00118, "epss_percentile": 0.31477}, "CVE-2014-10048": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2014-10050": {"epss_score": 0.00167, "epss_percentile": 0.38328}, "CVE-2014-10051": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2014-10052": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2014-10053": {"epss_score": 0.00167, "epss_percentile": 0.38328}, "CVE-2014-10054": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2014-10055": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2014-10056": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2014-10057": {"epss_score": 0.00156, "epss_percentile": 0.36903}, "CVE-2014-10058": {"epss_score": 0.00203, "epss_percentile": 0.42539}, "CVE-2014-10059": {"epss_score": 0.00167, "epss_percentile": 0.38328}, "CVE-2014-10062": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2014-10063": {"epss_score": 0.00203, "epss_percentile": 0.42539}, "CVE-2014-10064": {"epss_score": 0.00562, "epss_percentile": 0.67704}, "CVE-2014-10065": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2014-10066": {"epss_score": 0.00979, "epss_percentile": 0.76262}, "CVE-2014-10067": {"epss_score": 0.00222, "epss_percentile": 0.44791}, "CVE-2014-10068": {"epss_score": 0.00476, "epss_percentile": 0.64279}, "CVE-2014-10069": {"epss_score": 0.05607, "epss_percentile": 0.90044}, "CVE-2014-10070": {"epss_score": 0.0015, "epss_percentile": 0.3609}, "CVE-2014-10071": {"epss_score": 0.00479, "epss_percentile": 0.64441}, "CVE-2014-10072": {"epss_score": 0.0036, "epss_percentile": 0.57651}, "CVE-2014-10073": {"epss_score": 0.00335, "epss_percentile": 0.55829}, "CVE-2014-10074": {"epss_score": 0.014, "epss_percentile": 0.8}, "CVE-2014-10075": {"epss_score": 0.03343, "epss_percentile": 0.86948}, "CVE-2014-10076": {"epss_score": 0.00571, "epss_percentile": 0.6799}, "CVE-2014-10077": {"epss_score": 0.01306, "epss_percentile": 0.79334}, "CVE-2014-10078": {"epss_score": 0.01979, "epss_percentile": 0.83134}, "CVE-2014-10079": {"epss_score": 0.12298, "epss_percentile": 0.93626}, "CVE-2014-10374": {"epss_score": 0.00184, "epss_percentile": 0.40401}, "CVE-2014-10375": {"epss_score": 0.00351, "epss_percentile": 0.57031}, "CVE-2014-10376": {"epss_score": 0.00477, "epss_percentile": 0.64351}, "CVE-2014-10377": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2014-10378": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2014-10379": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2014-10380": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2014-10381": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2014-10382": {"epss_score": 0.00103, "epss_percentile": 0.28963}, "CVE-2014-10383": {"epss_score": 0.01546, "epss_percentile": 0.80968}, "CVE-2014-10384": {"epss_score": 0.0091, "epss_percentile": 0.75319}, "CVE-2014-10385": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2014-10386": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2014-10387": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2014-10388": {"epss_score": 0.00249, "epss_percentile": 0.48079}, "CVE-2014-10389": {"epss_score": 0.00756, "epss_percentile": 0.72731}, "CVE-2014-10390": {"epss_score": 0.00524, "epss_percentile": 0.66364}, "CVE-2014-10391": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2014-10392": {"epss_score": 0.00284, "epss_percentile": 0.51421}, "CVE-2014-10393": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2014-10394": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2014-10395": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2014-10396": {"epss_score": 0.01146, "epss_percentile": 0.78002}, "CVE-2014-10397": {"epss_score": 0.01146, "epss_percentile": 0.78002}, "CVE-2014-10398": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2014-10399": {"epss_score": 0.00456, "epss_percentile": 0.63351}, "CVE-2014-10400": {"epss_score": 0.00456, "epss_percentile": 0.63351}, "CVE-2014-10401": {"epss_score": 0.00032, "epss_percentile": 0.08789}, "CVE-2014-10402": {"epss_score": 0.00023, "epss_percentile": 0.05451}, "CVE-2014-125001": {"epss_score": 0.04912, "epss_percentile": 0.89281}, "CVE-2014-125002": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125003": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125004": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125005": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125006": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125007": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125008": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125009": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125010": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125011": {"epss_score": 0.00168, "epss_percentile": 0.38457}, "CVE-2014-125012": {"epss_score": 0.00146, "epss_percentile": 0.35557}, "CVE-2014-125013": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125014": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125015": {"epss_score": 0.00196, "epss_percentile": 0.41782}, "CVE-2014-125016": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125017": {"epss_score": 0.00196, "epss_percentile": 0.41782}, "CVE-2014-125018": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125019": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125020": {"epss_score": 0.00196, "epss_percentile": 0.41782}, "CVE-2014-125021": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125022": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125023": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125024": {"epss_score": 0.00196, "epss_percentile": 0.41782}, "CVE-2014-125025": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2014-125026": {"epss_score": 0.0088, "epss_percentile": 0.74849}, "CVE-2014-125027": {"epss_score": 0.00306, "epss_percentile": 0.53442}, "CVE-2014-125028": {"epss_score": 0.00202, "epss_percentile": 0.4246}, "CVE-2014-125029": {"epss_score": 0.00055, "epss_percentile": 0.17449}, "CVE-2014-125030": {"epss_score": 0.00251, "epss_percentile": 0.48268}, "CVE-2014-125031": {"epss_score": 0.00306, "epss_percentile": 0.53442}, "CVE-2014-125032": {"epss_score": 0.00229, "epss_percentile": 0.45561}, "CVE-2014-125033": {"epss_score": 0.00124, "epss_percentile": 0.32361}, "CVE-2014-125034": {"epss_score": 0.00306, "epss_percentile": 0.53442}, "CVE-2014-125035": {"epss_score": 0.00104, "epss_percentile": 0.29196}, "CVE-2014-125036": {"epss_score": 0.00144, "epss_percentile": 0.35295}, "CVE-2014-125037": {"epss_score": 0.00229, "epss_percentile": 0.45561}, "CVE-2014-125038": {"epss_score": 0.00358, "epss_percentile": 0.57503}, "CVE-2014-125039": {"epss_score": 0.00353, "epss_percentile": 0.57149}, "CVE-2014-125040": {"epss_score": 0.00358, "epss_percentile": 0.57503}, "CVE-2014-125041": {"epss_score": 0.00358, "epss_percentile": 0.57503}, "CVE-2014-125044": {"epss_score": 0.00487, "epss_percentile": 0.64804}, "CVE-2014-125045": {"epss_score": 0.00358, "epss_percentile": 0.57503}, "CVE-2014-125046": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2014-125047": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2014-125048": {"epss_score": 0.00206, "epss_percentile": 0.43002}, "CVE-2014-125049": {"epss_score": 0.00043, "epss_percentile": 0.1328}, "CVE-2014-125050": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2014-125051": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2014-125052": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2014-125053": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2014-125054": {"epss_score": 0.00268, "epss_percentile": 0.50066}, "CVE-2014-125055": {"epss_score": 0.00117, "epss_percentile": 0.31243}, "CVE-2014-125056": {"epss_score": 0.00334, "epss_percentile": 0.55744}, "CVE-2014-125057": {"epss_score": 0.00099, "epss_percentile": 0.28387}, "CVE-2014-125058": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2014-125059": {"epss_score": 0.00081, "epss_percentile": 0.24229}, "CVE-2014-125060": {"epss_score": 0.00087, "epss_percentile": 0.25448}, "CVE-2014-125061": {"epss_score": 0.00077, "epss_percentile": 0.2353}, "CVE-2014-125062": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2014-125063": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2014-125065": {"epss_score": 0.00059, "epss_percentile": 0.18857}, "CVE-2014-125066": {"epss_score": 0.00069, "epss_percentile": 0.21613}, "CVE-2014-125067": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2014-125068": {"epss_score": 0.00099, "epss_percentile": 0.2841}, "CVE-2014-125069": {"epss_score": 0.0014, "epss_percentile": 0.34786}, "CVE-2014-125070": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2014-125071": {"epss_score": 0.0008, "epss_percentile": 0.24205}, "CVE-2014-125072": {"epss_score": 0.0003, "epss_percentile": 0.08032}, "CVE-2014-125073": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2014-125074": {"epss_score": 0.00055, "epss_percentile": 0.17609}, "CVE-2014-125075": {"epss_score": 0.00055, "epss_percentile": 0.17609}, "CVE-2014-125076": {"epss_score": 0.00055, "epss_percentile": 0.17609}, "CVE-2014-125077": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2014-125078": {"epss_score": 0.00073, "epss_percentile": 0.2265}, "CVE-2014-125079": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2014-125080": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2014-125081": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2014-125082": {"epss_score": 0.00073, "epss_percentile": 0.22478}, "CVE-2014-125083": {"epss_score": 0.00055, "epss_percentile": 0.17609}, "CVE-2014-125084": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2014-125085": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2014-125086": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2014-125087": {"epss_score": 0.00243, "epss_percentile": 0.47427}, "CVE-2014-125088": {"epss_score": 0.00073, "epss_percentile": 0.2265}, "CVE-2014-125089": {"epss_score": 0.00073, "epss_percentile": 0.2265}, "CVE-2014-125090": {"epss_score": 0.00098, "epss_percentile": 0.27776}, "CVE-2014-125091": {"epss_score": 0.00135, "epss_percentile": 0.33977}, "CVE-2014-125092": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2014-125093": {"epss_score": 0.00345, "epss_percentile": 0.56581}, "CVE-2014-125094": {"epss_score": 0.00073, "epss_percentile": 0.22499}, "CVE-2014-125095": {"epss_score": 0.00097, "epss_percentile": 0.27572}, "CVE-2014-125096": {"epss_score": 0.00115, "epss_percentile": 0.30949}, "CVE-2014-125097": {"epss_score": 0.00073, "epss_percentile": 0.22499}, "CVE-2014-125098": {"epss_score": 0.0009, "epss_percentile": 0.25989}, "CVE-2014-125099": {"epss_score": 0.00103, "epss_percentile": 0.28992}, "CVE-2014-125100": {"epss_score": 0.00078, "epss_percentile": 0.2359}, "CVE-2014-125101": {"epss_score": 0.00103, "epss_percentile": 0.28992}, "CVE-2014-125102": {"epss_score": 0.00081, "epss_percentile": 0.24295}, "CVE-2014-125103": {"epss_score": 0.00074, "epss_percentile": 0.2269}, "CVE-2014-125104": {"epss_score": 0.00065, "epss_percentile": 0.2059}, "CVE-2014-125105": {"epss_score": 0.00067, "epss_percentile": 0.21148}, "CVE-2014-125106": {"epss_score": 0.00089, "epss_percentile": 0.25805}, "CVE-2014-125107": {"epss_score": 0.00076, "epss_percentile": 0.23089}, "CVE-2014-125108": {"epss_score": 0.00078, "epss_percentile": 0.23614}, "CVE-2014-125109": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2014-125110": {"epss_score": 0.00097, "epss_percentile": 0.27497}, "CVE-2014-125111": {"epss_score": 0.00069, "epss_percentile": 0.21492}, "CVE-2014-125113": {"epss_score": 0.52447, "epss_percentile": 0.97826}, "CVE-2014-125114": {"epss_score": 0.197, "epss_percentile": 0.95228}, "CVE-2014-125115": {"epss_score": 0.6504, "epss_percentile": 0.98402}, "CVE-2014-125116": {"epss_score": 0.50344, "epss_percentile": 0.97733}, "CVE-2014-125117": {"epss_score": 0.48485, "epss_percentile": 0.9764}, "CVE-2014-125118": {"epss_score": 0.43016, "epss_percentile": 0.97365}, "CVE-2014-125119": {"epss_score": 0.13742, "epss_percentile": 0.94046}, "CVE-2014-125121": {"epss_score": 0.40769, "epss_percentile": 0.97237}, "CVE-2014-125122": {"epss_score": 0.31797, "epss_percentile": 0.9665}, "CVE-2014-125123": {"epss_score": 0.30209, "epss_percentile": 0.96519}, "CVE-2014-125124": {"epss_score": 0.36043, "epss_percentile": 0.96952}, "CVE-2014-125125": {"epss_score": 0.35251, "epss_percentile": 0.96897}, "CVE-2014-125126": {"epss_score": 0.65647, "epss_percentile": 0.9843}, "CVE-2014-125127": {"epss_score": 0.00153, "epss_percentile": 0.36543}, "CVE-2014-125128": {"epss_score": 0.00069, "epss_percentile": 0.21539}, "CVE-2014-1201": {"epss_score": 0.24982, "epss_percentile": 0.95975}, "CVE-2014-1202": {"epss_score": 0.17347, "epss_percentile": 0.94831}, "CVE-2014-1203": {"epss_score": 0.72725, "epss_percentile": 0.98724}, "CVE-2014-1204": {"epss_score": 0.02325, "epss_percentile": 0.84389}, "CVE-2014-1206": {"epss_score": 0.0292, "epss_percentile": 0.85991}, "CVE-2014-1207": {"epss_score": 0.01345, "epss_percentile": 0.79625}, "CVE-2014-1208": {"epss_score": 0.0023, "epss_percentile": 0.45686}, "CVE-2014-1209": {"epss_score": 0.04133, "epss_percentile": 0.88302}, "CVE-2014-1210": {"epss_score": 0.00181, "epss_percentile": 0.40015}, "CVE-2014-1211": {"epss_score": 0.00297, "epss_percentile": 0.52745}, "CVE-2014-1213": {"epss_score": 0.00049, "epss_percentile": 0.15493}, "CVE-2014-1214": {"epss_score": 0.04105, "epss_percentile": 0.88265}, "CVE-2014-1215": {"epss_score": 0.00053, "epss_percentile": 0.17023}, "CVE-2014-1216": {"epss_score": 0.06575, "epss_percentile": 0.90858}, "CVE-2014-1217": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2014-1219": {"epss_score": 0.05332, "epss_percentile": 0.89739}, "CVE-2014-1222": {"epss_score": 0.07525, "epss_percentile": 0.91517}, "CVE-2014-1223": {"epss_score": 0.00363, "epss_percentile": 0.57864}, "CVE-2014-1224": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2014-1226": {"epss_score": 0.00046, "epss_percentile": 0.14179}, "CVE-2014-1232": {"epss_score": 0.00287, "epss_percentile": 0.51792}, "CVE-2014-1233": {"epss_score": 0.00068, "epss_percentile": 0.21394}, "CVE-2014-1234": {"epss_score": 0.00206, "epss_percentile": 0.42951}, "CVE-2014-1235": {"epss_score": 0.01182, "epss_percentile": 0.78315}, "CVE-2014-1236": {"epss_score": 0.07859, "epss_percentile": 0.91725}, "CVE-2014-1237": {"epss_score": 0.00698, "epss_percentile": 0.71416}, "CVE-2014-1238": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2014-1242": {"epss_score": 0.00463, "epss_percentile": 0.63631}, "CVE-2014-1243": {"epss_score": 0.03917, "epss_percentile": 0.87949}, "CVE-2014-1244": {"epss_score": 0.04028, "epss_percentile": 0.88145}, "CVE-2014-1245": {"epss_score": 0.03439, "epss_percentile": 0.87138}, "CVE-2014-1246": {"epss_score": 0.0512, "epss_percentile": 0.89518}, "CVE-2014-1247": {"epss_score": 0.03623, "epss_percentile": 0.87447}, "CVE-2014-1248": {"epss_score": 0.0512, "epss_percentile": 0.89518}, "CVE-2014-1249": {"epss_score": 0.0512, "epss_percentile": 0.89518}, "CVE-2014-1250": {"epss_score": 0.03623, "epss_percentile": 0.87447}, "CVE-2014-1251": {"epss_score": 0.06825, "epss_percentile": 0.91049}, "CVE-2014-1252": {"epss_score": 0.04116, "epss_percentile": 0.88279}, "CVE-2014-1253": {"epss_score": 0.00056, "epss_percentile": 0.17807}, "CVE-2014-1254": {"epss_score": 0.01256, "epss_percentile": 0.78935}, "CVE-2014-1255": {"epss_score": 0.003, "epss_percentile": 0.52908}, "CVE-2014-1256": {"epss_score": 0.00378, "epss_percentile": 0.58827}, "CVE-2014-1257": {"epss_score": 0.00061, "epss_percentile": 0.19495}, "CVE-2014-1258": {"epss_score": 0.01323, "epss_percentile": 0.79458}, "CVE-2014-1259": {"epss_score": 0.00697, "epss_percentile": 0.71402}, "CVE-2014-1260": {"epss_score": 0.01341, "epss_percentile": 0.79588}, "CVE-2014-1261": {"epss_score": 0.01341, "epss_percentile": 0.7959}, "CVE-2014-1262": {"epss_score": 0.00368, "epss_percentile": 0.58216}, "CVE-2014-1263": {"epss_score": 0.05846, "epss_percentile": 0.90256}, "CVE-2014-1264": {"epss_score": 0.00054, "epss_percentile": 0.17366}, "CVE-2014-1265": {"epss_score": 0.00054, "epss_percentile": 0.17077}, "CVE-2014-1266": {"epss_score": 0.31992, "epss_percentile": 0.96665}, "CVE-2014-1267": {"epss_score": 0.00222, "epss_percentile": 0.44753}, "CVE-2014-1268": {"epss_score": 0.00857, "epss_percentile": 0.7449}, "CVE-2014-1269": {"epss_score": 0.00895, "epss_percentile": 0.75108}, "CVE-2014-1270": {"epss_score": 0.00895, "epss_percentile": 0.75108}, "CVE-2014-1271": {"epss_score": 0.00304, "epss_percentile": 0.53252}, "CVE-2014-1272": {"epss_score": 0.00024, "epss_percentile": 0.05849}, "CVE-2014-1273": {"epss_score": 0.00222, "epss_percentile": 0.44753}, "CVE-2014-1274": {"epss_score": 0.00063, "epss_percentile": 0.19977}, "CVE-2014-1275": {"epss_score": 0.01142, "epss_percentile": 0.77978}, "CVE-2014-1276": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2014-1278": {"epss_score": 0.00038, "epss_percentile": 0.111}, "CVE-2014-1279": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2014-1280": {"epss_score": 0.004, "epss_percentile": 0.60172}, "CVE-2014-1281": {"epss_score": 0.00063, "epss_percentile": 0.19977}, "CVE-2014-1282": {"epss_score": 0.00222, "epss_percentile": 0.44753}, "CVE-2014-1285": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2014-1286": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-1287": {"epss_score": 0.01092, "epss_percentile": 0.7747}, "CVE-2014-1289": {"epss_score": 0.01795, "epss_percentile": 0.823}, "CVE-2014-1290": {"epss_score": 0.01795, "epss_percentile": 0.823}, "CVE-2014-1291": {"epss_score": 0.01795, "epss_percentile": 0.823}, "CVE-2014-1292": {"epss_score": 0.0085, "epss_percentile": 0.74391}, "CVE-2014-1293": {"epss_score": 0.01795, "epss_percentile": 0.823}, "CVE-2014-1294": {"epss_score": 0.01795, "epss_percentile": 0.823}, "CVE-2014-1295": {"epss_score": 0.00144, "epss_percentile": 0.35292}, "CVE-2014-1296": {"epss_score": 0.00207, "epss_percentile": 0.43199}, "CVE-2014-1297": {"epss_score": 0.00184, "epss_percentile": 0.40384}, "CVE-2014-1298": {"epss_score": 0.01557, "epss_percentile": 0.81019}, "CVE-2014-1299": {"epss_score": 0.00909, "epss_percentile": 0.75314}, "CVE-2014-1300": {"epss_score": 0.08527, "epss_percentile": 0.92104}, "CVE-2014-1301": {"epss_score": 0.01307, "epss_percentile": 0.79342}, "CVE-2014-1302": {"epss_score": 0.01795, "epss_percentile": 0.823}, "CVE-2014-1303": {"epss_score": 0.31681, "epss_percentile": 0.96641}, "CVE-2014-1304": {"epss_score": 0.01557, "epss_percentile": 0.81019}, "CVE-2014-1305": {"epss_score": 0.01557, "epss_percentile": 0.81019}, "CVE-2014-1307": {"epss_score": 0.01557, "epss_percentile": 0.81019}, "CVE-2014-1308": {"epss_score": 0.01557, "epss_percentile": 0.81019}, "CVE-2014-1309": {"epss_score": 0.00909, "epss_percentile": 0.75314}, "CVE-2014-1310": {"epss_score": 0.01795, "epss_percentile": 0.823}, "CVE-2014-1311": {"epss_score": 0.01557, "epss_percentile": 0.81019}, "CVE-2014-1312": {"epss_score": 0.01795, "epss_percentile": 0.823}, "CVE-2014-1313": {"epss_score": 0.00909, "epss_percentile": 0.75314}, "CVE-2014-1314": {"epss_score": 0.00291, "epss_percentile": 0.52163}, "CVE-2014-1315": {"epss_score": 0.01256, "epss_percentile": 0.78935}, "CVE-2014-1316": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-1317": {"epss_score": 0.00144, "epss_percentile": 0.35259}, "CVE-2014-1318": {"epss_score": 0.01286, "epss_percentile": 0.79189}, "CVE-2014-1319": {"epss_score": 0.01239, "epss_percentile": 0.78796}, "CVE-2014-1320": {"epss_score": 0.00062, "epss_percentile": 0.19565}, "CVE-2014-1321": {"epss_score": 0.00062, "epss_percentile": 0.19734}, "CVE-2014-1322": {"epss_score": 0.00242, "epss_percentile": 0.47336}, "CVE-2014-1323": {"epss_score": 0.01815, "epss_percentile": 0.82389}, "CVE-2014-1324": {"epss_score": 0.0148, "epss_percentile": 0.80562}, "CVE-2014-1325": {"epss_score": 0.03317, "epss_percentile": 0.86903}, "CVE-2014-1326": {"epss_score": 0.01815, "epss_percentile": 0.82389}, "CVE-2014-1327": {"epss_score": 0.02232, "epss_percentile": 0.84093}, "CVE-2014-1329": {"epss_score": 0.01277, "epss_percentile": 0.79117}, "CVE-2014-1330": {"epss_score": 0.01815, "epss_percentile": 0.82389}, "CVE-2014-1331": {"epss_score": 0.01815, "epss_percentile": 0.82389}, "CVE-2014-1333": {"epss_score": 0.01277, "epss_percentile": 0.79117}, "CVE-2014-1334": {"epss_score": 0.01815, "epss_percentile": 0.82389}, "CVE-2014-1335": {"epss_score": 0.01815, "epss_percentile": 0.82389}, "CVE-2014-1336": {"epss_score": 0.01277, "epss_percentile": 0.79117}, "CVE-2014-1337": {"epss_score": 0.01815, "epss_percentile": 0.82389}, "CVE-2014-1338": {"epss_score": 0.01815, "epss_percentile": 0.82389}, "CVE-2014-1339": {"epss_score": 0.01815, "epss_percentile": 0.82389}, "CVE-2014-1340": {"epss_score": 0.0231, "epss_percentile": 0.84332}, "CVE-2014-1341": {"epss_score": 0.01815, "epss_percentile": 0.82389}, "CVE-2014-1342": {"epss_score": 0.01815, "epss_percentile": 0.82389}, "CVE-2014-1343": {"epss_score": 0.01277, "epss_percentile": 0.79117}, "CVE-2014-1344": {"epss_score": 0.0184, "epss_percentile": 0.82493}, "CVE-2014-1345": {"epss_score": 0.00615, "epss_percentile": 0.69313}, "CVE-2014-1346": {"epss_score": 0.00615, "epss_percentile": 0.69301}, "CVE-2014-1347": {"epss_score": 0.00041, "epss_percentile": 0.12224}, "CVE-2014-1348": {"epss_score": 0.00105, "epss_percentile": 0.29373}, "CVE-2014-1349": {"epss_score": 0.01539, "epss_percentile": 0.80936}, "CVE-2014-1350": {"epss_score": 0.00063, "epss_percentile": 0.19827}, "CVE-2014-1351": {"epss_score": 0.00067, "epss_percentile": 0.21119}, "CVE-2014-1352": {"epss_score": 0.00067, "epss_percentile": 0.21119}, "CVE-2014-1353": {"epss_score": 0.00067, "epss_percentile": 0.21119}, "CVE-2014-1354": {"epss_score": 0.01314, "epss_percentile": 0.79397}, "CVE-2014-1355": {"epss_score": 0.00061, "epss_percentile": 0.19549}, "CVE-2014-1356": {"epss_score": 0.0306, "epss_percentile": 0.86307}, "CVE-2014-1357": {"epss_score": 0.0306, "epss_percentile": 0.86307}, "CVE-2014-1358": {"epss_score": 0.03185, "epss_percentile": 0.86589}, "CVE-2014-1359": {"epss_score": 0.02402, "epss_percentile": 0.84642}, "CVE-2014-1360": {"epss_score": 0.00075, "epss_percentile": 0.2289}, "CVE-2014-1361": {"epss_score": 0.00783, "epss_percentile": 0.73228}, "CVE-2014-1362": {"epss_score": 0.01583, "epss_percentile": 0.8115}, "CVE-2014-1363": {"epss_score": 0.01583, "epss_percentile": 0.8115}, "CVE-2014-1364": {"epss_score": 0.01583, "epss_percentile": 0.8115}, "CVE-2014-1365": {"epss_score": 0.01583, "epss_percentile": 0.8115}, "CVE-2014-1366": {"epss_score": 0.01583, "epss_percentile": 0.8115}, "CVE-2014-1367": {"epss_score": 0.01583, "epss_percentile": 0.8115}, "CVE-2014-1368": {"epss_score": 0.01583, "epss_percentile": 0.8115}, "CVE-2014-1369": {"epss_score": 0.00542, "epss_percentile": 0.6707}, "CVE-2014-1370": {"epss_score": 0.01847, "epss_percentile": 0.82522}, "CVE-2014-1371": {"epss_score": 0.00788, "epss_percentile": 0.73332}, "CVE-2014-1372": {"epss_score": 0.00071, "epss_percentile": 0.22198}, "CVE-2014-1373": {"epss_score": 0.01233, "epss_percentile": 0.78743}, "CVE-2014-1375": {"epss_score": 0.00068, "epss_percentile": 0.21414}, "CVE-2014-1376": {"epss_score": 0.01343, "epss_percentile": 0.79601}, "CVE-2014-1377": {"epss_score": 0.01343, "epss_percentile": 0.79601}, "CVE-2014-1378": {"epss_score": 0.00062, "epss_percentile": 0.19565}, "CVE-2014-1379": {"epss_score": 0.00469, "epss_percentile": 0.63934}, "CVE-2014-1380": {"epss_score": 0.00067, "epss_percentile": 0.21119}, "CVE-2014-1381": {"epss_score": 0.01249, "epss_percentile": 0.78871}, "CVE-2014-1382": {"epss_score": 0.03317, "epss_percentile": 0.86903}, "CVE-2014-1383": {"epss_score": 0.00152, "epss_percentile": 0.36385}, "CVE-2014-1384": {"epss_score": 0.01645, "epss_percentile": 0.81528}, "CVE-2014-1385": {"epss_score": 0.01645, "epss_percentile": 0.81528}, "CVE-2014-1386": {"epss_score": 0.0086, "epss_percentile": 0.74541}, "CVE-2014-1387": {"epss_score": 0.01645, "epss_percentile": 0.81528}, "CVE-2014-1388": {"epss_score": 0.01645, "epss_percentile": 0.81528}, "CVE-2014-1389": {"epss_score": 0.01645, "epss_percentile": 0.81528}, "CVE-2014-1390": {"epss_score": 0.0086, "epss_percentile": 0.74541}, "CVE-2014-1391": {"epss_score": 0.02575, "epss_percentile": 0.85141}, "CVE-2014-1398": {"epss_score": 0.00384, "epss_percentile": 0.59125}, "CVE-2014-1399": {"epss_score": 0.00308, "epss_percentile": 0.53638}, "CVE-2014-1400": {"epss_score": 0.00384, "epss_percentile": 0.59125}, "CVE-2014-1401": {"epss_score": 0.02298, "epss_percentile": 0.843}, "CVE-2014-1402": {"epss_score": 0.00096, "epss_percentile": 0.27411}, "CVE-2014-1403": {"epss_score": 0.00802, "epss_percentile": 0.73585}, "CVE-2014-1405": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2014-1406": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2014-1407": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-1408": {"epss_score": 0.00377, "epss_percentile": 0.5872}, "CVE-2014-1409": {"epss_score": 0.00217, "epss_percentile": 0.4431}, "CVE-2014-1418": {"epss_score": 0.00512, "epss_percentile": 0.65874}, "CVE-2014-1419": {"epss_score": 0.00035, "epss_percentile": 0.09968}, "CVE-2014-1420": {"epss_score": 0.00038, "epss_percentile": 0.1133}, "CVE-2014-1421": {"epss_score": 0.00014, "epss_percentile": 0.02087}, "CVE-2014-1422": {"epss_score": 0.00042, "epss_percentile": 0.12579}, "CVE-2014-1423": {"epss_score": 0.00207, "epss_percentile": 0.43161}, "CVE-2014-1424": {"epss_score": 0.0035, "epss_percentile": 0.5698}, "CVE-2014-1425": {"epss_score": 0.00054, "epss_percentile": 0.17366}, "CVE-2014-1426": {"epss_score": 0.00682, "epss_percentile": 0.71061}, "CVE-2014-1427": {"epss_score": 0.00383, "epss_percentile": 0.59093}, "CVE-2014-1428": {"epss_score": 0.00241, "epss_percentile": 0.47275}, "CVE-2014-1438": {"epss_score": 0.00054, "epss_percentile": 0.17341}, "CVE-2014-1439": {"epss_score": 0.00427, "epss_percentile": 0.61914}, "CVE-2014-1441": {"epss_score": 0.0035, "epss_percentile": 0.56952}, "CVE-2014-1442": {"epss_score": 0.00285, "epss_percentile": 0.51545}, "CVE-2014-1443": {"epss_score": 0.00337, "epss_percentile": 0.56042}, "CVE-2014-1444": {"epss_score": 0.0005, "epss_percentile": 0.15961}, "CVE-2014-1445": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2014-1446": {"epss_score": 0.002, "epss_percentile": 0.42271}, "CVE-2014-1447": {"epss_score": 0.11684, "epss_percentile": 0.93446}, "CVE-2014-1449": {"epss_score": 0.00301, "epss_percentile": 0.52998}, "CVE-2014-1452": {"epss_score": 0.0062, "epss_percentile": 0.69442}, "CVE-2014-1453": {"epss_score": 0.01178, "epss_percentile": 0.78288}, "CVE-2014-1454": {"epss_score": 0.00182, "epss_percentile": 0.40259}, "CVE-2014-1455": {"epss_score": 0.00234, "epss_percentile": 0.46123}, "CVE-2014-1456": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2014-1457": {"epss_score": 0.00024, "epss_percentile": 0.05992}, "CVE-2014-1458": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2014-1459": {"epss_score": 0.02154, "epss_percentile": 0.83796}, "CVE-2014-1466": {"epss_score": 0.0041, "epss_percentile": 0.60845}, "CVE-2014-1467": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2014-1469": {"epss_score": 0.00061, "epss_percentile": 0.19511}, "CVE-2014-1471": {"epss_score": 0.01617, "epss_percentile": 0.81366}, "CVE-2014-1472": {"epss_score": 0.00499, "epss_percentile": 0.65274}, "CVE-2014-1473": {"epss_score": 0.00269, "epss_percentile": 0.50155}, "CVE-2014-1474": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2014-1475": {"epss_score": 0.00839, "epss_percentile": 0.7419}, "CVE-2014-1476": {"epss_score": 0.00361, "epss_percentile": 0.57727}, "CVE-2014-1477": {"epss_score": 0.00852, "epss_percentile": 0.74419}, "CVE-2014-1478": {"epss_score": 0.01231, "epss_percentile": 0.78736}, "CVE-2014-1479": {"epss_score": 0.01468, "epss_percentile": 0.80481}, "CVE-2014-1480": {"epss_score": 0.0052, "epss_percentile": 0.66199}, "CVE-2014-1481": {"epss_score": 0.02581, "epss_percentile": 0.85152}, "CVE-2014-1482": {"epss_score": 0.02741, "epss_percentile": 0.85562}, "CVE-2014-1483": {"epss_score": 0.00277, "epss_percentile": 0.50798}, "CVE-2014-1484": {"epss_score": 0.00632, "epss_percentile": 0.69747}, "CVE-2014-1485": {"epss_score": 0.00964, "epss_percentile": 0.7603}, "CVE-2014-1486": {"epss_score": 0.10821, "epss_percentile": 0.93122}, "CVE-2014-1487": {"epss_score": 0.0061, "epss_percentile": 0.69149}, "CVE-2014-1488": {"epss_score": 0.01089, "epss_percentile": 0.77441}, "CVE-2014-1489": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2014-1490": {"epss_score": 0.01049, "epss_percentile": 0.77059}, "CVE-2014-1491": {"epss_score": 0.00607, "epss_percentile": 0.69056}, "CVE-2014-1492": {"epss_score": 0.00852, "epss_percentile": 0.7442}, "CVE-2014-1493": {"epss_score": 0.01468, "epss_percentile": 0.80477}, "CVE-2014-1494": {"epss_score": 0.00556, "epss_percentile": 0.67506}, "CVE-2014-1496": {"epss_score": 0.00064, "epss_percentile": 0.20134}, "CVE-2014-1497": {"epss_score": 0.00502, "epss_percentile": 0.65377}, "CVE-2014-1498": {"epss_score": 0.00548, "epss_percentile": 0.67292}, "CVE-2014-1499": {"epss_score": 0.00611, "epss_percentile": 0.6919}, "CVE-2014-1500": {"epss_score": 0.02256, "epss_percentile": 0.8417}, "CVE-2014-1501": {"epss_score": 0.00229, "epss_percentile": 0.45588}, "CVE-2014-1502": {"epss_score": 0.00284, "epss_percentile": 0.51418}, "CVE-2014-1504": {"epss_score": 0.00606, "epss_percentile": 0.68999}, "CVE-2014-1505": {"epss_score": 0.00578, "epss_percentile": 0.68191}, "CVE-2014-1506": {"epss_score": 0.02084, "epss_percentile": 0.83542}, "CVE-2014-1507": {"epss_score": 0.00936, "epss_percentile": 0.75686}, "CVE-2014-1508": {"epss_score": 0.00986, "epss_percentile": 0.76328}, "CVE-2014-1509": {"epss_score": 0.0081, "epss_percentile": 0.73721}, "CVE-2014-1510": {"epss_score": 0.76447, "epss_percentile": 0.98891}, "CVE-2014-1511": {"epss_score": 0.75961, "epss_percentile": 0.98871}, "CVE-2014-1512": {"epss_score": 0.1791, "epss_percentile": 0.94925}, "CVE-2014-1513": {"epss_score": 0.01605, "epss_percentile": 0.81295}, "CVE-2014-1514": {"epss_score": 0.04165, "epss_percentile": 0.88341}, "CVE-2014-1515": {"epss_score": 0.00068, "epss_percentile": 0.2136}, "CVE-2014-1516": {"epss_score": 0.00151, "epss_percentile": 0.36227}, "CVE-2014-1517": {"epss_score": 0.00394, "epss_percentile": 0.59795}, "CVE-2014-1518": {"epss_score": 0.02818, "epss_percentile": 0.85739}, "CVE-2014-1519": {"epss_score": 0.02191, "epss_percentile": 0.83935}, "CVE-2014-1520": {"epss_score": 0.00039, "epss_percentile": 0.11453}, "CVE-2014-1522": {"epss_score": 0.00762, "epss_percentile": 0.72846}, "CVE-2014-1523": {"epss_score": 0.0054, "epss_percentile": 0.6699}, "CVE-2014-1524": {"epss_score": 0.06412, "epss_percentile": 0.90741}, "CVE-2014-1525": {"epss_score": 0.01864, "epss_percentile": 0.82601}, "CVE-2014-1526": {"epss_score": 0.007, "epss_percentile": 0.71476}, "CVE-2014-1527": {"epss_score": 0.00846, "epss_percentile": 0.74336}, "CVE-2014-1528": {"epss_score": 0.0126, "epss_percentile": 0.78972}, "CVE-2014-1529": {"epss_score": 0.01321, "epss_percentile": 0.79442}, "CVE-2014-1530": {"epss_score": 0.00865, "epss_percentile": 0.74619}, "CVE-2014-1531": {"epss_score": 0.05086, "epss_percentile": 0.89478}, "CVE-2014-1532": {"epss_score": 0.04891, "epss_percentile": 0.89264}, "CVE-2014-1533": {"epss_score": 0.03197, "epss_percentile": 0.86615}, "CVE-2014-1534": {"epss_score": 0.03243, "epss_percentile": 0.86736}, "CVE-2014-1536": {"epss_score": 0.01355, "epss_percentile": 0.79708}, "CVE-2014-1537": {"epss_score": 0.03334, "epss_percentile": 0.86932}, "CVE-2014-1538": {"epss_score": 0.03597, "epss_percentile": 0.87406}, "CVE-2014-1539": {"epss_score": 0.0075, "epss_percentile": 0.72616}, "CVE-2014-1540": {"epss_score": 0.01114, "epss_percentile": 0.77697}, "CVE-2014-1541": {"epss_score": 0.02644, "epss_percentile": 0.85318}, "CVE-2014-1542": {"epss_score": 0.04721, "epss_percentile": 0.89054}, "CVE-2014-1543": {"epss_score": 0.03404, "epss_percentile": 0.87071}, "CVE-2014-1544": {"epss_score": 0.03216, "epss_percentile": 0.86663}, "CVE-2014-1545": {"epss_score": 0.03597, "epss_percentile": 0.87406}, "CVE-2014-1546": {"epss_score": 0.00223, "epss_percentile": 0.44895}, "CVE-2014-1547": {"epss_score": 0.02205, "epss_percentile": 0.84001}, "CVE-2014-1548": {"epss_score": 0.03199, "epss_percentile": 0.86619}, "CVE-2014-1549": {"epss_score": 0.02748, "epss_percentile": 0.85577}, "CVE-2014-1550": {"epss_score": 0.03758, "epss_percentile": 0.87683}, "CVE-2014-1551": {"epss_score": 0.05409, "epss_percentile": 0.89842}, "CVE-2014-1552": {"epss_score": 0.00201, "epss_percentile": 0.42283}, "CVE-2014-1553": {"epss_score": 0.00442, "epss_percentile": 0.62701}, "CVE-2014-1554": {"epss_score": 0.01014, "epss_percentile": 0.76651}, "CVE-2014-1555": {"epss_score": 0.02945, "epss_percentile": 0.86038}, "CVE-2014-1556": {"epss_score": 0.00786, "epss_percentile": 0.73272}, "CVE-2014-1557": {"epss_score": 0.02866, "epss_percentile": 0.85862}, "CVE-2014-1558": {"epss_score": 0.00562, "epss_percentile": 0.67688}, "CVE-2014-1559": {"epss_score": 0.00562, "epss_percentile": 0.67688}, "CVE-2014-1560": {"epss_score": 0.00562, "epss_percentile": 0.67688}, "CVE-2014-1561": {"epss_score": 0.00752, "epss_percentile": 0.72654}, "CVE-2014-1562": {"epss_score": 0.01014, "epss_percentile": 0.76651}, "CVE-2014-1563": {"epss_score": 0.01154, "epss_percentile": 0.78066}, "CVE-2014-1564": {"epss_score": 0.15414, "epss_percentile": 0.94427}, "CVE-2014-1565": {"epss_score": 0.00796, "epss_percentile": 0.73485}, "CVE-2014-1566": {"epss_score": 0.0063, "epss_percentile": 0.69693}, "CVE-2014-1567": {"epss_score": 0.01805, "epss_percentile": 0.82349}, "CVE-2014-1568": {"epss_score": 0.4004, "epss_percentile": 0.97192}, "CVE-2014-1569": {"epss_score": 0.03635, "epss_percentile": 0.8748}, "CVE-2014-1571": {"epss_score": 0.00503, "epss_percentile": 0.65466}, "CVE-2014-1572": {"epss_score": 0.01104, "epss_percentile": 0.77595}, "CVE-2014-1573": {"epss_score": 0.00869, "epss_percentile": 0.74684}, "CVE-2014-1574": {"epss_score": 0.01644, "epss_percentile": 0.81522}, "CVE-2014-1575": {"epss_score": 0.0199, "epss_percentile": 0.83174}, "CVE-2014-1576": {"epss_score": 0.04667, "epss_percentile": 0.88981}, "CVE-2014-1577": {"epss_score": 0.00951, "epss_percentile": 0.75868}, "CVE-2014-1578": {"epss_score": 0.01644, "epss_percentile": 0.81522}, "CVE-2014-1580": {"epss_score": 0.00485, "epss_percentile": 0.64714}, "CVE-2014-1581": {"epss_score": 0.02306, "epss_percentile": 0.84324}, "CVE-2014-1582": {"epss_score": 0.00879, "epss_percentile": 0.7484}, "CVE-2014-1583": {"epss_score": 0.00746, "epss_percentile": 0.72542}, "CVE-2014-1584": {"epss_score": 0.00682, "epss_percentile": 0.71067}, "CVE-2014-1585": {"epss_score": 0.00695, "epss_percentile": 0.71382}, "CVE-2014-1586": {"epss_score": 0.00695, "epss_percentile": 0.71382}, "CVE-2014-1587": {"epss_score": 0.01643, "epss_percentile": 0.81516}, "CVE-2014-1588": {"epss_score": 0.01676, "epss_percentile": 0.81706}, "CVE-2014-1589": {"epss_score": 0.00305, "epss_percentile": 0.53345}, "CVE-2014-1590": {"epss_score": 0.00999, "epss_percentile": 0.76479}, "CVE-2014-1591": {"epss_score": 0.00272, "epss_percentile": 0.50391}, "CVE-2014-1592": {"epss_score": 0.01768, "epss_percentile": 0.8218}, "CVE-2014-1593": {"epss_score": 0.0211, "epss_percentile": 0.83644}, "CVE-2014-1594": {"epss_score": 0.01693, "epss_percentile": 0.81795}, "CVE-2014-1595": {"epss_score": 0.00085, "epss_percentile": 0.25161}, "CVE-2014-1597": {"epss_score": 0.00344, "epss_percentile": 0.56516}, "CVE-2014-1598": {"epss_score": 0.00379, "epss_percentile": 0.58839}, "CVE-2014-1599": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-1603": {"epss_score": 0.02855, "epss_percentile": 0.85839}, "CVE-2014-1604": {"epss_score": 0.00074, "epss_percentile": 0.22688}, "CVE-2014-1607": {"epss_score": 0.00361, "epss_percentile": 0.5771}, "CVE-2014-1608": {"epss_score": 0.00605, "epss_percentile": 0.6899}, "CVE-2014-1609": {"epss_score": 0.00552, "epss_percentile": 0.67381}, "CVE-2014-1610": {"epss_score": 0.49387, "epss_percentile": 0.97683}, "CVE-2014-1611": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2014-1612": {"epss_score": 0.00565, "epss_percentile": 0.67803}, "CVE-2014-1613": {"epss_score": 0.0058, "epss_percentile": 0.68244}, "CVE-2014-1615": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2014-1617": {"epss_score": 0.00295, "epss_percentile": 0.52445}, "CVE-2014-1618": {"epss_score": 0.06475, "epss_percentile": 0.90782}, "CVE-2014-1619": {"epss_score": 0.01132, "epss_percentile": 0.77868}, "CVE-2014-1620": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-1624": {"epss_score": 0.00055, "epss_percentile": 0.17514}, "CVE-2014-1626": {"epss_score": 0.00681, "epss_percentile": 0.7105}, "CVE-2014-1631": {"epss_score": 0.27603, "epss_percentile": 0.96261}, "CVE-2014-1632": {"epss_score": 0.16901, "epss_percentile": 0.94746}, "CVE-2014-1634": {"epss_score": 0.00101, "epss_percentile": 0.28629}, "CVE-2014-1635": {"epss_score": 0.80814, "epss_percentile": 0.99107}, "CVE-2014-1636": {"epss_score": 0.06281, "epss_percentile": 0.90638}, "CVE-2014-1637": {"epss_score": 0.0638, "epss_percentile": 0.90712}, "CVE-2014-1638": {"epss_score": 0.00048, "epss_percentile": 0.15199}, "CVE-2014-1639": {"epss_score": 0.00048, "epss_percentile": 0.15199}, "CVE-2014-1640": {"epss_score": 0.00056, "epss_percentile": 0.1776}, "CVE-2014-1642": {"epss_score": 0.00178, "epss_percentile": 0.39692}, "CVE-2014-1643": {"epss_score": 0.00124, "epss_percentile": 0.32392}, "CVE-2014-1644": {"epss_score": 0.00886, "epss_percentile": 0.74951}, "CVE-2014-1645": {"epss_score": 0.00494, "epss_percentile": 0.65097}, "CVE-2014-1646": {"epss_score": 0.00318, "epss_percentile": 0.54398}, "CVE-2014-1647": {"epss_score": 0.00318, "epss_percentile": 0.54398}, "CVE-2014-1648": {"epss_score": 0.00525, "epss_percentile": 0.66393}, "CVE-2014-1649": {"epss_score": 0.40163, "epss_percentile": 0.97203}, "CVE-2014-1650": {"epss_score": 0.00715, "epss_percentile": 0.71837}, "CVE-2014-1651": {"epss_score": 0.01205, "epss_percentile": 0.78512}, "CVE-2014-1652": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2014-1663": {"epss_score": 0.00943, "epss_percentile": 0.75772}, "CVE-2014-1664": {"epss_score": 0.08787, "epss_percentile": 0.92256}, "CVE-2014-1665": {"epss_score": 0.0034, "epss_percentile": 0.56241}, "CVE-2014-1666": {"epss_score": 0.03254, "epss_percentile": 0.86758}, "CVE-2014-1670": {"epss_score": 0.29233, "epss_percentile": 0.96426}, "CVE-2014-1671": {"epss_score": 0.00342, "epss_percentile": 0.56359}, "CVE-2014-1672": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2014-1673": {"epss_score": 0.00439, "epss_percentile": 0.62603}, "CVE-2014-1677": {"epss_score": 0.2805, "epss_percentile": 0.96304}, "CVE-2014-1679": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-1680": {"epss_score": 0.00055, "epss_percentile": 0.17468}, "CVE-2014-1681": {"epss_score": 0.00324, "epss_percentile": 0.54944}, "CVE-2014-1682": {"epss_score": 0.00252, "epss_percentile": 0.48409}, "CVE-2014-1683": {"epss_score": 0.7853, "epss_percentile": 0.98991}, "CVE-2014-1684": {"epss_score": 0.1275, "epss_percentile": 0.93763}, "CVE-2014-1685": {"epss_score": 0.00394, "epss_percentile": 0.59782}, "CVE-2014-1686": {"epss_score": 0.0037, "epss_percentile": 0.58281}, "CVE-2014-1690": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2014-1691": {"epss_score": 0.8135, "epss_percentile": 0.99133}, "CVE-2014-1692": {"epss_score": 0.0756, "epss_percentile": 0.9154}, "CVE-2014-1693": {"epss_score": 0.00588, "epss_percentile": 0.6849}, "CVE-2014-1694": {"epss_score": 0.00584, "epss_percentile": 0.68396}, "CVE-2014-1695": {"epss_score": 0.03629, "epss_percentile": 0.8747}, "CVE-2014-1696": {"epss_score": 0.00584, "epss_percentile": 0.68376}, "CVE-2014-1697": {"epss_score": 0.04508, "epss_percentile": 0.88776}, "CVE-2014-1698": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2014-1699": {"epss_score": 0.01192, "epss_percentile": 0.78404}, "CVE-2014-1700": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2014-1701": {"epss_score": 0.00362, "epss_percentile": 0.57788}, "CVE-2014-1702": {"epss_score": 0.01274, "epss_percentile": 0.79099}, "CVE-2014-1703": {"epss_score": 0.00539, "epss_percentile": 0.66989}, "CVE-2014-1704": {"epss_score": 0.01488, "epss_percentile": 0.80617}, "CVE-2014-1705": {"epss_score": 0.03002, "epss_percentile": 0.86174}, "CVE-2014-1706": {"epss_score": 0.00113, "epss_percentile": 0.30652}, "CVE-2014-1707": {"epss_score": 0.00092, "epss_percentile": 0.26568}, "CVE-2014-1708": {"epss_score": 0.02884, "epss_percentile": 0.85908}, "CVE-2014-1710": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2014-1711": {"epss_score": 0.00301, "epss_percentile": 0.52998}, "CVE-2014-1713": {"epss_score": 0.01953, "epss_percentile": 0.83026}, "CVE-2014-1714": {"epss_score": 0.01038, "epss_percentile": 0.76935}, "CVE-2014-1715": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2014-1716": {"epss_score": 0.01068, "epss_percentile": 0.77243}, "CVE-2014-1717": {"epss_score": 0.01102, "epss_percentile": 0.77582}, "CVE-2014-1718": {"epss_score": 0.01735, "epss_percentile": 0.82009}, "CVE-2014-1719": {"epss_score": 0.01274, "epss_percentile": 0.79099}, "CVE-2014-1720": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2014-1721": {"epss_score": 0.01726, "epss_percentile": 0.8196}, "CVE-2014-1722": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2014-1723": {"epss_score": 0.01207, "epss_percentile": 0.78528}, "CVE-2014-1724": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2014-1725": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2014-1726": {"epss_score": 0.00373, "epss_percentile": 0.58473}, "CVE-2014-1727": {"epss_score": 0.01274, "epss_percentile": 0.79099}, "CVE-2014-1728": {"epss_score": 0.0041, "epss_percentile": 0.60808}, "CVE-2014-1729": {"epss_score": 0.00958, "epss_percentile": 0.75941}, "CVE-2014-1730": {"epss_score": 0.00937, "epss_percentile": 0.75694}, "CVE-2014-1731": {"epss_score": 0.02348, "epss_percentile": 0.84459}, "CVE-2014-1732": {"epss_score": 0.01012, "epss_percentile": 0.76624}, "CVE-2014-1733": {"epss_score": 0.0051, "epss_percentile": 0.65809}, "CVE-2014-1734": {"epss_score": 0.00489, "epss_percentile": 0.64903}, "CVE-2014-1735": {"epss_score": 0.00796, "epss_percentile": 0.73486}, "CVE-2014-1736": {"epss_score": 0.02257, "epss_percentile": 0.84176}, "CVE-2014-1737": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2014-1738": {"epss_score": 0.00032, "epss_percentile": 0.08846}, "CVE-2014-1739": {"epss_score": 0.00143, "epss_percentile": 0.35214}, "CVE-2014-1740": {"epss_score": 0.01735, "epss_percentile": 0.82009}, "CVE-2014-1741": {"epss_score": 0.0188, "epss_percentile": 0.82689}, "CVE-2014-1742": {"epss_score": 0.0188, "epss_percentile": 0.82689}, "CVE-2014-1743": {"epss_score": 0.0188, "epss_percentile": 0.82689}, "CVE-2014-1744": {"epss_score": 0.01735, "epss_percentile": 0.82009}, "CVE-2014-1745": {"epss_score": 0.00802, "epss_percentile": 0.73592}, "CVE-2014-1746": {"epss_score": 0.00831, "epss_percentile": 0.74041}, "CVE-2014-1747": {"epss_score": 0.0042, "epss_percentile": 0.61426}, "CVE-2014-1748": {"epss_score": 0.00732, "epss_percentile": 0.72189}, "CVE-2014-1749": {"epss_score": 0.00382, "epss_percentile": 0.59057}, "CVE-2014-1750": {"epss_score": 0.00413, "epss_percentile": 0.61009}, "CVE-2014-1751": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-1752": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-1753": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-1754": {"epss_score": 0.13321, "epss_percentile": 0.93932}, "CVE-2014-1755": {"epss_score": 0.20908, "epss_percentile": 0.95441}, "CVE-2014-1756": {"epss_score": 0.20081, "epss_percentile": 0.95286}, "CVE-2014-1757": {"epss_score": 0.34197, "epss_percentile": 0.96831}, "CVE-2014-1758": {"epss_score": 0.32468, "epss_percentile": 0.96702}, "CVE-2014-1759": {"epss_score": 0.21496, "epss_percentile": 0.95526}, "CVE-2014-1760": {"epss_score": 0.22762, "epss_percentile": 0.95683}, "CVE-2014-1761": {"epss_score": 0.93131, "epss_percentile": 0.99778}, "CVE-2014-1762": {"epss_score": 0.46186, "epss_percentile": 0.97535}, "CVE-2014-1763": {"epss_score": 0.39317, "epss_percentile": 0.97154}, "CVE-2014-1764": {"epss_score": 0.71057, "epss_percentile": 0.98651}, "CVE-2014-1765": {"epss_score": 0.42567, "epss_percentile": 0.97341}, "CVE-2014-1766": {"epss_score": 0.10968, "epss_percentile": 0.9318}, "CVE-2014-1767": {"epss_score": 0.6055, "epss_percentile": 0.9821}, "CVE-2014-1769": {"epss_score": 0.3392, "epss_percentile": 0.96817}, "CVE-2014-1770": {"epss_score": 0.43737, "epss_percentile": 0.97401}, "CVE-2014-1771": {"epss_score": 0.13423, "epss_percentile": 0.93959}, "CVE-2014-1772": {"epss_score": 0.51273, "epss_percentile": 0.97773}, "CVE-2014-1773": {"epss_score": 0.65585, "epss_percentile": 0.98427}, "CVE-2014-1774": {"epss_score": 0.23384, "epss_percentile": 0.95773}, "CVE-2014-1775": {"epss_score": 0.49014, "epss_percentile": 0.97662}, "CVE-2014-1776": {"epss_score": 0.78494, "epss_percentile": 0.98989}, "CVE-2014-1777": {"epss_score": 0.326, "epss_percentile": 0.9671}, "CVE-2014-1778": {"epss_score": 0.19884, "epss_percentile": 0.95254}, "CVE-2014-1779": {"epss_score": 0.47045, "epss_percentile": 0.97568}, "CVE-2014-1780": {"epss_score": 0.46114, "epss_percentile": 0.97529}, "CVE-2014-1781": {"epss_score": 0.46114, "epss_percentile": 0.97529}, "CVE-2014-1782": {"epss_score": 0.46114, "epss_percentile": 0.97529}, "CVE-2014-1783": {"epss_score": 0.46114, "epss_percentile": 0.97529}, "CVE-2014-1784": {"epss_score": 0.46114, "epss_percentile": 0.97529}, "CVE-2014-1785": {"epss_score": 0.55938, "epss_percentile": 0.98003}, "CVE-2014-1786": {"epss_score": 0.46114, "epss_percentile": 0.97529}, "CVE-2014-1788": {"epss_score": 0.48087, "epss_percentile": 0.9762}, "CVE-2014-1789": {"epss_score": 0.55032, "epss_percentile": 0.97957}, "CVE-2014-1790": {"epss_score": 0.46114, "epss_percentile": 0.97529}, "CVE-2014-1791": {"epss_score": 0.42234, "epss_percentile": 0.97321}, "CVE-2014-1792": {"epss_score": 0.46114, "epss_percentile": 0.97529}, "CVE-2014-1794": {"epss_score": 0.46114, "epss_percentile": 0.97529}, "CVE-2014-1795": {"epss_score": 0.42234, "epss_percentile": 0.97321}, "CVE-2014-1796": {"epss_score": 0.46114, "epss_percentile": 0.97529}, "CVE-2014-1797": {"epss_score": 0.42234, "epss_percentile": 0.97321}, "CVE-2014-1799": {"epss_score": 0.50465, "epss_percentile": 0.97737}, "CVE-2014-1800": {"epss_score": 0.42234, "epss_percentile": 0.97321}, "CVE-2014-1802": {"epss_score": 0.48087, "epss_percentile": 0.9762}, "CVE-2014-1803": {"epss_score": 0.4994, "epss_percentile": 0.97712}, "CVE-2014-1804": {"epss_score": 0.48087, "epss_percentile": 0.9762}, "CVE-2014-1805": {"epss_score": 0.51273, "epss_percentile": 0.97773}, "CVE-2014-1806": {"epss_score": 0.2675, "epss_percentile": 0.96172}, "CVE-2014-1807": {"epss_score": 0.03128, "epss_percentile": 0.8646}, "CVE-2014-1808": {"epss_score": 0.14709, "epss_percentile": 0.94268}, "CVE-2014-1809": {"epss_score": 0.09953, "epss_percentile": 0.92789}, "CVE-2014-1811": {"epss_score": 0.33415, "epss_percentile": 0.96772}, "CVE-2014-1812": {"epss_score": 0.79908, "epss_percentile": 0.99061}, "CVE-2014-1813": {"epss_score": 0.20167, "epss_percentile": 0.95296}, "CVE-2014-1814": {"epss_score": 0.00926, "epss_percentile": 0.75552}, "CVE-2014-1815": {"epss_score": 0.39252, "epss_percentile": 0.97149}, "CVE-2014-1816": {"epss_score": 0.10855, "epss_percentile": 0.93135}, "CVE-2014-1817": {"epss_score": 0.44437, "epss_percentile": 0.97436}, "CVE-2014-1818": {"epss_score": 0.42395, "epss_percentile": 0.9733}, "CVE-2014-1819": {"epss_score": 0.00749, "epss_percentile": 0.72592}, "CVE-2014-1820": {"epss_score": 0.1954, "epss_percentile": 0.95203}, "CVE-2014-1823": {"epss_score": 0.2598, "epss_percentile": 0.96098}, "CVE-2014-1824": {"epss_score": 0.09723, "epss_percentile": 0.92677}, "CVE-2014-1826": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-1827": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2014-1828": {"epss_score": 0.00415, "epss_percentile": 0.61129}, "CVE-2014-1829": {"epss_score": 0.00495, "epss_percentile": 0.65108}, "CVE-2014-1830": {"epss_score": 0.00464, "epss_percentile": 0.63707}, "CVE-2014-1831": {"epss_score": 0.00067, "epss_percentile": 0.21077}, "CVE-2014-1832": {"epss_score": 0.00067, "epss_percentile": 0.21077}, "CVE-2014-1833": {"epss_score": 0.00766, "epss_percentile": 0.72941}, "CVE-2014-1834": {"epss_score": 0.00121, "epss_percentile": 0.31941}, "CVE-2014-1835": {"epss_score": 0.00048, "epss_percentile": 0.14937}, "CVE-2014-1836": {"epss_score": 0.18119, "epss_percentile": 0.94959}, "CVE-2014-1837": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2014-1838": {"epss_score": 0.0005, "epss_percentile": 0.15844}, "CVE-2014-1839": {"epss_score": 0.00061, "epss_percentile": 0.1954}, "CVE-2014-1840": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2014-1841": {"epss_score": 0.05096, "epss_percentile": 0.89493}, "CVE-2014-1842": {"epss_score": 0.04433, "epss_percentile": 0.88681}, "CVE-2014-1843": {"epss_score": 0.04824, "epss_percentile": 0.89182}, "CVE-2014-1845": {"epss_score": 0.00062, "epss_percentile": 0.19693}, "CVE-2014-1846": {"epss_score": 0.00068, "epss_percentile": 0.21318}, "CVE-2014-1849": {"epss_score": 0.21131, "epss_percentile": 0.95467}, "CVE-2014-1854": {"epss_score": 0.16556, "epss_percentile": 0.9469}, "CVE-2014-1855": {"epss_score": 0.0041, "epss_percentile": 0.60798}, "CVE-2014-1858": {"epss_score": 0.00041, "epss_percentile": 0.12319}, "CVE-2014-1859": {"epss_score": 0.00048, "epss_percentile": 0.15136}, "CVE-2014-1860": {"epss_score": 0.00275, "epss_percentile": 0.50633}, "CVE-2014-1861": {"epss_score": 0.00296, "epss_percentile": 0.526}, "CVE-2014-1867": {"epss_score": 0.00063, "epss_percentile": 0.20102}, "CVE-2014-1868": {"epss_score": 0.00337, "epss_percentile": 0.56043}, "CVE-2014-1869": {"epss_score": 0.00599, "epss_percentile": 0.68793}, "CVE-2014-1870": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2014-1874": {"epss_score": 0.00089, "epss_percentile": 0.25833}, "CVE-2014-1875": {"epss_score": 0.00078, "epss_percentile": 0.23636}, "CVE-2014-1876": {"epss_score": 0.00075, "epss_percentile": 0.22988}, "CVE-2014-1877": {"epss_score": 0.00275, "epss_percentile": 0.50642}, "CVE-2014-1878": {"epss_score": 0.02337, "epss_percentile": 0.84422}, "CVE-2014-1879": {"epss_score": 0.00202, "epss_percentile": 0.42456}, "CVE-2014-1881": {"epss_score": 0.01857, "epss_percentile": 0.82576}, "CVE-2014-1882": {"epss_score": 0.07665, "epss_percentile": 0.91611}, "CVE-2014-1883": {"epss_score": 0.01318, "epss_percentile": 0.7942}, "CVE-2014-1884": {"epss_score": 0.02048, "epss_percentile": 0.83391}, "CVE-2014-1885": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2014-1886": {"epss_score": 0.00493, "epss_percentile": 0.65062}, "CVE-2014-1887": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2014-1888": {"epss_score": 0.00369, "epss_percentile": 0.58274}, "CVE-2014-1889": {"epss_score": 0.13364, "epss_percentile": 0.93943}, "CVE-2014-1891": {"epss_score": 0.00271, "epss_percentile": 0.50284}, "CVE-2014-1892": {"epss_score": 0.00271, "epss_percentile": 0.50284}, "CVE-2014-1893": {"epss_score": 0.00271, "epss_percentile": 0.50284}, "CVE-2014-1894": {"epss_score": 0.00271, "epss_percentile": 0.50284}, "CVE-2014-1895": {"epss_score": 0.00105, "epss_percentile": 0.29345}, "CVE-2014-1896": {"epss_score": 0.00143, "epss_percentile": 0.3519}, "CVE-2014-1899": {"epss_score": 0.00381, "epss_percentile": 0.59012}, "CVE-2014-1900": {"epss_score": 0.00263, "epss_percentile": 0.49511}, "CVE-2014-1901": {"epss_score": 0.00623, "epss_percentile": 0.69533}, "CVE-2014-1902": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2014-1903": {"epss_score": 0.83709, "epss_percentile": 0.99259}, "CVE-2014-1904": {"epss_score": 0.02196, "epss_percentile": 0.83954}, "CVE-2014-1905": {"epss_score": 0.17963, "epss_percentile": 0.94934}, "CVE-2014-1906": {"epss_score": 0.0122, "epss_percentile": 0.78622}, "CVE-2014-1907": {"epss_score": 0.08772, "epss_percentile": 0.92248}, "CVE-2014-1908": {"epss_score": 0.06369, "epss_percentile": 0.90704}, "CVE-2014-1909": {"epss_score": 0.0078, "epss_percentile": 0.73167}, "CVE-2014-1910": {"epss_score": 0.00199, "epss_percentile": 0.42147}, "CVE-2014-1911": {"epss_score": 0.00404, "epss_percentile": 0.60434}, "CVE-2014-1912": {"epss_score": 0.33632, "epss_percentile": 0.96788}, "CVE-2014-1914": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2014-1915": {"epss_score": 0.00369, "epss_percentile": 0.58277}, "CVE-2014-1916": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-1921": {"epss_score": 0.00417, "epss_percentile": 0.61229}, "CVE-2014-1922": {"epss_score": 0.0092, "epss_percentile": 0.75466}, "CVE-2014-1923": {"epss_score": 0.02419, "epss_percentile": 0.84699}, "CVE-2014-1924": {"epss_score": 0.04079, "epss_percentile": 0.88215}, "CVE-2014-1925": {"epss_score": 0.02522, "epss_percentile": 0.85005}, "CVE-2014-1927": {"epss_score": 0.00727, "epss_percentile": 0.72097}, "CVE-2014-1928": {"epss_score": 0.00205, "epss_percentile": 0.42705}, "CVE-2014-1929": {"epss_score": 0.00063, "epss_percentile": 0.2007}, "CVE-2014-1930": {"epss_score": 0.00825, "epss_percentile": 0.73953}, "CVE-2014-1931": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-1932": {"epss_score": 0.00133, "epss_percentile": 0.3373}, "CVE-2014-1933": {"epss_score": 0.00111, "epss_percentile": 0.30276}, "CVE-2014-1934": {"epss_score": 0.00048, "epss_percentile": 0.14991}, "CVE-2014-1935": {"epss_score": 0.0047, "epss_percentile": 0.6399}, "CVE-2014-1936": {"epss_score": 0.00433, "epss_percentile": 0.62223}, "CVE-2014-1937": {"epss_score": 0.0042, "epss_percentile": 0.61404}, "CVE-2014-1938": {"epss_score": 0.00143, "epss_percentile": 0.3518}, "CVE-2014-1939": {"epss_score": 0.00193, "epss_percentile": 0.41463}, "CVE-2014-1942": {"epss_score": 0.00799, "epss_percentile": 0.73524}, "CVE-2014-1943": {"epss_score": 0.21218, "epss_percentile": 0.95479}, "CVE-2014-1944": {"epss_score": 0.04522, "epss_percentile": 0.88802}, "CVE-2014-1945": {"epss_score": 0.00275, "epss_percentile": 0.50684}, "CVE-2014-1946": {"epss_score": 0.00787, "epss_percentile": 0.73312}, "CVE-2014-1947": {"epss_score": 0.06954, "epss_percentile": 0.91143}, "CVE-2014-1948": {"epss_score": 0.00062, "epss_percentile": 0.19676}, "CVE-2014-1949": {"epss_score": 0.00037, "epss_percentile": 0.10917}, "CVE-2014-1950": {"epss_score": 0.00083, "epss_percentile": 0.24591}, "CVE-2014-1955": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-1956": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2014-1957": {"epss_score": 0.0036, "epss_percentile": 0.57686}, "CVE-2014-1958": {"epss_score": 0.01143, "epss_percentile": 0.77984}, "CVE-2014-1959": {"epss_score": 0.0023, "epss_percentile": 0.4568}, "CVE-2014-1960": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2014-1961": {"epss_score": 0.00354, "epss_percentile": 0.57213}, "CVE-2014-1962": {"epss_score": 0.0054, "epss_percentile": 0.67008}, "CVE-2014-1963": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2014-1964": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2014-1965": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2014-1966": {"epss_score": 0.0025, "epss_percentile": 0.48089}, "CVE-2014-1967": {"epss_score": 0.00152, "epss_percentile": 0.364}, "CVE-2014-1968": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-1969": {"epss_score": 0.00242, "epss_percentile": 0.47349}, "CVE-2014-1970": {"epss_score": 0.00529, "epss_percentile": 0.666}, "CVE-2014-1971": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-1972": {"epss_score": 0.08822, "epss_percentile": 0.92271}, "CVE-2014-1973": {"epss_score": 0.00214, "epss_percentile": 0.43975}, "CVE-2014-1974": {"epss_score": 0.00407, "epss_percentile": 0.60606}, "CVE-2014-1975": {"epss_score": 0.00557, "epss_percentile": 0.67559}, "CVE-2014-1976": {"epss_score": 0.00152, "epss_percentile": 0.364}, "CVE-2014-1977": {"epss_score": 0.00195, "epss_percentile": 0.41616}, "CVE-2014-1978": {"epss_score": 0.00257, "epss_percentile": 0.48947}, "CVE-2014-1979": {"epss_score": 0.00458, "epss_percentile": 0.63421}, "CVE-2014-1980": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-1982": {"epss_score": 0.10475, "epss_percentile": 0.92999}, "CVE-2014-1983": {"epss_score": 0.01215, "epss_percentile": 0.78584}, "CVE-2014-1984": {"epss_score": 0.00555, "epss_percentile": 0.67477}, "CVE-2014-1985": {"epss_score": 0.01817, "epss_percentile": 0.82395}, "CVE-2014-1986": {"epss_score": 0.00282, "epss_percentile": 0.51269}, "CVE-2014-1987": {"epss_score": 0.04395, "epss_percentile": 0.88638}, "CVE-2014-1988": {"epss_score": 0.00426, "epss_percentile": 0.61736}, "CVE-2014-1989": {"epss_score": 0.00216, "epss_percentile": 0.44157}, "CVE-2014-1990": {"epss_score": 0.00351, "epss_percentile": 0.57072}, "CVE-2014-1991": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2014-1992": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2014-1993": {"epss_score": 0.00207, "epss_percentile": 0.43078}, "CVE-2014-1994": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2014-1995": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2014-1996": {"epss_score": 0.00752, "epss_percentile": 0.72664}, "CVE-2014-1997": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2014-1998": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-1999": {"epss_score": 0.01963, "epss_percentile": 0.83067}, "CVE-2014-2000": {"epss_score": 0.00291, "epss_percentile": 0.52169}, "CVE-2014-2001": {"epss_score": 0.00152, "epss_percentile": 0.364}, "CVE-2014-2002": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-2003": {"epss_score": 0.05367, "epss_percentile": 0.89792}, "CVE-2014-2004": {"epss_score": 0.04484, "epss_percentile": 0.88746}, "CVE-2014-2005": {"epss_score": 0.00058, "epss_percentile": 0.18287}, "CVE-2014-2006": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-2008": {"epss_score": 0.0482, "epss_percentile": 0.89176}, "CVE-2014-2009": {"epss_score": 0.17181, "epss_percentile": 0.94794}, "CVE-2014-2013": {"epss_score": 0.34472, "epss_percentile": 0.96848}, "CVE-2014-2014": {"epss_score": 0.00357, "epss_percentile": 0.57407}, "CVE-2014-2015": {"epss_score": 0.00881, "epss_percentile": 0.74861}, "CVE-2014-2016": {"epss_score": 0.0059, "epss_percentile": 0.68557}, "CVE-2014-2017": {"epss_score": 0.02188, "epss_percentile": 0.83927}, "CVE-2014-2018": {"epss_score": 0.00734, "epss_percentile": 0.72247}, "CVE-2014-2019": {"epss_score": 0.00077, "epss_percentile": 0.23532}, "CVE-2014-2020": {"epss_score": 0.00339, "epss_percentile": 0.56202}, "CVE-2014-2021": {"epss_score": 0.00912, "epss_percentile": 0.75361}, "CVE-2014-2022": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2014-2023": {"epss_score": 0.094, "epss_percentile": 0.92531}, "CVE-2014-2024": {"epss_score": 0.00374, "epss_percentile": 0.5858}, "CVE-2014-2025": {"epss_score": 0.09013, "epss_percentile": 0.92365}, "CVE-2014-2026": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2014-2027": {"epss_score": 0.02305, "epss_percentile": 0.84321}, "CVE-2014-2029": {"epss_score": 0.00721, "epss_percentile": 0.71983}, "CVE-2014-2030": {"epss_score": 0.18785, "epss_percentile": 0.95068}, "CVE-2014-2031": {"epss_score": 0.00729, "epss_percentile": 0.72134}, "CVE-2014-2032": {"epss_score": 0.01639, "epss_percentile": 0.81487}, "CVE-2014-2033": {"epss_score": 0.00097, "epss_percentile": 0.27564}, "CVE-2014-2034": {"epss_score": 0.00985, "epss_percentile": 0.76326}, "CVE-2014-2035": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-2037": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2014-2038": {"epss_score": 0.00051, "epss_percentile": 0.16052}, "CVE-2014-2039": {"epss_score": 0.00038, "epss_percentile": 0.11106}, "CVE-2014-2040": {"epss_score": 0.00151, "epss_percentile": 0.36215}, "CVE-2014-2042": {"epss_score": 0.01521, "epss_percentile": 0.8083}, "CVE-2014-2043": {"epss_score": 0.0039, "epss_percentile": 0.59522}, "CVE-2014-2044": {"epss_score": 0.17806, "epss_percentile": 0.94908}, "CVE-2014-2045": {"epss_score": 0.04338, "epss_percentile": 0.88566}, "CVE-2014-2046": {"epss_score": 0.12322, "epss_percentile": 0.9364}, "CVE-2014-2047": {"epss_score": 0.00365, "epss_percentile": 0.57965}, "CVE-2014-2048": {"epss_score": 0.00816, "epss_percentile": 0.73829}, "CVE-2014-2049": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-2050": {"epss_score": 0.00252, "epss_percentile": 0.48369}, "CVE-2014-2051": {"epss_score": 0.0057, "epss_percentile": 0.67964}, "CVE-2014-2052": {"epss_score": 0.0099, "epss_percentile": 0.76377}, "CVE-2014-2053": {"epss_score": 0.02653, "epss_percentile": 0.85349}, "CVE-2014-2054": {"epss_score": 0.00537, "epss_percentile": 0.66887}, "CVE-2014-2055": {"epss_score": 0.00537, "epss_percentile": 0.66887}, "CVE-2014-2056": {"epss_score": 0.00537, "epss_percentile": 0.66887}, "CVE-2014-2057": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-2058": {"epss_score": 0.00056, "epss_percentile": 0.17949}, "CVE-2014-2059": {"epss_score": 0.03119, "epss_percentile": 0.86445}, "CVE-2014-2060": {"epss_score": 0.00145, "epss_percentile": 0.3543}, "CVE-2014-2061": {"epss_score": 0.00284, "epss_percentile": 0.51443}, "CVE-2014-2062": {"epss_score": 0.00186, "epss_percentile": 0.40682}, "CVE-2014-2063": {"epss_score": 0.00428, "epss_percentile": 0.61957}, "CVE-2014-2064": {"epss_score": 0.00598, "epss_percentile": 0.6877}, "CVE-2014-2065": {"epss_score": 0.00137, "epss_percentile": 0.34333}, "CVE-2014-2066": {"epss_score": 0.00138, "epss_percentile": 0.3453}, "CVE-2014-2067": {"epss_score": 0.00109, "epss_percentile": 0.30063}, "CVE-2014-2068": {"epss_score": 0.00085, "epss_percentile": 0.25137}, "CVE-2014-2069": {"epss_score": 0.25344, "epss_percentile": 0.96016}, "CVE-2014-2071": {"epss_score": 0.00436, "epss_percentile": 0.62484}, "CVE-2014-2072": {"epss_score": 0.28399, "epss_percentile": 0.9635}, "CVE-2014-2073": {"epss_score": 0.07882, "epss_percentile": 0.91741}, "CVE-2014-2075": {"epss_score": 0.02516, "epss_percentile": 0.84986}, "CVE-2014-2077": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-2078": {"epss_score": 0.00194, "epss_percentile": 0.41525}, "CVE-2014-2079": {"epss_score": 0.00068, "epss_percentile": 0.21193}, "CVE-2014-2080": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2014-2081": {"epss_score": 0.00826, "epss_percentile": 0.73969}, "CVE-2014-2084": {"epss_score": 0.28126, "epss_percentile": 0.96313}, "CVE-2014-2087": {"epss_score": 0.41329, "epss_percentile": 0.97267}, "CVE-2014-2088": {"epss_score": 0.02219, "epss_percentile": 0.84046}, "CVE-2014-2089": {"epss_score": 0.02807, "epss_percentile": 0.85709}, "CVE-2014-2090": {"epss_score": 0.00265, "epss_percentile": 0.49772}, "CVE-2014-2091": {"epss_score": 0.00264, "epss_percentile": 0.49706}, "CVE-2014-2092": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2014-2093": {"epss_score": 0.00066, "epss_percentile": 0.20734}, "CVE-2014-2094": {"epss_score": 0.00066, "epss_percentile": 0.20734}, "CVE-2014-2095": {"epss_score": 0.00066, "epss_percentile": 0.20734}, "CVE-2014-2096": {"epss_score": 0.00066, "epss_percentile": 0.20734}, "CVE-2014-2097": {"epss_score": 0.0043, "epss_percentile": 0.62018}, "CVE-2014-2098": {"epss_score": 0.0043, "epss_percentile": 0.62018}, "CVE-2014-2099": {"epss_score": 0.0043, "epss_percentile": 0.62018}, "CVE-2014-2102": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2014-2103": {"epss_score": 0.00363, "epss_percentile": 0.57874}, "CVE-2014-2104": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2014-2106": {"epss_score": 0.01696, "epss_percentile": 0.81814}, "CVE-2014-2107": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2014-2108": {"epss_score": 0.01104, "epss_percentile": 0.77601}, "CVE-2014-2109": {"epss_score": 0.01117, "epss_percentile": 0.77741}, "CVE-2014-2111": {"epss_score": 0.00763, "epss_percentile": 0.72877}, "CVE-2014-2112": {"epss_score": 0.00417, "epss_percentile": 0.61224}, "CVE-2014-2113": {"epss_score": 0.01104, "epss_percentile": 0.77601}, "CVE-2014-2114": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2014-2115": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2014-2116": {"epss_score": 0.00377, "epss_percentile": 0.58698}, "CVE-2014-2117": {"epss_score": 0.00377, "epss_percentile": 0.58698}, "CVE-2014-2118": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2014-2119": {"epss_score": 0.01372, "epss_percentile": 0.79811}, "CVE-2014-2120": {"epss_score": 0.66837, "epss_percentile": 0.98483}, "CVE-2014-2121": {"epss_score": 0.00756, "epss_percentile": 0.72737}, "CVE-2014-2122": {"epss_score": 0.01036, "epss_percentile": 0.76919}, "CVE-2014-2124": {"epss_score": 0.01513, "epss_percentile": 0.8079}, "CVE-2014-2125": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2014-2126": {"epss_score": 0.00535, "epss_percentile": 0.66832}, "CVE-2014-2127": {"epss_score": 0.30946, "epss_percentile": 0.96577}, "CVE-2014-2128": {"epss_score": 0.00248, "epss_percentile": 0.47997}, "CVE-2014-2129": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2014-2130": {"epss_score": 0.01153, "epss_percentile": 0.78063}, "CVE-2014-2131": {"epss_score": 0.00182, "epss_percentile": 0.40206}, "CVE-2014-2132": {"epss_score": 0.00655, "epss_percentile": 0.70364}, "CVE-2014-2133": {"epss_score": 0.04271, "epss_percentile": 0.88475}, "CVE-2014-2134": {"epss_score": 0.02202, "epss_percentile": 0.83985}, "CVE-2014-2135": {"epss_score": 0.04271, "epss_percentile": 0.88475}, "CVE-2014-2136": {"epss_score": 0.04271, "epss_percentile": 0.88475}, "CVE-2014-2137": {"epss_score": 0.00211, "epss_percentile": 0.4368}, "CVE-2014-2138": {"epss_score": 0.00211, "epss_percentile": 0.4368}, "CVE-2014-2139": {"epss_score": 0.00412, "epss_percentile": 0.60947}, "CVE-2014-2140": {"epss_score": 0.00412, "epss_percentile": 0.60947}, "CVE-2014-2141": {"epss_score": 0.00351, "epss_percentile": 0.57014}, "CVE-2014-2142": {"epss_score": 0.00218, "epss_percentile": 0.44342}, "CVE-2014-2143": {"epss_score": 0.00412, "epss_percentile": 0.60947}, "CVE-2014-2144": {"epss_score": 0.00138, "epss_percentile": 0.34422}, "CVE-2014-2145": {"epss_score": 0.00324, "epss_percentile": 0.54947}, "CVE-2014-2146": {"epss_score": 0.00226, "epss_percentile": 0.45282}, "CVE-2014-2147": {"epss_score": 0.00422, "epss_percentile": 0.61548}, "CVE-2014-2151": {"epss_score": 0.00315, "epss_percentile": 0.54198}, "CVE-2014-2152": {"epss_score": 0.00173, "epss_percentile": 0.39123}, "CVE-2014-2153": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-2154": {"epss_score": 0.00918, "epss_percentile": 0.75435}, "CVE-2014-2155": {"epss_score": 0.00412, "epss_percentile": 0.60947}, "CVE-2014-2156": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2014-2157": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2014-2158": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-2159": {"epss_score": 0.00218, "epss_percentile": 0.44349}, "CVE-2014-2160": {"epss_score": 0.00218, "epss_percentile": 0.44349}, "CVE-2014-2161": {"epss_score": 0.00218, "epss_percentile": 0.44349}, "CVE-2014-2162": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-2163": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-2164": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-2165": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-2166": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-2167": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-2168": {"epss_score": 0.07426, "epss_percentile": 0.91469}, "CVE-2014-2169": {"epss_score": 0.00467, "epss_percentile": 0.63828}, "CVE-2014-2170": {"epss_score": 0.00711, "epss_percentile": 0.71742}, "CVE-2014-2171": {"epss_score": 0.07426, "epss_percentile": 0.91469}, "CVE-2014-2172": {"epss_score": 0.00085, "epss_percentile": 0.25138}, "CVE-2014-2173": {"epss_score": 0.00084, "epss_percentile": 0.25}, "CVE-2014-2174": {"epss_score": 0.00214, "epss_percentile": 0.43984}, "CVE-2014-2175": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-2176": {"epss_score": 0.00819, "epss_percentile": 0.73874}, "CVE-2014-2177": {"epss_score": 0.00636, "epss_percentile": 0.6986}, "CVE-2014-2178": {"epss_score": 0.00322, "epss_percentile": 0.5482}, "CVE-2014-2179": {"epss_score": 0.00253, "epss_percentile": 0.48449}, "CVE-2014-2180": {"epss_score": 0.00055, "epss_percentile": 0.17566}, "CVE-2014-2181": {"epss_score": 0.00309, "epss_percentile": 0.53669}, "CVE-2014-2182": {"epss_score": 0.00575, "epss_percentile": 0.68103}, "CVE-2014-2183": {"epss_score": 0.00296, "epss_percentile": 0.52539}, "CVE-2014-2184": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-2185": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2014-2186": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2014-2190": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2014-2191": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-2192": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-2193": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2014-2194": {"epss_score": 0.00403, "epss_percentile": 0.60318}, "CVE-2014-2195": {"epss_score": 0.00321, "epss_percentile": 0.54671}, "CVE-2014-2196": {"epss_score": 0.02983, "epss_percentile": 0.86126}, "CVE-2014-2197": {"epss_score": 0.00728, "epss_percentile": 0.7211}, "CVE-2014-2198": {"epss_score": 0.02197, "epss_percentile": 0.83961}, "CVE-2014-2199": {"epss_score": 0.00378, "epss_percentile": 0.58793}, "CVE-2014-2200": {"epss_score": 0.00657, "epss_percentile": 0.70469}, "CVE-2014-2201": {"epss_score": 0.0071, "epss_percentile": 0.71723}, "CVE-2014-2205": {"epss_score": 0.00357, "epss_percentile": 0.57473}, "CVE-2014-2206": {"epss_score": 0.76643, "epss_percentile": 0.98899}, "CVE-2014-2208": {"epss_score": 0.00697, "epss_percentile": 0.71405}, "CVE-2014-2209": {"epss_score": 0.00301, "epss_percentile": 0.52997}, "CVE-2014-2210": {"epss_score": 0.15357, "epss_percentile": 0.94415}, "CVE-2014-2211": {"epss_score": 0.00287, "epss_percentile": 0.51803}, "CVE-2014-2212": {"epss_score": 0.00291, "epss_percentile": 0.52169}, "CVE-2014-2213": {"epss_score": 0.00645, "epss_percentile": 0.70101}, "CVE-2014-2214": {"epss_score": 0.00429, "epss_percentile": 0.61969}, "CVE-2014-2216": {"epss_score": 0.05813, "epss_percentile": 0.90228}, "CVE-2014-2217": {"epss_score": 0.02802, "epss_percentile": 0.85699}, "CVE-2014-2219": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-2223": {"epss_score": 0.15411, "epss_percentile": 0.94426}, "CVE-2014-2224": {"epss_score": 0.00397, "epss_percentile": 0.59967}, "CVE-2014-2225": {"epss_score": 0.00181, "epss_percentile": 0.40069}, "CVE-2014-2226": {"epss_score": 0.00294, "epss_percentile": 0.52415}, "CVE-2014-2227": {"epss_score": 0.01625, "epss_percentile": 0.81422}, "CVE-2014-2228": {"epss_score": 0.03766, "epss_percentile": 0.87696}, "CVE-2014-2230": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2014-2231": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-2232": {"epss_score": 0.00493, "epss_percentile": 0.65054}, "CVE-2014-2233": {"epss_score": 0.00423, "epss_percentile": 0.61579}, "CVE-2014-2234": {"epss_score": 0.00111, "epss_percentile": 0.30334}, "CVE-2014-2235": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2014-2236": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2014-2237": {"epss_score": 0.00188, "epss_percentile": 0.40896}, "CVE-2014-2238": {"epss_score": 0.45353, "epss_percentile": 0.97483}, "CVE-2014-2240": {"epss_score": 0.01867, "epss_percentile": 0.82617}, "CVE-2014-2241": {"epss_score": 0.00618, "epss_percentile": 0.69376}, "CVE-2014-2242": {"epss_score": 0.00499, "epss_percentile": 0.65279}, "CVE-2014-2243": {"epss_score": 0.00383, "epss_percentile": 0.5911}, "CVE-2014-2244": {"epss_score": 0.00456, "epss_percentile": 0.6333}, "CVE-2014-2245": {"epss_score": 0.00316, "epss_percentile": 0.54234}, "CVE-2014-2246": {"epss_score": 0.00508, "epss_percentile": 0.65713}, "CVE-2014-2247": {"epss_score": 0.00676, "epss_percentile": 0.70932}, "CVE-2014-2248": {"epss_score": 0.0069, "epss_percentile": 0.7124}, "CVE-2014-2249": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2014-2250": {"epss_score": 0.01546, "epss_percentile": 0.80966}, "CVE-2014-2251": {"epss_score": 0.00902, "epss_percentile": 0.75185}, "CVE-2014-2252": {"epss_score": 0.0016, "epss_percentile": 0.3747}, "CVE-2014-2253": {"epss_score": 0.0016, "epss_percentile": 0.3747}, "CVE-2014-2254": {"epss_score": 0.00474, "epss_percentile": 0.64164}, "CVE-2014-2255": {"epss_score": 0.01597, "epss_percentile": 0.81245}, "CVE-2014-2256": {"epss_score": 0.00902, "epss_percentile": 0.75185}, "CVE-2014-2257": {"epss_score": 0.00902, "epss_percentile": 0.75185}, "CVE-2014-2258": {"epss_score": 0.00474, "epss_percentile": 0.64164}, "CVE-2014-2259": {"epss_score": 0.01597, "epss_percentile": 0.81245}, "CVE-2014-2260": {"epss_score": 0.00215, "epss_percentile": 0.44036}, "CVE-2014-2262": {"epss_score": 0.08346, "epss_percentile": 0.92002}, "CVE-2014-2263": {"epss_score": 0.0113, "epss_percentile": 0.77849}, "CVE-2014-2264": {"epss_score": 0.00628, "epss_percentile": 0.69656}, "CVE-2014-2265": {"epss_score": 0.01376, "epss_percentile": 0.7984}, "CVE-2014-2268": {"epss_score": 0.77294, "epss_percentile": 0.9893}, "CVE-2014-2269": {"epss_score": 0.00641, "epss_percentile": 0.70016}, "CVE-2014-2270": {"epss_score": 0.3294, "epss_percentile": 0.96737}, "CVE-2014-2271": {"epss_score": 0.01795, "epss_percentile": 0.82302}, "CVE-2014-2273": {"epss_score": 0.00021, "epss_percentile": 0.04887}, "CVE-2014-2274": {"epss_score": 0.00165, "epss_percentile": 0.38078}, "CVE-2014-2276": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2014-2277": {"epss_score": 0.0006, "epss_percentile": 0.18979}, "CVE-2014-2278": {"epss_score": 0.02437, "epss_percentile": 0.84744}, "CVE-2014-2279": {"epss_score": 0.03518, "epss_percentile": 0.8728}, "CVE-2014-2280": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2014-2281": {"epss_score": 0.03333, "epss_percentile": 0.86931}, "CVE-2014-2282": {"epss_score": 0.0057, "epss_percentile": 0.67947}, "CVE-2014-2283": {"epss_score": 0.02406, "epss_percentile": 0.84653}, "CVE-2014-2284": {"epss_score": 0.04136, "epss_percentile": 0.88307}, "CVE-2014-2285": {"epss_score": 0.03115, "epss_percentile": 0.86433}, "CVE-2014-2286": {"epss_score": 0.14756, "epss_percentile": 0.94275}, "CVE-2014-2287": {"epss_score": 0.05216, "epss_percentile": 0.8962}, "CVE-2014-2288": {"epss_score": 0.07478, "epss_percentile": 0.91494}, "CVE-2014-2289": {"epss_score": 0.03701, "epss_percentile": 0.87591}, "CVE-2014-2291": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2014-2292": {"epss_score": 0.00043, "epss_percentile": 0.13237}, "CVE-2014-2293": {"epss_score": 0.12567, "epss_percentile": 0.93718}, "CVE-2014-2294": {"epss_score": 0.04677, "epss_percentile": 0.88997}, "CVE-2014-2296": {"epss_score": 0.00368, "epss_percentile": 0.58192}, "CVE-2014-2297": {"epss_score": 0.00166, "epss_percentile": 0.38236}, "CVE-2014-2299": {"epss_score": 0.70169, "epss_percentile": 0.98621}, "CVE-2014-2301": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2014-2302": {"epss_score": 0.02025, "epss_percentile": 0.83312}, "CVE-2014-2303": {"epss_score": 0.04786, "epss_percentile": 0.89142}, "CVE-2014-2304": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2014-2309": {"epss_score": 0.00906, "epss_percentile": 0.75255}, "CVE-2014-2310": {"epss_score": 0.01147, "epss_percentile": 0.78008}, "CVE-2014-2311": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2014-2312": {"epss_score": 0.00046, "epss_percentile": 0.14113}, "CVE-2014-2313": {"epss_score": 0.00231, "epss_percentile": 0.45778}, "CVE-2014-2314": {"epss_score": 0.66824, "epss_percentile": 0.98481}, "CVE-2014-2315": {"epss_score": 0.0027, "epss_percentile": 0.50203}, "CVE-2014-2316": {"epss_score": 0.00624, "epss_percentile": 0.69561}, "CVE-2014-2317": {"epss_score": 0.0038, "epss_percentile": 0.58933}, "CVE-2014-2318": {"epss_score": 0.00526, "epss_percentile": 0.66403}, "CVE-2014-2319": {"epss_score": 0.00141, "epss_percentile": 0.34921}, "CVE-2014-2321": {"epss_score": 0.92497, "epss_percentile": 0.99719}, "CVE-2014-2322": {"epss_score": 0.00995, "epss_percentile": 0.76431}, "CVE-2014-2323": {"epss_score": 0.92388, "epss_percentile": 0.99712}, "CVE-2014-2324": {"epss_score": 0.73451, "epss_percentile": 0.98756}, "CVE-2014-2325": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-2326": {"epss_score": 0.01268, "epss_percentile": 0.79025}, "CVE-2014-2327": {"epss_score": 0.00424, "epss_percentile": 0.61666}, "CVE-2014-2328": {"epss_score": 0.01128, "epss_percentile": 0.77831}, "CVE-2014-2329": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2014-2330": {"epss_score": 0.00168, "epss_percentile": 0.38407}, "CVE-2014-2331": {"epss_score": 0.00805, "epss_percentile": 0.73643}, "CVE-2014-2332": {"epss_score": 0.00525, "epss_percentile": 0.66392}, "CVE-2014-2333": {"epss_score": 0.00377, "epss_percentile": 0.58717}, "CVE-2014-2334": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-2335": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-2336": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-2338": {"epss_score": 0.00315, "epss_percentile": 0.5418}, "CVE-2014-2339": {"epss_score": 0.00316, "epss_percentile": 0.54277}, "CVE-2014-2340": {"epss_score": 0.01409, "epss_percentile": 0.80071}, "CVE-2014-2341": {"epss_score": 0.05131, "epss_percentile": 0.8953}, "CVE-2014-2342": {"epss_score": 0.00696, "epss_percentile": 0.71397}, "CVE-2014-2343": {"epss_score": 0.00089, "epss_percentile": 0.25881}, "CVE-2014-2345": {"epss_score": 0.00938, "epss_percentile": 0.75703}, "CVE-2014-2346": {"epss_score": 0.00074, "epss_percentile": 0.22793}, "CVE-2014-2347": {"epss_score": 0.03256, "epss_percentile": 0.86761}, "CVE-2014-2349": {"epss_score": 0.00107, "epss_percentile": 0.29658}, "CVE-2014-2350": {"epss_score": 0.00254, "epss_percentile": 0.48527}, "CVE-2014-2351": {"epss_score": 0.00464, "epss_percentile": 0.63717}, "CVE-2014-2352": {"epss_score": 0.00406, "epss_percentile": 0.60512}, "CVE-2014-2353": {"epss_score": 0.00518, "epss_percentile": 0.66139}, "CVE-2014-2354": {"epss_score": 0.00104, "epss_percentile": 0.29216}, "CVE-2014-2355": {"epss_score": 0.00114, "epss_percentile": 0.30751}, "CVE-2014-2356": {"epss_score": 0.01755, "epss_percentile": 0.82122}, "CVE-2014-2357": {"epss_score": 0.01665, "epss_percentile": 0.81644}, "CVE-2014-2358": {"epss_score": 0.00054, "epss_percentile": 0.17311}, "CVE-2014-2359": {"epss_score": 0.00865, "epss_percentile": 0.74623}, "CVE-2014-2360": {"epss_score": 0.0218, "epss_percentile": 0.83897}, "CVE-2014-2361": {"epss_score": 0.00081, "epss_percentile": 0.24222}, "CVE-2014-2362": {"epss_score": 0.01053, "epss_percentile": 0.77102}, "CVE-2014-2363": {"epss_score": 0.00568, "epss_percentile": 0.67901}, "CVE-2014-2364": {"epss_score": 0.40188, "epss_percentile": 0.97205}, "CVE-2014-2365": {"epss_score": 0.00388, "epss_percentile": 0.59358}, "CVE-2014-2366": {"epss_score": 0.00183, "epss_percentile": 0.40288}, "CVE-2014-2367": {"epss_score": 0.00409, "epss_percentile": 0.60728}, "CVE-2014-2368": {"epss_score": 0.00511, "epss_percentile": 0.65836}, "CVE-2014-2369": {"epss_score": 0.00067, "epss_percentile": 0.21014}, "CVE-2014-2370": {"epss_score": 0.00561, "epss_percentile": 0.67659}, "CVE-2014-2373": {"epss_score": 0.00605, "epss_percentile": 0.68985}, "CVE-2014-2374": {"epss_score": 0.00657, "epss_percentile": 0.70469}, "CVE-2014-2375": {"epss_score": 0.00562, "epss_percentile": 0.67683}, "CVE-2014-2376": {"epss_score": 0.00293, "epss_percentile": 0.52298}, "CVE-2014-2377": {"epss_score": 0.00517, "epss_percentile": 0.66083}, "CVE-2014-2378": {"epss_score": 0.00189, "epss_percentile": 0.40934}, "CVE-2014-2379": {"epss_score": 0.00046, "epss_percentile": 0.1419}, "CVE-2014-2380": {"epss_score": 0.00137, "epss_percentile": 0.34307}, "CVE-2014-2381": {"epss_score": 0.0003, "epss_percentile": 0.08188}, "CVE-2014-2382": {"epss_score": 0.00121, "epss_percentile": 0.31995}, "CVE-2014-2383": {"epss_score": 0.44813, "epss_percentile": 0.97454}, "CVE-2014-2384": {"epss_score": 0.00036, "epss_percentile": 0.10244}, "CVE-2014-2385": {"epss_score": 0.0065, "epss_percentile": 0.7026}, "CVE-2014-2386": {"epss_score": 0.008, "epss_percentile": 0.73546}, "CVE-2014-2387": {"epss_score": 0.00103, "epss_percentile": 0.29067}, "CVE-2014-2388": {"epss_score": 0.00287, "epss_percentile": 0.51806}, "CVE-2014-2389": {"epss_score": 0.1459, "epss_percentile": 0.94246}, "CVE-2014-2390": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2014-2391": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2014-2392": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2014-2393": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-2397": {"epss_score": 0.03209, "epss_percentile": 0.86642}, "CVE-2014-2398": {"epss_score": 0.00259, "epss_percentile": 0.49091}, "CVE-2014-2399": {"epss_score": 0.26699, "epss_percentile": 0.96167}, "CVE-2014-2400": {"epss_score": 0.00442, "epss_percentile": 0.62721}, "CVE-2014-2401": {"epss_score": 0.02267, "epss_percentile": 0.84199}, "CVE-2014-2402": {"epss_score": 0.00741, "epss_percentile": 0.72438}, "CVE-2014-2403": {"epss_score": 0.03093, "epss_percentile": 0.864}, "CVE-2014-2404": {"epss_score": 0.00219, "epss_percentile": 0.44494}, "CVE-2014-2405": {"epss_score": 0.00609, "epss_percentile": 0.69132}, "CVE-2014-2406": {"epss_score": 0.0058, "epss_percentile": 0.68239}, "CVE-2014-2407": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2014-2408": {"epss_score": 0.00271, "epss_percentile": 0.50328}, "CVE-2014-2409": {"epss_score": 0.00428, "epss_percentile": 0.61918}, "CVE-2014-2410": {"epss_score": 0.03093, "epss_percentile": 0.86399}, "CVE-2014-2411": {"epss_score": 0.00375, "epss_percentile": 0.58637}, "CVE-2014-2412": {"epss_score": 0.04322, "epss_percentile": 0.88548}, "CVE-2014-2413": {"epss_score": 0.00473, "epss_percentile": 0.64088}, "CVE-2014-2414": {"epss_score": 0.04322, "epss_percentile": 0.88548}, "CVE-2014-2415": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2014-2416": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2014-2417": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2014-2418": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2014-2419": {"epss_score": 0.01268, "epss_percentile": 0.79029}, "CVE-2014-2420": {"epss_score": 0.02074, "epss_percentile": 0.83499}, "CVE-2014-2421": {"epss_score": 0.05825, "epss_percentile": 0.90237}, "CVE-2014-2422": {"epss_score": 0.00757, "epss_percentile": 0.7276}, "CVE-2014-2423": {"epss_score": 0.04322, "epss_percentile": 0.88548}, "CVE-2014-2424": {"epss_score": 0.80022, "epss_percentile": 0.99067}, "CVE-2014-2425": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-2426": {"epss_score": 0.00322, "epss_percentile": 0.548}, "CVE-2014-2427": {"epss_score": 0.04322, "epss_percentile": 0.88548}, "CVE-2014-2428": {"epss_score": 0.0204, "epss_percentile": 0.83365}, "CVE-2014-2429": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-2430": {"epss_score": 0.00647, "epss_percentile": 0.70179}, "CVE-2014-2431": {"epss_score": 0.00998, "epss_percentile": 0.7647}, "CVE-2014-2432": {"epss_score": 0.00797, "epss_percentile": 0.73502}, "CVE-2014-2433": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2014-2434": {"epss_score": 0.00328, "epss_percentile": 0.5516}, "CVE-2014-2435": {"epss_score": 0.00328, "epss_percentile": 0.5516}, "CVE-2014-2436": {"epss_score": 0.00937, "epss_percentile": 0.75692}, "CVE-2014-2437": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2014-2438": {"epss_score": 0.00679, "epss_percentile": 0.71015}, "CVE-2014-2439": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2014-2440": {"epss_score": 0.00789, "epss_percentile": 0.73351}, "CVE-2014-2441": {"epss_score": 0.00048, "epss_percentile": 0.15242}, "CVE-2014-2442": {"epss_score": 0.0029, "epss_percentile": 0.52122}, "CVE-2014-2443": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-2444": {"epss_score": 0.0029, "epss_percentile": 0.52122}, "CVE-2014-2445": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2014-2446": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-2447": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2014-2448": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2014-2449": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-2450": {"epss_score": 0.0029, "epss_percentile": 0.52122}, "CVE-2014-2451": {"epss_score": 0.00203, "epss_percentile": 0.42557}, "CVE-2014-2452": {"epss_score": 0.00501, "epss_percentile": 0.65347}, "CVE-2014-2453": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-2454": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-2455": {"epss_score": 0.00351, "epss_percentile": 0.5704}, "CVE-2014-2456": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2014-2457": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-2458": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-2459": {"epss_score": 0.0007, "epss_percentile": 0.21809}, "CVE-2014-2460": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-2461": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2014-2463": {"epss_score": 0.00211, "epss_percentile": 0.43665}, "CVE-2014-2464": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-2465": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-2466": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-2467": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2014-2468": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-2469": {"epss_score": 0.00513, "epss_percentile": 0.65878}, "CVE-2014-2470": {"epss_score": 0.01254, "epss_percentile": 0.78921}, "CVE-2014-2471": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-2472": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2014-2473": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2014-2474": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2014-2475": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2014-2476": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2014-2477": {"epss_score": 0.07491, "epss_percentile": 0.915}, "CVE-2014-2478": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2014-2479": {"epss_score": 0.01017, "epss_percentile": 0.76696}, "CVE-2014-2480": {"epss_score": 0.01017, "epss_percentile": 0.76696}, "CVE-2014-2481": {"epss_score": 0.01017, "epss_percentile": 0.76696}, "CVE-2014-2482": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2014-2483": {"epss_score": 0.07165, "epss_percentile": 0.91295}, "CVE-2014-2484": {"epss_score": 0.00634, "epss_percentile": 0.6981}, "CVE-2014-2485": {"epss_score": 0.00177, "epss_percentile": 0.3953}, "CVE-2014-2486": {"epss_score": 0.0008, "epss_percentile": 0.24027}, "CVE-2014-2487": {"epss_score": 0.00081, "epss_percentile": 0.24374}, "CVE-2014-2488": {"epss_score": 0.00121, "epss_percentile": 0.31825}, "CVE-2014-2489": {"epss_score": 0.00094, "epss_percentile": 0.2699}, "CVE-2014-2490": {"epss_score": 0.03114, "epss_percentile": 0.8643}, "CVE-2014-2491": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2014-2492": {"epss_score": 0.00334, "epss_percentile": 0.55733}, "CVE-2014-2493": {"epss_score": 0.00897, "epss_percentile": 0.75135}, "CVE-2014-2494": {"epss_score": 0.00442, "epss_percentile": 0.6271}, "CVE-2014-2495": {"epss_score": 0.00526, "epss_percentile": 0.66431}, "CVE-2014-2496": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2014-2497": {"epss_score": 0.12135, "epss_percentile": 0.93581}, "CVE-2014-2502": {"epss_score": 0.00222, "epss_percentile": 0.44719}, "CVE-2014-2503": {"epss_score": 0.00349, "epss_percentile": 0.56856}, "CVE-2014-2504": {"epss_score": 0.0033, "epss_percentile": 0.55479}, "CVE-2014-2505": {"epss_score": 0.00304, "epss_percentile": 0.53247}, "CVE-2014-2506": {"epss_score": 0.012, "epss_percentile": 0.78467}, "CVE-2014-2507": {"epss_score": 0.02022, "epss_percentile": 0.83299}, "CVE-2014-2508": {"epss_score": 0.00583, "epss_percentile": 0.68354}, "CVE-2014-2509": {"epss_score": 0.00275, "epss_percentile": 0.50664}, "CVE-2014-2510": {"epss_score": 0.00503, "epss_percentile": 0.65445}, "CVE-2014-2511": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2014-2512": {"epss_score": 0.00297, "epss_percentile": 0.52684}, "CVE-2014-2513": {"epss_score": 0.01157, "epss_percentile": 0.78114}, "CVE-2014-2514": {"epss_score": 0.02192, "epss_percentile": 0.83941}, "CVE-2014-2515": {"epss_score": 0.0102, "epss_percentile": 0.76742}, "CVE-2014-2516": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2014-2517": {"epss_score": 0.00498, "epss_percentile": 0.65242}, "CVE-2014-2518": {"epss_score": 0.002, "epss_percentile": 0.42239}, "CVE-2014-2519": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2014-2520": {"epss_score": 0.00422, "epss_percentile": 0.61541}, "CVE-2014-2521": {"epss_score": 0.00422, "epss_percentile": 0.61541}, "CVE-2014-2522": {"epss_score": 0.00292, "epss_percentile": 0.52225}, "CVE-2014-2523": {"epss_score": 0.04413, "epss_percentile": 0.88663}, "CVE-2014-2524": {"epss_score": 0.00157, "epss_percentile": 0.37077}, "CVE-2014-2525": {"epss_score": 0.63229, "epss_percentile": 0.98324}, "CVE-2014-2526": {"epss_score": 0.00704, "epss_percentile": 0.7157}, "CVE-2014-2527": {"epss_score": 0.00953, "epss_percentile": 0.75886}, "CVE-2014-2528": {"epss_score": 0.00925, "epss_percentile": 0.75533}, "CVE-2014-2531": {"epss_score": 0.00806, "epss_percentile": 0.73645}, "CVE-2014-2532": {"epss_score": 0.00204, "epss_percentile": 0.4261}, "CVE-2014-2533": {"epss_score": 0.26247, "epss_percentile": 0.96129}, "CVE-2014-2534": {"epss_score": 0.00652, "epss_percentile": 0.7031}, "CVE-2014-2535": {"epss_score": 0.01314, "epss_percentile": 0.79393}, "CVE-2014-2536": {"epss_score": 0.0089, "epss_percentile": 0.75031}, "CVE-2014-2537": {"epss_score": 0.01052, "epss_percentile": 0.77097}, "CVE-2014-2538": {"epss_score": 0.00273, "epss_percentile": 0.50466}, "CVE-2014-2540": {"epss_score": 0.00914, "epss_percentile": 0.75394}, "CVE-2014-2541": {"epss_score": 0.00307, "epss_percentile": 0.53474}, "CVE-2014-2542": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2014-2543": {"epss_score": 0.04297, "epss_percentile": 0.88511}, "CVE-2014-2544": {"epss_score": 0.01175, "epss_percentile": 0.78263}, "CVE-2014-2545": {"epss_score": 0.0023, "epss_percentile": 0.45717}, "CVE-2014-2550": {"epss_score": 0.00201, "epss_percentile": 0.42383}, "CVE-2014-2552": {"epss_score": 0.03164, "epss_percentile": 0.86535}, "CVE-2014-2553": {"epss_score": 0.00191, "epss_percentile": 0.41215}, "CVE-2014-2554": {"epss_score": 0.00226, "epss_percentile": 0.45346}, "CVE-2014-2558": {"epss_score": 0.00382, "epss_percentile": 0.59062}, "CVE-2014-2559": {"epss_score": 0.01476, "epss_percentile": 0.80535}, "CVE-2014-2560": {"epss_score": 0.02084, "epss_percentile": 0.83543}, "CVE-2014-2565": {"epss_score": 0.00562, "epss_percentile": 0.67707}, "CVE-2014-2567": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2014-2568": {"epss_score": 0.0019, "epss_percentile": 0.41064}, "CVE-2014-2570": {"epss_score": 0.00422, "epss_percentile": 0.61568}, "CVE-2014-2571": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2014-2572": {"epss_score": 0.00178, "epss_percentile": 0.3967}, "CVE-2014-2573": {"epss_score": 0.00106, "epss_percentile": 0.29437}, "CVE-2014-2575": {"epss_score": 0.10201, "epss_percentile": 0.92889}, "CVE-2014-2576": {"epss_score": 0.00669, "epss_percentile": 0.70763}, "CVE-2014-2577": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2014-2578": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2014-2579": {"epss_score": 0.0129, "epss_percentile": 0.79219}, "CVE-2014-2580": {"epss_score": 0.00071, "epss_percentile": 0.22142}, "CVE-2014-2581": {"epss_score": 0.01988, "epss_percentile": 0.83165}, "CVE-2014-2583": {"epss_score": 0.01506, "epss_percentile": 0.8075}, "CVE-2014-2585": {"epss_score": 0.00171, "epss_percentile": 0.38827}, "CVE-2014-2586": {"epss_score": 0.08642, "epss_percentile": 0.92169}, "CVE-2014-2587": {"epss_score": 0.04886, "epss_percentile": 0.89254}, "CVE-2014-2588": {"epss_score": 0.17987, "epss_percentile": 0.94937}, "CVE-2014-2589": {"epss_score": 0.00848, "epss_percentile": 0.74355}, "CVE-2014-2590": {"epss_score": 0.00305, "epss_percentile": 0.53343}, "CVE-2014-2591": {"epss_score": 0.00133, "epss_percentile": 0.33668}, "CVE-2014-2592": {"epss_score": 0.01754, "epss_percentile": 0.82115}, "CVE-2014-2593": {"epss_score": 0.00677, "epss_percentile": 0.7095}, "CVE-2014-2595": {"epss_score": 0.57469, "epss_percentile": 0.98065}, "CVE-2014-2597": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2014-2598": {"epss_score": 0.00979, "epss_percentile": 0.76259}, "CVE-2014-2599": {"epss_score": 0.00075, "epss_percentile": 0.22903}, "CVE-2014-2600": {"epss_score": 0.00241, "epss_percentile": 0.47257}, "CVE-2014-2601": {"epss_score": 0.03464, "epss_percentile": 0.87186}, "CVE-2014-2602": {"epss_score": 0.00234, "epss_percentile": 0.46094}, "CVE-2014-2603": {"epss_score": 0.00251, "epss_percentile": 0.48281}, "CVE-2014-2604": {"epss_score": 0.01563, "epss_percentile": 0.81058}, "CVE-2014-2605": {"epss_score": 0.01062, "epss_percentile": 0.77178}, "CVE-2014-2606": {"epss_score": 0.00266, "epss_percentile": 0.49883}, "CVE-2014-2607": {"epss_score": 0.00546, "epss_percentile": 0.6722}, "CVE-2014-2608": {"epss_score": 0.00043, "epss_percentile": 0.13237}, "CVE-2014-2609": {"epss_score": 0.25048, "epss_percentile": 0.95982}, "CVE-2014-2610": {"epss_score": 0.01751, "epss_percentile": 0.82102}, "CVE-2014-2611": {"epss_score": 0.02427, "epss_percentile": 0.8472}, "CVE-2014-2612": {"epss_score": 0.09752, "epss_percentile": 0.9269}, "CVE-2014-2613": {"epss_score": 0.00216, "epss_percentile": 0.44141}, "CVE-2014-2614": {"epss_score": 0.01037, "epss_percentile": 0.76926}, "CVE-2014-2615": {"epss_score": 0.07579, "epss_percentile": 0.91551}, "CVE-2014-2616": {"epss_score": 0.07579, "epss_percentile": 0.91551}, "CVE-2014-2617": {"epss_score": 0.412, "epss_percentile": 0.97259}, "CVE-2014-2618": {"epss_score": 0.01113, "epss_percentile": 0.77683}, "CVE-2014-2619": {"epss_score": 0.01522, "epss_percentile": 0.80837}, "CVE-2014-2620": {"epss_score": 0.01522, "epss_percentile": 0.80837}, "CVE-2014-2621": {"epss_score": 0.01522, "epss_percentile": 0.80837}, "CVE-2014-2622": {"epss_score": 0.00288, "epss_percentile": 0.51913}, "CVE-2014-2623": {"epss_score": 0.89835, "epss_percentile": 0.99545}, "CVE-2014-2624": {"epss_score": 0.77355, "epss_percentile": 0.98933}, "CVE-2014-2625": {"epss_score": 0.08745, "epss_percentile": 0.92238}, "CVE-2014-2626": {"epss_score": 0.40449, "epss_percentile": 0.97219}, "CVE-2014-2627": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2014-2628": {"epss_score": 0.00214, "epss_percentile": 0.43985}, "CVE-2014-2629": {"epss_score": 0.00139, "epss_percentile": 0.34659}, "CVE-2014-2630": {"epss_score": 0.12237, "epss_percentile": 0.93609}, "CVE-2014-2631": {"epss_score": 0.00355, "epss_percentile": 0.57292}, "CVE-2014-2632": {"epss_score": 0.3836, "epss_percentile": 0.97098}, "CVE-2014-2633": {"epss_score": 0.00302, "epss_percentile": 0.53159}, "CVE-2014-2634": {"epss_score": 0.05708, "epss_percentile": 0.90139}, "CVE-2014-2635": {"epss_score": 0.0484, "epss_percentile": 0.89199}, "CVE-2014-2636": {"epss_score": 0.0484, "epss_percentile": 0.89199}, "CVE-2014-2637": {"epss_score": 0.0484, "epss_percentile": 0.89199}, "CVE-2014-2638": {"epss_score": 0.0484, "epss_percentile": 0.89199}, "CVE-2014-2639": {"epss_score": 0.0028, "epss_percentile": 0.5109}, "CVE-2014-2640": {"epss_score": 0.02116, "epss_percentile": 0.83659}, "CVE-2014-2641": {"epss_score": 0.00056, "epss_percentile": 0.17909}, "CVE-2014-2642": {"epss_score": 0.00472, "epss_percentile": 0.64061}, "CVE-2014-2643": {"epss_score": 0.0026, "epss_percentile": 0.49175}, "CVE-2014-2644": {"epss_score": 0.00669, "epss_percentile": 0.70753}, "CVE-2014-2645": {"epss_score": 0.00472, "epss_percentile": 0.64061}, "CVE-2014-2646": {"epss_score": 0.00056, "epss_percentile": 0.1778}, "CVE-2014-2647": {"epss_score": 0.02052, "epss_percentile": 0.83411}, "CVE-2014-2648": {"epss_score": 0.22349, "epss_percentile": 0.95625}, "CVE-2014-2649": {"epss_score": 0.03623, "epss_percentile": 0.87445}, "CVE-2014-2650": {"epss_score": 0.05367, "epss_percentile": 0.89791}, "CVE-2014-2651": {"epss_score": 0.00402, "epss_percentile": 0.60262}, "CVE-2014-2652": {"epss_score": 0.00585, "epss_percentile": 0.68428}, "CVE-2014-2653": {"epss_score": 0.03883, "epss_percentile": 0.87899}, "CVE-2014-2654": {"epss_score": 0.00396, "epss_percentile": 0.59898}, "CVE-2014-2655": {"epss_score": 0.00515, "epss_percentile": 0.66008}, "CVE-2014-2657": {"epss_score": 0.00215, "epss_percentile": 0.44029}, "CVE-2014-2658": {"epss_score": 0.00225, "epss_percentile": 0.45227}, "CVE-2014-2659": {"epss_score": 0.00084, "epss_percentile": 0.24905}, "CVE-2014-2664": {"epss_score": 0.06855, "epss_percentile": 0.91078}, "CVE-2014-2665": {"epss_score": 0.00198, "epss_percentile": 0.42095}, "CVE-2014-2667": {"epss_score": 0.00063, "epss_percentile": 0.19923}, "CVE-2014-2668": {"epss_score": 0.40369, "epss_percentile": 0.97215}, "CVE-2014-2669": {"epss_score": 0.00939, "epss_percentile": 0.75724}, "CVE-2014-2670": {"epss_score": 0.00578, "epss_percentile": 0.68185}, "CVE-2014-2671": {"epss_score": 0.30873, "epss_percentile": 0.96573}, "CVE-2014-2672": {"epss_score": 0.00666, "epss_percentile": 0.70686}, "CVE-2014-2673": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2014-2674": {"epss_score": 0.2301, "epss_percentile": 0.95717}, "CVE-2014-2675": {"epss_score": 0.0008, "epss_percentile": 0.2419}, "CVE-2014-2678": {"epss_score": 0.00092, "epss_percentile": 0.26439}, "CVE-2014-2680": {"epss_score": 0.0212, "epss_percentile": 0.83673}, "CVE-2014-2681": {"epss_score": 0.03452, "epss_percentile": 0.87165}, "CVE-2014-2682": {"epss_score": 0.01826, "epss_percentile": 0.82435}, "CVE-2014-2683": {"epss_score": 0.02975, "epss_percentile": 0.86103}, "CVE-2014-2684": {"epss_score": 0.00573, "epss_percentile": 0.68039}, "CVE-2014-2685": {"epss_score": 0.00837, "epss_percentile": 0.74161}, "CVE-2014-2686": {"epss_score": 0.00376, "epss_percentile": 0.58663}, "CVE-2014-2689": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-2690": {"epss_score": 0.0007, "epss_percentile": 0.21701}, "CVE-2014-2706": {"epss_score": 0.03101, "epss_percentile": 0.86409}, "CVE-2014-2707": {"epss_score": 0.01347, "epss_percentile": 0.79655}, "CVE-2014-2708": {"epss_score": 0.01497, "epss_percentile": 0.8069}, "CVE-2014-2709": {"epss_score": 0.01868, "epss_percentile": 0.8262}, "CVE-2014-2710": {"epss_score": 0.00343, "epss_percentile": 0.56407}, "CVE-2014-2711": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-2712": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-2713": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-2714": {"epss_score": 0.00721, "epss_percentile": 0.71968}, "CVE-2014-2715": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-2716": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2014-2717": {"epss_score": 0.0042, "epss_percentile": 0.61439}, "CVE-2014-2718": {"epss_score": 0.00243, "epss_percentile": 0.47422}, "CVE-2014-2719": {"epss_score": 0.00309, "epss_percentile": 0.53706}, "CVE-2014-2720": {"epss_score": 0.02005, "epss_percentile": 0.8323}, "CVE-2014-2721": {"epss_score": 0.01117, "epss_percentile": 0.77723}, "CVE-2014-2722": {"epss_score": 0.01117, "epss_percentile": 0.77723}, "CVE-2014-2723": {"epss_score": 0.01117, "epss_percentile": 0.77723}, "CVE-2014-2727": {"epss_score": 0.0609, "epss_percentile": 0.90473}, "CVE-2014-2729": {"epss_score": 0.00179, "epss_percentile": 0.39815}, "CVE-2014-2730": {"epss_score": 0.09293, "epss_percentile": 0.92487}, "CVE-2014-2731": {"epss_score": 0.02357, "epss_percentile": 0.84486}, "CVE-2014-2732": {"epss_score": 0.0035, "epss_percentile": 0.56977}, "CVE-2014-2733": {"epss_score": 0.00376, "epss_percentile": 0.58651}, "CVE-2014-2734": {"epss_score": 0.05796, "epss_percentile": 0.90217}, "CVE-2014-2735": {"epss_score": 0.00152, "epss_percentile": 0.364}, "CVE-2014-2736": {"epss_score": 0.00517, "epss_percentile": 0.66081}, "CVE-2014-2737": {"epss_score": 0.00289, "epss_percentile": 0.52024}, "CVE-2014-2739": {"epss_score": 0.00356, "epss_percentile": 0.57365}, "CVE-2014-2741": {"epss_score": 0.03204, "epss_percentile": 0.86629}, "CVE-2014-2742": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2014-2743": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2014-2744": {"epss_score": 0.02179, "epss_percentile": 0.83895}, "CVE-2014-2745": {"epss_score": 0.02179, "epss_percentile": 0.83895}, "CVE-2014-2746": {"epss_score": 0.02877, "epss_percentile": 0.85884}, "CVE-2014-2748": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2014-2749": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2014-2751": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2014-2752": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2014-2753": {"epss_score": 0.48087, "epss_percentile": 0.9762}, "CVE-2014-2754": {"epss_score": 0.51273, "epss_percentile": 0.97773}, "CVE-2014-2755": {"epss_score": 0.48087, "epss_percentile": 0.9762}, "CVE-2014-2756": {"epss_score": 0.48087, "epss_percentile": 0.9762}, "CVE-2014-2757": {"epss_score": 0.49014, "epss_percentile": 0.97662}, "CVE-2014-2758": {"epss_score": 0.48087, "epss_percentile": 0.9762}, "CVE-2014-2759": {"epss_score": 0.48087, "epss_percentile": 0.9762}, "CVE-2014-2760": {"epss_score": 0.48087, "epss_percentile": 0.9762}, "CVE-2014-2761": {"epss_score": 0.42794, "epss_percentile": 0.97353}, "CVE-2014-2763": {"epss_score": 0.42794, "epss_percentile": 0.97353}, "CVE-2014-2764": {"epss_score": 0.42794, "epss_percentile": 0.97353}, "CVE-2014-2765": {"epss_score": 0.42794, "epss_percentile": 0.97353}, "CVE-2014-2766": {"epss_score": 0.42794, "epss_percentile": 0.97353}, "CVE-2014-2767": {"epss_score": 0.42794, "epss_percentile": 0.97353}, "CVE-2014-2768": {"epss_score": 0.42794, "epss_percentile": 0.97353}, "CVE-2014-2769": {"epss_score": 0.42794, "epss_percentile": 0.97353}, "CVE-2014-2770": {"epss_score": 0.42794, "epss_percentile": 0.97353}, "CVE-2014-2771": {"epss_score": 0.42794, "epss_percentile": 0.97353}, "CVE-2014-2772": {"epss_score": 0.42794, "epss_percentile": 0.97353}, "CVE-2014-2773": {"epss_score": 0.43785, "epss_percentile": 0.97403}, "CVE-2014-2774": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-2775": {"epss_score": 0.42424, "epss_percentile": 0.97331}, "CVE-2014-2776": {"epss_score": 0.41368, "epss_percentile": 0.97269}, "CVE-2014-2777": {"epss_score": 0.34014, "epss_percentile": 0.96821}, "CVE-2014-2778": {"epss_score": 0.40401, "epss_percentile": 0.97216}, "CVE-2014-2779": {"epss_score": 0.04191, "epss_percentile": 0.88376}, "CVE-2014-2780": {"epss_score": 0.03119, "epss_percentile": 0.86442}, "CVE-2014-2781": {"epss_score": 0.07537, "epss_percentile": 0.91523}, "CVE-2014-2782": {"epss_score": 0.42356, "epss_percentile": 0.97328}, "CVE-2014-2783": {"epss_score": 0.07745, "epss_percentile": 0.91655}, "CVE-2014-2784": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-2785": {"epss_score": 0.18345, "epss_percentile": 0.95}, "CVE-2014-2786": {"epss_score": 0.18345, "epss_percentile": 0.95}, "CVE-2014-2787": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2788": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2789": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2790": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2791": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2792": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2794": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2795": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2796": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-2797": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2798": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2799": {"epss_score": 0.18139, "epss_percentile": 0.94965}, "CVE-2014-2800": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2801": {"epss_score": 0.14922, "epss_percentile": 0.94325}, "CVE-2014-2802": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2803": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2804": {"epss_score": 0.14922, "epss_percentile": 0.94325}, "CVE-2014-2806": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2807": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2808": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-2809": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2810": {"epss_score": 0.1418, "epss_percentile": 0.94157}, "CVE-2014-2811": {"epss_score": 0.1418, "epss_percentile": 0.94157}, "CVE-2014-2813": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-2814": {"epss_score": 0.28065, "epss_percentile": 0.96305}, "CVE-2014-2815": {"epss_score": 0.13376, "epss_percentile": 0.93946}, "CVE-2014-2816": {"epss_score": 0.44981, "epss_percentile": 0.97465}, "CVE-2014-2817": {"epss_score": 0.26216, "epss_percentile": 0.96124}, "CVE-2014-2818": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-2819": {"epss_score": 0.10219, "epss_percentile": 0.929}, "CVE-2014-2820": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-2821": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-2822": {"epss_score": 0.1418, "epss_percentile": 0.94157}, "CVE-2014-2823": {"epss_score": 0.1418, "epss_percentile": 0.94157}, "CVE-2014-2824": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-2825": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-2826": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-2827": {"epss_score": 0.14833, "epss_percentile": 0.94299}, "CVE-2014-2828": {"epss_score": 0.00864, "epss_percentile": 0.74606}, "CVE-2014-2829": {"epss_score": 0.005, "epss_percentile": 0.65289}, "CVE-2014-2830": {"epss_score": 0.02896, "epss_percentile": 0.85926}, "CVE-2014-2838": {"epss_score": 0.00233, "epss_percentile": 0.46075}, "CVE-2014-2839": {"epss_score": 0.00271, "epss_percentile": 0.50329}, "CVE-2014-2842": {"epss_score": 0.00882, "epss_percentile": 0.74883}, "CVE-2014-2843": {"epss_score": 0.00417, "epss_percentile": 0.61231}, "CVE-2014-2844": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2014-2845": {"epss_score": 0.0013, "epss_percentile": 0.33301}, "CVE-2014-2846": {"epss_score": 0.05059, "epss_percentile": 0.89451}, "CVE-2014-2847": {"epss_score": 0.00379, "epss_percentile": 0.58859}, "CVE-2014-2848": {"epss_score": 0.00035, "epss_percentile": 0.09968}, "CVE-2014-2849": {"epss_score": 0.73239, "epss_percentile": 0.98743}, "CVE-2014-2850": {"epss_score": 0.75717, "epss_percentile": 0.98861}, "CVE-2014-2851": {"epss_score": 0.0022, "epss_percentile": 0.44579}, "CVE-2014-2852": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-2853": {"epss_score": 0.00454, "epss_percentile": 0.63268}, "CVE-2014-2854": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-2855": {"epss_score": 0.17189, "epss_percentile": 0.94795}, "CVE-2014-2856": {"epss_score": 0.01035, "epss_percentile": 0.76907}, "CVE-2014-2857": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2014-2858": {"epss_score": 0.00239, "epss_percentile": 0.4686}, "CVE-2014-2859": {"epss_score": 0.00345, "epss_percentile": 0.5657}, "CVE-2014-2860": {"epss_score": 0.00199, "epss_percentile": 0.42141}, "CVE-2014-2861": {"epss_score": 0.00352, "epss_percentile": 0.57104}, "CVE-2014-2862": {"epss_score": 0.00277, "epss_percentile": 0.50778}, "CVE-2014-2863": {"epss_score": 0.009, "epss_percentile": 0.7516}, "CVE-2014-2864": {"epss_score": 0.00649, "epss_percentile": 0.70243}, "CVE-2014-2865": {"epss_score": 0.00345, "epss_percentile": 0.5657}, "CVE-2014-2866": {"epss_score": 0.01057, "epss_percentile": 0.77135}, "CVE-2014-2867": {"epss_score": 0.04111, "epss_percentile": 0.88271}, "CVE-2014-2868": {"epss_score": 0.01342, "epss_percentile": 0.79594}, "CVE-2014-2869": {"epss_score": 0.00338, "epss_percentile": 0.56112}, "CVE-2014-2870": {"epss_score": 0.0027, "epss_percentile": 0.50215}, "CVE-2014-2871": {"epss_score": 0.00338, "epss_percentile": 0.56112}, "CVE-2014-2872": {"epss_score": 0.00338, "epss_percentile": 0.56112}, "CVE-2014-2873": {"epss_score": 0.00315, "epss_percentile": 0.54164}, "CVE-2014-2874": {"epss_score": 0.04363, "epss_percentile": 0.88599}, "CVE-2014-2875": {"epss_score": 0.00573, "epss_percentile": 0.68052}, "CVE-2014-2879": {"epss_score": 0.10572, "epss_percentile": 0.93031}, "CVE-2014-2880": {"epss_score": 0.12176, "epss_percentile": 0.93592}, "CVE-2014-2881": {"epss_score": 0.00421, "epss_percentile": 0.61463}, "CVE-2014-2882": {"epss_score": 0.00226, "epss_percentile": 0.45329}, "CVE-2014-2884": {"epss_score": 0.00035, "epss_percentile": 0.09821}, "CVE-2014-2885": {"epss_score": 0.0004, "epss_percentile": 0.12063}, "CVE-2014-2886": {"epss_score": 0.00442, "epss_percentile": 0.62713}, "CVE-2014-2888": {"epss_score": 0.00734, "epss_percentile": 0.72239}, "CVE-2014-2889": {"epss_score": 0.00129, "epss_percentile": 0.33213}, "CVE-2014-2890": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2014-2891": {"epss_score": 0.01638, "epss_percentile": 0.81484}, "CVE-2014-2892": {"epss_score": 0.03709, "epss_percentile": 0.87603}, "CVE-2014-2893": {"epss_score": 0.00084, "epss_percentile": 0.24893}, "CVE-2014-2894": {"epss_score": 0.00059, "epss_percentile": 0.18823}, "CVE-2014-2896": {"epss_score": 0.01008, "epss_percentile": 0.76567}, "CVE-2014-2897": {"epss_score": 0.01008, "epss_percentile": 0.76567}, "CVE-2014-2898": {"epss_score": 0.01008, "epss_percentile": 0.76567}, "CVE-2014-2899": {"epss_score": 0.00877, "epss_percentile": 0.74799}, "CVE-2014-2900": {"epss_score": 0.00285, "epss_percentile": 0.51653}, "CVE-2014-2901": {"epss_score": 0.00155, "epss_percentile": 0.36804}, "CVE-2014-2902": {"epss_score": 0.0022, "epss_percentile": 0.4458}, "CVE-2014-2903": {"epss_score": 0.00213, "epss_percentile": 0.43928}, "CVE-2014-2904": {"epss_score": 0.00228, "epss_percentile": 0.45519}, "CVE-2014-2905": {"epss_score": 0.00036, "epss_percentile": 0.1021}, "CVE-2014-2906": {"epss_score": 0.0011, "epss_percentile": 0.30216}, "CVE-2014-2907": {"epss_score": 0.00205, "epss_percentile": 0.42758}, "CVE-2014-2908": {"epss_score": 0.38723, "epss_percentile": 0.97117}, "CVE-2014-2909": {"epss_score": 0.00838, "epss_percentile": 0.74175}, "CVE-2014-2913": {"epss_score": 0.14237, "epss_percentile": 0.94169}, "CVE-2014-2914": {"epss_score": 0.02481, "epss_percentile": 0.84874}, "CVE-2014-2915": {"epss_score": 0.00118, "epss_percentile": 0.31484}, "CVE-2014-2916": {"epss_score": 0.00182, "epss_percentile": 0.40144}, "CVE-2014-2921": {"epss_score": 0.00462, "epss_percentile": 0.63615}, "CVE-2014-2922": {"epss_score": 0.003, "epss_percentile": 0.52954}, "CVE-2014-2925": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2014-2926": {"epss_score": 0.00221, "epss_percentile": 0.44703}, "CVE-2014-2927": {"epss_score": 0.07425, "epss_percentile": 0.91468}, "CVE-2014-2928": {"epss_score": 0.64597, "epss_percentile": 0.98385}, "CVE-2014-2933": {"epss_score": 0.00214, "epss_percentile": 0.43996}, "CVE-2014-2934": {"epss_score": 0.00555, "epss_percentile": 0.67457}, "CVE-2014-2935": {"epss_score": 0.01532, "epss_percentile": 0.80896}, "CVE-2014-2936": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2014-2938": {"epss_score": 0.00555, "epss_percentile": 0.67487}, "CVE-2014-2939": {"epss_score": 0.00589, "epss_percentile": 0.68528}, "CVE-2014-2940": {"epss_score": 0.00287, "epss_percentile": 0.51791}, "CVE-2014-2941": {"epss_score": 0.0155, "epss_percentile": 0.80985}, "CVE-2014-2942": {"epss_score": 0.00116, "epss_percentile": 0.31194}, "CVE-2014-2946": {"epss_score": 0.00456, "epss_percentile": 0.63348}, "CVE-2014-2947": {"epss_score": 0.0123, "epss_percentile": 0.78723}, "CVE-2014-2948": {"epss_score": 0.00318, "epss_percentile": 0.54433}, "CVE-2014-2949": {"epss_score": 0.00397, "epss_percentile": 0.59965}, "CVE-2014-2950": {"epss_score": 0.00517, "epss_percentile": 0.66066}, "CVE-2014-2951": {"epss_score": 0.00774, "epss_percentile": 0.73069}, "CVE-2014-2955": {"epss_score": 0.01178, "epss_percentile": 0.78283}, "CVE-2014-2956": {"epss_score": 0.01371, "epss_percentile": 0.79808}, "CVE-2014-2957": {"epss_score": 0.02176, "epss_percentile": 0.83885}, "CVE-2014-2959": {"epss_score": 0.01209, "epss_percentile": 0.78545}, "CVE-2014-2960": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2014-2962": {"epss_score": 0.87901, "epss_percentile": 0.99448}, "CVE-2014-2963": {"epss_score": 0.00547, "epss_percentile": 0.67243}, "CVE-2014-2964": {"epss_score": 0.00198, "epss_percentile": 0.42006}, "CVE-2014-2965": {"epss_score": 0.00819, "epss_percentile": 0.73871}, "CVE-2014-2966": {"epss_score": 0.00397, "epss_percentile": 0.6003}, "CVE-2014-2967": {"epss_score": 0.04363, "epss_percentile": 0.88599}, "CVE-2014-2968": {"epss_score": 0.00422, "epss_percentile": 0.61536}, "CVE-2014-2969": {"epss_score": 0.00234, "epss_percentile": 0.46091}, "CVE-2014-2971": {"epss_score": 0.00558, "epss_percentile": 0.67577}, "CVE-2014-2972": {"epss_score": 0.00213, "epss_percentile": 0.43945}, "CVE-2014-2974": {"epss_score": 0.00108, "epss_percentile": 0.29811}, "CVE-2014-2975": {"epss_score": 0.00547, "epss_percentile": 0.67243}, "CVE-2014-2976": {"epss_score": 0.14658, "epss_percentile": 0.94259}, "CVE-2014-2977": {"epss_score": 0.09648, "epss_percentile": 0.92639}, "CVE-2014-2978": {"epss_score": 0.08143, "epss_percentile": 0.919}, "CVE-2014-2980": {"epss_score": 0.01036, "epss_percentile": 0.76911}, "CVE-2014-2983": {"epss_score": 0.00434, "epss_percentile": 0.6231}, "CVE-2014-2986": {"epss_score": 0.00214, "epss_percentile": 0.43981}, "CVE-2014-2987": {"epss_score": 0.03683, "epss_percentile": 0.87562}, "CVE-2014-2988": {"epss_score": 0.00907, "epss_percentile": 0.7527}, "CVE-2014-2989": {"epss_score": 0.00171, "epss_percentile": 0.38901}, "CVE-2014-2992": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2014-2993": {"epss_score": 0.00152, "epss_percentile": 0.364}, "CVE-2014-2994": {"epss_score": 0.48147, "epss_percentile": 0.97623}, "CVE-2014-2995": {"epss_score": 0.00748, "epss_percentile": 0.72579}, "CVE-2014-2996": {"epss_score": 0.13785, "epss_percentile": 0.94057}, "CVE-2014-3000": {"epss_score": 0.06384, "epss_percentile": 0.90714}, "CVE-2014-3001": {"epss_score": 0.00288, "epss_percentile": 0.51911}, "CVE-2014-3004": {"epss_score": 0.0107, "epss_percentile": 0.7726}, "CVE-2014-3005": {"epss_score": 0.04287, "epss_percentile": 0.88497}, "CVE-2014-3006": {"epss_score": 0.00548, "epss_percentile": 0.67267}, "CVE-2014-3007": {"epss_score": 0.01846, "epss_percentile": 0.82512}, "CVE-2014-3008": {"epss_score": 0.21898, "epss_percentile": 0.95571}, "CVE-2014-3009": {"epss_score": 0.00137, "epss_percentile": 0.34314}, "CVE-2014-3010": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2014-3011": {"epss_score": 0.00256, "epss_percentile": 0.48814}, "CVE-2014-3012": {"epss_score": 0.00173, "epss_percentile": 0.3913}, "CVE-2014-3013": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-3014": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-3015": {"epss_score": 0.00109, "epss_percentile": 0.2996}, "CVE-2014-3018": {"epss_score": 0.00724, "epss_percentile": 0.72028}, "CVE-2014-3019": {"epss_score": 0.00218, "epss_percentile": 0.44413}, "CVE-2014-3020": {"epss_score": 0.00041, "epss_percentile": 0.12429}, "CVE-2014-3021": {"epss_score": 0.00294, "epss_percentile": 0.52428}, "CVE-2014-3022": {"epss_score": 0.00649, "epss_percentile": 0.70238}, "CVE-2014-3024": {"epss_score": 0.00152, "epss_percentile": 0.36429}, "CVE-2014-3025": {"epss_score": 0.00208, "epss_percentile": 0.43262}, "CVE-2014-3026": {"epss_score": 0.00173, "epss_percentile": 0.3913}, "CVE-2014-3031": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-3032": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-3033": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-3034": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-3035": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-3036": {"epss_score": 0.00218, "epss_percentile": 0.44418}, "CVE-2014-3037": {"epss_score": 0.00136, "epss_percentile": 0.34192}, "CVE-2014-3038": {"epss_score": 0.0006, "epss_percentile": 0.1898}, "CVE-2014-3040": {"epss_score": 0.00237, "epss_percentile": 0.46724}, "CVE-2014-3041": {"epss_score": 0.00314, "epss_percentile": 0.54095}, "CVE-2014-3042": {"epss_score": 0.00849, "epss_percentile": 0.74375}, "CVE-2014-3043": {"epss_score": 0.00349, "epss_percentile": 0.56905}, "CVE-2014-3045": {"epss_score": 0.0005, "epss_percentile": 0.15971}, "CVE-2014-3048": {"epss_score": 0.00047, "epss_percentile": 0.14819}, "CVE-2014-3050": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2014-3051": {"epss_score": 0.00143, "epss_percentile": 0.35209}, "CVE-2014-3052": {"epss_score": 0.0008, "epss_percentile": 0.24141}, "CVE-2014-3053": {"epss_score": 0.00783, "epss_percentile": 0.73227}, "CVE-2014-3054": {"epss_score": 0.00312, "epss_percentile": 0.53959}, "CVE-2014-3055": {"epss_score": 0.00291, "epss_percentile": 0.52208}, "CVE-2014-3056": {"epss_score": 0.00321, "epss_percentile": 0.5474}, "CVE-2014-3057": {"epss_score": 0.00265, "epss_percentile": 0.49789}, "CVE-2014-3058": {"epss_score": 0.00101, "epss_percentile": 0.2871}, "CVE-2014-3059": {"epss_score": 0.02405, "epss_percentile": 0.84648}, "CVE-2014-3060": {"epss_score": 0.02405, "epss_percentile": 0.84648}, "CVE-2014-3061": {"epss_score": 0.00112, "epss_percentile": 0.30512}, "CVE-2014-3062": {"epss_score": 0.07348, "epss_percentile": 0.91424}, "CVE-2014-3063": {"epss_score": 0.00394, "epss_percentile": 0.59752}, "CVE-2014-3064": {"epss_score": 0.00246, "epss_percentile": 0.47782}, "CVE-2014-3065": {"epss_score": 0.00096, "epss_percentile": 0.27307}, "CVE-2014-3066": {"epss_score": 0.00917, "epss_percentile": 0.75428}, "CVE-2014-3068": {"epss_score": 0.00231, "epss_percentile": 0.45805}, "CVE-2014-3069": {"epss_score": 0.0016, "epss_percentile": 0.37441}, "CVE-2014-3070": {"epss_score": 0.00419, "epss_percentile": 0.6139}, "CVE-2014-3071": {"epss_score": 0.00321, "epss_percentile": 0.54651}, "CVE-2014-3072": {"epss_score": 0.00146, "epss_percentile": 0.35641}, "CVE-2014-3073": {"epss_score": 0.10239, "epss_percentile": 0.92907}, "CVE-2014-3074": {"epss_score": 0.00081, "epss_percentile": 0.24235}, "CVE-2014-3075": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-3076": {"epss_score": 0.00451, "epss_percentile": 0.63144}, "CVE-2014-3077": {"epss_score": 0.0005, "epss_percentile": 0.15971}, "CVE-2014-3079": {"epss_score": 0.00373, "epss_percentile": 0.58506}, "CVE-2014-3080": {"epss_score": 0.10108, "epss_percentile": 0.92853}, "CVE-2014-3081": {"epss_score": 0.09748, "epss_percentile": 0.9269}, "CVE-2014-3083": {"epss_score": 0.00321, "epss_percentile": 0.5474}, "CVE-2014-3084": {"epss_score": 0.00548, "epss_percentile": 0.67291}, "CVE-2014-3085": {"epss_score": 0.14283, "epss_percentile": 0.94178}, "CVE-2014-3086": {"epss_score": 0.03306, "epss_percentile": 0.86876}, "CVE-2014-3087": {"epss_score": 0.00291, "epss_percentile": 0.52158}, "CVE-2014-3088": {"epss_score": 0.00133, "epss_percentile": 0.33701}, "CVE-2014-3089": {"epss_score": 0.00049, "epss_percentile": 0.15504}, "CVE-2014-3090": {"epss_score": 0.00885, "epss_percentile": 0.74935}, "CVE-2014-3091": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2014-3092": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2014-3093": {"epss_score": 0.00054, "epss_percentile": 0.17362}, "CVE-2014-3094": {"epss_score": 0.10382, "epss_percentile": 0.92967}, "CVE-2014-3095": {"epss_score": 0.01298, "epss_percentile": 0.79273}, "CVE-2014-3096": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-3097": {"epss_score": 0.00672, "epss_percentile": 0.70823}, "CVE-2014-3099": {"epss_score": 0.00131, "epss_percentile": 0.33488}, "CVE-2014-3100": {"epss_score": 0.01042, "epss_percentile": 0.76973}, "CVE-2014-3101": {"epss_score": 0.00216, "epss_percentile": 0.44139}, "CVE-2014-3102": {"epss_score": 0.00162, "epss_percentile": 0.37634}, "CVE-2014-3103": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2014-3104": {"epss_score": 0.00572, "epss_percentile": 0.68003}, "CVE-2014-3105": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2014-3106": {"epss_score": 0.00258, "epss_percentile": 0.49026}, "CVE-2014-3110": {"epss_score": 0.0283, "epss_percentile": 0.85773}, "CVE-2014-3111": {"epss_score": 0.00257, "epss_percentile": 0.4889}, "CVE-2014-3113": {"epss_score": 0.12198, "epss_percentile": 0.93599}, "CVE-2014-3114": {"epss_score": 0.02751, "epss_percentile": 0.85581}, "CVE-2014-3115": {"epss_score": 0.00188, "epss_percentile": 0.4087}, "CVE-2014-3119": {"epss_score": 0.00302, "epss_percentile": 0.53102}, "CVE-2014-3120": {"epss_score": 0.85557, "epss_percentile": 0.99339}, "CVE-2014-3121": {"epss_score": 0.03336, "epss_percentile": 0.86935}, "CVE-2014-3122": {"epss_score": 0.00085, "epss_percentile": 0.25159}, "CVE-2014-3123": {"epss_score": 0.00245, "epss_percentile": 0.47637}, "CVE-2014-3124": {"epss_score": 0.00527, "epss_percentile": 0.66531}, "CVE-2014-3125": {"epss_score": 0.00305, "epss_percentile": 0.53384}, "CVE-2014-3127": {"epss_score": 0.00923, "epss_percentile": 0.75496}, "CVE-2014-3129": {"epss_score": 0.00693, "epss_percentile": 0.7132}, "CVE-2014-3130": {"epss_score": 0.00066, "epss_percentile": 0.20804}, "CVE-2014-3131": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2014-3132": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2014-3133": {"epss_score": 0.00354, "epss_percentile": 0.57213}, "CVE-2014-3134": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2014-3135": {"epss_score": 0.00443, "epss_percentile": 0.62801}, "CVE-2014-3136": {"epss_score": 0.00851, "epss_percentile": 0.74406}, "CVE-2014-3137": {"epss_score": 0.0094, "epss_percentile": 0.75742}, "CVE-2014-3138": {"epss_score": 0.03452, "epss_percentile": 0.87166}, "CVE-2014-3139": {"epss_score": 0.04285, "epss_percentile": 0.88492}, "CVE-2014-3144": {"epss_score": 0.00057, "epss_percentile": 0.18158}, "CVE-2014-3145": {"epss_score": 0.00057, "epss_percentile": 0.18158}, "CVE-2014-3146": {"epss_score": 0.04268, "epss_percentile": 0.88472}, "CVE-2014-3147": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2014-3148": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-3149": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2014-3150": {"epss_score": 0.00621, "epss_percentile": 0.69492}, "CVE-2014-3152": {"epss_score": 0.03199, "epss_percentile": 0.86617}, "CVE-2014-3153": {"epss_score": 0.75331, "epss_percentile": 0.98838}, "CVE-2014-3154": {"epss_score": 0.01922, "epss_percentile": 0.82904}, "CVE-2014-3155": {"epss_score": 0.02346, "epss_percentile": 0.84454}, "CVE-2014-3156": {"epss_score": 0.02664, "epss_percentile": 0.85374}, "CVE-2014-3157": {"epss_score": 0.02884, "epss_percentile": 0.85907}, "CVE-2014-3158": {"epss_score": 0.01484, "epss_percentile": 0.80592}, "CVE-2014-3159": {"epss_score": 0.00223, "epss_percentile": 0.44901}, "CVE-2014-3160": {"epss_score": 0.00571, "epss_percentile": 0.67977}, "CVE-2014-3161": {"epss_score": 0.00246, "epss_percentile": 0.47809}, "CVE-2014-3162": {"epss_score": 0.00373, "epss_percentile": 0.58495}, "CVE-2014-3164": {"epss_score": 0.00312, "epss_percentile": 0.5397}, "CVE-2014-3165": {"epss_score": 0.01375, "epss_percentile": 0.79831}, "CVE-2014-3166": {"epss_score": 0.01201, "epss_percentile": 0.78479}, "CVE-2014-3167": {"epss_score": 0.00546, "epss_percentile": 0.67211}, "CVE-2014-3168": {"epss_score": 0.02053, "epss_percentile": 0.83417}, "CVE-2014-3169": {"epss_score": 0.03248, "epss_percentile": 0.86746}, "CVE-2014-3170": {"epss_score": 0.00677, "epss_percentile": 0.70953}, "CVE-2014-3171": {"epss_score": 0.02346, "epss_percentile": 0.84454}, "CVE-2014-3172": {"epss_score": 0.0048, "epss_percentile": 0.64479}, "CVE-2014-3173": {"epss_score": 0.02166, "epss_percentile": 0.83851}, "CVE-2014-3174": {"epss_score": 0.02166, "epss_percentile": 0.83851}, "CVE-2014-3175": {"epss_score": 0.02031, "epss_percentile": 0.83334}, "CVE-2014-3176": {"epss_score": 0.23379, "epss_percentile": 0.95771}, "CVE-2014-3177": {"epss_score": 0.07757, "epss_percentile": 0.91661}, "CVE-2014-3178": {"epss_score": 0.01461, "epss_percentile": 0.80429}, "CVE-2014-3179": {"epss_score": 0.00509, "epss_percentile": 0.65731}, "CVE-2014-3180": {"epss_score": 0.00175, "epss_percentile": 0.39292}, "CVE-2014-3181": {"epss_score": 0.00126, "epss_percentile": 0.32679}, "CVE-2014-3182": {"epss_score": 0.00135, "epss_percentile": 0.34047}, "CVE-2014-3183": {"epss_score": 0.00165, "epss_percentile": 0.38083}, "CVE-2014-3184": {"epss_score": 0.00068, "epss_percentile": 0.21288}, "CVE-2014-3185": {"epss_score": 0.00102, "epss_percentile": 0.2884}, "CVE-2014-3186": {"epss_score": 0.00089, "epss_percentile": 0.25955}, "CVE-2014-3187": {"epss_score": 0.00478, "epss_percentile": 0.64403}, "CVE-2014-3188": {"epss_score": 0.03581, "epss_percentile": 0.87384}, "CVE-2014-3189": {"epss_score": 0.00832, "epss_percentile": 0.74075}, "CVE-2014-3190": {"epss_score": 0.00755, "epss_percentile": 0.72718}, "CVE-2014-3191": {"epss_score": 0.00755, "epss_percentile": 0.72718}, "CVE-2014-3192": {"epss_score": 0.017, "epss_percentile": 0.8183}, "CVE-2014-3193": {"epss_score": 0.00767, "epss_percentile": 0.72959}, "CVE-2014-3194": {"epss_score": 0.00558, "epss_percentile": 0.67583}, "CVE-2014-3195": {"epss_score": 0.00492, "epss_percentile": 0.64982}, "CVE-2014-3196": {"epss_score": 0.00228, "epss_percentile": 0.45494}, "CVE-2014-3197": {"epss_score": 0.00309, "epss_percentile": 0.53676}, "CVE-2014-3198": {"epss_score": 0.00832, "epss_percentile": 0.74075}, "CVE-2014-3199": {"epss_score": 0.00832, "epss_percentile": 0.74075}, "CVE-2014-3200": {"epss_score": 0.01968, "epss_percentile": 0.83086}, "CVE-2014-3201": {"epss_score": 0.00217, "epss_percentile": 0.44241}, "CVE-2014-3202": {"epss_score": 0.00078, "epss_percentile": 0.23607}, "CVE-2014-3203": {"epss_score": 0.00071, "epss_percentile": 0.22058}, "CVE-2014-3204": {"epss_score": 0.00077, "epss_percentile": 0.23322}, "CVE-2014-3205": {"epss_score": 0.00852, "epss_percentile": 0.74415}, "CVE-2014-3206": {"epss_score": 0.9179, "epss_percentile": 0.99668}, "CVE-2014-3207": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2014-3208": {"epss_score": 0.00574, "epss_percentile": 0.68076}, "CVE-2014-3209": {"epss_score": 0.00154, "epss_percentile": 0.36694}, "CVE-2014-3210": {"epss_score": 0.02526, "epss_percentile": 0.85014}, "CVE-2014-3211": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2014-3214": {"epss_score": 0.11256, "epss_percentile": 0.9328}, "CVE-2014-3215": {"epss_score": 0.0007, "epss_percentile": 0.21828}, "CVE-2014-3216": {"epss_score": 0.07539, "epss_percentile": 0.91525}, "CVE-2014-3219": {"epss_score": 0.00035, "epss_percentile": 0.09917}, "CVE-2014-3220": {"epss_score": 0.31853, "epss_percentile": 0.96655}, "CVE-2014-3221": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2014-3222": {"epss_score": 0.00259, "epss_percentile": 0.49096}, "CVE-2014-3223": {"epss_score": 0.00181, "epss_percentile": 0.40092}, "CVE-2014-3224": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2014-3225": {"epss_score": 0.06113, "epss_percentile": 0.90489}, "CVE-2014-3227": {"epss_score": 0.00618, "epss_percentile": 0.69376}, "CVE-2014-3230": {"epss_score": 0.00192, "epss_percentile": 0.41289}, "CVE-2014-3242": {"epss_score": 0.005, "epss_percentile": 0.65331}, "CVE-2014-3243": {"epss_score": 0.00755, "epss_percentile": 0.72718}, "CVE-2014-3244": {"epss_score": 0.06511, "epss_percentile": 0.90811}, "CVE-2014-3246": {"epss_score": 0.00601, "epss_percentile": 0.6885}, "CVE-2014-3247": {"epss_score": 0.00683, "epss_percentile": 0.71093}, "CVE-2014-3248": {"epss_score": 0.00164, "epss_percentile": 0.37867}, "CVE-2014-3249": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-3250": {"epss_score": 0.00259, "epss_percentile": 0.49028}, "CVE-2014-3251": {"epss_score": 0.00027, "epss_percentile": 0.06825}, "CVE-2014-3260": {"epss_score": 0.0028, "epss_percentile": 0.51018}, "CVE-2014-3261": {"epss_score": 0.0082, "epss_percentile": 0.73884}, "CVE-2014-3262": {"epss_score": 0.00643, "epss_percentile": 0.70046}, "CVE-2014-3263": {"epss_score": 0.00773, "epss_percentile": 0.73054}, "CVE-2014-3264": {"epss_score": 0.00296, "epss_percentile": 0.52539}, "CVE-2014-3265": {"epss_score": 0.0043, "epss_percentile": 0.62031}, "CVE-2014-3266": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2014-3267": {"epss_score": 0.00128, "epss_percentile": 0.33025}, "CVE-2014-3268": {"epss_score": 0.00412, "epss_percentile": 0.60947}, "CVE-2014-3269": {"epss_score": 0.00316, "epss_percentile": 0.54276}, "CVE-2014-3270": {"epss_score": 0.0098, "epss_percentile": 0.76275}, "CVE-2014-3271": {"epss_score": 0.0098, "epss_percentile": 0.76275}, "CVE-2014-3272": {"epss_score": 0.00123, "epss_percentile": 0.32302}, "CVE-2014-3273": {"epss_score": 0.00349, "epss_percentile": 0.56915}, "CVE-2014-3274": {"epss_score": 0.00382, "epss_percentile": 0.59034}, "CVE-2014-3275": {"epss_score": 0.00279, "epss_percentile": 0.50959}, "CVE-2014-3276": {"epss_score": 0.00585, "epss_percentile": 0.68406}, "CVE-2014-3277": {"epss_score": 0.0036, "epss_percentile": 0.57663}, "CVE-2014-3278": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2014-3279": {"epss_score": 0.00677, "epss_percentile": 0.70962}, "CVE-2014-3280": {"epss_score": 0.00391, "epss_percentile": 0.59592}, "CVE-2014-3281": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2014-3282": {"epss_score": 0.00391, "epss_percentile": 0.59592}, "CVE-2014-3283": {"epss_score": 0.00554, "epss_percentile": 0.67446}, "CVE-2014-3284": {"epss_score": 0.00629, "epss_percentile": 0.69678}, "CVE-2014-3285": {"epss_score": 0.01141, "epss_percentile": 0.77955}, "CVE-2014-3286": {"epss_score": 0.00348, "epss_percentile": 0.56833}, "CVE-2014-3287": {"epss_score": 0.00242, "epss_percentile": 0.4735}, "CVE-2014-3289": {"epss_score": 0.0066, "epss_percentile": 0.70526}, "CVE-2014-3290": {"epss_score": 0.0056, "epss_percentile": 0.67655}, "CVE-2014-3291": {"epss_score": 0.00502, "epss_percentile": 0.65391}, "CVE-2014-3292": {"epss_score": 0.00959, "epss_percentile": 0.75951}, "CVE-2014-3293": {"epss_score": 0.01389, "epss_percentile": 0.79929}, "CVE-2014-3294": {"epss_score": 0.00279, "epss_percentile": 0.50991}, "CVE-2014-3295": {"epss_score": 0.01123, "epss_percentile": 0.77791}, "CVE-2014-3296": {"epss_score": 0.00277, "epss_percentile": 0.50791}, "CVE-2014-3297": {"epss_score": 0.0044, "epss_percentile": 0.62633}, "CVE-2014-3298": {"epss_score": 0.00306, "epss_percentile": 0.53452}, "CVE-2014-3299": {"epss_score": 0.00952, "epss_percentile": 0.75883}, "CVE-2014-3300": {"epss_score": 0.45577, "epss_percentile": 0.97491}, "CVE-2014-3301": {"epss_score": 0.00607, "epss_percentile": 0.69045}, "CVE-2014-3302": {"epss_score": 0.00302, "epss_percentile": 0.53133}, "CVE-2014-3303": {"epss_score": 0.00384, "epss_percentile": 0.59157}, "CVE-2014-3304": {"epss_score": 0.00483, "epss_percentile": 0.64612}, "CVE-2014-3305": {"epss_score": 0.0019, "epss_percentile": 0.41064}, "CVE-2014-3306": {"epss_score": 0.10468, "epss_percentile": 0.92996}, "CVE-2014-3307": {"epss_score": 0.00242, "epss_percentile": 0.47337}, "CVE-2014-3308": {"epss_score": 0.01418, "epss_percentile": 0.80157}, "CVE-2014-3309": {"epss_score": 0.0021, "epss_percentile": 0.43465}, "CVE-2014-3310": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2014-3311": {"epss_score": 0.03061, "epss_percentile": 0.86309}, "CVE-2014-3312": {"epss_score": 0.00052, "epss_percentile": 0.16451}, "CVE-2014-3313": {"epss_score": 0.00499, "epss_percentile": 0.65274}, "CVE-2014-3314": {"epss_score": 0.00354, "epss_percentile": 0.57224}, "CVE-2014-3315": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2014-3316": {"epss_score": 0.00511, "epss_percentile": 0.65831}, "CVE-2014-3317": {"epss_score": 0.02717, "epss_percentile": 0.8551}, "CVE-2014-3318": {"epss_score": 0.00504, "epss_percentile": 0.6554}, "CVE-2014-3319": {"epss_score": 0.0049, "epss_percentile": 0.64923}, "CVE-2014-3320": {"epss_score": 0.00528, "epss_percentile": 0.66557}, "CVE-2014-3321": {"epss_score": 0.00443, "epss_percentile": 0.6276}, "CVE-2014-3322": {"epss_score": 0.00629, "epss_percentile": 0.69678}, "CVE-2014-3323": {"epss_score": 0.00177, "epss_percentile": 0.39499}, "CVE-2014-3324": {"epss_score": 0.00561, "epss_percentile": 0.67676}, "CVE-2014-3325": {"epss_score": 0.00397, "epss_percentile": 0.5995}, "CVE-2014-3326": {"epss_score": 0.00563, "epss_percentile": 0.67711}, "CVE-2014-3327": {"epss_score": 0.01451, "epss_percentile": 0.80363}, "CVE-2014-3328": {"epss_score": 0.01036, "epss_percentile": 0.76919}, "CVE-2014-3329": {"epss_score": 0.00408, "epss_percentile": 0.60675}, "CVE-2014-3330": {"epss_score": 0.00179, "epss_percentile": 0.3978}, "CVE-2014-3331": {"epss_score": 0.00299, "epss_percentile": 0.52856}, "CVE-2014-3332": {"epss_score": 0.00353, "epss_percentile": 0.57169}, "CVE-2014-3333": {"epss_score": 0.01832, "epss_percentile": 0.82453}, "CVE-2014-3335": {"epss_score": 0.00687, "epss_percentile": 0.71178}, "CVE-2014-3336": {"epss_score": 0.00732, "epss_percentile": 0.7219}, "CVE-2014-3337": {"epss_score": 0.02122, "epss_percentile": 0.83682}, "CVE-2014-3338": {"epss_score": 0.0184, "epss_percentile": 0.82491}, "CVE-2014-3339": {"epss_score": 0.00378, "epss_percentile": 0.58779}, "CVE-2014-3340": {"epss_score": 0.00332, "epss_percentile": 0.55563}, "CVE-2014-3341": {"epss_score": 0.24387, "epss_percentile": 0.95916}, "CVE-2014-3342": {"epss_score": 0.00238, "epss_percentile": 0.46741}, "CVE-2014-3343": {"epss_score": 0.01284, "epss_percentile": 0.79168}, "CVE-2014-3344": {"epss_score": 0.00499, "epss_percentile": 0.65274}, "CVE-2014-3345": {"epss_score": 0.00677, "epss_percentile": 0.70962}, "CVE-2014-3346": {"epss_score": 0.00568, "epss_percentile": 0.67883}, "CVE-2014-3347": {"epss_score": 0.00458, "epss_percentile": 0.63443}, "CVE-2014-3348": {"epss_score": 0.01558, "epss_percentile": 0.81028}, "CVE-2014-3349": {"epss_score": 0.00265, "epss_percentile": 0.49833}, "CVE-2014-3350": {"epss_score": 0.00273, "epss_percentile": 0.5048}, "CVE-2014-3351": {"epss_score": 0.00272, "epss_percentile": 0.50351}, "CVE-2014-3352": {"epss_score": 0.01049, "epss_percentile": 0.77059}, "CVE-2014-3353": {"epss_score": 0.02529, "epss_percentile": 0.85021}, "CVE-2014-3354": {"epss_score": 0.02496, "epss_percentile": 0.84909}, "CVE-2014-3355": {"epss_score": 0.01092, "epss_percentile": 0.77466}, "CVE-2014-3356": {"epss_score": 0.0191, "epss_percentile": 0.82825}, "CVE-2014-3357": {"epss_score": 0.00898, "epss_percentile": 0.75145}, "CVE-2014-3358": {"epss_score": 0.00898, "epss_percentile": 0.75145}, "CVE-2014-3359": {"epss_score": 0.01092, "epss_percentile": 0.77466}, "CVE-2014-3360": {"epss_score": 0.0191, "epss_percentile": 0.82825}, "CVE-2014-3361": {"epss_score": 0.01022, "epss_percentile": 0.76759}, "CVE-2014-3362": {"epss_score": 0.00773, "epss_percentile": 0.73061}, "CVE-2014-3363": {"epss_score": 0.00324, "epss_percentile": 0.54954}, "CVE-2014-3364": {"epss_score": 0.00279, "epss_percentile": 0.50988}, "CVE-2014-3365": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2014-3366": {"epss_score": 0.00279, "epss_percentile": 0.50959}, "CVE-2014-3367": {"epss_score": 0.0034, "epss_percentile": 0.56236}, "CVE-2014-3368": {"epss_score": 0.00531, "epss_percentile": 0.66642}, "CVE-2014-3369": {"epss_score": 0.00724, "epss_percentile": 0.7203}, "CVE-2014-3370": {"epss_score": 0.00724, "epss_percentile": 0.7203}, "CVE-2014-3372": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2014-3373": {"epss_score": 0.00499, "epss_percentile": 0.65274}, "CVE-2014-3374": {"epss_score": 0.00499, "epss_percentile": 0.65274}, "CVE-2014-3375": {"epss_score": 0.00532, "epss_percentile": 0.667}, "CVE-2014-3376": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2014-3377": {"epss_score": 0.01015, "epss_percentile": 0.76658}, "CVE-2014-3378": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2014-3379": {"epss_score": 0.00995, "epss_percentile": 0.7643}, "CVE-2014-3380": {"epss_score": 0.00499, "epss_percentile": 0.65256}, "CVE-2014-3381": {"epss_score": 0.0016, "epss_percentile": 0.37452}, "CVE-2014-3382": {"epss_score": 0.00529, "epss_percentile": 0.66604}, "CVE-2014-3383": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-3384": {"epss_score": 0.0023, "epss_percentile": 0.45714}, "CVE-2014-3385": {"epss_score": 0.0033, "epss_percentile": 0.55497}, "CVE-2014-3386": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-3387": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-3388": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2014-3389": {"epss_score": 0.00212, "epss_percentile": 0.43748}, "CVE-2014-3390": {"epss_score": 0.00324, "epss_percentile": 0.54963}, "CVE-2014-3391": {"epss_score": 0.00095, "epss_percentile": 0.27103}, "CVE-2014-3392": {"epss_score": 0.00489, "epss_percentile": 0.64895}, "CVE-2014-3393": {"epss_score": 0.00785, "epss_percentile": 0.73257}, "CVE-2014-3394": {"epss_score": 0.00091, "epss_percentile": 0.26235}, "CVE-2014-3395": {"epss_score": 0.00218, "epss_percentile": 0.44355}, "CVE-2014-3396": {"epss_score": 0.00322, "epss_percentile": 0.54803}, "CVE-2014-3397": {"epss_score": 0.06219, "epss_percentile": 0.90577}, "CVE-2014-3398": {"epss_score": 0.009, "epss_percentile": 0.75159}, "CVE-2014-3399": {"epss_score": 0.00115, "epss_percentile": 0.31031}, "CVE-2014-3400": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2014-3402": {"epss_score": 0.00474, "epss_percentile": 0.64156}, "CVE-2014-3403": {"epss_score": 0.00131, "epss_percentile": 0.33349}, "CVE-2014-3404": {"epss_score": 0.00131, "epss_percentile": 0.33349}, "CVE-2014-3405": {"epss_score": 0.00196, "epss_percentile": 0.41772}, "CVE-2014-3406": {"epss_score": 0.00269, "epss_percentile": 0.50154}, "CVE-2014-3407": {"epss_score": 0.00381, "epss_percentile": 0.59002}, "CVE-2014-3408": {"epss_score": 0.00555, "epss_percentile": 0.67468}, "CVE-2014-3409": {"epss_score": 0.01488, "epss_percentile": 0.80614}, "CVE-2014-3410": {"epss_score": 0.00375, "epss_percentile": 0.58619}, "CVE-2014-3411": {"epss_score": 0.06728, "epss_percentile": 0.90972}, "CVE-2014-3412": {"epss_score": 0.01935, "epss_percentile": 0.82957}, "CVE-2014-3413": {"epss_score": 0.01657, "epss_percentile": 0.81603}, "CVE-2014-3414": {"epss_score": 0.00202, "epss_percentile": 0.4246}, "CVE-2014-3415": {"epss_score": 0.00804, "epss_percentile": 0.73613}, "CVE-2014-3416": {"epss_score": 0.00296, "epss_percentile": 0.52626}, "CVE-2014-3417": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2014-3418": {"epss_score": 0.23677, "epss_percentile": 0.95802}, "CVE-2014-3419": {"epss_score": 0.00066, "epss_percentile": 0.20893}, "CVE-2014-3421": {"epss_score": 0.00138, "epss_percentile": 0.34525}, "CVE-2014-3422": {"epss_score": 0.00138, "epss_percentile": 0.34525}, "CVE-2014-3423": {"epss_score": 0.00138, "epss_percentile": 0.34525}, "CVE-2014-3424": {"epss_score": 0.00138, "epss_percentile": 0.34525}, "CVE-2014-3425": {"epss_score": 0.00053, "epss_percentile": 0.16908}, "CVE-2014-3426": {"epss_score": 0.00053, "epss_percentile": 0.16908}, "CVE-2014-3427": {"epss_score": 0.03758, "epss_percentile": 0.87684}, "CVE-2014-3428": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-3429": {"epss_score": 0.02089, "epss_percentile": 0.83559}, "CVE-2014-3430": {"epss_score": 0.08347, "epss_percentile": 0.92003}, "CVE-2014-3431": {"epss_score": 0.00037, "epss_percentile": 0.10895}, "CVE-2014-3432": {"epss_score": 0.00606, "epss_percentile": 0.69004}, "CVE-2014-3433": {"epss_score": 0.00449, "epss_percentile": 0.63044}, "CVE-2014-3434": {"epss_score": 0.00828, "epss_percentile": 0.73997}, "CVE-2014-3436": {"epss_score": 0.00405, "epss_percentile": 0.60462}, "CVE-2014-3437": {"epss_score": 0.22282, "epss_percentile": 0.95618}, "CVE-2014-3438": {"epss_score": 0.16177, "epss_percentile": 0.94588}, "CVE-2014-3439": {"epss_score": 0.12381, "epss_percentile": 0.93655}, "CVE-2014-3440": {"epss_score": 0.00842, "epss_percentile": 0.74244}, "CVE-2014-3441": {"epss_score": 0.07967, "epss_percentile": 0.91796}, "CVE-2014-3442": {"epss_score": 0.10832, "epss_percentile": 0.93127}, "CVE-2014-3443": {"epss_score": 0.07967, "epss_percentile": 0.91796}, "CVE-2014-3444": {"epss_score": 0.27261, "epss_percentile": 0.96229}, "CVE-2014-3445": {"epss_score": 0.04393, "epss_percentile": 0.88636}, "CVE-2014-3446": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2014-3447": {"epss_score": 0.00988, "epss_percentile": 0.76358}, "CVE-2014-3448": {"epss_score": 0.04136, "epss_percentile": 0.88307}, "CVE-2014-3449": {"epss_score": 0.01437, "epss_percentile": 0.8028}, "CVE-2014-3450": {"epss_score": 0.00043, "epss_percentile": 0.13061}, "CVE-2014-3451": {"epss_score": 0.01328, "epss_percentile": 0.79497}, "CVE-2014-3452": {"epss_score": 0.00691, "epss_percentile": 0.71274}, "CVE-2014-3453": {"epss_score": 0.0046, "epss_percentile": 0.63533}, "CVE-2014-3454": {"epss_score": 0.00157, "epss_percentile": 0.37076}, "CVE-2014-3455": {"epss_score": 0.00108, "epss_percentile": 0.29801}, "CVE-2014-3456": {"epss_score": 0.0008, "epss_percentile": 0.24106}, "CVE-2014-3459": {"epss_score": 0.04551, "epss_percentile": 0.8884}, "CVE-2014-3460": {"epss_score": 0.01432, "epss_percentile": 0.80252}, "CVE-2014-3461": {"epss_score": 0.03335, "epss_percentile": 0.86934}, "CVE-2014-3462": {"epss_score": 0.01089, "epss_percentile": 0.77443}, "CVE-2014-3464": {"epss_score": 0.0019, "epss_percentile": 0.4108}, "CVE-2014-3465": {"epss_score": 0.0063, "epss_percentile": 0.697}, "CVE-2014-3466": {"epss_score": 0.17554, "epss_percentile": 0.94866}, "CVE-2014-3467": {"epss_score": 0.0889, "epss_percentile": 0.92303}, "CVE-2014-3468": {"epss_score": 0.10744, "epss_percentile": 0.93089}, "CVE-2014-3469": {"epss_score": 0.08667, "epss_percentile": 0.92181}, "CVE-2014-3470": {"epss_score": 0.91264, "epss_percentile": 0.9963}, "CVE-2014-3471": {"epss_score": 0.00089, "epss_percentile": 0.25882}, "CVE-2014-3472": {"epss_score": 0.00241, "epss_percentile": 0.47244}, "CVE-2014-3473": {"epss_score": 0.004, "epss_percentile": 0.60168}, "CVE-2014-3474": {"epss_score": 0.00303, "epss_percentile": 0.53218}, "CVE-2014-3475": {"epss_score": 0.00359, "epss_percentile": 0.57613}, "CVE-2014-3476": {"epss_score": 0.00721, "epss_percentile": 0.71984}, "CVE-2014-3477": {"epss_score": 0.00097, "epss_percentile": 0.27506}, "CVE-2014-3478": {"epss_score": 0.25344, "epss_percentile": 0.96017}, "CVE-2014-3479": {"epss_score": 0.10357, "epss_percentile": 0.92958}, "CVE-2014-3480": {"epss_score": 0.06258, "epss_percentile": 0.90619}, "CVE-2014-3481": {"epss_score": 0.01093, "epss_percentile": 0.77479}, "CVE-2014-3482": {"epss_score": 0.01531, "epss_percentile": 0.8089}, "CVE-2014-3483": {"epss_score": 0.0125, "epss_percentile": 0.78883}, "CVE-2014-3484": {"epss_score": 0.01794, "epss_percentile": 0.82291}, "CVE-2014-3485": {"epss_score": 0.00267, "epss_percentile": 0.49961}, "CVE-2014-3486": {"epss_score": 0.00176, "epss_percentile": 0.3944}, "CVE-2014-3487": {"epss_score": 0.19441, "epss_percentile": 0.95181}, "CVE-2014-3488": {"epss_score": 0.00867, "epss_percentile": 0.74649}, "CVE-2014-3489": {"epss_score": 0.00403, "epss_percentile": 0.60333}, "CVE-2014-3490": {"epss_score": 0.04646, "epss_percentile": 0.8896}, "CVE-2014-3491": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2014-3492": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2014-3493": {"epss_score": 0.02413, "epss_percentile": 0.84677}, "CVE-2014-3494": {"epss_score": 0.0018, "epss_percentile": 0.39899}, "CVE-2014-3495": {"epss_score": 0.00284, "epss_percentile": 0.51436}, "CVE-2014-3496": {"epss_score": 0.05407, "epss_percentile": 0.8984}, "CVE-2014-3497": {"epss_score": 0.00445, "epss_percentile": 0.62863}, "CVE-2014-3498": {"epss_score": 0.00548, "epss_percentile": 0.67271}, "CVE-2014-3499": {"epss_score": 0.00034, "epss_percentile": 0.09799}, "CVE-2014-3500": {"epss_score": 0.01245, "epss_percentile": 0.7884}, "CVE-2014-3501": {"epss_score": 0.01651, "epss_percentile": 0.8157}, "CVE-2014-3502": {"epss_score": 0.01489, "epss_percentile": 0.80622}, "CVE-2014-3503": {"epss_score": 0.01942, "epss_percentile": 0.82984}, "CVE-2014-3504": {"epss_score": 0.02097, "epss_percentile": 0.83589}, "CVE-2014-3505": {"epss_score": 0.47189, "epss_percentile": 0.97574}, "CVE-2014-3506": {"epss_score": 0.45674, "epss_percentile": 0.97496}, "CVE-2014-3507": {"epss_score": 0.66025, "epss_percentile": 0.98448}, "CVE-2014-3508": {"epss_score": 0.02958, "epss_percentile": 0.86065}, "CVE-2014-3509": {"epss_score": 0.1158, "epss_percentile": 0.9341}, "CVE-2014-3510": {"epss_score": 0.13682, "epss_percentile": 0.94033}, "CVE-2014-3511": {"epss_score": 0.05418, "epss_percentile": 0.89853}, "CVE-2014-3512": {"epss_score": 0.74883, "epss_percentile": 0.98822}, "CVE-2014-3513": {"epss_score": 0.32183, "epss_percentile": 0.96676}, "CVE-2014-3514": {"epss_score": 0.00331, "epss_percentile": 0.55535}, "CVE-2014-3515": {"epss_score": 0.60788, "epss_percentile": 0.98221}, "CVE-2014-3517": {"epss_score": 0.00398, "epss_percentile": 0.60091}, "CVE-2014-3518": {"epss_score": 0.01658, "epss_percentile": 0.81611}, "CVE-2014-3519": {"epss_score": 0.00088, "epss_percentile": 0.25704}, "CVE-2014-3520": {"epss_score": 0.00428, "epss_percentile": 0.6192}, "CVE-2014-3521": {"epss_score": 0.00152, "epss_percentile": 0.36385}, "CVE-2014-3522": {"epss_score": 0.02619, "epss_percentile": 0.85252}, "CVE-2014-3523": {"epss_score": 0.35235, "epss_percentile": 0.96895}, "CVE-2014-3524": {"epss_score": 0.12318, "epss_percentile": 0.9364}, "CVE-2014-3525": {"epss_score": 0.0127, "epss_percentile": 0.79045}, "CVE-2014-3526": {"epss_score": 0.00499, "epss_percentile": 0.65287}, "CVE-2014-3527": {"epss_score": 0.00359, "epss_percentile": 0.57546}, "CVE-2014-3528": {"epss_score": 0.03375, "epss_percentile": 0.87018}, "CVE-2014-3529": {"epss_score": 0.04546, "epss_percentile": 0.88834}, "CVE-2014-3530": {"epss_score": 0.02552, "epss_percentile": 0.85078}, "CVE-2014-3531": {"epss_score": 0.00277, "epss_percentile": 0.50823}, "CVE-2014-3532": {"epss_score": 0.00123, "epss_percentile": 0.32203}, "CVE-2014-3533": {"epss_score": 0.00089, "epss_percentile": 0.25951}, "CVE-2014-3534": {"epss_score": 0.00074, "epss_percentile": 0.22702}, "CVE-2014-3535": {"epss_score": 0.00821, "epss_percentile": 0.73894}, "CVE-2014-3536": {"epss_score": 0.00104, "epss_percentile": 0.29225}, "CVE-2014-3537": {"epss_score": 0.00053, "epss_percentile": 0.16933}, "CVE-2014-3538": {"epss_score": 0.20297, "epss_percentile": 0.95316}, "CVE-2014-3539": {"epss_score": 0.01983, "epss_percentile": 0.83148}, "CVE-2014-3541": {"epss_score": 0.01935, "epss_percentile": 0.8296}, "CVE-2014-3542": {"epss_score": 0.00427, "epss_percentile": 0.61914}, "CVE-2014-3543": {"epss_score": 0.00427, "epss_percentile": 0.61914}, "CVE-2014-3544": {"epss_score": 0.00956, "epss_percentile": 0.75927}, "CVE-2014-3545": {"epss_score": 0.01284, "epss_percentile": 0.7917}, "CVE-2014-3546": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2014-3547": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-3548": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-3549": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-3550": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-3551": {"epss_score": 0.00251, "epss_percentile": 0.48259}, "CVE-2014-3552": {"epss_score": 0.00353, "epss_percentile": 0.57192}, "CVE-2014-3553": {"epss_score": 0.00171, "epss_percentile": 0.38872}, "CVE-2014-3554": {"epss_score": 0.00631, "epss_percentile": 0.69711}, "CVE-2014-3555": {"epss_score": 0.00875, "epss_percentile": 0.74783}, "CVE-2014-3556": {"epss_score": 0.48169, "epss_percentile": 0.97624}, "CVE-2014-3558": {"epss_score": 0.00932, "epss_percentile": 0.75628}, "CVE-2014-3559": {"epss_score": 0.00273, "epss_percentile": 0.5048}, "CVE-2014-3560": {"epss_score": 0.74282, "epss_percentile": 0.98794}, "CVE-2014-3561": {"epss_score": 0.00061, "epss_percentile": 0.19284}, "CVE-2014-3562": {"epss_score": 0.00307, "epss_percentile": 0.53474}, "CVE-2014-3563": {"epss_score": 0.0014, "epss_percentile": 0.34786}, "CVE-2014-3564": {"epss_score": 0.0281, "epss_percentile": 0.85718}, "CVE-2014-3565": {"epss_score": 0.08758, "epss_percentile": 0.92243}, "CVE-2014-3566": {"epss_score": 0.93732, "epss_percentile": 0.99838}, "CVE-2014-3567": {"epss_score": 0.25261, "epss_percentile": 0.96005}, "CVE-2014-3568": {"epss_score": 0.03256, "epss_percentile": 0.86764}, "CVE-2014-3569": {"epss_score": 0.11389, "epss_percentile": 0.9333}, "CVE-2014-3570": {"epss_score": 0.06835, "epss_percentile": 0.91057}, "CVE-2014-3571": {"epss_score": 0.17352, "epss_percentile": 0.94833}, "CVE-2014-3572": {"epss_score": 0.06803, "epss_percentile": 0.91036}, "CVE-2014-3573": {"epss_score": 0.00457, "epss_percentile": 0.63366}, "CVE-2014-3574": {"epss_score": 0.11114, "epss_percentile": 0.93226}, "CVE-2014-3575": {"epss_score": 0.09871, "epss_percentile": 0.92746}, "CVE-2014-3576": {"epss_score": 0.11345, "epss_percentile": 0.93317}, "CVE-2014-3577": {"epss_score": 0.01367, "epss_percentile": 0.79784}, "CVE-2014-3578": {"epss_score": 0.04382, "epss_percentile": 0.88626}, "CVE-2014-3579": {"epss_score": 0.0348, "epss_percentile": 0.87218}, "CVE-2014-3580": {"epss_score": 0.13653, "epss_percentile": 0.94022}, "CVE-2014-3581": {"epss_score": 0.03873, "epss_percentile": 0.87884}, "CVE-2014-3582": {"epss_score": 0.00335, "epss_percentile": 0.55837}, "CVE-2014-3583": {"epss_score": 0.19785, "epss_percentile": 0.9524}, "CVE-2014-3584": {"epss_score": 0.05595, "epss_percentile": 0.90033}, "CVE-2014-3585": {"epss_score": 0.00277, "epss_percentile": 0.50784}, "CVE-2014-3586": {"epss_score": 0.0008, "epss_percentile": 0.24022}, "CVE-2014-3587": {"epss_score": 0.19121, "epss_percentile": 0.95133}, "CVE-2014-3589": {"epss_score": 0.00842, "epss_percentile": 0.74237}, "CVE-2014-3590": {"epss_score": 0.00242, "epss_percentile": 0.47368}, "CVE-2014-3591": {"epss_score": 0.00141, "epss_percentile": 0.3495}, "CVE-2014-3592": {"epss_score": 0.00341, "epss_percentile": 0.56288}, "CVE-2014-3593": {"epss_score": 0.00295, "epss_percentile": 0.52505}, "CVE-2014-3594": {"epss_score": 0.00605, "epss_percentile": 0.68978}, "CVE-2014-3595": {"epss_score": 0.00302, "epss_percentile": 0.53104}, "CVE-2014-3596": {"epss_score": 0.01182, "epss_percentile": 0.78313}, "CVE-2014-3597": {"epss_score": 0.05571, "epss_percentile": 0.90007}, "CVE-2014-3598": {"epss_score": 0.00403, "epss_percentile": 0.60328}, "CVE-2014-3599": {"epss_score": 0.00384, "epss_percentile": 0.59128}, "CVE-2014-3600": {"epss_score": 0.00511, "epss_percentile": 0.65845}, "CVE-2014-3601": {"epss_score": 0.00368, "epss_percentile": 0.58183}, "CVE-2014-3602": {"epss_score": 0.00114, "epss_percentile": 0.30836}, "CVE-2014-3603": {"epss_score": 0.0011, "epss_percentile": 0.30174}, "CVE-2014-3604": {"epss_score": 0.00205, "epss_percentile": 0.42753}, "CVE-2014-3607": {"epss_score": 0.00211, "epss_percentile": 0.43681}, "CVE-2014-3608": {"epss_score": 0.00689, "epss_percentile": 0.71214}, "CVE-2014-3609": {"epss_score": 0.8285, "epss_percentile": 0.99219}, "CVE-2014-3610": {"epss_score": 0.0005, "epss_percentile": 0.15927}, "CVE-2014-3611": {"epss_score": 0.00041, "epss_percentile": 0.12261}, "CVE-2014-3612": {"epss_score": 0.00874, "epss_percentile": 0.74768}, "CVE-2014-3613": {"epss_score": 0.0182, "epss_percentile": 0.82407}, "CVE-2014-3614": {"epss_score": 9e-05, "epss_percentile": 0.00639}, "CVE-2014-3615": {"epss_score": 0.00092, "epss_percentile": 0.26425}, "CVE-2014-3616": {"epss_score": 0.02435, "epss_percentile": 0.84736}, "CVE-2014-3617": {"epss_score": 0.00176, "epss_percentile": 0.39487}, "CVE-2014-3618": {"epss_score": 0.0982, "epss_percentile": 0.92717}, "CVE-2014-3619": {"epss_score": 0.01113, "epss_percentile": 0.77689}, "CVE-2014-3620": {"epss_score": 0.01306, "epss_percentile": 0.79334}, "CVE-2014-3621": {"epss_score": 0.00426, "epss_percentile": 0.61762}, "CVE-2014-3622": {"epss_score": 0.01951, "epss_percentile": 0.83019}, "CVE-2014-3623": {"epss_score": 0.0249, "epss_percentile": 0.84894}, "CVE-2014-3624": {"epss_score": 0.00387, "epss_percentile": 0.59336}, "CVE-2014-3625": {"epss_score": 0.18932, "epss_percentile": 0.95099}, "CVE-2014-3626": {"epss_score": 0.00979, "epss_percentile": 0.76262}, "CVE-2014-3627": {"epss_score": 0.01616, "epss_percentile": 0.81358}, "CVE-2014-3628": {"epss_score": 0.01918, "epss_percentile": 0.82881}, "CVE-2014-3629": {"epss_score": 0.01744, "epss_percentile": 0.82063}, "CVE-2014-3630": {"epss_score": 0.00708, "epss_percentile": 0.71677}, "CVE-2014-3631": {"epss_score": 0.00364, "epss_percentile": 0.57926}, "CVE-2014-3632": {"epss_score": 0.0122, "epss_percentile": 0.78623}, "CVE-2014-3633": {"epss_score": 0.0292, "epss_percentile": 0.8599}, "CVE-2014-3634": {"epss_score": 0.29383, "epss_percentile": 0.96438}, "CVE-2014-3635": {"epss_score": 0.00173, "epss_percentile": 0.39072}, "CVE-2014-3636": {"epss_score": 0.00096, "epss_percentile": 0.27414}, "CVE-2014-3637": {"epss_score": 0.00051, "epss_percentile": 0.16261}, "CVE-2014-3638": {"epss_score": 0.00098, "epss_percentile": 0.27799}, "CVE-2014-3639": {"epss_score": 0.00101, "epss_percentile": 0.2859}, "CVE-2014-3640": {"epss_score": 0.0005, "epss_percentile": 0.15973}, "CVE-2014-3641": {"epss_score": 0.00331, "epss_percentile": 0.55511}, "CVE-2014-3642": {"epss_score": 0.00385, "epss_percentile": 0.59197}, "CVE-2014-3643": {"epss_score": 0.00258, "epss_percentile": 0.48979}, "CVE-2014-3645": {"epss_score": 0.00092, "epss_percentile": 0.26529}, "CVE-2014-3646": {"epss_score": 0.001, "epss_percentile": 0.28431}, "CVE-2014-3647": {"epss_score": 0.00058, "epss_percentile": 0.18424}, "CVE-2014-3648": {"epss_score": 0.00325, "epss_percentile": 0.55034}, "CVE-2014-3649": {"epss_score": 0.00341, "epss_percentile": 0.56288}, "CVE-2014-3650": {"epss_score": 0.00156, "epss_percentile": 0.36999}, "CVE-2014-3651": {"epss_score": 0.00802, "epss_percentile": 0.7359}, "CVE-2014-3652": {"epss_score": 0.00219, "epss_percentile": 0.44513}, "CVE-2014-3653": {"epss_score": 0.00389, "epss_percentile": 0.59486}, "CVE-2014-3654": {"epss_score": 0.00302, "epss_percentile": 0.53104}, "CVE-2014-3655": {"epss_score": 0.00183, "epss_percentile": 0.40352}, "CVE-2014-3656": {"epss_score": 0.00341, "epss_percentile": 0.56288}, "CVE-2014-3657": {"epss_score": 0.01284, "epss_percentile": 0.79167}, "CVE-2014-3660": {"epss_score": 0.04342, "epss_percentile": 0.88571}, "CVE-2014-3661": {"epss_score": 0.00157, "epss_percentile": 0.37084}, "CVE-2014-3662": {"epss_score": 0.00107, "epss_percentile": 0.29612}, "CVE-2014-3663": {"epss_score": 0.00065, "epss_percentile": 0.20627}, "CVE-2014-3664": {"epss_score": 0.00193, "epss_percentile": 0.41434}, "CVE-2014-3665": {"epss_score": 0.00476, "epss_percentile": 0.64273}, "CVE-2014-3666": {"epss_score": 0.01213, "epss_percentile": 0.78567}, "CVE-2014-3667": {"epss_score": 0.00056, "epss_percentile": 0.17657}, "CVE-2014-3668": {"epss_score": 0.0134, "epss_percentile": 0.79578}, "CVE-2014-3669": {"epss_score": 0.66576, "epss_percentile": 0.98469}, "CVE-2014-3670": {"epss_score": 0.30302, "epss_percentile": 0.96526}, "CVE-2014-3672": {"epss_score": 0.00033, "epss_percentile": 0.0939}, "CVE-2014-3673": {"epss_score": 0.09797, "epss_percentile": 0.92707}, "CVE-2014-3674": {"epss_score": 0.00542, "epss_percentile": 0.67086}, "CVE-2014-3675": {"epss_score": 0.03051, "epss_percentile": 0.8629}, "CVE-2014-3676": {"epss_score": 0.05165, "epss_percentile": 0.89562}, "CVE-2014-3677": {"epss_score": 0.01453, "epss_percentile": 0.80372}, "CVE-2014-3678": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-3679": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2014-3680": {"epss_score": 0.00075, "epss_percentile": 0.23048}, "CVE-2014-3681": {"epss_score": 0.00249, "epss_percentile": 0.48071}, "CVE-2014-3682": {"epss_score": 0.02109, "epss_percentile": 0.83641}, "CVE-2014-3683": {"epss_score": 0.01888, "epss_percentile": 0.8272}, "CVE-2014-3684": {"epss_score": 0.02532, "epss_percentile": 0.85029}, "CVE-2014-3686": {"epss_score": 0.04674, "epss_percentile": 0.88989}, "CVE-2014-3687": {"epss_score": 0.01984, "epss_percentile": 0.8315}, "CVE-2014-3688": {"epss_score": 0.02243, "epss_percentile": 0.84121}, "CVE-2014-3689": {"epss_score": 0.0009, "epss_percentile": 0.2608}, "CVE-2014-3690": {"epss_score": 0.00011, "epss_percentile": 0.00985}, "CVE-2014-3691": {"epss_score": 0.00137, "epss_percentile": 0.34272}, "CVE-2014-3692": {"epss_score": 0.01705, "epss_percentile": 0.8185}, "CVE-2014-3693": {"epss_score": 0.0432, "epss_percentile": 0.88541}, "CVE-2014-3694": {"epss_score": 0.0127, "epss_percentile": 0.79048}, "CVE-2014-3695": {"epss_score": 0.02486, "epss_percentile": 0.84889}, "CVE-2014-3696": {"epss_score": 0.02486, "epss_percentile": 0.84889}, "CVE-2014-3697": {"epss_score": 0.01028, "epss_percentile": 0.76814}, "CVE-2014-3698": {"epss_score": 0.01332, "epss_percentile": 0.79526}, "CVE-2014-3699": {"epss_score": 0.0099, "epss_percentile": 0.76376}, "CVE-2014-3700": {"epss_score": 0.0314, "epss_percentile": 0.86485}, "CVE-2014-3701": {"epss_score": 0.00453, "epss_percentile": 0.63216}, "CVE-2014-3702": {"epss_score": 0.01124, "epss_percentile": 0.77794}, "CVE-2014-3703": {"epss_score": 0.00363, "epss_percentile": 0.57862}, "CVE-2014-3704": {"epss_score": 0.94366, "epss_percentile": 0.9996}, "CVE-2014-3706": {"epss_score": 0.0022, "epss_percentile": 0.44581}, "CVE-2014-3707": {"epss_score": 0.00371, "epss_percentile": 0.58406}, "CVE-2014-3708": {"epss_score": 0.01057, "epss_percentile": 0.77134}, "CVE-2014-3709": {"epss_score": 0.00274, "epss_percentile": 0.50487}, "CVE-2014-3710": {"epss_score": 0.07784, "epss_percentile": 0.91681}, "CVE-2014-3711": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2014-3712": {"epss_score": 0.00613, "epss_percentile": 0.69253}, "CVE-2014-3714": {"epss_score": 0.00183, "epss_percentile": 0.40317}, "CVE-2014-3715": {"epss_score": 0.00183, "epss_percentile": 0.40317}, "CVE-2014-3716": {"epss_score": 0.00147, "epss_percentile": 0.35681}, "CVE-2014-3717": {"epss_score": 0.00183, "epss_percentile": 0.40317}, "CVE-2014-3718": {"epss_score": 0.00366, "epss_percentile": 0.58058}, "CVE-2014-3719": {"epss_score": 0.01237, "epss_percentile": 0.78778}, "CVE-2014-3730": {"epss_score": 0.00988, "epss_percentile": 0.76354}, "CVE-2014-3735": {"epss_score": 0.0045, "epss_percentile": 0.63102}, "CVE-2014-3737": {"epss_score": 0.00615, "epss_percentile": 0.69305}, "CVE-2014-3738": {"epss_score": 0.05945, "epss_percentile": 0.90353}, "CVE-2014-3739": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-3740": {"epss_score": 0.02977, "epss_percentile": 0.86109}, "CVE-2014-3741": {"epss_score": 0.01874, "epss_percentile": 0.82648}, "CVE-2014-3742": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2014-3743": {"epss_score": 0.00584, "epss_percentile": 0.68377}, "CVE-2014-3744": {"epss_score": 0.5516, "epss_percentile": 0.97964}, "CVE-2014-3749": {"epss_score": 0.00379, "epss_percentile": 0.58859}, "CVE-2014-3750": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2014-3752": {"epss_score": 0.00086, "epss_percentile": 0.25337}, "CVE-2014-3753": {"epss_score": 0.00222, "epss_percentile": 0.44734}, "CVE-2014-3755": {"epss_score": 0.0112, "epss_percentile": 0.7776}, "CVE-2014-3756": {"epss_score": 0.006, "epss_percentile": 0.68824}, "CVE-2014-3757": {"epss_score": 0.00362, "epss_percentile": 0.5782}, "CVE-2014-3758": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-3759": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2014-3760": {"epss_score": 0.00209, "epss_percentile": 0.43414}, "CVE-2014-3761": {"epss_score": 0.00354, "epss_percentile": 0.57257}, "CVE-2014-3764": {"epss_score": 0.00245, "epss_percentile": 0.4766}, "CVE-2014-3771": {"epss_score": 0.00349, "epss_percentile": 0.56856}, "CVE-2014-3772": {"epss_score": 0.00349, "epss_percentile": 0.56856}, "CVE-2014-3773": {"epss_score": 0.00432, "epss_percentile": 0.62099}, "CVE-2014-3774": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2014-3775": {"epss_score": 0.01452, "epss_percentile": 0.80368}, "CVE-2014-3776": {"epss_score": 0.03058, "epss_percentile": 0.86304}, "CVE-2014-3777": {"epss_score": 0.00206, "epss_percentile": 0.42776}, "CVE-2014-3778": {"epss_score": 0.00405, "epss_percentile": 0.60461}, "CVE-2014-3779": {"epss_score": 0.00578, "epss_percentile": 0.68194}, "CVE-2014-3780": {"epss_score": 0.0041, "epss_percentile": 0.60793}, "CVE-2014-3781": {"epss_score": 0.00447, "epss_percentile": 0.62977}, "CVE-2014-3782": {"epss_score": 0.00829, "epss_percentile": 0.7401}, "CVE-2014-3783": {"epss_score": 0.00327, "epss_percentile": 0.55102}, "CVE-2014-3786": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-3787": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2014-3788": {"epss_score": 0.03241, "epss_percentile": 0.86733}, "CVE-2014-3789": {"epss_score": 0.71003, "epss_percentile": 0.98649}, "CVE-2014-3790": {"epss_score": 0.00502, "epss_percentile": 0.65416}, "CVE-2014-3791": {"epss_score": 0.77234, "epss_percentile": 0.98928}, "CVE-2014-3792": {"epss_score": 0.00256, "epss_percentile": 0.48817}, "CVE-2014-3793": {"epss_score": 0.00193, "epss_percentile": 0.41391}, "CVE-2014-3796": {"epss_score": 0.00486, "epss_percentile": 0.64766}, "CVE-2014-3797": {"epss_score": 0.0039, "epss_percentile": 0.59551}, "CVE-2014-3798": {"epss_score": 0.04615, "epss_percentile": 0.88924}, "CVE-2014-3800": {"epss_score": 0.00047, "epss_percentile": 0.14779}, "CVE-2014-3801": {"epss_score": 0.00428, "epss_percentile": 0.61938}, "CVE-2014-3802": {"epss_score": 0.09589, "epss_percentile": 0.92612}, "CVE-2014-3803": {"epss_score": 0.00682, "epss_percentile": 0.71085}, "CVE-2014-3804": {"epss_score": 0.79335, "epss_percentile": 0.99033}, "CVE-2014-3805": {"epss_score": 0.39829, "epss_percentile": 0.97181}, "CVE-2014-3806": {"epss_score": 0.11359, "epss_percentile": 0.93323}, "CVE-2014-3807": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-3808": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-3809": {"epss_score": 0.00195, "epss_percentile": 0.41666}, "CVE-2014-3810": {"epss_score": 0.00355, "epss_percentile": 0.57286}, "CVE-2014-3811": {"epss_score": 0.00043, "epss_percentile": 0.13237}, "CVE-2014-3812": {"epss_score": 0.00182, "epss_percentile": 0.40216}, "CVE-2014-3813": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2014-3814": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2014-3815": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2014-3816": {"epss_score": 0.00457, "epss_percentile": 0.63376}, "CVE-2014-3817": {"epss_score": 0.00778, "epss_percentile": 0.73122}, "CVE-2014-3818": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2014-3819": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2014-3820": {"epss_score": 0.00316, "epss_percentile": 0.54229}, "CVE-2014-3821": {"epss_score": 0.00257, "epss_percentile": 0.48888}, "CVE-2014-3822": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2014-3823": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2014-3824": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-3825": {"epss_score": 0.00766, "epss_percentile": 0.72932}, "CVE-2014-3826": {"epss_score": 0.00144, "epss_percentile": 0.35317}, "CVE-2014-3827": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2014-3828": {"epss_score": 0.78588, "epss_percentile": 0.98993}, "CVE-2014-3829": {"epss_score": 0.86204, "epss_percentile": 0.99373}, "CVE-2014-3830": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-3832": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-3833": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-3834": {"epss_score": 0.00303, "epss_percentile": 0.53223}, "CVE-2014-3835": {"epss_score": 0.00296, "epss_percentile": 0.52626}, "CVE-2014-3836": {"epss_score": 0.00118, "epss_percentile": 0.3146}, "CVE-2014-3837": {"epss_score": 0.00171, "epss_percentile": 0.38827}, "CVE-2014-3838": {"epss_score": 0.00133, "epss_percentile": 0.33734}, "CVE-2014-3840": {"epss_score": 0.01252, "epss_percentile": 0.789}, "CVE-2014-3841": {"epss_score": 0.00196, "epss_percentile": 0.41735}, "CVE-2014-3842": {"epss_score": 0.02082, "epss_percentile": 0.83538}, "CVE-2014-3843": {"epss_score": 0.00094, "epss_percentile": 0.26787}, "CVE-2014-3844": {"epss_score": 0.00194, "epss_percentile": 0.41516}, "CVE-2014-3845": {"epss_score": 0.00094, "epss_percentile": 0.26787}, "CVE-2014-3846": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-3848": {"epss_score": 0.15328, "epss_percentile": 0.94411}, "CVE-2014-3849": {"epss_score": 0.10273, "epss_percentile": 0.92922}, "CVE-2014-3850": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-3851": {"epss_score": 0.00043, "epss_percentile": 0.13217}, "CVE-2014-3852": {"epss_score": 0.00207, "epss_percentile": 0.43147}, "CVE-2014-3853": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-3854": {"epss_score": 0.00389, "epss_percentile": 0.59411}, "CVE-2014-3855": {"epss_score": 0.00136, "epss_percentile": 0.34132}, "CVE-2014-3856": {"epss_score": 0.00109, "epss_percentile": 0.29952}, "CVE-2014-3857": {"epss_score": 0.01864, "epss_percentile": 0.82599}, "CVE-2014-3859": {"epss_score": 0.29819, "epss_percentile": 0.96478}, "CVE-2014-3860": {"epss_score": 0.00067, "epss_percentile": 0.21057}, "CVE-2014-3861": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-3862": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2014-3863": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-3864": {"epss_score": 0.00982, "epss_percentile": 0.76297}, "CVE-2014-3865": {"epss_score": 0.05671, "epss_percentile": 0.90104}, "CVE-2014-3866": {"epss_score": 0.00228, "epss_percentile": 0.45501}, "CVE-2014-3867": {"epss_score": 0.00254, "epss_percentile": 0.48524}, "CVE-2014-3868": {"epss_score": 0.00939, "epss_percentile": 0.75725}, "CVE-2014-3870": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-3871": {"epss_score": 0.02262, "epss_percentile": 0.84189}, "CVE-2014-3872": {"epss_score": 0.00323, "epss_percentile": 0.54862}, "CVE-2014-3873": {"epss_score": 0.00061, "epss_percentile": 0.19511}, "CVE-2014-3875": {"epss_score": 0.00789, "epss_percentile": 0.73358}, "CVE-2014-3876": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-3877": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2014-3878": {"epss_score": 0.00364, "epss_percentile": 0.57953}, "CVE-2014-3879": {"epss_score": 0.01485, "epss_percentile": 0.80598}, "CVE-2014-3880": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2014-3881": {"epss_score": 0.00134, "epss_percentile": 0.33756}, "CVE-2014-3882": {"epss_score": 0.00187, "epss_percentile": 0.40792}, "CVE-2014-3883": {"epss_score": 0.00517, "epss_percentile": 0.6607}, "CVE-2014-3884": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2014-3885": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2014-3886": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2014-3887": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2014-3888": {"epss_score": 0.2899, "epss_percentile": 0.96408}, "CVE-2014-3889": {"epss_score": 0.00412, "epss_percentile": 0.60947}, "CVE-2014-3890": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-3891": {"epss_score": 0.01586, "epss_percentile": 0.81168}, "CVE-2014-3892": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2014-3894": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2014-3895": {"epss_score": 0.00304, "epss_percentile": 0.53303}, "CVE-2014-3896": {"epss_score": 0.00125, "epss_percentile": 0.32547}, "CVE-2014-3897": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-3898": {"epss_score": 0.00396, "epss_percentile": 0.59901}, "CVE-2014-3899": {"epss_score": 0.0068, "epss_percentile": 0.71031}, "CVE-2014-3900": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-3901": {"epss_score": 0.02523, "epss_percentile": 0.85007}, "CVE-2014-3902": {"epss_score": 0.00213, "epss_percentile": 0.43907}, "CVE-2014-3903": {"epss_score": 0.0018, "epss_percentile": 0.39911}, "CVE-2014-3904": {"epss_score": 0.00318, "epss_percentile": 0.54449}, "CVE-2014-3905": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2014-3906": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2014-3907": {"epss_score": 0.00102, "epss_percentile": 0.28812}, "CVE-2014-3908": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2014-3909": {"epss_score": 0.00447, "epss_percentile": 0.6297}, "CVE-2014-3910": {"epss_score": 0.00149, "epss_percentile": 0.35965}, "CVE-2014-3911": {"epss_score": 0.09726, "epss_percentile": 0.92678}, "CVE-2014-3912": {"epss_score": 0.12251, "epss_percentile": 0.93612}, "CVE-2014-3913": {"epss_score": 0.78737, "epss_percentile": 0.99002}, "CVE-2014-3914": {"epss_score": 0.81114, "epss_percentile": 0.99121}, "CVE-2014-3915": {"epss_score": 0.04613, "epss_percentile": 0.8892}, "CVE-2014-3916": {"epss_score": 0.0049, "epss_percentile": 0.64937}, "CVE-2014-3917": {"epss_score": 0.00089, "epss_percentile": 0.2591}, "CVE-2014-3919": {"epss_score": 0.00326, "epss_percentile": 0.55084}, "CVE-2014-3920": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2014-3921": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-3922": {"epss_score": 0.01137, "epss_percentile": 0.77926}, "CVE-2014-3923": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-3924": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2014-3925": {"epss_score": 0.00401, "epss_percentile": 0.60217}, "CVE-2014-3926": {"epss_score": 0.00806, "epss_percentile": 0.73652}, "CVE-2014-3927": {"epss_score": 0.0116, "epss_percentile": 0.78131}, "CVE-2014-3928": {"epss_score": 0.0071, "epss_percentile": 0.71717}, "CVE-2014-3929": {"epss_score": 0.00544, "epss_percentile": 0.67144}, "CVE-2014-3930": {"epss_score": 0.00381, "epss_percentile": 0.5901}, "CVE-2014-3931": {"epss_score": 0.35558, "epss_percentile": 0.96919}, "CVE-2014-3932": {"epss_score": 0.00294, "epss_percentile": 0.52392}, "CVE-2014-3933": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2014-3934": {"epss_score": 0.00826, "epss_percentile": 0.73969}, "CVE-2014-3935": {"epss_score": 0.00826, "epss_percentile": 0.73969}, "CVE-2014-3936": {"epss_score": 0.86285, "epss_percentile": 0.99376}, "CVE-2014-3937": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2014-3938": {"epss_score": 0.10546, "epss_percentile": 0.93024}, "CVE-2014-3939": {"epss_score": 0.12251, "epss_percentile": 0.93612}, "CVE-2014-3940": {"epss_score": 0.00041, "epss_percentile": 0.12443}, "CVE-2014-3941": {"epss_score": 0.00276, "epss_percentile": 0.50748}, "CVE-2014-3942": {"epss_score": 0.00442, "epss_percentile": 0.62733}, "CVE-2014-3943": {"epss_score": 0.00208, "epss_percentile": 0.43213}, "CVE-2014-3944": {"epss_score": 0.00186, "epss_percentile": 0.40694}, "CVE-2014-3945": {"epss_score": 0.00198, "epss_percentile": 0.42019}, "CVE-2014-3946": {"epss_score": 0.00151, "epss_percentile": 0.36203}, "CVE-2014-3947": {"epss_score": 0.01727, "epss_percentile": 0.8197}, "CVE-2014-3948": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-3949": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2014-3951": {"epss_score": 0.00408, "epss_percentile": 0.60636}, "CVE-2014-3952": {"epss_score": 0.0007, "epss_percentile": 0.21752}, "CVE-2014-3953": {"epss_score": 0.00071, "epss_percentile": 0.22169}, "CVE-2014-3954": {"epss_score": 0.08926, "epss_percentile": 0.92323}, "CVE-2014-3955": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2014-3956": {"epss_score": 0.001, "epss_percentile": 0.28537}, "CVE-2014-3959": {"epss_score": 0.00861, "epss_percentile": 0.74564}, "CVE-2014-3960": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-3961": {"epss_score": 0.06852, "epss_percentile": 0.91073}, "CVE-2014-3962": {"epss_score": 0.0096, "epss_percentile": 0.75967}, "CVE-2014-3963": {"epss_score": 0.00133, "epss_percentile": 0.33734}, "CVE-2014-3966": {"epss_score": 0.00324, "epss_percentile": 0.54934}, "CVE-2014-3967": {"epss_score": 0.00257, "epss_percentile": 0.4886}, "CVE-2014-3968": {"epss_score": 0.00383, "epss_percentile": 0.59094}, "CVE-2014-3969": {"epss_score": 0.00181, "epss_percentile": 0.4011}, "CVE-2014-3970": {"epss_score": 0.00473, "epss_percentile": 0.64103}, "CVE-2014-3971": {"epss_score": 0.01981, "epss_percentile": 0.83137}, "CVE-2014-3972": {"epss_score": 0.0085, "epss_percentile": 0.74395}, "CVE-2014-3973": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2014-3974": {"epss_score": 0.05461, "epss_percentile": 0.89901}, "CVE-2014-3975": {"epss_score": 0.14538, "epss_percentile": 0.94236}, "CVE-2014-3976": {"epss_score": 0.34981, "epss_percentile": 0.96881}, "CVE-2014-3977": {"epss_score": 0.00163, "epss_percentile": 0.37785}, "CVE-2014-3978": {"epss_score": 0.00705, "epss_percentile": 0.71587}, "CVE-2014-3979": {"epss_score": 0.01987, "epss_percentile": 0.8316}, "CVE-2014-3980": {"epss_score": 0.00056, "epss_percentile": 0.17911}, "CVE-2014-3981": {"epss_score": 0.00166, "epss_percentile": 0.38145}, "CVE-2014-3982": {"epss_score": 0.0005, "epss_percentile": 0.157}, "CVE-2014-3984": {"epss_score": 0.09612, "epss_percentile": 0.92622}, "CVE-2014-3985": {"epss_score": 0.01931, "epss_percentile": 0.82941}, "CVE-2014-3986": {"epss_score": 0.0005, "epss_percentile": 0.15844}, "CVE-2014-3988": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-3990": {"epss_score": 0.10961, "epss_percentile": 0.93177}, "CVE-2014-3991": {"epss_score": 0.00378, "epss_percentile": 0.58825}, "CVE-2014-3992": {"epss_score": 0.02469, "epss_percentile": 0.84843}, "CVE-2014-3994": {"epss_score": 0.00588, "epss_percentile": 0.68508}, "CVE-2014-3995": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2014-3996": {"epss_score": 0.71162, "epss_percentile": 0.98657}, "CVE-2014-3997": {"epss_score": 0.0129, "epss_percentile": 0.79215}, "CVE-2014-3999": {"epss_score": 0.02068, "epss_percentile": 0.83464}, "CVE-2014-4000": {"epss_score": 0.011, "epss_percentile": 0.77569}, "CVE-2014-4002": {"epss_score": 0.00431, "epss_percentile": 0.62053}, "CVE-2014-4003": {"epss_score": 0.01207, "epss_percentile": 0.78528}, "CVE-2014-4004": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2014-4005": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2014-4006": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2014-4007": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2014-4008": {"epss_score": 0.00294, "epss_percentile": 0.52383}, "CVE-2014-4009": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2014-4010": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2014-4011": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2014-4012": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2014-4013": {"epss_score": 0.00329, "epss_percentile": 0.55414}, "CVE-2014-4014": {"epss_score": 0.0257, "epss_percentile": 0.85126}, "CVE-2014-4017": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4018": {"epss_score": 0.06627, "epss_percentile": 0.90899}, "CVE-2014-4019": {"epss_score": 0.59441, "epss_percentile": 0.98165}, "CVE-2014-4020": {"epss_score": 0.00171, "epss_percentile": 0.38816}, "CVE-2014-4021": {"epss_score": 0.00234, "epss_percentile": 0.46085}, "CVE-2014-4022": {"epss_score": 0.00168, "epss_percentile": 0.38407}, "CVE-2014-4023": {"epss_score": 0.00408, "epss_percentile": 0.60625}, "CVE-2014-4024": {"epss_score": 0.00743, "epss_percentile": 0.72465}, "CVE-2014-4027": {"epss_score": 0.00091, "epss_percentile": 0.26293}, "CVE-2014-4030": {"epss_score": 0.00291, "epss_percentile": 0.52203}, "CVE-2014-4031": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2014-4032": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-4033": {"epss_score": 0.0338, "epss_percentile": 0.8703}, "CVE-2014-4034": {"epss_score": 0.13401, "epss_percentile": 0.93952}, "CVE-2014-4035": {"epss_score": 0.03324, "epss_percentile": 0.86918}, "CVE-2014-4036": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-4037": {"epss_score": 0.00353, "epss_percentile": 0.57139}, "CVE-2014-4038": {"epss_score": 0.00058, "epss_percentile": 0.18302}, "CVE-2014-4039": {"epss_score": 0.00063, "epss_percentile": 0.19835}, "CVE-2014-4040": {"epss_score": 0.00232, "epss_percentile": 0.45907}, "CVE-2014-4043": {"epss_score": 0.01643, "epss_percentile": 0.81514}, "CVE-2014-4044": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2014-4045": {"epss_score": 0.0711, "epss_percentile": 0.91258}, "CVE-2014-4046": {"epss_score": 0.03222, "epss_percentile": 0.86674}, "CVE-2014-4047": {"epss_score": 0.11713, "epss_percentile": 0.93458}, "CVE-2014-4048": {"epss_score": 0.0667, "epss_percentile": 0.90932}, "CVE-2014-4049": {"epss_score": 0.22414, "epss_percentile": 0.95632}, "CVE-2014-4050": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-4051": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-4052": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-4055": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-4056": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2014-4057": {"epss_score": 0.1418, "epss_percentile": 0.94157}, "CVE-2014-4058": {"epss_score": 0.14833, "epss_percentile": 0.94299}, "CVE-2014-4059": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4060": {"epss_score": 0.16013, "epss_percentile": 0.94558}, "CVE-2014-4061": {"epss_score": 0.33911, "epss_percentile": 0.96817}, "CVE-2014-4062": {"epss_score": 0.16961, "epss_percentile": 0.94753}, "CVE-2014-4063": {"epss_score": 0.14815, "epss_percentile": 0.9429}, "CVE-2014-4064": {"epss_score": 0.02449, "epss_percentile": 0.84775}, "CVE-2014-4065": {"epss_score": 0.18139, "epss_percentile": 0.94965}, "CVE-2014-4066": {"epss_score": 0.12434, "epss_percentile": 0.93668}, "CVE-2014-4067": {"epss_score": 0.14833, "epss_percentile": 0.94299}, "CVE-2014-4068": {"epss_score": 0.31146, "epss_percentile": 0.96598}, "CVE-2014-4070": {"epss_score": 0.18344, "epss_percentile": 0.94999}, "CVE-2014-4071": {"epss_score": 0.31146, "epss_percentile": 0.96598}, "CVE-2014-4072": {"epss_score": 0.39634, "epss_percentile": 0.97172}, "CVE-2014-4073": {"epss_score": 0.29986, "epss_percentile": 0.96491}, "CVE-2014-4074": {"epss_score": 0.01722, "epss_percentile": 0.81937}, "CVE-2014-4075": {"epss_score": 0.18596, "epss_percentile": 0.9504}, "CVE-2014-4076": {"epss_score": 0.52746, "epss_percentile": 0.97838}, "CVE-2014-4077": {"epss_score": 0.36747, "epss_percentile": 0.96999}, "CVE-2014-4078": {"epss_score": 0.13168, "epss_percentile": 0.93891}, "CVE-2014-4079": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4080": {"epss_score": 0.14078, "epss_percentile": 0.94128}, "CVE-2014-4081": {"epss_score": 0.14078, "epss_percentile": 0.94128}, "CVE-2014-4082": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-4083": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4084": {"epss_score": 0.14922, "epss_percentile": 0.94325}, "CVE-2014-4085": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4086": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-4087": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4088": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4089": {"epss_score": 0.1418, "epss_percentile": 0.94157}, "CVE-2014-4090": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4091": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4092": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4093": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-4094": {"epss_score": 0.1418, "epss_percentile": 0.94157}, "CVE-2014-4095": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4096": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4097": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4098": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4099": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4100": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4101": {"epss_score": 0.16326, "epss_percentile": 0.9463}, "CVE-2014-4102": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4103": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4104": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4105": {"epss_score": 0.18139, "epss_percentile": 0.94965}, "CVE-2014-4106": {"epss_score": 0.18139, "epss_percentile": 0.94965}, "CVE-2014-4107": {"epss_score": 0.18139, "epss_percentile": 0.94965}, "CVE-2014-4108": {"epss_score": 0.18139, "epss_percentile": 0.94965}, "CVE-2014-4109": {"epss_score": 0.16199, "epss_percentile": 0.94592}, "CVE-2014-4110": {"epss_score": 0.18139, "epss_percentile": 0.94965}, "CVE-2014-4111": {"epss_score": 0.18139, "epss_percentile": 0.94965}, "CVE-2014-4112": {"epss_score": 0.09552, "epss_percentile": 0.92595}, "CVE-2014-4113": {"epss_score": 0.82433, "epss_percentile": 0.99195}, "CVE-2014-4114": {"epss_score": 0.92305, "epss_percentile": 0.99706}, "CVE-2014-4115": {"epss_score": 0.00711, "epss_percentile": 0.71733}, "CVE-2014-4116": {"epss_score": 0.12319, "epss_percentile": 0.9364}, "CVE-2014-4117": {"epss_score": 0.32032, "epss_percentile": 0.96668}, "CVE-2014-4118": {"epss_score": 0.28411, "epss_percentile": 0.96354}, "CVE-2014-4121": {"epss_score": 0.4252, "epss_percentile": 0.97335}, "CVE-2014-4122": {"epss_score": 0.41115, "epss_percentile": 0.97255}, "CVE-2014-4123": {"epss_score": 0.46388, "epss_percentile": 0.97543}, "CVE-2014-4124": {"epss_score": 0.08383, "epss_percentile": 0.92019}, "CVE-2014-4126": {"epss_score": 0.15705, "epss_percentile": 0.94487}, "CVE-2014-4127": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-4128": {"epss_score": 0.14058, "epss_percentile": 0.94125}, "CVE-2014-4129": {"epss_score": 0.20817, "epss_percentile": 0.95418}, "CVE-2014-4130": {"epss_score": 0.1775, "epss_percentile": 0.94898}, "CVE-2014-4132": {"epss_score": 0.14058, "epss_percentile": 0.94125}, "CVE-2014-4133": {"epss_score": 0.15762, "epss_percentile": 0.94505}, "CVE-2014-4134": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2014-4137": {"epss_score": 0.1418, "epss_percentile": 0.94157}, "CVE-2014-4138": {"epss_score": 0.22252, "epss_percentile": 0.95615}, "CVE-2014-4140": {"epss_score": 0.15101, "epss_percentile": 0.94363}, "CVE-2014-4141": {"epss_score": 0.20532, "epss_percentile": 0.95365}, "CVE-2014-4143": {"epss_score": 0.33279, "epss_percentile": 0.96759}, "CVE-2014-4145": {"epss_score": 0.09552, "epss_percentile": 0.92595}, "CVE-2014-4148": {"epss_score": 0.49715, "epss_percentile": 0.97702}, "CVE-2014-4149": {"epss_score": 0.37747, "epss_percentile": 0.97067}, "CVE-2014-4150": {"epss_score": 0.00058, "epss_percentile": 0.18405}, "CVE-2014-4151": {"epss_score": 0.1138, "epss_percentile": 0.93327}, "CVE-2014-4152": {"epss_score": 0.1138, "epss_percentile": 0.93327}, "CVE-2014-4153": {"epss_score": 0.07557, "epss_percentile": 0.9154}, "CVE-2014-4154": {"epss_score": 0.10263, "epss_percentile": 0.92918}, "CVE-2014-4155": {"epss_score": 0.002, "epss_percentile": 0.42221}, "CVE-2014-4156": {"epss_score": 0.00209, "epss_percentile": 0.43325}, "CVE-2014-4157": {"epss_score": 0.00044, "epss_percentile": 0.13527}, "CVE-2014-4158": {"epss_score": 0.34008, "epss_percentile": 0.9682}, "CVE-2014-4159": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-4160": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-4161": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-4162": {"epss_score": 0.00358, "epss_percentile": 0.57519}, "CVE-2014-4163": {"epss_score": 0.00239, "epss_percentile": 0.46891}, "CVE-2014-4164": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-4165": {"epss_score": 0.00422, "epss_percentile": 0.61568}, "CVE-2014-4166": {"epss_score": 0.0338, "epss_percentile": 0.8703}, "CVE-2014-4167": {"epss_score": 0.00558, "epss_percentile": 0.67594}, "CVE-2014-4168": {"epss_score": 0.01036, "epss_percentile": 0.76914}, "CVE-2014-4170": {"epss_score": 0.47767, "epss_percentile": 0.976}, "CVE-2014-4171": {"epss_score": 0.00043, "epss_percentile": 0.13324}, "CVE-2014-4172": {"epss_score": 0.06742, "epss_percentile": 0.90997}, "CVE-2014-4174": {"epss_score": 0.01768, "epss_percentile": 0.82181}, "CVE-2014-4187": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-4188": {"epss_score": 0.00151, "epss_percentile": 0.36223}, "CVE-2014-4189": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-4190": {"epss_score": 0.00248, "epss_percentile": 0.47952}, "CVE-2014-4191": {"epss_score": 0.00221, "epss_percentile": 0.44677}, "CVE-2014-4192": {"epss_score": 0.00221, "epss_percentile": 0.44677}, "CVE-2014-4193": {"epss_score": 0.0025, "epss_percentile": 0.48094}, "CVE-2014-4194": {"epss_score": 0.01016, "epss_percentile": 0.76676}, "CVE-2014-4195": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-4196": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2014-4197": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2014-4198": {"epss_score": 0.00282, "epss_percentile": 0.51206}, "CVE-2014-4199": {"epss_score": 0.0003, "epss_percentile": 0.08305}, "CVE-2014-4200": {"epss_score": 0.00041, "epss_percentile": 0.12268}, "CVE-2014-4201": {"epss_score": 0.04029, "epss_percentile": 0.88148}, "CVE-2014-4202": {"epss_score": 0.04029, "epss_percentile": 0.88148}, "CVE-2014-4203": {"epss_score": 0.00099, "epss_percentile": 0.28385}, "CVE-2014-4204": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2014-4205": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2014-4206": {"epss_score": 0.00079, "epss_percentile": 0.23866}, "CVE-2014-4207": {"epss_score": 0.00469, "epss_percentile": 0.63918}, "CVE-2014-4208": {"epss_score": 0.02549, "epss_percentile": 0.85071}, "CVE-2014-4209": {"epss_score": 0.03216, "epss_percentile": 0.86664}, "CVE-2014-4210": {"epss_score": 0.94152, "epss_percentile": 0.99909}, "CVE-2014-4211": {"epss_score": 0.00494, "epss_percentile": 0.65099}, "CVE-2014-4212": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2014-4213": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2014-4214": {"epss_score": 0.01083, "epss_percentile": 0.7739}, "CVE-2014-4215": {"epss_score": 0.00127, "epss_percentile": 0.32835}, "CVE-2014-4216": {"epss_score": 0.05969, "epss_percentile": 0.90371}, "CVE-2014-4217": {"epss_score": 0.00646, "epss_percentile": 0.70135}, "CVE-2014-4218": {"epss_score": 0.03216, "epss_percentile": 0.86664}, "CVE-2014-4219": {"epss_score": 0.08456, "epss_percentile": 0.92061}, "CVE-2014-4220": {"epss_score": 0.03423, "epss_percentile": 0.87107}, "CVE-2014-4221": {"epss_score": 0.04125, "epss_percentile": 0.88288}, "CVE-2014-4222": {"epss_score": 0.00607, "epss_percentile": 0.69041}, "CVE-2014-4223": {"epss_score": 0.06348, "epss_percentile": 0.90688}, "CVE-2014-4224": {"epss_score": 0.00127, "epss_percentile": 0.32835}, "CVE-2014-4225": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2014-4226": {"epss_score": 0.01162, "epss_percentile": 0.78151}, "CVE-2014-4227": {"epss_score": 0.10621, "epss_percentile": 0.93052}, "CVE-2014-4228": {"epss_score": 0.00111, "epss_percentile": 0.30278}, "CVE-2014-4229": {"epss_score": 0.005, "epss_percentile": 0.65306}, "CVE-2014-4230": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2014-4231": {"epss_score": 0.00524, "epss_percentile": 0.66352}, "CVE-2014-4232": {"epss_score": 0.00488, "epss_percentile": 0.64831}, "CVE-2014-4233": {"epss_score": 0.00923, "epss_percentile": 0.75499}, "CVE-2014-4234": {"epss_score": 0.00645, "epss_percentile": 0.70107}, "CVE-2014-4235": {"epss_score": 0.00441, "epss_percentile": 0.62662}, "CVE-2014-4236": {"epss_score": 0.01816, "epss_percentile": 0.82392}, "CVE-2014-4237": {"epss_score": 0.00739, "epss_percentile": 0.7239}, "CVE-2014-4238": {"epss_score": 0.00923, "epss_percentile": 0.75499}, "CVE-2014-4239": {"epss_score": 0.00581, "epss_percentile": 0.68281}, "CVE-2014-4240": {"epss_score": 0.00064, "epss_percentile": 0.20193}, "CVE-2014-4241": {"epss_score": 0.00912, "epss_percentile": 0.75354}, "CVE-2014-4242": {"epss_score": 0.00494, "epss_percentile": 0.65099}, "CVE-2014-4243": {"epss_score": 0.00699, "epss_percentile": 0.71441}, "CVE-2014-4244": {"epss_score": 0.07992, "epss_percentile": 0.91811}, "CVE-2014-4245": {"epss_score": 0.00751, "epss_percentile": 0.72648}, "CVE-2014-4246": {"epss_score": 0.00581, "epss_percentile": 0.68281}, "CVE-2014-4247": {"epss_score": 0.01125, "epss_percentile": 0.77802}, "CVE-2014-4248": {"epss_score": 0.00081, "epss_percentile": 0.24267}, "CVE-2014-4249": {"epss_score": 0.0061, "epss_percentile": 0.69142}, "CVE-2014-4250": {"epss_score": 0.00441, "epss_percentile": 0.62662}, "CVE-2014-4251": {"epss_score": 0.0052, "epss_percentile": 0.66197}, "CVE-2014-4252": {"epss_score": 0.03042, "epss_percentile": 0.86275}, "CVE-2014-4253": {"epss_score": 0.0213, "epss_percentile": 0.83709}, "CVE-2014-4254": {"epss_score": 0.02707, "epss_percentile": 0.85468}, "CVE-2014-4255": {"epss_score": 0.02707, "epss_percentile": 0.85468}, "CVE-2014-4256": {"epss_score": 0.00494, "epss_percentile": 0.65099}, "CVE-2014-4257": {"epss_score": 0.00576, "epss_percentile": 0.68122}, "CVE-2014-4258": {"epss_score": 0.00595, "epss_percentile": 0.68695}, "CVE-2014-4259": {"epss_score": 0.00564, "epss_percentile": 0.67771}, "CVE-2014-4260": {"epss_score": 0.00452, "epss_percentile": 0.63199}, "CVE-2014-4261": {"epss_score": 0.00103, "epss_percentile": 0.29078}, "CVE-2014-4262": {"epss_score": 0.08456, "epss_percentile": 0.92061}, "CVE-2014-4263": {"epss_score": 0.09108, "epss_percentile": 0.92404}, "CVE-2014-4264": {"epss_score": 0.0556, "epss_percentile": 0.89992}, "CVE-2014-4265": {"epss_score": 0.04028, "epss_percentile": 0.88146}, "CVE-2014-4266": {"epss_score": 0.02806, "epss_percentile": 0.85707}, "CVE-2014-4267": {"epss_score": 0.01645, "epss_percentile": 0.8153}, "CVE-2014-4268": {"epss_score": 0.03754, "epss_percentile": 0.87678}, "CVE-2014-4269": {"epss_score": 0.00607, "epss_percentile": 0.69041}, "CVE-2014-4270": {"epss_score": 0.00581, "epss_percentile": 0.68281}, "CVE-2014-4271": {"epss_score": 0.01358, "epss_percentile": 0.79734}, "CVE-2014-4274": {"epss_score": 0.00151, "epss_percentile": 0.36365}, "CVE-2014-4275": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2014-4276": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2014-4277": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2014-4278": {"epss_score": 0.01231, "epss_percentile": 0.78734}, "CVE-2014-4279": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2014-4280": {"epss_score": 0.00059, "epss_percentile": 0.18642}, "CVE-2014-4281": {"epss_score": 0.00356, "epss_percentile": 0.57328}, "CVE-2014-4282": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2014-4283": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2014-4284": {"epss_score": 0.00059, "epss_percentile": 0.18642}, "CVE-2014-4285": {"epss_score": 0.00262, "epss_percentile": 0.49343}, "CVE-2014-4287": {"epss_score": 0.00471, "epss_percentile": 0.64013}, "CVE-2014-4288": {"epss_score": 0.07481, "epss_percentile": 0.91496}, "CVE-2014-4289": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2014-4290": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-4291": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-4292": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-4293": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-4294": {"epss_score": 0.00149, "epss_percentile": 0.3602}, "CVE-2014-4295": {"epss_score": 0.00149, "epss_percentile": 0.3602}, "CVE-2014-4296": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-4297": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-4298": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-4299": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-4300": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-4301": {"epss_score": 0.00367, "epss_percentile": 0.58142}, "CVE-2014-4302": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-4303": {"epss_score": 0.00366, "epss_percentile": 0.58094}, "CVE-2014-4304": {"epss_score": 0.00403, "epss_percentile": 0.60342}, "CVE-2014-4305": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2014-4306": {"epss_score": 0.0683, "epss_percentile": 0.91055}, "CVE-2014-4307": {"epss_score": 0.00826, "epss_percentile": 0.73969}, "CVE-2014-4308": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-4309": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-4310": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-4311": {"epss_score": 0.08728, "epss_percentile": 0.92231}, "CVE-2014-4312": {"epss_score": 0.18167, "epss_percentile": 0.94969}, "CVE-2014-4313": {"epss_score": 0.00356, "epss_percentile": 0.57348}, "CVE-2014-4322": {"epss_score": 0.03454, "epss_percentile": 0.87169}, "CVE-2014-4323": {"epss_score": 0.01657, "epss_percentile": 0.81605}, "CVE-2014-4325": {"epss_score": 0.00043, "epss_percentile": 0.13086}, "CVE-2014-4326": {"epss_score": 0.00881, "epss_percentile": 0.7488}, "CVE-2014-4329": {"epss_score": 0.00287, "epss_percentile": 0.51829}, "CVE-2014-4330": {"epss_score": 0.00117, "epss_percentile": 0.3135}, "CVE-2014-4331": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-4333": {"epss_score": 0.00216, "epss_percentile": 0.44164}, "CVE-2014-4334": {"epss_score": 0.17428, "epss_percentile": 0.94851}, "CVE-2014-4335": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-4336": {"epss_score": 0.00523, "epss_percentile": 0.66308}, "CVE-2014-4337": {"epss_score": 0.02131, "epss_percentile": 0.83715}, "CVE-2014-4338": {"epss_score": 0.00394, "epss_percentile": 0.59792}, "CVE-2014-4341": {"epss_score": 0.14451, "epss_percentile": 0.94215}, "CVE-2014-4342": {"epss_score": 0.08139, "epss_percentile": 0.91898}, "CVE-2014-4343": {"epss_score": 0.09608, "epss_percentile": 0.9262}, "CVE-2014-4344": {"epss_score": 0.09108, "epss_percentile": 0.92404}, "CVE-2014-4345": {"epss_score": 0.12674, "epss_percentile": 0.93746}, "CVE-2014-4346": {"epss_score": 0.00834, "epss_percentile": 0.74113}, "CVE-2014-4347": {"epss_score": 0.00978, "epss_percentile": 0.76253}, "CVE-2014-4348": {"epss_score": 0.00182, "epss_percentile": 0.40227}, "CVE-2014-4349": {"epss_score": 0.00354, "epss_percentile": 0.57214}, "CVE-2014-4350": {"epss_score": 0.10417, "epss_percentile": 0.92982}, "CVE-2014-4351": {"epss_score": 0.03213, "epss_percentile": 0.86657}, "CVE-2014-4352": {"epss_score": 0.00042, "epss_percentile": 0.12701}, "CVE-2014-4353": {"epss_score": 0.00461, "epss_percentile": 0.63539}, "CVE-2014-4354": {"epss_score": 0.00301, "epss_percentile": 0.53022}, "CVE-2014-4356": {"epss_score": 0.00076, "epss_percentile": 0.23097}, "CVE-2014-4357": {"epss_score": 0.00075, "epss_percentile": 0.22951}, "CVE-2014-4361": {"epss_score": 0.00594, "epss_percentile": 0.68677}, "CVE-2014-4362": {"epss_score": 0.00594, "epss_percentile": 0.68677}, "CVE-2014-4363": {"epss_score": 0.00762, "epss_percentile": 0.72834}, "CVE-2014-4364": {"epss_score": 0.00498, "epss_percentile": 0.6524}, "CVE-2014-4366": {"epss_score": 0.00783, "epss_percentile": 0.73228}, "CVE-2014-4367": {"epss_score": 0.00075, "epss_percentile": 0.22951}, "CVE-2014-4368": {"epss_score": 0.00057, "epss_percentile": 0.18102}, "CVE-2014-4369": {"epss_score": 0.01042, "epss_percentile": 0.76972}, "CVE-2014-4371": {"epss_score": 0.00078, "epss_percentile": 0.23581}, "CVE-2014-4372": {"epss_score": 0.00038, "epss_percentile": 0.11272}, "CVE-2014-4373": {"epss_score": 0.00191, "epss_percentile": 0.41204}, "CVE-2014-4374": {"epss_score": 0.00502, "epss_percentile": 0.65416}, "CVE-2014-4375": {"epss_score": 0.00054, "epss_percentile": 0.17309}, "CVE-2014-4376": {"epss_score": 0.00962, "epss_percentile": 0.75989}, "CVE-2014-4377": {"epss_score": 0.11335, "epss_percentile": 0.93313}, "CVE-2014-4378": {"epss_score": 0.0208, "epss_percentile": 0.8353}, "CVE-2014-4379": {"epss_score": 0.01872, "epss_percentile": 0.82641}, "CVE-2014-4380": {"epss_score": 0.02385, "epss_percentile": 0.84577}, "CVE-2014-4381": {"epss_score": 0.01741, "epss_percentile": 0.82047}, "CVE-2014-4383": {"epss_score": 0.00629, "epss_percentile": 0.69674}, "CVE-2014-4384": {"epss_score": 0.00043, "epss_percentile": 0.12964}, "CVE-2014-4386": {"epss_score": 0.00049, "epss_percentile": 0.15607}, "CVE-2014-4388": {"epss_score": 0.00543, "epss_percentile": 0.67095}, "CVE-2014-4389": {"epss_score": 0.01745, "epss_percentile": 0.82069}, "CVE-2014-4390": {"epss_score": 0.00744, "epss_percentile": 0.72512}, "CVE-2014-4391": {"epss_score": 0.01066, "epss_percentile": 0.77216}, "CVE-2014-4393": {"epss_score": 0.06092, "epss_percentile": 0.90475}, "CVE-2014-4394": {"epss_score": 0.00257, "epss_percentile": 0.4892}, "CVE-2014-4395": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2014-4396": {"epss_score": 0.00257, "epss_percentile": 0.4892}, "CVE-2014-4397": {"epss_score": 0.00257, "epss_percentile": 0.4892}, "CVE-2014-4398": {"epss_score": 0.00257, "epss_percentile": 0.4892}, "CVE-2014-4399": {"epss_score": 0.00257, "epss_percentile": 0.4892}, "CVE-2014-4400": {"epss_score": 0.00257, "epss_percentile": 0.4892}, "CVE-2014-4401": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2014-4402": {"epss_score": 0.01205, "epss_percentile": 0.7851}, "CVE-2014-4403": {"epss_score": 0.00071, "epss_percentile": 0.2218}, "CVE-2014-4404": {"epss_score": 0.61995, "epss_percentile": 0.98271}, "CVE-2014-4405": {"epss_score": 0.01754, "epss_percentile": 0.82118}, "CVE-2014-4406": {"epss_score": 0.0057, "epss_percentile": 0.67971}, "CVE-2014-4407": {"epss_score": 0.00215, "epss_percentile": 0.4403}, "CVE-2014-4408": {"epss_score": 0.00044, "epss_percentile": 0.13591}, "CVE-2014-4409": {"epss_score": 0.00958, "epss_percentile": 0.7594}, "CVE-2014-4410": {"epss_score": 0.01114, "epss_percentile": 0.77703}, "CVE-2014-4411": {"epss_score": 0.01114, "epss_percentile": 0.77703}, "CVE-2014-4412": {"epss_score": 0.01114, "epss_percentile": 0.77703}, "CVE-2014-4413": {"epss_score": 0.01114, "epss_percentile": 0.77703}, "CVE-2014-4414": {"epss_score": 0.01114, "epss_percentile": 0.77703}, "CVE-2014-4415": {"epss_score": 0.01118, "epss_percentile": 0.77744}, "CVE-2014-4416": {"epss_score": 0.00257, "epss_percentile": 0.4892}, "CVE-2014-4417": {"epss_score": 0.00818, "epss_percentile": 0.73856}, "CVE-2014-4418": {"epss_score": 0.00457, "epss_percentile": 0.63373}, "CVE-2014-4419": {"epss_score": 0.00078, "epss_percentile": 0.23583}, "CVE-2014-4420": {"epss_score": 0.00078, "epss_percentile": 0.23583}, "CVE-2014-4421": {"epss_score": 0.00078, "epss_percentile": 0.23583}, "CVE-2014-4422": {"epss_score": 0.0169, "epss_percentile": 0.81776}, "CVE-2014-4423": {"epss_score": 0.00594, "epss_percentile": 0.68677}, "CVE-2014-4424": {"epss_score": 0.01162, "epss_percentile": 0.7815}, "CVE-2014-4425": {"epss_score": 0.00061, "epss_percentile": 0.19476}, "CVE-2014-4426": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2014-4427": {"epss_score": 0.00463, "epss_percentile": 0.63631}, "CVE-2014-4428": {"epss_score": 0.00945, "epss_percentile": 0.75798}, "CVE-2014-4430": {"epss_score": 0.00041, "epss_percentile": 0.1236}, "CVE-2014-4431": {"epss_score": 0.00073, "epss_percentile": 0.22661}, "CVE-2014-4432": {"epss_score": 0.00041, "epss_percentile": 0.1236}, "CVE-2014-4433": {"epss_score": 0.00061, "epss_percentile": 0.19301}, "CVE-2014-4434": {"epss_score": 0.00053, "epss_percentile": 0.16864}, "CVE-2014-4435": {"epss_score": 0.00061, "epss_percentile": 0.19476}, "CVE-2014-4436": {"epss_score": 0.00449, "epss_percentile": 0.63036}, "CVE-2014-4437": {"epss_score": 0.00463, "epss_percentile": 0.63631}, "CVE-2014-4438": {"epss_score": 0.00041, "epss_percentile": 0.12342}, "CVE-2014-4439": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2014-4440": {"epss_score": 0.0084, "epss_percentile": 0.74201}, "CVE-2014-4441": {"epss_score": 0.00666, "epss_percentile": 0.70694}, "CVE-2014-4442": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2014-4443": {"epss_score": 0.00977, "epss_percentile": 0.7623}, "CVE-2014-4444": {"epss_score": 0.00055, "epss_percentile": 0.17616}, "CVE-2014-4446": {"epss_score": 0.00118, "epss_percentile": 0.31512}, "CVE-2014-4447": {"epss_score": 0.00142, "epss_percentile": 0.34985}, "CVE-2014-4448": {"epss_score": 0.00046, "epss_percentile": 0.14169}, "CVE-2014-4449": {"epss_score": 0.0036, "epss_percentile": 0.57653}, "CVE-2014-4450": {"epss_score": 0.00144, "epss_percentile": 0.35314}, "CVE-2014-4451": {"epss_score": 0.00072, "epss_percentile": 0.22413}, "CVE-2014-4452": {"epss_score": 0.01069, "epss_percentile": 0.77247}, "CVE-2014-4453": {"epss_score": 0.00782, "epss_percentile": 0.73206}, "CVE-2014-4455": {"epss_score": 0.00063, "epss_percentile": 0.19814}, "CVE-2014-4457": {"epss_score": 0.01115, "epss_percentile": 0.7771}, "CVE-2014-4458": {"epss_score": 0.0056, "epss_percentile": 0.67634}, "CVE-2014-4459": {"epss_score": 0.02966, "epss_percentile": 0.86081}, "CVE-2014-4460": {"epss_score": 0.00072, "epss_percentile": 0.22293}, "CVE-2014-4461": {"epss_score": 0.0186, "epss_percentile": 0.82588}, "CVE-2014-4462": {"epss_score": 0.01266, "epss_percentile": 0.7901}, "CVE-2014-4463": {"epss_score": 0.00082, "epss_percentile": 0.24546}, "CVE-2014-4465": {"epss_score": 0.00977, "epss_percentile": 0.76218}, "CVE-2014-4466": {"epss_score": 0.01006, "epss_percentile": 0.76555}, "CVE-2014-4467": {"epss_score": 0.00205, "epss_percentile": 0.42714}, "CVE-2014-4468": {"epss_score": 0.00843, "epss_percentile": 0.74252}, "CVE-2014-4469": {"epss_score": 0.00843, "epss_percentile": 0.74252}, "CVE-2014-4470": {"epss_score": 0.00843, "epss_percentile": 0.74252}, "CVE-2014-4471": {"epss_score": 0.00843, "epss_percentile": 0.74252}, "CVE-2014-4472": {"epss_score": 0.00843, "epss_percentile": 0.74252}, "CVE-2014-4473": {"epss_score": 0.00843, "epss_percentile": 0.74252}, "CVE-2014-4474": {"epss_score": 0.00843, "epss_percentile": 0.74252}, "CVE-2014-4475": {"epss_score": 0.00843, "epss_percentile": 0.74252}, "CVE-2014-4476": {"epss_score": 0.00913, "epss_percentile": 0.75374}, "CVE-2014-4477": {"epss_score": 0.00913, "epss_percentile": 0.75374}, "CVE-2014-4479": {"epss_score": 0.00913, "epss_percentile": 0.75374}, "CVE-2014-4480": {"epss_score": 0.01934, "epss_percentile": 0.82956}, "CVE-2014-4481": {"epss_score": 0.08613, "epss_percentile": 0.92152}, "CVE-2014-4483": {"epss_score": 0.02074, "epss_percentile": 0.83498}, "CVE-2014-4484": {"epss_score": 0.03229, "epss_percentile": 0.86692}, "CVE-2014-4485": {"epss_score": 0.02977, "epss_percentile": 0.86107}, "CVE-2014-4486": {"epss_score": 0.01019, "epss_percentile": 0.76721}, "CVE-2014-4487": {"epss_score": 0.02421, "epss_percentile": 0.84703}, "CVE-2014-4488": {"epss_score": 0.01797, "epss_percentile": 0.8231}, "CVE-2014-4489": {"epss_score": 0.01019, "epss_percentile": 0.76721}, "CVE-2014-4491": {"epss_score": 0.00524, "epss_percentile": 0.66338}, "CVE-2014-4492": {"epss_score": 0.24341, "epss_percentile": 0.95908}, "CVE-2014-4493": {"epss_score": 0.00213, "epss_percentile": 0.43853}, "CVE-2014-4494": {"epss_score": 0.00213, "epss_percentile": 0.43853}, "CVE-2014-4495": {"epss_score": 0.00834, "epss_percentile": 0.741}, "CVE-2014-4496": {"epss_score": 0.00664, "epss_percentile": 0.70629}, "CVE-2014-4497": {"epss_score": 0.01099, "epss_percentile": 0.77549}, "CVE-2014-4498": {"epss_score": 0.00071, "epss_percentile": 0.22076}, "CVE-2014-4499": {"epss_score": 0.00061, "epss_percentile": 0.19284}, "CVE-2014-4501": {"epss_score": 0.0022, "epss_percentile": 0.44551}, "CVE-2014-4502": {"epss_score": 0.00517, "epss_percentile": 0.66062}, "CVE-2014-4503": {"epss_score": 0.00305, "epss_percentile": 0.53327}, "CVE-2014-4505": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-4506": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2014-4507": {"epss_score": 0.00836, "epss_percentile": 0.74135}, "CVE-2014-4508": {"epss_score": 0.00043, "epss_percentile": 0.12963}, "CVE-2014-4509": {"epss_score": 0.00071, "epss_percentile": 0.22009}, "CVE-2014-4510": {"epss_score": 0.00268, "epss_percentile": 0.50095}, "CVE-2014-4511": {"epss_score": 0.84126, "epss_percentile": 0.99275}, "CVE-2014-4513": {"epss_score": 0.03718, "epss_percentile": 0.87617}, "CVE-2014-4514": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4515": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4516": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4517": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4518": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4519": {"epss_score": 0.00235, "epss_percentile": 0.46325}, "CVE-2014-4520": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2014-4521": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4522": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4523": {"epss_score": 0.00235, "epss_percentile": 0.46325}, "CVE-2014-4524": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2014-4525": {"epss_score": 0.00221, "epss_percentile": 0.44638}, "CVE-2014-4526": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4527": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4528": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4529": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4530": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2014-4531": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4532": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4533": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4534": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4535": {"epss_score": 0.03802, "epss_percentile": 0.87746}, "CVE-2014-4536": {"epss_score": 0.02649, "epss_percentile": 0.85341}, "CVE-2014-4537": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4538": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4539": {"epss_score": 0.0161, "epss_percentile": 0.81321}, "CVE-2014-4540": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4541": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4542": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4543": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4544": {"epss_score": 0.02584, "epss_percentile": 0.85162}, "CVE-2014-4545": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4546": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4547": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4548": {"epss_score": 0.00235, "epss_percentile": 0.46325}, "CVE-2014-4549": {"epss_score": 0.00198, "epss_percentile": 0.42023}, "CVE-2014-4550": {"epss_score": 0.02712, "epss_percentile": 0.85502}, "CVE-2014-4551": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4552": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4553": {"epss_score": 0.00172, "epss_percentile": 0.38955}, "CVE-2014-4554": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2014-4555": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4556": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4557": {"epss_score": 0.00239, "epss_percentile": 0.46871}, "CVE-2014-4558": {"epss_score": 0.04411, "epss_percentile": 0.8866}, "CVE-2014-4559": {"epss_score": 0.00235, "epss_percentile": 0.46325}, "CVE-2014-4560": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4561": {"epss_score": 0.12801, "epss_percentile": 0.93778}, "CVE-2014-4563": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4564": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4565": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4566": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4567": {"epss_score": 0.00221, "epss_percentile": 0.44638}, "CVE-2014-4568": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4569": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2014-4570": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2014-4571": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4572": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4573": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4574": {"epss_score": 0.0027, "epss_percentile": 0.50203}, "CVE-2014-4575": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4576": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4577": {"epss_score": 0.06185, "epss_percentile": 0.90542}, "CVE-2014-4578": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4579": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4580": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4581": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4582": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4583": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4584": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4585": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4586": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4587": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4588": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4589": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4590": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4591": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4592": {"epss_score": 0.03802, "epss_percentile": 0.87746}, "CVE-2014-4593": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4594": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2014-4595": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4596": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4597": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4598": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2014-4599": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4600": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4601": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4602": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4603": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4604": {"epss_score": 0.00239, "epss_percentile": 0.46871}, "CVE-2014-4605": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4606": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4607": {"epss_score": 0.11033, "epss_percentile": 0.93195}, "CVE-2014-4608": {"epss_score": 0.08604, "epss_percentile": 0.92145}, "CVE-2014-4609": {"epss_score": 0.02154, "epss_percentile": 0.83801}, "CVE-2014-4610": {"epss_score": 0.02978, "epss_percentile": 0.86114}, "CVE-2014-4611": {"epss_score": 0.10105, "epss_percentile": 0.92851}, "CVE-2014-4612": {"epss_score": 0.0054, "epss_percentile": 0.67022}, "CVE-2014-4613": {"epss_score": 0.03346, "epss_percentile": 0.86952}, "CVE-2014-4614": {"epss_score": 0.00176, "epss_percentile": 0.39419}, "CVE-2014-4615": {"epss_score": 0.0075, "epss_percentile": 0.72613}, "CVE-2014-4616": {"epss_score": 0.00558, "epss_percentile": 0.67602}, "CVE-2014-4617": {"epss_score": 0.08032, "epss_percentile": 0.91843}, "CVE-2014-4618": {"epss_score": 0.0102, "epss_percentile": 0.76742}, "CVE-2014-4619": {"epss_score": 0.02227, "epss_percentile": 0.84072}, "CVE-2014-4620": {"epss_score": 0.00064, "epss_percentile": 0.20163}, "CVE-2014-4621": {"epss_score": 0.00751, "epss_percentile": 0.72646}, "CVE-2014-4622": {"epss_score": 0.00448, "epss_percentile": 0.63018}, "CVE-2014-4623": {"epss_score": 0.00329, "epss_percentile": 0.55411}, "CVE-2014-4624": {"epss_score": 0.00896, "epss_percentile": 0.75115}, "CVE-2014-4626": {"epss_score": 0.01198, "epss_percentile": 0.78452}, "CVE-2014-4627": {"epss_score": 0.0131, "epss_percentile": 0.79363}, "CVE-2014-4628": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-4629": {"epss_score": 0.00684, "epss_percentile": 0.71121}, "CVE-2014-4630": {"epss_score": 0.00187, "epss_percentile": 0.40804}, "CVE-2014-4631": {"epss_score": 0.00999, "epss_percentile": 0.76481}, "CVE-2014-4632": {"epss_score": 0.00143, "epss_percentile": 0.35201}, "CVE-2014-4633": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-4634": {"epss_score": 0.0006, "epss_percentile": 0.19143}, "CVE-2014-4635": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-4636": {"epss_score": 0.00138, "epss_percentile": 0.34346}, "CVE-2014-4637": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2014-4638": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2014-4639": {"epss_score": 0.00347, "epss_percentile": 0.56781}, "CVE-2014-4643": {"epss_score": 0.22409, "epss_percentile": 0.95632}, "CVE-2014-4644": {"epss_score": 0.00946, "epss_percentile": 0.7581}, "CVE-2014-4645": {"epss_score": 0.05219, "epss_percentile": 0.89622}, "CVE-2014-4646": {"epss_score": 0.04332, "epss_percentile": 0.8856}, "CVE-2014-4647": {"epss_score": 0.02791, "epss_percentile": 0.85668}, "CVE-2014-4648": {"epss_score": 0.00436, "epss_percentile": 0.62468}, "CVE-2014-4649": {"epss_score": 0.00267, "epss_percentile": 0.49983}, "CVE-2014-4650": {"epss_score": 0.06019, "epss_percentile": 0.90414}, "CVE-2014-4651": {"epss_score": 0.02087, "epss_percentile": 0.83552}, "CVE-2014-4652": {"epss_score": 0.00051, "epss_percentile": 0.16115}, "CVE-2014-4653": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2014-4654": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2014-4655": {"epss_score": 0.00038, "epss_percentile": 0.11134}, "CVE-2014-4656": {"epss_score": 0.00075, "epss_percentile": 0.2306}, "CVE-2014-4657": {"epss_score": 0.02239, "epss_percentile": 0.84108}, "CVE-2014-4658": {"epss_score": 0.00119, "epss_percentile": 0.3166}, "CVE-2014-4659": {"epss_score": 0.00081, "epss_percentile": 0.24256}, "CVE-2014-4660": {"epss_score": 0.00119, "epss_percentile": 0.31539}, "CVE-2014-4661": {"epss_score": 0.01385, "epss_percentile": 0.79907}, "CVE-2014-4663": {"epss_score": 0.19056, "epss_percentile": 0.95119}, "CVE-2014-4664": {"epss_score": 0.00567, "epss_percentile": 0.67838}, "CVE-2014-4667": {"epss_score": 0.14138, "epss_percentile": 0.94143}, "CVE-2014-4668": {"epss_score": 0.00604, "epss_percentile": 0.6894}, "CVE-2014-4669": {"epss_score": 0.00348, "epss_percentile": 0.56846}, "CVE-2014-4670": {"epss_score": 0.00336, "epss_percentile": 0.55949}, "CVE-2014-4671": {"epss_score": 0.35827, "epss_percentile": 0.96936}, "CVE-2014-4672": {"epss_score": 0.0057, "epss_percentile": 0.67964}, "CVE-2014-4677": {"epss_score": 0.00175, "epss_percentile": 0.39314}, "CVE-2014-4678": {"epss_score": 0.04731, "epss_percentile": 0.89069}, "CVE-2014-4682": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2014-4683": {"epss_score": 0.00157, "epss_percentile": 0.37136}, "CVE-2014-4684": {"epss_score": 0.00366, "epss_percentile": 0.58066}, "CVE-2014-4685": {"epss_score": 0.00054, "epss_percentile": 0.17077}, "CVE-2014-4686": {"epss_score": 0.00231, "epss_percentile": 0.45842}, "CVE-2014-4687": {"epss_score": 0.00087, "epss_percentile": 0.25493}, "CVE-2014-4688": {"epss_score": 0.01993, "epss_percentile": 0.83186}, "CVE-2014-4689": {"epss_score": 0.0008, "epss_percentile": 0.2403}, "CVE-2014-4690": {"epss_score": 0.00185, "epss_percentile": 0.40578}, "CVE-2014-4691": {"epss_score": 0.00115, "epss_percentile": 0.30908}, "CVE-2014-4692": {"epss_score": 0.00072, "epss_percentile": 0.22455}, "CVE-2014-4693": {"epss_score": 0.00055, "epss_percentile": 0.17544}, "CVE-2014-4694": {"epss_score": 0.00055, "epss_percentile": 0.17544}, "CVE-2014-4695": {"epss_score": 0.00047, "epss_percentile": 0.14685}, "CVE-2014-4696": {"epss_score": 0.00047, "epss_percentile": 0.14685}, "CVE-2014-4698": {"epss_score": 0.00491, "epss_percentile": 0.64962}, "CVE-2014-4699": {"epss_score": 0.01327, "epss_percentile": 0.79491}, "CVE-2014-4700": {"epss_score": 0.00262, "epss_percentile": 0.49341}, "CVE-2014-4701": {"epss_score": 0.00063, "epss_percentile": 0.19814}, "CVE-2014-4702": {"epss_score": 0.00111, "epss_percentile": 0.30317}, "CVE-2014-4703": {"epss_score": 0.00443, "epss_percentile": 0.62766}, "CVE-2014-4705": {"epss_score": 0.00307, "epss_percentile": 0.53467}, "CVE-2014-4706": {"epss_score": 0.00172, "epss_percentile": 0.39013}, "CVE-2014-4707": {"epss_score": 0.00181, "epss_percentile": 0.40075}, "CVE-2014-4710": {"epss_score": 0.03324, "epss_percentile": 0.86918}, "CVE-2014-4715": {"epss_score": 0.00594, "epss_percentile": 0.68659}, "CVE-2014-4716": {"epss_score": 0.002, "epss_percentile": 0.42221}, "CVE-2014-4717": {"epss_score": 0.00297, "epss_percentile": 0.52697}, "CVE-2014-4718": {"epss_score": 0.02121, "epss_percentile": 0.8368}, "CVE-2014-4719": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-4720": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-4721": {"epss_score": 0.09939, "epss_percentile": 0.92782}, "CVE-2014-4722": {"epss_score": 0.00403, "epss_percentile": 0.60342}, "CVE-2014-4723": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4724": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4725": {"epss_score": 0.80303, "epss_percentile": 0.9908}, "CVE-2014-4726": {"epss_score": 0.00352, "epss_percentile": 0.57117}, "CVE-2014-4727": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2014-4728": {"epss_score": 0.0118, "epss_percentile": 0.78302}, "CVE-2014-4734": {"epss_score": 0.00378, "epss_percentile": 0.58778}, "CVE-2014-4735": {"epss_score": 0.00378, "epss_percentile": 0.58778}, "CVE-2014-4736": {"epss_score": 0.01978, "epss_percentile": 0.83129}, "CVE-2014-4737": {"epss_score": 0.00378, "epss_percentile": 0.58778}, "CVE-2014-4738": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2014-4741": {"epss_score": 0.01735, "epss_percentile": 0.82008}, "CVE-2014-4742": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2014-4743": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-4744": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-4746": {"epss_score": 0.00383, "epss_percentile": 0.59101}, "CVE-2014-4747": {"epss_score": 0.00061, "epss_percentile": 0.19493}, "CVE-2014-4748": {"epss_score": 0.00265, "epss_percentile": 0.49789}, "CVE-2014-4749": {"epss_score": 0.00236, "epss_percentile": 0.46422}, "CVE-2014-4750": {"epss_score": 0.00162, "epss_percentile": 0.37667}, "CVE-2014-4751": {"epss_score": 0.00322, "epss_percentile": 0.54826}, "CVE-2014-4752": {"epss_score": 0.02507, "epss_percentile": 0.84939}, "CVE-2014-4756": {"epss_score": 0.00275, "epss_percentile": 0.50672}, "CVE-2014-4757": {"epss_score": 0.00054, "epss_percentile": 0.17362}, "CVE-2014-4758": {"epss_score": 0.00202, "epss_percentile": 0.42423}, "CVE-2014-4759": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2014-4760": {"epss_score": 0.00328, "epss_percentile": 0.55261}, "CVE-2014-4761": {"epss_score": 0.00226, "epss_percentile": 0.45342}, "CVE-2014-4762": {"epss_score": 0.00162, "epss_percentile": 0.37634}, "CVE-2014-4763": {"epss_score": 0.00208, "epss_percentile": 0.43262}, "CVE-2014-4764": {"epss_score": 0.01128, "epss_percentile": 0.77827}, "CVE-2014-4765": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2014-4766": {"epss_score": 0.00254, "epss_percentile": 0.48524}, "CVE-2014-4767": {"epss_score": 0.01078, "epss_percentile": 0.77353}, "CVE-2014-4768": {"epss_score": 0.0036, "epss_percentile": 0.57662}, "CVE-2014-4769": {"epss_score": 0.00271, "epss_percentile": 0.50333}, "CVE-2014-4770": {"epss_score": 0.0035, "epss_percentile": 0.56967}, "CVE-2014-4771": {"epss_score": 0.0035, "epss_percentile": 0.56958}, "CVE-2014-4774": {"epss_score": 0.00103, "epss_percentile": 0.28976}, "CVE-2014-4775": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2014-4776": {"epss_score": 0.00195, "epss_percentile": 0.41649}, "CVE-2014-4778": {"epss_score": 0.00218, "epss_percentile": 0.44413}, "CVE-2014-4781": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2014-4782": {"epss_score": 0.00167, "epss_percentile": 0.38292}, "CVE-2014-4783": {"epss_score": 0.00126, "epss_percentile": 0.32779}, "CVE-2014-4784": {"epss_score": 0.003, "epss_percentile": 0.52908}, "CVE-2014-4785": {"epss_score": 0.00099, "epss_percentile": 0.28388}, "CVE-2014-4786": {"epss_score": 0.00223, "epss_percentile": 0.44965}, "CVE-2014-4787": {"epss_score": 0.00241, "epss_percentile": 0.47296}, "CVE-2014-4788": {"epss_score": 0.00286, "epss_percentile": 0.51779}, "CVE-2014-4789": {"epss_score": 0.00497, "epss_percentile": 0.65192}, "CVE-2014-4790": {"epss_score": 0.002, "epss_percentile": 0.42267}, "CVE-2014-4792": {"epss_score": 0.00514, "epss_percentile": 0.65963}, "CVE-2014-4793": {"epss_score": 0.00191, "epss_percentile": 0.41201}, "CVE-2014-4801": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-4802": {"epss_score": 0.00159, "epss_percentile": 0.37303}, "CVE-2014-4803": {"epss_score": 0.00141, "epss_percentile": 0.34947}, "CVE-2014-4804": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2014-4805": {"epss_score": 0.0005, "epss_percentile": 0.15712}, "CVE-2014-4806": {"epss_score": 0.00059, "epss_percentile": 0.18643}, "CVE-2014-4807": {"epss_score": 0.00406, "epss_percentile": 0.60564}, "CVE-2014-4808": {"epss_score": 0.01607, "epss_percentile": 0.81307}, "CVE-2014-4809": {"epss_score": 0.01128, "epss_percentile": 0.77827}, "CVE-2014-4810": {"epss_score": 0.0025, "epss_percentile": 0.48107}, "CVE-2014-4811": {"epss_score": 0.00735, "epss_percentile": 0.72288}, "CVE-2014-4812": {"epss_score": 0.0011, "epss_percentile": 0.30208}, "CVE-2014-4813": {"epss_score": 0.00038, "epss_percentile": 0.11417}, "CVE-2014-4814": {"epss_score": 0.0058, "epss_percentile": 0.68245}, "CVE-2014-4815": {"epss_score": 0.00201, "epss_percentile": 0.42329}, "CVE-2014-4816": {"epss_score": 0.00139, "epss_percentile": 0.3466}, "CVE-2014-4817": {"epss_score": 0.00152, "epss_percentile": 0.36499}, "CVE-2014-4818": {"epss_score": 0.00031, "epss_percentile": 0.08501}, "CVE-2014-4819": {"epss_score": 0.00186, "epss_percentile": 0.40609}, "CVE-2014-4820": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2014-4821": {"epss_score": 0.00321, "epss_percentile": 0.5474}, "CVE-2014-4822": {"epss_score": 0.0005, "epss_percentile": 0.15712}, "CVE-2014-4823": {"epss_score": 0.07644, "epss_percentile": 0.91599}, "CVE-2014-4824": {"epss_score": 0.00314, "epss_percentile": 0.54095}, "CVE-2014-4825": {"epss_score": 0.00236, "epss_percentile": 0.46422}, "CVE-2014-4826": {"epss_score": 0.00254, "epss_percentile": 0.48524}, "CVE-2014-4827": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2014-4828": {"epss_score": 0.00151, "epss_percentile": 0.36251}, "CVE-2014-4829": {"epss_score": 0.00103, "epss_percentile": 0.28976}, "CVE-2014-4830": {"epss_score": 0.00254, "epss_percentile": 0.48524}, "CVE-2014-4831": {"epss_score": 0.00201, "epss_percentile": 0.42306}, "CVE-2014-4832": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2014-4833": {"epss_score": 0.00349, "epss_percentile": 0.56905}, "CVE-2014-4834": {"epss_score": 0.00759, "epss_percentile": 0.72788}, "CVE-2014-4835": {"epss_score": 0.0005, "epss_percentile": 0.15971}, "CVE-2014-4836": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-4837": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-4838": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-4839": {"epss_score": 0.00088, "epss_percentile": 0.25689}, "CVE-2014-4840": {"epss_score": 0.02161, "epss_percentile": 0.83827}, "CVE-2014-4843": {"epss_score": 0.00156, "epss_percentile": 0.36967}, "CVE-2014-4844": {"epss_score": 0.00216, "epss_percentile": 0.44157}, "CVE-2014-4845": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4846": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4847": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4848": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4849": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-4850": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2014-4851": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2014-4852": {"epss_score": 0.01016, "epss_percentile": 0.76676}, "CVE-2014-4853": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-4854": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4855": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4856": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-4857": {"epss_score": 0.00607, "epss_percentile": 0.69042}, "CVE-2014-4858": {"epss_score": 0.00486, "epss_percentile": 0.64771}, "CVE-2014-4859": {"epss_score": 0.00039, "epss_percentile": 0.11707}, "CVE-2014-4860": {"epss_score": 0.00037, "epss_percentile": 0.10907}, "CVE-2014-4861": {"epss_score": 0.00478, "epss_percentile": 0.64385}, "CVE-2014-4862": {"epss_score": 0.54268, "epss_percentile": 0.97918}, "CVE-2014-4863": {"epss_score": 0.23552, "epss_percentile": 0.9579}, "CVE-2014-4864": {"epss_score": 0.00213, "epss_percentile": 0.43899}, "CVE-2014-4865": {"epss_score": 0.00273, "epss_percentile": 0.50425}, "CVE-2014-4867": {"epss_score": 0.00069, "epss_percentile": 0.21636}, "CVE-2014-4868": {"epss_score": 0.00195, "epss_percentile": 0.41605}, "CVE-2014-4869": {"epss_score": 0.00247, "epss_percentile": 0.47904}, "CVE-2014-4870": {"epss_score": 0.00097, "epss_percentile": 0.27467}, "CVE-2014-4871": {"epss_score": 0.00909, "epss_percentile": 0.75291}, "CVE-2014-4872": {"epss_score": 0.82177, "epss_percentile": 0.99178}, "CVE-2014-4873": {"epss_score": 0.04918, "epss_percentile": 0.89288}, "CVE-2014-4874": {"epss_score": 0.16055, "epss_percentile": 0.94565}, "CVE-2014-4875": {"epss_score": 0.00307, "epss_percentile": 0.53564}, "CVE-2014-4876": {"epss_score": 0.01364, "epss_percentile": 0.79773}, "CVE-2014-4877": {"epss_score": 0.69365, "epss_percentile": 0.98584}, "CVE-2014-4880": {"epss_score": 0.77998, "epss_percentile": 0.98964}, "CVE-2014-4881": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4882": {"epss_score": 0.00599, "epss_percentile": 0.68799}, "CVE-2014-4883": {"epss_score": 0.00114, "epss_percentile": 0.30758}, "CVE-2014-4884": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4885": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4887": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4888": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4889": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4890": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4891": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4892": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4894": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4895": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4896": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4897": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4898": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4899": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4900": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4901": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4903": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4904": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4905": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4906": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-4907": {"epss_score": 0.00431, "epss_percentile": 0.62053}, "CVE-2014-4908": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2014-4909": {"epss_score": 0.09187, "epss_percentile": 0.92436}, "CVE-2014-4910": {"epss_score": 0.00302, "epss_percentile": 0.53108}, "CVE-2014-4911": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2014-4912": {"epss_score": 0.08482, "epss_percentile": 0.92074}, "CVE-2014-4913": {"epss_score": 0.00565, "epss_percentile": 0.678}, "CVE-2014-4914": {"epss_score": 0.03436, "epss_percentile": 0.87133}, "CVE-2014-4919": {"epss_score": 0.00193, "epss_percentile": 0.41403}, "CVE-2014-4925": {"epss_score": 0.0028, "epss_percentile": 0.51006}, "CVE-2014-4927": {"epss_score": 0.20304, "epss_percentile": 0.95319}, "CVE-2014-4928": {"epss_score": 0.0037, "epss_percentile": 0.58303}, "CVE-2014-4929": {"epss_score": 0.00588, "epss_percentile": 0.68507}, "CVE-2014-4930": {"epss_score": 0.00447, "epss_percentile": 0.62978}, "CVE-2014-4932": {"epss_score": 0.00269, "epss_percentile": 0.50163}, "CVE-2014-4936": {"epss_score": 0.18948, "epss_percentile": 0.95101}, "CVE-2014-4937": {"epss_score": 0.06385, "epss_percentile": 0.90716}, "CVE-2014-4938": {"epss_score": 0.01741, "epss_percentile": 0.82048}, "CVE-2014-4939": {"epss_score": 0.01486, "epss_percentile": 0.80608}, "CVE-2014-4940": {"epss_score": 0.57666, "epss_percentile": 0.98077}, "CVE-2014-4941": {"epss_score": 0.01851, "epss_percentile": 0.82536}, "CVE-2014-4942": {"epss_score": 0.02447, "epss_percentile": 0.84772}, "CVE-2014-4943": {"epss_score": 0.01034, "epss_percentile": 0.76892}, "CVE-2014-4944": {"epss_score": 0.00967, "epss_percentile": 0.76066}, "CVE-2014-4945": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2014-4946": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2014-4947": {"epss_score": 0.00665, "epss_percentile": 0.70662}, "CVE-2014-4948": {"epss_score": 0.00545, "epss_percentile": 0.67175}, "CVE-2014-4954": {"epss_score": 0.00253, "epss_percentile": 0.48437}, "CVE-2014-4955": {"epss_score": 0.00257, "epss_percentile": 0.4889}, "CVE-2014-4958": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-4959": {"epss_score": 0.03115, "epss_percentile": 0.86434}, "CVE-2014-4960": {"epss_score": 0.00943, "epss_percentile": 0.7578}, "CVE-2014-4962": {"epss_score": 0.03733, "epss_percentile": 0.87647}, "CVE-2014-4963": {"epss_score": 0.03861, "epss_percentile": 0.87865}, "CVE-2014-4964": {"epss_score": 0.00467, "epss_percentile": 0.63812}, "CVE-2014-4965": {"epss_score": 0.04055, "epss_percentile": 0.88184}, "CVE-2014-4966": {"epss_score": 0.04747, "epss_percentile": 0.89099}, "CVE-2014-4967": {"epss_score": 0.04747, "epss_percentile": 0.89099}, "CVE-2014-4968": {"epss_score": 0.04317, "epss_percentile": 0.88539}, "CVE-2014-4971": {"epss_score": 0.18672, "epss_percentile": 0.9505}, "CVE-2014-4972": {"epss_score": 0.09369, "epss_percentile": 0.9252}, "CVE-2014-4973": {"epss_score": 0.00062, "epss_percentile": 0.19696}, "CVE-2014-4974": {"epss_score": 0.00063, "epss_percentile": 0.2009}, "CVE-2014-4975": {"epss_score": 0.03449, "epss_percentile": 0.87161}, "CVE-2014-4976": {"epss_score": 0.03128, "epss_percentile": 0.86461}, "CVE-2014-4977": {"epss_score": 0.84481, "epss_percentile": 0.99291}, "CVE-2014-4978": {"epss_score": 0.00049, "epss_percentile": 0.15371}, "CVE-2014-4979": {"epss_score": 0.03601, "epss_percentile": 0.87411}, "CVE-2014-4980": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2014-4981": {"epss_score": 0.38682, "epss_percentile": 0.97114}, "CVE-2014-4982": {"epss_score": 0.03445, "epss_percentile": 0.87145}, "CVE-2014-4984": {"epss_score": 0.03503, "epss_percentile": 0.87253}, "CVE-2014-4986": {"epss_score": 0.00339, "epss_percentile": 0.56184}, "CVE-2014-4987": {"epss_score": 0.00192, "epss_percentile": 0.41365}, "CVE-2014-4991": {"epss_score": 0.00078, "epss_percentile": 0.23619}, "CVE-2014-4992": {"epss_score": 0.00054, "epss_percentile": 0.17061}, "CVE-2014-4993": {"epss_score": 0.00064, "epss_percentile": 0.20389}, "CVE-2014-4994": {"epss_score": 0.00052, "epss_percentile": 0.16612}, "CVE-2014-4995": {"epss_score": 0.00054, "epss_percentile": 0.17092}, "CVE-2014-4996": {"epss_score": 0.00059, "epss_percentile": 0.18782}, "CVE-2014-4997": {"epss_score": 0.00078, "epss_percentile": 0.23619}, "CVE-2014-4998": {"epss_score": 0.00054, "epss_percentile": 0.17061}, "CVE-2014-4999": {"epss_score": 0.00054, "epss_percentile": 0.17061}, "CVE-2014-5000": {"epss_score": 0.00054, "epss_percentile": 0.17061}, "CVE-2014-5001": {"epss_score": 0.00054, "epss_percentile": 0.17061}, "CVE-2014-5002": {"epss_score": 0.00078, "epss_percentile": 0.2373}, "CVE-2014-5003": {"epss_score": 0.00052, "epss_percentile": 0.16612}, "CVE-2014-5004": {"epss_score": 0.00076, "epss_percentile": 0.23161}, "CVE-2014-5005": {"epss_score": 0.85825, "epss_percentile": 0.99352}, "CVE-2014-5006": {"epss_score": 0.61865, "epss_percentile": 0.98264}, "CVE-2014-5007": {"epss_score": 0.51612, "epss_percentile": 0.97789}, "CVE-2014-5008": {"epss_score": 0.05547, "epss_percentile": 0.89983}, "CVE-2014-5009": {"epss_score": 0.02686, "epss_percentile": 0.85426}, "CVE-2014-5011": {"epss_score": 0.00184, "epss_percentile": 0.40405}, "CVE-2014-5012": {"epss_score": 0.00136, "epss_percentile": 0.34168}, "CVE-2014-5013": {"epss_score": 0.25607, "epss_percentile": 0.9605}, "CVE-2014-5014": {"epss_score": 0.0228, "epss_percentile": 0.84244}, "CVE-2014-5015": {"epss_score": 0.00573, "epss_percentile": 0.68039}, "CVE-2014-5016": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-5017": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2014-5018": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2014-5019": {"epss_score": 0.00375, "epss_percentile": 0.58634}, "CVE-2014-5020": {"epss_score": 0.00114, "epss_percentile": 0.30852}, "CVE-2014-5021": {"epss_score": 0.00227, "epss_percentile": 0.45459}, "CVE-2014-5022": {"epss_score": 0.00261, "epss_percentile": 0.49304}, "CVE-2014-5023": {"epss_score": 0.03963, "epss_percentile": 0.88017}, "CVE-2014-5024": {"epss_score": 0.01364, "epss_percentile": 0.79772}, "CVE-2014-5025": {"epss_score": 0.00453, "epss_percentile": 0.63226}, "CVE-2014-5026": {"epss_score": 0.00347, "epss_percentile": 0.56756}, "CVE-2014-5027": {"epss_score": 0.00516, "epss_percentile": 0.66028}, "CVE-2014-5028": {"epss_score": 0.00468, "epss_percentile": 0.63914}, "CVE-2014-5029": {"epss_score": 0.00049, "epss_percentile": 0.1556}, "CVE-2014-5030": {"epss_score": 0.00052, "epss_percentile": 0.16386}, "CVE-2014-5031": {"epss_score": 0.01618, "epss_percentile": 0.81368}, "CVE-2014-5032": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2014-5033": {"epss_score": 0.00034, "epss_percentile": 0.09554}, "CVE-2014-5034": {"epss_score": 0.00173, "epss_percentile": 0.39097}, "CVE-2014-5035": {"epss_score": 0.00777, "epss_percentile": 0.7312}, "CVE-2014-5036": {"epss_score": 0.00061, "epss_percentile": 0.19284}, "CVE-2014-5037": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2014-5038": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2014-5039": {"epss_score": 0.00594, "epss_percentile": 0.68669}, "CVE-2014-5040": {"epss_score": 0.00093, "epss_percentile": 0.26664}, "CVE-2014-5044": {"epss_score": 0.03974, "epss_percentile": 0.88045}, "CVE-2014-5045": {"epss_score": 0.00029, "epss_percentile": 0.07651}, "CVE-2014-5068": {"epss_score": 0.00843, "epss_percentile": 0.74268}, "CVE-2014-5069": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2014-5070": {"epss_score": 0.0058, "epss_percentile": 0.68241}, "CVE-2014-5071": {"epss_score": 0.00421, "epss_percentile": 0.61529}, "CVE-2014-5072": {"epss_score": 0.00113, "epss_percentile": 0.30616}, "CVE-2014-5073": {"epss_score": 0.88269, "epss_percentile": 0.99464}, "CVE-2014-5074": {"epss_score": 0.13713, "epss_percentile": 0.94041}, "CVE-2014-5075": {"epss_score": 0.00182, "epss_percentile": 0.40156}, "CVE-2014-5076": {"epss_score": 0.00373, "epss_percentile": 0.58527}, "CVE-2014-5077": {"epss_score": 0.14696, "epss_percentile": 0.94267}, "CVE-2014-5081": {"epss_score": 0.0684, "epss_percentile": 0.91061}, "CVE-2014-5082": {"epss_score": 0.024, "epss_percentile": 0.84638}, "CVE-2014-5083": {"epss_score": 0.06685, "epss_percentile": 0.90944}, "CVE-2014-5084": {"epss_score": 0.06724, "epss_percentile": 0.9097}, "CVE-2014-5085": {"epss_score": 0.06685, "epss_percentile": 0.90944}, "CVE-2014-5086": {"epss_score": 0.06697, "epss_percentile": 0.90954}, "CVE-2014-5087": {"epss_score": 0.15835, "epss_percentile": 0.94516}, "CVE-2014-5088": {"epss_score": 0.00608, "epss_percentile": 0.69065}, "CVE-2014-5089": {"epss_score": 0.01016, "epss_percentile": 0.76676}, "CVE-2014-5090": {"epss_score": 0.07051, "epss_percentile": 0.91213}, "CVE-2014-5091": {"epss_score": 0.46943, "epss_percentile": 0.97564}, "CVE-2014-5092": {"epss_score": 0.0551, "epss_percentile": 0.89945}, "CVE-2014-5093": {"epss_score": 0.12189, "epss_percentile": 0.93598}, "CVE-2014-5094": {"epss_score": 0.07149, "epss_percentile": 0.91285}, "CVE-2014-5097": {"epss_score": 0.0096, "epss_percentile": 0.75967}, "CVE-2014-5098": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2014-5100": {"epss_score": 0.01941, "epss_percentile": 0.82983}, "CVE-2014-5101": {"epss_score": 0.00589, "epss_percentile": 0.68533}, "CVE-2014-5102": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2014-5103": {"epss_score": 0.00447, "epss_percentile": 0.62978}, "CVE-2014-5104": {"epss_score": 0.01068, "epss_percentile": 0.77241}, "CVE-2014-5105": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-5106": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-5107": {"epss_score": 0.01303, "epss_percentile": 0.79311}, "CVE-2014-5108": {"epss_score": 0.00449, "epss_percentile": 0.63052}, "CVE-2014-5109": {"epss_score": 0.00216, "epss_percentile": 0.44191}, "CVE-2014-5110": {"epss_score": 0.003, "epss_percentile": 0.52985}, "CVE-2014-5111": {"epss_score": 0.66663, "epss_percentile": 0.98473}, "CVE-2014-5112": {"epss_score": 0.07201, "epss_percentile": 0.91317}, "CVE-2014-5113": {"epss_score": 0.00334, "epss_percentile": 0.55726}, "CVE-2014-5114": {"epss_score": 0.00431, "epss_percentile": 0.62038}, "CVE-2014-5115": {"epss_score": 0.07192, "epss_percentile": 0.91312}, "CVE-2014-5116": {"epss_score": 0.06256, "epss_percentile": 0.90617}, "CVE-2014-5117": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2014-5118": {"epss_score": 0.0005, "epss_percentile": 0.15957}, "CVE-2014-5119": {"epss_score": 0.17197, "epss_percentile": 0.94796}, "CVE-2014-5120": {"epss_score": 0.08338, "epss_percentile": 0.91997}, "CVE-2014-5121": {"epss_score": 0.00292, "epss_percentile": 0.52223}, "CVE-2014-5122": {"epss_score": 0.00317, "epss_percentile": 0.54352}, "CVE-2014-5127": {"epss_score": 0.00347, "epss_percentile": 0.56781}, "CVE-2014-5128": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2014-5129": {"epss_score": 0.00498, "epss_percentile": 0.65218}, "CVE-2014-5130": {"epss_score": 0.00926, "epss_percentile": 0.75551}, "CVE-2014-5131": {"epss_score": 0.00926, "epss_percentile": 0.75551}, "CVE-2014-5132": {"epss_score": 0.00202, "epss_percentile": 0.42438}, "CVE-2014-5136": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-5137": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2014-5138": {"epss_score": 0.00391, "epss_percentile": 0.59623}, "CVE-2014-5139": {"epss_score": 0.21083, "epss_percentile": 0.95461}, "CVE-2014-5140": {"epss_score": 0.01106, "epss_percentile": 0.77617}, "CVE-2014-5144": {"epss_score": 0.00252, "epss_percentile": 0.48352}, "CVE-2014-5146": {"epss_score": 0.0007, "epss_percentile": 0.21681}, "CVE-2014-5147": {"epss_score": 0.00214, "epss_percentile": 0.43979}, "CVE-2014-5148": {"epss_score": 0.00156, "epss_percentile": 0.36966}, "CVE-2014-5149": {"epss_score": 0.0007, "epss_percentile": 0.21681}, "CVE-2014-5158": {"epss_score": 0.05486, "epss_percentile": 0.89923}, "CVE-2014-5159": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2014-5160": {"epss_score": 0.3004, "epss_percentile": 0.96499}, "CVE-2014-5161": {"epss_score": 0.00219, "epss_percentile": 0.44525}, "CVE-2014-5162": {"epss_score": 0.00219, "epss_percentile": 0.44525}, "CVE-2014-5163": {"epss_score": 0.00744, "epss_percentile": 0.72504}, "CVE-2014-5164": {"epss_score": 0.00239, "epss_percentile": 0.46899}, "CVE-2014-5165": {"epss_score": 0.00239, "epss_percentile": 0.46899}, "CVE-2014-5169": {"epss_score": 0.00208, "epss_percentile": 0.43213}, "CVE-2014-5170": {"epss_score": 0.07889, "epss_percentile": 0.91745}, "CVE-2014-5171": {"epss_score": 0.00399, "epss_percentile": 0.60094}, "CVE-2014-5172": {"epss_score": 0.0053, "epss_percentile": 0.66619}, "CVE-2014-5173": {"epss_score": 0.00441, "epss_percentile": 0.6267}, "CVE-2014-5174": {"epss_score": 0.00447, "epss_percentile": 0.62985}, "CVE-2014-5175": {"epss_score": 0.0072, "epss_percentile": 0.71967}, "CVE-2014-5176": {"epss_score": 0.01603, "epss_percentile": 0.81278}, "CVE-2014-5177": {"epss_score": 0.00114, "epss_percentile": 0.30816}, "CVE-2014-5178": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-5179": {"epss_score": 0.00214, "epss_percentile": 0.43993}, "CVE-2014-5180": {"epss_score": 0.01099, "epss_percentile": 0.77555}, "CVE-2014-5181": {"epss_score": 0.00991, "epss_percentile": 0.76387}, "CVE-2014-5182": {"epss_score": 0.03707, "epss_percentile": 0.87599}, "CVE-2014-5183": {"epss_score": 0.00318, "epss_percentile": 0.54434}, "CVE-2014-5184": {"epss_score": 0.00318, "epss_percentile": 0.54434}, "CVE-2014-5185": {"epss_score": 0.04993, "epss_percentile": 0.8937}, "CVE-2014-5186": {"epss_score": 0.00318, "epss_percentile": 0.54434}, "CVE-2014-5187": {"epss_score": 0.00991, "epss_percentile": 0.76387}, "CVE-2014-5188": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-5189": {"epss_score": 0.01933, "epss_percentile": 0.82947}, "CVE-2014-5190": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2014-5191": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-5192": {"epss_score": 0.01016, "epss_percentile": 0.76676}, "CVE-2014-5193": {"epss_score": 0.03118, "epss_percentile": 0.86439}, "CVE-2014-5194": {"epss_score": 0.02637, "epss_percentile": 0.85294}, "CVE-2014-5195": {"epss_score": 0.00043, "epss_percentile": 0.1303}, "CVE-2014-5196": {"epss_score": 0.00526, "epss_percentile": 0.66408}, "CVE-2014-5197": {"epss_score": 0.00463, "epss_percentile": 0.63693}, "CVE-2014-5198": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-5199": {"epss_score": 0.00125, "epss_percentile": 0.32539}, "CVE-2014-5200": {"epss_score": 0.0449, "epss_percentile": 0.88755}, "CVE-2014-5201": {"epss_score": 0.02844, "epss_percentile": 0.85815}, "CVE-2014-5202": {"epss_score": 0.00139, "epss_percentile": 0.34557}, "CVE-2014-5203": {"epss_score": 0.06913, "epss_percentile": 0.91114}, "CVE-2014-5204": {"epss_score": 0.00234, "epss_percentile": 0.46195}, "CVE-2014-5205": {"epss_score": 0.00142, "epss_percentile": 0.35006}, "CVE-2014-5206": {"epss_score": 0.00037, "epss_percentile": 0.10656}, "CVE-2014-5207": {"epss_score": 0.00228, "epss_percentile": 0.45513}, "CVE-2014-5208": {"epss_score": 0.08455, "epss_percentile": 0.9206}, "CVE-2014-5209": {"epss_score": 0.00568, "epss_percentile": 0.67884}, "CVE-2014-5210": {"epss_score": 0.13508, "epss_percentile": 0.93985}, "CVE-2014-5211": {"epss_score": 0.02381, "epss_percentile": 0.84564}, "CVE-2014-5212": {"epss_score": 0.12722, "epss_percentile": 0.93759}, "CVE-2014-5213": {"epss_score": 0.02054, "epss_percentile": 0.83418}, "CVE-2014-5214": {"epss_score": 0.005, "epss_percentile": 0.65326}, "CVE-2014-5215": {"epss_score": 0.00359, "epss_percentile": 0.57603}, "CVE-2014-5216": {"epss_score": 0.09328, "epss_percentile": 0.92502}, "CVE-2014-5217": {"epss_score": 0.0019, "epss_percentile": 0.41063}, "CVE-2014-5220": {"epss_score": 0.00158, "epss_percentile": 0.37172}, "CVE-2014-5231": {"epss_score": 0.00063, "epss_percentile": 0.19977}, "CVE-2014-5232": {"epss_score": 0.00054, "epss_percentile": 0.17366}, "CVE-2014-5233": {"epss_score": 0.00063, "epss_percentile": 0.19977}, "CVE-2014-5234": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2014-5235": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2014-5236": {"epss_score": 0.06674, "epss_percentile": 0.90935}, "CVE-2014-5237": {"epss_score": 0.00417, "epss_percentile": 0.61258}, "CVE-2014-5238": {"epss_score": 0.00903, "epss_percentile": 0.7521}, "CVE-2014-5239": {"epss_score": 0.05348, "epss_percentile": 0.89771}, "CVE-2014-5240": {"epss_score": 0.00634, "epss_percentile": 0.69792}, "CVE-2014-5241": {"epss_score": 0.00315, "epss_percentile": 0.54168}, "CVE-2014-5242": {"epss_score": 0.0042, "epss_percentile": 0.61447}, "CVE-2014-5243": {"epss_score": 0.00368, "epss_percentile": 0.5818}, "CVE-2014-5246": {"epss_score": 0.26194, "epss_percentile": 0.96122}, "CVE-2014-5247": {"epss_score": 0.00068, "epss_percentile": 0.21361}, "CVE-2014-5248": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-5249": {"epss_score": 0.00526, "epss_percentile": 0.66424}, "CVE-2014-5250": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2014-5251": {"epss_score": 0.0031, "epss_percentile": 0.53759}, "CVE-2014-5252": {"epss_score": 0.00287, "epss_percentile": 0.51848}, "CVE-2014-5253": {"epss_score": 0.0031, "epss_percentile": 0.53759}, "CVE-2014-5254": {"epss_score": 0.00111, "epss_percentile": 0.3035}, "CVE-2014-5255": {"epss_score": 0.00088, "epss_percentile": 0.25721}, "CVE-2014-5256": {"epss_score": 0.01263, "epss_percentile": 0.78988}, "CVE-2014-5257": {"epss_score": 0.004, "epss_percentile": 0.60191}, "CVE-2014-5258": {"epss_score": 0.81937, "epss_percentile": 0.99165}, "CVE-2014-5259": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2014-5260": {"epss_score": 0.0004, "epss_percentile": 0.11973}, "CVE-2014-5261": {"epss_score": 0.01337, "epss_percentile": 0.79561}, "CVE-2014-5262": {"epss_score": 0.00762, "epss_percentile": 0.72843}, "CVE-2014-5263": {"epss_score": 0.00413, "epss_percentile": 0.60997}, "CVE-2014-5265": {"epss_score": 0.07017, "epss_percentile": 0.91189}, "CVE-2014-5266": {"epss_score": 0.76306, "epss_percentile": 0.98885}, "CVE-2014-5267": {"epss_score": 0.00615, "epss_percentile": 0.69305}, "CVE-2014-5268": {"epss_score": 0.00374, "epss_percentile": 0.58573}, "CVE-2014-5269": {"epss_score": 0.00462, "epss_percentile": 0.63587}, "CVE-2014-5270": {"epss_score": 0.00072, "epss_percentile": 0.22433}, "CVE-2014-5271": {"epss_score": 0.13829, "epss_percentile": 0.94068}, "CVE-2014-5272": {"epss_score": 0.02931, "epss_percentile": 0.86016}, "CVE-2014-5273": {"epss_score": 0.00381, "epss_percentile": 0.59002}, "CVE-2014-5274": {"epss_score": 0.00219, "epss_percentile": 0.44527}, "CVE-2014-5275": {"epss_score": 0.00885, "epss_percentile": 0.74933}, "CVE-2014-5276": {"epss_score": 0.00808, "epss_percentile": 0.73693}, "CVE-2014-5277": {"epss_score": 0.00699, "epss_percentile": 0.71441}, "CVE-2014-5278": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2014-5279": {"epss_score": 0.02448, "epss_percentile": 0.84773}, "CVE-2014-5280": {"epss_score": 0.00119, "epss_percentile": 0.31654}, "CVE-2014-5282": {"epss_score": 0.00414, "epss_percentile": 0.61026}, "CVE-2014-5284": {"epss_score": 0.09659, "epss_percentile": 0.92643}, "CVE-2014-5285": {"epss_score": 0.0051, "epss_percentile": 0.65761}, "CVE-2014-5286": {"epss_score": 0.0026, "epss_percentile": 0.49234}, "CVE-2014-5287": {"epss_score": 0.13883, "epss_percentile": 0.94084}, "CVE-2014-5288": {"epss_score": 0.00235, "epss_percentile": 0.46333}, "CVE-2014-5289": {"epss_score": 0.23218, "epss_percentile": 0.95752}, "CVE-2014-5297": {"epss_score": 0.00651, "epss_percentile": 0.70274}, "CVE-2014-5298": {"epss_score": 0.01227, "epss_percentile": 0.78701}, "CVE-2014-5300": {"epss_score": 0.17967, "epss_percentile": 0.94935}, "CVE-2014-5301": {"epss_score": 0.78386, "epss_percentile": 0.98985}, "CVE-2014-5302": {"epss_score": 0.53882, "epss_percentile": 0.97902}, "CVE-2014-5307": {"epss_score": 0.0006, "epss_percentile": 0.19025}, "CVE-2014-5308": {"epss_score": 0.14361, "epss_percentile": 0.94193}, "CVE-2014-5313": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2014-5314": {"epss_score": 0.06103, "epss_percentile": 0.90483}, "CVE-2014-5315": {"epss_score": 0.00649, "epss_percentile": 0.70237}, "CVE-2014-5316": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2014-5317": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-5318": {"epss_score": 0.00227, "epss_percentile": 0.45432}, "CVE-2014-5319": {"epss_score": 0.00517, "epss_percentile": 0.66066}, "CVE-2014-5320": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2014-5321": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2014-5322": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-5323": {"epss_score": 0.00056, "epss_percentile": 0.17785}, "CVE-2014-5324": {"epss_score": 0.00459, "epss_percentile": 0.63458}, "CVE-2014-5325": {"epss_score": 0.00633, "epss_percentile": 0.69765}, "CVE-2014-5326": {"epss_score": 0.00217, "epss_percentile": 0.44328}, "CVE-2014-5327": {"epss_score": 0.00308, "epss_percentile": 0.53588}, "CVE-2014-5328": {"epss_score": 0.00308, "epss_percentile": 0.53588}, "CVE-2014-5329": {"epss_score": 0.02497, "epss_percentile": 0.84911}, "CVE-2014-5330": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2014-5331": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-5332": {"epss_score": 0.00036, "epss_percentile": 0.10519}, "CVE-2014-5333": {"epss_score": 0.00325, "epss_percentile": 0.55035}, "CVE-2014-5334": {"epss_score": 0.11464, "epss_percentile": 0.93374}, "CVE-2014-5335": {"epss_score": 0.00383, "epss_percentile": 0.59112}, "CVE-2014-5336": {"epss_score": 0.01138, "epss_percentile": 0.77933}, "CVE-2014-5337": {"epss_score": 0.52794, "epss_percentile": 0.97841}, "CVE-2014-5338": {"epss_score": 0.00288, "epss_percentile": 0.51865}, "CVE-2014-5339": {"epss_score": 0.00527, "epss_percentile": 0.66446}, "CVE-2014-5340": {"epss_score": 0.0315, "epss_percentile": 0.86505}, "CVE-2014-5341": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-5342": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2014-5343": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-5344": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-5345": {"epss_score": 0.02387, "epss_percentile": 0.84583}, "CVE-2014-5346": {"epss_score": 0.00248, "epss_percentile": 0.47992}, "CVE-2014-5347": {"epss_score": 0.03145, "epss_percentile": 0.86494}, "CVE-2014-5348": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-5349": {"epss_score": 0.08891, "epss_percentile": 0.92304}, "CVE-2014-5350": {"epss_score": 0.07214, "epss_percentile": 0.9133}, "CVE-2014-5351": {"epss_score": 0.00348, "epss_percentile": 0.56836}, "CVE-2014-5352": {"epss_score": 0.05407, "epss_percentile": 0.89841}, "CVE-2014-5353": {"epss_score": 0.00866, "epss_percentile": 0.74637}, "CVE-2014-5354": {"epss_score": 0.0054, "epss_percentile": 0.6702}, "CVE-2014-5355": {"epss_score": 0.09423, "epss_percentile": 0.9254}, "CVE-2014-5356": {"epss_score": 0.00804, "epss_percentile": 0.73612}, "CVE-2014-5359": {"epss_score": 0.00296, "epss_percentile": 0.52587}, "CVE-2014-5360": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2014-5361": {"epss_score": 0.00158, "epss_percentile": 0.3721}, "CVE-2014-5362": {"epss_score": 0.03788, "epss_percentile": 0.87727}, "CVE-2014-5368": {"epss_score": 0.53297, "epss_percentile": 0.9787}, "CVE-2014-5369": {"epss_score": 0.00582, "epss_percentile": 0.68287}, "CVE-2014-5370": {"epss_score": 0.11515, "epss_percentile": 0.93389}, "CVE-2014-5375": {"epss_score": 0.00306, "epss_percentile": 0.53452}, "CVE-2014-5376": {"epss_score": 0.00306, "epss_percentile": 0.53452}, "CVE-2014-5377": {"epss_score": 0.67644, "epss_percentile": 0.98516}, "CVE-2014-5380": {"epss_score": 0.18977, "epss_percentile": 0.95105}, "CVE-2014-5381": {"epss_score": 0.46437, "epss_percentile": 0.97545}, "CVE-2014-5382": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-5383": {"epss_score": 0.23456, "epss_percentile": 0.95779}, "CVE-2014-5384": {"epss_score": 0.00408, "epss_percentile": 0.60636}, "CVE-2014-5385": {"epss_score": 0.00309, "epss_percentile": 0.53723}, "CVE-2014-5386": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2014-5387": {"epss_score": 0.00482, "epss_percentile": 0.64545}, "CVE-2014-5388": {"epss_score": 0.00111, "epss_percentile": 0.30349}, "CVE-2014-5389": {"epss_score": 0.00498, "epss_percentile": 0.65229}, "CVE-2014-5391": {"epss_score": 0.00467, "epss_percentile": 0.63861}, "CVE-2014-5392": {"epss_score": 0.00968, "epss_percentile": 0.76088}, "CVE-2014-5393": {"epss_score": 0.00391, "epss_percentile": 0.59561}, "CVE-2014-5394": {"epss_score": 0.00427, "epss_percentile": 0.61783}, "CVE-2014-5395": {"epss_score": 0.00206, "epss_percentile": 0.4306}, "CVE-2014-5396": {"epss_score": 0.00431, "epss_percentile": 0.62038}, "CVE-2014-5397": {"epss_score": 0.00397, "epss_percentile": 0.60029}, "CVE-2014-5398": {"epss_score": 0.00309, "epss_percentile": 0.53683}, "CVE-2014-5399": {"epss_score": 0.0037, "epss_percentile": 0.58332}, "CVE-2014-5400": {"epss_score": 0.00058, "epss_percentile": 0.18413}, "CVE-2014-5401": {"epss_score": 0.01781, "epss_percentile": 0.8224}, "CVE-2014-5403": {"epss_score": 0.00678, "epss_percentile": 0.71001}, "CVE-2014-5405": {"epss_score": 0.0041, "epss_percentile": 0.60815}, "CVE-2014-5406": {"epss_score": 0.0055, "epss_percentile": 0.67335}, "CVE-2014-5407": {"epss_score": 0.00081, "epss_percentile": 0.24352}, "CVE-2014-5408": {"epss_score": 0.00868, "epss_percentile": 0.74677}, "CVE-2014-5409": {"epss_score": 0.02293, "epss_percentile": 0.84289}, "CVE-2014-5410": {"epss_score": 0.00048, "epss_percentile": 0.15189}, "CVE-2014-5411": {"epss_score": 0.00492, "epss_percentile": 0.65018}, "CVE-2014-5412": {"epss_score": 0.00537, "epss_percentile": 0.66924}, "CVE-2014-5413": {"epss_score": 0.00314, "epss_percentile": 0.5415}, "CVE-2014-5414": {"epss_score": 0.05939, "epss_percentile": 0.90347}, "CVE-2014-5415": {"epss_score": 0.04192, "epss_percentile": 0.88377}, "CVE-2014-5417": {"epss_score": 0.02627, "epss_percentile": 0.8527}, "CVE-2014-5418": {"epss_score": 0.01987, "epss_percentile": 0.83161}, "CVE-2014-5419": {"epss_score": 0.01383, "epss_percentile": 0.79896}, "CVE-2014-5420": {"epss_score": 0.00211, "epss_percentile": 0.43718}, "CVE-2014-5421": {"epss_score": 0.00053, "epss_percentile": 0.16795}, "CVE-2014-5422": {"epss_score": 0.00423, "epss_percentile": 0.61593}, "CVE-2014-5423": {"epss_score": 0.00058, "epss_percentile": 0.1839}, "CVE-2014-5424": {"epss_score": 0.00292, "epss_percentile": 0.52225}, "CVE-2014-5425": {"epss_score": 0.00442, "epss_percentile": 0.62732}, "CVE-2014-5426": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2014-5427": {"epss_score": 0.00533, "epss_percentile": 0.66754}, "CVE-2014-5428": {"epss_score": 0.0265, "epss_percentile": 0.85342}, "CVE-2014-5429": {"epss_score": 0.00455, "epss_percentile": 0.6329}, "CVE-2014-5430": {"epss_score": 0.00054, "epss_percentile": 0.17145}, "CVE-2014-5431": {"epss_score": 0.00053, "epss_percentile": 0.16818}, "CVE-2014-5432": {"epss_score": 0.00592, "epss_percentile": 0.68612}, "CVE-2014-5433": {"epss_score": 0.00192, "epss_percentile": 0.41282}, "CVE-2014-5434": {"epss_score": 0.00248, "epss_percentile": 0.47991}, "CVE-2014-5435": {"epss_score": 0.01435, "epss_percentile": 0.80268}, "CVE-2014-5436": {"epss_score": 0.01218, "epss_percentile": 0.78607}, "CVE-2014-5437": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2014-5438": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2014-5439": {"epss_score": 0.00422, "epss_percentile": 0.61576}, "CVE-2014-5440": {"epss_score": 0.00354, "epss_percentile": 0.5724}, "CVE-2014-5441": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-5443": {"epss_score": 0.0006, "epss_percentile": 0.1923}, "CVE-2014-5444": {"epss_score": 0.00147, "epss_percentile": 0.35781}, "CVE-2014-5445": {"epss_score": 0.90975, "epss_percentile": 0.99613}, "CVE-2014-5446": {"epss_score": 0.65741, "epss_percentile": 0.98436}, "CVE-2014-5447": {"epss_score": 0.00048, "epss_percentile": 0.15076}, "CVE-2014-5448": {"epss_score": 0.00048, "epss_percentile": 0.1516}, "CVE-2014-5449": {"epss_score": 0.00048, "epss_percentile": 0.1516}, "CVE-2014-5450": {"epss_score": 0.00045, "epss_percentile": 0.13825}, "CVE-2014-5451": {"epss_score": 0.00544, "epss_percentile": 0.67125}, "CVE-2014-5452": {"epss_score": 0.00442, "epss_percentile": 0.62733}, "CVE-2014-5453": {"epss_score": 0.0057, "epss_percentile": 0.67945}, "CVE-2014-5454": {"epss_score": 0.01383, "epss_percentile": 0.79894}, "CVE-2014-5455": {"epss_score": 0.00637, "epss_percentile": 0.69884}, "CVE-2014-5456": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2014-5457": {"epss_score": 0.00053, "epss_percentile": 0.16682}, "CVE-2014-5458": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2014-5459": {"epss_score": 0.00077, "epss_percentile": 0.23414}, "CVE-2014-5460": {"epss_score": 0.64727, "epss_percentile": 0.98389}, "CVE-2014-5461": {"epss_score": 0.21592, "epss_percentile": 0.95537}, "CVE-2014-5462": {"epss_score": 0.00059, "epss_percentile": 0.18628}, "CVE-2014-5464": {"epss_score": 0.28097, "epss_percentile": 0.96309}, "CVE-2014-5465": {"epss_score": 0.343, "epss_percentile": 0.9684}, "CVE-2014-5466": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-5468": {"epss_score": 0.65256, "epss_percentile": 0.98409}, "CVE-2014-5470": {"epss_score": 0.78051, "epss_percentile": 0.98966}, "CVE-2014-5471": {"epss_score": 0.00117, "epss_percentile": 0.31297}, "CVE-2014-5472": {"epss_score": 0.00076, "epss_percentile": 0.23279}, "CVE-2014-5500": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2014-5501": {"epss_score": 0.06665, "epss_percentile": 0.90928}, "CVE-2014-5502": {"epss_score": 0.01257, "epss_percentile": 0.78948}, "CVE-2014-5503": {"epss_score": 0.01276, "epss_percentile": 0.79108}, "CVE-2014-5504": {"epss_score": 0.25447, "epss_percentile": 0.96029}, "CVE-2014-5505": {"epss_score": 0.06503, "epss_percentile": 0.90804}, "CVE-2014-5506": {"epss_score": 0.02079, "epss_percentile": 0.83525}, "CVE-2014-5507": {"epss_score": 0.01131, "epss_percentile": 0.77865}, "CVE-2014-5508": {"epss_score": 0.00433, "epss_percentile": 0.6218}, "CVE-2014-5509": {"epss_score": 0.00062, "epss_percentile": 0.19624}, "CVE-2014-5516": {"epss_score": 0.00153, "epss_percentile": 0.36525}, "CVE-2014-5519": {"epss_score": 0.82624, "epss_percentile": 0.99202}, "CVE-2014-5520": {"epss_score": 0.07438, "epss_percentile": 0.91473}, "CVE-2014-5521": {"epss_score": 0.09793, "epss_percentile": 0.92704}, "CVE-2014-5524": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5525": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5526": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5527": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5528": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5529": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-5531": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5532": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5534": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5535": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5536": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5537": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5538": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5539": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5540": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5541": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5542": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5543": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5544": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5545": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5546": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5547": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5548": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5549": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5550": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5551": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5552": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5553": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5554": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5555": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5556": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5557": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5558": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5559": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5560": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5561": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5562": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5563": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5564": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5565": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5566": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5567": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5568": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5569": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5570": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5571": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5572": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5573": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5574": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5576": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5577": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5578": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5579": {"epss_score": 0.00134, "epss_percentile": 0.33822}, "CVE-2014-5580": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5581": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5582": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5583": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5584": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5585": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5586": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5587": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5588": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5589": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5590": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5591": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5592": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5593": {"epss_score": 0.00101, "epss_percentile": 0.28666}, "CVE-2014-5594": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5595": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5596": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5597": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5598": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5599": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5600": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5601": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5602": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5603": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5604": {"epss_score": 0.00101, "epss_percentile": 0.28666}, "CVE-2014-5605": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5606": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-5607": {"epss_score": 0.00043, "epss_percentile": 0.13224}, "CVE-2014-5608": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5609": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5610": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5611": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5612": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5613": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5614": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5615": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5616": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5617": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5618": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5620": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5621": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5622": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5623": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5624": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5625": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5626": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5627": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5628": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5629": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5630": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5631": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5632": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5633": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5634": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5635": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5636": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5637": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5638": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5639": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5640": {"epss_score": 0.00134, "epss_percentile": 0.33822}, "CVE-2014-5641": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5642": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5643": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5644": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5645": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5646": {"epss_score": 0.00134, "epss_percentile": 0.33822}, "CVE-2014-5647": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5648": {"epss_score": 0.00134, "epss_percentile": 0.33822}, "CVE-2014-5649": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5650": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5651": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5652": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5653": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5654": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-5655": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5656": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5657": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5658": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5659": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5660": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5661": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5662": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5663": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5664": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5665": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5666": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5667": {"epss_score": 0.00134, "epss_percentile": 0.33822}, "CVE-2014-5668": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5669": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5670": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5671": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5672": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5673": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5674": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5675": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5676": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5677": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5678": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5679": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5680": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5681": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5682": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5683": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5684": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5685": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5686": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5687": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5688": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5689": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5690": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5691": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5692": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5693": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5694": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5695": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5696": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5697": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5698": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5699": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5700": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5701": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5702": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5703": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5704": {"epss_score": 0.0005, "epss_percentile": 0.15824}, "CVE-2014-5705": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5706": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5707": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5708": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5709": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5710": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5711": {"epss_score": 0.00072, "epss_percentile": 0.22437}, "CVE-2014-5712": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5713": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5714": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5715": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5716": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5717": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5719": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5720": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5721": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5722": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5723": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5724": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5725": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5726": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5727": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5728": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5729": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5730": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5731": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5732": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5733": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5734": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5735": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5736": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5737": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5738": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5739": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5740": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5741": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5742": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5743": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5744": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5745": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5746": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5747": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5748": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5749": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5750": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5751": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5752": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5753": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5754": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5755": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5756": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5757": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5758": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5759": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5760": {"epss_score": 0.00106, "epss_percentile": 0.29553}, "CVE-2014-5761": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5762": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5763": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5764": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5765": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5766": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5767": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5768": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5769": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5770": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5771": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5772": {"epss_score": 0.00134, "epss_percentile": 0.33822}, "CVE-2014-5773": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5774": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5775": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5776": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5777": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5778": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5779": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5780": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5781": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5782": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5783": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5784": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5785": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5786": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5787": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5788": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5789": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5790": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5791": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5792": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5793": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5794": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5796": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5797": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5798": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5799": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5800": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5801": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5802": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5803": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5804": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5805": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5806": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5807": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5808": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5809": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5810": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5811": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5812": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5813": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5815": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5816": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5817": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5818": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5819": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5820": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5821": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5822": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5823": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5824": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5825": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5826": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5827": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5828": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5829": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5830": {"epss_score": 0.00116, "epss_percentile": 0.3108}, "CVE-2014-5831": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5832": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5833": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5834": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5835": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5836": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5837": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5838": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5839": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5840": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5841": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5842": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5843": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5844": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5845": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5846": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5847": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5848": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5849": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5850": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5851": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5852": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5853": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5854": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5855": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5856": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5857": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5858": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5859": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5860": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-5861": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5862": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5863": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5864": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5865": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5866": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5867": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5868": {"epss_score": 0.00125, "epss_percentile": 0.32537}, "CVE-2014-5869": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5870": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5871": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5872": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5873": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5874": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5875": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5876": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5877": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5878": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5879": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5881": {"epss_score": 0.00142, "epss_percentile": 0.34971}, "CVE-2014-5882": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5883": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5884": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5885": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5886": {"epss_score": 0.00184, "epss_percentile": 0.40392}, "CVE-2014-5887": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5888": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5889": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5890": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5891": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5892": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5893": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5894": {"epss_score": 0.00134, "epss_percentile": 0.33822}, "CVE-2014-5895": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5896": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5897": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5898": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5899": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5900": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5901": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5902": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5903": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5904": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5905": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5906": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5907": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5908": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5909": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5910": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5911": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5912": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5913": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5914": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5915": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5916": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5917": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5918": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5919": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5920": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5921": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5922": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5923": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5924": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5925": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5926": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5927": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5928": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5929": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5930": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5931": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5932": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5933": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5934": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5935": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5936": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5937": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5938": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5939": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5940": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5941": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5942": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5943": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5944": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5945": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5946": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5947": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5948": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5949": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5950": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5951": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5952": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5953": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5954": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5955": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5956": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5957": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5958": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5959": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5960": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5961": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5962": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5963": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5964": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5965": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5966": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5967": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5968": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5969": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5970": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5971": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5972": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5973": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5974": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5975": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5976": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5977": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5978": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5979": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5980": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5981": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5982": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5983": {"epss_score": 0.00134, "epss_percentile": 0.33822}, "CVE-2014-5984": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5985": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5986": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5987": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5988": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5989": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5990": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5991": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5992": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5993": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5994": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5995": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5996": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5997": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5998": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-5999": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6000": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6001": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6002": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6003": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6004": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6005": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6006": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-6007": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6008": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6009": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6010": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6011": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6012": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6013": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6014": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6015": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6016": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6017": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6018": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6019": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6020": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6021": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6022": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6023": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6024": {"epss_score": 0.00134, "epss_percentile": 0.33856}, "CVE-2014-6025": {"epss_score": 0.00134, "epss_percentile": 0.33856}, "CVE-2014-6027": {"epss_score": 0.00343, "epss_percentile": 0.56471}, "CVE-2014-6028": {"epss_score": 0.00265, "epss_percentile": 0.49833}, "CVE-2014-6029": {"epss_score": 0.00577, "epss_percentile": 0.68157}, "CVE-2014-6030": {"epss_score": 0.00704, "epss_percentile": 0.71556}, "CVE-2014-6031": {"epss_score": 0.00466, "epss_percentile": 0.63801}, "CVE-2014-6032": {"epss_score": 0.02455, "epss_percentile": 0.84795}, "CVE-2014-6034": {"epss_score": 0.86551, "epss_percentile": 0.99387}, "CVE-2014-6035": {"epss_score": 0.11588, "epss_percentile": 0.93413}, "CVE-2014-6036": {"epss_score": 0.36457, "epss_percentile": 0.9698}, "CVE-2014-6037": {"epss_score": 0.81733, "epss_percentile": 0.99153}, "CVE-2014-6038": {"epss_score": 0.83792, "epss_percentile": 0.99262}, "CVE-2014-6039": {"epss_score": 0.83631, "epss_percentile": 0.99255}, "CVE-2014-6040": {"epss_score": 0.07187, "epss_percentile": 0.91308}, "CVE-2014-6041": {"epss_score": 0.61209, "epss_percentile": 0.98238}, "CVE-2014-6043": {"epss_score": 0.05802, "epss_percentile": 0.9022}, "CVE-2014-6045": {"epss_score": 0.00394, "epss_percentile": 0.59758}, "CVE-2014-6046": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2014-6047": {"epss_score": 0.04672, "epss_percentile": 0.88987}, "CVE-2014-6048": {"epss_score": 0.06048, "epss_percentile": 0.90433}, "CVE-2014-6049": {"epss_score": 0.01239, "epss_percentile": 0.78795}, "CVE-2014-6050": {"epss_score": 0.04907, "epss_percentile": 0.89278}, "CVE-2014-6051": {"epss_score": 0.06605, "epss_percentile": 0.90881}, "CVE-2014-6052": {"epss_score": 0.0524, "epss_percentile": 0.8965}, "CVE-2014-6053": {"epss_score": 0.36865, "epss_percentile": 0.97005}, "CVE-2014-6054": {"epss_score": 0.34577, "epss_percentile": 0.96857}, "CVE-2014-6055": {"epss_score": 0.11157, "epss_percentile": 0.93249}, "CVE-2014-6059": {"epss_score": 0.01105, "epss_percentile": 0.77603}, "CVE-2014-6060": {"epss_score": 0.00136, "epss_percentile": 0.34108}, "CVE-2014-6064": {"epss_score": 0.00245, "epss_percentile": 0.47685}, "CVE-2014-6070": {"epss_score": 0.07235, "epss_percentile": 0.9134}, "CVE-2014-6071": {"epss_score": 0.01978, "epss_percentile": 0.8313}, "CVE-2014-6074": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2014-6075": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2014-6076": {"epss_score": 0.00249, "epss_percentile": 0.48007}, "CVE-2014-6077": {"epss_score": 0.00134, "epss_percentile": 0.33836}, "CVE-2014-6078": {"epss_score": 0.00236, "epss_percentile": 0.46377}, "CVE-2014-6079": {"epss_score": 0.00452, "epss_percentile": 0.63173}, "CVE-2014-6080": {"epss_score": 0.00278, "epss_percentile": 0.50866}, "CVE-2014-6082": {"epss_score": 0.00914, "epss_percentile": 0.75391}, "CVE-2014-6083": {"epss_score": 0.00264, "epss_percentile": 0.49687}, "CVE-2014-6084": {"epss_score": 0.00264, "epss_percentile": 0.49687}, "CVE-2014-6086": {"epss_score": 0.00264, "epss_percentile": 0.49687}, "CVE-2014-6087": {"epss_score": 0.00264, "epss_percentile": 0.49687}, "CVE-2014-6088": {"epss_score": 0.00264, "epss_percentile": 0.49687}, "CVE-2014-6089": {"epss_score": 0.00423, "epss_percentile": 0.6158}, "CVE-2014-6090": {"epss_score": 0.00103, "epss_percentile": 0.28976}, "CVE-2014-6091": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-6092": {"epss_score": 0.00527, "epss_percentile": 0.66445}, "CVE-2014-6093": {"epss_score": 0.00337, "epss_percentile": 0.56042}, "CVE-2014-6095": {"epss_score": 0.0049, "epss_percentile": 0.64919}, "CVE-2014-6096": {"epss_score": 0.00501, "epss_percentile": 0.65339}, "CVE-2014-6097": {"epss_score": 0.00558, "epss_percentile": 0.67594}, "CVE-2014-6098": {"epss_score": 0.00737, "epss_percentile": 0.72327}, "CVE-2014-6099": {"epss_score": 0.00278, "epss_percentile": 0.50881}, "CVE-2014-6100": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-6101": {"epss_score": 0.00321, "epss_percentile": 0.54651}, "CVE-2014-6102": {"epss_score": 0.00125, "epss_percentile": 0.32602}, "CVE-2014-6105": {"epss_score": 0.00737, "epss_percentile": 0.72327}, "CVE-2014-6106": {"epss_score": 0.00109, "epss_percentile": 0.29914}, "CVE-2014-6107": {"epss_score": 0.00737, "epss_percentile": 0.72327}, "CVE-2014-6108": {"epss_score": 0.00193, "epss_percentile": 0.41446}, "CVE-2014-6109": {"epss_score": 0.00116, "epss_percentile": 0.31176}, "CVE-2014-6110": {"epss_score": 0.00158, "epss_percentile": 0.3716}, "CVE-2014-6111": {"epss_score": 0.00042, "epss_percentile": 0.12815}, "CVE-2014-6112": {"epss_score": 0.0024, "epss_percentile": 0.46956}, "CVE-2014-6113": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2014-6114": {"epss_score": 0.00864, "epss_percentile": 0.74613}, "CVE-2014-6115": {"epss_score": 0.00223, "epss_percentile": 0.4494}, "CVE-2014-6116": {"epss_score": 0.00207, "epss_percentile": 0.43132}, "CVE-2014-6119": {"epss_score": 0.09944, "epss_percentile": 0.92785}, "CVE-2014-6120": {"epss_score": 0.03986, "epss_percentile": 0.88065}, "CVE-2014-6121": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-6122": {"epss_score": 0.01343, "epss_percentile": 0.79599}, "CVE-2014-6123": {"epss_score": 0.0005, "epss_percentile": 0.15971}, "CVE-2014-6125": {"epss_score": 0.00163, "epss_percentile": 0.37829}, "CVE-2014-6126": {"epss_score": 0.0023, "epss_percentile": 0.45669}, "CVE-2014-6129": {"epss_score": 0.00348, "epss_percentile": 0.56819}, "CVE-2014-6130": {"epss_score": 0.00508, "epss_percentile": 0.65705}, "CVE-2014-6131": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2014-6132": {"epss_score": 0.00308, "epss_percentile": 0.53618}, "CVE-2014-6133": {"epss_score": 0.00054, "epss_percentile": 0.17362}, "CVE-2014-6134": {"epss_score": 0.00118, "epss_percentile": 0.31437}, "CVE-2014-6135": {"epss_score": 0.00246, "epss_percentile": 0.47798}, "CVE-2014-6136": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2014-6137": {"epss_score": 0.01233, "epss_percentile": 0.78746}, "CVE-2014-6138": {"epss_score": 0.00159, "epss_percentile": 0.37303}, "CVE-2014-6139": {"epss_score": 0.0014, "epss_percentile": 0.34785}, "CVE-2014-6140": {"epss_score": 0.10066, "epss_percentile": 0.92838}, "CVE-2014-6141": {"epss_score": 0.00264, "epss_percentile": 0.49577}, "CVE-2014-6143": {"epss_score": 0.00054, "epss_percentile": 0.17362}, "CVE-2014-6144": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-6145": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-6146": {"epss_score": 0.00061, "epss_percentile": 0.19544}, "CVE-2014-6147": {"epss_score": 0.00054, "epss_percentile": 0.17362}, "CVE-2014-6148": {"epss_score": 0.00171, "epss_percentile": 0.38796}, "CVE-2014-6149": {"epss_score": 0.00485, "epss_percentile": 0.64732}, "CVE-2014-6150": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-6151": {"epss_score": 0.00226, "epss_percentile": 0.45276}, "CVE-2014-6152": {"epss_score": 0.00208, "epss_percentile": 0.43262}, "CVE-2014-6153": {"epss_score": 0.00609, "epss_percentile": 0.69091}, "CVE-2014-6154": {"epss_score": 0.0028, "epss_percentile": 0.51083}, "CVE-2014-6155": {"epss_score": 0.00316, "epss_percentile": 0.54216}, "CVE-2014-6158": {"epss_score": 0.0236, "epss_percentile": 0.84494}, "CVE-2014-6159": {"epss_score": 0.01463, "epss_percentile": 0.80443}, "CVE-2014-6160": {"epss_score": 0.00152, "epss_percentile": 0.36499}, "CVE-2014-6161": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-6163": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-6164": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2014-6166": {"epss_score": 0.0031, "epss_percentile": 0.53806}, "CVE-2014-6167": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2014-6168": {"epss_score": 0.00088, "epss_percentile": 0.25689}, "CVE-2014-6169": {"epss_score": 0.00154, "epss_percentile": 0.36683}, "CVE-2014-6170": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2014-6171": {"epss_score": 0.00289, "epss_percentile": 0.52034}, "CVE-2014-6172": {"epss_score": 0.00349, "epss_percentile": 0.56875}, "CVE-2014-6173": {"epss_score": 0.00227, "epss_percentile": 0.454}, "CVE-2014-6174": {"epss_score": 0.0022, "epss_percentile": 0.44603}, "CVE-2014-6175": {"epss_score": 0.0018, "epss_percentile": 0.39969}, "CVE-2014-6176": {"epss_score": 0.0036, "epss_percentile": 0.57646}, "CVE-2014-6177": {"epss_score": 0.00226, "epss_percentile": 0.45342}, "CVE-2014-6178": {"epss_score": 0.00162, "epss_percentile": 0.37634}, "CVE-2014-6179": {"epss_score": 0.00249, "epss_percentile": 0.48063}, "CVE-2014-6180": {"epss_score": 0.00162, "epss_percentile": 0.37634}, "CVE-2014-6181": {"epss_score": 0.00165, "epss_percentile": 0.38026}, "CVE-2014-6182": {"epss_score": 0.00389, "epss_percentile": 0.59487}, "CVE-2014-6183": {"epss_score": 0.01274, "epss_percentile": 0.7909}, "CVE-2014-6184": {"epss_score": 0.00042, "epss_percentile": 0.12917}, "CVE-2014-6185": {"epss_score": 0.0005, "epss_percentile": 0.15684}, "CVE-2014-6186": {"epss_score": 0.00338, "epss_percentile": 0.56144}, "CVE-2014-6187": {"epss_score": 0.00251, "epss_percentile": 0.4832}, "CVE-2014-6188": {"epss_score": 0.00291, "epss_percentile": 0.52197}, "CVE-2014-6189": {"epss_score": 0.00206, "epss_percentile": 0.42775}, "CVE-2014-6190": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2014-6191": {"epss_score": 0.00154, "epss_percentile": 0.36683}, "CVE-2014-6192": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-6193": {"epss_score": 0.0034, "epss_percentile": 0.56234}, "CVE-2014-6194": {"epss_score": 0.0043, "epss_percentile": 0.62014}, "CVE-2014-6195": {"epss_score": 0.00035, "epss_percentile": 0.09966}, "CVE-2014-6196": {"epss_score": 0.00452, "epss_percentile": 0.63173}, "CVE-2014-6197": {"epss_score": 0.00218, "epss_percentile": 0.44413}, "CVE-2014-6198": {"epss_score": 0.00103, "epss_percentile": 0.28976}, "CVE-2014-6199": {"epss_score": 0.01879, "epss_percentile": 0.82671}, "CVE-2014-6209": {"epss_score": 0.01597, "epss_percentile": 0.81244}, "CVE-2014-6210": {"epss_score": 0.01562, "epss_percentile": 0.81047}, "CVE-2014-6211": {"epss_score": 0.00055, "epss_percentile": 0.17551}, "CVE-2014-6212": {"epss_score": 0.00206, "epss_percentile": 0.43067}, "CVE-2014-6214": {"epss_score": 0.00119, "epss_percentile": 0.31563}, "CVE-2014-6215": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-6221": {"epss_score": 0.00631, "epss_percentile": 0.69718}, "CVE-2014-6222": {"epss_score": 0.00403, "epss_percentile": 0.60386}, "CVE-2014-6228": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2014-6229": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-6230": {"epss_score": 0.00677, "epss_percentile": 0.70951}, "CVE-2014-6231": {"epss_score": 0.01957, "epss_percentile": 0.83042}, "CVE-2014-6232": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2014-6233": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2014-6234": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2014-6235": {"epss_score": 0.07594, "epss_percentile": 0.91559}, "CVE-2014-6236": {"epss_score": 0.01957, "epss_percentile": 0.83042}, "CVE-2014-6237": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2014-6238": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-6239": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2014-6240": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-6241": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2014-6242": {"epss_score": 0.05719, "epss_percentile": 0.90149}, "CVE-2014-6243": {"epss_score": 0.00233, "epss_percentile": 0.46}, "CVE-2014-6251": {"epss_score": 0.00481, "epss_percentile": 0.64502}, "CVE-2014-6252": {"epss_score": 0.02237, "epss_percentile": 0.84102}, "CVE-2014-6253": {"epss_score": 0.00108, "epss_percentile": 0.29808}, "CVE-2014-6254": {"epss_score": 0.00688, "epss_percentile": 0.71199}, "CVE-2014-6255": {"epss_score": 0.00529, "epss_percentile": 0.66595}, "CVE-2014-6256": {"epss_score": 0.00204, "epss_percentile": 0.42597}, "CVE-2014-6257": {"epss_score": 0.00541, "epss_percentile": 0.6704}, "CVE-2014-6258": {"epss_score": 0.00736, "epss_percentile": 0.72308}, "CVE-2014-6259": {"epss_score": 0.01474, "epss_percentile": 0.80522}, "CVE-2014-6260": {"epss_score": 0.00492, "epss_percentile": 0.64991}, "CVE-2014-6261": {"epss_score": 0.02994, "epss_percentile": 0.86153}, "CVE-2014-6262": {"epss_score": 0.22586, "epss_percentile": 0.95654}, "CVE-2014-6268": {"epss_score": 0.00068, "epss_percentile": 0.21284}, "CVE-2014-6269": {"epss_score": 0.00106, "epss_percentile": 0.29491}, "CVE-2014-6270": {"epss_score": 0.18201, "epss_percentile": 0.94974}, "CVE-2014-6271": {"epss_score": 0.9422, "epss_percentile": 0.99918}, "CVE-2014-6272": {"epss_score": 0.01085, "epss_percentile": 0.77402}, "CVE-2014-6273": {"epss_score": 0.00677, "epss_percentile": 0.70944}, "CVE-2014-6274": {"epss_score": 0.00033, "epss_percentile": 0.0924}, "CVE-2014-6275": {"epss_score": 0.00326, "epss_percentile": 0.55089}, "CVE-2014-6276": {"epss_score": 0.0013, "epss_percentile": 0.33334}, "CVE-2014-6277": {"epss_score": 0.85132, "epss_percentile": 0.9932}, "CVE-2014-6278": {"epss_score": 0.90482, "epss_percentile": 0.99585}, "CVE-2014-6280": {"epss_score": 0.004, "epss_percentile": 0.60191}, "CVE-2014-6283": {"epss_score": 0.00865, "epss_percentile": 0.74615}, "CVE-2014-6284": {"epss_score": 0.00247, "epss_percentile": 0.479}, "CVE-2014-6287": {"epss_score": 0.94363, "epss_percentile": 0.9996}, "CVE-2014-6288": {"epss_score": 0.00225, "epss_percentile": 0.45089}, "CVE-2014-6289": {"epss_score": 0.00254, "epss_percentile": 0.48504}, "CVE-2014-6290": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2014-6291": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-6292": {"epss_score": 0.0035, "epss_percentile": 0.5698}, "CVE-2014-6293": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2014-6294": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-6295": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2014-6296": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-6297": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-6298": {"epss_score": 0.0188, "epss_percentile": 0.82676}, "CVE-2014-6299": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2014-6300": {"epss_score": 0.00273, "epss_percentile": 0.50466}, "CVE-2014-6301": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-6302": {"epss_score": 0.00379, "epss_percentile": 0.58848}, "CVE-2014-6303": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-6304": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-6308": {"epss_score": 0.69729, "epss_percentile": 0.98601}, "CVE-2014-6309": {"epss_score": 0.00237, "epss_percentile": 0.46658}, "CVE-2014-6310": {"epss_score": 0.16928, "epss_percentile": 0.94748}, "CVE-2014-6311": {"epss_score": 0.00506, "epss_percentile": 0.65637}, "CVE-2014-6312": {"epss_score": 0.01552, "epss_percentile": 0.80993}, "CVE-2014-6313": {"epss_score": 0.00198, "epss_percentile": 0.42023}, "CVE-2014-6315": {"epss_score": 0.00304, "epss_percentile": 0.53241}, "CVE-2014-6316": {"epss_score": 0.00605, "epss_percentile": 0.6897}, "CVE-2014-6317": {"epss_score": 0.25927, "epss_percentile": 0.96095}, "CVE-2014-6318": {"epss_score": 0.31604, "epss_percentile": 0.96638}, "CVE-2014-6319": {"epss_score": 0.05143, "epss_percentile": 0.8954}, "CVE-2014-6321": {"epss_score": 0.9327, "epss_percentile": 0.99791}, "CVE-2014-6322": {"epss_score": 0.06514, "epss_percentile": 0.90814}, "CVE-2014-6323": {"epss_score": 0.41442, "epss_percentile": 0.97274}, "CVE-2014-6324": {"epss_score": 0.8901, "epss_percentile": 0.99506}, "CVE-2014-6325": {"epss_score": 0.0513, "epss_percentile": 0.89529}, "CVE-2014-6326": {"epss_score": 0.0513, "epss_percentile": 0.89529}, "CVE-2014-6327": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2014-6328": {"epss_score": 0.33173, "epss_percentile": 0.96751}, "CVE-2014-6329": {"epss_score": 0.25808, "epss_percentile": 0.96074}, "CVE-2014-6330": {"epss_score": 0.20582, "epss_percentile": 0.95381}, "CVE-2014-6331": {"epss_score": 0.33598, "epss_percentile": 0.96786}, "CVE-2014-6332": {"epss_score": 0.94094, "epss_percentile": 0.99901}, "CVE-2014-6333": {"epss_score": 0.45984, "epss_percentile": 0.97516}, "CVE-2014-6334": {"epss_score": 0.45984, "epss_percentile": 0.97516}, "CVE-2014-6335": {"epss_score": 0.45984, "epss_percentile": 0.97516}, "CVE-2014-6336": {"epss_score": 0.03795, "epss_percentile": 0.87735}, "CVE-2014-6337": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2014-6339": {"epss_score": 0.08525, "epss_percentile": 0.92103}, "CVE-2014-6340": {"epss_score": 0.41356, "epss_percentile": 0.97268}, "CVE-2014-6341": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2014-6342": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2014-6343": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2014-6344": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2014-6345": {"epss_score": 0.30508, "epss_percentile": 0.96547}, "CVE-2014-6346": {"epss_score": 0.44808, "epss_percentile": 0.97454}, "CVE-2014-6347": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2014-6348": {"epss_score": 0.19558, "epss_percentile": 0.95209}, "CVE-2014-6349": {"epss_score": 0.08368, "epss_percentile": 0.92012}, "CVE-2014-6350": {"epss_score": 0.08217, "epss_percentile": 0.91934}, "CVE-2014-6351": {"epss_score": 0.20354, "epss_percentile": 0.9533}, "CVE-2014-6352": {"epss_score": 0.90732, "epss_percentile": 0.99598}, "CVE-2014-6353": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2014-6354": {"epss_score": 0.16719, "epss_percentile": 0.9472}, "CVE-2014-6355": {"epss_score": 0.13679, "epss_percentile": 0.94033}, "CVE-2014-6356": {"epss_score": 0.22725, "epss_percentile": 0.95675}, "CVE-2014-6357": {"epss_score": 0.57849, "epss_percentile": 0.98086}, "CVE-2014-6360": {"epss_score": 0.22725, "epss_percentile": 0.95675}, "CVE-2014-6361": {"epss_score": 0.22725, "epss_percentile": 0.95675}, "CVE-2014-6362": {"epss_score": 0.32345, "epss_percentile": 0.96691}, "CVE-2014-6363": {"epss_score": 0.26832, "epss_percentile": 0.96184}, "CVE-2014-6364": {"epss_score": 0.31739, "epss_percentile": 0.96644}, "CVE-2014-6365": {"epss_score": 0.23142, "epss_percentile": 0.95739}, "CVE-2014-6366": {"epss_score": 0.20582, "epss_percentile": 0.95381}, "CVE-2014-6368": {"epss_score": 0.11023, "epss_percentile": 0.93193}, "CVE-2014-6369": {"epss_score": 0.29698, "epss_percentile": 0.96467}, "CVE-2014-6373": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2014-6374": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2014-6375": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2014-6376": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2014-6377": {"epss_score": 0.0089, "epss_percentile": 0.75029}, "CVE-2014-6378": {"epss_score": 0.0089, "epss_percentile": 0.75029}, "CVE-2014-6379": {"epss_score": 0.00527, "epss_percentile": 0.66449}, "CVE-2014-6380": {"epss_score": 0.00905, "epss_percentile": 0.75232}, "CVE-2014-6381": {"epss_score": 0.00204, "epss_percentile": 0.4263}, "CVE-2014-6382": {"epss_score": 0.0046, "epss_percentile": 0.63502}, "CVE-2014-6383": {"epss_score": 0.00448, "epss_percentile": 0.63001}, "CVE-2014-6384": {"epss_score": 0.00051, "epss_percentile": 0.16123}, "CVE-2014-6385": {"epss_score": 0.00384, "epss_percentile": 0.59129}, "CVE-2014-6386": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2014-6387": {"epss_score": 0.00324, "epss_percentile": 0.54965}, "CVE-2014-6389": {"epss_score": 0.14497, "epss_percentile": 0.94224}, "CVE-2014-6392": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2014-6393": {"epss_score": 0.0029, "epss_percentile": 0.52109}, "CVE-2014-6394": {"epss_score": 0.04842, "epss_percentile": 0.89202}, "CVE-2014-6395": {"epss_score": 0.26583, "epss_percentile": 0.96159}, "CVE-2014-6396": {"epss_score": 0.02823, "epss_percentile": 0.8575}, "CVE-2014-6407": {"epss_score": 0.05577, "epss_percentile": 0.90013}, "CVE-2014-6408": {"epss_score": 0.01656, "epss_percentile": 0.81601}, "CVE-2014-6409": {"epss_score": 0.00267, "epss_percentile": 0.49997}, "CVE-2014-6410": {"epss_score": 0.00068, "epss_percentile": 0.21288}, "CVE-2014-6412": {"epss_score": 0.02444, "epss_percentile": 0.84761}, "CVE-2014-6413": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2014-6414": {"epss_score": 0.00573, "epss_percentile": 0.68057}, "CVE-2014-6416": {"epss_score": 0.02899, "epss_percentile": 0.8595}, "CVE-2014-6417": {"epss_score": 0.05588, "epss_percentile": 0.90028}, "CVE-2014-6418": {"epss_score": 0.03966, "epss_percentile": 0.88029}, "CVE-2014-6420": {"epss_score": 0.00881, "epss_percentile": 0.74875}, "CVE-2014-6421": {"epss_score": 0.00469, "epss_percentile": 0.63918}, "CVE-2014-6422": {"epss_score": 0.00566, "epss_percentile": 0.67822}, "CVE-2014-6423": {"epss_score": 0.01641, "epss_percentile": 0.81505}, "CVE-2014-6424": {"epss_score": 0.00462, "epss_percentile": 0.6362}, "CVE-2014-6425": {"epss_score": 0.01102, "epss_percentile": 0.77582}, "CVE-2014-6426": {"epss_score": 0.00271, "epss_percentile": 0.50278}, "CVE-2014-6427": {"epss_score": 0.01328, "epss_percentile": 0.79497}, "CVE-2014-6428": {"epss_score": 0.00558, "epss_percentile": 0.67593}, "CVE-2014-6429": {"epss_score": 0.01869, "epss_percentile": 0.82626}, "CVE-2014-6430": {"epss_score": 0.01869, "epss_percentile": 0.82626}, "CVE-2014-6431": {"epss_score": 0.01527, "epss_percentile": 0.80867}, "CVE-2014-6432": {"epss_score": 0.01641, "epss_percentile": 0.81505}, "CVE-2014-6433": {"epss_score": 0.017, "epss_percentile": 0.81834}, "CVE-2014-6434": {"epss_score": 0.03364, "epss_percentile": 0.86999}, "CVE-2014-6435": {"epss_score": 0.131, "epss_percentile": 0.93875}, "CVE-2014-6436": {"epss_score": 0.14747, "epss_percentile": 0.94272}, "CVE-2014-6437": {"epss_score": 0.18773, "epss_percentile": 0.95067}, "CVE-2014-6438": {"epss_score": 0.01127, "epss_percentile": 0.77823}, "CVE-2014-6439": {"epss_score": 0.00397, "epss_percentile": 0.60034}, "CVE-2014-6440": {"epss_score": 0.05344, "epss_percentile": 0.89766}, "CVE-2014-6444": {"epss_score": 0.0034, "epss_percentile": 0.56266}, "CVE-2014-6445": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-6446": {"epss_score": 0.80814, "epss_percentile": 0.99107}, "CVE-2014-6447": {"epss_score": 0.00475, "epss_percentile": 0.64194}, "CVE-2014-6448": {"epss_score": 0.00038, "epss_percentile": 0.11133}, "CVE-2014-6449": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-6450": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2014-6451": {"epss_score": 0.00453, "epss_percentile": 0.63206}, "CVE-2014-6452": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-6453": {"epss_score": 0.00564, "epss_percentile": 0.67771}, "CVE-2014-6454": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-6455": {"epss_score": 0.00564, "epss_percentile": 0.67771}, "CVE-2014-6456": {"epss_score": 0.0767, "epss_percentile": 0.91613}, "CVE-2014-6457": {"epss_score": 0.10612, "epss_percentile": 0.93048}, "CVE-2014-6458": {"epss_score": 0.00158, "epss_percentile": 0.37227}, "CVE-2014-6459": {"epss_score": 0.00796, "epss_percentile": 0.73481}, "CVE-2014-6460": {"epss_score": 0.00209, "epss_percentile": 0.43394}, "CVE-2014-6461": {"epss_score": 0.00255, "epss_percentile": 0.4864}, "CVE-2014-6462": {"epss_score": 0.00351, "epss_percentile": 0.57071}, "CVE-2014-6463": {"epss_score": 0.00553, "epss_percentile": 0.67431}, "CVE-2014-6464": {"epss_score": 0.00896, "epss_percentile": 0.75118}, "CVE-2014-6465": {"epss_score": 0.00338, "epss_percentile": 0.56068}, "CVE-2014-6466": {"epss_score": 0.00116, "epss_percentile": 0.31041}, "CVE-2014-6467": {"epss_score": 0.00564, "epss_percentile": 0.67771}, "CVE-2014-6468": {"epss_score": 0.0032, "epss_percentile": 0.54627}, "CVE-2014-6469": {"epss_score": 0.00952, "epss_percentile": 0.7588}, "CVE-2014-6470": {"epss_score": 0.00043, "epss_percentile": 0.13098}, "CVE-2014-6471": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2014-6472": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2014-6473": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2014-6474": {"epss_score": 0.00271, "epss_percentile": 0.50334}, "CVE-2014-6475": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2014-6476": {"epss_score": 0.04591, "epss_percentile": 0.88892}, "CVE-2014-6477": {"epss_score": 0.00158, "epss_percentile": 0.37224}, "CVE-2014-6478": {"epss_score": 0.00497, "epss_percentile": 0.65206}, "CVE-2014-6479": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2014-6480": {"epss_score": 0.00358, "epss_percentile": 0.57522}, "CVE-2014-6481": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-6482": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2014-6483": {"epss_score": 0.00351, "epss_percentile": 0.5704}, "CVE-2014-6484": {"epss_score": 0.00471, "epss_percentile": 0.64013}, "CVE-2014-6485": {"epss_score": 0.01123, "epss_percentile": 0.77791}, "CVE-2014-6486": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2014-6487": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2014-6488": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2014-6489": {"epss_score": 0.00707, "epss_percentile": 0.71646}, "CVE-2014-6490": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2014-6491": {"epss_score": 0.0226, "epss_percentile": 0.84185}, "CVE-2014-6492": {"epss_score": 0.01382, "epss_percentile": 0.79886}, "CVE-2014-6493": {"epss_score": 0.10413, "epss_percentile": 0.92979}, "CVE-2014-6494": {"epss_score": 0.01023, "epss_percentile": 0.76765}, "CVE-2014-6495": {"epss_score": 0.00558, "epss_percentile": 0.67596}, "CVE-2014-6496": {"epss_score": 0.00495, "epss_percentile": 0.65108}, "CVE-2014-6497": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2014-6498": {"epss_score": 0.00409, "epss_percentile": 0.60696}, "CVE-2014-6499": {"epss_score": 0.0059, "epss_percentile": 0.68568}, "CVE-2014-6500": {"epss_score": 0.0226, "epss_percentile": 0.84185}, "CVE-2014-6501": {"epss_score": 0.00061, "epss_percentile": 0.19511}, "CVE-2014-6502": {"epss_score": 0.03022, "epss_percentile": 0.86227}, "CVE-2014-6503": {"epss_score": 0.10413, "epss_percentile": 0.92979}, "CVE-2014-6504": {"epss_score": 0.02321, "epss_percentile": 0.84368}, "CVE-2014-6505": {"epss_score": 0.00471, "epss_percentile": 0.64013}, "CVE-2014-6506": {"epss_score": 0.07693, "epss_percentile": 0.9163}, "CVE-2014-6507": {"epss_score": 0.00604, "epss_percentile": 0.68964}, "CVE-2014-6508": {"epss_score": 0.0089, "epss_percentile": 0.75029}, "CVE-2014-6509": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2014-6510": {"epss_score": 0.00043, "epss_percentile": 0.13237}, "CVE-2014-6511": {"epss_score": 0.02618, "epss_percentile": 0.8525}, "CVE-2014-6512": {"epss_score": 0.0419, "epss_percentile": 0.88375}, "CVE-2014-6513": {"epss_score": 0.0657, "epss_percentile": 0.90853}, "CVE-2014-6514": {"epss_score": 0.00191, "epss_percentile": 0.41182}, "CVE-2014-6515": {"epss_score": 0.03119, "epss_percentile": 0.86444}, "CVE-2014-6516": {"epss_score": 0.00388, "epss_percentile": 0.59349}, "CVE-2014-6517": {"epss_score": 0.02786, "epss_percentile": 0.85659}, "CVE-2014-6518": {"epss_score": 0.00043, "epss_percentile": 0.13237}, "CVE-2014-6519": {"epss_score": 0.03119, "epss_percentile": 0.86444}, "CVE-2014-6520": {"epss_score": 0.00471, "epss_percentile": 0.64013}, "CVE-2014-6521": {"epss_score": 0.00048, "epss_percentile": 0.14953}, "CVE-2014-6522": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-6523": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2014-6524": {"epss_score": 0.00048, "epss_percentile": 0.14953}, "CVE-2014-6525": {"epss_score": 0.00139, "epss_percentile": 0.34537}, "CVE-2014-6526": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-6527": {"epss_score": 0.02656, "epss_percentile": 0.85356}, "CVE-2014-6528": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-6529": {"epss_score": 0.00526, "epss_percentile": 0.66413}, "CVE-2014-6530": {"epss_score": 0.00404, "epss_percentile": 0.60398}, "CVE-2014-6531": {"epss_score": 0.02643, "epss_percentile": 0.85311}, "CVE-2014-6532": {"epss_score": 0.07481, "epss_percentile": 0.91496}, "CVE-2014-6533": {"epss_score": 0.00815, "epss_percentile": 0.73788}, "CVE-2014-6534": {"epss_score": 0.00188, "epss_percentile": 0.40893}, "CVE-2014-6535": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2014-6536": {"epss_score": 0.00234, "epss_percentile": 0.46082}, "CVE-2014-6537": {"epss_score": 0.00375, "epss_percentile": 0.58637}, "CVE-2014-6538": {"epss_score": 0.00149, "epss_percentile": 0.3602}, "CVE-2014-6539": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2014-6540": {"epss_score": 0.00172, "epss_percentile": 0.38997}, "CVE-2014-6541": {"epss_score": 0.00194, "epss_percentile": 0.4152}, "CVE-2014-6542": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-6543": {"epss_score": 0.00215, "epss_percentile": 0.44119}, "CVE-2014-6544": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2014-6545": {"epss_score": 0.00564, "epss_percentile": 0.67771}, "CVE-2014-6546": {"epss_score": 0.00564, "epss_percentile": 0.67771}, "CVE-2014-6547": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-6548": {"epss_score": 0.00092, "epss_percentile": 0.26561}, "CVE-2014-6549": {"epss_score": 0.00995, "epss_percentile": 0.76432}, "CVE-2014-6550": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2014-6551": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2014-6552": {"epss_score": 0.00351, "epss_percentile": 0.57071}, "CVE-2014-6553": {"epss_score": 0.00351, "epss_percentile": 0.57071}, "CVE-2014-6554": {"epss_score": 0.00185, "epss_percentile": 0.40532}, "CVE-2014-6555": {"epss_score": 0.00456, "epss_percentile": 0.63354}, "CVE-2014-6556": {"epss_score": 0.00375, "epss_percentile": 0.58637}, "CVE-2014-6557": {"epss_score": 0.00185, "epss_percentile": 0.40532}, "CVE-2014-6558": {"epss_score": 0.03022, "epss_percentile": 0.86227}, "CVE-2014-6559": {"epss_score": 0.00811, "epss_percentile": 0.7373}, "CVE-2014-6560": {"epss_score": 0.00564, "epss_percentile": 0.67771}, "CVE-2014-6561": {"epss_score": 0.00409, "epss_percentile": 0.60696}, "CVE-2014-6562": {"epss_score": 0.01094, "epss_percentile": 0.77495}, "CVE-2014-6563": {"epss_score": 0.00149, "epss_percentile": 0.3602}, "CVE-2014-6564": {"epss_score": 0.00707, "epss_percentile": 0.71646}, "CVE-2014-6565": {"epss_score": 0.00685, "epss_percentile": 0.71137}, "CVE-2014-6566": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2014-6567": {"epss_score": 0.07046, "epss_percentile": 0.91209}, "CVE-2014-6568": {"epss_score": 0.00392, "epss_percentile": 0.59668}, "CVE-2014-6569": {"epss_score": 0.00295, "epss_percentile": 0.5251}, "CVE-2014-6570": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2014-6571": {"epss_score": 0.0059, "epss_percentile": 0.68568}, "CVE-2014-6572": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-6573": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-6574": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-6575": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-6576": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2014-6577": {"epss_score": 0.08779, "epss_percentile": 0.92251}, "CVE-2014-6578": {"epss_score": 0.00424, "epss_percentile": 0.61657}, "CVE-2014-6579": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-6580": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-6581": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-6582": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2014-6583": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-6584": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-6585": {"epss_score": 0.02579, "epss_percentile": 0.8515}, "CVE-2014-6586": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2014-6587": {"epss_score": 0.00141, "epss_percentile": 0.3491}, "CVE-2014-6588": {"epss_score": 0.00079, "epss_percentile": 0.23835}, "CVE-2014-6589": {"epss_score": 0.00113, "epss_percentile": 0.30667}, "CVE-2014-6590": {"epss_score": 0.00113, "epss_percentile": 0.30667}, "CVE-2014-6591": {"epss_score": 0.02311, "epss_percentile": 0.8434}, "CVE-2014-6592": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2014-6593": {"epss_score": 0.55045, "epss_percentile": 0.97958}, "CVE-2014-6594": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2014-6595": {"epss_score": 0.00079, "epss_percentile": 0.23835}, "CVE-2014-6596": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2014-6597": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2014-6598": {"epss_score": 0.10047, "epss_percentile": 0.92826}, "CVE-2014-6599": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2014-6600": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2014-6601": {"epss_score": 0.13255, "epss_percentile": 0.93916}, "CVE-2014-6602": {"epss_score": 0.00711, "epss_percentile": 0.71732}, "CVE-2014-6603": {"epss_score": 0.00471, "epss_percentile": 0.6402}, "CVE-2014-6604": {"epss_score": 0.00178, "epss_percentile": 0.39636}, "CVE-2014-6607": {"epss_score": 0.04879, "epss_percentile": 0.89244}, "CVE-2014-6609": {"epss_score": 0.00795, "epss_percentile": 0.73473}, "CVE-2014-6610": {"epss_score": 0.01519, "epss_percentile": 0.80819}, "CVE-2014-6611": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2014-6616": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-6617": {"epss_score": 0.16321, "epss_percentile": 0.9463}, "CVE-2014-6618": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-6619": {"epss_score": 0.0338, "epss_percentile": 0.8703}, "CVE-2014-6620": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-6621": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-6622": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-6623": {"epss_score": 0.00302, "epss_percentile": 0.53165}, "CVE-2014-6624": {"epss_score": 0.00273, "epss_percentile": 0.50442}, "CVE-2014-6625": {"epss_score": 0.00421, "epss_percentile": 0.6149}, "CVE-2014-6626": {"epss_score": 0.03949, "epss_percentile": 0.87999}, "CVE-2014-6627": {"epss_score": 0.00889, "epss_percentile": 0.75018}, "CVE-2014-6628": {"epss_score": 0.00949, "epss_percentile": 0.7585}, "CVE-2014-6631": {"epss_score": 0.00028, "epss_percentile": 0.07524}, "CVE-2014-6632": {"epss_score": 0.00071, "epss_percentile": 0.22138}, "CVE-2014-6633": {"epss_score": 0.01034, "epss_percentile": 0.76885}, "CVE-2014-6635": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-6636": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6637": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6638": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6639": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6640": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6641": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6642": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6643": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6645": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6646": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6647": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6648": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6649": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6650": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6651": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6652": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6653": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6654": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6655": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6656": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6657": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6658": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6659": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6660": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6661": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6662": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6663": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6664": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6665": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6666": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6667": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6668": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6669": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6670": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6671": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6672": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6673": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6674": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6675": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6676": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6677": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6678": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6679": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6680": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6681": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6682": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6683": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6684": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6685": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6686": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6687": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6688": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6689": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6690": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-6691": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6692": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-6693": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6694": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6695": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6696": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6697": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6698": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6699": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6700": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6701": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6702": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6703": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6704": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6705": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6706": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6707": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6708": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6709": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6710": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6711": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6712": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6713": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6714": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6715": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6716": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6717": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6718": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6719": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6720": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6721": {"epss_score": 0.00737, "epss_percentile": 0.72329}, "CVE-2014-6722": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6723": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6724": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6725": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6726": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6727": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6728": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6729": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6730": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6731": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6732": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6733": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6734": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6735": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6736": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6737": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6738": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6739": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6740": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6741": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6742": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6743": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6744": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6745": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6746": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6747": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6748": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6749": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6750": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6751": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6752": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6753": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6754": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6755": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6756": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6757": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6758": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6759": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6760": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6761": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6762": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6763": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6764": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6765": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6766": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6767": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6768": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6769": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6770": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6771": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6772": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6773": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6774": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6775": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6776": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6777": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6778": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6779": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6780": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6781": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6782": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6783": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6784": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6785": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6786": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6787": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6788": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6789": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6790": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6791": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6792": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6793": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6794": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6795": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6796": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6797": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6798": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6799": {"epss_score": 0.00115, "epss_percentile": 0.30998}, "CVE-2014-6800": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6801": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6802": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6803": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6804": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6805": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6806": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6807": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6808": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6810": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6812": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6813": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6814": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6815": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6816": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6817": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6818": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6819": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6820": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-6821": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6822": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6823": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6824": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6825": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6826": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6827": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6828": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6829": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6830": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6831": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6832": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6833": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6834": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6835": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6836": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6837": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6838": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6839": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6840": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6841": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6842": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6843": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6844": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6845": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6846": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6847": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6848": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6850": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6851": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6852": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6853": {"epss_score": 0.00605, "epss_percentile": 0.68977}, "CVE-2014-6854": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6855": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6856": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6857": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6858": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6859": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6860": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6861": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6862": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6863": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6864": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6865": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6866": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6867": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6868": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6869": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6870": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6871": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6872": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6873": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6874": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6875": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6876": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6877": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6878": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6879": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6880": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6881": {"epss_score": 0.00134, "epss_percentile": 0.33856}, "CVE-2014-6882": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6883": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6884": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6885": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6886": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6887": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6888": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6889": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6890": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6891": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6892": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6893": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6894": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6895": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6896": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6897": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6898": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6899": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6900": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6901": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6902": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6903": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6904": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6905": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6906": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6907": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6908": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6909": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6910": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6911": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6912": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6913": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6914": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6916": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6917": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6918": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6919": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6920": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6921": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6922": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6923": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6924": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6925": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6926": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6927": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6928": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-6929": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6930": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6931": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6932": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6933": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6934": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6935": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6936": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6937": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6938": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6939": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6940": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6941": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6942": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6943": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6944": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6945": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6946": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6947": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6948": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6949": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6950": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6951": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6952": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6953": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6954": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6955": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6956": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6957": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6958": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6959": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6960": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6961": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6962": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6963": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6964": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6965": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6966": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6967": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6968": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6969": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6970": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6971": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6972": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6973": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6974": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6975": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6976": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6977": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6978": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6979": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6980": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6981": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6982": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6983": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6984": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6985": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6986": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6987": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6988": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6989": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6990": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6991": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6992": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6993": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6994": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6995": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6996": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6997": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6998": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-6999": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7000": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7001": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7002": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7003": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7004": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7005": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7006": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7007": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7008": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7009": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7010": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7011": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7012": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7013": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7015": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7016": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7017": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7018": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7019": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7020": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7021": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7022": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7023": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7024": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7025": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7026": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7027": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7028": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7029": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7030": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7031": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7032": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7033": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7034": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7035": {"epss_score": 0.00184, "epss_percentile": 0.40392}, "CVE-2014-7036": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7037": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7038": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7039": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7040": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7041": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7042": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7043": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7044": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7045": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7046": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7047": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7048": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7049": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7050": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7052": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7053": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7054": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7055": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7056": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7057": {"epss_score": 0.00184, "epss_percentile": 0.40392}, "CVE-2014-7058": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7059": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7060": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7061": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7062": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7063": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7064": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7065": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7066": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7067": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7068": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7069": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7070": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7071": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7072": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7073": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7075": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7076": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7077": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7078": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7079": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7080": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7082": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7083": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7084": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7085": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7086": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7087": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7088": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7089": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7090": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7091": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7092": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7093": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7098": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7099": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7100": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7101": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7102": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7103": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7104": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7106": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7107": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7108": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7109": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7111": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7113": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7115": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7116": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7117": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7118": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7119": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7120": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7121": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7122": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7123": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7124": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7125": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7127": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7128": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7129": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7131": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7132": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7134": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7135": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7136": {"epss_score": 0.00114, "epss_percentile": 0.3086}, "CVE-2014-7137": {"epss_score": 0.00335, "epss_percentile": 0.55859}, "CVE-2014-7138": {"epss_score": 0.00586, "epss_percentile": 0.6844}, "CVE-2014-7139": {"epss_score": 0.00233, "epss_percentile": 0.46}, "CVE-2014-7140": {"epss_score": 0.0625, "epss_percentile": 0.90614}, "CVE-2014-7141": {"epss_score": 0.77333, "epss_percentile": 0.98932}, "CVE-2014-7142": {"epss_score": 0.64227, "epss_percentile": 0.9837}, "CVE-2014-7143": {"epss_score": 0.00351, "epss_percentile": 0.5705}, "CVE-2014-7144": {"epss_score": 0.00365, "epss_percentile": 0.58002}, "CVE-2014-7145": {"epss_score": 0.01212, "epss_percentile": 0.78561}, "CVE-2014-7146": {"epss_score": 0.80388, "epss_percentile": 0.99085}, "CVE-2014-7151": {"epss_score": 0.00166, "epss_percentile": 0.38236}, "CVE-2014-7152": {"epss_score": 0.00168, "epss_percentile": 0.38498}, "CVE-2014-7153": {"epss_score": 0.01486, "epss_percentile": 0.80608}, "CVE-2014-7154": {"epss_score": 0.00775, "epss_percentile": 0.73086}, "CVE-2014-7155": {"epss_score": 0.01034, "epss_percentile": 0.76888}, "CVE-2014-7156": {"epss_score": 0.00801, "epss_percentile": 0.73564}, "CVE-2014-7157": {"epss_score": 0.00336, "epss_percentile": 0.55918}, "CVE-2014-7158": {"epss_score": 0.00176, "epss_percentile": 0.39375}, "CVE-2014-7169": {"epss_score": 0.8961, "epss_percentile": 0.99534}, "CVE-2014-7170": {"epss_score": 0.00044, "epss_percentile": 0.13369}, "CVE-2014-7173": {"epss_score": 0.13082, "epss_percentile": 0.93868}, "CVE-2014-7174": {"epss_score": 0.00147, "epss_percentile": 0.35672}, "CVE-2014-7175": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2014-7176": {"epss_score": 0.13783, "epss_percentile": 0.94057}, "CVE-2014-7177": {"epss_score": 0.11584, "epss_percentile": 0.93411}, "CVE-2014-7178": {"epss_score": 0.10014, "epss_percentile": 0.92818}, "CVE-2014-7180": {"epss_score": 0.00048, "epss_percentile": 0.152}, "CVE-2014-7181": {"epss_score": 0.00347, "epss_percentile": 0.56792}, "CVE-2014-7182": {"epss_score": 0.00335, "epss_percentile": 0.55852}, "CVE-2014-7183": {"epss_score": 0.00821, "epss_percentile": 0.73899}, "CVE-2014-7185": {"epss_score": 0.00766, "epss_percentile": 0.72933}, "CVE-2014-7186": {"epss_score": 0.89656, "epss_percentile": 0.99537}, "CVE-2014-7187": {"epss_score": 0.89369, "epss_percentile": 0.99522}, "CVE-2014-7188": {"epss_score": 0.02548, "epss_percentile": 0.85068}, "CVE-2014-7189": {"epss_score": 0.00286, "epss_percentile": 0.51688}, "CVE-2014-7190": {"epss_score": 0.002, "epss_percentile": 0.42221}, "CVE-2014-7191": {"epss_score": 0.03001, "epss_percentile": 0.86167}, "CVE-2014-7192": {"epss_score": 0.43935, "epss_percentile": 0.97408}, "CVE-2014-7193": {"epss_score": 0.00194, "epss_percentile": 0.41556}, "CVE-2014-7194": {"epss_score": 0.00229, "epss_percentile": 0.45651}, "CVE-2014-7195": {"epss_score": 0.00141, "epss_percentile": 0.34909}, "CVE-2014-7198": {"epss_score": 0.00183, "epss_percentile": 0.40281}, "CVE-2014-7199": {"epss_score": 0.00311, "epss_percentile": 0.53922}, "CVE-2014-7200": {"epss_score": 0.08033, "epss_percentile": 0.91845}, "CVE-2014-7201": {"epss_score": 0.01366, "epss_percentile": 0.7978}, "CVE-2014-7202": {"epss_score": 0.00582, "epss_percentile": 0.6829}, "CVE-2014-7203": {"epss_score": 0.00582, "epss_percentile": 0.6829}, "CVE-2014-7204": {"epss_score": 0.02815, "epss_percentile": 0.85728}, "CVE-2014-7205": {"epss_score": 0.84242, "epss_percentile": 0.9928}, "CVE-2014-7206": {"epss_score": 0.00048, "epss_percentile": 0.15199}, "CVE-2014-7207": {"epss_score": 0.00087, "epss_percentile": 0.25468}, "CVE-2014-7208": {"epss_score": 0.00532, "epss_percentile": 0.66673}, "CVE-2014-7209": {"epss_score": 0.0068, "epss_percentile": 0.71028}, "CVE-2014-7210": {"epss_score": 0.00073, "epss_percentile": 0.22557}, "CVE-2014-7216": {"epss_score": 0.05592, "epss_percentile": 0.9003}, "CVE-2014-7217": {"epss_score": 0.00339, "epss_percentile": 0.56184}, "CVE-2014-7221": {"epss_score": 0.10229, "epss_percentile": 0.92903}, "CVE-2014-7222": {"epss_score": 0.12099, "epss_percentile": 0.93566}, "CVE-2014-7224": {"epss_score": 0.02201, "epss_percentile": 0.83981}, "CVE-2014-7226": {"epss_score": 0.0806, "epss_percentile": 0.91859}, "CVE-2014-7228": {"epss_score": 0.07974, "epss_percentile": 0.91799}, "CVE-2014-7229": {"epss_score": 0.00082, "epss_percentile": 0.2444}, "CVE-2014-7230": {"epss_score": 0.00123, "epss_percentile": 0.3218}, "CVE-2014-7231": {"epss_score": 0.00157, "epss_percentile": 0.37079}, "CVE-2014-7232": {"epss_score": 0.00624, "epss_percentile": 0.69573}, "CVE-2014-7233": {"epss_score": 0.00568, "epss_percentile": 0.67896}, "CVE-2014-7235": {"epss_score": 0.57417, "epss_percentile": 0.98061}, "CVE-2014-7236": {"epss_score": 0.84226, "epss_percentile": 0.99279}, "CVE-2014-7237": {"epss_score": 0.29599, "epss_percentile": 0.9646}, "CVE-2014-7238": {"epss_score": 0.00264, "epss_percentile": 0.49695}, "CVE-2014-7240": {"epss_score": 0.00178, "epss_percentile": 0.39636}, "CVE-2014-7241": {"epss_score": 0.00485, "epss_percentile": 0.64732}, "CVE-2014-7242": {"epss_score": 0.00256, "epss_percentile": 0.48791}, "CVE-2014-7243": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2014-7246": {"epss_score": 0.0048, "epss_percentile": 0.64473}, "CVE-2014-7247": {"epss_score": 0.06015, "epss_percentile": 0.90411}, "CVE-2014-7248": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-7249": {"epss_score": 0.08447, "epss_percentile": 0.92056}, "CVE-2014-7250": {"epss_score": 0.0373, "epss_percentile": 0.8764}, "CVE-2014-7251": {"epss_score": 0.00075, "epss_percentile": 0.2294}, "CVE-2014-7252": {"epss_score": 0.00072, "epss_percentile": 0.22381}, "CVE-2014-7253": {"epss_score": 0.00266, "epss_percentile": 0.4995}, "CVE-2014-7254": {"epss_score": 0.00063, "epss_percentile": 0.19827}, "CVE-2014-7255": {"epss_score": 0.01775, "epss_percentile": 0.82214}, "CVE-2014-7256": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2014-7257": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2014-7258": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-7259": {"epss_score": 0.00257, "epss_percentile": 0.48947}, "CVE-2014-7260": {"epss_score": 0.00881, "epss_percentile": 0.7488}, "CVE-2014-7261": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2014-7262": {"epss_score": 0.00284, "epss_percentile": 0.51477}, "CVE-2014-7263": {"epss_score": 0.00193, "epss_percentile": 0.41392}, "CVE-2014-7264": {"epss_score": 0.0018, "epss_percentile": 0.39898}, "CVE-2014-7265": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2014-7266": {"epss_score": 0.00547, "epss_percentile": 0.67255}, "CVE-2014-7267": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2014-7268": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2014-7269": {"epss_score": 0.00548, "epss_percentile": 0.67275}, "CVE-2014-7270": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2014-7271": {"epss_score": 0.00087, "epss_percentile": 0.25532}, "CVE-2014-7272": {"epss_score": 0.00149, "epss_percentile": 0.36012}, "CVE-2014-7273": {"epss_score": 0.0021, "epss_percentile": 0.43435}, "CVE-2014-7274": {"epss_score": 0.00177, "epss_percentile": 0.39584}, "CVE-2014-7275": {"epss_score": 0.00177, "epss_percentile": 0.39584}, "CVE-2014-7277": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2014-7278": {"epss_score": 0.00687, "epss_percentile": 0.71188}, "CVE-2014-7279": {"epss_score": 0.57903, "epss_percentile": 0.9809}, "CVE-2014-7280": {"epss_score": 0.10062, "epss_percentile": 0.92837}, "CVE-2014-7281": {"epss_score": 0.00332, "epss_percentile": 0.55576}, "CVE-2014-7283": {"epss_score": 0.0004, "epss_percentile": 0.12017}, "CVE-2014-7284": {"epss_score": 0.01011, "epss_percentile": 0.76611}, "CVE-2014-7285": {"epss_score": 0.74024, "epss_percentile": 0.98783}, "CVE-2014-7286": {"epss_score": 0.00786, "epss_percentile": 0.7329}, "CVE-2014-7287": {"epss_score": 0.00513, "epss_percentile": 0.65902}, "CVE-2014-7288": {"epss_score": 0.11203, "epss_percentile": 0.93263}, "CVE-2014-7289": {"epss_score": 0.00876, "epss_percentile": 0.74797}, "CVE-2014-7290": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-7291": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2014-7292": {"epss_score": 0.00544, "epss_percentile": 0.67125}, "CVE-2014-7293": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-7294": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2014-7295": {"epss_score": 0.00238, "epss_percentile": 0.46776}, "CVE-2014-7296": {"epss_score": 0.00533, "epss_percentile": 0.66776}, "CVE-2014-7297": {"epss_score": 0.01537, "epss_percentile": 0.80924}, "CVE-2014-7298": {"epss_score": 0.00055, "epss_percentile": 0.17656}, "CVE-2014-7299": {"epss_score": 0.00185, "epss_percentile": 0.40485}, "CVE-2014-7300": {"epss_score": 0.00044, "epss_percentile": 0.13558}, "CVE-2014-7301": {"epss_score": 0.00125, "epss_percentile": 0.32558}, "CVE-2014-7302": {"epss_score": 0.00064, "epss_percentile": 0.20178}, "CVE-2014-7303": {"epss_score": 0.00051, "epss_percentile": 0.16292}, "CVE-2014-7307": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7309": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7310": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7313": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7314": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7315": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7316": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7317": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7320": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7321": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7323": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7325": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7326": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7327": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7328": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7329": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7330": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7331": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7333": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7334": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7335": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7336": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7337": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7338": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7339": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7340": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7341": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7342": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7344": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7345": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7346": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7348": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7351": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7352": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7353": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7354": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7357": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7358": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7359": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7360": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7361": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7362": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7364": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7366": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7367": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7368": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7369": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7370": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7371": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7372": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7373": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7374": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7375": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7376": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7378": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7379": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7380": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7382": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7384": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7385": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7387": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7388": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7389": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7390": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7391": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7392": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7393": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7394": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7395": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7396": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7397": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7398": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7399": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7402": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7403": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7405": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7406": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7407": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7408": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7409": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7410": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7413": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7414": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7415": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7416": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7417": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7418": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7419": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7420": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7421": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7422": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7423": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7424": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7425": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7427": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7428": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7430": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7431": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7432": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7433": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7434": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7435": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7436": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7437": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7439": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7441": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7443": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7444": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7445": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7446": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7447": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7448": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7449": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7450": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7452": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7454": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7455": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7456": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7457": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7458": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7459": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7460": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7461": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7462": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7463": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7464": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7465": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7466": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7467": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7468": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7469": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7470": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7471": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7472": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7475": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7476": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7478": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7481": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7483": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7484": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7485": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7486": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7487": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7488": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7490": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7491": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7492": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7493": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7494": {"epss_score": 0.00106, "epss_percentile": 0.29553}, "CVE-2014-7495": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7497": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7498": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7499": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7501": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7502": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7505": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7506": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7507": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7508": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7509": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7510": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7513": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7515": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7516": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7517": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7518": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7519": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7520": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7521": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7522": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7523": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7524": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7525": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7526": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7527": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7528": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7529": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7530": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7532": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7533": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7534": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7535": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7536": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7538": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7539": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7542": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7543": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7544": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7546": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7547": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7550": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7551": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7552": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7553": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7554": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7555": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7557": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7558": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7559": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7560": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7562": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7563": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7564": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7565": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7566": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7567": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7568": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7569": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7570": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7571": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7572": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7573": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7575": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7576": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7577": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7578": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7580": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7581": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7582": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7584": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7585": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7587": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7589": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7590": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7591": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7592": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7593": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7595": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7596": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7597": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7598": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7602": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7603": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7604": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7605": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7606": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7607": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7608": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7609": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7610": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7611": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7612": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7613": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7614": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7616": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7617": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7618": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7620": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7621": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7622": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7624": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-7626": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7628": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7629": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7630": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7631": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7632": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7633": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7634": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7636": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7638": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7640": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7642": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7643": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7644": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-7646": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7647": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7648": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7649": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7650": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7652": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7655": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7656": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7659": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7660": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7661": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7663": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7664": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7666": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7667": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7668": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7670": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7671": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7674": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7676": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7677": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7681": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7682": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7683": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7685": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7686": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7688": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7689": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7690": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7691": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7692": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7693": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7694": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7695": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7696": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7697": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7698": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7700": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7701": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7702": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7703": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7705": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7707": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7708": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7710": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7712": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7713": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7714": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7715": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7716": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7717": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7718": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7719": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7720": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7721": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7722": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7723": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7724": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7725": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7726": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7727": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7728": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7731": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7733": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7734": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7735": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7737": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7739": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7740": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7741": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7742": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7743": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7744": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7745": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7746": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7748": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7749": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7750": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7751": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7752": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7753": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7754": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7755": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7756": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7757": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7758": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7759": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7760": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7761": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7762": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7763": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7764": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7765": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7766": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7767": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7768": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7769": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7770": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7771": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7772": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7773": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7774": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7775": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7776": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7777": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7778": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7779": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7780": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7781": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7782": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7783": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7784": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7785": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-7786": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7787": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7788": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7789": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7791": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7793": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7794": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7795": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7796": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7797": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7798": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2014-7799": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7800": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7802": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7803": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7804": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2014-7807": {"epss_score": 0.00419, "epss_percentile": 0.61352}, "CVE-2014-7808": {"epss_score": 0.00267, "epss_percentile": 0.49987}, "CVE-2014-7809": {"epss_score": 0.12466, "epss_percentile": 0.93681}, "CVE-2014-7810": {"epss_score": 0.12051, "epss_percentile": 0.93556}, "CVE-2014-7811": {"epss_score": 0.00184, "epss_percentile": 0.40451}, "CVE-2014-7812": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2014-7813": {"epss_score": 0.00432, "epss_percentile": 0.621}, "CVE-2014-7814": {"epss_score": 0.00311, "epss_percentile": 0.5386}, "CVE-2014-7815": {"epss_score": 0.05232, "epss_percentile": 0.89643}, "CVE-2014-7816": {"epss_score": 0.55155, "epss_percentile": 0.97963}, "CVE-2014-7817": {"epss_score": 0.00158, "epss_percentile": 0.37192}, "CVE-2014-7818": {"epss_score": 0.00301, "epss_percentile": 0.53073}, "CVE-2014-7819": {"epss_score": 0.01013, "epss_percentile": 0.76637}, "CVE-2014-7821": {"epss_score": 0.02168, "epss_percentile": 0.8386}, "CVE-2014-7822": {"epss_score": 0.00397, "epss_percentile": 0.60041}, "CVE-2014-7823": {"epss_score": 0.00531, "epss_percentile": 0.66643}, "CVE-2014-7824": {"epss_score": 0.00093, "epss_percentile": 0.26702}, "CVE-2014-7825": {"epss_score": 0.00035, "epss_percentile": 0.09855}, "CVE-2014-7826": {"epss_score": 0.0008, "epss_percentile": 0.24191}, "CVE-2014-7827": {"epss_score": 0.00316, "epss_percentile": 0.54223}, "CVE-2014-7828": {"epss_score": 0.00407, "epss_percentile": 0.60595}, "CVE-2014-7829": {"epss_score": 0.00266, "epss_percentile": 0.4995}, "CVE-2014-7830": {"epss_score": 0.00208, "epss_percentile": 0.43213}, "CVE-2014-7831": {"epss_score": 0.00252, "epss_percentile": 0.48369}, "CVE-2014-7832": {"epss_score": 0.00243, "epss_percentile": 0.47423}, "CVE-2014-7833": {"epss_score": 0.00273, "epss_percentile": 0.5048}, "CVE-2014-7834": {"epss_score": 0.0019, "epss_percentile": 0.41126}, "CVE-2014-7835": {"epss_score": 0.0018, "epss_percentile": 0.39898}, "CVE-2014-7836": {"epss_score": 0.00173, "epss_percentile": 0.39114}, "CVE-2014-7837": {"epss_score": 0.00606, "epss_percentile": 0.69028}, "CVE-2014-7838": {"epss_score": 0.00173, "epss_percentile": 0.39114}, "CVE-2014-7839": {"epss_score": 0.01262, "epss_percentile": 0.78984}, "CVE-2014-7840": {"epss_score": 0.02455, "epss_percentile": 0.84799}, "CVE-2014-7841": {"epss_score": 0.18308, "epss_percentile": 0.94992}, "CVE-2014-7842": {"epss_score": 0.00065, "epss_percentile": 0.20527}, "CVE-2014-7843": {"epss_score": 0.00092, "epss_percentile": 0.26488}, "CVE-2014-7844": {"epss_score": 0.01025, "epss_percentile": 0.76791}, "CVE-2014-7845": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2014-7846": {"epss_score": 0.00243, "epss_percentile": 0.47423}, "CVE-2014-7847": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2014-7848": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2014-7849": {"epss_score": 0.004, "epss_percentile": 0.60162}, "CVE-2014-7850": {"epss_score": 0.00361, "epss_percentile": 0.57705}, "CVE-2014-7851": {"epss_score": 0.00388, "epss_percentile": 0.59368}, "CVE-2014-7852": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-7853": {"epss_score": 0.00428, "epss_percentile": 0.61956}, "CVE-2014-7857": {"epss_score": 0.01478, "epss_percentile": 0.80552}, "CVE-2014-7858": {"epss_score": 0.0178, "epss_percentile": 0.82237}, "CVE-2014-7859": {"epss_score": 0.10545, "epss_percentile": 0.93023}, "CVE-2014-7860": {"epss_score": 0.00638, "epss_percentile": 0.69927}, "CVE-2014-7861": {"epss_score": 0.02604, "epss_percentile": 0.85214}, "CVE-2014-7862": {"epss_score": 0.81398, "epss_percentile": 0.99136}, "CVE-2014-7863": {"epss_score": 0.88867, "epss_percentile": 0.99495}, "CVE-2014-7864": {"epss_score": 0.32185, "epss_percentile": 0.96677}, "CVE-2014-7866": {"epss_score": 0.82753, "epss_percentile": 0.99212}, "CVE-2014-7867": {"epss_score": 0.62145, "epss_percentile": 0.98283}, "CVE-2014-7868": {"epss_score": 0.69684, "epss_percentile": 0.98598}, "CVE-2014-7869": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2014-7870": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2014-7871": {"epss_score": 0.00308, "epss_percentile": 0.53599}, "CVE-2014-7872": {"epss_score": 0.0074, "epss_percentile": 0.72403}, "CVE-2014-7874": {"epss_score": 0.00161, "epss_percentile": 0.37573}, "CVE-2014-7875": {"epss_score": 0.02339, "epss_percentile": 0.84426}, "CVE-2014-7876": {"epss_score": 0.25213, "epss_percentile": 0.95999}, "CVE-2014-7877": {"epss_score": 0.00083, "epss_percentile": 0.24791}, "CVE-2014-7878": {"epss_score": 0.28809, "epss_percentile": 0.96388}, "CVE-2014-7879": {"epss_score": 0.00421, "epss_percentile": 0.61511}, "CVE-2014-7880": {"epss_score": 0.01324, "epss_percentile": 0.7946}, "CVE-2014-7881": {"epss_score": 0.00595, "epss_percentile": 0.68681}, "CVE-2014-7882": {"epss_score": 0.0037, "epss_percentile": 0.5829}, "CVE-2014-7883": {"epss_score": 0.53161, "epss_percentile": 0.97858}, "CVE-2014-7884": {"epss_score": 0.23191, "epss_percentile": 0.95748}, "CVE-2014-7885": {"epss_score": 0.00742, "epss_percentile": 0.72453}, "CVE-2014-7888": {"epss_score": 0.30081, "epss_percentile": 0.96505}, "CVE-2014-7889": {"epss_score": 0.28809, "epss_percentile": 0.96388}, "CVE-2014-7890": {"epss_score": 0.30081, "epss_percentile": 0.96505}, "CVE-2014-7891": {"epss_score": 0.30081, "epss_percentile": 0.96505}, "CVE-2014-7892": {"epss_score": 0.28809, "epss_percentile": 0.96388}, "CVE-2014-7893": {"epss_score": 0.30081, "epss_percentile": 0.96505}, "CVE-2014-7894": {"epss_score": 0.30081, "epss_percentile": 0.96505}, "CVE-2014-7895": {"epss_score": 0.28809, "epss_percentile": 0.96388}, "CVE-2014-7896": {"epss_score": 0.00595, "epss_percentile": 0.68681}, "CVE-2014-7897": {"epss_score": 0.28809, "epss_percentile": 0.96388}, "CVE-2014-7898": {"epss_score": 0.23355, "epss_percentile": 0.9577}, "CVE-2014-7899": {"epss_score": 0.00562, "epss_percentile": 0.67702}, "CVE-2014-7900": {"epss_score": 0.01221, "epss_percentile": 0.78651}, "CVE-2014-7901": {"epss_score": 0.01221, "epss_percentile": 0.78651}, "CVE-2014-7902": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2014-7903": {"epss_score": 0.01331, "epss_percentile": 0.79517}, "CVE-2014-7904": {"epss_score": 0.01122, "epss_percentile": 0.77783}, "CVE-2014-7905": {"epss_score": 0.0021, "epss_percentile": 0.43442}, "CVE-2014-7906": {"epss_score": 0.01037, "epss_percentile": 0.76921}, "CVE-2014-7907": {"epss_score": 0.01338, "epss_percentile": 0.79567}, "CVE-2014-7908": {"epss_score": 0.01338, "epss_percentile": 0.79567}, "CVE-2014-7909": {"epss_score": 0.0166, "epss_percentile": 0.81618}, "CVE-2014-7910": {"epss_score": 0.1563, "epss_percentile": 0.94473}, "CVE-2014-7911": {"epss_score": 0.8219, "epss_percentile": 0.99179}, "CVE-2014-7912": {"epss_score": 0.00524, "epss_percentile": 0.66318}, "CVE-2014-7913": {"epss_score": 0.00571, "epss_percentile": 0.67989}, "CVE-2014-7914": {"epss_score": 0.00147, "epss_percentile": 0.35648}, "CVE-2014-7915": {"epss_score": 0.00218, "epss_percentile": 0.44431}, "CVE-2014-7916": {"epss_score": 0.00218, "epss_percentile": 0.44431}, "CVE-2014-7917": {"epss_score": 0.00218, "epss_percentile": 0.44431}, "CVE-2014-7919": {"epss_score": 0.00306, "epss_percentile": 0.53422}, "CVE-2014-7920": {"epss_score": 0.0962, "epss_percentile": 0.92626}, "CVE-2014-7921": {"epss_score": 0.00219, "epss_percentile": 0.44488}, "CVE-2014-7922": {"epss_score": 0.00095, "epss_percentile": 0.27235}, "CVE-2014-7923": {"epss_score": 0.02277, "epss_percentile": 0.84231}, "CVE-2014-7924": {"epss_score": 0.02997, "epss_percentile": 0.86157}, "CVE-2014-7925": {"epss_score": 0.03194, "epss_percentile": 0.86608}, "CVE-2014-7926": {"epss_score": 0.02277, "epss_percentile": 0.84231}, "CVE-2014-7927": {"epss_score": 0.0316, "epss_percentile": 0.86529}, "CVE-2014-7928": {"epss_score": 0.0316, "epss_percentile": 0.86529}, "CVE-2014-7929": {"epss_score": 0.02471, "epss_percentile": 0.84849}, "CVE-2014-7930": {"epss_score": 0.02471, "epss_percentile": 0.84849}, "CVE-2014-7931": {"epss_score": 0.0316, "epss_percentile": 0.86529}, "CVE-2014-7932": {"epss_score": 0.02471, "epss_percentile": 0.84849}, "CVE-2014-7933": {"epss_score": 0.05935, "epss_percentile": 0.90341}, "CVE-2014-7934": {"epss_score": 0.0291, "epss_percentile": 0.8597}, "CVE-2014-7935": {"epss_score": 0.0213, "epss_percentile": 0.83711}, "CVE-2014-7936": {"epss_score": 0.0233, "epss_percentile": 0.84399}, "CVE-2014-7937": {"epss_score": 0.02211, "epss_percentile": 0.84014}, "CVE-2014-7938": {"epss_score": 0.02358, "epss_percentile": 0.84489}, "CVE-2014-7939": {"epss_score": 0.00694, "epss_percentile": 0.71347}, "CVE-2014-7940": {"epss_score": 0.02151, "epss_percentile": 0.83786}, "CVE-2014-7941": {"epss_score": 0.02253, "epss_percentile": 0.84164}, "CVE-2014-7942": {"epss_score": 0.02358, "epss_percentile": 0.84489}, "CVE-2014-7943": {"epss_score": 0.01712, "epss_percentile": 0.81884}, "CVE-2014-7944": {"epss_score": 0.01675, "epss_percentile": 0.817}, "CVE-2014-7945": {"epss_score": 0.01675, "epss_percentile": 0.817}, "CVE-2014-7946": {"epss_score": 0.02414, "epss_percentile": 0.84678}, "CVE-2014-7947": {"epss_score": 0.01575, "epss_percentile": 0.8111}, "CVE-2014-7948": {"epss_score": 0.00569, "epss_percentile": 0.67932}, "CVE-2014-7951": {"epss_score": 0.01965, "epss_percentile": 0.83077}, "CVE-2014-7952": {"epss_score": 0.00121, "epss_percentile": 0.3189}, "CVE-2014-7953": {"epss_score": 0.01386, "epss_percentile": 0.79909}, "CVE-2014-7954": {"epss_score": 0.00416, "epss_percentile": 0.61163}, "CVE-2014-7956": {"epss_score": 0.00198, "epss_percentile": 0.42023}, "CVE-2014-7957": {"epss_score": 0.00227, "epss_percentile": 0.45428}, "CVE-2014-7958": {"epss_score": 0.00624, "epss_percentile": 0.69562}, "CVE-2014-7959": {"epss_score": 0.00923, "epss_percentile": 0.75509}, "CVE-2014-7960": {"epss_score": 0.00297, "epss_percentile": 0.52692}, "CVE-2014-7967": {"epss_score": 0.00111, "epss_percentile": 0.30259}, "CVE-2014-7968": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2014-7970": {"epss_score": 0.0004, "epss_percentile": 0.12139}, "CVE-2014-7975": {"epss_score": 0.00073, "epss_percentile": 0.22544}, "CVE-2014-7978": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2014-7979": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2014-7980": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2014-7981": {"epss_score": 0.14338, "epss_percentile": 0.9419}, "CVE-2014-7982": {"epss_score": 0.0002, "epss_percentile": 0.04553}, "CVE-2014-7983": {"epss_score": 0.0003, "epss_percentile": 0.08172}, "CVE-2014-7984": {"epss_score": 0.0019, "epss_percentile": 0.41063}, "CVE-2014-7985": {"epss_score": 0.01717, "epss_percentile": 0.81917}, "CVE-2014-7986": {"epss_score": 0.00581, "epss_percentile": 0.68279}, "CVE-2014-7987": {"epss_score": 0.00275, "epss_percentile": 0.50632}, "CVE-2014-7988": {"epss_score": 0.00306, "epss_percentile": 0.53452}, "CVE-2014-7989": {"epss_score": 0.00084, "epss_percentile": 0.24898}, "CVE-2014-7990": {"epss_score": 0.00084, "epss_percentile": 0.24898}, "CVE-2014-7991": {"epss_score": 0.00292, "epss_percentile": 0.52222}, "CVE-2014-7992": {"epss_score": 0.5995, "epss_percentile": 0.98188}, "CVE-2014-7993": {"epss_score": 0.00123, "epss_percentile": 0.32214}, "CVE-2014-7994": {"epss_score": 0.00147, "epss_percentile": 0.35648}, "CVE-2014-7995": {"epss_score": 0.00095, "epss_percentile": 0.27144}, "CVE-2014-7996": {"epss_score": 0.00174, "epss_percentile": 0.39171}, "CVE-2014-7997": {"epss_score": 0.00246, "epss_percentile": 0.47745}, "CVE-2014-7998": {"epss_score": 0.00563, "epss_percentile": 0.67723}, "CVE-2014-7999": {"epss_score": 0.00201, "epss_percentile": 0.42336}, "CVE-2014-8000": {"epss_score": 0.00735, "epss_percentile": 0.72287}, "CVE-2014-8001": {"epss_score": 0.03043, "epss_percentile": 0.86276}, "CVE-2014-8002": {"epss_score": 0.02128, "epss_percentile": 0.837}, "CVE-2014-8003": {"epss_score": 0.00073, "epss_percentile": 0.22666}, "CVE-2014-8004": {"epss_score": 0.00865, "epss_percentile": 0.74616}, "CVE-2014-8005": {"epss_score": 0.00566, "epss_percentile": 0.67811}, "CVE-2014-8006": {"epss_score": 0.00368, "epss_percentile": 0.5819}, "CVE-2014-8007": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2014-8008": {"epss_score": 0.09021, "epss_percentile": 0.9237}, "CVE-2014-8009": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2014-8010": {"epss_score": 0.0036, "epss_percentile": 0.57686}, "CVE-2014-8012": {"epss_score": 0.00296, "epss_percentile": 0.52563}, "CVE-2014-8013": {"epss_score": 0.00093, "epss_percentile": 0.26697}, "CVE-2014-8014": {"epss_score": 0.00766, "epss_percentile": 0.72947}, "CVE-2014-8015": {"epss_score": 0.00171, "epss_percentile": 0.38827}, "CVE-2014-8016": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2014-8017": {"epss_score": 0.00152, "epss_percentile": 0.36421}, "CVE-2014-8018": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-8019": {"epss_score": 0.00251, "epss_percentile": 0.4831}, "CVE-2014-8020": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2014-8021": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2014-8022": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2014-8023": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2014-8024": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2014-8025": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2014-8026": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-8027": {"epss_score": 0.00161, "epss_percentile": 0.37572}, "CVE-2014-8028": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2014-8029": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2014-8030": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2014-8031": {"epss_score": 0.00174, "epss_percentile": 0.39171}, "CVE-2014-8032": {"epss_score": 0.00207, "epss_percentile": 0.43119}, "CVE-2014-8033": {"epss_score": 0.00303, "epss_percentile": 0.53186}, "CVE-2014-8034": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2014-8035": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2014-8036": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-8068": {"epss_score": 0.00398, "epss_percentile": 0.60067}, "CVE-2014-8069": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-8070": {"epss_score": 0.00396, "epss_percentile": 0.599}, "CVE-2014-8071": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-8072": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2014-8073": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2014-8074": {"epss_score": 0.00418, "epss_percentile": 0.61292}, "CVE-2014-8075": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2014-8076": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2014-8077": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2014-8078": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2014-8079": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2014-8080": {"epss_score": 0.10784, "epss_percentile": 0.93103}, "CVE-2014-8081": {"epss_score": 0.03228, "epss_percentile": 0.86691}, "CVE-2014-8082": {"epss_score": 0.00656, "epss_percentile": 0.70445}, "CVE-2014-8083": {"epss_score": 0.00605, "epss_percentile": 0.68995}, "CVE-2014-8084": {"epss_score": 0.02119, "epss_percentile": 0.8367}, "CVE-2014-8085": {"epss_score": 0.01042, "epss_percentile": 0.76972}, "CVE-2014-8086": {"epss_score": 0.00036, "epss_percentile": 0.10434}, "CVE-2014-8087": {"epss_score": 0.00311, "epss_percentile": 0.53847}, "CVE-2014-8088": {"epss_score": 0.00608, "epss_percentile": 0.69084}, "CVE-2014-8089": {"epss_score": 0.01115, "epss_percentile": 0.77707}, "CVE-2014-8090": {"epss_score": 0.10488, "epss_percentile": 0.93004}, "CVE-2014-8091": {"epss_score": 0.06313, "epss_percentile": 0.90665}, "CVE-2014-8092": {"epss_score": 0.01293, "epss_percentile": 0.79238}, "CVE-2014-8093": {"epss_score": 0.01297, "epss_percentile": 0.79267}, "CVE-2014-8094": {"epss_score": 0.01042, "epss_percentile": 0.76971}, "CVE-2014-8095": {"epss_score": 0.01115, "epss_percentile": 0.77711}, "CVE-2014-8096": {"epss_score": 0.01014, "epss_percentile": 0.76647}, "CVE-2014-8097": {"epss_score": 0.01297, "epss_percentile": 0.79267}, "CVE-2014-8098": {"epss_score": 0.0101, "epss_percentile": 0.76595}, "CVE-2014-8099": {"epss_score": 0.01337, "epss_percentile": 0.7956}, "CVE-2014-8100": {"epss_score": 0.01297, "epss_percentile": 0.79267}, "CVE-2014-8101": {"epss_score": 0.01269, "epss_percentile": 0.79035}, "CVE-2014-8102": {"epss_score": 0.01115, "epss_percentile": 0.77711}, "CVE-2014-8103": {"epss_score": 0.01787, "epss_percentile": 0.82259}, "CVE-2014-8104": {"epss_score": 0.02041, "epss_percentile": 0.83367}, "CVE-2014-8105": {"epss_score": 0.00463, "epss_percentile": 0.63633}, "CVE-2014-8106": {"epss_score": 0.00347, "epss_percentile": 0.56793}, "CVE-2014-8108": {"epss_score": 0.04996, "epss_percentile": 0.89373}, "CVE-2014-8109": {"epss_score": 0.17551, "epss_percentile": 0.94865}, "CVE-2014-8110": {"epss_score": 0.03908, "epss_percentile": 0.87931}, "CVE-2014-8111": {"epss_score": 0.03739, "epss_percentile": 0.87653}, "CVE-2014-8112": {"epss_score": 0.0031, "epss_percentile": 0.53759}, "CVE-2014-8114": {"epss_score": 0.01771, "epss_percentile": 0.82198}, "CVE-2014-8115": {"epss_score": 0.00216, "epss_percentile": 0.44157}, "CVE-2014-8116": {"epss_score": 0.15876, "epss_percentile": 0.94525}, "CVE-2014-8117": {"epss_score": 0.16453, "epss_percentile": 0.94665}, "CVE-2014-8118": {"epss_score": 0.11803, "epss_percentile": 0.93481}, "CVE-2014-8119": {"epss_score": 0.02408, "epss_percentile": 0.84659}, "CVE-2014-8120": {"epss_score": 0.00052, "epss_percentile": 0.16352}, "CVE-2014-8121": {"epss_score": 0.02992, "epss_percentile": 0.86146}, "CVE-2014-8122": {"epss_score": 0.00754, "epss_percentile": 0.72693}, "CVE-2014-8123": {"epss_score": 0.01019, "epss_percentile": 0.76724}, "CVE-2014-8124": {"epss_score": 0.0097, "epss_percentile": 0.76106}, "CVE-2014-8125": {"epss_score": 0.00957, "epss_percentile": 0.75936}, "CVE-2014-8126": {"epss_score": 0.01451, "epss_percentile": 0.80365}, "CVE-2014-8127": {"epss_score": 0.00411, "epss_percentile": 0.60885}, "CVE-2014-8128": {"epss_score": 0.01463, "epss_percentile": 0.80445}, "CVE-2014-8129": {"epss_score": 0.0084, "epss_percentile": 0.742}, "CVE-2014-8130": {"epss_score": 0.02075, "epss_percentile": 0.83506}, "CVE-2014-8131": {"epss_score": 0.00374, "epss_percentile": 0.58564}, "CVE-2014-8132": {"epss_score": 0.03289, "epss_percentile": 0.86834}, "CVE-2014-8133": {"epss_score": 0.00043, "epss_percentile": 0.12958}, "CVE-2014-8134": {"epss_score": 0.00076, "epss_percentile": 0.23178}, "CVE-2014-8135": {"epss_score": 0.00158, "epss_percentile": 0.37182}, "CVE-2014-8136": {"epss_score": 0.00131, "epss_percentile": 0.33478}, "CVE-2014-8137": {"epss_score": 0.31457, "epss_percentile": 0.96621}, "CVE-2014-8138": {"epss_score": 0.05895, "epss_percentile": 0.90302}, "CVE-2014-8139": {"epss_score": 0.09808, "epss_percentile": 0.9271}, "CVE-2014-8140": {"epss_score": 0.09808, "epss_percentile": 0.9271}, "CVE-2014-8141": {"epss_score": 0.09808, "epss_percentile": 0.9271}, "CVE-2014-8142": {"epss_score": 0.88277, "epss_percentile": 0.99465}, "CVE-2014-8143": {"epss_score": 0.04898, "epss_percentile": 0.89271}, "CVE-2014-8144": {"epss_score": 0.00126, "epss_percentile": 0.32707}, "CVE-2014-8145": {"epss_score": 0.12998, "epss_percentile": 0.93839}, "CVE-2014-8146": {"epss_score": 0.25808, "epss_percentile": 0.96074}, "CVE-2014-8147": {"epss_score": 0.41904, "epss_percentile": 0.973}, "CVE-2014-8148": {"epss_score": 0.00071, "epss_percentile": 0.22029}, "CVE-2014-8149": {"epss_score": 0.0107, "epss_percentile": 0.77256}, "CVE-2014-8150": {"epss_score": 0.0123, "epss_percentile": 0.78727}, "CVE-2014-8151": {"epss_score": 0.00424, "epss_percentile": 0.61674}, "CVE-2014-8152": {"epss_score": 0.0396, "epss_percentile": 0.88011}, "CVE-2014-8153": {"epss_score": 0.00709, "epss_percentile": 0.71692}, "CVE-2014-8154": {"epss_score": 0.00888, "epss_percentile": 0.75001}, "CVE-2014-8155": {"epss_score": 0.00286, "epss_percentile": 0.51743}, "CVE-2014-8156": {"epss_score": 0.00064, "epss_percentile": 0.20285}, "CVE-2014-8157": {"epss_score": 0.05821, "epss_percentile": 0.90234}, "CVE-2014-8158": {"epss_score": 0.06219, "epss_percentile": 0.90576}, "CVE-2014-8159": {"epss_score": 0.00077, "epss_percentile": 0.23459}, "CVE-2014-8160": {"epss_score": 0.02896, "epss_percentile": 0.85926}, "CVE-2014-8161": {"epss_score": 0.00579, "epss_percentile": 0.68216}, "CVE-2014-8162": {"epss_score": 0.00606, "epss_percentile": 0.68999}, "CVE-2014-8163": {"epss_score": 0.00684, "epss_percentile": 0.71121}, "CVE-2014-8164": {"epss_score": 0.00142, "epss_percentile": 0.35007}, "CVE-2014-8165": {"epss_score": 0.05318, "epss_percentile": 0.89725}, "CVE-2014-8166": {"epss_score": 0.01071, "epss_percentile": 0.77268}, "CVE-2014-8167": {"epss_score": 0.00166, "epss_percentile": 0.38178}, "CVE-2014-8168": {"epss_score": 0.00034, "epss_percentile": 0.0944}, "CVE-2014-8169": {"epss_score": 0.0011, "epss_percentile": 0.30119}, "CVE-2014-8170": {"epss_score": 0.00523, "epss_percentile": 0.663}, "CVE-2014-8171": {"epss_score": 0.00049, "epss_percentile": 0.15368}, "CVE-2014-8172": {"epss_score": 0.00096, "epss_percentile": 0.27293}, "CVE-2014-8173": {"epss_score": 0.00045, "epss_percentile": 0.14071}, "CVE-2014-8174": {"epss_score": 0.028, "epss_percentile": 0.85694}, "CVE-2014-8175": {"epss_score": 0.00191, "epss_percentile": 0.41201}, "CVE-2014-8176": {"epss_score": 0.23776, "epss_percentile": 0.95816}, "CVE-2014-8177": {"epss_score": 0.00219, "epss_percentile": 0.44444}, "CVE-2014-8178": {"epss_score": 0.00139, "epss_percentile": 0.34658}, "CVE-2014-8179": {"epss_score": 0.00674, "epss_percentile": 0.70849}, "CVE-2014-8180": {"epss_score": 0.00047, "epss_percentile": 0.14828}, "CVE-2014-8181": {"epss_score": 0.00229, "epss_percentile": 0.45596}, "CVE-2014-8182": {"epss_score": 0.05154, "epss_percentile": 0.89551}, "CVE-2014-8183": {"epss_score": 0.00153, "epss_percentile": 0.3658}, "CVE-2014-8184": {"epss_score": 0.00691, "epss_percentile": 0.71269}, "CVE-2014-8240": {"epss_score": 0.01094, "epss_percentile": 0.77499}, "CVE-2014-8241": {"epss_score": 0.00695, "epss_percentile": 0.71381}, "CVE-2014-8242": {"epss_score": 0.02282, "epss_percentile": 0.84257}, "CVE-2014-8243": {"epss_score": 0.00158, "epss_percentile": 0.37178}, "CVE-2014-8244": {"epss_score": 0.13943, "epss_percentile": 0.94097}, "CVE-2014-8246": {"epss_score": 0.00198, "epss_percentile": 0.42031}, "CVE-2014-8247": {"epss_score": 0.01224, "epss_percentile": 0.78678}, "CVE-2014-8248": {"epss_score": 0.00703, "epss_percentile": 0.71549}, "CVE-2014-8266": {"epss_score": 0.00547, "epss_percentile": 0.67243}, "CVE-2014-8267": {"epss_score": 0.00909, "epss_percentile": 0.75291}, "CVE-2014-8268": {"epss_score": 0.00947, "epss_percentile": 0.75822}, "CVE-2014-8269": {"epss_score": 0.17062, "epss_percentile": 0.94767}, "CVE-2014-8270": {"epss_score": 0.62077, "epss_percentile": 0.98276}, "CVE-2014-8271": {"epss_score": 0.00219, "epss_percentile": 0.44516}, "CVE-2014-8272": {"epss_score": 0.407, "epss_percentile": 0.97233}, "CVE-2014-8275": {"epss_score": 0.05946, "epss_percentile": 0.90353}, "CVE-2014-8293": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-8294": {"epss_score": 0.00289, "epss_percentile": 0.52024}, "CVE-2014-8295": {"epss_score": 0.00943, "epss_percentile": 0.7578}, "CVE-2014-8296": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-8298": {"epss_score": 0.015, "epss_percentile": 0.80711}, "CVE-2014-8301": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-8302": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2014-8303": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-8304": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-8305": {"epss_score": 0.03069, "epss_percentile": 0.86343}, "CVE-2014-8306": {"epss_score": 0.00826, "epss_percentile": 0.73969}, "CVE-2014-8307": {"epss_score": 0.00494, "epss_percentile": 0.65068}, "CVE-2014-8308": {"epss_score": 0.00467, "epss_percentile": 0.63861}, "CVE-2014-8309": {"epss_score": 0.0049, "epss_percentile": 0.64931}, "CVE-2014-8310": {"epss_score": 0.03517, "epss_percentile": 0.87276}, "CVE-2014-8311": {"epss_score": 0.00423, "epss_percentile": 0.61598}, "CVE-2014-8312": {"epss_score": 0.0055, "epss_percentile": 0.6735}, "CVE-2014-8313": {"epss_score": 0.00795, "epss_percentile": 0.73461}, "CVE-2014-8314": {"epss_score": 0.00431, "epss_percentile": 0.62053}, "CVE-2014-8315": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2014-8316": {"epss_score": 0.00797, "epss_percentile": 0.735}, "CVE-2014-8317": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2014-8318": {"epss_score": 0.00268, "epss_percentile": 0.50054}, "CVE-2014-8319": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2014-8320": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2014-8321": {"epss_score": 0.00191, "epss_percentile": 0.41214}, "CVE-2014-8322": {"epss_score": 0.32211, "epss_percentile": 0.9668}, "CVE-2014-8323": {"epss_score": 0.07882, "epss_percentile": 0.91741}, "CVE-2014-8324": {"epss_score": 0.07882, "epss_percentile": 0.91741}, "CVE-2014-8325": {"epss_score": 0.0089, "epss_percentile": 0.75029}, "CVE-2014-8326": {"epss_score": 0.00269, "epss_percentile": 0.50167}, "CVE-2014-8327": {"epss_score": 0.00151, "epss_percentile": 0.36203}, "CVE-2014-8328": {"epss_score": 0.00324, "epss_percentile": 0.54976}, "CVE-2014-8329": {"epss_score": 0.01072, "epss_percentile": 0.77281}, "CVE-2014-8330": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2014-8331": {"epss_score": 0.00062, "epss_percentile": 0.19612}, "CVE-2014-8333": {"epss_score": 0.00736, "epss_percentile": 0.7231}, "CVE-2014-8334": {"epss_score": 0.04305, "epss_percentile": 0.88521}, "CVE-2014-8335": {"epss_score": 0.00106, "epss_percentile": 0.29434}, "CVE-2014-8336": {"epss_score": 0.01226, "epss_percentile": 0.7869}, "CVE-2014-8337": {"epss_score": 0.04136, "epss_percentile": 0.88307}, "CVE-2014-8338": {"epss_score": 0.00366, "epss_percentile": 0.58058}, "CVE-2014-8339": {"epss_score": 0.00432, "epss_percentile": 0.62099}, "CVE-2014-8340": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2014-8346": {"epss_score": 0.00488, "epss_percentile": 0.64848}, "CVE-2014-8347": {"epss_score": 0.00606, "epss_percentile": 0.69022}, "CVE-2014-8349": {"epss_score": 0.00253, "epss_percentile": 0.48437}, "CVE-2014-8350": {"epss_score": 0.00473, "epss_percentile": 0.64091}, "CVE-2014-8351": {"epss_score": 0.00322, "epss_percentile": 0.5483}, "CVE-2014-8352": {"epss_score": 0.00388, "epss_percentile": 0.59394}, "CVE-2014-8354": {"epss_score": 0.00606, "epss_percentile": 0.69002}, "CVE-2014-8355": {"epss_score": 0.00491, "epss_percentile": 0.64979}, "CVE-2014-8356": {"epss_score": 0.01814, "epss_percentile": 0.82379}, "CVE-2014-8357": {"epss_score": 0.18268, "epss_percentile": 0.94985}, "CVE-2014-8358": {"epss_score": 0.00784, "epss_percentile": 0.73233}, "CVE-2014-8359": {"epss_score": 0.00433, "epss_percentile": 0.62178}, "CVE-2014-8360": {"epss_score": 0.00982, "epss_percentile": 0.76297}, "CVE-2014-8361": {"epss_score": 0.93992, "epss_percentile": 0.99881}, "CVE-2014-8362": {"epss_score": 0.02667, "epss_percentile": 0.85379}, "CVE-2014-8363": {"epss_score": 0.00374, "epss_percentile": 0.5853}, "CVE-2014-8364": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-8365": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-8366": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2014-8367": {"epss_score": 0.0078, "epss_percentile": 0.73166}, "CVE-2014-8368": {"epss_score": 0.01368, "epss_percentile": 0.79788}, "CVE-2014-8369": {"epss_score": 0.0008, "epss_percentile": 0.2407}, "CVE-2014-8370": {"epss_score": 0.01041, "epss_percentile": 0.76967}, "CVE-2014-8371": {"epss_score": 0.00127, "epss_percentile": 0.32837}, "CVE-2014-8372": {"epss_score": 0.00126, "epss_percentile": 0.32678}, "CVE-2014-8373": {"epss_score": 0.01373, "epss_percentile": 0.79819}, "CVE-2014-8375": {"epss_score": 0.01391, "epss_percentile": 0.79952}, "CVE-2014-8376": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2014-8377": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-8378": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2014-8379": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2014-8380": {"epss_score": 0.03324, "epss_percentile": 0.86918}, "CVE-2014-8381": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2014-8383": {"epss_score": 0.04503, "epss_percentile": 0.88768}, "CVE-2014-8384": {"epss_score": 0.01059, "epss_percentile": 0.7716}, "CVE-2014-8385": {"epss_score": 0.01221, "epss_percentile": 0.78644}, "CVE-2014-8386": {"epss_score": 0.27881, "epss_percentile": 0.9629}, "CVE-2014-8387": {"epss_score": 0.13448, "epss_percentile": 0.93968}, "CVE-2014-8388": {"epss_score": 0.00246, "epss_percentile": 0.47756}, "CVE-2014-8389": {"epss_score": 0.14008, "epss_percentile": 0.94113}, "CVE-2014-8390": {"epss_score": 0.00163, "epss_percentile": 0.37757}, "CVE-2014-8391": {"epss_score": 0.09737, "epss_percentile": 0.92681}, "CVE-2014-8393": {"epss_score": 0.0484, "epss_percentile": 0.89197}, "CVE-2014-8394": {"epss_score": 0.07891, "epss_percentile": 0.91748}, "CVE-2014-8395": {"epss_score": 0.07891, "epss_percentile": 0.91748}, "CVE-2014-8396": {"epss_score": 0.07891, "epss_percentile": 0.91748}, "CVE-2014-8397": {"epss_score": 0.07891, "epss_percentile": 0.91748}, "CVE-2014-8398": {"epss_score": 0.07891, "epss_percentile": 0.91748}, "CVE-2014-8399": {"epss_score": 0.00131, "epss_percentile": 0.33424}, "CVE-2014-8412": {"epss_score": 0.00597, "epss_percentile": 0.68744}, "CVE-2014-8413": {"epss_score": 0.0033, "epss_percentile": 0.55428}, "CVE-2014-8414": {"epss_score": 0.01902, "epss_percentile": 0.82781}, "CVE-2014-8415": {"epss_score": 0.0091, "epss_percentile": 0.75317}, "CVE-2014-8416": {"epss_score": 0.01066, "epss_percentile": 0.77221}, "CVE-2014-8417": {"epss_score": 0.00897, "epss_percentile": 0.75135}, "CVE-2014-8418": {"epss_score": 0.01284, "epss_percentile": 0.79169}, "CVE-2014-8419": {"epss_score": 0.00034, "epss_percentile": 0.0966}, "CVE-2014-8420": {"epss_score": 0.73815, "epss_percentile": 0.98773}, "CVE-2014-8421": {"epss_score": 0.00632, "epss_percentile": 0.69751}, "CVE-2014-8422": {"epss_score": 0.00471, "epss_percentile": 0.64001}, "CVE-2014-8423": {"epss_score": 0.41689, "epss_percentile": 0.97289}, "CVE-2014-8424": {"epss_score": 0.53544, "epss_percentile": 0.97881}, "CVE-2014-8425": {"epss_score": 0.12485, "epss_percentile": 0.93687}, "CVE-2014-8426": {"epss_score": 0.00786, "epss_percentile": 0.73269}, "CVE-2014-8428": {"epss_score": 0.00937, "epss_percentile": 0.75691}, "CVE-2014-8429": {"epss_score": 0.00559, "epss_percentile": 0.67615}, "CVE-2014-8437": {"epss_score": 0.02256, "epss_percentile": 0.84172}, "CVE-2014-8438": {"epss_score": 0.06948, "epss_percentile": 0.91134}, "CVE-2014-8439": {"epss_score": 0.27067, "epss_percentile": 0.96202}, "CVE-2014-8440": {"epss_score": 0.8681, "epss_percentile": 0.99399}, "CVE-2014-8441": {"epss_score": 0.09297, "epss_percentile": 0.92488}, "CVE-2014-8442": {"epss_score": 0.02992, "epss_percentile": 0.86146}, "CVE-2014-8443": {"epss_score": 0.10924, "epss_percentile": 0.9316}, "CVE-2014-8445": {"epss_score": 0.20515, "epss_percentile": 0.95362}, "CVE-2014-8446": {"epss_score": 0.27545, "epss_percentile": 0.96256}, "CVE-2014-8447": {"epss_score": 0.20515, "epss_percentile": 0.95362}, "CVE-2014-8448": {"epss_score": 0.28151, "epss_percentile": 0.96326}, "CVE-2014-8449": {"epss_score": 0.34609, "epss_percentile": 0.96861}, "CVE-2014-8450": {"epss_score": 0.02761, "epss_percentile": 0.85602}, "CVE-2014-8451": {"epss_score": 0.28151, "epss_percentile": 0.96326}, "CVE-2014-8452": {"epss_score": 0.12443, "epss_percentile": 0.93673}, "CVE-2014-8453": {"epss_score": 0.1006, "epss_percentile": 0.92836}, "CVE-2014-8454": {"epss_score": 0.2145, "epss_percentile": 0.9552}, "CVE-2014-8455": {"epss_score": 0.2145, "epss_percentile": 0.9552}, "CVE-2014-8456": {"epss_score": 0.20515, "epss_percentile": 0.95362}, "CVE-2014-8457": {"epss_score": 0.28504, "epss_percentile": 0.96364}, "CVE-2014-8458": {"epss_score": 0.20515, "epss_percentile": 0.95362}, "CVE-2014-8459": {"epss_score": 0.20515, "epss_percentile": 0.95362}, "CVE-2014-8460": {"epss_score": 0.36278, "epss_percentile": 0.96965}, "CVE-2014-8461": {"epss_score": 0.20515, "epss_percentile": 0.95362}, "CVE-2014-8469": {"epss_score": 0.09115, "epss_percentile": 0.92406}, "CVE-2014-8471": {"epss_score": 0.00377, "epss_percentile": 0.58711}, "CVE-2014-8472": {"epss_score": 0.0033, "epss_percentile": 0.55427}, "CVE-2014-8473": {"epss_score": 0.00182, "epss_percentile": 0.40144}, "CVE-2014-8474": {"epss_score": 0.00831, "epss_percentile": 0.74043}, "CVE-2014-8475": {"epss_score": 0.01683, "epss_percentile": 0.81738}, "CVE-2014-8476": {"epss_score": 0.00068, "epss_percentile": 0.21414}, "CVE-2014-8478": {"epss_score": 0.00505, "epss_percentile": 0.65609}, "CVE-2014-8479": {"epss_score": 0.00418, "epss_percentile": 0.61325}, "CVE-2014-8480": {"epss_score": 0.00072, "epss_percentile": 0.22362}, "CVE-2014-8481": {"epss_score": 0.00072, "epss_percentile": 0.22362}, "CVE-2014-8483": {"epss_score": 0.03723, "epss_percentile": 0.87628}, "CVE-2014-8484": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2014-8485": {"epss_score": 0.04177, "epss_percentile": 0.88353}, "CVE-2014-8487": {"epss_score": 0.00284, "epss_percentile": 0.51423}, "CVE-2014-8488": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-8489": {"epss_score": 0.00253, "epss_percentile": 0.48451}, "CVE-2014-8490": {"epss_score": 0.00285, "epss_percentile": 0.51542}, "CVE-2014-8491": {"epss_score": 0.00264, "epss_percentile": 0.49707}, "CVE-2014-8492": {"epss_score": 0.00152, "epss_percentile": 0.36381}, "CVE-2014-8493": {"epss_score": 0.16313, "epss_percentile": 0.94628}, "CVE-2014-8494": {"epss_score": 0.00042, "epss_percentile": 0.12788}, "CVE-2014-8495": {"epss_score": 0.00386, "epss_percentile": 0.5926}, "CVE-2014-8496": {"epss_score": 0.01785, "epss_percentile": 0.82253}, "CVE-2014-8498": {"epss_score": 0.04568, "epss_percentile": 0.8886}, "CVE-2014-8499": {"epss_score": 0.76519, "epss_percentile": 0.98895}, "CVE-2014-8500": {"epss_score": 0.58417, "epss_percentile": 0.98115}, "CVE-2014-8501": {"epss_score": 0.06122, "epss_percentile": 0.90496}, "CVE-2014-8502": {"epss_score": 0.08369, "epss_percentile": 0.92014}, "CVE-2014-8503": {"epss_score": 0.0996, "epss_percentile": 0.92794}, "CVE-2014-8504": {"epss_score": 0.04445, "epss_percentile": 0.88698}, "CVE-2014-8505": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-8506": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2014-8507": {"epss_score": 0.03404, "epss_percentile": 0.87072}, "CVE-2014-8508": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-8509": {"epss_score": 0.08457, "epss_percentile": 0.92062}, "CVE-2014-8510": {"epss_score": 0.00236, "epss_percentile": 0.46393}, "CVE-2014-8511": {"epss_score": 0.05351, "epss_percentile": 0.89774}, "CVE-2014-8512": {"epss_score": 0.02556, "epss_percentile": 0.85091}, "CVE-2014-8513": {"epss_score": 0.02556, "epss_percentile": 0.85091}, "CVE-2014-8514": {"epss_score": 0.0358, "epss_percentile": 0.87383}, "CVE-2014-8515": {"epss_score": 0.00587, "epss_percentile": 0.68475}, "CVE-2014-8516": {"epss_score": 0.82704, "epss_percentile": 0.99209}, "CVE-2014-8517": {"epss_score": 0.8518, "epss_percentile": 0.99323}, "CVE-2014-8518": {"epss_score": 0.00031, "epss_percentile": 0.0871}, "CVE-2014-8519": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2014-8520": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2014-8521": {"epss_score": 0.00105, "epss_percentile": 0.29306}, "CVE-2014-8522": {"epss_score": 0.00574, "epss_percentile": 0.6807}, "CVE-2014-8523": {"epss_score": 0.00157, "epss_percentile": 0.37076}, "CVE-2014-8524": {"epss_score": 0.00403, "epss_percentile": 0.60333}, "CVE-2014-8525": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2014-8526": {"epss_score": 0.00118, "epss_percentile": 0.31485}, "CVE-2014-8527": {"epss_score": 0.00131, "epss_percentile": 0.33468}, "CVE-2014-8528": {"epss_score": 0.00131, "epss_percentile": 0.33468}, "CVE-2014-8529": {"epss_score": 0.00131, "epss_percentile": 0.33468}, "CVE-2014-8530": {"epss_score": 0.00623, "epss_percentile": 0.69538}, "CVE-2014-8531": {"epss_score": 0.04257, "epss_percentile": 0.8846}, "CVE-2014-8532": {"epss_score": 0.00131, "epss_percentile": 0.33468}, "CVE-2014-8533": {"epss_score": 0.03007, "epss_percentile": 0.86187}, "CVE-2014-8534": {"epss_score": 0.00051, "epss_percentile": 0.16155}, "CVE-2014-8535": {"epss_score": 0.00054, "epss_percentile": 0.17077}, "CVE-2014-8536": {"epss_score": 0.00061, "epss_percentile": 0.19284}, "CVE-2014-8537": {"epss_score": 0.00061, "epss_percentile": 0.19284}, "CVE-2014-8538": {"epss_score": 0.00184, "epss_percentile": 0.40392}, "CVE-2014-8539": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2014-8540": {"epss_score": 0.0032, "epss_percentile": 0.54635}, "CVE-2014-8541": {"epss_score": 0.00829, "epss_percentile": 0.74014}, "CVE-2014-8542": {"epss_score": 0.01766, "epss_percentile": 0.82172}, "CVE-2014-8543": {"epss_score": 0.01629, "epss_percentile": 0.8144}, "CVE-2014-8544": {"epss_score": 0.01205, "epss_percentile": 0.78514}, "CVE-2014-8545": {"epss_score": 0.01024, "epss_percentile": 0.76779}, "CVE-2014-8546": {"epss_score": 0.01024, "epss_percentile": 0.76779}, "CVE-2014-8547": {"epss_score": 0.0089, "epss_percentile": 0.75032}, "CVE-2014-8548": {"epss_score": 0.00829, "epss_percentile": 0.74014}, "CVE-2014-8549": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2014-8551": {"epss_score": 0.05807, "epss_percentile": 0.90224}, "CVE-2014-8552": {"epss_score": 0.00118, "epss_percentile": 0.31502}, "CVE-2014-8553": {"epss_score": 0.00635, "epss_percentile": 0.69812}, "CVE-2014-8554": {"epss_score": 0.00741, "epss_percentile": 0.7245}, "CVE-2014-8555": {"epss_score": 0.03515, "epss_percentile": 0.87273}, "CVE-2014-8557": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-8558": {"epss_score": 0.00191, "epss_percentile": 0.41201}, "CVE-2014-8559": {"epss_score": 0.00055, "epss_percentile": 0.17404}, "CVE-2014-8561": {"epss_score": 0.01037, "epss_percentile": 0.76928}, "CVE-2014-8562": {"epss_score": 0.0047, "epss_percentile": 0.63988}, "CVE-2014-8563": {"epss_score": 0.03212, "epss_percentile": 0.86657}, "CVE-2014-8564": {"epss_score": 0.00812, "epss_percentile": 0.73753}, "CVE-2014-8566": {"epss_score": 0.01092, "epss_percentile": 0.77465}, "CVE-2014-8567": {"epss_score": 0.04434, "epss_percentile": 0.88684}, "CVE-2014-8570": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2014-8571": {"epss_score": 0.00089, "epss_percentile": 0.25873}, "CVE-2014-8572": {"epss_score": 0.00281, "epss_percentile": 0.51134}, "CVE-2014-8577": {"epss_score": 0.15436, "epss_percentile": 0.9443}, "CVE-2014-8578": {"epss_score": 0.00317, "epss_percentile": 0.54378}, "CVE-2014-8579": {"epss_score": 0.01229, "epss_percentile": 0.78719}, "CVE-2014-8580": {"epss_score": 0.00251, "epss_percentile": 0.48313}, "CVE-2014-8582": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2014-8583": {"epss_score": 0.00107, "epss_percentile": 0.29682}, "CVE-2014-8584": {"epss_score": 0.00461, "epss_percentile": 0.63549}, "CVE-2014-8585": {"epss_score": 0.00203, "epss_percentile": 0.42575}, "CVE-2014-8586": {"epss_score": 0.78024, "epss_percentile": 0.98965}, "CVE-2014-8587": {"epss_score": 0.00585, "epss_percentile": 0.68426}, "CVE-2014-8588": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2014-8589": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2014-8590": {"epss_score": 0.00963, "epss_percentile": 0.7602}, "CVE-2014-8591": {"epss_score": 0.01389, "epss_percentile": 0.79929}, "CVE-2014-8592": {"epss_score": 0.0189, "epss_percentile": 0.82726}, "CVE-2014-8593": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-8594": {"epss_score": 0.01876, "epss_percentile": 0.82661}, "CVE-2014-8595": {"epss_score": 0.00071, "epss_percentile": 0.22025}, "CVE-2014-8596": {"epss_score": 0.0408, "epss_percentile": 0.88217}, "CVE-2014-8597": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2014-8598": {"epss_score": 0.67363, "epss_percentile": 0.98503}, "CVE-2014-8600": {"epss_score": 0.00283, "epss_percentile": 0.51353}, "CVE-2014-8601": {"epss_score": 0.00887, "epss_percentile": 0.74969}, "CVE-2014-8602": {"epss_score": 0.09755, "epss_percentile": 0.92691}, "CVE-2014-8603": {"epss_score": 0.06193, "epss_percentile": 0.90554}, "CVE-2014-8604": {"epss_score": 0.08404, "epss_percentile": 0.92034}, "CVE-2014-8605": {"epss_score": 0.07668, "epss_percentile": 0.91612}, "CVE-2014-8606": {"epss_score": 0.07264, "epss_percentile": 0.91358}, "CVE-2014-8607": {"epss_score": 0.00203, "epss_percentile": 0.42577}, "CVE-2014-8608": {"epss_score": 0.00075, "epss_percentile": 0.22885}, "CVE-2014-8609": {"epss_score": 0.00473, "epss_percentile": 0.64082}, "CVE-2014-8610": {"epss_score": 0.00061, "epss_percentile": 0.19309}, "CVE-2014-8611": {"epss_score": 0.00112, "epss_percentile": 0.3055}, "CVE-2014-8612": {"epss_score": 0.0036, "epss_percentile": 0.57657}, "CVE-2014-8613": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2014-8616": {"epss_score": 0.00323, "epss_percentile": 0.54864}, "CVE-2014-8617": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2014-8618": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-8619": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2014-8621": {"epss_score": 0.02546, "epss_percentile": 0.85063}, "CVE-2014-8622": {"epss_score": 0.00284, "epss_percentile": 0.51444}, "CVE-2014-8625": {"epss_score": 0.02462, "epss_percentile": 0.84828}, "CVE-2014-8626": {"epss_score": 0.03954, "epss_percentile": 0.88003}, "CVE-2014-8627": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2014-8628": {"epss_score": 0.0048, "epss_percentile": 0.64472}, "CVE-2014-8629": {"epss_score": 0.00361, "epss_percentile": 0.5771}, "CVE-2014-8630": {"epss_score": 0.00633, "epss_percentile": 0.69757}, "CVE-2014-8631": {"epss_score": 0.00217, "epss_percentile": 0.44261}, "CVE-2014-8632": {"epss_score": 0.00209, "epss_percentile": 0.43337}, "CVE-2014-8634": {"epss_score": 0.01748, "epss_percentile": 0.82082}, "CVE-2014-8635": {"epss_score": 0.01513, "epss_percentile": 0.80787}, "CVE-2014-8636": {"epss_score": 0.83612, "epss_percentile": 0.99254}, "CVE-2014-8637": {"epss_score": 0.00489, "epss_percentile": 0.649}, "CVE-2014-8638": {"epss_score": 0.00496, "epss_percentile": 0.65149}, "CVE-2014-8639": {"epss_score": 0.01837, "epss_percentile": 0.82481}, "CVE-2014-8640": {"epss_score": 0.0114, "epss_percentile": 0.7795}, "CVE-2014-8641": {"epss_score": 0.01522, "epss_percentile": 0.80837}, "CVE-2014-8642": {"epss_score": 0.00659, "epss_percentile": 0.7051}, "CVE-2014-8643": {"epss_score": 0.01348, "epss_percentile": 0.79662}, "CVE-2014-8650": {"epss_score": 0.00477, "epss_percentile": 0.64299}, "CVE-2014-8651": {"epss_score": 0.00089, "epss_percentile": 0.25922}, "CVE-2014-8652": {"epss_score": 0.0789, "epss_percentile": 0.91746}, "CVE-2014-8653": {"epss_score": 0.13963, "epss_percentile": 0.94102}, "CVE-2014-8654": {"epss_score": 0.03777, "epss_percentile": 0.87711}, "CVE-2014-8655": {"epss_score": 0.19589, "epss_percentile": 0.95212}, "CVE-2014-8656": {"epss_score": 0.16427, "epss_percentile": 0.94658}, "CVE-2014-8657": {"epss_score": 0.2089, "epss_percentile": 0.95433}, "CVE-2014-8658": {"epss_score": 0.00224, "epss_percentile": 0.45042}, "CVE-2014-8659": {"epss_score": 0.00202, "epss_percentile": 0.42442}, "CVE-2014-8660": {"epss_score": 0.00184, "epss_percentile": 0.40417}, "CVE-2014-8661": {"epss_score": 0.045, "epss_percentile": 0.88766}, "CVE-2014-8662": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2014-8663": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2014-8664": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2014-8665": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-8666": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-8667": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-8668": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2014-8669": {"epss_score": 0.09969, "epss_percentile": 0.92797}, "CVE-2014-8670": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2014-8671": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-8672": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-8673": {"epss_score": 0.49864, "epss_percentile": 0.97709}, "CVE-2014-8674": {"epss_score": 0.00659, "epss_percentile": 0.70502}, "CVE-2014-8675": {"epss_score": 0.36048, "epss_percentile": 0.96952}, "CVE-2014-8676": {"epss_score": 0.72418, "epss_percentile": 0.98708}, "CVE-2014-8677": {"epss_score": 0.03039, "epss_percentile": 0.8627}, "CVE-2014-8678": {"epss_score": 0.00377, "epss_percentile": 0.5872}, "CVE-2014-8680": {"epss_score": 0.02261, "epss_percentile": 0.84187}, "CVE-2014-8681": {"epss_score": 0.0651, "epss_percentile": 0.9081}, "CVE-2014-8682": {"epss_score": 0.66731, "epss_percentile": 0.98476}, "CVE-2014-8683": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2014-8684": {"epss_score": 0.44845, "epss_percentile": 0.97455}, "CVE-2014-8686": {"epss_score": 0.34041, "epss_percentile": 0.96822}, "CVE-2014-8687": {"epss_score": 0.49871, "epss_percentile": 0.97709}, "CVE-2014-8688": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2014-8690": {"epss_score": 0.14775, "epss_percentile": 0.94281}, "CVE-2014-8701": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2014-8702": {"epss_score": 0.0029, "epss_percentile": 0.52081}, "CVE-2014-8703": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2014-8704": {"epss_score": 0.01342, "epss_percentile": 0.79593}, "CVE-2014-8705": {"epss_score": 0.00691, "epss_percentile": 0.7128}, "CVE-2014-8706": {"epss_score": 0.00244, "epss_percentile": 0.47619}, "CVE-2014-8707": {"epss_score": 0.0016, "epss_percentile": 0.37477}, "CVE-2014-8708": {"epss_score": 0.02731, "epss_percentile": 0.85538}, "CVE-2014-8709": {"epss_score": 0.01481, "epss_percentile": 0.80568}, "CVE-2014-8710": {"epss_score": 0.00836, "epss_percentile": 0.74134}, "CVE-2014-8711": {"epss_score": 0.02134, "epss_percentile": 0.83723}, "CVE-2014-8712": {"epss_score": 0.00824, "epss_percentile": 0.73945}, "CVE-2014-8713": {"epss_score": 0.01323, "epss_percentile": 0.79459}, "CVE-2014-8714": {"epss_score": 0.00949, "epss_percentile": 0.75849}, "CVE-2014-8716": {"epss_score": 0.00128, "epss_percentile": 0.32968}, "CVE-2014-8722": {"epss_score": 0.33791, "epss_percentile": 0.96803}, "CVE-2014-8723": {"epss_score": 0.00261, "epss_percentile": 0.49276}, "CVE-2014-8724": {"epss_score": 0.00499, "epss_percentile": 0.65282}, "CVE-2014-8727": {"epss_score": 0.00164, "epss_percentile": 0.37972}, "CVE-2014-8728": {"epss_score": 0.00247, "epss_percentile": 0.47814}, "CVE-2014-8730": {"epss_score": 0.03099, "epss_percentile": 0.86407}, "CVE-2014-8731": {"epss_score": 0.4714, "epss_percentile": 0.97571}, "CVE-2014-8732": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2014-8733": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2014-8734": {"epss_score": 0.00193, "epss_percentile": 0.41427}, "CVE-2014-8735": {"epss_score": 0.00216, "epss_percentile": 0.4423}, "CVE-2014-8736": {"epss_score": 0.00184, "epss_percentile": 0.40384}, "CVE-2014-8737": {"epss_score": 0.00063, "epss_percentile": 0.19896}, "CVE-2014-8738": {"epss_score": 0.06056, "epss_percentile": 0.90439}, "CVE-2014-8739": {"epss_score": 0.90252, "epss_percentile": 0.99572}, "CVE-2014-8741": {"epss_score": 0.7035, "epss_percentile": 0.9863}, "CVE-2014-8742": {"epss_score": 0.08102, "epss_percentile": 0.91879}, "CVE-2014-8743": {"epss_score": 0.00175, "epss_percentile": 0.39319}, "CVE-2014-8744": {"epss_score": 0.00208, "epss_percentile": 0.43213}, "CVE-2014-8745": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2014-8746": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2014-8747": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2014-8748": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2014-8749": {"epss_score": 0.00448, "epss_percentile": 0.63019}, "CVE-2014-8750": {"epss_score": 0.00929, "epss_percentile": 0.75592}, "CVE-2014-8751": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-8752": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2014-8753": {"epss_score": 0.00285, "epss_percentile": 0.51547}, "CVE-2014-8754": {"epss_score": 0.00365, "epss_percentile": 0.58003}, "CVE-2014-8755": {"epss_score": 0.01616, "epss_percentile": 0.81361}, "CVE-2014-8756": {"epss_score": 0.01645, "epss_percentile": 0.8153}, "CVE-2014-8757": {"epss_score": 0.10806, "epss_percentile": 0.9311}, "CVE-2014-8758": {"epss_score": 0.00178, "epss_percentile": 0.39636}, "CVE-2014-8760": {"epss_score": 0.00264, "epss_percentile": 0.49722}, "CVE-2014-8761": {"epss_score": 0.00516, "epss_percentile": 0.66044}, "CVE-2014-8762": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2014-8763": {"epss_score": 0.0105, "epss_percentile": 0.77073}, "CVE-2014-8764": {"epss_score": 0.01224, "epss_percentile": 0.78676}, "CVE-2014-8765": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-8766": {"epss_score": 0.00326, "epss_percentile": 0.55077}, "CVE-2014-8767": {"epss_score": 0.06518, "epss_percentile": 0.90816}, "CVE-2014-8768": {"epss_score": 0.28307, "epss_percentile": 0.96341}, "CVE-2014-8769": {"epss_score": 0.03059, "epss_percentile": 0.86304}, "CVE-2014-8770": {"epss_score": 0.2613, "epss_percentile": 0.96115}, "CVE-2014-8771": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2014-8772": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2014-8773": {"epss_score": 0.00361, "epss_percentile": 0.57736}, "CVE-2014-8774": {"epss_score": 0.00453, "epss_percentile": 0.63212}, "CVE-2014-8775": {"epss_score": 0.06493, "epss_percentile": 0.90798}, "CVE-2014-8778": {"epss_score": 0.00569, "epss_percentile": 0.67934}, "CVE-2014-8779": {"epss_score": 0.00284, "epss_percentile": 0.51425}, "CVE-2014-8780": {"epss_score": 0.00138, "epss_percentile": 0.34349}, "CVE-2014-8788": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2014-8789": {"epss_score": 0.01745, "epss_percentile": 0.82068}, "CVE-2014-8790": {"epss_score": 0.00657, "epss_percentile": 0.7046}, "CVE-2014-8791": {"epss_score": 0.52397, "epss_percentile": 0.97824}, "CVE-2014-8793": {"epss_score": 0.00445, "epss_percentile": 0.6289}, "CVE-2014-8799": {"epss_score": 0.88094, "epss_percentile": 0.99457}, "CVE-2014-8800": {"epss_score": 0.02131, "epss_percentile": 0.83715}, "CVE-2014-8801": {"epss_score": 0.30512, "epss_percentile": 0.96548}, "CVE-2014-8802": {"epss_score": 0.07979, "epss_percentile": 0.91801}, "CVE-2014-8809": {"epss_score": 0.00357, "epss_percentile": 0.5745}, "CVE-2014-8810": {"epss_score": 0.03371, "epss_percentile": 0.87011}, "CVE-2014-8816": {"epss_score": 0.01581, "epss_percentile": 0.81137}, "CVE-2014-8817": {"epss_score": 0.01162, "epss_percentile": 0.78154}, "CVE-2014-8819": {"epss_score": 0.00055, "epss_percentile": 0.1762}, "CVE-2014-8820": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2014-8821": {"epss_score": 0.00055, "epss_percentile": 0.1762}, "CVE-2014-8822": {"epss_score": 0.00982, "epss_percentile": 0.76298}, "CVE-2014-8823": {"epss_score": 0.00064, "epss_percentile": 0.20314}, "CVE-2014-8824": {"epss_score": 0.00982, "epss_percentile": 0.76298}, "CVE-2014-8825": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2014-8826": {"epss_score": 0.13969, "epss_percentile": 0.94103}, "CVE-2014-8827": {"epss_score": 0.00058, "epss_percentile": 0.18608}, "CVE-2014-8828": {"epss_score": 0.0036, "epss_percentile": 0.57629}, "CVE-2014-8829": {"epss_score": 0.00707, "epss_percentile": 0.71646}, "CVE-2014-8830": {"epss_score": 0.03594, "epss_percentile": 0.87403}, "CVE-2014-8831": {"epss_score": 0.00161, "epss_percentile": 0.37602}, "CVE-2014-8832": {"epss_score": 0.00061, "epss_percentile": 0.19511}, "CVE-2014-8833": {"epss_score": 0.00051, "epss_percentile": 0.16333}, "CVE-2014-8834": {"epss_score": 0.00061, "epss_percentile": 0.19511}, "CVE-2014-8835": {"epss_score": 0.3542, "epss_percentile": 0.96907}, "CVE-2014-8836": {"epss_score": 0.01199, "epss_percentile": 0.78463}, "CVE-2014-8837": {"epss_score": 0.01678, "epss_percentile": 0.81718}, "CVE-2014-8838": {"epss_score": 0.00157, "epss_percentile": 0.37038}, "CVE-2014-8839": {"epss_score": 0.0048, "epss_percentile": 0.64448}, "CVE-2014-8840": {"epss_score": 0.00333, "epss_percentile": 0.55629}, "CVE-2014-8866": {"epss_score": 0.00093, "epss_percentile": 0.26729}, "CVE-2014-8867": {"epss_score": 0.00126, "epss_percentile": 0.32742}, "CVE-2014-8868": {"epss_score": 0.15335, "epss_percentile": 0.94412}, "CVE-2014-8869": {"epss_score": 0.00378, "epss_percentile": 0.58778}, "CVE-2014-8870": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2014-8871": {"epss_score": 0.02272, "epss_percentile": 0.84217}, "CVE-2014-8872": {"epss_score": 0.00139, "epss_percentile": 0.34555}, "CVE-2014-8873": {"epss_score": 0.07636, "epss_percentile": 0.91588}, "CVE-2014-8874": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2014-8875": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2014-8877": {"epss_score": 0.30124, "epss_percentile": 0.96513}, "CVE-2014-8878": {"epss_score": 0.00284, "epss_percentile": 0.51445}, "CVE-2014-8884": {"epss_score": 0.00042, "epss_percentile": 0.12666}, "CVE-2014-8886": {"epss_score": 0.04543, "epss_percentile": 0.8883}, "CVE-2014-8887": {"epss_score": 0.00196, "epss_percentile": 0.41746}, "CVE-2014-8888": {"epss_score": 0.08081, "epss_percentile": 0.91872}, "CVE-2014-8889": {"epss_score": 0.08256, "epss_percentile": 0.91952}, "CVE-2014-8890": {"epss_score": 0.01387, "epss_percentile": 0.79919}, "CVE-2014-8891": {"epss_score": 0.06611, "epss_percentile": 0.90887}, "CVE-2014-8892": {"epss_score": 0.01587, "epss_percentile": 0.81178}, "CVE-2014-8893": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-8894": {"epss_score": 0.0018, "epss_percentile": 0.39969}, "CVE-2014-8895": {"epss_score": 0.0021, "epss_percentile": 0.43587}, "CVE-2014-8896": {"epss_score": 0.00141, "epss_percentile": 0.34935}, "CVE-2014-8897": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-8898": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-8899": {"epss_score": 0.00142, "epss_percentile": 0.35088}, "CVE-2014-8900": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2014-8901": {"epss_score": 0.01579, "epss_percentile": 0.81128}, "CVE-2014-8902": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2014-8903": {"epss_score": 0.0085, "epss_percentile": 0.74385}, "CVE-2014-8904": {"epss_score": 0.0056, "epss_percentile": 0.67629}, "CVE-2014-8909": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2014-8910": {"epss_score": 0.00247, "epss_percentile": 0.47877}, "CVE-2014-8911": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2014-8912": {"epss_score": 0.00215, "epss_percentile": 0.44095}, "CVE-2014-8913": {"epss_score": 0.00231, "epss_percentile": 0.45804}, "CVE-2014-8914": {"epss_score": 0.00304, "epss_percentile": 0.53249}, "CVE-2014-8916": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2014-8917": {"epss_score": 0.00449, "epss_percentile": 0.63032}, "CVE-2014-8918": {"epss_score": 0.00123, "epss_percentile": 0.32272}, "CVE-2014-8920": {"epss_score": 0.00053, "epss_percentile": 0.167}, "CVE-2014-8921": {"epss_score": 0.00749, "epss_percentile": 0.726}, "CVE-2014-8923": {"epss_score": 0.00118, "epss_percentile": 0.31437}, "CVE-2014-8924": {"epss_score": 0.00285, "epss_percentile": 0.51512}, "CVE-2014-8925": {"epss_score": 0.00148, "epss_percentile": 0.35833}, "CVE-2014-8926": {"epss_score": 0.00572, "epss_percentile": 0.68003}, "CVE-2014-8927": {"epss_score": 0.00572, "epss_percentile": 0.68003}, "CVE-2014-8937": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2014-8938": {"epss_score": 0.00054, "epss_percentile": 0.17318}, "CVE-2014-8939": {"epss_score": 0.002, "epss_percentile": 0.42204}, "CVE-2014-8940": {"epss_score": 0.00243, "epss_percentile": 0.47458}, "CVE-2014-8941": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2014-8942": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2014-8943": {"epss_score": 0.0031, "epss_percentile": 0.53799}, "CVE-2014-8944": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2014-8945": {"epss_score": 0.17757, "epss_percentile": 0.94899}, "CVE-2014-8948": {"epss_score": 0.00961, "epss_percentile": 0.75975}, "CVE-2014-8949": {"epss_score": 0.10417, "epss_percentile": 0.92982}, "CVE-2014-8950": {"epss_score": 0.00833, "epss_percentile": 0.7408}, "CVE-2014-8951": {"epss_score": 0.00833, "epss_percentile": 0.7408}, "CVE-2014-8952": {"epss_score": 0.00833, "epss_percentile": 0.7408}, "CVE-2014-8953": {"epss_score": 0.002, "epss_percentile": 0.42221}, "CVE-2014-8954": {"epss_score": 0.03324, "epss_percentile": 0.86918}, "CVE-2014-8955": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-8956": {"epss_score": 0.00114, "epss_percentile": 0.3086}, "CVE-2014-8957": {"epss_score": 0.00197, "epss_percentile": 0.41866}, "CVE-2014-8958": {"epss_score": 0.00604, "epss_percentile": 0.68963}, "CVE-2014-8959": {"epss_score": 0.02772, "epss_percentile": 0.85622}, "CVE-2014-8960": {"epss_score": 0.00287, "epss_percentile": 0.51809}, "CVE-2014-8961": {"epss_score": 0.01954, "epss_percentile": 0.83029}, "CVE-2014-8962": {"epss_score": 0.14653, "epss_percentile": 0.94258}, "CVE-2014-8964": {"epss_score": 0.02089, "epss_percentile": 0.8356}, "CVE-2014-8966": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2014-8967": {"epss_score": 0.29876, "epss_percentile": 0.96483}, "CVE-2014-8985": {"epss_score": 0.12572, "epss_percentile": 0.93719}, "CVE-2014-8986": {"epss_score": 0.00532, "epss_percentile": 0.66702}, "CVE-2014-8987": {"epss_score": 0.00532, "epss_percentile": 0.66702}, "CVE-2014-8988": {"epss_score": 0.00397, "epss_percentile": 0.60022}, "CVE-2014-8989": {"epss_score": 0.00027, "epss_percentile": 0.06884}, "CVE-2014-8990": {"epss_score": 0.04309, "epss_percentile": 0.88529}, "CVE-2014-8991": {"epss_score": 0.00072, "epss_percentile": 0.22467}, "CVE-2014-8992": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-8993": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-8994": {"epss_score": 0.00063, "epss_percentile": 0.19886}, "CVE-2014-8995": {"epss_score": 0.0127, "epss_percentile": 0.79051}, "CVE-2014-8996": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2014-8997": {"epss_score": 0.07037, "epss_percentile": 0.91205}, "CVE-2014-8998": {"epss_score": 0.66001, "epss_percentile": 0.98445}, "CVE-2014-8999": {"epss_score": 0.00308, "epss_percentile": 0.53599}, "CVE-2014-9000": {"epss_score": 0.15125, "epss_percentile": 0.94368}, "CVE-2014-9001": {"epss_score": 0.07051, "epss_percentile": 0.91213}, "CVE-2014-9002": {"epss_score": 0.03811, "epss_percentile": 0.87762}, "CVE-2014-9003": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2014-9004": {"epss_score": 0.00453, "epss_percentile": 0.63212}, "CVE-2014-9005": {"epss_score": 0.00247, "epss_percentile": 0.47814}, "CVE-2014-9006": {"epss_score": 0.00345, "epss_percentile": 0.56577}, "CVE-2014-9013": {"epss_score": 0.36674, "epss_percentile": 0.96994}, "CVE-2014-9014": {"epss_score": 0.05247, "epss_percentile": 0.8966}, "CVE-2014-9015": {"epss_score": 0.0191, "epss_percentile": 0.82824}, "CVE-2014-9016": {"epss_score": 0.79786, "epss_percentile": 0.99055}, "CVE-2014-9017": {"epss_score": 0.00299, "epss_percentile": 0.5287}, "CVE-2014-9018": {"epss_score": 0.00807, "epss_percentile": 0.73668}, "CVE-2014-9019": {"epss_score": 0.00182, "epss_percentile": 0.40144}, "CVE-2014-9020": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2014-9021": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-9022": {"epss_score": 0.00561, "epss_percentile": 0.6767}, "CVE-2014-9023": {"epss_score": 0.00157, "epss_percentile": 0.37039}, "CVE-2014-9024": {"epss_score": 0.00225, "epss_percentile": 0.45089}, "CVE-2014-9025": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2014-9026": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2014-9027": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2014-9028": {"epss_score": 0.25739, "epss_percentile": 0.96061}, "CVE-2014-9029": {"epss_score": 0.32606, "epss_percentile": 0.96711}, "CVE-2014-9030": {"epss_score": 0.0232, "epss_percentile": 0.84367}, "CVE-2014-9031": {"epss_score": 0.00488, "epss_percentile": 0.64845}, "CVE-2014-9032": {"epss_score": 0.0042, "epss_percentile": 0.61414}, "CVE-2014-9033": {"epss_score": 0.00804, "epss_percentile": 0.73617}, "CVE-2014-9034": {"epss_score": 0.72483, "epss_percentile": 0.98712}, "CVE-2014-9035": {"epss_score": 0.00586, "epss_percentile": 0.68438}, "CVE-2014-9036": {"epss_score": 0.00586, "epss_percentile": 0.68438}, "CVE-2014-9037": {"epss_score": 0.02617, "epss_percentile": 0.85248}, "CVE-2014-9038": {"epss_score": 0.01235, "epss_percentile": 0.78761}, "CVE-2014-9039": {"epss_score": 0.01681, "epss_percentile": 0.81728}, "CVE-2014-9041": {"epss_score": 0.00182, "epss_percentile": 0.402}, "CVE-2014-9042": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2014-9043": {"epss_score": 0.00382, "epss_percentile": 0.5905}, "CVE-2014-9044": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-9045": {"epss_score": 0.00703, "epss_percentile": 0.71546}, "CVE-2014-9046": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-9047": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2014-9048": {"epss_score": 0.00397, "epss_percentile": 0.59967}, "CVE-2014-9049": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2014-9050": {"epss_score": 0.05453, "epss_percentile": 0.89894}, "CVE-2014-9057": {"epss_score": 0.00356, "epss_percentile": 0.57348}, "CVE-2014-9059": {"epss_score": 0.0032, "epss_percentile": 0.54618}, "CVE-2014-9060": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2014-9065": {"epss_score": 0.0007, "epss_percentile": 0.21957}, "CVE-2014-9066": {"epss_score": 0.00035, "epss_percentile": 0.10159}, "CVE-2014-9087": {"epss_score": 0.07754, "epss_percentile": 0.91661}, "CVE-2014-9089": {"epss_score": 0.00544, "epss_percentile": 0.67138}, "CVE-2014-9090": {"epss_score": 0.00043, "epss_percentile": 0.13075}, "CVE-2014-9091": {"epss_score": 0.00062, "epss_percentile": 0.19613}, "CVE-2014-9092": {"epss_score": 0.0187, "epss_percentile": 0.82628}, "CVE-2014-9093": {"epss_score": 0.03334, "epss_percentile": 0.86932}, "CVE-2014-9094": {"epss_score": 0.14728, "epss_percentile": 0.9427}, "CVE-2014-9095": {"epss_score": 0.0096, "epss_percentile": 0.75967}, "CVE-2014-9096": {"epss_score": 0.01328, "epss_percentile": 0.79493}, "CVE-2014-9097": {"epss_score": 0.02542, "epss_percentile": 0.85051}, "CVE-2014-9098": {"epss_score": 0.00232, "epss_percentile": 0.45884}, "CVE-2014-9099": {"epss_score": 0.00227, "epss_percentile": 0.45392}, "CVE-2014-9100": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-9101": {"epss_score": 0.02778, "epss_percentile": 0.85644}, "CVE-2014-9102": {"epss_score": 0.00308, "epss_percentile": 0.53599}, "CVE-2014-9103": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2014-9104": {"epss_score": 0.00234, "epss_percentile": 0.46159}, "CVE-2014-9112": {"epss_score": 0.01343, "epss_percentile": 0.79605}, "CVE-2014-9113": {"epss_score": 0.00826, "epss_percentile": 0.73961}, "CVE-2014-9114": {"epss_score": 0.00132, "epss_percentile": 0.33559}, "CVE-2014-9115": {"epss_score": 0.00579, "epss_percentile": 0.68217}, "CVE-2014-9116": {"epss_score": 0.02619, "epss_percentile": 0.85252}, "CVE-2014-9117": {"epss_score": 0.00629, "epss_percentile": 0.69682}, "CVE-2014-9118": {"epss_score": 0.52287, "epss_percentile": 0.97817}, "CVE-2014-9119": {"epss_score": 0.3807, "epss_percentile": 0.97084}, "CVE-2014-9120": {"epss_score": 0.0033, "epss_percentile": 0.55494}, "CVE-2014-9126": {"epss_score": 0.00161, "epss_percentile": 0.37551}, "CVE-2014-9127": {"epss_score": 0.00225, "epss_percentile": 0.45232}, "CVE-2014-9129": {"epss_score": 0.00262, "epss_percentile": 0.4935}, "CVE-2014-9130": {"epss_score": 0.5763, "epss_percentile": 0.98075}, "CVE-2014-9134": {"epss_score": 0.03754, "epss_percentile": 0.87678}, "CVE-2014-9135": {"epss_score": 0.00183, "epss_percentile": 0.40356}, "CVE-2014-9136": {"epss_score": 0.0009, "epss_percentile": 0.26016}, "CVE-2014-9137": {"epss_score": 0.0009, "epss_percentile": 0.26016}, "CVE-2014-9140": {"epss_score": 0.05511, "epss_percentile": 0.89946}, "CVE-2014-9141": {"epss_score": 0.00302, "epss_percentile": 0.53138}, "CVE-2014-9142": {"epss_score": 0.03324, "epss_percentile": 0.86918}, "CVE-2014-9143": {"epss_score": 0.03582, "epss_percentile": 0.87386}, "CVE-2014-9144": {"epss_score": 0.08916, "epss_percentile": 0.92317}, "CVE-2014-9145": {"epss_score": 0.01016, "epss_percentile": 0.76676}, "CVE-2014-9146": {"epss_score": 0.00434, "epss_percentile": 0.62305}, "CVE-2014-9147": {"epss_score": 0.17919, "epss_percentile": 0.94927}, "CVE-2014-9148": {"epss_score": 0.24232, "epss_percentile": 0.95895}, "CVE-2014-9150": {"epss_score": 0.01664, "epss_percentile": 0.81642}, "CVE-2014-9151": {"epss_score": 0.0051, "epss_percentile": 0.65761}, "CVE-2014-9152": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2014-9153": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2014-9154": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2014-9155": {"epss_score": 0.00925, "epss_percentile": 0.75531}, "CVE-2014-9156": {"epss_score": 0.00151, "epss_percentile": 0.36203}, "CVE-2014-9157": {"epss_score": 0.01899, "epss_percentile": 0.82767}, "CVE-2014-9158": {"epss_score": 0.16272, "epss_percentile": 0.94608}, "CVE-2014-9159": {"epss_score": 0.33398, "epss_percentile": 0.96768}, "CVE-2014-9160": {"epss_score": 0.49312, "epss_percentile": 0.97679}, "CVE-2014-9161": {"epss_score": 0.0121, "epss_percentile": 0.78551}, "CVE-2014-9162": {"epss_score": 0.01902, "epss_percentile": 0.82784}, "CVE-2014-9163": {"epss_score": 0.03626, "epss_percentile": 0.87459}, "CVE-2014-9164": {"epss_score": 0.09704, "epss_percentile": 0.92669}, "CVE-2014-9165": {"epss_score": 0.2145, "epss_percentile": 0.9552}, "CVE-2014-9166": {"epss_score": 0.01409, "epss_percentile": 0.80074}, "CVE-2014-9173": {"epss_score": 0.02762, "epss_percentile": 0.85605}, "CVE-2014-9174": {"epss_score": 0.00401, "epss_percentile": 0.6021}, "CVE-2014-9175": {"epss_score": 0.04845, "epss_percentile": 0.89209}, "CVE-2014-9176": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2014-9177": {"epss_score": 0.00716, "epss_percentile": 0.71855}, "CVE-2014-9178": {"epss_score": 0.0207, "epss_percentile": 0.83472}, "CVE-2014-9179": {"epss_score": 0.00255, "epss_percentile": 0.48652}, "CVE-2014-9180": {"epss_score": 0.0844, "epss_percentile": 0.92053}, "CVE-2014-9181": {"epss_score": 0.15303, "epss_percentile": 0.94406}, "CVE-2014-9182": {"epss_score": 0.00245, "epss_percentile": 0.47633}, "CVE-2014-9183": {"epss_score": 0.05171, "epss_percentile": 0.89571}, "CVE-2014-9184": {"epss_score": 0.06938, "epss_percentile": 0.91129}, "CVE-2014-9185": {"epss_score": 0.00554, "epss_percentile": 0.67442}, "CVE-2014-9186": {"epss_score": 0.01073, "epss_percentile": 0.7729}, "CVE-2014-9187": {"epss_score": 0.0223, "epss_percentile": 0.84083}, "CVE-2014-9188": {"epss_score": 0.17944, "epss_percentile": 0.94931}, "CVE-2014-9189": {"epss_score": 0.01712, "epss_percentile": 0.81887}, "CVE-2014-9190": {"epss_score": 0.06964, "epss_percentile": 0.91151}, "CVE-2014-9191": {"epss_score": 0.00098, "epss_percentile": 0.27722}, "CVE-2014-9192": {"epss_score": 0.01139, "epss_percentile": 0.77943}, "CVE-2014-9193": {"epss_score": 0.00472, "epss_percentile": 0.64038}, "CVE-2014-9194": {"epss_score": 0.00097, "epss_percentile": 0.27497}, "CVE-2014-9195": {"epss_score": 0.82494, "epss_percentile": 0.99197}, "CVE-2014-9196": {"epss_score": 0.023, "epss_percentile": 0.84308}, "CVE-2014-9197": {"epss_score": 0.0027, "epss_percentile": 0.50242}, "CVE-2014-9198": {"epss_score": 0.00821, "epss_percentile": 0.73904}, "CVE-2014-9199": {"epss_score": 0.00656, "epss_percentile": 0.70434}, "CVE-2014-9200": {"epss_score": 0.02192, "epss_percentile": 0.83943}, "CVE-2014-9201": {"epss_score": 0.00442, "epss_percentile": 0.62732}, "CVE-2014-9202": {"epss_score": 0.0025, "epss_percentile": 0.48147}, "CVE-2014-9203": {"epss_score": 0.00759, "epss_percentile": 0.7279}, "CVE-2014-9204": {"epss_score": 0.00028, "epss_percentile": 0.07243}, "CVE-2014-9205": {"epss_score": 0.04557, "epss_percentile": 0.88847}, "CVE-2014-9206": {"epss_score": 0.00046, "epss_percentile": 0.14461}, "CVE-2014-9207": {"epss_score": 0.00054, "epss_percentile": 0.17145}, "CVE-2014-9208": {"epss_score": 0.19991, "epss_percentile": 0.95271}, "CVE-2014-9209": {"epss_score": 3e-05, "epss_percentile": 0.00108}, "CVE-2014-9211": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2014-9212": {"epss_score": 0.00249, "epss_percentile": 0.48047}, "CVE-2014-9215": {"epss_score": 0.02423, "epss_percentile": 0.84707}, "CVE-2014-9217": {"epss_score": 0.00912, "epss_percentile": 0.75363}, "CVE-2014-9218": {"epss_score": 0.16901, "epss_percentile": 0.94746}, "CVE-2014-9219": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-9220": {"epss_score": 0.0044, "epss_percentile": 0.62623}, "CVE-2014-9221": {"epss_score": 0.07905, "epss_percentile": 0.91756}, "CVE-2014-9222": {"epss_score": 0.89041, "epss_percentile": 0.99507}, "CVE-2014-9223": {"epss_score": 0.07549, "epss_percentile": 0.91532}, "CVE-2014-9224": {"epss_score": 0.03985, "epss_percentile": 0.88064}, "CVE-2014-9225": {"epss_score": 0.10119, "epss_percentile": 0.92857}, "CVE-2014-9226": {"epss_score": 0.01331, "epss_percentile": 0.79515}, "CVE-2014-9227": {"epss_score": 0.00084, "epss_percentile": 0.24959}, "CVE-2014-9228": {"epss_score": 0.00059, "epss_percentile": 0.18858}, "CVE-2014-9229": {"epss_score": 0.00438, "epss_percentile": 0.62542}, "CVE-2014-9230": {"epss_score": 0.00609, "epss_percentile": 0.69129}, "CVE-2014-9234": {"epss_score": 0.00128, "epss_percentile": 0.32969}, "CVE-2014-9235": {"epss_score": 0.00748, "epss_percentile": 0.72584}, "CVE-2014-9236": {"epss_score": 0.00649, "epss_percentile": 0.70241}, "CVE-2014-9237": {"epss_score": 0.01134, "epss_percentile": 0.77884}, "CVE-2014-9238": {"epss_score": 0.00237, "epss_percentile": 0.4666}, "CVE-2014-9239": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2014-9240": {"epss_score": 0.01348, "epss_percentile": 0.79659}, "CVE-2014-9241": {"epss_score": 0.01019, "epss_percentile": 0.76727}, "CVE-2014-9242": {"epss_score": 0.00826, "epss_percentile": 0.73969}, "CVE-2014-9243": {"epss_score": 0.00649, "epss_percentile": 0.70241}, "CVE-2014-9245": {"epss_score": 0.005, "epss_percentile": 0.65314}, "CVE-2014-9247": {"epss_score": 0.00313, "epss_percentile": 0.54072}, "CVE-2014-9248": {"epss_score": 0.0072, "epss_percentile": 0.71955}, "CVE-2014-9249": {"epss_score": 0.00643, "epss_percentile": 0.70049}, "CVE-2014-9250": {"epss_score": 0.00539, "epss_percentile": 0.66984}, "CVE-2014-9251": {"epss_score": 0.00412, "epss_percentile": 0.60947}, "CVE-2014-9252": {"epss_score": 0.00088, "epss_percentile": 0.25787}, "CVE-2014-9253": {"epss_score": 0.00588, "epss_percentile": 0.68508}, "CVE-2014-9254": {"epss_score": 0.00679, "epss_percentile": 0.71013}, "CVE-2014-9258": {"epss_score": 0.08853, "epss_percentile": 0.92286}, "CVE-2014-9260": {"epss_score": 0.03809, "epss_percentile": 0.87755}, "CVE-2014-9261": {"epss_score": 0.15491, "epss_percentile": 0.94437}, "CVE-2014-9262": {"epss_score": 0.07376, "epss_percentile": 0.91442}, "CVE-2014-9263": {"epss_score": 0.06997, "epss_percentile": 0.91172}, "CVE-2014-9264": {"epss_score": 0.0426, "epss_percentile": 0.88462}, "CVE-2014-9265": {"epss_score": 0.08551, "epss_percentile": 0.92119}, "CVE-2014-9266": {"epss_score": 0.02049, "epss_percentile": 0.83396}, "CVE-2014-9267": {"epss_score": 0.03999, "epss_percentile": 0.8809}, "CVE-2014-9268": {"epss_score": 0.01616, "epss_percentile": 0.81361}, "CVE-2014-9269": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2014-9270": {"epss_score": 0.00431, "epss_percentile": 0.62053}, "CVE-2014-9271": {"epss_score": 0.00833, "epss_percentile": 0.74091}, "CVE-2014-9272": {"epss_score": 0.00442, "epss_percentile": 0.62733}, "CVE-2014-9273": {"epss_score": 0.00179, "epss_percentile": 0.39766}, "CVE-2014-9274": {"epss_score": 0.05942, "epss_percentile": 0.90351}, "CVE-2014-9275": {"epss_score": 0.03321, "epss_percentile": 0.86911}, "CVE-2014-9276": {"epss_score": 0.00114, "epss_percentile": 0.30784}, "CVE-2014-9277": {"epss_score": 0.00862, "epss_percentile": 0.74568}, "CVE-2014-9278": {"epss_score": 0.00351, "epss_percentile": 0.57032}, "CVE-2014-9279": {"epss_score": 0.00472, "epss_percentile": 0.64035}, "CVE-2014-9280": {"epss_score": 0.00996, "epss_percentile": 0.76453}, "CVE-2014-9281": {"epss_score": 0.00557, "epss_percentile": 0.67549}, "CVE-2014-9282": {"epss_score": 0.00231, "epss_percentile": 0.45844}, "CVE-2014-9283": {"epss_score": 0.00795, "epss_percentile": 0.7346}, "CVE-2014-9284": {"epss_score": 0.00717, "epss_percentile": 0.7187}, "CVE-2014-9292": {"epss_score": 0.00255, "epss_percentile": 0.48737}, "CVE-2014-9293": {"epss_score": 0.33271, "epss_percentile": 0.96759}, "CVE-2014-9294": {"epss_score": 0.33271, "epss_percentile": 0.96759}, "CVE-2014-9295": {"epss_score": 0.66623, "epss_percentile": 0.9847}, "CVE-2014-9296": {"epss_score": 0.24613, "epss_percentile": 0.9594}, "CVE-2014-9300": {"epss_score": 0.00128, "epss_percentile": 0.33049}, "CVE-2014-9301": {"epss_score": 0.04207, "epss_percentile": 0.88396}, "CVE-2014-9302": {"epss_score": 0.03057, "epss_percentile": 0.86303}, "CVE-2014-9303": {"epss_score": 0.12947, "epss_percentile": 0.93825}, "CVE-2014-9304": {"epss_score": 0.02201, "epss_percentile": 0.83979}, "CVE-2014-9305": {"epss_score": 0.03695, "epss_percentile": 0.87583}, "CVE-2014-9308": {"epss_score": 0.82898, "epss_percentile": 0.99221}, "CVE-2014-9310": {"epss_score": 0.00404, "epss_percentile": 0.60418}, "CVE-2014-9311": {"epss_score": 0.00374, "epss_percentile": 0.58556}, "CVE-2014-9312": {"epss_score": 0.76455, "epss_percentile": 0.98891}, "CVE-2014-9316": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2014-9317": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2014-9318": {"epss_score": 0.01024, "epss_percentile": 0.76779}, "CVE-2014-9319": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2014-9320": {"epss_score": 0.09493, "epss_percentile": 0.92572}, "CVE-2014-9322": {"epss_score": 0.05763, "epss_percentile": 0.90185}, "CVE-2014-9323": {"epss_score": 0.01731, "epss_percentile": 0.81992}, "CVE-2014-9324": {"epss_score": 0.00963, "epss_percentile": 0.76017}, "CVE-2014-9325": {"epss_score": 0.00336, "epss_percentile": 0.55918}, "CVE-2014-9326": {"epss_score": 0.00218, "epss_percentile": 0.44343}, "CVE-2014-9328": {"epss_score": 0.06069, "epss_percentile": 0.90451}, "CVE-2014-9330": {"epss_score": 0.01171, "epss_percentile": 0.78222}, "CVE-2014-9331": {"epss_score": 0.02046, "epss_percentile": 0.83387}, "CVE-2014-9334": {"epss_score": 0.00143, "epss_percentile": 0.35154}, "CVE-2014-9335": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9336": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9337": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9338": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9339": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9340": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9341": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9342": {"epss_score": 0.00304, "epss_percentile": 0.53274}, "CVE-2014-9343": {"epss_score": 0.00572, "epss_percentile": 0.68}, "CVE-2014-9344": {"epss_score": 0.00576, "epss_percentile": 0.68139}, "CVE-2014-9345": {"epss_score": 0.00943, "epss_percentile": 0.7578}, "CVE-2014-9346": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2014-9347": {"epss_score": 0.00258, "epss_percentile": 0.48958}, "CVE-2014-9348": {"epss_score": 0.00943, "epss_percentile": 0.7578}, "CVE-2014-9349": {"epss_score": 0.03324, "epss_percentile": 0.86918}, "CVE-2014-9350": {"epss_score": 0.13031, "epss_percentile": 0.9385}, "CVE-2014-9351": {"epss_score": 0.01612, "epss_percentile": 0.81332}, "CVE-2014-9352": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-9353": {"epss_score": 0.01305, "epss_percentile": 0.79322}, "CVE-2014-9354": {"epss_score": 0.0021, "epss_percentile": 0.43448}, "CVE-2014-9355": {"epss_score": 0.00095, "epss_percentile": 0.27101}, "CVE-2014-9356": {"epss_score": 0.01209, "epss_percentile": 0.7854}, "CVE-2014-9357": {"epss_score": 0.20452, "epss_percentile": 0.95346}, "CVE-2014-9358": {"epss_score": 0.00302, "epss_percentile": 0.53129}, "CVE-2014-9360": {"epss_score": 0.00382, "epss_percentile": 0.59063}, "CVE-2014-9361": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2014-9362": {"epss_score": 0.00161, "epss_percentile": 0.37542}, "CVE-2014-9363": {"epss_score": 0.00137, "epss_percentile": 0.34267}, "CVE-2014-9364": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2014-9365": {"epss_score": 0.02127, "epss_percentile": 0.83698}, "CVE-2014-9367": {"epss_score": 0.00336, "epss_percentile": 0.55918}, "CVE-2014-9368": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9369": {"epss_score": 0.00251, "epss_percentile": 0.4827}, "CVE-2014-9371": {"epss_score": 0.10223, "epss_percentile": 0.92901}, "CVE-2014-9372": {"epss_score": 0.01645, "epss_percentile": 0.81531}, "CVE-2014-9373": {"epss_score": 0.06842, "epss_percentile": 0.91062}, "CVE-2014-9374": {"epss_score": 0.49122, "epss_percentile": 0.97668}, "CVE-2014-9375": {"epss_score": 0.01475, "epss_percentile": 0.80527}, "CVE-2014-9376": {"epss_score": 0.03098, "epss_percentile": 0.86406}, "CVE-2014-9377": {"epss_score": 0.02786, "epss_percentile": 0.85658}, "CVE-2014-9378": {"epss_score": 0.02655, "epss_percentile": 0.85355}, "CVE-2014-9379": {"epss_score": 0.02786, "epss_percentile": 0.85658}, "CVE-2014-9380": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2014-9381": {"epss_score": 0.00965, "epss_percentile": 0.76044}, "CVE-2014-9382": {"epss_score": 0.00291, "epss_percentile": 0.52208}, "CVE-2014-9385": {"epss_score": 0.00522, "epss_percentile": 0.66251}, "CVE-2014-9386": {"epss_score": 0.00712, "epss_percentile": 0.71752}, "CVE-2014-9387": {"epss_score": 0.05791, "epss_percentile": 0.90213}, "CVE-2014-9388": {"epss_score": 0.00434, "epss_percentile": 0.62308}, "CVE-2014-9389": {"epss_score": 0.00673, "epss_percentile": 0.7084}, "CVE-2014-9390": {"epss_score": 0.5996, "epss_percentile": 0.98189}, "CVE-2014-9391": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9392": {"epss_score": 0.00101, "epss_percentile": 0.28623}, "CVE-2014-9393": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9394": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9395": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9396": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9397": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9398": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9399": {"epss_score": 0.00125, "epss_percentile": 0.32606}, "CVE-2014-9400": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9401": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9402": {"epss_score": 0.087, "epss_percentile": 0.92209}, "CVE-2014-9403": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2014-9405": {"epss_score": 0.00579, "epss_percentile": 0.68209}, "CVE-2014-9406": {"epss_score": 0.01639, "epss_percentile": 0.81493}, "CVE-2014-9407": {"epss_score": 0.00157, "epss_percentile": 0.37076}, "CVE-2014-9408": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2014-9410": {"epss_score": 0.00275, "epss_percentile": 0.50685}, "CVE-2014-9411": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2014-9412": {"epss_score": 0.08478, "epss_percentile": 0.92073}, "CVE-2014-9413": {"epss_score": 0.00182, "epss_percentile": 0.40263}, "CVE-2014-9414": {"epss_score": 0.00357, "epss_percentile": 0.57428}, "CVE-2014-9415": {"epss_score": 0.00106, "epss_percentile": 0.29418}, "CVE-2014-9416": {"epss_score": 0.00075, "epss_percentile": 0.22912}, "CVE-2014-9417": {"epss_score": 0.001, "epss_percentile": 0.28558}, "CVE-2014-9418": {"epss_score": 0.00191, "epss_percentile": 0.41174}, "CVE-2014-9419": {"epss_score": 0.00056, "epss_percentile": 0.17772}, "CVE-2014-9420": {"epss_score": 0.00075, "epss_percentile": 0.23032}, "CVE-2014-9421": {"epss_score": 0.05356, "epss_percentile": 0.89779}, "CVE-2014-9422": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2014-9423": {"epss_score": 0.01537, "epss_percentile": 0.80921}, "CVE-2014-9424": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2014-9425": {"epss_score": 0.1581, "epss_percentile": 0.94513}, "CVE-2014-9426": {"epss_score": 0.00785, "epss_percentile": 0.7325}, "CVE-2014-9427": {"epss_score": 0.04871, "epss_percentile": 0.89232}, "CVE-2014-9428": {"epss_score": 0.03394, "epss_percentile": 0.87057}, "CVE-2014-9429": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-9430": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2014-9431": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2014-9432": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2014-9433": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2014-9434": {"epss_score": 0.00464, "epss_percentile": 0.63728}, "CVE-2014-9435": {"epss_score": 0.00777, "epss_percentile": 0.73117}, "CVE-2014-9436": {"epss_score": 0.14538, "epss_percentile": 0.94236}, "CVE-2014-9437": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9438": {"epss_score": 0.00123, "epss_percentile": 0.32262}, "CVE-2014-9439": {"epss_score": 0.00608, "epss_percentile": 0.69065}, "CVE-2014-9440": {"epss_score": 0.00943, "epss_percentile": 0.7578}, "CVE-2014-9441": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9442": {"epss_score": 0.00438, "epss_percentile": 0.62555}, "CVE-2014-9443": {"epss_score": 0.00357, "epss_percentile": 0.5745}, "CVE-2014-9444": {"epss_score": 0.03285, "epss_percentile": 0.86823}, "CVE-2014-9445": {"epss_score": 0.00258, "epss_percentile": 0.48958}, "CVE-2014-9446": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2014-9447": {"epss_score": 0.03517, "epss_percentile": 0.87279}, "CVE-2014-9448": {"epss_score": 0.08187, "epss_percentile": 0.91918}, "CVE-2014-9449": {"epss_score": 0.01465, "epss_percentile": 0.8046}, "CVE-2014-9450": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2014-9451": {"epss_score": 0.07647, "epss_percentile": 0.916}, "CVE-2014-9452": {"epss_score": 0.00425, "epss_percentile": 0.61695}, "CVE-2014-9453": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2014-9454": {"epss_score": 0.00251, "epss_percentile": 0.48279}, "CVE-2014-9455": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2014-9456": {"epss_score": 0.26289, "epss_percentile": 0.96135}, "CVE-2014-9457": {"epss_score": 0.00705, "epss_percentile": 0.71587}, "CVE-2014-9458": {"epss_score": 0.00652, "epss_percentile": 0.70314}, "CVE-2014-9459": {"epss_score": 0.00179, "epss_percentile": 0.39749}, "CVE-2014-9460": {"epss_score": 0.00143, "epss_percentile": 0.35154}, "CVE-2014-9461": {"epss_score": 0.00312, "epss_percentile": 0.54006}, "CVE-2014-9462": {"epss_score": 0.01289, "epss_percentile": 0.79213}, "CVE-2014-9463": {"epss_score": 0.10732, "epss_percentile": 0.93086}, "CVE-2014-9464": {"epss_score": 0.01016, "epss_percentile": 0.76676}, "CVE-2014-9465": {"epss_score": 0.02515, "epss_percentile": 0.84983}, "CVE-2014-9466": {"epss_score": 0.00074, "epss_percentile": 0.22853}, "CVE-2014-9468": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-9469": {"epss_score": 0.00125, "epss_percentile": 0.32584}, "CVE-2014-9470": {"epss_score": 0.0087, "epss_percentile": 0.74706}, "CVE-2014-9471": {"epss_score": 0.03088, "epss_percentile": 0.8639}, "CVE-2014-9472": {"epss_score": 0.00875, "epss_percentile": 0.74782}, "CVE-2014-9473": {"epss_score": 0.39353, "epss_percentile": 0.97156}, "CVE-2014-9474": {"epss_score": 0.04159, "epss_percentile": 0.88334}, "CVE-2014-9475": {"epss_score": 0.00163, "epss_percentile": 0.37836}, "CVE-2014-9476": {"epss_score": 0.00722, "epss_percentile": 0.71989}, "CVE-2014-9477": {"epss_score": 0.00259, "epss_percentile": 0.49077}, "CVE-2014-9478": {"epss_score": 0.00255, "epss_percentile": 0.4864}, "CVE-2014-9479": {"epss_score": 0.00259, "epss_percentile": 0.49077}, "CVE-2014-9480": {"epss_score": 0.00259, "epss_percentile": 0.49077}, "CVE-2014-9481": {"epss_score": 0.00568, "epss_percentile": 0.67905}, "CVE-2014-9482": {"epss_score": 0.00695, "epss_percentile": 0.71365}, "CVE-2014-9483": {"epss_score": 0.00234, "epss_percentile": 0.46089}, "CVE-2014-9485": {"epss_score": 0.01731, "epss_percentile": 0.81993}, "CVE-2014-9487": {"epss_score": 0.01009, "epss_percentile": 0.76583}, "CVE-2014-9488": {"epss_score": 0.02325, "epss_percentile": 0.84388}, "CVE-2014-9489": {"epss_score": 0.04947, "epss_percentile": 0.89319}, "CVE-2014-9490": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2014-9491": {"epss_score": 0.0082, "epss_percentile": 0.73879}, "CVE-2014-9493": {"epss_score": 0.00746, "epss_percentile": 0.72553}, "CVE-2014-9494": {"epss_score": 0.00392, "epss_percentile": 0.597}, "CVE-2014-9495": {"epss_score": 0.03298, "epss_percentile": 0.8686}, "CVE-2014-9496": {"epss_score": 0.00103, "epss_percentile": 0.29017}, "CVE-2014-9497": {"epss_score": 0.01125, "epss_percentile": 0.77808}, "CVE-2014-9498": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2014-9499": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2014-9500": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2014-9501": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2014-9502": {"epss_score": 0.00088, "epss_percentile": 0.25658}, "CVE-2014-9503": {"epss_score": 0.00207, "epss_percentile": 0.43136}, "CVE-2014-9504": {"epss_score": 0.0027, "epss_percentile": 0.50259}, "CVE-2014-9505": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2014-9506": {"epss_score": 0.0019, "epss_percentile": 0.4108}, "CVE-2014-9507": {"epss_score": 0.00222, "epss_percentile": 0.44824}, "CVE-2014-9508": {"epss_score": 0.00289, "epss_percentile": 0.52029}, "CVE-2014-9509": {"epss_score": 0.00467, "epss_percentile": 0.63855}, "CVE-2014-9510": {"epss_score": 0.00128, "epss_percentile": 0.32951}, "CVE-2014-9512": {"epss_score": 0.08882, "epss_percentile": 0.92299}, "CVE-2014-9513": {"epss_score": 0.06547, "epss_percentile": 0.90841}, "CVE-2014-9514": {"epss_score": 0.00164, "epss_percentile": 0.37969}, "CVE-2014-9515": {"epss_score": 0.03321, "epss_percentile": 0.8691}, "CVE-2014-9516": {"epss_score": 0.00453, "epss_percentile": 0.63212}, "CVE-2014-9517": {"epss_score": 0.00929, "epss_percentile": 0.75591}, "CVE-2014-9518": {"epss_score": 0.00161, "epss_percentile": 0.37541}, "CVE-2014-9519": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2014-9520": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2014-9521": {"epss_score": 0.01618, "epss_percentile": 0.81371}, "CVE-2014-9522": {"epss_score": 0.10781, "epss_percentile": 0.93101}, "CVE-2014-9523": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2014-9524": {"epss_score": 0.00182, "epss_percentile": 0.40263}, "CVE-2014-9525": {"epss_score": 0.00104, "epss_percentile": 0.29153}, "CVE-2014-9526": {"epss_score": 0.00373, "epss_percentile": 0.58506}, "CVE-2014-9527": {"epss_score": 0.01231, "epss_percentile": 0.78728}, "CVE-2014-9528": {"epss_score": 0.03237, "epss_percentile": 0.86707}, "CVE-2014-9529": {"epss_score": 0.00105, "epss_percentile": 0.29309}, "CVE-2014-9530": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2014-9556": {"epss_score": 0.01286, "epss_percentile": 0.79185}, "CVE-2014-9557": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2014-9558": {"epss_score": 0.02738, "epss_percentile": 0.85553}, "CVE-2014-9559": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2014-9560": {"epss_score": 0.00517, "epss_percentile": 0.66081}, "CVE-2014-9561": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-9562": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2014-9563": {"epss_score": 0.0017, "epss_percentile": 0.38728}, "CVE-2014-9564": {"epss_score": 0.00285, "epss_percentile": 0.51524}, "CVE-2014-9565": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2014-9566": {"epss_score": 0.77539, "epss_percentile": 0.9894}, "CVE-2014-9567": {"epss_score": 0.82894, "epss_percentile": 0.9922}, "CVE-2014-9568": {"epss_score": 0.00131, "epss_percentile": 0.33468}, "CVE-2014-9569": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2014-9570": {"epss_score": 0.00239, "epss_percentile": 0.46871}, "CVE-2014-9571": {"epss_score": 0.00445, "epss_percentile": 0.6289}, "CVE-2014-9572": {"epss_score": 0.00924, "epss_percentile": 0.75514}, "CVE-2014-9573": {"epss_score": 0.00402, "epss_percentile": 0.60266}, "CVE-2014-9574": {"epss_score": 0.00914, "epss_percentile": 0.7539}, "CVE-2014-9575": {"epss_score": 0.00611, "epss_percentile": 0.69198}, "CVE-2014-9576": {"epss_score": 0.00371, "epss_percentile": 0.58367}, "CVE-2014-9577": {"epss_score": 0.00261, "epss_percentile": 0.49301}, "CVE-2014-9578": {"epss_score": 0.00493, "epss_percentile": 0.65039}, "CVE-2014-9579": {"epss_score": 0.00382, "epss_percentile": 0.59046}, "CVE-2014-9580": {"epss_score": 0.038, "epss_percentile": 0.87742}, "CVE-2014-9581": {"epss_score": 0.07167, "epss_percentile": 0.91296}, "CVE-2014-9582": {"epss_score": 0.00453, "epss_percentile": 0.63212}, "CVE-2014-9583": {"epss_score": 0.91049, "epss_percentile": 0.99616}, "CVE-2014-9584": {"epss_score": 0.0013, "epss_percentile": 0.33307}, "CVE-2014-9585": {"epss_score": 0.00045, "epss_percentile": 0.13722}, "CVE-2014-9587": {"epss_score": 0.03758, "epss_percentile": 0.87684}, "CVE-2014-9593": {"epss_score": 0.02699, "epss_percentile": 0.85448}, "CVE-2014-9594": {"epss_score": 0.01682, "epss_percentile": 0.81733}, "CVE-2014-9595": {"epss_score": 0.01682, "epss_percentile": 0.81733}, "CVE-2014-9596": {"epss_score": 0.00263, "epss_percentile": 0.49521}, "CVE-2014-9597": {"epss_score": 0.08494, "epss_percentile": 0.92083}, "CVE-2014-9598": {"epss_score": 0.1461, "epss_percentile": 0.94251}, "CVE-2014-9599": {"epss_score": 0.00541, "epss_percentile": 0.67032}, "CVE-2014-9600": {"epss_score": 0.0022, "epss_percentile": 0.44536}, "CVE-2014-9601": {"epss_score": 0.01079, "epss_percentile": 0.77353}, "CVE-2014-9602": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2014-9603": {"epss_score": 0.00908, "epss_percentile": 0.75281}, "CVE-2014-9604": {"epss_score": 0.00645, "epss_percentile": 0.70117}, "CVE-2014-9605": {"epss_score": 0.08686, "epss_percentile": 0.922}, "CVE-2014-9606": {"epss_score": 0.09412, "epss_percentile": 0.92536}, "CVE-2014-9607": {"epss_score": 0.08963, "epss_percentile": 0.92338}, "CVE-2014-9608": {"epss_score": 0.25742, "epss_percentile": 0.96062}, "CVE-2014-9609": {"epss_score": 0.33789, "epss_percentile": 0.96803}, "CVE-2014-9610": {"epss_score": 0.13362, "epss_percentile": 0.93942}, "CVE-2014-9611": {"epss_score": 0.28617, "epss_percentile": 0.96372}, "CVE-2014-9612": {"epss_score": 0.04692, "epss_percentile": 0.89013}, "CVE-2014-9613": {"epss_score": 0.04245, "epss_percentile": 0.88439}, "CVE-2014-9614": {"epss_score": 0.69538, "epss_percentile": 0.98592}, "CVE-2014-9615": {"epss_score": 0.15696, "epss_percentile": 0.94485}, "CVE-2014-9616": {"epss_score": 0.003, "epss_percentile": 0.52914}, "CVE-2014-9617": {"epss_score": 0.26191, "epss_percentile": 0.96121}, "CVE-2014-9618": {"epss_score": 0.68171, "epss_percentile": 0.98534}, "CVE-2014-9619": {"epss_score": 0.06457, "epss_percentile": 0.90769}, "CVE-2014-9620": {"epss_score": 0.03718, "epss_percentile": 0.87616}, "CVE-2014-9621": {"epss_score": 0.01286, "epss_percentile": 0.79185}, "CVE-2014-9622": {"epss_score": 0.00868, "epss_percentile": 0.74668}, "CVE-2014-9623": {"epss_score": 0.01006, "epss_percentile": 0.76552}, "CVE-2014-9624": {"epss_score": 0.00558, "epss_percentile": 0.67601}, "CVE-2014-9625": {"epss_score": 0.01634, "epss_percentile": 0.81465}, "CVE-2014-9626": {"epss_score": 0.00338, "epss_percentile": 0.56161}, "CVE-2014-9627": {"epss_score": 0.00338, "epss_percentile": 0.56161}, "CVE-2014-9628": {"epss_score": 0.01634, "epss_percentile": 0.81465}, "CVE-2014-9629": {"epss_score": 0.01498, "epss_percentile": 0.80705}, "CVE-2014-9630": {"epss_score": 0.00398, "epss_percentile": 0.6009}, "CVE-2014-9632": {"epss_score": 0.00862, "epss_percentile": 0.74575}, "CVE-2014-9633": {"epss_score": 0.04829, "epss_percentile": 0.89189}, "CVE-2014-9634": {"epss_score": 0.00681, "epss_percentile": 0.71055}, "CVE-2014-9635": {"epss_score": 0.00598, "epss_percentile": 0.68756}, "CVE-2014-9636": {"epss_score": 0.65042, "epss_percentile": 0.98402}, "CVE-2014-9637": {"epss_score": 0.00378, "epss_percentile": 0.58822}, "CVE-2014-9638": {"epss_score": 0.01279, "epss_percentile": 0.79131}, "CVE-2014-9639": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2014-9640": {"epss_score": 0.01279, "epss_percentile": 0.79131}, "CVE-2014-9641": {"epss_score": 0.00527, "epss_percentile": 0.66447}, "CVE-2014-9642": {"epss_score": 0.0133, "epss_percentile": 0.79513}, "CVE-2014-9643": {"epss_score": 0.00732, "epss_percentile": 0.72186}, "CVE-2014-9644": {"epss_score": 0.00038, "epss_percentile": 0.11201}, "CVE-2014-9645": {"epss_score": 0.00375, "epss_percentile": 0.586}, "CVE-2014-9646": {"epss_score": 0.00031, "epss_percentile": 0.08543}, "CVE-2014-9647": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2014-9648": {"epss_score": 0.00583, "epss_percentile": 0.68324}, "CVE-2014-9649": {"epss_score": 0.00295, "epss_percentile": 0.52499}, "CVE-2014-9650": {"epss_score": 0.0032, "epss_percentile": 0.54641}, "CVE-2014-9651": {"epss_score": 0.00433, "epss_percentile": 0.62184}, "CVE-2014-9652": {"epss_score": 0.05795, "epss_percentile": 0.90217}, "CVE-2014-9653": {"epss_score": 0.06827, "epss_percentile": 0.91051}, "CVE-2014-9654": {"epss_score": 0.01671, "epss_percentile": 0.81675}, "CVE-2014-9655": {"epss_score": 0.01105, "epss_percentile": 0.77612}, "CVE-2014-9656": {"epss_score": 0.02464, "epss_percentile": 0.84831}, "CVE-2014-9657": {"epss_score": 0.01518, "epss_percentile": 0.80811}, "CVE-2014-9658": {"epss_score": 0.01518, "epss_percentile": 0.80811}, "CVE-2014-9659": {"epss_score": 0.02866, "epss_percentile": 0.85863}, "CVE-2014-9660": {"epss_score": 0.04849, "epss_percentile": 0.89212}, "CVE-2014-9661": {"epss_score": 0.04948, "epss_percentile": 0.8932}, "CVE-2014-9662": {"epss_score": 0.05416, "epss_percentile": 0.89851}, "CVE-2014-9663": {"epss_score": 0.02607, "epss_percentile": 0.85227}, "CVE-2014-9664": {"epss_score": 0.01153, "epss_percentile": 0.78053}, "CVE-2014-9665": {"epss_score": 0.04321, "epss_percentile": 0.88543}, "CVE-2014-9666": {"epss_score": 0.01421, "epss_percentile": 0.80173}, "CVE-2014-9667": {"epss_score": 0.02029, "epss_percentile": 0.83327}, "CVE-2014-9668": {"epss_score": 0.01723, "epss_percentile": 0.81942}, "CVE-2014-9669": {"epss_score": 0.02443, "epss_percentile": 0.84761}, "CVE-2014-9670": {"epss_score": 0.05048, "epss_percentile": 0.89438}, "CVE-2014-9671": {"epss_score": 0.03218, "epss_percentile": 0.86666}, "CVE-2014-9672": {"epss_score": 0.04704, "epss_percentile": 0.8903}, "CVE-2014-9673": {"epss_score": 0.04219, "epss_percentile": 0.88409}, "CVE-2014-9674": {"epss_score": 0.05124, "epss_percentile": 0.89523}, "CVE-2014-9675": {"epss_score": 0.02114, "epss_percentile": 0.83655}, "CVE-2014-9676": {"epss_score": 0.01607, "epss_percentile": 0.81309}, "CVE-2014-9677": {"epss_score": 0.00233, "epss_percentile": 0.45976}, "CVE-2014-9678": {"epss_score": 0.00247, "epss_percentile": 0.47859}, "CVE-2014-9679": {"epss_score": 0.07364, "epss_percentile": 0.91434}, "CVE-2014-9680": {"epss_score": 0.00377, "epss_percentile": 0.5876}, "CVE-2014-9682": {"epss_score": 0.01039, "epss_percentile": 0.76944}, "CVE-2014-9683": {"epss_score": 0.00071, "epss_percentile": 0.22102}, "CVE-2014-9684": {"epss_score": 0.0058, "epss_percentile": 0.68253}, "CVE-2014-9685": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2014-9686": {"epss_score": 0.00862, "epss_percentile": 0.74583}, "CVE-2014-9687": {"epss_score": 0.00518, "epss_percentile": 0.66129}, "CVE-2014-9688": {"epss_score": 0.00311, "epss_percentile": 0.53926}, "CVE-2014-9689": {"epss_score": 0.00373, "epss_percentile": 0.58473}, "CVE-2014-9690": {"epss_score": 0.00177, "epss_percentile": 0.39583}, "CVE-2014-9691": {"epss_score": 0.00138, "epss_percentile": 0.34345}, "CVE-2014-9692": {"epss_score": 0.00143, "epss_percentile": 0.35173}, "CVE-2014-9693": {"epss_score": 0.00456, "epss_percentile": 0.63331}, "CVE-2014-9694": {"epss_score": 0.00074, "epss_percentile": 0.22814}, "CVE-2014-9695": {"epss_score": 0.00215, "epss_percentile": 0.44083}, "CVE-2014-9696": {"epss_score": 0.00215, "epss_percentile": 0.44083}, "CVE-2014-9697": {"epss_score": 0.00259, "epss_percentile": 0.49039}, "CVE-2014-9699": {"epss_score": 0.00511, "epss_percentile": 0.65842}, "CVE-2014-9701": {"epss_score": 0.009, "epss_percentile": 0.75162}, "CVE-2014-9702": {"epss_score": 0.00339, "epss_percentile": 0.56177}, "CVE-2014-9705": {"epss_score": 0.35164, "epss_percentile": 0.96891}, "CVE-2014-9706": {"epss_score": 0.02765, "epss_percentile": 0.85609}, "CVE-2014-9707": {"epss_score": 0.66123, "epss_percentile": 0.98451}, "CVE-2014-9708": {"epss_score": 0.0451, "epss_percentile": 0.8878}, "CVE-2014-9709": {"epss_score": 0.15311, "epss_percentile": 0.94407}, "CVE-2014-9710": {"epss_score": 0.00051, "epss_percentile": 0.1629}, "CVE-2014-9711": {"epss_score": 0.00737, "epss_percentile": 0.72333}, "CVE-2014-9712": {"epss_score": 0.00266, "epss_percentile": 0.49946}, "CVE-2014-9713": {"epss_score": 0.00142, "epss_percentile": 0.35039}, "CVE-2014-9714": {"epss_score": 0.00521, "epss_percentile": 0.66218}, "CVE-2014-9715": {"epss_score": 0.00043, "epss_percentile": 0.13326}, "CVE-2014-9716": {"epss_score": 0.005, "epss_percentile": 0.65312}, "CVE-2014-9717": {"epss_score": 0.00041, "epss_percentile": 0.12366}, "CVE-2014-9718": {"epss_score": 0.00217, "epss_percentile": 0.44247}, "CVE-2014-9720": {"epss_score": 0.00904, "epss_percentile": 0.75214}, "CVE-2014-9721": {"epss_score": 0.00345, "epss_percentile": 0.56591}, "CVE-2014-9727": {"epss_score": 0.87064, "epss_percentile": 0.99412}, "CVE-2014-9728": {"epss_score": 0.00041, "epss_percentile": 0.12286}, "CVE-2014-9729": {"epss_score": 0.00042, "epss_percentile": 0.12585}, "CVE-2014-9730": {"epss_score": 0.00042, "epss_percentile": 0.12585}, "CVE-2014-9731": {"epss_score": 0.00057, "epss_percentile": 0.18102}, "CVE-2014-9732": {"epss_score": 0.004, "epss_percentile": 0.60179}, "CVE-2014-9733": {"epss_score": 0.00691, "epss_percentile": 0.7128}, "CVE-2014-9734": {"epss_score": 0.06871, "epss_percentile": 0.91085}, "CVE-2014-9735": {"epss_score": 0.82749, "epss_percentile": 0.99211}, "CVE-2014-9736": {"epss_score": 0.00433, "epss_percentile": 0.62183}, "CVE-2014-9737": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2014-9738": {"epss_score": 0.00225, "epss_percentile": 0.45091}, "CVE-2014-9739": {"epss_score": 0.00158, "epss_percentile": 0.37221}, "CVE-2014-9740": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2014-9741": {"epss_score": 0.00344, "epss_percentile": 0.565}, "CVE-2014-9742": {"epss_score": 0.00281, "epss_percentile": 0.51135}, "CVE-2014-9743": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2014-9744": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2014-9745": {"epss_score": 0.02361, "epss_percentile": 0.84498}, "CVE-2014-9746": {"epss_score": 0.00847, "epss_percentile": 0.74345}, "CVE-2014-9747": {"epss_score": 0.01163, "epss_percentile": 0.7816}, "CVE-2014-9748": {"epss_score": 0.00477, "epss_percentile": 0.64329}, "CVE-2014-9749": {"epss_score": 0.01938, "epss_percentile": 0.82967}, "CVE-2014-9750": {"epss_score": 0.0726, "epss_percentile": 0.91355}, "CVE-2014-9751": {"epss_score": 0.05983, "epss_percentile": 0.9038}, "CVE-2014-9752": {"epss_score": 0.00699, "epss_percentile": 0.7145}, "CVE-2014-9753": {"epss_score": 0.01843, "epss_percentile": 0.82504}, "CVE-2014-9754": {"epss_score": 0.00388, "epss_percentile": 0.59394}, "CVE-2014-9755": {"epss_score": 0.01821, "epss_percentile": 0.8241}, "CVE-2014-9756": {"epss_score": 0.00675, "epss_percentile": 0.70911}, "CVE-2014-9757": {"epss_score": 0.00778, "epss_percentile": 0.73129}, "CVE-2014-9758": {"epss_score": 0.00073, "epss_percentile": 0.22606}, "CVE-2014-9759": {"epss_score": 0.00291, "epss_percentile": 0.52145}, "CVE-2014-9760": {"epss_score": 0.00413, "epss_percentile": 0.6099}, "CVE-2014-9761": {"epss_score": 0.03823, "epss_percentile": 0.87789}, "CVE-2014-9762": {"epss_score": 0.02843, "epss_percentile": 0.85812}, "CVE-2014-9763": {"epss_score": 0.01896, "epss_percentile": 0.82753}, "CVE-2014-9764": {"epss_score": 0.01608, "epss_percentile": 0.81314}, "CVE-2014-9765": {"epss_score": 0.02475, "epss_percentile": 0.84861}, "CVE-2014-9766": {"epss_score": 0.14144, "epss_percentile": 0.94144}, "CVE-2014-9767": {"epss_score": 0.00492, "epss_percentile": 0.65002}, "CVE-2014-9768": {"epss_score": 0.00659, "epss_percentile": 0.70506}, "CVE-2014-9769": {"epss_score": 0.00934, "epss_percentile": 0.75649}, "CVE-2014-9770": {"epss_score": 0.00095, "epss_percentile": 0.27193}, "CVE-2014-9771": {"epss_score": 0.01177, "epss_percentile": 0.78278}, "CVE-2014-9772": {"epss_score": 0.00602, "epss_percentile": 0.6889}, "CVE-2014-9773": {"epss_score": 0.00409, "epss_percentile": 0.60722}, "CVE-2014-9777": {"epss_score": 0.0007, "epss_percentile": 0.21821}, "CVE-2014-9778": {"epss_score": 0.0007, "epss_percentile": 0.21821}, "CVE-2014-9779": {"epss_score": 0.00123, "epss_percentile": 0.32326}, "CVE-2014-9780": {"epss_score": 0.0007, "epss_percentile": 0.21821}, "CVE-2014-9781": {"epss_score": 0.00076, "epss_percentile": 0.23224}, "CVE-2014-9782": {"epss_score": 0.00071, "epss_percentile": 0.2202}, "CVE-2014-9783": {"epss_score": 0.00067, "epss_percentile": 0.21043}, "CVE-2014-9784": {"epss_score": 0.00076, "epss_percentile": 0.23224}, "CVE-2014-9785": {"epss_score": 0.00071, "epss_percentile": 0.2202}, "CVE-2014-9786": {"epss_score": 0.00076, "epss_percentile": 0.23224}, "CVE-2014-9787": {"epss_score": 0.00071, "epss_percentile": 0.2202}, "CVE-2014-9788": {"epss_score": 0.00063, "epss_percentile": 0.20085}, "CVE-2014-9789": {"epss_score": 0.00065, "epss_percentile": 0.20568}, "CVE-2014-9790": {"epss_score": 0.00067, "epss_percentile": 0.21081}, "CVE-2014-9792": {"epss_score": 0.00145, "epss_percentile": 0.35447}, "CVE-2014-9793": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2014-9795": {"epss_score": 0.00067, "epss_percentile": 0.21081}, "CVE-2014-9796": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2014-9798": {"epss_score": 0.00049, "epss_percentile": 0.15425}, "CVE-2014-9799": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2014-9800": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2014-9801": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2014-9802": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2014-9803": {"epss_score": 0.00071, "epss_percentile": 0.21997}, "CVE-2014-9804": {"epss_score": 0.01223, "epss_percentile": 0.78667}, "CVE-2014-9805": {"epss_score": 0.00457, "epss_percentile": 0.63372}, "CVE-2014-9806": {"epss_score": 0.00457, "epss_percentile": 0.63372}, "CVE-2014-9807": {"epss_score": 0.00414, "epss_percentile": 0.61031}, "CVE-2014-9808": {"epss_score": 0.00454, "epss_percentile": 0.63262}, "CVE-2014-9809": {"epss_score": 0.00477, "epss_percentile": 0.64353}, "CVE-2014-9810": {"epss_score": 0.00457, "epss_percentile": 0.63372}, "CVE-2014-9811": {"epss_score": 0.00577, "epss_percentile": 0.68161}, "CVE-2014-9812": {"epss_score": 0.004, "epss_percentile": 0.60176}, "CVE-2014-9813": {"epss_score": 0.00577, "epss_percentile": 0.68161}, "CVE-2014-9814": {"epss_score": 0.004, "epss_percentile": 0.60176}, "CVE-2014-9815": {"epss_score": 0.00457, "epss_percentile": 0.63372}, "CVE-2014-9816": {"epss_score": 0.004, "epss_percentile": 0.60176}, "CVE-2014-9817": {"epss_score": 0.00424, "epss_percentile": 0.6168}, "CVE-2014-9818": {"epss_score": 0.004, "epss_percentile": 0.60176}, "CVE-2014-9819": {"epss_score": 0.00424, "epss_percentile": 0.6168}, "CVE-2014-9820": {"epss_score": 0.00424, "epss_percentile": 0.6168}, "CVE-2014-9821": {"epss_score": 0.00424, "epss_percentile": 0.6168}, "CVE-2014-9822": {"epss_score": 0.00424, "epss_percentile": 0.6168}, "CVE-2014-9823": {"epss_score": 0.00424, "epss_percentile": 0.6168}, "CVE-2014-9824": {"epss_score": 0.00296, "epss_percentile": 0.52617}, "CVE-2014-9825": {"epss_score": 0.00296, "epss_percentile": 0.52617}, "CVE-2014-9826": {"epss_score": 0.00794, "epss_percentile": 0.73438}, "CVE-2014-9827": {"epss_score": 0.00412, "epss_percentile": 0.60934}, "CVE-2014-9828": {"epss_score": 0.00498, "epss_percentile": 0.65222}, "CVE-2014-9829": {"epss_score": 0.00596, "epss_percentile": 0.68708}, "CVE-2014-9830": {"epss_score": 0.00498, "epss_percentile": 0.65222}, "CVE-2014-9831": {"epss_score": 0.00498, "epss_percentile": 0.65222}, "CVE-2014-9832": {"epss_score": 0.002, "epss_percentile": 0.42215}, "CVE-2014-9833": {"epss_score": 0.00267, "epss_percentile": 0.50009}, "CVE-2014-9834": {"epss_score": 0.00267, "epss_percentile": 0.50009}, "CVE-2014-9835": {"epss_score": 0.00267, "epss_percentile": 0.50009}, "CVE-2014-9836": {"epss_score": 0.00387, "epss_percentile": 0.59308}, "CVE-2014-9837": {"epss_score": 0.00596, "epss_percentile": 0.68708}, "CVE-2014-9838": {"epss_score": 0.00377, "epss_percentile": 0.58728}, "CVE-2014-9839": {"epss_score": 0.00674, "epss_percentile": 0.70853}, "CVE-2014-9840": {"epss_score": 0.00387, "epss_percentile": 0.59308}, "CVE-2014-9841": {"epss_score": 0.00954, "epss_percentile": 0.75903}, "CVE-2014-9842": {"epss_score": 0.02408, "epss_percentile": 0.84658}, "CVE-2014-9843": {"epss_score": 0.00954, "epss_percentile": 0.75903}, "CVE-2014-9844": {"epss_score": 0.00308, "epss_percentile": 0.53606}, "CVE-2014-9845": {"epss_score": 0.00418, "epss_percentile": 0.61283}, "CVE-2014-9846": {"epss_score": 0.0385, "epss_percentile": 0.87845}, "CVE-2014-9847": {"epss_score": 0.04084, "epss_percentile": 0.88225}, "CVE-2014-9848": {"epss_score": 0.01854, "epss_percentile": 0.82557}, "CVE-2014-9849": {"epss_score": 0.01406, "epss_percentile": 0.80052}, "CVE-2014-9850": {"epss_score": 0.01406, "epss_percentile": 0.80052}, "CVE-2014-9851": {"epss_score": 0.01785, "epss_percentile": 0.82253}, "CVE-2014-9852": {"epss_score": 0.01316, "epss_percentile": 0.79405}, "CVE-2014-9853": {"epss_score": 0.00473, "epss_percentile": 0.64076}, "CVE-2014-9854": {"epss_score": 0.01507, "epss_percentile": 0.80754}, "CVE-2014-9862": {"epss_score": 0.11765, "epss_percentile": 0.93468}, "CVE-2014-9863": {"epss_score": 0.00059, "epss_percentile": 0.18692}, "CVE-2014-9864": {"epss_score": 0.00059, "epss_percentile": 0.18692}, "CVE-2014-9865": {"epss_score": 0.00052, "epss_percentile": 0.16381}, "CVE-2014-9866": {"epss_score": 0.00059, "epss_percentile": 0.18692}, "CVE-2014-9867": {"epss_score": 0.00059, "epss_percentile": 0.18692}, "CVE-2014-9868": {"epss_score": 0.00038, "epss_percentile": 0.11403}, "CVE-2014-9869": {"epss_score": 0.00062, "epss_percentile": 0.19614}, "CVE-2014-9870": {"epss_score": 0.00075, "epss_percentile": 0.22913}, "CVE-2014-9871": {"epss_score": 0.00063, "epss_percentile": 0.20085}, "CVE-2014-9872": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9873": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9874": {"epss_score": 0.00082, "epss_percentile": 0.24463}, "CVE-2014-9875": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9876": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9877": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9878": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9879": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9880": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9881": {"epss_score": 0.00071, "epss_percentile": 0.22202}, "CVE-2014-9882": {"epss_score": 0.00091, "epss_percentile": 0.26215}, "CVE-2014-9883": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9884": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9885": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9886": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9887": {"epss_score": 0.00059, "epss_percentile": 0.18692}, "CVE-2014-9888": {"epss_score": 0.00044, "epss_percentile": 0.13371}, "CVE-2014-9889": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2014-9890": {"epss_score": 0.00059, "epss_percentile": 0.18692}, "CVE-2014-9891": {"epss_score": 0.00059, "epss_percentile": 0.18692}, "CVE-2014-9892": {"epss_score": 0.00102, "epss_percentile": 0.28798}, "CVE-2014-9893": {"epss_score": 0.0009, "epss_percentile": 0.26088}, "CVE-2014-9894": {"epss_score": 0.0009, "epss_percentile": 0.26088}, "CVE-2014-9895": {"epss_score": 0.00094, "epss_percentile": 0.27046}, "CVE-2014-9896": {"epss_score": 0.0009, "epss_percentile": 0.26088}, "CVE-2014-9897": {"epss_score": 0.0009, "epss_percentile": 0.26088}, "CVE-2014-9898": {"epss_score": 0.0009, "epss_percentile": 0.26088}, "CVE-2014-9899": {"epss_score": 0.0009, "epss_percentile": 0.26088}, "CVE-2014-9900": {"epss_score": 0.00079, "epss_percentile": 0.23808}, "CVE-2014-9901": {"epss_score": 0.0051, "epss_percentile": 0.65761}, "CVE-2014-9902": {"epss_score": 0.03882, "epss_percentile": 0.87897}, "CVE-2014-9903": {"epss_score": 0.0005, "epss_percentile": 0.15929}, "CVE-2014-9904": {"epss_score": 0.00094, "epss_percentile": 0.26779}, "CVE-2014-9905": {"epss_score": 0.006, "epss_percentile": 0.68825}, "CVE-2014-9906": {"epss_score": 0.02999, "epss_percentile": 0.8616}, "CVE-2014-9907": {"epss_score": 0.01405, "epss_percentile": 0.80046}, "CVE-2014-9908": {"epss_score": 0.00414, "epss_percentile": 0.61023}, "CVE-2014-9909": {"epss_score": 0.0004, "epss_percentile": 0.12103}, "CVE-2014-9910": {"epss_score": 0.0004, "epss_percentile": 0.12103}, "CVE-2014-9911": {"epss_score": 0.01888, "epss_percentile": 0.82721}, "CVE-2014-9912": {"epss_score": 0.01163, "epss_percentile": 0.78157}, "CVE-2014-9913": {"epss_score": 0.03083, "epss_percentile": 0.86375}, "CVE-2014-9914": {"epss_score": 0.00032, "epss_percentile": 0.08716}, "CVE-2014-9915": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2014-9916": {"epss_score": 0.00195, "epss_percentile": 0.41666}, "CVE-2014-9917": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2014-9918": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2014-9919": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2014-9920": {"epss_score": 0.00373, "epss_percentile": 0.58495}, "CVE-2014-9921": {"epss_score": 0.01198, "epss_percentile": 0.78453}, "CVE-2014-9922": {"epss_score": 0.00073, "epss_percentile": 0.22639}, "CVE-2014-9923": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2014-9924": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2014-9925": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2014-9926": {"epss_score": 0.00041, "epss_percentile": 0.12432}, "CVE-2014-9927": {"epss_score": 0.00044, "epss_percentile": 0.13653}, "CVE-2014-9928": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2014-9929": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2014-9930": {"epss_score": 0.00041, "epss_percentile": 0.12432}, "CVE-2014-9931": {"epss_score": 0.0018, "epss_percentile": 0.39889}, "CVE-2014-9932": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2014-9933": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2014-9934": {"epss_score": 0.00027, "epss_percentile": 0.06946}, "CVE-2014-9935": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2014-9936": {"epss_score": 0.00098, "epss_percentile": 0.27773}, "CVE-2014-9937": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2014-9938": {"epss_score": 0.0075, "epss_percentile": 0.72621}, "CVE-2014-9939": {"epss_score": 0.00378, "epss_percentile": 0.58829}, "CVE-2014-9940": {"epss_score": 0.00097, "epss_percentile": 0.27484}, "CVE-2014-9941": {"epss_score": 0.00027, "epss_percentile": 0.0712}, "CVE-2014-9942": {"epss_score": 0.00037, "epss_percentile": 0.10639}, "CVE-2014-9943": {"epss_score": 0.00034, "epss_percentile": 0.09457}, "CVE-2014-9944": {"epss_score": 0.00038, "epss_percentile": 0.11272}, "CVE-2014-9945": {"epss_score": 0.00031, "epss_percentile": 0.08555}, "CVE-2014-9946": {"epss_score": 0.00041, "epss_percentile": 0.12432}, "CVE-2014-9947": {"epss_score": 0.00057, "epss_percentile": 0.18087}, "CVE-2014-9948": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2014-9949": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2014-9950": {"epss_score": 0.00031, "epss_percentile": 0.08555}, "CVE-2014-9951": {"epss_score": 0.00057, "epss_percentile": 0.18087}, "CVE-2014-9952": {"epss_score": 0.00031, "epss_percentile": 0.08555}, "CVE-2014-9953": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2014-9954": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2014-9955": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2014-9956": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2014-9957": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2014-9958": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2014-9959": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2014-9960": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2014-9961": {"epss_score": 0.00051, "epss_percentile": 0.16244}, "CVE-2014-9962": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2014-9963": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2014-9964": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2014-9965": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2014-9966": {"epss_score": 0.00045, "epss_percentile": 0.13909}, "CVE-2014-9967": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2014-9968": {"epss_score": 0.00189, "epss_percentile": 0.40939}, "CVE-2014-9969": {"epss_score": 0.00082, "epss_percentile": 0.24553}, "CVE-2014-9970": {"epss_score": 0.00944, "epss_percentile": 0.7579}, "CVE-2014-9971": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2014-9972": {"epss_score": 0.00216, "epss_percentile": 0.44161}, "CVE-2014-9973": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2014-9974": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2014-9975": {"epss_score": 0.00044, "epss_percentile": 0.1362}, "CVE-2014-9976": {"epss_score": 0.00247, "epss_percentile": 0.47811}, "CVE-2014-9977": {"epss_score": 0.00189, "epss_percentile": 0.40939}, "CVE-2014-9978": {"epss_score": 0.00189, "epss_percentile": 0.40939}, "CVE-2014-9979": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2014-9980": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2014-9981": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2014-9983": {"epss_score": 0.00261, "epss_percentile": 0.4927}, "CVE-2014-9984": {"epss_score": 0.00678, "epss_percentile": 0.70981}, "CVE-2014-9985": {"epss_score": 0.00257, "epss_percentile": 0.48859}, "CVE-2014-9986": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2014-9987": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2014-9988": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2014-9989": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2014-9990": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2014-9991": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2014-9993": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2014-9994": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2014-9995": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2014-9996": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2014-9997": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2014-9998": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2015-0001": {"epss_score": 0.00649, "epss_percentile": 0.70239}, "CVE-2015-0002": {"epss_score": 0.39777, "epss_percentile": 0.9718}, "CVE-2015-0003": {"epss_score": 0.13573, "epss_percentile": 0.93999}, "CVE-2015-0004": {"epss_score": 0.24057, "epss_percentile": 0.95851}, "CVE-2015-0005": {"epss_score": 0.01085, "epss_percentile": 0.77404}, "CVE-2015-0006": {"epss_score": 0.11084, "epss_percentile": 0.93214}, "CVE-2015-0008": {"epss_score": 0.09423, "epss_percentile": 0.9254}, "CVE-2015-0009": {"epss_score": 0.01772, "epss_percentile": 0.82204}, "CVE-2015-0010": {"epss_score": 0.01726, "epss_percentile": 0.81966}, "CVE-2015-0011": {"epss_score": 0.0054, "epss_percentile": 0.66989}, "CVE-2015-0012": {"epss_score": 0.03941, "epss_percentile": 0.87989}, "CVE-2015-0014": {"epss_score": 0.80777, "epss_percentile": 0.99104}, "CVE-2015-0015": {"epss_score": 0.37244, "epss_percentile": 0.9703}, "CVE-2015-0016": {"epss_score": 0.91284, "epss_percentile": 0.99632}, "CVE-2015-0017": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0018": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0019": {"epss_score": 0.2961, "epss_percentile": 0.96461}, "CVE-2015-0020": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0021": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0022": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0023": {"epss_score": 0.14058, "epss_percentile": 0.94125}, "CVE-2015-0025": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0026": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0027": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0028": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0029": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0030": {"epss_score": 0.32076, "epss_percentile": 0.96671}, "CVE-2015-0031": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0032": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2015-0035": {"epss_score": 0.22023, "epss_percentile": 0.95585}, "CVE-2015-0036": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0037": {"epss_score": 0.21227, "epss_percentile": 0.95481}, "CVE-2015-0038": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0039": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0040": {"epss_score": 0.49669, "epss_percentile": 0.97699}, "CVE-2015-0041": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0042": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0043": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0044": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0045": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0046": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0048": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0049": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0050": {"epss_score": 0.51421, "epss_percentile": 0.97777}, "CVE-2015-0051": {"epss_score": 0.23412, "epss_percentile": 0.95775}, "CVE-2015-0052": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0053": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0054": {"epss_score": 0.079, "epss_percentile": 0.91754}, "CVE-2015-0055": {"epss_score": 0.079, "epss_percentile": 0.91754}, "CVE-2015-0056": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0057": {"epss_score": 0.65274, "epss_percentile": 0.9841}, "CVE-2015-0058": {"epss_score": 0.07744, "epss_percentile": 0.91654}, "CVE-2015-0059": {"epss_score": 0.36366, "epss_percentile": 0.96971}, "CVE-2015-0060": {"epss_score": 0.0252, "epss_percentile": 0.84999}, "CVE-2015-0061": {"epss_score": 0.22126, "epss_percentile": 0.95597}, "CVE-2015-0062": {"epss_score": 0.01449, "epss_percentile": 0.80342}, "CVE-2015-0063": {"epss_score": 0.3411, "epss_percentile": 0.96826}, "CVE-2015-0064": {"epss_score": 0.71222, "epss_percentile": 0.9866}, "CVE-2015-0065": {"epss_score": 0.68596, "epss_percentile": 0.98556}, "CVE-2015-0066": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0067": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0068": {"epss_score": 0.273, "epss_percentile": 0.96233}, "CVE-2015-0069": {"epss_score": 0.23412, "epss_percentile": 0.95775}, "CVE-2015-0070": {"epss_score": 0.22283, "epss_percentile": 0.95618}, "CVE-2015-0071": {"epss_score": 0.38673, "epss_percentile": 0.97113}, "CVE-2015-0072": {"epss_score": 0.88552, "epss_percentile": 0.99476}, "CVE-2015-0073": {"epss_score": 0.03465, "epss_percentile": 0.87188}, "CVE-2015-0074": {"epss_score": 0.14556, "epss_percentile": 0.9424}, "CVE-2015-0075": {"epss_score": 0.01332, "epss_percentile": 0.79527}, "CVE-2015-0076": {"epss_score": 0.07639, "epss_percentile": 0.91593}, "CVE-2015-0077": {"epss_score": 0.04753, "epss_percentile": 0.89106}, "CVE-2015-0078": {"epss_score": 0.04706, "epss_percentile": 0.89031}, "CVE-2015-0079": {"epss_score": 0.22982, "epss_percentile": 0.95712}, "CVE-2015-0080": {"epss_score": 0.08061, "epss_percentile": 0.9186}, "CVE-2015-0081": {"epss_score": 0.72598, "epss_percentile": 0.98718}, "CVE-2015-0084": {"epss_score": 0.0112, "epss_percentile": 0.77765}, "CVE-2015-0085": {"epss_score": 0.39549, "epss_percentile": 0.97167}, "CVE-2015-0086": {"epss_score": 0.35816, "epss_percentile": 0.96936}, "CVE-2015-0087": {"epss_score": 0.2699, "epss_percentile": 0.96197}, "CVE-2015-0088": {"epss_score": 0.23727, "epss_percentile": 0.95811}, "CVE-2015-0089": {"epss_score": 0.27314, "epss_percentile": 0.96236}, "CVE-2015-0090": {"epss_score": 0.23727, "epss_percentile": 0.95811}, "CVE-2015-0091": {"epss_score": 0.23727, "epss_percentile": 0.95811}, "CVE-2015-0092": {"epss_score": 0.23727, "epss_percentile": 0.95811}, "CVE-2015-0093": {"epss_score": 0.23727, "epss_percentile": 0.95811}, "CVE-2015-0094": {"epss_score": 0.02453, "epss_percentile": 0.84791}, "CVE-2015-0095": {"epss_score": 0.00597, "epss_percentile": 0.68736}, "CVE-2015-0096": {"epss_score": 0.87372, "epss_percentile": 0.99426}, "CVE-2015-0097": {"epss_score": 0.79327, "epss_percentile": 0.99033}, "CVE-2015-0098": {"epss_score": 0.00815, "epss_percentile": 0.73783}, "CVE-2015-0099": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-0100": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-0101": {"epss_score": 0.00224, "epss_percentile": 0.44977}, "CVE-2015-0102": {"epss_score": 0.00419, "epss_percentile": 0.61398}, "CVE-2015-0103": {"epss_score": 0.00176, "epss_percentile": 0.39422}, "CVE-2015-0104": {"epss_score": 0.02037, "epss_percentile": 0.83357}, "CVE-2015-0105": {"epss_score": 0.00352, "epss_percentile": 0.571}, "CVE-2015-0106": {"epss_score": 0.00271, "epss_percentile": 0.50325}, "CVE-2015-0107": {"epss_score": 0.07172, "epss_percentile": 0.91298}, "CVE-2015-0108": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2015-0109": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-0110": {"epss_score": 0.0009, "epss_percentile": 0.25993}, "CVE-2015-0112": {"epss_score": 0.00332, "epss_percentile": 0.55602}, "CVE-2015-0113": {"epss_score": 0.00362, "epss_percentile": 0.57773}, "CVE-2015-0114": {"epss_score": 0.00083, "epss_percentile": 0.24825}, "CVE-2015-0115": {"epss_score": 0.00087, "epss_percentile": 0.25617}, "CVE-2015-0116": {"epss_score": 0.00218, "epss_percentile": 0.44419}, "CVE-2015-0117": {"epss_score": 0.17508, "epss_percentile": 0.94858}, "CVE-2015-0118": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2015-0119": {"epss_score": 0.01799, "epss_percentile": 0.82316}, "CVE-2015-0120": {"epss_score": 0.00378, "epss_percentile": 0.58827}, "CVE-2015-0121": {"epss_score": 0.00193, "epss_percentile": 0.41494}, "CVE-2015-0122": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2015-0123": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2015-0124": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2015-0125": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-0126": {"epss_score": 0.00191, "epss_percentile": 0.41201}, "CVE-2015-0127": {"epss_score": 0.00137, "epss_percentile": 0.34314}, "CVE-2015-0128": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-0129": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-0130": {"epss_score": 0.00201, "epss_percentile": 0.42333}, "CVE-2015-0131": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-0132": {"epss_score": 0.00533, "epss_percentile": 0.66775}, "CVE-2015-0133": {"epss_score": 0.00391, "epss_percentile": 0.5959}, "CVE-2015-0134": {"epss_score": 0.24111, "epss_percentile": 0.95875}, "CVE-2015-0135": {"epss_score": 0.32382, "epss_percentile": 0.96694}, "CVE-2015-0136": {"epss_score": 0.00118, "epss_percentile": 0.31437}, "CVE-2015-0137": {"epss_score": 0.0017, "epss_percentile": 0.38657}, "CVE-2015-0138": {"epss_score": 0.01057, "epss_percentile": 0.77133}, "CVE-2015-0139": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2015-0140": {"epss_score": 0.01827, "epss_percentile": 0.82439}, "CVE-2015-0141": {"epss_score": 0.00201, "epss_percentile": 0.42323}, "CVE-2015-0142": {"epss_score": 0.00358, "epss_percentile": 0.57532}, "CVE-2015-0143": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2015-0144": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-0145": {"epss_score": 0.00103, "epss_percentile": 0.28976}, "CVE-2015-0146": {"epss_score": 0.0005, "epss_percentile": 0.15971}, "CVE-2015-0149": {"epss_score": 0.00154, "epss_percentile": 0.36652}, "CVE-2015-0150": {"epss_score": 0.00581, "epss_percentile": 0.6827}, "CVE-2015-0151": {"epss_score": 0.00176, "epss_percentile": 0.39433}, "CVE-2015-0152": {"epss_score": 0.00482, "epss_percentile": 0.64535}, "CVE-2015-0153": {"epss_score": 0.00425, "epss_percentile": 0.61697}, "CVE-2015-0156": {"epss_score": 0.00227, "epss_percentile": 0.454}, "CVE-2015-0157": {"epss_score": 0.01543, "epss_percentile": 0.80957}, "CVE-2015-0158": {"epss_score": 0.00358, "epss_percentile": 0.57515}, "CVE-2015-0160": {"epss_score": 0.01162, "epss_percentile": 0.78148}, "CVE-2015-0161": {"epss_score": 0.00277, "epss_percentile": 0.50779}, "CVE-2015-0162": {"epss_score": 0.00051, "epss_percentile": 0.16061}, "CVE-2015-0167": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-0168": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-0169": {"epss_score": 0.0018, "epss_percentile": 0.3997}, "CVE-2015-0170": {"epss_score": 0.0005, "epss_percentile": 0.15971}, "CVE-2015-0171": {"epss_score": 0.0093, "epss_percentile": 0.75596}, "CVE-2015-0172": {"epss_score": 0.00188, "epss_percentile": 0.40807}, "CVE-2015-0173": {"epss_score": 0.00165, "epss_percentile": 0.38078}, "CVE-2015-0174": {"epss_score": 0.00165, "epss_percentile": 0.38026}, "CVE-2015-0175": {"epss_score": 0.00362, "epss_percentile": 0.57766}, "CVE-2015-0176": {"epss_score": 0.0022, "epss_percentile": 0.44594}, "CVE-2015-0177": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2015-0178": {"epss_score": 0.00199, "epss_percentile": 0.42101}, "CVE-2015-0179": {"epss_score": 0.00692, "epss_percentile": 0.71297}, "CVE-2015-0180": {"epss_score": 0.00135, "epss_percentile": 0.34017}, "CVE-2015-0189": {"epss_score": 0.00512, "epss_percentile": 0.65865}, "CVE-2015-0192": {"epss_score": 0.02501, "epss_percentile": 0.84924}, "CVE-2015-0193": {"epss_score": 0.00201, "epss_percentile": 0.42333}, "CVE-2015-0194": {"epss_score": 0.00194, "epss_percentile": 0.41594}, "CVE-2015-0195": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2015-0196": {"epss_score": 0.00246, "epss_percentile": 0.47784}, "CVE-2015-0197": {"epss_score": 0.00283, "epss_percentile": 0.51404}, "CVE-2015-0198": {"epss_score": 0.01716, "epss_percentile": 0.81901}, "CVE-2015-0199": {"epss_score": 0.00195, "epss_percentile": 0.41628}, "CVE-2015-0200": {"epss_score": 0.00055, "epss_percentile": 0.17551}, "CVE-2015-0201": {"epss_score": 0.00293, "epss_percentile": 0.52288}, "CVE-2015-0202": {"epss_score": 0.02082, "epss_percentile": 0.83538}, "CVE-2015-0203": {"epss_score": 0.17096, "epss_percentile": 0.94773}, "CVE-2015-0204": {"epss_score": 0.92433, "epss_percentile": 0.99715}, "CVE-2015-0205": {"epss_score": 0.08275, "epss_percentile": 0.91964}, "CVE-2015-0206": {"epss_score": 0.34251, "epss_percentile": 0.96836}, "CVE-2015-0207": {"epss_score": 0.17612, "epss_percentile": 0.94875}, "CVE-2015-0208": {"epss_score": 0.22369, "epss_percentile": 0.95626}, "CVE-2015-0209": {"epss_score": 0.02501, "epss_percentile": 0.84921}, "CVE-2015-0210": {"epss_score": 0.00301, "epss_percentile": 0.52995}, "CVE-2015-0211": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2015-0212": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-0213": {"epss_score": 0.00126, "epss_percentile": 0.32699}, "CVE-2015-0214": {"epss_score": 0.00207, "epss_percentile": 0.43078}, "CVE-2015-0215": {"epss_score": 0.00183, "epss_percentile": 0.40335}, "CVE-2015-0216": {"epss_score": 0.00227, "epss_percentile": 0.45373}, "CVE-2015-0217": {"epss_score": 0.0059, "epss_percentile": 0.68551}, "CVE-2015-0218": {"epss_score": 0.00126, "epss_percentile": 0.32699}, "CVE-2015-0219": {"epss_score": 0.03128, "epss_percentile": 0.86459}, "CVE-2015-0220": {"epss_score": 0.02549, "epss_percentile": 0.8507}, "CVE-2015-0221": {"epss_score": 0.09153, "epss_percentile": 0.92424}, "CVE-2015-0222": {"epss_score": 0.05841, "epss_percentile": 0.90252}, "CVE-2015-0223": {"epss_score": 0.02275, "epss_percentile": 0.84226}, "CVE-2015-0224": {"epss_score": 0.57415, "epss_percentile": 0.9806}, "CVE-2015-0225": {"epss_score": 0.00904, "epss_percentile": 0.7521}, "CVE-2015-0226": {"epss_score": 0.0521, "epss_percentile": 0.89614}, "CVE-2015-0227": {"epss_score": 0.13872, "epss_percentile": 0.94081}, "CVE-2015-0228": {"epss_score": 0.18715, "epss_percentile": 0.95057}, "CVE-2015-0231": {"epss_score": 0.87284, "epss_percentile": 0.99422}, "CVE-2015-0232": {"epss_score": 0.68266, "epss_percentile": 0.98539}, "CVE-2015-0233": {"epss_score": 0.00071, "epss_percentile": 0.22055}, "CVE-2015-0234": {"epss_score": 0.00553, "epss_percentile": 0.67413}, "CVE-2015-0235": {"epss_score": 0.8487, "epss_percentile": 0.99309}, "CVE-2015-0236": {"epss_score": 0.0065, "epss_percentile": 0.70248}, "CVE-2015-0237": {"epss_score": 0.00418, "epss_percentile": 0.61325}, "CVE-2015-0238": {"epss_score": 0.00041, "epss_percentile": 0.12234}, "CVE-2015-0239": {"epss_score": 0.00101, "epss_percentile": 0.28624}, "CVE-2015-0240": {"epss_score": 0.90443, "epss_percentile": 0.99584}, "CVE-2015-0241": {"epss_score": 0.06686, "epss_percentile": 0.90946}, "CVE-2015-0242": {"epss_score": 0.03377, "epss_percentile": 0.87022}, "CVE-2015-0243": {"epss_score": 0.07121, "epss_percentile": 0.91264}, "CVE-2015-0244": {"epss_score": 0.01077, "epss_percentile": 0.77337}, "CVE-2015-0245": {"epss_score": 0.00083, "epss_percentile": 0.24826}, "CVE-2015-0247": {"epss_score": 0.00306, "epss_percentile": 0.53409}, "CVE-2015-0248": {"epss_score": 0.15803, "epss_percentile": 0.94511}, "CVE-2015-0249": {"epss_score": 0.0039, "epss_percentile": 0.59535}, "CVE-2015-0250": {"epss_score": 0.01083, "epss_percentile": 0.77388}, "CVE-2015-0251": {"epss_score": 0.01065, "epss_percentile": 0.7721}, "CVE-2015-0252": {"epss_score": 0.21534, "epss_percentile": 0.9553}, "CVE-2015-0253": {"epss_score": 0.1061, "epss_percentile": 0.93046}, "CVE-2015-0254": {"epss_score": 0.03808, "epss_percentile": 0.87752}, "CVE-2015-0255": {"epss_score": 0.06906, "epss_percentile": 0.91109}, "CVE-2015-0257": {"epss_score": 0.00042, "epss_percentile": 0.12932}, "CVE-2015-0258": {"epss_score": 0.16497, "epss_percentile": 0.9468}, "CVE-2015-0259": {"epss_score": 0.00205, "epss_percentile": 0.42708}, "CVE-2015-0260": {"epss_score": 0.0026, "epss_percentile": 0.49182}, "CVE-2015-0261": {"epss_score": 0.01517, "epss_percentile": 0.80802}, "CVE-2015-0263": {"epss_score": 0.0362, "epss_percentile": 0.87442}, "CVE-2015-0264": {"epss_score": 0.02016, "epss_percentile": 0.83275}, "CVE-2015-0265": {"epss_score": 0.02013, "epss_percentile": 0.8326}, "CVE-2015-0266": {"epss_score": 0.00113, "epss_percentile": 0.30689}, "CVE-2015-0267": {"epss_score": 0.00049, "epss_percentile": 0.15467}, "CVE-2015-0268": {"epss_score": 0.00051, "epss_percentile": 0.16054}, "CVE-2015-0269": {"epss_score": 0.0046, "epss_percentile": 0.63532}, "CVE-2015-0270": {"epss_score": 0.00394, "epss_percentile": 0.59789}, "CVE-2015-0271": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2015-0272": {"epss_score": 0.01081, "epss_percentile": 0.77376}, "CVE-2015-0273": {"epss_score": 0.7115, "epss_percentile": 0.98656}, "CVE-2015-0274": {"epss_score": 0.00047, "epss_percentile": 0.14853}, "CVE-2015-0275": {"epss_score": 0.00094, "epss_percentile": 0.2697}, "CVE-2015-0276": {"epss_score": 0.00255, "epss_percentile": 0.4872}, "CVE-2015-0277": {"epss_score": 0.00532, "epss_percentile": 0.66711}, "CVE-2015-0278": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2015-0279": {"epss_score": 0.06506, "epss_percentile": 0.90806}, "CVE-2015-0282": {"epss_score": 0.00271, "epss_percentile": 0.50295}, "CVE-2015-0283": {"epss_score": 0.01799, "epss_percentile": 0.82314}, "CVE-2015-0284": {"epss_score": 0.00413, "epss_percentile": 0.60963}, "CVE-2015-0285": {"epss_score": 0.0536, "epss_percentile": 0.89783}, "CVE-2015-0286": {"epss_score": 0.23554, "epss_percentile": 0.95791}, "CVE-2015-0287": {"epss_score": 0.04942, "epss_percentile": 0.89311}, "CVE-2015-0288": {"epss_score": 0.06745, "epss_percentile": 0.90998}, "CVE-2015-0289": {"epss_score": 0.05787, "epss_percentile": 0.90208}, "CVE-2015-0290": {"epss_score": 0.17612, "epss_percentile": 0.94875}, "CVE-2015-0291": {"epss_score": 0.18068, "epss_percentile": 0.94951}, "CVE-2015-0292": {"epss_score": 0.07025, "epss_percentile": 0.91194}, "CVE-2015-0293": {"epss_score": 0.08158, "epss_percentile": 0.91907}, "CVE-2015-0294": {"epss_score": 0.00584, "epss_percentile": 0.68371}, "CVE-2015-0295": {"epss_score": 0.01512, "epss_percentile": 0.80786}, "CVE-2015-0296": {"epss_score": 0.00084, "epss_percentile": 0.24836}, "CVE-2015-0297": {"epss_score": 0.00554, "epss_percentile": 0.67445}, "CVE-2015-0298": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-0299": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2015-0301": {"epss_score": 0.074, "epss_percentile": 0.91453}, "CVE-2015-0302": {"epss_score": 0.0418, "epss_percentile": 0.88356}, "CVE-2015-0303": {"epss_score": 0.11306, "epss_percentile": 0.93301}, "CVE-2015-0304": {"epss_score": 0.09906, "epss_percentile": 0.92766}, "CVE-2015-0305": {"epss_score": 0.02846, "epss_percentile": 0.85821}, "CVE-2015-0306": {"epss_score": 0.11306, "epss_percentile": 0.93301}, "CVE-2015-0307": {"epss_score": 0.06461, "epss_percentile": 0.9077}, "CVE-2015-0308": {"epss_score": 0.08652, "epss_percentile": 0.92174}, "CVE-2015-0309": {"epss_score": 0.09715, "epss_percentile": 0.92674}, "CVE-2015-0310": {"epss_score": 0.05023, "epss_percentile": 0.89404}, "CVE-2015-0311": {"epss_score": 0.92735, "epss_percentile": 0.9974}, "CVE-2015-0312": {"epss_score": 0.04745, "epss_percentile": 0.89088}, "CVE-2015-0313": {"epss_score": 0.93271, "epss_percentile": 0.99791}, "CVE-2015-0314": {"epss_score": 0.1143, "epss_percentile": 0.9335}, "CVE-2015-0315": {"epss_score": 0.03904, "epss_percentile": 0.87924}, "CVE-2015-0316": {"epss_score": 0.1143, "epss_percentile": 0.9335}, "CVE-2015-0317": {"epss_score": 0.08751, "epss_percentile": 0.92241}, "CVE-2015-0318": {"epss_score": 0.89185, "epss_percentile": 0.99514}, "CVE-2015-0319": {"epss_score": 0.08751, "epss_percentile": 0.92241}, "CVE-2015-0320": {"epss_score": 0.03904, "epss_percentile": 0.87924}, "CVE-2015-0321": {"epss_score": 0.1143, "epss_percentile": 0.9335}, "CVE-2015-0322": {"epss_score": 0.06843, "epss_percentile": 0.91063}, "CVE-2015-0323": {"epss_score": 0.07941, "epss_percentile": 0.91779}, "CVE-2015-0324": {"epss_score": 0.07941, "epss_percentile": 0.91779}, "CVE-2015-0325": {"epss_score": 0.08682, "epss_percentile": 0.92198}, "CVE-2015-0326": {"epss_score": 0.08682, "epss_percentile": 0.92198}, "CVE-2015-0327": {"epss_score": 0.07941, "epss_percentile": 0.91779}, "CVE-2015-0328": {"epss_score": 0.06586, "epss_percentile": 0.90867}, "CVE-2015-0329": {"epss_score": 0.1143, "epss_percentile": 0.9335}, "CVE-2015-0330": {"epss_score": 0.10662, "epss_percentile": 0.93061}, "CVE-2015-0331": {"epss_score": 0.09406, "epss_percentile": 0.92534}, "CVE-2015-0332": {"epss_score": 0.08652, "epss_percentile": 0.92174}, "CVE-2015-0333": {"epss_score": 0.09331, "epss_percentile": 0.92503}, "CVE-2015-0334": {"epss_score": 0.05018, "epss_percentile": 0.89397}, "CVE-2015-0335": {"epss_score": 0.09331, "epss_percentile": 0.92503}, "CVE-2015-0336": {"epss_score": 0.89528, "epss_percentile": 0.99531}, "CVE-2015-0337": {"epss_score": 0.00681, "epss_percentile": 0.71059}, "CVE-2015-0338": {"epss_score": 0.04014, "epss_percentile": 0.88116}, "CVE-2015-0339": {"epss_score": 0.09331, "epss_percentile": 0.92503}, "CVE-2015-0340": {"epss_score": 0.01224, "epss_percentile": 0.78677}, "CVE-2015-0341": {"epss_score": 0.05186, "epss_percentile": 0.89588}, "CVE-2015-0342": {"epss_score": 0.05186, "epss_percentile": 0.89588}, "CVE-2015-0343": {"epss_score": 0.00653, "epss_percentile": 0.7032}, "CVE-2015-0344": {"epss_score": 0.00644, "epss_percentile": 0.70072}, "CVE-2015-0345": {"epss_score": 0.0316, "epss_percentile": 0.8653}, "CVE-2015-0346": {"epss_score": 0.06983, "epss_percentile": 0.91161}, "CVE-2015-0347": {"epss_score": 0.03683, "epss_percentile": 0.87565}, "CVE-2015-0348": {"epss_score": 0.05587, "epss_percentile": 0.90027}, "CVE-2015-0349": {"epss_score": 0.1102, "epss_percentile": 0.93191}, "CVE-2015-0350": {"epss_score": 0.03683, "epss_percentile": 0.87565}, "CVE-2015-0351": {"epss_score": 0.087, "epss_percentile": 0.92209}, "CVE-2015-0352": {"epss_score": 0.03683, "epss_percentile": 0.87565}, "CVE-2015-0353": {"epss_score": 0.03683, "epss_percentile": 0.87565}, "CVE-2015-0354": {"epss_score": 0.03683, "epss_percentile": 0.87565}, "CVE-2015-0355": {"epss_score": 0.03683, "epss_percentile": 0.87565}, "CVE-2015-0356": {"epss_score": 0.05352, "epss_percentile": 0.89775}, "CVE-2015-0357": {"epss_score": 0.00663, "epss_percentile": 0.70617}, "CVE-2015-0358": {"epss_score": 0.02324, "epss_percentile": 0.84379}, "CVE-2015-0359": {"epss_score": 0.88559, "epss_percentile": 0.99478}, "CVE-2015-0360": {"epss_score": 0.03683, "epss_percentile": 0.87565}, "CVE-2015-0361": {"epss_score": 0.01747, "epss_percentile": 0.82079}, "CVE-2015-0362": {"epss_score": 0.00362, "epss_percentile": 0.57786}, "CVE-2015-0363": {"epss_score": 0.00452, "epss_percentile": 0.63178}, "CVE-2015-0364": {"epss_score": 0.00423, "epss_percentile": 0.61592}, "CVE-2015-0365": {"epss_score": 0.00497, "epss_percentile": 0.65207}, "CVE-2015-0366": {"epss_score": 0.01267, "epss_percentile": 0.79021}, "CVE-2015-0367": {"epss_score": 0.00483, "epss_percentile": 0.64571}, "CVE-2015-0368": {"epss_score": 0.00719, "epss_percentile": 0.71945}, "CVE-2015-0369": {"epss_score": 0.00365, "epss_percentile": 0.58002}, "CVE-2015-0370": {"epss_score": 0.00273, "epss_percentile": 0.50477}, "CVE-2015-0371": {"epss_score": 0.0041, "epss_percentile": 0.60838}, "CVE-2015-0372": {"epss_score": 0.00497, "epss_percentile": 0.65207}, "CVE-2015-0373": {"epss_score": 0.00478, "epss_percentile": 0.64397}, "CVE-2015-0374": {"epss_score": 0.00239, "epss_percentile": 0.46917}, "CVE-2015-0375": {"epss_score": 0.01165, "epss_percentile": 0.78174}, "CVE-2015-0376": {"epss_score": 0.00324, "epss_percentile": 0.54931}, "CVE-2015-0377": {"epss_score": 0.00105, "epss_percentile": 0.29398}, "CVE-2015-0378": {"epss_score": 0.00124, "epss_percentile": 0.32435}, "CVE-2015-0379": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2015-0380": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2015-0381": {"epss_score": 0.05032, "epss_percentile": 0.89416}, "CVE-2015-0382": {"epss_score": 0.05032, "epss_percentile": 0.89416}, "CVE-2015-0383": {"epss_score": 0.00099, "epss_percentile": 0.28347}, "CVE-2015-0384": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2015-0385": {"epss_score": 0.00481, "epss_percentile": 0.64519}, "CVE-2015-0386": {"epss_score": 0.00608, "epss_percentile": 0.69076}, "CVE-2015-0387": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2015-0388": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2015-0389": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-0390": {"epss_score": 0.00815, "epss_percentile": 0.73788}, "CVE-2015-0391": {"epss_score": 0.00424, "epss_percentile": 0.61675}, "CVE-2015-0392": {"epss_score": 0.00478, "epss_percentile": 0.64397}, "CVE-2015-0393": {"epss_score": 0.01753, "epss_percentile": 0.8211}, "CVE-2015-0394": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2015-0395": {"epss_score": 0.21936, "epss_percentile": 0.95574}, "CVE-2015-0396": {"epss_score": 0.00819, "epss_percentile": 0.73867}, "CVE-2015-0397": {"epss_score": 0.00061, "epss_percentile": 0.19527}, "CVE-2015-0398": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2015-0399": {"epss_score": 0.00219, "epss_percentile": 0.44494}, "CVE-2015-0400": {"epss_score": 0.01685, "epss_percentile": 0.81747}, "CVE-2015-0401": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-0402": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2015-0403": {"epss_score": 0.00154, "epss_percentile": 0.36653}, "CVE-2015-0404": {"epss_score": 0.00397, "epss_percentile": 0.59939}, "CVE-2015-0405": {"epss_score": 0.00782, "epss_percentile": 0.73209}, "CVE-2015-0406": {"epss_score": 0.09193, "epss_percentile": 0.92441}, "CVE-2015-0407": {"epss_score": 0.02857, "epss_percentile": 0.85843}, "CVE-2015-0408": {"epss_score": 0.11052, "epss_percentile": 0.93202}, "CVE-2015-0409": {"epss_score": 0.0086, "epss_percentile": 0.74536}, "CVE-2015-0410": {"epss_score": 0.04964, "epss_percentile": 0.8934}, "CVE-2015-0411": {"epss_score": 0.08098, "epss_percentile": 0.91877}, "CVE-2015-0412": {"epss_score": 0.02083, "epss_percentile": 0.83541}, "CVE-2015-0413": {"epss_score": 0.00098, "epss_percentile": 0.277}, "CVE-2015-0414": {"epss_score": 0.00197, "epss_percentile": 0.41949}, "CVE-2015-0415": {"epss_score": 0.00431, "epss_percentile": 0.62059}, "CVE-2015-0416": {"epss_score": 0.00363, "epss_percentile": 0.5785}, "CVE-2015-0417": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2015-0418": {"epss_score": 0.00074, "epss_percentile": 0.22764}, "CVE-2015-0419": {"epss_score": 0.00478, "epss_percentile": 0.64399}, "CVE-2015-0420": {"epss_score": 0.00362, "epss_percentile": 0.57786}, "CVE-2015-0421": {"epss_score": 0.00118, "epss_percentile": 0.31505}, "CVE-2015-0422": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2015-0423": {"epss_score": 0.00934, "epss_percentile": 0.75656}, "CVE-2015-0424": {"epss_score": 0.00667, "epss_percentile": 0.70722}, "CVE-2015-0425": {"epss_score": 0.00409, "epss_percentile": 0.60696}, "CVE-2015-0426": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-0427": {"epss_score": 0.00095, "epss_percentile": 0.27197}, "CVE-2015-0428": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2015-0429": {"epss_score": 0.0006, "epss_percentile": 0.19179}, "CVE-2015-0430": {"epss_score": 0.00075, "epss_percentile": 0.23061}, "CVE-2015-0431": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2015-0432": {"epss_score": 0.00419, "epss_percentile": 0.61379}, "CVE-2015-0433": {"epss_score": 0.00465, "epss_percentile": 0.63769}, "CVE-2015-0434": {"epss_score": 0.00409, "epss_percentile": 0.60696}, "CVE-2015-0435": {"epss_score": 0.00235, "epss_percentile": 0.46201}, "CVE-2015-0436": {"epss_score": 0.00409, "epss_percentile": 0.60696}, "CVE-2015-0437": {"epss_score": 0.01228, "epss_percentile": 0.78709}, "CVE-2015-0438": {"epss_score": 0.00782, "epss_percentile": 0.73209}, "CVE-2015-0439": {"epss_score": 0.00934, "epss_percentile": 0.75656}, "CVE-2015-0440": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-0441": {"epss_score": 0.00384, "epss_percentile": 0.5917}, "CVE-2015-0443": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2015-0444": {"epss_score": 0.006, "epss_percentile": 0.68823}, "CVE-2015-0445": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2015-0446": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2015-0447": {"epss_score": 0.00374, "epss_percentile": 0.58564}, "CVE-2015-0448": {"epss_score": 0.0018, "epss_percentile": 0.399}, "CVE-2015-0449": {"epss_score": 0.00348, "epss_percentile": 0.56821}, "CVE-2015-0450": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2015-0451": {"epss_score": 0.00143, "epss_percentile": 0.35149}, "CVE-2015-0452": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-0453": {"epss_score": 0.00363, "epss_percentile": 0.57867}, "CVE-2015-0455": {"epss_score": 0.00346, "epss_percentile": 0.56631}, "CVE-2015-0456": {"epss_score": 0.00407, "epss_percentile": 0.60593}, "CVE-2015-0457": {"epss_score": 0.00499, "epss_percentile": 0.65283}, "CVE-2015-0458": {"epss_score": 0.0746, "epss_percentile": 0.91484}, "CVE-2015-0459": {"epss_score": 0.10041, "epss_percentile": 0.92825}, "CVE-2015-0460": {"epss_score": 0.05278, "epss_percentile": 0.89683}, "CVE-2015-0461": {"epss_score": 0.00273, "epss_percentile": 0.5043}, "CVE-2015-0462": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-0463": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-0464": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-0465": {"epss_score": 0.00272, "epss_percentile": 0.50382}, "CVE-2015-0466": {"epss_score": 0.00499, "epss_percentile": 0.65259}, "CVE-2015-0467": {"epss_score": 0.00442, "epss_percentile": 0.62729}, "CVE-2015-0468": {"epss_score": 0.00503, "epss_percentile": 0.65469}, "CVE-2015-0469": {"epss_score": 0.08615, "epss_percentile": 0.92153}, "CVE-2015-0470": {"epss_score": 0.01655, "epss_percentile": 0.81588}, "CVE-2015-0471": {"epss_score": 0.0014, "epss_percentile": 0.34711}, "CVE-2015-0472": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-0473": {"epss_score": 0.00442, "epss_percentile": 0.62729}, "CVE-2015-0474": {"epss_score": 0.00526, "epss_percentile": 0.6641}, "CVE-2015-0475": {"epss_score": 0.00312, "epss_percentile": 0.54001}, "CVE-2015-0476": {"epss_score": 0.00233, "epss_percentile": 0.46037}, "CVE-2015-0477": {"epss_score": 0.03763, "epss_percentile": 0.87691}, "CVE-2015-0478": {"epss_score": 0.04125, "epss_percentile": 0.88288}, "CVE-2015-0479": {"epss_score": 0.0051, "epss_percentile": 0.65802}, "CVE-2015-0480": {"epss_score": 0.07494, "epss_percentile": 0.91501}, "CVE-2015-0482": {"epss_score": 0.00402, "epss_percentile": 0.60308}, "CVE-2015-0483": {"epss_score": 0.002, "epss_percentile": 0.42247}, "CVE-2015-0484": {"epss_score": 0.01252, "epss_percentile": 0.78906}, "CVE-2015-0485": {"epss_score": 0.00272, "epss_percentile": 0.50382}, "CVE-2015-0486": {"epss_score": 0.00343, "epss_percentile": 0.5645}, "CVE-2015-0487": {"epss_score": 0.00214, "epss_percentile": 0.43968}, "CVE-2015-0488": {"epss_score": 0.06547, "epss_percentile": 0.9084}, "CVE-2015-0489": {"epss_score": 0.00148, "epss_percentile": 0.35824}, "CVE-2015-0490": {"epss_score": 0.00233, "epss_percentile": 0.46037}, "CVE-2015-0491": {"epss_score": 0.07853, "epss_percentile": 0.9172}, "CVE-2015-0492": {"epss_score": 0.02032, "epss_percentile": 0.83335}, "CVE-2015-0493": {"epss_score": 0.00738, "epss_percentile": 0.72337}, "CVE-2015-0494": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-0495": {"epss_score": 0.00685, "epss_percentile": 0.71137}, "CVE-2015-0496": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-0497": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-0498": {"epss_score": 0.00464, "epss_percentile": 0.63705}, "CVE-2015-0499": {"epss_score": 0.00435, "epss_percentile": 0.62369}, "CVE-2015-0500": {"epss_score": 0.00951, "epss_percentile": 0.75863}, "CVE-2015-0501": {"epss_score": 0.00592, "epss_percentile": 0.68609}, "CVE-2015-0502": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-0503": {"epss_score": 0.00466, "epss_percentile": 0.63803}, "CVE-2015-0504": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-0505": {"epss_score": 0.0038, "epss_percentile": 0.58943}, "CVE-2015-0506": {"epss_score": 0.00327, "epss_percentile": 0.55107}, "CVE-2015-0507": {"epss_score": 0.00737, "epss_percentile": 0.72324}, "CVE-2015-0508": {"epss_score": 0.00466, "epss_percentile": 0.63803}, "CVE-2015-0509": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-0510": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-0511": {"epss_score": 0.00384, "epss_percentile": 0.59156}, "CVE-2015-0512": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2015-0513": {"epss_score": 0.0018, "epss_percentile": 0.3989}, "CVE-2015-0514": {"epss_score": 0.18285, "epss_percentile": 0.94989}, "CVE-2015-0515": {"epss_score": 0.00929, "epss_percentile": 0.75593}, "CVE-2015-0516": {"epss_score": 0.21436, "epss_percentile": 0.95517}, "CVE-2015-0517": {"epss_score": 0.00216, "epss_percentile": 0.4414}, "CVE-2015-0518": {"epss_score": 0.01159, "epss_percentile": 0.78123}, "CVE-2015-0519": {"epss_score": 0.00068, "epss_percentile": 0.21289}, "CVE-2015-0521": {"epss_score": 0.00096, "epss_percentile": 0.27384}, "CVE-2015-0522": {"epss_score": 0.00137, "epss_percentile": 0.34239}, "CVE-2015-0523": {"epss_score": 0.01324, "epss_percentile": 0.79465}, "CVE-2015-0524": {"epss_score": 0.00432, "epss_percentile": 0.62099}, "CVE-2015-0525": {"epss_score": 0.01832, "epss_percentile": 0.82455}, "CVE-2015-0526": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2015-0527": {"epss_score": 0.00133, "epss_percentile": 0.33709}, "CVE-2015-0528": {"epss_score": 0.00069, "epss_percentile": 0.21563}, "CVE-2015-0529": {"epss_score": 0.00601, "epss_percentile": 0.68849}, "CVE-2015-0530": {"epss_score": 0.00055, "epss_percentile": 0.17623}, "CVE-2015-0531": {"epss_score": 0.0026, "epss_percentile": 0.49187}, "CVE-2015-0532": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2015-0533": {"epss_score": 0.00309, "epss_percentile": 0.53687}, "CVE-2015-0534": {"epss_score": 0.00947, "epss_percentile": 0.75817}, "CVE-2015-0535": {"epss_score": 0.00443, "epss_percentile": 0.62761}, "CVE-2015-0536": {"epss_score": 0.01029, "epss_percentile": 0.7683}, "CVE-2015-0537": {"epss_score": 0.02278, "epss_percentile": 0.84235}, "CVE-2015-0538": {"epss_score": 0.05856, "epss_percentile": 0.90267}, "CVE-2015-0540": {"epss_score": 0.00267, "epss_percentile": 0.49983}, "CVE-2015-0541": {"epss_score": 0.00134, "epss_percentile": 0.33865}, "CVE-2015-0542": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-0543": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2015-0544": {"epss_score": 0.00827, "epss_percentile": 0.73977}, "CVE-2015-0545": {"epss_score": 0.06241, "epss_percentile": 0.90593}, "CVE-2015-0546": {"epss_score": 0.03406, "epss_percentile": 0.87077}, "CVE-2015-0547": {"epss_score": 0.00156, "epss_percentile": 0.36988}, "CVE-2015-0548": {"epss_score": 0.00156, "epss_percentile": 0.36988}, "CVE-2015-0549": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2015-0550": {"epss_score": 0.04043, "epss_percentile": 0.88169}, "CVE-2015-0551": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2015-0552": {"epss_score": 0.00737, "epss_percentile": 0.72322}, "CVE-2015-0553": {"epss_score": 0.00572, "epss_percentile": 0.68}, "CVE-2015-0554": {"epss_score": 0.38604, "epss_percentile": 0.97109}, "CVE-2015-0555": {"epss_score": 0.24857, "epss_percentile": 0.95959}, "CVE-2015-0556": {"epss_score": 0.02093, "epss_percentile": 0.83576}, "CVE-2015-0557": {"epss_score": 0.02096, "epss_percentile": 0.83585}, "CVE-2015-0558": {"epss_score": 0.00108, "epss_percentile": 0.29813}, "CVE-2015-0559": {"epss_score": 0.00215, "epss_percentile": 0.44034}, "CVE-2015-0560": {"epss_score": 0.00215, "epss_percentile": 0.44034}, "CVE-2015-0561": {"epss_score": 0.00259, "epss_percentile": 0.49069}, "CVE-2015-0562": {"epss_score": 0.01214, "epss_percentile": 0.78571}, "CVE-2015-0563": {"epss_score": 0.01046, "epss_percentile": 0.77025}, "CVE-2015-0564": {"epss_score": 0.00619, "epss_percentile": 0.69427}, "CVE-2015-0565": {"epss_score": 0.23019, "epss_percentile": 0.9572}, "CVE-2015-0568": {"epss_score": 0.00342, "epss_percentile": 0.56375}, "CVE-2015-0569": {"epss_score": 0.00446, "epss_percentile": 0.62912}, "CVE-2015-0570": {"epss_score": 0.00061, "epss_percentile": 0.19397}, "CVE-2015-0571": {"epss_score": 0.001, "epss_percentile": 0.28521}, "CVE-2015-0572": {"epss_score": 0.00061, "epss_percentile": 0.19534}, "CVE-2015-0573": {"epss_score": 0.00303, "epss_percentile": 0.53231}, "CVE-2015-0574": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2015-0575": {"epss_score": 0.00082, "epss_percentile": 0.24553}, "CVE-2015-0576": {"epss_score": 0.00142, "epss_percentile": 0.3504}, "CVE-2015-0577": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2015-0578": {"epss_score": 0.00596, "epss_percentile": 0.6871}, "CVE-2015-0579": {"epss_score": 0.00853, "epss_percentile": 0.74424}, "CVE-2015-0580": {"epss_score": 0.00105, "epss_percentile": 0.29284}, "CVE-2015-0581": {"epss_score": 0.0048, "epss_percentile": 0.64474}, "CVE-2015-0582": {"epss_score": 0.0105, "epss_percentile": 0.77066}, "CVE-2015-0583": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2015-0584": {"epss_score": 0.00084, "epss_percentile": 0.25}, "CVE-2015-0586": {"epss_score": 0.01092, "epss_percentile": 0.77468}, "CVE-2015-0588": {"epss_score": 0.00172, "epss_percentile": 0.39006}, "CVE-2015-0589": {"epss_score": 0.00737, "epss_percentile": 0.72319}, "CVE-2015-0590": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2015-0591": {"epss_score": 0.00853, "epss_percentile": 0.74424}, "CVE-2015-0592": {"epss_score": 0.00773, "epss_percentile": 0.73061}, "CVE-2015-0593": {"epss_score": 0.00724, "epss_percentile": 0.7203}, "CVE-2015-0594": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-0595": {"epss_score": 0.00607, "epss_percentile": 0.69045}, "CVE-2015-0596": {"epss_score": 0.00322, "epss_percentile": 0.54757}, "CVE-2015-0597": {"epss_score": 0.00334, "epss_percentile": 0.55699}, "CVE-2015-0598": {"epss_score": 0.00363, "epss_percentile": 0.57874}, "CVE-2015-0599": {"epss_score": 0.00422, "epss_percentile": 0.61548}, "CVE-2015-0600": {"epss_score": 0.00928, "epss_percentile": 0.75586}, "CVE-2015-0601": {"epss_score": 0.00258, "epss_percentile": 0.48966}, "CVE-2015-0602": {"epss_score": 0.00346, "epss_percentile": 0.56638}, "CVE-2015-0603": {"epss_score": 0.00063, "epss_percentile": 0.20094}, "CVE-2015-0604": {"epss_score": 0.00175, "epss_percentile": 0.39278}, "CVE-2015-0605": {"epss_score": 0.00583, "epss_percentile": 0.68329}, "CVE-2015-0606": {"epss_score": 0.00088, "epss_percentile": 0.25746}, "CVE-2015-0607": {"epss_score": 0.00264, "epss_percentile": 0.49723}, "CVE-2015-0608": {"epss_score": 0.00616, "epss_percentile": 0.69339}, "CVE-2015-0609": {"epss_score": 0.00616, "epss_percentile": 0.69339}, "CVE-2015-0610": {"epss_score": 0.00247, "epss_percentile": 0.47884}, "CVE-2015-0611": {"epss_score": 0.00612, "epss_percentile": 0.69238}, "CVE-2015-0612": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2015-0613": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2015-0614": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2015-0615": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2015-0616": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2015-0617": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2015-0618": {"epss_score": 0.00563, "epss_percentile": 0.67723}, "CVE-2015-0619": {"epss_score": 0.00568, "epss_percentile": 0.67891}, "CVE-2015-0620": {"epss_score": 0.00513, "epss_percentile": 0.65938}, "CVE-2015-0621": {"epss_score": 0.0085, "epss_percentile": 0.74383}, "CVE-2015-0622": {"epss_score": 0.00203, "epss_percentile": 0.42579}, "CVE-2015-0623": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-0624": {"epss_score": 0.00149, "epss_percentile": 0.35984}, "CVE-2015-0626": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2015-0628": {"epss_score": 0.00184, "epss_percentile": 0.40384}, "CVE-2015-0631": {"epss_score": 0.00436, "epss_percentile": 0.62465}, "CVE-2015-0632": {"epss_score": 0.00178, "epss_percentile": 0.39675}, "CVE-2015-0633": {"epss_score": 0.00266, "epss_percentile": 0.49888}, "CVE-2015-0634": {"epss_score": 0.00416, "epss_percentile": 0.61181}, "CVE-2015-0635": {"epss_score": 0.00134, "epss_percentile": 0.33747}, "CVE-2015-0636": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2015-0637": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2015-0638": {"epss_score": 0.01028, "epss_percentile": 0.76813}, "CVE-2015-0639": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2015-0640": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2015-0641": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2015-0642": {"epss_score": 0.01796, "epss_percentile": 0.82306}, "CVE-2015-0643": {"epss_score": 0.01796, "epss_percentile": 0.82306}, "CVE-2015-0644": {"epss_score": 0.02863, "epss_percentile": 0.85855}, "CVE-2015-0645": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2015-0646": {"epss_score": 0.01551, "epss_percentile": 0.80988}, "CVE-2015-0647": {"epss_score": 0.00811, "epss_percentile": 0.73724}, "CVE-2015-0648": {"epss_score": 0.0071, "epss_percentile": 0.71723}, "CVE-2015-0649": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2015-0650": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2015-0651": {"epss_score": 0.00134, "epss_percentile": 0.33756}, "CVE-2015-0652": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-0653": {"epss_score": 0.07805, "epss_percentile": 0.91691}, "CVE-2015-0654": {"epss_score": 0.00309, "epss_percentile": 0.53678}, "CVE-2015-0655": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-0656": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-0657": {"epss_score": 0.00766, "epss_percentile": 0.72947}, "CVE-2015-0658": {"epss_score": 0.00487, "epss_percentile": 0.648}, "CVE-2015-0659": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2015-0660": {"epss_score": 0.00053, "epss_percentile": 0.16721}, "CVE-2015-0661": {"epss_score": 0.00481, "epss_percentile": 0.64506}, "CVE-2015-0662": {"epss_score": 0.00084, "epss_percentile": 0.25}, "CVE-2015-0663": {"epss_score": 0.00084, "epss_percentile": 0.25}, "CVE-2015-0664": {"epss_score": 0.00073, "epss_percentile": 0.22668}, "CVE-2015-0665": {"epss_score": 0.00075, "epss_percentile": 0.2307}, "CVE-2015-0666": {"epss_score": 0.41425, "epss_percentile": 0.97273}, "CVE-2015-0667": {"epss_score": 0.00365, "epss_percentile": 0.57998}, "CVE-2015-0668": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-0669": {"epss_score": 0.00787, "epss_percentile": 0.73307}, "CVE-2015-0670": {"epss_score": 0.00532, "epss_percentile": 0.66675}, "CVE-2015-0671": {"epss_score": 0.00438, "epss_percentile": 0.62545}, "CVE-2015-0672": {"epss_score": 0.00681, "epss_percentile": 0.71047}, "CVE-2015-0673": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2015-0674": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2015-0675": {"epss_score": 0.00214, "epss_percentile": 0.43984}, "CVE-2015-0676": {"epss_score": 0.00349, "epss_percentile": 0.56879}, "CVE-2015-0677": {"epss_score": 0.01051, "epss_percentile": 0.77085}, "CVE-2015-0678": {"epss_score": 0.00251, "epss_percentile": 0.483}, "CVE-2015-0679": {"epss_score": 0.00362, "epss_percentile": 0.57752}, "CVE-2015-0680": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2015-0681": {"epss_score": 0.00563, "epss_percentile": 0.67723}, "CVE-2015-0682": {"epss_score": 0.01218, "epss_percentile": 0.78606}, "CVE-2015-0683": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2015-0684": {"epss_score": 0.00311, "epss_percentile": 0.5386}, "CVE-2015-0685": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-0686": {"epss_score": 0.00768, "epss_percentile": 0.72962}, "CVE-2015-0687": {"epss_score": 0.0034, "epss_percentile": 0.56224}, "CVE-2015-0688": {"epss_score": 0.00399, "epss_percentile": 0.60128}, "CVE-2015-0689": {"epss_score": 0.00369, "epss_percentile": 0.58248}, "CVE-2015-0690": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-0691": {"epss_score": 0.00709, "epss_percentile": 0.71688}, "CVE-2015-0692": {"epss_score": 0.00093, "epss_percentile": 0.26693}, "CVE-2015-0693": {"epss_score": 0.00093, "epss_percentile": 0.26693}, "CVE-2015-0694": {"epss_score": 0.00365, "epss_percentile": 0.57998}, "CVE-2015-0695": {"epss_score": 0.00851, "epss_percentile": 0.74398}, "CVE-2015-0696": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0697": {"epss_score": 0.00206, "epss_percentile": 0.42949}, "CVE-2015-0698": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0699": {"epss_score": 0.00235, "epss_percentile": 0.46221}, "CVE-2015-0700": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-0701": {"epss_score": 0.01071, "epss_percentile": 0.77261}, "CVE-2015-0702": {"epss_score": 0.01267, "epss_percentile": 0.79015}, "CVE-2015-0703": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0704": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-0705": {"epss_score": 0.0041, "epss_percentile": 0.60788}, "CVE-2015-0706": {"epss_score": 0.00062, "epss_percentile": 0.19596}, "CVE-2015-0707": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2015-0708": {"epss_score": 0.00182, "epss_percentile": 0.40206}, "CVE-2015-0709": {"epss_score": 0.00363, "epss_percentile": 0.57874}, "CVE-2015-0710": {"epss_score": 0.00182, "epss_percentile": 0.40206}, "CVE-2015-0711": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2015-0712": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2015-0713": {"epss_score": 0.0049, "epss_percentile": 0.6493}, "CVE-2015-0714": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-0715": {"epss_score": 0.00287, "epss_percentile": 0.51788}, "CVE-2015-0716": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2015-0717": {"epss_score": 0.00093, "epss_percentile": 0.26693}, "CVE-2015-0718": {"epss_score": 0.05955, "epss_percentile": 0.9036}, "CVE-2015-0721": {"epss_score": 0.00144, "epss_percentile": 0.35341}, "CVE-2015-0722": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-0723": {"epss_score": 0.00462, "epss_percentile": 0.63589}, "CVE-2015-0724": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0725": {"epss_score": 0.00153, "epss_percentile": 0.36632}, "CVE-2015-0726": {"epss_score": 0.00643, "epss_percentile": 0.70064}, "CVE-2015-0727": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0728": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0729": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0730": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-0731": {"epss_score": 0.00262, "epss_percentile": 0.49399}, "CVE-2015-0732": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-0733": {"epss_score": 0.00274, "epss_percentile": 0.5056}, "CVE-2015-0734": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0735": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-0736": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-0737": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0738": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0739": {"epss_score": 0.00283, "epss_percentile": 0.51383}, "CVE-2015-0740": {"epss_score": 0.00119, "epss_percentile": 0.31664}, "CVE-2015-0741": {"epss_score": 0.00119, "epss_percentile": 0.31664}, "CVE-2015-0742": {"epss_score": 0.01253, "epss_percentile": 0.78916}, "CVE-2015-0743": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-0744": {"epss_score": 0.00851, "epss_percentile": 0.74398}, "CVE-2015-0745": {"epss_score": 0.00241, "epss_percentile": 0.47247}, "CVE-2015-0746": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2015-0747": {"epss_score": 0.0022, "epss_percentile": 0.44557}, "CVE-2015-0749": {"epss_score": 0.00234, "epss_percentile": 0.46198}, "CVE-2015-0750": {"epss_score": 0.00526, "epss_percentile": 0.66429}, "CVE-2015-0751": {"epss_score": 0.00242, "epss_percentile": 0.47336}, "CVE-2015-0752": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0753": {"epss_score": 0.00269, "epss_percentile": 0.50103}, "CVE-2015-0754": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2015-0755": {"epss_score": 0.00055, "epss_percentile": 0.1758}, "CVE-2015-0756": {"epss_score": 0.00361, "epss_percentile": 0.57697}, "CVE-2015-0757": {"epss_score": 0.00261, "epss_percentile": 0.49306}, "CVE-2015-0758": {"epss_score": 0.00246, "epss_percentile": 0.47752}, "CVE-2015-0759": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-0760": {"epss_score": 0.00299, "epss_percentile": 0.52874}, "CVE-2015-0761": {"epss_score": 0.00122, "epss_percentile": 0.3206}, "CVE-2015-0762": {"epss_score": 0.00232, "epss_percentile": 0.45931}, "CVE-2015-0763": {"epss_score": 0.00241, "epss_percentile": 0.47247}, "CVE-2015-0764": {"epss_score": 0.00241, "epss_percentile": 0.47247}, "CVE-2015-0765": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-0766": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0767": {"epss_score": 0.00084, "epss_percentile": 0.25}, "CVE-2015-0768": {"epss_score": 0.00154, "epss_percentile": 0.36714}, "CVE-2015-0769": {"epss_score": 0.00411, "epss_percentile": 0.60856}, "CVE-2015-0770": {"epss_score": 0.00274, "epss_percentile": 0.5056}, "CVE-2015-0771": {"epss_score": 0.00327, "epss_percentile": 0.55109}, "CVE-2015-0772": {"epss_score": 0.00384, "epss_percentile": 0.59163}, "CVE-2015-0773": {"epss_score": 0.00376, "epss_percentile": 0.58686}, "CVE-2015-0774": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-0775": {"epss_score": 0.01246, "epss_percentile": 0.78848}, "CVE-2015-0776": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-0777": {"epss_score": 0.0013, "epss_percentile": 0.33264}, "CVE-2015-0778": {"epss_score": 0.00895, "epss_percentile": 0.7511}, "CVE-2015-0779": {"epss_score": 0.80149, "epss_percentile": 0.99072}, "CVE-2015-0780": {"epss_score": 0.03558, "epss_percentile": 0.8735}, "CVE-2015-0781": {"epss_score": 0.0557, "epss_percentile": 0.90005}, "CVE-2015-0782": {"epss_score": 0.03537, "epss_percentile": 0.87313}, "CVE-2015-0783": {"epss_score": 0.01259, "epss_percentile": 0.78962}, "CVE-2015-0784": {"epss_score": 0.03928, "epss_percentile": 0.87968}, "CVE-2015-0785": {"epss_score": 0.02179, "epss_percentile": 0.83893}, "CVE-2015-0786": {"epss_score": 0.25327, "epss_percentile": 0.96014}, "CVE-2015-0787": {"epss_score": 0.00233, "epss_percentile": 0.46044}, "CVE-2015-0794": {"epss_score": 0.00047, "epss_percentile": 0.14663}, "CVE-2015-0795": {"epss_score": 0.03417, "epss_percentile": 0.87093}, "CVE-2015-0796": {"epss_score": 0.00156, "epss_percentile": 0.37004}, "CVE-2015-0797": {"epss_score": 0.07609, "epss_percentile": 0.91566}, "CVE-2015-0798": {"epss_score": 0.01465, "epss_percentile": 0.80456}, "CVE-2015-0799": {"epss_score": 0.00108, "epss_percentile": 0.29876}, "CVE-2015-0800": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2015-0801": {"epss_score": 0.01191, "epss_percentile": 0.78397}, "CVE-2015-0802": {"epss_score": 0.80386, "epss_percentile": 0.99085}, "CVE-2015-0803": {"epss_score": 0.01674, "epss_percentile": 0.81697}, "CVE-2015-0804": {"epss_score": 0.01674, "epss_percentile": 0.81697}, "CVE-2015-0805": {"epss_score": 0.01674, "epss_percentile": 0.81697}, "CVE-2015-0806": {"epss_score": 0.01674, "epss_percentile": 0.81697}, "CVE-2015-0807": {"epss_score": 0.00137, "epss_percentile": 0.34307}, "CVE-2015-0808": {"epss_score": 0.00705, "epss_percentile": 0.71579}, "CVE-2015-0810": {"epss_score": 0.00396, "epss_percentile": 0.59923}, "CVE-2015-0811": {"epss_score": 0.00765, "epss_percentile": 0.72915}, "CVE-2015-0812": {"epss_score": 0.00148, "epss_percentile": 0.35861}, "CVE-2015-0813": {"epss_score": 0.02842, "epss_percentile": 0.8581}, "CVE-2015-0814": {"epss_score": 0.01881, "epss_percentile": 0.82692}, "CVE-2015-0815": {"epss_score": 0.01254, "epss_percentile": 0.78922}, "CVE-2015-0816": {"epss_score": 0.8537, "epss_percentile": 0.99331}, "CVE-2015-0817": {"epss_score": 0.01349, "epss_percentile": 0.7967}, "CVE-2015-0818": {"epss_score": 0.01726, "epss_percentile": 0.81965}, "CVE-2015-0819": {"epss_score": 0.00913, "epss_percentile": 0.75369}, "CVE-2015-0820": {"epss_score": 0.0034, "epss_percentile": 0.56234}, "CVE-2015-0821": {"epss_score": 0.01339, "epss_percentile": 0.79573}, "CVE-2015-0822": {"epss_score": 0.00637, "epss_percentile": 0.69886}, "CVE-2015-0823": {"epss_score": 0.01709, "epss_percentile": 0.8187}, "CVE-2015-0824": {"epss_score": 0.01589, "epss_percentile": 0.81193}, "CVE-2015-0825": {"epss_score": 0.00664, "epss_percentile": 0.70644}, "CVE-2015-0826": {"epss_score": 0.00697, "epss_percentile": 0.71413}, "CVE-2015-0827": {"epss_score": 0.00997, "epss_percentile": 0.76455}, "CVE-2015-0828": {"epss_score": 0.01358, "epss_percentile": 0.79731}, "CVE-2015-0829": {"epss_score": 0.02182, "epss_percentile": 0.83909}, "CVE-2015-0830": {"epss_score": 0.00942, "epss_percentile": 0.75762}, "CVE-2015-0831": {"epss_score": 0.02019, "epss_percentile": 0.8329}, "CVE-2015-0832": {"epss_score": 0.00118, "epss_percentile": 0.31441}, "CVE-2015-0833": {"epss_score": 0.00052, "epss_percentile": 0.16362}, "CVE-2015-0834": {"epss_score": 0.00514, "epss_percentile": 0.65961}, "CVE-2015-0835": {"epss_score": 0.01508, "epss_percentile": 0.8076}, "CVE-2015-0836": {"epss_score": 0.01493, "epss_percentile": 0.8064}, "CVE-2015-0837": {"epss_score": 0.00551, "epss_percentile": 0.67356}, "CVE-2015-0838": {"epss_score": 0.02814, "epss_percentile": 0.85728}, "CVE-2015-0839": {"epss_score": 0.00496, "epss_percentile": 0.65176}, "CVE-2015-0840": {"epss_score": 0.00647, "epss_percentile": 0.70198}, "CVE-2015-0841": {"epss_score": 0.01371, "epss_percentile": 0.79805}, "CVE-2015-0842": {"epss_score": 0.00051, "epss_percentile": 0.16213}, "CVE-2015-0843": {"epss_score": 0.00102, "epss_percentile": 0.28817}, "CVE-2015-0844": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2015-0845": {"epss_score": 0.02095, "epss_percentile": 0.83581}, "CVE-2015-0846": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2015-0847": {"epss_score": 0.02554, "epss_percentile": 0.85087}, "CVE-2015-0848": {"epss_score": 0.04681, "epss_percentile": 0.89}, "CVE-2015-0849": {"epss_score": 0.00039, "epss_percentile": 0.11431}, "CVE-2015-0850": {"epss_score": 0.0668, "epss_percentile": 0.90939}, "CVE-2015-0851": {"epss_score": 0.00624, "epss_percentile": 0.69568}, "CVE-2015-0852": {"epss_score": 0.02172, "epss_percentile": 0.83874}, "CVE-2015-0853": {"epss_score": 0.01667, "epss_percentile": 0.81657}, "CVE-2015-0854": {"epss_score": 0.00469, "epss_percentile": 0.63947}, "CVE-2015-0855": {"epss_score": 0.00805, "epss_percentile": 0.73629}, "CVE-2015-0856": {"epss_score": 0.00167, "epss_percentile": 0.38381}, "CVE-2015-0857": {"epss_score": 0.03116, "epss_percentile": 0.86435}, "CVE-2015-0858": {"epss_score": 0.0004, "epss_percentile": 0.12196}, "CVE-2015-0859": {"epss_score": 0.01323, "epss_percentile": 0.79454}, "CVE-2015-0860": {"epss_score": 0.04909, "epss_percentile": 0.89279}, "CVE-2015-0861": {"epss_score": 0.00251, "epss_percentile": 0.4828}, "CVE-2015-0862": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2015-0863": {"epss_score": 0.00104, "epss_percentile": 0.29177}, "CVE-2015-0864": {"epss_score": 0.00333, "epss_percentile": 0.55646}, "CVE-2015-0866": {"epss_score": 0.00437, "epss_percentile": 0.62496}, "CVE-2015-0867": {"epss_score": 0.00242, "epss_percentile": 0.47356}, "CVE-2015-0868": {"epss_score": 0.01696, "epss_percentile": 0.81811}, "CVE-2015-0869": {"epss_score": 0.004, "epss_percentile": 0.60186}, "CVE-2015-0870": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2015-0871": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2015-0873": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-0874": {"epss_score": 0.00497, "epss_percentile": 0.65194}, "CVE-2015-0875": {"epss_score": 0.0009, "epss_percentile": 0.26034}, "CVE-2015-0876": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-0877": {"epss_score": 0.01588, "epss_percentile": 0.8119}, "CVE-2015-0878": {"epss_score": 0.00464, "epss_percentile": 0.63725}, "CVE-2015-0879": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2015-0880": {"epss_score": 0.02977, "epss_percentile": 0.86108}, "CVE-2015-0881": {"epss_score": 0.04383, "epss_percentile": 0.88628}, "CVE-2015-0882": {"epss_score": 0.00443, "epss_percentile": 0.6279}, "CVE-2015-0883": {"epss_score": 0.01581, "epss_percentile": 0.81137}, "CVE-2015-0884": {"epss_score": 0.0045, "epss_percentile": 0.63073}, "CVE-2015-0885": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2015-0886": {"epss_score": 0.02553, "epss_percentile": 0.85085}, "CVE-2015-0887": {"epss_score": 0.00512, "epss_percentile": 0.65857}, "CVE-2015-0888": {"epss_score": 0.00663, "epss_percentile": 0.70617}, "CVE-2015-0889": {"epss_score": 0.02096, "epss_percentile": 0.83587}, "CVE-2015-0890": {"epss_score": 0.00795, "epss_percentile": 0.7346}, "CVE-2015-0891": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-0892": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-0893": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-0894": {"epss_score": 0.00674, "epss_percentile": 0.70872}, "CVE-2015-0895": {"epss_score": 0.00136, "epss_percentile": 0.34156}, "CVE-2015-0896": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-0897": {"epss_score": 0.00115, "epss_percentile": 0.30946}, "CVE-2015-0898": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2015-0899": {"epss_score": 0.75256, "epss_percentile": 0.98835}, "CVE-2015-0900": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2015-0901": {"epss_score": 0.00437, "epss_percentile": 0.62528}, "CVE-2015-0902": {"epss_score": 0.00784, "epss_percentile": 0.73244}, "CVE-2015-0903": {"epss_score": 0.03174, "epss_percentile": 0.86561}, "CVE-2015-0904": {"epss_score": 0.00333, "epss_percentile": 0.55639}, "CVE-2015-0905": {"epss_score": 0.00173, "epss_percentile": 0.39123}, "CVE-2015-0906": {"epss_score": 0.00483, "epss_percentile": 0.64621}, "CVE-2015-0907": {"epss_score": 0.03343, "epss_percentile": 0.86946}, "CVE-2015-0910": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-0911": {"epss_score": 0.00242, "epss_percentile": 0.47356}, "CVE-2015-0912": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2015-0913": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-0914": {"epss_score": 0.00218, "epss_percentile": 0.44397}, "CVE-2015-0915": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-0916": {"epss_score": 0.00351, "epss_percentile": 0.57053}, "CVE-2015-0917": {"epss_score": 0.004, "epss_percentile": 0.60191}, "CVE-2015-0918": {"epss_score": 0.00456, "epss_percentile": 0.63326}, "CVE-2015-0919": {"epss_score": 0.01, "epss_percentile": 0.7649}, "CVE-2015-0920": {"epss_score": 0.00104, "epss_percentile": 0.29153}, "CVE-2015-0921": {"epss_score": 0.58217, "epss_percentile": 0.98102}, "CVE-2015-0922": {"epss_score": 0.45748, "epss_percentile": 0.975}, "CVE-2015-0923": {"epss_score": 0.77782, "epss_percentile": 0.98954}, "CVE-2015-0924": {"epss_score": 0.00869, "epss_percentile": 0.74683}, "CVE-2015-0925": {"epss_score": 0.68289, "epss_percentile": 0.9854}, "CVE-2015-0926": {"epss_score": 0.00059, "epss_percentile": 0.18731}, "CVE-2015-0928": {"epss_score": 0.00832, "epss_percentile": 0.74056}, "CVE-2015-0929": {"epss_score": 0.01019, "epss_percentile": 0.76722}, "CVE-2015-0930": {"epss_score": 0.00467, "epss_percentile": 0.63813}, "CVE-2015-0931": {"epss_score": 0.03615, "epss_percentile": 0.87435}, "CVE-2015-0932": {"epss_score": 0.02081, "epss_percentile": 0.83531}, "CVE-2015-0933": {"epss_score": 0.00335, "epss_percentile": 0.55846}, "CVE-2015-0934": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2015-0935": {"epss_score": 0.51574, "epss_percentile": 0.97787}, "CVE-2015-0936": {"epss_score": 0.86318, "epss_percentile": 0.99377}, "CVE-2015-0937": {"epss_score": 0.00909, "epss_percentile": 0.75291}, "CVE-2015-0938": {"epss_score": 0.0022, "epss_percentile": 0.446}, "CVE-2015-0941": {"epss_score": 0.01602, "epss_percentile": 0.81272}, "CVE-2015-0943": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2015-0949": {"epss_score": 0.00077, "epss_percentile": 0.2339}, "CVE-2015-0950": {"epss_score": 0.00688, "epss_percentile": 0.71199}, "CVE-2015-0951": {"epss_score": 0.00403, "epss_percentile": 0.60374}, "CVE-2015-0961": {"epss_score": 0.00543, "epss_percentile": 0.67089}, "CVE-2015-0962": {"epss_score": 0.00618, "epss_percentile": 0.69373}, "CVE-2015-0967": {"epss_score": 0.01067, "epss_percentile": 0.77232}, "CVE-2015-0968": {"epss_score": 0.01918, "epss_percentile": 0.82875}, "CVE-2015-0969": {"epss_score": 0.01209, "epss_percentile": 0.78544}, "CVE-2015-0970": {"epss_score": 0.00217, "epss_percentile": 0.44333}, "CVE-2015-0971": {"epss_score": 0.00392, "epss_percentile": 0.59653}, "CVE-2015-0972": {"epss_score": 0.00489, "epss_percentile": 0.64883}, "CVE-2015-0973": {"epss_score": 0.02006, "epss_percentile": 0.83234}, "CVE-2015-0974": {"epss_score": 0.00054, "epss_percentile": 0.17259}, "CVE-2015-0976": {"epss_score": 0.00535, "epss_percentile": 0.66804}, "CVE-2015-0977": {"epss_score": 0.00784, "epss_percentile": 0.73244}, "CVE-2015-0978": {"epss_score": 0.0009, "epss_percentile": 0.2606}, "CVE-2015-0979": {"epss_score": 0.01912, "epss_percentile": 0.82832}, "CVE-2015-0980": {"epss_score": 0.01564, "epss_percentile": 0.8106}, "CVE-2015-0981": {"epss_score": 0.00466, "epss_percentile": 0.63802}, "CVE-2015-0982": {"epss_score": 0.04965, "epss_percentile": 0.89343}, "CVE-2015-0984": {"epss_score": 0.00771, "epss_percentile": 0.73017}, "CVE-2015-0985": {"epss_score": 0.00072, "epss_percentile": 0.22348}, "CVE-2015-0986": {"epss_score": 0.00868, "epss_percentile": 0.74669}, "CVE-2015-0987": {"epss_score": 0.00639, "epss_percentile": 0.69945}, "CVE-2015-0988": {"epss_score": 0.00058, "epss_percentile": 0.1839}, "CVE-2015-0989": {"epss_score": 0.00375, "epss_percentile": 0.58613}, "CVE-2015-0990": {"epss_score": 0.00061, "epss_percentile": 0.1942}, "CVE-2015-0991": {"epss_score": 0.00533, "epss_percentile": 0.66754}, "CVE-2015-0992": {"epss_score": 0.00058, "epss_percentile": 0.1839}, "CVE-2015-0993": {"epss_score": 0.00274, "epss_percentile": 0.50518}, "CVE-2015-0994": {"epss_score": 0.0025, "epss_percentile": 0.4809}, "CVE-2015-0995": {"epss_score": 0.0027, "epss_percentile": 0.50215}, "CVE-2015-0996": {"epss_score": 0.00062, "epss_percentile": 0.19557}, "CVE-2015-0997": {"epss_score": 0.00601, "epss_percentile": 0.68854}, "CVE-2015-0998": {"epss_score": 0.00226, "epss_percentile": 0.45355}, "CVE-2015-0999": {"epss_score": 0.00062, "epss_percentile": 0.19557}, "CVE-2015-1000000": {"epss_score": 0.10087, "epss_percentile": 0.92844}, "CVE-2015-1000001": {"epss_score": 0.07844, "epss_percentile": 0.91717}, "CVE-2015-1000002": {"epss_score": 0.03089, "epss_percentile": 0.86392}, "CVE-2015-1000003": {"epss_score": 0.0601, "epss_percentile": 0.90407}, "CVE-2015-1000004": {"epss_score": 0.01192, "epss_percentile": 0.78402}, "CVE-2015-1000005": {"epss_score": 0.21197, "epss_percentile": 0.95475}, "CVE-2015-1000006": {"epss_score": 0.10607, "epss_percentile": 0.93044}, "CVE-2015-1000007": {"epss_score": 0.0888, "epss_percentile": 0.92298}, "CVE-2015-1000008": {"epss_score": 0.038, "epss_percentile": 0.87742}, "CVE-2015-1000009": {"epss_score": 0.05702, "epss_percentile": 0.90133}, "CVE-2015-1000010": {"epss_score": 0.31974, "epss_percentile": 0.96663}, "CVE-2015-1000011": {"epss_score": 0.0601, "epss_percentile": 0.90407}, "CVE-2015-1000012": {"epss_score": 0.68585, "epss_percentile": 0.98555}, "CVE-2015-1000013": {"epss_score": 0.06039, "epss_percentile": 0.90427}, "CVE-2015-10001": {"epss_score": 0.00142, "epss_percentile": 0.34966}, "CVE-2015-10002": {"epss_score": 0.00053, "epss_percentile": 0.16694}, "CVE-2015-10003": {"epss_score": 0.00188, "epss_percentile": 0.4088}, "CVE-2015-10004": {"epss_score": 0.00323, "epss_percentile": 0.5489}, "CVE-2015-10005": {"epss_score": 0.00561, "epss_percentile": 0.67679}, "CVE-2015-10006": {"epss_score": 0.00353, "epss_percentile": 0.57149}, "CVE-2015-10007": {"epss_score": 0.00341, "epss_percentile": 0.56317}, "CVE-2015-10008": {"epss_score": 0.00346, "epss_percentile": 0.56633}, "CVE-2015-10009": {"epss_score": 0.00487, "epss_percentile": 0.64804}, "CVE-2015-10010": {"epss_score": 0.00506, "epss_percentile": 0.65623}, "CVE-2015-10011": {"epss_score": 0.00525, "epss_percentile": 0.66372}, "CVE-2015-10012": {"epss_score": 0.00359, "epss_percentile": 0.57595}, "CVE-2015-10013": {"epss_score": 0.00595, "epss_percentile": 0.68697}, "CVE-2015-10014": {"epss_score": 0.00358, "epss_percentile": 0.57503}, "CVE-2015-10015": {"epss_score": 0.00358, "epss_percentile": 0.57503}, "CVE-2015-10016": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2015-10017": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2015-10018": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2015-10019": {"epss_score": 0.00353, "epss_percentile": 0.57149}, "CVE-2015-10020": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2015-10021": {"epss_score": 0.00353, "epss_percentile": 0.57149}, "CVE-2015-10022": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2015-10023": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2015-10024": {"epss_score": 0.00121, "epss_percentile": 0.31934}, "CVE-2015-10025": {"epss_score": 0.00069, "epss_percentile": 0.21552}, "CVE-2015-10026": {"epss_score": 0.00065, "epss_percentile": 0.20666}, "CVE-2015-10027": {"epss_score": 0.00114, "epss_percentile": 0.30845}, "CVE-2015-10028": {"epss_score": 0.00353, "epss_percentile": 0.57149}, "CVE-2015-10029": {"epss_score": 0.00045, "epss_percentile": 0.1399}, "CVE-2015-10030": {"epss_score": 0.00101, "epss_percentile": 0.28709}, "CVE-2015-10031": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2015-10032": {"epss_score": 0.0038, "epss_percentile": 0.58957}, "CVE-2015-10033": {"epss_score": 0.00045, "epss_percentile": 0.13948}, "CVE-2015-10034": {"epss_score": 0.00181, "epss_percentile": 0.40103}, "CVE-2015-10035": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2015-10036": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2015-10037": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2015-10038": {"epss_score": 0.0003, "epss_percentile": 0.08232}, "CVE-2015-10039": {"epss_score": 0.00033, "epss_percentile": 0.09194}, "CVE-2015-10040": {"epss_score": 0.00053, "epss_percentile": 0.16929}, "CVE-2015-10041": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2015-10042": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2015-10043": {"epss_score": 0.00104, "epss_percentile": 0.29214}, "CVE-2015-10044": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2015-10045": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2015-10046": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2015-10047": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2015-10048": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2015-10049": {"epss_score": 0.00088, "epss_percentile": 0.25769}, "CVE-2015-10050": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2015-10051": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2015-10052": {"epss_score": 0.0005, "epss_percentile": 0.15825}, "CVE-2015-10053": {"epss_score": 0.0005, "epss_percentile": 0.15826}, "CVE-2015-10054": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2015-10055": {"epss_score": 0.00066, "epss_percentile": 0.20902}, "CVE-2015-10056": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2015-10057": {"epss_score": 0.00078, "epss_percentile": 0.23669}, "CVE-2015-10058": {"epss_score": 0.00194, "epss_percentile": 0.41517}, "CVE-2015-10059": {"epss_score": 0.00194, "epss_percentile": 0.41517}, "CVE-2015-10060": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2015-10061": {"epss_score": 0.00078, "epss_percentile": 0.23758}, "CVE-2015-10062": {"epss_score": 0.00105, "epss_percentile": 0.29298}, "CVE-2015-10063": {"epss_score": 0.00059, "epss_percentile": 0.1875}, "CVE-2015-10064": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2015-10065": {"epss_score": 0.00144, "epss_percentile": 0.35246}, "CVE-2015-10066": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2015-10067": {"epss_score": 0.00081, "epss_percentile": 0.24336}, "CVE-2015-10068": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2015-10069": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2015-10070": {"epss_score": 0.00056, "epss_percentile": 0.17921}, "CVE-2015-10071": {"epss_score": 0.00093, "epss_percentile": 0.26666}, "CVE-2015-10072": {"epss_score": 0.00078, "epss_percentile": 0.23647}, "CVE-2015-10073": {"epss_score": 0.00145, "epss_percentile": 0.35381}, "CVE-2015-10074": {"epss_score": 0.0008, "epss_percentile": 0.24048}, "CVE-2015-10075": {"epss_score": 0.00175, "epss_percentile": 0.39301}, "CVE-2015-10076": {"epss_score": 0.00055, "epss_percentile": 0.17609}, "CVE-2015-10077": {"epss_score": 0.00049, "epss_percentile": 0.15508}, "CVE-2015-10078": {"epss_score": 0.00132, "epss_percentile": 0.33513}, "CVE-2015-10079": {"epss_score": 0.00073, "epss_percentile": 0.2265}, "CVE-2015-10080": {"epss_score": 0.00073, "epss_percentile": 0.2265}, "CVE-2015-10081": {"epss_score": 0.00069, "epss_percentile": 0.21562}, "CVE-2015-10082": {"epss_score": 0.0014, "epss_percentile": 0.34797}, "CVE-2015-10083": {"epss_score": 0.00081, "epss_percentile": 0.2427}, "CVE-2015-10084": {"epss_score": 0.0006, "epss_percentile": 0.19155}, "CVE-2015-10085": {"epss_score": 0.00058, "epss_percentile": 0.18292}, "CVE-2015-10086": {"epss_score": 0.00055, "epss_percentile": 0.17598}, "CVE-2015-10087": {"epss_score": 0.00706, "epss_percentile": 0.71638}, "CVE-2015-10088": {"epss_score": 0.00089, "epss_percentile": 0.25833}, "CVE-2015-10089": {"epss_score": 0.00071, "epss_percentile": 0.22008}, "CVE-2015-10090": {"epss_score": 0.0035, "epss_percentile": 0.56941}, "CVE-2015-10091": {"epss_score": 0.00051, "epss_percentile": 0.16038}, "CVE-2015-10092": {"epss_score": 0.00107, "epss_percentile": 0.29732}, "CVE-2015-10093": {"epss_score": 0.00098, "epss_percentile": 0.27776}, "CVE-2015-10094": {"epss_score": 0.00093, "epss_percentile": 0.26676}, "CVE-2015-10095": {"epss_score": 0.00098, "epss_percentile": 0.27776}, "CVE-2015-10096": {"epss_score": 0.00265, "epss_percentile": 0.49841}, "CVE-2015-10097": {"epss_score": 0.00055, "epss_percentile": 0.17467}, "CVE-2015-10098": {"epss_score": 0.00097, "epss_percentile": 0.27572}, "CVE-2015-10099": {"epss_score": 0.01579, "epss_percentile": 0.8113}, "CVE-2015-10100": {"epss_score": 0.00836, "epss_percentile": 0.74139}, "CVE-2015-10101": {"epss_score": 0.00147, "epss_percentile": 0.35751}, "CVE-2015-10102": {"epss_score": 0.00056, "epss_percentile": 0.17801}, "CVE-2015-10103": {"epss_score": 0.00026, "epss_percentile": 0.06678}, "CVE-2015-10104": {"epss_score": 0.00082, "epss_percentile": 0.24434}, "CVE-2015-10105": {"epss_score": 0.00202, "epss_percentile": 0.42468}, "CVE-2015-10106": {"epss_score": 0.00049, "epss_percentile": 0.15325}, "CVE-2015-10107": {"epss_score": 0.00078, "epss_percentile": 0.2359}, "CVE-2015-10108": {"epss_score": 0.00066, "epss_percentile": 0.20823}, "CVE-2015-10109": {"epss_score": 0.00066, "epss_percentile": 0.20823}, "CVE-2015-10110": {"epss_score": 0.00078, "epss_percentile": 0.2359}, "CVE-2015-10111": {"epss_score": 0.00103, "epss_percentile": 0.28992}, "CVE-2015-10112": {"epss_score": 0.0007, "epss_percentile": 0.21721}, "CVE-2015-10113": {"epss_score": 0.00059, "epss_percentile": 0.1868}, "CVE-2015-10114": {"epss_score": 0.0007, "epss_percentile": 0.21721}, "CVE-2015-10115": {"epss_score": 0.0007, "epss_percentile": 0.21721}, "CVE-2015-10116": {"epss_score": 0.00067, "epss_percentile": 0.21062}, "CVE-2015-10117": {"epss_score": 0.00078, "epss_percentile": 0.2359}, "CVE-2015-10118": {"epss_score": 0.00058, "epss_percentile": 0.18461}, "CVE-2015-10119": {"epss_score": 0.00085, "epss_percentile": 0.25116}, "CVE-2015-10120": {"epss_score": 0.00078, "epss_percentile": 0.2359}, "CVE-2015-10121": {"epss_score": 0.00058, "epss_percentile": 0.18461}, "CVE-2015-10122": {"epss_score": 0.01267, "epss_percentile": 0.79016}, "CVE-2015-10123": {"epss_score": 0.00649, "epss_percentile": 0.7024}, "CVE-2015-10124": {"epss_score": 0.00122, "epss_percentile": 0.32023}, "CVE-2015-10125": {"epss_score": 0.00078, "epss_percentile": 0.2364}, "CVE-2015-10126": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2015-10127": {"epss_score": 0.00092, "epss_percentile": 0.2647}, "CVE-2015-10128": {"epss_score": 0.00171, "epss_percentile": 0.38859}, "CVE-2015-10129": {"epss_score": 0.00102, "epss_percentile": 0.28895}, "CVE-2015-10130": {"epss_score": 0.00097, "epss_percentile": 0.27505}, "CVE-2015-10131": {"epss_score": 0.00092, "epss_percentile": 0.2652}, "CVE-2015-10132": {"epss_score": 0.00092, "epss_percentile": 0.2652}, "CVE-2015-10133": {"epss_score": 0.26048, "epss_percentile": 0.96104}, "CVE-2015-10134": {"epss_score": 0.44158, "epss_percentile": 0.97422}, "CVE-2015-10135": {"epss_score": 0.61667, "epss_percentile": 0.98258}, "CVE-2015-10136": {"epss_score": 0.48596, "epss_percentile": 0.97644}, "CVE-2015-10137": {"epss_score": 0.64086, "epss_percentile": 0.98363}, "CVE-2015-10138": {"epss_score": 0.64167, "epss_percentile": 0.98367}, "CVE-2015-10139": {"epss_score": 0.44332, "epss_percentile": 0.9743}, "CVE-2015-10140": {"epss_score": 0.40788, "epss_percentile": 0.97238}, "CVE-2015-10141": {"epss_score": 0.57243, "epss_percentile": 0.98055}, "CVE-2015-10142": {"epss_score": 0.00057, "epss_percentile": 0.18111}, "CVE-2015-10143": {"epss_score": 0.64067, "epss_percentile": 0.98362}, "CVE-2015-10144": {"epss_score": 0.00328, "epss_percentile": 0.55255}, "CVE-2015-10145": {"epss_score": 0.00115, "epss_percentile": 0.31021}, "CVE-2015-10146": {"epss_score": 0.00036, "epss_percentile": 0.10219}, "CVE-2015-10147": {"epss_score": 0.00036, "epss_percentile": 0.10219}, "CVE-2015-1142857": {"epss_score": 0.0069, "epss_percentile": 0.71247}, "CVE-2015-1000": {"epss_score": 0.0358, "epss_percentile": 0.87383}, "CVE-2015-1001": {"epss_score": 0.01353, "epss_percentile": 0.79693}, "CVE-2015-1002": {"epss_score": 0.005, "epss_percentile": 0.65329}, "CVE-2015-1003": {"epss_score": 0.0042, "epss_percentile": 0.61437}, "CVE-2015-1005": {"epss_score": 0.00065, "epss_percentile": 0.2055}, "CVE-2015-1006": {"epss_score": 0.00863, "epss_percentile": 0.74594}, "CVE-2015-1007": {"epss_score": 0.01025, "epss_percentile": 0.76785}, "CVE-2015-1008": {"epss_score": 0.00486, "epss_percentile": 0.64751}, "CVE-2015-1009": {"epss_score": 0.00079, "epss_percentile": 0.24006}, "CVE-2015-1010": {"epss_score": 7e-05, "epss_percentile": 0.0044}, "CVE-2015-1011": {"epss_score": 0.00741, "epss_percentile": 0.72445}, "CVE-2015-1012": {"epss_score": 0.00112, "epss_percentile": 0.30544}, "CVE-2015-1013": {"epss_score": 0.00268, "epss_percentile": 0.50081}, "CVE-2015-1014": {"epss_score": 0.00057, "epss_percentile": 0.18167}, "CVE-2015-1015": {"epss_score": 0.00079, "epss_percentile": 0.23813}, "CVE-2015-1026": {"epss_score": 0.00441, "epss_percentile": 0.62666}, "CVE-2015-1027": {"epss_score": 0.00264, "epss_percentile": 0.49685}, "CVE-2015-1028": {"epss_score": 0.21077, "epss_percentile": 0.9546}, "CVE-2015-1029": {"epss_score": 0.00363, "epss_percentile": 0.57867}, "CVE-2015-1030": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2015-1031": {"epss_score": 0.00659, "epss_percentile": 0.70511}, "CVE-2015-1032": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-1038": {"epss_score": 0.03183, "epss_percentile": 0.86587}, "CVE-2015-1039": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-1040": {"epss_score": 0.00403, "epss_percentile": 0.60343}, "CVE-2015-1041": {"epss_score": 0.00796, "epss_percentile": 0.73485}, "CVE-2015-1042": {"epss_score": 0.0062, "epss_percentile": 0.69453}, "CVE-2015-1043": {"epss_score": 0.00197, "epss_percentile": 0.41875}, "CVE-2015-1044": {"epss_score": 0.00285, "epss_percentile": 0.51643}, "CVE-2015-1047": {"epss_score": 0.02916, "epss_percentile": 0.85982}, "CVE-2015-1048": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2015-1049": {"epss_score": 0.00537, "epss_percentile": 0.66902}, "CVE-2015-1050": {"epss_score": 0.00309, "epss_percentile": 0.53651}, "CVE-2015-1051": {"epss_score": 0.00631, "epss_percentile": 0.69719}, "CVE-2015-1052": {"epss_score": 0.00378, "epss_percentile": 0.58778}, "CVE-2015-1053": {"epss_score": 0.00541, "epss_percentile": 0.67032}, "CVE-2015-1054": {"epss_score": 0.01885, "epss_percentile": 0.82706}, "CVE-2015-1055": {"epss_score": 0.00374, "epss_percentile": 0.5853}, "CVE-2015-1056": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2015-1057": {"epss_score": 0.04122, "epss_percentile": 0.88285}, "CVE-2015-1058": {"epss_score": 0.14042, "epss_percentile": 0.9412}, "CVE-2015-1059": {"epss_score": 0.04099, "epss_percentile": 0.88256}, "CVE-2015-1060": {"epss_score": 0.10183, "epss_percentile": 0.92883}, "CVE-2015-1061": {"epss_score": 0.05405, "epss_percentile": 0.89837}, "CVE-2015-1062": {"epss_score": 0.00336, "epss_percentile": 0.55951}, "CVE-2015-1063": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2015-1064": {"epss_score": 0.00068, "epss_percentile": 0.2136}, "CVE-2015-1065": {"epss_score": 0.00231, "epss_percentile": 0.45821}, "CVE-2015-1066": {"epss_score": 0.01174, "epss_percentile": 0.78248}, "CVE-2015-1067": {"epss_score": 0.04799, "epss_percentile": 0.89156}, "CVE-2015-1068": {"epss_score": 0.00853, "epss_percentile": 0.74435}, "CVE-2015-1069": {"epss_score": 0.00872, "epss_percentile": 0.74736}, "CVE-2015-1070": {"epss_score": 0.00787, "epss_percentile": 0.73316}, "CVE-2015-1071": {"epss_score": 0.00805, "epss_percentile": 0.73632}, "CVE-2015-1072": {"epss_score": 0.00787, "epss_percentile": 0.73316}, "CVE-2015-1073": {"epss_score": 0.00787, "epss_percentile": 0.73316}, "CVE-2015-1074": {"epss_score": 0.00787, "epss_percentile": 0.73316}, "CVE-2015-1075": {"epss_score": 0.01015, "epss_percentile": 0.7666}, "CVE-2015-1076": {"epss_score": 0.00805, "epss_percentile": 0.73632}, "CVE-2015-1077": {"epss_score": 0.00913, "epss_percentile": 0.75374}, "CVE-2015-1078": {"epss_score": 0.00913, "epss_percentile": 0.75374}, "CVE-2015-1079": {"epss_score": 0.00843, "epss_percentile": 0.74252}, "CVE-2015-1080": {"epss_score": 0.00913, "epss_percentile": 0.75374}, "CVE-2015-1081": {"epss_score": 0.00861, "epss_percentile": 0.74567}, "CVE-2015-1082": {"epss_score": 0.00913, "epss_percentile": 0.75374}, "CVE-2015-1083": {"epss_score": 0.00861, "epss_percentile": 0.74567}, "CVE-2015-1084": {"epss_score": 0.00434, "epss_percentile": 0.6232}, "CVE-2015-1085": {"epss_score": 0.00069, "epss_percentile": 0.21531}, "CVE-2015-1086": {"epss_score": 0.00057, "epss_percentile": 0.18182}, "CVE-2015-1087": {"epss_score": 0.00051, "epss_percentile": 0.15996}, "CVE-2015-1088": {"epss_score": 0.01637, "epss_percentile": 0.81483}, "CVE-2015-1089": {"epss_score": 0.00498, "epss_percentile": 0.65237}, "CVE-2015-1090": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-1091": {"epss_score": 0.00498, "epss_percentile": 0.65237}, "CVE-2015-1092": {"epss_score": 0.00823, "epss_percentile": 0.73927}, "CVE-2015-1093": {"epss_score": 0.02489, "epss_percentile": 0.84894}, "CVE-2015-1094": {"epss_score": 0.00074, "epss_percentile": 0.22722}, "CVE-2015-1095": {"epss_score": 0.00216, "epss_percentile": 0.44154}, "CVE-2015-1096": {"epss_score": 0.00074, "epss_percentile": 0.22722}, "CVE-2015-1097": {"epss_score": 0.00074, "epss_percentile": 0.22722}, "CVE-2015-1098": {"epss_score": 0.00731, "epss_percentile": 0.72175}, "CVE-2015-1099": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2015-1100": {"epss_score": 0.00917, "epss_percentile": 0.75428}, "CVE-2015-1101": {"epss_score": 0.00071, "epss_percentile": 0.22177}, "CVE-2015-1102": {"epss_score": 0.01687, "epss_percentile": 0.81759}, "CVE-2015-1103": {"epss_score": 0.01456, "epss_percentile": 0.80395}, "CVE-2015-1104": {"epss_score": 0.01854, "epss_percentile": 0.82553}, "CVE-2015-1105": {"epss_score": 0.06234, "epss_percentile": 0.90588}, "CVE-2015-1106": {"epss_score": 0.00069, "epss_percentile": 0.21531}, "CVE-2015-1107": {"epss_score": 0.00058, "epss_percentile": 0.18463}, "CVE-2015-1108": {"epss_score": 0.00072, "epss_percentile": 0.22349}, "CVE-2015-1109": {"epss_score": 0.0007, "epss_percentile": 0.21682}, "CVE-2015-1110": {"epss_score": 0.00735, "epss_percentile": 0.72287}, "CVE-2015-1111": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-1112": {"epss_score": 0.00336, "epss_percentile": 0.55951}, "CVE-2015-1113": {"epss_score": 0.00069, "epss_percentile": 0.21531}, "CVE-2015-1114": {"epss_score": 0.00074, "epss_percentile": 0.22722}, "CVE-2015-1115": {"epss_score": 0.00056, "epss_percentile": 0.17762}, "CVE-2015-1116": {"epss_score": 0.00069, "epss_percentile": 0.21531}, "CVE-2015-1117": {"epss_score": 0.00126, "epss_percentile": 0.32638}, "CVE-2015-1118": {"epss_score": 0.00875, "epss_percentile": 0.74773}, "CVE-2015-1119": {"epss_score": 0.00913, "epss_percentile": 0.75374}, "CVE-2015-1120": {"epss_score": 0.00781, "epss_percentile": 0.73183}, "CVE-2015-1121": {"epss_score": 0.00843, "epss_percentile": 0.74252}, "CVE-2015-1122": {"epss_score": 0.00836, "epss_percentile": 0.74134}, "CVE-2015-1123": {"epss_score": 0.02011, "epss_percentile": 0.83249}, "CVE-2015-1124": {"epss_score": 0.00913, "epss_percentile": 0.75374}, "CVE-2015-1125": {"epss_score": 0.00266, "epss_percentile": 0.49888}, "CVE-2015-1126": {"epss_score": 0.65446, "epss_percentile": 0.98418}, "CVE-2015-1127": {"epss_score": 0.00062, "epss_percentile": 0.19786}, "CVE-2015-1128": {"epss_score": 0.00297, "epss_percentile": 0.5269}, "CVE-2015-1129": {"epss_score": 0.00227, "epss_percentile": 0.45395}, "CVE-2015-1130": {"epss_score": 0.21065, "epss_percentile": 0.95459}, "CVE-2015-1131": {"epss_score": 0.00074, "epss_percentile": 0.22766}, "CVE-2015-1132": {"epss_score": 0.01099, "epss_percentile": 0.77546}, "CVE-2015-1133": {"epss_score": 0.00074, "epss_percentile": 0.22766}, "CVE-2015-1134": {"epss_score": 0.00074, "epss_percentile": 0.22766}, "CVE-2015-1135": {"epss_score": 0.00061, "epss_percentile": 0.19427}, "CVE-2015-1136": {"epss_score": 0.02114, "epss_percentile": 0.83654}, "CVE-2015-1137": {"epss_score": 0.0006, "epss_percentile": 0.19142}, "CVE-2015-1138": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2015-1139": {"epss_score": 0.01971, "epss_percentile": 0.83106}, "CVE-2015-1140": {"epss_score": 0.00888, "epss_percentile": 0.74998}, "CVE-2015-1141": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2015-1142": {"epss_score": 0.00056, "epss_percentile": 0.1772}, "CVE-2015-1143": {"epss_score": 0.0006, "epss_percentile": 0.19142}, "CVE-2015-1144": {"epss_score": 0.00048, "epss_percentile": 0.1501}, "CVE-2015-1145": {"epss_score": 0.00073, "epss_percentile": 0.22634}, "CVE-2015-1146": {"epss_score": 0.00073, "epss_percentile": 0.22634}, "CVE-2015-1147": {"epss_score": 0.00446, "epss_percentile": 0.62927}, "CVE-2015-1148": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-1149": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2015-1150": {"epss_score": 0.00257, "epss_percentile": 0.48891}, "CVE-2015-1151": {"epss_score": 0.00412, "epss_percentile": 0.60948}, "CVE-2015-1152": {"epss_score": 0.00989, "epss_percentile": 0.76361}, "CVE-2015-1153": {"epss_score": 0.00885, "epss_percentile": 0.74941}, "CVE-2015-1154": {"epss_score": 0.01164, "epss_percentile": 0.78164}, "CVE-2015-1155": {"epss_score": 0.63155, "epss_percentile": 0.98322}, "CVE-2015-1156": {"epss_score": 0.00627, "epss_percentile": 0.69639}, "CVE-2015-1157": {"epss_score": 0.04805, "epss_percentile": 0.89161}, "CVE-2015-1158": {"epss_score": 0.80334, "epss_percentile": 0.99081}, "CVE-2015-1159": {"epss_score": 0.58776, "epss_percentile": 0.98136}, "CVE-2015-1164": {"epss_score": 0.003, "epss_percentile": 0.52974}, "CVE-2015-1165": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2015-1169": {"epss_score": 0.00316, "epss_percentile": 0.54223}, "CVE-2015-1170": {"epss_score": 0.00048, "epss_percentile": 0.15131}, "CVE-2015-1171": {"epss_score": 0.76868, "epss_percentile": 0.98909}, "CVE-2015-1172": {"epss_score": 0.81153, "epss_percentile": 0.99124}, "CVE-2015-1173": {"epss_score": 0.0039, "epss_percentile": 0.59522}, "CVE-2015-1174": {"epss_score": 0.00611, "epss_percentile": 0.69193}, "CVE-2015-1175": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-1176": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2015-1177": {"epss_score": 0.0028, "epss_percentile": 0.51006}, "CVE-2015-1178": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2015-1179": {"epss_score": 0.00331, "epss_percentile": 0.55525}, "CVE-2015-1180": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2015-1182": {"epss_score": 0.01697, "epss_percentile": 0.81818}, "CVE-2015-1187": {"epss_score": 0.81232, "epss_percentile": 0.99129}, "CVE-2015-1188": {"epss_score": 0.00247, "epss_percentile": 0.47894}, "CVE-2015-1191": {"epss_score": 0.00662, "epss_percentile": 0.70609}, "CVE-2015-1192": {"epss_score": 0.00369, "epss_percentile": 0.58275}, "CVE-2015-1193": {"epss_score": 0.00302, "epss_percentile": 0.53103}, "CVE-2015-1194": {"epss_score": 0.00441, "epss_percentile": 0.62697}, "CVE-2015-1195": {"epss_score": 0.01105, "epss_percentile": 0.77608}, "CVE-2015-1196": {"epss_score": 0.00853, "epss_percentile": 0.74425}, "CVE-2015-1197": {"epss_score": 0.03377, "epss_percentile": 0.87024}, "CVE-2015-1198": {"epss_score": 0.03115, "epss_percentile": 0.86435}, "CVE-2015-1199": {"epss_score": 0.0143, "epss_percentile": 0.80234}, "CVE-2015-1200": {"epss_score": 0.00037, "epss_percentile": 0.1097}, "CVE-2015-1201": {"epss_score": 0.00727, "epss_percentile": 0.72088}, "CVE-2015-1204": {"epss_score": 0.00271, "epss_percentile": 0.50328}, "CVE-2015-1205": {"epss_score": 0.00998, "epss_percentile": 0.76472}, "CVE-2015-1206": {"epss_score": 0.00249, "epss_percentile": 0.48055}, "CVE-2015-1207": {"epss_score": 0.00464, "epss_percentile": 0.63722}, "CVE-2015-1208": {"epss_score": 0.00317, "epss_percentile": 0.54367}, "CVE-2015-1209": {"epss_score": 0.01051, "epss_percentile": 0.77083}, "CVE-2015-1210": {"epss_score": 0.00608, "epss_percentile": 0.69063}, "CVE-2015-1211": {"epss_score": 0.00752, "epss_percentile": 0.72659}, "CVE-2015-1212": {"epss_score": 0.0046, "epss_percentile": 0.63513}, "CVE-2015-1213": {"epss_score": 0.00974, "epss_percentile": 0.76169}, "CVE-2015-1214": {"epss_score": 0.00974, "epss_percentile": 0.76169}, "CVE-2015-1215": {"epss_score": 0.00974, "epss_percentile": 0.76169}, "CVE-2015-1216": {"epss_score": 0.01073, "epss_percentile": 0.77287}, "CVE-2015-1217": {"epss_score": 0.01649, "epss_percentile": 0.81557}, "CVE-2015-1218": {"epss_score": 0.01073, "epss_percentile": 0.77287}, "CVE-2015-1219": {"epss_score": 0.00897, "epss_percentile": 0.75137}, "CVE-2015-1220": {"epss_score": 0.03072, "epss_percentile": 0.8635}, "CVE-2015-1221": {"epss_score": 0.00867, "epss_percentile": 0.74654}, "CVE-2015-1222": {"epss_score": 0.00989, "epss_percentile": 0.76362}, "CVE-2015-1223": {"epss_score": 0.0123, "epss_percentile": 0.78722}, "CVE-2015-1224": {"epss_score": 0.04075, "epss_percentile": 0.88211}, "CVE-2015-1225": {"epss_score": 0.00755, "epss_percentile": 0.72718}, "CVE-2015-1226": {"epss_score": 0.00315, "epss_percentile": 0.5417}, "CVE-2015-1227": {"epss_score": 0.01018, "epss_percentile": 0.76698}, "CVE-2015-1228": {"epss_score": 0.01073, "epss_percentile": 0.77287}, "CVE-2015-1229": {"epss_score": 0.00317, "epss_percentile": 0.54344}, "CVE-2015-1230": {"epss_score": 0.01726, "epss_percentile": 0.8196}, "CVE-2015-1231": {"epss_score": 0.01158, "epss_percentile": 0.78117}, "CVE-2015-1232": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2015-1233": {"epss_score": 0.26281, "epss_percentile": 0.96134}, "CVE-2015-1234": {"epss_score": 0.03159, "epss_percentile": 0.86528}, "CVE-2015-1235": {"epss_score": 0.01132, "epss_percentile": 0.77867}, "CVE-2015-1236": {"epss_score": 0.00602, "epss_percentile": 0.68891}, "CVE-2015-1237": {"epss_score": 0.01832, "epss_percentile": 0.82451}, "CVE-2015-1238": {"epss_score": 0.01832, "epss_percentile": 0.82451}, "CVE-2015-1239": {"epss_score": 0.00828, "epss_percentile": 0.74004}, "CVE-2015-1240": {"epss_score": 0.01363, "epss_percentile": 0.79767}, "CVE-2015-1241": {"epss_score": 0.02832, "epss_percentile": 0.85778}, "CVE-2015-1242": {"epss_score": 0.01652, "epss_percentile": 0.81573}, "CVE-2015-1243": {"epss_score": 0.01766, "epss_percentile": 0.8217}, "CVE-2015-1244": {"epss_score": 0.0111, "epss_percentile": 0.7766}, "CVE-2015-1245": {"epss_score": 0.01826, "epss_percentile": 0.82432}, "CVE-2015-1246": {"epss_score": 0.028, "epss_percentile": 0.85695}, "CVE-2015-1247": {"epss_score": 0.01064, "epss_percentile": 0.77197}, "CVE-2015-1248": {"epss_score": 0.00553, "epss_percentile": 0.67421}, "CVE-2015-1249": {"epss_score": 0.01495, "epss_percentile": 0.80653}, "CVE-2015-1250": {"epss_score": 0.01082, "epss_percentile": 0.77386}, "CVE-2015-1251": {"epss_score": 0.04454, "epss_percentile": 0.8871}, "CVE-2015-1252": {"epss_score": 0.01241, "epss_percentile": 0.78813}, "CVE-2015-1253": {"epss_score": 0.0094, "epss_percentile": 0.75728}, "CVE-2015-1254": {"epss_score": 0.01399, "epss_percentile": 0.79994}, "CVE-2015-1255": {"epss_score": 0.01583, "epss_percentile": 0.81146}, "CVE-2015-1256": {"epss_score": 0.02139, "epss_percentile": 0.83742}, "CVE-2015-1257": {"epss_score": 0.02139, "epss_percentile": 0.83742}, "CVE-2015-1258": {"epss_score": 0.02136, "epss_percentile": 0.83727}, "CVE-2015-1259": {"epss_score": 0.01153, "epss_percentile": 0.78051}, "CVE-2015-1260": {"epss_score": 0.0169, "epss_percentile": 0.81774}, "CVE-2015-1261": {"epss_score": 0.01064, "epss_percentile": 0.77197}, "CVE-2015-1262": {"epss_score": 0.01756, "epss_percentile": 0.82122}, "CVE-2015-1263": {"epss_score": 0.00689, "epss_percentile": 0.71215}, "CVE-2015-1264": {"epss_score": 0.00491, "epss_percentile": 0.64978}, "CVE-2015-1265": {"epss_score": 0.07626, "epss_percentile": 0.9158}, "CVE-2015-1266": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2015-1267": {"epss_score": 0.00931, "epss_percentile": 0.75607}, "CVE-2015-1268": {"epss_score": 0.00833, "epss_percentile": 0.74078}, "CVE-2015-1269": {"epss_score": 0.00924, "epss_percentile": 0.75522}, "CVE-2015-1270": {"epss_score": 0.01188, "epss_percentile": 0.78369}, "CVE-2015-1271": {"epss_score": 0.02867, "epss_percentile": 0.85865}, "CVE-2015-1272": {"epss_score": 0.0213, "epss_percentile": 0.83711}, "CVE-2015-1273": {"epss_score": 0.02695, "epss_percentile": 0.85442}, "CVE-2015-1274": {"epss_score": 0.02325, "epss_percentile": 0.84387}, "CVE-2015-1275": {"epss_score": 0.0036, "epss_percentile": 0.57634}, "CVE-2015-1276": {"epss_score": 0.02776, "epss_percentile": 0.85637}, "CVE-2015-1277": {"epss_score": 0.02307, "epss_percentile": 0.84328}, "CVE-2015-1278": {"epss_score": 0.0109, "epss_percentile": 0.77451}, "CVE-2015-1279": {"epss_score": 0.01573, "epss_percentile": 0.81102}, "CVE-2015-1280": {"epss_score": 0.0217, "epss_percentile": 0.83869}, "CVE-2015-1281": {"epss_score": 0.00976, "epss_percentile": 0.76207}, "CVE-2015-1282": {"epss_score": 0.02033, "epss_percentile": 0.83344}, "CVE-2015-1283": {"epss_score": 0.00585, "epss_percentile": 0.68404}, "CVE-2015-1284": {"epss_score": 0.01223, "epss_percentile": 0.78664}, "CVE-2015-1285": {"epss_score": 0.01106, "epss_percentile": 0.77613}, "CVE-2015-1286": {"epss_score": 0.00687, "epss_percentile": 0.71185}, "CVE-2015-1287": {"epss_score": 0.00865, "epss_percentile": 0.74622}, "CVE-2015-1288": {"epss_score": 0.00847, "epss_percentile": 0.74353}, "CVE-2015-1289": {"epss_score": 0.01471, "epss_percentile": 0.80505}, "CVE-2015-1290": {"epss_score": 0.0181, "epss_percentile": 0.82364}, "CVE-2015-1291": {"epss_score": 0.0058, "epss_percentile": 0.68251}, "CVE-2015-1292": {"epss_score": 0.00597, "epss_percentile": 0.68744}, "CVE-2015-1293": {"epss_score": 0.00497, "epss_percentile": 0.65179}, "CVE-2015-1294": {"epss_score": 0.01079, "epss_percentile": 0.77359}, "CVE-2015-1295": {"epss_score": 0.01234, "epss_percentile": 0.78754}, "CVE-2015-1296": {"epss_score": 0.00871, "epss_percentile": 0.74716}, "CVE-2015-1297": {"epss_score": 0.00872, "epss_percentile": 0.74736}, "CVE-2015-1298": {"epss_score": 0.00828, "epss_percentile": 0.74}, "CVE-2015-1299": {"epss_score": 0.01872, "epss_percentile": 0.8264}, "CVE-2015-1300": {"epss_score": 0.00909, "epss_percentile": 0.75289}, "CVE-2015-1301": {"epss_score": 0.00746, "epss_percentile": 0.7254}, "CVE-2015-1302": {"epss_score": 0.01229, "epss_percentile": 0.78712}, "CVE-2015-1303": {"epss_score": 0.01256, "epss_percentile": 0.78938}, "CVE-2015-1304": {"epss_score": 0.01935, "epss_percentile": 0.8296}, "CVE-2015-1305": {"epss_score": 0.00507, "epss_percentile": 0.65664}, "CVE-2015-1306": {"epss_score": 0.00585, "epss_percentile": 0.68401}, "CVE-2015-1307": {"epss_score": 0.0026, "epss_percentile": 0.49187}, "CVE-2015-1308": {"epss_score": 0.00421, "epss_percentile": 0.61528}, "CVE-2015-1309": {"epss_score": 0.00427, "epss_percentile": 0.61914}, "CVE-2015-1310": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2015-1311": {"epss_score": 0.017, "epss_percentile": 0.81834}, "CVE-2015-1312": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2015-1313": {"epss_score": 2e-05, "epss_percentile": 0.00038}, "CVE-2015-1314": {"epss_score": 0.00069, "epss_percentile": 0.21579}, "CVE-2015-1315": {"epss_score": 0.12096, "epss_percentile": 0.93564}, "CVE-2015-1316": {"epss_score": 0.00358, "epss_percentile": 0.57494}, "CVE-2015-1317": {"epss_score": 0.01436, "epss_percentile": 0.80274}, "CVE-2015-1318": {"epss_score": 0.19068, "epss_percentile": 0.95123}, "CVE-2015-1319": {"epss_score": 0.00061, "epss_percentile": 0.19495}, "CVE-2015-1320": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2015-1321": {"epss_score": 0.0136, "epss_percentile": 0.7975}, "CVE-2015-1322": {"epss_score": 0.00023, "epss_percentile": 0.05349}, "CVE-2015-1323": {"epss_score": 0.00039, "epss_percentile": 0.11534}, "CVE-2015-1324": {"epss_score": 0.00109, "epss_percentile": 0.30026}, "CVE-2015-1325": {"epss_score": 0.00384, "epss_percentile": 0.59172}, "CVE-2015-1326": {"epss_score": 0.00113, "epss_percentile": 0.30662}, "CVE-2015-1327": {"epss_score": 0.00186, "epss_percentile": 0.40641}, "CVE-2015-1328": {"epss_score": 0.88846, "epss_percentile": 0.99494}, "CVE-2015-1329": {"epss_score": 0.02247, "epss_percentile": 0.84135}, "CVE-2015-1330": {"epss_score": 0.00076, "epss_percentile": 0.23132}, "CVE-2015-1331": {"epss_score": 0.00048, "epss_percentile": 0.1524}, "CVE-2015-1332": {"epss_score": 0.01138, "epss_percentile": 0.77928}, "CVE-2015-1333": {"epss_score": 0.00041, "epss_percentile": 0.12286}, "CVE-2015-1334": {"epss_score": 0.00101, "epss_percentile": 0.28663}, "CVE-2015-1335": {"epss_score": 0.00111, "epss_percentile": 0.30403}, "CVE-2015-1336": {"epss_score": 0.00361, "epss_percentile": 0.57731}, "CVE-2015-1337": {"epss_score": 0.00334, "epss_percentile": 0.55711}, "CVE-2015-1338": {"epss_score": 0.00379, "epss_percentile": 0.58839}, "CVE-2015-1339": {"epss_score": 0.00032, "epss_percentile": 0.0873}, "CVE-2015-1340": {"epss_score": 0.00315, "epss_percentile": 0.54194}, "CVE-2015-1341": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2015-1342": {"epss_score": 0.00056, "epss_percentile": 0.1771}, "CVE-2015-1343": {"epss_score": 0.00183, "epss_percentile": 0.40328}, "CVE-2015-1344": {"epss_score": 0.00037, "epss_percentile": 0.1072}, "CVE-2015-1345": {"epss_score": 0.00135, "epss_percentile": 0.34001}, "CVE-2015-1346": {"epss_score": 0.00313, "epss_percentile": 0.54022}, "CVE-2015-1347": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2015-1348": {"epss_score": 0.00536, "epss_percentile": 0.66861}, "CVE-2015-1349": {"epss_score": 0.11127, "epss_percentile": 0.93232}, "CVE-2015-1350": {"epss_score": 0.00065, "epss_percentile": 0.20551}, "CVE-2015-1351": {"epss_score": 0.19134, "epss_percentile": 0.95137}, "CVE-2015-1352": {"epss_score": 0.30855, "epss_percentile": 0.96572}, "CVE-2015-1355": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2015-1356": {"epss_score": 0.00127, "epss_percentile": 0.32832}, "CVE-2015-1357": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2015-1358": {"epss_score": 0.00795, "epss_percentile": 0.73466}, "CVE-2015-1359": {"epss_score": 0.00849, "epss_percentile": 0.74379}, "CVE-2015-1360": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2015-1361": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2015-1362": {"epss_score": 0.06273, "epss_percentile": 0.9063}, "CVE-2015-1363": {"epss_score": 0.00334, "epss_percentile": 0.55726}, "CVE-2015-1364": {"epss_score": 0.00912, "epss_percentile": 0.75363}, "CVE-2015-1365": {"epss_score": 0.27253, "epss_percentile": 0.96228}, "CVE-2015-1366": {"epss_score": 0.04875, "epss_percentile": 0.89238}, "CVE-2015-1367": {"epss_score": 0.00417, "epss_percentile": 0.61251}, "CVE-2015-1368": {"epss_score": 0.14008, "epss_percentile": 0.94113}, "CVE-2015-1369": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2015-1370": {"epss_score": 0.00349, "epss_percentile": 0.56901}, "CVE-2015-1371": {"epss_score": 0.09226, "epss_percentile": 0.92457}, "CVE-2015-1372": {"epss_score": 0.01845, "epss_percentile": 0.8251}, "CVE-2015-1373": {"epss_score": 0.07235, "epss_percentile": 0.9134}, "CVE-2015-1374": {"epss_score": 0.01645, "epss_percentile": 0.81526}, "CVE-2015-1375": {"epss_score": 0.24781, "epss_percentile": 0.95953}, "CVE-2015-1376": {"epss_score": 0.7051, "epss_percentile": 0.98634}, "CVE-2015-1377": {"epss_score": 0.00133, "epss_percentile": 0.3366}, "CVE-2015-1378": {"epss_score": 0.00395, "epss_percentile": 0.5984}, "CVE-2015-1379": {"epss_score": 0.0103, "epss_percentile": 0.76836}, "CVE-2015-1380": {"epss_score": 0.01012, "epss_percentile": 0.76625}, "CVE-2015-1381": {"epss_score": 0.02206, "epss_percentile": 0.84003}, "CVE-2015-1382": {"epss_score": 0.02206, "epss_percentile": 0.84003}, "CVE-2015-1383": {"epss_score": 0.00473, "epss_percentile": 0.64092}, "CVE-2015-1384": {"epss_score": 0.0027, "epss_percentile": 0.50203}, "CVE-2015-1385": {"epss_score": 0.00633, "epss_percentile": 0.69764}, "CVE-2015-1386": {"epss_score": 0.00801, "epss_percentile": 0.73562}, "CVE-2015-1388": {"epss_score": 0.00249, "epss_percentile": 0.48049}, "CVE-2015-1389": {"epss_score": 0.09548, "epss_percentile": 0.92594}, "CVE-2015-1390": {"epss_score": 0.0059, "epss_percentile": 0.68544}, "CVE-2015-1391": {"epss_score": 0.00131, "epss_percentile": 0.33425}, "CVE-2015-1392": {"epss_score": 0.00227, "epss_percentile": 0.45439}, "CVE-2015-1393": {"epss_score": 0.00318, "epss_percentile": 0.54434}, "CVE-2015-1394": {"epss_score": 0.00293, "epss_percentile": 0.52334}, "CVE-2015-1395": {"epss_score": 0.01329, "epss_percentile": 0.79508}, "CVE-2015-1396": {"epss_score": 0.03663, "epss_percentile": 0.87531}, "CVE-2015-1397": {"epss_score": 0.77776, "epss_percentile": 0.98952}, "CVE-2015-1398": {"epss_score": 0.3322, "epss_percentile": 0.96753}, "CVE-2015-1399": {"epss_score": 0.03819, "epss_percentile": 0.87773}, "CVE-2015-1400": {"epss_score": 0.01095, "epss_percentile": 0.77501}, "CVE-2015-1401": {"epss_score": 0.02289, "epss_percentile": 0.84276}, "CVE-2015-1402": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-1403": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2015-1404": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-1405": {"epss_score": 0.00517, "epss_percentile": 0.66081}, "CVE-2015-1414": {"epss_score": 0.00886, "epss_percentile": 0.74949}, "CVE-2015-1415": {"epss_score": 0.00037, "epss_percentile": 0.10737}, "CVE-2015-1416": {"epss_score": 0.00878, "epss_percentile": 0.74817}, "CVE-2015-1417": {"epss_score": 0.01395, "epss_percentile": 0.79976}, "CVE-2015-1418": {"epss_score": 0.04111, "epss_percentile": 0.88273}, "CVE-2015-1419": {"epss_score": 0.64113, "epss_percentile": 0.98366}, "CVE-2015-1420": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2015-1421": {"epss_score": 0.1087, "epss_percentile": 0.9314}, "CVE-2015-1422": {"epss_score": 0.1711, "epss_percentile": 0.94777}, "CVE-2015-1423": {"epss_score": 0.00882, "epss_percentile": 0.74884}, "CVE-2015-1424": {"epss_score": 0.00557, "epss_percentile": 0.67552}, "CVE-2015-1425": {"epss_score": 0.00412, "epss_percentile": 0.60924}, "CVE-2015-1426": {"epss_score": 0.00059, "epss_percentile": 0.18799}, "CVE-2015-1427": {"epss_score": 0.92326, "epss_percentile": 0.99708}, "CVE-2015-1428": {"epss_score": 0.01412, "epss_percentile": 0.80116}, "CVE-2015-1429": {"epss_score": 0.01288, "epss_percentile": 0.79203}, "CVE-2015-1430": {"epss_score": 0.00436, "epss_percentile": 0.62455}, "CVE-2015-1431": {"epss_score": 0.0063, "epss_percentile": 0.69693}, "CVE-2015-1432": {"epss_score": 0.00508, "epss_percentile": 0.65718}, "CVE-2015-1433": {"epss_score": 0.00585, "epss_percentile": 0.6841}, "CVE-2015-1434": {"epss_score": 0.00437, "epss_percentile": 0.62532}, "CVE-2015-1435": {"epss_score": 0.00886, "epss_percentile": 0.74948}, "CVE-2015-1436": {"epss_score": 0.00336, "epss_percentile": 0.55927}, "CVE-2015-1437": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2015-1438": {"epss_score": 0.00105, "epss_percentile": 0.29312}, "CVE-2015-1441": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2015-1442": {"epss_score": 0.01005, "epss_percentile": 0.76536}, "CVE-2015-1443": {"epss_score": 0.032, "epss_percentile": 0.86623}, "CVE-2015-1444": {"epss_score": 0.004, "epss_percentile": 0.6016}, "CVE-2015-1445": {"epss_score": 0.00672, "epss_percentile": 0.7082}, "CVE-2015-1448": {"epss_score": 0.03435, "epss_percentile": 0.87131}, "CVE-2015-1449": {"epss_score": 0.07556, "epss_percentile": 0.91539}, "CVE-2015-1450": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2015-1451": {"epss_score": 0.00239, "epss_percentile": 0.46937}, "CVE-2015-1452": {"epss_score": 0.00977, "epss_percentile": 0.7623}, "CVE-2015-1453": {"epss_score": 0.00156, "epss_percentile": 0.36994}, "CVE-2015-1454": {"epss_score": 0.00174, "epss_percentile": 0.39139}, "CVE-2015-1455": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2015-1456": {"epss_score": 0.0027, "epss_percentile": 0.50207}, "CVE-2015-1457": {"epss_score": 0.00078, "epss_percentile": 0.23552}, "CVE-2015-1458": {"epss_score": 0.00062, "epss_percentile": 0.19704}, "CVE-2015-1459": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2015-1460": {"epss_score": 0.00692, "epss_percentile": 0.71283}, "CVE-2015-1461": {"epss_score": 0.01142, "epss_percentile": 0.77971}, "CVE-2015-1462": {"epss_score": 0.01142, "epss_percentile": 0.77971}, "CVE-2015-1463": {"epss_score": 0.0188, "epss_percentile": 0.82686}, "CVE-2015-1464": {"epss_score": 0.00347, "epss_percentile": 0.56764}, "CVE-2015-1465": {"epss_score": 0.07718, "epss_percentile": 0.91641}, "CVE-2015-1467": {"epss_score": 0.01345, "epss_percentile": 0.79622}, "CVE-2015-1469": {"epss_score": 0.00216, "epss_percentile": 0.44185}, "CVE-2015-1471": {"epss_score": 0.05408, "epss_percentile": 0.89842}, "CVE-2015-1472": {"epss_score": 0.04758, "epss_percentile": 0.89116}, "CVE-2015-1473": {"epss_score": 0.00449, "epss_percentile": 0.63039}, "CVE-2015-1474": {"epss_score": 0.08969, "epss_percentile": 0.92343}, "CVE-2015-1475": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-1476": {"epss_score": 0.0096, "epss_percentile": 0.75967}, "CVE-2015-1477": {"epss_score": 0.00943, "epss_percentile": 0.7578}, "CVE-2015-1478": {"epss_score": 0.03324, "epss_percentile": 0.86918}, "CVE-2015-1479": {"epss_score": 0.10556, "epss_percentile": 0.93027}, "CVE-2015-1480": {"epss_score": 0.1823, "epss_percentile": 0.94977}, "CVE-2015-1481": {"epss_score": 0.03958, "epss_percentile": 0.88006}, "CVE-2015-1482": {"epss_score": 0.17397, "epss_percentile": 0.94845}, "CVE-2015-1483": {"epss_score": 0.00646, "epss_percentile": 0.70138}, "CVE-2015-1484": {"epss_score": 0.00068, "epss_percentile": 0.21247}, "CVE-2015-1485": {"epss_score": 0.00157, "epss_percentile": 0.37104}, "CVE-2015-1486": {"epss_score": 0.78501, "epss_percentile": 0.98989}, "CVE-2015-1487": {"epss_score": 0.51202, "epss_percentile": 0.97768}, "CVE-2015-1488": {"epss_score": 0.00491, "epss_percentile": 0.64951}, "CVE-2015-1489": {"epss_score": 0.60766, "epss_percentile": 0.9822}, "CVE-2015-1490": {"epss_score": 0.02349, "epss_percentile": 0.84464}, "CVE-2015-1491": {"epss_score": 0.01004, "epss_percentile": 0.76523}, "CVE-2015-1492": {"epss_score": 0.00849, "epss_percentile": 0.74379}, "CVE-2015-1493": {"epss_score": 0.00901, "epss_percentile": 0.75171}, "CVE-2015-1494": {"epss_score": 0.04563, "epss_percentile": 0.88854}, "CVE-2015-1495": {"epss_score": 0.03798, "epss_percentile": 0.87739}, "CVE-2015-1496": {"epss_score": 0.00112, "epss_percentile": 0.30546}, "CVE-2015-1497": {"epss_score": 0.88255, "epss_percentile": 0.99463}, "CVE-2015-1498": {"epss_score": 0.01305, "epss_percentile": 0.79322}, "CVE-2015-1499": {"epss_score": 0.01129, "epss_percentile": 0.77841}, "CVE-2015-1500": {"epss_score": 0.42605, "epss_percentile": 0.97343}, "CVE-2015-1501": {"epss_score": 0.20891, "epss_percentile": 0.95434}, "CVE-2015-1503": {"epss_score": 0.91655, "epss_percentile": 0.99661}, "CVE-2015-1512": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2015-1513": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2015-1514": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2015-1515": {"epss_score": 0.00585, "epss_percentile": 0.68399}, "CVE-2015-1516": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2015-1517": {"epss_score": 0.01034, "epss_percentile": 0.76886}, "CVE-2015-1518": {"epss_score": 0.02486, "epss_percentile": 0.84886}, "CVE-2015-1521": {"epss_score": 0.00766, "epss_percentile": 0.72944}, "CVE-2015-1522": {"epss_score": 0.00766, "epss_percentile": 0.72944}, "CVE-2015-1525": {"epss_score": 0.00053, "epss_percentile": 0.16832}, "CVE-2015-1526": {"epss_score": 0.00168, "epss_percentile": 0.38404}, "CVE-2015-1527": {"epss_score": 0.00029, "epss_percentile": 0.07585}, "CVE-2015-1528": {"epss_score": 0.17098, "epss_percentile": 0.94773}, "CVE-2015-1529": {"epss_score": 0.00341, "epss_percentile": 0.56299}, "CVE-2015-1530": {"epss_score": 0.00063, "epss_percentile": 0.19803}, "CVE-2015-1536": {"epss_score": 0.00217, "epss_percentile": 0.44247}, "CVE-2015-1537": {"epss_score": 0.00644, "epss_percentile": 0.70073}, "CVE-2015-1538": {"epss_score": 0.87812, "epss_percentile": 0.99446}, "CVE-2015-1539": {"epss_score": 0.1862, "epss_percentile": 0.95044}, "CVE-2015-1541": {"epss_score": 0.00059, "epss_percentile": 0.18782}, "CVE-2015-1545": {"epss_score": 0.64842, "epss_percentile": 0.98395}, "CVE-2015-1546": {"epss_score": 0.10383, "epss_percentile": 0.92967}, "CVE-2015-1547": {"epss_score": 0.0445, "epss_percentile": 0.88704}, "CVE-2015-1548": {"epss_score": 0.00234, "epss_percentile": 0.46163}, "CVE-2015-1550": {"epss_score": 0.00758, "epss_percentile": 0.7277}, "CVE-2015-1551": {"epss_score": 0.00249, "epss_percentile": 0.48027}, "CVE-2015-1554": {"epss_score": 0.0088, "epss_percentile": 0.74855}, "CVE-2015-1555": {"epss_score": 0.00289, "epss_percentile": 0.51999}, "CVE-2015-1558": {"epss_score": 0.17453, "epss_percentile": 0.94853}, "CVE-2015-1559": {"epss_score": 0.00283, "epss_percentile": 0.51408}, "CVE-2015-1560": {"epss_score": 0.02982, "epss_percentile": 0.86125}, "CVE-2015-1561": {"epss_score": 0.05236, "epss_percentile": 0.89647}, "CVE-2015-1562": {"epss_score": 0.004, "epss_percentile": 0.60191}, "CVE-2015-1563": {"epss_score": 0.00076, "epss_percentile": 0.23129}, "CVE-2015-1564": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2015-1565": {"epss_score": 0.00276, "epss_percentile": 0.50769}, "CVE-2015-1566": {"epss_score": 0.00253, "epss_percentile": 0.48492}, "CVE-2015-1567": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-1568": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-1569": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2015-1570": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2015-1571": {"epss_score": 0.00155, "epss_percentile": 0.36786}, "CVE-2015-1572": {"epss_score": 0.00088, "epss_percentile": 0.25675}, "CVE-2015-1573": {"epss_score": 0.00042, "epss_percentile": 0.12881}, "CVE-2015-1574": {"epss_score": 0.01618, "epss_percentile": 0.81371}, "CVE-2015-1575": {"epss_score": 0.04307, "epss_percentile": 0.88525}, "CVE-2015-1576": {"epss_score": 0.00826, "epss_percentile": 0.73969}, "CVE-2015-1577": {"epss_score": 0.103, "epss_percentile": 0.92934}, "CVE-2015-1578": {"epss_score": 0.04482, "epss_percentile": 0.88743}, "CVE-2015-1579": {"epss_score": 0.80822, "epss_percentile": 0.99108}, "CVE-2015-1580": {"epss_score": 0.00113, "epss_percentile": 0.30682}, "CVE-2015-1581": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2015-1582": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2015-1583": {"epss_score": 0.00228, "epss_percentile": 0.45462}, "CVE-2015-1585": {"epss_score": 0.00283, "epss_percentile": 0.51401}, "CVE-2015-1587": {"epss_score": 0.79223, "epss_percentile": 0.99025}, "CVE-2015-1588": {"epss_score": 0.00292, "epss_percentile": 0.52224}, "CVE-2015-1589": {"epss_score": 0.00342, "epss_percentile": 0.56367}, "CVE-2015-1590": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2015-1591": {"epss_score": 0.00062, "epss_percentile": 0.1966}, "CVE-2015-1592": {"epss_score": 0.81049, "epss_percentile": 0.99118}, "CVE-2015-1593": {"epss_score": 0.01966, "epss_percentile": 0.83083}, "CVE-2015-1594": {"epss_score": 0.00056, "epss_percentile": 0.17833}, "CVE-2015-1595": {"epss_score": 0.00141, "epss_percentile": 0.34921}, "CVE-2015-1596": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2015-1597": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2015-1598": {"epss_score": 0.00063, "epss_percentile": 0.19977}, "CVE-2015-1599": {"epss_score": 0.00061, "epss_percentile": 0.19495}, "CVE-2015-1600": {"epss_score": 0.01001, "epss_percentile": 0.76498}, "CVE-2015-1601": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2015-1602": {"epss_score": 0.00056, "epss_percentile": 0.17862}, "CVE-2015-1603": {"epss_score": 0.00744, "epss_percentile": 0.72503}, "CVE-2015-1604": {"epss_score": 0.04371, "epss_percentile": 0.88609}, "CVE-2015-1605": {"epss_score": 0.00422, "epss_percentile": 0.61566}, "CVE-2015-1606": {"epss_score": 0.00474, "epss_percentile": 0.64162}, "CVE-2015-1607": {"epss_score": 0.0063, "epss_percentile": 0.69696}, "CVE-2015-1608": {"epss_score": 0.00868, "epss_percentile": 0.74682}, "CVE-2015-1609": {"epss_score": 0.01703, "epss_percentile": 0.81843}, "CVE-2015-1610": {"epss_score": 0.00256, "epss_percentile": 0.48785}, "CVE-2015-1611": {"epss_score": 0.00971, "epss_percentile": 0.76129}, "CVE-2015-1612": {"epss_score": 0.00971, "epss_percentile": 0.76129}, "CVE-2015-1613": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2015-1614": {"epss_score": 0.0014, "epss_percentile": 0.34796}, "CVE-2015-1616": {"epss_score": 0.00311, "epss_percentile": 0.5386}, "CVE-2015-1617": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2015-1618": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2015-1619": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2015-1621": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-1622": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-1623": {"epss_score": 0.20835, "epss_percentile": 0.95422}, "CVE-2015-1624": {"epss_score": 0.19558, "epss_percentile": 0.95209}, "CVE-2015-1625": {"epss_score": 0.19558, "epss_percentile": 0.95209}, "CVE-2015-1626": {"epss_score": 0.19558, "epss_percentile": 0.95209}, "CVE-2015-1627": {"epss_score": 0.08368, "epss_percentile": 0.92012}, "CVE-2015-1628": {"epss_score": 0.06935, "epss_percentile": 0.91127}, "CVE-2015-1629": {"epss_score": 0.06935, "epss_percentile": 0.91127}, "CVE-2015-1630": {"epss_score": 0.06935, "epss_percentile": 0.91127}, "CVE-2015-1631": {"epss_score": 0.08599, "epss_percentile": 0.92144}, "CVE-2015-1632": {"epss_score": 0.06643, "epss_percentile": 0.90911}, "CVE-2015-1633": {"epss_score": 0.07981, "epss_percentile": 0.91802}, "CVE-2015-1634": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-1635": {"epss_score": 0.9431, "epss_percentile": 0.99943}, "CVE-2015-1636": {"epss_score": 0.07981, "epss_percentile": 0.91802}, "CVE-2015-1637": {"epss_score": 0.43723, "epss_percentile": 0.974}, "CVE-2015-1638": {"epss_score": 0.22659, "epss_percentile": 0.95665}, "CVE-2015-1639": {"epss_score": 0.06935, "epss_percentile": 0.91127}, "CVE-2015-1640": {"epss_score": 0.08963, "epss_percentile": 0.92339}, "CVE-2015-1641": {"epss_score": 0.93624, "epss_percentile": 0.99825}, "CVE-2015-1642": {"epss_score": 0.72879, "epss_percentile": 0.98727}, "CVE-2015-1643": {"epss_score": 0.02327, "epss_percentile": 0.84394}, "CVE-2015-1644": {"epss_score": 0.02675, "epss_percentile": 0.85399}, "CVE-2015-1645": {"epss_score": 0.45984, "epss_percentile": 0.97516}, "CVE-2015-1646": {"epss_score": 0.28071, "epss_percentile": 0.96306}, "CVE-2015-1647": {"epss_score": 0.00439, "epss_percentile": 0.62604}, "CVE-2015-1648": {"epss_score": 0.34816, "epss_percentile": 0.96875}, "CVE-2015-1649": {"epss_score": 0.5476, "epss_percentile": 0.97943}, "CVE-2015-1650": {"epss_score": 0.60814, "epss_percentile": 0.98223}, "CVE-2015-1651": {"epss_score": 0.53055, "epss_percentile": 0.97853}, "CVE-2015-1652": {"epss_score": 0.19558, "epss_percentile": 0.95209}, "CVE-2015-1653": {"epss_score": 0.09872, "epss_percentile": 0.92746}, "CVE-2015-1657": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2015-1658": {"epss_score": 0.18473, "epss_percentile": 0.9502}, "CVE-2015-1659": {"epss_score": 0.19558, "epss_percentile": 0.95209}, "CVE-2015-1660": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2015-1661": {"epss_score": 0.18781, "epss_percentile": 0.95068}, "CVE-2015-1662": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2015-1665": {"epss_score": 0.19558, "epss_percentile": 0.95209}, "CVE-2015-1666": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2015-1667": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2015-1668": {"epss_score": 0.19558, "epss_percentile": 0.95209}, "CVE-2015-1670": {"epss_score": 0.04518, "epss_percentile": 0.88795}, "CVE-2015-1671": {"epss_score": 0.83857, "epss_percentile": 0.99263}, "CVE-2015-1672": {"epss_score": 0.16216, "epss_percentile": 0.94596}, "CVE-2015-1673": {"epss_score": 0.39189, "epss_percentile": 0.97144}, "CVE-2015-1674": {"epss_score": 0.00865, "epss_percentile": 0.74616}, "CVE-2015-1675": {"epss_score": 0.31425, "epss_percentile": 0.96619}, "CVE-2015-1676": {"epss_score": 0.02531, "epss_percentile": 0.85027}, "CVE-2015-1677": {"epss_score": 0.02531, "epss_percentile": 0.85027}, "CVE-2015-1678": {"epss_score": 0.02531, "epss_percentile": 0.85027}, "CVE-2015-1679": {"epss_score": 0.02392, "epss_percentile": 0.84603}, "CVE-2015-1680": {"epss_score": 0.02531, "epss_percentile": 0.85027}, "CVE-2015-1681": {"epss_score": 0.01207, "epss_percentile": 0.78525}, "CVE-2015-1682": {"epss_score": 0.36744, "epss_percentile": 0.96998}, "CVE-2015-1683": {"epss_score": 0.37547, "epss_percentile": 0.97056}, "CVE-2015-1684": {"epss_score": 0.1309, "epss_percentile": 0.93871}, "CVE-2015-1685": {"epss_score": 0.23412, "epss_percentile": 0.95775}, "CVE-2015-1686": {"epss_score": 0.1309, "epss_percentile": 0.93871}, "CVE-2015-1687": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2015-1688": {"epss_score": 0.10956, "epss_percentile": 0.93176}, "CVE-2015-1689": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-1691": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-1692": {"epss_score": 0.30508, "epss_percentile": 0.96547}, "CVE-2015-1694": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-1695": {"epss_score": 0.31425, "epss_percentile": 0.96619}, "CVE-2015-1696": {"epss_score": 0.33094, "epss_percentile": 0.96745}, "CVE-2015-1697": {"epss_score": 0.33094, "epss_percentile": 0.96745}, "CVE-2015-1698": {"epss_score": 0.33094, "epss_percentile": 0.96745}, "CVE-2015-1699": {"epss_score": 0.31425, "epss_percentile": 0.96619}, "CVE-2015-1700": {"epss_score": 0.19469, "epss_percentile": 0.95189}, "CVE-2015-1701": {"epss_score": 0.89856, "epss_percentile": 0.99546}, "CVE-2015-1702": {"epss_score": 0.05457, "epss_percentile": 0.89898}, "CVE-2015-1703": {"epss_score": 0.10956, "epss_percentile": 0.93176}, "CVE-2015-1704": {"epss_score": 0.10956, "epss_percentile": 0.93176}, "CVE-2015-1705": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-1706": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-1708": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-1709": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-1710": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-1711": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-1712": {"epss_score": 0.21227, "epss_percentile": 0.95481}, "CVE-2015-1713": {"epss_score": 0.10956, "epss_percentile": 0.93176}, "CVE-2015-1714": {"epss_score": 0.21227, "epss_percentile": 0.95481}, "CVE-2015-1715": {"epss_score": 0.26058, "epss_percentile": 0.96106}, "CVE-2015-1716": {"epss_score": 0.18434, "epss_percentile": 0.95016}, "CVE-2015-1717": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-1718": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-1719": {"epss_score": 0.02446, "epss_percentile": 0.84771}, "CVE-2015-1720": {"epss_score": 0.01115, "epss_percentile": 0.77711}, "CVE-2015-1721": {"epss_score": 0.10935, "epss_percentile": 0.93165}, "CVE-2015-1722": {"epss_score": 0.04739, "epss_percentile": 0.89077}, "CVE-2015-1723": {"epss_score": 0.10879, "epss_percentile": 0.93144}, "CVE-2015-1724": {"epss_score": 0.13806, "epss_percentile": 0.9406}, "CVE-2015-1725": {"epss_score": 0.06454, "epss_percentile": 0.90766}, "CVE-2015-1726": {"epss_score": 0.10879, "epss_percentile": 0.93144}, "CVE-2015-1727": {"epss_score": 0.19746, "epss_percentile": 0.95236}, "CVE-2015-1728": {"epss_score": 0.26887, "epss_percentile": 0.96188}, "CVE-2015-1729": {"epss_score": 0.21656, "epss_percentile": 0.95544}, "CVE-2015-1730": {"epss_score": 0.57165, "epss_percentile": 0.98052}, "CVE-2015-1731": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2015-1732": {"epss_score": 0.29545, "epss_percentile": 0.96455}, "CVE-2015-1733": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-1735": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-1736": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-1737": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-1738": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-1739": {"epss_score": 0.08383, "epss_percentile": 0.92019}, "CVE-2015-1740": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-1741": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-1742": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-1743": {"epss_score": 0.09823, "epss_percentile": 0.92719}, "CVE-2015-1744": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-1745": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-1747": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-1748": {"epss_score": 0.09834, "epss_percentile": 0.92724}, "CVE-2015-1750": {"epss_score": 0.20835, "epss_percentile": 0.95422}, "CVE-2015-1751": {"epss_score": 0.12944, "epss_percentile": 0.93825}, "CVE-2015-1752": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-1753": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-1754": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-1755": {"epss_score": 0.14058, "epss_percentile": 0.94125}, "CVE-2015-1756": {"epss_score": 0.44309, "epss_percentile": 0.97429}, "CVE-2015-1757": {"epss_score": 0.10694, "epss_percentile": 0.93072}, "CVE-2015-1758": {"epss_score": 0.05398, "epss_percentile": 0.89831}, "CVE-2015-1759": {"epss_score": 0.39189, "epss_percentile": 0.97144}, "CVE-2015-1760": {"epss_score": 0.35902, "epss_percentile": 0.96941}, "CVE-2015-1761": {"epss_score": 0.06637, "epss_percentile": 0.90908}, "CVE-2015-1762": {"epss_score": 0.02025, "epss_percentile": 0.83314}, "CVE-2015-1763": {"epss_score": 0.10746, "epss_percentile": 0.93091}, "CVE-2015-1764": {"epss_score": 0.08114, "epss_percentile": 0.91887}, "CVE-2015-1765": {"epss_score": 0.17003, "epss_percentile": 0.94759}, "CVE-2015-1766": {"epss_score": 0.24067, "epss_percentile": 0.95867}, "CVE-2015-1767": {"epss_score": 0.18139, "epss_percentile": 0.94965}, "CVE-2015-1768": {"epss_score": 0.01642, "epss_percentile": 0.8151}, "CVE-2015-1769": {"epss_score": 0.28425, "epss_percentile": 0.96357}, "CVE-2015-1770": {"epss_score": 0.78193, "epss_percentile": 0.98973}, "CVE-2015-1771": {"epss_score": 0.02012, "epss_percentile": 0.83253}, "CVE-2015-1772": {"epss_score": 0.00163, "epss_percentile": 0.3781}, "CVE-2015-1773": {"epss_score": 0.01283, "epss_percentile": 0.79157}, "CVE-2015-1774": {"epss_score": 0.1265, "epss_percentile": 0.93741}, "CVE-2015-1775": {"epss_score": 0.00344, "epss_percentile": 0.56495}, "CVE-2015-1776": {"epss_score": 0.00065, "epss_percentile": 0.20616}, "CVE-2015-1777": {"epss_score": 0.00195, "epss_percentile": 0.41663}, "CVE-2015-1778": {"epss_score": 0.03002, "epss_percentile": 0.86174}, "CVE-2015-1779": {"epss_score": 0.05573, "epss_percentile": 0.90009}, "CVE-2015-1780": {"epss_score": 0.00249, "epss_percentile": 0.48031}, "CVE-2015-1781": {"epss_score": 0.07793, "epss_percentile": 0.91685}, "CVE-2015-1782": {"epss_score": 0.04684, "epss_percentile": 0.89004}, "CVE-2015-1783": {"epss_score": 0.01056, "epss_percentile": 0.77121}, "CVE-2015-1784": {"epss_score": 0.01495, "epss_percentile": 0.80659}, "CVE-2015-1785": {"epss_score": 0.00129, "epss_percentile": 0.33218}, "CVE-2015-1786": {"epss_score": 0.00113, "epss_percentile": 0.30676}, "CVE-2015-1787": {"epss_score": 0.14935, "epss_percentile": 0.94328}, "CVE-2015-1788": {"epss_score": 0.15282, "epss_percentile": 0.94399}, "CVE-2015-1789": {"epss_score": 0.03274, "epss_percentile": 0.868}, "CVE-2015-1790": {"epss_score": 0.11772, "epss_percentile": 0.93469}, "CVE-2015-1791": {"epss_score": 0.10249, "epss_percentile": 0.92912}, "CVE-2015-1792": {"epss_score": 0.11695, "epss_percentile": 0.93452}, "CVE-2015-1793": {"epss_score": 0.85629, "epss_percentile": 0.99341}, "CVE-2015-1794": {"epss_score": 0.10711, "epss_percentile": 0.9308}, "CVE-2015-1795": {"epss_score": 0.00064, "epss_percentile": 0.20405}, "CVE-2015-1796": {"epss_score": 0.00166, "epss_percentile": 0.38191}, "CVE-2015-1798": {"epss_score": 0.0083, "epss_percentile": 0.7402}, "CVE-2015-1799": {"epss_score": 0.00638, "epss_percentile": 0.69906}, "CVE-2015-1800": {"epss_score": 0.00897, "epss_percentile": 0.75127}, "CVE-2015-1801": {"epss_score": 0.0091, "epss_percentile": 0.75318}, "CVE-2015-1802": {"epss_score": 0.01735, "epss_percentile": 0.8201}, "CVE-2015-1803": {"epss_score": 0.01689, "epss_percentile": 0.81769}, "CVE-2015-1804": {"epss_score": 0.02438, "epss_percentile": 0.84745}, "CVE-2015-1805": {"epss_score": 0.15033, "epss_percentile": 0.94349}, "CVE-2015-1806": {"epss_score": 0.00639, "epss_percentile": 0.69953}, "CVE-2015-1807": {"epss_score": 0.00128, "epss_percentile": 0.33064}, "CVE-2015-1808": {"epss_score": 0.00175, "epss_percentile": 0.3931}, "CVE-2015-1809": {"epss_score": 0.00132, "epss_percentile": 0.33516}, "CVE-2015-1810": {"epss_score": 0.00433, "epss_percentile": 0.62222}, "CVE-2015-1811": {"epss_score": 0.00125, "epss_percentile": 0.32563}, "CVE-2015-1812": {"epss_score": 0.00215, "epss_percentile": 0.44061}, "CVE-2015-1813": {"epss_score": 0.00215, "epss_percentile": 0.44061}, "CVE-2015-1814": {"epss_score": 0.00239, "epss_percentile": 0.46938}, "CVE-2015-1815": {"epss_score": 0.36469, "epss_percentile": 0.9698}, "CVE-2015-1816": {"epss_score": 0.00217, "epss_percentile": 0.44277}, "CVE-2015-1817": {"epss_score": 0.00453, "epss_percentile": 0.63218}, "CVE-2015-1818": {"epss_score": 0.00537, "epss_percentile": 0.66887}, "CVE-2015-1819": {"epss_score": 0.04917, "epss_percentile": 0.89287}, "CVE-2015-1820": {"epss_score": 0.03723, "epss_percentile": 0.87628}, "CVE-2015-1821": {"epss_score": 0.02605, "epss_percentile": 0.8522}, "CVE-2015-1822": {"epss_score": 0.0211, "epss_percentile": 0.83643}, "CVE-2015-1827": {"epss_score": 0.01175, "epss_percentile": 0.78257}, "CVE-2015-1828": {"epss_score": 0.0032, "epss_percentile": 0.54611}, "CVE-2015-1829": {"epss_score": 0.01006, "epss_percentile": 0.76546}, "CVE-2015-1830": {"epss_score": 0.86019, "epss_percentile": 0.99362}, "CVE-2015-1831": {"epss_score": 0.06005, "epss_percentile": 0.90395}, "CVE-2015-1832": {"epss_score": 0.00489, "epss_percentile": 0.64896}, "CVE-2015-1833": {"epss_score": 0.30217, "epss_percentile": 0.96521}, "CVE-2015-1834": {"epss_score": 0.00295, "epss_percentile": 0.52452}, "CVE-2015-1835": {"epss_score": 0.00625, "epss_percentile": 0.69587}, "CVE-2015-1836": {"epss_score": 0.02143, "epss_percentile": 0.83755}, "CVE-2015-1838": {"epss_score": 0.00069, "epss_percentile": 0.21445}, "CVE-2015-1839": {"epss_score": 0.00082, "epss_percentile": 0.24572}, "CVE-2015-1840": {"epss_score": 0.00323, "epss_percentile": 0.54876}, "CVE-2015-1841": {"epss_score": 0.00054, "epss_percentile": 0.17077}, "CVE-2015-1842": {"epss_score": 0.04844, "epss_percentile": 0.89205}, "CVE-2015-1843": {"epss_score": 0.01125, "epss_percentile": 0.77808}, "CVE-2015-1844": {"epss_score": 0.00261, "epss_percentile": 0.49308}, "CVE-2015-1845": {"epss_score": 0.10963, "epss_percentile": 0.93178}, "CVE-2015-1846": {"epss_score": 0.0085, "epss_percentile": 0.7439}, "CVE-2015-1847": {"epss_score": 0.00375, "epss_percentile": 0.58597}, "CVE-2015-1848": {"epss_score": 0.0121, "epss_percentile": 0.78549}, "CVE-2015-1849": {"epss_score": 0.00303, "epss_percentile": 0.53221}, "CVE-2015-1851": {"epss_score": 0.00489, "epss_percentile": 0.64875}, "CVE-2015-1852": {"epss_score": 0.00219, "epss_percentile": 0.44486}, "CVE-2015-1853": {"epss_score": 0.00915, "epss_percentile": 0.75399}, "CVE-2015-1854": {"epss_score": 0.01632, "epss_percentile": 0.81458}, "CVE-2015-1855": {"epss_score": 0.0272, "epss_percentile": 0.85516}, "CVE-2015-1856": {"epss_score": 0.01033, "epss_percentile": 0.7688}, "CVE-2015-1857": {"epss_score": 0.00348, "epss_percentile": 0.56835}, "CVE-2015-1858": {"epss_score": 0.02446, "epss_percentile": 0.84768}, "CVE-2015-1859": {"epss_score": 0.04396, "epss_percentile": 0.88639}, "CVE-2015-1860": {"epss_score": 0.05247, "epss_percentile": 0.89659}, "CVE-2015-1862": {"epss_score": 0.04064, "epss_percentile": 0.88194}, "CVE-2015-1863": {"epss_score": 0.08546, "epss_percentile": 0.92117}, "CVE-2015-1864": {"epss_score": 0.00372, "epss_percentile": 0.58464}, "CVE-2015-1865": {"epss_score": 0.00076, "epss_percentile": 0.2318}, "CVE-2015-1866": {"epss_score": 0.0033, "epss_percentile": 0.55432}, "CVE-2015-1867": {"epss_score": 0.00714, "epss_percentile": 0.71819}, "CVE-2015-1868": {"epss_score": 0.00351, "epss_percentile": 0.5701}, "CVE-2015-1869": {"epss_score": 0.00148, "epss_percentile": 0.35891}, "CVE-2015-1870": {"epss_score": 0.00101, "epss_percentile": 0.28571}, "CVE-2015-1872": {"epss_score": 0.00623, "epss_percentile": 0.69534}, "CVE-2015-1874": {"epss_score": 0.00189, "epss_percentile": 0.40956}, "CVE-2015-1875": {"epss_score": 0.00826, "epss_percentile": 0.73969}, "CVE-2015-1876": {"epss_score": 0.02596, "epss_percentile": 0.852}, "CVE-2015-1877": {"epss_score": 0.01364, "epss_percentile": 0.79773}, "CVE-2015-1878": {"epss_score": 0.00067, "epss_percentile": 0.21057}, "CVE-2015-1879": {"epss_score": 0.00143, "epss_percentile": 0.3521}, "CVE-2015-1880": {"epss_score": 0.59363, "epss_percentile": 0.98161}, "CVE-2015-1881": {"epss_score": 0.0058, "epss_percentile": 0.68253}, "CVE-2015-1882": {"epss_score": 0.022, "epss_percentile": 0.83973}, "CVE-2015-1883": {"epss_score": 0.00336, "epss_percentile": 0.55927}, "CVE-2015-1884": {"epss_score": 0.00808, "epss_percentile": 0.737}, "CVE-2015-1885": {"epss_score": 0.02478, "epss_percentile": 0.84867}, "CVE-2015-1886": {"epss_score": 0.02088, "epss_percentile": 0.83558}, "CVE-2015-1887": {"epss_score": 0.00285, "epss_percentile": 0.5165}, "CVE-2015-1888": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-1889": {"epss_score": 0.00237, "epss_percentile": 0.46721}, "CVE-2015-1890": {"epss_score": 0.00152, "epss_percentile": 0.36471}, "CVE-2015-1892": {"epss_score": 0.0182, "epss_percentile": 0.82408}, "CVE-2015-1893": {"epss_score": 0.0082, "epss_percentile": 0.73881}, "CVE-2015-1894": {"epss_score": 0.00095, "epss_percentile": 0.2712}, "CVE-2015-1895": {"epss_score": 0.00251, "epss_percentile": 0.48315}, "CVE-2015-1896": {"epss_score": 0.40254, "epss_percentile": 0.97209}, "CVE-2015-1897": {"epss_score": 0.0007, "epss_percentile": 0.21821}, "CVE-2015-1898": {"epss_score": 0.00069, "epss_percentile": 0.2156}, "CVE-2015-1899": {"epss_score": 0.00667, "epss_percentile": 0.70707}, "CVE-2015-1900": {"epss_score": 0.00055, "epss_percentile": 0.17437}, "CVE-2015-1901": {"epss_score": 0.00055, "epss_percentile": 0.17551}, "CVE-2015-1902": {"epss_score": 0.34021, "epss_percentile": 0.96822}, "CVE-2015-1903": {"epss_score": 0.34021, "epss_percentile": 0.96822}, "CVE-2015-1904": {"epss_score": 0.00117, "epss_percentile": 0.31353}, "CVE-2015-1905": {"epss_score": 0.0021, "epss_percentile": 0.4347}, "CVE-2015-1906": {"epss_score": 0.00227, "epss_percentile": 0.454}, "CVE-2015-1907": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2015-1908": {"epss_score": 0.0023, "epss_percentile": 0.45669}, "CVE-2015-1909": {"epss_score": 0.00293, "epss_percentile": 0.52343}, "CVE-2015-1910": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-1911": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2015-1913": {"epss_score": 0.00258, "epss_percentile": 0.49026}, "CVE-2015-1914": {"epss_score": 0.00158, "epss_percentile": 0.37282}, "CVE-2015-1915": {"epss_score": 0.00275, "epss_percentile": 0.50693}, "CVE-2015-1916": {"epss_score": 0.00633, "epss_percentile": 0.69773}, "CVE-2015-1917": {"epss_score": 0.0023, "epss_percentile": 0.45669}, "CVE-2015-1919": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2015-1920": {"epss_score": 0.18392, "epss_percentile": 0.9501}, "CVE-2015-1921": {"epss_score": 0.00228, "epss_percentile": 0.45491}, "CVE-2015-1922": {"epss_score": 0.00227, "epss_percentile": 0.45425}, "CVE-2015-1923": {"epss_score": 0.09617, "epss_percentile": 0.92623}, "CVE-2015-1924": {"epss_score": 0.01424, "epss_percentile": 0.80192}, "CVE-2015-1925": {"epss_score": 0.01424, "epss_percentile": 0.80192}, "CVE-2015-1926": {"epss_score": 0.00149, "epss_percentile": 0.35982}, "CVE-2015-1927": {"epss_score": 0.0058, "epss_percentile": 0.68244}, "CVE-2015-1928": {"epss_score": 0.00303, "epss_percentile": 0.53237}, "CVE-2015-1929": {"epss_score": 0.01424, "epss_percentile": 0.80192}, "CVE-2015-1930": {"epss_score": 0.70041, "epss_percentile": 0.98613}, "CVE-2015-1931": {"epss_score": 0.0005, "epss_percentile": 0.15842}, "CVE-2015-1932": {"epss_score": 0.00376, "epss_percentile": 0.5868}, "CVE-2015-1933": {"epss_score": 0.00079, "epss_percentile": 0.2399}, "CVE-2015-1934": {"epss_score": 0.00236, "epss_percentile": 0.46422}, "CVE-2015-1935": {"epss_score": 0.03171, "epss_percentile": 0.86547}, "CVE-2015-1936": {"epss_score": 0.00311, "epss_percentile": 0.53931}, "CVE-2015-1937": {"epss_score": 0.00769, "epss_percentile": 0.72994}, "CVE-2015-1938": {"epss_score": 0.1434, "epss_percentile": 0.94191}, "CVE-2015-1941": {"epss_score": 0.0423, "epss_percentile": 0.88422}, "CVE-2015-1942": {"epss_score": 0.02465, "epss_percentile": 0.84835}, "CVE-2015-1943": {"epss_score": 0.00939, "epss_percentile": 0.7572}, "CVE-2015-1944": {"epss_score": 0.00162, "epss_percentile": 0.37634}, "CVE-2015-1945": {"epss_score": 0.00348, "epss_percentile": 0.56819}, "CVE-2015-1946": {"epss_score": 0.00058, "epss_percentile": 0.18407}, "CVE-2015-1947": {"epss_score": 0.00055, "epss_percentile": 0.17528}, "CVE-2015-1948": {"epss_score": 0.01424, "epss_percentile": 0.80192}, "CVE-2015-1949": {"epss_score": 0.14366, "epss_percentile": 0.94194}, "CVE-2015-1950": {"epss_score": 0.00075, "epss_percentile": 0.22893}, "CVE-2015-1951": {"epss_score": 0.00057, "epss_percentile": 0.18046}, "CVE-2015-1952": {"epss_score": 0.00129, "epss_percentile": 0.33109}, "CVE-2015-1953": {"epss_score": 0.01424, "epss_percentile": 0.80192}, "CVE-2015-1954": {"epss_score": 0.0111, "epss_percentile": 0.77664}, "CVE-2015-1955": {"epss_score": 0.00994, "epss_percentile": 0.76428}, "CVE-2015-1956": {"epss_score": 0.00994, "epss_percentile": 0.76428}, "CVE-2015-1957": {"epss_score": 0.0013, "epss_percentile": 0.33331}, "CVE-2015-1958": {"epss_score": 0.00994, "epss_percentile": 0.76428}, "CVE-2015-1959": {"epss_score": 0.00049, "epss_percentile": 0.1549}, "CVE-2015-1961": {"epss_score": 0.00216, "epss_percentile": 0.44194}, "CVE-2015-1962": {"epss_score": 0.0111, "epss_percentile": 0.77664}, "CVE-2015-1963": {"epss_score": 0.0111, "epss_percentile": 0.77664}, "CVE-2015-1964": {"epss_score": 0.0111, "epss_percentile": 0.77664}, "CVE-2015-1965": {"epss_score": 0.0111, "epss_percentile": 0.77664}, "CVE-2015-1966": {"epss_score": 0.00366, "epss_percentile": 0.58063}, "CVE-2015-1967": {"epss_score": 0.00207, "epss_percentile": 0.43162}, "CVE-2015-1968": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-1969": {"epss_score": 0.00227, "epss_percentile": 0.454}, "CVE-2015-1970": {"epss_score": 0.00057, "epss_percentile": 0.18046}, "CVE-2015-1971": {"epss_score": 0.00249, "epss_percentile": 0.4806}, "CVE-2015-1972": {"epss_score": 0.00342, "epss_percentile": 0.56399}, "CVE-2015-1974": {"epss_score": 0.00304, "epss_percentile": 0.53291}, "CVE-2015-1975": {"epss_score": 0.00087, "epss_percentile": 0.25612}, "CVE-2015-1976": {"epss_score": 0.00078, "epss_percentile": 0.23598}, "CVE-2015-1977": {"epss_score": 0.00184, "epss_percentile": 0.40373}, "CVE-2015-1978": {"epss_score": 0.00374, "epss_percentile": 0.58542}, "CVE-2015-1979": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-1980": {"epss_score": 0.00154, "epss_percentile": 0.36652}, "CVE-2015-1981": {"epss_score": 0.00295, "epss_percentile": 0.525}, "CVE-2015-1982": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2015-1983": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-1984": {"epss_score": 0.0014, "epss_percentile": 0.34785}, "CVE-2015-1985": {"epss_score": 0.00041, "epss_percentile": 0.12334}, "CVE-2015-1986": {"epss_score": 0.25034, "epss_percentile": 0.95981}, "CVE-2015-1987": {"epss_score": 0.00994, "epss_percentile": 0.76428}, "CVE-2015-1988": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-1989": {"epss_score": 0.00277, "epss_percentile": 0.50779}, "CVE-2015-1992": {"epss_score": 0.00053, "epss_percentile": 0.16844}, "CVE-2015-1993": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2015-1994": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2015-1995": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2015-1996": {"epss_score": 0.00057, "epss_percentile": 0.18046}, "CVE-2015-1997": {"epss_score": 0.00103, "epss_percentile": 0.28976}, "CVE-2015-1999": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2015-20001": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2015-20019": {"epss_score": 0.00231, "epss_percentile": 0.4578}, "CVE-2015-20067": {"epss_score": 0.19119, "epss_percentile": 0.95132}, "CVE-2015-20105": {"epss_score": 0.00246, "epss_percentile": 0.47801}, "CVE-2015-20106": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2015-20107": {"epss_score": 0.00872, "epss_percentile": 0.74734}, "CVE-2015-20108": {"epss_score": 0.00329, "epss_percentile": 0.55383}, "CVE-2015-20109": {"epss_score": 0.00029, "epss_percentile": 0.07951}, "CVE-2015-20110": {"epss_score": 0.00214, "epss_percentile": 0.43969}, "CVE-2015-20111": {"epss_score": 0.01938, "epss_percentile": 0.82965}, "CVE-2015-20112": {"epss_score": 9e-05, "epss_percentile": 0.0068}, "CVE-2015-2000": {"epss_score": 0.01095, "epss_percentile": 0.77503}, "CVE-2015-2001": {"epss_score": 0.01095, "epss_percentile": 0.77503}, "CVE-2015-2002": {"epss_score": 0.01095, "epss_percentile": 0.77503}, "CVE-2015-2003": {"epss_score": 0.01095, "epss_percentile": 0.77503}, "CVE-2015-2004": {"epss_score": 0.01095, "epss_percentile": 0.77503}, "CVE-2015-2005": {"epss_score": 0.00207, "epss_percentile": 0.43148}, "CVE-2015-2007": {"epss_score": 0.00172, "epss_percentile": 0.38932}, "CVE-2015-2008": {"epss_score": 0.0019, "epss_percentile": 0.41123}, "CVE-2015-2009": {"epss_score": 0.00148, "epss_percentile": 0.35862}, "CVE-2015-2011": {"epss_score": 0.01027, "epss_percentile": 0.76807}, "CVE-2015-2012": {"epss_score": 0.00039, "epss_percentile": 0.11629}, "CVE-2015-2013": {"epss_score": 0.00594, "epss_percentile": 0.68675}, "CVE-2015-2014": {"epss_score": 0.00201, "epss_percentile": 0.42329}, "CVE-2015-2015": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2015-2016": {"epss_score": 0.00862, "epss_percentile": 0.74576}, "CVE-2015-2017": {"epss_score": 0.0035, "epss_percentile": 0.56937}, "CVE-2015-2018": {"epss_score": 0.00146, "epss_percentile": 0.35552}, "CVE-2015-2019": {"epss_score": 0.00085, "epss_percentile": 0.25148}, "CVE-2015-2020": {"epss_score": 0.01219, "epss_percentile": 0.78616}, "CVE-2015-2023": {"epss_score": 0.00161, "epss_percentile": 0.37543}, "CVE-2015-2025": {"epss_score": 0.00254, "epss_percentile": 0.48513}, "CVE-2015-2026": {"epss_score": 0.00101, "epss_percentile": 0.28639}, "CVE-2015-2027": {"epss_score": 0.00135, "epss_percentile": 0.34044}, "CVE-2015-2028": {"epss_score": 0.00246, "epss_percentile": 0.47784}, "CVE-2015-2029": {"epss_score": 0.00246, "epss_percentile": 0.47784}, "CVE-2015-2030": {"epss_score": 0.00254, "epss_percentile": 0.48513}, "CVE-2015-2031": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2015-2033": {"epss_score": 0.02536, "epss_percentile": 0.85038}, "CVE-2015-2034": {"epss_score": 0.0062, "epss_percentile": 0.69445}, "CVE-2015-2035": {"epss_score": 0.00613, "epss_percentile": 0.69242}, "CVE-2015-2039": {"epss_score": 0.00102, "epss_percentile": 0.28812}, "CVE-2015-2040": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2015-2041": {"epss_score": 0.00065, "epss_percentile": 0.20674}, "CVE-2015-2042": {"epss_score": 0.00056, "epss_percentile": 0.17795}, "CVE-2015-2043": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2015-2044": {"epss_score": 0.00082, "epss_percentile": 0.24423}, "CVE-2015-2045": {"epss_score": 0.00076, "epss_percentile": 0.23277}, "CVE-2015-2046": {"epss_score": 0.00374, "epss_percentile": 0.58588}, "CVE-2015-2047": {"epss_score": 0.00766, "epss_percentile": 0.72941}, "CVE-2015-2048": {"epss_score": 0.00068, "epss_percentile": 0.21339}, "CVE-2015-2049": {"epss_score": 0.82874, "epss_percentile": 0.9922}, "CVE-2015-2050": {"epss_score": 0.01209, "epss_percentile": 0.78539}, "CVE-2015-2051": {"epss_score": 0.93226, "epss_percentile": 0.99786}, "CVE-2015-2052": {"epss_score": 0.11647, "epss_percentile": 0.93428}, "CVE-2015-2053": {"epss_score": 0.00245, "epss_percentile": 0.47683}, "CVE-2015-2054": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2015-2055": {"epss_score": 0.20905, "epss_percentile": 0.95437}, "CVE-2015-2058": {"epss_score": 0.00483, "epss_percentile": 0.64619}, "CVE-2015-2059": {"epss_score": 0.00832, "epss_percentile": 0.74071}, "CVE-2015-2060": {"epss_score": 0.09239, "epss_percentile": 0.92462}, "CVE-2015-2061": {"epss_score": 0.03381, "epss_percentile": 0.87031}, "CVE-2015-2062": {"epss_score": 0.03168, "epss_percentile": 0.86544}, "CVE-2015-2063": {"epss_score": 0.01103, "epss_percentile": 0.77594}, "CVE-2015-2064": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-2065": {"epss_score": 0.80939, "epss_percentile": 0.99113}, "CVE-2015-2066": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2015-2067": {"epss_score": 0.82764, "epss_percentile": 0.99213}, "CVE-2015-2068": {"epss_score": 0.05406, "epss_percentile": 0.89838}, "CVE-2015-2069": {"epss_score": 0.00198, "epss_percentile": 0.42023}, "CVE-2015-2070": {"epss_score": 0.02121, "epss_percentile": 0.83676}, "CVE-2015-2071": {"epss_score": 0.14946, "epss_percentile": 0.94332}, "CVE-2015-2072": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-2073": {"epss_score": 0.02344, "epss_percentile": 0.84446}, "CVE-2015-2074": {"epss_score": 0.02139, "epss_percentile": 0.83742}, "CVE-2015-2075": {"epss_score": 0.01189, "epss_percentile": 0.78373}, "CVE-2015-2076": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2015-2077": {"epss_score": 0.02084, "epss_percentile": 0.83544}, "CVE-2015-2078": {"epss_score": 0.0059, "epss_percentile": 0.68555}, "CVE-2015-2079": {"epss_score": 0.00867, "epss_percentile": 0.74661}, "CVE-2015-2080": {"epss_score": 0.92414, "epss_percentile": 0.99713}, "CVE-2015-2081": {"epss_score": 0.01901, "epss_percentile": 0.8278}, "CVE-2015-2082": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2015-2083": {"epss_score": 0.00118, "epss_percentile": 0.31391}, "CVE-2015-2084": {"epss_score": 0.00676, "epss_percentile": 0.70933}, "CVE-2015-2086": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-2087": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2015-2088": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-2089": {"epss_score": 0.00095, "epss_percentile": 0.27208}, "CVE-2015-2090": {"epss_score": 0.04277, "epss_percentile": 0.88483}, "CVE-2015-2091": {"epss_score": 0.00714, "epss_percentile": 0.71822}, "CVE-2015-2092": {"epss_score": 0.02332, "epss_percentile": 0.84408}, "CVE-2015-2093": {"epss_score": 0.03241, "epss_percentile": 0.86732}, "CVE-2015-2094": {"epss_score": 0.57446, "epss_percentile": 0.98063}, "CVE-2015-2095": {"epss_score": 0.03241, "epss_percentile": 0.86732}, "CVE-2015-2096": {"epss_score": 0.01792, "epss_percentile": 0.82286}, "CVE-2015-2097": {"epss_score": 0.46293, "epss_percentile": 0.9754}, "CVE-2015-2098": {"epss_score": 0.41508, "epss_percentile": 0.97279}, "CVE-2015-2099": {"epss_score": 0.2007, "epss_percentile": 0.95285}, "CVE-2015-2100": {"epss_score": 0.03201, "epss_percentile": 0.86623}, "CVE-2015-2101": {"epss_score": 0.00494, "epss_percentile": 0.65088}, "CVE-2015-2102": {"epss_score": 0.03237, "epss_percentile": 0.86707}, "CVE-2015-2103": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2015-2106": {"epss_score": 0.00616, "epss_percentile": 0.69327}, "CVE-2015-2107": {"epss_score": 0.0003, "epss_percentile": 0.08193}, "CVE-2015-2108": {"epss_score": 0.00181, "epss_percentile": 0.40079}, "CVE-2015-2109": {"epss_score": 0.00563, "epss_percentile": 0.67709}, "CVE-2015-2110": {"epss_score": 0.33755, "epss_percentile": 0.96801}, "CVE-2015-2111": {"epss_score": 0.00145, "epss_percentile": 0.35499}, "CVE-2015-2112": {"epss_score": 0.00645, "epss_percentile": 0.70122}, "CVE-2015-2113": {"epss_score": 0.28201, "epss_percentile": 0.96331}, "CVE-2015-2114": {"epss_score": 0.00336, "epss_percentile": 0.55999}, "CVE-2015-2115": {"epss_score": 0.00098, "epss_percentile": 0.27799}, "CVE-2015-2116": {"epss_score": 0.0082, "epss_percentile": 0.73875}, "CVE-2015-2117": {"epss_score": 0.1015, "epss_percentile": 0.92865}, "CVE-2015-2118": {"epss_score": 0.002, "epss_percentile": 0.42259}, "CVE-2015-2120": {"epss_score": 0.01416, "epss_percentile": 0.8014}, "CVE-2015-2121": {"epss_score": 0.01113, "epss_percentile": 0.77683}, "CVE-2015-2122": {"epss_score": 0.01441, "epss_percentile": 0.80305}, "CVE-2015-2123": {"epss_score": 0.002, "epss_percentile": 0.42206}, "CVE-2015-2124": {"epss_score": 0.00065, "epss_percentile": 0.20626}, "CVE-2015-2125": {"epss_score": 0.31032, "epss_percentile": 0.96584}, "CVE-2015-2126": {"epss_score": 0.00046, "epss_percentile": 0.14078}, "CVE-2015-2132": {"epss_score": 0.00052, "epss_percentile": 0.16614}, "CVE-2015-2134": {"epss_score": 0.00076, "epss_percentile": 0.231}, "CVE-2015-2135": {"epss_score": 0.25873, "epss_percentile": 0.96087}, "CVE-2015-2136": {"epss_score": 0.00139, "epss_percentile": 0.34639}, "CVE-2015-2137": {"epss_score": 0.22002, "epss_percentile": 0.95583}, "CVE-2015-2139": {"epss_score": 0.00213, "epss_percentile": 0.43931}, "CVE-2015-2140": {"epss_score": 0.00269, "epss_percentile": 0.50152}, "CVE-2015-2141": {"epss_score": 0.00429, "epss_percentile": 0.61982}, "CVE-2015-2142": {"epss_score": 0.00156, "epss_percentile": 0.37012}, "CVE-2015-2143": {"epss_score": 0.00195, "epss_percentile": 0.41664}, "CVE-2015-2144": {"epss_score": 0.00183, "epss_percentile": 0.40321}, "CVE-2015-2145": {"epss_score": 0.00278, "epss_percentile": 0.5086}, "CVE-2015-2146": {"epss_score": 0.00433, "epss_percentile": 0.62174}, "CVE-2015-2147": {"epss_score": 0.00368, "epss_percentile": 0.58218}, "CVE-2015-2148": {"epss_score": 0.00171, "epss_percentile": 0.38899}, "CVE-2015-2149": {"epss_score": 0.00297, "epss_percentile": 0.52684}, "CVE-2015-2150": {"epss_score": 0.00109, "epss_percentile": 0.30072}, "CVE-2015-2151": {"epss_score": 0.00235, "epss_percentile": 0.46336}, "CVE-2015-2152": {"epss_score": 0.00076, "epss_percentile": 0.23086}, "CVE-2015-2153": {"epss_score": 0.13977, "epss_percentile": 0.94104}, "CVE-2015-2154": {"epss_score": 0.01896, "epss_percentile": 0.82754}, "CVE-2015-2155": {"epss_score": 0.04982, "epss_percentile": 0.89361}, "CVE-2015-2156": {"epss_score": 0.00865, "epss_percentile": 0.74622}, "CVE-2015-2157": {"epss_score": 0.00267, "epss_percentile": 0.50007}, "CVE-2015-2158": {"epss_score": 0.00406, "epss_percentile": 0.60514}, "CVE-2015-2165": {"epss_score": 0.00284, "epss_percentile": 0.51471}, "CVE-2015-2166": {"epss_score": 0.73601, "epss_percentile": 0.98763}, "CVE-2015-2167": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2015-2169": {"epss_score": 0.03078, "epss_percentile": 0.86367}, "CVE-2015-2170": {"epss_score": 0.00772, "epss_percentile": 0.73045}, "CVE-2015-2171": {"epss_score": 0.00555, "epss_percentile": 0.67477}, "CVE-2015-2172": {"epss_score": 0.01762, "epss_percentile": 0.82152}, "CVE-2015-2177": {"epss_score": 0.50636, "epss_percentile": 0.97743}, "CVE-2015-2179": {"epss_score": 0.00051, "epss_percentile": 0.16292}, "CVE-2015-2180": {"epss_score": 0.02743, "epss_percentile": 0.85566}, "CVE-2015-2181": {"epss_score": 0.00764, "epss_percentile": 0.72908}, "CVE-2015-2182": {"epss_score": 0.10728, "epss_percentile": 0.93085}, "CVE-2015-2183": {"epss_score": 0.03863, "epss_percentile": 0.87869}, "CVE-2015-2184": {"epss_score": 0.11468, "epss_percentile": 0.93376}, "CVE-2015-2186": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2015-2187": {"epss_score": 0.00251, "epss_percentile": 0.48258}, "CVE-2015-2188": {"epss_score": 0.00344, "epss_percentile": 0.56536}, "CVE-2015-2189": {"epss_score": 0.00295, "epss_percentile": 0.52527}, "CVE-2015-2190": {"epss_score": 0.00208, "epss_percentile": 0.43283}, "CVE-2015-2191": {"epss_score": 0.03288, "epss_percentile": 0.86832}, "CVE-2015-2192": {"epss_score": 0.00548, "epss_percentile": 0.67286}, "CVE-2015-2194": {"epss_score": 0.02449, "epss_percentile": 0.84776}, "CVE-2015-2195": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2015-2196": {"epss_score": 0.02862, "epss_percentile": 0.85853}, "CVE-2015-2197": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-2198": {"epss_score": 0.00509, "epss_percentile": 0.65748}, "CVE-2015-2199": {"epss_score": 0.01039, "epss_percentile": 0.76949}, "CVE-2015-2201": {"epss_score": 0.00446, "epss_percentile": 0.62901}, "CVE-2015-2202": {"epss_score": 0.00423, "epss_percentile": 0.6158}, "CVE-2015-2203": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2015-2204": {"epss_score": 0.00583, "epss_percentile": 0.68354}, "CVE-2015-2206": {"epss_score": 0.00916, "epss_percentile": 0.75417}, "CVE-2015-2207": {"epss_score": 0.00152, "epss_percentile": 0.36374}, "CVE-2015-2208": {"epss_score": 0.88268, "epss_percentile": 0.99464}, "CVE-2015-2209": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2015-2210": {"epss_score": 0.00139, "epss_percentile": 0.34664}, "CVE-2015-2213": {"epss_score": 0.21244, "epss_percentile": 0.95485}, "CVE-2015-2214": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2015-2215": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2015-2216": {"epss_score": 0.03471, "epss_percentile": 0.87198}, "CVE-2015-2217": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2015-2218": {"epss_score": 0.0745, "epss_percentile": 0.91478}, "CVE-2015-2219": {"epss_score": 0.29577, "epss_percentile": 0.96458}, "CVE-2015-2220": {"epss_score": 0.00198, "epss_percentile": 0.42023}, "CVE-2015-2221": {"epss_score": 0.00886, "epss_percentile": 0.74963}, "CVE-2015-2222": {"epss_score": 0.00772, "epss_percentile": 0.73045}, "CVE-2015-2223": {"epss_score": 0.01895, "epss_percentile": 0.82747}, "CVE-2015-2230": {"epss_score": 0.00215, "epss_percentile": 0.44058}, "CVE-2015-2233": {"epss_score": 0.0008, "epss_percentile": 0.24135}, "CVE-2015-2234": {"epss_score": 0.00026, "epss_percentile": 0.06731}, "CVE-2015-2237": {"epss_score": 0.00943, "epss_percentile": 0.7578}, "CVE-2015-2238": {"epss_score": 0.00107, "epss_percentile": 0.29654}, "CVE-2015-2239": {"epss_score": 0.00361, "epss_percentile": 0.57737}, "CVE-2015-2241": {"epss_score": 0.00257, "epss_percentile": 0.48886}, "CVE-2015-2242": {"epss_score": 0.00326, "epss_percentile": 0.55077}, "CVE-2015-2243": {"epss_score": 0.00569, "epss_percentile": 0.67934}, "CVE-2015-2244": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2015-2245": {"epss_score": 0.00321, "epss_percentile": 0.54733}, "CVE-2015-2246": {"epss_score": 0.00089, "epss_percentile": 0.25873}, "CVE-2015-2247": {"epss_score": 0.00145, "epss_percentile": 0.35431}, "CVE-2015-2248": {"epss_score": 0.02685, "epss_percentile": 0.85426}, "CVE-2015-2249": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2015-2250": {"epss_score": 0.00393, "epss_percentile": 0.5972}, "CVE-2015-2251": {"epss_score": 0.00137, "epss_percentile": 0.34324}, "CVE-2015-2252": {"epss_score": 0.00469, "epss_percentile": 0.63916}, "CVE-2015-2253": {"epss_score": 0.00075, "epss_percentile": 0.23049}, "CVE-2015-2254": {"epss_score": 0.00277, "epss_percentile": 0.50809}, "CVE-2015-2255": {"epss_score": 0.00259, "epss_percentile": 0.49069}, "CVE-2015-2263": {"epss_score": 0.00036, "epss_percentile": 0.10542}, "CVE-2015-2264": {"epss_score": 0.0009, "epss_percentile": 0.2606}, "CVE-2015-2265": {"epss_score": 0.05804, "epss_percentile": 0.90221}, "CVE-2015-2266": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2015-2267": {"epss_score": 0.0019, "epss_percentile": 0.41096}, "CVE-2015-2268": {"epss_score": 0.0059, "epss_percentile": 0.68551}, "CVE-2015-2269": {"epss_score": 0.00534, "epss_percentile": 0.66799}, "CVE-2015-2270": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2015-2271": {"epss_score": 0.00207, "epss_percentile": 0.43078}, "CVE-2015-2272": {"epss_score": 0.00284, "epss_percentile": 0.51451}, "CVE-2015-2273": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-2275": {"epss_score": 0.13963, "epss_percentile": 0.94102}, "CVE-2015-2278": {"epss_score": 0.00724, "epss_percentile": 0.72028}, "CVE-2015-2279": {"epss_score": 0.42161, "epss_percentile": 0.97315}, "CVE-2015-2280": {"epss_score": 0.29604, "epss_percentile": 0.96461}, "CVE-2015-2281": {"epss_score": 0.31617, "epss_percentile": 0.96639}, "CVE-2015-2282": {"epss_score": 0.00915, "epss_percentile": 0.75408}, "CVE-2015-2284": {"epss_score": 0.76296, "epss_percentile": 0.98884}, "CVE-2015-2285": {"epss_score": 0.00667, "epss_percentile": 0.70707}, "CVE-2015-2286": {"epss_score": 0.00336, "epss_percentile": 0.55919}, "CVE-2015-2289": {"epss_score": 0.00338, "epss_percentile": 0.56135}, "CVE-2015-2291": {"epss_score": 0.03181, "epss_percentile": 0.8658}, "CVE-2015-2292": {"epss_score": 0.06774, "epss_percentile": 0.91018}, "CVE-2015-2293": {"epss_score": 0.01054, "epss_percentile": 0.7711}, "CVE-2015-2294": {"epss_score": 0.01313, "epss_percentile": 0.7938}, "CVE-2015-2295": {"epss_score": 0.34591, "epss_percentile": 0.96859}, "CVE-2015-2296": {"epss_score": 0.01945, "epss_percentile": 0.82999}, "CVE-2015-2297": {"epss_score": 0.00565, "epss_percentile": 0.6778}, "CVE-2015-2298": {"epss_score": 0.00171, "epss_percentile": 0.38882}, "CVE-2015-2301": {"epss_score": 0.12744, "epss_percentile": 0.93763}, "CVE-2015-2304": {"epss_score": 0.03517, "epss_percentile": 0.87275}, "CVE-2015-2305": {"epss_score": 0.30482, "epss_percentile": 0.96545}, "CVE-2015-2308": {"epss_score": 0.00543, "epss_percentile": 0.671}, "CVE-2015-2310": {"epss_score": 0.00488, "epss_percentile": 0.64831}, "CVE-2015-2311": {"epss_score": 0.01055, "epss_percentile": 0.77117}, "CVE-2015-2312": {"epss_score": 0.00718, "epss_percentile": 0.71916}, "CVE-2015-2313": {"epss_score": 0.00657, "epss_percentile": 0.70462}, "CVE-2015-2314": {"epss_score": 0.22718, "epss_percentile": 0.95672}, "CVE-2015-2315": {"epss_score": 0.07838, "epss_percentile": 0.91705}, "CVE-2015-2316": {"epss_score": 0.01995, "epss_percentile": 0.8319}, "CVE-2015-2317": {"epss_score": 0.04666, "epss_percentile": 0.88981}, "CVE-2015-2318": {"epss_score": 0.0129, "epss_percentile": 0.79216}, "CVE-2015-2319": {"epss_score": 0.00874, "epss_percentile": 0.74757}, "CVE-2015-2320": {"epss_score": 0.04829, "epss_percentile": 0.89189}, "CVE-2015-2321": {"epss_score": 0.01518, "epss_percentile": 0.80811}, "CVE-2015-2323": {"epss_score": 0.00288, "epss_percentile": 0.51911}, "CVE-2015-2324": {"epss_score": 0.00116, "epss_percentile": 0.3115}, "CVE-2015-2325": {"epss_score": 0.00359, "epss_percentile": 0.57606}, "CVE-2015-2326": {"epss_score": 0.0059, "epss_percentile": 0.68545}, "CVE-2015-2327": {"epss_score": 0.05327, "epss_percentile": 0.89736}, "CVE-2015-2328": {"epss_score": 0.05132, "epss_percentile": 0.89531}, "CVE-2015-2329": {"epss_score": 0.00241, "epss_percentile": 0.47281}, "CVE-2015-2330": {"epss_score": 0.00322, "epss_percentile": 0.54785}, "CVE-2015-2331": {"epss_score": 0.4271, "epss_percentile": 0.97348}, "CVE-2015-2332": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-2333": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-2334": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-2335": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2015-2336": {"epss_score": 0.00342, "epss_percentile": 0.56373}, "CVE-2015-2337": {"epss_score": 0.00342, "epss_percentile": 0.56373}, "CVE-2015-2338": {"epss_score": 0.00231, "epss_percentile": 0.45842}, "CVE-2015-2339": {"epss_score": 0.00231, "epss_percentile": 0.45842}, "CVE-2015-2340": {"epss_score": 0.00231, "epss_percentile": 0.45842}, "CVE-2015-2341": {"epss_score": 0.0074, "epss_percentile": 0.72409}, "CVE-2015-2342": {"epss_score": 0.92031, "epss_percentile": 0.99686}, "CVE-2015-2344": {"epss_score": 0.00105, "epss_percentile": 0.29306}, "CVE-2015-2346": {"epss_score": 0.00123, "epss_percentile": 0.32288}, "CVE-2015-2347": {"epss_score": 0.00155, "epss_percentile": 0.36822}, "CVE-2015-2348": {"epss_score": 0.07236, "epss_percentile": 0.9134}, "CVE-2015-2349": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-2350": {"epss_score": 0.00186, "epss_percentile": 0.40597}, "CVE-2015-2351": {"epss_score": 0.004, "epss_percentile": 0.60191}, "CVE-2015-2352": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2015-2359": {"epss_score": 0.12149, "epss_percentile": 0.93584}, "CVE-2015-2360": {"epss_score": 0.13229, "epss_percentile": 0.93905}, "CVE-2015-2361": {"epss_score": 0.0055, "epss_percentile": 0.67345}, "CVE-2015-2362": {"epss_score": 0.00702, "epss_percentile": 0.71525}, "CVE-2015-2363": {"epss_score": 0.00985, "epss_percentile": 0.76327}, "CVE-2015-2364": {"epss_score": 0.00985, "epss_percentile": 0.76327}, "CVE-2015-2365": {"epss_score": 0.25178, "epss_percentile": 0.95994}, "CVE-2015-2366": {"epss_score": 0.25178, "epss_percentile": 0.95994}, "CVE-2015-2367": {"epss_score": 0.03202, "epss_percentile": 0.86625}, "CVE-2015-2368": {"epss_score": 0.07141, "epss_percentile": 0.91279}, "CVE-2015-2369": {"epss_score": 0.06187, "epss_percentile": 0.90545}, "CVE-2015-2370": {"epss_score": 0.19701, "epss_percentile": 0.95229}, "CVE-2015-2371": {"epss_score": 0.00734, "epss_percentile": 0.72253}, "CVE-2015-2372": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-2373": {"epss_score": 0.69243, "epss_percentile": 0.98581}, "CVE-2015-2374": {"epss_score": 0.02079, "epss_percentile": 0.83526}, "CVE-2015-2375": {"epss_score": 0.15727, "epss_percentile": 0.94493}, "CVE-2015-2376": {"epss_score": 0.37547, "epss_percentile": 0.97056}, "CVE-2015-2377": {"epss_score": 0.37547, "epss_percentile": 0.97056}, "CVE-2015-2378": {"epss_score": 0.06187, "epss_percentile": 0.90545}, "CVE-2015-2379": {"epss_score": 0.31321, "epss_percentile": 0.9661}, "CVE-2015-2380": {"epss_score": 0.31321, "epss_percentile": 0.9661}, "CVE-2015-2381": {"epss_score": 0.0148, "epss_percentile": 0.80564}, "CVE-2015-2382": {"epss_score": 0.0148, "epss_percentile": 0.80564}, "CVE-2015-2383": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2384": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2385": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2387": {"epss_score": 0.31208, "epss_percentile": 0.96601}, "CVE-2015-2388": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2389": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2390": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2391": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2397": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2398": {"epss_score": 0.19808, "epss_percentile": 0.95245}, "CVE-2015-2401": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2402": {"epss_score": 0.079, "epss_percentile": 0.91754}, "CVE-2015-2403": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2404": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2406": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2408": {"epss_score": 0.18341, "epss_percentile": 0.94999}, "CVE-2015-2410": {"epss_score": 0.23093, "epss_percentile": 0.95733}, "CVE-2015-2411": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2412": {"epss_score": 0.255, "epss_percentile": 0.96035}, "CVE-2015-2413": {"epss_score": 0.25791, "epss_percentile": 0.9607}, "CVE-2015-2414": {"epss_score": 0.23093, "epss_percentile": 0.95733}, "CVE-2015-2415": {"epss_score": 0.37547, "epss_percentile": 0.97056}, "CVE-2015-2416": {"epss_score": 0.15508, "epss_percentile": 0.94442}, "CVE-2015-2417": {"epss_score": 0.15508, "epss_percentile": 0.94442}, "CVE-2015-2418": {"epss_score": 0.00976, "epss_percentile": 0.7621}, "CVE-2015-2419": {"epss_score": 0.80247, "epss_percentile": 0.99078}, "CVE-2015-2420": {"epss_score": 0.12584, "epss_percentile": 0.93722}, "CVE-2015-2421": {"epss_score": 0.14942, "epss_percentile": 0.9433}, "CVE-2015-2422": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2423": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2015-2424": {"epss_score": 0.76623, "epss_percentile": 0.98898}, "CVE-2015-2425": {"epss_score": 0.31039, "epss_percentile": 0.96584}, "CVE-2015-2426": {"epss_score": 0.91616, "epss_percentile": 0.99658}, "CVE-2015-2427": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-2428": {"epss_score": 0.01078, "epss_percentile": 0.77349}, "CVE-2015-2429": {"epss_score": 0.05306, "epss_percentile": 0.89712}, "CVE-2015-2430": {"epss_score": 0.05306, "epss_percentile": 0.89712}, "CVE-2015-2431": {"epss_score": 0.61988, "epss_percentile": 0.98271}, "CVE-2015-2432": {"epss_score": 0.47332, "epss_percentile": 0.97583}, "CVE-2015-2433": {"epss_score": 0.15861, "epss_percentile": 0.94521}, "CVE-2015-2434": {"epss_score": 0.25791, "epss_percentile": 0.9607}, "CVE-2015-2435": {"epss_score": 0.33527, "epss_percentile": 0.96782}, "CVE-2015-2440": {"epss_score": 0.1263, "epss_percentile": 0.93734}, "CVE-2015-2441": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-2442": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-2443": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-2444": {"epss_score": 0.25579, "epss_percentile": 0.96047}, "CVE-2015-2445": {"epss_score": 0.14942, "epss_percentile": 0.9433}, "CVE-2015-2446": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-2447": {"epss_score": 0.28828, "epss_percentile": 0.96391}, "CVE-2015-2448": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-2449": {"epss_score": 0.16623, "epss_percentile": 0.94704}, "CVE-2015-2450": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-2451": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-2452": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-2453": {"epss_score": 0.03826, "epss_percentile": 0.87793}, "CVE-2015-2454": {"epss_score": 0.00955, "epss_percentile": 0.75917}, "CVE-2015-2455": {"epss_score": 0.51954, "epss_percentile": 0.97803}, "CVE-2015-2456": {"epss_score": 0.41519, "epss_percentile": 0.97281}, "CVE-2015-2458": {"epss_score": 0.51507, "epss_percentile": 0.97782}, "CVE-2015-2459": {"epss_score": 0.51507, "epss_percentile": 0.97782}, "CVE-2015-2460": {"epss_score": 0.48614, "epss_percentile": 0.97645}, "CVE-2015-2461": {"epss_score": 0.4107, "epss_percentile": 0.97252}, "CVE-2015-2462": {"epss_score": 0.41519, "epss_percentile": 0.97281}, "CVE-2015-2463": {"epss_score": 0.38619, "epss_percentile": 0.9711}, "CVE-2015-2464": {"epss_score": 0.48098, "epss_percentile": 0.97621}, "CVE-2015-2465": {"epss_score": 0.00562, "epss_percentile": 0.67693}, "CVE-2015-2466": {"epss_score": 0.39116, "epss_percentile": 0.97141}, "CVE-2015-2467": {"epss_score": 0.66699, "epss_percentile": 0.98475}, "CVE-2015-2468": {"epss_score": 0.69466, "epss_percentile": 0.98588}, "CVE-2015-2469": {"epss_score": 0.66699, "epss_percentile": 0.98475}, "CVE-2015-2470": {"epss_score": 0.64129, "epss_percentile": 0.98366}, "CVE-2015-2471": {"epss_score": 0.31532, "epss_percentile": 0.96625}, "CVE-2015-2472": {"epss_score": 0.03307, "epss_percentile": 0.86878}, "CVE-2015-2473": {"epss_score": 0.31771, "epss_percentile": 0.96647}, "CVE-2015-2474": {"epss_score": 0.34555, "epss_percentile": 0.96856}, "CVE-2015-2475": {"epss_score": 0.10266, "epss_percentile": 0.92919}, "CVE-2015-2476": {"epss_score": 0.27914, "epss_percentile": 0.96295}, "CVE-2015-2477": {"epss_score": 0.37547, "epss_percentile": 0.97056}, "CVE-2015-2478": {"epss_score": 0.02205, "epss_percentile": 0.83999}, "CVE-2015-2479": {"epss_score": 0.39116, "epss_percentile": 0.97141}, "CVE-2015-2480": {"epss_score": 0.39116, "epss_percentile": 0.97141}, "CVE-2015-2481": {"epss_score": 0.39116, "epss_percentile": 0.97141}, "CVE-2015-2482": {"epss_score": 0.64097, "epss_percentile": 0.98365}, "CVE-2015-2483": {"epss_score": 0.21147, "epss_percentile": 0.9547}, "CVE-2015-2484": {"epss_score": 0.21023, "epss_percentile": 0.95453}, "CVE-2015-2485": {"epss_score": 0.14833, "epss_percentile": 0.94299}, "CVE-2015-2486": {"epss_score": 0.14833, "epss_percentile": 0.94299}, "CVE-2015-2487": {"epss_score": 0.20844, "epss_percentile": 0.95426}, "CVE-2015-2489": {"epss_score": 0.08726, "epss_percentile": 0.92229}, "CVE-2015-2490": {"epss_score": 0.20844, "epss_percentile": 0.95426}, "CVE-2015-2491": {"epss_score": 0.20844, "epss_percentile": 0.95426}, "CVE-2015-2492": {"epss_score": 0.20844, "epss_percentile": 0.95426}, "CVE-2015-2493": {"epss_score": 0.20844, "epss_percentile": 0.95426}, "CVE-2015-2494": {"epss_score": 0.14833, "epss_percentile": 0.94299}, "CVE-2015-2498": {"epss_score": 0.12669, "epss_percentile": 0.93744}, "CVE-2015-2499": {"epss_score": 0.12669, "epss_percentile": 0.93744}, "CVE-2015-2500": {"epss_score": 0.14833, "epss_percentile": 0.94299}, "CVE-2015-2501": {"epss_score": 0.14833, "epss_percentile": 0.94299}, "CVE-2015-2502": {"epss_score": 0.22563, "epss_percentile": 0.95651}, "CVE-2015-2503": {"epss_score": 0.19426, "epss_percentile": 0.9518}, "CVE-2015-2504": {"epss_score": 0.31836, "epss_percentile": 0.96654}, "CVE-2015-2505": {"epss_score": 0.14297, "epss_percentile": 0.94181}, "CVE-2015-2506": {"epss_score": 0.23431, "epss_percentile": 0.95777}, "CVE-2015-2507": {"epss_score": 0.08263, "epss_percentile": 0.91957}, "CVE-2015-2508": {"epss_score": 0.0461, "epss_percentile": 0.88914}, "CVE-2015-2509": {"epss_score": 0.87937, "epss_percentile": 0.99451}, "CVE-2015-2510": {"epss_score": 0.70597, "epss_percentile": 0.98637}, "CVE-2015-2511": {"epss_score": 0.0353, "epss_percentile": 0.87301}, "CVE-2015-2512": {"epss_score": 0.0399, "epss_percentile": 0.88071}, "CVE-2015-2513": {"epss_score": 0.23095, "epss_percentile": 0.95734}, "CVE-2015-2514": {"epss_score": 0.23095, "epss_percentile": 0.95734}, "CVE-2015-2515": {"epss_score": 0.42303, "epss_percentile": 0.97324}, "CVE-2015-2516": {"epss_score": 0.12783, "epss_percentile": 0.93772}, "CVE-2015-2517": {"epss_score": 0.04718, "epss_percentile": 0.89045}, "CVE-2015-2518": {"epss_score": 0.04718, "epss_percentile": 0.89045}, "CVE-2015-2519": {"epss_score": 0.27966, "epss_percentile": 0.963}, "CVE-2015-2520": {"epss_score": 0.66829, "epss_percentile": 0.98482}, "CVE-2015-2521": {"epss_score": 0.66829, "epss_percentile": 0.98482}, "CVE-2015-2522": {"epss_score": 0.08627, "epss_percentile": 0.9216}, "CVE-2015-2523": {"epss_score": 0.72021, "epss_percentile": 0.98693}, "CVE-2015-2524": {"epss_score": 0.14807, "epss_percentile": 0.9429}, "CVE-2015-2525": {"epss_score": 0.25271, "epss_percentile": 0.96007}, "CVE-2015-2526": {"epss_score": 0.18356, "epss_percentile": 0.95002}, "CVE-2015-2527": {"epss_score": 0.14919, "epss_percentile": 0.94323}, "CVE-2015-2528": {"epss_score": 0.01436, "epss_percentile": 0.80275}, "CVE-2015-2529": {"epss_score": 0.03285, "epss_percentile": 0.86822}, "CVE-2015-2530": {"epss_score": 0.23095, "epss_percentile": 0.95734}, "CVE-2015-2531": {"epss_score": 0.13171, "epss_percentile": 0.93891}, "CVE-2015-2532": {"epss_score": 0.09615, "epss_percentile": 0.92623}, "CVE-2015-2534": {"epss_score": 0.00597, "epss_percentile": 0.6875}, "CVE-2015-2535": {"epss_score": 0.13757, "epss_percentile": 0.94049}, "CVE-2015-2536": {"epss_score": 0.08963, "epss_percentile": 0.92339}, "CVE-2015-2541": {"epss_score": 0.14833, "epss_percentile": 0.94299}, "CVE-2015-2542": {"epss_score": 0.14833, "epss_percentile": 0.94299}, "CVE-2015-2543": {"epss_score": 0.06935, "epss_percentile": 0.91127}, "CVE-2015-2544": {"epss_score": 0.06935, "epss_percentile": 0.91127}, "CVE-2015-2545": {"epss_score": 0.93446, "epss_percentile": 0.99808}, "CVE-2015-2546": {"epss_score": 0.39933, "epss_percentile": 0.97188}, "CVE-2015-2548": {"epss_score": 0.5952, "epss_percentile": 0.98168}, "CVE-2015-2549": {"epss_score": 0.01519, "epss_percentile": 0.80818}, "CVE-2015-2550": {"epss_score": 0.02205, "epss_percentile": 0.83999}, "CVE-2015-2552": {"epss_score": 0.01455, "epss_percentile": 0.80388}, "CVE-2015-2553": {"epss_score": 0.13323, "epss_percentile": 0.93933}, "CVE-2015-2554": {"epss_score": 0.02213, "epss_percentile": 0.84024}, "CVE-2015-2555": {"epss_score": 0.43025, "epss_percentile": 0.97366}, "CVE-2015-2556": {"epss_score": 0.3567, "epss_percentile": 0.96926}, "CVE-2015-2557": {"epss_score": 0.34582, "epss_percentile": 0.96858}, "CVE-2015-2558": {"epss_score": 0.43025, "epss_percentile": 0.97366}, "CVE-2015-2559": {"epss_score": 0.00452, "epss_percentile": 0.63194}, "CVE-2015-2560": {"epss_score": 0.20364, "epss_percentile": 0.95333}, "CVE-2015-2562": {"epss_score": 0.5373, "epss_percentile": 0.97894}, "CVE-2015-2563": {"epss_score": 0.00517, "epss_percentile": 0.66081}, "CVE-2015-2564": {"epss_score": 0.04008, "epss_percentile": 0.88105}, "CVE-2015-2565": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2015-2566": {"epss_score": 0.00764, "epss_percentile": 0.72894}, "CVE-2015-2567": {"epss_score": 0.00749, "epss_percentile": 0.72599}, "CVE-2015-2568": {"epss_score": 0.03957, "epss_percentile": 0.88006}, "CVE-2015-2570": {"epss_score": 0.00913, "epss_percentile": 0.75369}, "CVE-2015-2571": {"epss_score": 0.00406, "epss_percentile": 0.60549}, "CVE-2015-2572": {"epss_score": 0.00541, "epss_percentile": 0.67051}, "CVE-2015-2573": {"epss_score": 0.00406, "epss_percentile": 0.60549}, "CVE-2015-2574": {"epss_score": 0.00163, "epss_percentile": 0.37795}, "CVE-2015-2575": {"epss_score": 0.01666, "epss_percentile": 0.81653}, "CVE-2015-2576": {"epss_score": 0.00093, "epss_percentile": 0.26726}, "CVE-2015-2577": {"epss_score": 0.00194, "epss_percentile": 0.4156}, "CVE-2015-2578": {"epss_score": 0.01377, "epss_percentile": 0.79844}, "CVE-2015-2579": {"epss_score": 0.00171, "epss_percentile": 0.38822}, "CVE-2015-2580": {"epss_score": 0.00223, "epss_percentile": 0.44852}, "CVE-2015-2581": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2015-2582": {"epss_score": 0.00811, "epss_percentile": 0.73731}, "CVE-2015-2583": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-2584": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-2585": {"epss_score": 0.00355, "epss_percentile": 0.57273}, "CVE-2015-2586": {"epss_score": 0.0066, "epss_percentile": 0.70526}, "CVE-2015-2587": {"epss_score": 0.00351, "epss_percentile": 0.57071}, "CVE-2015-2588": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-2589": {"epss_score": 0.00274, "epss_percentile": 0.50488}, "CVE-2015-2590": {"epss_score": 0.61541, "epss_percentile": 0.98252}, "CVE-2015-2591": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-2592": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-2593": {"epss_score": 0.00089, "epss_percentile": 0.25809}, "CVE-2015-2594": {"epss_score": 0.00134, "epss_percentile": 0.33765}, "CVE-2015-2595": {"epss_score": 0.00375, "epss_percentile": 0.58637}, "CVE-2015-2596": {"epss_score": 0.00417, "epss_percentile": 0.61223}, "CVE-2015-2597": {"epss_score": 0.0012, "epss_percentile": 0.3171}, "CVE-2015-2598": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-2599": {"epss_score": 0.00191, "epss_percentile": 0.41182}, "CVE-2015-2600": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-2601": {"epss_score": 0.02888, "epss_percentile": 0.85914}, "CVE-2015-2602": {"epss_score": 0.00724, "epss_percentile": 0.72031}, "CVE-2015-2603": {"epss_score": 0.00724, "epss_percentile": 0.72031}, "CVE-2015-2604": {"epss_score": 0.00724, "epss_percentile": 0.72031}, "CVE-2015-2605": {"epss_score": 0.00724, "epss_percentile": 0.72031}, "CVE-2015-2606": {"epss_score": 0.00724, "epss_percentile": 0.72031}, "CVE-2015-2607": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-2608": {"epss_score": 0.02469, "epss_percentile": 0.84843}, "CVE-2015-2609": {"epss_score": 0.00253, "epss_percentile": 0.48489}, "CVE-2015-2610": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-2611": {"epss_score": 0.00785, "epss_percentile": 0.73252}, "CVE-2015-2612": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-2613": {"epss_score": 0.03281, "epss_percentile": 0.86815}, "CVE-2015-2614": {"epss_score": 0.00253, "epss_percentile": 0.48489}, "CVE-2015-2615": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-2616": {"epss_score": 0.00253, "epss_percentile": 0.48489}, "CVE-2015-2617": {"epss_score": 0.01073, "epss_percentile": 0.77285}, "CVE-2015-2618": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-2619": {"epss_score": 0.02242, "epss_percentile": 0.84119}, "CVE-2015-2620": {"epss_score": 0.00774, "epss_percentile": 0.73069}, "CVE-2015-2621": {"epss_score": 0.04125, "epss_percentile": 0.88288}, "CVE-2015-2622": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-2623": {"epss_score": 0.00237, "epss_percentile": 0.46705}, "CVE-2015-2624": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-2625": {"epss_score": 0.02888, "epss_percentile": 0.85914}, "CVE-2015-2626": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-2627": {"epss_score": 0.01759, "epss_percentile": 0.82141}, "CVE-2015-2628": {"epss_score": 0.08103, "epss_percentile": 0.9188}, "CVE-2015-2629": {"epss_score": 0.00572, "epss_percentile": 0.68032}, "CVE-2015-2630": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-2631": {"epss_score": 0.00463, "epss_percentile": 0.63665}, "CVE-2015-2632": {"epss_score": 0.01988, "epss_percentile": 0.83165}, "CVE-2015-2633": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2015-2634": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2015-2635": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2015-2636": {"epss_score": 0.00685, "epss_percentile": 0.71137}, "CVE-2015-2637": {"epss_score": 0.02811, "epss_percentile": 0.85722}, "CVE-2015-2638": {"epss_score": 0.06794, "epss_percentile": 0.91031}, "CVE-2015-2639": {"epss_score": 0.00389, "epss_percentile": 0.5941}, "CVE-2015-2640": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-2641": {"epss_score": 0.01014, "epss_percentile": 0.76654}, "CVE-2015-2642": {"epss_score": 0.00129, "epss_percentile": 0.33213}, "CVE-2015-2643": {"epss_score": 0.00598, "epss_percentile": 0.68773}, "CVE-2015-2644": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-2645": {"epss_score": 0.00139, "epss_percentile": 0.34537}, "CVE-2015-2646": {"epss_score": 0.00351, "epss_percentile": 0.57071}, "CVE-2015-2647": {"epss_score": 0.00185, "epss_percentile": 0.40532}, "CVE-2015-2648": {"epss_score": 0.00598, "epss_percentile": 0.68773}, "CVE-2015-2649": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-2650": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-2651": {"epss_score": 0.00173, "epss_percentile": 0.3908}, "CVE-2015-2652": {"epss_score": 0.00367, "epss_percentile": 0.58104}, "CVE-2015-2653": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-2654": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-2655": {"epss_score": 0.00185, "epss_percentile": 0.40532}, "CVE-2015-2656": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-2657": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-2658": {"epss_score": 0.00277, "epss_percentile": 0.50777}, "CVE-2015-2659": {"epss_score": 0.01108, "epss_percentile": 0.77638}, "CVE-2015-2660": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2015-2661": {"epss_score": 0.00171, "epss_percentile": 0.38835}, "CVE-2015-2662": {"epss_score": 0.00223, "epss_percentile": 0.44852}, "CVE-2015-2663": {"epss_score": 0.00153, "epss_percentile": 0.36642}, "CVE-2015-2664": {"epss_score": 0.00159, "epss_percentile": 0.3739}, "CVE-2015-2665": {"epss_score": 0.00432, "epss_percentile": 0.6212}, "CVE-2015-2666": {"epss_score": 0.00103, "epss_percentile": 0.29092}, "CVE-2015-2667": {"epss_score": 0.0016, "epss_percentile": 0.3748}, "CVE-2015-2668": {"epss_score": 0.00772, "epss_percentile": 0.73045}, "CVE-2015-2672": {"epss_score": 0.00042, "epss_percentile": 0.12764}, "CVE-2015-2673": {"epss_score": 0.63767, "epss_percentile": 0.98348}, "CVE-2015-2674": {"epss_score": 0.0034, "epss_percentile": 0.56231}, "CVE-2015-2675": {"epss_score": 0.03052, "epss_percentile": 0.86292}, "CVE-2015-2676": {"epss_score": 0.00174, "epss_percentile": 0.39173}, "CVE-2015-2677": {"epss_score": 0.00257, "epss_percentile": 0.4889}, "CVE-2015-2678": {"epss_score": 0.15727, "epss_percentile": 0.94494}, "CVE-2015-2679": {"epss_score": 0.08867, "epss_percentile": 0.92294}, "CVE-2015-2680": {"epss_score": 0.01789, "epss_percentile": 0.82276}, "CVE-2015-2681": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2015-2682": {"epss_score": 0.3472, "epss_percentile": 0.9687}, "CVE-2015-2683": {"epss_score": 0.03324, "epss_percentile": 0.86918}, "CVE-2015-2684": {"epss_score": 0.00455, "epss_percentile": 0.63299}, "CVE-2015-2686": {"epss_score": 0.00043, "epss_percentile": 0.13272}, "CVE-2015-2687": {"epss_score": 0.00051, "epss_percentile": 0.16246}, "CVE-2015-2688": {"epss_score": 0.00568, "epss_percentile": 0.67887}, "CVE-2015-2689": {"epss_score": 0.00648, "epss_percentile": 0.7022}, "CVE-2015-2690": {"epss_score": 0.00171, "epss_percentile": 0.38859}, "CVE-2015-2692": {"epss_score": 0.00621, "epss_percentile": 0.69474}, "CVE-2015-2694": {"epss_score": 0.00327, "epss_percentile": 0.55109}, "CVE-2015-2695": {"epss_score": 0.06447, "epss_percentile": 0.90762}, "CVE-2015-2696": {"epss_score": 0.08283, "epss_percentile": 0.91968}, "CVE-2015-2697": {"epss_score": 0.06393, "epss_percentile": 0.9072}, "CVE-2015-2698": {"epss_score": 0.01174, "epss_percentile": 0.78244}, "CVE-2015-2701": {"epss_score": 0.0086, "epss_percentile": 0.74525}, "CVE-2015-2702": {"epss_score": 0.00496, "epss_percentile": 0.65165}, "CVE-2015-2703": {"epss_score": 0.00665, "epss_percentile": 0.70663}, "CVE-2015-2704": {"epss_score": 0.0037, "epss_percentile": 0.58281}, "CVE-2015-2706": {"epss_score": 0.01133, "epss_percentile": 0.7788}, "CVE-2015-2708": {"epss_score": 0.01328, "epss_percentile": 0.79501}, "CVE-2015-2709": {"epss_score": 0.01077, "epss_percentile": 0.77332}, "CVE-2015-2710": {"epss_score": 0.02421, "epss_percentile": 0.84704}, "CVE-2015-2711": {"epss_score": 0.00519, "epss_percentile": 0.66174}, "CVE-2015-2712": {"epss_score": 0.03878, "epss_percentile": 0.87892}, "CVE-2015-2713": {"epss_score": 0.01751, "epss_percentile": 0.82099}, "CVE-2015-2714": {"epss_score": 0.00101, "epss_percentile": 0.28584}, "CVE-2015-2715": {"epss_score": 0.01381, "epss_percentile": 0.79868}, "CVE-2015-2716": {"epss_score": 0.055, "epss_percentile": 0.89937}, "CVE-2015-2717": {"epss_score": 0.02421, "epss_percentile": 0.84705}, "CVE-2015-2718": {"epss_score": 0.00118, "epss_percentile": 0.3151}, "CVE-2015-2720": {"epss_score": 0.00077, "epss_percentile": 0.23284}, "CVE-2015-2721": {"epss_score": 0.00607, "epss_percentile": 0.69055}, "CVE-2015-2722": {"epss_score": 0.02313, "epss_percentile": 0.84345}, "CVE-2015-2724": {"epss_score": 0.00912, "epss_percentile": 0.75364}, "CVE-2015-2725": {"epss_score": 0.01627, "epss_percentile": 0.81433}, "CVE-2015-2726": {"epss_score": 0.01252, "epss_percentile": 0.78901}, "CVE-2015-2727": {"epss_score": 0.01076, "epss_percentile": 0.77326}, "CVE-2015-2728": {"epss_score": 0.01072, "epss_percentile": 0.77278}, "CVE-2015-2729": {"epss_score": 0.00413, "epss_percentile": 0.61013}, "CVE-2015-2730": {"epss_score": 0.00235, "epss_percentile": 0.46202}, "CVE-2015-2731": {"epss_score": 0.00945, "epss_percentile": 0.75796}, "CVE-2015-2733": {"epss_score": 0.02666, "epss_percentile": 0.85377}, "CVE-2015-2734": {"epss_score": 0.01252, "epss_percentile": 0.78904}, "CVE-2015-2735": {"epss_score": 0.01193, "epss_percentile": 0.78409}, "CVE-2015-2736": {"epss_score": 0.01193, "epss_percentile": 0.78409}, "CVE-2015-2737": {"epss_score": 0.01252, "epss_percentile": 0.78904}, "CVE-2015-2738": {"epss_score": 0.01252, "epss_percentile": 0.78904}, "CVE-2015-2739": {"epss_score": 0.01051, "epss_percentile": 0.77082}, "CVE-2015-2740": {"epss_score": 0.03486, "epss_percentile": 0.87226}, "CVE-2015-2741": {"epss_score": 0.00426, "epss_percentile": 0.61744}, "CVE-2015-2742": {"epss_score": 0.00556, "epss_percentile": 0.6753}, "CVE-2015-2743": {"epss_score": 0.01074, "epss_percentile": 0.77301}, "CVE-2015-2744": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-2745": {"epss_score": 0.00322, "epss_percentile": 0.54789}, "CVE-2015-2746": {"epss_score": 0.43909, "epss_percentile": 0.97407}, "CVE-2015-2747": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2015-2748": {"epss_score": 0.00441, "epss_percentile": 0.6266}, "CVE-2015-2749": {"epss_score": 0.00561, "epss_percentile": 0.67662}, "CVE-2015-2750": {"epss_score": 0.00686, "epss_percentile": 0.71167}, "CVE-2015-2751": {"epss_score": 0.01427, "epss_percentile": 0.80215}, "CVE-2015-2752": {"epss_score": 0.00122, "epss_percentile": 0.32062}, "CVE-2015-2753": {"epss_score": 0.01918, "epss_percentile": 0.82876}, "CVE-2015-2754": {"epss_score": 0.02149, "epss_percentile": 0.83777}, "CVE-2015-2755": {"epss_score": 0.00693, "epss_percentile": 0.71331}, "CVE-2015-2756": {"epss_score": 0.00119, "epss_percentile": 0.31603}, "CVE-2015-2757": {"epss_score": 0.00403, "epss_percentile": 0.60368}, "CVE-2015-2758": {"epss_score": 0.00391, "epss_percentile": 0.59618}, "CVE-2015-2759": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2015-2760": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2015-2761": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-2762": {"epss_score": 0.00227, "epss_percentile": 0.45385}, "CVE-2015-2763": {"epss_score": 0.00382, "epss_percentile": 0.59042}, "CVE-2015-2764": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-2765": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2015-2766": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2015-2767": {"epss_score": 0.00382, "epss_percentile": 0.59042}, "CVE-2015-2768": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-2769": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2015-2770": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2015-2771": {"epss_score": 0.0023, "epss_percentile": 0.45758}, "CVE-2015-2772": {"epss_score": 0.0035, "epss_percentile": 0.5698}, "CVE-2015-2773": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2015-2774": {"epss_score": 0.00714, "epss_percentile": 0.71809}, "CVE-2015-2775": {"epss_score": 0.04916, "epss_percentile": 0.89286}, "CVE-2015-2776": {"epss_score": 0.02007, "epss_percentile": 0.83236}, "CVE-2015-2778": {"epss_score": 0.01612, "epss_percentile": 0.81332}, "CVE-2015-2779": {"epss_score": 0.01703, "epss_percentile": 0.81844}, "CVE-2015-2780": {"epss_score": 0.31921, "epss_percentile": 0.96659}, "CVE-2015-2781": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-2782": {"epss_score": 0.05446, "epss_percentile": 0.89887}, "CVE-2015-2783": {"epss_score": 0.09675, "epss_percentile": 0.92649}, "CVE-2015-2784": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2015-2785": {"epss_score": 0.01895, "epss_percentile": 0.82749}, "CVE-2015-2786": {"epss_score": 0.00382, "epss_percentile": 0.59042}, "CVE-2015-2787": {"epss_score": 0.3643, "epss_percentile": 0.96978}, "CVE-2015-2788": {"epss_score": 0.07802, "epss_percentile": 0.91688}, "CVE-2015-2789": {"epss_score": 0.00176, "epss_percentile": 0.39385}, "CVE-2015-2790": {"epss_score": 0.5221, "epss_percentile": 0.97813}, "CVE-2015-2791": {"epss_score": 0.17445, "epss_percentile": 0.94852}, "CVE-2015-2792": {"epss_score": 0.00431, "epss_percentile": 0.62089}, "CVE-2015-2793": {"epss_score": 0.01289, "epss_percentile": 0.79212}, "CVE-2015-2794": {"epss_score": 0.92349, "epss_percentile": 0.99711}, "CVE-2015-2796": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2015-2797": {"epss_score": 0.78328, "epss_percentile": 0.9898}, "CVE-2015-2798": {"epss_score": 0.00996, "epss_percentile": 0.76445}, "CVE-2015-2800": {"epss_score": 0.02804, "epss_percentile": 0.85704}, "CVE-2015-2802": {"epss_score": 0.02152, "epss_percentile": 0.83791}, "CVE-2015-2803": {"epss_score": 0.03302, "epss_percentile": 0.86867}, "CVE-2015-2804": {"epss_score": 0.00544, "epss_percentile": 0.67125}, "CVE-2015-2805": {"epss_score": 0.01115, "epss_percentile": 0.77717}, "CVE-2015-2806": {"epss_score": 0.09345, "epss_percentile": 0.9251}, "CVE-2015-2807": {"epss_score": 0.0689, "epss_percentile": 0.91094}, "CVE-2015-2808": {"epss_score": 0.34742, "epss_percentile": 0.96871}, "CVE-2015-2809": {"epss_score": 0.01716, "epss_percentile": 0.81904}, "CVE-2015-2810": {"epss_score": 0.01624, "epss_percentile": 0.81409}, "CVE-2015-2811": {"epss_score": 0.00657, "epss_percentile": 0.70461}, "CVE-2015-2812": {"epss_score": 0.0057, "epss_percentile": 0.67944}, "CVE-2015-2813": {"epss_score": 0.0054, "epss_percentile": 0.67008}, "CVE-2015-2814": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2015-2815": {"epss_score": 0.03458, "epss_percentile": 0.87176}, "CVE-2015-2816": {"epss_score": 0.00756, "epss_percentile": 0.72734}, "CVE-2015-2817": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2015-2818": {"epss_score": 0.00367, "epss_percentile": 0.58158}, "CVE-2015-2819": {"epss_score": 0.03285, "epss_percentile": 0.86822}, "CVE-2015-2820": {"epss_score": 0.03869, "epss_percentile": 0.87876}, "CVE-2015-2821": {"epss_score": 0.00315, "epss_percentile": 0.54179}, "CVE-2015-2822": {"epss_score": 0.00599, "epss_percentile": 0.68805}, "CVE-2015-2823": {"epss_score": 0.00497, "epss_percentile": 0.65197}, "CVE-2015-2824": {"epss_score": 0.11773, "epss_percentile": 0.93469}, "CVE-2015-2825": {"epss_score": 0.35261, "epss_percentile": 0.96897}, "CVE-2015-2826": {"epss_score": 0.43159, "epss_percentile": 0.97373}, "CVE-2015-2827": {"epss_score": 0.0022, "epss_percentile": 0.44615}, "CVE-2015-2828": {"epss_score": 0.00534, "epss_percentile": 0.66789}, "CVE-2015-2829": {"epss_score": 0.01286, "epss_percentile": 0.79182}, "CVE-2015-2830": {"epss_score": 0.00042, "epss_percentile": 0.12707}, "CVE-2015-2831": {"epss_score": 0.00054, "epss_percentile": 0.17146}, "CVE-2015-2838": {"epss_score": 0.04306, "epss_percentile": 0.88523}, "CVE-2015-2839": {"epss_score": 0.00426, "epss_percentile": 0.61731}, "CVE-2015-2840": {"epss_score": 0.00392, "epss_percentile": 0.59668}, "CVE-2015-2841": {"epss_score": 0.04409, "epss_percentile": 0.88654}, "CVE-2015-2842": {"epss_score": 0.43863, "epss_percentile": 0.97406}, "CVE-2015-2843": {"epss_score": 0.80047, "epss_percentile": 0.99069}, "CVE-2015-2844": {"epss_score": 0.39138, "epss_percentile": 0.97143}, "CVE-2015-2845": {"epss_score": 0.87464, "epss_percentile": 0.9943}, "CVE-2015-2846": {"epss_score": 0.0165, "epss_percentile": 0.81564}, "CVE-2015-2847": {"epss_score": 0.00381, "epss_percentile": 0.5903}, "CVE-2015-2848": {"epss_score": 0.00108, "epss_percentile": 0.29811}, "CVE-2015-2849": {"epss_score": 0.00473, "epss_percentile": 0.64081}, "CVE-2015-2850": {"epss_score": 0.00909, "epss_percentile": 0.75291}, "CVE-2015-2851": {"epss_score": 0.00412, "epss_percentile": 0.60923}, "CVE-2015-2852": {"epss_score": 0.00353, "epss_percentile": 0.57179}, "CVE-2015-2853": {"epss_score": 0.01526, "epss_percentile": 0.80861}, "CVE-2015-2854": {"epss_score": 0.02607, "epss_percentile": 0.85228}, "CVE-2015-2855": {"epss_score": 0.01827, "epss_percentile": 0.82438}, "CVE-2015-2856": {"epss_score": 0.71207, "epss_percentile": 0.98659}, "CVE-2015-2857": {"epss_score": 0.83027, "epss_percentile": 0.99226}, "CVE-2015-2858": {"epss_score": 0.00285, "epss_percentile": 0.51637}, "CVE-2015-2859": {"epss_score": 0.00262, "epss_percentile": 0.49333}, "CVE-2015-2860": {"epss_score": 0.00401, "epss_percentile": 0.60252}, "CVE-2015-2861": {"epss_score": 0.00179, "epss_percentile": 0.39828}, "CVE-2015-2862": {"epss_score": 0.02834, "epss_percentile": 0.85783}, "CVE-2015-2863": {"epss_score": 0.46464, "epss_percentile": 0.97547}, "CVE-2015-2864": {"epss_score": 0.00479, "epss_percentile": 0.64412}, "CVE-2015-2866": {"epss_score": 0.03623, "epss_percentile": 0.87444}, "CVE-2015-2867": {"epss_score": 0.02884, "epss_percentile": 0.85908}, "CVE-2015-2868": {"epss_score": 0.09063, "epss_percentile": 0.92385}, "CVE-2015-2869": {"epss_score": 0.01849, "epss_percentile": 0.82532}, "CVE-2015-2870": {"epss_score": 0.00909, "epss_percentile": 0.75291}, "CVE-2015-2871": {"epss_score": 0.00264, "epss_percentile": 0.49578}, "CVE-2015-2872": {"epss_score": 0.01913, "epss_percentile": 0.82838}, "CVE-2015-2873": {"epss_score": 0.01884, "epss_percentile": 0.82706}, "CVE-2015-2874": {"epss_score": 0.04724, "epss_percentile": 0.8906}, "CVE-2015-2875": {"epss_score": 0.03823, "epss_percentile": 0.87788}, "CVE-2015-2876": {"epss_score": 0.01702, "epss_percentile": 0.8184}, "CVE-2015-2877": {"epss_score": 0.00112, "epss_percentile": 0.30552}, "CVE-2015-2878": {"epss_score": 0.00333, "epss_percentile": 0.55631}, "CVE-2015-2880": {"epss_score": 0.00797, "epss_percentile": 0.73495}, "CVE-2015-2881": {"epss_score": 0.00796, "epss_percentile": 0.73482}, "CVE-2015-2882": {"epss_score": 0.00991, "epss_percentile": 0.76383}, "CVE-2015-2883": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2015-2884": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2015-2885": {"epss_score": 0.00284, "epss_percentile": 0.51448}, "CVE-2015-2886": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2015-2887": {"epss_score": 0.00284, "epss_percentile": 0.51448}, "CVE-2015-2888": {"epss_score": 0.00515, "epss_percentile": 0.65999}, "CVE-2015-2889": {"epss_score": 0.00607, "epss_percentile": 0.6905}, "CVE-2015-2890": {"epss_score": 0.00316, "epss_percentile": 0.54275}, "CVE-2015-2894": {"epss_score": 0.00671, "epss_percentile": 0.70806}, "CVE-2015-2895": {"epss_score": 0.0386, "epss_percentile": 0.87864}, "CVE-2015-2896": {"epss_score": 0.00208, "epss_percentile": 0.4324}, "CVE-2015-2897": {"epss_score": 0.00012, "epss_percentile": 0.0142}, "CVE-2015-2898": {"epss_score": 0.22232, "epss_percentile": 0.95611}, "CVE-2015-2899": {"epss_score": 0.07965, "epss_percentile": 0.91793}, "CVE-2015-2900": {"epss_score": 0.26741, "epss_percentile": 0.96172}, "CVE-2015-2901": {"epss_score": 0.22232, "epss_percentile": 0.95611}, "CVE-2015-2902": {"epss_score": 0.00949, "epss_percentile": 0.75851}, "CVE-2015-2903": {"epss_score": 0.03214, "epss_percentile": 0.8666}, "CVE-2015-2904": {"epss_score": 0.00258, "epss_percentile": 0.48997}, "CVE-2015-2905": {"epss_score": 0.00108, "epss_percentile": 0.29811}, "CVE-2015-2906": {"epss_score": 0.00648, "epss_percentile": 0.70211}, "CVE-2015-2907": {"epss_score": 0.00648, "epss_percentile": 0.70211}, "CVE-2015-2908": {"epss_score": 0.00982, "epss_percentile": 0.76288}, "CVE-2015-2909": {"epss_score": 0.03574, "epss_percentile": 0.87377}, "CVE-2015-2912": {"epss_score": 0.00343, "epss_percentile": 0.56423}, "CVE-2015-2913": {"epss_score": 0.00586, "epss_percentile": 0.68455}, "CVE-2015-2914": {"epss_score": 0.00601, "epss_percentile": 0.6884}, "CVE-2015-2915": {"epss_score": 0.00294, "epss_percentile": 0.52436}, "CVE-2015-2916": {"epss_score": 0.00108, "epss_percentile": 0.29811}, "CVE-2015-2917": {"epss_score": 0.00683, "epss_percentile": 0.71106}, "CVE-2015-2918": {"epss_score": 0.00597, "epss_percentile": 0.68747}, "CVE-2015-2922": {"epss_score": 0.01716, "epss_percentile": 0.81901}, "CVE-2015-2923": {"epss_score": 0.01374, "epss_percentile": 0.79826}, "CVE-2015-2924": {"epss_score": 0.0059, "epss_percentile": 0.68569}, "CVE-2015-2925": {"epss_score": 0.00958, "epss_percentile": 0.75944}, "CVE-2015-2926": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2015-2927": {"epss_score": 0.0129, "epss_percentile": 0.79219}, "CVE-2015-2928": {"epss_score": 0.00721, "epss_percentile": 0.7197}, "CVE-2015-2929": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2015-2931": {"epss_score": 0.00281, "epss_percentile": 0.51126}, "CVE-2015-2932": {"epss_score": 0.00281, "epss_percentile": 0.51126}, "CVE-2015-2933": {"epss_score": 0.00281, "epss_percentile": 0.51126}, "CVE-2015-2934": {"epss_score": 0.00281, "epss_percentile": 0.51126}, "CVE-2015-2935": {"epss_score": 0.00299, "epss_percentile": 0.52852}, "CVE-2015-2936": {"epss_score": 0.0189, "epss_percentile": 0.82725}, "CVE-2015-2937": {"epss_score": 0.02017, "epss_percentile": 0.83279}, "CVE-2015-2938": {"epss_score": 0.00281, "epss_percentile": 0.51126}, "CVE-2015-2939": {"epss_score": 0.00408, "epss_percentile": 0.60677}, "CVE-2015-2940": {"epss_score": 0.00295, "epss_percentile": 0.52502}, "CVE-2015-2941": {"epss_score": 0.00281, "epss_percentile": 0.51126}, "CVE-2015-2942": {"epss_score": 0.01675, "epss_percentile": 0.81703}, "CVE-2015-2943": {"epss_score": 0.00301, "epss_percentile": 0.53042}, "CVE-2015-2944": {"epss_score": 0.02866, "epss_percentile": 0.85861}, "CVE-2015-2945": {"epss_score": 0.00715, "epss_percentile": 0.71831}, "CVE-2015-2946": {"epss_score": 0.03651, "epss_percentile": 0.87508}, "CVE-2015-2947": {"epss_score": 0.00525, "epss_percentile": 0.66395}, "CVE-2015-2948": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2015-2949": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-2950": {"epss_score": 0.00563, "epss_percentile": 0.6773}, "CVE-2015-2951": {"epss_score": 0.02128, "epss_percentile": 0.837}, "CVE-2015-2952": {"epss_score": 0.00224, "epss_percentile": 0.45045}, "CVE-2015-2953": {"epss_score": 0.00505, "epss_percentile": 0.65608}, "CVE-2015-2954": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2015-2955": {"epss_score": 0.00619, "epss_percentile": 0.69401}, "CVE-2015-2956": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2015-2957": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2015-2958": {"epss_score": 0.00636, "epss_percentile": 0.69864}, "CVE-2015-2959": {"epss_score": 0.00824, "epss_percentile": 0.73938}, "CVE-2015-2960": {"epss_score": 0.00224, "epss_percentile": 0.45001}, "CVE-2015-2961": {"epss_score": 0.00393, "epss_percentile": 0.59731}, "CVE-2015-2962": {"epss_score": 0.01696, "epss_percentile": 0.81811}, "CVE-2015-2963": {"epss_score": 0.00481, "epss_percentile": 0.6449}, "CVE-2015-2964": {"epss_score": 0.00448, "epss_percentile": 0.63001}, "CVE-2015-2965": {"epss_score": 0.00374, "epss_percentile": 0.58571}, "CVE-2015-2966": {"epss_score": 0.00363, "epss_percentile": 0.57832}, "CVE-2015-2967": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2015-2968": {"epss_score": 0.00115, "epss_percentile": 0.30946}, "CVE-2015-2969": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-2970": {"epss_score": 0.01966, "epss_percentile": 0.83082}, "CVE-2015-2971": {"epss_score": 0.03084, "epss_percentile": 0.8638}, "CVE-2015-2972": {"epss_score": 0.00947, "epss_percentile": 0.75818}, "CVE-2015-2973": {"epss_score": 0.00435, "epss_percentile": 0.62346}, "CVE-2015-2974": {"epss_score": 0.00298, "epss_percentile": 0.52775}, "CVE-2015-2975": {"epss_score": 0.00298, "epss_percentile": 0.52775}, "CVE-2015-2976": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-2977": {"epss_score": 0.01256, "epss_percentile": 0.7894}, "CVE-2015-2978": {"epss_score": 0.00647, "epss_percentile": 0.70186}, "CVE-2015-2979": {"epss_score": 0.00457, "epss_percentile": 0.63394}, "CVE-2015-2980": {"epss_score": 0.00602, "epss_percentile": 0.68887}, "CVE-2015-2981": {"epss_score": 0.00497, "epss_percentile": 0.65194}, "CVE-2015-2982": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-2983": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-2984": {"epss_score": 0.00603, "epss_percentile": 0.68914}, "CVE-2015-2985": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2015-2986": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2015-2987": {"epss_score": 0.00231, "epss_percentile": 0.45854}, "CVE-2015-2988": {"epss_score": 0.00664, "epss_percentile": 0.70639}, "CVE-2015-2989": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2015-2990": {"epss_score": 0.0048, "epss_percentile": 0.6448}, "CVE-2015-2991": {"epss_score": 0.02977, "epss_percentile": 0.86108}, "CVE-2015-2992": {"epss_score": 0.01596, "epss_percentile": 0.81238}, "CVE-2015-2993": {"epss_score": 0.77003, "epss_percentile": 0.98915}, "CVE-2015-2994": {"epss_score": 0.76861, "epss_percentile": 0.98909}, "CVE-2015-2995": {"epss_score": 0.79205, "epss_percentile": 0.99023}, "CVE-2015-2996": {"epss_score": 0.89001, "epss_percentile": 0.99505}, "CVE-2015-2997": {"epss_score": 0.80831, "epss_percentile": 0.99109}, "CVE-2015-2998": {"epss_score": 0.62156, "epss_percentile": 0.98283}, "CVE-2015-2999": {"epss_score": 0.01023, "epss_percentile": 0.76767}, "CVE-2015-3000": {"epss_score": 0.20105, "epss_percentile": 0.95288}, "CVE-2015-3001": {"epss_score": 0.13706, "epss_percentile": 0.94039}, "CVE-2015-3002": {"epss_score": 0.00052, "epss_percentile": 0.1663}, "CVE-2015-3003": {"epss_score": 0.00047, "epss_percentile": 0.14504}, "CVE-2015-3004": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2015-3005": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-3006": {"epss_score": 0.00123, "epss_percentile": 0.32337}, "CVE-2015-3007": {"epss_score": 0.00041, "epss_percentile": 0.12374}, "CVE-2015-3008": {"epss_score": 0.39025, "epss_percentile": 0.97135}, "CVE-2015-3010": {"epss_score": 0.00048, "epss_percentile": 0.15144}, "CVE-2015-3011": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-3012": {"epss_score": 0.00455, "epss_percentile": 0.63308}, "CVE-2015-3013": {"epss_score": 0.00249, "epss_percentile": 0.48021}, "CVE-2015-3026": {"epss_score": 0.1532, "epss_percentile": 0.94408}, "CVE-2015-3027": {"epss_score": 0.00314, "epss_percentile": 0.54105}, "CVE-2015-3028": {"epss_score": 0.00152, "epss_percentile": 0.36385}, "CVE-2015-3029": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2015-3030": {"epss_score": 0.00162, "epss_percentile": 0.37718}, "CVE-2015-3035": {"epss_score": 0.92856, "epss_percentile": 0.99755}, "CVE-2015-3036": {"epss_score": 0.70085, "epss_percentile": 0.98614}, "CVE-2015-3038": {"epss_score": 0.09295, "epss_percentile": 0.92488}, "CVE-2015-3039": {"epss_score": 0.087, "epss_percentile": 0.92209}, "CVE-2015-3040": {"epss_score": 0.0076, "epss_percentile": 0.72806}, "CVE-2015-3041": {"epss_score": 0.03683, "epss_percentile": 0.87565}, "CVE-2015-3042": {"epss_score": 0.51905, "epss_percentile": 0.97801}, "CVE-2015-3043": {"epss_score": 0.82652, "epss_percentile": 0.99204}, "CVE-2015-3044": {"epss_score": 0.02305, "epss_percentile": 0.84322}, "CVE-2015-3046": {"epss_score": 0.12261, "epss_percentile": 0.93616}, "CVE-2015-3047": {"epss_score": 0.04286, "epss_percentile": 0.88495}, "CVE-2015-3048": {"epss_score": 0.13918, "epss_percentile": 0.94092}, "CVE-2015-3049": {"epss_score": 0.12261, "epss_percentile": 0.93616}, "CVE-2015-3050": {"epss_score": 0.12261, "epss_percentile": 0.93616}, "CVE-2015-3051": {"epss_score": 0.12261, "epss_percentile": 0.93616}, "CVE-2015-3052": {"epss_score": 0.12261, "epss_percentile": 0.93616}, "CVE-2015-3053": {"epss_score": 0.03086, "epss_percentile": 0.86385}, "CVE-2015-3054": {"epss_score": 0.03561, "epss_percentile": 0.87353}, "CVE-2015-3055": {"epss_score": 0.01971, "epss_percentile": 0.83096}, "CVE-2015-3056": {"epss_score": 0.05047, "epss_percentile": 0.89437}, "CVE-2015-3057": {"epss_score": 0.05047, "epss_percentile": 0.89437}, "CVE-2015-3058": {"epss_score": 0.05697, "epss_percentile": 0.90127}, "CVE-2015-3059": {"epss_score": 0.03561, "epss_percentile": 0.87353}, "CVE-2015-3060": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3061": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3062": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3063": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3064": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3065": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3066": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3067": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3068": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3069": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3070": {"epss_score": 0.12261, "epss_percentile": 0.93616}, "CVE-2015-3071": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3072": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3073": {"epss_score": 0.31105, "epss_percentile": 0.96588}, "CVE-2015-3074": {"epss_score": 0.03627, "epss_percentile": 0.87465}, "CVE-2015-3075": {"epss_score": 0.07408, "epss_percentile": 0.91457}, "CVE-2015-3076": {"epss_score": 0.12261, "epss_percentile": 0.93616}, "CVE-2015-3077": {"epss_score": 0.63195, "epss_percentile": 0.98323}, "CVE-2015-3078": {"epss_score": 0.04734, "epss_percentile": 0.89072}, "CVE-2015-3079": {"epss_score": 0.01007, "epss_percentile": 0.76557}, "CVE-2015-3080": {"epss_score": 0.67828, "epss_percentile": 0.98522}, "CVE-2015-3081": {"epss_score": 0.0778, "epss_percentile": 0.91678}, "CVE-2015-3082": {"epss_score": 0.19906, "epss_percentile": 0.95257}, "CVE-2015-3083": {"epss_score": 0.19906, "epss_percentile": 0.95257}, "CVE-2015-3084": {"epss_score": 0.05352, "epss_percentile": 0.89775}, "CVE-2015-3085": {"epss_score": 0.0601, "epss_percentile": 0.90404}, "CVE-2015-3086": {"epss_score": 0.05352, "epss_percentile": 0.89775}, "CVE-2015-3087": {"epss_score": 0.65307, "epss_percentile": 0.98412}, "CVE-2015-3088": {"epss_score": 0.7945, "epss_percentile": 0.99039}, "CVE-2015-3089": {"epss_score": 0.55434, "epss_percentile": 0.97978}, "CVE-2015-3090": {"epss_score": 0.89827, "epss_percentile": 0.99545}, "CVE-2015-3091": {"epss_score": 0.00755, "epss_percentile": 0.72721}, "CVE-2015-3092": {"epss_score": 0.00755, "epss_percentile": 0.72721}, "CVE-2015-3093": {"epss_score": 0.55434, "epss_percentile": 0.97978}, "CVE-2015-3095": {"epss_score": 0.03656, "epss_percentile": 0.87517}, "CVE-2015-3096": {"epss_score": 0.00423, "epss_percentile": 0.61617}, "CVE-2015-3097": {"epss_score": 0.09216, "epss_percentile": 0.92453}, "CVE-2015-3098": {"epss_score": 0.00583, "epss_percentile": 0.6834}, "CVE-2015-3099": {"epss_score": 0.00583, "epss_percentile": 0.6834}, "CVE-2015-3100": {"epss_score": 0.03393, "epss_percentile": 0.87054}, "CVE-2015-3101": {"epss_score": 0.00545, "epss_percentile": 0.67174}, "CVE-2015-3102": {"epss_score": 0.00583, "epss_percentile": 0.6834}, "CVE-2015-3103": {"epss_score": 0.01907, "epss_percentile": 0.8281}, "CVE-2015-3104": {"epss_score": 0.04479, "epss_percentile": 0.88741}, "CVE-2015-3105": {"epss_score": 0.90264, "epss_percentile": 0.99573}, "CVE-2015-3106": {"epss_score": 0.54609, "epss_percentile": 0.97935}, "CVE-2015-3107": {"epss_score": 0.50806, "epss_percentile": 0.9775}, "CVE-2015-3108": {"epss_score": 0.00443, "epss_percentile": 0.62759}, "CVE-2015-3109": {"epss_score": 0.08609, "epss_percentile": 0.92149}, "CVE-2015-3110": {"epss_score": 0.229, "epss_percentile": 0.95703}, "CVE-2015-3111": {"epss_score": 0.27413, "epss_percentile": 0.96244}, "CVE-2015-3112": {"epss_score": 0.22178, "epss_percentile": 0.95603}, "CVE-2015-3113": {"epss_score": 0.92717, "epss_percentile": 0.99738}, "CVE-2015-3114": {"epss_score": 0.00426, "epss_percentile": 0.61733}, "CVE-2015-3115": {"epss_score": 0.00235, "epss_percentile": 0.46229}, "CVE-2015-3116": {"epss_score": 0.00352, "epss_percentile": 0.57116}, "CVE-2015-3117": {"epss_score": 0.05538, "epss_percentile": 0.89975}, "CVE-2015-3118": {"epss_score": 0.61463, "epss_percentile": 0.98249}, "CVE-2015-3119": {"epss_score": 0.06665, "epss_percentile": 0.90927}, "CVE-2015-3120": {"epss_score": 0.07673, "epss_percentile": 0.91618}, "CVE-2015-3121": {"epss_score": 0.06665, "epss_percentile": 0.90927}, "CVE-2015-3122": {"epss_score": 0.06665, "epss_percentile": 0.90927}, "CVE-2015-3123": {"epss_score": 0.05538, "epss_percentile": 0.89975}, "CVE-2015-3124": {"epss_score": 0.5847, "epss_percentile": 0.98119}, "CVE-2015-3125": {"epss_score": 0.00352, "epss_percentile": 0.57116}, "CVE-2015-3126": {"epss_score": 0.01078, "epss_percentile": 0.77347}, "CVE-2015-3127": {"epss_score": 0.1049, "epss_percentile": 0.93008}, "CVE-2015-3128": {"epss_score": 0.6551, "epss_percentile": 0.98423}, "CVE-2015-3129": {"epss_score": 0.1049, "epss_percentile": 0.93008}, "CVE-2015-3130": {"epss_score": 0.05538, "epss_percentile": 0.89975}, "CVE-2015-3131": {"epss_score": 0.1049, "epss_percentile": 0.93008}, "CVE-2015-3132": {"epss_score": 0.1049, "epss_percentile": 0.93008}, "CVE-2015-3133": {"epss_score": 0.05538, "epss_percentile": 0.89975}, "CVE-2015-3134": {"epss_score": 0.59669, "epss_percentile": 0.98175}, "CVE-2015-3135": {"epss_score": 0.06644, "epss_percentile": 0.90911}, "CVE-2015-3136": {"epss_score": 0.1049, "epss_percentile": 0.93008}, "CVE-2015-3137": {"epss_score": 0.62732, "epss_percentile": 0.98306}, "CVE-2015-3138": {"epss_score": 0.00877, "epss_percentile": 0.748}, "CVE-2015-3140": {"epss_score": 0.00171, "epss_percentile": 0.3886}, "CVE-2015-3141": {"epss_score": 0.00365, "epss_percentile": 0.58013}, "CVE-2015-3142": {"epss_score": 0.00111, "epss_percentile": 0.30339}, "CVE-2015-3143": {"epss_score": 0.03007, "epss_percentile": 0.86188}, "CVE-2015-3144": {"epss_score": 0.01008, "epss_percentile": 0.76572}, "CVE-2015-3145": {"epss_score": 0.63704, "epss_percentile": 0.98345}, "CVE-2015-3146": {"epss_score": 0.02845, "epss_percentile": 0.85818}, "CVE-2015-3147": {"epss_score": 0.00535, "epss_percentile": 0.66825}, "CVE-2015-3148": {"epss_score": 0.02125, "epss_percentile": 0.8369}, "CVE-2015-3149": {"epss_score": 0.00067, "epss_percentile": 0.2115}, "CVE-2015-3150": {"epss_score": 0.00047, "epss_percentile": 0.14784}, "CVE-2015-3151": {"epss_score": 0.0007, "epss_percentile": 0.21806}, "CVE-2015-3152": {"epss_score": 0.51669, "epss_percentile": 0.97793}, "CVE-2015-3153": {"epss_score": 0.08124, "epss_percentile": 0.91891}, "CVE-2015-3154": {"epss_score": 0.00274, "epss_percentile": 0.50539}, "CVE-2015-3155": {"epss_score": 0.00563, "epss_percentile": 0.67725}, "CVE-2015-3156": {"epss_score": 0.00121, "epss_percentile": 0.32003}, "CVE-2015-3158": {"epss_score": 0.00447, "epss_percentile": 0.62985}, "CVE-2015-3159": {"epss_score": 0.00158, "epss_percentile": 0.37236}, "CVE-2015-3160": {"epss_score": 0.00257, "epss_percentile": 0.48865}, "CVE-2015-3161": {"epss_score": 0.00472, "epss_percentile": 0.64044}, "CVE-2015-3162": {"epss_score": 0.00393, "epss_percentile": 0.59729}, "CVE-2015-3163": {"epss_score": 0.00462, "epss_percentile": 0.63574}, "CVE-2015-3164": {"epss_score": 0.00065, "epss_percentile": 0.20585}, "CVE-2015-3165": {"epss_score": 0.0853, "epss_percentile": 0.92105}, "CVE-2015-3166": {"epss_score": 0.02905, "epss_percentile": 0.85961}, "CVE-2015-3167": {"epss_score": 0.02522, "epss_percentile": 0.85005}, "CVE-2015-3169": {"epss_score": 0.00285, "epss_percentile": 0.51547}, "CVE-2015-3170": {"epss_score": 0.0004, "epss_percentile": 0.12049}, "CVE-2015-3171": {"epss_score": 0.00039, "epss_percentile": 0.11653}, "CVE-2015-3172": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2015-3173": {"epss_score": 0.12405, "epss_percentile": 0.9366}, "CVE-2015-3174": {"epss_score": 0.00225, "epss_percentile": 0.45225}, "CVE-2015-3175": {"epss_score": 0.004, "epss_percentile": 0.60193}, "CVE-2015-3176": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2015-3177": {"epss_score": 0.00306, "epss_percentile": 0.53452}, "CVE-2015-3178": {"epss_score": 0.00208, "epss_percentile": 0.43213}, "CVE-2015-3179": {"epss_score": 0.00328, "epss_percentile": 0.55156}, "CVE-2015-3180": {"epss_score": 0.00306, "epss_percentile": 0.53452}, "CVE-2015-3181": {"epss_score": 0.00328, "epss_percentile": 0.55156}, "CVE-2015-3182": {"epss_score": 0.00087, "epss_percentile": 0.25549}, "CVE-2015-3183": {"epss_score": 0.28343, "epss_percentile": 0.96345}, "CVE-2015-3184": {"epss_score": 0.17005, "epss_percentile": 0.94759}, "CVE-2015-3185": {"epss_score": 0.09491, "epss_percentile": 0.92571}, "CVE-2015-3186": {"epss_score": 0.00204, "epss_percentile": 0.42614}, "CVE-2015-3187": {"epss_score": 0.00944, "epss_percentile": 0.75794}, "CVE-2015-3188": {"epss_score": 0.1242, "epss_percentile": 0.93665}, "CVE-2015-3189": {"epss_score": 0.00178, "epss_percentile": 0.39643}, "CVE-2015-3190": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2015-3191": {"epss_score": 0.00119, "epss_percentile": 0.31657}, "CVE-2015-3192": {"epss_score": 0.01081, "epss_percentile": 0.77373}, "CVE-2015-3193": {"epss_score": 0.31402, "epss_percentile": 0.96618}, "CVE-2015-3194": {"epss_score": 0.58143, "epss_percentile": 0.98101}, "CVE-2015-3195": {"epss_score": 0.03439, "epss_percentile": 0.87138}, "CVE-2015-3196": {"epss_score": 0.10256, "epss_percentile": 0.92915}, "CVE-2015-3197": {"epss_score": 0.21948, "epss_percentile": 0.95576}, "CVE-2015-3198": {"epss_score": 0.00392, "epss_percentile": 0.59669}, "CVE-2015-3200": {"epss_score": 0.20033, "epss_percentile": 0.95277}, "CVE-2015-3201": {"epss_score": 0.00048, "epss_percentile": 0.1507}, "CVE-2015-3202": {"epss_score": 0.00247, "epss_percentile": 0.47857}, "CVE-2015-3203": {"epss_score": 0.11275, "epss_percentile": 0.93289}, "CVE-2015-3204": {"epss_score": 0.00588, "epss_percentile": 0.68488}, "CVE-2015-3205": {"epss_score": 0.07573, "epss_percentile": 0.91546}, "CVE-2015-3206": {"epss_score": 0.00963, "epss_percentile": 0.76004}, "CVE-2015-3207": {"epss_score": 0.00204, "epss_percentile": 0.42596}, "CVE-2015-3209": {"epss_score": 0.20573, "epss_percentile": 0.95379}, "CVE-2015-3210": {"epss_score": 0.0573, "epss_percentile": 0.9016}, "CVE-2015-3211": {"epss_score": 0.00087, "epss_percentile": 0.25541}, "CVE-2015-3212": {"epss_score": 0.00077, "epss_percentile": 0.23456}, "CVE-2015-3213": {"epss_score": 0.00079, "epss_percentile": 0.23992}, "CVE-2015-3214": {"epss_score": 0.01593, "epss_percentile": 0.81227}, "CVE-2015-3215": {"epss_score": 0.01171, "epss_percentile": 0.7822}, "CVE-2015-3216": {"epss_score": 0.02281, "epss_percentile": 0.8425}, "CVE-2015-3217": {"epss_score": 0.00861, "epss_percentile": 0.74565}, "CVE-2015-3218": {"epss_score": 0.00133, "epss_percentile": 0.33664}, "CVE-2015-3219": {"epss_score": 0.00408, "epss_percentile": 0.60671}, "CVE-2015-3220": {"epss_score": 0.00779, "epss_percentile": 0.73156}, "CVE-2015-3221": {"epss_score": 0.1067, "epss_percentile": 0.93064}, "CVE-2015-3222": {"epss_score": 0.00477, "epss_percentile": 0.64321}, "CVE-2015-3223": {"epss_score": 0.2364, "epss_percentile": 0.95797}, "CVE-2015-3224": {"epss_score": 0.85262, "epss_percentile": 0.99325}, "CVE-2015-3225": {"epss_score": 0.1408, "epss_percentile": 0.94129}, "CVE-2015-3226": {"epss_score": 0.00212, "epss_percentile": 0.43753}, "CVE-2015-3227": {"epss_score": 0.02683, "epss_percentile": 0.85421}, "CVE-2015-3228": {"epss_score": 0.00967, "epss_percentile": 0.76067}, "CVE-2015-3229": {"epss_score": 0.00473, "epss_percentile": 0.64109}, "CVE-2015-3230": {"epss_score": 0.00606, "epss_percentile": 0.69005}, "CVE-2015-3231": {"epss_score": 0.00452, "epss_percentile": 0.63188}, "CVE-2015-3232": {"epss_score": 0.00443, "epss_percentile": 0.62788}, "CVE-2015-3233": {"epss_score": 0.0494, "epss_percentile": 0.89306}, "CVE-2015-3234": {"epss_score": 0.00498, "epss_percentile": 0.65221}, "CVE-2015-3235": {"epss_score": 0.0057, "epss_percentile": 0.67943}, "CVE-2015-3236": {"epss_score": 0.04525, "epss_percentile": 0.88804}, "CVE-2015-3237": {"epss_score": 0.05127, "epss_percentile": 0.89525}, "CVE-2015-3238": {"epss_score": 0.02446, "epss_percentile": 0.84768}, "CVE-2015-3239": {"epss_score": 0.00089, "epss_percentile": 0.25805}, "CVE-2015-3240": {"epss_score": 0.01204, "epss_percentile": 0.78504}, "CVE-2015-3241": {"epss_score": 0.0197, "epss_percentile": 0.83093}, "CVE-2015-3243": {"epss_score": 0.00134, "epss_percentile": 0.33768}, "CVE-2015-3244": {"epss_score": 0.00265, "epss_percentile": 0.49833}, "CVE-2015-3245": {"epss_score": 0.11161, "epss_percentile": 0.9325}, "CVE-2015-3246": {"epss_score": 0.21424, "epss_percentile": 0.95515}, "CVE-2015-3247": {"epss_score": 0.00771, "epss_percentile": 0.73027}, "CVE-2015-3248": {"epss_score": 0.00097, "epss_percentile": 0.27506}, "CVE-2015-3249": {"epss_score": 0.04233, "epss_percentile": 0.88425}, "CVE-2015-3250": {"epss_score": 0.02044, "epss_percentile": 0.83381}, "CVE-2015-3251": {"epss_score": 0.00179, "epss_percentile": 0.39825}, "CVE-2015-3252": {"epss_score": 0.01867, "epss_percentile": 0.82617}, "CVE-2015-3253": {"epss_score": 0.66025, "epss_percentile": 0.98447}, "CVE-2015-3254": {"epss_score": 0.02686, "epss_percentile": 0.85428}, "CVE-2015-3255": {"epss_score": 0.00106, "epss_percentile": 0.29428}, "CVE-2015-3256": {"epss_score": 0.00077, "epss_percentile": 0.23457}, "CVE-2015-3257": {"epss_score": 0.00239, "epss_percentile": 0.46881}, "CVE-2015-3258": {"epss_score": 0.37078, "epss_percentile": 0.97018}, "CVE-2015-3259": {"epss_score": 0.00056, "epss_percentile": 0.17857}, "CVE-2015-3267": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-3268": {"epss_score": 0.06534, "epss_percentile": 0.90827}, "CVE-2015-3269": {"epss_score": 0.13331, "epss_percentile": 0.93935}, "CVE-2015-3270": {"epss_score": 0.01015, "epss_percentile": 0.76668}, "CVE-2015-3271": {"epss_score": 0.00267, "epss_percentile": 0.49963}, "CVE-2015-3272": {"epss_score": 0.00347, "epss_percentile": 0.56781}, "CVE-2015-3273": {"epss_score": 0.00278, "epss_percentile": 0.50849}, "CVE-2015-3274": {"epss_score": 0.00255, "epss_percentile": 0.48733}, "CVE-2015-3275": {"epss_score": 0.00255, "epss_percentile": 0.48733}, "CVE-2015-3276": {"epss_score": 0.02938, "epss_percentile": 0.86029}, "CVE-2015-3277": {"epss_score": 0.00334, "epss_percentile": 0.55694}, "CVE-2015-3278": {"epss_score": 0.00422, "epss_percentile": 0.61574}, "CVE-2015-3279": {"epss_score": 0.34505, "epss_percentile": 0.96851}, "CVE-2015-3280": {"epss_score": 0.01077, "epss_percentile": 0.7734}, "CVE-2015-3281": {"epss_score": 0.00094, "epss_percentile": 0.26761}, "CVE-2015-3282": {"epss_score": 0.00472, "epss_percentile": 0.64035}, "CVE-2015-3283": {"epss_score": 0.00768, "epss_percentile": 0.72972}, "CVE-2015-3284": {"epss_score": 0.00062, "epss_percentile": 0.19786}, "CVE-2015-3285": {"epss_score": 0.00081, "epss_percentile": 0.24212}, "CVE-2015-3286": {"epss_score": 0.00069, "epss_percentile": 0.21526}, "CVE-2015-3288": {"epss_score": 0.00073, "epss_percentile": 0.22628}, "CVE-2015-3289": {"epss_score": 0.00362, "epss_percentile": 0.57817}, "CVE-2015-3290": {"epss_score": 0.00293, "epss_percentile": 0.52348}, "CVE-2015-3291": {"epss_score": 0.0006, "epss_percentile": 0.19225}, "CVE-2015-3292": {"epss_score": 0.33992, "epss_percentile": 0.9682}, "CVE-2015-3293": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2015-3294": {"epss_score": 0.00184, "epss_percentile": 0.40394}, "CVE-2015-3295": {"epss_score": 0.0058, "epss_percentile": 0.68254}, "CVE-2015-3296": {"epss_score": 0.00343, "epss_percentile": 0.56471}, "CVE-2015-3297": {"epss_score": 0.03809, "epss_percentile": 0.87755}, "CVE-2015-3298": {"epss_score": 0.00126, "epss_percentile": 0.32665}, "CVE-2015-3299": {"epss_score": 0.00305, "epss_percentile": 0.53311}, "CVE-2015-3300": {"epss_score": 0.0353, "epss_percentile": 0.873}, "CVE-2015-3301": {"epss_score": 0.144, "epss_percentile": 0.94203}, "CVE-2015-3302": {"epss_score": 0.20637, "epss_percentile": 0.95391}, "CVE-2015-3306": {"epss_score": 0.9393, "epss_percentile": 0.99869}, "CVE-2015-3307": {"epss_score": 0.18407, "epss_percentile": 0.95013}, "CVE-2015-3308": {"epss_score": 0.01394, "epss_percentile": 0.79969}, "CVE-2015-3309": {"epss_score": 0.00433, "epss_percentile": 0.62189}, "CVE-2015-3310": {"epss_score": 0.01515, "epss_percentile": 0.80795}, "CVE-2015-3313": {"epss_score": 0.18463, "epss_percentile": 0.95018}, "CVE-2015-3314": {"epss_score": 0.08759, "epss_percentile": 0.92244}, "CVE-2015-3315": {"epss_score": 0.05339, "epss_percentile": 0.89757}, "CVE-2015-3316": {"epss_score": 0.00068, "epss_percentile": 0.21385}, "CVE-2015-3317": {"epss_score": 0.00059, "epss_percentile": 0.18642}, "CVE-2015-3318": {"epss_score": 0.00059, "epss_percentile": 0.18642}, "CVE-2015-3319": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2015-3320": {"epss_score": 0.00062, "epss_percentile": 0.19665}, "CVE-2015-3321": {"epss_score": 0.00036, "epss_percentile": 0.10396}, "CVE-2015-3322": {"epss_score": 0.00136, "epss_percentile": 0.34119}, "CVE-2015-3323": {"epss_score": 0.00721, "epss_percentile": 0.71968}, "CVE-2015-3324": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2015-3325": {"epss_score": 0.019, "epss_percentile": 0.82769}, "CVE-2015-3326": {"epss_score": 0.00393, "epss_percentile": 0.59741}, "CVE-2015-3329": {"epss_score": 0.28148, "epss_percentile": 0.96325}, "CVE-2015-3330": {"epss_score": 0.38958, "epss_percentile": 0.97131}, "CVE-2015-3331": {"epss_score": 0.04034, "epss_percentile": 0.88154}, "CVE-2015-3332": {"epss_score": 0.00119, "epss_percentile": 0.31591}, "CVE-2015-3333": {"epss_score": 0.00255, "epss_percentile": 0.48728}, "CVE-2015-3334": {"epss_score": 0.00513, "epss_percentile": 0.65925}, "CVE-2015-3335": {"epss_score": 0.02071, "epss_percentile": 0.83481}, "CVE-2015-3336": {"epss_score": 0.00892, "epss_percentile": 0.75058}, "CVE-2015-3337": {"epss_score": 0.90729, "epss_percentile": 0.99597}, "CVE-2015-3339": {"epss_score": 0.00032, "epss_percentile": 0.08774}, "CVE-2015-3340": {"epss_score": 0.00634, "epss_percentile": 0.69799}, "CVE-2015-3342": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-3343": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2015-3344": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2015-3345": {"epss_score": 0.00247, "epss_percentile": 0.47832}, "CVE-2015-3346": {"epss_score": 0.00397, "epss_percentile": 0.60014}, "CVE-2015-3347": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2015-3348": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-3349": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2015-3350": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2015-3351": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2015-3352": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2015-3353": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-3354": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2015-3355": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2015-3356": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2015-3357": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-3358": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-3359": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-3360": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-3361": {"epss_score": 0.00212, "epss_percentile": 0.4372}, "CVE-2015-3362": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-3363": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2015-3364": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-3365": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-3366": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2015-3367": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2015-3368": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2015-3369": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2015-3370": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2015-3371": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-3372": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-3373": {"epss_score": 0.00435, "epss_percentile": 0.62338}, "CVE-2015-3374": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-3375": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2015-3376": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-3378": {"epss_score": 0.00509, "epss_percentile": 0.65749}, "CVE-2015-3379": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2015-3380": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-3381": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-3382": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-3383": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2015-3384": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-3385": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-3386": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-3387": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-3388": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-3389": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-3390": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-3391": {"epss_score": 0.00262, "epss_percentile": 0.49384}, "CVE-2015-3392": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2015-3393": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2015-3395": {"epss_score": 0.00791, "epss_percentile": 0.73384}, "CVE-2015-3397": {"epss_score": 0.0033, "epss_percentile": 0.55461}, "CVE-2015-3400": {"epss_score": 0.00236, "epss_percentile": 0.46455}, "CVE-2015-3404": {"epss_score": 0.0012, "epss_percentile": 0.31734}, "CVE-2015-3405": {"epss_score": 0.16556, "epss_percentile": 0.94689}, "CVE-2015-3406": {"epss_score": 0.01266, "epss_percentile": 0.79011}, "CVE-2015-3407": {"epss_score": 0.00363, "epss_percentile": 0.57896}, "CVE-2015-3408": {"epss_score": 0.03926, "epss_percentile": 0.87964}, "CVE-2015-3409": {"epss_score": 0.00058, "epss_percentile": 0.18294}, "CVE-2015-3411": {"epss_score": 0.0026, "epss_percentile": 0.49183}, "CVE-2015-3412": {"epss_score": 0.01006, "epss_percentile": 0.76552}, "CVE-2015-3414": {"epss_score": 0.063, "epss_percentile": 0.90655}, "CVE-2015-3415": {"epss_score": 0.063, "epss_percentile": 0.90655}, "CVE-2015-3416": {"epss_score": 0.07527, "epss_percentile": 0.91518}, "CVE-2015-3417": {"epss_score": 0.01017, "epss_percentile": 0.76689}, "CVE-2015-3418": {"epss_score": 0.00497, "epss_percentile": 0.65201}, "CVE-2015-3419": {"epss_score": 0.00161, "epss_percentile": 0.37564}, "CVE-2015-3420": {"epss_score": 0.07633, "epss_percentile": 0.91586}, "CVE-2015-3421": {"epss_score": 0.0017, "epss_percentile": 0.38728}, "CVE-2015-3422": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-3423": {"epss_score": 0.00592, "epss_percentile": 0.68619}, "CVE-2015-3424": {"epss_score": 0.0057, "epss_percentile": 0.67964}, "CVE-2015-3425": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2015-3427": {"epss_score": 0.00439, "epss_percentile": 0.62592}, "CVE-2015-3429": {"epss_score": 0.01531, "epss_percentile": 0.80891}, "CVE-2015-3431": {"epss_score": 0.06181, "epss_percentile": 0.90538}, "CVE-2015-3432": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2015-3435": {"epss_score": 0.10001, "epss_percentile": 0.9281}, "CVE-2015-3436": {"epss_score": 0.0004, "epss_percentile": 0.11973}, "CVE-2015-3438": {"epss_score": 0.01607, "epss_percentile": 0.81306}, "CVE-2015-3439": {"epss_score": 0.03125, "epss_percentile": 0.86454}, "CVE-2015-3440": {"epss_score": 0.10329, "epss_percentile": 0.92948}, "CVE-2015-3441": {"epss_score": 0.00867, "epss_percentile": 0.74661}, "CVE-2015-3442": {"epss_score": 0.01759, "epss_percentile": 0.82141}, "CVE-2015-3443": {"epss_score": 0.00972, "epss_percentile": 0.76134}, "CVE-2015-3446": {"epss_score": 0.01472, "epss_percentile": 0.80511}, "CVE-2015-3447": {"epss_score": 0.00737, "epss_percentile": 0.72325}, "CVE-2015-3448": {"epss_score": 0.00065, "epss_percentile": 0.20671}, "CVE-2015-3449": {"epss_score": 0.00036, "epss_percentile": 0.1021}, "CVE-2015-3450": {"epss_score": 0.0057, "epss_percentile": 0.67939}, "CVE-2015-3451": {"epss_score": 0.04979, "epss_percentile": 0.89359}, "CVE-2015-3454": {"epss_score": 0.0176, "epss_percentile": 0.82144}, "CVE-2015-3455": {"epss_score": 0.06474, "epss_percentile": 0.90781}, "CVE-2015-3456": {"epss_score": 0.36084, "epss_percentile": 0.96954}, "CVE-2015-3457": {"epss_score": 0.08958, "epss_percentile": 0.92337}, "CVE-2015-3458": {"epss_score": 0.02147, "epss_percentile": 0.83768}, "CVE-2015-3459": {"epss_score": 0.17736, "epss_percentile": 0.94897}, "CVE-2015-3610": {"epss_score": 0.00052, "epss_percentile": 0.1644}, "CVE-2015-3611": {"epss_score": 0.06685, "epss_percentile": 0.90945}, "CVE-2015-3612": {"epss_score": 0.00283, "epss_percentile": 0.51403}, "CVE-2015-3613": {"epss_score": 0.02281, "epss_percentile": 0.84244}, "CVE-2015-3614": {"epss_score": 0.0032, "epss_percentile": 0.54625}, "CVE-2015-3615": {"epss_score": 0.00179, "epss_percentile": 0.3983}, "CVE-2015-3616": {"epss_score": 0.00843, "epss_percentile": 0.74253}, "CVE-2015-3617": {"epss_score": 0.0016, "epss_percentile": 0.37425}, "CVE-2015-3618": {"epss_score": 0.0283, "epss_percentile": 0.85775}, "CVE-2015-3619": {"epss_score": 0.00231, "epss_percentile": 0.45787}, "CVE-2015-3620": {"epss_score": 0.00514, "epss_percentile": 0.65957}, "CVE-2015-3621": {"epss_score": 0.00416, "epss_percentile": 0.61164}, "CVE-2015-3622": {"epss_score": 0.06062, "epss_percentile": 0.90444}, "CVE-2015-3623": {"epss_score": 0.04195, "epss_percentile": 0.8838}, "CVE-2015-3624": {"epss_score": 0.00751, "epss_percentile": 0.7264}, "CVE-2015-3625": {"epss_score": 0.00032, "epss_percentile": 0.08828}, "CVE-2015-3626": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-3627": {"epss_score": 0.00161, "epss_percentile": 0.37552}, "CVE-2015-3628": {"epss_score": 0.79043, "epss_percentile": 0.99017}, "CVE-2015-3629": {"epss_score": 0.00189, "epss_percentile": 0.40969}, "CVE-2015-3630": {"epss_score": 0.00102, "epss_percentile": 0.28722}, "CVE-2015-3631": {"epss_score": 0.00134, "epss_percentile": 0.33813}, "CVE-2015-3632": {"epss_score": 0.06754, "epss_percentile": 0.91005}, "CVE-2015-3633": {"epss_score": 0.00113, "epss_percentile": 0.30695}, "CVE-2015-3634": {"epss_score": 0.02067, "epss_percentile": 0.83461}, "CVE-2015-3636": {"epss_score": 0.03016, "epss_percentile": 0.86216}, "CVE-2015-3637": {"epss_score": 0.0085, "epss_percentile": 0.74391}, "CVE-2015-3638": {"epss_score": 0.01612, "epss_percentile": 0.81336}, "CVE-2015-3639": {"epss_score": 0.01367, "epss_percentile": 0.79781}, "CVE-2015-3640": {"epss_score": 0.00879, "epss_percentile": 0.74835}, "CVE-2015-3641": {"epss_score": 0.00832, "epss_percentile": 0.7407}, "CVE-2015-3642": {"epss_score": 0.0029, "epss_percentile": 0.52134}, "CVE-2015-3643": {"epss_score": 0.00136, "epss_percentile": 0.34179}, "CVE-2015-3644": {"epss_score": 0.00248, "epss_percentile": 0.47989}, "CVE-2015-3646": {"epss_score": 0.00148, "epss_percentile": 0.3582}, "CVE-2015-3647": {"epss_score": 0.0036, "epss_percentile": 0.57631}, "CVE-2015-3648": {"epss_score": 0.45832, "epss_percentile": 0.97504}, "CVE-2015-3649": {"epss_score": 0.00062, "epss_percentile": 0.1966}, "CVE-2015-3650": {"epss_score": 0.0013, "epss_percentile": 0.33227}, "CVE-2015-3653": {"epss_score": 0.00647, "epss_percentile": 0.70208}, "CVE-2015-3654": {"epss_score": 0.00906, "epss_percentile": 0.75249}, "CVE-2015-3655": {"epss_score": 0.00107, "epss_percentile": 0.29613}, "CVE-2015-3656": {"epss_score": 0.00763, "epss_percentile": 0.72852}, "CVE-2015-3657": {"epss_score": 0.00763, "epss_percentile": 0.72852}, "CVE-2015-3658": {"epss_score": 0.00273, "epss_percentile": 0.50446}, "CVE-2015-3659": {"epss_score": 0.01109, "epss_percentile": 0.77651}, "CVE-2015-3660": {"epss_score": 0.0032, "epss_percentile": 0.54606}, "CVE-2015-3661": {"epss_score": 0.0324, "epss_percentile": 0.8673}, "CVE-2015-3662": {"epss_score": 0.0324, "epss_percentile": 0.8673}, "CVE-2015-3663": {"epss_score": 0.0324, "epss_percentile": 0.8673}, "CVE-2015-3664": {"epss_score": 0.02022, "epss_percentile": 0.83304}, "CVE-2015-3665": {"epss_score": 0.02022, "epss_percentile": 0.83304}, "CVE-2015-3666": {"epss_score": 0.0324, "epss_percentile": 0.8673}, "CVE-2015-3667": {"epss_score": 0.0324, "epss_percentile": 0.8673}, "CVE-2015-3668": {"epss_score": 0.03642, "epss_percentile": 0.87492}, "CVE-2015-3669": {"epss_score": 0.02022, "epss_percentile": 0.83304}, "CVE-2015-3671": {"epss_score": 0.00048, "epss_percentile": 0.1494}, "CVE-2015-3672": {"epss_score": 0.00043, "epss_percentile": 0.13279}, "CVE-2015-3673": {"epss_score": 0.02073, "epss_percentile": 0.83493}, "CVE-2015-3674": {"epss_score": 0.02159, "epss_percentile": 0.83819}, "CVE-2015-3675": {"epss_score": 0.00317, "epss_percentile": 0.54391}, "CVE-2015-3676": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-3677": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-3678": {"epss_score": 0.00164, "epss_percentile": 0.37895}, "CVE-2015-3679": {"epss_score": 0.02022, "epss_percentile": 0.83304}, "CVE-2015-3680": {"epss_score": 0.02022, "epss_percentile": 0.83304}, "CVE-2015-3681": {"epss_score": 0.02022, "epss_percentile": 0.83304}, "CVE-2015-3682": {"epss_score": 0.02022, "epss_percentile": 0.83304}, "CVE-2015-3683": {"epss_score": 0.02351, "epss_percentile": 0.84469}, "CVE-2015-3684": {"epss_score": 0.01789, "epss_percentile": 0.82275}, "CVE-2015-3685": {"epss_score": 0.01896, "epss_percentile": 0.82755}, "CVE-2015-3686": {"epss_score": 0.02635, "epss_percentile": 0.85292}, "CVE-2015-3687": {"epss_score": 0.02635, "epss_percentile": 0.85292}, "CVE-2015-3688": {"epss_score": 0.02635, "epss_percentile": 0.85292}, "CVE-2015-3689": {"epss_score": 0.01896, "epss_percentile": 0.82755}, "CVE-2015-3690": {"epss_score": 0.00575, "epss_percentile": 0.68113}, "CVE-2015-3691": {"epss_score": 0.01697, "epss_percentile": 0.81817}, "CVE-2015-3692": {"epss_score": 0.00037, "epss_percentile": 0.10635}, "CVE-2015-3693": {"epss_score": 0.23698, "epss_percentile": 0.95804}, "CVE-2015-3694": {"epss_score": 0.01404, "epss_percentile": 0.80039}, "CVE-2015-3695": {"epss_score": 0.0014, "epss_percentile": 0.34723}, "CVE-2015-3696": {"epss_score": 0.0014, "epss_percentile": 0.34723}, "CVE-2015-3697": {"epss_score": 0.0014, "epss_percentile": 0.34723}, "CVE-2015-3698": {"epss_score": 0.0014, "epss_percentile": 0.34723}, "CVE-2015-3699": {"epss_score": 0.0014, "epss_percentile": 0.34723}, "CVE-2015-3700": {"epss_score": 0.00048, "epss_percentile": 0.1501}, "CVE-2015-3701": {"epss_score": 0.0014, "epss_percentile": 0.34723}, "CVE-2015-3702": {"epss_score": 0.00048, "epss_percentile": 0.1501}, "CVE-2015-3703": {"epss_score": 0.01908, "epss_percentile": 0.82814}, "CVE-2015-3704": {"epss_score": 0.37857, "epss_percentile": 0.97073}, "CVE-2015-3705": {"epss_score": 0.01522, "epss_percentile": 0.80839}, "CVE-2015-3706": {"epss_score": 0.01522, "epss_percentile": 0.80839}, "CVE-2015-3707": {"epss_score": 0.02195, "epss_percentile": 0.83951}, "CVE-2015-3708": {"epss_score": 0.00505, "epss_percentile": 0.6559}, "CVE-2015-3709": {"epss_score": 0.00035, "epss_percentile": 0.09968}, "CVE-2015-3710": {"epss_score": 0.00521, "epss_percentile": 0.66218}, "CVE-2015-3711": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-3712": {"epss_score": 0.01213, "epss_percentile": 0.78565}, "CVE-2015-3713": {"epss_score": 0.01395, "epss_percentile": 0.79972}, "CVE-2015-3714": {"epss_score": 0.00291, "epss_percentile": 0.52207}, "CVE-2015-3715": {"epss_score": 0.00568, "epss_percentile": 0.67909}, "CVE-2015-3716": {"epss_score": 0.00144, "epss_percentile": 0.3534}, "CVE-2015-3717": {"epss_score": 0.01855, "epss_percentile": 0.82557}, "CVE-2015-3718": {"epss_score": 0.01178, "epss_percentile": 0.78286}, "CVE-2015-3719": {"epss_score": 0.01404, "epss_percentile": 0.80039}, "CVE-2015-3720": {"epss_score": 0.0043, "epss_percentile": 0.62024}, "CVE-2015-3721": {"epss_score": 0.00575, "epss_percentile": 0.68113}, "CVE-2015-3722": {"epss_score": 0.00596, "epss_percentile": 0.68705}, "CVE-2015-3723": {"epss_score": 0.01177, "epss_percentile": 0.78277}, "CVE-2015-3724": {"epss_score": 0.01177, "epss_percentile": 0.78277}, "CVE-2015-3725": {"epss_score": 0.00596, "epss_percentile": 0.68705}, "CVE-2015-3726": {"epss_score": 0.00326, "epss_percentile": 0.55062}, "CVE-2015-3727": {"epss_score": 0.00942, "epss_percentile": 0.75761}, "CVE-2015-3728": {"epss_score": 0.00187, "epss_percentile": 0.40701}, "CVE-2015-3729": {"epss_score": 0.00652, "epss_percentile": 0.70319}, "CVE-2015-3730": {"epss_score": 0.01081, "epss_percentile": 0.77373}, "CVE-2015-3731": {"epss_score": 0.00998, "epss_percentile": 0.76466}, "CVE-2015-3732": {"epss_score": 0.01576, "epss_percentile": 0.81111}, "CVE-2015-3733": {"epss_score": 0.01643, "epss_percentile": 0.81519}, "CVE-2015-3734": {"epss_score": 0.01643, "epss_percentile": 0.81519}, "CVE-2015-3735": {"epss_score": 0.01643, "epss_percentile": 0.81519}, "CVE-2015-3736": {"epss_score": 0.01643, "epss_percentile": 0.81519}, "CVE-2015-3737": {"epss_score": 0.01643, "epss_percentile": 0.81519}, "CVE-2015-3738": {"epss_score": 0.01081, "epss_percentile": 0.77373}, "CVE-2015-3739": {"epss_score": 0.01643, "epss_percentile": 0.81519}, "CVE-2015-3740": {"epss_score": 0.00998, "epss_percentile": 0.76466}, "CVE-2015-3741": {"epss_score": 0.00998, "epss_percentile": 0.76466}, "CVE-2015-3742": {"epss_score": 0.01081, "epss_percentile": 0.77373}, "CVE-2015-3743": {"epss_score": 0.00998, "epss_percentile": 0.76466}, "CVE-2015-3744": {"epss_score": 0.01081, "epss_percentile": 0.77373}, "CVE-2015-3745": {"epss_score": 0.00998, "epss_percentile": 0.76466}, "CVE-2015-3746": {"epss_score": 0.01081, "epss_percentile": 0.77373}, "CVE-2015-3747": {"epss_score": 0.00998, "epss_percentile": 0.76466}, "CVE-2015-3748": {"epss_score": 0.00998, "epss_percentile": 0.76466}, "CVE-2015-3749": {"epss_score": 0.00998, "epss_percentile": 0.76466}, "CVE-2015-3750": {"epss_score": 0.00771, "epss_percentile": 0.7302}, "CVE-2015-3751": {"epss_score": 0.01553, "epss_percentile": 0.81}, "CVE-2015-3752": {"epss_score": 0.01115, "epss_percentile": 0.77716}, "CVE-2015-3753": {"epss_score": 0.00621, "epss_percentile": 0.69474}, "CVE-2015-3754": {"epss_score": 0.00505, "epss_percentile": 0.65605}, "CVE-2015-3755": {"epss_score": 0.01386, "epss_percentile": 0.7991}, "CVE-2015-3756": {"epss_score": 0.00037, "epss_percentile": 0.11038}, "CVE-2015-3757": {"epss_score": 0.0005, "epss_percentile": 0.15977}, "CVE-2015-3758": {"epss_score": 0.00291, "epss_percentile": 0.52207}, "CVE-2015-3759": {"epss_score": 0.00053, "epss_percentile": 0.16966}, "CVE-2015-3760": {"epss_score": 0.03435, "epss_percentile": 0.87132}, "CVE-2015-3761": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2015-3762": {"epss_score": 0.00472, "epss_percentile": 0.64064}, "CVE-2015-3763": {"epss_score": 0.00633, "epss_percentile": 0.69758}, "CVE-2015-3764": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-3765": {"epss_score": 0.02022, "epss_percentile": 0.83304}, "CVE-2015-3766": {"epss_score": 0.00524, "epss_percentile": 0.66338}, "CVE-2015-3767": {"epss_score": 0.00053, "epss_percentile": 0.16885}, "CVE-2015-3768": {"epss_score": 0.0101, "epss_percentile": 0.76606}, "CVE-2015-3769": {"epss_score": 0.00053, "epss_percentile": 0.16885}, "CVE-2015-3770": {"epss_score": 0.01522, "epss_percentile": 0.80839}, "CVE-2015-3771": {"epss_score": 0.00053, "epss_percentile": 0.16885}, "CVE-2015-3772": {"epss_score": 0.00053, "epss_percentile": 0.16885}, "CVE-2015-3773": {"epss_score": 0.02159, "epss_percentile": 0.83819}, "CVE-2015-3774": {"epss_score": 0.00088, "epss_percentile": 0.25731}, "CVE-2015-3775": {"epss_score": 0.00043, "epss_percentile": 0.13279}, "CVE-2015-3776": {"epss_score": 0.01084, "epss_percentile": 0.77397}, "CVE-2015-3777": {"epss_score": 0.00068, "epss_percentile": 0.21417}, "CVE-2015-3778": {"epss_score": 0.00351, "epss_percentile": 0.57049}, "CVE-2015-3779": {"epss_score": 0.02022, "epss_percentile": 0.83304}, "CVE-2015-3780": {"epss_score": 0.00627, "epss_percentile": 0.69622}, "CVE-2015-3781": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2015-3782": {"epss_score": 0.00524, "epss_percentile": 0.66338}, "CVE-2015-3783": {"epss_score": 0.12635, "epss_percentile": 0.93736}, "CVE-2015-3784": {"epss_score": 0.0087, "epss_percentile": 0.74708}, "CVE-2015-3785": {"epss_score": 0.00094, "epss_percentile": 0.2676}, "CVE-2015-3786": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-3787": {"epss_score": 0.003, "epss_percentile": 0.52946}, "CVE-2015-3788": {"epss_score": 0.0324, "epss_percentile": 0.8673}, "CVE-2015-3789": {"epss_score": 0.0324, "epss_percentile": 0.8673}, "CVE-2015-3790": {"epss_score": 0.0324, "epss_percentile": 0.8673}, "CVE-2015-3791": {"epss_score": 0.0324, "epss_percentile": 0.8673}, "CVE-2015-3792": {"epss_score": 0.0324, "epss_percentile": 0.8673}, "CVE-2015-3793": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-3794": {"epss_score": 0.01895, "epss_percentile": 0.82747}, "CVE-2015-3795": {"epss_score": 0.01575, "epss_percentile": 0.81107}, "CVE-2015-3796": {"epss_score": 0.14689, "epss_percentile": 0.94265}, "CVE-2015-3797": {"epss_score": 0.00882, "epss_percentile": 0.749}, "CVE-2015-3798": {"epss_score": 0.20628, "epss_percentile": 0.9539}, "CVE-2015-3799": {"epss_score": 0.00505, "epss_percentile": 0.65612}, "CVE-2015-3800": {"epss_score": 0.00072, "epss_percentile": 0.22399}, "CVE-2015-3801": {"epss_score": 0.00977, "epss_percentile": 0.76218}, "CVE-2015-3802": {"epss_score": 0.00061, "epss_percentile": 0.19537}, "CVE-2015-3803": {"epss_score": 0.00061, "epss_percentile": 0.19537}, "CVE-2015-3804": {"epss_score": 0.01992, "epss_percentile": 0.83178}, "CVE-2015-3805": {"epss_score": 0.00061, "epss_percentile": 0.19537}, "CVE-2015-3806": {"epss_score": 0.00052, "epss_percentile": 0.16555}, "CVE-2015-3807": {"epss_score": 0.02365, "epss_percentile": 0.84513}, "CVE-2015-3808": {"epss_score": 0.00225, "epss_percentile": 0.45137}, "CVE-2015-3809": {"epss_score": 0.00335, "epss_percentile": 0.55809}, "CVE-2015-3810": {"epss_score": 0.00308, "epss_percentile": 0.53632}, "CVE-2015-3811": {"epss_score": 0.00212, "epss_percentile": 0.4373}, "CVE-2015-3812": {"epss_score": 0.00656, "epss_percentile": 0.7045}, "CVE-2015-3813": {"epss_score": 0.00239, "epss_percentile": 0.46899}, "CVE-2015-3814": {"epss_score": 0.00189, "epss_percentile": 0.40979}, "CVE-2015-3815": {"epss_score": 0.00548, "epss_percentile": 0.67286}, "CVE-2015-3823": {"epss_score": 0.01036, "epss_percentile": 0.76912}, "CVE-2015-3824": {"epss_score": 0.12233, "epss_percentile": 0.93608}, "CVE-2015-3826": {"epss_score": 0.01612, "epss_percentile": 0.81332}, "CVE-2015-3827": {"epss_score": 0.12431, "epss_percentile": 0.93667}, "CVE-2015-3828": {"epss_score": 0.27175, "epss_percentile": 0.96217}, "CVE-2015-3829": {"epss_score": 0.25098, "epss_percentile": 0.95985}, "CVE-2015-3830": {"epss_score": 0.00162, "epss_percentile": 0.3772}, "CVE-2015-3831": {"epss_score": 0.00465, "epss_percentile": 0.6376}, "CVE-2015-3832": {"epss_score": 0.0683, "epss_percentile": 0.91055}, "CVE-2015-3833": {"epss_score": 0.0013, "epss_percentile": 0.33325}, "CVE-2015-3834": {"epss_score": 0.00193, "epss_percentile": 0.41452}, "CVE-2015-3835": {"epss_score": 0.00703, "epss_percentile": 0.71548}, "CVE-2015-3836": {"epss_score": 0.04344, "epss_percentile": 0.88573}, "CVE-2015-3837": {"epss_score": 0.00792, "epss_percentile": 0.73413}, "CVE-2015-3839": {"epss_score": 0.0055, "epss_percentile": 0.67344}, "CVE-2015-3840": {"epss_score": 0.00025, "epss_percentile": 0.06065}, "CVE-2015-3842": {"epss_score": 0.00465, "epss_percentile": 0.6376}, "CVE-2015-3843": {"epss_score": 0.00494, "epss_percentile": 0.65072}, "CVE-2015-3844": {"epss_score": 0.00107, "epss_percentile": 0.29654}, "CVE-2015-3845": {"epss_score": 0.00107, "epss_percentile": 0.29654}, "CVE-2015-3847": {"epss_score": 0.00107, "epss_percentile": 0.29654}, "CVE-2015-3849": {"epss_score": 0.00521, "epss_percentile": 0.66219}, "CVE-2015-3854": {"epss_score": 0.00119, "epss_percentile": 0.31587}, "CVE-2015-3858": {"epss_score": 0.00157, "epss_percentile": 0.37132}, "CVE-2015-3860": {"epss_score": 0.00042, "epss_percentile": 0.12715}, "CVE-2015-3861": {"epss_score": 0.0031, "epss_percentile": 0.53751}, "CVE-2015-3862": {"epss_score": 0.0011, "epss_percentile": 0.30192}, "CVE-2015-3863": {"epss_score": 0.0021, "epss_percentile": 0.436}, "CVE-2015-3864": {"epss_score": 0.87033, "epss_percentile": 0.99409}, "CVE-2015-3865": {"epss_score": 0.00207, "epss_percentile": 0.43117}, "CVE-2015-3867": {"epss_score": 0.01467, "epss_percentile": 0.80472}, "CVE-2015-3868": {"epss_score": 0.04386, "epss_percentile": 0.88633}, "CVE-2015-3869": {"epss_score": 0.01036, "epss_percentile": 0.76912}, "CVE-2015-3870": {"epss_score": 0.01036, "epss_percentile": 0.76912}, "CVE-2015-3871": {"epss_score": 0.01467, "epss_percentile": 0.80472}, "CVE-2015-3872": {"epss_score": 0.01467, "epss_percentile": 0.80472}, "CVE-2015-3873": {"epss_score": 0.01036, "epss_percentile": 0.76912}, "CVE-2015-3874": {"epss_score": 0.01467, "epss_percentile": 0.80472}, "CVE-2015-3875": {"epss_score": 0.02357, "epss_percentile": 0.84485}, "CVE-2015-3876": {"epss_score": 0.04562, "epss_percentile": 0.88854}, "CVE-2015-3877": {"epss_score": 0.01467, "epss_percentile": 0.80472}, "CVE-2015-3878": {"epss_score": 0.01059, "epss_percentile": 0.77151}, "CVE-2015-3879": {"epss_score": 0.00207, "epss_percentile": 0.43117}, "CVE-2015-3880": {"epss_score": 0.00713, "epss_percentile": 0.71794}, "CVE-2015-3881": {"epss_score": 0.00337, "epss_percentile": 0.56023}, "CVE-2015-3882": {"epss_score": 0.00261, "epss_percentile": 0.49276}, "CVE-2015-3883": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2015-3884": {"epss_score": 0.75409, "epss_percentile": 0.98843}, "CVE-2015-3885": {"epss_score": 0.03564, "epss_percentile": 0.87359}, "CVE-2015-3886": {"epss_score": 0.00583, "epss_percentile": 0.68337}, "CVE-2015-3887": {"epss_score": 0.00101, "epss_percentile": 0.28601}, "CVE-2015-3888": {"epss_score": 0.00362, "epss_percentile": 0.57815}, "CVE-2015-3890": {"epss_score": 0.00487, "epss_percentile": 0.64823}, "CVE-2015-3897": {"epss_score": 0.6034, "epss_percentile": 0.98205}, "CVE-2015-3898": {"epss_score": 0.03409, "epss_percentile": 0.8708}, "CVE-2015-3900": {"epss_score": 0.02401, "epss_percentile": 0.84639}, "CVE-2015-3902": {"epss_score": 0.00217, "epss_percentile": 0.44323}, "CVE-2015-3903": {"epss_score": 0.01171, "epss_percentile": 0.7822}, "CVE-2015-3904": {"epss_score": 0.00606, "epss_percentile": 0.69006}, "CVE-2015-3905": {"epss_score": 0.04715, "epss_percentile": 0.89042}, "CVE-2015-3906": {"epss_score": 0.0053, "epss_percentile": 0.66628}, "CVE-2015-3907": {"epss_score": 0.00465, "epss_percentile": 0.63763}, "CVE-2015-3908": {"epss_score": 0.0008, "epss_percentile": 0.24173}, "CVE-2015-3910": {"epss_score": 0.00258, "epss_percentile": 0.48994}, "CVE-2015-3911": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2015-3912": {"epss_score": 0.00106, "epss_percentile": 0.29561}, "CVE-2015-3913": {"epss_score": 0.00281, "epss_percentile": 0.51134}, "CVE-2015-3921": {"epss_score": 0.00157, "epss_percentile": 0.37093}, "CVE-2015-3922": {"epss_score": 0.00303, "epss_percentile": 0.53217}, "CVE-2015-3923": {"epss_score": 0.00417, "epss_percentile": 0.61236}, "CVE-2015-3931": {"epss_score": 0.00355, "epss_percentile": 0.57312}, "CVE-2015-3932": {"epss_score": 0.00411, "epss_percentile": 0.60869}, "CVE-2015-3933": {"epss_score": 0.02429, "epss_percentile": 0.84723}, "CVE-2015-3934": {"epss_score": 0.01345, "epss_percentile": 0.7962}, "CVE-2015-3935": {"epss_score": 0.00307, "epss_percentile": 0.53483}, "CVE-2015-3938": {"epss_score": 0.00437, "epss_percentile": 0.62523}, "CVE-2015-3939": {"epss_score": 0.0032, "epss_percentile": 0.54585}, "CVE-2015-3940": {"epss_score": 0.00048, "epss_percentile": 0.15053}, "CVE-2015-3942": {"epss_score": 0.00797, "epss_percentile": 0.73502}, "CVE-2015-3943": {"epss_score": 0.00244, "epss_percentile": 0.47608}, "CVE-2015-3946": {"epss_score": 0.00106, "epss_percentile": 0.29437}, "CVE-2015-3947": {"epss_score": 0.00199, "epss_percentile": 0.4216}, "CVE-2015-3948": {"epss_score": 0.00213, "epss_percentile": 0.43837}, "CVE-2015-3949": {"epss_score": 0.00065, "epss_percentile": 0.2055}, "CVE-2015-3950": {"epss_score": 0.00065, "epss_percentile": 0.20517}, "CVE-2015-3951": {"epss_score": 0.00533, "epss_percentile": 0.66754}, "CVE-2015-3952": {"epss_score": 0.0012, "epss_percentile": 0.31764}, "CVE-2015-3953": {"epss_score": 0.00248, "epss_percentile": 0.47941}, "CVE-2015-3954": {"epss_score": 0.00533, "epss_percentile": 0.66754}, "CVE-2015-3955": {"epss_score": 0.1445, "epss_percentile": 0.94213}, "CVE-2015-3956": {"epss_score": 0.00236, "epss_percentile": 0.46383}, "CVE-2015-3957": {"epss_score": 0.00063, "epss_percentile": 0.19817}, "CVE-2015-3958": {"epss_score": 0.01993, "epss_percentile": 0.83183}, "CVE-2015-3959": {"epss_score": 0.00072, "epss_percentile": 0.22414}, "CVE-2015-3960": {"epss_score": 0.0044, "epss_percentile": 0.6262}, "CVE-2015-3961": {"epss_score": 0.00576, "epss_percentile": 0.68142}, "CVE-2015-3962": {"epss_score": 0.00264, "epss_percentile": 0.49703}, "CVE-2015-3963": {"epss_score": 0.03005, "epss_percentile": 0.86182}, "CVE-2015-3964": {"epss_score": 0.00709, "epss_percentile": 0.71692}, "CVE-2015-3965": {"epss_score": 0.00439, "epss_percentile": 0.62575}, "CVE-2015-3966": {"epss_score": 0.00204, "epss_percentile": 0.42614}, "CVE-2015-3967": {"epss_score": 0.00077, "epss_percentile": 0.23286}, "CVE-2015-3968": {"epss_score": 0.00336, "epss_percentile": 0.55997}, "CVE-2015-3969": {"epss_score": 0.00448, "epss_percentile": 0.63006}, "CVE-2015-3970": {"epss_score": 0.0087, "epss_percentile": 0.74699}, "CVE-2015-3971": {"epss_score": 0.00313, "epss_percentile": 0.54058}, "CVE-2015-3972": {"epss_score": 0.00615, "epss_percentile": 0.69296}, "CVE-2015-3973": {"epss_score": 0.0073, "epss_percentile": 0.72156}, "CVE-2015-3974": {"epss_score": 0.00494, "epss_percentile": 0.65075}, "CVE-2015-3976": {"epss_score": 0.00332, "epss_percentile": 0.55552}, "CVE-2015-3977": {"epss_score": 0.00127, "epss_percentile": 0.32937}, "CVE-2015-3978": {"epss_score": 0.00062, "epss_percentile": 0.19745}, "CVE-2015-3979": {"epss_score": 0.00654, "epss_percentile": 0.70339}, "CVE-2015-3980": {"epss_score": 0.00228, "epss_percentile": 0.45479}, "CVE-2015-3981": {"epss_score": 0.00291, "epss_percentile": 0.52169}, "CVE-2015-3982": {"epss_score": 0.00322, "epss_percentile": 0.5475}, "CVE-2015-3983": {"epss_score": 0.006, "epss_percentile": 0.6882}, "CVE-2015-3986": {"epss_score": 0.01624, "epss_percentile": 0.81404}, "CVE-2015-3987": {"epss_score": 0.00073, "epss_percentile": 0.22493}, "CVE-2015-3988": {"epss_score": 0.00411, "epss_percentile": 0.60904}, "CVE-2015-3989": {"epss_score": 0.00261, "epss_percentile": 0.49304}, "CVE-2015-3990": {"epss_score": 0.00583, "epss_percentile": 0.68351}, "CVE-2015-3991": {"epss_score": 0.04756, "epss_percentile": 0.89113}, "CVE-2015-3993": {"epss_score": 0.00237, "epss_percentile": 0.46721}, "CVE-2015-3994": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2015-3995": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2015-3996": {"epss_score": 0.00158, "epss_percentile": 0.37253}, "CVE-2015-3998": {"epss_score": 0.00173, "epss_percentile": 0.39081}, "CVE-2015-3999": {"epss_score": 0.00133, "epss_percentile": 0.33709}, "CVE-2015-4000": {"epss_score": 0.939, "epss_percentile": 0.99865}, "CVE-2015-4001": {"epss_score": 0.05914, "epss_percentile": 0.90317}, "CVE-2015-4002": {"epss_score": 0.02868, "epss_percentile": 0.85865}, "CVE-2015-4003": {"epss_score": 0.01469, "epss_percentile": 0.80483}, "CVE-2015-4004": {"epss_score": 0.04445, "epss_percentile": 0.88697}, "CVE-2015-4010": {"epss_score": 0.01352, "epss_percentile": 0.79685}, "CVE-2015-4016": {"epss_score": 0.01173, "epss_percentile": 0.78237}, "CVE-2015-4017": {"epss_score": 0.00311, "epss_percentile": 0.53861}, "CVE-2015-4018": {"epss_score": 0.0251, "epss_percentile": 0.8495}, "CVE-2015-4020": {"epss_score": 0.00524, "epss_percentile": 0.66315}, "CVE-2015-4021": {"epss_score": 0.42026, "epss_percentile": 0.97306}, "CVE-2015-4022": {"epss_score": 0.20639, "epss_percentile": 0.95393}, "CVE-2015-4024": {"epss_score": 0.75519, "epss_percentile": 0.9885}, "CVE-2015-4025": {"epss_score": 0.06077, "epss_percentile": 0.90458}, "CVE-2015-4026": {"epss_score": 0.09632, "epss_percentile": 0.92632}, "CVE-2015-4027": {"epss_score": 0.01002, "epss_percentile": 0.76509}, "CVE-2015-4029": {"epss_score": 0.01297, "epss_percentile": 0.79261}, "CVE-2015-4031": {"epss_score": 0.40634, "epss_percentile": 0.97228}, "CVE-2015-4032": {"epss_score": 0.01305, "epss_percentile": 0.79322}, "CVE-2015-4033": {"epss_score": 0.00429, "epss_percentile": 0.61973}, "CVE-2015-4034": {"epss_score": 0.00246, "epss_percentile": 0.47802}, "CVE-2015-4035": {"epss_score": 0.00612, "epss_percentile": 0.69218}, "CVE-2015-4036": {"epss_score": 0.00104, "epss_percentile": 0.29214}, "CVE-2015-4037": {"epss_score": 0.00096, "epss_percentile": 0.27411}, "CVE-2015-4038": {"epss_score": 0.11974, "epss_percentile": 0.93531}, "CVE-2015-4039": {"epss_score": 0.003, "epss_percentile": 0.52936}, "CVE-2015-4040": {"epss_score": 0.06773, "epss_percentile": 0.91017}, "CVE-2015-4041": {"epss_score": 0.00066, "epss_percentile": 0.20944}, "CVE-2015-4042": {"epss_score": 0.00391, "epss_percentile": 0.59631}, "CVE-2015-4043": {"epss_score": 0.00421, "epss_percentile": 0.61529}, "CVE-2015-4045": {"epss_score": 0.00062, "epss_percentile": 0.19694}, "CVE-2015-4046": {"epss_score": 0.06204, "epss_percentile": 0.90565}, "CVE-2015-4047": {"epss_score": 0.03587, "epss_percentile": 0.87394}, "CVE-2015-4049": {"epss_score": 0.0065, "epss_percentile": 0.70273}, "CVE-2015-4050": {"epss_score": 0.76192, "epss_percentile": 0.98881}, "CVE-2015-4051": {"epss_score": 0.01214, "epss_percentile": 0.78576}, "CVE-2015-4053": {"epss_score": 0.0005, "epss_percentile": 0.15701}, "CVE-2015-4054": {"epss_score": 0.03375, "epss_percentile": 0.87015}, "CVE-2015-4056": {"epss_score": 0.0006, "epss_percentile": 0.19053}, "CVE-2015-4057": {"epss_score": 0.00313, "epss_percentile": 0.54075}, "CVE-2015-4059": {"epss_score": 0.15009, "epss_percentile": 0.94341}, "CVE-2015-4060": {"epss_score": 0.15009, "epss_percentile": 0.94341}, "CVE-2015-4062": {"epss_score": 0.25156, "epss_percentile": 0.95991}, "CVE-2015-4063": {"epss_score": 0.03197, "epss_percentile": 0.86615}, "CVE-2015-4064": {"epss_score": 0.03371, "epss_percentile": 0.87011}, "CVE-2015-4065": {"epss_score": 0.00762, "epss_percentile": 0.72835}, "CVE-2015-4066": {"epss_score": 0.02669, "epss_percentile": 0.85385}, "CVE-2015-4067": {"epss_score": 0.10815, "epss_percentile": 0.9312}, "CVE-2015-4068": {"epss_score": 0.81937, "epss_percentile": 0.99165}, "CVE-2015-4069": {"epss_score": 0.00515, "epss_percentile": 0.65999}, "CVE-2015-4070": {"epss_score": 0.00157, "epss_percentile": 0.37087}, "CVE-2015-4071": {"epss_score": 0.12639, "epss_percentile": 0.93737}, "CVE-2015-4072": {"epss_score": 0.00444, "epss_percentile": 0.62848}, "CVE-2015-4073": {"epss_score": 0.10155, "epss_percentile": 0.92867}, "CVE-2015-4074": {"epss_score": 0.8582, "epss_percentile": 0.99351}, "CVE-2015-4075": {"epss_score": 0.17382, "epss_percentile": 0.94842}, "CVE-2015-4077": {"epss_score": 0.00212, "epss_percentile": 0.4376}, "CVE-2015-4078": {"epss_score": 0.00236, "epss_percentile": 0.46453}, "CVE-2015-4080": {"epss_score": 0.00666, "epss_percentile": 0.70694}, "CVE-2015-4082": {"epss_score": 0.00858, "epss_percentile": 0.74507}, "CVE-2015-4084": {"epss_score": 0.01451, "epss_percentile": 0.80357}, "CVE-2015-4085": {"epss_score": 0.00392, "epss_percentile": 0.59693}, "CVE-2015-4089": {"epss_score": 0.0018, "epss_percentile": 0.39983}, "CVE-2015-4091": {"epss_score": 0.00957, "epss_percentile": 0.75936}, "CVE-2015-4092": {"epss_score": 0.02109, "epss_percentile": 0.83642}, "CVE-2015-4093": {"epss_score": 0.00237, "epss_percentile": 0.46657}, "CVE-2015-4094": {"epss_score": 0.00105, "epss_percentile": 0.29371}, "CVE-2015-4100": {"epss_score": 0.00274, "epss_percentile": 0.50488}, "CVE-2015-4103": {"epss_score": 0.00121, "epss_percentile": 0.32009}, "CVE-2015-4104": {"epss_score": 0.08429, "epss_percentile": 0.92047}, "CVE-2015-4105": {"epss_score": 0.00121, "epss_percentile": 0.32009}, "CVE-2015-4106": {"epss_score": 0.00085, "epss_percentile": 0.2512}, "CVE-2015-4108": {"epss_score": 0.00843, "epss_percentile": 0.74247}, "CVE-2015-4109": {"epss_score": 0.0088, "epss_percentile": 0.74857}, "CVE-2015-4111": {"epss_score": 0.01404, "epss_percentile": 0.80035}, "CVE-2015-4112": {"epss_score": 0.00217, "epss_percentile": 0.44296}, "CVE-2015-4116": {"epss_score": 0.05426, "epss_percentile": 0.89868}, "CVE-2015-4117": {"epss_score": 0.07499, "epss_percentile": 0.91505}, "CVE-2015-4118": {"epss_score": 0.01417, "epss_percentile": 0.80146}, "CVE-2015-4119": {"epss_score": 0.04615, "epss_percentile": 0.88921}, "CVE-2015-4127": {"epss_score": 0.01716, "epss_percentile": 0.81905}, "CVE-2015-4129": {"epss_score": 0.00806, "epss_percentile": 0.7365}, "CVE-2015-4132": {"epss_score": 0.00284, "epss_percentile": 0.51425}, "CVE-2015-4133": {"epss_score": 0.75217, "epss_percentile": 0.98834}, "CVE-2015-4134": {"epss_score": 0.004, "epss_percentile": 0.60193}, "CVE-2015-4135": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2015-4137": {"epss_score": 0.0096, "epss_percentile": 0.75967}, "CVE-2015-4138": {"epss_score": 0.01837, "epss_percentile": 0.82481}, "CVE-2015-4139": {"epss_score": 0.00179, "epss_percentile": 0.39823}, "CVE-2015-4140": {"epss_score": 0.00104, "epss_percentile": 0.29153}, "CVE-2015-4141": {"epss_score": 0.01465, "epss_percentile": 0.80451}, "CVE-2015-4142": {"epss_score": 0.07071, "epss_percentile": 0.91228}, "CVE-2015-4143": {"epss_score": 0.01205, "epss_percentile": 0.78515}, "CVE-2015-4144": {"epss_score": 0.01205, "epss_percentile": 0.78515}, "CVE-2015-4145": {"epss_score": 0.01205, "epss_percentile": 0.78515}, "CVE-2015-4146": {"epss_score": 0.01312, "epss_percentile": 0.79377}, "CVE-2015-4147": {"epss_score": 0.50785, "epss_percentile": 0.97749}, "CVE-2015-4148": {"epss_score": 0.16938, "epss_percentile": 0.9475}, "CVE-2015-4152": {"epss_score": 0.00629, "epss_percentile": 0.69675}, "CVE-2015-4153": {"epss_score": 0.4589, "epss_percentile": 0.97506}, "CVE-2015-4155": {"epss_score": 0.00133, "epss_percentile": 0.33624}, "CVE-2015-4156": {"epss_score": 0.00052, "epss_percentile": 0.16347}, "CVE-2015-4157": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2015-4158": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2015-4159": {"epss_score": 0.00294, "epss_percentile": 0.52392}, "CVE-2015-4160": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2015-4161": {"epss_score": 0.00467, "epss_percentile": 0.63855}, "CVE-2015-4162": {"epss_score": 0.00318, "epss_percentile": 0.54456}, "CVE-2015-4163": {"epss_score": 0.00121, "epss_percentile": 0.31941}, "CVE-2015-4164": {"epss_score": 0.00074, "epss_percentile": 0.22679}, "CVE-2015-4165": {"epss_score": 0.02304, "epss_percentile": 0.8432}, "CVE-2015-4166": {"epss_score": 0.00271, "epss_percentile": 0.50342}, "CVE-2015-4167": {"epss_score": 0.00046, "epss_percentile": 0.14159}, "CVE-2015-4170": {"epss_score": 0.00064, "epss_percentile": 0.20265}, "CVE-2015-4171": {"epss_score": 0.01012, "epss_percentile": 0.76628}, "CVE-2015-4173": {"epss_score": 0.00338, "epss_percentile": 0.56124}, "CVE-2015-4174": {"epss_score": 0.00819, "epss_percentile": 0.73871}, "CVE-2015-4176": {"epss_score": 0.0005, "epss_percentile": 0.15832}, "CVE-2015-4177": {"epss_score": 0.00042, "epss_percentile": 0.12881}, "CVE-2015-4178": {"epss_score": 0.00042, "epss_percentile": 0.12881}, "CVE-2015-4179": {"epss_score": 0.00168, "epss_percentile": 0.38411}, "CVE-2015-4180": {"epss_score": 0.01042, "epss_percentile": 0.76976}, "CVE-2015-4181": {"epss_score": 0.18374, "epss_percentile": 0.95007}, "CVE-2015-4182": {"epss_score": 0.00206, "epss_percentile": 0.42942}, "CVE-2015-4183": {"epss_score": 0.00194, "epss_percentile": 0.41552}, "CVE-2015-4184": {"epss_score": 0.00575, "epss_percentile": 0.68119}, "CVE-2015-4185": {"epss_score": 0.00115, "epss_percentile": 0.31004}, "CVE-2015-4186": {"epss_score": 0.00194, "epss_percentile": 0.41552}, "CVE-2015-4188": {"epss_score": 0.00276, "epss_percentile": 0.50704}, "CVE-2015-4189": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2015-4190": {"epss_score": 0.00291, "epss_percentile": 0.52207}, "CVE-2015-4191": {"epss_score": 0.00756, "epss_percentile": 0.72737}, "CVE-2015-4194": {"epss_score": 0.00428, "epss_percentile": 0.61949}, "CVE-2015-4195": {"epss_score": 0.00597, "epss_percentile": 0.68736}, "CVE-2015-4196": {"epss_score": 0.00241, "epss_percentile": 0.47247}, "CVE-2015-4197": {"epss_score": 0.00633, "epss_percentile": 0.69772}, "CVE-2015-4198": {"epss_score": 0.00416, "epss_percentile": 0.61181}, "CVE-2015-4199": {"epss_score": 0.00526, "epss_percentile": 0.66434}, "CVE-2015-4200": {"epss_score": 0.00851, "epss_percentile": 0.74398}, "CVE-2015-4201": {"epss_score": 0.00756, "epss_percentile": 0.72737}, "CVE-2015-4202": {"epss_score": 0.00447, "epss_percentile": 0.6296}, "CVE-2015-4203": {"epss_score": 0.0066, "epss_percentile": 0.70521}, "CVE-2015-4204": {"epss_score": 0.00671, "epss_percentile": 0.70807}, "CVE-2015-4205": {"epss_score": 0.00416, "epss_percentile": 0.61169}, "CVE-2015-4206": {"epss_score": 0.00908, "epss_percentile": 0.75289}, "CVE-2015-4207": {"epss_score": 0.00328, "epss_percentile": 0.55281}, "CVE-2015-4208": {"epss_score": 0.00601, "epss_percentile": 0.68852}, "CVE-2015-4209": {"epss_score": 0.00778, "epss_percentile": 0.7313}, "CVE-2015-4210": {"epss_score": 0.00416, "epss_percentile": 0.61181}, "CVE-2015-4211": {"epss_score": 0.00368, "epss_percentile": 0.58184}, "CVE-2015-4212": {"epss_score": 0.00428, "epss_percentile": 0.61949}, "CVE-2015-4213": {"epss_score": 0.00724, "epss_percentile": 0.72035}, "CVE-2015-4214": {"epss_score": 0.00292, "epss_percentile": 0.52224}, "CVE-2015-4215": {"epss_score": 0.00521, "epss_percentile": 0.6624}, "CVE-2015-4216": {"epss_score": 0.00882, "epss_percentile": 0.74884}, "CVE-2015-4217": {"epss_score": 0.00684, "epss_percentile": 0.71127}, "CVE-2015-4218": {"epss_score": 0.00428, "epss_percentile": 0.61949}, "CVE-2015-4219": {"epss_score": 0.00408, "epss_percentile": 0.6069}, "CVE-2015-4220": {"epss_score": 0.00416, "epss_percentile": 0.61181}, "CVE-2015-4221": {"epss_score": 0.00155, "epss_percentile": 0.36801}, "CVE-2015-4222": {"epss_score": 0.00495, "epss_percentile": 0.65116}, "CVE-2015-4223": {"epss_score": 0.00404, "epss_percentile": 0.60417}, "CVE-2015-4224": {"epss_score": 0.00235, "epss_percentile": 0.46236}, "CVE-2015-4225": {"epss_score": 0.00278, "epss_percentile": 0.50871}, "CVE-2015-4226": {"epss_score": 0.00679, "epss_percentile": 0.71018}, "CVE-2015-4227": {"epss_score": 0.00851, "epss_percentile": 0.74398}, "CVE-2015-4228": {"epss_score": 0.00349, "epss_percentile": 0.56879}, "CVE-2015-4229": {"epss_score": 0.00428, "epss_percentile": 0.61949}, "CVE-2015-4230": {"epss_score": 0.00851, "epss_percentile": 0.74398}, "CVE-2015-4231": {"epss_score": 0.00112, "epss_percentile": 0.30554}, "CVE-2015-4232": {"epss_score": 0.0028, "epss_percentile": 0.51012}, "CVE-2015-4233": {"epss_score": 0.00495, "epss_percentile": 0.65116}, "CVE-2015-4234": {"epss_score": 0.00122, "epss_percentile": 0.3206}, "CVE-2015-4235": {"epss_score": 0.00521, "epss_percentile": 0.66229}, "CVE-2015-4236": {"epss_score": 0.00603, "epss_percentile": 0.68939}, "CVE-2015-4237": {"epss_score": 0.00222, "epss_percentile": 0.44731}, "CVE-2015-4238": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2015-4239": {"epss_score": 0.00501, "epss_percentile": 0.65331}, "CVE-2015-4240": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-4241": {"epss_score": 0.00436, "epss_percentile": 0.62447}, "CVE-2015-4242": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-4243": {"epss_score": 0.00262, "epss_percentile": 0.49399}, "CVE-2015-4244": {"epss_score": 0.0018, "epss_percentile": 0.39876}, "CVE-2015-4252": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-4253": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-4254": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2015-4255": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-4256": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-4257": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-4258": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-4259": {"epss_score": 0.00136, "epss_percentile": 0.34119}, "CVE-2015-4260": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-4262": {"epss_score": 0.00366, "epss_percentile": 0.58054}, "CVE-2015-4263": {"epss_score": 0.00169, "epss_percentile": 0.38643}, "CVE-2015-4265": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2015-4266": {"epss_score": 0.00217, "epss_percentile": 0.44296}, "CVE-2015-4267": {"epss_score": 0.00117, "epss_percentile": 0.31377}, "CVE-2015-4268": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-4269": {"epss_score": 0.00388, "epss_percentile": 0.59357}, "CVE-2015-4270": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-4271": {"epss_score": 0.0035, "epss_percentile": 0.56939}, "CVE-2015-4272": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2015-4273": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-4274": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2015-4275": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2015-4276": {"epss_score": 0.01205, "epss_percentile": 0.78512}, "CVE-2015-4277": {"epss_score": 0.00341, "epss_percentile": 0.56298}, "CVE-2015-4278": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2015-4279": {"epss_score": 0.00302, "epss_percentile": 0.53088}, "CVE-2015-4280": {"epss_score": 0.00264, "epss_percentile": 0.49573}, "CVE-2015-4281": {"epss_score": 0.00134, "epss_percentile": 0.33756}, "CVE-2015-4282": {"epss_score": 0.00278, "epss_percentile": 0.50889}, "CVE-2015-4283": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-4284": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2015-4285": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2015-4286": {"epss_score": 0.00078, "epss_percentile": 0.23614}, "CVE-2015-4287": {"epss_score": 0.00184, "epss_percentile": 0.40384}, "CVE-2015-4288": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2015-4289": {"epss_score": 0.00528, "epss_percentile": 0.66568}, "CVE-2015-4290": {"epss_score": 0.00086, "epss_percentile": 0.25387}, "CVE-2015-4291": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-4292": {"epss_score": 0.00402, "epss_percentile": 0.60288}, "CVE-2015-4293": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2015-4294": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-4295": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2015-4296": {"epss_score": 0.00918, "epss_percentile": 0.75435}, "CVE-2015-4297": {"epss_score": 0.00062, "epss_percentile": 0.19596}, "CVE-2015-4298": {"epss_score": 0.00549, "epss_percentile": 0.67304}, "CVE-2015-4299": {"epss_score": 0.00549, "epss_percentile": 0.67304}, "CVE-2015-4301": {"epss_score": 0.0082, "epss_percentile": 0.73886}, "CVE-2015-4302": {"epss_score": 0.00696, "epss_percentile": 0.71383}, "CVE-2015-4303": {"epss_score": 0.00572, "epss_percentile": 0.6801}, "CVE-2015-4304": {"epss_score": 0.00364, "epss_percentile": 0.57933}, "CVE-2015-4305": {"epss_score": 0.0017, "epss_percentile": 0.38749}, "CVE-2015-4306": {"epss_score": 0.00374, "epss_percentile": 0.5855}, "CVE-2015-4307": {"epss_score": 0.00364, "epss_percentile": 0.57933}, "CVE-2015-4308": {"epss_score": 0.0025, "epss_percentile": 0.48122}, "CVE-2015-4310": {"epss_score": 0.00469, "epss_percentile": 0.6395}, "CVE-2015-4314": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2015-4315": {"epss_score": 0.00455, "epss_percentile": 0.63299}, "CVE-2015-4316": {"epss_score": 0.00455, "epss_percentile": 0.63299}, "CVE-2015-4317": {"epss_score": 0.00833, "epss_percentile": 0.74082}, "CVE-2015-4318": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2015-4319": {"epss_score": 0.00596, "epss_percentile": 0.68711}, "CVE-2015-4320": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2015-4321": {"epss_score": 0.00212, "epss_percentile": 0.43781}, "CVE-2015-4322": {"epss_score": 0.00173, "epss_percentile": 0.39128}, "CVE-2015-4323": {"epss_score": 0.00806, "epss_percentile": 0.73661}, "CVE-2015-4324": {"epss_score": 0.00828, "epss_percentile": 0.73991}, "CVE-2015-4325": {"epss_score": 0.00093, "epss_percentile": 0.26693}, "CVE-2015-4327": {"epss_score": 0.00122, "epss_percentile": 0.3206}, "CVE-2015-4328": {"epss_score": 0.00243, "epss_percentile": 0.47513}, "CVE-2015-4329": {"epss_score": 0.00462, "epss_percentile": 0.63621}, "CVE-2015-4330": {"epss_score": 0.0015, "epss_percentile": 0.36138}, "CVE-2015-4331": {"epss_score": 0.00165, "epss_percentile": 0.38059}, "CVE-2015-4334": {"epss_score": 0.00579, "epss_percentile": 0.68211}, "CVE-2015-4335": {"epss_score": 0.0712, "epss_percentile": 0.91263}, "CVE-2015-4336": {"epss_score": 0.01457, "epss_percentile": 0.80399}, "CVE-2015-4337": {"epss_score": 0.00179, "epss_percentile": 0.39823}, "CVE-2015-4338": {"epss_score": 0.00518, "epss_percentile": 0.66116}, "CVE-2015-4342": {"epss_score": 0.03761, "epss_percentile": 0.87689}, "CVE-2015-4344": {"epss_score": 0.01352, "epss_percentile": 0.79687}, "CVE-2015-4345": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2015-4346": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-4347": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-4348": {"epss_score": 0.00329, "epss_percentile": 0.55304}, "CVE-2015-4349": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-4350": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-4351": {"epss_score": 0.00573, "epss_percentile": 0.68059}, "CVE-2015-4352": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-4353": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-4354": {"epss_score": 0.00175, "epss_percentile": 0.39319}, "CVE-2015-4355": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-4356": {"epss_score": 0.00175, "epss_percentile": 0.39319}, "CVE-2015-4357": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2015-4358": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2015-4359": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2015-4360": {"epss_score": 0.00254, "epss_percentile": 0.48535}, "CVE-2015-4361": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2015-4362": {"epss_score": 0.00295, "epss_percentile": 0.52519}, "CVE-2015-4363": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2015-4364": {"epss_score": 0.00174, "epss_percentile": 0.39171}, "CVE-2015-4365": {"epss_score": 0.00158, "epss_percentile": 0.37221}, "CVE-2015-4366": {"epss_score": 0.00158, "epss_percentile": 0.37221}, "CVE-2015-4367": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2015-4368": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2015-4369": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2015-4370": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2015-4371": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-4372": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2015-4373": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2015-4374": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2015-4375": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2015-4376": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2015-4377": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-4378": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-4379": {"epss_score": 0.00253, "epss_percentile": 0.48446}, "CVE-2015-4380": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2015-4381": {"epss_score": 0.00232, "epss_percentile": 0.45873}, "CVE-2015-4382": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2015-4383": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-4384": {"epss_score": 0.0016, "epss_percentile": 0.37451}, "CVE-2015-4385": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-4386": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-4387": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2015-4388": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-4389": {"epss_score": 0.00207, "epss_percentile": 0.43078}, "CVE-2015-4390": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2015-4391": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2015-4392": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2015-4393": {"epss_score": 0.01266, "epss_percentile": 0.79013}, "CVE-2015-4394": {"epss_score": 0.00234, "epss_percentile": 0.46154}, "CVE-2015-4395": {"epss_score": 0.0017, "epss_percentile": 0.38671}, "CVE-2015-4396": {"epss_score": 0.00146, "epss_percentile": 0.356}, "CVE-2015-4397": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2015-4398": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2015-4400": {"epss_score": 0.0015, "epss_percentile": 0.36078}, "CVE-2015-4407": {"epss_score": 0.00568, "epss_percentile": 0.67909}, "CVE-2015-4408": {"epss_score": 0.00568, "epss_percentile": 0.67909}, "CVE-2015-4409": {"epss_score": 0.00718, "epss_percentile": 0.71931}, "CVE-2015-4410": {"epss_score": 0.02283, "epss_percentile": 0.8426}, "CVE-2015-4411": {"epss_score": 0.0308, "epss_percentile": 0.86371}, "CVE-2015-4412": {"epss_score": 0.01749, "epss_percentile": 0.82088}, "CVE-2015-4413": {"epss_score": 0.0044, "epss_percentile": 0.62619}, "CVE-2015-4414": {"epss_score": 0.09051, "epss_percentile": 0.9238}, "CVE-2015-4415": {"epss_score": 0.00231, "epss_percentile": 0.45846}, "CVE-2015-4418": {"epss_score": 0.0487, "epss_percentile": 0.8923}, "CVE-2015-4420": {"epss_score": 0.00608, "epss_percentile": 0.69065}, "CVE-2015-4421": {"epss_score": 0.00161, "epss_percentile": 0.37599}, "CVE-2015-4422": {"epss_score": 0.00067, "epss_percentile": 0.21063}, "CVE-2015-4425": {"epss_score": 0.00034, "epss_percentile": 0.09452}, "CVE-2015-4426": {"epss_score": 3e-05, "epss_percentile": 0.00082}, "CVE-2015-4427": {"epss_score": 0.0018, "epss_percentile": 0.39898}, "CVE-2015-4428": {"epss_score": 0.1049, "epss_percentile": 0.93008}, "CVE-2015-4429": {"epss_score": 0.02395, "epss_percentile": 0.84615}, "CVE-2015-4430": {"epss_score": 0.62732, "epss_percentile": 0.98306}, "CVE-2015-4431": {"epss_score": 0.05538, "epss_percentile": 0.89975}, "CVE-2015-4432": {"epss_score": 0.62732, "epss_percentile": 0.98306}, "CVE-2015-4433": {"epss_score": 0.06665, "epss_percentile": 0.90927}, "CVE-2015-4435": {"epss_score": 0.04144, "epss_percentile": 0.88313}, "CVE-2015-4438": {"epss_score": 0.04144, "epss_percentile": 0.88313}, "CVE-2015-4441": {"epss_score": 0.00885, "epss_percentile": 0.74944}, "CVE-2015-4443": {"epss_score": 0.01233, "epss_percentile": 0.78744}, "CVE-2015-4444": {"epss_score": 0.01233, "epss_percentile": 0.78744}, "CVE-2015-4445": {"epss_score": 0.04144, "epss_percentile": 0.88313}, "CVE-2015-4446": {"epss_score": 0.00424, "epss_percentile": 0.61655}, "CVE-2015-4447": {"epss_score": 0.06102, "epss_percentile": 0.90482}, "CVE-2015-4448": {"epss_score": 0.02516, "epss_percentile": 0.84986}, "CVE-2015-4449": {"epss_score": 0.02761, "epss_percentile": 0.85602}, "CVE-2015-4450": {"epss_score": 0.02761, "epss_percentile": 0.85602}, "CVE-2015-4451": {"epss_score": 0.0313, "epss_percentile": 0.86465}, "CVE-2015-4452": {"epss_score": 0.0313, "epss_percentile": 0.86465}, "CVE-2015-4453": {"epss_score": 0.40869, "epss_percentile": 0.97242}, "CVE-2015-4454": {"epss_score": 0.00644, "epss_percentile": 0.70068}, "CVE-2015-4455": {"epss_score": 0.80327, "epss_percentile": 0.99081}, "CVE-2015-4456": {"epss_score": 0.00161, "epss_percentile": 0.37602}, "CVE-2015-4457": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2015-4458": {"epss_score": 0.00444, "epss_percentile": 0.62814}, "CVE-2015-4460": {"epss_score": 0.00372, "epss_percentile": 0.58454}, "CVE-2015-4461": {"epss_score": 0.00352, "epss_percentile": 0.5708}, "CVE-2015-4462": {"epss_score": 0.00224, "epss_percentile": 0.45067}, "CVE-2015-4463": {"epss_score": 0.00184, "epss_percentile": 0.40414}, "CVE-2015-4464": {"epss_score": 0.00585, "epss_percentile": 0.68408}, "CVE-2015-4465": {"epss_score": 0.00324, "epss_percentile": 0.54964}, "CVE-2015-4467": {"epss_score": 0.0048, "epss_percentile": 0.64457}, "CVE-2015-4468": {"epss_score": 0.0048, "epss_percentile": 0.64457}, "CVE-2015-4469": {"epss_score": 0.0048, "epss_percentile": 0.64457}, "CVE-2015-4470": {"epss_score": 0.00425, "epss_percentile": 0.61717}, "CVE-2015-4471": {"epss_score": 0.00584, "epss_percentile": 0.68375}, "CVE-2015-4472": {"epss_score": 0.00466, "epss_percentile": 0.63788}, "CVE-2015-4473": {"epss_score": 0.03655, "epss_percentile": 0.87514}, "CVE-2015-4474": {"epss_score": 0.02206, "epss_percentile": 0.84004}, "CVE-2015-4475": {"epss_score": 0.01248, "epss_percentile": 0.78864}, "CVE-2015-4476": {"epss_score": 0.00483, "epss_percentile": 0.64574}, "CVE-2015-4477": {"epss_score": 0.0291, "epss_percentile": 0.8597}, "CVE-2015-4478": {"epss_score": 0.00661, "epss_percentile": 0.70575}, "CVE-2015-4479": {"epss_score": 0.02255, "epss_percentile": 0.84165}, "CVE-2015-4480": {"epss_score": 0.02284, "epss_percentile": 0.84264}, "CVE-2015-4481": {"epss_score": 0.00164, "epss_percentile": 0.37869}, "CVE-2015-4482": {"epss_score": 0.00091, "epss_percentile": 0.26389}, "CVE-2015-4483": {"epss_score": 0.00299, "epss_percentile": 0.52892}, "CVE-2015-4484": {"epss_score": 0.00848, "epss_percentile": 0.7436}, "CVE-2015-4485": {"epss_score": 0.07599, "epss_percentile": 0.91561}, "CVE-2015-4486": {"epss_score": 0.01667, "epss_percentile": 0.81657}, "CVE-2015-4487": {"epss_score": 0.02676, "epss_percentile": 0.85402}, "CVE-2015-4488": {"epss_score": 0.01901, "epss_percentile": 0.82778}, "CVE-2015-4489": {"epss_score": 0.02203, "epss_percentile": 0.83995}, "CVE-2015-4490": {"epss_score": 0.00337, "epss_percentile": 0.56062}, "CVE-2015-4491": {"epss_score": 0.04296, "epss_percentile": 0.88509}, "CVE-2015-4492": {"epss_score": 0.02306, "epss_percentile": 0.84323}, "CVE-2015-4493": {"epss_score": 0.0731, "epss_percentile": 0.914}, "CVE-2015-4494": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2015-4495": {"epss_score": 0.71568, "epss_percentile": 0.98673}, "CVE-2015-4496": {"epss_score": 0.02429, "epss_percentile": 0.84722}, "CVE-2015-4497": {"epss_score": 0.0304, "epss_percentile": 0.86273}, "CVE-2015-4498": {"epss_score": 0.00576, "epss_percentile": 0.68145}, "CVE-2015-4499": {"epss_score": 0.01558, "epss_percentile": 0.81025}, "CVE-2015-4500": {"epss_score": 0.03173, "epss_percentile": 0.86553}, "CVE-2015-4501": {"epss_score": 0.02918, "epss_percentile": 0.85986}, "CVE-2015-4502": {"epss_score": 0.00775, "epss_percentile": 0.73081}, "CVE-2015-4503": {"epss_score": 0.00575, "epss_percentile": 0.68104}, "CVE-2015-4504": {"epss_score": 0.02099, "epss_percentile": 0.83595}, "CVE-2015-4505": {"epss_score": 0.00105, "epss_percentile": 0.29369}, "CVE-2015-4506": {"epss_score": 0.07974, "epss_percentile": 0.91799}, "CVE-2015-4507": {"epss_score": 0.01202, "epss_percentile": 0.78488}, "CVE-2015-4508": {"epss_score": 0.00697, "epss_percentile": 0.71398}, "CVE-2015-4509": {"epss_score": 0.04937, "epss_percentile": 0.89304}, "CVE-2015-4510": {"epss_score": 0.02515, "epss_percentile": 0.84982}, "CVE-2015-4511": {"epss_score": 0.0396, "epss_percentile": 0.88011}, "CVE-2015-4512": {"epss_score": 0.02006, "epss_percentile": 0.83231}, "CVE-2015-4513": {"epss_score": 0.04248, "epss_percentile": 0.88447}, "CVE-2015-4514": {"epss_score": 0.03911, "epss_percentile": 0.87935}, "CVE-2015-4515": {"epss_score": 0.00494, "epss_percentile": 0.65079}, "CVE-2015-4516": {"epss_score": 0.01673, "epss_percentile": 0.81687}, "CVE-2015-4517": {"epss_score": 0.03205, "epss_percentile": 0.86632}, "CVE-2015-4518": {"epss_score": 0.00568, "epss_percentile": 0.67905}, "CVE-2015-4519": {"epss_score": 0.00436, "epss_percentile": 0.62461}, "CVE-2015-4520": {"epss_score": 0.00592, "epss_percentile": 0.68606}, "CVE-2015-4521": {"epss_score": 0.03205, "epss_percentile": 0.86632}, "CVE-2015-4522": {"epss_score": 0.03205, "epss_percentile": 0.86632}, "CVE-2015-4523": {"epss_score": 0.05487, "epss_percentile": 0.89925}, "CVE-2015-4524": {"epss_score": 0.00896, "epss_percentile": 0.75111}, "CVE-2015-4525": {"epss_score": 0.00857, "epss_percentile": 0.74492}, "CVE-2015-4526": {"epss_score": 0.00059, "epss_percentile": 0.18661}, "CVE-2015-4527": {"epss_score": 0.00571, "epss_percentile": 0.67993}, "CVE-2015-4528": {"epss_score": 0.00179, "epss_percentile": 0.39815}, "CVE-2015-4529": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2015-4530": {"epss_score": 0.00122, "epss_percentile": 0.32164}, "CVE-2015-4531": {"epss_score": 0.00305, "epss_percentile": 0.5334}, "CVE-2015-4532": {"epss_score": 0.01595, "epss_percentile": 0.81237}, "CVE-2015-4533": {"epss_score": 0.03277, "epss_percentile": 0.86806}, "CVE-2015-4534": {"epss_score": 0.01671, "epss_percentile": 0.81675}, "CVE-2015-4535": {"epss_score": 0.00641, "epss_percentile": 0.69996}, "CVE-2015-4536": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2015-4537": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2015-4538": {"epss_score": 0.00737, "epss_percentile": 0.72325}, "CVE-2015-4539": {"epss_score": 0.00312, "epss_percentile": 0.54001}, "CVE-2015-4540": {"epss_score": 0.0022, "epss_percentile": 0.44575}, "CVE-2015-4541": {"epss_score": 0.00336, "epss_percentile": 0.55933}, "CVE-2015-4542": {"epss_score": 0.00137, "epss_percentile": 0.34317}, "CVE-2015-4543": {"epss_score": 0.00456, "epss_percentile": 0.63317}, "CVE-2015-4544": {"epss_score": 0.0053, "epss_percentile": 0.66626}, "CVE-2015-4545": {"epss_score": 0.00316, "epss_percentile": 0.54215}, "CVE-2015-4546": {"epss_score": 0.034, "epss_percentile": 0.87068}, "CVE-2015-4547": {"epss_score": 0.00513, "epss_percentile": 0.65894}, "CVE-2015-4548": {"epss_score": 0.00078, "epss_percentile": 0.23571}, "CVE-2015-4550": {"epss_score": 0.00501, "epss_percentile": 0.65346}, "CVE-2015-4551": {"epss_score": 0.096, "epss_percentile": 0.92617}, "CVE-2015-4552": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-4553": {"epss_score": 0.38521, "epss_percentile": 0.97103}, "CVE-2015-4554": {"epss_score": 0.01504, "epss_percentile": 0.8074}, "CVE-2015-4555": {"epss_score": 0.01076, "epss_percentile": 0.77321}, "CVE-2015-4556": {"epss_score": 0.01646, "epss_percentile": 0.81532}, "CVE-2015-4557": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2015-4559": {"epss_score": 0.00262, "epss_percentile": 0.4936}, "CVE-2015-4582": {"epss_score": 0.00045, "epss_percentile": 0.13951}, "CVE-2015-4586": {"epss_score": 0.00118, "epss_percentile": 0.31391}, "CVE-2015-4587": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2015-4588": {"epss_score": 0.05715, "epss_percentile": 0.90146}, "CVE-2015-4590": {"epss_score": 0.01017, "epss_percentile": 0.7669}, "CVE-2015-4591": {"epss_score": 0.02257, "epss_percentile": 0.84173}, "CVE-2015-4592": {"epss_score": 0.00577, "epss_percentile": 0.68161}, "CVE-2015-4593": {"epss_score": 0.00185, "epss_percentile": 0.40486}, "CVE-2015-4594": {"epss_score": 0.12264, "epss_percentile": 0.93616}, "CVE-2015-4596": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2015-4598": {"epss_score": 0.01451, "epss_percentile": 0.80359}, "CVE-2015-4599": {"epss_score": 0.06568, "epss_percentile": 0.90851}, "CVE-2015-4600": {"epss_score": 0.10739, "epss_percentile": 0.93088}, "CVE-2015-4601": {"epss_score": 0.21375, "epss_percentile": 0.9551}, "CVE-2015-4602": {"epss_score": 0.12863, "epss_percentile": 0.93804}, "CVE-2015-4603": {"epss_score": 0.08129, "epss_percentile": 0.91893}, "CVE-2015-4604": {"epss_score": 0.09106, "epss_percentile": 0.92403}, "CVE-2015-4605": {"epss_score": 0.09106, "epss_percentile": 0.92403}, "CVE-2015-4606": {"epss_score": 0.01696, "epss_percentile": 0.81811}, "CVE-2015-4607": {"epss_score": 0.01624, "epss_percentile": 0.81409}, "CVE-2015-4608": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2015-4609": {"epss_score": 0.00351, "epss_percentile": 0.57053}, "CVE-2015-4610": {"epss_score": 0.00351, "epss_percentile": 0.57053}, "CVE-2015-4611": {"epss_score": 0.00351, "epss_percentile": 0.57053}, "CVE-2015-4612": {"epss_score": 0.00351, "epss_percentile": 0.57053}, "CVE-2015-4613": {"epss_score": 0.00257, "epss_percentile": 0.48851}, "CVE-2015-4614": {"epss_score": 0.05561, "epss_percentile": 0.89993}, "CVE-2015-4615": {"epss_score": 0.00758, "epss_percentile": 0.72778}, "CVE-2015-4616": {"epss_score": 0.11833, "epss_percentile": 0.9349}, "CVE-2015-4617": {"epss_score": 0.00357, "epss_percentile": 0.57403}, "CVE-2015-4619": {"epss_score": 0.00235, "epss_percentile": 0.46201}, "CVE-2015-4620": {"epss_score": 0.27161, "epss_percentile": 0.96213}, "CVE-2015-4624": {"epss_score": 0.4762, "epss_percentile": 0.97594}, "CVE-2015-4625": {"epss_score": 0.00105, "epss_percentile": 0.29308}, "CVE-2015-4626": {"epss_score": 0.0024, "epss_percentile": 0.46939}, "CVE-2015-4627": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2015-4628": {"epss_score": 0.00349, "epss_percentile": 0.56899}, "CVE-2015-4629": {"epss_score": 0.02117, "epss_percentile": 0.83665}, "CVE-2015-4630": {"epss_score": 0.00642, "epss_percentile": 0.70044}, "CVE-2015-4631": {"epss_score": 0.00524, "epss_percentile": 0.66318}, "CVE-2015-4632": {"epss_score": 0.77745, "epss_percentile": 0.98951}, "CVE-2015-4633": {"epss_score": 0.04032, "epss_percentile": 0.88152}, "CVE-2015-4634": {"epss_score": 0.00409, "epss_percentile": 0.60754}, "CVE-2015-4637": {"epss_score": 0.00376, "epss_percentile": 0.5867}, "CVE-2015-4638": {"epss_score": 0.00725, "epss_percentile": 0.7206}, "CVE-2015-4639": {"epss_score": 0.00181, "epss_percentile": 0.40054}, "CVE-2015-4640": {"epss_score": 0.00182, "epss_percentile": 0.40197}, "CVE-2015-4641": {"epss_score": 0.00674, "epss_percentile": 0.70881}, "CVE-2015-4642": {"epss_score": 0.05952, "epss_percentile": 0.90357}, "CVE-2015-4643": {"epss_score": 0.08663, "epss_percentile": 0.92177}, "CVE-2015-4644": {"epss_score": 0.09888, "epss_percentile": 0.92754}, "CVE-2015-4645": {"epss_score": 0.00211, "epss_percentile": 0.4364}, "CVE-2015-4646": {"epss_score": 0.01047, "epss_percentile": 0.77037}, "CVE-2015-4647": {"epss_score": 0.0426, "epss_percentile": 0.88462}, "CVE-2015-4648": {"epss_score": 0.03624, "epss_percentile": 0.87454}, "CVE-2015-4649": {"epss_score": 0.00906, "epss_percentile": 0.75249}, "CVE-2015-4650": {"epss_score": 0.05487, "epss_percentile": 0.89926}, "CVE-2015-4651": {"epss_score": 0.00381, "epss_percentile": 0.58987}, "CVE-2015-4652": {"epss_score": 0.00421, "epss_percentile": 0.615}, "CVE-2015-4654": {"epss_score": 0.00019, "epss_percentile": 0.04337}, "CVE-2015-4655": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2015-4656": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-4657": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2015-4658": {"epss_score": 0.01016, "epss_percentile": 0.76676}, "CVE-2015-4659": {"epss_score": 0.00269, "epss_percentile": 0.50184}, "CVE-2015-4660": {"epss_score": 0.00757, "epss_percentile": 0.7275}, "CVE-2015-4661": {"epss_score": 0.00757, "epss_percentile": 0.7275}, "CVE-2015-4664": {"epss_score": 0.50998, "epss_percentile": 0.97758}, "CVE-2015-4665": {"epss_score": 0.0338, "epss_percentile": 0.8703}, "CVE-2015-4666": {"epss_score": 0.16389, "epss_percentile": 0.94643}, "CVE-2015-4667": {"epss_score": 0.24014, "epss_percentile": 0.95844}, "CVE-2015-4668": {"epss_score": 0.04202, "epss_percentile": 0.88389}, "CVE-2015-4669": {"epss_score": 0.00246, "epss_percentile": 0.47733}, "CVE-2015-4670": {"epss_score": 0.00877, "epss_percentile": 0.74815}, "CVE-2015-4671": {"epss_score": 0.00255, "epss_percentile": 0.48733}, "CVE-2015-4673": {"epss_score": 0.0019, "epss_percentile": 0.4106}, "CVE-2015-4674": {"epss_score": 0.00581, "epss_percentile": 0.68261}, "CVE-2015-4675": {"epss_score": 0.02627, "epss_percentile": 0.8527}, "CVE-2015-4676": {"epss_score": 0.00271, "epss_percentile": 0.50339}, "CVE-2015-4677": {"epss_score": 0.00277, "epss_percentile": 0.50837}, "CVE-2015-4678": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2015-4679": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2015-4680": {"epss_score": 0.0038, "epss_percentile": 0.58956}, "CVE-2015-4681": {"epss_score": 0.00515, "epss_percentile": 0.65971}, "CVE-2015-4682": {"epss_score": 0.1234, "epss_percentile": 0.93644}, "CVE-2015-4683": {"epss_score": 0.34308, "epss_percentile": 0.96841}, "CVE-2015-4684": {"epss_score": 0.11362, "epss_percentile": 0.93324}, "CVE-2015-4685": {"epss_score": 0.00186, "epss_percentile": 0.40644}, "CVE-2015-4687": {"epss_score": 0.00196, "epss_percentile": 0.41807}, "CVE-2015-4688": {"epss_score": 0.00234, "epss_percentile": 0.46171}, "CVE-2015-4689": {"epss_score": 0.01031, "epss_percentile": 0.76855}, "CVE-2015-4692": {"epss_score": 0.00041, "epss_percentile": 0.12286}, "CVE-2015-4694": {"epss_score": 0.35068, "epss_percentile": 0.96886}, "CVE-2015-4695": {"epss_score": 0.01549, "epss_percentile": 0.8098}, "CVE-2015-4696": {"epss_score": 0.01958, "epss_percentile": 0.83047}, "CVE-2015-4697": {"epss_score": 0.00212, "epss_percentile": 0.43744}, "CVE-2015-4699": {"epss_score": 0.00495, "epss_percentile": 0.65113}, "CVE-2015-4700": {"epss_score": 0.00075, "epss_percentile": 0.23032}, "CVE-2015-4703": {"epss_score": 0.00797, "epss_percentile": 0.73501}, "CVE-2015-4704": {"epss_score": 0.07355, "epss_percentile": 0.91428}, "CVE-2015-4706": {"epss_score": 0.00522, "epss_percentile": 0.66257}, "CVE-2015-4707": {"epss_score": 0.00811, "epss_percentile": 0.7373}, "CVE-2015-4713": {"epss_score": 0.00181, "epss_percentile": 0.40101}, "CVE-2015-4714": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2015-4715": {"epss_score": 0.01359, "epss_percentile": 0.79737}, "CVE-2015-4716": {"epss_score": 0.18569, "epss_percentile": 0.95034}, "CVE-2015-4717": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2015-4718": {"epss_score": 0.00988, "epss_percentile": 0.76352}, "CVE-2015-4719": {"epss_score": 0.00852, "epss_percentile": 0.74418}, "CVE-2015-4721": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2015-4724": {"epss_score": 0.00216, "epss_percentile": 0.44137}, "CVE-2015-4725": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2015-4726": {"epss_score": 0.00498, "epss_percentile": 0.65217}, "CVE-2015-4727": {"epss_score": 0.00631, "epss_percentile": 0.69717}, "CVE-2015-4728": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-4729": {"epss_score": 0.02597, "epss_percentile": 0.852}, "CVE-2015-4730": {"epss_score": 0.0041, "epss_percentile": 0.6083}, "CVE-2015-4731": {"epss_score": 0.07452, "epss_percentile": 0.91479}, "CVE-2015-4732": {"epss_score": 0.10776, "epss_percentile": 0.931}, "CVE-2015-4733": {"epss_score": 0.09787, "epss_percentile": 0.92702}, "CVE-2015-4734": {"epss_score": 0.02799, "epss_percentile": 0.85691}, "CVE-2015-4735": {"epss_score": 0.00803, "epss_percentile": 0.73595}, "CVE-2015-4736": {"epss_score": 0.04255, "epss_percentile": 0.88458}, "CVE-2015-4737": {"epss_score": 0.00531, "epss_percentile": 0.66642}, "CVE-2015-4738": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-4739": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-4740": {"epss_score": 0.00371, "epss_percentile": 0.58384}, "CVE-2015-4741": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-4742": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2015-4743": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-4744": {"epss_score": 0.00288, "epss_percentile": 0.51888}, "CVE-2015-4745": {"epss_score": 0.00772, "epss_percentile": 0.73048}, "CVE-2015-4746": {"epss_score": 0.00197, "epss_percentile": 0.41949}, "CVE-2015-4747": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2015-4748": {"epss_score": 0.07265, "epss_percentile": 0.91359}, "CVE-2015-4749": {"epss_score": 0.06192, "epss_percentile": 0.90549}, "CVE-2015-4750": {"epss_score": 0.00822, "epss_percentile": 0.73918}, "CVE-2015-4751": {"epss_score": 0.00725, "epss_percentile": 0.72055}, "CVE-2015-4752": {"epss_score": 0.00598, "epss_percentile": 0.68773}, "CVE-2015-4753": {"epss_score": 0.0042, "epss_percentile": 0.61436}, "CVE-2015-4754": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-4755": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-4756": {"epss_score": 0.00799, "epss_percentile": 0.73519}, "CVE-2015-4757": {"epss_score": 0.00598, "epss_percentile": 0.68773}, "CVE-2015-4758": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2015-4759": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2015-4760": {"epss_score": 0.09071, "epss_percentile": 0.92386}, "CVE-2015-4761": {"epss_score": 0.00839, "epss_percentile": 0.74194}, "CVE-2015-4762": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-4763": {"epss_score": 0.00191, "epss_percentile": 0.41269}, "CVE-2015-4764": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-4765": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-4766": {"epss_score": 0.00162, "epss_percentile": 0.377}, "CVE-2015-4767": {"epss_score": 0.01271, "epss_percentile": 0.79057}, "CVE-2015-4768": {"epss_score": 0.00197, "epss_percentile": 0.41949}, "CVE-2015-4769": {"epss_score": 0.01014, "epss_percentile": 0.76654}, "CVE-2015-4770": {"epss_score": 0.00274, "epss_percentile": 0.50488}, "CVE-2015-4771": {"epss_score": 0.01014, "epss_percentile": 0.76654}, "CVE-2015-4772": {"epss_score": 0.01466, "epss_percentile": 0.80463}, "CVE-2015-4773": {"epss_score": 0.00355, "epss_percentile": 0.57273}, "CVE-2015-4774": {"epss_score": 0.00212, "epss_percentile": 0.43728}, "CVE-2015-4775": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-4776": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-4777": {"epss_score": 0.00218, "epss_percentile": 0.44363}, "CVE-2015-4778": {"epss_score": 0.00218, "epss_percentile": 0.44363}, "CVE-2015-4779": {"epss_score": 0.00212, "epss_percentile": 0.43728}, "CVE-2015-4780": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-4781": {"epss_score": 0.00218, "epss_percentile": 0.44363}, "CVE-2015-4782": {"epss_score": 0.00218, "epss_percentile": 0.44363}, "CVE-2015-4783": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-4784": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-4785": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-4786": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-4787": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-4788": {"epss_score": 0.00212, "epss_percentile": 0.43728}, "CVE-2015-4789": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-4790": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2015-4791": {"epss_score": 0.00247, "epss_percentile": 0.47852}, "CVE-2015-4792": {"epss_score": 0.00906, "epss_percentile": 0.75254}, "CVE-2015-4793": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-4794": {"epss_score": 0.00528, "epss_percentile": 0.66573}, "CVE-2015-4795": {"epss_score": 0.00685, "epss_percentile": 0.71137}, "CVE-2015-4796": {"epss_score": 0.1269, "epss_percentile": 0.93751}, "CVE-2015-4797": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-4798": {"epss_score": 0.02711, "epss_percentile": 0.85498}, "CVE-2015-4799": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2015-4800": {"epss_score": 0.00565, "epss_percentile": 0.67785}, "CVE-2015-4801": {"epss_score": 0.00161, "epss_percentile": 0.37529}, "CVE-2015-4802": {"epss_score": 0.00413, "epss_percentile": 0.60959}, "CVE-2015-4803": {"epss_score": 0.06009, "epss_percentile": 0.90403}, "CVE-2015-4804": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-4805": {"epss_score": 0.05963, "epss_percentile": 0.90368}, "CVE-2015-4806": {"epss_score": 0.02549, "epss_percentile": 0.85071}, "CVE-2015-4807": {"epss_score": 0.00331, "epss_percentile": 0.55528}, "CVE-2015-4808": {"epss_score": 0.00123, "epss_percentile": 0.32265}, "CVE-2015-4809": {"epss_score": 0.00091, "epss_percentile": 0.26218}, "CVE-2015-4810": {"epss_score": 0.00082, "epss_percentile": 0.24503}, "CVE-2015-4811": {"epss_score": 0.00091, "epss_percentile": 0.26218}, "CVE-2015-4812": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-4813": {"epss_score": 0.00056, "epss_percentile": 0.17702}, "CVE-2015-4815": {"epss_score": 0.00413, "epss_percentile": 0.60959}, "CVE-2015-4816": {"epss_score": 0.00413, "epss_percentile": 0.60965}, "CVE-2015-4817": {"epss_score": 0.00188, "epss_percentile": 0.4092}, "CVE-2015-4818": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2015-4819": {"epss_score": 0.00089, "epss_percentile": 0.2592}, "CVE-2015-4820": {"epss_score": 0.00188, "epss_percentile": 0.4092}, "CVE-2015-4821": {"epss_score": 0.00705, "epss_percentile": 0.71601}, "CVE-2015-4822": {"epss_score": 0.00128, "epss_percentile": 0.3305}, "CVE-2015-4823": {"epss_score": 0.00171, "epss_percentile": 0.38822}, "CVE-2015-4824": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-4825": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-4826": {"epss_score": 0.00276, "epss_percentile": 0.50707}, "CVE-2015-4827": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-4828": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-4830": {"epss_score": 0.0027, "epss_percentile": 0.50267}, "CVE-2015-4831": {"epss_score": 0.00148, "epss_percentile": 0.35819}, "CVE-2015-4832": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-4833": {"epss_score": 0.00793, "epss_percentile": 0.73422}, "CVE-2015-4834": {"epss_score": 0.00169, "epss_percentile": 0.38611}, "CVE-2015-4835": {"epss_score": 0.04444, "epss_percentile": 0.88696}, "CVE-2015-4836": {"epss_score": 0.00848, "epss_percentile": 0.74363}, "CVE-2015-4837": {"epss_score": 0.00108, "epss_percentile": 0.29767}, "CVE-2015-4838": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-4839": {"epss_score": 0.02711, "epss_percentile": 0.85498}, "CVE-2015-4840": {"epss_score": 0.02799, "epss_percentile": 0.85691}, "CVE-2015-4841": {"epss_score": 0.00284, "epss_percentile": 0.51497}, "CVE-2015-4842": {"epss_score": 0.02799, "epss_percentile": 0.85691}, "CVE-2015-4843": {"epss_score": 0.13362, "epss_percentile": 0.93941}, "CVE-2015-4844": {"epss_score": 0.11777, "epss_percentile": 0.93471}, "CVE-2015-4845": {"epss_score": 0.00539, "epss_percentile": 0.66971}, "CVE-2015-4846": {"epss_score": 0.0031, "epss_percentile": 0.53761}, "CVE-2015-4847": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-4848": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-4849": {"epss_score": 0.01418, "epss_percentile": 0.80158}, "CVE-2015-4850": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2015-4851": {"epss_score": 0.01418, "epss_percentile": 0.80158}, "CVE-2015-4852": {"epss_score": 0.92463, "epss_percentile": 0.99716}, "CVE-2015-4854": {"epss_score": 0.00562, "epss_percentile": 0.67686}, "CVE-2015-4856": {"epss_score": 0.00175, "epss_percentile": 0.39263}, "CVE-2015-4857": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2015-4858": {"epss_score": 0.00413, "epss_percentile": 0.60959}, "CVE-2015-4859": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-4860": {"epss_score": 0.07481, "epss_percentile": 0.91496}, "CVE-2015-4861": {"epss_score": 0.00386, "epss_percentile": 0.59257}, "CVE-2015-4862": {"epss_score": 0.00565, "epss_percentile": 0.67785}, "CVE-2015-4863": {"epss_score": 0.02469, "epss_percentile": 0.84843}, "CVE-2015-4864": {"epss_score": 0.00332, "epss_percentile": 0.55594}, "CVE-2015-4865": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2015-4866": {"epss_score": 0.01011, "epss_percentile": 0.76609}, "CVE-2015-4867": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2015-4868": {"epss_score": 0.03545, "epss_percentile": 0.87325}, "CVE-2015-4869": {"epss_score": 0.00253, "epss_percentile": 0.48489}, "CVE-2015-4870": {"epss_score": 0.19912, "epss_percentile": 0.95259}, "CVE-2015-4871": {"epss_score": 0.03119, "epss_percentile": 0.86444}, "CVE-2015-4872": {"epss_score": 0.04075, "epss_percentile": 0.8821}, "CVE-2015-4873": {"epss_score": 0.00494, "epss_percentile": 0.65087}, "CVE-2015-4874": {"epss_score": 0.00234, "epss_percentile": 0.46155}, "CVE-2015-4875": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2015-4876": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-4877": {"epss_score": 0.0027, "epss_percentile": 0.50195}, "CVE-2015-4878": {"epss_score": 0.0027, "epss_percentile": 0.50195}, "CVE-2015-4879": {"epss_score": 0.00598, "epss_percentile": 0.68773}, "CVE-2015-4880": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2015-4881": {"epss_score": 0.06809, "epss_percentile": 0.9104}, "CVE-2015-4882": {"epss_score": 0.06009, "epss_percentile": 0.90403}, "CVE-2015-4883": {"epss_score": 0.07481, "epss_percentile": 0.91496}, "CVE-2015-4884": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-4885": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-4886": {"epss_score": 0.00691, "epss_percentile": 0.7127}, "CVE-2015-4887": {"epss_score": 0.00351, "epss_percentile": 0.5704}, "CVE-2015-4888": {"epss_score": 0.00375, "epss_percentile": 0.58637}, "CVE-2015-4890": {"epss_score": 0.00396, "epss_percentile": 0.59897}, "CVE-2015-4891": {"epss_score": 0.00427, "epss_percentile": 0.61899}, "CVE-2015-4892": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-4893": {"epss_score": 0.06009, "epss_percentile": 0.90403}, "CVE-2015-4894": {"epss_score": 0.00364, "epss_percentile": 0.57911}, "CVE-2015-4895": {"epss_score": 0.00387, "epss_percentile": 0.59318}, "CVE-2015-4896": {"epss_score": 0.01662, "epss_percentile": 0.81634}, "CVE-2015-4898": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-4899": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-4900": {"epss_score": 0.00352, "epss_percentile": 0.57081}, "CVE-2015-4901": {"epss_score": 0.01884, "epss_percentile": 0.82706}, "CVE-2015-4902": {"epss_score": 0.09381, "epss_percentile": 0.92525}, "CVE-2015-4903": {"epss_score": 0.02799, "epss_percentile": 0.85691}, "CVE-2015-4904": {"epss_score": 0.00793, "epss_percentile": 0.73422}, "CVE-2015-4905": {"epss_score": 0.00411, "epss_percentile": 0.6087}, "CVE-2015-4906": {"epss_score": 0.00395, "epss_percentile": 0.59803}, "CVE-2015-4907": {"epss_score": 0.00176, "epss_percentile": 0.39418}, "CVE-2015-4908": {"epss_score": 0.00395, "epss_percentile": 0.59803}, "CVE-2015-4909": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-4910": {"epss_score": 0.00557, "epss_percentile": 0.67547}, "CVE-2015-4911": {"epss_score": 0.06009, "epss_percentile": 0.90403}, "CVE-2015-4912": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2015-4913": {"epss_score": 0.00386, "epss_percentile": 0.59257}, "CVE-2015-4914": {"epss_score": 0.00143, "epss_percentile": 0.35149}, "CVE-2015-4915": {"epss_score": 0.02469, "epss_percentile": 0.84843}, "CVE-2015-4916": {"epss_score": 0.00395, "epss_percentile": 0.59803}, "CVE-2015-4917": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-4919": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2015-4920": {"epss_score": 0.00117, "epss_percentile": 0.31286}, "CVE-2015-4921": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-4922": {"epss_score": 0.00127, "epss_percentile": 0.32933}, "CVE-2015-4923": {"epss_score": 0.00355, "epss_percentile": 0.57273}, "CVE-2015-4924": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2015-4925": {"epss_score": 0.00375, "epss_percentile": 0.58637}, "CVE-2015-4926": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2015-4927": {"epss_score": 0.00111, "epss_percentile": 0.30261}, "CVE-2015-4928": {"epss_score": 0.00861, "epss_percentile": 0.74568}, "CVE-2015-4929": {"epss_score": 0.0014, "epss_percentile": 0.34785}, "CVE-2015-4930": {"epss_score": 0.02384, "epss_percentile": 0.84575}, "CVE-2015-4931": {"epss_score": 0.23298, "epss_percentile": 0.95761}, "CVE-2015-4932": {"epss_score": 0.23298, "epss_percentile": 0.95761}, "CVE-2015-4933": {"epss_score": 0.23068, "epss_percentile": 0.95729}, "CVE-2015-4934": {"epss_score": 0.23068, "epss_percentile": 0.95729}, "CVE-2015-4935": {"epss_score": 0.23068, "epss_percentile": 0.95729}, "CVE-2015-4936": {"epss_score": 0.00527, "epss_percentile": 0.66445}, "CVE-2015-4938": {"epss_score": 0.00376, "epss_percentile": 0.5868}, "CVE-2015-4939": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2015-4940": {"epss_score": 0.00117, "epss_percentile": 0.31368}, "CVE-2015-4941": {"epss_score": 0.00607, "epss_percentile": 0.69046}, "CVE-2015-4942": {"epss_score": 0.00538, "epss_percentile": 0.66929}, "CVE-2015-4943": {"epss_score": 0.00607, "epss_percentile": 0.69046}, "CVE-2015-4944": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-4945": {"epss_score": 0.00236, "epss_percentile": 0.46422}, "CVE-2015-4946": {"epss_score": 0.00054, "epss_percentile": 0.17356}, "CVE-2015-4947": {"epss_score": 0.04968, "epss_percentile": 0.89345}, "CVE-2015-4948": {"epss_score": 0.00048, "epss_percentile": 0.15097}, "CVE-2015-4949": {"epss_score": 0.00061, "epss_percentile": 0.19493}, "CVE-2015-4950": {"epss_score": 0.00246, "epss_percentile": 0.47747}, "CVE-2015-4951": {"epss_score": 0.00538, "epss_percentile": 0.66929}, "CVE-2015-4952": {"epss_score": 0.01479, "epss_percentile": 0.8056}, "CVE-2015-4953": {"epss_score": 0.00054, "epss_percentile": 0.17114}, "CVE-2015-4954": {"epss_score": 0.001, "epss_percentile": 0.28478}, "CVE-2015-4955": {"epss_score": 0.00231, "epss_percentile": 0.45804}, "CVE-2015-4956": {"epss_score": 0.00411, "epss_percentile": 0.60901}, "CVE-2015-4957": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2015-4958": {"epss_score": 0.00043, "epss_percentile": 0.1327}, "CVE-2015-4959": {"epss_score": 0.00266, "epss_percentile": 0.49919}, "CVE-2015-4960": {"epss_score": 0.00139, "epss_percentile": 0.34584}, "CVE-2015-4961": {"epss_score": 0.00096, "epss_percentile": 0.27413}, "CVE-2015-4962": {"epss_score": 0.00073, "epss_percentile": 0.22619}, "CVE-2015-4963": {"epss_score": 0.00755, "epss_percentile": 0.72709}, "CVE-2015-4964": {"epss_score": 0.01835, "epss_percentile": 0.82467}, "CVE-2015-4965": {"epss_score": 0.00146, "epss_percentile": 0.35552}, "CVE-2015-4966": {"epss_score": 0.00349, "epss_percentile": 0.56905}, "CVE-2015-4967": {"epss_score": 0.00277, "epss_percentile": 0.50779}, "CVE-2015-4971": {"epss_score": 0.00166, "epss_percentile": 0.38221}, "CVE-2015-4973": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2015-4974": {"epss_score": 0.00104, "epss_percentile": 0.29189}, "CVE-2015-4980": {"epss_score": 0.00165, "epss_percentile": 0.38026}, "CVE-2015-4981": {"epss_score": 0.00055, "epss_percentile": 0.17551}, "CVE-2015-4987": {"epss_score": 0.00153, "epss_percentile": 0.36604}, "CVE-2015-4988": {"epss_score": 0.00494, "epss_percentile": 0.6507}, "CVE-2015-4989": {"epss_score": 0.00207, "epss_percentile": 0.43148}, "CVE-2015-4990": {"epss_score": 0.00055, "epss_percentile": 0.17573}, "CVE-2015-4991": {"epss_score": 0.0004, "epss_percentile": 0.11915}, "CVE-2015-4992": {"epss_score": 0.00134, "epss_percentile": 0.33767}, "CVE-2015-4993": {"epss_score": 0.0023, "epss_percentile": 0.45664}, "CVE-2015-4994": {"epss_score": 0.02441, "epss_percentile": 0.84754}, "CVE-2015-4996": {"epss_score": 0.00049, "epss_percentile": 0.15451}, "CVE-2015-4997": {"epss_score": 0.00254, "epss_percentile": 0.48504}, "CVE-2015-4998": {"epss_score": 0.00266, "epss_percentile": 0.49919}, "CVE-2015-5001": {"epss_score": 0.00648, "epss_percentile": 0.70218}, "CVE-2015-5002": {"epss_score": 0.00225, "epss_percentile": 0.45124}, "CVE-2015-5003": {"epss_score": 0.01325, "epss_percentile": 0.79471}, "CVE-2015-5004": {"epss_score": 0.00165, "epss_percentile": 0.38026}, "CVE-2015-5005": {"epss_score": 0.01256, "epss_percentile": 0.78942}, "CVE-2015-5006": {"epss_score": 0.00074, "epss_percentile": 0.22813}, "CVE-2015-5007": {"epss_score": 0.00112, "epss_percentile": 0.30437}, "CVE-2015-5008": {"epss_score": 0.00654, "epss_percentile": 0.7035}, "CVE-2015-5009": {"epss_score": 0.00375, "epss_percentile": 0.58614}, "CVE-2015-5010": {"epss_score": 0.00278, "epss_percentile": 0.50876}, "CVE-2015-5011": {"epss_score": 0.00124, "epss_percentile": 0.32375}, "CVE-2015-5012": {"epss_score": 0.00278, "epss_percentile": 0.50876}, "CVE-2015-5013": {"epss_score": 0.00108, "epss_percentile": 0.299}, "CVE-2015-5014": {"epss_score": 0.00467, "epss_percentile": 0.63838}, "CVE-2015-5015": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2015-5016": {"epss_score": 0.00105, "epss_percentile": 0.29348}, "CVE-2015-5017": {"epss_score": 0.00105, "epss_percentile": 0.29326}, "CVE-2015-5018": {"epss_score": 0.01336, "epss_percentile": 0.79552}, "CVE-2015-5019": {"epss_score": 0.00134, "epss_percentile": 0.33767}, "CVE-2015-5020": {"epss_score": 0.00118, "epss_percentile": 0.31477}, "CVE-2015-5021": {"epss_score": 0.00254, "epss_percentile": 0.48519}, "CVE-2015-5022": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2015-5023": {"epss_score": 0.00126, "epss_percentile": 0.32725}, "CVE-2015-5024": {"epss_score": 0.00158, "epss_percentile": 0.37243}, "CVE-2015-5035": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2015-5036": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2015-5037": {"epss_score": 0.00044, "epss_percentile": 0.13636}, "CVE-2015-5038": {"epss_score": 0.00893, "epss_percentile": 0.75072}, "CVE-2015-5039": {"epss_score": 0.00125, "epss_percentile": 0.32557}, "CVE-2015-5040": {"epss_score": 0.02441, "epss_percentile": 0.84754}, "CVE-2015-5041": {"epss_score": 0.00995, "epss_percentile": 0.76441}, "CVE-2015-5042": {"epss_score": 0.00622, "epss_percentile": 0.69501}, "CVE-2015-5043": {"epss_score": 0.00046, "epss_percentile": 0.14273}, "CVE-2015-5044": {"epss_score": 0.00244, "epss_percentile": 0.47572}, "CVE-2015-5045": {"epss_score": 0.00041, "epss_percentile": 0.1241}, "CVE-2015-5049": {"epss_score": 0.00126, "epss_percentile": 0.32725}, "CVE-2015-5050": {"epss_score": 0.00105, "epss_percentile": 0.29371}, "CVE-2015-5051": {"epss_score": 0.00137, "epss_percentile": 0.34334}, "CVE-2015-5052": {"epss_score": 0.00307, "epss_percentile": 0.53527}, "CVE-2015-5053": {"epss_score": 0.00519, "epss_percentile": 0.6618}, "CVE-2015-5054": {"epss_score": 0.00189, "epss_percentile": 0.40975}, "CVE-2015-5057": {"epss_score": 0.00295, "epss_percentile": 0.52449}, "CVE-2015-5058": {"epss_score": 0.00816, "epss_percentile": 0.73836}, "CVE-2015-5059": {"epss_score": 0.00625, "epss_percentile": 0.69581}, "CVE-2015-5060": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2015-5061": {"epss_score": 0.00292, "epss_percentile": 0.52268}, "CVE-2015-5062": {"epss_score": 0.00347, "epss_percentile": 0.56781}, "CVE-2015-5063": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2015-5064": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-5065": {"epss_score": 0.41339, "epss_percentile": 0.97267}, "CVE-2015-5066": {"epss_score": 0.06242, "epss_percentile": 0.90594}, "CVE-2015-5067": {"epss_score": 0.01584, "epss_percentile": 0.8116}, "CVE-2015-5068": {"epss_score": 0.00957, "epss_percentile": 0.75936}, "CVE-2015-5069": {"epss_score": 0.00671, "epss_percentile": 0.70793}, "CVE-2015-5070": {"epss_score": 0.0066, "epss_percentile": 0.70534}, "CVE-2015-5071": {"epss_score": 0.00366, "epss_percentile": 0.58087}, "CVE-2015-5072": {"epss_score": 0.00186, "epss_percentile": 0.40684}, "CVE-2015-5073": {"epss_score": 0.00547, "epss_percentile": 0.67253}, "CVE-2015-5074": {"epss_score": 0.11204, "epss_percentile": 0.93264}, "CVE-2015-5075": {"epss_score": 0.00966, "epss_percentile": 0.76054}, "CVE-2015-5076": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2015-5078": {"epss_score": 0.00303, "epss_percentile": 0.53196}, "CVE-2015-5079": {"epss_score": 0.31814, "epss_percentile": 0.96651}, "CVE-2015-5080": {"epss_score": 0.01003, "epss_percentile": 0.76517}, "CVE-2015-5081": {"epss_score": 0.00196, "epss_percentile": 0.41712}, "CVE-2015-5082": {"epss_score": 0.86671, "epss_percentile": 0.99392}, "CVE-2015-5084": {"epss_score": 0.00097, "epss_percentile": 0.27495}, "CVE-2015-5085": {"epss_score": 0.00885, "epss_percentile": 0.74944}, "CVE-2015-5086": {"epss_score": 0.00885, "epss_percentile": 0.74944}, "CVE-2015-5087": {"epss_score": 0.03656, "epss_percentile": 0.87517}, "CVE-2015-5088": {"epss_score": 0.02761, "epss_percentile": 0.85602}, "CVE-2015-5089": {"epss_score": 0.02761, "epss_percentile": 0.85602}, "CVE-2015-5090": {"epss_score": 0.00495, "epss_percentile": 0.65121}, "CVE-2015-5091": {"epss_score": 0.01972, "epss_percentile": 0.83107}, "CVE-2015-5092": {"epss_score": 0.02761, "epss_percentile": 0.85602}, "CVE-2015-5093": {"epss_score": 0.04363, "epss_percentile": 0.88599}, "CVE-2015-5094": {"epss_score": 0.03656, "epss_percentile": 0.87517}, "CVE-2015-5095": {"epss_score": 0.02877, "epss_percentile": 0.85887}, "CVE-2015-5096": {"epss_score": 0.04543, "epss_percentile": 0.88829}, "CVE-2015-5097": {"epss_score": 0.05325, "epss_percentile": 0.89734}, "CVE-2015-5098": {"epss_score": 0.04543, "epss_percentile": 0.88829}, "CVE-2015-5099": {"epss_score": 0.02516, "epss_percentile": 0.84986}, "CVE-2015-5100": {"epss_score": 0.03656, "epss_percentile": 0.87517}, "CVE-2015-5101": {"epss_score": 0.02877, "epss_percentile": 0.85887}, "CVE-2015-5102": {"epss_score": 0.03656, "epss_percentile": 0.87517}, "CVE-2015-5103": {"epss_score": 0.03656, "epss_percentile": 0.87517}, "CVE-2015-5104": {"epss_score": 0.03656, "epss_percentile": 0.87517}, "CVE-2015-5105": {"epss_score": 0.04543, "epss_percentile": 0.88829}, "CVE-2015-5106": {"epss_score": 0.00383, "epss_percentile": 0.59099}, "CVE-2015-5107": {"epss_score": 0.02101, "epss_percentile": 0.83603}, "CVE-2015-5108": {"epss_score": 0.05325, "epss_percentile": 0.89734}, "CVE-2015-5109": {"epss_score": 0.01144, "epss_percentile": 0.77986}, "CVE-2015-5110": {"epss_score": 0.02796, "epss_percentile": 0.85682}, "CVE-2015-5111": {"epss_score": 0.01508, "epss_percentile": 0.80763}, "CVE-2015-5113": {"epss_score": 0.01508, "epss_percentile": 0.80763}, "CVE-2015-5114": {"epss_score": 0.02877, "epss_percentile": 0.85887}, "CVE-2015-5115": {"epss_score": 0.03656, "epss_percentile": 0.87517}, "CVE-2015-5116": {"epss_score": 0.24696, "epss_percentile": 0.95946}, "CVE-2015-5117": {"epss_score": 0.1049, "epss_percentile": 0.93008}, "CVE-2015-5118": {"epss_score": 0.62732, "epss_percentile": 0.98306}, "CVE-2015-5119": {"epss_score": 0.9308, "epss_percentile": 0.99774}, "CVE-2015-5120": {"epss_score": 0.0599, "epss_percentile": 0.90385}, "CVE-2015-5121": {"epss_score": 0.0599, "epss_percentile": 0.90385}, "CVE-2015-5122": {"epss_score": 0.9278, "epss_percentile": 0.99748}, "CVE-2015-5123": {"epss_score": 0.47561, "epss_percentile": 0.97592}, "CVE-2015-5124": {"epss_score": 0.11426, "epss_percentile": 0.93345}, "CVE-2015-5125": {"epss_score": 0.0396, "epss_percentile": 0.88011}, "CVE-2015-5127": {"epss_score": 0.52984, "epss_percentile": 0.97852}, "CVE-2015-5129": {"epss_score": 0.02821, "epss_percentile": 0.85744}, "CVE-2015-5130": {"epss_score": 0.52984, "epss_percentile": 0.97852}, "CVE-2015-5131": {"epss_score": 0.71451, "epss_percentile": 0.98669}, "CVE-2015-5132": {"epss_score": 0.71451, "epss_percentile": 0.98669}, "CVE-2015-5133": {"epss_score": 0.71451, "epss_percentile": 0.98669}, "CVE-2015-5134": {"epss_score": 0.52984, "epss_percentile": 0.97852}, "CVE-2015-5143": {"epss_score": 0.15813, "epss_percentile": 0.94513}, "CVE-2015-5144": {"epss_score": 0.02238, "epss_percentile": 0.84106}, "CVE-2015-5145": {"epss_score": 0.01434, "epss_percentile": 0.80263}, "CVE-2015-5146": {"epss_score": 0.02529, "epss_percentile": 0.85022}, "CVE-2015-5147": {"epss_score": 0.01153, "epss_percentile": 0.78063}, "CVE-2015-5148": {"epss_score": 0.01016, "epss_percentile": 0.76676}, "CVE-2015-5149": {"epss_score": 0.42459, "epss_percentile": 0.97333}, "CVE-2015-5150": {"epss_score": 0.00969, "epss_percentile": 0.76096}, "CVE-2015-5151": {"epss_score": 0.00174, "epss_percentile": 0.39257}, "CVE-2015-5152": {"epss_score": 0.00291, "epss_percentile": 0.52212}, "CVE-2015-5153": {"epss_score": 0.00428, "epss_percentile": 0.61929}, "CVE-2015-5154": {"epss_score": 0.00388, "epss_percentile": 0.59347}, "CVE-2015-5156": {"epss_score": 0.00221, "epss_percentile": 0.4468}, "CVE-2015-5157": {"epss_score": 0.00219, "epss_percentile": 0.44511}, "CVE-2015-5158": {"epss_score": 0.00081, "epss_percentile": 0.24311}, "CVE-2015-5159": {"epss_score": 0.00566, "epss_percentile": 0.6783}, "CVE-2015-5160": {"epss_score": 0.00145, "epss_percentile": 0.35433}, "CVE-2015-5161": {"epss_score": 0.40825, "epss_percentile": 0.97239}, "CVE-2015-5162": {"epss_score": 0.0359, "epss_percentile": 0.87399}, "CVE-2015-5163": {"epss_score": 0.00237, "epss_percentile": 0.46737}, "CVE-2015-5164": {"epss_score": 0.01696, "epss_percentile": 0.81813}, "CVE-2015-5165": {"epss_score": 0.09723, "epss_percentile": 0.92677}, "CVE-2015-5166": {"epss_score": 0.00072, "epss_percentile": 0.22373}, "CVE-2015-5167": {"epss_score": 0.00167, "epss_percentile": 0.38336}, "CVE-2015-5168": {"epss_score": 0.01885, "epss_percentile": 0.82709}, "CVE-2015-5169": {"epss_score": 0.01148, "epss_percentile": 0.78014}, "CVE-2015-5170": {"epss_score": 0.00306, "epss_percentile": 0.53454}, "CVE-2015-5171": {"epss_score": 0.00486, "epss_percentile": 0.6477}, "CVE-2015-5172": {"epss_score": 0.00398, "epss_percentile": 0.60077}, "CVE-2015-5173": {"epss_score": 0.00484, "epss_percentile": 0.64638}, "CVE-2015-5174": {"epss_score": 0.01086, "epss_percentile": 0.77425}, "CVE-2015-5175": {"epss_score": 0.13564, "epss_percentile": 0.93997}, "CVE-2015-5176": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2015-5177": {"epss_score": 0.01255, "epss_percentile": 0.78925}, "CVE-2015-5178": {"epss_score": 0.00505, "epss_percentile": 0.65608}, "CVE-2015-5179": {"epss_score": 0.00198, "epss_percentile": 0.42017}, "CVE-2015-5180": {"epss_score": 0.00737, "epss_percentile": 0.72331}, "CVE-2015-5181": {"epss_score": 0.00173, "epss_percentile": 0.39044}, "CVE-2015-5182": {"epss_score": 0.00215, "epss_percentile": 0.44084}, "CVE-2015-5183": {"epss_score": 0.00396, "epss_percentile": 0.59885}, "CVE-2015-5184": {"epss_score": 0.00289, "epss_percentile": 0.52036}, "CVE-2015-5185": {"epss_score": 0.01182, "epss_percentile": 0.78313}, "CVE-2015-5186": {"epss_score": 0.00373, "epss_percentile": 0.58526}, "CVE-2015-5187": {"epss_score": 0.00345, "epss_percentile": 0.56568}, "CVE-2015-5188": {"epss_score": 0.00331, "epss_percentile": 0.55523}, "CVE-2015-5189": {"epss_score": 0.00133, "epss_percentile": 0.33639}, "CVE-2015-5190": {"epss_score": 0.00629, "epss_percentile": 0.6967}, "CVE-2015-5191": {"epss_score": 0.00066, "epss_percentile": 0.20737}, "CVE-2015-5194": {"epss_score": 0.19357, "epss_percentile": 0.95168}, "CVE-2015-5195": {"epss_score": 0.15279, "epss_percentile": 0.94398}, "CVE-2015-5198": {"epss_score": 0.00093, "epss_percentile": 0.26662}, "CVE-2015-5199": {"epss_score": 0.00049, "epss_percentile": 0.15382}, "CVE-2015-5200": {"epss_score": 0.00093, "epss_percentile": 0.26662}, "CVE-2015-5201": {"epss_score": 0.00463, "epss_percentile": 0.63635}, "CVE-2015-5203": {"epss_score": 0.00381, "epss_percentile": 0.58985}, "CVE-2015-5204": {"epss_score": 0.01412, "epss_percentile": 0.80116}, "CVE-2015-5206": {"epss_score": 0.01903, "epss_percentile": 0.82787}, "CVE-2015-5207": {"epss_score": 0.00143, "epss_percentile": 0.35191}, "CVE-2015-5208": {"epss_score": 0.01795, "epss_percentile": 0.82303}, "CVE-2015-5209": {"epss_score": 0.03632, "epss_percentile": 0.87475}, "CVE-2015-5210": {"epss_score": 0.00993, "epss_percentile": 0.76403}, "CVE-2015-5211": {"epss_score": 0.01877, "epss_percentile": 0.82666}, "CVE-2015-5212": {"epss_score": 0.49583, "epss_percentile": 0.97696}, "CVE-2015-5213": {"epss_score": 0.2277, "epss_percentile": 0.95685}, "CVE-2015-5214": {"epss_score": 0.35608, "epss_percentile": 0.96922}, "CVE-2015-5215": {"epss_score": 0.00522, "epss_percentile": 0.66277}, "CVE-2015-5216": {"epss_score": 0.0059, "epss_percentile": 0.68576}, "CVE-2015-5217": {"epss_score": 0.00388, "epss_percentile": 0.59386}, "CVE-2015-5218": {"epss_score": 0.00078, "epss_percentile": 0.23654}, "CVE-2015-5219": {"epss_score": 0.03109, "epss_percentile": 0.86422}, "CVE-2015-5220": {"epss_score": 0.01515, "epss_percentile": 0.80796}, "CVE-2015-5221": {"epss_score": 0.00229, "epss_percentile": 0.45654}, "CVE-2015-5222": {"epss_score": 0.00471, "epss_percentile": 0.64018}, "CVE-2015-5223": {"epss_score": 0.01146, "epss_percentile": 0.77998}, "CVE-2015-5224": {"epss_score": 0.04076, "epss_percentile": 0.88211}, "CVE-2015-5225": {"epss_score": 0.00167, "epss_percentile": 0.38393}, "CVE-2015-5227": {"epss_score": 0.02042, "epss_percentile": 0.83376}, "CVE-2015-5228": {"epss_score": 0.00135, "epss_percentile": 0.33994}, "CVE-2015-5229": {"epss_score": 0.01, "epss_percentile": 0.76491}, "CVE-2015-5230": {"epss_score": 0.00177, "epss_percentile": 0.39596}, "CVE-2015-5231": {"epss_score": 0.0006, "epss_percentile": 0.19096}, "CVE-2015-5232": {"epss_score": 0.00849, "epss_percentile": 0.74375}, "CVE-2015-5233": {"epss_score": 0.00194, "epss_percentile": 0.41548}, "CVE-2015-5234": {"epss_score": 0.0092, "epss_percentile": 0.7547}, "CVE-2015-5235": {"epss_score": 0.00938, "epss_percentile": 0.75713}, "CVE-2015-5236": {"epss_score": 0.00124, "epss_percentile": 0.32384}, "CVE-2015-5237": {"epss_score": 0.00763, "epss_percentile": 0.72851}, "CVE-2015-5239": {"epss_score": 0.05062, "epss_percentile": 0.89454}, "CVE-2015-5240": {"epss_score": 0.00094, "epss_percentile": 0.27068}, "CVE-2015-5241": {"epss_score": 0.02557, "epss_percentile": 0.85095}, "CVE-2015-5242": {"epss_score": 0.01202, "epss_percentile": 0.78485}, "CVE-2015-5243": {"epss_score": 0.11626, "epss_percentile": 0.93424}, "CVE-2015-5244": {"epss_score": 0.00179, "epss_percentile": 0.39746}, "CVE-2015-5245": {"epss_score": 0.00361, "epss_percentile": 0.57719}, "CVE-2015-5246": {"epss_score": 0.00711, "epss_percentile": 0.71743}, "CVE-2015-5247": {"epss_score": 0.00485, "epss_percentile": 0.64715}, "CVE-2015-5248": {"epss_score": 0.00209, "epss_percentile": 0.434}, "CVE-2015-5250": {"epss_score": 0.00455, "epss_percentile": 0.63299}, "CVE-2015-5251": {"epss_score": 0.00171, "epss_percentile": 0.38902}, "CVE-2015-5252": {"epss_score": 0.17333, "epss_percentile": 0.94825}, "CVE-2015-5253": {"epss_score": 0.00336, "epss_percentile": 0.55987}, "CVE-2015-5254": {"epss_score": 0.77148, "epss_percentile": 0.98924}, "CVE-2015-5255": {"epss_score": 0.02902, "epss_percentile": 0.85957}, "CVE-2015-5256": {"epss_score": 0.00705, "epss_percentile": 0.71576}, "CVE-2015-5257": {"epss_score": 0.00075, "epss_percentile": 0.22945}, "CVE-2015-5258": {"epss_score": 0.00167, "epss_percentile": 0.38365}, "CVE-2015-5259": {"epss_score": 0.40679, "epss_percentile": 0.97231}, "CVE-2015-5260": {"epss_score": 0.00291, "epss_percentile": 0.52203}, "CVE-2015-5261": {"epss_score": 0.00092, "epss_percentile": 0.26594}, "CVE-2015-5262": {"epss_score": 0.0092, "epss_percentile": 0.75463}, "CVE-2015-5263": {"epss_score": 0.00298, "epss_percentile": 0.52773}, "CVE-2015-5264": {"epss_score": 0.00242, "epss_percentile": 0.4736}, "CVE-2015-5265": {"epss_score": 0.00269, "epss_percentile": 0.50183}, "CVE-2015-5266": {"epss_score": 0.00248, "epss_percentile": 0.47983}, "CVE-2015-5267": {"epss_score": 0.00401, "epss_percentile": 0.60213}, "CVE-2015-5268": {"epss_score": 0.00281, "epss_percentile": 0.51138}, "CVE-2015-5269": {"epss_score": 0.00191, "epss_percentile": 0.41211}, "CVE-2015-5271": {"epss_score": 0.00342, "epss_percentile": 0.56391}, "CVE-2015-5272": {"epss_score": 0.00259, "epss_percentile": 0.49097}, "CVE-2015-5273": {"epss_score": 0.00334, "epss_percentile": 0.55704}, "CVE-2015-5274": {"epss_score": 0.00622, "epss_percentile": 0.69505}, "CVE-2015-5276": {"epss_score": 0.00448, "epss_percentile": 0.63031}, "CVE-2015-5277": {"epss_score": 0.00102, "epss_percentile": 0.28749}, "CVE-2015-5278": {"epss_score": 0.01853, "epss_percentile": 0.8255}, "CVE-2015-5279": {"epss_score": 0.10195, "epss_percentile": 0.92888}, "CVE-2015-5281": {"epss_score": 0.0006, "epss_percentile": 0.19114}, "CVE-2015-5282": {"epss_score": 0.00433, "epss_percentile": 0.62222}, "CVE-2015-5283": {"epss_score": 0.00103, "epss_percentile": 0.28928}, "CVE-2015-5284": {"epss_score": 0.00297, "epss_percentile": 0.52705}, "CVE-2015-5285": {"epss_score": 0.05309, "epss_percentile": 0.89716}, "CVE-2015-5286": {"epss_score": 0.00445, "epss_percentile": 0.62873}, "CVE-2015-5287": {"epss_score": 0.12902, "epss_percentile": 0.93814}, "CVE-2015-5288": {"epss_score": 0.10288, "epss_percentile": 0.92929}, "CVE-2015-5289": {"epss_score": 0.12525, "epss_percentile": 0.93708}, "CVE-2015-5290": {"epss_score": 0.00528, "epss_percentile": 0.66546}, "CVE-2015-5291": {"epss_score": 0.01704, "epss_percentile": 0.81847}, "CVE-2015-5292": {"epss_score": 0.02687, "epss_percentile": 0.8543}, "CVE-2015-5293": {"epss_score": 0.00281, "epss_percentile": 0.51106}, "CVE-2015-5295": {"epss_score": 0.01636, "epss_percentile": 0.81474}, "CVE-2015-5296": {"epss_score": 0.03374, "epss_percentile": 0.87014}, "CVE-2015-5297": {"epss_score": 0.00387, "epss_percentile": 0.59303}, "CVE-2015-5298": {"epss_score": 0.00726, "epss_percentile": 0.72067}, "CVE-2015-5299": {"epss_score": 0.08491, "epss_percentile": 0.92082}, "CVE-2015-5300": {"epss_score": 0.36837, "epss_percentile": 0.97003}, "CVE-2015-5301": {"epss_score": 0.00659, "epss_percentile": 0.70515}, "CVE-2015-5302": {"epss_score": 0.00611, "epss_percentile": 0.69207}, "CVE-2015-5303": {"epss_score": 0.00326, "epss_percentile": 0.55089}, "CVE-2015-5304": {"epss_score": 0.01287, "epss_percentile": 0.79196}, "CVE-2015-5305": {"epss_score": 0.00283, "epss_percentile": 0.51398}, "CVE-2015-5306": {"epss_score": 0.0057, "epss_percentile": 0.67967}, "CVE-2015-5307": {"epss_score": 0.00171, "epss_percentile": 0.38806}, "CVE-2015-5308": {"epss_score": 0.00925, "epss_percentile": 0.75539}, "CVE-2015-5309": {"epss_score": 0.01736, "epss_percentile": 0.82014}, "CVE-2015-5310": {"epss_score": 0.00304, "epss_percentile": 0.53244}, "CVE-2015-5311": {"epss_score": 0.85298, "epss_percentile": 0.99327}, "CVE-2015-5312": {"epss_score": 0.01993, "epss_percentile": 0.83184}, "CVE-2015-5313": {"epss_score": 0.00057, "epss_percentile": 0.18009}, "CVE-2015-5314": {"epss_score": 0.0115, "epss_percentile": 0.78027}, "CVE-2015-5315": {"epss_score": 0.0115, "epss_percentile": 0.78027}, "CVE-2015-5316": {"epss_score": 0.01524, "epss_percentile": 0.80846}, "CVE-2015-5317": {"epss_score": 0.27392, "epss_percentile": 0.96242}, "CVE-2015-5318": {"epss_score": 0.00058, "epss_percentile": 0.1839}, "CVE-2015-5319": {"epss_score": 0.00316, "epss_percentile": 0.54297}, "CVE-2015-5320": {"epss_score": 0.00209, "epss_percentile": 0.43374}, "CVE-2015-5321": {"epss_score": 0.00209, "epss_percentile": 0.43374}, "CVE-2015-5322": {"epss_score": 0.00169, "epss_percentile": 0.38555}, "CVE-2015-5323": {"epss_score": 0.00201, "epss_percentile": 0.42282}, "CVE-2015-5324": {"epss_score": 0.00284, "epss_percentile": 0.51443}, "CVE-2015-5325": {"epss_score": 0.00127, "epss_percentile": 0.32867}, "CVE-2015-5326": {"epss_score": 0.0016, "epss_percentile": 0.375}, "CVE-2015-5327": {"epss_score": 0.00207, "epss_percentile": 0.43083}, "CVE-2015-5329": {"epss_score": 0.00447, "epss_percentile": 0.62983}, "CVE-2015-5330": {"epss_score": 0.01625, "epss_percentile": 0.81419}, "CVE-2015-5331": {"epss_score": 0.00179, "epss_percentile": 0.39785}, "CVE-2015-5332": {"epss_score": 0.00568, "epss_percentile": 0.6788}, "CVE-2015-5333": {"epss_score": 0.02094, "epss_percentile": 0.8358}, "CVE-2015-5334": {"epss_score": 0.09911, "epss_percentile": 0.92769}, "CVE-2015-5335": {"epss_score": 0.00068, "epss_percentile": 0.21229}, "CVE-2015-5336": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2015-5337": {"epss_score": 0.00272, "epss_percentile": 0.50359}, "CVE-2015-5338": {"epss_score": 0.00118, "epss_percentile": 0.31429}, "CVE-2015-5339": {"epss_score": 0.00159, "epss_percentile": 0.37354}, "CVE-2015-5340": {"epss_score": 0.00172, "epss_percentile": 0.39038}, "CVE-2015-5341": {"epss_score": 0.00153, "epss_percentile": 0.36571}, "CVE-2015-5342": {"epss_score": 0.00179, "epss_percentile": 0.39785}, "CVE-2015-5343": {"epss_score": 0.19092, "epss_percentile": 0.95128}, "CVE-2015-5344": {"epss_score": 0.04974, "epss_percentile": 0.89353}, "CVE-2015-5345": {"epss_score": 0.36786, "epss_percentile": 0.97}, "CVE-2015-5346": {"epss_score": 0.33163, "epss_percentile": 0.96751}, "CVE-2015-5347": {"epss_score": 0.01707, "epss_percentile": 0.81859}, "CVE-2015-5348": {"epss_score": 0.06832, "epss_percentile": 0.91055}, "CVE-2015-5349": {"epss_score": 0.01431, "epss_percentile": 0.8024}, "CVE-2015-5350": {"epss_score": 0.00178, "epss_percentile": 0.39715}, "CVE-2015-5351": {"epss_score": 0.06092, "epss_percentile": 0.90475}, "CVE-2015-5352": {"epss_score": 0.05019, "epss_percentile": 0.89399}, "CVE-2015-5353": {"epss_score": 0.0699, "epss_percentile": 0.91166}, "CVE-2015-5354": {"epss_score": 0.21803, "epss_percentile": 0.95562}, "CVE-2015-5355": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-5356": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-5357": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2015-5358": {"epss_score": 0.03332, "epss_percentile": 0.8693}, "CVE-2015-5359": {"epss_score": 0.0046, "epss_percentile": 0.63502}, "CVE-2015-5360": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2015-5361": {"epss_score": 0.00145, "epss_percentile": 0.35427}, "CVE-2015-5362": {"epss_score": 0.04182, "epss_percentile": 0.88358}, "CVE-2015-5363": {"epss_score": 0.00361, "epss_percentile": 0.57725}, "CVE-2015-5364": {"epss_score": 0.21228, "epss_percentile": 0.95481}, "CVE-2015-5365": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2015-5366": {"epss_score": 0.09717, "epss_percentile": 0.92675}, "CVE-2015-5367": {"epss_score": 0.00058, "epss_percentile": 0.18518}, "CVE-2015-5368": {"epss_score": 0.02816, "epss_percentile": 0.85732}, "CVE-2015-5369": {"epss_score": 0.00377, "epss_percentile": 0.58711}, "CVE-2015-5370": {"epss_score": 0.24041, "epss_percentile": 0.95849}, "CVE-2015-5371": {"epss_score": 0.83033, "epss_percentile": 0.99227}, "CVE-2015-5372": {"epss_score": 0.00196, "epss_percentile": 0.41791}, "CVE-2015-5374": {"epss_score": 0.84604, "epss_percentile": 0.99297}, "CVE-2015-5375": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2015-5376": {"epss_score": 0.00421, "epss_percentile": 0.61529}, "CVE-2015-5377": {"epss_score": 0.39895, "epss_percentile": 0.97186}, "CVE-2015-5378": {"epss_score": 0.00673, "epss_percentile": 0.70837}, "CVE-2015-5379": {"epss_score": 0.00254, "epss_percentile": 0.48565}, "CVE-2015-5380": {"epss_score": 0.00755, "epss_percentile": 0.72718}, "CVE-2015-5381": {"epss_score": 0.01182, "epss_percentile": 0.78313}, "CVE-2015-5382": {"epss_score": 0.01037, "epss_percentile": 0.76928}, "CVE-2015-5383": {"epss_score": 0.01804, "epss_percentile": 0.82344}, "CVE-2015-5384": {"epss_score": 0.00332, "epss_percentile": 0.55609}, "CVE-2015-5386": {"epss_score": 0.00725, "epss_percentile": 0.72047}, "CVE-2015-5395": {"epss_score": 0.00363, "epss_percentile": 0.57826}, "CVE-2015-5397": {"epss_score": 0.00028, "epss_percentile": 0.0728}, "CVE-2015-5399": {"epss_score": 0.00227, "epss_percentile": 0.45457}, "CVE-2015-5400": {"epss_score": 0.19753, "epss_percentile": 0.95237}, "CVE-2015-5401": {"epss_score": 0.0126, "epss_percentile": 0.78971}, "CVE-2015-5402": {"epss_score": 0.00056, "epss_percentile": 0.1778}, "CVE-2015-5403": {"epss_score": 0.00213, "epss_percentile": 0.43931}, "CVE-2015-5404": {"epss_score": 0.01011, "epss_percentile": 0.76612}, "CVE-2015-5405": {"epss_score": 0.00234, "epss_percentile": 0.46094}, "CVE-2015-5406": {"epss_score": 0.0036, "epss_percentile": 0.5765}, "CVE-2015-5407": {"epss_score": 0.00119, "epss_percentile": 0.3166}, "CVE-2015-5408": {"epss_score": 0.00119, "epss_percentile": 0.3166}, "CVE-2015-5409": {"epss_score": 0.00381, "epss_percentile": 0.59007}, "CVE-2015-5410": {"epss_score": 0.00615, "epss_percentile": 0.69292}, "CVE-2015-5411": {"epss_score": 0.00271, "epss_percentile": 0.50322}, "CVE-2015-5412": {"epss_score": 0.00051, "epss_percentile": 0.16039}, "CVE-2015-5413": {"epss_score": 0.00213, "epss_percentile": 0.43931}, "CVE-2015-5416": {"epss_score": 0.06847, "epss_percentile": 0.9107}, "CVE-2015-5417": {"epss_score": 0.15716, "epss_percentile": 0.94492}, "CVE-2015-5418": {"epss_score": 0.15716, "epss_percentile": 0.94492}, "CVE-2015-5419": {"epss_score": 0.15716, "epss_percentile": 0.94492}, "CVE-2015-5420": {"epss_score": 0.15716, "epss_percentile": 0.94492}, "CVE-2015-5421": {"epss_score": 0.15716, "epss_percentile": 0.94492}, "CVE-2015-5422": {"epss_score": 0.15716, "epss_percentile": 0.94492}, "CVE-2015-5423": {"epss_score": 0.15716, "epss_percentile": 0.94492}, "CVE-2015-5424": {"epss_score": 0.15716, "epss_percentile": 0.94492}, "CVE-2015-5426": {"epss_score": 0.00104, "epss_percentile": 0.29206}, "CVE-2015-5427": {"epss_score": 0.01115, "epss_percentile": 0.77714}, "CVE-2015-5428": {"epss_score": 0.01115, "epss_percentile": 0.77714}, "CVE-2015-5429": {"epss_score": 0.01115, "epss_percentile": 0.77714}, "CVE-2015-5430": {"epss_score": 0.00689, "epss_percentile": 0.71218}, "CVE-2015-5431": {"epss_score": 0.00234, "epss_percentile": 0.46094}, "CVE-2015-5432": {"epss_score": 0.01011, "epss_percentile": 0.76612}, "CVE-2015-5433": {"epss_score": 0.00213, "epss_percentile": 0.43931}, "CVE-2015-5434": {"epss_score": 0.00699, "epss_percentile": 0.71446}, "CVE-2015-5435": {"epss_score": 0.0026, "epss_percentile": 0.49102}, "CVE-2015-5436": {"epss_score": 0.00547, "epss_percentile": 0.67253}, "CVE-2015-5440": {"epss_score": 0.00766, "epss_percentile": 0.7294}, "CVE-2015-5441": {"epss_score": 0.00674, "epss_percentile": 0.70872}, "CVE-2015-5442": {"epss_score": 0.00086, "epss_percentile": 0.25312}, "CVE-2015-5443": {"epss_score": 0.00213, "epss_percentile": 0.43931}, "CVE-2015-5444": {"epss_score": 0.00623, "epss_percentile": 0.69548}, "CVE-2015-5445": {"epss_score": 0.00093, "epss_percentile": 0.26613}, "CVE-2015-5446": {"epss_score": 0.00829, "epss_percentile": 0.74011}, "CVE-2015-5447": {"epss_score": 0.00231, "epss_percentile": 0.45796}, "CVE-2015-5448": {"epss_score": 0.00061, "epss_percentile": 0.19284}, "CVE-2015-5451": {"epss_score": 0.00113, "epss_percentile": 0.30725}, "CVE-2015-5452": {"epss_score": 0.31088, "epss_percentile": 0.96587}, "CVE-2015-5453": {"epss_score": 0.72451, "epss_percentile": 0.98711}, "CVE-2015-5454": {"epss_score": 0.00506, "epss_percentile": 0.65637}, "CVE-2015-5455": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2015-5456": {"epss_score": 0.00421, "epss_percentile": 0.61506}, "CVE-2015-5457": {"epss_score": 0.03371, "epss_percentile": 0.8701}, "CVE-2015-5458": {"epss_score": 0.01077, "epss_percentile": 0.77334}, "CVE-2015-5459": {"epss_score": 0.00837, "epss_percentile": 0.74159}, "CVE-2015-5460": {"epss_score": 0.00811, "epss_percentile": 0.73739}, "CVE-2015-5461": {"epss_score": 0.1779, "epss_percentile": 0.94906}, "CVE-2015-5462": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2015-5463": {"epss_score": 0.00964, "epss_percentile": 0.76025}, "CVE-2015-5464": {"epss_score": 0.00046, "epss_percentile": 0.14187}, "CVE-2015-5465": {"epss_score": 0.00608, "epss_percentile": 0.69086}, "CVE-2015-5466": {"epss_score": 0.00158, "epss_percentile": 0.37163}, "CVE-2015-5467": {"epss_score": 0.00137, "epss_percentile": 0.34286}, "CVE-2015-5468": {"epss_score": 0.50893, "epss_percentile": 0.97755}, "CVE-2015-5469": {"epss_score": 0.4911, "epss_percentile": 0.97667}, "CVE-2015-5470": {"epss_score": 0.02321, "epss_percentile": 0.8437}, "CVE-2015-5471": {"epss_score": 0.41406, "epss_percentile": 0.97272}, "CVE-2015-5472": {"epss_score": 0.00928, "epss_percentile": 0.75574}, "CVE-2015-5473": {"epss_score": 0.46933, "epss_percentile": 0.97563}, "CVE-2015-5474": {"epss_score": 0.01221, "epss_percentile": 0.78646}, "CVE-2015-5475": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2015-5477": {"epss_score": 0.92752, "epss_percentile": 0.99744}, "CVE-2015-5479": {"epss_score": 0.01326, "epss_percentile": 0.79483}, "CVE-2015-5481": {"epss_score": 0.00233, "epss_percentile": 0.46}, "CVE-2015-5482": {"epss_score": 0.00653, "epss_percentile": 0.70328}, "CVE-2015-5483": {"epss_score": 0.00333, "epss_percentile": 0.55633}, "CVE-2015-5484": {"epss_score": 0.00205, "epss_percentile": 0.42715}, "CVE-2015-5485": {"epss_score": 0.00473, "epss_percentile": 0.64092}, "CVE-2015-5487": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2015-5488": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-5489": {"epss_score": 0.00158, "epss_percentile": 0.37221}, "CVE-2015-5490": {"epss_score": 0.00417, "epss_percentile": 0.61249}, "CVE-2015-5491": {"epss_score": 0.00176, "epss_percentile": 0.39487}, "CVE-2015-5492": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-5493": {"epss_score": 0.00214, "epss_percentile": 0.43993}, "CVE-2015-5494": {"epss_score": 0.00158, "epss_percentile": 0.37221}, "CVE-2015-5495": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-5496": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2015-5497": {"epss_score": 0.00152, "epss_percentile": 0.36391}, "CVE-2015-5498": {"epss_score": 0.00319, "epss_percentile": 0.54527}, "CVE-2015-5499": {"epss_score": 0.00129, "epss_percentile": 0.33215}, "CVE-2015-5500": {"epss_score": 0.0014, "epss_percentile": 0.34736}, "CVE-2015-5501": {"epss_score": 0.00715, "epss_percentile": 0.71842}, "CVE-2015-5502": {"epss_score": 0.00647, "epss_percentile": 0.70203}, "CVE-2015-5503": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2015-5504": {"epss_score": 0.0052, "epss_percentile": 0.66202}, "CVE-2015-5505": {"epss_score": 0.00559, "epss_percentile": 0.67621}, "CVE-2015-5506": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2015-5507": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2015-5508": {"epss_score": 0.00296, "epss_percentile": 0.52558}, "CVE-2015-5509": {"epss_score": 0.00277, "epss_percentile": 0.50809}, "CVE-2015-5510": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2015-5511": {"epss_score": 0.00291, "epss_percentile": 0.52178}, "CVE-2015-5512": {"epss_score": 0.0056, "epss_percentile": 0.6763}, "CVE-2015-5513": {"epss_score": 0.00208, "epss_percentile": 0.43282}, "CVE-2015-5514": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2015-5515": {"epss_score": 0.0056, "epss_percentile": 0.67641}, "CVE-2015-5516": {"epss_score": 0.01617, "epss_percentile": 0.81368}, "CVE-2015-5519": {"epss_score": 0.00361, "epss_percentile": 0.5771}, "CVE-2015-5520": {"epss_score": 0.12279, "epss_percentile": 0.9362}, "CVE-2015-5521": {"epss_score": 0.0024, "epss_percentile": 0.47206}, "CVE-2015-5522": {"epss_score": 0.06473, "epss_percentile": 0.9078}, "CVE-2015-5523": {"epss_score": 0.05027, "epss_percentile": 0.8941}, "CVE-2015-5524": {"epss_score": 0.00161, "epss_percentile": 0.37557}, "CVE-2015-5528": {"epss_score": 0.00498, "epss_percentile": 0.6522}, "CVE-2015-5529": {"epss_score": 0.0713, "epss_percentile": 0.9127}, "CVE-2015-5530": {"epss_score": 0.0057, "epss_percentile": 0.67951}, "CVE-2015-5531": {"epss_score": 0.91581, "epss_percentile": 0.99654}, "CVE-2015-5532": {"epss_score": 0.01286, "epss_percentile": 0.79181}, "CVE-2015-5533": {"epss_score": 0.09524, "epss_percentile": 0.92586}, "CVE-2015-5534": {"epss_score": 0.01177, "epss_percentile": 0.78278}, "CVE-2015-5535": {"epss_score": 0.0027, "epss_percentile": 0.50203}, "CVE-2015-5536": {"epss_score": 0.03352, "epss_percentile": 0.86966}, "CVE-2015-5537": {"epss_score": 0.00323, "epss_percentile": 0.54909}, "CVE-2015-5538": {"epss_score": 0.01961, "epss_percentile": 0.83059}, "CVE-2015-5539": {"epss_score": 0.51159, "epss_percentile": 0.97767}, "CVE-2015-5540": {"epss_score": 0.51159, "epss_percentile": 0.97767}, "CVE-2015-5541": {"epss_score": 0.0952, "epss_percentile": 0.92583}, "CVE-2015-5544": {"epss_score": 0.46078, "epss_percentile": 0.97524}, "CVE-2015-5545": {"epss_score": 0.46078, "epss_percentile": 0.97524}, "CVE-2015-5546": {"epss_score": 0.46078, "epss_percentile": 0.97524}, "CVE-2015-5547": {"epss_score": 0.46078, "epss_percentile": 0.97524}, "CVE-2015-5548": {"epss_score": 0.46078, "epss_percentile": 0.97524}, "CVE-2015-5549": {"epss_score": 0.46078, "epss_percentile": 0.97524}, "CVE-2015-5550": {"epss_score": 0.47024, "epss_percentile": 0.97567}, "CVE-2015-5551": {"epss_score": 0.47024, "epss_percentile": 0.97567}, "CVE-2015-5552": {"epss_score": 0.04245, "epss_percentile": 0.88439}, "CVE-2015-5553": {"epss_score": 0.04245, "epss_percentile": 0.88439}, "CVE-2015-5554": {"epss_score": 0.47024, "epss_percentile": 0.97567}, "CVE-2015-5555": {"epss_score": 0.47024, "epss_percentile": 0.97567}, "CVE-2015-5556": {"epss_score": 0.47024, "epss_percentile": 0.97567}, "CVE-2015-5557": {"epss_score": 0.47024, "epss_percentile": 0.97567}, "CVE-2015-5558": {"epss_score": 0.47024, "epss_percentile": 0.97567}, "CVE-2015-5559": {"epss_score": 0.03819, "epss_percentile": 0.87772}, "CVE-2015-5560": {"epss_score": 0.53139, "epss_percentile": 0.97857}, "CVE-2015-5561": {"epss_score": 0.47024, "epss_percentile": 0.97567}, "CVE-2015-5562": {"epss_score": 0.5818, "epss_percentile": 0.98102}, "CVE-2015-5563": {"epss_score": 0.5818, "epss_percentile": 0.98102}, "CVE-2015-5564": {"epss_score": 0.03237, "epss_percentile": 0.86707}, "CVE-2015-5565": {"epss_score": 0.04804, "epss_percentile": 0.8916}, "CVE-2015-5566": {"epss_score": 0.04803, "epss_percentile": 0.8916}, "CVE-2015-5567": {"epss_score": 0.03267, "epss_percentile": 0.86784}, "CVE-2015-5568": {"epss_score": 0.31842, "epss_percentile": 0.96654}, "CVE-2015-5569": {"epss_score": 0.06007, "epss_percentile": 0.90399}, "CVE-2015-5570": {"epss_score": 0.01694, "epss_percentile": 0.81801}, "CVE-2015-5571": {"epss_score": 0.01418, "epss_percentile": 0.80158}, "CVE-2015-5572": {"epss_score": 0.01518, "epss_percentile": 0.80815}, "CVE-2015-5573": {"epss_score": 0.03821, "epss_percentile": 0.87783}, "CVE-2015-5574": {"epss_score": 0.71007, "epss_percentile": 0.9865}, "CVE-2015-5575": {"epss_score": 0.043, "epss_percentile": 0.88514}, "CVE-2015-5576": {"epss_score": 0.03873, "epss_percentile": 0.87884}, "CVE-2015-5577": {"epss_score": 0.043, "epss_percentile": 0.88514}, "CVE-2015-5578": {"epss_score": 0.043, "epss_percentile": 0.88514}, "CVE-2015-5579": {"epss_score": 0.11081, "epss_percentile": 0.93213}, "CVE-2015-5580": {"epss_score": 0.043, "epss_percentile": 0.88514}, "CVE-2015-5581": {"epss_score": 0.01661, "epss_percentile": 0.81624}, "CVE-2015-5582": {"epss_score": 0.043, "epss_percentile": 0.88514}, "CVE-2015-5583": {"epss_score": 0.02968, "epss_percentile": 0.86089}, "CVE-2015-5584": {"epss_score": 0.01661, "epss_percentile": 0.81624}, "CVE-2015-5586": {"epss_score": 0.02518, "epss_percentile": 0.84994}, "CVE-2015-5587": {"epss_score": 0.09898, "epss_percentile": 0.92761}, "CVE-2015-5588": {"epss_score": 0.043, "epss_percentile": 0.88514}, "CVE-2015-5589": {"epss_score": 0.10384, "epss_percentile": 0.92968}, "CVE-2015-5590": {"epss_score": 0.06413, "epss_percentile": 0.90742}, "CVE-2015-5591": {"epss_score": 0.05314, "epss_percentile": 0.89721}, "CVE-2015-5592": {"epss_score": 0.00697, "epss_percentile": 0.71409}, "CVE-2015-5593": {"epss_score": 0.00373, "epss_percentile": 0.58516}, "CVE-2015-5594": {"epss_score": 0.00292, "epss_percentile": 0.52242}, "CVE-2015-5595": {"epss_score": 0.00159, "epss_percentile": 0.37384}, "CVE-2015-5599": {"epss_score": 0.01592, "epss_percentile": 0.81223}, "CVE-2015-5600": {"epss_score": 0.70907, "epss_percentile": 0.98646}, "CVE-2015-5601": {"epss_score": 0.00898, "epss_percentile": 0.75144}, "CVE-2015-5602": {"epss_score": 0.05506, "epss_percentile": 0.89943}, "CVE-2015-5603": {"epss_score": 0.8253, "epss_percentile": 0.99198}, "CVE-2015-5605": {"epss_score": 0.01482, "epss_percentile": 0.80574}, "CVE-2015-5606": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2015-5607": {"epss_score": 0.00215, "epss_percentile": 0.44101}, "CVE-2015-5608": {"epss_score": 0.00061, "epss_percentile": 0.19249}, "CVE-2015-5609": {"epss_score": 0.01234, "epss_percentile": 0.7876}, "CVE-2015-5610": {"epss_score": 0.00471, "epss_percentile": 0.63997}, "CVE-2015-5611": {"epss_score": 0.0407, "epss_percentile": 0.88204}, "CVE-2015-5612": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-5613": {"epss_score": 0.00227, "epss_percentile": 0.45434}, "CVE-2015-5617": {"epss_score": 0.01457, "epss_percentile": 0.80402}, "CVE-2015-5618": {"epss_score": 0.00264, "epss_percentile": 0.49578}, "CVE-2015-5619": {"epss_score": 0.00306, "epss_percentile": 0.53454}, "CVE-2015-5621": {"epss_score": 0.17811, "epss_percentile": 0.94909}, "CVE-2015-5622": {"epss_score": 0.00968, "epss_percentile": 0.76083}, "CVE-2015-5623": {"epss_score": 0.48368, "epss_percentile": 0.97634}, "CVE-2015-5624": {"epss_score": 0.02495, "epss_percentile": 0.84905}, "CVE-2015-5625": {"epss_score": 0.0035, "epss_percentile": 0.56947}, "CVE-2015-5626": {"epss_score": 0.01355, "epss_percentile": 0.79712}, "CVE-2015-5627": {"epss_score": 0.01355, "epss_percentile": 0.79712}, "CVE-2015-5628": {"epss_score": 0.07489, "epss_percentile": 0.91499}, "CVE-2015-5629": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2015-5630": {"epss_score": 0.00309, "epss_percentile": 0.53719}, "CVE-2015-5631": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-5632": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2015-5633": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2015-5634": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2015-5635": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2015-5636": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2015-5637": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2015-5638": {"epss_score": 0.00242, "epss_percentile": 0.47356}, "CVE-2015-5639": {"epss_score": 0.00566, "epss_percentile": 0.67828}, "CVE-2015-5640": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2015-5641": {"epss_score": 0.00351, "epss_percentile": 0.57053}, "CVE-2015-5642": {"epss_score": 0.00351, "epss_percentile": 0.57053}, "CVE-2015-5643": {"epss_score": 0.00602, "epss_percentile": 0.68887}, "CVE-2015-5644": {"epss_score": 0.00602, "epss_percentile": 0.68887}, "CVE-2015-5645": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2015-5646": {"epss_score": 0.00728, "epss_percentile": 0.72112}, "CVE-2015-5647": {"epss_score": 0.00663, "epss_percentile": 0.70613}, "CVE-2015-5648": {"epss_score": 0.00338, "epss_percentile": 0.56114}, "CVE-2015-5649": {"epss_score": 0.00161, "epss_percentile": 0.3756}, "CVE-2015-5650": {"epss_score": 0.00193, "epss_percentile": 0.41378}, "CVE-2015-5651": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-5652": {"epss_score": 0.00147, "epss_percentile": 0.35674}, "CVE-2015-5653": {"epss_score": 0.01342, "epss_percentile": 0.79595}, "CVE-2015-5654": {"epss_score": 0.00254, "epss_percentile": 0.48622}, "CVE-2015-5655": {"epss_score": 0.00155, "epss_percentile": 0.36786}, "CVE-2015-5659": {"epss_score": 0.00515, "epss_percentile": 0.66008}, "CVE-2015-5660": {"epss_score": 0.00126, "epss_percentile": 0.32707}, "CVE-2015-5661": {"epss_score": 0.00229, "epss_percentile": 0.45572}, "CVE-2015-5662": {"epss_score": 0.00455, "epss_percentile": 0.63312}, "CVE-2015-5663": {"epss_score": 0.00082, "epss_percentile": 0.24463}, "CVE-2015-5664": {"epss_score": 0.00309, "epss_percentile": 0.537}, "CVE-2015-5665": {"epss_score": 0.00146, "epss_percentile": 0.356}, "CVE-2015-5666": {"epss_score": 0.00584, "epss_percentile": 0.68383}, "CVE-2015-5667": {"epss_score": 0.00483, "epss_percentile": 0.64559}, "CVE-2015-5668": {"epss_score": 0.00413, "epss_percentile": 0.60988}, "CVE-2015-5669": {"epss_score": 0.01272, "epss_percentile": 0.79082}, "CVE-2015-5670": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-5671": {"epss_score": 0.00207, "epss_percentile": 0.43199}, "CVE-2015-5672": {"epss_score": 0.01768, "epss_percentile": 0.82179}, "CVE-2015-5673": {"epss_score": 0.00516, "epss_percentile": 0.66054}, "CVE-2015-5674": {"epss_score": 0.00754, "epss_percentile": 0.72701}, "CVE-2015-5675": {"epss_score": 0.00051, "epss_percentile": 0.16164}, "CVE-2015-5677": {"epss_score": 0.00088, "epss_percentile": 0.25723}, "CVE-2015-5681": {"epss_score": 0.07795, "epss_percentile": 0.91686}, "CVE-2015-5682": {"epss_score": 0.00262, "epss_percentile": 0.49358}, "CVE-2015-5684": {"epss_score": 0.04065, "epss_percentile": 0.882}, "CVE-2015-5685": {"epss_score": 0.06613, "epss_percentile": 0.9089}, "CVE-2015-5686": {"epss_score": 0.0014, "epss_percentile": 0.34684}, "CVE-2015-5687": {"epss_score": 0.00553, "epss_percentile": 0.67406}, "CVE-2015-5688": {"epss_score": 0.69364, "epss_percentile": 0.98584}, "CVE-2015-5689": {"epss_score": 0.03, "epss_percentile": 0.86165}, "CVE-2015-5690": {"epss_score": 0.01552, "epss_percentile": 0.80991}, "CVE-2015-5691": {"epss_score": 0.00525, "epss_percentile": 0.66393}, "CVE-2015-5692": {"epss_score": 0.05789, "epss_percentile": 0.90211}, "CVE-2015-5693": {"epss_score": 0.03118, "epss_percentile": 0.86439}, "CVE-2015-5694": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2015-5695": {"epss_score": 0.02434, "epss_percentile": 0.84735}, "CVE-2015-5696": {"epss_score": 0.1625, "epss_percentile": 0.94601}, "CVE-2015-5697": {"epss_score": 0.00061, "epss_percentile": 0.1932}, "CVE-2015-5698": {"epss_score": 0.04383, "epss_percentile": 0.88627}, "CVE-2015-5699": {"epss_score": 0.00057, "epss_percentile": 0.18168}, "CVE-2015-5700": {"epss_score": 0.00184, "epss_percentile": 0.4038}, "CVE-2015-5701": {"epss_score": 0.00192, "epss_percentile": 0.41374}, "CVE-2015-5703": {"epss_score": 0.0044, "epss_percentile": 0.62635}, "CVE-2015-5704": {"epss_score": 0.00051, "epss_percentile": 0.16331}, "CVE-2015-5705": {"epss_score": 0.00829, "epss_percentile": 0.74006}, "CVE-2015-5706": {"epss_score": 0.00058, "epss_percentile": 0.18449}, "CVE-2015-5707": {"epss_score": 0.00091, "epss_percentile": 0.26216}, "CVE-2015-5711": {"epss_score": 0.00098, "epss_percentile": 0.27812}, "CVE-2015-5712": {"epss_score": 0.0032, "epss_percentile": 0.5463}, "CVE-2015-5713": {"epss_score": 0.00493, "epss_percentile": 0.65054}, "CVE-2015-5714": {"epss_score": 0.30646, "epss_percentile": 0.96558}, "CVE-2015-5715": {"epss_score": 0.28517, "epss_percentile": 0.96364}, "CVE-2015-5717": {"epss_score": 0.00137, "epss_percentile": 0.34279}, "CVE-2015-5718": {"epss_score": 0.00739, "epss_percentile": 0.72353}, "CVE-2015-5719": {"epss_score": 0.00434, "epss_percentile": 0.62308}, "CVE-2015-5720": {"epss_score": 0.00246, "epss_percentile": 0.47768}, "CVE-2015-5721": {"epss_score": 0.00858, "epss_percentile": 0.74503}, "CVE-2015-5722": {"epss_score": 0.65919, "epss_percentile": 0.98443}, "CVE-2015-5723": {"epss_score": 0.00102, "epss_percentile": 0.28793}, "CVE-2015-5725": {"epss_score": 0.00665, "epss_percentile": 0.70656}, "CVE-2015-5726": {"epss_score": 0.00869, "epss_percentile": 0.74689}, "CVE-2015-5727": {"epss_score": 0.00607, "epss_percentile": 0.69045}, "CVE-2015-5729": {"epss_score": 0.01349, "epss_percentile": 0.79672}, "CVE-2015-5730": {"epss_score": 0.09542, "epss_percentile": 0.9259}, "CVE-2015-5731": {"epss_score": 0.14757, "epss_percentile": 0.94276}, "CVE-2015-5732": {"epss_score": 0.01687, "epss_percentile": 0.81756}, "CVE-2015-5733": {"epss_score": 0.01502, "epss_percentile": 0.80724}, "CVE-2015-5734": {"epss_score": 0.03446, "epss_percentile": 0.8715}, "CVE-2015-5735": {"epss_score": 0.00061, "epss_percentile": 0.19537}, "CVE-2015-5736": {"epss_score": 0.01778, "epss_percentile": 0.82226}, "CVE-2015-5737": {"epss_score": 0.00061, "epss_percentile": 0.19537}, "CVE-2015-5738": {"epss_score": 0.00806, "epss_percentile": 0.73657}, "CVE-2015-5739": {"epss_score": 0.19207, "epss_percentile": 0.95148}, "CVE-2015-5740": {"epss_score": 0.04273, "epss_percentile": 0.88478}, "CVE-2015-5741": {"epss_score": 0.01751, "epss_percentile": 0.82103}, "CVE-2015-5742": {"epss_score": 0.00053, "epss_percentile": 0.16879}, "CVE-2015-5745": {"epss_score": 0.01921, "epss_percentile": 0.829}, "CVE-2015-5746": {"epss_score": 0.00231, "epss_percentile": 0.45768}, "CVE-2015-5747": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2015-5748": {"epss_score": 0.0008, "epss_percentile": 0.24055}, "CVE-2015-5749": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-5750": {"epss_score": 0.00755, "epss_percentile": 0.72719}, "CVE-2015-5751": {"epss_score": 0.02513, "epss_percentile": 0.84978}, "CVE-2015-5752": {"epss_score": 0.00431, "epss_percentile": 0.62044}, "CVE-2015-5753": {"epss_score": 0.02022, "epss_percentile": 0.83304}, "CVE-2015-5754": {"epss_score": 0.19685, "epss_percentile": 0.95226}, "CVE-2015-5755": {"epss_score": 0.0281, "epss_percentile": 0.85716}, "CVE-2015-5756": {"epss_score": 0.02102, "epss_percentile": 0.83606}, "CVE-2015-5757": {"epss_score": 0.01084, "epss_percentile": 0.77397}, "CVE-2015-5758": {"epss_score": 0.02828, "epss_percentile": 0.85769}, "CVE-2015-5759": {"epss_score": 0.00366, "epss_percentile": 0.58049}, "CVE-2015-5761": {"epss_score": 0.02497, "epss_percentile": 0.8491}, "CVE-2015-5763": {"epss_score": 0.00056, "epss_percentile": 0.17803}, "CVE-2015-5764": {"epss_score": 0.00846, "epss_percentile": 0.74333}, "CVE-2015-5765": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2015-5766": {"epss_score": 0.00228, "epss_percentile": 0.45526}, "CVE-2015-5767": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2015-5768": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-5769": {"epss_score": 0.00833, "epss_percentile": 0.7408}, "CVE-2015-5770": {"epss_score": 0.0036, "epss_percentile": 0.57629}, "CVE-2015-5771": {"epss_score": 0.02022, "epss_percentile": 0.83304}, "CVE-2015-5772": {"epss_score": 0.02529, "epss_percentile": 0.8502}, "CVE-2015-5773": {"epss_score": 0.02513, "epss_percentile": 0.84978}, "CVE-2015-5774": {"epss_score": 0.00088, "epss_percentile": 0.2579}, "CVE-2015-5775": {"epss_score": 0.01992, "epss_percentile": 0.83178}, "CVE-2015-5776": {"epss_score": 0.03016, "epss_percentile": 0.86216}, "CVE-2015-5777": {"epss_score": 0.01866, "epss_percentile": 0.82608}, "CVE-2015-5778": {"epss_score": 0.01866, "epss_percentile": 0.82608}, "CVE-2015-5779": {"epss_score": 0.02681, "epss_percentile": 0.85415}, "CVE-2015-5780": {"epss_score": 0.00628, "epss_percentile": 0.69645}, "CVE-2015-5781": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2015-5782": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2015-5783": {"epss_score": 0.01126, "epss_percentile": 0.77813}, "CVE-2015-5784": {"epss_score": 0.26205, "epss_percentile": 0.96123}, "CVE-2015-5785": {"epss_score": 0.01481, "epss_percentile": 0.80569}, "CVE-2015-5786": {"epss_score": 0.01481, "epss_percentile": 0.80569}, "CVE-2015-5787": {"epss_score": 0.00547, "epss_percentile": 0.67262}, "CVE-2015-5788": {"epss_score": 0.00466, "epss_percentile": 0.63808}, "CVE-2015-5789": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5790": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5791": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5792": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5793": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5794": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-5795": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5796": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5797": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5798": {"epss_score": 0.00651, "epss_percentile": 0.70287}, "CVE-2015-5799": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5800": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5801": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-5802": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5803": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5804": {"epss_score": 0.01093, "epss_percentile": 0.77486}, "CVE-2015-5805": {"epss_score": 0.01093, "epss_percentile": 0.77486}, "CVE-2015-5806": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5807": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-5808": {"epss_score": 0.00651, "epss_percentile": 0.70287}, "CVE-2015-5809": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-5810": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-5811": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5812": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5813": {"epss_score": 0.01093, "epss_percentile": 0.77486}, "CVE-2015-5814": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-5815": {"epss_score": 0.00651, "epss_percentile": 0.70287}, "CVE-2015-5816": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5817": {"epss_score": 0.01093, "epss_percentile": 0.77486}, "CVE-2015-5818": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-5819": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5820": {"epss_score": 0.006, "epss_percentile": 0.68811}, "CVE-2015-5821": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5822": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-5823": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-5824": {"epss_score": 0.00096, "epss_percentile": 0.27355}, "CVE-2015-5825": {"epss_score": 0.006, "epss_percentile": 0.68811}, "CVE-2015-5826": {"epss_score": 0.00664, "epss_percentile": 0.70633}, "CVE-2015-5827": {"epss_score": 0.00441, "epss_percentile": 0.6267}, "CVE-2015-5828": {"epss_score": 0.00779, "epss_percentile": 0.73143}, "CVE-2015-5829": {"epss_score": 0.02828, "epss_percentile": 0.85769}, "CVE-2015-5830": {"epss_score": 0.0006, "epss_percentile": 0.19236}, "CVE-2015-5831": {"epss_score": 0.00524, "epss_percentile": 0.66338}, "CVE-2015-5832": {"epss_score": 0.00069, "epss_percentile": 0.21531}, "CVE-2015-5833": {"epss_score": 0.0007, "epss_percentile": 0.21953}, "CVE-2015-5834": {"epss_score": 0.00524, "epss_percentile": 0.66338}, "CVE-2015-5835": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-5836": {"epss_score": 0.00286, "epss_percentile": 0.51778}, "CVE-2015-5837": {"epss_score": 0.00524, "epss_percentile": 0.66338}, "CVE-2015-5838": {"epss_score": 0.00224, "epss_percentile": 0.45011}, "CVE-2015-5839": {"epss_score": 0.00555, "epss_percentile": 0.67458}, "CVE-2015-5840": {"epss_score": 0.00915, "epss_percentile": 0.75411}, "CVE-2015-5841": {"epss_score": 0.0062, "epss_percentile": 0.69451}, "CVE-2015-5842": {"epss_score": 0.00063, "epss_percentile": 0.19859}, "CVE-2015-5843": {"epss_score": 0.00072, "epss_percentile": 0.22399}, "CVE-2015-5844": {"epss_score": 0.01466, "epss_percentile": 0.80466}, "CVE-2015-5845": {"epss_score": 0.01084, "epss_percentile": 0.77397}, "CVE-2015-5846": {"epss_score": 0.01466, "epss_percentile": 0.80466}, "CVE-2015-5847": {"epss_score": 0.00073, "epss_percentile": 0.2249}, "CVE-2015-5848": {"epss_score": 0.00072, "epss_percentile": 0.22399}, "CVE-2015-5849": {"epss_score": 0.00382, "epss_percentile": 0.59061}, "CVE-2015-5850": {"epss_score": 0.00067, "epss_percentile": 0.21075}, "CVE-2015-5851": {"epss_score": 0.00063, "epss_percentile": 0.19859}, "CVE-2015-5853": {"epss_score": 0.0013, "epss_percentile": 0.33261}, "CVE-2015-5854": {"epss_score": 0.00082, "epss_percentile": 0.24467}, "CVE-2015-5855": {"epss_score": 0.00524, "epss_percentile": 0.66338}, "CVE-2015-5856": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2015-5857": {"epss_score": 0.00409, "epss_percentile": 0.6073}, "CVE-2015-5858": {"epss_score": 0.00498, "epss_percentile": 0.65237}, "CVE-2015-5859": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2015-5860": {"epss_score": 0.00498, "epss_percentile": 0.65237}, "CVE-2015-5861": {"epss_score": 0.00057, "epss_percentile": 0.18049}, "CVE-2015-5862": {"epss_score": 0.01798, "epss_percentile": 0.82312}, "CVE-2015-5863": {"epss_score": 0.00063, "epss_percentile": 0.19859}, "CVE-2015-5864": {"epss_score": 0.00096, "epss_percentile": 0.27301}, "CVE-2015-5865": {"epss_score": 0.00286, "epss_percentile": 0.51778}, "CVE-2015-5866": {"epss_score": 0.00818, "epss_percentile": 0.73863}, "CVE-2015-5867": {"epss_score": 0.01084, "epss_percentile": 0.77397}, "CVE-2015-5868": {"epss_score": 0.00072, "epss_percentile": 0.22399}, "CVE-2015-5869": {"epss_score": 0.00452, "epss_percentile": 0.63158}, "CVE-2015-5870": {"epss_score": 0.00082, "epss_percentile": 0.24467}, "CVE-2015-5871": {"epss_score": 0.0006, "epss_percentile": 0.19236}, "CVE-2015-5872": {"epss_score": 0.0006, "epss_percentile": 0.19236}, "CVE-2015-5873": {"epss_score": 0.0006, "epss_percentile": 0.19236}, "CVE-2015-5874": {"epss_score": 0.03213, "epss_percentile": 0.86658}, "CVE-2015-5875": {"epss_score": 0.00105, "epss_percentile": 0.29394}, "CVE-2015-5876": {"epss_score": 0.01636, "epss_percentile": 0.81477}, "CVE-2015-5877": {"epss_score": 0.0006, "epss_percentile": 0.19236}, "CVE-2015-5878": {"epss_score": 0.00082, "epss_percentile": 0.24467}, "CVE-2015-5879": {"epss_score": 0.01846, "epss_percentile": 0.82514}, "CVE-2015-5880": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-5882": {"epss_score": 0.00067, "epss_percentile": 0.2116}, "CVE-2015-5883": {"epss_score": 0.00409, "epss_percentile": 0.6073}, "CVE-2015-5884": {"epss_score": 0.00106, "epss_percentile": 0.29556}, "CVE-2015-5885": {"epss_score": 0.00777, "epss_percentile": 0.73116}, "CVE-2015-5887": {"epss_score": 0.00752, "epss_percentile": 0.72661}, "CVE-2015-5888": {"epss_score": 0.00047, "epss_percentile": 0.14504}, "CVE-2015-5889": {"epss_score": 0.11558, "epss_percentile": 0.93404}, "CVE-2015-5890": {"epss_score": 0.00055, "epss_percentile": 0.17476}, "CVE-2015-5891": {"epss_score": 0.00053, "epss_percentile": 0.16885}, "CVE-2015-5892": {"epss_score": 0.00069, "epss_percentile": 0.21531}, "CVE-2015-5893": {"epss_score": 0.00061, "epss_percentile": 0.19511}, "CVE-2015-5894": {"epss_score": 0.00157, "epss_percentile": 0.37038}, "CVE-2015-5895": {"epss_score": 0.19371, "epss_percentile": 0.9517}, "CVE-2015-5896": {"epss_score": 0.00093, "epss_percentile": 0.26743}, "CVE-2015-5897": {"epss_score": 0.00153, "epss_percentile": 0.36627}, "CVE-2015-5898": {"epss_score": 0.00041, "epss_percentile": 0.12402}, "CVE-2015-5899": {"epss_score": 0.00093, "epss_percentile": 0.26743}, "CVE-2015-5900": {"epss_score": 0.00458, "epss_percentile": 0.63398}, "CVE-2015-5901": {"epss_score": 0.00061, "epss_percentile": 0.19284}, "CVE-2015-5902": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2015-5903": {"epss_score": 0.02023, "epss_percentile": 0.83305}, "CVE-2015-5904": {"epss_score": 0.00366, "epss_percentile": 0.58049}, "CVE-2015-5905": {"epss_score": 0.00377, "epss_percentile": 0.58698}, "CVE-2015-5906": {"epss_score": 0.00388, "epss_percentile": 0.59369}, "CVE-2015-5907": {"epss_score": 0.00157, "epss_percentile": 0.37038}, "CVE-2015-5909": {"epss_score": 0.00307, "epss_percentile": 0.53474}, "CVE-2015-5910": {"epss_score": 0.00144, "epss_percentile": 0.35268}, "CVE-2015-5911": {"epss_score": 0.00391, "epss_percentile": 0.59576}, "CVE-2015-5912": {"epss_score": 0.00524, "epss_percentile": 0.66338}, "CVE-2015-5913": {"epss_score": 0.00447, "epss_percentile": 0.62948}, "CVE-2015-5914": {"epss_score": 0.00069, "epss_percentile": 0.21524}, "CVE-2015-5915": {"epss_score": 0.00291, "epss_percentile": 0.52207}, "CVE-2015-5916": {"epss_score": 0.00555, "epss_percentile": 0.67458}, "CVE-2015-5917": {"epss_score": 0.01612, "epss_percentile": 0.81332}, "CVE-2015-5918": {"epss_score": 0.00055, "epss_percentile": 0.17476}, "CVE-2015-5919": {"epss_score": 0.00055, "epss_percentile": 0.17476}, "CVE-2015-5920": {"epss_score": 0.00297, "epss_percentile": 0.5269}, "CVE-2015-5921": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-5922": {"epss_score": 0.01986, "epss_percentile": 0.83158}, "CVE-2015-5923": {"epss_score": 0.00068, "epss_percentile": 0.2136}, "CVE-2015-5924": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2015-5925": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2015-5926": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2015-5927": {"epss_score": 0.01866, "epss_percentile": 0.82608}, "CVE-2015-5928": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-5929": {"epss_score": 0.0108, "epss_percentile": 0.77364}, "CVE-2015-5930": {"epss_score": 0.0108, "epss_percentile": 0.77364}, "CVE-2015-5931": {"epss_score": 0.01529, "epss_percentile": 0.80878}, "CVE-2015-5932": {"epss_score": 0.01071, "epss_percentile": 0.77263}, "CVE-2015-5933": {"epss_score": 0.01237, "epss_percentile": 0.78779}, "CVE-2015-5934": {"epss_score": 0.01237, "epss_percentile": 0.78779}, "CVE-2015-5935": {"epss_score": 0.02828, "epss_percentile": 0.85769}, "CVE-2015-5936": {"epss_score": 0.02513, "epss_percentile": 0.84978}, "CVE-2015-5937": {"epss_score": 0.02513, "epss_percentile": 0.84978}, "CVE-2015-5938": {"epss_score": 0.01018, "epss_percentile": 0.76698}, "CVE-2015-5939": {"epss_score": 0.02513, "epss_percentile": 0.84978}, "CVE-2015-5940": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2015-5942": {"epss_score": 0.01866, "epss_percentile": 0.82608}, "CVE-2015-5943": {"epss_score": 0.00222, "epss_percentile": 0.44753}, "CVE-2015-5944": {"epss_score": 0.01158, "epss_percentile": 0.78118}, "CVE-2015-5945": {"epss_score": 0.0012, "epss_percentile": 0.31713}, "CVE-2015-5946": {"epss_score": 0.00363, "epss_percentile": 0.57869}, "CVE-2015-5947": {"epss_score": 0.02865, "epss_percentile": 0.8586}, "CVE-2015-5948": {"epss_score": 0.02163, "epss_percentile": 0.83832}, "CVE-2015-5949": {"epss_score": 0.07468, "epss_percentile": 0.9149}, "CVE-2015-5950": {"epss_score": 0.00047, "epss_percentile": 0.14487}, "CVE-2015-5951": {"epss_score": 0.03066, "epss_percentile": 0.86337}, "CVE-2015-5952": {"epss_score": 0.02151, "epss_percentile": 0.83786}, "CVE-2015-5953": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2015-5954": {"epss_score": 0.00143, "epss_percentile": 0.35095}, "CVE-2015-5955": {"epss_score": 0.00204, "epss_percentile": 0.42647}, "CVE-2015-5956": {"epss_score": 0.00124, "epss_percentile": 0.32461}, "CVE-2015-5957": {"epss_score": 0.00491, "epss_percentile": 0.64961}, "CVE-2015-5958": {"epss_score": 0.4346, "epss_percentile": 0.97387}, "CVE-2015-5959": {"epss_score": 0.01459, "epss_percentile": 0.80412}, "CVE-2015-5960": {"epss_score": 0.00058, "epss_percentile": 0.1838}, "CVE-2015-5961": {"epss_score": 0.00087, "epss_percentile": 0.25561}, "CVE-2015-5962": {"epss_score": 0.00408, "epss_percentile": 0.60636}, "CVE-2015-5963": {"epss_score": 0.05343, "epss_percentile": 0.89764}, "CVE-2015-5964": {"epss_score": 0.04366, "epss_percentile": 0.88604}, "CVE-2015-5965": {"epss_score": 0.0035, "epss_percentile": 0.56955}, "CVE-2015-5968": {"epss_score": 0.00241, "epss_percentile": 0.47245}, "CVE-2015-5969": {"epss_score": 0.00134, "epss_percentile": 0.33876}, "CVE-2015-5970": {"epss_score": 0.00519, "epss_percentile": 0.6617}, "CVE-2015-5986": {"epss_score": 0.47991, "epss_percentile": 0.97612}, "CVE-2015-5987": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2015-5988": {"epss_score": 0.01454, "epss_percentile": 0.80381}, "CVE-2015-5989": {"epss_score": 0.03149, "epss_percentile": 0.86503}, "CVE-2015-5990": {"epss_score": 0.00091, "epss_percentile": 0.26262}, "CVE-2015-5991": {"epss_score": 0.00108, "epss_percentile": 0.29811}, "CVE-2015-5992": {"epss_score": 0.0067, "epss_percentile": 0.70785}, "CVE-2015-5993": {"epss_score": 0.01358, "epss_percentile": 0.79729}, "CVE-2015-5994": {"epss_score": 0.0023, "epss_percentile": 0.45726}, "CVE-2015-5995": {"epss_score": 0.38203, "epss_percentile": 0.97089}, "CVE-2015-5996": {"epss_score": 0.00181, "epss_percentile": 0.40114}, "CVE-2015-5997": {"epss_score": 0.00409, "epss_percentile": 0.60693}, "CVE-2015-5998": {"epss_score": 0.00531, "epss_percentile": 0.66646}, "CVE-2015-5999": {"epss_score": 0.16438, "epss_percentile": 0.94661}, "CVE-2015-6000": {"epss_score": 0.7742, "epss_percentile": 0.98936}, "CVE-2015-6003": {"epss_score": 0.02509, "epss_percentile": 0.84945}, "CVE-2015-6004": {"epss_score": 0.16898, "epss_percentile": 0.94745}, "CVE-2015-6005": {"epss_score": 0.00198, "epss_percentile": 0.42079}, "CVE-2015-6006": {"epss_score": 0.17814, "epss_percentile": 0.9491}, "CVE-2015-6007": {"epss_score": 0.00108, "epss_percentile": 0.29811}, "CVE-2015-6008": {"epss_score": 0.05706, "epss_percentile": 0.90137}, "CVE-2015-6009": {"epss_score": 0.01628, "epss_percentile": 0.81435}, "CVE-2015-6010": {"epss_score": 0.0067, "epss_percentile": 0.70785}, "CVE-2015-6011": {"epss_score": 0.00683, "epss_percentile": 0.71106}, "CVE-2015-6012": {"epss_score": 0.00368, "epss_percentile": 0.58211}, "CVE-2015-6013": {"epss_score": 0.19917, "epss_percentile": 0.9526}, "CVE-2015-6014": {"epss_score": 0.19917, "epss_percentile": 0.9526}, "CVE-2015-6015": {"epss_score": 0.19917, "epss_percentile": 0.9526}, "CVE-2015-6016": {"epss_score": 0.05574, "epss_percentile": 0.90011}, "CVE-2015-6017": {"epss_score": 0.00536, "epss_percentile": 0.66865}, "CVE-2015-6018": {"epss_score": 0.22079, "epss_percentile": 0.95592}, "CVE-2015-6019": {"epss_score": 0.00331, "epss_percentile": 0.55505}, "CVE-2015-6020": {"epss_score": 0.00213, "epss_percentile": 0.43924}, "CVE-2015-6021": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2015-6022": {"epss_score": 0.00686, "epss_percentile": 0.71168}, "CVE-2015-6023": {"epss_score": 0.05018, "epss_percentile": 0.89396}, "CVE-2015-6024": {"epss_score": 0.43101, "epss_percentile": 0.9737}, "CVE-2015-6027": {"epss_score": 0.00298, "epss_percentile": 0.52804}, "CVE-2015-6028": {"epss_score": 0.00212, "epss_percentile": 0.4376}, "CVE-2015-6029": {"epss_score": 0.15828, "epss_percentile": 0.94515}, "CVE-2015-6030": {"epss_score": 0.00975, "epss_percentile": 0.76202}, "CVE-2015-6031": {"epss_score": 0.0166, "epss_percentile": 0.81618}, "CVE-2015-6032": {"epss_score": 0.00833, "epss_percentile": 0.74082}, "CVE-2015-6033": {"epss_score": 0.00116, "epss_percentile": 0.31107}, "CVE-2015-6034": {"epss_score": 0.00073, "epss_percentile": 0.22583}, "CVE-2015-6035": {"epss_score": 0.00298, "epss_percentile": 0.52804}, "CVE-2015-6036": {"epss_score": 0.00299, "epss_percentile": 0.52903}, "CVE-2015-6037": {"epss_score": 0.12301, "epss_percentile": 0.93627}, "CVE-2015-6038": {"epss_score": 0.43481, "epss_percentile": 0.97389}, "CVE-2015-6039": {"epss_score": 0.07989, "epss_percentile": 0.91809}, "CVE-2015-6040": {"epss_score": 0.37547, "epss_percentile": 0.97056}, "CVE-2015-6042": {"epss_score": 0.25707, "epss_percentile": 0.96058}, "CVE-2015-6044": {"epss_score": 0.16238, "epss_percentile": 0.94599}, "CVE-2015-6045": {"epss_score": 0.34437, "epss_percentile": 0.96847}, "CVE-2015-6046": {"epss_score": 0.21101, "epss_percentile": 0.95463}, "CVE-2015-6047": {"epss_score": 0.13746, "epss_percentile": 0.94047}, "CVE-2015-6048": {"epss_score": 0.21881, "epss_percentile": 0.9557}, "CVE-2015-6049": {"epss_score": 0.21131, "epss_percentile": 0.95467}, "CVE-2015-6050": {"epss_score": 0.30101, "epss_percentile": 0.96511}, "CVE-2015-6051": {"epss_score": 0.11057, "epss_percentile": 0.93205}, "CVE-2015-6052": {"epss_score": 0.2143, "epss_percentile": 0.95516}, "CVE-2015-6053": {"epss_score": 0.27869, "epss_percentile": 0.96289}, "CVE-2015-6055": {"epss_score": 0.44437, "epss_percentile": 0.97436}, "CVE-2015-6056": {"epss_score": 0.30101, "epss_percentile": 0.96511}, "CVE-2015-6057": {"epss_score": 0.21101, "epss_percentile": 0.95463}, "CVE-2015-6058": {"epss_score": 0.18964, "epss_percentile": 0.95102}, "CVE-2015-6059": {"epss_score": 0.25225, "epss_percentile": 0.96001}, "CVE-2015-6061": {"epss_score": 0.14161, "epss_percentile": 0.94147}, "CVE-2015-6064": {"epss_score": 0.32615, "epss_percentile": 0.96712}, "CVE-2015-6065": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-6066": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-6068": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-6069": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-6070": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-6071": {"epss_score": 0.31793, "epss_percentile": 0.96649}, "CVE-2015-6072": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-6073": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-6074": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-6075": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-6076": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-6077": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-6078": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-6079": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-6080": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-6081": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-6082": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-6083": {"epss_score": 0.16463, "epss_percentile": 0.94669}, "CVE-2015-6084": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-6085": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2015-6086": {"epss_score": 0.61485, "epss_percentile": 0.9825}, "CVE-2015-6087": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-6088": {"epss_score": 0.1224, "epss_percentile": 0.93609}, "CVE-2015-6089": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-6091": {"epss_score": 0.28216, "epss_percentile": 0.96332}, "CVE-2015-6092": {"epss_score": 0.28216, "epss_percentile": 0.96332}, "CVE-2015-6093": {"epss_score": 0.42399, "epss_percentile": 0.9733}, "CVE-2015-6094": {"epss_score": 0.37167, "epss_percentile": 0.97025}, "CVE-2015-6095": {"epss_score": 0.04574, "epss_percentile": 0.88867}, "CVE-2015-6096": {"epss_score": 0.32946, "epss_percentile": 0.96738}, "CVE-2015-6097": {"epss_score": 0.3884, "epss_percentile": 0.97123}, "CVE-2015-6098": {"epss_score": 0.04385, "epss_percentile": 0.8863}, "CVE-2015-6099": {"epss_score": 0.32198, "epss_percentile": 0.96678}, "CVE-2015-6100": {"epss_score": 0.05762, "epss_percentile": 0.90184}, "CVE-2015-6101": {"epss_score": 0.23233, "epss_percentile": 0.95755}, "CVE-2015-6102": {"epss_score": 0.03818, "epss_percentile": 0.8777}, "CVE-2015-6103": {"epss_score": 0.54538, "epss_percentile": 0.97932}, "CVE-2015-6104": {"epss_score": 0.54538, "epss_percentile": 0.97932}, "CVE-2015-6106": {"epss_score": 0.44785, "epss_percentile": 0.97452}, "CVE-2015-6107": {"epss_score": 0.49407, "epss_percentile": 0.97684}, "CVE-2015-6108": {"epss_score": 0.44437, "epss_percentile": 0.97436}, "CVE-2015-6109": {"epss_score": 0.02141, "epss_percentile": 0.83749}, "CVE-2015-6111": {"epss_score": 0.01433, "epss_percentile": 0.8026}, "CVE-2015-6112": {"epss_score": 0.07352, "epss_percentile": 0.91426}, "CVE-2015-6113": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2015-6114": {"epss_score": 0.20041, "epss_percentile": 0.95279}, "CVE-2015-6115": {"epss_score": 0.17179, "epss_percentile": 0.94793}, "CVE-2015-6117": {"epss_score": 0.01472, "epss_percentile": 0.8051}, "CVE-2015-6118": {"epss_score": 0.34302, "epss_percentile": 0.9684}, "CVE-2015-6122": {"epss_score": 0.37547, "epss_percentile": 0.97056}, "CVE-2015-6123": {"epss_score": 0.12047, "epss_percentile": 0.93555}, "CVE-2015-6124": {"epss_score": 0.37547, "epss_percentile": 0.97056}, "CVE-2015-6125": {"epss_score": 0.59229, "epss_percentile": 0.98156}, "CVE-2015-6126": {"epss_score": 0.00604, "epss_percentile": 0.68953}, "CVE-2015-6127": {"epss_score": 0.72017, "epss_percentile": 0.98692}, "CVE-2015-6128": {"epss_score": 0.43967, "epss_percentile": 0.97411}, "CVE-2015-6130": {"epss_score": 0.29526, "epss_percentile": 0.9645}, "CVE-2015-6131": {"epss_score": 0.5917, "epss_percentile": 0.98153}, "CVE-2015-6132": {"epss_score": 0.74499, "epss_percentile": 0.98803}, "CVE-2015-6133": {"epss_score": 0.61218, "epss_percentile": 0.9824}, "CVE-2015-6134": {"epss_score": 0.16463, "epss_percentile": 0.94669}, "CVE-2015-6135": {"epss_score": 0.09865, "epss_percentile": 0.92743}, "CVE-2015-6136": {"epss_score": 0.44585, "epss_percentile": 0.97445}, "CVE-2015-6138": {"epss_score": 0.24024, "epss_percentile": 0.95845}, "CVE-2015-6139": {"epss_score": 0.16102, "epss_percentile": 0.94573}, "CVE-2015-6140": {"epss_score": 0.14833, "epss_percentile": 0.94299}, "CVE-2015-6141": {"epss_score": 0.16463, "epss_percentile": 0.94669}, "CVE-2015-6142": {"epss_score": 0.235, "epss_percentile": 0.95786}, "CVE-2015-6143": {"epss_score": 0.16463, "epss_percentile": 0.94669}, "CVE-2015-6144": {"epss_score": 0.2412, "epss_percentile": 0.95878}, "CVE-2015-6145": {"epss_score": 0.26026, "epss_percentile": 0.96101}, "CVE-2015-6146": {"epss_score": 0.26026, "epss_percentile": 0.96101}, "CVE-2015-6147": {"epss_score": 0.16463, "epss_percentile": 0.94669}, "CVE-2015-6148": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2015-6149": {"epss_score": 0.16463, "epss_percentile": 0.94669}, "CVE-2015-6150": {"epss_score": 0.16463, "epss_percentile": 0.94669}, "CVE-2015-6151": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-6152": {"epss_score": 0.1493, "epss_percentile": 0.94326}, "CVE-2015-6153": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-6154": {"epss_score": 0.14833, "epss_percentile": 0.94299}, "CVE-2015-6155": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-6156": {"epss_score": 0.26026, "epss_percentile": 0.96101}, "CVE-2015-6157": {"epss_score": 0.25225, "epss_percentile": 0.96001}, "CVE-2015-6158": {"epss_score": 0.1631, "epss_percentile": 0.94627}, "CVE-2015-6159": {"epss_score": 0.18901, "epss_percentile": 0.95094}, "CVE-2015-6160": {"epss_score": 0.16463, "epss_percentile": 0.94669}, "CVE-2015-6161": {"epss_score": 0.09956, "epss_percentile": 0.92793}, "CVE-2015-6162": {"epss_score": 0.28139, "epss_percentile": 0.96324}, "CVE-2015-6164": {"epss_score": 0.1787, "epss_percentile": 0.9492}, "CVE-2015-6165": {"epss_score": 0.20041, "epss_percentile": 0.95279}, "CVE-2015-6166": {"epss_score": 0.20537, "epss_percentile": 0.95374}, "CVE-2015-6168": {"epss_score": 0.32545, "epss_percentile": 0.96707}, "CVE-2015-6169": {"epss_score": 0.12507, "epss_percentile": 0.93701}, "CVE-2015-6170": {"epss_score": 0.16545, "epss_percentile": 0.94688}, "CVE-2015-6171": {"epss_score": 0.01411, "epss_percentile": 0.80112}, "CVE-2015-6172": {"epss_score": 0.32798, "epss_percentile": 0.96725}, "CVE-2015-6173": {"epss_score": 0.01411, "epss_percentile": 0.80112}, "CVE-2015-6174": {"epss_score": 0.01411, "epss_percentile": 0.80112}, "CVE-2015-6175": {"epss_score": 0.02917, "epss_percentile": 0.85984}, "CVE-2015-6176": {"epss_score": 0.04304, "epss_percentile": 0.88518}, "CVE-2015-6177": {"epss_score": 0.37547, "epss_percentile": 0.97056}, "CVE-2015-6184": {"epss_score": 0.49659, "epss_percentile": 0.97699}, "CVE-2015-6237": {"epss_score": 0.00582, "epss_percentile": 0.68294}, "CVE-2015-6238": {"epss_score": 0.00288, "epss_percentile": 0.51949}, "CVE-2015-6240": {"epss_score": 0.00029, "epss_percentile": 0.07728}, "CVE-2015-6241": {"epss_score": 0.00569, "epss_percentile": 0.67927}, "CVE-2015-6242": {"epss_score": 0.00569, "epss_percentile": 0.67927}, "CVE-2015-6243": {"epss_score": 0.00661, "epss_percentile": 0.70566}, "CVE-2015-6244": {"epss_score": 0.00803, "epss_percentile": 0.73604}, "CVE-2015-6245": {"epss_score": 0.00378, "epss_percentile": 0.58815}, "CVE-2015-6246": {"epss_score": 0.00661, "epss_percentile": 0.70566}, "CVE-2015-6247": {"epss_score": 0.00569, "epss_percentile": 0.67927}, "CVE-2015-6248": {"epss_score": 0.00679, "epss_percentile": 0.71014}, "CVE-2015-6249": {"epss_score": 0.00569, "epss_percentile": 0.67927}, "CVE-2015-6250": {"epss_score": 0.00248, "epss_percentile": 0.47941}, "CVE-2015-6251": {"epss_score": 0.06692, "epss_percentile": 0.90951}, "CVE-2015-6252": {"epss_score": 0.00087, "epss_percentile": 0.25495}, "CVE-2015-6253": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2015-6254": {"epss_score": 0.00697, "epss_percentile": 0.71408}, "CVE-2015-6255": {"epss_score": 0.00453, "epss_percentile": 0.63214}, "CVE-2015-6256": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-6258": {"epss_score": 0.00213, "epss_percentile": 0.4384}, "CVE-2015-6259": {"epss_score": 0.01714, "epss_percentile": 0.81893}, "CVE-2015-6260": {"epss_score": 0.0037, "epss_percentile": 0.58312}, "CVE-2015-6261": {"epss_score": 0.0015, "epss_percentile": 0.36145}, "CVE-2015-6262": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-6263": {"epss_score": 0.00302, "epss_percentile": 0.531}, "CVE-2015-6265": {"epss_score": 0.0028, "epss_percentile": 0.51076}, "CVE-2015-6266": {"epss_score": 0.0023, "epss_percentile": 0.45735}, "CVE-2015-6267": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-6268": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-6269": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-6270": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-6271": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-6272": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-6273": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-6274": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2015-6276": {"epss_score": 0.00168, "epss_percentile": 0.38427}, "CVE-2015-6277": {"epss_score": 0.00397, "epss_percentile": 0.59934}, "CVE-2015-6278": {"epss_score": 0.00581, "epss_percentile": 0.68273}, "CVE-2015-6279": {"epss_score": 0.00581, "epss_percentile": 0.68273}, "CVE-2015-6280": {"epss_score": 0.01165, "epss_percentile": 0.78178}, "CVE-2015-6282": {"epss_score": 0.00411, "epss_percentile": 0.60856}, "CVE-2015-6284": {"epss_score": 0.00448, "epss_percentile": 0.63009}, "CVE-2015-6285": {"epss_score": 0.00442, "epss_percentile": 0.62745}, "CVE-2015-6286": {"epss_score": 0.0017, "epss_percentile": 0.38729}, "CVE-2015-6287": {"epss_score": 0.00724, "epss_percentile": 0.72043}, "CVE-2015-6288": {"epss_score": 0.00712, "epss_percentile": 0.71755}, "CVE-2015-6289": {"epss_score": 0.11655, "epss_percentile": 0.93435}, "CVE-2015-6290": {"epss_score": 0.00479, "epss_percentile": 0.64445}, "CVE-2015-6291": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2015-6292": {"epss_score": 0.00887, "epss_percentile": 0.74992}, "CVE-2015-6293": {"epss_score": 0.00887, "epss_percentile": 0.74992}, "CVE-2015-6294": {"epss_score": 0.00262, "epss_percentile": 0.49399}, "CVE-2015-6295": {"epss_score": 0.00647, "epss_percentile": 0.70199}, "CVE-2015-6296": {"epss_score": 0.00093, "epss_percentile": 0.26693}, "CVE-2015-6297": {"epss_score": 0.00421, "epss_percentile": 0.61511}, "CVE-2015-6298": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-6299": {"epss_score": 0.00287, "epss_percentile": 0.5181}, "CVE-2015-6300": {"epss_score": 0.00388, "epss_percentile": 0.59357}, "CVE-2015-6301": {"epss_score": 0.00572, "epss_percentile": 0.68009}, "CVE-2015-6302": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-6303": {"epss_score": 0.00141, "epss_percentile": 0.34921}, "CVE-2015-6304": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2015-6305": {"epss_score": 0.01961, "epss_percentile": 0.8306}, "CVE-2015-6306": {"epss_score": 0.03548, "epss_percentile": 0.87333}, "CVE-2015-6307": {"epss_score": 0.00098, "epss_percentile": 0.27724}, "CVE-2015-6308": {"epss_score": 0.00388, "epss_percentile": 0.59357}, "CVE-2015-6309": {"epss_score": 0.00309, "epss_percentile": 0.53698}, "CVE-2015-6310": {"epss_score": 0.00712, "epss_percentile": 0.71755}, "CVE-2015-6311": {"epss_score": 0.00262, "epss_percentile": 0.49399}, "CVE-2015-6312": {"epss_score": 0.00607, "epss_percentile": 0.69045}, "CVE-2015-6313": {"epss_score": 0.00326, "epss_percentile": 0.55051}, "CVE-2015-6314": {"epss_score": 0.01066, "epss_percentile": 0.7722}, "CVE-2015-6315": {"epss_score": 0.00093, "epss_percentile": 0.26693}, "CVE-2015-6316": {"epss_score": 0.00713, "epss_percentile": 0.71794}, "CVE-2015-6317": {"epss_score": 0.00139, "epss_percentile": 0.34656}, "CVE-2015-6318": {"epss_score": 0.00093, "epss_percentile": 0.26693}, "CVE-2015-6319": {"epss_score": 0.00807, "epss_percentile": 0.73671}, "CVE-2015-6320": {"epss_score": 0.00527, "epss_percentile": 0.66472}, "CVE-2015-6321": {"epss_score": 0.01001, "epss_percentile": 0.76496}, "CVE-2015-6322": {"epss_score": 0.00093, "epss_percentile": 0.26693}, "CVE-2015-6323": {"epss_score": 0.01486, "epss_percentile": 0.80602}, "CVE-2015-6324": {"epss_score": 0.00284, "epss_percentile": 0.51497}, "CVE-2015-6325": {"epss_score": 0.00679, "epss_percentile": 0.71018}, "CVE-2015-6326": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-6327": {"epss_score": 0.00411, "epss_percentile": 0.60856}, "CVE-2015-6328": {"epss_score": 0.00171, "epss_percentile": 0.38888}, "CVE-2015-6329": {"epss_score": 0.00299, "epss_percentile": 0.52897}, "CVE-2015-6330": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2015-6331": {"epss_score": 0.00287, "epss_percentile": 0.5181}, "CVE-2015-6332": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-6333": {"epss_score": 0.00085, "epss_percentile": 0.2515}, "CVE-2015-6334": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-6335": {"epss_score": 0.00342, "epss_percentile": 0.56371}, "CVE-2015-6336": {"epss_score": 0.00447, "epss_percentile": 0.62983}, "CVE-2015-6337": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2015-6340": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-6341": {"epss_score": 0.00437, "epss_percentile": 0.62496}, "CVE-2015-6343": {"epss_score": 0.00677, "epss_percentile": 0.70955}, "CVE-2015-6344": {"epss_score": 0.00156, "epss_percentile": 0.36988}, "CVE-2015-6345": {"epss_score": 0.00311, "epss_percentile": 0.5386}, "CVE-2015-6346": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-6347": {"epss_score": 0.00135, "epss_percentile": 0.33938}, "CVE-2015-6348": {"epss_score": 0.00156, "epss_percentile": 0.36988}, "CVE-2015-6349": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-6350": {"epss_score": 0.00287, "epss_percentile": 0.51788}, "CVE-2015-6351": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2015-6352": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2015-6353": {"epss_score": 0.00283, "epss_percentile": 0.51382}, "CVE-2015-6354": {"epss_score": 0.00283, "epss_percentile": 0.51382}, "CVE-2015-6355": {"epss_score": 0.00469, "epss_percentile": 0.6394}, "CVE-2015-6356": {"epss_score": 0.00402, "epss_percentile": 0.60288}, "CVE-2015-6357": {"epss_score": 0.05935, "epss_percentile": 0.9034}, "CVE-2015-6358": {"epss_score": 0.01998, "epss_percentile": 0.83209}, "CVE-2015-6359": {"epss_score": 0.00246, "epss_percentile": 0.47745}, "CVE-2015-6360": {"epss_score": 0.18485, "epss_percentile": 0.95022}, "CVE-2015-6361": {"epss_score": 0.00526, "epss_percentile": 0.66429}, "CVE-2015-6362": {"epss_score": 0.00111, "epss_percentile": 0.30317}, "CVE-2015-6363": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2015-6364": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2015-6365": {"epss_score": 0.00183, "epss_percentile": 0.40304}, "CVE-2015-6366": {"epss_score": 0.00365, "epss_percentile": 0.57998}, "CVE-2015-6367": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-6368": {"epss_score": 0.00084, "epss_percentile": 0.25026}, "CVE-2015-6369": {"epss_score": 0.00097, "epss_percentile": 0.27536}, "CVE-2015-6370": {"epss_score": 0.00317, "epss_percentile": 0.54312}, "CVE-2015-6371": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2015-6372": {"epss_score": 0.00296, "epss_percentile": 0.52563}, "CVE-2015-6373": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2015-6374": {"epss_score": 0.00217, "epss_percentile": 0.44296}, "CVE-2015-6375": {"epss_score": 0.00064, "epss_percentile": 0.20255}, "CVE-2015-6376": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2015-6377": {"epss_score": 0.03552, "epss_percentile": 0.87344}, "CVE-2015-6378": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2015-6379": {"epss_score": 0.00785, "epss_percentile": 0.73262}, "CVE-2015-6380": {"epss_score": 0.00447, "epss_percentile": 0.6298}, "CVE-2015-6382": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2015-6383": {"epss_score": 0.00088, "epss_percentile": 0.2574}, "CVE-2015-6384": {"epss_score": 0.00244, "epss_percentile": 0.4755}, "CVE-2015-6385": {"epss_score": 0.00057, "epss_percentile": 0.18182}, "CVE-2015-6386": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2015-6387": {"epss_score": 0.00402, "epss_percentile": 0.60288}, "CVE-2015-6388": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2015-6389": {"epss_score": 0.00554, "epss_percentile": 0.67444}, "CVE-2015-6390": {"epss_score": 0.00402, "epss_percentile": 0.60288}, "CVE-2015-6391": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2015-6392": {"epss_score": 0.01338, "epss_percentile": 0.79568}, "CVE-2015-6393": {"epss_score": 0.00989, "epss_percentile": 0.76359}, "CVE-2015-6394": {"epss_score": 0.00086, "epss_percentile": 0.25387}, "CVE-2015-6395": {"epss_score": 0.0036, "epss_percentile": 0.57686}, "CVE-2015-6396": {"epss_score": 0.02368, "epss_percentile": 0.8452}, "CVE-2015-6397": {"epss_score": 0.0119, "epss_percentile": 0.78391}, "CVE-2015-6398": {"epss_score": 0.00607, "epss_percentile": 0.69045}, "CVE-2015-6399": {"epss_score": 0.00659, "epss_percentile": 0.705}, "CVE-2015-6400": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-6401": {"epss_score": 0.07873, "epss_percentile": 0.91737}, "CVE-2015-6402": {"epss_score": 0.3427, "epss_percentile": 0.96837}, "CVE-2015-6403": {"epss_score": 0.00091, "epss_percentile": 0.2627}, "CVE-2015-6404": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2015-6405": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-6406": {"epss_score": 0.00425, "epss_percentile": 0.61712}, "CVE-2015-6407": {"epss_score": 0.00193, "epss_percentile": 0.41427}, "CVE-2015-6408": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2015-6409": {"epss_score": 0.00258, "epss_percentile": 0.48986}, "CVE-2015-6410": {"epss_score": 0.00176, "epss_percentile": 0.39487}, "CVE-2015-6411": {"epss_score": 0.00509, "epss_percentile": 0.65742}, "CVE-2015-6412": {"epss_score": 0.0194, "epss_percentile": 0.82977}, "CVE-2015-6413": {"epss_score": 0.0017, "epss_percentile": 0.38737}, "CVE-2015-6414": {"epss_score": 0.00039, "epss_percentile": 0.11464}, "CVE-2015-6415": {"epss_score": 0.00563, "epss_percentile": 0.67723}, "CVE-2015-6416": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-6417": {"epss_score": 0.00093, "epss_percentile": 0.26675}, "CVE-2015-6418": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2015-6419": {"epss_score": 0.00224, "epss_percentile": 0.45016}, "CVE-2015-6420": {"epss_score": 0.1651, "epss_percentile": 0.94681}, "CVE-2015-6421": {"epss_score": 0.00527, "epss_percentile": 0.66472}, "CVE-2015-6422": {"epss_score": 0.00455, "epss_percentile": 0.63299}, "CVE-2015-6423": {"epss_score": 0.00153, "epss_percentile": 0.36571}, "CVE-2015-6424": {"epss_score": 0.00091, "epss_percentile": 0.2627}, "CVE-2015-6425": {"epss_score": 0.00492, "epss_percentile": 0.65024}, "CVE-2015-6426": {"epss_score": 0.00112, "epss_percentile": 0.30423}, "CVE-2015-6427": {"epss_score": 0.00397, "epss_percentile": 0.59967}, "CVE-2015-6428": {"epss_score": 0.00102, "epss_percentile": 0.2887}, "CVE-2015-6429": {"epss_score": 0.00474, "epss_percentile": 0.64136}, "CVE-2015-6431": {"epss_score": 0.00304, "epss_percentile": 0.53247}, "CVE-2015-6432": {"epss_score": 0.00895, "epss_percentile": 0.75109}, "CVE-2015-6433": {"epss_score": 0.00163, "epss_percentile": 0.37809}, "CVE-2015-6434": {"epss_score": 0.00243, "epss_percentile": 0.47458}, "CVE-2015-6435": {"epss_score": 0.16005, "epss_percentile": 0.94553}, "CVE-2015-6454": {"epss_score": 0.00814, "epss_percentile": 0.73767}, "CVE-2015-6456": {"epss_score": 0.01506, "epss_percentile": 0.80746}, "CVE-2015-6457": {"epss_score": 0.01212, "epss_percentile": 0.78559}, "CVE-2015-6458": {"epss_score": 0.01212, "epss_percentile": 0.78559}, "CVE-2015-6459": {"epss_score": 0.01166, "epss_percentile": 0.78184}, "CVE-2015-6460": {"epss_score": 0.08638, "epss_percentile": 0.92166}, "CVE-2015-6461": {"epss_score": 0.00185, "epss_percentile": 0.40573}, "CVE-2015-6462": {"epss_score": 0.00583, "epss_percentile": 0.68346}, "CVE-2015-6463": {"epss_score": 0.00126, "epss_percentile": 0.32667}, "CVE-2015-6464": {"epss_score": 0.00182, "epss_percentile": 0.40199}, "CVE-2015-6465": {"epss_score": 0.01147, "epss_percentile": 0.78006}, "CVE-2015-6466": {"epss_score": 0.01067, "epss_percentile": 0.77232}, "CVE-2015-6467": {"epss_score": 0.0082, "epss_percentile": 0.73881}, "CVE-2015-6468": {"epss_score": 0.00072, "epss_percentile": 0.22348}, "CVE-2015-6469": {"epss_score": 0.00392, "epss_percentile": 0.59701}, "CVE-2015-6470": {"epss_score": 0.00198, "epss_percentile": 0.42011}, "CVE-2015-6471": {"epss_score": 0.00324, "epss_percentile": 0.54943}, "CVE-2015-6472": {"epss_score": 0.0127, "epss_percentile": 0.79045}, "CVE-2015-6473": {"epss_score": 0.02913, "epss_percentile": 0.85975}, "CVE-2015-6474": {"epss_score": 0.00392, "epss_percentile": 0.59701}, "CVE-2015-6475": {"epss_score": 0.00394, "epss_percentile": 0.59759}, "CVE-2015-6476": {"epss_score": 0.00283, "epss_percentile": 0.51354}, "CVE-2015-6477": {"epss_score": 0.40551, "epss_percentile": 0.97222}, "CVE-2015-6478": {"epss_score": 0.02599, "epss_percentile": 0.85203}, "CVE-2015-6479": {"epss_score": 0.00025, "epss_percentile": 0.06206}, "CVE-2015-6480": {"epss_score": 0.00246, "epss_percentile": 0.47734}, "CVE-2015-6481": {"epss_score": 0.00246, "epss_percentile": 0.47743}, "CVE-2015-6482": {"epss_score": 0.0031, "epss_percentile": 0.53784}, "CVE-2015-6484": {"epss_score": 0.00545, "epss_percentile": 0.67166}, "CVE-2015-6485": {"epss_score": 0.00417, "epss_percentile": 0.61238}, "CVE-2015-6486": {"epss_score": 0.00048, "epss_percentile": 0.14987}, "CVE-2015-6488": {"epss_score": 0.0028, "epss_percentile": 0.51017}, "CVE-2015-6490": {"epss_score": 0.00915, "epss_percentile": 0.75398}, "CVE-2015-6491": {"epss_score": 0.00441, "epss_percentile": 0.62681}, "CVE-2015-6492": {"epss_score": 0.09566, "epss_percentile": 0.92603}, "CVE-2015-6493": {"epss_score": 0.00319, "epss_percentile": 0.54546}, "CVE-2015-6494": {"epss_score": 0.00963, "epss_percentile": 0.76014}, "CVE-2015-6495": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2015-6496": {"epss_score": 0.02789, "epss_percentile": 0.85662}, "CVE-2015-6497": {"epss_score": 0.02665, "epss_percentile": 0.85376}, "CVE-2015-6498": {"epss_score": 0.0089, "epss_percentile": 0.75029}, "CVE-2015-6500": {"epss_score": 0.00904, "epss_percentile": 0.75229}, "CVE-2015-6501": {"epss_score": 0.00189, "epss_percentile": 0.40975}, "CVE-2015-6502": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2015-6506": {"epss_score": 0.00442, "epss_percentile": 0.62719}, "CVE-2015-6507": {"epss_score": 0.00055, "epss_percentile": 0.17582}, "CVE-2015-6508": {"epss_score": 0.01297, "epss_percentile": 0.79261}, "CVE-2015-6509": {"epss_score": 0.00087, "epss_percentile": 0.25493}, "CVE-2015-6510": {"epss_score": 0.00087, "epss_percentile": 0.25493}, "CVE-2015-6511": {"epss_score": 0.00087, "epss_percentile": 0.25493}, "CVE-2015-6512": {"epss_score": 0.02208, "epss_percentile": 0.84009}, "CVE-2015-6513": {"epss_score": 0.0042, "epss_percentile": 0.61421}, "CVE-2015-6514": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-6515": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-6516": {"epss_score": 0.00791, "epss_percentile": 0.73385}, "CVE-2015-6517": {"epss_score": 0.003, "epss_percentile": 0.52911}, "CVE-2015-6518": {"epss_score": 0.01204, "epss_percentile": 0.78508}, "CVE-2015-6519": {"epss_score": 0.01978, "epss_percentile": 0.83129}, "CVE-2015-6520": {"epss_score": 0.00821, "epss_percentile": 0.73898}, "CVE-2015-6521": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2015-6522": {"epss_score": 0.78195, "epss_percentile": 0.98973}, "CVE-2015-6523": {"epss_score": 0.00137, "epss_percentile": 0.34237}, "CVE-2015-6524": {"epss_score": 0.01167, "epss_percentile": 0.78188}, "CVE-2015-6525": {"epss_score": 0.0107, "epss_percentile": 0.77257}, "CVE-2015-6526": {"epss_score": 0.00042, "epss_percentile": 0.12922}, "CVE-2015-6527": {"epss_score": 0.02621, "epss_percentile": 0.85255}, "CVE-2015-6528": {"epss_score": 0.0021, "epss_percentile": 0.43482}, "CVE-2015-6529": {"epss_score": 0.00288, "epss_percentile": 0.51937}, "CVE-2015-6530": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2015-6531": {"epss_score": 0.0096, "epss_percentile": 0.75968}, "CVE-2015-6535": {"epss_score": 0.00501, "epss_percentile": 0.65362}, "CVE-2015-6537": {"epss_score": 0.00569, "epss_percentile": 0.67923}, "CVE-2015-6538": {"epss_score": 0.00209, "epss_percentile": 0.43371}, "CVE-2015-6540": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2015-6541": {"epss_score": 0.00267, "epss_percentile": 0.49957}, "CVE-2015-6544": {"epss_score": 0.3629, "epss_percentile": 0.96966}, "CVE-2015-6545": {"epss_score": 0.05095, "epss_percentile": 0.8949}, "CVE-2015-6546": {"epss_score": 0.00322, "epss_percentile": 0.54755}, "CVE-2015-6547": {"epss_score": 0.03261, "epss_percentile": 0.86772}, "CVE-2015-6548": {"epss_score": 0.00575, "epss_percentile": 0.68118}, "CVE-2015-6549": {"epss_score": 0.0047, "epss_percentile": 0.63968}, "CVE-2015-6550": {"epss_score": 0.03012, "epss_percentile": 0.862}, "CVE-2015-6551": {"epss_score": 0.00297, "epss_percentile": 0.5277}, "CVE-2015-6552": {"epss_score": 0.02162, "epss_percentile": 0.83829}, "CVE-2015-6554": {"epss_score": 0.01703, "epss_percentile": 0.81842}, "CVE-2015-6555": {"epss_score": 0.01552, "epss_percentile": 0.80992}, "CVE-2015-6556": {"epss_score": 0.00225, "epss_percentile": 0.45236}, "CVE-2015-6557": {"epss_score": 0.00049, "epss_percentile": 0.15622}, "CVE-2015-6563": {"epss_score": 0.00093, "epss_percentile": 0.26621}, "CVE-2015-6564": {"epss_score": 0.02076, "epss_percentile": 0.83512}, "CVE-2015-6565": {"epss_score": 0.00344, "epss_percentile": 0.5652}, "CVE-2015-6566": {"epss_score": 0.00037, "epss_percentile": 0.10886}, "CVE-2015-6567": {"epss_score": 0.14309, "epss_percentile": 0.94185}, "CVE-2015-6568": {"epss_score": 0.11862, "epss_percentile": 0.93498}, "CVE-2015-6569": {"epss_score": 0.00514, "epss_percentile": 0.65941}, "CVE-2015-6574": {"epss_score": 0.01028, "epss_percentile": 0.76824}, "CVE-2015-6575": {"epss_score": 0.18585, "epss_percentile": 0.95037}, "CVE-2015-6576": {"epss_score": 0.02273, "epss_percentile": 0.8422}, "CVE-2015-6580": {"epss_score": 0.00113, "epss_percentile": 0.30652}, "CVE-2015-6581": {"epss_score": 0.02349, "epss_percentile": 0.84466}, "CVE-2015-6582": {"epss_score": 0.00765, "epss_percentile": 0.72925}, "CVE-2015-6583": {"epss_score": 0.00354, "epss_percentile": 0.57213}, "CVE-2015-6584": {"epss_score": 0.00238, "epss_percentile": 0.46769}, "CVE-2015-6585": {"epss_score": 0.01813, "epss_percentile": 0.82376}, "CVE-2015-6586": {"epss_score": 0.00138, "epss_percentile": 0.34379}, "CVE-2015-6587": {"epss_score": 0.00625, "epss_percentile": 0.69585}, "CVE-2015-6588": {"epss_score": 0.00196, "epss_percentile": 0.41807}, "CVE-2015-6589": {"epss_score": 0.13155, "epss_percentile": 0.93886}, "CVE-2015-6591": {"epss_score": 0.00059, "epss_percentile": 0.18878}, "CVE-2015-6592": {"epss_score": 0.00101, "epss_percentile": 0.28641}, "CVE-2015-6596": {"epss_score": 0.00207, "epss_percentile": 0.43117}, "CVE-2015-6598": {"epss_score": 0.01402, "epss_percentile": 0.80012}, "CVE-2015-6599": {"epss_score": 0.01467, "epss_percentile": 0.80472}, "CVE-2015-6600": {"epss_score": 0.01467, "epss_percentile": 0.80472}, "CVE-2015-6601": {"epss_score": 0.01467, "epss_percentile": 0.80472}, "CVE-2015-6602": {"epss_score": 0.01766, "epss_percentile": 0.8217}, "CVE-2015-6603": {"epss_score": 0.03758, "epss_percentile": 0.87685}, "CVE-2015-6604": {"epss_score": 0.04944, "epss_percentile": 0.89312}, "CVE-2015-6605": {"epss_score": 0.001, "epss_percentile": 0.28536}, "CVE-2015-6606": {"epss_score": 0.00889, "epss_percentile": 0.75024}, "CVE-2015-6607": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2015-6608": {"epss_score": 0.03752, "epss_percentile": 0.87676}, "CVE-2015-6609": {"epss_score": 0.05925, "epss_percentile": 0.90326}, "CVE-2015-6610": {"epss_score": 0.00212, "epss_percentile": 0.43723}, "CVE-2015-6611": {"epss_score": 0.00106, "epss_percentile": 0.29436}, "CVE-2015-6612": {"epss_score": 0.07723, "epss_percentile": 0.91644}, "CVE-2015-6613": {"epss_score": 0.00141, "epss_percentile": 0.34864}, "CVE-2015-6614": {"epss_score": 0.0005, "epss_percentile": 0.15903}, "CVE-2015-6616": {"epss_score": 0.01816, "epss_percentile": 0.82394}, "CVE-2015-6617": {"epss_score": 0.00934, "epss_percentile": 0.75654}, "CVE-2015-6618": {"epss_score": 0.00161, "epss_percentile": 0.3752}, "CVE-2015-6619": {"epss_score": 0.00147, "epss_percentile": 0.35704}, "CVE-2015-6620": {"epss_score": 0.12567, "epss_percentile": 0.93718}, "CVE-2015-6621": {"epss_score": 0.00157, "epss_percentile": 0.37132}, "CVE-2015-6622": {"epss_score": 0.001, "epss_percentile": 0.28536}, "CVE-2015-6623": {"epss_score": 0.00157, "epss_percentile": 0.37132}, "CVE-2015-6624": {"epss_score": 0.001, "epss_percentile": 0.28536}, "CVE-2015-6625": {"epss_score": 0.001, "epss_percentile": 0.28536}, "CVE-2015-6626": {"epss_score": 0.0012, "epss_percentile": 0.31747}, "CVE-2015-6627": {"epss_score": 0.00163, "epss_percentile": 0.37863}, "CVE-2015-6628": {"epss_score": 0.001, "epss_percentile": 0.28536}, "CVE-2015-6629": {"epss_score": 0.001, "epss_percentile": 0.28536}, "CVE-2015-6630": {"epss_score": 0.001, "epss_percentile": 0.28536}, "CVE-2015-6631": {"epss_score": 0.00143, "epss_percentile": 0.35211}, "CVE-2015-6632": {"epss_score": 0.0012, "epss_percentile": 0.31747}, "CVE-2015-6633": {"epss_score": 0.00688, "epss_percentile": 0.71208}, "CVE-2015-6634": {"epss_score": 0.00933, "epss_percentile": 0.75635}, "CVE-2015-6636": {"epss_score": 0.01215, "epss_percentile": 0.78588}, "CVE-2015-6637": {"epss_score": 0.00068, "epss_percentile": 0.21312}, "CVE-2015-6638": {"epss_score": 0.00043, "epss_percentile": 0.12997}, "CVE-2015-6639": {"epss_score": 0.07464, "epss_percentile": 0.91487}, "CVE-2015-6640": {"epss_score": 0.00105, "epss_percentile": 0.29355}, "CVE-2015-6641": {"epss_score": 0.00065, "epss_percentile": 0.20656}, "CVE-2015-6642": {"epss_score": 0.00138, "epss_percentile": 0.34347}, "CVE-2015-6643": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2015-6644": {"epss_score": 0.00184, "epss_percentile": 0.40375}, "CVE-2015-6645": {"epss_score": 0.0005, "epss_percentile": 0.15755}, "CVE-2015-6646": {"epss_score": 0.001, "epss_percentile": 0.28529}, "CVE-2015-6647": {"epss_score": 0.00172, "epss_percentile": 0.3897}, "CVE-2015-6654": {"epss_score": 0.00047, "epss_percentile": 0.14836}, "CVE-2015-6655": {"epss_score": 0.00219, "epss_percentile": 0.44447}, "CVE-2015-6658": {"epss_score": 0.00762, "epss_percentile": 0.72845}, "CVE-2015-6659": {"epss_score": 0.14455, "epss_percentile": 0.94215}, "CVE-2015-6660": {"epss_score": 0.00489, "epss_percentile": 0.64901}, "CVE-2015-6661": {"epss_score": 0.00813, "epss_percentile": 0.73759}, "CVE-2015-6662": {"epss_score": 0.00639, "epss_percentile": 0.69942}, "CVE-2015-6663": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2015-6664": {"epss_score": 0.00639, "epss_percentile": 0.69942}, "CVE-2015-6665": {"epss_score": 0.0082, "epss_percentile": 0.73893}, "CVE-2015-6668": {"epss_score": 0.83973, "epss_percentile": 0.99268}, "CVE-2015-6670": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2015-6671": {"epss_score": 0.00256, "epss_percentile": 0.48802}, "CVE-2015-6672": {"epss_score": 0.00293, "epss_percentile": 0.52338}, "CVE-2015-6673": {"epss_score": 0.0134, "epss_percentile": 0.79581}, "CVE-2015-6674": {"epss_score": 0.01604, "epss_percentile": 0.8128}, "CVE-2015-6675": {"epss_score": 0.00145, "epss_percentile": 0.35484}, "CVE-2015-6676": {"epss_score": 0.02699, "epss_percentile": 0.8545}, "CVE-2015-6677": {"epss_score": 0.06367, "epss_percentile": 0.90703}, "CVE-2015-6678": {"epss_score": 0.02752, "epss_percentile": 0.85586}, "CVE-2015-6679": {"epss_score": 0.03491, "epss_percentile": 0.87232}, "CVE-2015-6680": {"epss_score": 0.09402, "epss_percentile": 0.92532}, "CVE-2015-6681": {"epss_score": 0.02565, "epss_percentile": 0.85114}, "CVE-2015-6682": {"epss_score": 0.01661, "epss_percentile": 0.81624}, "CVE-2015-6683": {"epss_score": 0.02877, "epss_percentile": 0.85887}, "CVE-2015-6684": {"epss_score": 0.02304, "epss_percentile": 0.84318}, "CVE-2015-6685": {"epss_score": 0.00838, "epss_percentile": 0.7417}, "CVE-2015-6686": {"epss_score": 0.00838, "epss_percentile": 0.7417}, "CVE-2015-6687": {"epss_score": 0.02518, "epss_percentile": 0.84994}, "CVE-2015-6688": {"epss_score": 0.01298, "epss_percentile": 0.79277}, "CVE-2015-6689": {"epss_score": 0.01298, "epss_percentile": 0.79277}, "CVE-2015-6690": {"epss_score": 0.01298, "epss_percentile": 0.79277}, "CVE-2015-6691": {"epss_score": 0.02518, "epss_percentile": 0.84994}, "CVE-2015-6692": {"epss_score": 0.0229, "epss_percentile": 0.84282}, "CVE-2015-6693": {"epss_score": 0.00838, "epss_percentile": 0.7417}, "CVE-2015-6694": {"epss_score": 0.00838, "epss_percentile": 0.7417}, "CVE-2015-6695": {"epss_score": 0.00838, "epss_percentile": 0.7417}, "CVE-2015-6696": {"epss_score": 0.01504, "epss_percentile": 0.80738}, "CVE-2015-6697": {"epss_score": 0.01689, "epss_percentile": 0.81772}, "CVE-2015-6698": {"epss_score": 0.01504, "epss_percentile": 0.80738}, "CVE-2015-6699": {"epss_score": 0.02101, "epss_percentile": 0.83603}, "CVE-2015-6700": {"epss_score": 0.02101, "epss_percentile": 0.83603}, "CVE-2015-6701": {"epss_score": 0.02101, "epss_percentile": 0.83603}, "CVE-2015-6702": {"epss_score": 0.02101, "epss_percentile": 0.83603}, "CVE-2015-6703": {"epss_score": 0.02101, "epss_percentile": 0.83603}, "CVE-2015-6704": {"epss_score": 0.02101, "epss_percentile": 0.83603}, "CVE-2015-6705": {"epss_score": 0.02138, "epss_percentile": 0.83735}, "CVE-2015-6706": {"epss_score": 0.02138, "epss_percentile": 0.83735}, "CVE-2015-6707": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6708": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6709": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6710": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6711": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6712": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6713": {"epss_score": 0.01522, "epss_percentile": 0.80836}, "CVE-2015-6714": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6715": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6716": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6717": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6718": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6719": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6720": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6721": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6722": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6723": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6724": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6725": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-6727": {"epss_score": 0.00407, "epss_percentile": 0.60584}, "CVE-2015-6728": {"epss_score": 0.00158, "epss_percentile": 0.37196}, "CVE-2015-6729": {"epss_score": 0.00281, "epss_percentile": 0.51126}, "CVE-2015-6730": {"epss_score": 0.00281, "epss_percentile": 0.51126}, "CVE-2015-6731": {"epss_score": 0.00475, "epss_percentile": 0.6424}, "CVE-2015-6732": {"epss_score": 0.0065, "epss_percentile": 0.70258}, "CVE-2015-6733": {"epss_score": 0.01485, "epss_percentile": 0.806}, "CVE-2015-6734": {"epss_score": 0.00281, "epss_percentile": 0.51126}, "CVE-2015-6735": {"epss_score": 0.01612, "epss_percentile": 0.81332}, "CVE-2015-6736": {"epss_score": 0.01612, "epss_percentile": 0.81332}, "CVE-2015-6737": {"epss_score": 0.00407, "epss_percentile": 0.60604}, "CVE-2015-6742": {"epss_score": 0.00191, "epss_percentile": 0.41201}, "CVE-2015-6743": {"epss_score": 0.00191, "epss_percentile": 0.41201}, "CVE-2015-6744": {"epss_score": 0.00443, "epss_percentile": 0.62783}, "CVE-2015-6745": {"epss_score": 0.00052, "epss_percentile": 0.16352}, "CVE-2015-6746": {"epss_score": 0.0012, "epss_percentile": 0.31762}, "CVE-2015-6747": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2015-6748": {"epss_score": 0.02044, "epss_percentile": 0.8338}, "CVE-2015-6749": {"epss_score": 0.0252, "epss_percentile": 0.85002}, "CVE-2015-6750": {"epss_score": 0.06072, "epss_percentile": 0.90453}, "CVE-2015-6751": {"epss_score": 0.00158, "epss_percentile": 0.37221}, "CVE-2015-6752": {"epss_score": 0.0014, "epss_percentile": 0.34736}, "CVE-2015-6753": {"epss_score": 0.0014, "epss_percentile": 0.34736}, "CVE-2015-6754": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2015-6755": {"epss_score": 0.01042, "epss_percentile": 0.76977}, "CVE-2015-6756": {"epss_score": 0.00964, "epss_percentile": 0.76024}, "CVE-2015-6757": {"epss_score": 0.01583, "epss_percentile": 0.81145}, "CVE-2015-6758": {"epss_score": 0.00964, "epss_percentile": 0.76024}, "CVE-2015-6759": {"epss_score": 0.00803, "epss_percentile": 0.73596}, "CVE-2015-6760": {"epss_score": 0.0103, "epss_percentile": 0.76837}, "CVE-2015-6761": {"epss_score": 0.01459, "epss_percentile": 0.8041}, "CVE-2015-6762": {"epss_score": 0.00699, "epss_percentile": 0.71432}, "CVE-2015-6763": {"epss_score": 0.09224, "epss_percentile": 0.92456}, "CVE-2015-6764": {"epss_score": 0.18787, "epss_percentile": 0.95069}, "CVE-2015-6765": {"epss_score": 0.04707, "epss_percentile": 0.89034}, "CVE-2015-6766": {"epss_score": 0.01715, "epss_percentile": 0.81899}, "CVE-2015-6767": {"epss_score": 0.01583, "epss_percentile": 0.81145}, "CVE-2015-6768": {"epss_score": 0.00957, "epss_percentile": 0.7593}, "CVE-2015-6769": {"epss_score": 0.01229, "epss_percentile": 0.78712}, "CVE-2015-6770": {"epss_score": 0.00957, "epss_percentile": 0.7593}, "CVE-2015-6771": {"epss_score": 0.02195, "epss_percentile": 0.83953}, "CVE-2015-6772": {"epss_score": 0.01229, "epss_percentile": 0.78712}, "CVE-2015-6773": {"epss_score": 0.01715, "epss_percentile": 0.81899}, "CVE-2015-6774": {"epss_score": 0.01338, "epss_percentile": 0.79567}, "CVE-2015-6775": {"epss_score": 0.01223, "epss_percentile": 0.78664}, "CVE-2015-6776": {"epss_score": 0.01642, "epss_percentile": 0.8151}, "CVE-2015-6777": {"epss_score": 0.01583, "epss_percentile": 0.81145}, "CVE-2015-6778": {"epss_score": 0.01338, "epss_percentile": 0.79567}, "CVE-2015-6779": {"epss_score": 0.00597, "epss_percentile": 0.68749}, "CVE-2015-6780": {"epss_score": 0.01155, "epss_percentile": 0.78073}, "CVE-2015-6781": {"epss_score": 0.01715, "epss_percentile": 0.81899}, "CVE-2015-6782": {"epss_score": 0.00779, "epss_percentile": 0.73153}, "CVE-2015-6783": {"epss_score": 0.00254, "epss_percentile": 0.48501}, "CVE-2015-6784": {"epss_score": 0.00733, "epss_percentile": 0.72215}, "CVE-2015-6785": {"epss_score": 0.00768, "epss_percentile": 0.72977}, "CVE-2015-6786": {"epss_score": 0.00768, "epss_percentile": 0.72977}, "CVE-2015-6787": {"epss_score": 0.48356, "epss_percentile": 0.97633}, "CVE-2015-6788": {"epss_score": 0.04251, "epss_percentile": 0.88452}, "CVE-2015-6789": {"epss_score": 0.01599, "epss_percentile": 0.81254}, "CVE-2015-6790": {"epss_score": 0.0094, "epss_percentile": 0.75728}, "CVE-2015-6791": {"epss_score": 0.01643, "epss_percentile": 0.81515}, "CVE-2015-6792": {"epss_score": 0.19696, "epss_percentile": 0.95227}, "CVE-2015-6805": {"epss_score": 0.00242, "epss_percentile": 0.47392}, "CVE-2015-6806": {"epss_score": 0.00643, "epss_percentile": 0.70067}, "CVE-2015-6807": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2015-6808": {"epss_score": 0.0014, "epss_percentile": 0.34736}, "CVE-2015-6809": {"epss_score": 0.03505, "epss_percentile": 0.87258}, "CVE-2015-6810": {"epss_score": 0.0034, "epss_percentile": 0.56238}, "CVE-2015-6811": {"epss_score": 0.01779, "epss_percentile": 0.8223}, "CVE-2015-6812": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2015-6815": {"epss_score": 0.02246, "epss_percentile": 0.84133}, "CVE-2015-6816": {"epss_score": 0.0211, "epss_percentile": 0.83644}, "CVE-2015-6817": {"epss_score": 0.01367, "epss_percentile": 0.79785}, "CVE-2015-6818": {"epss_score": 0.01033, "epss_percentile": 0.76871}, "CVE-2015-6819": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2015-6820": {"epss_score": 0.01033, "epss_percentile": 0.76871}, "CVE-2015-6821": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2015-6822": {"epss_score": 0.00887, "epss_percentile": 0.7499}, "CVE-2015-6823": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2015-6824": {"epss_score": 0.01033, "epss_percentile": 0.76871}, "CVE-2015-6825": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2015-6826": {"epss_score": 0.01033, "epss_percentile": 0.76871}, "CVE-2015-6827": {"epss_score": 0.00219, "epss_percentile": 0.44447}, "CVE-2015-6828": {"epss_score": 0.00582, "epss_percentile": 0.68313}, "CVE-2015-6829": {"epss_score": 0.00498, "epss_percentile": 0.65229}, "CVE-2015-6830": {"epss_score": 0.27309, "epss_percentile": 0.96235}, "CVE-2015-6831": {"epss_score": 0.01156, "epss_percentile": 0.78081}, "CVE-2015-6832": {"epss_score": 0.01536, "epss_percentile": 0.80917}, "CVE-2015-6833": {"epss_score": 0.00401, "epss_percentile": 0.60235}, "CVE-2015-6834": {"epss_score": 0.38954, "epss_percentile": 0.97129}, "CVE-2015-6835": {"epss_score": 0.21302, "epss_percentile": 0.95497}, "CVE-2015-6836": {"epss_score": 0.03428, "epss_percentile": 0.87118}, "CVE-2015-6837": {"epss_score": 0.03804, "epss_percentile": 0.87748}, "CVE-2015-6838": {"epss_score": 0.03804, "epss_percentile": 0.87748}, "CVE-2015-6839": {"epss_score": 0.00073, "epss_percentile": 0.22604}, "CVE-2015-6843": {"epss_score": 0.0085, "epss_percentile": 0.74394}, "CVE-2015-6844": {"epss_score": 0.00403, "epss_percentile": 0.60342}, "CVE-2015-6845": {"epss_score": 0.01493, "epss_percentile": 0.80639}, "CVE-2015-6846": {"epss_score": 0.0018, "epss_percentile": 0.39867}, "CVE-2015-6847": {"epss_score": 0.00062, "epss_percentile": 0.19565}, "CVE-2015-6848": {"epss_score": 0.00459, "epss_percentile": 0.63466}, "CVE-2015-6849": {"epss_score": 0.01015, "epss_percentile": 0.76665}, "CVE-2015-6850": {"epss_score": 0.00054, "epss_percentile": 0.17171}, "CVE-2015-6851": {"epss_score": 0.00048, "epss_percentile": 0.152}, "CVE-2015-6852": {"epss_score": 0.00147, "epss_percentile": 0.35701}, "CVE-2015-6853": {"epss_score": 0.00808, "epss_percentile": 0.73684}, "CVE-2015-6854": {"epss_score": 0.00553, "epss_percentile": 0.67422}, "CVE-2015-6855": {"epss_score": 0.05769, "epss_percentile": 0.90191}, "CVE-2015-6856": {"epss_score": 0.00077, "epss_percentile": 0.23447}, "CVE-2015-6857": {"epss_score": 0.02296, "epss_percentile": 0.84296}, "CVE-2015-6858": {"epss_score": 0.0041, "epss_percentile": 0.60818}, "CVE-2015-6859": {"epss_score": 0.00096, "epss_percentile": 0.27288}, "CVE-2015-6860": {"epss_score": 0.00046, "epss_percentile": 0.14394}, "CVE-2015-6861": {"epss_score": 0.00393, "epss_percentile": 0.59721}, "CVE-2015-6862": {"epss_score": 0.00467, "epss_percentile": 0.6385}, "CVE-2015-6863": {"epss_score": 0.02452, "epss_percentile": 0.84789}, "CVE-2015-6864": {"epss_score": 0.00667, "epss_percentile": 0.70719}, "CVE-2015-6867": {"epss_score": 0.00948, "epss_percentile": 0.75827}, "CVE-2015-6908": {"epss_score": 0.70513, "epss_percentile": 0.98635}, "CVE-2015-6909": {"epss_score": 0.00457, "epss_percentile": 0.63371}, "CVE-2015-6910": {"epss_score": 0.00626, "epss_percentile": 0.69609}, "CVE-2015-6911": {"epss_score": 0.01583, "epss_percentile": 0.8115}, "CVE-2015-6912": {"epss_score": 0.29734, "epss_percentile": 0.96469}, "CVE-2015-6913": {"epss_score": 0.00305, "epss_percentile": 0.53352}, "CVE-2015-6914": {"epss_score": 0.00362, "epss_percentile": 0.57756}, "CVE-2015-6915": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2015-6918": {"epss_score": 0.00298, "epss_percentile": 0.52823}, "CVE-2015-6919": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2015-6920": {"epss_score": 0.00682, "epss_percentile": 0.71061}, "CVE-2015-6921": {"epss_score": 0.00316, "epss_percentile": 0.54229}, "CVE-2015-6922": {"epss_score": 0.77795, "epss_percentile": 0.98954}, "CVE-2015-6923": {"epss_score": 0.00608, "epss_percentile": 0.69086}, "CVE-2015-6925": {"epss_score": 0.00895, "epss_percentile": 0.75108}, "CVE-2015-6926": {"epss_score": 0.00266, "epss_percentile": 0.49865}, "CVE-2015-6927": {"epss_score": 0.00076, "epss_percentile": 0.23132}, "CVE-2015-6928": {"epss_score": 0.00624, "epss_percentile": 0.69562}, "CVE-2015-6929": {"epss_score": 0.0018, "epss_percentile": 0.39877}, "CVE-2015-6931": {"epss_score": 0.00159, "epss_percentile": 0.37335}, "CVE-2015-6932": {"epss_score": 0.00174, "epss_percentile": 0.39153}, "CVE-2015-6933": {"epss_score": 0.01813, "epss_percentile": 0.82377}, "CVE-2015-6934": {"epss_score": 0.01776, "epss_percentile": 0.82222}, "CVE-2015-6937": {"epss_score": 0.00047, "epss_percentile": 0.14637}, "CVE-2015-6938": {"epss_score": 0.00861, "epss_percentile": 0.74565}, "CVE-2015-6939": {"epss_score": 0.00053, "epss_percentile": 0.16911}, "CVE-2015-6940": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2015-6941": {"epss_score": 0.00408, "epss_percentile": 0.60679}, "CVE-2015-6942": {"epss_score": 0.00196, "epss_percentile": 0.41807}, "CVE-2015-6943": {"epss_score": 0.00252, "epss_percentile": 0.48379}, "CVE-2015-6944": {"epss_score": 0.00239, "epss_percentile": 0.46904}, "CVE-2015-6945": {"epss_score": 0.03505, "epss_percentile": 0.87258}, "CVE-2015-6946": {"epss_score": 0.26199, "epss_percentile": 0.96122}, "CVE-2015-6948": {"epss_score": 0.03229, "epss_percentile": 0.86692}, "CVE-2015-6949": {"epss_score": 0.06024, "epss_percentile": 0.90418}, "CVE-2015-6959": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2015-6960": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2015-6961": {"epss_score": 0.0023, "epss_percentile": 0.4573}, "CVE-2015-6962": {"epss_score": 0.00826, "epss_percentile": 0.73969}, "CVE-2015-6964": {"epss_score": 0.00069, "epss_percentile": 0.21542}, "CVE-2015-6965": {"epss_score": 0.0046, "epss_percentile": 0.6353}, "CVE-2015-6966": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2015-6967": {"epss_score": 0.86769, "epss_percentile": 0.99395}, "CVE-2015-6968": {"epss_score": 0.00808, "epss_percentile": 0.737}, "CVE-2015-6969": {"epss_score": 0.00336, "epss_percentile": 0.55918}, "CVE-2015-6970": {"epss_score": 0.09425, "epss_percentile": 0.92541}, "CVE-2015-6971": {"epss_score": 0.00119, "epss_percentile": 0.31586}, "CVE-2015-6972": {"epss_score": 0.04557, "epss_percentile": 0.88847}, "CVE-2015-6973": {"epss_score": 0.16084, "epss_percentile": 0.9457}, "CVE-2015-6974": {"epss_score": 0.01084, "epss_percentile": 0.77397}, "CVE-2015-6975": {"epss_score": 0.02129, "epss_percentile": 0.83705}, "CVE-2015-6976": {"epss_score": 0.02102, "epss_percentile": 0.83606}, "CVE-2015-6977": {"epss_score": 0.02102, "epss_percentile": 0.83606}, "CVE-2015-6978": {"epss_score": 0.0503, "epss_percentile": 0.89414}, "CVE-2015-6979": {"epss_score": 0.01466, "epss_percentile": 0.80466}, "CVE-2015-6980": {"epss_score": 0.00125, "epss_percentile": 0.32586}, "CVE-2015-6981": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2015-6982": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2015-6983": {"epss_score": 0.00961, "epss_percentile": 0.75978}, "CVE-2015-6984": {"epss_score": 0.00351, "epss_percentile": 0.57049}, "CVE-2015-6985": {"epss_score": 0.01096, "epss_percentile": 0.77523}, "CVE-2015-6986": {"epss_score": 0.00775, "epss_percentile": 0.7308}, "CVE-2015-6987": {"epss_score": 0.00044, "epss_percentile": 0.13648}, "CVE-2015-6988": {"epss_score": 0.11013, "epss_percentile": 0.93189}, "CVE-2015-6989": {"epss_score": 0.00996, "epss_percentile": 0.76447}, "CVE-2015-6990": {"epss_score": 0.01866, "epss_percentile": 0.82608}, "CVE-2015-6991": {"epss_score": 0.01866, "epss_percentile": 0.82608}, "CVE-2015-6992": {"epss_score": 0.02129, "epss_percentile": 0.83705}, "CVE-2015-6993": {"epss_score": 0.01866, "epss_percentile": 0.82608}, "CVE-2015-6994": {"epss_score": 0.01596, "epss_percentile": 0.81241}, "CVE-2015-6995": {"epss_score": 0.10588, "epss_percentile": 0.93036}, "CVE-2015-6996": {"epss_score": 0.06119, "epss_percentile": 0.90492}, "CVE-2015-6997": {"epss_score": 0.0025, "epss_percentile": 0.48103}, "CVE-2015-6999": {"epss_score": 0.0022, "epss_percentile": 0.44582}, "CVE-2015-7000": {"epss_score": 0.00069, "epss_percentile": 0.21531}, "CVE-2015-7001": {"epss_score": 0.0091, "epss_percentile": 0.75316}, "CVE-2015-7002": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-7003": {"epss_score": 0.00645, "epss_percentile": 0.70116}, "CVE-2015-7004": {"epss_score": 0.00529, "epss_percentile": 0.66584}, "CVE-2015-7005": {"epss_score": 0.01314, "epss_percentile": 0.79392}, "CVE-2015-7006": {"epss_score": 0.01259, "epss_percentile": 0.78961}, "CVE-2015-7007": {"epss_score": 0.78161, "epss_percentile": 0.98971}, "CVE-2015-7008": {"epss_score": 0.01866, "epss_percentile": 0.82608}, "CVE-2015-7009": {"epss_score": 0.01866, "epss_percentile": 0.82608}, "CVE-2015-7010": {"epss_score": 0.01866, "epss_percentile": 0.82608}, "CVE-2015-7011": {"epss_score": 0.01655, "epss_percentile": 0.81593}, "CVE-2015-7012": {"epss_score": 0.01645, "epss_percentile": 0.81525}, "CVE-2015-7013": {"epss_score": 0.01529, "epss_percentile": 0.80878}, "CVE-2015-7014": {"epss_score": 0.0117, "epss_percentile": 0.78208}, "CVE-2015-7015": {"epss_score": 0.01162, "epss_percentile": 0.78152}, "CVE-2015-7016": {"epss_score": 0.00332, "epss_percentile": 0.55595}, "CVE-2015-7017": {"epss_score": 0.02129, "epss_percentile": 0.83705}, "CVE-2015-7018": {"epss_score": 0.01866, "epss_percentile": 0.82608}, "CVE-2015-7019": {"epss_score": 0.00042, "epss_percentile": 0.12566}, "CVE-2015-7020": {"epss_score": 0.00042, "epss_percentile": 0.12566}, "CVE-2015-7021": {"epss_score": 0.00044, "epss_percentile": 0.13588}, "CVE-2015-7022": {"epss_score": 0.003, "epss_percentile": 0.52971}, "CVE-2015-7023": {"epss_score": 0.00742, "epss_percentile": 0.72453}, "CVE-2015-7024": {"epss_score": 0.00062, "epss_percentile": 0.19592}, "CVE-2015-7029": {"epss_score": 0.04326, "epss_percentile": 0.88553}, "CVE-2015-7030": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2015-7031": {"epss_score": 0.00257, "epss_percentile": 0.48891}, "CVE-2015-7032": {"epss_score": 0.00713, "epss_percentile": 0.71783}, "CVE-2015-7033": {"epss_score": 0.02085, "epss_percentile": 0.83548}, "CVE-2015-7034": {"epss_score": 0.0102, "epss_percentile": 0.76744}, "CVE-2015-7035": {"epss_score": 0.00624, "epss_percentile": 0.69569}, "CVE-2015-7036": {"epss_score": 0.03516, "epss_percentile": 0.87274}, "CVE-2015-7037": {"epss_score": 0.00224, "epss_percentile": 0.45057}, "CVE-2015-7038": {"epss_score": 0.06456, "epss_percentile": 0.90768}, "CVE-2015-7039": {"epss_score": 0.27364, "epss_percentile": 0.96241}, "CVE-2015-7040": {"epss_score": 0.01078, "epss_percentile": 0.77347}, "CVE-2015-7041": {"epss_score": 0.01078, "epss_percentile": 0.77347}, "CVE-2015-7042": {"epss_score": 0.01078, "epss_percentile": 0.77347}, "CVE-2015-7043": {"epss_score": 0.01078, "epss_percentile": 0.77347}, "CVE-2015-7044": {"epss_score": 0.00867, "epss_percentile": 0.74651}, "CVE-2015-7045": {"epss_score": 0.00336, "epss_percentile": 0.55951}, "CVE-2015-7046": {"epss_score": 0.00738, "epss_percentile": 0.72343}, "CVE-2015-7047": {"epss_score": 0.00746, "epss_percentile": 0.72548}, "CVE-2015-7048": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-7049": {"epss_score": 0.00068, "epss_percentile": 0.21347}, "CVE-2015-7050": {"epss_score": 0.00582, "epss_percentile": 0.68298}, "CVE-2015-7051": {"epss_score": 0.00757, "epss_percentile": 0.7276}, "CVE-2015-7052": {"epss_score": 0.00047, "epss_percentile": 0.14504}, "CVE-2015-7053": {"epss_score": 0.03398, "epss_percentile": 0.87065}, "CVE-2015-7054": {"epss_score": 0.01142, "epss_percentile": 0.77968}, "CVE-2015-7055": {"epss_score": 0.00623, "epss_percentile": 0.69534}, "CVE-2015-7056": {"epss_score": 0.00307, "epss_percentile": 0.53474}, "CVE-2015-7057": {"epss_score": 0.00068, "epss_percentile": 0.21347}, "CVE-2015-7058": {"epss_score": 0.00524, "epss_percentile": 0.66338}, "CVE-2015-7059": {"epss_score": 0.01371, "epss_percentile": 0.79809}, "CVE-2015-7060": {"epss_score": 0.01371, "epss_percentile": 0.79809}, "CVE-2015-7061": {"epss_score": 0.01371, "epss_percentile": 0.79809}, "CVE-2015-7062": {"epss_score": 0.00062, "epss_percentile": 0.19709}, "CVE-2015-7063": {"epss_score": 0.00047, "epss_percentile": 0.14504}, "CVE-2015-7064": {"epss_score": 0.01234, "epss_percentile": 0.78754}, "CVE-2015-7065": {"epss_score": 0.01866, "epss_percentile": 0.82613}, "CVE-2015-7066": {"epss_score": 0.01234, "epss_percentile": 0.78754}, "CVE-2015-7067": {"epss_score": 0.00055, "epss_percentile": 0.17527}, "CVE-2015-7068": {"epss_score": 0.04372, "epss_percentile": 0.8861}, "CVE-2015-7069": {"epss_score": 0.00867, "epss_percentile": 0.74651}, "CVE-2015-7070": {"epss_score": 0.00867, "epss_percentile": 0.74651}, "CVE-2015-7071": {"epss_score": 0.00391, "epss_percentile": 0.59576}, "CVE-2015-7072": {"epss_score": 0.0101, "epss_percentile": 0.76606}, "CVE-2015-7073": {"epss_score": 0.03398, "epss_percentile": 0.87065}, "CVE-2015-7074": {"epss_score": 0.02828, "epss_percentile": 0.85769}, "CVE-2015-7075": {"epss_score": 0.03398, "epss_percentile": 0.87065}, "CVE-2015-7076": {"epss_score": 0.00047, "epss_percentile": 0.14504}, "CVE-2015-7077": {"epss_score": 0.0028, "epss_percentile": 0.51036}, "CVE-2015-7078": {"epss_score": 0.00293, "epss_percentile": 0.52308}, "CVE-2015-7079": {"epss_score": 0.01096, "epss_percentile": 0.77521}, "CVE-2015-7080": {"epss_score": 0.00068, "epss_percentile": 0.2136}, "CVE-2015-7081": {"epss_score": 0.00529, "epss_percentile": 0.66578}, "CVE-2015-7082": {"epss_score": 0.00605, "epss_percentile": 0.68974}, "CVE-2015-7083": {"epss_score": 0.00276, "epss_percentile": 0.50758}, "CVE-2015-7084": {"epss_score": 0.00335, "epss_percentile": 0.55798}, "CVE-2015-7085": {"epss_score": 0.00571, "epss_percentile": 0.67995}, "CVE-2015-7086": {"epss_score": 0.00571, "epss_percentile": 0.67995}, "CVE-2015-7087": {"epss_score": 0.00571, "epss_percentile": 0.67995}, "CVE-2015-7088": {"epss_score": 0.00571, "epss_percentile": 0.67995}, "CVE-2015-7089": {"epss_score": 0.00571, "epss_percentile": 0.67995}, "CVE-2015-7090": {"epss_score": 0.00571, "epss_percentile": 0.67995}, "CVE-2015-7091": {"epss_score": 0.0456, "epss_percentile": 0.8885}, "CVE-2015-7092": {"epss_score": 0.0068, "epss_percentile": 0.71033}, "CVE-2015-7093": {"epss_score": 0.00266, "epss_percentile": 0.49888}, "CVE-2015-7094": {"epss_score": 0.00336, "epss_percentile": 0.55951}, "CVE-2015-7095": {"epss_score": 0.01093, "epss_percentile": 0.77486}, "CVE-2015-7096": {"epss_score": 0.01032, "epss_percentile": 0.76862}, "CVE-2015-7097": {"epss_score": 0.01093, "epss_percentile": 0.77486}, "CVE-2015-7098": {"epss_score": 0.01032, "epss_percentile": 0.76862}, "CVE-2015-7099": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-7100": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-7101": {"epss_score": 0.01093, "epss_percentile": 0.77486}, "CVE-2015-7102": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-7103": {"epss_score": 0.01009, "epss_percentile": 0.76589}, "CVE-2015-7104": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2015-7105": {"epss_score": 0.02531, "epss_percentile": 0.85024}, "CVE-2015-7106": {"epss_score": 0.00329, "epss_percentile": 0.55415}, "CVE-2015-7107": {"epss_score": 0.02388, "epss_percentile": 0.84587}, "CVE-2015-7108": {"epss_score": 0.00974, "epss_percentile": 0.76171}, "CVE-2015-7109": {"epss_score": 0.00868, "epss_percentile": 0.74678}, "CVE-2015-7110": {"epss_score": 0.00387, "epss_percentile": 0.59337}, "CVE-2015-7111": {"epss_score": 0.01731, "epss_percentile": 0.81995}, "CVE-2015-7112": {"epss_score": 0.19674, "epss_percentile": 0.95223}, "CVE-2015-7113": {"epss_score": 0.00868, "epss_percentile": 0.74678}, "CVE-2015-7115": {"epss_score": 0.00828, "epss_percentile": 0.73995}, "CVE-2015-7116": {"epss_score": 0.00828, "epss_percentile": 0.73995}, "CVE-2015-7117": {"epss_score": 0.00571, "epss_percentile": 0.67995}, "CVE-2015-7174": {"epss_score": 0.03205, "epss_percentile": 0.86632}, "CVE-2015-7175": {"epss_score": 0.03205, "epss_percentile": 0.86632}, "CVE-2015-7176": {"epss_score": 0.05714, "epss_percentile": 0.90144}, "CVE-2015-7177": {"epss_score": 0.03205, "epss_percentile": 0.86632}, "CVE-2015-7178": {"epss_score": 0.01524, "epss_percentile": 0.80847}, "CVE-2015-7179": {"epss_score": 0.02116, "epss_percentile": 0.83663}, "CVE-2015-7180": {"epss_score": 0.03205, "epss_percentile": 0.86632}, "CVE-2015-7181": {"epss_score": 0.20434, "epss_percentile": 0.95344}, "CVE-2015-7182": {"epss_score": 0.21714, "epss_percentile": 0.95551}, "CVE-2015-7183": {"epss_score": 0.18188, "epss_percentile": 0.94972}, "CVE-2015-7184": {"epss_score": 0.00243, "epss_percentile": 0.4751}, "CVE-2015-7185": {"epss_score": 0.00396, "epss_percentile": 0.59923}, "CVE-2015-7186": {"epss_score": 0.00142, "epss_percentile": 0.34981}, "CVE-2015-7187": {"epss_score": 0.00486, "epss_percentile": 0.64746}, "CVE-2015-7188": {"epss_score": 0.0123, "epss_percentile": 0.78723}, "CVE-2015-7189": {"epss_score": 0.03503, "epss_percentile": 0.87253}, "CVE-2015-7190": {"epss_score": 0.00478, "epss_percentile": 0.64407}, "CVE-2015-7191": {"epss_score": 0.00731, "epss_percentile": 0.72177}, "CVE-2015-7192": {"epss_score": 0.02358, "epss_percentile": 0.8449}, "CVE-2015-7193": {"epss_score": 0.00508, "epss_percentile": 0.6571}, "CVE-2015-7194": {"epss_score": 0.02572, "epss_percentile": 0.85133}, "CVE-2015-7195": {"epss_score": 0.00567, "epss_percentile": 0.67846}, "CVE-2015-7196": {"epss_score": 0.02411, "epss_percentile": 0.84667}, "CVE-2015-7197": {"epss_score": 0.00739, "epss_percentile": 0.72354}, "CVE-2015-7198": {"epss_score": 0.0387, "epss_percentile": 0.8788}, "CVE-2015-7199": {"epss_score": 0.02497, "epss_percentile": 0.8491}, "CVE-2015-7200": {"epss_score": 0.02259, "epss_percentile": 0.8418}, "CVE-2015-7201": {"epss_score": 0.01913, "epss_percentile": 0.82843}, "CVE-2015-7202": {"epss_score": 0.01913, "epss_percentile": 0.82843}, "CVE-2015-7203": {"epss_score": 0.01662, "epss_percentile": 0.81632}, "CVE-2015-7204": {"epss_score": 0.0172, "epss_percentile": 0.81928}, "CVE-2015-7205": {"epss_score": 0.00863, "epss_percentile": 0.74586}, "CVE-2015-7207": {"epss_score": 0.00437, "epss_percentile": 0.62536}, "CVE-2015-7208": {"epss_score": 0.00618, "epss_percentile": 0.69375}, "CVE-2015-7210": {"epss_score": 0.01773, "epss_percentile": 0.82205}, "CVE-2015-7211": {"epss_score": 0.0068, "epss_percentile": 0.71036}, "CVE-2015-7212": {"epss_score": 0.02306, "epss_percentile": 0.84324}, "CVE-2015-7213": {"epss_score": 0.02438, "epss_percentile": 0.84745}, "CVE-2015-7214": {"epss_score": 0.15477, "epss_percentile": 0.94435}, "CVE-2015-7215": {"epss_score": 0.00437, "epss_percentile": 0.62536}, "CVE-2015-7216": {"epss_score": 0.00892, "epss_percentile": 0.75059}, "CVE-2015-7217": {"epss_score": 0.01302, "epss_percentile": 0.79301}, "CVE-2015-7218": {"epss_score": 0.01259, "epss_percentile": 0.78963}, "CVE-2015-7219": {"epss_score": 0.01259, "epss_percentile": 0.78963}, "CVE-2015-7220": {"epss_score": 0.01483, "epss_percentile": 0.80586}, "CVE-2015-7221": {"epss_score": 0.01483, "epss_percentile": 0.80586}, "CVE-2015-7222": {"epss_score": 0.03351, "epss_percentile": 0.86962}, "CVE-2015-7223": {"epss_score": 0.00744, "epss_percentile": 0.7251}, "CVE-2015-7224": {"epss_score": 0.00546, "epss_percentile": 0.67215}, "CVE-2015-7225": {"epss_score": 0.00648, "epss_percentile": 0.70214}, "CVE-2015-7226": {"epss_score": 0.00294, "epss_percentile": 0.52358}, "CVE-2015-7227": {"epss_score": 0.00129, "epss_percentile": 0.33215}, "CVE-2015-7228": {"epss_score": 0.00266, "epss_percentile": 0.49911}, "CVE-2015-7229": {"epss_score": 0.00165, "epss_percentile": 0.38039}, "CVE-2015-7230": {"epss_score": 0.00138, "epss_percentile": 0.34397}, "CVE-2015-7231": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2015-7232": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-7233": {"epss_score": 0.00119, "epss_percentile": 0.31571}, "CVE-2015-7234": {"epss_score": 0.00696, "epss_percentile": 0.71397}, "CVE-2015-7235": {"epss_score": 0.02603, "epss_percentile": 0.85211}, "CVE-2015-7236": {"epss_score": 0.07676, "epss_percentile": 0.91619}, "CVE-2015-7237": {"epss_score": 0.00235, "epss_percentile": 0.46333}, "CVE-2015-7238": {"epss_score": 0.00042, "epss_percentile": 0.12932}, "CVE-2015-7239": {"epss_score": 0.00356, "epss_percentile": 0.57348}, "CVE-2015-7241": {"epss_score": 0.27377, "epss_percentile": 0.96242}, "CVE-2015-7242": {"epss_score": 0.00255, "epss_percentile": 0.48733}, "CVE-2015-7243": {"epss_score": 0.73318, "epss_percentile": 0.98746}, "CVE-2015-7244": {"epss_score": 0.0731, "epss_percentile": 0.914}, "CVE-2015-7245": {"epss_score": 0.87413, "epss_percentile": 0.99428}, "CVE-2015-7246": {"epss_score": 0.33103, "epss_percentile": 0.96746}, "CVE-2015-7247": {"epss_score": 0.3094, "epss_percentile": 0.96576}, "CVE-2015-7248": {"epss_score": 0.35407, "epss_percentile": 0.96906}, "CVE-2015-7249": {"epss_score": 0.11222, "epss_percentile": 0.9327}, "CVE-2015-7250": {"epss_score": 0.20201, "epss_percentile": 0.95302}, "CVE-2015-7251": {"epss_score": 0.38832, "epss_percentile": 0.97122}, "CVE-2015-7252": {"epss_score": 0.24048, "epss_percentile": 0.9585}, "CVE-2015-7253": {"epss_score": 0.02367, "epss_percentile": 0.84518}, "CVE-2015-7254": {"epss_score": 0.19179, "epss_percentile": 0.95145}, "CVE-2015-7255": {"epss_score": 0.00804, "epss_percentile": 0.73623}, "CVE-2015-7256": {"epss_score": 0.00127, "epss_percentile": 0.32819}, "CVE-2015-7257": {"epss_score": 0.16737, "epss_percentile": 0.94724}, "CVE-2015-7258": {"epss_score": 0.32589, "epss_percentile": 0.96709}, "CVE-2015-7259": {"epss_score": 0.33338, "epss_percentile": 0.96764}, "CVE-2015-7260": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2015-7261": {"epss_score": 0.00253, "epss_percentile": 0.48449}, "CVE-2015-7262": {"epss_score": 0.00197, "epss_percentile": 0.41827}, "CVE-2015-7263": {"epss_score": 0.00349, "epss_percentile": 0.56914}, "CVE-2015-7264": {"epss_score": 0.00486, "epss_percentile": 0.64774}, "CVE-2015-7265": {"epss_score": 0.00349, "epss_percentile": 0.56914}, "CVE-2015-7266": {"epss_score": 0.0027, "epss_percentile": 0.50215}, "CVE-2015-7267": {"epss_score": 0.00059, "epss_percentile": 0.1863}, "CVE-2015-7268": {"epss_score": 0.00059, "epss_percentile": 0.1863}, "CVE-2015-7269": {"epss_score": 0.00059, "epss_percentile": 0.1863}, "CVE-2015-7270": {"epss_score": 0.00836, "epss_percentile": 0.74138}, "CVE-2015-7271": {"epss_score": 0.00841, "epss_percentile": 0.74222}, "CVE-2015-7272": {"epss_score": 0.00859, "epss_percentile": 0.74522}, "CVE-2015-7273": {"epss_score": 0.00714, "epss_percentile": 0.71805}, "CVE-2015-7274": {"epss_score": 0.02297, "epss_percentile": 0.84298}, "CVE-2015-7275": {"epss_score": 0.00239, "epss_percentile": 0.46881}, "CVE-2015-7276": {"epss_score": 0.00311, "epss_percentile": 0.53869}, "CVE-2015-7277": {"epss_score": 0.00686, "epss_percentile": 0.71166}, "CVE-2015-7278": {"epss_score": 0.00101, "epss_percentile": 0.28658}, "CVE-2015-7279": {"epss_score": 0.01067, "epss_percentile": 0.77224}, "CVE-2015-7280": {"epss_score": 0.00544, "epss_percentile": 0.67148}, "CVE-2015-7281": {"epss_score": 0.00101, "epss_percentile": 0.28658}, "CVE-2015-7282": {"epss_score": 0.00441, "epss_percentile": 0.62682}, "CVE-2015-7283": {"epss_score": 0.01581, "epss_percentile": 0.81136}, "CVE-2015-7284": {"epss_score": 0.00125, "epss_percentile": 0.32482}, "CVE-2015-7285": {"epss_score": 0.00513, "epss_percentile": 0.65877}, "CVE-2015-7286": {"epss_score": 0.03246, "epss_percentile": 0.86743}, "CVE-2015-7287": {"epss_score": 0.08724, "epss_percentile": 0.92227}, "CVE-2015-7288": {"epss_score": 0.02864, "epss_percentile": 0.85858}, "CVE-2015-7289": {"epss_score": 0.00376, "epss_percentile": 0.58687}, "CVE-2015-7290": {"epss_score": 0.00833, "epss_percentile": 0.74085}, "CVE-2015-7291": {"epss_score": 0.00094, "epss_percentile": 0.26782}, "CVE-2015-7292": {"epss_score": 0.00411, "epss_percentile": 0.60878}, "CVE-2015-7293": {"epss_score": 0.00332, "epss_percentile": 0.55607}, "CVE-2015-7294": {"epss_score": 0.01317, "epss_percentile": 0.79412}, "CVE-2015-7295": {"epss_score": 0.03583, "epss_percentile": 0.87387}, "CVE-2015-7296": {"epss_score": 0.00822, "epss_percentile": 0.73911}, "CVE-2015-7297": {"epss_score": 0.93328, "epss_percentile": 0.99797}, "CVE-2015-7298": {"epss_score": 0.00247, "epss_percentile": 0.47894}, "CVE-2015-7299": {"epss_score": 0.00549, "epss_percentile": 0.67305}, "CVE-2015-7303": {"epss_score": 0.09486, "epss_percentile": 0.92569}, "CVE-2015-7304": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-7305": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2015-7306": {"epss_score": 0.00255, "epss_percentile": 0.48698}, "CVE-2015-7307": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-7309": {"epss_score": 0.60269, "epss_percentile": 0.98202}, "CVE-2015-7310": {"epss_score": 0.00485, "epss_percentile": 0.64739}, "CVE-2015-7311": {"epss_score": 0.00067, "epss_percentile": 0.21061}, "CVE-2015-7312": {"epss_score": 0.00039, "epss_percentile": 0.11805}, "CVE-2015-7313": {"epss_score": 0.00246, "epss_percentile": 0.47804}, "CVE-2015-7314": {"epss_score": 0.00472, "epss_percentile": 0.64035}, "CVE-2015-7315": {"epss_score": 0.00436, "epss_percentile": 0.62448}, "CVE-2015-7316": {"epss_score": 0.0051, "epss_percentile": 0.65794}, "CVE-2015-7317": {"epss_score": 0.00252, "epss_percentile": 0.48352}, "CVE-2015-7318": {"epss_score": 0.00431, "epss_percentile": 0.62057}, "CVE-2015-7319": {"epss_score": 0.00417, "epss_percentile": 0.61228}, "CVE-2015-7320": {"epss_score": 0.00225, "epss_percentile": 0.45138}, "CVE-2015-7322": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2015-7323": {"epss_score": 0.00369, "epss_percentile": 0.5825}, "CVE-2015-7324": {"epss_score": 0.00324, "epss_percentile": 0.54941}, "CVE-2015-7326": {"epss_score": 0.01961, "epss_percentile": 0.83062}, "CVE-2015-7327": {"epss_score": 0.00403, "epss_percentile": 0.60354}, "CVE-2015-7328": {"epss_score": 0.00026, "epss_percentile": 0.06658}, "CVE-2015-7330": {"epss_score": 0.00373, "epss_percentile": 0.58515}, "CVE-2015-7331": {"epss_score": 0.00393, "epss_percentile": 0.59718}, "CVE-2015-7333": {"epss_score": 0.00038, "epss_percentile": 0.11141}, "CVE-2015-7334": {"epss_score": 0.00038, "epss_percentile": 0.11141}, "CVE-2015-7335": {"epss_score": 0.00038, "epss_percentile": 0.11385}, "CVE-2015-7336": {"epss_score": 0.00113, "epss_percentile": 0.3062}, "CVE-2015-7337": {"epss_score": 0.00775, "epss_percentile": 0.73084}, "CVE-2015-7338": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2015-7339": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2015-7340": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2015-7341": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2015-7342": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2015-7343": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2015-7344": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2015-7346": {"epss_score": 0.04151, "epss_percentile": 0.88323}, "CVE-2015-7347": {"epss_score": 0.00229, "epss_percentile": 0.45569}, "CVE-2015-7348": {"epss_score": 0.00296, "epss_percentile": 0.52679}, "CVE-2015-7349": {"epss_score": 0.00361, "epss_percentile": 0.57719}, "CVE-2015-7357": {"epss_score": 0.00335, "epss_percentile": 0.55815}, "CVE-2015-7358": {"epss_score": 0.01352, "epss_percentile": 0.79687}, "CVE-2015-7359": {"epss_score": 0.00204, "epss_percentile": 0.42604}, "CVE-2015-7360": {"epss_score": 0.00255, "epss_percentile": 0.48733}, "CVE-2015-7361": {"epss_score": 0.00737, "epss_percentile": 0.72318}, "CVE-2015-7362": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2015-7363": {"epss_score": 0.00327, "epss_percentile": 0.55139}, "CVE-2015-7364": {"epss_score": 0.0017, "epss_percentile": 0.38721}, "CVE-2015-7365": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-7366": {"epss_score": 0.00227, "epss_percentile": 0.45374}, "CVE-2015-7367": {"epss_score": 0.00656, "epss_percentile": 0.7044}, "CVE-2015-7368": {"epss_score": 0.00062, "epss_percentile": 0.19786}, "CVE-2015-7369": {"epss_score": 0.00844, "epss_percentile": 0.74275}, "CVE-2015-7370": {"epss_score": 0.00452, "epss_percentile": 0.63174}, "CVE-2015-7371": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2015-7372": {"epss_score": 0.01953, "epss_percentile": 0.83027}, "CVE-2015-7373": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-7374": {"epss_score": 0.01849, "epss_percentile": 0.82529}, "CVE-2015-7375": {"epss_score": 0.00786, "epss_percentile": 0.73288}, "CVE-2015-7377": {"epss_score": 0.05825, "epss_percentile": 0.90238}, "CVE-2015-7378": {"epss_score": 0.0018, "epss_percentile": 0.39984}, "CVE-2015-7381": {"epss_score": 0.04628, "epss_percentile": 0.88941}, "CVE-2015-7382": {"epss_score": 0.027, "epss_percentile": 0.85451}, "CVE-2015-7383": {"epss_score": 0.0067, "epss_percentile": 0.70785}, "CVE-2015-7384": {"epss_score": 0.00878, "epss_percentile": 0.74821}, "CVE-2015-7385": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-7386": {"epss_score": 0.00123, "epss_percentile": 0.32214}, "CVE-2015-7387": {"epss_score": 0.81709, "epss_percentile": 0.99152}, "CVE-2015-7390": {"epss_score": 0.004, "epss_percentile": 0.60191}, "CVE-2015-7391": {"epss_score": 0.00215, "epss_percentile": 0.44038}, "CVE-2015-7392": {"epss_score": 0.04091, "epss_percentile": 0.88237}, "CVE-2015-7393": {"epss_score": 0.00075, "epss_percentile": 0.22897}, "CVE-2015-7394": {"epss_score": 0.00978, "epss_percentile": 0.76254}, "CVE-2015-7395": {"epss_score": 0.00111, "epss_percentile": 0.30372}, "CVE-2015-7396": {"epss_score": 0.00133, "epss_percentile": 0.33733}, "CVE-2015-7397": {"epss_score": 0.00338, "epss_percentile": 0.56162}, "CVE-2015-7398": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2015-7399": {"epss_score": 0.00226, "epss_percentile": 0.45279}, "CVE-2015-7400": {"epss_score": 0.00769, "epss_percentile": 0.72982}, "CVE-2015-7401": {"epss_score": 0.00105, "epss_percentile": 0.29348}, "CVE-2015-7402": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2015-7403": {"epss_score": 0.00056, "epss_percentile": 0.1772}, "CVE-2015-7404": {"epss_score": 0.0003, "epss_percentile": 0.0826}, "CVE-2015-7407": {"epss_score": 0.00114, "epss_percentile": 0.30846}, "CVE-2015-7408": {"epss_score": 0.00196, "epss_percentile": 0.41714}, "CVE-2015-7409": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2015-7410": {"epss_score": 0.00227, "epss_percentile": 0.45385}, "CVE-2015-7411": {"epss_score": 0.00786, "epss_percentile": 0.73298}, "CVE-2015-7412": {"epss_score": 0.00212, "epss_percentile": 0.43806}, "CVE-2015-7413": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2015-7414": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2015-7415": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2015-7416": {"epss_score": 0.00202, "epss_percentile": 0.42489}, "CVE-2015-7417": {"epss_score": 0.00172, "epss_percentile": 0.38945}, "CVE-2015-7418": {"epss_score": 0.00128, "epss_percentile": 0.33045}, "CVE-2015-7419": {"epss_score": 0.00943, "epss_percentile": 0.75771}, "CVE-2015-7420": {"epss_score": 0.00285, "epss_percentile": 0.51656}, "CVE-2015-7421": {"epss_score": 0.00285, "epss_percentile": 0.51656}, "CVE-2015-7422": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2015-7423": {"epss_score": 0.00182, "epss_percentile": 0.4025}, "CVE-2015-7424": {"epss_score": 0.00105, "epss_percentile": 0.29348}, "CVE-2015-7425": {"epss_score": 0.09884, "epss_percentile": 0.92753}, "CVE-2015-7426": {"epss_score": 0.02726, "epss_percentile": 0.85526}, "CVE-2015-7427": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2015-7428": {"epss_score": 0.00201, "epss_percentile": 0.42329}, "CVE-2015-7429": {"epss_score": 0.00299, "epss_percentile": 0.52873}, "CVE-2015-7430": {"epss_score": 0.00049, "epss_percentile": 0.15305}, "CVE-2015-7431": {"epss_score": 0.00225, "epss_percentile": 0.45124}, "CVE-2015-7432": {"epss_score": 0.00042, "epss_percentile": 0.12815}, "CVE-2015-7433": {"epss_score": 0.00042, "epss_percentile": 0.12815}, "CVE-2015-7434": {"epss_score": 0.00042, "epss_percentile": 0.12815}, "CVE-2015-7435": {"epss_score": 0.00046, "epss_percentile": 0.14361}, "CVE-2015-7436": {"epss_score": 0.00035, "epss_percentile": 0.09981}, "CVE-2015-7437": {"epss_score": 0.00042, "epss_percentile": 0.12584}, "CVE-2015-7438": {"epss_score": 0.00042, "epss_percentile": 0.12584}, "CVE-2015-7439": {"epss_score": 0.00225, "epss_percentile": 0.45124}, "CVE-2015-7440": {"epss_score": 0.00049, "epss_percentile": 0.15491}, "CVE-2015-7441": {"epss_score": 0.00247, "epss_percentile": 0.47846}, "CVE-2015-7442": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2015-7444": {"epss_score": 0.00213, "epss_percentile": 0.43884}, "CVE-2015-7445": {"epss_score": 0.00184, "epss_percentile": 0.40371}, "CVE-2015-7446": {"epss_score": 0.00136, "epss_percentile": 0.34091}, "CVE-2015-7447": {"epss_score": 0.00248, "epss_percentile": 0.47912}, "CVE-2015-7448": {"epss_score": 0.00126, "epss_percentile": 0.32725}, "CVE-2015-7449": {"epss_score": 0.00018, "epss_percentile": 0.03751}, "CVE-2015-7450": {"epss_score": 0.9396, "epss_percentile": 0.99875}, "CVE-2015-7451": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2015-7452": {"epss_score": 0.00155, "epss_percentile": 0.36807}, "CVE-2015-7453": {"epss_score": 0.00187, "epss_percentile": 0.40715}, "CVE-2015-7454": {"epss_score": 0.0016, "epss_percentile": 0.37428}, "CVE-2015-7455": {"epss_score": 0.00088, "epss_percentile": 0.2576}, "CVE-2015-7456": {"epss_score": 0.00202, "epss_percentile": 0.424}, "CVE-2015-7457": {"epss_score": 0.00193, "epss_percentile": 0.41407}, "CVE-2015-7458": {"epss_score": 0.00129, "epss_percentile": 0.33109}, "CVE-2015-7459": {"epss_score": 0.00129, "epss_percentile": 0.33109}, "CVE-2015-7460": {"epss_score": 0.00129, "epss_percentile": 0.33109}, "CVE-2015-7461": {"epss_score": 0.00395, "epss_percentile": 0.59802}, "CVE-2015-7462": {"epss_score": 0.00029, "epss_percentile": 0.07911}, "CVE-2015-7463": {"epss_score": 0.00085, "epss_percentile": 0.25134}, "CVE-2015-7464": {"epss_score": 0.00869, "epss_percentile": 0.74689}, "CVE-2015-7465": {"epss_score": 0.00105, "epss_percentile": 0.29291}, "CVE-2015-7466": {"epss_score": 0.00188, "epss_percentile": 0.40836}, "CVE-2015-7467": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2015-7468": {"epss_score": 0.00118, "epss_percentile": 0.31396}, "CVE-2015-7469": {"epss_score": 0.00118, "epss_percentile": 0.31396}, "CVE-2015-7470": {"epss_score": 0.00234, "epss_percentile": 0.46087}, "CVE-2015-7471": {"epss_score": 0.00132, "epss_percentile": 0.33571}, "CVE-2015-7472": {"epss_score": 0.00219, "epss_percentile": 0.44511}, "CVE-2015-7473": {"epss_score": 0.00051, "epss_percentile": 0.16125}, "CVE-2015-7474": {"epss_score": 0.00148, "epss_percentile": 0.35863}, "CVE-2015-7484": {"epss_score": 0.00119, "epss_percentile": 0.31536}, "CVE-2015-7485": {"epss_score": 0.00129, "epss_percentile": 0.33109}, "CVE-2015-7486": {"epss_score": 0.00129, "epss_percentile": 0.33109}, "CVE-2015-7487": {"epss_score": 0.00052, "epss_percentile": 0.16606}, "CVE-2015-7488": {"epss_score": 0.00081, "epss_percentile": 0.24305}, "CVE-2015-7489": {"epss_score": 0.00031, "epss_percentile": 0.08695}, "CVE-2015-7490": {"epss_score": 0.00128, "epss_percentile": 0.33039}, "CVE-2015-7491": {"epss_score": 0.0013, "epss_percentile": 0.33228}, "CVE-2015-7492": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2015-7493": {"epss_score": 0.00053, "epss_percentile": 0.16931}, "CVE-2015-7494": {"epss_score": 0.00092, "epss_percentile": 0.26556}, "CVE-2015-7496": {"epss_score": 0.00079, "epss_percentile": 0.23861}, "CVE-2015-7497": {"epss_score": 0.03441, "epss_percentile": 0.87141}, "CVE-2015-7498": {"epss_score": 0.03441, "epss_percentile": 0.87141}, "CVE-2015-7499": {"epss_score": 0.02947, "epss_percentile": 0.86044}, "CVE-2015-7500": {"epss_score": 0.04248, "epss_percentile": 0.88447}, "CVE-2015-7501": {"epss_score": 0.71461, "epss_percentile": 0.9867}, "CVE-2015-7502": {"epss_score": 0.00061, "epss_percentile": 0.19258}, "CVE-2015-7503": {"epss_score": 0.00249, "epss_percentile": 0.48048}, "CVE-2015-7504": {"epss_score": 0.00609, "epss_percentile": 0.6909}, "CVE-2015-7505": {"epss_score": 0.00792, "epss_percentile": 0.73398}, "CVE-2015-7506": {"epss_score": 0.00436, "epss_percentile": 0.62451}, "CVE-2015-7507": {"epss_score": 0.00468, "epss_percentile": 0.63891}, "CVE-2015-7508": {"epss_score": 0.00783, "epss_percentile": 0.73221}, "CVE-2015-7509": {"epss_score": 0.00084, "epss_percentile": 0.24872}, "CVE-2015-7510": {"epss_score": 0.00452, "epss_percentile": 0.63163}, "CVE-2015-7511": {"epss_score": 0.00042, "epss_percentile": 0.12897}, "CVE-2015-7512": {"epss_score": 0.2106, "epss_percentile": 0.95459}, "CVE-2015-7513": {"epss_score": 0.00061, "epss_percentile": 0.19451}, "CVE-2015-7514": {"epss_score": 0.00191, "epss_percentile": 0.41208}, "CVE-2015-7515": {"epss_score": 0.00706, "epss_percentile": 0.71622}, "CVE-2015-7516": {"epss_score": 0.01343, "epss_percentile": 0.79606}, "CVE-2015-7517": {"epss_score": 0.04225, "epss_percentile": 0.88415}, "CVE-2015-7518": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2015-7519": {"epss_score": 0.00361, "epss_percentile": 0.57728}, "CVE-2015-7520": {"epss_score": 0.01397, "epss_percentile": 0.79984}, "CVE-2015-7521": {"epss_score": 0.00404, "epss_percentile": 0.60433}, "CVE-2015-7527": {"epss_score": 0.05376, "epss_percentile": 0.89798}, "CVE-2015-7528": {"epss_score": 0.00366, "epss_percentile": 0.58058}, "CVE-2015-7529": {"epss_score": 0.00058, "epss_percentile": 0.18262}, "CVE-2015-7536": {"epss_score": 0.00289, "epss_percentile": 0.52018}, "CVE-2015-7537": {"epss_score": 0.00397, "epss_percentile": 0.60049}, "CVE-2015-7538": {"epss_score": 0.00234, "epss_percentile": 0.46172}, "CVE-2015-7539": {"epss_score": 0.0104, "epss_percentile": 0.76961}, "CVE-2015-7540": {"epss_score": 0.43299, "epss_percentile": 0.9738}, "CVE-2015-7541": {"epss_score": 0.01299, "epss_percentile": 0.79285}, "CVE-2015-7542": {"epss_score": 0.00113, "epss_percentile": 0.3067}, "CVE-2015-7543": {"epss_score": 0.00103, "epss_percentile": 0.28931}, "CVE-2015-7544": {"epss_score": 0.00926, "epss_percentile": 0.7554}, "CVE-2015-7545": {"epss_score": 0.34729, "epss_percentile": 0.9687}, "CVE-2015-7546": {"epss_score": 0.00105, "epss_percentile": 0.29356}, "CVE-2015-7547": {"epss_score": 0.93872, "epss_percentile": 0.99861}, "CVE-2015-7548": {"epss_score": 0.00172, "epss_percentile": 0.38903}, "CVE-2015-7549": {"epss_score": 0.00124, "epss_percentile": 0.32341}, "CVE-2015-7550": {"epss_score": 0.00063, "epss_percentile": 0.1983}, "CVE-2015-7551": {"epss_score": 0.00127, "epss_percentile": 0.32821}, "CVE-2015-7552": {"epss_score": 0.01774, "epss_percentile": 0.82209}, "CVE-2015-7553": {"epss_score": 0.00036, "epss_percentile": 0.10376}, "CVE-2015-7554": {"epss_score": 0.00761, "epss_percentile": 0.72827}, "CVE-2015-7555": {"epss_score": 0.00357, "epss_percentile": 0.57435}, "CVE-2015-7556": {"epss_score": 0.00234, "epss_percentile": 0.46089}, "CVE-2015-7557": {"epss_score": 0.00518, "epss_percentile": 0.66127}, "CVE-2015-7558": {"epss_score": 0.0143, "epss_percentile": 0.80234}, "CVE-2015-7559": {"epss_score": 0.00082, "epss_percentile": 0.24498}, "CVE-2015-7560": {"epss_score": 0.03692, "epss_percentile": 0.87579}, "CVE-2015-7561": {"epss_score": 0.00172, "epss_percentile": 0.39026}, "CVE-2015-7562": {"epss_score": 0.00952, "epss_percentile": 0.75872}, "CVE-2015-7563": {"epss_score": 0.00126, "epss_percentile": 0.32736}, "CVE-2015-7564": {"epss_score": 0.02282, "epss_percentile": 0.84256}, "CVE-2015-7565": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2015-7566": {"epss_score": 0.00453, "epss_percentile": 0.63214}, "CVE-2015-7567": {"epss_score": 0.15422, "epss_percentile": 0.94428}, "CVE-2015-7568": {"epss_score": 0.05854, "epss_percentile": 0.90265}, "CVE-2015-7569": {"epss_score": 0.0053, "epss_percentile": 0.66633}, "CVE-2015-7570": {"epss_score": 0.06157, "epss_percentile": 0.90525}, "CVE-2015-7571": {"epss_score": 0.03342, "epss_percentile": 0.86945}, "CVE-2015-7575": {"epss_score": 0.01688, "epss_percentile": 0.81761}, "CVE-2015-7576": {"epss_score": 0.01574, "epss_percentile": 0.81103}, "CVE-2015-7577": {"epss_score": 0.01209, "epss_percentile": 0.78537}, "CVE-2015-7578": {"epss_score": 0.00166, "epss_percentile": 0.3819}, "CVE-2015-7579": {"epss_score": 0.00166, "epss_percentile": 0.3819}, "CVE-2015-7580": {"epss_score": 0.00163, "epss_percentile": 0.37856}, "CVE-2015-7581": {"epss_score": 0.09055, "epss_percentile": 0.92382}, "CVE-2015-7596": {"epss_score": 0.0006, "epss_percentile": 0.19241}, "CVE-2015-7597": {"epss_score": 0.0006, "epss_percentile": 0.19241}, "CVE-2015-7598": {"epss_score": 0.0006, "epss_percentile": 0.19241}, "CVE-2015-7599": {"epss_score": 0.06586, "epss_percentile": 0.90868}, "CVE-2015-7600": {"epss_score": 0.00065, "epss_percentile": 0.20465}, "CVE-2015-7601": {"epss_score": 0.5258, "epss_percentile": 0.97832}, "CVE-2015-7602": {"epss_score": 0.5258, "epss_percentile": 0.97832}, "CVE-2015-7603": {"epss_score": 0.72765, "epss_percentile": 0.98725}, "CVE-2015-7604": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2015-7609": {"epss_score": 0.00459, "epss_percentile": 0.63455}, "CVE-2015-7610": {"epss_score": 0.06222, "epss_percentile": 0.90582}, "CVE-2015-7611": {"epss_score": 0.74922, "epss_percentile": 0.98823}, "CVE-2015-7612": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2015-7613": {"epss_score": 0.00082, "epss_percentile": 0.24484}, "CVE-2015-7614": {"epss_score": 0.00999, "epss_percentile": 0.76479}, "CVE-2015-7615": {"epss_score": 0.01269, "epss_percentile": 0.79043}, "CVE-2015-7616": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-7617": {"epss_score": 0.01269, "epss_percentile": 0.79043}, "CVE-2015-7618": {"epss_score": 0.0109, "epss_percentile": 0.77453}, "CVE-2015-7619": {"epss_score": 0.01776, "epss_percentile": 0.82219}, "CVE-2015-7620": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-7621": {"epss_score": 0.01269, "epss_percentile": 0.79043}, "CVE-2015-7622": {"epss_score": 0.17504, "epss_percentile": 0.94857}, "CVE-2015-7623": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2015-7624": {"epss_score": 0.02138, "epss_percentile": 0.83735}, "CVE-2015-7625": {"epss_score": 0.11151, "epss_percentile": 0.93244}, "CVE-2015-7626": {"epss_score": 0.11151, "epss_percentile": 0.93244}, "CVE-2015-7627": {"epss_score": 0.11151, "epss_percentile": 0.93244}, "CVE-2015-7628": {"epss_score": 0.01385, "epss_percentile": 0.79908}, "CVE-2015-7629": {"epss_score": 0.19895, "epss_percentile": 0.95256}, "CVE-2015-7630": {"epss_score": 0.20928, "epss_percentile": 0.95444}, "CVE-2015-7631": {"epss_score": 0.05675, "epss_percentile": 0.9011}, "CVE-2015-7632": {"epss_score": 0.06986, "epss_percentile": 0.91163}, "CVE-2015-7633": {"epss_score": 0.12412, "epss_percentile": 0.93662}, "CVE-2015-7634": {"epss_score": 0.11151, "epss_percentile": 0.93244}, "CVE-2015-7635": {"epss_score": 0.0968, "epss_percentile": 0.9266}, "CVE-2015-7636": {"epss_score": 0.0968, "epss_percentile": 0.9266}, "CVE-2015-7637": {"epss_score": 0.0968, "epss_percentile": 0.9266}, "CVE-2015-7638": {"epss_score": 0.0968, "epss_percentile": 0.9266}, "CVE-2015-7639": {"epss_score": 0.0968, "epss_percentile": 0.9266}, "CVE-2015-7640": {"epss_score": 0.0968, "epss_percentile": 0.9266}, "CVE-2015-7641": {"epss_score": 0.0968, "epss_percentile": 0.9266}, "CVE-2015-7642": {"epss_score": 0.0968, "epss_percentile": 0.9266}, "CVE-2015-7643": {"epss_score": 0.05675, "epss_percentile": 0.9011}, "CVE-2015-7644": {"epss_score": 0.08652, "epss_percentile": 0.92174}, "CVE-2015-7645": {"epss_score": 0.86981, "epss_percentile": 0.99406}, "CVE-2015-7647": {"epss_score": 0.62654, "epss_percentile": 0.98301}, "CVE-2015-7648": {"epss_score": 0.62654, "epss_percentile": 0.98301}, "CVE-2015-7649": {"epss_score": 0.06397, "epss_percentile": 0.90724}, "CVE-2015-7650": {"epss_score": 0.01026, "epss_percentile": 0.76801}, "CVE-2015-7651": {"epss_score": 0.05831, "epss_percentile": 0.90243}, "CVE-2015-7652": {"epss_score": 0.6216, "epss_percentile": 0.98283}, "CVE-2015-7653": {"epss_score": 0.05831, "epss_percentile": 0.90243}, "CVE-2015-7654": {"epss_score": 0.05831, "epss_percentile": 0.90243}, "CVE-2015-7655": {"epss_score": 0.05831, "epss_percentile": 0.90243}, "CVE-2015-7656": {"epss_score": 0.05831, "epss_percentile": 0.90243}, "CVE-2015-7657": {"epss_score": 0.05831, "epss_percentile": 0.90243}, "CVE-2015-7658": {"epss_score": 0.05831, "epss_percentile": 0.90243}, "CVE-2015-7659": {"epss_score": 0.06178, "epss_percentile": 0.90536}, "CVE-2015-7660": {"epss_score": 0.05831, "epss_percentile": 0.90243}, "CVE-2015-7661": {"epss_score": 0.05831, "epss_percentile": 0.90243}, "CVE-2015-7662": {"epss_score": 0.01794, "epss_percentile": 0.82291}, "CVE-2015-7663": {"epss_score": 0.13603, "epss_percentile": 0.94008}, "CVE-2015-7665": {"epss_score": 0.00476, "epss_percentile": 0.64269}, "CVE-2015-7666": {"epss_score": 0.00587, "epss_percentile": 0.68469}, "CVE-2015-7667": {"epss_score": 0.00419, "epss_percentile": 0.61372}, "CVE-2015-7668": {"epss_score": 0.00228, "epss_percentile": 0.45461}, "CVE-2015-7669": {"epss_score": 0.01553, "epss_percentile": 0.80999}, "CVE-2015-7670": {"epss_score": 0.00887, "epss_percentile": 0.74966}, "CVE-2015-7672": {"epss_score": 0.00032, "epss_percentile": 0.09046}, "CVE-2015-7673": {"epss_score": 0.0139, "epss_percentile": 0.79932}, "CVE-2015-7674": {"epss_score": 0.01625, "epss_percentile": 0.81424}, "CVE-2015-7675": {"epss_score": 8e-05, "epss_percentile": 0.00564}, "CVE-2015-7676": {"epss_score": 0.00018, "epss_percentile": 0.03733}, "CVE-2015-7677": {"epss_score": 0.00021, "epss_percentile": 0.0469}, "CVE-2015-7678": {"epss_score": 0.0001, "epss_percentile": 0.00866}, "CVE-2015-7679": {"epss_score": 0.00012, "epss_percentile": 0.01347}, "CVE-2015-7680": {"epss_score": 0.00026, "epss_percentile": 0.06403}, "CVE-2015-7682": {"epss_score": 0.00362, "epss_percentile": 0.57815}, "CVE-2015-7683": {"epss_score": 0.00319, "epss_percentile": 0.54548}, "CVE-2015-7684": {"epss_score": 0.01223, "epss_percentile": 0.78666}, "CVE-2015-7685": {"epss_score": 0.00146, "epss_percentile": 0.35606}, "CVE-2015-7686": {"epss_score": 0.01026, "epss_percentile": 0.76798}, "CVE-2015-7687": {"epss_score": 0.10142, "epss_percentile": 0.92863}, "CVE-2015-7691": {"epss_score": 0.15161, "epss_percentile": 0.94377}, "CVE-2015-7692": {"epss_score": 0.13208, "epss_percentile": 0.93901}, "CVE-2015-7695": {"epss_score": 0.01232, "epss_percentile": 0.78739}, "CVE-2015-7696": {"epss_score": 0.34377, "epss_percentile": 0.96844}, "CVE-2015-7697": {"epss_score": 0.28496, "epss_percentile": 0.96363}, "CVE-2015-7698": {"epss_score": 0.00913, "epss_percentile": 0.75368}, "CVE-2015-7699": {"epss_score": 0.0133, "epss_percentile": 0.79512}, "CVE-2015-7700": {"epss_score": 0.00509, "epss_percentile": 0.65752}, "CVE-2015-7701": {"epss_score": 0.15961, "epss_percentile": 0.94544}, "CVE-2015-7702": {"epss_score": 0.02392, "epss_percentile": 0.84606}, "CVE-2015-7703": {"epss_score": 0.10078, "epss_percentile": 0.92841}, "CVE-2015-7704": {"epss_score": 0.08509, "epss_percentile": 0.92088}, "CVE-2015-7705": {"epss_score": 0.26017, "epss_percentile": 0.961}, "CVE-2015-7706": {"epss_score": 0.00255, "epss_percentile": 0.48733}, "CVE-2015-7707": {"epss_score": 0.03857, "epss_percentile": 0.87859}, "CVE-2015-7708": {"epss_score": 0.00225, "epss_percentile": 0.45219}, "CVE-2015-7709": {"epss_score": 0.88393, "epss_percentile": 0.9947}, "CVE-2015-7711": {"epss_score": 0.0075, "epss_percentile": 0.72624}, "CVE-2015-7712": {"epss_score": 0.00596, "epss_percentile": 0.6872}, "CVE-2015-7713": {"epss_score": 0.01522, "epss_percentile": 0.80838}, "CVE-2015-7714": {"epss_score": 0.03359, "epss_percentile": 0.86989}, "CVE-2015-7715": {"epss_score": 0.00136, "epss_percentile": 0.34189}, "CVE-2015-7716": {"epss_score": 0.01467, "epss_percentile": 0.80472}, "CVE-2015-7717": {"epss_score": 0.00207, "epss_percentile": 0.43117}, "CVE-2015-7718": {"epss_score": 0.0011, "epss_percentile": 0.30192}, "CVE-2015-7723": {"epss_score": 0.00033, "epss_percentile": 0.09322}, "CVE-2015-7724": {"epss_score": 0.00033, "epss_percentile": 0.09322}, "CVE-2015-7725": {"epss_score": 0.01014, "epss_percentile": 0.7664}, "CVE-2015-7726": {"epss_score": 0.00179, "epss_percentile": 0.39815}, "CVE-2015-7727": {"epss_score": 0.006, "epss_percentile": 0.68828}, "CVE-2015-7728": {"epss_score": 0.00179, "epss_percentile": 0.39815}, "CVE-2015-7729": {"epss_score": 0.00485, "epss_percentile": 0.64735}, "CVE-2015-7730": {"epss_score": 0.01876, "epss_percentile": 0.82657}, "CVE-2015-7731": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2015-7732": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2015-7740": {"epss_score": 0.00019, "epss_percentile": 0.04233}, "CVE-2015-7743": {"epss_score": 0.00317, "epss_percentile": 0.54391}, "CVE-2015-7744": {"epss_score": 0.02661, "epss_percentile": 0.85366}, "CVE-2015-7746": {"epss_score": 0.00641, "epss_percentile": 0.69994}, "CVE-2015-7747": {"epss_score": 0.57372, "epss_percentile": 0.98059}, "CVE-2015-7748": {"epss_score": 0.00516, "epss_percentile": 0.66053}, "CVE-2015-7749": {"epss_score": 0.00473, "epss_percentile": 0.64083}, "CVE-2015-7750": {"epss_score": 0.00456, "epss_percentile": 0.63325}, "CVE-2015-7751": {"epss_score": 0.00043, "epss_percentile": 0.13237}, "CVE-2015-7752": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2015-7754": {"epss_score": 0.01223, "epss_percentile": 0.78668}, "CVE-2015-7755": {"epss_score": 0.88724, "epss_percentile": 0.99486}, "CVE-2015-7756": {"epss_score": 0.00412, "epss_percentile": 0.60941}, "CVE-2015-7758": {"epss_score": 0.00048, "epss_percentile": 0.14934}, "CVE-2015-7759": {"epss_score": 0.00752, "epss_percentile": 0.72654}, "CVE-2015-7760": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2015-7761": {"epss_score": 0.00297, "epss_percentile": 0.5269}, "CVE-2015-7762": {"epss_score": 0.00472, "epss_percentile": 0.64035}, "CVE-2015-7763": {"epss_score": 0.00472, "epss_percentile": 0.64035}, "CVE-2015-7764": {"epss_score": 0.00345, "epss_percentile": 0.56578}, "CVE-2015-7765": {"epss_score": 0.80848, "epss_percentile": 0.9911}, "CVE-2015-7766": {"epss_score": 0.77548, "epss_percentile": 0.98941}, "CVE-2015-7767": {"epss_score": 0.05815, "epss_percentile": 0.90229}, "CVE-2015-7768": {"epss_score": 0.68408, "epss_percentile": 0.98546}, "CVE-2015-7769": {"epss_score": 0.00594, "epss_percentile": 0.68676}, "CVE-2015-7770": {"epss_score": 0.02454, "epss_percentile": 0.84793}, "CVE-2015-7771": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-7772": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-7773": {"epss_score": 0.00442, "epss_percentile": 0.62707}, "CVE-2015-7774": {"epss_score": 0.00621, "epss_percentile": 0.69474}, "CVE-2015-7775": {"epss_score": 0.00222, "epss_percentile": 0.4475}, "CVE-2015-7776": {"epss_score": 0.00559, "epss_percentile": 0.67628}, "CVE-2015-7777": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-7778": {"epss_score": 0.00667, "epss_percentile": 0.70699}, "CVE-2015-7780": {"epss_score": 0.36216, "epss_percentile": 0.96961}, "CVE-2015-7781": {"epss_score": 0.06722, "epss_percentile": 0.90968}, "CVE-2015-7782": {"epss_score": 0.00236, "epss_percentile": 0.46448}, "CVE-2015-7783": {"epss_score": 0.00322, "epss_percentile": 0.54754}, "CVE-2015-7784": {"epss_score": 0.00359, "epss_percentile": 0.57607}, "CVE-2015-7785": {"epss_score": 0.00301, "epss_percentile": 0.53042}, "CVE-2015-7786": {"epss_score": 0.00309, "epss_percentile": 0.537}, "CVE-2015-7787": {"epss_score": 0.00139, "epss_percentile": 0.34617}, "CVE-2015-7788": {"epss_score": 0.01244, "epss_percentile": 0.78836}, "CVE-2015-7789": {"epss_score": 0.00223, "epss_percentile": 0.44866}, "CVE-2015-7790": {"epss_score": 0.00322, "epss_percentile": 0.54754}, "CVE-2015-7791": {"epss_score": 0.00313, "epss_percentile": 0.54029}, "CVE-2015-7792": {"epss_score": 0.03026, "epss_percentile": 0.8624}, "CVE-2015-7793": {"epss_score": 0.00546, "epss_percentile": 0.67208}, "CVE-2015-7794": {"epss_score": 0.00546, "epss_percentile": 0.67208}, "CVE-2015-7795": {"epss_score": 0.00515, "epss_percentile": 0.66011}, "CVE-2015-7796": {"epss_score": 0.00515, "epss_percentile": 0.66011}, "CVE-2015-7797": {"epss_score": 0.00515, "epss_percentile": 0.66011}, "CVE-2015-7798": {"epss_score": 0.00515, "epss_percentile": 0.66011}, "CVE-2015-7799": {"epss_score": 0.00103, "epss_percentile": 0.29013}, "CVE-2015-7801": {"epss_score": 0.02392, "epss_percentile": 0.84604}, "CVE-2015-7802": {"epss_score": 0.00418, "epss_percentile": 0.61283}, "CVE-2015-7803": {"epss_score": 0.22702, "epss_percentile": 0.9567}, "CVE-2015-7804": {"epss_score": 0.11431, "epss_percentile": 0.9335}, "CVE-2015-7805": {"epss_score": 0.47656, "epss_percentile": 0.97595}, "CVE-2015-7806": {"epss_score": 0.13872, "epss_percentile": 0.94081}, "CVE-2015-7808": {"epss_score": 0.79043, "epss_percentile": 0.99017}, "CVE-2015-7809": {"epss_score": 0.02041, "epss_percentile": 0.83367}, "CVE-2015-7810": {"epss_score": 0.0011, "epss_percentile": 0.30076}, "CVE-2015-7812": {"epss_score": 0.00076, "epss_percentile": 0.23099}, "CVE-2015-7813": {"epss_score": 0.00109, "epss_percentile": 0.29972}, "CVE-2015-7814": {"epss_score": 0.00081, "epss_percentile": 0.24394}, "CVE-2015-7815": {"epss_score": 0.01351, "epss_percentile": 0.7968}, "CVE-2015-7816": {"epss_score": 0.00423, "epss_percentile": 0.61616}, "CVE-2015-7817": {"epss_score": 0.00207, "epss_percentile": 0.43157}, "CVE-2015-7818": {"epss_score": 0.00046, "epss_percentile": 0.14273}, "CVE-2015-7819": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2015-7820": {"epss_score": 0.00207, "epss_percentile": 0.43157}, "CVE-2015-7822": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2015-7823": {"epss_score": 0.1267, "epss_percentile": 0.93745}, "CVE-2015-7824": {"epss_score": 0.00237, "epss_percentile": 0.46462}, "CVE-2015-7825": {"epss_score": 0.0031, "epss_percentile": 0.53791}, "CVE-2015-7826": {"epss_score": 0.00429, "epss_percentile": 0.61978}, "CVE-2015-7827": {"epss_score": 0.00435, "epss_percentile": 0.6235}, "CVE-2015-7828": {"epss_score": 0.03556, "epss_percentile": 0.87348}, "CVE-2015-7829": {"epss_score": 0.00399, "epss_percentile": 0.60101}, "CVE-2015-7830": {"epss_score": 0.00574, "epss_percentile": 0.68079}, "CVE-2015-7831": {"epss_score": 0.00345, "epss_percentile": 0.56597}, "CVE-2015-7833": {"epss_score": 0.00178, "epss_percentile": 0.39647}, "CVE-2015-7834": {"epss_score": 0.00191, "epss_percentile": 0.41216}, "CVE-2015-7835": {"epss_score": 0.00122, "epss_percentile": 0.32115}, "CVE-2015-7836": {"epss_score": 0.00267, "epss_percentile": 0.49992}, "CVE-2015-7837": {"epss_score": 0.00073, "epss_percentile": 0.22587}, "CVE-2015-7838": {"epss_score": 0.16417, "epss_percentile": 0.94657}, "CVE-2015-7839": {"epss_score": 0.08611, "epss_percentile": 0.92151}, "CVE-2015-7840": {"epss_score": 0.19521, "epss_percentile": 0.95199}, "CVE-2015-7841": {"epss_score": 0.02006, "epss_percentile": 0.83233}, "CVE-2015-7842": {"epss_score": 0.00244, "epss_percentile": 0.47598}, "CVE-2015-7843": {"epss_score": 0.00146, "epss_percentile": 0.35591}, "CVE-2015-7844": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2015-7845": {"epss_score": 0.00219, "epss_percentile": 0.44491}, "CVE-2015-7846": {"epss_score": 0.00034, "epss_percentile": 0.09618}, "CVE-2015-7847": {"epss_score": 0.00021, "epss_percentile": 0.04924}, "CVE-2015-7848": {"epss_score": 0.01262, "epss_percentile": 0.78985}, "CVE-2015-7849": {"epss_score": 0.0386, "epss_percentile": 0.87864}, "CVE-2015-7850": {"epss_score": 0.04346, "epss_percentile": 0.88576}, "CVE-2015-7851": {"epss_score": 0.00532, "epss_percentile": 0.66703}, "CVE-2015-7852": {"epss_score": 0.04843, "epss_percentile": 0.89203}, "CVE-2015-7853": {"epss_score": 0.34954, "epss_percentile": 0.96879}, "CVE-2015-7854": {"epss_score": 0.038, "epss_percentile": 0.87741}, "CVE-2015-7855": {"epss_score": 0.60116, "epss_percentile": 0.98193}, "CVE-2015-7856": {"epss_score": 0.01785, "epss_percentile": 0.82253}, "CVE-2015-7857": {"epss_score": 0.85076, "epss_percentile": 0.99315}, "CVE-2015-7858": {"epss_score": 0.86753, "epss_percentile": 0.99395}, "CVE-2015-7859": {"epss_score": 0.00165, "epss_percentile": 0.38044}, "CVE-2015-7860": {"epss_score": 0.15734, "epss_percentile": 0.94495}, "CVE-2015-7861": {"epss_score": 0.09952, "epss_percentile": 0.92788}, "CVE-2015-7862": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2015-7863": {"epss_score": 0.00228, "epss_percentile": 0.45475}, "CVE-2015-7865": {"epss_score": 0.01443, "epss_percentile": 0.80313}, "CVE-2015-7866": {"epss_score": 0.00073, "epss_percentile": 0.22493}, "CVE-2015-7869": {"epss_score": 0.00057, "epss_percentile": 0.17984}, "CVE-2015-7871": {"epss_score": 0.7962, "epss_percentile": 0.9905}, "CVE-2015-7872": {"epss_score": 0.00057, "epss_percentile": 0.18185}, "CVE-2015-7873": {"epss_score": 0.00625, "epss_percentile": 0.69594}, "CVE-2015-7874": {"epss_score": 0.08442, "epss_percentile": 0.92053}, "CVE-2015-7875": {"epss_score": 0.00273, "epss_percentile": 0.50423}, "CVE-2015-7876": {"epss_score": 0.00555, "epss_percentile": 0.67477}, "CVE-2015-7877": {"epss_score": 0.00614, "epss_percentile": 0.69273}, "CVE-2015-7878": {"epss_score": 0.00142, "epss_percentile": 0.34999}, "CVE-2015-7879": {"epss_score": 0.0041, "epss_percentile": 0.60836}, "CVE-2015-7880": {"epss_score": 0.00065, "epss_percentile": 0.20522}, "CVE-2015-7881": {"epss_score": 0.00127, "epss_percentile": 0.32836}, "CVE-2015-7882": {"epss_score": 0.00951, "epss_percentile": 0.75862}, "CVE-2015-7884": {"epss_score": 0.00021, "epss_percentile": 0.04726}, "CVE-2015-7885": {"epss_score": 0.00077, "epss_percentile": 0.23465}, "CVE-2015-7886": {"epss_score": 0.00392, "epss_percentile": 0.59661}, "CVE-2015-7887": {"epss_score": 0.0014, "epss_percentile": 0.34734}, "CVE-2015-7888": {"epss_score": 0.13885, "epss_percentile": 0.94085}, "CVE-2015-7889": {"epss_score": 0.02446, "epss_percentile": 0.84767}, "CVE-2015-7890": {"epss_score": 0.00188, "epss_percentile": 0.40908}, "CVE-2015-7891": {"epss_score": 0.00172, "epss_percentile": 0.38934}, "CVE-2015-7892": {"epss_score": 0.00386, "epss_percentile": 0.59282}, "CVE-2015-7893": {"epss_score": 0.13648, "epss_percentile": 0.94021}, "CVE-2015-7894": {"epss_score": 0.04828, "epss_percentile": 0.89188}, "CVE-2015-7895": {"epss_score": 0.00288, "epss_percentile": 0.51949}, "CVE-2015-7896": {"epss_score": 0.07163, "epss_percentile": 0.91293}, "CVE-2015-7897": {"epss_score": 0.04509, "epss_percentile": 0.88779}, "CVE-2015-7898": {"epss_score": 0.00161, "epss_percentile": 0.37528}, "CVE-2015-7899": {"epss_score": 0.00077, "epss_percentile": 0.23447}, "CVE-2015-7900": {"epss_score": 0.09856, "epss_percentile": 0.92738}, "CVE-2015-7901": {"epss_score": 0.05496, "epss_percentile": 0.89933}, "CVE-2015-7902": {"epss_score": 0.09487, "epss_percentile": 0.92569}, "CVE-2015-7903": {"epss_score": 0.00491, "epss_percentile": 0.64961}, "CVE-2015-7904": {"epss_score": 0.04883, "epss_percentile": 0.89251}, "CVE-2015-7905": {"epss_score": 0.12786, "epss_percentile": 0.93772}, "CVE-2015-7906": {"epss_score": 0.00384, "epss_percentile": 0.59152}, "CVE-2015-7907": {"epss_score": 0.00296, "epss_percentile": 0.52541}, "CVE-2015-7908": {"epss_score": 0.00291, "epss_percentile": 0.5221}, "CVE-2015-7909": {"epss_score": 0.00388, "epss_percentile": 0.59343}, "CVE-2015-7910": {"epss_score": 0.00265, "epss_percentile": 0.49812}, "CVE-2015-7911": {"epss_score": 0.0069, "epss_percentile": 0.71249}, "CVE-2015-7912": {"epss_score": 0.00536, "epss_percentile": 0.66866}, "CVE-2015-7913": {"epss_score": 0.00046, "epss_percentile": 0.14127}, "CVE-2015-7914": {"epss_score": 0.00777, "epss_percentile": 0.73109}, "CVE-2015-7915": {"epss_score": 0.00756, "epss_percentile": 0.72747}, "CVE-2015-7916": {"epss_score": 0.00163, "epss_percentile": 0.37834}, "CVE-2015-7917": {"epss_score": 0.00054, "epss_percentile": 0.17091}, "CVE-2015-7918": {"epss_score": 0.1286, "epss_percentile": 0.93803}, "CVE-2015-7919": {"epss_score": 0.00568, "epss_percentile": 0.6788}, "CVE-2015-7921": {"epss_score": 0.00405, "epss_percentile": 0.60462}, "CVE-2015-7923": {"epss_score": 0.00237, "epss_percentile": 0.4669}, "CVE-2015-7924": {"epss_score": 0.03042, "epss_percentile": 0.86275}, "CVE-2015-7925": {"epss_score": 0.00211, "epss_percentile": 0.4368}, "CVE-2015-7926": {"epss_score": 0.00911, "epss_percentile": 0.75353}, "CVE-2015-7927": {"epss_score": 0.00538, "epss_percentile": 0.66937}, "CVE-2015-7928": {"epss_score": 0.03741, "epss_percentile": 0.87657}, "CVE-2015-7929": {"epss_score": 0.01826, "epss_percentile": 0.82433}, "CVE-2015-7930": {"epss_score": 0.00922, "epss_percentile": 0.75487}, "CVE-2015-7931": {"epss_score": 0.00172, "epss_percentile": 0.38965}, "CVE-2015-7932": {"epss_score": 0.00301, "epss_percentile": 0.53069}, "CVE-2015-7934": {"epss_score": 0.00266, "epss_percentile": 0.49911}, "CVE-2015-7935": {"epss_score": 0.00731, "epss_percentile": 0.72165}, "CVE-2015-7936": {"epss_score": 0.00163, "epss_percentile": 0.37764}, "CVE-2015-7937": {"epss_score": 0.02933, "epss_percentile": 0.86019}, "CVE-2015-7938": {"epss_score": 0.01332, "epss_percentile": 0.79525}, "CVE-2015-7939": {"epss_score": 0.01068, "epss_percentile": 0.77234}, "CVE-2015-7940": {"epss_score": 0.01019, "epss_percentile": 0.76724}, "CVE-2015-7941": {"epss_score": 0.01248, "epss_percentile": 0.78867}, "CVE-2015-7942": {"epss_score": 0.01457, "epss_percentile": 0.804}, "CVE-2015-7943": {"epss_score": 0.00674, "epss_percentile": 0.70859}, "CVE-2015-7944": {"epss_score": 0.18955, "epss_percentile": 0.95102}, "CVE-2015-7945": {"epss_score": 0.13554, "epss_percentile": 0.93995}, "CVE-2015-7946": {"epss_score": 0.00064, "epss_percentile": 0.20301}, "CVE-2015-7961": {"epss_score": 0.0006, "epss_percentile": 0.19241}, "CVE-2015-7962": {"epss_score": 0.0006, "epss_percentile": 0.19241}, "CVE-2015-7963": {"epss_score": 0.0006, "epss_percentile": 0.19241}, "CVE-2015-7964": {"epss_score": 0.0006, "epss_percentile": 0.19241}, "CVE-2015-7965": {"epss_score": 0.0006, "epss_percentile": 0.19241}, "CVE-2015-7966": {"epss_score": 0.0006, "epss_percentile": 0.19241}, "CVE-2015-7967": {"epss_score": 0.0006, "epss_percentile": 0.19241}, "CVE-2015-7968": {"epss_score": 0.00169, "epss_percentile": 0.38639}, "CVE-2015-7969": {"epss_score": 0.00093, "epss_percentile": 0.26737}, "CVE-2015-7970": {"epss_score": 0.00121, "epss_percentile": 0.31941}, "CVE-2015-7971": {"epss_score": 0.00089, "epss_percentile": 0.25796}, "CVE-2015-7972": {"epss_score": 0.00092, "epss_percentile": 0.26556}, "CVE-2015-7973": {"epss_score": 0.05731, "epss_percentile": 0.90161}, "CVE-2015-7974": {"epss_score": 0.05314, "epss_percentile": 0.8972}, "CVE-2015-7975": {"epss_score": 0.00426, "epss_percentile": 0.61746}, "CVE-2015-7976": {"epss_score": 0.03079, "epss_percentile": 0.86368}, "CVE-2015-7977": {"epss_score": 0.10207, "epss_percentile": 0.92893}, "CVE-2015-7978": {"epss_score": 0.29426, "epss_percentile": 0.96441}, "CVE-2015-7979": {"epss_score": 0.19215, "epss_percentile": 0.9515}, "CVE-2015-7980": {"epss_score": 0.00696, "epss_percentile": 0.71383}, "CVE-2015-7981": {"epss_score": 0.00934, "epss_percentile": 0.75648}, "CVE-2015-7984": {"epss_score": 0.01484, "epss_percentile": 0.80591}, "CVE-2015-7985": {"epss_score": 0.00141, "epss_percentile": 0.34823}, "CVE-2015-7986": {"epss_score": 0.25849, "epss_percentile": 0.96079}, "CVE-2015-7987": {"epss_score": 0.03085, "epss_percentile": 0.86384}, "CVE-2015-7988": {"epss_score": 0.02603, "epss_percentile": 0.85214}, "CVE-2015-7989": {"epss_score": 0.0029, "epss_percentile": 0.52132}, "CVE-2015-7990": {"epss_score": 0.00043, "epss_percentile": 0.13233}, "CVE-2015-7991": {"epss_score": 0.00211, "epss_percentile": 0.43616}, "CVE-2015-7992": {"epss_score": 0.0038, "epss_percentile": 0.58934}, "CVE-2015-7993": {"epss_score": 0.00561, "epss_percentile": 0.67658}, "CVE-2015-7994": {"epss_score": 0.02446, "epss_percentile": 0.84768}, "CVE-2015-7995": {"epss_score": 0.03037, "epss_percentile": 0.86265}, "CVE-2015-7996": {"epss_score": 0.00293, "epss_percentile": 0.52347}, "CVE-2015-7997": {"epss_score": 0.00293, "epss_percentile": 0.52338}, "CVE-2015-7998": {"epss_score": 0.00293, "epss_percentile": 0.52347}, "CVE-2015-7999": {"epss_score": 0.0047, "epss_percentile": 0.63968}, "CVE-2015-8000": {"epss_score": 0.67131, "epss_percentile": 0.98496}, "CVE-2015-8001": {"epss_score": 0.00324, "epss_percentile": 0.54944}, "CVE-2015-8002": {"epss_score": 0.00522, "epss_percentile": 0.66251}, "CVE-2015-8003": {"epss_score": 0.00522, "epss_percentile": 0.66251}, "CVE-2015-8004": {"epss_score": 0.00159, "epss_percentile": 0.3742}, "CVE-2015-8005": {"epss_score": 0.00253, "epss_percentile": 0.48484}, "CVE-2015-8006": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2015-8007": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2015-8008": {"epss_score": 0.00548, "epss_percentile": 0.6727}, "CVE-2015-8009": {"epss_score": 0.00344, "epss_percentile": 0.56541}, "CVE-2015-8010": {"epss_score": 0.00354, "epss_percentile": 0.57249}, "CVE-2015-8011": {"epss_score": 0.04146, "epss_percentile": 0.88314}, "CVE-2015-8012": {"epss_score": 0.00782, "epss_percentile": 0.73204}, "CVE-2015-8013": {"epss_score": 0.01077, "epss_percentile": 0.77339}, "CVE-2015-8019": {"epss_score": 0.00048, "epss_percentile": 0.14941}, "CVE-2015-8020": {"epss_score": 0.00247, "epss_percentile": 0.47841}, "CVE-2015-8021": {"epss_score": 0.00112, "epss_percentile": 0.30423}, "CVE-2015-8022": {"epss_score": 0.00536, "epss_percentile": 0.66884}, "CVE-2015-8023": {"epss_score": 0.00799, "epss_percentile": 0.7353}, "CVE-2015-8024": {"epss_score": 0.0145, "epss_percentile": 0.80355}, "CVE-2015-8025": {"epss_score": 0.00058, "epss_percentile": 0.184}, "CVE-2015-8026": {"epss_score": 0.0169, "epss_percentile": 0.81774}, "CVE-2015-8027": {"epss_score": 0.015, "epss_percentile": 0.80709}, "CVE-2015-8028": {"epss_score": 0.12423, "epss_percentile": 0.93666}, "CVE-2015-8029": {"epss_score": 0.02998, "epss_percentile": 0.86158}, "CVE-2015-8030": {"epss_score": 0.03128, "epss_percentile": 0.8646}, "CVE-2015-8031": {"epss_score": 0.0061, "epss_percentile": 0.6916}, "CVE-2015-8032": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2015-8033": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2015-8034": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2015-8035": {"epss_score": 0.01051, "epss_percentile": 0.77085}, "CVE-2015-8036": {"epss_score": 0.00915, "epss_percentile": 0.7541}, "CVE-2015-8037": {"epss_score": 0.02063, "epss_percentile": 0.83448}, "CVE-2015-8038": {"epss_score": 0.02063, "epss_percentile": 0.83448}, "CVE-2015-8039": {"epss_score": 0.03714, "epss_percentile": 0.87611}, "CVE-2015-8040": {"epss_score": 0.01157, "epss_percentile": 0.78115}, "CVE-2015-8041": {"epss_score": 0.01495, "epss_percentile": 0.80659}, "CVE-2015-8042": {"epss_score": 0.05831, "epss_percentile": 0.90243}, "CVE-2015-8043": {"epss_score": 0.7097, "epss_percentile": 0.98648}, "CVE-2015-8044": {"epss_score": 0.73093, "epss_percentile": 0.98736}, "CVE-2015-8045": {"epss_score": 0.07334, "epss_percentile": 0.91416}, "CVE-2015-8046": {"epss_score": 0.67446, "epss_percentile": 0.98507}, "CVE-2015-8047": {"epss_score": 0.07334, "epss_percentile": 0.91416}, "CVE-2015-8048": {"epss_score": 0.52388, "epss_percentile": 0.97823}, "CVE-2015-8049": {"epss_score": 0.06343, "epss_percentile": 0.90683}, "CVE-2015-8050": {"epss_score": 0.06343, "epss_percentile": 0.90683}, "CVE-2015-8051": {"epss_score": 0.04583, "epss_percentile": 0.88881}, "CVE-2015-8052": {"epss_score": 0.00752, "epss_percentile": 0.72667}, "CVE-2015-8053": {"epss_score": 0.00752, "epss_percentile": 0.72667}, "CVE-2015-8055": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8056": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8057": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8058": {"epss_score": 0.06213, "epss_percentile": 0.90572}, "CVE-2015-8059": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8060": {"epss_score": 0.07334, "epss_percentile": 0.91416}, "CVE-2015-8061": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8062": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8063": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8064": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8065": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8066": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8067": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8068": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8069": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8070": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8071": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8072": {"epss_score": 0.03758, "epss_percentile": 0.87685}, "CVE-2015-8073": {"epss_score": 0.03758, "epss_percentile": 0.87685}, "CVE-2015-8074": {"epss_score": 0.00061, "epss_percentile": 0.19411}, "CVE-2015-8076": {"epss_score": 0.02628, "epss_percentile": 0.85274}, "CVE-2015-8077": {"epss_score": 0.03429, "epss_percentile": 0.87121}, "CVE-2015-8078": {"epss_score": 0.00814, "epss_percentile": 0.73775}, "CVE-2015-8079": {"epss_score": 0.00235, "epss_percentile": 0.46237}, "CVE-2015-8080": {"epss_score": 0.0224, "epss_percentile": 0.84111}, "CVE-2015-8081": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2015-8082": {"epss_score": 0.00499, "epss_percentile": 0.6527}, "CVE-2015-8083": {"epss_score": 0.00227, "epss_percentile": 0.45437}, "CVE-2015-8084": {"epss_score": 0.00357, "epss_percentile": 0.5748}, "CVE-2015-8085": {"epss_score": 0.00038, "epss_percentile": 0.11187}, "CVE-2015-8086": {"epss_score": 0.00027, "epss_percentile": 0.06846}, "CVE-2015-8087": {"epss_score": 0.00219, "epss_percentile": 0.44491}, "CVE-2015-8088": {"epss_score": 0.00801, "epss_percentile": 0.73574}, "CVE-2015-8089": {"epss_score": 0.00024, "epss_percentile": 0.05773}, "CVE-2015-8090": {"epss_score": 0.00141, "epss_percentile": 0.34909}, "CVE-2015-8094": {"epss_score": 0.00462, "epss_percentile": 0.63614}, "CVE-2015-8095": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2015-8096": {"epss_score": 0.10251, "epss_percentile": 0.92913}, "CVE-2015-8098": {"epss_score": 0.10934, "epss_percentile": 0.93163}, "CVE-2015-8099": {"epss_score": 0.01048, "epss_percentile": 0.77056}, "CVE-2015-8100": {"epss_score": 0.00135, "epss_percentile": 0.33982}, "CVE-2015-8103": {"epss_score": 0.90824, "epss_percentile": 0.99602}, "CVE-2015-8104": {"epss_score": 0.00346, "epss_percentile": 0.56635}, "CVE-2015-8105": {"epss_score": 0.0018, "epss_percentile": 0.39898}, "CVE-2015-8106": {"epss_score": 0.00877, "epss_percentile": 0.74808}, "CVE-2015-8107": {"epss_score": 0.01341, "epss_percentile": 0.79588}, "CVE-2015-8108": {"epss_score": 0.0023, "epss_percentile": 0.45762}, "CVE-2015-8109": {"epss_score": 0.00043, "epss_percentile": 0.12953}, "CVE-2015-8110": {"epss_score": 0.00051, "epss_percentile": 0.16061}, "CVE-2015-8113": {"epss_score": 0.00236, "epss_percentile": 0.4638}, "CVE-2015-8124": {"epss_score": 0.00247, "epss_percentile": 0.47869}, "CVE-2015-8125": {"epss_score": 0.01008, "epss_percentile": 0.76568}, "CVE-2015-8126": {"epss_score": 0.04949, "epss_percentile": 0.89321}, "CVE-2015-8131": {"epss_score": 0.00116, "epss_percentile": 0.31043}, "CVE-2015-8138": {"epss_score": 0.0552, "epss_percentile": 0.89957}, "CVE-2015-8139": {"epss_score": 0.30064, "epss_percentile": 0.96501}, "CVE-2015-8140": {"epss_score": 0.29857, "epss_percentile": 0.96481}, "CVE-2015-8148": {"epss_score": 0.00443, "epss_percentile": 0.62789}, "CVE-2015-8149": {"epss_score": 0.01164, "epss_percentile": 0.78164}, "CVE-2015-8150": {"epss_score": 0.00176, "epss_percentile": 0.39473}, "CVE-2015-8151": {"epss_score": 0.01634, "epss_percentile": 0.81468}, "CVE-2015-8152": {"epss_score": 0.00794, "epss_percentile": 0.73439}, "CVE-2015-8153": {"epss_score": 0.0087, "epss_percentile": 0.74704}, "CVE-2015-8154": {"epss_score": 0.0168, "epss_percentile": 0.81725}, "CVE-2015-8156": {"epss_score": 0.00125, "epss_percentile": 0.32509}, "CVE-2015-8157": {"epss_score": 0.00405, "epss_percentile": 0.60488}, "CVE-2015-8158": {"epss_score": 0.15005, "epss_percentile": 0.94339}, "CVE-2015-8212": {"epss_score": 0.02154, "epss_percentile": 0.83797}, "CVE-2015-8213": {"epss_score": 0.03006, "epss_percentile": 0.86183}, "CVE-2015-8214": {"epss_score": 0.01347, "epss_percentile": 0.79648}, "CVE-2015-8215": {"epss_score": 0.06239, "epss_percentile": 0.90591}, "CVE-2015-8216": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2015-8217": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2015-8218": {"epss_score": 0.0043, "epss_percentile": 0.62018}, "CVE-2015-8219": {"epss_score": 0.0046, "epss_percentile": 0.6351}, "CVE-2015-8220": {"epss_score": 0.56462, "epss_percentile": 0.98023}, "CVE-2015-8221": {"epss_score": 0.24929, "epss_percentile": 0.95968}, "CVE-2015-8222": {"epss_score": 0.00116, "epss_percentile": 0.31099}, "CVE-2015-8223": {"epss_score": 0.00017, "epss_percentile": 0.03199}, "CVE-2015-8224": {"epss_score": 0.00106, "epss_percentile": 0.29562}, "CVE-2015-8225": {"epss_score": 0.00119, "epss_percentile": 0.31635}, "CVE-2015-8226": {"epss_score": 0.00119, "epss_percentile": 0.31635}, "CVE-2015-8227": {"epss_score": 0.0016, "epss_percentile": 0.37494}, "CVE-2015-8228": {"epss_score": 0.00543, "epss_percentile": 0.67103}, "CVE-2015-8229": {"epss_score": 0.00186, "epss_percentile": 0.40667}, "CVE-2015-8230": {"epss_score": 0.00281, "epss_percentile": 0.51134}, "CVE-2015-8231": {"epss_score": 0.00281, "epss_percentile": 0.51134}, "CVE-2015-8232": {"epss_score": 0.0025, "epss_percentile": 0.48206}, "CVE-2015-8233": {"epss_score": 0.00315, "epss_percentile": 0.54162}, "CVE-2015-8234": {"epss_score": 0.00247, "epss_percentile": 0.47834}, "CVE-2015-8235": {"epss_score": 0.03391, "epss_percentile": 0.87051}, "CVE-2015-8236": {"epss_score": 0.06019, "epss_percentile": 0.90414}, "CVE-2015-8239": {"epss_score": 0.00876, "epss_percentile": 0.7479}, "CVE-2015-8240": {"epss_score": 0.01195, "epss_percentile": 0.78426}, "CVE-2015-8241": {"epss_score": 0.01748, "epss_percentile": 0.82083}, "CVE-2015-8242": {"epss_score": 0.01661, "epss_percentile": 0.81622}, "CVE-2015-8247": {"epss_score": 0.00254, "epss_percentile": 0.4862}, "CVE-2015-8249": {"epss_score": 0.80165, "epss_percentile": 0.99073}, "CVE-2015-8251": {"epss_score": 0.00186, "epss_percentile": 0.40612}, "CVE-2015-8252": {"epss_score": 0.00586, "epss_percentile": 0.68455}, "CVE-2015-8253": {"epss_score": 0.00303, "epss_percentile": 0.53178}, "CVE-2015-8254": {"epss_score": 0.00108, "epss_percentile": 0.29857}, "CVE-2015-8255": {"epss_score": 0.00431, "epss_percentile": 0.62061}, "CVE-2015-8256": {"epss_score": 0.0691, "epss_percentile": 0.91112}, "CVE-2015-8257": {"epss_score": 0.19127, "epss_percentile": 0.95135}, "CVE-2015-8258": {"epss_score": 0.19114, "epss_percentile": 0.95131}, "CVE-2015-8261": {"epss_score": 0.04357, "epss_percentile": 0.88592}, "CVE-2015-8262": {"epss_score": 0.00526, "epss_percentile": 0.66405}, "CVE-2015-8263": {"epss_score": 0.00526, "epss_percentile": 0.66405}, "CVE-2015-8264": {"epss_score": 0.00672, "epss_percentile": 0.70818}, "CVE-2015-8265": {"epss_score": 0.00569, "epss_percentile": 0.67917}, "CVE-2015-8267": {"epss_score": 0.02216, "epss_percentile": 0.84036}, "CVE-2015-8268": {"epss_score": 0.00911, "epss_percentile": 0.75325}, "CVE-2015-8269": {"epss_score": 0.00791, "epss_percentile": 0.7338}, "CVE-2015-8270": {"epss_score": 0.00762, "epss_percentile": 0.72832}, "CVE-2015-8271": {"epss_score": 0.00966, "epss_percentile": 0.76052}, "CVE-2015-8272": {"epss_score": 0.00786, "epss_percentile": 0.73292}, "CVE-2015-8275": {"epss_score": 0.00159, "epss_percentile": 0.37369}, "CVE-2015-8276": {"epss_score": 0.00222, "epss_percentile": 0.44734}, "CVE-2015-8277": {"epss_score": 0.80474, "epss_percentile": 0.9909}, "CVE-2015-8279": {"epss_score": 0.67934, "epss_percentile": 0.98526}, "CVE-2015-8280": {"epss_score": 0.00758, "epss_percentile": 0.72764}, "CVE-2015-8281": {"epss_score": 0.00081, "epss_percentile": 0.24224}, "CVE-2015-8282": {"epss_score": 0.2556, "epss_percentile": 0.96043}, "CVE-2015-8283": {"epss_score": 0.14445, "epss_percentile": 0.94212}, "CVE-2015-8284": {"epss_score": 0.05916, "epss_percentile": 0.90318}, "CVE-2015-8285": {"epss_score": 0.10326, "epss_percentile": 0.92946}, "CVE-2015-8286": {"epss_score": 0.10807, "epss_percentile": 0.9311}, "CVE-2015-8287": {"epss_score": 0.00366, "epss_percentile": 0.58062}, "CVE-2015-8288": {"epss_score": 0.00586, "epss_percentile": 0.68455}, "CVE-2015-8289": {"epss_score": 0.00795, "epss_percentile": 0.7347}, "CVE-2015-8298": {"epss_score": 0.02371, "epss_percentile": 0.84527}, "CVE-2015-8299": {"epss_score": 0.12453, "epss_percentile": 0.93676}, "CVE-2015-8300": {"epss_score": 0.00041, "epss_percentile": 0.1234}, "CVE-2015-8303": {"epss_score": 0.00024, "epss_percentile": 0.05789}, "CVE-2015-8304": {"epss_score": 0.00138, "epss_percentile": 0.34386}, "CVE-2015-8305": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2015-8306": {"epss_score": 0.00113, "epss_percentile": 0.30646}, "CVE-2015-8307": {"epss_score": 0.0005, "epss_percentile": 0.15744}, "CVE-2015-8308": {"epss_score": 0.00034, "epss_percentile": 0.09655}, "CVE-2015-8309": {"epss_score": 0.06564, "epss_percentile": 0.9085}, "CVE-2015-8310": {"epss_score": 0.00237, "epss_percentile": 0.46653}, "CVE-2015-8312": {"epss_score": 0.0004, "epss_percentile": 0.11977}, "CVE-2015-8313": {"epss_score": 0.01064, "epss_percentile": 0.77202}, "CVE-2015-8314": {"epss_score": 0.00139, "epss_percentile": 0.34611}, "CVE-2015-8315": {"epss_score": 0.00944, "epss_percentile": 0.75794}, "CVE-2015-8316": {"epss_score": 0.00588, "epss_percentile": 0.68504}, "CVE-2015-8317": {"epss_score": 0.00327, "epss_percentile": 0.55114}, "CVE-2015-8318": {"epss_score": 0.00062, "epss_percentile": 0.1964}, "CVE-2015-8319": {"epss_score": 0.00062, "epss_percentile": 0.1964}, "CVE-2015-8320": {"epss_score": 0.02562, "epss_percentile": 0.85109}, "CVE-2015-8322": {"epss_score": 0.02259, "epss_percentile": 0.8418}, "CVE-2015-8324": {"epss_score": 0.00079, "epss_percentile": 0.23916}, "CVE-2015-8325": {"epss_score": 0.00112, "epss_percentile": 0.30413}, "CVE-2015-8326": {"epss_score": 0.00062, "epss_percentile": 0.19575}, "CVE-2015-8327": {"epss_score": 0.2071, "epss_percentile": 0.95405}, "CVE-2015-8328": {"epss_score": 0.00049, "epss_percentile": 0.15323}, "CVE-2015-8329": {"epss_score": 0.00151, "epss_percentile": 0.36258}, "CVE-2015-8330": {"epss_score": 0.03354, "epss_percentile": 0.86968}, "CVE-2015-8331": {"epss_score": 0.00133, "epss_percentile": 0.33726}, "CVE-2015-8332": {"epss_score": 0.00245, "epss_percentile": 0.47628}, "CVE-2015-8333": {"epss_score": 0.00387, "epss_percentile": 0.59314}, "CVE-2015-8334": {"epss_score": 0.00157, "epss_percentile": 0.37113}, "CVE-2015-8335": {"epss_score": 0.00104, "epss_percentile": 0.29121}, "CVE-2015-8336": {"epss_score": 0.0008, "epss_percentile": 0.24046}, "CVE-2015-8337": {"epss_score": 0.00119, "epss_percentile": 0.31613}, "CVE-2015-8338": {"epss_score": 0.00199, "epss_percentile": 0.4213}, "CVE-2015-8339": {"epss_score": 0.00097, "epss_percentile": 0.27493}, "CVE-2015-8340": {"epss_score": 0.00073, "epss_percentile": 0.22562}, "CVE-2015-8341": {"epss_score": 0.00731, "epss_percentile": 0.72171}, "CVE-2015-8345": {"epss_score": 0.0007, "epss_percentile": 0.21805}, "CVE-2015-8346": {"epss_score": 0.00467, "epss_percentile": 0.63827}, "CVE-2015-8349": {"epss_score": 0.09843, "epss_percentile": 0.92731}, "CVE-2015-8350": {"epss_score": 0.00984, "epss_percentile": 0.76315}, "CVE-2015-8351": {"epss_score": 0.69448, "epss_percentile": 0.98587}, "CVE-2015-8352": {"epss_score": 0.38492, "epss_percentile": 0.97102}, "CVE-2015-8353": {"epss_score": 0.00447, "epss_percentile": 0.62965}, "CVE-2015-8354": {"epss_score": 0.00533, "epss_percentile": 0.66753}, "CVE-2015-8355": {"epss_score": 0.00531, "epss_percentile": 0.6666}, "CVE-2015-8356": {"epss_score": 0.02553, "epss_percentile": 0.85086}, "CVE-2015-8357": {"epss_score": 0.04829, "epss_percentile": 0.89189}, "CVE-2015-8358": {"epss_score": 0.13589, "epss_percentile": 0.94004}, "CVE-2015-8360": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2015-8361": {"epss_score": 0.00524, "epss_percentile": 0.66322}, "CVE-2015-8362": {"epss_score": 0.07473, "epss_percentile": 0.91492}, "CVE-2015-8363": {"epss_score": 0.00485, "epss_percentile": 0.64732}, "CVE-2015-8364": {"epss_score": 0.00582, "epss_percentile": 0.68304}, "CVE-2015-8365": {"epss_score": 0.00536, "epss_percentile": 0.66884}, "CVE-2015-8366": {"epss_score": 0.01277, "epss_percentile": 0.79115}, "CVE-2015-8367": {"epss_score": 0.01731, "epss_percentile": 0.81993}, "CVE-2015-8368": {"epss_score": 0.02994, "epss_percentile": 0.86151}, "CVE-2015-8369": {"epss_score": 0.00495, "epss_percentile": 0.65126}, "CVE-2015-8370": {"epss_score": 0.03054, "epss_percentile": 0.86298}, "CVE-2015-8371": {"epss_score": 0.00936, "epss_percentile": 0.75689}, "CVE-2015-8373": {"epss_score": 0.03062, "epss_percentile": 0.86317}, "CVE-2015-8374": {"epss_score": 0.00043, "epss_percentile": 0.12948}, "CVE-2015-8375": {"epss_score": 0.00249, "epss_percentile": 0.48082}, "CVE-2015-8376": {"epss_score": 0.00232, "epss_percentile": 0.45929}, "CVE-2015-8377": {"epss_score": 0.00327, "epss_percentile": 0.55146}, "CVE-2015-8378": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2015-8379": {"epss_score": 0.00272, "epss_percentile": 0.50375}, "CVE-2015-8380": {"epss_score": 0.01238, "epss_percentile": 0.78786}, "CVE-2015-8381": {"epss_score": 0.10587, "epss_percentile": 0.93035}, "CVE-2015-8382": {"epss_score": 0.01772, "epss_percentile": 0.822}, "CVE-2015-8383": {"epss_score": 0.04437, "epss_percentile": 0.88689}, "CVE-2015-8384": {"epss_score": 0.01192, "epss_percentile": 0.78402}, "CVE-2015-8385": {"epss_score": 0.09455, "epss_percentile": 0.92556}, "CVE-2015-8386": {"epss_score": 0.08268, "epss_percentile": 0.9196}, "CVE-2015-8387": {"epss_score": 0.02146, "epss_percentile": 0.83764}, "CVE-2015-8388": {"epss_score": 0.07761, "epss_percentile": 0.91665}, "CVE-2015-8389": {"epss_score": 0.02653, "epss_percentile": 0.85351}, "CVE-2015-8390": {"epss_score": 0.04063, "epss_percentile": 0.88192}, "CVE-2015-8391": {"epss_score": 0.08891, "epss_percentile": 0.92303}, "CVE-2015-8392": {"epss_score": 0.08135, "epss_percentile": 0.91896}, "CVE-2015-8393": {"epss_score": 0.00689, "epss_percentile": 0.71234}, "CVE-2015-8394": {"epss_score": 0.03591, "epss_percentile": 0.874}, "CVE-2015-8395": {"epss_score": 0.04564, "epss_percentile": 0.88856}, "CVE-2015-8396": {"epss_score": 0.23518, "epss_percentile": 0.95788}, "CVE-2015-8397": {"epss_score": 0.02058, "epss_percentile": 0.83431}, "CVE-2015-8398": {"epss_score": 0.0052, "epss_percentile": 0.66196}, "CVE-2015-8399": {"epss_score": 0.92734, "epss_percentile": 0.9974}, "CVE-2015-8400": {"epss_score": 0.00556, "epss_percentile": 0.67525}, "CVE-2015-8401": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8402": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8403": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8404": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8405": {"epss_score": 0.0267, "epss_percentile": 0.85386}, "CVE-2015-8406": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8407": {"epss_score": 0.08757, "epss_percentile": 0.92243}, "CVE-2015-8408": {"epss_score": 0.07334, "epss_percentile": 0.91416}, "CVE-2015-8409": {"epss_score": 0.03512, "epss_percentile": 0.87269}, "CVE-2015-8410": {"epss_score": 0.52388, "epss_percentile": 0.97823}, "CVE-2015-8411": {"epss_score": 0.52388, "epss_percentile": 0.97823}, "CVE-2015-8412": {"epss_score": 0.52388, "epss_percentile": 0.97823}, "CVE-2015-8413": {"epss_score": 0.52388, "epss_percentile": 0.97823}, "CVE-2015-8414": {"epss_score": 0.06249, "epss_percentile": 0.90613}, "CVE-2015-8415": {"epss_score": 0.09715, "epss_percentile": 0.92674}, "CVE-2015-8416": {"epss_score": 0.13403, "epss_percentile": 0.93954}, "CVE-2015-8417": {"epss_score": 0.11151, "epss_percentile": 0.93244}, "CVE-2015-8418": {"epss_score": 0.11151, "epss_percentile": 0.93244}, "CVE-2015-8419": {"epss_score": 0.11151, "epss_percentile": 0.93244}, "CVE-2015-8420": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8421": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8422": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8423": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8424": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8425": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8426": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8427": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8428": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8429": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8430": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8431": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8432": {"epss_score": 0.06581, "epss_percentile": 0.90861}, "CVE-2015-8433": {"epss_score": 0.06581, "epss_percentile": 0.90861}, "CVE-2015-8434": {"epss_score": 0.54499, "epss_percentile": 0.97931}, "CVE-2015-8435": {"epss_score": 0.06581, "epss_percentile": 0.90861}, "CVE-2015-8436": {"epss_score": 0.07003, "epss_percentile": 0.91178}, "CVE-2015-8437": {"epss_score": 0.07003, "epss_percentile": 0.91178}, "CVE-2015-8438": {"epss_score": 0.07139, "epss_percentile": 0.91277}, "CVE-2015-8439": {"epss_score": 0.04349, "epss_percentile": 0.88581}, "CVE-2015-8440": {"epss_score": 0.06007, "epss_percentile": 0.90399}, "CVE-2015-8441": {"epss_score": 0.06581, "epss_percentile": 0.90861}, "CVE-2015-8442": {"epss_score": 0.07003, "epss_percentile": 0.91178}, "CVE-2015-8443": {"epss_score": 0.11151, "epss_percentile": 0.93244}, "CVE-2015-8444": {"epss_score": 0.11151, "epss_percentile": 0.93244}, "CVE-2015-8445": {"epss_score": 0.04765, "epss_percentile": 0.89122}, "CVE-2015-8446": {"epss_score": 0.07139, "epss_percentile": 0.91277}, "CVE-2015-8447": {"epss_score": 0.07003, "epss_percentile": 0.91178}, "CVE-2015-8448": {"epss_score": 0.07003, "epss_percentile": 0.91178}, "CVE-2015-8449": {"epss_score": 0.07003, "epss_percentile": 0.91178}, "CVE-2015-8450": {"epss_score": 0.07003, "epss_percentile": 0.91178}, "CVE-2015-8451": {"epss_score": 0.11151, "epss_percentile": 0.93244}, "CVE-2015-8452": {"epss_score": 0.06581, "epss_percentile": 0.90861}, "CVE-2015-8453": {"epss_score": 0.02414, "epss_percentile": 0.84678}, "CVE-2015-8454": {"epss_score": 0.07595, "epss_percentile": 0.9156}, "CVE-2015-8455": {"epss_score": 0.11151, "epss_percentile": 0.93244}, "CVE-2015-8456": {"epss_score": 0.0662, "epss_percentile": 0.90893}, "CVE-2015-8457": {"epss_score": 0.08159, "epss_percentile": 0.91908}, "CVE-2015-8458": {"epss_score": 0.02796, "epss_percentile": 0.85682}, "CVE-2015-8459": {"epss_score": 0.06401, "epss_percentile": 0.90728}, "CVE-2015-8460": {"epss_score": 0.06203, "epss_percentile": 0.90563}, "CVE-2015-8461": {"epss_score": 0.09361, "epss_percentile": 0.92516}, "CVE-2015-8466": {"epss_score": 0.00344, "epss_percentile": 0.56534}, "CVE-2015-8467": {"epss_score": 0.01749, "epss_percentile": 0.82085}, "CVE-2015-8470": {"epss_score": 0.00308, "epss_percentile": 0.5359}, "CVE-2015-8472": {"epss_score": 0.048, "epss_percentile": 0.89157}, "CVE-2015-8473": {"epss_score": 0.00465, "epss_percentile": 0.63754}, "CVE-2015-8474": {"epss_score": 0.00367, "epss_percentile": 0.58137}, "CVE-2015-8476": {"epss_score": 0.00948, "epss_percentile": 0.75829}, "CVE-2015-8477": {"epss_score": 0.0044, "epss_percentile": 0.62611}, "CVE-2015-8478": {"epss_score": 0.00111, "epss_percentile": 0.30259}, "CVE-2015-8479": {"epss_score": 0.00145, "epss_percentile": 0.3542}, "CVE-2015-8480": {"epss_score": 0.00789, "epss_percentile": 0.73359}, "CVE-2015-8481": {"epss_score": 0.0035, "epss_percentile": 0.56957}, "CVE-2015-8482": {"epss_score": 0.00061, "epss_percentile": 0.19495}, "CVE-2015-8483": {"epss_score": 0.00274, "epss_percentile": 0.50541}, "CVE-2015-8484": {"epss_score": 0.00241, "epss_percentile": 0.47295}, "CVE-2015-8485": {"epss_score": 0.00241, "epss_percentile": 0.47295}, "CVE-2015-8486": {"epss_score": 0.00241, "epss_percentile": 0.47295}, "CVE-2015-8487": {"epss_score": 0.00306, "epss_percentile": 0.53466}, "CVE-2015-8488": {"epss_score": 0.00306, "epss_percentile": 0.53466}, "CVE-2015-8489": {"epss_score": 0.00582, "epss_percentile": 0.68289}, "CVE-2015-8504": {"epss_score": 0.02814, "epss_percentile": 0.85725}, "CVE-2015-8505": {"epss_score": 0.00933, "epss_percentile": 0.75635}, "CVE-2015-8506": {"epss_score": 0.00933, "epss_percentile": 0.75635}, "CVE-2015-8507": {"epss_score": 0.00933, "epss_percentile": 0.75635}, "CVE-2015-8508": {"epss_score": 0.00317, "epss_percentile": 0.54365}, "CVE-2015-8509": {"epss_score": 0.0025, "epss_percentile": 0.48096}, "CVE-2015-8510": {"epss_score": 0.00304, "epss_percentile": 0.53289}, "CVE-2015-8511": {"epss_score": 0.00036, "epss_percentile": 0.10441}, "CVE-2015-8512": {"epss_score": 0.00073, "epss_percentile": 0.22663}, "CVE-2015-8519": {"epss_score": 0.08911, "epss_percentile": 0.92314}, "CVE-2015-8520": {"epss_score": 0.08911, "epss_percentile": 0.92314}, "CVE-2015-8521": {"epss_score": 0.08911, "epss_percentile": 0.92314}, "CVE-2015-8522": {"epss_score": 0.08911, "epss_percentile": 0.92314}, "CVE-2015-8523": {"epss_score": 0.01561, "epss_percentile": 0.81042}, "CVE-2015-8524": {"epss_score": 0.00266, "epss_percentile": 0.49919}, "CVE-2015-8530": {"epss_score": 0.01266, "epss_percentile": 0.79012}, "CVE-2015-8531": {"epss_score": 0.00225, "epss_percentile": 0.45124}, "CVE-2015-8534": {"epss_score": 0.00038, "epss_percentile": 0.11141}, "CVE-2015-8535": {"epss_score": 0.00068, "epss_percentile": 0.21322}, "CVE-2015-8536": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2015-8537": {"epss_score": 0.00464, "epss_percentile": 0.63718}, "CVE-2015-8538": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2015-8539": {"epss_score": 0.00071, "epss_percentile": 0.22103}, "CVE-2015-8540": {"epss_score": 0.13549, "epss_percentile": 0.93993}, "CVE-2015-8542": {"epss_score": 0.00164, "epss_percentile": 0.3789}, "CVE-2015-8543": {"epss_score": 0.02042, "epss_percentile": 0.83375}, "CVE-2015-8544": {"epss_score": 0.00476, "epss_percentile": 0.64265}, "CVE-2015-8546": {"epss_score": 0.01856, "epss_percentile": 0.82571}, "CVE-2015-8547": {"epss_score": 0.02362, "epss_percentile": 0.84503}, "CVE-2015-8548": {"epss_score": 0.00818, "epss_percentile": 0.73852}, "CVE-2015-8549": {"epss_score": 0.00449, "epss_percentile": 0.63046}, "CVE-2015-8550": {"epss_score": 0.15964, "epss_percentile": 0.94544}, "CVE-2015-8551": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2015-8552": {"epss_score": 0.00163, "epss_percentile": 0.37769}, "CVE-2015-8553": {"epss_score": 0.00273, "epss_percentile": 0.50475}, "CVE-2015-8554": {"epss_score": 0.00061, "epss_percentile": 0.19399}, "CVE-2015-8555": {"epss_score": 0.00551, "epss_percentile": 0.67373}, "CVE-2015-8556": {"epss_score": 0.21208, "epss_percentile": 0.95477}, "CVE-2015-8557": {"epss_score": 0.06995, "epss_percentile": 0.91171}, "CVE-2015-8558": {"epss_score": 0.00045, "epss_percentile": 0.13776}, "CVE-2015-8559": {"epss_score": 0.00395, "epss_percentile": 0.59834}, "CVE-2015-8560": {"epss_score": 0.10031, "epss_percentile": 0.92822}, "CVE-2015-8561": {"epss_score": 0.04457, "epss_percentile": 0.88713}, "CVE-2015-8562": {"epss_score": 0.93895, "epss_percentile": 0.99864}, "CVE-2015-8563": {"epss_score": 6e-05, "epss_percentile": 0.00264}, "CVE-2015-8564": {"epss_score": 0.00064, "epss_percentile": 0.20158}, "CVE-2015-8565": {"epss_score": 0.00064, "epss_percentile": 0.20158}, "CVE-2015-8566": {"epss_score": 0.01959, "epss_percentile": 0.83055}, "CVE-2015-8567": {"epss_score": 0.03508, "epss_percentile": 0.87262}, "CVE-2015-8568": {"epss_score": 0.00061, "epss_percentile": 0.19268}, "CVE-2015-8569": {"epss_score": 0.00017, "epss_percentile": 0.03354}, "CVE-2015-8570": {"epss_score": 0.00232, "epss_percentile": 0.4588}, "CVE-2015-8571": {"epss_score": 0.02241, "epss_percentile": 0.84116}, "CVE-2015-8572": {"epss_score": 0.06342, "epss_percentile": 0.90682}, "CVE-2015-8575": {"epss_score": 0.00014, "epss_percentile": 0.01885}, "CVE-2015-8577": {"epss_score": 0.00021, "epss_percentile": 0.04804}, "CVE-2015-8578": {"epss_score": 0.00241, "epss_percentile": 0.47244}, "CVE-2015-8579": {"epss_score": 0.00213, "epss_percentile": 0.4392}, "CVE-2015-8580": {"epss_score": 0.00499, "epss_percentile": 0.6525}, "CVE-2015-8592": {"epss_score": 0.00131, "epss_percentile": 0.33355}, "CVE-2015-8593": {"epss_score": 0.00181, "epss_percentile": 0.40104}, "CVE-2015-8594": {"epss_score": 0.00172, "epss_percentile": 0.38973}, "CVE-2015-8595": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-8596": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-8597": {"epss_score": 0.00253, "epss_percentile": 0.48424}, "CVE-2015-8600": {"epss_score": 0.00321, "epss_percentile": 0.54683}, "CVE-2015-8601": {"epss_score": 0.00139, "epss_percentile": 0.34619}, "CVE-2015-8602": {"epss_score": 0.00118, "epss_percentile": 0.31502}, "CVE-2015-8603": {"epss_score": 0.00191, "epss_percentile": 0.41211}, "CVE-2015-8604": {"epss_score": 0.00712, "epss_percentile": 0.71757}, "CVE-2015-8605": {"epss_score": 0.45998, "epss_percentile": 0.97516}, "CVE-2015-8606": {"epss_score": 0.00407, "epss_percentile": 0.60591}, "CVE-2015-8607": {"epss_score": 0.05664, "epss_percentile": 0.90099}, "CVE-2015-8608": {"epss_score": 0.02186, "epss_percentile": 0.8392}, "CVE-2015-8611": {"epss_score": 0.03574, "epss_percentile": 0.87378}, "CVE-2015-8612": {"epss_score": 0.25002, "epss_percentile": 0.95977}, "CVE-2015-8613": {"epss_score": 0.00101, "epss_percentile": 0.28589}, "CVE-2015-8614": {"epss_score": 0.01873, "epss_percentile": 0.82642}, "CVE-2015-8615": {"epss_score": 0.00242, "epss_percentile": 0.47351}, "CVE-2015-8616": {"epss_score": 0.00598, "epss_percentile": 0.68773}, "CVE-2015-8617": {"epss_score": 0.27141, "epss_percentile": 0.96212}, "CVE-2015-8618": {"epss_score": 0.00735, "epss_percentile": 0.72285}, "CVE-2015-8619": {"epss_score": 0.03318, "epss_percentile": 0.86906}, "CVE-2015-8620": {"epss_score": 0.00089, "epss_percentile": 0.25977}, "CVE-2015-8621": {"epss_score": 0.00062, "epss_percentile": 0.19678}, "CVE-2015-8622": {"epss_score": 0.00302, "epss_percentile": 0.5316}, "CVE-2015-8623": {"epss_score": 0.00128, "epss_percentile": 0.32999}, "CVE-2015-8624": {"epss_score": 0.00116, "epss_percentile": 0.3117}, "CVE-2015-8625": {"epss_score": 0.00309, "epss_percentile": 0.53703}, "CVE-2015-8626": {"epss_score": 0.00642, "epss_percentile": 0.70026}, "CVE-2015-8627": {"epss_score": 0.00429, "epss_percentile": 0.61995}, "CVE-2015-8628": {"epss_score": 0.00435, "epss_percentile": 0.62325}, "CVE-2015-8629": {"epss_score": 0.0161, "epss_percentile": 0.81322}, "CVE-2015-8630": {"epss_score": 0.0348, "epss_percentile": 0.87218}, "CVE-2015-8631": {"epss_score": 0.02564, "epss_percentile": 0.85111}, "CVE-2015-8634": {"epss_score": 0.49456, "epss_percentile": 0.97689}, "CVE-2015-8635": {"epss_score": 0.49456, "epss_percentile": 0.97689}, "CVE-2015-8636": {"epss_score": 0.41991, "epss_percentile": 0.97305}, "CVE-2015-8638": {"epss_score": 0.03298, "epss_percentile": 0.86862}, "CVE-2015-8639": {"epss_score": 0.03298, "epss_percentile": 0.86862}, "CVE-2015-8640": {"epss_score": 0.05036, "epss_percentile": 0.89421}, "CVE-2015-8641": {"epss_score": 0.05036, "epss_percentile": 0.89421}, "CVE-2015-8642": {"epss_score": 0.05036, "epss_percentile": 0.89421}, "CVE-2015-8643": {"epss_score": 0.05036, "epss_percentile": 0.89421}, "CVE-2015-8644": {"epss_score": 0.49456, "epss_percentile": 0.97689}, "CVE-2015-8645": {"epss_score": 0.07034, "epss_percentile": 0.91203}, "CVE-2015-8646": {"epss_score": 0.05036, "epss_percentile": 0.89421}, "CVE-2015-8647": {"epss_score": 0.03298, "epss_percentile": 0.86862}, "CVE-2015-8648": {"epss_score": 0.03298, "epss_percentile": 0.86862}, "CVE-2015-8649": {"epss_score": 0.03298, "epss_percentile": 0.86862}, "CVE-2015-8650": {"epss_score": 0.03298, "epss_percentile": 0.86862}, "CVE-2015-8651": {"epss_score": 0.90482, "epss_percentile": 0.99585}, "CVE-2015-8652": {"epss_score": 0.05733, "epss_percentile": 0.90163}, "CVE-2015-8653": {"epss_score": 0.01749, "epss_percentile": 0.82089}, "CVE-2015-8654": {"epss_score": 0.05733, "epss_percentile": 0.90163}, "CVE-2015-8655": {"epss_score": 0.01749, "epss_percentile": 0.82089}, "CVE-2015-8656": {"epss_score": 0.06679, "epss_percentile": 0.90938}, "CVE-2015-8657": {"epss_score": 0.06679, "epss_percentile": 0.90938}, "CVE-2015-8658": {"epss_score": 0.06679, "epss_percentile": 0.90938}, "CVE-2015-8659": {"epss_score": 0.02186, "epss_percentile": 0.8392}, "CVE-2015-8660": {"epss_score": 0.65431, "epss_percentile": 0.98418}, "CVE-2015-8661": {"epss_score": 0.00683, "epss_percentile": 0.71097}, "CVE-2015-8662": {"epss_score": 0.00683, "epss_percentile": 0.71097}, "CVE-2015-8663": {"epss_score": 0.00683, "epss_percentile": 0.71097}, "CVE-2015-8664": {"epss_score": 0.08837, "epss_percentile": 0.92277}, "CVE-2015-8665": {"epss_score": 0.00208, "epss_percentile": 0.43304}, "CVE-2015-8666": {"epss_score": 0.00079, "epss_percentile": 0.2395}, "CVE-2015-8667": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2015-8668": {"epss_score": 0.06282, "epss_percentile": 0.90639}, "CVE-2015-8669": {"epss_score": 0.00487, "epss_percentile": 0.64821}, "CVE-2015-8670": {"epss_score": 0.00165, "epss_percentile": 0.38133}, "CVE-2015-8671": {"epss_score": 0.00216, "epss_percentile": 0.4414}, "CVE-2015-8672": {"epss_score": 0.00224, "epss_percentile": 0.44984}, "CVE-2015-8673": {"epss_score": 0.00027, "epss_percentile": 0.07119}, "CVE-2015-8675": {"epss_score": 0.0003, "epss_percentile": 0.08028}, "CVE-2015-8676": {"epss_score": 0.00281, "epss_percentile": 0.51134}, "CVE-2015-8677": {"epss_score": 0.00242, "epss_percentile": 0.47351}, "CVE-2015-8678": {"epss_score": 0.00119, "epss_percentile": 0.31635}, "CVE-2015-8679": {"epss_score": 0.00059, "epss_percentile": 0.18846}, "CVE-2015-8680": {"epss_score": 0.0005, "epss_percentile": 0.15744}, "CVE-2015-8681": {"epss_score": 0.00052, "epss_percentile": 0.16354}, "CVE-2015-8682": {"epss_score": 0.00071, "epss_percentile": 0.22231}, "CVE-2015-8683": {"epss_score": 0.00207, "epss_percentile": 0.43205}, "CVE-2015-8684": {"epss_score": 0.00239, "epss_percentile": 0.46881}, "CVE-2015-8685": {"epss_score": 0.00212, "epss_percentile": 0.43724}, "CVE-2015-8687": {"epss_score": 0.00132, "epss_percentile": 0.33549}, "CVE-2015-8688": {"epss_score": 0.00556, "epss_percentile": 0.67516}, "CVE-2015-8697": {"epss_score": 0.00056, "epss_percentile": 0.17734}, "CVE-2015-8698": {"epss_score": 0.00264, "epss_percentile": 0.49571}, "CVE-2015-8699": {"epss_score": 0.00378, "epss_percentile": 0.58788}, "CVE-2015-8701": {"epss_score": 0.0007, "epss_percentile": 0.21761}, "CVE-2015-8702": {"epss_score": 0.00756, "epss_percentile": 0.72739}, "CVE-2015-8703": {"epss_score": 0.04487, "epss_percentile": 0.88753}, "CVE-2015-8704": {"epss_score": 0.19099, "epss_percentile": 0.95128}, "CVE-2015-8705": {"epss_score": 0.29182, "epss_percentile": 0.96423}, "CVE-2015-8707": {"epss_score": 0.00203, "epss_percentile": 0.42513}, "CVE-2015-8708": {"epss_score": 0.01292, "epss_percentile": 0.79235}, "CVE-2015-8709": {"epss_score": 0.00059, "epss_percentile": 0.18712}, "CVE-2015-8710": {"epss_score": 0.04711, "epss_percentile": 0.89038}, "CVE-2015-8711": {"epss_score": 0.00087, "epss_percentile": 0.25602}, "CVE-2015-8712": {"epss_score": 0.00083, "epss_percentile": 0.24729}, "CVE-2015-8713": {"epss_score": 0.00083, "epss_percentile": 0.24729}, "CVE-2015-8714": {"epss_score": 0.00083, "epss_percentile": 0.24729}, "CVE-2015-8715": {"epss_score": 0.00083, "epss_percentile": 0.24729}, "CVE-2015-8716": {"epss_score": 0.00083, "epss_percentile": 0.24729}, "CVE-2015-8717": {"epss_score": 0.00083, "epss_percentile": 0.24729}, "CVE-2015-8718": {"epss_score": 0.00087, "epss_percentile": 0.25549}, "CVE-2015-8719": {"epss_score": 0.00083, "epss_percentile": 0.24729}, "CVE-2015-8720": {"epss_score": 0.00087, "epss_percentile": 0.25549}, "CVE-2015-8721": {"epss_score": 0.00123, "epss_percentile": 0.32264}, "CVE-2015-8722": {"epss_score": 0.00076, "epss_percentile": 0.23077}, "CVE-2015-8723": {"epss_score": 0.01257, "epss_percentile": 0.78951}, "CVE-2015-8724": {"epss_score": 0.00773, "epss_percentile": 0.7305}, "CVE-2015-8725": {"epss_score": 0.00737, "epss_percentile": 0.72325}, "CVE-2015-8726": {"epss_score": 0.00971, "epss_percentile": 0.76128}, "CVE-2015-8727": {"epss_score": 0.00773, "epss_percentile": 0.7305}, "CVE-2015-8728": {"epss_score": 0.01047, "epss_percentile": 0.77034}, "CVE-2015-8729": {"epss_score": 0.00885, "epss_percentile": 0.74939}, "CVE-2015-8730": {"epss_score": 0.01042, "epss_percentile": 0.76973}, "CVE-2015-8731": {"epss_score": 0.01042, "epss_percentile": 0.76973}, "CVE-2015-8732": {"epss_score": 0.01003, "epss_percentile": 0.76513}, "CVE-2015-8733": {"epss_score": 0.01627, "epss_percentile": 0.81429}, "CVE-2015-8734": {"epss_score": 0.00093, "epss_percentile": 0.26611}, "CVE-2015-8735": {"epss_score": 0.00597, "epss_percentile": 0.68746}, "CVE-2015-8736": {"epss_score": 0.00687, "epss_percentile": 0.7118}, "CVE-2015-8737": {"epss_score": 0.00169, "epss_percentile": 0.38569}, "CVE-2015-8738": {"epss_score": 0.00093, "epss_percentile": 0.26611}, "CVE-2015-8739": {"epss_score": 0.00597, "epss_percentile": 0.68746}, "CVE-2015-8740": {"epss_score": 0.03256, "epss_percentile": 0.86761}, "CVE-2015-8741": {"epss_score": 0.00133, "epss_percentile": 0.33685}, "CVE-2015-8742": {"epss_score": 0.00093, "epss_percentile": 0.26611}, "CVE-2015-8743": {"epss_score": 0.00064, "epss_percentile": 0.2031}, "CVE-2015-8744": {"epss_score": 0.00067, "epss_percentile": 0.21148}, "CVE-2015-8745": {"epss_score": 0.00068, "epss_percentile": 0.21371}, "CVE-2015-8746": {"epss_score": 0.01868, "epss_percentile": 0.82622}, "CVE-2015-8747": {"epss_score": 0.01809, "epss_percentile": 0.82357}, "CVE-2015-8748": {"epss_score": 0.00566, "epss_percentile": 0.67814}, "CVE-2015-8749": {"epss_score": 0.00942, "epss_percentile": 0.75764}, "CVE-2015-8750": {"epss_score": 0.00604, "epss_percentile": 0.68955}, "CVE-2015-8751": {"epss_score": 0.00859, "epss_percentile": 0.74523}, "CVE-2015-8753": {"epss_score": 0.00467, "epss_percentile": 0.63843}, "CVE-2015-8754": {"epss_score": 0.00382, "epss_percentile": 0.59037}, "CVE-2015-8755": {"epss_score": 0.00222, "epss_percentile": 0.4475}, "CVE-2015-8756": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2015-8757": {"epss_score": 0.00296, "epss_percentile": 0.52621}, "CVE-2015-8758": {"epss_score": 0.00222, "epss_percentile": 0.4475}, "CVE-2015-8759": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2015-8760": {"epss_score": 0.00274, "epss_percentile": 0.50544}, "CVE-2015-8761": {"epss_score": 0.00318, "epss_percentile": 0.54441}, "CVE-2015-8762": {"epss_score": 0.00495, "epss_percentile": 0.65128}, "CVE-2015-8763": {"epss_score": 0.0055, "epss_percentile": 0.67345}, "CVE-2015-8764": {"epss_score": 0.00471, "epss_percentile": 0.6401}, "CVE-2015-8765": {"epss_score": 0.02067, "epss_percentile": 0.83462}, "CVE-2015-8766": {"epss_score": 0.00273, "epss_percentile": 0.50463}, "CVE-2015-8767": {"epss_score": 0.00121, "epss_percentile": 0.31876}, "CVE-2015-8768": {"epss_score": 0.0159, "epss_percentile": 0.81197}, "CVE-2015-8769": {"epss_score": 0.00599, "epss_percentile": 0.68789}, "CVE-2015-8770": {"epss_score": 0.28303, "epss_percentile": 0.96341}, "CVE-2015-8771": {"epss_score": 0.01204, "epss_percentile": 0.78507}, "CVE-2015-8772": {"epss_score": 0.00491, "epss_percentile": 0.64966}, "CVE-2015-8773": {"epss_score": 0.00292, "epss_percentile": 0.52268}, "CVE-2015-8776": {"epss_score": 0.08055, "epss_percentile": 0.91856}, "CVE-2015-8777": {"epss_score": 0.0006, "epss_percentile": 0.19012}, "CVE-2015-8778": {"epss_score": 0.07731, "epss_percentile": 0.91649}, "CVE-2015-8779": {"epss_score": 0.09682, "epss_percentile": 0.92661}, "CVE-2015-8780": {"epss_score": 0.00064, "epss_percentile": 0.20151}, "CVE-2015-8781": {"epss_score": 0.02089, "epss_percentile": 0.83563}, "CVE-2015-8782": {"epss_score": 0.01557, "epss_percentile": 0.8102}, "CVE-2015-8783": {"epss_score": 0.00655, "epss_percentile": 0.70422}, "CVE-2015-8784": {"epss_score": 0.01522, "epss_percentile": 0.80835}, "CVE-2015-8785": {"epss_score": 0.00088, "epss_percentile": 0.2572}, "CVE-2015-8786": {"epss_score": 0.01338, "epss_percentile": 0.79564}, "CVE-2015-8787": {"epss_score": 0.05655, "epss_percentile": 0.90087}, "CVE-2015-8789": {"epss_score": 0.00379, "epss_percentile": 0.58842}, "CVE-2015-8790": {"epss_score": 0.00536, "epss_percentile": 0.66868}, "CVE-2015-8791": {"epss_score": 0.00336, "epss_percentile": 0.55945}, "CVE-2015-8792": {"epss_score": 0.00312, "epss_percentile": 0.53948}, "CVE-2015-8793": {"epss_score": 0.00276, "epss_percentile": 0.50712}, "CVE-2015-8794": {"epss_score": 0.00288, "epss_percentile": 0.51974}, "CVE-2015-8795": {"epss_score": 0.02559, "epss_percentile": 0.851}, "CVE-2015-8796": {"epss_score": 0.02552, "epss_percentile": 0.85082}, "CVE-2015-8797": {"epss_score": 0.02074, "epss_percentile": 0.835}, "CVE-2015-8798": {"epss_score": 0.02095, "epss_percentile": 0.83584}, "CVE-2015-8799": {"epss_score": 0.01625, "epss_percentile": 0.81417}, "CVE-2015-8800": {"epss_score": 0.00399, "epss_percentile": 0.60105}, "CVE-2015-8801": {"epss_score": 0.00059, "epss_percentile": 0.18863}, "CVE-2015-8803": {"epss_score": 0.12343, "epss_percentile": 0.93645}, "CVE-2015-8804": {"epss_score": 0.11875, "epss_percentile": 0.93502}, "CVE-2015-8805": {"epss_score": 0.01196, "epss_percentile": 0.78441}, "CVE-2015-8806": {"epss_score": 0.06052, "epss_percentile": 0.90436}, "CVE-2015-8807": {"epss_score": 0.00676, "epss_percentile": 0.70938}, "CVE-2015-8808": {"epss_score": 0.00294, "epss_percentile": 0.5236}, "CVE-2015-8812": {"epss_score": 0.03778, "epss_percentile": 0.87711}, "CVE-2015-8813": {"epss_score": 0.83448, "epss_percentile": 0.99248}, "CVE-2015-8814": {"epss_score": 0.00106, "epss_percentile": 0.29498}, "CVE-2015-8815": {"epss_score": 0.002, "epss_percentile": 0.4221}, "CVE-2015-8816": {"epss_score": 0.00085, "epss_percentile": 0.25131}, "CVE-2015-8817": {"epss_score": 0.00088, "epss_percentile": 0.25651}, "CVE-2015-8818": {"epss_score": 0.00094, "epss_percentile": 0.26967}, "CVE-2015-8820": {"epss_score": 0.08557, "epss_percentile": 0.92125}, "CVE-2015-8821": {"epss_score": 0.01749, "epss_percentile": 0.82089}, "CVE-2015-8822": {"epss_score": 0.00977, "epss_percentile": 0.76222}, "CVE-2015-8823": {"epss_score": 0.00843, "epss_percentile": 0.74259}, "CVE-2015-8830": {"epss_score": 0.00058, "epss_percentile": 0.18271}, "CVE-2015-8831": {"epss_score": 0.03105, "epss_percentile": 0.86417}, "CVE-2015-8832": {"epss_score": 0.01118, "epss_percentile": 0.77743}, "CVE-2015-8833": {"epss_score": 0.16464, "epss_percentile": 0.94673}, "CVE-2015-8834": {"epss_score": 0.00748, "epss_percentile": 0.72588}, "CVE-2015-8835": {"epss_score": 0.04045, "epss_percentile": 0.88171}, "CVE-2015-8836": {"epss_score": 0.00492, "epss_percentile": 0.65012}, "CVE-2015-8837": {"epss_score": 0.01429, "epss_percentile": 0.80227}, "CVE-2015-8838": {"epss_score": 0.00661, "epss_percentile": 0.70563}, "CVE-2015-8839": {"epss_score": 0.00043, "epss_percentile": 0.13032}, "CVE-2015-8840": {"epss_score": 0.00476, "epss_percentile": 0.6428}, "CVE-2015-8841": {"epss_score": 0.13447, "epss_percentile": 0.93967}, "CVE-2015-8842": {"epss_score": 0.00068, "epss_percentile": 0.2142}, "CVE-2015-8843": {"epss_score": 3e-05, "epss_percentile": 0.00062}, "CVE-2015-8844": {"epss_score": 0.00089, "epss_percentile": 0.25836}, "CVE-2015-8845": {"epss_score": 0.00065, "epss_percentile": 0.2052}, "CVE-2015-8851": {"epss_score": 0.00477, "epss_percentile": 0.64331}, "CVE-2015-8852": {"epss_score": 0.0109, "epss_percentile": 0.77454}, "CVE-2015-8853": {"epss_score": 0.1399, "epss_percentile": 0.94111}, "CVE-2015-8854": {"epss_score": 0.0102, "epss_percentile": 0.76732}, "CVE-2015-8855": {"epss_score": 0.01023, "epss_percentile": 0.76765}, "CVE-2015-8856": {"epss_score": 0.00341, "epss_percentile": 0.56347}, "CVE-2015-8857": {"epss_score": 0.00268, "epss_percentile": 0.50102}, "CVE-2015-8858": {"epss_score": 0.00902, "epss_percentile": 0.75192}, "CVE-2015-8859": {"epss_score": 0.00184, "epss_percentile": 0.4043}, "CVE-2015-8860": {"epss_score": 0.00365, "epss_percentile": 0.57993}, "CVE-2015-8861": {"epss_score": 0.00669, "epss_percentile": 0.70765}, "CVE-2015-8862": {"epss_score": 0.0018, "epss_percentile": 0.39889}, "CVE-2015-8863": {"epss_score": 0.17246, "epss_percentile": 0.94806}, "CVE-2015-8864": {"epss_score": 0.00369, "epss_percentile": 0.58227}, "CVE-2015-8865": {"epss_score": 0.01014, "epss_percentile": 0.7665}, "CVE-2015-8866": {"epss_score": 0.03049, "epss_percentile": 0.86287}, "CVE-2015-8867": {"epss_score": 0.13368, "epss_percentile": 0.93943}, "CVE-2015-8868": {"epss_score": 0.01087, "epss_percentile": 0.77426}, "CVE-2015-8869": {"epss_score": 0.02814, "epss_percentile": 0.85727}, "CVE-2015-8870": {"epss_score": 0.00737, "epss_percentile": 0.72319}, "CVE-2015-8871": {"epss_score": 0.0223, "epss_percentile": 0.84085}, "CVE-2015-8872": {"epss_score": 0.00078, "epss_percentile": 0.23775}, "CVE-2015-8873": {"epss_score": 0.01854, "epss_percentile": 0.82553}, "CVE-2015-8874": {"epss_score": 0.02921, "epss_percentile": 0.85991}, "CVE-2015-8875": {"epss_score": 0.0114, "epss_percentile": 0.77953}, "CVE-2015-8876": {"epss_score": 0.12619, "epss_percentile": 0.93731}, "CVE-2015-8877": {"epss_score": 0.02317, "epss_percentile": 0.84358}, "CVE-2015-8878": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2015-8879": {"epss_score": 0.01617, "epss_percentile": 0.81366}, "CVE-2015-8880": {"epss_score": 0.02155, "epss_percentile": 0.83805}, "CVE-2015-8888": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2015-8889": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2015-8890": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2015-8891": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2015-8892": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2015-8893": {"epss_score": 0.0005, "epss_percentile": 0.15847}, "CVE-2015-8894": {"epss_score": 0.004, "epss_percentile": 0.60176}, "CVE-2015-8895": {"epss_score": 0.01481, "epss_percentile": 0.80567}, "CVE-2015-8896": {"epss_score": 0.00549, "epss_percentile": 0.67321}, "CVE-2015-8897": {"epss_score": 0.0048, "epss_percentile": 0.64477}, "CVE-2015-8898": {"epss_score": 0.00121, "epss_percentile": 0.31821}, "CVE-2015-8899": {"epss_score": 0.0008, "epss_percentile": 0.2417}, "CVE-2015-8900": {"epss_score": 0.00379, "epss_percentile": 0.5884}, "CVE-2015-8901": {"epss_score": 0.00634, "epss_percentile": 0.69787}, "CVE-2015-8902": {"epss_score": 0.00613, "epss_percentile": 0.69244}, "CVE-2015-8903": {"epss_score": 0.00634, "epss_percentile": 0.69787}, "CVE-2015-8914": {"epss_score": 0.06657, "epss_percentile": 0.90921}, "CVE-2015-8915": {"epss_score": 0.00418, "epss_percentile": 0.61274}, "CVE-2015-8916": {"epss_score": 0.02958, "epss_percentile": 0.86066}, "CVE-2015-8917": {"epss_score": 0.06561, "epss_percentile": 0.90848}, "CVE-2015-8918": {"epss_score": 0.02569, "epss_percentile": 0.85123}, "CVE-2015-8919": {"epss_score": 0.0746, "epss_percentile": 0.91484}, "CVE-2015-8920": {"epss_score": 0.00495, "epss_percentile": 0.65104}, "CVE-2015-8921": {"epss_score": 0.04315, "epss_percentile": 0.88537}, "CVE-2015-8922": {"epss_score": 0.00425, "epss_percentile": 0.61719}, "CVE-2015-8923": {"epss_score": 0.02586, "epss_percentile": 0.85165}, "CVE-2015-8924": {"epss_score": 0.00334, "epss_percentile": 0.55734}, "CVE-2015-8925": {"epss_score": 0.00563, "epss_percentile": 0.67739}, "CVE-2015-8926": {"epss_score": 0.00456, "epss_percentile": 0.63329}, "CVE-2015-8927": {"epss_score": 0.00222, "epss_percentile": 0.44783}, "CVE-2015-8928": {"epss_score": 0.00308, "epss_percentile": 0.53606}, "CVE-2015-8929": {"epss_score": 0.00271, "epss_percentile": 0.50285}, "CVE-2015-8930": {"epss_score": 0.05575, "epss_percentile": 0.90012}, "CVE-2015-8931": {"epss_score": 0.00299, "epss_percentile": 0.52861}, "CVE-2015-8932": {"epss_score": 0.00626, "epss_percentile": 0.6962}, "CVE-2015-8933": {"epss_score": 0.00325, "epss_percentile": 0.54998}, "CVE-2015-8934": {"epss_score": 0.01857, "epss_percentile": 0.82575}, "CVE-2015-8935": {"epss_score": 0.01121, "epss_percentile": 0.77774}, "CVE-2015-8936": {"epss_score": 0.00329, "epss_percentile": 0.55318}, "CVE-2015-8937": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2015-8938": {"epss_score": 0.00059, "epss_percentile": 0.18826}, "CVE-2015-8939": {"epss_score": 0.00059, "epss_percentile": 0.18692}, "CVE-2015-8940": {"epss_score": 0.00059, "epss_percentile": 0.18826}, "CVE-2015-8941": {"epss_score": 0.00059, "epss_percentile": 0.18692}, "CVE-2015-8942": {"epss_score": 0.00059, "epss_percentile": 0.18826}, "CVE-2015-8943": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2015-8944": {"epss_score": 0.00059, "epss_percentile": 0.18909}, "CVE-2015-8945": {"epss_score": 0.00136, "epss_percentile": 0.34152}, "CVE-2015-8946": {"epss_score": 0.00124, "epss_percentile": 0.3243}, "CVE-2015-8947": {"epss_score": 0.00653, "epss_percentile": 0.70323}, "CVE-2015-8948": {"epss_score": 0.05368, "epss_percentile": 0.89792}, "CVE-2015-8949": {"epss_score": 0.03925, "epss_percentile": 0.87961}, "CVE-2015-8950": {"epss_score": 0.00147, "epss_percentile": 0.35702}, "CVE-2015-8951": {"epss_score": 0.00061, "epss_percentile": 0.19512}, "CVE-2015-8952": {"epss_score": 0.00077, "epss_percentile": 0.23548}, "CVE-2015-8953": {"epss_score": 0.00071, "epss_percentile": 0.22076}, "CVE-2015-8954": {"epss_score": 0.01862, "epss_percentile": 0.82595}, "CVE-2015-8955": {"epss_score": 0.00064, "epss_percentile": 0.20176}, "CVE-2015-8956": {"epss_score": 0.00035, "epss_percentile": 0.09998}, "CVE-2015-8957": {"epss_score": 0.00668, "epss_percentile": 0.70725}, "CVE-2015-8958": {"epss_score": 0.00992, "epss_percentile": 0.76396}, "CVE-2015-8959": {"epss_score": 0.0159, "epss_percentile": 0.812}, "CVE-2015-8960": {"epss_score": 0.00364, "epss_percentile": 0.57909}, "CVE-2015-8961": {"epss_score": 0.00246, "epss_percentile": 0.47746}, "CVE-2015-8962": {"epss_score": 0.00342, "epss_percentile": 0.56358}, "CVE-2015-8963": {"epss_score": 0.00091, "epss_percentile": 0.2641}, "CVE-2015-8964": {"epss_score": 0.00173, "epss_percentile": 0.39042}, "CVE-2015-8965": {"epss_score": 0.01384, "epss_percentile": 0.79899}, "CVE-2015-8966": {"epss_score": 0.00182, "epss_percentile": 0.40273}, "CVE-2015-8967": {"epss_score": 0.00075, "epss_percentile": 0.23001}, "CVE-2015-8968": {"epss_score": 0.02844, "epss_percentile": 0.85817}, "CVE-2015-8969": {"epss_score": 0.02489, "epss_percentile": 0.84893}, "CVE-2015-8970": {"epss_score": 0.00072, "epss_percentile": 0.22419}, "CVE-2015-8971": {"epss_score": 0.00639, "epss_percentile": 0.69937}, "CVE-2015-8972": {"epss_score": 0.02387, "epss_percentile": 0.84582}, "CVE-2015-8973": {"epss_score": 0.00384, "epss_percentile": 0.59149}, "CVE-2015-8974": {"epss_score": 0.03692, "epss_percentile": 0.87578}, "CVE-2015-8975": {"epss_score": 0.00418, "epss_percentile": 0.61343}, "CVE-2015-8976": {"epss_score": 0.00316, "epss_percentile": 0.54294}, "CVE-2015-8977": {"epss_score": 0.01218, "epss_percentile": 0.78604}, "CVE-2015-8978": {"epss_score": 0.00691, "epss_percentile": 0.71279}, "CVE-2015-8979": {"epss_score": 0.00659, "epss_percentile": 0.70513}, "CVE-2015-8980": {"epss_score": 0.04573, "epss_percentile": 0.88865}, "CVE-2015-8981": {"epss_score": 0.00265, "epss_percentile": 0.49793}, "CVE-2015-8982": {"epss_score": 0.0131, "epss_percentile": 0.79362}, "CVE-2015-8983": {"epss_score": 0.00525, "epss_percentile": 0.66388}, "CVE-2015-8984": {"epss_score": 0.00557, "epss_percentile": 0.67553}, "CVE-2015-8985": {"epss_score": 0.00198, "epss_percentile": 0.42086}, "CVE-2015-8986": {"epss_score": 0.00194, "epss_percentile": 0.41528}, "CVE-2015-8987": {"epss_score": 0.00145, "epss_percentile": 0.35358}, "CVE-2015-8988": {"epss_score": 0.00584, "epss_percentile": 0.68369}, "CVE-2015-8989": {"epss_score": 0.00301, "epss_percentile": 0.53066}, "CVE-2015-8990": {"epss_score": 0.00255, "epss_percentile": 0.48642}, "CVE-2015-8991": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2015-8992": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2015-8993": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2015-8994": {"epss_score": 0.01997, "epss_percentile": 0.83207}, "CVE-2015-8995": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2015-8996": {"epss_score": 0.00045, "epss_percentile": 0.13909}, "CVE-2015-8997": {"epss_score": 0.00045, "epss_percentile": 0.13909}, "CVE-2015-8998": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2015-8999": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2015-9000": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2015-9001": {"epss_score": 0.00098, "epss_percentile": 0.278}, "CVE-2015-9002": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2015-9003": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2015-9004": {"epss_score": 0.00145, "epss_percentile": 0.35354}, "CVE-2015-9005": {"epss_score": 0.00038, "epss_percentile": 0.11272}, "CVE-2015-9006": {"epss_score": 0.00031, "epss_percentile": 0.08555}, "CVE-2015-9007": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2015-9008": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2015-9009": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2015-9010": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2015-9011": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2015-9012": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2015-9013": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2015-9014": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2015-9015": {"epss_score": 0.00028, "epss_percentile": 0.07315}, "CVE-2015-9016": {"epss_score": 0.00024, "epss_percentile": 0.05686}, "CVE-2015-9019": {"epss_score": 0.00984, "epss_percentile": 0.76313}, "CVE-2015-9020": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2015-9021": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2015-9022": {"epss_score": 0.00045, "epss_percentile": 0.13909}, "CVE-2015-9023": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2015-9024": {"epss_score": 0.00075, "epss_percentile": 0.2298}, "CVE-2015-9025": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2015-9026": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2015-9027": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2015-9028": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2015-9029": {"epss_score": 0.00051, "epss_percentile": 0.16244}, "CVE-2015-9030": {"epss_score": 0.00147, "epss_percentile": 0.35703}, "CVE-2015-9031": {"epss_score": 0.00087, "epss_percentile": 0.25616}, "CVE-2015-9032": {"epss_score": 0.00087, "epss_percentile": 0.25616}, "CVE-2015-9033": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2015-9034": {"epss_score": 0.00189, "epss_percentile": 0.40939}, "CVE-2015-9035": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9036": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9037": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9038": {"epss_score": 0.00131, "epss_percentile": 0.33355}, "CVE-2015-9039": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9040": {"epss_score": 0.00134, "epss_percentile": 0.3383}, "CVE-2015-9041": {"epss_score": 0.00189, "epss_percentile": 0.40939}, "CVE-2015-9042": {"epss_score": 0.00189, "epss_percentile": 0.40939}, "CVE-2015-9043": {"epss_score": 0.00131, "epss_percentile": 0.33355}, "CVE-2015-9044": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9045": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9046": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9047": {"epss_score": 0.00134, "epss_percentile": 0.3383}, "CVE-2015-9048": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9049": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9050": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9051": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9052": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9053": {"epss_score": 0.00149, "epss_percentile": 0.36001}, "CVE-2015-9054": {"epss_score": 0.00131, "epss_percentile": 0.33355}, "CVE-2015-9055": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9056": {"epss_score": 0.0029, "epss_percentile": 0.52129}, "CVE-2015-9057": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2015-9058": {"epss_score": 0.00215, "epss_percentile": 0.44082}, "CVE-2015-9059": {"epss_score": 0.1671, "epss_percentile": 0.94719}, "CVE-2015-9060": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9061": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9062": {"epss_score": 0.00149, "epss_percentile": 0.36001}, "CVE-2015-9063": {"epss_score": 0.00247, "epss_percentile": 0.47811}, "CVE-2015-9064": {"epss_score": 0.00221, "epss_percentile": 0.44699}, "CVE-2015-9065": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2015-9066": {"epss_score": 0.00247, "epss_percentile": 0.47811}, "CVE-2015-9067": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9068": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9069": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9070": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9071": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2015-9072": {"epss_score": 0.00131, "epss_percentile": 0.33355}, "CVE-2015-9073": {"epss_score": 0.00131, "epss_percentile": 0.33355}, "CVE-2015-9096": {"epss_score": 0.01592, "epss_percentile": 0.81225}, "CVE-2015-9097": {"epss_score": 0.01021, "epss_percentile": 0.76746}, "CVE-2015-9098": {"epss_score": 0.39987, "epss_percentile": 0.9719}, "CVE-2015-9099": {"epss_score": 0.00402, "epss_percentile": 0.6027}, "CVE-2015-9100": {"epss_score": 0.00402, "epss_percentile": 0.6027}, "CVE-2015-9101": {"epss_score": 0.00667, "epss_percentile": 0.70718}, "CVE-2015-9102": {"epss_score": 0.00327, "epss_percentile": 0.55136}, "CVE-2015-9103": {"epss_score": 0.00246, "epss_percentile": 0.47795}, "CVE-2015-9104": {"epss_score": 0.00195, "epss_percentile": 0.41641}, "CVE-2015-9105": {"epss_score": 0.00246, "epss_percentile": 0.47795}, "CVE-2015-9107": {"epss_score": 0.01665, "epss_percentile": 0.81649}, "CVE-2015-9108": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2015-9109": {"epss_score": 0.00254, "epss_percentile": 0.48551}, "CVE-2015-9110": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2015-9111": {"epss_score": 0.00254, "epss_percentile": 0.48551}, "CVE-2015-9112": {"epss_score": 0.00359, "epss_percentile": 0.57612}, "CVE-2015-9113": {"epss_score": 0.00254, "epss_percentile": 0.48551}, "CVE-2015-9114": {"epss_score": 0.00254, "epss_percentile": 0.48551}, "CVE-2015-9115": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2015-9116": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2015-9118": {"epss_score": 0.00359, "epss_percentile": 0.57612}, "CVE-2015-9119": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2015-9120": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2015-9122": {"epss_score": 0.00359, "epss_percentile": 0.57612}, "CVE-2015-9123": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2015-9124": {"epss_score": 0.0026, "epss_percentile": 0.49194}, "CVE-2015-9126": {"epss_score": 0.00359, "epss_percentile": 0.57612}, "CVE-2015-9127": {"epss_score": 0.00254, "epss_percentile": 0.48551}, "CVE-2015-9128": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2015-9129": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2015-9130": {"epss_score": 0.00254, "epss_percentile": 0.48551}, "CVE-2015-9131": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2015-9132": {"epss_score": 0.00185, "epss_percentile": 0.40529}, "CVE-2015-9133": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9134": {"epss_score": 0.00174, "epss_percentile": 0.39189}, "CVE-2015-9135": {"epss_score": 0.00177, "epss_percentile": 0.39524}, "CVE-2015-9136": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9137": {"epss_score": 0.00203, "epss_percentile": 0.42539}, "CVE-2015-9138": {"epss_score": 0.0012, "epss_percentile": 0.31694}, "CVE-2015-9139": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9140": {"epss_score": 0.00185, "epss_percentile": 0.40484}, "CVE-2015-9141": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9142": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9143": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9144": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9145": {"epss_score": 0.00168, "epss_percentile": 0.38474}, "CVE-2015-9146": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9147": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9148": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9149": {"epss_score": 0.00177, "epss_percentile": 0.39524}, "CVE-2015-9150": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9151": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9152": {"epss_score": 0.00167, "epss_percentile": 0.38328}, "CVE-2015-9153": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9156": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9157": {"epss_score": 0.00172, "epss_percentile": 0.38994}, "CVE-2015-9158": {"epss_score": 0.00359, "epss_percentile": 0.57612}, "CVE-2015-9159": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9160": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9161": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9162": {"epss_score": 0.00095, "epss_percentile": 0.2716}, "CVE-2015-9163": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2015-9164": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9165": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9166": {"epss_score": 0.00203, "epss_percentile": 0.42539}, "CVE-2015-9167": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9169": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2015-9170": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9171": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9172": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9173": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9174": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9175": {"epss_score": 0.00177, "epss_percentile": 0.39524}, "CVE-2015-9176": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2015-9177": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9178": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9179": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9180": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9181": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9182": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9183": {"epss_score": 0.00195, "epss_percentile": 0.4163}, "CVE-2015-9184": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9185": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9186": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9187": {"epss_score": 0.00181, "epss_percentile": 0.40074}, "CVE-2015-9188": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9189": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2015-9190": {"epss_score": 0.00257, "epss_percentile": 0.48859}, "CVE-2015-9191": {"epss_score": 0.00177, "epss_percentile": 0.39524}, "CVE-2015-9192": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9193": {"epss_score": 0.00301, "epss_percentile": 0.53055}, "CVE-2015-9194": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2015-9195": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9196": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9197": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9198": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9199": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9200": {"epss_score": 0.00177, "epss_percentile": 0.39524}, "CVE-2015-9201": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9202": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9203": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9204": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9205": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9206": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9207": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9208": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9209": {"epss_score": 0.00167, "epss_percentile": 0.38328}, "CVE-2015-9210": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9211": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9212": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9213": {"epss_score": 0.0021, "epss_percentile": 0.43444}, "CVE-2015-9215": {"epss_score": 0.00168, "epss_percentile": 0.38474}, "CVE-2015-9216": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9217": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2015-9218": {"epss_score": 0.00046, "epss_percentile": 0.14101}, "CVE-2015-9219": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9220": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2015-9221": {"epss_score": 0.00177, "epss_percentile": 0.39524}, "CVE-2015-9222": {"epss_score": 0.19028, "epss_percentile": 0.95113}, "CVE-2015-9223": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9224": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2015-9226": {"epss_score": 0.01749, "epss_percentile": 0.82094}, "CVE-2015-9227": {"epss_score": 0.0441, "epss_percentile": 0.88659}, "CVE-2015-9228": {"epss_score": 0.05042, "epss_percentile": 0.89429}, "CVE-2015-9229": {"epss_score": 0.00202, "epss_percentile": 0.42406}, "CVE-2015-9230": {"epss_score": 0.01206, "epss_percentile": 0.7852}, "CVE-2015-9231": {"epss_score": 0.00907, "epss_percentile": 0.75268}, "CVE-2015-9232": {"epss_score": 0.00136, "epss_percentile": 0.3412}, "CVE-2015-9233": {"epss_score": 0.00228, "epss_percentile": 0.45477}, "CVE-2015-9234": {"epss_score": 0.01159, "epss_percentile": 0.78127}, "CVE-2015-9235": {"epss_score": 0.3247, "epss_percentile": 0.96702}, "CVE-2015-9236": {"epss_score": 0.00248, "epss_percentile": 0.47978}, "CVE-2015-9238": {"epss_score": 0.00215, "epss_percentile": 0.44086}, "CVE-2015-9239": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2015-9240": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2015-9241": {"epss_score": 0.00346, "epss_percentile": 0.56704}, "CVE-2015-9242": {"epss_score": 0.00498, "epss_percentile": 0.65243}, "CVE-2015-9243": {"epss_score": 0.00165, "epss_percentile": 0.38137}, "CVE-2015-9244": {"epss_score": 0.00941, "epss_percentile": 0.75755}, "CVE-2015-9245": {"epss_score": 0.00062, "epss_percentile": 0.19702}, "CVE-2015-9246": {"epss_score": 0.02441, "epss_percentile": 0.84756}, "CVE-2015-9247": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2015-9248": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2015-9249": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2015-9250": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2015-9251": {"epss_score": 0.27164, "epss_percentile": 0.96214}, "CVE-2015-9252": {"epss_score": 0.00314, "epss_percentile": 0.54145}, "CVE-2015-9253": {"epss_score": 0.02956, "epss_percentile": 0.86062}, "CVE-2015-9254": {"epss_score": 0.00345, "epss_percentile": 0.56559}, "CVE-2015-9255": {"epss_score": 0.00234, "epss_percentile": 0.46158}, "CVE-2015-9256": {"epss_score": 0.00244, "epss_percentile": 0.47619}, "CVE-2015-9257": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2015-9258": {"epss_score": 0.00236, "epss_percentile": 0.46452}, "CVE-2015-9259": {"epss_score": 0.00576, "epss_percentile": 0.68126}, "CVE-2015-9260": {"epss_score": 0.00249, "epss_percentile": 0.48082}, "CVE-2015-9261": {"epss_score": 0.00598, "epss_percentile": 0.68762}, "CVE-2015-9262": {"epss_score": 0.03207, "epss_percentile": 0.86635}, "CVE-2015-9263": {"epss_score": 0.64322, "epss_percentile": 0.98373}, "CVE-2015-9264": {"epss_score": 0.01025, "epss_percentile": 0.76794}, "CVE-2015-9266": {"epss_score": 0.79542, "epss_percentile": 0.99044}, "CVE-2015-9267": {"epss_score": 0.00042, "epss_percentile": 0.12827}, "CVE-2015-9268": {"epss_score": 0.00569, "epss_percentile": 0.67931}, "CVE-2015-9269": {"epss_score": 0.00696, "epss_percentile": 0.7139}, "CVE-2015-9270": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9271": {"epss_score": 0.10612, "epss_percentile": 0.93047}, "CVE-2015-9272": {"epss_score": 0.11349, "epss_percentile": 0.93319}, "CVE-2015-9273": {"epss_score": 0.0025, "epss_percentile": 0.48148}, "CVE-2015-9274": {"epss_score": 0.00805, "epss_percentile": 0.73643}, "CVE-2015-9275": {"epss_score": 0.00335, "epss_percentile": 0.55839}, "CVE-2015-9276": {"epss_score": 0.00284, "epss_percentile": 0.51471}, "CVE-2015-9277": {"epss_score": 0.0019, "epss_percentile": 0.41118}, "CVE-2015-9278": {"epss_score": 0.00245, "epss_percentile": 0.47708}, "CVE-2015-9279": {"epss_score": 0.00124, "epss_percentile": 0.32448}, "CVE-2015-9280": {"epss_score": 0.00246, "epss_percentile": 0.47802}, "CVE-2015-9281": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2015-9282": {"epss_score": 0.00452, "epss_percentile": 0.63193}, "CVE-2015-9284": {"epss_score": 0.0045, "epss_percentile": 0.63088}, "CVE-2015-9285": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2015-9286": {"epss_score": 0.00308, "epss_percentile": 0.53636}, "CVE-2015-9287": {"epss_score": 0.00641, "epss_percentile": 0.70015}, "CVE-2015-9288": {"epss_score": 0.0031, "epss_percentile": 0.53787}, "CVE-2015-9289": {"epss_score": 0.00063, "epss_percentile": 0.19928}, "CVE-2015-9290": {"epss_score": 0.005, "epss_percentile": 0.65312}, "CVE-2015-9291": {"epss_score": 0.00496, "epss_percentile": 0.65152}, "CVE-2015-9292": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2015-9293": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9294": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9295": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9296": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9297": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9298": {"epss_score": 0.00994, "epss_percentile": 0.76419}, "CVE-2015-9299": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9300": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9301": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2015-9302": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9303": {"epss_score": 0.00403, "epss_percentile": 0.60318}, "CVE-2015-9304": {"epss_score": 0.00264, "epss_percentile": 0.49695}, "CVE-2015-9305": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9306": {"epss_score": 0.00403, "epss_percentile": 0.60318}, "CVE-2015-9307": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2015-9308": {"epss_score": 0.003, "epss_percentile": 0.52964}, "CVE-2015-9309": {"epss_score": 0.003, "epss_percentile": 0.52964}, "CVE-2015-9310": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2015-9311": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9312": {"epss_score": 0.06836, "epss_percentile": 0.91058}, "CVE-2015-9313": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2015-9314": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9315": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2015-9316": {"epss_score": 0.01484, "epss_percentile": 0.80593}, "CVE-2015-9317": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9318": {"epss_score": 0.00254, "epss_percentile": 0.48537}, "CVE-2015-9319": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9320": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9321": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9322": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2015-9323": {"epss_score": 0.76384, "epss_percentile": 0.98889}, "CVE-2015-9324": {"epss_score": 0.00706, "epss_percentile": 0.71611}, "CVE-2015-9325": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2015-9326": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2015-9327": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9328": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9329": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9330": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2015-9331": {"epss_score": 0.00548, "epss_percentile": 0.67286}, "CVE-2015-9332": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2015-9333": {"epss_score": 0.00596, "epss_percentile": 0.68717}, "CVE-2015-9334": {"epss_score": 0.00614, "epss_percentile": 0.6927}, "CVE-2015-9335": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2015-9336": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9337": {"epss_score": 0.00213, "epss_percentile": 0.43843}, "CVE-2015-9338": {"epss_score": 0.00278, "epss_percentile": 0.50852}, "CVE-2015-9339": {"epss_score": 0.00254, "epss_percentile": 0.48537}, "CVE-2015-9340": {"epss_score": 0.00254, "epss_percentile": 0.48537}, "CVE-2015-9341": {"epss_score": 0.00278, "epss_percentile": 0.50852}, "CVE-2015-9342": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9343": {"epss_score": 0.00149, "epss_percentile": 0.35951}, "CVE-2015-9344": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2015-9345": {"epss_score": 0.00254, "epss_percentile": 0.48537}, "CVE-2015-9346": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9347": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9348": {"epss_score": 0.00554, "epss_percentile": 0.67441}, "CVE-2015-9349": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9350": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9351": {"epss_score": 0.0331, "epss_percentile": 0.86885}, "CVE-2015-9352": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2015-9353": {"epss_score": 0.00539, "epss_percentile": 0.66961}, "CVE-2015-9354": {"epss_score": 0.00186, "epss_percentile": 0.406}, "CVE-2015-9355": {"epss_score": 0.00184, "epss_percentile": 0.40392}, "CVE-2015-9356": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9357": {"epss_score": 0.00207, "epss_percentile": 0.43167}, "CVE-2015-9358": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9359": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9360": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9361": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9362": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9363": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9364": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9365": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9366": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9367": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9368": {"epss_score": 0.00432, "epss_percentile": 0.62134}, "CVE-2015-9369": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9370": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9371": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9372": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9373": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9374": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9375": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9376": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9377": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9378": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9379": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2015-9380": {"epss_score": 0.00222, "epss_percentile": 0.44746}, "CVE-2015-9381": {"epss_score": 0.00711, "epss_percentile": 0.71731}, "CVE-2015-9382": {"epss_score": 0.00798, "epss_percentile": 0.7351}, "CVE-2015-9383": {"epss_score": 0.02952, "epss_percentile": 0.86056}, "CVE-2015-9384": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9385": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9386": {"epss_score": 0.00207, "epss_percentile": 0.43167}, "CVE-2015-9387": {"epss_score": 0.00153, "epss_percentile": 0.36512}, "CVE-2015-9388": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2015-9389": {"epss_score": 0.00178, "epss_percentile": 0.39652}, "CVE-2015-9390": {"epss_score": 0.0012, "epss_percentile": 0.31721}, "CVE-2015-9391": {"epss_score": 0.00938, "epss_percentile": 0.75715}, "CVE-2015-9392": {"epss_score": 0.00284, "epss_percentile": 0.51466}, "CVE-2015-9393": {"epss_score": 0.00178, "epss_percentile": 0.39652}, "CVE-2015-9394": {"epss_score": 0.00149, "epss_percentile": 0.35951}, "CVE-2015-9395": {"epss_score": 0.00604, "epss_percentile": 0.68965}, "CVE-2015-9396": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9397": {"epss_score": 0.00208, "epss_percentile": 0.43252}, "CVE-2015-9398": {"epss_score": 0.00616, "epss_percentile": 0.69325}, "CVE-2015-9399": {"epss_score": 0.00656, "epss_percentile": 0.70451}, "CVE-2015-9400": {"epss_score": 0.00673, "epss_percentile": 0.70833}, "CVE-2015-9401": {"epss_score": 0.00279, "epss_percentile": 0.50981}, "CVE-2015-9402": {"epss_score": 0.00938, "epss_percentile": 0.7571}, "CVE-2015-9403": {"epss_score": 0.0019, "epss_percentile": 0.41114}, "CVE-2015-9404": {"epss_score": 0.00242, "epss_percentile": 0.474}, "CVE-2015-9405": {"epss_score": 0.00338, "epss_percentile": 0.56117}, "CVE-2015-9406": {"epss_score": 0.81654, "epss_percentile": 0.99149}, "CVE-2015-9407": {"epss_score": 0.00258, "epss_percentile": 0.48994}, "CVE-2015-9408": {"epss_score": 0.00308, "epss_percentile": 0.53615}, "CVE-2015-9409": {"epss_score": 0.00308, "epss_percentile": 0.53615}, "CVE-2015-9410": {"epss_score": 0.0029, "epss_percentile": 0.52084}, "CVE-2015-9411": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9412": {"epss_score": 0.00359, "epss_percentile": 0.57544}, "CVE-2015-9413": {"epss_score": 0.00308, "epss_percentile": 0.53615}, "CVE-2015-9414": {"epss_score": 0.03076, "epss_percentile": 0.8636}, "CVE-2015-9415": {"epss_score": 0.15525, "epss_percentile": 0.94451}, "CVE-2015-9416": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9417": {"epss_score": 0.00153, "epss_percentile": 0.36512}, "CVE-2015-9418": {"epss_score": 0.00114, "epss_percentile": 0.30865}, "CVE-2015-9419": {"epss_score": 0.00174, "epss_percentile": 0.39185}, "CVE-2015-9420": {"epss_score": 0.00238, "epss_percentile": 0.46784}, "CVE-2015-9421": {"epss_score": 0.00186, "epss_percentile": 0.40646}, "CVE-2015-9422": {"epss_score": 0.00167, "epss_percentile": 0.38348}, "CVE-2015-9423": {"epss_score": 0.00208, "epss_percentile": 0.43252}, "CVE-2015-9424": {"epss_score": 0.00237, "epss_percentile": 0.46695}, "CVE-2015-9425": {"epss_score": 0.00137, "epss_percentile": 0.34256}, "CVE-2015-9426": {"epss_score": 0.00227, "epss_percentile": 0.45445}, "CVE-2015-9427": {"epss_score": 0.00282, "epss_percentile": 0.51223}, "CVE-2015-9428": {"epss_score": 0.00186, "epss_percentile": 0.40646}, "CVE-2015-9429": {"epss_score": 0.00186, "epss_percentile": 0.40646}, "CVE-2015-9430": {"epss_score": 0.0026, "epss_percentile": 0.492}, "CVE-2015-9431": {"epss_score": 0.00186, "epss_percentile": 0.40646}, "CVE-2015-9432": {"epss_score": 0.0017, "epss_percentile": 0.38733}, "CVE-2015-9433": {"epss_score": 0.00167, "epss_percentile": 0.38348}, "CVE-2015-9434": {"epss_score": 0.00186, "epss_percentile": 0.40646}, "CVE-2015-9435": {"epss_score": 0.00515, "epss_percentile": 0.65998}, "CVE-2015-9436": {"epss_score": 0.00227, "epss_percentile": 0.45445}, "CVE-2015-9437": {"epss_score": 0.00237, "epss_percentile": 0.46695}, "CVE-2015-9438": {"epss_score": 0.00227, "epss_percentile": 0.45445}, "CVE-2015-9439": {"epss_score": 0.00255, "epss_percentile": 0.4866}, "CVE-2015-9440": {"epss_score": 0.00189, "epss_percentile": 0.40968}, "CVE-2015-9441": {"epss_score": 0.00189, "epss_percentile": 0.40968}, "CVE-2015-9442": {"epss_score": 0.00263, "epss_percentile": 0.49535}, "CVE-2015-9443": {"epss_score": 0.00263, "epss_percentile": 0.49535}, "CVE-2015-9444": {"epss_score": 0.00171, "epss_percentile": 0.38897}, "CVE-2015-9445": {"epss_score": 0.00259, "epss_percentile": 0.49067}, "CVE-2015-9446": {"epss_score": 0.01588, "epss_percentile": 0.81187}, "CVE-2015-9447": {"epss_score": 0.00216, "epss_percentile": 0.44205}, "CVE-2015-9448": {"epss_score": 0.0066, "epss_percentile": 0.70538}, "CVE-2015-9449": {"epss_score": 0.00644, "epss_percentile": 0.70087}, "CVE-2015-9450": {"epss_score": 0.00713, "epss_percentile": 0.71793}, "CVE-2015-9451": {"epss_score": 0.00713, "epss_percentile": 0.71793}, "CVE-2015-9452": {"epss_score": 0.00713, "epss_percentile": 0.71793}, "CVE-2015-9453": {"epss_score": 0.00331, "epss_percentile": 0.55546}, "CVE-2015-9454": {"epss_score": 0.00696, "epss_percentile": 0.71386}, "CVE-2015-9455": {"epss_score": 0.00095, "epss_percentile": 0.27174}, "CVE-2015-9456": {"epss_score": 0.00286, "epss_percentile": 0.51736}, "CVE-2015-9457": {"epss_score": 0.00741, "epss_percentile": 0.72448}, "CVE-2015-9458": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2015-9459": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9460": {"epss_score": 0.00696, "epss_percentile": 0.71386}, "CVE-2015-9461": {"epss_score": 0.00756, "epss_percentile": 0.72729}, "CVE-2015-9462": {"epss_score": 0.00692, "epss_percentile": 0.71283}, "CVE-2015-9463": {"epss_score": 0.06514, "epss_percentile": 0.90814}, "CVE-2015-9464": {"epss_score": 0.06017, "epss_percentile": 0.90413}, "CVE-2015-9465": {"epss_score": 0.00901, "epss_percentile": 0.75181}, "CVE-2015-9466": {"epss_score": 0.00726, "epss_percentile": 0.72082}, "CVE-2015-9467": {"epss_score": 0.00665, "epss_percentile": 0.70658}, "CVE-2015-9468": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9469": {"epss_score": 0.00237, "epss_percentile": 0.46736}, "CVE-2015-9470": {"epss_score": 0.06002, "epss_percentile": 0.90393}, "CVE-2015-9471": {"epss_score": 0.05005, "epss_percentile": 0.89384}, "CVE-2015-9472": {"epss_score": 0.00243, "epss_percentile": 0.47415}, "CVE-2015-9473": {"epss_score": 0.04523, "epss_percentile": 0.88803}, "CVE-2015-9474": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2015-9475": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2015-9476": {"epss_score": 0.00581, "epss_percentile": 0.68276}, "CVE-2015-9477": {"epss_score": 0.00581, "epss_percentile": 0.68276}, "CVE-2015-9478": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2015-9479": {"epss_score": 0.00762, "epss_percentile": 0.72845}, "CVE-2015-9480": {"epss_score": 0.61858, "epss_percentile": 0.98264}, "CVE-2015-9481": {"epss_score": 0.00514, "epss_percentile": 0.65955}, "CVE-2015-9482": {"epss_score": 0.00514, "epss_percentile": 0.65955}, "CVE-2015-9483": {"epss_score": 0.00663, "epss_percentile": 0.70627}, "CVE-2015-9484": {"epss_score": 0.00514, "epss_percentile": 0.65955}, "CVE-2015-9485": {"epss_score": 0.00973, "epss_percentile": 0.76165}, "CVE-2015-9486": {"epss_score": 0.00663, "epss_percentile": 0.70627}, "CVE-2015-9487": {"epss_score": 0.00663, "epss_percentile": 0.70627}, "CVE-2015-9488": {"epss_score": 0.00514, "epss_percentile": 0.65955}, "CVE-2015-9489": {"epss_score": 0.0078, "epss_percentile": 0.73161}, "CVE-2015-9490": {"epss_score": 0.00514, "epss_percentile": 0.65955}, "CVE-2015-9491": {"epss_score": 0.00663, "epss_percentile": 0.70627}, "CVE-2015-9492": {"epss_score": 0.00663, "epss_percentile": 0.70627}, "CVE-2015-9493": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2015-9494": {"epss_score": 0.00284, "epss_percentile": 0.51421}, "CVE-2015-9495": {"epss_score": 0.00207, "epss_percentile": 0.43167}, "CVE-2015-9496": {"epss_score": 0.00821, "epss_percentile": 0.73901}, "CVE-2015-9497": {"epss_score": 0.00411, "epss_percentile": 0.60846}, "CVE-2015-9498": {"epss_score": 0.00382, "epss_percentile": 0.59066}, "CVE-2015-9499": {"epss_score": 0.67891, "epss_percentile": 0.98524}, "CVE-2015-9500": {"epss_score": 0.00259, "epss_percentile": 0.49095}, "CVE-2015-9501": {"epss_score": 0.00284, "epss_percentile": 0.51421}, "CVE-2015-9502": {"epss_score": 0.00259, "epss_percentile": 0.49095}, "CVE-2015-9503": {"epss_score": 0.00259, "epss_percentile": 0.49095}, "CVE-2015-9504": {"epss_score": 0.00284, "epss_percentile": 0.51421}, "CVE-2015-9505": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9506": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9507": {"epss_score": 0.00563, "epss_percentile": 0.67727}, "CVE-2015-9508": {"epss_score": 0.00563, "epss_percentile": 0.67727}, "CVE-2015-9509": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9510": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9511": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9512": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9513": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9514": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9515": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9516": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9517": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9518": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9519": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9520": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9521": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9522": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9523": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9524": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9525": {"epss_score": 0.00563, "epss_percentile": 0.67727}, "CVE-2015-9526": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9527": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9528": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9529": {"epss_score": 0.00563, "epss_percentile": 0.67727}, "CVE-2015-9530": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9531": {"epss_score": 0.00563, "epss_percentile": 0.67727}, "CVE-2015-9532": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9533": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9534": {"epss_score": 0.00563, "epss_percentile": 0.67727}, "CVE-2015-9535": {"epss_score": 0.00563, "epss_percentile": 0.67727}, "CVE-2015-9536": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2015-9537": {"epss_score": 0.00571, "epss_percentile": 0.67973}, "CVE-2015-9538": {"epss_score": 0.71039, "epss_percentile": 0.98651}, "CVE-2015-9539": {"epss_score": 0.00462, "epss_percentile": 0.63614}, "CVE-2015-9540": {"epss_score": 0.00204, "epss_percentile": 0.42649}, "CVE-2015-9541": {"epss_score": 0.00896, "epss_percentile": 0.7512}, "CVE-2015-9542": {"epss_score": 0.019, "epss_percentile": 0.82771}, "CVE-2015-9543": {"epss_score": 0.00132, "epss_percentile": 0.33622}, "CVE-2015-9544": {"epss_score": 0.00449, "epss_percentile": 0.63044}, "CVE-2015-9545": {"epss_score": 0.00449, "epss_percentile": 0.63044}, "CVE-2015-9546": {"epss_score": 0.00083, "epss_percentile": 0.24745}, "CVE-2015-9547": {"epss_score": 0.00118, "epss_percentile": 0.31384}, "CVE-2015-9548": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2015-9549": {"epss_score": 0.00403, "epss_percentile": 0.60369}, "CVE-2015-9550": {"epss_score": 0.00371, "epss_percentile": 0.58373}, "CVE-2015-9551": {"epss_score": 0.07369, "epss_percentile": 0.91438}, "CVE-2016-0002": {"epss_score": 0.47218, "epss_percentile": 0.97576}, "CVE-2016-0003": {"epss_score": 0.08219, "epss_percentile": 0.91935}, "CVE-2016-0005": {"epss_score": 0.36927, "epss_percentile": 0.9701}, "CVE-2016-0006": {"epss_score": 0.05233, "epss_percentile": 0.89644}, "CVE-2016-0007": {"epss_score": 0.03844, "epss_percentile": 0.87837}, "CVE-2016-0008": {"epss_score": 0.12167, "epss_percentile": 0.93588}, "CVE-2016-0009": {"epss_score": 0.24571, "epss_percentile": 0.95934}, "CVE-2016-0010": {"epss_score": 0.59618, "epss_percentile": 0.98172}, "CVE-2016-0011": {"epss_score": 0.01199, "epss_percentile": 0.78461}, "CVE-2016-0012": {"epss_score": 0.13313, "epss_percentile": 0.93929}, "CVE-2016-0014": {"epss_score": 0.02497, "epss_percentile": 0.8491}, "CVE-2016-0015": {"epss_score": 0.66981, "epss_percentile": 0.98488}, "CVE-2016-0016": {"epss_score": 0.06222, "epss_percentile": 0.90581}, "CVE-2016-0018": {"epss_score": 0.06818, "epss_percentile": 0.91044}, "CVE-2016-0019": {"epss_score": 0.09933, "epss_percentile": 0.92778}, "CVE-2016-0020": {"epss_score": 0.00693, "epss_percentile": 0.71314}, "CVE-2016-0021": {"epss_score": 0.31324, "epss_percentile": 0.9661}, "CVE-2016-0022": {"epss_score": 0.2989, "epss_percentile": 0.96484}, "CVE-2016-0024": {"epss_score": 0.32396, "epss_percentile": 0.96694}, "CVE-2016-0025": {"epss_score": 0.26865, "epss_percentile": 0.96187}, "CVE-2016-0026": {"epss_score": 0.05377, "epss_percentile": 0.89803}, "CVE-2016-0028": {"epss_score": 0.21122, "epss_percentile": 0.95465}, "CVE-2016-0029": {"epss_score": 0.01465, "epss_percentile": 0.80458}, "CVE-2016-0030": {"epss_score": 0.01465, "epss_percentile": 0.80458}, "CVE-2016-0031": {"epss_score": 0.01465, "epss_percentile": 0.80458}, "CVE-2016-0032": {"epss_score": 0.01465, "epss_percentile": 0.80458}, "CVE-2016-0033": {"epss_score": 0.23441, "epss_percentile": 0.95777}, "CVE-2016-0034": {"epss_score": 0.47074, "epss_percentile": 0.97569}, "CVE-2016-0035": {"epss_score": 0.2443, "epss_percentile": 0.95921}, "CVE-2016-0036": {"epss_score": 0.17408, "epss_percentile": 0.94847}, "CVE-2016-0037": {"epss_score": 0.43763, "epss_percentile": 0.97402}, "CVE-2016-0038": {"epss_score": 0.2029, "epss_percentile": 0.95315}, "CVE-2016-0039": {"epss_score": 0.01457, "epss_percentile": 0.80398}, "CVE-2016-0040": {"epss_score": 0.78896, "epss_percentile": 0.99009}, "CVE-2016-0041": {"epss_score": 0.60439, "epss_percentile": 0.98207}, "CVE-2016-0042": {"epss_score": 0.01034, "epss_percentile": 0.76891}, "CVE-2016-0044": {"epss_score": 0.31748, "epss_percentile": 0.96645}, "CVE-2016-0046": {"epss_score": 0.27396, "epss_percentile": 0.96242}, "CVE-2016-0047": {"epss_score": 0.24117, "epss_percentile": 0.95877}, "CVE-2016-0048": {"epss_score": 0.00581, "epss_percentile": 0.68282}, "CVE-2016-0049": {"epss_score": 0.03532, "epss_percentile": 0.87304}, "CVE-2016-0050": {"epss_score": 0.53172, "epss_percentile": 0.97859}, "CVE-2016-0051": {"epss_score": 0.80284, "epss_percentile": 0.9908}, "CVE-2016-0052": {"epss_score": 0.2989, "epss_percentile": 0.96484}, "CVE-2016-0053": {"epss_score": 0.31195, "epss_percentile": 0.96601}, "CVE-2016-0054": {"epss_score": 0.31517, "epss_percentile": 0.96624}, "CVE-2016-0055": {"epss_score": 0.30333, "epss_percentile": 0.9653}, "CVE-2016-0056": {"epss_score": 0.24713, "epss_percentile": 0.95948}, "CVE-2016-0057": {"epss_score": 0.00702, "epss_percentile": 0.71521}, "CVE-2016-0058": {"epss_score": 0.26342, "epss_percentile": 0.96138}, "CVE-2016-0059": {"epss_score": 0.17576, "epss_percentile": 0.94869}, "CVE-2016-0060": {"epss_score": 0.29918, "epss_percentile": 0.96486}, "CVE-2016-0061": {"epss_score": 0.17078, "epss_percentile": 0.94771}, "CVE-2016-0062": {"epss_score": 0.17078, "epss_percentile": 0.94771}, "CVE-2016-0063": {"epss_score": 0.40616, "epss_percentile": 0.97226}, "CVE-2016-0064": {"epss_score": 0.20463, "epss_percentile": 0.9535}, "CVE-2016-0067": {"epss_score": 0.20463, "epss_percentile": 0.9535}, "CVE-2016-0068": {"epss_score": 0.35004, "epss_percentile": 0.96883}, "CVE-2016-0069": {"epss_score": 0.37963, "epss_percentile": 0.97078}, "CVE-2016-0070": {"epss_score": 0.03584, "epss_percentile": 0.8739}, "CVE-2016-0071": {"epss_score": 0.20463, "epss_percentile": 0.9535}, "CVE-2016-0072": {"epss_score": 0.14031, "epss_percentile": 0.94119}, "CVE-2016-0073": {"epss_score": 0.02609, "epss_percentile": 0.85231}, "CVE-2016-0075": {"epss_score": 0.05869, "epss_percentile": 0.90278}, "CVE-2016-0077": {"epss_score": 0.09359, "epss_percentile": 0.92515}, "CVE-2016-0079": {"epss_score": 0.02609, "epss_percentile": 0.85231}, "CVE-2016-0080": {"epss_score": 0.15165, "epss_percentile": 0.94377}, "CVE-2016-0084": {"epss_score": 0.17936, "epss_percentile": 0.9493}, "CVE-2016-0087": {"epss_score": 0.00942, "epss_percentile": 0.75765}, "CVE-2016-0088": {"epss_score": 0.0154, "epss_percentile": 0.8094}, "CVE-2016-0089": {"epss_score": 0.00921, "epss_percentile": 0.75483}, "CVE-2016-0090": {"epss_score": 0.00709, "epss_percentile": 0.71687}, "CVE-2016-0091": {"epss_score": 0.30746, "epss_percentile": 0.96565}, "CVE-2016-0092": {"epss_score": 0.47205, "epss_percentile": 0.97576}, "CVE-2016-0093": {"epss_score": 0.036, "epss_percentile": 0.87409}, "CVE-2016-0094": {"epss_score": 0.02947, "epss_percentile": 0.86042}, "CVE-2016-0095": {"epss_score": 0.15262, "epss_percentile": 0.94394}, "CVE-2016-0096": {"epss_score": 0.00292, "epss_percentile": 0.52265}, "CVE-2016-0098": {"epss_score": 0.48268, "epss_percentile": 0.97628}, "CVE-2016-0099": {"epss_score": 0.92, "epss_percentile": 0.99684}, "CVE-2016-0100": {"epss_score": 0.6875, "epss_percentile": 0.98562}, "CVE-2016-0101": {"epss_score": 0.48268, "epss_percentile": 0.97628}, "CVE-2016-0102": {"epss_score": 0.16884, "epss_percentile": 0.9474}, "CVE-2016-0103": {"epss_score": 0.10216, "epss_percentile": 0.92897}, "CVE-2016-0104": {"epss_score": 0.15905, "epss_percentile": 0.94528}, "CVE-2016-0105": {"epss_score": 0.19457, "epss_percentile": 0.95187}, "CVE-2016-0106": {"epss_score": 0.19457, "epss_percentile": 0.95187}, "CVE-2016-0107": {"epss_score": 0.19457, "epss_percentile": 0.95187}, "CVE-2016-0108": {"epss_score": 0.31777, "epss_percentile": 0.96647}, "CVE-2016-0109": {"epss_score": 0.27071, "epss_percentile": 0.96203}, "CVE-2016-0110": {"epss_score": 0.19457, "epss_percentile": 0.95187}, "CVE-2016-0111": {"epss_score": 0.44978, "epss_percentile": 0.97464}, "CVE-2016-0112": {"epss_score": 0.19457, "epss_percentile": 0.95187}, "CVE-2016-0113": {"epss_score": 0.19457, "epss_percentile": 0.95187}, "CVE-2016-0114": {"epss_score": 0.19457, "epss_percentile": 0.95187}, "CVE-2016-0116": {"epss_score": 0.15981, "epss_percentile": 0.94547}, "CVE-2016-0117": {"epss_score": 0.41296, "epss_percentile": 0.97264}, "CVE-2016-0118": {"epss_score": 0.47205, "epss_percentile": 0.97576}, "CVE-2016-0120": {"epss_score": 0.52585, "epss_percentile": 0.97832}, "CVE-2016-0121": {"epss_score": 0.4724, "epss_percentile": 0.97577}, "CVE-2016-0122": {"epss_score": 0.39916, "epss_percentile": 0.97187}, "CVE-2016-0123": {"epss_score": 0.19457, "epss_percentile": 0.95187}, "CVE-2016-0124": {"epss_score": 0.15905, "epss_percentile": 0.94528}, "CVE-2016-0125": {"epss_score": 0.04703, "epss_percentile": 0.89028}, "CVE-2016-0126": {"epss_score": 0.30017, "epss_percentile": 0.96497}, "CVE-2016-0127": {"epss_score": 0.2989, "epss_percentile": 0.96484}, "CVE-2016-0128": {"epss_score": 0.40991, "epss_percentile": 0.97249}, "CVE-2016-0129": {"epss_score": 0.15905, "epss_percentile": 0.94528}, "CVE-2016-0130": {"epss_score": 0.15905, "epss_percentile": 0.94528}, "CVE-2016-0132": {"epss_score": 0.32646, "epss_percentile": 0.96714}, "CVE-2016-0133": {"epss_score": 0.00489, "epss_percentile": 0.64914}, "CVE-2016-0134": {"epss_score": 0.48518, "epss_percentile": 0.97641}, "CVE-2016-0135": {"epss_score": 0.00516, "epss_percentile": 0.66046}, "CVE-2016-0136": {"epss_score": 0.40637, "epss_percentile": 0.97229}, "CVE-2016-0137": {"epss_score": 0.06542, "epss_percentile": 0.90836}, "CVE-2016-0138": {"epss_score": 0.13989, "epss_percentile": 0.9411}, "CVE-2016-0139": {"epss_score": 0.30333, "epss_percentile": 0.9653}, "CVE-2016-0140": {"epss_score": 0.36012, "epss_percentile": 0.96949}, "CVE-2016-0141": {"epss_score": 0.0771, "epss_percentile": 0.91638}, "CVE-2016-0142": {"epss_score": 0.19734, "epss_percentile": 0.95233}, "CVE-2016-0143": {"epss_score": 0.05423, "epss_percentile": 0.89864}, "CVE-2016-0145": {"epss_score": 0.74815, "epss_percentile": 0.98818}, "CVE-2016-0147": {"epss_score": 0.26416, "epss_percentile": 0.96145}, "CVE-2016-0148": {"epss_score": 0.09258, "epss_percentile": 0.92469}, "CVE-2016-0149": {"epss_score": 0.15754, "epss_percentile": 0.94498}, "CVE-2016-0150": {"epss_score": 0.43281, "epss_percentile": 0.97379}, "CVE-2016-0151": {"epss_score": 0.44069, "epss_percentile": 0.97418}, "CVE-2016-0152": {"epss_score": 0.05368, "epss_percentile": 0.89792}, "CVE-2016-0153": {"epss_score": 0.33652, "epss_percentile": 0.9679}, "CVE-2016-0154": {"epss_score": 0.16295, "epss_percentile": 0.94612}, "CVE-2016-0155": {"epss_score": 0.15981, "epss_percentile": 0.94547}, "CVE-2016-0156": {"epss_score": 0.18369, "epss_percentile": 0.95006}, "CVE-2016-0157": {"epss_score": 0.1236, "epss_percentile": 0.93649}, "CVE-2016-0158": {"epss_score": 0.18898, "epss_percentile": 0.95088}, "CVE-2016-0159": {"epss_score": 0.09825, "epss_percentile": 0.9272}, "CVE-2016-0160": {"epss_score": 0.01225, "epss_percentile": 0.78684}, "CVE-2016-0161": {"epss_score": 0.23982, "epss_percentile": 0.9584}, "CVE-2016-0162": {"epss_score": 0.37993, "epss_percentile": 0.97081}, "CVE-2016-0164": {"epss_score": 0.12775, "epss_percentile": 0.93769}, "CVE-2016-0165": {"epss_score": 0.1173, "epss_percentile": 0.9346}, "CVE-2016-0166": {"epss_score": 0.09825, "epss_percentile": 0.9272}, "CVE-2016-0167": {"epss_score": 0.07024, "epss_percentile": 0.91194}, "CVE-2016-0168": {"epss_score": 0.69648, "epss_percentile": 0.98596}, "CVE-2016-0169": {"epss_score": 0.62714, "epss_percentile": 0.98305}, "CVE-2016-0170": {"epss_score": 0.79897, "epss_percentile": 0.9906}, "CVE-2016-0171": {"epss_score": 0.01977, "epss_percentile": 0.83127}, "CVE-2016-0173": {"epss_score": 0.01126, "epss_percentile": 0.77809}, "CVE-2016-0174": {"epss_score": 0.02456, "epss_percentile": 0.848}, "CVE-2016-0175": {"epss_score": 0.00802, "epss_percentile": 0.73581}, "CVE-2016-0176": {"epss_score": 0.00504, "epss_percentile": 0.65538}, "CVE-2016-0178": {"epss_score": 0.26245, "epss_percentile": 0.96129}, "CVE-2016-0179": {"epss_score": 0.19236, "epss_percentile": 0.95154}, "CVE-2016-0180": {"epss_score": 0.01609, "epss_percentile": 0.81316}, "CVE-2016-0181": {"epss_score": 0.00399, "epss_percentile": 0.60115}, "CVE-2016-0182": {"epss_score": 0.42911, "epss_percentile": 0.97361}, "CVE-2016-0183": {"epss_score": 0.40367, "epss_percentile": 0.97215}, "CVE-2016-0184": {"epss_score": 0.22325, "epss_percentile": 0.95623}, "CVE-2016-0185": {"epss_score": 0.82752, "epss_percentile": 0.99212}, "CVE-2016-0186": {"epss_score": 0.21761, "epss_percentile": 0.95557}, "CVE-2016-0187": {"epss_score": 0.22692, "epss_percentile": 0.9567}, "CVE-2016-0188": {"epss_score": 0.32657, "epss_percentile": 0.96715}, "CVE-2016-0189": {"epss_score": 0.91522, "epss_percentile": 0.9965}, "CVE-2016-0190": {"epss_score": 0.02564, "epss_percentile": 0.85113}, "CVE-2016-0191": {"epss_score": 0.21761, "epss_percentile": 0.95557}, "CVE-2016-0192": {"epss_score": 0.27071, "epss_percentile": 0.96203}, "CVE-2016-0193": {"epss_score": 0.21761, "epss_percentile": 0.95557}, "CVE-2016-0194": {"epss_score": 0.00907, "epss_percentile": 0.75269}, "CVE-2016-0195": {"epss_score": 0.2636, "epss_percentile": 0.96139}, "CVE-2016-0196": {"epss_score": 0.01726, "epss_percentile": 0.81964}, "CVE-2016-0197": {"epss_score": 0.01609, "epss_percentile": 0.81316}, "CVE-2016-0198": {"epss_score": 0.25849, "epss_percentile": 0.96078}, "CVE-2016-0199": {"epss_score": 0.70122, "epss_percentile": 0.98618}, "CVE-2016-0200": {"epss_score": 0.14031, "epss_percentile": 0.94119}, "CVE-2016-0201": {"epss_score": 0.00302, "epss_percentile": 0.53101}, "CVE-2016-0202": {"epss_score": 0.00108, "epss_percentile": 0.29805}, "CVE-2016-0203": {"epss_score": 0.00117, "epss_percentile": 0.31328}, "CVE-2016-0204": {"epss_score": 0.0016, "epss_percentile": 0.37474}, "CVE-2016-0205": {"epss_score": 0.0005, "epss_percentile": 0.15698}, "CVE-2016-0206": {"epss_score": 0.00169, "epss_percentile": 0.38563}, "CVE-2016-0207": {"epss_score": 0.00119, "epss_percentile": 0.31602}, "CVE-2016-0208": {"epss_score": 0.00582, "epss_percentile": 0.68303}, "CVE-2016-0209": {"epss_score": 0.00225, "epss_percentile": 0.45124}, "CVE-2016-0210": {"epss_score": 0.00352, "epss_percentile": 0.57119}, "CVE-2016-0211": {"epss_score": 0.01549, "epss_percentile": 0.80978}, "CVE-2016-0212": {"epss_score": 0.03235, "epss_percentile": 0.86702}, "CVE-2016-0213": {"epss_score": 0.03235, "epss_percentile": 0.86702}, "CVE-2016-0214": {"epss_score": 0.00482, "epss_percentile": 0.64556}, "CVE-2016-0215": {"epss_score": 0.00538, "epss_percentile": 0.66944}, "CVE-2016-0216": {"epss_score": 0.03235, "epss_percentile": 0.86702}, "CVE-2016-0217": {"epss_score": 0.00158, "epss_percentile": 0.37189}, "CVE-2016-0218": {"epss_score": 0.00158, "epss_percentile": 0.37189}, "CVE-2016-0219": {"epss_score": 0.00395, "epss_percentile": 0.59802}, "CVE-2016-0221": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-0222": {"epss_score": 0.00108, "epss_percentile": 0.29855}, "CVE-2016-0223": {"epss_score": 0.00187, "epss_percentile": 0.40715}, "CVE-2016-0224": {"epss_score": 0.00521, "epss_percentile": 0.66219}, "CVE-2016-0225": {"epss_score": 0.00155, "epss_percentile": 0.36776}, "CVE-2016-0226": {"epss_score": 0.00038, "epss_percentile": 0.112}, "CVE-2016-0227": {"epss_score": 0.00241, "epss_percentile": 0.47285}, "CVE-2016-0228": {"epss_score": 0.00103, "epss_percentile": 0.29052}, "CVE-2016-0229": {"epss_score": 0.00225, "epss_percentile": 0.45124}, "CVE-2016-0230": {"epss_score": 0.0008, "epss_percentile": 0.24045}, "CVE-2016-0231": {"epss_score": 0.00335, "epss_percentile": 0.559}, "CVE-2016-0232": {"epss_score": 0.00335, "epss_percentile": 0.559}, "CVE-2016-0233": {"epss_score": 0.00475, "epss_percentile": 0.64176}, "CVE-2016-0234": {"epss_score": 0.00034, "epss_percentile": 0.0955}, "CVE-2016-0235": {"epss_score": 0.00031, "epss_percentile": 0.08535}, "CVE-2016-0236": {"epss_score": 0.02993, "epss_percentile": 0.86149}, "CVE-2016-0237": {"epss_score": 0.00046, "epss_percentile": 0.14193}, "CVE-2016-0238": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2016-0239": {"epss_score": 0.00721, "epss_percentile": 0.71988}, "CVE-2016-0240": {"epss_score": 0.00171, "epss_percentile": 0.38831}, "CVE-2016-0241": {"epss_score": 0.00569, "epss_percentile": 0.67916}, "CVE-2016-0242": {"epss_score": 0.00155, "epss_percentile": 0.36807}, "CVE-2016-0243": {"epss_score": 0.00256, "epss_percentile": 0.48799}, "CVE-2016-0244": {"epss_score": 0.00193, "epss_percentile": 0.41407}, "CVE-2016-0245": {"epss_score": 0.0031, "epss_percentile": 0.53779}, "CVE-2016-0246": {"epss_score": 0.00225, "epss_percentile": 0.45124}, "CVE-2016-0247": {"epss_score": 0.00044, "epss_percentile": 0.13501}, "CVE-2016-0248": {"epss_score": 0.00328, "epss_percentile": 0.5528}, "CVE-2016-0249": {"epss_score": 0.00408, "epss_percentile": 0.6067}, "CVE-2016-0250": {"epss_score": 0.00256, "epss_percentile": 0.4877}, "CVE-2016-0252": {"epss_score": 0.0005, "epss_percentile": 0.15955}, "CVE-2016-0253": {"epss_score": 0.00129, "epss_percentile": 0.33109}, "CVE-2016-0254": {"epss_score": 0.00488, "epss_percentile": 0.64835}, "CVE-2016-0255": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2016-0259": {"epss_score": 0.00043, "epss_percentile": 0.1327}, "CVE-2016-0260": {"epss_score": 0.00665, "epss_percentile": 0.70668}, "CVE-2016-0261": {"epss_score": 0.00129, "epss_percentile": 0.33109}, "CVE-2016-0262": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-0263": {"epss_score": 0.0004, "epss_percentile": 0.11977}, "CVE-2016-0264": {"epss_score": 0.09841, "epss_percentile": 0.9273}, "CVE-2016-0265": {"epss_score": 0.00158, "epss_percentile": 0.37189}, "CVE-2016-0266": {"epss_score": 0.007, "epss_percentile": 0.71471}, "CVE-2016-0267": {"epss_score": 0.00202, "epss_percentile": 0.424}, "CVE-2016-0268": {"epss_score": 0.00188, "epss_percentile": 0.40806}, "CVE-2016-0269": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-0270": {"epss_score": 0.00707, "epss_percentile": 0.71657}, "CVE-2016-0271": {"epss_score": 0.00038, "epss_percentile": 0.11267}, "CVE-2016-0272": {"epss_score": 0.00069, "epss_percentile": 0.21534}, "CVE-2016-0273": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-0274": {"epss_score": 0.00106, "epss_percentile": 0.29556}, "CVE-2016-0275": {"epss_score": 0.00043, "epss_percentile": 0.1327}, "CVE-2016-0276": {"epss_score": 0.00946, "epss_percentile": 0.75813}, "CVE-2016-0277": {"epss_score": 0.0186, "epss_percentile": 0.82589}, "CVE-2016-0278": {"epss_score": 0.01942, "epss_percentile": 0.8299}, "CVE-2016-0279": {"epss_score": 0.0186, "epss_percentile": 0.82589}, "CVE-2016-0280": {"epss_score": 0.00151, "epss_percentile": 0.36319}, "CVE-2016-0281": {"epss_score": 0.03574, "epss_percentile": 0.87376}, "CVE-2016-0282": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-0283": {"epss_score": 0.00266, "epss_percentile": 0.49919}, "CVE-2016-0284": {"epss_score": 0.00334, "epss_percentile": 0.55727}, "CVE-2016-0285": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-0286": {"epss_score": 0.00284, "epss_percentile": 0.51462}, "CVE-2016-0287": {"epss_score": 0.00023, "epss_percentile": 0.05493}, "CVE-2016-0288": {"epss_score": 0.00246, "epss_percentile": 0.47754}, "CVE-2016-0289": {"epss_score": 0.00093, "epss_percentile": 0.26683}, "CVE-2016-0291": {"epss_score": 0.04969, "epss_percentile": 0.89349}, "CVE-2016-0292": {"epss_score": 0.00048, "epss_percentile": 0.15031}, "CVE-2016-0293": {"epss_score": 0.00225, "epss_percentile": 0.45124}, "CVE-2016-0295": {"epss_score": 0.00055, "epss_percentile": 0.17465}, "CVE-2016-0296": {"epss_score": 0.00047, "epss_percentile": 0.1491}, "CVE-2016-0297": {"epss_score": 0.00182, "epss_percentile": 0.40218}, "CVE-2016-0298": {"epss_score": 0.00362, "epss_percentile": 0.57813}, "CVE-2016-0299": {"epss_score": 0.00172, "epss_percentile": 0.38961}, "CVE-2016-0300": {"epss_score": 0.00138, "epss_percentile": 0.34515}, "CVE-2016-0301": {"epss_score": 0.01916, "epss_percentile": 0.82858}, "CVE-2016-0303": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-0304": {"epss_score": 0.0111, "epss_percentile": 0.77659}, "CVE-2016-0305": {"epss_score": 0.00165, "epss_percentile": 0.38033}, "CVE-2016-0306": {"epss_score": 0.00264, "epss_percentile": 0.49682}, "CVE-2016-0307": {"epss_score": 0.00264, "epss_percentile": 0.49572}, "CVE-2016-0308": {"epss_score": 0.00188, "epss_percentile": 0.40891}, "CVE-2016-0310": {"epss_score": 0.00258, "epss_percentile": 0.49}, "CVE-2016-0311": {"epss_score": 0.00175, "epss_percentile": 0.39353}, "CVE-2016-0312": {"epss_score": 0.0024, "epss_percentile": 0.46956}, "CVE-2016-0313": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-0314": {"epss_score": 0.0015, "epss_percentile": 0.36125}, "CVE-2016-0315": {"epss_score": 0.0047, "epss_percentile": 0.6398}, "CVE-2016-0316": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-0317": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2016-0318": {"epss_score": 0.0036, "epss_percentile": 0.57655}, "CVE-2016-0319": {"epss_score": 0.00547, "epss_percentile": 0.67228}, "CVE-2016-0320": {"epss_score": 0.00125, "epss_percentile": 0.32508}, "CVE-2016-0321": {"epss_score": 0.00134, "epss_percentile": 0.33782}, "CVE-2016-0322": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-0323": {"epss_score": 0.0009, "epss_percentile": 0.2617}, "CVE-2016-0324": {"epss_score": 0.03903, "epss_percentile": 0.87923}, "CVE-2016-0325": {"epss_score": 0.0047, "epss_percentile": 0.63993}, "CVE-2016-0326": {"epss_score": 0.00894, "epss_percentile": 0.75087}, "CVE-2016-0327": {"epss_score": 0.00049, "epss_percentile": 0.15491}, "CVE-2016-0328": {"epss_score": 0.00144, "epss_percentile": 0.35239}, "CVE-2016-0329": {"epss_score": 0.00086, "epss_percentile": 0.25407}, "CVE-2016-0330": {"epss_score": 0.00207, "epss_percentile": 0.43148}, "CVE-2016-0331": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-0332": {"epss_score": 0.00356, "epss_percentile": 0.57332}, "CVE-2016-0335": {"epss_score": 0.00076, "epss_percentile": 0.23104}, "CVE-2016-0336": {"epss_score": 0.00129, "epss_percentile": 0.33109}, "CVE-2016-0338": {"epss_score": 0.0005, "epss_percentile": 0.15955}, "CVE-2016-0339": {"epss_score": 0.00231, "epss_percentile": 0.458}, "CVE-2016-0340": {"epss_score": 0.00198, "epss_percentile": 0.42067}, "CVE-2016-0341": {"epss_score": 0.00267, "epss_percentile": 0.5}, "CVE-2016-0342": {"epss_score": 0.00091, "epss_percentile": 0.26194}, "CVE-2016-0343": {"epss_score": 0.00119, "epss_percentile": 0.31536}, "CVE-2016-0344": {"epss_score": 0.00129, "epss_percentile": 0.33109}, "CVE-2016-0345": {"epss_score": 0.00119, "epss_percentile": 0.31536}, "CVE-2016-0346": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-0348": {"epss_score": 0.00094, "epss_percentile": 0.268}, "CVE-2016-0349": {"epss_score": 0.00105, "epss_percentile": 0.29342}, "CVE-2016-0350": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-0351": {"epss_score": 0.00172, "epss_percentile": 0.38961}, "CVE-2016-0353": {"epss_score": 0.00207, "epss_percentile": 0.43148}, "CVE-2016-0354": {"epss_score": 0.00346, "epss_percentile": 0.56704}, "CVE-2016-0355": {"epss_score": 0.00261, "epss_percentile": 0.49292}, "CVE-2016-0356": {"epss_score": 0.00261, "epss_percentile": 0.49292}, "CVE-2016-0357": {"epss_score": 0.00214, "epss_percentile": 0.43964}, "CVE-2016-0358": {"epss_score": 0.00212, "epss_percentile": 0.43805}, "CVE-2016-0359": {"epss_score": 0.00312, "epss_percentile": 0.53956}, "CVE-2016-0360": {"epss_score": 0.00962, "epss_percentile": 0.75993}, "CVE-2016-0361": {"epss_score": 0.00201, "epss_percentile": 0.42336}, "CVE-2016-0362": {"epss_score": 0.00138, "epss_percentile": 0.34505}, "CVE-2016-0363": {"epss_score": 0.00637, "epss_percentile": 0.69885}, "CVE-2016-0364": {"epss_score": 0.00155, "epss_percentile": 0.36807}, "CVE-2016-0365": {"epss_score": 0.00188, "epss_percentile": 0.40916}, "CVE-2016-0366": {"epss_score": 0.00092, "epss_percentile": 0.26583}, "CVE-2016-0367": {"epss_score": 0.00119, "epss_percentile": 0.31536}, "CVE-2016-0369": {"epss_score": 0.00112, "epss_percentile": 0.3057}, "CVE-2016-0370": {"epss_score": 0.0016, "epss_percentile": 0.37429}, "CVE-2016-0371": {"epss_score": 0.00062, "epss_percentile": 0.19609}, "CVE-2016-0372": {"epss_score": 0.00263, "epss_percentile": 0.49516}, "CVE-2016-0373": {"epss_score": 0.00102, "epss_percentile": 0.28875}, "CVE-2016-0374": {"epss_score": 0.00599, "epss_percentile": 0.68802}, "CVE-2016-0375": {"epss_score": 0.0107, "epss_percentile": 0.77259}, "CVE-2016-0376": {"epss_score": 0.01931, "epss_percentile": 0.82941}, "CVE-2016-0377": {"epss_score": 0.00232, "epss_percentile": 0.45968}, "CVE-2016-0378": {"epss_score": 0.00336, "epss_percentile": 0.55919}, "CVE-2016-0379": {"epss_score": 0.0032, "epss_percentile": 0.54633}, "CVE-2016-0380": {"epss_score": 0.00041, "epss_percentile": 0.12237}, "CVE-2016-0381": {"epss_score": 0.00372, "epss_percentile": 0.58435}, "CVE-2016-0382": {"epss_score": 0.00058, "epss_percentile": 0.18614}, "CVE-2016-0385": {"epss_score": 0.00247, "epss_percentile": 0.47837}, "CVE-2016-0386": {"epss_score": 0.00096, "epss_percentile": 0.27327}, "CVE-2016-0387": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-0389": {"epss_score": 0.00226, "epss_percentile": 0.45279}, "CVE-2016-0390": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-0391": {"epss_score": 0.00861, "epss_percentile": 0.74546}, "CVE-2016-0392": {"epss_score": 0.00058, "epss_percentile": 0.18423}, "CVE-2016-0393": {"epss_score": 0.00207, "epss_percentile": 0.43148}, "CVE-2016-0394": {"epss_score": 0.00049, "epss_percentile": 0.15645}, "CVE-2016-0396": {"epss_score": 0.00531, "epss_percentile": 0.66668}, "CVE-2016-0397": {"epss_score": 0.0021, "epss_percentile": 0.43435}, "CVE-2016-0398": {"epss_score": 0.0031, "epss_percentile": 0.5376}, "CVE-2016-0399": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-0400": {"epss_score": 0.03486, "epss_percentile": 0.87227}, "CVE-2016-0401": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0402": {"epss_score": 0.03273, "epss_percentile": 0.86798}, "CVE-2016-0403": {"epss_score": 0.00717, "epss_percentile": 0.7189}, "CVE-2016-0404": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0405": {"epss_score": 0.00137, "epss_percentile": 0.34286}, "CVE-2016-0406": {"epss_score": 0.00111, "epss_percentile": 0.30384}, "CVE-2016-0407": {"epss_score": 0.00181, "epss_percentile": 0.40107}, "CVE-2016-0408": {"epss_score": 0.00177, "epss_percentile": 0.39619}, "CVE-2016-0409": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2016-0411": {"epss_score": 0.00176, "epss_percentile": 0.39418}, "CVE-2016-0412": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2016-0413": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2016-0414": {"epss_score": 0.00188, "epss_percentile": 0.4092}, "CVE-2016-0415": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2016-0416": {"epss_score": 0.00387, "epss_percentile": 0.59328}, "CVE-2016-0417": {"epss_score": 0.00176, "epss_percentile": 0.39418}, "CVE-2016-0418": {"epss_score": 0.00209, "epss_percentile": 0.4333}, "CVE-2016-0419": {"epss_score": 0.00142, "epss_percentile": 0.34981}, "CVE-2016-0420": {"epss_score": 0.0102, "epss_percentile": 0.7674}, "CVE-2016-0421": {"epss_score": 0.00874, "epss_percentile": 0.74767}, "CVE-2016-0422": {"epss_score": 0.00955, "epss_percentile": 0.75912}, "CVE-2016-0423": {"epss_score": 0.01361, "epss_percentile": 0.79756}, "CVE-2016-0424": {"epss_score": 0.00955, "epss_percentile": 0.75912}, "CVE-2016-0425": {"epss_score": 0.00545, "epss_percentile": 0.67153}, "CVE-2016-0426": {"epss_score": 0.00188, "epss_percentile": 0.40837}, "CVE-2016-0427": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2016-0428": {"epss_score": 0.00142, "epss_percentile": 0.34981}, "CVE-2016-0429": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0430": {"epss_score": 0.00295, "epss_percentile": 0.5251}, "CVE-2016-0431": {"epss_score": 0.00127, "epss_percentile": 0.32933}, "CVE-2016-0432": {"epss_score": 0.00123, "epss_percentile": 0.32265}, "CVE-2016-0433": {"epss_score": 0.00295, "epss_percentile": 0.5251}, "CVE-2016-0434": {"epss_score": 0.00283, "epss_percentile": 0.51381}, "CVE-2016-0435": {"epss_score": 0.00275, "epss_percentile": 0.50634}, "CVE-2016-0436": {"epss_score": 0.00283, "epss_percentile": 0.51381}, "CVE-2016-0437": {"epss_score": 0.00283, "epss_percentile": 0.51381}, "CVE-2016-0438": {"epss_score": 0.00116, "epss_percentile": 0.31192}, "CVE-2016-0439": {"epss_score": 0.00295, "epss_percentile": 0.5251}, "CVE-2016-0440": {"epss_score": 0.00836, "epss_percentile": 0.7414}, "CVE-2016-0441": {"epss_score": 0.00445, "epss_percentile": 0.62886}, "CVE-2016-0442": {"epss_score": 0.00375, "epss_percentile": 0.58637}, "CVE-2016-0443": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0444": {"epss_score": 0.00129, "epss_percentile": 0.33213}, "CVE-2016-0445": {"epss_score": 0.00176, "epss_percentile": 0.39418}, "CVE-2016-0446": {"epss_score": 0.00158, "epss_percentile": 0.37246}, "CVE-2016-0447": {"epss_score": 0.00176, "epss_percentile": 0.39418}, "CVE-2016-0448": {"epss_score": 0.00331, "epss_percentile": 0.55529}, "CVE-2016-0449": {"epss_score": 0.00176, "epss_percentile": 0.39418}, "CVE-2016-0450": {"epss_score": 0.03183, "epss_percentile": 0.86584}, "CVE-2016-0451": {"epss_score": 0.12412, "epss_percentile": 0.93663}, "CVE-2016-0452": {"epss_score": 0.11887, "epss_percentile": 0.93506}, "CVE-2016-0453": {"epss_score": 0.00521, "epss_percentile": 0.66247}, "CVE-2016-0454": {"epss_score": 0.00158, "epss_percentile": 0.37246}, "CVE-2016-0455": {"epss_score": 0.00124, "epss_percentile": 0.32461}, "CVE-2016-0456": {"epss_score": 0.00406, "epss_percentile": 0.60522}, "CVE-2016-0457": {"epss_score": 0.00563, "epss_percentile": 0.67733}, "CVE-2016-0458": {"epss_score": 0.00103, "epss_percentile": 0.28971}, "CVE-2016-0459": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2016-0460": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0461": {"epss_score": 0.00414, "epss_percentile": 0.61039}, "CVE-2016-0462": {"epss_score": 0.00197, "epss_percentile": 0.41949}, "CVE-2016-0463": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0464": {"epss_score": 0.00324, "epss_percentile": 0.54931}, "CVE-2016-0465": {"epss_score": 0.00142, "epss_percentile": 0.34981}, "CVE-2016-0466": {"epss_score": 0.03924, "epss_percentile": 0.8796}, "CVE-2016-0467": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2016-0468": {"epss_score": 0.00129, "epss_percentile": 0.33131}, "CVE-2016-0469": {"epss_score": 0.00061, "epss_percentile": 0.19387}, "CVE-2016-0470": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2016-0471": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0472": {"epss_score": 0.00387, "epss_percentile": 0.59302}, "CVE-2016-0473": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2016-0474": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2016-0475": {"epss_score": 0.0112, "epss_percentile": 0.77761}, "CVE-2016-0476": {"epss_score": 0.02378, "epss_percentile": 0.84558}, "CVE-2016-0477": {"epss_score": 0.02378, "epss_percentile": 0.84558}, "CVE-2016-0478": {"epss_score": 0.02378, "epss_percentile": 0.84558}, "CVE-2016-0479": {"epss_score": 0.00187, "epss_percentile": 0.40757}, "CVE-2016-0480": {"epss_score": 0.02378, "epss_percentile": 0.84558}, "CVE-2016-0481": {"epss_score": 0.02378, "epss_percentile": 0.84558}, "CVE-2016-0482": {"epss_score": 0.02378, "epss_percentile": 0.84558}, "CVE-2016-0483": {"epss_score": 0.12599, "epss_percentile": 0.93725}, "CVE-2016-0484": {"epss_score": 0.02378, "epss_percentile": 0.84558}, "CVE-2016-0485": {"epss_score": 0.18296, "epss_percentile": 0.94991}, "CVE-2016-0486": {"epss_score": 0.18296, "epss_percentile": 0.94991}, "CVE-2016-0487": {"epss_score": 0.2134, "epss_percentile": 0.95503}, "CVE-2016-0488": {"epss_score": 0.2134, "epss_percentile": 0.95503}, "CVE-2016-0489": {"epss_score": 0.17703, "epss_percentile": 0.94893}, "CVE-2016-0490": {"epss_score": 0.17876, "epss_percentile": 0.94921}, "CVE-2016-0491": {"epss_score": 0.88432, "epss_percentile": 0.99472}, "CVE-2016-0492": {"epss_score": 0.91458, "epss_percentile": 0.99645}, "CVE-2016-0493": {"epss_score": 0.00081, "epss_percentile": 0.24258}, "CVE-2016-0494": {"epss_score": 0.0867, "epss_percentile": 0.92182}, "CVE-2016-0495": {"epss_score": 0.01001, "epss_percentile": 0.76495}, "CVE-2016-0496": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0497": {"epss_score": 0.00348, "epss_percentile": 0.56821}, "CVE-2016-0498": {"epss_score": 0.00073, "epss_percentile": 0.22619}, "CVE-2016-0499": {"epss_score": 0.01126, "epss_percentile": 0.77818}, "CVE-2016-0500": {"epss_score": 0.00685, "epss_percentile": 0.71137}, "CVE-2016-0501": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2016-0502": {"epss_score": 0.0146, "epss_percentile": 0.80422}, "CVE-2016-0503": {"epss_score": 0.00688, "epss_percentile": 0.71213}, "CVE-2016-0504": {"epss_score": 0.02307, "epss_percentile": 0.84327}, "CVE-2016-0505": {"epss_score": 0.00709, "epss_percentile": 0.71692}, "CVE-2016-0506": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0507": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2016-0508": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0509": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2016-0510": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0511": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0512": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0513": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0514": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0515": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0516": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0517": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0518": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0519": {"epss_score": 0.00287, "epss_percentile": 0.51799}, "CVE-2016-0520": {"epss_score": 0.00275, "epss_percentile": 0.50661}, "CVE-2016-0521": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0522": {"epss_score": 0.00685, "epss_percentile": 0.71137}, "CVE-2016-0523": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2016-0524": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0525": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0526": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0527": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0528": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0529": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0530": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0531": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2016-0532": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0533": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0534": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0535": {"epss_score": 0.00615, "epss_percentile": 0.69316}, "CVE-2016-0536": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0537": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0538": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0539": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0540": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0541": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0542": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0543": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0544": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0545": {"epss_score": 0.04192, "epss_percentile": 0.88377}, "CVE-2016-0546": {"epss_score": 0.0018, "epss_percentile": 0.39917}, "CVE-2016-0547": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0548": {"epss_score": 0.003, "epss_percentile": 0.5298}, "CVE-2016-0549": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0550": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0551": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0552": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0553": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0554": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0555": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0556": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2016-0557": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2016-0558": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0559": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0560": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0561": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2016-0562": {"epss_score": 0.0015, "epss_percentile": 0.36172}, "CVE-2016-0563": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0564": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2016-0565": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0566": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0567": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0568": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0569": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0570": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0571": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2016-0572": {"epss_score": 0.00915, "epss_percentile": 0.75397}, "CVE-2016-0573": {"epss_score": 0.00761, "epss_percentile": 0.7283}, "CVE-2016-0574": {"epss_score": 0.01032, "epss_percentile": 0.76859}, "CVE-2016-0575": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0576": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0577": {"epss_score": 0.01032, "epss_percentile": 0.76859}, "CVE-2016-0578": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0579": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0580": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2016-0581": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0582": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0583": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0584": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0585": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2016-0586": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0587": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2016-0588": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0589": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0590": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2016-0591": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2016-0592": {"epss_score": 0.00091, "epss_percentile": 0.26231}, "CVE-2016-0594": {"epss_score": 0.00338, "epss_percentile": 0.56118}, "CVE-2016-0595": {"epss_score": 0.00688, "epss_percentile": 0.71213}, "CVE-2016-0596": {"epss_score": 0.00491, "epss_percentile": 0.64946}, "CVE-2016-0597": {"epss_score": 0.00491, "epss_percentile": 0.64946}, "CVE-2016-0598": {"epss_score": 0.00338, "epss_percentile": 0.56131}, "CVE-2016-0599": {"epss_score": 0.00198, "epss_percentile": 0.42001}, "CVE-2016-0600": {"epss_score": 0.00338, "epss_percentile": 0.56131}, "CVE-2016-0601": {"epss_score": 0.00198, "epss_percentile": 0.42001}, "CVE-2016-0602": {"epss_score": 0.01047, "epss_percentile": 0.77044}, "CVE-2016-0603": {"epss_score": 0.03, "epss_percentile": 0.86164}, "CVE-2016-0605": {"epss_score": 0.00591, "epss_percentile": 0.68593}, "CVE-2016-0606": {"epss_score": 0.00166, "epss_percentile": 0.38242}, "CVE-2016-0607": {"epss_score": 0.00655, "epss_percentile": 0.70424}, "CVE-2016-0608": {"epss_score": 0.00338, "epss_percentile": 0.56131}, "CVE-2016-0609": {"epss_score": 0.00794, "epss_percentile": 0.73457}, "CVE-2016-0610": {"epss_score": 0.00716, "epss_percentile": 0.71855}, "CVE-2016-0611": {"epss_score": 0.00711, "epss_percentile": 0.7173}, "CVE-2016-0614": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2016-0616": {"epss_score": 0.00472, "epss_percentile": 0.6407}, "CVE-2016-0617": {"epss_score": 0.00062, "epss_percentile": 0.19637}, "CVE-2016-0618": {"epss_score": 0.0008, "epss_percentile": 0.24038}, "CVE-2016-0623": {"epss_score": 0.00229, "epss_percentile": 0.45622}, "CVE-2016-0634": {"epss_score": 0.01448, "epss_percentile": 0.80337}, "CVE-2016-0635": {"epss_score": 0.06637, "epss_percentile": 0.90908}, "CVE-2016-0636": {"epss_score": 0.0802, "epss_percentile": 0.91833}, "CVE-2016-0638": {"epss_score": 0.73225, "epss_percentile": 0.98741}, "CVE-2016-0639": {"epss_score": 0.17044, "epss_percentile": 0.94764}, "CVE-2016-0640": {"epss_score": 0.00225, "epss_percentile": 0.45228}, "CVE-2016-0641": {"epss_score": 0.0025, "epss_percentile": 0.48094}, "CVE-2016-0642": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2016-0643": {"epss_score": 0.00362, "epss_percentile": 0.5782}, "CVE-2016-0644": {"epss_score": 0.00214, "epss_percentile": 0.43962}, "CVE-2016-0646": {"epss_score": 0.00214, "epss_percentile": 0.43962}, "CVE-2016-0647": {"epss_score": 0.0033, "epss_percentile": 0.55425}, "CVE-2016-0648": {"epss_score": 0.00243, "epss_percentile": 0.47423}, "CVE-2016-0649": {"epss_score": 0.00214, "epss_percentile": 0.43962}, "CVE-2016-0650": {"epss_score": 0.00214, "epss_percentile": 0.43962}, "CVE-2016-0651": {"epss_score": 0.00246, "epss_percentile": 0.47749}, "CVE-2016-0652": {"epss_score": 0.00128, "epss_percentile": 0.32962}, "CVE-2016-0653": {"epss_score": 0.00128, "epss_percentile": 0.32962}, "CVE-2016-0654": {"epss_score": 0.00128, "epss_percentile": 0.32962}, "CVE-2016-0655": {"epss_score": 0.00244, "epss_percentile": 0.47575}, "CVE-2016-0656": {"epss_score": 0.00128, "epss_percentile": 0.32962}, "CVE-2016-0657": {"epss_score": 0.00137, "epss_percentile": 0.34316}, "CVE-2016-0658": {"epss_score": 0.00128, "epss_percentile": 0.32962}, "CVE-2016-0659": {"epss_score": 0.00144, "epss_percentile": 0.35307}, "CVE-2016-0661": {"epss_score": 0.00194, "epss_percentile": 0.41553}, "CVE-2016-0662": {"epss_score": 0.00144, "epss_percentile": 0.35307}, "CVE-2016-0663": {"epss_score": 0.00128, "epss_percentile": 0.32962}, "CVE-2016-0665": {"epss_score": 0.00145, "epss_percentile": 0.35429}, "CVE-2016-0666": {"epss_score": 0.00243, "epss_percentile": 0.47423}, "CVE-2016-0667": {"epss_score": 0.00155, "epss_percentile": 0.36857}, "CVE-2016-0668": {"epss_score": 0.00357, "epss_percentile": 0.57477}, "CVE-2016-0669": {"epss_score": 0.00035, "epss_percentile": 0.09885}, "CVE-2016-0671": {"epss_score": 0.00253, "epss_percentile": 0.4847}, "CVE-2016-0672": {"epss_score": 0.00193, "epss_percentile": 0.41396}, "CVE-2016-0673": {"epss_score": 0.0014, "epss_percentile": 0.34731}, "CVE-2016-0674": {"epss_score": 0.00044, "epss_percentile": 0.13421}, "CVE-2016-0675": {"epss_score": 0.00204, "epss_percentile": 0.42607}, "CVE-2016-0676": {"epss_score": 0.00052, "epss_percentile": 0.16471}, "CVE-2016-0677": {"epss_score": 0.01044, "epss_percentile": 0.77}, "CVE-2016-0678": {"epss_score": 0.00112, "epss_percentile": 0.30433}, "CVE-2016-0679": {"epss_score": 0.00348, "epss_percentile": 0.56796}, "CVE-2016-0680": {"epss_score": 0.00135, "epss_percentile": 0.34029}, "CVE-2016-0681": {"epss_score": 0.00226, "epss_percentile": 0.45269}, "CVE-2016-0682": {"epss_score": 0.00178, "epss_percentile": 0.39701}, "CVE-2016-0683": {"epss_score": 0.0014, "epss_percentile": 0.34731}, "CVE-2016-0684": {"epss_score": 0.0023, "epss_percentile": 0.45737}, "CVE-2016-0685": {"epss_score": 0.0014, "epss_percentile": 0.34731}, "CVE-2016-0686": {"epss_score": 0.05413, "epss_percentile": 0.89848}, "CVE-2016-0687": {"epss_score": 0.05413, "epss_percentile": 0.89848}, "CVE-2016-0688": {"epss_score": 0.00261, "epss_percentile": 0.49271}, "CVE-2016-0689": {"epss_score": 0.00178, "epss_percentile": 0.39701}, "CVE-2016-0690": {"epss_score": 0.00149, "epss_percentile": 0.35963}, "CVE-2016-0691": {"epss_score": 0.00149, "epss_percentile": 0.35963}, "CVE-2016-0692": {"epss_score": 0.00152, "epss_percentile": 0.36465}, "CVE-2016-0693": {"epss_score": 0.0213, "epss_percentile": 0.83709}, "CVE-2016-0694": {"epss_score": 0.00178, "epss_percentile": 0.39701}, "CVE-2016-0695": {"epss_score": 0.02922, "epss_percentile": 0.85993}, "CVE-2016-0696": {"epss_score": 0.00204, "epss_percentile": 0.42607}, "CVE-2016-0697": {"epss_score": 0.002, "epss_percentile": 0.42232}, "CVE-2016-0698": {"epss_score": 0.00177, "epss_percentile": 0.39619}, "CVE-2016-0699": {"epss_score": 0.00666, "epss_percentile": 0.70686}, "CVE-2016-0700": {"epss_score": 0.00204, "epss_percentile": 0.42607}, "CVE-2016-0701": {"epss_score": 0.24988, "epss_percentile": 0.95976}, "CVE-2016-0702": {"epss_score": 0.00461, "epss_percentile": 0.63538}, "CVE-2016-0703": {"epss_score": 0.04941, "epss_percentile": 0.89307}, "CVE-2016-0704": {"epss_score": 0.05992, "epss_percentile": 0.90388}, "CVE-2016-0705": {"epss_score": 0.20656, "epss_percentile": 0.95395}, "CVE-2016-0706": {"epss_score": 0.00618, "epss_percentile": 0.69371}, "CVE-2016-0707": {"epss_score": 0.00057, "epss_percentile": 0.17981}, "CVE-2016-0708": {"epss_score": 0.00216, "epss_percentile": 0.44158}, "CVE-2016-0709": {"epss_score": 0.66979, "epss_percentile": 0.98488}, "CVE-2016-0710": {"epss_score": 0.7922, "epss_percentile": 0.99024}, "CVE-2016-0711": {"epss_score": 0.02552, "epss_percentile": 0.85082}, "CVE-2016-0712": {"epss_score": 0.02552, "epss_percentile": 0.85082}, "CVE-2016-0713": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2016-0714": {"epss_score": 0.10317, "epss_percentile": 0.92941}, "CVE-2016-0715": {"epss_score": 0.00212, "epss_percentile": 0.43796}, "CVE-2016-0718": {"epss_score": 0.01745, "epss_percentile": 0.82068}, "CVE-2016-0720": {"epss_score": 0.00431, "epss_percentile": 0.62088}, "CVE-2016-0721": {"epss_score": 0.00445, "epss_percentile": 0.62873}, "CVE-2016-0723": {"epss_score": 0.00026, "epss_percentile": 0.06404}, "CVE-2016-0724": {"epss_score": 0.00578, "epss_percentile": 0.68176}, "CVE-2016-0725": {"epss_score": 0.00596, "epss_percentile": 0.68719}, "CVE-2016-0726": {"epss_score": 0.0035, "epss_percentile": 0.56953}, "CVE-2016-0727": {"epss_score": 0.03038, "epss_percentile": 0.86267}, "CVE-2016-0728": {"epss_score": 0.52958, "epss_percentile": 0.97848}, "CVE-2016-0729": {"epss_score": 0.23016, "epss_percentile": 0.95718}, "CVE-2016-0731": {"epss_score": 0.00201, "epss_percentile": 0.42348}, "CVE-2016-0732": {"epss_score": 0.00414, "epss_percentile": 0.6104}, "CVE-2016-0733": {"epss_score": 0.01652, "epss_percentile": 0.81574}, "CVE-2016-0734": {"epss_score": 0.02975, "epss_percentile": 0.86105}, "CVE-2016-0735": {"epss_score": 0.00145, "epss_percentile": 0.35403}, "CVE-2016-0736": {"epss_score": 0.4168, "epss_percentile": 0.97289}, "CVE-2016-0737": {"epss_score": 0.05828, "epss_percentile": 0.90239}, "CVE-2016-0738": {"epss_score": 0.05828, "epss_percentile": 0.90239}, "CVE-2016-0739": {"epss_score": 0.04313, "epss_percentile": 0.88535}, "CVE-2016-0740": {"epss_score": 0.00146, "epss_percentile": 0.35583}, "CVE-2016-0741": {"epss_score": 0.04948, "epss_percentile": 0.8932}, "CVE-2016-0742": {"epss_score": 0.80364, "epss_percentile": 0.99084}, "CVE-2016-0746": {"epss_score": 0.14006, "epss_percentile": 0.94113}, "CVE-2016-0747": {"epss_score": 0.33182, "epss_percentile": 0.96752}, "CVE-2016-0749": {"epss_score": 0.28815, "epss_percentile": 0.96389}, "CVE-2016-0750": {"epss_score": 0.00556, "epss_percentile": 0.67513}, "CVE-2016-0751": {"epss_score": 0.06145, "epss_percentile": 0.90517}, "CVE-2016-0752": {"epss_score": 0.92705, "epss_percentile": 0.99737}, "CVE-2016-0753": {"epss_score": 0.02328, "epss_percentile": 0.84395}, "CVE-2016-0754": {"epss_score": 0.00351, "epss_percentile": 0.57007}, "CVE-2016-0755": {"epss_score": 0.00412, "epss_percentile": 0.60932}, "CVE-2016-0756": {"epss_score": 0.00681, "epss_percentile": 0.71057}, "CVE-2016-0757": {"epss_score": 0.00233, "epss_percentile": 0.46026}, "CVE-2016-0758": {"epss_score": 0.00204, "epss_percentile": 0.42662}, "CVE-2016-0760": {"epss_score": 0.00713, "epss_percentile": 0.71781}, "CVE-2016-0761": {"epss_score": 0.00551, "epss_percentile": 0.67357}, "CVE-2016-0762": {"epss_score": 0.00714, "epss_percentile": 0.71808}, "CVE-2016-0763": {"epss_score": 0.00329, "epss_percentile": 0.55394}, "CVE-2016-0764": {"epss_score": 0.00035, "epss_percentile": 0.09994}, "CVE-2016-0765": {"epss_score": 0.00297, "epss_percentile": 0.52711}, "CVE-2016-0766": {"epss_score": 0.01951, "epss_percentile": 0.83016}, "CVE-2016-0767": {"epss_score": 0.00123, "epss_percentile": 0.32298}, "CVE-2016-0768": {"epss_score": 0.00239, "epss_percentile": 0.46912}, "CVE-2016-0769": {"epss_score": 0.02109, "epss_percentile": 0.83642}, "CVE-2016-0770": {"epss_score": 0.00587, "epss_percentile": 0.68469}, "CVE-2016-0771": {"epss_score": 0.05663, "epss_percentile": 0.90098}, "CVE-2016-0772": {"epss_score": 0.05778, "epss_percentile": 0.90198}, "CVE-2016-0773": {"epss_score": 0.09468, "epss_percentile": 0.92561}, "CVE-2016-0774": {"epss_score": 0.00057, "epss_percentile": 0.18165}, "CVE-2016-0775": {"epss_score": 0.01369, "epss_percentile": 0.79797}, "CVE-2016-0777": {"epss_score": 0.67203, "epss_percentile": 0.98498}, "CVE-2016-0778": {"epss_score": 0.01594, "epss_percentile": 0.81232}, "CVE-2016-0779": {"epss_score": 0.04965, "epss_percentile": 0.89342}, "CVE-2016-0780": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2016-0781": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2016-0782": {"epss_score": 0.01162, "epss_percentile": 0.78152}, "CVE-2016-0783": {"epss_score": 0.00918, "epss_percentile": 0.75438}, "CVE-2016-0784": {"epss_score": 0.06065, "epss_percentile": 0.90447}, "CVE-2016-0785": {"epss_score": 0.35278, "epss_percentile": 0.96898}, "CVE-2016-0787": {"epss_score": 0.04065, "epss_percentile": 0.88198}, "CVE-2016-0788": {"epss_score": 0.3743, "epss_percentile": 0.97046}, "CVE-2016-0789": {"epss_score": 0.00148, "epss_percentile": 0.35845}, "CVE-2016-0790": {"epss_score": 0.00212, "epss_percentile": 0.43812}, "CVE-2016-0791": {"epss_score": 0.00469, "epss_percentile": 0.63936}, "CVE-2016-0792": {"epss_score": 0.90851, "epss_percentile": 0.99605}, "CVE-2016-0793": {"epss_score": 0.35266, "epss_percentile": 0.96897}, "CVE-2016-0794": {"epss_score": 0.00494, "epss_percentile": 0.6508}, "CVE-2016-0795": {"epss_score": 0.00547, "epss_percentile": 0.67243}, "CVE-2016-0796": {"epss_score": 0.00536, "epss_percentile": 0.66848}, "CVE-2016-0797": {"epss_score": 0.35729, "epss_percentile": 0.96929}, "CVE-2016-0798": {"epss_score": 0.29625, "epss_percentile": 0.96462}, "CVE-2016-0799": {"epss_score": 0.43537, "epss_percentile": 0.97391}, "CVE-2016-0800": {"epss_score": 0.89906, "epss_percentile": 0.99548}, "CVE-2016-0801": {"epss_score": 0.51228, "epss_percentile": 0.9777}, "CVE-2016-0802": {"epss_score": 0.06746, "epss_percentile": 0.90999}, "CVE-2016-0803": {"epss_score": 0.01215, "epss_percentile": 0.78588}, "CVE-2016-0804": {"epss_score": 0.01215, "epss_percentile": 0.78588}, "CVE-2016-0805": {"epss_score": 0.00127, "epss_percentile": 0.32871}, "CVE-2016-0806": {"epss_score": 0.00015, "epss_percentile": 0.02285}, "CVE-2016-0807": {"epss_score": 0.00015, "epss_percentile": 0.02285}, "CVE-2016-0808": {"epss_score": 0.00017, "epss_percentile": 0.03339}, "CVE-2016-0809": {"epss_score": 0.0004, "epss_percentile": 0.12192}, "CVE-2016-0810": {"epss_score": 0.00014, "epss_percentile": 0.02116}, "CVE-2016-0811": {"epss_score": 0.00111, "epss_percentile": 0.30405}, "CVE-2016-0812": {"epss_score": 0.00017, "epss_percentile": 0.03198}, "CVE-2016-0813": {"epss_score": 0.00017, "epss_percentile": 0.03198}, "CVE-2016-0815": {"epss_score": 0.01903, "epss_percentile": 0.82786}, "CVE-2016-0816": {"epss_score": 0.02229, "epss_percentile": 0.84082}, "CVE-2016-0818": {"epss_score": 0.00058, "epss_percentile": 0.18305}, "CVE-2016-0819": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-0820": {"epss_score": 0.00021, "epss_percentile": 0.04844}, "CVE-2016-0821": {"epss_score": 0.0001, "epss_percentile": 0.00901}, "CVE-2016-0822": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-0823": {"epss_score": 0.00016, "epss_percentile": 0.02874}, "CVE-2016-0824": {"epss_score": 0.00164, "epss_percentile": 0.37942}, "CVE-2016-0825": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2016-0826": {"epss_score": 0.00067, "epss_percentile": 0.21081}, "CVE-2016-0827": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2016-0828": {"epss_score": 0.00202, "epss_percentile": 0.42428}, "CVE-2016-0829": {"epss_score": 0.00202, "epss_percentile": 0.42428}, "CVE-2016-0830": {"epss_score": 0.00245, "epss_percentile": 0.47656}, "CVE-2016-0831": {"epss_score": 0.00125, "epss_percentile": 0.32563}, "CVE-2016-0832": {"epss_score": 0.00017, "epss_percentile": 0.03198}, "CVE-2016-0833": {"epss_score": 0.00127, "epss_percentile": 0.32809}, "CVE-2016-0834": {"epss_score": 0.00674, "epss_percentile": 0.70847}, "CVE-2016-0835": {"epss_score": 0.05364, "epss_percentile": 0.89785}, "CVE-2016-0836": {"epss_score": 0.0067, "epss_percentile": 0.70777}, "CVE-2016-0837": {"epss_score": 0.01215, "epss_percentile": 0.78588}, "CVE-2016-0838": {"epss_score": 0.02229, "epss_percentile": 0.84082}, "CVE-2016-0839": {"epss_score": 0.01215, "epss_percentile": 0.78588}, "CVE-2016-0840": {"epss_score": 0.00791, "epss_percentile": 0.73395}, "CVE-2016-0841": {"epss_score": 0.01215, "epss_percentile": 0.78588}, "CVE-2016-0842": {"epss_score": 0.00791, "epss_percentile": 0.73395}, "CVE-2016-0843": {"epss_score": 0.00015, "epss_percentile": 0.02285}, "CVE-2016-0844": {"epss_score": 0.00016, "epss_percentile": 0.02828}, "CVE-2016-0846": {"epss_score": 0.00527, "epss_percentile": 0.66528}, "CVE-2016-0847": {"epss_score": 0.00024, "epss_percentile": 0.05997}, "CVE-2016-0848": {"epss_score": 0.00012, "epss_percentile": 0.01155}, "CVE-2016-0849": {"epss_score": 0.00015, "epss_percentile": 0.02285}, "CVE-2016-0850": {"epss_score": 0.00085, "epss_percentile": 0.2512}, "CVE-2016-0851": {"epss_score": 0.0024, "epss_percentile": 0.47214}, "CVE-2016-0852": {"epss_score": 0.00167, "epss_percentile": 0.38349}, "CVE-2016-0853": {"epss_score": 0.00404, "epss_percentile": 0.60413}, "CVE-2016-0854": {"epss_score": 0.73701, "epss_percentile": 0.98768}, "CVE-2016-0855": {"epss_score": 0.03548, "epss_percentile": 0.87332}, "CVE-2016-0856": {"epss_score": 0.6094, "epss_percentile": 0.98228}, "CVE-2016-0857": {"epss_score": 0.0532, "epss_percentile": 0.89729}, "CVE-2016-0858": {"epss_score": 0.01514, "epss_percentile": 0.80792}, "CVE-2016-0859": {"epss_score": 0.0179, "epss_percentile": 0.82278}, "CVE-2016-0860": {"epss_score": 0.01276, "epss_percentile": 0.79109}, "CVE-2016-0861": {"epss_score": 0.1006, "epss_percentile": 0.92836}, "CVE-2016-0862": {"epss_score": 0.19227, "epss_percentile": 0.95153}, "CVE-2016-0863": {"epss_score": 0.00064, "epss_percentile": 0.20149}, "CVE-2016-0864": {"epss_score": 0.00318, "epss_percentile": 0.5445}, "CVE-2016-0865": {"epss_score": 0.00227, "epss_percentile": 0.4542}, "CVE-2016-0866": {"epss_score": 0.00337, "epss_percentile": 0.56053}, "CVE-2016-0867": {"epss_score": 0.00335, "epss_percentile": 0.55865}, "CVE-2016-0868": {"epss_score": 0.00207, "epss_percentile": 0.43202}, "CVE-2016-0869": {"epss_score": 0.00231, "epss_percentile": 0.45831}, "CVE-2016-0870": {"epss_score": 0.00568, "epss_percentile": 0.67908}, "CVE-2016-0871": {"epss_score": 0.00539, "epss_percentile": 0.66963}, "CVE-2016-0872": {"epss_score": 0.00253, "epss_percentile": 0.48437}, "CVE-2016-0875": {"epss_score": 0.00752, "epss_percentile": 0.72666}, "CVE-2016-0876": {"epss_score": 0.00402, "epss_percentile": 0.60282}, "CVE-2016-0877": {"epss_score": 0.00723, "epss_percentile": 0.72024}, "CVE-2016-0878": {"epss_score": 0.00723, "epss_percentile": 0.72024}, "CVE-2016-0879": {"epss_score": 0.00776, "epss_percentile": 0.73103}, "CVE-2016-0881": {"epss_score": 0.00282, "epss_percentile": 0.51232}, "CVE-2016-0882": {"epss_score": 0.00483, "epss_percentile": 0.64568}, "CVE-2016-0883": {"epss_score": 0.00156, "epss_percentile": 0.36963}, "CVE-2016-0886": {"epss_score": 0.00202, "epss_percentile": 0.42438}, "CVE-2016-0887": {"epss_score": 0.00935, "epss_percentile": 0.75663}, "CVE-2016-0888": {"epss_score": 0.01391, "epss_percentile": 0.79952}, "CVE-2016-0889": {"epss_score": 0.01707, "epss_percentile": 0.81858}, "CVE-2016-0890": {"epss_score": 0.00422, "epss_percentile": 0.61569}, "CVE-2016-0891": {"epss_score": 0.03087, "epss_percentile": 0.86388}, "CVE-2016-0892": {"epss_score": 0.00254, "epss_percentile": 0.48572}, "CVE-2016-0893": {"epss_score": 0.00172, "epss_percentile": 0.39007}, "CVE-2016-0894": {"epss_score": 0.00212, "epss_percentile": 0.43731}, "CVE-2016-0895": {"epss_score": 0.00359, "epss_percentile": 0.57565}, "CVE-2016-0896": {"epss_score": 0.0014, "epss_percentile": 0.34779}, "CVE-2016-0897": {"epss_score": 0.00478, "epss_percentile": 0.64385}, "CVE-2016-0898": {"epss_score": 0.00294, "epss_percentile": 0.52395}, "CVE-2016-0899": {"epss_score": 0.00174, "epss_percentile": 0.39202}, "CVE-2016-0900": {"epss_score": 0.00342, "epss_percentile": 0.56394}, "CVE-2016-0901": {"epss_score": 0.00342, "epss_percentile": 0.56394}, "CVE-2016-0902": {"epss_score": 0.00702, "epss_percentile": 0.71521}, "CVE-2016-0903": {"epss_score": 0.01071, "epss_percentile": 0.77264}, "CVE-2016-0904": {"epss_score": 0.00183, "epss_percentile": 0.40283}, "CVE-2016-0905": {"epss_score": 0.00044, "epss_percentile": 0.13574}, "CVE-2016-0906": {"epss_score": 0.00406, "epss_percentile": 0.60516}, "CVE-2016-0907": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2016-0908": {"epss_score": 0.00121, "epss_percentile": 0.31992}, "CVE-2016-0909": {"epss_score": 0.00053, "epss_percentile": 0.16675}, "CVE-2016-0910": {"epss_score": 0.00129, "epss_percentile": 0.33144}, "CVE-2016-0911": {"epss_score": 0.0035, "epss_percentile": 0.56924}, "CVE-2016-0912": {"epss_score": 0.01115, "epss_percentile": 0.77709}, "CVE-2016-0913": {"epss_score": 0.00354, "epss_percentile": 0.57227}, "CVE-2016-0914": {"epss_score": 0.0016, "epss_percentile": 0.37503}, "CVE-2016-0915": {"epss_score": 0.00744, "epss_percentile": 0.7251}, "CVE-2016-0916": {"epss_score": 0.05325, "epss_percentile": 0.89734}, "CVE-2016-0917": {"epss_score": 0.04134, "epss_percentile": 0.88304}, "CVE-2016-0918": {"epss_score": 0.00171, "epss_percentile": 0.38837}, "CVE-2016-0919": {"epss_score": 0.00465, "epss_percentile": 0.63754}, "CVE-2016-0920": {"epss_score": 0.00065, "epss_percentile": 0.20544}, "CVE-2016-0921": {"epss_score": 0.00036, "epss_percentile": 0.10254}, "CVE-2016-0922": {"epss_score": 0.00533, "epss_percentile": 0.66761}, "CVE-2016-0923": {"epss_score": 0.00578, "epss_percentile": 0.68204}, "CVE-2016-0925": {"epss_score": 0.00168, "epss_percentile": 0.38442}, "CVE-2016-0926": {"epss_score": 0.00315, "epss_percentile": 0.54184}, "CVE-2016-0927": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-0928": {"epss_score": 0.00217, "epss_percentile": 0.44284}, "CVE-2016-0929": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2016-0930": {"epss_score": 0.00342, "epss_percentile": 0.56351}, "CVE-2016-0931": {"epss_score": 0.02918, "epss_percentile": 0.85988}, "CVE-2016-0932": {"epss_score": 0.0321, "epss_percentile": 0.86653}, "CVE-2016-0933": {"epss_score": 0.02969, "epss_percentile": 0.86091}, "CVE-2016-0934": {"epss_score": 0.0321, "epss_percentile": 0.86653}, "CVE-2016-0935": {"epss_score": 0.03754, "epss_percentile": 0.8768}, "CVE-2016-0936": {"epss_score": 0.02724, "epss_percentile": 0.85524}, "CVE-2016-0937": {"epss_score": 0.04926, "epss_percentile": 0.89294}, "CVE-2016-0938": {"epss_score": 0.02724, "epss_percentile": 0.85524}, "CVE-2016-0939": {"epss_score": 0.02918, "epss_percentile": 0.85988}, "CVE-2016-0940": {"epss_score": 0.03936, "epss_percentile": 0.87984}, "CVE-2016-0941": {"epss_score": 0.0321, "epss_percentile": 0.86653}, "CVE-2016-0942": {"epss_score": 0.03243, "epss_percentile": 0.86739}, "CVE-2016-0943": {"epss_score": 0.02142, "epss_percentile": 0.83754}, "CVE-2016-0944": {"epss_score": 0.03243, "epss_percentile": 0.86739}, "CVE-2016-0945": {"epss_score": 0.03243, "epss_percentile": 0.86739}, "CVE-2016-0946": {"epss_score": 0.03243, "epss_percentile": 0.86739}, "CVE-2016-0947": {"epss_score": 0.00481, "epss_percentile": 0.64507}, "CVE-2016-0948": {"epss_score": 0.00289, "epss_percentile": 0.5203}, "CVE-2016-0949": {"epss_score": 0.02398, "epss_percentile": 0.84623}, "CVE-2016-0950": {"epss_score": 0.0073, "epss_percentile": 0.72156}, "CVE-2016-0951": {"epss_score": 0.17548, "epss_percentile": 0.94865}, "CVE-2016-0952": {"epss_score": 0.17548, "epss_percentile": 0.94865}, "CVE-2016-0953": {"epss_score": 0.17548, "epss_percentile": 0.94865}, "CVE-2016-0954": {"epss_score": 0.3366, "epss_percentile": 0.96794}, "CVE-2016-0955": {"epss_score": 0.00334, "epss_percentile": 0.55731}, "CVE-2016-0956": {"epss_score": 0.13277, "epss_percentile": 0.9392}, "CVE-2016-0957": {"epss_score": 0.93186, "epss_percentile": 0.99781}, "CVE-2016-0958": {"epss_score": 0.00643, "epss_percentile": 0.70061}, "CVE-2016-0959": {"epss_score": 0.00978, "epss_percentile": 0.76251}, "CVE-2016-0960": {"epss_score": 0.0662, "epss_percentile": 0.90893}, "CVE-2016-0961": {"epss_score": 0.05721, "epss_percentile": 0.90152}, "CVE-2016-0962": {"epss_score": 0.05721, "epss_percentile": 0.90152}, "CVE-2016-0963": {"epss_score": 0.05955, "epss_percentile": 0.90362}, "CVE-2016-0964": {"epss_score": 0.43246, "epss_percentile": 0.97378}, "CVE-2016-0965": {"epss_score": 0.43246, "epss_percentile": 0.97378}, "CVE-2016-0966": {"epss_score": 0.0441, "epss_percentile": 0.88658}, "CVE-2016-0967": {"epss_score": 0.43246, "epss_percentile": 0.97378}, "CVE-2016-0968": {"epss_score": 0.0441, "epss_percentile": 0.88658}, "CVE-2016-0969": {"epss_score": 0.0441, "epss_percentile": 0.88658}, "CVE-2016-0970": {"epss_score": 0.0441, "epss_percentile": 0.88658}, "CVE-2016-0971": {"epss_score": 0.50058, "epss_percentile": 0.97716}, "CVE-2016-0972": {"epss_score": 0.0441, "epss_percentile": 0.88658}, "CVE-2016-0973": {"epss_score": 0.05735, "epss_percentile": 0.90164}, "CVE-2016-0974": {"epss_score": 0.7297, "epss_percentile": 0.98731}, "CVE-2016-0975": {"epss_score": 0.05735, "epss_percentile": 0.90164}, "CVE-2016-0976": {"epss_score": 0.0441, "epss_percentile": 0.88658}, "CVE-2016-0977": {"epss_score": 0.0441, "epss_percentile": 0.88658}, "CVE-2016-0978": {"epss_score": 0.0441, "epss_percentile": 0.88658}, "CVE-2016-0979": {"epss_score": 0.0441, "epss_percentile": 0.88658}, "CVE-2016-0980": {"epss_score": 0.0441, "epss_percentile": 0.88658}, "CVE-2016-0981": {"epss_score": 0.06543, "epss_percentile": 0.90836}, "CVE-2016-0982": {"epss_score": 0.27991, "epss_percentile": 0.96301}, "CVE-2016-0983": {"epss_score": 0.11656, "epss_percentile": 0.93435}, "CVE-2016-0984": {"epss_score": 0.73452, "epss_percentile": 0.98756}, "CVE-2016-0985": {"epss_score": 0.48412, "epss_percentile": 0.97636}, "CVE-2016-0986": {"epss_score": 0.05534, "epss_percentile": 0.89968}, "CVE-2016-0987": {"epss_score": 0.07318, "epss_percentile": 0.91405}, "CVE-2016-0988": {"epss_score": 0.09501, "epss_percentile": 0.92574}, "CVE-2016-0989": {"epss_score": 0.05721, "epss_percentile": 0.90152}, "CVE-2016-0990": {"epss_score": 0.04106, "epss_percentile": 0.88266}, "CVE-2016-0991": {"epss_score": 0.09501, "epss_percentile": 0.92574}, "CVE-2016-0992": {"epss_score": 0.08132, "epss_percentile": 0.91895}, "CVE-2016-0993": {"epss_score": 0.05955, "epss_percentile": 0.90362}, "CVE-2016-0994": {"epss_score": 0.08063, "epss_percentile": 0.91863}, "CVE-2016-0995": {"epss_score": 0.07318, "epss_percentile": 0.91405}, "CVE-2016-0996": {"epss_score": 0.10437, "epss_percentile": 0.92987}, "CVE-2016-0997": {"epss_score": 0.55107, "epss_percentile": 0.9796}, "CVE-2016-0998": {"epss_score": 0.65826, "epss_percentile": 0.9844}, "CVE-2016-0999": {"epss_score": 0.55107, "epss_percentile": 0.9796}, "CVE-2016-1000000": {"epss_score": 0.00105, "epss_percentile": 0.29303}, "CVE-2016-1000001": {"epss_score": 0.00175, "epss_percentile": 0.3935}, "CVE-2016-1000002": {"epss_score": 0.0016, "epss_percentile": 0.37466}, "CVE-2016-1000003": {"epss_score": 0.01696, "epss_percentile": 0.81815}, "CVE-2016-1000004": {"epss_score": 0.0019, "epss_percentile": 0.41056}, "CVE-2016-1000005": {"epss_score": 0.00533, "epss_percentile": 0.66771}, "CVE-2016-1000006": {"epss_score": 0.0044, "epss_percentile": 0.62614}, "CVE-2016-1000007": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2016-1000009": {"epss_score": 0.00272, "epss_percentile": 0.5039}, "CVE-2016-1000027": {"epss_score": 0.57054, "epss_percentile": 0.98046}, "CVE-2016-1000028": {"epss_score": 0.00311, "epss_percentile": 0.53926}, "CVE-2016-1000029": {"epss_score": 0.00353, "epss_percentile": 0.57158}, "CVE-2016-1000030": {"epss_score": 0.00778, "epss_percentile": 0.73125}, "CVE-2016-1000031": {"epss_score": 0.50086, "epss_percentile": 0.97719}, "CVE-2016-1000032": {"epss_score": 0.00333, "epss_percentile": 0.55638}, "CVE-2016-1000033": {"epss_score": 0.00315, "epss_percentile": 0.54189}, "CVE-2016-1000037": {"epss_score": 0.00494, "epss_percentile": 0.65081}, "CVE-2016-1000104": {"epss_score": 0.00407, "epss_percentile": 0.60617}, "CVE-2016-1000107": {"epss_score": 0.00531, "epss_percentile": 0.66665}, "CVE-2016-1000108": {"epss_score": 0.00953, "epss_percentile": 0.75891}, "CVE-2016-1000109": {"epss_score": 0.01586, "epss_percentile": 0.81177}, "CVE-2016-1000110": {"epss_score": 0.09899, "epss_percentile": 0.92763}, "CVE-2016-1000111": {"epss_score": 0.00694, "epss_percentile": 0.71341}, "CVE-2016-1000112": {"epss_score": 0.35658, "epss_percentile": 0.96925}, "CVE-2016-1000113": {"epss_score": 0.02773, "epss_percentile": 0.85629}, "CVE-2016-1000114": {"epss_score": 0.00231, "epss_percentile": 0.45776}, "CVE-2016-1000115": {"epss_score": 0.0079, "epss_percentile": 0.73377}, "CVE-2016-1000116": {"epss_score": 0.004, "epss_percentile": 0.60151}, "CVE-2016-1000117": {"epss_score": 0.02035, "epss_percentile": 0.8335}, "CVE-2016-1000118": {"epss_score": 0.02035, "epss_percentile": 0.8335}, "CVE-2016-1000119": {"epss_score": 0.02035, "epss_percentile": 0.8335}, "CVE-2016-1000120": {"epss_score": 0.00899, "epss_percentile": 0.75151}, "CVE-2016-1000121": {"epss_score": 0.00297, "epss_percentile": 0.5276}, "CVE-2016-1000122": {"epss_score": 0.00899, "epss_percentile": 0.75151}, "CVE-2016-1000123": {"epss_score": 0.06446, "epss_percentile": 0.90761}, "CVE-2016-1000124": {"epss_score": 0.0227, "epss_percentile": 0.84207}, "CVE-2016-1000125": {"epss_score": 0.02249, "epss_percentile": 0.8414}, "CVE-2016-1000126": {"epss_score": 0.02196, "epss_percentile": 0.83957}, "CVE-2016-1000127": {"epss_score": 0.02196, "epss_percentile": 0.83957}, "CVE-2016-1000128": {"epss_score": 0.02927, "epss_percentile": 0.86009}, "CVE-2016-1000129": {"epss_score": 0.02773, "epss_percentile": 0.85628}, "CVE-2016-1000130": {"epss_score": 0.01668, "epss_percentile": 0.81662}, "CVE-2016-1000131": {"epss_score": 0.02155, "epss_percentile": 0.83803}, "CVE-2016-1000132": {"epss_score": 0.02422, "epss_percentile": 0.84706}, "CVE-2016-1000133": {"epss_score": 0.02995, "epss_percentile": 0.86155}, "CVE-2016-1000134": {"epss_score": 0.02155, "epss_percentile": 0.83803}, "CVE-2016-1000135": {"epss_score": 0.02155, "epss_percentile": 0.83803}, "CVE-2016-1000136": {"epss_score": 0.06584, "epss_percentile": 0.90864}, "CVE-2016-1000137": {"epss_score": 0.07251, "epss_percentile": 0.91351}, "CVE-2016-1000138": {"epss_score": 0.06584, "epss_percentile": 0.90864}, "CVE-2016-1000139": {"epss_score": 0.02927, "epss_percentile": 0.86009}, "CVE-2016-1000140": {"epss_score": 0.06584, "epss_percentile": 0.90864}, "CVE-2016-1000141": {"epss_score": 0.06584, "epss_percentile": 0.90864}, "CVE-2016-1000142": {"epss_score": 0.07251, "epss_percentile": 0.91351}, "CVE-2016-1000143": {"epss_score": 0.06584, "epss_percentile": 0.90864}, "CVE-2016-1000144": {"epss_score": 0.00992, "epss_percentile": 0.7639}, "CVE-2016-1000145": {"epss_score": 0.01342, "epss_percentile": 0.79594}, "CVE-2016-1000146": {"epss_score": 0.0204, "epss_percentile": 0.83365}, "CVE-2016-1000147": {"epss_score": 0.01342, "epss_percentile": 0.79594}, "CVE-2016-1000148": {"epss_score": 0.09352, "epss_percentile": 0.92512}, "CVE-2016-1000149": {"epss_score": 0.07335, "epss_percentile": 0.91417}, "CVE-2016-1000150": {"epss_score": 0.00992, "epss_percentile": 0.7639}, "CVE-2016-1000151": {"epss_score": 0.01342, "epss_percentile": 0.79594}, "CVE-2016-1000152": {"epss_score": 0.06492, "epss_percentile": 0.90797}, "CVE-2016-1000153": {"epss_score": 0.01868, "epss_percentile": 0.82621}, "CVE-2016-1000154": {"epss_score": 0.05754, "epss_percentile": 0.90179}, "CVE-2016-1000155": {"epss_score": 0.02155, "epss_percentile": 0.83803}, "CVE-2016-1000156": {"epss_score": 0.16392, "epss_percentile": 0.94644}, "CVE-2016-1000213": {"epss_score": 0.00166, "epss_percentile": 0.3823}, "CVE-2016-1000214": {"epss_score": 0.00331, "epss_percentile": 0.55501}, "CVE-2016-1000215": {"epss_score": 0.00415, "epss_percentile": 0.61145}, "CVE-2016-1000216": {"epss_score": 0.20214, "epss_percentile": 0.95304}, "CVE-2016-1000217": {"epss_score": 0.11397, "epss_percentile": 0.93334}, "CVE-2016-1000218": {"epss_score": 0.0013, "epss_percentile": 0.33255}, "CVE-2016-1000219": {"epss_score": 0.00678, "epss_percentile": 0.70987}, "CVE-2016-1000220": {"epss_score": 0.003, "epss_percentile": 0.52965}, "CVE-2016-1000221": {"epss_score": 0.00749, "epss_percentile": 0.72598}, "CVE-2016-1000222": {"epss_score": 0.0035, "epss_percentile": 0.56923}, "CVE-2016-1000229": {"epss_score": 0.0485, "epss_percentile": 0.89214}, "CVE-2016-1000232": {"epss_score": 0.00921, "epss_percentile": 0.75477}, "CVE-2016-1000236": {"epss_score": 0.00539, "epss_percentile": 0.66987}, "CVE-2016-1000237": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2016-1000271": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2016-1000282": {"epss_score": 0.74231, "epss_percentile": 0.98792}, "CVE-2016-1000307": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2016-1000338": {"epss_score": 0.00485, "epss_percentile": 0.64708}, "CVE-2016-1000339": {"epss_score": 0.01113, "epss_percentile": 0.77687}, "CVE-2016-1000340": {"epss_score": 0.00395, "epss_percentile": 0.59834}, "CVE-2016-1000341": {"epss_score": 0.00797, "epss_percentile": 0.73501}, "CVE-2016-1000342": {"epss_score": 0.00468, "epss_percentile": 0.63879}, "CVE-2016-1000343": {"epss_score": 0.01074, "epss_percentile": 0.77301}, "CVE-2016-1000344": {"epss_score": 0.00386, "epss_percentile": 0.59259}, "CVE-2016-1000345": {"epss_score": 0.00797, "epss_percentile": 0.73501}, "CVE-2016-1000346": {"epss_score": 0.0082, "epss_percentile": 0.7389}, "CVE-2016-1000352": {"epss_score": 0.00386, "epss_percentile": 0.59259}, "CVE-2016-10002": {"epss_score": 0.30071, "epss_percentile": 0.96503}, "CVE-2016-10003": {"epss_score": 0.00976, "epss_percentile": 0.76208}, "CVE-2016-10005": {"epss_score": 0.00993, "epss_percentile": 0.76401}, "CVE-2016-10006": {"epss_score": 0.00992, "epss_percentile": 0.764}, "CVE-2016-10007": {"epss_score": 0.00456, "epss_percentile": 0.63318}, "CVE-2016-10008": {"epss_score": 0.00456, "epss_percentile": 0.63318}, "CVE-2016-10009": {"epss_score": 0.01579, "epss_percentile": 0.81127}, "CVE-2016-10010": {"epss_score": 0.00093, "epss_percentile": 0.26652}, "CVE-2016-10011": {"epss_score": 0.00017, "epss_percentile": 0.03131}, "CVE-2016-10012": {"epss_score": 0.00016, "epss_percentile": 0.02731}, "CVE-2016-10013": {"epss_score": 0.00099, "epss_percentile": 0.27867}, "CVE-2016-10024": {"epss_score": 0.00143, "epss_percentile": 0.35106}, "CVE-2016-10025": {"epss_score": 0.00121, "epss_percentile": 0.3182}, "CVE-2016-10026": {"epss_score": 0.00377, "epss_percentile": 0.58698}, "CVE-2016-10027": {"epss_score": 0.00388, "epss_percentile": 0.59366}, "CVE-2016-10028": {"epss_score": 0.00087, "epss_percentile": 0.25488}, "CVE-2016-10029": {"epss_score": 0.0007, "epss_percentile": 0.21805}, "CVE-2016-10030": {"epss_score": 0.00654, "epss_percentile": 0.70345}, "CVE-2016-10031": {"epss_score": 0.00294, "epss_percentile": 0.52357}, "CVE-2016-10033": {"epss_score": 0.94457, "epss_percentile": 0.99993}, "CVE-2016-10034": {"epss_score": 0.82322, "epss_percentile": 0.99187}, "CVE-2016-10036": {"epss_score": 0.135, "epss_percentile": 0.93981}, "CVE-2016-10037": {"epss_score": 0.00792, "epss_percentile": 0.73408}, "CVE-2016-10038": {"epss_score": 0.00792, "epss_percentile": 0.73408}, "CVE-2016-10039": {"epss_score": 0.00792, "epss_percentile": 0.73408}, "CVE-2016-10040": {"epss_score": 0.00819, "epss_percentile": 0.73874}, "CVE-2016-10041": {"epss_score": 0.00474, "epss_percentile": 0.64152}, "CVE-2016-10042": {"epss_score": 0.00196, "epss_percentile": 0.41756}, "CVE-2016-10043": {"epss_score": 0.37587, "epss_percentile": 0.97059}, "CVE-2016-10044": {"epss_score": 4e-05, "epss_percentile": 0.00172}, "CVE-2016-10045": {"epss_score": 0.93535, "epss_percentile": 0.99816}, "CVE-2016-10046": {"epss_score": 0.00398, "epss_percentile": 0.60091}, "CVE-2016-10047": {"epss_score": 0.00823, "epss_percentile": 0.73928}, "CVE-2016-10048": {"epss_score": 0.04943, "epss_percentile": 0.89311}, "CVE-2016-10049": {"epss_score": 0.00362, "epss_percentile": 0.5777}, "CVE-2016-10050": {"epss_score": 0.00267, "epss_percentile": 0.50016}, "CVE-2016-10051": {"epss_score": 0.0034, "epss_percentile": 0.56216}, "CVE-2016-10052": {"epss_score": 0.00267, "epss_percentile": 0.50016}, "CVE-2016-10053": {"epss_score": 0.00407, "epss_percentile": 0.60607}, "CVE-2016-10054": {"epss_score": 0.00343, "epss_percentile": 0.56427}, "CVE-2016-10055": {"epss_score": 0.00343, "epss_percentile": 0.56427}, "CVE-2016-10056": {"epss_score": 0.00242, "epss_percentile": 0.4734}, "CVE-2016-10057": {"epss_score": 0.00343, "epss_percentile": 0.56427}, "CVE-2016-10058": {"epss_score": 0.00634, "epss_percentile": 0.69802}, "CVE-2016-10059": {"epss_score": 0.00387, "epss_percentile": 0.59292}, "CVE-2016-10060": {"epss_score": 0.00665, "epss_percentile": 0.70658}, "CVE-2016-10061": {"epss_score": 0.00616, "epss_percentile": 0.69335}, "CVE-2016-10062": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2016-10063": {"epss_score": 0.00879, "epss_percentile": 0.74841}, "CVE-2016-10064": {"epss_score": 0.00267, "epss_percentile": 0.50016}, "CVE-2016-10065": {"epss_score": 0.00261, "epss_percentile": 0.49281}, "CVE-2016-10066": {"epss_score": 0.0048, "epss_percentile": 0.64479}, "CVE-2016-10067": {"epss_score": 0.01096, "epss_percentile": 0.77521}, "CVE-2016-10068": {"epss_score": 0.00811, "epss_percentile": 0.73727}, "CVE-2016-10069": {"epss_score": 0.00571, "epss_percentile": 0.67982}, "CVE-2016-10070": {"epss_score": 0.00619, "epss_percentile": 0.6939}, "CVE-2016-10071": {"epss_score": 0.005, "epss_percentile": 0.65314}, "CVE-2016-10072": {"epss_score": 0.00185, "epss_percentile": 0.40568}, "CVE-2016-10073": {"epss_score": 0.53554, "epss_percentile": 0.97881}, "CVE-2016-10074": {"epss_score": 0.75512, "epss_percentile": 0.9885}, "CVE-2016-10075": {"epss_score": 0.00088, "epss_percentile": 0.25761}, "CVE-2016-10079": {"epss_score": 0.13933, "epss_percentile": 0.94096}, "CVE-2016-10081": {"epss_score": 0.0286, "epss_percentile": 0.85849}, "CVE-2016-10082": {"epss_score": 0.01533, "epss_percentile": 0.80898}, "CVE-2016-10083": {"epss_score": 0.00343, "epss_percentile": 0.56471}, "CVE-2016-10084": {"epss_score": 0.02052, "epss_percentile": 0.8341}, "CVE-2016-10085": {"epss_score": 0.02052, "epss_percentile": 0.8341}, "CVE-2016-10086": {"epss_score": 0.00715, "epss_percentile": 0.71842}, "CVE-2016-10087": {"epss_score": 0.00949, "epss_percentile": 0.75847}, "CVE-2016-10088": {"epss_score": 0.00075, "epss_percentile": 0.23038}, "CVE-2016-10089": {"epss_score": 0.00099, "epss_percentile": 0.28308}, "CVE-2016-10091": {"epss_score": 0.02609, "epss_percentile": 0.85233}, "CVE-2016-10092": {"epss_score": 0.02274, "epss_percentile": 0.84223}, "CVE-2016-10093": {"epss_score": 0.0137, "epss_percentile": 0.79799}, "CVE-2016-10094": {"epss_score": 0.0049, "epss_percentile": 0.64937}, "CVE-2016-10095": {"epss_score": 0.01011, "epss_percentile": 0.76608}, "CVE-2016-10096": {"epss_score": 0.00496, "epss_percentile": 0.65148}, "CVE-2016-10097": {"epss_score": 0.00781, "epss_percentile": 0.73192}, "CVE-2016-10098": {"epss_score": 0.03271, "epss_percentile": 0.86792}, "CVE-2016-10099": {"epss_score": 0.0054, "epss_percentile": 0.67016}, "CVE-2016-10100": {"epss_score": 0.00291, "epss_percentile": 0.52208}, "CVE-2016-10101": {"epss_score": 0.00295, "epss_percentile": 0.52485}, "CVE-2016-10102": {"epss_score": 0.00082, "epss_percentile": 0.2451}, "CVE-2016-10103": {"epss_score": 0.00159, "epss_percentile": 0.37323}, "CVE-2016-10104": {"epss_score": 0.0027, "epss_percentile": 0.50272}, "CVE-2016-10105": {"epss_score": 0.00806, "epss_percentile": 0.73647}, "CVE-2016-10106": {"epss_score": 0.0081, "epss_percentile": 0.73723}, "CVE-2016-10107": {"epss_score": 0.04341, "epss_percentile": 0.8857}, "CVE-2016-10108": {"epss_score": 0.91759, "epss_percentile": 0.99666}, "CVE-2016-10109": {"epss_score": 0.04872, "epss_percentile": 0.89232}, "CVE-2016-10112": {"epss_score": 0.00121, "epss_percentile": 0.31948}, "CVE-2016-10114": {"epss_score": 0.00548, "epss_percentile": 0.67269}, "CVE-2016-10115": {"epss_score": 0.0624, "epss_percentile": 0.90592}, "CVE-2016-10116": {"epss_score": 0.0709, "epss_percentile": 0.91243}, "CVE-2016-10117": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2016-10118": {"epss_score": 0.00045, "epss_percentile": 0.13917}, "CVE-2016-10119": {"epss_score": 0.00032, "epss_percentile": 0.08828}, "CVE-2016-10120": {"epss_score": 0.00032, "epss_percentile": 0.08828}, "CVE-2016-10121": {"epss_score": 0.00032, "epss_percentile": 0.08828}, "CVE-2016-10122": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2016-10123": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2016-10124": {"epss_score": 0.00277, "epss_percentile": 0.50838}, "CVE-2016-10125": {"epss_score": 0.00767, "epss_percentile": 0.72947}, "CVE-2016-10126": {"epss_score": 0.01373, "epss_percentile": 0.79817}, "CVE-2016-10127": {"epss_score": 0.00778, "epss_percentile": 0.7313}, "CVE-2016-10128": {"epss_score": 0.02867, "epss_percentile": 0.85864}, "CVE-2016-10129": {"epss_score": 0.04757, "epss_percentile": 0.89115}, "CVE-2016-10130": {"epss_score": 0.01054, "epss_percentile": 0.77107}, "CVE-2016-10131": {"epss_score": 0.03122, "epss_percentile": 0.86451}, "CVE-2016-10132": {"epss_score": 0.00496, "epss_percentile": 0.65163}, "CVE-2016-10133": {"epss_score": 0.00602, "epss_percentile": 0.68892}, "CVE-2016-10134": {"epss_score": 0.88001, "epss_percentile": 0.99454}, "CVE-2016-10135": {"epss_score": 0.003, "epss_percentile": 0.52951}, "CVE-2016-10136": {"epss_score": 0.00066, "epss_percentile": 0.20886}, "CVE-2016-10137": {"epss_score": 0.00052, "epss_percentile": 0.16621}, "CVE-2016-10138": {"epss_score": 0.00054, "epss_percentile": 0.17193}, "CVE-2016-10139": {"epss_score": 0.00048, "epss_percentile": 0.15077}, "CVE-2016-10140": {"epss_score": 0.34266, "epss_percentile": 0.96837}, "CVE-2016-10141": {"epss_score": 0.00609, "epss_percentile": 0.69096}, "CVE-2016-10142": {"epss_score": 0.00657, "epss_percentile": 0.7047}, "CVE-2016-10143": {"epss_score": 0.00414, "epss_percentile": 0.61094}, "CVE-2016-10144": {"epss_score": 0.00785, "epss_percentile": 0.73258}, "CVE-2016-10145": {"epss_score": 0.00662, "epss_percentile": 0.706}, "CVE-2016-10146": {"epss_score": 0.01541, "epss_percentile": 0.80946}, "CVE-2016-10147": {"epss_score": 0.00071, "epss_percentile": 0.22028}, "CVE-2016-10148": {"epss_score": 0.0045, "epss_percentile": 0.63067}, "CVE-2016-10149": {"epss_score": 0.0131, "epss_percentile": 0.79361}, "CVE-2016-10150": {"epss_score": 0.00792, "epss_percentile": 0.73397}, "CVE-2016-10151": {"epss_score": 0.00085, "epss_percentile": 0.25179}, "CVE-2016-10152": {"epss_score": 0.01873, "epss_percentile": 0.82644}, "CVE-2016-10153": {"epss_score": 0.00086, "epss_percentile": 0.25357}, "CVE-2016-10154": {"epss_score": 0.00091, "epss_percentile": 0.26287}, "CVE-2016-10155": {"epss_score": 0.00091, "epss_percentile": 0.26286}, "CVE-2016-10156": {"epss_score": 0.00712, "epss_percentile": 0.71753}, "CVE-2016-10157": {"epss_score": 0.00397, "epss_percentile": 0.59986}, "CVE-2016-10158": {"epss_score": 0.04988, "epss_percentile": 0.89365}, "CVE-2016-10159": {"epss_score": 0.08966, "epss_percentile": 0.92341}, "CVE-2016-10160": {"epss_score": 0.03771, "epss_percentile": 0.87703}, "CVE-2016-10161": {"epss_score": 0.14631, "epss_percentile": 0.94255}, "CVE-2016-10162": {"epss_score": 0.04004, "epss_percentile": 0.88097}, "CVE-2016-10163": {"epss_score": 0.00058, "epss_percentile": 0.18522}, "CVE-2016-10164": {"epss_score": 0.03739, "epss_percentile": 0.87653}, "CVE-2016-10165": {"epss_score": 0.00513, "epss_percentile": 0.65898}, "CVE-2016-10166": {"epss_score": 0.08333, "epss_percentile": 0.91995}, "CVE-2016-10167": {"epss_score": 0.00975, "epss_percentile": 0.76202}, "CVE-2016-10168": {"epss_score": 0.00655, "epss_percentile": 0.70368}, "CVE-2016-10169": {"epss_score": 0.00454, "epss_percentile": 0.63261}, "CVE-2016-10170": {"epss_score": 0.00427, "epss_percentile": 0.61887}, "CVE-2016-10171": {"epss_score": 0.00427, "epss_percentile": 0.61887}, "CVE-2016-10172": {"epss_score": 0.00427, "epss_percentile": 0.61887}, "CVE-2016-10173": {"epss_score": 0.02922, "epss_percentile": 0.85994}, "CVE-2016-10174": {"epss_score": 0.89771, "epss_percentile": 0.99541}, "CVE-2016-10175": {"epss_score": 0.81606, "epss_percentile": 0.99147}, "CVE-2016-10176": {"epss_score": 0.86619, "epss_percentile": 0.9939}, "CVE-2016-10177": {"epss_score": 0.20059, "epss_percentile": 0.95282}, "CVE-2016-10178": {"epss_score": 0.22246, "epss_percentile": 0.95614}, "CVE-2016-10179": {"epss_score": 0.12, "epss_percentile": 0.93542}, "CVE-2016-10180": {"epss_score": 0.03498, "epss_percentile": 0.87241}, "CVE-2016-10181": {"epss_score": 0.12067, "epss_percentile": 0.93558}, "CVE-2016-10182": {"epss_score": 0.49255, "epss_percentile": 0.97675}, "CVE-2016-10183": {"epss_score": 0.0555, "epss_percentile": 0.89985}, "CVE-2016-10184": {"epss_score": 0.0555, "epss_percentile": 0.89985}, "CVE-2016-10185": {"epss_score": 0.03032, "epss_percentile": 0.8625}, "CVE-2016-10186": {"epss_score": 0.03032, "epss_percentile": 0.8625}, "CVE-2016-10187": {"epss_score": 0.00338, "epss_percentile": 0.56152}, "CVE-2016-10188": {"epss_score": 0.01199, "epss_percentile": 0.78463}, "CVE-2016-10189": {"epss_score": 0.03183, "epss_percentile": 0.86586}, "CVE-2016-10190": {"epss_score": 0.33339, "epss_percentile": 0.96764}, "CVE-2016-10191": {"epss_score": 0.16183, "epss_percentile": 0.9459}, "CVE-2016-10192": {"epss_score": 0.12513, "epss_percentile": 0.93702}, "CVE-2016-10193": {"epss_score": 0.0122, "epss_percentile": 0.78624}, "CVE-2016-10194": {"epss_score": 0.01006, "epss_percentile": 0.76555}, "CVE-2016-10195": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2016-10196": {"epss_score": 0.00814, "epss_percentile": 0.73768}, "CVE-2016-10197": {"epss_score": 0.01864, "epss_percentile": 0.826}, "CVE-2016-10198": {"epss_score": 0.02174, "epss_percentile": 0.83877}, "CVE-2016-10199": {"epss_score": 0.05176, "epss_percentile": 0.89573}, "CVE-2016-10200": {"epss_score": 0.00029, "epss_percentile": 0.07669}, "CVE-2016-10201": {"epss_score": 0.00275, "epss_percentile": 0.50689}, "CVE-2016-10202": {"epss_score": 0.00275, "epss_percentile": 0.50689}, "CVE-2016-10203": {"epss_score": 0.00326, "epss_percentile": 0.55069}, "CVE-2016-10204": {"epss_score": 0.00518, "epss_percentile": 0.66117}, "CVE-2016-10205": {"epss_score": 0.00743, "epss_percentile": 0.72498}, "CVE-2016-10206": {"epss_score": 0.00131, "epss_percentile": 0.33363}, "CVE-2016-10207": {"epss_score": 0.01689, "epss_percentile": 0.81771}, "CVE-2016-10208": {"epss_score": 0.00085, "epss_percentile": 0.25177}, "CVE-2016-10209": {"epss_score": 0.00916, "epss_percentile": 0.75421}, "CVE-2016-10210": {"epss_score": 0.00641, "epss_percentile": 0.69993}, "CVE-2016-10211": {"epss_score": 0.00787, "epss_percentile": 0.73313}, "CVE-2016-10212": {"epss_score": 0.00476, "epss_percentile": 0.64273}, "CVE-2016-10213": {"epss_score": 0.00536, "epss_percentile": 0.66862}, "CVE-2016-10214": {"epss_score": 0.00068, "epss_percentile": 0.21231}, "CVE-2016-10215": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2016-10216": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2016-10217": {"epss_score": 0.00762, "epss_percentile": 0.72844}, "CVE-2016-10218": {"epss_score": 0.00391, "epss_percentile": 0.59619}, "CVE-2016-10219": {"epss_score": 0.00977, "epss_percentile": 0.76221}, "CVE-2016-10220": {"epss_score": 0.00977, "epss_percentile": 0.76221}, "CVE-2016-10221": {"epss_score": 0.00198, "epss_percentile": 0.41986}, "CVE-2016-10222": {"epss_score": 0.00464, "epss_percentile": 0.63702}, "CVE-2016-10223": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2016-10224": {"epss_score": 0.00481, "epss_percentile": 0.64506}, "CVE-2016-10225": {"epss_score": 0.06061, "epss_percentile": 0.90443}, "CVE-2016-10226": {"epss_score": 0.00464, "epss_percentile": 0.63702}, "CVE-2016-10227": {"epss_score": 0.00987, "epss_percentile": 0.76341}, "CVE-2016-10228": {"epss_score": 0.00441, "epss_percentile": 0.62659}, "CVE-2016-10229": {"epss_score": 0.01242, "epss_percentile": 0.78821}, "CVE-2016-10230": {"epss_score": 0.0714, "epss_percentile": 0.91278}, "CVE-2016-10231": {"epss_score": 0.00065, "epss_percentile": 0.20525}, "CVE-2016-10232": {"epss_score": 0.00065, "epss_percentile": 0.20525}, "CVE-2016-10233": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2016-10234": {"epss_score": 0.00122, "epss_percentile": 0.3206}, "CVE-2016-10235": {"epss_score": 0.00398, "epss_percentile": 0.60062}, "CVE-2016-10236": {"epss_score": 0.00107, "epss_percentile": 0.29581}, "CVE-2016-10237": {"epss_score": 0.00051, "epss_percentile": 0.16244}, "CVE-2016-10238": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2016-10239": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2016-10242": {"epss_score": 0.00057, "epss_percentile": 0.18047}, "CVE-2016-10243": {"epss_score": 0.05394, "epss_percentile": 0.89826}, "CVE-2016-10244": {"epss_score": 0.00395, "epss_percentile": 0.59843}, "CVE-2016-10245": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2016-10246": {"epss_score": 0.00285, "epss_percentile": 0.51525}, "CVE-2016-10247": {"epss_score": 0.0031, "epss_percentile": 0.53775}, "CVE-2016-10248": {"epss_score": 0.0066, "epss_percentile": 0.70525}, "CVE-2016-10249": {"epss_score": 0.00539, "epss_percentile": 0.66988}, "CVE-2016-10250": {"epss_score": 0.0067, "epss_percentile": 0.70769}, "CVE-2016-10251": {"epss_score": 0.00815, "epss_percentile": 0.73784}, "CVE-2016-10252": {"epss_score": 0.00838, "epss_percentile": 0.74171}, "CVE-2016-10253": {"epss_score": 0.00513, "epss_percentile": 0.65902}, "CVE-2016-10254": {"epss_score": 0.00631, "epss_percentile": 0.69711}, "CVE-2016-10255": {"epss_score": 0.00537, "epss_percentile": 0.66912}, "CVE-2016-10256": {"epss_score": 0.00378, "epss_percentile": 0.58788}, "CVE-2016-10257": {"epss_score": 0.00378, "epss_percentile": 0.58788}, "CVE-2016-10258": {"epss_score": 0.10463, "epss_percentile": 0.92994}, "CVE-2016-10259": {"epss_score": 0.0046, "epss_percentile": 0.6352}, "CVE-2016-10266": {"epss_score": 0.00551, "epss_percentile": 0.67358}, "CVE-2016-10267": {"epss_score": 0.00413, "epss_percentile": 0.61008}, "CVE-2016-10268": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2016-10269": {"epss_score": 0.00347, "epss_percentile": 0.56748}, "CVE-2016-10270": {"epss_score": 0.00342, "epss_percentile": 0.56349}, "CVE-2016-10271": {"epss_score": 0.00419, "epss_percentile": 0.61382}, "CVE-2016-10272": {"epss_score": 0.00486, "epss_percentile": 0.64767}, "CVE-2016-10273": {"epss_score": 0.02895, "epss_percentile": 0.85924}, "CVE-2016-10274": {"epss_score": 0.00043, "epss_percentile": 0.13221}, "CVE-2016-10275": {"epss_score": 0.00052, "epss_percentile": 0.16644}, "CVE-2016-10276": {"epss_score": 0.00043, "epss_percentile": 0.13221}, "CVE-2016-10277": {"epss_score": 0.44367, "epss_percentile": 0.97432}, "CVE-2016-10280": {"epss_score": 0.00043, "epss_percentile": 0.13221}, "CVE-2016-10281": {"epss_score": 0.00043, "epss_percentile": 0.13221}, "CVE-2016-10282": {"epss_score": 0.00043, "epss_percentile": 0.13221}, "CVE-2016-10283": {"epss_score": 0.00195, "epss_percentile": 0.41658}, "CVE-2016-10284": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2016-10285": {"epss_score": 0.0017, "epss_percentile": 0.3872}, "CVE-2016-10286": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2016-10287": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2016-10288": {"epss_score": 0.00263, "epss_percentile": 0.49524}, "CVE-2016-10289": {"epss_score": 0.00245, "epss_percentile": 0.47647}, "CVE-2016-10290": {"epss_score": 0.0017, "epss_percentile": 0.3872}, "CVE-2016-10291": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2016-10292": {"epss_score": 0.00213, "epss_percentile": 0.43897}, "CVE-2016-10293": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2016-10294": {"epss_score": 0.0025, "epss_percentile": 0.48255}, "CVE-2016-10295": {"epss_score": 0.00176, "epss_percentile": 0.39379}, "CVE-2016-10296": {"epss_score": 0.00176, "epss_percentile": 0.39379}, "CVE-2016-10297": {"epss_score": 0.00027, "epss_percentile": 0.0712}, "CVE-2016-10298": {"epss_score": 0.00296, "epss_percentile": 0.52565}, "CVE-2016-10299": {"epss_score": 0.00296, "epss_percentile": 0.52565}, "CVE-2016-10304": {"epss_score": 0.01075, "epss_percentile": 0.77314}, "CVE-2016-10305": {"epss_score": 0.00369, "epss_percentile": 0.58245}, "CVE-2016-10306": {"epss_score": 0.01371, "epss_percentile": 0.79807}, "CVE-2016-10307": {"epss_score": 0.01123, "epss_percentile": 0.77788}, "CVE-2016-10308": {"epss_score": 0.02104, "epss_percentile": 0.83616}, "CVE-2016-10309": {"epss_score": 0.00789, "epss_percentile": 0.73357}, "CVE-2016-10310": {"epss_score": 0.03475, "epss_percentile": 0.87207}, "CVE-2016-10311": {"epss_score": 0.06792, "epss_percentile": 0.9103}, "CVE-2016-10312": {"epss_score": 0.05585, "epss_percentile": 0.90023}, "CVE-2016-10313": {"epss_score": 0.00204, "epss_percentile": 0.42623}, "CVE-2016-10314": {"epss_score": 0.00298, "epss_percentile": 0.52799}, "CVE-2016-10315": {"epss_score": 0.00225, "epss_percentile": 0.45081}, "CVE-2016-10316": {"epss_score": 0.00225, "epss_percentile": 0.45081}, "CVE-2016-10317": {"epss_score": 0.00621, "epss_percentile": 0.69477}, "CVE-2016-10318": {"epss_score": 0.00565, "epss_percentile": 0.67803}, "CVE-2016-10319": {"epss_score": 0.00439, "epss_percentile": 0.62609}, "CVE-2016-10320": {"epss_score": 0.00838, "epss_percentile": 0.74174}, "CVE-2016-10321": {"epss_score": 0.00468, "epss_percentile": 0.63892}, "CVE-2016-10322": {"epss_score": 0.02815, "epss_percentile": 0.8573}, "CVE-2016-10323": {"epss_score": 0.0004, "epss_percentile": 0.12018}, "CVE-2016-10324": {"epss_score": 0.0056, "epss_percentile": 0.67637}, "CVE-2016-10325": {"epss_score": 0.00478, "epss_percentile": 0.64375}, "CVE-2016-10326": {"epss_score": 0.00478, "epss_percentile": 0.64375}, "CVE-2016-10327": {"epss_score": 0.00606, "epss_percentile": 0.69007}, "CVE-2016-10328": {"epss_score": 0.01044, "epss_percentile": 0.76998}, "CVE-2016-10329": {"epss_score": 0.15108, "epss_percentile": 0.94364}, "CVE-2016-10330": {"epss_score": 0.00054, "epss_percentile": 0.17195}, "CVE-2016-10331": {"epss_score": 0.00391, "epss_percentile": 0.59567}, "CVE-2016-10332": {"epss_score": 0.00133, "epss_percentile": 0.33673}, "CVE-2016-10333": {"epss_score": 0.00075, "epss_percentile": 0.2298}, "CVE-2016-10334": {"epss_score": 0.00075, "epss_percentile": 0.2298}, "CVE-2016-10335": {"epss_score": 0.00075, "epss_percentile": 0.2298}, "CVE-2016-10336": {"epss_score": 0.00085, "epss_percentile": 0.25167}, "CVE-2016-10337": {"epss_score": 0.00085, "epss_percentile": 0.25167}, "CVE-2016-10338": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2016-10339": {"epss_score": 0.00095, "epss_percentile": 0.27228}, "CVE-2016-10340": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2016-10341": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2016-10342": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2016-10343": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2016-10344": {"epss_score": 0.00131, "epss_percentile": 0.33355}, "CVE-2016-10345": {"epss_score": 0.00064, "epss_percentile": 0.20326}, "CVE-2016-10346": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2016-10347": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2016-10349": {"epss_score": 0.01567, "epss_percentile": 0.81072}, "CVE-2016-10350": {"epss_score": 0.01575, "epss_percentile": 0.81106}, "CVE-2016-10351": {"epss_score": 0.00047, "epss_percentile": 0.14688}, "CVE-2016-10362": {"epss_score": 0.0028, "epss_percentile": 0.51008}, "CVE-2016-10363": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2016-10364": {"epss_score": 0.00168, "epss_percentile": 0.38426}, "CVE-2016-10365": {"epss_score": 0.00197, "epss_percentile": 0.41832}, "CVE-2016-10366": {"epss_score": 0.00265, "epss_percentile": 0.49822}, "CVE-2016-10367": {"epss_score": 0.52468, "epss_percentile": 0.97827}, "CVE-2016-10368": {"epss_score": 0.01027, "epss_percentile": 0.76805}, "CVE-2016-10369": {"epss_score": 0.00038, "epss_percentile": 0.11103}, "CVE-2016-10370": {"epss_score": 0.0022, "epss_percentile": 0.44602}, "CVE-2016-10371": {"epss_score": 0.00482, "epss_percentile": 0.64556}, "CVE-2016-10372": {"epss_score": 0.92979, "epss_percentile": 0.99765}, "CVE-2016-10374": {"epss_score": 0.00048, "epss_percentile": 0.15056}, "CVE-2016-10375": {"epss_score": 0.00507, "epss_percentile": 0.65675}, "CVE-2016-10376": {"epss_score": 0.00523, "epss_percentile": 0.66287}, "CVE-2016-10377": {"epss_score": 0.00242, "epss_percentile": 0.47362}, "CVE-2016-10378": {"epss_score": 0.00456, "epss_percentile": 0.63318}, "CVE-2016-10379": {"epss_score": 0.00641, "epss_percentile": 0.69989}, "CVE-2016-10380": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2016-10381": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2016-10382": {"epss_score": 0.00134, "epss_percentile": 0.3383}, "CVE-2016-10383": {"epss_score": 0.00118, "epss_percentile": 0.31433}, "CVE-2016-10384": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2016-10385": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2016-10386": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2016-10387": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2016-10388": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2016-10389": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2016-10390": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2016-10391": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2016-10392": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2016-10393": {"epss_score": 0.00106, "epss_percentile": 0.2946}, "CVE-2016-10394": {"epss_score": 0.00046, "epss_percentile": 0.14266}, "CVE-2016-10395": {"epss_score": 0.00069, "epss_percentile": 0.21487}, "CVE-2016-10396": {"epss_score": 0.02076, "epss_percentile": 0.83513}, "CVE-2016-10397": {"epss_score": 0.00402, "epss_percentile": 0.60268}, "CVE-2016-10398": {"epss_score": 0.00014, "epss_percentile": 0.0204}, "CVE-2016-10399": {"epss_score": 0.00281, "epss_percentile": 0.51195}, "CVE-2016-10400": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2016-10401": {"epss_score": 0.3596, "epss_percentile": 0.96943}, "CVE-2016-10402": {"epss_score": 0.0161, "epss_percentile": 0.81322}, "CVE-2016-10403": {"epss_score": 0.00377, "epss_percentile": 0.58755}, "CVE-2016-10404": {"epss_score": 0.00247, "epss_percentile": 0.47854}, "CVE-2016-10405": {"epss_score": 0.00565, "epss_percentile": 0.67804}, "CVE-2016-10406": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2016-10407": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2016-10408": {"epss_score": 0.00036, "epss_percentile": 0.10344}, "CVE-2016-10409": {"epss_score": 0.0016, "epss_percentile": 0.37424}, "CVE-2016-10410": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2016-10411": {"epss_score": 0.00236, "epss_percentile": 0.46417}, "CVE-2016-10412": {"epss_score": 0.00336, "epss_percentile": 0.55915}, "CVE-2016-10414": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10415": {"epss_score": 0.00351, "epss_percentile": 0.57018}, "CVE-2016-10416": {"epss_score": 0.00236, "epss_percentile": 0.46417}, "CVE-2016-10417": {"epss_score": 0.00141, "epss_percentile": 0.34839}, "CVE-2016-10418": {"epss_score": 0.00164, "epss_percentile": 0.37981}, "CVE-2016-10419": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10420": {"epss_score": 0.00114, "epss_percentile": 0.30854}, "CVE-2016-10421": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10422": {"epss_score": 0.003, "epss_percentile": 0.52988}, "CVE-2016-10423": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2016-10424": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10425": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2016-10426": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2016-10427": {"epss_score": 0.00236, "epss_percentile": 0.46417}, "CVE-2016-10428": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2016-10429": {"epss_score": 0.00203, "epss_percentile": 0.42539}, "CVE-2016-10430": {"epss_score": 0.00311, "epss_percentile": 0.53842}, "CVE-2016-10431": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10432": {"epss_score": 0.0016, "epss_percentile": 0.37424}, "CVE-2016-10433": {"epss_score": 0.0016, "epss_percentile": 0.37424}, "CVE-2016-10434": {"epss_score": 0.00212, "epss_percentile": 0.43793}, "CVE-2016-10435": {"epss_score": 0.0016, "epss_percentile": 0.37424}, "CVE-2016-10436": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10437": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2016-10438": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2016-10439": {"epss_score": 0.00137, "epss_percentile": 0.34243}, "CVE-2016-10440": {"epss_score": 0.00167, "epss_percentile": 0.38328}, "CVE-2016-10441": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2016-10442": {"epss_score": 0.00167, "epss_percentile": 0.38328}, "CVE-2016-10443": {"epss_score": 0.00221, "epss_percentile": 0.44705}, "CVE-2016-10444": {"epss_score": 0.00167, "epss_percentile": 0.38328}, "CVE-2016-10445": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10446": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2016-10447": {"epss_score": 0.00301, "epss_percentile": 0.53055}, "CVE-2016-10448": {"epss_score": 0.00311, "epss_percentile": 0.53842}, "CVE-2016-10449": {"epss_score": 0.00168, "epss_percentile": 0.38474}, "CVE-2016-10450": {"epss_score": 0.00359, "epss_percentile": 0.57612}, "CVE-2016-10451": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2016-10452": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2016-10454": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10455": {"epss_score": 0.00369, "epss_percentile": 0.58253}, "CVE-2016-10456": {"epss_score": 0.00311, "epss_percentile": 0.53842}, "CVE-2016-10457": {"epss_score": 0.00156, "epss_percentile": 0.36903}, "CVE-2016-10458": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10459": {"epss_score": 0.00236, "epss_percentile": 0.46417}, "CVE-2016-10460": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10461": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10462": {"epss_score": 0.00167, "epss_percentile": 0.38328}, "CVE-2016-10464": {"epss_score": 0.00369, "epss_percentile": 0.58253}, "CVE-2016-10466": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2016-10467": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10469": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2016-10471": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2016-10472": {"epss_score": 0.00167, "epss_percentile": 0.38328}, "CVE-2016-10473": {"epss_score": 0.00359, "epss_percentile": 0.57612}, "CVE-2016-10474": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10475": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2016-10476": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2016-10477": {"epss_score": 0.00359, "epss_percentile": 0.57612}, "CVE-2016-10478": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2016-10479": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2016-10480": {"epss_score": 0.00355, "epss_percentile": 0.57281}, "CVE-2016-10481": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10482": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10483": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2016-10484": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2016-10485": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2016-10486": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10487": {"epss_score": 0.00177, "epss_percentile": 0.39524}, "CVE-2016-10489": {"epss_score": 0.00177, "epss_percentile": 0.39524}, "CVE-2016-10490": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2016-10491": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2016-10492": {"epss_score": 0.00259, "epss_percentile": 0.49093}, "CVE-2016-10493": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10494": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2016-10495": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2016-10496": {"epss_score": 0.00168, "epss_percentile": 0.38474}, "CVE-2016-10497": {"epss_score": 0.00236, "epss_percentile": 0.46417}, "CVE-2016-10498": {"epss_score": 0.00356, "epss_percentile": 0.57369}, "CVE-2016-10499": {"epss_score": 0.00236, "epss_percentile": 0.46417}, "CVE-2016-10501": {"epss_score": 0.00247, "epss_percentile": 0.47861}, "CVE-2016-10502": {"epss_score": 0.0033, "epss_percentile": 0.5543}, "CVE-2016-10503": {"epss_score": 0.00165, "epss_percentile": 0.38121}, "CVE-2016-10504": {"epss_score": 0.06106, "epss_percentile": 0.90484}, "CVE-2016-10505": {"epss_score": 0.00656, "epss_percentile": 0.70439}, "CVE-2016-10506": {"epss_score": 0.02046, "epss_percentile": 0.83385}, "CVE-2016-10507": {"epss_score": 0.00653, "epss_percentile": 0.70321}, "CVE-2016-10508": {"epss_score": 0.0019, "epss_percentile": 0.4107}, "CVE-2016-10509": {"epss_score": 0.00506, "epss_percentile": 0.65615}, "CVE-2016-10510": {"epss_score": 0.00669, "epss_percentile": 0.70767}, "CVE-2016-10511": {"epss_score": 0.00291, "epss_percentile": 0.52204}, "CVE-2016-10512": {"epss_score": 0.00398, "epss_percentile": 0.60065}, "CVE-2016-10513": {"epss_score": 0.00362, "epss_percentile": 0.57815}, "CVE-2016-10514": {"epss_score": 0.00285, "epss_percentile": 0.51512}, "CVE-2016-10515": {"epss_score": 0.00353, "epss_percentile": 0.57157}, "CVE-2016-10516": {"epss_score": 0.00314, "epss_percentile": 0.54132}, "CVE-2016-10517": {"epss_score": 0.00275, "epss_percentile": 0.50665}, "CVE-2016-10518": {"epss_score": 0.00345, "epss_percentile": 0.56566}, "CVE-2016-10519": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2016-10520": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2016-10521": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2016-10522": {"epss_score": 0.00162, "epss_percentile": 0.37694}, "CVE-2016-10523": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2016-10524": {"epss_score": 0.00249, "epss_percentile": 0.48065}, "CVE-2016-10525": {"epss_score": 0.00448, "epss_percentile": 0.62996}, "CVE-2016-10526": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2016-10527": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2016-10528": {"epss_score": 0.00393, "epss_percentile": 0.59708}, "CVE-2016-10529": {"epss_score": 0.00134, "epss_percentile": 0.33789}, "CVE-2016-10530": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2016-10531": {"epss_score": 0.00289, "epss_percentile": 0.52073}, "CVE-2016-10532": {"epss_score": 0.002, "epss_percentile": 0.42265}, "CVE-2016-10533": {"epss_score": 0.00242, "epss_percentile": 0.47399}, "CVE-2016-10534": {"epss_score": 0.00156, "epss_percentile": 0.36942}, "CVE-2016-10535": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2016-10536": {"epss_score": 0.00225, "epss_percentile": 0.45086}, "CVE-2016-10537": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2016-10538": {"epss_score": 0.00317, "epss_percentile": 0.54367}, "CVE-2016-10539": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2016-10540": {"epss_score": 0.00435, "epss_percentile": 0.62381}, "CVE-2016-10541": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2016-10542": {"epss_score": 0.66075, "epss_percentile": 0.9845}, "CVE-2016-10543": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2016-10544": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2016-10546": {"epss_score": 0.00931, "epss_percentile": 0.7562}, "CVE-2016-10547": {"epss_score": 0.0038, "epss_percentile": 0.5896}, "CVE-2016-10548": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2016-10549": {"epss_score": 0.00254, "epss_percentile": 0.48573}, "CVE-2016-10550": {"epss_score": 0.00486, "epss_percentile": 0.64774}, "CVE-2016-10551": {"epss_score": 0.00453, "epss_percentile": 0.63201}, "CVE-2016-10552": {"epss_score": 0.00136, "epss_percentile": 0.34121}, "CVE-2016-10553": {"epss_score": 0.00266, "epss_percentile": 0.49902}, "CVE-2016-10554": {"epss_score": 0.00486, "epss_percentile": 0.64774}, "CVE-2016-10555": {"epss_score": 0.81652, "epss_percentile": 0.99149}, "CVE-2016-10556": {"epss_score": 0.0022, "epss_percentile": 0.44583}, "CVE-2016-10557": {"epss_score": 0.00765, "epss_percentile": 0.72928}, "CVE-2016-10558": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10559": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10560": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10561": {"epss_score": 0.00353, "epss_percentile": 0.57189}, "CVE-2016-10562": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10563": {"epss_score": 0.00137, "epss_percentile": 0.3424}, "CVE-2016-10564": {"epss_score": 0.00765, "epss_percentile": 0.72928}, "CVE-2016-10565": {"epss_score": 0.00765, "epss_percentile": 0.72928}, "CVE-2016-10566": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10567": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10568": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10569": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10570": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10571": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10572": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10573": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10574": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10575": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10576": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10577": {"epss_score": 0.01076, "epss_percentile": 0.77326}, "CVE-2016-10578": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10579": {"epss_score": 0.00765, "epss_percentile": 0.72928}, "CVE-2016-10580": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10581": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10582": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10583": {"epss_score": 0.01558, "epss_percentile": 0.81023}, "CVE-2016-10584": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10585": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10586": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10587": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10588": {"epss_score": 0.00863, "epss_percentile": 0.74588}, "CVE-2016-10589": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10590": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10591": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10592": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10593": {"epss_score": 0.01467, "epss_percentile": 0.80475}, "CVE-2016-10594": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10595": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10596": {"epss_score": 0.00765, "epss_percentile": 0.72928}, "CVE-2016-10597": {"epss_score": 0.00119, "epss_percentile": 0.31607}, "CVE-2016-10598": {"epss_score": 0.00689, "epss_percentile": 0.7122}, "CVE-2016-10599": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10600": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10601": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10602": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10603": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10604": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10605": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10606": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10607": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10608": {"epss_score": 0.00814, "epss_percentile": 0.73769}, "CVE-2016-10609": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10610": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10611": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10612": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10613": {"epss_score": 0.00119, "epss_percentile": 0.31607}, "CVE-2016-10614": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10615": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10616": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10617": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10618": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10619": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10620": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10621": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10622": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10623": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10624": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10625": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10626": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10627": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10628": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10629": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10630": {"epss_score": 0.00119, "epss_percentile": 0.31607}, "CVE-2016-10631": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10632": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10633": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10634": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10635": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10636": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10637": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10638": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10639": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10640": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10641": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10642": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10643": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10644": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10645": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10646": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10647": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10648": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10649": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10650": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10651": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10652": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10653": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10654": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10655": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10656": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10657": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10658": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10659": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10660": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10661": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10662": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10663": {"epss_score": 0.00736, "epss_percentile": 0.72311}, "CVE-2016-10664": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10665": {"epss_score": 0.00736, "epss_percentile": 0.72311}, "CVE-2016-10666": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10667": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10668": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10669": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10670": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10671": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10672": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10673": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10674": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10675": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10676": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2016-10677": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10678": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10679": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10680": {"epss_score": 0.00163, "epss_percentile": 0.37855}, "CVE-2016-10681": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10682": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10683": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10684": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10685": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10686": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10687": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10688": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10689": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10690": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10691": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10692": {"epss_score": 0.01558, "epss_percentile": 0.81023}, "CVE-2016-10693": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10694": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10695": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10696": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10697": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10698": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2016-10699": {"epss_score": 0.0047, "epss_percentile": 0.63992}, "CVE-2016-10700": {"epss_score": 0.00551, "epss_percentile": 0.67369}, "CVE-2016-10701": {"epss_score": 0.00142, "epss_percentile": 0.35037}, "CVE-2016-10702": {"epss_score": 0.00215, "epss_percentile": 0.44094}, "CVE-2016-10703": {"epss_score": 0.01523, "epss_percentile": 0.80845}, "CVE-2016-10704": {"epss_score": 0.00104, "epss_percentile": 0.29227}, "CVE-2016-10705": {"epss_score": 0.00207, "epss_percentile": 0.43167}, "CVE-2016-10706": {"epss_score": 0.00207, "epss_percentile": 0.43167}, "CVE-2016-10707": {"epss_score": 0.00892, "epss_percentile": 0.75056}, "CVE-2016-10708": {"epss_score": 0.03751, "epss_percentile": 0.87674}, "CVE-2016-10709": {"epss_score": 0.78287, "epss_percentile": 0.98977}, "CVE-2016-10710": {"epss_score": 0.00216, "epss_percentile": 0.44223}, "CVE-2016-10711": {"epss_score": 0.00997, "epss_percentile": 0.7646}, "CVE-2016-10712": {"epss_score": 0.0056, "epss_percentile": 0.67644}, "CVE-2016-10713": {"epss_score": 0.00403, "epss_percentile": 0.60342}, "CVE-2016-10714": {"epss_score": 0.00399, "epss_percentile": 0.60113}, "CVE-2016-10715": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2016-10716": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2016-10717": {"epss_score": 0.00127, "epss_percentile": 0.32923}, "CVE-2016-10718": {"epss_score": 0.17952, "epss_percentile": 0.94933}, "CVE-2016-10719": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2016-10721": {"epss_score": 0.00944, "epss_percentile": 0.75789}, "CVE-2016-10722": {"epss_score": 0.0055, "epss_percentile": 0.67333}, "CVE-2016-10723": {"epss_score": 0.00041, "epss_percentile": 0.12342}, "CVE-2016-10724": {"epss_score": 0.0073, "epss_percentile": 0.72154}, "CVE-2016-10725": {"epss_score": 0.00905, "epss_percentile": 0.75244}, "CVE-2016-10726": {"epss_score": 0.00161, "epss_percentile": 0.37538}, "CVE-2016-10727": {"epss_score": 0.01077, "epss_percentile": 0.77334}, "CVE-2016-10728": {"epss_score": 0.00391, "epss_percentile": 0.59563}, "CVE-2016-10729": {"epss_score": 0.00213, "epss_percentile": 0.43909}, "CVE-2016-10730": {"epss_score": 0.00078, "epss_percentile": 0.23791}, "CVE-2016-10731": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2016-10732": {"epss_score": 0.00147, "epss_percentile": 0.35646}, "CVE-2016-10733": {"epss_score": 0.0044, "epss_percentile": 0.62627}, "CVE-2016-10734": {"epss_score": 0.00353, "epss_percentile": 0.57138}, "CVE-2016-10735": {"epss_score": 0.06043, "epss_percentile": 0.9043}, "CVE-2016-10736": {"epss_score": 0.00146, "epss_percentile": 0.35628}, "CVE-2016-10737": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2016-10738": {"epss_score": 0.00177, "epss_percentile": 0.39553}, "CVE-2016-10739": {"epss_score": 0.00024, "epss_percentile": 0.05689}, "CVE-2016-10740": {"epss_score": 0.00188, "epss_percentile": 0.40872}, "CVE-2016-10741": {"epss_score": 0.00066, "epss_percentile": 0.20925}, "CVE-2016-10742": {"epss_score": 0.00413, "epss_percentile": 0.60957}, "CVE-2016-10743": {"epss_score": 0.00447, "epss_percentile": 0.6298}, "CVE-2016-10744": {"epss_score": 0.00924, "epss_percentile": 0.75515}, "CVE-2016-10745": {"epss_score": 0.01042, "epss_percentile": 0.76974}, "CVE-2016-10746": {"epss_score": 0.00559, "epss_percentile": 0.67612}, "CVE-2016-10749": {"epss_score": 0.00571, "epss_percentile": 0.67988}, "CVE-2016-10750": {"epss_score": 0.02445, "epss_percentile": 0.84765}, "CVE-2016-10751": {"epss_score": 0.01171, "epss_percentile": 0.7822}, "CVE-2016-10752": {"epss_score": 0.00748, "epss_percentile": 0.72582}, "CVE-2016-10753": {"epss_score": 0.00231, "epss_percentile": 0.45802}, "CVE-2016-10754": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2016-10755": {"epss_score": 0.00222, "epss_percentile": 0.44799}, "CVE-2016-10756": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2016-10757": {"epss_score": 0.00474, "epss_percentile": 0.64139}, "CVE-2016-10758": {"epss_score": 0.00401, "epss_percentile": 0.6026}, "CVE-2016-10759": {"epss_score": 0.01006, "epss_percentile": 0.76554}, "CVE-2016-10760": {"epss_score": 0.0663, "epss_percentile": 0.90902}, "CVE-2016-10761": {"epss_score": 0.00043, "epss_percentile": 0.13019}, "CVE-2016-10762": {"epss_score": 0.00941, "epss_percentile": 0.75744}, "CVE-2016-10763": {"epss_score": 0.00413, "epss_percentile": 0.61006}, "CVE-2016-10764": {"epss_score": 0.00815, "epss_percentile": 0.73793}, "CVE-2016-10765": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2016-10766": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2016-10767": {"epss_score": 0.002, "epss_percentile": 0.42197}, "CVE-2016-10768": {"epss_score": 0.00314, "epss_percentile": 0.54159}, "CVE-2016-10769": {"epss_score": 0.00211, "epss_percentile": 0.43704}, "CVE-2016-10770": {"epss_score": 0.00314, "epss_percentile": 0.54159}, "CVE-2016-10771": {"epss_score": 0.00411, "epss_percentile": 0.60866}, "CVE-2016-10772": {"epss_score": 0.00082, "epss_percentile": 0.24493}, "CVE-2016-10773": {"epss_score": 0.00485, "epss_percentile": 0.64712}, "CVE-2016-10774": {"epss_score": 0.0025, "epss_percentile": 0.4814}, "CVE-2016-10775": {"epss_score": 0.00392, "epss_percentile": 0.5966}, "CVE-2016-10776": {"epss_score": 0.00309, "epss_percentile": 0.53658}, "CVE-2016-10777": {"epss_score": 0.00292, "epss_percentile": 0.52264}, "CVE-2016-10778": {"epss_score": 0.00309, "epss_percentile": 0.53658}, "CVE-2016-10779": {"epss_score": 0.00264, "epss_percentile": 0.49699}, "CVE-2016-10780": {"epss_score": 0.00309, "epss_percentile": 0.53658}, "CVE-2016-10781": {"epss_score": 0.00309, "epss_percentile": 0.53658}, "CVE-2016-10782": {"epss_score": 0.00309, "epss_percentile": 0.53658}, "CVE-2016-10783": {"epss_score": 0.00309, "epss_percentile": 0.53658}, "CVE-2016-10784": {"epss_score": 0.00309, "epss_percentile": 0.53658}, "CVE-2016-10785": {"epss_score": 0.00411, "epss_percentile": 0.60866}, "CVE-2016-10786": {"epss_score": 0.00411, "epss_percentile": 0.60866}, "CVE-2016-10787": {"epss_score": 0.00411, "epss_percentile": 0.60866}, "CVE-2016-10788": {"epss_score": 0.01055, "epss_percentile": 0.77116}, "CVE-2016-10789": {"epss_score": 0.01324, "epss_percentile": 0.79463}, "CVE-2016-10790": {"epss_score": 0.00579, "epss_percentile": 0.68228}, "CVE-2016-10791": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2016-10792": {"epss_score": 0.00874, "epss_percentile": 0.74769}, "CVE-2016-10793": {"epss_score": 0.01324, "epss_percentile": 0.79463}, "CVE-2016-10794": {"epss_score": 0.00411, "epss_percentile": 0.60866}, "CVE-2016-10795": {"epss_score": 0.00323, "epss_percentile": 0.54912}, "CVE-2016-10796": {"epss_score": 0.00059, "epss_percentile": 0.18809}, "CVE-2016-10797": {"epss_score": 0.00125, "epss_percentile": 0.3256}, "CVE-2016-10798": {"epss_score": 0.00233, "epss_percentile": 0.46041}, "CVE-2016-10799": {"epss_score": 0.0007, "epss_percentile": 0.21878}, "CVE-2016-10800": {"epss_score": 0.00256, "epss_percentile": 0.48739}, "CVE-2016-10801": {"epss_score": 0.00749, "epss_percentile": 0.72594}, "CVE-2016-10802": {"epss_score": 0.00762, "epss_percentile": 0.72833}, "CVE-2016-10803": {"epss_score": 0.00299, "epss_percentile": 0.52859}, "CVE-2016-10804": {"epss_score": 0.00334, "epss_percentile": 0.55728}, "CVE-2016-10805": {"epss_score": 0.01233, "epss_percentile": 0.78744}, "CVE-2016-10806": {"epss_score": 0.00264, "epss_percentile": 0.49699}, "CVE-2016-10807": {"epss_score": 0.00463, "epss_percentile": 0.63699}, "CVE-2016-10808": {"epss_score": 0.00587, "epss_percentile": 0.68476}, "CVE-2016-10809": {"epss_score": 0.00511, "epss_percentile": 0.6584}, "CVE-2016-10810": {"epss_score": 0.00511, "epss_percentile": 0.6584}, "CVE-2016-10811": {"epss_score": 0.00511, "epss_percentile": 0.6584}, "CVE-2016-10812": {"epss_score": 0.00587, "epss_percentile": 0.68476}, "CVE-2016-10813": {"epss_score": 0.00233, "epss_percentile": 0.46027}, "CVE-2016-10814": {"epss_score": 0.00695, "epss_percentile": 0.71363}, "CVE-2016-10815": {"epss_score": 0.00411, "epss_percentile": 0.60866}, "CVE-2016-10816": {"epss_score": 0.01324, "epss_percentile": 0.79463}, "CVE-2016-10817": {"epss_score": 0.004, "epss_percentile": 0.60169}, "CVE-2016-10818": {"epss_score": 0.0031, "epss_percentile": 0.53806}, "CVE-2016-10819": {"epss_score": 0.00411, "epss_percentile": 0.60866}, "CVE-2016-10820": {"epss_score": 0.00386, "epss_percentile": 0.59273}, "CVE-2016-10821": {"epss_score": 0.00411, "epss_percentile": 0.60866}, "CVE-2016-10822": {"epss_score": 0.00233, "epss_percentile": 0.46027}, "CVE-2016-10823": {"epss_score": 0.01055, "epss_percentile": 0.77116}, "CVE-2016-10824": {"epss_score": 0.00958, "epss_percentile": 0.75941}, "CVE-2016-10825": {"epss_score": 0.0029, "epss_percentile": 0.52133}, "CVE-2016-10826": {"epss_score": 0.00464, "epss_percentile": 0.63734}, "CVE-2016-10827": {"epss_score": 0.00233, "epss_percentile": 0.46027}, "CVE-2016-10828": {"epss_score": 0.01632, "epss_percentile": 0.81457}, "CVE-2016-10829": {"epss_score": 0.00456, "epss_percentile": 0.63343}, "CVE-2016-10830": {"epss_score": 0.00222, "epss_percentile": 0.44825}, "CVE-2016-10831": {"epss_score": 0.00731, "epss_percentile": 0.72177}, "CVE-2016-10832": {"epss_score": 0.00222, "epss_percentile": 0.44825}, "CVE-2016-10833": {"epss_score": 0.00496, "epss_percentile": 0.65152}, "CVE-2016-10834": {"epss_score": 0.00492, "epss_percentile": 0.64983}, "CVE-2016-10835": {"epss_score": 0.00171, "epss_percentile": 0.38769}, "CVE-2016-10836": {"epss_score": 0.00371, "epss_percentile": 0.58364}, "CVE-2016-10837": {"epss_score": 0.01127, "epss_percentile": 0.7782}, "CVE-2016-10838": {"epss_score": 0.00258, "epss_percentile": 0.48952}, "CVE-2016-10839": {"epss_score": 0.00373, "epss_percentile": 0.58478}, "CVE-2016-10840": {"epss_score": 0.01055, "epss_percentile": 0.77116}, "CVE-2016-10841": {"epss_score": 0.00357, "epss_percentile": 0.57479}, "CVE-2016-10842": {"epss_score": 0.00411, "epss_percentile": 0.60866}, "CVE-2016-10843": {"epss_score": 0.00858, "epss_percentile": 0.74504}, "CVE-2016-10844": {"epss_score": 0.00357, "epss_percentile": 0.57479}, "CVE-2016-10845": {"epss_score": 0.00449, "epss_percentile": 0.63034}, "CVE-2016-10846": {"epss_score": 0.00384, "epss_percentile": 0.59151}, "CVE-2016-10847": {"epss_score": 0.00391, "epss_percentile": 0.5956}, "CVE-2016-10848": {"epss_score": 0.00437, "epss_percentile": 0.62503}, "CVE-2016-10849": {"epss_score": 0.00344, "epss_percentile": 0.5648}, "CVE-2016-10850": {"epss_score": 0.01325, "epss_percentile": 0.79474}, "CVE-2016-10851": {"epss_score": 0.00294, "epss_percentile": 0.5241}, "CVE-2016-10852": {"epss_score": 0.00235, "epss_percentile": 0.46232}, "CVE-2016-10853": {"epss_score": 0.00252, "epss_percentile": 0.48337}, "CVE-2016-10854": {"epss_score": 0.00294, "epss_percentile": 0.5241}, "CVE-2016-10855": {"epss_score": 0.01292, "epss_percentile": 0.79235}, "CVE-2016-10856": {"epss_score": 0.0027, "epss_percentile": 0.50231}, "CVE-2016-10857": {"epss_score": 0.00251, "epss_percentile": 0.48304}, "CVE-2016-10858": {"epss_score": 0.0138, "epss_percentile": 0.79861}, "CVE-2016-10859": {"epss_score": 0.00235, "epss_percentile": 0.46232}, "CVE-2016-10860": {"epss_score": 0.0035, "epss_percentile": 0.56954}, "CVE-2016-10861": {"epss_score": 0.00117, "epss_percentile": 0.31326}, "CVE-2016-10862": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2016-10863": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2016-10864": {"epss_score": 0.00142, "epss_percentile": 0.34995}, "CVE-2016-10865": {"epss_score": 0.00107, "epss_percentile": 0.2966}, "CVE-2016-10866": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10867": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10868": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10869": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10870": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10871": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10872": {"epss_score": 0.00311, "epss_percentile": 0.53815}, "CVE-2016-10873": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10874": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2016-10875": {"epss_score": 0.00207, "epss_percentile": 0.43167}, "CVE-2016-10876": {"epss_score": 0.00132, "epss_percentile": 0.33619}, "CVE-2016-10877": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2016-10878": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10879": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2016-10880": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10881": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10882": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2016-10883": {"epss_score": 0.00086, "epss_percentile": 0.25341}, "CVE-2016-10884": {"epss_score": 0.003, "epss_percentile": 0.52964}, "CVE-2016-10885": {"epss_score": 0.00148, "epss_percentile": 0.35822}, "CVE-2016-10886": {"epss_score": 0.00697, "epss_percentile": 0.71406}, "CVE-2016-10887": {"epss_score": 0.00596, "epss_percentile": 0.68717}, "CVE-2016-10888": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2016-10889": {"epss_score": 0.00781, "epss_percentile": 0.7319}, "CVE-2016-10890": {"epss_score": 0.00242, "epss_percentile": 0.47362}, "CVE-2016-10891": {"epss_score": 0.00311, "epss_percentile": 0.53815}, "CVE-2016-10892": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10893": {"epss_score": 0.00496, "epss_percentile": 0.65157}, "CVE-2016-10894": {"epss_score": 0.00044, "epss_percentile": 0.13676}, "CVE-2016-10895": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10896": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10897": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10898": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10899": {"epss_score": 0.00187, "epss_percentile": 0.40739}, "CVE-2016-10900": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10901": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10902": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2016-10903": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2016-10904": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2016-10905": {"epss_score": 0.0007, "epss_percentile": 0.21684}, "CVE-2016-10906": {"epss_score": 0.00067, "epss_percentile": 0.21087}, "CVE-2016-10907": {"epss_score": 0.00089, "epss_percentile": 0.25935}, "CVE-2016-10908": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10909": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2016-10910": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10911": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10912": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10913": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10914": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2016-10915": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2016-10916": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2016-10917": {"epss_score": 0.00687, "epss_percentile": 0.7118}, "CVE-2016-10918": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2016-10919": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10920": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10921": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2016-10922": {"epss_score": 0.00337, "epss_percentile": 0.56015}, "CVE-2016-10923": {"epss_score": 0.00337, "epss_percentile": 0.56015}, "CVE-2016-10924": {"epss_score": 0.62226, "epss_percentile": 0.98285}, "CVE-2016-10925": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10926": {"epss_score": 0.00451, "epss_percentile": 0.63113}, "CVE-2016-10927": {"epss_score": 0.00451, "epss_percentile": 0.63113}, "CVE-2016-10928": {"epss_score": 0.00682, "epss_percentile": 0.71073}, "CVE-2016-10929": {"epss_score": 0.00249, "epss_percentile": 0.48079}, "CVE-2016-10930": {"epss_score": 0.00841, "epss_percentile": 0.74226}, "CVE-2016-10931": {"epss_score": 0.00183, "epss_percentile": 0.40305}, "CVE-2016-10932": {"epss_score": 0.00203, "epss_percentile": 0.42553}, "CVE-2016-10933": {"epss_score": 0.00242, "epss_percentile": 0.47385}, "CVE-2016-10934": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10935": {"epss_score": 0.00337, "epss_percentile": 0.56015}, "CVE-2016-10936": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10937": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2016-10938": {"epss_score": 0.00123, "epss_percentile": 0.32236}, "CVE-2016-10939": {"epss_score": 0.00539, "epss_percentile": 0.66961}, "CVE-2016-10940": {"epss_score": 0.13503, "epss_percentile": 0.93983}, "CVE-2016-10941": {"epss_score": 0.0026, "epss_percentile": 0.492}, "CVE-2016-10942": {"epss_score": 0.00977, "epss_percentile": 0.7622}, "CVE-2016-10943": {"epss_score": 0.00644, "epss_percentile": 0.70087}, "CVE-2016-10944": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2016-10945": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2016-10946": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2016-10947": {"epss_score": 0.00539, "epss_percentile": 0.66961}, "CVE-2016-10948": {"epss_score": 0.00841, "epss_percentile": 0.74226}, "CVE-2016-10949": {"epss_score": 0.00592, "epss_percentile": 0.68607}, "CVE-2016-10950": {"epss_score": 0.00616, "epss_percentile": 0.69325}, "CVE-2016-10951": {"epss_score": 0.00656, "epss_percentile": 0.70451}, "CVE-2016-10952": {"epss_score": 0.00243, "epss_percentile": 0.47415}, "CVE-2016-10953": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2016-10954": {"epss_score": 0.00841, "epss_percentile": 0.74226}, "CVE-2016-10955": {"epss_score": 0.00841, "epss_percentile": 0.74226}, "CVE-2016-10956": {"epss_score": 0.89171, "epss_percentile": 0.99512}, "CVE-2016-10957": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10958": {"epss_score": 0.00589, "epss_percentile": 0.68531}, "CVE-2016-10959": {"epss_score": 0.00423, "epss_percentile": 0.61582}, "CVE-2016-10960": {"epss_score": 0.57085, "epss_percentile": 0.98048}, "CVE-2016-10961": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10962": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2016-10963": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10964": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10965": {"epss_score": 0.00518, "epss_percentile": 0.66135}, "CVE-2016-10966": {"epss_score": 0.00358, "epss_percentile": 0.57498}, "CVE-2016-10967": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10968": {"epss_score": 0.0022, "epss_percentile": 0.44604}, "CVE-2016-10969": {"epss_score": 0.00264, "epss_percentile": 0.49695}, "CVE-2016-10970": {"epss_score": 0.00311, "epss_percentile": 0.53815}, "CVE-2016-10971": {"epss_score": 0.00706, "epss_percentile": 0.71605}, "CVE-2016-10972": {"epss_score": 0.66029, "epss_percentile": 0.98448}, "CVE-2016-10973": {"epss_score": 0.00979, "epss_percentile": 0.76254}, "CVE-2016-10974": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2016-10975": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10976": {"epss_score": 0.00656, "epss_percentile": 0.70451}, "CVE-2016-10977": {"epss_score": 0.00455, "epss_percentile": 0.63272}, "CVE-2016-10978": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2016-10979": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10980": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10981": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10982": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2016-10983": {"epss_score": 0.00558, "epss_percentile": 0.67579}, "CVE-2016-10984": {"epss_score": 0.00238, "epss_percentile": 0.46784}, "CVE-2016-10985": {"epss_score": 0.00238, "epss_percentile": 0.46784}, "CVE-2016-10986": {"epss_score": 0.00238, "epss_percentile": 0.46784}, "CVE-2016-10987": {"epss_score": 0.0026, "epss_percentile": 0.492}, "CVE-2016-10988": {"epss_score": 0.00238, "epss_percentile": 0.46784}, "CVE-2016-10989": {"epss_score": 0.00242, "epss_percentile": 0.47361}, "CVE-2016-10990": {"epss_score": 0.01192, "epss_percentile": 0.78402}, "CVE-2016-10991": {"epss_score": 0.00599, "epss_percentile": 0.68807}, "CVE-2016-10992": {"epss_score": 0.00258, "epss_percentile": 0.48994}, "CVE-2016-10993": {"epss_score": 0.01517, "epss_percentile": 0.80806}, "CVE-2016-10994": {"epss_score": 0.00938, "epss_percentile": 0.75715}, "CVE-2016-10995": {"epss_score": 0.00841, "epss_percentile": 0.74226}, "CVE-2016-10996": {"epss_score": 0.00157, "epss_percentile": 0.37019}, "CVE-2016-10997": {"epss_score": 0.00189, "epss_percentile": 0.40968}, "CVE-2016-10998": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-10999": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-11000": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2016-11001": {"epss_score": 0.00174, "epss_percentile": 0.39185}, "CVE-2016-11002": {"epss_score": 0.00192, "epss_percentile": 0.41331}, "CVE-2016-11003": {"epss_score": 0.00192, "epss_percentile": 0.41331}, "CVE-2016-11004": {"epss_score": 0.00192, "epss_percentile": 0.41331}, "CVE-2016-11005": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-11006": {"epss_score": 0.00228, "epss_percentile": 0.4551}, "CVE-2016-11007": {"epss_score": 0.00319, "epss_percentile": 0.54551}, "CVE-2016-11008": {"epss_score": 0.00228, "epss_percentile": 0.4551}, "CVE-2016-11009": {"epss_score": 0.00228, "epss_percentile": 0.4551}, "CVE-2016-11010": {"epss_score": 0.00249, "epss_percentile": 0.48071}, "CVE-2016-11011": {"epss_score": 0.0016, "epss_percentile": 0.37444}, "CVE-2016-11012": {"epss_score": 0.00178, "epss_percentile": 0.39652}, "CVE-2016-11013": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2016-11014": {"epss_score": 0.00444, "epss_percentile": 0.6281}, "CVE-2016-11015": {"epss_score": 0.00244, "epss_percentile": 0.47517}, "CVE-2016-11016": {"epss_score": 0.00681, "epss_percentile": 0.71046}, "CVE-2016-11017": {"epss_score": 0.19436, "epss_percentile": 0.95181}, "CVE-2016-11018": {"epss_score": 0.01138, "epss_percentile": 0.77931}, "CVE-2016-11020": {"epss_score": 0.03391, "epss_percentile": 0.87052}, "CVE-2016-11021": {"epss_score": 0.91253, "epss_percentile": 0.9963}, "CVE-2016-11022": {"epss_score": 0.03729, "epss_percentile": 0.87638}, "CVE-2016-11023": {"epss_score": 0.00281, "epss_percentile": 0.51103}, "CVE-2016-11024": {"epss_score": 0.00281, "epss_percentile": 0.51103}, "CVE-2016-11025": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2016-11026": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2016-11027": {"epss_score": 0.00018, "epss_percentile": 0.04025}, "CVE-2016-11028": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2016-11029": {"epss_score": 0.00114, "epss_percentile": 0.30879}, "CVE-2016-11030": {"epss_score": 0.00123, "epss_percentile": 0.32241}, "CVE-2016-11031": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2016-11032": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2016-11033": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2016-11034": {"epss_score": 0.00106, "epss_percentile": 0.29479}, "CVE-2016-11035": {"epss_score": 0.00016, "epss_percentile": 0.02939}, "CVE-2016-11036": {"epss_score": 0.00129, "epss_percentile": 0.33211}, "CVE-2016-11038": {"epss_score": 0.00187, "epss_percentile": 0.40754}, "CVE-2016-11039": {"epss_score": 0.00125, "epss_percentile": 0.32559}, "CVE-2016-11040": {"epss_score": 0.00019, "epss_percentile": 0.04156}, "CVE-2016-11041": {"epss_score": 0.00021, "epss_percentile": 0.04785}, "CVE-2016-11042": {"epss_score": 0.00114, "epss_percentile": 0.30879}, "CVE-2016-11043": {"epss_score": 0.0005, "epss_percentile": 0.15757}, "CVE-2016-11044": {"epss_score": 9e-05, "epss_percentile": 0.00685}, "CVE-2016-11045": {"epss_score": 0.00061, "epss_percentile": 0.19412}, "CVE-2016-11046": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2016-11047": {"epss_score": 0.00015, "epss_percentile": 0.026}, "CVE-2016-11048": {"epss_score": 0.00019, "epss_percentile": 0.04156}, "CVE-2016-11049": {"epss_score": 0.0012, "epss_percentile": 0.31691}, "CVE-2016-11050": {"epss_score": 0.00066, "epss_percentile": 0.20761}, "CVE-2016-11052": {"epss_score": 0.00061, "epss_percentile": 0.19412}, "CVE-2016-11053": {"epss_score": 0.00019, "epss_percentile": 0.04156}, "CVE-2016-11054": {"epss_score": 0.01259, "epss_percentile": 0.78965}, "CVE-2016-11055": {"epss_score": 0.0012, "epss_percentile": 0.317}, "CVE-2016-11056": {"epss_score": 0.0067, "epss_percentile": 0.70781}, "CVE-2016-11057": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2016-11058": {"epss_score": 0.00284, "epss_percentile": 0.51474}, "CVE-2016-11059": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2016-11060": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2016-11061": {"epss_score": 0.02486, "epss_percentile": 0.84889}, "CVE-2016-11062": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2016-11063": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2016-11064": {"epss_score": 0.00647, "epss_percentile": 0.70197}, "CVE-2016-11065": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2016-11066": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2016-11067": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2016-11068": {"epss_score": 0.0035, "epss_percentile": 0.56946}, "CVE-2016-11069": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2016-11070": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2016-11071": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2016-11072": {"epss_score": 0.00186, "epss_percentile": 0.40659}, "CVE-2016-11073": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2016-11074": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2016-11075": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2016-11076": {"epss_score": 0.00311, "epss_percentile": 0.5383}, "CVE-2016-11077": {"epss_score": 0.00182, "epss_percentile": 0.40224}, "CVE-2016-11078": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2016-11079": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2016-11080": {"epss_score": 0.00149, "epss_percentile": 0.35948}, "CVE-2016-11081": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2016-11082": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2016-11083": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2016-11084": {"epss_score": 0.00125, "epss_percentile": 0.32469}, "CVE-2016-11085": {"epss_score": 0.0023, "epss_percentile": 0.45737}, "CVE-2016-11086": {"epss_score": 0.00143, "epss_percentile": 0.35204}, "CVE-2016-15002": {"epss_score": 0.003, "epss_percentile": 0.52952}, "CVE-2016-15003": {"epss_score": 0.00412, "epss_percentile": 0.60931}, "CVE-2016-15004": {"epss_score": 0.01496, "epss_percentile": 0.80683}, "CVE-2016-15005": {"epss_score": 0.00199, "epss_percentile": 0.42117}, "CVE-2016-15006": {"epss_score": 0.00347, "epss_percentile": 0.56785}, "CVE-2016-15007": {"epss_score": 0.00487, "epss_percentile": 0.64804}, "CVE-2016-15008": {"epss_score": 0.00306, "epss_percentile": 0.53442}, "CVE-2016-15009": {"epss_score": 0.00185, "epss_percentile": 0.40516}, "CVE-2016-15010": {"epss_score": 0.00353, "epss_percentile": 0.57149}, "CVE-2016-15011": {"epss_score": 0.0005, "epss_percentile": 0.1567}, "CVE-2016-15012": {"epss_score": 0.00077, "epss_percentile": 0.2353}, "CVE-2016-15013": {"epss_score": 0.00059, "epss_percentile": 0.18857}, "CVE-2016-15014": {"epss_score": 0.00035, "epss_percentile": 0.09918}, "CVE-2016-15015": {"epss_score": 0.00135, "epss_percentile": 0.33991}, "CVE-2016-15016": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2016-15017": {"epss_score": 0.00123, "epss_percentile": 0.32299}, "CVE-2016-15018": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2016-15019": {"epss_score": 0.00156, "epss_percentile": 0.36937}, "CVE-2016-15020": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2016-15021": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2016-15022": {"epss_score": 0.00065, "epss_percentile": 0.20501}, "CVE-2016-15023": {"epss_score": 0.00129, "epss_percentile": 0.33147}, "CVE-2016-15024": {"epss_score": 0.00025, "epss_percentile": 0.06361}, "CVE-2016-15025": {"epss_score": 0.00091, "epss_percentile": 0.26221}, "CVE-2016-15026": {"epss_score": 0.00065, "epss_percentile": 0.20506}, "CVE-2016-15027": {"epss_score": 0.0019, "epss_percentile": 0.41102}, "CVE-2016-15028": {"epss_score": 0.00046, "epss_percentile": 0.14107}, "CVE-2016-15029": {"epss_score": 0.00073, "epss_percentile": 0.22499}, "CVE-2016-15030": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2016-15031": {"epss_score": 0.00044, "epss_percentile": 0.13455}, "CVE-2016-15032": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2016-15033": {"epss_score": 0.05045, "epss_percentile": 0.89434}, "CVE-2016-15034": {"epss_score": 0.00044, "epss_percentile": 0.13465}, "CVE-2016-15035": {"epss_score": 0.00312, "epss_percentile": 0.53997}, "CVE-2016-15036": {"epss_score": 0.0004, "epss_percentile": 0.12062}, "CVE-2016-15037": {"epss_score": 0.0031, "epss_percentile": 0.53741}, "CVE-2016-15038": {"epss_score": 0.00065, "epss_percentile": 0.20457}, "CVE-2016-15039": {"epss_score": 0.00104, "epss_percentile": 0.29177}, "CVE-2016-15040": {"epss_score": 0.00805, "epss_percentile": 0.73637}, "CVE-2016-15041": {"epss_score": 0.01103, "epss_percentile": 0.77592}, "CVE-2016-15042": {"epss_score": 0.70789, "epss_percentile": 0.98641}, "CVE-2016-15043": {"epss_score": 0.85359, "epss_percentile": 0.9933}, "CVE-2016-15044": {"epss_score": 0.64031, "epss_percentile": 0.9836}, "CVE-2016-15045": {"epss_score": 0.0138, "epss_percentile": 0.79865}, "CVE-2016-15046": {"epss_score": 0.00406, "epss_percentile": 0.60531}, "CVE-2016-15047": {"epss_score": 0.00651, "epss_percentile": 0.70303}, "CVE-2016-15048": {"epss_score": 0.00743, "epss_percentile": 0.72477}, "CVE-2016-15049": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2016-15050": {"epss_score": 0.01157, "epss_percentile": 0.7811}, "CVE-2016-15051": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2016-15052": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2016-15053": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2016-15055": {"epss_score": 0.02467, "epss_percentile": 0.84838}, "CVE-2016-15056": {"epss_score": 0.0046, "epss_percentile": 0.63515}, "CVE-2016-1000": {"epss_score": 0.557, "epss_percentile": 0.97989}, "CVE-2016-1001": {"epss_score": 0.33454, "epss_percentile": 0.96774}, "CVE-2016-1002": {"epss_score": 0.49164, "epss_percentile": 0.97671}, "CVE-2016-1005": {"epss_score": 0.05397, "epss_percentile": 0.89828}, "CVE-2016-1006": {"epss_score": 0.00948, "epss_percentile": 0.75833}, "CVE-2016-1007": {"epss_score": 0.03625, "epss_percentile": 0.87455}, "CVE-2016-1008": {"epss_score": 0.00586, "epss_percentile": 0.68436}, "CVE-2016-1009": {"epss_score": 0.03625, "epss_percentile": 0.87455}, "CVE-2016-1010": {"epss_score": 0.15627, "epss_percentile": 0.94472}, "CVE-2016-1011": {"epss_score": 0.55399, "epss_percentile": 0.97975}, "CVE-2016-1012": {"epss_score": 0.05385, "epss_percentile": 0.89818}, "CVE-2016-1013": {"epss_score": 0.51001, "epss_percentile": 0.97758}, "CVE-2016-1014": {"epss_score": 0.00215, "epss_percentile": 0.44109}, "CVE-2016-1015": {"epss_score": 0.07246, "epss_percentile": 0.91348}, "CVE-2016-1016": {"epss_score": 0.11851, "epss_percentile": 0.93496}, "CVE-2016-1017": {"epss_score": 0.11851, "epss_percentile": 0.93496}, "CVE-2016-1018": {"epss_score": 0.04918, "epss_percentile": 0.89289}, "CVE-2016-1019": {"epss_score": 0.7446, "epss_percentile": 0.988}, "CVE-2016-1020": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-1021": {"epss_score": 0.03301, "epss_percentile": 0.86866}, "CVE-2016-1022": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-1023": {"epss_score": 0.02374, "epss_percentile": 0.84536}, "CVE-2016-1024": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-1025": {"epss_score": 0.02374, "epss_percentile": 0.84536}, "CVE-2016-1026": {"epss_score": 0.02374, "epss_percentile": 0.84536}, "CVE-2016-1027": {"epss_score": 0.02374, "epss_percentile": 0.84536}, "CVE-2016-1028": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-1029": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-1030": {"epss_score": 0.011, "epss_percentile": 0.77566}, "CVE-2016-1031": {"epss_score": 0.04553, "epss_percentile": 0.88841}, "CVE-2016-1032": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-1033": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-1034": {"epss_score": 0.01473, "epss_percentile": 0.80516}, "CVE-2016-1035": {"epss_score": 0.0339, "epss_percentile": 0.87048}, "CVE-2016-1036": {"epss_score": 0.00636, "epss_percentile": 0.69861}, "CVE-2016-1037": {"epss_score": 0.0206, "epss_percentile": 0.83442}, "CVE-2016-1038": {"epss_score": 0.05352, "epss_percentile": 0.89775}, "CVE-2016-1039": {"epss_score": 0.00939, "epss_percentile": 0.75719}, "CVE-2016-1040": {"epss_score": 0.01271, "epss_percentile": 0.79053}, "CVE-2016-1041": {"epss_score": 0.00939, "epss_percentile": 0.75719}, "CVE-2016-1042": {"epss_score": 0.00939, "epss_percentile": 0.75719}, "CVE-2016-1043": {"epss_score": 0.02555, "epss_percentile": 0.8509}, "CVE-2016-1044": {"epss_score": 0.05096, "epss_percentile": 0.89494}, "CVE-2016-1045": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1046": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1047": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1048": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1049": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1050": {"epss_score": 0.02751, "epss_percentile": 0.85582}, "CVE-2016-1051": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1052": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1053": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1054": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1055": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1056": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1057": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1058": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1059": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1060": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1061": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1062": {"epss_score": 0.00939, "epss_percentile": 0.75719}, "CVE-2016-1063": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-1064": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1065": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1066": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1067": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1068": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1069": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1070": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1071": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-1072": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-1073": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-1074": {"epss_score": 0.0236, "epss_percentile": 0.84493}, "CVE-2016-1075": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1076": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-1077": {"epss_score": 0.12588, "epss_percentile": 0.93722}, "CVE-2016-1078": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-1079": {"epss_score": 0.0205, "epss_percentile": 0.83397}, "CVE-2016-1080": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-1081": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1082": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1083": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1084": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1085": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1086": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1087": {"epss_score": 0.00484, "epss_percentile": 0.64632}, "CVE-2016-1088": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1089": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-1090": {"epss_score": 0.00484, "epss_percentile": 0.64632}, "CVE-2016-1091": {"epss_score": 0.02077, "epss_percentile": 0.83515}, "CVE-2016-1092": {"epss_score": 0.02038, "epss_percentile": 0.8336}, "CVE-2016-1093": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1094": {"epss_score": 0.02457, "epss_percentile": 0.84812}, "CVE-2016-1095": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-1096": {"epss_score": 0.39664, "epss_percentile": 0.97174}, "CVE-2016-1097": {"epss_score": 0.06955, "epss_percentile": 0.91145}, "CVE-2016-1098": {"epss_score": 0.15468, "epss_percentile": 0.94435}, "CVE-2016-1099": {"epss_score": 0.15468, "epss_percentile": 0.94435}, "CVE-2016-1100": {"epss_score": 0.15468, "epss_percentile": 0.94435}, "CVE-2016-1101": {"epss_score": 0.53066, "epss_percentile": 0.97855}, "CVE-2016-1102": {"epss_score": 0.39664, "epss_percentile": 0.97174}, "CVE-2016-1103": {"epss_score": 0.53066, "epss_percentile": 0.97855}, "CVE-2016-1104": {"epss_score": 0.39664, "epss_percentile": 0.97174}, "CVE-2016-1105": {"epss_score": 0.53066, "epss_percentile": 0.97855}, "CVE-2016-1106": {"epss_score": 0.60045, "epss_percentile": 0.98191}, "CVE-2016-1107": {"epss_score": 0.06955, "epss_percentile": 0.91145}, "CVE-2016-1108": {"epss_score": 0.06955, "epss_percentile": 0.91145}, "CVE-2016-1109": {"epss_score": 0.06955, "epss_percentile": 0.91145}, "CVE-2016-1110": {"epss_score": 0.06955, "epss_percentile": 0.91145}, "CVE-2016-1111": {"epss_score": 0.02613, "epss_percentile": 0.85239}, "CVE-2016-1112": {"epss_score": 0.022, "epss_percentile": 0.83973}, "CVE-2016-1113": {"epss_score": 0.01228, "epss_percentile": 0.78705}, "CVE-2016-1114": {"epss_score": 0.0234, "epss_percentile": 0.84433}, "CVE-2016-1115": {"epss_score": 0.02491, "epss_percentile": 0.84898}, "CVE-2016-1116": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1117": {"epss_score": 0.00939, "epss_percentile": 0.75719}, "CVE-2016-1118": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1119": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1120": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1121": {"epss_score": 0.03673, "epss_percentile": 0.87547}, "CVE-2016-1122": {"epss_score": 0.03673, "epss_percentile": 0.87547}, "CVE-2016-1123": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1124": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1125": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1126": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1127": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1128": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1129": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1130": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-1131": {"epss_score": 0.01386, "epss_percentile": 0.79912}, "CVE-2016-1132": {"epss_score": 0.00298, "epss_percentile": 0.52808}, "CVE-2016-1133": {"epss_score": 0.00386, "epss_percentile": 0.59248}, "CVE-2016-1134": {"epss_score": 0.00103, "epss_percentile": 0.28923}, "CVE-2016-1135": {"epss_score": 0.00236, "epss_percentile": 0.46448}, "CVE-2016-1136": {"epss_score": 0.00222, "epss_percentile": 0.4475}, "CVE-2016-1137": {"epss_score": 0.00274, "epss_percentile": 0.50541}, "CVE-2016-1138": {"epss_score": 0.00298, "epss_percentile": 0.52775}, "CVE-2016-1139": {"epss_score": 0.00129, "epss_percentile": 0.33081}, "CVE-2016-1140": {"epss_score": 0.00297, "epss_percentile": 0.52772}, "CVE-2016-1141": {"epss_score": 0.00538, "epss_percentile": 0.6695}, "CVE-2016-1142": {"epss_score": 0.00703, "epss_percentile": 0.71544}, "CVE-2016-1143": {"epss_score": 0.00322, "epss_percentile": 0.54754}, "CVE-2016-1144": {"epss_score": 0.00203, "epss_percentile": 0.42527}, "CVE-2016-1145": {"epss_score": 0.0043, "epss_percentile": 0.62026}, "CVE-2016-1148": {"epss_score": 0.00455, "epss_percentile": 0.63293}, "CVE-2016-1149": {"epss_score": 0.00515, "epss_percentile": 0.66011}, "CVE-2016-1150": {"epss_score": 0.00515, "epss_percentile": 0.66011}, "CVE-2016-1151": {"epss_score": 0.00129, "epss_percentile": 0.33081}, "CVE-2016-1152": {"epss_score": 0.00241, "epss_percentile": 0.47295}, "CVE-2016-1153": {"epss_score": 0.00582, "epss_percentile": 0.68289}, "CVE-2016-1154": {"epss_score": 0.00878, "epss_percentile": 0.74826}, "CVE-2016-1155": {"epss_score": 0.05411, "epss_percentile": 0.89846}, "CVE-2016-1156": {"epss_score": 0.00375, "epss_percentile": 0.58629}, "CVE-2016-1157": {"epss_score": 0.00322, "epss_percentile": 0.54754}, "CVE-2016-1158": {"epss_score": 0.00179, "epss_percentile": 0.39854}, "CVE-2016-1159": {"epss_score": 0.00476, "epss_percentile": 0.64255}, "CVE-2016-1160": {"epss_score": 0.00442, "epss_percentile": 0.62742}, "CVE-2016-1161": {"epss_score": 0.00244, "epss_percentile": 0.47552}, "CVE-2016-1167": {"epss_score": 0.00129, "epss_percentile": 0.33081}, "CVE-2016-1168": {"epss_score": 0.00129, "epss_percentile": 0.33081}, "CVE-2016-1169": {"epss_score": 0.00322, "epss_percentile": 0.54754}, "CVE-2016-1170": {"epss_score": 0.00129, "epss_percentile": 0.33081}, "CVE-2016-1171": {"epss_score": 0.00322, "epss_percentile": 0.54754}, "CVE-2016-1172": {"epss_score": 0.00129, "epss_percentile": 0.33081}, "CVE-2016-1173": {"epss_score": 0.00322, "epss_percentile": 0.54754}, "CVE-2016-1174": {"epss_score": 0.00129, "epss_percentile": 0.33081}, "CVE-2016-1175": {"epss_score": 0.00061, "epss_percentile": 0.19475}, "CVE-2016-1176": {"epss_score": 0.01033, "epss_percentile": 0.76881}, "CVE-2016-1177": {"epss_score": 0.00297, "epss_percentile": 0.52772}, "CVE-2016-1178": {"epss_score": 0.00264, "epss_percentile": 0.49571}, "CVE-2016-1179": {"epss_score": 0.00278, "epss_percentile": 0.50866}, "CVE-2016-1180": {"epss_score": 0.00314, "epss_percentile": 0.5412}, "CVE-2016-1181": {"epss_score": 0.06133, "epss_percentile": 0.90504}, "CVE-2016-1182": {"epss_score": 0.01857, "epss_percentile": 0.82577}, "CVE-2016-1183": {"epss_score": 0.00159, "epss_percentile": 0.37417}, "CVE-2016-1184": {"epss_score": 0.0023, "epss_percentile": 0.45714}, "CVE-2016-1185": {"epss_score": 0.00241, "epss_percentile": 0.47243}, "CVE-2016-1186": {"epss_score": 0.00565, "epss_percentile": 0.67781}, "CVE-2016-1187": {"epss_score": 0.00379, "epss_percentile": 0.58879}, "CVE-2016-1188": {"epss_score": 0.00213, "epss_percentile": 0.43894}, "CVE-2016-1189": {"epss_score": 0.00214, "epss_percentile": 0.43973}, "CVE-2016-1190": {"epss_score": 0.00173, "epss_percentile": 0.3913}, "CVE-2016-1191": {"epss_score": 0.00596, "epss_percentile": 0.6871}, "CVE-2016-1192": {"epss_score": 0.00296, "epss_percentile": 0.5257}, "CVE-2016-1193": {"epss_score": 0.00364, "epss_percentile": 0.57956}, "CVE-2016-1194": {"epss_score": 0.00821, "epss_percentile": 0.73903}, "CVE-2016-1195": {"epss_score": 0.00274, "epss_percentile": 0.50541}, "CVE-2016-1196": {"epss_score": 0.00181, "epss_percentile": 0.40108}, "CVE-2016-1197": {"epss_score": 0.00322, "epss_percentile": 0.54754}, "CVE-2016-1198": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2016-1199": {"epss_score": 0.00226, "epss_percentile": 0.45315}, "CVE-2016-1200": {"epss_score": 0.0024, "epss_percentile": 0.472}, "CVE-2016-1201": {"epss_score": 0.0013, "epss_percentile": 0.33333}, "CVE-2016-1202": {"epss_score": 0.00057, "epss_percentile": 0.1818}, "CVE-2016-1203": {"epss_score": 0.0164, "epss_percentile": 0.81501}, "CVE-2016-1205": {"epss_score": 0.00309, "epss_percentile": 0.537}, "CVE-2016-1206": {"epss_score": 0.00139, "epss_percentile": 0.34617}, "CVE-2016-1207": {"epss_score": 0.00222, "epss_percentile": 0.4475}, "CVE-2016-1208": {"epss_score": 0.00364, "epss_percentile": 0.57956}, "CVE-2016-1209": {"epss_score": 0.77252, "epss_percentile": 0.98928}, "CVE-2016-1210": {"epss_score": 0.00256, "epss_percentile": 0.48791}, "CVE-2016-1211": {"epss_score": 0.00389, "epss_percentile": 0.59473}, "CVE-2016-1212": {"epss_score": 0.00196, "epss_percentile": 0.41742}, "CVE-2016-1213": {"epss_score": 0.0038, "epss_percentile": 0.58962}, "CVE-2016-1214": {"epss_score": 0.0035, "epss_percentile": 0.56951}, "CVE-2016-1215": {"epss_score": 0.00343, "epss_percentile": 0.56473}, "CVE-2016-1216": {"epss_score": 0.00343, "epss_percentile": 0.56473}, "CVE-2016-1217": {"epss_score": 0.00343, "epss_percentile": 0.56473}, "CVE-2016-1218": {"epss_score": 0.00979, "epss_percentile": 0.76259}, "CVE-2016-1219": {"epss_score": 0.03868, "epss_percentile": 0.87875}, "CVE-2016-1220": {"epss_score": 0.00197, "epss_percentile": 0.41899}, "CVE-2016-1221": {"epss_score": 0.00256, "epss_percentile": 0.48791}, "CVE-2016-1222": {"epss_score": 0.00314, "epss_percentile": 0.5412}, "CVE-2016-1223": {"epss_score": 0.01681, "epss_percentile": 0.8173}, "CVE-2016-1224": {"epss_score": 0.00483, "epss_percentile": 0.64569}, "CVE-2016-1225": {"epss_score": 0.00748, "epss_percentile": 0.7259}, "CVE-2016-1226": {"epss_score": 0.00371, "epss_percentile": 0.58367}, "CVE-2016-1227": {"epss_score": 0.01062, "epss_percentile": 0.77181}, "CVE-2016-1228": {"epss_score": 0.00103, "epss_percentile": 0.29085}, "CVE-2016-1229": {"epss_score": 0.00222, "epss_percentile": 0.4475}, "CVE-2016-1230": {"epss_score": 0.00357, "epss_percentile": 0.57406}, "CVE-2016-1231": {"epss_score": 0.00741, "epss_percentile": 0.72439}, "CVE-2016-1232": {"epss_score": 0.00708, "epss_percentile": 0.71682}, "CVE-2016-1233": {"epss_score": 0.0011, "epss_percentile": 0.30173}, "CVE-2016-1234": {"epss_score": 0.01181, "epss_percentile": 0.78311}, "CVE-2016-1235": {"epss_score": 0.00924, "epss_percentile": 0.75523}, "CVE-2016-1236": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2016-1237": {"epss_score": 0.00015, "epss_percentile": 0.02581}, "CVE-2016-1238": {"epss_score": 0.00274, "epss_percentile": 0.50572}, "CVE-2016-1239": {"epss_score": 0.00611, "epss_percentile": 0.6919}, "CVE-2016-1240": {"epss_score": 0.18611, "epss_percentile": 0.95043}, "CVE-2016-1241": {"epss_score": 0.00184, "epss_percentile": 0.40424}, "CVE-2016-1242": {"epss_score": 0.00162, "epss_percentile": 0.37733}, "CVE-2016-1243": {"epss_score": 0.27593, "epss_percentile": 0.96261}, "CVE-2016-1244": {"epss_score": 0.09936, "epss_percentile": 0.92781}, "CVE-2016-1245": {"epss_score": 0.0119, "epss_percentile": 0.78377}, "CVE-2016-1246": {"epss_score": 0.01281, "epss_percentile": 0.79146}, "CVE-2016-1247": {"epss_score": 0.08594, "epss_percentile": 0.92141}, "CVE-2016-1248": {"epss_score": 0.15939, "epss_percentile": 0.9454}, "CVE-2016-1249": {"epss_score": 0.00485, "epss_percentile": 0.64704}, "CVE-2016-1251": {"epss_score": 0.00508, "epss_percentile": 0.65711}, "CVE-2016-1252": {"epss_score": 0.05955, "epss_percentile": 0.90361}, "CVE-2016-1253": {"epss_score": 0.13545, "epss_percentile": 0.93992}, "CVE-2016-1254": {"epss_score": 0.03038, "epss_percentile": 0.86266}, "CVE-2016-1255": {"epss_score": 0.00034, "epss_percentile": 0.09686}, "CVE-2016-1256": {"epss_score": 0.00484, "epss_percentile": 0.64629}, "CVE-2016-1257": {"epss_score": 0.00608, "epss_percentile": 0.69062}, "CVE-2016-1258": {"epss_score": 0.00445, "epss_percentile": 0.62888}, "CVE-2016-1260": {"epss_score": 0.00484, "epss_percentile": 0.64629}, "CVE-2016-1261": {"epss_score": 0.0015, "epss_percentile": 0.36184}, "CVE-2016-1262": {"epss_score": 0.00608, "epss_percentile": 0.69062}, "CVE-2016-1263": {"epss_score": 0.00607, "epss_percentile": 0.69045}, "CVE-2016-1264": {"epss_score": 0.00807, "epss_percentile": 0.73675}, "CVE-2016-1265": {"epss_score": 0.00996, "epss_percentile": 0.76447}, "CVE-2016-1267": {"epss_score": 0.0004, "epss_percentile": 0.11907}, "CVE-2016-1268": {"epss_score": 0.00559, "epss_percentile": 0.67619}, "CVE-2016-1269": {"epss_score": 0.02888, "epss_percentile": 0.85913}, "CVE-2016-1270": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2016-1271": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2016-1273": {"epss_score": 0.0018, "epss_percentile": 0.39985}, "CVE-2016-1274": {"epss_score": 0.00607, "epss_percentile": 0.69045}, "CVE-2016-1275": {"epss_score": 0.0035, "epss_percentile": 0.56936}, "CVE-2016-1276": {"epss_score": 0.00987, "epss_percentile": 0.76344}, "CVE-2016-1277": {"epss_score": 0.0058, "epss_percentile": 0.68243}, "CVE-2016-1278": {"epss_score": 0.00047, "epss_percentile": 0.14708}, "CVE-2016-1279": {"epss_score": 0.01909, "epss_percentile": 0.8282}, "CVE-2016-1280": {"epss_score": 0.00091, "epss_percentile": 0.26399}, "CVE-2016-1281": {"epss_score": 0.00243, "epss_percentile": 0.47411}, "CVE-2016-1283": {"epss_score": 0.03762, "epss_percentile": 0.8769}, "CVE-2016-1284": {"epss_score": 0.09482, "epss_percentile": 0.92567}, "CVE-2016-1285": {"epss_score": 0.66463, "epss_percentile": 0.98463}, "CVE-2016-1286": {"epss_score": 0.60011, "epss_percentile": 0.98189}, "CVE-2016-1287": {"epss_score": 0.89776, "epss_percentile": 0.99541}, "CVE-2016-1288": {"epss_score": 0.00445, "epss_percentile": 0.62888}, "CVE-2016-1289": {"epss_score": 0.02663, "epss_percentile": 0.85371}, "CVE-2016-1290": {"epss_score": 0.00165, "epss_percentile": 0.38045}, "CVE-2016-1291": {"epss_score": 0.02322, "epss_percentile": 0.84373}, "CVE-2016-1293": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2016-1294": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2016-1295": {"epss_score": 0.00585, "epss_percentile": 0.68402}, "CVE-2016-1296": {"epss_score": 0.00369, "epss_percentile": 0.58248}, "CVE-2016-1297": {"epss_score": 0.00611, "epss_percentile": 0.69208}, "CVE-2016-1298": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2016-1299": {"epss_score": 0.00305, "epss_percentile": 0.53378}, "CVE-2016-1300": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1301": {"epss_score": 0.00275, "epss_percentile": 0.50688}, "CVE-2016-1302": {"epss_score": 0.00225, "epss_percentile": 0.45086}, "CVE-2016-1303": {"epss_score": 0.00354, "epss_percentile": 0.57223}, "CVE-2016-1304": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1305": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1306": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1307": {"epss_score": 0.00156, "epss_percentile": 0.36967}, "CVE-2016-1308": {"epss_score": 0.00183, "epss_percentile": 0.40282}, "CVE-2016-1309": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1310": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1311": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1312": {"epss_score": 0.00743, "epss_percentile": 0.72473}, "CVE-2016-1313": {"epss_score": 0.01486, "epss_percentile": 0.80602}, "CVE-2016-1314": {"epss_score": 0.00185, "epss_percentile": 0.40527}, "CVE-2016-1315": {"epss_score": 0.00358, "epss_percentile": 0.57512}, "CVE-2016-1316": {"epss_score": 0.0023, "epss_percentile": 0.45762}, "CVE-2016-1317": {"epss_score": 0.00172, "epss_percentile": 0.39038}, "CVE-2016-1318": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1319": {"epss_score": 0.00162, "epss_percentile": 0.37755}, "CVE-2016-1320": {"epss_score": 0.00189, "epss_percentile": 0.4094}, "CVE-2016-1321": {"epss_score": 0.00082, "epss_percentile": 0.24481}, "CVE-2016-1322": {"epss_score": 0.00383, "epss_percentile": 0.59118}, "CVE-2016-1323": {"epss_score": 0.00172, "epss_percentile": 0.39038}, "CVE-2016-1324": {"epss_score": 0.00484, "epss_percentile": 0.64629}, "CVE-2016-1325": {"epss_score": 0.00183, "epss_percentile": 0.40353}, "CVE-2016-1326": {"epss_score": 0.00315, "epss_percentile": 0.54207}, "CVE-2016-1327": {"epss_score": 0.03575, "epss_percentile": 0.87378}, "CVE-2016-1328": {"epss_score": 0.23202, "epss_percentile": 0.95749}, "CVE-2016-1329": {"epss_score": 0.02068, "epss_percentile": 0.83465}, "CVE-2016-1330": {"epss_score": 0.00259, "epss_percentile": 0.49071}, "CVE-2016-1331": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1333": {"epss_score": 0.00454, "epss_percentile": 0.63251}, "CVE-2016-1334": {"epss_score": 0.00235, "epss_percentile": 0.46213}, "CVE-2016-1335": {"epss_score": 0.02914, "epss_percentile": 0.85976}, "CVE-2016-1336": {"epss_score": 0.31813, "epss_percentile": 0.96651}, "CVE-2016-1337": {"epss_score": 0.0421, "epss_percentile": 0.88399}, "CVE-2016-1338": {"epss_score": 0.00647, "epss_percentile": 0.70205}, "CVE-2016-1339": {"epss_score": 0.00233, "epss_percentile": 0.46023}, "CVE-2016-1340": {"epss_score": 0.00086, "epss_percentile": 0.25346}, "CVE-2016-1341": {"epss_score": 0.00277, "epss_percentile": 0.50786}, "CVE-2016-1342": {"epss_score": 0.00495, "epss_percentile": 0.65133}, "CVE-2016-1343": {"epss_score": 0.00593, "epss_percentile": 0.68631}, "CVE-2016-1344": {"epss_score": 0.03031, "epss_percentile": 0.86248}, "CVE-2016-1345": {"epss_score": 0.00488, "epss_percentile": 0.64864}, "CVE-2016-1346": {"epss_score": 0.00759, "epss_percentile": 0.72795}, "CVE-2016-1347": {"epss_score": 0.04316, "epss_percentile": 0.88538}, "CVE-2016-1348": {"epss_score": 0.00523, "epss_percentile": 0.66298}, "CVE-2016-1349": {"epss_score": 0.00705, "epss_percentile": 0.71588}, "CVE-2016-1350": {"epss_score": 0.02439, "epss_percentile": 0.84751}, "CVE-2016-1351": {"epss_score": 0.01833, "epss_percentile": 0.82457}, "CVE-2016-1352": {"epss_score": 0.00389, "epss_percentile": 0.59487}, "CVE-2016-1353": {"epss_score": 0.00484, "epss_percentile": 0.64629}, "CVE-2016-1354": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1355": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1356": {"epss_score": 0.00236, "epss_percentile": 0.46447}, "CVE-2016-1357": {"epss_score": 0.00169, "epss_percentile": 0.38619}, "CVE-2016-1358": {"epss_score": 0.00486, "epss_percentile": 0.64743}, "CVE-2016-1359": {"epss_score": 0.00508, "epss_percentile": 0.65684}, "CVE-2016-1360": {"epss_score": 0.0006, "epss_percentile": 0.18969}, "CVE-2016-1361": {"epss_score": 0.00101, "epss_percentile": 0.28589}, "CVE-2016-1362": {"epss_score": 0.00208, "epss_percentile": 0.43285}, "CVE-2016-1363": {"epss_score": 0.11609, "epss_percentile": 0.93419}, "CVE-2016-1364": {"epss_score": 0.00527, "epss_percentile": 0.66472}, "CVE-2016-1365": {"epss_score": 0.00985, "epss_percentile": 0.76324}, "CVE-2016-1366": {"epss_score": 0.00156, "epss_percentile": 0.36965}, "CVE-2016-1367": {"epss_score": 0.00391, "epss_percentile": 0.59565}, "CVE-2016-1368": {"epss_score": 0.00217, "epss_percentile": 0.44245}, "CVE-2016-1369": {"epss_score": 0.00527, "epss_percentile": 0.66472}, "CVE-2016-1370": {"epss_score": 0.00465, "epss_percentile": 0.63774}, "CVE-2016-1371": {"epss_score": 0.00686, "epss_percentile": 0.71157}, "CVE-2016-1372": {"epss_score": 0.00572, "epss_percentile": 0.68009}, "CVE-2016-1373": {"epss_score": 0.00235, "epss_percentile": 0.46213}, "CVE-2016-1374": {"epss_score": 0.0084, "epss_percentile": 0.7421}, "CVE-2016-1375": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1376": {"epss_score": 0.00484, "epss_percentile": 0.64629}, "CVE-2016-1377": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1378": {"epss_score": 0.0023, "epss_percentile": 0.45762}, "CVE-2016-1379": {"epss_score": 0.01023, "epss_percentile": 0.76772}, "CVE-2016-1380": {"epss_score": 0.00561, "epss_percentile": 0.6768}, "CVE-2016-1381": {"epss_score": 0.01094, "epss_percentile": 0.77497}, "CVE-2016-1382": {"epss_score": 0.00486, "epss_percentile": 0.64744}, "CVE-2016-1383": {"epss_score": 0.01094, "epss_percentile": 0.77497}, "CVE-2016-1384": {"epss_score": 0.00161, "epss_percentile": 0.37547}, "CVE-2016-1385": {"epss_score": 0.00454, "epss_percentile": 0.63251}, "CVE-2016-1386": {"epss_score": 0.00235, "epss_percentile": 0.46213}, "CVE-2016-1387": {"epss_score": 0.01438, "epss_percentile": 0.80285}, "CVE-2016-1388": {"epss_score": 0.00389, "epss_percentile": 0.59487}, "CVE-2016-1389": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2016-1390": {"epss_score": 0.00314, "epss_percentile": 0.54141}, "CVE-2016-1391": {"epss_score": 0.00587, "epss_percentile": 0.68461}, "CVE-2016-1392": {"epss_score": 0.00224, "epss_percentile": 0.44994}, "CVE-2016-1393": {"epss_score": 0.0014, "epss_percentile": 0.34783}, "CVE-2016-1394": {"epss_score": 0.00687, "epss_percentile": 0.71183}, "CVE-2016-1395": {"epss_score": 0.01207, "epss_percentile": 0.78525}, "CVE-2016-1396": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1397": {"epss_score": 0.00511, "epss_percentile": 0.65847}, "CVE-2016-1398": {"epss_score": 0.00129, "epss_percentile": 0.33209}, "CVE-2016-1399": {"epss_score": 0.01119, "epss_percentile": 0.77753}, "CVE-2016-1400": {"epss_score": 0.00721, "epss_percentile": 0.7197}, "CVE-2016-1401": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1402": {"epss_score": 0.01094, "epss_percentile": 0.77493}, "CVE-2016-1403": {"epss_score": 0.00258, "epss_percentile": 0.48983}, "CVE-2016-1404": {"epss_score": 0.0016, "epss_percentile": 0.3746}, "CVE-2016-1405": {"epss_score": 0.01591, "epss_percentile": 0.81221}, "CVE-2016-1406": {"epss_score": 0.00301, "epss_percentile": 0.53005}, "CVE-2016-1407": {"epss_score": 0.00895, "epss_percentile": 0.75109}, "CVE-2016-1408": {"epss_score": 0.00351, "epss_percentile": 0.57007}, "CVE-2016-1409": {"epss_score": 0.04876, "epss_percentile": 0.89241}, "CVE-2016-1410": {"epss_score": 0.00291, "epss_percentile": 0.52151}, "CVE-2016-1411": {"epss_score": 0.00224, "epss_percentile": 0.45043}, "CVE-2016-1413": {"epss_score": 0.00292, "epss_percentile": 0.52267}, "CVE-2016-1415": {"epss_score": 0.04094, "epss_percentile": 0.88245}, "CVE-2016-1416": {"epss_score": 0.05094, "epss_percentile": 0.89489}, "CVE-2016-1417": {"epss_score": 0.04259, "epss_percentile": 0.88462}, "CVE-2016-1418": {"epss_score": 0.00314, "epss_percentile": 0.54141}, "CVE-2016-1419": {"epss_score": 0.00575, "epss_percentile": 0.68106}, "CVE-2016-1420": {"epss_score": 0.00231, "epss_percentile": 0.45839}, "CVE-2016-1421": {"epss_score": 0.04701, "epss_percentile": 0.89026}, "CVE-2016-1423": {"epss_score": 0.00545, "epss_percentile": 0.67177}, "CVE-2016-1424": {"epss_score": 0.0024, "epss_percentile": 0.46944}, "CVE-2016-1425": {"epss_score": 0.00904, "epss_percentile": 0.7523}, "CVE-2016-1426": {"epss_score": 0.00743, "epss_percentile": 0.72473}, "CVE-2016-1427": {"epss_score": 0.00305, "epss_percentile": 0.53362}, "CVE-2016-1428": {"epss_score": 0.00454, "epss_percentile": 0.63251}, "CVE-2016-1429": {"epss_score": 0.00481, "epss_percentile": 0.64495}, "CVE-2016-1430": {"epss_score": 0.00432, "epss_percentile": 0.62119}, "CVE-2016-1431": {"epss_score": 0.00383, "epss_percentile": 0.591}, "CVE-2016-1432": {"epss_score": 0.00454, "epss_percentile": 0.63251}, "CVE-2016-1433": {"epss_score": 0.00546, "epss_percentile": 0.67208}, "CVE-2016-1434": {"epss_score": 0.00164, "epss_percentile": 0.37882}, "CVE-2016-1435": {"epss_score": 0.00175, "epss_percentile": 0.39287}, "CVE-2016-1436": {"epss_score": 0.00721, "epss_percentile": 0.7197}, "CVE-2016-1437": {"epss_score": 0.00219, "epss_percentile": 0.44479}, "CVE-2016-1438": {"epss_score": 0.00383, "epss_percentile": 0.59118}, "CVE-2016-1439": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1440": {"epss_score": 0.00445, "epss_percentile": 0.62888}, "CVE-2016-1441": {"epss_score": 0.00212, "epss_percentile": 0.43778}, "CVE-2016-1442": {"epss_score": 0.00696, "epss_percentile": 0.71387}, "CVE-2016-1443": {"epss_score": 0.00358, "epss_percentile": 0.57492}, "CVE-2016-1444": {"epss_score": 0.00103, "epss_percentile": 0.29014}, "CVE-2016-1445": {"epss_score": 0.00307, "epss_percentile": 0.53483}, "CVE-2016-1446": {"epss_score": 0.00668, "epss_percentile": 0.70742}, "CVE-2016-1447": {"epss_score": 0.00296, "epss_percentile": 0.52621}, "CVE-2016-1448": {"epss_score": 0.00136, "epss_percentile": 0.3415}, "CVE-2016-1449": {"epss_score": 0.00296, "epss_percentile": 0.52621}, "CVE-2016-1450": {"epss_score": 0.00708, "epss_percentile": 0.71675}, "CVE-2016-1451": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1452": {"epss_score": 0.00265, "epss_percentile": 0.49791}, "CVE-2016-1453": {"epss_score": 0.26083, "epss_percentile": 0.96109}, "CVE-2016-1454": {"epss_score": 0.01403, "epss_percentile": 0.80031}, "CVE-2016-1455": {"epss_score": 0.00679, "epss_percentile": 0.71005}, "CVE-2016-1456": {"epss_score": 0.00083, "epss_percentile": 0.24746}, "CVE-2016-1457": {"epss_score": 0.00374, "epss_percentile": 0.58566}, "CVE-2016-1458": {"epss_score": 0.00287, "epss_percentile": 0.51812}, "CVE-2016-1459": {"epss_score": 0.0064, "epss_percentile": 0.6996}, "CVE-2016-1460": {"epss_score": 0.00323, "epss_percentile": 0.5492}, "CVE-2016-1461": {"epss_score": 0.00771, "epss_percentile": 0.73029}, "CVE-2016-1462": {"epss_score": 0.00453, "epss_percentile": 0.6324}, "CVE-2016-1463": {"epss_score": 0.00433, "epss_percentile": 0.62188}, "CVE-2016-1464": {"epss_score": 0.04485, "epss_percentile": 0.88747}, "CVE-2016-1465": {"epss_score": 0.00904, "epss_percentile": 0.7523}, "CVE-2016-1466": {"epss_score": 0.00743, "epss_percentile": 0.72473}, "CVE-2016-1467": {"epss_score": 0.00225, "epss_percentile": 0.45129}, "CVE-2016-1468": {"epss_score": 0.01496, "epss_percentile": 0.80682}, "CVE-2016-1469": {"epss_score": 0.01609, "epss_percentile": 0.81318}, "CVE-2016-1470": {"epss_score": 0.00137, "epss_percentile": 0.34252}, "CVE-2016-1471": {"epss_score": 0.00266, "epss_percentile": 0.49871}, "CVE-2016-1472": {"epss_score": 0.01159, "epss_percentile": 0.78129}, "CVE-2016-1473": {"epss_score": 0.02552, "epss_percentile": 0.85078}, "CVE-2016-1474": {"epss_score": 0.00238, "epss_percentile": 0.46766}, "CVE-2016-1476": {"epss_score": 0.00189, "epss_percentile": 0.40962}, "CVE-2016-1477": {"epss_score": 0.00224, "epss_percentile": 0.45067}, "CVE-2016-1478": {"epss_score": 0.01524, "epss_percentile": 0.80849}, "CVE-2016-1479": {"epss_score": 0.00677, "epss_percentile": 0.7095}, "CVE-2016-1480": {"epss_score": 0.00329, "epss_percentile": 0.55411}, "CVE-2016-1481": {"epss_score": 0.0076, "epss_percentile": 0.72811}, "CVE-2016-1482": {"epss_score": 0.014, "epss_percentile": 0.80002}, "CVE-2016-1483": {"epss_score": 0.00514, "epss_percentile": 0.6594}, "CVE-2016-1484": {"epss_score": 0.00247, "epss_percentile": 0.47817}, "CVE-2016-1485": {"epss_score": 0.00296, "epss_percentile": 0.52621}, "CVE-2016-1486": {"epss_score": 0.0076, "epss_percentile": 0.72811}, "CVE-2016-1487": {"epss_score": 0.00856, "epss_percentile": 0.74482}, "CVE-2016-1488": {"epss_score": 0.00214, "epss_percentile": 0.43996}, "CVE-2016-1489": {"epss_score": 0.00571, "epss_percentile": 0.67984}, "CVE-2016-1490": {"epss_score": 0.0023, "epss_percentile": 0.45722}, "CVE-2016-1491": {"epss_score": 0.01576, "epss_percentile": 0.81112}, "CVE-2016-1492": {"epss_score": 0.00642, "epss_percentile": 0.70044}, "CVE-2016-1493": {"epss_score": 0.00216, "epss_percentile": 0.44233}, "CVE-2016-1494": {"epss_score": 0.05091, "epss_percentile": 0.89483}, "CVE-2016-1495": {"epss_score": 0.00064, "epss_percentile": 0.20281}, "CVE-2016-1496": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2016-1497": {"epss_score": 0.00234, "epss_percentile": 0.46152}, "CVE-2016-1498": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1499": {"epss_score": 0.00591, "epss_percentile": 0.68601}, "CVE-2016-1500": {"epss_score": 0.00293, "epss_percentile": 0.52353}, "CVE-2016-1501": {"epss_score": 0.00193, "epss_percentile": 0.41402}, "CVE-2016-1502": {"epss_score": 0.00129, "epss_percentile": 0.33164}, "CVE-2016-1503": {"epss_score": 0.09383, "epss_percentile": 0.92525}, "CVE-2016-1504": {"epss_score": 0.01871, "epss_percentile": 0.82634}, "CVE-2016-1505": {"epss_score": 0.01377, "epss_percentile": 0.79841}, "CVE-2016-1513": {"epss_score": 0.01117, "epss_percentile": 0.77741}, "CVE-2016-1516": {"epss_score": 0.00582, "epss_percentile": 0.68312}, "CVE-2016-1517": {"epss_score": 0.00425, "epss_percentile": 0.61707}, "CVE-2016-1518": {"epss_score": 0.00849, "epss_percentile": 0.74378}, "CVE-2016-1519": {"epss_score": 0.00233, "epss_percentile": 0.46051}, "CVE-2016-1520": {"epss_score": 0.00252, "epss_percentile": 0.48401}, "CVE-2016-1521": {"epss_score": 0.00846, "epss_percentile": 0.74329}, "CVE-2016-1522": {"epss_score": 0.02415, "epss_percentile": 0.84685}, "CVE-2016-1523": {"epss_score": 0.01341, "epss_percentile": 0.7959}, "CVE-2016-1524": {"epss_score": 0.67599, "epss_percentile": 0.98514}, "CVE-2016-1525": {"epss_score": 0.83584, "epss_percentile": 0.99253}, "CVE-2016-1526": {"epss_score": 0.00759, "epss_percentile": 0.72789}, "CVE-2016-1531": {"epss_score": 0.52948, "epss_percentile": 0.97847}, "CVE-2016-1541": {"epss_score": 0.09266, "epss_percentile": 0.92471}, "CVE-2016-1542": {"epss_score": 0.71272, "epss_percentile": 0.98661}, "CVE-2016-1543": {"epss_score": 0.73034, "epss_percentile": 0.98733}, "CVE-2016-1544": {"epss_score": 0.01589, "epss_percentile": 0.81194}, "CVE-2016-1546": {"epss_score": 0.36839, "epss_percentile": 0.97004}, "CVE-2016-1547": {"epss_score": 0.02139, "epss_percentile": 0.83744}, "CVE-2016-1548": {"epss_score": 0.02762, "epss_percentile": 0.85606}, "CVE-2016-1549": {"epss_score": 0.00742, "epss_percentile": 0.72462}, "CVE-2016-1550": {"epss_score": 0.03248, "epss_percentile": 0.86746}, "CVE-2016-1551": {"epss_score": 0.00976, "epss_percentile": 0.76207}, "CVE-2016-1555": {"epss_score": 0.93967, "epss_percentile": 0.99876}, "CVE-2016-1556": {"epss_score": 0.00955, "epss_percentile": 0.75917}, "CVE-2016-1557": {"epss_score": 0.01182, "epss_percentile": 0.78317}, "CVE-2016-1558": {"epss_score": 0.14872, "epss_percentile": 0.94305}, "CVE-2016-1559": {"epss_score": 0.01102, "epss_percentile": 0.77578}, "CVE-2016-1560": {"epss_score": 0.81672, "epss_percentile": 0.9915}, "CVE-2016-1561": {"epss_score": 0.84403, "epss_percentile": 0.99288}, "CVE-2016-1562": {"epss_score": 0.00336, "epss_percentile": 0.55998}, "CVE-2016-1563": {"epss_score": 0.0013, "epss_percentile": 0.33249}, "CVE-2016-1564": {"epss_score": 0.00673, "epss_percentile": 0.70832}, "CVE-2016-1565": {"epss_score": 0.00185, "epss_percentile": 0.40527}, "CVE-2016-1566": {"epss_score": 0.00219, "epss_percentile": 0.4452}, "CVE-2016-1567": {"epss_score": 0.00714, "epss_percentile": 0.71821}, "CVE-2016-1568": {"epss_score": 0.0033, "epss_percentile": 0.55425}, "CVE-2016-1569": {"epss_score": 0.00758, "epss_percentile": 0.72772}, "CVE-2016-1570": {"epss_score": 0.00204, "epss_percentile": 0.42625}, "CVE-2016-1571": {"epss_score": 0.00297, "epss_percentile": 0.52685}, "CVE-2016-1572": {"epss_score": 0.00045, "epss_percentile": 0.13934}, "CVE-2016-1573": {"epss_score": 0.00086, "epss_percentile": 0.25441}, "CVE-2016-1575": {"epss_score": 0.00525, "epss_percentile": 0.66388}, "CVE-2016-1576": {"epss_score": 0.00352, "epss_percentile": 0.57084}, "CVE-2016-1577": {"epss_score": 0.07729, "epss_percentile": 0.91648}, "CVE-2016-1578": {"epss_score": 0.0221, "epss_percentile": 0.84013}, "CVE-2016-1579": {"epss_score": 0.00196, "epss_percentile": 0.41763}, "CVE-2016-1580": {"epss_score": 0.01652, "epss_percentile": 0.81575}, "CVE-2016-1581": {"epss_score": 0.00035, "epss_percentile": 0.09818}, "CVE-2016-1582": {"epss_score": 0.0004, "epss_percentile": 0.12104}, "CVE-2016-1583": {"epss_score": 0.00338, "epss_percentile": 0.56129}, "CVE-2016-1584": {"epss_score": 0.00241, "epss_percentile": 0.47275}, "CVE-2016-1585": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2016-1586": {"epss_score": 0.00178, "epss_percentile": 0.39658}, "CVE-2016-1587": {"epss_score": 0.00282, "epss_percentile": 0.51273}, "CVE-2016-1592": {"epss_score": 0.00233, "epss_percentile": 0.46044}, "CVE-2016-1593": {"epss_score": 0.85112, "epss_percentile": 0.99319}, "CVE-2016-1594": {"epss_score": 0.04705, "epss_percentile": 0.8903}, "CVE-2016-1595": {"epss_score": 0.03525, "epss_percentile": 0.87292}, "CVE-2016-1596": {"epss_score": 0.00246, "epss_percentile": 0.47767}, "CVE-2016-1597": {"epss_score": 0.00357, "epss_percentile": 0.57476}, "CVE-2016-1598": {"epss_score": 0.00274, "epss_percentile": 0.50528}, "CVE-2016-1599": {"epss_score": 0.00254, "epss_percentile": 0.48572}, "CVE-2016-1600": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2016-1601": {"epss_score": 0.00454, "epss_percentile": 0.63266}, "CVE-2016-1602": {"epss_score": 0.00113, "epss_percentile": 0.30646}, "CVE-2016-1603": {"epss_score": 0.00599, "epss_percentile": 0.68798}, "CVE-2016-1605": {"epss_score": 0.00785, "epss_percentile": 0.73255}, "CVE-2016-1606": {"epss_score": 0.41905, "epss_percentile": 0.97301}, "CVE-2016-1607": {"epss_score": 0.00966, "epss_percentile": 0.76052}, "CVE-2016-1608": {"epss_score": 0.10806, "epss_percentile": 0.93109}, "CVE-2016-1609": {"epss_score": 0.01356, "epss_percentile": 0.79713}, "CVE-2016-1610": {"epss_score": 0.20779, "epss_percentile": 0.95411}, "CVE-2016-1611": {"epss_score": 0.00228, "epss_percentile": 0.45516}, "CVE-2016-1612": {"epss_score": 0.01029, "epss_percentile": 0.76832}, "CVE-2016-1613": {"epss_score": 0.0087, "epss_percentile": 0.74706}, "CVE-2016-1614": {"epss_score": 0.00794, "epss_percentile": 0.73453}, "CVE-2016-1615": {"epss_score": 0.00755, "epss_percentile": 0.72711}, "CVE-2016-1616": {"epss_score": 0.0118, "epss_percentile": 0.783}, "CVE-2016-1617": {"epss_score": 0.00635, "epss_percentile": 0.69821}, "CVE-2016-1618": {"epss_score": 0.00913, "epss_percentile": 0.75375}, "CVE-2016-1619": {"epss_score": 0.00799, "epss_percentile": 0.73527}, "CVE-2016-1620": {"epss_score": 0.01427, "epss_percentile": 0.80213}, "CVE-2016-1621": {"epss_score": 0.08743, "epss_percentile": 0.92237}, "CVE-2016-1622": {"epss_score": 0.01496, "epss_percentile": 0.80684}, "CVE-2016-1623": {"epss_score": 0.0153, "epss_percentile": 0.80883}, "CVE-2016-1624": {"epss_score": 0.01418, "epss_percentile": 0.80159}, "CVE-2016-1625": {"epss_score": 0.00638, "epss_percentile": 0.6991}, "CVE-2016-1626": {"epss_score": 0.00638, "epss_percentile": 0.69905}, "CVE-2016-1627": {"epss_score": 0.01244, "epss_percentile": 0.78837}, "CVE-2016-1628": {"epss_score": 0.00908, "epss_percentile": 0.75286}, "CVE-2016-1629": {"epss_score": 0.03208, "epss_percentile": 0.8664}, "CVE-2016-1630": {"epss_score": 0.0097, "epss_percentile": 0.76117}, "CVE-2016-1631": {"epss_score": 0.0097, "epss_percentile": 0.76117}, "CVE-2016-1632": {"epss_score": 0.01206, "epss_percentile": 0.78523}, "CVE-2016-1633": {"epss_score": 0.05573, "epss_percentile": 0.90009}, "CVE-2016-1634": {"epss_score": 0.01954, "epss_percentile": 0.83028}, "CVE-2016-1635": {"epss_score": 0.05573, "epss_percentile": 0.90009}, "CVE-2016-1636": {"epss_score": 0.01448, "epss_percentile": 0.80334}, "CVE-2016-1637": {"epss_score": 0.01052, "epss_percentile": 0.77089}, "CVE-2016-1638": {"epss_score": 0.00765, "epss_percentile": 0.72923}, "CVE-2016-1639": {"epss_score": 0.05701, "epss_percentile": 0.90132}, "CVE-2016-1640": {"epss_score": 0.00764, "epss_percentile": 0.72895}, "CVE-2016-1641": {"epss_score": 0.01738, "epss_percentile": 0.82026}, "CVE-2016-1642": {"epss_score": 0.01856, "epss_percentile": 0.82573}, "CVE-2016-1643": {"epss_score": 0.02015, "epss_percentile": 0.83272}, "CVE-2016-1644": {"epss_score": 0.01831, "epss_percentile": 0.8245}, "CVE-2016-1645": {"epss_score": 0.02189, "epss_percentile": 0.83931}, "CVE-2016-1646": {"epss_score": 0.65121, "epss_percentile": 0.98404}, "CVE-2016-1647": {"epss_score": 0.01286, "epss_percentile": 0.79189}, "CVE-2016-1648": {"epss_score": 0.01948, "epss_percentile": 0.8301}, "CVE-2016-1649": {"epss_score": 0.02814, "epss_percentile": 0.85727}, "CVE-2016-1650": {"epss_score": 0.01179, "epss_percentile": 0.78291}, "CVE-2016-1651": {"epss_score": 0.01385, "epss_percentile": 0.79908}, "CVE-2016-1652": {"epss_score": 0.00411, "epss_percentile": 0.6085}, "CVE-2016-1653": {"epss_score": 0.01518, "epss_percentile": 0.80814}, "CVE-2016-1654": {"epss_score": 0.0249, "epss_percentile": 0.84896}, "CVE-2016-1655": {"epss_score": 0.03027, "epss_percentile": 0.86242}, "CVE-2016-1656": {"epss_score": 0.00404, "epss_percentile": 0.60451}, "CVE-2016-1657": {"epss_score": 0.02176, "epss_percentile": 0.83886}, "CVE-2016-1658": {"epss_score": 0.00882, "epss_percentile": 0.74889}, "CVE-2016-1659": {"epss_score": 0.02455, "epss_percentile": 0.84795}, "CVE-2016-1660": {"epss_score": 0.01238, "epss_percentile": 0.78791}, "CVE-2016-1661": {"epss_score": 0.00995, "epss_percentile": 0.76435}, "CVE-2016-1662": {"epss_score": 0.15771, "epss_percentile": 0.94507}, "CVE-2016-1663": {"epss_score": 0.01417, "epss_percentile": 0.80148}, "CVE-2016-1664": {"epss_score": 0.01056, "epss_percentile": 0.77125}, "CVE-2016-1665": {"epss_score": 0.01603, "epss_percentile": 0.81277}, "CVE-2016-1666": {"epss_score": 0.00777, "epss_percentile": 0.73109}, "CVE-2016-1667": {"epss_score": 0.00617, "epss_percentile": 0.69359}, "CVE-2016-1668": {"epss_score": 0.01195, "epss_percentile": 0.78434}, "CVE-2016-1669": {"epss_score": 0.01888, "epss_percentile": 0.82721}, "CVE-2016-1670": {"epss_score": 0.00682, "epss_percentile": 0.71065}, "CVE-2016-1671": {"epss_score": 0.002, "epss_percentile": 0.42263}, "CVE-2016-1672": {"epss_score": 0.01357, "epss_percentile": 0.79726}, "CVE-2016-1673": {"epss_score": 0.01034, "epss_percentile": 0.76884}, "CVE-2016-1674": {"epss_score": 0.01011, "epss_percentile": 0.76613}, "CVE-2016-1675": {"epss_score": 0.01024, "epss_percentile": 0.76782}, "CVE-2016-1676": {"epss_score": 0.01357, "epss_percentile": 0.79726}, "CVE-2016-1677": {"epss_score": 0.09832, "epss_percentile": 0.92724}, "CVE-2016-1678": {"epss_score": 0.01307, "epss_percentile": 0.79337}, "CVE-2016-1679": {"epss_score": 0.01532, "epss_percentile": 0.80896}, "CVE-2016-1680": {"epss_score": 0.01532, "epss_percentile": 0.80896}, "CVE-2016-1681": {"epss_score": 0.0128, "epss_percentile": 0.79136}, "CVE-2016-1682": {"epss_score": 0.00633, "epss_percentile": 0.69766}, "CVE-2016-1683": {"epss_score": 0.00456, "epss_percentile": 0.63351}, "CVE-2016-1684": {"epss_score": 0.00472, "epss_percentile": 0.64069}, "CVE-2016-1685": {"epss_score": 0.01451, "epss_percentile": 0.80365}, "CVE-2016-1686": {"epss_score": 0.01451, "epss_percentile": 0.80365}, "CVE-2016-1687": {"epss_score": 0.02058, "epss_percentile": 0.83431}, "CVE-2016-1688": {"epss_score": 0.04867, "epss_percentile": 0.8923}, "CVE-2016-1689": {"epss_score": 0.01734, "epss_percentile": 0.82004}, "CVE-2016-1690": {"epss_score": 0.01479, "epss_percentile": 0.80558}, "CVE-2016-1691": {"epss_score": 0.01396, "epss_percentile": 0.79978}, "CVE-2016-1692": {"epss_score": 0.00748, "epss_percentile": 0.72578}, "CVE-2016-1693": {"epss_score": 0.00895, "epss_percentile": 0.75103}, "CVE-2016-1694": {"epss_score": 0.00713, "epss_percentile": 0.71799}, "CVE-2016-1695": {"epss_score": 0.01191, "epss_percentile": 0.78398}, "CVE-2016-1696": {"epss_score": 0.00981, "epss_percentile": 0.76283}, "CVE-2016-1697": {"epss_score": 0.01354, "epss_percentile": 0.79702}, "CVE-2016-1698": {"epss_score": 0.00822, "epss_percentile": 0.73918}, "CVE-2016-1699": {"epss_score": 0.00575, "epss_percentile": 0.68116}, "CVE-2016-1700": {"epss_score": 0.01724, "epss_percentile": 0.81948}, "CVE-2016-1701": {"epss_score": 0.01354, "epss_percentile": 0.79704}, "CVE-2016-1702": {"epss_score": 0.0142, "epss_percentile": 0.80166}, "CVE-2016-1703": {"epss_score": 0.00999, "epss_percentile": 0.76478}, "CVE-2016-1704": {"epss_score": 0.00791, "epss_percentile": 0.73396}, "CVE-2016-1705": {"epss_score": 0.00613, "epss_percentile": 0.6924}, "CVE-2016-1706": {"epss_score": 0.01637, "epss_percentile": 0.81483}, "CVE-2016-1707": {"epss_score": 0.00696, "epss_percentile": 0.71393}, "CVE-2016-1708": {"epss_score": 0.01522, "epss_percentile": 0.80837}, "CVE-2016-1709": {"epss_score": 0.01146, "epss_percentile": 0.78001}, "CVE-2016-1710": {"epss_score": 0.01051, "epss_percentile": 0.7708}, "CVE-2016-1711": {"epss_score": 0.01459, "epss_percentile": 0.80413}, "CVE-2016-1712": {"epss_score": 0.00046, "epss_percentile": 0.14436}, "CVE-2016-1713": {"epss_score": 0.61943, "epss_percentile": 0.98268}, "CVE-2016-1714": {"epss_score": 0.00343, "epss_percentile": 0.56426}, "CVE-2016-1715": {"epss_score": 0.00381, "epss_percentile": 0.59022}, "CVE-2016-1716": {"epss_score": 0.00047, "epss_percentile": 0.1465}, "CVE-2016-1717": {"epss_score": 0.00083, "epss_percentile": 0.24597}, "CVE-2016-1718": {"epss_score": 0.00044, "epss_percentile": 0.13625}, "CVE-2016-1719": {"epss_score": 0.00296, "epss_percentile": 0.52603}, "CVE-2016-1720": {"epss_score": 0.00242, "epss_percentile": 0.47364}, "CVE-2016-1721": {"epss_score": 0.00242, "epss_percentile": 0.47364}, "CVE-2016-1722": {"epss_score": 0.00083, "epss_percentile": 0.24597}, "CVE-2016-1723": {"epss_score": 0.01695, "epss_percentile": 0.81806}, "CVE-2016-1724": {"epss_score": 0.01014, "epss_percentile": 0.7664}, "CVE-2016-1725": {"epss_score": 0.01695, "epss_percentile": 0.81806}, "CVE-2016-1726": {"epss_score": 0.01695, "epss_percentile": 0.81806}, "CVE-2016-1727": {"epss_score": 0.00895, "epss_percentile": 0.75107}, "CVE-2016-1728": {"epss_score": 0.00757, "epss_percentile": 0.72755}, "CVE-2016-1729": {"epss_score": 0.00486, "epss_percentile": 0.64743}, "CVE-2016-1730": {"epss_score": 0.00274, "epss_percentile": 0.50534}, "CVE-2016-1731": {"epss_score": 0.00161, "epss_percentile": 0.37539}, "CVE-2016-1732": {"epss_score": 0.00054, "epss_percentile": 0.17147}, "CVE-2016-1733": {"epss_score": 0.00227, "epss_percentile": 0.45429}, "CVE-2016-1734": {"epss_score": 0.00109, "epss_percentile": 0.30037}, "CVE-2016-1735": {"epss_score": 0.00241, "epss_percentile": 0.47273}, "CVE-2016-1736": {"epss_score": 0.00241, "epss_percentile": 0.47273}, "CVE-2016-1737": {"epss_score": 0.00741, "epss_percentile": 0.72443}, "CVE-2016-1738": {"epss_score": 0.00048, "epss_percentile": 0.15025}, "CVE-2016-1740": {"epss_score": 0.01785, "epss_percentile": 0.82254}, "CVE-2016-1741": {"epss_score": 0.17312, "epss_percentile": 0.9482}, "CVE-2016-1742": {"epss_score": 0.00153, "epss_percentile": 0.36576}, "CVE-2016-1743": {"epss_score": 0.03682, "epss_percentile": 0.87562}, "CVE-2016-1744": {"epss_score": 0.02524, "epss_percentile": 0.85011}, "CVE-2016-1745": {"epss_score": 0.00048, "epss_percentile": 0.15222}, "CVE-2016-1746": {"epss_score": 0.00228, "epss_percentile": 0.45497}, "CVE-2016-1747": {"epss_score": 0.00228, "epss_percentile": 0.45497}, "CVE-2016-1748": {"epss_score": 0.00257, "epss_percentile": 0.48881}, "CVE-2016-1749": {"epss_score": 0.02566, "epss_percentile": 0.85117}, "CVE-2016-1750": {"epss_score": 0.00502, "epss_percentile": 0.65403}, "CVE-2016-1751": {"epss_score": 0.00233, "epss_percentile": 0.46029}, "CVE-2016-1752": {"epss_score": 0.00246, "epss_percentile": 0.47799}, "CVE-2016-1753": {"epss_score": 0.00481, "epss_percentile": 0.64508}, "CVE-2016-1754": {"epss_score": 0.00637, "epss_percentile": 0.6988}, "CVE-2016-1755": {"epss_score": 0.04521, "epss_percentile": 0.888}, "CVE-2016-1756": {"epss_score": 0.0019, "epss_percentile": 0.41076}, "CVE-2016-1757": {"epss_score": 0.58452, "epss_percentile": 0.98118}, "CVE-2016-1758": {"epss_score": 0.00276, "epss_percentile": 0.50755}, "CVE-2016-1759": {"epss_score": 0.00241, "epss_percentile": 0.47273}, "CVE-2016-1760": {"epss_score": 0.00056, "epss_percentile": 0.17796}, "CVE-2016-1761": {"epss_score": 0.13953, "epss_percentile": 0.941}, "CVE-2016-1762": {"epss_score": 0.08579, "epss_percentile": 0.92132}, "CVE-2016-1763": {"epss_score": 0.00211, "epss_percentile": 0.43706}, "CVE-2016-1764": {"epss_score": 0.06683, "epss_percentile": 0.90939}, "CVE-2016-1765": {"epss_score": 0.00061, "epss_percentile": 0.19344}, "CVE-2016-1766": {"epss_score": 0.00148, "epss_percentile": 0.35901}, "CVE-2016-1767": {"epss_score": 0.04565, "epss_percentile": 0.88857}, "CVE-2016-1768": {"epss_score": 0.08571, "epss_percentile": 0.9213}, "CVE-2016-1769": {"epss_score": 0.04565, "epss_percentile": 0.88857}, "CVE-2016-1770": {"epss_score": 0.00233, "epss_percentile": 0.46042}, "CVE-2016-1771": {"epss_score": 0.0048, "epss_percentile": 0.64449}, "CVE-2016-1772": {"epss_score": 0.003, "epss_percentile": 0.52959}, "CVE-2016-1773": {"epss_score": 0.00054, "epss_percentile": 0.17342}, "CVE-2016-1774": {"epss_score": 0.00316, "epss_percentile": 0.54218}, "CVE-2016-1775": {"epss_score": 0.00976, "epss_percentile": 0.76213}, "CVE-2016-1776": {"epss_score": 0.00283, "epss_percentile": 0.51391}, "CVE-2016-1777": {"epss_score": 0.00401, "epss_percentile": 0.60204}, "CVE-2016-1778": {"epss_score": 0.01212, "epss_percentile": 0.78561}, "CVE-2016-1779": {"epss_score": 0.07674, "epss_percentile": 0.91619}, "CVE-2016-1780": {"epss_score": 0.00266, "epss_percentile": 0.49887}, "CVE-2016-1781": {"epss_score": 0.00464, "epss_percentile": 0.63712}, "CVE-2016-1782": {"epss_score": 0.00699, "epss_percentile": 0.71457}, "CVE-2016-1783": {"epss_score": 0.02194, "epss_percentile": 0.83948}, "CVE-2016-1784": {"epss_score": 0.00943, "epss_percentile": 0.75781}, "CVE-2016-1785": {"epss_score": 0.00431, "epss_percentile": 0.62055}, "CVE-2016-1786": {"epss_score": 0.00441, "epss_percentile": 0.62664}, "CVE-2016-1787": {"epss_score": 0.00375, "epss_percentile": 0.58627}, "CVE-2016-1788": {"epss_score": 0.00588, "epss_percentile": 0.68493}, "CVE-2016-1789": {"epss_score": 0.0056, "epss_percentile": 0.67649}, "CVE-2016-1790": {"epss_score": 0.00243, "epss_percentile": 0.47482}, "CVE-2016-1791": {"epss_score": 0.00228, "epss_percentile": 0.45511}, "CVE-2016-1792": {"epss_score": 0.00215, "epss_percentile": 0.44049}, "CVE-2016-1793": {"epss_score": 0.01489, "epss_percentile": 0.80621}, "CVE-2016-1794": {"epss_score": 0.01489, "epss_percentile": 0.80621}, "CVE-2016-1795": {"epss_score": 0.00215, "epss_percentile": 0.44049}, "CVE-2016-1796": {"epss_score": 0.00276, "epss_percentile": 0.50755}, "CVE-2016-1797": {"epss_score": 0.00223, "epss_percentile": 0.44901}, "CVE-2016-1798": {"epss_score": 0.00203, "epss_percentile": 0.42529}, "CVE-2016-1799": {"epss_score": 0.00215, "epss_percentile": 0.44049}, "CVE-2016-1800": {"epss_score": 0.01, "epss_percentile": 0.76487}, "CVE-2016-1801": {"epss_score": 0.07722, "epss_percentile": 0.91644}, "CVE-2016-1802": {"epss_score": 0.00262, "epss_percentile": 0.49341}, "CVE-2016-1803": {"epss_score": 0.06656, "epss_percentile": 0.9092}, "CVE-2016-1804": {"epss_score": 0.00339, "epss_percentile": 0.56166}, "CVE-2016-1805": {"epss_score": 0.00213, "epss_percentile": 0.43948}, "CVE-2016-1806": {"epss_score": 0.00223, "epss_percentile": 0.44901}, "CVE-2016-1807": {"epss_score": 0.00125, "epss_percentile": 0.32478}, "CVE-2016-1808": {"epss_score": 0.00469, "epss_percentile": 0.63947}, "CVE-2016-1809": {"epss_score": 0.00169, "epss_percentile": 0.38644}, "CVE-2016-1810": {"epss_score": 0.00215, "epss_percentile": 0.44049}, "CVE-2016-1811": {"epss_score": 0.01032, "epss_percentile": 0.76865}, "CVE-2016-1812": {"epss_score": 0.00331, "epss_percentile": 0.55501}, "CVE-2016-1813": {"epss_score": 0.0463, "epss_percentile": 0.88942}, "CVE-2016-1814": {"epss_score": 0.00243, "epss_percentile": 0.47511}, "CVE-2016-1815": {"epss_score": 0.00238, "epss_percentile": 0.46793}, "CVE-2016-1816": {"epss_score": 0.00228, "epss_percentile": 0.45497}, "CVE-2016-1817": {"epss_score": 0.00636, "epss_percentile": 0.69863}, "CVE-2016-1818": {"epss_score": 0.0091, "epss_percentile": 0.75315}, "CVE-2016-1819": {"epss_score": 0.05569, "epss_percentile": 0.90005}, "CVE-2016-1820": {"epss_score": 0.00296, "epss_percentile": 0.52559}, "CVE-2016-1821": {"epss_score": 0.0092, "epss_percentile": 0.75465}, "CVE-2016-1822": {"epss_score": 0.00156, "epss_percentile": 0.36918}, "CVE-2016-1823": {"epss_score": 0.04179, "epss_percentile": 0.88355}, "CVE-2016-1824": {"epss_score": 0.00637, "epss_percentile": 0.6988}, "CVE-2016-1825": {"epss_score": 0.04441, "epss_percentile": 0.88694}, "CVE-2016-1826": {"epss_score": 0.00172, "epss_percentile": 0.3894}, "CVE-2016-1827": {"epss_score": 0.04482, "epss_percentile": 0.88743}, "CVE-2016-1828": {"epss_score": 0.05638, "epss_percentile": 0.90073}, "CVE-2016-1829": {"epss_score": 0.00637, "epss_percentile": 0.6988}, "CVE-2016-1830": {"epss_score": 0.00329, "epss_percentile": 0.55322}, "CVE-2016-1831": {"epss_score": 0.00207, "epss_percentile": 0.432}, "CVE-2016-1832": {"epss_score": 0.00064, "epss_percentile": 0.20395}, "CVE-2016-1833": {"epss_score": 0.01214, "epss_percentile": 0.78578}, "CVE-2016-1834": {"epss_score": 0.02369, "epss_percentile": 0.84522}, "CVE-2016-1835": {"epss_score": 0.02568, "epss_percentile": 0.85122}, "CVE-2016-1836": {"epss_score": 0.01153, "epss_percentile": 0.78054}, "CVE-2016-1837": {"epss_score": 0.00785, "epss_percentile": 0.7325}, "CVE-2016-1838": {"epss_score": 0.1065, "epss_percentile": 0.93058}, "CVE-2016-1839": {"epss_score": 0.10773, "epss_percentile": 0.93099}, "CVE-2016-1840": {"epss_score": 0.02142, "epss_percentile": 0.83754}, "CVE-2016-1841": {"epss_score": 0.01678, "epss_percentile": 0.81718}, "CVE-2016-1842": {"epss_score": 0.01154, "epss_percentile": 0.78066}, "CVE-2016-1843": {"epss_score": 0.01287, "epss_percentile": 0.79193}, "CVE-2016-1844": {"epss_score": 0.01151, "epss_percentile": 0.78038}, "CVE-2016-1846": {"epss_score": 0.01322, "epss_percentile": 0.79452}, "CVE-2016-1847": {"epss_score": 0.00856, "epss_percentile": 0.7448}, "CVE-2016-1848": {"epss_score": 0.03338, "epss_percentile": 0.86939}, "CVE-2016-1849": {"epss_score": 0.00056, "epss_percentile": 0.17833}, "CVE-2016-1850": {"epss_score": 0.00531, "epss_percentile": 0.66655}, "CVE-2016-1851": {"epss_score": 0.00088, "epss_percentile": 0.25726}, "CVE-2016-1852": {"epss_score": 0.00074, "epss_percentile": 0.22719}, "CVE-2016-1853": {"epss_score": 0.01287, "epss_percentile": 0.79193}, "CVE-2016-1854": {"epss_score": 0.00589, "epss_percentile": 0.68517}, "CVE-2016-1855": {"epss_score": 0.00708, "epss_percentile": 0.71679}, "CVE-2016-1856": {"epss_score": 0.00589, "epss_percentile": 0.68517}, "CVE-2016-1857": {"epss_score": 0.01359, "epss_percentile": 0.79735}, "CVE-2016-1858": {"epss_score": 0.01328, "epss_percentile": 0.79496}, "CVE-2016-1859": {"epss_score": 0.00589, "epss_percentile": 0.68517}, "CVE-2016-1860": {"epss_score": 0.00166, "epss_percentile": 0.38142}, "CVE-2016-1861": {"epss_score": 0.01874, "epss_percentile": 0.82652}, "CVE-2016-1862": {"epss_score": 0.00166, "epss_percentile": 0.38142}, "CVE-2016-1863": {"epss_score": 0.00181, "epss_percentile": 0.40092}, "CVE-2016-1864": {"epss_score": 0.0055, "epss_percentile": 0.67327}, "CVE-2016-1865": {"epss_score": 0.00056, "epss_percentile": 0.1785}, "CVE-2016-1866": {"epss_score": 0.00628, "epss_percentile": 0.69653}, "CVE-2016-1867": {"epss_score": 0.00462, "epss_percentile": 0.63617}, "CVE-2016-1876": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2016-1879": {"epss_score": 0.19791, "epss_percentile": 0.95241}, "CVE-2016-1880": {"epss_score": 0.00043, "epss_percentile": 0.13339}, "CVE-2016-1881": {"epss_score": 0.00044, "epss_percentile": 0.13489}, "CVE-2016-1882": {"epss_score": 0.00474, "epss_percentile": 0.64165}, "CVE-2016-1883": {"epss_score": 0.00043, "epss_percentile": 0.13339}, "CVE-2016-1885": {"epss_score": 0.0015, "epss_percentile": 0.36092}, "CVE-2016-1886": {"epss_score": 0.00219, "epss_percentile": 0.44489}, "CVE-2016-1887": {"epss_score": 0.00378, "epss_percentile": 0.58812}, "CVE-2016-1888": {"epss_score": 0.01755, "epss_percentile": 0.82121}, "CVE-2016-1889": {"epss_score": 0.00043, "epss_percentile": 0.13339}, "CVE-2016-1894": {"epss_score": 0.00408, "epss_percentile": 0.60643}, "CVE-2016-1895": {"epss_score": 0.00515, "epss_percentile": 0.66005}, "CVE-2016-1896": {"epss_score": 0.09369, "epss_percentile": 0.92519}, "CVE-2016-1897": {"epss_score": 0.48759, "epss_percentile": 0.97653}, "CVE-2016-1898": {"epss_score": 0.29201, "epss_percentile": 0.96424}, "CVE-2016-1899": {"epss_score": 0.00646, "epss_percentile": 0.70138}, "CVE-2016-1900": {"epss_score": 0.00646, "epss_percentile": 0.70138}, "CVE-2016-1901": {"epss_score": 0.04365, "epss_percentile": 0.88602}, "CVE-2016-1902": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2016-1903": {"epss_score": 0.08692, "epss_percentile": 0.92207}, "CVE-2016-1904": {"epss_score": 0.00371, "epss_percentile": 0.58384}, "CVE-2016-1905": {"epss_score": 0.00133, "epss_percentile": 0.33659}, "CVE-2016-1906": {"epss_score": 0.01555, "epss_percentile": 0.81013}, "CVE-2016-1907": {"epss_score": 0.00474, "epss_percentile": 0.64158}, "CVE-2016-1908": {"epss_score": 0.02368, "epss_percentile": 0.8452}, "CVE-2016-1909": {"epss_score": 0.79714, "epss_percentile": 0.99052}, "CVE-2016-1910": {"epss_score": 0.08822, "epss_percentile": 0.92271}, "CVE-2016-1911": {"epss_score": 0.00329, "epss_percentile": 0.55318}, "CVE-2016-1912": {"epss_score": 0.00222, "epss_percentile": 0.44728}, "CVE-2016-1913": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2016-1914": {"epss_score": 0.03185, "epss_percentile": 0.86589}, "CVE-2016-1915": {"epss_score": 0.07249, "epss_percentile": 0.91349}, "CVE-2016-1916": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2016-1917": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1918": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-1919": {"epss_score": 0.00066, "epss_percentile": 0.20889}, "CVE-2016-1920": {"epss_score": 0.00115, "epss_percentile": 0.3098}, "CVE-2016-1922": {"epss_score": 0.00082, "epss_percentile": 0.2455}, "CVE-2016-1923": {"epss_score": 0.0047, "epss_percentile": 0.63959}, "CVE-2016-1924": {"epss_score": 0.00925, "epss_percentile": 0.75527}, "CVE-2016-1925": {"epss_score": 0.00938, "epss_percentile": 0.75702}, "CVE-2016-1926": {"epss_score": 0.00717, "epss_percentile": 0.71883}, "CVE-2016-1927": {"epss_score": 0.00628, "epss_percentile": 0.69659}, "CVE-2016-1928": {"epss_score": 0.37328, "epss_percentile": 0.97034}, "CVE-2016-1929": {"epss_score": 0.01328, "epss_percentile": 0.79502}, "CVE-2016-1930": {"epss_score": 0.0186, "epss_percentile": 0.82585}, "CVE-2016-1931": {"epss_score": 0.0254, "epss_percentile": 0.85049}, "CVE-2016-1933": {"epss_score": 0.00777, "epss_percentile": 0.73114}, "CVE-2016-1935": {"epss_score": 0.00458, "epss_percentile": 0.63444}, "CVE-2016-1937": {"epss_score": 0.00353, "epss_percentile": 0.57144}, "CVE-2016-1938": {"epss_score": 0.0059, "epss_percentile": 0.68554}, "CVE-2016-1939": {"epss_score": 0.00582, "epss_percentile": 0.68308}, "CVE-2016-1940": {"epss_score": 0.00322, "epss_percentile": 0.5486}, "CVE-2016-1941": {"epss_score": 0.00248, "epss_percentile": 0.4795}, "CVE-2016-1942": {"epss_score": 0.0082, "epss_percentile": 0.73878}, "CVE-2016-1943": {"epss_score": 0.00556, "epss_percentile": 0.67525}, "CVE-2016-1944": {"epss_score": 0.02826, "epss_percentile": 0.85765}, "CVE-2016-1945": {"epss_score": 0.00674, "epss_percentile": 0.70851}, "CVE-2016-1946": {"epss_score": 0.03529, "epss_percentile": 0.87298}, "CVE-2016-1947": {"epss_score": 0.00571, "epss_percentile": 0.67982}, "CVE-2016-1948": {"epss_score": 0.00219, "epss_percentile": 0.44493}, "CVE-2016-1949": {"epss_score": 0.00544, "epss_percentile": 0.67126}, "CVE-2016-1950": {"epss_score": 0.03325, "epss_percentile": 0.8692}, "CVE-2016-1951": {"epss_score": 0.00786, "epss_percentile": 0.73292}, "CVE-2016-1952": {"epss_score": 0.0061, "epss_percentile": 0.69175}, "CVE-2016-1953": {"epss_score": 0.01228, "epss_percentile": 0.78707}, "CVE-2016-1954": {"epss_score": 0.05058, "epss_percentile": 0.8945}, "CVE-2016-1955": {"epss_score": 0.00371, "epss_percentile": 0.58351}, "CVE-2016-1956": {"epss_score": 0.00896, "epss_percentile": 0.75112}, "CVE-2016-1957": {"epss_score": 0.00668, "epss_percentile": 0.70743}, "CVE-2016-1958": {"epss_score": 0.00538, "epss_percentile": 0.66945}, "CVE-2016-1959": {"epss_score": 0.00748, "epss_percentile": 0.72586}, "CVE-2016-1960": {"epss_score": 0.87699, "epss_percentile": 0.99439}, "CVE-2016-1961": {"epss_score": 0.01253, "epss_percentile": 0.78913}, "CVE-2016-1962": {"epss_score": 0.04436, "epss_percentile": 0.88688}, "CVE-2016-1963": {"epss_score": 0.0011, "epss_percentile": 0.30199}, "CVE-2016-1964": {"epss_score": 0.00963, "epss_percentile": 0.76022}, "CVE-2016-1965": {"epss_score": 0.00435, "epss_percentile": 0.62375}, "CVE-2016-1966": {"epss_score": 0.01007, "epss_percentile": 0.76559}, "CVE-2016-1967": {"epss_score": 0.00379, "epss_percentile": 0.58841}, "CVE-2016-1968": {"epss_score": 0.02132, "epss_percentile": 0.83716}, "CVE-2016-1969": {"epss_score": 0.00472, "epss_percentile": 0.64038}, "CVE-2016-1970": {"epss_score": 0.00565, "epss_percentile": 0.67783}, "CVE-2016-1971": {"epss_score": 0.00565, "epss_percentile": 0.67783}, "CVE-2016-1972": {"epss_score": 0.00623, "epss_percentile": 0.6955}, "CVE-2016-1973": {"epss_score": 0.00838, "epss_percentile": 0.7418}, "CVE-2016-1974": {"epss_score": 0.00678, "epss_percentile": 0.71001}, "CVE-2016-1975": {"epss_score": 0.00594, "epss_percentile": 0.68667}, "CVE-2016-1976": {"epss_score": 0.0053, "epss_percentile": 0.66606}, "CVE-2016-1977": {"epss_score": 0.00963, "epss_percentile": 0.76022}, "CVE-2016-1978": {"epss_score": 0.02263, "epss_percentile": 0.84192}, "CVE-2016-1979": {"epss_score": 0.00707, "epss_percentile": 0.71645}, "CVE-2016-1981": {"epss_score": 0.00062, "epss_percentile": 0.19758}, "CVE-2016-1982": {"epss_score": 0.02362, "epss_percentile": 0.84503}, "CVE-2016-1983": {"epss_score": 0.01815, "epss_percentile": 0.8239}, "CVE-2016-1984": {"epss_score": 0.01778, "epss_percentile": 0.82226}, "CVE-2016-1985": {"epss_score": 0.02406, "epss_percentile": 0.84654}, "CVE-2016-1986": {"epss_score": 0.01305, "epss_percentile": 0.79321}, "CVE-2016-1987": {"epss_score": 0.02248, "epss_percentile": 0.84139}, "CVE-2016-1988": {"epss_score": 0.13502, "epss_percentile": 0.93982}, "CVE-2016-1989": {"epss_score": 0.13502, "epss_percentile": 0.93982}, "CVE-2016-1990": {"epss_score": 0.00099, "epss_percentile": 0.28339}, "CVE-2016-1991": {"epss_score": 0.00483, "epss_percentile": 0.64569}, "CVE-2016-1992": {"epss_score": 0.00255, "epss_percentile": 0.48684}, "CVE-2016-1993": {"epss_score": 0.00309, "epss_percentile": 0.5365}, "CVE-2016-1994": {"epss_score": 0.00255, "epss_percentile": 0.48684}, "CVE-2016-1995": {"epss_score": 0.16407, "epss_percentile": 0.94647}, "CVE-2016-1996": {"epss_score": 0.00129, "epss_percentile": 0.33189}, "CVE-2016-1997": {"epss_score": 0.02585, "epss_percentile": 0.85164}, "CVE-2016-1998": {"epss_score": 0.01668, "epss_percentile": 0.81659}, "CVE-2016-1999": {"epss_score": 0.03231, "epss_percentile": 0.86698}, "CVE-2016-20001": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2016-20002": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2016-20003": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2016-20004": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2016-20005": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2016-20006": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2016-20007": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2016-20008": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2016-20009": {"epss_score": 0.00416, "epss_percentile": 0.61201}, "CVE-2016-20010": {"epss_score": 0.06828, "epss_percentile": 0.91052}, "CVE-2016-20011": {"epss_score": 0.00362, "epss_percentile": 0.57783}, "CVE-2016-20012": {"epss_score": 0.14603, "epss_percentile": 0.94249}, "CVE-2016-20013": {"epss_score": 0.00235, "epss_percentile": 0.46231}, "CVE-2016-20014": {"epss_score": 0.00156, "epss_percentile": 0.36919}, "CVE-2016-20015": {"epss_score": 0.00302, "epss_percentile": 0.53111}, "CVE-2016-20016": {"epss_score": 0.90604, "epss_percentile": 0.99592}, "CVE-2016-20017": {"epss_score": 0.93405, "epss_percentile": 0.99804}, "CVE-2016-20018": {"epss_score": 0.00325, "epss_percentile": 0.54977}, "CVE-2016-20021": {"epss_score": 0.00039, "epss_percentile": 0.11427}, "CVE-2016-20022": {"epss_score": 0.00111, "epss_percentile": 0.30363}, "CVE-2016-20023": {"epss_score": 0.00049, "epss_percentile": 0.15609}, "CVE-2016-2000": {"epss_score": 0.01054, "epss_percentile": 0.77107}, "CVE-2016-2001": {"epss_score": 0.00497, "epss_percentile": 0.65183}, "CVE-2016-2002": {"epss_score": 0.02938, "epss_percentile": 0.86028}, "CVE-2016-2003": {"epss_score": 0.01054, "epss_percentile": 0.77107}, "CVE-2016-2004": {"epss_score": 0.92734, "epss_percentile": 0.99739}, "CVE-2016-2005": {"epss_score": 0.4725, "epss_percentile": 0.97579}, "CVE-2016-2006": {"epss_score": 0.4725, "epss_percentile": 0.97579}, "CVE-2016-2007": {"epss_score": 0.4725, "epss_percentile": 0.97579}, "CVE-2016-2008": {"epss_score": 0.13204, "epss_percentile": 0.93901}, "CVE-2016-2009": {"epss_score": 0.01078, "epss_percentile": 0.77343}, "CVE-2016-2010": {"epss_score": 0.00229, "epss_percentile": 0.45595}, "CVE-2016-2011": {"epss_score": 0.00229, "epss_percentile": 0.45595}, "CVE-2016-2012": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2016-2013": {"epss_score": 0.00255, "epss_percentile": 0.48684}, "CVE-2016-2014": {"epss_score": 0.00317, "epss_percentile": 0.54382}, "CVE-2016-2015": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2016-2016": {"epss_score": 0.00054, "epss_percentile": 0.17172}, "CVE-2016-2017": {"epss_score": 0.00612, "epss_percentile": 0.69213}, "CVE-2016-2018": {"epss_score": 0.01368, "epss_percentile": 0.79791}, "CVE-2016-2019": {"epss_score": 0.00301, "epss_percentile": 0.53006}, "CVE-2016-2020": {"epss_score": 0.00271, "epss_percentile": 0.50311}, "CVE-2016-2021": {"epss_score": 0.00301, "epss_percentile": 0.53006}, "CVE-2016-2022": {"epss_score": 0.00192, "epss_percentile": 0.41308}, "CVE-2016-2023": {"epss_score": 0.00138, "epss_percentile": 0.34377}, "CVE-2016-2024": {"epss_score": 0.02156, "epss_percentile": 0.83811}, "CVE-2016-2025": {"epss_score": 0.0065, "epss_percentile": 0.70247}, "CVE-2016-2026": {"epss_score": 0.0224, "epss_percentile": 0.84113}, "CVE-2016-2027": {"epss_score": 0.0224, "epss_percentile": 0.84113}, "CVE-2016-2028": {"epss_score": 0.00179, "epss_percentile": 0.39855}, "CVE-2016-2029": {"epss_score": 0.01711, "epss_percentile": 0.8188}, "CVE-2016-2030": {"epss_score": 0.00173, "epss_percentile": 0.39071}, "CVE-2016-2031": {"epss_score": 0.01313, "epss_percentile": 0.79381}, "CVE-2016-2032": {"epss_score": 0.00903, "epss_percentile": 0.75198}, "CVE-2016-2034": {"epss_score": 0.0033, "epss_percentile": 0.55485}, "CVE-2016-2036": {"epss_score": 0.0008, "epss_percentile": 0.24085}, "CVE-2016-2037": {"epss_score": 0.19449, "epss_percentile": 0.95183}, "CVE-2016-2038": {"epss_score": 0.01204, "epss_percentile": 0.78508}, "CVE-2016-2039": {"epss_score": 0.00382, "epss_percentile": 0.59064}, "CVE-2016-2040": {"epss_score": 0.00493, "epss_percentile": 0.65027}, "CVE-2016-2041": {"epss_score": 0.01029, "epss_percentile": 0.76835}, "CVE-2016-2042": {"epss_score": 0.00577, "epss_percentile": 0.68151}, "CVE-2016-2043": {"epss_score": 0.00394, "epss_percentile": 0.5977}, "CVE-2016-2044": {"epss_score": 0.00437, "epss_percentile": 0.6251}, "CVE-2016-2045": {"epss_score": 0.00284, "epss_percentile": 0.51453}, "CVE-2016-2046": {"epss_score": 0.0097, "epss_percentile": 0.76108}, "CVE-2016-2047": {"epss_score": 0.01749, "epss_percentile": 0.82086}, "CVE-2016-2048": {"epss_score": 0.00142, "epss_percentile": 0.34963}, "CVE-2016-2049": {"epss_score": 0.00401, "epss_percentile": 0.60215}, "CVE-2016-2050": {"epss_score": 0.00582, "epss_percentile": 0.68309}, "CVE-2016-2051": {"epss_score": 0.003, "epss_percentile": 0.52913}, "CVE-2016-2052": {"epss_score": 0.00467, "epss_percentile": 0.63856}, "CVE-2016-2053": {"epss_score": 0.00093, "epss_percentile": 0.26687}, "CVE-2016-2054": {"epss_score": 0.04093, "epss_percentile": 0.88243}, "CVE-2016-2055": {"epss_score": 0.67997, "epss_percentile": 0.98528}, "CVE-2016-2056": {"epss_score": 0.56347, "epss_percentile": 0.98018}, "CVE-2016-2057": {"epss_score": 0.00099, "epss_percentile": 0.27865}, "CVE-2016-2058": {"epss_score": 0.00241, "epss_percentile": 0.47271}, "CVE-2016-2059": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2016-2060": {"epss_score": 0.00044, "epss_percentile": 0.13653}, "CVE-2016-2061": {"epss_score": 0.00205, "epss_percentile": 0.42686}, "CVE-2016-2062": {"epss_score": 0.00058, "epss_percentile": 0.18304}, "CVE-2016-2063": {"epss_score": 0.00065, "epss_percentile": 0.2051}, "CVE-2016-2064": {"epss_score": 0.00075, "epss_percentile": 0.23009}, "CVE-2016-2065": {"epss_score": 0.00181, "epss_percentile": 0.40017}, "CVE-2016-2066": {"epss_score": 0.00199, "epss_percentile": 0.42109}, "CVE-2016-2067": {"epss_score": 0.00066, "epss_percentile": 0.207}, "CVE-2016-2068": {"epss_score": 0.00132, "epss_percentile": 0.33605}, "CVE-2016-2069": {"epss_score": 0.00052, "epss_percentile": 0.16629}, "CVE-2016-2070": {"epss_score": 0.0074, "epss_percentile": 0.72402}, "CVE-2016-2071": {"epss_score": 0.02744, "epss_percentile": 0.85568}, "CVE-2016-2072": {"epss_score": 0.00238, "epss_percentile": 0.46775}, "CVE-2016-2073": {"epss_score": 0.01321, "epss_percentile": 0.79446}, "CVE-2016-2074": {"epss_score": 0.07538, "epss_percentile": 0.91524}, "CVE-2016-2075": {"epss_score": 0.00096, "epss_percentile": 0.27323}, "CVE-2016-2076": {"epss_score": 0.00438, "epss_percentile": 0.62552}, "CVE-2016-2077": {"epss_score": 0.00552, "epss_percentile": 0.674}, "CVE-2016-2078": {"epss_score": 0.00182, "epss_percentile": 0.40218}, "CVE-2016-2079": {"epss_score": 0.00392, "epss_percentile": 0.59644}, "CVE-2016-2081": {"epss_score": 0.00159, "epss_percentile": 0.37335}, "CVE-2016-2082": {"epss_score": 0.00084, "epss_percentile": 0.24985}, "CVE-2016-2084": {"epss_score": 0.00483, "epss_percentile": 0.64621}, "CVE-2016-2085": {"epss_score": 0.00072, "epss_percentile": 0.22344}, "CVE-2016-2086": {"epss_score": 0.00451, "epss_percentile": 0.63146}, "CVE-2016-2087": {"epss_score": 0.13018, "epss_percentile": 0.93847}, "CVE-2016-2088": {"epss_score": 0.48562, "epss_percentile": 0.97643}, "CVE-2016-2089": {"epss_score": 0.00766, "epss_percentile": 0.72936}, "CVE-2016-2090": {"epss_score": 0.01707, "epss_percentile": 0.81862}, "CVE-2016-2091": {"epss_score": 0.00291, "epss_percentile": 0.52162}, "CVE-2016-2094": {"epss_score": 0.01992, "epss_percentile": 0.8318}, "CVE-2016-2097": {"epss_score": 0.02343, "epss_percentile": 0.84441}, "CVE-2016-2098": {"epss_score": 0.8743, "epss_percentile": 0.99429}, "CVE-2016-2099": {"epss_score": 0.01611, "epss_percentile": 0.81326}, "CVE-2016-2100": {"epss_score": 0.00201, "epss_percentile": 0.42389}, "CVE-2016-2102": {"epss_score": 0.00015, "epss_percentile": 0.02536}, "CVE-2016-2103": {"epss_score": 0.00236, "epss_percentile": 0.46448}, "CVE-2016-2104": {"epss_score": 0.00301, "epss_percentile": 0.53051}, "CVE-2016-2105": {"epss_score": 0.48148, "epss_percentile": 0.97623}, "CVE-2016-2106": {"epss_score": 0.6302, "epss_percentile": 0.98317}, "CVE-2016-2107": {"epss_score": 0.78053, "epss_percentile": 0.98966}, "CVE-2016-2108": {"epss_score": 0.50006, "epss_percentile": 0.97714}, "CVE-2016-2109": {"epss_score": 0.57944, "epss_percentile": 0.98092}, "CVE-2016-2110": {"epss_score": 0.19664, "epss_percentile": 0.95222}, "CVE-2016-2111": {"epss_score": 0.03498, "epss_percentile": 0.87241}, "CVE-2016-2112": {"epss_score": 0.18436, "epss_percentile": 0.95016}, "CVE-2016-2113": {"epss_score": 0.06295, "epss_percentile": 0.9065}, "CVE-2016-2114": {"epss_score": 0.09085, "epss_percentile": 0.92395}, "CVE-2016-2115": {"epss_score": 0.23771, "epss_percentile": 0.95814}, "CVE-2016-2116": {"epss_score": 0.0734, "epss_percentile": 0.91419}, "CVE-2016-2117": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2016-2118": {"epss_score": 0.77138, "epss_percentile": 0.98923}, "CVE-2016-2119": {"epss_score": 0.01403, "epss_percentile": 0.80029}, "CVE-2016-2120": {"epss_score": 0.00131, "epss_percentile": 0.334}, "CVE-2016-2121": {"epss_score": 0.0006, "epss_percentile": 0.19052}, "CVE-2016-2123": {"epss_score": 0.01035, "epss_percentile": 0.76902}, "CVE-2016-2124": {"epss_score": 0.00779, "epss_percentile": 0.73156}, "CVE-2016-2125": {"epss_score": 0.09844, "epss_percentile": 0.92732}, "CVE-2016-2126": {"epss_score": 0.04207, "epss_percentile": 0.88397}, "CVE-2016-2138": {"epss_score": 0.00187, "epss_percentile": 0.40797}, "CVE-2016-2139": {"epss_score": 0.00187, "epss_percentile": 0.40797}, "CVE-2016-2140": {"epss_score": 0.00634, "epss_percentile": 0.69792}, "CVE-2016-2141": {"epss_score": 0.01546, "epss_percentile": 0.80968}, "CVE-2016-2142": {"epss_score": 0.0004, "epss_percentile": 0.12104}, "CVE-2016-2143": {"epss_score": 0.00171, "epss_percentile": 0.38836}, "CVE-2016-2145": {"epss_score": 0.00804, "epss_percentile": 0.73617}, "CVE-2016-2146": {"epss_score": 0.00649, "epss_percentile": 0.70242}, "CVE-2016-2147": {"epss_score": 0.02388, "epss_percentile": 0.84585}, "CVE-2016-2148": {"epss_score": 0.1607, "epss_percentile": 0.94566}, "CVE-2016-2149": {"epss_score": 0.00224, "epss_percentile": 0.45067}, "CVE-2016-2150": {"epss_score": 0.00078, "epss_percentile": 0.23677}, "CVE-2016-2151": {"epss_score": 0.00327, "epss_percentile": 0.55148}, "CVE-2016-2152": {"epss_score": 0.00223, "epss_percentile": 0.44896}, "CVE-2016-2153": {"epss_score": 0.00223, "epss_percentile": 0.44896}, "CVE-2016-2154": {"epss_score": 0.00328, "epss_percentile": 0.55279}, "CVE-2016-2155": {"epss_score": 0.00303, "epss_percentile": 0.53225}, "CVE-2016-2156": {"epss_score": 0.00302, "epss_percentile": 0.53164}, "CVE-2016-2157": {"epss_score": 0.00097, "epss_percentile": 0.27548}, "CVE-2016-2158": {"epss_score": 0.00328, "epss_percentile": 0.55279}, "CVE-2016-2159": {"epss_score": 0.0021, "epss_percentile": 0.43465}, "CVE-2016-2160": {"epss_score": 0.00817, "epss_percentile": 0.7384}, "CVE-2016-2161": {"epss_score": 0.39609, "epss_percentile": 0.9717}, "CVE-2016-2162": {"epss_score": 0.06525, "epss_percentile": 0.90821}, "CVE-2016-2163": {"epss_score": 0.02728, "epss_percentile": 0.85532}, "CVE-2016-2164": {"epss_score": 0.01232, "epss_percentile": 0.78742}, "CVE-2016-2165": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2016-2166": {"epss_score": 0.00271, "epss_percentile": 0.50333}, "CVE-2016-2167": {"epss_score": 0.00764, "epss_percentile": 0.72898}, "CVE-2016-2168": {"epss_score": 0.07044, "epss_percentile": 0.91208}, "CVE-2016-2169": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2016-2170": {"epss_score": 0.14912, "epss_percentile": 0.94321}, "CVE-2016-2171": {"epss_score": 0.10305, "epss_percentile": 0.92935}, "CVE-2016-2173": {"epss_score": 0.21294, "epss_percentile": 0.95496}, "CVE-2016-2174": {"epss_score": 0.00576, "epss_percentile": 0.68142}, "CVE-2016-2175": {"epss_score": 0.02916, "epss_percentile": 0.85982}, "CVE-2016-2176": {"epss_score": 0.09084, "epss_percentile": 0.92394}, "CVE-2016-2177": {"epss_score": 0.36256, "epss_percentile": 0.96964}, "CVE-2016-2178": {"epss_score": 0.0024, "epss_percentile": 0.47199}, "CVE-2016-2179": {"epss_score": 0.16962, "epss_percentile": 0.94754}, "CVE-2016-2180": {"epss_score": 0.05595, "epss_percentile": 0.90034}, "CVE-2016-2181": {"epss_score": 0.23026, "epss_percentile": 0.95721}, "CVE-2016-2182": {"epss_score": 0.37127, "epss_percentile": 0.97021}, "CVE-2016-2183": {"epss_score": 0.40016, "epss_percentile": 0.9719}, "CVE-2016-2184": {"epss_score": 0.00109, "epss_percentile": 0.30043}, "CVE-2016-2185": {"epss_score": 0.0002, "epss_percentile": 0.04676}, "CVE-2016-2186": {"epss_score": 0.00027, "epss_percentile": 0.06877}, "CVE-2016-2187": {"epss_score": 0.00026, "epss_percentile": 0.06405}, "CVE-2016-2188": {"epss_score": 0.00136, "epss_percentile": 0.34139}, "CVE-2016-2190": {"epss_score": 0.00437, "epss_percentile": 0.62526}, "CVE-2016-2191": {"epss_score": 0.02064, "epss_percentile": 0.83453}, "CVE-2016-2192": {"epss_score": 0.00123, "epss_percentile": 0.32298}, "CVE-2016-2193": {"epss_score": 0.01526, "epss_percentile": 0.80862}, "CVE-2016-2194": {"epss_score": 0.0169, "epss_percentile": 0.81775}, "CVE-2016-2195": {"epss_score": 0.08065, "epss_percentile": 0.91864}, "CVE-2016-2196": {"epss_score": 0.03444, "epss_percentile": 0.87144}, "CVE-2016-2197": {"epss_score": 0.00111, "epss_percentile": 0.30397}, "CVE-2016-2198": {"epss_score": 0.00104, "epss_percentile": 0.29228}, "CVE-2016-2199": {"epss_score": 0.00118, "epss_percentile": 0.31439}, "CVE-2016-2200": {"epss_score": 0.09239, "epss_percentile": 0.92462}, "CVE-2016-2201": {"epss_score": 0.0161, "epss_percentile": 0.81323}, "CVE-2016-2202": {"epss_score": 0.00061, "epss_percentile": 0.19385}, "CVE-2016-2203": {"epss_score": 0.29571, "epss_percentile": 0.96457}, "CVE-2016-2204": {"epss_score": 0.00154, "epss_percentile": 0.36749}, "CVE-2016-2205": {"epss_score": 0.00396, "epss_percentile": 0.59856}, "CVE-2016-2206": {"epss_score": 0.00153, "epss_percentile": 0.3651}, "CVE-2016-2207": {"epss_score": 0.50208, "epss_percentile": 0.97725}, "CVE-2016-2208": {"epss_score": 0.52666, "epss_percentile": 0.97834}, "CVE-2016-2209": {"epss_score": 0.29051, "epss_percentile": 0.96414}, "CVE-2016-2210": {"epss_score": 0.29051, "epss_percentile": 0.96414}, "CVE-2016-2211": {"epss_score": 0.10499, "epss_percentile": 0.93011}, "CVE-2016-2212": {"epss_score": 0.00126, "epss_percentile": 0.32666}, "CVE-2016-2213": {"epss_score": 0.00683, "epss_percentile": 0.71098}, "CVE-2016-2214": {"epss_score": 0.00114, "epss_percentile": 0.30848}, "CVE-2016-2216": {"epss_score": 0.02105, "epss_percentile": 0.83623}, "CVE-2016-2217": {"epss_score": 0.00352, "epss_percentile": 0.57109}, "CVE-2016-2219": {"epss_score": 0.00159, "epss_percentile": 0.37322}, "CVE-2016-2221": {"epss_score": 0.03465, "epss_percentile": 0.87188}, "CVE-2016-2222": {"epss_score": 0.05172, "epss_percentile": 0.89572}, "CVE-2016-2224": {"epss_score": 0.00944, "epss_percentile": 0.75789}, "CVE-2016-2225": {"epss_score": 0.00878, "epss_percentile": 0.74819}, "CVE-2016-2226": {"epss_score": 0.09327, "epss_percentile": 0.92501}, "CVE-2016-2228": {"epss_score": 0.00575, "epss_percentile": 0.68107}, "CVE-2016-2230": {"epss_score": 0.01635, "epss_percentile": 0.81474}, "CVE-2016-2231": {"epss_score": 0.00322, "epss_percentile": 0.54797}, "CVE-2016-2232": {"epss_score": 0.07852, "epss_percentile": 0.91719}, "CVE-2016-2233": {"epss_score": 0.14794, "epss_percentile": 0.94285}, "CVE-2016-2242": {"epss_score": 0.09645, "epss_percentile": 0.92638}, "CVE-2016-2243": {"epss_score": 0.00042, "epss_percentile": 0.12833}, "CVE-2016-2244": {"epss_score": 0.00705, "epss_percentile": 0.7158}, "CVE-2016-2245": {"epss_score": 0.14454, "epss_percentile": 0.94215}, "CVE-2016-2246": {"epss_score": 0.00088, "epss_percentile": 0.25648}, "CVE-2016-2268": {"epss_score": 0.00168, "epss_percentile": 0.38418}, "CVE-2016-2270": {"epss_score": 0.00295, "epss_percentile": 0.52526}, "CVE-2016-2271": {"epss_score": 0.00066, "epss_percentile": 0.2088}, "CVE-2016-2272": {"epss_score": 0.00413, "epss_percentile": 0.60964}, "CVE-2016-2274": {"epss_score": 0.0018, "epss_percentile": 0.39982}, "CVE-2016-2275": {"epss_score": 0.00294, "epss_percentile": 0.52357}, "CVE-2016-2277": {"epss_score": 0.0001, "epss_percentile": 0.00752}, "CVE-2016-2278": {"epss_score": 0.15868, "epss_percentile": 0.94523}, "CVE-2016-2279": {"epss_score": 0.02361, "epss_percentile": 0.84496}, "CVE-2016-2280": {"epss_score": 0.00354, "epss_percentile": 0.57202}, "CVE-2016-2281": {"epss_score": 0.00045, "epss_percentile": 0.13932}, "CVE-2016-2282": {"epss_score": 0.00568, "epss_percentile": 0.67908}, "CVE-2016-2283": {"epss_score": 0.00419, "epss_percentile": 0.61363}, "CVE-2016-2285": {"epss_score": 0.00195, "epss_percentile": 0.41691}, "CVE-2016-2286": {"epss_score": 0.00766, "epss_percentile": 0.72944}, "CVE-2016-2287": {"epss_score": 0.00337, "epss_percentile": 0.56053}, "CVE-2016-2288": {"epss_score": 0.00312, "epss_percentile": 0.54009}, "CVE-2016-2289": {"epss_score": 0.01051, "epss_percentile": 0.77082}, "CVE-2016-2290": {"epss_score": 0.01432, "epss_percentile": 0.80248}, "CVE-2016-2291": {"epss_score": 0.01301, "epss_percentile": 0.79289}, "CVE-2016-2292": {"epss_score": 0.02093, "epss_percentile": 0.83577}, "CVE-2016-2293": {"epss_score": 0.00337, "epss_percentile": 0.5606}, "CVE-2016-2294": {"epss_score": 0.00539, "epss_percentile": 0.66963}, "CVE-2016-2295": {"epss_score": 0.00747, "epss_percentile": 0.72575}, "CVE-2016-2296": {"epss_score": 0.75312, "epss_percentile": 0.98837}, "CVE-2016-2297": {"epss_score": 0.01592, "epss_percentile": 0.81224}, "CVE-2016-2298": {"epss_score": 0.73028, "epss_percentile": 0.98733}, "CVE-2016-2299": {"epss_score": 0.01303, "epss_percentile": 0.79311}, "CVE-2016-2300": {"epss_score": 0.00166, "epss_percentile": 0.38171}, "CVE-2016-2301": {"epss_score": 0.00141, "epss_percentile": 0.34938}, "CVE-2016-2302": {"epss_score": 0.00417, "epss_percentile": 0.61238}, "CVE-2016-2303": {"epss_score": 0.00425, "epss_percentile": 0.61724}, "CVE-2016-2304": {"epss_score": 0.00336, "epss_percentile": 0.55984}, "CVE-2016-2305": {"epss_score": 0.00337, "epss_percentile": 0.56053}, "CVE-2016-2306": {"epss_score": 0.00597, "epss_percentile": 0.68751}, "CVE-2016-2307": {"epss_score": 0.00397, "epss_percentile": 0.59983}, "CVE-2016-2308": {"epss_score": 0.00442, "epss_percentile": 0.62726}, "CVE-2016-2309": {"epss_score": 0.00091, "epss_percentile": 0.26206}, "CVE-2016-2310": {"epss_score": 0.00233, "epss_percentile": 0.45972}, "CVE-2016-2311": {"epss_score": 0.00325, "epss_percentile": 0.54999}, "CVE-2016-2312": {"epss_score": 0.00077, "epss_percentile": 0.23534}, "CVE-2016-2313": {"epss_score": 0.01075, "epss_percentile": 0.77316}, "CVE-2016-2314": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2016-2315": {"epss_score": 0.17652, "epss_percentile": 0.94884}, "CVE-2016-2316": {"epss_score": 0.01094, "epss_percentile": 0.77494}, "CVE-2016-2317": {"epss_score": 0.00383, "epss_percentile": 0.59085}, "CVE-2016-2318": {"epss_score": 0.00236, "epss_percentile": 0.46393}, "CVE-2016-2324": {"epss_score": 0.2205, "epss_percentile": 0.95588}, "CVE-2016-2326": {"epss_score": 0.00821, "epss_percentile": 0.73907}, "CVE-2016-2327": {"epss_score": 0.01068, "epss_percentile": 0.77238}, "CVE-2016-2328": {"epss_score": 0.01068, "epss_percentile": 0.77238}, "CVE-2016-2329": {"epss_score": 0.0116, "epss_percentile": 0.78135}, "CVE-2016-2330": {"epss_score": 0.00865, "epss_percentile": 0.74628}, "CVE-2016-2331": {"epss_score": 0.00295, "epss_percentile": 0.525}, "CVE-2016-2332": {"epss_score": 0.00096, "epss_percentile": 0.27357}, "CVE-2016-2333": {"epss_score": 0.00097, "epss_percentile": 0.27613}, "CVE-2016-2334": {"epss_score": 0.16299, "epss_percentile": 0.94613}, "CVE-2016-2335": {"epss_score": 0.01796, "epss_percentile": 0.82305}, "CVE-2016-2336": {"epss_score": 0.01274, "epss_percentile": 0.79097}, "CVE-2016-2337": {"epss_score": 0.00805, "epss_percentile": 0.73628}, "CVE-2016-2338": {"epss_score": 0.15381, "epss_percentile": 0.9442}, "CVE-2016-2339": {"epss_score": 0.00684, "epss_percentile": 0.7112}, "CVE-2016-2340": {"epss_score": 0.00293, "epss_percentile": 0.52356}, "CVE-2016-2342": {"epss_score": 0.16123, "epss_percentile": 0.94575}, "CVE-2016-2343": {"epss_score": 0.00544, "epss_percentile": 0.67148}, "CVE-2016-2344": {"epss_score": 0.02281, "epss_percentile": 0.84252}, "CVE-2016-2345": {"epss_score": 0.53488, "epss_percentile": 0.97879}, "CVE-2016-2346": {"epss_score": 0.00222, "epss_percentile": 0.44842}, "CVE-2016-2347": {"epss_score": 0.00417, "epss_percentile": 0.6126}, "CVE-2016-2349": {"epss_score": 0.00233, "epss_percentile": 0.46023}, "CVE-2016-2350": {"epss_score": 0.00267, "epss_percentile": 0.49952}, "CVE-2016-2351": {"epss_score": 0.00658, "epss_percentile": 0.70478}, "CVE-2016-2352": {"epss_score": 0.00373, "epss_percentile": 0.58479}, "CVE-2016-2353": {"epss_score": 0.00095, "epss_percentile": 0.27156}, "CVE-2016-2354": {"epss_score": 0.00176, "epss_percentile": 0.39407}, "CVE-2016-2355": {"epss_score": 0.0074, "epss_percentile": 0.72409}, "CVE-2016-2356": {"epss_score": 0.03513, "epss_percentile": 0.87269}, "CVE-2016-2357": {"epss_score": 0.00836, "epss_percentile": 0.74137}, "CVE-2016-2358": {"epss_score": 0.00836, "epss_percentile": 0.74137}, "CVE-2016-2359": {"epss_score": 0.00626, "epss_percentile": 0.69601}, "CVE-2016-2360": {"epss_score": 0.00836, "epss_percentile": 0.74137}, "CVE-2016-2362": {"epss_score": 0.00491, "epss_percentile": 0.64943}, "CVE-2016-2363": {"epss_score": 0.00104, "epss_percentile": 0.29126}, "CVE-2016-2364": {"epss_score": 0.00338, "epss_percentile": 0.56129}, "CVE-2016-2365": {"epss_score": 0.03252, "epss_percentile": 0.86752}, "CVE-2016-2366": {"epss_score": 0.01953, "epss_percentile": 0.83027}, "CVE-2016-2367": {"epss_score": 0.01948, "epss_percentile": 0.83009}, "CVE-2016-2368": {"epss_score": 0.06022, "epss_percentile": 0.90415}, "CVE-2016-2369": {"epss_score": 0.03252, "epss_percentile": 0.86752}, "CVE-2016-2370": {"epss_score": 0.01953, "epss_percentile": 0.83027}, "CVE-2016-2371": {"epss_score": 0.03521, "epss_percentile": 0.87287}, "CVE-2016-2372": {"epss_score": 0.01217, "epss_percentile": 0.78599}, "CVE-2016-2373": {"epss_score": 0.01953, "epss_percentile": 0.83027}, "CVE-2016-2374": {"epss_score": 0.02781, "epss_percentile": 0.8565}, "CVE-2016-2375": {"epss_score": 0.00483, "epss_percentile": 0.64565}, "CVE-2016-2376": {"epss_score": 0.06853, "epss_percentile": 0.91075}, "CVE-2016-2377": {"epss_score": 0.03306, "epss_percentile": 0.86876}, "CVE-2016-2378": {"epss_score": 0.03306, "epss_percentile": 0.86876}, "CVE-2016-2379": {"epss_score": 0.00158, "epss_percentile": 0.37202}, "CVE-2016-2380": {"epss_score": 0.00534, "epss_percentile": 0.66797}, "CVE-2016-2381": {"epss_score": 0.19468, "epss_percentile": 0.95189}, "CVE-2016-2383": {"epss_score": 0.00084, "epss_percentile": 0.24992}, "CVE-2016-2384": {"epss_score": 0.08978, "epss_percentile": 0.92349}, "CVE-2016-2385": {"epss_score": 0.25299, "epss_percentile": 0.9601}, "CVE-2016-2386": {"epss_score": 0.4395, "epss_percentile": 0.9741}, "CVE-2016-2387": {"epss_score": 0.00226, "epss_percentile": 0.45264}, "CVE-2016-2388": {"epss_score": 0.62285, "epss_percentile": 0.98287}, "CVE-2016-2389": {"epss_score": 0.80854, "epss_percentile": 0.9911}, "CVE-2016-2390": {"epss_score": 0.21283, "epss_percentile": 0.95493}, "CVE-2016-2391": {"epss_score": 0.00053, "epss_percentile": 0.16706}, "CVE-2016-2392": {"epss_score": 0.00086, "epss_percentile": 0.25382}, "CVE-2016-2393": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2016-2396": {"epss_score": 0.00586, "epss_percentile": 0.68442}, "CVE-2016-2397": {"epss_score": 0.05037, "epss_percentile": 0.89422}, "CVE-2016-2398": {"epss_score": 0.00527, "epss_percentile": 0.66447}, "CVE-2016-2399": {"epss_score": 0.00893, "epss_percentile": 0.75072}, "CVE-2016-2402": {"epss_score": 0.02681, "epss_percentile": 0.85416}, "CVE-2016-2403": {"epss_score": 0.00154, "epss_percentile": 0.36659}, "CVE-2016-2404": {"epss_score": 0.00165, "epss_percentile": 0.38057}, "CVE-2016-2405": {"epss_score": 0.00317, "epss_percentile": 0.54394}, "CVE-2016-2406": {"epss_score": 0.0007, "epss_percentile": 0.21947}, "CVE-2016-2408": {"epss_score": 0.00055, "epss_percentile": 0.17558}, "CVE-2016-2409": {"epss_score": 0.00161, "epss_percentile": 0.37559}, "CVE-2016-2410": {"epss_score": 0.00014, "epss_percentile": 0.02116}, "CVE-2016-2411": {"epss_score": 0.00064, "epss_percentile": 0.20256}, "CVE-2016-2412": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2413": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2414": {"epss_score": 0.005, "epss_percentile": 0.65317}, "CVE-2016-2415": {"epss_score": 0.00069, "epss_percentile": 0.21546}, "CVE-2016-2416": {"epss_score": 0.00287, "epss_percentile": 0.51844}, "CVE-2016-2417": {"epss_score": 0.13164, "epss_percentile": 0.9389}, "CVE-2016-2418": {"epss_score": 0.00201, "epss_percentile": 0.4228}, "CVE-2016-2419": {"epss_score": 0.00201, "epss_percentile": 0.4228}, "CVE-2016-2420": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2016-2421": {"epss_score": 0.00014, "epss_percentile": 0.01817}, "CVE-2016-2422": {"epss_score": 0.00024, "epss_percentile": 0.05877}, "CVE-2016-2423": {"epss_score": 0.00017, "epss_percentile": 0.03198}, "CVE-2016-2424": {"epss_score": 0.00053, "epss_percentile": 0.1669}, "CVE-2016-2425": {"epss_score": 0.00125, "epss_percentile": 0.32563}, "CVE-2016-2426": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-2427": {"epss_score": 0.0008, "epss_percentile": 0.24093}, "CVE-2016-2428": {"epss_score": 0.01215, "epss_percentile": 0.78588}, "CVE-2016-2429": {"epss_score": 0.01215, "epss_percentile": 0.78588}, "CVE-2016-2430": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2431": {"epss_score": 0.01432, "epss_percentile": 0.80247}, "CVE-2016-2432": {"epss_score": 0.00044, "epss_percentile": 0.13653}, "CVE-2016-2433": {"epss_score": 0.00376, "epss_percentile": 0.58677}, "CVE-2016-2434": {"epss_score": 0.0125, "epss_percentile": 0.78878}, "CVE-2016-2435": {"epss_score": 0.00061, "epss_percentile": 0.19468}, "CVE-2016-2436": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2437": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-2439": {"epss_score": 0.02776, "epss_percentile": 0.85638}, "CVE-2016-2440": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2441": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2016-2442": {"epss_score": 0.00058, "epss_percentile": 0.18532}, "CVE-2016-2443": {"epss_score": 0.00058, "epss_percentile": 0.18532}, "CVE-2016-2444": {"epss_score": 0.00058, "epss_percentile": 0.18532}, "CVE-2016-2445": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-2446": {"epss_score": 0.00058, "epss_percentile": 0.18532}, "CVE-2016-2448": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2449": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2450": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2451": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2452": {"epss_score": 0.00067, "epss_percentile": 0.21081}, "CVE-2016-2453": {"epss_score": 0.00058, "epss_percentile": 0.18532}, "CVE-2016-2454": {"epss_score": 0.00281, "epss_percentile": 0.51188}, "CVE-2016-2456": {"epss_score": 0.00061, "epss_percentile": 0.19412}, "CVE-2016-2457": {"epss_score": 0.00029, "epss_percentile": 0.07864}, "CVE-2016-2458": {"epss_score": 0.00125, "epss_percentile": 0.32563}, "CVE-2016-2459": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-2460": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-2461": {"epss_score": 0.00089, "epss_percentile": 0.25914}, "CVE-2016-2462": {"epss_score": 0.00064, "epss_percentile": 0.20141}, "CVE-2016-2463": {"epss_score": 0.00615, "epss_percentile": 0.69302}, "CVE-2016-2464": {"epss_score": 0.00254, "epss_percentile": 0.48531}, "CVE-2016-2465": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-2466": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2467": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2468": {"epss_score": 0.00386, "epss_percentile": 0.5925}, "CVE-2016-2469": {"epss_score": 0.00071, "epss_percentile": 0.2202}, "CVE-2016-2470": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2471": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2472": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2473": {"epss_score": 0.00161, "epss_percentile": 0.37559}, "CVE-2016-2474": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-2475": {"epss_score": 0.0003, "epss_percentile": 0.08188}, "CVE-2016-2476": {"epss_score": 0.00074, "epss_percentile": 0.22703}, "CVE-2016-2477": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2478": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2479": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2480": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2481": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2482": {"epss_score": 0.00043, "epss_percentile": 0.12997}, "CVE-2016-2483": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2484": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2485": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2486": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2487": {"epss_score": 0.00067, "epss_percentile": 0.21081}, "CVE-2016-2488": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2489": {"epss_score": 0.00043, "epss_percentile": 0.12954}, "CVE-2016-2490": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2491": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2492": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2493": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2494": {"epss_score": 0.01072, "epss_percentile": 0.77274}, "CVE-2016-2495": {"epss_score": 0.00284, "epss_percentile": 0.51442}, "CVE-2016-2496": {"epss_score": 0.00314, "epss_percentile": 0.54116}, "CVE-2016-2497": {"epss_score": 0.00155, "epss_percentile": 0.3677}, "CVE-2016-2498": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-2499": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-2500": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-2501": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-2502": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-2503": {"epss_score": 0.00043, "epss_percentile": 0.12997}, "CVE-2016-2504": {"epss_score": 0.00014, "epss_percentile": 0.02116}, "CVE-2016-2505": {"epss_score": 0.0017, "epss_percentile": 0.38687}, "CVE-2016-2506": {"epss_score": 0.03445, "epss_percentile": 0.87146}, "CVE-2016-2507": {"epss_score": 0.0017, "epss_percentile": 0.38687}, "CVE-2016-2508": {"epss_score": 0.00326, "epss_percentile": 0.55042}, "CVE-2016-2509": {"epss_score": 0.00031, "epss_percentile": 0.08639}, "CVE-2016-2510": {"epss_score": 0.37916, "epss_percentile": 0.97076}, "CVE-2016-2511": {"epss_score": 0.00388, "epss_percentile": 0.59373}, "CVE-2016-2512": {"epss_score": 0.00541, "epss_percentile": 0.67031}, "CVE-2016-2513": {"epss_score": 0.01692, "epss_percentile": 0.8179}, "CVE-2016-2515": {"epss_score": 0.05317, "epss_percentile": 0.89724}, "CVE-2016-2516": {"epss_score": 0.1465, "epss_percentile": 0.94257}, "CVE-2016-2517": {"epss_score": 0.07249, "epss_percentile": 0.91349}, "CVE-2016-2518": {"epss_score": 0.00858, "epss_percentile": 0.74499}, "CVE-2016-2519": {"epss_score": 0.09494, "epss_percentile": 0.92573}, "CVE-2016-2521": {"epss_score": 0.00032, "epss_percentile": 0.08771}, "CVE-2016-2522": {"epss_score": 0.00216, "epss_percentile": 0.44235}, "CVE-2016-2523": {"epss_score": 0.04921, "epss_percentile": 0.89291}, "CVE-2016-2524": {"epss_score": 0.00216, "epss_percentile": 0.44235}, "CVE-2016-2525": {"epss_score": 0.00294, "epss_percentile": 0.52423}, "CVE-2016-2526": {"epss_score": 0.00216, "epss_percentile": 0.44235}, "CVE-2016-2527": {"epss_score": 0.00185, "epss_percentile": 0.40524}, "CVE-2016-2528": {"epss_score": 0.00213, "epss_percentile": 0.43926}, "CVE-2016-2529": {"epss_score": 0.00169, "epss_percentile": 0.38569}, "CVE-2016-2530": {"epss_score": 0.01429, "epss_percentile": 0.80225}, "CVE-2016-2531": {"epss_score": 0.01429, "epss_percentile": 0.80225}, "CVE-2016-2532": {"epss_score": 0.01429, "epss_percentile": 0.80225}, "CVE-2016-2533": {"epss_score": 0.01184, "epss_percentile": 0.78333}, "CVE-2016-2536": {"epss_score": 0.00628, "epss_percentile": 0.69655}, "CVE-2016-2537": {"epss_score": 0.00499, "epss_percentile": 0.65251}, "CVE-2016-2538": {"epss_score": 0.00088, "epss_percentile": 0.25689}, "CVE-2016-2539": {"epss_score": 0.00188, "epss_percentile": 0.40836}, "CVE-2016-2540": {"epss_score": 0.00908, "epss_percentile": 0.75276}, "CVE-2016-2541": {"epss_score": 0.00859, "epss_percentile": 0.7452}, "CVE-2016-2542": {"epss_score": 0.00185, "epss_percentile": 0.40528}, "CVE-2016-2543": {"epss_score": 0.00043, "epss_percentile": 0.13178}, "CVE-2016-2544": {"epss_score": 0.0005, "epss_percentile": 0.1568}, "CVE-2016-2545": {"epss_score": 0.00067, "epss_percentile": 0.21027}, "CVE-2016-2546": {"epss_score": 0.00072, "epss_percentile": 0.22305}, "CVE-2016-2547": {"epss_score": 0.00067, "epss_percentile": 0.21154}, "CVE-2016-2548": {"epss_score": 0.00106, "epss_percentile": 0.29474}, "CVE-2016-2549": {"epss_score": 0.00072, "epss_percentile": 0.2232}, "CVE-2016-2550": {"epss_score": 0.00022, "epss_percentile": 0.05229}, "CVE-2016-2554": {"epss_score": 0.10282, "epss_percentile": 0.92925}, "CVE-2016-2555": {"epss_score": 0.80809, "epss_percentile": 0.99107}, "CVE-2016-2556": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2016-2557": {"epss_score": 0.00039, "epss_percentile": 0.11589}, "CVE-2016-2558": {"epss_score": 0.00039, "epss_percentile": 0.11589}, "CVE-2016-2559": {"epss_score": 0.00278, "epss_percentile": 0.50921}, "CVE-2016-2560": {"epss_score": 0.0134, "epss_percentile": 0.7958}, "CVE-2016-2561": {"epss_score": 0.00532, "epss_percentile": 0.66682}, "CVE-2016-2562": {"epss_score": 0.0023, "epss_percentile": 0.45741}, "CVE-2016-2563": {"epss_score": 0.28635, "epss_percentile": 0.96373}, "CVE-2016-2564": {"epss_score": 0.00305, "epss_percentile": 0.53312}, "CVE-2016-2565": {"epss_score": 0.00076, "epss_percentile": 0.2313}, "CVE-2016-2566": {"epss_score": 0.00572, "epss_percentile": 0.68005}, "CVE-2016-2567": {"epss_score": 0.00079, "epss_percentile": 0.23997}, "CVE-2016-2568": {"epss_score": 0.00131, "epss_percentile": 0.33499}, "CVE-2016-2569": {"epss_score": 0.71402, "epss_percentile": 0.98666}, "CVE-2016-2570": {"epss_score": 0.10072, "epss_percentile": 0.92839}, "CVE-2016-2571": {"epss_score": 0.14638, "epss_percentile": 0.94255}, "CVE-2016-2572": {"epss_score": 0.15158, "epss_percentile": 0.94375}, "CVE-2016-2774": {"epss_score": 0.65582, "epss_percentile": 0.98426}, "CVE-2016-2775": {"epss_score": 0.27715, "epss_percentile": 0.96276}, "CVE-2016-2776": {"epss_score": 0.88367, "epss_percentile": 0.99469}, "CVE-2016-2779": {"epss_score": 0.00158, "epss_percentile": 0.37201}, "CVE-2016-2780": {"epss_score": 0.00025, "epss_percentile": 0.06053}, "CVE-2016-2781": {"epss_score": 0.00084, "epss_percentile": 0.2485}, "CVE-2016-2782": {"epss_score": 0.00473, "epss_percentile": 0.64077}, "CVE-2016-2783": {"epss_score": 0.02547, "epss_percentile": 0.85064}, "CVE-2016-2784": {"epss_score": 0.06088, "epss_percentile": 0.90468}, "CVE-2016-2785": {"epss_score": 0.0017, "epss_percentile": 0.38669}, "CVE-2016-2786": {"epss_score": 0.0071, "epss_percentile": 0.71712}, "CVE-2016-2787": {"epss_score": 0.00174, "epss_percentile": 0.39153}, "CVE-2016-2788": {"epss_score": 0.01957, "epss_percentile": 0.83041}, "CVE-2016-2789": {"epss_score": 0.00279, "epss_percentile": 0.50991}, "CVE-2016-2790": {"epss_score": 0.00787, "epss_percentile": 0.73305}, "CVE-2016-2791": {"epss_score": 0.00787, "epss_percentile": 0.73305}, "CVE-2016-2792": {"epss_score": 0.00787, "epss_percentile": 0.73305}, "CVE-2016-2793": {"epss_score": 0.00787, "epss_percentile": 0.73305}, "CVE-2016-2794": {"epss_score": 0.01576, "epss_percentile": 0.81113}, "CVE-2016-2795": {"epss_score": 0.00787, "epss_percentile": 0.73305}, "CVE-2016-2796": {"epss_score": 0.00926, "epss_percentile": 0.75546}, "CVE-2016-2797": {"epss_score": 0.00787, "epss_percentile": 0.73305}, "CVE-2016-2798": {"epss_score": 0.00787, "epss_percentile": 0.73305}, "CVE-2016-2799": {"epss_score": 0.0137, "epss_percentile": 0.79798}, "CVE-2016-2800": {"epss_score": 0.00787, "epss_percentile": 0.73305}, "CVE-2016-2801": {"epss_score": 0.00787, "epss_percentile": 0.73305}, "CVE-2016-2802": {"epss_score": 0.00787, "epss_percentile": 0.73305}, "CVE-2016-2803": {"epss_score": 0.0039, "epss_percentile": 0.59544}, "CVE-2016-2804": {"epss_score": 0.00941, "epss_percentile": 0.75755}, "CVE-2016-2805": {"epss_score": 0.00922, "epss_percentile": 0.75494}, "CVE-2016-2806": {"epss_score": 0.01777, "epss_percentile": 0.82223}, "CVE-2016-2807": {"epss_score": 0.01777, "epss_percentile": 0.82223}, "CVE-2016-2808": {"epss_score": 0.00681, "epss_percentile": 0.71038}, "CVE-2016-2809": {"epss_score": 0.0039, "epss_percentile": 0.59509}, "CVE-2016-2810": {"epss_score": 0.00272, "epss_percentile": 0.5036}, "CVE-2016-2811": {"epss_score": 0.01744, "epss_percentile": 0.82065}, "CVE-2016-2812": {"epss_score": 0.00594, "epss_percentile": 0.68656}, "CVE-2016-2813": {"epss_score": 0.00472, "epss_percentile": 0.64055}, "CVE-2016-2814": {"epss_score": 0.02136, "epss_percentile": 0.83728}, "CVE-2016-2815": {"epss_score": 0.00362, "epss_percentile": 0.57787}, "CVE-2016-2816": {"epss_score": 0.00246, "epss_percentile": 0.47759}, "CVE-2016-2817": {"epss_score": 0.00399, "epss_percentile": 0.60132}, "CVE-2016-2818": {"epss_score": 0.00593, "epss_percentile": 0.68634}, "CVE-2016-2819": {"epss_score": 0.66636, "epss_percentile": 0.98471}, "CVE-2016-2820": {"epss_score": 0.00421, "epss_percentile": 0.61486}, "CVE-2016-2821": {"epss_score": 0.02857, "epss_percentile": 0.85843}, "CVE-2016-2822": {"epss_score": 0.00697, "epss_percentile": 0.71405}, "CVE-2016-2824": {"epss_score": 0.00696, "epss_percentile": 0.71387}, "CVE-2016-2825": {"epss_score": 0.00522, "epss_percentile": 0.66261}, "CVE-2016-2826": {"epss_score": 0.00053, "epss_percentile": 0.16882}, "CVE-2016-2827": {"epss_score": 0.00647, "epss_percentile": 0.7019}, "CVE-2016-2828": {"epss_score": 0.02095, "epss_percentile": 0.83581}, "CVE-2016-2829": {"epss_score": 0.00369, "epss_percentile": 0.5826}, "CVE-2016-2830": {"epss_score": 0.00522, "epss_percentile": 0.6628}, "CVE-2016-2831": {"epss_score": 0.00668, "epss_percentile": 0.70728}, "CVE-2016-2832": {"epss_score": 0.00425, "epss_percentile": 0.61725}, "CVE-2016-2833": {"epss_score": 0.0026, "epss_percentile": 0.49234}, "CVE-2016-2834": {"epss_score": 0.0119, "epss_percentile": 0.78375}, "CVE-2016-2835": {"epss_score": 0.0062, "epss_percentile": 0.69447}, "CVE-2016-2836": {"epss_score": 0.00567, "epss_percentile": 0.67852}, "CVE-2016-2837": {"epss_score": 0.00458, "epss_percentile": 0.63396}, "CVE-2016-2838": {"epss_score": 0.03072, "epss_percentile": 0.86349}, "CVE-2016-2839": {"epss_score": 0.00907, "epss_percentile": 0.75269}, "CVE-2016-2840": {"epss_score": 0.00627, "epss_percentile": 0.69631}, "CVE-2016-2841": {"epss_score": 0.00061, "epss_percentile": 0.19293}, "CVE-2016-2842": {"epss_score": 0.67559, "epss_percentile": 0.98513}, "CVE-2016-2843": {"epss_score": 0.00889, "epss_percentile": 0.75016}, "CVE-2016-2844": {"epss_score": 0.01985, "epss_percentile": 0.83156}, "CVE-2016-2845": {"epss_score": 0.00648, "epss_percentile": 0.70219}, "CVE-2016-2846": {"epss_score": 0.00194, "epss_percentile": 0.41597}, "CVE-2016-2847": {"epss_score": 0.00073, "epss_percentile": 0.22598}, "CVE-2016-2848": {"epss_score": 0.51276, "epss_percentile": 0.97773}, "CVE-2016-2849": {"epss_score": 0.00583, "epss_percentile": 0.68328}, "CVE-2016-2850": {"epss_score": 0.00431, "epss_percentile": 0.62092}, "CVE-2016-2851": {"epss_score": 0.23058, "epss_percentile": 0.95726}, "CVE-2016-2853": {"epss_score": 0.0022, "epss_percentile": 0.44618}, "CVE-2016-2854": {"epss_score": 0.00348, "epss_percentile": 0.56828}, "CVE-2016-2855": {"epss_score": 0.00025, "epss_percentile": 0.06107}, "CVE-2016-2856": {"epss_score": 0.00684, "epss_percentile": 0.71128}, "CVE-2016-2857": {"epss_score": 0.00058, "epss_percentile": 0.18408}, "CVE-2016-2858": {"epss_score": 0.00124, "epss_percentile": 0.32452}, "CVE-2016-2860": {"epss_score": 0.00252, "epss_percentile": 0.48381}, "CVE-2016-2861": {"epss_score": 0.00226, "epss_percentile": 0.45279}, "CVE-2016-2862": {"epss_score": 0.00427, "epss_percentile": 0.6188}, "CVE-2016-2863": {"epss_score": 0.00102, "epss_percentile": 0.28837}, "CVE-2016-2864": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-2865": {"epss_score": 0.00202, "epss_percentile": 0.424}, "CVE-2016-2866": {"epss_score": 0.00312, "epss_percentile": 0.54006}, "CVE-2016-2867": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2016-2868": {"epss_score": 0.00171, "epss_percentile": 0.38856}, "CVE-2016-2869": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-2870": {"epss_score": 0.00449, "epss_percentile": 0.6304}, "CVE-2016-2871": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2016-2872": {"epss_score": 0.00107, "epss_percentile": 0.29748}, "CVE-2016-2873": {"epss_score": 0.00574, "epss_percentile": 0.68094}, "CVE-2016-2874": {"epss_score": 0.00122, "epss_percentile": 0.32092}, "CVE-2016-2875": {"epss_score": 0.01224, "epss_percentile": 0.78677}, "CVE-2016-2876": {"epss_score": 0.01257, "epss_percentile": 0.78949}, "CVE-2016-2877": {"epss_score": 0.00045, "epss_percentile": 0.13808}, "CVE-2016-2878": {"epss_score": 0.00096, "epss_percentile": 0.27245}, "CVE-2016-2879": {"epss_score": 0.00021, "epss_percentile": 0.04733}, "CVE-2016-2880": {"epss_score": 0.00025, "epss_percentile": 0.06342}, "CVE-2016-2881": {"epss_score": 0.00147, "epss_percentile": 0.358}, "CVE-2016-2882": {"epss_score": 0.00155, "epss_percentile": 0.36807}, "CVE-2016-2883": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-2884": {"epss_score": 0.00096, "epss_percentile": 0.27327}, "CVE-2016-2887": {"epss_score": 0.00154, "epss_percentile": 0.36698}, "CVE-2016-2888": {"epss_score": 0.00213, "epss_percentile": 0.43923}, "CVE-2016-2889": {"epss_score": 0.00105, "epss_percentile": 0.29371}, "CVE-2016-2894": {"epss_score": 0.00055, "epss_percentile": 0.17562}, "CVE-2016-2901": {"epss_score": 0.00142, "epss_percentile": 0.35012}, "CVE-2016-2908": {"epss_score": 0.00949, "epss_percentile": 0.75845}, "CVE-2016-2912": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-2914": {"epss_score": 0.01129, "epss_percentile": 0.77835}, "CVE-2016-2917": {"epss_score": 0.00511, "epss_percentile": 0.65823}, "CVE-2016-2922": {"epss_score": 0.00203, "epss_percentile": 0.42567}, "CVE-2016-2923": {"epss_score": 0.00278, "epss_percentile": 0.50876}, "CVE-2016-2924": {"epss_score": 0.00158, "epss_percentile": 0.37189}, "CVE-2016-2925": {"epss_score": 0.00136, "epss_percentile": 0.34057}, "CVE-2016-2926": {"epss_score": 0.00541, "epss_percentile": 0.67057}, "CVE-2016-2927": {"epss_score": 0.00176, "epss_percentile": 0.39436}, "CVE-2016-2928": {"epss_score": 0.00184, "epss_percentile": 0.40371}, "CVE-2016-2929": {"epss_score": 0.00449, "epss_percentile": 0.63032}, "CVE-2016-2930": {"epss_score": 0.00266, "epss_percentile": 0.4988}, "CVE-2016-2931": {"epss_score": 0.00234, "epss_percentile": 0.46122}, "CVE-2016-2932": {"epss_score": 0.00293, "epss_percentile": 0.52316}, "CVE-2016-2933": {"epss_score": 0.00628, "epss_percentile": 0.69657}, "CVE-2016-2934": {"epss_score": 0.00264, "epss_percentile": 0.49725}, "CVE-2016-2935": {"epss_score": 0.00659, "epss_percentile": 0.70499}, "CVE-2016-2936": {"epss_score": 0.00199, "epss_percentile": 0.42144}, "CVE-2016-2937": {"epss_score": 0.00227, "epss_percentile": 0.45423}, "CVE-2016-2938": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2016-2939": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2016-2940": {"epss_score": 0.00266, "epss_percentile": 0.49904}, "CVE-2016-2941": {"epss_score": 0.00073, "epss_percentile": 0.22523}, "CVE-2016-2942": {"epss_score": 0.00236, "epss_percentile": 0.46443}, "CVE-2016-2943": {"epss_score": 0.00047, "epss_percentile": 0.1483}, "CVE-2016-2944": {"epss_score": 0.00498, "epss_percentile": 0.65219}, "CVE-2016-2945": {"epss_score": 0.00633, "epss_percentile": 0.69756}, "CVE-2016-2946": {"epss_score": 0.0005, "epss_percentile": 0.15699}, "CVE-2016-2947": {"epss_score": 0.00178, "epss_percentile": 0.39711}, "CVE-2016-2948": {"epss_score": 0.00047, "epss_percentile": 0.14875}, "CVE-2016-2949": {"epss_score": 0.00049, "epss_percentile": 0.15452}, "CVE-2016-2950": {"epss_score": 0.00222, "epss_percentile": 0.44772}, "CVE-2016-2951": {"epss_score": 0.00143, "epss_percentile": 0.35189}, "CVE-2016-2952": {"epss_score": 0.00266, "epss_percentile": 0.49904}, "CVE-2016-2953": {"epss_score": 0.0024, "epss_percentile": 0.46961}, "CVE-2016-2954": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-2955": {"epss_score": 0.00154, "epss_percentile": 0.36683}, "CVE-2016-2956": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-2957": {"epss_score": 0.00161, "epss_percentile": 0.37589}, "CVE-2016-2958": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2016-2959": {"epss_score": 0.00242, "epss_percentile": 0.47404}, "CVE-2016-2960": {"epss_score": 0.00676, "epss_percentile": 0.70944}, "CVE-2016-2961": {"epss_score": 0.00168, "epss_percentile": 0.38521}, "CVE-2016-2963": {"epss_score": 0.00114, "epss_percentile": 0.30846}, "CVE-2016-2964": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2016-2965": {"epss_score": 0.00152, "epss_percentile": 0.36376}, "CVE-2016-2966": {"epss_score": 0.00212, "epss_percentile": 0.43805}, "CVE-2016-2967": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-2968": {"epss_score": 0.00171, "epss_percentile": 0.38799}, "CVE-2016-2969": {"epss_score": 0.00235, "epss_percentile": 0.46344}, "CVE-2016-2970": {"epss_score": 0.00264, "epss_percentile": 0.49729}, "CVE-2016-2971": {"epss_score": 0.00247, "epss_percentile": 0.4782}, "CVE-2016-2972": {"epss_score": 0.00064, "epss_percentile": 0.20157}, "CVE-2016-2973": {"epss_score": 0.00272, "epss_percentile": 0.50402}, "CVE-2016-2974": {"epss_score": 0.00063, "epss_percentile": 0.19892}, "CVE-2016-2975": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-2976": {"epss_score": 0.00212, "epss_percentile": 0.43747}, "CVE-2016-2977": {"epss_score": 0.00242, "epss_percentile": 0.47404}, "CVE-2016-2978": {"epss_score": 0.00054, "epss_percentile": 0.171}, "CVE-2016-2979": {"epss_score": 0.00359, "epss_percentile": 0.57542}, "CVE-2016-2980": {"epss_score": 0.00315, "epss_percentile": 0.54205}, "CVE-2016-2981": {"epss_score": 0.00054, "epss_percentile": 0.17228}, "CVE-2016-2983": {"epss_score": 0.00529, "epss_percentile": 0.66603}, "CVE-2016-2984": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2016-2985": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2016-2986": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-2987": {"epss_score": 0.00179, "epss_percentile": 0.39783}, "CVE-2016-2988": {"epss_score": 0.00326, "epss_percentile": 0.55061}, "CVE-2016-2989": {"epss_score": 0.0022, "epss_percentile": 0.44596}, "CVE-2016-2991": {"epss_score": 0.00154, "epss_percentile": 0.36683}, "CVE-2016-2992": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-2994": {"epss_score": 0.00154, "epss_percentile": 0.36683}, "CVE-2016-2995": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-2996": {"epss_score": 0.0015, "epss_percentile": 0.36125}, "CVE-2016-2997": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-2998": {"epss_score": 0.00048, "epss_percentile": 0.14978}, "CVE-2016-2999": {"epss_score": 0.00228, "epss_percentile": 0.4547}, "CVE-2016-3000": {"epss_score": 0.0042, "epss_percentile": 0.61423}, "CVE-2016-3001": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-3002": {"epss_score": 0.00063, "epss_percentile": 0.19892}, "CVE-2016-3003": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-3004": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-3005": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-3006": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-3007": {"epss_score": 0.00115, "epss_percentile": 0.30931}, "CVE-2016-3008": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-3009": {"epss_score": 0.00044, "epss_percentile": 0.13507}, "CVE-2016-3010": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-3012": {"epss_score": 0.00153, "epss_percentile": 0.36553}, "CVE-2016-3013": {"epss_score": 0.00531, "epss_percentile": 0.66646}, "CVE-2016-3014": {"epss_score": 0.00684, "epss_percentile": 0.71126}, "CVE-2016-3015": {"epss_score": 0.00258, "epss_percentile": 0.49}, "CVE-2016-3016": {"epss_score": 0.00084, "epss_percentile": 0.24889}, "CVE-2016-3017": {"epss_score": 0.0025, "epss_percentile": 0.48111}, "CVE-2016-3018": {"epss_score": 0.00239, "epss_percentile": 0.46853}, "CVE-2016-3019": {"epss_score": 0.0013, "epss_percentile": 0.33224}, "CVE-2016-3020": {"epss_score": 0.00123, "epss_percentile": 0.32227}, "CVE-2016-3021": {"epss_score": 0.00073, "epss_percentile": 0.22591}, "CVE-2016-3022": {"epss_score": 0.0019, "epss_percentile": 0.41116}, "CVE-2016-3023": {"epss_score": 0.00296, "epss_percentile": 0.52574}, "CVE-2016-3024": {"epss_score": 0.00051, "epss_percentile": 0.16251}, "CVE-2016-3025": {"epss_score": 0.00536, "epss_percentile": 0.66862}, "CVE-2016-3027": {"epss_score": 0.0056, "epss_percentile": 0.67641}, "CVE-2016-3028": {"epss_score": 0.0057, "epss_percentile": 0.67951}, "CVE-2016-3029": {"epss_score": 0.00199, "epss_percentile": 0.42143}, "CVE-2016-3031": {"epss_score": 0.00258, "epss_percentile": 0.49}, "CVE-2016-3032": {"epss_score": 0.00243, "epss_percentile": 0.47433}, "CVE-2016-3033": {"epss_score": 0.00548, "epss_percentile": 0.67284}, "CVE-2016-3034": {"epss_score": 0.00024, "epss_percentile": 0.05817}, "CVE-2016-3035": {"epss_score": 0.00187, "epss_percentile": 0.40773}, "CVE-2016-3036": {"epss_score": 0.01175, "epss_percentile": 0.78257}, "CVE-2016-3037": {"epss_score": 0.00266, "epss_percentile": 0.49891}, "CVE-2016-3038": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-3039": {"epss_score": 0.00662, "epss_percentile": 0.70591}, "CVE-2016-3040": {"epss_score": 0.00113, "epss_percentile": 0.30605}, "CVE-2016-3042": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-3043": {"epss_score": 0.00207, "epss_percentile": 0.43117}, "CVE-2016-3044": {"epss_score": 0.0008, "epss_percentile": 0.24106}, "CVE-2016-3045": {"epss_score": 0.00187, "epss_percentile": 0.40773}, "CVE-2016-3046": {"epss_score": 0.00115, "epss_percentile": 0.31007}, "CVE-2016-3047": {"epss_score": 0.00092, "epss_percentile": 0.26588}, "CVE-2016-3048": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-3049": {"epss_score": 0.00182, "epss_percentile": 0.4025}, "CVE-2016-3051": {"epss_score": 0.00243, "epss_percentile": 0.47473}, "CVE-2016-3052": {"epss_score": 0.00207, "epss_percentile": 0.43164}, "CVE-2016-3053": {"epss_score": 0.03041, "epss_percentile": 0.86274}, "CVE-2016-3054": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-3055": {"epss_score": 0.00548, "epss_percentile": 0.67284}, "CVE-2016-3056": {"epss_score": 0.00241, "epss_percentile": 0.47285}, "CVE-2016-3057": {"epss_score": 0.00264, "epss_percentile": 0.49725}, "CVE-2016-3059": {"epss_score": 0.00056, "epss_percentile": 0.1768}, "CVE-2016-3060": {"epss_score": 0.00161, "epss_percentile": 0.37537}, "CVE-2016-3062": {"epss_score": 0.02512, "epss_percentile": 0.84976}, "CVE-2016-3063": {"epss_score": 0.00515, "epss_percentile": 0.66004}, "CVE-2016-3064": {"epss_score": 0.00253, "epss_percentile": 0.48487}, "CVE-2016-3065": {"epss_score": 0.01118, "epss_percentile": 0.77745}, "CVE-2016-3066": {"epss_score": 0.00276, "epss_percentile": 0.50756}, "CVE-2016-3067": {"epss_score": 0.0059, "epss_percentile": 0.68577}, "CVE-2016-3068": {"epss_score": 0.05001, "epss_percentile": 0.89378}, "CVE-2016-3069": {"epss_score": 0.0283, "epss_percentile": 0.85775}, "CVE-2016-3070": {"epss_score": 0.00072, "epss_percentile": 0.22369}, "CVE-2016-3071": {"epss_score": 0.00972, "epss_percentile": 0.76133}, "CVE-2016-3072": {"epss_score": 0.00855, "epss_percentile": 0.74462}, "CVE-2016-3074": {"epss_score": 0.54698, "epss_percentile": 0.97939}, "CVE-2016-3075": {"epss_score": 0.10879, "epss_percentile": 0.93144}, "CVE-2016-3076": {"epss_score": 0.00457, "epss_percentile": 0.63369}, "CVE-2016-3077": {"epss_score": 0.0039, "epss_percentile": 0.59557}, "CVE-2016-3078": {"epss_score": 0.47508, "epss_percentile": 0.9759}, "CVE-2016-3079": {"epss_score": 0.00431, "epss_percentile": 0.62042}, "CVE-2016-3080": {"epss_score": 0.00194, "epss_percentile": 0.41577}, "CVE-2016-3081": {"epss_score": 0.93973, "epss_percentile": 0.99877}, "CVE-2016-3082": {"epss_score": 0.34801, "epss_percentile": 0.96874}, "CVE-2016-3083": {"epss_score": 0.00206, "epss_percentile": 0.43003}, "CVE-2016-3084": {"epss_score": 0.00338, "epss_percentile": 0.56157}, "CVE-2016-3085": {"epss_score": 0.0027, "epss_percentile": 0.50199}, "CVE-2016-3086": {"epss_score": 0.00428, "epss_percentile": 0.61955}, "CVE-2016-3087": {"epss_score": 0.86541, "epss_percentile": 0.99387}, "CVE-2016-3088": {"epss_score": 0.94294, "epss_percentile": 0.99938}, "CVE-2016-3089": {"epss_score": 0.0087, "epss_percentile": 0.74707}, "CVE-2016-3090": {"epss_score": 0.02858, "epss_percentile": 0.85846}, "CVE-2016-3091": {"epss_score": 0.00563, "epss_percentile": 0.67718}, "CVE-2016-3092": {"epss_score": 0.36479, "epss_percentile": 0.9698}, "CVE-2016-3093": {"epss_score": 0.05255, "epss_percentile": 0.89666}, "CVE-2016-3094": {"epss_score": 0.00989, "epss_percentile": 0.76364}, "CVE-2016-3095": {"epss_score": 0.00045, "epss_percentile": 0.1396}, "CVE-2016-3096": {"epss_score": 0.00077, "epss_percentile": 0.2343}, "CVE-2016-3097": {"epss_score": 0.00206, "epss_percentile": 0.42782}, "CVE-2016-3098": {"epss_score": 0.00187, "epss_percentile": 0.40711}, "CVE-2016-3099": {"epss_score": 0.0028, "epss_percentile": 0.51079}, "CVE-2016-3100": {"epss_score": 0.00048, "epss_percentile": 0.1497}, "CVE-2016-3101": {"epss_score": 0.00178, "epss_percentile": 0.39744}, "CVE-2016-3102": {"epss_score": 0.00051, "epss_percentile": 0.16145}, "CVE-2016-3104": {"epss_score": 0.01286, "epss_percentile": 0.79183}, "CVE-2016-3105": {"epss_score": 0.0118, "epss_percentile": 0.78303}, "CVE-2016-3106": {"epss_score": 0.00245, "epss_percentile": 0.47675}, "CVE-2016-3107": {"epss_score": 0.00074, "epss_percentile": 0.22823}, "CVE-2016-3108": {"epss_score": 0.00041, "epss_percentile": 0.1236}, "CVE-2016-3109": {"epss_score": 0.28575, "epss_percentile": 0.96368}, "CVE-2016-3110": {"epss_score": 0.03218, "epss_percentile": 0.86667}, "CVE-2016-3111": {"epss_score": 0.00048, "epss_percentile": 0.14979}, "CVE-2016-3112": {"epss_score": 0.00421, "epss_percentile": 0.61475}, "CVE-2016-3113": {"epss_score": 0.04029, "epss_percentile": 0.88148}, "CVE-2016-3114": {"epss_score": 0.00159, "epss_percentile": 0.37386}, "CVE-2016-3115": {"epss_score": 0.43987, "epss_percentile": 0.97413}, "CVE-2016-3116": {"epss_score": 0.27583, "epss_percentile": 0.9626}, "CVE-2016-3118": {"epss_score": 0.00224, "epss_percentile": 0.44996}, "CVE-2016-3119": {"epss_score": 0.07199, "epss_percentile": 0.91316}, "CVE-2016-3120": {"epss_score": 0.03262, "epss_percentile": 0.86772}, "CVE-2016-3124": {"epss_score": 0.00203, "epss_percentile": 0.42499}, "CVE-2016-3125": {"epss_score": 0.01371, "epss_percentile": 0.79811}, "CVE-2016-3126": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-3127": {"epss_score": 0.00152, "epss_percentile": 0.36423}, "CVE-2016-3128": {"epss_score": 0.00253, "epss_percentile": 0.48479}, "CVE-2016-3129": {"epss_score": 0.01932, "epss_percentile": 0.82942}, "CVE-2016-3130": {"epss_score": 0.00344, "epss_percentile": 0.56523}, "CVE-2016-3131": {"epss_score": 0.00146, "epss_percentile": 0.35545}, "CVE-2016-3132": {"epss_score": 0.11333, "epss_percentile": 0.93313}, "CVE-2016-3134": {"epss_score": 0.00058, "epss_percentile": 0.18465}, "CVE-2016-3135": {"epss_score": 0.00131, "epss_percentile": 0.3345}, "CVE-2016-3136": {"epss_score": 0.00202, "epss_percentile": 0.42405}, "CVE-2016-3137": {"epss_score": 0.00021, "epss_percentile": 0.04871}, "CVE-2016-3138": {"epss_score": 0.00016, "epss_percentile": 0.02921}, "CVE-2016-3139": {"epss_score": 0.00126, "epss_percentile": 0.32751}, "CVE-2016-3140": {"epss_score": 0.0016, "epss_percentile": 0.37426}, "CVE-2016-3141": {"epss_score": 0.34896, "epss_percentile": 0.96877}, "CVE-2016-3142": {"epss_score": 0.03335, "epss_percentile": 0.86933}, "CVE-2016-3144": {"epss_score": 0.00221, "epss_percentile": 0.44637}, "CVE-2016-3145": {"epss_score": 0.00063, "epss_percentile": 0.19948}, "CVE-2016-3147": {"epss_score": 0.06074, "epss_percentile": 0.90454}, "CVE-2016-3149": {"epss_score": 0.14222, "epss_percentile": 0.94166}, "CVE-2016-3150": {"epss_score": 0.00278, "epss_percentile": 0.50866}, "CVE-2016-3151": {"epss_score": 0.00666, "epss_percentile": 0.70695}, "CVE-2016-3152": {"epss_score": 0.00449, "epss_percentile": 0.63051}, "CVE-2016-3153": {"epss_score": 0.01459, "epss_percentile": 0.80413}, "CVE-2016-3154": {"epss_score": 0.01459, "epss_percentile": 0.80413}, "CVE-2016-3155": {"epss_score": 0.00041, "epss_percentile": 0.12225}, "CVE-2016-3156": {"epss_score": 0.00019, "epss_percentile": 0.04324}, "CVE-2016-3157": {"epss_score": 0.00356, "epss_percentile": 0.57354}, "CVE-2016-3158": {"epss_score": 0.00036, "epss_percentile": 0.10344}, "CVE-2016-3159": {"epss_score": 0.00037, "epss_percentile": 0.10665}, "CVE-2016-3161": {"epss_score": 0.00137, "epss_percentile": 0.34265}, "CVE-2016-3162": {"epss_score": 0.00294, "epss_percentile": 0.5241}, "CVE-2016-3163": {"epss_score": 0.00855, "epss_percentile": 0.7447}, "CVE-2016-3164": {"epss_score": 0.007, "epss_percentile": 0.71472}, "CVE-2016-3165": {"epss_score": 0.00607, "epss_percentile": 0.69057}, "CVE-2016-3166": {"epss_score": 0.00497, "epss_percentile": 0.65211}, "CVE-2016-3167": {"epss_score": 0.00632, "epss_percentile": 0.69749}, "CVE-2016-3168": {"epss_score": 0.00535, "epss_percentile": 0.66829}, "CVE-2016-3169": {"epss_score": 0.01016, "epss_percentile": 0.76671}, "CVE-2016-3170": {"epss_score": 0.00498, "epss_percentile": 0.65228}, "CVE-2016-3171": {"epss_score": 0.08219, "epss_percentile": 0.91935}, "CVE-2016-3172": {"epss_score": 0.00504, "epss_percentile": 0.65547}, "CVE-2016-3173": {"epss_score": 0.00239, "epss_percentile": 0.46891}, "CVE-2016-3174": {"epss_score": 0.00201, "epss_percentile": 0.42381}, "CVE-2016-3176": {"epss_score": 0.00167, "epss_percentile": 0.38304}, "CVE-2016-3177": {"epss_score": 0.00193, "epss_percentile": 0.41461}, "CVE-2016-3178": {"epss_score": 0.00065, "epss_percentile": 0.20589}, "CVE-2016-3179": {"epss_score": 0.00065, "epss_percentile": 0.20589}, "CVE-2016-3180": {"epss_score": 0.00683, "epss_percentile": 0.71094}, "CVE-2016-3182": {"epss_score": 0.0057, "epss_percentile": 0.67945}, "CVE-2016-3183": {"epss_score": 0.00129, "epss_percentile": 0.33207}, "CVE-2016-3185": {"epss_score": 0.02434, "epss_percentile": 0.84735}, "CVE-2016-3186": {"epss_score": 0.00727, "epss_percentile": 0.721}, "CVE-2016-3187": {"epss_score": 0.0053, "epss_percentile": 0.66607}, "CVE-2016-3188": {"epss_score": 0.0053, "epss_percentile": 0.66607}, "CVE-2016-3189": {"epss_score": 0.23714, "epss_percentile": 0.95807}, "CVE-2016-3190": {"epss_score": 0.00701, "epss_percentile": 0.71486}, "CVE-2016-3191": {"epss_score": 0.11337, "epss_percentile": 0.93314}, "CVE-2016-3192": {"epss_score": 0.00196, "epss_percentile": 0.41749}, "CVE-2016-3193": {"epss_score": 0.00222, "epss_percentile": 0.4475}, "CVE-2016-3194": {"epss_score": 0.00296, "epss_percentile": 0.52621}, "CVE-2016-3195": {"epss_score": 0.00296, "epss_percentile": 0.52621}, "CVE-2016-3196": {"epss_score": 0.00468, "epss_percentile": 0.63893}, "CVE-2016-3198": {"epss_score": 0.34916, "epss_percentile": 0.96877}, "CVE-2016-3199": {"epss_score": 0.17078, "epss_percentile": 0.94771}, "CVE-2016-3201": {"epss_score": 0.29518, "epss_percentile": 0.9645}, "CVE-2016-3202": {"epss_score": 0.13185, "epss_percentile": 0.93895}, "CVE-2016-3203": {"epss_score": 0.49159, "epss_percentile": 0.97671}, "CVE-2016-3204": {"epss_score": 0.25422, "epss_percentile": 0.96026}, "CVE-2016-3205": {"epss_score": 0.14916, "epss_percentile": 0.94323}, "CVE-2016-3206": {"epss_score": 0.14916, "epss_percentile": 0.94323}, "CVE-2016-3207": {"epss_score": 0.13185, "epss_percentile": 0.93895}, "CVE-2016-3209": {"epss_score": 0.192, "epss_percentile": 0.95147}, "CVE-2016-3210": {"epss_score": 0.17936, "epss_percentile": 0.9493}, "CVE-2016-3211": {"epss_score": 0.17936, "epss_percentile": 0.9493}, "CVE-2016-3212": {"epss_score": 0.22386, "epss_percentile": 0.95629}, "CVE-2016-3213": {"epss_score": 0.78311, "epss_percentile": 0.98979}, "CVE-2016-3214": {"epss_score": 0.20463, "epss_percentile": 0.9535}, "CVE-2016-3215": {"epss_score": 0.36951, "epss_percentile": 0.97011}, "CVE-2016-3216": {"epss_score": 0.37546, "epss_percentile": 0.97053}, "CVE-2016-3218": {"epss_score": 0.00492, "epss_percentile": 0.65013}, "CVE-2016-3219": {"epss_score": 0.12622, "epss_percentile": 0.93732}, "CVE-2016-3220": {"epss_score": 0.14219, "epss_percentile": 0.94165}, "CVE-2016-3221": {"epss_score": 0.0193, "epss_percentile": 0.82936}, "CVE-2016-3222": {"epss_score": 0.69898, "epss_percentile": 0.98608}, "CVE-2016-3223": {"epss_score": 0.54795, "epss_percentile": 0.97945}, "CVE-2016-3225": {"epss_score": 0.22137, "epss_percentile": 0.956}, "CVE-2016-3226": {"epss_score": 0.13437, "epss_percentile": 0.93963}, "CVE-2016-3227": {"epss_score": 0.22529, "epss_percentile": 0.95648}, "CVE-2016-3228": {"epss_score": 0.33825, "epss_percentile": 0.96807}, "CVE-2016-3230": {"epss_score": 0.01376, "epss_percentile": 0.79837}, "CVE-2016-3231": {"epss_score": 0.03336, "epss_percentile": 0.86937}, "CVE-2016-3232": {"epss_score": 0.17789, "epss_percentile": 0.94905}, "CVE-2016-3233": {"epss_score": 0.29812, "epss_percentile": 0.96478}, "CVE-2016-3234": {"epss_score": 0.27164, "epss_percentile": 0.96214}, "CVE-2016-3235": {"epss_score": 0.81164, "epss_percentile": 0.99126}, "CVE-2016-3236": {"epss_score": 0.78002, "epss_percentile": 0.98964}, "CVE-2016-3237": {"epss_score": 0.24935, "epss_percentile": 0.9597}, "CVE-2016-3238": {"epss_score": 0.15154, "epss_percentile": 0.94374}, "CVE-2016-3239": {"epss_score": 0.00781, "epss_percentile": 0.73183}, "CVE-2016-3240": {"epss_score": 0.15015, "epss_percentile": 0.94343}, "CVE-2016-3241": {"epss_score": 0.16252, "epss_percentile": 0.94602}, "CVE-2016-3242": {"epss_score": 0.15015, "epss_percentile": 0.94343}, "CVE-2016-3243": {"epss_score": 0.16252, "epss_percentile": 0.94602}, "CVE-2016-3244": {"epss_score": 0.20014, "epss_percentile": 0.95275}, "CVE-2016-3245": {"epss_score": 0.12137, "epss_percentile": 0.93582}, "CVE-2016-3246": {"epss_score": 0.18282, "epss_percentile": 0.94988}, "CVE-2016-3247": {"epss_score": 0.50789, "epss_percentile": 0.97749}, "CVE-2016-3248": {"epss_score": 0.25179, "epss_percentile": 0.95994}, "CVE-2016-3249": {"epss_score": 0.01187, "epss_percentile": 0.78353}, "CVE-2016-3250": {"epss_score": 0.02646, "epss_percentile": 0.85331}, "CVE-2016-3251": {"epss_score": 0.14121, "epss_percentile": 0.94138}, "CVE-2016-3252": {"epss_score": 0.02653, "epss_percentile": 0.85351}, "CVE-2016-3254": {"epss_score": 0.00468, "epss_percentile": 0.63881}, "CVE-2016-3255": {"epss_score": 0.29474, "epss_percentile": 0.96445}, "CVE-2016-3256": {"epss_score": 0.04682, "epss_percentile": 0.89001}, "CVE-2016-3258": {"epss_score": 0.00219, "epss_percentile": 0.44496}, "CVE-2016-3259": {"epss_score": 0.27132, "epss_percentile": 0.9621}, "CVE-2016-3260": {"epss_score": 0.22641, "epss_percentile": 0.95663}, "CVE-2016-3261": {"epss_score": 0.20202, "epss_percentile": 0.95303}, "CVE-2016-3262": {"epss_score": 0.19061, "epss_percentile": 0.9512}, "CVE-2016-3263": {"epss_score": 0.19061, "epss_percentile": 0.9512}, "CVE-2016-3264": {"epss_score": 0.20455, "epss_percentile": 0.95347}, "CVE-2016-3265": {"epss_score": 0.25114, "epss_percentile": 0.95987}, "CVE-2016-3266": {"epss_score": 0.1012, "epss_percentile": 0.92858}, "CVE-2016-3267": {"epss_score": 0.22204, "epss_percentile": 0.95609}, "CVE-2016-3269": {"epss_score": 0.2258, "epss_percentile": 0.95653}, "CVE-2016-3270": {"epss_score": 0.16428, "epss_percentile": 0.94659}, "CVE-2016-3271": {"epss_score": 0.27979, "epss_percentile": 0.963}, "CVE-2016-3272": {"epss_score": 0.1256, "epss_percentile": 0.93716}, "CVE-2016-3273": {"epss_score": 0.22915, "epss_percentile": 0.95705}, "CVE-2016-3274": {"epss_score": 0.0717, "epss_percentile": 0.91297}, "CVE-2016-3276": {"epss_score": 0.07191, "epss_percentile": 0.91311}, "CVE-2016-3277": {"epss_score": 0.17384, "epss_percentile": 0.94843}, "CVE-2016-3278": {"epss_score": 0.2443, "epss_percentile": 0.95921}, "CVE-2016-3279": {"epss_score": 0.34384, "epss_percentile": 0.96845}, "CVE-2016-3280": {"epss_score": 0.30017, "epss_percentile": 0.96497}, "CVE-2016-3281": {"epss_score": 0.48354, "epss_percentile": 0.97632}, "CVE-2016-3282": {"epss_score": 0.54593, "epss_percentile": 0.97935}, "CVE-2016-3283": {"epss_score": 0.30017, "epss_percentile": 0.96497}, "CVE-2016-3284": {"epss_score": 0.30017, "epss_percentile": 0.96497}, "CVE-2016-3286": {"epss_score": 0.01187, "epss_percentile": 0.78353}, "CVE-2016-3287": {"epss_score": 0.00155, "epss_percentile": 0.36771}, "CVE-2016-3288": {"epss_score": 0.37236, "epss_percentile": 0.97029}, "CVE-2016-3289": {"epss_score": 0.31575, "epss_percentile": 0.96627}, "CVE-2016-3290": {"epss_score": 0.24718, "epss_percentile": 0.95948}, "CVE-2016-3291": {"epss_score": 0.02337, "epss_percentile": 0.84422}, "CVE-2016-3292": {"epss_score": 0.06429, "epss_percentile": 0.90753}, "CVE-2016-3293": {"epss_score": 0.31796, "epss_percentile": 0.96649}, "CVE-2016-3294": {"epss_score": 0.15015, "epss_percentile": 0.94343}, "CVE-2016-3295": {"epss_score": 0.22493, "epss_percentile": 0.95643}, "CVE-2016-3296": {"epss_score": 0.2363, "epss_percentile": 0.95796}, "CVE-2016-3297": {"epss_score": 0.19571, "epss_percentile": 0.9521}, "CVE-2016-3298": {"epss_score": 0.27734, "epss_percentile": 0.96278}, "CVE-2016-3299": {"epss_score": 0.07344, "epss_percentile": 0.91421}, "CVE-2016-3300": {"epss_score": 0.02079, "epss_percentile": 0.83527}, "CVE-2016-3301": {"epss_score": 0.53609, "epss_percentile": 0.97884}, "CVE-2016-3302": {"epss_score": 0.011, "epss_percentile": 0.77571}, "CVE-2016-3303": {"epss_score": 0.52976, "epss_percentile": 0.97851}, "CVE-2016-3304": {"epss_score": 0.52976, "epss_percentile": 0.97851}, "CVE-2016-3305": {"epss_score": 0.00646, "epss_percentile": 0.70152}, "CVE-2016-3306": {"epss_score": 0.00646, "epss_percentile": 0.70152}, "CVE-2016-3308": {"epss_score": 0.09424, "epss_percentile": 0.92541}, "CVE-2016-3309": {"epss_score": 0.60501, "epss_percentile": 0.98209}, "CVE-2016-3310": {"epss_score": 0.02025, "epss_percentile": 0.83313}, "CVE-2016-3311": {"epss_score": 0.01498, "epss_percentile": 0.80697}, "CVE-2016-3312": {"epss_score": 0.14263, "epss_percentile": 0.94175}, "CVE-2016-3313": {"epss_score": 0.50266, "epss_percentile": 0.9773}, "CVE-2016-3315": {"epss_score": 0.34655, "epss_percentile": 0.96864}, "CVE-2016-3316": {"epss_score": 0.50266, "epss_percentile": 0.9773}, "CVE-2016-3317": {"epss_score": 0.30017, "epss_percentile": 0.96497}, "CVE-2016-3318": {"epss_score": 0.30017, "epss_percentile": 0.96497}, "CVE-2016-3319": {"epss_score": 0.37191, "epss_percentile": 0.97026}, "CVE-2016-3320": {"epss_score": 0.10457, "epss_percentile": 0.92992}, "CVE-2016-3321": {"epss_score": 0.28678, "epss_percentile": 0.96377}, "CVE-2016-3322": {"epss_score": 0.23933, "epss_percentile": 0.95835}, "CVE-2016-3324": {"epss_score": 0.12327, "epss_percentile": 0.93642}, "CVE-2016-3325": {"epss_score": 0.18839, "epss_percentile": 0.95079}, "CVE-2016-3326": {"epss_score": 0.17405, "epss_percentile": 0.94846}, "CVE-2016-3327": {"epss_score": 0.32707, "epss_percentile": 0.96719}, "CVE-2016-3329": {"epss_score": 0.32707, "epss_percentile": 0.96719}, "CVE-2016-3330": {"epss_score": 0.20182, "epss_percentile": 0.953}, "CVE-2016-3331": {"epss_score": 0.23334, "epss_percentile": 0.95768}, "CVE-2016-3332": {"epss_score": 0.05377, "epss_percentile": 0.89803}, "CVE-2016-3333": {"epss_score": 0.05377, "epss_percentile": 0.89803}, "CVE-2016-3334": {"epss_score": 0.05377, "epss_percentile": 0.89803}, "CVE-2016-3335": {"epss_score": 0.05377, "epss_percentile": 0.89803}, "CVE-2016-3338": {"epss_score": 0.05377, "epss_percentile": 0.89803}, "CVE-2016-3340": {"epss_score": 0.05377, "epss_percentile": 0.89803}, "CVE-2016-3341": {"epss_score": 0.09799, "epss_percentile": 0.92707}, "CVE-2016-3342": {"epss_score": 0.05377, "epss_percentile": 0.89803}, "CVE-2016-3343": {"epss_score": 0.05377, "epss_percentile": 0.89803}, "CVE-2016-3344": {"epss_score": 0.0146, "epss_percentile": 0.80418}, "CVE-2016-3345": {"epss_score": 0.26851, "epss_percentile": 0.96185}, "CVE-2016-3346": {"epss_score": 0.00848, "epss_percentile": 0.74362}, "CVE-2016-3348": {"epss_score": 0.07685, "epss_percentile": 0.91626}, "CVE-2016-3349": {"epss_score": 0.01463, "epss_percentile": 0.80441}, "CVE-2016-3350": {"epss_score": 0.20182, "epss_percentile": 0.953}, "CVE-2016-3351": {"epss_score": 0.40288, "epss_percentile": 0.9721}, "CVE-2016-3352": {"epss_score": 0.3289, "epss_percentile": 0.96732}, "CVE-2016-3353": {"epss_score": 0.15207, "epss_percentile": 0.94384}, "CVE-2016-3354": {"epss_score": 0.0573, "epss_percentile": 0.9016}, "CVE-2016-3355": {"epss_score": 0.01463, "epss_percentile": 0.80441}, "CVE-2016-3356": {"epss_score": 0.20505, "epss_percentile": 0.95357}, "CVE-2016-3357": {"epss_score": 0.32411, "epss_percentile": 0.96695}, "CVE-2016-3358": {"epss_score": 0.28595, "epss_percentile": 0.9637}, "CVE-2016-3359": {"epss_score": 0.19792, "epss_percentile": 0.95242}, "CVE-2016-3360": {"epss_score": 0.17411, "epss_percentile": 0.94847}, "CVE-2016-3361": {"epss_score": 0.19792, "epss_percentile": 0.95242}, "CVE-2016-3362": {"epss_score": 0.19792, "epss_percentile": 0.95242}, "CVE-2016-3363": {"epss_score": 0.27582, "epss_percentile": 0.9626}, "CVE-2016-3364": {"epss_score": 0.19274, "epss_percentile": 0.95158}, "CVE-2016-3365": {"epss_score": 0.18988, "epss_percentile": 0.95107}, "CVE-2016-3366": {"epss_score": 0.10418, "epss_percentile": 0.92982}, "CVE-2016-3367": {"epss_score": 0.21341, "epss_percentile": 0.95503}, "CVE-2016-3368": {"epss_score": 0.24928, "epss_percentile": 0.95967}, "CVE-2016-3369": {"epss_score": 0.18807, "epss_percentile": 0.95073}, "CVE-2016-3370": {"epss_score": 0.18859, "epss_percentile": 0.9508}, "CVE-2016-3371": {"epss_score": 0.35261, "epss_percentile": 0.96897}, "CVE-2016-3372": {"epss_score": 0.00624, "epss_percentile": 0.69567}, "CVE-2016-3373": {"epss_score": 0.0947, "epss_percentile": 0.92561}, "CVE-2016-3374": {"epss_score": 0.32313, "epss_percentile": 0.96688}, "CVE-2016-3375": {"epss_score": 0.26763, "epss_percentile": 0.96174}, "CVE-2016-3376": {"epss_score": 0.19972, "epss_percentile": 0.95268}, "CVE-2016-3377": {"epss_score": 0.15015, "epss_percentile": 0.94343}, "CVE-2016-3378": {"epss_score": 0.03118, "epss_percentile": 0.86438}, "CVE-2016-3379": {"epss_score": 0.07631, "epss_percentile": 0.91584}, "CVE-2016-3381": {"epss_score": 0.20039, "epss_percentile": 0.95278}, "CVE-2016-3382": {"epss_score": 0.23334, "epss_percentile": 0.95768}, "CVE-2016-3383": {"epss_score": 0.1541, "epss_percentile": 0.94426}, "CVE-2016-3384": {"epss_score": 0.20673, "epss_percentile": 0.954}, "CVE-2016-3385": {"epss_score": 0.31255, "epss_percentile": 0.96604}, "CVE-2016-3386": {"epss_score": 0.77908, "epss_percentile": 0.98959}, "CVE-2016-3387": {"epss_score": 0.33345, "epss_percentile": 0.96765}, "CVE-2016-3388": {"epss_score": 0.47217, "epss_percentile": 0.97576}, "CVE-2016-3389": {"epss_score": 0.18978, "epss_percentile": 0.95105}, "CVE-2016-3390": {"epss_score": 0.22988, "epss_percentile": 0.95714}, "CVE-2016-3391": {"epss_score": 0.27405, "epss_percentile": 0.96243}, "CVE-2016-3392": {"epss_score": 0.0943, "epss_percentile": 0.92544}, "CVE-2016-3393": {"epss_score": 0.3242, "epss_percentile": 0.96699}, "CVE-2016-3396": {"epss_score": 0.32397, "epss_percentile": 0.96694}, "CVE-2016-3400": {"epss_score": 0.00737, "epss_percentile": 0.72323}, "CVE-2016-3401": {"epss_score": 0.00189, "epss_percentile": 0.40943}, "CVE-2016-3402": {"epss_score": 0.00336, "epss_percentile": 0.55932}, "CVE-2016-3403": {"epss_score": 0.00369, "epss_percentile": 0.58238}, "CVE-2016-3404": {"epss_score": 0.00398, "epss_percentile": 0.60056}, "CVE-2016-3405": {"epss_score": 0.00398, "epss_percentile": 0.60056}, "CVE-2016-3406": {"epss_score": 0.00159, "epss_percentile": 0.3736}, "CVE-2016-3407": {"epss_score": 0.00359, "epss_percentile": 0.57546}, "CVE-2016-3408": {"epss_score": 0.00296, "epss_percentile": 0.52621}, "CVE-2016-3409": {"epss_score": 0.00359, "epss_percentile": 0.57546}, "CVE-2016-3410": {"epss_score": 0.00359, "epss_percentile": 0.57546}, "CVE-2016-3411": {"epss_score": 0.10381, "epss_percentile": 0.92967}, "CVE-2016-3412": {"epss_score": 0.00296, "epss_percentile": 0.52621}, "CVE-2016-3413": {"epss_score": 0.00398, "epss_percentile": 0.60056}, "CVE-2016-3414": {"epss_score": 0.007, "epss_percentile": 0.71482}, "CVE-2016-3415": {"epss_score": 0.00475, "epss_percentile": 0.64241}, "CVE-2016-3416": {"epss_score": 0.00204, "epss_percentile": 0.42607}, "CVE-2016-3417": {"epss_score": 0.00177, "epss_percentile": 0.39619}, "CVE-2016-3418": {"epss_score": 0.00178, "epss_percentile": 0.39701}, "CVE-2016-3419": {"epss_score": 0.00158, "epss_percentile": 0.37169}, "CVE-2016-3420": {"epss_score": 0.00135, "epss_percentile": 0.34029}, "CVE-2016-3421": {"epss_score": 0.00327, "epss_percentile": 0.55138}, "CVE-2016-3422": {"epss_score": 0.03713, "epss_percentile": 0.87611}, "CVE-2016-3423": {"epss_score": 0.0014, "epss_percentile": 0.34731}, "CVE-2016-3424": {"epss_score": 0.00945, "epss_percentile": 0.75801}, "CVE-2016-3425": {"epss_score": 0.09098, "epss_percentile": 0.924}, "CVE-2016-3426": {"epss_score": 0.01336, "epss_percentile": 0.79553}, "CVE-2016-3427": {"epss_score": 0.93616, "epss_percentile": 0.99825}, "CVE-2016-3428": {"epss_score": 0.00307, "epss_percentile": 0.53566}, "CVE-2016-3429": {"epss_score": 0.00218, "epss_percentile": 0.44365}, "CVE-2016-3431": {"epss_score": 0.00135, "epss_percentile": 0.34029}, "CVE-2016-3432": {"epss_score": 0.00245, "epss_percentile": 0.47725}, "CVE-2016-3433": {"epss_score": 0.00245, "epss_percentile": 0.47725}, "CVE-2016-3434": {"epss_score": 0.00229, "epss_percentile": 0.45622}, "CVE-2016-3435": {"epss_score": 0.00414, "epss_percentile": 0.61037}, "CVE-2016-3436": {"epss_score": 0.00268, "epss_percentile": 0.50061}, "CVE-2016-3437": {"epss_score": 0.00268, "epss_percentile": 0.50061}, "CVE-2016-3438": {"epss_score": 0.0039, "epss_percentile": 0.5953}, "CVE-2016-3439": {"epss_score": 0.00268, "epss_percentile": 0.50061}, "CVE-2016-3440": {"epss_score": 0.01002, "epss_percentile": 0.76505}, "CVE-2016-3441": {"epss_score": 0.0023, "epss_percentile": 0.45685}, "CVE-2016-3442": {"epss_score": 0.00177, "epss_percentile": 0.39619}, "CVE-2016-3443": {"epss_score": 0.03399, "epss_percentile": 0.87066}, "CVE-2016-3444": {"epss_score": 0.05566, "epss_percentile": 0.90001}, "CVE-2016-3445": {"epss_score": 0.01453, "epss_percentile": 0.80376}, "CVE-2016-3446": {"epss_score": 0.00633, "epss_percentile": 0.69765}, "CVE-2016-3447": {"epss_score": 0.00237, "epss_percentile": 0.46719}, "CVE-2016-3448": {"epss_score": 0.00342, "epss_percentile": 0.56386}, "CVE-2016-3449": {"epss_score": 0.0409, "epss_percentile": 0.88236}, "CVE-2016-3450": {"epss_score": 0.00366, "epss_percentile": 0.58085}, "CVE-2016-3451": {"epss_score": 0.00399, "epss_percentile": 0.6011}, "CVE-2016-3452": {"epss_score": 0.03269, "epss_percentile": 0.86788}, "CVE-2016-3453": {"epss_score": 0.00105, "epss_percentile": 0.29296}, "CVE-2016-3454": {"epss_score": 0.01168, "epss_percentile": 0.78194}, "CVE-2016-3455": {"epss_score": 0.01024, "epss_percentile": 0.76777}, "CVE-2016-3456": {"epss_score": 0.00237, "epss_percentile": 0.46719}, "CVE-2016-3457": {"epss_score": 0.0014, "epss_percentile": 0.34731}, "CVE-2016-3458": {"epss_score": 0.023, "epss_percentile": 0.84308}, "CVE-2016-3459": {"epss_score": 0.00878, "epss_percentile": 0.74818}, "CVE-2016-3460": {"epss_score": 0.00135, "epss_percentile": 0.34029}, "CVE-2016-3461": {"epss_score": 0.00877, "epss_percentile": 0.74807}, "CVE-2016-3462": {"epss_score": 0.00052, "epss_percentile": 0.16471}, "CVE-2016-3463": {"epss_score": 0.00193, "epss_percentile": 0.41396}, "CVE-2016-3464": {"epss_score": 0.00188, "epss_percentile": 0.40807}, "CVE-2016-3465": {"epss_score": 0.00069, "epss_percentile": 0.21634}, "CVE-2016-3466": {"epss_score": 0.00239, "epss_percentile": 0.4691}, "CVE-2016-3467": {"epss_score": 0.00961, "epss_percentile": 0.7598}, "CVE-2016-3468": {"epss_score": 0.05566, "epss_percentile": 0.90001}, "CVE-2016-3469": {"epss_score": 0.00067, "epss_percentile": 0.21175}, "CVE-2016-3470": {"epss_score": 0.00244, "epss_percentile": 0.47566}, "CVE-2016-3471": {"epss_score": 0.0009, "epss_percentile": 0.26009}, "CVE-2016-3472": {"epss_score": 0.00278, "epss_percentile": 0.50921}, "CVE-2016-3473": {"epss_score": 0.028, "epss_percentile": 0.85693}, "CVE-2016-3474": {"epss_score": 0.00366, "epss_percentile": 0.58085}, "CVE-2016-3475": {"epss_score": 0.0026, "epss_percentile": 0.49193}, "CVE-2016-3476": {"epss_score": 0.00331, "epss_percentile": 0.55509}, "CVE-2016-3477": {"epss_score": 0.00115, "epss_percentile": 0.30948}, "CVE-2016-3478": {"epss_score": 0.00342, "epss_percentile": 0.56386}, "CVE-2016-3479": {"epss_score": 0.02176, "epss_percentile": 0.83884}, "CVE-2016-3480": {"epss_score": 0.00104, "epss_percentile": 0.29124}, "CVE-2016-3481": {"epss_score": 0.01046, "epss_percentile": 0.77028}, "CVE-2016-3482": {"epss_score": 0.00366, "epss_percentile": 0.58085}, "CVE-2016-3483": {"epss_score": 0.00637, "epss_percentile": 0.69878}, "CVE-2016-3484": {"epss_score": 0.00072, "epss_percentile": 0.2238}, "CVE-2016-3485": {"epss_score": 0.00043, "epss_percentile": 0.13075}, "CVE-2016-3486": {"epss_score": 0.02375, "epss_percentile": 0.84539}, "CVE-2016-3487": {"epss_score": 0.04887, "epss_percentile": 0.89256}, "CVE-2016-3488": {"epss_score": 0.00096, "epss_percentile": 0.27415}, "CVE-2016-3489": {"epss_score": 0.00088, "epss_percentile": 0.25697}, "CVE-2016-3490": {"epss_score": 0.00228, "epss_percentile": 0.45476}, "CVE-2016-3491": {"epss_score": 0.01568, "epss_percentile": 0.81077}, "CVE-2016-3492": {"epss_score": 0.01057, "epss_percentile": 0.77131}, "CVE-2016-3493": {"epss_score": 0.0338, "epss_percentile": 0.87028}, "CVE-2016-3494": {"epss_score": 0.01343, "epss_percentile": 0.79603}, "CVE-2016-3495": {"epss_score": 0.00739, "epss_percentile": 0.72387}, "CVE-2016-3496": {"epss_score": 0.0033, "epss_percentile": 0.55427}, "CVE-2016-3497": {"epss_score": 0.00175, "epss_percentile": 0.39355}, "CVE-2016-3498": {"epss_score": 0.07768, "epss_percentile": 0.91671}, "CVE-2016-3499": {"epss_score": 0.07404, "epss_percentile": 0.91455}, "CVE-2016-3500": {"epss_score": 0.08998, "epss_percentile": 0.92358}, "CVE-2016-3501": {"epss_score": 0.00709, "epss_percentile": 0.717}, "CVE-2016-3502": {"epss_score": 0.00447, "epss_percentile": 0.62941}, "CVE-2016-3503": {"epss_score": 0.00089, "epss_percentile": 0.25856}, "CVE-2016-3504": {"epss_score": 0.01607, "epss_percentile": 0.81308}, "CVE-2016-3505": {"epss_score": 0.01986, "epss_percentile": 0.83157}, "CVE-2016-3506": {"epss_score": 0.01827, "epss_percentile": 0.82436}, "CVE-2016-3507": {"epss_score": 0.00399, "epss_percentile": 0.6011}, "CVE-2016-3508": {"epss_score": 0.0725, "epss_percentile": 0.9135}, "CVE-2016-3509": {"epss_score": 0.00256, "epss_percentile": 0.48817}, "CVE-2016-3510": {"epss_score": 0.94011, "epss_percentile": 0.99885}, "CVE-2016-3511": {"epss_score": 0.00079, "epss_percentile": 0.23805}, "CVE-2016-3512": {"epss_score": 0.00411, "epss_percentile": 0.60852}, "CVE-2016-3513": {"epss_score": 0.00631, "epss_percentile": 0.69725}, "CVE-2016-3514": {"epss_score": 0.00631, "epss_percentile": 0.69725}, "CVE-2016-3515": {"epss_score": 0.01487, "epss_percentile": 0.80611}, "CVE-2016-3516": {"epss_score": 0.00198, "epss_percentile": 0.42087}, "CVE-2016-3517": {"epss_score": 0.00416, "epss_percentile": 0.612}, "CVE-2016-3518": {"epss_score": 0.01635, "epss_percentile": 0.8147}, "CVE-2016-3519": {"epss_score": 0.00342, "epss_percentile": 0.56386}, "CVE-2016-3520": {"epss_score": 0.0031, "epss_percentile": 0.53741}, "CVE-2016-3521": {"epss_score": 0.01117, "epss_percentile": 0.77742}, "CVE-2016-3522": {"epss_score": 0.00553, "epss_percentile": 0.67417}, "CVE-2016-3523": {"epss_score": 0.00399, "epss_percentile": 0.6011}, "CVE-2016-3524": {"epss_score": 0.00162, "epss_percentile": 0.37699}, "CVE-2016-3525": {"epss_score": 0.0066, "epss_percentile": 0.70531}, "CVE-2016-3526": {"epss_score": 0.00779, "epss_percentile": 0.73154}, "CVE-2016-3527": {"epss_score": 0.01364, "epss_percentile": 0.7977}, "CVE-2016-3528": {"epss_score": 0.02176, "epss_percentile": 0.83884}, "CVE-2016-3529": {"epss_score": 0.00319, "epss_percentile": 0.54476}, "CVE-2016-3530": {"epss_score": 0.00983, "epss_percentile": 0.76304}, "CVE-2016-3531": {"epss_score": 0.00269, "epss_percentile": 0.50167}, "CVE-2016-3532": {"epss_score": 0.00907, "epss_percentile": 0.75268}, "CVE-2016-3533": {"epss_score": 0.00794, "epss_percentile": 0.73457}, "CVE-2016-3534": {"epss_score": 0.00794, "epss_percentile": 0.73457}, "CVE-2016-3535": {"epss_score": 0.00907, "epss_percentile": 0.75268}, "CVE-2016-3536": {"epss_score": 0.00688, "epss_percentile": 0.71207}, "CVE-2016-3537": {"epss_score": 0.00274, "epss_percentile": 0.50539}, "CVE-2016-3538": {"epss_score": 0.00983, "epss_percentile": 0.76304}, "CVE-2016-3539": {"epss_score": 0.00983, "epss_percentile": 0.76304}, "CVE-2016-3540": {"epss_score": 0.00448, "epss_percentile": 0.62997}, "CVE-2016-3541": {"epss_score": 0.01364, "epss_percentile": 0.7977}, "CVE-2016-3542": {"epss_score": 0.2833, "epss_percentile": 0.96343}, "CVE-2016-3543": {"epss_score": 0.01364, "epss_percentile": 0.7977}, "CVE-2016-3544": {"epss_score": 0.00274, "epss_percentile": 0.50537}, "CVE-2016-3545": {"epss_score": 0.00415, "epss_percentile": 0.61114}, "CVE-2016-3546": {"epss_score": 0.01364, "epss_percentile": 0.7977}, "CVE-2016-3547": {"epss_score": 0.00433, "epss_percentile": 0.62187}, "CVE-2016-3548": {"epss_score": 0.00433, "epss_percentile": 0.62187}, "CVE-2016-3549": {"epss_score": 0.00433, "epss_percentile": 0.62187}, "CVE-2016-3550": {"epss_score": 0.01984, "epss_percentile": 0.83152}, "CVE-2016-3551": {"epss_score": 0.03765, "epss_percentile": 0.87695}, "CVE-2016-3552": {"epss_score": 0.00057, "epss_percentile": 0.18108}, "CVE-2016-3553": {"epss_score": 0.00248, "epss_percentile": 0.47914}, "CVE-2016-3554": {"epss_score": 0.02433, "epss_percentile": 0.84733}, "CVE-2016-3555": {"epss_score": 0.00342, "epss_percentile": 0.56386}, "CVE-2016-3556": {"epss_score": 0.03925, "epss_percentile": 0.87962}, "CVE-2016-3557": {"epss_score": 0.00236, "epss_percentile": 0.46435}, "CVE-2016-3558": {"epss_score": 0.00416, "epss_percentile": 0.612}, "CVE-2016-3559": {"epss_score": 0.00416, "epss_percentile": 0.612}, "CVE-2016-3560": {"epss_score": 0.0032, "epss_percentile": 0.54583}, "CVE-2016-3561": {"epss_score": 0.00661, "epss_percentile": 0.70562}, "CVE-2016-3562": {"epss_score": 0.00246, "epss_percentile": 0.47742}, "CVE-2016-3563": {"epss_score": 0.00107, "epss_percentile": 0.29634}, "CVE-2016-3564": {"epss_score": 0.01925, "epss_percentile": 0.82918}, "CVE-2016-3565": {"epss_score": 0.00517, "epss_percentile": 0.66074}, "CVE-2016-3566": {"epss_score": 0.00328, "epss_percentile": 0.55191}, "CVE-2016-3567": {"epss_score": 0.00245, "epss_percentile": 0.47725}, "CVE-2016-3568": {"epss_score": 0.00328, "epss_percentile": 0.55191}, "CVE-2016-3569": {"epss_score": 0.00328, "epss_percentile": 0.55191}, "CVE-2016-3570": {"epss_score": 0.00328, "epss_percentile": 0.55191}, "CVE-2016-3571": {"epss_score": 0.00328, "epss_percentile": 0.55191}, "CVE-2016-3572": {"epss_score": 0.00237, "epss_percentile": 0.46712}, "CVE-2016-3573": {"epss_score": 0.00328, "epss_percentile": 0.55191}, "CVE-2016-3574": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3575": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3576": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3577": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3578": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3579": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3580": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3581": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3582": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3583": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3584": {"epss_score": 0.00088, "epss_percentile": 0.25744}, "CVE-2016-3585": {"epss_score": 0.00342, "epss_percentile": 0.56368}, "CVE-2016-3586": {"epss_score": 0.11573, "epss_percentile": 0.93408}, "CVE-2016-3587": {"epss_score": 0.07294, "epss_percentile": 0.91388}, "CVE-2016-3588": {"epss_score": 0.00589, "epss_percentile": 0.68524}, "CVE-2016-3589": {"epss_score": 0.00342, "epss_percentile": 0.56386}, "CVE-2016-3590": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3591": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3592": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3593": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3594": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3595": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3596": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2016-3597": {"epss_score": 0.00074, "epss_percentile": 0.22735}, "CVE-2016-3598": {"epss_score": 0.08525, "epss_percentile": 0.92102}, "CVE-2016-3606": {"epss_score": 0.0432, "epss_percentile": 0.88543}, "CVE-2016-3607": {"epss_score": 0.04552, "epss_percentile": 0.88841}, "CVE-2016-3608": {"epss_score": 0.00348, "epss_percentile": 0.56816}, "CVE-2016-3609": {"epss_score": 0.01397, "epss_percentile": 0.79982}, "CVE-2016-3610": {"epss_score": 0.0679, "epss_percentile": 0.91028}, "CVE-2016-3611": {"epss_score": 0.00342, "epss_percentile": 0.56386}, "CVE-2016-3612": {"epss_score": 0.00338, "epss_percentile": 0.56117}, "CVE-2016-3613": {"epss_score": 0.05236, "epss_percentile": 0.89648}, "CVE-2016-3614": {"epss_score": 0.00497, "epss_percentile": 0.65201}, "CVE-2016-3615": {"epss_score": 0.01847, "epss_percentile": 0.82524}, "CVE-2016-3616": {"epss_score": 0.01404, "epss_percentile": 0.80036}, "CVE-2016-3619": {"epss_score": 0.00918, "epss_percentile": 0.75451}, "CVE-2016-3620": {"epss_score": 0.00589, "epss_percentile": 0.68513}, "CVE-2016-3621": {"epss_score": 0.00676, "epss_percentile": 0.70916}, "CVE-2016-3622": {"epss_score": 0.00912, "epss_percentile": 0.75357}, "CVE-2016-3623": {"epss_score": 0.01585, "epss_percentile": 0.81166}, "CVE-2016-3624": {"epss_score": 0.01333, "epss_percentile": 0.79528}, "CVE-2016-3625": {"epss_score": 0.00636, "epss_percentile": 0.69833}, "CVE-2016-3627": {"epss_score": 0.00163, "epss_percentile": 0.37863}, "CVE-2016-3628": {"epss_score": 0.02863, "epss_percentile": 0.85854}, "CVE-2016-3630": {"epss_score": 0.05192, "epss_percentile": 0.89596}, "CVE-2016-3631": {"epss_score": 0.0079, "epss_percentile": 0.73378}, "CVE-2016-3632": {"epss_score": 0.00481, "epss_percentile": 0.64513}, "CVE-2016-3633": {"epss_score": 0.00452, "epss_percentile": 0.63197}, "CVE-2016-3634": {"epss_score": 0.00693, "epss_percentile": 0.71321}, "CVE-2016-3635": {"epss_score": 0.00592, "epss_percentile": 0.68612}, "CVE-2016-3638": {"epss_score": 0.00085, "epss_percentile": 0.25137}, "CVE-2016-3639": {"epss_score": 0.00358, "epss_percentile": 0.57512}, "CVE-2016-3640": {"epss_score": 0.0011, "epss_percentile": 0.30129}, "CVE-2016-3642": {"epss_score": 0.22376, "epss_percentile": 0.95627}, "CVE-2016-3643": {"epss_score": 0.05418, "epss_percentile": 0.89853}, "CVE-2016-3644": {"epss_score": 0.29018, "epss_percentile": 0.96412}, "CVE-2016-3645": {"epss_score": 0.75552, "epss_percentile": 0.98853}, "CVE-2016-3646": {"epss_score": 0.25975, "epss_percentile": 0.96097}, "CVE-2016-3647": {"epss_score": 0.00235, "epss_percentile": 0.46322}, "CVE-2016-3648": {"epss_score": 0.00608, "epss_percentile": 0.69081}, "CVE-2016-3649": {"epss_score": 0.00255, "epss_percentile": 0.48634}, "CVE-2016-3650": {"epss_score": 0.00468, "epss_percentile": 0.63884}, "CVE-2016-3651": {"epss_score": 0.01486, "epss_percentile": 0.80606}, "CVE-2016-3652": {"epss_score": 0.0091, "epss_percentile": 0.75315}, "CVE-2016-3653": {"epss_score": 0.00159, "epss_percentile": 0.37331}, "CVE-2016-3654": {"epss_score": 0.00518, "epss_percentile": 0.66129}, "CVE-2016-3655": {"epss_score": 0.01314, "epss_percentile": 0.79395}, "CVE-2016-3656": {"epss_score": 0.0062, "epss_percentile": 0.69447}, "CVE-2016-3657": {"epss_score": 0.0303, "epss_percentile": 0.86247}, "CVE-2016-3658": {"epss_score": 0.00951, "epss_percentile": 0.75864}, "CVE-2016-3659": {"epss_score": 0.00587, "epss_percentile": 0.68468}, "CVE-2016-3664": {"epss_score": 0.0018, "epss_percentile": 0.39928}, "CVE-2016-3670": {"epss_score": 0.0929, "epss_percentile": 0.92486}, "CVE-2016-3672": {"epss_score": 0.00031, "epss_percentile": 0.085}, "CVE-2016-3674": {"epss_score": 0.02859, "epss_percentile": 0.85847}, "CVE-2016-3675": {"epss_score": 0.00084, "epss_percentile": 0.24986}, "CVE-2016-3676": {"epss_score": 0.00045, "epss_percentile": 0.13798}, "CVE-2016-3677": {"epss_score": 0.0003, "epss_percentile": 0.08241}, "CVE-2016-3678": {"epss_score": 0.00281, "epss_percentile": 0.51134}, "CVE-2016-3679": {"epss_score": 0.00883, "epss_percentile": 0.74921}, "CVE-2016-3680": {"epss_score": 0.00064, "epss_percentile": 0.20281}, "CVE-2016-3681": {"epss_score": 0.00064, "epss_percentile": 0.20281}, "CVE-2016-3684": {"epss_score": 0.00072, "epss_percentile": 0.22293}, "CVE-2016-3685": {"epss_score": 0.00044, "epss_percentile": 0.13579}, "CVE-2016-3686": {"epss_score": 0.00495, "epss_percentile": 0.65122}, "CVE-2016-3687": {"epss_score": 0.00373, "epss_percentile": 0.58467}, "CVE-2016-3688": {"epss_score": 0.00111, "epss_percentile": 0.30385}, "CVE-2016-3689": {"epss_score": 0.00087, "epss_percentile": 0.25633}, "CVE-2016-3690": {"epss_score": 0.01894, "epss_percentile": 0.82743}, "CVE-2016-3691": {"epss_score": 0.00112, "epss_percentile": 0.30563}, "CVE-2016-3693": {"epss_score": 0.00732, "epss_percentile": 0.72193}, "CVE-2016-3694": {"epss_score": 0.01178, "epss_percentile": 0.78285}, "CVE-2016-3695": {"epss_score": 0.00114, "epss_percentile": 0.30831}, "CVE-2016-3696": {"epss_score": 0.00053, "epss_percentile": 0.1693}, "CVE-2016-3697": {"epss_score": 0.00092, "epss_percentile": 0.26423}, "CVE-2016-3698": {"epss_score": 0.02062, "epss_percentile": 0.83444}, "CVE-2016-3699": {"epss_score": 0.00038, "epss_percentile": 0.11339}, "CVE-2016-3702": {"epss_score": 0.0018, "epss_percentile": 0.39893}, "CVE-2016-3703": {"epss_score": 0.00142, "epss_percentile": 0.34962}, "CVE-2016-3704": {"epss_score": 0.00543, "epss_percentile": 0.67103}, "CVE-2016-3705": {"epss_score": 0.01034, "epss_percentile": 0.76884}, "CVE-2016-3706": {"epss_score": 0.02438, "epss_percentile": 0.84745}, "CVE-2016-3707": {"epss_score": 0.01788, "epss_percentile": 0.82267}, "CVE-2016-3708": {"epss_score": 0.00132, "epss_percentile": 0.33533}, "CVE-2016-3709": {"epss_score": 0.00132, "epss_percentile": 0.33547}, "CVE-2016-3710": {"epss_score": 0.00103, "epss_percentile": 0.29041}, "CVE-2016-3711": {"epss_score": 0.00048, "epss_percentile": 0.1512}, "CVE-2016-3712": {"epss_score": 0.00106, "epss_percentile": 0.29401}, "CVE-2016-3713": {"epss_score": 0.00059, "epss_percentile": 0.18705}, "CVE-2016-3714": {"epss_score": 0.93579, "epss_percentile": 0.9982}, "CVE-2016-3715": {"epss_score": 0.79798, "epss_percentile": 0.99056}, "CVE-2016-3716": {"epss_score": 0.17347, "epss_percentile": 0.94832}, "CVE-2016-3717": {"epss_score": 0.2622, "epss_percentile": 0.96125}, "CVE-2016-3718": {"epss_score": 0.79254, "epss_percentile": 0.99027}, "CVE-2016-3720": {"epss_score": 0.0009, "epss_percentile": 0.26044}, "CVE-2016-3721": {"epss_score": 0.00194, "epss_percentile": 0.41555}, "CVE-2016-3722": {"epss_score": 0.00224, "epss_percentile": 0.44968}, "CVE-2016-3723": {"epss_score": 0.00079, "epss_percentile": 0.23808}, "CVE-2016-3724": {"epss_score": 0.00279, "epss_percentile": 0.5098}, "CVE-2016-3725": {"epss_score": 0.00184, "epss_percentile": 0.40412}, "CVE-2016-3726": {"epss_score": 0.00091, "epss_percentile": 0.26399}, "CVE-2016-3727": {"epss_score": 0.00099, "epss_percentile": 0.28385}, "CVE-2016-3728": {"epss_score": 0.04491, "epss_percentile": 0.88758}, "CVE-2016-3729": {"epss_score": 0.00379, "epss_percentile": 0.58889}, "CVE-2016-3731": {"epss_score": 0.00371, "epss_percentile": 0.58365}, "CVE-2016-3732": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2016-3733": {"epss_score": 0.00442, "epss_percentile": 0.6273}, "CVE-2016-3734": {"epss_score": 0.00093, "epss_percentile": 0.26636}, "CVE-2016-3735": {"epss_score": 0.01888, "epss_percentile": 0.8272}, "CVE-2016-3737": {"epss_score": 0.00609, "epss_percentile": 0.69128}, "CVE-2016-3738": {"epss_score": 0.00736, "epss_percentile": 0.72302}, "CVE-2016-3739": {"epss_score": 0.01068, "epss_percentile": 0.77238}, "CVE-2016-3740": {"epss_score": 0.01279, "epss_percentile": 0.79133}, "CVE-2016-3741": {"epss_score": 0.01167, "epss_percentile": 0.78188}, "CVE-2016-3742": {"epss_score": 0.00733, "epss_percentile": 0.72216}, "CVE-2016-3743": {"epss_score": 0.00733, "epss_percentile": 0.72216}, "CVE-2016-3744": {"epss_score": 0.00154, "epss_percentile": 0.36696}, "CVE-2016-3745": {"epss_score": 0.00182, "epss_percentile": 0.40154}, "CVE-2016-3746": {"epss_score": 0.00072, "epss_percentile": 0.22273}, "CVE-2016-3747": {"epss_score": 0.00068, "epss_percentile": 0.21403}, "CVE-2016-3748": {"epss_score": 0.00067, "epss_percentile": 0.21015}, "CVE-2016-3749": {"epss_score": 0.00019, "epss_percentile": 0.0425}, "CVE-2016-3750": {"epss_score": 0.0003, "epss_percentile": 0.0808}, "CVE-2016-3751": {"epss_score": 0.00135, "epss_percentile": 0.3394}, "CVE-2016-3752": {"epss_score": 0.00061, "epss_percentile": 0.19412}, "CVE-2016-3753": {"epss_score": 0.00172, "epss_percentile": 0.38981}, "CVE-2016-3754": {"epss_score": 0.00732, "epss_percentile": 0.72201}, "CVE-2016-3755": {"epss_score": 0.0034, "epss_percentile": 0.56244}, "CVE-2016-3756": {"epss_score": 0.0034, "epss_percentile": 0.56244}, "CVE-2016-3757": {"epss_score": 0.00014, "epss_percentile": 0.01845}, "CVE-2016-3758": {"epss_score": 0.00046, "epss_percentile": 0.14395}, "CVE-2016-3759": {"epss_score": 0.00061, "epss_percentile": 0.19357}, "CVE-2016-3760": {"epss_score": 0.00053, "epss_percentile": 0.1683}, "CVE-2016-3761": {"epss_score": 0.00018, "epss_percentile": 0.04025}, "CVE-2016-3762": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3763": {"epss_score": 0.00113, "epss_percentile": 0.30633}, "CVE-2016-3764": {"epss_score": 0.00058, "epss_percentile": 0.18299}, "CVE-2016-3765": {"epss_score": 0.00062, "epss_percentile": 0.19779}, "CVE-2016-3766": {"epss_score": 0.00732, "epss_percentile": 0.72201}, "CVE-2016-3767": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3768": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3769": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3770": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3771": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3772": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3773": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3774": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3775": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-3792": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3793": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3795": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3796": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3797": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-3798": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3799": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3800": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3801": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3802": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-3803": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-3804": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3805": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3806": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3807": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3808": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3809": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-3810": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-3811": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3812": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-3813": {"epss_score": 0.00062, "epss_percentile": 0.19744}, "CVE-2016-3814": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-3815": {"epss_score": 0.00062, "epss_percentile": 0.19744}, "CVE-2016-3816": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-3818": {"epss_score": 0.00145, "epss_percentile": 0.35437}, "CVE-2016-3819": {"epss_score": 0.01486, "epss_percentile": 0.80603}, "CVE-2016-3820": {"epss_score": 0.01486, "epss_percentile": 0.80603}, "CVE-2016-3821": {"epss_score": 0.00841, "epss_percentile": 0.74223}, "CVE-2016-3822": {"epss_score": 0.00349, "epss_percentile": 0.569}, "CVE-2016-3823": {"epss_score": 0.00023, "epss_percentile": 0.05334}, "CVE-2016-3824": {"epss_score": 0.00023, "epss_percentile": 0.05334}, "CVE-2016-3825": {"epss_score": 0.00023, "epss_percentile": 0.05334}, "CVE-2016-3826": {"epss_score": 0.00023, "epss_percentile": 0.05334}, "CVE-2016-3827": {"epss_score": 0.00192, "epss_percentile": 0.41336}, "CVE-2016-3828": {"epss_score": 0.00192, "epss_percentile": 0.41336}, "CVE-2016-3829": {"epss_score": 0.00192, "epss_percentile": 0.41336}, "CVE-2016-3830": {"epss_score": 0.00192, "epss_percentile": 0.41336}, "CVE-2016-3831": {"epss_score": 0.00502, "epss_percentile": 0.65409}, "CVE-2016-3832": {"epss_score": 0.00074, "epss_percentile": 0.22693}, "CVE-2016-3833": {"epss_score": 0.00053, "epss_percentile": 0.17029}, "CVE-2016-3834": {"epss_score": 0.00105, "epss_percentile": 0.29276}, "CVE-2016-3835": {"epss_score": 0.00105, "epss_percentile": 0.29276}, "CVE-2016-3836": {"epss_score": 0.00105, "epss_percentile": 0.29276}, "CVE-2016-3837": {"epss_score": 0.00105, "epss_percentile": 0.29276}, "CVE-2016-3838": {"epss_score": 0.00067, "epss_percentile": 0.21139}, "CVE-2016-3839": {"epss_score": 0.00067, "epss_percentile": 0.21139}, "CVE-2016-3840": {"epss_score": 0.02299, "epss_percentile": 0.84305}, "CVE-2016-3841": {"epss_score": 0.00034, "epss_percentile": 0.09787}, "CVE-2016-3842": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3843": {"epss_score": 0.0006, "epss_percentile": 0.18973}, "CVE-2016-3844": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3845": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3846": {"epss_score": 0.0006, "epss_percentile": 0.19173}, "CVE-2016-3847": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2016-3848": {"epss_score": 0.0006, "epss_percentile": 0.19173}, "CVE-2016-3849": {"epss_score": 0.00014, "epss_percentile": 0.02116}, "CVE-2016-3850": {"epss_score": 0.00019, "epss_percentile": 0.04174}, "CVE-2016-3851": {"epss_score": 0.00123, "epss_percentile": 0.32183}, "CVE-2016-3852": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-3853": {"epss_score": 0.00012, "epss_percentile": 0.01238}, "CVE-2016-3854": {"epss_score": 0.00083, "epss_percentile": 0.24611}, "CVE-2016-3855": {"epss_score": 0.00083, "epss_percentile": 0.24611}, "CVE-2016-3856": {"epss_score": 0.00092, "epss_percentile": 0.26423}, "CVE-2016-3857": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2016-3858": {"epss_score": 0.00067, "epss_percentile": 0.21134}, "CVE-2016-3859": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2016-3860": {"epss_score": 0.00105, "epss_percentile": 0.29276}, "CVE-2016-3861": {"epss_score": 0.12447, "epss_percentile": 0.93675}, "CVE-2016-3862": {"epss_score": 0.0024, "epss_percentile": 0.47198}, "CVE-2016-3863": {"epss_score": 0.00599, "epss_percentile": 0.68787}, "CVE-2016-3864": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2016-3865": {"epss_score": 0.0007, "epss_percentile": 0.21821}, "CVE-2016-3866": {"epss_score": 0.0007, "epss_percentile": 0.21937}, "CVE-2016-3867": {"epss_score": 0.00484, "epss_percentile": 0.64648}, "CVE-2016-3868": {"epss_score": 0.00071, "epss_percentile": 0.2202}, "CVE-2016-3869": {"epss_score": 0.0007, "epss_percentile": 0.21821}, "CVE-2016-3870": {"epss_score": 0.00059, "epss_percentile": 0.1887}, "CVE-2016-3871": {"epss_score": 0.00088, "epss_percentile": 0.25759}, "CVE-2016-3872": {"epss_score": 0.00067, "epss_percentile": 0.21134}, "CVE-2016-3873": {"epss_score": 0.0007, "epss_percentile": 0.21821}, "CVE-2016-3874": {"epss_score": 0.00069, "epss_percentile": 0.21426}, "CVE-2016-3875": {"epss_score": 0.00025, "epss_percentile": 0.06347}, "CVE-2016-3876": {"epss_score": 0.00025, "epss_percentile": 0.06347}, "CVE-2016-3877": {"epss_score": 0.00161, "epss_percentile": 0.37559}, "CVE-2016-3878": {"epss_score": 0.00272, "epss_percentile": 0.5042}, "CVE-2016-3879": {"epss_score": 0.00272, "epss_percentile": 0.5042}, "CVE-2016-3880": {"epss_score": 0.00297, "epss_percentile": 0.52757}, "CVE-2016-3881": {"epss_score": 0.00266, "epss_percentile": 0.4987}, "CVE-2016-3882": {"epss_score": 0.00208, "epss_percentile": 0.43253}, "CVE-2016-3883": {"epss_score": 0.00089, "epss_percentile": 0.25819}, "CVE-2016-3884": {"epss_score": 0.00089, "epss_percentile": 0.25819}, "CVE-2016-3885": {"epss_score": 0.00069, "epss_percentile": 0.21426}, "CVE-2016-3886": {"epss_score": 0.00025, "epss_percentile": 0.06347}, "CVE-2016-3887": {"epss_score": 0.00098, "epss_percentile": 0.27692}, "CVE-2016-3888": {"epss_score": 0.00028, "epss_percentile": 0.07224}, "CVE-2016-3889": {"epss_score": 0.00024, "epss_percentile": 0.05961}, "CVE-2016-3890": {"epss_score": 0.00092, "epss_percentile": 0.26587}, "CVE-2016-3892": {"epss_score": 0.00125, "epss_percentile": 0.32563}, "CVE-2016-3893": {"epss_score": 0.00111, "epss_percentile": 0.30306}, "CVE-2016-3894": {"epss_score": 0.00125, "epss_percentile": 0.32563}, "CVE-2016-3895": {"epss_score": 0.00105, "epss_percentile": 0.29276}, "CVE-2016-3896": {"epss_score": 0.00116, "epss_percentile": 0.31047}, "CVE-2016-3897": {"epss_score": 0.00127, "epss_percentile": 0.32888}, "CVE-2016-3898": {"epss_score": 0.00067, "epss_percentile": 0.21139}, "CVE-2016-3899": {"epss_score": 0.00272, "epss_percentile": 0.5042}, "CVE-2016-3900": {"epss_score": 0.00062, "epss_percentile": 0.19753}, "CVE-2016-3901": {"epss_score": 0.00059, "epss_percentile": 0.1887}, "CVE-2016-3902": {"epss_score": 0.0009, "epss_percentile": 0.26088}, "CVE-2016-3903": {"epss_score": 0.00059, "epss_percentile": 0.18826}, "CVE-2016-3904": {"epss_score": 0.00094, "epss_percentile": 0.26781}, "CVE-2016-3905": {"epss_score": 0.00061, "epss_percentile": 0.19512}, "CVE-2016-3906": {"epss_score": 0.00109, "epss_percentile": 0.30074}, "CVE-2016-3907": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-3908": {"epss_score": 0.0009, "epss_percentile": 0.26011}, "CVE-2016-3909": {"epss_score": 0.00062, "epss_percentile": 0.19753}, "CVE-2016-3910": {"epss_score": 0.00135, "epss_percentile": 0.34003}, "CVE-2016-3911": {"epss_score": 0.00059, "epss_percentile": 0.1887}, "CVE-2016-3912": {"epss_score": 0.00135, "epss_percentile": 0.34003}, "CVE-2016-3913": {"epss_score": 0.00059, "epss_percentile": 0.1887}, "CVE-2016-3914": {"epss_score": 0.00104, "epss_percentile": 0.29246}, "CVE-2016-3915": {"epss_score": 0.00059, "epss_percentile": 0.1887}, "CVE-2016-3916": {"epss_score": 0.00059, "epss_percentile": 0.1887}, "CVE-2016-3917": {"epss_score": 0.00021, "epss_percentile": 0.04719}, "CVE-2016-3918": {"epss_score": 0.00105, "epss_percentile": 0.29276}, "CVE-2016-3920": {"epss_score": 0.00192, "epss_percentile": 0.41336}, "CVE-2016-3921": {"epss_score": 0.00059, "epss_percentile": 0.1887}, "CVE-2016-3922": {"epss_score": 0.00088, "epss_percentile": 0.25748}, "CVE-2016-3923": {"epss_score": 0.00079, "epss_percentile": 0.2387}, "CVE-2016-3924": {"epss_score": 0.00105, "epss_percentile": 0.29276}, "CVE-2016-3925": {"epss_score": 0.00067, "epss_percentile": 0.21139}, "CVE-2016-3926": {"epss_score": 0.00123, "epss_percentile": 0.32183}, "CVE-2016-3927": {"epss_score": 0.00123, "epss_percentile": 0.32183}, "CVE-2016-3928": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-3929": {"epss_score": 0.00123, "epss_percentile": 0.32183}, "CVE-2016-3930": {"epss_score": 0.00073, "epss_percentile": 0.2263}, "CVE-2016-3931": {"epss_score": 0.00059, "epss_percentile": 0.18826}, "CVE-2016-3932": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3933": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3934": {"epss_score": 0.00077, "epss_percentile": 0.23382}, "CVE-2016-3935": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2016-3936": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-3937": {"epss_score": 0.00043, "epss_percentile": 0.13067}, "CVE-2016-3938": {"epss_score": 0.00073, "epss_percentile": 0.2263}, "CVE-2016-3939": {"epss_score": 0.00044, "epss_percentile": 0.13653}, "CVE-2016-3940": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-3941": {"epss_score": 0.00307, "epss_percentile": 0.53502}, "CVE-2016-3943": {"epss_score": 0.00193, "epss_percentile": 0.41488}, "CVE-2016-3944": {"epss_score": 0.00422, "epss_percentile": 0.61554}, "CVE-2016-3945": {"epss_score": 0.00116, "epss_percentile": 0.31157}, "CVE-2016-3946": {"epss_score": 0.00054, "epss_percentile": 0.17349}, "CVE-2016-3947": {"epss_score": 0.7881, "epss_percentile": 0.99004}, "CVE-2016-3948": {"epss_score": 0.69622, "epss_percentile": 0.98595}, "CVE-2016-3949": {"epss_score": 0.04865, "epss_percentile": 0.89225}, "CVE-2016-3950": {"epss_score": 0.0009, "epss_percentile": 0.26133}, "CVE-2016-3951": {"epss_score": 0.00039, "epss_percentile": 0.11789}, "CVE-2016-3952": {"epss_score": 0.00397, "epss_percentile": 0.59963}, "CVE-2016-3953": {"epss_score": 0.01507, "epss_percentile": 0.80755}, "CVE-2016-3954": {"epss_score": 0.00392, "epss_percentile": 0.59671}, "CVE-2016-3955": {"epss_score": 0.12798, "epss_percentile": 0.93776}, "CVE-2016-3956": {"epss_score": 0.03208, "epss_percentile": 0.86639}, "CVE-2016-3957": {"epss_score": 0.12737, "epss_percentile": 0.93762}, "CVE-2016-3958": {"epss_score": 0.00154, "epss_percentile": 0.36663}, "CVE-2016-3959": {"epss_score": 0.0247, "epss_percentile": 0.84845}, "CVE-2016-3960": {"epss_score": 0.00077, "epss_percentile": 0.23359}, "CVE-2016-3961": {"epss_score": 0.00126, "epss_percentile": 0.32637}, "CVE-2016-3962": {"epss_score": 0.11107, "epss_percentile": 0.93223}, "CVE-2016-3963": {"epss_score": 0.06491, "epss_percentile": 0.90794}, "CVE-2016-3968": {"epss_score": 0.00091, "epss_percentile": 0.26246}, "CVE-2016-3969": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-3971": {"epss_score": 0.00192, "epss_percentile": 0.41349}, "CVE-2016-3972": {"epss_score": 0.00101, "epss_percentile": 0.28618}, "CVE-2016-3973": {"epss_score": 0.00503, "epss_percentile": 0.65456}, "CVE-2016-3974": {"epss_score": 0.13851, "epss_percentile": 0.94076}, "CVE-2016-3975": {"epss_score": 0.00657, "epss_percentile": 0.70458}, "CVE-2016-3976": {"epss_score": 0.81466, "epss_percentile": 0.9914}, "CVE-2016-3977": {"epss_score": 0.00972, "epss_percentile": 0.76136}, "CVE-2016-3978": {"epss_score": 0.05549, "epss_percentile": 0.89984}, "CVE-2016-3979": {"epss_score": 0.03697, "epss_percentile": 0.87587}, "CVE-2016-3980": {"epss_score": 0.03308, "epss_percentile": 0.86881}, "CVE-2016-3981": {"epss_score": 0.00953, "epss_percentile": 0.75887}, "CVE-2016-3982": {"epss_score": 0.01698, "epss_percentile": 0.81821}, "CVE-2016-3983": {"epss_score": 0.0018, "epss_percentile": 0.39899}, "CVE-2016-3984": {"epss_score": 0.0029, "epss_percentile": 0.52135}, "CVE-2016-3985": {"epss_score": 0.00165, "epss_percentile": 0.3813}, "CVE-2016-3986": {"epss_score": 0.03378, "epss_percentile": 0.87026}, "CVE-2016-3987": {"epss_score": 0.43149, "epss_percentile": 0.97373}, "CVE-2016-3988": {"epss_score": 0.00559, "epss_percentile": 0.67604}, "CVE-2016-3989": {"epss_score": 0.08283, "epss_percentile": 0.91968}, "CVE-2016-3990": {"epss_score": 0.00444, "epss_percentile": 0.6281}, "CVE-2016-3991": {"epss_score": 0.00379, "epss_percentile": 0.58857}, "CVE-2016-3992": {"epss_score": 0.00059, "epss_percentile": 0.18679}, "CVE-2016-3993": {"epss_score": 0.01098, "epss_percentile": 0.77543}, "CVE-2016-3994": {"epss_score": 0.00993, "epss_percentile": 0.76411}, "CVE-2016-3995": {"epss_score": 0.01025, "epss_percentile": 0.76788}, "CVE-2016-3996": {"epss_score": 0.00201, "epss_percentile": 0.42337}, "CVE-2016-3997": {"epss_score": 0.00426, "epss_percentile": 0.61737}, "CVE-2016-3998": {"epss_score": 0.00448, "epss_percentile": 0.62995}, "CVE-2016-3999": {"epss_score": 0.00359, "epss_percentile": 0.57546}, "CVE-2016-4000": {"epss_score": 0.15579, "epss_percentile": 0.94463}, "CVE-2016-4001": {"epss_score": 0.09366, "epss_percentile": 0.92518}, "CVE-2016-4002": {"epss_score": 0.11969, "epss_percentile": 0.93529}, "CVE-2016-4003": {"epss_score": 0.03402, "epss_percentile": 0.87069}, "CVE-2016-4004": {"epss_score": 0.12172, "epss_percentile": 0.93591}, "CVE-2016-4005": {"epss_score": 0.00045, "epss_percentile": 0.13892}, "CVE-2016-4006": {"epss_score": 0.00197, "epss_percentile": 0.41902}, "CVE-2016-4007": {"epss_score": 0.01314, "epss_percentile": 0.79398}, "CVE-2016-4008": {"epss_score": 0.05049, "epss_percentile": 0.89439}, "CVE-2016-4009": {"epss_score": 0.03498, "epss_percentile": 0.87239}, "CVE-2016-4010": {"epss_score": 0.87063, "epss_percentile": 0.99412}, "CVE-2016-4014": {"epss_score": 0.06906, "epss_percentile": 0.91109}, "CVE-2016-4015": {"epss_score": 0.03044, "epss_percentile": 0.8628}, "CVE-2016-4016": {"epss_score": 0.00491, "epss_percentile": 0.6495}, "CVE-2016-4017": {"epss_score": 0.00499, "epss_percentile": 0.65251}, "CVE-2016-4018": {"epss_score": 0.00408, "epss_percentile": 0.6064}, "CVE-2016-4019": {"epss_score": 0.00398, "epss_percentile": 0.60056}, "CVE-2016-4020": {"epss_score": 0.00085, "epss_percentile": 0.25056}, "CVE-2016-4021": {"epss_score": 0.03451, "epss_percentile": 0.87164}, "CVE-2016-4024": {"epss_score": 0.09628, "epss_percentile": 0.9263}, "CVE-2016-4025": {"epss_score": 0.0006, "epss_percentile": 0.19063}, "CVE-2016-4026": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2016-4027": {"epss_score": 0.00215, "epss_percentile": 0.4408}, "CVE-2016-4028": {"epss_score": 0.00201, "epss_percentile": 0.42345}, "CVE-2016-4029": {"epss_score": 0.00529, "epss_percentile": 0.66578}, "CVE-2016-4030": {"epss_score": 0.00089, "epss_percentile": 0.25908}, "CVE-2016-4031": {"epss_score": 0.00089, "epss_percentile": 0.25908}, "CVE-2016-4032": {"epss_score": 0.00108, "epss_percentile": 0.29789}, "CVE-2016-4036": {"epss_score": 0.001, "epss_percentile": 0.28459}, "CVE-2016-4037": {"epss_score": 0.00093, "epss_percentile": 0.26684}, "CVE-2016-4038": {"epss_score": 0.00043, "epss_percentile": 0.12953}, "CVE-2016-4040": {"epss_score": 0.00391, "epss_percentile": 0.5963}, "CVE-2016-4041": {"epss_score": 0.00429, "epss_percentile": 0.61963}, "CVE-2016-4042": {"epss_score": 0.0023, "epss_percentile": 0.45762}, "CVE-2016-4043": {"epss_score": 0.00139, "epss_percentile": 0.34592}, "CVE-2016-4045": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2016-4046": {"epss_score": 0.00181, "epss_percentile": 0.40037}, "CVE-2016-4047": {"epss_score": 0.00133, "epss_percentile": 0.33626}, "CVE-2016-4048": {"epss_score": 0.00216, "epss_percentile": 0.44151}, "CVE-2016-4049": {"epss_score": 0.02164, "epss_percentile": 0.83837}, "CVE-2016-4051": {"epss_score": 0.04905, "epss_percentile": 0.89276}, "CVE-2016-4052": {"epss_score": 0.12508, "epss_percentile": 0.93702}, "CVE-2016-4053": {"epss_score": 0.09506, "epss_percentile": 0.92577}, "CVE-2016-4054": {"epss_score": 0.8268, "epss_percentile": 0.99206}, "CVE-2016-4055": {"epss_score": 0.04049, "epss_percentile": 0.88175}, "CVE-2016-4056": {"epss_score": 0.00308, "epss_percentile": 0.53629}, "CVE-2016-4057": {"epss_score": 0.00104, "epss_percentile": 0.29184}, "CVE-2016-4058": {"epss_score": 0.00087, "epss_percentile": 0.25444}, "CVE-2016-4059": {"epss_score": 0.01302, "epss_percentile": 0.793}, "CVE-2016-4060": {"epss_score": 0.00146, "epss_percentile": 0.35616}, "CVE-2016-4061": {"epss_score": 0.0022, "epss_percentile": 0.44592}, "CVE-2016-4062": {"epss_score": 0.00038, "epss_percentile": 0.1128}, "CVE-2016-4063": {"epss_score": 0.01544, "epss_percentile": 0.8096}, "CVE-2016-4064": {"epss_score": 0.01264, "epss_percentile": 0.78992}, "CVE-2016-4065": {"epss_score": 0.00266, "epss_percentile": 0.49926}, "CVE-2016-4066": {"epss_score": 0.00136, "epss_percentile": 0.3415}, "CVE-2016-4068": {"epss_score": 0.00369, "epss_percentile": 0.58227}, "CVE-2016-4069": {"epss_score": 0.01131, "epss_percentile": 0.77864}, "CVE-2016-4070": {"epss_score": 0.06468, "epss_percentile": 0.90776}, "CVE-2016-4071": {"epss_score": 0.3258, "epss_percentile": 0.96709}, "CVE-2016-4072": {"epss_score": 0.11136, "epss_percentile": 0.93234}, "CVE-2016-4073": {"epss_score": 0.0663, "epss_percentile": 0.90902}, "CVE-2016-4074": {"epss_score": 0.01282, "epss_percentile": 0.79152}, "CVE-2016-4075": {"epss_score": 0.00298, "epss_percentile": 0.52819}, "CVE-2016-4076": {"epss_score": 0.00168, "epss_percentile": 0.38499}, "CVE-2016-4077": {"epss_score": 0.00216, "epss_percentile": 0.44235}, "CVE-2016-4078": {"epss_score": 0.00357, "epss_percentile": 0.57453}, "CVE-2016-4079": {"epss_score": 0.00228, "epss_percentile": 0.455}, "CVE-2016-4080": {"epss_score": 0.00357, "epss_percentile": 0.57453}, "CVE-2016-4081": {"epss_score": 0.00366, "epss_percentile": 0.58075}, "CVE-2016-4082": {"epss_score": 0.00228, "epss_percentile": 0.455}, "CVE-2016-4083": {"epss_score": 0.00216, "epss_percentile": 0.44163}, "CVE-2016-4084": {"epss_score": 0.00164, "epss_percentile": 0.37954}, "CVE-2016-4085": {"epss_score": 0.00884, "epss_percentile": 0.74931}, "CVE-2016-4086": {"epss_score": 0.00057, "epss_percentile": 0.18034}, "CVE-2016-4087": {"epss_score": 0.00827, "epss_percentile": 0.7399}, "CVE-2016-4088": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4089": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4090": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4091": {"epss_score": 0.05382, "epss_percentile": 0.89812}, "CVE-2016-4092": {"epss_score": 0.05382, "epss_percentile": 0.89812}, "CVE-2016-4093": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4094": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4095": {"epss_score": 0.02414, "epss_percentile": 0.8468}, "CVE-2016-4096": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4097": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4098": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4099": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4100": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4101": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4102": {"epss_score": 0.04015, "epss_percentile": 0.88121}, "CVE-2016-4103": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4104": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4105": {"epss_score": 0.02899, "epss_percentile": 0.85948}, "CVE-2016-4106": {"epss_score": 0.00484, "epss_percentile": 0.64632}, "CVE-2016-4107": {"epss_score": 0.04015, "epss_percentile": 0.88121}, "CVE-2016-4108": {"epss_score": 0.65591, "epss_percentile": 0.98428}, "CVE-2016-4109": {"epss_score": 0.06491, "epss_percentile": 0.90797}, "CVE-2016-4110": {"epss_score": 0.06955, "epss_percentile": 0.91145}, "CVE-2016-4111": {"epss_score": 0.06491, "epss_percentile": 0.90797}, "CVE-2016-4112": {"epss_score": 0.06491, "epss_percentile": 0.90797}, "CVE-2016-4113": {"epss_score": 0.06491, "epss_percentile": 0.90797}, "CVE-2016-4114": {"epss_score": 0.06491, "epss_percentile": 0.90797}, "CVE-2016-4115": {"epss_score": 0.06491, "epss_percentile": 0.90797}, "CVE-2016-4116": {"epss_score": 0.06137, "epss_percentile": 0.90511}, "CVE-2016-4117": {"epss_score": 0.93209, "epss_percentile": 0.99783}, "CVE-2016-4118": {"epss_score": 0.00635, "epss_percentile": 0.69819}, "CVE-2016-4119": {"epss_score": 0.02414, "epss_percentile": 0.8468}, "CVE-2016-4120": {"epss_score": 0.03158, "epss_percentile": 0.8652}, "CVE-2016-4121": {"epss_score": 0.05232, "epss_percentile": 0.89643}, "CVE-2016-4122": {"epss_score": 0.02182, "epss_percentile": 0.83908}, "CVE-2016-4123": {"epss_score": 0.02182, "epss_percentile": 0.83908}, "CVE-2016-4124": {"epss_score": 0.02182, "epss_percentile": 0.83908}, "CVE-2016-4125": {"epss_score": 0.02182, "epss_percentile": 0.83908}, "CVE-2016-4126": {"epss_score": 0.01293, "epss_percentile": 0.7924}, "CVE-2016-4127": {"epss_score": 0.02182, "epss_percentile": 0.83908}, "CVE-2016-4128": {"epss_score": 0.02182, "epss_percentile": 0.83908}, "CVE-2016-4129": {"epss_score": 0.02182, "epss_percentile": 0.83908}, "CVE-2016-4130": {"epss_score": 0.02182, "epss_percentile": 0.83908}, "CVE-2016-4131": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4132": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4133": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4134": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4135": {"epss_score": 0.30323, "epss_percentile": 0.96528}, "CVE-2016-4136": {"epss_score": 0.35033, "epss_percentile": 0.96884}, "CVE-2016-4137": {"epss_score": 0.35033, "epss_percentile": 0.96884}, "CVE-2016-4138": {"epss_score": 0.60707, "epss_percentile": 0.98217}, "CVE-2016-4139": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4140": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4141": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4142": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4143": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4144": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4145": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4146": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4147": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4148": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4149": {"epss_score": 0.02922, "epss_percentile": 0.86}, "CVE-2016-4150": {"epss_score": 0.04131, "epss_percentile": 0.88299}, "CVE-2016-4151": {"epss_score": 0.04131, "epss_percentile": 0.88299}, "CVE-2016-4152": {"epss_score": 0.04131, "epss_percentile": 0.88299}, "CVE-2016-4153": {"epss_score": 0.04131, "epss_percentile": 0.88299}, "CVE-2016-4154": {"epss_score": 0.04131, "epss_percentile": 0.88299}, "CVE-2016-4155": {"epss_score": 0.04131, "epss_percentile": 0.88299}, "CVE-2016-4156": {"epss_score": 0.04973, "epss_percentile": 0.89352}, "CVE-2016-4157": {"epss_score": 0.00163, "epss_percentile": 0.37776}, "CVE-2016-4158": {"epss_score": 0.01757, "epss_percentile": 0.82132}, "CVE-2016-4159": {"epss_score": 0.00698, "epss_percentile": 0.71416}, "CVE-2016-4160": {"epss_score": 0.03158, "epss_percentile": 0.8652}, "CVE-2016-4161": {"epss_score": 0.03158, "epss_percentile": 0.8652}, "CVE-2016-4162": {"epss_score": 0.03158, "epss_percentile": 0.8652}, "CVE-2016-4163": {"epss_score": 0.03158, "epss_percentile": 0.8652}, "CVE-2016-4164": {"epss_score": 0.00636, "epss_percentile": 0.69861}, "CVE-2016-4165": {"epss_score": 0.0377, "epss_percentile": 0.87702}, "CVE-2016-4166": {"epss_score": 0.02194, "epss_percentile": 0.83951}, "CVE-2016-4167": {"epss_score": 0.06478, "epss_percentile": 0.90783}, "CVE-2016-4168": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2016-4169": {"epss_score": 0.02399, "epss_percentile": 0.84636}, "CVE-2016-4170": {"epss_score": 0.00752, "epss_percentile": 0.72663}, "CVE-2016-4171": {"epss_score": 0.50544, "epss_percentile": 0.9774}, "CVE-2016-4172": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-4173": {"epss_score": 0.09023, "epss_percentile": 0.92371}, "CVE-2016-4174": {"epss_score": 0.09023, "epss_percentile": 0.92371}, "CVE-2016-4175": {"epss_score": 0.36692, "epss_percentile": 0.96996}, "CVE-2016-4176": {"epss_score": 0.41362, "epss_percentile": 0.97269}, "CVE-2016-4177": {"epss_score": 0.41362, "epss_percentile": 0.97269}, "CVE-2016-4178": {"epss_score": 0.01213, "epss_percentile": 0.78569}, "CVE-2016-4179": {"epss_score": 0.36692, "epss_percentile": 0.96996}, "CVE-2016-4180": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-4181": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-4182": {"epss_score": 0.10307, "epss_percentile": 0.92936}, "CVE-2016-4183": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-4184": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-4185": {"epss_score": 0.05385, "epss_percentile": 0.89818}, "CVE-2016-4186": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-4187": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-4188": {"epss_score": 0.03707, "epss_percentile": 0.876}, "CVE-2016-4189": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-4190": {"epss_score": 0.0319, "epss_percentile": 0.86599}, "CVE-2016-4191": {"epss_score": 0.03024, "epss_percentile": 0.86237}, "CVE-2016-4192": {"epss_score": 0.03024, "epss_percentile": 0.86237}, "CVE-2016-4193": {"epss_score": 0.03024, "epss_percentile": 0.86237}, "CVE-2016-4194": {"epss_score": 0.03383, "epss_percentile": 0.87036}, "CVE-2016-4195": {"epss_score": 0.03306, "epss_percentile": 0.86878}, "CVE-2016-4196": {"epss_score": 0.01974, "epss_percentile": 0.83116}, "CVE-2016-4197": {"epss_score": 0.01974, "epss_percentile": 0.83116}, "CVE-2016-4198": {"epss_score": 0.01974, "epss_percentile": 0.83116}, "CVE-2016-4199": {"epss_score": 0.01974, "epss_percentile": 0.83116}, "CVE-2016-4200": {"epss_score": 0.01974, "epss_percentile": 0.83116}, "CVE-2016-4201": {"epss_score": 0.15076, "epss_percentile": 0.94357}, "CVE-2016-4202": {"epss_score": 0.03325, "epss_percentile": 0.86922}, "CVE-2016-4203": {"epss_score": 0.15193, "epss_percentile": 0.94382}, "CVE-2016-4204": {"epss_score": 0.15076, "epss_percentile": 0.94357}, "CVE-2016-4205": {"epss_score": 0.15076, "epss_percentile": 0.94357}, "CVE-2016-4206": {"epss_score": 0.15076, "epss_percentile": 0.94357}, "CVE-2016-4207": {"epss_score": 0.15076, "epss_percentile": 0.94357}, "CVE-2016-4208": {"epss_score": 0.15076, "epss_percentile": 0.94357}, "CVE-2016-4209": {"epss_score": 0.05005, "epss_percentile": 0.89384}, "CVE-2016-4210": {"epss_score": 0.03816, "epss_percentile": 0.87769}, "CVE-2016-4211": {"epss_score": 0.03024, "epss_percentile": 0.86237}, "CVE-2016-4212": {"epss_score": 0.03383, "epss_percentile": 0.87036}, "CVE-2016-4213": {"epss_score": 0.03024, "epss_percentile": 0.86237}, "CVE-2016-4214": {"epss_score": 0.03024, "epss_percentile": 0.86237}, "CVE-2016-4215": {"epss_score": 0.01271, "epss_percentile": 0.79053}, "CVE-2016-4216": {"epss_score": 0.00682, "epss_percentile": 0.71075}, "CVE-2016-4217": {"epss_score": 0.04039, "epss_percentile": 0.88164}, "CVE-2016-4218": {"epss_score": 0.04039, "epss_percentile": 0.88164}, "CVE-2016-4219": {"epss_score": 0.04039, "epss_percentile": 0.88164}, "CVE-2016-4220": {"epss_score": 0.04039, "epss_percentile": 0.88164}, "CVE-2016-4221": {"epss_score": 0.04039, "epss_percentile": 0.88164}, "CVE-2016-4222": {"epss_score": 0.08307, "epss_percentile": 0.91982}, "CVE-2016-4223": {"epss_score": 0.0341, "epss_percentile": 0.87081}, "CVE-2016-4224": {"epss_score": 0.0341, "epss_percentile": 0.87081}, "CVE-2016-4225": {"epss_score": 0.0341, "epss_percentile": 0.87081}, "CVE-2016-4226": {"epss_score": 0.6341, "epss_percentile": 0.98333}, "CVE-2016-4227": {"epss_score": 0.57587, "epss_percentile": 0.98073}, "CVE-2016-4228": {"epss_score": 0.6341, "epss_percentile": 0.98333}, "CVE-2016-4229": {"epss_score": 0.6341, "epss_percentile": 0.98333}, "CVE-2016-4230": {"epss_score": 0.56475, "epss_percentile": 0.98024}, "CVE-2016-4231": {"epss_score": 0.57587, "epss_percentile": 0.98073}, "CVE-2016-4232": {"epss_score": 0.2744, "epss_percentile": 0.96245}, "CVE-2016-4233": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4234": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4235": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4236": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4237": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4238": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4239": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4240": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4241": {"epss_score": 0.04039, "epss_percentile": 0.88164}, "CVE-2016-4242": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4243": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4244": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4245": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4246": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2016-4247": {"epss_score": 0.01099, "epss_percentile": 0.7756}, "CVE-2016-4248": {"epss_score": 0.06154, "epss_percentile": 0.90523}, "CVE-2016-4249": {"epss_score": 0.04682, "epss_percentile": 0.89}, "CVE-2016-4250": {"epss_score": 0.03024, "epss_percentile": 0.86237}, "CVE-2016-4251": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-4252": {"epss_score": 0.03024, "epss_percentile": 0.86237}, "CVE-2016-4253": {"epss_score": 0.0268, "epss_percentile": 0.85414}, "CVE-2016-4254": {"epss_score": 0.03024, "epss_percentile": 0.86237}, "CVE-2016-4255": {"epss_score": 0.02083, "epss_percentile": 0.83542}, "CVE-2016-4256": {"epss_score": 0.01933, "epss_percentile": 0.82951}, "CVE-2016-4257": {"epss_score": 0.01933, "epss_percentile": 0.82951}, "CVE-2016-4258": {"epss_score": 0.01933, "epss_percentile": 0.82951}, "CVE-2016-4259": {"epss_score": 0.01933, "epss_percentile": 0.82951}, "CVE-2016-4260": {"epss_score": 0.01933, "epss_percentile": 0.82951}, "CVE-2016-4261": {"epss_score": 0.01933, "epss_percentile": 0.82951}, "CVE-2016-4262": {"epss_score": 0.01933, "epss_percentile": 0.82951}, "CVE-2016-4263": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-4264": {"epss_score": 0.55384, "epss_percentile": 0.97974}, "CVE-2016-4265": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-4266": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-4267": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-4268": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-4269": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-4270": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2016-4271": {"epss_score": 0.01511, "epss_percentile": 0.80772}, "CVE-2016-4272": {"epss_score": 0.01963, "epss_percentile": 0.83071}, "CVE-2016-4273": {"epss_score": 0.59718, "epss_percentile": 0.98176}, "CVE-2016-4274": {"epss_score": 0.03311, "epss_percentile": 0.86893}, "CVE-2016-4275": {"epss_score": 0.61494, "epss_percentile": 0.9825}, "CVE-2016-4276": {"epss_score": 0.03311, "epss_percentile": 0.86893}, "CVE-2016-4277": {"epss_score": 0.01897, "epss_percentile": 0.82758}, "CVE-2016-4278": {"epss_score": 0.02182, "epss_percentile": 0.8391}, "CVE-2016-4279": {"epss_score": 0.01963, "epss_percentile": 0.83071}, "CVE-2016-4280": {"epss_score": 0.03311, "epss_percentile": 0.86893}, "CVE-2016-4281": {"epss_score": 0.03311, "epss_percentile": 0.86893}, "CVE-2016-4282": {"epss_score": 0.03311, "epss_percentile": 0.86893}, "CVE-2016-4283": {"epss_score": 0.03311, "epss_percentile": 0.86893}, "CVE-2016-4284": {"epss_score": 0.03311, "epss_percentile": 0.86893}, "CVE-2016-4285": {"epss_score": 0.03311, "epss_percentile": 0.86893}, "CVE-2016-4286": {"epss_score": 0.02415, "epss_percentile": 0.84686}, "CVE-2016-4287": {"epss_score": 0.07669, "epss_percentile": 0.91612}, "CVE-2016-4288": {"epss_score": 0.00054, "epss_percentile": 0.17098}, "CVE-2016-4289": {"epss_score": 0.00129, "epss_percentile": 0.33198}, "CVE-2016-4290": {"epss_score": 0.00429, "epss_percentile": 0.61965}, "CVE-2016-4291": {"epss_score": 0.00429, "epss_percentile": 0.61965}, "CVE-2016-4292": {"epss_score": 0.00429, "epss_percentile": 0.61965}, "CVE-2016-4293": {"epss_score": 0.01119, "epss_percentile": 0.77749}, "CVE-2016-4294": {"epss_score": 0.00817, "epss_percentile": 0.73837}, "CVE-2016-4295": {"epss_score": 0.00429, "epss_percentile": 0.61965}, "CVE-2016-4296": {"epss_score": 0.00527, "epss_percentile": 0.66522}, "CVE-2016-4298": {"epss_score": 0.00527, "epss_percentile": 0.66522}, "CVE-2016-4300": {"epss_score": 0.0057, "epss_percentile": 0.6797}, "CVE-2016-4301": {"epss_score": 0.0143, "epss_percentile": 0.80231}, "CVE-2016-4302": {"epss_score": 0.00758, "epss_percentile": 0.72764}, "CVE-2016-4303": {"epss_score": 0.05726, "epss_percentile": 0.90156}, "CVE-2016-4304": {"epss_score": 0.00064, "epss_percentile": 0.2027}, "CVE-2016-4305": {"epss_score": 0.00064, "epss_percentile": 0.2027}, "CVE-2016-4306": {"epss_score": 0.00097, "epss_percentile": 0.27529}, "CVE-2016-4307": {"epss_score": 0.00075, "epss_percentile": 0.22947}, "CVE-2016-4309": {"epss_score": 0.21885, "epss_percentile": 0.9557}, "CVE-2016-4311": {"epss_score": 0.0028, "epss_percentile": 0.51094}, "CVE-2016-4312": {"epss_score": 0.05424, "epss_percentile": 0.89866}, "CVE-2016-4313": {"epss_score": 0.03218, "epss_percentile": 0.86666}, "CVE-2016-4314": {"epss_score": 0.23258, "epss_percentile": 0.95758}, "CVE-2016-4315": {"epss_score": 0.02743, "epss_percentile": 0.85564}, "CVE-2016-4316": {"epss_score": 0.03159, "epss_percentile": 0.86528}, "CVE-2016-4317": {"epss_score": 0.00189, "epss_percentile": 0.40962}, "CVE-2016-4318": {"epss_score": 0.00168, "epss_percentile": 0.38498}, "CVE-2016-4319": {"epss_score": 0.00172, "epss_percentile": 0.38903}, "CVE-2016-4320": {"epss_score": 0.00609, "epss_percentile": 0.69128}, "CVE-2016-4322": {"epss_score": 0.03289, "epss_percentile": 0.86833}, "CVE-2016-4323": {"epss_score": 0.01998, "epss_percentile": 0.83208}, "CVE-2016-4324": {"epss_score": 0.00667, "epss_percentile": 0.70713}, "CVE-2016-4325": {"epss_score": 0.00491, "epss_percentile": 0.64943}, "CVE-2016-4326": {"epss_score": 0.06772, "epss_percentile": 0.91016}, "CVE-2016-4327": {"epss_score": 0.00236, "epss_percentile": 0.46423}, "CVE-2016-4328": {"epss_score": 0.00426, "epss_percentile": 0.61771}, "CVE-2016-4329": {"epss_score": 0.00053, "epss_percentile": 0.16851}, "CVE-2016-4330": {"epss_score": 0.00442, "epss_percentile": 0.62701}, "CVE-2016-4331": {"epss_score": 0.0045, "epss_percentile": 0.63106}, "CVE-2016-4332": {"epss_score": 0.0011, "epss_percentile": 0.30121}, "CVE-2016-4333": {"epss_score": 0.0025, "epss_percentile": 0.48149}, "CVE-2016-4334": {"epss_score": 0.00267, "epss_percentile": 0.49997}, "CVE-2016-4335": {"epss_score": 0.03467, "epss_percentile": 0.87194}, "CVE-2016-4336": {"epss_score": 0.01183, "epss_percentile": 0.78324}, "CVE-2016-4337": {"epss_score": 0.02724, "epss_percentile": 0.85524}, "CVE-2016-4338": {"epss_score": 0.4496, "epss_percentile": 0.97463}, "CVE-2016-4340": {"epss_score": 0.02474, "epss_percentile": 0.84856}, "CVE-2016-4341": {"epss_score": 0.00476, "epss_percentile": 0.64265}, "CVE-2016-4342": {"epss_score": 0.05555, "epss_percentile": 0.89988}, "CVE-2016-4343": {"epss_score": 0.07843, "epss_percentile": 0.91716}, "CVE-2016-4344": {"epss_score": 0.00493, "epss_percentile": 0.65057}, "CVE-2016-4345": {"epss_score": 0.00493, "epss_percentile": 0.65057}, "CVE-2016-4346": {"epss_score": 0.00629, "epss_percentile": 0.69681}, "CVE-2016-4348": {"epss_score": 0.03078, "epss_percentile": 0.86364}, "CVE-2016-4349": {"epss_score": 0.00297, "epss_percentile": 0.52702}, "CVE-2016-4350": {"epss_score": 0.63498, "epss_percentile": 0.98335}, "CVE-2016-4351": {"epss_score": 0.00769, "epss_percentile": 0.72988}, "CVE-2016-4352": {"epss_score": 0.00432, "epss_percentile": 0.62115}, "CVE-2016-4353": {"epss_score": 0.00796, "epss_percentile": 0.73482}, "CVE-2016-4354": {"epss_score": 0.00791, "epss_percentile": 0.73391}, "CVE-2016-4355": {"epss_score": 0.00791, "epss_percentile": 0.73391}, "CVE-2016-4356": {"epss_score": 0.00956, "epss_percentile": 0.75922}, "CVE-2016-4357": {"epss_score": 0.00231, "epss_percentile": 0.45859}, "CVE-2016-4358": {"epss_score": 0.01004, "epss_percentile": 0.76528}, "CVE-2016-4359": {"epss_score": 0.28585, "epss_percentile": 0.96369}, "CVE-2016-4360": {"epss_score": 0.05458, "epss_percentile": 0.89899}, "CVE-2016-4361": {"epss_score": 0.02672, "epss_percentile": 0.85394}, "CVE-2016-4362": {"epss_score": 0.00199, "epss_percentile": 0.42172}, "CVE-2016-4363": {"epss_score": 0.01063, "epss_percentile": 0.77187}, "CVE-2016-4364": {"epss_score": 0.00317, "epss_percentile": 0.54335}, "CVE-2016-4365": {"epss_score": 0.0234, "epss_percentile": 0.84431}, "CVE-2016-4366": {"epss_score": 0.02263, "epss_percentile": 0.84191}, "CVE-2016-4367": {"epss_score": 0.01289, "epss_percentile": 0.7921}, "CVE-2016-4368": {"epss_score": 0.0059, "epss_percentile": 0.68553}, "CVE-2016-4369": {"epss_score": 0.00281, "epss_percentile": 0.51186}, "CVE-2016-4370": {"epss_score": 0.0053, "epss_percentile": 0.66641}, "CVE-2016-4371": {"epss_score": 0.00068, "epss_percentile": 0.21263}, "CVE-2016-4372": {"epss_score": 0.10201, "epss_percentile": 0.9289}, "CVE-2016-4373": {"epss_score": 0.01835, "epss_percentile": 0.82465}, "CVE-2016-4374": {"epss_score": 0.0024, "epss_percentile": 0.47229}, "CVE-2016-4375": {"epss_score": 0.01854, "epss_percentile": 0.82554}, "CVE-2016-4376": {"epss_score": 0.00464, "epss_percentile": 0.63701}, "CVE-2016-4377": {"epss_score": 0.16885, "epss_percentile": 0.94741}, "CVE-2016-4378": {"epss_score": 0.00793, "epss_percentile": 0.73423}, "CVE-2016-4379": {"epss_score": 0.00463, "epss_percentile": 0.63632}, "CVE-2016-4380": {"epss_score": 0.0027, "epss_percentile": 0.50245}, "CVE-2016-4381": {"epss_score": 0.00064, "epss_percentile": 0.20189}, "CVE-2016-4382": {"epss_score": 0.00223, "epss_percentile": 0.44946}, "CVE-2016-4383": {"epss_score": 0.00448, "epss_percentile": 0.63029}, "CVE-2016-4384": {"epss_score": 0.02904, "epss_percentile": 0.8596}, "CVE-2016-4385": {"epss_score": 0.03675, "epss_percentile": 0.87552}, "CVE-2016-4386": {"epss_score": 0.0005, "epss_percentile": 0.15739}, "CVE-2016-4387": {"epss_score": 0.02013, "epss_percentile": 0.83258}, "CVE-2016-4388": {"epss_score": 0.02198, "epss_percentile": 0.83965}, "CVE-2016-4389": {"epss_score": 0.02025, "epss_percentile": 0.83313}, "CVE-2016-4390": {"epss_score": 0.02025, "epss_percentile": 0.83313}, "CVE-2016-4391": {"epss_score": 0.41613, "epss_percentile": 0.97285}, "CVE-2016-4392": {"epss_score": 0.00272, "epss_percentile": 0.50386}, "CVE-2016-4393": {"epss_score": 0.00251, "epss_percentile": 0.48271}, "CVE-2016-4394": {"epss_score": 0.00485, "epss_percentile": 0.64717}, "CVE-2016-4395": {"epss_score": 0.01457, "epss_percentile": 0.80397}, "CVE-2016-4396": {"epss_score": 0.01457, "epss_percentile": 0.80397}, "CVE-2016-4397": {"epss_score": 0.00229, "epss_percentile": 0.45657}, "CVE-2016-4398": {"epss_score": 0.16011, "epss_percentile": 0.94554}, "CVE-2016-4399": {"epss_score": 0.00272, "epss_percentile": 0.50386}, "CVE-2016-4400": {"epss_score": 0.00309, "epss_percentile": 0.53643}, "CVE-2016-4401": {"epss_score": 0.00445, "epss_percentile": 0.62868}, "CVE-2016-4402": {"epss_score": 0.12801, "epss_percentile": 0.93777}, "CVE-2016-4403": {"epss_score": 0.12004, "epss_percentile": 0.93545}, "CVE-2016-4404": {"epss_score": 0.12004, "epss_percentile": 0.93545}, "CVE-2016-4405": {"epss_score": 0.16011, "epss_percentile": 0.94554}, "CVE-2016-4406": {"epss_score": 0.00535, "epss_percentile": 0.66835}, "CVE-2016-4407": {"epss_score": 0.00158, "epss_percentile": 0.37148}, "CVE-2016-4412": {"epss_score": 0.0024, "epss_percentile": 0.46968}, "CVE-2016-4414": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2016-4415": {"epss_score": 0.00387, "epss_percentile": 0.593}, "CVE-2016-4416": {"epss_score": 0.00112, "epss_percentile": 0.30477}, "CVE-2016-4417": {"epss_score": 0.00216, "epss_percentile": 0.44235}, "CVE-2016-4418": {"epss_score": 0.00164, "epss_percentile": 0.37954}, "CVE-2016-4419": {"epss_score": 0.00119, "epss_percentile": 0.31584}, "CVE-2016-4420": {"epss_score": 0.00109, "epss_percentile": 0.30073}, "CVE-2016-4421": {"epss_score": 0.00518, "epss_percentile": 0.66125}, "CVE-2016-4422": {"epss_score": 0.00357, "epss_percentile": 0.57437}, "CVE-2016-4423": {"epss_score": 0.01435, "epss_percentile": 0.8027}, "CVE-2016-4425": {"epss_score": 0.01008, "epss_percentile": 0.76569}, "CVE-2016-4426": {"epss_score": 0.00151, "epss_percentile": 0.36359}, "CVE-2016-4427": {"epss_score": 0.00265, "epss_percentile": 0.49825}, "CVE-2016-4428": {"epss_score": 0.0057, "epss_percentile": 0.67949}, "CVE-2016-4429": {"epss_score": 0.02138, "epss_percentile": 0.8374}, "CVE-2016-4430": {"epss_score": 0.02845, "epss_percentile": 0.85818}, "CVE-2016-4431": {"epss_score": 0.22062, "epss_percentile": 0.9559}, "CVE-2016-4432": {"epss_score": 0.00629, "epss_percentile": 0.69675}, "CVE-2016-4433": {"epss_score": 0.10632, "epss_percentile": 0.93054}, "CVE-2016-4434": {"epss_score": 0.00415, "epss_percentile": 0.61132}, "CVE-2016-4435": {"epss_score": 0.00554, "epss_percentile": 0.67438}, "CVE-2016-4436": {"epss_score": 0.06115, "epss_percentile": 0.9049}, "CVE-2016-4437": {"epss_score": 0.94303, "epss_percentile": 0.99941}, "CVE-2016-4438": {"epss_score": 0.72057, "epss_percentile": 0.98694}, "CVE-2016-4439": {"epss_score": 0.00309, "epss_percentile": 0.53699}, "CVE-2016-4440": {"epss_score": 0.00163, "epss_percentile": 0.37766}, "CVE-2016-4441": {"epss_score": 0.00099, "epss_percentile": 0.27862}, "CVE-2016-4442": {"epss_score": 0.00282, "epss_percentile": 0.5128}, "CVE-2016-4443": {"epss_score": 0.00047, "epss_percentile": 0.14854}, "CVE-2016-4444": {"epss_score": 0.0007, "epss_percentile": 0.21938}, "CVE-2016-4445": {"epss_score": 0.0007, "epss_percentile": 0.21938}, "CVE-2016-4446": {"epss_score": 0.0007, "epss_percentile": 0.21938}, "CVE-2016-4447": {"epss_score": 0.03334, "epss_percentile": 0.86932}, "CVE-2016-4448": {"epss_score": 0.01204, "epss_percentile": 0.78504}, "CVE-2016-4449": {"epss_score": 0.00121, "epss_percentile": 0.31837}, "CVE-2016-4450": {"epss_score": 0.04016, "epss_percentile": 0.88122}, "CVE-2016-4451": {"epss_score": 0.00142, "epss_percentile": 0.35084}, "CVE-2016-4453": {"epss_score": 0.00068, "epss_percentile": 0.21284}, "CVE-2016-4454": {"epss_score": 0.00062, "epss_percentile": 0.19669}, "CVE-2016-4455": {"epss_score": 0.00048, "epss_percentile": 0.1504}, "CVE-2016-4456": {"epss_score": 0.00246, "epss_percentile": 0.47799}, "CVE-2016-4457": {"epss_score": 0.00177, "epss_percentile": 0.39501}, "CVE-2016-4459": {"epss_score": 0.01537, "epss_percentile": 0.80922}, "CVE-2016-4460": {"epss_score": 0.00088, "epss_percentile": 0.25773}, "CVE-2016-4461": {"epss_score": 0.02633, "epss_percentile": 0.85286}, "CVE-2016-4462": {"epss_score": 0.01029, "epss_percentile": 0.76831}, "CVE-2016-4463": {"epss_score": 0.32071, "epss_percentile": 0.9667}, "CVE-2016-4464": {"epss_score": 0.02058, "epss_percentile": 0.83434}, "CVE-2016-4465": {"epss_score": 0.13342, "epss_percentile": 0.93937}, "CVE-2016-4467": {"epss_score": 0.00409, "epss_percentile": 0.60728}, "CVE-2016-4468": {"epss_score": 0.01332, "epss_percentile": 0.79526}, "CVE-2016-4469": {"epss_score": 0.00798, "epss_percentile": 0.73512}, "CVE-2016-4470": {"epss_score": 0.00055, "epss_percentile": 0.17383}, "CVE-2016-4471": {"epss_score": 0.01639, "epss_percentile": 0.81488}, "CVE-2016-4472": {"epss_score": 0.01684, "epss_percentile": 0.81744}, "CVE-2016-4473": {"epss_score": 0.21263, "epss_percentile": 0.9549}, "CVE-2016-4474": {"epss_score": 0.00108, "epss_percentile": 0.2985}, "CVE-2016-4475": {"epss_score": 0.00288, "epss_percentile": 0.51927}, "CVE-2016-4476": {"epss_score": 0.0061, "epss_percentile": 0.69152}, "CVE-2016-4477": {"epss_score": 0.0013, "epss_percentile": 0.33291}, "CVE-2016-4478": {"epss_score": 0.015, "epss_percentile": 0.8071}, "CVE-2016-4480": {"epss_score": 0.00516, "epss_percentile": 0.66037}, "CVE-2016-4482": {"epss_score": 0.00035, "epss_percentile": 0.09823}, "CVE-2016-4483": {"epss_score": 0.00938, "epss_percentile": 0.75712}, "CVE-2016-4484": {"epss_score": 0.00459, "epss_percentile": 0.63466}, "CVE-2016-4485": {"epss_score": 0.00509, "epss_percentile": 0.65734}, "CVE-2016-4486": {"epss_score": 0.0052, "epss_percentile": 0.662}, "CVE-2016-4487": {"epss_score": 0.0012, "epss_percentile": 0.31771}, "CVE-2016-4488": {"epss_score": 0.00333, "epss_percentile": 0.55634}, "CVE-2016-4489": {"epss_score": 0.00333, "epss_percentile": 0.55634}, "CVE-2016-4490": {"epss_score": 0.00467, "epss_percentile": 0.63863}, "CVE-2016-4491": {"epss_score": 0.0052, "epss_percentile": 0.66199}, "CVE-2016-4492": {"epss_score": 0.00304, "epss_percentile": 0.53253}, "CVE-2016-4493": {"epss_score": 0.00442, "epss_percentile": 0.62708}, "CVE-2016-4494": {"epss_score": 0.00064, "epss_percentile": 0.20149}, "CVE-2016-4495": {"epss_score": 0.0018, "epss_percentile": 0.39971}, "CVE-2016-4496": {"epss_score": 0.00103, "epss_percentile": 0.28934}, "CVE-2016-4497": {"epss_score": 0.00227, "epss_percentile": 0.45419}, "CVE-2016-4498": {"epss_score": 0.00329, "epss_percentile": 0.55412}, "CVE-2016-4499": {"epss_score": 0.00119, "epss_percentile": 0.31556}, "CVE-2016-4500": {"epss_score": 0.00169, "epss_percentile": 0.38622}, "CVE-2016-4501": {"epss_score": 0.00337, "epss_percentile": 0.56012}, "CVE-2016-4502": {"epss_score": 0.00233, "epss_percentile": 0.46001}, "CVE-2016-4503": {"epss_score": 0.01337, "epss_percentile": 0.79564}, "CVE-2016-4504": {"epss_score": 0.00103, "epss_percentile": 0.29053}, "CVE-2016-4505": {"epss_score": 0.00227, "epss_percentile": 0.4542}, "CVE-2016-4506": {"epss_score": 0.00056, "epss_percentile": 0.17759}, "CVE-2016-4507": {"epss_score": 0.0021, "epss_percentile": 0.43457}, "CVE-2016-4508": {"epss_score": 0.00534, "epss_percentile": 0.66778}, "CVE-2016-4509": {"epss_score": 0.02546, "epss_percentile": 0.85063}, "CVE-2016-4510": {"epss_score": 0.00691, "epss_percentile": 0.7126}, "CVE-2016-4511": {"epss_score": 0.0005, "epss_percentile": 0.15845}, "CVE-2016-4512": {"epss_score": 0.06408, "epss_percentile": 0.90738}, "CVE-2016-4513": {"epss_score": 0.00337, "epss_percentile": 0.56053}, "CVE-2016-4514": {"epss_score": 0.00265, "epss_percentile": 0.49775}, "CVE-2016-4516": {"epss_score": 0.00047, "epss_percentile": 0.14899}, "CVE-2016-4518": {"epss_score": 0.0041, "epss_percentile": 0.60822}, "CVE-2016-4519": {"epss_score": 0.09753, "epss_percentile": 0.92691}, "CVE-2016-4520": {"epss_score": 0.02714, "epss_percentile": 0.85506}, "CVE-2016-4521": {"epss_score": 0.00411, "epss_percentile": 0.60875}, "CVE-2016-4522": {"epss_score": 0.00631, "epss_percentile": 0.6972}, "CVE-2016-4523": {"epss_score": 0.66951, "epss_percentile": 0.98487}, "CVE-2016-4524": {"epss_score": 0.00047, "epss_percentile": 0.14705}, "CVE-2016-4525": {"epss_score": 0.00231, "epss_percentile": 0.45795}, "CVE-2016-4526": {"epss_score": 0.00057, "epss_percentile": 0.18054}, "CVE-2016-4527": {"epss_score": 0.00046, "epss_percentile": 0.14274}, "CVE-2016-4528": {"epss_score": 0.00141, "epss_percentile": 0.34817}, "CVE-2016-4529": {"epss_score": 0.04299, "epss_percentile": 0.88512}, "CVE-2016-4530": {"epss_score": 0.00557, "epss_percentile": 0.67537}, "CVE-2016-4531": {"epss_score": 0.2096, "epss_percentile": 0.95446}, "CVE-2016-4532": {"epss_score": 0.03935, "epss_percentile": 0.87982}, "CVE-2016-4533": {"epss_score": 0.08341, "epss_percentile": 0.92}, "CVE-2016-4534": {"epss_score": 0.02796, "epss_percentile": 0.85682}, "CVE-2016-4535": {"epss_score": 0.10376, "epss_percentile": 0.92965}, "CVE-2016-4536": {"epss_score": 0.00296, "epss_percentile": 0.52597}, "CVE-2016-4537": {"epss_score": 0.0488, "epss_percentile": 0.89245}, "CVE-2016-4538": {"epss_score": 0.0488, "epss_percentile": 0.89245}, "CVE-2016-4539": {"epss_score": 0.03369, "epss_percentile": 0.87008}, "CVE-2016-4540": {"epss_score": 0.01458, "epss_percentile": 0.80407}, "CVE-2016-4541": {"epss_score": 0.01434, "epss_percentile": 0.80265}, "CVE-2016-4542": {"epss_score": 0.01233, "epss_percentile": 0.78748}, "CVE-2016-4543": {"epss_score": 0.02351, "epss_percentile": 0.84469}, "CVE-2016-4544": {"epss_score": 0.03339, "epss_percentile": 0.8694}, "CVE-2016-4545": {"epss_score": 0.01724, "epss_percentile": 0.8195}, "CVE-2016-4546": {"epss_score": 0.00054, "epss_percentile": 0.17042}, "CVE-2016-4547": {"epss_score": 0.0056, "epss_percentile": 0.67648}, "CVE-2016-4551": {"epss_score": 0.00291, "epss_percentile": 0.52191}, "CVE-2016-4552": {"epss_score": 0.00276, "epss_percentile": 0.50712}, "CVE-2016-4553": {"epss_score": 0.82841, "epss_percentile": 0.99218}, "CVE-2016-4554": {"epss_score": 0.73388, "epss_percentile": 0.9875}, "CVE-2016-4555": {"epss_score": 0.66065, "epss_percentile": 0.98449}, "CVE-2016-4556": {"epss_score": 0.56857, "epss_percentile": 0.98039}, "CVE-2016-4557": {"epss_score": 0.15042, "epss_percentile": 0.94349}, "CVE-2016-4558": {"epss_score": 0.00272, "epss_percentile": 0.50365}, "CVE-2016-4560": {"epss_score": 0.00071, "epss_percentile": 0.22}, "CVE-2016-4561": {"epss_score": 0.00296, "epss_percentile": 0.52621}, "CVE-2016-4562": {"epss_score": 0.00572, "epss_percentile": 0.68019}, "CVE-2016-4563": {"epss_score": 0.00572, "epss_percentile": 0.68019}, "CVE-2016-4564": {"epss_score": 0.00992, "epss_percentile": 0.764}, "CVE-2016-4565": {"epss_score": 0.00184, "epss_percentile": 0.40376}, "CVE-2016-4566": {"epss_score": 0.04653, "epss_percentile": 0.88965}, "CVE-2016-4567": {"epss_score": 0.04155, "epss_percentile": 0.88326}, "CVE-2016-4568": {"epss_score": 0.00084, "epss_percentile": 0.24905}, "CVE-2016-4569": {"epss_score": 0.00366, "epss_percentile": 0.58077}, "CVE-2016-4570": {"epss_score": 0.00808, "epss_percentile": 0.73694}, "CVE-2016-4571": {"epss_score": 0.00808, "epss_percentile": 0.73694}, "CVE-2016-4572": {"epss_score": 0.00345, "epss_percentile": 0.56597}, "CVE-2016-4573": {"epss_score": 0.07629, "epss_percentile": 0.91583}, "CVE-2016-4574": {"epss_score": 0.00956, "epss_percentile": 0.75922}, "CVE-2016-4575": {"epss_score": 0.00116, "epss_percentile": 0.31048}, "CVE-2016-4576": {"epss_score": 0.02348, "epss_percentile": 0.84457}, "CVE-2016-4577": {"epss_score": 0.00125, "epss_percentile": 0.32473}, "CVE-2016-4578": {"epss_score": 0.0013, "epss_percentile": 0.33294}, "CVE-2016-4579": {"epss_score": 0.01164, "epss_percentile": 0.78163}, "CVE-2016-4580": {"epss_score": 0.0155, "epss_percentile": 0.80985}, "CVE-2016-4581": {"epss_score": 0.00033, "epss_percentile": 0.09422}, "CVE-2016-4582": {"epss_score": 0.00119, "epss_percentile": 0.31575}, "CVE-2016-4583": {"epss_score": 0.00389, "epss_percentile": 0.5946}, "CVE-2016-4584": {"epss_score": 0.00768, "epss_percentile": 0.72965}, "CVE-2016-4585": {"epss_score": 0.01012, "epss_percentile": 0.76623}, "CVE-2016-4586": {"epss_score": 0.00667, "epss_percentile": 0.707}, "CVE-2016-4587": {"epss_score": 0.00699, "epss_percentile": 0.71449}, "CVE-2016-4588": {"epss_score": 0.01275, "epss_percentile": 0.79102}, "CVE-2016-4589": {"epss_score": 0.00818, "epss_percentile": 0.73861}, "CVE-2016-4590": {"epss_score": 0.0072, "epss_percentile": 0.71963}, "CVE-2016-4591": {"epss_score": 0.02713, "epss_percentile": 0.85504}, "CVE-2016-4592": {"epss_score": 0.01607, "epss_percentile": 0.81308}, "CVE-2016-4593": {"epss_score": 0.00065, "epss_percentile": 0.20606}, "CVE-2016-4594": {"epss_score": 0.00209, "epss_percentile": 0.43408}, "CVE-2016-4595": {"epss_score": 0.00068, "epss_percentile": 0.21221}, "CVE-2016-4596": {"epss_score": 0.00981, "epss_percentile": 0.76281}, "CVE-2016-4597": {"epss_score": 0.00981, "epss_percentile": 0.76281}, "CVE-2016-4598": {"epss_score": 0.0339, "epss_percentile": 0.87049}, "CVE-2016-4599": {"epss_score": 0.00655, "epss_percentile": 0.70363}, "CVE-2016-4600": {"epss_score": 0.00981, "epss_percentile": 0.76281}, "CVE-2016-4601": {"epss_score": 0.00981, "epss_percentile": 0.76281}, "CVE-2016-4602": {"epss_score": 0.00981, "epss_percentile": 0.76281}, "CVE-2016-4603": {"epss_score": 0.003, "epss_percentile": 0.52959}, "CVE-2016-4604": {"epss_score": 0.00366, "epss_percentile": 0.58018}, "CVE-2016-4605": {"epss_score": 0.00522, "epss_percentile": 0.66274}, "CVE-2016-4606": {"epss_score": 0.00218, "epss_percentile": 0.444}, "CVE-2016-4607": {"epss_score": 0.04742, "epss_percentile": 0.89081}, "CVE-2016-4608": {"epss_score": 0.05214, "epss_percentile": 0.89619}, "CVE-2016-4609": {"epss_score": 0.0559, "epss_percentile": 0.90029}, "CVE-2016-4610": {"epss_score": 0.03258, "epss_percentile": 0.86766}, "CVE-2016-4611": {"epss_score": 0.0092, "epss_percentile": 0.75473}, "CVE-2016-4613": {"epss_score": 0.0059, "epss_percentile": 0.68574}, "CVE-2016-4614": {"epss_score": 0.02581, "epss_percentile": 0.85156}, "CVE-2016-4615": {"epss_score": 0.02581, "epss_percentile": 0.85156}, "CVE-2016-4616": {"epss_score": 0.02581, "epss_percentile": 0.85156}, "CVE-2016-4617": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2016-4618": {"epss_score": 0.005, "epss_percentile": 0.65327}, "CVE-2016-4620": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2016-4621": {"epss_score": 0.00215, "epss_percentile": 0.44049}, "CVE-2016-4622": {"epss_score": 0.74787, "epss_percentile": 0.98817}, "CVE-2016-4623": {"epss_score": 0.00818, "epss_percentile": 0.73861}, "CVE-2016-4624": {"epss_score": 0.01412, "epss_percentile": 0.80114}, "CVE-2016-4625": {"epss_score": 0.00544, "epss_percentile": 0.67137}, "CVE-2016-4626": {"epss_score": 0.00053, "epss_percentile": 0.1684}, "CVE-2016-4627": {"epss_score": 0.00056, "epss_percentile": 0.17709}, "CVE-2016-4628": {"epss_score": 0.00058, "epss_percentile": 0.18476}, "CVE-2016-4629": {"epss_score": 0.11075, "epss_percentile": 0.9321}, "CVE-2016-4630": {"epss_score": 0.01109, "epss_percentile": 0.77645}, "CVE-2016-4631": {"epss_score": 0.0271, "epss_percentile": 0.85482}, "CVE-2016-4632": {"epss_score": 0.02619, "epss_percentile": 0.85253}, "CVE-2016-4633": {"epss_score": 0.0005, "epss_percentile": 0.1596}, "CVE-2016-4634": {"epss_score": 0.00054, "epss_percentile": 0.17243}, "CVE-2016-4635": {"epss_score": 0.00397, "epss_percentile": 0.60029}, "CVE-2016-4637": {"epss_score": 0.02103, "epss_percentile": 0.83611}, "CVE-2016-4638": {"epss_score": 0.00149, "epss_percentile": 0.35933}, "CVE-2016-4639": {"epss_score": 0.00057, "epss_percentile": 0.18216}, "CVE-2016-4640": {"epss_score": 0.0019, "epss_percentile": 0.41076}, "CVE-2016-4641": {"epss_score": 0.00192, "epss_percentile": 0.41366}, "CVE-2016-4642": {"epss_score": 0.00341, "epss_percentile": 0.56298}, "CVE-2016-4643": {"epss_score": 0.0035, "epss_percentile": 0.56963}, "CVE-2016-4644": {"epss_score": 0.00428, "epss_percentile": 0.61928}, "CVE-2016-4645": {"epss_score": 0.00042, "epss_percentile": 0.12594}, "CVE-2016-4646": {"epss_score": 0.00535, "epss_percentile": 0.66804}, "CVE-2016-4647": {"epss_score": 0.00051, "epss_percentile": 0.15993}, "CVE-2016-4648": {"epss_score": 0.00058, "epss_percentile": 0.18402}, "CVE-2016-4649": {"epss_score": 0.0006, "epss_percentile": 0.19066}, "CVE-2016-4650": {"epss_score": 0.00279, "epss_percentile": 0.50994}, "CVE-2016-4651": {"epss_score": 0.00175, "epss_percentile": 0.39288}, "CVE-2016-4652": {"epss_score": 0.00057, "epss_percentile": 0.18216}, "CVE-2016-4653": {"epss_score": 0.00062, "epss_percentile": 0.19714}, "CVE-2016-4654": {"epss_score": 0.0036, "epss_percentile": 0.5765}, "CVE-2016-4655": {"epss_score": 0.8229, "epss_percentile": 0.99185}, "CVE-2016-4656": {"epss_score": 0.73334, "epss_percentile": 0.98747}, "CVE-2016-4657": {"epss_score": 0.78362, "epss_percentile": 0.98983}, "CVE-2016-4658": {"epss_score": 0.19344, "epss_percentile": 0.95166}, "CVE-2016-4660": {"epss_score": 0.01009, "epss_percentile": 0.7659}, "CVE-2016-4661": {"epss_score": 0.00164, "epss_percentile": 0.37881}, "CVE-2016-4662": {"epss_score": 0.0017, "epss_percentile": 0.38754}, "CVE-2016-4663": {"epss_score": 0.00191, "epss_percentile": 0.41275}, "CVE-2016-4664": {"epss_score": 0.00228, "epss_percentile": 0.45543}, "CVE-2016-4665": {"epss_score": 0.00228, "epss_percentile": 0.45543}, "CVE-2016-4666": {"epss_score": 0.01141, "epss_percentile": 0.7796}, "CVE-2016-4667": {"epss_score": 0.00942, "epss_percentile": 0.7576}, "CVE-2016-4669": {"epss_score": 0.33691, "epss_percentile": 0.96798}, "CVE-2016-4670": {"epss_score": 0.0006, "epss_percentile": 0.19013}, "CVE-2016-4671": {"epss_score": 0.0101, "epss_percentile": 0.76592}, "CVE-2016-4673": {"epss_score": 0.0077, "epss_percentile": 0.73006}, "CVE-2016-4674": {"epss_score": 0.00067, "epss_percentile": 0.21102}, "CVE-2016-4675": {"epss_score": 0.00217, "epss_percentile": 0.44334}, "CVE-2016-4676": {"epss_score": 0.01783, "epss_percentile": 0.82249}, "CVE-2016-4677": {"epss_score": 0.01141, "epss_percentile": 0.7796}, "CVE-2016-4678": {"epss_score": 0.00054, "epss_percentile": 0.17292}, "CVE-2016-4679": {"epss_score": 0.00633, "epss_percentile": 0.6977}, "CVE-2016-4680": {"epss_score": 0.00247, "epss_percentile": 0.47885}, "CVE-2016-4681": {"epss_score": 0.00509, "epss_percentile": 0.6575}, "CVE-2016-4682": {"epss_score": 0.0027, "epss_percentile": 0.5027}, "CVE-2016-4683": {"epss_score": 0.00628, "epss_percentile": 0.6966}, "CVE-2016-4685": {"epss_score": 0.00136, "epss_percentile": 0.34095}, "CVE-2016-4686": {"epss_score": 0.00068, "epss_percentile": 0.21292}, "CVE-2016-4688": {"epss_score": 0.01404, "epss_percentile": 0.80036}, "CVE-2016-4689": {"epss_score": 0.00141, "epss_percentile": 0.34949}, "CVE-2016-4690": {"epss_score": 0.00108, "epss_percentile": 0.29825}, "CVE-2016-4691": {"epss_score": 0.0087, "epss_percentile": 0.74702}, "CVE-2016-4692": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-4693": {"epss_score": 0.00134, "epss_percentile": 0.33905}, "CVE-2016-4694": {"epss_score": 0.00961, "epss_percentile": 0.75977}, "CVE-2016-4696": {"epss_score": 0.00215, "epss_percentile": 0.44049}, "CVE-2016-4697": {"epss_score": 0.00215, "epss_percentile": 0.44049}, "CVE-2016-4698": {"epss_score": 0.00239, "epss_percentile": 0.46866}, "CVE-2016-4699": {"epss_score": 0.00228, "epss_percentile": 0.45497}, "CVE-2016-4700": {"epss_score": 0.00228, "epss_percentile": 0.45497}, "CVE-2016-4701": {"epss_score": 0.00063, "epss_percentile": 0.19959}, "CVE-2016-4702": {"epss_score": 0.14118, "epss_percentile": 0.94136}, "CVE-2016-4703": {"epss_score": 0.00215, "epss_percentile": 0.44049}, "CVE-2016-4704": {"epss_score": 0.00054, "epss_percentile": 0.17243}, "CVE-2016-4705": {"epss_score": 0.00054, "epss_percentile": 0.17243}, "CVE-2016-4706": {"epss_score": 0.00049, "epss_percentile": 0.1537}, "CVE-2016-4707": {"epss_score": 0.00059, "epss_percentile": 0.18902}, "CVE-2016-4708": {"epss_score": 0.04174, "epss_percentile": 0.88349}, "CVE-2016-4709": {"epss_score": 0.00046, "epss_percentile": 0.14457}, "CVE-2016-4710": {"epss_score": 0.00046, "epss_percentile": 0.14457}, "CVE-2016-4711": {"epss_score": 0.00485, "epss_percentile": 0.64721}, "CVE-2016-4712": {"epss_score": 0.00354, "epss_percentile": 0.57226}, "CVE-2016-4713": {"epss_score": 0.00288, "epss_percentile": 0.51912}, "CVE-2016-4715": {"epss_score": 0.00228, "epss_percentile": 0.45511}, "CVE-2016-4716": {"epss_score": 0.00049, "epss_percentile": 0.15488}, "CVE-2016-4717": {"epss_score": 0.00203, "epss_percentile": 0.42529}, "CVE-2016-4718": {"epss_score": 0.0232, "epss_percentile": 0.84365}, "CVE-2016-4719": {"epss_score": 0.00233, "epss_percentile": 0.46046}, "CVE-2016-4721": {"epss_score": 0.00263, "epss_percentile": 0.49523}, "CVE-2016-4722": {"epss_score": 0.02514, "epss_percentile": 0.8498}, "CVE-2016-4723": {"epss_score": 0.00228, "epss_percentile": 0.45497}, "CVE-2016-4724": {"epss_score": 0.00172, "epss_percentile": 0.38934}, "CVE-2016-4725": {"epss_score": 0.01307, "epss_percentile": 0.79341}, "CVE-2016-4726": {"epss_score": 0.00353, "epss_percentile": 0.57184}, "CVE-2016-4727": {"epss_score": 0.00215, "epss_percentile": 0.44049}, "CVE-2016-4728": {"epss_score": 0.01042, "epss_percentile": 0.76973}, "CVE-2016-4729": {"epss_score": 0.01203, "epss_percentile": 0.78492}, "CVE-2016-4730": {"epss_score": 0.0165, "epss_percentile": 0.81565}, "CVE-2016-4731": {"epss_score": 0.01203, "epss_percentile": 0.78492}, "CVE-2016-4733": {"epss_score": 0.00818, "epss_percentile": 0.73857}, "CVE-2016-4734": {"epss_score": 0.08398, "epss_percentile": 0.92031}, "CVE-2016-4735": {"epss_score": 0.0165, "epss_percentile": 0.81565}, "CVE-2016-4736": {"epss_score": 0.00767, "epss_percentile": 0.72952}, "CVE-2016-4737": {"epss_score": 0.01841, "epss_percentile": 0.82496}, "CVE-2016-4738": {"epss_score": 0.07628, "epss_percentile": 0.91582}, "CVE-2016-4739": {"epss_score": 0.00345, "epss_percentile": 0.56546}, "CVE-2016-4740": {"epss_score": 0.00069, "epss_percentile": 0.21634}, "CVE-2016-4741": {"epss_score": 0.0067, "epss_percentile": 0.70781}, "CVE-2016-4742": {"epss_score": 0.00254, "epss_percentile": 0.48518}, "CVE-2016-4743": {"epss_score": 0.00356, "epss_percentile": 0.57349}, "CVE-2016-4745": {"epss_score": 0.00407, "epss_percentile": 0.60595}, "CVE-2016-4746": {"epss_score": 0.00456, "epss_percentile": 0.6332}, "CVE-2016-4747": {"epss_score": 0.00171, "epss_percentile": 0.38836}, "CVE-2016-4748": {"epss_score": 0.00058, "epss_percentile": 0.18575}, "CVE-2016-4749": {"epss_score": 0.00056, "epss_percentile": 0.17833}, "CVE-2016-4750": {"epss_score": 0.00223, "epss_percentile": 0.449}, "CVE-2016-4751": {"epss_score": 0.0032, "epss_percentile": 0.54586}, "CVE-2016-4752": {"epss_score": 0.00254, "epss_percentile": 0.48518}, "CVE-2016-4753": {"epss_score": 0.00492, "epss_percentile": 0.64996}, "CVE-2016-4754": {"epss_score": 0.00435, "epss_percentile": 0.6235}, "CVE-2016-4755": {"epss_score": 0.00043, "epss_percentile": 0.13238}, "CVE-2016-4758": {"epss_score": 0.00915, "epss_percentile": 0.75398}, "CVE-2016-4759": {"epss_score": 0.00976, "epss_percentile": 0.76216}, "CVE-2016-4760": {"epss_score": 0.00806, "epss_percentile": 0.73649}, "CVE-2016-4761": {"epss_score": 0.0047, "epss_percentile": 0.63975}, "CVE-2016-4762": {"epss_score": 0.00937, "epss_percentile": 0.75699}, "CVE-2016-4763": {"epss_score": 0.00171, "epss_percentile": 0.38901}, "CVE-2016-4764": {"epss_score": 0.00956, "epss_percentile": 0.75923}, "CVE-2016-4765": {"epss_score": 0.00976, "epss_percentile": 0.76216}, "CVE-2016-4766": {"epss_score": 0.00909, "epss_percentile": 0.75299}, "CVE-2016-4767": {"epss_score": 0.00996, "epss_percentile": 0.76451}, "CVE-2016-4768": {"epss_score": 0.00976, "epss_percentile": 0.76216}, "CVE-2016-4769": {"epss_score": 0.00527, "epss_percentile": 0.66525}, "CVE-2016-4771": {"epss_score": 0.00208, "epss_percentile": 0.43249}, "CVE-2016-4772": {"epss_score": 0.03175, "epss_percentile": 0.86562}, "CVE-2016-4773": {"epss_score": 0.00196, "epss_percentile": 0.41768}, "CVE-2016-4774": {"epss_score": 0.00196, "epss_percentile": 0.41768}, "CVE-2016-4775": {"epss_score": 0.00065, "epss_percentile": 0.2062}, "CVE-2016-4776": {"epss_score": 0.00196, "epss_percentile": 0.41768}, "CVE-2016-4777": {"epss_score": 0.00354, "epss_percentile": 0.57226}, "CVE-2016-4778": {"epss_score": 0.00353, "epss_percentile": 0.57184}, "CVE-2016-4779": {"epss_score": 0.00617, "epss_percentile": 0.69357}, "CVE-2016-4780": {"epss_score": 0.00375, "epss_percentile": 0.58622}, "CVE-2016-4781": {"epss_score": 0.00075, "epss_percentile": 0.23005}, "CVE-2016-4782": {"epss_score": 0.00531, "epss_percentile": 0.66669}, "CVE-2016-4783": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-4784": {"epss_score": 0.02402, "epss_percentile": 0.84643}, "CVE-2016-4785": {"epss_score": 0.02402, "epss_percentile": 0.84643}, "CVE-2016-4786": {"epss_score": 0.03515, "epss_percentile": 0.87272}, "CVE-2016-4787": {"epss_score": 0.02837, "epss_percentile": 0.85793}, "CVE-2016-4788": {"epss_score": 0.00212, "epss_percentile": 0.43799}, "CVE-2016-4789": {"epss_score": 0.00093, "epss_percentile": 0.2666}, "CVE-2016-4790": {"epss_score": 0.00081, "epss_percentile": 0.24306}, "CVE-2016-4791": {"epss_score": 0.00222, "epss_percentile": 0.44804}, "CVE-2016-4792": {"epss_score": 0.00366, "epss_percentile": 0.58096}, "CVE-2016-4793": {"epss_score": 0.08275, "epss_percentile": 0.91963}, "CVE-2016-4794": {"epss_score": 0.00044, "epss_percentile": 0.13461}, "CVE-2016-4796": {"epss_score": 0.00203, "epss_percentile": 0.42498}, "CVE-2016-4797": {"epss_score": 0.00517, "epss_percentile": 0.66087}, "CVE-2016-4800": {"epss_score": 0.00643, "epss_percentile": 0.70065}, "CVE-2016-4802": {"epss_score": 0.00612, "epss_percentile": 0.69211}, "CVE-2016-4803": {"epss_score": 0.00398, "epss_percentile": 0.60056}, "CVE-2016-4804": {"epss_score": 0.00122, "epss_percentile": 0.32058}, "CVE-2016-4805": {"epss_score": 0.00087, "epss_percentile": 0.25508}, "CVE-2016-4806": {"epss_score": 0.06724, "epss_percentile": 0.9097}, "CVE-2016-4807": {"epss_score": 0.0041, "epss_percentile": 0.60834}, "CVE-2016-4808": {"epss_score": 0.00229, "epss_percentile": 0.4566}, "CVE-2016-4809": {"epss_score": 0.02853, "epss_percentile": 0.85833}, "CVE-2016-4810": {"epss_score": 0.00218, "epss_percentile": 0.44411}, "CVE-2016-4811": {"epss_score": 0.00436, "epss_percentile": 0.62457}, "CVE-2016-4812": {"epss_score": 0.00332, "epss_percentile": 0.55608}, "CVE-2016-4813": {"epss_score": 0.00493, "epss_percentile": 0.65058}, "CVE-2016-4814": {"epss_score": 0.00355, "epss_percentile": 0.57284}, "CVE-2016-4815": {"epss_score": 0.00387, "epss_percentile": 0.59304}, "CVE-2016-4816": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2016-4817": {"epss_score": 0.07964, "epss_percentile": 0.91792}, "CVE-2016-4818": {"epss_score": 0.00565, "epss_percentile": 0.67795}, "CVE-2016-4819": {"epss_score": 0.02675, "epss_percentile": 0.85401}, "CVE-2016-4820": {"epss_score": 0.00129, "epss_percentile": 0.33081}, "CVE-2016-4821": {"epss_score": 0.00503, "epss_percentile": 0.65455}, "CVE-2016-4822": {"epss_score": 0.0078, "epss_percentile": 0.73171}, "CVE-2016-4823": {"epss_score": 0.00675, "epss_percentile": 0.70913}, "CVE-2016-4824": {"epss_score": 0.00338, "epss_percentile": 0.56116}, "CVE-2016-4825": {"epss_score": 0.09545, "epss_percentile": 0.92592}, "CVE-2016-4826": {"epss_score": 0.00442, "epss_percentile": 0.62742}, "CVE-2016-4827": {"epss_score": 0.00442, "epss_percentile": 0.62742}, "CVE-2016-4828": {"epss_score": 0.0038, "epss_percentile": 0.58949}, "CVE-2016-4829": {"epss_score": 0.00184, "epss_percentile": 0.40407}, "CVE-2016-4830": {"epss_score": 0.00584, "epss_percentile": 0.68383}, "CVE-2016-4831": {"epss_score": 0.00057, "epss_percentile": 0.1818}, "CVE-2016-4832": {"epss_score": 0.00278, "epss_percentile": 0.50917}, "CVE-2016-4833": {"epss_score": 0.00454, "epss_percentile": 0.63249}, "CVE-2016-4834": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2016-4837": {"epss_score": 0.02606, "epss_percentile": 0.85224}, "CVE-2016-4838": {"epss_score": 0.00315, "epss_percentile": 0.54162}, "CVE-2016-4839": {"epss_score": 0.00555, "epss_percentile": 0.67474}, "CVE-2016-4840": {"epss_score": 0.00584, "epss_percentile": 0.68383}, "CVE-2016-4841": {"epss_score": 0.00672, "epss_percentile": 0.70822}, "CVE-2016-4842": {"epss_score": 0.00359, "epss_percentile": 0.57591}, "CVE-2016-4843": {"epss_score": 0.00932, "epss_percentile": 0.75631}, "CVE-2016-4844": {"epss_score": 0.00672, "epss_percentile": 0.70822}, "CVE-2016-4845": {"epss_score": 0.05576, "epss_percentile": 0.90013}, "CVE-2016-4846": {"epss_score": 0.00187, "epss_percentile": 0.40767}, "CVE-2016-4847": {"epss_score": 0.00514, "epss_percentile": 0.6595}, "CVE-2016-4848": {"epss_score": 0.00471, "epss_percentile": 0.64011}, "CVE-2016-4849": {"epss_score": 0.00801, "epss_percentile": 0.7357}, "CVE-2016-4850": {"epss_score": 0.02186, "epss_percentile": 0.83921}, "CVE-2016-4851": {"epss_score": 0.00278, "epss_percentile": 0.50866}, "CVE-2016-4852": {"epss_score": 0.00686, "epss_percentile": 0.71165}, "CVE-2016-4853": {"epss_score": 0.0036, "epss_percentile": 0.57651}, "CVE-2016-4854": {"epss_score": 0.0014, "epss_percentile": 0.34681}, "CVE-2016-4855": {"epss_score": 0.00361, "epss_percentile": 0.57737}, "CVE-2016-4856": {"epss_score": 0.00304, "epss_percentile": 0.53259}, "CVE-2016-4857": {"epss_score": 0.00173, "epss_percentile": 0.39085}, "CVE-2016-4858": {"epss_score": 0.00176, "epss_percentile": 0.39391}, "CVE-2016-4859": {"epss_score": 0.00229, "epss_percentile": 0.4565}, "CVE-2016-4860": {"epss_score": 0.00923, "epss_percentile": 0.75511}, "CVE-2016-4861": {"epss_score": 0.03977, "epss_percentile": 0.88049}, "CVE-2016-4862": {"epss_score": 0.02432, "epss_percentile": 0.84729}, "CVE-2016-4863": {"epss_score": 0.00118, "epss_percentile": 0.31512}, "CVE-2016-4864": {"epss_score": 0.01598, "epss_percentile": 0.81248}, "CVE-2016-4865": {"epss_score": 0.00404, "epss_percentile": 0.60426}, "CVE-2016-4866": {"epss_score": 0.00404, "epss_percentile": 0.60426}, "CVE-2016-4867": {"epss_score": 0.00216, "epss_percentile": 0.44236}, "CVE-2016-4868": {"epss_score": 0.00672, "epss_percentile": 0.70822}, "CVE-2016-4869": {"epss_score": 0.01162, "epss_percentile": 0.78153}, "CVE-2016-4870": {"epss_score": 0.00276, "epss_percentile": 0.50718}, "CVE-2016-4871": {"epss_score": 0.01511, "epss_percentile": 0.80776}, "CVE-2016-4872": {"epss_score": 0.00216, "epss_percentile": 0.44236}, "CVE-2016-4873": {"epss_score": 0.00279, "epss_percentile": 0.50983}, "CVE-2016-4874": {"epss_score": 0.00231, "epss_percentile": 0.45857}, "CVE-2016-4875": {"epss_score": 0.00601, "epss_percentile": 0.68841}, "CVE-2016-4876": {"epss_score": 0.00117, "epss_percentile": 0.31203}, "CVE-2016-4877": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2016-4878": {"epss_score": 0.00118, "epss_percentile": 0.31476}, "CVE-2016-4879": {"epss_score": 0.00121, "epss_percentile": 0.31945}, "CVE-2016-4880": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2016-4881": {"epss_score": 0.00118, "epss_percentile": 0.31476}, "CVE-2016-4882": {"epss_score": 0.00117, "epss_percentile": 0.31203}, "CVE-2016-4883": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2016-4884": {"epss_score": 0.00117, "epss_percentile": 0.31203}, "CVE-2016-4885": {"epss_score": 0.00117, "epss_percentile": 0.31203}, "CVE-2016-4886": {"epss_score": 0.00117, "epss_percentile": 0.31203}, "CVE-2016-4887": {"epss_score": 0.00117, "epss_percentile": 0.31203}, "CVE-2016-4888": {"epss_score": 0.02389, "epss_percentile": 0.84592}, "CVE-2016-4889": {"epss_score": 0.04312, "epss_percentile": 0.88533}, "CVE-2016-4890": {"epss_score": 0.03, "epss_percentile": 0.86163}, "CVE-2016-4891": {"epss_score": 0.0014, "epss_percentile": 0.34681}, "CVE-2016-4892": {"epss_score": 0.00343, "epss_percentile": 0.56471}, "CVE-2016-4893": {"epss_score": 0.00697, "epss_percentile": 0.71404}, "CVE-2016-4894": {"epss_score": 0.00996, "epss_percentile": 0.76444}, "CVE-2016-4895": {"epss_score": 0.01346, "epss_percentile": 0.79643}, "CVE-2016-4896": {"epss_score": 0.00272, "epss_percentile": 0.50354}, "CVE-2016-4897": {"epss_score": 0.00285, "epss_percentile": 0.51547}, "CVE-2016-4898": {"epss_score": 0.04198, "epss_percentile": 0.88385}, "CVE-2016-4899": {"epss_score": 0.04198, "epss_percentile": 0.88385}, "CVE-2016-4900": {"epss_score": 0.00423, "epss_percentile": 0.61592}, "CVE-2016-4901": {"epss_score": 0.00423, "epss_percentile": 0.61592}, "CVE-2016-4902": {"epss_score": 0.01015, "epss_percentile": 0.76668}, "CVE-2016-4903": {"epss_score": 0.00324, "epss_percentile": 0.54941}, "CVE-2016-4904": {"epss_score": 0.00104, "epss_percentile": 0.291}, "CVE-2016-4905": {"epss_score": 0.01733, "epss_percentile": 0.81999}, "CVE-2016-4906": {"epss_score": 0.00324, "epss_percentile": 0.54941}, "CVE-2016-4907": {"epss_score": 0.00317, "epss_percentile": 0.54365}, "CVE-2016-4908": {"epss_score": 0.00209, "epss_percentile": 0.43396}, "CVE-2016-4909": {"epss_score": 0.00232, "epss_percentile": 0.45889}, "CVE-2016-4910": {"epss_score": 0.00153, "epss_percentile": 0.36624}, "CVE-2016-4911": {"epss_score": 0.00304, "epss_percentile": 0.53265}, "CVE-2016-4912": {"epss_score": 0.00785, "epss_percentile": 0.73254}, "CVE-2016-4913": {"epss_score": 0.00076, "epss_percentile": 0.23084}, "CVE-2016-4921": {"epss_score": 0.01351, "epss_percentile": 0.79678}, "CVE-2016-4922": {"epss_score": 0.00084, "epss_percentile": 0.24831}, "CVE-2016-4923": {"epss_score": 0.00328, "epss_percentile": 0.55192}, "CVE-2016-4924": {"epss_score": 0.00053, "epss_percentile": 0.16722}, "CVE-2016-4925": {"epss_score": 0.01482, "epss_percentile": 0.80573}, "CVE-2016-4926": {"epss_score": 0.03639, "epss_percentile": 0.87485}, "CVE-2016-4927": {"epss_score": 0.00419, "epss_percentile": 0.61387}, "CVE-2016-4928": {"epss_score": 0.00185, "epss_percentile": 0.40508}, "CVE-2016-4929": {"epss_score": 0.01919, "epss_percentile": 0.82886}, "CVE-2016-4930": {"epss_score": 0.00239, "epss_percentile": 0.46881}, "CVE-2016-4931": {"epss_score": 0.00269, "epss_percentile": 0.50173}, "CVE-2016-4945": {"epss_score": 0.00617, "epss_percentile": 0.69359}, "CVE-2016-4946": {"epss_score": 0.00196, "epss_percentile": 0.41746}, "CVE-2016-4947": {"epss_score": 0.00291, "epss_percentile": 0.52195}, "CVE-2016-4948": {"epss_score": 0.00105, "epss_percentile": 0.29363}, "CVE-2016-4949": {"epss_score": 0.00613, "epss_percentile": 0.69256}, "CVE-2016-4950": {"epss_score": 0.00613, "epss_percentile": 0.69256}, "CVE-2016-4951": {"epss_score": 0.00089, "epss_percentile": 0.2582}, "CVE-2016-4952": {"epss_score": 0.00111, "epss_percentile": 0.30278}, "CVE-2016-4953": {"epss_score": 0.14372, "epss_percentile": 0.94196}, "CVE-2016-4954": {"epss_score": 0.01792, "epss_percentile": 0.82285}, "CVE-2016-4955": {"epss_score": 0.04308, "epss_percentile": 0.88526}, "CVE-2016-4956": {"epss_score": 0.01874, "epss_percentile": 0.82647}, "CVE-2016-4957": {"epss_score": 0.53716, "epss_percentile": 0.97894}, "CVE-2016-4959": {"epss_score": 0.0159, "epss_percentile": 0.81199}, "CVE-2016-4960": {"epss_score": 0.00048, "epss_percentile": 0.15025}, "CVE-2016-4961": {"epss_score": 0.00049, "epss_percentile": 0.15479}, "CVE-2016-4962": {"epss_score": 0.00089, "epss_percentile": 0.25823}, "CVE-2016-4963": {"epss_score": 0.00047, "epss_percentile": 0.14702}, "CVE-2016-4964": {"epss_score": 0.0006, "epss_percentile": 0.19022}, "CVE-2016-4965": {"epss_score": 0.07695, "epss_percentile": 0.91631}, "CVE-2016-4966": {"epss_score": 0.02279, "epss_percentile": 0.84237}, "CVE-2016-4967": {"epss_score": 0.01933, "epss_percentile": 0.82951}, "CVE-2016-4968": {"epss_score": 0.03494, "epss_percentile": 0.87234}, "CVE-2016-4969": {"epss_score": 0.00719, "epss_percentile": 0.71943}, "CVE-2016-4970": {"epss_score": 0.0823, "epss_percentile": 0.91941}, "CVE-2016-4971": {"epss_score": 0.75588, "epss_percentile": 0.98856}, "CVE-2016-4972": {"epss_score": 0.03928, "epss_percentile": 0.87968}, "CVE-2016-4973": {"epss_score": 0.00063, "epss_percentile": 0.19955}, "CVE-2016-4974": {"epss_score": 0.02129, "epss_percentile": 0.83704}, "CVE-2016-4975": {"epss_score": 0.73014, "epss_percentile": 0.98733}, "CVE-2016-4976": {"epss_score": 0.00082, "epss_percentile": 0.24512}, "CVE-2016-4977": {"epss_score": 0.94093, "epss_percentile": 0.99901}, "CVE-2016-4978": {"epss_score": 0.01084, "epss_percentile": 0.77394}, "CVE-2016-4979": {"epss_score": 0.32726, "epss_percentile": 0.96719}, "CVE-2016-4980": {"epss_score": 0.00129, "epss_percentile": 0.3312}, "CVE-2016-4982": {"epss_score": 0.00077, "epss_percentile": 0.23529}, "CVE-2016-4983": {"epss_score": 0.00143, "epss_percentile": 0.3515}, "CVE-2016-4984": {"epss_score": 0.00024, "epss_percentile": 0.05735}, "CVE-2016-4985": {"epss_score": 0.00786, "epss_percentile": 0.73266}, "CVE-2016-4986": {"epss_score": 0.0034, "epss_percentile": 0.56262}, "CVE-2016-4987": {"epss_score": 0.00427, "epss_percentile": 0.61777}, "CVE-2016-4988": {"epss_score": 0.00105, "epss_percentile": 0.29374}, "CVE-2016-4989": {"epss_score": 0.00049, "epss_percentile": 0.15379}, "CVE-2016-4991": {"epss_score": 0.01235, "epss_percentile": 0.78761}, "CVE-2016-4992": {"epss_score": 0.00444, "epss_percentile": 0.62835}, "CVE-2016-4993": {"epss_score": 0.01133, "epss_percentile": 0.77884}, "CVE-2016-4994": {"epss_score": 0.00639, "epss_percentile": 0.69932}, "CVE-2016-4995": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2016-4996": {"epss_score": 0.0004, "epss_percentile": 0.11972}, "CVE-2016-4997": {"epss_score": 0.06365, "epss_percentile": 0.90702}, "CVE-2016-4998": {"epss_score": 0.01215, "epss_percentile": 0.78583}, "CVE-2016-4999": {"epss_score": 0.06972, "epss_percentile": 0.91154}, "CVE-2016-5000": {"epss_score": 0.0033, "epss_percentile": 0.5546}, "CVE-2016-5001": {"epss_score": 0.00118, "epss_percentile": 0.31412}, "CVE-2016-5002": {"epss_score": 0.0353, "epss_percentile": 0.873}, "CVE-2016-5003": {"epss_score": 0.41523, "epss_percentile": 0.97281}, "CVE-2016-5004": {"epss_score": 0.01108, "epss_percentile": 0.77639}, "CVE-2016-5005": {"epss_score": 0.00547, "epss_percentile": 0.67259}, "CVE-2016-5006": {"epss_score": 0.00328, "epss_percentile": 0.55285}, "CVE-2016-5007": {"epss_score": 0.00155, "epss_percentile": 0.3679}, "CVE-2016-5008": {"epss_score": 0.02817, "epss_percentile": 0.85738}, "CVE-2016-5009": {"epss_score": 0.01361, "epss_percentile": 0.79751}, "CVE-2016-5010": {"epss_score": 0.00307, "epss_percentile": 0.53491}, "CVE-2016-5011": {"epss_score": 0.00203, "epss_percentile": 0.42551}, "CVE-2016-5012": {"epss_score": 0.00172, "epss_percentile": 0.3899}, "CVE-2016-5013": {"epss_score": 0.00363, "epss_percentile": 0.5783}, "CVE-2016-5014": {"epss_score": 0.00215, "epss_percentile": 0.44102}, "CVE-2016-5016": {"epss_score": 0.00278, "epss_percentile": 0.50899}, "CVE-2016-5017": {"epss_score": 0.06114, "epss_percentile": 0.90489}, "CVE-2016-5018": {"epss_score": 0.0097, "epss_percentile": 0.76116}, "CVE-2016-5019": {"epss_score": 0.06021, "epss_percentile": 0.90415}, "CVE-2016-5020": {"epss_score": 0.01763, "epss_percentile": 0.82155}, "CVE-2016-5021": {"epss_score": 0.00157, "epss_percentile": 0.37134}, "CVE-2016-5022": {"epss_score": 0.03073, "epss_percentile": 0.86352}, "CVE-2016-5023": {"epss_score": 0.02984, "epss_percentile": 0.86127}, "CVE-2016-5024": {"epss_score": 0.01342, "epss_percentile": 0.79593}, "CVE-2016-5025": {"epss_score": 0.00065, "epss_percentile": 0.20456}, "CVE-2016-5026": {"epss_score": 0.00057, "epss_percentile": 0.18006}, "CVE-2016-5027": {"epss_score": 0.00434, "epss_percentile": 0.62293}, "CVE-2016-5028": {"epss_score": 0.00645, "epss_percentile": 0.70099}, "CVE-2016-5029": {"epss_score": 0.00645, "epss_percentile": 0.70099}, "CVE-2016-5030": {"epss_score": 0.00645, "epss_percentile": 0.70099}, "CVE-2016-5031": {"epss_score": 0.00427, "epss_percentile": 0.61887}, "CVE-2016-5032": {"epss_score": 0.00642, "epss_percentile": 0.70042}, "CVE-2016-5033": {"epss_score": 0.00642, "epss_percentile": 0.70042}, "CVE-2016-5034": {"epss_score": 0.00642, "epss_percentile": 0.70042}, "CVE-2016-5035": {"epss_score": 0.00642, "epss_percentile": 0.70042}, "CVE-2016-5036": {"epss_score": 0.00993, "epss_percentile": 0.76408}, "CVE-2016-5037": {"epss_score": 0.00645, "epss_percentile": 0.70099}, "CVE-2016-5038": {"epss_score": 0.00993, "epss_percentile": 0.76408}, "CVE-2016-5039": {"epss_score": 0.00993, "epss_percentile": 0.76408}, "CVE-2016-5040": {"epss_score": 0.00993, "epss_percentile": 0.76408}, "CVE-2016-5041": {"epss_score": 0.00922, "epss_percentile": 0.75488}, "CVE-2016-5042": {"epss_score": 0.00993, "epss_percentile": 0.76408}, "CVE-2016-5043": {"epss_score": 0.00993, "epss_percentile": 0.76408}, "CVE-2016-5044": {"epss_score": 0.00993, "epss_percentile": 0.76408}, "CVE-2016-5045": {"epss_score": 0.00688, "epss_percentile": 0.71202}, "CVE-2016-5047": {"epss_score": 0.00676, "epss_percentile": 0.70943}, "CVE-2016-5048": {"epss_score": 0.01004, "epss_percentile": 0.76527}, "CVE-2016-5049": {"epss_score": 0.00794, "epss_percentile": 0.73437}, "CVE-2016-5050": {"epss_score": 0.0343, "epss_percentile": 0.87123}, "CVE-2016-5051": {"epss_score": 0.00487, "epss_percentile": 0.64779}, "CVE-2016-5052": {"epss_score": 0.00451, "epss_percentile": 0.63114}, "CVE-2016-5053": {"epss_score": 0.02043, "epss_percentile": 0.83378}, "CVE-2016-5054": {"epss_score": 0.00259, "epss_percentile": 0.4908}, "CVE-2016-5055": {"epss_score": 0.0028, "epss_percentile": 0.51081}, "CVE-2016-5056": {"epss_score": 0.00184, "epss_percentile": 0.40372}, "CVE-2016-5057": {"epss_score": 0.0031, "epss_percentile": 0.53767}, "CVE-2016-5058": {"epss_score": 0.00259, "epss_percentile": 0.4908}, "CVE-2016-5059": {"epss_score": 0.00237, "epss_percentile": 0.4665}, "CVE-2016-5060": {"epss_score": 0.00506, "epss_percentile": 0.65638}, "CVE-2016-5061": {"epss_score": 0.00295, "epss_percentile": 0.52491}, "CVE-2016-5062": {"epss_score": 0.00476, "epss_percentile": 0.64282}, "CVE-2016-5063": {"epss_score": 0.16862, "epss_percentile": 0.94739}, "CVE-2016-5065": {"epss_score": 0.00659, "epss_percentile": 0.70506}, "CVE-2016-5066": {"epss_score": 0.00028, "epss_percentile": 0.07347}, "CVE-2016-5067": {"epss_score": 0.00527, "epss_percentile": 0.6644}, "CVE-2016-5068": {"epss_score": 0.00043, "epss_percentile": 0.13085}, "CVE-2016-5069": {"epss_score": 0.00028, "epss_percentile": 0.07514}, "CVE-2016-5070": {"epss_score": 0.0002, "epss_percentile": 0.0452}, "CVE-2016-5071": {"epss_score": 0.00027, "epss_percentile": 0.06943}, "CVE-2016-5072": {"epss_score": 0.0204, "epss_percentile": 0.83365}, "CVE-2016-5073": {"epss_score": 0.00298, "epss_percentile": 0.52804}, "CVE-2016-5074": {"epss_score": 0.0051, "epss_percentile": 0.6581}, "CVE-2016-5075": {"epss_score": 0.00298, "epss_percentile": 0.52804}, "CVE-2016-5076": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2016-5077": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2016-5078": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2016-5080": {"epss_score": 0.33337, "epss_percentile": 0.96764}, "CVE-2016-5081": {"epss_score": 0.01588, "epss_percentile": 0.81186}, "CVE-2016-5084": {"epss_score": 0.01236, "epss_percentile": 0.78775}, "CVE-2016-5085": {"epss_score": 0.032, "epss_percentile": 0.86621}, "CVE-2016-5086": {"epss_score": 0.03014, "epss_percentile": 0.86207}, "CVE-2016-5087": {"epss_score": 0.00221, "epss_percentile": 0.44682}, "CVE-2016-5091": {"epss_score": 0.02369, "epss_percentile": 0.84521}, "CVE-2016-5092": {"epss_score": 0.00313, "epss_percentile": 0.5402}, "CVE-2016-5093": {"epss_score": 0.00974, "epss_percentile": 0.76172}, "CVE-2016-5094": {"epss_score": 0.01691, "epss_percentile": 0.81789}, "CVE-2016-5095": {"epss_score": 0.0095, "epss_percentile": 0.75853}, "CVE-2016-5096": {"epss_score": 0.01942, "epss_percentile": 0.8299}, "CVE-2016-5097": {"epss_score": 0.00551, "epss_percentile": 0.6737}, "CVE-2016-5098": {"epss_score": 0.00452, "epss_percentile": 0.63188}, "CVE-2016-5099": {"epss_score": 0.00493, "epss_percentile": 0.65059}, "CVE-2016-5100": {"epss_score": 0.00288, "epss_percentile": 0.51924}, "CVE-2016-5101": {"epss_score": 0.01057, "epss_percentile": 0.77129}, "CVE-2016-5102": {"epss_score": 0.00499, "epss_percentile": 0.65282}, "CVE-2016-5104": {"epss_score": 0.00908, "epss_percentile": 0.75282}, "CVE-2016-5105": {"epss_score": 0.00064, "epss_percentile": 0.20431}, "CVE-2016-5106": {"epss_score": 0.00064, "epss_percentile": 0.204}, "CVE-2016-5107": {"epss_score": 0.00061, "epss_percentile": 0.19377}, "CVE-2016-5108": {"epss_score": 0.16355, "epss_percentile": 0.94634}, "CVE-2016-5109": {"epss_score": 0.00058, "epss_percentile": 0.185}, "CVE-2016-5114": {"epss_score": 0.01016, "epss_percentile": 0.76676}, "CVE-2016-5115": {"epss_score": 0.00432, "epss_percentile": 0.62115}, "CVE-2016-5116": {"epss_score": 0.02731, "epss_percentile": 0.85539}, "CVE-2016-5117": {"epss_score": 0.0027, "epss_percentile": 0.50273}, "CVE-2016-5118": {"epss_score": 0.36711, "epss_percentile": 0.96997}, "CVE-2016-5119": {"epss_score": 0.0026, "epss_percentile": 0.49102}, "CVE-2016-5124": {"epss_score": 0.00462, "epss_percentile": 0.63589}, "CVE-2016-5126": {"epss_score": 0.00263, "epss_percentile": 0.49407}, "CVE-2016-5127": {"epss_score": 0.02155, "epss_percentile": 0.83805}, "CVE-2016-5128": {"epss_score": 0.01195, "epss_percentile": 0.78428}, "CVE-2016-5129": {"epss_score": 0.02444, "epss_percentile": 0.84764}, "CVE-2016-5130": {"epss_score": 0.01114, "epss_percentile": 0.77703}, "CVE-2016-5131": {"epss_score": 0.03868, "epss_percentile": 0.87876}, "CVE-2016-5132": {"epss_score": 0.01308, "epss_percentile": 0.79349}, "CVE-2016-5133": {"epss_score": 0.00644, "epss_percentile": 0.7009}, "CVE-2016-5134": {"epss_score": 0.01176, "epss_percentile": 0.78267}, "CVE-2016-5135": {"epss_score": 0.00752, "epss_percentile": 0.72662}, "CVE-2016-5136": {"epss_score": 0.01987, "epss_percentile": 0.83162}, "CVE-2016-5137": {"epss_score": 0.00998, "epss_percentile": 0.76468}, "CVE-2016-5138": {"epss_score": 0.01073, "epss_percentile": 0.77284}, "CVE-2016-5139": {"epss_score": 0.01279, "epss_percentile": 0.79131}, "CVE-2016-5140": {"epss_score": 0.02379, "epss_percentile": 0.84561}, "CVE-2016-5141": {"epss_score": 0.01037, "epss_percentile": 0.76931}, "CVE-2016-5142": {"epss_score": 0.01914, "epss_percentile": 0.82846}, "CVE-2016-5143": {"epss_score": 0.0127, "epss_percentile": 0.79052}, "CVE-2016-5144": {"epss_score": 0.01233, "epss_percentile": 0.78749}, "CVE-2016-5145": {"epss_score": 0.01445, "epss_percentile": 0.80322}, "CVE-2016-5146": {"epss_score": 0.00531, "epss_percentile": 0.66661}, "CVE-2016-5147": {"epss_score": 0.00683, "epss_percentile": 0.711}, "CVE-2016-5148": {"epss_score": 0.0067, "epss_percentile": 0.70772}, "CVE-2016-5149": {"epss_score": 0.01312, "epss_percentile": 0.79374}, "CVE-2016-5150": {"epss_score": 0.01554, "epss_percentile": 0.81001}, "CVE-2016-5151": {"epss_score": 0.01038, "epss_percentile": 0.76932}, "CVE-2016-5152": {"epss_score": 0.01001, "epss_percentile": 0.76501}, "CVE-2016-5153": {"epss_score": 0.01834, "epss_percentile": 0.82461}, "CVE-2016-5154": {"epss_score": 0.01051, "epss_percentile": 0.77075}, "CVE-2016-5155": {"epss_score": 0.00769, "epss_percentile": 0.72989}, "CVE-2016-5156": {"epss_score": 0.01684, "epss_percentile": 0.81745}, "CVE-2016-5157": {"epss_score": 0.06592, "epss_percentile": 0.90874}, "CVE-2016-5158": {"epss_score": 0.00754, "epss_percentile": 0.72695}, "CVE-2016-5159": {"epss_score": 0.0126, "epss_percentile": 0.78968}, "CVE-2016-5160": {"epss_score": 0.00682, "epss_percentile": 0.71069}, "CVE-2016-5161": {"epss_score": 0.01834, "epss_percentile": 0.82461}, "CVE-2016-5162": {"epss_score": 0.00682, "epss_percentile": 0.71069}, "CVE-2016-5163": {"epss_score": 0.01462, "epss_percentile": 0.80435}, "CVE-2016-5164": {"epss_score": 0.0049, "epss_percentile": 0.6492}, "CVE-2016-5165": {"epss_score": 0.00504, "epss_percentile": 0.65551}, "CVE-2016-5166": {"epss_score": 0.00633, "epss_percentile": 0.6976}, "CVE-2016-5167": {"epss_score": 0.01754, "epss_percentile": 0.82119}, "CVE-2016-5168": {"epss_score": 0.09634, "epss_percentile": 0.92633}, "CVE-2016-5169": {"epss_score": 0.00578, "epss_percentile": 0.68206}, "CVE-2016-5170": {"epss_score": 0.00728, "epss_percentile": 0.72104}, "CVE-2016-5171": {"epss_score": 0.00728, "epss_percentile": 0.72104}, "CVE-2016-5172": {"epss_score": 0.01104, "epss_percentile": 0.77597}, "CVE-2016-5173": {"epss_score": 0.00749, "epss_percentile": 0.72591}, "CVE-2016-5174": {"epss_score": 0.01131, "epss_percentile": 0.77855}, "CVE-2016-5175": {"epss_score": 0.00419, "epss_percentile": 0.61352}, "CVE-2016-5176": {"epss_score": 0.0021, "epss_percentile": 0.43492}, "CVE-2016-5177": {"epss_score": 0.0165, "epss_percentile": 0.81561}, "CVE-2016-5178": {"epss_score": 0.01854, "epss_percentile": 0.82551}, "CVE-2016-5179": {"epss_score": 0.03187, "epss_percentile": 0.86591}, "CVE-2016-5180": {"epss_score": 0.19344, "epss_percentile": 0.95167}, "CVE-2016-5181": {"epss_score": 0.00346, "epss_percentile": 0.56733}, "CVE-2016-5182": {"epss_score": 0.00543, "epss_percentile": 0.67115}, "CVE-2016-5183": {"epss_score": 0.00858, "epss_percentile": 0.74508}, "CVE-2016-5184": {"epss_score": 0.00512, "epss_percentile": 0.65851}, "CVE-2016-5185": {"epss_score": 0.00512, "epss_percentile": 0.65851}, "CVE-2016-5186": {"epss_score": 0.00329, "epss_percentile": 0.55403}, "CVE-2016-5187": {"epss_score": 0.00385, "epss_percentile": 0.59213}, "CVE-2016-5188": {"epss_score": 0.00355, "epss_percentile": 0.5727}, "CVE-2016-5189": {"epss_score": 0.00345, "epss_percentile": 0.56601}, "CVE-2016-5190": {"epss_score": 0.00613, "epss_percentile": 0.69257}, "CVE-2016-5191": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2016-5192": {"epss_score": 0.00242, "epss_percentile": 0.47378}, "CVE-2016-5193": {"epss_score": 0.00275, "epss_percentile": 0.50632}, "CVE-2016-5194": {"epss_score": 0.00253, "epss_percentile": 0.48426}, "CVE-2016-5195": {"epss_score": 0.94176, "epss_percentile": 0.99912}, "CVE-2016-5196": {"epss_score": 0.00617, "epss_percentile": 0.69362}, "CVE-2016-5197": {"epss_score": 0.00617, "epss_percentile": 0.69362}, "CVE-2016-5198": {"epss_score": 0.77011, "epss_percentile": 0.98916}, "CVE-2016-5199": {"epss_score": 0.0072, "epss_percentile": 0.7196}, "CVE-2016-5200": {"epss_score": 0.02668, "epss_percentile": 0.85382}, "CVE-2016-5201": {"epss_score": 0.0052, "epss_percentile": 0.66185}, "CVE-2016-5202": {"epss_score": 0.00145, "epss_percentile": 0.35514}, "CVE-2016-5203": {"epss_score": 0.00543, "epss_percentile": 0.67115}, "CVE-2016-5204": {"epss_score": 0.003, "epss_percentile": 0.52944}, "CVE-2016-5205": {"epss_score": 0.00247, "epss_percentile": 0.47822}, "CVE-2016-5206": {"epss_score": 0.00299, "epss_percentile": 0.52897}, "CVE-2016-5207": {"epss_score": 0.00227, "epss_percentile": 0.45455}, "CVE-2016-5208": {"epss_score": 0.00247, "epss_percentile": 0.47822}, "CVE-2016-5209": {"epss_score": 0.00512, "epss_percentile": 0.65851}, "CVE-2016-5210": {"epss_score": 0.00821, "epss_percentile": 0.73901}, "CVE-2016-5211": {"epss_score": 0.00543, "epss_percentile": 0.67115}, "CVE-2016-5212": {"epss_score": 0.00374, "epss_percentile": 0.58539}, "CVE-2016-5213": {"epss_score": 0.00512, "epss_percentile": 0.65851}, "CVE-2016-5214": {"epss_score": 0.00328, "epss_percentile": 0.55259}, "CVE-2016-5215": {"epss_score": 0.00492, "epss_percentile": 0.64991}, "CVE-2016-5216": {"epss_score": 0.00492, "epss_percentile": 0.64989}, "CVE-2016-5217": {"epss_score": 0.00224, "epss_percentile": 0.45037}, "CVE-2016-5218": {"epss_score": 0.00356, "epss_percentile": 0.57365}, "CVE-2016-5219": {"epss_score": 0.00534, "epss_percentile": 0.66785}, "CVE-2016-5220": {"epss_score": 0.00352, "epss_percentile": 0.57091}, "CVE-2016-5221": {"epss_score": 0.00303, "epss_percentile": 0.53217}, "CVE-2016-5222": {"epss_score": 0.00356, "epss_percentile": 0.57365}, "CVE-2016-5223": {"epss_score": 0.00481, "epss_percentile": 0.64517}, "CVE-2016-5224": {"epss_score": 0.00231, "epss_percentile": 0.45807}, "CVE-2016-5225": {"epss_score": 0.00231, "epss_percentile": 0.45807}, "CVE-2016-5226": {"epss_score": 0.00163, "epss_percentile": 0.37825}, "CVE-2016-5228": {"epss_score": 0.33708, "epss_percentile": 0.96799}, "CVE-2016-5229": {"epss_score": 0.0603, "epss_percentile": 0.90422}, "CVE-2016-5230": {"epss_score": 0.00213, "epss_percentile": 0.43825}, "CVE-2016-5231": {"epss_score": 0.00098, "epss_percentile": 0.27682}, "CVE-2016-5232": {"epss_score": 0.0007, "epss_percentile": 0.21638}, "CVE-2016-5233": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2016-5234": {"epss_score": 0.0167, "epss_percentile": 0.81673}, "CVE-2016-5235": {"epss_score": 0.00342, "epss_percentile": 0.56373}, "CVE-2016-5236": {"epss_score": 0.00207, "epss_percentile": 0.43191}, "CVE-2016-5237": {"epss_score": 0.00141, "epss_percentile": 0.34844}, "CVE-2016-5238": {"epss_score": 0.00061, "epss_percentile": 0.19377}, "CVE-2016-5239": {"epss_score": 0.00922, "epss_percentile": 0.75488}, "CVE-2016-5240": {"epss_score": 0.00599, "epss_percentile": 0.68794}, "CVE-2016-5241": {"epss_score": 0.00354, "epss_percentile": 0.57219}, "CVE-2016-5242": {"epss_score": 0.00137, "epss_percentile": 0.34311}, "CVE-2016-5243": {"epss_score": 0.00043, "epss_percentile": 0.13319}, "CVE-2016-5244": {"epss_score": 0.00578, "epss_percentile": 0.68198}, "CVE-2016-5247": {"epss_score": 0.0007, "epss_percentile": 0.21711}, "CVE-2016-5248": {"epss_score": 0.00066, "epss_percentile": 0.2088}, "CVE-2016-5249": {"epss_score": 0.00171, "epss_percentile": 0.38794}, "CVE-2016-5250": {"epss_score": 0.00527, "epss_percentile": 0.66528}, "CVE-2016-5251": {"epss_score": 0.00489, "epss_percentile": 0.64912}, "CVE-2016-5252": {"epss_score": 0.01493, "epss_percentile": 0.80641}, "CVE-2016-5253": {"epss_score": 0.00058, "epss_percentile": 0.18512}, "CVE-2016-5254": {"epss_score": 0.00892, "epss_percentile": 0.75069}, "CVE-2016-5255": {"epss_score": 0.01121, "epss_percentile": 0.77767}, "CVE-2016-5256": {"epss_score": 0.01023, "epss_percentile": 0.76767}, "CVE-2016-5257": {"epss_score": 0.00817, "epss_percentile": 0.73839}, "CVE-2016-5258": {"epss_score": 0.01059, "epss_percentile": 0.77161}, "CVE-2016-5259": {"epss_score": 0.0115, "epss_percentile": 0.78027}, "CVE-2016-5260": {"epss_score": 0.00569, "epss_percentile": 0.67934}, "CVE-2016-5261": {"epss_score": 0.01136, "epss_percentile": 0.77918}, "CVE-2016-5262": {"epss_score": 0.00294, "epss_percentile": 0.52377}, "CVE-2016-5263": {"epss_score": 0.00678, "epss_percentile": 0.70982}, "CVE-2016-5264": {"epss_score": 0.01012, "epss_percentile": 0.76626}, "CVE-2016-5265": {"epss_score": 0.00261, "epss_percentile": 0.49293}, "CVE-2016-5266": {"epss_score": 0.00428, "epss_percentile": 0.61928}, "CVE-2016-5267": {"epss_score": 0.00369, "epss_percentile": 0.58231}, "CVE-2016-5268": {"epss_score": 0.00443, "epss_percentile": 0.62788}, "CVE-2016-5270": {"epss_score": 0.02647, "epss_percentile": 0.85332}, "CVE-2016-5271": {"epss_score": 0.00609, "epss_percentile": 0.69124}, "CVE-2016-5272": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2016-5273": {"epss_score": 0.00571, "epss_percentile": 0.67988}, "CVE-2016-5274": {"epss_score": 0.01508, "epss_percentile": 0.80758}, "CVE-2016-5275": {"epss_score": 0.02584, "epss_percentile": 0.8516}, "CVE-2016-5276": {"epss_score": 0.01149, "epss_percentile": 0.78019}, "CVE-2016-5277": {"epss_score": 0.01354, "epss_percentile": 0.79699}, "CVE-2016-5278": {"epss_score": 0.01362, "epss_percentile": 0.79763}, "CVE-2016-5279": {"epss_score": 0.00399, "epss_percentile": 0.60111}, "CVE-2016-5280": {"epss_score": 0.017, "epss_percentile": 0.8183}, "CVE-2016-5281": {"epss_score": 0.01737, "epss_percentile": 0.82019}, "CVE-2016-5282": {"epss_score": 0.00454, "epss_percentile": 0.63246}, "CVE-2016-5283": {"epss_score": 0.00095, "epss_percentile": 0.27224}, "CVE-2016-5284": {"epss_score": 0.00462, "epss_percentile": 0.63621}, "CVE-2016-5285": {"epss_score": 0.00646, "epss_percentile": 0.70133}, "CVE-2016-5287": {"epss_score": 0.00563, "epss_percentile": 0.67724}, "CVE-2016-5288": {"epss_score": 0.00438, "epss_percentile": 0.62554}, "CVE-2016-5289": {"epss_score": 0.01811, "epss_percentile": 0.82365}, "CVE-2016-5290": {"epss_score": 0.01874, "epss_percentile": 0.82651}, "CVE-2016-5291": {"epss_score": 0.00037, "epss_percentile": 0.10625}, "CVE-2016-5292": {"epss_score": 0.00858, "epss_percentile": 0.7451}, "CVE-2016-5293": {"epss_score": 0.00071, "epss_percentile": 0.22227}, "CVE-2016-5294": {"epss_score": 0.00071, "epss_percentile": 0.22227}, "CVE-2016-5295": {"epss_score": 0.0008, "epss_percentile": 0.24052}, "CVE-2016-5296": {"epss_score": 0.0257, "epss_percentile": 0.85125}, "CVE-2016-5297": {"epss_score": 0.01818, "epss_percentile": 0.824}, "CVE-2016-5298": {"epss_score": 0.00639, "epss_percentile": 0.69951}, "CVE-2016-5299": {"epss_score": 0.00822, "epss_percentile": 0.73917}, "CVE-2016-5300": {"epss_score": 0.0197, "epss_percentile": 0.83096}, "CVE-2016-5301": {"epss_score": 0.01385, "epss_percentile": 0.79903}, "CVE-2016-5302": {"epss_score": 0.01175, "epss_percentile": 0.78264}, "CVE-2016-5303": {"epss_score": 0.00355, "epss_percentile": 0.57285}, "CVE-2016-5304": {"epss_score": 0.07147, "epss_percentile": 0.91282}, "CVE-2016-5305": {"epss_score": 0.00456, "epss_percentile": 0.6335}, "CVE-2016-5306": {"epss_score": 0.0034, "epss_percentile": 0.56258}, "CVE-2016-5307": {"epss_score": 0.00103, "epss_percentile": 0.29085}, "CVE-2016-5308": {"epss_score": 0.02502, "epss_percentile": 0.84926}, "CVE-2016-5309": {"epss_score": 0.08027, "epss_percentile": 0.91839}, "CVE-2016-5310": {"epss_score": 0.07963, "epss_percentile": 0.91792}, "CVE-2016-5311": {"epss_score": 0.00289, "epss_percentile": 0.51997}, "CVE-2016-5312": {"epss_score": 0.40029, "epss_percentile": 0.97191}, "CVE-2016-5313": {"epss_score": 0.25812, "epss_percentile": 0.96075}, "CVE-2016-5314": {"epss_score": 0.011, "epss_percentile": 0.77568}, "CVE-2016-5315": {"epss_score": 0.00417, "epss_percentile": 0.61229}, "CVE-2016-5316": {"epss_score": 0.00858, "epss_percentile": 0.74504}, "CVE-2016-5317": {"epss_score": 0.00611, "epss_percentile": 0.69178}, "CVE-2016-5318": {"epss_score": 0.00879, "epss_percentile": 0.7484}, "CVE-2016-5319": {"epss_score": 0.00506, "epss_percentile": 0.65617}, "CVE-2016-5321": {"epss_score": 0.00173, "epss_percentile": 0.39077}, "CVE-2016-5322": {"epss_score": 0.0018, "epss_percentile": 0.39882}, "CVE-2016-5323": {"epss_score": 0.01105, "epss_percentile": 0.77606}, "CVE-2016-5325": {"epss_score": 0.01004, "epss_percentile": 0.76527}, "CVE-2016-5328": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2016-5329": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2016-5330": {"epss_score": 0.25479, "epss_percentile": 0.96032}, "CVE-2016-5331": {"epss_score": 0.00332, "epss_percentile": 0.55587}, "CVE-2016-5332": {"epss_score": 0.0024, "epss_percentile": 0.47217}, "CVE-2016-5333": {"epss_score": 0.01586, "epss_percentile": 0.81169}, "CVE-2016-5334": {"epss_score": 0.0023, "epss_percentile": 0.45764}, "CVE-2016-5335": {"epss_score": 0.00034, "epss_percentile": 0.09763}, "CVE-2016-5336": {"epss_score": 0.01931, "epss_percentile": 0.8294}, "CVE-2016-5337": {"epss_score": 0.00053, "epss_percentile": 0.17013}, "CVE-2016-5338": {"epss_score": 0.00083, "epss_percentile": 0.24741}, "CVE-2016-5340": {"epss_score": 0.00033, "epss_percentile": 0.09423}, "CVE-2016-5341": {"epss_score": 0.00229, "epss_percentile": 0.45649}, "CVE-2016-5342": {"epss_score": 0.00614, "epss_percentile": 0.69286}, "CVE-2016-5343": {"epss_score": 0.0106, "epss_percentile": 0.77165}, "CVE-2016-5344": {"epss_score": 0.00651, "epss_percentile": 0.70284}, "CVE-2016-5345": {"epss_score": 0.0006, "epss_percentile": 0.19063}, "CVE-2016-5346": {"epss_score": 0.00105, "epss_percentile": 0.29323}, "CVE-2016-5347": {"epss_score": 0.00128, "epss_percentile": 0.33038}, "CVE-2016-5348": {"epss_score": 0.09597, "epss_percentile": 0.92614}, "CVE-2016-5349": {"epss_score": 0.00123, "epss_percentile": 0.32204}, "CVE-2016-5350": {"epss_score": 0.00357, "epss_percentile": 0.57453}, "CVE-2016-5351": {"epss_score": 0.00278, "epss_percentile": 0.50872}, "CVE-2016-5352": {"epss_score": 0.00255, "epss_percentile": 0.48638}, "CVE-2016-5353": {"epss_score": 0.00278, "epss_percentile": 0.50872}, "CVE-2016-5354": {"epss_score": 0.00362, "epss_percentile": 0.5781}, "CVE-2016-5355": {"epss_score": 0.00865, "epss_percentile": 0.74617}, "CVE-2016-5356": {"epss_score": 0.00865, "epss_percentile": 0.74617}, "CVE-2016-5357": {"epss_score": 0.00671, "epss_percentile": 0.708}, "CVE-2016-5358": {"epss_score": 0.00209, "epss_percentile": 0.43398}, "CVE-2016-5359": {"epss_score": 0.00255, "epss_percentile": 0.48638}, "CVE-2016-5360": {"epss_score": 0.46077, "epss_percentile": 0.97522}, "CVE-2016-5361": {"epss_score": 0.00953, "epss_percentile": 0.75884}, "CVE-2016-5362": {"epss_score": 0.0631, "epss_percentile": 0.90662}, "CVE-2016-5363": {"epss_score": 0.04749, "epss_percentile": 0.89101}, "CVE-2016-5364": {"epss_score": 0.00297, "epss_percentile": 0.52746}, "CVE-2016-5365": {"epss_score": 0.01691, "epss_percentile": 0.81779}, "CVE-2016-5366": {"epss_score": 0.00105, "epss_percentile": 0.29351}, "CVE-2016-5367": {"epss_score": 0.00137, "epss_percentile": 0.34324}, "CVE-2016-5368": {"epss_score": 0.00281, "epss_percentile": 0.51134}, "CVE-2016-5372": {"epss_score": 0.00089, "epss_percentile": 0.25947}, "CVE-2016-5374": {"epss_score": 0.00373, "epss_percentile": 0.58515}, "CVE-2016-5383": {"epss_score": 0.01452, "epss_percentile": 0.8037}, "CVE-2016-5384": {"epss_score": 0.00195, "epss_percentile": 0.41655}, "CVE-2016-5385": {"epss_score": 0.82999, "epss_percentile": 0.99225}, "CVE-2016-5386": {"epss_score": 0.81558, "epss_percentile": 0.99144}, "CVE-2016-5387": {"epss_score": 0.77268, "epss_percentile": 0.98929}, "CVE-2016-5388": {"epss_score": 0.65438, "epss_percentile": 0.98418}, "CVE-2016-5390": {"epss_score": 0.00259, "epss_percentile": 0.4904}, "CVE-2016-5391": {"epss_score": 0.0089, "epss_percentile": 0.75025}, "CVE-2016-5392": {"epss_score": 0.00181, "epss_percentile": 0.40054}, "CVE-2016-5393": {"epss_score": 0.02585, "epss_percentile": 0.85164}, "CVE-2016-5394": {"epss_score": 0.01094, "epss_percentile": 0.77495}, "CVE-2016-5395": {"epss_score": 0.00129, "epss_percentile": 0.33184}, "CVE-2016-5396": {"epss_score": 0.01806, "epss_percentile": 0.82349}, "CVE-2016-5397": {"epss_score": 0.22566, "epss_percentile": 0.95652}, "CVE-2016-5398": {"epss_score": 0.00191, "epss_percentile": 0.41206}, "CVE-2016-5399": {"epss_score": 0.2096, "epss_percentile": 0.95447}, "CVE-2016-5400": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2016-5401": {"epss_score": 0.0013, "epss_percentile": 0.33326}, "CVE-2016-5402": {"epss_score": 0.03126, "epss_percentile": 0.86456}, "CVE-2016-5403": {"epss_score": 0.00056, "epss_percentile": 0.17883}, "CVE-2016-5404": {"epss_score": 0.00341, "epss_percentile": 0.56324}, "CVE-2016-5405": {"epss_score": 0.00593, "epss_percentile": 0.68634}, "CVE-2016-5406": {"epss_score": 0.01504, "epss_percentile": 0.80739}, "CVE-2016-5407": {"epss_score": 0.02123, "epss_percentile": 0.83684}, "CVE-2016-5408": {"epss_score": 0.05371, "epss_percentile": 0.89795}, "CVE-2016-5409": {"epss_score": 0.00234, "epss_percentile": 0.46108}, "CVE-2016-5410": {"epss_score": 0.0006, "epss_percentile": 0.1901}, "CVE-2016-5411": {"epss_score": 0.00413, "epss_percentile": 0.6096}, "CVE-2016-5412": {"epss_score": 0.0008, "epss_percentile": 0.24029}, "CVE-2016-5414": {"epss_score": 0.00166, "epss_percentile": 0.38184}, "CVE-2016-5416": {"epss_score": 0.00296, "epss_percentile": 0.52574}, "CVE-2016-5417": {"epss_score": 0.01185, "epss_percentile": 0.78339}, "CVE-2016-5418": {"epss_score": 0.05224, "epss_percentile": 0.89631}, "CVE-2016-5419": {"epss_score": 0.01514, "epss_percentile": 0.80792}, "CVE-2016-5420": {"epss_score": 0.00552, "epss_percentile": 0.67383}, "CVE-2016-5421": {"epss_score": 0.01296, "epss_percentile": 0.79258}, "CVE-2016-5422": {"epss_score": 0.00735, "epss_percentile": 0.72294}, "CVE-2016-5423": {"epss_score": 0.02712, "epss_percentile": 0.855}, "CVE-2016-5424": {"epss_score": 0.01294, "epss_percentile": 0.79241}, "CVE-2016-5425": {"epss_score": 0.14472, "epss_percentile": 0.9422}, "CVE-2016-5426": {"epss_score": 0.33823, "epss_percentile": 0.96806}, "CVE-2016-5427": {"epss_score": 0.85547, "epss_percentile": 0.99339}, "CVE-2016-5429": {"epss_score": 0.00325, "epss_percentile": 0.54991}, "CVE-2016-5430": {"epss_score": 0.00274, "epss_percentile": 0.50545}, "CVE-2016-5431": {"epss_score": 0.00078, "epss_percentile": 0.2358}, "CVE-2016-5432": {"epss_score": 0.00134, "epss_percentile": 0.33872}, "CVE-2016-5433": {"epss_score": 0.00103, "epss_percentile": 0.29041}, "CVE-2016-5434": {"epss_score": 0.0046, "epss_percentile": 0.635}, "CVE-2016-5435": {"epss_score": 0.00146, "epss_percentile": 0.35639}, "CVE-2016-5436": {"epss_score": 0.00945, "epss_percentile": 0.75801}, "CVE-2016-5437": {"epss_score": 0.00744, "epss_percentile": 0.72513}, "CVE-2016-5439": {"epss_score": 0.00438, "epss_percentile": 0.62544}, "CVE-2016-5440": {"epss_score": 0.00707, "epss_percentile": 0.71644}, "CVE-2016-5441": {"epss_score": 0.00744, "epss_percentile": 0.72513}, "CVE-2016-5442": {"epss_score": 0.00593, "epss_percentile": 0.68645}, "CVE-2016-5443": {"epss_score": 0.00056, "epss_percentile": 0.17919}, "CVE-2016-5444": {"epss_score": 0.03806, "epss_percentile": 0.87751}, "CVE-2016-5445": {"epss_score": 0.00732, "epss_percentile": 0.72188}, "CVE-2016-5446": {"epss_score": 0.00732, "epss_percentile": 0.72188}, "CVE-2016-5447": {"epss_score": 0.01709, "epss_percentile": 0.81869}, "CVE-2016-5448": {"epss_score": 0.00933, "epss_percentile": 0.75642}, "CVE-2016-5449": {"epss_score": 0.02123, "epss_percentile": 0.83685}, "CVE-2016-5450": {"epss_score": 0.00416, "epss_percentile": 0.612}, "CVE-2016-5451": {"epss_score": 0.00349, "epss_percentile": 0.56859}, "CVE-2016-5452": {"epss_score": 0.00095, "epss_percentile": 0.27117}, "CVE-2016-5453": {"epss_score": 0.01607, "epss_percentile": 0.81308}, "CVE-2016-5454": {"epss_score": 0.00135, "epss_percentile": 0.33977}, "CVE-2016-5455": {"epss_score": 0.00433, "epss_percentile": 0.62187}, "CVE-2016-5456": {"epss_score": 0.00263, "epss_percentile": 0.49486}, "CVE-2016-5457": {"epss_score": 0.02433, "epss_percentile": 0.84733}, "CVE-2016-5458": {"epss_score": 0.00248, "epss_percentile": 0.47914}, "CVE-2016-5459": {"epss_score": 0.00416, "epss_percentile": 0.612}, "CVE-2016-5460": {"epss_score": 0.00366, "epss_percentile": 0.58085}, "CVE-2016-5461": {"epss_score": 0.00306, "epss_percentile": 0.53459}, "CVE-2016-5462": {"epss_score": 0.00255, "epss_percentile": 0.48629}, "CVE-2016-5463": {"epss_score": 0.00277, "epss_percentile": 0.50786}, "CVE-2016-5464": {"epss_score": 0.00277, "epss_percentile": 0.50786}, "CVE-2016-5465": {"epss_score": 0.00401, "epss_percentile": 0.6021}, "CVE-2016-5466": {"epss_score": 0.00366, "epss_percentile": 0.58085}, "CVE-2016-5467": {"epss_score": 0.00248, "epss_percentile": 0.47914}, "CVE-2016-5468": {"epss_score": 0.00248, "epss_percentile": 0.47914}, "CVE-2016-5469": {"epss_score": 0.00103, "epss_percentile": 0.29048}, "CVE-2016-5470": {"epss_score": 0.00574, "epss_percentile": 0.68088}, "CVE-2016-5471": {"epss_score": 0.0017, "epss_percentile": 0.38747}, "CVE-2016-5472": {"epss_score": 0.0008, "epss_percentile": 0.24177}, "CVE-2016-5473": {"epss_score": 0.0022, "epss_percentile": 0.44589}, "CVE-2016-5474": {"epss_score": 0.02433, "epss_percentile": 0.84733}, "CVE-2016-5475": {"epss_score": 0.00704, "epss_percentile": 0.71566}, "CVE-2016-5476": {"epss_score": 0.00778, "epss_percentile": 0.7313}, "CVE-2016-5477": {"epss_score": 0.00348, "epss_percentile": 0.56816}, "CVE-2016-5479": {"epss_score": 0.0018, "epss_percentile": 0.39913}, "CVE-2016-5480": {"epss_score": 0.00143, "epss_percentile": 0.35219}, "CVE-2016-5481": {"epss_score": 0.00186, "epss_percentile": 0.40663}, "CVE-2016-5482": {"epss_score": 0.0023, "epss_percentile": 0.45725}, "CVE-2016-5486": {"epss_score": 0.00066, "epss_percentile": 0.20824}, "CVE-2016-5487": {"epss_score": 0.00048, "epss_percentile": 0.15185}, "CVE-2016-5488": {"epss_score": 0.01197, "epss_percentile": 0.78444}, "CVE-2016-5489": {"epss_score": 0.00274, "epss_percentile": 0.50579}, "CVE-2016-5490": {"epss_score": 0.00051, "epss_percentile": 0.16105}, "CVE-2016-5491": {"epss_score": 0.0023, "epss_percentile": 0.45725}, "CVE-2016-5492": {"epss_score": 0.00043, "epss_percentile": 0.13029}, "CVE-2016-5493": {"epss_score": 0.00126, "epss_percentile": 0.32735}, "CVE-2016-5495": {"epss_score": 0.00274, "epss_percentile": 0.50485}, "CVE-2016-5497": {"epss_score": 0.0005, "epss_percentile": 0.15864}, "CVE-2016-5498": {"epss_score": 0.00046, "epss_percentile": 0.14075}, "CVE-2016-5499": {"epss_score": 0.00051, "epss_percentile": 0.16105}, "CVE-2016-5500": {"epss_score": 0.00267, "epss_percentile": 0.49969}, "CVE-2016-5501": {"epss_score": 0.00047, "epss_percentile": 0.14578}, "CVE-2016-5502": {"epss_score": 0.00126, "epss_percentile": 0.32735}, "CVE-2016-5503": {"epss_score": 0.00055, "epss_percentile": 0.17469}, "CVE-2016-5504": {"epss_score": 0.00118, "epss_percentile": 0.31387}, "CVE-2016-5505": {"epss_score": 0.00064, "epss_percentile": 0.2019}, "CVE-2016-5506": {"epss_score": 0.00114, "epss_percentile": 0.30783}, "CVE-2016-5507": {"epss_score": 0.00674, "epss_percentile": 0.70883}, "CVE-2016-5508": {"epss_score": 0.00046, "epss_percentile": 0.14075}, "CVE-2016-5509": {"epss_score": 0.00358, "epss_percentile": 0.57489}, "CVE-2016-5510": {"epss_score": 0.00186, "epss_percentile": 0.40663}, "CVE-2016-5511": {"epss_score": 0.00238, "epss_percentile": 0.46805}, "CVE-2016-5512": {"epss_score": 0.0022, "epss_percentile": 0.44552}, "CVE-2016-5513": {"epss_score": 0.00152, "epss_percentile": 0.36436}, "CVE-2016-5514": {"epss_score": 0.00882, "epss_percentile": 0.74889}, "CVE-2016-5515": {"epss_score": 0.00882, "epss_percentile": 0.74889}, "CVE-2016-5516": {"epss_score": 0.00072, "epss_percentile": 0.22249}, "CVE-2016-5517": {"epss_score": 0.00061, "epss_percentile": 0.19428}, "CVE-2016-5518": {"epss_score": 0.00658, "epss_percentile": 0.70482}, "CVE-2016-5519": {"epss_score": 0.01101, "epss_percentile": 0.77575}, "CVE-2016-5521": {"epss_score": 0.0033, "epss_percentile": 0.55454}, "CVE-2016-5522": {"epss_score": 0.00152, "epss_percentile": 0.36436}, "CVE-2016-5523": {"epss_score": 0.00882, "epss_percentile": 0.74889}, "CVE-2016-5524": {"epss_score": 0.00186, "epss_percentile": 0.40663}, "CVE-2016-5525": {"epss_score": 0.00046, "epss_percentile": 0.14459}, "CVE-2016-5526": {"epss_score": 0.00329, "epss_percentile": 0.55309}, "CVE-2016-5527": {"epss_score": 0.00329, "epss_percentile": 0.55397}, "CVE-2016-5528": {"epss_score": 0.00913, "epss_percentile": 0.7537}, "CVE-2016-5529": {"epss_score": 0.00222, "epss_percentile": 0.44719}, "CVE-2016-5530": {"epss_score": 0.00222, "epss_percentile": 0.44719}, "CVE-2016-5531": {"epss_score": 0.02399, "epss_percentile": 0.84636}, "CVE-2016-5532": {"epss_score": 0.00896, "epss_percentile": 0.75112}, "CVE-2016-5533": {"epss_score": 0.00106, "epss_percentile": 0.29576}, "CVE-2016-5534": {"epss_score": 0.00143, "epss_percentile": 0.35114}, "CVE-2016-5535": {"epss_score": 0.03552, "epss_percentile": 0.87343}, "CVE-2016-5536": {"epss_score": 0.00411, "epss_percentile": 0.60852}, "CVE-2016-5537": {"epss_score": 0.00123, "epss_percentile": 0.32251}, "CVE-2016-5538": {"epss_score": 0.00138, "epss_percentile": 0.34373}, "CVE-2016-5539": {"epss_score": 0.00052, "epss_percentile": 0.16449}, "CVE-2016-5540": {"epss_score": 0.0005, "epss_percentile": 0.15756}, "CVE-2016-5541": {"epss_score": 0.00851, "epss_percentile": 0.7441}, "CVE-2016-5542": {"epss_score": 0.02877, "epss_percentile": 0.85885}, "CVE-2016-5543": {"epss_score": 0.00222, "epss_percentile": 0.44719}, "CVE-2016-5544": {"epss_score": 0.00042, "epss_percentile": 0.12599}, "CVE-2016-5545": {"epss_score": 0.00571, "epss_percentile": 0.67993}, "CVE-2016-5546": {"epss_score": 0.0162, "epss_percentile": 0.81384}, "CVE-2016-5547": {"epss_score": 0.01187, "epss_percentile": 0.78357}, "CVE-2016-5548": {"epss_score": 0.00779, "epss_percentile": 0.73152}, "CVE-2016-5549": {"epss_score": 0.00779, "epss_percentile": 0.73152}, "CVE-2016-5551": {"epss_score": 0.00148, "epss_percentile": 0.35885}, "CVE-2016-5552": {"epss_score": 0.00702, "epss_percentile": 0.71514}, "CVE-2016-5553": {"epss_score": 0.00141, "epss_percentile": 0.3481}, "CVE-2016-5554": {"epss_score": 0.02877, "epss_percentile": 0.85885}, "CVE-2016-5555": {"epss_score": 0.00948, "epss_percentile": 0.75828}, "CVE-2016-5556": {"epss_score": 0.03944, "epss_percentile": 0.87992}, "CVE-2016-5557": {"epss_score": 0.0026, "epss_percentile": 0.49174}, "CVE-2016-5558": {"epss_score": 0.03411, "epss_percentile": 0.87083}, "CVE-2016-5559": {"epss_score": 0.0007, "epss_percentile": 0.2168}, "CVE-2016-5560": {"epss_score": 0.00106, "epss_percentile": 0.29576}, "CVE-2016-5561": {"epss_score": 0.00678, "epss_percentile": 0.70971}, "CVE-2016-5562": {"epss_score": 0.00148, "epss_percentile": 0.35916}, "CVE-2016-5563": {"epss_score": 0.00484, "epss_percentile": 0.64642}, "CVE-2016-5564": {"epss_score": 0.00327, "epss_percentile": 0.55138}, "CVE-2016-5565": {"epss_score": 0.00143, "epss_percentile": 0.35114}, "CVE-2016-5566": {"epss_score": 0.00307, "epss_percentile": 0.53563}, "CVE-2016-5567": {"epss_score": 0.00399, "epss_percentile": 0.60146}, "CVE-2016-5568": {"epss_score": 0.00917, "epss_percentile": 0.75432}, "CVE-2016-5569": {"epss_score": 0.00126, "epss_percentile": 0.32735}, "CVE-2016-5570": {"epss_score": 0.00407, "epss_percentile": 0.60616}, "CVE-2016-5571": {"epss_score": 0.00407, "epss_percentile": 0.60616}, "CVE-2016-5572": {"epss_score": 0.00059, "epss_percentile": 0.18835}, "CVE-2016-5573": {"epss_score": 0.06508, "epss_percentile": 0.90808}, "CVE-2016-5574": {"epss_score": 0.00922, "epss_percentile": 0.7549}, "CVE-2016-5575": {"epss_score": 0.00226, "epss_percentile": 0.45331}, "CVE-2016-5576": {"epss_score": 0.00048, "epss_percentile": 0.1512}, "CVE-2016-5577": {"epss_score": 0.00691, "epss_percentile": 0.71277}, "CVE-2016-5578": {"epss_score": 0.00691, "epss_percentile": 0.71277}, "CVE-2016-5579": {"epss_score": 0.00691, "epss_percentile": 0.71277}, "CVE-2016-5580": {"epss_score": 0.00502, "epss_percentile": 0.65369}, "CVE-2016-5581": {"epss_score": 0.00046, "epss_percentile": 0.14456}, "CVE-2016-5582": {"epss_score": 0.06252, "epss_percentile": 0.90616}, "CVE-2016-5583": {"epss_score": 0.0025, "epss_percentile": 0.48125}, "CVE-2016-5584": {"epss_score": 0.00442, "epss_percentile": 0.62755}, "CVE-2016-5585": {"epss_score": 0.00208, "epss_percentile": 0.43226}, "CVE-2016-5586": {"epss_score": 0.00313, "epss_percentile": 0.54065}, "CVE-2016-5587": {"epss_score": 0.00313, "epss_percentile": 0.54065}, "CVE-2016-5588": {"epss_score": 0.00691, "epss_percentile": 0.71277}, "CVE-2016-5589": {"epss_score": 0.00313, "epss_percentile": 0.54065}, "CVE-2016-5590": {"epss_score": 0.00795, "epss_percentile": 0.73472}, "CVE-2016-5591": {"epss_score": 0.00313, "epss_percentile": 0.54065}, "CVE-2016-5592": {"epss_score": 0.00313, "epss_percentile": 0.54065}, "CVE-2016-5593": {"epss_score": 0.00313, "epss_percentile": 0.54065}, "CVE-2016-5594": {"epss_score": 0.00142, "epss_percentile": 0.34991}, "CVE-2016-5595": {"epss_score": 0.00313, "epss_percentile": 0.54065}, "CVE-2016-5596": {"epss_score": 0.0018, "epss_percentile": 0.39913}, "CVE-2016-5597": {"epss_score": 0.0214, "epss_percentile": 0.83748}, "CVE-2016-5598": {"epss_score": 0.00304, "epss_percentile": 0.53276}, "CVE-2016-5599": {"epss_score": 0.00232, "epss_percentile": 0.45926}, "CVE-2016-5600": {"epss_score": 0.00126, "epss_percentile": 0.32735}, "CVE-2016-5601": {"epss_score": 0.00155, "epss_percentile": 0.36827}, "CVE-2016-5602": {"epss_score": 0.00212, "epss_percentile": 0.43749}, "CVE-2016-5603": {"epss_score": 0.0018, "epss_percentile": 0.39913}, "CVE-2016-5604": {"epss_score": 0.00155, "epss_percentile": 0.36827}, "CVE-2016-5605": {"epss_score": 0.00217, "epss_percentile": 0.4426}, "CVE-2016-5606": {"epss_score": 0.00045, "epss_percentile": 0.13978}, "CVE-2016-5607": {"epss_score": 0.00785, "epss_percentile": 0.73252}, "CVE-2016-5608": {"epss_score": 0.00056, "epss_percentile": 0.17796}, "CVE-2016-5609": {"epss_score": 0.01357, "epss_percentile": 0.79722}, "CVE-2016-5610": {"epss_score": 0.00062, "epss_percentile": 0.19647}, "CVE-2016-5611": {"epss_score": 0.00046, "epss_percentile": 0.14344}, "CVE-2016-5612": {"epss_score": 0.00712, "epss_percentile": 0.71748}, "CVE-2016-5613": {"epss_score": 0.00077, "epss_percentile": 0.23461}, "CVE-2016-5614": {"epss_score": 0.00249, "epss_percentile": 0.48036}, "CVE-2016-5615": {"epss_score": 0.00057, "epss_percentile": 0.18035}, "CVE-2016-5618": {"epss_score": 0.0018, "epss_percentile": 0.39913}, "CVE-2016-5619": {"epss_score": 0.00183, "epss_percentile": 0.40366}, "CVE-2016-5620": {"epss_score": 0.00126, "epss_percentile": 0.32735}, "CVE-2016-5621": {"epss_score": 0.00142, "epss_percentile": 0.34991}, "CVE-2016-5622": {"epss_score": 0.0022, "epss_percentile": 0.44606}, "CVE-2016-5623": {"epss_score": 0.00221, "epss_percentile": 0.44711}, "CVE-2016-5624": {"epss_score": 0.0069, "epss_percentile": 0.71246}, "CVE-2016-5625": {"epss_score": 0.00079, "epss_percentile": 0.23949}, "CVE-2016-5626": {"epss_score": 0.00515, "epss_percentile": 0.66001}, "CVE-2016-5627": {"epss_score": 0.01357, "epss_percentile": 0.79722}, "CVE-2016-5628": {"epss_score": 0.02921, "epss_percentile": 0.85992}, "CVE-2016-5629": {"epss_score": 0.00698, "epss_percentile": 0.71429}, "CVE-2016-5630": {"epss_score": 0.00755, "epss_percentile": 0.72715}, "CVE-2016-5631": {"epss_score": 0.01417, "epss_percentile": 0.80151}, "CVE-2016-5632": {"epss_score": 0.01417, "epss_percentile": 0.80151}, "CVE-2016-5633": {"epss_score": 0.01417, "epss_percentile": 0.80151}, "CVE-2016-5634": {"epss_score": 0.01417, "epss_percentile": 0.80151}, "CVE-2016-5635": {"epss_score": 0.01417, "epss_percentile": 0.80151}, "CVE-2016-5636": {"epss_score": 0.63691, "epss_percentile": 0.98344}, "CVE-2016-5637": {"epss_score": 0.00512, "epss_percentile": 0.65876}, "CVE-2016-5638": {"epss_score": 0.01269, "epss_percentile": 0.79041}, "CVE-2016-5639": {"epss_score": 0.47818, "epss_percentile": 0.97602}, "CVE-2016-5640": {"epss_score": 0.52332, "epss_percentile": 0.97819}, "CVE-2016-5642": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2016-5645": {"epss_score": 0.30312, "epss_percentile": 0.96527}, "CVE-2016-5646": {"epss_score": 0.0077, "epss_percentile": 0.72995}, "CVE-2016-5647": {"epss_score": 0.00077, "epss_percentile": 0.23306}, "CVE-2016-5648": {"epss_score": 0.01335, "epss_percentile": 0.79548}, "CVE-2016-5649": {"epss_score": 0.75112, "epss_percentile": 0.9883}, "CVE-2016-5650": {"epss_score": 0.00573, "epss_percentile": 0.68052}, "CVE-2016-5652": {"epss_score": 0.06098, "epss_percentile": 0.9048}, "CVE-2016-5653": {"epss_score": 0.00294, "epss_percentile": 0.5239}, "CVE-2016-5654": {"epss_score": 0.00797, "epss_percentile": 0.73494}, "CVE-2016-5655": {"epss_score": 0.00083, "epss_percentile": 0.24638}, "CVE-2016-5660": {"epss_score": 0.03479, "epss_percentile": 0.87216}, "CVE-2016-5661": {"epss_score": 0.05693, "epss_percentile": 0.90126}, "CVE-2016-5662": {"epss_score": 0.00072, "epss_percentile": 0.22325}, "CVE-2016-5663": {"epss_score": 0.00492, "epss_percentile": 0.64982}, "CVE-2016-5664": {"epss_score": 0.0049, "epss_percentile": 0.64918}, "CVE-2016-5666": {"epss_score": 0.02016, "epss_percentile": 0.83276}, "CVE-2016-5667": {"epss_score": 0.00385, "epss_percentile": 0.59205}, "CVE-2016-5668": {"epss_score": 0.03438, "epss_percentile": 0.87136}, "CVE-2016-5669": {"epss_score": 0.00135, "epss_percentile": 0.34008}, "CVE-2016-5670": {"epss_score": 0.02354, "epss_percentile": 0.84477}, "CVE-2016-5671": {"epss_score": 0.00141, "epss_percentile": 0.34823}, "CVE-2016-5672": {"epss_score": 0.00389, "epss_percentile": 0.59493}, "CVE-2016-5673": {"epss_score": 0.01374, "epss_percentile": 0.79824}, "CVE-2016-5674": {"epss_score": 0.89376, "epss_percentile": 0.99523}, "CVE-2016-5675": {"epss_score": 0.73057, "epss_percentile": 0.98734}, "CVE-2016-5676": {"epss_score": 0.76234, "epss_percentile": 0.98883}, "CVE-2016-5677": {"epss_score": 0.19234, "epss_percentile": 0.95153}, "CVE-2016-5678": {"epss_score": 0.38155, "epss_percentile": 0.97088}, "CVE-2016-5679": {"epss_score": 0.15463, "epss_percentile": 0.94433}, "CVE-2016-5680": {"epss_score": 0.33302, "epss_percentile": 0.96761}, "CVE-2016-5681": {"epss_score": 0.29261, "epss_percentile": 0.96428}, "CVE-2016-5682": {"epss_score": 0.0047, "epss_percentile": 0.6396}, "CVE-2016-5683": {"epss_score": 0.00346, "epss_percentile": 0.56708}, "CVE-2016-5684": {"epss_score": 0.00496, "epss_percentile": 0.65169}, "CVE-2016-5685": {"epss_score": 0.00612, "epss_percentile": 0.69213}, "CVE-2016-5686": {"epss_score": 0.03006, "epss_percentile": 0.86185}, "CVE-2016-5687": {"epss_score": 0.00798, "epss_percentile": 0.73513}, "CVE-2016-5688": {"epss_score": 0.02389, "epss_percentile": 0.84594}, "CVE-2016-5689": {"epss_score": 0.01069, "epss_percentile": 0.77249}, "CVE-2016-5690": {"epss_score": 0.01541, "epss_percentile": 0.80946}, "CVE-2016-5691": {"epss_score": 0.01326, "epss_percentile": 0.79478}, "CVE-2016-5696": {"epss_score": 0.34409, "epss_percentile": 0.96846}, "CVE-2016-5697": {"epss_score": 0.00131, "epss_percentile": 0.33465}, "CVE-2016-5699": {"epss_score": 0.41714, "epss_percentile": 0.9729}, "CVE-2016-5700": {"epss_score": 0.05614, "epss_percentile": 0.90053}, "CVE-2016-5701": {"epss_score": 0.00459, "epss_percentile": 0.63457}, "CVE-2016-5702": {"epss_score": 0.00248, "epss_percentile": 0.47927}, "CVE-2016-5703": {"epss_score": 0.01576, "epss_percentile": 0.81111}, "CVE-2016-5704": {"epss_score": 0.00277, "epss_percentile": 0.50812}, "CVE-2016-5705": {"epss_score": 0.00605, "epss_percentile": 0.68977}, "CVE-2016-5706": {"epss_score": 0.02778, "epss_percentile": 0.85644}, "CVE-2016-5709": {"epss_score": 0.00104, "epss_percentile": 0.29218}, "CVE-2016-5710": {"epss_score": 0.00136, "epss_percentile": 0.34175}, "CVE-2016-5711": {"epss_score": 0.00335, "epss_percentile": 0.55801}, "CVE-2016-5713": {"epss_score": 0.0112, "epss_percentile": 0.77766}, "CVE-2016-5714": {"epss_score": 0.0101, "epss_percentile": 0.76604}, "CVE-2016-5715": {"epss_score": 0.00839, "epss_percentile": 0.74197}, "CVE-2016-5716": {"epss_score": 0.0185, "epss_percentile": 0.82533}, "CVE-2016-5720": {"epss_score": 0.01063, "epss_percentile": 0.77192}, "CVE-2016-5721": {"epss_score": 0.00303, "epss_percentile": 0.53197}, "CVE-2016-5722": {"epss_score": 0.00207, "epss_percentile": 0.43123}, "CVE-2016-5723": {"epss_score": 0.00059, "epss_percentile": 0.1886}, "CVE-2016-5724": {"epss_score": 0.00402, "epss_percentile": 0.60289}, "CVE-2016-5725": {"epss_score": 0.35722, "epss_percentile": 0.96927}, "CVE-2016-5726": {"epss_score": 0.00839, "epss_percentile": 0.74185}, "CVE-2016-5727": {"epss_score": 0.00595, "epss_percentile": 0.68694}, "CVE-2016-5728": {"epss_score": 0.00012, "epss_percentile": 0.01246}, "CVE-2016-5729": {"epss_score": 0.00204, "epss_percentile": 0.42617}, "CVE-2016-5730": {"epss_score": 0.01317, "epss_percentile": 0.79413}, "CVE-2016-5731": {"epss_score": 0.00424, "epss_percentile": 0.61656}, "CVE-2016-5732": {"epss_score": 0.00224, "epss_percentile": 0.44984}, "CVE-2016-5733": {"epss_score": 0.01243, "epss_percentile": 0.78828}, "CVE-2016-5734": {"epss_score": 0.74964, "epss_percentile": 0.98826}, "CVE-2016-5735": {"epss_score": 0.00406, "epss_percentile": 0.60558}, "CVE-2016-5736": {"epss_score": 0.0113, "epss_percentile": 0.7785}, "CVE-2016-5737": {"epss_score": 0.00069, "epss_percentile": 0.21544}, "CVE-2016-5739": {"epss_score": 0.00919, "epss_percentile": 0.75461}, "CVE-2016-5740": {"epss_score": 0.00144, "epss_percentile": 0.35256}, "CVE-2016-5742": {"epss_score": 0.01022, "epss_percentile": 0.76762}, "CVE-2016-5743": {"epss_score": 0.17777, "epss_percentile": 0.94904}, "CVE-2016-5744": {"epss_score": 0.0079, "epss_percentile": 0.73379}, "CVE-2016-5745": {"epss_score": 0.03888, "epss_percentile": 0.87908}, "CVE-2016-5746": {"epss_score": 0.00058, "epss_percentile": 0.18562}, "CVE-2016-5747": {"epss_score": 0.00327, "epss_percentile": 0.55101}, "CVE-2016-5748": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2016-5749": {"epss_score": 0.00073, "epss_percentile": 0.22567}, "CVE-2016-5750": {"epss_score": 0.00634, "epss_percentile": 0.69807}, "CVE-2016-5751": {"epss_score": 0.00233, "epss_percentile": 0.45977}, "CVE-2016-5752": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2016-5754": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2016-5755": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2016-5756": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2016-5757": {"epss_score": 0.01068, "epss_percentile": 0.77239}, "CVE-2016-5758": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2016-5759": {"epss_score": 0.00029, "epss_percentile": 0.07947}, "CVE-2016-5760": {"epss_score": 0.00397, "epss_percentile": 0.59982}, "CVE-2016-5761": {"epss_score": 0.00397, "epss_percentile": 0.59982}, "CVE-2016-5762": {"epss_score": 0.08401, "epss_percentile": 0.92032}, "CVE-2016-5763": {"epss_score": 0.01034, "epss_percentile": 0.76882}, "CVE-2016-5764": {"epss_score": 0.09232, "epss_percentile": 0.92458}, "CVE-2016-5765": {"epss_score": 0.00851, "epss_percentile": 0.74399}, "CVE-2016-5766": {"epss_score": 0.15273, "epss_percentile": 0.94397}, "CVE-2016-5767": {"epss_score": 0.03587, "epss_percentile": 0.87395}, "CVE-2016-5768": {"epss_score": 0.20814, "epss_percentile": 0.95417}, "CVE-2016-5769": {"epss_score": 0.05188, "epss_percentile": 0.89592}, "CVE-2016-5770": {"epss_score": 0.10051, "epss_percentile": 0.92828}, "CVE-2016-5771": {"epss_score": 0.13654, "epss_percentile": 0.94023}, "CVE-2016-5772": {"epss_score": 0.1531, "epss_percentile": 0.94407}, "CVE-2016-5773": {"epss_score": 0.2113, "epss_percentile": 0.95466}, "CVE-2016-5774": {"epss_score": 0.00397, "epss_percentile": 0.60047}, "CVE-2016-5781": {"epss_score": 0.0149, "epss_percentile": 0.8063}, "CVE-2016-5782": {"epss_score": 0.00875, "epss_percentile": 0.74778}, "CVE-2016-5786": {"epss_score": 0.00457, "epss_percentile": 0.63379}, "CVE-2016-5787": {"epss_score": 0.00093, "epss_percentile": 0.26679}, "CVE-2016-5788": {"epss_score": 0.00303, "epss_percentile": 0.53194}, "CVE-2016-5789": {"epss_score": 0.00072, "epss_percentile": 0.22401}, "CVE-2016-5790": {"epss_score": 0.0173, "epss_percentile": 0.81988}, "CVE-2016-5791": {"epss_score": 0.00325, "epss_percentile": 0.54995}, "CVE-2016-5792": {"epss_score": 0.01703, "epss_percentile": 0.81842}, "CVE-2016-5793": {"epss_score": 0.0005, "epss_percentile": 0.15941}, "CVE-2016-5795": {"epss_score": 0.00731, "epss_percentile": 0.72162}, "CVE-2016-5796": {"epss_score": 0.004, "epss_percentile": 0.60161}, "CVE-2016-5797": {"epss_score": 0.00432, "epss_percentile": 0.62121}, "CVE-2016-5798": {"epss_score": 0.01685, "epss_percentile": 0.8175}, "CVE-2016-5799": {"epss_score": 0.00896, "epss_percentile": 0.7511}, "CVE-2016-5800": {"epss_score": 0.00364, "epss_percentile": 0.5792}, "CVE-2016-5801": {"epss_score": 0.00405, "epss_percentile": 0.60479}, "CVE-2016-5802": {"epss_score": 0.00151, "epss_percentile": 0.36256}, "CVE-2016-5803": {"epss_score": 0.05421, "epss_percentile": 0.89857}, "CVE-2016-5804": {"epss_score": 0.00179, "epss_percentile": 0.39774}, "CVE-2016-5805": {"epss_score": 0.00209, "epss_percentile": 0.43416}, "CVE-2016-5807": {"epss_score": 0.00262, "epss_percentile": 0.49405}, "CVE-2016-5809": {"epss_score": 0.00321, "epss_percentile": 0.54645}, "CVE-2016-5810": {"epss_score": 0.25401, "epss_percentile": 0.96024}, "CVE-2016-5811": {"epss_score": 0.0018, "epss_percentile": 0.39982}, "CVE-2016-5812": {"epss_score": 0.00047, "epss_percentile": 0.14899}, "CVE-2016-5813": {"epss_score": 0.00219, "epss_percentile": 0.44446}, "CVE-2016-5814": {"epss_score": 0.00618, "epss_percentile": 0.69383}, "CVE-2016-5815": {"epss_score": 0.01186, "epss_percentile": 0.78344}, "CVE-2016-5816": {"epss_score": 0.00171, "epss_percentile": 0.38859}, "CVE-2016-5817": {"epss_score": 0.00325, "epss_percentile": 0.54979}, "CVE-2016-5818": {"epss_score": 0.00378, "epss_percentile": 0.5881}, "CVE-2016-5819": {"epss_score": 0.00185, "epss_percentile": 0.4051}, "CVE-2016-5821": {"epss_score": 0.00021, "epss_percentile": 0.04845}, "CVE-2016-5822": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2016-5823": {"epss_score": 0.00402, "epss_percentile": 0.60314}, "CVE-2016-5824": {"epss_score": 0.00444, "epss_percentile": 0.62839}, "CVE-2016-5825": {"epss_score": 0.00453, "epss_percentile": 0.63236}, "CVE-2016-5826": {"epss_score": 0.00759, "epss_percentile": 0.72797}, "CVE-2016-5827": {"epss_score": 0.00759, "epss_percentile": 0.72797}, "CVE-2016-5828": {"epss_score": 0.00108, "epss_percentile": 0.2985}, "CVE-2016-5829": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2016-5832": {"epss_score": 0.01728, "epss_percentile": 0.81971}, "CVE-2016-5833": {"epss_score": 0.00912, "epss_percentile": 0.75356}, "CVE-2016-5834": {"epss_score": 0.00912, "epss_percentile": 0.75356}, "CVE-2016-5835": {"epss_score": 0.01938, "epss_percentile": 0.82966}, "CVE-2016-5836": {"epss_score": 0.07246, "epss_percentile": 0.91348}, "CVE-2016-5837": {"epss_score": 0.00827, "epss_percentile": 0.73976}, "CVE-2016-5838": {"epss_score": 0.01728, "epss_percentile": 0.81971}, "CVE-2016-5839": {"epss_score": 0.01122, "epss_percentile": 0.7778}, "CVE-2016-5840": {"epss_score": 0.14105, "epss_percentile": 0.94133}, "CVE-2016-5841": {"epss_score": 0.2299, "epss_percentile": 0.95714}, "CVE-2016-5842": {"epss_score": 0.01127, "epss_percentile": 0.77821}, "CVE-2016-5843": {"epss_score": 0.0103, "epss_percentile": 0.76843}, "CVE-2016-5844": {"epss_score": 0.02481, "epss_percentile": 0.84875}, "CVE-2016-5845": {"epss_score": 0.01959, "epss_percentile": 0.83055}, "CVE-2016-5847": {"epss_score": 0.0022, "epss_percentile": 0.44624}, "CVE-2016-5848": {"epss_score": 0.00137, "epss_percentile": 0.34321}, "CVE-2016-5849": {"epss_score": 0.00088, "epss_percentile": 0.2567}, "CVE-2016-5850": {"epss_score": 0.00087, "epss_percentile": 0.25444}, "CVE-2016-5851": {"epss_score": 0.00899, "epss_percentile": 0.75157}, "CVE-2016-5852": {"epss_score": 0.00048, "epss_percentile": 0.15025}, "CVE-2016-5853": {"epss_score": 0.00077, "epss_percentile": 0.23524}, "CVE-2016-5854": {"epss_score": 0.00111, "epss_percentile": 0.30242}, "CVE-2016-5855": {"epss_score": 0.00111, "epss_percentile": 0.30242}, "CVE-2016-5856": {"epss_score": 0.0005, "epss_percentile": 0.15833}, "CVE-2016-5857": {"epss_score": 0.00027, "epss_percentile": 0.06943}, "CVE-2016-5858": {"epss_score": 0.00142, "epss_percentile": 0.35044}, "CVE-2016-5859": {"epss_score": 0.00064, "epss_percentile": 0.2014}, "CVE-2016-5860": {"epss_score": 0.00064, "epss_percentile": 0.2014}, "CVE-2016-5861": {"epss_score": 0.00242, "epss_percentile": 0.47335}, "CVE-2016-5862": {"epss_score": 0.00059, "epss_percentile": 0.18741}, "CVE-2016-5863": {"epss_score": 0.00054, "epss_percentile": 0.17202}, "CVE-2016-5864": {"epss_score": 0.00059, "epss_percentile": 0.18661}, "CVE-2016-5867": {"epss_score": 0.00064, "epss_percentile": 0.2014}, "CVE-2016-5868": {"epss_score": 0.00945, "epss_percentile": 0.75795}, "CVE-2016-5870": {"epss_score": 0.00071, "epss_percentile": 0.22168}, "CVE-2016-5871": {"epss_score": 0.00189, "epss_percentile": 0.40939}, "CVE-2016-5872": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2016-5873": {"epss_score": 0.04743, "epss_percentile": 0.89082}, "CVE-2016-5874": {"epss_score": 0.0087, "epss_percentile": 0.74704}, "CVE-2016-5876": {"epss_score": 0.00297, "epss_percentile": 0.5277}, "CVE-2016-5878": {"epss_score": 0.00113, "epss_percentile": 0.30605}, "CVE-2016-5879": {"epss_score": 0.00038, "epss_percentile": 0.11327}, "CVE-2016-5880": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-5881": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2016-5882": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2016-5883": {"epss_score": 0.00283, "epss_percentile": 0.5135}, "CVE-2016-5884": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2016-5888": {"epss_score": 0.00258, "epss_percentile": 0.49}, "CVE-2016-5889": {"epss_score": 0.00159, "epss_percentile": 0.37328}, "CVE-2016-5890": {"epss_score": 0.00164, "epss_percentile": 0.37887}, "CVE-2016-5892": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-5893": {"epss_score": 0.00067, "epss_percentile": 0.20999}, "CVE-2016-5894": {"epss_score": 0.00054, "epss_percentile": 0.17338}, "CVE-2016-5896": {"epss_score": 0.00187, "epss_percentile": 0.40773}, "CVE-2016-5897": {"epss_score": 0.00154, "epss_percentile": 0.36683}, "CVE-2016-5898": {"epss_score": 0.00136, "epss_percentile": 0.34157}, "CVE-2016-5899": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-5900": {"epss_score": 0.00123, "epss_percentile": 0.32182}, "CVE-2016-5901": {"epss_score": 0.0017, "epss_percentile": 0.38686}, "CVE-2016-5902": {"epss_score": 0.00317, "epss_percentile": 0.54359}, "CVE-2016-5905": {"epss_score": 0.00154, "epss_percentile": 0.36683}, "CVE-2016-5918": {"epss_score": 0.00116, "epss_percentile": 0.31089}, "CVE-2016-5919": {"epss_score": 0.00128, "epss_percentile": 0.33061}, "CVE-2016-5920": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2016-5927": {"epss_score": 0.00052, "epss_percentile": 0.16367}, "CVE-2016-5932": {"epss_score": 0.00258, "epss_percentile": 0.49}, "CVE-2016-5933": {"epss_score": 0.00208, "epss_percentile": 0.43307}, "CVE-2016-5934": {"epss_score": 0.02897, "epss_percentile": 0.85928}, "CVE-2016-5935": {"epss_score": 0.00116, "epss_percentile": 0.31127}, "CVE-2016-5937": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2016-5938": {"epss_score": 0.00056, "epss_percentile": 0.17658}, "CVE-2016-5939": {"epss_score": 0.00252, "epss_percentile": 0.48337}, "CVE-2016-5940": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-5941": {"epss_score": 0.00474, "epss_percentile": 0.6417}, "CVE-2016-5942": {"epss_score": 0.00215, "epss_percentile": 0.44056}, "CVE-2016-5943": {"epss_score": 0.00109, "epss_percentile": 0.3004}, "CVE-2016-5944": {"epss_score": 0.00197, "epss_percentile": 0.41903}, "CVE-2016-5945": {"epss_score": 0.00077, "epss_percentile": 0.23413}, "CVE-2016-5946": {"epss_score": 0.00281, "epss_percentile": 0.51186}, "CVE-2016-5947": {"epss_score": 0.00157, "epss_percentile": 0.37063}, "CVE-2016-5948": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-5949": {"epss_score": 0.00527, "epss_percentile": 0.66453}, "CVE-2016-5950": {"epss_score": 0.00252, "epss_percentile": 0.48362}, "CVE-2016-5951": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-5952": {"epss_score": 0.00543, "epss_percentile": 0.67111}, "CVE-2016-5953": {"epss_score": 0.00141, "epss_percentile": 0.34947}, "CVE-2016-5954": {"epss_score": 0.00624, "epss_percentile": 0.69561}, "CVE-2016-5955": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-5957": {"epss_score": 0.00267, "epss_percentile": 0.5}, "CVE-2016-5958": {"epss_score": 0.00254, "epss_percentile": 0.48528}, "CVE-2016-5959": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2016-5960": {"epss_score": 0.00057, "epss_percentile": 0.18093}, "CVE-2016-5963": {"epss_score": 0.01767, "epss_percentile": 0.82176}, "CVE-2016-5964": {"epss_score": 0.00386, "epss_percentile": 0.5927}, "CVE-2016-5966": {"epss_score": 0.00216, "epss_percentile": 0.44163}, "CVE-2016-5967": {"epss_score": 0.00052, "epss_percentile": 0.16367}, "CVE-2016-5968": {"epss_score": 0.00205, "epss_percentile": 0.42673}, "CVE-2016-5970": {"epss_score": 0.00394, "epss_percentile": 0.59787}, "CVE-2016-5971": {"epss_score": 0.00407, "epss_percentile": 0.60586}, "CVE-2016-5972": {"epss_score": 0.00117, "epss_percentile": 0.31217}, "CVE-2016-5974": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-5975": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-5976": {"epss_score": 0.00255, "epss_percentile": 0.48627}, "CVE-2016-5977": {"epss_score": 0.00113, "epss_percentile": 0.30605}, "CVE-2016-5978": {"epss_score": 0.00168, "epss_percentile": 0.38492}, "CVE-2016-5979": {"epss_score": 0.0024, "epss_percentile": 0.47198}, "CVE-2016-5980": {"epss_score": 0.00303, "epss_percentile": 0.53194}, "CVE-2016-5981": {"epss_score": 0.00143, "epss_percentile": 0.3521}, "CVE-2016-5983": {"epss_score": 0.13762, "epss_percentile": 0.94053}, "CVE-2016-5984": {"epss_score": 0.00206, "epss_percentile": 0.42775}, "CVE-2016-5985": {"epss_score": 0.00068, "epss_percentile": 0.21367}, "CVE-2016-5986": {"epss_score": 0.00332, "epss_percentile": 0.55565}, "CVE-2016-5987": {"epss_score": 0.00316, "epss_percentile": 0.54216}, "CVE-2016-5988": {"epss_score": 0.00252, "epss_percentile": 0.48362}, "CVE-2016-5990": {"epss_score": 0.00193, "epss_percentile": 0.41431}, "CVE-2016-5991": {"epss_score": 0.00058, "epss_percentile": 0.18354}, "CVE-2016-5992": {"epss_score": 0.00052, "epss_percentile": 0.16588}, "CVE-2016-5994": {"epss_score": 0.00285, "epss_percentile": 0.51673}, "CVE-2016-5995": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2016-5996": {"epss_score": 0.00252, "epss_percentile": 0.48407}, "CVE-2016-5997": {"epss_score": 0.00109, "epss_percentile": 0.29957}, "CVE-2016-6000": {"epss_score": 0.00238, "epss_percentile": 0.46758}, "CVE-2016-6001": {"epss_score": 0.00138, "epss_percentile": 0.34523}, "CVE-2016-6018": {"epss_score": 0.00212, "epss_percentile": 0.43747}, "CVE-2016-6019": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-6020": {"epss_score": 0.00267, "epss_percentile": 0.49952}, "CVE-2016-6021": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2016-6022": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6023": {"epss_score": 0.00221, "epss_percentile": 0.44702}, "CVE-2016-6024": {"epss_score": 0.0013, "epss_percentile": 0.33297}, "CVE-2016-6025": {"epss_score": 0.00204, "epss_percentile": 0.42665}, "CVE-2016-6026": {"epss_score": 0.00069, "epss_percentile": 0.21497}, "CVE-2016-6027": {"epss_score": 0.00244, "epss_percentile": 0.47582}, "CVE-2016-6028": {"epss_score": 0.00179, "epss_percentile": 0.39783}, "CVE-2016-6029": {"epss_score": 0.00204, "epss_percentile": 0.42616}, "CVE-2016-6030": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6031": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6032": {"epss_score": 0.00303, "epss_percentile": 0.53194}, "CVE-2016-6033": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2016-6034": {"epss_score": 0.00305, "epss_percentile": 0.53374}, "CVE-2016-6035": {"epss_score": 0.00258, "epss_percentile": 0.49}, "CVE-2016-6036": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6037": {"epss_score": 0.00152, "epss_percentile": 0.36491}, "CVE-2016-6038": {"epss_score": 0.00224, "epss_percentile": 0.45068}, "CVE-2016-6039": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6040": {"epss_score": 0.00193, "epss_percentile": 0.41431}, "CVE-2016-6042": {"epss_score": 0.0077, "epss_percentile": 0.73004}, "CVE-2016-6043": {"epss_score": 0.00048, "epss_percentile": 0.15239}, "CVE-2016-6044": {"epss_score": 0.00125, "epss_percentile": 0.32508}, "CVE-2016-6045": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2016-6046": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6047": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6054": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6055": {"epss_score": 0.00258, "epss_percentile": 0.49}, "CVE-2016-6056": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6059": {"epss_score": 0.00359, "epss_percentile": 0.57568}, "CVE-2016-6060": {"epss_score": 0.00203, "epss_percentile": 0.42565}, "CVE-2016-6061": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6062": {"epss_score": 0.00238, "epss_percentile": 0.46758}, "CVE-2016-6065": {"epss_score": 0.00076, "epss_percentile": 0.23282}, "CVE-2016-6068": {"epss_score": 0.00262, "epss_percentile": 0.49338}, "CVE-2016-6072": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6077": {"epss_score": 0.00081, "epss_percentile": 0.24329}, "CVE-2016-6079": {"epss_score": 0.02047, "epss_percentile": 0.8339}, "CVE-2016-6080": {"epss_score": 0.00187, "epss_percentile": 0.40773}, "CVE-2016-6082": {"epss_score": 0.07425, "epss_percentile": 0.91468}, "CVE-2016-6083": {"epss_score": 0.00203, "epss_percentile": 0.42566}, "CVE-2016-6084": {"epss_score": 0.00186, "epss_percentile": 0.40591}, "CVE-2016-6085": {"epss_score": 0.00175, "epss_percentile": 0.39347}, "CVE-2016-6087": {"epss_score": 0.01433, "epss_percentile": 0.80261}, "CVE-2016-6089": {"epss_score": 0.00035, "epss_percentile": 0.10131}, "CVE-2016-6090": {"epss_score": 0.01007, "epss_percentile": 0.76561}, "CVE-2016-6092": {"epss_score": 0.0005, "epss_percentile": 0.15955}, "CVE-2016-6093": {"epss_score": 0.00365, "epss_percentile": 0.57978}, "CVE-2016-6094": {"epss_score": 0.00312, "epss_percentile": 0.53943}, "CVE-2016-6095": {"epss_score": 0.00386, "epss_percentile": 0.5927}, "CVE-2016-6096": {"epss_score": 0.00317, "epss_percentile": 0.54359}, "CVE-2016-6097": {"epss_score": 0.00058, "epss_percentile": 0.18614}, "CVE-2016-6098": {"epss_score": 0.00137, "epss_percentile": 0.34289}, "CVE-2016-6099": {"epss_score": 0.00187, "epss_percentile": 0.40773}, "CVE-2016-6100": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2016-6102": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2016-6103": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2016-6104": {"epss_score": 0.03237, "epss_percentile": 0.86706}, "CVE-2016-6105": {"epss_score": 0.00255, "epss_percentile": 0.48654}, "CVE-2016-6110": {"epss_score": 0.00046, "epss_percentile": 0.14278}, "CVE-2016-6111": {"epss_score": 0.00407, "epss_percentile": 0.60577}, "CVE-2016-6112": {"epss_score": 0.00349, "epss_percentile": 0.56854}, "CVE-2016-6113": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2016-6114": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-6115": {"epss_score": 0.03934, "epss_percentile": 0.87979}, "CVE-2016-6116": {"epss_score": 0.00216, "epss_percentile": 0.44163}, "CVE-2016-6117": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2016-6118": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-6121": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-6122": {"epss_score": 0.00179, "epss_percentile": 0.39826}, "CVE-2016-6123": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6124": {"epss_score": 0.02673, "epss_percentile": 0.85396}, "CVE-2016-6125": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-6126": {"epss_score": 0.00638, "epss_percentile": 0.69907}, "CVE-2016-6127": {"epss_score": 0.00324, "epss_percentile": 0.54941}, "CVE-2016-6128": {"epss_score": 0.06819, "epss_percentile": 0.91046}, "CVE-2016-6129": {"epss_score": 0.00145, "epss_percentile": 0.35411}, "CVE-2016-6130": {"epss_score": 0.0006, "epss_percentile": 0.19134}, "CVE-2016-6131": {"epss_score": 0.0177, "epss_percentile": 0.82192}, "CVE-2016-6132": {"epss_score": 0.02138, "epss_percentile": 0.83735}, "CVE-2016-6133": {"epss_score": 0.00215, "epss_percentile": 0.44038}, "CVE-2016-6136": {"epss_score": 0.00021, "epss_percentile": 0.0482}, "CVE-2016-6137": {"epss_score": 0.04037, "epss_percentile": 0.88159}, "CVE-2016-6138": {"epss_score": 0.1569, "epss_percentile": 0.94485}, "CVE-2016-6139": {"epss_score": 0.05046, "epss_percentile": 0.89435}, "CVE-2016-6140": {"epss_score": 0.09791, "epss_percentile": 0.92704}, "CVE-2016-6142": {"epss_score": 0.01219, "epss_percentile": 0.78612}, "CVE-2016-6143": {"epss_score": 0.06145, "epss_percentile": 0.90517}, "CVE-2016-6144": {"epss_score": 0.00929, "epss_percentile": 0.75594}, "CVE-2016-6145": {"epss_score": 0.0039, "epss_percentile": 0.59557}, "CVE-2016-6146": {"epss_score": 0.00325, "epss_percentile": 0.55021}, "CVE-2016-6147": {"epss_score": 0.10552, "epss_percentile": 0.93026}, "CVE-2016-6148": {"epss_score": 0.0329, "epss_percentile": 0.86834}, "CVE-2016-6149": {"epss_score": 0.00063, "epss_percentile": 0.20069}, "CVE-2016-6150": {"epss_score": 0.0175, "epss_percentile": 0.82096}, "CVE-2016-6151": {"epss_score": 0.0113, "epss_percentile": 0.77854}, "CVE-2016-6152": {"epss_score": 0.01009, "epss_percentile": 0.76584}, "CVE-2016-6153": {"epss_score": 0.00032, "epss_percentile": 0.08986}, "CVE-2016-6154": {"epss_score": 0.00212, "epss_percentile": 0.43813}, "CVE-2016-6156": {"epss_score": 0.00043, "epss_percentile": 0.1297}, "CVE-2016-6158": {"epss_score": 0.00161, "epss_percentile": 0.37574}, "CVE-2016-6159": {"epss_score": 0.00804, "epss_percentile": 0.73627}, "CVE-2016-6160": {"epss_score": 0.0062, "epss_percentile": 0.69452}, "CVE-2016-6161": {"epss_score": 0.00402, "epss_percentile": 0.603}, "CVE-2016-6162": {"epss_score": 0.00041, "epss_percentile": 0.12407}, "CVE-2016-6163": {"epss_score": 0.00434, "epss_percentile": 0.62293}, "CVE-2016-6164": {"epss_score": 0.00936, "epss_percentile": 0.75689}, "CVE-2016-6167": {"epss_score": 0.00119, "epss_percentile": 0.31613}, "CVE-2016-6168": {"epss_score": 0.00347, "epss_percentile": 0.56782}, "CVE-2016-6169": {"epss_score": 0.00377, "epss_percentile": 0.58732}, "CVE-2016-6170": {"epss_score": 0.1302, "epss_percentile": 0.93847}, "CVE-2016-6171": {"epss_score": 0.01196, "epss_percentile": 0.78442}, "CVE-2016-6172": {"epss_score": 0.00014, "epss_percentile": 0.02116}, "CVE-2016-6173": {"epss_score": 0.01924, "epss_percentile": 0.82914}, "CVE-2016-6174": {"epss_score": 0.19825, "epss_percentile": 0.95247}, "CVE-2016-6175": {"epss_score": 0.13155, "epss_percentile": 0.93887}, "CVE-2016-6177": {"epss_score": 0.00197, "epss_percentile": 0.41835}, "CVE-2016-6178": {"epss_score": 0.01321, "epss_percentile": 0.79443}, "CVE-2016-6179": {"epss_score": 0.00021, "epss_percentile": 0.0485}, "CVE-2016-6180": {"epss_score": 0.00018, "epss_percentile": 0.04021}, "CVE-2016-6181": {"epss_score": 0.00018, "epss_percentile": 0.04021}, "CVE-2016-6182": {"epss_score": 0.00052, "epss_percentile": 0.16354}, "CVE-2016-6183": {"epss_score": 0.00018, "epss_percentile": 0.04021}, "CVE-2016-6184": {"epss_score": 0.00018, "epss_percentile": 0.04021}, "CVE-2016-6185": {"epss_score": 0.00246, "epss_percentile": 0.47744}, "CVE-2016-6186": {"epss_score": 0.13095, "epss_percentile": 0.93874}, "CVE-2016-6187": {"epss_score": 0.03522, "epss_percentile": 0.8729}, "CVE-2016-6188": {"epss_score": 0.01516, "epss_percentile": 0.80799}, "CVE-2016-6189": {"epss_score": 0.00173, "epss_percentile": 0.39132}, "CVE-2016-6190": {"epss_score": 0.002, "epss_percentile": 0.42214}, "CVE-2016-6191": {"epss_score": 0.00332, "epss_percentile": 0.55605}, "CVE-2016-6192": {"epss_score": 0.00048, "epss_percentile": 0.15149}, "CVE-2016-6193": {"epss_score": 0.00051, "epss_percentile": 0.16062}, "CVE-2016-6195": {"epss_score": 0.8643, "epss_percentile": 0.99382}, "CVE-2016-6197": {"epss_score": 0.00023, "epss_percentile": 0.05403}, "CVE-2016-6198": {"epss_score": 0.00025, "epss_percentile": 0.06219}, "CVE-2016-6199": {"epss_score": 0.02251, "epss_percentile": 0.84158}, "CVE-2016-6201": {"epss_score": 0.00196, "epss_percentile": 0.41807}, "CVE-2016-6204": {"epss_score": 0.0021, "epss_percentile": 0.43428}, "CVE-2016-6206": {"epss_score": 0.01774, "epss_percentile": 0.82211}, "CVE-2016-6207": {"epss_score": 0.06847, "epss_percentile": 0.91071}, "CVE-2016-6209": {"epss_score": 0.00589, "epss_percentile": 0.68535}, "CVE-2016-6210": {"epss_score": 0.92487, "epss_percentile": 0.99719}, "CVE-2016-6211": {"epss_score": 0.01128, "epss_percentile": 0.77828}, "CVE-2016-6212": {"epss_score": 0.00537, "epss_percentile": 0.669}, "CVE-2016-6213": {"epss_score": 0.00039, "epss_percentile": 0.11735}, "CVE-2016-6214": {"epss_score": 0.07758, "epss_percentile": 0.91662}, "CVE-2016-6217": {"epss_score": 0.00099, "epss_percentile": 0.2786}, "CVE-2016-6220": {"epss_score": 0.00528, "epss_percentile": 0.66548}, "CVE-2016-6223": {"epss_score": 0.01239, "epss_percentile": 0.78796}, "CVE-2016-6224": {"epss_score": 0.00057, "epss_percentile": 0.18051}, "CVE-2016-6225": {"epss_score": 0.00526, "epss_percentile": 0.66412}, "CVE-2016-6231": {"epss_score": 0.00192, "epss_percentile": 0.41322}, "CVE-2016-6232": {"epss_score": 0.05654, "epss_percentile": 0.90086}, "CVE-2016-6233": {"epss_score": 0.01724, "epss_percentile": 0.81952}, "CVE-2016-6234": {"epss_score": 0.00207, "epss_percentile": 0.43182}, "CVE-2016-6235": {"epss_score": 0.00207, "epss_percentile": 0.43182}, "CVE-2016-6236": {"epss_score": 0.00207, "epss_percentile": 0.43182}, "CVE-2016-6237": {"epss_score": 0.00207, "epss_percentile": 0.43182}, "CVE-2016-6238": {"epss_score": 0.00207, "epss_percentile": 0.43182}, "CVE-2016-6239": {"epss_score": 0.00138, "epss_percentile": 0.34512}, "CVE-2016-6240": {"epss_score": 0.00138, "epss_percentile": 0.3452}, "CVE-2016-6241": {"epss_score": 0.00129, "epss_percentile": 0.33121}, "CVE-2016-6242": {"epss_score": 0.00043, "epss_percentile": 0.13207}, "CVE-2016-6243": {"epss_score": 0.00043, "epss_percentile": 0.13207}, "CVE-2016-6244": {"epss_score": 0.01051, "epss_percentile": 0.77086}, "CVE-2016-6245": {"epss_score": 0.00043, "epss_percentile": 0.13207}, "CVE-2016-6246": {"epss_score": 0.00046, "epss_percentile": 0.14203}, "CVE-2016-6247": {"epss_score": 0.00043, "epss_percentile": 0.13207}, "CVE-2016-6249": {"epss_score": 0.00063, "epss_percentile": 0.20092}, "CVE-2016-6250": {"epss_score": 0.01708, "epss_percentile": 0.81868}, "CVE-2016-6252": {"epss_score": 0.00103, "epss_percentile": 0.2896}, "CVE-2016-6253": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2016-6254": {"epss_score": 0.13065, "epss_percentile": 0.93863}, "CVE-2016-6255": {"epss_score": 0.54208, "epss_percentile": 0.97914}, "CVE-2016-6256": {"epss_score": 0.10057, "epss_percentile": 0.92835}, "CVE-2016-6257": {"epss_score": 0.01034, "epss_percentile": 0.76885}, "CVE-2016-6258": {"epss_score": 0.00112, "epss_percentile": 0.30521}, "CVE-2016-6259": {"epss_score": 0.00266, "epss_percentile": 0.49899}, "CVE-2016-6261": {"epss_score": 0.04296, "epss_percentile": 0.88509}, "CVE-2016-6262": {"epss_score": 0.06274, "epss_percentile": 0.9063}, "CVE-2016-6263": {"epss_score": 0.03644, "epss_percentile": 0.87496}, "CVE-2016-6264": {"epss_score": 0.02321, "epss_percentile": 0.84371}, "CVE-2016-6265": {"epss_score": 0.00498, "epss_percentile": 0.65232}, "CVE-2016-6266": {"epss_score": 0.03015, "epss_percentile": 0.86213}, "CVE-2016-6267": {"epss_score": 0.72519, "epss_percentile": 0.98715}, "CVE-2016-6268": {"epss_score": 0.00081, "epss_percentile": 0.24268}, "CVE-2016-6269": {"epss_score": 0.01854, "epss_percentile": 0.82552}, "CVE-2016-6270": {"epss_score": 0.08435, "epss_percentile": 0.92051}, "CVE-2016-6271": {"epss_score": 0.07377, "epss_percentile": 0.91443}, "CVE-2016-6272": {"epss_score": 0.06477, "epss_percentile": 0.90783}, "CVE-2016-6273": {"epss_score": 0.01669, "epss_percentile": 0.81665}, "CVE-2016-6276": {"epss_score": 0.00051, "epss_percentile": 0.16041}, "CVE-2016-6277": {"epss_score": 0.93986, "epss_percentile": 0.9988}, "CVE-2016-6283": {"epss_score": 0.02983, "epss_percentile": 0.86126}, "CVE-2016-6285": {"epss_score": 0.00762, "epss_percentile": 0.7284}, "CVE-2016-6286": {"epss_score": 0.00697, "epss_percentile": 0.71399}, "CVE-2016-6287": {"epss_score": 0.00697, "epss_percentile": 0.71399}, "CVE-2016-6288": {"epss_score": 0.05206, "epss_percentile": 0.89609}, "CVE-2016-6289": {"epss_score": 0.02774, "epss_percentile": 0.85631}, "CVE-2016-6290": {"epss_score": 0.08003, "epss_percentile": 0.91822}, "CVE-2016-6291": {"epss_score": 0.09932, "epss_percentile": 0.92777}, "CVE-2016-6292": {"epss_score": 0.0256, "epss_percentile": 0.85104}, "CVE-2016-6293": {"epss_score": 0.02751, "epss_percentile": 0.85581}, "CVE-2016-6294": {"epss_score": 0.0738, "epss_percentile": 0.91443}, "CVE-2016-6295": {"epss_score": 0.09516, "epss_percentile": 0.92582}, "CVE-2016-6296": {"epss_score": 0.12374, "epss_percentile": 0.93653}, "CVE-2016-6297": {"epss_score": 0.07487, "epss_percentile": 0.91498}, "CVE-2016-6298": {"epss_score": 0.00365, "epss_percentile": 0.57995}, "CVE-2016-6299": {"epss_score": 0.00129, "epss_percentile": 0.33142}, "CVE-2016-6301": {"epss_score": 0.03125, "epss_percentile": 0.86453}, "CVE-2016-6302": {"epss_score": 0.1751, "epss_percentile": 0.94859}, "CVE-2016-6303": {"epss_score": 0.32879, "epss_percentile": 0.96732}, "CVE-2016-6304": {"epss_score": 0.23429, "epss_percentile": 0.95776}, "CVE-2016-6305": {"epss_score": 0.32754, "epss_percentile": 0.96723}, "CVE-2016-6306": {"epss_score": 0.09316, "epss_percentile": 0.92497}, "CVE-2016-6307": {"epss_score": 0.20873, "epss_percentile": 0.95431}, "CVE-2016-6308": {"epss_score": 0.2425, "epss_percentile": 0.95896}, "CVE-2016-6309": {"epss_score": 0.28212, "epss_percentile": 0.96332}, "CVE-2016-6310": {"epss_score": 0.00129, "epss_percentile": 0.33127}, "CVE-2016-6311": {"epss_score": 0.00665, "epss_percentile": 0.70668}, "CVE-2016-6312": {"epss_score": 0.00515, "epss_percentile": 0.65985}, "CVE-2016-6313": {"epss_score": 0.03177, "epss_percentile": 0.86572}, "CVE-2016-6316": {"epss_score": 0.01626, "epss_percentile": 0.81425}, "CVE-2016-6317": {"epss_score": 0.00381, "epss_percentile": 0.58983}, "CVE-2016-6318": {"epss_score": 0.03522, "epss_percentile": 0.87289}, "CVE-2016-6319": {"epss_score": 0.00734, "epss_percentile": 0.72231}, "CVE-2016-6320": {"epss_score": 0.00348, "epss_percentile": 0.56796}, "CVE-2016-6321": {"epss_score": 0.12594, "epss_percentile": 0.93723}, "CVE-2016-6322": {"epss_score": 0.00041, "epss_percentile": 0.12364}, "CVE-2016-6323": {"epss_score": 0.01133, "epss_percentile": 0.77883}, "CVE-2016-6325": {"epss_score": 0.00095, "epss_percentile": 0.27214}, "CVE-2016-6327": {"epss_score": 0.00075, "epss_percentile": 0.22964}, "CVE-2016-6328": {"epss_score": 0.01118, "epss_percentile": 0.77749}, "CVE-2016-6329": {"epss_score": 0.04887, "epss_percentile": 0.89255}, "CVE-2016-6330": {"epss_score": 0.10009, "epss_percentile": 0.92816}, "CVE-2016-6331": {"epss_score": 0.00166, "epss_percentile": 0.38241}, "CVE-2016-6332": {"epss_score": 0.00221, "epss_percentile": 0.44668}, "CVE-2016-6333": {"epss_score": 0.00335, "epss_percentile": 0.55804}, "CVE-2016-6334": {"epss_score": 0.00221, "epss_percentile": 0.44633}, "CVE-2016-6335": {"epss_score": 0.00273, "epss_percentile": 0.50474}, "CVE-2016-6336": {"epss_score": 0.00105, "epss_percentile": 0.29358}, "CVE-2016-6337": {"epss_score": 0.00339, "epss_percentile": 0.562}, "CVE-2016-6338": {"epss_score": 0.00063, "epss_percentile": 0.19908}, "CVE-2016-6340": {"epss_score": 0.00125, "epss_percentile": 0.32468}, "CVE-2016-6341": {"epss_score": 0.00065, "epss_percentile": 0.20606}, "CVE-2016-6342": {"epss_score": 0.00228, "epss_percentile": 0.45534}, "CVE-2016-6343": {"epss_score": 0.00365, "epss_percentile": 0.5797}, "CVE-2016-6344": {"epss_score": 0.00321, "epss_percentile": 0.54673}, "CVE-2016-6345": {"epss_score": 0.00084, "epss_percentile": 0.25022}, "CVE-2016-6346": {"epss_score": 0.01184, "epss_percentile": 0.78328}, "CVE-2016-6347": {"epss_score": 0.00093, "epss_percentile": 0.26728}, "CVE-2016-6348": {"epss_score": 0.00132, "epss_percentile": 0.33554}, "CVE-2016-6349": {"epss_score": 0.00129, "epss_percentile": 0.33184}, "CVE-2016-6350": {"epss_score": 0.00145, "epss_percentile": 0.35518}, "CVE-2016-6351": {"epss_score": 0.00167, "epss_percentile": 0.38402}, "CVE-2016-6352": {"epss_score": 0.01565, "epss_percentile": 0.81066}, "CVE-2016-6353": {"epss_score": 0.00176, "epss_percentile": 0.39388}, "CVE-2016-6354": {"epss_score": 0.36848, "epss_percentile": 0.97004}, "CVE-2016-6355": {"epss_score": 0.00743, "epss_percentile": 0.72473}, "CVE-2016-6356": {"epss_score": 0.0076, "epss_percentile": 0.72811}, "CVE-2016-6357": {"epss_score": 0.00222, "epss_percentile": 0.44804}, "CVE-2016-6358": {"epss_score": 0.01027, "epss_percentile": 0.76811}, "CVE-2016-6359": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-6360": {"epss_score": 0.01361, "epss_percentile": 0.79753}, "CVE-2016-6361": {"epss_score": 0.00804, "epss_percentile": 0.73624}, "CVE-2016-6362": {"epss_score": 0.00099, "epss_percentile": 0.28392}, "CVE-2016-6363": {"epss_score": 0.00804, "epss_percentile": 0.73624}, "CVE-2016-6364": {"epss_score": 0.00734, "epss_percentile": 0.7222}, "CVE-2016-6365": {"epss_score": 0.00398, "epss_percentile": 0.60083}, "CVE-2016-6366": {"epss_score": 0.91389, "epss_percentile": 0.99638}, "CVE-2016-6367": {"epss_score": 0.23087, "epss_percentile": 0.95732}, "CVE-2016-6368": {"epss_score": 0.00379, "epss_percentile": 0.5888}, "CVE-2016-6369": {"epss_score": 0.00099, "epss_percentile": 0.28392}, "CVE-2016-6370": {"epss_score": 0.00543, "epss_percentile": 0.67112}, "CVE-2016-6371": {"epss_score": 0.0729, "epss_percentile": 0.91386}, "CVE-2016-6372": {"epss_score": 0.0027, "epss_percentile": 0.50272}, "CVE-2016-6373": {"epss_score": 0.0078, "epss_percentile": 0.73165}, "CVE-2016-6374": {"epss_score": 0.05617, "epss_percentile": 0.90056}, "CVE-2016-6375": {"epss_score": 0.00284, "epss_percentile": 0.51455}, "CVE-2016-6376": {"epss_score": 0.00304, "epss_percentile": 0.53247}, "CVE-2016-6377": {"epss_score": 0.00335, "epss_percentile": 0.55807}, "CVE-2016-6378": {"epss_score": 0.00743, "epss_percentile": 0.72473}, "CVE-2016-6379": {"epss_score": 0.00743, "epss_percentile": 0.72473}, "CVE-2016-6380": {"epss_score": 0.01673, "epss_percentile": 0.8169}, "CVE-2016-6381": {"epss_score": 0.0126, "epss_percentile": 0.78969}, "CVE-2016-6382": {"epss_score": 0.07696, "epss_percentile": 0.91632}, "CVE-2016-6384": {"epss_score": 0.01972, "epss_percentile": 0.83107}, "CVE-2016-6385": {"epss_score": 0.03487, "epss_percentile": 0.87228}, "CVE-2016-6386": {"epss_score": 0.00743, "epss_percentile": 0.72473}, "CVE-2016-6391": {"epss_score": 0.00743, "epss_percentile": 0.72473}, "CVE-2016-6392": {"epss_score": 0.01309, "epss_percentile": 0.79356}, "CVE-2016-6393": {"epss_score": 0.0912, "epss_percentile": 0.92408}, "CVE-2016-6394": {"epss_score": 0.003, "epss_percentile": 0.52975}, "CVE-2016-6395": {"epss_score": 0.00222, "epss_percentile": 0.4475}, "CVE-2016-6396": {"epss_score": 0.00433, "epss_percentile": 0.62188}, "CVE-2016-6397": {"epss_score": 0.0102, "epss_percentile": 0.76732}, "CVE-2016-6398": {"epss_score": 0.00273, "epss_percentile": 0.50443}, "CVE-2016-6399": {"epss_score": 0.00743, "epss_percentile": 0.72473}, "CVE-2016-6401": {"epss_score": 0.00284, "epss_percentile": 0.51455}, "CVE-2016-6402": {"epss_score": 0.00083, "epss_percentile": 0.24746}, "CVE-2016-6403": {"epss_score": 0.00992, "epss_percentile": 0.76391}, "CVE-2016-6404": {"epss_score": 0.00453, "epss_percentile": 0.6324}, "CVE-2016-6405": {"epss_score": 0.00177, "epss_percentile": 0.39576}, "CVE-2016-6406": {"epss_score": 0.02876, "epss_percentile": 0.85883}, "CVE-2016-6407": {"epss_score": 0.00749, "epss_percentile": 0.72609}, "CVE-2016-6408": {"epss_score": 0.00431, "epss_percentile": 0.62094}, "CVE-2016-6409": {"epss_score": 0.00686, "epss_percentile": 0.71156}, "CVE-2016-6410": {"epss_score": 0.00308, "epss_percentile": 0.53604}, "CVE-2016-6411": {"epss_score": 0.00206, "epss_percentile": 0.43053}, "CVE-2016-6412": {"epss_score": 0.00149, "epss_percentile": 0.3596}, "CVE-2016-6413": {"epss_score": 0.00078, "epss_percentile": 0.23667}, "CVE-2016-6414": {"epss_score": 0.00222, "epss_percentile": 0.44754}, "CVE-2016-6415": {"epss_score": 0.92999, "epss_percentile": 0.99767}, "CVE-2016-6416": {"epss_score": 0.00888, "epss_percentile": 0.74998}, "CVE-2016-6417": {"epss_score": 0.00129, "epss_percentile": 0.33081}, "CVE-2016-6418": {"epss_score": 0.00292, "epss_percentile": 0.52243}, "CVE-2016-6419": {"epss_score": 0.00542, "epss_percentile": 0.67075}, "CVE-2016-6420": {"epss_score": 0.00049, "epss_percentile": 0.15482}, "CVE-2016-6421": {"epss_score": 0.00546, "epss_percentile": 0.67208}, "CVE-2016-6422": {"epss_score": 0.0021, "epss_percentile": 0.43476}, "CVE-2016-6423": {"epss_score": 0.00437, "epss_percentile": 0.62531}, "CVE-2016-6424": {"epss_score": 0.00685, "epss_percentile": 0.7114}, "CVE-2016-6425": {"epss_score": 0.00296, "epss_percentile": 0.52621}, "CVE-2016-6426": {"epss_score": 0.00244, "epss_percentile": 0.47579}, "CVE-2016-6427": {"epss_score": 0.00129, "epss_percentile": 0.33081}, "CVE-2016-6428": {"epss_score": 0.00083, "epss_percentile": 0.24746}, "CVE-2016-6429": {"epss_score": 0.0027, "epss_percentile": 0.50243}, "CVE-2016-6430": {"epss_score": 0.00058, "epss_percentile": 0.18378}, "CVE-2016-6431": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2016-6432": {"epss_score": 0.04744, "epss_percentile": 0.89084}, "CVE-2016-6433": {"epss_score": 0.72601, "epss_percentile": 0.98718}, "CVE-2016-6434": {"epss_score": 0.00385, "epss_percentile": 0.59185}, "CVE-2016-6435": {"epss_score": 0.55026, "epss_percentile": 0.97957}, "CVE-2016-6436": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2016-6437": {"epss_score": 0.00711, "epss_percentile": 0.7174}, "CVE-2016-6438": {"epss_score": 0.00374, "epss_percentile": 0.58532}, "CVE-2016-6439": {"epss_score": 0.00145, "epss_percentile": 0.35445}, "CVE-2016-6440": {"epss_score": 0.00288, "epss_percentile": 0.51911}, "CVE-2016-6441": {"epss_score": 0.03452, "epss_percentile": 0.87167}, "CVE-2016-6442": {"epss_score": 0.00203, "epss_percentile": 0.42535}, "CVE-2016-6443": {"epss_score": 0.0187, "epss_percentile": 0.8263}, "CVE-2016-6444": {"epss_score": 0.00194, "epss_percentile": 0.41571}, "CVE-2016-6445": {"epss_score": 0.0077, "epss_percentile": 0.72995}, "CVE-2016-6446": {"epss_score": 0.00484, "epss_percentile": 0.64657}, "CVE-2016-6447": {"epss_score": 0.07588, "epss_percentile": 0.91557}, "CVE-2016-6448": {"epss_score": 0.07588, "epss_percentile": 0.91557}, "CVE-2016-6449": {"epss_score": 0.00051, "epss_percentile": 0.16176}, "CVE-2016-6450": {"epss_score": 0.00063, "epss_percentile": 0.19993}, "CVE-2016-6451": {"epss_score": 0.00489, "epss_percentile": 0.64909}, "CVE-2016-6452": {"epss_score": 0.01119, "epss_percentile": 0.77758}, "CVE-2016-6453": {"epss_score": 0.0034, "epss_percentile": 0.56279}, "CVE-2016-6454": {"epss_score": 0.00155, "epss_percentile": 0.36814}, "CVE-2016-6455": {"epss_score": 0.01243, "epss_percentile": 0.78827}, "CVE-2016-6457": {"epss_score": 0.00361, "epss_percentile": 0.57721}, "CVE-2016-6458": {"epss_score": 0.00215, "epss_percentile": 0.44033}, "CVE-2016-6459": {"epss_score": 0.00591, "epss_percentile": 0.6859}, "CVE-2016-6460": {"epss_score": 0.00227, "epss_percentile": 0.4537}, "CVE-2016-6461": {"epss_score": 0.00335, "epss_percentile": 0.55843}, "CVE-2016-6462": {"epss_score": 0.00183, "epss_percentile": 0.40352}, "CVE-2016-6463": {"epss_score": 0.00172, "epss_percentile": 0.38983}, "CVE-2016-6464": {"epss_score": 0.01357, "epss_percentile": 0.79721}, "CVE-2016-6465": {"epss_score": 0.00194, "epss_percentile": 0.41558}, "CVE-2016-6466": {"epss_score": 0.00777, "epss_percentile": 0.73107}, "CVE-2016-6467": {"epss_score": 0.01792, "epss_percentile": 0.82287}, "CVE-2016-6468": {"epss_score": 0.00329, "epss_percentile": 0.55382}, "CVE-2016-6469": {"epss_score": 0.00992, "epss_percentile": 0.764}, "CVE-2016-6470": {"epss_score": 0.00063, "epss_percentile": 0.19885}, "CVE-2016-6471": {"epss_score": 0.00422, "epss_percentile": 0.61564}, "CVE-2016-6472": {"epss_score": 0.0032, "epss_percentile": 0.54608}, "CVE-2016-6473": {"epss_score": 0.00208, "epss_percentile": 0.43217}, "CVE-2016-6474": {"epss_score": 0.00315, "epss_percentile": 0.5419}, "CVE-2016-6480": {"epss_score": 0.00065, "epss_percentile": 0.20552}, "CVE-2016-6483": {"epss_score": 0.14564, "epss_percentile": 0.94242}, "CVE-2016-6484": {"epss_score": 0.00312, "epss_percentile": 0.53995}, "CVE-2016-6485": {"epss_score": 0.00047, "epss_percentile": 0.14855}, "CVE-2016-6486": {"epss_score": 0.00071, "epss_percentile": 0.22014}, "CVE-2016-6489": {"epss_score": 0.01684, "epss_percentile": 0.81741}, "CVE-2016-6490": {"epss_score": 0.00075, "epss_percentile": 0.22922}, "CVE-2016-6491": {"epss_score": 0.01194, "epss_percentile": 0.78424}, "CVE-2016-6492": {"epss_score": 0.00058, "epss_percentile": 0.18529}, "CVE-2016-6493": {"epss_score": 0.02169, "epss_percentile": 0.83865}, "CVE-2016-6494": {"epss_score": 0.00056, "epss_percentile": 0.17722}, "CVE-2016-6495": {"epss_score": 0.0035, "epss_percentile": 0.56969}, "CVE-2016-6496": {"epss_score": 0.02912, "epss_percentile": 0.85973}, "CVE-2016-6497": {"epss_score": 0.03008, "epss_percentile": 0.86193}, "CVE-2016-6500": {"epss_score": 0.01888, "epss_percentile": 0.8272}, "CVE-2016-6501": {"epss_score": 0.01685, "epss_percentile": 0.81751}, "CVE-2016-6503": {"epss_score": 0.02162, "epss_percentile": 0.83829}, "CVE-2016-6504": {"epss_score": 0.02013, "epss_percentile": 0.8326}, "CVE-2016-6505": {"epss_score": 0.02278, "epss_percentile": 0.84234}, "CVE-2016-6506": {"epss_score": 0.00172, "epss_percentile": 0.39039}, "CVE-2016-6507": {"epss_score": 0.00332, "epss_percentile": 0.55586}, "CVE-2016-6508": {"epss_score": 0.00183, "epss_percentile": 0.40346}, "CVE-2016-6509": {"epss_score": 0.00209, "epss_percentile": 0.43413}, "CVE-2016-6510": {"epss_score": 0.00196, "epss_percentile": 0.41759}, "CVE-2016-6511": {"epss_score": 0.00183, "epss_percentile": 0.40346}, "CVE-2016-6512": {"epss_score": 0.01894, "epss_percentile": 0.82744}, "CVE-2016-6513": {"epss_score": 0.00144, "epss_percentile": 0.35244}, "CVE-2016-6515": {"epss_score": 0.84415, "epss_percentile": 0.99288}, "CVE-2016-6516": {"epss_score": 0.00516, "epss_percentile": 0.66047}, "CVE-2016-6517": {"epss_score": 0.01282, "epss_percentile": 0.79151}, "CVE-2016-6518": {"epss_score": 0.00321, "epss_percentile": 0.54733}, "CVE-2016-6519": {"epss_score": 0.00326, "epss_percentile": 0.55088}, "CVE-2016-6520": {"epss_score": 0.03417, "epss_percentile": 0.87094}, "CVE-2016-6521": {"epss_score": 0.00286, "epss_percentile": 0.51689}, "CVE-2016-6522": {"epss_score": 0.00083, "epss_percentile": 0.24618}, "CVE-2016-6523": {"epss_score": 0.00793, "epss_percentile": 0.73432}, "CVE-2016-6525": {"epss_score": 0.05362, "epss_percentile": 0.89784}, "CVE-2016-6526": {"epss_score": 0.0013, "epss_percentile": 0.3331}, "CVE-2016-6527": {"epss_score": 0.0013, "epss_percentile": 0.3331}, "CVE-2016-6530": {"epss_score": 0.02381, "epss_percentile": 0.84564}, "CVE-2016-6531": {"epss_score": 0.03269, "epss_percentile": 0.86788}, "CVE-2016-6532": {"epss_score": 0.00734, "epss_percentile": 0.72244}, "CVE-2016-6534": {"epss_score": 0.03701, "epss_percentile": 0.87592}, "CVE-2016-6535": {"epss_score": 0.00734, "epss_percentile": 0.72244}, "CVE-2016-6536": {"epss_score": 0.00802, "epss_percentile": 0.73593}, "CVE-2016-6537": {"epss_score": 0.00231, "epss_percentile": 0.45833}, "CVE-2016-6538": {"epss_score": 0.00277, "epss_percentile": 0.5084}, "CVE-2016-6539": {"epss_score": 0.00163, "epss_percentile": 0.37814}, "CVE-2016-6540": {"epss_score": 0.00443, "epss_percentile": 0.6276}, "CVE-2016-6541": {"epss_score": 0.00767, "epss_percentile": 0.72951}, "CVE-2016-6542": {"epss_score": 0.00362, "epss_percentile": 0.57809}, "CVE-2016-6543": {"epss_score": 0.00913, "epss_percentile": 0.7538}, "CVE-2016-6544": {"epss_score": 0.01206, "epss_percentile": 0.78521}, "CVE-2016-6545": {"epss_score": 0.00996, "epss_percentile": 0.76449}, "CVE-2016-6546": {"epss_score": 0.00081, "epss_percentile": 0.24352}, "CVE-2016-6547": {"epss_score": 0.00081, "epss_percentile": 0.24352}, "CVE-2016-6548": {"epss_score": 0.02039, "epss_percentile": 0.83362}, "CVE-2016-6549": {"epss_score": 0.00245, "epss_percentile": 0.47658}, "CVE-2016-6550": {"epss_score": 0.0003, "epss_percentile": 0.08058}, "CVE-2016-6551": {"epss_score": 0.00649, "epss_percentile": 0.70229}, "CVE-2016-6552": {"epss_score": 0.00649, "epss_percentile": 0.70229}, "CVE-2016-6553": {"epss_score": 0.00649, "epss_percentile": 0.70229}, "CVE-2016-6554": {"epss_score": 0.01541, "epss_percentile": 0.80947}, "CVE-2016-6555": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2016-6556": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2016-6557": {"epss_score": 0.00105, "epss_percentile": 0.29252}, "CVE-2016-6558": {"epss_score": 0.04241, "epss_percentile": 0.88434}, "CVE-2016-6559": {"epss_score": 0.01633, "epss_percentile": 0.81463}, "CVE-2016-6560": {"epss_score": 0.00481, "epss_percentile": 0.64513}, "CVE-2016-6561": {"epss_score": 0.00732, "epss_percentile": 0.722}, "CVE-2016-6562": {"epss_score": 0.00102, "epss_percentile": 0.28799}, "CVE-2016-6563": {"epss_score": 0.87965, "epss_percentile": 0.99452}, "CVE-2016-6564": {"epss_score": 0.00359, "epss_percentile": 0.57613}, "CVE-2016-6565": {"epss_score": 0.01595, "epss_percentile": 0.81238}, "CVE-2016-6566": {"epss_score": 0.05295, "epss_percentile": 0.89701}, "CVE-2016-6567": {"epss_score": 0.01252, "epss_percentile": 0.78911}, "CVE-2016-6578": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2016-6580": {"epss_score": 0.00476, "epss_percentile": 0.64254}, "CVE-2016-6581": {"epss_score": 0.00373, "epss_percentile": 0.58477}, "CVE-2016-6582": {"epss_score": 0.01593, "epss_percentile": 0.81226}, "CVE-2016-6585": {"epss_score": 0.00938, "epss_percentile": 0.75706}, "CVE-2016-6586": {"epss_score": 0.00839, "epss_percentile": 0.74193}, "CVE-2016-6587": {"epss_score": 0.00131, "epss_percentile": 0.3349}, "CVE-2016-6588": {"epss_score": 0.00471, "epss_percentile": 0.64011}, "CVE-2016-6589": {"epss_score": 0.00768, "epss_percentile": 0.72969}, "CVE-2016-6590": {"epss_score": 0.00058, "epss_percentile": 0.18546}, "CVE-2016-6591": {"epss_score": 0.00071, "epss_percentile": 0.22147}, "CVE-2016-6592": {"epss_score": 0.00614, "epss_percentile": 0.69275}, "CVE-2016-6593": {"epss_score": 0.00344, "epss_percentile": 0.56519}, "CVE-2016-6594": {"epss_score": 0.00734, "epss_percentile": 0.72237}, "CVE-2016-6595": {"epss_score": 0.00649, "epss_percentile": 0.70227}, "CVE-2016-6597": {"epss_score": 0.00164, "epss_percentile": 0.37983}, "CVE-2016-6598": {"epss_score": 0.36872, "epss_percentile": 0.97006}, "CVE-2016-6599": {"epss_score": 0.33367, "epss_percentile": 0.96766}, "CVE-2016-6600": {"epss_score": 0.90636, "epss_percentile": 0.99593}, "CVE-2016-6601": {"epss_score": 0.9278, "epss_percentile": 0.99748}, "CVE-2016-6602": {"epss_score": 0.47774, "epss_percentile": 0.97601}, "CVE-2016-6603": {"epss_score": 0.70316, "epss_percentile": 0.98628}, "CVE-2016-6604": {"epss_score": 0.00551, "epss_percentile": 0.67359}, "CVE-2016-6605": {"epss_score": 0.0021, "epss_percentile": 0.43588}, "CVE-2016-6606": {"epss_score": 0.00258, "epss_percentile": 0.49014}, "CVE-2016-6607": {"epss_score": 0.00541, "epss_percentile": 0.67044}, "CVE-2016-6608": {"epss_score": 0.00452, "epss_percentile": 0.63162}, "CVE-2016-6609": {"epss_score": 0.00425, "epss_percentile": 0.61704}, "CVE-2016-6610": {"epss_score": 0.00449, "epss_percentile": 0.63043}, "CVE-2016-6611": {"epss_score": 0.00365, "epss_percentile": 0.57973}, "CVE-2016-6612": {"epss_score": 0.00411, "epss_percentile": 0.60903}, "CVE-2016-6613": {"epss_score": 0.00411, "epss_percentile": 0.60903}, "CVE-2016-6614": {"epss_score": 0.0111, "epss_percentile": 0.77656}, "CVE-2016-6615": {"epss_score": 0.005, "epss_percentile": 0.65317}, "CVE-2016-6616": {"epss_score": 0.00316, "epss_percentile": 0.54294}, "CVE-2016-6617": {"epss_score": 0.00376, "epss_percentile": 0.58686}, "CVE-2016-6618": {"epss_score": 0.0055, "epss_percentile": 0.67332}, "CVE-2016-6619": {"epss_score": 0.00332, "epss_percentile": 0.55574}, "CVE-2016-6620": {"epss_score": 0.01398, "epss_percentile": 0.79988}, "CVE-2016-6621": {"epss_score": 0.00389, "epss_percentile": 0.5941}, "CVE-2016-6622": {"epss_score": 0.01016, "epss_percentile": 0.7667}, "CVE-2016-6623": {"epss_score": 0.0055, "epss_percentile": 0.67332}, "CVE-2016-6624": {"epss_score": 0.003, "epss_percentile": 0.52922}, "CVE-2016-6625": {"epss_score": 0.00275, "epss_percentile": 0.50634}, "CVE-2016-6626": {"epss_score": 0.00433, "epss_percentile": 0.62198}, "CVE-2016-6627": {"epss_score": 0.0035, "epss_percentile": 0.56926}, "CVE-2016-6628": {"epss_score": 0.00258, "epss_percentile": 0.49011}, "CVE-2016-6629": {"epss_score": 0.00435, "epss_percentile": 0.62348}, "CVE-2016-6630": {"epss_score": 0.00713, "epss_percentile": 0.71799}, "CVE-2016-6631": {"epss_score": 0.03567, "epss_percentile": 0.87367}, "CVE-2016-6632": {"epss_score": 0.00567, "epss_percentile": 0.67847}, "CVE-2016-6633": {"epss_score": 0.01833, "epss_percentile": 0.8246}, "CVE-2016-6634": {"epss_score": 0.00782, "epss_percentile": 0.73211}, "CVE-2016-6635": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2016-6636": {"epss_score": 0.00236, "epss_percentile": 0.46447}, "CVE-2016-6637": {"epss_score": 0.00118, "epss_percentile": 0.31439}, "CVE-2016-6639": {"epss_score": 0.00379, "epss_percentile": 0.58896}, "CVE-2016-6641": {"epss_score": 0.00195, "epss_percentile": 0.41672}, "CVE-2016-6642": {"epss_score": 0.00073, "epss_percentile": 0.22608}, "CVE-2016-6643": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2016-6644": {"epss_score": 0.0029, "epss_percentile": 0.52081}, "CVE-2016-6645": {"epss_score": 0.01344, "epss_percentile": 0.79613}, "CVE-2016-6646": {"epss_score": 0.03932, "epss_percentile": 0.87975}, "CVE-2016-6647": {"epss_score": 0.00178, "epss_percentile": 0.39661}, "CVE-2016-6648": {"epss_score": 0.00119, "epss_percentile": 0.31646}, "CVE-2016-6649": {"epss_score": 0.0018, "epss_percentile": 0.3988}, "CVE-2016-6650": {"epss_score": 0.0115, "epss_percentile": 0.78028}, "CVE-2016-6651": {"epss_score": 0.00578, "epss_percentile": 0.68203}, "CVE-2016-6652": {"epss_score": 0.00317, "epss_percentile": 0.54336}, "CVE-2016-6653": {"epss_score": 0.00297, "epss_percentile": 0.5277}, "CVE-2016-6655": {"epss_score": 0.04683, "epss_percentile": 0.89002}, "CVE-2016-6656": {"epss_score": 0.00432, "epss_percentile": 0.62109}, "CVE-2016-6657": {"epss_score": 0.00187, "epss_percentile": 0.40726}, "CVE-2016-6658": {"epss_score": 0.00294, "epss_percentile": 0.52426}, "CVE-2016-6659": {"epss_score": 0.00323, "epss_percentile": 0.54884}, "CVE-2016-6662": {"epss_score": 0.89577, "epss_percentile": 0.99532}, "CVE-2016-6663": {"epss_score": 0.02108, "epss_percentile": 0.8364}, "CVE-2016-6664": {"epss_score": 0.44687, "epss_percentile": 0.97449}, "CVE-2016-6667": {"epss_score": 0.02471, "epss_percentile": 0.84848}, "CVE-2016-6668": {"epss_score": 0.01318, "epss_percentile": 0.79422}, "CVE-2016-6669": {"epss_score": 0.02122, "epss_percentile": 0.8368}, "CVE-2016-6670": {"epss_score": 0.00103, "epss_percentile": 0.28972}, "CVE-2016-6671": {"epss_score": 0.0058, "epss_percentile": 0.68237}, "CVE-2016-6672": {"epss_score": 0.00043, "epss_percentile": 0.13122}, "CVE-2016-6673": {"epss_score": 0.00044, "epss_percentile": 0.13653}, "CVE-2016-6674": {"epss_score": 0.00061, "epss_percentile": 0.19412}, "CVE-2016-6675": {"epss_score": 0.00061, "epss_percentile": 0.19421}, "CVE-2016-6676": {"epss_score": 0.00061, "epss_percentile": 0.19421}, "CVE-2016-6677": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2016-6678": {"epss_score": 0.00109, "epss_percentile": 0.29995}, "CVE-2016-6679": {"epss_score": 0.00108, "epss_percentile": 0.29877}, "CVE-2016-6680": {"epss_score": 0.00092, "epss_percentile": 0.26489}, "CVE-2016-6681": {"epss_score": 0.00122, "epss_percentile": 0.3206}, "CVE-2016-6682": {"epss_score": 0.00122, "epss_percentile": 0.3206}, "CVE-2016-6683": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2016-6684": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2016-6685": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2016-6686": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2016-6687": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2016-6688": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2016-6689": {"epss_score": 0.00797, "epss_percentile": 0.73498}, "CVE-2016-6690": {"epss_score": 0.00035, "epss_percentile": 0.09975}, "CVE-2016-6691": {"epss_score": 0.00551, "epss_percentile": 0.67375}, "CVE-2016-6692": {"epss_score": 0.00186, "epss_percentile": 0.40681}, "CVE-2016-6693": {"epss_score": 0.00217, "epss_percentile": 0.44324}, "CVE-2016-6694": {"epss_score": 0.00217, "epss_percentile": 0.44324}, "CVE-2016-6695": {"epss_score": 0.00249, "epss_percentile": 0.48025}, "CVE-2016-6696": {"epss_score": 0.00217, "epss_percentile": 0.44324}, "CVE-2016-6698": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2016-6699": {"epss_score": 0.00246, "epss_percentile": 0.47808}, "CVE-2016-6700": {"epss_score": 0.00094, "epss_percentile": 0.27047}, "CVE-2016-6701": {"epss_score": 0.00243, "epss_percentile": 0.47453}, "CVE-2016-6702": {"epss_score": 0.00424, "epss_percentile": 0.61671}, "CVE-2016-6703": {"epss_score": 0.00267, "epss_percentile": 0.49956}, "CVE-2016-6704": {"epss_score": 0.00078, "epss_percentile": 0.23735}, "CVE-2016-6705": {"epss_score": 0.00049, "epss_percentile": 0.15464}, "CVE-2016-6706": {"epss_score": 0.0005, "epss_percentile": 0.15774}, "CVE-2016-6707": {"epss_score": 0.01516, "epss_percentile": 0.808}, "CVE-2016-6708": {"epss_score": 0.00016, "epss_percentile": 0.02933}, "CVE-2016-6709": {"epss_score": 0.00094, "epss_percentile": 0.27046}, "CVE-2016-6710": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2016-6711": {"epss_score": 0.00452, "epss_percentile": 0.63167}, "CVE-2016-6712": {"epss_score": 0.00192, "epss_percentile": 0.41336}, "CVE-2016-6713": {"epss_score": 0.00128, "epss_percentile": 0.3303}, "CVE-2016-6714": {"epss_score": 0.00128, "epss_percentile": 0.3303}, "CVE-2016-6715": {"epss_score": 0.00041, "epss_percentile": 0.12383}, "CVE-2016-6716": {"epss_score": 0.00041, "epss_percentile": 0.12383}, "CVE-2016-6717": {"epss_score": 0.00049, "epss_percentile": 0.15464}, "CVE-2016-6718": {"epss_score": 0.00054, "epss_percentile": 0.17188}, "CVE-2016-6719": {"epss_score": 0.00041, "epss_percentile": 0.12383}, "CVE-2016-6720": {"epss_score": 0.0011, "epss_percentile": 0.3019}, "CVE-2016-6721": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2016-6722": {"epss_score": 0.00091, "epss_percentile": 0.26292}, "CVE-2016-6723": {"epss_score": 0.00377, "epss_percentile": 0.58747}, "CVE-2016-6724": {"epss_score": 0.00043, "epss_percentile": 0.13238}, "CVE-2016-6725": {"epss_score": 0.03055, "epss_percentile": 0.86298}, "CVE-2016-6726": {"epss_score": 0.00106, "epss_percentile": 0.2946}, "CVE-2016-6727": {"epss_score": 0.0714, "epss_percentile": 0.91278}, "CVE-2016-6728": {"epss_score": 0.00107, "epss_percentile": 0.29724}, "CVE-2016-6729": {"epss_score": 0.00037, "epss_percentile": 0.10975}, "CVE-2016-6730": {"epss_score": 0.00035, "epss_percentile": 0.10153}, "CVE-2016-6731": {"epss_score": 0.00035, "epss_percentile": 0.10153}, "CVE-2016-6732": {"epss_score": 0.00035, "epss_percentile": 0.10153}, "CVE-2016-6733": {"epss_score": 0.00035, "epss_percentile": 0.10153}, "CVE-2016-6734": {"epss_score": 0.00037, "epss_percentile": 0.10975}, "CVE-2016-6735": {"epss_score": 0.00037, "epss_percentile": 0.10975}, "CVE-2016-6736": {"epss_score": 0.00037, "epss_percentile": 0.10975}, "CVE-2016-6737": {"epss_score": 0.00037, "epss_percentile": 0.10975}, "CVE-2016-6738": {"epss_score": 0.00065, "epss_percentile": 0.20534}, "CVE-2016-6739": {"epss_score": 0.00037, "epss_percentile": 0.10975}, "CVE-2016-6740": {"epss_score": 0.00065, "epss_percentile": 0.20534}, "CVE-2016-6741": {"epss_score": 0.00065, "epss_percentile": 0.20534}, "CVE-2016-6742": {"epss_score": 0.00065, "epss_percentile": 0.20534}, "CVE-2016-6743": {"epss_score": 0.00037, "epss_percentile": 0.10975}, "CVE-2016-6744": {"epss_score": 0.00065, "epss_percentile": 0.20534}, "CVE-2016-6745": {"epss_score": 0.00065, "epss_percentile": 0.20534}, "CVE-2016-6746": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-6747": {"epss_score": 0.00117, "epss_percentile": 0.31351}, "CVE-2016-6748": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-6749": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-6750": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-6751": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-6752": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-6753": {"epss_score": 0.00109, "epss_percentile": 0.30074}, "CVE-2016-6754": {"epss_score": 0.28454, "epss_percentile": 0.96359}, "CVE-2016-6755": {"epss_score": 0.00185, "epss_percentile": 0.40504}, "CVE-2016-6756": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2016-6757": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2016-6758": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2016-6759": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2016-6760": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2016-6761": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2016-6762": {"epss_score": 0.00204, "epss_percentile": 0.42632}, "CVE-2016-6763": {"epss_score": 0.00049, "epss_percentile": 0.15458}, "CVE-2016-6764": {"epss_score": 0.00145, "epss_percentile": 0.35422}, "CVE-2016-6765": {"epss_score": 0.00145, "epss_percentile": 0.35422}, "CVE-2016-6766": {"epss_score": 0.00145, "epss_percentile": 0.35422}, "CVE-2016-6767": {"epss_score": 0.00145, "epss_percentile": 0.35422}, "CVE-2016-6768": {"epss_score": 0.00243, "epss_percentile": 0.47453}, "CVE-2016-6769": {"epss_score": 0.00021, "epss_percentile": 0.04779}, "CVE-2016-6770": {"epss_score": 0.00043, "epss_percentile": 0.13292}, "CVE-2016-6771": {"epss_score": 0.00041, "epss_percentile": 0.12387}, "CVE-2016-6772": {"epss_score": 0.01435, "epss_percentile": 0.80271}, "CVE-2016-6773": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2016-6774": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-6775": {"epss_score": 0.00147, "epss_percentile": 0.35756}, "CVE-2016-6776": {"epss_score": 0.00147, "epss_percentile": 0.35756}, "CVE-2016-6777": {"epss_score": 0.00147, "epss_percentile": 0.35756}, "CVE-2016-6778": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2016-6779": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2016-6780": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2016-6781": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2016-6782": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2016-6783": {"epss_score": 0.00043, "epss_percentile": 0.13208}, "CVE-2016-6784": {"epss_score": 0.00035, "epss_percentile": 0.10149}, "CVE-2016-6785": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2016-6786": {"epss_score": 0.00086, "epss_percentile": 0.25414}, "CVE-2016-6787": {"epss_score": 0.00086, "epss_percentile": 0.25414}, "CVE-2016-6788": {"epss_score": 0.00049, "epss_percentile": 0.15464}, "CVE-2016-6789": {"epss_score": 0.00147, "epss_percentile": 0.35756}, "CVE-2016-6790": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2016-6791": {"epss_score": 0.00185, "epss_percentile": 0.40504}, "CVE-2016-6793": {"epss_score": 0.04849, "epss_percentile": 0.89212}, "CVE-2016-6794": {"epss_score": 0.00361, "epss_percentile": 0.57707}, "CVE-2016-6795": {"epss_score": 0.12481, "epss_percentile": 0.93686}, "CVE-2016-6796": {"epss_score": 0.00745, "epss_percentile": 0.72523}, "CVE-2016-6797": {"epss_score": 0.00557, "epss_percentile": 0.67542}, "CVE-2016-6798": {"epss_score": 0.01343, "epss_percentile": 0.79602}, "CVE-2016-6799": {"epss_score": 0.00464, "epss_percentile": 0.63708}, "CVE-2016-6800": {"epss_score": 0.02723, "epss_percentile": 0.85521}, "CVE-2016-6801": {"epss_score": 0.0036, "epss_percentile": 0.5763}, "CVE-2016-6802": {"epss_score": 0.09907, "epss_percentile": 0.92766}, "CVE-2016-6803": {"epss_score": 0.00118, "epss_percentile": 0.31482}, "CVE-2016-6804": {"epss_score": 0.00276, "epss_percentile": 0.50752}, "CVE-2016-6805": {"epss_score": 0.00926, "epss_percentile": 0.75557}, "CVE-2016-6806": {"epss_score": 0.00166, "epss_percentile": 0.38148}, "CVE-2016-6807": {"epss_score": 0.00841, "epss_percentile": 0.74218}, "CVE-2016-6808": {"epss_score": 0.34234, "epss_percentile": 0.96835}, "CVE-2016-6809": {"epss_score": 0.07049, "epss_percentile": 0.91212}, "CVE-2016-6810": {"epss_score": 0.01791, "epss_percentile": 0.82282}, "CVE-2016-6811": {"epss_score": 0.00538, "epss_percentile": 0.66927}, "CVE-2016-6812": {"epss_score": 0.06747, "epss_percentile": 0.90999}, "CVE-2016-6813": {"epss_score": 0.0153, "epss_percentile": 0.80886}, "CVE-2016-6814": {"epss_score": 0.25712, "epss_percentile": 0.96058}, "CVE-2016-6815": {"epss_score": 0.00489, "epss_percentile": 0.64902}, "CVE-2016-6816": {"epss_score": 0.01747, "epss_percentile": 0.82078}, "CVE-2016-6817": {"epss_score": 0.00496, "epss_percentile": 0.6517}, "CVE-2016-6818": {"epss_score": 0.01509, "epss_percentile": 0.80766}, "CVE-2016-6820": {"epss_score": 0.00377, "epss_percentile": 0.58745}, "CVE-2016-6823": {"epss_score": 0.00915, "epss_percentile": 0.75409}, "CVE-2016-6824": {"epss_score": 0.00197, "epss_percentile": 0.41958}, "CVE-2016-6825": {"epss_score": 0.00786, "epss_percentile": 0.73293}, "CVE-2016-6826": {"epss_score": 0.00187, "epss_percentile": 0.40702}, "CVE-2016-6827": {"epss_score": 0.00112, "epss_percentile": 0.30416}, "CVE-2016-6828": {"epss_score": 0.00098, "epss_percentile": 0.2776}, "CVE-2016-6829": {"epss_score": 0.03197, "epss_percentile": 0.86614}, "CVE-2016-6830": {"epss_score": 0.00491, "epss_percentile": 0.64979}, "CVE-2016-6831": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2016-6832": {"epss_score": 0.00363, "epss_percentile": 0.57823}, "CVE-2016-6833": {"epss_score": 0.00111, "epss_percentile": 0.30278}, "CVE-2016-6834": {"epss_score": 0.00116, "epss_percentile": 0.31072}, "CVE-2016-6835": {"epss_score": 0.00106, "epss_percentile": 0.29509}, "CVE-2016-6836": {"epss_score": 0.00112, "epss_percentile": 0.30429}, "CVE-2016-6837": {"epss_score": 0.00944, "epss_percentile": 0.75784}, "CVE-2016-6838": {"epss_score": 0.0007, "epss_percentile": 0.21825}, "CVE-2016-6839": {"epss_score": 0.0011, "epss_percentile": 0.30211}, "CVE-2016-6840": {"epss_score": 0.0015, "epss_percentile": 0.36056}, "CVE-2016-6842": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2016-6843": {"epss_score": 0.002, "epss_percentile": 0.4223}, "CVE-2016-6844": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2016-6845": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2016-6846": {"epss_score": 0.00301, "epss_percentile": 0.53064}, "CVE-2016-6847": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2016-6848": {"epss_score": 0.001, "epss_percentile": 0.28518}, "CVE-2016-6850": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2016-6851": {"epss_score": 0.01374, "epss_percentile": 0.79822}, "CVE-2016-6852": {"epss_score": 0.0022, "epss_percentile": 0.44596}, "CVE-2016-6853": {"epss_score": 0.00768, "epss_percentile": 0.72975}, "CVE-2016-6854": {"epss_score": 0.00768, "epss_percentile": 0.72975}, "CVE-2016-6855": {"epss_score": 0.03015, "epss_percentile": 0.86211}, "CVE-2016-6856": {"epss_score": 0.00233, "epss_percentile": 0.45976}, "CVE-2016-6857": {"epss_score": 0.00152, "epss_percentile": 0.36374}, "CVE-2016-6858": {"epss_score": 0.00152, "epss_percentile": 0.36374}, "CVE-2016-6859": {"epss_score": 0.00128, "epss_percentile": 0.3307}, "CVE-2016-6866": {"epss_score": 0.00473, "epss_percentile": 0.64094}, "CVE-2016-6870": {"epss_score": 0.0097, "epss_percentile": 0.76107}, "CVE-2016-6871": {"epss_score": 0.00512, "epss_percentile": 0.65852}, "CVE-2016-6872": {"epss_score": 0.00571, "epss_percentile": 0.67988}, "CVE-2016-6873": {"epss_score": 0.00571, "epss_percentile": 0.67988}, "CVE-2016-6874": {"epss_score": 0.00571, "epss_percentile": 0.67988}, "CVE-2016-6875": {"epss_score": 0.00571, "epss_percentile": 0.67988}, "CVE-2016-6876": {"epss_score": 0.00749, "epss_percentile": 0.72607}, "CVE-2016-6877": {"epss_score": 0.00778, "epss_percentile": 0.73128}, "CVE-2016-6878": {"epss_score": 0.00397, "epss_percentile": 0.59986}, "CVE-2016-6879": {"epss_score": 0.00185, "epss_percentile": 0.40512}, "CVE-2016-6881": {"epss_score": 0.00435, "epss_percentile": 0.62372}, "CVE-2016-6882": {"epss_score": 0.00384, "epss_percentile": 0.5916}, "CVE-2016-6883": {"epss_score": 0.69485, "epss_percentile": 0.98588}, "CVE-2016-6884": {"epss_score": 0.00476, "epss_percentile": 0.64263}, "CVE-2016-6885": {"epss_score": 0.00721, "epss_percentile": 0.7197}, "CVE-2016-6886": {"epss_score": 0.00813, "epss_percentile": 0.7376}, "CVE-2016-6887": {"epss_score": 0.00297, "epss_percentile": 0.5277}, "CVE-2016-6888": {"epss_score": 0.00086, "epss_percentile": 0.25306}, "CVE-2016-6890": {"epss_score": 0.13636, "epss_percentile": 0.94018}, "CVE-2016-6891": {"epss_score": 0.02081, "epss_percentile": 0.83535}, "CVE-2016-6892": {"epss_score": 0.02081, "epss_percentile": 0.83535}, "CVE-2016-6893": {"epss_score": 0.00444, "epss_percentile": 0.62842}, "CVE-2016-6894": {"epss_score": 0.00272, "epss_percentile": 0.50395}, "CVE-2016-6896": {"epss_score": 0.37104, "epss_percentile": 0.97019}, "CVE-2016-6897": {"epss_score": 0.30259, "epss_percentile": 0.96522}, "CVE-2016-6898": {"epss_score": 0.00083, "epss_percentile": 0.24609}, "CVE-2016-6899": {"epss_score": 0.0007, "epss_percentile": 0.21825}, "CVE-2016-6900": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2016-6901": {"epss_score": 0.00233, "epss_percentile": 0.45978}, "CVE-2016-6902": {"epss_score": 0.02356, "epss_percentile": 0.84484}, "CVE-2016-6903": {"epss_score": 0.01868, "epss_percentile": 0.82623}, "CVE-2016-6904": {"epss_score": 0.00225, "epss_percentile": 0.45139}, "CVE-2016-6905": {"epss_score": 0.01086, "epss_percentile": 0.77425}, "CVE-2016-6906": {"epss_score": 0.00448, "epss_percentile": 0.62992}, "CVE-2016-6908": {"epss_score": 0.00175, "epss_percentile": 0.39366}, "CVE-2016-6909": {"epss_score": 0.7156, "epss_percentile": 0.98673}, "CVE-2016-6910": {"epss_score": 0.00088, "epss_percentile": 0.2573}, "CVE-2016-6911": {"epss_score": 0.0067, "epss_percentile": 0.70782}, "CVE-2016-6912": {"epss_score": 0.00883, "epss_percentile": 0.74902}, "CVE-2016-6913": {"epss_score": 0.00203, "epss_percentile": 0.42527}, "CVE-2016-6914": {"epss_score": 0.00556, "epss_percentile": 0.6753}, "CVE-2016-6915": {"epss_score": 0.00073, "epss_percentile": 0.22506}, "CVE-2016-6916": {"epss_score": 0.00054, "epss_percentile": 0.17253}, "CVE-2016-6917": {"epss_score": 0.00073, "epss_percentile": 0.22506}, "CVE-2016-6918": {"epss_score": 0.01101, "epss_percentile": 0.77574}, "CVE-2016-6920": {"epss_score": 0.01693, "epss_percentile": 0.81795}, "CVE-2016-6921": {"epss_score": 0.01963, "epss_percentile": 0.83071}, "CVE-2016-6922": {"epss_score": 0.03311, "epss_percentile": 0.86893}, "CVE-2016-6923": {"epss_score": 0.01963, "epss_percentile": 0.83071}, "CVE-2016-6924": {"epss_score": 0.03311, "epss_percentile": 0.86893}, "CVE-2016-6925": {"epss_score": 0.01963, "epss_percentile": 0.83071}, "CVE-2016-6926": {"epss_score": 0.01963, "epss_percentile": 0.83071}, "CVE-2016-6927": {"epss_score": 0.01963, "epss_percentile": 0.83071}, "CVE-2016-6929": {"epss_score": 0.01963, "epss_percentile": 0.83071}, "CVE-2016-6930": {"epss_score": 0.01963, "epss_percentile": 0.83071}, "CVE-2016-6931": {"epss_score": 0.01814, "epss_percentile": 0.82378}, "CVE-2016-6932": {"epss_score": 0.01963, "epss_percentile": 0.83071}, "CVE-2016-6933": {"epss_score": 0.01191, "epss_percentile": 0.78395}, "CVE-2016-6934": {"epss_score": 0.00902, "epss_percentile": 0.75183}, "CVE-2016-6935": {"epss_score": 0.00221, "epss_percentile": 0.44686}, "CVE-2016-6936": {"epss_score": 0.01502, "epss_percentile": 0.80724}, "CVE-2016-6937": {"epss_score": 0.01855, "epss_percentile": 0.8256}, "CVE-2016-6938": {"epss_score": 0.01937, "epss_percentile": 0.82964}, "CVE-2016-6939": {"epss_score": 0.04207, "epss_percentile": 0.88397}, "CVE-2016-6940": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6941": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6942": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6943": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6944": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6945": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6946": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6947": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6948": {"epss_score": 0.0252, "epss_percentile": 0.84998}, "CVE-2016-6949": {"epss_score": 0.0216, "epss_percentile": 0.83822}, "CVE-2016-6950": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6951": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6952": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6953": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6954": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6955": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6956": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6957": {"epss_score": 0.02267, "epss_percentile": 0.842}, "CVE-2016-6958": {"epss_score": 0.00585, "epss_percentile": 0.68405}, "CVE-2016-6959": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6960": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6961": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6962": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6963": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6964": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6965": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6966": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6967": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6968": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6969": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6970": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6971": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6972": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6973": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6974": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6975": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6976": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6977": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6978": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6979": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6980": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6981": {"epss_score": 0.02869, "epss_percentile": 0.85869}, "CVE-2016-6982": {"epss_score": 0.03502, "epss_percentile": 0.87249}, "CVE-2016-6983": {"epss_score": 0.03502, "epss_percentile": 0.87249}, "CVE-2016-6984": {"epss_score": 0.03502, "epss_percentile": 0.87249}, "CVE-2016-6985": {"epss_score": 0.03502, "epss_percentile": 0.87249}, "CVE-2016-6986": {"epss_score": 0.03502, "epss_percentile": 0.87249}, "CVE-2016-6987": {"epss_score": 0.02869, "epss_percentile": 0.85869}, "CVE-2016-6988": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6989": {"epss_score": 0.03502, "epss_percentile": 0.87249}, "CVE-2016-6990": {"epss_score": 0.03502, "epss_percentile": 0.87249}, "CVE-2016-6992": {"epss_score": 0.08794, "epss_percentile": 0.92257}, "CVE-2016-6993": {"epss_score": 0.01971, "epss_percentile": 0.83105}, "CVE-2016-6994": {"epss_score": 0.03749, "epss_percentile": 0.8767}, "CVE-2016-6995": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6996": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6997": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6998": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-6999": {"epss_score": 0.03935, "epss_percentile": 0.87981}, "CVE-2016-7000": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7001": {"epss_score": 0.0347, "epss_percentile": 0.87197}, "CVE-2016-7002": {"epss_score": 0.0347, "epss_percentile": 0.87197}, "CVE-2016-7003": {"epss_score": 0.0347, "epss_percentile": 0.87197}, "CVE-2016-7004": {"epss_score": 0.0347, "epss_percentile": 0.87197}, "CVE-2016-7005": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7006": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7007": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7008": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7009": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7010": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7011": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7012": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7013": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7014": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7015": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7016": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7017": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7018": {"epss_score": 0.02249, "epss_percentile": 0.84155}, "CVE-2016-7019": {"epss_score": 0.01933, "epss_percentile": 0.82951}, "CVE-2016-7020": {"epss_score": 0.03859, "epss_percentile": 0.87863}, "CVE-2016-7030": {"epss_score": 0.01175, "epss_percentile": 0.78264}, "CVE-2016-7031": {"epss_score": 0.00743, "epss_percentile": 0.72498}, "CVE-2016-7032": {"epss_score": 0.00047, "epss_percentile": 0.14856}, "CVE-2016-7033": {"epss_score": 0.00216, "epss_percentile": 0.44221}, "CVE-2016-7034": {"epss_score": 0.00093, "epss_percentile": 0.2673}, "CVE-2016-7035": {"epss_score": 0.00103, "epss_percentile": 0.28931}, "CVE-2016-7036": {"epss_score": 0.00417, "epss_percentile": 0.61232}, "CVE-2016-7037": {"epss_score": 0.0014, "epss_percentile": 0.34713}, "CVE-2016-7038": {"epss_score": 0.00243, "epss_percentile": 0.47425}, "CVE-2016-7039": {"epss_score": 0.0032, "epss_percentile": 0.54632}, "CVE-2016-7040": {"epss_score": 0.00641, "epss_percentile": 0.69995}, "CVE-2016-7041": {"epss_score": 0.00977, "epss_percentile": 0.76223}, "CVE-2016-7042": {"epss_score": 0.00097, "epss_percentile": 0.27483}, "CVE-2016-7043": {"epss_score": 0.00298, "epss_percentile": 0.52829}, "CVE-2016-7044": {"epss_score": 0.01975, "epss_percentile": 0.83117}, "CVE-2016-7045": {"epss_score": 0.01934, "epss_percentile": 0.82954}, "CVE-2016-7046": {"epss_score": 0.0406, "epss_percentile": 0.88189}, "CVE-2016-7047": {"epss_score": 0.00328, "epss_percentile": 0.55165}, "CVE-2016-7048": {"epss_score": 0.10931, "epss_percentile": 0.93162}, "CVE-2016-7050": {"epss_score": 0.00622, "epss_percentile": 0.69529}, "CVE-2016-7051": {"epss_score": 0.00543, "epss_percentile": 0.67101}, "CVE-2016-7052": {"epss_score": 0.13857, "epss_percentile": 0.94076}, "CVE-2016-7053": {"epss_score": 0.042, "epss_percentile": 0.88387}, "CVE-2016-7054": {"epss_score": 0.16505, "epss_percentile": 0.94681}, "CVE-2016-7055": {"epss_score": 0.06977, "epss_percentile": 0.91156}, "CVE-2016-7056": {"epss_score": 0.00334, "epss_percentile": 0.55737}, "CVE-2016-7060": {"epss_score": 0.0008, "epss_percentile": 0.24197}, "CVE-2016-7061": {"epss_score": 0.00591, "epss_percentile": 0.68579}, "CVE-2016-7062": {"epss_score": 0.00071, "epss_percentile": 0.22198}, "CVE-2016-7063": {"epss_score": 0.00588, "epss_percentile": 0.68493}, "CVE-2016-7064": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2016-7065": {"epss_score": 0.12098, "epss_percentile": 0.93565}, "CVE-2016-7066": {"epss_score": 0.00027, "epss_percentile": 0.07206}, "CVE-2016-7067": {"epss_score": 0.00204, "epss_percentile": 0.42588}, "CVE-2016-7068": {"epss_score": 0.00085, "epss_percentile": 0.25178}, "CVE-2016-7069": {"epss_score": 0.00016, "epss_percentile": 0.02957}, "CVE-2016-7070": {"epss_score": 0.00088, "epss_percentile": 0.25637}, "CVE-2016-7071": {"epss_score": 0.00496, "epss_percentile": 0.65156}, "CVE-2016-7072": {"epss_score": 0.00029, "epss_percentile": 0.07906}, "CVE-2016-7073": {"epss_score": 6e-05, "epss_percentile": 0.00321}, "CVE-2016-7074": {"epss_score": 4e-05, "epss_percentile": 0.00146}, "CVE-2016-7075": {"epss_score": 0.00289, "epss_percentile": 0.52029}, "CVE-2016-7076": {"epss_score": 0.00077, "epss_percentile": 0.23361}, "CVE-2016-7077": {"epss_score": 0.00251, "epss_percentile": 0.48261}, "CVE-2016-7078": {"epss_score": 0.00316, "epss_percentile": 0.54225}, "CVE-2016-7079": {"epss_score": 0.00108, "epss_percentile": 0.29797}, "CVE-2016-7080": {"epss_score": 0.00108, "epss_percentile": 0.29797}, "CVE-2016-7081": {"epss_score": 0.00188, "epss_percentile": 0.40811}, "CVE-2016-7082": {"epss_score": 0.00102, "epss_percentile": 0.28824}, "CVE-2016-7083": {"epss_score": 0.00346, "epss_percentile": 0.56629}, "CVE-2016-7084": {"epss_score": 0.00656, "epss_percentile": 0.70444}, "CVE-2016-7085": {"epss_score": 0.00145, "epss_percentile": 0.3542}, "CVE-2016-7086": {"epss_score": 0.00044, "epss_percentile": 0.13658}, "CVE-2016-7087": {"epss_score": 0.02949, "epss_percentile": 0.8605}, "CVE-2016-7089": {"epss_score": 0.00213, "epss_percentile": 0.43928}, "CVE-2016-7090": {"epss_score": 0.00671, "epss_percentile": 0.70808}, "CVE-2016-7091": {"epss_score": 0.00069, "epss_percentile": 0.21601}, "CVE-2016-7092": {"epss_score": 0.00074, "epss_percentile": 0.22843}, "CVE-2016-7093": {"epss_score": 0.00058, "epss_percentile": 0.18417}, "CVE-2016-7094": {"epss_score": 0.0007, "epss_percentile": 0.21745}, "CVE-2016-7095": {"epss_score": 0.01203, "epss_percentile": 0.78497}, "CVE-2016-7097": {"epss_score": 0.00053, "epss_percentile": 0.16845}, "CVE-2016-7098": {"epss_score": 0.08815, "epss_percentile": 0.92268}, "CVE-2016-7099": {"epss_score": 0.00718, "epss_percentile": 0.71922}, "CVE-2016-7101": {"epss_score": 0.00522, "epss_percentile": 0.66281}, "CVE-2016-7102": {"epss_score": 0.00168, "epss_percentile": 0.3845}, "CVE-2016-7103": {"epss_score": 0.01397, "epss_percentile": 0.79984}, "CVE-2016-7107": {"epss_score": 0.00101, "epss_percentile": 0.2867}, "CVE-2016-7108": {"epss_score": 0.00098, "epss_percentile": 0.27822}, "CVE-2016-7109": {"epss_score": 0.01749, "epss_percentile": 0.82086}, "CVE-2016-7110": {"epss_score": 0.01749, "epss_percentile": 0.82086}, "CVE-2016-7111": {"epss_score": 0.0033, "epss_percentile": 0.55481}, "CVE-2016-7112": {"epss_score": 0.00717, "epss_percentile": 0.71878}, "CVE-2016-7113": {"epss_score": 0.00506, "epss_percentile": 0.65615}, "CVE-2016-7114": {"epss_score": 0.00591, "epss_percentile": 0.68584}, "CVE-2016-7115": {"epss_score": 0.01799, "epss_percentile": 0.82315}, "CVE-2016-7116": {"epss_score": 0.01038, "epss_percentile": 0.76937}, "CVE-2016-7117": {"epss_score": 0.04788, "epss_percentile": 0.89145}, "CVE-2016-7118": {"epss_score": 0.00052, "epss_percentile": 0.16376}, "CVE-2016-7119": {"epss_score": 0.00227, "epss_percentile": 0.45377}, "CVE-2016-7122": {"epss_score": 0.00186, "epss_percentile": 0.4069}, "CVE-2016-7123": {"epss_score": 0.00223, "epss_percentile": 0.44847}, "CVE-2016-7124": {"epss_score": 0.73386, "epss_percentile": 0.9875}, "CVE-2016-7125": {"epss_score": 0.00546, "epss_percentile": 0.67217}, "CVE-2016-7126": {"epss_score": 0.04632, "epss_percentile": 0.88946}, "CVE-2016-7127": {"epss_score": 0.01496, "epss_percentile": 0.80685}, "CVE-2016-7128": {"epss_score": 0.01468, "epss_percentile": 0.80477}, "CVE-2016-7129": {"epss_score": 0.02157, "epss_percentile": 0.83812}, "CVE-2016-7130": {"epss_score": 0.02558, "epss_percentile": 0.85099}, "CVE-2016-7131": {"epss_score": 0.06375, "epss_percentile": 0.90707}, "CVE-2016-7132": {"epss_score": 0.06375, "epss_percentile": 0.90707}, "CVE-2016-7133": {"epss_score": 0.00495, "epss_percentile": 0.65133}, "CVE-2016-7134": {"epss_score": 0.00519, "epss_percentile": 0.66167}, "CVE-2016-7135": {"epss_score": 0.007, "epss_percentile": 0.71483}, "CVE-2016-7136": {"epss_score": 0.00498, "epss_percentile": 0.65239}, "CVE-2016-7137": {"epss_score": 0.00477, "epss_percentile": 0.643}, "CVE-2016-7138": {"epss_score": 0.00491, "epss_percentile": 0.64971}, "CVE-2016-7139": {"epss_score": 0.00491, "epss_percentile": 0.64971}, "CVE-2016-7140": {"epss_score": 0.00491, "epss_percentile": 0.64971}, "CVE-2016-7141": {"epss_score": 0.00422, "epss_percentile": 0.61566}, "CVE-2016-7142": {"epss_score": 0.00138, "epss_percentile": 0.34401}, "CVE-2016-7143": {"epss_score": 0.01006, "epss_percentile": 0.76557}, "CVE-2016-7144": {"epss_score": 0.02386, "epss_percentile": 0.84579}, "CVE-2016-7145": {"epss_score": 0.00361, "epss_percentile": 0.57748}, "CVE-2016-7146": {"epss_score": 0.0025, "epss_percentile": 0.48244}, "CVE-2016-7147": {"epss_score": 0.00299, "epss_percentile": 0.52848}, "CVE-2016-7148": {"epss_score": 0.00235, "epss_percentile": 0.462}, "CVE-2016-7149": {"epss_score": 0.00611, "epss_percentile": 0.69205}, "CVE-2016-7150": {"epss_score": 0.00386, "epss_percentile": 0.59287}, "CVE-2016-7151": {"epss_score": 0.0031, "epss_percentile": 0.53745}, "CVE-2016-7152": {"epss_score": 0.02278, "epss_percentile": 0.84234}, "CVE-2016-7153": {"epss_score": 0.02278, "epss_percentile": 0.84234}, "CVE-2016-7154": {"epss_score": 0.00095, "epss_percentile": 0.2721}, "CVE-2016-7155": {"epss_score": 0.00111, "epss_percentile": 0.30278}, "CVE-2016-7156": {"epss_score": 0.00099, "epss_percentile": 0.27862}, "CVE-2016-7157": {"epss_score": 0.00111, "epss_percentile": 0.30278}, "CVE-2016-7160": {"epss_score": 0.00573, "epss_percentile": 0.68043}, "CVE-2016-7161": {"epss_score": 0.05178, "epss_percentile": 0.89576}, "CVE-2016-7162": {"epss_score": 0.01151, "epss_percentile": 0.78041}, "CVE-2016-7163": {"epss_score": 0.00337, "epss_percentile": 0.56046}, "CVE-2016-7164": {"epss_score": 0.00475, "epss_percentile": 0.64185}, "CVE-2016-7165": {"epss_score": 0.00098, "epss_percentile": 0.27662}, "CVE-2016-7166": {"epss_score": 0.00246, "epss_percentile": 0.4775}, "CVE-2016-7167": {"epss_score": 0.02289, "epss_percentile": 0.84275}, "CVE-2016-7168": {"epss_score": 0.00648, "epss_percentile": 0.70212}, "CVE-2016-7169": {"epss_score": 0.03015, "epss_percentile": 0.8621}, "CVE-2016-7170": {"epss_score": 0.00111, "epss_percentile": 0.30278}, "CVE-2016-7171": {"epss_score": 0.00177, "epss_percentile": 0.39586}, "CVE-2016-7172": {"epss_score": 0.00345, "epss_percentile": 0.56592}, "CVE-2016-7175": {"epss_score": 0.00189, "epss_percentile": 0.40931}, "CVE-2016-7176": {"epss_score": 0.00506, "epss_percentile": 0.65643}, "CVE-2016-7177": {"epss_score": 0.00558, "epss_percentile": 0.67596}, "CVE-2016-7178": {"epss_score": 0.00558, "epss_percentile": 0.67596}, "CVE-2016-7179": {"epss_score": 0.00678, "epss_percentile": 0.70988}, "CVE-2016-7180": {"epss_score": 0.00558, "epss_percentile": 0.67596}, "CVE-2016-7181": {"epss_score": 0.27286, "epss_percentile": 0.96231}, "CVE-2016-7182": {"epss_score": 0.34666, "epss_percentile": 0.96865}, "CVE-2016-7184": {"epss_score": 0.05377, "epss_percentile": 0.89803}, "CVE-2016-7185": {"epss_score": 0.01443, "epss_percentile": 0.80314}, "CVE-2016-7188": {"epss_score": 0.02542, "epss_percentile": 0.85053}, "CVE-2016-7189": {"epss_score": 0.78624, "epss_percentile": 0.98994}, "CVE-2016-7190": {"epss_score": 0.7613, "epss_percentile": 0.98879}, "CVE-2016-7191": {"epss_score": 0.10511, "epss_percentile": 0.93014}, "CVE-2016-7193": {"epss_score": 0.71199, "epss_percentile": 0.98658}, "CVE-2016-7194": {"epss_score": 0.77908, "epss_percentile": 0.98959}, "CVE-2016-7195": {"epss_score": 0.20455, "epss_percentile": 0.95347}, "CVE-2016-7196": {"epss_score": 0.30629, "epss_percentile": 0.96558}, "CVE-2016-7198": {"epss_score": 0.30629, "epss_percentile": 0.96558}, "CVE-2016-7199": {"epss_score": 0.16588, "epss_percentile": 0.94698}, "CVE-2016-7200": {"epss_score": 0.89039, "epss_percentile": 0.99507}, "CVE-2016-7201": {"epss_score": 0.90142, "epss_percentile": 0.99564}, "CVE-2016-7202": {"epss_score": 0.80224, "epss_percentile": 0.99077}, "CVE-2016-7203": {"epss_score": 0.77611, "epss_percentile": 0.98943}, "CVE-2016-7204": {"epss_score": 0.18602, "epss_percentile": 0.95041}, "CVE-2016-7205": {"epss_score": 0.17769, "epss_percentile": 0.94904}, "CVE-2016-7206": {"epss_score": 0.04339, "epss_percentile": 0.88567}, "CVE-2016-7208": {"epss_score": 0.15227, "epss_percentile": 0.94388}, "CVE-2016-7209": {"epss_score": 0.06822, "epss_percentile": 0.91048}, "CVE-2016-7210": {"epss_score": 0.35475, "epss_percentile": 0.96915}, "CVE-2016-7211": {"epss_score": 0.04632, "epss_percentile": 0.88946}, "CVE-2016-7212": {"epss_score": 0.40707, "epss_percentile": 0.97234}, "CVE-2016-7213": {"epss_score": 0.28979, "epss_percentile": 0.96407}, "CVE-2016-7214": {"epss_score": 0.01956, "epss_percentile": 0.83038}, "CVE-2016-7215": {"epss_score": 0.04894, "epss_percentile": 0.89268}, "CVE-2016-7216": {"epss_score": 0.02761, "epss_percentile": 0.856}, "CVE-2016-7217": {"epss_score": 0.17769, "epss_percentile": 0.94904}, "CVE-2016-7218": {"epss_score": 0.00635, "epss_percentile": 0.69829}, "CVE-2016-7219": {"epss_score": 0.01469, "epss_percentile": 0.80482}, "CVE-2016-7220": {"epss_score": 0.0146, "epss_percentile": 0.80418}, "CVE-2016-7221": {"epss_score": 0.01519, "epss_percentile": 0.80819}, "CVE-2016-7222": {"epss_score": 0.01092, "epss_percentile": 0.77467}, "CVE-2016-7223": {"epss_score": 0.00911, "epss_percentile": 0.75323}, "CVE-2016-7224": {"epss_score": 0.01093, "epss_percentile": 0.77481}, "CVE-2016-7225": {"epss_score": 0.01093, "epss_percentile": 0.77481}, "CVE-2016-7226": {"epss_score": 0.01093, "epss_percentile": 0.77481}, "CVE-2016-7227": {"epss_score": 0.16141, "epss_percentile": 0.94578}, "CVE-2016-7228": {"epss_score": 0.30017, "epss_percentile": 0.96497}, "CVE-2016-7229": {"epss_score": 0.28979, "epss_percentile": 0.96407}, "CVE-2016-7230": {"epss_score": 0.26904, "epss_percentile": 0.96191}, "CVE-2016-7231": {"epss_score": 0.30017, "epss_percentile": 0.96497}, "CVE-2016-7232": {"epss_score": 0.40637, "epss_percentile": 0.97229}, "CVE-2016-7233": {"epss_score": 0.14568, "epss_percentile": 0.94242}, "CVE-2016-7234": {"epss_score": 0.48354, "epss_percentile": 0.97632}, "CVE-2016-7235": {"epss_score": 0.30017, "epss_percentile": 0.96497}, "CVE-2016-7236": {"epss_score": 0.44055, "epss_percentile": 0.97417}, "CVE-2016-7237": {"epss_score": 0.4644, "epss_percentile": 0.97546}, "CVE-2016-7238": {"epss_score": 0.01463, "epss_percentile": 0.80441}, "CVE-2016-7239": {"epss_score": 0.1353, "epss_percentile": 0.93989}, "CVE-2016-7240": {"epss_score": 0.78678, "epss_percentile": 0.98998}, "CVE-2016-7241": {"epss_score": 0.7407, "epss_percentile": 0.98788}, "CVE-2016-7242": {"epss_score": 0.23313, "epss_percentile": 0.95763}, "CVE-2016-7243": {"epss_score": 0.17162, "epss_percentile": 0.94789}, "CVE-2016-7244": {"epss_score": 0.16652, "epss_percentile": 0.94708}, "CVE-2016-7245": {"epss_score": 0.30017, "epss_percentile": 0.96497}, "CVE-2016-7246": {"epss_score": 0.0375, "epss_percentile": 0.87672}, "CVE-2016-7247": {"epss_score": 0.24934, "epss_percentile": 0.95969}, "CVE-2016-7248": {"epss_score": 0.3156, "epss_percentile": 0.96627}, "CVE-2016-7249": {"epss_score": 0.16567, "epss_percentile": 0.94694}, "CVE-2016-7250": {"epss_score": 0.16567, "epss_percentile": 0.94694}, "CVE-2016-7251": {"epss_score": 0.07631, "epss_percentile": 0.91584}, "CVE-2016-7252": {"epss_score": 0.19685, "epss_percentile": 0.95225}, "CVE-2016-7253": {"epss_score": 0.18223, "epss_percentile": 0.94976}, "CVE-2016-7254": {"epss_score": 0.16567, "epss_percentile": 0.94694}, "CVE-2016-7255": {"epss_score": 0.89359, "epss_percentile": 0.99521}, "CVE-2016-7256": {"epss_score": 0.59042, "epss_percentile": 0.98147}, "CVE-2016-7257": {"epss_score": 0.14148, "epss_percentile": 0.94144}, "CVE-2016-7258": {"epss_score": 0.00708, "epss_percentile": 0.71664}, "CVE-2016-7259": {"epss_score": 0.026, "epss_percentile": 0.85206}, "CVE-2016-7260": {"epss_score": 0.00255, "epss_percentile": 0.48631}, "CVE-2016-7262": {"epss_score": 0.87086, "epss_percentile": 0.99414}, "CVE-2016-7263": {"epss_score": 0.1833, "epss_percentile": 0.94996}, "CVE-2016-7264": {"epss_score": 0.08545, "epss_percentile": 0.92115}, "CVE-2016-7265": {"epss_score": 0.1023, "epss_percentile": 0.92903}, "CVE-2016-7266": {"epss_score": 0.16365, "epss_percentile": 0.94636}, "CVE-2016-7267": {"epss_score": 0.23516, "epss_percentile": 0.95787}, "CVE-2016-7268": {"epss_score": 0.10903, "epss_percentile": 0.9315}, "CVE-2016-7270": {"epss_score": 0.37038, "epss_percentile": 0.97017}, "CVE-2016-7271": {"epss_score": 0.0012, "epss_percentile": 0.31688}, "CVE-2016-7272": {"epss_score": 0.48848, "epss_percentile": 0.97657}, "CVE-2016-7273": {"epss_score": 0.23064, "epss_percentile": 0.95727}, "CVE-2016-7274": {"epss_score": 0.3625, "epss_percentile": 0.96964}, "CVE-2016-7275": {"epss_score": 0.00683, "epss_percentile": 0.71101}, "CVE-2016-7276": {"epss_score": 0.08545, "epss_percentile": 0.92115}, "CVE-2016-7277": {"epss_score": 0.0477, "epss_percentile": 0.89125}, "CVE-2016-7278": {"epss_score": 0.20202, "epss_percentile": 0.95303}, "CVE-2016-7279": {"epss_score": 0.44774, "epss_percentile": 0.97452}, "CVE-2016-7280": {"epss_score": 0.08674, "epss_percentile": 0.92184}, "CVE-2016-7281": {"epss_score": 0.22473, "epss_percentile": 0.95639}, "CVE-2016-7282": {"epss_score": 0.05952, "epss_percentile": 0.90356}, "CVE-2016-7283": {"epss_score": 0.23023, "epss_percentile": 0.9572}, "CVE-2016-7284": {"epss_score": 0.24215, "epss_percentile": 0.95888}, "CVE-2016-7286": {"epss_score": 0.81693, "epss_percentile": 0.99151}, "CVE-2016-7287": {"epss_score": 0.81458, "epss_percentile": 0.99139}, "CVE-2016-7288": {"epss_score": 0.82725, "epss_percentile": 0.9921}, "CVE-2016-7289": {"epss_score": 0.33375, "epss_percentile": 0.96767}, "CVE-2016-7290": {"epss_score": 0.10903, "epss_percentile": 0.9315}, "CVE-2016-7291": {"epss_score": 0.10903, "epss_percentile": 0.9315}, "CVE-2016-7292": {"epss_score": 0.00849, "epss_percentile": 0.7438}, "CVE-2016-7295": {"epss_score": 0.00708, "epss_percentile": 0.71664}, "CVE-2016-7296": {"epss_score": 0.40727, "epss_percentile": 0.97236}, "CVE-2016-7297": {"epss_score": 0.40727, "epss_percentile": 0.97236}, "CVE-2016-7298": {"epss_score": 0.1833, "epss_percentile": 0.94996}, "CVE-2016-7300": {"epss_score": 0.00435, "epss_percentile": 0.62375}, "CVE-2016-7381": {"epss_score": 0.00056, "epss_percentile": 0.17695}, "CVE-2016-7382": {"epss_score": 0.00048, "epss_percentile": 0.15051}, "CVE-2016-7383": {"epss_score": 0.0006, "epss_percentile": 0.19182}, "CVE-2016-7384": {"epss_score": 0.00394, "epss_percentile": 0.59755}, "CVE-2016-7385": {"epss_score": 0.00394, "epss_percentile": 0.59755}, "CVE-2016-7386": {"epss_score": 0.00285, "epss_percentile": 0.51533}, "CVE-2016-7387": {"epss_score": 0.00394, "epss_percentile": 0.59755}, "CVE-2016-7388": {"epss_score": 0.00056, "epss_percentile": 0.17695}, "CVE-2016-7389": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2016-7390": {"epss_score": 0.00394, "epss_percentile": 0.59755}, "CVE-2016-7391": {"epss_score": 0.00379, "epss_percentile": 0.58893}, "CVE-2016-7392": {"epss_score": 0.0028, "epss_percentile": 0.51018}, "CVE-2016-7393": {"epss_score": 0.0028, "epss_percentile": 0.51018}, "CVE-2016-7394": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2016-7395": {"epss_score": 0.00629, "epss_percentile": 0.69676}, "CVE-2016-7397": {"epss_score": 0.00028, "epss_percentile": 0.07541}, "CVE-2016-7398": {"epss_score": 0.05723, "epss_percentile": 0.90153}, "CVE-2016-7399": {"epss_score": 0.13393, "epss_percentile": 0.93951}, "CVE-2016-7400": {"epss_score": 0.16527, "epss_percentile": 0.94686}, "CVE-2016-7401": {"epss_score": 0.05488, "epss_percentile": 0.89927}, "CVE-2016-7402": {"epss_score": 0.00248, "epss_percentile": 0.47998}, "CVE-2016-7404": {"epss_score": 0.02859, "epss_percentile": 0.85846}, "CVE-2016-7405": {"epss_score": 0.03101, "epss_percentile": 0.8641}, "CVE-2016-7406": {"epss_score": 0.20265, "epss_percentile": 0.9531}, "CVE-2016-7407": {"epss_score": 0.01128, "epss_percentile": 0.77828}, "CVE-2016-7408": {"epss_score": 0.02775, "epss_percentile": 0.85634}, "CVE-2016-7409": {"epss_score": 0.00217, "epss_percentile": 0.44321}, "CVE-2016-7410": {"epss_score": 0.00309, "epss_percentile": 0.53654}, "CVE-2016-7411": {"epss_score": 0.00868, "epss_percentile": 0.74673}, "CVE-2016-7412": {"epss_score": 0.01727, "epss_percentile": 0.81968}, "CVE-2016-7413": {"epss_score": 0.02322, "epss_percentile": 0.84372}, "CVE-2016-7414": {"epss_score": 0.02031, "epss_percentile": 0.83332}, "CVE-2016-7415": {"epss_score": 0.02161, "epss_percentile": 0.83826}, "CVE-2016-7416": {"epss_score": 0.02263, "epss_percentile": 0.8419}, "CVE-2016-7417": {"epss_score": 0.02517, "epss_percentile": 0.84989}, "CVE-2016-7418": {"epss_score": 0.02321, "epss_percentile": 0.84369}, "CVE-2016-7419": {"epss_score": 0.002, "epss_percentile": 0.42212}, "CVE-2016-7420": {"epss_score": 0.00681, "epss_percentile": 0.7105}, "CVE-2016-7421": {"epss_score": 0.00116, "epss_percentile": 0.31072}, "CVE-2016-7422": {"epss_score": 0.00098, "epss_percentile": 0.27726}, "CVE-2016-7423": {"epss_score": 0.00147, "epss_percentile": 0.35697}, "CVE-2016-7424": {"epss_score": 0.0024, "epss_percentile": 0.46952}, "CVE-2016-7425": {"epss_score": 0.00077, "epss_percentile": 0.23326}, "CVE-2016-7426": {"epss_score": 0.41876, "epss_percentile": 0.97298}, "CVE-2016-7427": {"epss_score": 0.05301, "epss_percentile": 0.89706}, "CVE-2016-7428": {"epss_score": 0.05301, "epss_percentile": 0.89706}, "CVE-2016-7429": {"epss_score": 0.24154, "epss_percentile": 0.9588}, "CVE-2016-7431": {"epss_score": 0.18621, "epss_percentile": 0.95044}, "CVE-2016-7433": {"epss_score": 0.29508, "epss_percentile": 0.96449}, "CVE-2016-7434": {"epss_score": 0.62378, "epss_percentile": 0.98289}, "CVE-2016-7435": {"epss_score": 0.01213, "epss_percentile": 0.78568}, "CVE-2016-7437": {"epss_score": 0.00054, "epss_percentile": 0.17199}, "CVE-2016-7438": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2016-7439": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2016-7440": {"epss_score": 0.0008, "epss_percentile": 0.24084}, "CVE-2016-7442": {"epss_score": 0.00028, "epss_percentile": 0.07541}, "CVE-2016-7443": {"epss_score": 0.00885, "epss_percentile": 0.74938}, "CVE-2016-7444": {"epss_score": 0.01021, "epss_percentile": 0.76747}, "CVE-2016-7445": {"epss_score": 0.02039, "epss_percentile": 0.83364}, "CVE-2016-7446": {"epss_score": 0.02021, "epss_percentile": 0.83297}, "CVE-2016-7447": {"epss_score": 0.02033, "epss_percentile": 0.83342}, "CVE-2016-7448": {"epss_score": 0.04162, "epss_percentile": 0.88336}, "CVE-2016-7449": {"epss_score": 0.03278, "epss_percentile": 0.86807}, "CVE-2016-7450": {"epss_score": 0.00221, "epss_percentile": 0.44697}, "CVE-2016-7452": {"epss_score": 0.01057, "epss_percentile": 0.77131}, "CVE-2016-7453": {"epss_score": 0.00532, "epss_percentile": 0.66678}, "CVE-2016-7454": {"epss_score": 0.01038, "epss_percentile": 0.76931}, "CVE-2016-7456": {"epss_score": 0.82117, "epss_percentile": 0.99175}, "CVE-2016-7457": {"epss_score": 0.01514, "epss_percentile": 0.80794}, "CVE-2016-7458": {"epss_score": 0.00449, "epss_percentile": 0.63047}, "CVE-2016-7459": {"epss_score": 0.00549, "epss_percentile": 0.67297}, "CVE-2016-7460": {"epss_score": 0.02008, "epss_percentile": 0.83242}, "CVE-2016-7461": {"epss_score": 0.00147, "epss_percentile": 0.35658}, "CVE-2016-7462": {"epss_score": 0.01674, "epss_percentile": 0.81699}, "CVE-2016-7463": {"epss_score": 0.00182, "epss_percentile": 0.4026}, "CVE-2016-7466": {"epss_score": 0.00098, "epss_percentile": 0.27726}, "CVE-2016-7467": {"epss_score": 0.01577, "epss_percentile": 0.81117}, "CVE-2016-7468": {"epss_score": 0.00917, "epss_percentile": 0.75431}, "CVE-2016-7469": {"epss_score": 0.00269, "epss_percentile": 0.50177}, "CVE-2016-7472": {"epss_score": 0.0912, "epss_percentile": 0.92408}, "CVE-2016-7474": {"epss_score": 0.00108, "epss_percentile": 0.29778}, "CVE-2016-7475": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2016-7476": {"epss_score": 0.01196, "epss_percentile": 0.78434}, "CVE-2016-7477": {"epss_score": 0.00237, "epss_percentile": 0.46646}, "CVE-2016-7478": {"epss_score": 0.18863, "epss_percentile": 0.95081}, "CVE-2016-7479": {"epss_score": 0.2518, "epss_percentile": 0.95995}, "CVE-2016-7480": {"epss_score": 0.03611, "epss_percentile": 0.87425}, "CVE-2016-7488": {"epss_score": 0.00065, "epss_percentile": 0.20545}, "CVE-2016-7489": {"epss_score": 0.00886, "epss_percentile": 0.74949}, "CVE-2016-7490": {"epss_score": 0.00041, "epss_percentile": 0.12462}, "CVE-2016-7498": {"epss_score": 0.02248, "epss_percentile": 0.84136}, "CVE-2016-7499": {"epss_score": 0.00543, "epss_percentile": 0.67093}, "CVE-2016-7502": {"epss_score": 0.00309, "epss_percentile": 0.53654}, "CVE-2016-7504": {"epss_score": 0.01068, "epss_percentile": 0.77235}, "CVE-2016-7505": {"epss_score": 0.00903, "epss_percentile": 0.752}, "CVE-2016-7506": {"epss_score": 0.00802, "epss_percentile": 0.73584}, "CVE-2016-7507": {"epss_score": 0.00207, "epss_percentile": 0.43158}, "CVE-2016-7508": {"epss_score": 0.00416, "epss_percentile": 0.61188}, "CVE-2016-7509": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2016-7510": {"epss_score": 0.00582, "epss_percentile": 0.68291}, "CVE-2016-7511": {"epss_score": 0.00402, "epss_percentile": 0.6027}, "CVE-2016-7513": {"epss_score": 0.00616, "epss_percentile": 0.69335}, "CVE-2016-7514": {"epss_score": 0.0143, "epss_percentile": 0.80233}, "CVE-2016-7515": {"epss_score": 0.01754, "epss_percentile": 0.82117}, "CVE-2016-7516": {"epss_score": 0.00914, "epss_percentile": 0.75391}, "CVE-2016-7517": {"epss_score": 0.00775, "epss_percentile": 0.73079}, "CVE-2016-7518": {"epss_score": 0.0058, "epss_percentile": 0.68255}, "CVE-2016-7519": {"epss_score": 0.00775, "epss_percentile": 0.73079}, "CVE-2016-7520": {"epss_score": 0.01787, "epss_percentile": 0.8226}, "CVE-2016-7521": {"epss_score": 0.01341, "epss_percentile": 0.79592}, "CVE-2016-7522": {"epss_score": 0.01489, "epss_percentile": 0.80625}, "CVE-2016-7523": {"epss_score": 0.0036, "epss_percentile": 0.57657}, "CVE-2016-7524": {"epss_score": 0.00975, "epss_percentile": 0.76196}, "CVE-2016-7525": {"epss_score": 0.01787, "epss_percentile": 0.8226}, "CVE-2016-7526": {"epss_score": 0.01647, "epss_percentile": 0.8154}, "CVE-2016-7527": {"epss_score": 0.00995, "epss_percentile": 0.7644}, "CVE-2016-7528": {"epss_score": 0.01489, "epss_percentile": 0.80625}, "CVE-2016-7529": {"epss_score": 0.0162, "epss_percentile": 0.81386}, "CVE-2016-7530": {"epss_score": 0.04207, "epss_percentile": 0.88397}, "CVE-2016-7531": {"epss_score": 0.01396, "epss_percentile": 0.7998}, "CVE-2016-7532": {"epss_score": 0.01489, "epss_percentile": 0.80625}, "CVE-2016-7533": {"epss_score": 0.01525, "epss_percentile": 0.80854}, "CVE-2016-7534": {"epss_score": 0.00358, "epss_percentile": 0.57488}, "CVE-2016-7535": {"epss_score": 0.00729, "epss_percentile": 0.72124}, "CVE-2016-7536": {"epss_score": 0.01414, "epss_percentile": 0.80124}, "CVE-2016-7537": {"epss_score": 0.01161, "epss_percentile": 0.78144}, "CVE-2016-7538": {"epss_score": 0.01489, "epss_percentile": 0.80625}, "CVE-2016-7539": {"epss_score": 0.02914, "epss_percentile": 0.85979}, "CVE-2016-7540": {"epss_score": 0.00995, "epss_percentile": 0.7644}, "CVE-2016-7541": {"epss_score": 0.00228, "epss_percentile": 0.45468}, "CVE-2016-7542": {"epss_score": 0.00319, "epss_percentile": 0.5447}, "CVE-2016-7543": {"epss_score": 0.00101, "epss_percentile": 0.28633}, "CVE-2016-7544": {"epss_score": 0.03271, "epss_percentile": 0.86792}, "CVE-2016-7545": {"epss_score": 0.00072, "epss_percentile": 0.22239}, "CVE-2016-7547": {"epss_score": 0.89354, "epss_percentile": 0.9952}, "CVE-2016-7549": {"epss_score": 0.00725, "epss_percentile": 0.7205}, "CVE-2016-7550": {"epss_score": 0.00122, "epss_percentile": 0.32085}, "CVE-2016-7551": {"epss_score": 0.0663, "epss_percentile": 0.90903}, "CVE-2016-7552": {"epss_score": 0.92979, "epss_percentile": 0.99765}, "CVE-2016-7553": {"epss_score": 0.00084, "epss_percentile": 0.24913}, "CVE-2016-7555": {"epss_score": 0.00332, "epss_percentile": 0.5558}, "CVE-2016-7560": {"epss_score": 0.02563, "epss_percentile": 0.85111}, "CVE-2016-7561": {"epss_score": 0.00312, "epss_percentile": 0.53997}, "CVE-2016-7562": {"epss_score": 0.00634, "epss_percentile": 0.69805}, "CVE-2016-7563": {"epss_score": 0.00316, "epss_percentile": 0.54281}, "CVE-2016-7564": {"epss_score": 0.00312, "epss_percentile": 0.53952}, "CVE-2016-7565": {"epss_score": 0.01513, "epss_percentile": 0.80786}, "CVE-2016-7567": {"epss_score": 0.10833, "epss_percentile": 0.93127}, "CVE-2016-7568": {"epss_score": 0.01023, "epss_percentile": 0.76772}, "CVE-2016-7569": {"epss_score": 0.01209, "epss_percentile": 0.78545}, "CVE-2016-7570": {"epss_score": 0.00345, "epss_percentile": 0.5659}, "CVE-2016-7571": {"epss_score": 0.0039, "epss_percentile": 0.59538}, "CVE-2016-7572": {"epss_score": 0.00252, "epss_percentile": 0.48408}, "CVE-2016-7576": {"epss_score": 0.00171, "epss_percentile": 0.38876}, "CVE-2016-7577": {"epss_score": 0.0026, "epss_percentile": 0.49235}, "CVE-2016-7578": {"epss_score": 0.01371, "epss_percentile": 0.7981}, "CVE-2016-7579": {"epss_score": 0.00682, "epss_percentile": 0.71073}, "CVE-2016-7580": {"epss_score": 0.00331, "epss_percentile": 0.555}, "CVE-2016-7581": {"epss_score": 0.00296, "epss_percentile": 0.5254}, "CVE-2016-7582": {"epss_score": 0.00522, "epss_percentile": 0.6626}, "CVE-2016-7583": {"epss_score": 0.00056, "epss_percentile": 0.17921}, "CVE-2016-7584": {"epss_score": 0.00289, "epss_percentile": 0.52004}, "CVE-2016-7585": {"epss_score": 0.00081, "epss_percentile": 0.24257}, "CVE-2016-7586": {"epss_score": 0.00569, "epss_percentile": 0.67928}, "CVE-2016-7587": {"epss_score": 0.00628, "epss_percentile": 0.6965}, "CVE-2016-7588": {"epss_score": 0.0087, "epss_percentile": 0.74702}, "CVE-2016-7589": {"epss_score": 0.0069, "epss_percentile": 0.71245}, "CVE-2016-7591": {"epss_score": 0.00251, "epss_percentile": 0.48275}, "CVE-2016-7592": {"epss_score": 0.00618, "epss_percentile": 0.6937}, "CVE-2016-7594": {"epss_score": 0.00892, "epss_percentile": 0.7506}, "CVE-2016-7595": {"epss_score": 0.0087, "epss_percentile": 0.74702}, "CVE-2016-7596": {"epss_score": 0.00499, "epss_percentile": 0.65253}, "CVE-2016-7597": {"epss_score": 0.00072, "epss_percentile": 0.22353}, "CVE-2016-7598": {"epss_score": 0.00569, "epss_percentile": 0.67928}, "CVE-2016-7599": {"epss_score": 0.00427, "epss_percentile": 0.61881}, "CVE-2016-7600": {"epss_score": 0.00138, "epss_percentile": 0.34529}, "CVE-2016-7601": {"epss_score": 0.0016, "epss_percentile": 0.37442}, "CVE-2016-7602": {"epss_score": 0.0017, "epss_percentile": 0.38754}, "CVE-2016-7603": {"epss_score": 0.00046, "epss_percentile": 0.14151}, "CVE-2016-7604": {"epss_score": 0.00046, "epss_percentile": 0.14151}, "CVE-2016-7605": {"epss_score": 0.00156, "epss_percentile": 0.3691}, "CVE-2016-7606": {"epss_score": 0.00161, "epss_percentile": 0.37568}, "CVE-2016-7607": {"epss_score": 0.00221, "epss_percentile": 0.44707}, "CVE-2016-7608": {"epss_score": 0.00787, "epss_percentile": 0.73302}, "CVE-2016-7609": {"epss_score": 0.00048, "epss_percentile": 0.15042}, "CVE-2016-7610": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7611": {"epss_score": 0.00861, "epss_percentile": 0.74559}, "CVE-2016-7612": {"epss_score": 0.01352, "epss_percentile": 0.79686}, "CVE-2016-7613": {"epss_score": 0.00147, "epss_percentile": 0.35665}, "CVE-2016-7614": {"epss_score": 0.00059, "epss_percentile": 0.18668}, "CVE-2016-7615": {"epss_score": 0.00049, "epss_percentile": 0.15483}, "CVE-2016-7616": {"epss_score": 0.00161, "epss_percentile": 0.37568}, "CVE-2016-7617": {"epss_score": 0.02663, "epss_percentile": 0.85372}, "CVE-2016-7618": {"epss_score": 0.00532, "epss_percentile": 0.66696}, "CVE-2016-7619": {"epss_score": 0.00087, "epss_percentile": 0.25634}, "CVE-2016-7620": {"epss_score": 0.00144, "epss_percentile": 0.35333}, "CVE-2016-7621": {"epss_score": 0.00158, "epss_percentile": 0.37234}, "CVE-2016-7622": {"epss_score": 0.00532, "epss_percentile": 0.66696}, "CVE-2016-7623": {"epss_score": 0.00411, "epss_percentile": 0.60897}, "CVE-2016-7624": {"epss_score": 0.00063, "epss_percentile": 0.19939}, "CVE-2016-7625": {"epss_score": 0.0006, "epss_percentile": 0.19013}, "CVE-2016-7626": {"epss_score": 0.04337, "epss_percentile": 0.88565}, "CVE-2016-7627": {"epss_score": 0.00498, "epss_percentile": 0.65246}, "CVE-2016-7628": {"epss_score": 0.00058, "epss_percentile": 0.18537}, "CVE-2016-7629": {"epss_score": 0.00225, "epss_percentile": 0.45128}, "CVE-2016-7630": {"epss_score": 0.00478, "epss_percentile": 0.64385}, "CVE-2016-7632": {"epss_score": 0.00756, "epss_percentile": 0.72731}, "CVE-2016-7633": {"epss_score": 0.00171, "epss_percentile": 0.38857}, "CVE-2016-7634": {"epss_score": 0.00069, "epss_percentile": 0.21557}, "CVE-2016-7635": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7636": {"epss_score": 0.00665, "epss_percentile": 0.70651}, "CVE-2016-7637": {"epss_score": 0.00175, "epss_percentile": 0.39333}, "CVE-2016-7638": {"epss_score": 0.00286, "epss_percentile": 0.51691}, "CVE-2016-7639": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7640": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7641": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7642": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7643": {"epss_score": 0.00497, "epss_percentile": 0.65194}, "CVE-2016-7644": {"epss_score": 0.0359, "epss_percentile": 0.87399}, "CVE-2016-7645": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7646": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7648": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7649": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7650": {"epss_score": 0.00248, "epss_percentile": 0.4795}, "CVE-2016-7651": {"epss_score": 0.00061, "epss_percentile": 0.19313}, "CVE-2016-7652": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7653": {"epss_score": 0.00074, "epss_percentile": 0.22719}, "CVE-2016-7654": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7655": {"epss_score": 0.0017, "epss_percentile": 0.38741}, "CVE-2016-7656": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2016-7657": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2016-7658": {"epss_score": 0.0087, "epss_percentile": 0.74702}, "CVE-2016-7659": {"epss_score": 0.0087, "epss_percentile": 0.74702}, "CVE-2016-7660": {"epss_score": 0.00183, "epss_percentile": 0.40316}, "CVE-2016-7661": {"epss_score": 0.00186, "epss_percentile": 0.40695}, "CVE-2016-7662": {"epss_score": 0.00209, "epss_percentile": 0.43383}, "CVE-2016-7663": {"epss_score": 0.02878, "epss_percentile": 0.8589}, "CVE-2016-7664": {"epss_score": 0.00074, "epss_percentile": 0.22719}, "CVE-2016-7665": {"epss_score": 0.00241, "epss_percentile": 0.47236}, "CVE-2016-7666": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2016-7667": {"epss_score": 0.00628, "epss_percentile": 0.69647}, "CVE-2016-7714": {"epss_score": 0.00054, "epss_percentile": 0.17342}, "CVE-2016-7742": {"epss_score": 0.0051, "epss_percentile": 0.6581}, "CVE-2016-7759": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2016-7761": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2016-7762": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2016-7765": {"epss_score": 0.00125, "epss_percentile": 0.32555}, "CVE-2016-7777": {"epss_score": 0.00122, "epss_percentile": 0.32068}, "CVE-2016-7780": {"epss_score": 0.00581, "epss_percentile": 0.68268}, "CVE-2016-7781": {"epss_score": 0.00581, "epss_percentile": 0.68268}, "CVE-2016-7782": {"epss_score": 0.00488, "epss_percentile": 0.64862}, "CVE-2016-7783": {"epss_score": 0.00488, "epss_percentile": 0.64862}, "CVE-2016-7784": {"epss_score": 0.00582, "epss_percentile": 0.68313}, "CVE-2016-7785": {"epss_score": 0.00276, "epss_percentile": 0.50709}, "CVE-2016-7786": {"epss_score": 0.02458, "epss_percentile": 0.84814}, "CVE-2016-7787": {"epss_score": 0.0054, "epss_percentile": 0.67017}, "CVE-2016-7788": {"epss_score": 0.00581, "epss_percentile": 0.68268}, "CVE-2016-7789": {"epss_score": 0.00671, "epss_percentile": 0.70802}, "CVE-2016-7790": {"epss_score": 0.033, "epss_percentile": 0.86864}, "CVE-2016-7791": {"epss_score": 0.033, "epss_percentile": 0.86864}, "CVE-2016-7792": {"epss_score": 0.00671, "epss_percentile": 0.70808}, "CVE-2016-7793": {"epss_score": 0.02051, "epss_percentile": 0.83401}, "CVE-2016-7794": {"epss_score": 0.05574, "epss_percentile": 0.90011}, "CVE-2016-7795": {"epss_score": 0.0016, "epss_percentile": 0.37434}, "CVE-2016-7796": {"epss_score": 0.00385, "epss_percentile": 0.59228}, "CVE-2016-7797": {"epss_score": 0.02415, "epss_percentile": 0.84686}, "CVE-2016-7798": {"epss_score": 0.00597, "epss_percentile": 0.68741}, "CVE-2016-7799": {"epss_score": 0.01299, "epss_percentile": 0.79283}, "CVE-2016-7800": {"epss_score": 0.02194, "epss_percentile": 0.8395}, "CVE-2016-7801": {"epss_score": 0.00283, "epss_percentile": 0.51399}, "CVE-2016-7802": {"epss_score": 0.03534, "epss_percentile": 0.87309}, "CVE-2016-7803": {"epss_score": 0.01207, "epss_percentile": 0.78528}, "CVE-2016-7804": {"epss_score": 0.00636, "epss_percentile": 0.69864}, "CVE-2016-7805": {"epss_score": 0.00177, "epss_percentile": 0.39526}, "CVE-2016-7806": {"epss_score": 0.11023, "epss_percentile": 0.93193}, "CVE-2016-7807": {"epss_score": 0.00752, "epss_percentile": 0.72662}, "CVE-2016-7808": {"epss_score": 0.00324, "epss_percentile": 0.54941}, "CVE-2016-7809": {"epss_score": 0.00171, "epss_percentile": 0.38815}, "CVE-2016-7810": {"epss_score": 0.0047, "epss_percentile": 0.63964}, "CVE-2016-7811": {"epss_score": 0.00071, "epss_percentile": 0.22131}, "CVE-2016-7812": {"epss_score": 0.00418, "epss_percentile": 0.61347}, "CVE-2016-7813": {"epss_score": 0.00324, "epss_percentile": 0.54941}, "CVE-2016-7814": {"epss_score": 0.01476, "epss_percentile": 0.80534}, "CVE-2016-7815": {"epss_score": 0.00088, "epss_percentile": 0.25697}, "CVE-2016-7816": {"epss_score": 0.00129, "epss_percentile": 0.3312}, "CVE-2016-7817": {"epss_score": 0.00233, "epss_percentile": 0.45976}, "CVE-2016-7818": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2016-7819": {"epss_score": 0.00932, "epss_percentile": 0.75624}, "CVE-2016-7820": {"epss_score": 0.01225, "epss_percentile": 0.78686}, "CVE-2016-7821": {"epss_score": 0.00506, "epss_percentile": 0.65618}, "CVE-2016-7822": {"epss_score": 0.0014, "epss_percentile": 0.34681}, "CVE-2016-7823": {"epss_score": 0.00178, "epss_percentile": 0.39653}, "CVE-2016-7824": {"epss_score": 0.0051, "epss_percentile": 0.65759}, "CVE-2016-7825": {"epss_score": 0.0427, "epss_percentile": 0.88474}, "CVE-2016-7826": {"epss_score": 0.0427, "epss_percentile": 0.88474}, "CVE-2016-7830": {"epss_score": 0.00463, "epss_percentile": 0.63664}, "CVE-2016-7831": {"epss_score": 0.00217, "epss_percentile": 0.44331}, "CVE-2016-7832": {"epss_score": 0.00194, "epss_percentile": 0.41542}, "CVE-2016-7833": {"epss_score": 0.0093, "epss_percentile": 0.75603}, "CVE-2016-7834": {"epss_score": 0.39457, "epss_percentile": 0.97162}, "CVE-2016-7835": {"epss_score": 0.03157, "epss_percentile": 0.86518}, "CVE-2016-7836": {"epss_score": 0.35342, "epss_percentile": 0.96902}, "CVE-2016-7837": {"epss_score": 0.00381, "epss_percentile": 0.58977}, "CVE-2016-7838": {"epss_score": 0.00924, "epss_percentile": 0.75526}, "CVE-2016-7839": {"epss_score": 0.00233, "epss_percentile": 0.45976}, "CVE-2016-7840": {"epss_score": 0.00196, "epss_percentile": 0.41807}, "CVE-2016-7841": {"epss_score": 0.00233, "epss_percentile": 0.45976}, "CVE-2016-7842": {"epss_score": 0.0687, "epss_percentile": 0.91085}, "CVE-2016-7843": {"epss_score": 0.06623, "epss_percentile": 0.90897}, "CVE-2016-7844": {"epss_score": 0.00318, "epss_percentile": 0.54455}, "CVE-2016-7845": {"epss_score": 0.00455, "epss_percentile": 0.63304}, "CVE-2016-7851": {"epss_score": 0.05706, "epss_percentile": 0.90136}, "CVE-2016-7852": {"epss_score": 0.02155, "epss_percentile": 0.83803}, "CVE-2016-7853": {"epss_score": 0.03326, "epss_percentile": 0.86923}, "CVE-2016-7854": {"epss_score": 0.02155, "epss_percentile": 0.83803}, "CVE-2016-7855": {"epss_score": 0.46889, "epss_percentile": 0.9756}, "CVE-2016-7856": {"epss_score": 0.03787, "epss_percentile": 0.87726}, "CVE-2016-7857": {"epss_score": 0.08079, "epss_percentile": 0.91872}, "CVE-2016-7858": {"epss_score": 0.08079, "epss_percentile": 0.91872}, "CVE-2016-7859": {"epss_score": 0.08079, "epss_percentile": 0.91872}, "CVE-2016-7860": {"epss_score": 0.11156, "epss_percentile": 0.93248}, "CVE-2016-7861": {"epss_score": 0.11156, "epss_percentile": 0.93248}, "CVE-2016-7862": {"epss_score": 0.08079, "epss_percentile": 0.91872}, "CVE-2016-7863": {"epss_score": 0.08079, "epss_percentile": 0.91872}, "CVE-2016-7864": {"epss_score": 0.08079, "epss_percentile": 0.91872}, "CVE-2016-7865": {"epss_score": 0.11156, "epss_percentile": 0.93248}, "CVE-2016-7866": {"epss_score": 0.66805, "epss_percentile": 0.9848}, "CVE-2016-7867": {"epss_score": 0.01047, "epss_percentile": 0.77043}, "CVE-2016-7868": {"epss_score": 0.01047, "epss_percentile": 0.77043}, "CVE-2016-7869": {"epss_score": 0.01047, "epss_percentile": 0.77043}, "CVE-2016-7870": {"epss_score": 0.01047, "epss_percentile": 0.77043}, "CVE-2016-7871": {"epss_score": 0.02828, "epss_percentile": 0.85768}, "CVE-2016-7872": {"epss_score": 0.03792, "epss_percentile": 0.87731}, "CVE-2016-7873": {"epss_score": 0.05087, "epss_percentile": 0.8948}, "CVE-2016-7874": {"epss_score": 0.05087, "epss_percentile": 0.8948}, "CVE-2016-7875": {"epss_score": 0.02828, "epss_percentile": 0.85768}, "CVE-2016-7876": {"epss_score": 0.05087, "epss_percentile": 0.8948}, "CVE-2016-7877": {"epss_score": 0.05939, "epss_percentile": 0.90348}, "CVE-2016-7878": {"epss_score": 0.03792, "epss_percentile": 0.87731}, "CVE-2016-7879": {"epss_score": 0.03792, "epss_percentile": 0.87731}, "CVE-2016-7880": {"epss_score": 0.05939, "epss_percentile": 0.90348}, "CVE-2016-7881": {"epss_score": 0.05939, "epss_percentile": 0.90348}, "CVE-2016-7882": {"epss_score": 0.01252, "epss_percentile": 0.78906}, "CVE-2016-7883": {"epss_score": 0.01316, "epss_percentile": 0.79409}, "CVE-2016-7884": {"epss_score": 0.01316, "epss_percentile": 0.79409}, "CVE-2016-7885": {"epss_score": 0.0118, "epss_percentile": 0.78303}, "CVE-2016-7886": {"epss_score": 0.10455, "epss_percentile": 0.92991}, "CVE-2016-7887": {"epss_score": 0.08625, "epss_percentile": 0.9216}, "CVE-2016-7888": {"epss_score": 0.01832, "epss_percentile": 0.82453}, "CVE-2016-7889": {"epss_score": 0.02002, "epss_percentile": 0.83224}, "CVE-2016-7890": {"epss_score": 0.00476, "epss_percentile": 0.64295}, "CVE-2016-7891": {"epss_score": 0.00924, "epss_percentile": 0.75524}, "CVE-2016-7892": {"epss_score": 0.23263, "epss_percentile": 0.95758}, "CVE-2016-7902": {"epss_score": 0.02357, "epss_percentile": 0.84486}, "CVE-2016-7903": {"epss_score": 0.00276, "epss_percentile": 0.50756}, "CVE-2016-7904": {"epss_score": 0.00167, "epss_percentile": 0.3834}, "CVE-2016-7905": {"epss_score": 0.00538, "epss_percentile": 0.66934}, "CVE-2016-7906": {"epss_score": 0.00468, "epss_percentile": 0.6387}, "CVE-2016-7907": {"epss_score": 0.00112, "epss_percentile": 0.30478}, "CVE-2016-7908": {"epss_score": 0.00135, "epss_percentile": 0.33999}, "CVE-2016-7909": {"epss_score": 0.00143, "epss_percentile": 0.35105}, "CVE-2016-7910": {"epss_score": 0.00452, "epss_percentile": 0.63189}, "CVE-2016-7911": {"epss_score": 0.00203, "epss_percentile": 0.42498}, "CVE-2016-7912": {"epss_score": 0.00279, "epss_percentile": 0.50994}, "CVE-2016-7913": {"epss_score": 0.00791, "epss_percentile": 0.73382}, "CVE-2016-7914": {"epss_score": 0.00181, "epss_percentile": 0.40097}, "CVE-2016-7915": {"epss_score": 0.00288, "epss_percentile": 0.51869}, "CVE-2016-7916": {"epss_score": 0.00053, "epss_percentile": 0.16963}, "CVE-2016-7917": {"epss_score": 0.00162, "epss_percentile": 0.37628}, "CVE-2016-7919": {"epss_score": 0.00302, "epss_percentile": 0.53084}, "CVE-2016-7922": {"epss_score": 0.00925, "epss_percentile": 0.75538}, "CVE-2016-7923": {"epss_score": 0.00925, "epss_percentile": 0.75538}, "CVE-2016-7924": {"epss_score": 0.00925, "epss_percentile": 0.75538}, "CVE-2016-7925": {"epss_score": 0.00925, "epss_percentile": 0.75538}, "CVE-2016-7926": {"epss_score": 0.00925, "epss_percentile": 0.75538}, "CVE-2016-7927": {"epss_score": 0.00925, "epss_percentile": 0.75538}, "CVE-2016-7928": {"epss_score": 0.00925, "epss_percentile": 0.75538}, "CVE-2016-7929": {"epss_score": 0.00925, "epss_percentile": 0.75538}, "CVE-2016-7930": {"epss_score": 0.00925, "epss_percentile": 0.75538}, "CVE-2016-7931": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7932": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7933": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7934": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7935": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7936": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7937": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7938": {"epss_score": 0.00715, "epss_percentile": 0.71848}, "CVE-2016-7939": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7940": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7942": {"epss_score": 0.03155, "epss_percentile": 0.86514}, "CVE-2016-7943": {"epss_score": 0.04712, "epss_percentile": 0.89039}, "CVE-2016-7944": {"epss_score": 0.00601, "epss_percentile": 0.68843}, "CVE-2016-7945": {"epss_score": 0.01218, "epss_percentile": 0.78607}, "CVE-2016-7946": {"epss_score": 0.0108, "epss_percentile": 0.77366}, "CVE-2016-7947": {"epss_score": 0.03155, "epss_percentile": 0.86514}, "CVE-2016-7948": {"epss_score": 0.03155, "epss_percentile": 0.86514}, "CVE-2016-7949": {"epss_score": 0.04763, "epss_percentile": 0.8912}, "CVE-2016-7950": {"epss_score": 0.00747, "epss_percentile": 0.72568}, "CVE-2016-7951": {"epss_score": 0.00706, "epss_percentile": 0.7162}, "CVE-2016-7952": {"epss_score": 0.0086, "epss_percentile": 0.74537}, "CVE-2016-7953": {"epss_score": 0.00914, "epss_percentile": 0.75383}, "CVE-2016-7954": {"epss_score": 0.02776, "epss_percentile": 0.85637}, "CVE-2016-7955": {"epss_score": 0.08552, "epss_percentile": 0.92119}, "CVE-2016-7957": {"epss_score": 0.00333, "epss_percentile": 0.55629}, "CVE-2016-7958": {"epss_score": 0.00394, "epss_percentile": 0.59786}, "CVE-2016-7959": {"epss_score": 0.00063, "epss_percentile": 0.20073}, "CVE-2016-7960": {"epss_score": 0.00088, "epss_percentile": 0.2567}, "CVE-2016-7964": {"epss_score": 0.00559, "epss_percentile": 0.67603}, "CVE-2016-7965": {"epss_score": 0.00289, "epss_percentile": 0.5201}, "CVE-2016-7966": {"epss_score": 0.00391, "epss_percentile": 0.59569}, "CVE-2016-7967": {"epss_score": 0.00332, "epss_percentile": 0.55552}, "CVE-2016-7968": {"epss_score": 0.0024, "epss_percentile": 0.46941}, "CVE-2016-7969": {"epss_score": 0.05279, "epss_percentile": 0.89685}, "CVE-2016-7970": {"epss_score": 0.0124, "epss_percentile": 0.78804}, "CVE-2016-7972": {"epss_score": 0.02344, "epss_percentile": 0.84445}, "CVE-2016-7973": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7974": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7975": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7976": {"epss_score": 0.7492, "epss_percentile": 0.98823}, "CVE-2016-7977": {"epss_score": 0.00909, "epss_percentile": 0.75298}, "CVE-2016-7978": {"epss_score": 0.02976, "epss_percentile": 0.86106}, "CVE-2016-7979": {"epss_score": 0.01789, "epss_percentile": 0.82277}, "CVE-2016-7980": {"epss_score": 0.00554, "epss_percentile": 0.67451}, "CVE-2016-7981": {"epss_score": 0.37001, "epss_percentile": 0.97013}, "CVE-2016-7982": {"epss_score": 0.32657, "epss_percentile": 0.96715}, "CVE-2016-7983": {"epss_score": 0.00688, "epss_percentile": 0.7121}, "CVE-2016-7984": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7985": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7986": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7987": {"epss_score": 0.00844, "epss_percentile": 0.7428}, "CVE-2016-7988": {"epss_score": 0.00091, "epss_percentile": 0.26205}, "CVE-2016-7989": {"epss_score": 0.0012, "epss_percentile": 0.31742}, "CVE-2016-7990": {"epss_score": 0.01775, "epss_percentile": 0.82217}, "CVE-2016-7991": {"epss_score": 0.00077, "epss_percentile": 0.23442}, "CVE-2016-7992": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7993": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-7994": {"epss_score": 0.00157, "epss_percentile": 0.37115}, "CVE-2016-7995": {"epss_score": 0.00157, "epss_percentile": 0.37115}, "CVE-2016-7996": {"epss_score": 0.01164, "epss_percentile": 0.78164}, "CVE-2016-7997": {"epss_score": 0.01147, "epss_percentile": 0.78007}, "CVE-2016-7998": {"epss_score": 0.23155, "epss_percentile": 0.95745}, "CVE-2016-7999": {"epss_score": 0.00748, "epss_percentile": 0.72584}, "CVE-2016-8005": {"epss_score": 0.00219, "epss_percentile": 0.44515}, "CVE-2016-8006": {"epss_score": 0.00076, "epss_percentile": 0.23279}, "CVE-2016-8007": {"epss_score": 0.00145, "epss_percentile": 0.35425}, "CVE-2016-8008": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2016-8009": {"epss_score": 0.00064, "epss_percentile": 0.20363}, "CVE-2016-8010": {"epss_score": 0.00048, "epss_percentile": 0.15239}, "CVE-2016-8011": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2016-8012": {"epss_score": 0.00044, "epss_percentile": 0.13366}, "CVE-2016-8016": {"epss_score": 0.09829, "epss_percentile": 0.92722}, "CVE-2016-8017": {"epss_score": 0.14314, "epss_percentile": 0.94185}, "CVE-2016-8018": {"epss_score": 0.00434, "epss_percentile": 0.62289}, "CVE-2016-8019": {"epss_score": 0.01334, "epss_percentile": 0.79541}, "CVE-2016-8020": {"epss_score": 0.02922, "epss_percentile": 0.85993}, "CVE-2016-8021": {"epss_score": 0.02847, "epss_percentile": 0.85824}, "CVE-2016-8022": {"epss_score": 0.08579, "epss_percentile": 0.92131}, "CVE-2016-8023": {"epss_score": 0.11326, "epss_percentile": 0.93309}, "CVE-2016-8024": {"epss_score": 0.09215, "epss_percentile": 0.92452}, "CVE-2016-8025": {"epss_score": 0.0185, "epss_percentile": 0.82533}, "CVE-2016-8026": {"epss_score": 0.00073, "epss_percentile": 0.22541}, "CVE-2016-8027": {"epss_score": 0.16236, "epss_percentile": 0.94599}, "CVE-2016-8030": {"epss_score": 0.0036, "epss_percentile": 0.57685}, "CVE-2016-8031": {"epss_score": 0.00066, "epss_percentile": 0.20803}, "CVE-2016-8032": {"epss_score": 0.00052, "epss_percentile": 0.16574}, "CVE-2016-8100": {"epss_score": 0.00059, "epss_percentile": 0.18668}, "CVE-2016-8101": {"epss_score": 0.00043, "epss_percentile": 0.13339}, "CVE-2016-8102": {"epss_score": 0.00043, "epss_percentile": 0.12953}, "CVE-2016-8103": {"epss_score": 0.0004, "epss_percentile": 0.11993}, "CVE-2016-8104": {"epss_score": 0.00049, "epss_percentile": 0.1534}, "CVE-2016-8105": {"epss_score": 0.00084, "epss_percentile": 0.24975}, "CVE-2016-8106": {"epss_score": 0.02584, "epss_percentile": 0.85163}, "CVE-2016-8201": {"epss_score": 0.00142, "epss_percentile": 0.35012}, "CVE-2016-8202": {"epss_score": 0.01357, "epss_percentile": 0.79726}, "CVE-2016-8203": {"epss_score": 0.00465, "epss_percentile": 0.63751}, "CVE-2016-8204": {"epss_score": 0.71339, "epss_percentile": 0.98663}, "CVE-2016-8205": {"epss_score": 0.24061, "epss_percentile": 0.95852}, "CVE-2016-8206": {"epss_score": 0.10385, "epss_percentile": 0.92969}, "CVE-2016-8207": {"epss_score": 0.05091, "epss_percentile": 0.89482}, "CVE-2016-8209": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2016-8211": {"epss_score": 0.00783, "epss_percentile": 0.73217}, "CVE-2016-8212": {"epss_score": 0.01138, "epss_percentile": 0.77929}, "CVE-2016-8213": {"epss_score": 0.0025, "epss_percentile": 0.48112}, "CVE-2016-8214": {"epss_score": 0.0008, "epss_percentile": 0.24125}, "CVE-2016-8215": {"epss_score": 0.0028, "epss_percentile": 0.51006}, "CVE-2016-8216": {"epss_score": 0.00385, "epss_percentile": 0.59192}, "CVE-2016-8217": {"epss_score": 0.00276, "epss_percentile": 0.50725}, "CVE-2016-8218": {"epss_score": 0.00585, "epss_percentile": 0.68414}, "CVE-2016-8219": {"epss_score": 0.00232, "epss_percentile": 0.45928}, "CVE-2016-8220": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2016-8221": {"epss_score": 0.00057, "epss_percentile": 0.18075}, "CVE-2016-8222": {"epss_score": 0.00037, "epss_percentile": 0.10894}, "CVE-2016-8223": {"epss_score": 0.00034, "epss_percentile": 0.09558}, "CVE-2016-8224": {"epss_score": 0.00042, "epss_percentile": 0.12607}, "CVE-2016-8225": {"epss_score": 0.00058, "epss_percentile": 0.18276}, "CVE-2016-8226": {"epss_score": 0.00302, "epss_percentile": 0.53119}, "CVE-2016-8227": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2016-8228": {"epss_score": 0.00044, "epss_percentile": 0.13628}, "CVE-2016-8229": {"epss_score": 0.00159, "epss_percentile": 0.37328}, "CVE-2016-8230": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2016-8231": {"epss_score": 0.00105, "epss_percentile": 0.29335}, "CVE-2016-8232": {"epss_score": 0.00242, "epss_percentile": 0.47384}, "CVE-2016-8233": {"epss_score": 0.00398, "epss_percentile": 0.60077}, "CVE-2016-8235": {"epss_score": 0.00064, "epss_percentile": 0.20265}, "CVE-2016-8236": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2016-8237": {"epss_score": 0.01545, "epss_percentile": 0.80961}, "CVE-2016-8271": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2016-8272": {"epss_score": 0.00025, "epss_percentile": 0.06352}, "CVE-2016-8273": {"epss_score": 0.00015, "epss_percentile": 0.02509}, "CVE-2016-8274": {"epss_score": 0.00017, "epss_percentile": 0.03314}, "CVE-2016-8275": {"epss_score": 0.00233, "epss_percentile": 0.46024}, "CVE-2016-8276": {"epss_score": 0.02978, "epss_percentile": 0.8611}, "CVE-2016-8277": {"epss_score": 0.00233, "epss_percentile": 0.45978}, "CVE-2016-8278": {"epss_score": 0.0027, "epss_percentile": 0.50252}, "CVE-2016-8279": {"epss_score": 0.00052, "epss_percentile": 0.16611}, "CVE-2016-8280": {"epss_score": 0.01103, "epss_percentile": 0.77593}, "CVE-2016-8281": {"epss_score": 0.00475, "epss_percentile": 0.64172}, "CVE-2016-8282": {"epss_score": 0.00512, "epss_percentile": 0.65875}, "CVE-2016-8283": {"epss_score": 0.00684, "epss_percentile": 0.7112}, "CVE-2016-8284": {"epss_score": 0.00067, "epss_percentile": 0.2118}, "CVE-2016-8285": {"epss_score": 0.00344, "epss_percentile": 0.56489}, "CVE-2016-8286": {"epss_score": 0.00172, "epss_percentile": 0.38937}, "CVE-2016-8287": {"epss_score": 0.00274, "epss_percentile": 0.50528}, "CVE-2016-8288": {"epss_score": 0.00219, "epss_percentile": 0.44443}, "CVE-2016-8289": {"epss_score": 0.00075, "epss_percentile": 0.22989}, "CVE-2016-8290": {"epss_score": 0.00542, "epss_percentile": 0.67073}, "CVE-2016-8291": {"epss_score": 0.003, "epss_percentile": 0.52992}, "CVE-2016-8292": {"epss_score": 0.00182, "epss_percentile": 0.40193}, "CVE-2016-8293": {"epss_score": 0.003, "epss_percentile": 0.52992}, "CVE-2016-8294": {"epss_score": 0.00192, "epss_percentile": 0.41324}, "CVE-2016-8295": {"epss_score": 0.00192, "epss_percentile": 0.41324}, "CVE-2016-8296": {"epss_score": 0.00172, "epss_percentile": 0.38912}, "CVE-2016-8297": {"epss_score": 0.00393, "epss_percentile": 0.59717}, "CVE-2016-8298": {"epss_score": 0.00393, "epss_percentile": 0.59717}, "CVE-2016-8299": {"epss_score": 0.00293, "epss_percentile": 0.52347}, "CVE-2016-8300": {"epss_score": 0.00305, "epss_percentile": 0.53343}, "CVE-2016-8301": {"epss_score": 0.00642, "epss_percentile": 0.7003}, "CVE-2016-8302": {"epss_score": 0.00249, "epss_percentile": 0.48036}, "CVE-2016-8303": {"epss_score": 0.00501, "epss_percentile": 0.65362}, "CVE-2016-8304": {"epss_score": 0.00204, "epss_percentile": 0.42636}, "CVE-2016-8305": {"epss_score": 0.00079, "epss_percentile": 0.23895}, "CVE-2016-8306": {"epss_score": 0.00221, "epss_percentile": 0.44711}, "CVE-2016-8307": {"epss_score": 0.00716, "epss_percentile": 0.71869}, "CVE-2016-8308": {"epss_score": 0.00642, "epss_percentile": 0.7003}, "CVE-2016-8309": {"epss_score": 0.00217, "epss_percentile": 0.44292}, "CVE-2016-8310": {"epss_score": 0.00649, "epss_percentile": 0.70227}, "CVE-2016-8311": {"epss_score": 0.00305, "epss_percentile": 0.53343}, "CVE-2016-8312": {"epss_score": 0.00764, "epss_percentile": 0.72896}, "CVE-2016-8313": {"epss_score": 0.00263, "epss_percentile": 0.49504}, "CVE-2016-8314": {"epss_score": 0.00249, "epss_percentile": 0.48036}, "CVE-2016-8315": {"epss_score": 0.00393, "epss_percentile": 0.59717}, "CVE-2016-8316": {"epss_score": 0.00204, "epss_percentile": 0.42636}, "CVE-2016-8317": {"epss_score": 0.00267, "epss_percentile": 0.4999}, "CVE-2016-8318": {"epss_score": 0.00214, "epss_percentile": 0.44008}, "CVE-2016-8319": {"epss_score": 0.00512, "epss_percentile": 0.65875}, "CVE-2016-8320": {"epss_score": 0.00512, "epss_percentile": 0.65875}, "CVE-2016-8322": {"epss_score": 0.00249, "epss_percentile": 0.48036}, "CVE-2016-8323": {"epss_score": 0.00193, "epss_percentile": 0.4145}, "CVE-2016-8324": {"epss_score": 0.00716, "epss_percentile": 0.71869}, "CVE-2016-8325": {"epss_score": 0.01277, "epss_percentile": 0.79113}, "CVE-2016-8327": {"epss_score": 0.00484, "epss_percentile": 0.6464}, "CVE-2016-8328": {"epss_score": 0.00558, "epss_percentile": 0.67597}, "CVE-2016-8329": {"epss_score": 0.00501, "epss_percentile": 0.65362}, "CVE-2016-8330": {"epss_score": 0.00447, "epss_percentile": 0.62975}, "CVE-2016-8331": {"epss_score": 0.07325, "epss_percentile": 0.9141}, "CVE-2016-8332": {"epss_score": 0.01168, "epss_percentile": 0.78193}, "CVE-2016-8333": {"epss_score": 0.01064, "epss_percentile": 0.77194}, "CVE-2016-8334": {"epss_score": 0.13461, "epss_percentile": 0.93971}, "CVE-2016-8335": {"epss_score": 0.01064, "epss_percentile": 0.77194}, "CVE-2016-8339": {"epss_score": 0.02487, "epss_percentile": 0.84891}, "CVE-2016-8341": {"epss_score": 0.00281, "epss_percentile": 0.51149}, "CVE-2016-8343": {"epss_score": 0.10355, "epss_percentile": 0.92957}, "CVE-2016-8344": {"epss_score": 0.00943, "epss_percentile": 0.75769}, "CVE-2016-8346": {"epss_score": 0.00163, "epss_percentile": 0.37783}, "CVE-2016-8347": {"epss_score": 0.01279, "epss_percentile": 0.79134}, "CVE-2016-8348": {"epss_score": 0.00351, "epss_percentile": 0.57007}, "CVE-2016-8350": {"epss_score": 0.00153, "epss_percentile": 0.36538}, "CVE-2016-8352": {"epss_score": 0.03358, "epss_percentile": 0.86979}, "CVE-2016-8353": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2016-8354": {"epss_score": 0.00164, "epss_percentile": 0.3789}, "CVE-2016-8355": {"epss_score": 0.00393, "epss_percentile": 0.59742}, "CVE-2016-8356": {"epss_score": 0.00304, "epss_percentile": 0.53251}, "CVE-2016-8357": {"epss_score": 0.00202, "epss_percentile": 0.42461}, "CVE-2016-8358": {"epss_score": 0.00149, "epss_percentile": 0.35978}, "CVE-2016-8359": {"epss_score": 0.00477, "epss_percentile": 0.64343}, "CVE-2016-8360": {"epss_score": 0.00803, "epss_percentile": 0.73601}, "CVE-2016-8361": {"epss_score": 0.00382, "epss_percentile": 0.59076}, "CVE-2016-8362": {"epss_score": 0.00161, "epss_percentile": 0.37522}, "CVE-2016-8363": {"epss_score": 0.00285, "epss_percentile": 0.51527}, "CVE-2016-8364": {"epss_score": 0.00652, "epss_percentile": 0.70312}, "CVE-2016-8365": {"epss_score": 0.00108, "epss_percentile": 0.29875}, "CVE-2016-8366": {"epss_score": 0.11596, "epss_percentile": 0.93415}, "CVE-2016-8367": {"epss_score": 0.13711, "epss_percentile": 0.9404}, "CVE-2016-8368": {"epss_score": 0.00686, "epss_percentile": 0.71169}, "CVE-2016-8369": {"epss_score": 0.00123, "epss_percentile": 0.3233}, "CVE-2016-8370": {"epss_score": 0.00183, "epss_percentile": 0.40353}, "CVE-2016-8371": {"epss_score": 0.2434, "epss_percentile": 0.95907}, "CVE-2016-8372": {"epss_score": 0.00564, "epss_percentile": 0.67775}, "CVE-2016-8374": {"epss_score": 0.00416, "epss_percentile": 0.6118}, "CVE-2016-8375": {"epss_score": 0.0028, "epss_percentile": 0.51086}, "CVE-2016-8376": {"epss_score": 0.00251, "epss_percentile": 0.48271}, "CVE-2016-8377": {"epss_score": 0.08653, "epss_percentile": 0.92175}, "CVE-2016-8378": {"epss_score": 0.00499, "epss_percentile": 0.65253}, "CVE-2016-8379": {"epss_score": 0.00465, "epss_percentile": 0.63758}, "CVE-2016-8380": {"epss_score": 0.2434, "epss_percentile": 0.95907}, "CVE-2016-8382": {"epss_score": 0.0067, "epss_percentile": 0.7077}, "CVE-2016-8383": {"epss_score": 0.00354, "epss_percentile": 0.57246}, "CVE-2016-8384": {"epss_score": 0.00397, "epss_percentile": 0.59986}, "CVE-2016-8385": {"epss_score": 0.00333, "epss_percentile": 0.55646}, "CVE-2016-8386": {"epss_score": 0.00333, "epss_percentile": 0.55646}, "CVE-2016-8387": {"epss_score": 0.00281, "epss_percentile": 0.5114}, "CVE-2016-8388": {"epss_score": 0.00129, "epss_percentile": 0.3322}, "CVE-2016-8389": {"epss_score": 0.00174, "epss_percentile": 0.39212}, "CVE-2016-8390": {"epss_score": 0.00194, "epss_percentile": 0.41583}, "CVE-2016-8391": {"epss_score": 0.00185, "epss_percentile": 0.40504}, "CVE-2016-8392": {"epss_score": 0.00185, "epss_percentile": 0.40504}, "CVE-2016-8393": {"epss_score": 0.00166, "epss_percentile": 0.38252}, "CVE-2016-8394": {"epss_score": 0.00166, "epss_percentile": 0.38252}, "CVE-2016-8395": {"epss_score": 0.00167, "epss_percentile": 0.38368}, "CVE-2016-8396": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-8397": {"epss_score": 0.00223, "epss_percentile": 0.44863}, "CVE-2016-8398": {"epss_score": 0.00632, "epss_percentile": 0.69738}, "CVE-2016-8399": {"epss_score": 0.00257, "epss_percentile": 0.48864}, "CVE-2016-8400": {"epss_score": 0.00255, "epss_percentile": 0.48726}, "CVE-2016-8401": {"epss_score": 0.00146, "epss_percentile": 0.35577}, "CVE-2016-8402": {"epss_score": 0.00146, "epss_percentile": 0.35577}, "CVE-2016-8403": {"epss_score": 0.00146, "epss_percentile": 0.35577}, "CVE-2016-8404": {"epss_score": 0.00146, "epss_percentile": 0.35577}, "CVE-2016-8405": {"epss_score": 0.00341, "epss_percentile": 0.56316}, "CVE-2016-8406": {"epss_score": 0.00146, "epss_percentile": 0.35577}, "CVE-2016-8407": {"epss_score": 0.00146, "epss_percentile": 0.35577}, "CVE-2016-8408": {"epss_score": 0.00193, "epss_percentile": 0.41462}, "CVE-2016-8409": {"epss_score": 0.00193, "epss_percentile": 0.41462}, "CVE-2016-8410": {"epss_score": 0.00193, "epss_percentile": 0.41462}, "CVE-2016-8411": {"epss_score": 0.00114, "epss_percentile": 0.30855}, "CVE-2016-8412": {"epss_score": 0.00185, "epss_percentile": 0.40504}, "CVE-2016-8413": {"epss_score": 0.00283, "epss_percentile": 0.51388}, "CVE-2016-8414": {"epss_score": 0.00152, "epss_percentile": 0.3647}, "CVE-2016-8415": {"epss_score": 0.00185, "epss_percentile": 0.40504}, "CVE-2016-8416": {"epss_score": 0.00254, "epss_percentile": 0.48518}, "CVE-2016-8417": {"epss_score": 0.00224, "epss_percentile": 0.45051}, "CVE-2016-8418": {"epss_score": 0.05532, "epss_percentile": 0.89967}, "CVE-2016-8419": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2016-8420": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2016-8421": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2016-8422": {"epss_score": 0.0004, "epss_percentile": 0.12103}, "CVE-2016-8423": {"epss_score": 0.0004, "epss_percentile": 0.12103}, "CVE-2016-8424": {"epss_score": 0.00239, "epss_percentile": 0.46863}, "CVE-2016-8425": {"epss_score": 0.00239, "epss_percentile": 0.46863}, "CVE-2016-8426": {"epss_score": 0.00239, "epss_percentile": 0.46863}, "CVE-2016-8427": {"epss_score": 0.00239, "epss_percentile": 0.46863}, "CVE-2016-8428": {"epss_score": 0.00239, "epss_percentile": 0.46863}, "CVE-2016-8429": {"epss_score": 0.00239, "epss_percentile": 0.46863}, "CVE-2016-8430": {"epss_score": 0.00239, "epss_percentile": 0.46863}, "CVE-2016-8431": {"epss_score": 0.00228, "epss_percentile": 0.4554}, "CVE-2016-8432": {"epss_score": 0.00228, "epss_percentile": 0.4554}, "CVE-2016-8433": {"epss_score": 0.0004, "epss_percentile": 0.12103}, "CVE-2016-8434": {"epss_score": 0.00185, "epss_percentile": 0.40504}, "CVE-2016-8435": {"epss_score": 0.00185, "epss_percentile": 0.40504}, "CVE-2016-8436": {"epss_score": 0.00037, "epss_percentile": 0.10975}, "CVE-2016-8437": {"epss_score": 0.00551, "epss_percentile": 0.67357}, "CVE-2016-8438": {"epss_score": 0.00777, "epss_percentile": 0.73114}, "CVE-2016-8439": {"epss_score": 0.00594, "epss_percentile": 0.68671}, "CVE-2016-8440": {"epss_score": 0.00532, "epss_percentile": 0.66672}, "CVE-2016-8441": {"epss_score": 0.00054, "epss_percentile": 0.1715}, "CVE-2016-8442": {"epss_score": 0.00051, "epss_percentile": 0.16109}, "CVE-2016-8443": {"epss_score": 0.00044, "epss_percentile": 0.13385}, "CVE-2016-8444": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2016-8445": {"epss_score": 0.00049, "epss_percentile": 0.15464}, "CVE-2016-8446": {"epss_score": 0.0004, "epss_percentile": 0.12103}, "CVE-2016-8447": {"epss_score": 0.0004, "epss_percentile": 0.12103}, "CVE-2016-8448": {"epss_score": 0.00037, "epss_percentile": 0.10975}, "CVE-2016-8449": {"epss_score": 0.00239, "epss_percentile": 0.46863}, "CVE-2016-8450": {"epss_score": 0.00228, "epss_percentile": 0.4554}, "CVE-2016-8451": {"epss_score": 0.00175, "epss_percentile": 0.39345}, "CVE-2016-8452": {"epss_score": 0.00228, "epss_percentile": 0.4554}, "CVE-2016-8453": {"epss_score": 0.00106, "epss_percentile": 0.295}, "CVE-2016-8454": {"epss_score": 0.00228, "epss_percentile": 0.4554}, "CVE-2016-8455": {"epss_score": 0.00174, "epss_percentile": 0.39191}, "CVE-2016-8456": {"epss_score": 0.00174, "epss_percentile": 0.39191}, "CVE-2016-8457": {"epss_score": 0.00174, "epss_percentile": 0.39191}, "CVE-2016-8458": {"epss_score": 0.00174, "epss_percentile": 0.39191}, "CVE-2016-8459": {"epss_score": 0.00594, "epss_percentile": 0.68671}, "CVE-2016-8460": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2016-8461": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2016-8462": {"epss_score": 0.00061, "epss_percentile": 0.19308}, "CVE-2016-8463": {"epss_score": 0.00258, "epss_percentile": 0.48971}, "CVE-2016-8464": {"epss_score": 0.00206, "epss_percentile": 0.42772}, "CVE-2016-8465": {"epss_score": 0.00239, "epss_percentile": 0.46863}, "CVE-2016-8466": {"epss_score": 0.00228, "epss_percentile": 0.4554}, "CVE-2016-8467": {"epss_score": 0.00021, "epss_percentile": 0.04697}, "CVE-2016-8468": {"epss_score": 0.00228, "epss_percentile": 0.4554}, "CVE-2016-8469": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2016-8470": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-8471": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-8472": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2016-8473": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2016-8474": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2016-8475": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2016-8476": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2016-8477": {"epss_score": 0.00279, "epss_percentile": 0.50954}, "CVE-2016-8478": {"epss_score": 0.00254, "epss_percentile": 0.48518}, "CVE-2016-8479": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2016-8480": {"epss_score": 0.00129, "epss_percentile": 0.33092}, "CVE-2016-8481": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2016-8482": {"epss_score": 0.00064, "epss_percentile": 0.20265}, "CVE-2016-8483": {"epss_score": 0.00283, "epss_percentile": 0.51388}, "CVE-2016-8484": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2016-8485": {"epss_score": 0.00564, "epss_percentile": 0.67747}, "CVE-2016-8486": {"epss_score": 0.00564, "epss_percentile": 0.67747}, "CVE-2016-8487": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2016-8488": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2016-8491": {"epss_score": 0.00272, "epss_percentile": 0.50363}, "CVE-2016-8492": {"epss_score": 0.00379, "epss_percentile": 0.58878}, "CVE-2016-8493": {"epss_score": 0.0059, "epss_percentile": 0.68564}, "CVE-2016-8494": {"epss_score": 0.01068, "epss_percentile": 0.77235}, "CVE-2016-8495": {"epss_score": 0.00128, "epss_percentile": 0.33011}, "CVE-2016-8501": {"epss_score": 0.00149, "epss_percentile": 0.35953}, "CVE-2016-8502": {"epss_score": 0.00194, "epss_percentile": 0.41565}, "CVE-2016-8503": {"epss_score": 0.00194, "epss_percentile": 0.41565}, "CVE-2016-8504": {"epss_score": 0.00094, "epss_percentile": 0.27007}, "CVE-2016-8505": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2016-8506": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2016-8507": {"epss_score": 0.0041, "epss_percentile": 0.60828}, "CVE-2016-8508": {"epss_score": 0.00252, "epss_percentile": 0.48387}, "CVE-2016-8511": {"epss_score": 0.18398, "epss_percentile": 0.95011}, "CVE-2016-8512": {"epss_score": 0.07059, "epss_percentile": 0.91219}, "CVE-2016-8513": {"epss_score": 0.00164, "epss_percentile": 0.38003}, "CVE-2016-8514": {"epss_score": 0.00536, "epss_percentile": 0.66863}, "CVE-2016-8515": {"epss_score": 0.01521, "epss_percentile": 0.80829}, "CVE-2016-8516": {"epss_score": 0.05547, "epss_percentile": 0.89983}, "CVE-2016-8517": {"epss_score": 0.00539, "epss_percentile": 0.66959}, "CVE-2016-8518": {"epss_score": 0.05547, "epss_percentile": 0.89983}, "CVE-2016-8519": {"epss_score": 0.57598, "epss_percentile": 0.98074}, "CVE-2016-8520": {"epss_score": 0.00457, "epss_percentile": 0.6337}, "CVE-2016-8521": {"epss_score": 0.01169, "epss_percentile": 0.78204}, "CVE-2016-8522": {"epss_score": 0.00272, "epss_percentile": 0.50386}, "CVE-2016-8523": {"epss_score": 0.30312, "epss_percentile": 0.96527}, "CVE-2016-8525": {"epss_score": 0.06508, "epss_percentile": 0.90809}, "CVE-2016-8526": {"epss_score": 0.13178, "epss_percentile": 0.93894}, "CVE-2016-8527": {"epss_score": 0.59405, "epss_percentile": 0.98163}, "CVE-2016-8528": {"epss_score": 0.02297, "epss_percentile": 0.84298}, "CVE-2016-8529": {"epss_score": 0.01996, "epss_percentile": 0.83195}, "CVE-2016-8530": {"epss_score": 0.06195, "epss_percentile": 0.90556}, "CVE-2016-8531": {"epss_score": 0.00547, "epss_percentile": 0.67249}, "CVE-2016-8532": {"epss_score": 0.003, "epss_percentile": 0.52948}, "CVE-2016-8533": {"epss_score": 0.00499, "epss_percentile": 0.6527}, "CVE-2016-8534": {"epss_score": 0.00499, "epss_percentile": 0.6527}, "CVE-2016-8535": {"epss_score": 0.00242, "epss_percentile": 0.47355}, "CVE-2016-8561": {"epss_score": 0.00548, "epss_percentile": 0.67269}, "CVE-2016-8562": {"epss_score": 0.14581, "epss_percentile": 0.94245}, "CVE-2016-8563": {"epss_score": 0.01001, "epss_percentile": 0.765}, "CVE-2016-8564": {"epss_score": 0.0023, "epss_percentile": 0.45722}, "CVE-2016-8565": {"epss_score": 0.00972, "epss_percentile": 0.76131}, "CVE-2016-8566": {"epss_score": 0.00113, "epss_percentile": 0.30694}, "CVE-2016-8567": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2016-8568": {"epss_score": 0.00637, "epss_percentile": 0.69888}, "CVE-2016-8569": {"epss_score": 0.00735, "epss_percentile": 0.72289}, "CVE-2016-8574": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2016-8575": {"epss_score": 0.04378, "epss_percentile": 0.8862}, "CVE-2016-8576": {"epss_score": 0.00043, "epss_percentile": 0.13082}, "CVE-2016-8577": {"epss_score": 0.00116, "epss_percentile": 0.31072}, "CVE-2016-8578": {"epss_score": 0.00116, "epss_percentile": 0.31072}, "CVE-2016-8579": {"epss_score": 0.00071, "epss_percentile": 0.22223}, "CVE-2016-8580": {"epss_score": 0.12558, "epss_percentile": 0.93715}, "CVE-2016-8581": {"epss_score": 0.68151, "epss_percentile": 0.98532}, "CVE-2016-8582": {"epss_score": 0.80548, "epss_percentile": 0.99094}, "CVE-2016-8583": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2016-8584": {"epss_score": 0.04082, "epss_percentile": 0.88221}, "CVE-2016-8585": {"epss_score": 0.07254, "epss_percentile": 0.91353}, "CVE-2016-8586": {"epss_score": 0.03311, "epss_percentile": 0.86889}, "CVE-2016-8587": {"epss_score": 0.00526, "epss_percentile": 0.66396}, "CVE-2016-8588": {"epss_score": 0.00526, "epss_percentile": 0.66396}, "CVE-2016-8589": {"epss_score": 0.03311, "epss_percentile": 0.86889}, "CVE-2016-8590": {"epss_score": 0.03311, "epss_percentile": 0.86889}, "CVE-2016-8591": {"epss_score": 0.03311, "epss_percentile": 0.86889}, "CVE-2016-8592": {"epss_score": 0.03311, "epss_percentile": 0.86889}, "CVE-2016-8593": {"epss_score": 0.0458, "epss_percentile": 0.88875}, "CVE-2016-8595": {"epss_score": 0.00242, "epss_percentile": 0.47377}, "CVE-2016-8596": {"epss_score": 0.03362, "epss_percentile": 0.86993}, "CVE-2016-8597": {"epss_score": 0.03362, "epss_percentile": 0.86993}, "CVE-2016-8598": {"epss_score": 0.03362, "epss_percentile": 0.86993}, "CVE-2016-8600": {"epss_score": 0.00867, "epss_percentile": 0.74659}, "CVE-2016-8602": {"epss_score": 0.00974, "epss_percentile": 0.76168}, "CVE-2016-8605": {"epss_score": 0.00089, "epss_percentile": 0.25836}, "CVE-2016-8606": {"epss_score": 0.0034, "epss_percentile": 0.5624}, "CVE-2016-8608": {"epss_score": 0.00179, "epss_percentile": 0.39794}, "CVE-2016-8609": {"epss_score": 0.00157, "epss_percentile": 0.37088}, "CVE-2016-8610": {"epss_score": 0.7113, "epss_percentile": 0.98655}, "CVE-2016-8611": {"epss_score": 0.00535, "epss_percentile": 0.66838}, "CVE-2016-8612": {"epss_score": 0.01319, "epss_percentile": 0.7943}, "CVE-2016-8613": {"epss_score": 0.00737, "epss_percentile": 0.72332}, "CVE-2016-8614": {"epss_score": 0.00079, "epss_percentile": 0.239}, "CVE-2016-8615": {"epss_score": 0.01651, "epss_percentile": 0.81569}, "CVE-2016-8616": {"epss_score": 0.0294, "epss_percentile": 0.86033}, "CVE-2016-8617": {"epss_score": 0.00081, "epss_percentile": 0.24335}, "CVE-2016-8618": {"epss_score": 0.01659, "epss_percentile": 0.81615}, "CVE-2016-8619": {"epss_score": 0.02678, "epss_percentile": 0.85408}, "CVE-2016-8620": {"epss_score": 0.00546, "epss_percentile": 0.67225}, "CVE-2016-8621": {"epss_score": 0.02378, "epss_percentile": 0.84559}, "CVE-2016-8622": {"epss_score": 0.0172, "epss_percentile": 0.81931}, "CVE-2016-8623": {"epss_score": 0.00682, "epss_percentile": 0.71063}, "CVE-2016-8624": {"epss_score": 0.01223, "epss_percentile": 0.78662}, "CVE-2016-8625": {"epss_score": 0.01526, "epss_percentile": 0.80861}, "CVE-2016-8626": {"epss_score": 0.02873, "epss_percentile": 0.85879}, "CVE-2016-8627": {"epss_score": 0.00801, "epss_percentile": 0.73571}, "CVE-2016-8628": {"epss_score": 0.00445, "epss_percentile": 0.62878}, "CVE-2016-8629": {"epss_score": 0.00213, "epss_percentile": 0.43923}, "CVE-2016-8630": {"epss_score": 0.00031, "epss_percentile": 0.08337}, "CVE-2016-8631": {"epss_score": 0.00191, "epss_percentile": 0.41271}, "CVE-2016-8632": {"epss_score": 0.00101, "epss_percentile": 0.287}, "CVE-2016-8633": {"epss_score": 0.00927, "epss_percentile": 0.75569}, "CVE-2016-8634": {"epss_score": 0.00328, "epss_percentile": 0.55152}, "CVE-2016-8635": {"epss_score": 0.00443, "epss_percentile": 0.62764}, "CVE-2016-8636": {"epss_score": 0.00356, "epss_percentile": 0.5735}, "CVE-2016-8637": {"epss_score": 0.00073, "epss_percentile": 0.2263}, "CVE-2016-8638": {"epss_score": 0.07142, "epss_percentile": 0.91279}, "CVE-2016-8639": {"epss_score": 0.00582, "epss_percentile": 0.68306}, "CVE-2016-8640": {"epss_score": 0.00905, "epss_percentile": 0.75239}, "CVE-2016-8641": {"epss_score": 0.01124, "epss_percentile": 0.77799}, "CVE-2016-8642": {"epss_score": 0.00222, "epss_percentile": 0.44744}, "CVE-2016-8643": {"epss_score": 0.00189, "epss_percentile": 0.40936}, "CVE-2016-8644": {"epss_score": 0.00284, "epss_percentile": 0.51418}, "CVE-2016-8645": {"epss_score": 0.00033, "epss_percentile": 0.0913}, "CVE-2016-8646": {"epss_score": 0.00034, "epss_percentile": 0.09583}, "CVE-2016-8647": {"epss_score": 0.00171, "epss_percentile": 0.38767}, "CVE-2016-8648": {"epss_score": 0.00536, "epss_percentile": 0.6687}, "CVE-2016-8649": {"epss_score": 0.02154, "epss_percentile": 0.83796}, "CVE-2016-8650": {"epss_score": 0.00045, "epss_percentile": 0.13791}, "CVE-2016-8651": {"epss_score": 0.00238, "epss_percentile": 0.46785}, "CVE-2016-8652": {"epss_score": 0.16367, "epss_percentile": 0.94637}, "CVE-2016-8653": {"epss_score": 0.00345, "epss_percentile": 0.56546}, "CVE-2016-8654": {"epss_score": 0.00234, "epss_percentile": 0.46112}, "CVE-2016-8655": {"epss_score": 0.39457, "epss_percentile": 0.97161}, "CVE-2016-8656": {"epss_score": 0.00071, "epss_percentile": 0.22059}, "CVE-2016-8657": {"epss_score": 0.00057, "epss_percentile": 0.17997}, "CVE-2016-8658": {"epss_score": 0.00303, "epss_percentile": 0.53185}, "CVE-2016-8659": {"epss_score": 0.00064, "epss_percentile": 0.20192}, "CVE-2016-8660": {"epss_score": 0.00118, "epss_percentile": 0.3144}, "CVE-2016-8661": {"epss_score": 0.00052, "epss_percentile": 0.16342}, "CVE-2016-8666": {"epss_score": 0.0352, "epss_percentile": 0.87283}, "CVE-2016-8667": {"epss_score": 0.00075, "epss_percentile": 0.22928}, "CVE-2016-8668": {"epss_score": 0.00157, "epss_percentile": 0.37115}, "CVE-2016-8669": {"epss_score": 0.00094, "epss_percentile": 0.26803}, "CVE-2016-8670": {"epss_score": 0.01668, "epss_percentile": 0.81661}, "CVE-2016-8671": {"epss_score": 0.00373, "epss_percentile": 0.5847}, "CVE-2016-8672": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2016-8673": {"epss_score": 0.00136, "epss_percentile": 0.34111}, "CVE-2016-8674": {"epss_score": 0.00225, "epss_percentile": 0.45151}, "CVE-2016-8675": {"epss_score": 0.0024, "epss_percentile": 0.47224}, "CVE-2016-8676": {"epss_score": 0.00258, "epss_percentile": 0.48991}, "CVE-2016-8677": {"epss_score": 0.00651, "epss_percentile": 0.70285}, "CVE-2016-8678": {"epss_score": 0.00212, "epss_percentile": 0.43755}, "CVE-2016-8679": {"epss_score": 0.00754, "epss_percentile": 0.72709}, "CVE-2016-8680": {"epss_score": 0.00768, "epss_percentile": 0.72967}, "CVE-2016-8681": {"epss_score": 0.00862, "epss_percentile": 0.74579}, "CVE-2016-8682": {"epss_score": 0.01784, "epss_percentile": 0.82252}, "CVE-2016-8683": {"epss_score": 0.00292, "epss_percentile": 0.52241}, "CVE-2016-8684": {"epss_score": 0.01433, "epss_percentile": 0.80259}, "CVE-2016-8685": {"epss_score": 0.0024, "epss_percentile": 0.47224}, "CVE-2016-8686": {"epss_score": 0.00338, "epss_percentile": 0.56156}, "CVE-2016-8687": {"epss_score": 0.01379, "epss_percentile": 0.79852}, "CVE-2016-8688": {"epss_score": 0.00226, "epss_percentile": 0.45329}, "CVE-2016-8689": {"epss_score": 0.01118, "epss_percentile": 0.77748}, "CVE-2016-8690": {"epss_score": 0.00421, "epss_percentile": 0.61518}, "CVE-2016-8691": {"epss_score": 0.0047, "epss_percentile": 0.63989}, "CVE-2016-8692": {"epss_score": 0.0047, "epss_percentile": 0.63989}, "CVE-2016-8693": {"epss_score": 0.00614, "epss_percentile": 0.69272}, "CVE-2016-8694": {"epss_score": 0.00282, "epss_percentile": 0.51216}, "CVE-2016-8695": {"epss_score": 0.00282, "epss_percentile": 0.51216}, "CVE-2016-8696": {"epss_score": 0.0033, "epss_percentile": 0.55424}, "CVE-2016-8697": {"epss_score": 0.0024, "epss_percentile": 0.47224}, "CVE-2016-8698": {"epss_score": 0.00653, "epss_percentile": 0.70332}, "CVE-2016-8699": {"epss_score": 0.00559, "epss_percentile": 0.67609}, "CVE-2016-8700": {"epss_score": 0.00559, "epss_percentile": 0.67609}, "CVE-2016-8701": {"epss_score": 0.00559, "epss_percentile": 0.67609}, "CVE-2016-8702": {"epss_score": 0.00559, "epss_percentile": 0.67609}, "CVE-2016-8703": {"epss_score": 0.00559, "epss_percentile": 0.67609}, "CVE-2016-8704": {"epss_score": 0.40823, "epss_percentile": 0.97239}, "CVE-2016-8705": {"epss_score": 0.16221, "epss_percentile": 0.94597}, "CVE-2016-8706": {"epss_score": 0.68629, "epss_percentile": 0.98557}, "CVE-2016-8707": {"epss_score": 0.02137, "epss_percentile": 0.83733}, "CVE-2016-8709": {"epss_score": 0.00025, "epss_percentile": 0.06255}, "CVE-2016-8710": {"epss_score": 0.00416, "epss_percentile": 0.61167}, "CVE-2016-8711": {"epss_score": 0.0012, "epss_percentile": 0.31799}, "CVE-2016-8712": {"epss_score": 0.0038, "epss_percentile": 0.5893}, "CVE-2016-8713": {"epss_score": 0.00025, "epss_percentile": 0.06255}, "CVE-2016-8714": {"epss_score": 0.00816, "epss_percentile": 0.73801}, "CVE-2016-8715": {"epss_score": 0.00392, "epss_percentile": 0.59677}, "CVE-2016-8716": {"epss_score": 0.00178, "epss_percentile": 0.39727}, "CVE-2016-8717": {"epss_score": 0.00353, "epss_percentile": 0.57138}, "CVE-2016-8718": {"epss_score": 0.00159, "epss_percentile": 0.37341}, "CVE-2016-8719": {"epss_score": 0.00315, "epss_percentile": 0.54177}, "CVE-2016-8720": {"epss_score": 0.0118, "epss_percentile": 0.78302}, "CVE-2016-8721": {"epss_score": 0.01001, "epss_percentile": 0.76498}, "CVE-2016-8722": {"epss_score": 0.00368, "epss_percentile": 0.58196}, "CVE-2016-8723": {"epss_score": 0.00447, "epss_percentile": 0.62971}, "CVE-2016-8724": {"epss_score": 0.03205, "epss_percentile": 0.8663}, "CVE-2016-8725": {"epss_score": 0.00368, "epss_percentile": 0.58196}, "CVE-2016-8726": {"epss_score": 0.00447, "epss_percentile": 0.62971}, "CVE-2016-8727": {"epss_score": 0.00496, "epss_percentile": 0.65136}, "CVE-2016-8728": {"epss_score": 0.00586, "epss_percentile": 0.68438}, "CVE-2016-8729": {"epss_score": 0.00532, "epss_percentile": 0.66695}, "CVE-2016-8730": {"epss_score": 0.00199, "epss_percentile": 0.42098}, "CVE-2016-8731": {"epss_score": 0.00779, "epss_percentile": 0.7314}, "CVE-2016-8732": {"epss_score": 0.0003, "epss_percentile": 0.08168}, "CVE-2016-8733": {"epss_score": 0.00146, "epss_percentile": 0.35547}, "CVE-2016-8734": {"epss_score": 0.12879, "epss_percentile": 0.9381}, "CVE-2016-8735": {"epss_score": 0.93875, "epss_percentile": 0.99861}, "CVE-2016-8736": {"epss_score": 0.06146, "epss_percentile": 0.90518}, "CVE-2016-8737": {"epss_score": 0.00186, "epss_percentile": 0.40648}, "CVE-2016-8738": {"epss_score": 0.006, "epss_percentile": 0.68813}, "CVE-2016-8739": {"epss_score": 0.02672, "epss_percentile": 0.85394}, "CVE-2016-8740": {"epss_score": 0.68259, "epss_percentile": 0.98538}, "CVE-2016-8741": {"epss_score": 0.00492, "epss_percentile": 0.65003}, "CVE-2016-8742": {"epss_score": 0.00436, "epss_percentile": 0.62387}, "CVE-2016-8743": {"epss_score": 0.08406, "epss_percentile": 0.92034}, "CVE-2016-8744": {"epss_score": 0.00459, "epss_percentile": 0.6346}, "CVE-2016-8745": {"epss_score": 0.17099, "epss_percentile": 0.94774}, "CVE-2016-8746": {"epss_score": 0.00538, "epss_percentile": 0.66938}, "CVE-2016-8747": {"epss_score": 0.02332, "epss_percentile": 0.84407}, "CVE-2016-8748": {"epss_score": 0.00492, "epss_percentile": 0.65018}, "CVE-2016-8749": {"epss_score": 0.05584, "epss_percentile": 0.90022}, "CVE-2016-8750": {"epss_score": 0.0151, "epss_percentile": 0.8077}, "CVE-2016-8751": {"epss_score": 0.00177, "epss_percentile": 0.39517}, "CVE-2016-8752": {"epss_score": 0.0102, "epss_percentile": 0.76734}, "CVE-2016-8754": {"epss_score": 0.0008, "epss_percentile": 0.2409}, "CVE-2016-8756": {"epss_score": 0.00061, "epss_percentile": 0.19447}, "CVE-2016-8757": {"epss_score": 0.00078, "epss_percentile": 0.23677}, "CVE-2016-8758": {"epss_score": 0.00061, "epss_percentile": 0.19447}, "CVE-2016-8759": {"epss_score": 0.00058, "epss_percentile": 0.1852}, "CVE-2016-8760": {"epss_score": 0.00058, "epss_percentile": 0.1852}, "CVE-2016-8761": {"epss_score": 0.00058, "epss_percentile": 0.1852}, "CVE-2016-8762": {"epss_score": 0.00027, "epss_percentile": 0.06941}, "CVE-2016-8763": {"epss_score": 0.00056, "epss_percentile": 0.17791}, "CVE-2016-8764": {"epss_score": 0.00032, "epss_percentile": 0.09019}, "CVE-2016-8768": {"epss_score": 0.00054, "epss_percentile": 0.17192}, "CVE-2016-8769": {"epss_score": 0.0042, "epss_percentile": 0.61448}, "CVE-2016-8773": {"epss_score": 0.00211, "epss_percentile": 0.43635}, "CVE-2016-8774": {"epss_score": 0.00036, "epss_percentile": 0.10439}, "CVE-2016-8775": {"epss_score": 0.00036, "epss_percentile": 0.10439}, "CVE-2016-8776": {"epss_score": 0.0003, "epss_percentile": 0.08172}, "CVE-2016-8779": {"epss_score": 0.00098, "epss_percentile": 0.27822}, "CVE-2016-8780": {"epss_score": 0.00233, "epss_percentile": 0.45978}, "CVE-2016-8781": {"epss_score": 0.00276, "epss_percentile": 0.50771}, "CVE-2016-8782": {"epss_score": 0.00129, "epss_percentile": 0.33205}, "CVE-2016-8783": {"epss_score": 0.00058, "epss_percentile": 0.1852}, "CVE-2016-8784": {"epss_score": 0.00071, "epss_percentile": 0.22204}, "CVE-2016-8785": {"epss_score": 0.00103, "epss_percentile": 0.28986}, "CVE-2016-8786": {"epss_score": 0.00221, "epss_percentile": 0.4467}, "CVE-2016-8789": {"epss_score": 0.00109, "epss_percentile": 0.29992}, "CVE-2016-8790": {"epss_score": 0.00042, "epss_percentile": 0.12662}, "CVE-2016-8791": {"epss_score": 0.00036, "epss_percentile": 0.10338}, "CVE-2016-8792": {"epss_score": 0.00036, "epss_percentile": 0.10338}, "CVE-2016-8793": {"epss_score": 0.00019, "epss_percentile": 0.04098}, "CVE-2016-8794": {"epss_score": 0.00036, "epss_percentile": 0.10338}, "CVE-2016-8795": {"epss_score": 0.00241, "epss_percentile": 0.4732}, "CVE-2016-8796": {"epss_score": 0.00195, "epss_percentile": 0.41626}, "CVE-2016-8797": {"epss_score": 0.00277, "epss_percentile": 0.50809}, "CVE-2016-8798": {"epss_score": 0.00141, "epss_percentile": 0.34927}, "CVE-2016-8801": {"epss_score": 0.00227, "epss_percentile": 0.45364}, "CVE-2016-8802": {"epss_score": 0.00208, "epss_percentile": 0.43303}, "CVE-2016-8803": {"epss_score": 0.00031, "epss_percentile": 0.08684}, "CVE-2016-8805": {"epss_score": 0.00394, "epss_percentile": 0.59755}, "CVE-2016-8806": {"epss_score": 0.00379, "epss_percentile": 0.58893}, "CVE-2016-8807": {"epss_score": 0.00379, "epss_percentile": 0.58893}, "CVE-2016-8808": {"epss_score": 0.00394, "epss_percentile": 0.59755}, "CVE-2016-8809": {"epss_score": 0.00263, "epss_percentile": 0.49544}, "CVE-2016-8810": {"epss_score": 0.00394, "epss_percentile": 0.59755}, "CVE-2016-8811": {"epss_score": 0.00394, "epss_percentile": 0.59755}, "CVE-2016-8812": {"epss_score": 0.00376, "epss_percentile": 0.58661}, "CVE-2016-8813": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2016-8814": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2016-8815": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2016-8816": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2016-8817": {"epss_score": 0.00041, "epss_percentile": 0.12312}, "CVE-2016-8818": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2016-8819": {"epss_score": 0.00043, "epss_percentile": 0.1317}, "CVE-2016-8820": {"epss_score": 0.00047, "epss_percentile": 0.14661}, "CVE-2016-8821": {"epss_score": 0.00044, "epss_percentile": 0.13385}, "CVE-2016-8822": {"epss_score": 0.00048, "epss_percentile": 0.14952}, "CVE-2016-8823": {"epss_score": 0.00107, "epss_percentile": 0.29686}, "CVE-2016-8824": {"epss_score": 0.00044, "epss_percentile": 0.13385}, "CVE-2016-8825": {"epss_score": 0.00048, "epss_percentile": 0.14952}, "CVE-2016-8826": {"epss_score": 0.00052, "epss_percentile": 0.16554}, "CVE-2016-8827": {"epss_score": 0.05952, "epss_percentile": 0.90357}, "CVE-2016-8855": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2016-8856": {"epss_score": 7e-05, "epss_percentile": 0.00415}, "CVE-2016-8858": {"epss_score": 0.27135, "epss_percentile": 0.9621}, "CVE-2016-8859": {"epss_score": 0.00766, "epss_percentile": 0.72945}, "CVE-2016-8860": {"epss_score": 0.02682, "epss_percentile": 0.85417}, "CVE-2016-8862": {"epss_score": 0.00813, "epss_percentile": 0.73766}, "CVE-2016-8863": {"epss_score": 0.24433, "epss_percentile": 0.95921}, "CVE-2016-8864": {"epss_score": 0.45373, "epss_percentile": 0.97484}, "CVE-2016-8866": {"epss_score": 0.00678, "epss_percentile": 0.70988}, "CVE-2016-8867": {"epss_score": 0.00367, "epss_percentile": 0.5814}, "CVE-2016-8869": {"epss_score": 0.93416, "epss_percentile": 0.99805}, "CVE-2016-8870": {"epss_score": 0.91921, "epss_percentile": 0.99678}, "CVE-2016-8871": {"epss_score": 0.00136, "epss_percentile": 0.34125}, "CVE-2016-8875": {"epss_score": 0.00088, "epss_percentile": 0.25717}, "CVE-2016-8876": {"epss_score": 0.00361, "epss_percentile": 0.57718}, "CVE-2016-8877": {"epss_score": 0.00534, "epss_percentile": 0.66801}, "CVE-2016-8878": {"epss_score": 0.00361, "epss_percentile": 0.57718}, "CVE-2016-8879": {"epss_score": 0.00088, "epss_percentile": 0.25717}, "CVE-2016-8882": {"epss_score": 0.00236, "epss_percentile": 0.46434}, "CVE-2016-8883": {"epss_score": 0.00379, "epss_percentile": 0.5884}, "CVE-2016-8884": {"epss_score": 0.00407, "epss_percentile": 0.60619}, "CVE-2016-8885": {"epss_score": 0.00352, "epss_percentile": 0.57085}, "CVE-2016-8886": {"epss_score": 0.00317, "epss_percentile": 0.5433}, "CVE-2016-8887": {"epss_score": 0.00219, "epss_percentile": 0.44512}, "CVE-2016-8889": {"epss_score": 0.00085, "epss_percentile": 0.25189}, "CVE-2016-8897": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2016-8898": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2016-8899": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2016-8900": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2016-8901": {"epss_score": 0.00625, "epss_percentile": 0.69584}, "CVE-2016-8902": {"epss_score": 0.01437, "epss_percentile": 0.80281}, "CVE-2016-8903": {"epss_score": 0.01374, "epss_percentile": 0.79825}, "CVE-2016-8904": {"epss_score": 0.01374, "epss_percentile": 0.79825}, "CVE-2016-8905": {"epss_score": 0.01994, "epss_percentile": 0.83187}, "CVE-2016-8906": {"epss_score": 0.02036, "epss_percentile": 0.83353}, "CVE-2016-8907": {"epss_score": 0.01994, "epss_percentile": 0.83187}, "CVE-2016-8908": {"epss_score": 0.02036, "epss_percentile": 0.83353}, "CVE-2016-8909": {"epss_score": 0.00037, "epss_percentile": 0.10989}, "CVE-2016-8910": {"epss_score": 0.00099, "epss_percentile": 0.27835}, "CVE-2016-8911": {"epss_score": 0.00204, "epss_percentile": 0.42603}, "CVE-2016-8912": {"epss_score": 0.00156, "epss_percentile": 0.3694}, "CVE-2016-8913": {"epss_score": 0.00638, "epss_percentile": 0.69907}, "CVE-2016-8915": {"epss_score": 0.0028, "epss_percentile": 0.51098}, "CVE-2016-8916": {"epss_score": 0.00053, "epss_percentile": 0.16739}, "CVE-2016-8917": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2016-8918": {"epss_score": 0.00203, "epss_percentile": 0.42525}, "CVE-2016-8919": {"epss_score": 0.00859, "epss_percentile": 0.74524}, "CVE-2016-8920": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-8921": {"epss_score": 0.02673, "epss_percentile": 0.85396}, "CVE-2016-8922": {"epss_score": 0.00238, "epss_percentile": 0.46758}, "CVE-2016-8923": {"epss_score": 0.00203, "epss_percentile": 0.42565}, "CVE-2016-8924": {"epss_score": 0.00207, "epss_percentile": 0.43201}, "CVE-2016-8925": {"epss_score": 0.0021, "epss_percentile": 0.43495}, "CVE-2016-8926": {"epss_score": 0.00155, "epss_percentile": 0.36807}, "CVE-2016-8927": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-8928": {"epss_score": 0.00353, "epss_percentile": 0.57199}, "CVE-2016-8929": {"epss_score": 0.00275, "epss_percentile": 0.50651}, "CVE-2016-8930": {"epss_score": 0.00353, "epss_percentile": 0.57199}, "CVE-2016-8931": {"epss_score": 0.0212, "epss_percentile": 0.83675}, "CVE-2016-8932": {"epss_score": 0.0212, "epss_percentile": 0.83675}, "CVE-2016-8933": {"epss_score": 0.00638, "epss_percentile": 0.69907}, "CVE-2016-8934": {"epss_score": 0.002, "epss_percentile": 0.4226}, "CVE-2016-8935": {"epss_score": 0.00303, "epss_percentile": 0.53194}, "CVE-2016-8936": {"epss_score": 0.00224, "epss_percentile": 0.44977}, "CVE-2016-8937": {"epss_score": 0.00232, "epss_percentile": 0.45911}, "CVE-2016-8938": {"epss_score": 0.00768, "epss_percentile": 0.72974}, "CVE-2016-8939": {"epss_score": 0.00074, "epss_percentile": 0.2275}, "CVE-2016-8940": {"epss_score": 0.00336, "epss_percentile": 0.56005}, "CVE-2016-8941": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2016-8942": {"epss_score": 0.00125, "epss_percentile": 0.32508}, "CVE-2016-8943": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-8944": {"epss_score": 0.00051, "epss_percentile": 0.16245}, "CVE-2016-8946": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-8947": {"epss_score": 0.00212, "epss_percentile": 0.43783}, "CVE-2016-8948": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-8949": {"epss_score": 0.00119, "epss_percentile": 0.31549}, "CVE-2016-8950": {"epss_score": 0.00235, "epss_percentile": 0.46201}, "CVE-2016-8951": {"epss_score": 0.00674, "epss_percentile": 0.70882}, "CVE-2016-8952": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-8953": {"epss_score": 0.00119, "epss_percentile": 0.31549}, "CVE-2016-8954": {"epss_score": 0.00913, "epss_percentile": 0.75369}, "CVE-2016-8960": {"epss_score": 0.00526, "epss_percentile": 0.66435}, "CVE-2016-8961": {"epss_score": 0.00154, "epss_percentile": 0.36667}, "CVE-2016-8962": {"epss_score": 0.00296, "epss_percentile": 0.52565}, "CVE-2016-8963": {"epss_score": 0.00046, "epss_percentile": 0.14278}, "CVE-2016-8964": {"epss_score": 0.02438, "epss_percentile": 0.84746}, "CVE-2016-8966": {"epss_score": 0.00191, "epss_percentile": 0.41263}, "CVE-2016-8967": {"epss_score": 0.00046, "epss_percentile": 0.14278}, "CVE-2016-8968": {"epss_score": 0.00657, "epss_percentile": 0.70474}, "CVE-2016-8971": {"epss_score": 0.00405, "epss_percentile": 0.60475}, "CVE-2016-8972": {"epss_score": 0.00627, "epss_percentile": 0.69622}, "CVE-2016-8973": {"epss_score": 0.0019, "epss_percentile": 0.41088}, "CVE-2016-8974": {"epss_score": 0.00378, "epss_percentile": 0.58787}, "CVE-2016-8975": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-8977": {"epss_score": 0.00233, "epss_percentile": 0.46035}, "CVE-2016-8980": {"epss_score": 0.00359, "epss_percentile": 0.57568}, "CVE-2016-8981": {"epss_score": 0.00054, "epss_percentile": 0.17143}, "CVE-2016-8982": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2016-8986": {"epss_score": 0.00203, "epss_percentile": 0.42582}, "CVE-2016-8987": {"epss_score": 0.00212, "epss_percentile": 0.43805}, "CVE-2016-8998": {"epss_score": 0.02352, "epss_percentile": 0.84472}, "CVE-2016-8999": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-9000": {"epss_score": 0.00244, "epss_percentile": 0.47516}, "CVE-2016-9005": {"epss_score": 0.00492, "epss_percentile": 0.65003}, "CVE-2016-9006": {"epss_score": 0.00303, "epss_percentile": 0.53194}, "CVE-2016-9008": {"epss_score": 0.00255, "epss_percentile": 0.48719}, "CVE-2016-9009": {"epss_score": 0.00344, "epss_percentile": 0.56489}, "CVE-2016-9010": {"epss_score": 0.00191, "epss_percentile": 0.41277}, "CVE-2016-9011": {"epss_score": 0.00491, "epss_percentile": 0.64979}, "CVE-2016-9012": {"epss_score": 0.00735, "epss_percentile": 0.72294}, "CVE-2016-9013": {"epss_score": 0.02395, "epss_percentile": 0.84614}, "CVE-2016-9014": {"epss_score": 0.04312, "epss_percentile": 0.88534}, "CVE-2016-9015": {"epss_score": 0.00058, "epss_percentile": 0.18427}, "CVE-2016-9016": {"epss_score": 0.00136, "epss_percentile": 0.34191}, "CVE-2016-9017": {"epss_score": 0.00291, "epss_percentile": 0.5215}, "CVE-2016-9018": {"epss_score": 0.01385, "epss_percentile": 0.79902}, "CVE-2016-9019": {"epss_score": 0.02574, "epss_percentile": 0.85139}, "CVE-2016-9020": {"epss_score": 0.02606, "epss_percentile": 0.85224}, "CVE-2016-9021": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2016-9022": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2016-9023": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2016-9025": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2016-9026": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2016-9028": {"epss_score": 0.00476, "epss_percentile": 0.64275}, "CVE-2016-9031": {"epss_score": 0.00146, "epss_percentile": 0.35547}, "CVE-2016-9032": {"epss_score": 0.00062, "epss_percentile": 0.19635}, "CVE-2016-9033": {"epss_score": 0.00062, "epss_percentile": 0.19635}, "CVE-2016-9034": {"epss_score": 0.00062, "epss_percentile": 0.19635}, "CVE-2016-9035": {"epss_score": 0.00062, "epss_percentile": 0.19635}, "CVE-2016-9036": {"epss_score": 0.01042, "epss_percentile": 0.7698}, "CVE-2016-9037": {"epss_score": 0.02171, "epss_percentile": 0.83872}, "CVE-2016-9038": {"epss_score": 0.00027, "epss_percentile": 0.07096}, "CVE-2016-9039": {"epss_score": 0.00074, "epss_percentile": 0.2283}, "CVE-2016-9040": {"epss_score": 0.0006, "epss_percentile": 0.1916}, "CVE-2016-9042": {"epss_score": 0.04844, "epss_percentile": 0.89204}, "CVE-2016-9043": {"epss_score": 0.0029, "epss_percentile": 0.52116}, "CVE-2016-9044": {"epss_score": 0.01285, "epss_percentile": 0.79174}, "CVE-2016-9045": {"epss_score": 0.0036, "epss_percentile": 0.57686}, "CVE-2016-9048": {"epss_score": 0.00177, "epss_percentile": 0.39503}, "CVE-2016-9049": {"epss_score": 0.01399, "epss_percentile": 0.79994}, "CVE-2016-9050": {"epss_score": 0.00607, "epss_percentile": 0.6904}, "CVE-2016-9051": {"epss_score": 0.0391, "epss_percentile": 0.87933}, "CVE-2016-9052": {"epss_score": 0.14838, "epss_percentile": 0.943}, "CVE-2016-9053": {"epss_score": 0.05433, "epss_percentile": 0.89879}, "CVE-2016-9054": {"epss_score": 0.14838, "epss_percentile": 0.943}, "CVE-2016-9061": {"epss_score": 0.00822, "epss_percentile": 0.73917}, "CVE-2016-9062": {"epss_score": 0.0008, "epss_percentile": 0.24051}, "CVE-2016-9063": {"epss_score": 0.02423, "epss_percentile": 0.84708}, "CVE-2016-9064": {"epss_score": 0.00274, "epss_percentile": 0.50505}, "CVE-2016-9065": {"epss_score": 0.0077, "epss_percentile": 0.72997}, "CVE-2016-9066": {"epss_score": 0.20609, "epss_percentile": 0.95384}, "CVE-2016-9067": {"epss_score": 0.01358, "epss_percentile": 0.79734}, "CVE-2016-9068": {"epss_score": 0.01719, "epss_percentile": 0.81926}, "CVE-2016-9069": {"epss_score": 0.00253, "epss_percentile": 0.48448}, "CVE-2016-9070": {"epss_score": 0.00688, "epss_percentile": 0.71208}, "CVE-2016-9071": {"epss_score": 0.00259, "epss_percentile": 0.4907}, "CVE-2016-9072": {"epss_score": 0.00369, "epss_percentile": 0.58229}, "CVE-2016-9073": {"epss_score": 0.00807, "epss_percentile": 0.73666}, "CVE-2016-9074": {"epss_score": 0.01221, "epss_percentile": 0.78651}, "CVE-2016-9075": {"epss_score": 0.02551, "epss_percentile": 0.85077}, "CVE-2016-9076": {"epss_score": 0.00528, "epss_percentile": 0.6654}, "CVE-2016-9077": {"epss_score": 0.00171, "epss_percentile": 0.38835}, "CVE-2016-9078": {"epss_score": 0.01176, "epss_percentile": 0.78275}, "CVE-2016-9079": {"epss_score": 0.84813, "epss_percentile": 0.99306}, "CVE-2016-9080": {"epss_score": 0.01847, "epss_percentile": 0.82523}, "CVE-2016-9081": {"epss_score": 0.00213, "epss_percentile": 0.43909}, "CVE-2016-9082": {"epss_score": 0.00429, "epss_percentile": 0.61982}, "CVE-2016-9083": {"epss_score": 0.00051, "epss_percentile": 0.16021}, "CVE-2016-9084": {"epss_score": 0.00051, "epss_percentile": 0.16055}, "CVE-2016-9085": {"epss_score": 0.00105, "epss_percentile": 0.29317}, "CVE-2016-9086": {"epss_score": 0.13489, "epss_percentile": 0.93979}, "CVE-2016-9087": {"epss_score": 0.02606, "epss_percentile": 0.85224}, "CVE-2016-9091": {"epss_score": 0.36512, "epss_percentile": 0.96982}, "CVE-2016-9092": {"epss_score": 0.00243, "epss_percentile": 0.47426}, "CVE-2016-9093": {"epss_score": 0.00092, "epss_percentile": 0.26437}, "CVE-2016-9094": {"epss_score": 0.00296, "epss_percentile": 0.52535}, "CVE-2016-9097": {"epss_score": 0.01223, "epss_percentile": 0.78661}, "CVE-2016-9099": {"epss_score": 0.00312, "epss_percentile": 0.5397}, "CVE-2016-9100": {"epss_score": 0.00169, "epss_percentile": 0.38597}, "CVE-2016-9101": {"epss_score": 0.00134, "epss_percentile": 0.33799}, "CVE-2016-9102": {"epss_score": 0.00032, "epss_percentile": 0.08739}, "CVE-2016-9103": {"epss_score": 0.00102, "epss_percentile": 0.28813}, "CVE-2016-9104": {"epss_score": 0.00121, "epss_percentile": 0.3189}, "CVE-2016-9105": {"epss_score": 0.00104, "epss_percentile": 0.29126}, "CVE-2016-9106": {"epss_score": 0.00134, "epss_percentile": 0.33799}, "CVE-2016-9107": {"epss_score": 0.01261, "epss_percentile": 0.78974}, "CVE-2016-9108": {"epss_score": 0.00825, "epss_percentile": 0.73948}, "CVE-2016-9109": {"epss_score": 0.00836, "epss_percentile": 0.74136}, "CVE-2016-9111": {"epss_score": 0.026, "epss_percentile": 0.85204}, "CVE-2016-9112": {"epss_score": 0.00787, "epss_percentile": 0.73313}, "CVE-2016-9113": {"epss_score": 0.00448, "epss_percentile": 0.62994}, "CVE-2016-9114": {"epss_score": 0.00478, "epss_percentile": 0.64376}, "CVE-2016-9115": {"epss_score": 0.00374, "epss_percentile": 0.58575}, "CVE-2016-9116": {"epss_score": 0.00581, "epss_percentile": 0.68267}, "CVE-2016-9117": {"epss_score": 0.00581, "epss_percentile": 0.68267}, "CVE-2016-9118": {"epss_score": 0.00547, "epss_percentile": 0.67248}, "CVE-2016-9119": {"epss_score": 0.00806, "epss_percentile": 0.73657}, "CVE-2016-9120": {"epss_score": 0.00276, "epss_percentile": 0.50772}, "CVE-2016-9121": {"epss_score": 0.00514, "epss_percentile": 0.65948}, "CVE-2016-9122": {"epss_score": 0.0031, "epss_percentile": 0.53758}, "CVE-2016-9123": {"epss_score": 0.00274, "epss_percentile": 0.50578}, "CVE-2016-9124": {"epss_score": 0.00773, "epss_percentile": 0.7306}, "CVE-2016-9125": {"epss_score": 0.01075, "epss_percentile": 0.77309}, "CVE-2016-9126": {"epss_score": 0.00264, "epss_percentile": 0.49579}, "CVE-2016-9127": {"epss_score": 0.00136, "epss_percentile": 0.34137}, "CVE-2016-9128": {"epss_score": 0.00373, "epss_percentile": 0.58468}, "CVE-2016-9129": {"epss_score": 0.00223, "epss_percentile": 0.44844}, "CVE-2016-9130": {"epss_score": 0.00236, "epss_percentile": 0.46385}, "CVE-2016-9131": {"epss_score": 0.7283, "epss_percentile": 0.98726}, "CVE-2016-9132": {"epss_score": 0.00484, "epss_percentile": 0.64651}, "CVE-2016-9134": {"epss_score": 0.00954, "epss_percentile": 0.75901}, "CVE-2016-9135": {"epss_score": 0.00533, "epss_percentile": 0.66768}, "CVE-2016-9136": {"epss_score": 0.00238, "epss_percentile": 0.46832}, "CVE-2016-9137": {"epss_score": 0.00942, "epss_percentile": 0.75761}, "CVE-2016-9138": {"epss_score": 0.04295, "epss_percentile": 0.88508}, "CVE-2016-9139": {"epss_score": 0.00233, "epss_percentile": 0.46056}, "CVE-2016-9147": {"epss_score": 0.6188, "epss_percentile": 0.98266}, "CVE-2016-9148": {"epss_score": 0.00369, "epss_percentile": 0.58242}, "CVE-2016-9149": {"epss_score": 0.00249, "epss_percentile": 0.48066}, "CVE-2016-9150": {"epss_score": 0.62847, "epss_percentile": 0.9831}, "CVE-2016-9151": {"epss_score": 0.0043, "epss_percentile": 0.62028}, "CVE-2016-9152": {"epss_score": 0.00252, "epss_percentile": 0.4838}, "CVE-2016-9154": {"epss_score": 0.01167, "epss_percentile": 0.78187}, "CVE-2016-9155": {"epss_score": 0.00919, "epss_percentile": 0.75463}, "CVE-2016-9156": {"epss_score": 0.00496, "epss_percentile": 0.6515}, "CVE-2016-9157": {"epss_score": 0.01455, "epss_percentile": 0.80386}, "CVE-2016-9158": {"epss_score": 0.01146, "epss_percentile": 0.77996}, "CVE-2016-9159": {"epss_score": 0.00327, "epss_percentile": 0.55141}, "CVE-2016-9160": {"epss_score": 0.00489, "epss_percentile": 0.64909}, "CVE-2016-9164": {"epss_score": 0.03618, "epss_percentile": 0.87438}, "CVE-2016-9165": {"epss_score": 0.0124, "epss_percentile": 0.78801}, "CVE-2016-9166": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2016-9167": {"epss_score": 0.00499, "epss_percentile": 0.65277}, "CVE-2016-9168": {"epss_score": 0.00565, "epss_percentile": 0.67795}, "CVE-2016-9169": {"epss_score": 0.00444, "epss_percentile": 0.62833}, "CVE-2016-9176": {"epss_score": 0.00971, "epss_percentile": 0.76128}, "CVE-2016-9177": {"epss_score": 0.01566, "epss_percentile": 0.81069}, "CVE-2016-9178": {"epss_score": 0.0007, "epss_percentile": 0.21669}, "CVE-2016-9179": {"epss_score": 0.0021, "epss_percentile": 0.435}, "CVE-2016-9180": {"epss_score": 0.00433, "epss_percentile": 0.62199}, "CVE-2016-9181": {"epss_score": 0.00253, "epss_percentile": 0.48472}, "CVE-2016-9182": {"epss_score": 0.00166, "epss_percentile": 0.38178}, "CVE-2016-9183": {"epss_score": 0.00477, "epss_percentile": 0.64295}, "CVE-2016-9184": {"epss_score": 0.00533, "epss_percentile": 0.66768}, "CVE-2016-9185": {"epss_score": 0.00527, "epss_percentile": 0.66524}, "CVE-2016-9186": {"epss_score": 0.03277, "epss_percentile": 0.86805}, "CVE-2016-9187": {"epss_score": 0.03277, "epss_percentile": 0.86805}, "CVE-2016-9188": {"epss_score": 0.00371, "epss_percentile": 0.58387}, "CVE-2016-9189": {"epss_score": 0.00358, "epss_percentile": 0.57507}, "CVE-2016-9190": {"epss_score": 0.00566, "epss_percentile": 0.67811}, "CVE-2016-9191": {"epss_score": 0.00084, "epss_percentile": 0.24861}, "CVE-2016-9192": {"epss_score": 0.31816, "epss_percentile": 0.96651}, "CVE-2016-9193": {"epss_score": 0.00383, "epss_percentile": 0.59116}, "CVE-2016-9194": {"epss_score": 0.00183, "epss_percentile": 0.40324}, "CVE-2016-9195": {"epss_score": 0.00435, "epss_percentile": 0.62354}, "CVE-2016-9196": {"epss_score": 0.00163, "epss_percentile": 0.37813}, "CVE-2016-9197": {"epss_score": 0.00061, "epss_percentile": 0.19288}, "CVE-2016-9198": {"epss_score": 0.01295, "epss_percentile": 0.7925}, "CVE-2016-9199": {"epss_score": 0.00902, "epss_percentile": 0.75182}, "CVE-2016-9200": {"epss_score": 0.0031, "epss_percentile": 0.53762}, "CVE-2016-9201": {"epss_score": 0.01253, "epss_percentile": 0.78916}, "CVE-2016-9202": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2016-9203": {"epss_score": 0.01792, "epss_percentile": 0.82287}, "CVE-2016-9204": {"epss_score": 0.00259, "epss_percentile": 0.49032}, "CVE-2016-9205": {"epss_score": 0.00662, "epss_percentile": 0.70608}, "CVE-2016-9206": {"epss_score": 0.00361, "epss_percentile": 0.577}, "CVE-2016-9207": {"epss_score": 0.00814, "epss_percentile": 0.73774}, "CVE-2016-9208": {"epss_score": 0.01007, "epss_percentile": 0.76558}, "CVE-2016-9209": {"epss_score": 0.00303, "epss_percentile": 0.53221}, "CVE-2016-9210": {"epss_score": 0.02278, "epss_percentile": 0.84233}, "CVE-2016-9211": {"epss_score": 0.01648, "epss_percentile": 0.81544}, "CVE-2016-9212": {"epss_score": 0.00876, "epss_percentile": 0.74789}, "CVE-2016-9214": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2016-9215": {"epss_score": 0.00073, "epss_percentile": 0.22666}, "CVE-2016-9216": {"epss_score": 0.00496, "epss_percentile": 0.6515}, "CVE-2016-9217": {"epss_score": 0.00578, "epss_percentile": 0.68186}, "CVE-2016-9218": {"epss_score": 0.00192, "epss_percentile": 0.41307}, "CVE-2016-9219": {"epss_score": 0.0041, "epss_percentile": 0.60841}, "CVE-2016-9220": {"epss_score": 0.00108, "epss_percentile": 0.29772}, "CVE-2016-9221": {"epss_score": 0.00394, "epss_percentile": 0.59786}, "CVE-2016-9222": {"epss_score": 0.0027, "epss_percentile": 0.50243}, "CVE-2016-9223": {"epss_score": 0.0175, "epss_percentile": 0.82098}, "CVE-2016-9224": {"epss_score": 0.00299, "epss_percentile": 0.5286}, "CVE-2016-9225": {"epss_score": 0.01379, "epss_percentile": 0.79854}, "CVE-2016-9242": {"epss_score": 0.00433, "epss_percentile": 0.62203}, "CVE-2016-9243": {"epss_score": 0.0165, "epss_percentile": 0.81562}, "CVE-2016-9244": {"epss_score": 0.73652, "epss_percentile": 0.98764}, "CVE-2016-9245": {"epss_score": 0.00655, "epss_percentile": 0.7037}, "CVE-2016-9247": {"epss_score": 0.00765, "epss_percentile": 0.72909}, "CVE-2016-9249": {"epss_score": 0.00772, "epss_percentile": 0.73048}, "CVE-2016-9250": {"epss_score": 0.00608, "epss_percentile": 0.69084}, "CVE-2016-9251": {"epss_score": 0.00454, "epss_percentile": 0.63241}, "CVE-2016-9252": {"epss_score": 0.01195, "epss_percentile": 0.78426}, "CVE-2016-9253": {"epss_score": 0.00778, "epss_percentile": 0.73135}, "CVE-2016-9256": {"epss_score": 0.00227, "epss_percentile": 0.45367}, "CVE-2016-9257": {"epss_score": 0.00295, "epss_percentile": 0.52491}, "CVE-2016-9259": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2016-9260": {"epss_score": 0.00247, "epss_percentile": 0.4789}, "CVE-2016-9261": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2016-9262": {"epss_score": 0.00433, "epss_percentile": 0.62223}, "CVE-2016-9263": {"epss_score": 0.01241, "epss_percentile": 0.78818}, "CVE-2016-9264": {"epss_score": 0.00239, "epss_percentile": 0.46865}, "CVE-2016-9265": {"epss_score": 0.00219, "epss_percentile": 0.44476}, "CVE-2016-9266": {"epss_score": 0.00736, "epss_percentile": 0.72309}, "CVE-2016-9268": {"epss_score": 0.00875, "epss_percentile": 0.74781}, "CVE-2016-9269": {"epss_score": 0.06848, "epss_percentile": 0.91071}, "CVE-2016-9271": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2016-9272": {"epss_score": 0.00846, "epss_percentile": 0.74327}, "CVE-2016-9273": {"epss_score": 0.00709, "epss_percentile": 0.71694}, "CVE-2016-9274": {"epss_score": 0.00059, "epss_percentile": 0.18686}, "CVE-2016-9275": {"epss_score": 0.00711, "epss_percentile": 0.71743}, "CVE-2016-9276": {"epss_score": 0.00822, "epss_percentile": 0.7391}, "CVE-2016-9277": {"epss_score": 0.00473, "epss_percentile": 0.64095}, "CVE-2016-9278": {"epss_score": 0.00059, "epss_percentile": 0.18873}, "CVE-2016-9279": {"epss_score": 0.01138, "epss_percentile": 0.77927}, "CVE-2016-9282": {"epss_score": 0.00264, "epss_percentile": 0.49729}, "CVE-2016-9283": {"epss_score": 0.00264, "epss_percentile": 0.49729}, "CVE-2016-9284": {"epss_score": 0.00213, "epss_percentile": 0.43898}, "CVE-2016-9285": {"epss_score": 0.00213, "epss_percentile": 0.43898}, "CVE-2016-9286": {"epss_score": 0.00213, "epss_percentile": 0.43898}, "CVE-2016-9287": {"epss_score": 0.00532, "epss_percentile": 0.66678}, "CVE-2016-9288": {"epss_score": 0.00251, "epss_percentile": 0.48261}, "CVE-2016-9294": {"epss_score": 0.00491, "epss_percentile": 0.64947}, "CVE-2016-9296": {"epss_score": 0.02148, "epss_percentile": 0.8377}, "CVE-2016-9297": {"epss_score": 0.00332, "epss_percentile": 0.55597}, "CVE-2016-9298": {"epss_score": 0.00243, "epss_percentile": 0.47474}, "CVE-2016-9299": {"epss_score": 0.86028, "epss_percentile": 0.99363}, "CVE-2016-9303": {"epss_score": 0.03153, "epss_percentile": 0.8651}, "CVE-2016-9304": {"epss_score": 0.01421, "epss_percentile": 0.80175}, "CVE-2016-9305": {"epss_score": 0.00576, "epss_percentile": 0.68126}, "CVE-2016-9306": {"epss_score": 0.03362, "epss_percentile": 0.86993}, "CVE-2016-9307": {"epss_score": 0.03362, "epss_percentile": 0.86993}, "CVE-2016-9310": {"epss_score": 0.07012, "epss_percentile": 0.91185}, "CVE-2016-9311": {"epss_score": 0.18814, "epss_percentile": 0.95074}, "CVE-2016-9312": {"epss_score": 0.19624, "epss_percentile": 0.95216}, "CVE-2016-9313": {"epss_score": 0.00143, "epss_percentile": 0.35097}, "CVE-2016-9314": {"epss_score": 0.01484, "epss_percentile": 0.80591}, "CVE-2016-9315": {"epss_score": 0.05864, "epss_percentile": 0.90274}, "CVE-2016-9316": {"epss_score": 0.00623, "epss_percentile": 0.69541}, "CVE-2016-9317": {"epss_score": 0.01088, "epss_percentile": 0.77436}, "CVE-2016-9318": {"epss_score": 0.00132, "epss_percentile": 0.33573}, "CVE-2016-9319": {"epss_score": 0.00358, "epss_percentile": 0.57512}, "CVE-2016-9332": {"epss_score": 0.29698, "epss_percentile": 0.96467}, "CVE-2016-9333": {"epss_score": 0.00655, "epss_percentile": 0.70367}, "CVE-2016-9334": {"epss_score": 0.00065, "epss_percentile": 0.20595}, "CVE-2016-9335": {"epss_score": 0.00223, "epss_percentile": 0.44881}, "CVE-2016-9337": {"epss_score": 0.00949, "epss_percentile": 0.75847}, "CVE-2016-9338": {"epss_score": 0.00037, "epss_percentile": 0.10839}, "CVE-2016-9339": {"epss_score": 0.00367, "epss_percentile": 0.58157}, "CVE-2016-9343": {"epss_score": 0.00069, "epss_percentile": 0.21446}, "CVE-2016-9344": {"epss_score": 0.00319, "epss_percentile": 0.54548}, "CVE-2016-9345": {"epss_score": 0.00206, "epss_percentile": 0.4304}, "CVE-2016-9346": {"epss_score": 0.00161, "epss_percentile": 0.37541}, "CVE-2016-9347": {"epss_score": 0.00118, "epss_percentile": 0.31506}, "CVE-2016-9348": {"epss_score": 0.00135, "epss_percentile": 0.34049}, "CVE-2016-9349": {"epss_score": 0.23687, "epss_percentile": 0.95803}, "CVE-2016-9351": {"epss_score": 0.03705, "epss_percentile": 0.87597}, "CVE-2016-9353": {"epss_score": 0.0008, "epss_percentile": 0.24183}, "CVE-2016-9354": {"epss_score": 0.00112, "epss_percentile": 0.30548}, "CVE-2016-9355": {"epss_score": 0.00247, "epss_percentile": 0.47884}, "CVE-2016-9356": {"epss_score": 0.00082, "epss_percentile": 0.24532}, "CVE-2016-9357": {"epss_score": 0.01661, "epss_percentile": 0.81625}, "CVE-2016-9358": {"epss_score": 0.00545, "epss_percentile": 0.67154}, "CVE-2016-9360": {"epss_score": 0.00156, "epss_percentile": 0.36905}, "CVE-2016-9361": {"epss_score": 0.49582, "epss_percentile": 0.97695}, "CVE-2016-9362": {"epss_score": 0.00206, "epss_percentile": 0.42773}, "CVE-2016-9363": {"epss_score": 0.01572, "epss_percentile": 0.81095}, "CVE-2016-9364": {"epss_score": 0.01713, "epss_percentile": 0.81889}, "CVE-2016-9365": {"epss_score": 0.0012, "epss_percentile": 0.31798}, "CVE-2016-9366": {"epss_score": 0.0018, "epss_percentile": 0.39869}, "CVE-2016-9367": {"epss_score": 0.00549, "epss_percentile": 0.67296}, "CVE-2016-9368": {"epss_score": 0.00216, "epss_percentile": 0.44188}, "CVE-2016-9369": {"epss_score": 0.07403, "epss_percentile": 0.91454}, "CVE-2016-9371": {"epss_score": 0.00323, "epss_percentile": 0.54874}, "CVE-2016-9372": {"epss_score": 0.00382, "epss_percentile": 0.59076}, "CVE-2016-9373": {"epss_score": 0.01217, "epss_percentile": 0.78598}, "CVE-2016-9374": {"epss_score": 0.01217, "epss_percentile": 0.78598}, "CVE-2016-9375": {"epss_score": 0.01481, "epss_percentile": 0.80571}, "CVE-2016-9376": {"epss_score": 0.01481, "epss_percentile": 0.80571}, "CVE-2016-9377": {"epss_score": 0.00071, "epss_percentile": 0.22052}, "CVE-2016-9378": {"epss_score": 0.00061, "epss_percentile": 0.193}, "CVE-2016-9379": {"epss_score": 0.00101, "epss_percentile": 0.28697}, "CVE-2016-9380": {"epss_score": 0.00093, "epss_percentile": 0.26632}, "CVE-2016-9381": {"epss_score": 0.00105, "epss_percentile": 0.29282}, "CVE-2016-9382": {"epss_score": 0.00124, "epss_percentile": 0.3238}, "CVE-2016-9383": {"epss_score": 0.00135, "epss_percentile": 0.33989}, "CVE-2016-9384": {"epss_score": 0.00078, "epss_percentile": 0.23557}, "CVE-2016-9385": {"epss_score": 0.00104, "epss_percentile": 0.29224}, "CVE-2016-9386": {"epss_score": 0.001, "epss_percentile": 0.28484}, "CVE-2016-9387": {"epss_score": 0.0033, "epss_percentile": 0.55459}, "CVE-2016-9388": {"epss_score": 0.00263, "epss_percentile": 0.49516}, "CVE-2016-9389": {"epss_score": 0.01628, "epss_percentile": 0.81435}, "CVE-2016-9390": {"epss_score": 0.00461, "epss_percentile": 0.63561}, "CVE-2016-9391": {"epss_score": 0.01218, "epss_percentile": 0.78605}, "CVE-2016-9392": {"epss_score": 0.00466, "epss_percentile": 0.6381}, "CVE-2016-9393": {"epss_score": 0.00475, "epss_percentile": 0.64181}, "CVE-2016-9394": {"epss_score": 0.00461, "epss_percentile": 0.63561}, "CVE-2016-9395": {"epss_score": 0.00395, "epss_percentile": 0.59844}, "CVE-2016-9396": {"epss_score": 0.04577, "epss_percentile": 0.8887}, "CVE-2016-9397": {"epss_score": 0.01797, "epss_percentile": 0.82308}, "CVE-2016-9398": {"epss_score": 0.0411, "epss_percentile": 0.8827}, "CVE-2016-9399": {"epss_score": 0.02137, "epss_percentile": 0.83733}, "CVE-2016-9400": {"epss_score": 0.03415, "epss_percentile": 0.87091}, "CVE-2016-9401": {"epss_score": 0.00025, "epss_percentile": 0.0629}, "CVE-2016-9402": {"epss_score": 0.03692, "epss_percentile": 0.87578}, "CVE-2016-9403": {"epss_score": 0.05329, "epss_percentile": 0.89738}, "CVE-2016-9404": {"epss_score": 0.00611, "epss_percentile": 0.69205}, "CVE-2016-9405": {"epss_score": 0.00611, "epss_percentile": 0.69205}, "CVE-2016-9406": {"epss_score": 0.00611, "epss_percentile": 0.69205}, "CVE-2016-9407": {"epss_score": 0.00611, "epss_percentile": 0.69205}, "CVE-2016-9408": {"epss_score": 0.00611, "epss_percentile": 0.69205}, "CVE-2016-9409": {"epss_score": 0.00611, "epss_percentile": 0.69205}, "CVE-2016-9410": {"epss_score": 0.01218, "epss_percentile": 0.78604}, "CVE-2016-9411": {"epss_score": 0.00308, "epss_percentile": 0.53631}, "CVE-2016-9412": {"epss_score": 0.02853, "epss_percentile": 0.85832}, "CVE-2016-9413": {"epss_score": 0.00652, "epss_percentile": 0.70314}, "CVE-2016-9414": {"epss_score": 0.01218, "epss_percentile": 0.78604}, "CVE-2016-9415": {"epss_score": 0.01001, "epss_percentile": 0.76503}, "CVE-2016-9416": {"epss_score": 0.03692, "epss_percentile": 0.87578}, "CVE-2016-9417": {"epss_score": 0.00652, "epss_percentile": 0.70314}, "CVE-2016-9418": {"epss_score": 0.01327, "epss_percentile": 0.79491}, "CVE-2016-9419": {"epss_score": 0.00398, "epss_percentile": 0.60076}, "CVE-2016-9420": {"epss_score": 0.01105, "epss_percentile": 0.77604}, "CVE-2016-9421": {"epss_score": 0.00431, "epss_percentile": 0.62065}, "CVE-2016-9422": {"epss_score": 0.01043, "epss_percentile": 0.76998}, "CVE-2016-9423": {"epss_score": 0.01043, "epss_percentile": 0.76998}, "CVE-2016-9424": {"epss_score": 0.00993, "epss_percentile": 0.76402}, "CVE-2016-9425": {"epss_score": 0.01594, "epss_percentile": 0.81231}, "CVE-2016-9426": {"epss_score": 0.00536, "epss_percentile": 0.66852}, "CVE-2016-9427": {"epss_score": 0.02406, "epss_percentile": 0.84652}, "CVE-2016-9428": {"epss_score": 0.01594, "epss_percentile": 0.81231}, "CVE-2016-9429": {"epss_score": 0.00844, "epss_percentile": 0.74279}, "CVE-2016-9430": {"epss_score": 0.00758, "epss_percentile": 0.72766}, "CVE-2016-9431": {"epss_score": 0.00651, "epss_percentile": 0.70282}, "CVE-2016-9432": {"epss_score": 0.00965, "epss_percentile": 0.76044}, "CVE-2016-9433": {"epss_score": 0.00651, "epss_percentile": 0.70282}, "CVE-2016-9434": {"epss_score": 0.0071, "epss_percentile": 0.71715}, "CVE-2016-9435": {"epss_score": 0.0141, "epss_percentile": 0.80081}, "CVE-2016-9436": {"epss_score": 0.01359, "epss_percentile": 0.79735}, "CVE-2016-9437": {"epss_score": 0.0061, "epss_percentile": 0.69147}, "CVE-2016-9438": {"epss_score": 0.0071, "epss_percentile": 0.71715}, "CVE-2016-9439": {"epss_score": 0.00767, "epss_percentile": 0.72949}, "CVE-2016-9440": {"epss_score": 0.00892, "epss_percentile": 0.75066}, "CVE-2016-9441": {"epss_score": 0.00892, "epss_percentile": 0.75066}, "CVE-2016-9442": {"epss_score": 0.00767, "epss_percentile": 0.72949}, "CVE-2016-9443": {"epss_score": 0.0071, "epss_percentile": 0.71715}, "CVE-2016-9444": {"epss_score": 0.56539, "epss_percentile": 0.98026}, "CVE-2016-9445": {"epss_score": 0.02406, "epss_percentile": 0.84653}, "CVE-2016-9446": {"epss_score": 0.01283, "epss_percentile": 0.7916}, "CVE-2016-9447": {"epss_score": 0.00483, "epss_percentile": 0.64573}, "CVE-2016-9448": {"epss_score": 0.0164, "epss_percentile": 0.815}, "CVE-2016-9449": {"epss_score": 0.00215, "epss_percentile": 0.44078}, "CVE-2016-9450": {"epss_score": 0.00227, "epss_percentile": 0.45387}, "CVE-2016-9451": {"epss_score": 0.00119, "epss_percentile": 0.31566}, "CVE-2016-9452": {"epss_score": 0.00378, "epss_percentile": 0.58814}, "CVE-2016-9453": {"epss_score": 0.00418, "epss_percentile": 0.61282}, "CVE-2016-9454": {"epss_score": 0.00317, "epss_percentile": 0.54328}, "CVE-2016-9455": {"epss_score": 0.00134, "epss_percentile": 0.3392}, "CVE-2016-9456": {"epss_score": 0.0015, "epss_percentile": 0.36098}, "CVE-2016-9457": {"epss_score": 0.00213, "epss_percentile": 0.43835}, "CVE-2016-9459": {"epss_score": 0.00494, "epss_percentile": 0.65095}, "CVE-2016-9460": {"epss_score": 0.00375, "epss_percentile": 0.586}, "CVE-2016-9461": {"epss_score": 0.0076, "epss_percentile": 0.72797}, "CVE-2016-9462": {"epss_score": 0.00455, "epss_percentile": 0.63291}, "CVE-2016-9463": {"epss_score": 0.03864, "epss_percentile": 0.8787}, "CVE-2016-9464": {"epss_score": 0.00292, "epss_percentile": 0.52232}, "CVE-2016-9465": {"epss_score": 0.00497, "epss_percentile": 0.65205}, "CVE-2016-9466": {"epss_score": 0.00458, "epss_percentile": 0.63419}, "CVE-2016-9467": {"epss_score": 0.01045, "epss_percentile": 0.77019}, "CVE-2016-9468": {"epss_score": 0.00301, "epss_percentile": 0.5307}, "CVE-2016-9469": {"epss_score": 0.00135, "epss_percentile": 0.34025}, "CVE-2016-9470": {"epss_score": 0.0054, "epss_percentile": 0.67006}, "CVE-2016-9471": {"epss_score": 0.00271, "epss_percentile": 0.50308}, "CVE-2016-9472": {"epss_score": 0.00364, "epss_percentile": 0.57919}, "CVE-2016-9473": {"epss_score": 0.01211, "epss_percentile": 0.78553}, "CVE-2016-9479": {"epss_score": 0.00838, "epss_percentile": 0.74167}, "CVE-2016-9480": {"epss_score": 0.00435, "epss_percentile": 0.62339}, "CVE-2016-9481": {"epss_score": 0.00351, "epss_percentile": 0.57017}, "CVE-2016-9482": {"epss_score": 0.09653, "epss_percentile": 0.9264}, "CVE-2016-9483": {"epss_score": 0.00615, "epss_percentile": 0.69305}, "CVE-2016-9484": {"epss_score": 0.05449, "epss_percentile": 0.8989}, "CVE-2016-9485": {"epss_score": 0.00255, "epss_percentile": 0.4864}, "CVE-2016-9486": {"epss_score": 0.00458, "epss_percentile": 0.63397}, "CVE-2016-9487": {"epss_score": 0.00133, "epss_percentile": 0.33667}, "CVE-2016-9488": {"epss_score": 0.04398, "epss_percentile": 0.88642}, "CVE-2016-9489": {"epss_score": 0.00301, "epss_percentile": 0.53015}, "CVE-2016-9490": {"epss_score": 0.00852, "epss_percentile": 0.74422}, "CVE-2016-9491": {"epss_score": 0.00775, "epss_percentile": 0.73079}, "CVE-2016-9492": {"epss_score": 0.00828, "epss_percentile": 0.74004}, "CVE-2016-9493": {"epss_score": 0.0021, "epss_percentile": 0.43474}, "CVE-2016-9494": {"epss_score": 0.0024, "epss_percentile": 0.46945}, "CVE-2016-9495": {"epss_score": 0.00217, "epss_percentile": 0.44307}, "CVE-2016-9496": {"epss_score": 0.02445, "epss_percentile": 0.84764}, "CVE-2016-9497": {"epss_score": 0.05172, "epss_percentile": 0.89572}, "CVE-2016-9498": {"epss_score": 0.71196, "epss_percentile": 0.98658}, "CVE-2016-9499": {"epss_score": 0.00509, "epss_percentile": 0.65742}, "CVE-2016-9500": {"epss_score": 0.00745, "epss_percentile": 0.72532}, "CVE-2016-9532": {"epss_score": 0.00612, "epss_percentile": 0.69217}, "CVE-2016-9533": {"epss_score": 0.0039, "epss_percentile": 0.5954}, "CVE-2016-9534": {"epss_score": 0.00448, "epss_percentile": 0.62993}, "CVE-2016-9535": {"epss_score": 0.0078, "epss_percentile": 0.73172}, "CVE-2016-9536": {"epss_score": 0.00416, "epss_percentile": 0.61218}, "CVE-2016-9537": {"epss_score": 0.00416, "epss_percentile": 0.61218}, "CVE-2016-9538": {"epss_score": 0.00416, "epss_percentile": 0.61218}, "CVE-2016-9539": {"epss_score": 0.00416, "epss_percentile": 0.61218}, "CVE-2016-9540": {"epss_score": 0.00416, "epss_percentile": 0.61218}, "CVE-2016-9553": {"epss_score": 0.06751, "epss_percentile": 0.91002}, "CVE-2016-9554": {"epss_score": 0.11274, "epss_percentile": 0.93288}, "CVE-2016-9555": {"epss_score": 0.32282, "epss_percentile": 0.96686}, "CVE-2016-9556": {"epss_score": 0.00228, "epss_percentile": 0.45481}, "CVE-2016-9557": {"epss_score": 0.00212, "epss_percentile": 0.43755}, "CVE-2016-9558": {"epss_score": 0.0116, "epss_percentile": 0.78136}, "CVE-2016-9559": {"epss_score": 0.01033, "epss_percentile": 0.76877}, "CVE-2016-9560": {"epss_score": 0.00401, "epss_percentile": 0.60249}, "CVE-2016-9561": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2016-9562": {"epss_score": 0.01174, "epss_percentile": 0.78254}, "CVE-2016-9563": {"epss_score": 0.58435, "epss_percentile": 0.98116}, "CVE-2016-9564": {"epss_score": 0.00622, "epss_percentile": 0.69507}, "CVE-2016-9565": {"epss_score": 0.19945, "epss_percentile": 0.95264}, "CVE-2016-9566": {"epss_score": 0.11231, "epss_percentile": 0.93271}, "CVE-2016-9567": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2016-9568": {"epss_score": 0.00679, "epss_percentile": 0.71012}, "CVE-2016-9569": {"epss_score": 0.00131, "epss_percentile": 0.33472}, "CVE-2016-9570": {"epss_score": 0.0039, "epss_percentile": 0.59514}, "CVE-2016-9572": {"epss_score": 0.01771, "epss_percentile": 0.82196}, "CVE-2016-9573": {"epss_score": 0.01115, "epss_percentile": 0.77716}, "CVE-2016-9574": {"epss_score": 0.00184, "epss_percentile": 0.40447}, "CVE-2016-9575": {"epss_score": 0.00272, "epss_percentile": 0.50364}, "CVE-2016-9576": {"epss_score": 0.00067, "epss_percentile": 0.21094}, "CVE-2016-9577": {"epss_score": 0.03861, "epss_percentile": 0.87865}, "CVE-2016-9578": {"epss_score": 0.03335, "epss_percentile": 0.86934}, "CVE-2016-9579": {"epss_score": 0.18013, "epss_percentile": 0.94945}, "CVE-2016-9580": {"epss_score": 0.00396, "epss_percentile": 0.59855}, "CVE-2016-9581": {"epss_score": 0.00352, "epss_percentile": 0.57128}, "CVE-2016-9583": {"epss_score": 0.00318, "epss_percentile": 0.54444}, "CVE-2016-9584": {"epss_score": 0.00779, "epss_percentile": 0.73147}, "CVE-2016-9585": {"epss_score": 0.00181, "epss_percentile": 0.40105}, "CVE-2016-9586": {"epss_score": 0.00609, "epss_percentile": 0.69098}, "CVE-2016-9587": {"epss_score": 0.02827, "epss_percentile": 0.85766}, "CVE-2016-9588": {"epss_score": 0.00076, "epss_percentile": 0.23101}, "CVE-2016-9589": {"epss_score": 0.02193, "epss_percentile": 0.83946}, "CVE-2016-9590": {"epss_score": 0.00281, "epss_percentile": 0.51149}, "CVE-2016-9591": {"epss_score": 0.00479, "epss_percentile": 0.64411}, "CVE-2016-9592": {"epss_score": 0.00315, "epss_percentile": 0.54194}, "CVE-2016-9593": {"epss_score": 0.00218, "epss_percentile": 0.44399}, "CVE-2016-9594": {"epss_score": 0.00905, "epss_percentile": 0.75238}, "CVE-2016-9595": {"epss_score": 0.00042, "epss_percentile": 0.12734}, "CVE-2016-9596": {"epss_score": 0.00673, "epss_percentile": 0.70844}, "CVE-2016-9597": {"epss_score": 0.01327, "epss_percentile": 0.79488}, "CVE-2016-9598": {"epss_score": 0.00673, "epss_percentile": 0.70844}, "CVE-2016-9599": {"epss_score": 0.00179, "epss_percentile": 0.39812}, "CVE-2016-9600": {"epss_score": 0.00295, "epss_percentile": 0.52515}, "CVE-2016-9601": {"epss_score": 0.0045, "epss_percentile": 0.63096}, "CVE-2016-9602": {"epss_score": 0.01302, "epss_percentile": 0.79303}, "CVE-2016-9603": {"epss_score": 0.01381, "epss_percentile": 0.79867}, "CVE-2016-9604": {"epss_score": 0.00018, "epss_percentile": 0.04048}, "CVE-2016-9605": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2016-9606": {"epss_score": 0.01752, "epss_percentile": 0.82108}, "CVE-2016-9622": {"epss_score": 0.00877, "epss_percentile": 0.74805}, "CVE-2016-9623": {"epss_score": 0.00877, "epss_percentile": 0.74805}, "CVE-2016-9624": {"epss_score": 0.00877, "epss_percentile": 0.74805}, "CVE-2016-9625": {"epss_score": 0.00753, "epss_percentile": 0.72684}, "CVE-2016-9626": {"epss_score": 0.00948, "epss_percentile": 0.75836}, "CVE-2016-9627": {"epss_score": 0.01132, "epss_percentile": 0.77872}, "CVE-2016-9628": {"epss_score": 0.00745, "epss_percentile": 0.72518}, "CVE-2016-9629": {"epss_score": 0.00745, "epss_percentile": 0.72518}, "CVE-2016-9630": {"epss_score": 0.01112, "epss_percentile": 0.77676}, "CVE-2016-9631": {"epss_score": 0.00698, "epss_percentile": 0.71418}, "CVE-2016-9632": {"epss_score": 0.00707, "epss_percentile": 0.71645}, "CVE-2016-9633": {"epss_score": 0.00753, "epss_percentile": 0.72684}, "CVE-2016-9634": {"epss_score": 0.16094, "epss_percentile": 0.94572}, "CVE-2016-9635": {"epss_score": 0.16094, "epss_percentile": 0.94572}, "CVE-2016-9636": {"epss_score": 0.1664, "epss_percentile": 0.94706}, "CVE-2016-9637": {"epss_score": 0.00087, "epss_percentile": 0.2557}, "CVE-2016-9638": {"epss_score": 0.00054, "epss_percentile": 0.17281}, "CVE-2016-9639": {"epss_score": 0.00325, "epss_percentile": 0.55013}, "CVE-2016-9642": {"epss_score": 0.00187, "epss_percentile": 0.40715}, "CVE-2016-9643": {"epss_score": 0.00917, "epss_percentile": 0.7543}, "CVE-2016-9644": {"epss_score": 0.00173, "epss_percentile": 0.3912}, "CVE-2016-9645": {"epss_score": 0.00163, "epss_percentile": 0.3777}, "CVE-2016-9646": {"epss_score": 0.00262, "epss_percentile": 0.49388}, "CVE-2016-9650": {"epss_score": 0.00231, "epss_percentile": 0.45807}, "CVE-2016-9651": {"epss_score": 0.52739, "epss_percentile": 0.97838}, "CVE-2016-9652": {"epss_score": 0.01302, "epss_percentile": 0.79304}, "CVE-2016-9675": {"epss_score": 0.00797, "epss_percentile": 0.7349}, "CVE-2016-9676": {"epss_score": 0.06226, "epss_percentile": 0.90584}, "CVE-2016-9677": {"epss_score": 0.00327, "epss_percentile": 0.55124}, "CVE-2016-9678": {"epss_score": 0.04393, "epss_percentile": 0.88636}, "CVE-2016-9679": {"epss_score": 0.03774, "epss_percentile": 0.87707}, "CVE-2016-9680": {"epss_score": 0.01232, "epss_percentile": 0.78736}, "CVE-2016-9681": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2016-9682": {"epss_score": 0.19514, "epss_percentile": 0.95196}, "CVE-2016-9683": {"epss_score": 0.21972, "epss_percentile": 0.95579}, "CVE-2016-9684": {"epss_score": 0.13521, "epss_percentile": 0.93987}, "CVE-2016-9685": {"epss_score": 0.00065, "epss_percentile": 0.20433}, "CVE-2016-9686": {"epss_score": 0.00522, "epss_percentile": 0.66284}, "CVE-2016-9691": {"epss_score": 0.00349, "epss_percentile": 0.56871}, "CVE-2016-9692": {"epss_score": 0.00857, "epss_percentile": 0.74497}, "CVE-2016-9693": {"epss_score": 0.00178, "epss_percentile": 0.39726}, "CVE-2016-9694": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-9696": {"epss_score": 0.00154, "epss_percentile": 0.36683}, "CVE-2016-9697": {"epss_score": 0.00179, "epss_percentile": 0.39783}, "CVE-2016-9698": {"epss_score": 0.00556, "epss_percentile": 0.67508}, "CVE-2016-9700": {"epss_score": 0.00177, "epss_percentile": 0.39611}, "CVE-2016-9701": {"epss_score": 0.00272, "epss_percentile": 0.50402}, "CVE-2016-9703": {"epss_score": 0.00063, "epss_percentile": 0.19817}, "CVE-2016-9704": {"epss_score": 0.00248, "epss_percentile": 0.47995}, "CVE-2016-9706": {"epss_score": 0.00394, "epss_percentile": 0.59794}, "CVE-2016-9707": {"epss_score": 0.00359, "epss_percentile": 0.57568}, "CVE-2016-9710": {"epss_score": 0.00234, "epss_percentile": 0.46122}, "CVE-2016-9711": {"epss_score": 0.00191, "epss_percentile": 0.41188}, "CVE-2016-9714": {"epss_score": 0.00131, "epss_percentile": 0.3345}, "CVE-2016-9715": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-9716": {"epss_score": 0.00171, "epss_percentile": 0.38809}, "CVE-2016-9717": {"epss_score": 0.00215, "epss_percentile": 0.44045}, "CVE-2016-9718": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-9719": {"epss_score": 0.00162, "epss_percentile": 0.3772}, "CVE-2016-9720": {"epss_score": 0.00213, "epss_percentile": 0.43884}, "CVE-2016-9722": {"epss_score": 0.31976, "epss_percentile": 0.96664}, "CVE-2016-9723": {"epss_score": 0.0027, "epss_percentile": 0.50263}, "CVE-2016-9724": {"epss_score": 0.00378, "epss_percentile": 0.58787}, "CVE-2016-9725": {"epss_score": 0.00213, "epss_percentile": 0.43884}, "CVE-2016-9726": {"epss_score": 0.01453, "epss_percentile": 0.80375}, "CVE-2016-9727": {"epss_score": 0.0038, "epss_percentile": 0.58914}, "CVE-2016-9728": {"epss_score": 0.00261, "epss_percentile": 0.49253}, "CVE-2016-9729": {"epss_score": 0.00169, "epss_percentile": 0.3857}, "CVE-2016-9730": {"epss_score": 0.00107, "epss_percentile": 0.29746}, "CVE-2016-9731": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-9732": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2016-9733": {"epss_score": 0.00272, "epss_percentile": 0.50402}, "CVE-2016-9735": {"epss_score": 0.00204, "epss_percentile": 0.42616}, "CVE-2016-9736": {"epss_score": 0.00509, "epss_percentile": 0.65751}, "CVE-2016-9737": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2016-9738": {"epss_score": 0.00296, "epss_percentile": 0.52565}, "CVE-2016-9739": {"epss_score": 0.00055, "epss_percentile": 0.17522}, "CVE-2016-9740": {"epss_score": 0.00893, "epss_percentile": 0.75072}, "CVE-2016-9746": {"epss_score": 0.00272, "epss_percentile": 0.50402}, "CVE-2016-9747": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-9748": {"epss_score": 0.00312, "epss_percentile": 0.53943}, "CVE-2016-9749": {"epss_score": 0.00043, "epss_percentile": 0.13058}, "CVE-2016-9750": {"epss_score": 0.00335, "epss_percentile": 0.55812}, "CVE-2016-9751": {"epss_score": 0.00216, "epss_percentile": 0.44222}, "CVE-2016-9752": {"epss_score": 0.00185, "epss_percentile": 0.40475}, "CVE-2016-9754": {"epss_score": 0.00101, "epss_percentile": 0.28579}, "CVE-2016-9755": {"epss_score": 0.00051, "epss_percentile": 0.16055}, "CVE-2016-9756": {"epss_score": 0.00022, "epss_percentile": 0.05261}, "CVE-2016-9757": {"epss_score": 0.00223, "epss_percentile": 0.44964}, "CVE-2016-9772": {"epss_score": 0.00264, "epss_percentile": 0.49691}, "CVE-2016-9773": {"epss_score": 0.00472, "epss_percentile": 0.64059}, "CVE-2016-9774": {"epss_score": 0.0007, "epss_percentile": 0.2198}, "CVE-2016-9775": {"epss_score": 0.0011, "epss_percentile": 0.3012}, "CVE-2016-9776": {"epss_score": 0.00064, "epss_percentile": 0.2021}, "CVE-2016-9777": {"epss_score": 0.00067, "epss_percentile": 0.21053}, "CVE-2016-9778": {"epss_score": 0.08178, "epss_percentile": 0.91916}, "CVE-2016-9793": {"epss_score": 0.0218, "epss_percentile": 0.83896}, "CVE-2016-9794": {"epss_score": 0.00057, "epss_percentile": 0.18194}, "CVE-2016-9795": {"epss_score": 0.0007, "epss_percentile": 0.21662}, "CVE-2016-9796": {"epss_score": 0.23667, "epss_percentile": 0.958}, "CVE-2016-9797": {"epss_score": 0.00479, "epss_percentile": 0.64419}, "CVE-2016-9798": {"epss_score": 0.00487, "epss_percentile": 0.64821}, "CVE-2016-9799": {"epss_score": 0.00476, "epss_percentile": 0.64263}, "CVE-2016-9800": {"epss_score": 0.00387, "epss_percentile": 0.59288}, "CVE-2016-9801": {"epss_score": 0.00387, "epss_percentile": 0.59288}, "CVE-2016-9802": {"epss_score": 0.00476, "epss_percentile": 0.64271}, "CVE-2016-9803": {"epss_score": 0.00422, "epss_percentile": 0.61537}, "CVE-2016-9804": {"epss_score": 0.0036, "epss_percentile": 0.57656}, "CVE-2016-9806": {"epss_score": 0.00053, "epss_percentile": 0.16791}, "CVE-2016-9807": {"epss_score": 0.00765, "epss_percentile": 0.7292}, "CVE-2016-9808": {"epss_score": 0.07194, "epss_percentile": 0.91312}, "CVE-2016-9809": {"epss_score": 0.00471, "epss_percentile": 0.64006}, "CVE-2016-9810": {"epss_score": 0.00665, "epss_percentile": 0.70658}, "CVE-2016-9811": {"epss_score": 0.00485, "epss_percentile": 0.64735}, "CVE-2016-9812": {"epss_score": 0.01408, "epss_percentile": 0.80064}, "CVE-2016-9813": {"epss_score": 0.04811, "epss_percentile": 0.89167}, "CVE-2016-9814": {"epss_score": 0.00825, "epss_percentile": 0.73957}, "CVE-2016-9815": {"epss_score": 0.0006, "epss_percentile": 0.1911}, "CVE-2016-9816": {"epss_score": 0.0006, "epss_percentile": 0.1911}, "CVE-2016-9817": {"epss_score": 0.00098, "epss_percentile": 0.27727}, "CVE-2016-9818": {"epss_score": 0.0011, "epss_percentile": 0.30161}, "CVE-2016-9819": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2016-9820": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2016-9821": {"epss_score": 0.00236, "epss_percentile": 0.46425}, "CVE-2016-9822": {"epss_score": 0.00236, "epss_percentile": 0.46425}, "CVE-2016-9823": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2016-9824": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2016-9825": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2016-9826": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2016-9827": {"epss_score": 0.00222, "epss_percentile": 0.44789}, "CVE-2016-9828": {"epss_score": 0.00222, "epss_percentile": 0.44789}, "CVE-2016-9829": {"epss_score": 0.00366, "epss_percentile": 0.58055}, "CVE-2016-9830": {"epss_score": 0.00598, "epss_percentile": 0.68762}, "CVE-2016-9831": {"epss_score": 0.00366, "epss_percentile": 0.58055}, "CVE-2016-9832": {"epss_score": 0.0726, "epss_percentile": 0.91356}, "CVE-2016-9834": {"epss_score": 0.0011, "epss_percentile": 0.30103}, "CVE-2016-9835": {"epss_score": 0.03905, "epss_percentile": 0.87925}, "CVE-2016-9836": {"epss_score": 0.00374, "epss_percentile": 0.58549}, "CVE-2016-9837": {"epss_score": 0.0001, "epss_percentile": 0.00749}, "CVE-2016-9838": {"epss_score": 0.02871, "epss_percentile": 0.85874}, "CVE-2016-9839": {"epss_score": 0.00355, "epss_percentile": 0.57315}, "CVE-2016-9840": {"epss_score": 0.13004, "epss_percentile": 0.93841}, "CVE-2016-9841": {"epss_score": 0.20281, "epss_percentile": 0.95312}, "CVE-2016-9842": {"epss_score": 0.12602, "epss_percentile": 0.93726}, "CVE-2016-9843": {"epss_score": 0.06977, "epss_percentile": 0.91156}, "CVE-2016-9844": {"epss_score": 0.0855, "epss_percentile": 0.92119}, "CVE-2016-9845": {"epss_score": 0.00095, "epss_percentile": 0.27223}, "CVE-2016-9846": {"epss_score": 0.00085, "epss_percentile": 0.25064}, "CVE-2016-9847": {"epss_score": 0.00432, "epss_percentile": 0.62135}, "CVE-2016-9848": {"epss_score": 0.00336, "epss_percentile": 0.55931}, "CVE-2016-9849": {"epss_score": 0.00295, "epss_percentile": 0.52476}, "CVE-2016-9850": {"epss_score": 0.00565, "epss_percentile": 0.67779}, "CVE-2016-9851": {"epss_score": 0.00241, "epss_percentile": 0.47263}, "CVE-2016-9852": {"epss_score": 0.00501, "epss_percentile": 0.65358}, "CVE-2016-9853": {"epss_score": 0.00851, "epss_percentile": 0.74405}, "CVE-2016-9854": {"epss_score": 0.00501, "epss_percentile": 0.65358}, "CVE-2016-9855": {"epss_score": 0.00724, "epss_percentile": 0.7204}, "CVE-2016-9856": {"epss_score": 0.00418, "epss_percentile": 0.61262}, "CVE-2016-9857": {"epss_score": 0.00418, "epss_percentile": 0.61262}, "CVE-2016-9858": {"epss_score": 0.00637, "epss_percentile": 0.69893}, "CVE-2016-9859": {"epss_score": 0.00637, "epss_percentile": 0.69893}, "CVE-2016-9860": {"epss_score": 0.01016, "epss_percentile": 0.7667}, "CVE-2016-9861": {"epss_score": 0.00246, "epss_percentile": 0.47765}, "CVE-2016-9862": {"epss_score": 0.00457, "epss_percentile": 0.63369}, "CVE-2016-9863": {"epss_score": 0.00605, "epss_percentile": 0.68983}, "CVE-2016-9864": {"epss_score": 0.00436, "epss_percentile": 0.62481}, "CVE-2016-9865": {"epss_score": 0.00662, "epss_percentile": 0.70597}, "CVE-2016-9866": {"epss_score": 0.00222, "epss_percentile": 0.44786}, "CVE-2016-9867": {"epss_score": 0.00083, "epss_percentile": 0.246}, "CVE-2016-9868": {"epss_score": 0.00053, "epss_percentile": 0.16733}, "CVE-2016-9869": {"epss_score": 0.0004, "epss_percentile": 0.11991}, "CVE-2016-9870": {"epss_score": 0.00072, "epss_percentile": 0.22251}, "CVE-2016-9871": {"epss_score": 0.00499, "epss_percentile": 0.6525}, "CVE-2016-9872": {"epss_score": 0.0028, "epss_percentile": 0.51006}, "CVE-2016-9873": {"epss_score": 0.00586, "epss_percentile": 0.68453}, "CVE-2016-9877": {"epss_score": 0.00329, "epss_percentile": 0.55405}, "CVE-2016-9878": {"epss_score": 0.04927, "epss_percentile": 0.89294}, "CVE-2016-9879": {"epss_score": 0.00322, "epss_percentile": 0.54816}, "CVE-2016-9880": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2016-9882": {"epss_score": 0.00372, "epss_percentile": 0.58463}, "CVE-2016-9885": {"epss_score": 0.00541, "epss_percentile": 0.67025}, "CVE-2016-9888": {"epss_score": 0.00369, "epss_percentile": 0.58239}, "CVE-2016-9889": {"epss_score": 0.00276, "epss_percentile": 0.50773}, "CVE-2016-9891": {"epss_score": 0.00364, "epss_percentile": 0.57929}, "CVE-2016-9892": {"epss_score": 0.00185, "epss_percentile": 0.40552}, "CVE-2016-9893": {"epss_score": 0.02683, "epss_percentile": 0.85421}, "CVE-2016-9894": {"epss_score": 0.01889, "epss_percentile": 0.82723}, "CVE-2016-9895": {"epss_score": 0.00709, "epss_percentile": 0.71696}, "CVE-2016-9896": {"epss_score": 0.01539, "epss_percentile": 0.80939}, "CVE-2016-9897": {"epss_score": 0.0395, "epss_percentile": 0.88}, "CVE-2016-9898": {"epss_score": 0.02604, "epss_percentile": 0.85216}, "CVE-2016-9899": {"epss_score": 0.38374, "epss_percentile": 0.97098}, "CVE-2016-9900": {"epss_score": 0.01368, "epss_percentile": 0.79789}, "CVE-2016-9901": {"epss_score": 0.0203, "epss_percentile": 0.83331}, "CVE-2016-9902": {"epss_score": 0.00411, "epss_percentile": 0.60867}, "CVE-2016-9903": {"epss_score": 0.0071, "epss_percentile": 0.71701}, "CVE-2016-9904": {"epss_score": 0.01192, "epss_percentile": 0.78399}, "CVE-2016-9905": {"epss_score": 0.01174, "epss_percentile": 0.78245}, "CVE-2016-9907": {"epss_score": 0.00153, "epss_percentile": 0.36621}, "CVE-2016-9908": {"epss_score": 0.00074, "epss_percentile": 0.22705}, "CVE-2016-9909": {"epss_score": 0.00463, "epss_percentile": 0.63677}, "CVE-2016-9910": {"epss_score": 0.00494, "epss_percentile": 0.65088}, "CVE-2016-9911": {"epss_score": 0.00153, "epss_percentile": 0.36621}, "CVE-2016-9912": {"epss_score": 0.00111, "epss_percentile": 0.30404}, "CVE-2016-9913": {"epss_score": 0.00071, "epss_percentile": 0.22175}, "CVE-2016-9914": {"epss_score": 0.00071, "epss_percentile": 0.22175}, "CVE-2016-9915": {"epss_score": 0.00071, "epss_percentile": 0.22175}, "CVE-2016-9916": {"epss_score": 0.00071, "epss_percentile": 0.22175}, "CVE-2016-9917": {"epss_score": 0.00454, "epss_percentile": 0.63253}, "CVE-2016-9918": {"epss_score": 0.00489, "epss_percentile": 0.64869}, "CVE-2016-9919": {"epss_score": 0.02704, "epss_percentile": 0.8546}, "CVE-2016-9920": {"epss_score": 0.44834, "epss_percentile": 0.97455}, "CVE-2016-9921": {"epss_score": 0.00104, "epss_percentile": 0.29157}, "CVE-2016-9922": {"epss_score": 0.00092, "epss_percentile": 0.26585}, "CVE-2016-9923": {"epss_score": 0.00151, "epss_percentile": 0.36365}, "CVE-2016-9924": {"epss_score": 0.00651, "epss_percentile": 0.70295}, "CVE-2016-9928": {"epss_score": 0.04514, "epss_percentile": 0.88787}, "CVE-2016-9932": {"epss_score": 0.00069, "epss_percentile": 0.2161}, "CVE-2016-9933": {"epss_score": 0.11102, "epss_percentile": 0.9322}, "CVE-2016-9934": {"epss_score": 0.11579, "epss_percentile": 0.93409}, "CVE-2016-9935": {"epss_score": 0.04393, "epss_percentile": 0.88637}, "CVE-2016-9936": {"epss_score": 0.00703, "epss_percentile": 0.71534}, "CVE-2016-9937": {"epss_score": 0.00343, "epss_percentile": 0.56443}, "CVE-2016-9938": {"epss_score": 0.01916, "epss_percentile": 0.82858}, "CVE-2016-9939": {"epss_score": 0.05919, "epss_percentile": 0.9032}, "CVE-2016-9941": {"epss_score": 0.00836, "epss_percentile": 0.74146}, "CVE-2016-9942": {"epss_score": 0.00836, "epss_percentile": 0.74146}, "CVE-2016-9949": {"epss_score": 0.0974, "epss_percentile": 0.92686}, "CVE-2016-9950": {"epss_score": 0.02092, "epss_percentile": 0.83574}, "CVE-2016-9951": {"epss_score": 0.08925, "epss_percentile": 0.92322}, "CVE-2016-9952": {"epss_score": 0.01005, "epss_percentile": 0.76545}, "CVE-2016-9953": {"epss_score": 0.01854, "epss_percentile": 0.82552}, "CVE-2016-9954": {"epss_score": 0.02062, "epss_percentile": 0.83446}, "CVE-2016-9955": {"epss_score": 0.0041, "epss_percentile": 0.60808}, "CVE-2016-9956": {"epss_score": 0.01886, "epss_percentile": 0.8271}, "CVE-2016-9957": {"epss_score": 0.00291, "epss_percentile": 0.52163}, "CVE-2016-9958": {"epss_score": 0.00313, "epss_percentile": 0.54013}, "CVE-2016-9959": {"epss_score": 0.00313, "epss_percentile": 0.54013}, "CVE-2016-9960": {"epss_score": 0.00102, "epss_percentile": 0.28831}, "CVE-2016-9961": {"epss_score": 0.02847, "epss_percentile": 0.85822}, "CVE-2016-9962": {"epss_score": 0.00214, "epss_percentile": 0.4399}, "CVE-2016-9963": {"epss_score": 0.01678, "epss_percentile": 0.81717}, "CVE-2016-9964": {"epss_score": 0.01087, "epss_percentile": 0.77429}, "CVE-2016-9965": {"epss_score": 0.00493, "epss_percentile": 0.65029}, "CVE-2016-9966": {"epss_score": 0.00493, "epss_percentile": 0.65029}, "CVE-2016-9967": {"epss_score": 0.00493, "epss_percentile": 0.65029}, "CVE-2016-9969": {"epss_score": 0.00206, "epss_percentile": 0.43004}, "CVE-2016-9972": {"epss_score": 0.00265, "epss_percentile": 0.49837}, "CVE-2016-9973": {"epss_score": 0.00255, "epss_percentile": 0.48629}, "CVE-2016-9975": {"epss_score": 0.00159, "epss_percentile": 0.37328}, "CVE-2016-9976": {"epss_score": 0.02062, "epss_percentile": 0.83445}, "CVE-2016-9977": {"epss_score": 0.01047, "epss_percentile": 0.77035}, "CVE-2016-9978": {"epss_score": 0.00204, "epss_percentile": 0.42616}, "CVE-2016-9979": {"epss_score": 0.00258, "epss_percentile": 0.49}, "CVE-2016-9980": {"epss_score": 0.00228, "epss_percentile": 0.45481}, "CVE-2016-9981": {"epss_score": 0.00452, "epss_percentile": 0.63193}, "CVE-2016-9982": {"epss_score": 0.00285, "epss_percentile": 0.51673}, "CVE-2016-9983": {"epss_score": 0.00285, "epss_percentile": 0.51673}, "CVE-2016-9984": {"epss_score": 0.02587, "epss_percentile": 0.8517}, "CVE-2016-9985": {"epss_score": 0.00048, "epss_percentile": 0.15031}, "CVE-2016-9986": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-9987": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-9988": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-9989": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2016-9990": {"epss_score": 0.00248, "epss_percentile": 0.47995}, "CVE-2016-9991": {"epss_score": 0.00164, "epss_percentile": 0.37987}, "CVE-2016-9992": {"epss_score": 0.00164, "epss_percentile": 0.37935}, "CVE-2016-9993": {"epss_score": 0.00164, "epss_percentile": 0.37935}, "CVE-2016-9994": {"epss_score": 0.00164, "epss_percentile": 0.37935}, "CVE-2016-9997": {"epss_score": 0.00292, "epss_percentile": 0.52216}, "CVE-2016-9998": {"epss_score": 0.00292, "epss_percentile": 0.52216}, "CVE-2017-0001": {"epss_score": 0.25434, "epss_percentile": 0.96027}, "CVE-2017-0002": {"epss_score": 0.14732, "epss_percentile": 0.94271}, "CVE-2017-0003": {"epss_score": 0.33607, "epss_percentile": 0.96787}, "CVE-2017-0004": {"epss_score": 0.53467, "epss_percentile": 0.97878}, "CVE-2017-0005": {"epss_score": 0.08678, "epss_percentile": 0.92194}, "CVE-2017-0006": {"epss_score": 0.26245, "epss_percentile": 0.96128}, "CVE-2017-0007": {"epss_score": 0.00905, "epss_percentile": 0.75237}, "CVE-2017-0008": {"epss_score": 0.1286, "epss_percentile": 0.93803}, "CVE-2017-0009": {"epss_score": 0.10647, "epss_percentile": 0.93057}, "CVE-2017-0010": {"epss_score": 0.25142, "epss_percentile": 0.9599}, "CVE-2017-0011": {"epss_score": 0.08427, "epss_percentile": 0.92046}, "CVE-2017-0012": {"epss_score": 0.08369, "epss_percentile": 0.92012}, "CVE-2017-0014": {"epss_score": 0.2375, "epss_percentile": 0.95812}, "CVE-2017-0015": {"epss_score": 0.26145, "epss_percentile": 0.96117}, "CVE-2017-0016": {"epss_score": 0.49202, "epss_percentile": 0.97673}, "CVE-2017-0017": {"epss_score": 0.01886, "epss_percentile": 0.82713}, "CVE-2017-0018": {"epss_score": 0.20815, "epss_percentile": 0.95417}, "CVE-2017-0019": {"epss_score": 0.03877, "epss_percentile": 0.87891}, "CVE-2017-0020": {"epss_score": 0.21743, "epss_percentile": 0.95554}, "CVE-2017-0021": {"epss_score": 0.00631, "epss_percentile": 0.69732}, "CVE-2017-0022": {"epss_score": 0.31107, "epss_percentile": 0.96588}, "CVE-2017-0023": {"epss_score": 0.27879, "epss_percentile": 0.9629}, "CVE-2017-0024": {"epss_score": 0.06734, "epss_percentile": 0.90992}, "CVE-2017-0025": {"epss_score": 0.01252, "epss_percentile": 0.78905}, "CVE-2017-0026": {"epss_score": 0.06734, "epss_percentile": 0.90992}, "CVE-2017-0027": {"epss_score": 0.29737, "epss_percentile": 0.96469}, "CVE-2017-0028": {"epss_score": 0.19629, "epss_percentile": 0.95217}, "CVE-2017-0029": {"epss_score": 0.22643, "epss_percentile": 0.95664}, "CVE-2017-0030": {"epss_score": 0.33593, "epss_percentile": 0.96786}, "CVE-2017-0031": {"epss_score": 0.32508, "epss_percentile": 0.96706}, "CVE-2017-0032": {"epss_score": 0.16013, "epss_percentile": 0.94558}, "CVE-2017-0033": {"epss_score": 0.10334, "epss_percentile": 0.92949}, "CVE-2017-0034": {"epss_score": 0.23582, "epss_percentile": 0.95794}, "CVE-2017-0035": {"epss_score": 0.16013, "epss_percentile": 0.94558}, "CVE-2017-0037": {"epss_score": 0.91983, "epss_percentile": 0.99683}, "CVE-2017-0038": {"epss_score": 0.82234, "epss_percentile": 0.99181}, "CVE-2017-0039": {"epss_score": 0.2493, "epss_percentile": 0.95968}, "CVE-2017-0040": {"epss_score": 0.18742, "epss_percentile": 0.95062}, "CVE-2017-0042": {"epss_score": 0.1516, "epss_percentile": 0.94376}, "CVE-2017-0043": {"epss_score": 0.05993, "epss_percentile": 0.90388}, "CVE-2017-0045": {"epss_score": 0.0364, "epss_percentile": 0.87489}, "CVE-2017-0047": {"epss_score": 0.01714, "epss_percentile": 0.81894}, "CVE-2017-0049": {"epss_score": 0.20639, "epss_percentile": 0.95392}, "CVE-2017-0050": {"epss_score": 0.03663, "epss_percentile": 0.8753}, "CVE-2017-0051": {"epss_score": 0.00514, "epss_percentile": 0.65953}, "CVE-2017-0052": {"epss_score": 0.26245, "epss_percentile": 0.96128}, "CVE-2017-0053": {"epss_score": 0.23473, "epss_percentile": 0.95782}, "CVE-2017-0055": {"epss_score": 0.01696, "epss_percentile": 0.81811}, "CVE-2017-0056": {"epss_score": 0.06734, "epss_percentile": 0.90992}, "CVE-2017-0057": {"epss_score": 0.31132, "epss_percentile": 0.96596}, "CVE-2017-0058": {"epss_score": 0.16494, "epss_percentile": 0.94679}, "CVE-2017-0059": {"epss_score": 0.86139, "epss_percentile": 0.99369}, "CVE-2017-0060": {"epss_score": 0.03764, "epss_percentile": 0.87692}, "CVE-2017-0061": {"epss_score": 0.18487, "epss_percentile": 0.95023}, "CVE-2017-0062": {"epss_score": 0.02515, "epss_percentile": 0.84981}, "CVE-2017-0063": {"epss_score": 0.16295, "epss_percentile": 0.94612}, "CVE-2017-0064": {"epss_score": 0.22416, "epss_percentile": 0.95633}, "CVE-2017-0065": {"epss_score": 0.27177, "epss_percentile": 0.96217}, "CVE-2017-0066": {"epss_score": 0.21775, "epss_percentile": 0.95558}, "CVE-2017-0067": {"epss_score": 0.16013, "epss_percentile": 0.94558}, "CVE-2017-0068": {"epss_score": 0.23062, "epss_percentile": 0.95727}, "CVE-2017-0069": {"epss_score": 0.07951, "epss_percentile": 0.91784}, "CVE-2017-0070": {"epss_score": 0.80217, "epss_percentile": 0.99076}, "CVE-2017-0071": {"epss_score": 0.26145, "epss_percentile": 0.96117}, "CVE-2017-0072": {"epss_score": 0.18339, "epss_percentile": 0.94998}, "CVE-2017-0073": {"epss_score": 0.11311, "epss_percentile": 0.93302}, "CVE-2017-0074": {"epss_score": 0.00585, "epss_percentile": 0.68417}, "CVE-2017-0075": {"epss_score": 0.04458, "epss_percentile": 0.88715}, "CVE-2017-0076": {"epss_score": 0.00651, "epss_percentile": 0.70295}, "CVE-2017-0077": {"epss_score": 0.04643, "epss_percentile": 0.88955}, "CVE-2017-0078": {"epss_score": 0.0553, "epss_percentile": 0.89965}, "CVE-2017-0079": {"epss_score": 0.05407, "epss_percentile": 0.89839}, "CVE-2017-0080": {"epss_score": 0.0553, "epss_percentile": 0.89965}, "CVE-2017-0081": {"epss_score": 0.0553, "epss_percentile": 0.89965}, "CVE-2017-0082": {"epss_score": 0.0553, "epss_percentile": 0.89965}, "CVE-2017-0083": {"epss_score": 0.25807, "epss_percentile": 0.96073}, "CVE-2017-0084": {"epss_score": 0.22725, "epss_percentile": 0.95674}, "CVE-2017-0085": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0086": {"epss_score": 0.25807, "epss_percentile": 0.96073}, "CVE-2017-0087": {"epss_score": 0.25807, "epss_percentile": 0.96073}, "CVE-2017-0088": {"epss_score": 0.25807, "epss_percentile": 0.96073}, "CVE-2017-0089": {"epss_score": 0.62388, "epss_percentile": 0.98291}, "CVE-2017-0090": {"epss_score": 0.25807, "epss_percentile": 0.96073}, "CVE-2017-0091": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0092": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0093": {"epss_score": 0.21418, "epss_percentile": 0.95515}, "CVE-2017-0094": {"epss_score": 0.32465, "epss_percentile": 0.96702}, "CVE-2017-0095": {"epss_score": 0.01164, "epss_percentile": 0.78162}, "CVE-2017-0096": {"epss_score": 0.01077, "epss_percentile": 0.77332}, "CVE-2017-0097": {"epss_score": 0.00585, "epss_percentile": 0.68417}, "CVE-2017-0098": {"epss_score": 0.00623, "epss_percentile": 0.69554}, "CVE-2017-0099": {"epss_score": 0.00585, "epss_percentile": 0.68417}, "CVE-2017-0100": {"epss_score": 0.38287, "epss_percentile": 0.97093}, "CVE-2017-0101": {"epss_score": 0.63791, "epss_percentile": 0.98348}, "CVE-2017-0102": {"epss_score": 0.00687, "epss_percentile": 0.71176}, "CVE-2017-0103": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2017-0104": {"epss_score": 0.34862, "epss_percentile": 0.96876}, "CVE-2017-0105": {"epss_score": 0.4318, "epss_percentile": 0.97374}, "CVE-2017-0106": {"epss_score": 0.10809, "epss_percentile": 0.93111}, "CVE-2017-0107": {"epss_score": 0.02318, "epss_percentile": 0.84361}, "CVE-2017-0108": {"epss_score": 0.36288, "epss_percentile": 0.96966}, "CVE-2017-0109": {"epss_score": 0.00577, "epss_percentile": 0.68171}, "CVE-2017-0110": {"epss_score": 0.01205, "epss_percentile": 0.78515}, "CVE-2017-0111": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0112": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0113": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0114": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0115": {"epss_score": 0.07148, "epss_percentile": 0.91284}, "CVE-2017-0116": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0117": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0118": {"epss_score": 0.13744, "epss_percentile": 0.94047}, "CVE-2017-0119": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0120": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0121": {"epss_score": 0.1578, "epss_percentile": 0.94508}, "CVE-2017-0122": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0123": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0124": {"epss_score": 0.07148, "epss_percentile": 0.91284}, "CVE-2017-0125": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0126": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0127": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0128": {"epss_score": 0.1081, "epss_percentile": 0.93117}, "CVE-2017-0129": {"epss_score": 0.01738, "epss_percentile": 0.82026}, "CVE-2017-0130": {"epss_score": 0.17567, "epss_percentile": 0.94867}, "CVE-2017-0131": {"epss_score": 0.16013, "epss_percentile": 0.94558}, "CVE-2017-0132": {"epss_score": 0.16013, "epss_percentile": 0.94558}, "CVE-2017-0133": {"epss_score": 0.16013, "epss_percentile": 0.94558}, "CVE-2017-0134": {"epss_score": 0.26145, "epss_percentile": 0.96117}, "CVE-2017-0135": {"epss_score": 0.22472, "epss_percentile": 0.95639}, "CVE-2017-0136": {"epss_score": 0.16013, "epss_percentile": 0.94558}, "CVE-2017-0137": {"epss_score": 0.16013, "epss_percentile": 0.94558}, "CVE-2017-0138": {"epss_score": 0.16013, "epss_percentile": 0.94558}, "CVE-2017-0140": {"epss_score": 0.13465, "epss_percentile": 0.93973}, "CVE-2017-0141": {"epss_score": 0.54756, "epss_percentile": 0.97942}, "CVE-2017-0143": {"epss_score": 0.94022, "epss_percentile": 0.99887}, "CVE-2017-0144": {"epss_score": 0.94318, "epss_percentile": 0.99945}, "CVE-2017-0145": {"epss_score": 0.93343, "epss_percentile": 0.99798}, "CVE-2017-0146": {"epss_score": 0.9373, "epss_percentile": 0.99837}, "CVE-2017-0147": {"epss_score": 0.92418, "epss_percentile": 0.99714}, "CVE-2017-0148": {"epss_score": 0.94067, "epss_percentile": 0.99896}, "CVE-2017-0149": {"epss_score": 0.4146, "epss_percentile": 0.97275}, "CVE-2017-0150": {"epss_score": 0.16013, "epss_percentile": 0.94558}, "CVE-2017-0151": {"epss_score": 0.16013, "epss_percentile": 0.94558}, "CVE-2017-0152": {"epss_score": 0.14554, "epss_percentile": 0.94239}, "CVE-2017-0154": {"epss_score": 0.01348, "epss_percentile": 0.79663}, "CVE-2017-0155": {"epss_score": 0.10557, "epss_percentile": 0.93028}, "CVE-2017-0156": {"epss_score": 0.01085, "epss_percentile": 0.77401}, "CVE-2017-0158": {"epss_score": 0.20303, "epss_percentile": 0.95318}, "CVE-2017-0159": {"epss_score": 0.05447, "epss_percentile": 0.89888}, "CVE-2017-0160": {"epss_score": 0.14415, "epss_percentile": 0.94207}, "CVE-2017-0161": {"epss_score": 0.13764, "epss_percentile": 0.94053}, "CVE-2017-0162": {"epss_score": 0.00365, "epss_percentile": 0.58012}, "CVE-2017-0163": {"epss_score": 0.00382, "epss_percentile": 0.59045}, "CVE-2017-0164": {"epss_score": 0.05366, "epss_percentile": 0.8979}, "CVE-2017-0165": {"epss_score": 0.12685, "epss_percentile": 0.93749}, "CVE-2017-0166": {"epss_score": 0.01531, "epss_percentile": 0.80888}, "CVE-2017-0167": {"epss_score": 0.14108, "epss_percentile": 0.94133}, "CVE-2017-0168": {"epss_score": 0.00852, "epss_percentile": 0.74417}, "CVE-2017-0169": {"epss_score": 0.00518, "epss_percentile": 0.66124}, "CVE-2017-0170": {"epss_score": 0.18028, "epss_percentile": 0.94945}, "CVE-2017-0171": {"epss_score": 0.21484, "epss_percentile": 0.95524}, "CVE-2017-0173": {"epss_score": 0.00581, "epss_percentile": 0.68277}, "CVE-2017-0174": {"epss_score": 0.00483, "epss_percentile": 0.64574}, "CVE-2017-0175": {"epss_score": 0.02541, "epss_percentile": 0.8505}, "CVE-2017-0176": {"epss_score": 0.57669, "epss_percentile": 0.98078}, "CVE-2017-0178": {"epss_score": 0.0017, "epss_percentile": 0.38755}, "CVE-2017-0179": {"epss_score": 0.00389, "epss_percentile": 0.59412}, "CVE-2017-0180": {"epss_score": 0.00382, "epss_percentile": 0.59045}, "CVE-2017-0181": {"epss_score": 0.00365, "epss_percentile": 0.58012}, "CVE-2017-0182": {"epss_score": 0.00389, "epss_percentile": 0.59412}, "CVE-2017-0183": {"epss_score": 0.00389, "epss_percentile": 0.59412}, "CVE-2017-0184": {"epss_score": 0.0017, "epss_percentile": 0.38755}, "CVE-2017-0185": {"epss_score": 0.00563, "epss_percentile": 0.67741}, "CVE-2017-0186": {"epss_score": 0.00389, "epss_percentile": 0.59412}, "CVE-2017-0188": {"epss_score": 0.05109, "epss_percentile": 0.89507}, "CVE-2017-0189": {"epss_score": 0.00978, "epss_percentile": 0.76233}, "CVE-2017-0190": {"epss_score": 0.01149, "epss_percentile": 0.78021}, "CVE-2017-0191": {"epss_score": 0.01653, "epss_percentile": 0.81579}, "CVE-2017-0192": {"epss_score": 0.22919, "epss_percentile": 0.95706}, "CVE-2017-0193": {"epss_score": 0.00986, "epss_percentile": 0.76333}, "CVE-2017-0194": {"epss_score": 0.44218, "epss_percentile": 0.97425}, "CVE-2017-0195": {"epss_score": 0.01115, "epss_percentile": 0.77715}, "CVE-2017-0196": {"epss_score": 0.19086, "epss_percentile": 0.95127}, "CVE-2017-0197": {"epss_score": 0.27808, "epss_percentile": 0.96284}, "CVE-2017-0199": {"epss_score": 0.94366, "epss_percentile": 0.9996}, "CVE-2017-0200": {"epss_score": 0.29434, "epss_percentile": 0.96442}, "CVE-2017-0201": {"epss_score": 0.2391, "epss_percentile": 0.95832}, "CVE-2017-0202": {"epss_score": 0.61873, "epss_percentile": 0.98265}, "CVE-2017-0203": {"epss_score": 0.04512, "epss_percentile": 0.88782}, "CVE-2017-0204": {"epss_score": 0.11657, "epss_percentile": 0.93436}, "CVE-2017-0205": {"epss_score": 0.2391, "epss_percentile": 0.95832}, "CVE-2017-0207": {"epss_score": 0.11655, "epss_percentile": 0.93435}, "CVE-2017-0208": {"epss_score": 0.19075, "epss_percentile": 0.95125}, "CVE-2017-0210": {"epss_score": 0.3644, "epss_percentile": 0.96978}, "CVE-2017-0211": {"epss_score": 0.17576, "epss_percentile": 0.94869}, "CVE-2017-0212": {"epss_score": 0.00351, "epss_percentile": 0.57045}, "CVE-2017-0213": {"epss_score": 0.92686, "epss_percentile": 0.99735}, "CVE-2017-0214": {"epss_score": 0.01794, "epss_percentile": 0.82291}, "CVE-2017-0215": {"epss_score": 0.48183, "epss_percentile": 0.97625}, "CVE-2017-0216": {"epss_score": 0.00581, "epss_percentile": 0.68277}, "CVE-2017-0218": {"epss_score": 0.02004, "epss_percentile": 0.83227}, "CVE-2017-0219": {"epss_score": 0.00581, "epss_percentile": 0.68277}, "CVE-2017-0220": {"epss_score": 0.04008, "epss_percentile": 0.88104}, "CVE-2017-0221": {"epss_score": 0.17251, "epss_percentile": 0.94809}, "CVE-2017-0222": {"epss_score": 0.61982, "epss_percentile": 0.98271}, "CVE-2017-0223": {"epss_score": 0.36015, "epss_percentile": 0.96949}, "CVE-2017-0224": {"epss_score": 0.27583, "epss_percentile": 0.9626}, "CVE-2017-0226": {"epss_score": 0.2401, "epss_percentile": 0.95843}, "CVE-2017-0227": {"epss_score": 0.21965, "epss_percentile": 0.95579}, "CVE-2017-0228": {"epss_score": 0.38059, "epss_percentile": 0.97083}, "CVE-2017-0229": {"epss_score": 0.2401, "epss_percentile": 0.95843}, "CVE-2017-0230": {"epss_score": 0.2401, "epss_percentile": 0.95843}, "CVE-2017-0231": {"epss_score": 0.08539, "epss_percentile": 0.92111}, "CVE-2017-0233": {"epss_score": 0.02619, "epss_percentile": 0.85253}, "CVE-2017-0234": {"epss_score": 0.55566, "epss_percentile": 0.97985}, "CVE-2017-0235": {"epss_score": 0.27041, "epss_percentile": 0.96199}, "CVE-2017-0236": {"epss_score": 0.55566, "epss_percentile": 0.97985}, "CVE-2017-0238": {"epss_score": 0.23478, "epss_percentile": 0.95784}, "CVE-2017-0240": {"epss_score": 0.29434, "epss_percentile": 0.96442}, "CVE-2017-0241": {"epss_score": 0.15019, "epss_percentile": 0.94345}, "CVE-2017-0242": {"epss_score": 0.07627, "epss_percentile": 0.91582}, "CVE-2017-0243": {"epss_score": 0.34044, "epss_percentile": 0.96823}, "CVE-2017-0244": {"epss_score": 0.01477, "epss_percentile": 0.80545}, "CVE-2017-0245": {"epss_score": 0.11171, "epss_percentile": 0.93252}, "CVE-2017-0246": {"epss_score": 0.16582, "epss_percentile": 0.94697}, "CVE-2017-0247": {"epss_score": 0.11122, "epss_percentile": 0.93229}, "CVE-2017-0248": {"epss_score": 0.01092, "epss_percentile": 0.7747}, "CVE-2017-0249": {"epss_score": 0.05786, "epss_percentile": 0.90207}, "CVE-2017-0250": {"epss_score": 0.23522, "epss_percentile": 0.95789}, "CVE-2017-0252": {"epss_score": 0.24319, "epss_percentile": 0.95903}, "CVE-2017-0254": {"epss_score": 0.32629, "epss_percentile": 0.96713}, "CVE-2017-0255": {"epss_score": 0.01164, "epss_percentile": 0.78169}, "CVE-2017-0256": {"epss_score": 0.04349, "epss_percentile": 0.88582}, "CVE-2017-0258": {"epss_score": 0.04725, "epss_percentile": 0.89062}, "CVE-2017-0259": {"epss_score": 0.02372, "epss_percentile": 0.84529}, "CVE-2017-0260": {"epss_score": 0.28434, "epss_percentile": 0.96358}, "CVE-2017-0261": {"epss_score": 0.92255, "epss_percentile": 0.99703}, "CVE-2017-0262": {"epss_score": 0.649, "epss_percentile": 0.98397}, "CVE-2017-0263": {"epss_score": 0.17285, "epss_percentile": 0.94816}, "CVE-2017-0264": {"epss_score": 0.29025, "epss_percentile": 0.96412}, "CVE-2017-0265": {"epss_score": 0.28715, "epss_percentile": 0.96378}, "CVE-2017-0266": {"epss_score": 0.53213, "epss_percentile": 0.97863}, "CVE-2017-0267": {"epss_score": 0.25205, "epss_percentile": 0.95998}, "CVE-2017-0268": {"epss_score": 0.15552, "epss_percentile": 0.94456}, "CVE-2017-0269": {"epss_score": 0.09629, "epss_percentile": 0.92631}, "CVE-2017-0270": {"epss_score": 0.15552, "epss_percentile": 0.94456}, "CVE-2017-0271": {"epss_score": 0.26164, "epss_percentile": 0.96119}, "CVE-2017-0272": {"epss_score": 0.05522, "epss_percentile": 0.89959}, "CVE-2017-0273": {"epss_score": 0.09629, "epss_percentile": 0.92631}, "CVE-2017-0274": {"epss_score": 0.15552, "epss_percentile": 0.94456}, "CVE-2017-0275": {"epss_score": 0.05417, "epss_percentile": 0.89852}, "CVE-2017-0276": {"epss_score": 0.028, "epss_percentile": 0.85696}, "CVE-2017-0277": {"epss_score": 0.01985, "epss_percentile": 0.83154}, "CVE-2017-0278": {"epss_score": 0.0149, "epss_percentile": 0.80627}, "CVE-2017-0279": {"epss_score": 0.01985, "epss_percentile": 0.83154}, "CVE-2017-0280": {"epss_score": 0.03621, "epss_percentile": 0.87442}, "CVE-2017-0281": {"epss_score": 0.4333, "epss_percentile": 0.97382}, "CVE-2017-0282": {"epss_score": 0.10482, "epss_percentile": 0.93003}, "CVE-2017-0283": {"epss_score": 0.55105, "epss_percentile": 0.97959}, "CVE-2017-0284": {"epss_score": 0.10482, "epss_percentile": 0.93003}, "CVE-2017-0285": {"epss_score": 0.10482, "epss_percentile": 0.93003}, "CVE-2017-0286": {"epss_score": 0.09257, "epss_percentile": 0.92468}, "CVE-2017-0287": {"epss_score": 0.07809, "epss_percentile": 0.91693}, "CVE-2017-0288": {"epss_score": 0.11408, "epss_percentile": 0.93338}, "CVE-2017-0289": {"epss_score": 0.09448, "epss_percentile": 0.92552}, "CVE-2017-0290": {"epss_score": 0.90288, "epss_percentile": 0.99575}, "CVE-2017-0291": {"epss_score": 0.28742, "epss_percentile": 0.9638}, "CVE-2017-0292": {"epss_score": 0.28434, "epss_percentile": 0.96358}, "CVE-2017-0293": {"epss_score": 0.22532, "epss_percentile": 0.95648}, "CVE-2017-0294": {"epss_score": 0.28742, "epss_percentile": 0.9638}, "CVE-2017-0295": {"epss_score": 0.00529, "epss_percentile": 0.66581}, "CVE-2017-0296": {"epss_score": 0.00273, "epss_percentile": 0.50449}, "CVE-2017-0297": {"epss_score": 0.02767, "epss_percentile": 0.85613}, "CVE-2017-0298": {"epss_score": 0.00872, "epss_percentile": 0.74722}, "CVE-2017-0299": {"epss_score": 0.04678, "epss_percentile": 0.88999}, "CVE-2017-0300": {"epss_score": 0.08833, "epss_percentile": 0.92276}, "CVE-2017-0301": {"epss_score": 0.00134, "epss_percentile": 0.33769}, "CVE-2017-0302": {"epss_score": 0.00314, "epss_percentile": 0.54093}, "CVE-2017-0303": {"epss_score": 0.02438, "epss_percentile": 0.84747}, "CVE-2017-0304": {"epss_score": 0.00171, "epss_percentile": 0.38848}, "CVE-2017-0305": {"epss_score": 0.02895, "epss_percentile": 0.85924}, "CVE-2017-0306": {"epss_score": 0.00224, "epss_percentile": 0.45051}, "CVE-2017-0307": {"epss_score": 0.00224, "epss_percentile": 0.45051}, "CVE-2017-0308": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0309": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0310": {"epss_score": 0.00039, "epss_percentile": 0.11612}, "CVE-2017-0311": {"epss_score": 0.00036, "epss_percentile": 0.10215}, "CVE-2017-0312": {"epss_score": 0.00253, "epss_percentile": 0.48446}, "CVE-2017-0313": {"epss_score": 0.00289, "epss_percentile": 0.52005}, "CVE-2017-0314": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0315": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0316": {"epss_score": 0.00045, "epss_percentile": 0.13935}, "CVE-2017-0317": {"epss_score": 0.00036, "epss_percentile": 0.10497}, "CVE-2017-0318": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2017-0319": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2017-0320": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2017-0321": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0322": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0323": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0324": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0325": {"epss_score": 0.00172, "epss_percentile": 0.3898}, "CVE-2017-0326": {"epss_score": 0.00109, "epss_percentile": 0.29995}, "CVE-2017-0327": {"epss_score": 0.00172, "epss_percentile": 0.3898}, "CVE-2017-0328": {"epss_score": 0.00223, "epss_percentile": 0.44863}, "CVE-2017-0329": {"epss_score": 0.00166, "epss_percentile": 0.38183}, "CVE-2017-0330": {"epss_score": 0.00247, "epss_percentile": 0.47841}, "CVE-2017-0331": {"epss_score": 0.00061, "epss_percentile": 0.19262}, "CVE-2017-0332": {"epss_score": 0.00157, "epss_percentile": 0.37067}, "CVE-2017-0333": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0334": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2017-0335": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0336": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2017-0337": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0338": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0339": {"epss_score": 0.00182, "epss_percentile": 0.40207}, "CVE-2017-0340": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0341": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0342": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0343": {"epss_score": 0.00032, "epss_percentile": 0.09006}, "CVE-2017-0344": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2017-0345": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0346": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0347": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0348": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0349": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0350": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0351": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-0352": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2017-0353": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2017-0354": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2017-0355": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2017-0356": {"epss_score": 0.07441, "epss_percentile": 0.91474}, "CVE-2017-0357": {"epss_score": 0.01604, "epss_percentile": 0.8128}, "CVE-2017-0358": {"epss_score": 0.07546, "epss_percentile": 0.9153}, "CVE-2017-0359": {"epss_score": 0.00591, "epss_percentile": 0.68599}, "CVE-2017-0360": {"epss_score": 0.00317, "epss_percentile": 0.54364}, "CVE-2017-0361": {"epss_score": 0.00079, "epss_percentile": 0.23809}, "CVE-2017-0362": {"epss_score": 0.0015, "epss_percentile": 0.36124}, "CVE-2017-0363": {"epss_score": 0.00205, "epss_percentile": 0.42752}, "CVE-2017-0364": {"epss_score": 0.00205, "epss_percentile": 0.42752}, "CVE-2017-0365": {"epss_score": 0.00303, "epss_percentile": 0.53183}, "CVE-2017-0366": {"epss_score": 0.00387, "epss_percentile": 0.59301}, "CVE-2017-0367": {"epss_score": 0.00516, "epss_percentile": 0.66013}, "CVE-2017-0368": {"epss_score": 0.00236, "epss_percentile": 0.4642}, "CVE-2017-0369": {"epss_score": 0.00141, "epss_percentile": 0.34842}, "CVE-2017-0370": {"epss_score": 0.00236, "epss_percentile": 0.4642}, "CVE-2017-0371": {"epss_score": 0.00212, "epss_percentile": 0.43801}, "CVE-2017-0372": {"epss_score": 0.58351, "epss_percentile": 0.98111}, "CVE-2017-0373": {"epss_score": 0.00488, "epss_percentile": 0.64833}, "CVE-2017-0374": {"epss_score": 0.0004, "epss_percentile": 0.11891}, "CVE-2017-0375": {"epss_score": 0.01397, "epss_percentile": 0.79987}, "CVE-2017-0376": {"epss_score": 0.00819, "epss_percentile": 0.73868}, "CVE-2017-0377": {"epss_score": 0.00476, "epss_percentile": 0.64283}, "CVE-2017-0378": {"epss_score": 0.00536, "epss_percentile": 0.66851}, "CVE-2017-0379": {"epss_score": 0.01856, "epss_percentile": 0.82573}, "CVE-2017-0380": {"epss_score": 0.0044, "epss_percentile": 0.62618}, "CVE-2017-0381": {"epss_score": 0.00134, "epss_percentile": 0.33905}, "CVE-2017-0382": {"epss_score": 0.00275, "epss_percentile": 0.50648}, "CVE-2017-0383": {"epss_score": 0.00049, "epss_percentile": 0.15464}, "CVE-2017-0384": {"epss_score": 0.00065, "epss_percentile": 0.20674}, "CVE-2017-0385": {"epss_score": 0.00049, "epss_percentile": 0.15464}, "CVE-2017-0386": {"epss_score": 0.00138, "epss_percentile": 0.34503}, "CVE-2017-0387": {"epss_score": 0.00049, "epss_percentile": 0.15464}, "CVE-2017-0388": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2017-0389": {"epss_score": 0.0034, "epss_percentile": 0.56244}, "CVE-2017-0390": {"epss_score": 0.0017, "epss_percentile": 0.38669}, "CVE-2017-0391": {"epss_score": 0.00173, "epss_percentile": 0.39063}, "CVE-2017-0392": {"epss_score": 0.0017, "epss_percentile": 0.38669}, "CVE-2017-0393": {"epss_score": 0.00414, "epss_percentile": 0.61029}, "CVE-2017-0394": {"epss_score": 0.00327, "epss_percentile": 0.55138}, "CVE-2017-0395": {"epss_score": 0.00047, "epss_percentile": 0.14636}, "CVE-2017-0396": {"epss_score": 0.00091, "epss_percentile": 0.26292}, "CVE-2017-0397": {"epss_score": 0.00091, "epss_percentile": 0.26292}, "CVE-2017-0398": {"epss_score": 0.00071, "epss_percentile": 0.22088}, "CVE-2017-0399": {"epss_score": 0.00091, "epss_percentile": 0.26292}, "CVE-2017-0400": {"epss_score": 0.00154, "epss_percentile": 0.36735}, "CVE-2017-0401": {"epss_score": 0.00091, "epss_percentile": 0.26292}, "CVE-2017-0402": {"epss_score": 0.00112, "epss_percentile": 0.3057}, "CVE-2017-0403": {"epss_score": 0.00241, "epss_percentile": 0.4724}, "CVE-2017-0404": {"epss_score": 0.00241, "epss_percentile": 0.4724}, "CVE-2017-0405": {"epss_score": 0.01737, "epss_percentile": 0.82018}, "CVE-2017-0406": {"epss_score": 0.01737, "epss_percentile": 0.82018}, "CVE-2017-0407": {"epss_score": 0.01737, "epss_percentile": 0.82018}, "CVE-2017-0408": {"epss_score": 0.0096, "epss_percentile": 0.7597}, "CVE-2017-0409": {"epss_score": 0.0104, "epss_percentile": 0.76962}, "CVE-2017-0410": {"epss_score": 0.00134, "epss_percentile": 0.33864}, "CVE-2017-0411": {"epss_score": 0.03261, "epss_percentile": 0.86771}, "CVE-2017-0412": {"epss_score": 0.00938, "epss_percentile": 0.75703}, "CVE-2017-0413": {"epss_score": 0.00218, "epss_percentile": 0.44342}, "CVE-2017-0414": {"epss_score": 0.00106, "epss_percentile": 0.29474}, "CVE-2017-0415": {"epss_score": 0.00127, "epss_percentile": 0.32878}, "CVE-2017-0416": {"epss_score": 0.00127, "epss_percentile": 0.32878}, "CVE-2017-0417": {"epss_score": 0.00127, "epss_percentile": 0.32878}, "CVE-2017-0418": {"epss_score": 0.00127, "epss_percentile": 0.32878}, "CVE-2017-0419": {"epss_score": 0.00127, "epss_percentile": 0.32878}, "CVE-2017-0420": {"epss_score": 0.0016, "epss_percentile": 0.37473}, "CVE-2017-0421": {"epss_score": 0.00106, "epss_percentile": 0.29474}, "CVE-2017-0422": {"epss_score": 0.01038, "epss_percentile": 0.76931}, "CVE-2017-0423": {"epss_score": 0.00084, "epss_percentile": 0.24996}, "CVE-2017-0424": {"epss_score": 0.00121, "epss_percentile": 0.31921}, "CVE-2017-0425": {"epss_score": 0.00166, "epss_percentile": 0.38184}, "CVE-2017-0426": {"epss_score": 0.0027, "epss_percentile": 0.5023}, "CVE-2017-0427": {"epss_score": 0.00112, "epss_percentile": 0.30446}, "CVE-2017-0428": {"epss_score": 0.00126, "epss_percentile": 0.32744}, "CVE-2017-0429": {"epss_score": 0.00126, "epss_percentile": 0.32744}, "CVE-2017-0430": {"epss_score": 0.00126, "epss_percentile": 0.32744}, "CVE-2017-0431": {"epss_score": 0.00028, "epss_percentile": 0.07315}, "CVE-2017-0432": {"epss_score": 0.0026, "epss_percentile": 0.49179}, "CVE-2017-0433": {"epss_score": 0.00112, "epss_percentile": 0.30446}, "CVE-2017-0434": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2017-0435": {"epss_score": 0.00135, "epss_percentile": 0.33997}, "CVE-2017-0436": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2017-0437": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2017-0438": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2017-0439": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2017-0440": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2017-0441": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2017-0442": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2017-0443": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2017-0444": {"epss_score": 0.0013, "epss_percentile": 0.33287}, "CVE-2017-0445": {"epss_score": 0.00112, "epss_percentile": 0.30446}, "CVE-2017-0446": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2017-0447": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2017-0448": {"epss_score": 0.00166, "epss_percentile": 0.38184}, "CVE-2017-0449": {"epss_score": 0.00128, "epss_percentile": 0.32982}, "CVE-2017-0450": {"epss_score": 0.00127, "epss_percentile": 0.32878}, "CVE-2017-0451": {"epss_score": 0.00088, "epss_percentile": 0.25749}, "CVE-2017-0452": {"epss_score": 0.00255, "epss_percentile": 0.48726}, "CVE-2017-0453": {"epss_score": 0.00224, "epss_percentile": 0.45051}, "CVE-2017-0454": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0455": {"epss_score": 0.00224, "epss_percentile": 0.45051}, "CVE-2017-0456": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0457": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0458": {"epss_score": 0.00224, "epss_percentile": 0.45051}, "CVE-2017-0459": {"epss_score": 0.00283, "epss_percentile": 0.51388}, "CVE-2017-0460": {"epss_score": 0.00224, "epss_percentile": 0.45051}, "CVE-2017-0461": {"epss_score": 0.00283, "epss_percentile": 0.51388}, "CVE-2017-0462": {"epss_score": 0.00176, "epss_percentile": 0.3938}, "CVE-2017-0463": {"epss_score": 0.00226, "epss_percentile": 0.45242}, "CVE-2017-0464": {"epss_score": 0.00224, "epss_percentile": 0.45051}, "CVE-2017-0465": {"epss_score": 0.00052, "epss_percentile": 0.16644}, "CVE-2017-0466": {"epss_score": 0.004, "epss_percentile": 0.60165}, "CVE-2017-0467": {"epss_score": 0.004, "epss_percentile": 0.60165}, "CVE-2017-0468": {"epss_score": 0.004, "epss_percentile": 0.60165}, "CVE-2017-0469": {"epss_score": 0.004, "epss_percentile": 0.60165}, "CVE-2017-0470": {"epss_score": 0.004, "epss_percentile": 0.60165}, "CVE-2017-0471": {"epss_score": 0.004, "epss_percentile": 0.60165}, "CVE-2017-0472": {"epss_score": 0.004, "epss_percentile": 0.60165}, "CVE-2017-0473": {"epss_score": 0.004, "epss_percentile": 0.60165}, "CVE-2017-0474": {"epss_score": 0.02868, "epss_percentile": 0.85868}, "CVE-2017-0475": {"epss_score": 0.00104, "epss_percentile": 0.29152}, "CVE-2017-0476": {"epss_score": 0.00315, "epss_percentile": 0.54187}, "CVE-2017-0477": {"epss_score": 0.00315, "epss_percentile": 0.54187}, "CVE-2017-0478": {"epss_score": 0.06463, "epss_percentile": 0.90771}, "CVE-2017-0479": {"epss_score": 0.0006, "epss_percentile": 0.18973}, "CVE-2017-0480": {"epss_score": 0.00064, "epss_percentile": 0.20382}, "CVE-2017-0481": {"epss_score": 0.00056, "epss_percentile": 0.17924}, "CVE-2017-0482": {"epss_score": 0.00284, "epss_percentile": 0.51429}, "CVE-2017-0483": {"epss_score": 0.00284, "epss_percentile": 0.51442}, "CVE-2017-0484": {"epss_score": 0.00284, "epss_percentile": 0.51442}, "CVE-2017-0485": {"epss_score": 0.00284, "epss_percentile": 0.51429}, "CVE-2017-0486": {"epss_score": 0.00284, "epss_percentile": 0.51429}, "CVE-2017-0487": {"epss_score": 0.00284, "epss_percentile": 0.51429}, "CVE-2017-0488": {"epss_score": 0.00284, "epss_percentile": 0.51442}, "CVE-2017-0489": {"epss_score": 0.00107, "epss_percentile": 0.29687}, "CVE-2017-0490": {"epss_score": 0.00095, "epss_percentile": 0.27196}, "CVE-2017-0491": {"epss_score": 0.00072, "epss_percentile": 0.22364}, "CVE-2017-0492": {"epss_score": 0.00084, "epss_percentile": 0.24874}, "CVE-2017-0493": {"epss_score": 0.00035, "epss_percentile": 0.10128}, "CVE-2017-0494": {"epss_score": 0.00205, "epss_percentile": 0.42681}, "CVE-2017-0495": {"epss_score": 0.00125, "epss_percentile": 0.32563}, "CVE-2017-0496": {"epss_score": 0.00086, "epss_percentile": 0.25433}, "CVE-2017-0497": {"epss_score": 0.00147, "epss_percentile": 0.35784}, "CVE-2017-0498": {"epss_score": 0.00023, "epss_percentile": 0.05375}, "CVE-2017-0499": {"epss_score": 0.00091, "epss_percentile": 0.26217}, "CVE-2017-0500": {"epss_score": 0.0006, "epss_percentile": 0.18973}, "CVE-2017-0501": {"epss_score": 0.0006, "epss_percentile": 0.18973}, "CVE-2017-0502": {"epss_score": 0.0006, "epss_percentile": 0.18973}, "CVE-2017-0503": {"epss_score": 0.00202, "epss_percentile": 0.42429}, "CVE-2017-0504": {"epss_score": 0.00105, "epss_percentile": 0.29249}, "CVE-2017-0505": {"epss_score": 0.03779, "epss_percentile": 0.87713}, "CVE-2017-0506": {"epss_score": 0.0006, "epss_percentile": 0.18973}, "CVE-2017-0507": {"epss_score": 0.00213, "epss_percentile": 0.43942}, "CVE-2017-0508": {"epss_score": 0.00233, "epss_percentile": 0.46058}, "CVE-2017-0509": {"epss_score": 0.00056, "epss_percentile": 0.17924}, "CVE-2017-0510": {"epss_score": 0.00281, "epss_percentile": 0.51147}, "CVE-2017-0516": {"epss_score": 0.00213, "epss_percentile": 0.43942}, "CVE-2017-0517": {"epss_score": 0.0006, "epss_percentile": 0.18973}, "CVE-2017-0518": {"epss_score": 0.00213, "epss_percentile": 0.43942}, "CVE-2017-0519": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0520": {"epss_score": 0.00224, "epss_percentile": 0.45051}, "CVE-2017-0521": {"epss_score": 0.00221, "epss_percentile": 0.44638}, "CVE-2017-0522": {"epss_score": 0.00057, "epss_percentile": 0.18159}, "CVE-2017-0523": {"epss_score": 0.00052, "epss_percentile": 0.16556}, "CVE-2017-0524": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0525": {"epss_score": 0.00224, "epss_percentile": 0.45051}, "CVE-2017-0526": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0527": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0528": {"epss_score": 0.00213, "epss_percentile": 0.43942}, "CVE-2017-0529": {"epss_score": 0.00125, "epss_percentile": 0.32563}, "CVE-2017-0531": {"epss_score": 0.00283, "epss_percentile": 0.51388}, "CVE-2017-0532": {"epss_score": 0.00125, "epss_percentile": 0.32563}, "CVE-2017-0533": {"epss_score": 0.00283, "epss_percentile": 0.51388}, "CVE-2017-0534": {"epss_score": 0.00283, "epss_percentile": 0.51388}, "CVE-2017-0535": {"epss_score": 0.00255, "epss_percentile": 0.48726}, "CVE-2017-0536": {"epss_score": 0.00255, "epss_percentile": 0.48726}, "CVE-2017-0537": {"epss_score": 0.00283, "epss_percentile": 0.51367}, "CVE-2017-0538": {"epss_score": 0.00246, "epss_percentile": 0.47769}, "CVE-2017-0539": {"epss_score": 0.00267, "epss_percentile": 0.49977}, "CVE-2017-0540": {"epss_score": 0.0035, "epss_percentile": 0.5696}, "CVE-2017-0541": {"epss_score": 0.04611, "epss_percentile": 0.88914}, "CVE-2017-0542": {"epss_score": 0.00267, "epss_percentile": 0.49977}, "CVE-2017-0543": {"epss_score": 0.00267, "epss_percentile": 0.49977}, "CVE-2017-0544": {"epss_score": 0.00062, "epss_percentile": 0.19736}, "CVE-2017-0545": {"epss_score": 0.00078, "epss_percentile": 0.23735}, "CVE-2017-0546": {"epss_score": 0.00078, "epss_percentile": 0.23735}, "CVE-2017-0547": {"epss_score": 0.00125, "epss_percentile": 0.32619}, "CVE-2017-0548": {"epss_score": 0.00299, "epss_percentile": 0.52876}, "CVE-2017-0549": {"epss_score": 0.00198, "epss_percentile": 0.42027}, "CVE-2017-0550": {"epss_score": 0.00198, "epss_percentile": 0.42027}, "CVE-2017-0551": {"epss_score": 0.00197, "epss_percentile": 0.41888}, "CVE-2017-0552": {"epss_score": 0.00198, "epss_percentile": 0.42027}, "CVE-2017-0553": {"epss_score": 0.0031, "epss_percentile": 0.5379}, "CVE-2017-0554": {"epss_score": 0.00762, "epss_percentile": 0.72838}, "CVE-2017-0555": {"epss_score": 0.00125, "epss_percentile": 0.32619}, "CVE-2017-0556": {"epss_score": 0.00125, "epss_percentile": 0.32619}, "CVE-2017-0557": {"epss_score": 0.00112, "epss_percentile": 0.3058}, "CVE-2017-0558": {"epss_score": 0.00112, "epss_percentile": 0.3058}, "CVE-2017-0559": {"epss_score": 0.00109, "epss_percentile": 0.29995}, "CVE-2017-0560": {"epss_score": 0.00109, "epss_percentile": 0.29995}, "CVE-2017-0561": {"epss_score": 0.44374, "epss_percentile": 0.97432}, "CVE-2017-0562": {"epss_score": 0.00078, "epss_percentile": 0.23735}, "CVE-2017-0563": {"epss_score": 0.00168, "epss_percentile": 0.38424}, "CVE-2017-0564": {"epss_score": 0.02704, "epss_percentile": 0.85462}, "CVE-2017-0565": {"epss_score": 0.00078, "epss_percentile": 0.23735}, "CVE-2017-0566": {"epss_score": 0.00078, "epss_percentile": 0.23735}, "CVE-2017-0567": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0568": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0569": {"epss_score": 0.02192, "epss_percentile": 0.83941}, "CVE-2017-0570": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0571": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0572": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0573": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0574": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0575": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0576": {"epss_score": 0.0023, "epss_percentile": 0.45683}, "CVE-2017-0577": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0578": {"epss_score": 0.00078, "epss_percentile": 0.23735}, "CVE-2017-0579": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0580": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0581": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0582": {"epss_score": 0.00353, "epss_percentile": 0.57173}, "CVE-2017-0583": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2017-0584": {"epss_score": 0.00223, "epss_percentile": 0.44863}, "CVE-2017-0585": {"epss_score": 0.00165, "epss_percentile": 0.38056}, "CVE-2017-0586": {"epss_score": 0.00223, "epss_percentile": 0.44863}, "CVE-2017-0587": {"epss_score": 0.00272, "epss_percentile": 0.50381}, "CVE-2017-0588": {"epss_score": 0.00272, "epss_percentile": 0.50381}, "CVE-2017-0589": {"epss_score": 0.00272, "epss_percentile": 0.50381}, "CVE-2017-0590": {"epss_score": 0.00272, "epss_percentile": 0.50381}, "CVE-2017-0591": {"epss_score": 0.00272, "epss_percentile": 0.50381}, "CVE-2017-0592": {"epss_score": 0.00272, "epss_percentile": 0.50381}, "CVE-2017-0593": {"epss_score": 0.00024, "epss_percentile": 0.05664}, "CVE-2017-0594": {"epss_score": 0.00068, "epss_percentile": 0.2129}, "CVE-2017-0595": {"epss_score": 0.00067, "epss_percentile": 0.21167}, "CVE-2017-0596": {"epss_score": 0.00067, "epss_percentile": 0.21167}, "CVE-2017-0597": {"epss_score": 0.00052, "epss_percentile": 0.16644}, "CVE-2017-0598": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2017-0599": {"epss_score": 0.00194, "epss_percentile": 0.41591}, "CVE-2017-0600": {"epss_score": 0.00111, "epss_percentile": 0.30347}, "CVE-2017-0601": {"epss_score": 0.00036, "epss_percentile": 0.10373}, "CVE-2017-0602": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2017-0603": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2017-0604": {"epss_score": 0.00043, "epss_percentile": 0.13221}, "CVE-2017-0606": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2017-0607": {"epss_score": 0.00193, "epss_percentile": 0.41496}, "CVE-2017-0608": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2017-0609": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2017-0610": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2017-0611": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2017-0612": {"epss_score": 0.00193, "epss_percentile": 0.41496}, "CVE-2017-0613": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2017-0614": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2017-0615": {"epss_score": 0.00052, "epss_percentile": 0.16644}, "CVE-2017-0616": {"epss_score": 0.00052, "epss_percentile": 0.16644}, "CVE-2017-0617": {"epss_score": 0.00052, "epss_percentile": 0.16644}, "CVE-2017-0618": {"epss_score": 0.00043, "epss_percentile": 0.13221}, "CVE-2017-0619": {"epss_score": 0.0004, "epss_percentile": 0.12036}, "CVE-2017-0620": {"epss_score": 0.00052, "epss_percentile": 0.16644}, "CVE-2017-0621": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2017-0622": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2017-0623": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2017-0624": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-0625": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2017-0626": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-0627": {"epss_score": 0.00341, "epss_percentile": 0.56316}, "CVE-2017-0628": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-0629": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-0630": {"epss_score": 0.00302, "epss_percentile": 0.53123}, "CVE-2017-0631": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-0632": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-0633": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-0634": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-0635": {"epss_score": 0.00111, "epss_percentile": 0.30347}, "CVE-2017-0636": {"epss_score": 0.00084, "epss_percentile": 0.24888}, "CVE-2017-0637": {"epss_score": 0.0084, "epss_percentile": 0.74198}, "CVE-2017-0638": {"epss_score": 0.00447, "epss_percentile": 0.62958}, "CVE-2017-0639": {"epss_score": 0.00109, "epss_percentile": 0.29995}, "CVE-2017-0640": {"epss_score": 0.00203, "epss_percentile": 0.42507}, "CVE-2017-0641": {"epss_score": 0.02719, "epss_percentile": 0.85513}, "CVE-2017-0642": {"epss_score": 0.00186, "epss_percentile": 0.40597}, "CVE-2017-0643": {"epss_score": 0.00203, "epss_percentile": 0.42507}, "CVE-2017-0644": {"epss_score": 0.00203, "epss_percentile": 0.42507}, "CVE-2017-0645": {"epss_score": 0.00093, "epss_percentile": 0.26703}, "CVE-2017-0646": {"epss_score": 0.00109, "epss_percentile": 0.29995}, "CVE-2017-0647": {"epss_score": 0.00109, "epss_percentile": 0.29995}, "CVE-2017-0648": {"epss_score": 0.00195, "epss_percentile": 0.41658}, "CVE-2017-0649": {"epss_score": 0.00084, "epss_percentile": 0.24888}, "CVE-2017-0650": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2017-0651": {"epss_score": 0.00223, "epss_percentile": 0.44863}, "CVE-2017-0663": {"epss_score": 0.0134, "epss_percentile": 0.79578}, "CVE-2017-0664": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0665": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0666": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0667": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0668": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2017-0669": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2017-0670": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0671": {"epss_score": 0.00177, "epss_percentile": 0.39606}, "CVE-2017-0672": {"epss_score": 0.0005, "epss_percentile": 0.15847}, "CVE-2017-0673": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0674": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0675": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0676": {"epss_score": 0.00288, "epss_percentile": 0.51901}, "CVE-2017-0677": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0678": {"epss_score": 0.00248, "epss_percentile": 0.47969}, "CVE-2017-0679": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0680": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0681": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0682": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0683": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0684": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0685": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0686": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0687": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0688": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0689": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0690": {"epss_score": 0.0005, "epss_percentile": 0.15847}, "CVE-2017-0691": {"epss_score": 0.00036, "epss_percentile": 0.10399}, "CVE-2017-0692": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0693": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0694": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0695": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0696": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0697": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0698": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2017-0699": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2017-0700": {"epss_score": 0.00269, "epss_percentile": 0.50167}, "CVE-2017-0701": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0702": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0703": {"epss_score": 0.00031, "epss_percentile": 0.08555}, "CVE-2017-0704": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-0705": {"epss_score": 0.00053, "epss_percentile": 0.16701}, "CVE-2017-0706": {"epss_score": 0.00032, "epss_percentile": 0.08833}, "CVE-2017-0707": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-0708": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2017-0709": {"epss_score": 0.00054, "epss_percentile": 0.17057}, "CVE-2017-0710": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-0711": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0712": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-0713": {"epss_score": 0.0028, "epss_percentile": 0.5101}, "CVE-2017-0714": {"epss_score": 0.00248, "epss_percentile": 0.47969}, "CVE-2017-0715": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0716": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0718": {"epss_score": 0.00248, "epss_percentile": 0.47969}, "CVE-2017-0719": {"epss_score": 0.00308, "epss_percentile": 0.53584}, "CVE-2017-0720": {"epss_score": 0.00248, "epss_percentile": 0.47969}, "CVE-2017-0721": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0722": {"epss_score": 0.00248, "epss_percentile": 0.47969}, "CVE-2017-0723": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0724": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0725": {"epss_score": 0.00039, "epss_percentile": 0.11474}, "CVE-2017-0726": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0727": {"epss_score": 0.00041, "epss_percentile": 0.12398}, "CVE-2017-0728": {"epss_score": 0.0005, "epss_percentile": 0.15756}, "CVE-2017-0729": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-0730": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0731": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-0732": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-0733": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0734": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0735": {"epss_score": 0.00044, "epss_percentile": 0.13598}, "CVE-2017-0736": {"epss_score": 0.00038, "epss_percentile": 0.11105}, "CVE-2017-0737": {"epss_score": 0.00092, "epss_percentile": 0.26489}, "CVE-2017-0738": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2017-0739": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2017-0740": {"epss_score": 0.0028, "epss_percentile": 0.5101}, "CVE-2017-0741": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-0742": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-0744": {"epss_score": 0.00018, "epss_percentile": 0.03663}, "CVE-2017-0745": {"epss_score": 0.00308, "epss_percentile": 0.53584}, "CVE-2017-0746": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-0747": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-0748": {"epss_score": 0.0008, "epss_percentile": 0.24026}, "CVE-2017-0749": {"epss_score": 0.00144, "epss_percentile": 0.35346}, "CVE-2017-0750": {"epss_score": 0.0026, "epss_percentile": 0.49174}, "CVE-2017-0751": {"epss_score": 0.00018, "epss_percentile": 0.03663}, "CVE-2017-0752": {"epss_score": 0.00031, "epss_percentile": 0.08555}, "CVE-2017-0753": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0755": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0756": {"epss_score": 0.00164, "epss_percentile": 0.37913}, "CVE-2017-0757": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0758": {"epss_score": 0.00248, "epss_percentile": 0.47969}, "CVE-2017-0759": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0760": {"epss_score": 0.00248, "epss_percentile": 0.47969}, "CVE-2017-0761": {"epss_score": 0.00248, "epss_percentile": 0.47969}, "CVE-2017-0762": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0763": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0764": {"epss_score": 0.00269, "epss_percentile": 0.50167}, "CVE-2017-0765": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0766": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-0767": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0768": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0769": {"epss_score": 0.00037, "epss_percentile": 0.10639}, "CVE-2017-0770": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0771": {"epss_score": 0.00038, "epss_percentile": 0.11105}, "CVE-2017-0772": {"epss_score": 0.00038, "epss_percentile": 0.11105}, "CVE-2017-0773": {"epss_score": 0.00038, "epss_percentile": 0.11105}, "CVE-2017-0774": {"epss_score": 0.00038, "epss_percentile": 0.11105}, "CVE-2017-0775": {"epss_score": 0.00038, "epss_percentile": 0.11105}, "CVE-2017-0776": {"epss_score": 0.00051, "epss_percentile": 0.16291}, "CVE-2017-0777": {"epss_score": 0.00051, "epss_percentile": 0.16291}, "CVE-2017-0778": {"epss_score": 0.00064, "epss_percentile": 0.20292}, "CVE-2017-0779": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2017-0780": {"epss_score": 0.00038, "epss_percentile": 0.11105}, "CVE-2017-0781": {"epss_score": 0.4195, "epss_percentile": 0.97303}, "CVE-2017-0782": {"epss_score": 0.33328, "epss_percentile": 0.96764}, "CVE-2017-0783": {"epss_score": 0.00074, "epss_percentile": 0.2281}, "CVE-2017-0784": {"epss_score": 0.0006, "epss_percentile": 0.19154}, "CVE-2017-0785": {"epss_score": 0.11787, "epss_percentile": 0.93475}, "CVE-2017-0786": {"epss_score": 0.00157, "epss_percentile": 0.37084}, "CVE-2017-0787": {"epss_score": 0.00062, "epss_percentile": 0.19698}, "CVE-2017-0788": {"epss_score": 0.00062, "epss_percentile": 0.19698}, "CVE-2017-0789": {"epss_score": 0.00062, "epss_percentile": 0.19698}, "CVE-2017-0790": {"epss_score": 0.00062, "epss_percentile": 0.19698}, "CVE-2017-0791": {"epss_score": 0.00062, "epss_percentile": 0.19698}, "CVE-2017-0792": {"epss_score": 0.0005, "epss_percentile": 0.15699}, "CVE-2017-0793": {"epss_score": 0.0006, "epss_percentile": 0.19169}, "CVE-2017-0794": {"epss_score": 0.00057, "epss_percentile": 0.18128}, "CVE-2017-0795": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0796": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0797": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-0798": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-0799": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-0800": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-0801": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-0802": {"epss_score": 0.00083, "epss_percentile": 0.247}, "CVE-2017-0803": {"epss_score": 0.00083, "epss_percentile": 0.247}, "CVE-2017-0804": {"epss_score": 0.00083, "epss_percentile": 0.247}, "CVE-2017-0805": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-0806": {"epss_score": 0.01494, "epss_percentile": 0.8065}, "CVE-2017-0807": {"epss_score": 0.02479, "epss_percentile": 0.84868}, "CVE-2017-0808": {"epss_score": 0.00161, "epss_percentile": 0.37566}, "CVE-2017-0809": {"epss_score": 0.0084, "epss_percentile": 0.74198}, "CVE-2017-0810": {"epss_score": 0.00496, "epss_percentile": 0.65141}, "CVE-2017-0811": {"epss_score": 0.00669, "epss_percentile": 0.70748}, "CVE-2017-0812": {"epss_score": 0.00134, "epss_percentile": 0.33849}, "CVE-2017-0813": {"epss_score": 0.00376, "epss_percentile": 0.58663}, "CVE-2017-0814": {"epss_score": 0.00834, "epss_percentile": 0.74102}, "CVE-2017-0815": {"epss_score": 0.00154, "epss_percentile": 0.36735}, "CVE-2017-0816": {"epss_score": 0.00154, "epss_percentile": 0.36735}, "CVE-2017-0817": {"epss_score": 0.00233, "epss_percentile": 0.46}, "CVE-2017-0818": {"epss_score": 0.00262, "epss_percentile": 0.49393}, "CVE-2017-0819": {"epss_score": 0.00262, "epss_percentile": 0.49393}, "CVE-2017-0820": {"epss_score": 0.00599, "epss_percentile": 0.68809}, "CVE-2017-0822": {"epss_score": 0.00134, "epss_percentile": 0.33751}, "CVE-2017-0823": {"epss_score": 0.00282, "epss_percentile": 0.51266}, "CVE-2017-0824": {"epss_score": 0.00144, "epss_percentile": 0.35234}, "CVE-2017-0825": {"epss_score": 0.00145, "epss_percentile": 0.35396}, "CVE-2017-0826": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-0827": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-0828": {"epss_score": 0.00144, "epss_percentile": 0.35234}, "CVE-2017-0829": {"epss_score": 0.00144, "epss_percentile": 0.35234}, "CVE-2017-0830": {"epss_score": 0.00081, "epss_percentile": 0.24243}, "CVE-2017-0831": {"epss_score": 0.00077, "epss_percentile": 0.23466}, "CVE-2017-0832": {"epss_score": 0.01003, "epss_percentile": 0.76519}, "CVE-2017-0833": {"epss_score": 0.0096, "epss_percentile": 0.75971}, "CVE-2017-0834": {"epss_score": 0.0096, "epss_percentile": 0.75971}, "CVE-2017-0835": {"epss_score": 0.0096, "epss_percentile": 0.75971}, "CVE-2017-0836": {"epss_score": 0.0096, "epss_percentile": 0.75971}, "CVE-2017-0837": {"epss_score": 0.00016, "epss_percentile": 0.02699}, "CVE-2017-0838": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2017-0839": {"epss_score": 0.00145, "epss_percentile": 0.35396}, "CVE-2017-0840": {"epss_score": 0.00145, "epss_percentile": 0.35396}, "CVE-2017-0841": {"epss_score": 0.00886, "epss_percentile": 0.74953}, "CVE-2017-0842": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2017-0843": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2017-0845": {"epss_score": 0.00124, "epss_percentile": 0.32392}, "CVE-2017-0846": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-0847": {"epss_score": 0.00144, "epss_percentile": 0.3532}, "CVE-2017-0848": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-0849": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-0850": {"epss_score": 0.00108, "epss_percentile": 0.29836}, "CVE-2017-0851": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-0852": {"epss_score": 0.00101, "epss_percentile": 0.28622}, "CVE-2017-0853": {"epss_score": 0.00122, "epss_percentile": 0.32079}, "CVE-2017-0854": {"epss_score": 0.00122, "epss_percentile": 0.32079}, "CVE-2017-0855": {"epss_score": 0.02288, "epss_percentile": 0.84272}, "CVE-2017-0857": {"epss_score": 0.00101, "epss_percentile": 0.28622}, "CVE-2017-0858": {"epss_score": 0.00108, "epss_percentile": 0.29781}, "CVE-2017-0859": {"epss_score": 0.00101, "epss_percentile": 0.28622}, "CVE-2017-0860": {"epss_score": 0.00016, "epss_percentile": 0.02626}, "CVE-2017-0861": {"epss_score": 0.00085, "epss_percentile": 0.25074}, "CVE-2017-0862": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2017-0863": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-0864": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-0865": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-0866": {"epss_score": 0.00045, "epss_percentile": 0.13728}, "CVE-2017-0869": {"epss_score": 0.00037, "epss_percentile": 0.10882}, "CVE-2017-0870": {"epss_score": 0.00016, "epss_percentile": 0.02699}, "CVE-2017-0871": {"epss_score": 0.00016, "epss_percentile": 0.02699}, "CVE-2017-0872": {"epss_score": 0.00456, "epss_percentile": 0.63345}, "CVE-2017-0873": {"epss_score": 0.00102, "epss_percentile": 0.28801}, "CVE-2017-0874": {"epss_score": 0.00102, "epss_percentile": 0.28801}, "CVE-2017-0876": {"epss_score": 0.00456, "epss_percentile": 0.63345}, "CVE-2017-0877": {"epss_score": 0.00456, "epss_percentile": 0.63345}, "CVE-2017-0878": {"epss_score": 0.00456, "epss_percentile": 0.63345}, "CVE-2017-0879": {"epss_score": 0.00212, "epss_percentile": 0.43807}, "CVE-2017-0880": {"epss_score": 0.00102, "epss_percentile": 0.28801}, "CVE-2017-0881": {"epss_score": 0.00206, "epss_percentile": 0.42952}, "CVE-2017-0882": {"epss_score": 0.00183, "epss_percentile": 0.40279}, "CVE-2017-0883": {"epss_score": 0.00087, "epss_percentile": 0.2556}, "CVE-2017-0884": {"epss_score": 0.00099, "epss_percentile": 0.27863}, "CVE-2017-0885": {"epss_score": 0.00211, "epss_percentile": 0.43696}, "CVE-2017-0886": {"epss_score": 0.00612, "epss_percentile": 0.69223}, "CVE-2017-0887": {"epss_score": 0.00249, "epss_percentile": 0.48014}, "CVE-2017-0888": {"epss_score": 0.00537, "epss_percentile": 0.66895}, "CVE-2017-0889": {"epss_score": 0.00344, "epss_percentile": 0.56538}, "CVE-2017-0890": {"epss_score": 0.00252, "epss_percentile": 0.48383}, "CVE-2017-0891": {"epss_score": 0.00191, "epss_percentile": 0.41147}, "CVE-2017-0892": {"epss_score": 0.0022, "epss_percentile": 0.44585}, "CVE-2017-0893": {"epss_score": 0.00312, "epss_percentile": 0.53999}, "CVE-2017-0894": {"epss_score": 0.00793, "epss_percentile": 0.73431}, "CVE-2017-0895": {"epss_score": 0.00126, "epss_percentile": 0.3264}, "CVE-2017-0896": {"epss_score": 0.00148, "epss_percentile": 0.35882}, "CVE-2017-0897": {"epss_score": 0.00751, "epss_percentile": 0.72648}, "CVE-2017-0898": {"epss_score": 0.00846, "epss_percentile": 0.74335}, "CVE-2017-0899": {"epss_score": 0.07362, "epss_percentile": 0.91433}, "CVE-2017-0900": {"epss_score": 0.09382, "epss_percentile": 0.92525}, "CVE-2017-0901": {"epss_score": 0.18555, "epss_percentile": 0.95033}, "CVE-2017-0902": {"epss_score": 0.03392, "epss_percentile": 0.87054}, "CVE-2017-0903": {"epss_score": 0.06336, "epss_percentile": 0.90678}, "CVE-2017-0904": {"epss_score": 0.00862, "epss_percentile": 0.74581}, "CVE-2017-0905": {"epss_score": 0.00519, "epss_percentile": 0.66173}, "CVE-2017-0906": {"epss_score": 0.00519, "epss_percentile": 0.66173}, "CVE-2017-0907": {"epss_score": 0.00519, "epss_percentile": 0.66173}, "CVE-2017-0909": {"epss_score": 0.00339, "epss_percentile": 0.56166}, "CVE-2017-0910": {"epss_score": 0.00239, "epss_percentile": 0.46855}, "CVE-2017-0911": {"epss_score": 0.00084, "epss_percentile": 0.24925}, "CVE-2017-0912": {"epss_score": 0.00217, "epss_percentile": 0.44259}, "CVE-2017-0913": {"epss_score": 0.00055, "epss_percentile": 0.17416}, "CVE-2017-0914": {"epss_score": 0.00172, "epss_percentile": 0.38992}, "CVE-2017-0915": {"epss_score": 0.01156, "epss_percentile": 0.78099}, "CVE-2017-0916": {"epss_score": 0.00427, "epss_percentile": 0.61899}, "CVE-2017-0917": {"epss_score": 0.0008, "epss_percentile": 0.24109}, "CVE-2017-0918": {"epss_score": 0.06158, "epss_percentile": 0.90526}, "CVE-2017-0919": {"epss_score": 0.0006, "epss_percentile": 0.18957}, "CVE-2017-0920": {"epss_score": 0.00094, "epss_percentile": 0.27076}, "CVE-2017-0921": {"epss_score": 0.00089, "epss_percentile": 0.2584}, "CVE-2017-0922": {"epss_score": 0.00081, "epss_percentile": 0.2434}, "CVE-2017-0923": {"epss_score": 0.00076, "epss_percentile": 0.23118}, "CVE-2017-0924": {"epss_score": 0.00076, "epss_percentile": 0.23118}, "CVE-2017-0925": {"epss_score": 0.00105, "epss_percentile": 0.29294}, "CVE-2017-0926": {"epss_score": 0.00316, "epss_percentile": 0.54224}, "CVE-2017-0927": {"epss_score": 0.00095, "epss_percentile": 0.27106}, "CVE-2017-0928": {"epss_score": 0.00185, "epss_percentile": 0.4058}, "CVE-2017-0929": {"epss_score": 0.92808, "epss_percentile": 0.99751}, "CVE-2017-0930": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2017-0931": {"epss_score": 0.0022, "epss_percentile": 0.44554}, "CVE-2017-0932": {"epss_score": 0.00346, "epss_percentile": 0.56707}, "CVE-2017-0933": {"epss_score": 0.0018, "epss_percentile": 0.39881}, "CVE-2017-0934": {"epss_score": 0.00346, "epss_percentile": 0.56707}, "CVE-2017-0935": {"epss_score": 0.00346, "epss_percentile": 0.56707}, "CVE-2017-0936": {"epss_score": 0.00144, "epss_percentile": 0.35285}, "CVE-2017-0938": {"epss_score": 0.05305, "epss_percentile": 0.89711}, "CVE-2017-1000001": {"epss_score": 0.00614, "epss_percentile": 0.69287}, "CVE-2017-1000002": {"epss_score": 0.60219, "epss_percentile": 0.98199}, "CVE-2017-1000003": {"epss_score": 0.00282, "epss_percentile": 0.51222}, "CVE-2017-1000004": {"epss_score": 0.02219, "epss_percentile": 0.84045}, "CVE-2017-1000005": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-1000006": {"epss_score": 0.00644, "epss_percentile": 0.70074}, "CVE-2017-1000007": {"epss_score": 0.00169, "epss_percentile": 0.3863}, "CVE-2017-1000008": {"epss_score": 0.00071, "epss_percentile": 0.22082}, "CVE-2017-1000009": {"epss_score": 0.111, "epss_percentile": 0.93219}, "CVE-2017-1000010": {"epss_score": 0.01374, "epss_percentile": 0.79822}, "CVE-2017-1000011": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-1000012": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-1000013": {"epss_score": 0.00239, "epss_percentile": 0.46931}, "CVE-2017-1000014": {"epss_score": 0.01144, "epss_percentile": 0.77989}, "CVE-2017-1000015": {"epss_score": 0.00557, "epss_percentile": 0.67541}, "CVE-2017-1000016": {"epss_score": 0.00488, "epss_percentile": 0.64844}, "CVE-2017-1000017": {"epss_score": 0.0092, "epss_percentile": 0.75465}, "CVE-2017-1000018": {"epss_score": 0.01295, "epss_percentile": 0.7925}, "CVE-2017-1000020": {"epss_score": 0.01129, "epss_percentile": 0.77839}, "CVE-2017-1000021": {"epss_score": 0.00694, "epss_percentile": 0.7135}, "CVE-2017-1000022": {"epss_score": 0.00277, "epss_percentile": 0.50836}, "CVE-2017-1000023": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2017-1000024": {"epss_score": 0.00247, "epss_percentile": 0.47855}, "CVE-2017-1000025": {"epss_score": 0.00498, "epss_percentile": 0.65235}, "CVE-2017-1000026": {"epss_score": 0.00198, "epss_percentile": 0.42031}, "CVE-2017-1000027": {"epss_score": 0.0214, "epss_percentile": 0.83745}, "CVE-2017-1000028": {"epss_score": 0.94123, "epss_percentile": 0.99907}, "CVE-2017-1000029": {"epss_score": 0.73502, "epss_percentile": 0.98759}, "CVE-2017-1000030": {"epss_score": 0.04204, "epss_percentile": 0.88392}, "CVE-2017-1000031": {"epss_score": 0.01092, "epss_percentile": 0.77469}, "CVE-2017-1000032": {"epss_score": 0.00196, "epss_percentile": 0.41746}, "CVE-2017-1000033": {"epss_score": 0.0245, "epss_percentile": 0.84781}, "CVE-2017-1000034": {"epss_score": 0.0955, "epss_percentile": 0.92594}, "CVE-2017-1000035": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-1000037": {"epss_score": 0.21707, "epss_percentile": 0.9555}, "CVE-2017-1000038": {"epss_score": 0.0104, "epss_percentile": 0.76959}, "CVE-2017-1000039": {"epss_score": 0.03634, "epss_percentile": 0.87478}, "CVE-2017-1000042": {"epss_score": 0.00164, "epss_percentile": 0.37896}, "CVE-2017-1000043": {"epss_score": 0.00164, "epss_percentile": 0.37896}, "CVE-2017-1000044": {"epss_score": 0.01665, "epss_percentile": 0.81645}, "CVE-2017-1000046": {"epss_score": 0.00282, "epss_percentile": 0.51221}, "CVE-2017-1000047": {"epss_score": 0.03031, "epss_percentile": 0.86249}, "CVE-2017-1000048": {"epss_score": 0.00532, "epss_percentile": 0.66674}, "CVE-2017-1000050": {"epss_score": 0.01605, "epss_percentile": 0.81292}, "CVE-2017-1000051": {"epss_score": 0.00062, "epss_percentile": 0.19749}, "CVE-2017-1000052": {"epss_score": 0.00246, "epss_percentile": 0.47753}, "CVE-2017-1000053": {"epss_score": 0.01151, "epss_percentile": 0.78039}, "CVE-2017-1000054": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-1000056": {"epss_score": 0.00256, "epss_percentile": 0.48779}, "CVE-2017-1000058": {"epss_score": 0.00265, "epss_percentile": 0.49776}, "CVE-2017-1000059": {"epss_score": 0.00347, "epss_percentile": 0.56789}, "CVE-2017-1000060": {"epss_score": 0.0657, "epss_percentile": 0.90853}, "CVE-2017-1000061": {"epss_score": 0.00591, "epss_percentile": 0.68598}, "CVE-2017-1000062": {"epss_score": 0.03229, "epss_percentile": 0.86693}, "CVE-2017-1000063": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-1000064": {"epss_score": 0.00398, "epss_percentile": 0.60081}, "CVE-2017-1000065": {"epss_score": 0.00346, "epss_percentile": 0.56733}, "CVE-2017-1000066": {"epss_score": 0.00595, "epss_percentile": 0.6868}, "CVE-2017-1000067": {"epss_score": 0.00546, "epss_percentile": 0.67226}, "CVE-2017-1000068": {"epss_score": 0.00407, "epss_percentile": 0.60568}, "CVE-2017-1000069": {"epss_score": 0.00091, "epss_percentile": 0.26247}, "CVE-2017-1000070": {"epss_score": 0.00178, "epss_percentile": 0.39653}, "CVE-2017-1000071": {"epss_score": 0.00249, "epss_percentile": 0.48065}, "CVE-2017-1000072": {"epss_score": 0.00828, "epss_percentile": 0.74}, "CVE-2017-1000073": {"epss_score": 0.03269, "epss_percentile": 0.86788}, "CVE-2017-1000074": {"epss_score": 0.00846, "epss_percentile": 0.7432}, "CVE-2017-1000075": {"epss_score": 0.00846, "epss_percentile": 0.7432}, "CVE-2017-1000078": {"epss_score": 0.00265, "epss_percentile": 0.49776}, "CVE-2017-1000079": {"epss_score": 0.00464, "epss_percentile": 0.63714}, "CVE-2017-1000080": {"epss_score": 0.00324, "epss_percentile": 0.54938}, "CVE-2017-1000081": {"epss_score": 0.08814, "epss_percentile": 0.92267}, "CVE-2017-1000082": {"epss_score": 0.00258, "epss_percentile": 0.48968}, "CVE-2017-1000083": {"epss_score": 0.76668, "epss_percentile": 0.989}, "CVE-2017-1000084": {"epss_score": 0.00038, "epss_percentile": 0.11235}, "CVE-2017-1000085": {"epss_score": 0.00141, "epss_percentile": 0.34909}, "CVE-2017-1000086": {"epss_score": 0.00088, "epss_percentile": 0.25693}, "CVE-2017-1000087": {"epss_score": 0.00023, "epss_percentile": 0.05653}, "CVE-2017-1000088": {"epss_score": 0.00058, "epss_percentile": 0.18534}, "CVE-2017-1000089": {"epss_score": 0.00031, "epss_percentile": 0.08665}, "CVE-2017-1000090": {"epss_score": 0.00062, "epss_percentile": 0.19775}, "CVE-2017-1000091": {"epss_score": 0.00066, "epss_percentile": 0.20867}, "CVE-2017-1000092": {"epss_score": 0.00147, "epss_percentile": 0.35705}, "CVE-2017-1000093": {"epss_score": 0.00062, "epss_percentile": 0.19775}, "CVE-2017-1000094": {"epss_score": 0.0005, "epss_percentile": 0.15668}, "CVE-2017-1000095": {"epss_score": 0.00066, "epss_percentile": 0.20877}, "CVE-2017-1000096": {"epss_score": 0.00195, "epss_percentile": 0.4165}, "CVE-2017-1000097": {"epss_score": 0.00177, "epss_percentile": 0.39598}, "CVE-2017-1000098": {"epss_score": 0.00434, "epss_percentile": 0.62295}, "CVE-2017-1000099": {"epss_score": 0.00744, "epss_percentile": 0.72507}, "CVE-2017-1000100": {"epss_score": 0.00699, "epss_percentile": 0.71458}, "CVE-2017-1000101": {"epss_score": 0.00624, "epss_percentile": 0.6956}, "CVE-2017-1000102": {"epss_score": 0.00049, "epss_percentile": 0.15301}, "CVE-2017-1000103": {"epss_score": 0.00049, "epss_percentile": 0.15301}, "CVE-2017-1000104": {"epss_score": 0.0003, "epss_percentile": 0.08157}, "CVE-2017-1000105": {"epss_score": 0.00038, "epss_percentile": 0.11298}, "CVE-2017-1000106": {"epss_score": 0.0003, "epss_percentile": 0.07983}, "CVE-2017-1000107": {"epss_score": 0.00274, "epss_percentile": 0.50538}, "CVE-2017-1000108": {"epss_score": 0.00085, "epss_percentile": 0.25054}, "CVE-2017-1000109": {"epss_score": 0.00054, "epss_percentile": 0.17166}, "CVE-2017-1000110": {"epss_score": 0.00042, "epss_percentile": 0.12905}, "CVE-2017-1000111": {"epss_score": 0.00088, "epss_percentile": 0.25774}, "CVE-2017-1000112": {"epss_score": 0.8232, "epss_percentile": 0.99187}, "CVE-2017-1000113": {"epss_score": 0.00015, "epss_percentile": 0.02601}, "CVE-2017-1000114": {"epss_score": 0.00033, "epss_percentile": 0.09184}, "CVE-2017-1000115": {"epss_score": 0.02142, "epss_percentile": 0.83754}, "CVE-2017-1000116": {"epss_score": 0.02397, "epss_percentile": 0.84621}, "CVE-2017-1000117": {"epss_score": 0.70588, "epss_percentile": 0.98636}, "CVE-2017-1000118": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2017-1000119": {"epss_score": 0.76231, "epss_percentile": 0.98883}, "CVE-2017-1000120": {"epss_score": 0.0037, "epss_percentile": 0.58303}, "CVE-2017-1000121": {"epss_score": 0.00647, "epss_percentile": 0.70184}, "CVE-2017-1000122": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2017-1000125": {"epss_score": 0.00198, "epss_percentile": 0.42005}, "CVE-2017-1000126": {"epss_score": 0.0032, "epss_percentile": 0.54598}, "CVE-2017-1000127": {"epss_score": 0.00357, "epss_percentile": 0.57398}, "CVE-2017-1000128": {"epss_score": 0.00299, "epss_percentile": 0.52881}, "CVE-2017-1000129": {"epss_score": 0.00315, "epss_percentile": 0.54171}, "CVE-2017-1000131": {"epss_score": 0.00122, "epss_percentile": 0.32095}, "CVE-2017-1000132": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2017-1000133": {"epss_score": 0.00251, "epss_percentile": 0.48292}, "CVE-2017-1000134": {"epss_score": 0.00181, "epss_percentile": 0.40119}, "CVE-2017-1000135": {"epss_score": 0.00122, "epss_percentile": 0.32095}, "CVE-2017-1000136": {"epss_score": 0.00145, "epss_percentile": 0.35521}, "CVE-2017-1000137": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2017-1000138": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2017-1000139": {"epss_score": 0.00206, "epss_percentile": 0.43043}, "CVE-2017-1000140": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2017-1000141": {"epss_score": 0.00207, "epss_percentile": 0.43185}, "CVE-2017-1000142": {"epss_score": 0.00161, "epss_percentile": 0.37608}, "CVE-2017-1000143": {"epss_score": 0.00167, "epss_percentile": 0.38298}, "CVE-2017-1000144": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2017-1000145": {"epss_score": 0.00185, "epss_percentile": 0.40461}, "CVE-2017-1000146": {"epss_score": 0.0032, "epss_percentile": 0.54595}, "CVE-2017-1000147": {"epss_score": 0.00104, "epss_percentile": 0.29161}, "CVE-2017-1000148": {"epss_score": 0.00505, "epss_percentile": 0.65607}, "CVE-2017-1000149": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2017-1000150": {"epss_score": 0.00225, "epss_percentile": 0.4522}, "CVE-2017-1000151": {"epss_score": 0.00251, "epss_percentile": 0.48292}, "CVE-2017-1000152": {"epss_score": 0.00344, "epss_percentile": 0.56536}, "CVE-2017-1000153": {"epss_score": 0.00383, "epss_percentile": 0.59097}, "CVE-2017-1000154": {"epss_score": 0.00608, "epss_percentile": 0.69063}, "CVE-2017-1000155": {"epss_score": 0.00167, "epss_percentile": 0.38298}, "CVE-2017-1000156": {"epss_score": 0.00254, "epss_percentile": 0.4851}, "CVE-2017-1000157": {"epss_score": 0.00248, "epss_percentile": 0.4793}, "CVE-2017-1000158": {"epss_score": 0.03255, "epss_percentile": 0.8676}, "CVE-2017-1000159": {"epss_score": 0.00359, "epss_percentile": 0.57543}, "CVE-2017-1000160": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2017-1000163": {"epss_score": 0.00827, "epss_percentile": 0.7398}, "CVE-2017-1000164": {"epss_score": 0.00344, "epss_percentile": 0.56491}, "CVE-2017-1000168": {"epss_score": 0.00265, "epss_percentile": 0.49809}, "CVE-2017-1000169": {"epss_score": 0.03437, "epss_percentile": 0.87135}, "CVE-2017-1000170": {"epss_score": 0.8999, "epss_percentile": 0.99556}, "CVE-2017-1000171": {"epss_score": 0.00327, "epss_percentile": 0.55127}, "CVE-2017-1000172": {"epss_score": 0.01132, "epss_percentile": 0.7787}, "CVE-2017-1000173": {"epss_score": 0.01123, "epss_percentile": 0.77793}, "CVE-2017-1000174": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2017-1000176": {"epss_score": 0.00158, "epss_percentile": 0.37257}, "CVE-2017-1000182": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2017-1000185": {"epss_score": 0.00158, "epss_percentile": 0.37257}, "CVE-2017-1000186": {"epss_score": 0.0016, "epss_percentile": 0.37474}, "CVE-2017-1000187": {"epss_score": 0.00184, "epss_percentile": 0.40433}, "CVE-2017-1000188": {"epss_score": 0.00234, "epss_percentile": 0.46112}, "CVE-2017-1000189": {"epss_score": 0.00913, "epss_percentile": 0.75366}, "CVE-2017-1000190": {"epss_score": 0.0076, "epss_percentile": 0.72804}, "CVE-2017-1000191": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2017-1000192": {"epss_score": 0.0019, "epss_percentile": 0.41132}, "CVE-2017-1000193": {"epss_score": 0.00396, "epss_percentile": 0.59908}, "CVE-2017-1000194": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2017-1000195": {"epss_score": 0.00183, "epss_percentile": 0.40366}, "CVE-2017-1000196": {"epss_score": 0.01058, "epss_percentile": 0.77143}, "CVE-2017-1000197": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2017-1000198": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-1000199": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2017-1000200": {"epss_score": 0.00367, "epss_percentile": 0.58112}, "CVE-2017-1000201": {"epss_score": 0.00048, "epss_percentile": 0.15028}, "CVE-2017-1000203": {"epss_score": 0.02238, "epss_percentile": 0.84107}, "CVE-2017-1000206": {"epss_score": 0.00629, "epss_percentile": 0.69676}, "CVE-2017-1000207": {"epss_score": 0.00423, "epss_percentile": 0.61632}, "CVE-2017-1000208": {"epss_score": 0.00463, "epss_percentile": 0.63678}, "CVE-2017-1000209": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-1000210": {"epss_score": 0.00817, "epss_percentile": 0.73849}, "CVE-2017-1000211": {"epss_score": 0.0043, "epss_percentile": 0.62009}, "CVE-2017-1000212": {"epss_score": 0.01872, "epss_percentile": 0.82639}, "CVE-2017-1000213": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2017-1000214": {"epss_score": 0.07221, "epss_percentile": 0.91334}, "CVE-2017-1000215": {"epss_score": 0.0707, "epss_percentile": 0.91226}, "CVE-2017-1000217": {"epss_score": 0.00694, "epss_percentile": 0.71359}, "CVE-2017-1000218": {"epss_score": 0.02329, "epss_percentile": 0.84399}, "CVE-2017-1000219": {"epss_score": 0.03342, "epss_percentile": 0.86945}, "CVE-2017-1000220": {"epss_score": 0.11815, "epss_percentile": 0.93485}, "CVE-2017-1000221": {"epss_score": 0.00215, "epss_percentile": 0.44061}, "CVE-2017-1000223": {"epss_score": 0.00256, "epss_percentile": 0.48803}, "CVE-2017-1000224": {"epss_score": 0.00215, "epss_percentile": 0.44023}, "CVE-2017-1000225": {"epss_score": 0.0061, "epss_percentile": 0.69146}, "CVE-2017-1000226": {"epss_score": 0.00424, "epss_percentile": 0.61685}, "CVE-2017-1000227": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2017-1000228": {"epss_score": 0.0718, "epss_percentile": 0.91302}, "CVE-2017-1000229": {"epss_score": 0.00473, "epss_percentile": 0.64075}, "CVE-2017-1000230": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-1000231": {"epss_score": 0.00548, "epss_percentile": 0.67271}, "CVE-2017-1000232": {"epss_score": 0.00494, "epss_percentile": 0.65084}, "CVE-2017-1000234": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2017-1000235": {"epss_score": 0.08556, "epss_percentile": 0.92124}, "CVE-2017-1000236": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-1000237": {"epss_score": 0.00358, "epss_percentile": 0.57495}, "CVE-2017-1000238": {"epss_score": 0.00567, "epss_percentile": 0.67857}, "CVE-2017-1000239": {"epss_score": 0.00298, "epss_percentile": 0.52782}, "CVE-2017-1000240": {"epss_score": 0.00097, "epss_percentile": 0.27465}, "CVE-2017-1000241": {"epss_score": 0.00599, "epss_percentile": 0.68808}, "CVE-2017-1000242": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2017-1000243": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2017-1000244": {"epss_score": 0.00059, "epss_percentile": 0.18733}, "CVE-2017-1000245": {"epss_score": 0.00061, "epss_percentile": 0.19523}, "CVE-2017-1000246": {"epss_score": 0.00122, "epss_percentile": 0.32018}, "CVE-2017-1000247": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2017-1000248": {"epss_score": 0.00618, "epss_percentile": 0.69377}, "CVE-2017-1000249": {"epss_score": 0.00138, "epss_percentile": 0.34507}, "CVE-2017-1000250": {"epss_score": 0.36932, "epss_percentile": 0.9701}, "CVE-2017-1000251": {"epss_score": 0.03397, "epss_percentile": 0.87061}, "CVE-2017-1000252": {"epss_score": 0.00083, "epss_percentile": 0.24696}, "CVE-2017-1000253": {"epss_score": 0.57207, "epss_percentile": 0.98054}, "CVE-2017-1000254": {"epss_score": 0.01348, "epss_percentile": 0.79661}, "CVE-2017-1000255": {"epss_score": 0.00048, "epss_percentile": 0.1524}, "CVE-2017-1000256": {"epss_score": 0.00778, "epss_percentile": 0.7313}, "CVE-2017-1000257": {"epss_score": 0.0109, "epss_percentile": 0.77447}, "CVE-2017-1000353": {"epss_score": 0.94508, "epss_percentile": 1.0}, "CVE-2017-1000354": {"epss_score": 0.00364, "epss_percentile": 0.57958}, "CVE-2017-1000355": {"epss_score": 0.00429, "epss_percentile": 0.61987}, "CVE-2017-1000356": {"epss_score": 0.08667, "epss_percentile": 0.92181}, "CVE-2017-1000357": {"epss_score": 0.00494, "epss_percentile": 0.65098}, "CVE-2017-1000358": {"epss_score": 0.00371, "epss_percentile": 0.58364}, "CVE-2017-1000359": {"epss_score": 0.0045, "epss_percentile": 0.63104}, "CVE-2017-1000360": {"epss_score": 0.00386, "epss_percentile": 0.59283}, "CVE-2017-1000361": {"epss_score": 0.00494, "epss_percentile": 0.65098}, "CVE-2017-1000362": {"epss_score": 0.01234, "epss_percentile": 0.78758}, "CVE-2017-1000363": {"epss_score": 0.00562, "epss_percentile": 0.67706}, "CVE-2017-1000364": {"epss_score": 0.09599, "epss_percentile": 0.92616}, "CVE-2017-1000365": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2017-1000366": {"epss_score": 0.08164, "epss_percentile": 0.91911}, "CVE-2017-1000367": {"epss_score": 0.19435, "epss_percentile": 0.95181}, "CVE-2017-1000368": {"epss_score": 0.00166, "epss_percentile": 0.38146}, "CVE-2017-1000369": {"epss_score": 0.00286, "epss_percentile": 0.51709}, "CVE-2017-1000370": {"epss_score": 0.00984, "epss_percentile": 0.76317}, "CVE-2017-1000371": {"epss_score": 0.02099, "epss_percentile": 0.83596}, "CVE-2017-1000372": {"epss_score": 0.00922, "epss_percentile": 0.75486}, "CVE-2017-1000373": {"epss_score": 0.18752, "epss_percentile": 0.95064}, "CVE-2017-1000374": {"epss_score": 0.02723, "epss_percentile": 0.85522}, "CVE-2017-1000375": {"epss_score": 0.38409, "epss_percentile": 0.97099}, "CVE-2017-1000376": {"epss_score": 0.00419, "epss_percentile": 0.6138}, "CVE-2017-1000377": {"epss_score": 0.00076, "epss_percentile": 0.2316}, "CVE-2017-1000378": {"epss_score": 0.03981, "epss_percentile": 0.88059}, "CVE-2017-1000379": {"epss_score": 0.00519, "epss_percentile": 0.66167}, "CVE-2017-1000380": {"epss_score": 0.00326, "epss_percentile": 0.55091}, "CVE-2017-1000381": {"epss_score": 0.00374, "epss_percentile": 0.5859}, "CVE-2017-1000382": {"epss_score": 0.00129, "epss_percentile": 0.33117}, "CVE-2017-1000383": {"epss_score": 0.00142, "epss_percentile": 0.34969}, "CVE-2017-1000385": {"epss_score": 0.83282, "epss_percentile": 0.99241}, "CVE-2017-1000386": {"epss_score": 0.00042, "epss_percentile": 0.12891}, "CVE-2017-1000387": {"epss_score": 0.00013, "epss_percentile": 0.0161}, "CVE-2017-1000388": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2017-1000389": {"epss_score": 0.00065, "epss_percentile": 0.20466}, "CVE-2017-1000390": {"epss_score": 0.0002, "epss_percentile": 0.04525}, "CVE-2017-1000391": {"epss_score": 0.00202, "epss_percentile": 0.4244}, "CVE-2017-1000392": {"epss_score": 0.00155, "epss_percentile": 0.36843}, "CVE-2017-1000393": {"epss_score": 0.00535, "epss_percentile": 0.66832}, "CVE-2017-1000394": {"epss_score": 0.005, "epss_percentile": 0.65294}, "CVE-2017-1000395": {"epss_score": 0.00145, "epss_percentile": 0.35422}, "CVE-2017-1000396": {"epss_score": 0.0004, "epss_percentile": 0.12149}, "CVE-2017-1000397": {"epss_score": 0.00033, "epss_percentile": 0.09135}, "CVE-2017-1000398": {"epss_score": 0.00188, "epss_percentile": 0.40921}, "CVE-2017-1000399": {"epss_score": 0.00275, "epss_percentile": 0.5068}, "CVE-2017-1000400": {"epss_score": 0.00112, "epss_percentile": 0.3041}, "CVE-2017-1000401": {"epss_score": 0.00039, "epss_percentile": 0.11437}, "CVE-2017-1000402": {"epss_score": 0.00033, "epss_percentile": 0.09135}, "CVE-2017-1000403": {"epss_score": 0.00097, "epss_percentile": 0.27595}, "CVE-2017-1000404": {"epss_score": 0.00054, "epss_percentile": 0.17166}, "CVE-2017-1000405": {"epss_score": 0.04492, "epss_percentile": 0.88758}, "CVE-2017-1000406": {"epss_score": 0.00228, "epss_percentile": 0.45517}, "CVE-2017-1000407": {"epss_score": 0.00458, "epss_percentile": 0.6344}, "CVE-2017-1000408": {"epss_score": 0.00761, "epss_percentile": 0.72824}, "CVE-2017-1000409": {"epss_score": 0.00841, "epss_percentile": 0.74229}, "CVE-2017-1000410": {"epss_score": 0.01922, "epss_percentile": 0.82906}, "CVE-2017-1000411": {"epss_score": 0.00931, "epss_percentile": 0.75618}, "CVE-2017-1000412": {"epss_score": 0.00345, "epss_percentile": 0.56592}, "CVE-2017-1000413": {"epss_score": 0.00345, "epss_percentile": 0.56592}, "CVE-2017-1000414": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-1000415": {"epss_score": 0.00107, "epss_percentile": 0.29578}, "CVE-2017-1000416": {"epss_score": 0.00294, "epss_percentile": 0.52389}, "CVE-2017-1000417": {"epss_score": 0.00149, "epss_percentile": 0.36036}, "CVE-2017-1000418": {"epss_score": 0.00378, "epss_percentile": 0.58812}, "CVE-2017-1000419": {"epss_score": 0.0038, "epss_percentile": 0.58934}, "CVE-2017-1000420": {"epss_score": 0.00269, "epss_percentile": 0.50156}, "CVE-2017-1000421": {"epss_score": 0.00497, "epss_percentile": 0.65181}, "CVE-2017-1000422": {"epss_score": 0.00961, "epss_percentile": 0.75979}, "CVE-2017-1000423": {"epss_score": 0.01702, "epss_percentile": 0.81838}, "CVE-2017-1000424": {"epss_score": 0.00273, "epss_percentile": 0.5046}, "CVE-2017-1000425": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2017-1000426": {"epss_score": 0.00229, "epss_percentile": 0.45657}, "CVE-2017-1000427": {"epss_score": 0.00388, "epss_percentile": 0.59362}, "CVE-2017-1000428": {"epss_score": 0.00286, "epss_percentile": 0.51749}, "CVE-2017-1000429": {"epss_score": 0.00286, "epss_percentile": 0.51749}, "CVE-2017-1000430": {"epss_score": 0.00476, "epss_percentile": 0.6429}, "CVE-2017-1000431": {"epss_score": 0.00292, "epss_percentile": 0.52231}, "CVE-2017-1000432": {"epss_score": 0.00238, "epss_percentile": 0.46835}, "CVE-2017-1000433": {"epss_score": 0.02083, "epss_percentile": 0.83539}, "CVE-2017-1000434": {"epss_score": 0.00241, "epss_percentile": 0.47239}, "CVE-2017-1000437": {"epss_score": 0.03325, "epss_percentile": 0.8692}, "CVE-2017-1000438": {"epss_score": 0.00457, "epss_percentile": 0.6339}, "CVE-2017-1000442": {"epss_score": 0.0025, "epss_percentile": 0.4814}, "CVE-2017-1000443": {"epss_score": 0.00305, "epss_percentile": 0.53311}, "CVE-2017-1000444": {"epss_score": 0.01317, "epss_percentile": 0.79413}, "CVE-2017-1000445": {"epss_score": 0.01758, "epss_percentile": 0.82136}, "CVE-2017-1000448": {"epss_score": 0.00616, "epss_percentile": 0.69332}, "CVE-2017-1000450": {"epss_score": 0.02264, "epss_percentile": 0.84193}, "CVE-2017-1000451": {"epss_score": 0.00422, "epss_percentile": 0.61574}, "CVE-2017-1000452": {"epss_score": 0.00136, "epss_percentile": 0.34098}, "CVE-2017-1000453": {"epss_score": 0.00979, "epss_percentile": 0.76257}, "CVE-2017-1000454": {"epss_score": 0.00176, "epss_percentile": 0.39424}, "CVE-2017-1000455": {"epss_score": 0.00022, "epss_percentile": 0.05034}, "CVE-2017-1000456": {"epss_score": 0.00719, "epss_percentile": 0.7195}, "CVE-2017-1000457": {"epss_score": 0.00233, "epss_percentile": 0.45973}, "CVE-2017-1000458": {"epss_score": 0.00574, "epss_percentile": 0.68089}, "CVE-2017-1000459": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-1000460": {"epss_score": 0.00216, "epss_percentile": 0.44233}, "CVE-2017-1000461": {"epss_score": 0.00217, "epss_percentile": 0.44316}, "CVE-2017-1000462": {"epss_score": 0.0032, "epss_percentile": 0.54595}, "CVE-2017-1000463": {"epss_score": 0.00296, "epss_percentile": 0.52622}, "CVE-2017-1000465": {"epss_score": 0.00319, "epss_percentile": 0.54474}, "CVE-2017-1000466": {"epss_score": 0.00233, "epss_percentile": 0.46063}, "CVE-2017-1000467": {"epss_score": 0.00296, "epss_percentile": 0.52622}, "CVE-2017-1000469": {"epss_score": 0.0095, "epss_percentile": 0.75855}, "CVE-2017-1000470": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-1000471": {"epss_score": 0.00277, "epss_percentile": 0.50784}, "CVE-2017-1000472": {"epss_score": 0.00472, "epss_percentile": 0.64063}, "CVE-2017-1000473": {"epss_score": 0.00316, "epss_percentile": 0.54287}, "CVE-2017-1000474": {"epss_score": 0.02589, "epss_percentile": 0.85178}, "CVE-2017-1000475": {"epss_score": 0.00406, "epss_percentile": 0.60556}, "CVE-2017-1000476": {"epss_score": 0.00679, "epss_percentile": 0.71014}, "CVE-2017-1000477": {"epss_score": 0.00296, "epss_percentile": 0.52528}, "CVE-2017-1000478": {"epss_score": 0.0032, "epss_percentile": 0.54595}, "CVE-2017-1000479": {"epss_score": 0.18994, "epss_percentile": 0.95109}, "CVE-2017-1000480": {"epss_score": 0.00863, "epss_percentile": 0.74584}, "CVE-2017-1000481": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2017-1000482": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2017-1000483": {"epss_score": 0.00294, "epss_percentile": 0.52426}, "CVE-2017-1000484": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2017-1000485": {"epss_score": 0.00038, "epss_percentile": 0.1113}, "CVE-2017-1000486": {"epss_score": 0.94035, "epss_percentile": 0.9989}, "CVE-2017-1000487": {"epss_score": 0.22571, "epss_percentile": 0.95652}, "CVE-2017-1000488": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-1000489": {"epss_score": 0.00271, "epss_percentile": 0.5033}, "CVE-2017-1000490": {"epss_score": 0.00344, "epss_percentile": 0.56479}, "CVE-2017-1000491": {"epss_score": 0.00369, "epss_percentile": 0.58226}, "CVE-2017-1000492": {"epss_score": 0.00369, "epss_percentile": 0.58226}, "CVE-2017-1000493": {"epss_score": 0.00296, "epss_percentile": 0.52606}, "CVE-2017-1000494": {"epss_score": 0.0008, "epss_percentile": 0.24191}, "CVE-2017-1000495": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-1000496": {"epss_score": 0.00827, "epss_percentile": 0.73978}, "CVE-2017-1000497": {"epss_score": 0.01553, "epss_percentile": 0.80998}, "CVE-2017-1000498": {"epss_score": 0.01193, "epss_percentile": 0.7841}, "CVE-2017-1000499": {"epss_score": 0.11439, "epss_percentile": 0.93361}, "CVE-2017-1000501": {"epss_score": 0.05922, "epss_percentile": 0.90323}, "CVE-2017-1000502": {"epss_score": 0.00674, "epss_percentile": 0.70851}, "CVE-2017-1000503": {"epss_score": 0.02745, "epss_percentile": 0.85568}, "CVE-2017-1000504": {"epss_score": 0.01149, "epss_percentile": 0.78017}, "CVE-2017-1000505": {"epss_score": 0.00316, "epss_percentile": 0.54275}, "CVE-2017-1000506": {"epss_score": 0.00398, "epss_percentile": 0.60054}, "CVE-2017-1000507": {"epss_score": 0.0032, "epss_percentile": 0.54595}, "CVE-2017-1000508": {"epss_score": 0.00369, "epss_percentile": 0.58226}, "CVE-2017-1000509": {"epss_score": 0.00249, "epss_percentile": 0.48048}, "CVE-2017-1000510": {"epss_score": 0.0032, "epss_percentile": 0.54595}, "CVE-2017-1000600": {"epss_score": 0.20622, "epss_percentile": 0.95386}, "CVE-2017-1001000": {"epss_score": 0.80371, "epss_percentile": 0.99084}, "CVE-2017-1001001": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-1001002": {"epss_score": 0.01044, "epss_percentile": 0.76999}, "CVE-2017-1001003": {"epss_score": 0.00486, "epss_percentile": 0.64774}, "CVE-2017-1001004": {"epss_score": 0.0075, "epss_percentile": 0.7262}, "CVE-2017-1002000": {"epss_score": 0.64339, "epss_percentile": 0.98373}, "CVE-2017-1002001": {"epss_score": 0.44532, "epss_percentile": 0.97443}, "CVE-2017-1002002": {"epss_score": 0.51155, "epss_percentile": 0.97767}, "CVE-2017-1002003": {"epss_score": 0.4773, "epss_percentile": 0.97598}, "CVE-2017-1002004": {"epss_score": 0.05503, "epss_percentile": 0.8994}, "CVE-2017-1002005": {"epss_score": 0.05407, "epss_percentile": 0.8984}, "CVE-2017-1002006": {"epss_score": 0.04624, "epss_percentile": 0.88937}, "CVE-2017-1002007": {"epss_score": 0.04624, "epss_percentile": 0.88937}, "CVE-2017-1002008": {"epss_score": 0.39956, "epss_percentile": 0.97189}, "CVE-2017-1002009": {"epss_score": 0.0601, "epss_percentile": 0.90407}, "CVE-2017-1002010": {"epss_score": 0.0601, "epss_percentile": 0.90407}, "CVE-2017-1002011": {"epss_score": 0.00893, "epss_percentile": 0.75074}, "CVE-2017-1002012": {"epss_score": 0.10327, "epss_percentile": 0.92947}, "CVE-2017-1002013": {"epss_score": 0.0601, "epss_percentile": 0.90407}, "CVE-2017-1002014": {"epss_score": 0.0601, "epss_percentile": 0.90407}, "CVE-2017-1002015": {"epss_score": 0.0601, "epss_percentile": 0.90407}, "CVE-2017-1002016": {"epss_score": 0.1458, "epss_percentile": 0.94244}, "CVE-2017-1002017": {"epss_score": 0.00562, "epss_percentile": 0.67691}, "CVE-2017-1002018": {"epss_score": 0.0601, "epss_percentile": 0.90407}, "CVE-2017-1002019": {"epss_score": 0.0601, "epss_percentile": 0.90407}, "CVE-2017-1002020": {"epss_score": 0.10906, "epss_percentile": 0.93152}, "CVE-2017-1002021": {"epss_score": 0.10906, "epss_percentile": 0.93152}, "CVE-2017-1002022": {"epss_score": 0.10906, "epss_percentile": 0.93152}, "CVE-2017-1002023": {"epss_score": 0.10327, "epss_percentile": 0.92947}, "CVE-2017-1002024": {"epss_score": 0.00297, "epss_percentile": 0.52703}, "CVE-2017-1002025": {"epss_score": 0.00931, "epss_percentile": 0.75619}, "CVE-2017-1002026": {"epss_score": 0.00874, "epss_percentile": 0.74764}, "CVE-2017-1002027": {"epss_score": 0.01084, "epss_percentile": 0.77394}, "CVE-2017-1002028": {"epss_score": 0.00595, "epss_percentile": 0.68696}, "CVE-2017-1002100": {"epss_score": 0.00267, "epss_percentile": 0.49986}, "CVE-2017-1002101": {"epss_score": 0.31965, "epss_percentile": 0.96663}, "CVE-2017-1002102": {"epss_score": 0.00476, "epss_percentile": 0.6427}, "CVE-2017-1002150": {"epss_score": 0.00187, "epss_percentile": 0.40727}, "CVE-2017-1002151": {"epss_score": 0.00282, "epss_percentile": 0.51275}, "CVE-2017-1002152": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2017-1002153": {"epss_score": 0.0032, "epss_percentile": 0.54592}, "CVE-2017-1002157": {"epss_score": 0.00725, "epss_percentile": 0.72048}, "CVE-2017-1002201": {"epss_score": 0.00825, "epss_percentile": 0.73951}, "CVE-2017-10000": {"epss_score": 0.00367, "epss_percentile": 0.58114}, "CVE-2017-10001": {"epss_score": 0.00578, "epss_percentile": 0.68176}, "CVE-2017-10002": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10003": {"epss_score": 0.00063, "epss_percentile": 0.19893}, "CVE-2017-10004": {"epss_score": 0.00071, "epss_percentile": 0.22173}, "CVE-2017-10005": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10006": {"epss_score": 0.00492, "epss_percentile": 0.64995}, "CVE-2017-10007": {"epss_score": 0.00223, "epss_percentile": 0.44861}, "CVE-2017-10008": {"epss_score": 0.0021, "epss_percentile": 0.43487}, "CVE-2017-10009": {"epss_score": 0.00405, "epss_percentile": 0.60502}, "CVE-2017-10010": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2017-10011": {"epss_score": 0.00121, "epss_percentile": 0.31987}, "CVE-2017-10012": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10013": {"epss_score": 0.01923, "epss_percentile": 0.82913}, "CVE-2017-10014": {"epss_score": 0.00235, "epss_percentile": 0.46234}, "CVE-2017-10015": {"epss_score": 0.00143, "epss_percentile": 0.35186}, "CVE-2017-10016": {"epss_score": 0.0259, "epss_percentile": 0.85181}, "CVE-2017-10017": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10018": {"epss_score": 0.00405, "epss_percentile": 0.60502}, "CVE-2017-10019": {"epss_score": 0.01697, "epss_percentile": 0.81819}, "CVE-2017-10020": {"epss_score": 0.00121, "epss_percentile": 0.31987}, "CVE-2017-10021": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10022": {"epss_score": 0.00223, "epss_percentile": 0.44861}, "CVE-2017-10023": {"epss_score": 0.00753, "epss_percentile": 0.72681}, "CVE-2017-10024": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10025": {"epss_score": 0.01692, "epss_percentile": 0.81789}, "CVE-2017-10026": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10027": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2017-10028": {"epss_score": 0.01606, "epss_percentile": 0.81299}, "CVE-2017-10029": {"epss_score": 0.01606, "epss_percentile": 0.81299}, "CVE-2017-10030": {"epss_score": 0.01606, "epss_percentile": 0.81299}, "CVE-2017-10031": {"epss_score": 0.00403, "epss_percentile": 0.60381}, "CVE-2017-10032": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10033": {"epss_score": 0.00613, "epss_percentile": 0.69256}, "CVE-2017-10034": {"epss_score": 0.01842, "epss_percentile": 0.82501}, "CVE-2017-10035": {"epss_score": 0.01606, "epss_percentile": 0.81299}, "CVE-2017-10036": {"epss_score": 0.05561, "epss_percentile": 0.89994}, "CVE-2017-10037": {"epss_score": 0.0212, "epss_percentile": 0.83675}, "CVE-2017-10038": {"epss_score": 0.00691, "epss_percentile": 0.71272}, "CVE-2017-10039": {"epss_score": 0.00715, "epss_percentile": 0.71839}, "CVE-2017-10040": {"epss_score": 0.00873, "epss_percentile": 0.74751}, "CVE-2017-10041": {"epss_score": 0.00522, "epss_percentile": 0.66277}, "CVE-2017-10042": {"epss_score": 0.05561, "epss_percentile": 0.89994}, "CVE-2017-10043": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10044": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10045": {"epss_score": 0.02095, "epss_percentile": 0.83583}, "CVE-2017-10046": {"epss_score": 0.01002, "epss_percentile": 0.76508}, "CVE-2017-10047": {"epss_score": 0.00403, "epss_percentile": 0.60381}, "CVE-2017-10048": {"epss_score": 0.01606, "epss_percentile": 0.81299}, "CVE-2017-10049": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10050": {"epss_score": 0.00947, "epss_percentile": 0.75823}, "CVE-2017-10051": {"epss_score": 0.00304, "epss_percentile": 0.53292}, "CVE-2017-10052": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10053": {"epss_score": 0.0128, "epss_percentile": 0.79139}, "CVE-2017-10054": {"epss_score": 0.00142, "epss_percentile": 0.34977}, "CVE-2017-10055": {"epss_score": 0.00389, "epss_percentile": 0.59464}, "CVE-2017-10056": {"epss_score": 0.00121, "epss_percentile": 0.31987}, "CVE-2017-10057": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2017-10058": {"epss_score": 0.00293, "epss_percentile": 0.52303}, "CVE-2017-10059": {"epss_score": 0.00522, "epss_percentile": 0.66277}, "CVE-2017-10060": {"epss_score": 0.01606, "epss_percentile": 0.81299}, "CVE-2017-10061": {"epss_score": 0.00911, "epss_percentile": 0.75328}, "CVE-2017-10062": {"epss_score": 0.00063, "epss_percentile": 0.19893}, "CVE-2017-10063": {"epss_score": 0.00959, "epss_percentile": 0.75961}, "CVE-2017-10064": {"epss_score": 0.00511, "epss_percentile": 0.6582}, "CVE-2017-10065": {"epss_score": 0.00247, "epss_percentile": 0.47888}, "CVE-2017-10066": {"epss_score": 0.01456, "epss_percentile": 0.80395}, "CVE-2017-10067": {"epss_score": 0.00866, "epss_percentile": 0.74632}, "CVE-2017-10068": {"epss_score": 0.02172, "epss_percentile": 0.83875}, "CVE-2017-10069": {"epss_score": 0.00738, "epss_percentile": 0.72341}, "CVE-2017-10070": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10071": {"epss_score": 0.01058, "epss_percentile": 0.77145}, "CVE-2017-10072": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10073": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2017-10074": {"epss_score": 0.01893, "epss_percentile": 0.82738}, "CVE-2017-10075": {"epss_score": 0.8913, "epss_percentile": 0.9951}, "CVE-2017-10076": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10077": {"epss_score": 0.01109, "epss_percentile": 0.77653}, "CVE-2017-10078": {"epss_score": 0.01518, "epss_percentile": 0.80813}, "CVE-2017-10079": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10080": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10081": {"epss_score": 0.00293, "epss_percentile": 0.5235}, "CVE-2017-10082": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10083": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10084": {"epss_score": 0.00753, "epss_percentile": 0.72681}, "CVE-2017-10085": {"epss_score": 0.00671, "epss_percentile": 0.70796}, "CVE-2017-10086": {"epss_score": 0.01124, "epss_percentile": 0.77797}, "CVE-2017-10087": {"epss_score": 0.00468, "epss_percentile": 0.63907}, "CVE-2017-10088": {"epss_score": 0.00063, "epss_percentile": 0.19875}, "CVE-2017-10089": {"epss_score": 0.00468, "epss_percentile": 0.63907}, "CVE-2017-10090": {"epss_score": 0.00489, "epss_percentile": 0.64913}, "CVE-2017-10091": {"epss_score": 0.00492, "epss_percentile": 0.64995}, "CVE-2017-10092": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10093": {"epss_score": 0.00416, "epss_percentile": 0.61161}, "CVE-2017-10094": {"epss_score": 0.00183, "epss_percentile": 0.4029}, "CVE-2017-10095": {"epss_score": 0.00138, "epss_percentile": 0.34365}, "CVE-2017-10096": {"epss_score": 0.00468, "epss_percentile": 0.63907}, "CVE-2017-10097": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10098": {"epss_score": 0.00173, "epss_percentile": 0.39079}, "CVE-2017-10099": {"epss_score": 0.00108, "epss_percentile": 0.2986}, "CVE-2017-10100": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10101": {"epss_score": 0.00468, "epss_percentile": 0.63907}, "CVE-2017-10102": {"epss_score": 0.00673, "epss_percentile": 0.70836}, "CVE-2017-10103": {"epss_score": 0.00658, "epss_percentile": 0.70483}, "CVE-2017-10104": {"epss_score": 0.00362, "epss_percentile": 0.57752}, "CVE-2017-10105": {"epss_score": 0.00499, "epss_percentile": 0.65249}, "CVE-2017-10106": {"epss_score": 0.00806, "epss_percentile": 0.73664}, "CVE-2017-10107": {"epss_score": 0.00468, "epss_percentile": 0.63907}, "CVE-2017-10108": {"epss_score": 0.007, "epss_percentile": 0.71485}, "CVE-2017-10109": {"epss_score": 0.007, "epss_percentile": 0.71485}, "CVE-2017-10110": {"epss_score": 0.00468, "epss_percentile": 0.63907}, "CVE-2017-10111": {"epss_score": 0.01124, "epss_percentile": 0.77797}, "CVE-2017-10112": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-10113": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10114": {"epss_score": 0.01749, "epss_percentile": 0.82085}, "CVE-2017-10115": {"epss_score": 0.00508, "epss_percentile": 0.65712}, "CVE-2017-10116": {"epss_score": 0.00937, "epss_percentile": 0.75691}, "CVE-2017-10117": {"epss_score": 0.00848, "epss_percentile": 0.74365}, "CVE-2017-10118": {"epss_score": 0.00753, "epss_percentile": 0.72677}, "CVE-2017-10119": {"epss_score": 0.00485, "epss_percentile": 0.64713}, "CVE-2017-10120": {"epss_score": 0.00081, "epss_percentile": 0.24354}, "CVE-2017-10121": {"epss_score": 0.00708, "epss_percentile": 0.71684}, "CVE-2017-10122": {"epss_score": 0.00096, "epss_percentile": 0.27417}, "CVE-2017-10123": {"epss_score": 0.00204, "epss_percentile": 0.42652}, "CVE-2017-10125": {"epss_score": 0.00236, "epss_percentile": 0.46455}, "CVE-2017-10126": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10128": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2017-10129": {"epss_score": 0.00457, "epss_percentile": 0.6337}, "CVE-2017-10130": {"epss_score": 0.00522, "epss_percentile": 0.66277}, "CVE-2017-10131": {"epss_score": 0.00245, "epss_percentile": 0.47666}, "CVE-2017-10132": {"epss_score": 0.00405, "epss_percentile": 0.60502}, "CVE-2017-10133": {"epss_score": 0.00405, "epss_percentile": 0.60502}, "CVE-2017-10134": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2017-10135": {"epss_score": 0.00405, "epss_percentile": 0.60478}, "CVE-2017-10136": {"epss_score": 0.01284, "epss_percentile": 0.79172}, "CVE-2017-10137": {"epss_score": 0.04726, "epss_percentile": 0.89065}, "CVE-2017-10140": {"epss_score": 0.00216, "epss_percentile": 0.4414}, "CVE-2017-10141": {"epss_score": 0.03267, "epss_percentile": 0.86786}, "CVE-2017-10142": {"epss_score": 0.00173, "epss_percentile": 0.39079}, "CVE-2017-10143": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10144": {"epss_score": 0.04372, "epss_percentile": 0.88611}, "CVE-2017-10145": {"epss_score": 0.00414, "epss_percentile": 0.61103}, "CVE-2017-10146": {"epss_score": 0.00746, "epss_percentile": 0.72544}, "CVE-2017-10147": {"epss_score": 0.08627, "epss_percentile": 0.9216}, "CVE-2017-10148": {"epss_score": 0.02253, "epss_percentile": 0.84164}, "CVE-2017-10149": {"epss_score": 0.00221, "epss_percentile": 0.44713}, "CVE-2017-10150": {"epss_score": 0.00405, "epss_percentile": 0.60502}, "CVE-2017-10151": {"epss_score": 0.13792, "epss_percentile": 0.94058}, "CVE-2017-10152": {"epss_score": 0.01242, "epss_percentile": 0.78823}, "CVE-2017-10153": {"epss_score": 0.00507, "epss_percentile": 0.65657}, "CVE-2017-10154": {"epss_score": 0.00508, "epss_percentile": 0.65705}, "CVE-2017-10155": {"epss_score": 0.01426, "epss_percentile": 0.80205}, "CVE-2017-10156": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10157": {"epss_score": 0.00403, "epss_percentile": 0.60381}, "CVE-2017-10158": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10159": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10160": {"epss_score": 0.00204, "epss_percentile": 0.42652}, "CVE-2017-10161": {"epss_score": 0.00407, "epss_percentile": 0.60594}, "CVE-2017-10162": {"epss_score": 0.00187, "epss_percentile": 0.40747}, "CVE-2017-10163": {"epss_score": 0.00277, "epss_percentile": 0.50799}, "CVE-2017-10164": {"epss_score": 0.00223, "epss_percentile": 0.44861}, "CVE-2017-10165": {"epss_score": 0.00355, "epss_percentile": 0.57298}, "CVE-2017-10166": {"epss_score": 0.00845, "epss_percentile": 0.74289}, "CVE-2017-10167": {"epss_score": 0.00449, "epss_percentile": 0.6304}, "CVE-2017-10168": {"epss_score": 0.0017, "epss_percentile": 0.38667}, "CVE-2017-10169": {"epss_score": 0.00121, "epss_percentile": 0.31987}, "CVE-2017-10170": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10171": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10172": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10173": {"epss_score": 0.01774, "epss_percentile": 0.82211}, "CVE-2017-10174": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10175": {"epss_score": 0.00223, "epss_percentile": 0.44861}, "CVE-2017-10176": {"epss_score": 0.01766, "epss_percentile": 0.82171}, "CVE-2017-10177": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2017-10178": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2017-10179": {"epss_score": 0.00403, "epss_percentile": 0.60381}, "CVE-2017-10180": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10181": {"epss_score": 0.00275, "epss_percentile": 0.50652}, "CVE-2017-10182": {"epss_score": 0.00587, "epss_percentile": 0.68475}, "CVE-2017-10183": {"epss_score": 0.00472, "epss_percentile": 0.6407}, "CVE-2017-10184": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2017-10185": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10186": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2017-10187": {"epss_score": 0.00088, "epss_percentile": 0.2578}, "CVE-2017-10188": {"epss_score": 0.00121, "epss_percentile": 0.31987}, "CVE-2017-10189": {"epss_score": 0.00121, "epss_percentile": 0.31987}, "CVE-2017-10190": {"epss_score": 0.00101, "epss_percentile": 0.28602}, "CVE-2017-10191": {"epss_score": 0.01606, "epss_percentile": 0.81299}, "CVE-2017-10192": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2017-10193": {"epss_score": 0.00493, "epss_percentile": 0.65064}, "CVE-2017-10194": {"epss_score": 0.00216, "epss_percentile": 0.44127}, "CVE-2017-10195": {"epss_score": 0.01058, "epss_percentile": 0.77145}, "CVE-2017-10196": {"epss_score": 0.03068, "epss_percentile": 0.86341}, "CVE-2017-10197": {"epss_score": 0.00116, "epss_percentile": 0.31194}, "CVE-2017-10198": {"epss_score": 0.00335, "epss_percentile": 0.55811}, "CVE-2017-10199": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10200": {"epss_score": 0.0006, "epss_percentile": 0.19237}, "CVE-2017-10201": {"epss_score": 0.00121, "epss_percentile": 0.31987}, "CVE-2017-10202": {"epss_score": 0.02138, "epss_percentile": 0.8374}, "CVE-2017-10203": {"epss_score": 0.01706, "epss_percentile": 0.81854}, "CVE-2017-10204": {"epss_score": 0.00347, "epss_percentile": 0.56747}, "CVE-2017-10205": {"epss_score": 0.00223, "epss_percentile": 0.44861}, "CVE-2017-10206": {"epss_score": 0.00551, "epss_percentile": 0.67378}, "CVE-2017-10207": {"epss_score": 0.02507, "epss_percentile": 0.8494}, "CVE-2017-10208": {"epss_score": 0.00223, "epss_percentile": 0.44861}, "CVE-2017-10209": {"epss_score": 0.00058, "epss_percentile": 0.18272}, "CVE-2017-10210": {"epss_score": 0.00078, "epss_percentile": 0.23757}, "CVE-2017-10211": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2017-10212": {"epss_score": 0.00691, "epss_percentile": 0.71272}, "CVE-2017-10213": {"epss_score": 0.00185, "epss_percentile": 0.405}, "CVE-2017-10214": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2017-10215": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10216": {"epss_score": 0.00753, "epss_percentile": 0.72681}, "CVE-2017-10217": {"epss_score": 0.00405, "epss_percentile": 0.60502}, "CVE-2017-10218": {"epss_score": 0.00223, "epss_percentile": 0.44861}, "CVE-2017-10219": {"epss_score": 0.00121, "epss_percentile": 0.31987}, "CVE-2017-10220": {"epss_score": 0.00151, "epss_percentile": 0.36314}, "CVE-2017-10221": {"epss_score": 0.00063, "epss_percentile": 0.19893}, "CVE-2017-10222": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10223": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10224": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10225": {"epss_score": 0.0009, "epss_percentile": 0.26162}, "CVE-2017-10226": {"epss_score": 0.00671, "epss_percentile": 0.70796}, "CVE-2017-10227": {"epss_score": 0.00516, "epss_percentile": 0.66057}, "CVE-2017-10228": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10229": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10230": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10231": {"epss_score": 0.00121, "epss_percentile": 0.31987}, "CVE-2017-10232": {"epss_score": 0.00678, "epss_percentile": 0.70991}, "CVE-2017-10233": {"epss_score": 0.00073, "epss_percentile": 0.22503}, "CVE-2017-10234": {"epss_score": 0.00076, "epss_percentile": 0.23107}, "CVE-2017-10235": {"epss_score": 0.0231, "epss_percentile": 0.84336}, "CVE-2017-10236": {"epss_score": 0.00059, "epss_percentile": 0.18802}, "CVE-2017-10237": {"epss_score": 0.00061, "epss_percentile": 0.1952}, "CVE-2017-10238": {"epss_score": 0.00061, "epss_percentile": 0.1952}, "CVE-2017-10239": {"epss_score": 0.00061, "epss_percentile": 0.1952}, "CVE-2017-10240": {"epss_score": 0.00059, "epss_percentile": 0.18802}, "CVE-2017-10241": {"epss_score": 0.00061, "epss_percentile": 0.1952}, "CVE-2017-10242": {"epss_score": 0.00061, "epss_percentile": 0.1952}, "CVE-2017-10243": {"epss_score": 0.00949, "epss_percentile": 0.75846}, "CVE-2017-10244": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2017-10245": {"epss_score": 0.02348, "epss_percentile": 0.84462}, "CVE-2017-10246": {"epss_score": 0.12912, "epss_percentile": 0.93815}, "CVE-2017-10247": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10248": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10249": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10250": {"epss_score": 0.00121, "epss_percentile": 0.31987}, "CVE-2017-10251": {"epss_score": 0.00121, "epss_percentile": 0.31987}, "CVE-2017-10252": {"epss_score": 0.00121, "epss_percentile": 0.31987}, "CVE-2017-10253": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10254": {"epss_score": 0.00217, "epss_percentile": 0.44267}, "CVE-2017-10255": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10256": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10257": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10258": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10259": {"epss_score": 0.0212, "epss_percentile": 0.83675}, "CVE-2017-10260": {"epss_score": 0.01599, "epss_percentile": 0.81251}, "CVE-2017-10261": {"epss_score": 0.00355, "epss_percentile": 0.57312}, "CVE-2017-10262": {"epss_score": 0.01323, "epss_percentile": 0.79457}, "CVE-2017-10263": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-10264": {"epss_score": 0.01469, "epss_percentile": 0.80487}, "CVE-2017-10265": {"epss_score": 0.00678, "epss_percentile": 0.71002}, "CVE-2017-10266": {"epss_score": 0.00511, "epss_percentile": 0.65849}, "CVE-2017-10267": {"epss_score": 0.00949, "epss_percentile": 0.75842}, "CVE-2017-10268": {"epss_score": 0.00046, "epss_percentile": 0.14145}, "CVE-2017-10269": {"epss_score": 0.02099, "epss_percentile": 0.83595}, "CVE-2017-10270": {"epss_score": 0.00183, "epss_percentile": 0.40346}, "CVE-2017-10271": {"epss_score": 0.94439, "epss_percentile": 0.99987}, "CVE-2017-10272": {"epss_score": 0.01325, "epss_percentile": 0.79476}, "CVE-2017-10273": {"epss_score": 0.00137, "epss_percentile": 0.34213}, "CVE-2017-10274": {"epss_score": 0.00607, "epss_percentile": 0.69052}, "CVE-2017-10275": {"epss_score": 0.0014, "epss_percentile": 0.34728}, "CVE-2017-10276": {"epss_score": 0.00949, "epss_percentile": 0.75848}, "CVE-2017-10277": {"epss_score": 0.00901, "epss_percentile": 0.75181}, "CVE-2017-10278": {"epss_score": 0.01157, "epss_percentile": 0.78114}, "CVE-2017-10279": {"epss_score": 0.00516, "epss_percentile": 0.66057}, "CVE-2017-10280": {"epss_score": 0.0073, "epss_percentile": 0.72154}, "CVE-2017-10281": {"epss_score": 0.00734, "epss_percentile": 0.72251}, "CVE-2017-10282": {"epss_score": 0.01898, "epss_percentile": 0.82759}, "CVE-2017-10283": {"epss_score": 0.00499, "epss_percentile": 0.65261}, "CVE-2017-10284": {"epss_score": 0.00355, "epss_percentile": 0.57298}, "CVE-2017-10285": {"epss_score": 0.00578, "epss_percentile": 0.682}, "CVE-2017-10286": {"epss_score": 0.00534, "epss_percentile": 0.66802}, "CVE-2017-10287": {"epss_score": 0.00203, "epss_percentile": 0.42531}, "CVE-2017-10292": {"epss_score": 0.00066, "epss_percentile": 0.20911}, "CVE-2017-10293": {"epss_score": 0.00432, "epss_percentile": 0.62104}, "CVE-2017-10294": {"epss_score": 0.00267, "epss_percentile": 0.49978}, "CVE-2017-10295": {"epss_score": 0.00352, "epss_percentile": 0.57098}, "CVE-2017-10296": {"epss_score": 0.00452, "epss_percentile": 0.63177}, "CVE-2017-10299": {"epss_score": 0.0021, "epss_percentile": 0.43487}, "CVE-2017-10300": {"epss_score": 0.00511, "epss_percentile": 0.65849}, "CVE-2017-10301": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2017-10302": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2017-10303": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10304": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2017-10306": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2017-10308": {"epss_score": 0.00064, "epss_percentile": 0.20309}, "CVE-2017-10309": {"epss_score": 0.01803, "epss_percentile": 0.82342}, "CVE-2017-10310": {"epss_score": 0.02011, "epss_percentile": 0.83249}, "CVE-2017-10311": {"epss_score": 0.00355, "epss_percentile": 0.57298}, "CVE-2017-10312": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10313": {"epss_score": 0.00355, "epss_percentile": 0.57298}, "CVE-2017-10314": {"epss_score": 0.00522, "epss_percentile": 0.66249}, "CVE-2017-10315": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2017-10316": {"epss_score": 0.00458, "epss_percentile": 0.63428}, "CVE-2017-10317": {"epss_score": 0.00179, "epss_percentile": 0.39748}, "CVE-2017-10318": {"epss_score": 0.00526, "epss_percentile": 0.66414}, "CVE-2017-10319": {"epss_score": 0.00511, "epss_percentile": 0.65849}, "CVE-2017-10320": {"epss_score": 0.00373, "epss_percentile": 0.58516}, "CVE-2017-10321": {"epss_score": 0.00076, "epss_percentile": 0.23107}, "CVE-2017-10322": {"epss_score": 0.01456, "epss_percentile": 0.80395}, "CVE-2017-10323": {"epss_score": 0.01606, "epss_percentile": 0.81299}, "CVE-2017-10324": {"epss_score": 0.00416, "epss_percentile": 0.61161}, "CVE-2017-10325": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10326": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10327": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10328": {"epss_score": 0.01742, "epss_percentile": 0.82052}, "CVE-2017-10329": {"epss_score": 0.02197, "epss_percentile": 0.83959}, "CVE-2017-10330": {"epss_score": 0.02197, "epss_percentile": 0.83959}, "CVE-2017-10331": {"epss_score": 0.00416, "epss_percentile": 0.61161}, "CVE-2017-10332": {"epss_score": 0.01742, "epss_percentile": 0.82052}, "CVE-2017-10333": {"epss_score": 0.00284, "epss_percentile": 0.51443}, "CVE-2017-10334": {"epss_score": 0.00262, "epss_percentile": 0.49344}, "CVE-2017-10335": {"epss_score": 0.01742, "epss_percentile": 0.82052}, "CVE-2017-10336": {"epss_score": 0.01774, "epss_percentile": 0.82211}, "CVE-2017-10337": {"epss_score": 0.00319, "epss_percentile": 0.5453}, "CVE-2017-10338": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10339": {"epss_score": 0.00779, "epss_percentile": 0.73147}, "CVE-2017-10340": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2017-10341": {"epss_score": 0.00619, "epss_percentile": 0.69395}, "CVE-2017-10342": {"epss_score": 0.01859, "epss_percentile": 0.82584}, "CVE-2017-10343": {"epss_score": 0.01002, "epss_percentile": 0.76506}, "CVE-2017-10344": {"epss_score": 0.00777, "epss_percentile": 0.73109}, "CVE-2017-10345": {"epss_score": 0.00762, "epss_percentile": 0.72843}, "CVE-2017-10346": {"epss_score": 0.00578, "epss_percentile": 0.682}, "CVE-2017-10347": {"epss_score": 0.00734, "epss_percentile": 0.72251}, "CVE-2017-10348": {"epss_score": 0.00734, "epss_percentile": 0.72251}, "CVE-2017-10349": {"epss_score": 0.00734, "epss_percentile": 0.72251}, "CVE-2017-10350": {"epss_score": 0.00734, "epss_percentile": 0.72251}, "CVE-2017-10351": {"epss_score": 0.00188, "epss_percentile": 0.40852}, "CVE-2017-10352": {"epss_score": 0.27739, "epss_percentile": 0.96278}, "CVE-2017-10353": {"epss_score": 0.00762, "epss_percentile": 0.72833}, "CVE-2017-10354": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2017-10355": {"epss_score": 0.06296, "epss_percentile": 0.90652}, "CVE-2017-10356": {"epss_score": 0.00594, "epss_percentile": 0.68652}, "CVE-2017-10357": {"epss_score": 0.00734, "epss_percentile": 0.72251}, "CVE-2017-10358": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2017-10359": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2017-10360": {"epss_score": 0.00873, "epss_percentile": 0.74751}, "CVE-2017-10361": {"epss_score": 0.00319, "epss_percentile": 0.5453}, "CVE-2017-10362": {"epss_score": 0.00568, "epss_percentile": 0.67891}, "CVE-2017-10363": {"epss_score": 0.00671, "epss_percentile": 0.70796}, "CVE-2017-10364": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2017-10365": {"epss_score": 0.00394, "epss_percentile": 0.59759}, "CVE-2017-10366": {"epss_score": 0.64382, "epss_percentile": 0.98376}, "CVE-2017-10367": {"epss_score": 0.00492, "epss_percentile": 0.64994}, "CVE-2017-10368": {"epss_score": 0.0047, "epss_percentile": 0.63985}, "CVE-2017-10369": {"epss_score": 0.00597, "epss_percentile": 0.68748}, "CVE-2017-10370": {"epss_score": 0.00308, "epss_percentile": 0.53607}, "CVE-2017-10372": {"epss_score": 0.00346, "epss_percentile": 0.56674}, "CVE-2017-10373": {"epss_score": 0.00631, "epss_percentile": 0.6972}, "CVE-2017-10375": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2017-10378": {"epss_score": 0.00303, "epss_percentile": 0.53224}, "CVE-2017-10379": {"epss_score": 0.00351, "epss_percentile": 0.57004}, "CVE-2017-10380": {"epss_score": 0.00545, "epss_percentile": 0.67156}, "CVE-2017-10381": {"epss_score": 0.0047, "epss_percentile": 0.63985}, "CVE-2017-10382": {"epss_score": 0.00549, "epss_percentile": 0.67298}, "CVE-2017-10383": {"epss_score": 0.0048, "epss_percentile": 0.64459}, "CVE-2017-10384": {"epss_score": 0.00666, "epss_percentile": 0.70687}, "CVE-2017-10385": {"epss_score": 0.0039, "epss_percentile": 0.59548}, "CVE-2017-10386": {"epss_score": 0.0031, "epss_percentile": 0.53757}, "CVE-2017-10387": {"epss_score": 0.00549, "epss_percentile": 0.67298}, "CVE-2017-10388": {"epss_score": 0.00544, "epss_percentile": 0.67136}, "CVE-2017-10389": {"epss_score": 0.0009, "epss_percentile": 0.25999}, "CVE-2017-10391": {"epss_score": 0.00682, "epss_percentile": 0.71064}, "CVE-2017-10392": {"epss_score": 0.00053, "epss_percentile": 0.16899}, "CVE-2017-10393": {"epss_score": 0.00405, "epss_percentile": 0.60506}, "CVE-2017-10394": {"epss_score": 0.00327, "epss_percentile": 0.55098}, "CVE-2017-10395": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2017-10396": {"epss_score": 0.00438, "epss_percentile": 0.62566}, "CVE-2017-10397": {"epss_score": 0.00492, "epss_percentile": 0.64994}, "CVE-2017-10398": {"epss_score": 0.00105, "epss_percentile": 0.29391}, "CVE-2017-10399": {"epss_score": 0.00298, "epss_percentile": 0.5281}, "CVE-2017-10400": {"epss_score": 0.00395, "epss_percentile": 0.59831}, "CVE-2017-10401": {"epss_score": 0.00042, "epss_percentile": 0.12902}, "CVE-2017-10402": {"epss_score": 0.01652, "epss_percentile": 0.81576}, "CVE-2017-10403": {"epss_score": 0.00915, "epss_percentile": 0.75397}, "CVE-2017-10404": {"epss_score": 0.01043, "epss_percentile": 0.76994}, "CVE-2017-10405": {"epss_score": 0.01739, "epss_percentile": 0.82039}, "CVE-2017-10406": {"epss_score": 0.0047, "epss_percentile": 0.63985}, "CVE-2017-10407": {"epss_score": 0.00068, "epss_percentile": 0.21233}, "CVE-2017-10408": {"epss_score": 0.00051, "epss_percentile": 0.16193}, "CVE-2017-10409": {"epss_score": 0.00866, "epss_percentile": 0.74639}, "CVE-2017-10410": {"epss_score": 0.00866, "epss_percentile": 0.74639}, "CVE-2017-10411": {"epss_score": 0.00866, "epss_percentile": 0.74639}, "CVE-2017-10412": {"epss_score": 0.00866, "epss_percentile": 0.74639}, "CVE-2017-10413": {"epss_score": 0.00925, "epss_percentile": 0.75527}, "CVE-2017-10414": {"epss_score": 0.00866, "epss_percentile": 0.74639}, "CVE-2017-10415": {"epss_score": 0.00866, "epss_percentile": 0.74639}, "CVE-2017-10416": {"epss_score": 0.00866, "epss_percentile": 0.74639}, "CVE-2017-10417": {"epss_score": 0.00866, "epss_percentile": 0.74639}, "CVE-2017-10418": {"epss_score": 0.00208, "epss_percentile": 0.4322}, "CVE-2017-10419": {"epss_score": 0.00102, "epss_percentile": 0.28806}, "CVE-2017-10420": {"epss_score": 0.00289, "epss_percentile": 0.52051}, "CVE-2017-10421": {"epss_score": 0.00319, "epss_percentile": 0.54564}, "CVE-2017-10422": {"epss_score": 0.00532, "epss_percentile": 0.66673}, "CVE-2017-10423": {"epss_score": 0.00219, "epss_percentile": 0.4453}, "CVE-2017-10424": {"epss_score": 0.0098, "epss_percentile": 0.76269}, "CVE-2017-10425": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2017-10426": {"epss_score": 0.00239, "epss_percentile": 0.46923}, "CVE-2017-10427": {"epss_score": 0.0048, "epss_percentile": 0.64469}, "CVE-2017-10428": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2017-10600": {"epss_score": 0.00046, "epss_percentile": 0.14327}, "CVE-2017-10601": {"epss_score": 0.00421, "epss_percentile": 0.61509}, "CVE-2017-10602": {"epss_score": 0.00071, "epss_percentile": 0.22051}, "CVE-2017-10603": {"epss_score": 0.0009, "epss_percentile": 0.25997}, "CVE-2017-10604": {"epss_score": 0.00337, "epss_percentile": 0.56017}, "CVE-2017-10605": {"epss_score": 0.00772, "epss_percentile": 0.73045}, "CVE-2017-10606": {"epss_score": 0.00053, "epss_percentile": 0.16741}, "CVE-2017-10607": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2017-10608": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2017-10610": {"epss_score": 0.00367, "epss_percentile": 0.58139}, "CVE-2017-10611": {"epss_score": 0.0025, "epss_percentile": 0.48092}, "CVE-2017-10612": {"epss_score": 0.00391, "epss_percentile": 0.59575}, "CVE-2017-10613": {"epss_score": 0.00045, "epss_percentile": 0.1375}, "CVE-2017-10614": {"epss_score": 0.00355, "epss_percentile": 0.57264}, "CVE-2017-10615": {"epss_score": 0.01716, "epss_percentile": 0.81907}, "CVE-2017-10616": {"epss_score": 0.00599, "epss_percentile": 0.68785}, "CVE-2017-10617": {"epss_score": 0.08568, "epss_percentile": 0.92129}, "CVE-2017-10618": {"epss_score": 0.00295, "epss_percentile": 0.52448}, "CVE-2017-10619": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2017-10620": {"epss_score": 0.00169, "epss_percentile": 0.38628}, "CVE-2017-10621": {"epss_score": 0.00353, "epss_percentile": 0.5716}, "CVE-2017-10622": {"epss_score": 0.21512, "epss_percentile": 0.95527}, "CVE-2017-10623": {"epss_score": 0.00234, "epss_percentile": 0.46086}, "CVE-2017-10624": {"epss_score": 0.00098, "epss_percentile": 0.27676}, "CVE-2017-10661": {"epss_score": 0.27639, "epss_percentile": 0.96268}, "CVE-2017-10662": {"epss_score": 0.00099, "epss_percentile": 0.28381}, "CVE-2017-10663": {"epss_score": 0.00092, "epss_percentile": 0.2657}, "CVE-2017-10664": {"epss_score": 0.06241, "epss_percentile": 0.90592}, "CVE-2017-10665": {"epss_score": 0.01348, "epss_percentile": 0.79661}, "CVE-2017-10667": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-10668": {"epss_score": 0.0008, "epss_percentile": 0.24008}, "CVE-2017-10669": {"epss_score": 0.00131, "epss_percentile": 0.33378}, "CVE-2017-10670": {"epss_score": 0.00368, "epss_percentile": 0.58177}, "CVE-2017-10671": {"epss_score": 0.00287, "epss_percentile": 0.51835}, "CVE-2017-10672": {"epss_score": 0.12353, "epss_percentile": 0.93647}, "CVE-2017-10673": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-10674": {"epss_score": 0.00043, "epss_percentile": 0.13231}, "CVE-2017-10676": {"epss_score": 0.00219, "epss_percentile": 0.44512}, "CVE-2017-10677": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2017-10678": {"epss_score": 0.00179, "epss_percentile": 0.39798}, "CVE-2017-10679": {"epss_score": 0.00318, "epss_percentile": 0.54451}, "CVE-2017-10680": {"epss_score": 0.00179, "epss_percentile": 0.39798}, "CVE-2017-10681": {"epss_score": 0.00179, "epss_percentile": 0.39798}, "CVE-2017-10682": {"epss_score": 0.00317, "epss_percentile": 0.54329}, "CVE-2017-10683": {"epss_score": 0.00666, "epss_percentile": 0.70688}, "CVE-2017-10684": {"epss_score": 0.032, "epss_percentile": 0.86621}, "CVE-2017-10685": {"epss_score": 0.01126, "epss_percentile": 0.77809}, "CVE-2017-10686": {"epss_score": 0.00621, "epss_percentile": 0.69483}, "CVE-2017-10687": {"epss_score": 0.00418, "epss_percentile": 0.61265}, "CVE-2017-10688": {"epss_score": 0.06845, "epss_percentile": 0.91065}, "CVE-2017-10689": {"epss_score": 0.00092, "epss_percentile": 0.26424}, "CVE-2017-10690": {"epss_score": 0.00193, "epss_percentile": 0.41455}, "CVE-2017-10699": {"epss_score": 0.00536, "epss_percentile": 0.66847}, "CVE-2017-10700": {"epss_score": 0.01271, "epss_percentile": 0.79052}, "CVE-2017-10701": {"epss_score": 0.00511, "epss_percentile": 0.65841}, "CVE-2017-10706": {"epss_score": 0.00059, "epss_percentile": 0.18626}, "CVE-2017-10708": {"epss_score": 0.00777, "epss_percentile": 0.73116}, "CVE-2017-10709": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2017-10711": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-10718": {"epss_score": 0.00354, "epss_percentile": 0.57224}, "CVE-2017-10719": {"epss_score": 0.00427, "epss_percentile": 0.6178}, "CVE-2017-10720": {"epss_score": 0.00241, "epss_percentile": 0.47282}, "CVE-2017-10721": {"epss_score": 0.00268, "epss_percentile": 0.50036}, "CVE-2017-10722": {"epss_score": 0.00241, "epss_percentile": 0.47282}, "CVE-2017-10723": {"epss_score": 0.00488, "epss_percentile": 0.64866}, "CVE-2017-10724": {"epss_score": 0.00488, "epss_percentile": 0.64866}, "CVE-2017-10725": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-10726": {"epss_score": 0.00364, "epss_percentile": 0.57916}, "CVE-2017-10727": {"epss_score": 0.00364, "epss_percentile": 0.57916}, "CVE-2017-10728": {"epss_score": 0.00364, "epss_percentile": 0.57916}, "CVE-2017-10729": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2017-10730": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2017-10731": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2017-10732": {"epss_score": 0.00288, "epss_percentile": 0.51934}, "CVE-2017-10733": {"epss_score": 0.00288, "epss_percentile": 0.51934}, "CVE-2017-10734": {"epss_score": 0.00288, "epss_percentile": 0.51934}, "CVE-2017-10735": {"epss_score": 0.00288, "epss_percentile": 0.51934}, "CVE-2017-10736": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10737": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10738": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10739": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10740": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10741": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10742": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10743": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10744": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10745": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10746": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10747": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10748": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10749": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10750": {"epss_score": 0.00052, "epss_percentile": 0.16401}, "CVE-2017-10751": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10752": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10753": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10754": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10755": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10756": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10757": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10758": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10759": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10760": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10761": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10762": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10763": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10764": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10765": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10766": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10767": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10768": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10769": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10770": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10771": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10772": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10773": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10774": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10775": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10776": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10777": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10778": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10779": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10780": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10781": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10782": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10783": {"epss_score": 0.00046, "epss_percentile": 0.14409}, "CVE-2017-10784": {"epss_score": 0.01385, "epss_percentile": 0.79908}, "CVE-2017-10788": {"epss_score": 0.00885, "epss_percentile": 0.74933}, "CVE-2017-10789": {"epss_score": 0.00256, "epss_percentile": 0.48827}, "CVE-2017-10790": {"epss_score": 0.00394, "epss_percentile": 0.59794}, "CVE-2017-10791": {"epss_score": 0.00339, "epss_percentile": 0.56183}, "CVE-2017-10792": {"epss_score": 0.00472, "epss_percentile": 0.64039}, "CVE-2017-10793": {"epss_score": 0.01386, "epss_percentile": 0.7991}, "CVE-2017-10794": {"epss_score": 0.00352, "epss_percentile": 0.5708}, "CVE-2017-10795": {"epss_score": 0.00216, "epss_percentile": 0.44222}, "CVE-2017-10796": {"epss_score": 0.00078, "epss_percentile": 0.23784}, "CVE-2017-10798": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-10799": {"epss_score": 0.00356, "epss_percentile": 0.57345}, "CVE-2017-10800": {"epss_score": 0.00323, "epss_percentile": 0.54923}, "CVE-2017-10801": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-10803": {"epss_score": 0.01551, "epss_percentile": 0.80989}, "CVE-2017-10804": {"epss_score": 0.00882, "epss_percentile": 0.749}, "CVE-2017-10805": {"epss_score": 0.00325, "epss_percentile": 0.55005}, "CVE-2017-10806": {"epss_score": 0.00094, "epss_percentile": 0.27008}, "CVE-2017-10807": {"epss_score": 0.01574, "epss_percentile": 0.81104}, "CVE-2017-10810": {"epss_score": 0.00833, "epss_percentile": 0.74083}, "CVE-2017-10811": {"epss_score": 0.00178, "epss_percentile": 0.39685}, "CVE-2017-10812": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-10813": {"epss_score": 0.00273, "epss_percentile": 0.50435}, "CVE-2017-10814": {"epss_score": 0.00258, "epss_percentile": 0.48977}, "CVE-2017-10815": {"epss_score": 0.0114, "epss_percentile": 0.77954}, "CVE-2017-10816": {"epss_score": 0.0067, "epss_percentile": 0.70773}, "CVE-2017-10817": {"epss_score": 0.01029, "epss_percentile": 0.76829}, "CVE-2017-10818": {"epss_score": 0.00443, "epss_percentile": 0.62791}, "CVE-2017-10819": {"epss_score": 0.00134, "epss_percentile": 0.33771}, "CVE-2017-10820": {"epss_score": 0.00151, "epss_percentile": 0.36264}, "CVE-2017-10821": {"epss_score": 0.00324, "epss_percentile": 0.54946}, "CVE-2017-10822": {"epss_score": 0.00322, "epss_percentile": 0.54791}, "CVE-2017-10823": {"epss_score": 0.00324, "epss_percentile": 0.54946}, "CVE-2017-10824": {"epss_score": 0.00171, "epss_percentile": 0.38824}, "CVE-2017-10825": {"epss_score": 0.00222, "epss_percentile": 0.44798}, "CVE-2017-10826": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10827": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10828": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10829": {"epss_score": 0.00146, "epss_percentile": 0.35635}, "CVE-2017-10830": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10831": {"epss_score": 0.00181, "epss_percentile": 0.40014}, "CVE-2017-10832": {"epss_score": 0.0325, "epss_percentile": 0.86748}, "CVE-2017-10833": {"epss_score": 0.00195, "epss_percentile": 0.41687}, "CVE-2017-10834": {"epss_score": 0.05713, "epss_percentile": 0.90143}, "CVE-2017-10835": {"epss_score": 0.00569, "epss_percentile": 0.67918}, "CVE-2017-10836": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10837": {"epss_score": 0.00193, "epss_percentile": 0.41438}, "CVE-2017-10838": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2017-10839": {"epss_score": 0.00233, "epss_percentile": 0.46047}, "CVE-2017-10840": {"epss_score": 0.00218, "epss_percentile": 0.44362}, "CVE-2017-10841": {"epss_score": 0.02181, "epss_percentile": 0.83905}, "CVE-2017-10842": {"epss_score": 0.0067, "epss_percentile": 0.70773}, "CVE-2017-10843": {"epss_score": 0.0057, "epss_percentile": 0.67958}, "CVE-2017-10844": {"epss_score": 0.00568, "epss_percentile": 0.67877}, "CVE-2017-10845": {"epss_score": 0.02639, "epss_percentile": 0.853}, "CVE-2017-10846": {"epss_score": 0.00213, "epss_percentile": 0.43845}, "CVE-2017-10848": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10849": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10850": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10851": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10852": {"epss_score": 0.00132, "epss_percentile": 0.33541}, "CVE-2017-10853": {"epss_score": 0.00211, "epss_percentile": 0.43668}, "CVE-2017-10854": {"epss_score": 0.00163, "epss_percentile": 0.37758}, "CVE-2017-10855": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10856": {"epss_score": 0.00741, "epss_percentile": 0.72435}, "CVE-2017-10857": {"epss_score": 0.00139, "epss_percentile": 0.34592}, "CVE-2017-10858": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10859": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10860": {"epss_score": 0.00231, "epss_percentile": 0.45801}, "CVE-2017-10861": {"epss_score": 0.06541, "epss_percentile": 0.90835}, "CVE-2017-10862": {"epss_score": 0.0023, "epss_percentile": 0.45711}, "CVE-2017-10863": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10864": {"epss_score": 0.00113, "epss_percentile": 0.30725}, "CVE-2017-10865": {"epss_score": 0.00113, "epss_percentile": 0.30725}, "CVE-2017-10868": {"epss_score": 0.01218, "epss_percentile": 0.78608}, "CVE-2017-10869": {"epss_score": 0.01867, "epss_percentile": 0.82618}, "CVE-2017-10870": {"epss_score": 0.00341, "epss_percentile": 0.56347}, "CVE-2017-10871": {"epss_score": 0.00635, "epss_percentile": 0.69813}, "CVE-2017-10872": {"epss_score": 0.00676, "epss_percentile": 0.70922}, "CVE-2017-10873": {"epss_score": 0.00966, "epss_percentile": 0.76055}, "CVE-2017-10874": {"epss_score": 0.00621, "epss_percentile": 0.6948}, "CVE-2017-10875": {"epss_score": 0.00377, "epss_percentile": 0.58762}, "CVE-2017-10885": {"epss_score": 0.00114, "epss_percentile": 0.30834}, "CVE-2017-10886": {"epss_score": 0.00253, "epss_percentile": 0.48442}, "CVE-2017-10887": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-10888": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-10889": {"epss_score": 0.00296, "epss_percentile": 0.52606}, "CVE-2017-10890": {"epss_score": 0.00092, "epss_percentile": 0.26472}, "CVE-2017-10891": {"epss_score": 0.00114, "epss_percentile": 0.30834}, "CVE-2017-10892": {"epss_score": 0.00114, "epss_percentile": 0.30834}, "CVE-2017-10893": {"epss_score": 0.00114, "epss_percentile": 0.30834}, "CVE-2017-10894": {"epss_score": 0.00542, "epss_percentile": 0.67062}, "CVE-2017-10895": {"epss_score": 0.00542, "epss_percentile": 0.67062}, "CVE-2017-10896": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2017-10897": {"epss_score": 0.0012, "epss_percentile": 0.31695}, "CVE-2017-10898": {"epss_score": 0.00221, "epss_percentile": 0.44685}, "CVE-2017-10899": {"epss_score": 0.00221, "epss_percentile": 0.44685}, "CVE-2017-10900": {"epss_score": 0.00358, "epss_percentile": 0.57492}, "CVE-2017-10901": {"epss_score": 0.00701, "epss_percentile": 0.715}, "CVE-2017-10902": {"epss_score": 0.02108, "epss_percentile": 0.83639}, "CVE-2017-10903": {"epss_score": 0.03667, "epss_percentile": 0.87535}, "CVE-2017-10904": {"epss_score": 0.0097, "epss_percentile": 0.76109}, "CVE-2017-10905": {"epss_score": 0.00131, "epss_percentile": 0.33404}, "CVE-2017-10906": {"epss_score": 0.01357, "epss_percentile": 0.7972}, "CVE-2017-10907": {"epss_score": 0.03104, "epss_percentile": 0.86415}, "CVE-2017-10908": {"epss_score": 0.01336, "epss_percentile": 0.79553}, "CVE-2017-10909": {"epss_score": 0.00114, "epss_percentile": 0.30834}, "CVE-2017-10910": {"epss_score": 0.0079, "epss_percentile": 0.73367}, "CVE-2017-10911": {"epss_score": 0.00082, "epss_percentile": 0.24426}, "CVE-2017-10912": {"epss_score": 0.01672, "epss_percentile": 0.81682}, "CVE-2017-10913": {"epss_score": 0.01199, "epss_percentile": 0.78461}, "CVE-2017-10914": {"epss_score": 0.00603, "epss_percentile": 0.68938}, "CVE-2017-10915": {"epss_score": 0.00492, "epss_percentile": 0.64992}, "CVE-2017-10916": {"epss_score": 0.00393, "epss_percentile": 0.59711}, "CVE-2017-10917": {"epss_score": 0.00839, "epss_percentile": 0.74196}, "CVE-2017-10918": {"epss_score": 0.01672, "epss_percentile": 0.81682}, "CVE-2017-10919": {"epss_score": 0.00676, "epss_percentile": 0.70944}, "CVE-2017-10920": {"epss_score": 0.01132, "epss_percentile": 0.77869}, "CVE-2017-10921": {"epss_score": 0.01132, "epss_percentile": 0.77869}, "CVE-2017-10922": {"epss_score": 0.00616, "epss_percentile": 0.69318}, "CVE-2017-10923": {"epss_score": 0.00779, "epss_percentile": 0.73144}, "CVE-2017-10924": {"epss_score": 0.0036, "epss_percentile": 0.57688}, "CVE-2017-10925": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-10926": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-10928": {"epss_score": 0.01045, "epss_percentile": 0.77018}, "CVE-2017-10929": {"epss_score": 0.00369, "epss_percentile": 0.58243}, "CVE-2017-10930": {"epss_score": 0.00327, "epss_percentile": 0.55127}, "CVE-2017-10931": {"epss_score": 0.00398, "epss_percentile": 0.60056}, "CVE-2017-10932": {"epss_score": 0.13762, "epss_percentile": 0.94052}, "CVE-2017-10933": {"epss_score": 0.00407, "epss_percentile": 0.60576}, "CVE-2017-10934": {"epss_score": 0.07437, "epss_percentile": 0.91472}, "CVE-2017-10935": {"epss_score": 0.00452, "epss_percentile": 0.63171}, "CVE-2017-10936": {"epss_score": 0.00306, "epss_percentile": 0.53413}, "CVE-2017-10937": {"epss_score": 0.00306, "epss_percentile": 0.53413}, "CVE-2017-10940": {"epss_score": 0.13979, "epss_percentile": 0.94105}, "CVE-2017-10941": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-10942": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2017-10943": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2017-10944": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2017-10945": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-10946": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-10947": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-10948": {"epss_score": 0.01632, "epss_percentile": 0.81459}, "CVE-2017-10949": {"epss_score": 0.18011, "epss_percentile": 0.94944}, "CVE-2017-10950": {"epss_score": 0.00056, "epss_percentile": 0.17827}, "CVE-2017-10951": {"epss_score": 0.17855, "epss_percentile": 0.94917}, "CVE-2017-10952": {"epss_score": 0.07257, "epss_percentile": 0.91354}, "CVE-2017-10953": {"epss_score": 0.1651, "epss_percentile": 0.94682}, "CVE-2017-10954": {"epss_score": 0.06336, "epss_percentile": 0.90678}, "CVE-2017-10955": {"epss_score": 0.33492, "epss_percentile": 0.96779}, "CVE-2017-10956": {"epss_score": 0.0019, "epss_percentile": 0.41125}, "CVE-2017-10957": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-10958": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-10959": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-10961": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2017-10962": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-10963": {"epss_score": 0.00257, "epss_percentile": 0.48864}, "CVE-2017-10965": {"epss_score": 0.01452, "epss_percentile": 0.80371}, "CVE-2017-10966": {"epss_score": 0.00834, "epss_percentile": 0.74111}, "CVE-2017-10967": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2017-10968": {"epss_score": 0.01203, "epss_percentile": 0.78493}, "CVE-2017-10970": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-10971": {"epss_score": 0.02013, "epss_percentile": 0.83255}, "CVE-2017-10972": {"epss_score": 0.0056, "epss_percentile": 0.67628}, "CVE-2017-10973": {"epss_score": 0.00209, "epss_percentile": 0.43412}, "CVE-2017-10974": {"epss_score": 0.91231, "epss_percentile": 0.99629}, "CVE-2017-10975": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2017-10976": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-10978": {"epss_score": 0.03305, "epss_percentile": 0.86875}, "CVE-2017-10979": {"epss_score": 0.25821, "epss_percentile": 0.96076}, "CVE-2017-10980": {"epss_score": 0.01594, "epss_percentile": 0.8123}, "CVE-2017-10981": {"epss_score": 0.01594, "epss_percentile": 0.8123}, "CVE-2017-10982": {"epss_score": 0.0142, "epss_percentile": 0.80165}, "CVE-2017-10983": {"epss_score": 0.02761, "epss_percentile": 0.85602}, "CVE-2017-10984": {"epss_score": 0.11348, "epss_percentile": 0.93318}, "CVE-2017-10985": {"epss_score": 0.01017, "epss_percentile": 0.76697}, "CVE-2017-10986": {"epss_score": 0.01209, "epss_percentile": 0.78539}, "CVE-2017-10987": {"epss_score": 0.01036, "epss_percentile": 0.76915}, "CVE-2017-10989": {"epss_score": 0.09587, "epss_percentile": 0.9261}, "CVE-2017-10991": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-10992": {"epss_score": 0.02863, "epss_percentile": 0.85857}, "CVE-2017-10993": {"epss_score": 0.00825, "epss_percentile": 0.73955}, "CVE-2017-10994": {"epss_score": 0.01029, "epss_percentile": 0.76835}, "CVE-2017-10995": {"epss_score": 0.00425, "epss_percentile": 0.61701}, "CVE-2017-10996": {"epss_score": 0.00092, "epss_percentile": 0.26436}, "CVE-2017-10997": {"epss_score": 0.00083, "epss_percentile": 0.247}, "CVE-2017-10998": {"epss_score": 0.00138, "epss_percentile": 0.34442}, "CVE-2017-10999": {"epss_score": 0.00083, "epss_percentile": 0.247}, "CVE-2017-11000": {"epss_score": 0.00083, "epss_percentile": 0.247}, "CVE-2017-11001": {"epss_score": 0.00096, "epss_percentile": 0.27334}, "CVE-2017-11002": {"epss_score": 0.00096, "epss_percentile": 0.27334}, "CVE-2017-11003": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-11004": {"epss_score": 0.00051, "epss_percentile": 0.16187}, "CVE-2017-11005": {"epss_score": 0.00124, "epss_percentile": 0.3245}, "CVE-2017-11006": {"epss_score": 0.00124, "epss_percentile": 0.3245}, "CVE-2017-11007": {"epss_score": 0.00017, "epss_percentile": 0.0312}, "CVE-2017-11010": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2017-11011": {"epss_score": 0.00242, "epss_percentile": 0.47371}, "CVE-2017-11012": {"epss_score": 0.0001, "epss_percentile": 0.00856}, "CVE-2017-11013": {"epss_score": 0.00273, "epss_percentile": 0.50464}, "CVE-2017-11014": {"epss_score": 0.00176, "epss_percentile": 0.39482}, "CVE-2017-11015": {"epss_score": 0.00109, "epss_percentile": 0.2995}, "CVE-2017-11016": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-11017": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2017-11018": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-11019": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-11022": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-11023": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-11024": {"epss_score": 0.00019, "epss_percentile": 0.04292}, "CVE-2017-11025": {"epss_score": 0.00013, "epss_percentile": 0.01515}, "CVE-2017-11026": {"epss_score": 0.00021, "epss_percentile": 0.04912}, "CVE-2017-11027": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-11028": {"epss_score": 0.00145, "epss_percentile": 0.35396}, "CVE-2017-11029": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-11030": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-11031": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2017-11032": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-11033": {"epss_score": 0.00019, "epss_percentile": 0.04292}, "CVE-2017-11035": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-11038": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-11040": {"epss_score": 0.00096, "epss_percentile": 0.27334}, "CVE-2017-11041": {"epss_score": 0.00145, "epss_percentile": 0.35447}, "CVE-2017-11042": {"epss_score": 0.00015, "epss_percentile": 0.02508}, "CVE-2017-11043": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2017-11044": {"epss_score": 0.00015, "epss_percentile": 0.02299}, "CVE-2017-11045": {"epss_score": 0.00015, "epss_percentile": 0.02299}, "CVE-2017-11046": {"epss_score": 0.00019, "epss_percentile": 0.04153}, "CVE-2017-11047": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-11048": {"epss_score": 0.00022, "epss_percentile": 0.0516}, "CVE-2017-11049": {"epss_score": 0.00014, "epss_percentile": 0.01754}, "CVE-2017-11050": {"epss_score": 0.0002, "epss_percentile": 0.04523}, "CVE-2017-11051": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-11052": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-11053": {"epss_score": 0.00057, "epss_percentile": 0.18221}, "CVE-2017-11054": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-11055": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-11056": {"epss_score": 0.00019, "epss_percentile": 0.04153}, "CVE-2017-11057": {"epss_score": 0.00019, "epss_percentile": 0.04153}, "CVE-2017-11058": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-11059": {"epss_score": 0.0002, "epss_percentile": 0.04523}, "CVE-2017-11060": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-11061": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-11062": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-11063": {"epss_score": 0.00113, "epss_percentile": 0.30689}, "CVE-2017-11064": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-11066": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-11067": {"epss_score": 0.00019, "epss_percentile": 0.04153}, "CVE-2017-11069": {"epss_score": 0.0007, "epss_percentile": 0.21767}, "CVE-2017-11072": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-11073": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-11074": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-11075": {"epss_score": 0.00019, "epss_percentile": 0.04292}, "CVE-2017-11076": {"epss_score": 0.00207, "epss_percentile": 0.43184}, "CVE-2017-11078": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2017-11079": {"epss_score": 0.00164, "epss_percentile": 0.37936}, "CVE-2017-11080": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-11081": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-11082": {"epss_score": 0.00014, "epss_percentile": 0.01754}, "CVE-2017-11085": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-11087": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-11088": {"epss_score": 0.00246, "epss_percentile": 0.47755}, "CVE-2017-11089": {"epss_score": 0.00643, "epss_percentile": 0.70052}, "CVE-2017-11090": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-11091": {"epss_score": 0.00019, "epss_percentile": 0.04292}, "CVE-2017-11092": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-11093": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-11096": {"epss_score": 0.00349, "epss_percentile": 0.56883}, "CVE-2017-11097": {"epss_score": 0.00349, "epss_percentile": 0.56883}, "CVE-2017-11098": {"epss_score": 0.00407, "epss_percentile": 0.60587}, "CVE-2017-11099": {"epss_score": 0.00407, "epss_percentile": 0.60587}, "CVE-2017-11100": {"epss_score": 0.00349, "epss_percentile": 0.56883}, "CVE-2017-11101": {"epss_score": 0.00349, "epss_percentile": 0.56883}, "CVE-2017-11102": {"epss_score": 0.0201, "epss_percentile": 0.83247}, "CVE-2017-11103": {"epss_score": 0.05766, "epss_percentile": 0.90188}, "CVE-2017-11104": {"epss_score": 0.01978, "epss_percentile": 0.8313}, "CVE-2017-11105": {"epss_score": 0.00559, "epss_percentile": 0.67609}, "CVE-2017-11107": {"epss_score": 0.00193, "epss_percentile": 0.4139}, "CVE-2017-11108": {"epss_score": 0.01938, "epss_percentile": 0.82968}, "CVE-2017-11109": {"epss_score": 0.00264, "epss_percentile": 0.49725}, "CVE-2017-11110": {"epss_score": 0.002, "epss_percentile": 0.42219}, "CVE-2017-11111": {"epss_score": 0.00237, "epss_percentile": 0.46655}, "CVE-2017-11112": {"epss_score": 0.00272, "epss_percentile": 0.5036}, "CVE-2017-11113": {"epss_score": 0.0028, "epss_percentile": 0.51038}, "CVE-2017-11114": {"epss_score": 0.00402, "epss_percentile": 0.60314}, "CVE-2017-11115": {"epss_score": 0.00268, "epss_percentile": 0.50039}, "CVE-2017-11116": {"epss_score": 0.0028, "epss_percentile": 0.51072}, "CVE-2017-11117": {"epss_score": 0.00245, "epss_percentile": 0.47695}, "CVE-2017-11118": {"epss_score": 0.00258, "epss_percentile": 0.48971}, "CVE-2017-11119": {"epss_score": 0.00245, "epss_percentile": 0.47695}, "CVE-2017-11120": {"epss_score": 0.24373, "epss_percentile": 0.95915}, "CVE-2017-11121": {"epss_score": 0.02083, "epss_percentile": 0.83542}, "CVE-2017-11122": {"epss_score": 0.01, "epss_percentile": 0.7649}, "CVE-2017-11124": {"epss_score": 0.00361, "epss_percentile": 0.57746}, "CVE-2017-11125": {"epss_score": 0.00361, "epss_percentile": 0.57746}, "CVE-2017-11126": {"epss_score": 0.00432, "epss_percentile": 0.62107}, "CVE-2017-11127": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-11128": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-11129": {"epss_score": 0.00345, "epss_percentile": 0.56559}, "CVE-2017-11130": {"epss_score": 0.00156, "epss_percentile": 0.37004}, "CVE-2017-11131": {"epss_score": 0.00136, "epss_percentile": 0.34097}, "CVE-2017-11132": {"epss_score": 0.00107, "epss_percentile": 0.29578}, "CVE-2017-11133": {"epss_score": 0.0014, "epss_percentile": 0.34739}, "CVE-2017-11134": {"epss_score": 0.00259, "epss_percentile": 0.49064}, "CVE-2017-11135": {"epss_score": 0.00296, "epss_percentile": 0.52585}, "CVE-2017-11136": {"epss_score": 0.00143, "epss_percentile": 0.35196}, "CVE-2017-11139": {"epss_score": 0.00472, "epss_percentile": 0.64032}, "CVE-2017-11140": {"epss_score": 0.00533, "epss_percentile": 0.66772}, "CVE-2017-11141": {"epss_score": 0.00503, "epss_percentile": 0.65454}, "CVE-2017-11142": {"epss_score": 0.50029, "epss_percentile": 0.97715}, "CVE-2017-11143": {"epss_score": 0.11856, "epss_percentile": 0.93497}, "CVE-2017-11144": {"epss_score": 0.41629, "epss_percentile": 0.97286}, "CVE-2017-11145": {"epss_score": 0.08268, "epss_percentile": 0.9196}, "CVE-2017-11147": {"epss_score": 0.02855, "epss_percentile": 0.85838}, "CVE-2017-11148": {"epss_score": 0.00168, "epss_percentile": 0.3843}, "CVE-2017-11149": {"epss_score": 0.00177, "epss_percentile": 0.39504}, "CVE-2017-11150": {"epss_score": 0.02501, "epss_percentile": 0.84923}, "CVE-2017-11151": {"epss_score": 0.14779, "epss_percentile": 0.94282}, "CVE-2017-11152": {"epss_score": 0.14053, "epss_percentile": 0.94122}, "CVE-2017-11153": {"epss_score": 0.15084, "epss_percentile": 0.94359}, "CVE-2017-11154": {"epss_score": 0.06862, "epss_percentile": 0.91081}, "CVE-2017-11155": {"epss_score": 0.35175, "epss_percentile": 0.96892}, "CVE-2017-11156": {"epss_score": 0.00862, "epss_percentile": 0.74576}, "CVE-2017-11157": {"epss_score": 0.00067, "epss_percentile": 0.21012}, "CVE-2017-11158": {"epss_score": 0.00067, "epss_percentile": 0.21012}, "CVE-2017-11159": {"epss_score": 0.00158, "epss_percentile": 0.37245}, "CVE-2017-11160": {"epss_score": 0.00067, "epss_percentile": 0.21116}, "CVE-2017-11161": {"epss_score": 0.00585, "epss_percentile": 0.68428}, "CVE-2017-11162": {"epss_score": 0.00375, "epss_percentile": 0.58616}, "CVE-2017-11163": {"epss_score": 0.00223, "epss_percentile": 0.44846}, "CVE-2017-11164": {"epss_score": 0.00274, "epss_percentile": 0.5058}, "CVE-2017-11165": {"epss_score": 0.91455, "epss_percentile": 0.99645}, "CVE-2017-11166": {"epss_score": 0.00139, "epss_percentile": 0.34551}, "CVE-2017-11167": {"epss_score": 0.00795, "epss_percentile": 0.73472}, "CVE-2017-11169": {"epss_score": 0.00751, "epss_percentile": 0.72649}, "CVE-2017-11170": {"epss_score": 0.00348, "epss_percentile": 0.56809}, "CVE-2017-11171": {"epss_score": 0.00156, "epss_percentile": 0.36969}, "CVE-2017-11173": {"epss_score": 0.0175, "epss_percentile": 0.82096}, "CVE-2017-11174": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-11175": {"epss_score": 0.00215, "epss_percentile": 0.4411}, "CVE-2017-11176": {"epss_score": 0.16262, "epss_percentile": 0.94605}, "CVE-2017-11177": {"epss_score": 0.00251, "epss_percentile": 0.48292}, "CVE-2017-11178": {"epss_score": 0.00117, "epss_percentile": 0.3123}, "CVE-2017-11179": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-11180": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-11181": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2017-11182": {"epss_score": 0.00563, "epss_percentile": 0.67727}, "CVE-2017-11183": {"epss_score": 0.00414, "epss_percentile": 0.61041}, "CVE-2017-11184": {"epss_score": 0.00266, "epss_percentile": 0.49902}, "CVE-2017-11185": {"epss_score": 0.00707, "epss_percentile": 0.71652}, "CVE-2017-11187": {"epss_score": 0.00268, "epss_percentile": 0.50064}, "CVE-2017-11188": {"epss_score": 0.00368, "epss_percentile": 0.58193}, "CVE-2017-11189": {"epss_score": 0.00389, "epss_percentile": 0.59477}, "CVE-2017-11190": {"epss_score": 0.00301, "epss_percentile": 0.52997}, "CVE-2017-11191": {"epss_score": 0.00072, "epss_percentile": 0.22453}, "CVE-2017-11193": {"epss_score": 0.00151, "epss_percentile": 0.36313}, "CVE-2017-11194": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-11195": {"epss_score": 0.00388, "epss_percentile": 0.59378}, "CVE-2017-11196": {"epss_score": 0.00151, "epss_percentile": 0.36313}, "CVE-2017-11197": {"epss_score": 0.00119, "epss_percentile": 0.31679}, "CVE-2017-11198": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2017-11200": {"epss_score": 0.00232, "epss_percentile": 0.45894}, "CVE-2017-11201": {"epss_score": 0.00157, "epss_percentile": 0.37034}, "CVE-2017-11202": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-11209": {"epss_score": 0.11531, "epss_percentile": 0.93397}, "CVE-2017-11210": {"epss_score": 0.11531, "epss_percentile": 0.93397}, "CVE-2017-11211": {"epss_score": 0.30095, "epss_percentile": 0.96507}, "CVE-2017-11212": {"epss_score": 0.07216, "epss_percentile": 0.91331}, "CVE-2017-11213": {"epss_score": 0.11384, "epss_percentile": 0.93328}, "CVE-2017-11214": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11215": {"epss_score": 0.05822, "epss_percentile": 0.90235}, "CVE-2017-11216": {"epss_score": 0.06929, "epss_percentile": 0.91122}, "CVE-2017-11217": {"epss_score": 0.11531, "epss_percentile": 0.93397}, "CVE-2017-11218": {"epss_score": 0.05069, "epss_percentile": 0.89462}, "CVE-2017-11219": {"epss_score": 0.05069, "epss_percentile": 0.89462}, "CVE-2017-11220": {"epss_score": 0.13201, "epss_percentile": 0.939}, "CVE-2017-11221": {"epss_score": 0.13237, "epss_percentile": 0.93908}, "CVE-2017-11222": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11223": {"epss_score": 0.05069, "epss_percentile": 0.89462}, "CVE-2017-11224": {"epss_score": 0.05069, "epss_percentile": 0.89462}, "CVE-2017-11225": {"epss_score": 0.05822, "epss_percentile": 0.90235}, "CVE-2017-11226": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11227": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11228": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11229": {"epss_score": 0.05846, "epss_percentile": 0.90257}, "CVE-2017-11230": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11231": {"epss_score": 0.0504, "epss_percentile": 0.89426}, "CVE-2017-11232": {"epss_score": 0.12407, "epss_percentile": 0.93661}, "CVE-2017-11233": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11234": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11235": {"epss_score": 0.0504, "epss_percentile": 0.89426}, "CVE-2017-11236": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11237": {"epss_score": 0.08397, "epss_percentile": 0.9203}, "CVE-2017-11238": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11239": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11240": {"epss_score": 0.16452, "epss_percentile": 0.94664}, "CVE-2017-11241": {"epss_score": 0.13201, "epss_percentile": 0.939}, "CVE-2017-11242": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11243": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11244": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11245": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11246": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11248": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11249": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11250": {"epss_score": 0.16452, "epss_percentile": 0.94664}, "CVE-2017-11251": {"epss_score": 0.08397, "epss_percentile": 0.9203}, "CVE-2017-11252": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11253": {"epss_score": 0.16452, "epss_percentile": 0.94664}, "CVE-2017-11254": {"epss_score": 0.14013, "epss_percentile": 0.94114}, "CVE-2017-11255": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11256": {"epss_score": 0.0504, "epss_percentile": 0.89426}, "CVE-2017-11257": {"epss_score": 0.13237, "epss_percentile": 0.93908}, "CVE-2017-11258": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11259": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11260": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11261": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11262": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11263": {"epss_score": 0.03068, "epss_percentile": 0.86341}, "CVE-2017-11265": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-11267": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11268": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11269": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11270": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11271": {"epss_score": 0.07932, "epss_percentile": 0.91772}, "CVE-2017-11272": {"epss_score": 0.0066, "epss_percentile": 0.70539}, "CVE-2017-11273": {"epss_score": 0.06524, "epss_percentile": 0.9082}, "CVE-2017-11274": {"epss_score": 0.02443, "epss_percentile": 0.84759}, "CVE-2017-11275": {"epss_score": 0.12809, "epss_percentile": 0.93781}, "CVE-2017-11276": {"epss_score": 0.05345, "epss_percentile": 0.89769}, "CVE-2017-11277": {"epss_score": 0.05345, "epss_percentile": 0.89769}, "CVE-2017-11278": {"epss_score": 0.05345, "epss_percentile": 0.89769}, "CVE-2017-11279": {"epss_score": 0.03876, "epss_percentile": 0.87886}, "CVE-2017-11280": {"epss_score": 0.05345, "epss_percentile": 0.89769}, "CVE-2017-11281": {"epss_score": 0.45372, "epss_percentile": 0.97484}, "CVE-2017-11282": {"epss_score": 0.20687, "epss_percentile": 0.95402}, "CVE-2017-11283": {"epss_score": 0.23859, "epss_percentile": 0.95825}, "CVE-2017-11284": {"epss_score": 0.23859, "epss_percentile": 0.95825}, "CVE-2017-11285": {"epss_score": 0.01032, "epss_percentile": 0.76863}, "CVE-2017-11286": {"epss_score": 0.01292, "epss_percentile": 0.79231}, "CVE-2017-11287": {"epss_score": 0.01208, "epss_percentile": 0.78536}, "CVE-2017-11288": {"epss_score": 0.01208, "epss_percentile": 0.78536}, "CVE-2017-11289": {"epss_score": 0.01208, "epss_percentile": 0.78536}, "CVE-2017-11290": {"epss_score": 0.00448, "epss_percentile": 0.63015}, "CVE-2017-11291": {"epss_score": 0.0208, "epss_percentile": 0.83529}, "CVE-2017-11292": {"epss_score": 0.21236, "epss_percentile": 0.95482}, "CVE-2017-11293": {"epss_score": 0.10805, "epss_percentile": 0.93109}, "CVE-2017-11294": {"epss_score": 0.03477, "epss_percentile": 0.87212}, "CVE-2017-11295": {"epss_score": 0.04757, "epss_percentile": 0.89115}, "CVE-2017-11296": {"epss_score": 0.01471, "epss_percentile": 0.80506}, "CVE-2017-11297": {"epss_score": 0.00878, "epss_percentile": 0.74828}, "CVE-2017-11298": {"epss_score": 0.00878, "epss_percentile": 0.74828}, "CVE-2017-11299": {"epss_score": 0.00878, "epss_percentile": 0.74828}, "CVE-2017-11300": {"epss_score": 0.00878, "epss_percentile": 0.74828}, "CVE-2017-11301": {"epss_score": 0.00878, "epss_percentile": 0.74828}, "CVE-2017-11302": {"epss_score": 0.02868, "epss_percentile": 0.85867}, "CVE-2017-11303": {"epss_score": 0.03902, "epss_percentile": 0.87923}, "CVE-2017-11304": {"epss_score": 0.03267, "epss_percentile": 0.86785}, "CVE-2017-11305": {"epss_score": 0.0247, "epss_percentile": 0.84845}, "CVE-2017-11306": {"epss_score": 0.16452, "epss_percentile": 0.94664}, "CVE-2017-11307": {"epss_score": 0.16452, "epss_percentile": 0.94664}, "CVE-2017-11308": {"epss_score": 0.21564, "epss_percentile": 0.95535}, "CVE-2017-11309": {"epss_score": 0.28588, "epss_percentile": 0.96369}, "CVE-2017-11310": {"epss_score": 0.0039, "epss_percentile": 0.5954}, "CVE-2017-11311": {"epss_score": 0.01224, "epss_percentile": 0.78672}, "CVE-2017-11317": {"epss_score": 0.92121, "epss_percentile": 0.99692}, "CVE-2017-11318": {"epss_score": 0.00592, "epss_percentile": 0.68622}, "CVE-2017-11319": {"epss_score": 0.02372, "epss_percentile": 0.8453}, "CVE-2017-11320": {"epss_score": 0.00401, "epss_percentile": 0.60249}, "CVE-2017-11321": {"epss_score": 0.10482, "epss_percentile": 0.93002}, "CVE-2017-11322": {"epss_score": 0.01333, "epss_percentile": 0.79527}, "CVE-2017-11323": {"epss_score": 0.10434, "epss_percentile": 0.92986}, "CVE-2017-11324": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-11325": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2017-11326": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2017-11327": {"epss_score": 0.00259, "epss_percentile": 0.49064}, "CVE-2017-11328": {"epss_score": 0.00191, "epss_percentile": 0.41254}, "CVE-2017-11329": {"epss_score": 0.00335, "epss_percentile": 0.55847}, "CVE-2017-11330": {"epss_score": 0.03454, "epss_percentile": 0.87169}, "CVE-2017-11331": {"epss_score": 0.01903, "epss_percentile": 0.82785}, "CVE-2017-11332": {"epss_score": 0.03395, "epss_percentile": 0.87058}, "CVE-2017-11333": {"epss_score": 0.02385, "epss_percentile": 0.84578}, "CVE-2017-11334": {"epss_score": 0.0004, "epss_percentile": 0.12074}, "CVE-2017-11335": {"epss_score": 0.0124, "epss_percentile": 0.78803}, "CVE-2017-11336": {"epss_score": 0.01065, "epss_percentile": 0.77213}, "CVE-2017-11337": {"epss_score": 0.01065, "epss_percentile": 0.77213}, "CVE-2017-11338": {"epss_score": 0.01065, "epss_percentile": 0.77213}, "CVE-2017-11339": {"epss_score": 0.00664, "epss_percentile": 0.70644}, "CVE-2017-11340": {"epss_score": 0.01065, "epss_percentile": 0.77213}, "CVE-2017-11341": {"epss_score": 0.00442, "epss_percentile": 0.62731}, "CVE-2017-11342": {"epss_score": 0.00442, "epss_percentile": 0.62731}, "CVE-2017-11343": {"epss_score": 0.00351, "epss_percentile": 0.57031}, "CVE-2017-11344": {"epss_score": 0.01188, "epss_percentile": 0.78369}, "CVE-2017-11345": {"epss_score": 0.0135, "epss_percentile": 0.79676}, "CVE-2017-11346": {"epss_score": 0.24987, "epss_percentile": 0.95975}, "CVE-2017-11347": {"epss_score": 0.01489, "epss_percentile": 0.80622}, "CVE-2017-11348": {"epss_score": 0.00626, "epss_percentile": 0.69618}, "CVE-2017-11349": {"epss_score": 0.00612, "epss_percentile": 0.69212}, "CVE-2017-11350": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2017-11351": {"epss_score": 0.00284, "epss_percentile": 0.51448}, "CVE-2017-11352": {"epss_score": 0.00979, "epss_percentile": 0.7626}, "CVE-2017-11353": {"epss_score": 0.00167, "epss_percentile": 0.38275}, "CVE-2017-11354": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-11355": {"epss_score": 0.02826, "epss_percentile": 0.85765}, "CVE-2017-11356": {"epss_score": 0.03027, "epss_percentile": 0.86243}, "CVE-2017-11357": {"epss_score": 0.93843, "epss_percentile": 0.99855}, "CVE-2017-11358": {"epss_score": 0.03286, "epss_percentile": 0.86824}, "CVE-2017-11359": {"epss_score": 0.03877, "epss_percentile": 0.87891}, "CVE-2017-11360": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2017-11361": {"epss_score": 0.00606, "epss_percentile": 0.69026}, "CVE-2017-11362": {"epss_score": 0.01584, "epss_percentile": 0.81155}, "CVE-2017-11364": {"epss_score": 0.0034, "epss_percentile": 0.56216}, "CVE-2017-11365": {"epss_score": 0.00356, "epss_percentile": 0.57355}, "CVE-2017-11366": {"epss_score": 0.41511, "epss_percentile": 0.9728}, "CVE-2017-11367": {"epss_score": 0.00795, "epss_percentile": 0.73471}, "CVE-2017-11368": {"epss_score": 0.00681, "epss_percentile": 0.71049}, "CVE-2017-11379": {"epss_score": 0.00206, "epss_percentile": 0.42941}, "CVE-2017-11380": {"epss_score": 0.00846, "epss_percentile": 0.7432}, "CVE-2017-11381": {"epss_score": 0.18473, "epss_percentile": 0.9502}, "CVE-2017-11382": {"epss_score": 0.01117, "epss_percentile": 0.77735}, "CVE-2017-11383": {"epss_score": 0.0724, "epss_percentile": 0.91345}, "CVE-2017-11384": {"epss_score": 0.0724, "epss_percentile": 0.91345}, "CVE-2017-11385": {"epss_score": 0.0724, "epss_percentile": 0.91345}, "CVE-2017-11386": {"epss_score": 0.0724, "epss_percentile": 0.91345}, "CVE-2017-11387": {"epss_score": 0.02088, "epss_percentile": 0.83554}, "CVE-2017-11388": {"epss_score": 0.07769, "epss_percentile": 0.91672}, "CVE-2017-11389": {"epss_score": 0.07673, "epss_percentile": 0.91618}, "CVE-2017-11390": {"epss_score": 0.00569, "epss_percentile": 0.67929}, "CVE-2017-11391": {"epss_score": 0.81392, "epss_percentile": 0.99136}, "CVE-2017-11392": {"epss_score": 0.73935, "epss_percentile": 0.98777}, "CVE-2017-11393": {"epss_score": 0.08967, "epss_percentile": 0.92342}, "CVE-2017-11394": {"epss_score": 0.80666, "epss_percentile": 0.991}, "CVE-2017-11395": {"epss_score": 0.0845, "epss_percentile": 0.92058}, "CVE-2017-11396": {"epss_score": 0.0088, "epss_percentile": 0.74858}, "CVE-2017-11397": {"epss_score": 0.00511, "epss_percentile": 0.65817}, "CVE-2017-11398": {"epss_score": 0.08976, "epss_percentile": 0.92347}, "CVE-2017-11399": {"epss_score": 0.0009, "epss_percentile": 0.26059}, "CVE-2017-11400": {"epss_score": 0.00011, "epss_percentile": 0.01042}, "CVE-2017-11401": {"epss_score": 0.00081, "epss_percentile": 0.2427}, "CVE-2017-11402": {"epss_score": 0.00089, "epss_percentile": 0.25982}, "CVE-2017-11403": {"epss_score": 0.0112, "epss_percentile": 0.77764}, "CVE-2017-11404": {"epss_score": 0.00182, "epss_percentile": 0.40195}, "CVE-2017-11405": {"epss_score": 0.00182, "epss_percentile": 0.40195}, "CVE-2017-11406": {"epss_score": 0.00806, "epss_percentile": 0.73664}, "CVE-2017-11407": {"epss_score": 0.01186, "epss_percentile": 0.7835}, "CVE-2017-11408": {"epss_score": 0.00603, "epss_percentile": 0.68939}, "CVE-2017-11409": {"epss_score": 0.01193, "epss_percentile": 0.78405}, "CVE-2017-11410": {"epss_score": 0.00259, "epss_percentile": 0.49057}, "CVE-2017-11411": {"epss_score": 0.00478, "epss_percentile": 0.6437}, "CVE-2017-11412": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-11413": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-11414": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-11415": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-11416": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-11417": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-11418": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-11419": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-11420": {"epss_score": 0.10612, "epss_percentile": 0.93048}, "CVE-2017-11421": {"epss_score": 0.00021, "epss_percentile": 0.0483}, "CVE-2017-11422": {"epss_score": 0.00203, "epss_percentile": 0.42574}, "CVE-2017-11423": {"epss_score": 0.03047, "epss_percentile": 0.86284}, "CVE-2017-11424": {"epss_score": 0.01296, "epss_percentile": 0.79254}, "CVE-2017-11427": {"epss_score": 0.03605, "epss_percentile": 0.87415}, "CVE-2017-11428": {"epss_score": 0.00436, "epss_percentile": 0.62486}, "CVE-2017-11429": {"epss_score": 0.00272, "epss_percentile": 0.50361}, "CVE-2017-11430": {"epss_score": 0.00436, "epss_percentile": 0.62486}, "CVE-2017-11434": {"epss_score": 0.00052, "epss_percentile": 0.16471}, "CVE-2017-11435": {"epss_score": 0.19675, "epss_percentile": 0.95224}, "CVE-2017-11436": {"epss_score": 0.01094, "epss_percentile": 0.77498}, "CVE-2017-11437": {"epss_score": 0.0009, "epss_percentile": 0.26046}, "CVE-2017-11438": {"epss_score": 0.00119, "epss_percentile": 0.31679}, "CVE-2017-11439": {"epss_score": 0.00195, "epss_percentile": 0.41621}, "CVE-2017-11440": {"epss_score": 0.00869, "epss_percentile": 0.74683}, "CVE-2017-11441": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2017-11444": {"epss_score": 0.74991, "epss_percentile": 0.98827}, "CVE-2017-11445": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-11446": {"epss_score": 0.00416, "epss_percentile": 0.61166}, "CVE-2017-11447": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-11448": {"epss_score": 0.00658, "epss_percentile": 0.70481}, "CVE-2017-11449": {"epss_score": 0.00442, "epss_percentile": 0.62738}, "CVE-2017-11450": {"epss_score": 0.00466, "epss_percentile": 0.63794}, "CVE-2017-11455": {"epss_score": 0.00563, "epss_percentile": 0.6771}, "CVE-2017-11456": {"epss_score": 0.08214, "epss_percentile": 0.91933}, "CVE-2017-11457": {"epss_score": 0.00587, "epss_percentile": 0.68477}, "CVE-2017-11458": {"epss_score": 0.00297, "epss_percentile": 0.52689}, "CVE-2017-11459": {"epss_score": 0.02124, "epss_percentile": 0.83688}, "CVE-2017-11460": {"epss_score": 0.00233, "epss_percentile": 0.45973}, "CVE-2017-11461": {"epss_score": 0.00245, "epss_percentile": 0.47707}, "CVE-2017-11462": {"epss_score": 0.01706, "epss_percentile": 0.81854}, "CVE-2017-11463": {"epss_score": 0.01156, "epss_percentile": 0.78083}, "CVE-2017-11464": {"epss_score": 0.00267, "epss_percentile": 0.49961}, "CVE-2017-11465": {"epss_score": 0.00338, "epss_percentile": 0.56113}, "CVE-2017-11466": {"epss_score": 0.03263, "epss_percentile": 0.86776}, "CVE-2017-11467": {"epss_score": 0.80603, "epss_percentile": 0.99096}, "CVE-2017-11468": {"epss_score": 0.00442, "epss_percentile": 0.62722}, "CVE-2017-11469": {"epss_score": 0.07214, "epss_percentile": 0.9133}, "CVE-2017-11470": {"epss_score": 0.01452, "epss_percentile": 0.80367}, "CVE-2017-11471": {"epss_score": 0.01452, "epss_percentile": 0.80367}, "CVE-2017-11472": {"epss_score": 0.00066, "epss_percentile": 0.20878}, "CVE-2017-11473": {"epss_score": 0.00092, "epss_percentile": 0.26416}, "CVE-2017-11474": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-11475": {"epss_score": 0.00232, "epss_percentile": 0.45894}, "CVE-2017-11478": {"epss_score": 0.00529, "epss_percentile": 0.66583}, "CVE-2017-11479": {"epss_score": 0.00389, "epss_percentile": 0.59413}, "CVE-2017-11480": {"epss_score": 0.0054, "epss_percentile": 0.66997}, "CVE-2017-11481": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2017-11482": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2017-11494": {"epss_score": 0.02774, "epss_percentile": 0.85632}, "CVE-2017-11495": {"epss_score": 0.02633, "epss_percentile": 0.85288}, "CVE-2017-11496": {"epss_score": 0.08272, "epss_percentile": 0.91961}, "CVE-2017-11497": {"epss_score": 0.08272, "epss_percentile": 0.91961}, "CVE-2017-11498": {"epss_score": 0.02917, "epss_percentile": 0.85983}, "CVE-2017-11499": {"epss_score": 0.00323, "epss_percentile": 0.54881}, "CVE-2017-11500": {"epss_score": 0.00332, "epss_percentile": 0.55599}, "CVE-2017-11501": {"epss_score": 0.00092, "epss_percentile": 0.26523}, "CVE-2017-11502": {"epss_score": 0.07998, "epss_percentile": 0.91815}, "CVE-2017-11503": {"epss_score": 0.00566, "epss_percentile": 0.67831}, "CVE-2017-11505": {"epss_score": 0.00572, "epss_percentile": 0.68007}, "CVE-2017-11506": {"epss_score": 0.00104, "epss_percentile": 0.29223}, "CVE-2017-11507": {"epss_score": 0.00351, "epss_percentile": 0.57004}, "CVE-2017-11508": {"epss_score": 0.00435, "epss_percentile": 0.62357}, "CVE-2017-11509": {"epss_score": 0.08469, "epss_percentile": 0.92068}, "CVE-2017-11510": {"epss_score": 0.00948, "epss_percentile": 0.75832}, "CVE-2017-11511": {"epss_score": 0.04095, "epss_percentile": 0.88248}, "CVE-2017-11512": {"epss_score": 0.8294, "epss_percentile": 0.99221}, "CVE-2017-11516": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-11517": {"epss_score": 0.3702, "epss_percentile": 0.97014}, "CVE-2017-11519": {"epss_score": 0.13243, "epss_percentile": 0.93912}, "CVE-2017-11521": {"epss_score": 0.01633, "epss_percentile": 0.81461}, "CVE-2017-11522": {"epss_score": 0.00358, "epss_percentile": 0.57504}, "CVE-2017-11523": {"epss_score": 0.0066, "epss_percentile": 0.70538}, "CVE-2017-11524": {"epss_score": 0.00712, "epss_percentile": 0.71753}, "CVE-2017-11525": {"epss_score": 0.01245, "epss_percentile": 0.7884}, "CVE-2017-11526": {"epss_score": 0.00958, "epss_percentile": 0.75944}, "CVE-2017-11527": {"epss_score": 0.00717, "epss_percentile": 0.71886}, "CVE-2017-11528": {"epss_score": 0.00545, "epss_percentile": 0.6717}, "CVE-2017-11529": {"epss_score": 0.00545, "epss_percentile": 0.6717}, "CVE-2017-11530": {"epss_score": 0.00722, "epss_percentile": 0.71988}, "CVE-2017-11531": {"epss_score": 0.00408, "epss_percentile": 0.60658}, "CVE-2017-11532": {"epss_score": 0.00343, "epss_percentile": 0.56468}, "CVE-2017-11533": {"epss_score": 0.00429, "epss_percentile": 0.61961}, "CVE-2017-11534": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2017-11535": {"epss_score": 0.00426, "epss_percentile": 0.61752}, "CVE-2017-11536": {"epss_score": 0.00348, "epss_percentile": 0.56813}, "CVE-2017-11537": {"epss_score": 0.00429, "epss_percentile": 0.61961}, "CVE-2017-11538": {"epss_score": 0.00406, "epss_percentile": 0.60515}, "CVE-2017-11539": {"epss_score": 0.0038, "epss_percentile": 0.58913}, "CVE-2017-11540": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2017-11541": {"epss_score": 0.01047, "epss_percentile": 0.77038}, "CVE-2017-11542": {"epss_score": 0.01047, "epss_percentile": 0.77038}, "CVE-2017-11543": {"epss_score": 0.10465, "epss_percentile": 0.92995}, "CVE-2017-11546": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2017-11547": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2017-11548": {"epss_score": 0.02266, "epss_percentile": 0.84197}, "CVE-2017-11549": {"epss_score": 0.00229, "epss_percentile": 0.45636}, "CVE-2017-11550": {"epss_score": 0.005, "epss_percentile": 0.65318}, "CVE-2017-11551": {"epss_score": 0.00631, "epss_percentile": 0.69727}, "CVE-2017-11552": {"epss_score": 0.07099, "epss_percentile": 0.91249}, "CVE-2017-11553": {"epss_score": 0.01065, "epss_percentile": 0.77213}, "CVE-2017-11554": {"epss_score": 0.00559, "epss_percentile": 0.6762}, "CVE-2017-11555": {"epss_score": 0.00401, "epss_percentile": 0.6021}, "CVE-2017-11556": {"epss_score": 0.00401, "epss_percentile": 0.6021}, "CVE-2017-11557": {"epss_score": 0.00873, "epss_percentile": 0.74745}, "CVE-2017-11559": {"epss_score": 0.07858, "epss_percentile": 0.91725}, "CVE-2017-11560": {"epss_score": 0.015, "epss_percentile": 0.80712}, "CVE-2017-11561": {"epss_score": 0.00816, "epss_percentile": 0.73828}, "CVE-2017-11562": {"epss_score": 0.00315, "epss_percentile": 0.54203}, "CVE-2017-11563": {"epss_score": 0.15674, "epss_percentile": 0.94481}, "CVE-2017-11564": {"epss_score": 0.02785, "epss_percentile": 0.85657}, "CVE-2017-11565": {"epss_score": 0.00207, "epss_percentile": 0.43082}, "CVE-2017-11566": {"epss_score": 0.00599, "epss_percentile": 0.68785}, "CVE-2017-11567": {"epss_score": 0.00358, "epss_percentile": 0.5749}, "CVE-2017-11568": {"epss_score": 0.00368, "epss_percentile": 0.58171}, "CVE-2017-11569": {"epss_score": 0.00728, "epss_percentile": 0.72107}, "CVE-2017-11570": {"epss_score": 0.00352, "epss_percentile": 0.57094}, "CVE-2017-11571": {"epss_score": 0.00661, "epss_percentile": 0.70584}, "CVE-2017-11572": {"epss_score": 0.00352, "epss_percentile": 0.57094}, "CVE-2017-11573": {"epss_score": 0.00352, "epss_percentile": 0.57094}, "CVE-2017-11574": {"epss_score": 0.00818, "epss_percentile": 0.73857}, "CVE-2017-11575": {"epss_score": 0.00352, "epss_percentile": 0.57094}, "CVE-2017-11576": {"epss_score": 0.00249, "epss_percentile": 0.48085}, "CVE-2017-11577": {"epss_score": 0.00352, "epss_percentile": 0.57094}, "CVE-2017-11578": {"epss_score": 0.01409, "epss_percentile": 0.80071}, "CVE-2017-11579": {"epss_score": 0.00756, "epss_percentile": 0.72727}, "CVE-2017-11580": {"epss_score": 0.00497, "epss_percentile": 0.65209}, "CVE-2017-11581": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-11582": {"epss_score": 0.00292, "epss_percentile": 0.52221}, "CVE-2017-11583": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-11584": {"epss_score": 0.00518, "epss_percentile": 0.66097}, "CVE-2017-11585": {"epss_score": 0.01141, "epss_percentile": 0.77955}, "CVE-2017-11586": {"epss_score": 0.06568, "epss_percentile": 0.90852}, "CVE-2017-11587": {"epss_score": 0.00723, "epss_percentile": 0.72009}, "CVE-2017-11588": {"epss_score": 0.0667, "epss_percentile": 0.90933}, "CVE-2017-11589": {"epss_score": 0.00599, "epss_percentile": 0.6879}, "CVE-2017-11590": {"epss_score": 0.01069, "epss_percentile": 0.77247}, "CVE-2017-11591": {"epss_score": 0.00277, "epss_percentile": 0.50795}, "CVE-2017-11592": {"epss_score": 0.01065, "epss_percentile": 0.77213}, "CVE-2017-11593": {"epss_score": 0.00242, "epss_percentile": 0.4738}, "CVE-2017-11594": {"epss_score": 0.00227, "epss_percentile": 0.45434}, "CVE-2017-11600": {"epss_score": 0.00074, "epss_percentile": 0.22771}, "CVE-2017-11605": {"epss_score": 0.00289, "epss_percentile": 0.52044}, "CVE-2017-11608": {"epss_score": 0.01021, "epss_percentile": 0.76749}, "CVE-2017-11610": {"epss_score": 0.93776, "epss_percentile": 0.99843}, "CVE-2017-11611": {"epss_score": 0.01345, "epss_percentile": 0.79627}, "CVE-2017-11612": {"epss_score": 0.00103, "epss_percentile": 0.29002}, "CVE-2017-11613": {"epss_score": 0.00362, "epss_percentile": 0.5778}, "CVE-2017-11614": {"epss_score": 0.00345, "epss_percentile": 0.56559}, "CVE-2017-11615": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2017-11617": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2017-11624": {"epss_score": 0.00317, "epss_percentile": 0.54311}, "CVE-2017-11625": {"epss_score": 0.00306, "epss_percentile": 0.53402}, "CVE-2017-11626": {"epss_score": 0.00338, "epss_percentile": 0.56126}, "CVE-2017-11627": {"epss_score": 0.00144, "epss_percentile": 0.35299}, "CVE-2017-11628": {"epss_score": 0.00151, "epss_percentile": 0.36251}, "CVE-2017-11629": {"epss_score": 0.00588, "epss_percentile": 0.68498}, "CVE-2017-11630": {"epss_score": 0.00784, "epss_percentile": 0.73233}, "CVE-2017-11631": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-11632": {"epss_score": 0.02464, "epss_percentile": 0.84833}, "CVE-2017-11633": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2017-11634": {"epss_score": 0.02464, "epss_percentile": 0.84833}, "CVE-2017-11635": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2017-11636": {"epss_score": 0.00736, "epss_percentile": 0.72304}, "CVE-2017-11637": {"epss_score": 0.00415, "epss_percentile": 0.61154}, "CVE-2017-11638": {"epss_score": 0.00589, "epss_percentile": 0.68513}, "CVE-2017-11639": {"epss_score": 0.00516, "epss_percentile": 0.66011}, "CVE-2017-11640": {"epss_score": 0.0057, "epss_percentile": 0.67938}, "CVE-2017-11641": {"epss_score": 0.00451, "epss_percentile": 0.63115}, "CVE-2017-11642": {"epss_score": 0.00505, "epss_percentile": 0.65601}, "CVE-2017-11643": {"epss_score": 0.00511, "epss_percentile": 0.65845}, "CVE-2017-11644": {"epss_score": 0.0038, "epss_percentile": 0.58913}, "CVE-2017-11645": {"epss_score": 0.00403, "epss_percentile": 0.60355}, "CVE-2017-11646": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2017-11647": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-11648": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2017-11649": {"epss_score": 0.0013, "epss_percentile": 0.33228}, "CVE-2017-11650": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2017-11651": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-11652": {"epss_score": 0.00039, "epss_percentile": 0.11468}, "CVE-2017-11653": {"epss_score": 0.00035, "epss_percentile": 0.10049}, "CVE-2017-11654": {"epss_score": 0.01178, "epss_percentile": 0.78288}, "CVE-2017-11655": {"epss_score": 0.01826, "epss_percentile": 0.82433}, "CVE-2017-11657": {"epss_score": 0.0012, "epss_percentile": 0.31759}, "CVE-2017-11658": {"epss_score": 0.03026, "epss_percentile": 0.86241}, "CVE-2017-11661": {"epss_score": 0.07864, "epss_percentile": 0.91728}, "CVE-2017-11662": {"epss_score": 0.08437, "epss_percentile": 0.92052}, "CVE-2017-11663": {"epss_score": 0.06265, "epss_percentile": 0.90622}, "CVE-2017-11664": {"epss_score": 0.06482, "epss_percentile": 0.90789}, "CVE-2017-11665": {"epss_score": 0.00534, "epss_percentile": 0.668}, "CVE-2017-11666": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2017-11667": {"epss_score": 0.00817, "epss_percentile": 0.73848}, "CVE-2017-11668": {"epss_score": 0.0065, "epss_percentile": 0.70268}, "CVE-2017-11669": {"epss_score": 0.0065, "epss_percentile": 0.70268}, "CVE-2017-11670": {"epss_score": 0.0065, "epss_percentile": 0.70268}, "CVE-2017-11671": {"epss_score": 0.00113, "epss_percentile": 0.30716}, "CVE-2017-11672": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2017-11673": {"epss_score": 0.02361, "epss_percentile": 0.84496}, "CVE-2017-11674": {"epss_score": 0.00141, "epss_percentile": 0.34951}, "CVE-2017-11675": {"epss_score": 0.00717, "epss_percentile": 0.71891}, "CVE-2017-11677": {"epss_score": 0.00233, "epss_percentile": 0.45976}, "CVE-2017-11678": {"epss_score": 0.00538, "epss_percentile": 0.66941}, "CVE-2017-11679": {"epss_score": 0.00212, "epss_percentile": 0.43789}, "CVE-2017-11680": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2017-11681": {"epss_score": 0.00574, "epss_percentile": 0.68095}, "CVE-2017-11682": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2017-11683": {"epss_score": 0.00399, "epss_percentile": 0.60112}, "CVE-2017-11684": {"epss_score": 0.00753, "epss_percentile": 0.72668}, "CVE-2017-11685": {"epss_score": 0.00474, "epss_percentile": 0.64145}, "CVE-2017-11686": {"epss_score": 0.01664, "epss_percentile": 0.81642}, "CVE-2017-11687": {"epss_score": 0.00474, "epss_percentile": 0.64145}, "CVE-2017-11691": {"epss_score": 0.00506, "epss_percentile": 0.65631}, "CVE-2017-11692": {"epss_score": 0.00637, "epss_percentile": 0.69888}, "CVE-2017-11693": {"epss_score": 0.00244, "epss_percentile": 0.47553}, "CVE-2017-11694": {"epss_score": 0.00244, "epss_percentile": 0.47553}, "CVE-2017-11695": {"epss_score": 0.00088, "epss_percentile": 0.2577}, "CVE-2017-11696": {"epss_score": 0.00088, "epss_percentile": 0.2577}, "CVE-2017-11697": {"epss_score": 0.00106, "epss_percentile": 0.29485}, "CVE-2017-11698": {"epss_score": 0.00088, "epss_percentile": 0.2577}, "CVE-2017-11703": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2017-11704": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2017-11705": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2017-11706": {"epss_score": 0.00337, "epss_percentile": 0.56023}, "CVE-2017-11714": {"epss_score": 0.00335, "epss_percentile": 0.55817}, "CVE-2017-11715": {"epss_score": 0.00851, "epss_percentile": 0.74406}, "CVE-2017-11716": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-11717": {"epss_score": 0.00395, "epss_percentile": 0.59803}, "CVE-2017-11718": {"epss_score": 0.00199, "epss_percentile": 0.42149}, "CVE-2017-11719": {"epss_score": 0.0025, "epss_percentile": 0.48112}, "CVE-2017-11720": {"epss_score": 0.0045, "epss_percentile": 0.63101}, "CVE-2017-11721": {"epss_score": 0.03231, "epss_percentile": 0.86697}, "CVE-2017-11722": {"epss_score": 0.00733, "epss_percentile": 0.72211}, "CVE-2017-11723": {"epss_score": 0.00334, "epss_percentile": 0.55744}, "CVE-2017-11724": {"epss_score": 0.00461, "epss_percentile": 0.63539}, "CVE-2017-11725": {"epss_score": 0.00161, "epss_percentile": 0.37608}, "CVE-2017-11726": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2017-11727": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2017-11728": {"epss_score": 0.00208, "epss_percentile": 0.43225}, "CVE-2017-11729": {"epss_score": 0.00205, "epss_percentile": 0.42756}, "CVE-2017-11730": {"epss_score": 0.00205, "epss_percentile": 0.42756}, "CVE-2017-11731": {"epss_score": 0.00208, "epss_percentile": 0.43225}, "CVE-2017-11732": {"epss_score": 0.00215, "epss_percentile": 0.44064}, "CVE-2017-11733": {"epss_score": 0.00318, "epss_percentile": 0.54442}, "CVE-2017-11734": {"epss_score": 0.00178, "epss_percentile": 0.39676}, "CVE-2017-11736": {"epss_score": 0.00344, "epss_percentile": 0.56499}, "CVE-2017-11737": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-11738": {"epss_score": 0.00835, "epss_percentile": 0.74125}, "CVE-2017-11739": {"epss_score": 0.01853, "epss_percentile": 0.82548}, "CVE-2017-11740": {"epss_score": 0.01835, "epss_percentile": 0.82465}, "CVE-2017-11741": {"epss_score": 0.00312, "epss_percentile": 0.53957}, "CVE-2017-11742": {"epss_score": 0.00019, "epss_percentile": 0.04063}, "CVE-2017-11743": {"epss_score": 0.00786, "epss_percentile": 0.73269}, "CVE-2017-11744": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-11746": {"epss_score": 0.00321, "epss_percentile": 0.54679}, "CVE-2017-11747": {"epss_score": 0.0003, "epss_percentile": 0.082}, "CVE-2017-11748": {"epss_score": 0.00237, "epss_percentile": 0.46643}, "CVE-2017-11749": {"epss_score": 0.00237, "epss_percentile": 0.46643}, "CVE-2017-11750": {"epss_score": 0.00533, "epss_percentile": 0.66753}, "CVE-2017-11751": {"epss_score": 0.00531, "epss_percentile": 0.66657}, "CVE-2017-11752": {"epss_score": 0.00191, "epss_percentile": 0.41261}, "CVE-2017-11753": {"epss_score": 0.00528, "epss_percentile": 0.66549}, "CVE-2017-11754": {"epss_score": 0.00528, "epss_percentile": 0.66549}, "CVE-2017-11755": {"epss_score": 0.00528, "epss_percentile": 0.66549}, "CVE-2017-11756": {"epss_score": 0.00305, "epss_percentile": 0.53384}, "CVE-2017-11757": {"epss_score": 0.03545, "epss_percentile": 0.87324}, "CVE-2017-11760": {"epss_score": 0.00636, "epss_percentile": 0.69833}, "CVE-2017-11761": {"epss_score": 0.07988, "epss_percentile": 0.91807}, "CVE-2017-11762": {"epss_score": 0.40686, "epss_percentile": 0.97232}, "CVE-2017-11763": {"epss_score": 0.40686, "epss_percentile": 0.97232}, "CVE-2017-11764": {"epss_score": 0.76682, "epss_percentile": 0.98901}, "CVE-2017-11765": {"epss_score": 0.08, "epss_percentile": 0.9182}, "CVE-2017-11766": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11767": {"epss_score": 0.17164, "epss_percentile": 0.9479}, "CVE-2017-11768": {"epss_score": 0.01539, "epss_percentile": 0.80936}, "CVE-2017-11769": {"epss_score": 0.3391, "epss_percentile": 0.96816}, "CVE-2017-11770": {"epss_score": 0.09898, "epss_percentile": 0.92761}, "CVE-2017-11771": {"epss_score": 0.65606, "epss_percentile": 0.98428}, "CVE-2017-11772": {"epss_score": 0.22657, "epss_percentile": 0.95665}, "CVE-2017-11774": {"epss_score": 0.82853, "epss_percentile": 0.99219}, "CVE-2017-11775": {"epss_score": 0.00855, "epss_percentile": 0.74461}, "CVE-2017-11776": {"epss_score": 0.18636, "epss_percentile": 0.95046}, "CVE-2017-11777": {"epss_score": 0.00855, "epss_percentile": 0.74461}, "CVE-2017-11779": {"epss_score": 0.38264, "epss_percentile": 0.97093}, "CVE-2017-11780": {"epss_score": 0.09106, "epss_percentile": 0.92402}, "CVE-2017-11781": {"epss_score": 0.21784, "epss_percentile": 0.95559}, "CVE-2017-11782": {"epss_score": 0.00724, "epss_percentile": 0.72033}, "CVE-2017-11783": {"epss_score": 0.07572, "epss_percentile": 0.91546}, "CVE-2017-11784": {"epss_score": 0.08, "epss_percentile": 0.9182}, "CVE-2017-11785": {"epss_score": 0.07293, "epss_percentile": 0.91388}, "CVE-2017-11786": {"epss_score": 0.11493, "epss_percentile": 0.93384}, "CVE-2017-11788": {"epss_score": 0.1833, "epss_percentile": 0.94996}, "CVE-2017-11790": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2017-11791": {"epss_score": 0.15554, "epss_percentile": 0.94458}, "CVE-2017-11792": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2017-11793": {"epss_score": 0.6165, "epss_percentile": 0.98257}, "CVE-2017-11794": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2017-11796": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2017-11797": {"epss_score": 0.26105, "epss_percentile": 0.96112}, "CVE-2017-11798": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11799": {"epss_score": 0.78672, "epss_percentile": 0.98998}, "CVE-2017-11800": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11801": {"epss_score": 0.26105, "epss_percentile": 0.96112}, "CVE-2017-11802": {"epss_score": 0.78672, "epss_percentile": 0.98998}, "CVE-2017-11803": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2017-11804": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11805": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2017-11806": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2017-11807": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2017-11808": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2017-11809": {"epss_score": 0.78672, "epss_percentile": 0.98998}, "CVE-2017-11810": {"epss_score": 0.62692, "epss_percentile": 0.98303}, "CVE-2017-11811": {"epss_score": 0.74043, "epss_percentile": 0.98786}, "CVE-2017-11812": {"epss_score": 0.42327, "epss_percentile": 0.97326}, "CVE-2017-11813": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11814": {"epss_score": 0.08, "epss_percentile": 0.9182}, "CVE-2017-11815": {"epss_score": 0.22607, "epss_percentile": 0.95656}, "CVE-2017-11816": {"epss_score": 0.00619, "epss_percentile": 0.69431}, "CVE-2017-11817": {"epss_score": 0.03549, "epss_percentile": 0.87336}, "CVE-2017-11818": {"epss_score": 0.01721, "epss_percentile": 0.81934}, "CVE-2017-11819": {"epss_score": 0.25959, "epss_percentile": 0.96096}, "CVE-2017-11820": {"epss_score": 0.00855, "epss_percentile": 0.74461}, "CVE-2017-11821": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2017-11822": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11823": {"epss_score": 0.0302, "epss_percentile": 0.86222}, "CVE-2017-11824": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2017-11825": {"epss_score": 0.32412, "epss_percentile": 0.96697}, "CVE-2017-11826": {"epss_score": 0.90484, "epss_percentile": 0.99585}, "CVE-2017-11827": {"epss_score": 0.28147, "epss_percentile": 0.96324}, "CVE-2017-11829": {"epss_score": 0.02283, "epss_percentile": 0.84259}, "CVE-2017-11830": {"epss_score": 0.05314, "epss_percentile": 0.8972}, "CVE-2017-11831": {"epss_score": 0.02972, "epss_percentile": 0.86097}, "CVE-2017-11832": {"epss_score": 0.01194, "epss_percentile": 0.78412}, "CVE-2017-11833": {"epss_score": 0.12271, "epss_percentile": 0.93618}, "CVE-2017-11834": {"epss_score": 0.22344, "epss_percentile": 0.95624}, "CVE-2017-11835": {"epss_score": 0.02807, "epss_percentile": 0.85708}, "CVE-2017-11836": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11837": {"epss_score": 0.27619, "epss_percentile": 0.96264}, "CVE-2017-11838": {"epss_score": 0.27619, "epss_percentile": 0.96264}, "CVE-2017-11839": {"epss_score": 0.82281, "epss_percentile": 0.99184}, "CVE-2017-11840": {"epss_score": 0.80398, "epss_percentile": 0.99086}, "CVE-2017-11841": {"epss_score": 0.80398, "epss_percentile": 0.99086}, "CVE-2017-11842": {"epss_score": 0.04118, "epss_percentile": 0.88281}, "CVE-2017-11843": {"epss_score": 0.27619, "epss_percentile": 0.96264}, "CVE-2017-11844": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2017-11845": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11846": {"epss_score": 0.28099, "epss_percentile": 0.9631}, "CVE-2017-11847": {"epss_score": 0.14392, "epss_percentile": 0.94202}, "CVE-2017-11848": {"epss_score": 0.0865, "epss_percentile": 0.92171}, "CVE-2017-11849": {"epss_score": 0.04118, "epss_percentile": 0.88281}, "CVE-2017-11850": {"epss_score": 0.03652, "epss_percentile": 0.8751}, "CVE-2017-11851": {"epss_score": 0.03549, "epss_percentile": 0.87336}, "CVE-2017-11852": {"epss_score": 0.04118, "epss_percentile": 0.88281}, "CVE-2017-11853": {"epss_score": 0.09951, "epss_percentile": 0.92787}, "CVE-2017-11854": {"epss_score": 0.1888, "epss_percentile": 0.95083}, "CVE-2017-11855": {"epss_score": 0.4926, "epss_percentile": 0.97676}, "CVE-2017-11856": {"epss_score": 0.20786, "epss_percentile": 0.95412}, "CVE-2017-11858": {"epss_score": 0.24329, "epss_percentile": 0.95905}, "CVE-2017-11861": {"epss_score": 0.76161, "epss_percentile": 0.9888}, "CVE-2017-11862": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11863": {"epss_score": 0.01093, "epss_percentile": 0.77472}, "CVE-2017-11866": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11869": {"epss_score": 0.24329, "epss_percentile": 0.95905}, "CVE-2017-11870": {"epss_score": 0.80398, "epss_percentile": 0.99086}, "CVE-2017-11871": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11872": {"epss_score": 0.20753, "epss_percentile": 0.95407}, "CVE-2017-11873": {"epss_score": 0.76107, "epss_percentile": 0.98878}, "CVE-2017-11874": {"epss_score": 0.05826, "epss_percentile": 0.90239}, "CVE-2017-11876": {"epss_score": 0.00976, "epss_percentile": 0.76212}, "CVE-2017-11877": {"epss_score": 0.11994, "epss_percentile": 0.9354}, "CVE-2017-11878": {"epss_score": 0.09662, "epss_percentile": 0.92645}, "CVE-2017-11879": {"epss_score": 0.10013, "epss_percentile": 0.92817}, "CVE-2017-11880": {"epss_score": 0.01393, "epss_percentile": 0.79963}, "CVE-2017-11882": {"epss_score": 0.94384, "epss_percentile": 0.99966}, "CVE-2017-11883": {"epss_score": 0.20304, "epss_percentile": 0.95318}, "CVE-2017-11884": {"epss_score": 0.55619, "epss_percentile": 0.97987}, "CVE-2017-11885": {"epss_score": 0.64731, "epss_percentile": 0.9839}, "CVE-2017-11886": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11887": {"epss_score": 0.25571, "epss_percentile": 0.96046}, "CVE-2017-11888": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11889": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2017-11890": {"epss_score": 0.5872, "epss_percentile": 0.98133}, "CVE-2017-11893": {"epss_score": 0.73993, "epss_percentile": 0.98781}, "CVE-2017-11894": {"epss_score": 0.3205, "epss_percentile": 0.96669}, "CVE-2017-11895": {"epss_score": 0.3205, "epss_percentile": 0.96669}, "CVE-2017-11899": {"epss_score": 0.20177, "epss_percentile": 0.95299}, "CVE-2017-11901": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11903": {"epss_score": 0.60834, "epss_percentile": 0.98223}, "CVE-2017-11905": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2017-11906": {"epss_score": 0.5589, "epss_percentile": 0.98001}, "CVE-2017-11907": {"epss_score": 0.76161, "epss_percentile": 0.9888}, "CVE-2017-11908": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2017-11909": {"epss_score": 0.73993, "epss_percentile": 0.98781}, "CVE-2017-11910": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2017-11911": {"epss_score": 0.73993, "epss_percentile": 0.98781}, "CVE-2017-11912": {"epss_score": 0.3205, "epss_percentile": 0.96669}, "CVE-2017-11913": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11914": {"epss_score": 0.73407, "epss_percentile": 0.98751}, "CVE-2017-11916": {"epss_score": 0.2394, "epss_percentile": 0.95836}, "CVE-2017-11918": {"epss_score": 0.73407, "epss_percentile": 0.98751}, "CVE-2017-11919": {"epss_score": 0.25571, "epss_percentile": 0.96046}, "CVE-2017-11927": {"epss_score": 0.25961, "epss_percentile": 0.96097}, "CVE-2017-11930": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-11932": {"epss_score": 0.14796, "epss_percentile": 0.94286}, "CVE-2017-11934": {"epss_score": 0.20427, "epss_percentile": 0.95344}, "CVE-2017-11935": {"epss_score": 0.32412, "epss_percentile": 0.96697}, "CVE-2017-11936": {"epss_score": 0.14996, "epss_percentile": 0.94338}, "CVE-2017-11937": {"epss_score": 0.69515, "epss_percentile": 0.98591}, "CVE-2017-11939": {"epss_score": 0.01995, "epss_percentile": 0.8319}, "CVE-2017-11940": {"epss_score": 0.32412, "epss_percentile": 0.96697}, "CVE-2017-12061": {"epss_score": 0.01034, "epss_percentile": 0.76887}, "CVE-2017-12062": {"epss_score": 0.00741, "epss_percentile": 0.72447}, "CVE-2017-12064": {"epss_score": 0.00593, "epss_percentile": 0.68643}, "CVE-2017-12065": {"epss_score": 0.03315, "epss_percentile": 0.86899}, "CVE-2017-12066": {"epss_score": 0.0024, "epss_percentile": 0.47198}, "CVE-2017-12067": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2017-12068": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-12069": {"epss_score": 0.00937, "epss_percentile": 0.75699}, "CVE-2017-12070": {"epss_score": 0.00419, "epss_percentile": 0.61354}, "CVE-2017-12071": {"epss_score": 0.00344, "epss_percentile": 0.56496}, "CVE-2017-12072": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2017-12074": {"epss_score": 0.00418, "epss_percentile": 0.61293}, "CVE-2017-12075": {"epss_score": 0.01865, "epss_percentile": 0.82602}, "CVE-2017-12076": {"epss_score": 0.00467, "epss_percentile": 0.63819}, "CVE-2017-12077": {"epss_score": 0.00518, "epss_percentile": 0.66126}, "CVE-2017-12078": {"epss_score": 0.07498, "epss_percentile": 0.91505}, "CVE-2017-12079": {"epss_score": 0.00297, "epss_percentile": 0.5277}, "CVE-2017-12080": {"epss_score": 0.0023, "epss_percentile": 0.45762}, "CVE-2017-12081": {"epss_score": 0.00786, "epss_percentile": 0.73267}, "CVE-2017-12082": {"epss_score": 0.00786, "epss_percentile": 0.73267}, "CVE-2017-12083": {"epss_score": 0.00289, "epss_percentile": 0.51981}, "CVE-2017-12084": {"epss_score": 0.00392, "epss_percentile": 0.59645}, "CVE-2017-12085": {"epss_score": 0.01455, "epss_percentile": 0.80385}, "CVE-2017-12086": {"epss_score": 0.00786, "epss_percentile": 0.73267}, "CVE-2017-12087": {"epss_score": 0.01691, "epss_percentile": 0.81778}, "CVE-2017-12088": {"epss_score": 0.00087, "epss_percentile": 0.25478}, "CVE-2017-12089": {"epss_score": 0.00092, "epss_percentile": 0.26441}, "CVE-2017-12090": {"epss_score": 0.00017, "epss_percentile": 0.03396}, "CVE-2017-12092": {"epss_score": 0.00078, "epss_percentile": 0.23553}, "CVE-2017-12093": {"epss_score": 0.03237, "epss_percentile": 0.86706}, "CVE-2017-12094": {"epss_score": 0.00325, "epss_percentile": 0.55014}, "CVE-2017-12095": {"epss_score": 0.00105, "epss_percentile": 0.29346}, "CVE-2017-12096": {"epss_score": 0.00099, "epss_percentile": 0.28311}, "CVE-2017-12097": {"epss_score": 0.00398, "epss_percentile": 0.60069}, "CVE-2017-12098": {"epss_score": 0.00397, "epss_percentile": 0.60038}, "CVE-2017-12099": {"epss_score": 0.01231, "epss_percentile": 0.78732}, "CVE-2017-12100": {"epss_score": 0.01231, "epss_percentile": 0.78732}, "CVE-2017-12101": {"epss_score": 0.00974, "epss_percentile": 0.76173}, "CVE-2017-12102": {"epss_score": 0.00974, "epss_percentile": 0.76173}, "CVE-2017-12103": {"epss_score": 0.01231, "epss_percentile": 0.78732}, "CVE-2017-12104": {"epss_score": 0.01231, "epss_percentile": 0.78732}, "CVE-2017-12105": {"epss_score": 0.01231, "epss_percentile": 0.78732}, "CVE-2017-12106": {"epss_score": 0.00386, "epss_percentile": 0.59235}, "CVE-2017-12107": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2017-12108": {"epss_score": 0.01096, "epss_percentile": 0.7752}, "CVE-2017-12109": {"epss_score": 0.01096, "epss_percentile": 0.7752}, "CVE-2017-12110": {"epss_score": 0.00658, "epss_percentile": 0.70485}, "CVE-2017-12111": {"epss_score": 0.00658, "epss_percentile": 0.70485}, "CVE-2017-12112": {"epss_score": 0.00283, "epss_percentile": 0.51362}, "CVE-2017-12113": {"epss_score": 0.00283, "epss_percentile": 0.51362}, "CVE-2017-12114": {"epss_score": 0.00253, "epss_percentile": 0.4846}, "CVE-2017-12115": {"epss_score": 0.00558, "epss_percentile": 0.67601}, "CVE-2017-12116": {"epss_score": 0.00608, "epss_percentile": 0.69073}, "CVE-2017-12117": {"epss_score": 0.00613, "epss_percentile": 0.69262}, "CVE-2017-12118": {"epss_score": 0.00788, "epss_percentile": 0.73324}, "CVE-2017-12119": {"epss_score": 0.0055, "epss_percentile": 0.6735}, "CVE-2017-12120": {"epss_score": 0.02733, "epss_percentile": 0.85546}, "CVE-2017-12121": {"epss_score": 0.02733, "epss_percentile": 0.85546}, "CVE-2017-12122": {"epss_score": 0.01548, "epss_percentile": 0.80978}, "CVE-2017-12123": {"epss_score": 0.0017, "epss_percentile": 0.38718}, "CVE-2017-12124": {"epss_score": 0.01217, "epss_percentile": 0.78597}, "CVE-2017-12125": {"epss_score": 0.02733, "epss_percentile": 0.85546}, "CVE-2017-12126": {"epss_score": 0.00876, "epss_percentile": 0.74787}, "CVE-2017-12127": {"epss_score": 0.00121, "epss_percentile": 0.31988}, "CVE-2017-12128": {"epss_score": 0.03045, "epss_percentile": 0.86281}, "CVE-2017-12129": {"epss_score": 0.0008, "epss_percentile": 0.24142}, "CVE-2017-12130": {"epss_score": 0.00726, "epss_percentile": 0.72066}, "CVE-2017-12131": {"epss_score": 0.00315, "epss_percentile": 0.54168}, "CVE-2017-12132": {"epss_score": 0.00258, "epss_percentile": 0.48956}, "CVE-2017-12133": {"epss_score": 0.00471, "epss_percentile": 0.64004}, "CVE-2017-12134": {"epss_score": 0.00339, "epss_percentile": 0.56209}, "CVE-2017-12135": {"epss_score": 0.00126, "epss_percentile": 0.32671}, "CVE-2017-12136": {"epss_score": 0.00053, "epss_percentile": 0.16721}, "CVE-2017-12137": {"epss_score": 0.00099, "epss_percentile": 0.27854}, "CVE-2017-12138": {"epss_score": 0.20503, "epss_percentile": 0.95356}, "CVE-2017-12139": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-12140": {"epss_score": 0.0064, "epss_percentile": 0.69973}, "CVE-2017-12141": {"epss_score": 0.00174, "epss_percentile": 0.39152}, "CVE-2017-12142": {"epss_score": 0.00156, "epss_percentile": 0.3696}, "CVE-2017-12143": {"epss_score": 0.00278, "epss_percentile": 0.50891}, "CVE-2017-12144": {"epss_score": 0.00193, "epss_percentile": 0.41379}, "CVE-2017-12145": {"epss_score": 0.00334, "epss_percentile": 0.55732}, "CVE-2017-12146": {"epss_score": 0.00059, "epss_percentile": 0.18843}, "CVE-2017-12148": {"epss_score": 0.00448, "epss_percentile": 0.63016}, "CVE-2017-12149": {"epss_score": 0.94294, "epss_percentile": 0.99937}, "CVE-2017-12150": {"epss_score": 0.19452, "epss_percentile": 0.95183}, "CVE-2017-12151": {"epss_score": 0.0803, "epss_percentile": 0.91841}, "CVE-2017-12153": {"epss_score": 0.00017, "epss_percentile": 0.03057}, "CVE-2017-12154": {"epss_score": 0.00027, "epss_percentile": 0.06744}, "CVE-2017-12155": {"epss_score": 0.00047, "epss_percentile": 0.14627}, "CVE-2017-12156": {"epss_score": 0.00217, "epss_percentile": 0.44334}, "CVE-2017-12157": {"epss_score": 0.00232, "epss_percentile": 0.45902}, "CVE-2017-12158": {"epss_score": 0.00668, "epss_percentile": 0.70729}, "CVE-2017-12159": {"epss_score": 0.00588, "epss_percentile": 0.68496}, "CVE-2017-12160": {"epss_score": 0.00571, "epss_percentile": 0.67984}, "CVE-2017-12161": {"epss_score": 0.00279, "epss_percentile": 0.5093}, "CVE-2017-12163": {"epss_score": 0.58954, "epss_percentile": 0.98142}, "CVE-2017-12164": {"epss_score": 0.00117, "epss_percentile": 0.31235}, "CVE-2017-12165": {"epss_score": 0.01096, "epss_percentile": 0.77522}, "CVE-2017-12166": {"epss_score": 0.0133, "epss_percentile": 0.79509}, "CVE-2017-12167": {"epss_score": 0.00051, "epss_percentile": 0.16319}, "CVE-2017-12168": {"epss_score": 0.00052, "epss_percentile": 0.16617}, "CVE-2017-12169": {"epss_score": 0.00219, "epss_percentile": 0.44475}, "CVE-2017-12170": {"epss_score": 0.00327, "epss_percentile": 0.55133}, "CVE-2017-12171": {"epss_score": 0.00898, "epss_percentile": 0.7514}, "CVE-2017-12172": {"epss_score": 0.00039, "epss_percentile": 0.11628}, "CVE-2017-12173": {"epss_score": 0.00471, "epss_percentile": 0.64023}, "CVE-2017-12174": {"epss_score": 0.20493, "epss_percentile": 0.95355}, "CVE-2017-12175": {"epss_score": 0.00473, "epss_percentile": 0.64097}, "CVE-2017-12176": {"epss_score": 0.0095, "epss_percentile": 0.75855}, "CVE-2017-12177": {"epss_score": 0.0095, "epss_percentile": 0.75855}, "CVE-2017-12178": {"epss_score": 0.0095, "epss_percentile": 0.75855}, "CVE-2017-12179": {"epss_score": 0.00843, "epss_percentile": 0.74258}, "CVE-2017-12180": {"epss_score": 0.0095, "epss_percentile": 0.75855}, "CVE-2017-12181": {"epss_score": 0.00843, "epss_percentile": 0.74258}, "CVE-2017-12182": {"epss_score": 0.0095, "epss_percentile": 0.75855}, "CVE-2017-12183": {"epss_score": 0.0095, "epss_percentile": 0.75855}, "CVE-2017-12184": {"epss_score": 0.00843, "epss_percentile": 0.74258}, "CVE-2017-12185": {"epss_score": 0.00843, "epss_percentile": 0.74258}, "CVE-2017-12186": {"epss_score": 0.00754, "epss_percentile": 0.72703}, "CVE-2017-12187": {"epss_score": 0.00773, "epss_percentile": 0.7306}, "CVE-2017-12188": {"epss_score": 0.00055, "epss_percentile": 0.17372}, "CVE-2017-12189": {"epss_score": 0.00049, "epss_percentile": 0.15496}, "CVE-2017-12190": {"epss_score": 0.00092, "epss_percentile": 0.26582}, "CVE-2017-12191": {"epss_score": 0.00169, "epss_percentile": 0.38571}, "CVE-2017-12192": {"epss_score": 0.00113, "epss_percentile": 0.30705}, "CVE-2017-12193": {"epss_score": 0.00076, "epss_percentile": 0.23179}, "CVE-2017-12194": {"epss_score": 0.01485, "epss_percentile": 0.80594}, "CVE-2017-12195": {"epss_score": 0.00198, "epss_percentile": 0.4202}, "CVE-2017-12196": {"epss_score": 0.00214, "epss_percentile": 0.44011}, "CVE-2017-12197": {"epss_score": 0.00427, "epss_percentile": 0.61869}, "CVE-2017-12199": {"epss_score": 0.02081, "epss_percentile": 0.83532}, "CVE-2017-12200": {"epss_score": 0.00329, "epss_percentile": 0.5539}, "CVE-2017-12211": {"epss_score": 0.01139, "epss_percentile": 0.7794}, "CVE-2017-12212": {"epss_score": 0.00308, "epss_percentile": 0.53625}, "CVE-2017-12213": {"epss_score": 0.00239, "epss_percentile": 0.46905}, "CVE-2017-12214": {"epss_score": 0.0092, "epss_percentile": 0.7547}, "CVE-2017-12215": {"epss_score": 0.0089, "epss_percentile": 0.75033}, "CVE-2017-12216": {"epss_score": 0.01569, "epss_percentile": 0.8108}, "CVE-2017-12217": {"epss_score": 0.00552, "epss_percentile": 0.6738}, "CVE-2017-12218": {"epss_score": 0.00383, "epss_percentile": 0.59116}, "CVE-2017-12219": {"epss_score": 0.01379, "epss_percentile": 0.79854}, "CVE-2017-12220": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2017-12221": {"epss_score": 0.00363, "epss_percentile": 0.57824}, "CVE-2017-12222": {"epss_score": 0.00256, "epss_percentile": 0.48826}, "CVE-2017-12223": {"epss_score": 0.00097, "epss_percentile": 0.27546}, "CVE-2017-12224": {"epss_score": 0.00441, "epss_percentile": 0.62652}, "CVE-2017-12225": {"epss_score": 0.00415, "epss_percentile": 0.61153}, "CVE-2017-12226": {"epss_score": 0.03974, "epss_percentile": 0.88046}, "CVE-2017-12227": {"epss_score": 0.00175, "epss_percentile": 0.39293}, "CVE-2017-12228": {"epss_score": 0.00323, "epss_percentile": 0.54863}, "CVE-2017-12229": {"epss_score": 0.09258, "epss_percentile": 0.92468}, "CVE-2017-12230": {"epss_score": 0.00787, "epss_percentile": 0.73301}, "CVE-2017-12231": {"epss_score": 0.06802, "epss_percentile": 0.91035}, "CVE-2017-12232": {"epss_score": 0.00987, "epss_percentile": 0.76343}, "CVE-2017-12233": {"epss_score": 0.06545, "epss_percentile": 0.90839}, "CVE-2017-12234": {"epss_score": 0.06545, "epss_percentile": 0.90839}, "CVE-2017-12235": {"epss_score": 0.04928, "epss_percentile": 0.89296}, "CVE-2017-12236": {"epss_score": 0.03344, "epss_percentile": 0.8695}, "CVE-2017-12237": {"epss_score": 0.05315, "epss_percentile": 0.89722}, "CVE-2017-12238": {"epss_score": 0.01154, "epss_percentile": 0.7807}, "CVE-2017-12239": {"epss_score": 0.00142, "epss_percentile": 0.34993}, "CVE-2017-12240": {"epss_score": 0.07962, "epss_percentile": 0.91791}, "CVE-2017-12243": {"epss_score": 0.4022, "epss_percentile": 0.97207}, "CVE-2017-12244": {"epss_score": 0.00274, "epss_percentile": 0.50579}, "CVE-2017-12245": {"epss_score": 0.00662, "epss_percentile": 0.70608}, "CVE-2017-12246": {"epss_score": 0.03293, "epss_percentile": 0.86839}, "CVE-2017-12248": {"epss_score": 0.00232, "epss_percentile": 0.45882}, "CVE-2017-12249": {"epss_score": 0.01223, "epss_percentile": 0.78666}, "CVE-2017-12250": {"epss_score": 0.00821, "epss_percentile": 0.73897}, "CVE-2017-12251": {"epss_score": 0.03196, "epss_percentile": 0.8661}, "CVE-2017-12252": {"epss_score": 0.0007, "epss_percentile": 0.21815}, "CVE-2017-12253": {"epss_score": 0.00329, "epss_percentile": 0.55382}, "CVE-2017-12254": {"epss_score": 0.00319, "epss_percentile": 0.54481}, "CVE-2017-12255": {"epss_score": 0.00062, "epss_percentile": 0.19585}, "CVE-2017-12256": {"epss_score": 0.00314, "epss_percentile": 0.54126}, "CVE-2017-12257": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2017-12258": {"epss_score": 0.0257, "epss_percentile": 0.85127}, "CVE-2017-12259": {"epss_score": 0.01409, "epss_percentile": 0.80068}, "CVE-2017-12260": {"epss_score": 0.01409, "epss_percentile": 0.80068}, "CVE-2017-12261": {"epss_score": 0.00046, "epss_percentile": 0.1443}, "CVE-2017-12262": {"epss_score": 0.00602, "epss_percentile": 0.68893}, "CVE-2017-12263": {"epss_score": 0.334, "epss_percentile": 0.96769}, "CVE-2017-12264": {"epss_score": 0.0096, "epss_percentile": 0.75967}, "CVE-2017-12265": {"epss_score": 0.0017, "epss_percentile": 0.38765}, "CVE-2017-12266": {"epss_score": 0.00028, "epss_percentile": 0.07491}, "CVE-2017-12267": {"epss_score": 0.00476, "epss_percentile": 0.64252}, "CVE-2017-12268": {"epss_score": 0.00072, "epss_percentile": 0.22331}, "CVE-2017-12269": {"epss_score": 0.00363, "epss_percentile": 0.57824}, "CVE-2017-12270": {"epss_score": 0.00889, "epss_percentile": 0.75021}, "CVE-2017-12271": {"epss_score": 0.00282, "epss_percentile": 0.51265}, "CVE-2017-12272": {"epss_score": 0.00232, "epss_percentile": 0.45882}, "CVE-2017-12273": {"epss_score": 0.00252, "epss_percentile": 0.48363}, "CVE-2017-12274": {"epss_score": 0.00708, "epss_percentile": 0.71683}, "CVE-2017-12275": {"epss_score": 0.00256, "epss_percentile": 0.48826}, "CVE-2017-12276": {"epss_score": 0.00213, "epss_percentile": 0.43836}, "CVE-2017-12277": {"epss_score": 0.00549, "epss_percentile": 0.67318}, "CVE-2017-12278": {"epss_score": 0.00807, "epss_percentile": 0.73669}, "CVE-2017-12279": {"epss_score": 0.00115, "epss_percentile": 0.31012}, "CVE-2017-12280": {"epss_score": 0.00642, "epss_percentile": 0.70024}, "CVE-2017-12281": {"epss_score": 0.00333, "epss_percentile": 0.55667}, "CVE-2017-12282": {"epss_score": 0.00218, "epss_percentile": 0.44435}, "CVE-2017-12283": {"epss_score": 0.00398, "epss_percentile": 0.60066}, "CVE-2017-12284": {"epss_score": 0.00078, "epss_percentile": 0.23669}, "CVE-2017-12285": {"epss_score": 0.7745, "epss_percentile": 0.98938}, "CVE-2017-12286": {"epss_score": 0.00078, "epss_percentile": 0.23669}, "CVE-2017-12287": {"epss_score": 0.00497, "epss_percentile": 0.65191}, "CVE-2017-12288": {"epss_score": 0.00235, "epss_percentile": 0.46328}, "CVE-2017-12289": {"epss_score": 0.00081, "epss_percentile": 0.24272}, "CVE-2017-12290": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2017-12291": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2017-12292": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2017-12293": {"epss_score": 0.01646, "epss_percentile": 0.81536}, "CVE-2017-12294": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-12295": {"epss_score": 0.00361, "epss_percentile": 0.57706}, "CVE-2017-12296": {"epss_score": 0.00232, "epss_percentile": 0.45882}, "CVE-2017-12297": {"epss_score": 0.00237, "epss_percentile": 0.46689}, "CVE-2017-12298": {"epss_score": 0.00232, "epss_percentile": 0.45882}, "CVE-2017-12299": {"epss_score": 0.00227, "epss_percentile": 0.4537}, "CVE-2017-12300": {"epss_score": 0.00227, "epss_percentile": 0.4537}, "CVE-2017-12301": {"epss_score": 0.00118, "epss_percentile": 0.31443}, "CVE-2017-12302": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2017-12303": {"epss_score": 0.00402, "epss_percentile": 0.60305}, "CVE-2017-12304": {"epss_score": 0.0017, "epss_percentile": 0.38765}, "CVE-2017-12305": {"epss_score": 0.00332, "epss_percentile": 0.55584}, "CVE-2017-12306": {"epss_score": 0.00028, "epss_percentile": 0.07339}, "CVE-2017-12307": {"epss_score": 0.00184, "epss_percentile": 0.40459}, "CVE-2017-12308": {"epss_score": 0.00242, "epss_percentile": 0.47353}, "CVE-2017-12309": {"epss_score": 0.00976, "epss_percentile": 0.76212}, "CVE-2017-12310": {"epss_score": 0.00273, "epss_percentile": 0.50445}, "CVE-2017-12311": {"epss_score": 0.0082, "epss_percentile": 0.7389}, "CVE-2017-12312": {"epss_score": 0.00063, "epss_percentile": 0.19918}, "CVE-2017-12313": {"epss_score": 0.00063, "epss_percentile": 0.19918}, "CVE-2017-12314": {"epss_score": 0.0007, "epss_percentile": 0.21815}, "CVE-2017-12315": {"epss_score": 0.00064, "epss_percentile": 0.20423}, "CVE-2017-12316": {"epss_score": 0.0119, "epss_percentile": 0.7838}, "CVE-2017-12317": {"epss_score": 0.00049, "epss_percentile": 0.15545}, "CVE-2017-12318": {"epss_score": 0.00662, "epss_percentile": 0.70608}, "CVE-2017-12319": {"epss_score": 0.00937, "epss_percentile": 0.75697}, "CVE-2017-12320": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2017-12321": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2017-12322": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2017-12323": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2017-12328": {"epss_score": 0.00552, "epss_percentile": 0.6738}, "CVE-2017-12329": {"epss_score": 0.00377, "epss_percentile": 0.58744}, "CVE-2017-12330": {"epss_score": 0.00377, "epss_percentile": 0.58744}, "CVE-2017-12331": {"epss_score": 0.00035, "epss_percentile": 0.0982}, "CVE-2017-12332": {"epss_score": 0.00084, "epss_percentile": 0.25017}, "CVE-2017-12333": {"epss_score": 0.00033, "epss_percentile": 0.09303}, "CVE-2017-12334": {"epss_score": 0.00106, "epss_percentile": 0.29471}, "CVE-2017-12335": {"epss_score": 0.00275, "epss_percentile": 0.50633}, "CVE-2017-12336": {"epss_score": 0.00048, "epss_percentile": 0.15252}, "CVE-2017-12337": {"epss_score": 0.13192, "epss_percentile": 0.93896}, "CVE-2017-12338": {"epss_score": 0.00077, "epss_percentile": 0.23377}, "CVE-2017-12339": {"epss_score": 0.00138, "epss_percentile": 0.344}, "CVE-2017-12340": {"epss_score": 0.00049, "epss_percentile": 0.15428}, "CVE-2017-12341": {"epss_score": 0.00258, "epss_percentile": 0.48981}, "CVE-2017-12342": {"epss_score": 0.0007, "epss_percentile": 0.21712}, "CVE-2017-12343": {"epss_score": 0.00911, "epss_percentile": 0.75327}, "CVE-2017-12344": {"epss_score": 0.00222, "epss_percentile": 0.44774}, "CVE-2017-12345": {"epss_score": 0.0031, "epss_percentile": 0.53732}, "CVE-2017-12346": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2017-12347": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2017-12348": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-12349": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-12350": {"epss_score": 0.00049, "epss_percentile": 0.15647}, "CVE-2017-12351": {"epss_score": 0.00066, "epss_percentile": 0.20801}, "CVE-2017-12352": {"epss_score": 0.00096, "epss_percentile": 0.27308}, "CVE-2017-12353": {"epss_score": 0.00383, "epss_percentile": 0.59116}, "CVE-2017-12354": {"epss_score": 0.00501, "epss_percentile": 0.65364}, "CVE-2017-12355": {"epss_score": 0.00552, "epss_percentile": 0.6738}, "CVE-2017-12356": {"epss_score": 0.0017, "epss_percentile": 0.38765}, "CVE-2017-12357": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-12358": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2017-12359": {"epss_score": 0.01027, "epss_percentile": 0.76808}, "CVE-2017-12360": {"epss_score": 0.00296, "epss_percentile": 0.5254}, "CVE-2017-12361": {"epss_score": 0.00137, "epss_percentile": 0.34322}, "CVE-2017-12362": {"epss_score": 0.00892, "epss_percentile": 0.75056}, "CVE-2017-12363": {"epss_score": 0.00876, "epss_percentile": 0.74789}, "CVE-2017-12364": {"epss_score": 0.00325, "epss_percentile": 0.54977}, "CVE-2017-12365": {"epss_score": 0.00253, "epss_percentile": 0.48487}, "CVE-2017-12366": {"epss_score": 0.00232, "epss_percentile": 0.45882}, "CVE-2017-12367": {"epss_score": 0.01213, "epss_percentile": 0.78568}, "CVE-2017-12368": {"epss_score": 0.02154, "epss_percentile": 0.83799}, "CVE-2017-12369": {"epss_score": 0.02154, "epss_percentile": 0.83799}, "CVE-2017-12370": {"epss_score": 0.02154, "epss_percentile": 0.83799}, "CVE-2017-12371": {"epss_score": 0.02154, "epss_percentile": 0.83799}, "CVE-2017-12372": {"epss_score": 0.02154, "epss_percentile": 0.83799}, "CVE-2017-12373": {"epss_score": 0.61618, "epss_percentile": 0.98255}, "CVE-2017-12374": {"epss_score": 0.04838, "epss_percentile": 0.89195}, "CVE-2017-12375": {"epss_score": 0.06456, "epss_percentile": 0.90768}, "CVE-2017-12376": {"epss_score": 0.099, "epss_percentile": 0.92763}, "CVE-2017-12377": {"epss_score": 0.11418, "epss_percentile": 0.93342}, "CVE-2017-12378": {"epss_score": 0.05096, "epss_percentile": 0.89492}, "CVE-2017-12379": {"epss_score": 0.08048, "epss_percentile": 0.91852}, "CVE-2017-12380": {"epss_score": 0.08975, "epss_percentile": 0.92345}, "CVE-2017-12410": {"epss_score": 0.0004, "epss_percentile": 0.11875}, "CVE-2017-12412": {"epss_score": 0.00251, "epss_percentile": 0.48323}, "CVE-2017-12413": {"epss_score": 0.00319, "epss_percentile": 0.54549}, "CVE-2017-12414": {"epss_score": 0.0051, "epss_percentile": 0.65763}, "CVE-2017-12415": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2017-12416": {"epss_score": 0.0059, "epss_percentile": 0.68553}, "CVE-2017-12418": {"epss_score": 0.00181, "epss_percentile": 0.40102}, "CVE-2017-12419": {"epss_score": 0.01076, "epss_percentile": 0.77322}, "CVE-2017-12420": {"epss_score": 0.01949, "epss_percentile": 0.8301}, "CVE-2017-12421": {"epss_score": 0.01733, "epss_percentile": 0.81999}, "CVE-2017-12422": {"epss_score": 0.00451, "epss_percentile": 0.63142}, "CVE-2017-12423": {"epss_score": 0.00224, "epss_percentile": 0.45067}, "CVE-2017-12424": {"epss_score": 0.00637, "epss_percentile": 0.69885}, "CVE-2017-12425": {"epss_score": 0.01046, "epss_percentile": 0.77025}, "CVE-2017-12426": {"epss_score": 0.01432, "epss_percentile": 0.80249}, "CVE-2017-12427": {"epss_score": 0.00612, "epss_percentile": 0.69211}, "CVE-2017-12428": {"epss_score": 0.00426, "epss_percentile": 0.61752}, "CVE-2017-12429": {"epss_score": 0.00661, "epss_percentile": 0.70577}, "CVE-2017-12430": {"epss_score": 0.00886, "epss_percentile": 0.74948}, "CVE-2017-12431": {"epss_score": 0.00297, "epss_percentile": 0.52759}, "CVE-2017-12432": {"epss_score": 0.00706, "epss_percentile": 0.71637}, "CVE-2017-12433": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2017-12434": {"epss_score": 0.0038, "epss_percentile": 0.58913}, "CVE-2017-12435": {"epss_score": 0.00886, "epss_percentile": 0.74948}, "CVE-2017-12439": {"epss_score": 0.00173, "epss_percentile": 0.39076}, "CVE-2017-12440": {"epss_score": 0.00859, "epss_percentile": 0.74511}, "CVE-2017-12441": {"epss_score": 0.00473, "epss_percentile": 0.6411}, "CVE-2017-12442": {"epss_score": 0.00473, "epss_percentile": 0.6411}, "CVE-2017-12443": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2017-12444": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2017-12445": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2017-12447": {"epss_score": 0.00326, "epss_percentile": 0.55066}, "CVE-2017-12448": {"epss_score": 0.00628, "epss_percentile": 0.69662}, "CVE-2017-12449": {"epss_score": 0.00332, "epss_percentile": 0.5559}, "CVE-2017-12450": {"epss_score": 0.00543, "epss_percentile": 0.67094}, "CVE-2017-12451": {"epss_score": 0.00347, "epss_percentile": 0.56779}, "CVE-2017-12452": {"epss_score": 0.00305, "epss_percentile": 0.53388}, "CVE-2017-12453": {"epss_score": 0.00347, "epss_percentile": 0.56779}, "CVE-2017-12454": {"epss_score": 0.00347, "epss_percentile": 0.56779}, "CVE-2017-12455": {"epss_score": 0.00325, "epss_percentile": 0.55023}, "CVE-2017-12456": {"epss_score": 0.00347, "epss_percentile": 0.56779}, "CVE-2017-12457": {"epss_score": 0.00311, "epss_percentile": 0.53867}, "CVE-2017-12458": {"epss_score": 0.00347, "epss_percentile": 0.56779}, "CVE-2017-12459": {"epss_score": 0.00543, "epss_percentile": 0.67094}, "CVE-2017-12460": {"epss_score": 0.00317, "epss_percentile": 0.54386}, "CVE-2017-12463": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-12464": {"epss_score": 0.00435, "epss_percentile": 0.62332}, "CVE-2017-12465": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2017-12466": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2017-12467": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-12468": {"epss_score": 0.00436, "epss_percentile": 0.62455}, "CVE-2017-12469": {"epss_score": 0.00436, "epss_percentile": 0.62455}, "CVE-2017-12470": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2017-12471": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2017-12472": {"epss_score": 0.0034, "epss_percentile": 0.5628}, "CVE-2017-12473": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2017-12474": {"epss_score": 0.00256, "epss_percentile": 0.48801}, "CVE-2017-12475": {"epss_score": 0.00256, "epss_percentile": 0.48801}, "CVE-2017-12476": {"epss_score": 0.00256, "epss_percentile": 0.48801}, "CVE-2017-12477": {"epss_score": 0.76006, "epss_percentile": 0.98873}, "CVE-2017-12478": {"epss_score": 0.63609, "epss_percentile": 0.98341}, "CVE-2017-12479": {"epss_score": 0.13453, "epss_percentile": 0.9397}, "CVE-2017-12480": {"epss_score": 0.00193, "epss_percentile": 0.41494}, "CVE-2017-12481": {"epss_score": 0.00295, "epss_percentile": 0.52496}, "CVE-2017-12482": {"epss_score": 0.00295, "epss_percentile": 0.52496}, "CVE-2017-12487": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12488": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12489": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12490": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12491": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12492": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12493": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12494": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12495": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12496": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12497": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12498": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12499": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12500": {"epss_score": 0.4127, "epss_percentile": 0.97263}, "CVE-2017-12501": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12502": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12503": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12504": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12505": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12506": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12507": {"epss_score": 0.02496, "epss_percentile": 0.84907}, "CVE-2017-12508": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12509": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12510": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12511": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12512": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12513": {"epss_score": 0.03286, "epss_percentile": 0.86824}, "CVE-2017-12514": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12515": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12516": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12517": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12518": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12519": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12520": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12521": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12522": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12523": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12524": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12525": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12526": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12527": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12528": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12529": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12530": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12531": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12532": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12533": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12534": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12535": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12536": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12537": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12538": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12539": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12540": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12541": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2017-12542": {"epss_score": 0.94254, "epss_percentile": 0.99927}, "CVE-2017-12543": {"epss_score": 0.00355, "epss_percentile": 0.57289}, "CVE-2017-12544": {"epss_score": 0.72051, "epss_percentile": 0.98693}, "CVE-2017-12545": {"epss_score": 0.1445, "epss_percentile": 0.94214}, "CVE-2017-12546": {"epss_score": 0.00102, "epss_percentile": 0.28772}, "CVE-2017-12547": {"epss_score": 0.0003, "epss_percentile": 0.08307}, "CVE-2017-12548": {"epss_score": 0.0003, "epss_percentile": 0.08307}, "CVE-2017-12549": {"epss_score": 0.00117, "epss_percentile": 0.31279}, "CVE-2017-12550": {"epss_score": 0.00059, "epss_percentile": 0.18657}, "CVE-2017-12551": {"epss_score": 0.0006, "epss_percentile": 0.19112}, "CVE-2017-12552": {"epss_score": 0.0006, "epss_percentile": 0.19112}, "CVE-2017-12553": {"epss_score": 0.00097, "epss_percentile": 0.27537}, "CVE-2017-12554": {"epss_score": 0.05431, "epss_percentile": 0.89877}, "CVE-2017-12555": {"epss_score": 0.00574, "epss_percentile": 0.68092}, "CVE-2017-12556": {"epss_score": 0.53168, "epss_percentile": 0.97859}, "CVE-2017-12557": {"epss_score": 0.85863, "epss_percentile": 0.99353}, "CVE-2017-12558": {"epss_score": 0.53168, "epss_percentile": 0.97859}, "CVE-2017-12559": {"epss_score": 0.00816, "epss_percentile": 0.73829}, "CVE-2017-12560": {"epss_score": 0.00816, "epss_percentile": 0.73829}, "CVE-2017-12561": {"epss_score": 0.38733, "epss_percentile": 0.97118}, "CVE-2017-12562": {"epss_score": 0.02708, "epss_percentile": 0.85478}, "CVE-2017-12563": {"epss_score": 0.00445, "epss_percentile": 0.62882}, "CVE-2017-12564": {"epss_score": 0.00223, "epss_percentile": 0.4489}, "CVE-2017-12565": {"epss_score": 0.00223, "epss_percentile": 0.4489}, "CVE-2017-12566": {"epss_score": 0.00343, "epss_percentile": 0.56468}, "CVE-2017-12567": {"epss_score": 0.0033, "epss_percentile": 0.55485}, "CVE-2017-12568": {"epss_score": 0.00535, "epss_percentile": 0.66841}, "CVE-2017-12572": {"epss_score": 0.0026, "epss_percentile": 0.49199}, "CVE-2017-12573": {"epss_score": 0.00806, "epss_percentile": 0.73664}, "CVE-2017-12574": {"epss_score": 0.00421, "epss_percentile": 0.61513}, "CVE-2017-12575": {"epss_score": 0.00676, "epss_percentile": 0.70926}, "CVE-2017-12576": {"epss_score": 0.00537, "epss_percentile": 0.66925}, "CVE-2017-12577": {"epss_score": 0.00393, "epss_percentile": 0.59724}, "CVE-2017-12579": {"epss_score": 0.01108, "epss_percentile": 0.77631}, "CVE-2017-12580": {"epss_score": 0.00049, "epss_percentile": 0.15329}, "CVE-2017-12581": {"epss_score": 0.01854, "epss_percentile": 0.82556}, "CVE-2017-12582": {"epss_score": 0.00345, "epss_percentile": 0.56559}, "CVE-2017-12583": {"epss_score": 0.01334, "epss_percentile": 0.79541}, "CVE-2017-12584": {"epss_score": 0.00177, "epss_percentile": 0.39516}, "CVE-2017-12585": {"epss_score": 0.00514, "epss_percentile": 0.65941}, "CVE-2017-12586": {"epss_score": 0.00327, "epss_percentile": 0.55103}, "CVE-2017-12587": {"epss_score": 0.00168, "epss_percentile": 0.38519}, "CVE-2017-12588": {"epss_score": 0.00259, "epss_percentile": 0.49042}, "CVE-2017-12589": {"epss_score": 0.00163, "epss_percentile": 0.37766}, "CVE-2017-12590": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-12591": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-12592": {"epss_score": 0.00381, "epss_percentile": 0.58996}, "CVE-2017-12593": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2017-12595": {"epss_score": 0.00509, "epss_percentile": 0.6575}, "CVE-2017-12596": {"epss_score": 0.00552, "epss_percentile": 0.67398}, "CVE-2017-12597": {"epss_score": 0.00386, "epss_percentile": 0.59285}, "CVE-2017-12598": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2017-12599": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2017-12600": {"epss_score": 0.0077, "epss_percentile": 0.72997}, "CVE-2017-12601": {"epss_score": 0.004, "epss_percentile": 0.60163}, "CVE-2017-12602": {"epss_score": 0.0077, "epss_percentile": 0.72997}, "CVE-2017-12603": {"epss_score": 0.00386, "epss_percentile": 0.59285}, "CVE-2017-12604": {"epss_score": 0.00386, "epss_percentile": 0.59285}, "CVE-2017-12605": {"epss_score": 0.00386, "epss_percentile": 0.59285}, "CVE-2017-12606": {"epss_score": 0.00468, "epss_percentile": 0.63908}, "CVE-2017-12607": {"epss_score": 0.00745, "epss_percentile": 0.72526}, "CVE-2017-12608": {"epss_score": 0.01012, "epss_percentile": 0.76618}, "CVE-2017-12610": {"epss_score": 0.0029, "epss_percentile": 0.52115}, "CVE-2017-12611": {"epss_score": 0.94228, "epss_percentile": 0.9992}, "CVE-2017-12612": {"epss_score": 0.00155, "epss_percentile": 0.3681}, "CVE-2017-12613": {"epss_score": 0.00326, "epss_percentile": 0.5508}, "CVE-2017-12614": {"epss_score": 0.02255, "epss_percentile": 0.84168}, "CVE-2017-12615": {"epss_score": 0.94277, "epss_percentile": 0.99932}, "CVE-2017-12616": {"epss_score": 0.91499, "epss_percentile": 0.99648}, "CVE-2017-12617": {"epss_score": 0.94356, "epss_percentile": 0.99958}, "CVE-2017-12618": {"epss_score": 0.00164, "epss_percentile": 0.37966}, "CVE-2017-12619": {"epss_score": 0.00986, "epss_percentile": 0.76331}, "CVE-2017-12620": {"epss_score": 0.01018, "epss_percentile": 0.76706}, "CVE-2017-12621": {"epss_score": 0.00342, "epss_percentile": 0.56372}, "CVE-2017-12622": {"epss_score": 0.00107, "epss_percentile": 0.29626}, "CVE-2017-12623": {"epss_score": 0.00506, "epss_percentile": 0.65616}, "CVE-2017-12624": {"epss_score": 0.05408, "epss_percentile": 0.89842}, "CVE-2017-12625": {"epss_score": 0.00468, "epss_percentile": 0.6387}, "CVE-2017-12626": {"epss_score": 0.04402, "epss_percentile": 0.88646}, "CVE-2017-12627": {"epss_score": 0.05316, "epss_percentile": 0.89723}, "CVE-2017-12628": {"epss_score": 0.00142, "epss_percentile": 0.35038}, "CVE-2017-12629": {"epss_score": 0.93776, "epss_percentile": 0.99844}, "CVE-2017-12630": {"epss_score": 0.0072, "epss_percentile": 0.71959}, "CVE-2017-12631": {"epss_score": 0.01374, "epss_percentile": 0.79826}, "CVE-2017-12632": {"epss_score": 0.00414, "epss_percentile": 0.61092}, "CVE-2017-12633": {"epss_score": 0.03414, "epss_percentile": 0.8709}, "CVE-2017-12634": {"epss_score": 0.04565, "epss_percentile": 0.88856}, "CVE-2017-12635": {"epss_score": 0.9419, "epss_percentile": 0.99915}, "CVE-2017-12636": {"epss_score": 0.93141, "epss_percentile": 0.99779}, "CVE-2017-12637": {"epss_score": 0.93219, "epss_percentile": 0.99785}, "CVE-2017-12638": {"epss_score": 0.00191, "epss_percentile": 0.41175}, "CVE-2017-12639": {"epss_score": 0.00191, "epss_percentile": 0.41175}, "CVE-2017-12640": {"epss_score": 0.00923, "epss_percentile": 0.75508}, "CVE-2017-12641": {"epss_score": 0.0041, "epss_percentile": 0.60797}, "CVE-2017-12642": {"epss_score": 0.00346, "epss_percentile": 0.56619}, "CVE-2017-12643": {"epss_score": 0.01466, "epss_percentile": 0.80461}, "CVE-2017-12644": {"epss_score": 0.0095, "epss_percentile": 0.75858}, "CVE-2017-12645": {"epss_score": 0.00244, "epss_percentile": 0.47525}, "CVE-2017-12646": {"epss_score": 0.00247, "epss_percentile": 0.47854}, "CVE-2017-12647": {"epss_score": 0.00247, "epss_percentile": 0.47854}, "CVE-2017-12648": {"epss_score": 0.00247, "epss_percentile": 0.47854}, "CVE-2017-12649": {"epss_score": 0.00247, "epss_percentile": 0.47854}, "CVE-2017-12650": {"epss_score": 0.00595, "epss_percentile": 0.68696}, "CVE-2017-12651": {"epss_score": 0.00122, "epss_percentile": 0.32141}, "CVE-2017-12652": {"epss_score": 0.00621, "epss_percentile": 0.69483}, "CVE-2017-12653": {"epss_score": 0.0224, "epss_percentile": 0.84111}, "CVE-2017-12654": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2017-12655": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-12662": {"epss_score": 0.00383, "epss_percentile": 0.5912}, "CVE-2017-12663": {"epss_score": 0.00357, "epss_percentile": 0.57399}, "CVE-2017-12664": {"epss_score": 0.00357, "epss_percentile": 0.57399}, "CVE-2017-12665": {"epss_score": 0.00357, "epss_percentile": 0.57399}, "CVE-2017-12666": {"epss_score": 0.00383, "epss_percentile": 0.5912}, "CVE-2017-12667": {"epss_score": 0.0031, "epss_percentile": 0.53769}, "CVE-2017-12668": {"epss_score": 0.0031, "epss_percentile": 0.53769}, "CVE-2017-12669": {"epss_score": 0.00311, "epss_percentile": 0.53933}, "CVE-2017-12670": {"epss_score": 0.00433, "epss_percentile": 0.62227}, "CVE-2017-12671": {"epss_score": 0.00223, "epss_percentile": 0.4489}, "CVE-2017-12672": {"epss_score": 0.00223, "epss_percentile": 0.4489}, "CVE-2017-12673": {"epss_score": 0.00223, "epss_percentile": 0.4489}, "CVE-2017-12674": {"epss_score": 0.00256, "epss_percentile": 0.48787}, "CVE-2017-12675": {"epss_score": 0.00223, "epss_percentile": 0.4489}, "CVE-2017-12676": {"epss_score": 0.00223, "epss_percentile": 0.4489}, "CVE-2017-12677": {"epss_score": 0.00233, "epss_percentile": 0.46044}, "CVE-2017-12678": {"epss_score": 0.0069, "epss_percentile": 0.71236}, "CVE-2017-12679": {"epss_score": 0.00293, "epss_percentile": 0.52349}, "CVE-2017-12680": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-12691": {"epss_score": 0.00818, "epss_percentile": 0.73858}, "CVE-2017-12692": {"epss_score": 0.00823, "epss_percentile": 0.73926}, "CVE-2017-12693": {"epss_score": 0.00814, "epss_percentile": 0.73772}, "CVE-2017-12694": {"epss_score": 0.01167, "epss_percentile": 0.78185}, "CVE-2017-12695": {"epss_score": 0.00221, "epss_percentile": 0.44695}, "CVE-2017-12697": {"epss_score": 0.00186, "epss_percentile": 0.40595}, "CVE-2017-12698": {"epss_score": 0.06851, "epss_percentile": 0.91073}, "CVE-2017-12699": {"epss_score": 0.00065, "epss_percentile": 0.20521}, "CVE-2017-12701": {"epss_score": 0.00533, "epss_percentile": 0.66765}, "CVE-2017-12702": {"epss_score": 0.00433, "epss_percentile": 0.62182}, "CVE-2017-12703": {"epss_score": 0.0012, "epss_percentile": 0.31798}, "CVE-2017-12704": {"epss_score": 0.00822, "epss_percentile": 0.73915}, "CVE-2017-12705": {"epss_score": 0.00127, "epss_percentile": 0.32794}, "CVE-2017-12706": {"epss_score": 0.0136, "epss_percentile": 0.7975}, "CVE-2017-12707": {"epss_score": 0.00438, "epss_percentile": 0.62554}, "CVE-2017-12708": {"epss_score": 0.00741, "epss_percentile": 0.72444}, "CVE-2017-12709": {"epss_score": 0.00094, "epss_percentile": 0.27037}, "CVE-2017-12710": {"epss_score": 0.00495, "epss_percentile": 0.65114}, "CVE-2017-12711": {"epss_score": 0.0008, "epss_percentile": 0.24203}, "CVE-2017-12712": {"epss_score": 0.00699, "epss_percentile": 0.71451}, "CVE-2017-12713": {"epss_score": 0.0008, "epss_percentile": 0.24203}, "CVE-2017-12714": {"epss_score": 0.00215, "epss_percentile": 0.44121}, "CVE-2017-12716": {"epss_score": 0.00036, "epss_percentile": 0.10324}, "CVE-2017-12717": {"epss_score": 0.00674, "epss_percentile": 0.7085}, "CVE-2017-12718": {"epss_score": 0.25769, "epss_percentile": 0.96067}, "CVE-2017-12719": {"epss_score": 0.01871, "epss_percentile": 0.82633}, "CVE-2017-12720": {"epss_score": 0.01234, "epss_percentile": 0.78753}, "CVE-2017-12721": {"epss_score": 0.00126, "epss_percentile": 0.327}, "CVE-2017-12722": {"epss_score": 0.00849, "epss_percentile": 0.74376}, "CVE-2017-12723": {"epss_score": 0.00175, "epss_percentile": 0.39284}, "CVE-2017-12724": {"epss_score": 0.00459, "epss_percentile": 0.63469}, "CVE-2017-12725": {"epss_score": 0.00178, "epss_percentile": 0.3964}, "CVE-2017-12726": {"epss_score": 0.00222, "epss_percentile": 0.44785}, "CVE-2017-12728": {"epss_score": 0.0005, "epss_percentile": 0.15825}, "CVE-2017-12729": {"epss_score": 0.00204, "epss_percentile": 0.42604}, "CVE-2017-12730": {"epss_score": 0.00106, "epss_percentile": 0.2954}, "CVE-2017-12731": {"epss_score": 0.00281, "epss_percentile": 0.51149}, "CVE-2017-12732": {"epss_score": 0.00248, "epss_percentile": 0.47933}, "CVE-2017-12733": {"epss_score": 0.0125, "epss_percentile": 0.7889}, "CVE-2017-12734": {"epss_score": 0.00379, "epss_percentile": 0.58878}, "CVE-2017-12735": {"epss_score": 0.0024, "epss_percentile": 0.47221}, "CVE-2017-12736": {"epss_score": 0.00149, "epss_percentile": 0.35968}, "CVE-2017-12737": {"epss_score": 0.00298, "epss_percentile": 0.52797}, "CVE-2017-12738": {"epss_score": 0.00219, "epss_percentile": 0.44535}, "CVE-2017-12739": {"epss_score": 0.0314, "epss_percentile": 0.86486}, "CVE-2017-12740": {"epss_score": 0.00138, "epss_percentile": 0.34529}, "CVE-2017-12741": {"epss_score": 0.05261, "epss_percentile": 0.89669}, "CVE-2017-12754": {"epss_score": 0.10008, "epss_percentile": 0.92814}, "CVE-2017-12756": {"epss_score": 0.00509, "epss_percentile": 0.65726}, "CVE-2017-12757": {"epss_score": 0.00842, "epss_percentile": 0.74245}, "CVE-2017-12758": {"epss_score": 0.00631, "epss_percentile": 0.6973}, "CVE-2017-12759": {"epss_score": 0.00842, "epss_percentile": 0.74245}, "CVE-2017-12760": {"epss_score": 0.00356, "epss_percentile": 0.57335}, "CVE-2017-12761": {"epss_score": 0.0166, "epss_percentile": 0.81617}, "CVE-2017-12762": {"epss_score": 0.01111, "epss_percentile": 0.77665}, "CVE-2017-12763": {"epss_score": 0.05074, "epss_percentile": 0.89468}, "CVE-2017-12774": {"epss_score": 0.00904, "epss_percentile": 0.75222}, "CVE-2017-12775": {"epss_score": 0.00292, "epss_percentile": 0.52261}, "CVE-2017-12776": {"epss_score": 0.00487, "epss_percentile": 0.64817}, "CVE-2017-12777": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-12778": {"epss_score": 0.00094, "epss_percentile": 0.26769}, "CVE-2017-12779": {"epss_score": 0.00464, "epss_percentile": 0.63714}, "CVE-2017-12780": {"epss_score": 0.00676, "epss_percentile": 0.70931}, "CVE-2017-12781": {"epss_score": 0.00678, "epss_percentile": 0.70986}, "CVE-2017-12782": {"epss_score": 0.00624, "epss_percentile": 0.69557}, "CVE-2017-12783": {"epss_score": 0.00624, "epss_percentile": 0.69557}, "CVE-2017-12784": {"epss_score": 0.02123, "epss_percentile": 0.83684}, "CVE-2017-12785": {"epss_score": 0.11676, "epss_percentile": 0.93443}, "CVE-2017-12786": {"epss_score": 0.35137, "epss_percentile": 0.9689}, "CVE-2017-12787": {"epss_score": 0.34179, "epss_percentile": 0.96829}, "CVE-2017-12788": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2017-12789": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2017-12790": {"epss_score": 0.00157, "epss_percentile": 0.37029}, "CVE-2017-12791": {"epss_score": 0.01383, "epss_percentile": 0.79892}, "CVE-2017-12792": {"epss_score": 0.01156, "epss_percentile": 0.78083}, "CVE-2017-12794": {"epss_score": 0.18768, "epss_percentile": 0.95066}, "CVE-2017-12795": {"epss_score": 0.00868, "epss_percentile": 0.74682}, "CVE-2017-12796": {"epss_score": 0.0573, "epss_percentile": 0.90161}, "CVE-2017-12797": {"epss_score": 0.00474, "epss_percentile": 0.64169}, "CVE-2017-12798": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-12799": {"epss_score": 0.00285, "epss_percentile": 0.51655}, "CVE-2017-12800": {"epss_score": 0.00678, "epss_percentile": 0.70986}, "CVE-2017-12801": {"epss_score": 0.00676, "epss_percentile": 0.70931}, "CVE-2017-12802": {"epss_score": 0.00676, "epss_percentile": 0.70931}, "CVE-2017-12803": {"epss_score": 0.00539, "epss_percentile": 0.66962}, "CVE-2017-12804": {"epss_score": 0.00421, "epss_percentile": 0.61486}, "CVE-2017-12805": {"epss_score": 0.00191, "epss_percentile": 0.41172}, "CVE-2017-12806": {"epss_score": 0.00191, "epss_percentile": 0.41172}, "CVE-2017-12809": {"epss_score": 0.0009, "epss_percentile": 0.26037}, "CVE-2017-12810": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-12811": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-12812": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-12813": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-12814": {"epss_score": 0.06061, "epss_percentile": 0.90443}, "CVE-2017-12815": {"epss_score": 0.00493, "epss_percentile": 0.65065}, "CVE-2017-12816": {"epss_score": 0.00361, "epss_percentile": 0.57726}, "CVE-2017-12817": {"epss_score": 0.00142, "epss_percentile": 0.35052}, "CVE-2017-12818": {"epss_score": 0.00954, "epss_percentile": 0.75901}, "CVE-2017-12819": {"epss_score": 0.00389, "epss_percentile": 0.59468}, "CVE-2017-12820": {"epss_score": 0.00875, "epss_percentile": 0.74777}, "CVE-2017-12821": {"epss_score": 0.02998, "epss_percentile": 0.86158}, "CVE-2017-12822": {"epss_score": 0.00337, "epss_percentile": 0.56046}, "CVE-2017-12823": {"epss_score": 0.00151, "epss_percentile": 0.36185}, "CVE-2017-12824": {"epss_score": 0.00728, "epss_percentile": 0.72103}, "CVE-2017-12836": {"epss_score": 0.04023, "epss_percentile": 0.88136}, "CVE-2017-12837": {"epss_score": 0.02585, "epss_percentile": 0.85163}, "CVE-2017-12838": {"epss_score": 0.00123, "epss_percentile": 0.32333}, "CVE-2017-12839": {"epss_score": 0.01139, "epss_percentile": 0.77939}, "CVE-2017-12840": {"epss_score": 0.00062, "epss_percentile": 0.19738}, "CVE-2017-12842": {"epss_score": 0.01482, "epss_percentile": 0.80581}, "CVE-2017-12843": {"epss_score": 0.00227, "epss_percentile": 0.45452}, "CVE-2017-12844": {"epss_score": 0.00176, "epss_percentile": 0.39402}, "CVE-2017-12847": {"epss_score": 0.00114, "epss_percentile": 0.30843}, "CVE-2017-12849": {"epss_score": 0.0023, "epss_percentile": 0.45762}, "CVE-2017-12850": {"epss_score": 0.00466, "epss_percentile": 0.63809}, "CVE-2017-12851": {"epss_score": 0.00466, "epss_percentile": 0.63809}, "CVE-2017-12852": {"epss_score": 0.01125, "epss_percentile": 0.77805}, "CVE-2017-12853": {"epss_score": 0.0025, "epss_percentile": 0.48098}, "CVE-2017-12855": {"epss_score": 0.00094, "epss_percentile": 0.26773}, "CVE-2017-12856": {"epss_score": 0.00315, "epss_percentile": 0.54184}, "CVE-2017-12857": {"epss_score": 0.00404, "epss_percentile": 0.60411}, "CVE-2017-12858": {"epss_score": 0.00738, "epss_percentile": 0.72346}, "CVE-2017-12859": {"epss_score": 0.00585, "epss_percentile": 0.68403}, "CVE-2017-12860": {"epss_score": 0.03461, "epss_percentile": 0.87181}, "CVE-2017-12861": {"epss_score": 0.03717, "epss_percentile": 0.87615}, "CVE-2017-12862": {"epss_score": 0.01977, "epss_percentile": 0.83125}, "CVE-2017-12863": {"epss_score": 0.01588, "epss_percentile": 0.81188}, "CVE-2017-12864": {"epss_score": 0.01588, "epss_percentile": 0.81188}, "CVE-2017-12865": {"epss_score": 0.03761, "epss_percentile": 0.87688}, "CVE-2017-12867": {"epss_score": 0.00241, "epss_percentile": 0.47286}, "CVE-2017-12868": {"epss_score": 0.00764, "epss_percentile": 0.72904}, "CVE-2017-12869": {"epss_score": 0.00418, "epss_percentile": 0.61295}, "CVE-2017-12870": {"epss_score": 0.0026, "epss_percentile": 0.49189}, "CVE-2017-12871": {"epss_score": 0.0008, "epss_percentile": 0.24137}, "CVE-2017-12872": {"epss_score": 0.00404, "epss_percentile": 0.60437}, "CVE-2017-12873": {"epss_score": 0.00725, "epss_percentile": 0.7206}, "CVE-2017-12874": {"epss_score": 0.00282, "epss_percentile": 0.51205}, "CVE-2017-12875": {"epss_score": 0.00506, "epss_percentile": 0.65641}, "CVE-2017-12876": {"epss_score": 0.00476, "epss_percentile": 0.64293}, "CVE-2017-12877": {"epss_score": 0.0119, "epss_percentile": 0.78392}, "CVE-2017-12879": {"epss_score": 0.00278, "epss_percentile": 0.50857}, "CVE-2017-12881": {"epss_score": 0.00162, "epss_percentile": 0.37631}, "CVE-2017-12882": {"epss_score": 0.00158, "epss_percentile": 0.37235}, "CVE-2017-12883": {"epss_score": 0.04509, "epss_percentile": 0.88779}, "CVE-2017-12884": {"epss_score": 0.00386, "epss_percentile": 0.59253}, "CVE-2017-12885": {"epss_score": 0.00378, "epss_percentile": 0.58796}, "CVE-2017-12892": {"epss_score": 0.03479, "epss_percentile": 0.87216}, "CVE-2017-12893": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12894": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12895": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12896": {"epss_score": 0.0206, "epss_percentile": 0.83441}, "CVE-2017-12897": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12898": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12899": {"epss_score": 0.0206, "epss_percentile": 0.83441}, "CVE-2017-12900": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12901": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12902": {"epss_score": 0.0206, "epss_percentile": 0.83441}, "CVE-2017-12904": {"epss_score": 0.03571, "epss_percentile": 0.8737}, "CVE-2017-12905": {"epss_score": 0.01846, "epss_percentile": 0.82514}, "CVE-2017-12906": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2017-12907": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-12908": {"epss_score": 0.00487, "epss_percentile": 0.64817}, "CVE-2017-12909": {"epss_score": 0.00487, "epss_percentile": 0.64817}, "CVE-2017-12910": {"epss_score": 0.00487, "epss_percentile": 0.64817}, "CVE-2017-12911": {"epss_score": 0.00218, "epss_percentile": 0.44408}, "CVE-2017-12912": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2017-12919": {"epss_score": 0.00527, "epss_percentile": 0.66527}, "CVE-2017-12920": {"epss_score": 0.00485, "epss_percentile": 0.6472}, "CVE-2017-12921": {"epss_score": 0.00485, "epss_percentile": 0.6472}, "CVE-2017-12922": {"epss_score": 0.00485, "epss_percentile": 0.6472}, "CVE-2017-12923": {"epss_score": 0.00485, "epss_percentile": 0.6472}, "CVE-2017-12924": {"epss_score": 0.00483, "epss_percentile": 0.6462}, "CVE-2017-12925": {"epss_score": 0.00483, "epss_percentile": 0.6462}, "CVE-2017-12927": {"epss_score": 0.00519, "epss_percentile": 0.66178}, "CVE-2017-12928": {"epss_score": 0.0227, "epss_percentile": 0.84205}, "CVE-2017-12929": {"epss_score": 0.03913, "epss_percentile": 0.87937}, "CVE-2017-12930": {"epss_score": 0.0304, "epss_percentile": 0.86271}, "CVE-2017-12932": {"epss_score": 0.01773, "epss_percentile": 0.82208}, "CVE-2017-12933": {"epss_score": 0.16709, "epss_percentile": 0.94718}, "CVE-2017-12934": {"epss_score": 0.0049, "epss_percentile": 0.64927}, "CVE-2017-12935": {"epss_score": 0.00868, "epss_percentile": 0.74665}, "CVE-2017-12936": {"epss_score": 0.019, "epss_percentile": 0.82768}, "CVE-2017-12937": {"epss_score": 0.0095, "epss_percentile": 0.75861}, "CVE-2017-12938": {"epss_score": 0.0089, "epss_percentile": 0.75027}, "CVE-2017-12939": {"epss_score": 0.02841, "epss_percentile": 0.85805}, "CVE-2017-12940": {"epss_score": 0.00448, "epss_percentile": 0.63007}, "CVE-2017-12941": {"epss_score": 0.00484, "epss_percentile": 0.64651}, "CVE-2017-12942": {"epss_score": 0.00479, "epss_percentile": 0.64432}, "CVE-2017-12943": {"epss_score": 0.81803, "epss_percentile": 0.99157}, "CVE-2017-12944": {"epss_score": 0.0074, "epss_percentile": 0.72407}, "CVE-2017-12945": {"epss_score": 0.26364, "epss_percentile": 0.96141}, "CVE-2017-12946": {"epss_score": 0.00481, "epss_percentile": 0.64487}, "CVE-2017-12947": {"epss_score": 0.00511, "epss_percentile": 0.65834}, "CVE-2017-12948": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-12949": {"epss_score": 0.00719, "epss_percentile": 0.71947}, "CVE-2017-12950": {"epss_score": 0.04372, "epss_percentile": 0.8861}, "CVE-2017-12951": {"epss_score": 0.03146, "epss_percentile": 0.86497}, "CVE-2017-12952": {"epss_score": 0.04733, "epss_percentile": 0.89071}, "CVE-2017-12953": {"epss_score": 0.03146, "epss_percentile": 0.86497}, "CVE-2017-12954": {"epss_score": 0.03146, "epss_percentile": 0.86497}, "CVE-2017-12955": {"epss_score": 0.01121, "epss_percentile": 0.77775}, "CVE-2017-12956": {"epss_score": 0.01065, "epss_percentile": 0.77213}, "CVE-2017-12957": {"epss_score": 0.01065, "epss_percentile": 0.77213}, "CVE-2017-12958": {"epss_score": 0.00471, "epss_percentile": 0.64025}, "CVE-2017-12959": {"epss_score": 0.00471, "epss_percentile": 0.64025}, "CVE-2017-12960": {"epss_score": 0.00471, "epss_percentile": 0.64025}, "CVE-2017-12961": {"epss_score": 0.00471, "epss_percentile": 0.64025}, "CVE-2017-12962": {"epss_score": 0.00401, "epss_percentile": 0.6021}, "CVE-2017-12963": {"epss_score": 0.00401, "epss_percentile": 0.6021}, "CVE-2017-12964": {"epss_score": 0.00596, "epss_percentile": 0.68717}, "CVE-2017-12965": {"epss_score": 0.07486, "epss_percentile": 0.91498}, "CVE-2017-12966": {"epss_score": 0.00388, "epss_percentile": 0.5936}, "CVE-2017-12967": {"epss_score": 0.01003, "epss_percentile": 0.76519}, "CVE-2017-12969": {"epss_score": 0.06964, "epss_percentile": 0.91151}, "CVE-2017-12970": {"epss_score": 0.00179, "epss_percentile": 0.3983}, "CVE-2017-12971": {"epss_score": 0.02899, "epss_percentile": 0.85951}, "CVE-2017-12972": {"epss_score": 0.00148, "epss_percentile": 0.35892}, "CVE-2017-12973": {"epss_score": 0.00334, "epss_percentile": 0.5573}, "CVE-2017-12974": {"epss_score": 0.002, "epss_percentile": 0.42211}, "CVE-2017-12976": {"epss_score": 0.0032, "epss_percentile": 0.54578}, "CVE-2017-12977": {"epss_score": 0.00511, "epss_percentile": 0.65834}, "CVE-2017-12978": {"epss_score": 0.00337, "epss_percentile": 0.56058}, "CVE-2017-12979": {"epss_score": 0.00543, "epss_percentile": 0.67109}, "CVE-2017-12980": {"epss_score": 0.00543, "epss_percentile": 0.67109}, "CVE-2017-12981": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-12982": {"epss_score": 0.00266, "epss_percentile": 0.49877}, "CVE-2017-12983": {"epss_score": 0.00484, "epss_percentile": 0.64649}, "CVE-2017-12984": {"epss_score": 0.01431, "epss_percentile": 0.80247}, "CVE-2017-12985": {"epss_score": 0.02013, "epss_percentile": 0.83262}, "CVE-2017-12986": {"epss_score": 0.02013, "epss_percentile": 0.83262}, "CVE-2017-12987": {"epss_score": 0.0206, "epss_percentile": 0.83441}, "CVE-2017-12988": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12989": {"epss_score": 0.01143, "epss_percentile": 0.77979}, "CVE-2017-12990": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12991": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-12992": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12993": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12994": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12995": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12996": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12997": {"epss_score": 0.01451, "epss_percentile": 0.80358}, "CVE-2017-12998": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-12999": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13000": {"epss_score": 0.04371, "epss_percentile": 0.88609}, "CVE-2017-13001": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13002": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13003": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13004": {"epss_score": 0.0206, "epss_percentile": 0.83441}, "CVE-2017-13005": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13006": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13007": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13008": {"epss_score": 0.02013, "epss_percentile": 0.83262}, "CVE-2017-13009": {"epss_score": 0.02013, "epss_percentile": 0.83262}, "CVE-2017-13010": {"epss_score": 0.02013, "epss_percentile": 0.83262}, "CVE-2017-13011": {"epss_score": 0.01488, "epss_percentile": 0.80617}, "CVE-2017-13012": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13013": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13014": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13015": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13016": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13017": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13018": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2017-13019": {"epss_score": 0.02637, "epss_percentile": 0.85295}, "CVE-2017-13020": {"epss_score": 0.0206, "epss_percentile": 0.83441}, "CVE-2017-13021": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2017-13022": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13023": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13024": {"epss_score": 0.0206, "epss_percentile": 0.83441}, "CVE-2017-13025": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13026": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2017-13027": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2017-13028": {"epss_score": 0.01009, "epss_percentile": 0.76582}, "CVE-2017-13029": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13030": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2017-13031": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13032": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13033": {"epss_score": 0.01843, "epss_percentile": 0.82505}, "CVE-2017-13034": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13035": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13036": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13037": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2017-13038": {"epss_score": 0.02637, "epss_percentile": 0.85295}, "CVE-2017-13039": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13040": {"epss_score": 0.01843, "epss_percentile": 0.82505}, "CVE-2017-13041": {"epss_score": 0.01843, "epss_percentile": 0.82505}, "CVE-2017-13042": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2017-13043": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2017-13044": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2017-13045": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2017-13046": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13047": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2017-13048": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13049": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13050": {"epss_score": 0.02637, "epss_percentile": 0.85295}, "CVE-2017-13051": {"epss_score": 0.00607, "epss_percentile": 0.69057}, "CVE-2017-13052": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2017-13053": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13054": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13055": {"epss_score": 0.0136, "epss_percentile": 0.79743}, "CVE-2017-13056": {"epss_score": 0.01691, "epss_percentile": 0.81778}, "CVE-2017-13058": {"epss_score": 0.00458, "epss_percentile": 0.63421}, "CVE-2017-13059": {"epss_score": 0.00458, "epss_percentile": 0.63421}, "CVE-2017-13060": {"epss_score": 0.00458, "epss_percentile": 0.63421}, "CVE-2017-13061": {"epss_score": 0.00466, "epss_percentile": 0.63797}, "CVE-2017-13062": {"epss_score": 0.00458, "epss_percentile": 0.63421}, "CVE-2017-13063": {"epss_score": 0.01536, "epss_percentile": 0.80919}, "CVE-2017-13064": {"epss_score": 0.017, "epss_percentile": 0.8183}, "CVE-2017-13065": {"epss_score": 0.01287, "epss_percentile": 0.79195}, "CVE-2017-13066": {"epss_score": 0.00207, "epss_percentile": 0.43188}, "CVE-2017-13067": {"epss_score": 0.51069, "epss_percentile": 0.97762}, "CVE-2017-13068": {"epss_score": 0.01224, "epss_percentile": 0.78673}, "CVE-2017-13069": {"epss_score": 0.0573, "epss_percentile": 0.90161}, "CVE-2017-13070": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2017-13071": {"epss_score": 0.00911, "epss_percentile": 0.75329}, "CVE-2017-13072": {"epss_score": 0.00272, "epss_percentile": 0.50359}, "CVE-2017-13073": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2017-13077": {"epss_score": 0.00664, "epss_percentile": 0.70651}, "CVE-2017-13078": {"epss_score": 0.00815, "epss_percentile": 0.73779}, "CVE-2017-13079": {"epss_score": 0.0035, "epss_percentile": 0.56976}, "CVE-2017-13080": {"epss_score": 0.01572, "epss_percentile": 0.81097}, "CVE-2017-13081": {"epss_score": 0.0034, "epss_percentile": 0.5623}, "CVE-2017-13082": {"epss_score": 0.00453, "epss_percentile": 0.63219}, "CVE-2017-13083": {"epss_score": 0.00114, "epss_percentile": 0.3079}, "CVE-2017-13084": {"epss_score": 0.00907, "epss_percentile": 0.75265}, "CVE-2017-13086": {"epss_score": 0.00293, "epss_percentile": 0.52343}, "CVE-2017-13087": {"epss_score": 0.00216, "epss_percentile": 0.44192}, "CVE-2017-13088": {"epss_score": 0.00186, "epss_percentile": 0.40639}, "CVE-2017-13089": {"epss_score": 0.73113, "epss_percentile": 0.98737}, "CVE-2017-13090": {"epss_score": 0.08139, "epss_percentile": 0.91898}, "CVE-2017-13091": {"epss_score": 0.00096, "epss_percentile": 0.27401}, "CVE-2017-13092": {"epss_score": 0.00096, "epss_percentile": 0.27401}, "CVE-2017-13093": {"epss_score": 0.00096, "epss_percentile": 0.27401}, "CVE-2017-13094": {"epss_score": 0.00041, "epss_percentile": 0.12276}, "CVE-2017-13095": {"epss_score": 0.00096, "epss_percentile": 0.27401}, "CVE-2017-13096": {"epss_score": 0.00096, "epss_percentile": 0.27401}, "CVE-2017-13097": {"epss_score": 0.00096, "epss_percentile": 0.27401}, "CVE-2017-13098": {"epss_score": 0.66233, "epss_percentile": 0.98456}, "CVE-2017-13099": {"epss_score": 0.70023, "epss_percentile": 0.98612}, "CVE-2017-13100": {"epss_score": 0.00114, "epss_percentile": 0.30825}, "CVE-2017-13101": {"epss_score": 0.00114, "epss_percentile": 0.30825}, "CVE-2017-13102": {"epss_score": 0.00155, "epss_percentile": 0.36819}, "CVE-2017-13104": {"epss_score": 0.00114, "epss_percentile": 0.30825}, "CVE-2017-13105": {"epss_score": 0.00097, "epss_percentile": 0.27541}, "CVE-2017-13106": {"epss_score": 0.00114, "epss_percentile": 0.30825}, "CVE-2017-13107": {"epss_score": 0.00114, "epss_percentile": 0.30825}, "CVE-2017-13108": {"epss_score": 0.00114, "epss_percentile": 0.30825}, "CVE-2017-13127": {"epss_score": 0.00653, "epss_percentile": 0.70336}, "CVE-2017-13129": {"epss_score": 0.00156, "epss_percentile": 0.37012}, "CVE-2017-13130": {"epss_score": 0.00237, "epss_percentile": 0.46694}, "CVE-2017-13131": {"epss_score": 0.00426, "epss_percentile": 0.61752}, "CVE-2017-13132": {"epss_score": 0.00252, "epss_percentile": 0.48357}, "CVE-2017-13133": {"epss_score": 0.00657, "epss_percentile": 0.70471}, "CVE-2017-13134": {"epss_score": 0.01351, "epss_percentile": 0.79679}, "CVE-2017-13135": {"epss_score": 0.00295, "epss_percentile": 0.52526}, "CVE-2017-13136": {"epss_score": 0.00491, "epss_percentile": 0.6498}, "CVE-2017-13137": {"epss_score": 0.00648, "epss_percentile": 0.70214}, "CVE-2017-13138": {"epss_score": 0.00495, "epss_percentile": 0.65112}, "CVE-2017-13139": {"epss_score": 0.01094, "epss_percentile": 0.77496}, "CVE-2017-13140": {"epss_score": 0.00414, "epss_percentile": 0.6104}, "CVE-2017-13141": {"epss_score": 0.00426, "epss_percentile": 0.61752}, "CVE-2017-13142": {"epss_score": 0.00624, "epss_percentile": 0.69561}, "CVE-2017-13143": {"epss_score": 0.0036, "epss_percentile": 0.57689}, "CVE-2017-13144": {"epss_score": 0.00243, "epss_percentile": 0.47411}, "CVE-2017-13145": {"epss_score": 0.01329, "epss_percentile": 0.79507}, "CVE-2017-13146": {"epss_score": 0.00462, "epss_percentile": 0.63624}, "CVE-2017-13147": {"epss_score": 0.00258, "epss_percentile": 0.48986}, "CVE-2017-13148": {"epss_score": 0.00102, "epss_percentile": 0.28801}, "CVE-2017-13149": {"epss_score": 0.00122, "epss_percentile": 0.32079}, "CVE-2017-13150": {"epss_score": 0.00122, "epss_percentile": 0.32079}, "CVE-2017-13151": {"epss_score": 0.00456, "epss_percentile": 0.63345}, "CVE-2017-13152": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-13153": {"epss_score": 0.00016, "epss_percentile": 0.02924}, "CVE-2017-13154": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2017-13156": {"epss_score": 0.59668, "epss_percentile": 0.98175}, "CVE-2017-13157": {"epss_score": 0.00106, "epss_percentile": 0.29449}, "CVE-2017-13158": {"epss_score": 0.00106, "epss_percentile": 0.29449}, "CVE-2017-13159": {"epss_score": 0.00106, "epss_percentile": 0.29449}, "CVE-2017-13160": {"epss_score": 0.01255, "epss_percentile": 0.78931}, "CVE-2017-13161": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-13162": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2017-13163": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-13164": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-13165": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2017-13166": {"epss_score": 0.00072, "epss_percentile": 0.22252}, "CVE-2017-13167": {"epss_score": 0.00084, "epss_percentile": 0.2496}, "CVE-2017-13168": {"epss_score": 0.00308, "epss_percentile": 0.53594}, "CVE-2017-13169": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-13170": {"epss_score": 0.00016, "epss_percentile": 0.02699}, "CVE-2017-13171": {"epss_score": 0.00016, "epss_percentile": 0.02699}, "CVE-2017-13172": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-13173": {"epss_score": 0.00016, "epss_percentile": 0.02699}, "CVE-2017-13174": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2017-13175": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-13176": {"epss_score": 0.00689, "epss_percentile": 0.7123}, "CVE-2017-13177": {"epss_score": 0.1005, "epss_percentile": 0.92828}, "CVE-2017-13178": {"epss_score": 0.03421, "epss_percentile": 0.87102}, "CVE-2017-13179": {"epss_score": 0.03421, "epss_percentile": 0.87102}, "CVE-2017-13180": {"epss_score": 0.00037, "epss_percentile": 0.10882}, "CVE-2017-13181": {"epss_score": 0.00032, "epss_percentile": 0.08772}, "CVE-2017-13182": {"epss_score": 0.00032, "epss_percentile": 0.08772}, "CVE-2017-13183": {"epss_score": 0.00034, "epss_percentile": 0.09586}, "CVE-2017-13184": {"epss_score": 0.00037, "epss_percentile": 0.10882}, "CVE-2017-13185": {"epss_score": 0.00122, "epss_percentile": 0.32079}, "CVE-2017-13186": {"epss_score": 0.00101, "epss_percentile": 0.28622}, "CVE-2017-13187": {"epss_score": 0.00122, "epss_percentile": 0.32079}, "CVE-2017-13188": {"epss_score": 0.00134, "epss_percentile": 0.33823}, "CVE-2017-13189": {"epss_score": 0.00152, "epss_percentile": 0.3641}, "CVE-2017-13190": {"epss_score": 0.00101, "epss_percentile": 0.28622}, "CVE-2017-13191": {"epss_score": 0.02288, "epss_percentile": 0.84272}, "CVE-2017-13192": {"epss_score": 0.02288, "epss_percentile": 0.84272}, "CVE-2017-13193": {"epss_score": 0.03008, "epss_percentile": 0.86192}, "CVE-2017-13194": {"epss_score": 0.00926, "epss_percentile": 0.75545}, "CVE-2017-13195": {"epss_score": 0.02288, "epss_percentile": 0.84272}, "CVE-2017-13196": {"epss_score": 0.03008, "epss_percentile": 0.86192}, "CVE-2017-13197": {"epss_score": 0.04329, "epss_percentile": 0.88557}, "CVE-2017-13198": {"epss_score": 0.0013, "epss_percentile": 0.33314}, "CVE-2017-13199": {"epss_score": 0.03008, "epss_percentile": 0.86192}, "CVE-2017-13200": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-13201": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-13202": {"epss_score": 0.00086, "epss_percentile": 0.25289}, "CVE-2017-13203": {"epss_score": 0.00102, "epss_percentile": 0.28848}, "CVE-2017-13204": {"epss_score": 0.00102, "epss_percentile": 0.28848}, "CVE-2017-13205": {"epss_score": 0.00102, "epss_percentile": 0.28848}, "CVE-2017-13206": {"epss_score": 0.00086, "epss_percentile": 0.25289}, "CVE-2017-13207": {"epss_score": 0.00086, "epss_percentile": 0.25289}, "CVE-2017-13208": {"epss_score": 0.15731, "epss_percentile": 0.94495}, "CVE-2017-13209": {"epss_score": 0.00467, "epss_percentile": 0.63858}, "CVE-2017-13210": {"epss_score": 0.00042, "epss_percentile": 0.1258}, "CVE-2017-13211": {"epss_score": 0.03684, "epss_percentile": 0.87567}, "CVE-2017-13212": {"epss_score": 0.00028, "epss_percentile": 0.07544}, "CVE-2017-13213": {"epss_score": 0.00028, "epss_percentile": 0.07544}, "CVE-2017-13214": {"epss_score": 0.01517, "epss_percentile": 0.80804}, "CVE-2017-13215": {"epss_score": 0.00102, "epss_percentile": 0.28831}, "CVE-2017-13216": {"epss_score": 0.03835, "epss_percentile": 0.87823}, "CVE-2017-13217": {"epss_score": 0.00032, "epss_percentile": 0.08772}, "CVE-2017-13218": {"epss_score": 0.00044, "epss_percentile": 0.13605}, "CVE-2017-13219": {"epss_score": 0.00158, "epss_percentile": 0.37168}, "CVE-2017-13220": {"epss_score": 0.00097, "epss_percentile": 0.27454}, "CVE-2017-13221": {"epss_score": 0.00062, "epss_percentile": 0.19555}, "CVE-2017-13222": {"epss_score": 0.00179, "epss_percentile": 0.39851}, "CVE-2017-13225": {"epss_score": 0.002, "epss_percentile": 0.42245}, "CVE-2017-13226": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-13227": {"epss_score": 0.00056, "epss_percentile": 0.17797}, "CVE-2017-13228": {"epss_score": 0.00456, "epss_percentile": 0.63345}, "CVE-2017-13229": {"epss_score": 0.01255, "epss_percentile": 0.78931}, "CVE-2017-13230": {"epss_score": 0.01758, "epss_percentile": 0.82137}, "CVE-2017-13231": {"epss_score": 0.00021, "epss_percentile": 0.04882}, "CVE-2017-13232": {"epss_score": 0.00143, "epss_percentile": 0.35149}, "CVE-2017-13233": {"epss_score": 0.00157, "epss_percentile": 0.37035}, "CVE-2017-13234": {"epss_score": 0.00157, "epss_percentile": 0.37035}, "CVE-2017-13235": {"epss_score": 0.00112, "epss_percentile": 0.3058}, "CVE-2017-13236": {"epss_score": 0.00071, "epss_percentile": 0.22235}, "CVE-2017-13238": {"epss_score": 0.00025, "epss_percentile": 0.06275}, "CVE-2017-13239": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-13240": {"epss_score": 0.00136, "epss_percentile": 0.34104}, "CVE-2017-13241": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-13242": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-13243": {"epss_score": 0.00097, "epss_percentile": 0.27582}, "CVE-2017-13244": {"epss_score": 0.00019, "epss_percentile": 0.04153}, "CVE-2017-13245": {"epss_score": 0.00019, "epss_percentile": 0.04153}, "CVE-2017-13246": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-13247": {"epss_score": 0.00024, "epss_percentile": 0.05691}, "CVE-2017-13248": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-13249": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-13250": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-13251": {"epss_score": 0.00045, "epss_percentile": 0.13786}, "CVE-2017-13252": {"epss_score": 0.00045, "epss_percentile": 0.13786}, "CVE-2017-13253": {"epss_score": 0.04218, "epss_percentile": 0.88408}, "CVE-2017-13254": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2017-13255": {"epss_score": 0.00286, "epss_percentile": 0.51687}, "CVE-2017-13256": {"epss_score": 0.00286, "epss_percentile": 0.51687}, "CVE-2017-13257": {"epss_score": 0.00211, "epss_percentile": 0.43702}, "CVE-2017-13258": {"epss_score": 0.27631, "epss_percentile": 0.96267}, "CVE-2017-13259": {"epss_score": 0.00818, "epss_percentile": 0.73858}, "CVE-2017-13260": {"epss_score": 0.20051, "epss_percentile": 0.95281}, "CVE-2017-13261": {"epss_score": 0.33566, "epss_percentile": 0.96784}, "CVE-2017-13262": {"epss_score": 0.18927, "epss_percentile": 0.95099}, "CVE-2017-13263": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2017-13264": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2017-13265": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2017-13266": {"epss_score": 0.01255, "epss_percentile": 0.78931}, "CVE-2017-13267": {"epss_score": 0.02862, "epss_percentile": 0.85853}, "CVE-2017-13268": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2017-13269": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2017-13270": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2017-13271": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2017-13272": {"epss_score": 0.0078, "epss_percentile": 0.7316}, "CVE-2017-13273": {"epss_score": 0.00014, "epss_percentile": 0.01992}, "CVE-2017-13274": {"epss_score": 0.00077, "epss_percentile": 0.23409}, "CVE-2017-13275": {"epss_score": 0.00044, "epss_percentile": 0.13389}, "CVE-2017-13276": {"epss_score": 0.01912, "epss_percentile": 0.8283}, "CVE-2017-13277": {"epss_score": 0.00722, "epss_percentile": 0.71994}, "CVE-2017-13278": {"epss_score": 0.00101, "epss_percentile": 0.28632}, "CVE-2017-13279": {"epss_score": 0.00164, "epss_percentile": 0.37998}, "CVE-2017-13280": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2017-13281": {"epss_score": 0.02538, "epss_percentile": 0.85043}, "CVE-2017-13282": {"epss_score": 0.03182, "epss_percentile": 0.86583}, "CVE-2017-13283": {"epss_score": 0.0281, "epss_percentile": 0.85718}, "CVE-2017-13284": {"epss_score": 0.0117, "epss_percentile": 0.78207}, "CVE-2017-13285": {"epss_score": 0.02127, "epss_percentile": 0.83697}, "CVE-2017-13286": {"epss_score": 0.00013, "epss_percentile": 0.01449}, "CVE-2017-13287": {"epss_score": 0.00034, "epss_percentile": 0.09473}, "CVE-2017-13288": {"epss_score": 0.00013, "epss_percentile": 0.01653}, "CVE-2017-13289": {"epss_score": 0.00013, "epss_percentile": 0.01653}, "CVE-2017-13290": {"epss_score": 0.00046, "epss_percentile": 0.14198}, "CVE-2017-13291": {"epss_score": 0.01769, "epss_percentile": 0.82185}, "CVE-2017-13292": {"epss_score": 0.02127, "epss_percentile": 0.83697}, "CVE-2017-13293": {"epss_score": 0.00034, "epss_percentile": 0.09473}, "CVE-2017-13294": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-13295": {"epss_score": 0.0011, "epss_percentile": 0.30192}, "CVE-2017-13296": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-13297": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-13298": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-13299": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2017-13300": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2017-13301": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2017-13302": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2017-13303": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-13304": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-13305": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2017-13306": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2017-13307": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2017-13308": {"epss_score": 0.00028, "epss_percentile": 0.07345}, "CVE-2017-13309": {"epss_score": 0.00041, "epss_percentile": 0.12395}, "CVE-2017-13310": {"epss_score": 7e-05, "epss_percentile": 0.0037}, "CVE-2017-13311": {"epss_score": 6e-05, "epss_percentile": 0.00294}, "CVE-2017-13312": {"epss_score": 0.00026, "epss_percentile": 0.06414}, "CVE-2017-13313": {"epss_score": 0.02712, "epss_percentile": 0.855}, "CVE-2017-13314": {"epss_score": 8e-05, "epss_percentile": 0.0053}, "CVE-2017-13315": {"epss_score": 0.00012, "epss_percentile": 0.01332}, "CVE-2017-13316": {"epss_score": 4e-05, "epss_percentile": 0.00128}, "CVE-2017-13317": {"epss_score": 0.00088, "epss_percentile": 0.25639}, "CVE-2017-13318": {"epss_score": 0.00088, "epss_percentile": 0.25639}, "CVE-2017-13319": {"epss_score": 0.00181, "epss_percentile": 0.4006}, "CVE-2017-13320": {"epss_score": 0.00062, "epss_percentile": 0.19717}, "CVE-2017-13321": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2017-13322": {"epss_score": 0.00032, "epss_percentile": 0.08778}, "CVE-2017-13323": {"epss_score": 0.00016, "epss_percentile": 0.02852}, "CVE-2017-13648": {"epss_score": 0.00429, "epss_percentile": 0.61961}, "CVE-2017-13649": {"epss_score": 0.00047, "epss_percentile": 0.14897}, "CVE-2017-13652": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2017-13658": {"epss_score": 0.00475, "epss_percentile": 0.64185}, "CVE-2017-13663": {"epss_score": 0.00093, "epss_percentile": 0.26728}, "CVE-2017-13664": {"epss_score": 0.00557, "epss_percentile": 0.67558}, "CVE-2017-13666": {"epss_score": 0.00096, "epss_percentile": 0.27258}, "CVE-2017-13667": {"epss_score": 0.00384, "epss_percentile": 0.59169}, "CVE-2017-13668": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2017-13669": {"epss_score": 0.00293, "epss_percentile": 0.52349}, "CVE-2017-13670": {"epss_score": 0.00133, "epss_percentile": 0.33702}, "CVE-2017-13671": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2017-13672": {"epss_score": 0.00668, "epss_percentile": 0.70726}, "CVE-2017-13673": {"epss_score": 0.00732, "epss_percentile": 0.72189}, "CVE-2017-13674": {"epss_score": 0.00094, "epss_percentile": 0.26979}, "CVE-2017-13675": {"epss_score": 0.00476, "epss_percentile": 0.64268}, "CVE-2017-13676": {"epss_score": 0.00273, "epss_percentile": 0.50452}, "CVE-2017-13677": {"epss_score": 0.07189, "epss_percentile": 0.9131}, "CVE-2017-13678": {"epss_score": 0.00312, "epss_percentile": 0.53964}, "CVE-2017-13679": {"epss_score": 0.00256, "epss_percentile": 0.48783}, "CVE-2017-13680": {"epss_score": 0.00102, "epss_percentile": 0.28771}, "CVE-2017-13681": {"epss_score": 0.00087, "epss_percentile": 0.25448}, "CVE-2017-13682": {"epss_score": 0.00105, "epss_percentile": 0.2926}, "CVE-2017-13683": {"epss_score": 0.00105, "epss_percentile": 0.2926}, "CVE-2017-13684": {"epss_score": 0.0014, "epss_percentile": 0.34782}, "CVE-2017-13685": {"epss_score": 0.00397, "epss_percentile": 0.6004}, "CVE-2017-13686": {"epss_score": 0.0013, "epss_percentile": 0.33313}, "CVE-2017-13687": {"epss_score": 0.0206, "epss_percentile": 0.83441}, "CVE-2017-13688": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13689": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13690": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2017-13692": {"epss_score": 0.00257, "epss_percentile": 0.48883}, "CVE-2017-13693": {"epss_score": 0.00043, "epss_percentile": 0.12963}, "CVE-2017-13694": {"epss_score": 0.00089, "epss_percentile": 0.25882}, "CVE-2017-13695": {"epss_score": 0.00011, "epss_percentile": 0.01031}, "CVE-2017-13696": {"epss_score": 0.6338, "epss_percentile": 0.98331}, "CVE-2017-13697": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2017-13698": {"epss_score": 0.00371, "epss_percentile": 0.5841}, "CVE-2017-13699": {"epss_score": 0.00098, "epss_percentile": 0.27824}, "CVE-2017-13700": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2017-13701": {"epss_score": 0.00402, "epss_percentile": 0.60316}, "CVE-2017-13702": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2017-13703": {"epss_score": 0.00446, "epss_percentile": 0.629}, "CVE-2017-13704": {"epss_score": 0.81755, "epss_percentile": 0.99154}, "CVE-2017-13706": {"epss_score": 0.0141, "epss_percentile": 0.80078}, "CVE-2017-13707": {"epss_score": 0.00568, "epss_percentile": 0.67879}, "CVE-2017-13708": {"epss_score": 0.70719, "epss_percentile": 0.9864}, "CVE-2017-13709": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2017-13710": {"epss_score": 0.0059, "epss_percentile": 0.68556}, "CVE-2017-13711": {"epss_score": 0.02957, "epss_percentile": 0.86064}, "CVE-2017-13712": {"epss_score": 0.00434, "epss_percentile": 0.62314}, "CVE-2017-13713": {"epss_score": 0.0357, "epss_percentile": 0.87369}, "CVE-2017-13715": {"epss_score": 0.13128, "epss_percentile": 0.93881}, "CVE-2017-13716": {"epss_score": 0.00237, "epss_percentile": 0.46693}, "CVE-2017-13717": {"epss_score": 0.0216, "epss_percentile": 0.83822}, "CVE-2017-13718": {"epss_score": 0.01558, "epss_percentile": 0.8103}, "CVE-2017-13719": {"epss_score": 0.03303, "epss_percentile": 0.86868}, "CVE-2017-13720": {"epss_score": 0.00103, "epss_percentile": 0.28903}, "CVE-2017-13721": {"epss_score": 0.00086, "epss_percentile": 0.25274}, "CVE-2017-13722": {"epss_score": 0.001, "epss_percentile": 0.28482}, "CVE-2017-13723": {"epss_score": 0.00136, "epss_percentile": 0.34163}, "CVE-2017-13724": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-13725": {"epss_score": 0.0206, "epss_percentile": 0.83441}, "CVE-2017-13726": {"epss_score": 0.0064, "epss_percentile": 0.69956}, "CVE-2017-13727": {"epss_score": 0.00636, "epss_percentile": 0.69833}, "CVE-2017-13728": {"epss_score": 0.00307, "epss_percentile": 0.53498}, "CVE-2017-13729": {"epss_score": 0.00307, "epss_percentile": 0.53498}, "CVE-2017-13730": {"epss_score": 0.00481, "epss_percentile": 0.64507}, "CVE-2017-13731": {"epss_score": 0.00307, "epss_percentile": 0.53498}, "CVE-2017-13732": {"epss_score": 0.00481, "epss_percentile": 0.64507}, "CVE-2017-13733": {"epss_score": 0.00481, "epss_percentile": 0.64507}, "CVE-2017-13734": {"epss_score": 0.00177, "epss_percentile": 0.39588}, "CVE-2017-13735": {"epss_score": 0.006, "epss_percentile": 0.6883}, "CVE-2017-13736": {"epss_score": 0.00733, "epss_percentile": 0.72211}, "CVE-2017-13737": {"epss_score": 0.0183, "epss_percentile": 0.82446}, "CVE-2017-13738": {"epss_score": 0.00385, "epss_percentile": 0.59187}, "CVE-2017-13739": {"epss_score": 0.00783, "epss_percentile": 0.73223}, "CVE-2017-13740": {"epss_score": 0.00355, "epss_percentile": 0.57299}, "CVE-2017-13741": {"epss_score": 0.00339, "epss_percentile": 0.56188}, "CVE-2017-13742": {"epss_score": 0.004, "epss_percentile": 0.60173}, "CVE-2017-13743": {"epss_score": 0.004, "epss_percentile": 0.60173}, "CVE-2017-13744": {"epss_score": 0.00291, "epss_percentile": 0.52161}, "CVE-2017-13745": {"epss_score": 0.00367, "epss_percentile": 0.58138}, "CVE-2017-13746": {"epss_score": 0.01636, "epss_percentile": 0.81475}, "CVE-2017-13747": {"epss_score": 0.0101, "epss_percentile": 0.76599}, "CVE-2017-13748": {"epss_score": 0.02661, "epss_percentile": 0.85368}, "CVE-2017-13749": {"epss_score": 0.0101, "epss_percentile": 0.76599}, "CVE-2017-13750": {"epss_score": 0.01636, "epss_percentile": 0.81475}, "CVE-2017-13751": {"epss_score": 0.0101, "epss_percentile": 0.76599}, "CVE-2017-13752": {"epss_score": 0.0101, "epss_percentile": 0.76599}, "CVE-2017-13754": {"epss_score": 0.00693, "epss_percentile": 0.71321}, "CVE-2017-13755": {"epss_score": 0.00273, "epss_percentile": 0.50429}, "CVE-2017-13756": {"epss_score": 0.00214, "epss_percentile": 0.43959}, "CVE-2017-13757": {"epss_score": 0.00452, "epss_percentile": 0.63174}, "CVE-2017-13758": {"epss_score": 0.01016, "epss_percentile": 0.76679}, "CVE-2017-13760": {"epss_score": 0.00195, "epss_percentile": 0.41605}, "CVE-2017-13761": {"epss_score": 0.00283, "epss_percentile": 0.5135}, "CVE-2017-13762": {"epss_score": 0.00748, "epss_percentile": 0.72585}, "CVE-2017-13763": {"epss_score": 0.00341, "epss_percentile": 0.56341}, "CVE-2017-13764": {"epss_score": 0.00404, "epss_percentile": 0.60444}, "CVE-2017-13765": {"epss_score": 0.01179, "epss_percentile": 0.78295}, "CVE-2017-13766": {"epss_score": 0.00447, "epss_percentile": 0.62966}, "CVE-2017-13767": {"epss_score": 0.00325, "epss_percentile": 0.54981}, "CVE-2017-13768": {"epss_score": 0.00879, "epss_percentile": 0.74836}, "CVE-2017-13769": {"epss_score": 0.00531, "epss_percentile": 0.66664}, "CVE-2017-13771": {"epss_score": 0.01532, "epss_percentile": 0.80893}, "CVE-2017-13772": {"epss_score": 0.5222, "epss_percentile": 0.97813}, "CVE-2017-13774": {"epss_score": 0.00119, "epss_percentile": 0.31592}, "CVE-2017-13775": {"epss_score": 0.0215, "epss_percentile": 0.83779}, "CVE-2017-13776": {"epss_score": 0.01071, "epss_percentile": 0.77263}, "CVE-2017-13777": {"epss_score": 0.01071, "epss_percentile": 0.77263}, "CVE-2017-13778": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-13779": {"epss_score": 0.00379, "epss_percentile": 0.58895}, "CVE-2017-13780": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-13782": {"epss_score": 0.0058, "epss_percentile": 0.68247}, "CVE-2017-13783": {"epss_score": 0.19925, "epss_percentile": 0.95262}, "CVE-2017-13784": {"epss_score": 0.21364, "epss_percentile": 0.95509}, "CVE-2017-13785": {"epss_score": 0.21364, "epss_percentile": 0.95509}, "CVE-2017-13786": {"epss_score": 0.00072, "epss_percentile": 0.22443}, "CVE-2017-13788": {"epss_score": 0.01056, "epss_percentile": 0.77128}, "CVE-2017-13789": {"epss_score": 0.00217, "epss_percentile": 0.44312}, "CVE-2017-13790": {"epss_score": 0.00217, "epss_percentile": 0.44312}, "CVE-2017-13791": {"epss_score": 0.19925, "epss_percentile": 0.95262}, "CVE-2017-13792": {"epss_score": 0.21364, "epss_percentile": 0.95509}, "CVE-2017-13793": {"epss_score": 0.01056, "epss_percentile": 0.77128}, "CVE-2017-13794": {"epss_score": 0.21364, "epss_percentile": 0.95509}, "CVE-2017-13795": {"epss_score": 0.21364, "epss_percentile": 0.95509}, "CVE-2017-13796": {"epss_score": 0.19925, "epss_percentile": 0.95262}, "CVE-2017-13797": {"epss_score": 0.1598, "epss_percentile": 0.94547}, "CVE-2017-13798": {"epss_score": 0.18557, "epss_percentile": 0.95033}, "CVE-2017-13799": {"epss_score": 0.00386, "epss_percentile": 0.59239}, "CVE-2017-13800": {"epss_score": 0.00175, "epss_percentile": 0.39286}, "CVE-2017-13801": {"epss_score": 0.00062, "epss_percentile": 0.19622}, "CVE-2017-13802": {"epss_score": 0.21364, "epss_percentile": 0.95509}, "CVE-2017-13803": {"epss_score": 0.01056, "epss_percentile": 0.77128}, "CVE-2017-13804": {"epss_score": 0.00328, "epss_percentile": 0.55274}, "CVE-2017-13805": {"epss_score": 0.00125, "epss_percentile": 0.32555}, "CVE-2017-13806": {"epss_score": 0.00194, "epss_percentile": 0.41528}, "CVE-2017-13807": {"epss_score": 0.00518, "epss_percentile": 0.66132}, "CVE-2017-13808": {"epss_score": 0.00176, "epss_percentile": 0.39439}, "CVE-2017-13809": {"epss_score": 0.00558, "epss_percentile": 0.6756}, "CVE-2017-13810": {"epss_score": 0.00059, "epss_percentile": 0.18668}, "CVE-2017-13811": {"epss_score": 0.00175, "epss_percentile": 0.39286}, "CVE-2017-13812": {"epss_score": 0.00518, "epss_percentile": 0.66132}, "CVE-2017-13813": {"epss_score": 0.00636, "epss_percentile": 0.69831}, "CVE-2017-13814": {"epss_score": 0.00518, "epss_percentile": 0.66132}, "CVE-2017-13815": {"epss_score": 0.01839, "epss_percentile": 0.82487}, "CVE-2017-13816": {"epss_score": 0.00636, "epss_percentile": 0.69831}, "CVE-2017-13817": {"epss_score": 0.00059, "epss_percentile": 0.18668}, "CVE-2017-13818": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-13819": {"epss_score": 0.00367, "epss_percentile": 0.58112}, "CVE-2017-13820": {"epss_score": 0.00283, "epss_percentile": 0.51367}, "CVE-2017-13821": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-13822": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-13823": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-13824": {"epss_score": 0.00522, "epss_percentile": 0.66279}, "CVE-2017-13825": {"epss_score": 0.00518, "epss_percentile": 0.66132}, "CVE-2017-13827": {"epss_score": 0.00232, "epss_percentile": 0.45899}, "CVE-2017-13828": {"epss_score": 0.00164, "epss_percentile": 0.37868}, "CVE-2017-13829": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2017-13830": {"epss_score": 0.00175, "epss_percentile": 0.39286}, "CVE-2017-13831": {"epss_score": 0.0024, "epss_percentile": 0.47211}, "CVE-2017-13832": {"epss_score": 0.00547, "epss_percentile": 0.6725}, "CVE-2017-13833": {"epss_score": 0.00187, "epss_percentile": 0.40698}, "CVE-2017-13834": {"epss_score": 0.00392, "epss_percentile": 0.59673}, "CVE-2017-13835": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2017-13836": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-13837": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2017-13838": {"epss_score": 0.00175, "epss_percentile": 0.39286}, "CVE-2017-13839": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2017-13840": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-13841": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-13842": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-13843": {"epss_score": 0.00175, "epss_percentile": 0.39286}, "CVE-2017-13844": {"epss_score": 0.00142, "epss_percentile": 0.34981}, "CVE-2017-13846": {"epss_score": 0.01839, "epss_percentile": 0.82487}, "CVE-2017-13847": {"epss_score": 0.01243, "epss_percentile": 0.78828}, "CVE-2017-13848": {"epss_score": 0.00176, "epss_percentile": 0.39425}, "CVE-2017-13849": {"epss_score": 0.05893, "epss_percentile": 0.90301}, "CVE-2017-13850": {"epss_score": 0.00324, "epss_percentile": 0.54967}, "CVE-2017-13851": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2017-13852": {"epss_score": 0.00228, "epss_percentile": 0.45511}, "CVE-2017-13853": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2017-13854": {"epss_score": 0.00244, "epss_percentile": 0.47598}, "CVE-2017-13855": {"epss_score": 0.06249, "epss_percentile": 0.90614}, "CVE-2017-13856": {"epss_score": 0.01523, "epss_percentile": 0.80844}, "CVE-2017-13858": {"epss_score": 0.00176, "epss_percentile": 0.39425}, "CVE-2017-13860": {"epss_score": 0.00504, "epss_percentile": 0.65487}, "CVE-2017-13861": {"epss_score": 0.68491, "epss_percentile": 0.9855}, "CVE-2017-13862": {"epss_score": 0.00253, "epss_percentile": 0.48496}, "CVE-2017-13863": {"epss_score": 0.0012, "epss_percentile": 0.31708}, "CVE-2017-13864": {"epss_score": 0.0023, "epss_percentile": 0.45717}, "CVE-2017-13865": {"epss_score": 0.04815, "epss_percentile": 0.8917}, "CVE-2017-13866": {"epss_score": 0.01523, "epss_percentile": 0.80844}, "CVE-2017-13867": {"epss_score": 0.02252, "epss_percentile": 0.84162}, "CVE-2017-13868": {"epss_score": 0.09858, "epss_percentile": 0.92739}, "CVE-2017-13869": {"epss_score": 0.07328, "epss_percentile": 0.91412}, "CVE-2017-13870": {"epss_score": 0.01523, "epss_percentile": 0.80844}, "CVE-2017-13871": {"epss_score": 0.00538, "epss_percentile": 0.66946}, "CVE-2017-13872": {"epss_score": 0.76664, "epss_percentile": 0.989}, "CVE-2017-13873": {"epss_score": 0.00335, "epss_percentile": 0.55807}, "CVE-2017-13874": {"epss_score": 0.00396, "epss_percentile": 0.59852}, "CVE-2017-13875": {"epss_score": 0.01266, "epss_percentile": 0.79009}, "CVE-2017-13876": {"epss_score": 0.02252, "epss_percentile": 0.84162}, "CVE-2017-13877": {"epss_score": 0.0019, "epss_percentile": 0.41108}, "CVE-2017-13878": {"epss_score": 0.00095, "epss_percentile": 0.27168}, "CVE-2017-13879": {"epss_score": 0.00155, "epss_percentile": 0.36786}, "CVE-2017-13880": {"epss_score": 0.00202, "epss_percentile": 0.42411}, "CVE-2017-13883": {"epss_score": 0.00165, "epss_percentile": 0.38055}, "CVE-2017-13884": {"epss_score": 0.00476, "epss_percentile": 0.64258}, "CVE-2017-13885": {"epss_score": 0.00476, "epss_percentile": 0.64258}, "CVE-2017-13886": {"epss_score": 0.00353, "epss_percentile": 0.57179}, "CVE-2017-13887": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2017-13888": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2017-13889": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2017-13890": {"epss_score": 0.00645, "epss_percentile": 0.70108}, "CVE-2017-13891": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2017-13892": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2017-13903": {"epss_score": 0.00573, "epss_percentile": 0.68046}, "CVE-2017-13904": {"epss_score": 0.00386, "epss_percentile": 0.59239}, "CVE-2017-13905": {"epss_score": 0.00607, "epss_percentile": 0.69052}, "CVE-2017-13906": {"epss_score": 0.00222, "epss_percentile": 0.44795}, "CVE-2017-13907": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2017-13908": {"epss_score": 0.00034, "epss_percentile": 0.09523}, "CVE-2017-13909": {"epss_score": 0.0005, "epss_percentile": 0.15671}, "CVE-2017-13910": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2017-13911": {"epss_score": 0.00127, "epss_percentile": 0.32785}, "CVE-2017-13982": {"epss_score": 0.0332, "epss_percentile": 0.86909}, "CVE-2017-13983": {"epss_score": 0.14919, "epss_percentile": 0.94323}, "CVE-2017-13984": {"epss_score": 0.01269, "epss_percentile": 0.79044}, "CVE-2017-13985": {"epss_score": 0.00449, "epss_percentile": 0.63035}, "CVE-2017-13986": {"epss_score": 0.00362, "epss_percentile": 0.57751}, "CVE-2017-13987": {"epss_score": 0.00349, "epss_percentile": 0.56866}, "CVE-2017-13988": {"epss_score": 0.0026, "epss_percentile": 0.49168}, "CVE-2017-13989": {"epss_score": 0.00339, "epss_percentile": 0.56163}, "CVE-2017-13990": {"epss_score": 0.00551, "epss_percentile": 0.67373}, "CVE-2017-13991": {"epss_score": 0.00551, "epss_percentile": 0.67373}, "CVE-2017-13992": {"epss_score": 0.0828, "epss_percentile": 0.91967}, "CVE-2017-13993": {"epss_score": 0.00157, "epss_percentile": 0.37099}, "CVE-2017-13994": {"epss_score": 0.00259, "epss_percentile": 0.4907}, "CVE-2017-13995": {"epss_score": 0.01603, "epss_percentile": 0.81277}, "CVE-2017-13996": {"epss_score": 0.0196, "epss_percentile": 0.83058}, "CVE-2017-13997": {"epss_score": 0.01586, "epss_percentile": 0.81178}, "CVE-2017-13998": {"epss_score": 0.00448, "epss_percentile": 0.63029}, "CVE-2017-13999": {"epss_score": 0.01173, "epss_percentile": 0.78241}, "CVE-2017-14000": {"epss_score": 0.0105, "epss_percentile": 0.77069}, "CVE-2017-14001": {"epss_score": 0.01654, "epss_percentile": 0.81584}, "CVE-2017-14002": {"epss_score": 0.14735, "epss_percentile": 0.94271}, "CVE-2017-14003": {"epss_score": 0.01493, "epss_percentile": 0.80642}, "CVE-2017-14004": {"epss_score": 0.00868, "epss_percentile": 0.74666}, "CVE-2017-14005": {"epss_score": 0.00401, "epss_percentile": 0.60236}, "CVE-2017-14006": {"epss_score": 0.00868, "epss_percentile": 0.74666}, "CVE-2017-14007": {"epss_score": 0.00227, "epss_percentile": 0.45392}, "CVE-2017-14008": {"epss_score": 0.06612, "epss_percentile": 0.90888}, "CVE-2017-14009": {"epss_score": 0.00256, "epss_percentile": 0.48816}, "CVE-2017-14010": {"epss_score": 0.00353, "epss_percentile": 0.57193}, "CVE-2017-14011": {"epss_score": 0.00123, "epss_percentile": 0.3233}, "CVE-2017-14012": {"epss_score": 0.00057, "epss_percentile": 0.18073}, "CVE-2017-14013": {"epss_score": 0.00286, "epss_percentile": 0.51744}, "CVE-2017-14014": {"epss_score": 0.00115, "epss_percentile": 0.30938}, "CVE-2017-14016": {"epss_score": 0.19225, "epss_percentile": 0.95151}, "CVE-2017-14017": {"epss_score": 0.00328, "epss_percentile": 0.55188}, "CVE-2017-14018": {"epss_score": 0.00142, "epss_percentile": 0.34961}, "CVE-2017-14019": {"epss_score": 0.00101, "epss_percentile": 0.28649}, "CVE-2017-14020": {"epss_score": 0.00127, "epss_percentile": 0.32923}, "CVE-2017-14021": {"epss_score": 0.00078, "epss_percentile": 0.23766}, "CVE-2017-14022": {"epss_score": 0.00035, "epss_percentile": 0.10002}, "CVE-2017-14023": {"epss_score": 0.02765, "epss_percentile": 0.85608}, "CVE-2017-14024": {"epss_score": 0.03527, "epss_percentile": 0.87296}, "CVE-2017-14025": {"epss_score": 0.00213, "epss_percentile": 0.4383}, "CVE-2017-14026": {"epss_score": 0.00404, "epss_percentile": 0.6045}, "CVE-2017-14027": {"epss_score": 0.00233, "epss_percentile": 0.4603}, "CVE-2017-14028": {"epss_score": 0.00424, "epss_percentile": 0.61674}, "CVE-2017-14029": {"epss_score": 0.00145, "epss_percentile": 0.35435}, "CVE-2017-14030": {"epss_score": 0.00096, "epss_percentile": 0.27401}, "CVE-2017-14031": {"epss_score": 0.00035, "epss_percentile": 0.09978}, "CVE-2017-14032": {"epss_score": 0.00075, "epss_percentile": 0.2294}, "CVE-2017-14033": {"epss_score": 0.07822, "epss_percentile": 0.91698}, "CVE-2017-14034": {"epss_score": 0.00521, "epss_percentile": 0.66215}, "CVE-2017-14035": {"epss_score": 0.00526, "epss_percentile": 0.66414}, "CVE-2017-14036": {"epss_score": 0.00195, "epss_percentile": 0.41686}, "CVE-2017-14037": {"epss_score": 0.00195, "epss_percentile": 0.41686}, "CVE-2017-14038": {"epss_score": 0.0014, "epss_percentile": 0.34733}, "CVE-2017-14039": {"epss_score": 0.00644, "epss_percentile": 0.70068}, "CVE-2017-14040": {"epss_score": 0.00581, "epss_percentile": 0.6826}, "CVE-2017-14041": {"epss_score": 0.00707, "epss_percentile": 0.7166}, "CVE-2017-14042": {"epss_score": 0.00707, "epss_percentile": 0.71656}, "CVE-2017-14048": {"epss_score": 0.00181, "epss_percentile": 0.40062}, "CVE-2017-14049": {"epss_score": 0.0014, "epss_percentile": 0.34683}, "CVE-2017-14050": {"epss_score": 0.00508, "epss_percentile": 0.65715}, "CVE-2017-14051": {"epss_score": 0.00065, "epss_percentile": 0.20577}, "CVE-2017-14053": {"epss_score": 0.00297, "epss_percentile": 0.5277}, "CVE-2017-14054": {"epss_score": 0.00447, "epss_percentile": 0.62945}, "CVE-2017-14055": {"epss_score": 0.00447, "epss_percentile": 0.62945}, "CVE-2017-14056": {"epss_score": 0.00447, "epss_percentile": 0.62945}, "CVE-2017-14057": {"epss_score": 0.00447, "epss_percentile": 0.62945}, "CVE-2017-14058": {"epss_score": 0.00883, "epss_percentile": 0.74921}, "CVE-2017-14059": {"epss_score": 0.00576, "epss_percentile": 0.68149}, "CVE-2017-14060": {"epss_score": 0.00476, "epss_percentile": 0.64292}, "CVE-2017-14061": {"epss_score": 0.00566, "epss_percentile": 0.67809}, "CVE-2017-14062": {"epss_score": 0.00779, "epss_percentile": 0.73142}, "CVE-2017-14063": {"epss_score": 0.01638, "epss_percentile": 0.81487}, "CVE-2017-14064": {"epss_score": 0.01477, "epss_percentile": 0.80547}, "CVE-2017-14069": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-14070": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-14075": {"epss_score": 0.00157, "epss_percentile": 0.37028}, "CVE-2017-14076": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-14077": {"epss_score": 0.00233, "epss_percentile": 0.46044}, "CVE-2017-14078": {"epss_score": 0.66335, "epss_percentile": 0.9846}, "CVE-2017-14079": {"epss_score": 0.13237, "epss_percentile": 0.93907}, "CVE-2017-14080": {"epss_score": 0.02878, "epss_percentile": 0.8589}, "CVE-2017-14081": {"epss_score": 0.13341, "epss_percentile": 0.93936}, "CVE-2017-14082": {"epss_score": 0.02743, "epss_percentile": 0.85565}, "CVE-2017-14083": {"epss_score": 0.12935, "epss_percentile": 0.93822}, "CVE-2017-14084": {"epss_score": 0.07923, "epss_percentile": 0.91764}, "CVE-2017-14085": {"epss_score": 0.12425, "epss_percentile": 0.93666}, "CVE-2017-14086": {"epss_score": 0.14233, "epss_percentile": 0.94167}, "CVE-2017-14087": {"epss_score": 0.22458, "epss_percentile": 0.95638}, "CVE-2017-14088": {"epss_score": 0.00108, "epss_percentile": 0.29877}, "CVE-2017-14089": {"epss_score": 0.31502, "epss_percentile": 0.96624}, "CVE-2017-14090": {"epss_score": 0.0029, "epss_percentile": 0.52094}, "CVE-2017-14091": {"epss_score": 0.00254, "epss_percentile": 0.48538}, "CVE-2017-14092": {"epss_score": 0.00271, "epss_percentile": 0.5034}, "CVE-2017-14093": {"epss_score": 0.00355, "epss_percentile": 0.57313}, "CVE-2017-14094": {"epss_score": 0.56266, "epss_percentile": 0.98014}, "CVE-2017-14095": {"epss_score": 0.02918, "epss_percentile": 0.85988}, "CVE-2017-14096": {"epss_score": 0.02543, "epss_percentile": 0.85057}, "CVE-2017-14097": {"epss_score": 0.16249, "epss_percentile": 0.94601}, "CVE-2017-14098": {"epss_score": 0.40123, "epss_percentile": 0.97197}, "CVE-2017-14099": {"epss_score": 0.00368, "epss_percentile": 0.5817}, "CVE-2017-14100": {"epss_score": 0.34964, "epss_percentile": 0.96879}, "CVE-2017-14101": {"epss_score": 0.00499, "epss_percentile": 0.65285}, "CVE-2017-14102": {"epss_score": 0.0005, "epss_percentile": 0.15965}, "CVE-2017-14103": {"epss_score": 0.02795, "epss_percentile": 0.85677}, "CVE-2017-14105": {"epss_score": 0.01513, "epss_percentile": 0.80791}, "CVE-2017-14106": {"epss_score": 0.00082, "epss_percentile": 0.24487}, "CVE-2017-14107": {"epss_score": 0.01193, "epss_percentile": 0.78407}, "CVE-2017-14108": {"epss_score": 0.00579, "epss_percentile": 0.68211}, "CVE-2017-14111": {"epss_score": 0.01613, "epss_percentile": 0.81341}, "CVE-2017-14114": {"epss_score": 0.00489, "epss_percentile": 0.64876}, "CVE-2017-14115": {"epss_score": 0.04024, "epss_percentile": 0.88137}, "CVE-2017-14116": {"epss_score": 0.04024, "epss_percentile": 0.88137}, "CVE-2017-14117": {"epss_score": 0.31907, "epss_percentile": 0.96658}, "CVE-2017-14118": {"epss_score": 0.03082, "epss_percentile": 0.86375}, "CVE-2017-14119": {"epss_score": 0.03082, "epss_percentile": 0.86375}, "CVE-2017-14120": {"epss_score": 0.00532, "epss_percentile": 0.66682}, "CVE-2017-14121": {"epss_score": 0.00193, "epss_percentile": 0.41442}, "CVE-2017-14122": {"epss_score": 0.00569, "epss_percentile": 0.67925}, "CVE-2017-14123": {"epss_score": 0.04422, "epss_percentile": 0.88671}, "CVE-2017-14124": {"epss_score": 0.00038, "epss_percentile": 0.11126}, "CVE-2017-14125": {"epss_score": 0.01872, "epss_percentile": 0.82641}, "CVE-2017-14126": {"epss_score": 0.0239, "epss_percentile": 0.84599}, "CVE-2017-14127": {"epss_score": 0.13505, "epss_percentile": 0.93984}, "CVE-2017-14128": {"epss_score": 0.00414, "epss_percentile": 0.61031}, "CVE-2017-14129": {"epss_score": 0.00414, "epss_percentile": 0.61031}, "CVE-2017-14130": {"epss_score": 0.00414, "epss_percentile": 0.61031}, "CVE-2017-14132": {"epss_score": 0.01042, "epss_percentile": 0.76975}, "CVE-2017-14134": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-14135": {"epss_score": 0.91421, "epss_percentile": 0.99642}, "CVE-2017-14136": {"epss_score": 0.01012, "epss_percentile": 0.76627}, "CVE-2017-14137": {"epss_score": 0.00257, "epss_percentile": 0.48883}, "CVE-2017-14138": {"epss_score": 0.00316, "epss_percentile": 0.54282}, "CVE-2017-14139": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2017-14140": {"epss_score": 0.00071, "epss_percentile": 0.22085}, "CVE-2017-14141": {"epss_score": 0.02194, "epss_percentile": 0.83949}, "CVE-2017-14142": {"epss_score": 0.00477, "epss_percentile": 0.64341}, "CVE-2017-14143": {"epss_score": 0.77447, "epss_percentile": 0.98937}, "CVE-2017-14145": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-14146": {"epss_score": 0.00717, "epss_percentile": 0.71891}, "CVE-2017-14147": {"epss_score": 0.73439, "epss_percentile": 0.98755}, "CVE-2017-14149": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2017-14151": {"epss_score": 0.0091, "epss_percentile": 0.75317}, "CVE-2017-14152": {"epss_score": 0.01089, "epss_percentile": 0.77445}, "CVE-2017-14153": {"epss_score": 0.00157, "epss_percentile": 0.37028}, "CVE-2017-14156": {"epss_score": 0.00092, "epss_percentile": 0.26446}, "CVE-2017-14158": {"epss_score": 0.00717, "epss_percentile": 0.71878}, "CVE-2017-14159": {"epss_score": 0.00123, "epss_percentile": 0.32233}, "CVE-2017-14160": {"epss_score": 0.01552, "epss_percentile": 0.80995}, "CVE-2017-14163": {"epss_score": 0.00225, "epss_percentile": 0.4522}, "CVE-2017-14164": {"epss_score": 0.00789, "epss_percentile": 0.73358}, "CVE-2017-14165": {"epss_score": 0.00642, "epss_percentile": 0.70042}, "CVE-2017-14166": {"epss_score": 0.01359, "epss_percentile": 0.79737}, "CVE-2017-14167": {"epss_score": 0.0015, "epss_percentile": 0.36183}, "CVE-2017-14169": {"epss_score": 0.00237, "epss_percentile": 0.46655}, "CVE-2017-14170": {"epss_score": 0.00416, "epss_percentile": 0.61166}, "CVE-2017-14171": {"epss_score": 0.00416, "epss_percentile": 0.61166}, "CVE-2017-14172": {"epss_score": 0.00579, "epss_percentile": 0.68225}, "CVE-2017-14173": {"epss_score": 0.01402, "epss_percentile": 0.80012}, "CVE-2017-14174": {"epss_score": 0.00646, "epss_percentile": 0.70127}, "CVE-2017-14175": {"epss_score": 0.00579, "epss_percentile": 0.68225}, "CVE-2017-14176": {"epss_score": 0.01597, "epss_percentile": 0.81243}, "CVE-2017-14177": {"epss_score": 0.00052, "epss_percentile": 0.16467}, "CVE-2017-14178": {"epss_score": 0.01172, "epss_percentile": 0.78226}, "CVE-2017-14179": {"epss_score": 0.00034, "epss_percentile": 0.0973}, "CVE-2017-14180": {"epss_score": 0.00045, "epss_percentile": 0.13788}, "CVE-2017-14181": {"epss_score": 0.00241, "epss_percentile": 0.47242}, "CVE-2017-14182": {"epss_score": 0.01458, "epss_percentile": 0.80408}, "CVE-2017-14184": {"epss_score": 0.01649, "epss_percentile": 0.81559}, "CVE-2017-14185": {"epss_score": 0.00327, "epss_percentile": 0.55148}, "CVE-2017-14186": {"epss_score": 0.04051, "epss_percentile": 0.88177}, "CVE-2017-14187": {"epss_score": 0.00068, "epss_percentile": 0.21307}, "CVE-2017-14189": {"epss_score": 0.00536, "epss_percentile": 0.66846}, "CVE-2017-14190": {"epss_score": 0.00393, "epss_percentile": 0.59724}, "CVE-2017-14191": {"epss_score": 0.00218, "epss_percentile": 0.44427}, "CVE-2017-14192": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-14193": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-14194": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-14195": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-14196": {"epss_score": 0.0052, "epss_percentile": 0.66191}, "CVE-2017-14197": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-14198": {"epss_score": 0.01487, "epss_percentile": 0.80613}, "CVE-2017-14199": {"epss_score": 0.00548, "epss_percentile": 0.67289}, "CVE-2017-14201": {"epss_score": 0.00698, "epss_percentile": 0.71425}, "CVE-2017-14202": {"epss_score": 0.00155, "epss_percentile": 0.36833}, "CVE-2017-14219": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2017-14222": {"epss_score": 0.00416, "epss_percentile": 0.61166}, "CVE-2017-14223": {"epss_score": 0.0073, "epss_percentile": 0.72162}, "CVE-2017-14224": {"epss_score": 0.01705, "epss_percentile": 0.81852}, "CVE-2017-14225": {"epss_score": 0.00356, "epss_percentile": 0.57388}, "CVE-2017-14226": {"epss_score": 0.01612, "epss_percentile": 0.81333}, "CVE-2017-14227": {"epss_score": 0.01494, "epss_percentile": 0.80644}, "CVE-2017-14228": {"epss_score": 0.00185, "epss_percentile": 0.40521}, "CVE-2017-14229": {"epss_score": 0.00744, "epss_percentile": 0.72514}, "CVE-2017-14230": {"epss_score": 0.00877, "epss_percentile": 0.74805}, "CVE-2017-14231": {"epss_score": 0.00608, "epss_percentile": 0.6908}, "CVE-2017-14232": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2017-14238": {"epss_score": 0.00342, "epss_percentile": 0.56378}, "CVE-2017-14239": {"epss_score": 0.00122, "epss_percentile": 0.32152}, "CVE-2017-14240": {"epss_score": 0.0027, "epss_percentile": 0.50193}, "CVE-2017-14241": {"epss_score": 0.00122, "epss_percentile": 0.32152}, "CVE-2017-14242": {"epss_score": 0.00342, "epss_percentile": 0.56378}, "CVE-2017-14243": {"epss_score": 0.60326, "epss_percentile": 0.98203}, "CVE-2017-14244": {"epss_score": 0.50791, "epss_percentile": 0.9775}, "CVE-2017-14245": {"epss_score": 0.00428, "epss_percentile": 0.61947}, "CVE-2017-14246": {"epss_score": 0.00519, "epss_percentile": 0.66174}, "CVE-2017-14247": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-14248": {"epss_score": 0.00281, "epss_percentile": 0.51189}, "CVE-2017-14249": {"epss_score": 0.00606, "epss_percentile": 0.69019}, "CVE-2017-14251": {"epss_score": 0.03536, "epss_percentile": 0.87311}, "CVE-2017-14252": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-14257": {"epss_score": 0.00218, "epss_percentile": 0.44358}, "CVE-2017-14258": {"epss_score": 0.00532, "epss_percentile": 0.66694}, "CVE-2017-14259": {"epss_score": 0.00461, "epss_percentile": 0.63556}, "CVE-2017-14260": {"epss_score": 0.00461, "epss_percentile": 0.63556}, "CVE-2017-14261": {"epss_score": 0.00218, "epss_percentile": 0.44358}, "CVE-2017-14262": {"epss_score": 0.21016, "epss_percentile": 0.95452}, "CVE-2017-14263": {"epss_score": 0.24422, "epss_percentile": 0.95919}, "CVE-2017-14265": {"epss_score": 0.01644, "epss_percentile": 0.8152}, "CVE-2017-14266": {"epss_score": 0.01727, "epss_percentile": 0.81967}, "CVE-2017-14267": {"epss_score": 0.00274, "epss_percentile": 0.50519}, "CVE-2017-14268": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2017-14269": {"epss_score": 0.00702, "epss_percentile": 0.71523}, "CVE-2017-14270": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14271": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14272": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14273": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14274": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14275": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14276": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14277": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14278": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14279": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14280": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14281": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14282": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14283": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14284": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14285": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14286": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14287": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14288": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14289": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14290": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14291": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14292": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14293": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14294": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14295": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14296": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14297": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14298": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14299": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14300": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14301": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14302": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14303": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14304": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14305": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14306": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14307": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14308": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14309": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14310": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14311": {"epss_score": 0.00321, "epss_percentile": 0.54693}, "CVE-2017-14312": {"epss_score": 0.00094, "epss_percentile": 0.27045}, "CVE-2017-14313": {"epss_score": 0.01345, "epss_percentile": 0.79626}, "CVE-2017-14314": {"epss_score": 0.00758, "epss_percentile": 0.72775}, "CVE-2017-14315": {"epss_score": 0.00101, "epss_percentile": 0.28648}, "CVE-2017-14316": {"epss_score": 0.00072, "epss_percentile": 0.22363}, "CVE-2017-14317": {"epss_score": 0.00141, "epss_percentile": 0.34854}, "CVE-2017-14318": {"epss_score": 0.00196, "epss_percentile": 0.4174}, "CVE-2017-14319": {"epss_score": 0.00072, "epss_percentile": 0.22363}, "CVE-2017-14320": {"epss_score": 0.00836, "epss_percentile": 0.74141}, "CVE-2017-14321": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2017-14322": {"epss_score": 0.26136, "epss_percentile": 0.96116}, "CVE-2017-14323": {"epss_score": 0.0695, "epss_percentile": 0.91138}, "CVE-2017-14324": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2017-14325": {"epss_score": 0.00618, "epss_percentile": 0.69372}, "CVE-2017-14326": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2017-14327": {"epss_score": 0.00059, "epss_percentile": 0.18661}, "CVE-2017-14328": {"epss_score": 0.00578, "epss_percentile": 0.68193}, "CVE-2017-14329": {"epss_score": 0.00036, "epss_percentile": 0.10495}, "CVE-2017-14330": {"epss_score": 0.00036, "epss_percentile": 0.10495}, "CVE-2017-14331": {"epss_score": 0.00043, "epss_percentile": 0.13026}, "CVE-2017-14332": {"epss_score": 0.00499, "epss_percentile": 0.65247}, "CVE-2017-14333": {"epss_score": 0.00266, "epss_percentile": 0.49886}, "CVE-2017-14335": {"epss_score": 0.20179, "epss_percentile": 0.953}, "CVE-2017-14337": {"epss_score": 0.00624, "epss_percentile": 0.69555}, "CVE-2017-14339": {"epss_score": 0.0083, "epss_percentile": 0.74018}, "CVE-2017-14340": {"epss_score": 0.00039, "epss_percentile": 0.1163}, "CVE-2017-14341": {"epss_score": 0.00527, "epss_percentile": 0.6652}, "CVE-2017-14342": {"epss_score": 0.00266, "epss_percentile": 0.49925}, "CVE-2017-14343": {"epss_score": 0.00406, "epss_percentile": 0.60515}, "CVE-2017-14344": {"epss_score": 0.00107, "epss_percentile": 0.29582}, "CVE-2017-14345": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-14346": {"epss_score": 0.00966, "epss_percentile": 0.76053}, "CVE-2017-14347": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-14348": {"epss_score": 0.00785, "epss_percentile": 0.73257}, "CVE-2017-14349": {"epss_score": 0.00759, "epss_percentile": 0.72784}, "CVE-2017-14350": {"epss_score": 0.01132, "epss_percentile": 0.7787}, "CVE-2017-14351": {"epss_score": 0.02565, "epss_percentile": 0.85115}, "CVE-2017-14352": {"epss_score": 0.00362, "epss_percentile": 0.57751}, "CVE-2017-14353": {"epss_score": 0.01361, "epss_percentile": 0.79754}, "CVE-2017-14354": {"epss_score": 0.00478, "epss_percentile": 0.64389}, "CVE-2017-14355": {"epss_score": 0.00353, "epss_percentile": 0.57164}, "CVE-2017-14356": {"epss_score": 0.00527, "epss_percentile": 0.66526}, "CVE-2017-14357": {"epss_score": 0.00362, "epss_percentile": 0.57751}, "CVE-2017-14358": {"epss_score": 0.00249, "epss_percentile": 0.48017}, "CVE-2017-14359": {"epss_score": 0.00239, "epss_percentile": 0.46864}, "CVE-2017-14360": {"epss_score": 0.00501, "epss_percentile": 0.65368}, "CVE-2017-14361": {"epss_score": 0.00247, "epss_percentile": 0.47901}, "CVE-2017-14362": {"epss_score": 0.00119, "epss_percentile": 0.31635}, "CVE-2017-14363": {"epss_score": 0.00172, "epss_percentile": 0.38906}, "CVE-2017-14369": {"epss_score": 0.00229, "epss_percentile": 0.45659}, "CVE-2017-14370": {"epss_score": 0.0028, "epss_percentile": 0.51068}, "CVE-2017-14371": {"epss_score": 0.00335, "epss_percentile": 0.55816}, "CVE-2017-14372": {"epss_score": 0.00335, "epss_percentile": 0.55816}, "CVE-2017-14373": {"epss_score": 0.0025, "epss_percentile": 0.48126}, "CVE-2017-14374": {"epss_score": 0.00714, "epss_percentile": 0.71805}, "CVE-2017-14375": {"epss_score": 0.0205, "epss_percentile": 0.83399}, "CVE-2017-14376": {"epss_score": 0.00049, "epss_percentile": 0.1536}, "CVE-2017-14377": {"epss_score": 0.02676, "epss_percentile": 0.85404}, "CVE-2017-14378": {"epss_score": 0.0196, "epss_percentile": 0.83056}, "CVE-2017-14379": {"epss_score": 0.00214, "epss_percentile": 0.44012}, "CVE-2017-14380": {"epss_score": 0.00059, "epss_percentile": 0.18725}, "CVE-2017-14383": {"epss_score": 0.00177, "epss_percentile": 0.39614}, "CVE-2017-14384": {"epss_score": 0.04601, "epss_percentile": 0.88903}, "CVE-2017-14385": {"epss_score": 0.0915, "epss_percentile": 0.92422}, "CVE-2017-14386": {"epss_score": 0.00307, "epss_percentile": 0.5352}, "CVE-2017-14387": {"epss_score": 0.00299, "epss_percentile": 0.52875}, "CVE-2017-14388": {"epss_score": 0.00182, "epss_percentile": 0.40142}, "CVE-2017-14389": {"epss_score": 0.00183, "epss_percentile": 0.403}, "CVE-2017-14390": {"epss_score": 0.00573, "epss_percentile": 0.68059}, "CVE-2017-14394": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2017-14395": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2017-14396": {"epss_score": 0.01968, "epss_percentile": 0.83088}, "CVE-2017-14397": {"epss_score": 0.00486, "epss_percentile": 0.64774}, "CVE-2017-14398": {"epss_score": 0.0005, "epss_percentile": 0.15965}, "CVE-2017-14399": {"epss_score": 0.00381, "epss_percentile": 0.58996}, "CVE-2017-14400": {"epss_score": 0.00487, "epss_percentile": 0.64803}, "CVE-2017-14401": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-14402": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-14403": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-14404": {"epss_score": 0.00325, "epss_percentile": 0.54978}, "CVE-2017-14405": {"epss_score": 0.06852, "epss_percentile": 0.91073}, "CVE-2017-14406": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2017-14407": {"epss_score": 0.00464, "epss_percentile": 0.63726}, "CVE-2017-14408": {"epss_score": 0.00435, "epss_percentile": 0.62372}, "CVE-2017-14409": {"epss_score": 0.01325, "epss_percentile": 0.79469}, "CVE-2017-14410": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2017-14411": {"epss_score": 0.00723, "epss_percentile": 0.72016}, "CVE-2017-14412": {"epss_score": 0.00189, "epss_percentile": 0.40928}, "CVE-2017-14413": {"epss_score": 0.00248, "epss_percentile": 0.47963}, "CVE-2017-14414": {"epss_score": 0.00248, "epss_percentile": 0.47963}, "CVE-2017-14415": {"epss_score": 0.00248, "epss_percentile": 0.47963}, "CVE-2017-14416": {"epss_score": 0.00248, "epss_percentile": 0.47963}, "CVE-2017-14417": {"epss_score": 0.00691, "epss_percentile": 0.71275}, "CVE-2017-14418": {"epss_score": 0.00773, "epss_percentile": 0.73052}, "CVE-2017-14419": {"epss_score": 0.00465, "epss_percentile": 0.63744}, "CVE-2017-14420": {"epss_score": 0.00213, "epss_percentile": 0.4383}, "CVE-2017-14421": {"epss_score": 0.04942, "epss_percentile": 0.89309}, "CVE-2017-14422": {"epss_score": 0.00424, "epss_percentile": 0.61641}, "CVE-2017-14423": {"epss_score": 0.00234, "epss_percentile": 0.46119}, "CVE-2017-14424": {"epss_score": 0.00061, "epss_percentile": 0.19518}, "CVE-2017-14425": {"epss_score": 0.00061, "epss_percentile": 0.19518}, "CVE-2017-14426": {"epss_score": 0.00061, "epss_percentile": 0.19518}, "CVE-2017-14427": {"epss_score": 0.00061, "epss_percentile": 0.19518}, "CVE-2017-14428": {"epss_score": 0.00061, "epss_percentile": 0.19518}, "CVE-2017-14429": {"epss_score": 0.03411, "epss_percentile": 0.87083}, "CVE-2017-14430": {"epss_score": 0.00635, "epss_percentile": 0.69818}, "CVE-2017-14431": {"epss_score": 0.00127, "epss_percentile": 0.32881}, "CVE-2017-14432": {"epss_score": 0.02733, "epss_percentile": 0.85546}, "CVE-2017-14433": {"epss_score": 0.02733, "epss_percentile": 0.85546}, "CVE-2017-14434": {"epss_score": 0.02733, "epss_percentile": 0.85546}, "CVE-2017-14435": {"epss_score": 0.02218, "epss_percentile": 0.84041}, "CVE-2017-14436": {"epss_score": 0.02218, "epss_percentile": 0.84041}, "CVE-2017-14437": {"epss_score": 0.02218, "epss_percentile": 0.84041}, "CVE-2017-14438": {"epss_score": 0.01039, "epss_percentile": 0.76948}, "CVE-2017-14439": {"epss_score": 0.01039, "epss_percentile": 0.76948}, "CVE-2017-14440": {"epss_score": 0.01953, "epss_percentile": 0.83026}, "CVE-2017-14441": {"epss_score": 0.0132, "epss_percentile": 0.79437}, "CVE-2017-14442": {"epss_score": 0.01548, "epss_percentile": 0.80978}, "CVE-2017-14443": {"epss_score": 0.00543, "epss_percentile": 0.67101}, "CVE-2017-14444": {"epss_score": 0.00383, "epss_percentile": 0.59108}, "CVE-2017-14445": {"epss_score": 0.00383, "epss_percentile": 0.59108}, "CVE-2017-14446": {"epss_score": 0.00383, "epss_percentile": 0.59108}, "CVE-2017-14447": {"epss_score": 0.00575, "epss_percentile": 0.68116}, "CVE-2017-14448": {"epss_score": 0.01672, "epss_percentile": 0.8168}, "CVE-2017-14449": {"epss_score": 0.00607, "epss_percentile": 0.69042}, "CVE-2017-14450": {"epss_score": 0.00766, "epss_percentile": 0.72941}, "CVE-2017-14451": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2017-14452": {"epss_score": 0.00425, "epss_percentile": 0.61727}, "CVE-2017-14453": {"epss_score": 0.00524, "epss_percentile": 0.66326}, "CVE-2017-14454": {"epss_score": 0.00132, "epss_percentile": 0.33594}, "CVE-2017-14455": {"epss_score": 0.00886, "epss_percentile": 0.74952}, "CVE-2017-14457": {"epss_score": 0.00286, "epss_percentile": 0.51763}, "CVE-2017-14458": {"epss_score": 0.00864, "epss_percentile": 0.74607}, "CVE-2017-14459": {"epss_score": 0.19799, "epss_percentile": 0.95243}, "CVE-2017-14460": {"epss_score": 0.00493, "epss_percentile": 0.65025}, "CVE-2017-14461": {"epss_score": 0.01746, "epss_percentile": 0.82071}, "CVE-2017-14462": {"epss_score": 0.36951, "epss_percentile": 0.97011}, "CVE-2017-14463": {"epss_score": 0.36951, "epss_percentile": 0.97011}, "CVE-2017-14464": {"epss_score": 0.36951, "epss_percentile": 0.97011}, "CVE-2017-14465": {"epss_score": 0.42565, "epss_percentile": 0.97341}, "CVE-2017-14466": {"epss_score": 0.42565, "epss_percentile": 0.97341}, "CVE-2017-14467": {"epss_score": 0.61377, "epss_percentile": 0.98245}, "CVE-2017-14468": {"epss_score": 0.42565, "epss_percentile": 0.97341}, "CVE-2017-14469": {"epss_score": 0.36951, "epss_percentile": 0.97011}, "CVE-2017-14470": {"epss_score": 0.42565, "epss_percentile": 0.97341}, "CVE-2017-14471": {"epss_score": 0.42565, "epss_percentile": 0.97341}, "CVE-2017-14472": {"epss_score": 0.42565, "epss_percentile": 0.97341}, "CVE-2017-14473": {"epss_score": 0.42565, "epss_percentile": 0.97341}, "CVE-2017-14474": {"epss_score": 0.08861, "epss_percentile": 0.9229}, "CVE-2017-14475": {"epss_score": 0.08861, "epss_percentile": 0.9229}, "CVE-2017-14476": {"epss_score": 0.08861, "epss_percentile": 0.9229}, "CVE-2017-14477": {"epss_score": 0.08861, "epss_percentile": 0.9229}, "CVE-2017-14478": {"epss_score": 0.08861, "epss_percentile": 0.9229}, "CVE-2017-14479": {"epss_score": 0.08861, "epss_percentile": 0.9229}, "CVE-2017-14480": {"epss_score": 0.08861, "epss_percentile": 0.9229}, "CVE-2017-14481": {"epss_score": 0.07445, "epss_percentile": 0.91475}, "CVE-2017-14482": {"epss_score": 0.04583, "epss_percentile": 0.88881}, "CVE-2017-14483": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2017-14484": {"epss_score": 0.0003, "epss_percentile": 0.07984}, "CVE-2017-14486": {"epss_score": 0.00147, "epss_percentile": 0.35776}, "CVE-2017-14487": {"epss_score": 0.00249, "epss_percentile": 0.48017}, "CVE-2017-14489": {"epss_score": 0.00273, "epss_percentile": 0.50453}, "CVE-2017-14491": {"epss_score": 0.60192, "epss_percentile": 0.98196}, "CVE-2017-14492": {"epss_score": 0.92641, "epss_percentile": 0.99732}, "CVE-2017-14493": {"epss_score": 0.05615, "epss_percentile": 0.90054}, "CVE-2017-14494": {"epss_score": 0.13046, "epss_percentile": 0.93856}, "CVE-2017-14495": {"epss_score": 0.60149, "epss_percentile": 0.98194}, "CVE-2017-14496": {"epss_score": 0.15737, "epss_percentile": 0.94496}, "CVE-2017-14497": {"epss_score": 0.00086, "epss_percentile": 0.25245}, "CVE-2017-14498": {"epss_score": 0.00375, "epss_percentile": 0.58628}, "CVE-2017-14500": {"epss_score": 0.01502, "epss_percentile": 0.80721}, "CVE-2017-14501": {"epss_score": 0.00673, "epss_percentile": 0.70831}, "CVE-2017-14502": {"epss_score": 0.01199, "epss_percentile": 0.78457}, "CVE-2017-14503": {"epss_score": 0.00666, "epss_percentile": 0.70688}, "CVE-2017-14504": {"epss_score": 0.01, "epss_percentile": 0.76486}, "CVE-2017-14505": {"epss_score": 0.00435, "epss_percentile": 0.62349}, "CVE-2017-14506": {"epss_score": 0.00222, "epss_percentile": 0.44803}, "CVE-2017-14507": {"epss_score": 0.07947, "epss_percentile": 0.91782}, "CVE-2017-14508": {"epss_score": 0.00536, "epss_percentile": 0.66862}, "CVE-2017-14509": {"epss_score": 0.0079, "epss_percentile": 0.7337}, "CVE-2017-14510": {"epss_score": 0.00341, "epss_percentile": 0.563}, "CVE-2017-14511": {"epss_score": 0.00529, "epss_percentile": 0.6658}, "CVE-2017-14512": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-14513": {"epss_score": 0.0014, "epss_percentile": 0.34766}, "CVE-2017-14514": {"epss_score": 0.00407, "epss_percentile": 0.60576}, "CVE-2017-14515": {"epss_score": 0.00653, "epss_percentile": 0.70324}, "CVE-2017-14516": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-14517": {"epss_score": 0.00411, "epss_percentile": 0.60897}, "CVE-2017-14518": {"epss_score": 0.00348, "epss_percentile": 0.56802}, "CVE-2017-14519": {"epss_score": 0.00435, "epss_percentile": 0.62381}, "CVE-2017-14520": {"epss_score": 0.00285, "epss_percentile": 0.51684}, "CVE-2017-14521": {"epss_score": 0.03643, "epss_percentile": 0.87495}, "CVE-2017-14522": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2017-14523": {"epss_score": 0.11226, "epss_percentile": 0.9327}, "CVE-2017-14524": {"epss_score": 0.05987, "epss_percentile": 0.90383}, "CVE-2017-14525": {"epss_score": 0.0018, "epss_percentile": 0.3991}, "CVE-2017-14526": {"epss_score": 0.00646, "epss_percentile": 0.70132}, "CVE-2017-14527": {"epss_score": 0.00558, "epss_percentile": 0.67583}, "CVE-2017-14528": {"epss_score": 0.00776, "epss_percentile": 0.73105}, "CVE-2017-14529": {"epss_score": 0.00414, "epss_percentile": 0.61031}, "CVE-2017-14530": {"epss_score": 0.00111, "epss_percentile": 0.30401}, "CVE-2017-14531": {"epss_score": 0.00707, "epss_percentile": 0.71656}, "CVE-2017-14532": {"epss_score": 0.01511, "epss_percentile": 0.80776}, "CVE-2017-14533": {"epss_score": 0.00467, "epss_percentile": 0.63816}, "CVE-2017-14534": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-14535": {"epss_score": 0.91276, "epss_percentile": 0.99631}, "CVE-2017-14536": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2017-14537": {"epss_score": 0.91358, "epss_percentile": 0.99636}, "CVE-2017-14538": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14539": {"epss_score": 0.00136, "epss_percentile": 0.34196}, "CVE-2017-14540": {"epss_score": 0.00136, "epss_percentile": 0.34196}, "CVE-2017-14541": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14542": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14543": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14544": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14545": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14546": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14547": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14548": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14549": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14550": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14551": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14552": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14553": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14554": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14555": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14556": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14557": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14558": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14559": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14560": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14561": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14562": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14563": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14564": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14565": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14566": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14567": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14568": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14569": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14570": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14571": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14572": {"epss_score": 0.00116, "epss_percentile": 0.31199}, "CVE-2017-14573": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14574": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14575": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14576": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14577": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14578": {"epss_score": 0.00136, "epss_percentile": 0.34196}, "CVE-2017-14579": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14580": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14581": {"epss_score": 0.00796, "epss_percentile": 0.73484}, "CVE-2017-14582": {"epss_score": 0.00237, "epss_percentile": 0.46657}, "CVE-2017-14583": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2017-14585": {"epss_score": 0.01753, "epss_percentile": 0.82114}, "CVE-2017-14586": {"epss_score": 0.02514, "epss_percentile": 0.84979}, "CVE-2017-14587": {"epss_score": 0.00196, "epss_percentile": 0.41712}, "CVE-2017-14588": {"epss_score": 0.00239, "epss_percentile": 0.46916}, "CVE-2017-14589": {"epss_score": 0.00438, "epss_percentile": 0.62548}, "CVE-2017-14590": {"epss_score": 0.00488, "epss_percentile": 0.6483}, "CVE-2017-14591": {"epss_score": 0.00652, "epss_percentile": 0.70312}, "CVE-2017-14592": {"epss_score": 0.02133, "epss_percentile": 0.83718}, "CVE-2017-14593": {"epss_score": 0.02133, "epss_percentile": 0.83718}, "CVE-2017-14594": {"epss_score": 0.00225, "epss_percentile": 0.45097}, "CVE-2017-14595": {"epss_score": 0.00026, "epss_percentile": 0.0662}, "CVE-2017-14596": {"epss_score": 0.02572, "epss_percentile": 0.85132}, "CVE-2017-14597": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2017-14600": {"epss_score": 0.00305, "epss_percentile": 0.53333}, "CVE-2017-14601": {"epss_score": 0.00305, "epss_percentile": 0.53333}, "CVE-2017-14602": {"epss_score": 0.01175, "epss_percentile": 0.78258}, "CVE-2017-14603": {"epss_score": 0.00747, "epss_percentile": 0.7256}, "CVE-2017-14604": {"epss_score": 0.03908, "epss_percentile": 0.87931}, "CVE-2017-14607": {"epss_score": 0.01676, "epss_percentile": 0.81706}, "CVE-2017-14608": {"epss_score": 0.00375, "epss_percentile": 0.58628}, "CVE-2017-14609": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2017-14610": {"epss_score": 0.00043, "epss_percentile": 0.13072}, "CVE-2017-14611": {"epss_score": 0.00297, "epss_percentile": 0.52714}, "CVE-2017-14612": {"epss_score": 0.00128, "epss_percentile": 0.33}, "CVE-2017-14614": {"epss_score": 0.00485, "epss_percentile": 0.64712}, "CVE-2017-14615": {"epss_score": 0.00356, "epss_percentile": 0.57393}, "CVE-2017-14616": {"epss_score": 0.00826, "epss_percentile": 0.73964}, "CVE-2017-14617": {"epss_score": 0.00525, "epss_percentile": 0.66377}, "CVE-2017-14618": {"epss_score": 0.00552, "epss_percentile": 0.67401}, "CVE-2017-14619": {"epss_score": 0.01062, "epss_percentile": 0.7718}, "CVE-2017-14620": {"epss_score": 0.01265, "epss_percentile": 0.79002}, "CVE-2017-14621": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-14622": {"epss_score": 0.01358, "epss_percentile": 0.79729}, "CVE-2017-14623": {"epss_score": 0.00329, "epss_percentile": 0.55309}, "CVE-2017-14624": {"epss_score": 0.01511, "epss_percentile": 0.80776}, "CVE-2017-14625": {"epss_score": 0.01511, "epss_percentile": 0.80776}, "CVE-2017-14626": {"epss_score": 0.01117, "epss_percentile": 0.77724}, "CVE-2017-14627": {"epss_score": 0.50197, "epss_percentile": 0.97724}, "CVE-2017-14628": {"epss_score": 0.00427, "epss_percentile": 0.61889}, "CVE-2017-14629": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2017-14630": {"epss_score": 0.00403, "epss_percentile": 0.60364}, "CVE-2017-14631": {"epss_score": 0.00427, "epss_percentile": 0.61889}, "CVE-2017-14632": {"epss_score": 0.06507, "epss_percentile": 0.90808}, "CVE-2017-14633": {"epss_score": 0.01001, "epss_percentile": 0.76497}, "CVE-2017-14634": {"epss_score": 0.01154, "epss_percentile": 0.78064}, "CVE-2017-14635": {"epss_score": 0.00725, "epss_percentile": 0.72047}, "CVE-2017-14636": {"epss_score": 0.00378, "epss_percentile": 0.58787}, "CVE-2017-14637": {"epss_score": 0.00403, "epss_percentile": 0.60364}, "CVE-2017-14638": {"epss_score": 0.00572, "epss_percentile": 0.68017}, "CVE-2017-14639": {"epss_score": 0.0087, "epss_percentile": 0.74708}, "CVE-2017-14640": {"epss_score": 0.00521, "epss_percentile": 0.66227}, "CVE-2017-14641": {"epss_score": 0.00563, "epss_percentile": 0.67736}, "CVE-2017-14642": {"epss_score": 0.00488, "epss_percentile": 0.64846}, "CVE-2017-14643": {"epss_score": 0.00534, "epss_percentile": 0.66795}, "CVE-2017-14644": {"epss_score": 0.00865, "epss_percentile": 0.74617}, "CVE-2017-14645": {"epss_score": 0.00333, "epss_percentile": 0.55672}, "CVE-2017-14646": {"epss_score": 0.00896, "epss_percentile": 0.75121}, "CVE-2017-14647": {"epss_score": 0.01148, "epss_percentile": 0.78012}, "CVE-2017-14648": {"epss_score": 0.0229, "epss_percentile": 0.84281}, "CVE-2017-14649": {"epss_score": 0.00466, "epss_percentile": 0.63798}, "CVE-2017-14650": {"epss_score": 0.02995, "epss_percentile": 0.86155}, "CVE-2017-14651": {"epss_score": 0.07641, "epss_percentile": 0.91595}, "CVE-2017-14652": {"epss_score": 0.01398, "epss_percentile": 0.79989}, "CVE-2017-14653": {"epss_score": 0.00214, "epss_percentile": 0.43958}, "CVE-2017-14680": {"epss_score": 0.10118, "epss_percentile": 0.92856}, "CVE-2017-14681": {"epss_score": 0.00048, "epss_percentile": 0.15028}, "CVE-2017-14682": {"epss_score": 0.00451, "epss_percentile": 0.63115}, "CVE-2017-14683": {"epss_score": 0.00121, "epss_percentile": 0.31919}, "CVE-2017-14684": {"epss_score": 0.00218, "epss_percentile": 0.44426}, "CVE-2017-14685": {"epss_score": 0.00247, "epss_percentile": 0.47891}, "CVE-2017-14686": {"epss_score": 0.00711, "epss_percentile": 0.71741}, "CVE-2017-14687": {"epss_score": 0.00272, "epss_percentile": 0.50364}, "CVE-2017-14688": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14689": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14690": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14691": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14692": {"epss_score": 0.00059, "epss_percentile": 0.18898}, "CVE-2017-14693": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2017-14694": {"epss_score": 0.00064, "epss_percentile": 0.20196}, "CVE-2017-14695": {"epss_score": 0.00331, "epss_percentile": 0.55508}, "CVE-2017-14696": {"epss_score": 0.01854, "epss_percentile": 0.82556}, "CVE-2017-14698": {"epss_score": 0.00452, "epss_percentile": 0.63191}, "CVE-2017-14699": {"epss_score": 0.00315, "epss_percentile": 0.54186}, "CVE-2017-14702": {"epss_score": 0.12371, "epss_percentile": 0.93653}, "CVE-2017-14703": {"epss_score": 0.01493, "epss_percentile": 0.80641}, "CVE-2017-14704": {"epss_score": 0.01912, "epss_percentile": 0.82831}, "CVE-2017-14705": {"epss_score": 0.04356, "epss_percentile": 0.8859}, "CVE-2017-14706": {"epss_score": 0.72371, "epss_percentile": 0.98706}, "CVE-2017-14709": {"epss_score": 0.00117, "epss_percentile": 0.31371}, "CVE-2017-14710": {"epss_score": 0.00133, "epss_percentile": 0.33654}, "CVE-2017-14711": {"epss_score": 0.00206, "epss_percentile": 0.42768}, "CVE-2017-14712": {"epss_score": 0.00358, "epss_percentile": 0.57488}, "CVE-2017-14713": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-14714": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-14715": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-14716": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-14717": {"epss_score": 0.00358, "epss_percentile": 0.57488}, "CVE-2017-14718": {"epss_score": 0.02645, "epss_percentile": 0.85322}, "CVE-2017-14719": {"epss_score": 0.50739, "epss_percentile": 0.97747}, "CVE-2017-14720": {"epss_score": 0.02645, "epss_percentile": 0.85322}, "CVE-2017-14721": {"epss_score": 0.02645, "epss_percentile": 0.85322}, "CVE-2017-14722": {"epss_score": 0.30547, "epss_percentile": 0.9655}, "CVE-2017-14723": {"epss_score": 0.10428, "epss_percentile": 0.92984}, "CVE-2017-14724": {"epss_score": 0.07679, "epss_percentile": 0.91621}, "CVE-2017-14725": {"epss_score": 0.02353, "epss_percentile": 0.84476}, "CVE-2017-14726": {"epss_score": 0.04614, "epss_percentile": 0.8892}, "CVE-2017-14727": {"epss_score": 0.00658, "epss_percentile": 0.7049}, "CVE-2017-14728": {"epss_score": 0.10781, "epss_percentile": 0.93101}, "CVE-2017-14729": {"epss_score": 0.00301, "epss_percentile": 0.53045}, "CVE-2017-14730": {"epss_score": 0.00045, "epss_percentile": 0.13744}, "CVE-2017-14731": {"epss_score": 0.00318, "epss_percentile": 0.54404}, "CVE-2017-14733": {"epss_score": 0.01424, "epss_percentile": 0.80193}, "CVE-2017-14734": {"epss_score": 0.01674, "epss_percentile": 0.81698}, "CVE-2017-14735": {"epss_score": 0.00688, "epss_percentile": 0.71195}, "CVE-2017-14737": {"epss_score": 0.00052, "epss_percentile": 0.16379}, "CVE-2017-14738": {"epss_score": 0.06269, "epss_percentile": 0.90627}, "CVE-2017-14739": {"epss_score": 0.00696, "epss_percentile": 0.71386}, "CVE-2017-14740": {"epss_score": 0.00171, "epss_percentile": 0.38899}, "CVE-2017-14741": {"epss_score": 0.00375, "epss_percentile": 0.58624}, "CVE-2017-14742": {"epss_score": 0.00997, "epss_percentile": 0.76462}, "CVE-2017-14743": {"epss_score": 0.00447, "epss_percentile": 0.62989}, "CVE-2017-14744": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-14745": {"epss_score": 0.00388, "epss_percentile": 0.59398}, "CVE-2017-14746": {"epss_score": 0.41219, "epss_percentile": 0.9726}, "CVE-2017-14748": {"epss_score": 0.00416, "epss_percentile": 0.61198}, "CVE-2017-14749": {"epss_score": 0.00607, "epss_percentile": 0.69061}, "CVE-2017-14751": {"epss_score": 0.00235, "epss_percentile": 0.46313}, "CVE-2017-14752": {"epss_score": 0.00296, "epss_percentile": 0.52622}, "CVE-2017-14753": {"epss_score": 0.00152, "epss_percentile": 0.36374}, "CVE-2017-14754": {"epss_score": 0.00373, "epss_percentile": 0.58466}, "CVE-2017-14755": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-14756": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-14757": {"epss_score": 0.00329, "epss_percentile": 0.55304}, "CVE-2017-14758": {"epss_score": 0.00329, "epss_percentile": 0.55304}, "CVE-2017-14759": {"epss_score": 0.00464, "epss_percentile": 0.63734}, "CVE-2017-14760": {"epss_score": 0.00518, "epss_percentile": 0.66097}, "CVE-2017-14761": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-14762": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-14763": {"epss_score": 0.00701, "epss_percentile": 0.715}, "CVE-2017-14764": {"epss_score": 0.00829, "epss_percentile": 0.74007}, "CVE-2017-14765": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-14766": {"epss_score": 0.00408, "epss_percentile": 0.60678}, "CVE-2017-14767": {"epss_score": 0.00672, "epss_percentile": 0.70814}, "CVE-2017-14770": {"epss_score": 0.00163, "epss_percentile": 0.37822}, "CVE-2017-14771": {"epss_score": 0.00124, "epss_percentile": 0.3246}, "CVE-2017-14772": {"epss_score": 0.00262, "epss_percentile": 0.49399}, "CVE-2017-14773": {"epss_score": 0.00156, "epss_percentile": 0.3695}, "CVE-2017-14775": {"epss_score": 0.00289, "epss_percentile": 0.52036}, "CVE-2017-14795": {"epss_score": 0.00521, "epss_percentile": 0.66237}, "CVE-2017-14796": {"epss_score": 0.00606, "epss_percentile": 0.68998}, "CVE-2017-14797": {"epss_score": 0.00038, "epss_percentile": 0.11099}, "CVE-2017-14798": {"epss_score": 0.01186, "epss_percentile": 0.78345}, "CVE-2017-14799": {"epss_score": 0.00182, "epss_percentile": 0.40158}, "CVE-2017-14800": {"epss_score": 0.00199, "epss_percentile": 0.42171}, "CVE-2017-14801": {"epss_score": 0.00182, "epss_percentile": 0.40158}, "CVE-2017-14802": {"epss_score": 0.00211, "epss_percentile": 0.43644}, "CVE-2017-14803": {"epss_score": 0.00892, "epss_percentile": 0.75068}, "CVE-2017-14804": {"epss_score": 0.00431, "epss_percentile": 0.62065}, "CVE-2017-14806": {"epss_score": 0.00114, "epss_percentile": 0.30843}, "CVE-2017-14807": {"epss_score": 0.00171, "epss_percentile": 0.38791}, "CVE-2017-14818": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2017-14819": {"epss_score": 0.0019, "epss_percentile": 0.41125}, "CVE-2017-14820": {"epss_score": 0.0019, "epss_percentile": 0.41125}, "CVE-2017-14821": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2017-14822": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2017-14823": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-14824": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-14825": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-14826": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-14827": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-14828": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-14829": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-14830": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-14831": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-14832": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-14833": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-14834": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-14835": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-14836": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-14837": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-14838": {"epss_score": 0.02389, "epss_percentile": 0.84595}, "CVE-2017-14839": {"epss_score": 0.02389, "epss_percentile": 0.84595}, "CVE-2017-14840": {"epss_score": 0.02389, "epss_percentile": 0.84595}, "CVE-2017-14841": {"epss_score": 0.01677, "epss_percentile": 0.81717}, "CVE-2017-14842": {"epss_score": 0.00749, "epss_percentile": 0.72603}, "CVE-2017-14843": {"epss_score": 0.00749, "epss_percentile": 0.72603}, "CVE-2017-14844": {"epss_score": 0.00749, "epss_percentile": 0.72603}, "CVE-2017-14845": {"epss_score": 0.00749, "epss_percentile": 0.72603}, "CVE-2017-14846": {"epss_score": 0.00749, "epss_percentile": 0.72603}, "CVE-2017-14847": {"epss_score": 0.00749, "epss_percentile": 0.72603}, "CVE-2017-14848": {"epss_score": 0.00666, "epss_percentile": 0.70675}, "CVE-2017-14849": {"epss_score": 0.90232, "epss_percentile": 0.99571}, "CVE-2017-14850": {"epss_score": 0.00444, "epss_percentile": 0.62843}, "CVE-2017-14851": {"epss_score": 0.05067, "epss_percentile": 0.89459}, "CVE-2017-14852": {"epss_score": 0.00713, "epss_percentile": 0.71784}, "CVE-2017-14853": {"epss_score": 0.01832, "epss_percentile": 0.82456}, "CVE-2017-14854": {"epss_score": 0.14509, "epss_percentile": 0.94226}, "CVE-2017-14855": {"epss_score": 0.00619, "epss_percentile": 0.69396}, "CVE-2017-14857": {"epss_score": 0.00261, "epss_percentile": 0.49264}, "CVE-2017-14858": {"epss_score": 0.00274, "epss_percentile": 0.50525}, "CVE-2017-14859": {"epss_score": 0.00099, "epss_percentile": 0.28318}, "CVE-2017-14860": {"epss_score": 0.00298, "epss_percentile": 0.52776}, "CVE-2017-14861": {"epss_score": 0.00367, "epss_percentile": 0.58099}, "CVE-2017-14862": {"epss_score": 0.00099, "epss_percentile": 0.28318}, "CVE-2017-14863": {"epss_score": 0.00278, "epss_percentile": 0.50901}, "CVE-2017-14864": {"epss_score": 0.00099, "epss_percentile": 0.28318}, "CVE-2017-14865": {"epss_score": 0.00309, "epss_percentile": 0.53653}, "CVE-2017-14866": {"epss_score": 0.00274, "epss_percentile": 0.50525}, "CVE-2017-14867": {"epss_score": 0.06968, "epss_percentile": 0.91153}, "CVE-2017-14868": {"epss_score": 0.0038, "epss_percentile": 0.58954}, "CVE-2017-14869": {"epss_score": 0.00086, "epss_percentile": 0.25289}, "CVE-2017-14870": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-14872": {"epss_score": 0.00041, "epss_percentile": 0.12425}, "CVE-2017-14873": {"epss_score": 0.00042, "epss_percentile": 0.12579}, "CVE-2017-14875": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-14876": {"epss_score": 0.00168, "epss_percentile": 0.38496}, "CVE-2017-14877": {"epss_score": 0.00198, "epss_percentile": 0.41991}, "CVE-2017-14878": {"epss_score": 0.00341, "epss_percentile": 0.56296}, "CVE-2017-14879": {"epss_score": 0.00084, "epss_percentile": 0.25013}, "CVE-2017-14880": {"epss_score": 0.00013, "epss_percentile": 0.01515}, "CVE-2017-14881": {"epss_score": 0.00198, "epss_percentile": 0.41991}, "CVE-2017-14882": {"epss_score": 0.00515, "epss_percentile": 0.65971}, "CVE-2017-14883": {"epss_score": 0.00182, "epss_percentile": 0.40154}, "CVE-2017-14884": {"epss_score": 0.00017, "epss_percentile": 0.0312}, "CVE-2017-14885": {"epss_score": 0.00029, "epss_percentile": 0.07976}, "CVE-2017-14887": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-14888": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-14889": {"epss_score": 0.00017, "epss_percentile": 0.0322}, "CVE-2017-14890": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2017-14891": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-14892": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-14893": {"epss_score": 0.00041, "epss_percentile": 0.12425}, "CVE-2017-14894": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2017-14895": {"epss_score": 0.00013, "epss_percentile": 0.01653}, "CVE-2017-14896": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-14897": {"epss_score": 0.00016, "epss_percentile": 0.02699}, "CVE-2017-14898": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-14899": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-14900": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-14901": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-14902": {"epss_score": 0.00014, "epss_percentile": 0.02059}, "CVE-2017-14903": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-14904": {"epss_score": 0.00026, "epss_percentile": 0.06445}, "CVE-2017-14905": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-14906": {"epss_score": 0.00556, "epss_percentile": 0.67504}, "CVE-2017-14907": {"epss_score": 0.00066, "epss_percentile": 0.20805}, "CVE-2017-14908": {"epss_score": 0.00106, "epss_percentile": 0.2946}, "CVE-2017-14909": {"epss_score": 0.00106, "epss_percentile": 0.2946}, "CVE-2017-14910": {"epss_score": 0.00252, "epss_percentile": 0.48365}, "CVE-2017-14911": {"epss_score": 0.0138, "epss_percentile": 0.7986}, "CVE-2017-14912": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2017-14913": {"epss_score": 0.00705, "epss_percentile": 0.71599}, "CVE-2017-14914": {"epss_score": 0.00106, "epss_percentile": 0.2946}, "CVE-2017-14915": {"epss_score": 0.00827, "epss_percentile": 0.73986}, "CVE-2017-14916": {"epss_score": 0.00106, "epss_percentile": 0.2946}, "CVE-2017-14917": {"epss_score": 0.00106, "epss_percentile": 0.2946}, "CVE-2017-14918": {"epss_score": 0.00124, "epss_percentile": 0.3245}, "CVE-2017-14919": {"epss_score": 0.01039, "epss_percentile": 0.76943}, "CVE-2017-14920": {"epss_score": 0.0122, "epss_percentile": 0.78622}, "CVE-2017-14921": {"epss_score": 0.00325, "epss_percentile": 0.54996}, "CVE-2017-14922": {"epss_score": 0.00325, "epss_percentile": 0.54996}, "CVE-2017-14923": {"epss_score": 0.00325, "epss_percentile": 0.54996}, "CVE-2017-14924": {"epss_score": 0.0022, "epss_percentile": 0.44607}, "CVE-2017-14925": {"epss_score": 0.00171, "epss_percentile": 0.38883}, "CVE-2017-14926": {"epss_score": 0.00291, "epss_percentile": 0.52176}, "CVE-2017-14927": {"epss_score": 0.0026, "epss_percentile": 0.49232}, "CVE-2017-14928": {"epss_score": 0.00291, "epss_percentile": 0.52176}, "CVE-2017-14929": {"epss_score": 0.00472, "epss_percentile": 0.64065}, "CVE-2017-14930": {"epss_score": 0.00314, "epss_percentile": 0.54121}, "CVE-2017-14931": {"epss_score": 0.00248, "epss_percentile": 0.4792}, "CVE-2017-14932": {"epss_score": 0.00367, "epss_percentile": 0.58099}, "CVE-2017-14933": {"epss_score": 0.00495, "epss_percentile": 0.65126}, "CVE-2017-14934": {"epss_score": 0.00358, "epss_percentile": 0.57535}, "CVE-2017-14935": {"epss_score": 0.00284, "epss_percentile": 0.51477}, "CVE-2017-14937": {"epss_score": 0.03673, "epss_percentile": 0.87548}, "CVE-2017-14938": {"epss_score": 0.00499, "epss_percentile": 0.65278}, "CVE-2017-14939": {"epss_score": 0.02994, "epss_percentile": 0.8615}, "CVE-2017-14940": {"epss_score": 0.00425, "epss_percentile": 0.61701}, "CVE-2017-14941": {"epss_score": 0.00179, "epss_percentile": 0.39789}, "CVE-2017-14942": {"epss_score": 0.01009, "epss_percentile": 0.7659}, "CVE-2017-14943": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2017-14944": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2017-14945": {"epss_score": 0.00158, "epss_percentile": 0.37181}, "CVE-2017-14946": {"epss_score": 0.00158, "epss_percentile": 0.37181}, "CVE-2017-14947": {"epss_score": 0.00386, "epss_percentile": 0.59272}, "CVE-2017-14948": {"epss_score": 0.04036, "epss_percentile": 0.88157}, "CVE-2017-14949": {"epss_score": 0.00512, "epss_percentile": 0.65859}, "CVE-2017-14952": {"epss_score": 0.02586, "epss_percentile": 0.85168}, "CVE-2017-14953": {"epss_score": 0.00036, "epss_percentile": 0.1024}, "CVE-2017-14954": {"epss_score": 0.00974, "epss_percentile": 0.76193}, "CVE-2017-14955": {"epss_score": 0.19623, "epss_percentile": 0.95215}, "CVE-2017-14956": {"epss_score": 0.00862, "epss_percentile": 0.7458}, "CVE-2017-14957": {"epss_score": 0.0122, "epss_percentile": 0.78617}, "CVE-2017-14958": {"epss_score": 0.00575, "epss_percentile": 0.68109}, "CVE-2017-14960": {"epss_score": 0.09496, "epss_percentile": 0.92573}, "CVE-2017-14961": {"epss_score": 0.00391, "epss_percentile": 0.59571}, "CVE-2017-14962": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2017-14963": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2017-14964": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2017-14965": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2017-14966": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2017-14967": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2017-14968": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2017-14969": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2017-14970": {"epss_score": 0.00651, "epss_percentile": 0.70292}, "CVE-2017-14971": {"epss_score": 0.00222, "epss_percentile": 0.44734}, "CVE-2017-14972": {"epss_score": 0.00327, "epss_percentile": 0.5515}, "CVE-2017-14973": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-14974": {"epss_score": 0.00367, "epss_percentile": 0.58099}, "CVE-2017-14975": {"epss_score": 0.01097, "epss_percentile": 0.77525}, "CVE-2017-14976": {"epss_score": 0.01093, "epss_percentile": 0.77481}, "CVE-2017-14977": {"epss_score": 0.01097, "epss_percentile": 0.77525}, "CVE-2017-14979": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2017-14980": {"epss_score": 0.7554, "epss_percentile": 0.98852}, "CVE-2017-14981": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-14983": {"epss_score": 0.00171, "epss_percentile": 0.38899}, "CVE-2017-14984": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2017-14985": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2017-14988": {"epss_score": 0.00377, "epss_percentile": 0.58728}, "CVE-2017-14989": {"epss_score": 0.00347, "epss_percentile": 0.56746}, "CVE-2017-14990": {"epss_score": 0.00398, "epss_percentile": 0.60075}, "CVE-2017-14991": {"epss_score": 0.00056, "epss_percentile": 0.17816}, "CVE-2017-14992": {"epss_score": 0.00167, "epss_percentile": 0.38296}, "CVE-2017-14993": {"epss_score": 0.00643, "epss_percentile": 0.70067}, "CVE-2017-14994": {"epss_score": 0.02352, "epss_percentile": 0.84471}, "CVE-2017-14995": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-14997": {"epss_score": 0.01852, "epss_percentile": 0.82544}, "CVE-2017-15008": {"epss_score": 0.00215, "epss_percentile": 0.44051}, "CVE-2017-15009": {"epss_score": 0.00298, "epss_percentile": 0.52804}, "CVE-2017-15010": {"epss_score": 0.08205, "epss_percentile": 0.9193}, "CVE-2017-15011": {"epss_score": 0.00578, "epss_percentile": 0.68183}, "CVE-2017-15012": {"epss_score": 0.0229, "epss_percentile": 0.84278}, "CVE-2017-15013": {"epss_score": 0.01887, "epss_percentile": 0.82716}, "CVE-2017-15014": {"epss_score": 0.03972, "epss_percentile": 0.88038}, "CVE-2017-15015": {"epss_score": 0.00293, "epss_percentile": 0.52335}, "CVE-2017-15016": {"epss_score": 0.00298, "epss_percentile": 0.52818}, "CVE-2017-15017": {"epss_score": 0.00337, "epss_percentile": 0.56023}, "CVE-2017-15018": {"epss_score": 0.00268, "epss_percentile": 0.50083}, "CVE-2017-15019": {"epss_score": 0.00285, "epss_percentile": 0.51684}, "CVE-2017-15020": {"epss_score": 0.00344, "epss_percentile": 0.56479}, "CVE-2017-15021": {"epss_score": 0.00425, "epss_percentile": 0.61701}, "CVE-2017-15022": {"epss_score": 0.00425, "epss_percentile": 0.61701}, "CVE-2017-15023": {"epss_score": 0.00489, "epss_percentile": 0.64905}, "CVE-2017-15024": {"epss_score": 0.00425, "epss_percentile": 0.61701}, "CVE-2017-15025": {"epss_score": 0.00261, "epss_percentile": 0.49253}, "CVE-2017-15029": {"epss_score": 0.00172, "epss_percentile": 0.39027}, "CVE-2017-15030": {"epss_score": 0.00378, "epss_percentile": 0.58796}, "CVE-2017-15031": {"epss_score": 0.00721, "epss_percentile": 0.71978}, "CVE-2017-15032": {"epss_score": 0.00316, "epss_percentile": 0.54282}, "CVE-2017-15033": {"epss_score": 0.00257, "epss_percentile": 0.48883}, "CVE-2017-15035": {"epss_score": 0.23003, "epss_percentile": 0.95716}, "CVE-2017-15037": {"epss_score": 0.00362, "epss_percentile": 0.57792}, "CVE-2017-15038": {"epss_score": 0.00053, "epss_percentile": 0.16909}, "CVE-2017-15039": {"epss_score": 0.00193, "epss_percentile": 0.41408}, "CVE-2017-15041": {"epss_score": 0.05411, "epss_percentile": 0.89845}, "CVE-2017-15042": {"epss_score": 0.00191, "epss_percentile": 0.41254}, "CVE-2017-15043": {"epss_score": 0.00013, "epss_percentile": 0.01568}, "CVE-2017-15044": {"epss_score": 0.00381, "epss_percentile": 0.58976}, "CVE-2017-15045": {"epss_score": 0.00268, "epss_percentile": 0.50083}, "CVE-2017-15046": {"epss_score": 0.00164, "epss_percentile": 0.37899}, "CVE-2017-15047": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2017-15048": {"epss_score": 0.21428, "epss_percentile": 0.95516}, "CVE-2017-15049": {"epss_score": 0.28861, "epss_percentile": 0.96395}, "CVE-2017-15051": {"epss_score": 0.0015, "epss_percentile": 0.36174}, "CVE-2017-15052": {"epss_score": 0.00236, "epss_percentile": 0.46432}, "CVE-2017-15053": {"epss_score": 0.00236, "epss_percentile": 0.46432}, "CVE-2017-15054": {"epss_score": 0.0192, "epss_percentile": 0.82895}, "CVE-2017-15055": {"epss_score": 0.00341, "epss_percentile": 0.56326}, "CVE-2017-15056": {"epss_score": 0.00187, "epss_percentile": 0.40771}, "CVE-2017-15063": {"epss_score": 0.00133, "epss_percentile": 0.33649}, "CVE-2017-15079": {"epss_score": 0.00937, "epss_percentile": 0.75698}, "CVE-2017-15081": {"epss_score": 0.07326, "epss_percentile": 0.91411}, "CVE-2017-15084": {"epss_score": 0.00126, "epss_percentile": 0.32739}, "CVE-2017-15085": {"epss_score": 0.0045, "epss_percentile": 0.63106}, "CVE-2017-15086": {"epss_score": 0.00393, "epss_percentile": 0.59711}, "CVE-2017-15087": {"epss_score": 0.00526, "epss_percentile": 0.66426}, "CVE-2017-15088": {"epss_score": 0.01539, "epss_percentile": 0.80935}, "CVE-2017-15089": {"epss_score": 0.03911, "epss_percentile": 0.87934}, "CVE-2017-15090": {"epss_score": 2e-05, "epss_percentile": 0.00052}, "CVE-2017-15091": {"epss_score": 3e-05, "epss_percentile": 0.00068}, "CVE-2017-15092": {"epss_score": 3e-05, "epss_percentile": 0.00062}, "CVE-2017-15093": {"epss_score": 5e-05, "epss_percentile": 0.00237}, "CVE-2017-15094": {"epss_score": 5e-05, "epss_percentile": 0.00183}, "CVE-2017-15095": {"epss_score": 0.09261, "epss_percentile": 0.9247}, "CVE-2017-15096": {"epss_score": 0.00056, "epss_percentile": 0.17782}, "CVE-2017-15097": {"epss_score": 0.00037, "epss_percentile": 0.1092}, "CVE-2017-15098": {"epss_score": 0.00772, "epss_percentile": 0.73033}, "CVE-2017-15099": {"epss_score": 0.30234, "epss_percentile": 0.96522}, "CVE-2017-15100": {"epss_score": 0.00343, "epss_percentile": 0.56443}, "CVE-2017-15101": {"epss_score": 0.00316, "epss_percentile": 0.54281}, "CVE-2017-15102": {"epss_score": 0.0011, "epss_percentile": 0.30208}, "CVE-2017-15103": {"epss_score": 0.01019, "epss_percentile": 0.76726}, "CVE-2017-15104": {"epss_score": 0.00085, "epss_percentile": 0.25132}, "CVE-2017-15105": {"epss_score": 0.00686, "epss_percentile": 0.71167}, "CVE-2017-15107": {"epss_score": 0.00025, "epss_percentile": 0.06338}, "CVE-2017-15108": {"epss_score": 0.00143, "epss_percentile": 0.35201}, "CVE-2017-15110": {"epss_score": 0.00237, "epss_percentile": 0.46463}, "CVE-2017-15111": {"epss_score": 0.00055, "epss_percentile": 0.17556}, "CVE-2017-15112": {"epss_score": 0.00051, "epss_percentile": 0.16312}, "CVE-2017-15113": {"epss_score": 0.00344, "epss_percentile": 0.56493}, "CVE-2017-15114": {"epss_score": 0.00696, "epss_percentile": 0.71396}, "CVE-2017-15115": {"epss_score": 0.00044, "epss_percentile": 0.13415}, "CVE-2017-15116": {"epss_score": 0.00046, "epss_percentile": 0.14345}, "CVE-2017-15118": {"epss_score": 0.0228, "epss_percentile": 0.84241}, "CVE-2017-15119": {"epss_score": 0.0155, "epss_percentile": 0.80986}, "CVE-2017-15120": {"epss_score": 0.00332, "epss_percentile": 0.55604}, "CVE-2017-15121": {"epss_score": 0.00069, "epss_percentile": 0.21539}, "CVE-2017-15123": {"epss_score": 0.00245, "epss_percentile": 0.47638}, "CVE-2017-15124": {"epss_score": 0.01684, "epss_percentile": 0.81747}, "CVE-2017-15125": {"epss_score": 0.00246, "epss_percentile": 0.47734}, "CVE-2017-15126": {"epss_score": 0.01153, "epss_percentile": 0.78062}, "CVE-2017-15127": {"epss_score": 0.00043, "epss_percentile": 0.13183}, "CVE-2017-15128": {"epss_score": 0.00046, "epss_percentile": 0.14124}, "CVE-2017-15129": {"epss_score": 0.00078, "epss_percentile": 0.23651}, "CVE-2017-15130": {"epss_score": 0.02378, "epss_percentile": 0.84555}, "CVE-2017-15131": {"epss_score": 0.00129, "epss_percentile": 0.33082}, "CVE-2017-15132": {"epss_score": 0.01457, "epss_percentile": 0.80402}, "CVE-2017-15133": {"epss_score": 0.00669, "epss_percentile": 0.70762}, "CVE-2017-15134": {"epss_score": 0.05689, "epss_percentile": 0.90121}, "CVE-2017-15135": {"epss_score": 0.00207, "epss_percentile": 0.4316}, "CVE-2017-15136": {"epss_score": 0.00229, "epss_percentile": 0.45588}, "CVE-2017-15137": {"epss_score": 0.00167, "epss_percentile": 0.38309}, "CVE-2017-15138": {"epss_score": 0.00165, "epss_percentile": 0.38057}, "CVE-2017-15139": {"epss_score": 0.00242, "epss_percentile": 0.47394}, "CVE-2017-15185": {"epss_score": 0.00196, "epss_percentile": 0.41808}, "CVE-2017-15186": {"epss_score": 0.00552, "epss_percentile": 0.67396}, "CVE-2017-15188": {"epss_score": 0.00171, "epss_percentile": 0.38899}, "CVE-2017-15189": {"epss_score": 0.00339, "epss_percentile": 0.56165}, "CVE-2017-15190": {"epss_score": 0.00398, "epss_percentile": 0.60062}, "CVE-2017-15191": {"epss_score": 0.00924, "epss_percentile": 0.75514}, "CVE-2017-15192": {"epss_score": 0.0046, "epss_percentile": 0.63513}, "CVE-2017-15193": {"epss_score": 0.00441, "epss_percentile": 0.62667}, "CVE-2017-15194": {"epss_score": 0.00312, "epss_percentile": 0.53935}, "CVE-2017-15195": {"epss_score": 0.00487, "epss_percentile": 0.64821}, "CVE-2017-15196": {"epss_score": 0.00487, "epss_percentile": 0.64821}, "CVE-2017-15197": {"epss_score": 0.00487, "epss_percentile": 0.64821}, "CVE-2017-15198": {"epss_score": 0.0074, "epss_percentile": 0.72406}, "CVE-2017-15199": {"epss_score": 0.00487, "epss_percentile": 0.64821}, "CVE-2017-15200": {"epss_score": 0.00487, "epss_percentile": 0.64821}, "CVE-2017-15201": {"epss_score": 0.00487, "epss_percentile": 0.64821}, "CVE-2017-15202": {"epss_score": 0.00543, "epss_percentile": 0.67109}, "CVE-2017-15203": {"epss_score": 0.00543, "epss_percentile": 0.67109}, "CVE-2017-15204": {"epss_score": 0.00543, "epss_percentile": 0.67109}, "CVE-2017-15205": {"epss_score": 0.00294, "epss_percentile": 0.52372}, "CVE-2017-15206": {"epss_score": 0.00487, "epss_percentile": 0.64821}, "CVE-2017-15207": {"epss_score": 0.00543, "epss_percentile": 0.67109}, "CVE-2017-15208": {"epss_score": 0.00543, "epss_percentile": 0.67109}, "CVE-2017-15209": {"epss_score": 0.00472, "epss_percentile": 0.6407}, "CVE-2017-15210": {"epss_score": 0.00294, "epss_percentile": 0.52372}, "CVE-2017-15211": {"epss_score": 0.00543, "epss_percentile": 0.67109}, "CVE-2017-15212": {"epss_score": 0.00332, "epss_percentile": 0.556}, "CVE-2017-15213": {"epss_score": 0.00287, "epss_percentile": 0.51851}, "CVE-2017-15214": {"epss_score": 0.00638, "epss_percentile": 0.69908}, "CVE-2017-15215": {"epss_score": 0.01038, "epss_percentile": 0.76933}, "CVE-2017-15216": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2017-15217": {"epss_score": 0.00534, "epss_percentile": 0.66795}, "CVE-2017-15218": {"epss_score": 0.00467, "epss_percentile": 0.63816}, "CVE-2017-15219": {"epss_score": 0.00193, "epss_percentile": 0.41466}, "CVE-2017-15220": {"epss_score": 0.12375, "epss_percentile": 0.93654}, "CVE-2017-15221": {"epss_score": 0.07141, "epss_percentile": 0.91279}, "CVE-2017-15222": {"epss_score": 0.81586, "epss_percentile": 0.99145}, "CVE-2017-15223": {"epss_score": 0.17176, "epss_percentile": 0.94793}, "CVE-2017-15225": {"epss_score": 0.00226, "epss_percentile": 0.45335}, "CVE-2017-15226": {"epss_score": 0.07511, "epss_percentile": 0.91512}, "CVE-2017-15227": {"epss_score": 0.00572, "epss_percentile": 0.68026}, "CVE-2017-15228": {"epss_score": 0.00572, "epss_percentile": 0.68026}, "CVE-2017-15232": {"epss_score": 0.00487, "epss_percentile": 0.64815}, "CVE-2017-15235": {"epss_score": 0.12693, "epss_percentile": 0.93751}, "CVE-2017-15236": {"epss_score": 0.04438, "epss_percentile": 0.8869}, "CVE-2017-15238": {"epss_score": 0.00566, "epss_percentile": 0.67811}, "CVE-2017-15239": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15240": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15241": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15242": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15243": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15244": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15245": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15246": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15247": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15248": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15249": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15250": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15251": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15252": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15253": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15254": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15255": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15256": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15257": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15258": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15259": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15260": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15261": {"epss_score": 0.00256, "epss_percentile": 0.48797}, "CVE-2017-15262": {"epss_score": 0.00286, "epss_percentile": 0.51689}, "CVE-2017-15263": {"epss_score": 0.00256, "epss_percentile": 0.48797}, "CVE-2017-15264": {"epss_score": 0.00256, "epss_percentile": 0.48797}, "CVE-2017-15265": {"epss_score": 0.00106, "epss_percentile": 0.29419}, "CVE-2017-15266": {"epss_score": 0.00363, "epss_percentile": 0.57897}, "CVE-2017-15267": {"epss_score": 0.0066, "epss_percentile": 0.70539}, "CVE-2017-15268": {"epss_score": 0.02569, "epss_percentile": 0.85122}, "CVE-2017-15269": {"epss_score": 0.00225, "epss_percentile": 0.45145}, "CVE-2017-15270": {"epss_score": 0.13968, "epss_percentile": 0.94102}, "CVE-2017-15271": {"epss_score": 0.19311, "epss_percentile": 0.95162}, "CVE-2017-15272": {"epss_score": 0.00065, "epss_percentile": 0.20511}, "CVE-2017-15273": {"epss_score": 0.00333, "epss_percentile": 0.55682}, "CVE-2017-15274": {"epss_score": 0.00076, "epss_percentile": 0.23151}, "CVE-2017-15275": {"epss_score": 0.4521, "epss_percentile": 0.97476}, "CVE-2017-15276": {"epss_score": 0.02611, "epss_percentile": 0.85237}, "CVE-2017-15277": {"epss_score": 0.50442, "epss_percentile": 0.97737}, "CVE-2017-15278": {"epss_score": 0.00292, "epss_percentile": 0.52232}, "CVE-2017-15279": {"epss_score": 0.00195, "epss_percentile": 0.41641}, "CVE-2017-15280": {"epss_score": 0.00193, "epss_percentile": 0.414}, "CVE-2017-15281": {"epss_score": 0.00591, "epss_percentile": 0.68582}, "CVE-2017-15284": {"epss_score": 0.01729, "epss_percentile": 0.81982}, "CVE-2017-15285": {"epss_score": 0.02081, "epss_percentile": 0.83536}, "CVE-2017-15286": {"epss_score": 0.00467, "epss_percentile": 0.63837}, "CVE-2017-15287": {"epss_score": 0.03021, "epss_percentile": 0.86224}, "CVE-2017-15288": {"epss_score": 0.00151, "epss_percentile": 0.36348}, "CVE-2017-15289": {"epss_score": 0.00036, "epss_percentile": 0.10435}, "CVE-2017-15290": {"epss_score": 0.0014, "epss_percentile": 0.34739}, "CVE-2017-15291": {"epss_score": 0.00536, "epss_percentile": 0.66884}, "CVE-2017-15293": {"epss_score": 0.01414, "epss_percentile": 0.80124}, "CVE-2017-15294": {"epss_score": 0.00326, "epss_percentile": 0.55071}, "CVE-2017-15295": {"epss_score": 0.01235, "epss_percentile": 0.78762}, "CVE-2017-15296": {"epss_score": 0.00141, "epss_percentile": 0.34825}, "CVE-2017-15297": {"epss_score": 0.02628, "epss_percentile": 0.85271}, "CVE-2017-15298": {"epss_score": 0.00446, "epss_percentile": 0.6292}, "CVE-2017-15299": {"epss_score": 0.00058, "epss_percentile": 0.18309}, "CVE-2017-15300": {"epss_score": 0.00255, "epss_percentile": 0.48675}, "CVE-2017-15302": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2017-15303": {"epss_score": 0.01546, "epss_percentile": 0.80967}, "CVE-2017-15304": {"epss_score": 0.00345, "epss_percentile": 0.56559}, "CVE-2017-15305": {"epss_score": 0.00278, "epss_percentile": 0.50886}, "CVE-2017-15306": {"epss_score": 0.00045, "epss_percentile": 0.13715}, "CVE-2017-15307": {"epss_score": 0.00025, "epss_percentile": 0.06227}, "CVE-2017-15308": {"epss_score": 0.00196, "epss_percentile": 0.41742}, "CVE-2017-15309": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2017-15310": {"epss_score": 0.00123, "epss_percentile": 0.32265}, "CVE-2017-15311": {"epss_score": 0.00115, "epss_percentile": 0.30906}, "CVE-2017-15312": {"epss_score": 0.00076, "epss_percentile": 0.23122}, "CVE-2017-15313": {"epss_score": 0.00181, "epss_percentile": 0.40079}, "CVE-2017-15314": {"epss_score": 0.00024, "epss_percentile": 0.05726}, "CVE-2017-15315": {"epss_score": 0.00156, "epss_percentile": 0.36988}, "CVE-2017-15316": {"epss_score": 0.00108, "epss_percentile": 0.29869}, "CVE-2017-15317": {"epss_score": 0.0015, "epss_percentile": 0.36049}, "CVE-2017-15318": {"epss_score": 0.0021, "epss_percentile": 0.43604}, "CVE-2017-15319": {"epss_score": 0.0021, "epss_percentile": 0.43604}, "CVE-2017-15320": {"epss_score": 0.0021, "epss_percentile": 0.43604}, "CVE-2017-15321": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2017-15322": {"epss_score": 0.0005, "epss_percentile": 0.15778}, "CVE-2017-15323": {"epss_score": 0.00021, "epss_percentile": 0.04924}, "CVE-2017-15324": {"epss_score": 0.0021, "epss_percentile": 0.43604}, "CVE-2017-15325": {"epss_score": 0.00108, "epss_percentile": 0.29869}, "CVE-2017-15326": {"epss_score": 0.0004, "epss_percentile": 0.12058}, "CVE-2017-15327": {"epss_score": 0.00106, "epss_percentile": 0.29473}, "CVE-2017-15328": {"epss_score": 0.00177, "epss_percentile": 0.39596}, "CVE-2017-15329": {"epss_score": 0.00106, "epss_percentile": 0.29575}, "CVE-2017-15330": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2017-15331": {"epss_score": 0.00336, "epss_percentile": 0.55953}, "CVE-2017-15332": {"epss_score": 0.00336, "epss_percentile": 0.55953}, "CVE-2017-15333": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2017-15334": {"epss_score": 0.0019, "epss_percentile": 0.41131}, "CVE-2017-15335": {"epss_score": 0.0019, "epss_percentile": 0.41131}, "CVE-2017-15336": {"epss_score": 0.0019, "epss_percentile": 0.41131}, "CVE-2017-15337": {"epss_score": 0.0019, "epss_percentile": 0.41131}, "CVE-2017-15338": {"epss_score": 0.0019, "epss_percentile": 0.41131}, "CVE-2017-15339": {"epss_score": 0.0019, "epss_percentile": 0.41131}, "CVE-2017-15340": {"epss_score": 0.00106, "epss_percentile": 0.29423}, "CVE-2017-15341": {"epss_score": 0.00146, "epss_percentile": 0.35561}, "CVE-2017-15342": {"epss_score": 0.00265, "epss_percentile": 0.49753}, "CVE-2017-15343": {"epss_score": 0.00268, "epss_percentile": 0.50082}, "CVE-2017-15344": {"epss_score": 0.00268, "epss_percentile": 0.50082}, "CVE-2017-15345": {"epss_score": 0.00047, "epss_percentile": 0.14797}, "CVE-2017-15346": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2017-15347": {"epss_score": 0.00069, "epss_percentile": 0.21489}, "CVE-2017-15348": {"epss_score": 0.0015, "epss_percentile": 0.36049}, "CVE-2017-15349": {"epss_score": 0.00174, "epss_percentile": 0.3917}, "CVE-2017-15350": {"epss_score": 0.00162, "epss_percentile": 0.37705}, "CVE-2017-15351": {"epss_score": 0.00023, "epss_percentile": 0.05437}, "CVE-2017-15352": {"epss_score": 0.00034, "epss_percentile": 0.09608}, "CVE-2017-15353": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2017-15354": {"epss_score": 0.00266, "epss_percentile": 0.49868}, "CVE-2017-15355": {"epss_score": 0.00266, "epss_percentile": 0.49868}, "CVE-2017-15356": {"epss_score": 0.00266, "epss_percentile": 0.49868}, "CVE-2017-15357": {"epss_score": 0.00642, "epss_percentile": 0.70027}, "CVE-2017-15358": {"epss_score": 0.00288, "epss_percentile": 0.51914}, "CVE-2017-15359": {"epss_score": 0.06863, "epss_percentile": 0.91081}, "CVE-2017-15360": {"epss_score": 0.00188, "epss_percentile": 0.40868}, "CVE-2017-15361": {"epss_score": 0.73437, "epss_percentile": 0.98754}, "CVE-2017-15362": {"epss_score": 0.00396, "epss_percentile": 0.59908}, "CVE-2017-15363": {"epss_score": 0.61008, "epss_percentile": 0.9823}, "CVE-2017-15364": {"epss_score": 0.00547, "epss_percentile": 0.67265}, "CVE-2017-15365": {"epss_score": 0.00574, "epss_percentile": 0.68072}, "CVE-2017-15366": {"epss_score": 0.00284, "epss_percentile": 0.51427}, "CVE-2017-15367": {"epss_score": 0.222, "epss_percentile": 0.95609}, "CVE-2017-15368": {"epss_score": 0.00237, "epss_percentile": 0.46648}, "CVE-2017-15369": {"epss_score": 0.002, "epss_percentile": 0.42219}, "CVE-2017-15370": {"epss_score": 0.00804, "epss_percentile": 0.73609}, "CVE-2017-15371": {"epss_score": 0.00588, "epss_percentile": 0.68497}, "CVE-2017-15372": {"epss_score": 0.00616, "epss_percentile": 0.6932}, "CVE-2017-15373": {"epss_score": 0.00572, "epss_percentile": 0.68005}, "CVE-2017-15374": {"epss_score": 0.03459, "epss_percentile": 0.87178}, "CVE-2017-15375": {"epss_score": 0.00196, "epss_percentile": 0.41746}, "CVE-2017-15376": {"epss_score": 0.04389, "epss_percentile": 0.88634}, "CVE-2017-15377": {"epss_score": 0.00529, "epss_percentile": 0.6658}, "CVE-2017-15378": {"epss_score": 0.00284, "epss_percentile": 0.5149}, "CVE-2017-15379": {"epss_score": 0.02804, "epss_percentile": 0.85703}, "CVE-2017-15380": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-15381": {"epss_score": 0.00238, "epss_percentile": 0.46759}, "CVE-2017-15383": {"epss_score": 0.00049, "epss_percentile": 0.15415}, "CVE-2017-15384": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-15385": {"epss_score": 0.00283, "epss_percentile": 0.51365}, "CVE-2017-15386": {"epss_score": 0.0079, "epss_percentile": 0.73367}, "CVE-2017-15387": {"epss_score": 0.01062, "epss_percentile": 0.77182}, "CVE-2017-15388": {"epss_score": 0.00927, "epss_percentile": 0.75559}, "CVE-2017-15389": {"epss_score": 0.00672, "epss_percentile": 0.70814}, "CVE-2017-15390": {"epss_score": 0.0079, "epss_percentile": 0.73367}, "CVE-2017-15391": {"epss_score": 0.0079, "epss_percentile": 0.73367}, "CVE-2017-15392": {"epss_score": 0.00408, "epss_percentile": 0.60684}, "CVE-2017-15393": {"epss_score": 0.01062, "epss_percentile": 0.77182}, "CVE-2017-15394": {"epss_score": 0.01299, "epss_percentile": 0.79282}, "CVE-2017-15395": {"epss_score": 0.01486, "epss_percentile": 0.80604}, "CVE-2017-15396": {"epss_score": 0.01792, "epss_percentile": 0.82287}, "CVE-2017-15397": {"epss_score": 0.00338, "epss_percentile": 0.56126}, "CVE-2017-15398": {"epss_score": 0.09047, "epss_percentile": 0.92378}, "CVE-2017-15399": {"epss_score": 0.30445, "epss_percentile": 0.9654}, "CVE-2017-15400": {"epss_score": 0.00411, "epss_percentile": 0.60868}, "CVE-2017-15401": {"epss_score": 0.01175, "epss_percentile": 0.7826}, "CVE-2017-15402": {"epss_score": 0.00377, "epss_percentile": 0.58755}, "CVE-2017-15403": {"epss_score": 0.00094, "epss_percentile": 0.26804}, "CVE-2017-15404": {"epss_score": 0.00014, "epss_percentile": 0.02086}, "CVE-2017-15405": {"epss_score": 0.00011, "epss_percentile": 0.01023}, "CVE-2017-15406": {"epss_score": 0.01017, "epss_percentile": 0.76697}, "CVE-2017-15407": {"epss_score": 0.02028, "epss_percentile": 0.83321}, "CVE-2017-15408": {"epss_score": 0.01095, "epss_percentile": 0.77512}, "CVE-2017-15409": {"epss_score": 0.01095, "epss_percentile": 0.77512}, "CVE-2017-15410": {"epss_score": 0.00936, "epss_percentile": 0.75679}, "CVE-2017-15411": {"epss_score": 0.00936, "epss_percentile": 0.75679}, "CVE-2017-15412": {"epss_score": 0.03546, "epss_percentile": 0.87327}, "CVE-2017-15413": {"epss_score": 0.00916, "epss_percentile": 0.75418}, "CVE-2017-15415": {"epss_score": 0.00729, "epss_percentile": 0.72131}, "CVE-2017-15416": {"epss_score": 0.0057, "epss_percentile": 0.6794}, "CVE-2017-15417": {"epss_score": 0.00618, "epss_percentile": 0.69366}, "CVE-2017-15418": {"epss_score": 0.00659, "epss_percentile": 0.70515}, "CVE-2017-15419": {"epss_score": 0.00748, "epss_percentile": 0.72579}, "CVE-2017-15420": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2017-15422": {"epss_score": 0.03854, "epss_percentile": 0.87856}, "CVE-2017-15423": {"epss_score": 0.00599, "epss_percentile": 0.68798}, "CVE-2017-15424": {"epss_score": 0.0066, "epss_percentile": 0.70518}, "CVE-2017-15425": {"epss_score": 0.0066, "epss_percentile": 0.70518}, "CVE-2017-15426": {"epss_score": 0.0066, "epss_percentile": 0.70518}, "CVE-2017-15427": {"epss_score": 0.00373, "epss_percentile": 0.58519}, "CVE-2017-15428": {"epss_score": 0.29882, "epss_percentile": 0.96483}, "CVE-2017-15429": {"epss_score": 0.00728, "epss_percentile": 0.72104}, "CVE-2017-15430": {"epss_score": 0.00156, "epss_percentile": 0.36919}, "CVE-2017-15515": {"epss_score": 0.00202, "epss_percentile": 0.42419}, "CVE-2017-15516": {"epss_score": 0.00159, "epss_percentile": 0.37373}, "CVE-2017-15517": {"epss_score": 0.0018, "epss_percentile": 0.3991}, "CVE-2017-15518": {"epss_score": 0.00165, "epss_percentile": 0.38128}, "CVE-2017-15519": {"epss_score": 0.00414, "epss_percentile": 0.61023}, "CVE-2017-15524": {"epss_score": 0.00281, "epss_percentile": 0.51113}, "CVE-2017-15525": {"epss_score": 0.0017, "epss_percentile": 0.38705}, "CVE-2017-15526": {"epss_score": 0.00149, "epss_percentile": 0.35998}, "CVE-2017-15527": {"epss_score": 0.00484, "epss_percentile": 0.64647}, "CVE-2017-15528": {"epss_score": 0.0023, "epss_percentile": 0.45714}, "CVE-2017-15529": {"epss_score": 0.00076, "epss_percentile": 0.23123}, "CVE-2017-15530": {"epss_score": 0.00077, "epss_percentile": 0.23388}, "CVE-2017-15531": {"epss_score": 0.02809, "epss_percentile": 0.85713}, "CVE-2017-15532": {"epss_score": 0.00661, "epss_percentile": 0.70586}, "CVE-2017-15533": {"epss_score": 0.00283, "epss_percentile": 0.51349}, "CVE-2017-15534": {"epss_score": 0.00167, "epss_percentile": 0.38356}, "CVE-2017-15535": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2017-15536": {"epss_score": 0.00303, "epss_percentile": 0.5322}, "CVE-2017-15537": {"epss_score": 0.00047, "epss_percentile": 0.14615}, "CVE-2017-15538": {"epss_score": 0.00433, "epss_percentile": 0.62196}, "CVE-2017-15539": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-15546": {"epss_score": 0.00362, "epss_percentile": 0.57817}, "CVE-2017-15548": {"epss_score": 0.00228, "epss_percentile": 0.45499}, "CVE-2017-15549": {"epss_score": 0.02348, "epss_percentile": 0.84457}, "CVE-2017-15550": {"epss_score": 0.03767, "epss_percentile": 0.87697}, "CVE-2017-15565": {"epss_score": 0.00617, "epss_percentile": 0.69361}, "CVE-2017-15566": {"epss_score": 0.00154, "epss_percentile": 0.36697}, "CVE-2017-15567": {"epss_score": 0.00024, "epss_percentile": 0.05975}, "CVE-2017-15568": {"epss_score": 0.00432, "epss_percentile": 0.62102}, "CVE-2017-15569": {"epss_score": 0.00432, "epss_percentile": 0.62102}, "CVE-2017-15570": {"epss_score": 0.00517, "epss_percentile": 0.66082}, "CVE-2017-15571": {"epss_score": 0.00517, "epss_percentile": 0.66082}, "CVE-2017-15572": {"epss_score": 0.00583, "epss_percentile": 0.68328}, "CVE-2017-15573": {"epss_score": 0.00381, "epss_percentile": 0.58994}, "CVE-2017-15574": {"epss_score": 0.00381, "epss_percentile": 0.58994}, "CVE-2017-15575": {"epss_score": 0.00717, "epss_percentile": 0.71892}, "CVE-2017-15576": {"epss_score": 0.00537, "epss_percentile": 0.66913}, "CVE-2017-15577": {"epss_score": 0.00537, "epss_percentile": 0.66913}, "CVE-2017-15578": {"epss_score": 0.002, "epss_percentile": 0.42222}, "CVE-2017-15579": {"epss_score": 0.00376, "epss_percentile": 0.58674}, "CVE-2017-15580": {"epss_score": 0.3584, "epss_percentile": 0.96937}, "CVE-2017-15581": {"epss_score": 0.0075, "epss_percentile": 0.72614}, "CVE-2017-15582": {"epss_score": 0.00222, "epss_percentile": 0.44791}, "CVE-2017-15583": {"epss_score": 0.0036, "epss_percentile": 0.57619}, "CVE-2017-15587": {"epss_score": 0.00236, "epss_percentile": 0.46387}, "CVE-2017-15588": {"epss_score": 0.0008, "epss_percentile": 0.24045}, "CVE-2017-15589": {"epss_score": 0.00094, "epss_percentile": 0.26959}, "CVE-2017-15590": {"epss_score": 0.00071, "epss_percentile": 0.22089}, "CVE-2017-15591": {"epss_score": 0.00051, "epss_percentile": 0.16311}, "CVE-2017-15592": {"epss_score": 0.00105, "epss_percentile": 0.29256}, "CVE-2017-15593": {"epss_score": 0.00073, "epss_percentile": 0.22561}, "CVE-2017-15594": {"epss_score": 0.00072, "epss_percentile": 0.22439}, "CVE-2017-15595": {"epss_score": 0.00675, "epss_percentile": 0.70886}, "CVE-2017-15596": {"epss_score": 0.0008, "epss_percentile": 0.24135}, "CVE-2017-15597": {"epss_score": 0.01348, "epss_percentile": 0.79664}, "CVE-2017-15600": {"epss_score": 0.01659, "epss_percentile": 0.81615}, "CVE-2017-15601": {"epss_score": 0.00432, "epss_percentile": 0.62161}, "CVE-2017-15602": {"epss_score": 0.00408, "epss_percentile": 0.6067}, "CVE-2017-15607": {"epss_score": 0.00479, "epss_percentile": 0.64434}, "CVE-2017-15608": {"epss_score": 0.00104, "epss_percentile": 0.29179}, "CVE-2017-15609": {"epss_score": 0.00117, "epss_percentile": 0.31328}, "CVE-2017-15610": {"epss_score": 0.00139, "epss_percentile": 0.34656}, "CVE-2017-15611": {"epss_score": 0.00141, "epss_percentile": 0.34926}, "CVE-2017-15612": {"epss_score": 0.00223, "epss_percentile": 0.44893}, "CVE-2017-15613": {"epss_score": 0.01073, "epss_percentile": 0.77284}, "CVE-2017-15614": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15615": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15616": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15617": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15618": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15619": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15620": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15621": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15622": {"epss_score": 0.00881, "epss_percentile": 0.74875}, "CVE-2017-15623": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15624": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15625": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15626": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15627": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15628": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15629": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15630": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15631": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15632": {"epss_score": 0.00881, "epss_percentile": 0.74875}, "CVE-2017-15633": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15634": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15635": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2017-15636": {"epss_score": 0.00934, "epss_percentile": 0.75652}, "CVE-2017-15637": {"epss_score": 0.01073, "epss_percentile": 0.77284}, "CVE-2017-15638": {"epss_score": 0.00286, "epss_percentile": 0.51754}, "CVE-2017-15639": {"epss_score": 0.04241, "epss_percentile": 0.88433}, "CVE-2017-15640": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-15642": {"epss_score": 0.00639, "epss_percentile": 0.69952}, "CVE-2017-15643": {"epss_score": 0.07273, "epss_percentile": 0.91377}, "CVE-2017-15644": {"epss_score": 0.13209, "epss_percentile": 0.93902}, "CVE-2017-15645": {"epss_score": 0.00836, "epss_percentile": 0.74135}, "CVE-2017-15646": {"epss_score": 0.10508, "epss_percentile": 0.93013}, "CVE-2017-15647": {"epss_score": 0.38911, "epss_percentile": 0.97126}, "CVE-2017-15648": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-15649": {"epss_score": 0.00422, "epss_percentile": 0.61537}, "CVE-2017-15650": {"epss_score": 0.0063, "epss_percentile": 0.69706}, "CVE-2017-15651": {"epss_score": 0.0058, "epss_percentile": 0.68258}, "CVE-2017-15652": {"epss_score": 0.00271, "epss_percentile": 0.50294}, "CVE-2017-15653": {"epss_score": 0.00303, "epss_percentile": 0.53175}, "CVE-2017-15654": {"epss_score": 0.00951, "epss_percentile": 0.75868}, "CVE-2017-15655": {"epss_score": 0.01439, "epss_percentile": 0.8029}, "CVE-2017-15656": {"epss_score": 0.0048, "epss_percentile": 0.64451}, "CVE-2017-15662": {"epss_score": 0.09578, "epss_percentile": 0.92606}, "CVE-2017-15663": {"epss_score": 0.11866, "epss_percentile": 0.93499}, "CVE-2017-15664": {"epss_score": 0.09578, "epss_percentile": 0.92606}, "CVE-2017-15665": {"epss_score": 0.09563, "epss_percentile": 0.926}, "CVE-2017-15667": {"epss_score": 0.12383, "epss_percentile": 0.93656}, "CVE-2017-15670": {"epss_score": 0.00218, "epss_percentile": 0.44336}, "CVE-2017-15671": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2017-15672": {"epss_score": 0.01164, "epss_percentile": 0.78168}, "CVE-2017-15673": {"epss_score": 0.00415, "epss_percentile": 0.61153}, "CVE-2017-15680": {"epss_score": 0.00919, "epss_percentile": 0.75458}, "CVE-2017-15681": {"epss_score": 0.01976, "epss_percentile": 0.8312}, "CVE-2017-15682": {"epss_score": 0.01409, "epss_percentile": 0.80073}, "CVE-2017-15683": {"epss_score": 0.01918, "epss_percentile": 0.82883}, "CVE-2017-15684": {"epss_score": 0.03127, "epss_percentile": 0.86459}, "CVE-2017-15685": {"epss_score": 0.02272, "epss_percentile": 0.84218}, "CVE-2017-15686": {"epss_score": 0.00327, "epss_percentile": 0.551}, "CVE-2017-15687": {"epss_score": 0.00826, "epss_percentile": 0.73974}, "CVE-2017-15691": {"epss_score": 0.00976, "epss_percentile": 0.76214}, "CVE-2017-15692": {"epss_score": 0.04372, "epss_percentile": 0.88611}, "CVE-2017-15693": {"epss_score": 0.01615, "epss_percentile": 0.81349}, "CVE-2017-15694": {"epss_score": 0.00933, "epss_percentile": 0.75639}, "CVE-2017-15695": {"epss_score": 0.01517, "epss_percentile": 0.80805}, "CVE-2017-15696": {"epss_score": 0.00609, "epss_percentile": 0.69089}, "CVE-2017-15697": {"epss_score": 0.00852, "epss_percentile": 0.74418}, "CVE-2017-15698": {"epss_score": 0.00826, "epss_percentile": 0.73963}, "CVE-2017-15699": {"epss_score": 0.00832, "epss_percentile": 0.74064}, "CVE-2017-15700": {"epss_score": 0.00224, "epss_percentile": 0.45053}, "CVE-2017-15701": {"epss_score": 0.02276, "epss_percentile": 0.84228}, "CVE-2017-15702": {"epss_score": 0.03087, "epss_percentile": 0.8639}, "CVE-2017-15703": {"epss_score": 0.00377, "epss_percentile": 0.58702}, "CVE-2017-15705": {"epss_score": 0.01771, "epss_percentile": 0.82193}, "CVE-2017-15706": {"epss_score": 0.04624, "epss_percentile": 0.88936}, "CVE-2017-15707": {"epss_score": 0.02482, "epss_percentile": 0.84877}, "CVE-2017-15708": {"epss_score": 0.15668, "epss_percentile": 0.9448}, "CVE-2017-15709": {"epss_score": 0.65728, "epss_percentile": 0.98435}, "CVE-2017-15710": {"epss_score": 0.0722, "epss_percentile": 0.91333}, "CVE-2017-15712": {"epss_score": 0.00659, "epss_percentile": 0.70502}, "CVE-2017-15713": {"epss_score": 0.00311, "epss_percentile": 0.53934}, "CVE-2017-15714": {"epss_score": 0.00809, "epss_percentile": 0.73707}, "CVE-2017-15715": {"epss_score": 0.94023, "epss_percentile": 0.99887}, "CVE-2017-15717": {"epss_score": 0.01185, "epss_percentile": 0.78337}, "CVE-2017-15718": {"epss_score": 0.01336, "epss_percentile": 0.79554}, "CVE-2017-15719": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2017-15720": {"epss_score": 0.00277, "epss_percentile": 0.50838}, "CVE-2017-15721": {"epss_score": 0.01142, "epss_percentile": 0.77976}, "CVE-2017-15722": {"epss_score": 0.01082, "epss_percentile": 0.77381}, "CVE-2017-15723": {"epss_score": 0.01114, "epss_percentile": 0.77699}, "CVE-2017-15725": {"epss_score": 0.00412, "epss_percentile": 0.60949}, "CVE-2017-15727": {"epss_score": 0.00184, "epss_percentile": 0.40394}, "CVE-2017-15728": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2017-15729": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2017-15730": {"epss_score": 0.00377, "epss_percentile": 0.58701}, "CVE-2017-15731": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2017-15732": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2017-15733": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2017-15734": {"epss_score": 0.00211, "epss_percentile": 0.4363}, "CVE-2017-15735": {"epss_score": 0.00211, "epss_percentile": 0.4363}, "CVE-2017-15736": {"epss_score": 0.00221, "epss_percentile": 0.4463}, "CVE-2017-15737": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15738": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15739": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15740": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15741": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15742": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15743": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15744": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15745": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15746": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15747": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15748": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15749": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15750": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15751": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15752": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15753": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15754": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15755": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15756": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15757": {"epss_score": 0.00268, "epss_percentile": 0.50033}, "CVE-2017-15758": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15759": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-15760": {"epss_score": 0.00364, "epss_percentile": 0.57916}, "CVE-2017-15761": {"epss_score": 0.00364, "epss_percentile": 0.57916}, "CVE-2017-15762": {"epss_score": 0.00364, "epss_percentile": 0.57916}, "CVE-2017-15763": {"epss_score": 0.00364, "epss_percentile": 0.57916}, "CVE-2017-15764": {"epss_score": 0.00189, "epss_percentile": 0.40928}, "CVE-2017-15765": {"epss_score": 0.00189, "epss_percentile": 0.40928}, "CVE-2017-15766": {"epss_score": 0.00189, "epss_percentile": 0.40928}, "CVE-2017-15767": {"epss_score": 0.00364, "epss_percentile": 0.57916}, "CVE-2017-15768": {"epss_score": 0.00189, "epss_percentile": 0.40928}, "CVE-2017-15769": {"epss_score": 0.00189, "epss_percentile": 0.40928}, "CVE-2017-15772": {"epss_score": 0.00164, "epss_percentile": 0.3798}, "CVE-2017-15773": {"epss_score": 0.00164, "epss_percentile": 0.3798}, "CVE-2017-15774": {"epss_score": 0.00317, "epss_percentile": 0.54356}, "CVE-2017-15775": {"epss_score": 0.00164, "epss_percentile": 0.3798}, "CVE-2017-15776": {"epss_score": 0.00164, "epss_percentile": 0.3798}, "CVE-2017-15777": {"epss_score": 0.00317, "epss_percentile": 0.54356}, "CVE-2017-15778": {"epss_score": 0.00164, "epss_percentile": 0.3798}, "CVE-2017-15779": {"epss_score": 0.00317, "epss_percentile": 0.54356}, "CVE-2017-15780": {"epss_score": 0.00164, "epss_percentile": 0.3798}, "CVE-2017-15781": {"epss_score": 0.00317, "epss_percentile": 0.54356}, "CVE-2017-15782": {"epss_score": 0.00317, "epss_percentile": 0.54356}, "CVE-2017-15783": {"epss_score": 0.00164, "epss_percentile": 0.3798}, "CVE-2017-15784": {"epss_score": 0.00317, "epss_percentile": 0.54356}, "CVE-2017-15785": {"epss_score": 0.00317, "epss_percentile": 0.54356}, "CVE-2017-15786": {"epss_score": 0.00164, "epss_percentile": 0.3798}, "CVE-2017-15787": {"epss_score": 0.00317, "epss_percentile": 0.54356}, "CVE-2017-15788": {"epss_score": 0.00317, "epss_percentile": 0.54356}, "CVE-2017-15789": {"epss_score": 0.00317, "epss_percentile": 0.54356}, "CVE-2017-15801": {"epss_score": 0.00164, "epss_percentile": 0.3798}, "CVE-2017-15802": {"epss_score": 0.00164, "epss_percentile": 0.3798}, "CVE-2017-15803": {"epss_score": 0.00164, "epss_percentile": 0.3798}, "CVE-2017-15804": {"epss_score": 0.00207, "epss_percentile": 0.43137}, "CVE-2017-15805": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-15806": {"epss_score": 0.20401, "epss_percentile": 0.95338}, "CVE-2017-15808": {"epss_score": 0.00109, "epss_percentile": 0.29912}, "CVE-2017-15809": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-15810": {"epss_score": 0.00235, "epss_percentile": 0.46313}, "CVE-2017-15811": {"epss_score": 0.00196, "epss_percentile": 0.41712}, "CVE-2017-15812": {"epss_score": 0.00196, "epss_percentile": 0.41731}, "CVE-2017-15813": {"epss_score": 0.00177, "epss_percentile": 0.39569}, "CVE-2017-15814": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2017-15815": {"epss_score": 0.00599, "epss_percentile": 0.68806}, "CVE-2017-15817": {"epss_score": 0.00153, "epss_percentile": 0.3662}, "CVE-2017-15818": {"epss_score": 0.00025, "epss_percentile": 0.06283}, "CVE-2017-15820": {"epss_score": 0.00018, "epss_percentile": 0.04005}, "CVE-2017-15821": {"epss_score": 0.00028, "epss_percentile": 0.07315}, "CVE-2017-15822": {"epss_score": 0.00091, "epss_percentile": 0.26194}, "CVE-2017-15823": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-15824": {"epss_score": 0.00041, "epss_percentile": 0.12425}, "CVE-2017-15825": {"epss_score": 0.00064, "epss_percentile": 0.20265}, "CVE-2017-15826": {"epss_score": 0.00013, "epss_percentile": 0.01515}, "CVE-2017-15828": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2017-15829": {"epss_score": 0.00014, "epss_percentile": 0.02059}, "CVE-2017-15830": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-15831": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-15832": {"epss_score": 0.00074, "epss_percentile": 0.22687}, "CVE-2017-15833": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-15834": {"epss_score": 0.00014, "epss_percentile": 0.01754}, "CVE-2017-15835": {"epss_score": 0.00038, "epss_percentile": 0.11118}, "CVE-2017-15836": {"epss_score": 0.0011, "epss_percentile": 0.3016}, "CVE-2017-15837": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-15841": {"epss_score": 0.0011, "epss_percentile": 0.3018}, "CVE-2017-15842": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2017-15843": {"epss_score": 0.00034, "epss_percentile": 0.09524}, "CVE-2017-15844": {"epss_score": 0.00019, "epss_percentile": 0.04165}, "CVE-2017-15845": {"epss_score": 0.00027, "epss_percentile": 0.06832}, "CVE-2017-15846": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-15847": {"epss_score": 0.00022, "epss_percentile": 0.0517}, "CVE-2017-15848": {"epss_score": 0.00027, "epss_percentile": 0.06832}, "CVE-2017-15849": {"epss_score": 0.00096, "epss_percentile": 0.2729}, "CVE-2017-15850": {"epss_score": 0.00086, "epss_percentile": 0.25289}, "CVE-2017-15851": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-15852": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-15853": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-15854": {"epss_score": 0.00056, "epss_percentile": 0.17711}, "CVE-2017-15855": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2017-15856": {"epss_score": 0.0005, "epss_percentile": 0.15654}, "CVE-2017-15857": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2017-15859": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-15860": {"epss_score": 0.00049, "epss_percentile": 0.15557}, "CVE-2017-15861": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2017-15862": {"epss_score": 0.00015, "epss_percentile": 0.02137}, "CVE-2017-15863": {"epss_score": 0.00193, "epss_percentile": 0.41438}, "CVE-2017-15864": {"epss_score": 0.00501, "epss_percentile": 0.65353}, "CVE-2017-15865": {"epss_score": 0.0055, "epss_percentile": 0.67343}, "CVE-2017-15867": {"epss_score": 0.0027, "epss_percentile": 0.5023}, "CVE-2017-15868": {"epss_score": 0.00073, "epss_percentile": 0.22485}, "CVE-2017-15869": {"epss_score": 0.00388, "epss_percentile": 0.59372}, "CVE-2017-15870": {"epss_score": 0.00094, "epss_percentile": 0.27007}, "CVE-2017-15871": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2017-15872": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2017-15873": {"epss_score": 0.00138, "epss_percentile": 0.34464}, "CVE-2017-15874": {"epss_score": 0.0028, "epss_percentile": 0.51038}, "CVE-2017-15875": {"epss_score": 0.00467, "epss_percentile": 0.6382}, "CVE-2017-15876": {"epss_score": 0.01085, "epss_percentile": 0.77405}, "CVE-2017-15877": {"epss_score": 0.00343, "epss_percentile": 0.56455}, "CVE-2017-15878": {"epss_score": 0.03604, "epss_percentile": 0.87414}, "CVE-2017-15879": {"epss_score": 0.09815, "epss_percentile": 0.92714}, "CVE-2017-15880": {"epss_score": 0.00407, "epss_percentile": 0.60584}, "CVE-2017-15881": {"epss_score": 0.00466, "epss_percentile": 0.63791}, "CVE-2017-15882": {"epss_score": 0.00691, "epss_percentile": 0.71281}, "CVE-2017-15883": {"epss_score": 0.00105, "epss_percentile": 0.29315}, "CVE-2017-15884": {"epss_score": 0.00077, "epss_percentile": 0.23306}, "CVE-2017-15885": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-15886": {"epss_score": 0.00177, "epss_percentile": 0.39504}, "CVE-2017-15887": {"epss_score": 0.00419, "epss_percentile": 0.61365}, "CVE-2017-15888": {"epss_score": 0.00265, "epss_percentile": 0.49814}, "CVE-2017-15889": {"epss_score": 0.6238, "epss_percentile": 0.9829}, "CVE-2017-15890": {"epss_score": 0.0017, "epss_percentile": 0.38656}, "CVE-2017-15891": {"epss_score": 0.00132, "epss_percentile": 0.33511}, "CVE-2017-15892": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2017-15893": {"epss_score": 0.00171, "epss_percentile": 0.38797}, "CVE-2017-15894": {"epss_score": 0.00404, "epss_percentile": 0.60446}, "CVE-2017-15895": {"epss_score": 0.00312, "epss_percentile": 0.53993}, "CVE-2017-15896": {"epss_score": 0.001, "epss_percentile": 0.28462}, "CVE-2017-15897": {"epss_score": 0.00642, "epss_percentile": 0.70043}, "CVE-2017-15906": {"epss_score": 0.02493, "epss_percentile": 0.84901}, "CVE-2017-15907": {"epss_score": 0.00487, "epss_percentile": 0.64817}, "CVE-2017-15908": {"epss_score": 0.00331, "epss_percentile": 0.55507}, "CVE-2017-15909": {"epss_score": 0.00698, "epss_percentile": 0.71427}, "CVE-2017-15911": {"epss_score": 0.00479, "epss_percentile": 0.64435}, "CVE-2017-15913": {"epss_score": 0.00154, "epss_percentile": 0.36722}, "CVE-2017-15914": {"epss_score": 0.00389, "epss_percentile": 0.59464}, "CVE-2017-15917": {"epss_score": 0.00164, "epss_percentile": 0.37953}, "CVE-2017-15918": {"epss_score": 0.00256, "epss_percentile": 0.48767}, "CVE-2017-15919": {"epss_score": 0.02095, "epss_percentile": 0.83584}, "CVE-2017-15920": {"epss_score": 0.09663, "epss_percentile": 0.92646}, "CVE-2017-15921": {"epss_score": 0.09663, "epss_percentile": 0.92646}, "CVE-2017-15922": {"epss_score": 0.00177, "epss_percentile": 0.39544}, "CVE-2017-15923": {"epss_score": 0.01477, "epss_percentile": 0.80547}, "CVE-2017-15924": {"epss_score": 0.00451, "epss_percentile": 0.63122}, "CVE-2017-15928": {"epss_score": 0.00459, "epss_percentile": 0.63462}, "CVE-2017-15930": {"epss_score": 0.00771, "epss_percentile": 0.73017}, "CVE-2017-15931": {"epss_score": 0.00206, "epss_percentile": 0.42926}, "CVE-2017-15932": {"epss_score": 0.00206, "epss_percentile": 0.42926}, "CVE-2017-15933": {"epss_score": 0.00614, "epss_percentile": 0.6928}, "CVE-2017-15934": {"epss_score": 0.0027, "epss_percentile": 0.5027}, "CVE-2017-15935": {"epss_score": 0.00391, "epss_percentile": 0.5963}, "CVE-2017-15936": {"epss_score": 0.0027, "epss_percentile": 0.5027}, "CVE-2017-15937": {"epss_score": 0.00309, "epss_percentile": 0.53662}, "CVE-2017-15938": {"epss_score": 0.00485, "epss_percentile": 0.64717}, "CVE-2017-15939": {"epss_score": 0.00335, "epss_percentile": 0.55802}, "CVE-2017-15940": {"epss_score": 0.06137, "epss_percentile": 0.9051}, "CVE-2017-15941": {"epss_score": 0.0059, "epss_percentile": 0.68553}, "CVE-2017-15942": {"epss_score": 0.01408, "epss_percentile": 0.80062}, "CVE-2017-15943": {"epss_score": 0.00567, "epss_percentile": 0.67842}, "CVE-2017-15944": {"epss_score": 0.94179, "epss_percentile": 0.99913}, "CVE-2017-15945": {"epss_score": 0.00027, "epss_percentile": 0.06927}, "CVE-2017-15946": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-15947": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-15948": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2017-15949": {"epss_score": 0.0023, "epss_percentile": 0.45684}, "CVE-2017-15950": {"epss_score": 0.10414, "epss_percentile": 0.92979}, "CVE-2017-15951": {"epss_score": 0.00096, "epss_percentile": 0.27342}, "CVE-2017-15953": {"epss_score": 0.00266, "epss_percentile": 0.49944}, "CVE-2017-15954": {"epss_score": 0.00308, "epss_percentile": 0.53584}, "CVE-2017-15955": {"epss_score": 0.00251, "epss_percentile": 0.48329}, "CVE-2017-15956": {"epss_score": 0.22843, "epss_percentile": 0.95698}, "CVE-2017-15957": {"epss_score": 0.03316, "epss_percentile": 0.86901}, "CVE-2017-15958": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-15959": {"epss_score": 0.02342, "epss_percentile": 0.84439}, "CVE-2017-15960": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-15961": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-15962": {"epss_score": 0.18153, "epss_percentile": 0.94966}, "CVE-2017-15963": {"epss_score": 0.02342, "epss_percentile": 0.84439}, "CVE-2017-15964": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-15965": {"epss_score": 0.04151, "epss_percentile": 0.88323}, "CVE-2017-15966": {"epss_score": 0.04151, "epss_percentile": 0.88323}, "CVE-2017-15967": {"epss_score": 0.02342, "epss_percentile": 0.84439}, "CVE-2017-15968": {"epss_score": 0.02342, "epss_percentile": 0.84439}, "CVE-2017-15969": {"epss_score": 0.02342, "epss_percentile": 0.84439}, "CVE-2017-15970": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-15971": {"epss_score": 0.02215, "epss_percentile": 0.84029}, "CVE-2017-15972": {"epss_score": 0.02342, "epss_percentile": 0.84439}, "CVE-2017-15973": {"epss_score": 0.02342, "epss_percentile": 0.84439}, "CVE-2017-15974": {"epss_score": 0.04083, "epss_percentile": 0.88222}, "CVE-2017-15975": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-15976": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-15977": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15978": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15979": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15980": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15981": {"epss_score": 0.01085, "epss_percentile": 0.77411}, "CVE-2017-15982": {"epss_score": 0.01085, "epss_percentile": 0.77411}, "CVE-2017-15983": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15984": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15985": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15986": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15987": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15988": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15989": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15990": {"epss_score": 0.08793, "epss_percentile": 0.92257}, "CVE-2017-15991": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15992": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15993": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-15994": {"epss_score": 0.00128, "epss_percentile": 0.33036}, "CVE-2017-15996": {"epss_score": 0.00314, "epss_percentile": 0.54152}, "CVE-2017-15997": {"epss_score": 0.00015, "epss_percentile": 0.0216}, "CVE-2017-15998": {"epss_score": 0.00079, "epss_percentile": 0.23954}, "CVE-2017-15999": {"epss_score": 0.00153, "epss_percentile": 0.36547}, "CVE-2017-16000": {"epss_score": 0.00437, "epss_percentile": 0.62488}, "CVE-2017-16001": {"epss_score": 0.00093, "epss_percentile": 0.26721}, "CVE-2017-16003": {"epss_score": 0.00699, "epss_percentile": 0.71459}, "CVE-2017-16005": {"epss_score": 0.00161, "epss_percentile": 0.37526}, "CVE-2017-16006": {"epss_score": 0.00241, "epss_percentile": 0.47291}, "CVE-2017-16007": {"epss_score": 0.00249, "epss_percentile": 0.4801}, "CVE-2017-16008": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-16009": {"epss_score": 0.00494, "epss_percentile": 0.65086}, "CVE-2017-16010": {"epss_score": 0.00223, "epss_percentile": 0.44893}, "CVE-2017-16013": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-16014": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2017-16015": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-16016": {"epss_score": 0.00286, "epss_percentile": 0.51698}, "CVE-2017-16017": {"epss_score": 0.00264, "epss_percentile": 0.49728}, "CVE-2017-16018": {"epss_score": 0.00223, "epss_percentile": 0.44893}, "CVE-2017-16019": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-16020": {"epss_score": 0.00788, "epss_percentile": 0.73346}, "CVE-2017-16021": {"epss_score": 0.00217, "epss_percentile": 0.44269}, "CVE-2017-16022": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-16023": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2017-16024": {"epss_score": 0.00262, "epss_percentile": 0.49358}, "CVE-2017-16025": {"epss_score": 0.00365, "epss_percentile": 0.58012}, "CVE-2017-16026": {"epss_score": 0.00774, "epss_percentile": 0.7307}, "CVE-2017-16028": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2017-16029": {"epss_score": 0.00534, "epss_percentile": 0.66802}, "CVE-2017-16030": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2017-16031": {"epss_score": 0.00385, "epss_percentile": 0.59207}, "CVE-2017-16035": {"epss_score": 0.00177, "epss_percentile": 0.39526}, "CVE-2017-16036": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16037": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16038": {"epss_score": 0.00862, "epss_percentile": 0.74579}, "CVE-2017-16039": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16040": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2017-16041": {"epss_score": 0.00119, "epss_percentile": 0.31607}, "CVE-2017-16042": {"epss_score": 0.00808, "epss_percentile": 0.73698}, "CVE-2017-16043": {"epss_score": 0.00259, "epss_percentile": 0.49087}, "CVE-2017-16044": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16045": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16046": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16047": {"epss_score": 0.00322, "epss_percentile": 0.54797}, "CVE-2017-16048": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16049": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16050": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16051": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16052": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16053": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16054": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16055": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16056": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16057": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16058": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16059": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16060": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16061": {"epss_score": 0.00262, "epss_percentile": 0.49398}, "CVE-2017-16062": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16063": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16064": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16065": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16066": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16067": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16068": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16069": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16070": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16071": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16072": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16073": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16074": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16075": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16076": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16077": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16078": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16079": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16080": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16081": {"epss_score": 0.00322, "epss_percentile": 0.54829}, "CVE-2017-16082": {"epss_score": 0.70815, "epss_percentile": 0.98643}, "CVE-2017-16083": {"epss_score": 0.00596, "epss_percentile": 0.68701}, "CVE-2017-16084": {"epss_score": 0.00651, "epss_percentile": 0.7028}, "CVE-2017-16085": {"epss_score": 0.00596, "epss_percentile": 0.68701}, "CVE-2017-16086": {"epss_score": 0.57769, "epss_percentile": 0.98082}, "CVE-2017-16088": {"epss_score": 0.02058, "epss_percentile": 0.83432}, "CVE-2017-16089": {"epss_score": 0.00596, "epss_percentile": 0.68701}, "CVE-2017-16090": {"epss_score": 0.00596, "epss_percentile": 0.68701}, "CVE-2017-16091": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16092": {"epss_score": 0.00596, "epss_percentile": 0.68701}, "CVE-2017-16093": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16094": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16095": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16096": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16097": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16098": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2017-16099": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-16100": {"epss_score": 0.0534, "epss_percentile": 0.89758}, "CVE-2017-16101": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16102": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16103": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16104": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16105": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16106": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16107": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16108": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16109": {"epss_score": 0.00191, "epss_percentile": 0.4127}, "CVE-2017-16110": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16111": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-16113": {"epss_score": 0.00303, "epss_percentile": 0.53181}, "CVE-2017-16114": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2017-16115": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2017-16116": {"epss_score": 0.00366, "epss_percentile": 0.58025}, "CVE-2017-16117": {"epss_score": 0.00362, "epss_percentile": 0.5775}, "CVE-2017-16118": {"epss_score": 0.006, "epss_percentile": 0.68825}, "CVE-2017-16119": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2017-16120": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16121": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16122": {"epss_score": 0.00596, "epss_percentile": 0.68701}, "CVE-2017-16123": {"epss_score": 0.00596, "epss_percentile": 0.68701}, "CVE-2017-16124": {"epss_score": 0.00596, "epss_percentile": 0.68701}, "CVE-2017-16125": {"epss_score": 0.00596, "epss_percentile": 0.68701}, "CVE-2017-16126": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2017-16127": {"epss_score": 0.0032, "epss_percentile": 0.54593}, "CVE-2017-16128": {"epss_score": 0.0032, "epss_percentile": 0.54593}, "CVE-2017-16129": {"epss_score": 0.00385, "epss_percentile": 0.59184}, "CVE-2017-16130": {"epss_score": 0.00596, "epss_percentile": 0.68701}, "CVE-2017-16131": {"epss_score": 0.00596, "epss_percentile": 0.68701}, "CVE-2017-16132": {"epss_score": 0.00596, "epss_percentile": 0.68701}, "CVE-2017-16133": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16134": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16135": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16136": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2017-16137": {"epss_score": 0.00097, "epss_percentile": 0.27483}, "CVE-2017-16138": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2017-16139": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16140": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16141": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16142": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16143": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16144": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16145": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16146": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16147": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16148": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16149": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16150": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16151": {"epss_score": 0.02704, "epss_percentile": 0.85464}, "CVE-2017-16152": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16153": {"epss_score": 0.00543, "epss_percentile": 0.67119}, "CVE-2017-16154": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16155": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16156": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16157": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16158": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16159": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16160": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16161": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16162": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16163": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16164": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16165": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16166": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16167": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16168": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16169": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16170": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16171": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16172": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16173": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16174": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16175": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16176": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16177": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16178": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16179": {"epss_score": 0.00191, "epss_percentile": 0.4127}, "CVE-2017-16180": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16181": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16182": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16183": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16184": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16185": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16186": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16187": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16188": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16189": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16190": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16191": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16192": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16193": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16194": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16195": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16196": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16197": {"epss_score": 0.00257, "epss_percentile": 0.48909}, "CVE-2017-16198": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16199": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16200": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16201": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16202": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16203": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16204": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16205": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2017-16206": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2017-16207": {"epss_score": 0.00199, "epss_percentile": 0.42169}, "CVE-2017-16208": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16209": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16210": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16211": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16212": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16213": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16214": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16215": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16216": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16217": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16218": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16219": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16220": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16221": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16222": {"epss_score": 0.00191, "epss_percentile": 0.4127}, "CVE-2017-16223": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2017-16224": {"epss_score": 0.00215, "epss_percentile": 0.44097}, "CVE-2017-16225": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2017-16226": {"epss_score": 0.01261, "epss_percentile": 0.78976}, "CVE-2017-16227": {"epss_score": 0.01457, "epss_percentile": 0.80399}, "CVE-2017-16228": {"epss_score": 0.00739, "epss_percentile": 0.72389}, "CVE-2017-16229": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2017-16230": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-16231": {"epss_score": 0.00094, "epss_percentile": 0.2698}, "CVE-2017-16232": {"epss_score": 0.01705, "epss_percentile": 0.81851}, "CVE-2017-16237": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2017-16239": {"epss_score": 0.00385, "epss_percentile": 0.59231}, "CVE-2017-16241": {"epss_score": 0.00273, "epss_percentile": 0.50431}, "CVE-2017-16242": {"epss_score": 0.00062, "epss_percentile": 0.1975}, "CVE-2017-16244": {"epss_score": 0.00403, "epss_percentile": 0.60387}, "CVE-2017-16248": {"epss_score": 0.00318, "epss_percentile": 0.54451}, "CVE-2017-16249": {"epss_score": 0.67301, "epss_percentile": 0.98501}, "CVE-2017-16250": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2017-16251": {"epss_score": 0.01441, "epss_percentile": 0.80302}, "CVE-2017-16252": {"epss_score": 0.00633, "epss_percentile": 0.69774}, "CVE-2017-16253": {"epss_score": 0.00989, "epss_percentile": 0.76364}, "CVE-2017-16254": {"epss_score": 0.00989, "epss_percentile": 0.76364}, "CVE-2017-16255": {"epss_score": 0.00989, "epss_percentile": 0.76364}, "CVE-2017-16256": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16257": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16258": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16259": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16260": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16261": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16262": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16263": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16264": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16265": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16266": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16267": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16268": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16269": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16270": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16271": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16272": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16273": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16274": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16275": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16276": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16277": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16278": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16279": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16280": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16281": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16282": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16283": {"epss_score": 0.00115, "epss_percentile": 0.31003}, "CVE-2017-16284": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16285": {"epss_score": 0.00115, "epss_percentile": 0.31003}, "CVE-2017-16286": {"epss_score": 0.00115, "epss_percentile": 0.31003}, "CVE-2017-16287": {"epss_score": 0.00115, "epss_percentile": 0.31003}, "CVE-2017-16288": {"epss_score": 0.00115, "epss_percentile": 0.31003}, "CVE-2017-16289": {"epss_score": 0.00115, "epss_percentile": 0.31003}, "CVE-2017-16290": {"epss_score": 0.00115, "epss_percentile": 0.31003}, "CVE-2017-16291": {"epss_score": 0.00115, "epss_percentile": 0.31003}, "CVE-2017-16292": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16293": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16294": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16295": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16296": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16297": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16298": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16299": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16300": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16301": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16302": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16303": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16304": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16305": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16306": {"epss_score": 0.00115, "epss_percentile": 0.31003}, "CVE-2017-16307": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16308": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16309": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16310": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16311": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16312": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16313": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16314": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16315": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16316": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16317": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16318": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16319": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16320": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16321": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16322": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16323": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16324": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16325": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16326": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16327": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16328": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16329": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16330": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16331": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2017-16332": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16333": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16334": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16335": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16336": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2017-16337": {"epss_score": 0.00671, "epss_percentile": 0.7079}, "CVE-2017-16338": {"epss_score": 0.00771, "epss_percentile": 0.73028}, "CVE-2017-16339": {"epss_score": 0.00771, "epss_percentile": 0.73028}, "CVE-2017-16340": {"epss_score": 0.00771, "epss_percentile": 0.73028}, "CVE-2017-16341": {"epss_score": 0.00771, "epss_percentile": 0.73028}, "CVE-2017-16342": {"epss_score": 0.00771, "epss_percentile": 0.73028}, "CVE-2017-16343": {"epss_score": 0.00771, "epss_percentile": 0.73028}, "CVE-2017-16344": {"epss_score": 0.00681, "epss_percentile": 0.71053}, "CVE-2017-16345": {"epss_score": 0.00681, "epss_percentile": 0.71053}, "CVE-2017-16346": {"epss_score": 0.00681, "epss_percentile": 0.71053}, "CVE-2017-16347": {"epss_score": 0.00681, "epss_percentile": 0.71053}, "CVE-2017-16348": {"epss_score": 0.00611, "epss_percentile": 0.69181}, "CVE-2017-16349": {"epss_score": 0.00333, "epss_percentile": 0.55649}, "CVE-2017-16352": {"epss_score": 0.3137, "epss_percentile": 0.96614}, "CVE-2017-16353": {"epss_score": 0.32261, "epss_percentile": 0.96683}, "CVE-2017-16355": {"epss_score": 0.00136, "epss_percentile": 0.34116}, "CVE-2017-16356": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2017-16357": {"epss_score": 0.00215, "epss_percentile": 0.44023}, "CVE-2017-16358": {"epss_score": 0.00184, "epss_percentile": 0.40433}, "CVE-2017-16359": {"epss_score": 0.00193, "epss_percentile": 0.41422}, "CVE-2017-16360": {"epss_score": 0.0413, "epss_percentile": 0.88297}, "CVE-2017-16361": {"epss_score": 0.03786, "epss_percentile": 0.87725}, "CVE-2017-16362": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16363": {"epss_score": 0.17919, "epss_percentile": 0.94927}, "CVE-2017-16364": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16365": {"epss_score": 0.18822, "epss_percentile": 0.95075}, "CVE-2017-16366": {"epss_score": 0.05211, "epss_percentile": 0.89615}, "CVE-2017-16367": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16368": {"epss_score": 0.18397, "epss_percentile": 0.95011}, "CVE-2017-16369": {"epss_score": 0.07498, "epss_percentile": 0.91504}, "CVE-2017-16370": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16371": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16372": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16373": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16374": {"epss_score": 0.17919, "epss_percentile": 0.94927}, "CVE-2017-16375": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16376": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16377": {"epss_score": 0.16377, "epss_percentile": 0.9464}, "CVE-2017-16378": {"epss_score": 0.16377, "epss_percentile": 0.9464}, "CVE-2017-16379": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16380": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16381": {"epss_score": 0.26272, "epss_percentile": 0.96132}, "CVE-2017-16382": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16383": {"epss_score": 0.08649, "epss_percentile": 0.92171}, "CVE-2017-16384": {"epss_score": 0.17919, "epss_percentile": 0.94927}, "CVE-2017-16385": {"epss_score": 0.27426, "epss_percentile": 0.96245}, "CVE-2017-16386": {"epss_score": 0.01933, "epss_percentile": 0.82948}, "CVE-2017-16387": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16388": {"epss_score": 0.0413, "epss_percentile": 0.88297}, "CVE-2017-16389": {"epss_score": 0.0413, "epss_percentile": 0.88297}, "CVE-2017-16390": {"epss_score": 0.0413, "epss_percentile": 0.88297}, "CVE-2017-16391": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16392": {"epss_score": 0.26272, "epss_percentile": 0.96132}, "CVE-2017-16393": {"epss_score": 0.0413, "epss_percentile": 0.88297}, "CVE-2017-16394": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16395": {"epss_score": 0.26272, "epss_percentile": 0.96132}, "CVE-2017-16396": {"epss_score": 0.26272, "epss_percentile": 0.96132}, "CVE-2017-16397": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16398": {"epss_score": 0.04618, "epss_percentile": 0.88927}, "CVE-2017-16399": {"epss_score": 0.09178, "epss_percentile": 0.92433}, "CVE-2017-16400": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16401": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16402": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16403": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16404": {"epss_score": 0.14941, "epss_percentile": 0.94329}, "CVE-2017-16405": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16406": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16407": {"epss_score": 0.14941, "epss_percentile": 0.94329}, "CVE-2017-16408": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16409": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16410": {"epss_score": 0.06588, "epss_percentile": 0.9087}, "CVE-2017-16411": {"epss_score": 0.06588, "epss_percentile": 0.9087}, "CVE-2017-16412": {"epss_score": 0.06588, "epss_percentile": 0.9087}, "CVE-2017-16413": {"epss_score": 0.11586, "epss_percentile": 0.93413}, "CVE-2017-16414": {"epss_score": 0.06588, "epss_percentile": 0.9087}, "CVE-2017-16415": {"epss_score": 0.11586, "epss_percentile": 0.93413}, "CVE-2017-16416": {"epss_score": 0.11586, "epss_percentile": 0.93413}, "CVE-2017-16417": {"epss_score": 0.06981, "epss_percentile": 0.9116}, "CVE-2017-16418": {"epss_score": 0.06588, "epss_percentile": 0.9087}, "CVE-2017-16419": {"epss_score": 0.02832, "epss_percentile": 0.85779}, "CVE-2017-16420": {"epss_score": 0.08675, "epss_percentile": 0.92192}, "CVE-2017-16510": {"epss_score": 0.04169, "epss_percentile": 0.88344}, "CVE-2017-16512": {"epss_score": 0.00033, "epss_percentile": 0.09152}, "CVE-2017-16513": {"epss_score": 0.00034, "epss_percentile": 0.09461}, "CVE-2017-16514": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-16516": {"epss_score": 0.01553, "epss_percentile": 0.80996}, "CVE-2017-16520": {"epss_score": 0.00221, "epss_percentile": 0.44641}, "CVE-2017-16521": {"epss_score": 0.0078, "epss_percentile": 0.73166}, "CVE-2017-16522": {"epss_score": 0.01622, "epss_percentile": 0.81398}, "CVE-2017-16523": {"epss_score": 0.02913, "epss_percentile": 0.85975}, "CVE-2017-16524": {"epss_score": 0.74711, "epss_percentile": 0.98814}, "CVE-2017-16525": {"epss_score": 0.00103, "epss_percentile": 0.29097}, "CVE-2017-16526": {"epss_score": 0.00122, "epss_percentile": 0.32071}, "CVE-2017-16527": {"epss_score": 0.00122, "epss_percentile": 0.32071}, "CVE-2017-16528": {"epss_score": 0.00113, "epss_percentile": 0.30714}, "CVE-2017-16529": {"epss_score": 0.00122, "epss_percentile": 0.32071}, "CVE-2017-16530": {"epss_score": 0.0009, "epss_percentile": 0.26097}, "CVE-2017-16531": {"epss_score": 0.00093, "epss_percentile": 0.26665}, "CVE-2017-16532": {"epss_score": 0.00085, "epss_percentile": 0.25031}, "CVE-2017-16533": {"epss_score": 0.00113, "epss_percentile": 0.30714}, "CVE-2017-16534": {"epss_score": 0.00107, "epss_percentile": 0.29582}, "CVE-2017-16535": {"epss_score": 0.00111, "epss_percentile": 0.30364}, "CVE-2017-16536": {"epss_score": 0.00085, "epss_percentile": 0.25098}, "CVE-2017-16537": {"epss_score": 0.00086, "epss_percentile": 0.2534}, "CVE-2017-16538": {"epss_score": 0.00079, "epss_percentile": 0.23829}, "CVE-2017-16539": {"epss_score": 0.00771, "epss_percentile": 0.73021}, "CVE-2017-16540": {"epss_score": 0.00334, "epss_percentile": 0.55691}, "CVE-2017-16541": {"epss_score": 0.04969, "epss_percentile": 0.89348}, "CVE-2017-16542": {"epss_score": 0.01223, "epss_percentile": 0.7867}, "CVE-2017-16543": {"epss_score": 0.01933, "epss_percentile": 0.82951}, "CVE-2017-16544": {"epss_score": 0.02144, "epss_percentile": 0.83761}, "CVE-2017-16545": {"epss_score": 0.0066, "epss_percentile": 0.70521}, "CVE-2017-16546": {"epss_score": 0.00594, "epss_percentile": 0.68671}, "CVE-2017-16547": {"epss_score": 0.00859, "epss_percentile": 0.74516}, "CVE-2017-16548": {"epss_score": 0.02941, "epss_percentile": 0.86033}, "CVE-2017-16549": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2017-16550": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2017-16551": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2017-16552": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2017-16553": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2017-16554": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2017-16555": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2017-16556": {"epss_score": 0.00049, "epss_percentile": 0.15458}, "CVE-2017-16557": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2017-16558": {"epss_score": 0.00288, "epss_percentile": 0.51889}, "CVE-2017-16560": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2017-16561": {"epss_score": 0.00221, "epss_percentile": 0.44685}, "CVE-2017-16562": {"epss_score": 0.48165, "epss_percentile": 0.97624}, "CVE-2017-16563": {"epss_score": 0.00128, "epss_percentile": 0.32956}, "CVE-2017-16564": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2017-16565": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2017-16566": {"epss_score": 0.01334, "epss_percentile": 0.79542}, "CVE-2017-16567": {"epss_score": 0.0024, "epss_percentile": 0.47217}, "CVE-2017-16568": {"epss_score": 0.00304, "epss_percentile": 0.53249}, "CVE-2017-16569": {"epss_score": 0.00137, "epss_percentile": 0.34259}, "CVE-2017-16570": {"epss_score": 0.00198, "epss_percentile": 0.42051}, "CVE-2017-16571": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-16572": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-16573": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2017-16574": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2017-16575": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-16576": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-16577": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-16578": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-16579": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2017-16580": {"epss_score": 0.0019, "epss_percentile": 0.41125}, "CVE-2017-16581": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-16582": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2017-16583": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-16584": {"epss_score": 0.00222, "epss_percentile": 0.44754}, "CVE-2017-16585": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-16586": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-16587": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2017-16588": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2017-16589": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2017-16590": {"epss_score": 0.02143, "epss_percentile": 0.83756}, "CVE-2017-16591": {"epss_score": 0.02244, "epss_percentile": 0.84126}, "CVE-2017-16592": {"epss_score": 0.02244, "epss_percentile": 0.84126}, "CVE-2017-16593": {"epss_score": 0.03268, "epss_percentile": 0.86786}, "CVE-2017-16594": {"epss_score": 0.04148, "epss_percentile": 0.88318}, "CVE-2017-16595": {"epss_score": 0.02244, "epss_percentile": 0.84126}, "CVE-2017-16596": {"epss_score": 0.02244, "epss_percentile": 0.84126}, "CVE-2017-16597": {"epss_score": 0.36114, "epss_percentile": 0.96957}, "CVE-2017-16598": {"epss_score": 0.42975, "epss_percentile": 0.97364}, "CVE-2017-16599": {"epss_score": 0.04962, "epss_percentile": 0.89335}, "CVE-2017-16600": {"epss_score": 0.01726, "epss_percentile": 0.81959}, "CVE-2017-16601": {"epss_score": 0.02183, "epss_percentile": 0.83912}, "CVE-2017-16602": {"epss_score": 0.11335, "epss_percentile": 0.93314}, "CVE-2017-16603": {"epss_score": 0.09198, "epss_percentile": 0.92444}, "CVE-2017-16604": {"epss_score": 0.02183, "epss_percentile": 0.83912}, "CVE-2017-16605": {"epss_score": 0.01726, "epss_percentile": 0.81959}, "CVE-2017-16606": {"epss_score": 0.42975, "epss_percentile": 0.97364}, "CVE-2017-16607": {"epss_score": 0.01859, "epss_percentile": 0.82583}, "CVE-2017-16608": {"epss_score": 0.13497, "epss_percentile": 0.9398}, "CVE-2017-16609": {"epss_score": 0.02528, "epss_percentile": 0.85019}, "CVE-2017-16610": {"epss_score": 0.31251, "epss_percentile": 0.96603}, "CVE-2017-16611": {"epss_score": 0.00056, "epss_percentile": 0.17805}, "CVE-2017-16612": {"epss_score": 0.03557, "epss_percentile": 0.87349}, "CVE-2017-16613": {"epss_score": 0.02345, "epss_percentile": 0.8445}, "CVE-2017-16614": {"epss_score": 0.01724, "epss_percentile": 0.81952}, "CVE-2017-16615": {"epss_score": 0.00896, "epss_percentile": 0.75115}, "CVE-2017-16616": {"epss_score": 0.0119, "epss_percentile": 0.78378}, "CVE-2017-16618": {"epss_score": 0.02016, "epss_percentile": 0.83275}, "CVE-2017-16629": {"epss_score": 0.00341, "epss_percentile": 0.56306}, "CVE-2017-16630": {"epss_score": 0.00324, "epss_percentile": 0.54933}, "CVE-2017-16631": {"epss_score": 0.00154, "epss_percentile": 0.3669}, "CVE-2017-16632": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2017-16633": {"epss_score": 0.0003, "epss_percentile": 0.08065}, "CVE-2017-16634": {"epss_score": 0.00096, "epss_percentile": 0.27273}, "CVE-2017-16635": {"epss_score": 0.00251, "epss_percentile": 0.48258}, "CVE-2017-16636": {"epss_score": 0.00171, "epss_percentile": 0.38787}, "CVE-2017-16637": {"epss_score": 0.00041, "epss_percentile": 0.12327}, "CVE-2017-16638": {"epss_score": 0.00248, "epss_percentile": 0.4792}, "CVE-2017-16639": {"epss_score": 0.00586, "epss_percentile": 0.68442}, "CVE-2017-16641": {"epss_score": 0.00465, "epss_percentile": 0.63783}, "CVE-2017-16642": {"epss_score": 0.08366, "epss_percentile": 0.9201}, "CVE-2017-16643": {"epss_score": 0.00032, "epss_percentile": 0.08817}, "CVE-2017-16644": {"epss_score": 0.00114, "epss_percentile": 0.30758}, "CVE-2017-16645": {"epss_score": 0.00041, "epss_percentile": 0.12401}, "CVE-2017-16646": {"epss_score": 0.00083, "epss_percentile": 0.24632}, "CVE-2017-16647": {"epss_score": 0.00086, "epss_percentile": 0.25437}, "CVE-2017-16648": {"epss_score": 0.00054, "epss_percentile": 0.17091}, "CVE-2017-16649": {"epss_score": 0.0008, "epss_percentile": 0.24191}, "CVE-2017-16650": {"epss_score": 0.00079, "epss_percentile": 0.23829}, "CVE-2017-16651": {"epss_score": 0.30221, "epss_percentile": 0.96521}, "CVE-2017-16652": {"epss_score": 0.00222, "epss_percentile": 0.44771}, "CVE-2017-16653": {"epss_score": 0.00343, "epss_percentile": 0.56442}, "CVE-2017-16654": {"epss_score": 0.00572, "epss_percentile": 0.6803}, "CVE-2017-16659": {"epss_score": 0.00111, "epss_percentile": 0.30336}, "CVE-2017-16660": {"epss_score": 0.01457, "epss_percentile": 0.80398}, "CVE-2017-16661": {"epss_score": 0.00181, "epss_percentile": 0.40073}, "CVE-2017-16663": {"epss_score": 0.00175, "epss_percentile": 0.39323}, "CVE-2017-16664": {"epss_score": 0.0122, "epss_percentile": 0.78625}, "CVE-2017-16665": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-16666": {"epss_score": 0.80763, "epss_percentile": 0.99103}, "CVE-2017-16667": {"epss_score": 0.00197, "epss_percentile": 0.41846}, "CVE-2017-16669": {"epss_score": 0.01131, "epss_percentile": 0.77863}, "CVE-2017-16670": {"epss_score": 0.00412, "epss_percentile": 0.60928}, "CVE-2017-16671": {"epss_score": 0.03635, "epss_percentile": 0.87481}, "CVE-2017-16672": {"epss_score": 0.05269, "epss_percentile": 0.89675}, "CVE-2017-16673": {"epss_score": 0.00085, "epss_percentile": 0.25068}, "CVE-2017-16674": {"epss_score": 0.00172, "epss_percentile": 0.39035}, "CVE-2017-16678": {"epss_score": 0.00409, "epss_percentile": 0.60734}, "CVE-2017-16679": {"epss_score": 0.00298, "epss_percentile": 0.52827}, "CVE-2017-16680": {"epss_score": 0.00426, "epss_percentile": 0.61752}, "CVE-2017-16681": {"epss_score": 0.00418, "epss_percentile": 0.61278}, "CVE-2017-16682": {"epss_score": 0.00546, "epss_percentile": 0.67214}, "CVE-2017-16683": {"epss_score": 0.0055, "epss_percentile": 0.67345}, "CVE-2017-16684": {"epss_score": 0.00507, "epss_percentile": 0.65676}, "CVE-2017-16685": {"epss_score": 0.00418, "epss_percentile": 0.61278}, "CVE-2017-16687": {"epss_score": 0.00877, "epss_percentile": 0.74815}, "CVE-2017-16689": {"epss_score": 0.00327, "epss_percentile": 0.55095}, "CVE-2017-16690": {"epss_score": 0.00332, "epss_percentile": 0.55612}, "CVE-2017-16691": {"epss_score": 0.00369, "epss_percentile": 0.58229}, "CVE-2017-16709": {"epss_score": 0.82422, "epss_percentile": 0.99194}, "CVE-2017-16710": {"epss_score": 0.0017, "epss_percentile": 0.38656}, "CVE-2017-16711": {"epss_score": 0.00443, "epss_percentile": 0.62798}, "CVE-2017-16714": {"epss_score": 0.02452, "epss_percentile": 0.8479}, "CVE-2017-16715": {"epss_score": 0.00245, "epss_percentile": 0.47725}, "CVE-2017-16716": {"epss_score": 0.0415, "epss_percentile": 0.8832}, "CVE-2017-16717": {"epss_score": 0.01177, "epss_percentile": 0.78276}, "CVE-2017-16718": {"epss_score": 0.0006, "epss_percentile": 0.18951}, "CVE-2017-16719": {"epss_score": 0.00312, "epss_percentile": 0.53998}, "CVE-2017-16720": {"epss_score": 0.27209, "epss_percentile": 0.9622}, "CVE-2017-16721": {"epss_score": 0.00313, "epss_percentile": 0.54073}, "CVE-2017-16723": {"epss_score": 0.00418, "epss_percentile": 0.61284}, "CVE-2017-16724": {"epss_score": 0.00396, "epss_percentile": 0.59859}, "CVE-2017-16725": {"epss_score": 0.15094, "epss_percentile": 0.9436}, "CVE-2017-16726": {"epss_score": 0.00075, "epss_percentile": 0.22986}, "CVE-2017-16727": {"epss_score": 0.00206, "epss_percentile": 0.42773}, "CVE-2017-16728": {"epss_score": 0.00646, "epss_percentile": 0.70126}, "CVE-2017-16731": {"epss_score": 0.00096, "epss_percentile": 0.27375}, "CVE-2017-16732": {"epss_score": 0.00285, "epss_percentile": 0.5155}, "CVE-2017-16733": {"epss_score": 0.0015, "epss_percentile": 0.36088}, "CVE-2017-16735": {"epss_score": 0.0016, "epss_percentile": 0.37485}, "CVE-2017-16736": {"epss_score": 0.00394, "epss_percentile": 0.59772}, "CVE-2017-16737": {"epss_score": 0.00159, "epss_percentile": 0.37341}, "CVE-2017-16739": {"epss_score": 0.01016, "epss_percentile": 0.76677}, "CVE-2017-16740": {"epss_score": 0.00166, "epss_percentile": 0.382}, "CVE-2017-16741": {"epss_score": 0.0076, "epss_percentile": 0.72817}, "CVE-2017-16743": {"epss_score": 0.0124, "epss_percentile": 0.78803}, "CVE-2017-16744": {"epss_score": 0.17183, "epss_percentile": 0.94794}, "CVE-2017-16745": {"epss_score": 0.0015, "epss_percentile": 0.36078}, "CVE-2017-16747": {"epss_score": 0.00151, "epss_percentile": 0.36256}, "CVE-2017-16748": {"epss_score": 0.05886, "epss_percentile": 0.90294}, "CVE-2017-16749": {"epss_score": 0.00177, "epss_percentile": 0.39591}, "CVE-2017-16751": {"epss_score": 0.00389, "epss_percentile": 0.59462}, "CVE-2017-16753": {"epss_score": 0.0055, "epss_percentile": 0.67347}, "CVE-2017-16754": {"epss_score": 0.0038, "epss_percentile": 0.58968}, "CVE-2017-16755": {"epss_score": 0.00356, "epss_percentile": 0.57393}, "CVE-2017-16756": {"epss_score": 0.00185, "epss_percentile": 0.40461}, "CVE-2017-16757": {"epss_score": 0.00038, "epss_percentile": 0.11154}, "CVE-2017-16758": {"epss_score": 0.00191, "epss_percentile": 0.41255}, "CVE-2017-16759": {"epss_score": 9e-05, "epss_percentile": 0.00609}, "CVE-2017-16760": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2017-16761": {"epss_score": 0.00266, "epss_percentile": 0.49877}, "CVE-2017-16762": {"epss_score": 0.00289, "epss_percentile": 0.52016}, "CVE-2017-16763": {"epss_score": 0.01919, "epss_percentile": 0.82885}, "CVE-2017-16764": {"epss_score": 0.03068, "epss_percentile": 0.86341}, "CVE-2017-16765": {"epss_score": 0.00358, "epss_percentile": 0.57496}, "CVE-2017-16766": {"epss_score": 0.0038, "epss_percentile": 0.58969}, "CVE-2017-16767": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2017-16768": {"epss_score": 0.00184, "epss_percentile": 0.4042}, "CVE-2017-16769": {"epss_score": 0.0023, "epss_percentile": 0.45762}, "CVE-2017-16770": {"epss_score": 0.00224, "epss_percentile": 0.45067}, "CVE-2017-16771": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2017-16772": {"epss_score": 0.01305, "epss_percentile": 0.7933}, "CVE-2017-16773": {"epss_score": 0.00143, "epss_percentile": 0.35143}, "CVE-2017-16774": {"epss_score": 0.00227, "epss_percentile": 0.45377}, "CVE-2017-16775": {"epss_score": 0.00319, "epss_percentile": 0.54535}, "CVE-2017-16776": {"epss_score": 0.01451, "epss_percentile": 0.80364}, "CVE-2017-16777": {"epss_score": 0.00089, "epss_percentile": 0.25821}, "CVE-2017-16778": {"epss_score": 0.01305, "epss_percentile": 0.79324}, "CVE-2017-16780": {"epss_score": 0.01922, "epss_percentile": 0.82905}, "CVE-2017-16781": {"epss_score": 0.00262, "epss_percentile": 0.49385}, "CVE-2017-16782": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2017-16783": {"epss_score": 0.09872, "epss_percentile": 0.92746}, "CVE-2017-16784": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-16785": {"epss_score": 0.00196, "epss_percentile": 0.41773}, "CVE-2017-16786": {"epss_score": 0.00304, "epss_percentile": 0.53294}, "CVE-2017-16787": {"epss_score": 0.09187, "epss_percentile": 0.92439}, "CVE-2017-16788": {"epss_score": 0.01341, "epss_percentile": 0.79585}, "CVE-2017-16789": {"epss_score": 0.00179, "epss_percentile": 0.39831}, "CVE-2017-16790": {"epss_score": 0.00723, "epss_percentile": 0.72023}, "CVE-2017-16792": {"epss_score": 0.00361, "epss_percentile": 0.57727}, "CVE-2017-16793": {"epss_score": 0.00236, "epss_percentile": 0.46393}, "CVE-2017-16794": {"epss_score": 0.00202, "epss_percentile": 0.42426}, "CVE-2017-16796": {"epss_score": 0.00231, "epss_percentile": 0.45768}, "CVE-2017-16797": {"epss_score": 0.00252, "epss_percentile": 0.48343}, "CVE-2017-16798": {"epss_score": 0.0027, "epss_percentile": 0.50261}, "CVE-2017-16799": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2017-16801": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2017-16802": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2017-16803": {"epss_score": 0.00676, "epss_percentile": 0.70921}, "CVE-2017-16804": {"epss_score": 0.00345, "epss_percentile": 0.5658}, "CVE-2017-16805": {"epss_score": 0.00202, "epss_percentile": 0.42426}, "CVE-2017-16806": {"epss_score": 0.9018, "epss_percentile": 0.99566}, "CVE-2017-16807": {"epss_score": 0.00147, "epss_percentile": 0.3571}, "CVE-2017-16808": {"epss_score": 0.01159, "epss_percentile": 0.78126}, "CVE-2017-16810": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2017-16813": {"epss_score": 0.00014, "epss_percentile": 0.01895}, "CVE-2017-16814": {"epss_score": 0.00053, "epss_percentile": 0.16718}, "CVE-2017-16815": {"epss_score": 0.00252, "epss_percentile": 0.48384}, "CVE-2017-16816": {"epss_score": 0.00863, "epss_percentile": 0.74595}, "CVE-2017-16818": {"epss_score": 0.00587, "epss_percentile": 0.68459}, "CVE-2017-16819": {"epss_score": 0.01086, "epss_percentile": 0.77424}, "CVE-2017-16820": {"epss_score": 0.03326, "epss_percentile": 0.86923}, "CVE-2017-16821": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2017-16826": {"epss_score": 0.00189, "epss_percentile": 0.40984}, "CVE-2017-16827": {"epss_score": 0.00189, "epss_percentile": 0.40984}, "CVE-2017-16828": {"epss_score": 0.00189, "epss_percentile": 0.40984}, "CVE-2017-16829": {"epss_score": 0.00435, "epss_percentile": 0.62345}, "CVE-2017-16830": {"epss_score": 0.00257, "epss_percentile": 0.48886}, "CVE-2017-16831": {"epss_score": 0.00189, "epss_percentile": 0.40984}, "CVE-2017-16832": {"epss_score": 0.00189, "epss_percentile": 0.40984}, "CVE-2017-16833": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2017-16834": {"epss_score": 0.00038, "epss_percentile": 0.11161}, "CVE-2017-16835": {"epss_score": 0.0024, "epss_percentile": 0.47197}, "CVE-2017-16836": {"epss_score": 0.00473, "epss_percentile": 0.6409}, "CVE-2017-16837": {"epss_score": 0.00117, "epss_percentile": 0.31382}, "CVE-2017-16839": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2017-16840": {"epss_score": 0.01585, "epss_percentile": 0.81166}, "CVE-2017-16841": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2017-16842": {"epss_score": 0.00072, "epss_percentile": 0.22367}, "CVE-2017-16843": {"epss_score": 0.00108, "epss_percentile": 0.29842}, "CVE-2017-16844": {"epss_score": 0.2023, "epss_percentile": 0.95307}, "CVE-2017-16845": {"epss_score": 0.02074, "epss_percentile": 0.83501}, "CVE-2017-16846": {"epss_score": 0.12312, "epss_percentile": 0.93633}, "CVE-2017-16847": {"epss_score": 0.12312, "epss_percentile": 0.93633}, "CVE-2017-16848": {"epss_score": 0.09454, "epss_percentile": 0.92555}, "CVE-2017-16849": {"epss_score": 0.12312, "epss_percentile": 0.93633}, "CVE-2017-16850": {"epss_score": 0.12312, "epss_percentile": 0.93633}, "CVE-2017-16851": {"epss_score": 0.12312, "epss_percentile": 0.93633}, "CVE-2017-16852": {"epss_score": 0.00315, "epss_percentile": 0.54162}, "CVE-2017-16853": {"epss_score": 0.00694, "epss_percentile": 0.71353}, "CVE-2017-16854": {"epss_score": 0.00358, "epss_percentile": 0.57495}, "CVE-2017-16856": {"epss_score": 0.00189, "epss_percentile": 0.41001}, "CVE-2017-16857": {"epss_score": 0.00274, "epss_percentile": 0.50578}, "CVE-2017-16858": {"epss_score": 0.00128, "epss_percentile": 0.33039}, "CVE-2017-16859": {"epss_score": 0.0136, "epss_percentile": 0.79747}, "CVE-2017-16860": {"epss_score": 0.00228, "epss_percentile": 0.45525}, "CVE-2017-16861": {"epss_score": 0.00555, "epss_percentile": 0.67467}, "CVE-2017-16862": {"epss_score": 0.0017, "epss_percentile": 0.38715}, "CVE-2017-16863": {"epss_score": 0.00203, "epss_percentile": 0.42555}, "CVE-2017-16864": {"epss_score": 0.00226, "epss_percentile": 0.45254}, "CVE-2017-16865": {"epss_score": 0.00137, "epss_percentile": 0.34282}, "CVE-2017-16866": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2017-16867": {"epss_score": 0.00812, "epss_percentile": 0.73745}, "CVE-2017-16868": {"epss_score": 0.00189, "epss_percentile": 0.40989}, "CVE-2017-16869": {"epss_score": 0.00258, "epss_percentile": 0.49005}, "CVE-2017-16870": {"epss_score": 0.00383, "epss_percentile": 0.59097}, "CVE-2017-16871": {"epss_score": 0.01062, "epss_percentile": 0.77179}, "CVE-2017-16872": {"epss_score": 0.00865, "epss_percentile": 0.74623}, "CVE-2017-16873": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2017-16875": {"epss_score": 0.00529, "epss_percentile": 0.6658}, "CVE-2017-16876": {"epss_score": 0.0058, "epss_percentile": 0.68247}, "CVE-2017-16877": {"epss_score": 0.83198, "epss_percentile": 0.99238}, "CVE-2017-16878": {"epss_score": 0.00242, "epss_percentile": 0.47339}, "CVE-2017-16879": {"epss_score": 0.00437, "epss_percentile": 0.6252}, "CVE-2017-16880": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-16881": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-16882": {"epss_score": 0.00042, "epss_percentile": 0.12809}, "CVE-2017-16883": {"epss_score": 0.00315, "epss_percentile": 0.54205}, "CVE-2017-16884": {"epss_score": 0.06199, "epss_percentile": 0.90558}, "CVE-2017-16885": {"epss_score": 0.11035, "epss_percentile": 0.93196}, "CVE-2017-16886": {"epss_score": 0.00162, "epss_percentile": 0.37734}, "CVE-2017-16887": {"epss_score": 0.05625, "epss_percentile": 0.90064}, "CVE-2017-16890": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2017-16892": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-16893": {"epss_score": 0.00157, "epss_percentile": 0.37086}, "CVE-2017-16894": {"epss_score": 0.88787, "epss_percentile": 0.9949}, "CVE-2017-16895": {"epss_score": 0.00284, "epss_percentile": 0.51489}, "CVE-2017-16896": {"epss_score": 0.00351, "epss_percentile": 0.57041}, "CVE-2017-16897": {"epss_score": 0.00422, "epss_percentile": 0.61565}, "CVE-2017-16898": {"epss_score": 0.00149, "epss_percentile": 0.35985}, "CVE-2017-16899": {"epss_score": 0.00426, "epss_percentile": 0.61741}, "CVE-2017-16900": {"epss_score": 0.00052, "epss_percentile": 0.1658}, "CVE-2017-16902": {"epss_score": 0.18288, "epss_percentile": 0.9499}, "CVE-2017-16903": {"epss_score": 0.01016, "epss_percentile": 0.7668}, "CVE-2017-16904": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-16905": {"epss_score": 0.02545, "epss_percentile": 0.8506}, "CVE-2017-16906": {"epss_score": 0.00249, "epss_percentile": 0.48069}, "CVE-2017-16907": {"epss_score": 0.00227, "epss_percentile": 0.45459}, "CVE-2017-16908": {"epss_score": 0.00462, "epss_percentile": 0.63574}, "CVE-2017-16909": {"epss_score": 0.00571, "epss_percentile": 0.67997}, "CVE-2017-16910": {"epss_score": 0.00507, "epss_percentile": 0.65653}, "CVE-2017-16911": {"epss_score": 0.00059, "epss_percentile": 0.18725}, "CVE-2017-16912": {"epss_score": 0.08621, "epss_percentile": 0.92157}, "CVE-2017-16913": {"epss_score": 0.11081, "epss_percentile": 0.93213}, "CVE-2017-16914": {"epss_score": 0.11306, "epss_percentile": 0.93301}, "CVE-2017-16919": {"epss_score": 0.00134, "epss_percentile": 0.33854}, "CVE-2017-16920": {"epss_score": 0.0071, "epss_percentile": 0.7171}, "CVE-2017-16921": {"epss_score": 0.33869, "epss_percentile": 0.96811}, "CVE-2017-16922": {"epss_score": 0.00593, "epss_percentile": 0.68646}, "CVE-2017-16923": {"epss_score": 0.03467, "epss_percentile": 0.87194}, "CVE-2017-16924": {"epss_score": 0.01728, "epss_percentile": 0.81974}, "CVE-2017-16926": {"epss_score": 0.06409, "epss_percentile": 0.9074}, "CVE-2017-16927": {"epss_score": 0.00124, "epss_percentile": 0.32443}, "CVE-2017-16928": {"epss_score": 0.00349, "epss_percentile": 0.56912}, "CVE-2017-16929": {"epss_score": 0.27143, "epss_percentile": 0.96212}, "CVE-2017-16930": {"epss_score": 0.53864, "epss_percentile": 0.979}, "CVE-2017-16931": {"epss_score": 0.0165, "epss_percentile": 0.81559}, "CVE-2017-16932": {"epss_score": 0.12981, "epss_percentile": 0.93834}, "CVE-2017-16933": {"epss_score": 0.0003, "epss_percentile": 0.07984}, "CVE-2017-16934": {"epss_score": 0.18402, "epss_percentile": 0.95012}, "CVE-2017-16935": {"epss_score": 0.07136, "epss_percentile": 0.91274}, "CVE-2017-16936": {"epss_score": 0.00849, "epss_percentile": 0.74381}, "CVE-2017-16938": {"epss_score": 0.00503, "epss_percentile": 0.65482}, "CVE-2017-16939": {"epss_score": 0.10879, "epss_percentile": 0.93143}, "CVE-2017-16941": {"epss_score": 0.00508, "epss_percentile": 0.65715}, "CVE-2017-16942": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2017-16943": {"epss_score": 0.745, "epss_percentile": 0.98803}, "CVE-2017-16944": {"epss_score": 0.76031, "epss_percentile": 0.98874}, "CVE-2017-16945": {"epss_score": 0.00349, "epss_percentile": 0.56912}, "CVE-2017-16946": {"epss_score": 0.00296, "epss_percentile": 0.52574}, "CVE-2017-16948": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2017-16949": {"epss_score": 0.38791, "epss_percentile": 0.9712}, "CVE-2017-16950": {"epss_score": 0.00236, "epss_percentile": 0.46448}, "CVE-2017-16951": {"epss_score": 0.01512, "epss_percentile": 0.80782}, "CVE-2017-16952": {"epss_score": 0.01253, "epss_percentile": 0.78918}, "CVE-2017-16953": {"epss_score": 0.18122, "epss_percentile": 0.9496}, "CVE-2017-16955": {"epss_score": 0.00639, "epss_percentile": 0.69936}, "CVE-2017-16956": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-16957": {"epss_score": 0.02893, "epss_percentile": 0.85922}, "CVE-2017-16958": {"epss_score": 0.01371, "epss_percentile": 0.79807}, "CVE-2017-16959": {"epss_score": 0.00378, "epss_percentile": 0.58814}, "CVE-2017-16960": {"epss_score": 0.00864, "epss_percentile": 0.74612}, "CVE-2017-16961": {"epss_score": 0.00166, "epss_percentile": 0.38235}, "CVE-2017-16962": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2017-16994": {"epss_score": 0.048, "epss_percentile": 0.89157}, "CVE-2017-16995": {"epss_score": 0.82988, "epss_percentile": 0.99225}, "CVE-2017-16996": {"epss_score": 0.00134, "epss_percentile": 0.33857}, "CVE-2017-16997": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2017-17010": {"epss_score": 0.00173, "epss_percentile": 0.39057}, "CVE-2017-17020": {"epss_score": 0.06633, "epss_percentile": 0.90905}, "CVE-2017-17023": {"epss_score": 0.00075, "epss_percentile": 0.23048}, "CVE-2017-17027": {"epss_score": 0.03236, "epss_percentile": 0.86705}, "CVE-2017-17028": {"epss_score": 0.0731, "epss_percentile": 0.914}, "CVE-2017-17029": {"epss_score": 0.03236, "epss_percentile": 0.86705}, "CVE-2017-17030": {"epss_score": 0.03236, "epss_percentile": 0.86705}, "CVE-2017-17031": {"epss_score": 0.03236, "epss_percentile": 0.86705}, "CVE-2017-17032": {"epss_score": 0.03236, "epss_percentile": 0.86705}, "CVE-2017-17033": {"epss_score": 0.0593, "epss_percentile": 0.90335}, "CVE-2017-17042": {"epss_score": 0.00313, "epss_percentile": 0.54058}, "CVE-2017-17043": {"epss_score": 0.03568, "epss_percentile": 0.87367}, "CVE-2017-17044": {"epss_score": 0.00051, "epss_percentile": 0.1616}, "CVE-2017-17045": {"epss_score": 0.00069, "epss_percentile": 0.21476}, "CVE-2017-17046": {"epss_score": 0.00057, "epss_percentile": 0.18077}, "CVE-2017-17049": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2017-17050": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2017-17051": {"epss_score": 0.00841, "epss_percentile": 0.74218}, "CVE-2017-17052": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2017-17053": {"epss_score": 0.00108, "epss_percentile": 0.29812}, "CVE-2017-17054": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2017-17055": {"epss_score": 0.04573, "epss_percentile": 0.88865}, "CVE-2017-17056": {"epss_score": 0.0018, "epss_percentile": 0.39932}, "CVE-2017-17057": {"epss_score": 0.00233, "epss_percentile": 0.45976}, "CVE-2017-17058": {"epss_score": 0.42903, "epss_percentile": 0.9736}, "CVE-2017-17059": {"epss_score": 0.00709, "epss_percentile": 0.71699}, "CVE-2017-17060": {"epss_score": 0.00459, "epss_percentile": 0.63462}, "CVE-2017-17061": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2017-17062": {"epss_score": 0.01388, "epss_percentile": 0.79921}, "CVE-2017-17065": {"epss_score": 0.00288, "epss_percentile": 0.5192}, "CVE-2017-17066": {"epss_score": 0.01353, "epss_percentile": 0.79698}, "CVE-2017-17067": {"epss_score": 0.03341, "epss_percentile": 0.86943}, "CVE-2017-17068": {"epss_score": 0.00329, "epss_percentile": 0.55304}, "CVE-2017-17069": {"epss_score": 0.00152, "epss_percentile": 0.36501}, "CVE-2017-17080": {"epss_score": 0.00391, "epss_percentile": 0.59619}, "CVE-2017-17081": {"epss_score": 0.00526, "epss_percentile": 0.66422}, "CVE-2017-17083": {"epss_score": 0.00918, "epss_percentile": 0.75445}, "CVE-2017-17084": {"epss_score": 0.00918, "epss_percentile": 0.75445}, "CVE-2017-17085": {"epss_score": 0.10395, "epss_percentile": 0.92973}, "CVE-2017-17086": {"epss_score": 0.00689, "epss_percentile": 0.71226}, "CVE-2017-17087": {"epss_score": 0.00051, "epss_percentile": 0.16062}, "CVE-2017-17088": {"epss_score": 0.30343, "epss_percentile": 0.96533}, "CVE-2017-17089": {"epss_score": 0.00166, "epss_percentile": 0.38199}, "CVE-2017-17090": {"epss_score": 0.89199, "epss_percentile": 0.99515}, "CVE-2017-17091": {"epss_score": 0.04478, "epss_percentile": 0.88741}, "CVE-2017-17092": {"epss_score": 0.03307, "epss_percentile": 0.86879}, "CVE-2017-17093": {"epss_score": 0.06276, "epss_percentile": 0.90632}, "CVE-2017-17094": {"epss_score": 0.06615, "epss_percentile": 0.90891}, "CVE-2017-17095": {"epss_score": 0.03473, "epss_percentile": 0.87204}, "CVE-2017-17096": {"epss_score": 0.00318, "epss_percentile": 0.54435}, "CVE-2017-17097": {"epss_score": 0.36893, "epss_percentile": 0.97008}, "CVE-2017-17098": {"epss_score": 0.31242, "epss_percentile": 0.96602}, "CVE-2017-17099": {"epss_score": 0.16384, "epss_percentile": 0.94642}, "CVE-2017-17101": {"epss_score": 0.01836, "epss_percentile": 0.82468}, "CVE-2017-17102": {"epss_score": 0.00233, "epss_percentile": 0.46061}, "CVE-2017-17103": {"epss_score": 0.00216, "epss_percentile": 0.44137}, "CVE-2017-17104": {"epss_score": 0.00435, "epss_percentile": 0.62329}, "CVE-2017-17105": {"epss_score": 0.90398, "epss_percentile": 0.9958}, "CVE-2017-17106": {"epss_score": 0.27791, "epss_percentile": 0.96283}, "CVE-2017-17107": {"epss_score": 0.03763, "epss_percentile": 0.87691}, "CVE-2017-17108": {"epss_score": 0.01619, "epss_percentile": 0.81377}, "CVE-2017-17110": {"epss_score": 0.17712, "epss_percentile": 0.94894}, "CVE-2017-17111": {"epss_score": 0.17712, "epss_percentile": 0.94894}, "CVE-2017-17112": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2017-17113": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2017-17114": {"epss_score": 0.00056, "epss_percentile": 0.17717}, "CVE-2017-17121": {"epss_score": 0.00367, "epss_percentile": 0.58122}, "CVE-2017-17122": {"epss_score": 0.00218, "epss_percentile": 0.44387}, "CVE-2017-17123": {"epss_score": 0.00442, "epss_percentile": 0.62708}, "CVE-2017-17124": {"epss_score": 0.00387, "epss_percentile": 0.593}, "CVE-2017-17125": {"epss_score": 0.00377, "epss_percentile": 0.58707}, "CVE-2017-17126": {"epss_score": 0.00377, "epss_percentile": 0.58707}, "CVE-2017-17127": {"epss_score": 0.00399, "epss_percentile": 0.60114}, "CVE-2017-17128": {"epss_score": 0.00352, "epss_percentile": 0.57122}, "CVE-2017-17129": {"epss_score": 0.00374, "epss_percentile": 0.58584}, "CVE-2017-17130": {"epss_score": 0.00476, "epss_percentile": 0.64276}, "CVE-2017-17131": {"epss_score": 0.00157, "epss_percentile": 0.37024}, "CVE-2017-17132": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2017-17133": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2017-17134": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2017-17135": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2017-17136": {"epss_score": 0.00016, "epss_percentile": 0.0293}, "CVE-2017-17137": {"epss_score": 0.00017, "epss_percentile": 0.03058}, "CVE-2017-17138": {"epss_score": 0.00012, "epss_percentile": 0.01333}, "CVE-2017-17139": {"epss_score": 0.00106, "epss_percentile": 0.29423}, "CVE-2017-17140": {"epss_score": 0.00106, "epss_percentile": 0.29423}, "CVE-2017-17141": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2017-17142": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2017-17143": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2017-17144": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2017-17145": {"epss_score": 0.00036, "epss_percentile": 0.1052}, "CVE-2017-17146": {"epss_score": 0.00057, "epss_percentile": 0.18149}, "CVE-2017-17147": {"epss_score": 0.00019, "epss_percentile": 0.04233}, "CVE-2017-17148": {"epss_score": 0.00019, "epss_percentile": 0.04233}, "CVE-2017-17149": {"epss_score": 0.00025, "epss_percentile": 0.06227}, "CVE-2017-17150": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2017-17151": {"epss_score": 0.00129, "epss_percentile": 0.33208}, "CVE-2017-17152": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2017-17153": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2017-17154": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2017-17155": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2017-17156": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2017-17157": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2017-17158": {"epss_score": 0.0003, "epss_percentile": 0.08165}, "CVE-2017-17159": {"epss_score": 0.0003, "epss_percentile": 0.0831}, "CVE-2017-17160": {"epss_score": 0.00265, "epss_percentile": 0.49843}, "CVE-2017-17161": {"epss_score": 0.00023, "epss_percentile": 0.05437}, "CVE-2017-17162": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2017-17163": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2017-17164": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2017-17165": {"epss_score": 0.00202, "epss_percentile": 0.42468}, "CVE-2017-17166": {"epss_score": 0.00229, "epss_percentile": 0.45557}, "CVE-2017-17167": {"epss_score": 0.00068, "epss_percentile": 0.21389}, "CVE-2017-17168": {"epss_score": 0.00204, "epss_percentile": 0.42594}, "CVE-2017-17169": {"epss_score": 0.00204, "epss_percentile": 0.42594}, "CVE-2017-17170": {"epss_score": 0.00204, "epss_percentile": 0.42594}, "CVE-2017-17171": {"epss_score": 0.00046, "epss_percentile": 0.1439}, "CVE-2017-17172": {"epss_score": 0.00024, "epss_percentile": 0.05854}, "CVE-2017-17173": {"epss_score": 0.00108, "epss_percentile": 0.29869}, "CVE-2017-17174": {"epss_score": 0.00154, "epss_percentile": 0.36716}, "CVE-2017-17175": {"epss_score": 0.00048, "epss_percentile": 0.14985}, "CVE-2017-17176": {"epss_score": 0.00021, "epss_percentile": 0.04861}, "CVE-2017-17182": {"epss_score": 0.00173, "epss_percentile": 0.39125}, "CVE-2017-17183": {"epss_score": 0.00173, "epss_percentile": 0.39125}, "CVE-2017-17184": {"epss_score": 0.00173, "epss_percentile": 0.39125}, "CVE-2017-17185": {"epss_score": 0.00173, "epss_percentile": 0.39125}, "CVE-2017-17186": {"epss_score": 0.00168, "epss_percentile": 0.38478}, "CVE-2017-17187": {"epss_score": 0.00173, "epss_percentile": 0.39125}, "CVE-2017-17199": {"epss_score": 0.00259, "epss_percentile": 0.49069}, "CVE-2017-17200": {"epss_score": 0.00259, "epss_percentile": 0.49069}, "CVE-2017-17201": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2017-17202": {"epss_score": 0.00147, "epss_percentile": 0.35792}, "CVE-2017-17215": {"epss_score": 0.927, "epss_percentile": 0.99736}, "CVE-2017-17216": {"epss_score": 0.00138, "epss_percentile": 0.34405}, "CVE-2017-17217": {"epss_score": 0.00138, "epss_percentile": 0.34405}, "CVE-2017-17218": {"epss_score": 0.00153, "epss_percentile": 0.3661}, "CVE-2017-17219": {"epss_score": 0.00153, "epss_percentile": 0.3661}, "CVE-2017-17220": {"epss_score": 0.00153, "epss_percentile": 0.3661}, "CVE-2017-17221": {"epss_score": 0.0081, "epss_percentile": 0.73715}, "CVE-2017-17222": {"epss_score": 0.0081, "epss_percentile": 0.73715}, "CVE-2017-17223": {"epss_score": 0.00481, "epss_percentile": 0.64484}, "CVE-2017-17224": {"epss_score": 0.00062, "epss_percentile": 0.19746}, "CVE-2017-17225": {"epss_score": 0.00058, "epss_percentile": 0.18577}, "CVE-2017-17226": {"epss_score": 0.00178, "epss_percentile": 0.39689}, "CVE-2017-17227": {"epss_score": 0.00108, "epss_percentile": 0.29869}, "CVE-2017-17250": {"epss_score": 0.00174, "epss_percentile": 0.39154}, "CVE-2017-17251": {"epss_score": 0.00154, "epss_percentile": 0.3667}, "CVE-2017-17252": {"epss_score": 0.00153, "epss_percentile": 0.3661}, "CVE-2017-17253": {"epss_score": 0.00147, "epss_percentile": 0.35792}, "CVE-2017-17254": {"epss_score": 0.00148, "epss_percentile": 0.35865}, "CVE-2017-17255": {"epss_score": 0.00148, "epss_percentile": 0.35865}, "CVE-2017-17256": {"epss_score": 0.00265, "epss_percentile": 0.49753}, "CVE-2017-17257": {"epss_score": 0.00265, "epss_percentile": 0.49753}, "CVE-2017-17258": {"epss_score": 0.00147, "epss_percentile": 0.35792}, "CVE-2017-17279": {"epss_score": 0.00124, "epss_percentile": 0.32442}, "CVE-2017-17280": {"epss_score": 0.00037, "epss_percentile": 0.10867}, "CVE-2017-17281": {"epss_score": 0.0008, "epss_percentile": 0.24046}, "CVE-2017-17282": {"epss_score": 0.00051, "epss_percentile": 0.16302}, "CVE-2017-17283": {"epss_score": 0.00201, "epss_percentile": 0.42392}, "CVE-2017-17284": {"epss_score": 0.00224, "epss_percentile": 0.44984}, "CVE-2017-17285": {"epss_score": 0.00045, "epss_percentile": 0.13724}, "CVE-2017-17286": {"epss_score": 0.00087, "epss_percentile": 0.25578}, "CVE-2017-17287": {"epss_score": 0.00162, "epss_percentile": 0.37705}, "CVE-2017-17288": {"epss_score": 0.00153, "epss_percentile": 0.3661}, "CVE-2017-17289": {"epss_score": 0.00023, "epss_percentile": 0.05402}, "CVE-2017-17290": {"epss_score": 0.00265, "epss_percentile": 0.49753}, "CVE-2017-17291": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2017-17292": {"epss_score": 0.00023, "epss_percentile": 0.05402}, "CVE-2017-17293": {"epss_score": 0.00024, "epss_percentile": 0.05865}, "CVE-2017-17294": {"epss_score": 0.00023, "epss_percentile": 0.05402}, "CVE-2017-17295": {"epss_score": 0.00162, "epss_percentile": 0.37705}, "CVE-2017-17296": {"epss_score": 0.00229, "epss_percentile": 0.45557}, "CVE-2017-17297": {"epss_score": 0.00162, "epss_percentile": 0.37705}, "CVE-2017-17298": {"epss_score": 0.00118, "epss_percentile": 0.31516}, "CVE-2017-17299": {"epss_score": 0.00147, "epss_percentile": 0.35792}, "CVE-2017-17300": {"epss_score": 0.00421, "epss_percentile": 0.61475}, "CVE-2017-17301": {"epss_score": 0.00157, "epss_percentile": 0.37109}, "CVE-2017-17302": {"epss_score": 0.00013, "epss_percentile": 0.01632}, "CVE-2017-17303": {"epss_score": 0.00094, "epss_percentile": 0.26952}, "CVE-2017-17304": {"epss_score": 0.00204, "epss_percentile": 0.42594}, "CVE-2017-17305": {"epss_score": 0.00145, "epss_percentile": 0.35404}, "CVE-2017-17306": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2017-17307": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2017-17308": {"epss_score": 0.00225, "epss_percentile": 0.45234}, "CVE-2017-17309": {"epss_score": 0.09184, "epss_percentile": 0.92435}, "CVE-2017-17310": {"epss_score": 0.00265, "epss_percentile": 0.49753}, "CVE-2017-17311": {"epss_score": 0.0012, "epss_percentile": 0.31704}, "CVE-2017-17312": {"epss_score": 0.0012, "epss_percentile": 0.31704}, "CVE-2017-17313": {"epss_score": 0.00075, "epss_percentile": 0.22914}, "CVE-2017-17314": {"epss_score": 0.00134, "epss_percentile": 0.33924}, "CVE-2017-17315": {"epss_score": 0.00153, "epss_percentile": 0.3661}, "CVE-2017-17316": {"epss_score": 0.00153, "epss_percentile": 0.3661}, "CVE-2017-17317": {"epss_score": 0.00152, "epss_percentile": 0.36396}, "CVE-2017-17318": {"epss_score": 0.00047, "epss_percentile": 0.14797}, "CVE-2017-17319": {"epss_score": 0.00101, "epss_percentile": 0.28619}, "CVE-2017-17320": {"epss_score": 0.00108, "epss_percentile": 0.29869}, "CVE-2017-17321": {"epss_score": 0.00027, "epss_percentile": 0.06751}, "CVE-2017-17322": {"epss_score": 0.00103, "epss_percentile": 0.28986}, "CVE-2017-17323": {"epss_score": 0.00069, "epss_percentile": 0.21631}, "CVE-2017-17324": {"epss_score": 0.00352, "epss_percentile": 0.57082}, "CVE-2017-17325": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2017-17326": {"epss_score": 0.00027, "epss_percentile": 0.07001}, "CVE-2017-17327": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2017-17328": {"epss_score": 0.00101, "epss_percentile": 0.28619}, "CVE-2017-17329": {"epss_score": 0.00026, "epss_percentile": 0.06404}, "CVE-2017-17330": {"epss_score": 0.00026, "epss_percentile": 0.06404}, "CVE-2017-17381": {"epss_score": 0.00185, "epss_percentile": 0.40463}, "CVE-2017-17382": {"epss_score": 0.79419, "epss_percentile": 0.99037}, "CVE-2017-17383": {"epss_score": 0.00162, "epss_percentile": 0.377}, "CVE-2017-17384": {"epss_score": 0.00483, "epss_percentile": 0.64595}, "CVE-2017-17405": {"epss_score": 0.88646, "epss_percentile": 0.99482}, "CVE-2017-17406": {"epss_score": 0.30392, "epss_percentile": 0.96536}, "CVE-2017-17407": {"epss_score": 0.0641, "epss_percentile": 0.9074}, "CVE-2017-17408": {"epss_score": 0.0634, "epss_percentile": 0.90681}, "CVE-2017-17409": {"epss_score": 0.01278, "epss_percentile": 0.79127}, "CVE-2017-17410": {"epss_score": 0.01278, "epss_percentile": 0.79127}, "CVE-2017-17411": {"epss_score": 0.92161, "epss_percentile": 0.99695}, "CVE-2017-17412": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17413": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17414": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17415": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17416": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17417": {"epss_score": 0.15977, "epss_percentile": 0.94546}, "CVE-2017-17418": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17419": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17420": {"epss_score": 0.19119, "epss_percentile": 0.95132}, "CVE-2017-17421": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17422": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17423": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17424": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17425": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17426": {"epss_score": 0.00358, "epss_percentile": 0.5749}, "CVE-2017-17427": {"epss_score": 0.76595, "epss_percentile": 0.98897}, "CVE-2017-17428": {"epss_score": 0.78881, "epss_percentile": 0.99008}, "CVE-2017-17429": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2017-17430": {"epss_score": 0.00892, "epss_percentile": 0.7507}, "CVE-2017-17431": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17432": {"epss_score": 0.01235, "epss_percentile": 0.78765}, "CVE-2017-17433": {"epss_score": 0.01555, "epss_percentile": 0.81005}, "CVE-2017-17434": {"epss_score": 0.01156, "epss_percentile": 0.78084}, "CVE-2017-17435": {"epss_score": 0.0011, "epss_percentile": 0.30161}, "CVE-2017-17436": {"epss_score": 0.0003, "epss_percentile": 0.08026}, "CVE-2017-17439": {"epss_score": 0.0918, "epss_percentile": 0.92434}, "CVE-2017-17440": {"epss_score": 0.01003, "epss_percentile": 0.76523}, "CVE-2017-17442": {"epss_score": 0.00364, "epss_percentile": 0.57907}, "CVE-2017-17443": {"epss_score": 0.00353, "epss_percentile": 0.57179}, "CVE-2017-17446": {"epss_score": 0.00653, "epss_percentile": 0.70337}, "CVE-2017-17448": {"epss_score": 0.00061, "epss_percentile": 0.19452}, "CVE-2017-17449": {"epss_score": 0.00055, "epss_percentile": 0.17553}, "CVE-2017-17450": {"epss_score": 0.00058, "epss_percentile": 0.18296}, "CVE-2017-17451": {"epss_score": 0.13674, "epss_percentile": 0.94031}, "CVE-2017-17454": {"epss_score": 0.0034, "epss_percentile": 0.56275}, "CVE-2017-17455": {"epss_score": 0.00135, "epss_percentile": 0.34012}, "CVE-2017-17458": {"epss_score": 0.17249, "epss_percentile": 0.94807}, "CVE-2017-17459": {"epss_score": 0.01142, "epss_percentile": 0.77974}, "CVE-2017-17463": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2017-17464": {"epss_score": 0.00353, "epss_percentile": 0.57154}, "CVE-2017-17465": {"epss_score": 0.00353, "epss_percentile": 0.57154}, "CVE-2017-17466": {"epss_score": 0.0004, "epss_percentile": 0.11892}, "CVE-2017-17467": {"epss_score": 0.00033, "epss_percentile": 0.09306}, "CVE-2017-17468": {"epss_score": 0.0004, "epss_percentile": 0.11892}, "CVE-2017-17469": {"epss_score": 0.00033, "epss_percentile": 0.09306}, "CVE-2017-17470": {"epss_score": 0.00033, "epss_percentile": 0.09306}, "CVE-2017-17471": {"epss_score": 0.00033, "epss_percentile": 0.09306}, "CVE-2017-17472": {"epss_score": 0.00118, "epss_percentile": 0.31468}, "CVE-2017-17473": {"epss_score": 0.00118, "epss_percentile": 0.31468}, "CVE-2017-17474": {"epss_score": 0.00118, "epss_percentile": 0.31468}, "CVE-2017-17475": {"epss_score": 0.00118, "epss_percentile": 0.31468}, "CVE-2017-17476": {"epss_score": 0.00909, "epss_percentile": 0.75298}, "CVE-2017-17477": {"epss_score": 0.00409, "epss_percentile": 0.6072}, "CVE-2017-17478": {"epss_score": 0.0026, "epss_percentile": 0.49199}, "CVE-2017-17479": {"epss_score": 0.06464, "epss_percentile": 0.90772}, "CVE-2017-17480": {"epss_score": 0.03921, "epss_percentile": 0.87952}, "CVE-2017-17482": {"epss_score": 0.00426, "epss_percentile": 0.61767}, "CVE-2017-17484": {"epss_score": 0.02204, "epss_percentile": 0.83999}, "CVE-2017-17485": {"epss_score": 0.79787, "epss_percentile": 0.99055}, "CVE-2017-17497": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2017-17498": {"epss_score": 0.00714, "epss_percentile": 0.71821}, "CVE-2017-17499": {"epss_score": 0.02031, "epss_percentile": 0.83334}, "CVE-2017-17500": {"epss_score": 0.02188, "epss_percentile": 0.83927}, "CVE-2017-17501": {"epss_score": 0.02188, "epss_percentile": 0.83927}, "CVE-2017-17502": {"epss_score": 0.00945, "epss_percentile": 0.75797}, "CVE-2017-17503": {"epss_score": 0.00945, "epss_percentile": 0.75797}, "CVE-2017-17504": {"epss_score": 0.00979, "epss_percentile": 0.7626}, "CVE-2017-17505": {"epss_score": 0.00467, "epss_percentile": 0.63837}, "CVE-2017-17506": {"epss_score": 0.00465, "epss_percentile": 0.63785}, "CVE-2017-17507": {"epss_score": 0.00147, "epss_percentile": 0.35776}, "CVE-2017-17508": {"epss_score": 0.00465, "epss_percentile": 0.63785}, "CVE-2017-17509": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-17511": {"epss_score": 0.0056, "epss_percentile": 0.6764}, "CVE-2017-17512": {"epss_score": 0.00594, "epss_percentile": 0.68656}, "CVE-2017-17513": {"epss_score": 0.00508, "epss_percentile": 0.65713}, "CVE-2017-17514": {"epss_score": 0.0056, "epss_percentile": 0.6764}, "CVE-2017-17515": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17516": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17517": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17518": {"epss_score": 0.00586, "epss_percentile": 0.68451}, "CVE-2017-17519": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17520": {"epss_score": 0.0053, "epss_percentile": 0.66636}, "CVE-2017-17521": {"epss_score": 0.00363, "epss_percentile": 0.57832}, "CVE-2017-17522": {"epss_score": 0.0065, "epss_percentile": 0.70261}, "CVE-2017-17523": {"epss_score": 0.00632, "epss_percentile": 0.6974}, "CVE-2017-17524": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17525": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17526": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17527": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17528": {"epss_score": 0.0053, "epss_percentile": 0.66636}, "CVE-2017-17529": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17530": {"epss_score": 0.00554, "epss_percentile": 0.67434}, "CVE-2017-17531": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17532": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17533": {"epss_score": 0.00704, "epss_percentile": 0.71551}, "CVE-2017-17534": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17535": {"epss_score": 0.00545, "epss_percentile": 0.67182}, "CVE-2017-17536": {"epss_score": 0.00787, "epss_percentile": 0.73308}, "CVE-2017-17537": {"epss_score": 0.017, "epss_percentile": 0.81827}, "CVE-2017-17538": {"epss_score": 0.22259, "epss_percentile": 0.95617}, "CVE-2017-17539": {"epss_score": 0.00399, "epss_percentile": 0.60121}, "CVE-2017-17540": {"epss_score": 0.00399, "epss_percentile": 0.60121}, "CVE-2017-17541": {"epss_score": 0.00166, "epss_percentile": 0.38245}, "CVE-2017-17543": {"epss_score": 0.00068, "epss_percentile": 0.21246}, "CVE-2017-17544": {"epss_score": 0.00361, "epss_percentile": 0.57732}, "CVE-2017-17549": {"epss_score": 0.00343, "epss_percentile": 0.56465}, "CVE-2017-17550": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2017-17551": {"epss_score": 0.00315, "epss_percentile": 0.54191}, "CVE-2017-17552": {"epss_score": 0.00332, "epss_percentile": 0.55599}, "CVE-2017-17553": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2017-17554": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2017-17555": {"epss_score": 0.0036, "epss_percentile": 0.5765}, "CVE-2017-17556": {"epss_score": 0.0013, "epss_percentile": 0.33301}, "CVE-2017-17557": {"epss_score": 0.29016, "epss_percentile": 0.96411}, "CVE-2017-17558": {"epss_score": 0.00039, "epss_percentile": 0.11582}, "CVE-2017-17560": {"epss_score": 0.83376, "epss_percentile": 0.99247}, "CVE-2017-17561": {"epss_score": 0.00643, "epss_percentile": 0.70048}, "CVE-2017-17562": {"epss_score": 0.9403, "epss_percentile": 0.99889}, "CVE-2017-17563": {"epss_score": 0.00064, "epss_percentile": 0.20388}, "CVE-2017-17564": {"epss_score": 0.00064, "epss_percentile": 0.20388}, "CVE-2017-17565": {"epss_score": 0.00067, "epss_percentile": 0.21141}, "CVE-2017-17566": {"epss_score": 0.00105, "epss_percentile": 0.29256}, "CVE-2017-17567": {"epss_score": 0.00251, "epss_percentile": 0.48287}, "CVE-2017-17568": {"epss_score": 0.00323, "epss_percentile": 0.54923}, "CVE-2017-17569": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17570": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17571": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17572": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17573": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17574": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17575": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17576": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17577": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17578": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17579": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17580": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17581": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17582": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17583": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17584": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17585": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17586": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17587": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17588": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17589": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17590": {"epss_score": 0.00709, "epss_percentile": 0.717}, "CVE-2017-17591": {"epss_score": 0.02093, "epss_percentile": 0.83577}, "CVE-2017-17592": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17593": {"epss_score": 0.16206, "epss_percentile": 0.94594}, "CVE-2017-17594": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17595": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17596": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17597": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17598": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17599": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17600": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17601": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17602": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17603": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17604": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17605": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17606": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17607": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17608": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17609": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17610": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17611": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17612": {"epss_score": 0.03786, "epss_percentile": 0.87726}, "CVE-2017-17613": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17614": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17615": {"epss_score": 0.00237, "epss_percentile": 0.4671}, "CVE-2017-17616": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17617": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17618": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17619": {"epss_score": 0.04151, "epss_percentile": 0.88323}, "CVE-2017-17620": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17621": {"epss_score": 0.04151, "epss_percentile": 0.88323}, "CVE-2017-17622": {"epss_score": 0.04151, "epss_percentile": 0.88323}, "CVE-2017-17623": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17624": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17625": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17626": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17627": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17628": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17629": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17630": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17631": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17632": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17633": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17634": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17635": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17636": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17637": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17638": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17639": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17640": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17641": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17642": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17643": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2017-17645": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17648": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-17649": {"epss_score": 0.01265, "epss_percentile": 0.79002}, "CVE-2017-17651": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2017-17652": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17653": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17654": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17655": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17656": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17657": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17658": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17659": {"epss_score": 0.14875, "epss_percentile": 0.94312}, "CVE-2017-17662": {"epss_score": 0.03553, "epss_percentile": 0.87345}, "CVE-2017-17663": {"epss_score": 0.00578, "epss_percentile": 0.68193}, "CVE-2017-17664": {"epss_score": 0.03141, "epss_percentile": 0.86487}, "CVE-2017-17665": {"epss_score": 0.00269, "epss_percentile": 0.50169}, "CVE-2017-17668": {"epss_score": 0.00347, "epss_percentile": 0.56762}, "CVE-2017-17669": {"epss_score": 0.00174, "epss_percentile": 0.39258}, "CVE-2017-17670": {"epss_score": 0.01254, "epss_percentile": 0.78921}, "CVE-2017-17671": {"epss_score": 0.01286, "epss_percentile": 0.79183}, "CVE-2017-17672": {"epss_score": 0.08279, "epss_percentile": 0.91966}, "CVE-2017-17674": {"epss_score": 0.03285, "epss_percentile": 0.86823}, "CVE-2017-17675": {"epss_score": 0.00327, "epss_percentile": 0.55136}, "CVE-2017-17677": {"epss_score": 0.01014, "epss_percentile": 0.76655}, "CVE-2017-17678": {"epss_score": 0.00465, "epss_percentile": 0.63767}, "CVE-2017-17680": {"epss_score": 0.00467, "epss_percentile": 0.63816}, "CVE-2017-17681": {"epss_score": 0.00455, "epss_percentile": 0.63305}, "CVE-2017-17682": {"epss_score": 0.01465, "epss_percentile": 0.80452}, "CVE-2017-17683": {"epss_score": 0.00261, "epss_percentile": 0.49289}, "CVE-2017-17684": {"epss_score": 0.00261, "epss_percentile": 0.49289}, "CVE-2017-17688": {"epss_score": 0.02845, "epss_percentile": 0.85818}, "CVE-2017-17689": {"epss_score": 0.00822, "epss_percentile": 0.73914}, "CVE-2017-17691": {"epss_score": 0.00287, "epss_percentile": 0.5186}, "CVE-2017-17692": {"epss_score": 0.61074, "epss_percentile": 0.98234}, "CVE-2017-17693": {"epss_score": 0.00146, "epss_percentile": 0.35554}, "CVE-2017-17694": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-17695": {"epss_score": 0.00232, "epss_percentile": 0.45894}, "CVE-2017-17696": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2017-17697": {"epss_score": 0.00276, "epss_percentile": 0.50703}, "CVE-2017-17698": {"epss_score": 0.01883, "epss_percentile": 0.82698}, "CVE-2017-17699": {"epss_score": 0.00353, "epss_percentile": 0.57154}, "CVE-2017-17700": {"epss_score": 0.00353, "epss_percentile": 0.57154}, "CVE-2017-17701": {"epss_score": 0.00353, "epss_percentile": 0.57154}, "CVE-2017-17703": {"epss_score": 0.00652, "epss_percentile": 0.70307}, "CVE-2017-17704": {"epss_score": 0.00155, "epss_percentile": 0.36796}, "CVE-2017-17707": {"epss_score": 0.00391, "epss_percentile": 0.59621}, "CVE-2017-17708": {"epss_score": 0.00265, "epss_percentile": 0.49792}, "CVE-2017-17712": {"epss_score": 0.00076, "epss_percentile": 0.23088}, "CVE-2017-17713": {"epss_score": 0.00357, "epss_percentile": 0.57407}, "CVE-2017-17714": {"epss_score": 0.00396, "epss_percentile": 0.59865}, "CVE-2017-17715": {"epss_score": 0.00527, "epss_percentile": 0.66465}, "CVE-2017-17716": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2017-17717": {"epss_score": 0.00116, "epss_percentile": 0.31101}, "CVE-2017-17718": {"epss_score": 0.00172, "epss_percentile": 0.38955}, "CVE-2017-17719": {"epss_score": 0.00209, "epss_percentile": 0.4338}, "CVE-2017-17721": {"epss_score": 0.06936, "epss_percentile": 0.91128}, "CVE-2017-17722": {"epss_score": 0.003, "epss_percentile": 0.52978}, "CVE-2017-17723": {"epss_score": 0.0061, "epss_percentile": 0.69176}, "CVE-2017-17724": {"epss_score": 0.00448, "epss_percentile": 0.63004}, "CVE-2017-17725": {"epss_score": 0.00563, "epss_percentile": 0.67738}, "CVE-2017-17727": {"epss_score": 0.00659, "epss_percentile": 0.70509}, "CVE-2017-17730": {"epss_score": 0.00339, "epss_percentile": 0.56204}, "CVE-2017-17731": {"epss_score": 0.84456, "epss_percentile": 0.9929}, "CVE-2017-17733": {"epss_score": 0.31783, "epss_percentile": 0.96648}, "CVE-2017-17734": {"epss_score": 0.00275, "epss_percentile": 0.50653}, "CVE-2017-17735": {"epss_score": 0.00275, "epss_percentile": 0.50653}, "CVE-2017-17736": {"epss_score": 0.92649, "epss_percentile": 0.99733}, "CVE-2017-17737": {"epss_score": 0.00339, "epss_percentile": 0.56179}, "CVE-2017-17738": {"epss_score": 0.16154, "epss_percentile": 0.94579}, "CVE-2017-17739": {"epss_score": 0.21264, "epss_percentile": 0.95491}, "CVE-2017-17740": {"epss_score": 0.01643, "epss_percentile": 0.81516}, "CVE-2017-17741": {"epss_score": 0.00073, "epss_percentile": 0.22644}, "CVE-2017-17742": {"epss_score": 0.01067, "epss_percentile": 0.77226}, "CVE-2017-17743": {"epss_score": 0.00482, "epss_percentile": 0.64526}, "CVE-2017-17744": {"epss_score": 0.00209, "epss_percentile": 0.4338}, "CVE-2017-17745": {"epss_score": 0.00157, "epss_percentile": 0.37034}, "CVE-2017-17746": {"epss_score": 0.00173, "epss_percentile": 0.39126}, "CVE-2017-17747": {"epss_score": 0.00164, "epss_percentile": 0.37957}, "CVE-2017-17749": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-17750": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2017-17751": {"epss_score": 0.00533, "epss_percentile": 0.6676}, "CVE-2017-17752": {"epss_score": 0.00259, "epss_percentile": 0.49043}, "CVE-2017-17753": {"epss_score": 0.00182, "epss_percentile": 0.40222}, "CVE-2017-17757": {"epss_score": 0.01277, "epss_percentile": 0.79112}, "CVE-2017-17758": {"epss_score": 0.01277, "epss_percentile": 0.79112}, "CVE-2017-17759": {"epss_score": 0.12548, "epss_percentile": 0.93712}, "CVE-2017-17760": {"epss_score": 0.01536, "epss_percentile": 0.80919}, "CVE-2017-17761": {"epss_score": 0.04978, "epss_percentile": 0.89357}, "CVE-2017-17762": {"epss_score": 0.14323, "epss_percentile": 0.94186}, "CVE-2017-17763": {"epss_score": 0.00709, "epss_percentile": 0.7169}, "CVE-2017-17764": {"epss_score": 0.0005, "epss_percentile": 0.15684}, "CVE-2017-17765": {"epss_score": 0.00017, "epss_percentile": 0.0312}, "CVE-2017-17766": {"epss_score": 0.00182, "epss_percentile": 0.40154}, "CVE-2017-17767": {"epss_score": 0.00016, "epss_percentile": 0.02699}, "CVE-2017-17769": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2017-17770": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-17771": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-17772": {"epss_score": 0.00153, "epss_percentile": 0.36519}, "CVE-2017-17773": {"epss_score": 0.00555, "epss_percentile": 0.67469}, "CVE-2017-17774": {"epss_score": 0.00121, "epss_percentile": 0.31817}, "CVE-2017-17775": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17776": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2017-17777": {"epss_score": 0.00725, "epss_percentile": 0.72057}, "CVE-2017-17778": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2017-17779": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-17780": {"epss_score": 0.00281, "epss_percentile": 0.51197}, "CVE-2017-17782": {"epss_score": 0.00659, "epss_percentile": 0.70514}, "CVE-2017-17783": {"epss_score": 0.00458, "epss_percentile": 0.63437}, "CVE-2017-17784": {"epss_score": 0.0039, "epss_percentile": 0.59522}, "CVE-2017-17785": {"epss_score": 0.00366, "epss_percentile": 0.58096}, "CVE-2017-17786": {"epss_score": 0.00326, "epss_percentile": 0.55065}, "CVE-2017-17787": {"epss_score": 0.00351, "epss_percentile": 0.57015}, "CVE-2017-17788": {"epss_score": 0.005, "epss_percentile": 0.65313}, "CVE-2017-17789": {"epss_score": 0.00291, "epss_percentile": 0.52149}, "CVE-2017-17790": {"epss_score": 0.04754, "epss_percentile": 0.89108}, "CVE-2017-17792": {"epss_score": 0.00306, "epss_percentile": 0.53414}, "CVE-2017-17793": {"epss_score": 0.00469, "epss_percentile": 0.63953}, "CVE-2017-17794": {"epss_score": 0.00132, "epss_percentile": 0.33555}, "CVE-2017-17795": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2017-17796": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2017-17797": {"epss_score": 0.00039, "epss_percentile": 0.11804}, "CVE-2017-17798": {"epss_score": 0.00039, "epss_percentile": 0.11804}, "CVE-2017-17799": {"epss_score": 0.00039, "epss_percentile": 0.11804}, "CVE-2017-17800": {"epss_score": 0.00039, "epss_percentile": 0.11804}, "CVE-2017-17801": {"epss_score": 0.00039, "epss_percentile": 0.11804}, "CVE-2017-17802": {"epss_score": 0.00039, "epss_percentile": 0.11804}, "CVE-2017-17803": {"epss_score": 0.00039, "epss_percentile": 0.11804}, "CVE-2017-17804": {"epss_score": 0.00039, "epss_percentile": 0.11804}, "CVE-2017-17805": {"epss_score": 0.00053, "epss_percentile": 0.16704}, "CVE-2017-17806": {"epss_score": 0.00025, "epss_percentile": 0.06137}, "CVE-2017-17807": {"epss_score": 0.00058, "epss_percentile": 0.18478}, "CVE-2017-17809": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2017-17810": {"epss_score": 0.00198, "epss_percentile": 0.41986}, "CVE-2017-17811": {"epss_score": 0.00191, "epss_percentile": 0.41189}, "CVE-2017-17812": {"epss_score": 0.00198, "epss_percentile": 0.41986}, "CVE-2017-17813": {"epss_score": 0.00175, "epss_percentile": 0.39322}, "CVE-2017-17814": {"epss_score": 0.00175, "epss_percentile": 0.39322}, "CVE-2017-17815": {"epss_score": 0.00198, "epss_percentile": 0.41986}, "CVE-2017-17816": {"epss_score": 0.00175, "epss_percentile": 0.39322}, "CVE-2017-17817": {"epss_score": 0.00176, "epss_percentile": 0.39378}, "CVE-2017-17818": {"epss_score": 0.00683, "epss_percentile": 0.71089}, "CVE-2017-17819": {"epss_score": 0.00198, "epss_percentile": 0.41986}, "CVE-2017-17820": {"epss_score": 0.00176, "epss_percentile": 0.39378}, "CVE-2017-17821": {"epss_score": 0.00677, "epss_percentile": 0.7096}, "CVE-2017-17822": {"epss_score": 0.00303, "epss_percentile": 0.53218}, "CVE-2017-17823": {"epss_score": 0.00331, "epss_percentile": 0.55544}, "CVE-2017-17824": {"epss_score": 0.00331, "epss_percentile": 0.55544}, "CVE-2017-17825": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2017-17826": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17827": {"epss_score": 0.00166, "epss_percentile": 0.38168}, "CVE-2017-17828": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2017-17829": {"epss_score": 0.00247, "epss_percentile": 0.47867}, "CVE-2017-17830": {"epss_score": 0.00132, "epss_percentile": 0.33579}, "CVE-2017-17831": {"epss_score": 0.00729, "epss_percentile": 0.72125}, "CVE-2017-17832": {"epss_score": 0.00223, "epss_percentile": 0.44884}, "CVE-2017-17833": {"epss_score": 0.0087, "epss_percentile": 0.74698}, "CVE-2017-17835": {"epss_score": 0.00413, "epss_percentile": 0.61011}, "CVE-2017-17836": {"epss_score": 0.00441, "epss_percentile": 0.62681}, "CVE-2017-17837": {"epss_score": 0.01345, "epss_percentile": 0.79622}, "CVE-2017-17840": {"epss_score": 0.00161, "epss_percentile": 0.37554}, "CVE-2017-17841": {"epss_score": 0.0146, "epss_percentile": 0.80418}, "CVE-2017-17843": {"epss_score": 0.00204, "epss_percentile": 0.42637}, "CVE-2017-17844": {"epss_score": 0.00238, "epss_percentile": 0.46788}, "CVE-2017-17845": {"epss_score": 0.00508, "epss_percentile": 0.65703}, "CVE-2017-17846": {"epss_score": 0.00782, "epss_percentile": 0.73213}, "CVE-2017-17847": {"epss_score": 0.00291, "epss_percentile": 0.52146}, "CVE-2017-17848": {"epss_score": 0.00872, "epss_percentile": 0.74738}, "CVE-2017-17849": {"epss_score": 0.3513, "epss_percentile": 0.96889}, "CVE-2017-17850": {"epss_score": 0.67457, "epss_percentile": 0.98508}, "CVE-2017-17852": {"epss_score": 0.00132, "epss_percentile": 0.33524}, "CVE-2017-17853": {"epss_score": 0.00115, "epss_percentile": 0.31004}, "CVE-2017-17854": {"epss_score": 0.00056, "epss_percentile": 0.17669}, "CVE-2017-17855": {"epss_score": 0.00214, "epss_percentile": 0.44008}, "CVE-2017-17856": {"epss_score": 0.00128, "epss_percentile": 0.33073}, "CVE-2017-17857": {"epss_score": 0.00128, "epss_percentile": 0.33073}, "CVE-2017-17858": {"epss_score": 0.06191, "epss_percentile": 0.90549}, "CVE-2017-17859": {"epss_score": 0.0042, "epss_percentile": 0.61443}, "CVE-2017-17860": {"epss_score": 0.00093, "epss_percentile": 0.26679}, "CVE-2017-17862": {"epss_score": 0.00078, "epss_percentile": 0.23653}, "CVE-2017-17863": {"epss_score": 0.00093, "epss_percentile": 0.26665}, "CVE-2017-17864": {"epss_score": 0.00086, "epss_percentile": 0.25432}, "CVE-2017-17866": {"epss_score": 0.00288, "epss_percentile": 0.51929}, "CVE-2017-17867": {"epss_score": 0.19814, "epss_percentile": 0.95245}, "CVE-2017-17868": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17869": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-17870": {"epss_score": 0.03103, "epss_percentile": 0.86413}, "CVE-2017-17871": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-17872": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-17873": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-17874": {"epss_score": 0.02389, "epss_percentile": 0.84595}, "CVE-2017-17875": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2017-17876": {"epss_score": 0.24025, "epss_percentile": 0.95845}, "CVE-2017-17877": {"epss_score": 0.01273, "epss_percentile": 0.79088}, "CVE-2017-17878": {"epss_score": 0.00168, "epss_percentile": 0.38493}, "CVE-2017-17879": {"epss_score": 0.01108, "epss_percentile": 0.77638}, "CVE-2017-17880": {"epss_score": 0.0041, "epss_percentile": 0.60797}, "CVE-2017-17881": {"epss_score": 0.0045, "epss_percentile": 0.63078}, "CVE-2017-17882": {"epss_score": 0.0045, "epss_percentile": 0.63078}, "CVE-2017-17883": {"epss_score": 0.00248, "epss_percentile": 0.4795}, "CVE-2017-17884": {"epss_score": 0.0045, "epss_percentile": 0.63078}, "CVE-2017-17885": {"epss_score": 0.0045, "epss_percentile": 0.63078}, "CVE-2017-17886": {"epss_score": 0.00447, "epss_percentile": 0.62972}, "CVE-2017-17887": {"epss_score": 0.0045, "epss_percentile": 0.63078}, "CVE-2017-17888": {"epss_score": 0.09493, "epss_percentile": 0.92571}, "CVE-2017-17889": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-17891": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2017-17892": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-17893": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17894": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2017-17895": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-17896": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17897": {"epss_score": 0.00342, "epss_percentile": 0.56378}, "CVE-2017-17898": {"epss_score": 0.00258, "epss_percentile": 0.48969}, "CVE-2017-17899": {"epss_score": 0.00342, "epss_percentile": 0.56378}, "CVE-2017-17900": {"epss_score": 0.00342, "epss_percentile": 0.56378}, "CVE-2017-17901": {"epss_score": 0.00499, "epss_percentile": 0.65257}, "CVE-2017-17902": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-17903": {"epss_score": 0.00112, "epss_percentile": 0.30501}, "CVE-2017-17904": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2017-17905": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2017-17906": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-17907": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17908": {"epss_score": 0.00112, "epss_percentile": 0.30501}, "CVE-2017-17909": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2017-17910": {"epss_score": 0.00064, "epss_percentile": 0.20128}, "CVE-2017-17911": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-17912": {"epss_score": 0.00825, "epss_percentile": 0.73947}, "CVE-2017-17913": {"epss_score": 0.00409, "epss_percentile": 0.60724}, "CVE-2017-17914": {"epss_score": 0.00526, "epss_percentile": 0.66436}, "CVE-2017-17915": {"epss_score": 0.00692, "epss_percentile": 0.71297}, "CVE-2017-17916": {"epss_score": 0.00586, "epss_percentile": 0.68431}, "CVE-2017-17917": {"epss_score": 0.01779, "epss_percentile": 0.82231}, "CVE-2017-17919": {"epss_score": 0.00582, "epss_percentile": 0.68297}, "CVE-2017-17920": {"epss_score": 0.00484, "epss_percentile": 0.64671}, "CVE-2017-17924": {"epss_score": 0.00248, "epss_percentile": 0.47922}, "CVE-2017-17925": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2017-17926": {"epss_score": 0.00244, "epss_percentile": 0.47619}, "CVE-2017-17927": {"epss_score": 0.00248, "epss_percentile": 0.47922}, "CVE-2017-17928": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-17929": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2017-17930": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2017-17931": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-17932": {"epss_score": 0.77388, "epss_percentile": 0.98934}, "CVE-2017-17933": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2017-17934": {"epss_score": 0.00508, "epss_percentile": 0.65701}, "CVE-2017-17935": {"epss_score": 0.00582, "epss_percentile": 0.68296}, "CVE-2017-17936": {"epss_score": 0.00112, "epss_percentile": 0.30501}, "CVE-2017-17937": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-17938": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2017-17939": {"epss_score": 0.00112, "epss_percentile": 0.30501}, "CVE-2017-17940": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2017-17941": {"epss_score": 0.0023, "epss_percentile": 0.45684}, "CVE-2017-17942": {"epss_score": 0.00369, "epss_percentile": 0.58265}, "CVE-2017-17944": {"epss_score": 0.00183, "epss_percentile": 0.40362}, "CVE-2017-17945": {"epss_score": 0.00183, "epss_percentile": 0.40362}, "CVE-2017-17946": {"epss_score": 0.04378, "epss_percentile": 0.88621}, "CVE-2017-17947": {"epss_score": 0.0026, "epss_percentile": 0.49199}, "CVE-2017-17948": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17949": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17950": {"epss_score": 0.00232, "epss_percentile": 0.45894}, "CVE-2017-17951": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-17952": {"epss_score": 0.00249, "epss_percentile": 0.48044}, "CVE-2017-17953": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17954": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17955": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17956": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17957": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-17958": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17959": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-17960": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2017-17967": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2017-17968": {"epss_score": 0.54586, "epss_percentile": 0.97934}, "CVE-2017-17969": {"epss_score": 0.03258, "epss_percentile": 0.86766}, "CVE-2017-17970": {"epss_score": 0.02932, "epss_percentile": 0.86018}, "CVE-2017-17971": {"epss_score": 0.00199, "epss_percentile": 0.42182}, "CVE-2017-17972": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-17973": {"epss_score": 0.00486, "epss_percentile": 0.64757}, "CVE-2017-17974": {"epss_score": 0.00458, "epss_percentile": 0.63445}, "CVE-2017-17975": {"epss_score": 0.00047, "epss_percentile": 0.14615}, "CVE-2017-17976": {"epss_score": 0.16552, "epss_percentile": 0.94688}, "CVE-2017-17981": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2017-17982": {"epss_score": 0.00111, "epss_percentile": 0.30246}, "CVE-2017-17983": {"epss_score": 0.00216, "epss_percentile": 0.44137}, "CVE-2017-17984": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2017-17985": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2017-17986": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2017-17987": {"epss_score": 0.0034, "epss_percentile": 0.56238}, "CVE-2017-17988": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2017-17989": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-17990": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2017-17991": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-17992": {"epss_score": 0.00793, "epss_percentile": 0.73421}, "CVE-2017-17993": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-17994": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-17995": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-17996": {"epss_score": 0.04149, "epss_percentile": 0.88318}, "CVE-2017-17997": {"epss_score": 0.00702, "epss_percentile": 0.71517}, "CVE-2017-17999": {"epss_score": 0.02724, "epss_percentile": 0.85524}, "CVE-2017-18001": {"epss_score": 0.2085, "epss_percentile": 0.95429}, "CVE-2017-18004": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-18005": {"epss_score": 0.00146, "epss_percentile": 0.35619}, "CVE-2017-18006": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-18008": {"epss_score": 0.00469, "epss_percentile": 0.63953}, "CVE-2017-18009": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2017-18010": {"epss_score": 0.00235, "epss_percentile": 0.46313}, "CVE-2017-18011": {"epss_score": 0.00257, "epss_percentile": 0.48882}, "CVE-2017-18012": {"epss_score": 0.00799, "epss_percentile": 0.73527}, "CVE-2017-18013": {"epss_score": 0.00392, "epss_percentile": 0.59666}, "CVE-2017-18014": {"epss_score": 0.00178, "epss_percentile": 0.39647}, "CVE-2017-18015": {"epss_score": 0.00298, "epss_percentile": 0.52826}, "CVE-2017-18016": {"epss_score": 0.01252, "epss_percentile": 0.78906}, "CVE-2017-18017": {"epss_score": 0.33581, "epss_percentile": 0.96784}, "CVE-2017-18018": {"epss_score": 0.00056, "epss_percentile": 0.17658}, "CVE-2017-18019": {"epss_score": 0.0143, "epss_percentile": 0.80239}, "CVE-2017-18020": {"epss_score": 0.00052, "epss_percentile": 0.16561}, "CVE-2017-18021": {"epss_score": 0.00576, "epss_percentile": 0.68132}, "CVE-2017-18022": {"epss_score": 0.00134, "epss_percentile": 0.33806}, "CVE-2017-18023": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2017-18024": {"epss_score": 0.07772, "epss_percentile": 0.91674}, "CVE-2017-18025": {"epss_score": 0.03155, "epss_percentile": 0.86512}, "CVE-2017-18026": {"epss_score": 0.00747, "epss_percentile": 0.72574}, "CVE-2017-18027": {"epss_score": 0.00615, "epss_percentile": 0.69309}, "CVE-2017-18028": {"epss_score": 0.00728, "epss_percentile": 0.72113}, "CVE-2017-18029": {"epss_score": 0.00897, "epss_percentile": 0.75134}, "CVE-2017-18030": {"epss_score": 0.00107, "epss_percentile": 0.29685}, "CVE-2017-18032": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18033": {"epss_score": 0.00084, "epss_percentile": 0.24896}, "CVE-2017-18034": {"epss_score": 0.0014, "epss_percentile": 0.34711}, "CVE-2017-18035": {"epss_score": 0.00112, "epss_percentile": 0.30502}, "CVE-2017-18036": {"epss_score": 0.0015, "epss_percentile": 0.36074}, "CVE-2017-18037": {"epss_score": 0.00289, "epss_percentile": 0.52023}, "CVE-2017-18038": {"epss_score": 0.00225, "epss_percentile": 0.45221}, "CVE-2017-18039": {"epss_score": 0.00203, "epss_percentile": 0.42555}, "CVE-2017-18040": {"epss_score": 0.00144, "epss_percentile": 0.3525}, "CVE-2017-18041": {"epss_score": 0.00144, "epss_percentile": 0.3525}, "CVE-2017-18042": {"epss_score": 0.00134, "epss_percentile": 0.3375}, "CVE-2017-18043": {"epss_score": 0.00101, "epss_percentile": 0.28715}, "CVE-2017-18044": {"epss_score": 0.82647, "epss_percentile": 0.99204}, "CVE-2017-18045": {"epss_score": 0.00815, "epss_percentile": 0.73782}, "CVE-2017-18046": {"epss_score": 0.10593, "epss_percentile": 0.93039}, "CVE-2017-18047": {"epss_score": 0.70618, "epss_percentile": 0.98639}, "CVE-2017-18048": {"epss_score": 0.77014, "epss_percentile": 0.98916}, "CVE-2017-18049": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2017-18050": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-18051": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-18052": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-18053": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-18054": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-18055": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-18056": {"epss_score": 0.00016, "epss_percentile": 0.02699}, "CVE-2017-18057": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-18058": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-18059": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-18060": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-18061": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-18062": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-18063": {"epss_score": 0.00028, "epss_percentile": 0.07315}, "CVE-2017-18064": {"epss_score": 0.00029, "epss_percentile": 0.07976}, "CVE-2017-18065": {"epss_score": 0.00017, "epss_percentile": 0.0322}, "CVE-2017-18066": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-18067": {"epss_score": 0.01605, "epss_percentile": 0.81292}, "CVE-2017-18068": {"epss_score": 0.00029, "epss_percentile": 0.07976}, "CVE-2017-18069": {"epss_score": 0.00106, "epss_percentile": 0.29449}, "CVE-2017-18070": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2017-18071": {"epss_score": 0.00257, "epss_percentile": 0.48859}, "CVE-2017-18072": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2017-18073": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2017-18074": {"epss_score": 0.00296, "epss_percentile": 0.52595}, "CVE-2017-18075": {"epss_score": 0.00069, "epss_percentile": 0.21512}, "CVE-2017-18076": {"epss_score": 0.00439, "epss_percentile": 0.62608}, "CVE-2017-18077": {"epss_score": 0.00498, "epss_percentile": 0.65231}, "CVE-2017-18078": {"epss_score": 0.00084, "epss_percentile": 0.25009}, "CVE-2017-18079": {"epss_score": 0.00032, "epss_percentile": 0.08738}, "CVE-2017-18080": {"epss_score": 0.00141, "epss_percentile": 0.34809}, "CVE-2017-18081": {"epss_score": 0.00189, "epss_percentile": 0.41001}, "CVE-2017-18082": {"epss_score": 0.00164, "epss_percentile": 0.37864}, "CVE-2017-18083": {"epss_score": 0.00164, "epss_percentile": 0.37864}, "CVE-2017-18084": {"epss_score": 0.0013, "epss_percentile": 0.33291}, "CVE-2017-18085": {"epss_score": 0.00189, "epss_percentile": 0.41001}, "CVE-2017-18086": {"epss_score": 0.00189, "epss_percentile": 0.41001}, "CVE-2017-18087": {"epss_score": 0.01583, "epss_percentile": 0.81151}, "CVE-2017-18088": {"epss_score": 0.00205, "epss_percentile": 0.42701}, "CVE-2017-18089": {"epss_score": 0.0018, "epss_percentile": 0.39923}, "CVE-2017-18090": {"epss_score": 0.00225, "epss_percentile": 0.45087}, "CVE-2017-18091": {"epss_score": 0.00177, "epss_percentile": 0.39565}, "CVE-2017-18092": {"epss_score": 0.0018, "epss_percentile": 0.39923}, "CVE-2017-18093": {"epss_score": 0.00177, "epss_percentile": 0.39565}, "CVE-2017-18094": {"epss_score": 0.00148, "epss_percentile": 0.3586}, "CVE-2017-18095": {"epss_score": 0.00206, "epss_percentile": 0.42944}, "CVE-2017-18096": {"epss_score": 0.00335, "epss_percentile": 0.5581}, "CVE-2017-18097": {"epss_score": 0.0018, "epss_percentile": 0.39923}, "CVE-2017-18098": {"epss_score": 0.00225, "epss_percentile": 0.45087}, "CVE-2017-18100": {"epss_score": 0.00173, "epss_percentile": 0.39064}, "CVE-2017-18101": {"epss_score": 0.00384, "epss_percentile": 0.59174}, "CVE-2017-18102": {"epss_score": 0.00313, "epss_percentile": 0.54073}, "CVE-2017-18103": {"epss_score": 0.00171, "epss_percentile": 0.38865}, "CVE-2017-18104": {"epss_score": 0.00272, "epss_percentile": 0.50347}, "CVE-2017-18105": {"epss_score": 0.00509, "epss_percentile": 0.65728}, "CVE-2017-18106": {"epss_score": 0.0054, "epss_percentile": 0.67007}, "CVE-2017-18107": {"epss_score": 0.00411, "epss_percentile": 0.60872}, "CVE-2017-18108": {"epss_score": 0.01536, "epss_percentile": 0.80913}, "CVE-2017-18109": {"epss_score": 0.00148, "epss_percentile": 0.35803}, "CVE-2017-18110": {"epss_score": 0.00171, "epss_percentile": 0.38858}, "CVE-2017-18111": {"epss_score": 0.00221, "epss_percentile": 0.44682}, "CVE-2017-18112": {"epss_score": 0.00302, "epss_percentile": 0.53107}, "CVE-2017-18113": {"epss_score": 0.02571, "epss_percentile": 0.85132}, "CVE-2017-18120": {"epss_score": 0.00203, "epss_percentile": 0.42511}, "CVE-2017-18121": {"epss_score": 0.00355, "epss_percentile": 0.57288}, "CVE-2017-18122": {"epss_score": 0.00308, "epss_percentile": 0.5357}, "CVE-2017-18123": {"epss_score": 0.00354, "epss_percentile": 0.57222}, "CVE-2017-18124": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2017-18125": {"epss_score": 0.00164, "epss_percentile": 0.37981}, "CVE-2017-18126": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2017-18127": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2017-18128": {"epss_score": 0.00206, "epss_percentile": 0.43}, "CVE-2017-18129": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2017-18130": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2017-18131": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2017-18132": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2017-18133": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2017-18134": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2017-18135": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2017-18136": {"epss_score": 0.00242, "epss_percentile": 0.47371}, "CVE-2017-18137": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2017-18138": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2017-18139": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2017-18140": {"epss_score": 0.00242, "epss_percentile": 0.47371}, "CVE-2017-18141": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2017-18142": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2017-18143": {"epss_score": 0.00216, "epss_percentile": 0.44183}, "CVE-2017-18144": {"epss_score": 0.00242, "epss_percentile": 0.47371}, "CVE-2017-18145": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2017-18146": {"epss_score": 0.00096, "epss_percentile": 0.27378}, "CVE-2017-18147": {"epss_score": 0.0016, "epss_percentile": 0.37456}, "CVE-2017-18153": {"epss_score": 0.0007, "epss_percentile": 0.21797}, "CVE-2017-18154": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2017-18155": {"epss_score": 0.00108, "epss_percentile": 0.29861}, "CVE-2017-18156": {"epss_score": 0.00096, "epss_percentile": 0.27446}, "CVE-2017-18157": {"epss_score": 0.00096, "epss_percentile": 0.27446}, "CVE-2017-18158": {"epss_score": 0.00043, "epss_percentile": 0.13186}, "CVE-2017-18159": {"epss_score": 0.00042, "epss_percentile": 0.12702}, "CVE-2017-18160": {"epss_score": 0.00217, "epss_percentile": 0.44315}, "CVE-2017-18169": {"epss_score": 0.00016, "epss_percentile": 0.03018}, "CVE-2017-18170": {"epss_score": 0.00145, "epss_percentile": 0.35409}, "CVE-2017-18171": {"epss_score": 0.00126, "epss_percentile": 0.32704}, "CVE-2017-18172": {"epss_score": 0.00082, "epss_percentile": 0.24487}, "CVE-2017-18173": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2017-18174": {"epss_score": 0.00423, "epss_percentile": 0.61624}, "CVE-2017-18175": {"epss_score": 0.00032, "epss_percentile": 0.08957}, "CVE-2017-18176": {"epss_score": 0.00046, "epss_percentile": 0.14335}, "CVE-2017-18177": {"epss_score": 0.00046, "epss_percentile": 0.14335}, "CVE-2017-18178": {"epss_score": 0.00112, "epss_percentile": 0.30487}, "CVE-2017-18179": {"epss_score": 0.00219, "epss_percentile": 0.44472}, "CVE-2017-18183": {"epss_score": 0.00338, "epss_percentile": 0.56126}, "CVE-2017-18184": {"epss_score": 0.00101, "epss_percentile": 0.28691}, "CVE-2017-18185": {"epss_score": 0.00156, "epss_percentile": 0.36943}, "CVE-2017-18186": {"epss_score": 0.00323, "epss_percentile": 0.54908}, "CVE-2017-18187": {"epss_score": 0.00415, "epss_percentile": 0.61111}, "CVE-2017-18188": {"epss_score": 0.00046, "epss_percentile": 0.14269}, "CVE-2017-18189": {"epss_score": 0.08174, "epss_percentile": 0.91914}, "CVE-2017-18190": {"epss_score": 0.007, "epss_percentile": 0.71459}, "CVE-2017-18191": {"epss_score": 0.01356, "epss_percentile": 0.79714}, "CVE-2017-18192": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2017-18193": {"epss_score": 0.00084, "epss_percentile": 0.24956}, "CVE-2017-18194": {"epss_score": 0.005, "epss_percentile": 0.65311}, "CVE-2017-18195": {"epss_score": 0.08031, "epss_percentile": 0.91842}, "CVE-2017-18196": {"epss_score": 0.00041, "epss_percentile": 0.12428}, "CVE-2017-18197": {"epss_score": 0.0044, "epss_percentile": 0.62647}, "CVE-2017-18198": {"epss_score": 0.00903, "epss_percentile": 0.75198}, "CVE-2017-18199": {"epss_score": 0.01853, "epss_percentile": 0.82549}, "CVE-2017-18200": {"epss_score": 0.00042, "epss_percentile": 0.12776}, "CVE-2017-18201": {"epss_score": 0.00448, "epss_percentile": 0.62993}, "CVE-2017-18202": {"epss_score": 0.00101, "epss_percentile": 0.28643}, "CVE-2017-18203": {"epss_score": 0.00053, "epss_percentile": 0.16968}, "CVE-2017-18204": {"epss_score": 0.0007, "epss_percentile": 0.21811}, "CVE-2017-18205": {"epss_score": 0.00755, "epss_percentile": 0.72724}, "CVE-2017-18206": {"epss_score": 0.00544, "epss_percentile": 0.67135}, "CVE-2017-18207": {"epss_score": 0.0078, "epss_percentile": 0.73171}, "CVE-2017-18208": {"epss_score": 0.0005, "epss_percentile": 0.15972}, "CVE-2017-18209": {"epss_score": 0.00428, "epss_percentile": 0.61946}, "CVE-2017-18210": {"epss_score": 0.00319, "epss_percentile": 0.54482}, "CVE-2017-18211": {"epss_score": 0.00428, "epss_percentile": 0.61946}, "CVE-2017-18212": {"epss_score": 0.00327, "epss_percentile": 0.55106}, "CVE-2017-18213": {"epss_score": 0.00568, "epss_percentile": 0.679}, "CVE-2017-18214": {"epss_score": 0.00322, "epss_percentile": 0.54828}, "CVE-2017-18215": {"epss_score": 0.01094, "epss_percentile": 0.77495}, "CVE-2017-18216": {"epss_score": 0.00064, "epss_percentile": 0.20377}, "CVE-2017-18217": {"epss_score": 0.0034, "epss_percentile": 0.56268}, "CVE-2017-18218": {"epss_score": 0.00109, "epss_percentile": 0.29909}, "CVE-2017-18219": {"epss_score": 0.05758, "epss_percentile": 0.90181}, "CVE-2017-18220": {"epss_score": 0.04062, "epss_percentile": 0.88191}, "CVE-2017-18221": {"epss_score": 0.0005, "epss_percentile": 0.15832}, "CVE-2017-18222": {"epss_score": 0.00118, "epss_percentile": 0.31464}, "CVE-2017-18223": {"epss_score": 0.00347, "epss_percentile": 0.56771}, "CVE-2017-18224": {"epss_score": 0.0005, "epss_percentile": 0.15706}, "CVE-2017-18225": {"epss_score": 0.00105, "epss_percentile": 0.29379}, "CVE-2017-18226": {"epss_score": 0.00034, "epss_percentile": 0.09433}, "CVE-2017-18227": {"epss_score": 0.0011, "epss_percentile": 0.30152}, "CVE-2017-18228": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2017-18229": {"epss_score": 0.01015, "epss_percentile": 0.76664}, "CVE-2017-18230": {"epss_score": 0.01691, "epss_percentile": 0.8178}, "CVE-2017-18231": {"epss_score": 0.01691, "epss_percentile": 0.8178}, "CVE-2017-18232": {"epss_score": 0.00086, "epss_percentile": 0.25284}, "CVE-2017-18233": {"epss_score": 0.00548, "epss_percentile": 0.67273}, "CVE-2017-18234": {"epss_score": 0.00624, "epss_percentile": 0.69565}, "CVE-2017-18235": {"epss_score": 0.0041, "epss_percentile": 0.60789}, "CVE-2017-18236": {"epss_score": 0.00873, "epss_percentile": 0.74746}, "CVE-2017-18237": {"epss_score": 0.00402, "epss_percentile": 0.60314}, "CVE-2017-18238": {"epss_score": 0.00519, "epss_percentile": 0.66145}, "CVE-2017-18239": {"epss_score": 0.00398, "epss_percentile": 0.60069}, "CVE-2017-18240": {"epss_score": 0.0004, "epss_percentile": 0.12114}, "CVE-2017-18241": {"epss_score": 0.00092, "epss_percentile": 0.26537}, "CVE-2017-18242": {"epss_score": 0.00296, "epss_percentile": 0.52603}, "CVE-2017-18243": {"epss_score": 0.00346, "epss_percentile": 0.56711}, "CVE-2017-18244": {"epss_score": 0.0065, "epss_percentile": 0.70245}, "CVE-2017-18245": {"epss_score": 0.0065, "epss_percentile": 0.70245}, "CVE-2017-18246": {"epss_score": 0.0065, "epss_percentile": 0.70245}, "CVE-2017-18247": {"epss_score": 0.00652, "epss_percentile": 0.70307}, "CVE-2017-18248": {"epss_score": 0.01002, "epss_percentile": 0.76511}, "CVE-2017-18249": {"epss_score": 0.00063, "epss_percentile": 0.1992}, "CVE-2017-18250": {"epss_score": 0.00381, "epss_percentile": 0.58992}, "CVE-2017-18251": {"epss_score": 0.00343, "epss_percentile": 0.56434}, "CVE-2017-18252": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2017-18253": {"epss_score": 0.00379, "epss_percentile": 0.58843}, "CVE-2017-18254": {"epss_score": 0.00343, "epss_percentile": 0.56434}, "CVE-2017-18255": {"epss_score": 0.0011, "epss_percentile": 0.3019}, "CVE-2017-18256": {"epss_score": 0.11217, "epss_percentile": 0.93268}, "CVE-2017-18257": {"epss_score": 0.00111, "epss_percentile": 0.30314}, "CVE-2017-18258": {"epss_score": 0.00561, "epss_percentile": 0.6766}, "CVE-2017-18259": {"epss_score": 0.00185, "epss_percentile": 0.40499}, "CVE-2017-18260": {"epss_score": 0.00218, "epss_percentile": 0.44427}, "CVE-2017-18261": {"epss_score": 0.00045, "epss_percentile": 0.13741}, "CVE-2017-18262": {"epss_score": 0.00278, "epss_percentile": 0.50922}, "CVE-2017-18263": {"epss_score": 0.05566, "epss_percentile": 0.90002}, "CVE-2017-18264": {"epss_score": 0.00305, "epss_percentile": 0.53323}, "CVE-2017-18265": {"epss_score": 0.01063, "epss_percentile": 0.77186}, "CVE-2017-18266": {"epss_score": 0.01003, "epss_percentile": 0.76517}, "CVE-2017-18267": {"epss_score": 0.00254, "epss_percentile": 0.4854}, "CVE-2017-18268": {"epss_score": 0.0036, "epss_percentile": 0.57684}, "CVE-2017-18269": {"epss_score": 0.01027, "epss_percentile": 0.76811}, "CVE-2017-18270": {"epss_score": 0.00074, "epss_percentile": 0.22679}, "CVE-2017-18271": {"epss_score": 0.00208, "epss_percentile": 0.4324}, "CVE-2017-18272": {"epss_score": 0.00406, "epss_percentile": 0.60515}, "CVE-2017-18273": {"epss_score": 0.00208, "epss_percentile": 0.4324}, "CVE-2017-18274": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2017-18275": {"epss_score": 0.00109, "epss_percentile": 0.29947}, "CVE-2017-18276": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2017-18277": {"epss_score": 0.0011, "epss_percentile": 0.3018}, "CVE-2017-18278": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2017-18279": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2017-18280": {"epss_score": 0.00041, "epss_percentile": 0.12281}, "CVE-2017-18281": {"epss_score": 0.00023, "epss_percentile": 0.05489}, "CVE-2017-18282": {"epss_score": 0.00044, "epss_percentile": 0.13578}, "CVE-2017-18283": {"epss_score": 0.00427, "epss_percentile": 0.6189}, "CVE-2017-18284": {"epss_score": 0.00032, "epss_percentile": 0.09003}, "CVE-2017-18285": {"epss_score": 0.0004, "epss_percentile": 0.1205}, "CVE-2017-18286": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2017-18287": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-18288": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-18289": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-18290": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-18291": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-18292": {"epss_score": 0.00053, "epss_percentile": 0.16967}, "CVE-2017-18293": {"epss_score": 0.00044, "epss_percentile": 0.13578}, "CVE-2017-18294": {"epss_score": 0.00044, "epss_percentile": 0.13578}, "CVE-2017-18295": {"epss_score": 0.00047, "epss_percentile": 0.14638}, "CVE-2017-18296": {"epss_score": 0.00044, "epss_percentile": 0.13578}, "CVE-2017-18297": {"epss_score": 0.00044, "epss_percentile": 0.13578}, "CVE-2017-18298": {"epss_score": 0.00044, "epss_percentile": 0.13578}, "CVE-2017-18299": {"epss_score": 0.00053, "epss_percentile": 0.16967}, "CVE-2017-18300": {"epss_score": 0.0006, "epss_percentile": 0.18988}, "CVE-2017-18301": {"epss_score": 0.00049, "epss_percentile": 0.15557}, "CVE-2017-18302": {"epss_score": 0.00047, "epss_percentile": 0.14504}, "CVE-2017-18303": {"epss_score": 0.00047, "epss_percentile": 0.14638}, "CVE-2017-18304": {"epss_score": 0.00044, "epss_percentile": 0.13578}, "CVE-2017-18305": {"epss_score": 0.00044, "epss_percentile": 0.13578}, "CVE-2017-18306": {"epss_score": 0.0007, "epss_percentile": 0.21879}, "CVE-2017-18307": {"epss_score": 0.0007, "epss_percentile": 0.21879}, "CVE-2017-18308": {"epss_score": 0.00207, "epss_percentile": 0.43151}, "CVE-2017-18309": {"epss_score": 0.00051, "epss_percentile": 0.16175}, "CVE-2017-18310": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2017-18311": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2017-18312": {"epss_score": 0.00081, "epss_percentile": 0.24258}, "CVE-2017-18313": {"epss_score": 0.00151, "epss_percentile": 0.36265}, "CVE-2017-18314": {"epss_score": 0.00272, "epss_percentile": 0.50355}, "CVE-2017-18315": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2017-18316": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2017-18317": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2017-18318": {"epss_score": 0.00217, "epss_percentile": 0.44315}, "CVE-2017-18319": {"epss_score": 0.00051, "epss_percentile": 0.16187}, "CVE-2017-18320": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2017-18321": {"epss_score": 0.00051, "epss_percentile": 0.16187}, "CVE-2017-18322": {"epss_score": 0.00051, "epss_percentile": 0.16187}, "CVE-2017-18323": {"epss_score": 0.00051, "epss_percentile": 0.16187}, "CVE-2017-18324": {"epss_score": 0.00051, "epss_percentile": 0.16187}, "CVE-2017-18326": {"epss_score": 0.00051, "epss_percentile": 0.16187}, "CVE-2017-18327": {"epss_score": 0.00051, "epss_percentile": 0.16187}, "CVE-2017-18328": {"epss_score": 0.00042, "epss_percentile": 0.12882}, "CVE-2017-18329": {"epss_score": 0.0004, "epss_percentile": 0.12053}, "CVE-2017-18330": {"epss_score": 0.00023, "epss_percentile": 0.05494}, "CVE-2017-18331": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2017-18332": {"epss_score": 0.00051, "epss_percentile": 0.16187}, "CVE-2017-18342": {"epss_score": 0.04697, "epss_percentile": 0.89022}, "CVE-2017-18343": {"epss_score": 0.00504, "epss_percentile": 0.65544}, "CVE-2017-18344": {"epss_score": 0.10164, "epss_percentile": 0.92872}, "CVE-2017-18345": {"epss_score": 0.02461, "epss_percentile": 0.84824}, "CVE-2017-18346": {"epss_score": 0.01321, "epss_percentile": 0.79444}, "CVE-2017-18347": {"epss_score": 0.00063, "epss_percentile": 0.20048}, "CVE-2017-18348": {"epss_score": 0.00117, "epss_percentile": 0.31365}, "CVE-2017-18349": {"epss_score": 0.92079, "epss_percentile": 0.9969}, "CVE-2017-18350": {"epss_score": 0.00274, "epss_percentile": 0.50577}, "CVE-2017-18352": {"epss_score": 0.00154, "epss_percentile": 0.36741}, "CVE-2017-18353": {"epss_score": 0.00427, "epss_percentile": 0.61879}, "CVE-2017-18354": {"epss_score": 0.00278, "epss_percentile": 0.50847}, "CVE-2017-18355": {"epss_score": 0.0026, "epss_percentile": 0.49101}, "CVE-2017-18356": {"epss_score": 0.01567, "epss_percentile": 0.81073}, "CVE-2017-18357": {"epss_score": 0.57295, "epss_percentile": 0.98056}, "CVE-2017-18358": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2017-18359": {"epss_score": 0.01952, "epss_percentile": 0.83021}, "CVE-2017-18360": {"epss_score": 0.00078, "epss_percentile": 0.2359}, "CVE-2017-18361": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2017-18362": {"epss_score": 0.81865, "epss_percentile": 0.99161}, "CVE-2017-18364": {"epss_score": 0.00431, "epss_percentile": 0.62091}, "CVE-2017-18365": {"epss_score": 0.63003, "epss_percentile": 0.98316}, "CVE-2017-18366": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2017-18367": {"epss_score": 0.00465, "epss_percentile": 0.63753}, "CVE-2017-18368": {"epss_score": 0.9375, "epss_percentile": 0.99839}, "CVE-2017-18369": {"epss_score": 0.87496, "epss_percentile": 0.99431}, "CVE-2017-18370": {"epss_score": 0.75866, "epss_percentile": 0.98868}, "CVE-2017-18371": {"epss_score": 0.73547, "epss_percentile": 0.9876}, "CVE-2017-18372": {"epss_score": 0.72978, "epss_percentile": 0.98731}, "CVE-2017-18373": {"epss_score": 0.12061, "epss_percentile": 0.93558}, "CVE-2017-18374": {"epss_score": 0.07007, "epss_percentile": 0.9118}, "CVE-2017-18375": {"epss_score": 0.00379, "epss_percentile": 0.58903}, "CVE-2017-18376": {"epss_score": 0.00463, "epss_percentile": 0.63699}, "CVE-2017-18377": {"epss_score": 0.03175, "epss_percentile": 0.86567}, "CVE-2017-18378": {"epss_score": 0.1554, "epss_percentile": 0.94453}, "CVE-2017-18379": {"epss_score": 0.00798, "epss_percentile": 0.73511}, "CVE-2017-18380": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2017-18381": {"epss_score": 0.00428, "epss_percentile": 0.61934}, "CVE-2017-18382": {"epss_score": 0.00252, "epss_percentile": 0.48345}, "CVE-2017-18383": {"epss_score": 0.00068, "epss_percentile": 0.21234}, "CVE-2017-18384": {"epss_score": 0.00057, "epss_percentile": 0.18123}, "CVE-2017-18385": {"epss_score": 0.00063, "epss_percentile": 0.1996}, "CVE-2017-18386": {"epss_score": 0.016, "epss_percentile": 0.81256}, "CVE-2017-18387": {"epss_score": 0.016, "epss_percentile": 0.81256}, "CVE-2017-18388": {"epss_score": 0.00054, "epss_percentile": 0.17346}, "CVE-2017-18389": {"epss_score": 0.0036, "epss_percentile": 0.5762}, "CVE-2017-18390": {"epss_score": 0.00052, "epss_percentile": 0.1656}, "CVE-2017-18391": {"epss_score": 0.00066, "epss_percentile": 0.20963}, "CVE-2017-18392": {"epss_score": 0.00258, "epss_percentile": 0.4895}, "CVE-2017-18393": {"epss_score": 0.00252, "epss_percentile": 0.48345}, "CVE-2017-18394": {"epss_score": 0.00232, "epss_percentile": 0.45936}, "CVE-2017-18395": {"epss_score": 0.00252, "epss_percentile": 0.48345}, "CVE-2017-18396": {"epss_score": 0.00074, "epss_percentile": 0.22697}, "CVE-2017-18397": {"epss_score": 0.0005, "epss_percentile": 0.15898}, "CVE-2017-18398": {"epss_score": 0.00244, "epss_percentile": 0.47597}, "CVE-2017-18399": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2017-18400": {"epss_score": 0.00184, "epss_percentile": 0.40459}, "CVE-2017-18401": {"epss_score": 0.00244, "epss_percentile": 0.47556}, "CVE-2017-18402": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2017-18403": {"epss_score": 0.0042, "epss_percentile": 0.61449}, "CVE-2017-18404": {"epss_score": 0.00144, "epss_percentile": 0.35289}, "CVE-2017-18405": {"epss_score": 0.00074, "epss_percentile": 0.22697}, "CVE-2017-18406": {"epss_score": 0.00248, "epss_percentile": 0.47983}, "CVE-2017-18407": {"epss_score": 0.00107, "epss_percentile": 0.29745}, "CVE-2017-18408": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2017-18409": {"epss_score": 0.0031, "epss_percentile": 0.53787}, "CVE-2017-18410": {"epss_score": 0.0031, "epss_percentile": 0.53787}, "CVE-2017-18411": {"epss_score": 0.00318, "epss_percentile": 0.54452}, "CVE-2017-18412": {"epss_score": 0.00066, "epss_percentile": 0.20963}, "CVE-2017-18413": {"epss_score": 0.00068, "epss_percentile": 0.21234}, "CVE-2017-18414": {"epss_score": 0.0019, "epss_percentile": 0.41054}, "CVE-2017-18415": {"epss_score": 0.00061, "epss_percentile": 0.19533}, "CVE-2017-18416": {"epss_score": 0.00045, "epss_percentile": 0.1392}, "CVE-2017-18417": {"epss_score": 0.00378, "epss_percentile": 0.58804}, "CVE-2017-18418": {"epss_score": 0.00378, "epss_percentile": 0.58804}, "CVE-2017-18419": {"epss_score": 0.00378, "epss_percentile": 0.58804}, "CVE-2017-18420": {"epss_score": 0.00378, "epss_percentile": 0.58804}, "CVE-2017-18421": {"epss_score": 0.00057, "epss_percentile": 0.18123}, "CVE-2017-18422": {"epss_score": 0.0005, "epss_percentile": 0.15898}, "CVE-2017-18423": {"epss_score": 0.00066, "epss_percentile": 0.20963}, "CVE-2017-18424": {"epss_score": 0.00066, "epss_percentile": 0.20963}, "CVE-2017-18425": {"epss_score": 0.00032, "epss_percentile": 0.09043}, "CVE-2017-18426": {"epss_score": 0.0035, "epss_percentile": 0.56961}, "CVE-2017-18427": {"epss_score": 0.0005, "epss_percentile": 0.15898}, "CVE-2017-18428": {"epss_score": 0.00066, "epss_percentile": 0.20963}, "CVE-2017-18429": {"epss_score": 0.00066, "epss_percentile": 0.20963}, "CVE-2017-18430": {"epss_score": 0.00185, "epss_percentile": 0.40576}, "CVE-2017-18431": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2017-18432": {"epss_score": 0.00065, "epss_percentile": 0.20488}, "CVE-2017-18433": {"epss_score": 0.0076, "epss_percentile": 0.72798}, "CVE-2017-18434": {"epss_score": 0.00039, "epss_percentile": 0.11673}, "CVE-2017-18435": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2017-18436": {"epss_score": 0.00062, "epss_percentile": 0.19752}, "CVE-2017-18437": {"epss_score": 0.00121, "epss_percentile": 0.31939}, "CVE-2017-18438": {"epss_score": 0.00366, "epss_percentile": 0.5806}, "CVE-2017-18439": {"epss_score": 0.00556, "epss_percentile": 0.67521}, "CVE-2017-18440": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2017-18441": {"epss_score": 0.00144, "epss_percentile": 0.35289}, "CVE-2017-18442": {"epss_score": 0.00299, "epss_percentile": 0.52859}, "CVE-2017-18443": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2017-18444": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2017-18445": {"epss_score": 0.00219, "epss_percentile": 0.44515}, "CVE-2017-18446": {"epss_score": 0.00333, "epss_percentile": 0.55678}, "CVE-2017-18447": {"epss_score": 0.00639, "epss_percentile": 0.69934}, "CVE-2017-18448": {"epss_score": 0.00269, "epss_percentile": 0.50151}, "CVE-2017-18449": {"epss_score": 0.00043, "epss_percentile": 0.1334}, "CVE-2017-18450": {"epss_score": 0.00043, "epss_percentile": 0.13171}, "CVE-2017-18451": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2017-18452": {"epss_score": 0.00122, "epss_percentile": 0.32123}, "CVE-2017-18453": {"epss_score": 0.00244, "epss_percentile": 0.47556}, "CVE-2017-18454": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2017-18455": {"epss_score": 0.00381, "epss_percentile": 0.59014}, "CVE-2017-18456": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-18457": {"epss_score": 0.00074, "epss_percentile": 0.22768}, "CVE-2017-18458": {"epss_score": 0.00068, "epss_percentile": 0.21233}, "CVE-2017-18459": {"epss_score": 0.00061, "epss_percentile": 0.19397}, "CVE-2017-18460": {"epss_score": 0.00061, "epss_percentile": 0.19397}, "CVE-2017-18461": {"epss_score": 0.00229, "epss_percentile": 0.45611}, "CVE-2017-18462": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2017-18463": {"epss_score": 0.00061, "epss_percentile": 0.19397}, "CVE-2017-18464": {"epss_score": 0.00244, "epss_percentile": 0.47556}, "CVE-2017-18465": {"epss_score": 0.00074, "epss_percentile": 0.22793}, "CVE-2017-18466": {"epss_score": 0.00244, "epss_percentile": 0.47556}, "CVE-2017-18467": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2017-18468": {"epss_score": 0.00688, "epss_percentile": 0.71212}, "CVE-2017-18469": {"epss_score": 0.00639, "epss_percentile": 0.69934}, "CVE-2017-18470": {"epss_score": 0.00455, "epss_percentile": 0.63314}, "CVE-2017-18471": {"epss_score": 0.00264, "epss_percentile": 0.49699}, "CVE-2017-18472": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2017-18473": {"epss_score": 0.00264, "epss_percentile": 0.49699}, "CVE-2017-18474": {"epss_score": 0.00392, "epss_percentile": 0.5966}, "CVE-2017-18475": {"epss_score": 0.00695, "epss_percentile": 0.71363}, "CVE-2017-18476": {"epss_score": 0.00579, "epss_percentile": 0.68228}, "CVE-2017-18477": {"epss_score": 0.00411, "epss_percentile": 0.60866}, "CVE-2017-18478": {"epss_score": 0.00411, "epss_percentile": 0.60866}, "CVE-2017-18479": {"epss_score": 0.00149, "epss_percentile": 0.3601}, "CVE-2017-18480": {"epss_score": 0.00411, "epss_percentile": 0.60866}, "CVE-2017-18481": {"epss_score": 0.00264, "epss_percentile": 0.49699}, "CVE-2017-18482": {"epss_score": 0.00532, "epss_percentile": 0.66703}, "CVE-2017-18483": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-18484": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-18485": {"epss_score": 0.00115, "epss_percentile": 0.30976}, "CVE-2017-18486": {"epss_score": 0.01586, "epss_percentile": 0.81169}, "CVE-2017-18487": {"epss_score": 0.0048, "epss_percentile": 0.64476}, "CVE-2017-18488": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18489": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18490": {"epss_score": 0.00104, "epss_percentile": 0.29144}, "CVE-2017-18491": {"epss_score": 0.00104, "epss_percentile": 0.29144}, "CVE-2017-18492": {"epss_score": 0.00104, "epss_percentile": 0.29144}, "CVE-2017-18493": {"epss_score": 0.00104, "epss_percentile": 0.29204}, "CVE-2017-18494": {"epss_score": 0.00104, "epss_percentile": 0.29204}, "CVE-2017-18495": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18496": {"epss_score": 0.00104, "epss_percentile": 0.29204}, "CVE-2017-18497": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18498": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18499": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2017-18500": {"epss_score": 0.00385, "epss_percentile": 0.59231}, "CVE-2017-18501": {"epss_score": 0.00385, "epss_percentile": 0.59231}, "CVE-2017-18502": {"epss_score": 0.00314, "epss_percentile": 0.54122}, "CVE-2017-18503": {"epss_score": 0.00408, "epss_percentile": 0.6069}, "CVE-2017-18504": {"epss_score": 0.0018, "epss_percentile": 0.39908}, "CVE-2017-18505": {"epss_score": 0.02615, "epss_percentile": 0.85244}, "CVE-2017-18506": {"epss_score": 0.00408, "epss_percentile": 0.6069}, "CVE-2017-18507": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18508": {"epss_score": 0.00408, "epss_percentile": 0.6069}, "CVE-2017-18509": {"epss_score": 0.00138, "epss_percentile": 0.34403}, "CVE-2017-18510": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2017-18511": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2017-18512": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2017-18513": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2017-18514": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2017-18515": {"epss_score": 0.07859, "epss_percentile": 0.91725}, "CVE-2017-18516": {"epss_score": 0.00059, "epss_percentile": 0.18652}, "CVE-2017-18517": {"epss_score": 0.00059, "epss_percentile": 0.18652}, "CVE-2017-18518": {"epss_score": 0.00059, "epss_percentile": 0.18652}, "CVE-2017-18519": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18520": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18521": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2017-18522": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2017-18523": {"epss_score": 0.00149, "epss_percentile": 0.35951}, "CVE-2017-18524": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18525": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18526": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18527": {"epss_score": 0.00059, "epss_percentile": 0.18652}, "CVE-2017-18528": {"epss_score": 0.00056, "epss_percentile": 0.17679}, "CVE-2017-18529": {"epss_score": 0.00059, "epss_percentile": 0.18652}, "CVE-2017-18530": {"epss_score": 0.00098, "epss_percentile": 0.27688}, "CVE-2017-18531": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2017-18532": {"epss_score": 0.00098, "epss_percentile": 0.27688}, "CVE-2017-18533": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18534": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18535": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18536": {"epss_score": 0.05223, "epss_percentile": 0.89629}, "CVE-2017-18537": {"epss_score": 0.00059, "epss_percentile": 0.18652}, "CVE-2017-18538": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2017-18539": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2017-18540": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2017-18541": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18542": {"epss_score": 0.00089, "epss_percentile": 0.25935}, "CVE-2017-18543": {"epss_score": 0.00591, "epss_percentile": 0.68594}, "CVE-2017-18544": {"epss_score": 0.00092, "epss_percentile": 0.2644}, "CVE-2017-18545": {"epss_score": 0.00236, "epss_percentile": 0.46385}, "CVE-2017-18546": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2017-18547": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2017-18548": {"epss_score": 0.00597, "epss_percentile": 0.68745}, "CVE-2017-18549": {"epss_score": 0.00254, "epss_percentile": 0.48537}, "CVE-2017-18550": {"epss_score": 0.00428, "epss_percentile": 0.61942}, "CVE-2017-18551": {"epss_score": 0.00132, "epss_percentile": 0.33586}, "CVE-2017-18552": {"epss_score": 0.00085, "epss_percentile": 0.25037}, "CVE-2017-18553": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18554": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18555": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18556": {"epss_score": 0.00098, "epss_percentile": 0.27688}, "CVE-2017-18557": {"epss_score": 0.00098, "epss_percentile": 0.27688}, "CVE-2017-18558": {"epss_score": 0.00097, "epss_percentile": 0.27601}, "CVE-2017-18559": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18560": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18561": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18562": {"epss_score": 0.00097, "epss_percentile": 0.27601}, "CVE-2017-18563": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18564": {"epss_score": 0.00097, "epss_percentile": 0.27601}, "CVE-2017-18565": {"epss_score": 0.00097, "epss_percentile": 0.27601}, "CVE-2017-18566": {"epss_score": 0.00097, "epss_percentile": 0.27601}, "CVE-2017-18567": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18568": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18569": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2017-18570": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2017-18571": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2017-18572": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18573": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2017-18574": {"epss_score": 0.00209, "epss_percentile": 0.43363}, "CVE-2017-18575": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18576": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18577": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2017-18578": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18579": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18580": {"epss_score": 0.75969, "epss_percentile": 0.98871}, "CVE-2017-18581": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18582": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18583": {"epss_score": 0.00994, "epss_percentile": 0.76419}, "CVE-2017-18584": {"epss_score": 0.00213, "epss_percentile": 0.43877}, "CVE-2017-18585": {"epss_score": 0.00471, "epss_percentile": 0.64026}, "CVE-2017-18586": {"epss_score": 0.00524, "epss_percentile": 0.66364}, "CVE-2017-18587": {"epss_score": 0.00215, "epss_percentile": 0.44042}, "CVE-2017-18588": {"epss_score": 0.00104, "epss_percentile": 0.2914}, "CVE-2017-18589": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-18590": {"epss_score": 0.00075, "epss_percentile": 0.2296}, "CVE-2017-18591": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18592": {"epss_score": 0.00282, "epss_percentile": 0.51221}, "CVE-2017-18593": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18594": {"epss_score": 0.01169, "epss_percentile": 0.78202}, "CVE-2017-18595": {"epss_score": 0.00126, "epss_percentile": 0.32748}, "CVE-2017-18596": {"epss_score": 0.00552, "epss_percentile": 0.67383}, "CVE-2017-18597": {"epss_score": 0.00604, "epss_percentile": 0.68965}, "CVE-2017-18598": {"epss_score": 0.02107, "epss_percentile": 0.83632}, "CVE-2017-18599": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18600": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2017-18601": {"epss_score": 0.00149, "epss_percentile": 0.36004}, "CVE-2017-18602": {"epss_score": 0.00458, "epss_percentile": 0.63416}, "CVE-2017-18603": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18604": {"epss_score": 0.0038, "epss_percentile": 0.58955}, "CVE-2017-18605": {"epss_score": 0.01263, "epss_percentile": 0.78986}, "CVE-2017-18606": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2017-18607": {"epss_score": 0.003, "epss_percentile": 0.52964}, "CVE-2017-18608": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-18609": {"epss_score": 0.00345, "epss_percentile": 0.56555}, "CVE-2017-18610": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2017-18611": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2017-18612": {"epss_score": 0.00408, "epss_percentile": 0.6069}, "CVE-2017-18613": {"epss_score": 0.00408, "epss_percentile": 0.6069}, "CVE-2017-18614": {"epss_score": 0.00628, "epss_percentile": 0.69648}, "CVE-2017-18615": {"epss_score": 0.00408, "epss_percentile": 0.6069}, "CVE-2017-18634": {"epss_score": 0.01085, "epss_percentile": 0.77404}, "CVE-2017-18635": {"epss_score": 0.08306, "epss_percentile": 0.91981}, "CVE-2017-18636": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2017-18638": {"epss_score": 0.90804, "epss_percentile": 0.99602}, "CVE-2017-18639": {"epss_score": 0.00025, "epss_percentile": 0.06035}, "CVE-2017-18640": {"epss_score": 0.02166, "epss_percentile": 0.8385}, "CVE-2017-18641": {"epss_score": 0.00346, "epss_percentile": 0.56623}, "CVE-2017-18642": {"epss_score": 0.00096, "epss_percentile": 0.27413}, "CVE-2017-18643": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2017-18644": {"epss_score": 0.00199, "epss_percentile": 0.42188}, "CVE-2017-18645": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2017-18646": {"epss_score": 0.00018, "epss_percentile": 0.03899}, "CVE-2017-18647": {"epss_score": 0.00123, "epss_percentile": 0.32241}, "CVE-2017-18648": {"epss_score": 0.0012, "epss_percentile": 0.31691}, "CVE-2017-18649": {"epss_score": 0.00058, "epss_percentile": 0.18448}, "CVE-2017-18650": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2017-18651": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2017-18652": {"epss_score": 0.00315, "epss_percentile": 0.54171}, "CVE-2017-18653": {"epss_score": 0.00088, "epss_percentile": 0.25751}, "CVE-2017-18654": {"epss_score": 0.00131, "epss_percentile": 0.33444}, "CVE-2017-18655": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2017-18656": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-18657": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2017-18658": {"epss_score": 0.00094, "epss_percentile": 0.27077}, "CVE-2017-18659": {"epss_score": 0.0011, "epss_percentile": 0.30192}, "CVE-2017-18660": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2017-18661": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2017-18662": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2017-18663": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2017-18664": {"epss_score": 0.00114, "epss_percentile": 0.30787}, "CVE-2017-18665": {"epss_score": 0.00032, "epss_percentile": 0.0909}, "CVE-2017-18666": {"epss_score": 0.00081, "epss_percentile": 0.24322}, "CVE-2017-18667": {"epss_score": 0.00097, "epss_percentile": 0.27618}, "CVE-2017-18668": {"epss_score": 0.00081, "epss_percentile": 0.24322}, "CVE-2017-18669": {"epss_score": 0.00081, "epss_percentile": 0.24322}, "CVE-2017-18670": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2017-18671": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2017-18672": {"epss_score": 0.00015, "epss_percentile": 0.02148}, "CVE-2017-18673": {"epss_score": 0.00019, "epss_percentile": 0.04156}, "CVE-2017-18674": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2017-18675": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2017-18676": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2017-18677": {"epss_score": 0.00081, "epss_percentile": 0.24322}, "CVE-2017-18678": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2017-18679": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2017-18680": {"epss_score": 0.00019, "epss_percentile": 0.0416}, "CVE-2017-18681": {"epss_score": 0.00626, "epss_percentile": 0.69616}, "CVE-2017-18682": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2017-18683": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2017-18684": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2017-18685": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2017-18686": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-18687": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-18688": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2017-18689": {"epss_score": 0.00043, "epss_percentile": 0.13307}, "CVE-2017-18690": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2017-18691": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2017-18692": {"epss_score": 0.00123, "epss_percentile": 0.32241}, "CVE-2017-18693": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2017-18694": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2017-18695": {"epss_score": 0.00089, "epss_percentile": 0.25922}, "CVE-2017-18696": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2017-18697": {"epss_score": 0.00142, "epss_percentile": 0.35033}, "CVE-2017-18698": {"epss_score": 0.00142, "epss_percentile": 0.35033}, "CVE-2017-18699": {"epss_score": 0.00142, "epss_percentile": 0.35033}, "CVE-2017-18700": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2017-18701": {"epss_score": 0.00273, "epss_percentile": 0.50483}, "CVE-2017-18702": {"epss_score": 0.00073, "epss_percentile": 0.22529}, "CVE-2017-18703": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2017-18704": {"epss_score": 0.00181, "epss_percentile": 0.40088}, "CVE-2017-18705": {"epss_score": 0.00129, "epss_percentile": 0.33129}, "CVE-2017-18706": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2017-18707": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2017-18708": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2017-18709": {"epss_score": 0.00042, "epss_percentile": 0.12764}, "CVE-2017-18710": {"epss_score": 0.00068, "epss_percentile": 0.21411}, "CVE-2017-18711": {"epss_score": 0.00243, "epss_percentile": 0.47485}, "CVE-2017-18712": {"epss_score": 0.00181, "epss_percentile": 0.40088}, "CVE-2017-18713": {"epss_score": 0.00095, "epss_percentile": 0.27148}, "CVE-2017-18714": {"epss_score": 0.00243, "epss_percentile": 0.47508}, "CVE-2017-18715": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2017-18716": {"epss_score": 0.00272, "epss_percentile": 0.50385}, "CVE-2017-18717": {"epss_score": 0.00272, "epss_percentile": 0.50385}, "CVE-2017-18718": {"epss_score": 0.0065, "epss_percentile": 0.70265}, "CVE-2017-18719": {"epss_score": 0.0014, "epss_percentile": 0.34673}, "CVE-2017-18720": {"epss_score": 0.00161, "epss_percentile": 0.37547}, "CVE-2017-18721": {"epss_score": 0.0065, "epss_percentile": 0.70265}, "CVE-2017-18722": {"epss_score": 0.00272, "epss_percentile": 0.50385}, "CVE-2017-18723": {"epss_score": 0.00272, "epss_percentile": 0.50385}, "CVE-2017-18724": {"epss_score": 0.00272, "epss_percentile": 0.50385}, "CVE-2017-18725": {"epss_score": 0.00272, "epss_percentile": 0.50385}, "CVE-2017-18726": {"epss_score": 0.00272, "epss_percentile": 0.50385}, "CVE-2017-18727": {"epss_score": 0.00272, "epss_percentile": 0.50385}, "CVE-2017-18728": {"epss_score": 0.00579, "epss_percentile": 0.68223}, "CVE-2017-18729": {"epss_score": 0.00272, "epss_percentile": 0.50385}, "CVE-2017-18730": {"epss_score": 0.00789, "epss_percentile": 0.73355}, "CVE-2017-18731": {"epss_score": 0.00123, "epss_percentile": 0.32224}, "CVE-2017-18732": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2017-18733": {"epss_score": 0.00161, "epss_percentile": 0.37547}, "CVE-2017-18734": {"epss_score": 0.00788, "epss_percentile": 0.73343}, "CVE-2017-18735": {"epss_score": 0.00788, "epss_percentile": 0.73343}, "CVE-2017-18736": {"epss_score": 0.00794, "epss_percentile": 0.73454}, "CVE-2017-18737": {"epss_score": 0.01536, "epss_percentile": 0.80916}, "CVE-2017-18738": {"epss_score": 0.00854, "epss_percentile": 0.74452}, "CVE-2017-18739": {"epss_score": 0.0014, "epss_percentile": 0.34673}, "CVE-2017-18740": {"epss_score": 0.00072, "epss_percentile": 0.22376}, "CVE-2017-18741": {"epss_score": 0.00095, "epss_percentile": 0.27148}, "CVE-2017-18742": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2017-18743": {"epss_score": 0.00161, "epss_percentile": 0.37547}, "CVE-2017-18744": {"epss_score": 0.0014, "epss_percentile": 0.34673}, "CVE-2017-18745": {"epss_score": 0.00191, "epss_percentile": 0.41168}, "CVE-2017-18746": {"epss_score": 0.00046, "epss_percentile": 0.14307}, "CVE-2017-18747": {"epss_score": 0.00256, "epss_percentile": 0.48834}, "CVE-2017-18748": {"epss_score": 0.00129, "epss_percentile": 0.33129}, "CVE-2017-18749": {"epss_score": 0.0021, "epss_percentile": 0.43452}, "CVE-2017-18750": {"epss_score": 0.00579, "epss_percentile": 0.68223}, "CVE-2017-18751": {"epss_score": 0.01483, "epss_percentile": 0.80587}, "CVE-2017-18752": {"epss_score": 0.00181, "epss_percentile": 0.40016}, "CVE-2017-18754": {"epss_score": 0.001, "epss_percentile": 0.28552}, "CVE-2017-18755": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2017-18756": {"epss_score": 0.00129, "epss_percentile": 0.33129}, "CVE-2017-18757": {"epss_score": 0.00395, "epss_percentile": 0.59849}, "CVE-2017-18758": {"epss_score": 0.00992, "epss_percentile": 0.76397}, "CVE-2017-18759": {"epss_score": 0.0034, "epss_percentile": 0.5627}, "CVE-2017-18761": {"epss_score": 0.00186, "epss_percentile": 0.40636}, "CVE-2017-18762": {"epss_score": 0.00794, "epss_percentile": 0.73454}, "CVE-2017-18763": {"epss_score": 0.00097, "epss_percentile": 0.2757}, "CVE-2017-18764": {"epss_score": 0.00794, "epss_percentile": 0.73454}, "CVE-2017-18765": {"epss_score": 0.00067, "epss_percentile": 0.21097}, "CVE-2017-18766": {"epss_score": 0.00097, "epss_percentile": 0.2757}, "CVE-2017-18767": {"epss_score": 0.00067, "epss_percentile": 0.20982}, "CVE-2017-18768": {"epss_score": 0.00263, "epss_percentile": 0.49512}, "CVE-2017-18769": {"epss_score": 0.00063, "epss_percentile": 0.19948}, "CVE-2017-18770": {"epss_score": 0.00223, "epss_percentile": 0.44959}, "CVE-2017-18772": {"epss_score": 0.00161, "epss_percentile": 0.37547}, "CVE-2017-18773": {"epss_score": 0.00073, "epss_percentile": 0.22507}, "CVE-2017-18775": {"epss_score": 0.00149, "epss_percentile": 0.35936}, "CVE-2017-18776": {"epss_score": 0.00034, "epss_percentile": 0.09704}, "CVE-2017-18777": {"epss_score": 0.00121, "epss_percentile": 0.31954}, "CVE-2017-18778": {"epss_score": 0.00055, "epss_percentile": 0.17502}, "CVE-2017-18779": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2017-18780": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2017-18781": {"epss_score": 0.0021, "epss_percentile": 0.43452}, "CVE-2017-18782": {"epss_score": 0.01687, "epss_percentile": 0.81758}, "CVE-2017-18783": {"epss_score": 0.00332, "epss_percentile": 0.55606}, "CVE-2017-18784": {"epss_score": 0.00185, "epss_percentile": 0.40525}, "CVE-2017-18785": {"epss_score": 0.0006, "epss_percentile": 0.19033}, "CVE-2017-18786": {"epss_score": 0.00349, "epss_percentile": 0.56866}, "CVE-2017-18787": {"epss_score": 0.00349, "epss_percentile": 0.56866}, "CVE-2017-18788": {"epss_score": 0.00064, "epss_percentile": 0.20327}, "CVE-2017-18789": {"epss_score": 0.00048, "epss_percentile": 0.15104}, "CVE-2017-18790": {"epss_score": 0.00063, "epss_percentile": 0.19948}, "CVE-2017-18791": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2017-18792": {"epss_score": 0.00368, "epss_percentile": 0.58173}, "CVE-2017-18793": {"epss_score": 0.00248, "epss_percentile": 0.47935}, "CVE-2017-18794": {"epss_score": 0.00368, "epss_percentile": 0.58173}, "CVE-2017-18795": {"epss_score": 0.00248, "epss_percentile": 0.47935}, "CVE-2017-18796": {"epss_score": 0.00073, "epss_percentile": 0.22507}, "CVE-2017-18797": {"epss_score": 0.00058, "epss_percentile": 0.18281}, "CVE-2017-18798": {"epss_score": 0.00046, "epss_percentile": 0.1441}, "CVE-2017-18799": {"epss_score": 0.00313, "epss_percentile": 0.54034}, "CVE-2017-18800": {"epss_score": 0.00213, "epss_percentile": 0.43927}, "CVE-2017-18801": {"epss_score": 0.00048, "epss_percentile": 0.15279}, "CVE-2017-18802": {"epss_score": 0.00248, "epss_percentile": 0.47935}, "CVE-2017-18803": {"epss_score": 0.00058, "epss_percentile": 0.18434}, "CVE-2017-18804": {"epss_score": 0.00248, "epss_percentile": 0.47935}, "CVE-2017-18805": {"epss_score": 0.00088, "epss_percentile": 0.25792}, "CVE-2017-18806": {"epss_score": 0.00088, "epss_percentile": 0.25792}, "CVE-2017-18807": {"epss_score": 0.00157, "epss_percentile": 0.37068}, "CVE-2017-18808": {"epss_score": 0.00053, "epss_percentile": 0.16715}, "CVE-2017-18809": {"epss_score": 0.00085, "epss_percentile": 0.25121}, "CVE-2017-18810": {"epss_score": 0.00167, "epss_percentile": 0.38403}, "CVE-2017-18811": {"epss_score": 0.00168, "epss_percentile": 0.38437}, "CVE-2017-18812": {"epss_score": 0.00167, "epss_percentile": 0.38403}, "CVE-2017-18813": {"epss_score": 0.00167, "epss_percentile": 0.38403}, "CVE-2017-18814": {"epss_score": 0.00189, "epss_percentile": 0.40979}, "CVE-2017-18815": {"epss_score": 0.00168, "epss_percentile": 0.38437}, "CVE-2017-18816": {"epss_score": 0.00168, "epss_percentile": 0.38437}, "CVE-2017-18819": {"epss_score": 0.00054, "epss_percentile": 0.17226}, "CVE-2017-18820": {"epss_score": 0.00168, "epss_percentile": 0.38437}, "CVE-2017-18821": {"epss_score": 0.00092, "epss_percentile": 0.26519}, "CVE-2017-18822": {"epss_score": 0.00121, "epss_percentile": 0.3192}, "CVE-2017-18823": {"epss_score": 0.00052, "epss_percentile": 0.16557}, "CVE-2017-18824": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2017-18825": {"epss_score": 0.00283, "epss_percentile": 0.51374}, "CVE-2017-18826": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2017-18827": {"epss_score": 0.0019, "epss_percentile": 0.41112}, "CVE-2017-18828": {"epss_score": 0.0019, "epss_percentile": 0.41112}, "CVE-2017-18829": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2017-18830": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2017-18831": {"epss_score": 0.00234, "epss_percentile": 0.46149}, "CVE-2017-18832": {"epss_score": 0.0019, "epss_percentile": 0.41112}, "CVE-2017-18833": {"epss_score": 0.00242, "epss_percentile": 0.4738}, "CVE-2017-18834": {"epss_score": 0.00208, "epss_percentile": 0.43227}, "CVE-2017-18835": {"epss_score": 0.00214, "epss_percentile": 0.43954}, "CVE-2017-18836": {"epss_score": 0.00063, "epss_percentile": 0.19961}, "CVE-2017-18837": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2017-18838": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2017-18839": {"epss_score": 0.0019, "epss_percentile": 0.41112}, "CVE-2017-18840": {"epss_score": 0.00053, "epss_percentile": 0.1687}, "CVE-2017-18841": {"epss_score": 0.00203, "epss_percentile": 0.42573}, "CVE-2017-18842": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2017-18843": {"epss_score": 0.00053, "epss_percentile": 0.16677}, "CVE-2017-18844": {"epss_score": 0.00096, "epss_percentile": 0.27367}, "CVE-2017-18845": {"epss_score": 0.00053, "epss_percentile": 0.16677}, "CVE-2017-18846": {"epss_score": 0.00051, "epss_percentile": 0.16122}, "CVE-2017-18847": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2017-18848": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2017-18849": {"epss_score": 0.00253, "epss_percentile": 0.48439}, "CVE-2017-18850": {"epss_score": 0.00076, "epss_percentile": 0.23092}, "CVE-2017-18851": {"epss_score": 0.00087, "epss_percentile": 0.2556}, "CVE-2017-18852": {"epss_score": 0.00035, "epss_percentile": 0.09969}, "CVE-2017-18853": {"epss_score": 0.0041, "epss_percentile": 0.60826}, "CVE-2017-18854": {"epss_score": 0.00219, "epss_percentile": 0.44467}, "CVE-2017-18855": {"epss_score": 0.00266, "epss_percentile": 0.49926}, "CVE-2017-18856": {"epss_score": 0.00179, "epss_percentile": 0.39852}, "CVE-2017-18857": {"epss_score": 0.00295, "epss_percentile": 0.52504}, "CVE-2017-18858": {"epss_score": 0.02086, "epss_percentile": 0.83549}, "CVE-2017-18859": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2017-18860": {"epss_score": 0.00051, "epss_percentile": 0.16301}, "CVE-2017-18861": {"epss_score": 0.00053, "epss_percentile": 0.16697}, "CVE-2017-18862": {"epss_score": 0.00103, "epss_percentile": 0.2898}, "CVE-2017-18863": {"epss_score": 0.00181, "epss_percentile": 0.40093}, "CVE-2017-18864": {"epss_score": 0.0065, "epss_percentile": 0.70265}, "CVE-2017-18865": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2017-18866": {"epss_score": 0.00191, "epss_percentile": 0.41168}, "CVE-2017-18867": {"epss_score": 0.00058, "epss_percentile": 0.18375}, "CVE-2017-18868": {"epss_score": 0.00141, "epss_percentile": 0.34821}, "CVE-2017-18869": {"epss_score": 0.00123, "epss_percentile": 0.32332}, "CVE-2017-18870": {"epss_score": 0.00221, "epss_percentile": 0.44656}, "CVE-2017-18871": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2017-18872": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2017-18873": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2017-18874": {"epss_score": 0.00716, "epss_percentile": 0.7186}, "CVE-2017-18875": {"epss_score": 0.00182, "epss_percentile": 0.40224}, "CVE-2017-18876": {"epss_score": 0.00258, "epss_percentile": 0.48959}, "CVE-2017-18877": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2017-18878": {"epss_score": 0.00237, "epss_percentile": 0.46739}, "CVE-2017-18879": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2017-18880": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2017-18881": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2017-18882": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2017-18883": {"epss_score": 0.00313, "epss_percentile": 0.54034}, "CVE-2017-18884": {"epss_score": 0.00209, "epss_percentile": 0.43311}, "CVE-2017-18885": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2017-18886": {"epss_score": 0.00336, "epss_percentile": 0.55939}, "CVE-2017-18887": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2017-18888": {"epss_score": 0.00415, "epss_percentile": 0.61132}, "CVE-2017-18889": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2017-18890": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2017-18891": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2017-18892": {"epss_score": 0.00243, "epss_percentile": 0.47472}, "CVE-2017-18893": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2017-18894": {"epss_score": 0.00209, "epss_percentile": 0.43311}, "CVE-2017-18895": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2017-18896": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2017-18897": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2017-18898": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2017-18899": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2017-18900": {"epss_score": 0.00647, "epss_percentile": 0.70197}, "CVE-2017-18901": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2017-18902": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2017-18903": {"epss_score": 0.00171, "epss_percentile": 0.38802}, "CVE-2017-18904": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2017-18905": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2017-18906": {"epss_score": 0.00209, "epss_percentile": 0.43311}, "CVE-2017-18907": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2017-18908": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2017-18909": {"epss_score": 0.00148, "epss_percentile": 0.35914}, "CVE-2017-18910": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2017-18911": {"epss_score": 0.00136, "epss_percentile": 0.34156}, "CVE-2017-18912": {"epss_score": 0.00733, "epss_percentile": 0.72205}, "CVE-2017-18913": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2017-18914": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2017-18915": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2017-18916": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2017-18917": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2017-18918": {"epss_score": 0.00098, "epss_percentile": 0.27712}, "CVE-2017-18919": {"epss_score": 0.00224, "epss_percentile": 0.45058}, "CVE-2017-18920": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2017-18921": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2017-18922": {"epss_score": 0.04777, "epss_percentile": 0.89132}, "CVE-2017-18923": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2017-18924": {"epss_score": 0.00202, "epss_percentile": 0.42406}, "CVE-2017-18925": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2017-18926": {"epss_score": 0.02722, "epss_percentile": 0.8552}, "CVE-2017-1081": {"epss_score": 0.0221, "epss_percentile": 0.84012}, "CVE-2017-1082": {"epss_score": 0.00415, "epss_percentile": 0.61145}, "CVE-2017-1083": {"epss_score": 0.0039, "epss_percentile": 0.5953}, "CVE-2017-1084": {"epss_score": 0.24449, "epss_percentile": 0.95922}, "CVE-2017-1085": {"epss_score": 0.00669, "epss_percentile": 0.70747}, "CVE-2017-1086": {"epss_score": 0.00075, "epss_percentile": 0.22886}, "CVE-2017-1087": {"epss_score": 0.00051, "epss_percentile": 0.16144}, "CVE-2017-1088": {"epss_score": 0.00075, "epss_percentile": 0.22886}, "CVE-2017-1092": {"epss_score": 0.80359, "epss_percentile": 0.99083}, "CVE-2017-1093": {"epss_score": 0.00047, "epss_percentile": 0.14655}, "CVE-2017-1096": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1097": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2017-1098": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2017-1099": {"epss_score": 0.35506, "epss_percentile": 0.96916}, "CVE-2017-1100": {"epss_score": 0.00272, "epss_percentile": 0.50402}, "CVE-2017-1101": {"epss_score": 0.00272, "epss_percentile": 0.50402}, "CVE-2017-1102": {"epss_score": 0.00272, "epss_percentile": 0.50402}, "CVE-2017-1103": {"epss_score": 0.00378, "epss_percentile": 0.58787}, "CVE-2017-1104": {"epss_score": 0.00272, "epss_percentile": 0.50402}, "CVE-2017-1105": {"epss_score": 0.00065, "epss_percentile": 0.20563}, "CVE-2017-1106": {"epss_score": 0.00253, "epss_percentile": 0.48454}, "CVE-2017-1107": {"epss_score": 0.00354, "epss_percentile": 0.57227}, "CVE-2017-1110": {"epss_score": 0.00219, "epss_percentile": 0.44502}, "CVE-2017-1113": {"epss_score": 0.00272, "epss_percentile": 0.50402}, "CVE-2017-1114": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2017-1115": {"epss_score": 0.00092, "epss_percentile": 0.26425}, "CVE-2017-1116": {"epss_score": 0.00212, "epss_percentile": 0.43805}, "CVE-2017-1117": {"epss_score": 0.00419, "epss_percentile": 0.61371}, "CVE-2017-1118": {"epss_score": 0.00511, "epss_percentile": 0.65814}, "CVE-2017-1119": {"epss_score": 0.00094, "epss_percentile": 0.27063}, "CVE-2017-1120": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2017-1121": {"epss_score": 0.0027, "epss_percentile": 0.50218}, "CVE-2017-1122": {"epss_score": 0.00049, "epss_percentile": 0.15625}, "CVE-2017-1124": {"epss_score": 0.00046, "epss_percentile": 0.14088}, "CVE-2017-1125": {"epss_score": 0.00054, "epss_percentile": 0.171}, "CVE-2017-1126": {"epss_score": 0.00186, "epss_percentile": 0.40592}, "CVE-2017-1127": {"epss_score": 0.00303, "epss_percentile": 0.53194}, "CVE-2017-1128": {"epss_score": 0.00303, "epss_percentile": 0.53194}, "CVE-2017-1129": {"epss_score": 0.68501, "epss_percentile": 0.98551}, "CVE-2017-1130": {"epss_score": 0.6548, "epss_percentile": 0.98421}, "CVE-2017-1131": {"epss_score": 0.00188, "epss_percentile": 0.40861}, "CVE-2017-1132": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1133": {"epss_score": 0.00258, "epss_percentile": 0.49}, "CVE-2017-1134": {"epss_score": 0.00047, "epss_percentile": 0.14655}, "CVE-2017-1137": {"epss_score": 0.00988, "epss_percentile": 0.76356}, "CVE-2017-1140": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1141": {"epss_score": 0.00179, "epss_percentile": 0.39826}, "CVE-2017-1142": {"epss_score": 0.00183, "epss_percentile": 0.40319}, "CVE-2017-1143": {"epss_score": 0.00139, "epss_percentile": 0.3455}, "CVE-2017-1144": {"epss_score": 0.00058, "epss_percentile": 0.18284}, "CVE-2017-1145": {"epss_score": 0.00495, "epss_percentile": 0.6511}, "CVE-2017-1146": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2017-1147": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1148": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2017-1149": {"epss_score": 0.00359, "epss_percentile": 0.57568}, "CVE-2017-1150": {"epss_score": 0.00159, "epss_percentile": 0.37317}, "CVE-2017-1151": {"epss_score": 0.00558, "epss_percentile": 0.67577}, "CVE-2017-1152": {"epss_score": 0.00134, "epss_percentile": 0.3376}, "CVE-2017-1153": {"epss_score": 0.00528, "epss_percentile": 0.66539}, "CVE-2017-1154": {"epss_score": 0.00251, "epss_percentile": 0.48312}, "CVE-2017-1155": {"epss_score": 0.00526, "epss_percentile": 0.66399}, "CVE-2017-1156": {"epss_score": 0.00678, "epss_percentile": 0.71001}, "CVE-2017-1157": {"epss_score": 0.00212, "epss_percentile": 0.43805}, "CVE-2017-1159": {"epss_score": 0.001, "epss_percentile": 0.28511}, "CVE-2017-1160": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2017-1161": {"epss_score": 0.00376, "epss_percentile": 0.58687}, "CVE-2017-1162": {"epss_score": 0.00296, "epss_percentile": 0.52565}, "CVE-2017-1164": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1168": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1169": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1170": {"epss_score": 0.00081, "epss_percentile": 0.24362}, "CVE-2017-1171": {"epss_score": 0.0019, "epss_percentile": 0.41088}, "CVE-2017-1174": {"epss_score": 0.00615, "epss_percentile": 0.69311}, "CVE-2017-1175": {"epss_score": 0.00675, "epss_percentile": 0.70887}, "CVE-2017-1176": {"epss_score": 0.00054, "epss_percentile": 0.171}, "CVE-2017-1177": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2017-1178": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2017-1179": {"epss_score": 0.00137, "epss_percentile": 0.3432}, "CVE-2017-1180": {"epss_score": 0.0019, "epss_percentile": 0.41088}, "CVE-2017-1181": {"epss_score": 0.00032, "epss_percentile": 0.0899}, "CVE-2017-1182": {"epss_score": 0.04791, "epss_percentile": 0.89149}, "CVE-2017-1183": {"epss_score": 0.00911, "epss_percentile": 0.75327}, "CVE-2017-1189": {"epss_score": 0.00309, "epss_percentile": 0.53652}, "CVE-2017-1190": {"epss_score": 0.00054, "epss_percentile": 0.17253}, "CVE-2017-1191": {"epss_score": 0.0013, "epss_percentile": 0.33297}, "CVE-2017-1192": {"epss_score": 0.00528, "epss_percentile": 0.66534}, "CVE-2017-1193": {"epss_score": 0.00285, "epss_percentile": 0.51524}, "CVE-2017-1194": {"epss_score": 0.00171, "epss_percentile": 0.38809}, "CVE-2017-1195": {"epss_score": 0.0015, "epss_percentile": 0.36071}, "CVE-2017-1196": {"epss_score": 0.00312, "epss_percentile": 0.53999}, "CVE-2017-1197": {"epss_score": 0.00365, "epss_percentile": 0.57969}, "CVE-2017-1198": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2017-1199": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1200": {"epss_score": 0.00082, "epss_percentile": 0.24409}, "CVE-2017-1201": {"epss_score": 0.00036, "epss_percentile": 0.10452}, "CVE-2017-1202": {"epss_score": 0.00092, "epss_percentile": 0.26425}, "CVE-2017-1203": {"epss_score": 0.00307, "epss_percentile": 0.53468}, "CVE-2017-1204": {"epss_score": 0.01167, "epss_percentile": 0.78188}, "CVE-2017-1205": {"epss_score": 0.00043, "epss_percentile": 0.13339}, "CVE-2017-1207": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2017-1208": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1209": {"epss_score": 0.00184, "epss_percentile": 0.40393}, "CVE-2017-1210": {"epss_score": 0.00258, "epss_percentile": 0.48991}, "CVE-2017-1211": {"epss_score": 0.00045, "epss_percentile": 0.13833}, "CVE-2017-1212": {"epss_score": 0.00241, "epss_percentile": 0.47253}, "CVE-2017-1214": {"epss_score": 0.00357, "epss_percentile": 0.57409}, "CVE-2017-1217": {"epss_score": 0.00419, "epss_percentile": 0.61382}, "CVE-2017-1218": {"epss_score": 0.00142, "epss_percentile": 0.34962}, "CVE-2017-1219": {"epss_score": 0.00537, "epss_percentile": 0.66893}, "CVE-2017-1220": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2017-1221": {"epss_score": 0.00261, "epss_percentile": 0.49314}, "CVE-2017-1222": {"epss_score": 0.00178, "epss_percentile": 0.39714}, "CVE-2017-1223": {"epss_score": 0.00212, "epss_percentile": 0.43783}, "CVE-2017-1224": {"epss_score": 0.00137, "epss_percentile": 0.3432}, "CVE-2017-1225": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2017-1226": {"epss_score": 0.00212, "epss_percentile": 0.43747}, "CVE-2017-1227": {"epss_score": 0.00327, "epss_percentile": 0.55146}, "CVE-2017-1228": {"epss_score": 0.00234, "epss_percentile": 0.46122}, "CVE-2017-1229": {"epss_score": 0.00171, "epss_percentile": 0.38781}, "CVE-2017-1230": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2017-1231": {"epss_score": 0.00028, "epss_percentile": 0.07563}, "CVE-2017-1232": {"epss_score": 0.00137, "epss_percentile": 0.3432}, "CVE-2017-1233": {"epss_score": 0.00031, "epss_percentile": 0.08535}, "CVE-2017-1234": {"epss_score": 0.00359, "epss_percentile": 0.57542}, "CVE-2017-1235": {"epss_score": 0.00352, "epss_percentile": 0.57102}, "CVE-2017-1236": {"epss_score": 0.00465, "epss_percentile": 0.63764}, "CVE-2017-1237": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1238": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2017-1239": {"epss_score": 0.00126, "epss_percentile": 0.32732}, "CVE-2017-1240": {"epss_score": 0.00177, "epss_percentile": 0.39593}, "CVE-2017-1241": {"epss_score": 0.00177, "epss_percentile": 0.39593}, "CVE-2017-1242": {"epss_score": 0.00129, "epss_percentile": 0.33109}, "CVE-2017-1245": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2017-1247": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1248": {"epss_score": 0.00177, "epss_percentile": 0.39571}, "CVE-2017-1249": {"epss_score": 0.002, "epss_percentile": 0.4226}, "CVE-2017-1250": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1251": {"epss_score": 0.0013, "epss_percentile": 0.33297}, "CVE-2017-1253": {"epss_score": 0.01355, "epss_percentile": 0.79708}, "CVE-2017-1254": {"epss_score": 0.00465, "epss_percentile": 0.6378}, "CVE-2017-1255": {"epss_score": 0.00106, "epss_percentile": 0.29488}, "CVE-2017-1256": {"epss_score": 0.0032, "epss_percentile": 0.54631}, "CVE-2017-1257": {"epss_score": 0.0023, "epss_percentile": 0.4569}, "CVE-2017-1258": {"epss_score": 0.00178, "epss_percentile": 0.39714}, "CVE-2017-1261": {"epss_score": 0.00047, "epss_percentile": 0.1491}, "CVE-2017-1262": {"epss_score": 0.0032, "epss_percentile": 0.54583}, "CVE-2017-1264": {"epss_score": 0.00253, "epss_percentile": 0.48474}, "CVE-2017-1265": {"epss_score": 0.00099, "epss_percentile": 0.28351}, "CVE-2017-1266": {"epss_score": 0.00086, "epss_percentile": 0.25367}, "CVE-2017-1267": {"epss_score": 0.0078, "epss_percentile": 0.73163}, "CVE-2017-1268": {"epss_score": 0.00163, "epss_percentile": 0.37818}, "CVE-2017-1269": {"epss_score": 0.00675, "epss_percentile": 0.70887}, "CVE-2017-1270": {"epss_score": 0.00053, "epss_percentile": 0.16912}, "CVE-2017-1271": {"epss_score": 0.00059, "epss_percentile": 0.18856}, "CVE-2017-1272": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2017-1274": {"epss_score": 0.17768, "epss_percentile": 0.94903}, "CVE-2017-1275": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1276": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1277": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1278": {"epss_score": 0.00182, "epss_percentile": 0.4025}, "CVE-2017-1279": {"epss_score": 0.00638, "epss_percentile": 0.69907}, "CVE-2017-1280": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1281": {"epss_score": 0.00162, "epss_percentile": 0.37739}, "CVE-2017-1282": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2017-1283": {"epss_score": 0.00276, "epss_percentile": 0.50723}, "CVE-2017-1284": {"epss_score": 0.00057, "epss_percentile": 0.18093}, "CVE-2017-1285": {"epss_score": 0.00465, "epss_percentile": 0.63764}, "CVE-2017-1286": {"epss_score": 0.00208, "epss_percentile": 0.43297}, "CVE-2017-1287": {"epss_score": 0.00096, "epss_percentile": 0.27384}, "CVE-2017-1289": {"epss_score": 0.00923, "epss_percentile": 0.75509}, "CVE-2017-1290": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1291": {"epss_score": 0.00146, "epss_percentile": 0.35632}, "CVE-2017-1292": {"epss_score": 0.00185, "epss_percentile": 0.40547}, "CVE-2017-1293": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1294": {"epss_score": 0.00162, "epss_percentile": 0.37739}, "CVE-2017-1295": {"epss_score": 0.00177, "epss_percentile": 0.39593}, "CVE-2017-1297": {"epss_score": 0.00266, "epss_percentile": 0.49878}, "CVE-2017-1299": {"epss_score": 0.002, "epss_percentile": 0.4226}, "CVE-2017-1300": {"epss_score": 0.00171, "epss_percentile": 0.38809}, "CVE-2017-1301": {"epss_score": 0.00103, "epss_percentile": 0.29076}, "CVE-2017-1302": {"epss_score": 0.00057, "epss_percentile": 0.18093}, "CVE-2017-1303": {"epss_score": 0.00248, "epss_percentile": 0.47995}, "CVE-2017-1304": {"epss_score": 0.00071, "epss_percentile": 0.22066}, "CVE-2017-1305": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1306": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1308": {"epss_score": 0.00285, "epss_percentile": 0.51673}, "CVE-2017-1309": {"epss_score": 0.00024, "epss_percentile": 0.06021}, "CVE-2017-1310": {"epss_score": 0.00717, "epss_percentile": 0.71889}, "CVE-2017-1311": {"epss_score": 0.00615, "epss_percentile": 0.69311}, "CVE-2017-1312": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1313": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1314": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1315": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1316": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1317": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1318": {"epss_score": 0.00988, "epss_percentile": 0.76356}, "CVE-2017-1319": {"epss_score": 0.00137, "epss_percentile": 0.3432}, "CVE-2017-1320": {"epss_score": 0.00258, "epss_percentile": 0.49}, "CVE-2017-1321": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2017-1322": {"epss_score": 0.00528, "epss_percentile": 0.66534}, "CVE-2017-1324": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1325": {"epss_score": 0.0032, "epss_percentile": 0.54631}, "CVE-2017-1326": {"epss_score": 0.00141, "epss_percentile": 0.34903}, "CVE-2017-1327": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2017-1328": {"epss_score": 0.00275, "epss_percentile": 0.50679}, "CVE-2017-1329": {"epss_score": 0.00129, "epss_percentile": 0.33109}, "CVE-2017-1331": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1332": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2017-1333": {"epss_score": 0.00203, "epss_percentile": 0.42566}, "CVE-2017-1334": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1335": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1336": {"epss_score": 0.0025, "epss_percentile": 0.48145}, "CVE-2017-1337": {"epss_score": 0.00281, "epss_percentile": 0.5119}, "CVE-2017-1338": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1339": {"epss_score": 0.00021, "epss_percentile": 0.04873}, "CVE-2017-1340": {"epss_score": 0.00212, "epss_percentile": 0.43805}, "CVE-2017-1341": {"epss_score": 0.00198, "epss_percentile": 0.4202}, "CVE-2017-1342": {"epss_score": 0.0013, "epss_percentile": 0.33337}, "CVE-2017-1345": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2017-1346": {"epss_score": 0.00042, "epss_percentile": 0.12571}, "CVE-2017-1347": {"epss_score": 0.00615, "epss_percentile": 0.69311}, "CVE-2017-1348": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1349": {"epss_score": 0.00057, "epss_percentile": 0.18093}, "CVE-2017-1350": {"epss_score": 0.0007, "epss_percentile": 0.21717}, "CVE-2017-1352": {"epss_score": 0.00328, "epss_percentile": 0.55184}, "CVE-2017-1353": {"epss_score": 0.00138, "epss_percentile": 0.34398}, "CVE-2017-1354": {"epss_score": 0.00184, "epss_percentile": 0.40393}, "CVE-2017-1355": {"epss_score": 0.00186, "epss_percentile": 0.40592}, "CVE-2017-1356": {"epss_score": 0.00572, "epss_percentile": 0.68034}, "CVE-2017-1357": {"epss_score": 0.00215, "epss_percentile": 0.44102}, "CVE-2017-1359": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1362": {"epss_score": 0.00045, "epss_percentile": 0.13797}, "CVE-2017-1363": {"epss_score": 0.0025, "epss_percentile": 0.48145}, "CVE-2017-1364": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1365": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2017-1366": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2017-1367": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2017-1368": {"epss_score": 0.00217, "epss_percentile": 0.44251}, "CVE-2017-1369": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1370": {"epss_score": 0.00258, "epss_percentile": 0.48965}, "CVE-2017-1371": {"epss_score": 0.00459, "epss_percentile": 0.63497}, "CVE-2017-1372": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2017-1373": {"epss_score": 0.00598, "epss_percentile": 0.68759}, "CVE-2017-1374": {"epss_score": 0.00261, "epss_percentile": 0.49268}, "CVE-2017-1375": {"epss_score": 0.00137, "epss_percentile": 0.3432}, "CVE-2017-1376": {"epss_score": 0.0082, "epss_percentile": 0.73884}, "CVE-2017-1377": {"epss_score": 0.00212, "epss_percentile": 0.43747}, "CVE-2017-1378": {"epss_score": 0.00036, "epss_percentile": 0.10452}, "CVE-2017-1379": {"epss_score": 0.00312, "epss_percentile": 0.53984}, "CVE-2017-1380": {"epss_score": 0.00403, "epss_percentile": 0.60349}, "CVE-2017-1381": {"epss_score": 0.00057, "epss_percentile": 0.18095}, "CVE-2017-1382": {"epss_score": 0.00039, "epss_percentile": 0.11449}, "CVE-2017-1383": {"epss_score": 0.00575, "epss_percentile": 0.68105}, "CVE-2017-1386": {"epss_score": 0.00215, "epss_percentile": 0.44098}, "CVE-2017-1395": {"epss_score": 0.00192, "epss_percentile": 0.41371}, "CVE-2017-1396": {"epss_score": 0.00136, "epss_percentile": 0.34142}, "CVE-2017-1398": {"epss_score": 0.00151, "epss_percentile": 0.36289}, "CVE-2017-1405": {"epss_score": 0.0006, "epss_percentile": 0.19194}, "CVE-2017-1407": {"epss_score": 0.03897, "epss_percentile": 0.87917}, "CVE-2017-1409": {"epss_score": 0.00161, "epss_percentile": 0.37572}, "CVE-2017-1411": {"epss_score": 0.00203, "epss_percentile": 0.42513}, "CVE-2017-1412": {"epss_score": 0.00137, "epss_percentile": 0.3425}, "CVE-2017-1418": {"epss_score": 0.00037, "epss_percentile": 0.10936}, "CVE-2017-1421": {"epss_score": 0.00287, "epss_percentile": 0.51831}, "CVE-2017-1422": {"epss_score": 0.0013, "epss_percentile": 0.3325}, "CVE-2017-1423": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2017-1424": {"epss_score": 0.00253, "epss_percentile": 0.48454}, "CVE-2017-1425": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1427": {"epss_score": 0.00285, "epss_percentile": 0.51652}, "CVE-2017-1428": {"epss_score": 0.00257, "epss_percentile": 0.48923}, "CVE-2017-1429": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1431": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2017-1433": {"epss_score": 0.00389, "epss_percentile": 0.59496}, "CVE-2017-1434": {"epss_score": 0.00068, "epss_percentile": 0.21381}, "CVE-2017-1438": {"epss_score": 0.00072, "epss_percentile": 0.22266}, "CVE-2017-1439": {"epss_score": 0.00072, "epss_percentile": 0.22266}, "CVE-2017-1440": {"epss_score": 0.04457, "epss_percentile": 0.88714}, "CVE-2017-1441": {"epss_score": 0.00057, "epss_percentile": 0.18093}, "CVE-2017-1442": {"epss_score": 0.00171, "epss_percentile": 0.38809}, "CVE-2017-1443": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2017-1444": {"epss_score": 0.00084, "epss_percentile": 0.25021}, "CVE-2017-1445": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1446": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1447": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2017-1448": {"epss_score": 0.00119, "epss_percentile": 0.31549}, "CVE-2017-1449": {"epss_score": 0.00084, "epss_percentile": 0.24878}, "CVE-2017-1450": {"epss_score": 0.0015, "epss_percentile": 0.36071}, "CVE-2017-1451": {"epss_score": 0.00059, "epss_percentile": 0.18637}, "CVE-2017-1452": {"epss_score": 0.00059, "epss_percentile": 0.18637}, "CVE-2017-1453": {"epss_score": 0.04969, "epss_percentile": 0.89349}, "CVE-2017-1457": {"epss_score": 0.00248, "epss_percentile": 0.47995}, "CVE-2017-1458": {"epss_score": 0.0066, "epss_percentile": 0.70521}, "CVE-2017-1459": {"epss_score": 0.00102, "epss_percentile": 0.28797}, "CVE-2017-1460": {"epss_score": 0.00392, "epss_percentile": 0.59687}, "CVE-2017-1461": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1462": {"epss_score": 0.00375, "epss_percentile": 0.5862}, "CVE-2017-1465": {"epss_score": 0.0012, "epss_percentile": 0.31715}, "CVE-2017-1467": {"epss_score": 0.00558, "epss_percentile": 0.67587}, "CVE-2017-1468": {"epss_score": 0.00061, "epss_percentile": 0.19346}, "CVE-2017-1469": {"epss_score": 0.00099, "epss_percentile": 0.28364}, "CVE-2017-1473": {"epss_score": 0.00106, "epss_percentile": 0.29488}, "CVE-2017-1474": {"epss_score": 0.00191, "epss_percentile": 0.41188}, "CVE-2017-1476": {"epss_score": 0.00238, "epss_percentile": 0.46756}, "CVE-2017-1477": {"epss_score": 0.00583, "epss_percentile": 0.68324}, "CVE-2017-1478": {"epss_score": 0.00089, "epss_percentile": 0.259}, "CVE-2017-1480": {"epss_score": 0.00128, "epss_percentile": 0.33072}, "CVE-2017-1481": {"epss_score": 0.00177, "epss_percentile": 0.39593}, "CVE-2017-1482": {"epss_score": 0.0025, "epss_percentile": 0.48145}, "CVE-2017-1483": {"epss_score": 0.00523, "epss_percentile": 0.66299}, "CVE-2017-1484": {"epss_score": 0.00212, "epss_percentile": 0.43805}, "CVE-2017-1485": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2017-1486": {"epss_score": 0.00182, "epss_percentile": 0.40276}, "CVE-2017-1487": {"epss_score": 0.00239, "epss_percentile": 0.46877}, "CVE-2017-1488": {"epss_score": 0.00187, "epss_percentile": 0.40773}, "CVE-2017-1489": {"epss_score": 0.0021, "epss_percentile": 0.43498}, "CVE-2017-1490": {"epss_score": 0.00285, "epss_percentile": 0.51524}, "CVE-2017-1491": {"epss_score": 0.0011, "epss_percentile": 0.30209}, "CVE-2017-1493": {"epss_score": 0.00135, "epss_percentile": 0.34036}, "CVE-2017-1494": {"epss_score": 0.00286, "epss_percentile": 0.51721}, "CVE-2017-1495": {"epss_score": 0.00258, "epss_percentile": 0.48995}, "CVE-2017-1496": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2017-1497": {"epss_score": 0.00186, "epss_percentile": 0.40592}, "CVE-2017-1498": {"epss_score": 0.0025, "epss_percentile": 0.48145}, "CVE-2017-1499": {"epss_score": 0.01962, "epss_percentile": 0.83065}, "CVE-2017-1500": {"epss_score": 0.0021, "epss_percentile": 0.43588}, "CVE-2017-1501": {"epss_score": 0.00701, "epss_percentile": 0.71494}, "CVE-2017-1502": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2017-1503": {"epss_score": 0.00277, "epss_percentile": 0.5082}, "CVE-2017-1504": {"epss_score": 0.00157, "epss_percentile": 0.37127}, "CVE-2017-1506": {"epss_score": 0.00405, "epss_percentile": 0.60475}, "CVE-2017-1507": {"epss_score": 0.0013, "epss_percentile": 0.33297}, "CVE-2017-1508": {"epss_score": 0.00043, "epss_percentile": 0.13187}, "CVE-2017-1509": {"epss_score": 0.00137, "epss_percentile": 0.34292}, "CVE-2017-1515": {"epss_score": 0.0037, "epss_percentile": 0.58309}, "CVE-2017-1516": {"epss_score": 0.00251, "epss_percentile": 0.48286}, "CVE-2017-1519": {"epss_score": 0.01513, "epss_percentile": 0.80787}, "CVE-2017-1520": {"epss_score": 0.00199, "epss_percentile": 0.42145}, "CVE-2017-1521": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2017-1522": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2017-1523": {"epss_score": 0.00263, "epss_percentile": 0.49475}, "CVE-2017-1524": {"epss_score": 0.00264, "epss_percentile": 0.49733}, "CVE-2017-1527": {"epss_score": 0.00542, "epss_percentile": 0.67081}, "CVE-2017-1530": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1531": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1532": {"epss_score": 0.00316, "epss_percentile": 0.54293}, "CVE-2017-1533": {"epss_score": 0.00309, "epss_percentile": 0.53652}, "CVE-2017-1534": {"epss_score": 0.00291, "epss_percentile": 0.52198}, "CVE-2017-1535": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1536": {"epss_score": 0.0025, "epss_percentile": 0.48145}, "CVE-2017-1538": {"epss_score": 0.00744, "epss_percentile": 0.72508}, "CVE-2017-1539": {"epss_score": 0.00596, "epss_percentile": 0.68719}, "CVE-2017-1540": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2017-1541": {"epss_score": 0.0046, "epss_percentile": 0.63534}, "CVE-2017-1544": {"epss_score": 0.00052, "epss_percentile": 0.16536}, "CVE-2017-1545": {"epss_score": 0.00065, "epss_percentile": 0.20445}, "CVE-2017-1546": {"epss_score": 0.0025, "epss_percentile": 0.48145}, "CVE-2017-1548": {"epss_score": 0.00496, "epss_percentile": 0.6517}, "CVE-2017-1549": {"epss_score": 0.00292, "epss_percentile": 0.52242}, "CVE-2017-1550": {"epss_score": 0.00274, "epss_percentile": 0.50527}, "CVE-2017-1551": {"epss_score": 0.00159, "epss_percentile": 0.37366}, "CVE-2017-1552": {"epss_score": 0.0019, "epss_percentile": 0.41113}, "CVE-2017-1553": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1554": {"epss_score": 0.00182, "epss_percentile": 0.4025}, "CVE-2017-1555": {"epss_score": 0.00215, "epss_percentile": 0.44102}, "CVE-2017-1556": {"epss_score": 0.00465, "epss_percentile": 0.63764}, "CVE-2017-1557": {"epss_score": 0.00375, "epss_percentile": 0.58606}, "CVE-2017-1558": {"epss_score": 0.00177, "epss_percentile": 0.3962}, "CVE-2017-1559": {"epss_score": 0.00179, "epss_percentile": 0.39783}, "CVE-2017-1560": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1561": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1562": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1563": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2017-1564": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1565": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1567": {"epss_score": 0.00316, "epss_percentile": 0.54293}, "CVE-2017-1568": {"epss_score": 0.00162, "epss_percentile": 0.37739}, "CVE-2017-1569": {"epss_score": 0.00511, "epss_percentile": 0.65814}, "CVE-2017-1570": {"epss_score": 0.00178, "epss_percentile": 0.39653}, "CVE-2017-1571": {"epss_score": 0.00031, "epss_percentile": 0.08555}, "CVE-2017-1575": {"epss_score": 0.00023, "epss_percentile": 0.05466}, "CVE-2017-1577": {"epss_score": 0.01468, "epss_percentile": 0.80479}, "CVE-2017-1583": {"epss_score": 0.0111, "epss_percentile": 0.77659}, "CVE-2017-1591": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2017-1592": {"epss_score": 0.00162, "epss_percentile": 0.37739}, "CVE-2017-1593": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1595": {"epss_score": 0.00053, "epss_percentile": 0.16739}, "CVE-2017-1596": {"epss_score": 0.00053, "epss_percentile": 0.16739}, "CVE-2017-1597": {"epss_score": 0.00241, "epss_percentile": 0.47322}, "CVE-2017-1598": {"epss_score": 0.00122, "epss_percentile": 0.32088}, "CVE-2017-1600": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2017-1601": {"epss_score": 0.00502, "epss_percentile": 0.654}, "CVE-2017-1602": {"epss_score": 0.00165, "epss_percentile": 0.3806}, "CVE-2017-1604": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1606": {"epss_score": 0.00572, "epss_percentile": 0.68034}, "CVE-2017-1607": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1608": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1609": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2017-1612": {"epss_score": 0.00094, "epss_percentile": 0.26978}, "CVE-2017-1613": {"epss_score": 0.00323, "epss_percentile": 0.54892}, "CVE-2017-1621": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1622": {"epss_score": 0.00079, "epss_percentile": 0.23942}, "CVE-2017-1623": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2017-1624": {"epss_score": 0.00067, "epss_percentile": 0.21099}, "CVE-2017-1625": {"epss_score": 0.00191, "epss_percentile": 0.41188}, "CVE-2017-1628": {"epss_score": 0.00563, "epss_percentile": 0.67737}, "CVE-2017-1629": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2017-1631": {"epss_score": 0.0011, "epss_percentile": 0.30114}, "CVE-2017-1632": {"epss_score": 0.0025, "epss_percentile": 0.48145}, "CVE-2017-1633": {"epss_score": 0.00264, "epss_percentile": 0.49733}, "CVE-2017-1635": {"epss_score": 0.18199, "epss_percentile": 0.94973}, "CVE-2017-1649": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2017-1650": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1651": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1652": {"epss_score": 0.00162, "epss_percentile": 0.37739}, "CVE-2017-1653": {"epss_score": 0.00574, "epss_percentile": 0.6808}, "CVE-2017-1654": {"epss_score": 0.00054, "epss_percentile": 0.17336}, "CVE-2017-1655": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2017-1659": {"epss_score": 0.00289, "epss_percentile": 0.52077}, "CVE-2017-1664": {"epss_score": 0.00137, "epss_percentile": 0.3432}, "CVE-2017-1665": {"epss_score": 0.00142, "epss_percentile": 0.35001}, "CVE-2017-1666": {"epss_score": 0.0066, "epss_percentile": 0.70521}, "CVE-2017-1668": {"epss_score": 0.00195, "epss_percentile": 0.41688}, "CVE-2017-1669": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2017-1670": {"epss_score": 0.00675, "epss_percentile": 0.70887}, "CVE-2017-1671": {"epss_score": 0.00955, "epss_percentile": 0.75916}, "CVE-2017-1672": {"epss_score": 0.00131, "epss_percentile": 0.3345}, "CVE-2017-1673": {"epss_score": 0.00262, "epss_percentile": 0.49358}, "CVE-2017-1677": {"epss_score": 0.00167, "epss_percentile": 0.38345}, "CVE-2017-1678": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1679": {"epss_score": 0.00047, "epss_percentile": 0.14476}, "CVE-2017-1681": {"epss_score": 0.00054, "epss_percentile": 0.171}, "CVE-2017-1682": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2017-1683": {"epss_score": 0.0025, "epss_percentile": 0.48145}, "CVE-2017-1688": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1689": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1690": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2017-1691": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1692": {"epss_score": 0.00055, "epss_percentile": 0.1748}, "CVE-2017-1693": {"epss_score": 0.00294, "epss_percentile": 0.52434}, "CVE-2017-1694": {"epss_score": 0.0013, "epss_percentile": 0.33251}, "CVE-2017-1695": {"epss_score": 0.00158, "epss_percentile": 0.37218}, "CVE-2017-1696": {"epss_score": 0.04036, "epss_percentile": 0.88158}, "CVE-2017-1698": {"epss_score": 0.00315, "epss_percentile": 0.54166}, "CVE-2017-1699": {"epss_score": 0.00029, "epss_percentile": 0.07701}, "CVE-2017-1700": {"epss_score": 0.00269, "epss_percentile": 0.50127}, "CVE-2017-1701": {"epss_score": 0.0007, "epss_percentile": 0.21697}, "CVE-2017-1705": {"epss_score": 0.00162, "epss_percentile": 0.37692}, "CVE-2017-1710": {"epss_score": 0.01013, "epss_percentile": 0.76637}, "CVE-2017-1711": {"epss_score": 0.00214, "epss_percentile": 0.43952}, "CVE-2017-1712": {"epss_score": 0.00185, "epss_percentile": 0.40477}, "CVE-2017-1713": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2017-1714": {"epss_score": 0.00047, "epss_percentile": 0.14655}, "CVE-2017-1715": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1716": {"epss_score": 0.00039, "epss_percentile": 0.11454}, "CVE-2017-1717": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1720": {"epss_score": 0.00191, "epss_percentile": 0.41214}, "CVE-2017-1721": {"epss_score": 0.00583, "epss_percentile": 0.68353}, "CVE-2017-1722": {"epss_score": 0.00219, "epss_percentile": 0.44484}, "CVE-2017-1723": {"epss_score": 0.00409, "epss_percentile": 0.60753}, "CVE-2017-1724": {"epss_score": 0.00172, "epss_percentile": 0.39009}, "CVE-2017-1725": {"epss_score": 0.00252, "epss_percentile": 0.48351}, "CVE-2017-1727": {"epss_score": 0.00177, "epss_percentile": 0.39593}, "CVE-2017-1729": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1731": {"epss_score": 0.01747, "epss_percentile": 0.82077}, "CVE-2017-1732": {"epss_score": 0.00232, "epss_percentile": 0.45956}, "CVE-2017-1733": {"epss_score": 0.00046, "epss_percentile": 0.14473}, "CVE-2017-1734": {"epss_score": 0.0021, "epss_percentile": 0.43613}, "CVE-2017-1738": {"epss_score": 0.00121, "epss_percentile": 0.31961}, "CVE-2017-1739": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1740": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2017-1741": {"epss_score": 0.00249, "epss_percentile": 0.48053}, "CVE-2017-1743": {"epss_score": 0.00279, "epss_percentile": 0.50946}, "CVE-2017-1746": {"epss_score": 0.0011, "epss_percentile": 0.30114}, "CVE-2017-1747": {"epss_score": 0.00244, "epss_percentile": 0.47616}, "CVE-2017-1748": {"epss_score": 0.0013, "epss_percentile": 0.33222}, "CVE-2017-1749": {"epss_score": 0.00532, "epss_percentile": 0.66677}, "CVE-2017-1750": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2017-1751": {"epss_score": 0.0025, "epss_percentile": 0.48145}, "CVE-2017-1752": {"epss_score": 0.00258, "epss_percentile": 0.49013}, "CVE-2017-1753": {"epss_score": 0.00078, "epss_percentile": 0.23649}, "CVE-2017-1755": {"epss_score": 0.00047, "epss_percentile": 0.14771}, "CVE-2017-1756": {"epss_score": 0.00054, "epss_percentile": 0.17336}, "CVE-2017-1757": {"epss_score": 0.01075, "epss_percentile": 0.77305}, "CVE-2017-1758": {"epss_score": 0.00456, "epss_percentile": 0.63353}, "CVE-2017-1760": {"epss_score": 0.00041, "epss_percentile": 0.12365}, "CVE-2017-1761": {"epss_score": 0.00282, "epss_percentile": 0.51211}, "CVE-2017-1762": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2017-1764": {"epss_score": 0.00036, "epss_percentile": 0.10452}, "CVE-2017-1765": {"epss_score": 0.00323, "epss_percentile": 0.54886}, "CVE-2017-1766": {"epss_score": 0.00097, "epss_percentile": 0.27538}, "CVE-2017-1767": {"epss_score": 0.0039, "epss_percentile": 0.59558}, "CVE-2017-1768": {"epss_score": 0.00231, "epss_percentile": 0.45771}, "CVE-2017-1769": {"epss_score": 0.00203, "epss_percentile": 0.42544}, "CVE-2017-1772": {"epss_score": 0.00178, "epss_percentile": 0.39727}, "CVE-2017-1773": {"epss_score": 0.00107, "epss_percentile": 0.29689}, "CVE-2017-1774": {"epss_score": 0.00222, "epss_percentile": 0.4474}, "CVE-2017-1779": {"epss_score": 0.00103, "epss_percentile": 0.2907}, "CVE-2017-1783": {"epss_score": 0.00086, "epss_percentile": 0.25346}, "CVE-2017-1784": {"epss_score": 0.00153, "epss_percentile": 0.36557}, "CVE-2017-1785": {"epss_score": 0.00119, "epss_percentile": 0.31536}, "CVE-2017-1786": {"epss_score": 0.00322, "epss_percentile": 0.54787}, "CVE-2017-1787": {"epss_score": 0.00039, "epss_percentile": 0.1166}, "CVE-2017-1788": {"epss_score": 0.00201, "epss_percentile": 0.42305}, "CVE-2017-1789": {"epss_score": 0.0199, "epss_percentile": 0.83173}, "CVE-2017-1790": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2017-1791": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1792": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1793": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2017-1794": {"epss_score": 0.00408, "epss_percentile": 0.60626}, "CVE-2017-1795": {"epss_score": 0.0004, "epss_percentile": 0.12187}, "CVE-2017-20001": {"epss_score": 0.00079, "epss_percentile": 0.23981}, "CVE-2017-20002": {"epss_score": 0.00052, "epss_percentile": 0.16437}, "CVE-2017-20004": {"epss_score": 0.0024, "epss_percentile": 0.46968}, "CVE-2017-20005": {"epss_score": 0.0325, "epss_percentile": 0.86748}, "CVE-2017-20006": {"epss_score": 0.0036, "epss_percentile": 0.57653}, "CVE-2017-20007": {"epss_score": 0.00531, "epss_percentile": 0.66652}, "CVE-2017-20008": {"epss_score": 0.00423, "epss_percentile": 0.61634}, "CVE-2017-20011": {"epss_score": 0.00131, "epss_percentile": 0.33395}, "CVE-2017-20012": {"epss_score": 0.00153, "epss_percentile": 0.3654}, "CVE-2017-20013": {"epss_score": 0.00153, "epss_percentile": 0.3654}, "CVE-2017-20014": {"epss_score": 0.00105, "epss_percentile": 0.29365}, "CVE-2017-20015": {"epss_score": 0.0009, "epss_percentile": 0.25997}, "CVE-2017-20016": {"epss_score": 0.00824, "epss_percentile": 0.73934}, "CVE-2017-20017": {"epss_score": 0.00245, "epss_percentile": 0.47643}, "CVE-2017-20018": {"epss_score": 0.00171, "epss_percentile": 0.3887}, "CVE-2017-20019": {"epss_score": 0.00273, "epss_percentile": 0.50481}, "CVE-2017-20020": {"epss_score": 0.00128, "epss_percentile": 0.32997}, "CVE-2017-20021": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2017-20022": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2017-20023": {"epss_score": 0.00311, "epss_percentile": 0.53838}, "CVE-2017-20024": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2017-20025": {"epss_score": 0.00347, "epss_percentile": 0.56754}, "CVE-2017-20026": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2017-20027": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2017-20028": {"epss_score": 0.00334, "epss_percentile": 0.5572}, "CVE-2017-20029": {"epss_score": 0.01825, "epss_percentile": 0.82431}, "CVE-2017-20030": {"epss_score": 0.00261, "epss_percentile": 0.49274}, "CVE-2017-20031": {"epss_score": 0.00228, "epss_percentile": 0.45466}, "CVE-2017-20032": {"epss_score": 0.00245, "epss_percentile": 0.47643}, "CVE-2017-20033": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-20034": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-20035": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-20036": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-20037": {"epss_score": 0.00221, "epss_percentile": 0.44698}, "CVE-2017-20038": {"epss_score": 0.00221, "epss_percentile": 0.44698}, "CVE-2017-20039": {"epss_score": 0.00404, "epss_percentile": 0.60414}, "CVE-2017-20040": {"epss_score": 0.00018, "epss_percentile": 0.0386}, "CVE-2017-20041": {"epss_score": 0.00207, "epss_percentile": 0.43155}, "CVE-2017-20042": {"epss_score": 0.00229, "epss_percentile": 0.45573}, "CVE-2017-20043": {"epss_score": 0.00184, "epss_percentile": 0.40431}, "CVE-2017-20044": {"epss_score": 0.00184, "epss_percentile": 0.40431}, "CVE-2017-20045": {"epss_score": 0.00131, "epss_percentile": 0.3348}, "CVE-2017-20049": {"epss_score": 0.00372, "epss_percentile": 0.58423}, "CVE-2017-20051": {"epss_score": 0.00219, "epss_percentile": 0.44532}, "CVE-2017-20052": {"epss_score": 0.00451, "epss_percentile": 0.63123}, "CVE-2017-20053": {"epss_score": 0.00125, "epss_percentile": 0.32588}, "CVE-2017-20054": {"epss_score": 0.00231, "epss_percentile": 0.4578}, "CVE-2017-20055": {"epss_score": 0.00271, "epss_percentile": 0.50316}, "CVE-2017-20056": {"epss_score": 0.00271, "epss_percentile": 0.50316}, "CVE-2017-20057": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-20058": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-20059": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-20060": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-20061": {"epss_score": 0.00195, "epss_percentile": 0.41625}, "CVE-2017-20062": {"epss_score": 0.00138, "epss_percentile": 0.34525}, "CVE-2017-20063": {"epss_score": 0.00295, "epss_percentile": 0.52482}, "CVE-2017-20064": {"epss_score": 0.00476, "epss_percentile": 0.64259}, "CVE-2017-20065": {"epss_score": 0.00226, "epss_percentile": 0.4533}, "CVE-2017-20066": {"epss_score": 0.00143, "epss_percentile": 0.35111}, "CVE-2017-20067": {"epss_score": 0.00223, "epss_percentile": 0.44886}, "CVE-2017-20068": {"epss_score": 0.00276, "epss_percentile": 0.50706}, "CVE-2017-20069": {"epss_score": 0.00276, "epss_percentile": 0.50706}, "CVE-2017-20070": {"epss_score": 0.00285, "epss_percentile": 0.51521}, "CVE-2017-20071": {"epss_score": 0.00285, "epss_percentile": 0.51521}, "CVE-2017-20072": {"epss_score": 0.00285, "epss_percentile": 0.51521}, "CVE-2017-20073": {"epss_score": 0.00285, "epss_percentile": 0.51521}, "CVE-2017-20074": {"epss_score": 0.00285, "epss_percentile": 0.51521}, "CVE-2017-20075": {"epss_score": 0.00285, "epss_percentile": 0.51521}, "CVE-2017-20076": {"epss_score": 0.00285, "epss_percentile": 0.51521}, "CVE-2017-20077": {"epss_score": 0.00285, "epss_percentile": 0.51521}, "CVE-2017-20078": {"epss_score": 0.00285, "epss_percentile": 0.51521}, "CVE-2017-20079": {"epss_score": 0.00285, "epss_percentile": 0.51521}, "CVE-2017-20080": {"epss_score": 0.00285, "epss_percentile": 0.51521}, "CVE-2017-20081": {"epss_score": 0.00285, "epss_percentile": 0.51521}, "CVE-2017-20082": {"epss_score": 0.00072, "epss_percentile": 0.22277}, "CVE-2017-20083": {"epss_score": 0.00073, "epss_percentile": 0.22542}, "CVE-2017-20084": {"epss_score": 0.00065, "epss_percentile": 0.20597}, "CVE-2017-20085": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-20086": {"epss_score": 0.00444, "epss_percentile": 0.62849}, "CVE-2017-20087": {"epss_score": 0.00206, "epss_percentile": 0.43041}, "CVE-2017-20088": {"epss_score": 0.00127, "epss_percentile": 0.32911}, "CVE-2017-20089": {"epss_score": 0.00206, "epss_percentile": 0.43041}, "CVE-2017-20090": {"epss_score": 0.0013, "epss_percentile": 0.33238}, "CVE-2017-20091": {"epss_score": 0.00127, "epss_percentile": 0.32911}, "CVE-2017-20092": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2017-20093": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2017-20094": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-20095": {"epss_score": 0.00476, "epss_percentile": 0.64259}, "CVE-2017-20096": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2017-20097": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2017-20098": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2017-20099": {"epss_score": 0.00489, "epss_percentile": 0.64869}, "CVE-2017-20100": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2017-20101": {"epss_score": 0.00139, "epss_percentile": 0.34653}, "CVE-2017-20102": {"epss_score": 0.00055, "epss_percentile": 0.17478}, "CVE-2017-20103": {"epss_score": 0.00394, "epss_percentile": 0.59782}, "CVE-2017-20104": {"epss_score": 0.0036, "epss_percentile": 0.57649}, "CVE-2017-20105": {"epss_score": 0.00437, "epss_percentile": 0.62521}, "CVE-2017-20106": {"epss_score": 0.00111, "epss_percentile": 0.30301}, "CVE-2017-20107": {"epss_score": 0.00038, "epss_percentile": 0.11136}, "CVE-2017-20108": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2017-20109": {"epss_score": 0.00128, "epss_percentile": 0.32971}, "CVE-2017-20110": {"epss_score": 0.00273, "epss_percentile": 0.50481}, "CVE-2017-20111": {"epss_score": 0.00359, "epss_percentile": 0.57608}, "CVE-2017-20112": {"epss_score": 0.00046, "epss_percentile": 0.14321}, "CVE-2017-20113": {"epss_score": 0.00195, "epss_percentile": 0.41621}, "CVE-2017-20114": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2017-20115": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2017-20116": {"epss_score": 0.00291, "epss_percentile": 0.52165}, "CVE-2017-20117": {"epss_score": 0.00291, "epss_percentile": 0.52165}, "CVE-2017-20118": {"epss_score": 0.00291, "epss_percentile": 0.52165}, "CVE-2017-20119": {"epss_score": 0.00255, "epss_percentile": 0.48696}, "CVE-2017-20120": {"epss_score": 0.0013, "epss_percentile": 0.33238}, "CVE-2017-20121": {"epss_score": 0.00113, "epss_percentile": 0.30698}, "CVE-2017-20122": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-20123": {"epss_score": 0.0061, "epss_percentile": 0.69137}, "CVE-2017-20124": {"epss_score": 0.00078, "epss_percentile": 0.23774}, "CVE-2017-20125": {"epss_score": 0.00106, "epss_percentile": 0.29576}, "CVE-2017-20126": {"epss_score": 0.00207, "epss_percentile": 0.43086}, "CVE-2017-20127": {"epss_score": 0.00365, "epss_percentile": 0.57968}, "CVE-2017-20128": {"epss_score": 0.00328, "epss_percentile": 0.55162}, "CVE-2017-20129": {"epss_score": 0.00189, "epss_percentile": 0.4093}, "CVE-2017-20130": {"epss_score": 0.00251, "epss_percentile": 0.48306}, "CVE-2017-20131": {"epss_score": 0.00251, "epss_percentile": 0.48306}, "CVE-2017-20132": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2017-20133": {"epss_score": 0.00315, "epss_percentile": 0.54196}, "CVE-2017-20134": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2017-20135": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2017-20136": {"epss_score": 0.00203, "epss_percentile": 0.42512}, "CVE-2017-20137": {"epss_score": 0.00203, "epss_percentile": 0.42512}, "CVE-2017-20138": {"epss_score": 0.00179, "epss_percentile": 0.39791}, "CVE-2017-20139": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2017-20140": {"epss_score": 0.00191, "epss_percentile": 0.41166}, "CVE-2017-20141": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2017-20142": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2017-20143": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2017-20144": {"epss_score": 0.00307, "epss_percentile": 0.53564}, "CVE-2017-20145": {"epss_score": 0.00469, "epss_percentile": 0.63958}, "CVE-2017-20146": {"epss_score": 0.00108, "epss_percentile": 0.29804}, "CVE-2017-20147": {"epss_score": 0.00258, "epss_percentile": 0.4902}, "CVE-2017-20148": {"epss_score": 0.00309, "epss_percentile": 0.53701}, "CVE-2017-20149": {"epss_score": 0.01675, "epss_percentile": 0.81703}, "CVE-2017-20150": {"epss_score": 0.00349, "epss_percentile": 0.56875}, "CVE-2017-20151": {"epss_score": 0.00307, "epss_percentile": 0.53484}, "CVE-2017-20152": {"epss_score": 0.00509, "epss_percentile": 0.65733}, "CVE-2017-20153": {"epss_score": 0.00353, "epss_percentile": 0.57149}, "CVE-2017-20154": {"epss_score": 0.0027, "epss_percentile": 0.50268}, "CVE-2017-20155": {"epss_score": 0.00472, "epss_percentile": 0.64047}, "CVE-2017-20156": {"epss_score": 0.03121, "epss_percentile": 0.8645}, "CVE-2017-20157": {"epss_score": 0.00363, "epss_percentile": 0.5783}, "CVE-2017-20158": {"epss_score": 0.00378, "epss_percentile": 0.58834}, "CVE-2017-20159": {"epss_score": 0.00244, "epss_percentile": 0.47573}, "CVE-2017-20160": {"epss_score": 0.00478, "epss_percentile": 0.64373}, "CVE-2017-20161": {"epss_score": 0.00166, "epss_percentile": 0.38148}, "CVE-2017-20162": {"epss_score": 0.0008, "epss_percentile": 0.24134}, "CVE-2017-20163": {"epss_score": 0.00358, "epss_percentile": 0.57503}, "CVE-2017-20164": {"epss_score": 0.00061, "epss_percentile": 0.19314}, "CVE-2017-20165": {"epss_score": 0.01247, "epss_percentile": 0.78862}, "CVE-2017-20166": {"epss_score": 0.00161, "epss_percentile": 0.3756}, "CVE-2017-20167": {"epss_score": 0.00075, "epss_percentile": 0.2293}, "CVE-2017-20168": {"epss_score": 0.00055, "epss_percentile": 0.17609}, "CVE-2017-20169": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2017-20170": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2017-20171": {"epss_score": 0.0007, "epss_percentile": 0.21767}, "CVE-2017-20172": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2017-20173": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2017-20174": {"epss_score": 0.00104, "epss_percentile": 0.29198}, "CVE-2017-20175": {"epss_score": 0.0008, "epss_percentile": 0.24048}, "CVE-2017-20176": {"epss_score": 0.00088, "epss_percentile": 0.25769}, "CVE-2017-20177": {"epss_score": 0.00268, "epss_percentile": 0.501}, "CVE-2017-20178": {"epss_score": 0.00114, "epss_percentile": 0.30854}, "CVE-2017-20179": {"epss_score": 0.00103, "epss_percentile": 0.28996}, "CVE-2017-20180": {"epss_score": 0.0004, "epss_percentile": 0.12137}, "CVE-2017-20181": {"epss_score": 0.0004, "epss_percentile": 0.11991}, "CVE-2017-20182": {"epss_score": 0.00073, "epss_percentile": 0.2265}, "CVE-2017-20183": {"epss_score": 0.00085, "epss_percentile": 0.25116}, "CVE-2017-20184": {"epss_score": 0.00229, "epss_percentile": 0.45611}, "CVE-2017-20185": {"epss_score": 0.00056, "epss_percentile": 0.17775}, "CVE-2017-20186": {"epss_score": 0.0005, "epss_percentile": 0.15699}, "CVE-2017-20187": {"epss_score": 0.00085, "epss_percentile": 0.25193}, "CVE-2017-20188": {"epss_score": 0.00134, "epss_percentile": 0.33894}, "CVE-2017-20189": {"epss_score": 0.03638, "epss_percentile": 0.87484}, "CVE-2017-20190": {"epss_score": 0.00096, "epss_percentile": 0.27348}, "CVE-2017-20191": {"epss_score": 0.00072, "epss_percentile": 0.22426}, "CVE-2017-20192": {"epss_score": 0.29483, "epss_percentile": 0.96447}, "CVE-2017-20193": {"epss_score": 0.01745, "epss_percentile": 0.82067}, "CVE-2017-20194": {"epss_score": 0.10488, "epss_percentile": 0.93005}, "CVE-2017-20195": {"epss_score": 0.00091, "epss_percentile": 0.26411}, "CVE-2017-20196": {"epss_score": 0.00066, "epss_percentile": 0.20856}, "CVE-2017-20197": {"epss_score": 0.00035, "epss_percentile": 0.10154}, "CVE-2017-20198": {"epss_score": 0.63324, "epss_percentile": 0.98328}, "CVE-2017-20199": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2017-20200": {"epss_score": 0.00021, "epss_percentile": 0.0487}, "CVE-2017-20201": {"epss_score": 0.00105, "epss_percentile": 0.29285}, "CVE-2017-20202": {"epss_score": 0.00086, "epss_percentile": 0.2533}, "CVE-2017-20203": {"epss_score": 0.00486, "epss_percentile": 0.64774}, "CVE-2017-20204": {"epss_score": 0.00759, "epss_percentile": 0.72792}, "CVE-2017-20205": {"epss_score": 0.00407, "epss_percentile": 0.60619}, "CVE-2017-20206": {"epss_score": 0.0021, "epss_percentile": 0.43496}, "CVE-2017-20207": {"epss_score": 0.0021, "epss_percentile": 0.43496}, "CVE-2017-20208": {"epss_score": 0.0021, "epss_percentile": 0.43496}, "CVE-2017-20209": {"epss_score": 0.00503, "epss_percentile": 0.65469}, "CVE-2017-20210": {"epss_score": 0.00065, "epss_percentile": 0.20449}, "CVE-2017-20211": {"epss_score": 0.00419, "epss_percentile": 0.61353}, "CVE-2017-20212": {"epss_score": 0.0019, "epss_percentile": 0.41115}, "CVE-2017-20213": {"epss_score": 0.001, "epss_percentile": 0.28514}, "CVE-2017-20214": {"epss_score": 0.00033, "epss_percentile": 0.09205}, "CVE-2017-20215": {"epss_score": 0.00264, "epss_percentile": 0.49733}, "CVE-2017-20216": {"epss_score": 0.00311, "epss_percentile": 0.53922}, "CVE-2017-2090": {"epss_score": 0.03372, "epss_percentile": 0.87013}, "CVE-2017-2091": {"epss_score": 0.00195, "epss_percentile": 0.41642}, "CVE-2017-2092": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-2093": {"epss_score": 0.00297, "epss_percentile": 0.52687}, "CVE-2017-2094": {"epss_score": 0.00153, "epss_percentile": 0.36624}, "CVE-2017-2095": {"epss_score": 0.00195, "epss_percentile": 0.41642}, "CVE-2017-2096": {"epss_score": 0.04665, "epss_percentile": 0.88979}, "CVE-2017-2097": {"epss_score": 0.0011, "epss_percentile": 0.3008}, "CVE-2017-2098": {"epss_score": 0.01525, "epss_percentile": 0.80855}, "CVE-2017-2099": {"epss_score": 0.00443, "epss_percentile": 0.62766}, "CVE-2017-2100": {"epss_score": 0.00335, "epss_percentile": 0.558}, "CVE-2017-2101": {"epss_score": 0.00424, "epss_percentile": 0.61655}, "CVE-2017-2102": {"epss_score": 0.00154, "epss_percentile": 0.36695}, "CVE-2017-2103": {"epss_score": 0.00289, "epss_percentile": 0.52029}, "CVE-2017-2104": {"epss_score": 0.00289, "epss_percentile": 0.52029}, "CVE-2017-2105": {"epss_score": 0.00289, "epss_percentile": 0.52029}, "CVE-2017-2106": {"epss_score": 0.00343, "epss_percentile": 0.56471}, "CVE-2017-2107": {"epss_score": 0.00441, "epss_percentile": 0.6266}, "CVE-2017-2108": {"epss_score": 0.0047, "epss_percentile": 0.63972}, "CVE-2017-2109": {"epss_score": 0.00262, "epss_percentile": 0.49378}, "CVE-2017-2110": {"epss_score": 0.00256, "epss_percentile": 0.48791}, "CVE-2017-2111": {"epss_score": 0.00338, "epss_percentile": 0.56133}, "CVE-2017-2112": {"epss_score": 0.03746, "epss_percentile": 0.87662}, "CVE-2017-2113": {"epss_score": 0.0241, "epss_percentile": 0.84663}, "CVE-2017-2114": {"epss_score": 0.00181, "epss_percentile": 0.40086}, "CVE-2017-2115": {"epss_score": 0.00125, "epss_percentile": 0.32614}, "CVE-2017-2116": {"epss_score": 0.00195, "epss_percentile": 0.41642}, "CVE-2017-2117": {"epss_score": 0.01726, "epss_percentile": 0.81964}, "CVE-2017-2118": {"epss_score": 0.00324, "epss_percentile": 0.54941}, "CVE-2017-2119": {"epss_score": 0.07421, "epss_percentile": 0.91467}, "CVE-2017-2120": {"epss_score": 0.01173, "epss_percentile": 0.78243}, "CVE-2017-2122": {"epss_score": 0.002, "epss_percentile": 0.42272}, "CVE-2017-2123": {"epss_score": 0.00324, "epss_percentile": 0.54941}, "CVE-2017-2124": {"epss_score": 0.00271, "epss_percentile": 0.50313}, "CVE-2017-2125": {"epss_score": 0.01785, "epss_percentile": 0.82254}, "CVE-2017-2126": {"epss_score": 0.13465, "epss_percentile": 0.93972}, "CVE-2017-2127": {"epss_score": 0.00125, "epss_percentile": 0.32552}, "CVE-2017-2128": {"epss_score": 0.0126, "epss_percentile": 0.78971}, "CVE-2017-2130": {"epss_score": 0.0039, "epss_percentile": 0.59526}, "CVE-2017-2131": {"epss_score": 0.00209, "epss_percentile": 0.43325}, "CVE-2017-2132": {"epss_score": 0.00682, "epss_percentile": 0.7107}, "CVE-2017-2133": {"epss_score": 0.00327, "epss_percentile": 0.55144}, "CVE-2017-2134": {"epss_score": 0.00297, "epss_percentile": 0.52689}, "CVE-2017-2135": {"epss_score": 0.00324, "epss_percentile": 0.54941}, "CVE-2017-2136": {"epss_score": 0.01082, "epss_percentile": 0.77384}, "CVE-2017-2137": {"epss_score": 0.00129, "epss_percentile": 0.33092}, "CVE-2017-2138": {"epss_score": 0.00154, "epss_percentile": 0.36646}, "CVE-2017-2139": {"epss_score": 0.00153, "epss_percentile": 0.36507}, "CVE-2017-2140": {"epss_score": 0.00884, "epss_percentile": 0.74932}, "CVE-2017-2141": {"epss_score": 0.00484, "epss_percentile": 0.64667}, "CVE-2017-2142": {"epss_score": 0.02791, "epss_percentile": 0.85669}, "CVE-2017-2143": {"epss_score": 0.00356, "epss_percentile": 0.57385}, "CVE-2017-2144": {"epss_score": 0.00287, "epss_percentile": 0.51819}, "CVE-2017-2145": {"epss_score": 0.00197, "epss_percentile": 0.41961}, "CVE-2017-2146": {"epss_score": 0.002, "epss_percentile": 0.42222}, "CVE-2017-2147": {"epss_score": 0.00343, "epss_percentile": 0.56471}, "CVE-2017-2148": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-2149": {"epss_score": 0.07542, "epss_percentile": 0.91527}, "CVE-2017-2150": {"epss_score": 0.01197, "epss_percentile": 0.78443}, "CVE-2017-2151": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2017-2152": {"epss_score": 0.00265, "epss_percentile": 0.49779}, "CVE-2017-2153": {"epss_score": 0.00694, "epss_percentile": 0.71338}, "CVE-2017-2154": {"epss_score": 0.00301, "epss_percentile": 0.53074}, "CVE-2017-2155": {"epss_score": 0.01846, "epss_percentile": 0.82512}, "CVE-2017-2156": {"epss_score": 0.00398, "epss_percentile": 0.60091}, "CVE-2017-2157": {"epss_score": 0.00163, "epss_percentile": 0.37826}, "CVE-2017-2158": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2017-2161": {"epss_score": 0.00093, "epss_percentile": 0.26714}, "CVE-2017-2162": {"epss_score": 0.00115, "epss_percentile": 0.31012}, "CVE-2017-2163": {"epss_score": 0.10577, "epss_percentile": 0.93033}, "CVE-2017-2164": {"epss_score": 0.00196, "epss_percentile": 0.41807}, "CVE-2017-2165": {"epss_score": 0.0027, "epss_percentile": 0.50224}, "CVE-2017-2166": {"epss_score": 0.00175, "epss_percentile": 0.39366}, "CVE-2017-2167": {"epss_score": 0.00655, "epss_percentile": 0.70366}, "CVE-2017-2168": {"epss_score": 0.00594, "epss_percentile": 0.68658}, "CVE-2017-2169": {"epss_score": 0.00469, "epss_percentile": 0.63921}, "CVE-2017-2171": {"epss_score": 0.00233, "epss_percentile": 0.45976}, "CVE-2017-2172": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2017-2173": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-2174": {"epss_score": 0.00324, "epss_percentile": 0.54941}, "CVE-2017-2175": {"epss_score": 0.0039, "epss_percentile": 0.59526}, "CVE-2017-2176": {"epss_score": 0.00419, "epss_percentile": 0.61365}, "CVE-2017-2177": {"epss_score": 0.00929, "epss_percentile": 0.75587}, "CVE-2017-2178": {"epss_score": 0.0051, "epss_percentile": 0.65769}, "CVE-2017-2179": {"epss_score": 0.00882, "epss_percentile": 0.74894}, "CVE-2017-2180": {"epss_score": 0.00201, "epss_percentile": 0.42322}, "CVE-2017-2181": {"epss_score": 0.00498, "epss_percentile": 0.65236}, "CVE-2017-2182": {"epss_score": 0.00498, "epss_percentile": 0.65236}, "CVE-2017-2183": {"epss_score": 0.00536, "epss_percentile": 0.66857}, "CVE-2017-2184": {"epss_score": 0.00755, "epss_percentile": 0.72722}, "CVE-2017-2185": {"epss_score": 0.00906, "epss_percentile": 0.75247}, "CVE-2017-2186": {"epss_score": 0.00502, "epss_percentile": 0.65408}, "CVE-2017-2187": {"epss_score": 0.00286, "epss_percentile": 0.51737}, "CVE-2017-2188": {"epss_score": 0.00222, "epss_percentile": 0.44798}, "CVE-2017-2189": {"epss_score": 0.00151, "epss_percentile": 0.36264}, "CVE-2017-2190": {"epss_score": 0.00237, "epss_percentile": 0.46462}, "CVE-2017-2191": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2192": {"epss_score": 0.00237, "epss_percentile": 0.46462}, "CVE-2017-2193": {"epss_score": 0.00248, "epss_percentile": 0.47974}, "CVE-2017-2194": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2017-2195": {"epss_score": 0.0082, "epss_percentile": 0.73883}, "CVE-2017-2206": {"epss_score": 0.01536, "epss_percentile": 0.8092}, "CVE-2017-2207": {"epss_score": 0.01536, "epss_percentile": 0.8092}, "CVE-2017-2208": {"epss_score": 0.00511, "epss_percentile": 0.65817}, "CVE-2017-2209": {"epss_score": 0.0025, "epss_percentile": 0.48207}, "CVE-2017-2210": {"epss_score": 0.00171, "epss_percentile": 0.38824}, "CVE-2017-2211": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2212": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2213": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2214": {"epss_score": 0.00277, "epss_percentile": 0.50796}, "CVE-2017-2215": {"epss_score": 0.0028, "epss_percentile": 0.51077}, "CVE-2017-2216": {"epss_score": 0.00479, "epss_percentile": 0.64413}, "CVE-2017-2217": {"epss_score": 0.00356, "epss_percentile": 0.57369}, "CVE-2017-2218": {"epss_score": 0.00183, "epss_percentile": 0.4031}, "CVE-2017-2219": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2220": {"epss_score": 0.00222, "epss_percentile": 0.44798}, "CVE-2017-2221": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2222": {"epss_score": 0.00283, "epss_percentile": 0.51409}, "CVE-2017-2223": {"epss_score": 0.00112, "epss_percentile": 0.30519}, "CVE-2017-2224": {"epss_score": 0.00423, "epss_percentile": 0.61623}, "CVE-2017-2225": {"epss_score": 0.00579, "epss_percentile": 0.68215}, "CVE-2017-2226": {"epss_score": 0.00228, "epss_percentile": 0.45533}, "CVE-2017-2227": {"epss_score": 0.00206, "epss_percentile": 0.43058}, "CVE-2017-2228": {"epss_score": 0.00324, "epss_percentile": 0.54946}, "CVE-2017-2229": {"epss_score": 0.00251, "epss_percentile": 0.4829}, "CVE-2017-2230": {"epss_score": 0.0039, "epss_percentile": 0.59539}, "CVE-2017-2231": {"epss_score": 0.00146, "epss_percentile": 0.35635}, "CVE-2017-2232": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2233": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2234": {"epss_score": 0.00657, "epss_percentile": 0.70469}, "CVE-2017-2235": {"epss_score": 0.00311, "epss_percentile": 0.53819}, "CVE-2017-2236": {"epss_score": 0.00327, "epss_percentile": 0.55147}, "CVE-2017-2237": {"epss_score": 0.00424, "epss_percentile": 0.61652}, "CVE-2017-2238": {"epss_score": 0.00136, "epss_percentile": 0.34147}, "CVE-2017-2239": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2017-2240": {"epss_score": 0.00755, "epss_percentile": 0.72714}, "CVE-2017-2241": {"epss_score": 0.00308, "epss_percentile": 0.53632}, "CVE-2017-2242": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2243": {"epss_score": 0.00448, "epss_percentile": 0.63007}, "CVE-2017-2244": {"epss_score": 0.00124, "epss_percentile": 0.32366}, "CVE-2017-2245": {"epss_score": 0.0061, "epss_percentile": 0.69145}, "CVE-2017-2246": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2247": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2248": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2249": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2252": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2253": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2254": {"epss_score": 0.00371, "epss_percentile": 0.5836}, "CVE-2017-2255": {"epss_score": 0.00253, "epss_percentile": 0.48442}, "CVE-2017-2256": {"epss_score": 0.00253, "epss_percentile": 0.48442}, "CVE-2017-2257": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2017-2258": {"epss_score": 0.0128, "epss_percentile": 0.79141}, "CVE-2017-2265": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2266": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2267": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2268": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2269": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2270": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2017-2271": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2272": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2273": {"epss_score": 0.00136, "epss_percentile": 0.34147}, "CVE-2017-2274": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2017-2275": {"epss_score": 0.00519, "epss_percentile": 0.66184}, "CVE-2017-2276": {"epss_score": 0.00206, "epss_percentile": 0.43067}, "CVE-2017-2277": {"epss_score": 0.00297, "epss_percentile": 0.52703}, "CVE-2017-2278": {"epss_score": 0.00313, "epss_percentile": 0.54044}, "CVE-2017-2279": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2280": {"epss_score": 0.002, "epss_percentile": 0.42257}, "CVE-2017-2281": {"epss_score": 0.00251, "epss_percentile": 0.48329}, "CVE-2017-2282": {"epss_score": 0.00104, "epss_percentile": 0.29247}, "CVE-2017-2283": {"epss_score": 0.00218, "epss_percentile": 0.44409}, "CVE-2017-2284": {"epss_score": 0.0054, "epss_percentile": 0.67022}, "CVE-2017-2285": {"epss_score": 0.00534, "epss_percentile": 0.6678}, "CVE-2017-2286": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2287": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2288": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2017-2289": {"epss_score": 0.00324, "epss_percentile": 0.54946}, "CVE-2017-2290": {"epss_score": 0.00388, "epss_percentile": 0.59376}, "CVE-2017-2292": {"epss_score": 0.01932, "epss_percentile": 0.82942}, "CVE-2017-2293": {"epss_score": 0.00225, "epss_percentile": 0.45133}, "CVE-2017-2294": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2017-2295": {"epss_score": 0.02026, "epss_percentile": 0.83315}, "CVE-2017-2296": {"epss_score": 0.00353, "epss_percentile": 0.57179}, "CVE-2017-2297": {"epss_score": 0.00302, "epss_percentile": 0.53166}, "CVE-2017-2298": {"epss_score": 0.00271, "epss_percentile": 0.50289}, "CVE-2017-2299": {"epss_score": 0.00125, "epss_percentile": 0.3257}, "CVE-2017-2300": {"epss_score": 0.00539, "epss_percentile": 0.66962}, "CVE-2017-2301": {"epss_score": 0.01488, "epss_percentile": 0.80613}, "CVE-2017-2302": {"epss_score": 0.00808, "epss_percentile": 0.73685}, "CVE-2017-2303": {"epss_score": 0.00808, "epss_percentile": 0.73685}, "CVE-2017-2304": {"epss_score": 0.00961, "epss_percentile": 0.75974}, "CVE-2017-2305": {"epss_score": 0.00272, "epss_percentile": 0.5035}, "CVE-2017-2306": {"epss_score": 0.00615, "epss_percentile": 0.69297}, "CVE-2017-2307": {"epss_score": 0.00239, "epss_percentile": 0.46881}, "CVE-2017-2308": {"epss_score": 0.00276, "epss_percentile": 0.50735}, "CVE-2017-2309": {"epss_score": 0.00222, "epss_percentile": 0.44771}, "CVE-2017-2310": {"epss_score": 0.00166, "epss_percentile": 0.38163}, "CVE-2017-2311": {"epss_score": 0.00349, "epss_percentile": 0.56906}, "CVE-2017-2312": {"epss_score": 0.00446, "epss_percentile": 0.62894}, "CVE-2017-2313": {"epss_score": 0.00511, "epss_percentile": 0.65814}, "CVE-2017-2314": {"epss_score": 0.00451, "epss_percentile": 0.63118}, "CVE-2017-2315": {"epss_score": 0.0049, "epss_percentile": 0.64939}, "CVE-2017-2316": {"epss_score": 0.00057, "epss_percentile": 0.18089}, "CVE-2017-2317": {"epss_score": 0.00458, "epss_percentile": 0.63444}, "CVE-2017-2318": {"epss_score": 0.00296, "epss_percentile": 0.52559}, "CVE-2017-2319": {"epss_score": 0.00566, "epss_percentile": 0.67818}, "CVE-2017-2320": {"epss_score": 0.00488, "epss_percentile": 0.64846}, "CVE-2017-2321": {"epss_score": 0.00746, "epss_percentile": 0.72552}, "CVE-2017-2322": {"epss_score": 0.00058, "epss_percentile": 0.18359}, "CVE-2017-2323": {"epss_score": 0.00476, "epss_percentile": 0.64254}, "CVE-2017-2324": {"epss_score": 0.02441, "epss_percentile": 0.84755}, "CVE-2017-2325": {"epss_score": 0.00488, "epss_percentile": 0.64837}, "CVE-2017-2326": {"epss_score": 0.00282, "epss_percentile": 0.51272}, "CVE-2017-2327": {"epss_score": 0.00052, "epss_percentile": 0.16554}, "CVE-2017-2328": {"epss_score": 0.00052, "epss_percentile": 0.16475}, "CVE-2017-2329": {"epss_score": 0.00186, "epss_percentile": 0.40585}, "CVE-2017-2330": {"epss_score": 0.00049, "epss_percentile": 0.15618}, "CVE-2017-2331": {"epss_score": 0.00677, "epss_percentile": 0.70966}, "CVE-2017-2332": {"epss_score": 0.01088, "epss_percentile": 0.77437}, "CVE-2017-2333": {"epss_score": 0.00433, "epss_percentile": 0.62208}, "CVE-2017-2334": {"epss_score": 0.00274, "epss_percentile": 0.50578}, "CVE-2017-2335": {"epss_score": 0.00208, "epss_percentile": 0.43217}, "CVE-2017-2336": {"epss_score": 0.00327, "epss_percentile": 0.55094}, "CVE-2017-2337": {"epss_score": 0.00208, "epss_percentile": 0.43217}, "CVE-2017-2338": {"epss_score": 0.00208, "epss_percentile": 0.43217}, "CVE-2017-2339": {"epss_score": 0.00208, "epss_percentile": 0.43217}, "CVE-2017-2340": {"epss_score": 0.00411, "epss_percentile": 0.60904}, "CVE-2017-2341": {"epss_score": 0.00191, "epss_percentile": 0.41189}, "CVE-2017-2342": {"epss_score": 0.00108, "epss_percentile": 0.29837}, "CVE-2017-2343": {"epss_score": 0.03095, "epss_percentile": 0.86403}, "CVE-2017-2344": {"epss_score": 0.00058, "epss_percentile": 0.18409}, "CVE-2017-2345": {"epss_score": 0.04326, "epss_percentile": 0.88554}, "CVE-2017-2346": {"epss_score": 0.00267, "epss_percentile": 0.49988}, "CVE-2017-2347": {"epss_score": 0.00607, "epss_percentile": 0.69046}, "CVE-2017-2348": {"epss_score": 0.00451, "epss_percentile": 0.63118}, "CVE-2017-2349": {"epss_score": 0.03494, "epss_percentile": 0.87233}, "CVE-2017-2350": {"epss_score": 0.00522, "epss_percentile": 0.66278}, "CVE-2017-2351": {"epss_score": 0.00074, "epss_percentile": 0.22719}, "CVE-2017-2352": {"epss_score": 0.00073, "epss_percentile": 0.2253}, "CVE-2017-2353": {"epss_score": 0.01603, "epss_percentile": 0.8128}, "CVE-2017-2354": {"epss_score": 0.00615, "epss_percentile": 0.69298}, "CVE-2017-2355": {"epss_score": 0.00867, "epss_percentile": 0.74661}, "CVE-2017-2356": {"epss_score": 0.00615, "epss_percentile": 0.69298}, "CVE-2017-2357": {"epss_score": 0.00198, "epss_percentile": 0.42047}, "CVE-2017-2358": {"epss_score": 0.0017, "epss_percentile": 0.38754}, "CVE-2017-2359": {"epss_score": 0.00245, "epss_percentile": 0.47683}, "CVE-2017-2360": {"epss_score": 0.03244, "epss_percentile": 0.86741}, "CVE-2017-2361": {"epss_score": 0.06176, "epss_percentile": 0.90533}, "CVE-2017-2362": {"epss_score": 0.04875, "epss_percentile": 0.89238}, "CVE-2017-2363": {"epss_score": 0.21274, "epss_percentile": 0.95492}, "CVE-2017-2364": {"epss_score": 0.18057, "epss_percentile": 0.9495}, "CVE-2017-2365": {"epss_score": 0.19545, "epss_percentile": 0.95205}, "CVE-2017-2366": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2017-2367": {"epss_score": 0.12422, "epss_percentile": 0.93665}, "CVE-2017-2368": {"epss_score": 0.00233, "epss_percentile": 0.46036}, "CVE-2017-2369": {"epss_score": 0.04069, "epss_percentile": 0.88203}, "CVE-2017-2370": {"epss_score": 0.72581, "epss_percentile": 0.98717}, "CVE-2017-2371": {"epss_score": 0.06935, "epss_percentile": 0.91127}, "CVE-2017-2372": {"epss_score": 0.00836, "epss_percentile": 0.74132}, "CVE-2017-2373": {"epss_score": 0.05934, "epss_percentile": 0.9034}, "CVE-2017-2374": {"epss_score": 0.00617, "epss_percentile": 0.69357}, "CVE-2017-2375": {"epss_score": 0.00055, "epss_percentile": 0.17525}, "CVE-2017-2376": {"epss_score": 0.004, "epss_percentile": 0.60196}, "CVE-2017-2377": {"epss_score": 0.00604, "epss_percentile": 0.68967}, "CVE-2017-2378": {"epss_score": 0.00789, "epss_percentile": 0.73358}, "CVE-2017-2379": {"epss_score": 0.00905, "epss_percentile": 0.75238}, "CVE-2017-2380": {"epss_score": 0.00052, "epss_percentile": 0.16561}, "CVE-2017-2381": {"epss_score": 0.00868, "epss_percentile": 0.74681}, "CVE-2017-2382": {"epss_score": 0.00537, "epss_percentile": 0.66913}, "CVE-2017-2383": {"epss_score": 0.00145, "epss_percentile": 0.35407}, "CVE-2017-2384": {"epss_score": 0.00053, "epss_percentile": 0.16838}, "CVE-2017-2385": {"epss_score": 0.00063, "epss_percentile": 0.20073}, "CVE-2017-2386": {"epss_score": 0.00427, "epss_percentile": 0.61881}, "CVE-2017-2387": {"epss_score": 0.00174, "epss_percentile": 0.3914}, "CVE-2017-2388": {"epss_score": 0.04205, "epss_percentile": 0.88395}, "CVE-2017-2389": {"epss_score": 0.00955, "epss_percentile": 0.7592}, "CVE-2017-2390": {"epss_score": 0.00086, "epss_percentile": 0.25331}, "CVE-2017-2391": {"epss_score": 0.00116, "epss_percentile": 0.31171}, "CVE-2017-2392": {"epss_score": 0.00325, "epss_percentile": 0.55011}, "CVE-2017-2393": {"epss_score": 0.00263, "epss_percentile": 0.4952}, "CVE-2017-2394": {"epss_score": 0.00969, "epss_percentile": 0.76103}, "CVE-2017-2395": {"epss_score": 0.00969, "epss_percentile": 0.76103}, "CVE-2017-2396": {"epss_score": 0.00969, "epss_percentile": 0.76103}, "CVE-2017-2397": {"epss_score": 0.00073, "epss_percentile": 0.22617}, "CVE-2017-2398": {"epss_score": 0.00161, "epss_percentile": 0.37568}, "CVE-2017-2399": {"epss_score": 0.0002, "epss_percentile": 0.0468}, "CVE-2017-2400": {"epss_score": 0.00247, "epss_percentile": 0.47841}, "CVE-2017-2401": {"epss_score": 0.0042, "epss_percentile": 0.61406}, "CVE-2017-2402": {"epss_score": 0.0025, "epss_percentile": 0.48095}, "CVE-2017-2403": {"epss_score": 0.01005, "epss_percentile": 0.76537}, "CVE-2017-2404": {"epss_score": 0.01094, "epss_percentile": 0.7749}, "CVE-2017-2405": {"epss_score": 0.00739, "epss_percentile": 0.72396}, "CVE-2017-2406": {"epss_score": 0.00585, "epss_percentile": 0.68431}, "CVE-2017-2407": {"epss_score": 0.00585, "epss_percentile": 0.68431}, "CVE-2017-2408": {"epss_score": 0.0017, "epss_percentile": 0.38754}, "CVE-2017-2409": {"epss_score": 0.002, "epss_percentile": 0.42234}, "CVE-2017-2410": {"epss_score": 0.00182, "epss_percentile": 0.40207}, "CVE-2017-2411": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2017-2412": {"epss_score": 0.00122, "epss_percentile": 0.32115}, "CVE-2017-2413": {"epss_score": 0.00532, "epss_percentile": 0.66696}, "CVE-2017-2414": {"epss_score": 0.00326, "epss_percentile": 0.55083}, "CVE-2017-2415": {"epss_score": 0.01156, "epss_percentile": 0.78098}, "CVE-2017-2416": {"epss_score": 0.00794, "epss_percentile": 0.73452}, "CVE-2017-2417": {"epss_score": 0.00554, "epss_percentile": 0.67433}, "CVE-2017-2418": {"epss_score": 0.00074, "epss_percentile": 0.22822}, "CVE-2017-2419": {"epss_score": 0.00602, "epss_percentile": 0.68892}, "CVE-2017-2420": {"epss_score": 0.0017, "epss_percentile": 0.38754}, "CVE-2017-2421": {"epss_score": 0.00142, "epss_percentile": 0.35005}, "CVE-2017-2422": {"epss_score": 0.0017, "epss_percentile": 0.38754}, "CVE-2017-2423": {"epss_score": 0.00292, "epss_percentile": 0.52234}, "CVE-2017-2424": {"epss_score": 0.00388, "epss_percentile": 0.59343}, "CVE-2017-2425": {"epss_score": 0.0032, "epss_percentile": 0.54629}, "CVE-2017-2426": {"epss_score": 0.00257, "epss_percentile": 0.4885}, "CVE-2017-2427": {"epss_score": 0.0017, "epss_percentile": 0.38754}, "CVE-2017-2428": {"epss_score": 0.00733, "epss_percentile": 0.72204}, "CVE-2017-2429": {"epss_score": 0.00418, "epss_percentile": 0.61291}, "CVE-2017-2430": {"epss_score": 0.00794, "epss_percentile": 0.73452}, "CVE-2017-2431": {"epss_score": 0.00532, "epss_percentile": 0.66696}, "CVE-2017-2432": {"epss_score": 0.00905, "epss_percentile": 0.75244}, "CVE-2017-2433": {"epss_score": 0.00739, "epss_percentile": 0.72396}, "CVE-2017-2434": {"epss_score": 0.00576, "epss_percentile": 0.68137}, "CVE-2017-2435": {"epss_score": 0.00761, "epss_percentile": 0.72826}, "CVE-2017-2436": {"epss_score": 0.0017, "epss_percentile": 0.38754}, "CVE-2017-2437": {"epss_score": 0.00052, "epss_percentile": 0.16376}, "CVE-2017-2438": {"epss_score": 0.003, "epss_percentile": 0.52949}, "CVE-2017-2439": {"epss_score": 0.00614, "epss_percentile": 0.69278}, "CVE-2017-2440": {"epss_score": 0.00421, "epss_percentile": 0.61466}, "CVE-2017-2441": {"epss_score": 0.02747, "epss_percentile": 0.85575}, "CVE-2017-2442": {"epss_score": 0.12422, "epss_percentile": 0.93665}, "CVE-2017-2443": {"epss_score": 0.01118, "epss_percentile": 0.77745}, "CVE-2017-2444": {"epss_score": 0.0083, "epss_percentile": 0.74019}, "CVE-2017-2445": {"epss_score": 0.01127, "epss_percentile": 0.77823}, "CVE-2017-2446": {"epss_score": 0.25094, "epss_percentile": 0.95984}, "CVE-2017-2447": {"epss_score": 0.09604, "epss_percentile": 0.92617}, "CVE-2017-2448": {"epss_score": 0.00682, "epss_percentile": 0.71073}, "CVE-2017-2449": {"epss_score": 0.003, "epss_percentile": 0.52949}, "CVE-2017-2450": {"epss_score": 0.00614, "epss_percentile": 0.69278}, "CVE-2017-2451": {"epss_score": 0.00456, "epss_percentile": 0.63328}, "CVE-2017-2452": {"epss_score": 0.00078, "epss_percentile": 0.23684}, "CVE-2017-2453": {"epss_score": 0.00367, "epss_percentile": 0.58136}, "CVE-2017-2454": {"epss_score": 0.04294, "epss_percentile": 0.88506}, "CVE-2017-2455": {"epss_score": 0.04294, "epss_percentile": 0.88506}, "CVE-2017-2456": {"epss_score": 0.06162, "epss_percentile": 0.90526}, "CVE-2017-2457": {"epss_score": 0.02526, "epss_percentile": 0.85012}, "CVE-2017-2458": {"epss_score": 0.00648, "epss_percentile": 0.70222}, "CVE-2017-2459": {"epss_score": 0.04294, "epss_percentile": 0.88506}, "CVE-2017-2460": {"epss_score": 0.04408, "epss_percentile": 0.88653}, "CVE-2017-2461": {"epss_score": 0.02076, "epss_percentile": 0.83507}, "CVE-2017-2462": {"epss_score": 0.00815, "epss_percentile": 0.73786}, "CVE-2017-2463": {"epss_score": 0.00447, "epss_percentile": 0.62939}, "CVE-2017-2464": {"epss_score": 0.09024, "epss_percentile": 0.92372}, "CVE-2017-2465": {"epss_score": 0.00969, "epss_percentile": 0.76103}, "CVE-2017-2466": {"epss_score": 0.03715, "epss_percentile": 0.87612}, "CVE-2017-2467": {"epss_score": 0.00794, "epss_percentile": 0.73452}, "CVE-2017-2468": {"epss_score": 0.04752, "epss_percentile": 0.89104}, "CVE-2017-2469": {"epss_score": 0.02682, "epss_percentile": 0.8542}, "CVE-2017-2470": {"epss_score": 0.02682, "epss_percentile": 0.8542}, "CVE-2017-2471": {"epss_score": 0.23334, "epss_percentile": 0.95767}, "CVE-2017-2472": {"epss_score": 0.05388, "epss_percentile": 0.89822}, "CVE-2017-2473": {"epss_score": 0.04697, "epss_percentile": 0.89021}, "CVE-2017-2474": {"epss_score": 0.05538, "epss_percentile": 0.89975}, "CVE-2017-2475": {"epss_score": 0.00601, "epss_percentile": 0.68853}, "CVE-2017-2476": {"epss_score": 0.05257, "epss_percentile": 0.89667}, "CVE-2017-2477": {"epss_score": 0.00829, "epss_percentile": 0.74014}, "CVE-2017-2478": {"epss_score": 0.03911, "epss_percentile": 0.87934}, "CVE-2017-2479": {"epss_score": 0.08813, "epss_percentile": 0.92267}, "CVE-2017-2480": {"epss_score": 0.19072, "epss_percentile": 0.95124}, "CVE-2017-2481": {"epss_score": 0.00781, "epss_percentile": 0.7319}, "CVE-2017-2482": {"epss_score": 0.05787, "epss_percentile": 0.90208}, "CVE-2017-2483": {"epss_score": 0.05787, "epss_percentile": 0.90208}, "CVE-2017-2484": {"epss_score": 0.00263, "epss_percentile": 0.49523}, "CVE-2017-2485": {"epss_score": 0.02581, "epss_percentile": 0.85155}, "CVE-2017-2486": {"epss_score": 0.00356, "epss_percentile": 0.57387}, "CVE-2017-2487": {"epss_score": 0.00761, "epss_percentile": 0.72826}, "CVE-2017-2488": {"epss_score": 0.0014, "epss_percentile": 0.34777}, "CVE-2017-2489": {"epss_score": 0.01649, "epss_percentile": 0.81558}, "CVE-2017-2490": {"epss_score": 0.04697, "epss_percentile": 0.89021}, "CVE-2017-2491": {"epss_score": 0.21689, "epss_percentile": 0.95548}, "CVE-2017-2492": {"epss_score": 0.00312, "epss_percentile": 0.53992}, "CVE-2017-2493": {"epss_score": 0.00267, "epss_percentile": 0.49968}, "CVE-2017-2494": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2017-2495": {"epss_score": 0.00466, "epss_percentile": 0.63795}, "CVE-2017-2496": {"epss_score": 0.008, "epss_percentile": 0.73542}, "CVE-2017-2497": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2017-2498": {"epss_score": 0.00115, "epss_percentile": 0.30883}, "CVE-2017-2499": {"epss_score": 0.00262, "epss_percentile": 0.49378}, "CVE-2017-2500": {"epss_score": 0.00217, "epss_percentile": 0.44296}, "CVE-2017-2501": {"epss_score": 0.02057, "epss_percentile": 0.83428}, "CVE-2017-2502": {"epss_score": 0.00265, "epss_percentile": 0.49794}, "CVE-2017-2503": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2017-2504": {"epss_score": 0.00793, "epss_percentile": 0.73419}, "CVE-2017-2505": {"epss_score": 0.00958, "epss_percentile": 0.75946}, "CVE-2017-2506": {"epss_score": 0.00853, "epss_percentile": 0.74428}, "CVE-2017-2507": {"epss_score": 0.00265, "epss_percentile": 0.49794}, "CVE-2017-2508": {"epss_score": 0.0104, "epss_percentile": 0.76953}, "CVE-2017-2509": {"epss_score": 0.01649, "epss_percentile": 0.81558}, "CVE-2017-2510": {"epss_score": 0.01206, "epss_percentile": 0.78523}, "CVE-2017-2511": {"epss_score": 0.00217, "epss_percentile": 0.44296}, "CVE-2017-2512": {"epss_score": 0.00239, "epss_percentile": 0.46908}, "CVE-2017-2513": {"epss_score": 0.01982, "epss_percentile": 0.83139}, "CVE-2017-2514": {"epss_score": 0.03551, "epss_percentile": 0.87342}, "CVE-2017-2515": {"epss_score": 0.04118, "epss_percentile": 0.88279}, "CVE-2017-2516": {"epss_score": 0.01566, "epss_percentile": 0.8107}, "CVE-2017-2517": {"epss_score": 0.00527, "epss_percentile": 0.66467}, "CVE-2017-2518": {"epss_score": 0.18544, "epss_percentile": 0.95031}, "CVE-2017-2519": {"epss_score": 0.09633, "epss_percentile": 0.92633}, "CVE-2017-2520": {"epss_score": 0.08101, "epss_percentile": 0.91879}, "CVE-2017-2521": {"epss_score": 0.05746, "epss_percentile": 0.90174}, "CVE-2017-2522": {"epss_score": 0.13046, "epss_percentile": 0.93857}, "CVE-2017-2523": {"epss_score": 0.13046, "epss_percentile": 0.93857}, "CVE-2017-2524": {"epss_score": 0.17644, "epss_percentile": 0.94883}, "CVE-2017-2525": {"epss_score": 0.00892, "epss_percentile": 0.75063}, "CVE-2017-2526": {"epss_score": 0.00752, "epss_percentile": 0.72665}, "CVE-2017-2527": {"epss_score": 0.09359, "epss_percentile": 0.92515}, "CVE-2017-2528": {"epss_score": 0.01328, "epss_percentile": 0.79501}, "CVE-2017-2530": {"epss_score": 0.00658, "epss_percentile": 0.7049}, "CVE-2017-2531": {"epss_score": 0.06379, "epss_percentile": 0.9071}, "CVE-2017-2533": {"epss_score": 0.01866, "epss_percentile": 0.82609}, "CVE-2017-2534": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2017-2535": {"epss_score": 0.00203, "epss_percentile": 0.4255}, "CVE-2017-2536": {"epss_score": 0.1003, "epss_percentile": 0.92821}, "CVE-2017-2537": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2017-2538": {"epss_score": 0.00706, "epss_percentile": 0.7161}, "CVE-2017-2539": {"epss_score": 0.008, "epss_percentile": 0.73542}, "CVE-2017-2540": {"epss_score": 0.00342, "epss_percentile": 0.56379}, "CVE-2017-2541": {"epss_score": 0.00402, "epss_percentile": 0.60293}, "CVE-2017-2542": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2017-2543": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2017-2544": {"epss_score": 0.00979, "epss_percentile": 0.76263}, "CVE-2017-2545": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2017-2546": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2017-2547": {"epss_score": 0.56117, "epss_percentile": 0.98008}, "CVE-2017-2548": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2017-2549": {"epss_score": 0.00429, "epss_percentile": 0.61972}, "CVE-2017-2550": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2017-2551": {"epss_score": 0.00583, "epss_percentile": 0.68338}, "CVE-2017-2575": {"epss_score": 0.00556, "epss_percentile": 0.67532}, "CVE-2017-2576": {"epss_score": 0.00289, "epss_percentile": 0.5201}, "CVE-2017-2578": {"epss_score": 0.00264, "epss_percentile": 0.49739}, "CVE-2017-2579": {"epss_score": 0.00443, "epss_percentile": 0.62802}, "CVE-2017-2580": {"epss_score": 0.0029, "epss_percentile": 0.52114}, "CVE-2017-2581": {"epss_score": 0.00264, "epss_percentile": 0.4975}, "CVE-2017-2582": {"epss_score": 0.00663, "epss_percentile": 0.70618}, "CVE-2017-2583": {"epss_score": 0.00059, "epss_percentile": 0.18734}, "CVE-2017-2584": {"epss_score": 0.00087, "epss_percentile": 0.25591}, "CVE-2017-2585": {"epss_score": 0.00671, "epss_percentile": 0.70806}, "CVE-2017-2586": {"epss_score": 0.00116, "epss_percentile": 0.31131}, "CVE-2017-2587": {"epss_score": 0.00135, "epss_percentile": 0.33998}, "CVE-2017-2589": {"epss_score": 0.00175, "epss_percentile": 0.3937}, "CVE-2017-2590": {"epss_score": 0.00177, "epss_percentile": 0.39541}, "CVE-2017-2591": {"epss_score": 0.06828, "epss_percentile": 0.91053}, "CVE-2017-2592": {"epss_score": 0.00093, "epss_percentile": 0.26674}, "CVE-2017-2594": {"epss_score": 0.01968, "epss_percentile": 0.83087}, "CVE-2017-2595": {"epss_score": 0.01165, "epss_percentile": 0.78172}, "CVE-2017-2596": {"epss_score": 0.00049, "epss_percentile": 0.15542}, "CVE-2017-2598": {"epss_score": 0.00059, "epss_percentile": 0.1886}, "CVE-2017-2599": {"epss_score": 0.00164, "epss_percentile": 0.3797}, "CVE-2017-2600": {"epss_score": 0.00034, "epss_percentile": 0.09752}, "CVE-2017-2601": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2017-2602": {"epss_score": 0.00165, "epss_percentile": 0.38058}, "CVE-2017-2603": {"epss_score": 0.00023, "epss_percentile": 0.05603}, "CVE-2017-2604": {"epss_score": 0.00087, "epss_percentile": 0.25575}, "CVE-2017-2606": {"epss_score": 0.00081, "epss_percentile": 0.24303}, "CVE-2017-2607": {"epss_score": 0.00047, "epss_percentile": 0.14887}, "CVE-2017-2608": {"epss_score": 0.02976, "epss_percentile": 0.86106}, "CVE-2017-2609": {"epss_score": 0.00084, "epss_percentile": 0.24966}, "CVE-2017-2610": {"epss_score": 0.00061, "epss_percentile": 0.19533}, "CVE-2017-2611": {"epss_score": 0.00293, "epss_percentile": 0.52297}, "CVE-2017-2612": {"epss_score": 0.00119, "epss_percentile": 0.31665}, "CVE-2017-2613": {"epss_score": 0.0006, "epss_percentile": 0.19076}, "CVE-2017-2614": {"epss_score": 0.00035, "epss_percentile": 0.09845}, "CVE-2017-2615": {"epss_score": 0.01064, "epss_percentile": 0.77198}, "CVE-2017-2616": {"epss_score": 0.00062, "epss_percentile": 0.19608}, "CVE-2017-2617": {"epss_score": 0.007, "epss_percentile": 0.71484}, "CVE-2017-2618": {"epss_score": 0.0005, "epss_percentile": 0.15951}, "CVE-2017-2619": {"epss_score": 0.22627, "epss_percentile": 0.9566}, "CVE-2017-2620": {"epss_score": 0.02536, "epss_percentile": 0.85037}, "CVE-2017-2621": {"epss_score": 0.00072, "epss_percentile": 0.2238}, "CVE-2017-2622": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2017-2623": {"epss_score": 0.00263, "epss_percentile": 0.49507}, "CVE-2017-2624": {"epss_score": 0.0011, "epss_percentile": 0.30085}, "CVE-2017-2625": {"epss_score": 0.00077, "epss_percentile": 0.23375}, "CVE-2017-2626": {"epss_score": 0.00098, "epss_percentile": 0.27676}, "CVE-2017-2627": {"epss_score": 0.00074, "epss_percentile": 0.22791}, "CVE-2017-2628": {"epss_score": 0.00831, "epss_percentile": 0.74045}, "CVE-2017-2629": {"epss_score": 0.00363, "epss_percentile": 0.57847}, "CVE-2017-2630": {"epss_score": 0.01194, "epss_percentile": 0.78422}, "CVE-2017-2632": {"epss_score": 0.00382, "epss_percentile": 0.59061}, "CVE-2017-2633": {"epss_score": 0.00558, "epss_percentile": 0.67593}, "CVE-2017-2634": {"epss_score": 0.03662, "epss_percentile": 0.87529}, "CVE-2017-2635": {"epss_score": 0.00322, "epss_percentile": 0.54799}, "CVE-2017-2636": {"epss_score": 0.00547, "epss_percentile": 0.67264}, "CVE-2017-2637": {"epss_score": 0.00415, "epss_percentile": 0.61117}, "CVE-2017-2638": {"epss_score": 0.00495, "epss_percentile": 0.65111}, "CVE-2017-2639": {"epss_score": 0.00496, "epss_percentile": 0.65169}, "CVE-2017-2640": {"epss_score": 0.01003, "epss_percentile": 0.76518}, "CVE-2017-2641": {"epss_score": 0.01895, "epss_percentile": 0.82746}, "CVE-2017-2642": {"epss_score": 0.00262, "epss_percentile": 0.49345}, "CVE-2017-2643": {"epss_score": 0.00762, "epss_percentile": 0.72847}, "CVE-2017-2644": {"epss_score": 0.00306, "epss_percentile": 0.53404}, "CVE-2017-2645": {"epss_score": 0.00306, "epss_percentile": 0.53404}, "CVE-2017-2646": {"epss_score": 0.00503, "epss_percentile": 0.65446}, "CVE-2017-2647": {"epss_score": 0.00041, "epss_percentile": 0.12401}, "CVE-2017-2648": {"epss_score": 0.00034, "epss_percentile": 0.09728}, "CVE-2017-2649": {"epss_score": 0.00052, "epss_percentile": 0.16447}, "CVE-2017-2650": {"epss_score": 0.00121, "epss_percentile": 0.31819}, "CVE-2017-2651": {"epss_score": 0.00032, "epss_percentile": 0.08989}, "CVE-2017-2652": {"epss_score": 0.00363, "epss_percentile": 0.57825}, "CVE-2017-2653": {"epss_score": 0.00213, "epss_percentile": 0.43901}, "CVE-2017-2654": {"epss_score": 0.00058, "epss_percentile": 0.18518}, "CVE-2017-2658": {"epss_score": 0.00302, "epss_percentile": 0.53093}, "CVE-2017-2659": {"epss_score": 0.00275, "epss_percentile": 0.50686}, "CVE-2017-2661": {"epss_score": 0.00397, "epss_percentile": 0.59965}, "CVE-2017-2662": {"epss_score": 0.00115, "epss_percentile": 0.30957}, "CVE-2017-2663": {"epss_score": 0.00125, "epss_percentile": 0.32485}, "CVE-2017-2664": {"epss_score": 0.0022, "epss_percentile": 0.44591}, "CVE-2017-2665": {"epss_score": 0.00041, "epss_percentile": 0.12444}, "CVE-2017-2666": {"epss_score": 0.02223, "epss_percentile": 0.84065}, "CVE-2017-2667": {"epss_score": 0.00152, "epss_percentile": 0.364}, "CVE-2017-2668": {"epss_score": 0.07615, "epss_percentile": 0.91569}, "CVE-2017-2669": {"epss_score": 0.06874, "epss_percentile": 0.91086}, "CVE-2017-2670": {"epss_score": 0.05972, "epss_percentile": 0.90373}, "CVE-2017-2671": {"epss_score": 0.00252, "epss_percentile": 0.48389}, "CVE-2017-2672": {"epss_score": 0.00175, "epss_percentile": 0.39268}, "CVE-2017-2673": {"epss_score": 0.00602, "epss_percentile": 0.68895}, "CVE-2017-2674": {"epss_score": 0.00179, "epss_percentile": 0.39794}, "CVE-2017-2675": {"epss_score": 0.0005, "epss_percentile": 0.15965}, "CVE-2017-2680": {"epss_score": 0.02335, "epss_percentile": 0.84413}, "CVE-2017-2681": {"epss_score": 0.00442, "epss_percentile": 0.62736}, "CVE-2017-2682": {"epss_score": 0.00207, "epss_percentile": 0.43082}, "CVE-2017-2683": {"epss_score": 0.00297, "epss_percentile": 0.52756}, "CVE-2017-2684": {"epss_score": 0.01711, "epss_percentile": 0.81882}, "CVE-2017-2685": {"epss_score": 0.0024, "epss_percentile": 0.46959}, "CVE-2017-2686": {"epss_score": 0.00205, "epss_percentile": 0.42671}, "CVE-2017-2687": {"epss_score": 0.00317, "epss_percentile": 0.54394}, "CVE-2017-2688": {"epss_score": 0.00185, "epss_percentile": 0.40553}, "CVE-2017-2689": {"epss_score": 0.00532, "epss_percentile": 0.66677}, "CVE-2017-2690": {"epss_score": 0.00024, "epss_percentile": 0.06034}, "CVE-2017-2691": {"epss_score": 0.00041, "epss_percentile": 0.12392}, "CVE-2017-2692": {"epss_score": 0.00192, "epss_percentile": 0.41352}, "CVE-2017-2693": {"epss_score": 0.00238, "epss_percentile": 0.46819}, "CVE-2017-2694": {"epss_score": 0.0007, "epss_percentile": 0.21958}, "CVE-2017-2695": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2017-2696": {"epss_score": 0.00073, "epss_percentile": 0.22645}, "CVE-2017-2697": {"epss_score": 0.00073, "epss_percentile": 0.22645}, "CVE-2017-2698": {"epss_score": 0.00058, "epss_percentile": 0.1852}, "CVE-2017-2699": {"epss_score": 0.0016, "epss_percentile": 0.3743}, "CVE-2017-2700": {"epss_score": 0.00219, "epss_percentile": 0.44493}, "CVE-2017-2701": {"epss_score": 0.00039, "epss_percentile": 0.11548}, "CVE-2017-2702": {"epss_score": 0.00018, "epss_percentile": 0.04027}, "CVE-2017-2703": {"epss_score": 0.00021, "epss_percentile": 0.04859}, "CVE-2017-2704": {"epss_score": 0.00077, "epss_percentile": 0.2337}, "CVE-2017-2705": {"epss_score": 0.00047, "epss_percentile": 0.14653}, "CVE-2017-2706": {"epss_score": 0.00097, "epss_percentile": 0.27578}, "CVE-2017-2707": {"epss_score": 0.00036, "epss_percentile": 0.10314}, "CVE-2017-2708": {"epss_score": 0.00192, "epss_percentile": 0.41372}, "CVE-2017-2709": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2017-2710": {"epss_score": 0.00026, "epss_percentile": 0.06595}, "CVE-2017-2711": {"epss_score": 0.00061, "epss_percentile": 0.19447}, "CVE-2017-2712": {"epss_score": 0.0017, "epss_percentile": 0.38686}, "CVE-2017-2713": {"epss_score": 0.00034, "epss_percentile": 0.0967}, "CVE-2017-2714": {"epss_score": 0.00057, "epss_percentile": 0.18044}, "CVE-2017-2715": {"epss_score": 0.00029, "epss_percentile": 0.07679}, "CVE-2017-2716": {"epss_score": 0.00073, "epss_percentile": 0.22645}, "CVE-2017-2717": {"epss_score": 0.0005, "epss_percentile": 0.15778}, "CVE-2017-2718": {"epss_score": 0.00445, "epss_percentile": 0.62878}, "CVE-2017-2719": {"epss_score": 0.00445, "epss_percentile": 0.62878}, "CVE-2017-2720": {"epss_score": 0.00095, "epss_percentile": 0.27114}, "CVE-2017-2721": {"epss_score": 0.0002, "epss_percentile": 0.04675}, "CVE-2017-2722": {"epss_score": 0.00477, "epss_percentile": 0.64306}, "CVE-2017-2723": {"epss_score": 0.00012, "epss_percentile": 0.0124}, "CVE-2017-2724": {"epss_score": 0.00185, "epss_percentile": 0.40575}, "CVE-2017-2725": {"epss_score": 0.0017, "epss_percentile": 0.38679}, "CVE-2017-2726": {"epss_score": 0.00185, "epss_percentile": 0.40575}, "CVE-2017-2727": {"epss_score": 0.0003, "epss_percentile": 0.0828}, "CVE-2017-2728": {"epss_score": 0.00025, "epss_percentile": 0.06281}, "CVE-2017-2729": {"epss_score": 0.0017, "epss_percentile": 0.38679}, "CVE-2017-2730": {"epss_score": 0.00037, "epss_percentile": 0.10867}, "CVE-2017-2731": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2017-2732": {"epss_score": 0.00088, "epss_percentile": 0.25786}, "CVE-2017-2733": {"epss_score": 0.00092, "epss_percentile": 0.26535}, "CVE-2017-2734": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2017-2735": {"epss_score": 0.00068, "epss_percentile": 0.21241}, "CVE-2017-2736": {"epss_score": 0.01056, "epss_percentile": 0.77127}, "CVE-2017-2737": {"epss_score": 0.00247, "epss_percentile": 0.47844}, "CVE-2017-2738": {"epss_score": 0.0125, "epss_percentile": 0.7888}, "CVE-2017-2739": {"epss_score": 0.00021, "epss_percentile": 0.04889}, "CVE-2017-2740": {"epss_score": 0.00057, "epss_percentile": 0.18194}, "CVE-2017-2741": {"epss_score": 0.86027, "epss_percentile": 0.99363}, "CVE-2017-2742": {"epss_score": 0.00899, "epss_percentile": 0.75154}, "CVE-2017-2743": {"epss_score": 0.004, "epss_percentile": 0.60168}, "CVE-2017-2744": {"epss_score": 0.00165, "epss_percentile": 0.38083}, "CVE-2017-2745": {"epss_score": 0.00453, "epss_percentile": 0.63233}, "CVE-2017-2746": {"epss_score": 0.00453, "epss_percentile": 0.63233}, "CVE-2017-2747": {"epss_score": 0.00141, "epss_percentile": 0.34824}, "CVE-2017-2748": {"epss_score": 0.01035, "epss_percentile": 0.76898}, "CVE-2017-2750": {"epss_score": 0.1402, "epss_percentile": 0.94115}, "CVE-2017-2751": {"epss_score": 0.04384, "epss_percentile": 0.88629}, "CVE-2017-2752": {"epss_score": 0.0011, "epss_percentile": 0.30108}, "CVE-2017-2765": {"epss_score": 0.00139, "epss_percentile": 0.34607}, "CVE-2017-2766": {"epss_score": 0.00786, "epss_percentile": 0.73269}, "CVE-2017-2767": {"epss_score": 0.10752, "epss_percentile": 0.93094}, "CVE-2017-2768": {"epss_score": 0.02709, "epss_percentile": 0.85481}, "CVE-2017-2773": {"epss_score": 0.00687, "epss_percentile": 0.71183}, "CVE-2017-2775": {"epss_score": 0.0064, "epss_percentile": 0.69973}, "CVE-2017-2777": {"epss_score": 0.0026, "epss_percentile": 0.49173}, "CVE-2017-2779": {"epss_score": 0.00616, "epss_percentile": 0.69316}, "CVE-2017-2780": {"epss_score": 0.05523, "epss_percentile": 0.8996}, "CVE-2017-2781": {"epss_score": 0.04579, "epss_percentile": 0.88871}, "CVE-2017-2782": {"epss_score": 0.00241, "epss_percentile": 0.47331}, "CVE-2017-2783": {"epss_score": 0.00611, "epss_percentile": 0.69195}, "CVE-2017-2784": {"epss_score": 0.03121, "epss_percentile": 0.86451}, "CVE-2017-2785": {"epss_score": 0.19363, "epss_percentile": 0.95169}, "CVE-2017-2786": {"epss_score": 0.01857, "epss_percentile": 0.82575}, "CVE-2017-2787": {"epss_score": 0.12955, "epss_percentile": 0.9383}, "CVE-2017-2788": {"epss_score": 0.23582, "epss_percentile": 0.95794}, "CVE-2017-2789": {"epss_score": 0.0149, "epss_percentile": 0.80631}, "CVE-2017-2790": {"epss_score": 0.0149, "epss_percentile": 0.80631}, "CVE-2017-2791": {"epss_score": 0.00382, "epss_percentile": 0.59033}, "CVE-2017-2792": {"epss_score": 0.00654, "epss_percentile": 0.70354}, "CVE-2017-2793": {"epss_score": 0.01006, "epss_percentile": 0.76556}, "CVE-2017-2794": {"epss_score": 0.01024, "epss_percentile": 0.76783}, "CVE-2017-2795": {"epss_score": 0.00492, "epss_percentile": 0.65016}, "CVE-2017-2797": {"epss_score": 0.00265, "epss_percentile": 0.49798}, "CVE-2017-2798": {"epss_score": 0.00611, "epss_percentile": 0.69195}, "CVE-2017-2799": {"epss_score": 0.00611, "epss_percentile": 0.69195}, "CVE-2017-2800": {"epss_score": 0.1419, "epss_percentile": 0.94159}, "CVE-2017-2801": {"epss_score": 0.00295, "epss_percentile": 0.52452}, "CVE-2017-2802": {"epss_score": 0.00218, "epss_percentile": 0.4434}, "CVE-2017-2803": {"epss_score": 0.00172, "epss_percentile": 0.38978}, "CVE-2017-2804": {"epss_score": 0.00172, "epss_percentile": 0.38978}, "CVE-2017-2805": {"epss_score": 0.03826, "epss_percentile": 0.87793}, "CVE-2017-2806": {"epss_score": 0.00164, "epss_percentile": 0.37908}, "CVE-2017-2807": {"epss_score": 0.00654, "epss_percentile": 0.70342}, "CVE-2017-2808": {"epss_score": 0.00493, "epss_percentile": 0.65028}, "CVE-2017-2809": {"epss_score": 0.00664, "epss_percentile": 0.70632}, "CVE-2017-2810": {"epss_score": 0.0328, "epss_percentile": 0.86813}, "CVE-2017-2811": {"epss_score": 0.00264, "epss_percentile": 0.49697}, "CVE-2017-2812": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2017-2813": {"epss_score": 0.00369, "epss_percentile": 0.58265}, "CVE-2017-2814": {"epss_score": 0.03345, "epss_percentile": 0.86951}, "CVE-2017-2815": {"epss_score": 0.00333, "epss_percentile": 0.55682}, "CVE-2017-2816": {"epss_score": 0.00747, "epss_percentile": 0.72562}, "CVE-2017-2817": {"epss_score": 0.00771, "epss_percentile": 0.73022}, "CVE-2017-2818": {"epss_score": 0.01018, "epss_percentile": 0.76707}, "CVE-2017-2819": {"epss_score": 0.0064, "epss_percentile": 0.69976}, "CVE-2017-2820": {"epss_score": 0.01212, "epss_percentile": 0.78557}, "CVE-2017-2821": {"epss_score": 0.01683, "epss_percentile": 0.81739}, "CVE-2017-2822": {"epss_score": 0.01117, "epss_percentile": 0.7774}, "CVE-2017-2823": {"epss_score": 0.00745, "epss_percentile": 0.72519}, "CVE-2017-2824": {"epss_score": 0.73548, "epss_percentile": 0.98761}, "CVE-2017-2825": {"epss_score": 0.00626, "epss_percentile": 0.69614}, "CVE-2017-2826": {"epss_score": 0.00262, "epss_percentile": 0.49396}, "CVE-2017-2827": {"epss_score": 0.02244, "epss_percentile": 0.84125}, "CVE-2017-2828": {"epss_score": 0.02244, "epss_percentile": 0.84125}, "CVE-2017-2829": {"epss_score": 0.05373, "epss_percentile": 0.89795}, "CVE-2017-2830": {"epss_score": 0.01, "epss_percentile": 0.76491}, "CVE-2017-2831": {"epss_score": 0.011, "epss_percentile": 0.77571}, "CVE-2017-2832": {"epss_score": 0.01986, "epss_percentile": 0.83157}, "CVE-2017-2833": {"epss_score": 0.01035, "epss_percentile": 0.76899}, "CVE-2017-2834": {"epss_score": 0.01071, "epss_percentile": 0.77262}, "CVE-2017-2835": {"epss_score": 0.00681, "epss_percentile": 0.71039}, "CVE-2017-2836": {"epss_score": 0.00297, "epss_percentile": 0.52686}, "CVE-2017-2837": {"epss_score": 0.00622, "epss_percentile": 0.69503}, "CVE-2017-2838": {"epss_score": 0.00622, "epss_percentile": 0.69503}, "CVE-2017-2839": {"epss_score": 0.00622, "epss_percentile": 0.69503}, "CVE-2017-2840": {"epss_score": 0.01161, "epss_percentile": 0.78144}, "CVE-2017-2841": {"epss_score": 0.0123, "epss_percentile": 0.78726}, "CVE-2017-2842": {"epss_score": 0.00549, "epss_percentile": 0.67318}, "CVE-2017-2843": {"epss_score": 0.00601, "epss_percentile": 0.68839}, "CVE-2017-2844": {"epss_score": 0.00549, "epss_percentile": 0.67318}, "CVE-2017-2845": {"epss_score": 0.0123, "epss_percentile": 0.78726}, "CVE-2017-2846": {"epss_score": 0.02198, "epss_percentile": 0.83966}, "CVE-2017-2847": {"epss_score": 0.02198, "epss_percentile": 0.83966}, "CVE-2017-2848": {"epss_score": 0.02654, "epss_percentile": 0.85353}, "CVE-2017-2849": {"epss_score": 0.02198, "epss_percentile": 0.83966}, "CVE-2017-2850": {"epss_score": 0.00319, "epss_percentile": 0.54482}, "CVE-2017-2851": {"epss_score": 0.00292, "epss_percentile": 0.52263}, "CVE-2017-2852": {"epss_score": 0.00415, "epss_percentile": 0.61145}, "CVE-2017-2853": {"epss_score": 0.0177, "epss_percentile": 0.82192}, "CVE-2017-2854": {"epss_score": 0.00422, "epss_percentile": 0.61547}, "CVE-2017-2855": {"epss_score": 0.00422, "epss_percentile": 0.61547}, "CVE-2017-2856": {"epss_score": 0.00422, "epss_percentile": 0.61547}, "CVE-2017-2857": {"epss_score": 0.00422, "epss_percentile": 0.61547}, "CVE-2017-2858": {"epss_score": 0.00415, "epss_percentile": 0.61145}, "CVE-2017-2860": {"epss_score": 0.00415, "epss_percentile": 0.61145}, "CVE-2017-2861": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-2862": {"epss_score": 0.05689, "epss_percentile": 0.90122}, "CVE-2017-2863": {"epss_score": 0.00252, "epss_percentile": 0.48356}, "CVE-2017-2864": {"epss_score": 0.005, "epss_percentile": 0.6532}, "CVE-2017-2865": {"epss_score": 0.00128, "epss_percentile": 0.32997}, "CVE-2017-2866": {"epss_score": 0.04629, "epss_percentile": 0.88942}, "CVE-2017-2867": {"epss_score": 0.01895, "epss_percentile": 0.82748}, "CVE-2017-2868": {"epss_score": 0.01895, "epss_percentile": 0.82748}, "CVE-2017-2869": {"epss_score": 0.02291, "epss_percentile": 0.84283}, "CVE-2017-2870": {"epss_score": 0.0313, "epss_percentile": 0.86463}, "CVE-2017-2871": {"epss_score": 0.00181, "epss_percentile": 0.40032}, "CVE-2017-2872": {"epss_score": 0.00288, "epss_percentile": 0.51953}, "CVE-2017-2873": {"epss_score": 0.07072, "epss_percentile": 0.91229}, "CVE-2017-2874": {"epss_score": 0.00496, "epss_percentile": 0.6516}, "CVE-2017-2875": {"epss_score": 0.00447, "epss_percentile": 0.62966}, "CVE-2017-2876": {"epss_score": 0.0034, "epss_percentile": 0.56238}, "CVE-2017-2877": {"epss_score": 0.00492, "epss_percentile": 0.64989}, "CVE-2017-2878": {"epss_score": 0.0135, "epss_percentile": 0.79673}, "CVE-2017-2879": {"epss_score": 0.00142, "epss_percentile": 0.34999}, "CVE-2017-2880": {"epss_score": 0.00611, "epss_percentile": 0.69195}, "CVE-2017-2881": {"epss_score": 0.00135, "epss_percentile": 0.34037}, "CVE-2017-2882": {"epss_score": 0.01196, "epss_percentile": 0.78443}, "CVE-2017-2883": {"epss_score": 0.00993, "epss_percentile": 0.76415}, "CVE-2017-2884": {"epss_score": 0.00368, "epss_percentile": 0.58185}, "CVE-2017-2885": {"epss_score": 0.13197, "epss_percentile": 0.93898}, "CVE-2017-2886": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2017-2887": {"epss_score": 0.01656, "epss_percentile": 0.81601}, "CVE-2017-2888": {"epss_score": 0.02799, "epss_percentile": 0.8569}, "CVE-2017-2889": {"epss_score": 0.00368, "epss_percentile": 0.58185}, "CVE-2017-2890": {"epss_score": 0.06479, "epss_percentile": 0.90785}, "CVE-2017-2891": {"epss_score": 0.02937, "epss_percentile": 0.86027}, "CVE-2017-2892": {"epss_score": 0.02479, "epss_percentile": 0.84868}, "CVE-2017-2893": {"epss_score": 0.05265, "epss_percentile": 0.89672}, "CVE-2017-2894": {"epss_score": 0.05089, "epss_percentile": 0.89482}, "CVE-2017-2895": {"epss_score": 0.00376, "epss_percentile": 0.58675}, "CVE-2017-2896": {"epss_score": 0.00559, "epss_percentile": 0.67612}, "CVE-2017-2897": {"epss_score": 0.01506, "epss_percentile": 0.80743}, "CVE-2017-2898": {"epss_score": 0.00508, "epss_percentile": 0.65683}, "CVE-2017-2899": {"epss_score": 0.01064, "epss_percentile": 0.77202}, "CVE-2017-2900": {"epss_score": 0.01064, "epss_percentile": 0.77202}, "CVE-2017-2901": {"epss_score": 0.01064, "epss_percentile": 0.77202}, "CVE-2017-2902": {"epss_score": 0.01064, "epss_percentile": 0.77202}, "CVE-2017-2903": {"epss_score": 0.0378, "epss_percentile": 0.8772}, "CVE-2017-2904": {"epss_score": 0.01064, "epss_percentile": 0.77202}, "CVE-2017-2905": {"epss_score": 0.01064, "epss_percentile": 0.77202}, "CVE-2017-2906": {"epss_score": 0.01064, "epss_percentile": 0.77202}, "CVE-2017-2907": {"epss_score": 0.01064, "epss_percentile": 0.77202}, "CVE-2017-2908": {"epss_score": 0.01064, "epss_percentile": 0.77202}, "CVE-2017-2909": {"epss_score": 0.00368, "epss_percentile": 0.58185}, "CVE-2017-2910": {"epss_score": 0.01251, "epss_percentile": 0.78896}, "CVE-2017-2911": {"epss_score": 0.00195, "epss_percentile": 0.41711}, "CVE-2017-2912": {"epss_score": 0.00136, "epss_percentile": 0.3413}, "CVE-2017-2913": {"epss_score": 0.00243, "epss_percentile": 0.47452}, "CVE-2017-2914": {"epss_score": 0.0054, "epss_percentile": 0.67022}, "CVE-2017-2915": {"epss_score": 0.00114, "epss_percentile": 0.30813}, "CVE-2017-2916": {"epss_score": 0.00479, "epss_percentile": 0.64414}, "CVE-2017-2917": {"epss_score": 0.03989, "epss_percentile": 0.88069}, "CVE-2017-2918": {"epss_score": 0.01064, "epss_percentile": 0.77202}, "CVE-2017-2919": {"epss_score": 0.01299, "epss_percentile": 0.79278}, "CVE-2017-2920": {"epss_score": 0.00601, "epss_percentile": 0.68856}, "CVE-2017-2921": {"epss_score": 0.02149, "epss_percentile": 0.83778}, "CVE-2017-2922": {"epss_score": 0.02712, "epss_percentile": 0.85498}, "CVE-2017-2923": {"epss_score": 0.02235, "epss_percentile": 0.841}, "CVE-2017-2924": {"epss_score": 0.02235, "epss_percentile": 0.841}, "CVE-2017-2925": {"epss_score": 0.01471, "epss_percentile": 0.80501}, "CVE-2017-2926": {"epss_score": 0.01471, "epss_percentile": 0.80501}, "CVE-2017-2927": {"epss_score": 0.0134, "epss_percentile": 0.79581}, "CVE-2017-2928": {"epss_score": 0.03253, "epss_percentile": 0.86755}, "CVE-2017-2929": {"epss_score": 0.03873, "epss_percentile": 0.87885}, "CVE-2017-2930": {"epss_score": 0.81971, "epss_percentile": 0.99167}, "CVE-2017-2931": {"epss_score": 0.67944, "epss_percentile": 0.98526}, "CVE-2017-2932": {"epss_score": 0.64351, "epss_percentile": 0.98374}, "CVE-2017-2933": {"epss_score": 0.69087, "epss_percentile": 0.98578}, "CVE-2017-2934": {"epss_score": 0.69087, "epss_percentile": 0.98578}, "CVE-2017-2935": {"epss_score": 0.69087, "epss_percentile": 0.98578}, "CVE-2017-2936": {"epss_score": 0.02653, "epss_percentile": 0.85352}, "CVE-2017-2937": {"epss_score": 0.02026, "epss_percentile": 0.83317}, "CVE-2017-2938": {"epss_score": 0.02003, "epss_percentile": 0.83226}, "CVE-2017-2939": {"epss_score": 0.02069, "epss_percentile": 0.83467}, "CVE-2017-2940": {"epss_score": 0.02069, "epss_percentile": 0.83467}, "CVE-2017-2941": {"epss_score": 0.02251, "epss_percentile": 0.84159}, "CVE-2017-2942": {"epss_score": 0.03844, "epss_percentile": 0.87838}, "CVE-2017-2943": {"epss_score": 0.02053, "epss_percentile": 0.83416}, "CVE-2017-2944": {"epss_score": 0.02053, "epss_percentile": 0.83416}, "CVE-2017-2945": {"epss_score": 0.03844, "epss_percentile": 0.87838}, "CVE-2017-2946": {"epss_score": 0.04065, "epss_percentile": 0.88194}, "CVE-2017-2947": {"epss_score": 0.02186, "epss_percentile": 0.8392}, "CVE-2017-2948": {"epss_score": 0.03873, "epss_percentile": 0.87883}, "CVE-2017-2949": {"epss_score": 0.10197, "epss_percentile": 0.92889}, "CVE-2017-2950": {"epss_score": 0.03346, "epss_percentile": 0.86953}, "CVE-2017-2951": {"epss_score": 0.02558, "epss_percentile": 0.85098}, "CVE-2017-2952": {"epss_score": 0.03157, "epss_percentile": 0.86517}, "CVE-2017-2953": {"epss_score": 0.02053, "epss_percentile": 0.83416}, "CVE-2017-2954": {"epss_score": 0.02053, "epss_percentile": 0.83416}, "CVE-2017-2955": {"epss_score": 0.02849, "epss_percentile": 0.85827}, "CVE-2017-2956": {"epss_score": 0.02491, "epss_percentile": 0.84896}, "CVE-2017-2957": {"epss_score": 0.03923, "epss_percentile": 0.87957}, "CVE-2017-2958": {"epss_score": 0.06237, "epss_percentile": 0.90591}, "CVE-2017-2959": {"epss_score": 0.03888, "epss_percentile": 0.87906}, "CVE-2017-2960": {"epss_score": 0.03435, "epss_percentile": 0.87132}, "CVE-2017-2961": {"epss_score": 0.03752, "epss_percentile": 0.87675}, "CVE-2017-2962": {"epss_score": 0.05483, "epss_percentile": 0.8992}, "CVE-2017-2963": {"epss_score": 0.0346, "epss_percentile": 0.87179}, "CVE-2017-2964": {"epss_score": 0.02251, "epss_percentile": 0.84159}, "CVE-2017-2965": {"epss_score": 0.02234, "epss_percentile": 0.84096}, "CVE-2017-2966": {"epss_score": 0.04758, "epss_percentile": 0.89115}, "CVE-2017-2967": {"epss_score": 0.02251, "epss_percentile": 0.84159}, "CVE-2017-2968": {"epss_score": 0.02977, "epss_percentile": 0.86109}, "CVE-2017-2969": {"epss_score": 0.01232, "epss_percentile": 0.78741}, "CVE-2017-2970": {"epss_score": 0.03026, "epss_percentile": 0.8624}, "CVE-2017-2971": {"epss_score": 0.03134, "epss_percentile": 0.86478}, "CVE-2017-2972": {"epss_score": 0.02145, "epss_percentile": 0.83763}, "CVE-2017-2973": {"epss_score": 0.13252, "epss_percentile": 0.93914}, "CVE-2017-2974": {"epss_score": 0.03, "epss_percentile": 0.86163}, "CVE-2017-2975": {"epss_score": 0.03, "epss_percentile": 0.86163}, "CVE-2017-2976": {"epss_score": 0.03, "epss_percentile": 0.86163}, "CVE-2017-2977": {"epss_score": 0.03, "epss_percentile": 0.86163}, "CVE-2017-2978": {"epss_score": 0.03, "epss_percentile": 0.86163}, "CVE-2017-2979": {"epss_score": 0.03, "epss_percentile": 0.86163}, "CVE-2017-2980": {"epss_score": 0.03, "epss_percentile": 0.86163}, "CVE-2017-2981": {"epss_score": 0.03, "epss_percentile": 0.86163}, "CVE-2017-2982": {"epss_score": 0.01921, "epss_percentile": 0.82897}, "CVE-2017-2983": {"epss_score": 0.02171, "epss_percentile": 0.83872}, "CVE-2017-2984": {"epss_score": 0.03728, "epss_percentile": 0.87636}, "CVE-2017-2985": {"epss_score": 0.52416, "epss_percentile": 0.97824}, "CVE-2017-2986": {"epss_score": 0.69087, "epss_percentile": 0.98578}, "CVE-2017-2987": {"epss_score": 0.09411, "epss_percentile": 0.92536}, "CVE-2017-2988": {"epss_score": 0.60856, "epss_percentile": 0.98224}, "CVE-2017-2989": {"epss_score": 0.03507, "epss_percentile": 0.87261}, "CVE-2017-2990": {"epss_score": 0.01037, "epss_percentile": 0.76924}, "CVE-2017-2991": {"epss_score": 0.01202, "epss_percentile": 0.78488}, "CVE-2017-2992": {"epss_score": 0.69087, "epss_percentile": 0.98578}, "CVE-2017-2993": {"epss_score": 0.01921, "epss_percentile": 0.82897}, "CVE-2017-2994": {"epss_score": 0.02879, "epss_percentile": 0.85893}, "CVE-2017-2995": {"epss_score": 0.08869, "epss_percentile": 0.92294}, "CVE-2017-2996": {"epss_score": 0.02296, "epss_percentile": 0.84296}, "CVE-2017-2997": {"epss_score": 0.01751, "epss_percentile": 0.82105}, "CVE-2017-2998": {"epss_score": 0.01026, "epss_percentile": 0.76801}, "CVE-2017-2999": {"epss_score": 0.01152, "epss_percentile": 0.78047}, "CVE-2017-3000": {"epss_score": 0.24878, "epss_percentile": 0.95962}, "CVE-2017-3001": {"epss_score": 0.01304, "epss_percentile": 0.79313}, "CVE-2017-3002": {"epss_score": 0.01304, "epss_percentile": 0.79313}, "CVE-2017-3003": {"epss_score": 0.02458, "epss_percentile": 0.84815}, "CVE-2017-3004": {"epss_score": 0.0669, "epss_percentile": 0.90949}, "CVE-2017-3005": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2017-3006": {"epss_score": 0.24109, "epss_percentile": 0.9587}, "CVE-2017-3007": {"epss_score": 0.00268, "epss_percentile": 0.50102}, "CVE-2017-3008": {"epss_score": 0.00484, "epss_percentile": 0.64673}, "CVE-2017-3009": {"epss_score": 0.01909, "epss_percentile": 0.82822}, "CVE-2017-3010": {"epss_score": 0.02297, "epss_percentile": 0.843}, "CVE-2017-3011": {"epss_score": 0.06257, "epss_percentile": 0.90618}, "CVE-2017-3012": {"epss_score": 0.01951, "epss_percentile": 0.83018}, "CVE-2017-3013": {"epss_score": 0.01951, "epss_percentile": 0.83018}, "CVE-2017-3014": {"epss_score": 0.01463, "epss_percentile": 0.8044}, "CVE-2017-3015": {"epss_score": 0.02108, "epss_percentile": 0.83637}, "CVE-2017-3016": {"epss_score": 0.08256, "epss_percentile": 0.91953}, "CVE-2017-3017": {"epss_score": 0.02108, "epss_percentile": 0.83637}, "CVE-2017-3018": {"epss_score": 0.02108, "epss_percentile": 0.83637}, "CVE-2017-3019": {"epss_score": 0.01938, "epss_percentile": 0.8297}, "CVE-2017-3020": {"epss_score": 0.01991, "epss_percentile": 0.83177}, "CVE-2017-3021": {"epss_score": 0.01942, "epss_percentile": 0.82985}, "CVE-2017-3022": {"epss_score": 0.02721, "epss_percentile": 0.85518}, "CVE-2017-3023": {"epss_score": 0.02401, "epss_percentile": 0.8464}, "CVE-2017-3024": {"epss_score": 0.02155, "epss_percentile": 0.83804}, "CVE-2017-3025": {"epss_score": 0.01938, "epss_percentile": 0.8297}, "CVE-2017-3026": {"epss_score": 0.0226, "epss_percentile": 0.84186}, "CVE-2017-3027": {"epss_score": 0.0226, "epss_percentile": 0.84186}, "CVE-2017-3028": {"epss_score": 0.02383, "epss_percentile": 0.84573}, "CVE-2017-3029": {"epss_score": 0.01991, "epss_percentile": 0.83177}, "CVE-2017-3030": {"epss_score": 0.01924, "epss_percentile": 0.82915}, "CVE-2017-3031": {"epss_score": 0.0158, "epss_percentile": 0.81133}, "CVE-2017-3032": {"epss_score": 0.02079, "epss_percentile": 0.83525}, "CVE-2017-3033": {"epss_score": 0.0158, "epss_percentile": 0.81133}, "CVE-2017-3034": {"epss_score": 0.03029, "epss_percentile": 0.86244}, "CVE-2017-3035": {"epss_score": 0.02027, "epss_percentile": 0.8332}, "CVE-2017-3036": {"epss_score": 0.02401, "epss_percentile": 0.8464}, "CVE-2017-3037": {"epss_score": 0.02398, "epss_percentile": 0.84623}, "CVE-2017-3038": {"epss_score": 0.01289, "epss_percentile": 0.79213}, "CVE-2017-3039": {"epss_score": 0.01924, "epss_percentile": 0.82915}, "CVE-2017-3040": {"epss_score": 0.01924, "epss_percentile": 0.82915}, "CVE-2017-3041": {"epss_score": 0.01938, "epss_percentile": 0.8297}, "CVE-2017-3042": {"epss_score": 0.02232, "epss_percentile": 0.8409}, "CVE-2017-3043": {"epss_score": 0.01636, "epss_percentile": 0.81479}, "CVE-2017-3044": {"epss_score": 0.0456, "epss_percentile": 0.88851}, "CVE-2017-3045": {"epss_score": 0.01636, "epss_percentile": 0.81479}, "CVE-2017-3046": {"epss_score": 0.01636, "epss_percentile": 0.81479}, "CVE-2017-3047": {"epss_score": 0.02134, "epss_percentile": 0.83724}, "CVE-2017-3048": {"epss_score": 0.02547, "epss_percentile": 0.85064}, "CVE-2017-3049": {"epss_score": 0.03679, "epss_percentile": 0.87556}, "CVE-2017-3050": {"epss_score": 0.02383, "epss_percentile": 0.84573}, "CVE-2017-3051": {"epss_score": 0.02383, "epss_percentile": 0.84573}, "CVE-2017-3052": {"epss_score": 0.01636, "epss_percentile": 0.81479}, "CVE-2017-3053": {"epss_score": 0.01636, "epss_percentile": 0.81479}, "CVE-2017-3054": {"epss_score": 0.01924, "epss_percentile": 0.82915}, "CVE-2017-3055": {"epss_score": 0.02232, "epss_percentile": 0.8409}, "CVE-2017-3056": {"epss_score": 0.01938, "epss_percentile": 0.8297}, "CVE-2017-3057": {"epss_score": 0.02134, "epss_percentile": 0.83724}, "CVE-2017-3058": {"epss_score": 0.013, "epss_percentile": 0.79288}, "CVE-2017-3059": {"epss_score": 0.04446, "epss_percentile": 0.88699}, "CVE-2017-3060": {"epss_score": 0.07937, "epss_percentile": 0.91775}, "CVE-2017-3061": {"epss_score": 0.53858, "epss_percentile": 0.97899}, "CVE-2017-3062": {"epss_score": 0.04446, "epss_percentile": 0.88699}, "CVE-2017-3063": {"epss_score": 0.04446, "epss_percentile": 0.88699}, "CVE-2017-3064": {"epss_score": 0.04828, "epss_percentile": 0.89187}, "CVE-2017-3065": {"epss_score": 0.01924, "epss_percentile": 0.82915}, "CVE-2017-3066": {"epss_score": 0.93362, "epss_percentile": 0.998}, "CVE-2017-3067": {"epss_score": 0.04527, "epss_percentile": 0.88807}, "CVE-2017-3068": {"epss_score": 0.35099, "epss_percentile": 0.96887}, "CVE-2017-3069": {"epss_score": 0.01969, "epss_percentile": 0.83091}, "CVE-2017-3070": {"epss_score": 0.01969, "epss_percentile": 0.83091}, "CVE-2017-3071": {"epss_score": 0.01646, "epss_percentile": 0.81534}, "CVE-2017-3072": {"epss_score": 0.01969, "epss_percentile": 0.83091}, "CVE-2017-3073": {"epss_score": 0.01768, "epss_percentile": 0.82183}, "CVE-2017-3074": {"epss_score": 0.01969, "epss_percentile": 0.83091}, "CVE-2017-3075": {"epss_score": 0.01682, "epss_percentile": 0.81734}, "CVE-2017-3076": {"epss_score": 0.53858, "epss_percentile": 0.97899}, "CVE-2017-3077": {"epss_score": 0.53858, "epss_percentile": 0.97899}, "CVE-2017-3078": {"epss_score": 0.69989, "epss_percentile": 0.98611}, "CVE-2017-3079": {"epss_score": 0.03626, "epss_percentile": 0.87458}, "CVE-2017-3080": {"epss_score": 0.03071, "epss_percentile": 0.86348}, "CVE-2017-3081": {"epss_score": 0.01682, "epss_percentile": 0.81734}, "CVE-2017-3082": {"epss_score": 0.03626, "epss_percentile": 0.87458}, "CVE-2017-3083": {"epss_score": 0.01682, "epss_percentile": 0.81734}, "CVE-2017-3084": {"epss_score": 0.01682, "epss_percentile": 0.81734}, "CVE-2017-3085": {"epss_score": 0.00815, "epss_percentile": 0.73785}, "CVE-2017-3086": {"epss_score": 0.07429, "epss_percentile": 0.91471}, "CVE-2017-3087": {"epss_score": 0.04244, "epss_percentile": 0.88438}, "CVE-2017-3088": {"epss_score": 0.03393, "epss_percentile": 0.87056}, "CVE-2017-3089": {"epss_score": 0.03393, "epss_percentile": 0.87056}, "CVE-2017-3090": {"epss_score": 0.08832, "epss_percentile": 0.92274}, "CVE-2017-3091": {"epss_score": 0.05345, "epss_percentile": 0.89769}, "CVE-2017-3092": {"epss_score": 0.08832, "epss_percentile": 0.92274}, "CVE-2017-3093": {"epss_score": 0.03393, "epss_percentile": 0.87056}, "CVE-2017-3094": {"epss_score": 0.03393, "epss_percentile": 0.87056}, "CVE-2017-3095": {"epss_score": 0.03606, "epss_percentile": 0.87417}, "CVE-2017-3096": {"epss_score": 0.03393, "epss_percentile": 0.87056}, "CVE-2017-3097": {"epss_score": 0.08832, "epss_percentile": 0.92274}, "CVE-2017-3098": {"epss_score": 0.15166, "epss_percentile": 0.94378}, "CVE-2017-3099": {"epss_score": 0.0186, "epss_percentile": 0.82587}, "CVE-2017-3100": {"epss_score": 0.01881, "epss_percentile": 0.82693}, "CVE-2017-3101": {"epss_score": 0.01527, "epss_percentile": 0.80866}, "CVE-2017-3102": {"epss_score": 0.00638, "epss_percentile": 0.69915}, "CVE-2017-3103": {"epss_score": 0.01066, "epss_percentile": 0.77219}, "CVE-2017-3104": {"epss_score": 0.01279, "epss_percentile": 0.79132}, "CVE-2017-3105": {"epss_score": 0.00437, "epss_percentile": 0.625}, "CVE-2017-3106": {"epss_score": 0.53254, "epss_percentile": 0.97869}, "CVE-2017-3107": {"epss_score": 0.09607, "epss_percentile": 0.92619}, "CVE-2017-3108": {"epss_score": 0.13208, "epss_percentile": 0.93901}, "CVE-2017-3109": {"epss_score": 0.01471, "epss_percentile": 0.80506}, "CVE-2017-3110": {"epss_score": 0.09607, "epss_percentile": 0.92619}, "CVE-2017-3111": {"epss_score": 0.09607, "epss_percentile": 0.92619}, "CVE-2017-3112": {"epss_score": 0.0968, "epss_percentile": 0.92657}, "CVE-2017-3113": {"epss_score": 0.04802, "epss_percentile": 0.89158}, "CVE-2017-3114": {"epss_score": 0.0968, "epss_percentile": 0.92657}, "CVE-2017-3115": {"epss_score": 0.07053, "epss_percentile": 0.91215}, "CVE-2017-3116": {"epss_score": 0.08737, "epss_percentile": 0.92233}, "CVE-2017-3117": {"epss_score": 0.29149, "epss_percentile": 0.96421}, "CVE-2017-3118": {"epss_score": 0.13607, "epss_percentile": 0.94009}, "CVE-2017-3119": {"epss_score": 0.14123, "epss_percentile": 0.94139}, "CVE-2017-3120": {"epss_score": 0.05097, "epss_percentile": 0.89495}, "CVE-2017-3121": {"epss_score": 0.08256, "epss_percentile": 0.91953}, "CVE-2017-3122": {"epss_score": 0.12506, "epss_percentile": 0.93701}, "CVE-2017-3123": {"epss_score": 0.08256, "epss_percentile": 0.91953}, "CVE-2017-3124": {"epss_score": 0.11539, "epss_percentile": 0.93399}, "CVE-2017-3125": {"epss_score": 0.00581, "epss_percentile": 0.68282}, "CVE-2017-3126": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2017-3127": {"epss_score": 0.00313, "epss_percentile": 0.54069}, "CVE-2017-3128": {"epss_score": 0.00307, "epss_percentile": 0.53517}, "CVE-2017-3129": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2017-3130": {"epss_score": 0.00291, "epss_percentile": 0.5215}, "CVE-2017-3131": {"epss_score": 0.11481, "epss_percentile": 0.93379}, "CVE-2017-3132": {"epss_score": 0.08784, "epss_percentile": 0.92253}, "CVE-2017-3133": {"epss_score": 0.0869, "epss_percentile": 0.92205}, "CVE-2017-3134": {"epss_score": 0.00446, "epss_percentile": 0.62912}, "CVE-2017-3135": {"epss_score": 0.34413, "epss_percentile": 0.96846}, "CVE-2017-3136": {"epss_score": 0.49378, "epss_percentile": 0.97683}, "CVE-2017-3137": {"epss_score": 0.34251, "epss_percentile": 0.96836}, "CVE-2017-3138": {"epss_score": 0.38782, "epss_percentile": 0.97119}, "CVE-2017-3139": {"epss_score": 0.00723, "epss_percentile": 0.72027}, "CVE-2017-3140": {"epss_score": 0.19519, "epss_percentile": 0.95199}, "CVE-2017-3141": {"epss_score": 0.02412, "epss_percentile": 0.84672}, "CVE-2017-3142": {"epss_score": 0.04951, "epss_percentile": 0.89324}, "CVE-2017-3143": {"epss_score": 0.26927, "epss_percentile": 0.96193}, "CVE-2017-3144": {"epss_score": 0.17594, "epss_percentile": 0.94872}, "CVE-2017-3145": {"epss_score": 0.10126, "epss_percentile": 0.9286}, "CVE-2017-3150": {"epss_score": 0.01019, "epss_percentile": 0.76726}, "CVE-2017-3151": {"epss_score": 0.01019, "epss_percentile": 0.76726}, "CVE-2017-3152": {"epss_score": 0.0144, "epss_percentile": 0.80295}, "CVE-2017-3153": {"epss_score": 0.0144, "epss_percentile": 0.80295}, "CVE-2017-3154": {"epss_score": 0.00825, "epss_percentile": 0.73954}, "CVE-2017-3155": {"epss_score": 0.01943, "epss_percentile": 0.82995}, "CVE-2017-3156": {"epss_score": 0.1307, "epss_percentile": 0.93865}, "CVE-2017-3157": {"epss_score": 0.01063, "epss_percentile": 0.77191}, "CVE-2017-3158": {"epss_score": 0.00687, "epss_percentile": 0.71178}, "CVE-2017-3159": {"epss_score": 0.02766, "epss_percentile": 0.85611}, "CVE-2017-3160": {"epss_score": 0.00775, "epss_percentile": 0.73092}, "CVE-2017-3161": {"epss_score": 0.0503, "epss_percentile": 0.89413}, "CVE-2017-3162": {"epss_score": 0.01938, "epss_percentile": 0.82967}, "CVE-2017-3163": {"epss_score": 0.16448, "epss_percentile": 0.94662}, "CVE-2017-3164": {"epss_score": 0.55454, "epss_percentile": 0.97979}, "CVE-2017-3165": {"epss_score": 0.0027, "epss_percentile": 0.50192}, "CVE-2017-3166": {"epss_score": 0.00214, "epss_percentile": 0.43963}, "CVE-2017-3167": {"epss_score": 0.0944, "epss_percentile": 0.92549}, "CVE-2017-3169": {"epss_score": 0.32547, "epss_percentile": 0.96707}, "CVE-2017-3180": {"epss_score": 0.0034, "epss_percentile": 0.56278}, "CVE-2017-3181": {"epss_score": 0.00621, "epss_percentile": 0.69488}, "CVE-2017-3182": {"epss_score": 0.00055, "epss_percentile": 0.17488}, "CVE-2017-3183": {"epss_score": 0.01483, "epss_percentile": 0.80586}, "CVE-2017-3184": {"epss_score": 0.13983, "epss_percentile": 0.94107}, "CVE-2017-3185": {"epss_score": 0.01712, "epss_percentile": 0.81886}, "CVE-2017-3186": {"epss_score": 0.09872, "epss_percentile": 0.92747}, "CVE-2017-3187": {"epss_score": 0.00287, "epss_percentile": 0.51863}, "CVE-2017-3188": {"epss_score": 0.01674, "epss_percentile": 0.81698}, "CVE-2017-3189": {"epss_score": 0.07139, "epss_percentile": 0.91277}, "CVE-2017-3190": {"epss_score": 0.00097, "epss_percentile": 0.27501}, "CVE-2017-3191": {"epss_score": 0.33804, "epss_percentile": 0.96804}, "CVE-2017-3192": {"epss_score": 0.27688, "epss_percentile": 0.96274}, "CVE-2017-3193": {"epss_score": 0.0109, "epss_percentile": 0.77454}, "CVE-2017-3194": {"epss_score": 0.00472, "epss_percentile": 0.64053}, "CVE-2017-3195": {"epss_score": 0.46232, "epss_percentile": 0.97538}, "CVE-2017-3196": {"epss_score": 0.00249, "epss_percentile": 0.48007}, "CVE-2017-3197": {"epss_score": 0.02992, "epss_percentile": 0.86147}, "CVE-2017-3198": {"epss_score": 0.00223, "epss_percentile": 0.44939}, "CVE-2017-3199": {"epss_score": 0.13846, "epss_percentile": 0.94075}, "CVE-2017-3200": {"epss_score": 0.1373, "epss_percentile": 0.94044}, "CVE-2017-3201": {"epss_score": 0.07505, "epss_percentile": 0.91509}, "CVE-2017-3202": {"epss_score": 0.10592, "epss_percentile": 0.93037}, "CVE-2017-3203": {"epss_score": 0.13418, "epss_percentile": 0.93957}, "CVE-2017-3204": {"epss_score": 0.01811, "epss_percentile": 0.82365}, "CVE-2017-3206": {"epss_score": 0.01456, "epss_percentile": 0.80395}, "CVE-2017-3207": {"epss_score": 0.07161, "epss_percentile": 0.91292}, "CVE-2017-3208": {"epss_score": 0.01706, "epss_percentile": 0.81856}, "CVE-2017-3209": {"epss_score": 0.00725, "epss_percentile": 0.72043}, "CVE-2017-3210": {"epss_score": 0.00053, "epss_percentile": 0.17039}, "CVE-2017-3211": {"epss_score": 0.00273, "epss_percentile": 0.50481}, "CVE-2017-3212": {"epss_score": 0.00223, "epss_percentile": 0.44941}, "CVE-2017-3213": {"epss_score": 0.00223, "epss_percentile": 0.44941}, "CVE-2017-3214": {"epss_score": 0.00124, "epss_percentile": 0.32392}, "CVE-2017-3215": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2017-3216": {"epss_score": 0.03167, "epss_percentile": 0.8654}, "CVE-2017-3217": {"epss_score": 0.00502, "epss_percentile": 0.6537}, "CVE-2017-3218": {"epss_score": 0.00018, "epss_percentile": 0.03673}, "CVE-2017-3219": {"epss_score": 0.0003, "epss_percentile": 0.0806}, "CVE-2017-3221": {"epss_score": 0.02048, "epss_percentile": 0.83391}, "CVE-2017-3222": {"epss_score": 0.06119, "epss_percentile": 0.90492}, "CVE-2017-3223": {"epss_score": 0.11281, "epss_percentile": 0.9329}, "CVE-2017-3224": {"epss_score": 0.00025, "epss_percentile": 0.06337}, "CVE-2017-3225": {"epss_score": 0.0005, "epss_percentile": 0.15842}, "CVE-2017-3226": {"epss_score": 0.00042, "epss_percentile": 0.12745}, "CVE-2017-3230": {"epss_score": 0.05882, "epss_percentile": 0.90291}, "CVE-2017-3231": {"epss_score": 0.00593, "epss_percentile": 0.68637}, "CVE-2017-3232": {"epss_score": 0.0011, "epss_percentile": 0.3023}, "CVE-2017-3233": {"epss_score": 0.01643, "epss_percentile": 0.81519}, "CVE-2017-3234": {"epss_score": 0.01898, "epss_percentile": 0.8276}, "CVE-2017-3235": {"epss_score": 0.00073, "epss_percentile": 0.2249}, "CVE-2017-3236": {"epss_score": 0.00642, "epss_percentile": 0.7003}, "CVE-2017-3237": {"epss_score": 0.0006, "epss_percentile": 0.19226}, "CVE-2017-3238": {"epss_score": 0.01946, "epss_percentile": 0.83003}, "CVE-2017-3239": {"epss_score": 0.00036, "epss_percentile": 0.10486}, "CVE-2017-3240": {"epss_score": 0.00051, "epss_percentile": 0.16241}, "CVE-2017-3241": {"epss_score": 0.78326, "epss_percentile": 0.9898}, "CVE-2017-3242": {"epss_score": 0.00145, "epss_percentile": 0.35522}, "CVE-2017-3243": {"epss_score": 0.05555, "epss_percentile": 0.89989}, "CVE-2017-3244": {"epss_score": 0.00314, "epss_percentile": 0.54149}, "CVE-2017-3245": {"epss_score": 0.00516, "epss_percentile": 0.6606}, "CVE-2017-3246": {"epss_score": 0.001, "epss_percentile": 0.28549}, "CVE-2017-3247": {"epss_score": 0.00506, "epss_percentile": 0.65613}, "CVE-2017-3248": {"epss_score": 0.92161, "epss_percentile": 0.99694}, "CVE-2017-3249": {"epss_score": 0.0076, "epss_percentile": 0.72807}, "CVE-2017-3250": {"epss_score": 0.00713, "epss_percentile": 0.71795}, "CVE-2017-3251": {"epss_score": 0.005, "epss_percentile": 0.65324}, "CVE-2017-3252": {"epss_score": 0.00381, "epss_percentile": 0.59014}, "CVE-2017-3253": {"epss_score": 0.01827, "epss_percentile": 0.82437}, "CVE-2017-3254": {"epss_score": 0.01222, "epss_percentile": 0.78659}, "CVE-2017-3255": {"epss_score": 0.00489, "epss_percentile": 0.64897}, "CVE-2017-3256": {"epss_score": 0.00604, "epss_percentile": 0.68952}, "CVE-2017-3257": {"epss_score": 0.00222, "epss_percentile": 0.44785}, "CVE-2017-3258": {"epss_score": 0.00312, "epss_percentile": 0.54003}, "CVE-2017-3259": {"epss_score": 0.00471, "epss_percentile": 0.64008}, "CVE-2017-3260": {"epss_score": 0.01903, "epss_percentile": 0.82786}, "CVE-2017-3261": {"epss_score": 0.00857, "epss_percentile": 0.74491}, "CVE-2017-3262": {"epss_score": 0.00663, "epss_percentile": 0.70612}, "CVE-2017-3263": {"epss_score": 0.00411, "epss_percentile": 0.609}, "CVE-2017-3264": {"epss_score": 0.00252, "epss_percentile": 0.48375}, "CVE-2017-3265": {"epss_score": 0.00225, "epss_percentile": 0.45115}, "CVE-2017-3266": {"epss_score": 0.02861, "epss_percentile": 0.85851}, "CVE-2017-3267": {"epss_score": 0.01871, "epss_percentile": 0.82635}, "CVE-2017-3268": {"epss_score": 0.01871, "epss_percentile": 0.82635}, "CVE-2017-3269": {"epss_score": 0.01871, "epss_percentile": 0.82635}, "CVE-2017-3270": {"epss_score": 0.01871, "epss_percentile": 0.82635}, "CVE-2017-3271": {"epss_score": 0.01528, "epss_percentile": 0.80874}, "CVE-2017-3272": {"epss_score": 0.01126, "epss_percentile": 0.77814}, "CVE-2017-3273": {"epss_score": 0.00852, "epss_percentile": 0.74412}, "CVE-2017-3274": {"epss_score": 0.00747, "epss_percentile": 0.72572}, "CVE-2017-3275": {"epss_score": 0.00747, "epss_percentile": 0.72572}, "CVE-2017-3276": {"epss_score": 0.00047, "epss_percentile": 0.14585}, "CVE-2017-3277": {"epss_score": 0.0031, "epss_percentile": 0.53768}, "CVE-2017-3278": {"epss_score": 0.00747, "epss_percentile": 0.72572}, "CVE-2017-3279": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3280": {"epss_score": 0.00642, "epss_percentile": 0.7003}, "CVE-2017-3281": {"epss_score": 0.01008, "epss_percentile": 0.76572}, "CVE-2017-3282": {"epss_score": 0.00549, "epss_percentile": 0.67298}, "CVE-2017-3283": {"epss_score": 0.00549, "epss_percentile": 0.67298}, "CVE-2017-3284": {"epss_score": 0.00747, "epss_percentile": 0.72572}, "CVE-2017-3285": {"epss_score": 0.00747, "epss_percentile": 0.72572}, "CVE-2017-3286": {"epss_score": 0.001, "epss_percentile": 0.28549}, "CVE-2017-3287": {"epss_score": 0.00747, "epss_percentile": 0.72572}, "CVE-2017-3288": {"epss_score": 0.00221, "epss_percentile": 0.44711}, "CVE-2017-3289": {"epss_score": 0.01126, "epss_percentile": 0.77814}, "CVE-2017-3290": {"epss_score": 0.00075, "epss_percentile": 0.22987}, "CVE-2017-3291": {"epss_score": 0.00091, "epss_percentile": 0.26197}, "CVE-2017-3292": {"epss_score": 0.00369, "epss_percentile": 0.58255}, "CVE-2017-3293": {"epss_score": 0.01528, "epss_percentile": 0.80874}, "CVE-2017-3294": {"epss_score": 0.02878, "epss_percentile": 0.8589}, "CVE-2017-3295": {"epss_score": 0.02878, "epss_percentile": 0.8589}, "CVE-2017-3296": {"epss_score": 0.00507, "epss_percentile": 0.65654}, "CVE-2017-3297": {"epss_score": 0.00302, "epss_percentile": 0.53134}, "CVE-2017-3298": {"epss_score": 0.00501, "epss_percentile": 0.65362}, "CVE-2017-3299": {"epss_score": 0.0047, "epss_percentile": 0.63985}, "CVE-2017-3300": {"epss_score": 0.01006, "epss_percentile": 0.76552}, "CVE-2017-3301": {"epss_score": 0.00457, "epss_percentile": 0.63382}, "CVE-2017-3302": {"epss_score": 0.01456, "epss_percentile": 0.80392}, "CVE-2017-3303": {"epss_score": 0.00747, "epss_percentile": 0.72572}, "CVE-2017-3304": {"epss_score": 0.00358, "epss_percentile": 0.57521}, "CVE-2017-3305": {"epss_score": 0.00105, "epss_percentile": 0.29347}, "CVE-2017-3306": {"epss_score": 0.00455, "epss_percentile": 0.63293}, "CVE-2017-3307": {"epss_score": 0.00436, "epss_percentile": 0.62472}, "CVE-2017-3308": {"epss_score": 0.00321, "epss_percentile": 0.54647}, "CVE-2017-3309": {"epss_score": 0.00319, "epss_percentile": 0.54466}, "CVE-2017-3310": {"epss_score": 0.00605, "epss_percentile": 0.68971}, "CVE-2017-3311": {"epss_score": 0.00635, "epss_percentile": 0.69817}, "CVE-2017-3312": {"epss_score": 0.00123, "epss_percentile": 0.32185}, "CVE-2017-3313": {"epss_score": 0.00053, "epss_percentile": 0.1687}, "CVE-2017-3314": {"epss_score": 0.00501, "epss_percentile": 0.65362}, "CVE-2017-3315": {"epss_score": 0.00249, "epss_percentile": 0.48036}, "CVE-2017-3316": {"epss_score": 0.03091, "epss_percentile": 0.86395}, "CVE-2017-3317": {"epss_score": 0.00031, "epss_percentile": 0.08583}, "CVE-2017-3318": {"epss_score": 0.00052, "epss_percentile": 0.16596}, "CVE-2017-3319": {"epss_score": 0.00589, "epss_percentile": 0.68514}, "CVE-2017-3320": {"epss_score": 0.00297, "epss_percentile": 0.52745}, "CVE-2017-3321": {"epss_score": 0.01064, "epss_percentile": 0.77195}, "CVE-2017-3322": {"epss_score": 0.0091, "epss_percentile": 0.75319}, "CVE-2017-3323": {"epss_score": 0.0091, "epss_percentile": 0.75319}, "CVE-2017-3324": {"epss_score": 0.02719, "epss_percentile": 0.85514}, "CVE-2017-3325": {"epss_score": 0.00747, "epss_percentile": 0.72572}, "CVE-2017-3326": {"epss_score": 0.00747, "epss_percentile": 0.72572}, "CVE-2017-3327": {"epss_score": 0.00747, "epss_percentile": 0.72572}, "CVE-2017-3328": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3329": {"epss_score": 0.0263, "epss_percentile": 0.8528}, "CVE-2017-3330": {"epss_score": 0.00284, "epss_percentile": 0.51467}, "CVE-2017-3331": {"epss_score": 0.00488, "epss_percentile": 0.64833}, "CVE-2017-3332": {"epss_score": 0.00113, "epss_percentile": 0.30716}, "CVE-2017-3333": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3334": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3335": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3336": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3337": {"epss_score": 0.01912, "epss_percentile": 0.82834}, "CVE-2017-3338": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3339": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3340": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3341": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3342": {"epss_score": 0.00953, "epss_percentile": 0.75889}, "CVE-2017-3343": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3344": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3345": {"epss_score": 0.01015, "epss_percentile": 0.76668}, "CVE-2017-3346": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3347": {"epss_score": 0.00953, "epss_percentile": 0.75889}, "CVE-2017-3348": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3349": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3350": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3351": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3352": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3353": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3354": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3355": {"epss_score": 0.01015, "epss_percentile": 0.76668}, "CVE-2017-3356": {"epss_score": 0.01015, "epss_percentile": 0.76668}, "CVE-2017-3357": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3358": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3359": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3360": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3361": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3362": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3363": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3364": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3365": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3366": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3367": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3368": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3369": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3370": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3371": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3372": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3373": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3374": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3375": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3376": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3377": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3378": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3379": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3380": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3381": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3382": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3383": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3384": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3385": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3386": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3387": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3388": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3389": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3390": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3391": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3392": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3393": {"epss_score": 0.01912, "epss_percentile": 0.82834}, "CVE-2017-3394": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3395": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3396": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3397": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3398": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3399": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3400": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3401": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3402": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3403": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3404": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3405": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3406": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3407": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3408": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3409": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3410": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3411": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3412": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3413": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3414": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3415": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3416": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3417": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3418": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3419": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3420": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3421": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3422": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3423": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3424": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3425": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3426": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3427": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3428": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3429": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3430": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3431": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3432": {"epss_score": 0.01912, "epss_percentile": 0.82834}, "CVE-2017-3433": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3434": {"epss_score": 0.01015, "epss_percentile": 0.76668}, "CVE-2017-3435": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3436": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3437": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3438": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3439": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3440": {"epss_score": 0.00747, "epss_percentile": 0.72572}, "CVE-2017-3441": {"epss_score": 0.00845, "epss_percentile": 0.74315}, "CVE-2017-3442": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2017-3443": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3444": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3445": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3446": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2017-3450": {"epss_score": 0.01049, "epss_percentile": 0.77062}, "CVE-2017-3451": {"epss_score": 0.00198, "epss_percentile": 0.41976}, "CVE-2017-3452": {"epss_score": 0.00593, "epss_percentile": 0.68649}, "CVE-2017-3453": {"epss_score": 0.00321, "epss_percentile": 0.54647}, "CVE-2017-3454": {"epss_score": 0.00368, "epss_percentile": 0.58207}, "CVE-2017-3455": {"epss_score": 0.00356, "epss_percentile": 0.57394}, "CVE-2017-3456": {"epss_score": 0.0018, "epss_percentile": 0.39977}, "CVE-2017-3457": {"epss_score": 0.0047, "epss_percentile": 0.63972}, "CVE-2017-3458": {"epss_score": 0.0047, "epss_percentile": 0.63972}, "CVE-2017-3459": {"epss_score": 0.0047, "epss_percentile": 0.63972}, "CVE-2017-3460": {"epss_score": 0.0047, "epss_percentile": 0.63972}, "CVE-2017-3461": {"epss_score": 0.00543, "epss_percentile": 0.67095}, "CVE-2017-3462": {"epss_score": 0.00585, "epss_percentile": 0.68415}, "CVE-2017-3463": {"epss_score": 0.00543, "epss_percentile": 0.67095}, "CVE-2017-3464": {"epss_score": 0.00166, "epss_percentile": 0.38167}, "CVE-2017-3465": {"epss_score": 0.00339, "epss_percentile": 0.56198}, "CVE-2017-3467": {"epss_score": 0.00566, "epss_percentile": 0.67816}, "CVE-2017-3468": {"epss_score": 0.00204, "epss_percentile": 0.42661}, "CVE-2017-3469": {"epss_score": 0.00323, "epss_percentile": 0.54868}, "CVE-2017-3470": {"epss_score": 0.01469, "epss_percentile": 0.80487}, "CVE-2017-3471": {"epss_score": 0.00642, "epss_percentile": 0.7003}, "CVE-2017-3472": {"epss_score": 0.00474, "epss_percentile": 0.64168}, "CVE-2017-3473": {"epss_score": 0.00249, "epss_percentile": 0.48036}, "CVE-2017-3474": {"epss_score": 0.00096, "epss_percentile": 0.27405}, "CVE-2017-3475": {"epss_score": 0.00394, "epss_percentile": 0.59778}, "CVE-2017-3476": {"epss_score": 0.00282, "epss_percentile": 0.51235}, "CVE-2017-3477": {"epss_score": 0.00221, "epss_percentile": 0.44711}, "CVE-2017-3478": {"epss_score": 0.00221, "epss_percentile": 0.44711}, "CVE-2017-3479": {"epss_score": 0.00382, "epss_percentile": 0.59078}, "CVE-2017-3480": {"epss_score": 0.00516, "epss_percentile": 0.6606}, "CVE-2017-3481": {"epss_score": 0.00394, "epss_percentile": 0.59778}, "CVE-2017-3482": {"epss_score": 0.00234, "epss_percentile": 0.46119}, "CVE-2017-3483": {"epss_score": 0.00149, "epss_percentile": 0.35944}, "CVE-2017-3484": {"epss_score": 0.00221, "epss_percentile": 0.44711}, "CVE-2017-3485": {"epss_score": 0.00397, "epss_percentile": 0.59982}, "CVE-2017-3486": {"epss_score": 0.0012, "epss_percentile": 0.31715}, "CVE-2017-3487": {"epss_score": 0.00252, "epss_percentile": 0.48375}, "CVE-2017-3488": {"epss_score": 0.00306, "epss_percentile": 0.5343}, "CVE-2017-3489": {"epss_score": 0.00221, "epss_percentile": 0.44711}, "CVE-2017-3490": {"epss_score": 0.00249, "epss_percentile": 0.48036}, "CVE-2017-3491": {"epss_score": 0.00349, "epss_percentile": 0.56902}, "CVE-2017-3492": {"epss_score": 0.00221, "epss_percentile": 0.44711}, "CVE-2017-3493": {"epss_score": 0.00724, "epss_percentile": 0.72032}, "CVE-2017-3494": {"epss_score": 0.00484, "epss_percentile": 0.64672}, "CVE-2017-3495": {"epss_score": 0.00516, "epss_percentile": 0.6606}, "CVE-2017-3496": {"epss_score": 0.00501, "epss_percentile": 0.65362}, "CVE-2017-3497": {"epss_score": 0.00649, "epss_percentile": 0.70227}, "CVE-2017-3498": {"epss_score": 0.00071, "epss_percentile": 0.2208}, "CVE-2017-3499": {"epss_score": 0.00896, "epss_percentile": 0.7512}, "CVE-2017-3500": {"epss_score": 0.00541, "epss_percentile": 0.67027}, "CVE-2017-3501": {"epss_score": 0.00501, "epss_percentile": 0.65362}, "CVE-2017-3502": {"epss_score": 0.00608, "epss_percentile": 0.69069}, "CVE-2017-3503": {"epss_score": 0.01067, "epss_percentile": 0.77226}, "CVE-2017-3504": {"epss_score": 0.00193, "epss_percentile": 0.41464}, "CVE-2017-3505": {"epss_score": 0.00193, "epss_percentile": 0.41464}, "CVE-2017-3506": {"epss_score": 0.94393, "epss_percentile": 0.9997}, "CVE-2017-3507": {"epss_score": 0.00792, "epss_percentile": 0.73416}, "CVE-2017-3508": {"epss_score": 0.02754, "epss_percentile": 0.85587}, "CVE-2017-3509": {"epss_score": 0.00717, "epss_percentile": 0.7188}, "CVE-2017-3510": {"epss_score": 0.00479, "epss_percentile": 0.64434}, "CVE-2017-3511": {"epss_score": 0.01597, "epss_percentile": 0.81246}, "CVE-2017-3512": {"epss_score": 0.05127, "epss_percentile": 0.89525}, "CVE-2017-3513": {"epss_score": 0.00066, "epss_percentile": 0.20739}, "CVE-2017-3514": {"epss_score": 0.01199, "epss_percentile": 0.78465}, "CVE-2017-3515": {"epss_score": 0.00501, "epss_percentile": 0.65362}, "CVE-2017-3516": {"epss_score": 0.00393, "epss_percentile": 0.59735}, "CVE-2017-3517": {"epss_score": 0.00946, "epss_percentile": 0.75805}, "CVE-2017-3518": {"epss_score": 0.01871, "epss_percentile": 0.82635}, "CVE-2017-3519": {"epss_score": 0.00896, "epss_percentile": 0.7512}, "CVE-2017-3520": {"epss_score": 0.01576, "epss_percentile": 0.81113}, "CVE-2017-3521": {"epss_score": 0.00462, "epss_percentile": 0.63578}, "CVE-2017-3522": {"epss_score": 0.00462, "epss_percentile": 0.63578}, "CVE-2017-3523": {"epss_score": 0.01378, "epss_percentile": 0.7985}, "CVE-2017-3524": {"epss_score": 0.00462, "epss_percentile": 0.63578}, "CVE-2017-3525": {"epss_score": 0.00462, "epss_percentile": 0.63578}, "CVE-2017-3526": {"epss_score": 0.01924, "epss_percentile": 0.82917}, "CVE-2017-3527": {"epss_score": 0.00489, "epss_percentile": 0.64897}, "CVE-2017-3528": {"epss_score": 0.43239, "epss_percentile": 0.97377}, "CVE-2017-3529": {"epss_score": 0.00511, "epss_percentile": 0.65821}, "CVE-2017-3530": {"epss_score": 0.00379, "epss_percentile": 0.5885}, "CVE-2017-3531": {"epss_score": 0.01192, "epss_percentile": 0.78399}, "CVE-2017-3532": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2017-3533": {"epss_score": 0.00648, "epss_percentile": 0.7022}, "CVE-2017-3534": {"epss_score": 0.00317, "epss_percentile": 0.54336}, "CVE-2017-3535": {"epss_score": 0.00516, "epss_percentile": 0.6606}, "CVE-2017-3536": {"epss_score": 0.00234, "epss_percentile": 0.46119}, "CVE-2017-3537": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2017-3538": {"epss_score": 0.00081, "epss_percentile": 0.24366}, "CVE-2017-3539": {"epss_score": 0.00731, "epss_percentile": 0.72172}, "CVE-2017-3540": {"epss_score": 0.01139, "epss_percentile": 0.77939}, "CVE-2017-3541": {"epss_score": 0.00864, "epss_percentile": 0.74609}, "CVE-2017-3542": {"epss_score": 0.01691, "epss_percentile": 0.81779}, "CVE-2017-3543": {"epss_score": 0.01691, "epss_percentile": 0.81779}, "CVE-2017-3544": {"epss_score": 0.0038, "epss_percentile": 0.58928}, "CVE-2017-3545": {"epss_score": 0.02966, "epss_percentile": 0.86082}, "CVE-2017-3546": {"epss_score": 0.02322, "epss_percentile": 0.84372}, "CVE-2017-3547": {"epss_score": 0.03139, "epss_percentile": 0.86484}, "CVE-2017-3548": {"epss_score": 0.51785, "epss_percentile": 0.97797}, "CVE-2017-3549": {"epss_score": 0.31006, "epss_percentile": 0.96581}, "CVE-2017-3550": {"epss_score": 0.00971, "epss_percentile": 0.76127}, "CVE-2017-3551": {"epss_score": 0.00062, "epss_percentile": 0.19781}, "CVE-2017-3552": {"epss_score": 0.0021, "epss_percentile": 0.43487}, "CVE-2017-3553": {"epss_score": 0.00866, "epss_percentile": 0.7463}, "CVE-2017-3554": {"epss_score": 0.0045, "epss_percentile": 0.6309}, "CVE-2017-3555": {"epss_score": 0.02878, "epss_percentile": 0.8589}, "CVE-2017-3556": {"epss_score": 0.00573, "epss_percentile": 0.68042}, "CVE-2017-3557": {"epss_score": 0.01868, "epss_percentile": 0.82622}, "CVE-2017-3558": {"epss_score": 0.00157, "epss_percentile": 0.37057}, "CVE-2017-3559": {"epss_score": 0.00058, "epss_percentile": 0.18285}, "CVE-2017-3560": {"epss_score": 0.0021, "epss_percentile": 0.43487}, "CVE-2017-3561": {"epss_score": 0.00221, "epss_percentile": 0.44709}, "CVE-2017-3562": {"epss_score": 0.01109, "epss_percentile": 0.77653}, "CVE-2017-3563": {"epss_score": 0.00212, "epss_percentile": 0.43774}, "CVE-2017-3564": {"epss_score": 0.00084, "epss_percentile": 0.24962}, "CVE-2017-3565": {"epss_score": 0.00133, "epss_percentile": 0.33743}, "CVE-2017-3567": {"epss_score": 0.00429, "epss_percentile": 0.61988}, "CVE-2017-3568": {"epss_score": 0.00312, "epss_percentile": 0.5395}, "CVE-2017-3569": {"epss_score": 0.00187, "epss_percentile": 0.40747}, "CVE-2017-3570": {"epss_score": 0.00462, "epss_percentile": 0.63578}, "CVE-2017-3571": {"epss_score": 0.0147, "epss_percentile": 0.80497}, "CVE-2017-3572": {"epss_score": 0.01656, "epss_percentile": 0.81596}, "CVE-2017-3573": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2017-3574": {"epss_score": 0.00327, "epss_percentile": 0.55148}, "CVE-2017-3575": {"epss_score": 0.00525, "epss_percentile": 0.6637}, "CVE-2017-3576": {"epss_score": 0.00221, "epss_percentile": 0.44709}, "CVE-2017-3577": {"epss_score": 0.00462, "epss_percentile": 0.63578}, "CVE-2017-3578": {"epss_score": 0.00085, "epss_percentile": 0.25095}, "CVE-2017-3579": {"epss_score": 0.00488, "epss_percentile": 0.64848}, "CVE-2017-3580": {"epss_score": 0.01578, "epss_percentile": 0.81125}, "CVE-2017-3581": {"epss_score": 0.00079, "epss_percentile": 0.23807}, "CVE-2017-3582": {"epss_score": 0.00198, "epss_percentile": 0.42052}, "CVE-2017-3583": {"epss_score": 0.00949, "epss_percentile": 0.75848}, "CVE-2017-3584": {"epss_score": 0.00085, "epss_percentile": 0.25095}, "CVE-2017-3585": {"epss_score": 0.00608, "epss_percentile": 0.69069}, "CVE-2017-3586": {"epss_score": 0.0056, "epss_percentile": 0.67654}, "CVE-2017-3587": {"epss_score": 0.00265, "epss_percentile": 0.49784}, "CVE-2017-3588": {"epss_score": 0.00278, "epss_percentile": 0.50857}, "CVE-2017-3589": {"epss_score": 0.00073, "epss_percentile": 0.22629}, "CVE-2017-3590": {"epss_score": 0.00067, "epss_percentile": 0.21182}, "CVE-2017-3591": {"epss_score": 0.00946, "epss_percentile": 0.75806}, "CVE-2017-3592": {"epss_score": 0.00358, "epss_percentile": 0.57538}, "CVE-2017-3593": {"epss_score": 0.0066, "epss_percentile": 0.70531}, "CVE-2017-3594": {"epss_score": 0.00427, "epss_percentile": 0.61899}, "CVE-2017-3595": {"epss_score": 0.00282, "epss_percentile": 0.51235}, "CVE-2017-3596": {"epss_score": 0.00645, "epss_percentile": 0.70099}, "CVE-2017-3597": {"epss_score": 0.00307, "epss_percentile": 0.53499}, "CVE-2017-3598": {"epss_score": 0.00228, "epss_percentile": 0.45521}, "CVE-2017-3599": {"epss_score": 0.87337, "epss_percentile": 0.99425}, "CVE-2017-3600": {"epss_score": 0.00811, "epss_percentile": 0.73728}, "CVE-2017-3601": {"epss_score": 0.01381, "epss_percentile": 0.7987}, "CVE-2017-3602": {"epss_score": 0.00474, "epss_percentile": 0.64168}, "CVE-2017-3603": {"epss_score": 0.00228, "epss_percentile": 0.45521}, "CVE-2017-3604": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2017-3605": {"epss_score": 0.00633, "epss_percentile": 0.69786}, "CVE-2017-3606": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2017-3607": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2017-3608": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2017-3609": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2017-3610": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2017-3611": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2017-3612": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2017-3613": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2017-3614": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2017-3615": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2017-3616": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2017-3617": {"epss_score": 0.00633, "epss_percentile": 0.69786}, "CVE-2017-3618": {"epss_score": 0.00093, "epss_percentile": 0.2671}, "CVE-2017-3619": {"epss_score": 0.0011, "epss_percentile": 0.3023}, "CVE-2017-3620": {"epss_score": 0.00079, "epss_percentile": 0.23807}, "CVE-2017-3621": {"epss_score": 0.01871, "epss_percentile": 0.82635}, "CVE-2017-3622": {"epss_score": 0.19606, "epss_percentile": 0.95214}, "CVE-2017-3623": {"epss_score": 0.76943, "epss_percentile": 0.98911}, "CVE-2017-3625": {"epss_score": 0.00618, "epss_percentile": 0.69384}, "CVE-2017-3626": {"epss_score": 0.00473, "epss_percentile": 0.64093}, "CVE-2017-3629": {"epss_score": 0.31431, "epss_percentile": 0.9662}, "CVE-2017-3630": {"epss_score": 0.11937, "epss_percentile": 0.93521}, "CVE-2017-3631": {"epss_score": 0.11937, "epss_percentile": 0.93521}, "CVE-2017-3632": {"epss_score": 0.10282, "epss_percentile": 0.92926}, "CVE-2017-3633": {"epss_score": 0.00799, "epss_percentile": 0.73521}, "CVE-2017-3634": {"epss_score": 0.00429, "epss_percentile": 0.61991}, "CVE-2017-3635": {"epss_score": 0.00635, "epss_percentile": 0.69827}, "CVE-2017-3636": {"epss_score": 0.00075, "epss_percentile": 0.2291}, "CVE-2017-3637": {"epss_score": 0.00441, "epss_percentile": 0.62678}, "CVE-2017-3638": {"epss_score": 0.00349, "epss_percentile": 0.56886}, "CVE-2017-3639": {"epss_score": 0.00349, "epss_percentile": 0.56886}, "CVE-2017-3640": {"epss_score": 0.00349, "epss_percentile": 0.56886}, "CVE-2017-3641": {"epss_score": 0.00187, "epss_percentile": 0.40774}, "CVE-2017-3642": {"epss_score": 0.00349, "epss_percentile": 0.56886}, "CVE-2017-3643": {"epss_score": 0.00349, "epss_percentile": 0.56886}, "CVE-2017-3644": {"epss_score": 0.00349, "epss_percentile": 0.56886}, "CVE-2017-3645": {"epss_score": 0.00349, "epss_percentile": 0.56886}, "CVE-2017-3646": {"epss_score": 0.00349, "epss_percentile": 0.56886}, "CVE-2017-3647": {"epss_score": 0.00406, "epss_percentile": 0.60525}, "CVE-2017-3648": {"epss_score": 0.00543, "epss_percentile": 0.67095}, "CVE-2017-3649": {"epss_score": 0.00406, "epss_percentile": 0.60525}, "CVE-2017-3650": {"epss_score": 0.00566, "epss_percentile": 0.67816}, "CVE-2017-3651": {"epss_score": 0.00414, "epss_percentile": 0.61024}, "CVE-2017-3652": {"epss_score": 0.00426, "epss_percentile": 0.61769}, "CVE-2017-3653": {"epss_score": 0.00199, "epss_percentile": 0.42113}, "CVE-2017-3718": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2017-3730": {"epss_score": 0.46035, "epss_percentile": 0.97518}, "CVE-2017-3731": {"epss_score": 0.14955, "epss_percentile": 0.94333}, "CVE-2017-3732": {"epss_score": 0.07578, "epss_percentile": 0.9155}, "CVE-2017-3733": {"epss_score": 0.05892, "epss_percentile": 0.903}, "CVE-2017-3735": {"epss_score": 0.3668, "epss_percentile": 0.96994}, "CVE-2017-3736": {"epss_score": 0.06716, "epss_percentile": 0.90964}, "CVE-2017-3737": {"epss_score": 0.42931, "epss_percentile": 0.97362}, "CVE-2017-3738": {"epss_score": 0.13961, "epss_percentile": 0.94101}, "CVE-2017-3740": {"epss_score": 0.00022, "epss_percentile": 0.05001}, "CVE-2017-3741": {"epss_score": 0.00051, "epss_percentile": 0.16322}, "CVE-2017-3742": {"epss_score": 0.00041, "epss_percentile": 0.12336}, "CVE-2017-3743": {"epss_score": 0.00354, "epss_percentile": 0.57219}, "CVE-2017-3744": {"epss_score": 0.00264, "epss_percentile": 0.49749}, "CVE-2017-3745": {"epss_score": 0.00097, "epss_percentile": 0.27539}, "CVE-2017-3746": {"epss_score": 0.00064, "epss_percentile": 0.20405}, "CVE-2017-3747": {"epss_score": 0.00054, "epss_percentile": 0.17198}, "CVE-2017-3748": {"epss_score": 0.00016, "epss_percentile": 0.02699}, "CVE-2017-3749": {"epss_score": 0.00014, "epss_percentile": 0.02116}, "CVE-2017-3750": {"epss_score": 0.00014, "epss_percentile": 0.02116}, "CVE-2017-3751": {"epss_score": 0.00044, "epss_percentile": 0.13628}, "CVE-2017-3752": {"epss_score": 0.00146, "epss_percentile": 0.35533}, "CVE-2017-3753": {"epss_score": 0.0005, "epss_percentile": 0.15927}, "CVE-2017-3754": {"epss_score": 0.00043, "epss_percentile": 0.13026}, "CVE-2017-3756": {"epss_score": 0.00064, "epss_percentile": 0.20405}, "CVE-2017-3757": {"epss_score": 0.00044, "epss_percentile": 0.13628}, "CVE-2017-3758": {"epss_score": 0.02362, "epss_percentile": 0.84505}, "CVE-2017-3759": {"epss_score": 0.01425, "epss_percentile": 0.80195}, "CVE-2017-3760": {"epss_score": 0.0083, "epss_percentile": 0.74028}, "CVE-2017-3761": {"epss_score": 0.04521, "epss_percentile": 0.888}, "CVE-2017-3762": {"epss_score": 0.0016, "epss_percentile": 0.37424}, "CVE-2017-3763": {"epss_score": 0.00053, "epss_percentile": 0.1689}, "CVE-2017-3764": {"epss_score": 0.00734, "epss_percentile": 0.72219}, "CVE-2017-3765": {"epss_score": 0.00036, "epss_percentile": 0.1045}, "CVE-2017-3767": {"epss_score": 0.00036, "epss_percentile": 0.10509}, "CVE-2017-3768": {"epss_score": 0.00693, "epss_percentile": 0.71321}, "CVE-2017-3770": {"epss_score": 0.00461, "epss_percentile": 0.63555}, "CVE-2017-3771": {"epss_score": 0.00202, "epss_percentile": 0.42436}, "CVE-2017-3772": {"epss_score": 0.00077, "epss_percentile": 0.23346}, "CVE-2017-3774": {"epss_score": 0.00585, "epss_percentile": 0.68407}, "CVE-2017-3775": {"epss_score": 0.00042, "epss_percentile": 0.12605}, "CVE-2017-3776": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2017-3790": {"epss_score": 0.00302, "epss_percentile": 0.53131}, "CVE-2017-3791": {"epss_score": 0.15662, "epss_percentile": 0.94479}, "CVE-2017-3792": {"epss_score": 0.01859, "epss_percentile": 0.82585}, "CVE-2017-3793": {"epss_score": 0.00407, "epss_percentile": 0.60584}, "CVE-2017-3794": {"epss_score": 0.00217, "epss_percentile": 0.44326}, "CVE-2017-3795": {"epss_score": 0.00113, "epss_percentile": 0.30664}, "CVE-2017-3796": {"epss_score": 0.00934, "epss_percentile": 0.75661}, "CVE-2017-3797": {"epss_score": 0.00328, "epss_percentile": 0.55273}, "CVE-2017-3798": {"epss_score": 0.00567, "epss_percentile": 0.67863}, "CVE-2017-3799": {"epss_score": 0.00211, "epss_percentile": 0.4371}, "CVE-2017-3800": {"epss_score": 0.00207, "epss_percentile": 0.43177}, "CVE-2017-3801": {"epss_score": 0.0005, "epss_percentile": 0.15968}, "CVE-2017-3802": {"epss_score": 0.00293, "epss_percentile": 0.52291}, "CVE-2017-3803": {"epss_score": 0.00171, "epss_percentile": 0.38829}, "CVE-2017-3804": {"epss_score": 0.00342, "epss_percentile": 0.56382}, "CVE-2017-3805": {"epss_score": 0.00328, "epss_percentile": 0.55273}, "CVE-2017-3806": {"epss_score": 0.00097, "epss_percentile": 0.27544}, "CVE-2017-3807": {"epss_score": 0.13796, "epss_percentile": 0.94059}, "CVE-2017-3808": {"epss_score": 0.00541, "epss_percentile": 0.6705}, "CVE-2017-3809": {"epss_score": 0.00586, "epss_percentile": 0.68448}, "CVE-2017-3810": {"epss_score": 0.00278, "epss_percentile": 0.50887}, "CVE-2017-3811": {"epss_score": 0.00325, "epss_percentile": 0.55005}, "CVE-2017-3812": {"epss_score": 0.00687, "epss_percentile": 0.71181}, "CVE-2017-3813": {"epss_score": 0.04649, "epss_percentile": 0.88963}, "CVE-2017-3814": {"epss_score": 0.00317, "epss_percentile": 0.54353}, "CVE-2017-3815": {"epss_score": 0.0013, "epss_percentile": 0.33276}, "CVE-2017-3817": {"epss_score": 0.00141, "epss_percentile": 0.3494}, "CVE-2017-3818": {"epss_score": 0.00207, "epss_percentile": 0.43177}, "CVE-2017-3819": {"epss_score": 0.00638, "epss_percentile": 0.69925}, "CVE-2017-3820": {"epss_score": 0.00618, "epss_percentile": 0.69371}, "CVE-2017-3821": {"epss_score": 0.00357, "epss_percentile": 0.57406}, "CVE-2017-3822": {"epss_score": 0.00299, "epss_percentile": 0.52841}, "CVE-2017-3823": {"epss_score": 0.80391, "epss_percentile": 0.99085}, "CVE-2017-3824": {"epss_score": 0.00541, "epss_percentile": 0.6705}, "CVE-2017-3825": {"epss_score": 0.00419, "epss_percentile": 0.61389}, "CVE-2017-3826": {"epss_score": 0.00434, "epss_percentile": 0.62309}, "CVE-2017-3827": {"epss_score": 0.00361, "epss_percentile": 0.57711}, "CVE-2017-3828": {"epss_score": 0.0032, "epss_percentile": 0.54608}, "CVE-2017-3829": {"epss_score": 0.0032, "epss_percentile": 0.54608}, "CVE-2017-3830": {"epss_score": 0.00631, "epss_percentile": 0.69733}, "CVE-2017-3831": {"epss_score": 0.06116, "epss_percentile": 0.9049}, "CVE-2017-3832": {"epss_score": 0.01611, "epss_percentile": 0.81329}, "CVE-2017-3833": {"epss_score": 0.0027, "epss_percentile": 0.50243}, "CVE-2017-3834": {"epss_score": 0.06232, "epss_percentile": 0.90587}, "CVE-2017-3835": {"epss_score": 0.00725, "epss_percentile": 0.72058}, "CVE-2017-3836": {"epss_score": 0.00283, "epss_percentile": 0.51395}, "CVE-2017-3837": {"epss_score": 0.00786, "epss_percentile": 0.73299}, "CVE-2017-3838": {"epss_score": 0.0032, "epss_percentile": 0.54608}, "CVE-2017-3839": {"epss_score": 0.00397, "epss_percentile": 0.6005}, "CVE-2017-3840": {"epss_score": 0.00278, "epss_percentile": 0.50902}, "CVE-2017-3841": {"epss_score": 0.00441, "epss_percentile": 0.62691}, "CVE-2017-3842": {"epss_score": 0.00359, "epss_percentile": 0.5759}, "CVE-2017-3843": {"epss_score": 0.00204, "epss_percentile": 0.42656}, "CVE-2017-3844": {"epss_score": 0.00204, "epss_percentile": 0.42656}, "CVE-2017-3845": {"epss_score": 0.0032, "epss_percentile": 0.54608}, "CVE-2017-3846": {"epss_score": 0.00221, "epss_percentile": 0.4467}, "CVE-2017-3847": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2017-3848": {"epss_score": 0.00293, "epss_percentile": 0.52291}, "CVE-2017-3849": {"epss_score": 0.00126, "epss_percentile": 0.32733}, "CVE-2017-3850": {"epss_score": 0.00395, "epss_percentile": 0.59833}, "CVE-2017-3851": {"epss_score": 0.0762, "epss_percentile": 0.91575}, "CVE-2017-3852": {"epss_score": 0.00789, "epss_percentile": 0.73359}, "CVE-2017-3853": {"epss_score": 0.01727, "epss_percentile": 0.81967}, "CVE-2017-3854": {"epss_score": 0.01359, "epss_percentile": 0.79738}, "CVE-2017-3856": {"epss_score": 0.00859, "epss_percentile": 0.74518}, "CVE-2017-3857": {"epss_score": 0.01141, "epss_percentile": 0.77959}, "CVE-2017-3858": {"epss_score": 0.00665, "epss_percentile": 0.70657}, "CVE-2017-3859": {"epss_score": 0.00344, "epss_percentile": 0.56482}, "CVE-2017-3860": {"epss_score": 0.00683, "epss_percentile": 0.71096}, "CVE-2017-3861": {"epss_score": 0.00683, "epss_percentile": 0.71096}, "CVE-2017-3862": {"epss_score": 0.00683, "epss_percentile": 0.71096}, "CVE-2017-3863": {"epss_score": 0.00683, "epss_percentile": 0.71096}, "CVE-2017-3864": {"epss_score": 0.01125, "epss_percentile": 0.77805}, "CVE-2017-3865": {"epss_score": 0.0082, "epss_percentile": 0.7389}, "CVE-2017-3866": {"epss_score": 0.00293, "epss_percentile": 0.52291}, "CVE-2017-3867": {"epss_score": 0.00187, "epss_percentile": 0.40725}, "CVE-2017-3868": {"epss_score": 0.00293, "epss_percentile": 0.52291}, "CVE-2017-3869": {"epss_score": 0.00174, "epss_percentile": 0.39215}, "CVE-2017-3870": {"epss_score": 0.00254, "epss_percentile": 0.48496}, "CVE-2017-3871": {"epss_score": 0.00145, "epss_percentile": 0.35458}, "CVE-2017-3872": {"epss_score": 0.00439, "epss_percentile": 0.62598}, "CVE-2017-3873": {"epss_score": 0.00254, "epss_percentile": 0.4853}, "CVE-2017-3874": {"epss_score": 0.00203, "epss_percentile": 0.42527}, "CVE-2017-3875": {"epss_score": 0.00248, "epss_percentile": 0.4793}, "CVE-2017-3876": {"epss_score": 0.00734, "epss_percentile": 0.72244}, "CVE-2017-3877": {"epss_score": 0.00142, "epss_percentile": 0.34999}, "CVE-2017-3878": {"epss_score": 0.00873, "epss_percentile": 0.74743}, "CVE-2017-3879": {"epss_score": 0.00873, "epss_percentile": 0.74743}, "CVE-2017-3880": {"epss_score": 0.00379, "epss_percentile": 0.58887}, "CVE-2017-3881": {"epss_score": 0.94282, "epss_percentile": 0.99933}, "CVE-2017-3882": {"epss_score": 0.00786, "epss_percentile": 0.73265}, "CVE-2017-3883": {"epss_score": 0.02619, "epss_percentile": 0.85253}, "CVE-2017-3884": {"epss_score": 0.00231, "epss_percentile": 0.45846}, "CVE-2017-3885": {"epss_score": 0.00453, "epss_percentile": 0.63223}, "CVE-2017-3886": {"epss_score": 0.00204, "epss_percentile": 0.42655}, "CVE-2017-3887": {"epss_score": 0.00558, "epss_percentile": 0.676}, "CVE-2017-3888": {"epss_score": 0.00203, "epss_percentile": 0.42527}, "CVE-2017-3889": {"epss_score": 0.00266, "epss_percentile": 0.49913}, "CVE-2017-3890": {"epss_score": 0.00292, "epss_percentile": 0.52243}, "CVE-2017-3891": {"epss_score": 0.00299, "epss_percentile": 0.52849}, "CVE-2017-3892": {"epss_score": 0.00194, "epss_percentile": 0.41519}, "CVE-2017-3893": {"epss_score": 0.00205, "epss_percentile": 0.42746}, "CVE-2017-3894": {"epss_score": 0.00356, "epss_percentile": 0.57393}, "CVE-2017-3896": {"epss_score": 0.0095, "epss_percentile": 0.75853}, "CVE-2017-3897": {"epss_score": 0.08254, "epss_percentile": 0.91951}, "CVE-2017-3898": {"epss_score": 0.04169, "epss_percentile": 0.88344}, "CVE-2017-3899": {"epss_score": 0.00507, "epss_percentile": 0.65674}, "CVE-2017-3902": {"epss_score": 0.00341, "epss_percentile": 0.56322}, "CVE-2017-3907": {"epss_score": 0.00465, "epss_percentile": 0.63761}, "CVE-2017-3912": {"epss_score": 0.00034, "epss_percentile": 0.09544}, "CVE-2017-3933": {"epss_score": 0.00179, "epss_percentile": 0.39787}, "CVE-2017-3934": {"epss_score": 0.00247, "epss_percentile": 0.47864}, "CVE-2017-3935": {"epss_score": 0.00251, "epss_percentile": 0.48292}, "CVE-2017-3936": {"epss_score": 0.05478, "epss_percentile": 0.89918}, "CVE-2017-3948": {"epss_score": 0.00288, "epss_percentile": 0.51921}, "CVE-2017-3960": {"epss_score": 0.00144, "epss_percentile": 0.35299}, "CVE-2017-3961": {"epss_score": 0.00338, "epss_percentile": 0.56136}, "CVE-2017-3962": {"epss_score": 0.00047, "epss_percentile": 0.14892}, "CVE-2017-3964": {"epss_score": 0.00235, "epss_percentile": 0.46235}, "CVE-2017-3965": {"epss_score": 0.00179, "epss_percentile": 0.39843}, "CVE-2017-3966": {"epss_score": 0.00221, "epss_percentile": 0.44631}, "CVE-2017-3967": {"epss_score": 0.00196, "epss_percentile": 0.41748}, "CVE-2017-3968": {"epss_score": 0.00511, "epss_percentile": 0.65837}, "CVE-2017-3969": {"epss_score": 0.00231, "epss_percentile": 0.45857}, "CVE-2017-3971": {"epss_score": 0.00067, "epss_percentile": 0.21057}, "CVE-2017-3972": {"epss_score": 0.00854, "epss_percentile": 0.74454}, "CVE-2017-3980": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2017-4011": {"epss_score": 0.1089, "epss_percentile": 0.93147}, "CVE-2017-4012": {"epss_score": 0.00282, "epss_percentile": 0.51268}, "CVE-2017-4013": {"epss_score": 0.0023, "epss_percentile": 0.45762}, "CVE-2017-4014": {"epss_score": 0.004, "epss_percentile": 0.60185}, "CVE-2017-4015": {"epss_score": 0.00224, "epss_percentile": 0.44979}, "CVE-2017-4016": {"epss_score": 0.00212, "epss_percentile": 0.43808}, "CVE-2017-4017": {"epss_score": 0.00212, "epss_percentile": 0.43808}, "CVE-2017-4028": {"epss_score": 0.00054, "epss_percentile": 0.1731}, "CVE-2017-4052": {"epss_score": 0.00395, "epss_percentile": 0.59836}, "CVE-2017-4053": {"epss_score": 0.04427, "epss_percentile": 0.88676}, "CVE-2017-4054": {"epss_score": 0.0429, "epss_percentile": 0.88501}, "CVE-2017-4055": {"epss_score": 0.00639, "epss_percentile": 0.6994}, "CVE-2017-4057": {"epss_score": 0.00952, "epss_percentile": 0.7588}, "CVE-2017-4895": {"epss_score": 0.00048, "epss_percentile": 0.15177}, "CVE-2017-4896": {"epss_score": 0.00047, "epss_percentile": 0.14861}, "CVE-2017-4897": {"epss_score": 0.00111, "epss_percentile": 0.30249}, "CVE-2017-4898": {"epss_score": 0.00114, "epss_percentile": 0.30828}, "CVE-2017-4899": {"epss_score": 0.00048, "epss_percentile": 0.15243}, "CVE-2017-4900": {"epss_score": 0.00046, "epss_percentile": 0.14292}, "CVE-2017-4901": {"epss_score": 0.20903, "epss_percentile": 0.95436}, "CVE-2017-4902": {"epss_score": 0.00062, "epss_percentile": 0.1976}, "CVE-2017-4903": {"epss_score": 0.00067, "epss_percentile": 0.21069}, "CVE-2017-4904": {"epss_score": 0.00102, "epss_percentile": 0.28778}, "CVE-2017-4905": {"epss_score": 0.02068, "epss_percentile": 0.83465}, "CVE-2017-4907": {"epss_score": 0.01989, "epss_percentile": 0.83169}, "CVE-2017-4908": {"epss_score": 0.00066, "epss_percentile": 0.20685}, "CVE-2017-4909": {"epss_score": 0.00066, "epss_percentile": 0.20685}, "CVE-2017-4910": {"epss_score": 0.00066, "epss_percentile": 0.20685}, "CVE-2017-4911": {"epss_score": 0.00066, "epss_percentile": 0.20685}, "CVE-2017-4912": {"epss_score": 0.00066, "epss_percentile": 0.20685}, "CVE-2017-4913": {"epss_score": 0.00057, "epss_percentile": 0.1806}, "CVE-2017-4914": {"epss_score": 0.13343, "epss_percentile": 0.93938}, "CVE-2017-4915": {"epss_score": 0.11558, "epss_percentile": 0.93404}, "CVE-2017-4916": {"epss_score": 0.09503, "epss_percentile": 0.92575}, "CVE-2017-4917": {"epss_score": 0.00081, "epss_percentile": 0.24314}, "CVE-2017-4918": {"epss_score": 0.03008, "epss_percentile": 0.8619}, "CVE-2017-4919": {"epss_score": 0.00915, "epss_percentile": 0.754}, "CVE-2017-4920": {"epss_score": 0.0029, "epss_percentile": 0.52096}, "CVE-2017-4921": {"epss_score": 0.00834, "epss_percentile": 0.74101}, "CVE-2017-4922": {"epss_score": 0.00444, "epss_percentile": 0.62826}, "CVE-2017-4923": {"epss_score": 0.00812, "epss_percentile": 0.73747}, "CVE-2017-4924": {"epss_score": 0.00255, "epss_percentile": 0.487}, "CVE-2017-4925": {"epss_score": 0.0019, "epss_percentile": 0.41099}, "CVE-2017-4926": {"epss_score": 0.00206, "epss_percentile": 0.43001}, "CVE-2017-4927": {"epss_score": 0.0142, "epss_percentile": 0.80166}, "CVE-2017-4928": {"epss_score": 0.00166, "epss_percentile": 0.38227}, "CVE-2017-4929": {"epss_score": 0.00222, "epss_percentile": 0.4484}, "CVE-2017-4930": {"epss_score": 0.00301, "epss_percentile": 0.52993}, "CVE-2017-4931": {"epss_score": 0.00217, "epss_percentile": 0.44293}, "CVE-2017-4932": {"epss_score": 0.00124, "epss_percentile": 0.32355}, "CVE-2017-4933": {"epss_score": 0.07078, "epss_percentile": 0.91234}, "CVE-2017-4934": {"epss_score": 0.0005, "epss_percentile": 0.15829}, "CVE-2017-4935": {"epss_score": 0.00063, "epss_percentile": 0.19852}, "CVE-2017-4936": {"epss_score": 0.00055, "epss_percentile": 0.17544}, "CVE-2017-4937": {"epss_score": 0.00063, "epss_percentile": 0.19852}, "CVE-2017-4938": {"epss_score": 0.00046, "epss_percentile": 0.14128}, "CVE-2017-4939": {"epss_score": 0.00186, "epss_percentile": 0.40613}, "CVE-2017-4940": {"epss_score": 0.00231, "epss_percentile": 0.4577}, "CVE-2017-4941": {"epss_score": 0.04776, "epss_percentile": 0.89131}, "CVE-2017-4942": {"epss_score": 0.00392, "epss_percentile": 0.59658}, "CVE-2017-4943": {"epss_score": 0.00034, "epss_percentile": 0.09529}, "CVE-2017-4945": {"epss_score": 0.00062, "epss_percentile": 0.19673}, "CVE-2017-4946": {"epss_score": 0.00312, "epss_percentile": 0.53935}, "CVE-2017-4947": {"epss_score": 0.26641, "epss_percentile": 0.96164}, "CVE-2017-4948": {"epss_score": 0.0004, "epss_percentile": 0.12176}, "CVE-2017-4949": {"epss_score": 0.00071, "epss_percentile": 0.22046}, "CVE-2017-4950": {"epss_score": 0.00047, "epss_percentile": 0.14573}, "CVE-2017-4951": {"epss_score": 0.0018, "epss_percentile": 0.39918}, "CVE-2017-4952": {"epss_score": 0.01924, "epss_percentile": 0.82916}, "CVE-2017-4955": {"epss_score": 0.00411, "epss_percentile": 0.60851}, "CVE-2017-4959": {"epss_score": 0.00526, "epss_percentile": 0.66435}, "CVE-2017-4960": {"epss_score": 0.00451, "epss_percentile": 0.63118}, "CVE-2017-4961": {"epss_score": 0.002, "epss_percentile": 0.42249}, "CVE-2017-4963": {"epss_score": 0.00387, "epss_percentile": 0.59314}, "CVE-2017-4964": {"epss_score": 0.00159, "epss_percentile": 0.37413}, "CVE-2017-4965": {"epss_score": 0.00601, "epss_percentile": 0.68842}, "CVE-2017-4966": {"epss_score": 0.00119, "epss_percentile": 0.31583}, "CVE-2017-4967": {"epss_score": 0.00425, "epss_percentile": 0.61686}, "CVE-2017-4969": {"epss_score": 0.00383, "epss_percentile": 0.59092}, "CVE-2017-4970": {"epss_score": 0.00227, "epss_percentile": 0.45396}, "CVE-2017-4971": {"epss_score": 0.75359, "epss_percentile": 0.9884}, "CVE-2017-4972": {"epss_score": 0.00278, "epss_percentile": 0.50855}, "CVE-2017-4973": {"epss_score": 0.00311, "epss_percentile": 0.53841}, "CVE-2017-4974": {"epss_score": 0.00282, "epss_percentile": 0.51253}, "CVE-2017-4975": {"epss_score": 0.00206, "epss_percentile": 0.43045}, "CVE-2017-4976": {"epss_score": 0.0131, "epss_percentile": 0.79361}, "CVE-2017-4977": {"epss_score": 0.00072, "epss_percentile": 0.22301}, "CVE-2017-4978": {"epss_score": 0.0021, "epss_percentile": 0.43499}, "CVE-2017-4979": {"epss_score": 0.00349, "epss_percentile": 0.56916}, "CVE-2017-4980": {"epss_score": 0.02676, "epss_percentile": 0.85403}, "CVE-2017-4981": {"epss_score": 0.00603, "epss_percentile": 0.68903}, "CVE-2017-4982": {"epss_score": 0.00967, "epss_percentile": 0.76068}, "CVE-2017-4983": {"epss_score": 0.0008, "epss_percentile": 0.24125}, "CVE-2017-4984": {"epss_score": 0.03514, "epss_percentile": 0.87271}, "CVE-2017-4985": {"epss_score": 0.00038, "epss_percentile": 0.1128}, "CVE-2017-4986": {"epss_score": 0.00421, "epss_percentile": 0.61495}, "CVE-2017-4987": {"epss_score": 0.00072, "epss_percentile": 0.2231}, "CVE-2017-4988": {"epss_score": 0.00499, "epss_percentile": 0.6525}, "CVE-2017-4989": {"epss_score": 0.02972, "epss_percentile": 0.86098}, "CVE-2017-4990": {"epss_score": 0.02261, "epss_percentile": 0.84187}, "CVE-2017-4991": {"epss_score": 0.0028, "epss_percentile": 0.51016}, "CVE-2017-4992": {"epss_score": 0.00387, "epss_percentile": 0.59314}, "CVE-2017-4994": {"epss_score": 0.00255, "epss_percentile": 0.48642}, "CVE-2017-4995": {"epss_score": 0.00826, "epss_percentile": 0.7396}, "CVE-2017-4997": {"epss_score": 0.05221, "epss_percentile": 0.89625}, "CVE-2017-4998": {"epss_score": 0.00384, "epss_percentile": 0.5915}, "CVE-2017-4999": {"epss_score": 0.00451, "epss_percentile": 0.63112}, "CVE-2017-5000": {"epss_score": 0.00202, "epss_percentile": 0.42438}, "CVE-2017-5001": {"epss_score": 0.00202, "epss_percentile": 0.42438}, "CVE-2017-5002": {"epss_score": 0.00278, "epss_percentile": 0.50922}, "CVE-2017-5003": {"epss_score": 0.00285, "epss_percentile": 0.51547}, "CVE-2017-5004": {"epss_score": 0.00237, "epss_percentile": 0.46665}, "CVE-2017-5005": {"epss_score": 0.30622, "epss_percentile": 0.96556}, "CVE-2017-5006": {"epss_score": 0.0041, "epss_percentile": 0.60797}, "CVE-2017-5007": {"epss_score": 0.05622, "epss_percentile": 0.90061}, "CVE-2017-5008": {"epss_score": 0.0041, "epss_percentile": 0.60797}, "CVE-2017-5009": {"epss_score": 0.0084, "epss_percentile": 0.74208}, "CVE-2017-5010": {"epss_score": 0.0041, "epss_percentile": 0.60797}, "CVE-2017-5011": {"epss_score": 0.00544, "epss_percentile": 0.67126}, "CVE-2017-5012": {"epss_score": 0.02822, "epss_percentile": 0.85749}, "CVE-2017-5013": {"epss_score": 0.00601, "epss_percentile": 0.68855}, "CVE-2017-5014": {"epss_score": 0.00836, "epss_percentile": 0.74147}, "CVE-2017-5015": {"epss_score": 0.00556, "epss_percentile": 0.67525}, "CVE-2017-5016": {"epss_score": 0.00584, "epss_percentile": 0.68369}, "CVE-2017-5017": {"epss_score": 0.00601, "epss_percentile": 0.68851}, "CVE-2017-5018": {"epss_score": 0.00443, "epss_percentile": 0.62784}, "CVE-2017-5019": {"epss_score": 0.00782, "epss_percentile": 0.73203}, "CVE-2017-5020": {"epss_score": 0.00532, "epss_percentile": 0.66702}, "CVE-2017-5021": {"epss_score": 0.00782, "epss_percentile": 0.73206}, "CVE-2017-5022": {"epss_score": 0.00382, "epss_percentile": 0.59037}, "CVE-2017-5023": {"epss_score": 0.00671, "epss_percentile": 0.70808}, "CVE-2017-5024": {"epss_score": 0.00202, "epss_percentile": 0.42399}, "CVE-2017-5025": {"epss_score": 0.00354, "epss_percentile": 0.57215}, "CVE-2017-5026": {"epss_score": 0.00584, "epss_percentile": 0.68369}, "CVE-2017-5027": {"epss_score": 0.00109, "epss_percentile": 0.29987}, "CVE-2017-5028": {"epss_score": 0.00212, "epss_percentile": 0.43784}, "CVE-2017-5029": {"epss_score": 0.02374, "epss_percentile": 0.84536}, "CVE-2017-5030": {"epss_score": 0.50891, "epss_percentile": 0.97754}, "CVE-2017-5031": {"epss_score": 0.00758, "epss_percentile": 0.72782}, "CVE-2017-5032": {"epss_score": 0.00911, "epss_percentile": 0.75332}, "CVE-2017-5033": {"epss_score": 0.00606, "epss_percentile": 0.69018}, "CVE-2017-5034": {"epss_score": 0.00911, "epss_percentile": 0.75332}, "CVE-2017-5035": {"epss_score": 0.00435, "epss_percentile": 0.62345}, "CVE-2017-5036": {"epss_score": 0.00279, "epss_percentile": 0.50986}, "CVE-2017-5037": {"epss_score": 0.00279, "epss_percentile": 0.50986}, "CVE-2017-5038": {"epss_score": 0.00942, "epss_percentile": 0.75762}, "CVE-2017-5039": {"epss_score": 0.00279, "epss_percentile": 0.50986}, "CVE-2017-5040": {"epss_score": 0.03425, "epss_percentile": 0.87112}, "CVE-2017-5041": {"epss_score": 0.00601, "epss_percentile": 0.68855}, "CVE-2017-5042": {"epss_score": 0.00044, "epss_percentile": 0.13592}, "CVE-2017-5043": {"epss_score": 0.01098, "epss_percentile": 0.77534}, "CVE-2017-5044": {"epss_score": 0.01013, "epss_percentile": 0.76637}, "CVE-2017-5045": {"epss_score": 0.00854, "epss_percentile": 0.74447}, "CVE-2017-5046": {"epss_score": 0.01156, "epss_percentile": 0.78098}, "CVE-2017-5047": {"epss_score": 0.0031, "epss_percentile": 0.53789}, "CVE-2017-5048": {"epss_score": 0.0031, "epss_percentile": 0.53789}, "CVE-2017-5049": {"epss_score": 0.0031, "epss_percentile": 0.53789}, "CVE-2017-5050": {"epss_score": 0.0031, "epss_percentile": 0.53789}, "CVE-2017-5051": {"epss_score": 0.0031, "epss_percentile": 0.53789}, "CVE-2017-5052": {"epss_score": 0.00512, "epss_percentile": 0.65851}, "CVE-2017-5053": {"epss_score": 0.01324, "epss_percentile": 0.79468}, "CVE-2017-5054": {"epss_score": 0.00512, "epss_percentile": 0.65851}, "CVE-2017-5055": {"epss_score": 0.00705, "epss_percentile": 0.71579}, "CVE-2017-5056": {"epss_score": 0.00858, "epss_percentile": 0.74508}, "CVE-2017-5057": {"epss_score": 0.00839, "epss_percentile": 0.74196}, "CVE-2017-5058": {"epss_score": 0.00985, "epss_percentile": 0.76325}, "CVE-2017-5059": {"epss_score": 0.02491, "epss_percentile": 0.84898}, "CVE-2017-5060": {"epss_score": 0.00688, "epss_percentile": 0.71192}, "CVE-2017-5061": {"epss_score": 0.00465, "epss_percentile": 0.63757}, "CVE-2017-5062": {"epss_score": 0.00985, "epss_percentile": 0.76325}, "CVE-2017-5063": {"epss_score": 0.00911, "epss_percentile": 0.75332}, "CVE-2017-5064": {"epss_score": 0.00985, "epss_percentile": 0.76325}, "CVE-2017-5065": {"epss_score": 0.00709, "epss_percentile": 0.71686}, "CVE-2017-5066": {"epss_score": 0.00177, "epss_percentile": 0.39612}, "CVE-2017-5067": {"epss_score": 0.00709, "epss_percentile": 0.71686}, "CVE-2017-5068": {"epss_score": 0.0039, "epss_percentile": 0.59543}, "CVE-2017-5069": {"epss_score": 0.00522, "epss_percentile": 0.66272}, "CVE-2017-5070": {"epss_score": 0.61978, "epss_percentile": 0.9827}, "CVE-2017-5071": {"epss_score": 0.00736, "epss_percentile": 0.72311}, "CVE-2017-5072": {"epss_score": 0.00524, "epss_percentile": 0.66317}, "CVE-2017-5073": {"epss_score": 0.00858, "epss_percentile": 0.74508}, "CVE-2017-5074": {"epss_score": 0.00424, "epss_percentile": 0.61686}, "CVE-2017-5075": {"epss_score": 0.00667, "epss_percentile": 0.70709}, "CVE-2017-5076": {"epss_score": 0.00709, "epss_percentile": 0.71686}, "CVE-2017-5077": {"epss_score": 0.00911, "epss_percentile": 0.75332}, "CVE-2017-5078": {"epss_score": 0.02862, "epss_percentile": 0.85854}, "CVE-2017-5079": {"epss_score": 0.00709, "epss_percentile": 0.71686}, "CVE-2017-5080": {"epss_score": 0.00911, "epss_percentile": 0.75332}, "CVE-2017-5081": {"epss_score": 0.00025, "epss_percentile": 0.06287}, "CVE-2017-5082": {"epss_score": 0.00042, "epss_percentile": 0.12916}, "CVE-2017-5083": {"epss_score": 0.00667, "epss_percentile": 0.70715}, "CVE-2017-5084": {"epss_score": 0.00029, "epss_percentile": 0.07606}, "CVE-2017-5085": {"epss_score": 0.00443, "epss_percentile": 0.62784}, "CVE-2017-5086": {"epss_score": 0.00709, "epss_percentile": 0.71686}, "CVE-2017-5087": {"epss_score": 0.00911, "epss_percentile": 0.75332}, "CVE-2017-5088": {"epss_score": 0.00858, "epss_percentile": 0.74508}, "CVE-2017-5089": {"epss_score": 0.00667, "epss_percentile": 0.70715}, "CVE-2017-5090": {"epss_score": 0.00159, "epss_percentile": 0.3733}, "CVE-2017-5091": {"epss_score": 0.01098, "epss_percentile": 0.77534}, "CVE-2017-5092": {"epss_score": 0.01484, "epss_percentile": 0.80593}, "CVE-2017-5093": {"epss_score": 0.01156, "epss_percentile": 0.78104}, "CVE-2017-5094": {"epss_score": 0.00985, "epss_percentile": 0.7632}, "CVE-2017-5095": {"epss_score": 0.01587, "epss_percentile": 0.81182}, "CVE-2017-5096": {"epss_score": 0.00403, "epss_percentile": 0.60345}, "CVE-2017-5097": {"epss_score": 0.01098, "epss_percentile": 0.77534}, "CVE-2017-5098": {"epss_score": 0.03366, "epss_percentile": 0.87003}, "CVE-2017-5099": {"epss_score": 0.01265, "epss_percentile": 0.79006}, "CVE-2017-5100": {"epss_score": 0.01098, "epss_percentile": 0.77534}, "CVE-2017-5101": {"epss_score": 0.01156, "epss_percentile": 0.78104}, "CVE-2017-5102": {"epss_score": 0.01156, "epss_percentile": 0.78098}, "CVE-2017-5103": {"epss_score": 0.01156, "epss_percentile": 0.78098}, "CVE-2017-5104": {"epss_score": 0.01156, "epss_percentile": 0.78104}, "CVE-2017-5105": {"epss_score": 0.01156, "epss_percentile": 0.78104}, "CVE-2017-5106": {"epss_score": 0.01156, "epss_percentile": 0.78104}, "CVE-2017-5107": {"epss_score": 0.00586, "epss_percentile": 0.68456}, "CVE-2017-5108": {"epss_score": 0.00839, "epss_percentile": 0.74196}, "CVE-2017-5109": {"epss_score": 0.01156, "epss_percentile": 0.78104}, "CVE-2017-5110": {"epss_score": 0.01066, "epss_percentile": 0.7722}, "CVE-2017-5111": {"epss_score": 0.01484, "epss_percentile": 0.80593}, "CVE-2017-5112": {"epss_score": 0.02731, "epss_percentile": 0.85538}, "CVE-2017-5113": {"epss_score": 0.01265, "epss_percentile": 0.79006}, "CVE-2017-5114": {"epss_score": 0.01484, "epss_percentile": 0.80593}, "CVE-2017-5115": {"epss_score": 0.0281, "epss_percentile": 0.85717}, "CVE-2017-5116": {"epss_score": 0.55771, "epss_percentile": 0.97995}, "CVE-2017-5117": {"epss_score": 0.00765, "epss_percentile": 0.7291}, "CVE-2017-5118": {"epss_score": 0.00606, "epss_percentile": 0.69018}, "CVE-2017-5119": {"epss_score": 0.00909, "epss_percentile": 0.75294}, "CVE-2017-5120": {"epss_score": 0.00869, "epss_percentile": 0.74692}, "CVE-2017-5121": {"epss_score": 0.06791, "epss_percentile": 0.91028}, "CVE-2017-5122": {"epss_score": 0.01484, "epss_percentile": 0.80593}, "CVE-2017-5123": {"epss_score": 0.01713, "epss_percentile": 0.8189}, "CVE-2017-5124": {"epss_score": 0.24995, "epss_percentile": 0.95976}, "CVE-2017-5125": {"epss_score": 0.01297, "epss_percentile": 0.79265}, "CVE-2017-5126": {"epss_score": 0.01254, "epss_percentile": 0.78924}, "CVE-2017-5127": {"epss_score": 0.01247, "epss_percentile": 0.7886}, "CVE-2017-5128": {"epss_score": 0.01262, "epss_percentile": 0.78979}, "CVE-2017-5129": {"epss_score": 0.00849, "epss_percentile": 0.74376}, "CVE-2017-5130": {"epss_score": 0.00762, "epss_percentile": 0.72836}, "CVE-2017-5131": {"epss_score": 0.01062, "epss_percentile": 0.77182}, "CVE-2017-5132": {"epss_score": 0.0115, "epss_percentile": 0.7803}, "CVE-2017-5133": {"epss_score": 0.02732, "epss_percentile": 0.85543}, "CVE-2017-5135": {"epss_score": 0.22367, "epss_percentile": 0.95626}, "CVE-2017-5136": {"epss_score": 0.00395, "epss_percentile": 0.5981}, "CVE-2017-5137": {"epss_score": 0.00316, "epss_percentile": 0.5428}, "CVE-2017-5139": {"epss_score": 0.00419, "epss_percentile": 0.6135}, "CVE-2017-5140": {"epss_score": 0.00419, "epss_percentile": 0.6135}, "CVE-2017-5141": {"epss_score": 0.00453, "epss_percentile": 0.63234}, "CVE-2017-5142": {"epss_score": 0.00332, "epss_percentile": 0.55608}, "CVE-2017-5143": {"epss_score": 0.03159, "epss_percentile": 0.86522}, "CVE-2017-5144": {"epss_score": 0.02493, "epss_percentile": 0.84902}, "CVE-2017-5145": {"epss_score": 0.00193, "epss_percentile": 0.41382}, "CVE-2017-5146": {"epss_score": 0.64606, "epss_percentile": 0.98386}, "CVE-2017-5147": {"epss_score": 0.00105, "epss_percentile": 0.29347}, "CVE-2017-5149": {"epss_score": 0.00318, "epss_percentile": 0.5444}, "CVE-2017-5151": {"epss_score": 0.00571, "epss_percentile": 0.67992}, "CVE-2017-5152": {"epss_score": 0.01309, "epss_percentile": 0.79355}, "CVE-2017-5153": {"epss_score": 0.00091, "epss_percentile": 0.26218}, "CVE-2017-5154": {"epss_score": 0.00601, "epss_percentile": 0.6886}, "CVE-2017-5155": {"epss_score": 0.00642, "epss_percentile": 0.70017}, "CVE-2017-5156": {"epss_score": 0.00134, "epss_percentile": 0.33827}, "CVE-2017-5157": {"epss_score": 0.00206, "epss_percentile": 0.43061}, "CVE-2017-5158": {"epss_score": 0.01017, "epss_percentile": 0.76693}, "CVE-2017-5159": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2017-5160": {"epss_score": 0.00107, "epss_percentile": 0.29716}, "CVE-2017-5161": {"epss_score": 0.00116, "epss_percentile": 0.31188}, "CVE-2017-5162": {"epss_score": 0.60061, "epss_percentile": 0.98191}, "CVE-2017-5163": {"epss_score": 0.01381, "epss_percentile": 0.7987}, "CVE-2017-5164": {"epss_score": 0.0018, "epss_percentile": 0.39982}, "CVE-2017-5165": {"epss_score": 0.00083, "epss_percentile": 0.24707}, "CVE-2017-5166": {"epss_score": 0.00473, "epss_percentile": 0.64075}, "CVE-2017-5167": {"epss_score": 0.0044, "epss_percentile": 0.62642}, "CVE-2017-5168": {"epss_score": 0.04253, "epss_percentile": 0.88455}, "CVE-2017-5169": {"epss_score": 0.00295, "epss_percentile": 0.52447}, "CVE-2017-5170": {"epss_score": 0.00693, "epss_percentile": 0.71322}, "CVE-2017-5173": {"epss_score": 0.80502, "epss_percentile": 0.99092}, "CVE-2017-5174": {"epss_score": 0.38216, "epss_percentile": 0.9709}, "CVE-2017-5175": {"epss_score": 0.00225, "epss_percentile": 0.45096}, "CVE-2017-5176": {"epss_score": 4e-05, "epss_percentile": 0.00155}, "CVE-2017-5177": {"epss_score": 0.45114, "epss_percentile": 0.97474}, "CVE-2017-5178": {"epss_score": 0.02543, "epss_percentile": 0.85057}, "CVE-2017-5179": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-5180": {"epss_score": 0.00345, "epss_percentile": 0.56565}, "CVE-2017-5182": {"epss_score": 0.00988, "epss_percentile": 0.76348}, "CVE-2017-5183": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-5184": {"epss_score": 0.00275, "epss_percentile": 0.50674}, "CVE-2017-5185": {"epss_score": 0.00563, "epss_percentile": 0.67716}, "CVE-2017-5186": {"epss_score": 0.00468, "epss_percentile": 0.63876}, "CVE-2017-5187": {"epss_score": 0.00253, "epss_percentile": 0.48452}, "CVE-2017-5188": {"epss_score": 0.00154, "epss_percentile": 0.36715}, "CVE-2017-5189": {"epss_score": 0.00172, "epss_percentile": 0.3904}, "CVE-2017-5190": {"epss_score": 0.00236, "epss_percentile": 0.46387}, "CVE-2017-5191": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-5192": {"epss_score": 0.00149, "epss_percentile": 0.36025}, "CVE-2017-5193": {"epss_score": 0.01876, "epss_percentile": 0.82658}, "CVE-2017-5194": {"epss_score": 0.0187, "epss_percentile": 0.82627}, "CVE-2017-5195": {"epss_score": 0.01054, "epss_percentile": 0.77105}, "CVE-2017-5196": {"epss_score": 0.01054, "epss_percentile": 0.77105}, "CVE-2017-5197": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2017-5198": {"epss_score": 0.00098, "epss_percentile": 0.27718}, "CVE-2017-5199": {"epss_score": 0.02829, "epss_percentile": 0.8577}, "CVE-2017-5200": {"epss_score": 0.01262, "epss_percentile": 0.78982}, "CVE-2017-5201": {"epss_score": 0.00124, "epss_percentile": 0.32359}, "CVE-2017-5202": {"epss_score": 0.0108, "epss_percentile": 0.77362}, "CVE-2017-5203": {"epss_score": 0.0108, "epss_percentile": 0.77362}, "CVE-2017-5204": {"epss_score": 0.0217, "epss_percentile": 0.83868}, "CVE-2017-5205": {"epss_score": 0.0108, "epss_percentile": 0.77362}, "CVE-2017-5206": {"epss_score": 0.0241, "epss_percentile": 0.84664}, "CVE-2017-5207": {"epss_score": 0.00037, "epss_percentile": 0.10684}, "CVE-2017-5208": {"epss_score": 0.01645, "epss_percentile": 0.81529}, "CVE-2017-5209": {"epss_score": 0.00381, "epss_percentile": 0.58983}, "CVE-2017-5210": {"epss_score": 0.00476, "epss_percentile": 0.64265}, "CVE-2017-5211": {"epss_score": 0.00289, "epss_percentile": 0.52015}, "CVE-2017-5212": {"epss_score": 0.00588, "epss_percentile": 0.68499}, "CVE-2017-5213": {"epss_score": 0.00378, "epss_percentile": 0.58796}, "CVE-2017-5214": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2017-5215": {"epss_score": 0.00217, "epss_percentile": 0.44325}, "CVE-2017-5216": {"epss_score": 0.00177, "epss_percentile": 0.39581}, "CVE-2017-5217": {"epss_score": 0.00148, "epss_percentile": 0.35887}, "CVE-2017-5218": {"epss_score": 0.00284, "epss_percentile": 0.5149}, "CVE-2017-5219": {"epss_score": 0.04033, "epss_percentile": 0.88153}, "CVE-2017-5223": {"epss_score": 0.08899, "epss_percentile": 0.92306}, "CVE-2017-5225": {"epss_score": 0.00724, "epss_percentile": 0.72028}, "CVE-2017-5226": {"epss_score": 0.08848, "epss_percentile": 0.92283}, "CVE-2017-5227": {"epss_score": 0.21427, "epss_percentile": 0.95515}, "CVE-2017-5228": {"epss_score": 0.00299, "epss_percentile": 0.52888}, "CVE-2017-5229": {"epss_score": 0.00299, "epss_percentile": 0.52888}, "CVE-2017-5230": {"epss_score": 0.00444, "epss_percentile": 0.62839}, "CVE-2017-5231": {"epss_score": 0.00299, "epss_percentile": 0.52888}, "CVE-2017-5232": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2017-5233": {"epss_score": 0.00189, "epss_percentile": 0.40978}, "CVE-2017-5234": {"epss_score": 0.00189, "epss_percentile": 0.40978}, "CVE-2017-5235": {"epss_score": 0.00189, "epss_percentile": 0.40978}, "CVE-2017-5236": {"epss_score": 0.00256, "epss_percentile": 0.48739}, "CVE-2017-5237": {"epss_score": 0.02497, "epss_percentile": 0.84911}, "CVE-2017-5238": {"epss_score": 0.00228, "epss_percentile": 0.45468}, "CVE-2017-5239": {"epss_score": 0.00061, "epss_percentile": 0.19337}, "CVE-2017-5240": {"epss_score": 0.0039, "epss_percentile": 0.59552}, "CVE-2017-5241": {"epss_score": 0.00388, "epss_percentile": 0.59367}, "CVE-2017-5242": {"epss_score": 0.00195, "epss_percentile": 0.41642}, "CVE-2017-5243": {"epss_score": 0.0018, "epss_percentile": 0.39929}, "CVE-2017-5244": {"epss_score": 0.00203, "epss_percentile": 0.42522}, "CVE-2017-5246": {"epss_score": 0.0028, "epss_percentile": 0.51009}, "CVE-2017-5247": {"epss_score": 0.00224, "epss_percentile": 0.44985}, "CVE-2017-5249": {"epss_score": 0.00178, "epss_percentile": 0.3971}, "CVE-2017-5250": {"epss_score": 0.00153, "epss_percentile": 0.36547}, "CVE-2017-5251": {"epss_score": 0.00161, "epss_percentile": 0.37557}, "CVE-2017-5254": {"epss_score": 0.67592, "epss_percentile": 0.98514}, "CVE-2017-5255": {"epss_score": 0.71417, "epss_percentile": 0.98667}, "CVE-2017-5256": {"epss_score": 0.00296, "epss_percentile": 0.5257}, "CVE-2017-5257": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2017-5258": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2017-5259": {"epss_score": 0.59538, "epss_percentile": 0.9817}, "CVE-2017-5260": {"epss_score": 0.33387, "epss_percentile": 0.96768}, "CVE-2017-5261": {"epss_score": 0.24144, "epss_percentile": 0.95879}, "CVE-2017-5262": {"epss_score": 0.07842, "epss_percentile": 0.91714}, "CVE-2017-5263": {"epss_score": 0.00039, "epss_percentile": 0.11573}, "CVE-2017-5264": {"epss_score": 0.00335, "epss_percentile": 0.55804}, "CVE-2017-5328": {"epss_score": 0.00232, "epss_percentile": 0.45938}, "CVE-2017-5329": {"epss_score": 0.00156, "epss_percentile": 0.36994}, "CVE-2017-5330": {"epss_score": 0.00523, "epss_percentile": 0.66303}, "CVE-2017-5331": {"epss_score": 0.00076, "epss_percentile": 0.23231}, "CVE-2017-5332": {"epss_score": 0.00234, "epss_percentile": 0.46095}, "CVE-2017-5333": {"epss_score": 0.00234, "epss_percentile": 0.46095}, "CVE-2017-5334": {"epss_score": 0.05592, "epss_percentile": 0.9003}, "CVE-2017-5335": {"epss_score": 0.03542, "epss_percentile": 0.8732}, "CVE-2017-5336": {"epss_score": 0.05206, "epss_percentile": 0.89611}, "CVE-2017-5337": {"epss_score": 0.03732, "epss_percentile": 0.87645}, "CVE-2017-5340": {"epss_score": 0.0714, "epss_percentile": 0.91277}, "CVE-2017-5341": {"epss_score": 0.04378, "epss_percentile": 0.8862}, "CVE-2017-5342": {"epss_score": 0.04378, "epss_percentile": 0.8862}, "CVE-2017-5344": {"epss_score": 0.08148, "epss_percentile": 0.91902}, "CVE-2017-5345": {"epss_score": 0.00428, "epss_percentile": 0.61933}, "CVE-2017-5346": {"epss_score": 0.0108, "epss_percentile": 0.77368}, "CVE-2017-5347": {"epss_score": 0.00403, "epss_percentile": 0.60329}, "CVE-2017-5350": {"epss_score": 0.00539, "epss_percentile": 0.6698}, "CVE-2017-5351": {"epss_score": 0.00473, "epss_percentile": 0.64095}, "CVE-2017-5356": {"epss_score": 0.02755, "epss_percentile": 0.85589}, "CVE-2017-5357": {"epss_score": 0.01025, "epss_percentile": 0.7679}, "CVE-2017-5358": {"epss_score": 0.35316, "epss_percentile": 0.969}, "CVE-2017-5359": {"epss_score": 0.37436, "epss_percentile": 0.97046}, "CVE-2017-5361": {"epss_score": 0.00358, "epss_percentile": 0.57537}, "CVE-2017-5364": {"epss_score": 0.00287, "epss_percentile": 0.51815}, "CVE-2017-5367": {"epss_score": 0.00492, "epss_percentile": 0.65001}, "CVE-2017-5368": {"epss_score": 0.00205, "epss_percentile": 0.42703}, "CVE-2017-5371": {"epss_score": 0.03997, "epss_percentile": 0.88085}, "CVE-2017-5372": {"epss_score": 0.00714, "epss_percentile": 0.7181}, "CVE-2017-5373": {"epss_score": 0.0193, "epss_percentile": 0.82936}, "CVE-2017-5374": {"epss_score": 0.01847, "epss_percentile": 0.82523}, "CVE-2017-5375": {"epss_score": 0.60738, "epss_percentile": 0.98218}, "CVE-2017-5376": {"epss_score": 0.01799, "epss_percentile": 0.82315}, "CVE-2017-5377": {"epss_score": 0.01847, "epss_percentile": 0.82523}, "CVE-2017-5378": {"epss_score": 0.01705, "epss_percentile": 0.81851}, "CVE-2017-5379": {"epss_score": 0.01753, "epss_percentile": 0.82113}, "CVE-2017-5380": {"epss_score": 0.01799, "epss_percentile": 0.82315}, "CVE-2017-5381": {"epss_score": 0.01264, "epss_percentile": 0.78992}, "CVE-2017-5382": {"epss_score": 0.00957, "epss_percentile": 0.75937}, "CVE-2017-5383": {"epss_score": 0.02444, "epss_percentile": 0.84762}, "CVE-2017-5384": {"epss_score": 0.00764, "epss_percentile": 0.72901}, "CVE-2017-5385": {"epss_score": 0.00947, "epss_percentile": 0.75816}, "CVE-2017-5386": {"epss_score": 0.01186, "epss_percentile": 0.78348}, "CVE-2017-5387": {"epss_score": 0.00126, "epss_percentile": 0.32736}, "CVE-2017-5388": {"epss_score": 0.0128, "epss_percentile": 0.79141}, "CVE-2017-5389": {"epss_score": 0.00374, "epss_percentile": 0.58555}, "CVE-2017-5390": {"epss_score": 0.01748, "epss_percentile": 0.82081}, "CVE-2017-5391": {"epss_score": 0.02446, "epss_percentile": 0.84771}, "CVE-2017-5392": {"epss_score": 0.01847, "epss_percentile": 0.82523}, "CVE-2017-5393": {"epss_score": 0.00466, "epss_percentile": 0.63807}, "CVE-2017-5394": {"epss_score": 0.0014, "epss_percentile": 0.34731}, "CVE-2017-5395": {"epss_score": 0.00375, "epss_percentile": 0.58633}, "CVE-2017-5396": {"epss_score": 0.01838, "epss_percentile": 0.82484}, "CVE-2017-5397": {"epss_score": 0.00523, "epss_percentile": 0.66308}, "CVE-2017-5398": {"epss_score": 0.03265, "epss_percentile": 0.8678}, "CVE-2017-5399": {"epss_score": 0.00731, "epss_percentile": 0.72167}, "CVE-2017-5400": {"epss_score": 0.00999, "epss_percentile": 0.7648}, "CVE-2017-5401": {"epss_score": 0.02199, "epss_percentile": 0.83969}, "CVE-2017-5402": {"epss_score": 0.02531, "epss_percentile": 0.85026}, "CVE-2017-5403": {"epss_score": 0.00516, "epss_percentile": 0.6605}, "CVE-2017-5404": {"epss_score": 0.22792, "epss_percentile": 0.95687}, "CVE-2017-5405": {"epss_score": 0.02352, "epss_percentile": 0.84471}, "CVE-2017-5406": {"epss_score": 0.00736, "epss_percentile": 0.72303}, "CVE-2017-5407": {"epss_score": 0.01045, "epss_percentile": 0.77014}, "CVE-2017-5408": {"epss_score": 0.01068, "epss_percentile": 0.77244}, "CVE-2017-5409": {"epss_score": 0.00109, "epss_percentile": 0.29992}, "CVE-2017-5410": {"epss_score": 0.02531, "epss_percentile": 0.85026}, "CVE-2017-5411": {"epss_score": 0.00736, "epss_percentile": 0.72303}, "CVE-2017-5412": {"epss_score": 0.00361, "epss_percentile": 0.57728}, "CVE-2017-5413": {"epss_score": 0.00564, "epss_percentile": 0.67754}, "CVE-2017-5414": {"epss_score": 0.0013, "epss_percentile": 0.33225}, "CVE-2017-5415": {"epss_score": 0.29152, "epss_percentile": 0.96421}, "CVE-2017-5416": {"epss_score": 0.00856, "epss_percentile": 0.74483}, "CVE-2017-5417": {"epss_score": 0.00369, "epss_percentile": 0.58229}, "CVE-2017-5418": {"epss_score": 0.00523, "epss_percentile": 0.66296}, "CVE-2017-5419": {"epss_score": 0.00907, "epss_percentile": 0.75267}, "CVE-2017-5420": {"epss_score": 0.00398, "epss_percentile": 0.60088}, "CVE-2017-5421": {"epss_score": 0.00405, "epss_percentile": 0.60508}, "CVE-2017-5422": {"epss_score": 0.00736, "epss_percentile": 0.72303}, "CVE-2017-5425": {"epss_score": 0.00468, "epss_percentile": 0.63872}, "CVE-2017-5426": {"epss_score": 0.00304, "epss_percentile": 0.53252}, "CVE-2017-5427": {"epss_score": 0.00098, "epss_percentile": 0.27715}, "CVE-2017-5428": {"epss_score": 0.00371, "epss_percentile": 0.58343}, "CVE-2017-5429": {"epss_score": 0.0189, "epss_percentile": 0.82725}, "CVE-2017-5430": {"epss_score": 0.00746, "epss_percentile": 0.72544}, "CVE-2017-5432": {"epss_score": 0.01915, "epss_percentile": 0.82856}, "CVE-2017-5433": {"epss_score": 0.01915, "epss_percentile": 0.82856}, "CVE-2017-5434": {"epss_score": 0.01915, "epss_percentile": 0.82856}, "CVE-2017-5435": {"epss_score": 0.02361, "epss_percentile": 0.84498}, "CVE-2017-5436": {"epss_score": 0.00994, "epss_percentile": 0.76422}, "CVE-2017-5438": {"epss_score": 0.01915, "epss_percentile": 0.82856}, "CVE-2017-5439": {"epss_score": 0.01915, "epss_percentile": 0.82856}, "CVE-2017-5440": {"epss_score": 0.01915, "epss_percentile": 0.82856}, "CVE-2017-5441": {"epss_score": 0.01915, "epss_percentile": 0.82856}, "CVE-2017-5442": {"epss_score": 0.01915, "epss_percentile": 0.82856}, "CVE-2017-5443": {"epss_score": 0.01915, "epss_percentile": 0.82856}, "CVE-2017-5444": {"epss_score": 0.02566, "epss_percentile": 0.85118}, "CVE-2017-5445": {"epss_score": 0.0214, "epss_percentile": 0.83745}, "CVE-2017-5446": {"epss_score": 0.01355, "epss_percentile": 0.79705}, "CVE-2017-5447": {"epss_score": 0.17133, "epss_percentile": 0.9478}, "CVE-2017-5448": {"epss_score": 0.01377, "epss_percentile": 0.7984}, "CVE-2017-5449": {"epss_score": 0.01539, "epss_percentile": 0.80935}, "CVE-2017-5450": {"epss_score": 0.01072, "epss_percentile": 0.77278}, "CVE-2017-5451": {"epss_score": 0.00551, "epss_percentile": 0.6736}, "CVE-2017-5452": {"epss_score": 0.00585, "epss_percentile": 0.68411}, "CVE-2017-5453": {"epss_score": 0.00548, "epss_percentile": 0.67274}, "CVE-2017-5454": {"epss_score": 0.00723, "epss_percentile": 0.7201}, "CVE-2017-5455": {"epss_score": 0.02652, "epss_percentile": 0.85346}, "CVE-2017-5456": {"epss_score": 0.00347, "epss_percentile": 0.56756}, "CVE-2017-5458": {"epss_score": 0.00632, "epss_percentile": 0.69746}, "CVE-2017-5459": {"epss_score": 0.0631, "epss_percentile": 0.90662}, "CVE-2017-5460": {"epss_score": 0.01915, "epss_percentile": 0.82856}, "CVE-2017-5461": {"epss_score": 0.01237, "epss_percentile": 0.7878}, "CVE-2017-5462": {"epss_score": 0.01072, "epss_percentile": 0.77277}, "CVE-2017-5463": {"epss_score": 0.0077, "epss_percentile": 0.72997}, "CVE-2017-5464": {"epss_score": 0.01915, "epss_percentile": 0.82856}, "CVE-2017-5465": {"epss_score": 0.22769, "epss_percentile": 0.95684}, "CVE-2017-5466": {"epss_score": 0.00624, "epss_percentile": 0.69555}, "CVE-2017-5467": {"epss_score": 0.01301, "epss_percentile": 0.79293}, "CVE-2017-5468": {"epss_score": 0.022, "epss_percentile": 0.83974}, "CVE-2017-5469": {"epss_score": 0.05368, "epss_percentile": 0.89793}, "CVE-2017-5470": {"epss_score": 0.01874, "epss_percentile": 0.82651}, "CVE-2017-5471": {"epss_score": 0.00564, "epss_percentile": 0.67754}, "CVE-2017-5472": {"epss_score": 0.01874, "epss_percentile": 0.82651}, "CVE-2017-5473": {"epss_score": 0.00308, "epss_percentile": 0.53602}, "CVE-2017-5474": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2017-5475": {"epss_score": 0.00158, "epss_percentile": 0.37252}, "CVE-2017-5476": {"epss_score": 0.00158, "epss_percentile": 0.37252}, "CVE-2017-5480": {"epss_score": 0.0032, "epss_percentile": 0.54619}, "CVE-2017-5481": {"epss_score": 0.00478, "epss_percentile": 0.64373}, "CVE-2017-5482": {"epss_score": 0.04378, "epss_percentile": 0.8862}, "CVE-2017-5483": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2017-5484": {"epss_score": 0.0176, "epss_percentile": 0.82145}, "CVE-2017-5485": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2017-5486": {"epss_score": 0.00931, "epss_percentile": 0.75614}, "CVE-2017-5487": {"epss_score": 0.92497, "epss_percentile": 0.9972}, "CVE-2017-5488": {"epss_score": 0.00882, "epss_percentile": 0.74893}, "CVE-2017-5489": {"epss_score": 0.00512, "epss_percentile": 0.65863}, "CVE-2017-5490": {"epss_score": 0.01307, "epss_percentile": 0.7934}, "CVE-2017-5491": {"epss_score": 0.01622, "epss_percentile": 0.81396}, "CVE-2017-5492": {"epss_score": 0.00533, "epss_percentile": 0.66758}, "CVE-2017-5493": {"epss_score": 0.01668, "epss_percentile": 0.81659}, "CVE-2017-5494": {"epss_score": 0.00217, "epss_percentile": 0.44269}, "CVE-2017-5495": {"epss_score": 0.03624, "epss_percentile": 0.87454}, "CVE-2017-5496": {"epss_score": 0.11321, "epss_percentile": 0.93308}, "CVE-2017-5498": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2017-5499": {"epss_score": 0.00454, "epss_percentile": 0.63265}, "CVE-2017-5500": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2017-5501": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2017-5502": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2017-5503": {"epss_score": 0.00444, "epss_percentile": 0.62846}, "CVE-2017-5504": {"epss_score": 0.00462, "epss_percentile": 0.63621}, "CVE-2017-5505": {"epss_score": 0.00404, "epss_percentile": 0.6043}, "CVE-2017-5506": {"epss_score": 0.00407, "epss_percentile": 0.60594}, "CVE-2017-5507": {"epss_score": 0.11405, "epss_percentile": 0.93336}, "CVE-2017-5508": {"epss_score": 0.00516, "epss_percentile": 0.66037}, "CVE-2017-5509": {"epss_score": 0.00296, "epss_percentile": 0.52629}, "CVE-2017-5510": {"epss_score": 0.00262, "epss_percentile": 0.49394}, "CVE-2017-5511": {"epss_score": 0.01355, "epss_percentile": 0.7971}, "CVE-2017-5515": {"epss_score": 0.00141, "epss_percentile": 0.34854}, "CVE-2017-5516": {"epss_score": 0.00216, "epss_percentile": 0.44222}, "CVE-2017-5517": {"epss_score": 0.01058, "epss_percentile": 0.77144}, "CVE-2017-5518": {"epss_score": 0.00403, "epss_percentile": 0.60361}, "CVE-2017-5519": {"epss_score": 0.01058, "epss_percentile": 0.77144}, "CVE-2017-5520": {"epss_score": 0.00525, "epss_percentile": 0.66387}, "CVE-2017-5521": {"epss_score": 0.93804, "epss_percentile": 0.99849}, "CVE-2017-5522": {"epss_score": 0.06039, "epss_percentile": 0.90427}, "CVE-2017-5524": {"epss_score": 0.00185, "epss_percentile": 0.40472}, "CVE-2017-5525": {"epss_score": 0.00143, "epss_percentile": 0.35119}, "CVE-2017-5526": {"epss_score": 0.00091, "epss_percentile": 0.2619}, "CVE-2017-5527": {"epss_score": 0.00217, "epss_percentile": 0.44278}, "CVE-2017-5528": {"epss_score": 0.00135, "epss_percentile": 0.34042}, "CVE-2017-5529": {"epss_score": 0.00307, "epss_percentile": 0.53485}, "CVE-2017-5530": {"epss_score": 0.00286, "epss_percentile": 0.51696}, "CVE-2017-5531": {"epss_score": 0.00547, "epss_percentile": 0.6726}, "CVE-2017-5532": {"epss_score": 0.00267, "epss_percentile": 0.49965}, "CVE-2017-5533": {"epss_score": 0.00537, "epss_percentile": 0.66904}, "CVE-2017-5534": {"epss_score": 0.0046, "epss_percentile": 0.6352}, "CVE-2017-5535": {"epss_score": 0.0002, "epss_percentile": 0.04609}, "CVE-2017-5536": {"epss_score": 0.00198, "epss_percentile": 0.4201}, "CVE-2017-5537": {"epss_score": 0.00543, "epss_percentile": 0.67107}, "CVE-2017-5538": {"epss_score": 0.02764, "epss_percentile": 0.85607}, "CVE-2017-5539": {"epss_score": 0.07446, "epss_percentile": 0.91476}, "CVE-2017-5541": {"epss_score": 0.01305, "epss_percentile": 0.79325}, "CVE-2017-5542": {"epss_score": 0.00271, "epss_percentile": 0.50313}, "CVE-2017-5543": {"epss_score": 0.01765, "epss_percentile": 0.82163}, "CVE-2017-5544": {"epss_score": 0.00031, "epss_percentile": 0.08447}, "CVE-2017-5545": {"epss_score": 0.00416, "epss_percentile": 0.61179}, "CVE-2017-5546": {"epss_score": 0.00079, "epss_percentile": 0.23851}, "CVE-2017-5547": {"epss_score": 0.00092, "epss_percentile": 0.26593}, "CVE-2017-5548": {"epss_score": 0.00086, "epss_percentile": 0.25357}, "CVE-2017-5549": {"epss_score": 0.00082, "epss_percentile": 0.24442}, "CVE-2017-5550": {"epss_score": 0.0008, "epss_percentile": 0.24012}, "CVE-2017-5551": {"epss_score": 0.00064, "epss_percentile": 0.20323}, "CVE-2017-5552": {"epss_score": 0.00198, "epss_percentile": 0.42091}, "CVE-2017-5553": {"epss_score": 0.00219, "epss_percentile": 0.4447}, "CVE-2017-5554": {"epss_score": 0.02132, "epss_percentile": 0.83717}, "CVE-2017-5556": {"epss_score": 0.0059, "epss_percentile": 0.68545}, "CVE-2017-5563": {"epss_score": 0.00354, "epss_percentile": 0.57249}, "CVE-2017-5565": {"epss_score": 0.00125, "epss_percentile": 0.32614}, "CVE-2017-5566": {"epss_score": 0.00101, "epss_percentile": 0.2865}, "CVE-2017-5567": {"epss_score": 0.00101, "epss_percentile": 0.2865}, "CVE-2017-5569": {"epss_score": 0.0193, "epss_percentile": 0.82939}, "CVE-2017-5570": {"epss_score": 0.00327, "epss_percentile": 0.55144}, "CVE-2017-5571": {"epss_score": 0.00589, "epss_percentile": 0.68534}, "CVE-2017-5572": {"epss_score": 0.00428, "epss_percentile": 0.6195}, "CVE-2017-5573": {"epss_score": 0.00392, "epss_percentile": 0.59695}, "CVE-2017-5574": {"epss_score": 0.03377, "epss_percentile": 0.87023}, "CVE-2017-5575": {"epss_score": 0.00718, "epss_percentile": 0.71938}, "CVE-2017-5576": {"epss_score": 0.0008, "epss_percentile": 0.24189}, "CVE-2017-5577": {"epss_score": 0.0004, "epss_percentile": 0.11983}, "CVE-2017-5578": {"epss_score": 0.00198, "epss_percentile": 0.42091}, "CVE-2017-5579": {"epss_score": 0.00137, "epss_percentile": 0.34224}, "CVE-2017-5580": {"epss_score": 0.00117, "epss_percentile": 0.31286}, "CVE-2017-5581": {"epss_score": 0.03195, "epss_percentile": 0.8661}, "CVE-2017-5583": {"epss_score": 0.0058, "epss_percentile": 0.6825}, "CVE-2017-5584": {"epss_score": 0.00195, "epss_percentile": 0.416}, "CVE-2017-5585": {"epss_score": 0.00717, "epss_percentile": 0.71873}, "CVE-2017-5586": {"epss_score": 0.35327, "epss_percentile": 0.969}, "CVE-2017-5589": {"epss_score": 0.00245, "epss_percentile": 0.47705}, "CVE-2017-5590": {"epss_score": 0.00384, "epss_percentile": 0.59178}, "CVE-2017-5591": {"epss_score": 0.00456, "epss_percentile": 0.63352}, "CVE-2017-5592": {"epss_score": 0.00415, "epss_percentile": 0.61146}, "CVE-2017-5593": {"epss_score": 0.00245, "epss_percentile": 0.47687}, "CVE-2017-5594": {"epss_score": 0.04961, "epss_percentile": 0.89334}, "CVE-2017-5595": {"epss_score": 0.00208, "epss_percentile": 0.43292}, "CVE-2017-5596": {"epss_score": 0.00558, "epss_percentile": 0.67579}, "CVE-2017-5597": {"epss_score": 0.00478, "epss_percentile": 0.64379}, "CVE-2017-5598": {"epss_score": 0.00287, "epss_percentile": 0.51844}, "CVE-2017-5599": {"epss_score": 0.00233, "epss_percentile": 0.45977}, "CVE-2017-5600": {"epss_score": 0.00816, "epss_percentile": 0.73829}, "CVE-2017-5601": {"epss_score": 0.00679, "epss_percentile": 0.71014}, "CVE-2017-5602": {"epss_score": 0.00245, "epss_percentile": 0.47687}, "CVE-2017-5603": {"epss_score": 0.00253, "epss_percentile": 0.48485}, "CVE-2017-5604": {"epss_score": 0.00253, "epss_percentile": 0.48438}, "CVE-2017-5605": {"epss_score": 0.00253, "epss_percentile": 0.48449}, "CVE-2017-5606": {"epss_score": 0.00376, "epss_percentile": 0.58688}, "CVE-2017-5607": {"epss_score": 0.09035, "epss_percentile": 0.92376}, "CVE-2017-5608": {"epss_score": 0.00697, "epss_percentile": 0.71408}, "CVE-2017-5609": {"epss_score": 0.01013, "epss_percentile": 0.76636}, "CVE-2017-5610": {"epss_score": 0.0086, "epss_percentile": 0.74526}, "CVE-2017-5611": {"epss_score": 0.12378, "epss_percentile": 0.93655}, "CVE-2017-5612": {"epss_score": 0.01526, "epss_percentile": 0.80865}, "CVE-2017-5613": {"epss_score": 0.0052, "epss_percentile": 0.66213}, "CVE-2017-5614": {"epss_score": 0.00351, "epss_percentile": 0.57076}, "CVE-2017-5615": {"epss_score": 0.00279, "epss_percentile": 0.50985}, "CVE-2017-5616": {"epss_score": 0.00271, "epss_percentile": 0.50313}, "CVE-2017-5617": {"epss_score": 0.01078, "epss_percentile": 0.77348}, "CVE-2017-5618": {"epss_score": 0.02075, "epss_percentile": 0.83505}, "CVE-2017-5619": {"epss_score": 0.00443, "epss_percentile": 0.62791}, "CVE-2017-5620": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-5621": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-5622": {"epss_score": 0.00063, "epss_percentile": 0.19861}, "CVE-2017-5623": {"epss_score": 0.00049, "epss_percentile": 0.15494}, "CVE-2017-5624": {"epss_score": 0.01838, "epss_percentile": 0.82485}, "CVE-2017-5625": {"epss_score": 0.0008, "epss_percentile": 0.24007}, "CVE-2017-5626": {"epss_score": 0.01657, "epss_percentile": 0.81602}, "CVE-2017-5627": {"epss_score": 0.00287, "epss_percentile": 0.51832}, "CVE-2017-5628": {"epss_score": 0.00166, "epss_percentile": 0.38185}, "CVE-2017-5630": {"epss_score": 0.05117, "epss_percentile": 0.89513}, "CVE-2017-5631": {"epss_score": 0.2527, "epss_percentile": 0.96006}, "CVE-2017-5632": {"epss_score": 0.00186, "epss_percentile": 0.40591}, "CVE-2017-5633": {"epss_score": 0.0137, "epss_percentile": 0.79797}, "CVE-2017-5634": {"epss_score": 0.0006, "epss_percentile": 0.19132}, "CVE-2017-5635": {"epss_score": 0.01131, "epss_percentile": 0.7786}, "CVE-2017-5636": {"epss_score": 0.01041, "epss_percentile": 0.76969}, "CVE-2017-5637": {"epss_score": 0.17446, "epss_percentile": 0.94852}, "CVE-2017-5638": {"epss_score": 0.94267, "epss_percentile": 0.9993}, "CVE-2017-5640": {"epss_score": 0.01296, "epss_percentile": 0.79255}, "CVE-2017-5641": {"epss_score": 0.49668, "epss_percentile": 0.97699}, "CVE-2017-5642": {"epss_score": 0.00769, "epss_percentile": 0.72982}, "CVE-2017-5643": {"epss_score": 0.0181, "epss_percentile": 0.82364}, "CVE-2017-5644": {"epss_score": 0.0066, "epss_percentile": 0.70531}, "CVE-2017-5645": {"epss_score": 0.94013, "epss_percentile": 0.99886}, "CVE-2017-5646": {"epss_score": 0.00038, "epss_percentile": 0.11122}, "CVE-2017-5647": {"epss_score": 0.02978, "epss_percentile": 0.86113}, "CVE-2017-5648": {"epss_score": 0.19005, "epss_percentile": 0.9511}, "CVE-2017-5649": {"epss_score": 0.00099, "epss_percentile": 0.28347}, "CVE-2017-5650": {"epss_score": 0.18596, "epss_percentile": 0.9504}, "CVE-2017-5651": {"epss_score": 0.05572, "epss_percentile": 0.90008}, "CVE-2017-5652": {"epss_score": 0.00333, "epss_percentile": 0.55669}, "CVE-2017-5653": {"epss_score": 0.03167, "epss_percentile": 0.86541}, "CVE-2017-5654": {"epss_score": 0.00907, "epss_percentile": 0.75262}, "CVE-2017-5655": {"epss_score": 0.00149, "epss_percentile": 0.35934}, "CVE-2017-5656": {"epss_score": 0.03801, "epss_percentile": 0.87745}, "CVE-2017-5657": {"epss_score": 0.00123, "epss_percentile": 0.32309}, "CVE-2017-5658": {"epss_score": 0.00922, "epss_percentile": 0.75487}, "CVE-2017-5659": {"epss_score": 0.01461, "epss_percentile": 0.80431}, "CVE-2017-5660": {"epss_score": 0.02584, "epss_percentile": 0.85161}, "CVE-2017-5661": {"epss_score": 0.0211, "epss_percentile": 0.83644}, "CVE-2017-5662": {"epss_score": 0.00179, "epss_percentile": 0.3985}, "CVE-2017-5663": {"epss_score": 0.00194, "epss_percentile": 0.4158}, "CVE-2017-5664": {"epss_score": 0.10802, "epss_percentile": 0.93107}, "CVE-2017-5665": {"epss_score": 0.00245, "epss_percentile": 0.47695}, "CVE-2017-5666": {"epss_score": 0.00245, "epss_percentile": 0.47695}, "CVE-2017-5667": {"epss_score": 0.00223, "epss_percentile": 0.44877}, "CVE-2017-5668": {"epss_score": 0.02443, "epss_percentile": 0.84757}, "CVE-2017-5669": {"epss_score": 0.00051, "epss_percentile": 0.16137}, "CVE-2017-5670": {"epss_score": 0.00105, "epss_percentile": 0.29302}, "CVE-2017-5671": {"epss_score": 0.00507, "epss_percentile": 0.65661}, "CVE-2017-5672": {"epss_score": 0.00214, "epss_percentile": 0.43975}, "CVE-2017-5673": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-5674": {"epss_score": 0.00808, "epss_percentile": 0.73684}, "CVE-2017-5675": {"epss_score": 0.00673, "epss_percentile": 0.70832}, "CVE-2017-5677": {"epss_score": 0.04016, "epss_percentile": 0.88122}, "CVE-2017-5681": {"epss_score": 0.00297, "epss_percentile": 0.5277}, "CVE-2017-5682": {"epss_score": 0.00109, "epss_percentile": 0.30059}, "CVE-2017-5683": {"epss_score": 0.00044, "epss_percentile": 0.13628}, "CVE-2017-5684": {"epss_score": 0.00049, "epss_percentile": 0.15466}, "CVE-2017-5685": {"epss_score": 0.00064, "epss_percentile": 0.20154}, "CVE-2017-5686": {"epss_score": 0.00055, "epss_percentile": 0.17652}, "CVE-2017-5688": {"epss_score": 0.00073, "epss_percentile": 0.22535}, "CVE-2017-5689": {"epss_score": 0.94254, "epss_percentile": 0.99927}, "CVE-2017-5691": {"epss_score": 0.00407, "epss_percentile": 0.60569}, "CVE-2017-5692": {"epss_score": 0.00041, "epss_percentile": 0.12415}, "CVE-2017-5693": {"epss_score": 0.17684, "epss_percentile": 0.94888}, "CVE-2017-5694": {"epss_score": 0.00043, "epss_percentile": 0.12965}, "CVE-2017-5695": {"epss_score": 0.00047, "epss_percentile": 0.14788}, "CVE-2017-5696": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2017-5697": {"epss_score": 0.00209, "epss_percentile": 0.43407}, "CVE-2017-5698": {"epss_score": 0.0012, "epss_percentile": 0.31768}, "CVE-2017-5699": {"epss_score": 0.00048, "epss_percentile": 0.15028}, "CVE-2017-5700": {"epss_score": 0.00051, "epss_percentile": 0.16205}, "CVE-2017-5701": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2017-5703": {"epss_score": 0.00123, "epss_percentile": 0.32181}, "CVE-2017-5704": {"epss_score": 0.0004, "epss_percentile": 0.12044}, "CVE-2017-5705": {"epss_score": 0.00117, "epss_percentile": 0.31352}, "CVE-2017-5706": {"epss_score": 0.00114, "epss_percentile": 0.30867}, "CVE-2017-5707": {"epss_score": 0.00119, "epss_percentile": 0.31669}, "CVE-2017-5708": {"epss_score": 0.001, "epss_percentile": 0.28542}, "CVE-2017-5709": {"epss_score": 0.00096, "epss_percentile": 0.27356}, "CVE-2017-5710": {"epss_score": 0.00073, "epss_percentile": 0.22668}, "CVE-2017-5711": {"epss_score": 0.00149, "epss_percentile": 0.35939}, "CVE-2017-5712": {"epss_score": 0.01885, "epss_percentile": 0.82707}, "CVE-2017-5715": {"epss_score": 0.91588, "epss_percentile": 0.99655}, "CVE-2017-5717": {"epss_score": 0.00694, "epss_percentile": 0.71342}, "CVE-2017-5719": {"epss_score": 0.00866, "epss_percentile": 0.7464}, "CVE-2017-5721": {"epss_score": 0.03989, "epss_percentile": 0.88069}, "CVE-2017-5722": {"epss_score": 0.00046, "epss_percentile": 0.14144}, "CVE-2017-5727": {"epss_score": 0.00037, "epss_percentile": 0.10868}, "CVE-2017-5729": {"epss_score": 0.00683, "epss_percentile": 0.71094}, "CVE-2017-5731": {"epss_score": 0.00119, "epss_percentile": 0.31588}, "CVE-2017-5736": {"epss_score": 0.00047, "epss_percentile": 0.1462}, "CVE-2017-5738": {"epss_score": 0.00512, "epss_percentile": 0.65873}, "CVE-2017-5753": {"epss_score": 0.94332, "epss_percentile": 0.99949}, "CVE-2017-5754": {"epss_score": 0.88928, "epss_percentile": 0.99499}, "CVE-2017-5780": {"epss_score": 0.00487, "epss_percentile": 0.64782}, "CVE-2017-5781": {"epss_score": 0.00189, "epss_percentile": 0.40929}, "CVE-2017-5782": {"epss_score": 0.00366, "epss_percentile": 0.58078}, "CVE-2017-5783": {"epss_score": 0.00562, "epss_percentile": 0.67703}, "CVE-2017-5784": {"epss_score": 0.00471, "epss_percentile": 0.64}, "CVE-2017-5785": {"epss_score": 0.00531, "epss_percentile": 0.6665}, "CVE-2017-5786": {"epss_score": 0.00268, "epss_percentile": 0.50044}, "CVE-2017-5787": {"epss_score": 0.00346, "epss_percentile": 0.56627}, "CVE-2017-5788": {"epss_score": 0.00216, "epss_percentile": 0.44144}, "CVE-2017-5789": {"epss_score": 0.33852, "epss_percentile": 0.96809}, "CVE-2017-5790": {"epss_score": 0.39764, "epss_percentile": 0.97179}, "CVE-2017-5791": {"epss_score": 0.64342, "epss_percentile": 0.98374}, "CVE-2017-5792": {"epss_score": 0.80795, "epss_percentile": 0.99106}, "CVE-2017-5793": {"epss_score": 0.02394, "epss_percentile": 0.84613}, "CVE-2017-5794": {"epss_score": 0.01032, "epss_percentile": 0.76861}, "CVE-2017-5795": {"epss_score": 0.00559, "epss_percentile": 0.67626}, "CVE-2017-5796": {"epss_score": 0.00426, "epss_percentile": 0.61753}, "CVE-2017-5797": {"epss_score": 0.0205, "epss_percentile": 0.83397}, "CVE-2017-5798": {"epss_score": 0.05883, "epss_percentile": 0.90292}, "CVE-2017-5799": {"epss_score": 0.13721, "epss_percentile": 0.94043}, "CVE-2017-5800": {"epss_score": 0.00236, "epss_percentile": 0.46419}, "CVE-2017-5801": {"epss_score": 0.05273, "epss_percentile": 0.89681}, "CVE-2017-5802": {"epss_score": 0.00493, "epss_percentile": 0.65029}, "CVE-2017-5803": {"epss_score": 0.07244, "epss_percentile": 0.91347}, "CVE-2017-5804": {"epss_score": 0.52361, "epss_percentile": 0.97821}, "CVE-2017-5805": {"epss_score": 0.55427, "epss_percentile": 0.97977}, "CVE-2017-5806": {"epss_score": 0.55427, "epss_percentile": 0.97977}, "CVE-2017-5807": {"epss_score": 0.43954, "epss_percentile": 0.9741}, "CVE-2017-5808": {"epss_score": 0.18202, "epss_percentile": 0.94974}, "CVE-2017-5809": {"epss_score": 0.00658, "epss_percentile": 0.70491}, "CVE-2017-5810": {"epss_score": 0.11909, "epss_percentile": 0.93512}, "CVE-2017-5811": {"epss_score": 0.14171, "epss_percentile": 0.94149}, "CVE-2017-5812": {"epss_score": 0.06209, "epss_percentile": 0.90569}, "CVE-2017-5813": {"epss_score": 0.00453, "epss_percentile": 0.63222}, "CVE-2017-5814": {"epss_score": 0.23574, "epss_percentile": 0.95793}, "CVE-2017-5815": {"epss_score": 0.58568, "epss_percentile": 0.98124}, "CVE-2017-5816": {"epss_score": 0.89949, "epss_percentile": 0.99551}, "CVE-2017-5817": {"epss_score": 0.82548, "epss_percentile": 0.992}, "CVE-2017-5818": {"epss_score": 0.13579, "epss_percentile": 0.94001}, "CVE-2017-5819": {"epss_score": 0.51056, "epss_percentile": 0.97762}, "CVE-2017-5820": {"epss_score": 0.51056, "epss_percentile": 0.97762}, "CVE-2017-5821": {"epss_score": 0.4452, "epss_percentile": 0.97442}, "CVE-2017-5822": {"epss_score": 0.21053, "epss_percentile": 0.95458}, "CVE-2017-5823": {"epss_score": 0.51056, "epss_percentile": 0.97762}, "CVE-2017-5824": {"epss_score": 0.24094, "epss_percentile": 0.95869}, "CVE-2017-5825": {"epss_score": 0.01719, "epss_percentile": 0.81924}, "CVE-2017-5826": {"epss_score": 0.02465, "epss_percentile": 0.84835}, "CVE-2017-5827": {"epss_score": 0.00279, "epss_percentile": 0.50939}, "CVE-2017-5828": {"epss_score": 0.00522, "epss_percentile": 0.66279}, "CVE-2017-5829": {"epss_score": 0.00129, "epss_percentile": 0.33087}, "CVE-2017-5830": {"epss_score": 0.03495, "epss_percentile": 0.87235}, "CVE-2017-5831": {"epss_score": 0.00222, "epss_percentile": 0.44825}, "CVE-2017-5832": {"epss_score": 0.00231, "epss_percentile": 0.45787}, "CVE-2017-5833": {"epss_score": 0.00308, "epss_percentile": 0.53629}, "CVE-2017-5834": {"epss_score": 0.00504, "epss_percentile": 0.65538}, "CVE-2017-5835": {"epss_score": 0.00728, "epss_percentile": 0.72115}, "CVE-2017-5836": {"epss_score": 0.00446, "epss_percentile": 0.62926}, "CVE-2017-5837": {"epss_score": 0.00756, "epss_percentile": 0.72738}, "CVE-2017-5838": {"epss_score": 0.02755, "epss_percentile": 0.8559}, "CVE-2017-5839": {"epss_score": 0.03053, "epss_percentile": 0.86293}, "CVE-2017-5840": {"epss_score": 0.14085, "epss_percentile": 0.9413}, "CVE-2017-5841": {"epss_score": 0.02478, "epss_percentile": 0.84866}, "CVE-2017-5842": {"epss_score": 0.0083, "epss_percentile": 0.74025}, "CVE-2017-5843": {"epss_score": 0.0655, "epss_percentile": 0.90843}, "CVE-2017-5844": {"epss_score": 0.00756, "epss_percentile": 0.72738}, "CVE-2017-5845": {"epss_score": 0.02478, "epss_percentile": 0.84866}, "CVE-2017-5846": {"epss_score": 0.0083, "epss_percentile": 0.74025}, "CVE-2017-5847": {"epss_score": 0.03089, "epss_percentile": 0.86392}, "CVE-2017-5848": {"epss_score": 0.05482, "epss_percentile": 0.8992}, "CVE-2017-5849": {"epss_score": 0.00234, "epss_percentile": 0.46115}, "CVE-2017-5850": {"epss_score": 0.4959, "epss_percentile": 0.97696}, "CVE-2017-5851": {"epss_score": 0.00245, "epss_percentile": 0.47695}, "CVE-2017-5852": {"epss_score": 0.00462, "epss_percentile": 0.63588}, "CVE-2017-5853": {"epss_score": 0.00386, "epss_percentile": 0.59272}, "CVE-2017-5854": {"epss_score": 0.00595, "epss_percentile": 0.68685}, "CVE-2017-5855": {"epss_score": 0.00435, "epss_percentile": 0.62372}, "CVE-2017-5856": {"epss_score": 0.00143, "epss_percentile": 0.35119}, "CVE-2017-5857": {"epss_score": 0.00143, "epss_percentile": 0.35119}, "CVE-2017-5858": {"epss_score": 0.00253, "epss_percentile": 0.48449}, "CVE-2017-5859": {"epss_score": 0.00182, "epss_percentile": 0.4024}, "CVE-2017-5863": {"epss_score": 0.00588, "epss_percentile": 0.68499}, "CVE-2017-5864": {"epss_score": 0.00378, "epss_percentile": 0.58796}, "CVE-2017-5865": {"epss_score": 0.00203, "epss_percentile": 0.42499}, "CVE-2017-5866": {"epss_score": 0.00152, "epss_percentile": 0.36384}, "CVE-2017-5867": {"epss_score": 0.00597, "epss_percentile": 0.68751}, "CVE-2017-5868": {"epss_score": 0.08462, "epss_percentile": 0.92065}, "CVE-2017-5869": {"epss_score": 0.02599, "epss_percentile": 0.85203}, "CVE-2017-5870": {"epss_score": 0.00158, "epss_percentile": 0.37286}, "CVE-2017-5871": {"epss_score": 0.02676, "epss_percentile": 0.85401}, "CVE-2017-5872": {"epss_score": 0.00694, "epss_percentile": 0.71338}, "CVE-2017-5873": {"epss_score": 0.00065, "epss_percentile": 0.20598}, "CVE-2017-5874": {"epss_score": 0.00043, "epss_percentile": 0.13103}, "CVE-2017-5875": {"epss_score": 0.00282, "epss_percentile": 0.51215}, "CVE-2017-5876": {"epss_score": 0.00474, "epss_percentile": 0.64156}, "CVE-2017-5877": {"epss_score": 0.00474, "epss_percentile": 0.64156}, "CVE-2017-5878": {"epss_score": 0.03142, "epss_percentile": 0.8649}, "CVE-2017-5879": {"epss_score": 0.00329, "epss_percentile": 0.55379}, "CVE-2017-5880": {"epss_score": 0.00558, "epss_percentile": 0.6756}, "CVE-2017-5881": {"epss_score": 0.01277, "epss_percentile": 0.7912}, "CVE-2017-5882": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2017-5884": {"epss_score": 0.00457, "epss_percentile": 0.63381}, "CVE-2017-5885": {"epss_score": 0.0065, "epss_percentile": 0.70251}, "CVE-2017-5886": {"epss_score": 0.00487, "epss_percentile": 0.64802}, "CVE-2017-5887": {"epss_score": 0.00224, "epss_percentile": 0.45006}, "CVE-2017-5891": {"epss_score": 0.00159, "epss_percentile": 0.37328}, "CVE-2017-5892": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2017-5896": {"epss_score": 0.00405, "epss_percentile": 0.60484}, "CVE-2017-5897": {"epss_score": 0.01986, "epss_percentile": 0.83159}, "CVE-2017-5898": {"epss_score": 0.00094, "epss_percentile": 0.26967}, "CVE-2017-5899": {"epss_score": 0.00788, "epss_percentile": 0.73335}, "CVE-2017-5900": {"epss_score": 0.00268, "epss_percentile": 0.50036}, "CVE-2017-5901": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5902": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5905": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5906": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5907": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5909": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5911": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5912": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5913": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5914": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5915": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5916": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5918": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5919": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-5923": {"epss_score": 0.00787, "epss_percentile": 0.73313}, "CVE-2017-5924": {"epss_score": 0.00546, "epss_percentile": 0.67204}, "CVE-2017-5925": {"epss_score": 0.00383, "epss_percentile": 0.59112}, "CVE-2017-5926": {"epss_score": 0.00383, "epss_percentile": 0.59112}, "CVE-2017-5927": {"epss_score": 0.00383, "epss_percentile": 0.59112}, "CVE-2017-5928": {"epss_score": 0.00641, "epss_percentile": 0.69996}, "CVE-2017-5929": {"epss_score": 0.13693, "epss_percentile": 0.94036}, "CVE-2017-5930": {"epss_score": 0.39864, "epss_percentile": 0.97185}, "CVE-2017-5931": {"epss_score": 0.00238, "epss_percentile": 0.46765}, "CVE-2017-5932": {"epss_score": 0.00213, "epss_percentile": 0.43918}, "CVE-2017-5933": {"epss_score": 0.00531, "epss_percentile": 0.66662}, "CVE-2017-5934": {"epss_score": 0.00652, "epss_percentile": 0.70313}, "CVE-2017-5936": {"epss_score": 0.02467, "epss_percentile": 0.84838}, "CVE-2017-5937": {"epss_score": 0.00091, "epss_percentile": 0.26275}, "CVE-2017-5938": {"epss_score": 0.00631, "epss_percentile": 0.69722}, "CVE-2017-5940": {"epss_score": 0.00085, "epss_percentile": 0.25124}, "CVE-2017-5941": {"epss_score": 0.7793, "epss_percentile": 0.9896}, "CVE-2017-5942": {"epss_score": 0.00193, "epss_percentile": 0.41438}, "CVE-2017-5943": {"epss_score": 0.00409, "epss_percentile": 0.60764}, "CVE-2017-5944": {"epss_score": 0.04438, "epss_percentile": 0.8869}, "CVE-2017-5945": {"epss_score": 0.00353, "epss_percentile": 0.57157}, "CVE-2017-5946": {"epss_score": 0.05924, "epss_percentile": 0.90325}, "CVE-2017-5947": {"epss_score": 0.00139, "epss_percentile": 0.34643}, "CVE-2017-5948": {"epss_score": 0.00294, "epss_percentile": 0.52389}, "CVE-2017-5949": {"epss_score": 0.01816, "epss_percentile": 0.82394}, "CVE-2017-5950": {"epss_score": 0.00776, "epss_percentile": 0.731}, "CVE-2017-5951": {"epss_score": 0.0086, "epss_percentile": 0.74533}, "CVE-2017-5953": {"epss_score": 0.00913, "epss_percentile": 0.75381}, "CVE-2017-5954": {"epss_score": 0.00329, "epss_percentile": 0.55398}, "CVE-2017-5956": {"epss_score": 0.00085, "epss_percentile": 0.25056}, "CVE-2017-5957": {"epss_score": 0.00083, "epss_percentile": 0.24818}, "CVE-2017-5959": {"epss_score": 0.00122, "epss_percentile": 0.32142}, "CVE-2017-5960": {"epss_score": 0.00353, "epss_percentile": 0.57157}, "CVE-2017-5961": {"epss_score": 0.00311, "epss_percentile": 0.53925}, "CVE-2017-5962": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-5963": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-5964": {"epss_score": 0.00353, "epss_percentile": 0.57157}, "CVE-2017-5965": {"epss_score": 0.0038, "epss_percentile": 0.58914}, "CVE-2017-5966": {"epss_score": 0.00271, "epss_percentile": 0.50282}, "CVE-2017-5967": {"epss_score": 0.00048, "epss_percentile": 0.14936}, "CVE-2017-5969": {"epss_score": 0.0271, "epss_percentile": 0.8549}, "CVE-2017-5970": {"epss_score": 0.01752, "epss_percentile": 0.82106}, "CVE-2017-5971": {"epss_score": 0.00463, "epss_percentile": 0.63667}, "CVE-2017-5972": {"epss_score": 0.18911, "epss_percentile": 0.95096}, "CVE-2017-5973": {"epss_score": 0.00095, "epss_percentile": 0.27081}, "CVE-2017-5974": {"epss_score": 0.00601, "epss_percentile": 0.68856}, "CVE-2017-5975": {"epss_score": 0.00634, "epss_percentile": 0.69795}, "CVE-2017-5976": {"epss_score": 0.00634, "epss_percentile": 0.69795}, "CVE-2017-5977": {"epss_score": 0.00457, "epss_percentile": 0.6336}, "CVE-2017-5978": {"epss_score": 0.00426, "epss_percentile": 0.6174}, "CVE-2017-5979": {"epss_score": 0.00426, "epss_percentile": 0.6174}, "CVE-2017-5980": {"epss_score": 0.00221, "epss_percentile": 0.44687}, "CVE-2017-5981": {"epss_score": 0.00426, "epss_percentile": 0.6174}, "CVE-2017-5982": {"epss_score": 0.8642, "epss_percentile": 0.99381}, "CVE-2017-5983": {"epss_score": 0.08385, "epss_percentile": 0.9202}, "CVE-2017-5984": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2017-5985": {"epss_score": 0.0009, "epss_percentile": 0.26157}, "CVE-2017-5986": {"epss_score": 0.0055, "epss_percentile": 0.67323}, "CVE-2017-5987": {"epss_score": 0.00066, "epss_percentile": 0.20686}, "CVE-2017-5988": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2017-5990": {"epss_score": 0.00313, "epss_percentile": 0.54069}, "CVE-2017-5991": {"epss_score": 0.1757, "epss_percentile": 0.94868}, "CVE-2017-5992": {"epss_score": 0.00528, "epss_percentile": 0.66547}, "CVE-2017-5993": {"epss_score": 0.00067, "epss_percentile": 0.21013}, "CVE-2017-5994": {"epss_score": 0.0007, "epss_percentile": 0.21825}, "CVE-2017-5995": {"epss_score": 0.0036, "epss_percentile": 0.57684}, "CVE-2017-5996": {"epss_score": 0.00145, "epss_percentile": 0.35349}, "CVE-2017-5997": {"epss_score": 0.00736, "epss_percentile": 0.72312}, "CVE-2017-5998": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2017-5999": {"epss_score": 0.00317, "epss_percentile": 0.54357}, "CVE-2017-6001": {"epss_score": 0.00115, "epss_percentile": 0.31017}, "CVE-2017-6002": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2017-6003": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-6004": {"epss_score": 0.03327, "epss_percentile": 0.86924}, "CVE-2017-6005": {"epss_score": 0.00047, "epss_percentile": 0.14891}, "CVE-2017-6007": {"epss_score": 0.00019, "epss_percentile": 0.04079}, "CVE-2017-6008": {"epss_score": 0.02775, "epss_percentile": 0.85635}, "CVE-2017-6009": {"epss_score": 0.0028, "epss_percentile": 0.51087}, "CVE-2017-6010": {"epss_score": 0.00354, "epss_percentile": 0.57228}, "CVE-2017-6011": {"epss_score": 0.00354, "epss_percentile": 0.57228}, "CVE-2017-6013": {"epss_score": 0.00567, "epss_percentile": 0.67837}, "CVE-2017-6014": {"epss_score": 0.00423, "epss_percentile": 0.61622}, "CVE-2017-6015": {"epss_score": 0.00054, "epss_percentile": 0.17059}, "CVE-2017-6016": {"epss_score": 0.00074, "epss_percentile": 0.22687}, "CVE-2017-6017": {"epss_score": 0.0517, "epss_percentile": 0.89568}, "CVE-2017-6018": {"epss_score": 0.00154, "epss_percentile": 0.36677}, "CVE-2017-6019": {"epss_score": 0.2416, "epss_percentile": 0.95881}, "CVE-2017-6020": {"epss_score": 0.06683, "epss_percentile": 0.9094}, "CVE-2017-6021": {"epss_score": 0.00449, "epss_percentile": 0.63031}, "CVE-2017-6022": {"epss_score": 0.00525, "epss_percentile": 0.66389}, "CVE-2017-6023": {"epss_score": 0.03955, "epss_percentile": 0.88004}, "CVE-2017-6024": {"epss_score": 0.00049, "epss_percentile": 0.15558}, "CVE-2017-6025": {"epss_score": 0.00629, "epss_percentile": 0.69681}, "CVE-2017-6026": {"epss_score": 0.14763, "epss_percentile": 0.94277}, "CVE-2017-6027": {"epss_score": 0.01992, "epss_percentile": 0.83181}, "CVE-2017-6028": {"epss_score": 0.0023, "epss_percentile": 0.45715}, "CVE-2017-6029": {"epss_score": 0.00137, "epss_percentile": 0.34341}, "CVE-2017-6030": {"epss_score": 0.00394, "epss_percentile": 0.59793}, "CVE-2017-6031": {"epss_score": 0.01153, "epss_percentile": 0.78059}, "CVE-2017-6032": {"epss_score": 0.00458, "epss_percentile": 0.6342}, "CVE-2017-6033": {"epss_score": 0.00216, "epss_percentile": 0.4419}, "CVE-2017-6034": {"epss_score": 0.00164, "epss_percentile": 0.37864}, "CVE-2017-6035": {"epss_score": 0.00348, "epss_percentile": 0.56849}, "CVE-2017-6036": {"epss_score": 0.00152, "epss_percentile": 0.36405}, "CVE-2017-6037": {"epss_score": 0.00406, "epss_percentile": 0.60522}, "CVE-2017-6038": {"epss_score": 0.00077, "epss_percentile": 0.23434}, "CVE-2017-6039": {"epss_score": 0.00244, "epss_percentile": 0.47525}, "CVE-2017-6040": {"epss_score": 0.00189, "epss_percentile": 0.40969}, "CVE-2017-6041": {"epss_score": 0.00627, "epss_percentile": 0.69627}, "CVE-2017-6042": {"epss_score": 0.00131, "epss_percentile": 0.33477}, "CVE-2017-6043": {"epss_score": 0.00552, "epss_percentile": 0.674}, "CVE-2017-6044": {"epss_score": 0.0769, "epss_percentile": 0.91629}, "CVE-2017-6045": {"epss_score": 0.00522, "epss_percentile": 0.66256}, "CVE-2017-6046": {"epss_score": 0.00384, "epss_percentile": 0.59132}, "CVE-2017-6047": {"epss_score": 0.00261, "epss_percentile": 0.49279}, "CVE-2017-6048": {"epss_score": 0.45622, "epss_percentile": 0.97493}, "CVE-2017-6049": {"epss_score": 0.00385, "epss_percentile": 0.59218}, "CVE-2017-6050": {"epss_score": 0.01273, "epss_percentile": 0.79085}, "CVE-2017-6051": {"epss_score": 0.00262, "epss_percentile": 0.49326}, "CVE-2017-6052": {"epss_score": 0.00127, "epss_percentile": 0.32886}, "CVE-2017-6053": {"epss_score": 0.0017, "epss_percentile": 0.38677}, "CVE-2017-6054": {"epss_score": 0.00868, "epss_percentile": 0.74663}, "CVE-2017-6055": {"epss_score": 0.00542, "epss_percentile": 0.67061}, "CVE-2017-6056": {"epss_score": 0.17815, "epss_percentile": 0.94911}, "CVE-2017-6058": {"epss_score": 0.03408, "epss_percentile": 0.87079}, "CVE-2017-6059": {"epss_score": 0.0201, "epss_percentile": 0.83246}, "CVE-2017-6060": {"epss_score": 0.02921, "epss_percentile": 0.85992}, "CVE-2017-6061": {"epss_score": 0.00756, "epss_percentile": 0.7274}, "CVE-2017-6062": {"epss_score": 0.00413, "epss_percentile": 0.60989}, "CVE-2017-6065": {"epss_score": 0.00344, "epss_percentile": 0.56499}, "CVE-2017-6066": {"epss_score": 0.00207, "epss_percentile": 0.43169}, "CVE-2017-6067": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-6068": {"epss_score": 0.00207, "epss_percentile": 0.43169}, "CVE-2017-6069": {"epss_score": 0.00207, "epss_percentile": 0.43169}, "CVE-2017-6070": {"epss_score": 0.00799, "epss_percentile": 0.73522}, "CVE-2017-6071": {"epss_score": 0.00312, "epss_percentile": 0.53952}, "CVE-2017-6072": {"epss_score": 0.00244, "epss_percentile": 0.47619}, "CVE-2017-6074": {"epss_score": 0.18323, "epss_percentile": 0.94995}, "CVE-2017-6076": {"epss_score": 0.00154, "epss_percentile": 0.36722}, "CVE-2017-6077": {"epss_score": 0.86105, "epss_percentile": 0.99367}, "CVE-2017-6078": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2017-6079": {"epss_score": 0.3236, "epss_percentile": 0.96692}, "CVE-2017-6080": {"epss_score": 0.00172, "epss_percentile": 0.3899}, "CVE-2017-6081": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2017-6086": {"epss_score": 0.00168, "epss_percentile": 0.38459}, "CVE-2017-6087": {"epss_score": 0.05768, "epss_percentile": 0.90189}, "CVE-2017-6088": {"epss_score": 0.06903, "epss_percentile": 0.91105}, "CVE-2017-6089": {"epss_score": 0.02642, "epss_percentile": 0.85309}, "CVE-2017-6090": {"epss_score": 0.86913, "epss_percentile": 0.99403}, "CVE-2017-6094": {"epss_score": 0.00441, "epss_percentile": 0.62674}, "CVE-2017-6095": {"epss_score": 0.06929, "epss_percentile": 0.91121}, "CVE-2017-6096": {"epss_score": 0.04583, "epss_percentile": 0.88882}, "CVE-2017-6097": {"epss_score": 0.06096, "epss_percentile": 0.90477}, "CVE-2017-6098": {"epss_score": 0.07106, "epss_percentile": 0.91256}, "CVE-2017-6099": {"epss_score": 0.00233, "epss_percentile": 0.45976}, "CVE-2017-6100": {"epss_score": 0.0031, "epss_percentile": 0.53807}, "CVE-2017-6102": {"epss_score": 0.00235, "epss_percentile": 0.46313}, "CVE-2017-6103": {"epss_score": 0.00193, "epss_percentile": 0.41438}, "CVE-2017-6104": {"epss_score": 0.38597, "epss_percentile": 0.97108}, "CVE-2017-6127": {"epss_score": 0.00167, "epss_percentile": 0.38313}, "CVE-2017-6128": {"epss_score": 0.00926, "epss_percentile": 0.75554}, "CVE-2017-6129": {"epss_score": 0.00492, "epss_percentile": 0.65013}, "CVE-2017-6130": {"epss_score": 0.00344, "epss_percentile": 0.56498}, "CVE-2017-6131": {"epss_score": 0.00775, "epss_percentile": 0.73089}, "CVE-2017-6132": {"epss_score": 0.02162, "epss_percentile": 0.83829}, "CVE-2017-6133": {"epss_score": 0.00647, "epss_percentile": 0.70204}, "CVE-2017-6134": {"epss_score": 0.0141, "epss_percentile": 0.80084}, "CVE-2017-6135": {"epss_score": 0.0052, "epss_percentile": 0.66185}, "CVE-2017-6136": {"epss_score": 0.00566, "epss_percentile": 0.67817}, "CVE-2017-6137": {"epss_score": 0.00702, "epss_percentile": 0.71508}, "CVE-2017-6138": {"epss_score": 0.00662, "epss_percentile": 0.70606}, "CVE-2017-6139": {"epss_score": 0.00432, "epss_percentile": 0.62103}, "CVE-2017-6140": {"epss_score": 0.00628, "epss_percentile": 0.6965}, "CVE-2017-6141": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2017-6142": {"epss_score": 0.00098, "epss_percentile": 0.27661}, "CVE-2017-6143": {"epss_score": 0.00111, "epss_percentile": 0.30331}, "CVE-2017-6144": {"epss_score": 0.00172, "epss_percentile": 0.38995}, "CVE-2017-6145": {"epss_score": 0.00365, "epss_percentile": 0.58}, "CVE-2017-6147": {"epss_score": 0.00675, "epss_percentile": 0.7091}, "CVE-2017-6148": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2017-6150": {"epss_score": 0.00588, "epss_percentile": 0.68492}, "CVE-2017-6151": {"epss_score": 0.00492, "epss_percentile": 0.65013}, "CVE-2017-6152": {"epss_score": 0.00073, "epss_percentile": 0.22658}, "CVE-2017-6153": {"epss_score": 0.00604, "epss_percentile": 0.68958}, "CVE-2017-6154": {"epss_score": 0.00749, "epss_percentile": 0.72607}, "CVE-2017-6155": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2017-6156": {"epss_score": 0.00394, "epss_percentile": 0.59786}, "CVE-2017-6157": {"epss_score": 0.06882, "epss_percentile": 0.91091}, "CVE-2017-6158": {"epss_score": 0.00609, "epss_percentile": 0.69134}, "CVE-2017-6159": {"epss_score": 0.00911, "epss_percentile": 0.75325}, "CVE-2017-6160": {"epss_score": 0.04588, "epss_percentile": 0.88889}, "CVE-2017-6161": {"epss_score": 0.02586, "epss_percentile": 0.85165}, "CVE-2017-6162": {"epss_score": 0.01522, "epss_percentile": 0.80834}, "CVE-2017-6163": {"epss_score": 0.01522, "epss_percentile": 0.80834}, "CVE-2017-6164": {"epss_score": 0.02462, "epss_percentile": 0.84828}, "CVE-2017-6165": {"epss_score": 0.01951, "epss_percentile": 0.83016}, "CVE-2017-6166": {"epss_score": 0.01202, "epss_percentile": 0.7849}, "CVE-2017-6167": {"epss_score": 0.00312, "epss_percentile": 0.5401}, "CVE-2017-6168": {"epss_score": 0.6991, "epss_percentile": 0.98608}, "CVE-2017-6169": {"epss_score": 0.00675, "epss_percentile": 0.7091}, "CVE-2017-6178": {"epss_score": 0.00114, "epss_percentile": 0.30857}, "CVE-2017-6180": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2017-6181": {"epss_score": 0.00696, "epss_percentile": 0.71388}, "CVE-2017-6182": {"epss_score": 0.14264, "epss_percentile": 0.94176}, "CVE-2017-6183": {"epss_score": 0.02574, "epss_percentile": 0.85139}, "CVE-2017-6184": {"epss_score": 0.01163, "epss_percentile": 0.78159}, "CVE-2017-6186": {"epss_score": 0.00142, "epss_percentile": 0.34986}, "CVE-2017-6187": {"epss_score": 0.69378, "epss_percentile": 0.98584}, "CVE-2017-6188": {"epss_score": 0.00135, "epss_percentile": 0.33972}, "CVE-2017-6189": {"epss_score": 0.00047, "epss_percentile": 0.14596}, "CVE-2017-6190": {"epss_score": 0.64648, "epss_percentile": 0.98388}, "CVE-2017-6191": {"epss_score": 0.02639, "epss_percentile": 0.85299}, "CVE-2017-6192": {"epss_score": 0.0361, "epss_percentile": 0.87424}, "CVE-2017-6193": {"epss_score": 0.1167, "epss_percentile": 0.9344}, "CVE-2017-6194": {"epss_score": 0.00157, "epss_percentile": 0.37064}, "CVE-2017-6195": {"epss_score": 0.00096, "epss_percentile": 0.27379}, "CVE-2017-6196": {"epss_score": 0.00367, "epss_percentile": 0.58103}, "CVE-2017-6197": {"epss_score": 0.00294, "epss_percentile": 0.52396}, "CVE-2017-6198": {"epss_score": 0.00604, "epss_percentile": 0.68951}, "CVE-2017-6199": {"epss_score": 0.00089, "epss_percentile": 0.25979}, "CVE-2017-6200": {"epss_score": 0.00287, "epss_percentile": 0.51831}, "CVE-2017-6201": {"epss_score": 0.00091, "epss_percentile": 0.26385}, "CVE-2017-6205": {"epss_score": 0.02353, "epss_percentile": 0.84476}, "CVE-2017-6206": {"epss_score": 0.46431, "epss_percentile": 0.97545}, "CVE-2017-6209": {"epss_score": 0.00065, "epss_percentile": 0.20611}, "CVE-2017-6210": {"epss_score": 0.00066, "epss_percentile": 0.20892}, "CVE-2017-6211": {"epss_score": 0.00114, "epss_percentile": 0.30855}, "CVE-2017-6213": {"epss_score": 0.00274, "epss_percentile": 0.50555}, "CVE-2017-6214": {"epss_score": 0.0946, "epss_percentile": 0.92557}, "CVE-2017-6215": {"epss_score": 0.00274, "epss_percentile": 0.50555}, "CVE-2017-6216": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2017-6217": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2017-6223": {"epss_score": 0.01432, "epss_percentile": 0.80251}, "CVE-2017-6224": {"epss_score": 0.00868, "epss_percentile": 0.74667}, "CVE-2017-6225": {"epss_score": 0.00559, "epss_percentile": 0.67606}, "CVE-2017-6227": {"epss_score": 0.00145, "epss_percentile": 0.35407}, "CVE-2017-6229": {"epss_score": 0.0529, "epss_percentile": 0.89696}, "CVE-2017-6230": {"epss_score": 0.05561, "epss_percentile": 0.89995}, "CVE-2017-6247": {"epss_score": 0.00088, "epss_percentile": 0.25675}, "CVE-2017-6248": {"epss_score": 0.00111, "epss_percentile": 0.30408}, "CVE-2017-6249": {"epss_score": 0.00111, "epss_percentile": 0.30408}, "CVE-2017-6250": {"epss_score": 0.00058, "epss_percentile": 0.18276}, "CVE-2017-6251": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2017-6252": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-6253": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-6254": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-6255": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-6256": {"epss_score": 0.00047, "epss_percentile": 0.14686}, "CVE-2017-6257": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-6258": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2017-6259": {"epss_score": 0.00528, "epss_percentile": 0.66554}, "CVE-2017-6260": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2017-6261": {"epss_score": 0.00066, "epss_percentile": 0.2082}, "CVE-2017-6262": {"epss_score": 0.00025, "epss_percentile": 0.06162}, "CVE-2017-6263": {"epss_score": 0.00025, "epss_percentile": 0.06162}, "CVE-2017-6264": {"epss_score": 0.00404, "epss_percentile": 0.60412}, "CVE-2017-6266": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2017-6267": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2017-6268": {"epss_score": 0.00048, "epss_percentile": 0.14952}, "CVE-2017-6269": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2017-6270": {"epss_score": 0.00052, "epss_percentile": 0.16554}, "CVE-2017-6271": {"epss_score": 0.00052, "epss_percentile": 0.16554}, "CVE-2017-6272": {"epss_score": 0.00119, "epss_percentile": 0.31573}, "CVE-2017-6273": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2017-6274": {"epss_score": 0.00141, "epss_percentile": 0.34842}, "CVE-2017-6275": {"epss_score": 0.00135, "epss_percentile": 0.33965}, "CVE-2017-6276": {"epss_score": 0.00025, "epss_percentile": 0.06162}, "CVE-2017-6277": {"epss_score": 0.00119, "epss_percentile": 0.31573}, "CVE-2017-6278": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2017-6279": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2017-6280": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-6281": {"epss_score": 0.00013, "epss_percentile": 0.01722}, "CVE-2017-6282": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2017-6283": {"epss_score": 0.00015, "epss_percentile": 0.02225}, "CVE-2017-6284": {"epss_score": 8e-05, "epss_percentile": 0.00578}, "CVE-2017-6285": {"epss_score": 0.00017, "epss_percentile": 0.03378}, "CVE-2017-6286": {"epss_score": 0.00013, "epss_percentile": 0.01722}, "CVE-2017-6287": {"epss_score": 0.00017, "epss_percentile": 0.03378}, "CVE-2017-6288": {"epss_score": 0.00017, "epss_percentile": 0.03378}, "CVE-2017-6289": {"epss_score": 0.00046, "epss_percentile": 0.14111}, "CVE-2017-6290": {"epss_score": 0.00036, "epss_percentile": 0.1041}, "CVE-2017-6292": {"epss_score": 0.00036, "epss_percentile": 0.1041}, "CVE-2017-6293": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2017-6294": {"epss_score": 0.00042, "epss_percentile": 0.12579}, "CVE-2017-6295": {"epss_score": 0.00015, "epss_percentile": 0.02548}, "CVE-2017-6296": {"epss_score": 0.00012, "epss_percentile": 0.01264}, "CVE-2017-6297": {"epss_score": 0.00109, "epss_percentile": 0.29932}, "CVE-2017-6298": {"epss_score": 0.0034, "epss_percentile": 0.56232}, "CVE-2017-6299": {"epss_score": 0.00352, "epss_percentile": 0.57118}, "CVE-2017-6300": {"epss_score": 0.00347, "epss_percentile": 0.56783}, "CVE-2017-6301": {"epss_score": 0.0036, "epss_percentile": 0.57681}, "CVE-2017-6302": {"epss_score": 0.00321, "epss_percentile": 0.54737}, "CVE-2017-6303": {"epss_score": 0.0033, "epss_percentile": 0.55479}, "CVE-2017-6304": {"epss_score": 0.0036, "epss_percentile": 0.57681}, "CVE-2017-6305": {"epss_score": 0.0033, "epss_percentile": 0.55479}, "CVE-2017-6306": {"epss_score": 0.00471, "epss_percentile": 0.63997}, "CVE-2017-6307": {"epss_score": 0.00443, "epss_percentile": 0.62793}, "CVE-2017-6308": {"epss_score": 0.00404, "epss_percentile": 0.6041}, "CVE-2017-6309": {"epss_score": 0.00443, "epss_percentile": 0.62793}, "CVE-2017-6310": {"epss_score": 0.00353, "epss_percentile": 0.57174}, "CVE-2017-6311": {"epss_score": 0.01913, "epss_percentile": 0.82844}, "CVE-2017-6312": {"epss_score": 0.0031, "epss_percentile": 0.53777}, "CVE-2017-6313": {"epss_score": 0.00329, "epss_percentile": 0.55392}, "CVE-2017-6314": {"epss_score": 0.00421, "epss_percentile": 0.61512}, "CVE-2017-6315": {"epss_score": 0.09429, "epss_percentile": 0.92543}, "CVE-2017-6316": {"epss_score": 0.87787, "epss_percentile": 0.99443}, "CVE-2017-6317": {"epss_score": 0.00054, "epss_percentile": 0.17267}, "CVE-2017-6318": {"epss_score": 0.00731, "epss_percentile": 0.72171}, "CVE-2017-6319": {"epss_score": 0.00292, "epss_percentile": 0.52229}, "CVE-2017-6320": {"epss_score": 0.28644, "epss_percentile": 0.96374}, "CVE-2017-6323": {"epss_score": 0.00192, "epss_percentile": 0.41317}, "CVE-2017-6324": {"epss_score": 0.00453, "epss_percentile": 0.63215}, "CVE-2017-6325": {"epss_score": 0.03604, "epss_percentile": 0.87415}, "CVE-2017-6326": {"epss_score": 0.79143, "epss_percentile": 0.99021}, "CVE-2017-6327": {"epss_score": 0.77325, "epss_percentile": 0.98932}, "CVE-2017-6328": {"epss_score": 0.00891, "epss_percentile": 0.75052}, "CVE-2017-6329": {"epss_score": 0.00326, "epss_percentile": 0.55053}, "CVE-2017-6330": {"epss_score": 0.00198, "epss_percentile": 0.41993}, "CVE-2017-6331": {"epss_score": 0.02195, "epss_percentile": 0.83952}, "CVE-2017-6334": {"epss_score": 0.89741, "epss_percentile": 0.9954}, "CVE-2017-6335": {"epss_score": 0.00475, "epss_percentile": 0.64181}, "CVE-2017-6338": {"epss_score": 0.01013, "epss_percentile": 0.76632}, "CVE-2017-6339": {"epss_score": 0.02677, "epss_percentile": 0.85407}, "CVE-2017-6340": {"epss_score": 0.00227, "epss_percentile": 0.45441}, "CVE-2017-6341": {"epss_score": 0.00476, "epss_percentile": 0.6425}, "CVE-2017-6342": {"epss_score": 0.00353, "epss_percentile": 0.57138}, "CVE-2017-6343": {"epss_score": 0.0234, "epss_percentile": 0.84431}, "CVE-2017-6344": {"epss_score": 0.00328, "epss_percentile": 0.55287}, "CVE-2017-6345": {"epss_score": 0.00047, "epss_percentile": 0.14581}, "CVE-2017-6346": {"epss_score": 0.00058, "epss_percentile": 0.18456}, "CVE-2017-6347": {"epss_score": 0.00086, "epss_percentile": 0.25342}, "CVE-2017-6348": {"epss_score": 0.00081, "epss_percentile": 0.24394}, "CVE-2017-6349": {"epss_score": 0.0077, "epss_percentile": 0.73004}, "CVE-2017-6350": {"epss_score": 0.01188, "epss_percentile": 0.78358}, "CVE-2017-6351": {"epss_score": 0.16698, "epss_percentile": 0.94716}, "CVE-2017-6353": {"epss_score": 0.00046, "epss_percentile": 0.14172}, "CVE-2017-6355": {"epss_score": 0.00137, "epss_percentile": 0.34287}, "CVE-2017-6356": {"epss_score": 0.00117, "epss_percentile": 0.31332}, "CVE-2017-6359": {"epss_score": 0.78134, "epss_percentile": 0.9897}, "CVE-2017-6360": {"epss_score": 0.79979, "epss_percentile": 0.99065}, "CVE-2017-6361": {"epss_score": 0.90506, "epss_percentile": 0.99588}, "CVE-2017-6362": {"epss_score": 0.02144, "epss_percentile": 0.83763}, "CVE-2017-6363": {"epss_score": 0.00425, "epss_percentile": 0.61693}, "CVE-2017-6366": {"epss_score": 0.00247, "epss_percentile": 0.47859}, "CVE-2017-6367": {"epss_score": 0.3977, "epss_percentile": 0.97179}, "CVE-2017-6369": {"epss_score": 0.08854, "epss_percentile": 0.92286}, "CVE-2017-6370": {"epss_score": 0.00112, "epss_percentile": 0.30492}, "CVE-2017-6371": {"epss_score": 0.14714, "epss_percentile": 0.94269}, "CVE-2017-6377": {"epss_score": 0.00288, "epss_percentile": 0.51882}, "CVE-2017-6379": {"epss_score": 0.00191, "epss_percentile": 0.41162}, "CVE-2017-6381": {"epss_score": 0.03314, "epss_percentile": 0.86898}, "CVE-2017-6384": {"epss_score": 0.01311, "epss_percentile": 0.79372}, "CVE-2017-6386": {"epss_score": 0.00091, "epss_percentile": 0.2619}, "CVE-2017-6387": {"epss_score": 0.00234, "epss_percentile": 0.46149}, "CVE-2017-6390": {"epss_score": 0.00284, "epss_percentile": 0.51471}, "CVE-2017-6391": {"epss_score": 0.00284, "epss_percentile": 0.51471}, "CVE-2017-6392": {"epss_score": 0.00284, "epss_percentile": 0.51471}, "CVE-2017-6393": {"epss_score": 0.00287, "epss_percentile": 0.51827}, "CVE-2017-6394": {"epss_score": 0.00471, "epss_percentile": 0.64001}, "CVE-2017-6395": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6396": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6397": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-6398": {"epss_score": 0.6462, "epss_percentile": 0.98387}, "CVE-2017-6399": {"epss_score": 0.00468, "epss_percentile": 0.63869}, "CVE-2017-6400": {"epss_score": 0.00068, "epss_percentile": 0.21242}, "CVE-2017-6401": {"epss_score": 0.00047, "epss_percentile": 0.14697}, "CVE-2017-6402": {"epss_score": 0.00426, "epss_percentile": 0.61735}, "CVE-2017-6403": {"epss_score": 0.0064, "epss_percentile": 0.69975}, "CVE-2017-6404": {"epss_score": 0.00047, "epss_percentile": 0.14806}, "CVE-2017-6405": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2017-6406": {"epss_score": 0.00068, "epss_percentile": 0.21242}, "CVE-2017-6407": {"epss_score": 0.00328, "epss_percentile": 0.55256}, "CVE-2017-6408": {"epss_score": 0.00032, "epss_percentile": 0.09093}, "CVE-2017-6409": {"epss_score": 0.00528, "epss_percentile": 0.66543}, "CVE-2017-6410": {"epss_score": 0.00288, "epss_percentile": 0.51978}, "CVE-2017-6411": {"epss_score": 0.02004, "epss_percentile": 0.83228}, "CVE-2017-6412": {"epss_score": 0.00735, "epss_percentile": 0.72298}, "CVE-2017-6413": {"epss_score": 0.00408, "epss_percentile": 0.60669}, "CVE-2017-6414": {"epss_score": 0.00189, "epss_percentile": 0.40946}, "CVE-2017-6415": {"epss_score": 0.00231, "epss_percentile": 0.45787}, "CVE-2017-6416": {"epss_score": 0.64638, "epss_percentile": 0.98387}, "CVE-2017-6417": {"epss_score": 0.00101, "epss_percentile": 0.2865}, "CVE-2017-6418": {"epss_score": 0.00448, "epss_percentile": 0.63013}, "CVE-2017-6419": {"epss_score": 0.00459, "epss_percentile": 0.6346}, "CVE-2017-6420": {"epss_score": 0.00378, "epss_percentile": 0.58801}, "CVE-2017-6421": {"epss_score": 0.00268, "epss_percentile": 0.50043}, "CVE-2017-6423": {"epss_score": 0.00028, "epss_percentile": 0.07315}, "CVE-2017-6424": {"epss_score": 0.00028, "epss_percentile": 0.07315}, "CVE-2017-6425": {"epss_score": 0.00107, "epss_percentile": 0.29581}, "CVE-2017-6426": {"epss_score": 0.00107, "epss_percentile": 0.29581}, "CVE-2017-6427": {"epss_score": 0.3977, "epss_percentile": 0.97179}, "CVE-2017-6429": {"epss_score": 0.0061, "epss_percentile": 0.69163}, "CVE-2017-6430": {"epss_score": 0.0023, "epss_percentile": 0.4574}, "CVE-2017-6432": {"epss_score": 0.00168, "epss_percentile": 0.38472}, "CVE-2017-6435": {"epss_score": 0.00157, "epss_percentile": 0.37063}, "CVE-2017-6436": {"epss_score": 0.00131, "epss_percentile": 0.33488}, "CVE-2017-6437": {"epss_score": 0.00123, "epss_percentile": 0.32306}, "CVE-2017-6438": {"epss_score": 0.0015, "epss_percentile": 0.36051}, "CVE-2017-6439": {"epss_score": 0.00121, "epss_percentile": 0.32009}, "CVE-2017-6440": {"epss_score": 0.00122, "epss_percentile": 0.32029}, "CVE-2017-6441": {"epss_score": 0.00356, "epss_percentile": 0.5737}, "CVE-2017-6443": {"epss_score": 0.0201, "epss_percentile": 0.83248}, "CVE-2017-6444": {"epss_score": 0.18055, "epss_percentile": 0.94949}, "CVE-2017-6445": {"epss_score": 0.00276, "epss_percentile": 0.50763}, "CVE-2017-6446": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-6448": {"epss_score": 0.00248, "epss_percentile": 0.4793}, "CVE-2017-6451": {"epss_score": 0.00163, "epss_percentile": 0.37781}, "CVE-2017-6452": {"epss_score": 0.00136, "epss_percentile": 0.34113}, "CVE-2017-6455": {"epss_score": 0.00055, "epss_percentile": 0.17515}, "CVE-2017-6458": {"epss_score": 0.12057, "epss_percentile": 0.93557}, "CVE-2017-6459": {"epss_score": 0.00052, "epss_percentile": 0.16564}, "CVE-2017-6460": {"epss_score": 0.00895, "epss_percentile": 0.75105}, "CVE-2017-6462": {"epss_score": 0.00098, "epss_percentile": 0.27671}, "CVE-2017-6463": {"epss_score": 0.03142, "epss_percentile": 0.86491}, "CVE-2017-6464": {"epss_score": 0.02462, "epss_percentile": 0.84827}, "CVE-2017-6465": {"epss_score": 0.80491, "epss_percentile": 0.99091}, "CVE-2017-6466": {"epss_score": 0.00749, "epss_percentile": 0.72598}, "CVE-2017-6467": {"epss_score": 0.00704, "epss_percentile": 0.71561}, "CVE-2017-6468": {"epss_score": 0.00704, "epss_percentile": 0.71561}, "CVE-2017-6469": {"epss_score": 0.00704, "epss_percentile": 0.71561}, "CVE-2017-6470": {"epss_score": 0.00386, "epss_percentile": 0.59281}, "CVE-2017-6471": {"epss_score": 0.00704, "epss_percentile": 0.71561}, "CVE-2017-6472": {"epss_score": 0.007, "epss_percentile": 0.71465}, "CVE-2017-6473": {"epss_score": 0.00704, "epss_percentile": 0.71561}, "CVE-2017-6474": {"epss_score": 0.00704, "epss_percentile": 0.71561}, "CVE-2017-6478": {"epss_score": 0.02814, "epss_percentile": 0.85727}, "CVE-2017-6479": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-6480": {"epss_score": 0.00356, "epss_percentile": 0.57393}, "CVE-2017-6481": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-6483": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-6484": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-6485": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-6486": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2017-6487": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2017-6488": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2017-6489": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2017-6490": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2017-6491": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2017-6492": {"epss_score": 0.00471, "epss_percentile": 0.64001}, "CVE-2017-6497": {"epss_score": 0.00821, "epss_percentile": 0.73908}, "CVE-2017-6498": {"epss_score": 0.00276, "epss_percentile": 0.50766}, "CVE-2017-6499": {"epss_score": 0.00275, "epss_percentile": 0.50643}, "CVE-2017-6500": {"epss_score": 0.00269, "epss_percentile": 0.50188}, "CVE-2017-6501": {"epss_score": 0.00144, "epss_percentile": 0.35285}, "CVE-2017-6502": {"epss_score": 0.00151, "epss_percentile": 0.3631}, "CVE-2017-6503": {"epss_score": 0.00284, "epss_percentile": 0.51471}, "CVE-2017-6504": {"epss_score": 0.00238, "epss_percentile": 0.46802}, "CVE-2017-6505": {"epss_score": 0.00111, "epss_percentile": 0.30306}, "CVE-2017-6506": {"epss_score": 0.21599, "epss_percentile": 0.95538}, "CVE-2017-6507": {"epss_score": 0.00337, "epss_percentile": 0.56067}, "CVE-2017-6508": {"epss_score": 0.00143, "epss_percentile": 0.35091}, "CVE-2017-6509": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-6510": {"epss_score": 0.59811, "epss_percentile": 0.98182}, "CVE-2017-6511": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-6512": {"epss_score": 0.01167, "epss_percentile": 0.78184}, "CVE-2017-6513": {"epss_score": 0.00807, "epss_percentile": 0.73675}, "CVE-2017-6514": {"epss_score": 0.01457, "epss_percentile": 0.80396}, "CVE-2017-6516": {"epss_score": 0.21359, "epss_percentile": 0.95506}, "CVE-2017-6517": {"epss_score": 0.1974, "epss_percentile": 0.95235}, "CVE-2017-6518": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2017-6519": {"epss_score": 0.01134, "epss_percentile": 0.77892}, "CVE-2017-6520": {"epss_score": 0.00806, "epss_percentile": 0.73656}, "CVE-2017-6526": {"epss_score": 0.8373, "epss_percentile": 0.9926}, "CVE-2017-6527": {"epss_score": 0.75905, "epss_percentile": 0.98869}, "CVE-2017-6528": {"epss_score": 0.07206, "epss_percentile": 0.91323}, "CVE-2017-6529": {"epss_score": 0.04481, "epss_percentile": 0.88742}, "CVE-2017-6530": {"epss_score": 0.00541, "epss_percentile": 0.67043}, "CVE-2017-6531": {"epss_score": 0.00856, "epss_percentile": 0.74485}, "CVE-2017-6532": {"epss_score": 0.00541, "epss_percentile": 0.67043}, "CVE-2017-6533": {"epss_score": 0.00196, "epss_percentile": 0.4179}, "CVE-2017-6534": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6535": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6536": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6537": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6538": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6539": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6540": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6541": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6542": {"epss_score": 0.25845, "epss_percentile": 0.96078}, "CVE-2017-6543": {"epss_score": 0.00268, "epss_percentile": 0.50073}, "CVE-2017-6544": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-6547": {"epss_score": 0.01043, "epss_percentile": 0.76989}, "CVE-2017-6548": {"epss_score": 0.48343, "epss_percentile": 0.97632}, "CVE-2017-6549": {"epss_score": 0.24524, "epss_percentile": 0.9593}, "CVE-2017-6550": {"epss_score": 0.05854, "epss_percentile": 0.90265}, "CVE-2017-6551": {"epss_score": 0.01649, "epss_percentile": 0.81556}, "CVE-2017-6552": {"epss_score": 0.08398, "epss_percentile": 0.92031}, "CVE-2017-6553": {"epss_score": 0.74037, "epss_percentile": 0.98784}, "CVE-2017-6554": {"epss_score": 0.23886, "epss_percentile": 0.9583}, "CVE-2017-6555": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2017-6556": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2017-6557": {"epss_score": 0.0037, "epss_percentile": 0.58303}, "CVE-2017-6558": {"epss_score": 0.34772, "epss_percentile": 0.96873}, "CVE-2017-6559": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-6560": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-6561": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-6562": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-6564": {"epss_score": 0.00179, "epss_percentile": 0.39835}, "CVE-2017-6565": {"epss_score": 0.00246, "epss_percentile": 0.47767}, "CVE-2017-6570": {"epss_score": 0.00729, "epss_percentile": 0.72139}, "CVE-2017-6571": {"epss_score": 0.00729, "epss_percentile": 0.72139}, "CVE-2017-6572": {"epss_score": 0.00927, "epss_percentile": 0.75572}, "CVE-2017-6573": {"epss_score": 0.00729, "epss_percentile": 0.72139}, "CVE-2017-6574": {"epss_score": 0.00729, "epss_percentile": 0.72139}, "CVE-2017-6575": {"epss_score": 0.00729, "epss_percentile": 0.72139}, "CVE-2017-6576": {"epss_score": 0.00729, "epss_percentile": 0.72139}, "CVE-2017-6577": {"epss_score": 0.00729, "epss_percentile": 0.72139}, "CVE-2017-6578": {"epss_score": 0.00729, "epss_percentile": 0.72139}, "CVE-2017-6589": {"epss_score": 0.00298, "epss_percentile": 0.52804}, "CVE-2017-6590": {"epss_score": 0.00041, "epss_percentile": 0.12264}, "CVE-2017-6591": {"epss_score": 0.00298, "epss_percentile": 0.52804}, "CVE-2017-6594": {"epss_score": 0.00249, "epss_percentile": 0.48027}, "CVE-2017-6596": {"epss_score": 0.00176, "epss_percentile": 0.39431}, "CVE-2017-6597": {"epss_score": 0.00366, "epss_percentile": 0.58018}, "CVE-2017-6598": {"epss_score": 0.00024, "epss_percentile": 0.05889}, "CVE-2017-6599": {"epss_score": 0.00435, "epss_percentile": 0.62354}, "CVE-2017-6600": {"epss_score": 0.00366, "epss_percentile": 0.58018}, "CVE-2017-6601": {"epss_score": 0.00278, "epss_percentile": 0.50868}, "CVE-2017-6602": {"epss_score": 0.00262, "epss_percentile": 0.49365}, "CVE-2017-6603": {"epss_score": 0.00342, "epss_percentile": 0.56382}, "CVE-2017-6604": {"epss_score": 0.00255, "epss_percentile": 0.48627}, "CVE-2017-6605": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-6606": {"epss_score": 0.00161, "epss_percentile": 0.37601}, "CVE-2017-6607": {"epss_score": 0.00998, "epss_percentile": 0.76471}, "CVE-2017-6608": {"epss_score": 0.00424, "epss_percentile": 0.61684}, "CVE-2017-6609": {"epss_score": 0.00797, "epss_percentile": 0.73491}, "CVE-2017-6610": {"epss_score": 0.00623, "epss_percentile": 0.69549}, "CVE-2017-6611": {"epss_score": 0.00194, "epss_percentile": 0.41552}, "CVE-2017-6612": {"epss_score": 0.00749, "epss_percentile": 0.72591}, "CVE-2017-6613": {"epss_score": 0.00292, "epss_percentile": 0.52239}, "CVE-2017-6614": {"epss_score": 0.00335, "epss_percentile": 0.55855}, "CVE-2017-6615": {"epss_score": 0.00448, "epss_percentile": 0.62999}, "CVE-2017-6616": {"epss_score": 0.01223, "epss_percentile": 0.7867}, "CVE-2017-6617": {"epss_score": 0.0029, "epss_percentile": 0.52113}, "CVE-2017-6618": {"epss_score": 0.00356, "epss_percentile": 0.57384}, "CVE-2017-6619": {"epss_score": 0.00846, "epss_percentile": 0.74334}, "CVE-2017-6620": {"epss_score": 0.00161, "epss_percentile": 0.37571}, "CVE-2017-6621": {"epss_score": 0.03823, "epss_percentile": 0.87787}, "CVE-2017-6622": {"epss_score": 0.77352, "epss_percentile": 0.98932}, "CVE-2017-6623": {"epss_score": 0.0003, "epss_percentile": 0.08208}, "CVE-2017-6624": {"epss_score": 0.0029, "epss_percentile": 0.52098}, "CVE-2017-6625": {"epss_score": 0.00648, "epss_percentile": 0.70219}, "CVE-2017-6626": {"epss_score": 0.0028, "epss_percentile": 0.51067}, "CVE-2017-6627": {"epss_score": 0.1083, "epss_percentile": 0.93126}, "CVE-2017-6628": {"epss_score": 0.00632, "epss_percentile": 0.69754}, "CVE-2017-6629": {"epss_score": 0.01141, "epss_percentile": 0.77962}, "CVE-2017-6630": {"epss_score": 0.00676, "epss_percentile": 0.70923}, "CVE-2017-6631": {"epss_score": 0.00484, "epss_percentile": 0.6467}, "CVE-2017-6632": {"epss_score": 0.01356, "epss_percentile": 0.79715}, "CVE-2017-6633": {"epss_score": 0.0075, "epss_percentile": 0.72619}, "CVE-2017-6634": {"epss_score": 0.00217, "epss_percentile": 0.44326}, "CVE-2017-6635": {"epss_score": 0.04886, "epss_percentile": 0.89255}, "CVE-2017-6636": {"epss_score": 0.03768, "epss_percentile": 0.87698}, "CVE-2017-6637": {"epss_score": 0.01136, "epss_percentile": 0.77916}, "CVE-2017-6638": {"epss_score": 0.00062, "epss_percentile": 0.19655}, "CVE-2017-6639": {"epss_score": 0.33812, "epss_percentile": 0.96805}, "CVE-2017-6640": {"epss_score": 0.46097, "epss_percentile": 0.97524}, "CVE-2017-6641": {"epss_score": 0.01356, "epss_percentile": 0.79715}, "CVE-2017-6642": {"epss_score": 0.00366, "epss_percentile": 0.58082}, "CVE-2017-6643": {"epss_score": 0.00366, "epss_percentile": 0.58082}, "CVE-2017-6644": {"epss_score": 0.00366, "epss_percentile": 0.58082}, "CVE-2017-6645": {"epss_score": 0.00366, "epss_percentile": 0.58082}, "CVE-2017-6646": {"epss_score": 0.00366, "epss_percentile": 0.58082}, "CVE-2017-6647": {"epss_score": 0.00366, "epss_percentile": 0.58082}, "CVE-2017-6648": {"epss_score": 0.00734, "epss_percentile": 0.72244}, "CVE-2017-6649": {"epss_score": 0.00577, "epss_percentile": 0.68152}, "CVE-2017-6650": {"epss_score": 0.00577, "epss_percentile": 0.68152}, "CVE-2017-6651": {"epss_score": 0.00438, "epss_percentile": 0.62542}, "CVE-2017-6652": {"epss_score": 0.03008, "epss_percentile": 0.86189}, "CVE-2017-6653": {"epss_score": 0.0075, "epss_percentile": 0.72619}, "CVE-2017-6654": {"epss_score": 0.00143, "epss_percentile": 0.35113}, "CVE-2017-6655": {"epss_score": 0.00282, "epss_percentile": 0.51212}, "CVE-2017-6656": {"epss_score": 0.0098, "epss_percentile": 0.7627}, "CVE-2017-6657": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2017-6658": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2017-6659": {"epss_score": 0.00217, "epss_percentile": 0.44326}, "CVE-2017-6661": {"epss_score": 0.00296, "epss_percentile": 0.52617}, "CVE-2017-6662": {"epss_score": 0.00946, "epss_percentile": 0.75806}, "CVE-2017-6663": {"epss_score": 0.02321, "epss_percentile": 0.8437}, "CVE-2017-6664": {"epss_score": 0.00337, "epss_percentile": 0.56019}, "CVE-2017-6665": {"epss_score": 0.00109, "epss_percentile": 0.29975}, "CVE-2017-6666": {"epss_score": 0.00074, "epss_percentile": 0.22865}, "CVE-2017-6667": {"epss_score": 0.03348, "epss_percentile": 0.86954}, "CVE-2017-6668": {"epss_score": 0.00204, "epss_percentile": 0.42655}, "CVE-2017-6669": {"epss_score": 0.00921, "epss_percentile": 0.7548}, "CVE-2017-6670": {"epss_score": 0.00255, "epss_percentile": 0.48627}, "CVE-2017-6671": {"epss_score": 0.00383, "epss_percentile": 0.59116}, "CVE-2017-6672": {"epss_score": 0.00372, "epss_percentile": 0.58444}, "CVE-2017-6673": {"epss_score": 0.00224, "epss_percentile": 0.45067}, "CVE-2017-6674": {"epss_score": 0.00217, "epss_percentile": 0.44247}, "CVE-2017-6675": {"epss_score": 0.00247, "epss_percentile": 0.47858}, "CVE-2017-6678": {"epss_score": 0.00484, "epss_percentile": 0.6467}, "CVE-2017-6679": {"epss_score": 0.00113, "epss_percentile": 0.30693}, "CVE-2017-6680": {"epss_score": 0.00326, "epss_percentile": 0.55091}, "CVE-2017-6681": {"epss_score": 0.03078, "epss_percentile": 0.86365}, "CVE-2017-6682": {"epss_score": 0.00951, "epss_percentile": 0.75863}, "CVE-2017-6683": {"epss_score": 0.12361, "epss_percentile": 0.9365}, "CVE-2017-6684": {"epss_score": 0.00992, "epss_percentile": 0.76393}, "CVE-2017-6685": {"epss_score": 0.00767, "epss_percentile": 0.72957}, "CVE-2017-6686": {"epss_score": 0.00767, "epss_percentile": 0.72957}, "CVE-2017-6687": {"epss_score": 0.00767, "epss_percentile": 0.72957}, "CVE-2017-6688": {"epss_score": 0.00992, "epss_percentile": 0.76393}, "CVE-2017-6689": {"epss_score": 0.00767, "epss_percentile": 0.72957}, "CVE-2017-6690": {"epss_score": 0.00165, "epss_percentile": 0.38066}, "CVE-2017-6691": {"epss_score": 0.00213, "epss_percentile": 0.43905}, "CVE-2017-6692": {"epss_score": 0.00992, "epss_percentile": 0.76393}, "CVE-2017-6693": {"epss_score": 0.00057, "epss_percentile": 0.18177}, "CVE-2017-6694": {"epss_score": 0.00057, "epss_percentile": 0.18177}, "CVE-2017-6695": {"epss_score": 0.00067, "epss_percentile": 0.21035}, "CVE-2017-6696": {"epss_score": 0.00067, "epss_percentile": 0.21035}, "CVE-2017-6697": {"epss_score": 0.00204, "epss_percentile": 0.42642}, "CVE-2017-6698": {"epss_score": 0.00197, "epss_percentile": 0.419}, "CVE-2017-6699": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2017-6700": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2017-6701": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2017-6702": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2017-6703": {"epss_score": 0.00977, "epss_percentile": 0.76231}, "CVE-2017-6704": {"epss_score": 0.00965, "epss_percentile": 0.76042}, "CVE-2017-6705": {"epss_score": 0.00078, "epss_percentile": 0.23669}, "CVE-2017-6706": {"epss_score": 0.00068, "epss_percentile": 0.21216}, "CVE-2017-6707": {"epss_score": 0.00238, "epss_percentile": 0.468}, "CVE-2017-6708": {"epss_score": 0.00566, "epss_percentile": 0.6783}, "CVE-2017-6709": {"epss_score": 0.00507, "epss_percentile": 0.65654}, "CVE-2017-6710": {"epss_score": 0.01282, "epss_percentile": 0.7915}, "CVE-2017-6711": {"epss_score": 0.00436, "epss_percentile": 0.62434}, "CVE-2017-6712": {"epss_score": 0.00788, "epss_percentile": 0.73339}, "CVE-2017-6713": {"epss_score": 0.01735, "epss_percentile": 0.82008}, "CVE-2017-6714": {"epss_score": 0.01897, "epss_percentile": 0.82756}, "CVE-2017-6715": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2017-6716": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2017-6717": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2017-6718": {"epss_score": 0.00079, "epss_percentile": 0.23962}, "CVE-2017-6719": {"epss_score": 0.00154, "epss_percentile": 0.36662}, "CVE-2017-6720": {"epss_score": 0.00437, "epss_percentile": 0.62497}, "CVE-2017-6721": {"epss_score": 0.0082, "epss_percentile": 0.7389}, "CVE-2017-6722": {"epss_score": 0.00447, "epss_percentile": 0.62972}, "CVE-2017-6724": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2017-6725": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2017-6726": {"epss_score": 0.00067, "epss_percentile": 0.21035}, "CVE-2017-6727": {"epss_score": 0.0082, "epss_percentile": 0.7389}, "CVE-2017-6728": {"epss_score": 0.00048, "epss_percentile": 0.15161}, "CVE-2017-6729": {"epss_score": 0.01409, "epss_percentile": 0.80068}, "CVE-2017-6730": {"epss_score": 0.00361, "epss_percentile": 0.57706}, "CVE-2017-6731": {"epss_score": 0.00662, "epss_percentile": 0.70608}, "CVE-2017-6732": {"epss_score": 0.00038, "epss_percentile": 0.11202}, "CVE-2017-6733": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2017-6734": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-6735": {"epss_score": 0.00084, "epss_percentile": 0.24896}, "CVE-2017-6736": {"epss_score": 0.89022, "epss_percentile": 0.99506}, "CVE-2017-6737": {"epss_score": 0.28835, "epss_percentile": 0.96393}, "CVE-2017-6738": {"epss_score": 0.28835, "epss_percentile": 0.96393}, "CVE-2017-6739": {"epss_score": 0.28835, "epss_percentile": 0.96393}, "CVE-2017-6740": {"epss_score": 0.2427, "epss_percentile": 0.95897}, "CVE-2017-6741": {"epss_score": 0.26739, "epss_percentile": 0.96172}, "CVE-2017-6742": {"epss_score": 0.03599, "epss_percentile": 0.87409}, "CVE-2017-6743": {"epss_score": 0.28835, "epss_percentile": 0.96393}, "CVE-2017-6744": {"epss_score": 0.18984, "epss_percentile": 0.95106}, "CVE-2017-6745": {"epss_score": 0.00484, "epss_percentile": 0.6467}, "CVE-2017-6746": {"epss_score": 0.02509, "epss_percentile": 0.84943}, "CVE-2017-6747": {"epss_score": 0.02246, "epss_percentile": 0.84132}, "CVE-2017-6748": {"epss_score": 0.00315, "epss_percentile": 0.54161}, "CVE-2017-6749": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-6750": {"epss_score": 0.00749, "epss_percentile": 0.72604}, "CVE-2017-6751": {"epss_score": 0.00469, "epss_percentile": 0.63932}, "CVE-2017-6752": {"epss_score": 0.00856, "epss_percentile": 0.74472}, "CVE-2017-6753": {"epss_score": 0.111, "epss_percentile": 0.93219}, "CVE-2017-6754": {"epss_score": 0.00258, "epss_percentile": 0.49013}, "CVE-2017-6755": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2017-6756": {"epss_score": 0.00329, "epss_percentile": 0.55382}, "CVE-2017-6757": {"epss_score": 0.00679, "epss_percentile": 0.71017}, "CVE-2017-6758": {"epss_score": 0.01243, "epss_percentile": 0.78825}, "CVE-2017-6759": {"epss_score": 0.0027, "epss_percentile": 0.50274}, "CVE-2017-6761": {"epss_score": 0.00227, "epss_percentile": 0.45391}, "CVE-2017-6762": {"epss_score": 0.00227, "epss_percentile": 0.45391}, "CVE-2017-6763": {"epss_score": 0.02175, "epss_percentile": 0.83882}, "CVE-2017-6764": {"epss_score": 0.00278, "epss_percentile": 0.50847}, "CVE-2017-6765": {"epss_score": 0.00195, "epss_percentile": 0.41677}, "CVE-2017-6766": {"epss_score": 0.00151, "epss_percentile": 0.36248}, "CVE-2017-6767": {"epss_score": 0.00894, "epss_percentile": 0.75088}, "CVE-2017-6768": {"epss_score": 0.00086, "epss_percentile": 0.25302}, "CVE-2017-6769": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-6770": {"epss_score": 0.00583, "epss_percentile": 0.68356}, "CVE-2017-6771": {"epss_score": 0.00408, "epss_percentile": 0.60684}, "CVE-2017-6772": {"epss_score": 0.00152, "epss_percentile": 0.36384}, "CVE-2017-6773": {"epss_score": 0.00052, "epss_percentile": 0.16447}, "CVE-2017-6774": {"epss_score": 0.00247, "epss_percentile": 0.47902}, "CVE-2017-6775": {"epss_score": 0.0005, "epss_percentile": 0.15738}, "CVE-2017-6776": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2017-6777": {"epss_score": 0.00193, "epss_percentile": 0.41417}, "CVE-2017-6778": {"epss_score": 0.00204, "epss_percentile": 0.42642}, "CVE-2017-6779": {"epss_score": 0.01275, "epss_percentile": 0.79106}, "CVE-2017-6780": {"epss_score": 0.00484, "epss_percentile": 0.6467}, "CVE-2017-6781": {"epss_score": 0.00051, "epss_percentile": 0.16212}, "CVE-2017-6782": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2017-6783": {"epss_score": 0.0028, "epss_percentile": 0.51015}, "CVE-2017-6784": {"epss_score": 0.00361, "epss_percentile": 0.57706}, "CVE-2017-6785": {"epss_score": 0.00171, "epss_percentile": 0.38791}, "CVE-2017-6786": {"epss_score": 0.00066, "epss_percentile": 0.20936}, "CVE-2017-6788": {"epss_score": 0.00232, "epss_percentile": 0.45882}, "CVE-2017-6789": {"epss_score": 0.00342, "epss_percentile": 0.5639}, "CVE-2017-6790": {"epss_score": 0.01795, "epss_percentile": 0.82302}, "CVE-2017-6791": {"epss_score": 0.0179, "epss_percentile": 0.82277}, "CVE-2017-6792": {"epss_score": 0.00398, "epss_percentile": 0.6006}, "CVE-2017-6793": {"epss_score": 0.00213, "epss_percentile": 0.43905}, "CVE-2017-6794": {"epss_score": 0.00221, "epss_percentile": 0.44639}, "CVE-2017-6795": {"epss_score": 0.00091, "epss_percentile": 0.26236}, "CVE-2017-6796": {"epss_score": 0.0013, "epss_percentile": 0.33309}, "CVE-2017-6797": {"epss_score": 0.00827, "epss_percentile": 0.73976}, "CVE-2017-6798": {"epss_score": 0.01624, "epss_percentile": 0.81407}, "CVE-2017-6799": {"epss_score": 0.00721, "epss_percentile": 0.71987}, "CVE-2017-6800": {"epss_score": 0.00538, "epss_percentile": 0.66943}, "CVE-2017-6801": {"epss_score": 0.00505, "epss_percentile": 0.65602}, "CVE-2017-6802": {"epss_score": 0.00797, "epss_percentile": 0.73492}, "CVE-2017-6803": {"epss_score": 0.00177, "epss_percentile": 0.39542}, "CVE-2017-6805": {"epss_score": 0.18594, "epss_percentile": 0.95039}, "CVE-2017-6807": {"epss_score": 0.00363, "epss_percentile": 0.57866}, "CVE-2017-6808": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6809": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6810": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6811": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6812": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-6813": {"epss_score": 0.00555, "epss_percentile": 0.67467}, "CVE-2017-6814": {"epss_score": 0.02424, "epss_percentile": 0.84712}, "CVE-2017-6815": {"epss_score": 0.06385, "epss_percentile": 0.90715}, "CVE-2017-6816": {"epss_score": 0.02189, "epss_percentile": 0.83929}, "CVE-2017-6817": {"epss_score": 0.06481, "epss_percentile": 0.90787}, "CVE-2017-6818": {"epss_score": 0.09282, "epss_percentile": 0.92482}, "CVE-2017-6819": {"epss_score": 0.13419, "epss_percentile": 0.93958}, "CVE-2017-6820": {"epss_score": 0.00556, "epss_percentile": 0.67519}, "CVE-2017-6821": {"epss_score": 0.00754, "epss_percentile": 0.7269}, "CVE-2017-6823": {"epss_score": 0.06845, "epss_percentile": 0.91064}, "CVE-2017-6827": {"epss_score": 0.41772, "epss_percentile": 0.97294}, "CVE-2017-6828": {"epss_score": 0.24524, "epss_percentile": 0.9593}, "CVE-2017-6829": {"epss_score": 0.04576, "epss_percentile": 0.88869}, "CVE-2017-6830": {"epss_score": 0.06895, "epss_percentile": 0.91099}, "CVE-2017-6831": {"epss_score": 0.04517, "epss_percentile": 0.88792}, "CVE-2017-6832": {"epss_score": 0.04517, "epss_percentile": 0.88792}, "CVE-2017-6833": {"epss_score": 0.05773, "epss_percentile": 0.90195}, "CVE-2017-6834": {"epss_score": 0.06895, "epss_percentile": 0.91099}, "CVE-2017-6835": {"epss_score": 0.04451, "epss_percentile": 0.88705}, "CVE-2017-6836": {"epss_score": 0.04984, "epss_percentile": 0.89362}, "CVE-2017-6837": {"epss_score": 0.06086, "epss_percentile": 0.90465}, "CVE-2017-6838": {"epss_score": 0.05773, "epss_percentile": 0.90195}, "CVE-2017-6839": {"epss_score": 0.04451, "epss_percentile": 0.88705}, "CVE-2017-6840": {"epss_score": 0.0037, "epss_percentile": 0.5833}, "CVE-2017-6841": {"epss_score": 0.00393, "epss_percentile": 0.59712}, "CVE-2017-6842": {"epss_score": 0.00393, "epss_percentile": 0.59712}, "CVE-2017-6843": {"epss_score": 0.00528, "epss_percentile": 0.66567}, "CVE-2017-6844": {"epss_score": 0.00552, "epss_percentile": 0.67395}, "CVE-2017-6845": {"epss_score": 0.00346, "epss_percentile": 0.56603}, "CVE-2017-6846": {"epss_score": 0.00402, "epss_percentile": 0.60314}, "CVE-2017-6847": {"epss_score": 0.00421, "epss_percentile": 0.61465}, "CVE-2017-6848": {"epss_score": 0.00402, "epss_percentile": 0.60314}, "CVE-2017-6849": {"epss_score": 0.00324, "epss_percentile": 0.54935}, "CVE-2017-6850": {"epss_score": 0.00222, "epss_percentile": 0.44789}, "CVE-2017-6851": {"epss_score": 0.00453, "epss_percentile": 0.63236}, "CVE-2017-6852": {"epss_score": 0.00595, "epss_percentile": 0.68689}, "CVE-2017-6862": {"epss_score": 0.49861, "epss_percentile": 0.97708}, "CVE-2017-6864": {"epss_score": 0.00304, "epss_percentile": 0.53261}, "CVE-2017-6865": {"epss_score": 0.00084, "epss_percentile": 0.24975}, "CVE-2017-6866": {"epss_score": 0.00168, "epss_percentile": 0.3843}, "CVE-2017-6867": {"epss_score": 0.00613, "epss_percentile": 0.69244}, "CVE-2017-6868": {"epss_score": 0.04201, "epss_percentile": 0.88387}, "CVE-2017-6869": {"epss_score": 0.01474, "epss_percentile": 0.80521}, "CVE-2017-6870": {"epss_score": 0.0024, "epss_percentile": 0.47221}, "CVE-2017-6871": {"epss_score": 0.00059, "epss_percentile": 0.18704}, "CVE-2017-6872": {"epss_score": 0.00164, "epss_percentile": 0.37892}, "CVE-2017-6873": {"epss_score": 0.00194, "epss_percentile": 0.41572}, "CVE-2017-6874": {"epss_score": 0.00094, "epss_percentile": 0.27035}, "CVE-2017-6877": {"epss_score": 0.00263, "epss_percentile": 0.49477}, "CVE-2017-6878": {"epss_score": 0.00291, "epss_percentile": 0.52179}, "CVE-2017-6880": {"epss_score": 0.09226, "epss_percentile": 0.92457}, "CVE-2017-6883": {"epss_score": 0.00123, "epss_percentile": 0.32201}, "CVE-2017-6884": {"epss_score": 0.91063, "epss_percentile": 0.99617}, "CVE-2017-6885": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2017-6886": {"epss_score": 0.0058, "epss_percentile": 0.68255}, "CVE-2017-6887": {"epss_score": 0.00471, "epss_percentile": 0.64002}, "CVE-2017-6888": {"epss_score": 0.00445, "epss_percentile": 0.62867}, "CVE-2017-6889": {"epss_score": 0.00436, "epss_percentile": 0.62455}, "CVE-2017-6890": {"epss_score": 0.00436, "epss_percentile": 0.62455}, "CVE-2017-6891": {"epss_score": 0.01917, "epss_percentile": 0.82863}, "CVE-2017-6892": {"epss_score": 0.02341, "epss_percentile": 0.84437}, "CVE-2017-6894": {"epss_score": 0.0003, "epss_percentile": 0.08067}, "CVE-2017-6895": {"epss_score": 0.04078, "epss_percentile": 0.88215}, "CVE-2017-6896": {"epss_score": 0.02516, "epss_percentile": 0.84985}, "CVE-2017-6899": {"epss_score": 0.00069, "epss_percentile": 0.21472}, "CVE-2017-6900": {"epss_score": 0.02709, "epss_percentile": 0.85481}, "CVE-2017-6903": {"epss_score": 0.00116, "epss_percentile": 0.31094}, "CVE-2017-6905": {"epss_score": 0.0024, "epss_percentile": 0.46941}, "CVE-2017-6906": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2017-6907": {"epss_score": 0.00218, "epss_percentile": 0.44362}, "CVE-2017-6908": {"epss_score": 0.00312, "epss_percentile": 0.53984}, "CVE-2017-6909": {"epss_score": 0.00218, "epss_percentile": 0.44362}, "CVE-2017-6910": {"epss_score": 0.00209, "epss_percentile": 0.43337}, "CVE-2017-6911": {"epss_score": 0.00089, "epss_percentile": 0.2589}, "CVE-2017-6912": {"epss_score": 0.0046, "epss_percentile": 0.63503}, "CVE-2017-6913": {"epss_score": 0.004, "epss_percentile": 0.60197}, "CVE-2017-6914": {"epss_score": 0.0012, "epss_percentile": 0.31723}, "CVE-2017-6915": {"epss_score": 0.00119, "epss_percentile": 0.31688}, "CVE-2017-6916": {"epss_score": 0.00119, "epss_percentile": 0.31688}, "CVE-2017-6917": {"epss_score": 0.00119, "epss_percentile": 0.31688}, "CVE-2017-6918": {"epss_score": 0.00119, "epss_percentile": 0.31688}, "CVE-2017-6919": {"epss_score": 0.00598, "epss_percentile": 0.68757}, "CVE-2017-6920": {"epss_score": 0.67036, "epss_percentile": 0.98491}, "CVE-2017-6921": {"epss_score": 0.00532, "epss_percentile": 0.66684}, "CVE-2017-6922": {"epss_score": 0.02623, "epss_percentile": 0.85258}, "CVE-2017-6923": {"epss_score": 0.0082, "epss_percentile": 0.73875}, "CVE-2017-6924": {"epss_score": 0.0056, "epss_percentile": 0.67645}, "CVE-2017-6925": {"epss_score": 0.0062, "epss_percentile": 0.69457}, "CVE-2017-6926": {"epss_score": 0.00366, "epss_percentile": 0.58021}, "CVE-2017-6927": {"epss_score": 0.0139, "epss_percentile": 0.79938}, "CVE-2017-6928": {"epss_score": 0.00277, "epss_percentile": 0.50826}, "CVE-2017-6929": {"epss_score": 0.00603, "epss_percentile": 0.68935}, "CVE-2017-6930": {"epss_score": 0.00424, "epss_percentile": 0.61663}, "CVE-2017-6931": {"epss_score": 0.00179, "epss_percentile": 0.39841}, "CVE-2017-6932": {"epss_score": 0.00383, "epss_percentile": 0.59092}, "CVE-2017-6949": {"epss_score": 0.00516, "epss_percentile": 0.66053}, "CVE-2017-6950": {"epss_score": 0.006, "epss_percentile": 0.68833}, "CVE-2017-6951": {"epss_score": 0.00092, "epss_percentile": 0.26449}, "CVE-2017-6952": {"epss_score": 0.00348, "epss_percentile": 0.56795}, "CVE-2017-6953": {"epss_score": 0.00247, "epss_percentile": 0.47841}, "CVE-2017-6954": {"epss_score": 0.00295, "epss_percentile": 0.52477}, "CVE-2017-6955": {"epss_score": 0.00882, "epss_percentile": 0.74887}, "CVE-2017-6956": {"epss_score": 0.05418, "epss_percentile": 0.89854}, "CVE-2017-6957": {"epss_score": 0.09709, "epss_percentile": 0.92672}, "CVE-2017-6958": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2017-6960": {"epss_score": 0.00358, "epss_percentile": 0.57503}, "CVE-2017-6961": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2017-6962": {"epss_score": 0.00297, "epss_percentile": 0.52695}, "CVE-2017-6964": {"epss_score": 0.00086, "epss_percentile": 0.25412}, "CVE-2017-6965": {"epss_score": 0.00254, "epss_percentile": 0.48502}, "CVE-2017-6966": {"epss_score": 0.00278, "epss_percentile": 0.50901}, "CVE-2017-6967": {"epss_score": 0.00182, "epss_percentile": 0.40203}, "CVE-2017-6968": {"epss_score": 0.00662, "epss_percentile": 0.706}, "CVE-2017-6969": {"epss_score": 0.00455, "epss_percentile": 0.63292}, "CVE-2017-6970": {"epss_score": 0.00599, "epss_percentile": 0.68797}, "CVE-2017-6971": {"epss_score": 0.31634, "epss_percentile": 0.9664}, "CVE-2017-6972": {"epss_score": 0.20929, "epss_percentile": 0.95444}, "CVE-2017-6973": {"epss_score": 0.00624, "epss_percentile": 0.6957}, "CVE-2017-6974": {"epss_score": 0.00193, "epss_percentile": 0.41448}, "CVE-2017-6975": {"epss_score": 0.00061, "epss_percentile": 0.19473}, "CVE-2017-6976": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2017-6977": {"epss_score": 0.00239, "epss_percentile": 0.46908}, "CVE-2017-6978": {"epss_score": 0.01537, "epss_percentile": 0.80921}, "CVE-2017-6979": {"epss_score": 0.02343, "epss_percentile": 0.84442}, "CVE-2017-6980": {"epss_score": 0.06379, "epss_percentile": 0.9071}, "CVE-2017-6981": {"epss_score": 0.00269, "epss_percentile": 0.50173}, "CVE-2017-6982": {"epss_score": 0.01181, "epss_percentile": 0.78306}, "CVE-2017-6983": {"epss_score": 0.00473, "epss_percentile": 0.64093}, "CVE-2017-6984": {"epss_score": 0.06415, "epss_percentile": 0.90745}, "CVE-2017-6985": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2017-6986": {"epss_score": 0.00239, "epss_percentile": 0.46908}, "CVE-2017-6987": {"epss_score": 0.00242, "epss_percentile": 0.47389}, "CVE-2017-6988": {"epss_score": 0.00163, "epss_percentile": 0.37767}, "CVE-2017-6989": {"epss_score": 0.01208, "epss_percentile": 0.78535}, "CVE-2017-6990": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2017-6991": {"epss_score": 0.00958, "epss_percentile": 0.75942}, "CVE-2017-6994": {"epss_score": 0.00676, "epss_percentile": 0.70942}, "CVE-2017-6995": {"epss_score": 0.00676, "epss_percentile": 0.70942}, "CVE-2017-6996": {"epss_score": 0.00676, "epss_percentile": 0.70942}, "CVE-2017-6997": {"epss_score": 0.00676, "epss_percentile": 0.70942}, "CVE-2017-6998": {"epss_score": 0.00676, "epss_percentile": 0.70942}, "CVE-2017-6999": {"epss_score": 0.00676, "epss_percentile": 0.70942}, "CVE-2017-7000": {"epss_score": 0.00584, "epss_percentile": 0.68378}, "CVE-2017-7001": {"epss_score": 0.00883, "epss_percentile": 0.74914}, "CVE-2017-7002": {"epss_score": 0.00883, "epss_percentile": 0.74914}, "CVE-2017-7003": {"epss_score": 0.00277, "epss_percentile": 0.50783}, "CVE-2017-7004": {"epss_score": 0.05611, "epss_percentile": 0.90046}, "CVE-2017-7005": {"epss_score": 0.03216, "epss_percentile": 0.86663}, "CVE-2017-7006": {"epss_score": 0.00644, "epss_percentile": 0.70091}, "CVE-2017-7007": {"epss_score": 0.01395, "epss_percentile": 0.79976}, "CVE-2017-7008": {"epss_score": 0.00579, "epss_percentile": 0.68234}, "CVE-2017-7009": {"epss_score": 0.00183, "epss_percentile": 0.40323}, "CVE-2017-7010": {"epss_score": 0.00318, "epss_percentile": 0.54455}, "CVE-2017-7011": {"epss_score": 0.00835, "epss_percentile": 0.74121}, "CVE-2017-7012": {"epss_score": 0.00707, "epss_percentile": 0.71653}, "CVE-2017-7013": {"epss_score": 0.00311, "epss_percentile": 0.53918}, "CVE-2017-7014": {"epss_score": 0.00165, "epss_percentile": 0.38055}, "CVE-2017-7015": {"epss_score": 0.00366, "epss_percentile": 0.58064}, "CVE-2017-7016": {"epss_score": 0.00502, "epss_percentile": 0.65395}, "CVE-2017-7017": {"epss_score": 0.00165, "epss_percentile": 0.38055}, "CVE-2017-7018": {"epss_score": 0.03472, "epss_percentile": 0.87201}, "CVE-2017-7019": {"epss_score": 0.00513, "epss_percentile": 0.65893}, "CVE-2017-7020": {"epss_score": 0.00513, "epss_percentile": 0.65893}, "CVE-2017-7021": {"epss_score": 0.00165, "epss_percentile": 0.38055}, "CVE-2017-7022": {"epss_score": 0.00307, "epss_percentile": 0.53569}, "CVE-2017-7023": {"epss_score": 0.00307, "epss_percentile": 0.53569}, "CVE-2017-7024": {"epss_score": 0.00307, "epss_percentile": 0.53569}, "CVE-2017-7025": {"epss_score": 0.00307, "epss_percentile": 0.53569}, "CVE-2017-7026": {"epss_score": 0.00183, "epss_percentile": 0.40323}, "CVE-2017-7027": {"epss_score": 0.00183, "epss_percentile": 0.40323}, "CVE-2017-7028": {"epss_score": 0.00265, "epss_percentile": 0.49794}, "CVE-2017-7029": {"epss_score": 0.00265, "epss_percentile": 0.49794}, "CVE-2017-7030": {"epss_score": 0.00513, "epss_percentile": 0.65893}, "CVE-2017-7031": {"epss_score": 0.00502, "epss_percentile": 0.65395}, "CVE-2017-7032": {"epss_score": 0.00165, "epss_percentile": 0.38055}, "CVE-2017-7033": {"epss_score": 0.00502, "epss_percentile": 0.65395}, "CVE-2017-7034": {"epss_score": 0.00513, "epss_percentile": 0.65893}, "CVE-2017-7035": {"epss_score": 0.00423, "epss_percentile": 0.61601}, "CVE-2017-7036": {"epss_score": 0.00249, "epss_percentile": 0.48013}, "CVE-2017-7037": {"epss_score": 0.03473, "epss_percentile": 0.87204}, "CVE-2017-7038": {"epss_score": 0.0561, "epss_percentile": 0.90045}, "CVE-2017-7039": {"epss_score": 0.03473, "epss_percentile": 0.87204}, "CVE-2017-7040": {"epss_score": 0.03473, "epss_percentile": 0.87204}, "CVE-2017-7041": {"epss_score": 0.13305, "epss_percentile": 0.93928}, "CVE-2017-7042": {"epss_score": 0.14373, "epss_percentile": 0.94197}, "CVE-2017-7043": {"epss_score": 0.03473, "epss_percentile": 0.87204}, "CVE-2017-7044": {"epss_score": 0.00165, "epss_percentile": 0.38055}, "CVE-2017-7045": {"epss_score": 0.00249, "epss_percentile": 0.48013}, "CVE-2017-7046": {"epss_score": 0.0481, "epss_percentile": 0.89165}, "CVE-2017-7047": {"epss_score": 0.22491, "epss_percentile": 0.95643}, "CVE-2017-7048": {"epss_score": 0.04406, "epss_percentile": 0.88652}, "CVE-2017-7049": {"epss_score": 0.0481, "epss_percentile": 0.89165}, "CVE-2017-7050": {"epss_score": 0.00317, "epss_percentile": 0.54331}, "CVE-2017-7051": {"epss_score": 0.00317, "epss_percentile": 0.54331}, "CVE-2017-7052": {"epss_score": 0.00927, "epss_percentile": 0.75562}, "CVE-2017-7053": {"epss_score": 0.00188, "epss_percentile": 0.40872}, "CVE-2017-7054": {"epss_score": 0.00317, "epss_percentile": 0.54331}, "CVE-2017-7055": {"epss_score": 0.00927, "epss_percentile": 0.75562}, "CVE-2017-7056": {"epss_score": 0.07455, "epss_percentile": 0.91481}, "CVE-2017-7058": {"epss_score": 0.00075, "epss_percentile": 0.22892}, "CVE-2017-7059": {"epss_score": 0.00489, "epss_percentile": 0.6491}, "CVE-2017-7060": {"epss_score": 0.00582, "epss_percentile": 0.68306}, "CVE-2017-7061": {"epss_score": 0.08109, "epss_percentile": 0.91883}, "CVE-2017-7062": {"epss_score": 0.03565, "epss_percentile": 0.87361}, "CVE-2017-7063": {"epss_score": 0.02154, "epss_percentile": 0.83801}, "CVE-2017-7064": {"epss_score": 0.03323, "epss_percentile": 0.86914}, "CVE-2017-7065": {"epss_score": 0.00942, "epss_percentile": 0.75759}, "CVE-2017-7066": {"epss_score": 0.00112, "epss_percentile": 0.30497}, "CVE-2017-7067": {"epss_score": 0.00249, "epss_percentile": 0.48013}, "CVE-2017-7068": {"epss_score": 0.01802, "epss_percentile": 0.82332}, "CVE-2017-7069": {"epss_score": 0.0017, "epss_percentile": 0.38651}, "CVE-2017-7070": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2017-7071": {"epss_score": 0.00842, "epss_percentile": 0.74239}, "CVE-2017-7072": {"epss_score": 0.00276, "epss_percentile": 0.50709}, "CVE-2017-7074": {"epss_score": 0.00183, "epss_percentile": 0.40291}, "CVE-2017-7075": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2017-7076": {"epss_score": 0.00502, "epss_percentile": 0.65395}, "CVE-2017-7077": {"epss_score": 0.00165, "epss_percentile": 0.38055}, "CVE-2017-7078": {"epss_score": 0.00208, "epss_percentile": 0.43237}, "CVE-2017-7079": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-7080": {"epss_score": 0.00441, "epss_percentile": 0.62687}, "CVE-2017-7081": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7082": {"epss_score": 0.00075, "epss_percentile": 0.22892}, "CVE-2017-7083": {"epss_score": 0.01772, "epss_percentile": 0.82202}, "CVE-2017-7084": {"epss_score": 0.00658, "epss_percentile": 0.70492}, "CVE-2017-7085": {"epss_score": 0.00765, "epss_percentile": 0.72915}, "CVE-2017-7086": {"epss_score": 0.04633, "epss_percentile": 0.88947}, "CVE-2017-7087": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7088": {"epss_score": 0.01577, "epss_percentile": 0.8112}, "CVE-2017-7089": {"epss_score": 0.01892, "epss_percentile": 0.82736}, "CVE-2017-7090": {"epss_score": 0.00586, "epss_percentile": 0.68432}, "CVE-2017-7091": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7092": {"epss_score": 0.29833, "epss_percentile": 0.96478}, "CVE-2017-7093": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7094": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7095": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7096": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7097": {"epss_score": 0.0029, "epss_percentile": 0.52137}, "CVE-2017-7098": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7099": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7100": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7102": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7103": {"epss_score": 0.0493, "epss_percentile": 0.89296}, "CVE-2017-7104": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7105": {"epss_score": 0.10946, "epss_percentile": 0.9317}, "CVE-2017-7106": {"epss_score": 0.00898, "epss_percentile": 0.75145}, "CVE-2017-7107": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7108": {"epss_score": 0.10946, "epss_percentile": 0.9317}, "CVE-2017-7109": {"epss_score": 0.00936, "epss_percentile": 0.75686}, "CVE-2017-7110": {"epss_score": 0.10946, "epss_percentile": 0.9317}, "CVE-2017-7111": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7112": {"epss_score": 0.10946, "epss_percentile": 0.9317}, "CVE-2017-7113": {"epss_score": 0.00046, "epss_percentile": 0.14326}, "CVE-2017-7114": {"epss_score": 0.00183, "epss_percentile": 0.40323}, "CVE-2017-7115": {"epss_score": 0.07984, "epss_percentile": 0.91803}, "CVE-2017-7116": {"epss_score": 0.00782, "epss_percentile": 0.73211}, "CVE-2017-7117": {"epss_score": 0.04112, "epss_percentile": 0.88274}, "CVE-2017-7118": {"epss_score": 0.00276, "epss_percentile": 0.50709}, "CVE-2017-7119": {"epss_score": 0.00249, "epss_percentile": 0.48013}, "CVE-2017-7120": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2017-7121": {"epss_score": 0.00788, "epss_percentile": 0.73338}, "CVE-2017-7122": {"epss_score": 0.00788, "epss_percentile": 0.73338}, "CVE-2017-7123": {"epss_score": 0.00788, "epss_percentile": 0.73338}, "CVE-2017-7124": {"epss_score": 0.00788, "epss_percentile": 0.73338}, "CVE-2017-7125": {"epss_score": 0.00788, "epss_percentile": 0.73338}, "CVE-2017-7126": {"epss_score": 0.01583, "epss_percentile": 0.81151}, "CVE-2017-7127": {"epss_score": 0.00156, "epss_percentile": 0.3696}, "CVE-2017-7128": {"epss_score": 0.01729, "epss_percentile": 0.81981}, "CVE-2017-7129": {"epss_score": 0.01729, "epss_percentile": 0.81981}, "CVE-2017-7130": {"epss_score": 0.01729, "epss_percentile": 0.81981}, "CVE-2017-7131": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2017-7132": {"epss_score": 0.01183, "epss_percentile": 0.78322}, "CVE-2017-7133": {"epss_score": 0.00342, "epss_percentile": 0.56402}, "CVE-2017-7134": {"epss_score": 0.00502, "epss_percentile": 0.65395}, "CVE-2017-7135": {"epss_score": 0.00502, "epss_percentile": 0.65395}, "CVE-2017-7136": {"epss_score": 0.00502, "epss_percentile": 0.65395}, "CVE-2017-7137": {"epss_score": 0.00502, "epss_percentile": 0.65395}, "CVE-2017-7138": {"epss_score": 0.00064, "epss_percentile": 0.20153}, "CVE-2017-7139": {"epss_score": 0.00065, "epss_percentile": 0.2056}, "CVE-2017-7140": {"epss_score": 0.00208, "epss_percentile": 0.43299}, "CVE-2017-7141": {"epss_score": 0.00194, "epss_percentile": 0.41542}, "CVE-2017-7142": {"epss_score": 0.00254, "epss_percentile": 0.48566}, "CVE-2017-7143": {"epss_score": 0.00074, "epss_percentile": 0.22802}, "CVE-2017-7144": {"epss_score": 0.00446, "epss_percentile": 0.6292}, "CVE-2017-7145": {"epss_score": 0.00232, "epss_percentile": 0.45938}, "CVE-2017-7146": {"epss_score": 0.00178, "epss_percentile": 0.39718}, "CVE-2017-7147": {"epss_score": 0.00123, "epss_percentile": 0.32177}, "CVE-2017-7148": {"epss_score": 0.00167, "epss_percentile": 0.38367}, "CVE-2017-7149": {"epss_score": 0.00101, "epss_percentile": 0.28565}, "CVE-2017-7150": {"epss_score": 0.00069, "epss_percentile": 0.21502}, "CVE-2017-7151": {"epss_score": 0.00254, "epss_percentile": 0.48501}, "CVE-2017-7152": {"epss_score": 0.00466, "epss_percentile": 0.6379}, "CVE-2017-7153": {"epss_score": 0.00423, "epss_percentile": 0.61616}, "CVE-2017-7154": {"epss_score": 0.00093, "epss_percentile": 0.2672}, "CVE-2017-7155": {"epss_score": 0.00229, "epss_percentile": 0.45643}, "CVE-2017-7156": {"epss_score": 0.01523, "epss_percentile": 0.80844}, "CVE-2017-7157": {"epss_score": 0.01523, "epss_percentile": 0.80844}, "CVE-2017-7158": {"epss_score": 0.00281, "epss_percentile": 0.5113}, "CVE-2017-7159": {"epss_score": 0.00229, "epss_percentile": 0.45643}, "CVE-2017-7160": {"epss_score": 0.00476, "epss_percentile": 0.64258}, "CVE-2017-7161": {"epss_score": 0.00906, "epss_percentile": 0.75248}, "CVE-2017-7162": {"epss_score": 0.00244, "epss_percentile": 0.47598}, "CVE-2017-7163": {"epss_score": 0.00229, "epss_percentile": 0.45643}, "CVE-2017-7164": {"epss_score": 0.00179, "epss_percentile": 0.39855}, "CVE-2017-7165": {"epss_score": 0.00476, "epss_percentile": 0.64258}, "CVE-2017-7167": {"epss_score": 0.01112, "epss_percentile": 0.77674}, "CVE-2017-7170": {"epss_score": 0.00297, "epss_percentile": 0.52752}, "CVE-2017-7171": {"epss_score": 0.00244, "epss_percentile": 0.47598}, "CVE-2017-7172": {"epss_score": 0.00442, "epss_percentile": 0.62746}, "CVE-2017-7173": {"epss_score": 0.04078, "epss_percentile": 0.88213}, "CVE-2017-7174": {"epss_score": 0.02014, "epss_percentile": 0.83262}, "CVE-2017-7175": {"epss_score": 0.21418, "epss_percentile": 0.95514}, "CVE-2017-7177": {"epss_score": 0.00241, "epss_percentile": 0.47234}, "CVE-2017-7178": {"epss_score": 0.01226, "epss_percentile": 0.7869}, "CVE-2017-7180": {"epss_score": 0.00081, "epss_percentile": 0.24213}, "CVE-2017-7183": {"epss_score": 0.30059, "epss_percentile": 0.96501}, "CVE-2017-7184": {"epss_score": 0.01765, "epss_percentile": 0.82164}, "CVE-2017-7185": {"epss_score": 0.3325, "epss_percentile": 0.96756}, "CVE-2017-7186": {"epss_score": 0.05405, "epss_percentile": 0.89838}, "CVE-2017-7187": {"epss_score": 0.00082, "epss_percentile": 0.24495}, "CVE-2017-7188": {"epss_score": 0.00933, "epss_percentile": 0.7564}, "CVE-2017-7189": {"epss_score": 0.01221, "epss_percentile": 0.7865}, "CVE-2017-7191": {"epss_score": 0.02075, "epss_percentile": 0.83505}, "CVE-2017-7192": {"epss_score": 0.00224, "epss_percentile": 0.45006}, "CVE-2017-7199": {"epss_score": 0.00079, "epss_percentile": 0.23817}, "CVE-2017-7200": {"epss_score": 0.00375, "epss_percentile": 0.58614}, "CVE-2017-7202": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-7203": {"epss_score": 0.00283, "epss_percentile": 0.51385}, "CVE-2017-7204": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-7205": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2017-7206": {"epss_score": 0.00216, "epss_percentile": 0.44205}, "CVE-2017-7207": {"epss_score": 0.00547, "epss_percentile": 0.67256}, "CVE-2017-7208": {"epss_score": 0.00226, "epss_percentile": 0.45257}, "CVE-2017-7209": {"epss_score": 0.00314, "epss_percentile": 0.54145}, "CVE-2017-7210": {"epss_score": 0.00314, "epss_percentile": 0.54145}, "CVE-2017-7213": {"epss_score": 0.10414, "epss_percentile": 0.9298}, "CVE-2017-7214": {"epss_score": 0.01297, "epss_percentile": 0.79262}, "CVE-2017-7215": {"epss_score": 0.006, "epss_percentile": 0.68813}, "CVE-2017-7216": {"epss_score": 0.00221, "epss_percentile": 0.44655}, "CVE-2017-7217": {"epss_score": 0.00204, "epss_percentile": 0.4267}, "CVE-2017-7218": {"epss_score": 0.00175, "epss_percentile": 0.39277}, "CVE-2017-7219": {"epss_score": 0.0164, "epss_percentile": 0.81499}, "CVE-2017-7220": {"epss_score": 0.00674, "epss_percentile": 0.70875}, "CVE-2017-7221": {"epss_score": 0.01844, "epss_percentile": 0.82506}, "CVE-2017-7222": {"epss_score": 0.00272, "epss_percentile": 0.50359}, "CVE-2017-7223": {"epss_score": 0.0039, "epss_percentile": 0.59519}, "CVE-2017-7224": {"epss_score": 0.00296, "epss_percentile": 0.52558}, "CVE-2017-7225": {"epss_score": 0.00432, "epss_percentile": 0.62119}, "CVE-2017-7226": {"epss_score": 0.00379, "epss_percentile": 0.58891}, "CVE-2017-7227": {"epss_score": 0.0044, "epss_percentile": 0.62628}, "CVE-2017-7228": {"epss_score": 0.01734, "epss_percentile": 0.82003}, "CVE-2017-7229": {"epss_score": 0.00245, "epss_percentile": 0.47634}, "CVE-2017-7230": {"epss_score": 0.65643, "epss_percentile": 0.9843}, "CVE-2017-7231": {"epss_score": 0.00273, "epss_percentile": 0.50472}, "CVE-2017-7233": {"epss_score": 0.00814, "epss_percentile": 0.73771}, "CVE-2017-7234": {"epss_score": 0.00422, "epss_percentile": 0.6157}, "CVE-2017-7235": {"epss_score": 0.00494, "epss_percentile": 0.65078}, "CVE-2017-7236": {"epss_score": 0.0029, "epss_percentile": 0.5212}, "CVE-2017-7237": {"epss_score": 0.14619, "epss_percentile": 0.94252}, "CVE-2017-7239": {"epss_score": 0.02113, "epss_percentile": 0.83651}, "CVE-2017-7240": {"epss_score": 0.32658, "epss_percentile": 0.96715}, "CVE-2017-7241": {"epss_score": 0.00804, "epss_percentile": 0.73615}, "CVE-2017-7242": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-7243": {"epss_score": 0.00759, "epss_percentile": 0.72787}, "CVE-2017-7244": {"epss_score": 0.00762, "epss_percentile": 0.72836}, "CVE-2017-7245": {"epss_score": 0.00436, "epss_percentile": 0.62487}, "CVE-2017-7246": {"epss_score": 0.0059, "epss_percentile": 0.68556}, "CVE-2017-7247": {"epss_score": 0.00315, "epss_percentile": 0.54179}, "CVE-2017-7248": {"epss_score": 0.00315, "epss_percentile": 0.54179}, "CVE-2017-7249": {"epss_score": 0.00315, "epss_percentile": 0.54179}, "CVE-2017-7250": {"epss_score": 0.00315, "epss_percentile": 0.54179}, "CVE-2017-7251": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-7252": {"epss_score": 0.0009, "epss_percentile": 0.26062}, "CVE-2017-7253": {"epss_score": 0.00837, "epss_percentile": 0.74155}, "CVE-2017-7255": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-7256": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-7257": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-7258": {"epss_score": 0.0058, "epss_percentile": 0.68238}, "CVE-2017-7261": {"epss_score": 0.0011, "epss_percentile": 0.30108}, "CVE-2017-7262": {"epss_score": 0.00058, "epss_percentile": 0.18391}, "CVE-2017-7263": {"epss_score": 0.0035, "epss_percentile": 0.56916}, "CVE-2017-7264": {"epss_score": 0.00194, "epss_percentile": 0.41581}, "CVE-2017-7266": {"epss_score": 0.00244, "epss_percentile": 0.47552}, "CVE-2017-7269": {"epss_score": 0.94429, "epss_percentile": 0.99982}, "CVE-2017-7271": {"epss_score": 0.00285, "epss_percentile": 0.51548}, "CVE-2017-7272": {"epss_score": 0.02667, "epss_percentile": 0.85379}, "CVE-2017-7273": {"epss_score": 0.00104, "epss_percentile": 0.29184}, "CVE-2017-7274": {"epss_score": 0.00227, "epss_percentile": 0.45427}, "CVE-2017-7275": {"epss_score": 0.00406, "epss_percentile": 0.60566}, "CVE-2017-7276": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-7277": {"epss_score": 0.00085, "epss_percentile": 0.25039}, "CVE-2017-7278": {"epss_score": 0.00521, "epss_percentile": 0.66234}, "CVE-2017-7279": {"epss_score": 0.04464, "epss_percentile": 0.88727}, "CVE-2017-7280": {"epss_score": 0.10183, "epss_percentile": 0.92883}, "CVE-2017-7281": {"epss_score": 0.07407, "epss_percentile": 0.91456}, "CVE-2017-7282": {"epss_score": 0.07531, "epss_percentile": 0.9152}, "CVE-2017-7283": {"epss_score": 0.16596, "epss_percentile": 0.94699}, "CVE-2017-7284": {"epss_score": 0.0378, "epss_percentile": 0.87719}, "CVE-2017-7285": {"epss_score": 0.23231, "epss_percentile": 0.95754}, "CVE-2017-7288": {"epss_score": 0.00405, "epss_percentile": 0.60464}, "CVE-2017-7290": {"epss_score": 0.00562, "epss_percentile": 0.67689}, "CVE-2017-7293": {"epss_score": 0.01922, "epss_percentile": 0.82907}, "CVE-2017-7294": {"epss_score": 0.00113, "epss_percentile": 0.30714}, "CVE-2017-7295": {"epss_score": 0.00348, "epss_percentile": 0.56823}, "CVE-2017-7296": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-7297": {"epss_score": 0.01029, "epss_percentile": 0.7683}, "CVE-2017-7298": {"epss_score": 0.00243, "epss_percentile": 0.47509}, "CVE-2017-7299": {"epss_score": 0.00261, "epss_percentile": 0.49264}, "CVE-2017-7300": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2017-7301": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2017-7302": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2017-7303": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2017-7304": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2017-7305": {"epss_score": 0.00052, "epss_percentile": 0.16453}, "CVE-2017-7306": {"epss_score": 0.0007, "epss_percentile": 0.21725}, "CVE-2017-7307": {"epss_score": 0.00042, "epss_percentile": 0.12605}, "CVE-2017-7308": {"epss_score": 0.86119, "epss_percentile": 0.99368}, "CVE-2017-7309": {"epss_score": 0.02475, "epss_percentile": 0.84859}, "CVE-2017-7310": {"epss_score": 0.86559, "epss_percentile": 0.99388}, "CVE-2017-7312": {"epss_score": 0.08326, "epss_percentile": 0.91992}, "CVE-2017-7313": {"epss_score": 0.00379, "epss_percentile": 0.58889}, "CVE-2017-7314": {"epss_score": 0.08852, "epss_percentile": 0.92285}, "CVE-2017-7315": {"epss_score": 0.00887, "epss_percentile": 0.74966}, "CVE-2017-7316": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2017-7317": {"epss_score": 0.00798, "epss_percentile": 0.73512}, "CVE-2017-7318": {"epss_score": 0.09657, "epss_percentile": 0.92643}, "CVE-2017-7320": {"epss_score": 0.0031, "epss_percentile": 0.53743}, "CVE-2017-7321": {"epss_score": 0.02182, "epss_percentile": 0.83909}, "CVE-2017-7322": {"epss_score": 0.0051, "epss_percentile": 0.65765}, "CVE-2017-7323": {"epss_score": 0.01126, "epss_percentile": 0.77812}, "CVE-2017-7324": {"epss_score": 0.02182, "epss_percentile": 0.83909}, "CVE-2017-7325": {"epss_score": 0.00216, "epss_percentile": 0.44203}, "CVE-2017-7326": {"epss_score": 0.00392, "epss_percentile": 0.59647}, "CVE-2017-7327": {"epss_score": 0.00264, "epss_percentile": 0.49713}, "CVE-2017-7335": {"epss_score": 0.00253, "epss_percentile": 0.48483}, "CVE-2017-7336": {"epss_score": 0.00942, "epss_percentile": 0.7576}, "CVE-2017-7337": {"epss_score": 0.0024, "epss_percentile": 0.47225}, "CVE-2017-7338": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2017-7339": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-7340": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-7341": {"epss_score": 0.02526, "epss_percentile": 0.85015}, "CVE-2017-7342": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2017-7343": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2017-7344": {"epss_score": 0.01272, "epss_percentile": 0.79079}, "CVE-2017-7345": {"epss_score": 0.00203, "epss_percentile": 0.42499}, "CVE-2017-7346": {"epss_score": 0.00102, "epss_percentile": 0.28809}, "CVE-2017-7351": {"epss_score": 0.00211, "epss_percentile": 0.43641}, "CVE-2017-7352": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2017-7357": {"epss_score": 0.0216, "epss_percentile": 0.83823}, "CVE-2017-7358": {"epss_score": 0.01019, "epss_percentile": 0.76722}, "CVE-2017-7359": {"epss_score": 0.00285, "epss_percentile": 0.51547}, "CVE-2017-7360": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-7361": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-7362": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-7363": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-7364": {"epss_score": 0.00152, "epss_percentile": 0.36483}, "CVE-2017-7365": {"epss_score": 0.00044, "epss_percentile": 0.13653}, "CVE-2017-7366": {"epss_score": 0.00062, "epss_percentile": 0.19684}, "CVE-2017-7367": {"epss_score": 0.00044, "epss_percentile": 0.13653}, "CVE-2017-7368": {"epss_score": 0.00034, "epss_percentile": 0.09789}, "CVE-2017-7369": {"epss_score": 0.00075, "epss_percentile": 0.23014}, "CVE-2017-7370": {"epss_score": 0.0005, "epss_percentile": 0.15946}, "CVE-2017-7371": {"epss_score": 0.00044, "epss_percentile": 0.13653}, "CVE-2017-7372": {"epss_score": 0.00037, "epss_percentile": 0.10883}, "CVE-2017-7373": {"epss_score": 0.00044, "epss_percentile": 0.13653}, "CVE-2017-7374": {"epss_score": 0.00354, "epss_percentile": 0.57204}, "CVE-2017-7375": {"epss_score": 0.00255, "epss_percentile": 0.48647}, "CVE-2017-7376": {"epss_score": 0.38432, "epss_percentile": 0.971}, "CVE-2017-7377": {"epss_score": 0.00075, "epss_percentile": 0.22928}, "CVE-2017-7378": {"epss_score": 0.00432, "epss_percentile": 0.62107}, "CVE-2017-7379": {"epss_score": 0.00432, "epss_percentile": 0.62107}, "CVE-2017-7380": {"epss_score": 0.00432, "epss_percentile": 0.62107}, "CVE-2017-7381": {"epss_score": 0.00413, "epss_percentile": 0.60998}, "CVE-2017-7382": {"epss_score": 0.00413, "epss_percentile": 0.60998}, "CVE-2017-7383": {"epss_score": 0.00413, "epss_percentile": 0.60998}, "CVE-2017-7384": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2017-7386": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-7387": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-7388": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-7389": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-7390": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-7391": {"epss_score": 0.08891, "epss_percentile": 0.92304}, "CVE-2017-7392": {"epss_score": 0.00705, "epss_percentile": 0.71574}, "CVE-2017-7393": {"epss_score": 0.02051, "epss_percentile": 0.83402}, "CVE-2017-7394": {"epss_score": 0.02813, "epss_percentile": 0.85725}, "CVE-2017-7395": {"epss_score": 0.00481, "epss_percentile": 0.64515}, "CVE-2017-7396": {"epss_score": 0.00528, "epss_percentile": 0.66575}, "CVE-2017-7397": {"epss_score": 0.21803, "epss_percentile": 0.95562}, "CVE-2017-7398": {"epss_score": 0.00333, "epss_percentile": 0.55653}, "CVE-2017-7399": {"epss_score": 0.00336, "epss_percentile": 0.55939}, "CVE-2017-7400": {"epss_score": 0.00223, "epss_percentile": 0.44865}, "CVE-2017-7401": {"epss_score": 0.00982, "epss_percentile": 0.76285}, "CVE-2017-7402": {"epss_score": 0.09321, "epss_percentile": 0.92499}, "CVE-2017-7404": {"epss_score": 0.00312, "epss_percentile": 0.53961}, "CVE-2017-7405": {"epss_score": 0.01744, "epss_percentile": 0.82062}, "CVE-2017-7406": {"epss_score": 0.00102, "epss_percentile": 0.28759}, "CVE-2017-7407": {"epss_score": 0.0027, "epss_percentile": 0.50263}, "CVE-2017-7408": {"epss_score": 0.00511, "epss_percentile": 0.65814}, "CVE-2017-7409": {"epss_score": 0.00307, "epss_percentile": 0.53562}, "CVE-2017-7410": {"epss_score": 0.01687, "epss_percentile": 0.8176}, "CVE-2017-7411": {"epss_score": 0.73892, "epss_percentile": 0.98775}, "CVE-2017-7412": {"epss_score": 0.00045, "epss_percentile": 0.1406}, "CVE-2017-7413": {"epss_score": 0.13252, "epss_percentile": 0.93914}, "CVE-2017-7414": {"epss_score": 0.01304, "epss_percentile": 0.79315}, "CVE-2017-7415": {"epss_score": 0.01093, "epss_percentile": 0.77472}, "CVE-2017-7416": {"epss_score": 0.00227, "epss_percentile": 0.45457}, "CVE-2017-7418": {"epss_score": 0.00065, "epss_percentile": 0.2057}, "CVE-2017-7419": {"epss_score": 0.00182, "epss_percentile": 0.40158}, "CVE-2017-7420": {"epss_score": 0.00233, "epss_percentile": 0.46075}, "CVE-2017-7421": {"epss_score": 0.00306, "epss_percentile": 0.53445}, "CVE-2017-7422": {"epss_score": 0.00188, "epss_percentile": 0.40876}, "CVE-2017-7423": {"epss_score": 0.00282, "epss_percentile": 0.51234}, "CVE-2017-7424": {"epss_score": 0.00335, "epss_percentile": 0.55832}, "CVE-2017-7425": {"epss_score": 0.00491, "epss_percentile": 0.64961}, "CVE-2017-7426": {"epss_score": 0.00281, "epss_percentile": 0.51189}, "CVE-2017-7427": {"epss_score": 0.00202, "epss_percentile": 0.42442}, "CVE-2017-7428": {"epss_score": 0.00344, "epss_percentile": 0.56508}, "CVE-2017-7429": {"epss_score": 0.00194, "epss_percentile": 0.41575}, "CVE-2017-7430": {"epss_score": 0.00661, "epss_percentile": 0.70587}, "CVE-2017-7431": {"epss_score": 0.00275, "epss_percentile": 0.50644}, "CVE-2017-7432": {"epss_score": 0.0109, "epss_percentile": 0.77452}, "CVE-2017-7433": {"epss_score": 0.0025, "epss_percentile": 0.48207}, "CVE-2017-7434": {"epss_score": 0.00167, "epss_percentile": 0.3832}, "CVE-2017-7435": {"epss_score": 0.00521, "epss_percentile": 0.66239}, "CVE-2017-7436": {"epss_score": 0.00521, "epss_percentile": 0.66239}, "CVE-2017-7437": {"epss_score": 0.00182, "epss_percentile": 0.40158}, "CVE-2017-7438": {"epss_score": 0.00182, "epss_percentile": 0.40158}, "CVE-2017-7439": {"epss_score": 0.00297, "epss_percentile": 0.5277}, "CVE-2017-7440": {"epss_score": 0.00234, "epss_percentile": 0.46151}, "CVE-2017-7441": {"epss_score": 0.00032, "epss_percentile": 0.0879}, "CVE-2017-7442": {"epss_score": 0.68976, "epss_percentile": 0.98571}, "CVE-2017-7443": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-7444": {"epss_score": 0.00115, "epss_percentile": 0.31022}, "CVE-2017-7446": {"epss_score": 0.00272, "epss_percentile": 0.50389}, "CVE-2017-7447": {"epss_score": 0.00275, "epss_percentile": 0.50642}, "CVE-2017-7448": {"epss_score": 0.00284, "epss_percentile": 0.51478}, "CVE-2017-7450": {"epss_score": 0.00328, "epss_percentile": 0.55263}, "CVE-2017-7452": {"epss_score": 0.00272, "epss_percentile": 0.50404}, "CVE-2017-7453": {"epss_score": 0.00272, "epss_percentile": 0.50404}, "CVE-2017-7454": {"epss_score": 0.00272, "epss_percentile": 0.50404}, "CVE-2017-7455": {"epss_score": 0.39989, "epss_percentile": 0.9719}, "CVE-2017-7456": {"epss_score": 0.10539, "epss_percentile": 0.93021}, "CVE-2017-7457": {"epss_score": 0.00472, "epss_percentile": 0.64061}, "CVE-2017-7458": {"epss_score": 0.00604, "epss_percentile": 0.6895}, "CVE-2017-7459": {"epss_score": 0.00302, "epss_percentile": 0.53088}, "CVE-2017-7461": {"epss_score": 0.07798, "epss_percentile": 0.91687}, "CVE-2017-7462": {"epss_score": 0.1129, "epss_percentile": 0.93294}, "CVE-2017-7463": {"epss_score": 0.00655, "epss_percentile": 0.7037}, "CVE-2017-7464": {"epss_score": 0.00563, "epss_percentile": 0.67721}, "CVE-2017-7465": {"epss_score": 0.03681, "epss_percentile": 0.87559}, "CVE-2017-7466": {"epss_score": 0.02741, "epss_percentile": 0.8556}, "CVE-2017-7467": {"epss_score": 0.01344, "epss_percentile": 0.79609}, "CVE-2017-7468": {"epss_score": 0.00502, "epss_percentile": 0.65375}, "CVE-2017-7470": {"epss_score": 0.00766, "epss_percentile": 0.72942}, "CVE-2017-7471": {"epss_score": 0.00596, "epss_percentile": 0.68722}, "CVE-2017-7472": {"epss_score": 0.00934, "epss_percentile": 0.75654}, "CVE-2017-7474": {"epss_score": 0.01726, "epss_percentile": 0.81961}, "CVE-2017-7475": {"epss_score": 0.00344, "epss_percentile": 0.5653}, "CVE-2017-7476": {"epss_score": 0.01611, "epss_percentile": 0.81329}, "CVE-2017-7477": {"epss_score": 0.0005, "epss_percentile": 0.1585}, "CVE-2017-7478": {"epss_score": 0.06902, "epss_percentile": 0.91105}, "CVE-2017-7479": {"epss_score": 0.00712, "epss_percentile": 0.71753}, "CVE-2017-7480": {"epss_score": 0.02289, "epss_percentile": 0.84277}, "CVE-2017-7481": {"epss_score": 0.02024, "epss_percentile": 0.83311}, "CVE-2017-7482": {"epss_score": 0.00161, "epss_percentile": 0.37528}, "CVE-2017-7483": {"epss_score": 0.00779, "epss_percentile": 0.73146}, "CVE-2017-7484": {"epss_score": 0.0129, "epss_percentile": 0.79218}, "CVE-2017-7485": {"epss_score": 0.01022, "epss_percentile": 0.76759}, "CVE-2017-7486": {"epss_score": 0.06234, "epss_percentile": 0.90589}, "CVE-2017-7487": {"epss_score": 0.00094, "epss_percentile": 0.27009}, "CVE-2017-7488": {"epss_score": 0.00336, "epss_percentile": 0.55986}, "CVE-2017-7489": {"epss_score": 0.00316, "epss_percentile": 0.54236}, "CVE-2017-7490": {"epss_score": 0.00295, "epss_percentile": 0.52456}, "CVE-2017-7491": {"epss_score": 0.00122, "epss_percentile": 0.32038}, "CVE-2017-7493": {"epss_score": 0.0006, "epss_percentile": 0.18976}, "CVE-2017-7494": {"epss_score": 0.94176, "epss_percentile": 0.99912}, "CVE-2017-7495": {"epss_score": 0.00051, "epss_percentile": 0.16322}, "CVE-2017-7496": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2017-7497": {"epss_score": 0.00121, "epss_percentile": 0.31817}, "CVE-2017-7500": {"epss_score": 0.00054, "epss_percentile": 0.17045}, "CVE-2017-7501": {"epss_score": 0.00054, "epss_percentile": 0.17201}, "CVE-2017-7502": {"epss_score": 0.04527, "epss_percentile": 0.88807}, "CVE-2017-7503": {"epss_score": 0.00309, "epss_percentile": 0.53704}, "CVE-2017-7504": {"epss_score": 0.89407, "epss_percentile": 0.99524}, "CVE-2017-7505": {"epss_score": 0.00306, "epss_percentile": 0.53453}, "CVE-2017-7506": {"epss_score": 0.01575, "epss_percentile": 0.8111}, "CVE-2017-7507": {"epss_score": 0.00518, "epss_percentile": 0.66114}, "CVE-2017-7508": {"epss_score": 0.00712, "epss_percentile": 0.71774}, "CVE-2017-7509": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2017-7510": {"epss_score": 0.00253, "epss_percentile": 0.48464}, "CVE-2017-7511": {"epss_score": 0.00245, "epss_percentile": 0.47631}, "CVE-2017-7512": {"epss_score": 0.00498, "epss_percentile": 0.65224}, "CVE-2017-7513": {"epss_score": 0.0009, "epss_percentile": 0.26006}, "CVE-2017-7514": {"epss_score": 0.00205, "epss_percentile": 0.42728}, "CVE-2017-7515": {"epss_score": 0.00216, "epss_percentile": 0.44151}, "CVE-2017-7517": {"epss_score": 0.00184, "epss_percentile": 0.40454}, "CVE-2017-7518": {"epss_score": 0.0009, "epss_percentile": 0.26164}, "CVE-2017-7519": {"epss_score": 0.00042, "epss_percentile": 0.12889}, "CVE-2017-7520": {"epss_score": 0.00871, "epss_percentile": 0.74717}, "CVE-2017-7521": {"epss_score": 0.00833, "epss_percentile": 0.7409}, "CVE-2017-7522": {"epss_score": 0.01024, "epss_percentile": 0.76781}, "CVE-2017-7523": {"epss_score": 0.00419, "epss_percentile": 0.614}, "CVE-2017-7524": {"epss_score": 0.00248, "epss_percentile": 0.48001}, "CVE-2017-7525": {"epss_score": 0.79267, "epss_percentile": 0.99028}, "CVE-2017-7526": {"epss_score": 0.03739, "epss_percentile": 0.87653}, "CVE-2017-7528": {"epss_score": 0.00144, "epss_percentile": 0.35238}, "CVE-2017-7529": {"epss_score": 0.91909, "epss_percentile": 0.99677}, "CVE-2017-7530": {"epss_score": 0.00344, "epss_percentile": 0.56529}, "CVE-2017-7531": {"epss_score": 0.00199, "epss_percentile": 0.42118}, "CVE-2017-7532": {"epss_score": 0.00144, "epss_percentile": 0.35267}, "CVE-2017-7533": {"epss_score": 0.09416, "epss_percentile": 0.92538}, "CVE-2017-7534": {"epss_score": 0.00168, "epss_percentile": 0.38466}, "CVE-2017-7535": {"epss_score": 0.0051, "epss_percentile": 0.65794}, "CVE-2017-7536": {"epss_score": 0.00104, "epss_percentile": 0.29109}, "CVE-2017-7537": {"epss_score": 0.00079, "epss_percentile": 0.23836}, "CVE-2017-7538": {"epss_score": 0.00278, "epss_percentile": 0.50904}, "CVE-2017-7539": {"epss_score": 0.02754, "epss_percentile": 0.85588}, "CVE-2017-7540": {"epss_score": 0.00289, "epss_percentile": 0.52072}, "CVE-2017-7541": {"epss_score": 0.00067, "epss_percentile": 0.21149}, "CVE-2017-7542": {"epss_score": 0.00082, "epss_percentile": 0.24487}, "CVE-2017-7543": {"epss_score": 0.00481, "epss_percentile": 0.64494}, "CVE-2017-7544": {"epss_score": 0.00436, "epss_percentile": 0.62387}, "CVE-2017-7545": {"epss_score": 0.00815, "epss_percentile": 0.73795}, "CVE-2017-7546": {"epss_score": 0.33122, "epss_percentile": 0.96748}, "CVE-2017-7547": {"epss_score": 0.01147, "epss_percentile": 0.78008}, "CVE-2017-7548": {"epss_score": 0.01438, "epss_percentile": 0.80288}, "CVE-2017-7549": {"epss_score": 0.00079, "epss_percentile": 0.23949}, "CVE-2017-7550": {"epss_score": 0.00498, "epss_percentile": 0.65216}, "CVE-2017-7551": {"epss_score": 0.00369, "epss_percentile": 0.5824}, "CVE-2017-7552": {"epss_score": 0.00389, "epss_percentile": 0.59451}, "CVE-2017-7553": {"epss_score": 0.00181, "epss_percentile": 0.40117}, "CVE-2017-7554": {"epss_score": 0.00292, "epss_percentile": 0.52216}, "CVE-2017-7555": {"epss_score": 0.01596, "epss_percentile": 0.81241}, "CVE-2017-7556": {"epss_score": 0.0025, "epss_percentile": 0.48241}, "CVE-2017-7557": {"epss_score": 3e-05, "epss_percentile": 0.00085}, "CVE-2017-7558": {"epss_score": 0.00768, "epss_percentile": 0.72976}, "CVE-2017-7559": {"epss_score": 0.01128, "epss_percentile": 0.77833}, "CVE-2017-7560": {"epss_score": 0.00106, "epss_percentile": 0.29405}, "CVE-2017-7561": {"epss_score": 0.01068, "epss_percentile": 0.77237}, "CVE-2017-7562": {"epss_score": 0.00767, "epss_percentile": 0.72953}, "CVE-2017-7563": {"epss_score": 0.00345, "epss_percentile": 0.56559}, "CVE-2017-7564": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2017-7565": {"epss_score": 0.02586, "epss_percentile": 0.85169}, "CVE-2017-7566": {"epss_score": 0.00563, "epss_percentile": 0.67728}, "CVE-2017-7568": {"epss_score": 0.01375, "epss_percentile": 0.79828}, "CVE-2017-7569": {"epss_score": 0.0045, "epss_percentile": 0.63072}, "CVE-2017-7570": {"epss_score": 0.00829, "epss_percentile": 0.74007}, "CVE-2017-7571": {"epss_score": 0.00291, "epss_percentile": 0.52192}, "CVE-2017-7572": {"epss_score": 0.00649, "epss_percentile": 0.70226}, "CVE-2017-7574": {"epss_score": 0.0027, "epss_percentile": 0.50248}, "CVE-2017-7575": {"epss_score": 0.03375, "epss_percentile": 0.87018}, "CVE-2017-7576": {"epss_score": 0.00345, "epss_percentile": 0.56559}, "CVE-2017-7577": {"epss_score": 0.05644, "epss_percentile": 0.9008}, "CVE-2017-7578": {"epss_score": 0.00346, "epss_percentile": 0.56641}, "CVE-2017-7579": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-7581": {"epss_score": 0.64506, "epss_percentile": 0.9838}, "CVE-2017-7583": {"epss_score": 0.00579, "epss_percentile": 0.68222}, "CVE-2017-7584": {"epss_score": 0.00287, "epss_percentile": 0.51815}, "CVE-2017-7585": {"epss_score": 0.00613, "epss_percentile": 0.69251}, "CVE-2017-7586": {"epss_score": 0.00318, "epss_percentile": 0.54428}, "CVE-2017-7588": {"epss_score": 0.30892, "epss_percentile": 0.96574}, "CVE-2017-7589": {"epss_score": 0.00273, "epss_percentile": 0.50469}, "CVE-2017-7590": {"epss_score": 0.00267, "epss_percentile": 0.49998}, "CVE-2017-7591": {"epss_score": 0.00226, "epss_percentile": 0.45249}, "CVE-2017-7592": {"epss_score": 0.00351, "epss_percentile": 0.57048}, "CVE-2017-7593": {"epss_score": 0.00361, "epss_percentile": 0.57702}, "CVE-2017-7594": {"epss_score": 0.00441, "epss_percentile": 0.62696}, "CVE-2017-7595": {"epss_score": 0.00433, "epss_percentile": 0.62207}, "CVE-2017-7596": {"epss_score": 0.00363, "epss_percentile": 0.5787}, "CVE-2017-7597": {"epss_score": 0.00363, "epss_percentile": 0.5787}, "CVE-2017-7598": {"epss_score": 0.00699, "epss_percentile": 0.71456}, "CVE-2017-7599": {"epss_score": 0.00309, "epss_percentile": 0.53682}, "CVE-2017-7600": {"epss_score": 0.00354, "epss_percentile": 0.5721}, "CVE-2017-7601": {"epss_score": 0.00515, "epss_percentile": 0.66002}, "CVE-2017-7602": {"epss_score": 0.00515, "epss_percentile": 0.66002}, "CVE-2017-7603": {"epss_score": 0.00208, "epss_percentile": 0.43215}, "CVE-2017-7604": {"epss_score": 0.00208, "epss_percentile": 0.43215}, "CVE-2017-7605": {"epss_score": 0.00208, "epss_percentile": 0.43215}, "CVE-2017-7606": {"epss_score": 0.00379, "epss_percentile": 0.58899}, "CVE-2017-7607": {"epss_score": 0.00603, "epss_percentile": 0.68901}, "CVE-2017-7608": {"epss_score": 0.00459, "epss_percentile": 0.63455}, "CVE-2017-7609": {"epss_score": 0.00477, "epss_percentile": 0.64299}, "CVE-2017-7610": {"epss_score": 0.00514, "epss_percentile": 0.65959}, "CVE-2017-7611": {"epss_score": 0.00514, "epss_percentile": 0.65959}, "CVE-2017-7612": {"epss_score": 0.00514, "epss_percentile": 0.65959}, "CVE-2017-7613": {"epss_score": 0.00613, "epss_percentile": 0.6926}, "CVE-2017-7614": {"epss_score": 0.00236, "epss_percentile": 0.46433}, "CVE-2017-7615": {"epss_score": 0.93166, "epss_percentile": 0.9978}, "CVE-2017-7616": {"epss_score": 0.00082, "epss_percentile": 0.24426}, "CVE-2017-7617": {"epss_score": 0.22039, "epss_percentile": 0.95586}, "CVE-2017-7618": {"epss_score": 0.00729, "epss_percentile": 0.72126}, "CVE-2017-7619": {"epss_score": 0.00485, "epss_percentile": 0.64736}, "CVE-2017-7620": {"epss_score": 0.00325, "epss_percentile": 0.55011}, "CVE-2017-7621": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-7622": {"epss_score": 0.00606, "epss_percentile": 0.69026}, "CVE-2017-7623": {"epss_score": 0.00242, "epss_percentile": 0.47377}, "CVE-2017-7624": {"epss_score": 0.00242, "epss_percentile": 0.47377}, "CVE-2017-7625": {"epss_score": 0.01364, "epss_percentile": 0.79774}, "CVE-2017-7626": {"epss_score": 0.00264, "epss_percentile": 0.49728}, "CVE-2017-7627": {"epss_score": 0.00198, "epss_percentile": 0.42035}, "CVE-2017-7628": {"epss_score": 0.00263, "epss_percentile": 0.49503}, "CVE-2017-7629": {"epss_score": 0.00286, "epss_percentile": 0.51722}, "CVE-2017-7630": {"epss_score": 0.0023, "epss_percentile": 0.45762}, "CVE-2017-7631": {"epss_score": 0.00303, "epss_percentile": 0.53197}, "CVE-2017-7632": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2017-7633": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2017-7634": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2017-7635": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2017-7636": {"epss_score": 0.00315, "epss_percentile": 0.54184}, "CVE-2017-7637": {"epss_score": 0.0325, "epss_percentile": 0.86748}, "CVE-2017-7638": {"epss_score": 0.00186, "epss_percentile": 0.40659}, "CVE-2017-7639": {"epss_score": 0.00188, "epss_percentile": 0.4087}, "CVE-2017-7640": {"epss_score": 0.02299, "epss_percentile": 0.84305}, "CVE-2017-7641": {"epss_score": 0.00159, "epss_percentile": 0.37328}, "CVE-2017-7642": {"epss_score": 0.00385, "epss_percentile": 0.59215}, "CVE-2017-7643": {"epss_score": 0.00268, "epss_percentile": 0.50053}, "CVE-2017-7644": {"epss_score": 0.00231, "epss_percentile": 0.45786}, "CVE-2017-7645": {"epss_score": 0.16011, "epss_percentile": 0.94554}, "CVE-2017-7646": {"epss_score": 0.00826, "epss_percentile": 0.73962}, "CVE-2017-7647": {"epss_score": 0.02654, "epss_percentile": 0.85353}, "CVE-2017-7648": {"epss_score": 0.00621, "epss_percentile": 0.69482}, "CVE-2017-7649": {"epss_score": 0.00373, "epss_percentile": 0.58476}, "CVE-2017-7650": {"epss_score": 0.0111, "epss_percentile": 0.77655}, "CVE-2017-7651": {"epss_score": 0.23234, "epss_percentile": 0.95755}, "CVE-2017-7652": {"epss_score": 0.01038, "epss_percentile": 0.76936}, "CVE-2017-7653": {"epss_score": 0.0093, "epss_percentile": 0.75605}, "CVE-2017-7654": {"epss_score": 0.01447, "epss_percentile": 0.80331}, "CVE-2017-7655": {"epss_score": 0.00834, "epss_percentile": 0.74107}, "CVE-2017-7656": {"epss_score": 0.07346, "epss_percentile": 0.91422}, "CVE-2017-7657": {"epss_score": 0.07642, "epss_percentile": 0.91595}, "CVE-2017-7658": {"epss_score": 0.11354, "epss_percentile": 0.93322}, "CVE-2017-7659": {"epss_score": 0.38383, "epss_percentile": 0.97099}, "CVE-2017-7660": {"epss_score": 0.00455, "epss_percentile": 0.63308}, "CVE-2017-7661": {"epss_score": 0.00795, "epss_percentile": 0.73469}, "CVE-2017-7662": {"epss_score": 0.00848, "epss_percentile": 0.74356}, "CVE-2017-7663": {"epss_score": 0.00834, "epss_percentile": 0.74105}, "CVE-2017-7664": {"epss_score": 0.00627, "epss_percentile": 0.69637}, "CVE-2017-7665": {"epss_score": 0.0106, "epss_percentile": 0.77168}, "CVE-2017-7666": {"epss_score": 0.00167, "epss_percentile": 0.38384}, "CVE-2017-7667": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2017-7668": {"epss_score": 0.64408, "epss_percentile": 0.98377}, "CVE-2017-7669": {"epss_score": 0.00298, "epss_percentile": 0.52796}, "CVE-2017-7670": {"epss_score": 0.01728, "epss_percentile": 0.81974}, "CVE-2017-7671": {"epss_score": 0.0427, "epss_percentile": 0.88474}, "CVE-2017-7672": {"epss_score": 0.01818, "epss_percentile": 0.824}, "CVE-2017-7673": {"epss_score": 0.00405, "epss_percentile": 0.60479}, "CVE-2017-7674": {"epss_score": 0.0592, "epss_percentile": 0.90321}, "CVE-2017-7675": {"epss_score": 0.03836, "epss_percentile": 0.87824}, "CVE-2017-7676": {"epss_score": 0.0087, "epss_percentile": 0.74703}, "CVE-2017-7677": {"epss_score": 0.00321, "epss_percentile": 0.54686}, "CVE-2017-7678": {"epss_score": 0.0179, "epss_percentile": 0.82281}, "CVE-2017-7679": {"epss_score": 0.40144, "epss_percentile": 0.97199}, "CVE-2017-7680": {"epss_score": 0.01253, "epss_percentile": 0.78917}, "CVE-2017-7681": {"epss_score": 0.00097, "epss_percentile": 0.27625}, "CVE-2017-7682": {"epss_score": 0.00735, "epss_percentile": 0.7229}, "CVE-2017-7683": {"epss_score": 0.00609, "epss_percentile": 0.69089}, "CVE-2017-7684": {"epss_score": 0.01505, "epss_percentile": 0.80742}, "CVE-2017-7685": {"epss_score": 0.01062, "epss_percentile": 0.77185}, "CVE-2017-7686": {"epss_score": 0.0117, "epss_percentile": 0.78212}, "CVE-2017-7687": {"epss_score": 0.03234, "epss_percentile": 0.86701}, "CVE-2017-7688": {"epss_score": 0.0111, "epss_percentile": 0.77658}, "CVE-2017-7689": {"epss_score": 0.03225, "epss_percentile": 0.86684}, "CVE-2017-7690": {"epss_score": 0.00157, "epss_percentile": 0.37097}, "CVE-2017-7691": {"epss_score": 0.0059, "epss_percentile": 0.68546}, "CVE-2017-7692": {"epss_score": 0.12407, "epss_percentile": 0.93662}, "CVE-2017-7693": {"epss_score": 0.00723, "epss_percentile": 0.72014}, "CVE-2017-7694": {"epss_score": 0.05424, "epss_percentile": 0.89866}, "CVE-2017-7695": {"epss_score": 0.00389, "epss_percentile": 0.59451}, "CVE-2017-7696": {"epss_score": 0.01787, "epss_percentile": 0.82262}, "CVE-2017-7697": {"epss_score": 0.00429, "epss_percentile": 0.61992}, "CVE-2017-7698": {"epss_score": 0.00611, "epss_percentile": 0.69176}, "CVE-2017-7700": {"epss_score": 0.0051, "epss_percentile": 0.65763}, "CVE-2017-7701": {"epss_score": 0.0053, "epss_percentile": 0.6663}, "CVE-2017-7702": {"epss_score": 0.00533, "epss_percentile": 0.66777}, "CVE-2017-7703": {"epss_score": 0.00915, "epss_percentile": 0.75409}, "CVE-2017-7704": {"epss_score": 0.0053, "epss_percentile": 0.6663}, "CVE-2017-7705": {"epss_score": 0.0053, "epss_percentile": 0.6663}, "CVE-2017-7716": {"epss_score": 0.00186, "epss_percentile": 0.40631}, "CVE-2017-7717": {"epss_score": 0.00836, "epss_percentile": 0.74146}, "CVE-2017-7718": {"epss_score": 0.00127, "epss_percentile": 0.32871}, "CVE-2017-7719": {"epss_score": 0.01225, "epss_percentile": 0.78686}, "CVE-2017-7720": {"epss_score": 0.00051, "epss_percentile": 0.16302}, "CVE-2017-7721": {"epss_score": 0.00308, "epss_percentile": 0.53588}, "CVE-2017-7722": {"epss_score": 0.51511, "epss_percentile": 0.97783}, "CVE-2017-7723": {"epss_score": 0.00352, "epss_percentile": 0.57109}, "CVE-2017-7725": {"epss_score": 0.0362, "epss_percentile": 0.87442}, "CVE-2017-7726": {"epss_score": 0.00111, "epss_percentile": 0.30245}, "CVE-2017-7728": {"epss_score": 0.02115, "epss_percentile": 0.83657}, "CVE-2017-7729": {"epss_score": 0.0011, "epss_percentile": 0.30228}, "CVE-2017-7730": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2017-7731": {"epss_score": 0.00262, "epss_percentile": 0.49345}, "CVE-2017-7732": {"epss_score": 0.00852, "epss_percentile": 0.74423}, "CVE-2017-7733": {"epss_score": 0.00349, "epss_percentile": 0.5691}, "CVE-2017-7734": {"epss_score": 0.00305, "epss_percentile": 0.53395}, "CVE-2017-7735": {"epss_score": 0.00305, "epss_percentile": 0.53395}, "CVE-2017-7736": {"epss_score": 0.00151, "epss_percentile": 0.36316}, "CVE-2017-7737": {"epss_score": 0.00374, "epss_percentile": 0.58564}, "CVE-2017-7738": {"epss_score": 0.00346, "epss_percentile": 0.56675}, "CVE-2017-7739": {"epss_score": 0.00739, "epss_percentile": 0.72388}, "CVE-2017-7741": {"epss_score": 0.00338, "epss_percentile": 0.56126}, "CVE-2017-7742": {"epss_score": 0.00338, "epss_percentile": 0.56126}, "CVE-2017-7745": {"epss_score": 0.00325, "epss_percentile": 0.54981}, "CVE-2017-7746": {"epss_score": 0.02045, "epss_percentile": 0.83382}, "CVE-2017-7747": {"epss_score": 0.02045, "epss_percentile": 0.83382}, "CVE-2017-7748": {"epss_score": 0.00325, "epss_percentile": 0.54981}, "CVE-2017-7749": {"epss_score": 0.01874, "epss_percentile": 0.82651}, "CVE-2017-7750": {"epss_score": 0.01874, "epss_percentile": 0.82651}, "CVE-2017-7751": {"epss_score": 0.01874, "epss_percentile": 0.82651}, "CVE-2017-7752": {"epss_score": 0.00972, "epss_percentile": 0.76139}, "CVE-2017-7753": {"epss_score": 0.01721, "epss_percentile": 0.81935}, "CVE-2017-7754": {"epss_score": 0.01409, "epss_percentile": 0.80076}, "CVE-2017-7755": {"epss_score": 0.00765, "epss_percentile": 0.72912}, "CVE-2017-7756": {"epss_score": 0.01874, "epss_percentile": 0.82651}, "CVE-2017-7757": {"epss_score": 0.01874, "epss_percentile": 0.82651}, "CVE-2017-7758": {"epss_score": 0.01684, "epss_percentile": 0.81744}, "CVE-2017-7759": {"epss_score": 0.00299, "epss_percentile": 0.52877}, "CVE-2017-7760": {"epss_score": 0.00138, "epss_percentile": 0.34445}, "CVE-2017-7761": {"epss_score": 0.00086, "epss_percentile": 0.25341}, "CVE-2017-7762": {"epss_score": 0.0054, "epss_percentile": 0.66993}, "CVE-2017-7763": {"epss_score": 0.00509, "epss_percentile": 0.65747}, "CVE-2017-7764": {"epss_score": 0.01035, "epss_percentile": 0.76898}, "CVE-2017-7765": {"epss_score": 0.00493, "epss_percentile": 0.65037}, "CVE-2017-7766": {"epss_score": 0.00174, "epss_percentile": 0.39194}, "CVE-2017-7767": {"epss_score": 0.00138, "epss_percentile": 0.34342}, "CVE-2017-7768": {"epss_score": 0.00046, "epss_percentile": 0.14419}, "CVE-2017-7770": {"epss_score": 0.00369, "epss_percentile": 0.58229}, "CVE-2017-7771": {"epss_score": 0.00441, "epss_percentile": 0.62671}, "CVE-2017-7772": {"epss_score": 0.00476, "epss_percentile": 0.64264}, "CVE-2017-7773": {"epss_score": 0.00476, "epss_percentile": 0.64264}, "CVE-2017-7774": {"epss_score": 0.0058, "epss_percentile": 0.68239}, "CVE-2017-7776": {"epss_score": 0.00476, "epss_percentile": 0.64264}, "CVE-2017-7777": {"epss_score": 0.00518, "epss_percentile": 0.66114}, "CVE-2017-7778": {"epss_score": 0.0106, "epss_percentile": 0.77169}, "CVE-2017-7779": {"epss_score": 0.02073, "epss_percentile": 0.83495}, "CVE-2017-7780": {"epss_score": 0.01811, "epss_percentile": 0.82365}, "CVE-2017-7781": {"epss_score": 0.00911, "epss_percentile": 0.75328}, "CVE-2017-7782": {"epss_score": 0.0051, "epss_percentile": 0.65769}, "CVE-2017-7783": {"epss_score": 0.06903, "epss_percentile": 0.91106}, "CVE-2017-7784": {"epss_score": 0.05217, "epss_percentile": 0.89621}, "CVE-2017-7785": {"epss_score": 0.08433, "epss_percentile": 0.92049}, "CVE-2017-7786": {"epss_score": 0.0852, "epss_percentile": 0.92099}, "CVE-2017-7787": {"epss_score": 0.00979, "epss_percentile": 0.76256}, "CVE-2017-7788": {"epss_score": 0.01918, "epss_percentile": 0.82876}, "CVE-2017-7789": {"epss_score": 0.00769, "epss_percentile": 0.72992}, "CVE-2017-7790": {"epss_score": 0.00276, "epss_percentile": 0.50705}, "CVE-2017-7791": {"epss_score": 0.01355, "epss_percentile": 0.79707}, "CVE-2017-7792": {"epss_score": 0.07363, "epss_percentile": 0.91434}, "CVE-2017-7793": {"epss_score": 0.02442, "epss_percentile": 0.84756}, "CVE-2017-7794": {"epss_score": 0.00046, "epss_percentile": 0.14325}, "CVE-2017-7796": {"epss_score": 0.00057, "epss_percentile": 0.1815}, "CVE-2017-7797": {"epss_score": 0.00123, "epss_percentile": 0.32201}, "CVE-2017-7798": {"epss_score": 0.03574, "epss_percentile": 0.87377}, "CVE-2017-7799": {"epss_score": 0.00495, "epss_percentile": 0.65128}, "CVE-2017-7800": {"epss_score": 0.04285, "epss_percentile": 0.88492}, "CVE-2017-7801": {"epss_score": 0.02318, "epss_percentile": 0.84362}, "CVE-2017-7802": {"epss_score": 0.02292, "epss_percentile": 0.84287}, "CVE-2017-7803": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2017-7804": {"epss_score": 0.00689, "epss_percentile": 0.71229}, "CVE-2017-7805": {"epss_score": 0.03851, "epss_percentile": 0.87849}, "CVE-2017-7806": {"epss_score": 0.01719, "epss_percentile": 0.81926}, "CVE-2017-7807": {"epss_score": 0.00778, "epss_percentile": 0.73131}, "CVE-2017-7808": {"epss_score": 0.00125, "epss_percentile": 0.32502}, "CVE-2017-7809": {"epss_score": 0.02292, "epss_percentile": 0.84287}, "CVE-2017-7810": {"epss_score": 0.02388, "epss_percentile": 0.84585}, "CVE-2017-7811": {"epss_score": 0.02107, "epss_percentile": 0.83636}, "CVE-2017-7812": {"epss_score": 0.00272, "epss_percentile": 0.5037}, "CVE-2017-7813": {"epss_score": 0.00579, "epss_percentile": 0.6822}, "CVE-2017-7814": {"epss_score": 0.00319, "epss_percentile": 0.54532}, "CVE-2017-7815": {"epss_score": 0.00807, "epss_percentile": 0.73674}, "CVE-2017-7816": {"epss_score": 0.00272, "epss_percentile": 0.5037}, "CVE-2017-7817": {"epss_score": 0.00882, "epss_percentile": 0.74887}, "CVE-2017-7818": {"epss_score": 0.06919, "epss_percentile": 0.91117}, "CVE-2017-7819": {"epss_score": 0.06919, "epss_percentile": 0.91117}, "CVE-2017-7820": {"epss_score": 0.00807, "epss_percentile": 0.73674}, "CVE-2017-7821": {"epss_score": 0.02595, "epss_percentile": 0.85192}, "CVE-2017-7822": {"epss_score": 0.00612, "epss_percentile": 0.69224}, "CVE-2017-7823": {"epss_score": 0.01416, "epss_percentile": 0.8014}, "CVE-2017-7824": {"epss_score": 0.12063, "epss_percentile": 0.93558}, "CVE-2017-7825": {"epss_score": 0.0171, "epss_percentile": 0.81874}, "CVE-2017-7826": {"epss_score": 0.02383, "epss_percentile": 0.84571}, "CVE-2017-7827": {"epss_score": 0.02127, "epss_percentile": 0.83699}, "CVE-2017-7828": {"epss_score": 0.28905, "epss_percentile": 0.964}, "CVE-2017-7829": {"epss_score": 0.01597, "epss_percentile": 0.81243}, "CVE-2017-7830": {"epss_score": 0.00862, "epss_percentile": 0.74571}, "CVE-2017-7831": {"epss_score": 0.00331, "epss_percentile": 0.55539}, "CVE-2017-7832": {"epss_score": 0.00981, "epss_percentile": 0.76284}, "CVE-2017-7833": {"epss_score": 0.01072, "epss_percentile": 0.77278}, "CVE-2017-7834": {"epss_score": 0.00984, "epss_percentile": 0.7631}, "CVE-2017-7835": {"epss_score": 0.00662, "epss_percentile": 0.70592}, "CVE-2017-7836": {"epss_score": 0.00087, "epss_percentile": 0.2561}, "CVE-2017-7837": {"epss_score": 0.00981, "epss_percentile": 0.76284}, "CVE-2017-7838": {"epss_score": 0.01072, "epss_percentile": 0.77278}, "CVE-2017-7839": {"epss_score": 0.00633, "epss_percentile": 0.69759}, "CVE-2017-7840": {"epss_score": 0.00633, "epss_percentile": 0.69759}, "CVE-2017-7842": {"epss_score": 0.00362, "epss_percentile": 0.57791}, "CVE-2017-7843": {"epss_score": 0.01058, "epss_percentile": 0.77146}, "CVE-2017-7844": {"epss_score": 0.01268, "epss_percentile": 0.79034}, "CVE-2017-7845": {"epss_score": 0.00763, "epss_percentile": 0.72884}, "CVE-2017-7846": {"epss_score": 0.01283, "epss_percentile": 0.79164}, "CVE-2017-7847": {"epss_score": 0.00879, "epss_percentile": 0.74848}, "CVE-2017-7848": {"epss_score": 0.01887, "epss_percentile": 0.82714}, "CVE-2017-7849": {"epss_score": 0.00032, "epss_percentile": 0.08868}, "CVE-2017-7850": {"epss_score": 0.00028, "epss_percentile": 0.07504}, "CVE-2017-7851": {"epss_score": 0.00295, "epss_percentile": 0.52527}, "CVE-2017-7852": {"epss_score": 0.01001, "epss_percentile": 0.76501}, "CVE-2017-7853": {"epss_score": 0.00452, "epss_percentile": 0.63186}, "CVE-2017-7854": {"epss_score": 0.00256, "epss_percentile": 0.48776}, "CVE-2017-7855": {"epss_score": 0.00545, "epss_percentile": 0.67175}, "CVE-2017-7856": {"epss_score": 0.01783, "epss_percentile": 0.82249}, "CVE-2017-7857": {"epss_score": 0.02549, "epss_percentile": 0.8507}, "CVE-2017-7858": {"epss_score": 0.02409, "epss_percentile": 0.8466}, "CVE-2017-7859": {"epss_score": 0.00992, "epss_percentile": 0.76397}, "CVE-2017-7860": {"epss_score": 0.01644, "epss_percentile": 0.81524}, "CVE-2017-7861": {"epss_score": 0.01553, "epss_percentile": 0.80999}, "CVE-2017-7862": {"epss_score": 0.01662, "epss_percentile": 0.81635}, "CVE-2017-7863": {"epss_score": 0.01878, "epss_percentile": 0.82667}, "CVE-2017-7864": {"epss_score": 0.02062, "epss_percentile": 0.83447}, "CVE-2017-7865": {"epss_score": 0.01878, "epss_percentile": 0.82667}, "CVE-2017-7866": {"epss_score": 0.01644, "epss_percentile": 0.81524}, "CVE-2017-7867": {"epss_score": 0.01613, "epss_percentile": 0.8134}, "CVE-2017-7868": {"epss_score": 0.01545, "epss_percentile": 0.80964}, "CVE-2017-7869": {"epss_score": 0.00703, "epss_percentile": 0.7155}, "CVE-2017-7870": {"epss_score": 0.01349, "epss_percentile": 0.79667}, "CVE-2017-7871": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-7875": {"epss_score": 0.00738, "epss_percentile": 0.72343}, "CVE-2017-7876": {"epss_score": 0.06706, "epss_percentile": 0.90959}, "CVE-2017-7877": {"epss_score": 0.00269, "epss_percentile": 0.50186}, "CVE-2017-7878": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-7879": {"epss_score": 0.00233, "epss_percentile": 0.46061}, "CVE-2017-7881": {"epss_score": 0.00087, "epss_percentile": 0.25483}, "CVE-2017-7882": {"epss_score": 0.01219, "epss_percentile": 0.78617}, "CVE-2017-7884": {"epss_score": 0.00043, "epss_percentile": 0.13207}, "CVE-2017-7885": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2017-7886": {"epss_score": 0.00211, "epss_percentile": 0.43645}, "CVE-2017-7887": {"epss_score": 0.00187, "epss_percentile": 0.40801}, "CVE-2017-7888": {"epss_score": 0.00156, "epss_percentile": 0.36989}, "CVE-2017-7889": {"epss_score": 0.00033, "epss_percentile": 0.09377}, "CVE-2017-7890": {"epss_score": 0.19468, "epss_percentile": 0.95189}, "CVE-2017-7891": {"epss_score": 0.00246, "epss_percentile": 0.47777}, "CVE-2017-7892": {"epss_score": 0.00864, "epss_percentile": 0.74606}, "CVE-2017-7893": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2017-7894": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2017-7895": {"epss_score": 0.17417, "epss_percentile": 0.94848}, "CVE-2017-7896": {"epss_score": 0.53308, "epss_percentile": 0.9787}, "CVE-2017-7897": {"epss_score": 0.00251, "epss_percentile": 0.48301}, "CVE-2017-7898": {"epss_score": 0.01143, "epss_percentile": 0.77978}, "CVE-2017-7899": {"epss_score": 0.03537, "epss_percentile": 0.87313}, "CVE-2017-7901": {"epss_score": 0.00076, "epss_percentile": 0.23091}, "CVE-2017-7902": {"epss_score": 0.00043, "epss_percentile": 0.13336}, "CVE-2017-7903": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2017-7905": {"epss_score": 0.00196, "epss_percentile": 0.4173}, "CVE-2017-7906": {"epss_score": 0.00188, "epss_percentile": 0.40916}, "CVE-2017-7907": {"epss_score": 0.00081, "epss_percentile": 0.24396}, "CVE-2017-7908": {"epss_score": 0.00252, "epss_percentile": 0.48374}, "CVE-2017-7909": {"epss_score": 0.01603, "epss_percentile": 0.81277}, "CVE-2017-7910": {"epss_score": 0.0066, "epss_percentile": 0.7053}, "CVE-2017-7911": {"epss_score": 0.06585, "epss_percentile": 0.90866}, "CVE-2017-7912": {"epss_score": 0.00647, "epss_percentile": 0.70181}, "CVE-2017-7913": {"epss_score": 0.00223, "epss_percentile": 0.44945}, "CVE-2017-7914": {"epss_score": 0.12579, "epss_percentile": 0.9372}, "CVE-2017-7915": {"epss_score": 0.00311, "epss_percentile": 0.53829}, "CVE-2017-7916": {"epss_score": 0.00282, "epss_percentile": 0.5123}, "CVE-2017-7917": {"epss_score": 0.00103, "epss_percentile": 0.29053}, "CVE-2017-7918": {"epss_score": 0.42228, "epss_percentile": 0.97319}, "CVE-2017-7919": {"epss_score": 0.0125, "epss_percentile": 0.7889}, "CVE-2017-7920": {"epss_score": 0.01403, "epss_percentile": 0.80032}, "CVE-2017-7921": {"epss_score": 0.94097, "epss_percentile": 0.99902}, "CVE-2017-7922": {"epss_score": 0.38105, "epss_percentile": 0.97085}, "CVE-2017-7923": {"epss_score": 0.00897, "epss_percentile": 0.75136}, "CVE-2017-7924": {"epss_score": 0.09954, "epss_percentile": 0.92789}, "CVE-2017-7925": {"epss_score": 0.80551, "epss_percentile": 0.99094}, "CVE-2017-7926": {"epss_score": 0.00155, "epss_percentile": 0.36796}, "CVE-2017-7927": {"epss_score": 0.05184, "epss_percentile": 0.89585}, "CVE-2017-7928": {"epss_score": 0.00525, "epss_percentile": 0.66389}, "CVE-2017-7929": {"epss_score": 0.00762, "epss_percentile": 0.72838}, "CVE-2017-7930": {"epss_score": 0.00224, "epss_percentile": 0.4506}, "CVE-2017-7931": {"epss_score": 0.02162, "epss_percentile": 0.8383}, "CVE-2017-7932": {"epss_score": 0.00032, "epss_percentile": 0.09037}, "CVE-2017-7933": {"epss_score": 0.00368, "epss_percentile": 0.58168}, "CVE-2017-7934": {"epss_score": 0.00234, "epss_percentile": 0.46158}, "CVE-2017-7935": {"epss_score": 0.00229, "epss_percentile": 0.45555}, "CVE-2017-7936": {"epss_score": 0.00159, "epss_percentile": 0.37332}, "CVE-2017-7937": {"epss_score": 0.00153, "epss_percentile": 0.36525}, "CVE-2017-7938": {"epss_score": 0.01939, "epss_percentile": 0.82974}, "CVE-2017-7939": {"epss_score": 0.00207, "epss_percentile": 0.43182}, "CVE-2017-7940": {"epss_score": 0.00202, "epss_percentile": 0.42426}, "CVE-2017-7941": {"epss_score": 0.01082, "epss_percentile": 0.77385}, "CVE-2017-7942": {"epss_score": 0.00552, "epss_percentile": 0.67402}, "CVE-2017-7943": {"epss_score": 0.01082, "epss_percentile": 0.77385}, "CVE-2017-7944": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2017-7945": {"epss_score": 0.00437, "epss_percentile": 0.62525}, "CVE-2017-7946": {"epss_score": 0.00207, "epss_percentile": 0.43182}, "CVE-2017-7947": {"epss_score": 0.0029, "epss_percentile": 0.52123}, "CVE-2017-7948": {"epss_score": 0.00226, "epss_percentile": 0.45257}, "CVE-2017-7950": {"epss_score": 0.00094, "epss_percentile": 0.27064}, "CVE-2017-7951": {"epss_score": 0.00133, "epss_percentile": 0.33659}, "CVE-2017-7952": {"epss_score": 0.00193, "epss_percentile": 0.41377}, "CVE-2017-7953": {"epss_score": 0.002, "epss_percentile": 0.4222}, "CVE-2017-7957": {"epss_score": 0.02946, "epss_percentile": 0.8604}, "CVE-2017-7960": {"epss_score": 0.00533, "epss_percentile": 0.66763}, "CVE-2017-7961": {"epss_score": 0.0087, "epss_percentile": 0.74704}, "CVE-2017-7962": {"epss_score": 0.00501, "epss_percentile": 0.65344}, "CVE-2017-7963": {"epss_score": 0.00299, "epss_percentile": 0.52865}, "CVE-2017-7964": {"epss_score": 0.02707, "epss_percentile": 0.85469}, "CVE-2017-7965": {"epss_score": 0.00083, "epss_percentile": 0.24825}, "CVE-2017-7966": {"epss_score": 0.00975, "epss_percentile": 0.76202}, "CVE-2017-7967": {"epss_score": 0.00059, "epss_percentile": 0.18836}, "CVE-2017-7968": {"epss_score": 0.0004, "epss_percentile": 0.1215}, "CVE-2017-7969": {"epss_score": 0.00134, "epss_percentile": 0.33905}, "CVE-2017-7970": {"epss_score": 0.00124, "epss_percentile": 0.32446}, "CVE-2017-7971": {"epss_score": 0.00126, "epss_percentile": 0.32727}, "CVE-2017-7972": {"epss_score": 0.00133, "epss_percentile": 0.33718}, "CVE-2017-7973": {"epss_score": 0.00336, "epss_percentile": 0.55939}, "CVE-2017-7974": {"epss_score": 0.07797, "epss_percentile": 0.91686}, "CVE-2017-7975": {"epss_score": 0.00267, "epss_percentile": 0.49986}, "CVE-2017-7976": {"epss_score": 0.00292, "epss_percentile": 0.52233}, "CVE-2017-7977": {"epss_score": 0.01472, "epss_percentile": 0.8051}, "CVE-2017-7978": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2017-7979": {"epss_score": 0.00044, "epss_percentile": 0.1363}, "CVE-2017-7980": {"epss_score": 0.00166, "epss_percentile": 0.38249}, "CVE-2017-7981": {"epss_score": 0.13322, "epss_percentile": 0.93933}, "CVE-2017-7982": {"epss_score": 0.00402, "epss_percentile": 0.60314}, "CVE-2017-7983": {"epss_score": 8e-05, "epss_percentile": 0.00585}, "CVE-2017-7984": {"epss_score": 0.0001, "epss_percentile": 0.00908}, "CVE-2017-7985": {"epss_score": 0.00065, "epss_percentile": 0.20504}, "CVE-2017-7986": {"epss_score": 0.0001, "epss_percentile": 0.00908}, "CVE-2017-7987": {"epss_score": 0.0001, "epss_percentile": 0.00908}, "CVE-2017-7988": {"epss_score": 6e-05, "epss_percentile": 0.00307}, "CVE-2017-7989": {"epss_score": 6e-05, "epss_percentile": 0.00273}, "CVE-2017-7990": {"epss_score": 0.00115, "epss_percentile": 0.30902}, "CVE-2017-7991": {"epss_score": 0.01354, "epss_percentile": 0.79698}, "CVE-2017-7992": {"epss_score": 0.00233, "epss_percentile": 0.45977}, "CVE-2017-7994": {"epss_score": 0.00648, "epss_percentile": 0.70223}, "CVE-2017-7995": {"epss_score": 0.00099, "epss_percentile": 0.28309}, "CVE-2017-7997": {"epss_score": 0.12941, "epss_percentile": 0.93823}, "CVE-2017-7998": {"epss_score": 0.02398, "epss_percentile": 0.84624}, "CVE-2017-7999": {"epss_score": 0.00482, "epss_percentile": 0.64542}, "CVE-2017-8000": {"epss_score": 0.00254, "epss_percentile": 0.48539}, "CVE-2017-8001": {"epss_score": 0.00081, "epss_percentile": 0.24313}, "CVE-2017-8002": {"epss_score": 0.02328, "epss_percentile": 0.84396}, "CVE-2017-8003": {"epss_score": 0.00693, "epss_percentile": 0.71324}, "CVE-2017-8004": {"epss_score": 0.00889, "epss_percentile": 0.7502}, "CVE-2017-8005": {"epss_score": 0.00193, "epss_percentile": 0.41387}, "CVE-2017-8006": {"epss_score": 0.00972, "epss_percentile": 0.76143}, "CVE-2017-8007": {"epss_score": 0.01645, "epss_percentile": 0.81528}, "CVE-2017-8011": {"epss_score": 0.15648, "epss_percentile": 0.94474}, "CVE-2017-8012": {"epss_score": 0.0069, "epss_percentile": 0.71241}, "CVE-2017-8013": {"epss_score": 0.01305, "epss_percentile": 0.79324}, "CVE-2017-8015": {"epss_score": 0.00572, "epss_percentile": 0.68005}, "CVE-2017-8016": {"epss_score": 0.0028, "epss_percentile": 0.51068}, "CVE-2017-8017": {"epss_score": 0.00285, "epss_percentile": 0.51547}, "CVE-2017-8018": {"epss_score": 0.00729, "epss_percentile": 0.72117}, "CVE-2017-8019": {"epss_score": 0.0275, "epss_percentile": 0.8558}, "CVE-2017-8020": {"epss_score": 0.0859, "epss_percentile": 0.92138}, "CVE-2017-8021": {"epss_score": 0.00953, "epss_percentile": 0.75893}, "CVE-2017-8022": {"epss_score": 0.0182, "epss_percentile": 0.82408}, "CVE-2017-8023": {"epss_score": 0.17989, "epss_percentile": 0.94938}, "CVE-2017-8024": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-8025": {"epss_score": 0.00761, "epss_percentile": 0.72825}, "CVE-2017-8028": {"epss_score": 0.01283, "epss_percentile": 0.79158}, "CVE-2017-8031": {"epss_score": 0.00419, "epss_percentile": 0.61359}, "CVE-2017-8032": {"epss_score": 0.00265, "epss_percentile": 0.49802}, "CVE-2017-8033": {"epss_score": 0.00211, "epss_percentile": 0.43719}, "CVE-2017-8034": {"epss_score": 0.00472, "epss_percentile": 0.64047}, "CVE-2017-8035": {"epss_score": 0.00381, "epss_percentile": 0.59012}, "CVE-2017-8036": {"epss_score": 0.00457, "epss_percentile": 0.63379}, "CVE-2017-8037": {"epss_score": 0.00381, "epss_percentile": 0.59012}, "CVE-2017-8038": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2017-8039": {"epss_score": 0.00183, "epss_percentile": 0.40294}, "CVE-2017-8040": {"epss_score": 0.00129, "epss_percentile": 0.33123}, "CVE-2017-8041": {"epss_score": 0.00197, "epss_percentile": 0.41963}, "CVE-2017-8044": {"epss_score": 0.00197, "epss_percentile": 0.41963}, "CVE-2017-8045": {"epss_score": 0.02827, "epss_percentile": 0.85766}, "CVE-2017-8046": {"epss_score": 0.93978, "epss_percentile": 0.99878}, "CVE-2017-8047": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2017-8048": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2017-8050": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2017-8051": {"epss_score": 0.53063, "epss_percentile": 0.97854}, "CVE-2017-8052": {"epss_score": 0.00353, "epss_percentile": 0.57157}, "CVE-2017-8053": {"epss_score": 0.00349, "epss_percentile": 0.56854}, "CVE-2017-8054": {"epss_score": 0.00421, "epss_percentile": 0.61465}, "CVE-2017-8055": {"epss_score": 0.00292, "epss_percentile": 0.52275}, "CVE-2017-8056": {"epss_score": 0.16308, "epss_percentile": 0.94615}, "CVE-2017-8057": {"epss_score": 8e-05, "epss_percentile": 0.00585}, "CVE-2017-8058": {"epss_score": 0.00115, "epss_percentile": 0.31008}, "CVE-2017-8059": {"epss_score": 0.00011, "epss_percentile": 0.0102}, "CVE-2017-8060": {"epss_score": 0.00115, "epss_percentile": 0.31008}, "CVE-2017-8061": {"epss_score": 0.00046, "epss_percentile": 0.14389}, "CVE-2017-8062": {"epss_score": 0.00119, "epss_percentile": 0.31554}, "CVE-2017-8063": {"epss_score": 0.00108, "epss_percentile": 0.29861}, "CVE-2017-8064": {"epss_score": 0.00086, "epss_percentile": 0.25357}, "CVE-2017-8065": {"epss_score": 0.00062, "epss_percentile": 0.1968}, "CVE-2017-8066": {"epss_score": 0.00046, "epss_percentile": 0.14389}, "CVE-2017-8067": {"epss_score": 0.00113, "epss_percentile": 0.30675}, "CVE-2017-8068": {"epss_score": 0.00043, "epss_percentile": 0.13266}, "CVE-2017-8069": {"epss_score": 0.00119, "epss_percentile": 0.31554}, "CVE-2017-8070": {"epss_score": 0.00111, "epss_percentile": 0.30322}, "CVE-2017-8071": {"epss_score": 0.00099, "epss_percentile": 0.28314}, "CVE-2017-8072": {"epss_score": 0.00101, "epss_percentile": 0.28579}, "CVE-2017-8073": {"epss_score": 0.01643, "epss_percentile": 0.81515}, "CVE-2017-8074": {"epss_score": 0.01353, "epss_percentile": 0.79697}, "CVE-2017-8075": {"epss_score": 0.01897, "epss_percentile": 0.82757}, "CVE-2017-8076": {"epss_score": 0.0042, "epss_percentile": 0.61444}, "CVE-2017-8077": {"epss_score": 0.00437, "epss_percentile": 0.62536}, "CVE-2017-8078": {"epss_score": 0.00345, "epss_percentile": 0.56596}, "CVE-2017-8080": {"epss_score": 0.01598, "epss_percentile": 0.81247}, "CVE-2017-8081": {"epss_score": 0.00351, "epss_percentile": 0.56982}, "CVE-2017-8082": {"epss_score": 0.00528, "epss_percentile": 0.66566}, "CVE-2017-8083": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2017-8085": {"epss_score": 0.00368, "epss_percentile": 0.58195}, "CVE-2017-8086": {"epss_score": 0.00076, "epss_percentile": 0.23218}, "CVE-2017-8087": {"epss_score": 0.00152, "epss_percentile": 0.36502}, "CVE-2017-8098": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2017-8099": {"epss_score": 0.00175, "epss_percentile": 0.39293}, "CVE-2017-8100": {"epss_score": 0.00349, "epss_percentile": 0.56852}, "CVE-2017-8101": {"epss_score": 0.00121, "epss_percentile": 0.31919}, "CVE-2017-8102": {"epss_score": 0.00185, "epss_percentile": 0.40464}, "CVE-2017-8103": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2017-8104": {"epss_score": 0.0134, "epss_percentile": 0.79582}, "CVE-2017-8105": {"epss_score": 0.00966, "epss_percentile": 0.76062}, "CVE-2017-8106": {"epss_score": 0.00038, "epss_percentile": 0.11416}, "CVE-2017-8108": {"epss_score": 0.00065, "epss_percentile": 0.20622}, "CVE-2017-8109": {"epss_score": 0.00047, "epss_percentile": 0.14668}, "CVE-2017-8110": {"epss_score": 0.00345, "epss_percentile": 0.56559}, "CVE-2017-8112": {"epss_score": 0.00056, "epss_percentile": 0.17847}, "CVE-2017-8114": {"epss_score": 0.00632, "epss_percentile": 0.69741}, "CVE-2017-8115": {"epss_score": 0.00144, "epss_percentile": 0.35269}, "CVE-2017-8116": {"epss_score": 0.07455, "epss_percentile": 0.91481}, "CVE-2017-8117": {"epss_score": 0.00224, "epss_percentile": 0.44973}, "CVE-2017-8118": {"epss_score": 0.00028, "epss_percentile": 0.07293}, "CVE-2017-8119": {"epss_score": 0.00224, "epss_percentile": 0.44973}, "CVE-2017-8120": {"epss_score": 0.00224, "epss_percentile": 0.44973}, "CVE-2017-8121": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2017-8122": {"epss_score": 0.00256, "epss_percentile": 0.48793}, "CVE-2017-8123": {"epss_score": 0.00224, "epss_percentile": 0.44973}, "CVE-2017-8124": {"epss_score": 0.00224, "epss_percentile": 0.44973}, "CVE-2017-8125": {"epss_score": 0.00124, "epss_percentile": 0.32411}, "CVE-2017-8126": {"epss_score": 0.00224, "epss_percentile": 0.44973}, "CVE-2017-8127": {"epss_score": 0.00124, "epss_percentile": 0.32411}, "CVE-2017-8128": {"epss_score": 0.0023, "epss_percentile": 0.45689}, "CVE-2017-8129": {"epss_score": 0.0023, "epss_percentile": 0.45689}, "CVE-2017-8130": {"epss_score": 0.0017, "epss_percentile": 0.38763}, "CVE-2017-8131": {"epss_score": 0.00303, "epss_percentile": 0.53171}, "CVE-2017-8132": {"epss_score": 0.00303, "epss_percentile": 0.53171}, "CVE-2017-8133": {"epss_score": 0.01137, "epss_percentile": 0.77924}, "CVE-2017-8134": {"epss_score": 0.00303, "epss_percentile": 0.53171}, "CVE-2017-8135": {"epss_score": 0.00532, "epss_percentile": 0.66703}, "CVE-2017-8136": {"epss_score": 0.00088, "epss_percentile": 0.25786}, "CVE-2017-8137": {"epss_score": 0.00057, "epss_percentile": 0.18083}, "CVE-2017-8138": {"epss_score": 0.00062, "epss_percentile": 0.19701}, "CVE-2017-8139": {"epss_score": 0.00115, "epss_percentile": 0.31023}, "CVE-2017-8140": {"epss_score": 0.00114, "epss_percentile": 0.30859}, "CVE-2017-8141": {"epss_score": 0.00114, "epss_percentile": 0.30859}, "CVE-2017-8142": {"epss_score": 0.00201, "epss_percentile": 0.42359}, "CVE-2017-8143": {"epss_score": 0.00061, "epss_percentile": 0.19447}, "CVE-2017-8144": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2017-8145": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2017-8146": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2017-8147": {"epss_score": 0.0016, "epss_percentile": 0.37518}, "CVE-2017-8148": {"epss_score": 0.00054, "epss_percentile": 0.17069}, "CVE-2017-8149": {"epss_score": 0.00063, "epss_percentile": 0.19809}, "CVE-2017-8150": {"epss_score": 0.00097, "epss_percentile": 0.27584}, "CVE-2017-8151": {"epss_score": 0.00023, "epss_percentile": 0.05437}, "CVE-2017-8152": {"epss_score": 0.00032, "epss_percentile": 0.09073}, "CVE-2017-8153": {"epss_score": 0.00085, "epss_percentile": 0.25096}, "CVE-2017-8154": {"epss_score": 0.00056, "epss_percentile": 0.17713}, "CVE-2017-8155": {"epss_score": 0.00023, "epss_percentile": 0.05437}, "CVE-2017-8156": {"epss_score": 0.00023, "epss_percentile": 0.05437}, "CVE-2017-8157": {"epss_score": 0.00091, "epss_percentile": 0.26212}, "CVE-2017-8158": {"epss_score": 0.00018, "epss_percentile": 0.03982}, "CVE-2017-8159": {"epss_score": 0.00207, "epss_percentile": 0.43091}, "CVE-2017-8160": {"epss_score": 0.00201, "epss_percentile": 0.42359}, "CVE-2017-8161": {"epss_score": 0.00027, "epss_percentile": 0.07205}, "CVE-2017-8162": {"epss_score": 0.00314, "epss_percentile": 0.54079}, "CVE-2017-8163": {"epss_score": 0.00181, "epss_percentile": 0.40086}, "CVE-2017-8164": {"epss_score": 0.00083, "epss_percentile": 0.24719}, "CVE-2017-8165": {"epss_score": 0.00106, "epss_percentile": 0.29423}, "CVE-2017-8166": {"epss_score": 0.00022, "epss_percentile": 0.05155}, "CVE-2017-8167": {"epss_score": 0.00281, "epss_percentile": 0.51134}, "CVE-2017-8168": {"epss_score": 0.00022, "epss_percentile": 0.05302}, "CVE-2017-8169": {"epss_score": 0.00177, "epss_percentile": 0.39546}, "CVE-2017-8170": {"epss_score": 0.00177, "epss_percentile": 0.39546}, "CVE-2017-8171": {"epss_score": 0.00027, "epss_percentile": 0.07205}, "CVE-2017-8172": {"epss_score": 0.00061, "epss_percentile": 0.19447}, "CVE-2017-8173": {"epss_score": 0.00023, "epss_percentile": 0.0542}, "CVE-2017-8174": {"epss_score": 0.00067, "epss_percentile": 0.21036}, "CVE-2017-8175": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2017-8176": {"epss_score": 0.00177, "epss_percentile": 0.39596}, "CVE-2017-8177": {"epss_score": 0.00053, "epss_percentile": 0.16732}, "CVE-2017-8178": {"epss_score": 0.00164, "epss_percentile": 0.37955}, "CVE-2017-8179": {"epss_score": 0.00114, "epss_percentile": 0.30788}, "CVE-2017-8180": {"epss_score": 0.00131, "epss_percentile": 0.33357}, "CVE-2017-8181": {"epss_score": 0.00101, "epss_percentile": 0.28695}, "CVE-2017-8182": {"epss_score": 0.00079, "epss_percentile": 0.23948}, "CVE-2017-8183": {"epss_score": 0.00106, "epss_percentile": 0.29423}, "CVE-2017-8184": {"epss_score": 0.00106, "epss_percentile": 0.29423}, "CVE-2017-8185": {"epss_score": 0.00023, "epss_percentile": 0.0564}, "CVE-2017-8186": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2017-8187": {"epss_score": 0.0008, "epss_percentile": 0.24189}, "CVE-2017-8188": {"epss_score": 0.00541, "epss_percentile": 0.67042}, "CVE-2017-8189": {"epss_score": 0.00026, "epss_percentile": 0.06571}, "CVE-2017-8190": {"epss_score": 0.00012, "epss_percentile": 0.0139}, "CVE-2017-8191": {"epss_score": 0.00067, "epss_percentile": 0.21036}, "CVE-2017-8192": {"epss_score": 0.00023, "epss_percentile": 0.05509}, "CVE-2017-8193": {"epss_score": 0.00438, "epss_percentile": 0.62566}, "CVE-2017-8194": {"epss_score": 0.00366, "epss_percentile": 0.58015}, "CVE-2017-8195": {"epss_score": 0.00303, "epss_percentile": 0.53229}, "CVE-2017-8196": {"epss_score": 0.00014, "epss_percentile": 0.01831}, "CVE-2017-8197": {"epss_score": 0.01912, "epss_percentile": 0.82836}, "CVE-2017-8198": {"epss_score": 0.00224, "epss_percentile": 0.44977}, "CVE-2017-8199": {"epss_score": 0.00233, "epss_percentile": 0.4601}, "CVE-2017-8200": {"epss_score": 0.00233, "epss_percentile": 0.4601}, "CVE-2017-8201": {"epss_score": 0.00233, "epss_percentile": 0.4601}, "CVE-2017-8202": {"epss_score": 0.00066, "epss_percentile": 0.20823}, "CVE-2017-8203": {"epss_score": 0.00257, "epss_percentile": 0.48914}, "CVE-2017-8204": {"epss_score": 0.0017, "epss_percentile": 0.38679}, "CVE-2017-8205": {"epss_score": 0.00087, "epss_percentile": 0.25573}, "CVE-2017-8206": {"epss_score": 0.00022, "epss_percentile": 0.05155}, "CVE-2017-8207": {"epss_score": 0.00177, "epss_percentile": 0.39546}, "CVE-2017-8208": {"epss_score": 0.00177, "epss_percentile": 0.39546}, "CVE-2017-8209": {"epss_score": 0.00177, "epss_percentile": 0.39546}, "CVE-2017-8210": {"epss_score": 0.00177, "epss_percentile": 0.39546}, "CVE-2017-8211": {"epss_score": 0.00177, "epss_percentile": 0.39546}, "CVE-2017-8212": {"epss_score": 0.00177, "epss_percentile": 0.39546}, "CVE-2017-8213": {"epss_score": 0.00171, "epss_percentile": 0.38811}, "CVE-2017-8214": {"epss_score": 0.00016, "epss_percentile": 0.02919}, "CVE-2017-8215": {"epss_score": 0.00019, "epss_percentile": 0.04268}, "CVE-2017-8216": {"epss_score": 0.00086, "epss_percentile": 0.25404}, "CVE-2017-8217": {"epss_score": 0.00246, "epss_percentile": 0.47735}, "CVE-2017-8218": {"epss_score": 0.009, "epss_percentile": 0.75158}, "CVE-2017-8219": {"epss_score": 0.00267, "epss_percentile": 0.50007}, "CVE-2017-8220": {"epss_score": 0.03779, "epss_percentile": 0.87713}, "CVE-2017-8221": {"epss_score": 0.19067, "epss_percentile": 0.9512}, "CVE-2017-8222": {"epss_score": 0.07265, "epss_percentile": 0.91359}, "CVE-2017-8223": {"epss_score": 0.18038, "epss_percentile": 0.94948}, "CVE-2017-8224": {"epss_score": 0.1191, "epss_percentile": 0.93512}, "CVE-2017-8225": {"epss_score": 0.70891, "epss_percentile": 0.98646}, "CVE-2017-8226": {"epss_score": 0.01151, "epss_percentile": 0.78038}, "CVE-2017-8227": {"epss_score": 0.03777, "epss_percentile": 0.8771}, "CVE-2017-8228": {"epss_score": 0.02333, "epss_percentile": 0.84411}, "CVE-2017-8229": {"epss_score": 0.92899, "epss_percentile": 0.99758}, "CVE-2017-8230": {"epss_score": 0.00503, "epss_percentile": 0.65447}, "CVE-2017-8233": {"epss_score": 0.00044, "epss_percentile": 0.13653}, "CVE-2017-8234": {"epss_score": 0.00044, "epss_percentile": 0.13653}, "CVE-2017-8235": {"epss_score": 0.00062, "epss_percentile": 0.19684}, "CVE-2017-8236": {"epss_score": 0.00048, "epss_percentile": 0.15054}, "CVE-2017-8237": {"epss_score": 0.00048, "epss_percentile": 0.15054}, "CVE-2017-8238": {"epss_score": 0.00048, "epss_percentile": 0.15054}, "CVE-2017-8239": {"epss_score": 0.00125, "epss_percentile": 0.32563}, "CVE-2017-8240": {"epss_score": 0.00075, "epss_percentile": 0.22914}, "CVE-2017-8241": {"epss_score": 0.00046, "epss_percentile": 0.14395}, "CVE-2017-8242": {"epss_score": 0.00085, "epss_percentile": 0.25159}, "CVE-2017-8243": {"epss_score": 0.00038, "epss_percentile": 0.11272}, "CVE-2017-8244": {"epss_score": 0.00031, "epss_percentile": 0.08322}, "CVE-2017-8245": {"epss_score": 0.00041, "epss_percentile": 0.12242}, "CVE-2017-8246": {"epss_score": 0.00032, "epss_percentile": 0.08761}, "CVE-2017-8247": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-8248": {"epss_score": 0.02376, "epss_percentile": 0.84544}, "CVE-2017-8250": {"epss_score": 0.00057, "epss_percentile": 0.18221}, "CVE-2017-8251": {"epss_score": 0.00057, "epss_percentile": 0.18221}, "CVE-2017-8252": {"epss_score": 0.0004, "epss_percentile": 0.11909}, "CVE-2017-8253": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-8254": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2017-8255": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-8256": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-8257": {"epss_score": 0.00041, "epss_percentile": 0.12398}, "CVE-2017-8258": {"epss_score": 0.00063, "epss_percentile": 0.19973}, "CVE-2017-8259": {"epss_score": 0.00083, "epss_percentile": 0.2464}, "CVE-2017-8260": {"epss_score": 0.00233, "epss_percentile": 0.46024}, "CVE-2017-8261": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-8262": {"epss_score": 0.00068, "epss_percentile": 0.21316}, "CVE-2017-8263": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-8264": {"epss_score": 0.0005, "epss_percentile": 0.15756}, "CVE-2017-8265": {"epss_score": 0.00041, "epss_percentile": 0.12398}, "CVE-2017-8266": {"epss_score": 0.00048, "epss_percentile": 0.15253}, "CVE-2017-8267": {"epss_score": 0.00068, "epss_percentile": 0.21316}, "CVE-2017-8268": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-8269": {"epss_score": 0.00109, "epss_percentile": 0.29995}, "CVE-2017-8270": {"epss_score": 0.00048, "epss_percentile": 0.15253}, "CVE-2017-8271": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-8272": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-8273": {"epss_score": 0.00057, "epss_percentile": 0.18221}, "CVE-2017-8274": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2017-8275": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2017-8276": {"epss_score": 0.00042, "epss_percentile": 0.12769}, "CVE-2017-8277": {"epss_score": 0.00062, "epss_percentile": 0.19786}, "CVE-2017-8278": {"epss_score": 0.00038, "epss_percentile": 0.11272}, "CVE-2017-8279": {"epss_score": 0.0009, "epss_percentile": 0.26163}, "CVE-2017-8280": {"epss_score": 0.00045, "epss_percentile": 0.13686}, "CVE-2017-8281": {"epss_score": 0.00084, "epss_percentile": 0.25012}, "CVE-2017-8282": {"epss_score": 0.00628, "epss_percentile": 0.69663}, "CVE-2017-8283": {"epss_score": 0.01076, "epss_percentile": 0.77323}, "CVE-2017-8284": {"epss_score": 0.00108, "epss_percentile": 0.29816}, "CVE-2017-8287": {"epss_score": 0.00495, "epss_percentile": 0.65113}, "CVE-2017-8288": {"epss_score": 0.00309, "epss_percentile": 0.53668}, "CVE-2017-8289": {"epss_score": 0.0061, "epss_percentile": 0.6915}, "CVE-2017-8290": {"epss_score": 0.00448, "epss_percentile": 0.62999}, "CVE-2017-8291": {"epss_score": 0.92862, "epss_percentile": 0.99756}, "CVE-2017-8294": {"epss_score": 0.00514, "epss_percentile": 0.65947}, "CVE-2017-8295": {"epss_score": 0.67424, "epss_percentile": 0.98506}, "CVE-2017-8296": {"epss_score": 0.00273, "epss_percentile": 0.50464}, "CVE-2017-8297": {"epss_score": 0.015, "epss_percentile": 0.80713}, "CVE-2017-8298": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2017-8301": {"epss_score": 0.00207, "epss_percentile": 0.43205}, "CVE-2017-8302": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-8303": {"epss_score": 0.03197, "epss_percentile": 0.86614}, "CVE-2017-8304": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-8305": {"epss_score": 0.00621, "epss_percentile": 0.6948}, "CVE-2017-8307": {"epss_score": 0.00986, "epss_percentile": 0.76333}, "CVE-2017-8308": {"epss_score": 0.00685, "epss_percentile": 0.71151}, "CVE-2017-8309": {"epss_score": 0.01768, "epss_percentile": 0.82182}, "CVE-2017-8310": {"epss_score": 0.00183, "epss_percentile": 0.40299}, "CVE-2017-8311": {"epss_score": 0.09953, "epss_percentile": 0.92788}, "CVE-2017-8312": {"epss_score": 0.00338, "epss_percentile": 0.56113}, "CVE-2017-8313": {"epss_score": 0.00323, "epss_percentile": 0.54923}, "CVE-2017-8314": {"epss_score": 0.0692, "epss_percentile": 0.91117}, "CVE-2017-8315": {"epss_score": 0.00658, "epss_percentile": 0.70478}, "CVE-2017-8316": {"epss_score": 6e-05, "epss_percentile": 0.00302}, "CVE-2017-8325": {"epss_score": 0.00968, "epss_percentile": 0.76083}, "CVE-2017-8326": {"epss_score": 0.00888, "epss_percentile": 0.74995}, "CVE-2017-8327": {"epss_score": 0.0047, "epss_percentile": 0.63961}, "CVE-2017-8328": {"epss_score": 0.00253, "epss_percentile": 0.48472}, "CVE-2017-8329": {"epss_score": 0.00595, "epss_percentile": 0.68685}, "CVE-2017-8330": {"epss_score": 0.00742, "epss_percentile": 0.72452}, "CVE-2017-8331": {"epss_score": 0.03517, "epss_percentile": 0.87276}, "CVE-2017-8332": {"epss_score": 0.00574, "epss_percentile": 0.68073}, "CVE-2017-8333": {"epss_score": 0.04126, "epss_percentile": 0.8829}, "CVE-2017-8334": {"epss_score": 0.00243, "epss_percentile": 0.47471}, "CVE-2017-8335": {"epss_score": 0.00488, "epss_percentile": 0.64866}, "CVE-2017-8336": {"epss_score": 0.01959, "epss_percentile": 0.8305}, "CVE-2017-8337": {"epss_score": 0.02333, "epss_percentile": 0.84411}, "CVE-2017-8338": {"epss_score": 0.02883, "epss_percentile": 0.85906}, "CVE-2017-8339": {"epss_score": 0.00148, "epss_percentile": 0.35897}, "CVE-2017-8340": {"epss_score": 0.0046, "epss_percentile": 0.63503}, "CVE-2017-8341": {"epss_score": 0.00289, "epss_percentile": 0.52015}, "CVE-2017-8342": {"epss_score": 0.00726, "epss_percentile": 0.7208}, "CVE-2017-8343": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8344": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8345": {"epss_score": 0.00962, "epss_percentile": 0.75997}, "CVE-2017-8346": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8347": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8348": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8349": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8350": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8351": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8352": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8353": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8354": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8355": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8356": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8357": {"epss_score": 0.00657, "epss_percentile": 0.70467}, "CVE-2017-8358": {"epss_score": 0.00508, "epss_percentile": 0.65683}, "CVE-2017-8359": {"epss_score": 0.01818, "epss_percentile": 0.82399}, "CVE-2017-8360": {"epss_score": 0.00201, "epss_percentile": 0.42355}, "CVE-2017-8361": {"epss_score": 0.01535, "epss_percentile": 0.80909}, "CVE-2017-8362": {"epss_score": 0.01336, "epss_percentile": 0.79552}, "CVE-2017-8363": {"epss_score": 0.01328, "epss_percentile": 0.79494}, "CVE-2017-8364": {"epss_score": 0.00261, "epss_percentile": 0.49246}, "CVE-2017-8365": {"epss_score": 0.01328, "epss_percentile": 0.79494}, "CVE-2017-8366": {"epss_score": 0.00601, "epss_percentile": 0.68844}, "CVE-2017-8367": {"epss_score": 0.00107, "epss_percentile": 0.29737}, "CVE-2017-8368": {"epss_score": 0.00189, "epss_percentile": 0.40928}, "CVE-2017-8369": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2017-8370": {"epss_score": 0.01657, "epss_percentile": 0.81605}, "CVE-2017-8371": {"epss_score": 0.00179, "epss_percentile": 0.39774}, "CVE-2017-8372": {"epss_score": 0.00381, "epss_percentile": 0.58988}, "CVE-2017-8373": {"epss_score": 0.00342, "epss_percentile": 0.5636}, "CVE-2017-8374": {"epss_score": 0.00208, "epss_percentile": 0.43307}, "CVE-2017-8376": {"epss_score": 0.0032, "epss_percentile": 0.54608}, "CVE-2017-8377": {"epss_score": 0.00451, "epss_percentile": 0.6313}, "CVE-2017-8378": {"epss_score": 0.00743, "epss_percentile": 0.72497}, "CVE-2017-8379": {"epss_score": 0.00143, "epss_percentile": 0.35119}, "CVE-2017-8380": {"epss_score": 0.02849, "epss_percentile": 0.85827}, "CVE-2017-8381": {"epss_score": 0.00628, "epss_percentile": 0.69663}, "CVE-2017-8382": {"epss_score": 0.00645, "epss_percentile": 0.70122}, "CVE-2017-8383": {"epss_score": 0.00316, "epss_percentile": 0.54278}, "CVE-2017-8384": {"epss_score": 0.00307, "epss_percentile": 0.5352}, "CVE-2017-8385": {"epss_score": 0.00284, "epss_percentile": 0.51474}, "CVE-2017-8386": {"epss_score": 0.72255, "epss_percentile": 0.98701}, "CVE-2017-8387": {"epss_score": 0.00404, "epss_percentile": 0.60432}, "CVE-2017-8388": {"epss_score": 0.00429, "epss_percentile": 0.61992}, "CVE-2017-8390": {"epss_score": 0.14681, "epss_percentile": 0.94262}, "CVE-2017-8391": {"epss_score": 0.00047, "epss_percentile": 0.14886}, "CVE-2017-8392": {"epss_score": 0.00442, "epss_percentile": 0.62741}, "CVE-2017-8393": {"epss_score": 0.0038, "epss_percentile": 0.58913}, "CVE-2017-8394": {"epss_score": 0.00381, "epss_percentile": 0.58992}, "CVE-2017-8395": {"epss_score": 0.00472, "epss_percentile": 0.64054}, "CVE-2017-8396": {"epss_score": 0.0038, "epss_percentile": 0.58913}, "CVE-2017-8397": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2017-8398": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2017-8399": {"epss_score": 0.02737, "epss_percentile": 0.85551}, "CVE-2017-8400": {"epss_score": 0.00675, "epss_percentile": 0.70912}, "CVE-2017-8401": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2017-8402": {"epss_score": 0.00636, "epss_percentile": 0.69833}, "CVE-2017-8403": {"epss_score": 0.00114, "epss_percentile": 0.30838}, "CVE-2017-8404": {"epss_score": 0.24538, "epss_percentile": 0.95931}, "CVE-2017-8405": {"epss_score": 0.03929, "epss_percentile": 0.8797}, "CVE-2017-8406": {"epss_score": 0.0175, "epss_percentile": 0.82096}, "CVE-2017-8407": {"epss_score": 0.0175, "epss_percentile": 0.82096}, "CVE-2017-8408": {"epss_score": 0.2017, "epss_percentile": 0.95297}, "CVE-2017-8409": {"epss_score": 0.04034, "epss_percentile": 0.88154}, "CVE-2017-8410": {"epss_score": 0.04109, "epss_percentile": 0.88269}, "CVE-2017-8411": {"epss_score": 0.10416, "epss_percentile": 0.92981}, "CVE-2017-8412": {"epss_score": 0.01506, "epss_percentile": 0.80747}, "CVE-2017-8413": {"epss_score": 0.01761, "epss_percentile": 0.82151}, "CVE-2017-8414": {"epss_score": 0.00184, "epss_percentile": 0.4039}, "CVE-2017-8415": {"epss_score": 0.03096, "epss_percentile": 0.86404}, "CVE-2017-8416": {"epss_score": 0.00536, "epss_percentile": 0.66884}, "CVE-2017-8417": {"epss_score": 0.05255, "epss_percentile": 0.89666}, "CVE-2017-8418": {"epss_score": 0.00063, "epss_percentile": 0.19938}, "CVE-2017-8419": {"epss_score": 0.00956, "epss_percentile": 0.75926}, "CVE-2017-8420": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2017-8421": {"epss_score": 0.00087, "epss_percentile": 0.25453}, "CVE-2017-8422": {"epss_score": 0.00373, "epss_percentile": 0.58525}, "CVE-2017-8438": {"epss_score": 0.00411, "epss_percentile": 0.60904}, "CVE-2017-8439": {"epss_score": 0.00335, "epss_percentile": 0.55834}, "CVE-2017-8440": {"epss_score": 0.00335, "epss_percentile": 0.55834}, "CVE-2017-8441": {"epss_score": 0.00133, "epss_percentile": 0.33692}, "CVE-2017-8442": {"epss_score": 0.00427, "epss_percentile": 0.61902}, "CVE-2017-8443": {"epss_score": 0.00353, "epss_percentile": 0.57179}, "CVE-2017-8444": {"epss_score": 0.00121, "epss_percentile": 0.3201}, "CVE-2017-8445": {"epss_score": 0.00027, "epss_percentile": 0.06981}, "CVE-2017-8446": {"epss_score": 0.00145, "epss_percentile": 0.35372}, "CVE-2017-8447": {"epss_score": 0.00111, "epss_percentile": 0.30264}, "CVE-2017-8448": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2017-8449": {"epss_score": 0.00262, "epss_percentile": 0.49345}, "CVE-2017-8450": {"epss_score": 0.00249, "epss_percentile": 0.48054}, "CVE-2017-8451": {"epss_score": 0.00296, "epss_percentile": 0.52584}, "CVE-2017-8452": {"epss_score": 0.00381, "epss_percentile": 0.58999}, "CVE-2017-8453": {"epss_score": 0.00892, "epss_percentile": 0.75063}, "CVE-2017-8454": {"epss_score": 0.00892, "epss_percentile": 0.75063}, "CVE-2017-8455": {"epss_score": 0.00377, "epss_percentile": 0.58731}, "CVE-2017-8458": {"epss_score": 0.00448, "epss_percentile": 0.63014}, "CVE-2017-8459": {"epss_score": 0.00137, "epss_percentile": 0.34232}, "CVE-2017-8460": {"epss_score": 0.01927, "epss_percentile": 0.82928}, "CVE-2017-8461": {"epss_score": 0.08421, "epss_percentile": 0.92044}, "CVE-2017-8462": {"epss_score": 0.14765, "epss_percentile": 0.94278}, "CVE-2017-8463": {"epss_score": 0.35569, "epss_percentile": 0.96919}, "CVE-2017-8464": {"epss_score": 0.93878, "epss_percentile": 0.99863}, "CVE-2017-8465": {"epss_score": 0.06987, "epss_percentile": 0.91163}, "CVE-2017-8466": {"epss_score": 0.00692, "epss_percentile": 0.71287}, "CVE-2017-8467": {"epss_score": 0.00972, "epss_percentile": 0.76143}, "CVE-2017-8468": {"epss_score": 0.00291, "epss_percentile": 0.52151}, "CVE-2017-8469": {"epss_score": 0.0787, "epss_percentile": 0.91735}, "CVE-2017-8470": {"epss_score": 0.15731, "epss_percentile": 0.94495}, "CVE-2017-8471": {"epss_score": 0.07728, "epss_percentile": 0.91647}, "CVE-2017-8472": {"epss_score": 0.15731, "epss_percentile": 0.94495}, "CVE-2017-8473": {"epss_score": 0.07728, "epss_percentile": 0.91647}, "CVE-2017-8474": {"epss_score": 0.02844, "epss_percentile": 0.85813}, "CVE-2017-8475": {"epss_score": 0.02617, "epss_percentile": 0.85249}, "CVE-2017-8476": {"epss_score": 0.13043, "epss_percentile": 0.93856}, "CVE-2017-8477": {"epss_score": 0.03134, "epss_percentile": 0.86478}, "CVE-2017-8478": {"epss_score": 0.13043, "epss_percentile": 0.93856}, "CVE-2017-8479": {"epss_score": 0.05537, "epss_percentile": 0.89972}, "CVE-2017-8480": {"epss_score": 0.13043, "epss_percentile": 0.93856}, "CVE-2017-8481": {"epss_score": 0.06361, "epss_percentile": 0.90699}, "CVE-2017-8482": {"epss_score": 0.14765, "epss_percentile": 0.94278}, "CVE-2017-8483": {"epss_score": 0.03619, "epss_percentile": 0.8744}, "CVE-2017-8484": {"epss_score": 0.14765, "epss_percentile": 0.94278}, "CVE-2017-8485": {"epss_score": 0.07728, "epss_percentile": 0.91647}, "CVE-2017-8486": {"epss_score": 0.01433, "epss_percentile": 0.80258}, "CVE-2017-8487": {"epss_score": 0.6874, "epss_percentile": 0.9856}, "CVE-2017-8488": {"epss_score": 0.14765, "epss_percentile": 0.94278}, "CVE-2017-8489": {"epss_score": 0.06361, "epss_percentile": 0.90699}, "CVE-2017-8490": {"epss_score": 0.08833, "epss_percentile": 0.92276}, "CVE-2017-8491": {"epss_score": 0.06361, "epss_percentile": 0.90699}, "CVE-2017-8492": {"epss_score": 0.14765, "epss_percentile": 0.94278}, "CVE-2017-8493": {"epss_score": 0.00531, "epss_percentile": 0.66662}, "CVE-2017-8494": {"epss_score": 0.00591, "epss_percentile": 0.68586}, "CVE-2017-8495": {"epss_score": 0.16419, "epss_percentile": 0.94657}, "CVE-2017-8496": {"epss_score": 0.37644, "epss_percentile": 0.97061}, "CVE-2017-8497": {"epss_score": 0.14548, "epss_percentile": 0.94238}, "CVE-2017-8498": {"epss_score": 0.10737, "epss_percentile": 0.93087}, "CVE-2017-8499": {"epss_score": 0.162, "epss_percentile": 0.94593}, "CVE-2017-8501": {"epss_score": 0.31287, "epss_percentile": 0.96606}, "CVE-2017-8502": {"epss_score": 0.2823, "epss_percentile": 0.96334}, "CVE-2017-8503": {"epss_score": 0.01161, "epss_percentile": 0.78143}, "CVE-2017-8504": {"epss_score": 0.11174, "epss_percentile": 0.93254}, "CVE-2017-8506": {"epss_score": 0.3391, "epss_percentile": 0.96816}, "CVE-2017-8507": {"epss_score": 0.22842, "epss_percentile": 0.95698}, "CVE-2017-8508": {"epss_score": 0.19402, "epss_percentile": 0.95176}, "CVE-2017-8509": {"epss_score": 0.05628, "epss_percentile": 0.90065}, "CVE-2017-8510": {"epss_score": 0.36403, "epss_percentile": 0.96977}, "CVE-2017-8511": {"epss_score": 0.06355, "epss_percentile": 0.90694}, "CVE-2017-8512": {"epss_score": 0.08579, "epss_percentile": 0.92132}, "CVE-2017-8513": {"epss_score": 0.36526, "epss_percentile": 0.96983}, "CVE-2017-8514": {"epss_score": 0.00592, "epss_percentile": 0.68611}, "CVE-2017-8515": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2017-8516": {"epss_score": 0.016, "epss_percentile": 0.81257}, "CVE-2017-8517": {"epss_score": 0.13778, "epss_percentile": 0.94056}, "CVE-2017-8518": {"epss_score": 0.2401, "epss_percentile": 0.95843}, "CVE-2017-8519": {"epss_score": 0.13466, "epss_percentile": 0.93973}, "CVE-2017-8520": {"epss_score": 0.162, "epss_percentile": 0.94593}, "CVE-2017-8521": {"epss_score": 0.15875, "epss_percentile": 0.94524}, "CVE-2017-8522": {"epss_score": 0.13778, "epss_percentile": 0.94056}, "CVE-2017-8523": {"epss_score": 0.01022, "epss_percentile": 0.76763}, "CVE-2017-8524": {"epss_score": 0.13839, "epss_percentile": 0.94073}, "CVE-2017-8527": {"epss_score": 0.28831, "epss_percentile": 0.96392}, "CVE-2017-8528": {"epss_score": 0.26837, "epss_percentile": 0.96185}, "CVE-2017-8529": {"epss_score": 0.22496, "epss_percentile": 0.95644}, "CVE-2017-8530": {"epss_score": 0.00529, "epss_percentile": 0.66595}, "CVE-2017-8531": {"epss_score": 0.19789, "epss_percentile": 0.95241}, "CVE-2017-8532": {"epss_score": 0.21558, "epss_percentile": 0.95533}, "CVE-2017-8533": {"epss_score": 0.24455, "epss_percentile": 0.95923}, "CVE-2017-8534": {"epss_score": 0.17084, "epss_percentile": 0.94771}, "CVE-2017-8535": {"epss_score": 0.04953, "epss_percentile": 0.89325}, "CVE-2017-8536": {"epss_score": 0.04953, "epss_percentile": 0.89325}, "CVE-2017-8537": {"epss_score": 0.04953, "epss_percentile": 0.89325}, "CVE-2017-8538": {"epss_score": 0.64811, "epss_percentile": 0.98393}, "CVE-2017-8539": {"epss_score": 0.1918, "epss_percentile": 0.95145}, "CVE-2017-8540": {"epss_score": 0.84613, "epss_percentile": 0.99297}, "CVE-2017-8541": {"epss_score": 0.66355, "epss_percentile": 0.98461}, "CVE-2017-8542": {"epss_score": 0.1918, "epss_percentile": 0.95145}, "CVE-2017-8543": {"epss_score": 0.7994, "epss_percentile": 0.99064}, "CVE-2017-8544": {"epss_score": 0.0347, "epss_percentile": 0.87198}, "CVE-2017-8545": {"epss_score": 0.13057, "epss_percentile": 0.93859}, "CVE-2017-8547": {"epss_score": 0.13466, "epss_percentile": 0.93973}, "CVE-2017-8548": {"epss_score": 0.74995, "epss_percentile": 0.98828}, "CVE-2017-8549": {"epss_score": 0.15875, "epss_percentile": 0.94524}, "CVE-2017-8550": {"epss_score": 0.1238, "epss_percentile": 0.93655}, "CVE-2017-8551": {"epss_score": 0.00757, "epss_percentile": 0.72761}, "CVE-2017-8552": {"epss_score": 0.00249, "epss_percentile": 0.48083}, "CVE-2017-8553": {"epss_score": 0.02644, "epss_percentile": 0.8532}, "CVE-2017-8554": {"epss_score": 0.0127, "epss_percentile": 0.79051}, "CVE-2017-8555": {"epss_score": 0.06082, "epss_percentile": 0.90464}, "CVE-2017-8556": {"epss_score": 0.00972, "epss_percentile": 0.76143}, "CVE-2017-8557": {"epss_score": 0.01506, "epss_percentile": 0.80745}, "CVE-2017-8558": {"epss_score": 0.57846, "epss_percentile": 0.98085}, "CVE-2017-8559": {"epss_score": 0.0079, "epss_percentile": 0.73377}, "CVE-2017-8560": {"epss_score": 0.0079, "epss_percentile": 0.73377}, "CVE-2017-8561": {"epss_score": 0.00359, "epss_percentile": 0.57592}, "CVE-2017-8562": {"epss_score": 0.00474, "epss_percentile": 0.64157}, "CVE-2017-8563": {"epss_score": 0.17921, "epss_percentile": 0.94928}, "CVE-2017-8564": {"epss_score": 0.22928, "epss_percentile": 0.95706}, "CVE-2017-8565": {"epss_score": 0.31394, "epss_percentile": 0.96616}, "CVE-2017-8566": {"epss_score": 0.00554, "epss_percentile": 0.67434}, "CVE-2017-8567": {"epss_score": 0.32412, "epss_percentile": 0.96697}, "CVE-2017-8569": {"epss_score": 0.14546, "epss_percentile": 0.94238}, "CVE-2017-8570": {"epss_score": 0.94247, "epss_percentile": 0.99924}, "CVE-2017-8571": {"epss_score": 0.14406, "epss_percentile": 0.94205}, "CVE-2017-8572": {"epss_score": 0.10846, "epss_percentile": 0.93132}, "CVE-2017-8573": {"epss_score": 0.00972, "epss_percentile": 0.76143}, "CVE-2017-8574": {"epss_score": 0.00972, "epss_percentile": 0.76143}, "CVE-2017-8575": {"epss_score": 0.02131, "epss_percentile": 0.83712}, "CVE-2017-8576": {"epss_score": 0.01277, "epss_percentile": 0.79112}, "CVE-2017-8577": {"epss_score": 0.00972, "epss_percentile": 0.76143}, "CVE-2017-8578": {"epss_score": 0.12071, "epss_percentile": 0.93559}, "CVE-2017-8579": {"epss_score": 0.00658, "epss_percentile": 0.70483}, "CVE-2017-8580": {"epss_score": 0.01046, "epss_percentile": 0.77029}, "CVE-2017-8581": {"epss_score": 0.03233, "epss_percentile": 0.86699}, "CVE-2017-8582": {"epss_score": 0.12553, "epss_percentile": 0.93714}, "CVE-2017-8584": {"epss_score": 0.021, "epss_percentile": 0.836}, "CVE-2017-8585": {"epss_score": 0.27709, "epss_percentile": 0.96275}, "CVE-2017-8587": {"epss_score": 0.16489, "epss_percentile": 0.94678}, "CVE-2017-8588": {"epss_score": 0.28882, "epss_percentile": 0.96397}, "CVE-2017-8589": {"epss_score": 0.28386, "epss_percentile": 0.96348}, "CVE-2017-8590": {"epss_score": 0.00997, "epss_percentile": 0.76457}, "CVE-2017-8591": {"epss_score": 0.03109, "epss_percentile": 0.86423}, "CVE-2017-8592": {"epss_score": 0.29443, "epss_percentile": 0.96443}, "CVE-2017-8593": {"epss_score": 0.00685, "epss_percentile": 0.71148}, "CVE-2017-8594": {"epss_score": 0.51066, "epss_percentile": 0.97762}, "CVE-2017-8595": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-8596": {"epss_score": 0.20786, "epss_percentile": 0.95412}, "CVE-2017-8597": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2017-8598": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-8599": {"epss_score": 0.16756, "epss_percentile": 0.94728}, "CVE-2017-8601": {"epss_score": 0.78054, "epss_percentile": 0.98967}, "CVE-2017-8602": {"epss_score": 0.27181, "epss_percentile": 0.96218}, "CVE-2017-8603": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-8604": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-8605": {"epss_score": 0.18558, "epss_percentile": 0.95034}, "CVE-2017-8606": {"epss_score": 0.21953, "epss_percentile": 0.95578}, "CVE-2017-8607": {"epss_score": 0.21953, "epss_percentile": 0.95578}, "CVE-2017-8608": {"epss_score": 0.21953, "epss_percentile": 0.95578}, "CVE-2017-8609": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-8610": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-8611": {"epss_score": 0.08373, "epss_percentile": 0.92015}, "CVE-2017-8613": {"epss_score": 0.02124, "epss_percentile": 0.83688}, "CVE-2017-8617": {"epss_score": 0.19637, "epss_percentile": 0.95218}, "CVE-2017-8618": {"epss_score": 0.59856, "epss_percentile": 0.98185}, "CVE-2017-8619": {"epss_score": 0.22389, "epss_percentile": 0.9563}, "CVE-2017-8620": {"epss_score": 0.54603, "epss_percentile": 0.97935}, "CVE-2017-8621": {"epss_score": 0.00915, "epss_percentile": 0.75395}, "CVE-2017-8622": {"epss_score": 0.01092, "epss_percentile": 0.77466}, "CVE-2017-8623": {"epss_score": 0.01498, "epss_percentile": 0.80704}, "CVE-2017-8624": {"epss_score": 0.00467, "epss_percentile": 0.63862}, "CVE-2017-8625": {"epss_score": 0.69817, "epss_percentile": 0.98605}, "CVE-2017-8627": {"epss_score": 0.00583, "epss_percentile": 0.68338}, "CVE-2017-8628": {"epss_score": 0.00736, "epss_percentile": 0.723}, "CVE-2017-8629": {"epss_score": 0.0088, "epss_percentile": 0.74853}, "CVE-2017-8630": {"epss_score": 0.22842, "epss_percentile": 0.95698}, "CVE-2017-8631": {"epss_score": 0.21403, "epss_percentile": 0.95513}, "CVE-2017-8632": {"epss_score": 0.19049, "epss_percentile": 0.95118}, "CVE-2017-8633": {"epss_score": 0.1398, "epss_percentile": 0.94106}, "CVE-2017-8634": {"epss_score": 0.7437, "epss_percentile": 0.98797}, "CVE-2017-8635": {"epss_score": 0.57966, "epss_percentile": 0.98093}, "CVE-2017-8636": {"epss_score": 0.82712, "epss_percentile": 0.9921}, "CVE-2017-8637": {"epss_score": 0.18274, "epss_percentile": 0.94986}, "CVE-2017-8638": {"epss_score": 0.1763, "epss_percentile": 0.9488}, "CVE-2017-8639": {"epss_score": 0.1763, "epss_percentile": 0.9488}, "CVE-2017-8640": {"epss_score": 0.81883, "epss_percentile": 0.99163}, "CVE-2017-8641": {"epss_score": 0.75579, "epss_percentile": 0.98855}, "CVE-2017-8642": {"epss_score": 0.00896, "epss_percentile": 0.75113}, "CVE-2017-8643": {"epss_score": 0.11405, "epss_percentile": 0.93337}, "CVE-2017-8644": {"epss_score": 0.41117, "epss_percentile": 0.97256}, "CVE-2017-8645": {"epss_score": 0.81883, "epss_percentile": 0.99163}, "CVE-2017-8646": {"epss_score": 0.81883, "epss_percentile": 0.99163}, "CVE-2017-8647": {"epss_score": 0.1763, "epss_percentile": 0.9488}, "CVE-2017-8648": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2017-8649": {"epss_score": 0.1763, "epss_percentile": 0.9488}, "CVE-2017-8650": {"epss_score": 0.00718, "epss_percentile": 0.71919}, "CVE-2017-8651": {"epss_score": 0.17251, "epss_percentile": 0.94809}, "CVE-2017-8652": {"epss_score": 0.61658, "epss_percentile": 0.98257}, "CVE-2017-8653": {"epss_score": 0.24329, "epss_percentile": 0.95905}, "CVE-2017-8654": {"epss_score": 0.01078, "epss_percentile": 0.77351}, "CVE-2017-8655": {"epss_score": 0.1763, "epss_percentile": 0.9488}, "CVE-2017-8656": {"epss_score": 0.81883, "epss_percentile": 0.99163}, "CVE-2017-8657": {"epss_score": 0.57662, "epss_percentile": 0.98077}, "CVE-2017-8658": {"epss_score": 0.36011, "epss_percentile": 0.96948}, "CVE-2017-8659": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2017-8660": {"epss_score": 0.16152, "epss_percentile": 0.94579}, "CVE-2017-8661": {"epss_score": 0.17251, "epss_percentile": 0.94809}, "CVE-2017-8662": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2017-8663": {"epss_score": 0.1816, "epss_percentile": 0.94967}, "CVE-2017-8664": {"epss_score": 0.00929, "epss_percentile": 0.75588}, "CVE-2017-8665": {"epss_score": 0.10758, "epss_percentile": 0.93095}, "CVE-2017-8666": {"epss_score": 0.02807, "epss_percentile": 0.85708}, "CVE-2017-8668": {"epss_score": 0.02854, "epss_percentile": 0.85834}, "CVE-2017-8669": {"epss_score": 0.21953, "epss_percentile": 0.95578}, "CVE-2017-8670": {"epss_score": 0.78973, "epss_percentile": 0.99014}, "CVE-2017-8671": {"epss_score": 0.81883, "epss_percentile": 0.99163}, "CVE-2017-8672": {"epss_score": 0.1763, "epss_percentile": 0.9488}, "CVE-2017-8673": {"epss_score": 0.22601, "epss_percentile": 0.95655}, "CVE-2017-8674": {"epss_score": 0.1763, "epss_percentile": 0.9488}, "CVE-2017-8675": {"epss_score": 0.01052, "epss_percentile": 0.77092}, "CVE-2017-8676": {"epss_score": 0.07591, "epss_percentile": 0.91558}, "CVE-2017-8677": {"epss_score": 0.08, "epss_percentile": 0.9182}, "CVE-2017-8678": {"epss_score": 0.2035, "epss_percentile": 0.95329}, "CVE-2017-8679": {"epss_score": 0.06191, "epss_percentile": 0.90549}, "CVE-2017-8680": {"epss_score": 0.26895, "epss_percentile": 0.9619}, "CVE-2017-8681": {"epss_score": 0.2035, "epss_percentile": 0.95329}, "CVE-2017-8682": {"epss_score": 0.66013, "epss_percentile": 0.98447}, "CVE-2017-8683": {"epss_score": 0.18156, "epss_percentile": 0.94967}, "CVE-2017-8684": {"epss_score": 0.26895, "epss_percentile": 0.9619}, "CVE-2017-8685": {"epss_score": 0.26895, "epss_percentile": 0.9619}, "CVE-2017-8686": {"epss_score": 0.06584, "epss_percentile": 0.90865}, "CVE-2017-8687": {"epss_score": 0.22731, "epss_percentile": 0.95675}, "CVE-2017-8688": {"epss_score": 0.06191, "epss_percentile": 0.90549}, "CVE-2017-8689": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2017-8691": {"epss_score": 0.41644, "epss_percentile": 0.97287}, "CVE-2017-8692": {"epss_score": 0.40923, "epss_percentile": 0.97244}, "CVE-2017-8693": {"epss_score": 0.06191, "epss_percentile": 0.90549}, "CVE-2017-8694": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2017-8695": {"epss_score": 0.25671, "epss_percentile": 0.96055}, "CVE-2017-8696": {"epss_score": 0.21457, "epss_percentile": 0.95521}, "CVE-2017-8699": {"epss_score": 0.30581, "epss_percentile": 0.96552}, "CVE-2017-8700": {"epss_score": 0.10707, "epss_percentile": 0.93078}, "CVE-2017-8702": {"epss_score": 0.00889, "epss_percentile": 0.75023}, "CVE-2017-8703": {"epss_score": 0.00424, "epss_percentile": 0.6167}, "CVE-2017-8704": {"epss_score": 0.00231, "epss_percentile": 0.45834}, "CVE-2017-8706": {"epss_score": 0.03199, "epss_percentile": 0.8662}, "CVE-2017-8707": {"epss_score": 0.03199, "epss_percentile": 0.8662}, "CVE-2017-8708": {"epss_score": 0.19314, "epss_percentile": 0.95163}, "CVE-2017-8709": {"epss_score": 0.03549, "epss_percentile": 0.87336}, "CVE-2017-8710": {"epss_score": 0.33099, "epss_percentile": 0.96745}, "CVE-2017-8711": {"epss_score": 0.03199, "epss_percentile": 0.8662}, "CVE-2017-8712": {"epss_score": 0.03199, "epss_percentile": 0.8662}, "CVE-2017-8713": {"epss_score": 0.03199, "epss_percentile": 0.8662}, "CVE-2017-8714": {"epss_score": 0.01056, "epss_percentile": 0.77122}, "CVE-2017-8715": {"epss_score": 0.01906, "epss_percentile": 0.82809}, "CVE-2017-8716": {"epss_score": 0.02335, "epss_percentile": 0.84414}, "CVE-2017-8717": {"epss_score": 0.32412, "epss_percentile": 0.96697}, "CVE-2017-8718": {"epss_score": 0.32412, "epss_percentile": 0.96697}, "CVE-2017-8719": {"epss_score": 0.03549, "epss_percentile": 0.87336}, "CVE-2017-8720": {"epss_score": 0.00826, "epss_percentile": 0.73964}, "CVE-2017-8723": {"epss_score": 0.06267, "epss_percentile": 0.90624}, "CVE-2017-8724": {"epss_score": 0.02843, "epss_percentile": 0.85813}, "CVE-2017-8725": {"epss_score": 0.32412, "epss_percentile": 0.96697}, "CVE-2017-8726": {"epss_score": 0.10515, "epss_percentile": 0.93016}, "CVE-2017-8727": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-8728": {"epss_score": 0.34224, "epss_percentile": 0.96833}, "CVE-2017-8729": {"epss_score": 0.78226, "epss_percentile": 0.98975}, "CVE-2017-8731": {"epss_score": 0.6165, "epss_percentile": 0.98257}, "CVE-2017-8733": {"epss_score": 0.03672, "epss_percentile": 0.8754}, "CVE-2017-8734": {"epss_score": 0.61551, "epss_percentile": 0.98253}, "CVE-2017-8735": {"epss_score": 0.02843, "epss_percentile": 0.85813}, "CVE-2017-8736": {"epss_score": 0.16518, "epss_percentile": 0.94684}, "CVE-2017-8737": {"epss_score": 0.34224, "epss_percentile": 0.96833}, "CVE-2017-8738": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-8739": {"epss_score": 0.13004, "epss_percentile": 0.93841}, "CVE-2017-8740": {"epss_score": 0.76981, "epss_percentile": 0.98913}, "CVE-2017-8741": {"epss_score": 0.24329, "epss_percentile": 0.95905}, "CVE-2017-8742": {"epss_score": 0.3652, "epss_percentile": 0.96983}, "CVE-2017-8743": {"epss_score": 0.32436, "epss_percentile": 0.967}, "CVE-2017-8744": {"epss_score": 0.22842, "epss_percentile": 0.95698}, "CVE-2017-8745": {"epss_score": 0.01286, "epss_percentile": 0.7919}, "CVE-2017-8746": {"epss_score": 0.00524, "epss_percentile": 0.66333}, "CVE-2017-8747": {"epss_score": 0.20003, "epss_percentile": 0.95274}, "CVE-2017-8748": {"epss_score": 0.24329, "epss_percentile": 0.95905}, "CVE-2017-8749": {"epss_score": 0.20003, "epss_percentile": 0.95274}, "CVE-2017-8750": {"epss_score": 0.24219, "epss_percentile": 0.95888}, "CVE-2017-8751": {"epss_score": 0.53999, "epss_percentile": 0.97907}, "CVE-2017-8752": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-8753": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-8754": {"epss_score": 0.05051, "epss_percentile": 0.89441}, "CVE-2017-8755": {"epss_score": 0.76981, "epss_percentile": 0.98913}, "CVE-2017-8756": {"epss_score": 0.20533, "epss_percentile": 0.95374}, "CVE-2017-8757": {"epss_score": 0.22389, "epss_percentile": 0.9563}, "CVE-2017-8758": {"epss_score": 0.0079, "epss_percentile": 0.73377}, "CVE-2017-8759": {"epss_score": 0.93953, "epss_percentile": 0.99873}, "CVE-2017-8760": {"epss_score": 0.0104, "epss_percentile": 0.76959}, "CVE-2017-8761": {"epss_score": 0.00167, "epss_percentile": 0.38274}, "CVE-2017-8762": {"epss_score": 0.00315, "epss_percentile": 0.54191}, "CVE-2017-8763": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2017-8765": {"epss_score": 0.00389, "epss_percentile": 0.59462}, "CVE-2017-8766": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2017-8768": {"epss_score": 0.08015, "epss_percentile": 0.91831}, "CVE-2017-8769": {"epss_score": 0.00022, "epss_percentile": 0.05282}, "CVE-2017-8770": {"epss_score": 0.2183, "epss_percentile": 0.95565}, "CVE-2017-8771": {"epss_score": 0.00353, "epss_percentile": 0.57135}, "CVE-2017-8772": {"epss_score": 0.00284, "epss_percentile": 0.51448}, "CVE-2017-8773": {"epss_score": 0.02395, "epss_percentile": 0.84615}, "CVE-2017-8774": {"epss_score": 0.00531, "epss_percentile": 0.66649}, "CVE-2017-8775": {"epss_score": 0.00531, "epss_percentile": 0.66649}, "CVE-2017-8776": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2017-8777": {"epss_score": 0.00597, "epss_percentile": 0.6874}, "CVE-2017-8778": {"epss_score": 0.00074, "epss_percentile": 0.22851}, "CVE-2017-8779": {"epss_score": 0.82537, "epss_percentile": 0.99199}, "CVE-2017-8780": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2017-8781": {"epss_score": 0.00628, "epss_percentile": 0.69663}, "CVE-2017-8782": {"epss_score": 0.00419, "epss_percentile": 0.61372}, "CVE-2017-8783": {"epss_score": 0.00445, "epss_percentile": 0.6286}, "CVE-2017-8785": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2017-8786": {"epss_score": 0.00671, "epss_percentile": 0.70799}, "CVE-2017-8787": {"epss_score": 0.00452, "epss_percentile": 0.63193}, "CVE-2017-8788": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-8789": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-8790": {"epss_score": 0.00486, "epss_percentile": 0.64774}, "CVE-2017-8791": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-8792": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-8793": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2017-8794": {"epss_score": 0.00324, "epss_percentile": 0.54927}, "CVE-2017-8795": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-8796": {"epss_score": 0.00292, "epss_percentile": 0.52221}, "CVE-2017-8797": {"epss_score": 0.31791, "epss_percentile": 0.96648}, "CVE-2017-8798": {"epss_score": 0.25607, "epss_percentile": 0.96049}, "CVE-2017-8799": {"epss_score": 0.0092, "epss_percentile": 0.75466}, "CVE-2017-8801": {"epss_score": 0.0033, "epss_percentile": 0.55424}, "CVE-2017-8802": {"epss_score": 0.00307, "epss_percentile": 0.53503}, "CVE-2017-8803": {"epss_score": 0.00313, "epss_percentile": 0.54012}, "CVE-2017-8804": {"epss_score": 0.03759, "epss_percentile": 0.87686}, "CVE-2017-8805": {"epss_score": 0.00301, "epss_percentile": 0.52993}, "CVE-2017-8806": {"epss_score": 0.0016, "epss_percentile": 0.37483}, "CVE-2017-8807": {"epss_score": 0.01748, "epss_percentile": 0.8208}, "CVE-2017-8808": {"epss_score": 0.00403, "epss_percentile": 0.60381}, "CVE-2017-8809": {"epss_score": 0.18083, "epss_percentile": 0.94954}, "CVE-2017-8810": {"epss_score": 0.00959, "epss_percentile": 0.75961}, "CVE-2017-8811": {"epss_score": 0.00326, "epss_percentile": 0.55045}, "CVE-2017-8812": {"epss_score": 0.00832, "epss_percentile": 0.74061}, "CVE-2017-8814": {"epss_score": 0.00652, "epss_percentile": 0.70308}, "CVE-2017-8815": {"epss_score": 0.00395, "epss_percentile": 0.5985}, "CVE-2017-8816": {"epss_score": 0.00595, "epss_percentile": 0.68678}, "CVE-2017-8817": {"epss_score": 0.0061, "epss_percentile": 0.69136}, "CVE-2017-8818": {"epss_score": 0.00559, "epss_percentile": 0.67603}, "CVE-2017-8819": {"epss_score": 0.00546, "epss_percentile": 0.67215}, "CVE-2017-8820": {"epss_score": 0.00816, "epss_percentile": 0.73797}, "CVE-2017-8821": {"epss_score": 0.01001, "epss_percentile": 0.76496}, "CVE-2017-8822": {"epss_score": 0.00304, "epss_percentile": 0.53308}, "CVE-2017-8823": {"epss_score": 0.00674, "epss_percentile": 0.70859}, "CVE-2017-8824": {"epss_score": 0.00768, "epss_percentile": 0.72973}, "CVE-2017-8825": {"epss_score": 0.00543, "epss_percentile": 0.67124}, "CVE-2017-8826": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2017-8827": {"epss_score": 0.00457, "epss_percentile": 0.6339}, "CVE-2017-8829": {"epss_score": 0.00308, "epss_percentile": 0.53606}, "CVE-2017-8830": {"epss_score": 0.00426, "epss_percentile": 0.61752}, "CVE-2017-8831": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2017-8832": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2017-8833": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-8834": {"epss_score": 0.00828, "epss_percentile": 0.74003}, "CVE-2017-8835": {"epss_score": 0.63815, "epss_percentile": 0.9835}, "CVE-2017-8836": {"epss_score": 0.00595, "epss_percentile": 0.68694}, "CVE-2017-8837": {"epss_score": 0.1103, "epss_percentile": 0.93195}, "CVE-2017-8838": {"epss_score": 0.02047, "epss_percentile": 0.83389}, "CVE-2017-8839": {"epss_score": 0.02047, "epss_percentile": 0.83389}, "CVE-2017-8840": {"epss_score": 0.03845, "epss_percentile": 0.87841}, "CVE-2017-8841": {"epss_score": 0.04455, "epss_percentile": 0.88711}, "CVE-2017-8842": {"epss_score": 0.00184, "epss_percentile": 0.40452}, "CVE-2017-8843": {"epss_score": 0.00184, "epss_percentile": 0.40452}, "CVE-2017-8844": {"epss_score": 0.00356, "epss_percentile": 0.57391}, "CVE-2017-8845": {"epss_score": 0.00184, "epss_percentile": 0.40452}, "CVE-2017-8846": {"epss_score": 0.00515, "epss_percentile": 0.65998}, "CVE-2017-8847": {"epss_score": 0.00184, "epss_percentile": 0.40452}, "CVE-2017-8848": {"epss_score": 0.00098, "epss_percentile": 0.27754}, "CVE-2017-8849": {"epss_score": 0.00242, "epss_percentile": 0.47372}, "CVE-2017-8850": {"epss_score": 0.00092, "epss_percentile": 0.26593}, "CVE-2017-8851": {"epss_score": 0.00137, "epss_percentile": 0.34303}, "CVE-2017-8852": {"epss_score": 0.01682, "epss_percentile": 0.81736}, "CVE-2017-8853": {"epss_score": 0.00588, "epss_percentile": 0.6851}, "CVE-2017-8854": {"epss_score": 0.00266, "epss_percentile": 0.49864}, "CVE-2017-8855": {"epss_score": 0.0032, "epss_percentile": 0.54612}, "CVE-2017-8856": {"epss_score": 0.02573, "epss_percentile": 0.85136}, "CVE-2017-8857": {"epss_score": 0.03006, "epss_percentile": 0.86184}, "CVE-2017-8858": {"epss_score": 0.01419, "epss_percentile": 0.80163}, "CVE-2017-8859": {"epss_score": 0.01129, "epss_percentile": 0.7784}, "CVE-2017-8860": {"epss_score": 0.00272, "epss_percentile": 0.50391}, "CVE-2017-8861": {"epss_score": 0.01068, "epss_percentile": 0.77239}, "CVE-2017-8862": {"epss_score": 0.00339, "epss_percentile": 0.5618}, "CVE-2017-8863": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2017-8864": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2017-8865": {"epss_score": 0.00251, "epss_percentile": 0.48292}, "CVE-2017-8866": {"epss_score": 0.00123, "epss_percentile": 0.32308}, "CVE-2017-8867": {"epss_score": 0.00251, "epss_percentile": 0.48292}, "CVE-2017-8868": {"epss_score": 0.00645, "epss_percentile": 0.70114}, "CVE-2017-8869": {"epss_score": 0.22935, "epss_percentile": 0.95708}, "CVE-2017-8870": {"epss_score": 0.37614, "epss_percentile": 0.97059}, "CVE-2017-8871": {"epss_score": 0.01942, "epss_percentile": 0.82991}, "CVE-2017-8872": {"epss_score": 0.00178, "epss_percentile": 0.39739}, "CVE-2017-8874": {"epss_score": 0.00118, "epss_percentile": 0.31437}, "CVE-2017-8875": {"epss_score": 0.00133, "epss_percentile": 0.3369}, "CVE-2017-8876": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-8877": {"epss_score": 0.00259, "epss_percentile": 0.49064}, "CVE-2017-8878": {"epss_score": 0.00214, "epss_percentile": 0.43958}, "CVE-2017-8879": {"epss_score": 0.00048, "epss_percentile": 0.15105}, "CVE-2017-8890": {"epss_score": 0.00475, "epss_percentile": 0.64197}, "CVE-2017-8891": {"epss_score": 0.00171, "epss_percentile": 0.38833}, "CVE-2017-8892": {"epss_score": 0.00196, "epss_percentile": 0.41746}, "CVE-2017-8893": {"epss_score": 0.0033, "epss_percentile": 0.5545}, "CVE-2017-8894": {"epss_score": 0.00955, "epss_percentile": 0.75912}, "CVE-2017-8895": {"epss_score": 0.67063, "epss_percentile": 0.98492}, "CVE-2017-8896": {"epss_score": 0.00379, "epss_percentile": 0.58884}, "CVE-2017-8897": {"epss_score": 0.00285, "epss_percentile": 0.51547}, "CVE-2017-8898": {"epss_score": 0.00559, "epss_percentile": 0.67627}, "CVE-2017-8899": {"epss_score": 0.00559, "epss_percentile": 0.67627}, "CVE-2017-8900": {"epss_score": 0.00049, "epss_percentile": 0.15424}, "CVE-2017-8903": {"epss_score": 0.00338, "epss_percentile": 0.56069}, "CVE-2017-8904": {"epss_score": 0.00087, "epss_percentile": 0.25553}, "CVE-2017-8905": {"epss_score": 0.00087, "epss_percentile": 0.25553}, "CVE-2017-8906": {"epss_score": 0.00279, "epss_percentile": 0.50926}, "CVE-2017-8907": {"epss_score": 0.00853, "epss_percentile": 0.74441}, "CVE-2017-8908": {"epss_score": 0.00391, "epss_percentile": 0.59619}, "CVE-2017-8911": {"epss_score": 0.00381, "epss_percentile": 0.59}, "CVE-2017-8912": {"epss_score": 0.03714, "epss_percentile": 0.87612}, "CVE-2017-8913": {"epss_score": 0.00552, "epss_percentile": 0.67403}, "CVE-2017-8914": {"epss_score": 0.00494, "epss_percentile": 0.65082}, "CVE-2017-8915": {"epss_score": 0.00852, "epss_percentile": 0.74419}, "CVE-2017-8916": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2017-8917": {"epss_score": 0.94513, "epss_percentile": 1.0}, "CVE-2017-8918": {"epss_score": 0.01735, "epss_percentile": 0.8201}, "CVE-2017-8919": {"epss_score": 0.00213, "epss_percentile": 0.43905}, "CVE-2017-8920": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-8921": {"epss_score": 0.00588, "epss_percentile": 0.6851}, "CVE-2017-8923": {"epss_score": 0.04586, "epss_percentile": 0.88887}, "CVE-2017-8924": {"epss_score": 0.0011, "epss_percentile": 0.30151}, "CVE-2017-8925": {"epss_score": 0.00101, "epss_percentile": 0.28593}, "CVE-2017-8926": {"epss_score": 0.01119, "epss_percentile": 0.77758}, "CVE-2017-8927": {"epss_score": 0.0104, "epss_percentile": 0.76954}, "CVE-2017-8928": {"epss_score": 0.00288, "epss_percentile": 0.51922}, "CVE-2017-8929": {"epss_score": 0.00418, "epss_percentile": 0.61265}, "CVE-2017-8930": {"epss_score": 0.00118, "epss_percentile": 0.31439}, "CVE-2017-8931": {"epss_score": 0.00442, "epss_percentile": 0.62751}, "CVE-2017-8932": {"epss_score": 0.02018, "epss_percentile": 0.83287}, "CVE-2017-8933": {"epss_score": 0.00052, "epss_percentile": 0.16384}, "CVE-2017-8934": {"epss_score": 0.00136, "epss_percentile": 0.34098}, "CVE-2017-8935": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-8936": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-8937": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-8938": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-8939": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-8940": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-8941": {"epss_score": 0.00299, "epss_percentile": 0.5284}, "CVE-2017-8942": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-8943": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-8944": {"epss_score": 0.03097, "epss_percentile": 0.86405}, "CVE-2017-8945": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2017-8946": {"epss_score": 0.22199, "epss_percentile": 0.95608}, "CVE-2017-8947": {"epss_score": 0.638, "epss_percentile": 0.9835}, "CVE-2017-8948": {"epss_score": 0.09392, "epss_percentile": 0.9253}, "CVE-2017-8949": {"epss_score": 0.00255, "epss_percentile": 0.48645}, "CVE-2017-8950": {"epss_score": 0.00597, "epss_percentile": 0.68753}, "CVE-2017-8951": {"epss_score": 0.0037, "epss_percentile": 0.5832}, "CVE-2017-8952": {"epss_score": 0.02469, "epss_percentile": 0.84842}, "CVE-2017-8953": {"epss_score": 0.00309, "epss_percentile": 0.53643}, "CVE-2017-8954": {"epss_score": 0.51056, "epss_percentile": 0.97762}, "CVE-2017-8955": {"epss_score": 0.13579, "epss_percentile": 0.94001}, "CVE-2017-8956": {"epss_score": 0.12217, "epss_percentile": 0.93604}, "CVE-2017-8957": {"epss_score": 0.51056, "epss_percentile": 0.97762}, "CVE-2017-8958": {"epss_score": 0.02658, "epss_percentile": 0.85361}, "CVE-2017-8959": {"epss_score": 0.00566, "epss_percentile": 0.67827}, "CVE-2017-8960": {"epss_score": 0.01011, "epss_percentile": 0.76614}, "CVE-2017-8961": {"epss_score": 0.66349, "epss_percentile": 0.9846}, "CVE-2017-8962": {"epss_score": 0.02017, "epss_percentile": 0.83283}, "CVE-2017-8963": {"epss_score": 0.02017, "epss_percentile": 0.83283}, "CVE-2017-8964": {"epss_score": 0.02017, "epss_percentile": 0.83283}, "CVE-2017-8965": {"epss_score": 0.02017, "epss_percentile": 0.83283}, "CVE-2017-8966": {"epss_score": 0.02017, "epss_percentile": 0.83283}, "CVE-2017-8967": {"epss_score": 0.02017, "epss_percentile": 0.83283}, "CVE-2017-8968": {"epss_score": 0.00723, "epss_percentile": 0.72008}, "CVE-2017-8969": {"epss_score": 0.0019, "epss_percentile": 0.41103}, "CVE-2017-8970": {"epss_score": 0.0076, "epss_percentile": 0.72807}, "CVE-2017-8971": {"epss_score": 0.00284, "epss_percentile": 0.51441}, "CVE-2017-8972": {"epss_score": 0.00284, "epss_percentile": 0.51441}, "CVE-2017-8973": {"epss_score": 0.00284, "epss_percentile": 0.51441}, "CVE-2017-8974": {"epss_score": 0.00072, "epss_percentile": 0.22302}, "CVE-2017-8975": {"epss_score": 0.51056, "epss_percentile": 0.97762}, "CVE-2017-8976": {"epss_score": 0.51056, "epss_percentile": 0.97762}, "CVE-2017-8977": {"epss_score": 0.03973, "epss_percentile": 0.88045}, "CVE-2017-8978": {"epss_score": 0.00242, "epss_percentile": 0.47386}, "CVE-2017-8979": {"epss_score": 0.02692, "epss_percentile": 0.85439}, "CVE-2017-8980": {"epss_score": 0.02347, "epss_percentile": 0.84456}, "CVE-2017-8981": {"epss_score": 0.12217, "epss_percentile": 0.93604}, "CVE-2017-8982": {"epss_score": 0.47184, "epss_percentile": 0.97573}, "CVE-2017-8983": {"epss_score": 0.02554, "epss_percentile": 0.85088}, "CVE-2017-8984": {"epss_score": 0.02658, "epss_percentile": 0.85361}, "CVE-2017-8985": {"epss_score": 0.00082, "epss_percentile": 0.24403}, "CVE-2017-8987": {"epss_score": 0.03975, "epss_percentile": 0.88048}, "CVE-2017-8988": {"epss_score": 0.00769, "epss_percentile": 0.72982}, "CVE-2017-8989": {"epss_score": 0.00675, "epss_percentile": 0.70896}, "CVE-2017-8990": {"epss_score": 0.35782, "epss_percentile": 0.96935}, "CVE-2017-8991": {"epss_score": 0.003, "epss_percentile": 0.52948}, "CVE-2017-8992": {"epss_score": 0.02894, "epss_percentile": 0.85923}, "CVE-2017-8993": {"epss_score": 0.00325, "epss_percentile": 0.55006}, "CVE-2017-8994": {"epss_score": 0.01369, "epss_percentile": 0.79796}, "CVE-2017-9000": {"epss_score": 0.01359, "epss_percentile": 0.79735}, "CVE-2017-9001": {"epss_score": 0.02307, "epss_percentile": 0.84325}, "CVE-2017-9002": {"epss_score": 0.00453, "epss_percentile": 0.63233}, "CVE-2017-9003": {"epss_score": 0.02384, "epss_percentile": 0.84576}, "CVE-2017-9022": {"epss_score": 0.01034, "epss_percentile": 0.76888}, "CVE-2017-9023": {"epss_score": 0.02101, "epss_percentile": 0.83604}, "CVE-2017-9024": {"epss_score": 0.10121, "epss_percentile": 0.92858}, "CVE-2017-9025": {"epss_score": 0.03932, "epss_percentile": 0.87977}, "CVE-2017-9026": {"epss_score": 0.01154, "epss_percentile": 0.78068}, "CVE-2017-9030": {"epss_score": 0.02076, "epss_percentile": 0.83512}, "CVE-2017-9031": {"epss_score": 0.00506, "epss_percentile": 0.65621}, "CVE-2017-9032": {"epss_score": 0.0124, "epss_percentile": 0.78802}, "CVE-2017-9033": {"epss_score": 0.00132, "epss_percentile": 0.33533}, "CVE-2017-9034": {"epss_score": 0.07387, "epss_percentile": 0.91447}, "CVE-2017-9035": {"epss_score": 0.00675, "epss_percentile": 0.7089}, "CVE-2017-9036": {"epss_score": 0.00101, "epss_percentile": 0.28685}, "CVE-2017-9037": {"epss_score": 0.0124, "epss_percentile": 0.78802}, "CVE-2017-9038": {"epss_score": 0.00358, "epss_percentile": 0.57501}, "CVE-2017-9039": {"epss_score": 0.00358, "epss_percentile": 0.57501}, "CVE-2017-9040": {"epss_score": 0.00475, "epss_percentile": 0.64179}, "CVE-2017-9041": {"epss_score": 0.00483, "epss_percentile": 0.64593}, "CVE-2017-9042": {"epss_score": 0.00395, "epss_percentile": 0.59806}, "CVE-2017-9043": {"epss_score": 0.00395, "epss_percentile": 0.59806}, "CVE-2017-9044": {"epss_score": 0.00421, "epss_percentile": 0.61465}, "CVE-2017-9045": {"epss_score": 0.00094, "epss_percentile": 0.26769}, "CVE-2017-9046": {"epss_score": 0.00113, "epss_percentile": 0.3064}, "CVE-2017-9047": {"epss_score": 0.024, "epss_percentile": 0.84637}, "CVE-2017-9048": {"epss_score": 0.00537, "epss_percentile": 0.669}, "CVE-2017-9049": {"epss_score": 0.00458, "epss_percentile": 0.63429}, "CVE-2017-9050": {"epss_score": 0.00313, "epss_percentile": 0.54057}, "CVE-2017-9051": {"epss_score": 0.00334, "epss_percentile": 0.55684}, "CVE-2017-9052": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9053": {"epss_score": 0.00431, "epss_percentile": 0.62037}, "CVE-2017-9054": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9055": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9058": {"epss_score": 0.00389, "epss_percentile": 0.59451}, "CVE-2017-9059": {"epss_score": 0.0012, "epss_percentile": 0.31782}, "CVE-2017-9060": {"epss_score": 0.00091, "epss_percentile": 0.2619}, "CVE-2017-9061": {"epss_score": 0.03308, "epss_percentile": 0.86881}, "CVE-2017-9062": {"epss_score": 0.01674, "epss_percentile": 0.81692}, "CVE-2017-9063": {"epss_score": 0.01449, "epss_percentile": 0.80344}, "CVE-2017-9064": {"epss_score": 0.01257, "epss_percentile": 0.78943}, "CVE-2017-9065": {"epss_score": 0.03545, "epss_percentile": 0.87324}, "CVE-2017-9066": {"epss_score": 0.01408, "epss_percentile": 0.80063}, "CVE-2017-9067": {"epss_score": 0.00037, "epss_percentile": 0.10772}, "CVE-2017-9068": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-9069": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2017-9070": {"epss_score": 0.00217, "epss_percentile": 0.44306}, "CVE-2017-9071": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-9072": {"epss_score": 0.00227, "epss_percentile": 0.45419}, "CVE-2017-9074": {"epss_score": 0.00079, "epss_percentile": 0.23907}, "CVE-2017-9075": {"epss_score": 0.00079, "epss_percentile": 0.23907}, "CVE-2017-9076": {"epss_score": 0.00079, "epss_percentile": 0.23907}, "CVE-2017-9077": {"epss_score": 0.00968, "epss_percentile": 0.76084}, "CVE-2017-9078": {"epss_score": 0.05693, "epss_percentile": 0.90126}, "CVE-2017-9079": {"epss_score": 0.0013, "epss_percentile": 0.33301}, "CVE-2017-9080": {"epss_score": 0.73453, "epss_percentile": 0.98757}, "CVE-2017-9083": {"epss_score": 0.00676, "epss_percentile": 0.7093}, "CVE-2017-9085": {"epss_score": 0.00196, "epss_percentile": 0.41807}, "CVE-2017-9090": {"epss_score": 0.00198, "epss_percentile": 0.42035}, "CVE-2017-9091": {"epss_score": 0.00198, "epss_percentile": 0.42035}, "CVE-2017-9093": {"epss_score": 0.00346, "epss_percentile": 0.56711}, "CVE-2017-9094": {"epss_score": 0.00346, "epss_percentile": 0.56711}, "CVE-2017-9095": {"epss_score": 0.01558, "epss_percentile": 0.8103}, "CVE-2017-9096": {"epss_score": 0.08838, "epss_percentile": 0.92278}, "CVE-2017-9097": {"epss_score": 0.09535, "epss_percentile": 0.92588}, "CVE-2017-9098": {"epss_score": 0.0146, "epss_percentile": 0.80419}, "CVE-2017-9100": {"epss_score": 0.29384, "epss_percentile": 0.96439}, "CVE-2017-9101": {"epss_score": 0.78868, "epss_percentile": 0.99008}, "CVE-2017-9103": {"epss_score": 0.00805, "epss_percentile": 0.73629}, "CVE-2017-9104": {"epss_score": 0.0067, "epss_percentile": 0.70773}, "CVE-2017-9105": {"epss_score": 0.03207, "epss_percentile": 0.86636}, "CVE-2017-9106": {"epss_score": 0.00531, "epss_percentile": 0.66644}, "CVE-2017-9107": {"epss_score": 0.00531, "epss_percentile": 0.66644}, "CVE-2017-9108": {"epss_score": 0.00527, "epss_percentile": 0.66529}, "CVE-2017-9109": {"epss_score": 0.00674, "epss_percentile": 0.7085}, "CVE-2017-9110": {"epss_score": 0.00789, "epss_percentile": 0.73365}, "CVE-2017-9111": {"epss_score": 0.01888, "epss_percentile": 0.82721}, "CVE-2017-9112": {"epss_score": 0.00458, "epss_percentile": 0.63401}, "CVE-2017-9113": {"epss_score": 0.03305, "epss_percentile": 0.86873}, "CVE-2017-9114": {"epss_score": 0.00338, "epss_percentile": 0.5611}, "CVE-2017-9115": {"epss_score": 0.03278, "epss_percentile": 0.86807}, "CVE-2017-9116": {"epss_score": 0.00249, "epss_percentile": 0.48006}, "CVE-2017-9117": {"epss_score": 0.00098, "epss_percentile": 0.27812}, "CVE-2017-9118": {"epss_score": 0.00302, "epss_percentile": 0.53109}, "CVE-2017-9119": {"epss_score": 0.00502, "epss_percentile": 0.65407}, "CVE-2017-9120": {"epss_score": 0.06142, "epss_percentile": 0.90515}, "CVE-2017-9122": {"epss_score": 0.06241, "epss_percentile": 0.90594}, "CVE-2017-9123": {"epss_score": 0.02879, "epss_percentile": 0.85892}, "CVE-2017-9124": {"epss_score": 0.07643, "epss_percentile": 0.91597}, "CVE-2017-9125": {"epss_score": 0.02879, "epss_percentile": 0.85892}, "CVE-2017-9126": {"epss_score": 0.02879, "epss_percentile": 0.85892}, "CVE-2017-9127": {"epss_score": 0.02879, "epss_percentile": 0.85892}, "CVE-2017-9128": {"epss_score": 0.02879, "epss_percentile": 0.85892}, "CVE-2017-9129": {"epss_score": 0.00815, "epss_percentile": 0.73795}, "CVE-2017-9130": {"epss_score": 0.01123, "epss_percentile": 0.77793}, "CVE-2017-9131": {"epss_score": 0.0145, "epss_percentile": 0.80353}, "CVE-2017-9132": {"epss_score": 0.00265, "epss_percentile": 0.49837}, "CVE-2017-9133": {"epss_score": 0.00381, "epss_percentile": 0.58983}, "CVE-2017-9134": {"epss_score": 0.00379, "epss_percentile": 0.58889}, "CVE-2017-9135": {"epss_score": 0.00368, "epss_percentile": 0.58187}, "CVE-2017-9136": {"epss_score": 0.00118, "epss_percentile": 0.31487}, "CVE-2017-9137": {"epss_score": 0.00282, "epss_percentile": 0.51227}, "CVE-2017-9138": {"epss_score": 0.00135, "epss_percentile": 0.34002}, "CVE-2017-9139": {"epss_score": 0.00112, "epss_percentile": 0.30491}, "CVE-2017-9140": {"epss_score": 0.05518, "epss_percentile": 0.89954}, "CVE-2017-9141": {"epss_score": 0.01404, "epss_percentile": 0.80038}, "CVE-2017-9142": {"epss_score": 0.01404, "epss_percentile": 0.80038}, "CVE-2017-9143": {"epss_score": 0.0084, "epss_percentile": 0.74209}, "CVE-2017-9144": {"epss_score": 0.00948, "epss_percentile": 0.75831}, "CVE-2017-9145": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-9146": {"epss_score": 0.00608, "epss_percentile": 0.69073}, "CVE-2017-9147": {"epss_score": 0.04347, "epss_percentile": 0.88577}, "CVE-2017-9148": {"epss_score": 0.01209, "epss_percentile": 0.78543}, "CVE-2017-9149": {"epss_score": 0.00277, "epss_percentile": 0.50789}, "CVE-2017-9150": {"epss_score": 0.00573, "epss_percentile": 0.68066}, "CVE-2017-9151": {"epss_score": 0.00516, "epss_percentile": 0.66045}, "CVE-2017-9152": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9153": {"epss_score": 0.00513, "epss_percentile": 0.65902}, "CVE-2017-9154": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9155": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9156": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9157": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9158": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9159": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9160": {"epss_score": 0.00513, "epss_percentile": 0.65902}, "CVE-2017-9161": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9162": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9163": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9164": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9165": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9166": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9167": {"epss_score": 0.00513, "epss_percentile": 0.65902}, "CVE-2017-9168": {"epss_score": 0.00513, "epss_percentile": 0.65902}, "CVE-2017-9169": {"epss_score": 0.00513, "epss_percentile": 0.65902}, "CVE-2017-9170": {"epss_score": 0.00513, "epss_percentile": 0.65902}, "CVE-2017-9171": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9172": {"epss_score": 0.00513, "epss_percentile": 0.65902}, "CVE-2017-9173": {"epss_score": 0.00513, "epss_percentile": 0.65902}, "CVE-2017-9174": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9175": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9176": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9177": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9178": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9179": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9180": {"epss_score": 0.00844, "epss_percentile": 0.7428}, "CVE-2017-9181": {"epss_score": 0.00705, "epss_percentile": 0.71577}, "CVE-2017-9182": {"epss_score": 0.00247, "epss_percentile": 0.4782}, "CVE-2017-9183": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9184": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9185": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9186": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9187": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9188": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9189": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9190": {"epss_score": 0.00701, "epss_percentile": 0.7149}, "CVE-2017-9191": {"epss_score": 0.00513, "epss_percentile": 0.65902}, "CVE-2017-9192": {"epss_score": 0.00513, "epss_percentile": 0.65902}, "CVE-2017-9193": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9194": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9195": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9196": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9197": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9198": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9199": {"epss_score": 0.00397, "epss_percentile": 0.59949}, "CVE-2017-9200": {"epss_score": 0.00399, "epss_percentile": 0.60113}, "CVE-2017-9201": {"epss_score": 0.00405, "epss_percentile": 0.60472}, "CVE-2017-9202": {"epss_score": 0.00405, "epss_percentile": 0.60472}, "CVE-2017-9203": {"epss_score": 0.00405, "epss_percentile": 0.60472}, "CVE-2017-9204": {"epss_score": 0.00405, "epss_percentile": 0.60472}, "CVE-2017-9205": {"epss_score": 0.00405, "epss_percentile": 0.60472}, "CVE-2017-9206": {"epss_score": 0.00405, "epss_percentile": 0.60472}, "CVE-2017-9207": {"epss_score": 0.0038, "epss_percentile": 0.58907}, "CVE-2017-9208": {"epss_score": 0.00432, "epss_percentile": 0.62107}, "CVE-2017-9209": {"epss_score": 0.00232, "epss_percentile": 0.45971}, "CVE-2017-9210": {"epss_score": 0.00283, "epss_percentile": 0.51396}, "CVE-2017-9211": {"epss_score": 0.00044, "epss_percentile": 0.13537}, "CVE-2017-9212": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2017-9214": {"epss_score": 0.0339, "epss_percentile": 0.87049}, "CVE-2017-9216": {"epss_score": 0.01428, "epss_percentile": 0.80219}, "CVE-2017-9217": {"epss_score": 0.0149, "epss_percentile": 0.80628}, "CVE-2017-9218": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2017-9219": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2017-9220": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2017-9221": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2017-9222": {"epss_score": 0.00258, "epss_percentile": 0.48971}, "CVE-2017-9223": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2017-9224": {"epss_score": 0.00664, "epss_percentile": 0.70629}, "CVE-2017-9225": {"epss_score": 0.00392, "epss_percentile": 0.5969}, "CVE-2017-9226": {"epss_score": 0.00963, "epss_percentile": 0.76023}, "CVE-2017-9227": {"epss_score": 0.00482, "epss_percentile": 0.64553}, "CVE-2017-9228": {"epss_score": 0.00823, "epss_percentile": 0.73927}, "CVE-2017-9229": {"epss_score": 0.00593, "epss_percentile": 0.68647}, "CVE-2017-9230": {"epss_score": 0.00864, "epss_percentile": 0.74603}, "CVE-2017-9231": {"epss_score": 0.00403, "epss_percentile": 0.60354}, "CVE-2017-9232": {"epss_score": 0.81605, "epss_percentile": 0.99147}, "CVE-2017-9233": {"epss_score": 0.00253, "epss_percentile": 0.48477}, "CVE-2017-9239": {"epss_score": 0.00133, "epss_percentile": 0.33638}, "CVE-2017-9242": {"epss_score": 0.00046, "epss_percentile": 0.14291}, "CVE-2017-9243": {"epss_score": 0.00193, "epss_percentile": 0.41438}, "CVE-2017-9244": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2017-9245": {"epss_score": 0.01316, "epss_percentile": 0.79411}, "CVE-2017-9246": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-9247": {"epss_score": 2e-05, "epss_percentile": 0.00032}, "CVE-2017-9248": {"epss_score": 0.87802, "epss_percentile": 0.99445}, "CVE-2017-9249": {"epss_score": 0.00152, "epss_percentile": 0.36374}, "CVE-2017-9250": {"epss_score": 0.02382, "epss_percentile": 0.84569}, "CVE-2017-9251": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-9252": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-9253": {"epss_score": 0.00258, "epss_percentile": 0.48971}, "CVE-2017-9254": {"epss_score": 0.00258, "epss_percentile": 0.48971}, "CVE-2017-9255": {"epss_score": 0.00258, "epss_percentile": 0.48971}, "CVE-2017-9256": {"epss_score": 0.00258, "epss_percentile": 0.48971}, "CVE-2017-9257": {"epss_score": 0.00258, "epss_percentile": 0.48971}, "CVE-2017-9258": {"epss_score": 0.02405, "epss_percentile": 0.84651}, "CVE-2017-9259": {"epss_score": 0.02671, "epss_percentile": 0.85389}, "CVE-2017-9260": {"epss_score": 0.02358, "epss_percentile": 0.84489}, "CVE-2017-9261": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2017-9262": {"epss_score": 0.0038, "epss_percentile": 0.58913}, "CVE-2017-9263": {"epss_score": 0.00248, "epss_percentile": 0.47981}, "CVE-2017-9264": {"epss_score": 0.00786, "epss_percentile": 0.73295}, "CVE-2017-9265": {"epss_score": 0.01417, "epss_percentile": 0.80148}, "CVE-2017-9267": {"epss_score": 0.0071, "epss_percentile": 0.71721}, "CVE-2017-9268": {"epss_score": 0.00127, "epss_percentile": 0.32845}, "CVE-2017-9269": {"epss_score": 0.00451, "epss_percentile": 0.63115}, "CVE-2017-9270": {"epss_score": 0.00495, "epss_percentile": 0.6512}, "CVE-2017-9271": {"epss_score": 0.0014, "epss_percentile": 0.34781}, "CVE-2017-9272": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-9273": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2017-9274": {"epss_score": 0.00474, "epss_percentile": 0.64148}, "CVE-2017-9275": {"epss_score": 0.00167, "epss_percentile": 0.3833}, "CVE-2017-9276": {"epss_score": 0.00202, "epss_percentile": 0.42442}, "CVE-2017-9277": {"epss_score": 0.00376, "epss_percentile": 0.58657}, "CVE-2017-9278": {"epss_score": 0.00147, "epss_percentile": 0.35664}, "CVE-2017-9279": {"epss_score": 0.00176, "epss_percentile": 0.39404}, "CVE-2017-9280": {"epss_score": 0.00204, "epss_percentile": 0.4262}, "CVE-2017-9281": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2017-9282": {"epss_score": 0.00397, "epss_percentile": 0.59986}, "CVE-2017-9283": {"epss_score": 0.00397, "epss_percentile": 0.59986}, "CVE-2017-9284": {"epss_score": 0.00275, "epss_percentile": 0.50628}, "CVE-2017-9285": {"epss_score": 0.00208, "epss_percentile": 0.433}, "CVE-2017-9286": {"epss_score": 0.0021, "epss_percentile": 0.43484}, "CVE-2017-9287": {"epss_score": 0.38966, "epss_percentile": 0.97132}, "CVE-2017-9288": {"epss_score": 0.02863, "epss_percentile": 0.85857}, "CVE-2017-9289": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-9292": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-9294": {"epss_score": 0.04439, "epss_percentile": 0.88691}, "CVE-2017-9295": {"epss_score": 0.00168, "epss_percentile": 0.3843}, "CVE-2017-9296": {"epss_score": 0.00189, "epss_percentile": 0.40975}, "CVE-2017-9297": {"epss_score": 0.00189, "epss_percentile": 0.40975}, "CVE-2017-9298": {"epss_score": 0.00203, "epss_percentile": 0.42571}, "CVE-2017-9299": {"epss_score": 0.00259, "epss_percentile": 0.49087}, "CVE-2017-9300": {"epss_score": 0.00242, "epss_percentile": 0.47372}, "CVE-2017-9301": {"epss_score": 0.00232, "epss_percentile": 0.45965}, "CVE-2017-9302": {"epss_score": 0.00242, "epss_percentile": 0.47377}, "CVE-2017-9303": {"epss_score": 0.00203, "epss_percentile": 0.42577}, "CVE-2017-9304": {"epss_score": 0.00334, "epss_percentile": 0.55722}, "CVE-2017-9305": {"epss_score": 0.00417, "epss_percentile": 0.61246}, "CVE-2017-9306": {"epss_score": 0.00659, "epss_percentile": 0.70516}, "CVE-2017-9307": {"epss_score": 0.00187, "epss_percentile": 0.40794}, "CVE-2017-9310": {"epss_score": 0.00093, "epss_percentile": 0.26612}, "CVE-2017-9312": {"epss_score": 0.00038, "epss_percentile": 0.11153}, "CVE-2017-9313": {"epss_score": 0.00601, "epss_percentile": 0.68835}, "CVE-2017-9314": {"epss_score": 0.00312, "epss_percentile": 0.53969}, "CVE-2017-9315": {"epss_score": 0.00389, "epss_percentile": 0.59471}, "CVE-2017-9316": {"epss_score": 0.01736, "epss_percentile": 0.82017}, "CVE-2017-9317": {"epss_score": 0.00374, "epss_percentile": 0.58587}, "CVE-2017-9324": {"epss_score": 0.01363, "epss_percentile": 0.79764}, "CVE-2017-9325": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2017-9326": {"epss_score": 0.00318, "epss_percentile": 0.544}, "CVE-2017-9327": {"epss_score": 0.00234, "epss_percentile": 0.46195}, "CVE-2017-9328": {"epss_score": 0.06214, "epss_percentile": 0.90572}, "CVE-2017-9330": {"epss_score": 0.0007, "epss_percentile": 0.21805}, "CVE-2017-9331": {"epss_score": 0.0016, "epss_percentile": 0.37477}, "CVE-2017-9332": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-9333": {"epss_score": 0.00859, "epss_percentile": 0.74521}, "CVE-2017-9334": {"epss_score": 0.00436, "epss_percentile": 0.62451}, "CVE-2017-9336": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-9337": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2017-9338": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2017-9339": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2017-9340": {"epss_score": 0.00211, "epss_percentile": 0.43647}, "CVE-2017-9343": {"epss_score": 0.00784, "epss_percentile": 0.73237}, "CVE-2017-9344": {"epss_score": 0.01179, "epss_percentile": 0.78295}, "CVE-2017-9345": {"epss_score": 0.00682, "epss_percentile": 0.71076}, "CVE-2017-9346": {"epss_score": 0.00459, "epss_percentile": 0.6345}, "CVE-2017-9347": {"epss_score": 0.05567, "epss_percentile": 0.90003}, "CVE-2017-9348": {"epss_score": 0.00777, "epss_percentile": 0.73111}, "CVE-2017-9349": {"epss_score": 0.00811, "epss_percentile": 0.73734}, "CVE-2017-9350": {"epss_score": 0.01464, "epss_percentile": 0.80451}, "CVE-2017-9351": {"epss_score": 0.00768, "epss_percentile": 0.72972}, "CVE-2017-9352": {"epss_score": 0.00492, "epss_percentile": 0.65019}, "CVE-2017-9353": {"epss_score": 0.07995, "epss_percentile": 0.91812}, "CVE-2017-9354": {"epss_score": 0.00781, "epss_percentile": 0.73194}, "CVE-2017-9355": {"epss_score": 0.04206, "epss_percentile": 0.88396}, "CVE-2017-9356": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2017-9358": {"epss_score": 0.01716, "epss_percentile": 0.81906}, "CVE-2017-9359": {"epss_score": 0.00323, "epss_percentile": 0.54897}, "CVE-2017-9360": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2017-9361": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-9362": {"epss_score": 0.00278, "epss_percentile": 0.5089}, "CVE-2017-9363": {"epss_score": 0.05471, "epss_percentile": 0.89908}, "CVE-2017-9364": {"epss_score": 0.00344, "epss_percentile": 0.56536}, "CVE-2017-9365": {"epss_score": 0.00112, "epss_percentile": 0.30501}, "CVE-2017-9366": {"epss_score": 0.00183, "epss_percentile": 0.40321}, "CVE-2017-9367": {"epss_score": 0.0062, "epss_percentile": 0.69445}, "CVE-2017-9368": {"epss_score": 0.00291, "epss_percentile": 0.5215}, "CVE-2017-9369": {"epss_score": 0.0024, "epss_percentile": 0.46969}, "CVE-2017-9370": {"epss_score": 0.00302, "epss_percentile": 0.53166}, "CVE-2017-9371": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2017-9372": {"epss_score": 0.03658, "epss_percentile": 0.87521}, "CVE-2017-9373": {"epss_score": 0.00099, "epss_percentile": 0.28425}, "CVE-2017-9374": {"epss_score": 0.00099, "epss_percentile": 0.28425}, "CVE-2017-9375": {"epss_score": 0.00099, "epss_percentile": 0.28425}, "CVE-2017-9376": {"epss_score": 0.00613, "epss_percentile": 0.69247}, "CVE-2017-9377": {"epss_score": 0.0571, "epss_percentile": 0.9014}, "CVE-2017-9378": {"epss_score": 0.00122, "epss_percentile": 0.32095}, "CVE-2017-9379": {"epss_score": 0.00112, "epss_percentile": 0.30489}, "CVE-2017-9380": {"epss_score": 0.0055, "epss_percentile": 0.67349}, "CVE-2017-9381": {"epss_score": 0.00255, "epss_percentile": 0.48701}, "CVE-2017-9382": {"epss_score": 0.00682, "epss_percentile": 0.71068}, "CVE-2017-9383": {"epss_score": 0.00538, "epss_percentile": 0.66945}, "CVE-2017-9384": {"epss_score": 0.01017, "epss_percentile": 0.76694}, "CVE-2017-9385": {"epss_score": 0.00858, "epss_percentile": 0.74506}, "CVE-2017-9386": {"epss_score": 0.01663, "epss_percentile": 0.81638}, "CVE-2017-9387": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2017-9388": {"epss_score": 0.01017, "epss_percentile": 0.76694}, "CVE-2017-9389": {"epss_score": 0.00838, "epss_percentile": 0.74166}, "CVE-2017-9390": {"epss_score": 0.00858, "epss_percentile": 0.74506}, "CVE-2017-9391": {"epss_score": 0.00569, "epss_percentile": 0.67911}, "CVE-2017-9392": {"epss_score": 0.00569, "epss_percentile": 0.67911}, "CVE-2017-9393": {"epss_score": 0.00419, "epss_percentile": 0.61373}, "CVE-2017-9394": {"epss_score": 0.00179, "epss_percentile": 0.39787}, "CVE-2017-9403": {"epss_score": 0.00962, "epss_percentile": 0.75997}, "CVE-2017-9404": {"epss_score": 0.00962, "epss_percentile": 0.75997}, "CVE-2017-9405": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2017-9406": {"epss_score": 0.01046, "epss_percentile": 0.77032}, "CVE-2017-9407": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2017-9408": {"epss_score": 0.01046, "epss_percentile": 0.77032}, "CVE-2017-9409": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2017-9412": {"epss_score": 0.0248, "epss_percentile": 0.84872}, "CVE-2017-9413": {"epss_score": 0.00217, "epss_percentile": 0.44277}, "CVE-2017-9414": {"epss_score": 0.02123, "epss_percentile": 0.83685}, "CVE-2017-9415": {"epss_score": 0.00829, "epss_percentile": 0.74009}, "CVE-2017-9416": {"epss_score": 0.50415, "epss_percentile": 0.97736}, "CVE-2017-9417": {"epss_score": 0.40673, "epss_percentile": 0.97231}, "CVE-2017-9418": {"epss_score": 0.01046, "epss_percentile": 0.7703}, "CVE-2017-9419": {"epss_score": 0.00188, "epss_percentile": 0.40886}, "CVE-2017-9420": {"epss_score": 0.0041, "epss_percentile": 0.60801}, "CVE-2017-9421": {"epss_score": 0.00256, "epss_percentile": 0.48767}, "CVE-2017-9424": {"epss_score": 0.04732, "epss_percentile": 0.8907}, "CVE-2017-9425": {"epss_score": 0.00235, "epss_percentile": 0.46313}, "CVE-2017-9426": {"epss_score": 0.01478, "epss_percentile": 0.80552}, "CVE-2017-9427": {"epss_score": 0.00352, "epss_percentile": 0.57119}, "CVE-2017-9428": {"epss_score": 0.00379, "epss_percentile": 0.58887}, "CVE-2017-9429": {"epss_score": 0.00772, "epss_percentile": 0.73046}, "CVE-2017-9430": {"epss_score": 0.16467, "epss_percentile": 0.94674}, "CVE-2017-9431": {"epss_score": 0.00832, "epss_percentile": 0.74061}, "CVE-2017-9432": {"epss_score": 0.00832, "epss_percentile": 0.74061}, "CVE-2017-9433": {"epss_score": 0.00538, "epss_percentile": 0.66958}, "CVE-2017-9434": {"epss_score": 0.00472, "epss_percentile": 0.64071}, "CVE-2017-9435": {"epss_score": 0.00331, "epss_percentile": 0.55523}, "CVE-2017-9436": {"epss_score": 0.00233, "epss_percentile": 0.46008}, "CVE-2017-9437": {"epss_score": 0.00351, "epss_percentile": 0.57048}, "CVE-2017-9438": {"epss_score": 0.00614, "epss_percentile": 0.69276}, "CVE-2017-9439": {"epss_score": 0.00303, "epss_percentile": 0.53224}, "CVE-2017-9440": {"epss_score": 0.00303, "epss_percentile": 0.53224}, "CVE-2017-9441": {"epss_score": 0.00185, "epss_percentile": 0.40529}, "CVE-2017-9442": {"epss_score": 0.02261, "epss_percentile": 0.84189}, "CVE-2017-9443": {"epss_score": 0.00546, "epss_percentile": 0.67214}, "CVE-2017-9444": {"epss_score": 0.00112, "epss_percentile": 0.30501}, "CVE-2017-9445": {"epss_score": 0.04426, "epss_percentile": 0.88675}, "CVE-2017-9447": {"epss_score": 0.00694, "epss_percentile": 0.7136}, "CVE-2017-9448": {"epss_score": 0.0014, "epss_percentile": 0.34683}, "CVE-2017-9449": {"epss_score": 0.00344, "epss_percentile": 0.56499}, "CVE-2017-9450": {"epss_score": 0.00173, "epss_percentile": 0.39097}, "CVE-2017-9451": {"epss_score": 0.00217, "epss_percentile": 0.44261}, "CVE-2017-9452": {"epss_score": 0.00171, "epss_percentile": 0.38899}, "CVE-2017-9453": {"epss_score": 0.00065, "epss_percentile": 0.20661}, "CVE-2017-9454": {"epss_score": 0.00786, "epss_percentile": 0.73287}, "CVE-2017-9457": {"epss_score": 0.00096, "epss_percentile": 0.27294}, "CVE-2017-9458": {"epss_score": 0.01272, "epss_percentile": 0.79083}, "CVE-2017-9459": {"epss_score": 0.0059, "epss_percentile": 0.68553}, "CVE-2017-9461": {"epss_score": 0.04032, "epss_percentile": 0.88153}, "CVE-2017-9462": {"epss_score": 0.48699, "epss_percentile": 0.9765}, "CVE-2017-9463": {"epss_score": 0.0022, "epss_percentile": 0.44551}, "CVE-2017-9464": {"epss_score": 0.00192, "epss_percentile": 0.41351}, "CVE-2017-9465": {"epss_score": 0.0023, "epss_percentile": 0.45669}, "CVE-2017-9466": {"epss_score": 0.00174, "epss_percentile": 0.39149}, "CVE-2017-9467": {"epss_score": 0.0059, "epss_percentile": 0.68553}, "CVE-2017-9468": {"epss_score": 0.01363, "epss_percentile": 0.79764}, "CVE-2017-9469": {"epss_score": 0.02189, "epss_percentile": 0.83929}, "CVE-2017-9470": {"epss_score": 0.00226, "epss_percentile": 0.45309}, "CVE-2017-9471": {"epss_score": 0.00227, "epss_percentile": 0.45416}, "CVE-2017-9472": {"epss_score": 0.00196, "epss_percentile": 0.41754}, "CVE-2017-9473": {"epss_score": 0.00262, "epss_percentile": 0.49385}, "CVE-2017-9474": {"epss_score": 0.00196, "epss_percentile": 0.41754}, "CVE-2017-9475": {"epss_score": 0.00552, "epss_percentile": 0.67394}, "CVE-2017-9476": {"epss_score": 0.16075, "epss_percentile": 0.94568}, "CVE-2017-9477": {"epss_score": 0.00156, "epss_percentile": 0.3699}, "CVE-2017-9478": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2017-9479": {"epss_score": 0.0234, "epss_percentile": 0.84429}, "CVE-2017-9480": {"epss_score": 0.00059, "epss_percentile": 0.18717}, "CVE-2017-9481": {"epss_score": 0.00249, "epss_percentile": 0.48044}, "CVE-2017-9482": {"epss_score": 0.02148, "epss_percentile": 0.83775}, "CVE-2017-9483": {"epss_score": 0.00723, "epss_percentile": 0.72012}, "CVE-2017-9484": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2017-9485": {"epss_score": 0.00249, "epss_percentile": 0.48044}, "CVE-2017-9486": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2017-9487": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2017-9488": {"epss_score": 0.00296, "epss_percentile": 0.52543}, "CVE-2017-9489": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2017-9490": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2017-9491": {"epss_score": 0.00263, "epss_percentile": 0.49536}, "CVE-2017-9492": {"epss_score": 0.0034, "epss_percentile": 0.56226}, "CVE-2017-9493": {"epss_score": 0.00202, "epss_percentile": 0.42472}, "CVE-2017-9494": {"epss_score": 0.00185, "epss_percentile": 0.40509}, "CVE-2017-9495": {"epss_score": 0.00064, "epss_percentile": 0.20301}, "CVE-2017-9496": {"epss_score": 0.00084, "epss_percentile": 0.24908}, "CVE-2017-9497": {"epss_score": 0.00126, "epss_percentile": 0.32668}, "CVE-2017-9498": {"epss_score": 0.00022, "epss_percentile": 0.05314}, "CVE-2017-9499": {"epss_score": 0.00318, "epss_percentile": 0.5443}, "CVE-2017-9500": {"epss_score": 0.00429, "epss_percentile": 0.61961}, "CVE-2017-9501": {"epss_score": 0.00318, "epss_percentile": 0.5443}, "CVE-2017-9502": {"epss_score": 0.00555, "epss_percentile": 0.67497}, "CVE-2017-9503": {"epss_score": 0.0007, "epss_percentile": 0.21805}, "CVE-2017-9505": {"epss_score": 0.00387, "epss_percentile": 0.59304}, "CVE-2017-9506": {"epss_score": 0.37506, "epss_percentile": 0.97051}, "CVE-2017-9507": {"epss_score": 0.00257, "epss_percentile": 0.48842}, "CVE-2017-9508": {"epss_score": 0.00223, "epss_percentile": 0.4494}, "CVE-2017-9509": {"epss_score": 0.00257, "epss_percentile": 0.48842}, "CVE-2017-9510": {"epss_score": 0.00257, "epss_percentile": 0.48842}, "CVE-2017-9511": {"epss_score": 0.00856, "epss_percentile": 0.74479}, "CVE-2017-9512": {"epss_score": 0.01571, "epss_percentile": 0.81093}, "CVE-2017-9513": {"epss_score": 0.00117, "epss_percentile": 0.31232}, "CVE-2017-9514": {"epss_score": 0.00311, "epss_percentile": 0.53841}, "CVE-2017-9516": {"epss_score": 0.00895, "epss_percentile": 0.75103}, "CVE-2017-9517": {"epss_score": 0.00159, "epss_percentile": 0.37328}, "CVE-2017-9518": {"epss_score": 0.00159, "epss_percentile": 0.37328}, "CVE-2017-9519": {"epss_score": 0.00159, "epss_percentile": 0.37328}, "CVE-2017-9520": {"epss_score": 0.00202, "epss_percentile": 0.42426}, "CVE-2017-9521": {"epss_score": 0.02322, "epss_percentile": 0.84373}, "CVE-2017-9522": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2017-9523": {"epss_score": 0.00119, "epss_percentile": 0.31558}, "CVE-2017-9524": {"epss_score": 0.04157, "epss_percentile": 0.8833}, "CVE-2017-9525": {"epss_score": 0.00063, "epss_percentile": 0.19831}, "CVE-2017-9526": {"epss_score": 0.00651, "epss_percentile": 0.70297}, "CVE-2017-9527": {"epss_score": 0.00202, "epss_percentile": 0.42415}, "CVE-2017-9528": {"epss_score": 0.01657, "epss_percentile": 0.81605}, "CVE-2017-9529": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2017-9530": {"epss_score": 0.00177, "epss_percentile": 0.39529}, "CVE-2017-9531": {"epss_score": 0.00392, "epss_percentile": 0.59649}, "CVE-2017-9532": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2017-9533": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2017-9534": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2017-9535": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2017-9536": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2017-9537": {"epss_score": 0.01302, "epss_percentile": 0.79299}, "CVE-2017-9538": {"epss_score": 0.05631, "epss_percentile": 0.90069}, "CVE-2017-9542": {"epss_score": 0.02163, "epss_percentile": 0.83833}, "CVE-2017-9543": {"epss_score": 0.00231, "epss_percentile": 0.45796}, "CVE-2017-9544": {"epss_score": 0.79593, "epss_percentile": 0.99046}, "CVE-2017-9545": {"epss_score": 0.00671, "epss_percentile": 0.70799}, "CVE-2017-9546": {"epss_score": 0.00357, "epss_percentile": 0.57403}, "CVE-2017-9547": {"epss_score": 0.0014, "epss_percentile": 0.34683}, "CVE-2017-9548": {"epss_score": 0.0014, "epss_percentile": 0.34683}, "CVE-2017-9551": {"epss_score": 0.0028, "epss_percentile": 0.51042}, "CVE-2017-9552": {"epss_score": 0.00044, "epss_percentile": 0.13492}, "CVE-2017-9553": {"epss_score": 0.00127, "epss_percentile": 0.32864}, "CVE-2017-9554": {"epss_score": 0.57867, "epss_percentile": 0.98087}, "CVE-2017-9555": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2017-9556": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2017-9557": {"epss_score": 0.00305, "epss_percentile": 0.53388}, "CVE-2017-9558": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9559": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9560": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9561": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9562": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9563": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9564": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9565": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9566": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9567": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9568": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9569": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9570": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9571": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9572": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9573": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9574": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9575": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9576": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9577": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9578": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9579": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9580": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9581": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9582": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9583": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9584": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9585": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9586": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9587": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9588": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9589": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9590": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9591": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9592": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9593": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9594": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9595": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9596": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9597": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9598": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9599": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9600": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9601": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2017-9602": {"epss_score": 0.07376, "epss_percentile": 0.91442}, "CVE-2017-9603": {"epss_score": 0.01292, "epss_percentile": 0.79231}, "CVE-2017-9604": {"epss_score": 0.00263, "epss_percentile": 0.49524}, "CVE-2017-9605": {"epss_score": 0.00112, "epss_percentile": 0.30477}, "CVE-2017-9606": {"epss_score": 0.00023, "epss_percentile": 0.05397}, "CVE-2017-9607": {"epss_score": 0.00186, "epss_percentile": 0.40626}, "CVE-2017-9608": {"epss_score": 0.08942, "epss_percentile": 0.92329}, "CVE-2017-9609": {"epss_score": 0.01159, "epss_percentile": 0.78124}, "CVE-2017-9610": {"epss_score": 0.00407, "epss_percentile": 0.60614}, "CVE-2017-9611": {"epss_score": 0.00392, "epss_percentile": 0.59697}, "CVE-2017-9612": {"epss_score": 0.00392, "epss_percentile": 0.59697}, "CVE-2017-9613": {"epss_score": 0.00302, "epss_percentile": 0.53086}, "CVE-2017-9614": {"epss_score": 0.03462, "epss_percentile": 0.87184}, "CVE-2017-9615": {"epss_score": 0.00281, "epss_percentile": 0.51144}, "CVE-2017-9616": {"epss_score": 0.00221, "epss_percentile": 0.44707}, "CVE-2017-9617": {"epss_score": 0.00221, "epss_percentile": 0.44707}, "CVE-2017-9618": {"epss_score": 0.01382, "epss_percentile": 0.79889}, "CVE-2017-9619": {"epss_score": 0.00648, "epss_percentile": 0.70209}, "CVE-2017-9620": {"epss_score": 0.00989, "epss_percentile": 0.76366}, "CVE-2017-9621": {"epss_score": 0.00399, "epss_percentile": 0.60108}, "CVE-2017-9622": {"epss_score": 0.00222, "epss_percentile": 0.44736}, "CVE-2017-9623": {"epss_score": 0.00222, "epss_percentile": 0.44736}, "CVE-2017-9624": {"epss_score": 0.00222, "epss_percentile": 0.44736}, "CVE-2017-9625": {"epss_score": 0.01344, "epss_percentile": 0.79619}, "CVE-2017-9626": {"epss_score": 0.00328, "epss_percentile": 0.55163}, "CVE-2017-9627": {"epss_score": 0.02334, "epss_percentile": 0.84412}, "CVE-2017-9628": {"epss_score": 0.00219, "epss_percentile": 0.44446}, "CVE-2017-9629": {"epss_score": 0.19417, "epss_percentile": 0.95178}, "CVE-2017-9630": {"epss_score": 0.00197, "epss_percentile": 0.41873}, "CVE-2017-9631": {"epss_score": 0.00874, "epss_percentile": 0.74768}, "CVE-2017-9632": {"epss_score": 0.00067, "epss_percentile": 0.21051}, "CVE-2017-9633": {"epss_score": 0.00638, "epss_percentile": 0.69903}, "CVE-2017-9634": {"epss_score": 0.00587, "epss_percentile": 0.68486}, "CVE-2017-9635": {"epss_score": 0.00038, "epss_percentile": 0.11112}, "CVE-2017-9636": {"epss_score": 0.00587, "epss_percentile": 0.68486}, "CVE-2017-9637": {"epss_score": 0.00033, "epss_percentile": 0.09287}, "CVE-2017-9638": {"epss_score": 0.00587, "epss_percentile": 0.68486}, "CVE-2017-9639": {"epss_score": 0.0122, "epss_percentile": 0.78625}, "CVE-2017-9640": {"epss_score": 0.02971, "epss_percentile": 0.86095}, "CVE-2017-9641": {"epss_score": 0.00158, "epss_percentile": 0.37215}, "CVE-2017-9644": {"epss_score": 0.00719, "epss_percentile": 0.71949}, "CVE-2017-9645": {"epss_score": 0.00038, "epss_percentile": 0.11185}, "CVE-2017-9646": {"epss_score": 0.00157, "epss_percentile": 0.37099}, "CVE-2017-9647": {"epss_score": 0.00095, "epss_percentile": 0.27194}, "CVE-2017-9648": {"epss_score": 0.00157, "epss_percentile": 0.37099}, "CVE-2017-9649": {"epss_score": 0.00099, "epss_percentile": 0.28411}, "CVE-2017-9650": {"epss_score": 0.01185, "epss_percentile": 0.78344}, "CVE-2017-9653": {"epss_score": 0.01323, "epss_percentile": 0.79457}, "CVE-2017-9654": {"epss_score": 0.00214, "epss_percentile": 0.43964}, "CVE-2017-9655": {"epss_score": 0.0032, "epss_percentile": 0.54617}, "CVE-2017-9656": {"epss_score": 0.00966, "epss_percentile": 0.76049}, "CVE-2017-9657": {"epss_score": 0.0036, "epss_percentile": 0.57623}, "CVE-2017-9658": {"epss_score": 0.00327, "epss_percentile": 0.55142}, "CVE-2017-9659": {"epss_score": 0.06022, "epss_percentile": 0.90416}, "CVE-2017-9660": {"epss_score": 0.06482, "epss_percentile": 0.90789}, "CVE-2017-9661": {"epss_score": 0.00262, "epss_percentile": 0.49326}, "CVE-2017-9662": {"epss_score": 0.00097, "epss_percentile": 0.27546}, "CVE-2017-9663": {"epss_score": 0.00154, "epss_percentile": 0.36747}, "CVE-2017-9664": {"epss_score": 0.02094, "epss_percentile": 0.83578}, "CVE-2017-9668": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2017-9669": {"epss_score": 0.04376, "epss_percentile": 0.88618}, "CVE-2017-9670": {"epss_score": 0.00208, "epss_percentile": 0.43239}, "CVE-2017-9671": {"epss_score": 0.04376, "epss_percentile": 0.88618}, "CVE-2017-9673": {"epss_score": 0.00131, "epss_percentile": 0.334}, "CVE-2017-9674": {"epss_score": 0.00281, "epss_percentile": 0.51189}, "CVE-2017-9675": {"epss_score": 0.3088, "epss_percentile": 0.96574}, "CVE-2017-9676": {"epss_score": 0.00057, "epss_percentile": 0.18211}, "CVE-2017-9677": {"epss_score": 0.00045, "epss_percentile": 0.13686}, "CVE-2017-9678": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2017-9679": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-9680": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-9681": {"epss_score": 0.00107, "epss_percentile": 0.29632}, "CVE-2017-9682": {"epss_score": 0.00057, "epss_percentile": 0.18211}, "CVE-2017-9683": {"epss_score": 0.00016, "epss_percentile": 0.02699}, "CVE-2017-9684": {"epss_score": 0.00068, "epss_percentile": 0.21316}, "CVE-2017-9685": {"epss_score": 0.00118, "epss_percentile": 0.31433}, "CVE-2017-9686": {"epss_score": 0.00022, "epss_percentile": 0.0516}, "CVE-2017-9687": {"epss_score": 0.00022, "epss_percentile": 0.0516}, "CVE-2017-9689": {"epss_score": 0.00042, "epss_percentile": 0.12579}, "CVE-2017-9690": {"epss_score": 0.0005, "epss_percentile": 0.15684}, "CVE-2017-9691": {"epss_score": 0.00018, "epss_percentile": 0.03757}, "CVE-2017-9692": {"epss_score": 0.00046, "epss_percentile": 0.14398}, "CVE-2017-9693": {"epss_score": 0.00039, "epss_percentile": 0.11633}, "CVE-2017-9694": {"epss_score": 0.00078, "epss_percentile": 0.23568}, "CVE-2017-9696": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-9697": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2017-9698": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-9700": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-9701": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2017-9702": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-9703": {"epss_score": 0.00015, "epss_percentile": 0.02299}, "CVE-2017-9704": {"epss_score": 0.00018, "epss_percentile": 0.03795}, "CVE-2017-9705": {"epss_score": 0.00028, "epss_percentile": 0.07544}, "CVE-2017-9706": {"epss_score": 0.00019, "epss_percentile": 0.04153}, "CVE-2017-9708": {"epss_score": 0.00013, "epss_percentile": 0.01515}, "CVE-2017-9709": {"epss_score": 0.00164, "epss_percentile": 0.37936}, "CVE-2017-9710": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-9711": {"epss_score": 0.00013, "epss_percentile": 0.01565}, "CVE-2017-9712": {"epss_score": 0.00086, "epss_percentile": 0.25289}, "CVE-2017-9714": {"epss_score": 0.00019, "epss_percentile": 0.04153}, "CVE-2017-9715": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-9716": {"epss_score": 0.00016, "epss_percentile": 0.02699}, "CVE-2017-9717": {"epss_score": 0.00111, "epss_percentile": 0.3033}, "CVE-2017-9718": {"epss_score": 0.00013, "epss_percentile": 0.01515}, "CVE-2017-9719": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-9720": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2017-9721": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-9722": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2017-9723": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2017-9724": {"epss_score": 0.00024, "epss_percentile": 0.05664}, "CVE-2017-9725": {"epss_score": 0.00184, "epss_percentile": 0.40454}, "CVE-2017-9726": {"epss_score": 0.00392, "epss_percentile": 0.59697}, "CVE-2017-9727": {"epss_score": 0.00392, "epss_percentile": 0.59697}, "CVE-2017-9728": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2017-9729": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2017-9730": {"epss_score": 0.01149, "epss_percentile": 0.7802}, "CVE-2017-9731": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2017-9732": {"epss_score": 0.04524, "epss_percentile": 0.88804}, "CVE-2017-9735": {"epss_score": 0.0084, "epss_percentile": 0.74214}, "CVE-2017-9736": {"epss_score": 0.04422, "epss_percentile": 0.8867}, "CVE-2017-9739": {"epss_score": 0.00392, "epss_percentile": 0.59697}, "CVE-2017-9740": {"epss_score": 0.00407, "epss_percentile": 0.60614}, "CVE-2017-9741": {"epss_score": 0.00799, "epss_percentile": 0.73522}, "CVE-2017-9742": {"epss_score": 0.02696, "epss_percentile": 0.85444}, "CVE-2017-9743": {"epss_score": 0.01267, "epss_percentile": 0.79016}, "CVE-2017-9744": {"epss_score": 0.01026, "epss_percentile": 0.76796}, "CVE-2017-9745": {"epss_score": 0.01034, "epss_percentile": 0.76892}, "CVE-2017-9746": {"epss_score": 0.04547, "epss_percentile": 0.88836}, "CVE-2017-9747": {"epss_score": 0.01959, "epss_percentile": 0.83052}, "CVE-2017-9748": {"epss_score": 0.02696, "epss_percentile": 0.85444}, "CVE-2017-9749": {"epss_score": 0.04778, "epss_percentile": 0.89133}, "CVE-2017-9750": {"epss_score": 0.01451, "epss_percentile": 0.80363}, "CVE-2017-9751": {"epss_score": 0.01071, "epss_percentile": 0.77272}, "CVE-2017-9752": {"epss_score": 0.01081, "epss_percentile": 0.77369}, "CVE-2017-9753": {"epss_score": 0.00993, "epss_percentile": 0.76412}, "CVE-2017-9754": {"epss_score": 0.01026, "epss_percentile": 0.76796}, "CVE-2017-9755": {"epss_score": 0.01071, "epss_percentile": 0.77272}, "CVE-2017-9756": {"epss_score": 0.02696, "epss_percentile": 0.85444}, "CVE-2017-9757": {"epss_score": 0.77889, "epss_percentile": 0.98958}, "CVE-2017-9758": {"epss_score": 0.005, "epss_percentile": 0.65299}, "CVE-2017-9759": {"epss_score": 0.00284, "epss_percentile": 0.5149}, "CVE-2017-9761": {"epss_score": 0.00227, "epss_percentile": 0.45427}, "CVE-2017-9762": {"epss_score": 0.00203, "epss_percentile": 0.42502}, "CVE-2017-9763": {"epss_score": 0.01357, "epss_percentile": 0.79716}, "CVE-2017-9764": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2017-9765": {"epss_score": 0.2525, "epss_percentile": 0.96003}, "CVE-2017-9766": {"epss_score": 0.00889, "epss_percentile": 0.7501}, "CVE-2017-9767": {"epss_score": 0.0028, "epss_percentile": 0.51012}, "CVE-2017-9769": {"epss_score": 0.77698, "epss_percentile": 0.98948}, "CVE-2017-9770": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2017-9771": {"epss_score": 0.00783, "epss_percentile": 0.73222}, "CVE-2017-9772": {"epss_score": 0.0664, "epss_percentile": 0.9091}, "CVE-2017-9773": {"epss_score": 0.00277, "epss_percentile": 0.50801}, "CVE-2017-9774": {"epss_score": 0.07066, "epss_percentile": 0.91225}, "CVE-2017-9775": {"epss_score": 0.00778, "epss_percentile": 0.73124}, "CVE-2017-9776": {"epss_score": 0.01248, "epss_percentile": 0.78866}, "CVE-2017-9778": {"epss_score": 0.00298, "epss_percentile": 0.52776}, "CVE-2017-9779": {"epss_score": 0.00093, "epss_percentile": 0.26755}, "CVE-2017-9780": {"epss_score": 0.00105, "epss_percentile": 0.29373}, "CVE-2017-9781": {"epss_score": 0.00398, "epss_percentile": 0.60057}, "CVE-2017-9782": {"epss_score": 0.00396, "epss_percentile": 0.59895}, "CVE-2017-9783": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2017-9785": {"epss_score": 0.02466, "epss_percentile": 0.84836}, "CVE-2017-9786": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2017-9787": {"epss_score": 0.13883, "epss_percentile": 0.94084}, "CVE-2017-9788": {"epss_score": 0.52641, "epss_percentile": 0.97833}, "CVE-2017-9789": {"epss_score": 0.11126, "epss_percentile": 0.93231}, "CVE-2017-9790": {"epss_score": 0.02141, "epss_percentile": 0.83752}, "CVE-2017-9791": {"epss_score": 0.94239, "epss_percentile": 0.99924}, "CVE-2017-9792": {"epss_score": 0.00207, "epss_percentile": 0.4314}, "CVE-2017-9793": {"epss_score": 0.13427, "epss_percentile": 0.9396}, "CVE-2017-9794": {"epss_score": 0.00459, "epss_percentile": 0.63465}, "CVE-2017-9795": {"epss_score": 0.0263, "epss_percentile": 0.85279}, "CVE-2017-9796": {"epss_score": 0.00154, "epss_percentile": 0.36745}, "CVE-2017-9797": {"epss_score": 0.00345, "epss_percentile": 0.56587}, "CVE-2017-9798": {"epss_score": 0.9384, "epss_percentile": 0.99854}, "CVE-2017-9799": {"epss_score": 0.00887, "epss_percentile": 0.74965}, "CVE-2017-9800": {"epss_score": 0.53578, "epss_percentile": 0.97882}, "CVE-2017-9801": {"epss_score": 0.01321, "epss_percentile": 0.79444}, "CVE-2017-9802": {"epss_score": 0.00584, "epss_percentile": 0.68359}, "CVE-2017-9803": {"epss_score": 0.00342, "epss_percentile": 0.56352}, "CVE-2017-9804": {"epss_score": 0.12074, "epss_percentile": 0.93559}, "CVE-2017-9805": {"epss_score": 0.94322, "epss_percentile": 0.99947}, "CVE-2017-9806": {"epss_score": 0.01822, "epss_percentile": 0.82416}, "CVE-2017-9807": {"epss_score": 0.14043, "epss_percentile": 0.94121}, "CVE-2017-9808": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2017-9809": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2017-9810": {"epss_score": 0.01078, "epss_percentile": 0.77349}, "CVE-2017-9811": {"epss_score": 0.24673, "epss_percentile": 0.95945}, "CVE-2017-9812": {"epss_score": 0.2717, "epss_percentile": 0.96215}, "CVE-2017-9813": {"epss_score": 0.03675, "epss_percentile": 0.87551}, "CVE-2017-9814": {"epss_score": 0.00274, "epss_percentile": 0.50517}, "CVE-2017-9815": {"epss_score": 0.00467, "epss_percentile": 0.63816}, "CVE-2017-9816": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2017-9818": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2017-9819": {"epss_score": 0.00554, "epss_percentile": 0.67447}, "CVE-2017-9820": {"epss_score": 0.00577, "epss_percentile": 0.6815}, "CVE-2017-9821": {"epss_score": 0.00577, "epss_percentile": 0.6815}, "CVE-2017-9822": {"epss_score": 0.94293, "epss_percentile": 0.99937}, "CVE-2017-9828": {"epss_score": 0.58307, "epss_percentile": 0.98108}, "CVE-2017-9829": {"epss_score": 0.05926, "epss_percentile": 0.90332}, "CVE-2017-9830": {"epss_score": 0.10851, "epss_percentile": 0.93134}, "CVE-2017-9831": {"epss_score": 0.00232, "epss_percentile": 0.45902}, "CVE-2017-9832": {"epss_score": 0.00232, "epss_percentile": 0.45902}, "CVE-2017-9833": {"epss_score": 0.90326, "epss_percentile": 0.99577}, "CVE-2017-9834": {"epss_score": 0.1247, "epss_percentile": 0.93682}, "CVE-2017-9835": {"epss_score": 0.00353, "epss_percentile": 0.57151}, "CVE-2017-9836": {"epss_score": 0.00159, "epss_percentile": 0.3742}, "CVE-2017-9838": {"epss_score": 0.00185, "epss_percentile": 0.40499}, "CVE-2017-9839": {"epss_score": 0.00218, "epss_percentile": 0.44427}, "CVE-2017-9840": {"epss_score": 0.00747, "epss_percentile": 0.72573}, "CVE-2017-9841": {"epss_score": 0.94202, "epss_percentile": 0.99917}, "CVE-2017-9843": {"epss_score": 0.00269, "epss_percentile": 0.5017}, "CVE-2017-9844": {"epss_score": 0.01857, "epss_percentile": 0.82576}, "CVE-2017-9845": {"epss_score": 0.04189, "epss_percentile": 0.88374}, "CVE-2017-9846": {"epss_score": 0.01438, "epss_percentile": 0.80284}, "CVE-2017-9847": {"epss_score": 0.00189, "epss_percentile": 0.40989}, "CVE-2017-9848": {"epss_score": 0.00456, "epss_percentile": 0.63326}, "CVE-2017-9851": {"epss_score": 0.00378, "epss_percentile": 0.58782}, "CVE-2017-9852": {"epss_score": 0.00327, "epss_percentile": 0.55115}, "CVE-2017-9853": {"epss_score": 0.00327, "epss_percentile": 0.55115}, "CVE-2017-9854": {"epss_score": 0.002, "epss_percentile": 0.42237}, "CVE-2017-9855": {"epss_score": 0.00424, "epss_percentile": 0.6166}, "CVE-2017-9856": {"epss_score": 0.00176, "epss_percentile": 0.394}, "CVE-2017-9857": {"epss_score": 0.00118, "epss_percentile": 0.31484}, "CVE-2017-9858": {"epss_score": 0.00765, "epss_percentile": 0.72913}, "CVE-2017-9859": {"epss_score": 0.00171, "epss_percentile": 0.38901}, "CVE-2017-9860": {"epss_score": 0.00435, "epss_percentile": 0.62324}, "CVE-2017-9861": {"epss_score": 0.00159, "epss_percentile": 0.37338}, "CVE-2017-9862": {"epss_score": 0.00339, "epss_percentile": 0.56162}, "CVE-2017-9863": {"epss_score": 0.00249, "epss_percentile": 0.48053}, "CVE-2017-9864": {"epss_score": 0.0044, "epss_percentile": 0.62619}, "CVE-2017-9865": {"epss_score": 0.0076, "epss_percentile": 0.72815}, "CVE-2017-9868": {"epss_score": 0.00111, "epss_percentile": 0.30313}, "CVE-2017-9869": {"epss_score": 0.00806, "epss_percentile": 0.73663}, "CVE-2017-9870": {"epss_score": 0.00402, "epss_percentile": 0.60314}, "CVE-2017-9871": {"epss_score": 0.00227, "epss_percentile": 0.45427}, "CVE-2017-9872": {"epss_score": 0.034, "epss_percentile": 0.87068}, "CVE-2017-9873": {"epss_score": 0.00392, "epss_percentile": 0.59649}, "CVE-2017-9874": {"epss_score": 0.00392, "epss_percentile": 0.59649}, "CVE-2017-9875": {"epss_score": 0.00392, "epss_percentile": 0.59649}, "CVE-2017-9876": {"epss_score": 0.00392, "epss_percentile": 0.59649}, "CVE-2017-9877": {"epss_score": 0.00392, "epss_percentile": 0.59649}, "CVE-2017-9878": {"epss_score": 0.00392, "epss_percentile": 0.59649}, "CVE-2017-9879": {"epss_score": 0.00392, "epss_percentile": 0.59649}, "CVE-2017-9880": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2017-9881": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2017-9882": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2017-9883": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2017-9884": {"epss_score": 0.00219, "epss_percentile": 0.44523}, "CVE-2017-9885": {"epss_score": 0.00288, "epss_percentile": 0.51934}, "CVE-2017-9886": {"epss_score": 0.00288, "epss_percentile": 0.51934}, "CVE-2017-9887": {"epss_score": 0.00288, "epss_percentile": 0.51934}, "CVE-2017-9888": {"epss_score": 0.00288, "epss_percentile": 0.51934}, "CVE-2017-9889": {"epss_score": 0.00288, "epss_percentile": 0.51934}, "CVE-2017-9890": {"epss_score": 0.00203, "epss_percentile": 0.4255}, "CVE-2017-9891": {"epss_score": 0.00203, "epss_percentile": 0.4255}, "CVE-2017-9892": {"epss_score": 0.00203, "epss_percentile": 0.4255}, "CVE-2017-9893": {"epss_score": 0.00175, "epss_percentile": 0.39369}, "CVE-2017-9894": {"epss_score": 0.00175, "epss_percentile": 0.39369}, "CVE-2017-9895": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2017-9896": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2017-9897": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2017-9898": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2017-9899": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2017-9900": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2017-9901": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2017-9902": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2017-9903": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2017-9904": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2017-9905": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2017-9906": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2017-9907": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2017-9908": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2017-9909": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2017-9910": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2017-9911": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2017-9912": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2017-9913": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2017-9914": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2017-9915": {"epss_score": 0.00298, "epss_percentile": 0.52835}, "CVE-2017-9916": {"epss_score": 0.00136, "epss_percentile": 0.34196}, "CVE-2017-9917": {"epss_score": 0.00136, "epss_percentile": 0.34176}, "CVE-2017-9918": {"epss_score": 0.00125, "epss_percentile": 0.32565}, "CVE-2017-9919": {"epss_score": 0.00125, "epss_percentile": 0.32565}, "CVE-2017-9920": {"epss_score": 0.00125, "epss_percentile": 0.32565}, "CVE-2017-9921": {"epss_score": 0.00061, "epss_percentile": 0.19389}, "CVE-2017-9922": {"epss_score": 0.00125, "epss_percentile": 0.32565}, "CVE-2017-9923": {"epss_score": 0.00125, "epss_percentile": 0.32565}, "CVE-2017-9924": {"epss_score": 0.00937, "epss_percentile": 0.757}, "CVE-2017-9925": {"epss_score": 0.00937, "epss_percentile": 0.757}, "CVE-2017-9926": {"epss_score": 0.00513, "epss_percentile": 0.65877}, "CVE-2017-9927": {"epss_score": 0.00513, "epss_percentile": 0.65877}, "CVE-2017-9928": {"epss_score": 0.00421, "epss_percentile": 0.61508}, "CVE-2017-9929": {"epss_score": 0.00421, "epss_percentile": 0.61508}, "CVE-2017-9930": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2017-9931": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2017-9932": {"epss_score": 0.00441, "epss_percentile": 0.62685}, "CVE-2017-9933": {"epss_score": 0.00046, "epss_percentile": 0.14147}, "CVE-2017-9934": {"epss_score": 0.00411, "epss_percentile": 0.60867}, "CVE-2017-9935": {"epss_score": 0.00628, "epss_percentile": 0.69652}, "CVE-2017-9936": {"epss_score": 0.06042, "epss_percentile": 0.90429}, "CVE-2017-9937": {"epss_score": 0.00868, "epss_percentile": 0.74671}, "CVE-2017-9938": {"epss_score": 0.00973, "epss_percentile": 0.76145}, "CVE-2017-9939": {"epss_score": 0.0206, "epss_percentile": 0.83441}, "CVE-2017-9940": {"epss_score": 0.00178, "epss_percentile": 0.39717}, "CVE-2017-9941": {"epss_score": 0.00194, "epss_percentile": 0.41572}, "CVE-2017-9942": {"epss_score": 0.00046, "epss_percentile": 0.14361}, "CVE-2017-9944": {"epss_score": 0.02605, "epss_percentile": 0.85219}, "CVE-2017-9945": {"epss_score": 0.00145, "epss_percentile": 0.35505}, "CVE-2017-9946": {"epss_score": 0.00749, "epss_percentile": 0.72609}, "CVE-2017-9947": {"epss_score": 0.07807, "epss_percentile": 0.91692}, "CVE-2017-9948": {"epss_score": 0.04865, "epss_percentile": 0.89225}, "CVE-2017-9949": {"epss_score": 0.00338, "epss_percentile": 0.56136}, "CVE-2017-9951": {"epss_score": 0.01674, "epss_percentile": 0.81693}, "CVE-2017-9953": {"epss_score": 0.00656, "epss_percentile": 0.70439}, "CVE-2017-9954": {"epss_score": 0.00416, "epss_percentile": 0.61172}, "CVE-2017-9955": {"epss_score": 0.00307, "epss_percentile": 0.53499}, "CVE-2017-9956": {"epss_score": 0.00486, "epss_percentile": 0.6475}, "CVE-2017-9957": {"epss_score": 0.00443, "epss_percentile": 0.62791}, "CVE-2017-9958": {"epss_score": 0.00055, "epss_percentile": 0.17436}, "CVE-2017-9959": {"epss_score": 0.00055, "epss_percentile": 0.17471}, "CVE-2017-9960": {"epss_score": 0.00237, "epss_percentile": 0.46652}, "CVE-2017-9961": {"epss_score": 0.00098, "epss_percentile": 0.27724}, "CVE-2017-9962": {"epss_score": 0.00566, "epss_percentile": 0.67824}, "CVE-2017-9963": {"epss_score": 0.00147, "epss_percentile": 0.35713}, "CVE-2017-9964": {"epss_score": 0.0053, "epss_percentile": 0.66611}, "CVE-2017-9965": {"epss_score": 0.00211, "epss_percentile": 0.43626}, "CVE-2017-9966": {"epss_score": 0.00529, "epss_percentile": 0.66598}, "CVE-2017-9967": {"epss_score": 0.00091, "epss_percentile": 0.26382}, "CVE-2017-9968": {"epss_score": 0.00162, "epss_percentile": 0.37683}, "CVE-2017-9969": {"epss_score": 0.00078, "epss_percentile": 0.2357}, "CVE-2017-9970": {"epss_score": 0.0279, "epss_percentile": 0.85667}, "CVE-2017-9977": {"epss_score": 0.00407, "epss_percentile": 0.60575}, "CVE-2017-9978": {"epss_score": 0.16418, "epss_percentile": 0.94657}, "CVE-2017-9979": {"epss_score": 0.02404, "epss_percentile": 0.84647}, "CVE-2017-9980": {"epss_score": 0.044, "epss_percentile": 0.88645}, "CVE-2017-9982": {"epss_score": 0.0154, "epss_percentile": 0.80942}, "CVE-2017-9984": {"epss_score": 0.00106, "epss_percentile": 0.29481}, "CVE-2017-9985": {"epss_score": 0.00114, "epss_percentile": 0.30804}, "CVE-2017-9986": {"epss_score": 0.00096, "epss_percentile": 0.27299}, "CVE-2017-9987": {"epss_score": 0.00421, "epss_percentile": 0.61488}, "CVE-2017-9988": {"epss_score": 0.00625, "epss_percentile": 0.69593}, "CVE-2017-9989": {"epss_score": 0.00625, "epss_percentile": 0.69593}, "CVE-2017-9990": {"epss_score": 0.00968, "epss_percentile": 0.76083}, "CVE-2017-9991": {"epss_score": 0.00455, "epss_percentile": 0.63314}, "CVE-2017-9992": {"epss_score": 0.00699, "epss_percentile": 0.71434}, "CVE-2017-9993": {"epss_score": 0.56172, "epss_percentile": 0.98011}, "CVE-2017-9994": {"epss_score": 0.00422, "epss_percentile": 0.61572}, "CVE-2017-9995": {"epss_score": 0.00378, "epss_percentile": 0.58807}, "CVE-2017-9996": {"epss_score": 0.00389, "epss_percentile": 0.59497}, "CVE-2017-9998": {"epss_score": 0.00578, "epss_percentile": 0.68201}, "CVE-2018-0001": {"epss_score": 0.04221, "epss_percentile": 0.8841}, "CVE-2018-0002": {"epss_score": 0.0184, "epss_percentile": 0.82491}, "CVE-2018-0003": {"epss_score": 0.00224, "epss_percentile": 0.45047}, "CVE-2018-0004": {"epss_score": 0.00288, "epss_percentile": 0.51867}, "CVE-2018-0005": {"epss_score": 0.00224, "epss_percentile": 0.45063}, "CVE-2018-0006": {"epss_score": 0.00297, "epss_percentile": 0.52714}, "CVE-2018-0007": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2018-0008": {"epss_score": 0.00151, "epss_percentile": 0.36318}, "CVE-2018-0009": {"epss_score": 0.00181, "epss_percentile": 0.40073}, "CVE-2018-0010": {"epss_score": 0.00144, "epss_percentile": 0.35289}, "CVE-2018-0011": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2018-0012": {"epss_score": 0.00036, "epss_percentile": 0.10541}, "CVE-2018-0013": {"epss_score": 0.00239, "epss_percentile": 0.46921}, "CVE-2018-0014": {"epss_score": 0.00113, "epss_percentile": 0.30679}, "CVE-2018-0015": {"epss_score": 0.0028, "epss_percentile": 0.51036}, "CVE-2018-0016": {"epss_score": 0.11246, "epss_percentile": 0.93277}, "CVE-2018-0017": {"epss_score": 0.0049, "epss_percentile": 0.64918}, "CVE-2018-0018": {"epss_score": 0.00265, "epss_percentile": 0.49778}, "CVE-2018-0019": {"epss_score": 0.00337, "epss_percentile": 0.56029}, "CVE-2018-0020": {"epss_score": 0.00353, "epss_percentile": 0.57183}, "CVE-2018-0021": {"epss_score": 0.0016, "epss_percentile": 0.37492}, "CVE-2018-0022": {"epss_score": 0.01351, "epss_percentile": 0.79678}, "CVE-2018-0023": {"epss_score": 0.00093, "epss_percentile": 0.26635}, "CVE-2018-0024": {"epss_score": 0.0006, "epss_percentile": 0.19115}, "CVE-2018-0025": {"epss_score": 0.00222, "epss_percentile": 0.44744}, "CVE-2018-0026": {"epss_score": 0.00769, "epss_percentile": 0.7299}, "CVE-2018-0027": {"epss_score": 0.00865, "epss_percentile": 0.74626}, "CVE-2018-0029": {"epss_score": 0.00153, "epss_percentile": 0.36635}, "CVE-2018-0030": {"epss_score": 0.00511, "epss_percentile": 0.65814}, "CVE-2018-0031": {"epss_score": 0.0019, "epss_percentile": 0.41006}, "CVE-2018-0032": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2018-0034": {"epss_score": 0.00605, "epss_percentile": 0.68993}, "CVE-2018-0035": {"epss_score": 0.00264, "epss_percentile": 0.4968}, "CVE-2018-0037": {"epss_score": 0.01815, "epss_percentile": 0.82383}, "CVE-2018-0038": {"epss_score": 0.00487, "epss_percentile": 0.64781}, "CVE-2018-0039": {"epss_score": 0.00261, "epss_percentile": 0.4925}, "CVE-2018-0040": {"epss_score": 0.0017, "epss_percentile": 0.38749}, "CVE-2018-0041": {"epss_score": 0.00487, "epss_percentile": 0.64781}, "CVE-2018-0042": {"epss_score": 0.0033, "epss_percentile": 0.55457}, "CVE-2018-0043": {"epss_score": 0.00679, "epss_percentile": 0.71008}, "CVE-2018-0044": {"epss_score": 0.00422, "epss_percentile": 0.61552}, "CVE-2018-0045": {"epss_score": 0.00679, "epss_percentile": 0.71008}, "CVE-2018-0046": {"epss_score": 0.00789, "epss_percentile": 0.73364}, "CVE-2018-0047": {"epss_score": 0.00317, "epss_percentile": 0.54369}, "CVE-2018-0048": {"epss_score": 0.01419, "epss_percentile": 0.80164}, "CVE-2018-0049": {"epss_score": 0.00843, "epss_percentile": 0.7426}, "CVE-2018-0050": {"epss_score": 0.00516, "epss_percentile": 0.66047}, "CVE-2018-0051": {"epss_score": 0.00406, "epss_percentile": 0.60539}, "CVE-2018-0052": {"epss_score": 0.08911, "epss_percentile": 0.92314}, "CVE-2018-0053": {"epss_score": 0.0005, "epss_percentile": 0.15821}, "CVE-2018-0054": {"epss_score": 0.00186, "epss_percentile": 0.40591}, "CVE-2018-0055": {"epss_score": 0.00241, "epss_percentile": 0.47281}, "CVE-2018-0056": {"epss_score": 0.00167, "epss_percentile": 0.38358}, "CVE-2018-0057": {"epss_score": 0.00341, "epss_percentile": 0.56324}, "CVE-2018-0058": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2018-0059": {"epss_score": 0.00133, "epss_percentile": 0.33708}, "CVE-2018-0060": {"epss_score": 0.002, "epss_percentile": 0.42203}, "CVE-2018-0061": {"epss_score": 0.0043, "epss_percentile": 0.62014}, "CVE-2018-0062": {"epss_score": 0.00488, "epss_percentile": 0.64834}, "CVE-2018-0063": {"epss_score": 0.00116, "epss_percentile": 0.31185}, "CVE-2018-0086": {"epss_score": 0.01646, "epss_percentile": 0.81536}, "CVE-2018-0087": {"epss_score": 0.00279, "epss_percentile": 0.50973}, "CVE-2018-0088": {"epss_score": 0.00068, "epss_percentile": 0.21374}, "CVE-2018-0089": {"epss_score": 0.00685, "epss_percentile": 0.71141}, "CVE-2018-0090": {"epss_score": 0.0181, "epss_percentile": 0.82362}, "CVE-2018-0091": {"epss_score": 0.00232, "epss_percentile": 0.45882}, "CVE-2018-0092": {"epss_score": 0.00112, "epss_percentile": 0.30575}, "CVE-2018-0093": {"epss_score": 0.00332, "epss_percentile": 0.55611}, "CVE-2018-0094": {"epss_score": 0.01409, "epss_percentile": 0.80068}, "CVE-2018-0095": {"epss_score": 0.00086, "epss_percentile": 0.25432}, "CVE-2018-0096": {"epss_score": 0.00254, "epss_percentile": 0.48531}, "CVE-2018-0097": {"epss_score": 0.00252, "epss_percentile": 0.4837}, "CVE-2018-0098": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2018-0099": {"epss_score": 0.0176, "epss_percentile": 0.82147}, "CVE-2018-0100": {"epss_score": 0.00111, "epss_percentile": 0.30338}, "CVE-2018-0101": {"epss_score": 0.91639, "epss_percentile": 0.9966}, "CVE-2018-0102": {"epss_score": 0.00256, "epss_percentile": 0.48826}, "CVE-2018-0103": {"epss_score": 0.00382, "epss_percentile": 0.59036}, "CVE-2018-0104": {"epss_score": 0.01206, "epss_percentile": 0.78516}, "CVE-2018-0105": {"epss_score": 0.0072, "epss_percentile": 0.71961}, "CVE-2018-0106": {"epss_score": 0.00068, "epss_percentile": 0.21332}, "CVE-2018-0107": {"epss_score": 0.00329, "epss_percentile": 0.55382}, "CVE-2018-0108": {"epss_score": 0.00523, "epss_percentile": 0.66305}, "CVE-2018-0109": {"epss_score": 0.00247, "epss_percentile": 0.47822}, "CVE-2018-0110": {"epss_score": 0.0041, "epss_percentile": 0.60808}, "CVE-2018-0111": {"epss_score": 0.0089, "epss_percentile": 0.75031}, "CVE-2018-0112": {"epss_score": 0.01256, "epss_percentile": 0.78938}, "CVE-2018-0113": {"epss_score": 0.01108, "epss_percentile": 0.77641}, "CVE-2018-0114": {"epss_score": 0.84691, "epss_percentile": 0.99301}, "CVE-2018-0115": {"epss_score": 0.00109, "epss_percentile": 0.29919}, "CVE-2018-0116": {"epss_score": 0.00355, "epss_percentile": 0.57312}, "CVE-2018-0117": {"epss_score": 0.00484, "epss_percentile": 0.6467}, "CVE-2018-0118": {"epss_score": 0.00437, "epss_percentile": 0.6251}, "CVE-2018-0119": {"epss_score": 0.00513, "epss_percentile": 0.65879}, "CVE-2018-0120": {"epss_score": 0.00207, "epss_percentile": 0.43191}, "CVE-2018-0121": {"epss_score": 0.0364, "epss_percentile": 0.87488}, "CVE-2018-0122": {"epss_score": 0.00123, "epss_percentile": 0.32312}, "CVE-2018-0123": {"epss_score": 0.00078, "epss_percentile": 0.23754}, "CVE-2018-0124": {"epss_score": 0.01095, "epss_percentile": 0.77504}, "CVE-2018-0125": {"epss_score": 0.43613, "epss_percentile": 0.97394}, "CVE-2018-0127": {"epss_score": 0.91541, "epss_percentile": 0.99651}, "CVE-2018-0128": {"epss_score": 0.00235, "epss_percentile": 0.46239}, "CVE-2018-0129": {"epss_score": 0.00235, "epss_percentile": 0.46239}, "CVE-2018-0130": {"epss_score": 0.0094, "epss_percentile": 0.75738}, "CVE-2018-0131": {"epss_score": 0.00409, "epss_percentile": 0.60693}, "CVE-2018-0132": {"epss_score": 0.01409, "epss_percentile": 0.80068}, "CVE-2018-0134": {"epss_score": 0.00362, "epss_percentile": 0.5778}, "CVE-2018-0135": {"epss_score": 0.00208, "epss_percentile": 0.4328}, "CVE-2018-0136": {"epss_score": 0.01379, "epss_percentile": 0.79854}, "CVE-2018-0137": {"epss_score": 0.00662, "epss_percentile": 0.70608}, "CVE-2018-0138": {"epss_score": 0.00227, "epss_percentile": 0.4537}, "CVE-2018-0139": {"epss_score": 0.01409, "epss_percentile": 0.80068}, "CVE-2018-0140": {"epss_score": 0.00463, "epss_percentile": 0.6369}, "CVE-2018-0141": {"epss_score": 0.00097, "epss_percentile": 0.27559}, "CVE-2018-0144": {"epss_score": 0.00332, "epss_percentile": 0.55611}, "CVE-2018-0145": {"epss_score": 0.00319, "epss_percentile": 0.54563}, "CVE-2018-0146": {"epss_score": 0.00145, "epss_percentile": 0.35403}, "CVE-2018-0147": {"epss_score": 0.03023, "epss_percentile": 0.8623}, "CVE-2018-0148": {"epss_score": 0.00329, "epss_percentile": 0.55382}, "CVE-2018-0149": {"epss_score": 0.00249, "epss_percentile": 0.48014}, "CVE-2018-0150": {"epss_score": 0.02911, "epss_percentile": 0.85972}, "CVE-2018-0151": {"epss_score": 0.05855, "epss_percentile": 0.90266}, "CVE-2018-0152": {"epss_score": 0.02729, "epss_percentile": 0.85534}, "CVE-2018-0154": {"epss_score": 0.08958, "epss_percentile": 0.92336}, "CVE-2018-0155": {"epss_score": 0.11218, "epss_percentile": 0.93269}, "CVE-2018-0156": {"epss_score": 0.09701, "epss_percentile": 0.92668}, "CVE-2018-0157": {"epss_score": 0.02747, "epss_percentile": 0.85575}, "CVE-2018-0158": {"epss_score": 0.11321, "epss_percentile": 0.93308}, "CVE-2018-0159": {"epss_score": 0.06436, "epss_percentile": 0.90756}, "CVE-2018-0160": {"epss_score": 0.00439, "epss_percentile": 0.6259}, "CVE-2018-0161": {"epss_score": 0.01658, "epss_percentile": 0.81611}, "CVE-2018-0163": {"epss_score": 0.00251, "epss_percentile": 0.48274}, "CVE-2018-0164": {"epss_score": 0.00484, "epss_percentile": 0.6467}, "CVE-2018-0165": {"epss_score": 0.00256, "epss_percentile": 0.48826}, "CVE-2018-0167": {"epss_score": 0.02378, "epss_percentile": 0.84556}, "CVE-2018-0169": {"epss_score": 0.00168, "epss_percentile": 0.38442}, "CVE-2018-0170": {"epss_score": 0.01965, "epss_percentile": 0.8308}, "CVE-2018-0171": {"epss_score": 0.93123, "epss_percentile": 0.99776}, "CVE-2018-0172": {"epss_score": 0.04655, "epss_percentile": 0.8897}, "CVE-2018-0173": {"epss_score": 0.04069, "epss_percentile": 0.88204}, "CVE-2018-0174": {"epss_score": 0.04069, "epss_percentile": 0.88204}, "CVE-2018-0175": {"epss_score": 0.02469, "epss_percentile": 0.84841}, "CVE-2018-0176": {"epss_score": 0.00168, "epss_percentile": 0.38442}, "CVE-2018-0177": {"epss_score": 0.02646, "epss_percentile": 0.8533}, "CVE-2018-0179": {"epss_score": 0.0202, "epss_percentile": 0.83294}, "CVE-2018-0180": {"epss_score": 0.01727, "epss_percentile": 0.81968}, "CVE-2018-0181": {"epss_score": 0.04082, "epss_percentile": 0.88221}, "CVE-2018-0182": {"epss_score": 0.00242, "epss_percentile": 0.47406}, "CVE-2018-0183": {"epss_score": 0.00062, "epss_percentile": 0.19645}, "CVE-2018-0184": {"epss_score": 0.00062, "epss_percentile": 0.19645}, "CVE-2018-0185": {"epss_score": 0.00242, "epss_percentile": 0.47406}, "CVE-2018-0186": {"epss_score": 0.00318, "epss_percentile": 0.54411}, "CVE-2018-0187": {"epss_score": 0.00209, "epss_percentile": 0.43427}, "CVE-2018-0188": {"epss_score": 0.00318, "epss_percentile": 0.54411}, "CVE-2018-0189": {"epss_score": 0.00336, "epss_percentile": 0.55941}, "CVE-2018-0190": {"epss_score": 0.00318, "epss_percentile": 0.54411}, "CVE-2018-0193": {"epss_score": 0.00242, "epss_percentile": 0.47406}, "CVE-2018-0194": {"epss_score": 0.00242, "epss_percentile": 0.47406}, "CVE-2018-0195": {"epss_score": 0.00294, "epss_percentile": 0.52398}, "CVE-2018-0196": {"epss_score": 0.00142, "epss_percentile": 0.35077}, "CVE-2018-0197": {"epss_score": 0.00149, "epss_percentile": 0.36021}, "CVE-2018-0198": {"epss_score": 0.0072, "epss_percentile": 0.71961}, "CVE-2018-0199": {"epss_score": 0.00481, "epss_percentile": 0.64482}, "CVE-2018-0200": {"epss_score": 0.0017, "epss_percentile": 0.38765}, "CVE-2018-0201": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2018-0202": {"epss_score": 0.02654, "epss_percentile": 0.85352}, "CVE-2018-0203": {"epss_score": 0.00749, "epss_percentile": 0.72591}, "CVE-2018-0204": {"epss_score": 0.01687, "epss_percentile": 0.81757}, "CVE-2018-0205": {"epss_score": 0.00267, "epss_percentile": 0.50002}, "CVE-2018-0206": {"epss_score": 0.00451, "epss_percentile": 0.63156}, "CVE-2018-0207": {"epss_score": 0.00462, "epss_percentile": 0.63575}, "CVE-2018-0208": {"epss_score": 0.00248, "epss_percentile": 0.47963}, "CVE-2018-0209": {"epss_score": 0.0067, "epss_percentile": 0.70774}, "CVE-2018-0210": {"epss_score": 0.00304, "epss_percentile": 0.53309}, "CVE-2018-0211": {"epss_score": 0.00092, "epss_percentile": 0.26531}, "CVE-2018-0212": {"epss_score": 0.00332, "epss_percentile": 0.55611}, "CVE-2018-0213": {"epss_score": 0.0092, "epss_percentile": 0.7547}, "CVE-2018-0214": {"epss_score": 0.00272, "epss_percentile": 0.50347}, "CVE-2018-0215": {"epss_score": 0.00146, "epss_percentile": 0.35619}, "CVE-2018-0216": {"epss_score": 0.00105, "epss_percentile": 0.29345}, "CVE-2018-0217": {"epss_score": 0.00184, "epss_percentile": 0.40441}, "CVE-2018-0218": {"epss_score": 0.00499, "epss_percentile": 0.65276}, "CVE-2018-0219": {"epss_score": 0.00332, "epss_percentile": 0.55611}, "CVE-2018-0220": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2018-0221": {"epss_score": 0.00356, "epss_percentile": 0.5739}, "CVE-2018-0222": {"epss_score": 0.01808, "epss_percentile": 0.82357}, "CVE-2018-0223": {"epss_score": 0.0017, "epss_percentile": 0.38765}, "CVE-2018-0224": {"epss_score": 0.00072, "epss_percentile": 0.22429}, "CVE-2018-0225": {"epss_score": 0.00271, "epss_percentile": 0.50343}, "CVE-2018-0226": {"epss_score": 0.01278, "epss_percentile": 0.79127}, "CVE-2018-0227": {"epss_score": 0.01079, "epss_percentile": 0.77356}, "CVE-2018-0228": {"epss_score": 0.04157, "epss_percentile": 0.88329}, "CVE-2018-0229": {"epss_score": 0.01391, "epss_percentile": 0.79947}, "CVE-2018-0230": {"epss_score": 0.00837, "epss_percentile": 0.74161}, "CVE-2018-0231": {"epss_score": 0.00488, "epss_percentile": 0.64863}, "CVE-2018-0233": {"epss_score": 0.00484, "epss_percentile": 0.6467}, "CVE-2018-0234": {"epss_score": 0.01172, "epss_percentile": 0.78229}, "CVE-2018-0235": {"epss_score": 0.00145, "epss_percentile": 0.35505}, "CVE-2018-0237": {"epss_score": 0.00606, "epss_percentile": 0.69}, "CVE-2018-0238": {"epss_score": 0.0483, "epss_percentile": 0.8919}, "CVE-2018-0239": {"epss_score": 0.02702, "epss_percentile": 0.85455}, "CVE-2018-0240": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2018-0241": {"epss_score": 0.00256, "epss_percentile": 0.48826}, "CVE-2018-0242": {"epss_score": 0.00332, "epss_percentile": 0.55611}, "CVE-2018-0243": {"epss_score": 0.00227, "epss_percentile": 0.4537}, "CVE-2018-0244": {"epss_score": 0.00227, "epss_percentile": 0.4537}, "CVE-2018-0245": {"epss_score": 0.00495, "epss_percentile": 0.651}, "CVE-2018-0247": {"epss_score": 0.00464, "epss_percentile": 0.63704}, "CVE-2018-0248": {"epss_score": 0.00314, "epss_percentile": 0.5409}, "CVE-2018-0249": {"epss_score": 0.00149, "epss_percentile": 0.36039}, "CVE-2018-0250": {"epss_score": 0.00264, "epss_percentile": 0.49682}, "CVE-2018-0251": {"epss_score": 0.00373, "epss_percentile": 0.58513}, "CVE-2018-0252": {"epss_score": 0.00484, "epss_percentile": 0.6467}, "CVE-2018-0253": {"epss_score": 0.0429, "epss_percentile": 0.88501}, "CVE-2018-0254": {"epss_score": 0.00227, "epss_percentile": 0.4537}, "CVE-2018-0255": {"epss_score": 0.00192, "epss_percentile": 0.41307}, "CVE-2018-0256": {"epss_score": 0.00319, "epss_percentile": 0.54554}, "CVE-2018-0257": {"epss_score": 0.00229, "epss_percentile": 0.45596}, "CVE-2018-0258": {"epss_score": 0.2969, "epss_percentile": 0.96466}, "CVE-2018-0259": {"epss_score": 0.00178, "epss_percentile": 0.39639}, "CVE-2018-0260": {"epss_score": 0.00712, "epss_percentile": 0.71748}, "CVE-2018-0262": {"epss_score": 0.04177, "epss_percentile": 0.88352}, "CVE-2018-0263": {"epss_score": 0.00235, "epss_percentile": 0.46216}, "CVE-2018-0264": {"epss_score": 0.00836, "epss_percentile": 0.74137}, "CVE-2018-0266": {"epss_score": 0.00157, "epss_percentile": 0.37087}, "CVE-2018-0267": {"epss_score": 0.00067, "epss_percentile": 0.21067}, "CVE-2018-0268": {"epss_score": 0.09641, "epss_percentile": 0.92636}, "CVE-2018-0269": {"epss_score": 0.00565, "epss_percentile": 0.67783}, "CVE-2018-0270": {"epss_score": 0.00192, "epss_percentile": 0.41307}, "CVE-2018-0271": {"epss_score": 0.05265, "epss_percentile": 0.89673}, "CVE-2018-0272": {"epss_score": 0.00404, "epss_percentile": 0.60453}, "CVE-2018-0273": {"epss_score": 0.0082, "epss_percentile": 0.7389}, "CVE-2018-0274": {"epss_score": 0.00547, "epss_percentile": 0.6723}, "CVE-2018-0275": {"epss_score": 0.00069, "epss_percentile": 0.21481}, "CVE-2018-0276": {"epss_score": 0.00319, "epss_percentile": 0.54563}, "CVE-2018-0277": {"epss_score": 0.00387, "epss_percentile": 0.59316}, "CVE-2018-0278": {"epss_score": 0.00786, "epss_percentile": 0.73288}, "CVE-2018-0279": {"epss_score": 0.02274, "epss_percentile": 0.84225}, "CVE-2018-0280": {"epss_score": 0.00791, "epss_percentile": 0.73387}, "CVE-2018-0281": {"epss_score": 0.00433, "epss_percentile": 0.62224}, "CVE-2018-0282": {"epss_score": 0.00359, "epss_percentile": 0.57617}, "CVE-2018-0283": {"epss_score": 0.00433, "epss_percentile": 0.62224}, "CVE-2018-0284": {"epss_score": 0.00445, "epss_percentile": 0.6287}, "CVE-2018-0285": {"epss_score": 0.00882, "epss_percentile": 0.74882}, "CVE-2018-0286": {"epss_score": 0.0082, "epss_percentile": 0.7389}, "CVE-2018-0287": {"epss_score": 0.02006, "epss_percentile": 0.83235}, "CVE-2018-0288": {"epss_score": 0.00537, "epss_percentile": 0.66892}, "CVE-2018-0289": {"epss_score": 0.00267, "epss_percentile": 0.50002}, "CVE-2018-0290": {"epss_score": 0.00476, "epss_percentile": 0.64252}, "CVE-2018-0291": {"epss_score": 0.00907, "epss_percentile": 0.75264}, "CVE-2018-0292": {"epss_score": 0.00235, "epss_percentile": 0.46199}, "CVE-2018-0293": {"epss_score": 0.01939, "epss_percentile": 0.82974}, "CVE-2018-0294": {"epss_score": 0.00255, "epss_percentile": 0.48674}, "CVE-2018-0295": {"epss_score": 0.0073, "epss_percentile": 0.72149}, "CVE-2018-0296": {"epss_score": 0.94404, "epss_percentile": 0.99973}, "CVE-2018-0297": {"epss_score": 0.00167, "epss_percentile": 0.38315}, "CVE-2018-0298": {"epss_score": 0.0133, "epss_percentile": 0.79511}, "CVE-2018-0299": {"epss_score": 0.00907, "epss_percentile": 0.75264}, "CVE-2018-0300": {"epss_score": 0.0183, "epss_percentile": 0.82445}, "CVE-2018-0301": {"epss_score": 0.01353, "epss_percentile": 0.79696}, "CVE-2018-0302": {"epss_score": 0.00161, "epss_percentile": 0.37544}, "CVE-2018-0303": {"epss_score": 0.00394, "epss_percentile": 0.59796}, "CVE-2018-0304": {"epss_score": 0.02266, "epss_percentile": 0.84199}, "CVE-2018-0305": {"epss_score": 0.01106, "epss_percentile": 0.77616}, "CVE-2018-0306": {"epss_score": 0.00134, "epss_percentile": 0.33858}, "CVE-2018-0307": {"epss_score": 0.00134, "epss_percentile": 0.33858}, "CVE-2018-0308": {"epss_score": 0.0147, "epss_percentile": 0.80492}, "CVE-2018-0309": {"epss_score": 0.01058, "epss_percentile": 0.77142}, "CVE-2018-0310": {"epss_score": 0.0323, "epss_percentile": 0.86695}, "CVE-2018-0311": {"epss_score": 0.01377, "epss_percentile": 0.79845}, "CVE-2018-0312": {"epss_score": 0.02686, "epss_percentile": 0.85427}, "CVE-2018-0313": {"epss_score": 0.00761, "epss_percentile": 0.7282}, "CVE-2018-0314": {"epss_score": 0.0503, "epss_percentile": 0.89413}, "CVE-2018-0315": {"epss_score": 0.14933, "epss_percentile": 0.94327}, "CVE-2018-0316": {"epss_score": 0.01141, "epss_percentile": 0.77958}, "CVE-2018-0317": {"epss_score": 0.00786, "epss_percentile": 0.73295}, "CVE-2018-0318": {"epss_score": 0.02366, "epss_percentile": 0.84516}, "CVE-2018-0319": {"epss_score": 0.02366, "epss_percentile": 0.84516}, "CVE-2018-0320": {"epss_score": 0.01921, "epss_percentile": 0.82898}, "CVE-2018-0321": {"epss_score": 0.026, "epss_percentile": 0.85205}, "CVE-2018-0322": {"epss_score": 0.01146, "epss_percentile": 0.78001}, "CVE-2018-0323": {"epss_score": 0.00681, "epss_percentile": 0.71056}, "CVE-2018-0324": {"epss_score": 0.002, "epss_percentile": 0.42241}, "CVE-2018-0325": {"epss_score": 0.00791, "epss_percentile": 0.73387}, "CVE-2018-0326": {"epss_score": 0.00313, "epss_percentile": 0.54062}, "CVE-2018-0327": {"epss_score": 0.00451, "epss_percentile": 0.63156}, "CVE-2018-0328": {"epss_score": 0.00251, "epss_percentile": 0.48334}, "CVE-2018-0329": {"epss_score": 0.00316, "epss_percentile": 0.54232}, "CVE-2018-0330": {"epss_score": 0.00146, "epss_percentile": 0.35579}, "CVE-2018-0331": {"epss_score": 0.00319, "epss_percentile": 0.54484}, "CVE-2018-0332": {"epss_score": 0.01409, "epss_percentile": 0.80068}, "CVE-2018-0333": {"epss_score": 0.00169, "epss_percentile": 0.38536}, "CVE-2018-0334": {"epss_score": 0.00076, "epss_percentile": 0.23122}, "CVE-2018-0335": {"epss_score": 0.00525, "epss_percentile": 0.66374}, "CVE-2018-0336": {"epss_score": 0.01196, "epss_percentile": 0.78437}, "CVE-2018-0337": {"epss_score": 0.00127, "epss_percentile": 0.3281}, "CVE-2018-0338": {"epss_score": 0.00097, "epss_percentile": 0.27598}, "CVE-2018-0339": {"epss_score": 0.00232, "epss_percentile": 0.45882}, "CVE-2018-0340": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2018-0341": {"epss_score": 0.02656, "epss_percentile": 0.85357}, "CVE-2018-0342": {"epss_score": 0.00238, "epss_percentile": 0.46767}, "CVE-2018-0343": {"epss_score": 0.01646, "epss_percentile": 0.81536}, "CVE-2018-0344": {"epss_score": 0.00376, "epss_percentile": 0.5866}, "CVE-2018-0345": {"epss_score": 0.00955, "epss_percentile": 0.75915}, "CVE-2018-0346": {"epss_score": 0.00477, "epss_percentile": 0.64336}, "CVE-2018-0347": {"epss_score": 0.00137, "epss_percentile": 0.34291}, "CVE-2018-0348": {"epss_score": 0.00359, "epss_percentile": 0.57604}, "CVE-2018-0349": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2018-0350": {"epss_score": 0.005, "epss_percentile": 0.65321}, "CVE-2018-0351": {"epss_score": 0.00137, "epss_percentile": 0.34291}, "CVE-2018-0352": {"epss_score": 0.00056, "epss_percentile": 0.17821}, "CVE-2018-0353": {"epss_score": 0.0082, "epss_percentile": 0.73887}, "CVE-2018-0354": {"epss_score": 0.00451, "epss_percentile": 0.63156}, "CVE-2018-0355": {"epss_score": 0.00304, "epss_percentile": 0.53269}, "CVE-2018-0356": {"epss_score": 0.00451, "epss_percentile": 0.63156}, "CVE-2018-0357": {"epss_score": 0.00451, "epss_percentile": 0.63156}, "CVE-2018-0358": {"epss_score": 0.01409, "epss_percentile": 0.80068}, "CVE-2018-0359": {"epss_score": 0.00089, "epss_percentile": 0.25892}, "CVE-2018-0360": {"epss_score": 0.01086, "epss_percentile": 0.77411}, "CVE-2018-0361": {"epss_score": 0.00642, "epss_percentile": 0.70019}, "CVE-2018-0362": {"epss_score": 0.00164, "epss_percentile": 0.37903}, "CVE-2018-0363": {"epss_score": 0.00329, "epss_percentile": 0.55382}, "CVE-2018-0364": {"epss_score": 0.00306, "epss_percentile": 0.53433}, "CVE-2018-0365": {"epss_score": 0.00192, "epss_percentile": 0.41307}, "CVE-2018-0366": {"epss_score": 0.00332, "epss_percentile": 0.55611}, "CVE-2018-0367": {"epss_score": 0.00144, "epss_percentile": 0.353}, "CVE-2018-0368": {"epss_score": 0.00061, "epss_percentile": 0.19507}, "CVE-2018-0369": {"epss_score": 0.01257, "epss_percentile": 0.78945}, "CVE-2018-0370": {"epss_score": 0.01109, "epss_percentile": 0.77647}, "CVE-2018-0371": {"epss_score": 0.00334, "epss_percentile": 0.55691}, "CVE-2018-0372": {"epss_score": 0.01134, "epss_percentile": 0.77891}, "CVE-2018-0373": {"epss_score": 0.00075, "epss_percentile": 0.23043}, "CVE-2018-0374": {"epss_score": 0.09452, "epss_percentile": 0.92554}, "CVE-2018-0375": {"epss_score": 0.01904, "epss_percentile": 0.82789}, "CVE-2018-0376": {"epss_score": 0.09452, "epss_percentile": 0.92554}, "CVE-2018-0377": {"epss_score": 0.09452, "epss_percentile": 0.92554}, "CVE-2018-0378": {"epss_score": 0.01403, "epss_percentile": 0.80034}, "CVE-2018-0379": {"epss_score": 0.00407, "epss_percentile": 0.60583}, "CVE-2018-0380": {"epss_score": 0.00358, "epss_percentile": 0.57496}, "CVE-2018-0381": {"epss_score": 0.00182, "epss_percentile": 0.40155}, "CVE-2018-0382": {"epss_score": 0.00697, "epss_percentile": 0.71403}, "CVE-2018-0383": {"epss_score": 0.00383, "epss_percentile": 0.59116}, "CVE-2018-0384": {"epss_score": 0.00383, "epss_percentile": 0.59116}, "CVE-2018-0385": {"epss_score": 0.00297, "epss_percentile": 0.52712}, "CVE-2018-0386": {"epss_score": 0.00305, "epss_percentile": 0.53313}, "CVE-2018-0387": {"epss_score": 0.01196, "epss_percentile": 0.78438}, "CVE-2018-0388": {"epss_score": 0.00341, "epss_percentile": 0.5633}, "CVE-2018-0389": {"epss_score": 0.00901, "epss_percentile": 0.75182}, "CVE-2018-0390": {"epss_score": 0.0021, "epss_percentile": 0.43447}, "CVE-2018-0391": {"epss_score": 0.00444, "epss_percentile": 0.62808}, "CVE-2018-0392": {"epss_score": 0.00043, "epss_percentile": 0.13307}, "CVE-2018-0393": {"epss_score": 0.00127, "epss_percentile": 0.32787}, "CVE-2018-0394": {"epss_score": 0.00581, "epss_percentile": 0.68279}, "CVE-2018-0395": {"epss_score": 0.00328, "epss_percentile": 0.55294}, "CVE-2018-0396": {"epss_score": 0.00351, "epss_percentile": 0.57078}, "CVE-2018-0397": {"epss_score": 0.00784, "epss_percentile": 0.73229}, "CVE-2018-0398": {"epss_score": 0.00961, "epss_percentile": 0.75979}, "CVE-2018-0399": {"epss_score": 0.00716, "epss_percentile": 0.71853}, "CVE-2018-0400": {"epss_score": 0.00481, "epss_percentile": 0.64515}, "CVE-2018-0401": {"epss_score": 0.00296, "epss_percentile": 0.52605}, "CVE-2018-0402": {"epss_score": 0.00195, "epss_percentile": 0.41634}, "CVE-2018-0403": {"epss_score": 0.00689, "epss_percentile": 0.71236}, "CVE-2018-0404": {"epss_score": 0.00583, "epss_percentile": 0.68335}, "CVE-2018-0405": {"epss_score": 0.04307, "epss_percentile": 0.88523}, "CVE-2018-0406": {"epss_score": 0.0017, "epss_percentile": 0.38765}, "CVE-2018-0407": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2018-0408": {"epss_score": 0.00219, "epss_percentile": 0.44534}, "CVE-2018-0409": {"epss_score": 0.01042, "epss_percentile": 0.76975}, "CVE-2018-0410": {"epss_score": 0.02086, "epss_percentile": 0.83549}, "CVE-2018-0411": {"epss_score": 0.00332, "epss_percentile": 0.55611}, "CVE-2018-0412": {"epss_score": 0.00169, "epss_percentile": 0.38564}, "CVE-2018-0413": {"epss_score": 0.00321, "epss_percentile": 0.54685}, "CVE-2018-0414": {"epss_score": 0.00363, "epss_percentile": 0.57824}, "CVE-2018-0415": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2018-0416": {"epss_score": 0.00285, "epss_percentile": 0.51645}, "CVE-2018-0417": {"epss_score": 0.00467, "epss_percentile": 0.63832}, "CVE-2018-0418": {"epss_score": 0.01211, "epss_percentile": 0.78553}, "CVE-2018-0419": {"epss_score": 0.00242, "epss_percentile": 0.47342}, "CVE-2018-0420": {"epss_score": 0.03032, "epss_percentile": 0.86252}, "CVE-2018-0421": {"epss_score": 0.01495, "epss_percentile": 0.80681}, "CVE-2018-0422": {"epss_score": 0.00438, "epss_percentile": 0.62551}, "CVE-2018-0423": {"epss_score": 0.02886, "epss_percentile": 0.85912}, "CVE-2018-0424": {"epss_score": 0.00832, "epss_percentile": 0.74057}, "CVE-2018-0425": {"epss_score": 0.08051, "epss_percentile": 0.91854}, "CVE-2018-0426": {"epss_score": 0.09707, "epss_percentile": 0.92671}, "CVE-2018-0427": {"epss_score": 0.01531, "epss_percentile": 0.8089}, "CVE-2018-0428": {"epss_score": 0.00131, "epss_percentile": 0.33347}, "CVE-2018-0429": {"epss_score": 0.00113, "epss_percentile": 0.30622}, "CVE-2018-0430": {"epss_score": 0.0083, "epss_percentile": 0.74023}, "CVE-2018-0431": {"epss_score": 0.0083, "epss_percentile": 0.74023}, "CVE-2018-0432": {"epss_score": 0.01293, "epss_percentile": 0.7924}, "CVE-2018-0433": {"epss_score": 0.00098, "epss_percentile": 0.27703}, "CVE-2018-0434": {"epss_score": 0.00125, "epss_percentile": 0.32563}, "CVE-2018-0435": {"epss_score": 0.01598, "epss_percentile": 0.81249}, "CVE-2018-0436": {"epss_score": 0.00235, "epss_percentile": 0.46203}, "CVE-2018-0437": {"epss_score": 0.05829, "epss_percentile": 0.9024}, "CVE-2018-0438": {"epss_score": 0.03999, "epss_percentile": 0.88091}, "CVE-2018-0439": {"epss_score": 0.00321, "epss_percentile": 0.54685}, "CVE-2018-0440": {"epss_score": 0.0006, "epss_percentile": 0.19034}, "CVE-2018-0441": {"epss_score": 0.00305, "epss_percentile": 0.53391}, "CVE-2018-0442": {"epss_score": 0.01225, "epss_percentile": 0.78682}, "CVE-2018-0443": {"epss_score": 0.00996, "epss_percentile": 0.76442}, "CVE-2018-0444": {"epss_score": 0.00106, "epss_percentile": 0.29408}, "CVE-2018-0445": {"epss_score": 0.00205, "epss_percentile": 0.42679}, "CVE-2018-0446": {"epss_score": 0.00189, "epss_percentile": 0.41}, "CVE-2018-0447": {"epss_score": 0.00242, "epss_percentile": 0.47333}, "CVE-2018-0448": {"epss_score": 0.0011, "epss_percentile": 0.30159}, "CVE-2018-0449": {"epss_score": 0.00038, "epss_percentile": 0.11183}, "CVE-2018-0450": {"epss_score": 0.00319, "epss_percentile": 0.54563}, "CVE-2018-0451": {"epss_score": 0.00187, "epss_percentile": 0.40728}, "CVE-2018-0452": {"epss_score": 0.00319, "epss_percentile": 0.54563}, "CVE-2018-0453": {"epss_score": 0.00131, "epss_percentile": 0.33358}, "CVE-2018-0454": {"epss_score": 0.02084, "epss_percentile": 0.83544}, "CVE-2018-0455": {"epss_score": 0.00589, "epss_percentile": 0.68521}, "CVE-2018-0456": {"epss_score": 0.00939, "epss_percentile": 0.75716}, "CVE-2018-0457": {"epss_score": 0.00418, "epss_percentile": 0.61348}, "CVE-2018-0458": {"epss_score": 0.00451, "epss_percentile": 0.63156}, "CVE-2018-0459": {"epss_score": 0.00265, "epss_percentile": 0.49774}, "CVE-2018-0460": {"epss_score": 0.01104, "epss_percentile": 0.77597}, "CVE-2018-0461": {"epss_score": 0.00268, "epss_percentile": 0.50094}, "CVE-2018-0462": {"epss_score": 0.00336, "epss_percentile": 0.55929}, "CVE-2018-0463": {"epss_score": 0.00648, "epss_percentile": 0.70217}, "CVE-2018-0464": {"epss_score": 0.02163, "epss_percentile": 0.83833}, "CVE-2018-0465": {"epss_score": 0.00179, "epss_percentile": 0.39806}, "CVE-2018-0466": {"epss_score": 0.00342, "epss_percentile": 0.56382}, "CVE-2018-0467": {"epss_score": 0.01457, "epss_percentile": 0.80399}, "CVE-2018-0468": {"epss_score": 0.0006, "epss_percentile": 0.19159}, "CVE-2018-0469": {"epss_score": 0.0076, "epss_percentile": 0.72806}, "CVE-2018-0470": {"epss_score": 0.01406, "epss_percentile": 0.80053}, "CVE-2018-0471": {"epss_score": 0.00225, "epss_percentile": 0.45142}, "CVE-2018-0472": {"epss_score": 0.14922, "epss_percentile": 0.94324}, "CVE-2018-0473": {"epss_score": 0.01495, "epss_percentile": 0.80681}, "CVE-2018-0474": {"epss_score": 0.00182, "epss_percentile": 0.4027}, "CVE-2018-0475": {"epss_score": 0.00256, "epss_percentile": 0.48826}, "CVE-2018-0476": {"epss_score": 0.03064, "epss_percentile": 0.86322}, "CVE-2018-0477": {"epss_score": 0.00041, "epss_percentile": 0.12387}, "CVE-2018-0480": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2018-0481": {"epss_score": 0.00041, "epss_percentile": 0.12387}, "CVE-2018-0482": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2018-0483": {"epss_score": 0.00179, "epss_percentile": 0.39787}, "CVE-2018-0484": {"epss_score": 0.0018, "epss_percentile": 0.39883}, "CVE-2018-0485": {"epss_score": 0.03805, "epss_percentile": 0.8775}, "CVE-2018-0486": {"epss_score": 0.00921, "epss_percentile": 0.75477}, "CVE-2018-0487": {"epss_score": 0.0487, "epss_percentile": 0.89231}, "CVE-2018-0488": {"epss_score": 0.03563, "epss_percentile": 0.87356}, "CVE-2018-0489": {"epss_score": 0.00243, "epss_percentile": 0.47454}, "CVE-2018-0490": {"epss_score": 0.01035, "epss_percentile": 0.76898}, "CVE-2018-0491": {"epss_score": 0.08038, "epss_percentile": 0.91847}, "CVE-2018-0492": {"epss_score": 0.01725, "epss_percentile": 0.81954}, "CVE-2018-0493": {"epss_score": 0.00964, "epss_percentile": 0.76031}, "CVE-2018-0494": {"epss_score": 0.72891, "epss_percentile": 0.98729}, "CVE-2018-0495": {"epss_score": 0.00242, "epss_percentile": 0.47386}, "CVE-2018-0496": {"epss_score": 0.00531, "epss_percentile": 0.6667}, "CVE-2018-0497": {"epss_score": 0.00619, "epss_percentile": 0.69428}, "CVE-2018-0498": {"epss_score": 0.00208, "epss_percentile": 0.43208}, "CVE-2018-0499": {"epss_score": 0.00404, "epss_percentile": 0.60429}, "CVE-2018-0500": {"epss_score": 0.01212, "epss_percentile": 0.78559}, "CVE-2018-0501": {"epss_score": 0.00132, "epss_percentile": 0.3358}, "CVE-2018-0502": {"epss_score": 0.01175, "epss_percentile": 0.78261}, "CVE-2018-0503": {"epss_score": 0.00383, "epss_percentile": 0.59082}, "CVE-2018-0504": {"epss_score": 0.01612, "epss_percentile": 0.81334}, "CVE-2018-0505": {"epss_score": 0.00427, "epss_percentile": 0.61906}, "CVE-2018-0506": {"epss_score": 0.01605, "epss_percentile": 0.81289}, "CVE-2018-0507": {"epss_score": 0.00172, "epss_percentile": 0.38972}, "CVE-2018-0508": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-0509": {"epss_score": 0.00106, "epss_percentile": 0.29399}, "CVE-2018-0510": {"epss_score": 0.00983, "epss_percentile": 0.76307}, "CVE-2018-0511": {"epss_score": 0.00141, "epss_percentile": 0.34916}, "CVE-2018-0512": {"epss_score": 0.00254, "epss_percentile": 0.48512}, "CVE-2018-0513": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2018-0514": {"epss_score": 0.02108, "epss_percentile": 0.83639}, "CVE-2018-0515": {"epss_score": 0.00222, "epss_percentile": 0.44798}, "CVE-2018-0516": {"epss_score": 0.00222, "epss_percentile": 0.44798}, "CVE-2018-0517": {"epss_score": 0.00206, "epss_percentile": 0.43058}, "CVE-2018-0518": {"epss_score": 0.00114, "epss_percentile": 0.30753}, "CVE-2018-0519": {"epss_score": 0.00171, "epss_percentile": 0.38894}, "CVE-2018-0520": {"epss_score": 0.00073, "epss_percentile": 0.22581}, "CVE-2018-0521": {"epss_score": 0.00242, "epss_percentile": 0.47332}, "CVE-2018-0522": {"epss_score": 0.00851, "epss_percentile": 0.74401}, "CVE-2018-0523": {"epss_score": 0.00299, "epss_percentile": 0.5286}, "CVE-2018-0524": {"epss_score": 0.0093, "epss_percentile": 0.75606}, "CVE-2018-0525": {"epss_score": 0.00624, "epss_percentile": 0.69567}, "CVE-2018-0526": {"epss_score": 0.00255, "epss_percentile": 0.4863}, "CVE-2018-0527": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2018-0528": {"epss_score": 0.00176, "epss_percentile": 0.39463}, "CVE-2018-0529": {"epss_score": 0.00387, "epss_percentile": 0.59305}, "CVE-2018-0530": {"epss_score": 0.00611, "epss_percentile": 0.69184}, "CVE-2018-0531": {"epss_score": 0.00172, "epss_percentile": 0.38976}, "CVE-2018-0532": {"epss_score": 0.00182, "epss_percentile": 0.40259}, "CVE-2018-0533": {"epss_score": 0.01348, "epss_percentile": 0.7966}, "CVE-2018-0534": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-0535": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-0536": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-0537": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-0538": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-0539": {"epss_score": 0.00511, "epss_percentile": 0.65825}, "CVE-2018-0540": {"epss_score": 0.00206, "epss_percentile": 0.43058}, "CVE-2018-0541": {"epss_score": 0.0073, "epss_percentile": 0.72144}, "CVE-2018-0542": {"epss_score": 0.01845, "epss_percentile": 0.82508}, "CVE-2018-0543": {"epss_score": 0.00171, "epss_percentile": 0.38824}, "CVE-2018-0544": {"epss_score": 0.00171, "epss_percentile": 0.38824}, "CVE-2018-0545": {"epss_score": 0.0266, "epss_percentile": 0.85365}, "CVE-2018-0546": {"epss_score": 0.00276, "epss_percentile": 0.5076}, "CVE-2018-0547": {"epss_score": 0.00276, "epss_percentile": 0.5076}, "CVE-2018-0548": {"epss_score": 0.00141, "epss_percentile": 0.34901}, "CVE-2018-0549": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2018-0550": {"epss_score": 0.00135, "epss_percentile": 0.33929}, "CVE-2018-0551": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2018-0552": {"epss_score": 0.00222, "epss_percentile": 0.44798}, "CVE-2018-0553": {"epss_score": 0.00111, "epss_percentile": 0.30391}, "CVE-2018-0554": {"epss_score": 0.00242, "epss_percentile": 0.47332}, "CVE-2018-0555": {"epss_score": 0.00451, "epss_percentile": 0.63126}, "CVE-2018-0556": {"epss_score": 0.00299, "epss_percentile": 0.5286}, "CVE-2018-0557": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2018-0558": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2018-0559": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2018-0560": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2018-0561": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2018-0562": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2018-0563": {"epss_score": 0.00185, "epss_percentile": 0.40468}, "CVE-2018-0564": {"epss_score": 0.00651, "epss_percentile": 0.70285}, "CVE-2018-0565": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2018-0566": {"epss_score": 0.00176, "epss_percentile": 0.39463}, "CVE-2018-0567": {"epss_score": 0.00274, "epss_percentile": 0.50557}, "CVE-2018-0568": {"epss_score": 0.01023, "epss_percentile": 0.76771}, "CVE-2018-0569": {"epss_score": 0.01054, "epss_percentile": 0.77105}, "CVE-2018-0570": {"epss_score": 0.00195, "epss_percentile": 0.41641}, "CVE-2018-0571": {"epss_score": 0.00167, "epss_percentile": 0.38353}, "CVE-2018-0572": {"epss_score": 0.00204, "epss_percentile": 0.426}, "CVE-2018-0573": {"epss_score": 0.00173, "epss_percentile": 0.39135}, "CVE-2018-0574": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2018-0575": {"epss_score": 0.00169, "epss_percentile": 0.38619}, "CVE-2018-0576": {"epss_score": 0.00211, "epss_percentile": 0.43637}, "CVE-2018-0577": {"epss_score": 0.00228, "epss_percentile": 0.45472}, "CVE-2018-0578": {"epss_score": 0.00125, "epss_percentile": 0.32552}, "CVE-2018-0579": {"epss_score": 0.00192, "epss_percentile": 0.41313}, "CVE-2018-0580": {"epss_score": 0.0034, "epss_percentile": 0.56268}, "CVE-2018-0581": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2018-0582": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2018-0583": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2018-0584": {"epss_score": 0.00627, "epss_percentile": 0.69637}, "CVE-2018-0585": {"epss_score": 0.00417, "epss_percentile": 0.61237}, "CVE-2018-0586": {"epss_score": 0.00236, "epss_percentile": 0.46409}, "CVE-2018-0587": {"epss_score": 0.00157, "epss_percentile": 0.37141}, "CVE-2018-0588": {"epss_score": 0.003, "epss_percentile": 0.52953}, "CVE-2018-0589": {"epss_score": 0.00168, "epss_percentile": 0.38523}, "CVE-2018-0590": {"epss_score": 0.00168, "epss_percentile": 0.38523}, "CVE-2018-0591": {"epss_score": 0.00497, "epss_percentile": 0.65194}, "CVE-2018-0592": {"epss_score": 0.03882, "epss_percentile": 0.87898}, "CVE-2018-0593": {"epss_score": 0.04844, "epss_percentile": 0.89207}, "CVE-2018-0594": {"epss_score": 0.04844, "epss_percentile": 0.89207}, "CVE-2018-0595": {"epss_score": 0.04844, "epss_percentile": 0.89207}, "CVE-2018-0596": {"epss_score": 0.04844, "epss_percentile": 0.89207}, "CVE-2018-0597": {"epss_score": 0.04844, "epss_percentile": 0.89207}, "CVE-2018-0598": {"epss_score": 0.13879, "epss_percentile": 0.94083}, "CVE-2018-0599": {"epss_score": 0.02184, "epss_percentile": 0.83913}, "CVE-2018-0600": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2018-0601": {"epss_score": 0.00166, "epss_percentile": 0.38231}, "CVE-2018-0602": {"epss_score": 0.00248, "epss_percentile": 0.47908}, "CVE-2018-0603": {"epss_score": 0.00306, "epss_percentile": 0.5343}, "CVE-2018-0604": {"epss_score": 0.01558, "epss_percentile": 0.81027}, "CVE-2018-0605": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-0606": {"epss_score": 0.00367, "epss_percentile": 0.58104}, "CVE-2018-0607": {"epss_score": 0.00677, "epss_percentile": 0.70966}, "CVE-2018-0608": {"epss_score": 0.02571, "epss_percentile": 0.85132}, "CVE-2018-0609": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2018-0610": {"epss_score": 0.01851, "epss_percentile": 0.82537}, "CVE-2018-0611": {"epss_score": 0.00116, "epss_percentile": 0.31083}, "CVE-2018-0612": {"epss_score": 0.00285, "epss_percentile": 0.51542}, "CVE-2018-0613": {"epss_score": 0.00326, "epss_percentile": 0.55067}, "CVE-2018-0614": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2018-0617": {"epss_score": 0.01067, "epss_percentile": 0.7723}, "CVE-2018-0618": {"epss_score": 0.00536, "epss_percentile": 0.6685}, "CVE-2018-0619": {"epss_score": 0.00237, "epss_percentile": 0.46643}, "CVE-2018-0620": {"epss_score": 0.00237, "epss_percentile": 0.46643}, "CVE-2018-0621": {"epss_score": 0.00237, "epss_percentile": 0.46643}, "CVE-2018-0622": {"epss_score": 0.00112, "epss_percentile": 0.30414}, "CVE-2018-0623": {"epss_score": 0.00206, "epss_percentile": 0.43058}, "CVE-2018-0624": {"epss_score": 0.00305, "epss_percentile": 0.5339}, "CVE-2018-0625": {"epss_score": 0.00669, "epss_percentile": 0.70746}, "CVE-2018-0626": {"epss_score": 0.00669, "epss_percentile": 0.70746}, "CVE-2018-0627": {"epss_score": 0.00669, "epss_percentile": 0.70746}, "CVE-2018-0628": {"epss_score": 0.00669, "epss_percentile": 0.70746}, "CVE-2018-0629": {"epss_score": 0.00669, "epss_percentile": 0.70746}, "CVE-2018-0630": {"epss_score": 0.00669, "epss_percentile": 0.70746}, "CVE-2018-0631": {"epss_score": 0.00669, "epss_percentile": 0.70746}, "CVE-2018-0632": {"epss_score": 0.01689, "epss_percentile": 0.81766}, "CVE-2018-0633": {"epss_score": 0.01689, "epss_percentile": 0.81766}, "CVE-2018-0634": {"epss_score": 0.0059, "epss_percentile": 0.68571}, "CVE-2018-0635": {"epss_score": 0.0059, "epss_percentile": 0.68571}, "CVE-2018-0636": {"epss_score": 0.0059, "epss_percentile": 0.68571}, "CVE-2018-0637": {"epss_score": 0.00669, "epss_percentile": 0.70746}, "CVE-2018-0638": {"epss_score": 0.00669, "epss_percentile": 0.70746}, "CVE-2018-0639": {"epss_score": 0.0059, "epss_percentile": 0.68571}, "CVE-2018-0640": {"epss_score": 0.02037, "epss_percentile": 0.83355}, "CVE-2018-0641": {"epss_score": 0.02037, "epss_percentile": 0.83355}, "CVE-2018-0642": {"epss_score": 0.00319, "epss_percentile": 0.54481}, "CVE-2018-0643": {"epss_score": 0.00318, "epss_percentile": 0.54438}, "CVE-2018-0644": {"epss_score": 0.00642, "epss_percentile": 0.70027}, "CVE-2018-0645": {"epss_score": 0.0127, "epss_percentile": 0.79049}, "CVE-2018-0646": {"epss_score": 0.01621, "epss_percentile": 0.8139}, "CVE-2018-0647": {"epss_score": 0.00166, "epss_percentile": 0.38156}, "CVE-2018-0648": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2018-0649": {"epss_score": 0.00136, "epss_percentile": 0.34073}, "CVE-2018-0650": {"epss_score": 0.00131, "epss_percentile": 0.33378}, "CVE-2018-0651": {"epss_score": 0.04622, "epss_percentile": 0.88933}, "CVE-2018-0652": {"epss_score": 0.00176, "epss_percentile": 0.39391}, "CVE-2018-0653": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2018-0654": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2018-0655": {"epss_score": 0.00176, "epss_percentile": 0.39391}, "CVE-2018-0656": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2018-0657": {"epss_score": 0.00387, "epss_percentile": 0.59312}, "CVE-2018-0658": {"epss_score": 0.00704, "epss_percentile": 0.71552}, "CVE-2018-0659": {"epss_score": 0.0029, "epss_percentile": 0.52083}, "CVE-2018-0660": {"epss_score": 0.00213, "epss_percentile": 0.43904}, "CVE-2018-0661": {"epss_score": 0.00162, "epss_percentile": 0.37643}, "CVE-2018-0662": {"epss_score": 0.00049, "epss_percentile": 0.15466}, "CVE-2018-0663": {"epss_score": 0.00608, "epss_percentile": 0.69067}, "CVE-2018-0664": {"epss_score": 0.00576, "epss_percentile": 0.68144}, "CVE-2018-0665": {"epss_score": 0.00176, "epss_percentile": 0.3941}, "CVE-2018-0666": {"epss_score": 0.00176, "epss_percentile": 0.3941}, "CVE-2018-0667": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2018-0668": {"epss_score": 0.01091, "epss_percentile": 0.77462}, "CVE-2018-0669": {"epss_score": 0.00921, "epss_percentile": 0.75481}, "CVE-2018-0670": {"epss_score": 0.00921, "epss_percentile": 0.75481}, "CVE-2018-0671": {"epss_score": 0.00039, "epss_percentile": 0.1164}, "CVE-2018-0672": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-0673": {"epss_score": 0.00575, "epss_percentile": 0.68114}, "CVE-2018-0674": {"epss_score": 0.00578, "epss_percentile": 0.68195}, "CVE-2018-0675": {"epss_score": 0.00578, "epss_percentile": 0.68195}, "CVE-2018-0676": {"epss_score": 0.00162, "epss_percentile": 0.37729}, "CVE-2018-0677": {"epss_score": 0.00318, "epss_percentile": 0.54438}, "CVE-2018-0678": {"epss_score": 0.00137, "epss_percentile": 0.34314}, "CVE-2018-0679": {"epss_score": 0.00245, "epss_percentile": 0.4769}, "CVE-2018-0680": {"epss_score": 0.0102, "epss_percentile": 0.76743}, "CVE-2018-0681": {"epss_score": 0.0102, "epss_percentile": 0.76743}, "CVE-2018-0682": {"epss_score": 0.01051, "epss_percentile": 0.77085}, "CVE-2018-0683": {"epss_score": 0.05898, "epss_percentile": 0.90306}, "CVE-2018-0684": {"epss_score": 0.05898, "epss_percentile": 0.90306}, "CVE-2018-0685": {"epss_score": 0.00764, "epss_percentile": 0.72904}, "CVE-2018-0686": {"epss_score": 0.00959, "epss_percentile": 0.7596}, "CVE-2018-0687": {"epss_score": 0.00335, "epss_percentile": 0.55798}, "CVE-2018-0688": {"epss_score": 0.00189, "epss_percentile": 0.40975}, "CVE-2018-0689": {"epss_score": 0.00627, "epss_percentile": 0.69638}, "CVE-2018-0690": {"epss_score": 0.00452, "epss_percentile": 0.63187}, "CVE-2018-0691": {"epss_score": 0.00125, "epss_percentile": 0.32545}, "CVE-2018-0692": {"epss_score": 0.00172, "epss_percentile": 0.38972}, "CVE-2018-0693": {"epss_score": 0.00514, "epss_percentile": 0.65967}, "CVE-2018-0694": {"epss_score": 0.02888, "epss_percentile": 0.85913}, "CVE-2018-0695": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2018-0696": {"epss_score": 0.00258, "epss_percentile": 0.48955}, "CVE-2018-0697": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2018-0698": {"epss_score": 0.00151, "epss_percentile": 0.3619}, "CVE-2018-0699": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2018-0700": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2018-0701": {"epss_score": 0.00185, "epss_percentile": 0.40568}, "CVE-2018-0702": {"epss_score": 0.00903, "epss_percentile": 0.75208}, "CVE-2018-0703": {"epss_score": 0.00903, "epss_percentile": 0.75208}, "CVE-2018-0704": {"epss_score": 0.00903, "epss_percentile": 0.75208}, "CVE-2018-0705": {"epss_score": 0.00653, "epss_percentile": 0.70334}, "CVE-2018-0706": {"epss_score": 0.61692, "epss_percentile": 0.9826}, "CVE-2018-0707": {"epss_score": 0.75392, "epss_percentile": 0.98842}, "CVE-2018-0708": {"epss_score": 0.57163, "epss_percentile": 0.98052}, "CVE-2018-0709": {"epss_score": 0.35636, "epss_percentile": 0.96924}, "CVE-2018-0710": {"epss_score": 0.21177, "epss_percentile": 0.95472}, "CVE-2018-0711": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2018-0712": {"epss_score": 0.02596, "epss_percentile": 0.85199}, "CVE-2018-0714": {"epss_score": 0.02291, "epss_percentile": 0.84283}, "CVE-2018-0715": {"epss_score": 0.0436, "epss_percentile": 0.88594}, "CVE-2018-0716": {"epss_score": 0.00272, "epss_percentile": 0.50359}, "CVE-2018-0718": {"epss_score": 0.06016, "epss_percentile": 0.90412}, "CVE-2018-0719": {"epss_score": 0.00226, "epss_percentile": 0.45253}, "CVE-2018-0721": {"epss_score": 0.01264, "epss_percentile": 0.78998}, "CVE-2018-0722": {"epss_score": 0.00371, "epss_percentile": 0.58405}, "CVE-2018-0723": {"epss_score": 0.00272, "epss_percentile": 0.50359}, "CVE-2018-0724": {"epss_score": 0.00272, "epss_percentile": 0.50359}, "CVE-2018-0728": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2018-0729": {"epss_score": 0.04188, "epss_percentile": 0.88367}, "CVE-2018-0730": {"epss_score": 0.01203, "epss_percentile": 0.78499}, "CVE-2018-0732": {"epss_score": 0.81092, "epss_percentile": 0.99119}, "CVE-2018-0733": {"epss_score": 0.01955, "epss_percentile": 0.83036}, "CVE-2018-0734": {"epss_score": 0.06051, "epss_percentile": 0.90434}, "CVE-2018-0735": {"epss_score": 0.07042, "epss_percentile": 0.91207}, "CVE-2018-0737": {"epss_score": 0.37092, "epss_percentile": 0.97019}, "CVE-2018-0739": {"epss_score": 0.1242, "epss_percentile": 0.93664}, "CVE-2018-0741": {"epss_score": 0.25571, "epss_percentile": 0.96046}, "CVE-2018-0742": {"epss_score": 0.01161, "epss_percentile": 0.78143}, "CVE-2018-0743": {"epss_score": 0.07246, "epss_percentile": 0.91348}, "CVE-2018-0744": {"epss_score": 0.05739, "epss_percentile": 0.90167}, "CVE-2018-0745": {"epss_score": 0.14467, "epss_percentile": 0.94218}, "CVE-2018-0746": {"epss_score": 0.10138, "epss_percentile": 0.92862}, "CVE-2018-0747": {"epss_score": 0.00588, "epss_percentile": 0.68511}, "CVE-2018-0748": {"epss_score": 0.07601, "epss_percentile": 0.91562}, "CVE-2018-0749": {"epss_score": 0.13865, "epss_percentile": 0.94079}, "CVE-2018-0750": {"epss_score": 0.03092, "epss_percentile": 0.86397}, "CVE-2018-0751": {"epss_score": 0.0805, "epss_percentile": 0.91853}, "CVE-2018-0752": {"epss_score": 0.05117, "epss_percentile": 0.89514}, "CVE-2018-0753": {"epss_score": 0.19193, "epss_percentile": 0.95146}, "CVE-2018-0754": {"epss_score": 0.01035, "epss_percentile": 0.76904}, "CVE-2018-0755": {"epss_score": 0.08, "epss_percentile": 0.9182}, "CVE-2018-0756": {"epss_score": 0.01161, "epss_percentile": 0.78143}, "CVE-2018-0757": {"epss_score": 0.01781, "epss_percentile": 0.82238}, "CVE-2018-0758": {"epss_score": 0.7392, "epss_percentile": 0.98776}, "CVE-2018-0760": {"epss_score": 0.08, "epss_percentile": 0.9182}, "CVE-2018-0761": {"epss_score": 0.08, "epss_percentile": 0.9182}, "CVE-2018-0762": {"epss_score": 0.27619, "epss_percentile": 0.96264}, "CVE-2018-0763": {"epss_score": 0.13778, "epss_percentile": 0.94057}, "CVE-2018-0764": {"epss_score": 0.34677, "epss_percentile": 0.96867}, "CVE-2018-0765": {"epss_score": 0.0991, "epss_percentile": 0.92767}, "CVE-2018-0766": {"epss_score": 0.11388, "epss_percentile": 0.93329}, "CVE-2018-0767": {"epss_score": 0.72275, "epss_percentile": 0.98703}, "CVE-2018-0768": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2018-0769": {"epss_score": 0.74038, "epss_percentile": 0.98784}, "CVE-2018-0770": {"epss_score": 0.74043, "epss_percentile": 0.98786}, "CVE-2018-0771": {"epss_score": 0.11213, "epss_percentile": 0.93266}, "CVE-2018-0772": {"epss_score": 0.27619, "epss_percentile": 0.96264}, "CVE-2018-0773": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2018-0774": {"epss_score": 0.73993, "epss_percentile": 0.98781}, "CVE-2018-0775": {"epss_score": 0.73993, "epss_percentile": 0.98781}, "CVE-2018-0776": {"epss_score": 0.74043, "epss_percentile": 0.98786}, "CVE-2018-0777": {"epss_score": 0.74043, "epss_percentile": 0.98786}, "CVE-2018-0778": {"epss_score": 0.24372, "epss_percentile": 0.95915}, "CVE-2018-0780": {"epss_score": 0.72275, "epss_percentile": 0.98703}, "CVE-2018-0781": {"epss_score": 0.20003, "epss_percentile": 0.95274}, "CVE-2018-0784": {"epss_score": 0.15711, "epss_percentile": 0.94489}, "CVE-2018-0785": {"epss_score": 0.02614, "epss_percentile": 0.85241}, "CVE-2018-0786": {"epss_score": 0.02026, "epss_percentile": 0.83317}, "CVE-2018-0787": {"epss_score": 0.17477, "epss_percentile": 0.94855}, "CVE-2018-0788": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2018-0789": {"epss_score": 0.21719, "epss_percentile": 0.95552}, "CVE-2018-0790": {"epss_score": 0.17285, "epss_percentile": 0.94816}, "CVE-2018-0791": {"epss_score": 0.35569, "epss_percentile": 0.96919}, "CVE-2018-0792": {"epss_score": 0.37727, "epss_percentile": 0.97066}, "CVE-2018-0793": {"epss_score": 0.3391, "epss_percentile": 0.96816}, "CVE-2018-0794": {"epss_score": 0.36403, "epss_percentile": 0.96977}, "CVE-2018-0795": {"epss_score": 0.36001, "epss_percentile": 0.96948}, "CVE-2018-0796": {"epss_score": 0.36403, "epss_percentile": 0.96977}, "CVE-2018-0797": {"epss_score": 0.33961, "epss_percentile": 0.96818}, "CVE-2018-0798": {"epss_score": 0.94056, "epss_percentile": 0.99894}, "CVE-2018-0799": {"epss_score": 0.00791, "epss_percentile": 0.7339}, "CVE-2018-0800": {"epss_score": 0.23543, "epss_percentile": 0.9579}, "CVE-2018-0801": {"epss_score": 0.36403, "epss_percentile": 0.96977}, "CVE-2018-0802": {"epss_score": 0.94073, "epss_percentile": 0.99898}, "CVE-2018-0803": {"epss_score": 0.03657, "epss_percentile": 0.87518}, "CVE-2018-0804": {"epss_score": 0.36403, "epss_percentile": 0.96977}, "CVE-2018-0805": {"epss_score": 0.36403, "epss_percentile": 0.96977}, "CVE-2018-0806": {"epss_score": 0.36403, "epss_percentile": 0.96977}, "CVE-2018-0807": {"epss_score": 0.36403, "epss_percentile": 0.96977}, "CVE-2018-0808": {"epss_score": 0.12839, "epss_percentile": 0.93799}, "CVE-2018-0809": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2018-0810": {"epss_score": 0.02146, "epss_percentile": 0.83765}, "CVE-2018-0811": {"epss_score": 0.03182, "epss_percentile": 0.86583}, "CVE-2018-0812": {"epss_score": 0.27911, "epss_percentile": 0.96294}, "CVE-2018-0813": {"epss_score": 0.03182, "epss_percentile": 0.86583}, "CVE-2018-0814": {"epss_score": 0.03182, "epss_percentile": 0.86583}, "CVE-2018-0815": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2018-0816": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2018-0817": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2018-0818": {"epss_score": 0.27262, "epss_percentile": 0.96229}, "CVE-2018-0819": {"epss_score": 0.10051, "epss_percentile": 0.92829}, "CVE-2018-0820": {"epss_score": 0.01161, "epss_percentile": 0.78143}, "CVE-2018-0821": {"epss_score": 0.02473, "epss_percentile": 0.84852}, "CVE-2018-0822": {"epss_score": 0.0265, "epss_percentile": 0.85342}, "CVE-2018-0823": {"epss_score": 0.0265, "epss_percentile": 0.85342}, "CVE-2018-0824": {"epss_score": 0.88995, "epss_percentile": 0.99503}, "CVE-2018-0825": {"epss_score": 0.35752, "epss_percentile": 0.96931}, "CVE-2018-0826": {"epss_score": 0.02911, "epss_percentile": 0.85971}, "CVE-2018-0827": {"epss_score": 0.02238, "epss_percentile": 0.84106}, "CVE-2018-0828": {"epss_score": 0.00997, "epss_percentile": 0.76457}, "CVE-2018-0829": {"epss_score": 0.03549, "epss_percentile": 0.87336}, "CVE-2018-0830": {"epss_score": 0.03549, "epss_percentile": 0.87336}, "CVE-2018-0831": {"epss_score": 0.00878, "epss_percentile": 0.7483}, "CVE-2018-0832": {"epss_score": 0.17062, "epss_percentile": 0.94767}, "CVE-2018-0833": {"epss_score": 0.74526, "epss_percentile": 0.98807}, "CVE-2018-0834": {"epss_score": 0.78098, "epss_percentile": 0.98969}, "CVE-2018-0835": {"epss_score": 0.79299, "epss_percentile": 0.9903}, "CVE-2018-0836": {"epss_score": 0.284, "epss_percentile": 0.96353}, "CVE-2018-0837": {"epss_score": 0.79299, "epss_percentile": 0.9903}, "CVE-2018-0838": {"epss_score": 0.79299, "epss_percentile": 0.9903}, "CVE-2018-0839": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2018-0840": {"epss_score": 0.7974, "epss_percentile": 0.99053}, "CVE-2018-0841": {"epss_score": 0.36403, "epss_percentile": 0.96977}, "CVE-2018-0842": {"epss_score": 0.00589, "epss_percentile": 0.68524}, "CVE-2018-0843": {"epss_score": 0.03549, "epss_percentile": 0.87336}, "CVE-2018-0844": {"epss_score": 0.00344, "epss_percentile": 0.56492}, "CVE-2018-0845": {"epss_score": 0.34275, "epss_percentile": 0.96838}, "CVE-2018-0846": {"epss_score": 0.00344, "epss_percentile": 0.56492}, "CVE-2018-0847": {"epss_score": 0.12044, "epss_percentile": 0.93554}, "CVE-2018-0848": {"epss_score": 0.25929, "epss_percentile": 0.96095}, "CVE-2018-0849": {"epss_score": 0.3657, "epss_percentile": 0.96988}, "CVE-2018-0850": {"epss_score": 0.16756, "epss_percentile": 0.94728}, "CVE-2018-0851": {"epss_score": 0.30543, "epss_percentile": 0.9655}, "CVE-2018-0852": {"epss_score": 0.30543, "epss_percentile": 0.9655}, "CVE-2018-0853": {"epss_score": 0.13146, "epss_percentile": 0.93885}, "CVE-2018-0854": {"epss_score": 0.02238, "epss_percentile": 0.84106}, "CVE-2018-0855": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2018-0856": {"epss_score": 0.284, "epss_percentile": 0.96353}, "CVE-2018-0857": {"epss_score": 0.284, "epss_percentile": 0.96353}, "CVE-2018-0858": {"epss_score": 0.26244, "epss_percentile": 0.96128}, "CVE-2018-0859": {"epss_score": 0.29342, "epss_percentile": 0.96434}, "CVE-2018-0860": {"epss_score": 0.79299, "epss_percentile": 0.9903}, "CVE-2018-0861": {"epss_score": 0.33654, "epss_percentile": 0.96794}, "CVE-2018-0862": {"epss_score": 0.3657, "epss_percentile": 0.96988}, "CVE-2018-0864": {"epss_score": 0.01397, "epss_percentile": 0.79982}, "CVE-2018-0866": {"epss_score": 0.66823, "epss_percentile": 0.98481}, "CVE-2018-0868": {"epss_score": 0.00706, "epss_percentile": 0.71617}, "CVE-2018-0869": {"epss_score": 0.00855, "epss_percentile": 0.74461}, "CVE-2018-0870": {"epss_score": 0.24025, "epss_percentile": 0.95847}, "CVE-2018-0871": {"epss_score": 0.11411, "epss_percentile": 0.93341}, "CVE-2018-0872": {"epss_score": 0.284, "epss_percentile": 0.96353}, "CVE-2018-0873": {"epss_score": 0.284, "epss_percentile": 0.96353}, "CVE-2018-0874": {"epss_score": 0.284, "epss_percentile": 0.96353}, "CVE-2018-0875": {"epss_score": 0.22234, "epss_percentile": 0.95612}, "CVE-2018-0876": {"epss_score": 0.24025, "epss_percentile": 0.95847}, "CVE-2018-0877": {"epss_score": 0.16721, "epss_percentile": 0.94721}, "CVE-2018-0878": {"epss_score": 0.4177, "epss_percentile": 0.97293}, "CVE-2018-0879": {"epss_score": 0.22657, "epss_percentile": 0.95665}, "CVE-2018-0880": {"epss_score": 0.25549, "epss_percentile": 0.96039}, "CVE-2018-0881": {"epss_score": 0.00799, "epss_percentile": 0.7352}, "CVE-2018-0882": {"epss_score": 0.14907, "epss_percentile": 0.94319}, "CVE-2018-0883": {"epss_score": 0.29278, "epss_percentile": 0.96429}, "CVE-2018-0884": {"epss_score": 0.01161, "epss_percentile": 0.78143}, "CVE-2018-0885": {"epss_score": 0.02008, "epss_percentile": 0.83242}, "CVE-2018-0886": {"epss_score": 0.91367, "epss_percentile": 0.99637}, "CVE-2018-0887": {"epss_score": 0.01066, "epss_percentile": 0.77223}, "CVE-2018-0888": {"epss_score": 0.0124, "epss_percentile": 0.788}, "CVE-2018-0889": {"epss_score": 0.24025, "epss_percentile": 0.95847}, "CVE-2018-0890": {"epss_score": 0.19514, "epss_percentile": 0.95196}, "CVE-2018-0891": {"epss_score": 0.56551, "epss_percentile": 0.98027}, "CVE-2018-0892": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2018-0893": {"epss_score": 0.39594, "epss_percentile": 0.97169}, "CVE-2018-0894": {"epss_score": 0.17062, "epss_percentile": 0.94767}, "CVE-2018-0895": {"epss_score": 0.12825, "epss_percentile": 0.93787}, "CVE-2018-0896": {"epss_score": 0.03549, "epss_percentile": 0.87336}, "CVE-2018-0897": {"epss_score": 0.18628, "epss_percentile": 0.95045}, "CVE-2018-0898": {"epss_score": 0.0251, "epss_percentile": 0.84949}, "CVE-2018-0899": {"epss_score": 0.0251, "epss_percentile": 0.84949}, "CVE-2018-0900": {"epss_score": 0.0251, "epss_percentile": 0.84949}, "CVE-2018-0901": {"epss_score": 0.16435, "epss_percentile": 0.9466}, "CVE-2018-0902": {"epss_score": 0.00487, "epss_percentile": 0.648}, "CVE-2018-0903": {"epss_score": 0.30456, "epss_percentile": 0.96541}, "CVE-2018-0904": {"epss_score": 0.03549, "epss_percentile": 0.87336}, "CVE-2018-0907": {"epss_score": 0.18388, "epss_percentile": 0.95009}, "CVE-2018-0908": {"epss_score": 0.01051, "epss_percentile": 0.77083}, "CVE-2018-0909": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0910": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0911": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0912": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0913": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0914": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0915": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0916": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0917": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0919": {"epss_score": 0.13277, "epss_percentile": 0.93919}, "CVE-2018-0920": {"epss_score": 0.3391, "epss_percentile": 0.96816}, "CVE-2018-0921": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0922": {"epss_score": 0.32514, "epss_percentile": 0.96706}, "CVE-2018-0923": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0924": {"epss_score": 0.23115, "epss_percentile": 0.95736}, "CVE-2018-0925": {"epss_score": 0.23085, "epss_percentile": 0.95732}, "CVE-2018-0926": {"epss_score": 0.02424, "epss_percentile": 0.84713}, "CVE-2018-0927": {"epss_score": 0.11405, "epss_percentile": 0.93337}, "CVE-2018-0929": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2018-0930": {"epss_score": 0.26113, "epss_percentile": 0.96113}, "CVE-2018-0931": {"epss_score": 0.26113, "epss_percentile": 0.96113}, "CVE-2018-0932": {"epss_score": 0.11405, "epss_percentile": 0.93337}, "CVE-2018-0933": {"epss_score": 0.76952, "epss_percentile": 0.98912}, "CVE-2018-0934": {"epss_score": 0.85288, "epss_percentile": 0.99327}, "CVE-2018-0935": {"epss_score": 0.67364, "epss_percentile": 0.98504}, "CVE-2018-0936": {"epss_score": 0.284, "epss_percentile": 0.96353}, "CVE-2018-0937": {"epss_score": 0.284, "epss_percentile": 0.96353}, "CVE-2018-0939": {"epss_score": 0.12044, "epss_percentile": 0.93554}, "CVE-2018-0940": {"epss_score": 0.19917, "epss_percentile": 0.95261}, "CVE-2018-0941": {"epss_score": 0.28949, "epss_percentile": 0.96403}, "CVE-2018-0942": {"epss_score": 0.01892, "epss_percentile": 0.82737}, "CVE-2018-0943": {"epss_score": 0.27304, "epss_percentile": 0.96234}, "CVE-2018-0944": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0945": {"epss_score": 0.21715, "epss_percentile": 0.95551}, "CVE-2018-0946": {"epss_score": 0.62506, "epss_percentile": 0.98295}, "CVE-2018-0947": {"epss_score": 0.09924, "epss_percentile": 0.92775}, "CVE-2018-0949": {"epss_score": 0.25169, "epss_percentile": 0.95992}, "CVE-2018-0950": {"epss_score": 0.10722, "epss_percentile": 0.93083}, "CVE-2018-0951": {"epss_score": 0.23032, "epss_percentile": 0.95722}, "CVE-2018-0952": {"epss_score": 0.39182, "epss_percentile": 0.97144}, "CVE-2018-0953": {"epss_score": 0.76997, "epss_percentile": 0.98915}, "CVE-2018-0954": {"epss_score": 0.15814, "epss_percentile": 0.94514}, "CVE-2018-0955": {"epss_score": 0.172, "epss_percentile": 0.94798}, "CVE-2018-0956": {"epss_score": 0.23568, "epss_percentile": 0.95792}, "CVE-2018-0957": {"epss_score": 0.01001, "epss_percentile": 0.76493}, "CVE-2018-0958": {"epss_score": 0.017, "epss_percentile": 0.81826}, "CVE-2018-0959": {"epss_score": 0.23975, "epss_percentile": 0.95839}, "CVE-2018-0960": {"epss_score": 0.01035, "epss_percentile": 0.76904}, "CVE-2018-0961": {"epss_score": 0.00936, "epss_percentile": 0.7568}, "CVE-2018-0963": {"epss_score": 0.01161, "epss_percentile": 0.78143}, "CVE-2018-0964": {"epss_score": 0.01601, "epss_percentile": 0.81267}, "CVE-2018-0965": {"epss_score": 0.00585, "epss_percentile": 0.6841}, "CVE-2018-0966": {"epss_score": 0.00876, "epss_percentile": 0.7479}, "CVE-2018-0967": {"epss_score": 0.2245, "epss_percentile": 0.95635}, "CVE-2018-0968": {"epss_score": 0.06422, "epss_percentile": 0.9075}, "CVE-2018-0969": {"epss_score": 0.12804, "epss_percentile": 0.9378}, "CVE-2018-0970": {"epss_score": 0.12804, "epss_percentile": 0.9378}, "CVE-2018-0971": {"epss_score": 0.12804, "epss_percentile": 0.9378}, "CVE-2018-0972": {"epss_score": 0.12804, "epss_percentile": 0.9378}, "CVE-2018-0973": {"epss_score": 0.12804, "epss_percentile": 0.9378}, "CVE-2018-0974": {"epss_score": 0.12804, "epss_percentile": 0.9378}, "CVE-2018-0975": {"epss_score": 0.14429, "epss_percentile": 0.94211}, "CVE-2018-0976": {"epss_score": 0.19514, "epss_percentile": 0.95196}, "CVE-2018-0977": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2018-0978": {"epss_score": 0.45916, "epss_percentile": 0.97509}, "CVE-2018-0979": {"epss_score": 0.22672, "epss_percentile": 0.95669}, "CVE-2018-0980": {"epss_score": 0.76997, "epss_percentile": 0.98915}, "CVE-2018-0981": {"epss_score": 0.21154, "epss_percentile": 0.95471}, "CVE-2018-0982": {"epss_score": 0.17125, "epss_percentile": 0.9478}, "CVE-2018-0983": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2018-0986": {"epss_score": 0.75368, "epss_percentile": 0.98841}, "CVE-2018-0987": {"epss_score": 0.06512, "epss_percentile": 0.90812}, "CVE-2018-0988": {"epss_score": 0.29935, "epss_percentile": 0.96487}, "CVE-2018-0989": {"epss_score": 0.10681, "epss_percentile": 0.93068}, "CVE-2018-0990": {"epss_score": 0.22672, "epss_percentile": 0.95669}, "CVE-2018-0991": {"epss_score": 0.24025, "epss_percentile": 0.95847}, "CVE-2018-0993": {"epss_score": 0.22672, "epss_percentile": 0.95669}, "CVE-2018-0994": {"epss_score": 0.22672, "epss_percentile": 0.95669}, "CVE-2018-0995": {"epss_score": 0.22672, "epss_percentile": 0.95669}, "CVE-2018-0996": {"epss_score": 0.29935, "epss_percentile": 0.96487}, "CVE-2018-0997": {"epss_score": 0.24025, "epss_percentile": 0.95847}, "CVE-2018-0998": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2018-1000001": {"epss_score": 0.3368, "epss_percentile": 0.96797}, "CVE-2018-1000002": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2018-1000003": {"epss_score": 0.00017, "epss_percentile": 0.03213}, "CVE-2018-1000004": {"epss_score": 0.01941, "epss_percentile": 0.82982}, "CVE-2018-1000005": {"epss_score": 0.00472, "epss_percentile": 0.64042}, "CVE-2018-1000006": {"epss_score": 0.92322, "epss_percentile": 0.99707}, "CVE-2018-1000007": {"epss_score": 0.03883, "epss_percentile": 0.87898}, "CVE-2018-1000008": {"epss_score": 0.00074, "epss_percentile": 0.22805}, "CVE-2018-1000009": {"epss_score": 0.00065, "epss_percentile": 0.20486}, "CVE-2018-1000010": {"epss_score": 0.00065, "epss_percentile": 0.20486}, "CVE-2018-1000011": {"epss_score": 0.00065, "epss_percentile": 0.20486}, "CVE-2018-1000012": {"epss_score": 0.00065, "epss_percentile": 0.20486}, "CVE-2018-1000013": {"epss_score": 0.00059, "epss_percentile": 0.18733}, "CVE-2018-1000014": {"epss_score": 0.00059, "epss_percentile": 0.18733}, "CVE-2018-1000015": {"epss_score": 0.00033, "epss_percentile": 0.09422}, "CVE-2018-1000018": {"epss_score": 0.00047, "epss_percentile": 0.14802}, "CVE-2018-1000019": {"epss_score": 0.28317, "epss_percentile": 0.96343}, "CVE-2018-1000020": {"epss_score": 0.0386, "epss_percentile": 0.87863}, "CVE-2018-1000021": {"epss_score": 0.00306, "epss_percentile": 0.53455}, "CVE-2018-1000022": {"epss_score": 0.00333, "epss_percentile": 0.55656}, "CVE-2018-1000023": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2018-1000024": {"epss_score": 0.09121, "epss_percentile": 0.92409}, "CVE-2018-1000025": {"epss_score": 0.00345, "epss_percentile": 0.56559}, "CVE-2018-1000026": {"epss_score": 0.00865, "epss_percentile": 0.74623}, "CVE-2018-1000027": {"epss_score": 0.68081, "epss_percentile": 0.9853}, "CVE-2018-1000028": {"epss_score": 0.0037, "epss_percentile": 0.5831}, "CVE-2018-1000029": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-1000030": {"epss_score": 0.01576, "epss_percentile": 0.81114}, "CVE-2018-1000031": {"epss_score": 0.00513, "epss_percentile": 0.65893}, "CVE-2018-1000032": {"epss_score": 0.00513, "epss_percentile": 0.65893}, "CVE-2018-1000033": {"epss_score": 0.00513, "epss_percentile": 0.65903}, "CVE-2018-1000034": {"epss_score": 0.00377, "epss_percentile": 0.58775}, "CVE-2018-1000035": {"epss_score": 0.65327, "epss_percentile": 0.98413}, "CVE-2018-1000036": {"epss_score": 0.00479, "epss_percentile": 0.64411}, "CVE-2018-1000037": {"epss_score": 0.00304, "epss_percentile": 0.5324}, "CVE-2018-1000038": {"epss_score": 0.00935, "epss_percentile": 0.75664}, "CVE-2018-1000039": {"epss_score": 0.00705, "epss_percentile": 0.71577}, "CVE-2018-1000040": {"epss_score": 0.00262, "epss_percentile": 0.49325}, "CVE-2018-1000041": {"epss_score": 0.00645, "epss_percentile": 0.70106}, "CVE-2018-1000042": {"epss_score": 0.02193, "epss_percentile": 0.83944}, "CVE-2018-1000043": {"epss_score": 0.02193, "epss_percentile": 0.83944}, "CVE-2018-1000044": {"epss_score": 0.00846, "epss_percentile": 0.74319}, "CVE-2018-1000045": {"epss_score": 0.00578, "epss_percentile": 0.68188}, "CVE-2018-1000046": {"epss_score": 0.00578, "epss_percentile": 0.68188}, "CVE-2018-1000047": {"epss_score": 0.00919, "epss_percentile": 0.75454}, "CVE-2018-1000048": {"epss_score": 0.00919, "epss_percentile": 0.75454}, "CVE-2018-1000049": {"epss_score": 0.82763, "epss_percentile": 0.99213}, "CVE-2018-1000050": {"epss_score": 0.00645, "epss_percentile": 0.70105}, "CVE-2018-1000051": {"epss_score": 0.00711, "epss_percentile": 0.71727}, "CVE-2018-1000052": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2018-1000053": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2018-1000054": {"epss_score": 0.00065, "epss_percentile": 0.20486}, "CVE-2018-1000055": {"epss_score": 0.00065, "epss_percentile": 0.20486}, "CVE-2018-1000056": {"epss_score": 0.00142, "epss_percentile": 0.35028}, "CVE-2018-1000057": {"epss_score": 0.0003, "epss_percentile": 0.08291}, "CVE-2018-1000058": {"epss_score": 0.01296, "epss_percentile": 0.7926}, "CVE-2018-1000059": {"epss_score": 0.00266, "epss_percentile": 0.49909}, "CVE-2018-1000060": {"epss_score": 0.0045, "epss_percentile": 0.63086}, "CVE-2018-1000062": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-1000067": {"epss_score": 0.00353, "epss_percentile": 0.57189}, "CVE-2018-1000068": {"epss_score": 0.00309, "epss_percentile": 0.5365}, "CVE-2018-1000069": {"epss_score": 0.00333, "epss_percentile": 0.55678}, "CVE-2018-1000070": {"epss_score": 0.01118, "epss_percentile": 0.77744}, "CVE-2018-1000071": {"epss_score": 0.00291, "epss_percentile": 0.52195}, "CVE-2018-1000072": {"epss_score": 0.00281, "epss_percentile": 0.51148}, "CVE-2018-1000073": {"epss_score": 0.0098, "epss_percentile": 0.76265}, "CVE-2018-1000074": {"epss_score": 0.00495, "epss_percentile": 0.65116}, "CVE-2018-1000075": {"epss_score": 0.01632, "epss_percentile": 0.81454}, "CVE-2018-1000076": {"epss_score": 0.0086, "epss_percentile": 0.7454}, "CVE-2018-1000077": {"epss_score": 0.01026, "epss_percentile": 0.76799}, "CVE-2018-1000078": {"epss_score": 0.00763, "epss_percentile": 0.72853}, "CVE-2018-1000079": {"epss_score": 0.00293, "epss_percentile": 0.52303}, "CVE-2018-1000080": {"epss_score": 0.0011, "epss_percentile": 0.30186}, "CVE-2018-1000081": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-1000082": {"epss_score": 0.00798, "epss_percentile": 0.73514}, "CVE-2018-1000083": {"epss_score": 0.00264, "epss_percentile": 0.49569}, "CVE-2018-1000084": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-1000085": {"epss_score": 0.00997, "epss_percentile": 0.76455}, "CVE-2018-1000086": {"epss_score": 0.00296, "epss_percentile": 0.52577}, "CVE-2018-1000087": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-1000088": {"epss_score": 0.00172, "epss_percentile": 0.39006}, "CVE-2018-1000089": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2018-1000090": {"epss_score": 0.00219, "epss_percentile": 0.44507}, "CVE-2018-1000091": {"epss_score": 0.02446, "epss_percentile": 0.84769}, "CVE-2018-1000092": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2018-1000093": {"epss_score": 0.00458, "epss_percentile": 0.63429}, "CVE-2018-1000094": {"epss_score": 0.54916, "epss_percentile": 0.97951}, "CVE-2018-1000095": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-1000096": {"epss_score": 0.0017, "epss_percentile": 0.38744}, "CVE-2018-1000097": {"epss_score": 0.03603, "epss_percentile": 0.87413}, "CVE-2018-1000098": {"epss_score": 0.00704, "epss_percentile": 0.71572}, "CVE-2018-1000099": {"epss_score": 0.0097, "epss_percentile": 0.76109}, "CVE-2018-1000100": {"epss_score": 0.00213, "epss_percentile": 0.43919}, "CVE-2018-1000101": {"epss_score": 0.00568, "epss_percentile": 0.67904}, "CVE-2018-1000104": {"epss_score": 0.0001, "epss_percentile": 0.00878}, "CVE-2018-1000105": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2018-1000106": {"epss_score": 0.00088, "epss_percentile": 0.25755}, "CVE-2018-1000107": {"epss_score": 0.00021, "epss_percentile": 0.04723}, "CVE-2018-1000108": {"epss_score": 0.00065, "epss_percentile": 0.20466}, "CVE-2018-1000109": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2018-1000110": {"epss_score": 0.12984, "epss_percentile": 0.93836}, "CVE-2018-1000111": {"epss_score": 0.00038, "epss_percentile": 0.11093}, "CVE-2018-1000112": {"epss_score": 0.00052, "epss_percentile": 0.16577}, "CVE-2018-1000113": {"epss_score": 0.00058, "epss_percentile": 0.18534}, "CVE-2018-1000114": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2018-1000115": {"epss_score": 0.82527, "epss_percentile": 0.99198}, "CVE-2018-1000116": {"epss_score": 0.03936, "epss_percentile": 0.87985}, "CVE-2018-1000117": {"epss_score": 0.00069, "epss_percentile": 0.21559}, "CVE-2018-1000118": {"epss_score": 0.04546, "epss_percentile": 0.88833}, "CVE-2018-1000119": {"epss_score": 0.00427, "epss_percentile": 0.61881}, "CVE-2018-1000120": {"epss_score": 0.01642, "epss_percentile": 0.81513}, "CVE-2018-1000121": {"epss_score": 0.02849, "epss_percentile": 0.85825}, "CVE-2018-1000122": {"epss_score": 0.01751, "epss_percentile": 0.82105}, "CVE-2018-1000123": {"epss_score": 0.00327, "epss_percentile": 0.55127}, "CVE-2018-1000124": {"epss_score": 0.00308, "epss_percentile": 0.5357}, "CVE-2018-1000125": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2018-1000126": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2018-1000127": {"epss_score": 0.01002, "epss_percentile": 0.76511}, "CVE-2018-1000129": {"epss_score": 0.67423, "epss_percentile": 0.98506}, "CVE-2018-1000130": {"epss_score": 0.91608, "epss_percentile": 0.99658}, "CVE-2018-1000131": {"epss_score": 0.00764, "epss_percentile": 0.72895}, "CVE-2018-1000132": {"epss_score": 0.00783, "epss_percentile": 0.73214}, "CVE-2018-1000133": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2018-1000134": {"epss_score": 0.01578, "epss_percentile": 0.81121}, "CVE-2018-1000135": {"epss_score": 0.01115, "epss_percentile": 0.77713}, "CVE-2018-1000136": {"epss_score": 0.01407, "epss_percentile": 0.8006}, "CVE-2018-1000137": {"epss_score": 0.00112, "epss_percentile": 0.30489}, "CVE-2018-1000138": {"epss_score": 0.00212, "epss_percentile": 0.4375}, "CVE-2018-1000139": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-1000140": {"epss_score": 0.3631, "epss_percentile": 0.96969}, "CVE-2018-1000141": {"epss_score": 0.00291, "epss_percentile": 0.5217}, "CVE-2018-1000142": {"epss_score": 0.00019, "epss_percentile": 0.04324}, "CVE-2018-1000143": {"epss_score": 0.0002, "epss_percentile": 0.04536}, "CVE-2018-1000144": {"epss_score": 0.00065, "epss_percentile": 0.20466}, "CVE-2018-1000145": {"epss_score": 0.00096, "epss_percentile": 0.27341}, "CVE-2018-1000146": {"epss_score": 0.00228, "epss_percentile": 0.4547}, "CVE-2018-1000147": {"epss_score": 0.00294, "epss_percentile": 0.52426}, "CVE-2018-1000148": {"epss_score": 0.00094, "epss_percentile": 0.27}, "CVE-2018-1000149": {"epss_score": 0.00074, "epss_percentile": 0.22735}, "CVE-2018-1000150": {"epss_score": 9e-05, "epss_percentile": 0.00737}, "CVE-2018-1000151": {"epss_score": 0.00037, "epss_percentile": 0.10981}, "CVE-2018-1000152": {"epss_score": 0.00058, "epss_percentile": 0.18571}, "CVE-2018-1000153": {"epss_score": 0.00058, "epss_percentile": 0.18605}, "CVE-2018-1000154": {"epss_score": 0.0048, "epss_percentile": 0.64481}, "CVE-2018-1000155": {"epss_score": 0.00475, "epss_percentile": 0.64176}, "CVE-2018-1000156": {"epss_score": 0.35167, "epss_percentile": 0.96892}, "CVE-2018-1000158": {"epss_score": 0.00409, "epss_percentile": 0.60702}, "CVE-2018-1000159": {"epss_score": 0.00161, "epss_percentile": 0.37572}, "CVE-2018-1000160": {"epss_score": 0.0029, "epss_percentile": 0.52094}, "CVE-2018-1000161": {"epss_score": 0.00183, "epss_percentile": 0.4035}, "CVE-2018-1000162": {"epss_score": 0.00396, "epss_percentile": 0.59908}, "CVE-2018-1000163": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-1000164": {"epss_score": 0.01484, "epss_percentile": 0.8059}, "CVE-2018-1000165": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2018-1000167": {"epss_score": 0.01506, "epss_percentile": 0.80748}, "CVE-2018-1000168": {"epss_score": 0.03611, "epss_percentile": 0.87425}, "CVE-2018-1000169": {"epss_score": 0.00185, "epss_percentile": 0.40475}, "CVE-2018-1000170": {"epss_score": 0.00215, "epss_percentile": 0.44074}, "CVE-2018-1000172": {"epss_score": 0.0019, "epss_percentile": 0.41071}, "CVE-2018-1000173": {"epss_score": 0.00181, "epss_percentile": 0.40101}, "CVE-2018-1000174": {"epss_score": 0.0003, "epss_percentile": 0.08068}, "CVE-2018-1000175": {"epss_score": 0.00342, "epss_percentile": 0.56396}, "CVE-2018-1000176": {"epss_score": 0.00094, "epss_percentile": 0.27}, "CVE-2018-1000177": {"epss_score": 0.00058, "epss_percentile": 0.18534}, "CVE-2018-1000178": {"epss_score": 0.01075, "epss_percentile": 0.77305}, "CVE-2018-1000179": {"epss_score": 0.00568, "epss_percentile": 0.67882}, "CVE-2018-1000180": {"epss_score": 0.00256, "epss_percentile": 0.48802}, "CVE-2018-1000181": {"epss_score": 0.00275, "epss_percentile": 0.50651}, "CVE-2018-1000182": {"epss_score": 0.00039, "epss_percentile": 0.11653}, "CVE-2018-1000183": {"epss_score": 0.00316, "epss_percentile": 0.54275}, "CVE-2018-1000184": {"epss_score": 0.0003, "epss_percentile": 0.08291}, "CVE-2018-1000185": {"epss_score": 0.00041, "epss_percentile": 0.12391}, "CVE-2018-1000186": {"epss_score": 0.00094, "epss_percentile": 0.27}, "CVE-2018-1000187": {"epss_score": 0.00316, "epss_percentile": 0.54275}, "CVE-2018-1000188": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2018-1000189": {"epss_score": 0.00201, "epss_percentile": 0.42276}, "CVE-2018-1000190": {"epss_score": 0.00094, "epss_percentile": 0.27}, "CVE-2018-1000191": {"epss_score": 0.00094, "epss_percentile": 0.27}, "CVE-2018-1000192": {"epss_score": 0.00479, "epss_percentile": 0.64413}, "CVE-2018-1000193": {"epss_score": 0.00759, "epss_percentile": 0.72796}, "CVE-2018-1000194": {"epss_score": 0.00469, "epss_percentile": 0.63952}, "CVE-2018-1000195": {"epss_score": 0.00695, "epss_percentile": 0.71382}, "CVE-2018-1000196": {"epss_score": 0.00096, "epss_percentile": 0.27341}, "CVE-2018-1000197": {"epss_score": 0.00045, "epss_percentile": 0.13781}, "CVE-2018-1000198": {"epss_score": 0.00062, "epss_percentile": 0.19741}, "CVE-2018-1000199": {"epss_score": 0.00478, "epss_percentile": 0.64369}, "CVE-2018-1000200": {"epss_score": 0.00084, "epss_percentile": 0.24887}, "CVE-2018-1000201": {"epss_score": 0.00237, "epss_percentile": 0.4672}, "CVE-2018-1000202": {"epss_score": 0.00058, "epss_percentile": 0.18534}, "CVE-2018-1000203": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-1000204": {"epss_score": 0.00249, "epss_percentile": 0.48075}, "CVE-2018-1000205": {"epss_score": 0.00182, "epss_percentile": 0.40237}, "CVE-2018-1000206": {"epss_score": 0.0022, "epss_percentile": 0.44616}, "CVE-2018-1000207": {"epss_score": 0.04016, "epss_percentile": 0.88123}, "CVE-2018-1000208": {"epss_score": 0.00336, "epss_percentile": 0.55943}, "CVE-2018-1000209": {"epss_score": 0.00403, "epss_percentile": 0.60341}, "CVE-2018-1000210": {"epss_score": 0.00339, "epss_percentile": 0.56168}, "CVE-2018-1000211": {"epss_score": 0.0028, "epss_percentile": 0.51006}, "CVE-2018-1000215": {"epss_score": 0.00464, "epss_percentile": 0.63721}, "CVE-2018-1000216": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2018-1000217": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2018-1000218": {"epss_score": 0.0002, "epss_percentile": 0.04491}, "CVE-2018-1000219": {"epss_score": 0.00059, "epss_percentile": 0.18653}, "CVE-2018-1000221": {"epss_score": 0.0045, "epss_percentile": 0.63092}, "CVE-2018-1000222": {"epss_score": 0.0128, "epss_percentile": 0.79136}, "CVE-2018-1000223": {"epss_score": 0.00973, "epss_percentile": 0.76165}, "CVE-2018-1000224": {"epss_score": 0.13162, "epss_percentile": 0.93888}, "CVE-2018-1000225": {"epss_score": 0.00268, "epss_percentile": 0.50056}, "CVE-2018-1000226": {"epss_score": 0.61011, "epss_percentile": 0.98231}, "CVE-2018-1000300": {"epss_score": 0.00825, "epss_percentile": 0.73946}, "CVE-2018-1000301": {"epss_score": 0.02562, "epss_percentile": 0.85108}, "CVE-2018-1000400": {"epss_score": 0.00879, "epss_percentile": 0.74845}, "CVE-2018-1000401": {"epss_score": 0.00012, "epss_percentile": 0.01122}, "CVE-2018-1000402": {"epss_score": 0.00039, "epss_percentile": 0.11623}, "CVE-2018-1000403": {"epss_score": 0.00012, "epss_percentile": 0.01122}, "CVE-2018-1000404": {"epss_score": 0.00012, "epss_percentile": 0.01122}, "CVE-2018-1000406": {"epss_score": 0.10909, "epss_percentile": 0.93153}, "CVE-2018-1000407": {"epss_score": 0.00311, "epss_percentile": 0.53838}, "CVE-2018-1000408": {"epss_score": 0.00152, "epss_percentile": 0.3645}, "CVE-2018-1000409": {"epss_score": 0.00073, "epss_percentile": 0.22628}, "CVE-2018-1000410": {"epss_score": 0.00126, "epss_percentile": 0.32737}, "CVE-2018-1000411": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2018-1000412": {"epss_score": 0.00096, "epss_percentile": 0.2729}, "CVE-2018-1000413": {"epss_score": 0.00106, "epss_percentile": 0.29491}, "CVE-2018-1000414": {"epss_score": 0.00072, "epss_percentile": 0.22239}, "CVE-2018-1000415": {"epss_score": 0.00195, "epss_percentile": 0.41621}, "CVE-2018-1000416": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-1000417": {"epss_score": 0.00071, "epss_percentile": 0.21986}, "CVE-2018-1000418": {"epss_score": 0.00214, "epss_percentile": 0.44008}, "CVE-2018-1000419": {"epss_score": 0.00259, "epss_percentile": 0.49087}, "CVE-2018-1000420": {"epss_score": 0.00221, "epss_percentile": 0.44666}, "CVE-2018-1000421": {"epss_score": 0.00326, "epss_percentile": 0.55066}, "CVE-2018-1000422": {"epss_score": 0.00139, "epss_percentile": 0.34545}, "CVE-2018-1000423": {"epss_score": 0.00046, "epss_percentile": 0.14304}, "CVE-2018-1000424": {"epss_score": 0.0004, "epss_percentile": 0.12146}, "CVE-2018-1000425": {"epss_score": 0.00046, "epss_percentile": 0.14304}, "CVE-2018-1000426": {"epss_score": 0.00099, "epss_percentile": 0.28402}, "CVE-2018-1000500": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2018-1000501": {"epss_score": 0.00492, "epss_percentile": 0.64985}, "CVE-2018-1000502": {"epss_score": 0.00686, "epss_percentile": 0.71154}, "CVE-2018-1000503": {"epss_score": 0.00149, "epss_percentile": 0.35948}, "CVE-2018-1000504": {"epss_score": 0.0101, "epss_percentile": 0.76593}, "CVE-2018-1000505": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2018-1000506": {"epss_score": 0.00228, "epss_percentile": 0.45514}, "CVE-2018-1000507": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2018-1000508": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2018-1000509": {"epss_score": 0.00892, "epss_percentile": 0.7506}, "CVE-2018-1000510": {"epss_score": 0.00268, "epss_percentile": 0.50099}, "CVE-2018-1000511": {"epss_score": 0.00212, "epss_percentile": 0.43726}, "CVE-2018-1000512": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2018-1000513": {"epss_score": 0.00458, "epss_percentile": 0.63433}, "CVE-2018-1000514": {"epss_score": 0.00087, "epss_percentile": 0.25561}, "CVE-2018-1000515": {"epss_score": 0.00413, "epss_percentile": 0.60995}, "CVE-2018-1000516": {"epss_score": 0.00497, "epss_percentile": 0.65184}, "CVE-2018-1000517": {"epss_score": 0.34242, "epss_percentile": 0.96835}, "CVE-2018-1000518": {"epss_score": 0.00155, "epss_percentile": 0.36852}, "CVE-2018-1000519": {"epss_score": 0.00217, "epss_percentile": 0.4432}, "CVE-2018-1000520": {"epss_score": 0.00104, "epss_percentile": 0.29123}, "CVE-2018-1000521": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-1000523": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-1000524": {"epss_score": 0.00252, "epss_percentile": 0.4836}, "CVE-2018-1000525": {"epss_score": 0.04203, "epss_percentile": 0.8839}, "CVE-2018-1000526": {"epss_score": 0.00789, "epss_percentile": 0.7335}, "CVE-2018-1000527": {"epss_score": 0.02702, "epss_percentile": 0.85456}, "CVE-2018-1000528": {"epss_score": 0.00485, "epss_percentile": 0.64723}, "CVE-2018-1000529": {"epss_score": 0.00345, "epss_percentile": 0.56555}, "CVE-2018-1000531": {"epss_score": 0.00451, "epss_percentile": 0.63142}, "CVE-2018-1000532": {"epss_score": 0.00126, "epss_percentile": 0.32756}, "CVE-2018-1000533": {"epss_score": 0.92503, "epss_percentile": 0.99721}, "CVE-2018-1000534": {"epss_score": 0.00462, "epss_percentile": 0.63588}, "CVE-2018-1000535": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-1000536": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2018-1000537": {"epss_score": 0.06595, "epss_percentile": 0.90875}, "CVE-2018-1000538": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2018-1000539": {"epss_score": 0.0014, "epss_percentile": 0.34698}, "CVE-2018-1000540": {"epss_score": 0.0018, "epss_percentile": 0.39935}, "CVE-2018-1000542": {"epss_score": 0.01349, "epss_percentile": 0.79669}, "CVE-2018-1000543": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2018-1000544": {"epss_score": 0.00344, "epss_percentile": 0.56476}, "CVE-2018-1000546": {"epss_score": 0.00641, "epss_percentile": 0.69994}, "CVE-2018-1000547": {"epss_score": 0.00155, "epss_percentile": 0.36851}, "CVE-2018-1000548": {"epss_score": 0.00197, "epss_percentile": 0.41902}, "CVE-2018-1000549": {"epss_score": 0.0029, "epss_percentile": 0.52081}, "CVE-2018-1000550": {"epss_score": 0.00474, "epss_percentile": 0.64157}, "CVE-2018-1000551": {"epss_score": 0.00455, "epss_percentile": 0.63315}, "CVE-2018-1000552": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2018-1000553": {"epss_score": 0.00377, "epss_percentile": 0.58692}, "CVE-2018-1000554": {"epss_score": 0.00415, "epss_percentile": 0.61138}, "CVE-2018-1000556": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-1000557": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-1000558": {"epss_score": 0.00346, "epss_percentile": 0.56634}, "CVE-2018-1000559": {"epss_score": 0.00502, "epss_percentile": 0.65414}, "CVE-2018-1000600": {"epss_score": 0.93549, "epss_percentile": 0.99816}, "CVE-2018-1000601": {"epss_score": 0.00333, "epss_percentile": 0.55652}, "CVE-2018-1000602": {"epss_score": 0.00032, "epss_percentile": 0.09079}, "CVE-2018-1000603": {"epss_score": 0.00113, "epss_percentile": 0.30666}, "CVE-2018-1000604": {"epss_score": 0.00058, "epss_percentile": 0.18534}, "CVE-2018-1000605": {"epss_score": 0.00042, "epss_percentile": 0.12905}, "CVE-2018-1000606": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2018-1000607": {"epss_score": 0.00058, "epss_percentile": 0.18563}, "CVE-2018-1000608": {"epss_score": 0.00057, "epss_percentile": 0.18081}, "CVE-2018-1000609": {"epss_score": 0.00072, "epss_percentile": 0.22416}, "CVE-2018-1000610": {"epss_score": 0.00054, "epss_percentile": 0.17116}, "CVE-2018-1000611": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-1000613": {"epss_score": 0.04043, "epss_percentile": 0.88168}, "CVE-2018-1000614": {"epss_score": 0.00551, "epss_percentile": 0.67358}, "CVE-2018-1000615": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2018-1000616": {"epss_score": 0.00347, "epss_percentile": 0.56767}, "CVE-2018-1000617": {"epss_score": 0.01105, "epss_percentile": 0.77604}, "CVE-2018-1000618": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2018-1000619": {"epss_score": 0.02759, "epss_percentile": 0.85595}, "CVE-2018-1000620": {"epss_score": 0.00374, "epss_percentile": 0.58538}, "CVE-2018-1000621": {"epss_score": 0.01356, "epss_percentile": 0.79714}, "CVE-2018-1000622": {"epss_score": 0.00801, "epss_percentile": 0.73562}, "CVE-2018-1000623": {"epss_score": 0.0107, "epss_percentile": 0.77254}, "CVE-2018-1000624": {"epss_score": 0.00528, "epss_percentile": 0.66568}, "CVE-2018-1000625": {"epss_score": 0.00309, "epss_percentile": 0.53646}, "CVE-2018-1000626": {"epss_score": 0.00545, "epss_percentile": 0.6717}, "CVE-2018-1000627": {"epss_score": 0.00421, "epss_percentile": 0.61527}, "CVE-2018-1000628": {"epss_score": 0.00457, "epss_percentile": 0.63382}, "CVE-2018-1000629": {"epss_score": 0.00271, "epss_percentile": 0.50327}, "CVE-2018-1000630": {"epss_score": 0.00348, "epss_percentile": 0.56844}, "CVE-2018-1000631": {"epss_score": 0.00422, "epss_percentile": 0.6156}, "CVE-2018-1000632": {"epss_score": 0.01611, "epss_percentile": 0.81324}, "CVE-2018-1000633": {"epss_score": 0.00302, "epss_percentile": 0.53085}, "CVE-2018-1000634": {"epss_score": 0.00273, "epss_percentile": 0.5044}, "CVE-2018-1000635": {"epss_score": 0.00037, "epss_percentile": 0.10912}, "CVE-2018-1000636": {"epss_score": 0.00285, "epss_percentile": 0.51681}, "CVE-2018-1000637": {"epss_score": 0.00399, "epss_percentile": 0.60143}, "CVE-2018-1000638": {"epss_score": 0.00335, "epss_percentile": 0.55857}, "CVE-2018-1000639": {"epss_score": 0.00321, "epss_percentile": 0.54672}, "CVE-2018-1000640": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-1000641": {"epss_score": 0.00819, "epss_percentile": 0.73871}, "CVE-2018-1000642": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-1000644": {"epss_score": 0.00378, "epss_percentile": 0.58789}, "CVE-2018-1000645": {"epss_score": 0.00425, "epss_percentile": 0.61688}, "CVE-2018-1000646": {"epss_score": 0.02544, "epss_percentile": 0.85059}, "CVE-2018-1000647": {"epss_score": 0.00953, "epss_percentile": 0.75888}, "CVE-2018-1000648": {"epss_score": 0.02094, "epss_percentile": 0.8358}, "CVE-2018-1000649": {"epss_score": 0.02094, "epss_percentile": 0.8358}, "CVE-2018-1000650": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2018-1000651": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000652": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000653": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-1000654": {"epss_score": 0.00125, "epss_percentile": 0.32467}, "CVE-2018-1000655": {"epss_score": 0.00317, "epss_percentile": 0.54395}, "CVE-2018-1000656": {"epss_score": 0.0043, "epss_percentile": 0.62011}, "CVE-2018-1000657": {"epss_score": 0.00152, "epss_percentile": 0.36404}, "CVE-2018-1000658": {"epss_score": 0.0072, "epss_percentile": 0.71961}, "CVE-2018-1000659": {"epss_score": 0.02157, "epss_percentile": 0.83815}, "CVE-2018-1000660": {"epss_score": 0.00201, "epss_percentile": 0.4232}, "CVE-2018-1000661": {"epss_score": 0.00317, "epss_percentile": 0.54395}, "CVE-2018-1000663": {"epss_score": 0.00401, "epss_percentile": 0.60244}, "CVE-2018-1000664": {"epss_score": 0.00102, "epss_percentile": 0.28837}, "CVE-2018-1000665": {"epss_score": 0.00277, "epss_percentile": 0.50777}, "CVE-2018-1000666": {"epss_score": 0.03791, "epss_percentile": 0.8773}, "CVE-2018-1000667": {"epss_score": 0.00206, "epss_percentile": 0.42936}, "CVE-2018-1000668": {"epss_score": 0.00372, "epss_percentile": 0.58433}, "CVE-2018-1000669": {"epss_score": 0.00143, "epss_percentile": 0.35166}, "CVE-2018-1000670": {"epss_score": 0.0028, "epss_percentile": 0.51042}, "CVE-2018-1000671": {"epss_score": 0.00883, "epss_percentile": 0.74923}, "CVE-2018-1000773": {"epss_score": 0.23946, "epss_percentile": 0.95836}, "CVE-2018-1000800": {"epss_score": 0.00372, "epss_percentile": 0.58439}, "CVE-2018-1000801": {"epss_score": 0.02278, "epss_percentile": 0.84235}, "CVE-2018-1000802": {"epss_score": 0.2745, "epss_percentile": 0.96246}, "CVE-2018-1000803": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2018-1000804": {"epss_score": 0.11467, "epss_percentile": 0.93375}, "CVE-2018-1000805": {"epss_score": 0.00407, "epss_percentile": 0.6062}, "CVE-2018-1000807": {"epss_score": 0.0303, "epss_percentile": 0.86247}, "CVE-2018-1000808": {"epss_score": 0.00161, "epss_percentile": 0.37534}, "CVE-2018-1000809": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-1000810": {"epss_score": 0.00625, "epss_percentile": 0.69586}, "CVE-2018-1000811": {"epss_score": 0.23071, "epss_percentile": 0.9573}, "CVE-2018-1000812": {"epss_score": 0.00638, "epss_percentile": 0.69913}, "CVE-2018-1000813": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2018-1000814": {"epss_score": 0.00241, "epss_percentile": 0.4728}, "CVE-2018-1000815": {"epss_score": 0.00291, "epss_percentile": 0.5216}, "CVE-2018-1000816": {"epss_score": 0.00444, "epss_percentile": 0.62809}, "CVE-2018-1000817": {"epss_score": 0.00561, "epss_percentile": 0.67679}, "CVE-2018-1000820": {"epss_score": 0.00262, "epss_percentile": 0.49403}, "CVE-2018-1000821": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000822": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000823": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000824": {"epss_score": 0.01979, "epss_percentile": 0.83132}, "CVE-2018-1000825": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000826": {"epss_score": 0.00398, "epss_percentile": 0.60056}, "CVE-2018-1000827": {"epss_score": 0.02042, "epss_percentile": 0.83376}, "CVE-2018-1000828": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000829": {"epss_score": 0.00292, "epss_percentile": 0.52282}, "CVE-2018-1000830": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000831": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000832": {"epss_score": 0.0816, "epss_percentile": 0.91908}, "CVE-2018-1000833": {"epss_score": 0.01979, "epss_percentile": 0.83132}, "CVE-2018-1000834": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000835": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000836": {"epss_score": 0.00292, "epss_percentile": 0.52282}, "CVE-2018-1000837": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000838": {"epss_score": 0.00245, "epss_percentile": 0.47655}, "CVE-2018-1000839": {"epss_score": 0.03837, "epss_percentile": 0.87825}, "CVE-2018-1000840": {"epss_score": 0.00571, "epss_percentile": 0.67974}, "CVE-2018-1000841": {"epss_score": 0.00263, "epss_percentile": 0.49508}, "CVE-2018-1000842": {"epss_score": 0.00436, "epss_percentile": 0.62472}, "CVE-2018-1000843": {"epss_score": 0.00136, "epss_percentile": 0.34178}, "CVE-2018-1000844": {"epss_score": 0.00908, "epss_percentile": 0.75274}, "CVE-2018-1000846": {"epss_score": 0.00232, "epss_percentile": 0.45968}, "CVE-2018-1000847": {"epss_score": 0.00319, "epss_percentile": 0.54474}, "CVE-2018-1000848": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-1000849": {"epss_score": 0.0133, "epss_percentile": 0.79512}, "CVE-2018-1000850": {"epss_score": 0.03057, "epss_percentile": 0.86301}, "CVE-2018-1000851": {"epss_score": 0.00572, "epss_percentile": 0.68023}, "CVE-2018-1000852": {"epss_score": 0.00833, "epss_percentile": 0.74086}, "CVE-2018-1000854": {"epss_score": 0.02515, "epss_percentile": 0.84982}, "CVE-2018-1000855": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-1000856": {"epss_score": 0.0104, "epss_percentile": 0.76956}, "CVE-2018-1000857": {"epss_score": 0.00578, "epss_percentile": 0.68197}, "CVE-2018-1000858": {"epss_score": 0.00203, "epss_percentile": 0.42574}, "CVE-2018-1000860": {"epss_score": 0.00156, "epss_percentile": 0.36992}, "CVE-2018-1000861": {"epss_score": 0.94485, "epss_percentile": 0.99999}, "CVE-2018-1000862": {"epss_score": 0.00184, "epss_percentile": 0.40421}, "CVE-2018-1000863": {"epss_score": 0.0756, "epss_percentile": 0.9154}, "CVE-2018-1000864": {"epss_score": 0.00216, "epss_percentile": 0.4423}, "CVE-2018-1000865": {"epss_score": 0.00615, "epss_percentile": 0.693}, "CVE-2018-1000866": {"epss_score": 0.00615, "epss_percentile": 0.693}, "CVE-2018-1000867": {"epss_score": 0.00374, "epss_percentile": 0.58563}, "CVE-2018-1000868": {"epss_score": 0.00482, "epss_percentile": 0.64547}, "CVE-2018-1000869": {"epss_score": 0.00281, "epss_percentile": 0.51103}, "CVE-2018-1000870": {"epss_score": 0.00344, "epss_percentile": 0.56491}, "CVE-2018-1000871": {"epss_score": 0.00291, "epss_percentile": 0.52205}, "CVE-2018-1000872": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2018-1000873": {"epss_score": 0.02511, "epss_percentile": 0.84951}, "CVE-2018-1000874": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-1000875": {"epss_score": 0.00392, "epss_percentile": 0.59686}, "CVE-2018-1000876": {"epss_score": 0.00133, "epss_percentile": 0.33689}, "CVE-2018-1000877": {"epss_score": 0.01775, "epss_percentile": 0.82217}, "CVE-2018-1000878": {"epss_score": 0.0171, "epss_percentile": 0.81872}, "CVE-2018-1000879": {"epss_score": 0.00775, "epss_percentile": 0.73086}, "CVE-2018-1000880": {"epss_score": 0.00431, "epss_percentile": 0.62055}, "CVE-2018-1000881": {"epss_score": 0.08043, "epss_percentile": 0.91847}, "CVE-2018-1000882": {"epss_score": 0.00504, "epss_percentile": 0.65527}, "CVE-2018-1000883": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2018-1000884": {"epss_score": 0.00567, "epss_percentile": 0.67859}, "CVE-2018-1000885": {"epss_score": 0.24216, "epss_percentile": 0.95888}, "CVE-2018-1000886": {"epss_score": 0.00146, "epss_percentile": 0.35626}, "CVE-2018-1000887": {"epss_score": 0.00366, "epss_percentile": 0.58019}, "CVE-2018-1000888": {"epss_score": 0.29482, "epss_percentile": 0.96447}, "CVE-2018-1000889": {"epss_score": 0.00286, "epss_percentile": 0.51708}, "CVE-2018-1000890": {"epss_score": 0.00604, "epss_percentile": 0.68952}, "CVE-2018-1000891": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2018-1000892": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2018-1000893": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2018-1000997": {"epss_score": 0.01923, "epss_percentile": 0.82911}, "CVE-2018-1000998": {"epss_score": 0.00262, "epss_percentile": 0.49391}, "CVE-2018-1002000": {"epss_score": 0.04786, "epss_percentile": 0.89142}, "CVE-2018-1002001": {"epss_score": 0.00226, "epss_percentile": 0.45264}, "CVE-2018-1002002": {"epss_score": 0.0023, "epss_percentile": 0.45713}, "CVE-2018-1002003": {"epss_score": 0.0023, "epss_percentile": 0.45713}, "CVE-2018-1002004": {"epss_score": 0.0023, "epss_percentile": 0.45713}, "CVE-2018-1002005": {"epss_score": 0.00271, "epss_percentile": 0.50282}, "CVE-2018-1002006": {"epss_score": 0.00174, "epss_percentile": 0.3915}, "CVE-2018-1002007": {"epss_score": 0.00174, "epss_percentile": 0.3915}, "CVE-2018-1002008": {"epss_score": 0.00174, "epss_percentile": 0.3915}, "CVE-2018-1002009": {"epss_score": 0.0017, "epss_percentile": 0.38751}, "CVE-2018-1002100": {"epss_score": 0.0051, "epss_percentile": 0.65792}, "CVE-2018-1002101": {"epss_score": 0.01011, "epss_percentile": 0.76609}, "CVE-2018-1002102": {"epss_score": 0.00206, "epss_percentile": 0.43033}, "CVE-2018-1002103": {"epss_score": 0.00175, "epss_percentile": 0.39356}, "CVE-2018-1002104": {"epss_score": 0.00436, "epss_percentile": 0.62382}, "CVE-2018-1002105": {"epss_score": 0.90698, "epss_percentile": 0.99596}, "CVE-2018-1002150": {"epss_score": 0.00302, "epss_percentile": 0.53135}, "CVE-2018-1002200": {"epss_score": 0.01901, "epss_percentile": 0.82777}, "CVE-2018-1002201": {"epss_score": 0.01877, "epss_percentile": 0.82661}, "CVE-2018-1002202": {"epss_score": 0.02878, "epss_percentile": 0.85888}, "CVE-2018-1002203": {"epss_score": 0.0557, "epss_percentile": 0.90005}, "CVE-2018-1002204": {"epss_score": 0.17577, "epss_percentile": 0.94869}, "CVE-2018-1002205": {"epss_score": 0.00387, "epss_percentile": 0.5931}, "CVE-2018-1002206": {"epss_score": 0.02504, "epss_percentile": 0.84933}, "CVE-2018-1002207": {"epss_score": 0.02615, "epss_percentile": 0.85244}, "CVE-2018-1002208": {"epss_score": 0.00548, "epss_percentile": 0.6727}, "CVE-2018-1002209": {"epss_score": 0.00857, "epss_percentile": 0.74497}, "CVE-2018-10000": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-10001": {"epss_score": 0.00975, "epss_percentile": 0.76195}, "CVE-2018-10016": {"epss_score": 0.00156, "epss_percentile": 0.36943}, "CVE-2018-10017": {"epss_score": 0.01816, "epss_percentile": 0.8239}, "CVE-2018-10018": {"epss_score": 0.08037, "epss_percentile": 0.91847}, "CVE-2018-10021": {"epss_score": 0.00035, "epss_percentile": 0.1005}, "CVE-2018-10023": {"epss_score": 0.00437, "epss_percentile": 0.62517}, "CVE-2018-10024": {"epss_score": 0.00563, "epss_percentile": 0.67729}, "CVE-2018-10026": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10027": {"epss_score": 0.00067, "epss_percentile": 0.20974}, "CVE-2018-10028": {"epss_score": 0.00244, "epss_percentile": 0.47619}, "CVE-2018-10029": {"epss_score": 0.00215, "epss_percentile": 0.44051}, "CVE-2018-10030": {"epss_score": 0.00171, "epss_percentile": 0.38862}, "CVE-2018-10031": {"epss_score": 0.00171, "epss_percentile": 0.38862}, "CVE-2018-10032": {"epss_score": 0.00215, "epss_percentile": 0.44051}, "CVE-2018-10033": {"epss_score": 0.00215, "epss_percentile": 0.44051}, "CVE-2018-10048": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2018-10049": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2018-10050": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2018-10051": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2018-10052": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2018-10054": {"epss_score": 0.53325, "epss_percentile": 0.97871}, "CVE-2018-10055": {"epss_score": 0.00174, "epss_percentile": 0.39155}, "CVE-2018-10057": {"epss_score": 0.00527, "epss_percentile": 0.66454}, "CVE-2018-10058": {"epss_score": 0.15368, "epss_percentile": 0.94416}, "CVE-2018-10059": {"epss_score": 0.00287, "epss_percentile": 0.51792}, "CVE-2018-10060": {"epss_score": 0.00667, "epss_percentile": 0.70701}, "CVE-2018-10061": {"epss_score": 0.00955, "epss_percentile": 0.75919}, "CVE-2018-10063": {"epss_score": 0.03344, "epss_percentile": 0.86949}, "CVE-2018-10066": {"epss_score": 0.00723, "epss_percentile": 0.7202}, "CVE-2018-10068": {"epss_score": 0.03988, "epss_percentile": 0.88066}, "CVE-2018-10070": {"epss_score": 0.17841, "epss_percentile": 0.94915}, "CVE-2018-10071": {"epss_score": 0.00049, "epss_percentile": 0.153}, "CVE-2018-10072": {"epss_score": 0.00049, "epss_percentile": 0.153}, "CVE-2018-10073": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10074": {"epss_score": 0.00038, "epss_percentile": 0.11325}, "CVE-2018-10075": {"epss_score": 0.00514, "epss_percentile": 0.65959}, "CVE-2018-10076": {"epss_score": 0.00514, "epss_percentile": 0.65959}, "CVE-2018-10077": {"epss_score": 0.14111, "epss_percentile": 0.94134}, "CVE-2018-10078": {"epss_score": 0.00436, "epss_percentile": 0.62434}, "CVE-2018-10079": {"epss_score": 0.00082, "epss_percentile": 0.24435}, "CVE-2018-10080": {"epss_score": 0.00107, "epss_percentile": 0.29613}, "CVE-2018-10081": {"epss_score": 0.00489, "epss_percentile": 0.64883}, "CVE-2018-10082": {"epss_score": 0.00289, "epss_percentile": 0.51981}, "CVE-2018-10083": {"epss_score": 0.0089, "epss_percentile": 0.7503}, "CVE-2018-10084": {"epss_score": 0.00163, "epss_percentile": 0.37771}, "CVE-2018-10085": {"epss_score": 0.02873, "epss_percentile": 0.85879}, "CVE-2018-10086": {"epss_score": 0.00967, "epss_percentile": 0.76073}, "CVE-2018-10087": {"epss_score": 0.00084, "epss_percentile": 0.24981}, "CVE-2018-10088": {"epss_score": 0.89819, "epss_percentile": 0.99542}, "CVE-2018-10091": {"epss_score": 0.00229, "epss_percentile": 0.4565}, "CVE-2018-10092": {"epss_score": 0.00426, "epss_percentile": 0.6177}, "CVE-2018-10093": {"epss_score": 0.67408, "epss_percentile": 0.98505}, "CVE-2018-10094": {"epss_score": 0.73712, "epss_percentile": 0.98768}, "CVE-2018-10095": {"epss_score": 0.53955, "epss_percentile": 0.97904}, "CVE-2018-10096": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10097": {"epss_score": 0.01433, "epss_percentile": 0.80256}, "CVE-2018-10098": {"epss_score": 0.00049, "epss_percentile": 0.153}, "CVE-2018-10099": {"epss_score": 0.00105, "epss_percentile": 0.29395}, "CVE-2018-10100": {"epss_score": 0.06599, "epss_percentile": 0.90877}, "CVE-2018-10101": {"epss_score": 0.09391, "epss_percentile": 0.9253}, "CVE-2018-10102": {"epss_score": 0.05168, "epss_percentile": 0.89567}, "CVE-2018-10103": {"epss_score": 0.00401, "epss_percentile": 0.60205}, "CVE-2018-10105": {"epss_score": 0.00369, "epss_percentile": 0.58223}, "CVE-2018-10106": {"epss_score": 0.00675, "epss_percentile": 0.70915}, "CVE-2018-10107": {"epss_score": 0.00289, "epss_percentile": 0.52046}, "CVE-2018-10108": {"epss_score": 0.00289, "epss_percentile": 0.52046}, "CVE-2018-10109": {"epss_score": 0.00286, "epss_percentile": 0.51743}, "CVE-2018-10110": {"epss_score": 0.00249, "epss_percentile": 0.48071}, "CVE-2018-10111": {"epss_score": 0.00381, "epss_percentile": 0.58999}, "CVE-2018-10112": {"epss_score": 0.00379, "epss_percentile": 0.5888}, "CVE-2018-10113": {"epss_score": 0.00381, "epss_percentile": 0.58999}, "CVE-2018-10114": {"epss_score": 0.00379, "epss_percentile": 0.5888}, "CVE-2018-10115": {"epss_score": 0.0758, "epss_percentile": 0.91552}, "CVE-2018-10117": {"epss_score": 0.00115, "epss_percentile": 0.3102}, "CVE-2018-10118": {"epss_score": 0.00391, "epss_percentile": 0.59574}, "CVE-2018-10119": {"epss_score": 0.00545, "epss_percentile": 0.67164}, "CVE-2018-10120": {"epss_score": 0.00499, "epss_percentile": 0.65254}, "CVE-2018-10121": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10122": {"epss_score": 0.0053, "epss_percentile": 0.66629}, "CVE-2018-10123": {"epss_score": 0.17135, "epss_percentile": 0.9478}, "CVE-2018-10124": {"epss_score": 0.00035, "epss_percentile": 0.09994}, "CVE-2018-10125": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-10126": {"epss_score": 0.00459, "epss_percentile": 0.6346}, "CVE-2018-10127": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2018-10128": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10132": {"epss_score": 0.00168, "epss_percentile": 0.38442}, "CVE-2018-10133": {"epss_score": 0.00397, "epss_percentile": 0.59986}, "CVE-2018-10135": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-10136": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10137": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2018-10138": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10139": {"epss_score": 0.00764, "epss_percentile": 0.72907}, "CVE-2018-10140": {"epss_score": 0.0066, "epss_percentile": 0.70535}, "CVE-2018-10141": {"epss_score": 0.44152, "epss_percentile": 0.97421}, "CVE-2018-10142": {"epss_score": 0.0075, "epss_percentile": 0.72622}, "CVE-2018-10143": {"epss_score": 0.28135, "epss_percentile": 0.96314}, "CVE-2018-10164": {"epss_score": 0.00303, "epss_percentile": 0.53195}, "CVE-2018-10165": {"epss_score": 0.00257, "epss_percentile": 0.48878}, "CVE-2018-10166": {"epss_score": 0.00383, "epss_percentile": 0.59114}, "CVE-2018-10167": {"epss_score": 0.00433, "epss_percentile": 0.62225}, "CVE-2018-10168": {"epss_score": 0.00588, "epss_percentile": 0.68504}, "CVE-2018-10169": {"epss_score": 0.00583, "epss_percentile": 0.68344}, "CVE-2018-10170": {"epss_score": 0.00583, "epss_percentile": 0.68344}, "CVE-2018-10171": {"epss_score": 0.00299, "epss_percentile": 0.52886}, "CVE-2018-10172": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2018-10173": {"epss_score": 0.01688, "epss_percentile": 0.81762}, "CVE-2018-10174": {"epss_score": 0.00178, "epss_percentile": 0.3969}, "CVE-2018-10175": {"epss_score": 0.00186, "epss_percentile": 0.40664}, "CVE-2018-10176": {"epss_score": 0.02253, "epss_percentile": 0.84164}, "CVE-2018-10177": {"epss_score": 0.00329, "epss_percentile": 0.55383}, "CVE-2018-10178": {"epss_score": 0.00233, "epss_percentile": 0.45987}, "CVE-2018-10183": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10184": {"epss_score": 0.25058, "epss_percentile": 0.95983}, "CVE-2018-10185": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2018-10186": {"epss_score": 0.00226, "epss_percentile": 0.45309}, "CVE-2018-10187": {"epss_score": 0.00226, "epss_percentile": 0.45309}, "CVE-2018-10188": {"epss_score": 0.00935, "epss_percentile": 0.75662}, "CVE-2018-10189": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2018-10190": {"epss_score": 0.00122, "epss_percentile": 0.32138}, "CVE-2018-10191": {"epss_score": 0.01293, "epss_percentile": 0.7924}, "CVE-2018-10192": {"epss_score": 0.00695, "epss_percentile": 0.71379}, "CVE-2018-10193": {"epss_score": 0.00934, "epss_percentile": 0.75646}, "CVE-2018-10194": {"epss_score": 0.00648, "epss_percentile": 0.70213}, "CVE-2018-10195": {"epss_score": 0.00051, "epss_percentile": 0.16014}, "CVE-2018-10196": {"epss_score": 0.001, "epss_percentile": 0.28472}, "CVE-2018-10197": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-10198": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2018-10199": {"epss_score": 0.01443, "epss_percentile": 0.80312}, "CVE-2018-10201": {"epss_score": 0.81415, "epss_percentile": 0.99137}, "CVE-2018-10204": {"epss_score": 0.00489, "epss_percentile": 0.64868}, "CVE-2018-10205": {"epss_score": 0.00305, "epss_percentile": 0.53327}, "CVE-2018-10206": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-10207": {"epss_score": 0.00206, "epss_percentile": 0.42787}, "CVE-2018-10208": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10209": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-10210": {"epss_score": 0.00206, "epss_percentile": 0.42787}, "CVE-2018-10211": {"epss_score": 0.00206, "epss_percentile": 0.42787}, "CVE-2018-10212": {"epss_score": 0.00146, "epss_percentile": 0.35621}, "CVE-2018-10213": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-10219": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2018-10220": {"epss_score": 0.00433, "epss_percentile": 0.62204}, "CVE-2018-10221": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-10222": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2018-10223": {"epss_score": 0.00132, "epss_percentile": 0.33579}, "CVE-2018-10224": {"epss_score": 0.00132, "epss_percentile": 0.33579}, "CVE-2018-10225": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-10227": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-10228": {"epss_score": 0.0023, "epss_percentile": 0.45724}, "CVE-2018-10229": {"epss_score": 0.00325, "epss_percentile": 0.55021}, "CVE-2018-10230": {"epss_score": 0.03364, "epss_percentile": 0.86998}, "CVE-2018-10231": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2018-10232": {"epss_score": 0.00096, "epss_percentile": 0.27347}, "CVE-2018-10233": {"epss_score": 0.0017, "epss_percentile": 0.38649}, "CVE-2018-10234": {"epss_score": 0.0035, "epss_percentile": 0.56967}, "CVE-2018-10235": {"epss_score": 0.00883, "epss_percentile": 0.74916}, "CVE-2018-10236": {"epss_score": 0.00883, "epss_percentile": 0.74916}, "CVE-2018-10237": {"epss_score": 0.03259, "epss_percentile": 0.86769}, "CVE-2018-10238": {"epss_score": 0.00492, "epss_percentile": 0.64996}, "CVE-2018-10239": {"epss_score": 0.00122, "epss_percentile": 0.32151}, "CVE-2018-10240": {"epss_score": 0.01355, "epss_percentile": 0.79707}, "CVE-2018-10241": {"epss_score": 0.01466, "epss_percentile": 0.80465}, "CVE-2018-10242": {"epss_score": 0.00413, "epss_percentile": 0.60962}, "CVE-2018-10243": {"epss_score": 0.00822, "epss_percentile": 0.73914}, "CVE-2018-10244": {"epss_score": 0.00668, "epss_percentile": 0.70733}, "CVE-2018-10245": {"epss_score": 0.00111, "epss_percentile": 0.30268}, "CVE-2018-10248": {"epss_score": 0.00117, "epss_percentile": 0.31307}, "CVE-2018-10249": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2018-10250": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-10251": {"epss_score": 0.0008, "epss_percentile": 0.2407}, "CVE-2018-10252": {"epss_score": 0.00324, "epss_percentile": 0.54957}, "CVE-2018-10253": {"epss_score": 0.10232, "epss_percentile": 0.92904}, "CVE-2018-10254": {"epss_score": 0.0027, "epss_percentile": 0.50195}, "CVE-2018-10255": {"epss_score": 0.02473, "epss_percentile": 0.84852}, "CVE-2018-10256": {"epss_score": 0.00237, "epss_percentile": 0.4671}, "CVE-2018-10257": {"epss_score": 0.00782, "epss_percentile": 0.73201}, "CVE-2018-10258": {"epss_score": 0.02613, "epss_percentile": 0.8524}, "CVE-2018-10259": {"epss_score": 0.00188, "epss_percentile": 0.40879}, "CVE-2018-10260": {"epss_score": 0.0202, "epss_percentile": 0.83293}, "CVE-2018-10265": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2018-10266": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2018-10267": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2018-10268": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-10283": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-10284": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-10285": {"epss_score": 0.47703, "epss_percentile": 0.97597}, "CVE-2018-10286": {"epss_score": 0.04307, "epss_percentile": 0.88524}, "CVE-2018-10289": {"epss_score": 0.00414, "epss_percentile": 0.61025}, "CVE-2018-10294": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10295": {"epss_score": 0.00134, "epss_percentile": 0.33789}, "CVE-2018-10296": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10297": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-10298": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-10299": {"epss_score": 0.012, "epss_percentile": 0.78478}, "CVE-2018-10300": {"epss_score": 0.00188, "epss_percentile": 0.40886}, "CVE-2018-10301": {"epss_score": 0.00188, "epss_percentile": 0.40886}, "CVE-2018-10302": {"epss_score": 0.00713, "epss_percentile": 0.71801}, "CVE-2018-10303": {"epss_score": 0.00594, "epss_percentile": 0.68654}, "CVE-2018-10305": {"epss_score": 0.004, "epss_percentile": 0.60181}, "CVE-2018-10306": {"epss_score": 0.00284, "epss_percentile": 0.51471}, "CVE-2018-10307": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-10309": {"epss_score": 0.00248, "epss_percentile": 0.47963}, "CVE-2018-10310": {"epss_score": 0.0178, "epss_percentile": 0.82236}, "CVE-2018-10311": {"epss_score": 0.00437, "epss_percentile": 0.62497}, "CVE-2018-10312": {"epss_score": 0.00314, "epss_percentile": 0.54103}, "CVE-2018-10313": {"epss_score": 0.00243, "epss_percentile": 0.47458}, "CVE-2018-10314": {"epss_score": 0.00194, "epss_percentile": 0.41539}, "CVE-2018-10316": {"epss_score": 0.00156, "epss_percentile": 0.36943}, "CVE-2018-10318": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10319": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10320": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10321": {"epss_score": 0.01287, "epss_percentile": 0.79196}, "CVE-2018-10322": {"epss_score": 0.00051, "epss_percentile": 0.16259}, "CVE-2018-10323": {"epss_score": 0.00084, "epss_percentile": 0.24887}, "CVE-2018-10326": {"epss_score": 0.0031, "epss_percentile": 0.53776}, "CVE-2018-10327": {"epss_score": 0.00054, "epss_percentile": 0.17318}, "CVE-2018-10328": {"epss_score": 0.00148, "epss_percentile": 0.35856}, "CVE-2018-10329": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10350": {"epss_score": 0.40924, "epss_percentile": 0.97245}, "CVE-2018-10351": {"epss_score": 0.08172, "epss_percentile": 0.91914}, "CVE-2018-10352": {"epss_score": 0.02285, "epss_percentile": 0.84267}, "CVE-2018-10353": {"epss_score": 0.0041, "epss_percentile": 0.608}, "CVE-2018-10354": {"epss_score": 0.06361, "epss_percentile": 0.907}, "CVE-2018-10355": {"epss_score": 0.001, "epss_percentile": 0.28548}, "CVE-2018-10356": {"epss_score": 0.08878, "epss_percentile": 0.92298}, "CVE-2018-10357": {"epss_score": 0.70238, "epss_percentile": 0.98624}, "CVE-2018-10358": {"epss_score": 0.00084, "epss_percentile": 0.24918}, "CVE-2018-10359": {"epss_score": 0.00084, "epss_percentile": 0.24918}, "CVE-2018-10360": {"epss_score": 0.01597, "epss_percentile": 0.81244}, "CVE-2018-10361": {"epss_score": 0.00043, "epss_percentile": 0.1324}, "CVE-2018-10362": {"epss_score": 0.00301, "epss_percentile": 0.53046}, "CVE-2018-10363": {"epss_score": 0.00296, "epss_percentile": 0.52627}, "CVE-2018-10364": {"epss_score": 0.00227, "epss_percentile": 0.45365}, "CVE-2018-10365": {"epss_score": 0.00188, "epss_percentile": 0.40809}, "CVE-2018-10366": {"epss_score": 0.00482, "epss_percentile": 0.64544}, "CVE-2018-10367": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10368": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10369": {"epss_score": 0.00383, "epss_percentile": 0.59088}, "CVE-2018-10371": {"epss_score": 0.02516, "epss_percentile": 0.84984}, "CVE-2018-10372": {"epss_score": 0.00422, "epss_percentile": 0.61568}, "CVE-2018-10373": {"epss_score": 0.01071, "epss_percentile": 0.77271}, "CVE-2018-10374": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10375": {"epss_score": 0.00557, "epss_percentile": 0.67553}, "CVE-2018-10376": {"epss_score": 0.00267, "epss_percentile": 0.49993}, "CVE-2018-10377": {"epss_score": 0.00135, "epss_percentile": 0.34012}, "CVE-2018-10379": {"epss_score": 0.00062, "epss_percentile": 0.19562}, "CVE-2018-10380": {"epss_score": 0.00092, "epss_percentile": 0.26546}, "CVE-2018-10381": {"epss_score": 0.00648, "epss_percentile": 0.70218}, "CVE-2018-10382": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-10383": {"epss_score": 0.05855, "epss_percentile": 0.90267}, "CVE-2018-10387": {"epss_score": 0.08191, "epss_percentile": 0.91921}, "CVE-2018-10388": {"epss_score": 0.18152, "epss_percentile": 0.94966}, "CVE-2018-10389": {"epss_score": 0.02739, "epss_percentile": 0.85556}, "CVE-2018-10391": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10392": {"epss_score": 0.01319, "epss_percentile": 0.79435}, "CVE-2018-10393": {"epss_score": 0.00269, "epss_percentile": 0.5011}, "CVE-2018-10403": {"epss_score": 0.00224, "epss_percentile": 0.45021}, "CVE-2018-10404": {"epss_score": 0.00224, "epss_percentile": 0.45021}, "CVE-2018-10405": {"epss_score": 0.00078, "epss_percentile": 0.23617}, "CVE-2018-10406": {"epss_score": 0.00224, "epss_percentile": 0.45021}, "CVE-2018-10407": {"epss_score": 0.00089, "epss_percentile": 0.25819}, "CVE-2018-10408": {"epss_score": 0.00224, "epss_percentile": 0.45021}, "CVE-2018-10422": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10423": {"epss_score": 0.0018, "epss_percentile": 0.39888}, "CVE-2018-10424": {"epss_score": 0.00228, "epss_percentile": 0.45466}, "CVE-2018-10425": {"epss_score": 0.0005, "epss_percentile": 0.15965}, "CVE-2018-10428": {"epss_score": 0.00466, "epss_percentile": 0.63794}, "CVE-2018-10429": {"epss_score": 0.00486, "epss_percentile": 0.64774}, "CVE-2018-10430": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10431": {"epss_score": 0.02373, "epss_percentile": 0.84531}, "CVE-2018-10432": {"epss_score": 0.00528, "epss_percentile": 0.66569}, "CVE-2018-10465": {"epss_score": 0.00638, "epss_percentile": 0.69922}, "CVE-2018-10466": {"epss_score": 0.09847, "epss_percentile": 0.92733}, "CVE-2018-10468": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2018-10469": {"epss_score": 0.00799, "epss_percentile": 0.73522}, "CVE-2018-10470": {"epss_score": 0.0011, "epss_percentile": 0.30228}, "CVE-2018-10471": {"epss_score": 0.0011, "epss_percentile": 0.30149}, "CVE-2018-10472": {"epss_score": 0.00088, "epss_percentile": 0.25658}, "CVE-2018-10473": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2018-10474": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2018-10475": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-10476": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-10477": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2018-10478": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-10479": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-10480": {"epss_score": 0.00391, "epss_percentile": 0.59569}, "CVE-2018-10481": {"epss_score": 0.00391, "epss_percentile": 0.59569}, "CVE-2018-10482": {"epss_score": 0.00391, "epss_percentile": 0.59569}, "CVE-2018-10483": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2018-10484": {"epss_score": 0.00223, "epss_percentile": 0.44894}, "CVE-2018-10485": {"epss_score": 0.00391, "epss_percentile": 0.59569}, "CVE-2018-10486": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-10487": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-10488": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2018-10489": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2018-10490": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2018-10491": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2018-10492": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-10493": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-10494": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2018-10495": {"epss_score": 0.00223, "epss_percentile": 0.44894}, "CVE-2018-10496": {"epss_score": 0.0093, "epss_percentile": 0.75595}, "CVE-2018-10497": {"epss_score": 0.00056, "epss_percentile": 0.17691}, "CVE-2018-10498": {"epss_score": 0.00059, "epss_percentile": 0.1878}, "CVE-2018-10499": {"epss_score": 0.00077, "epss_percentile": 0.23389}, "CVE-2018-10500": {"epss_score": 0.00046, "epss_percentile": 0.14472}, "CVE-2018-10501": {"epss_score": 0.00044, "epss_percentile": 0.13556}, "CVE-2018-10502": {"epss_score": 0.00046, "epss_percentile": 0.14472}, "CVE-2018-10503": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2018-10504": {"epss_score": 0.03023, "epss_percentile": 0.86229}, "CVE-2018-10505": {"epss_score": 0.00084, "epss_percentile": 0.24918}, "CVE-2018-10506": {"epss_score": 0.00111, "epss_percentile": 0.30297}, "CVE-2018-10507": {"epss_score": 0.00796, "epss_percentile": 0.73479}, "CVE-2018-10508": {"epss_score": 0.00593, "epss_percentile": 0.68646}, "CVE-2018-10509": {"epss_score": 0.00438, "epss_percentile": 0.62547}, "CVE-2018-10510": {"epss_score": 0.03801, "epss_percentile": 0.87745}, "CVE-2018-10511": {"epss_score": 0.00368, "epss_percentile": 0.58211}, "CVE-2018-10512": {"epss_score": 0.00699, "epss_percentile": 0.71454}, "CVE-2018-10513": {"epss_score": 0.00059, "epss_percentile": 0.18689}, "CVE-2018-10514": {"epss_score": 0.00061, "epss_percentile": 0.19415}, "CVE-2018-10515": {"epss_score": 0.02607, "epss_percentile": 0.85229}, "CVE-2018-10516": {"epss_score": 0.00406, "epss_percentile": 0.60541}, "CVE-2018-10517": {"epss_score": 0.17792, "epss_percentile": 0.94907}, "CVE-2018-10518": {"epss_score": 0.00207, "epss_percentile": 0.43123}, "CVE-2018-10519": {"epss_score": 0.00357, "epss_percentile": 0.57468}, "CVE-2018-10520": {"epss_score": 0.00207, "epss_percentile": 0.43123}, "CVE-2018-10521": {"epss_score": 0.00284, "epss_percentile": 0.51453}, "CVE-2018-10522": {"epss_score": 0.00271, "epss_percentile": 0.50277}, "CVE-2018-10523": {"epss_score": 0.00477, "epss_percentile": 0.64305}, "CVE-2018-10527": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-10528": {"epss_score": 0.0194, "epss_percentile": 0.82976}, "CVE-2018-10529": {"epss_score": 0.00406, "epss_percentile": 0.60566}, "CVE-2018-10531": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2018-10532": {"epss_score": 0.00072, "epss_percentile": 0.22347}, "CVE-2018-10534": {"epss_score": 0.00215, "epss_percentile": 0.4412}, "CVE-2018-10535": {"epss_score": 0.00122, "epss_percentile": 0.32027}, "CVE-2018-10536": {"epss_score": 0.01005, "epss_percentile": 0.76542}, "CVE-2018-10537": {"epss_score": 0.00962, "epss_percentile": 0.75997}, "CVE-2018-10538": {"epss_score": 0.00643, "epss_percentile": 0.70062}, "CVE-2018-10539": {"epss_score": 0.00616, "epss_percentile": 0.69319}, "CVE-2018-10540": {"epss_score": 0.00375, "epss_percentile": 0.58626}, "CVE-2018-10544": {"epss_score": 0.00701, "epss_percentile": 0.715}, "CVE-2018-10545": {"epss_score": 0.00042, "epss_percentile": 0.12616}, "CVE-2018-10546": {"epss_score": 0.54713, "epss_percentile": 0.9794}, "CVE-2018-10547": {"epss_score": 0.16216, "epss_percentile": 0.94596}, "CVE-2018-10548": {"epss_score": 0.51085, "epss_percentile": 0.97764}, "CVE-2018-10549": {"epss_score": 0.02272, "epss_percentile": 0.84218}, "CVE-2018-10550": {"epss_score": 0.00222, "epss_percentile": 0.44791}, "CVE-2018-10553": {"epss_score": 0.03135, "epss_percentile": 0.86479}, "CVE-2018-10554": {"epss_score": 0.02176, "epss_percentile": 0.83884}, "CVE-2018-10561": {"epss_score": 0.93311, "epss_percentile": 0.99796}, "CVE-2018-10562": {"epss_score": 0.94028, "epss_percentile": 0.99889}, "CVE-2018-10563": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10564": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10565": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10566": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10567": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10568": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10569": {"epss_score": 0.00286, "epss_percentile": 0.51749}, "CVE-2018-10570": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-10571": {"epss_score": 0.00141, "epss_percentile": 0.34821}, "CVE-2018-10572": {"epss_score": 0.00266, "epss_percentile": 0.49889}, "CVE-2018-10573": {"epss_score": 0.00669, "epss_percentile": 0.7076}, "CVE-2018-10574": {"epss_score": 0.00878, "epss_percentile": 0.74829}, "CVE-2018-10575": {"epss_score": 0.11206, "epss_percentile": 0.93264}, "CVE-2018-10576": {"epss_score": 0.00252, "epss_percentile": 0.48387}, "CVE-2018-10577": {"epss_score": 0.0462, "epss_percentile": 0.8893}, "CVE-2018-10578": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2018-10580": {"epss_score": 0.00188, "epss_percentile": 0.40879}, "CVE-2018-10581": {"epss_score": 0.00227, "epss_percentile": 0.45433}, "CVE-2018-10583": {"epss_score": 0.71895, "epss_percentile": 0.98685}, "CVE-2018-10585": {"epss_score": 0.00682, "epss_percentile": 0.71062}, "CVE-2018-10586": {"epss_score": 0.00207, "epss_percentile": 0.43195}, "CVE-2018-10587": {"epss_score": 0.02111, "epss_percentile": 0.83647}, "CVE-2018-10589": {"epss_score": 0.03351, "epss_percentile": 0.86963}, "CVE-2018-10590": {"epss_score": 0.00433, "epss_percentile": 0.62221}, "CVE-2018-10591": {"epss_score": 0.00159, "epss_percentile": 0.37416}, "CVE-2018-10592": {"epss_score": 0.0681, "epss_percentile": 0.9104}, "CVE-2018-10593": {"epss_score": 0.00172, "epss_percentile": 0.38985}, "CVE-2018-10594": {"epss_score": 0.78809, "epss_percentile": 0.99004}, "CVE-2018-10595": {"epss_score": 0.00209, "epss_percentile": 0.43363}, "CVE-2018-10596": {"epss_score": 0.00191, "epss_percentile": 0.41269}, "CVE-2018-10597": {"epss_score": 0.00126, "epss_percentile": 0.3276}, "CVE-2018-10598": {"epss_score": 0.01356, "epss_percentile": 0.79713}, "CVE-2018-10599": {"epss_score": 0.00093, "epss_percentile": 0.26659}, "CVE-2018-10600": {"epss_score": 0.00777, "epss_percentile": 0.73116}, "CVE-2018-10601": {"epss_score": 0.00117, "epss_percentile": 0.31224}, "CVE-2018-10602": {"epss_score": 0.00428, "epss_percentile": 0.61922}, "CVE-2018-10603": {"epss_score": 0.03059, "epss_percentile": 0.86305}, "CVE-2018-10604": {"epss_score": 0.00609, "epss_percentile": 0.69095}, "CVE-2018-10605": {"epss_score": 0.00196, "epss_percentile": 0.41803}, "CVE-2018-10606": {"epss_score": 0.00428, "epss_percentile": 0.61922}, "CVE-2018-10607": {"epss_score": 0.01257, "epss_percentile": 0.78946}, "CVE-2018-10608": {"epss_score": 0.05467, "epss_percentile": 0.89906}, "CVE-2018-10609": {"epss_score": 0.00449, "epss_percentile": 0.63038}, "CVE-2018-10610": {"epss_score": 0.00308, "epss_percentile": 0.5363}, "CVE-2018-10611": {"epss_score": 0.0546, "epss_percentile": 0.899}, "CVE-2018-10612": {"epss_score": 0.00101, "epss_percentile": 0.28583}, "CVE-2018-10613": {"epss_score": 0.00961, "epss_percentile": 0.7598}, "CVE-2018-10614": {"epss_score": 0.00256, "epss_percentile": 0.4883}, "CVE-2018-10615": {"epss_score": 0.01735, "epss_percentile": 0.82006}, "CVE-2018-10616": {"epss_score": 0.00244, "epss_percentile": 0.47609}, "CVE-2018-10617": {"epss_score": 0.02701, "epss_percentile": 0.85454}, "CVE-2018-10618": {"epss_score": 0.19279, "epss_percentile": 0.95159}, "CVE-2018-10619": {"epss_score": 0.00024, "epss_percentile": 0.05975}, "CVE-2018-10620": {"epss_score": 0.05254, "epss_percentile": 0.89665}, "CVE-2018-10621": {"epss_score": 0.02701, "epss_percentile": 0.85454}, "CVE-2018-10622": {"epss_score": 0.0006, "epss_percentile": 0.18935}, "CVE-2018-10623": {"epss_score": 0.02701, "epss_percentile": 0.85454}, "CVE-2018-10624": {"epss_score": 0.0013, "epss_percentile": 0.33267}, "CVE-2018-10626": {"epss_score": 0.00036, "epss_percentile": 0.10326}, "CVE-2018-10627": {"epss_score": 0.00266, "epss_percentile": 0.49878}, "CVE-2018-10628": {"epss_score": 0.05612, "epss_percentile": 0.90048}, "CVE-2018-10630": {"epss_score": 0.00282, "epss_percentile": 0.51237}, "CVE-2018-10631": {"epss_score": 0.00152, "epss_percentile": 0.36416}, "CVE-2018-10632": {"epss_score": 0.00424, "epss_percentile": 0.61674}, "CVE-2018-10633": {"epss_score": 0.00554, "epss_percentile": 0.67437}, "CVE-2018-10634": {"epss_score": 0.00128, "epss_percentile": 0.3297}, "CVE-2018-10635": {"epss_score": 0.03353, "epss_percentile": 0.86967}, "CVE-2018-10636": {"epss_score": 0.04178, "epss_percentile": 0.88354}, "CVE-2018-10637": {"epss_score": 0.00463, "epss_percentile": 0.63676}, "CVE-2018-10641": {"epss_score": 0.02127, "epss_percentile": 0.83698}, "CVE-2018-10642": {"epss_score": 0.03801, "epss_percentile": 0.87745}, "CVE-2018-10645": {"epss_score": 0.00044, "epss_percentile": 0.13582}, "CVE-2018-10646": {"epss_score": 0.00044, "epss_percentile": 0.13582}, "CVE-2018-10647": {"epss_score": 0.00055, "epss_percentile": 0.17472}, "CVE-2018-10648": {"epss_score": 0.00579, "epss_percentile": 0.68212}, "CVE-2018-10649": {"epss_score": 0.00328, "epss_percentile": 0.55154}, "CVE-2018-10650": {"epss_score": 0.00205, "epss_percentile": 0.42722}, "CVE-2018-10651": {"epss_score": 0.00177, "epss_percentile": 0.39612}, "CVE-2018-10652": {"epss_score": 0.00341, "epss_percentile": 0.56346}, "CVE-2018-10653": {"epss_score": 0.11484, "epss_percentile": 0.93381}, "CVE-2018-10654": {"epss_score": 0.00361, "epss_percentile": 0.57704}, "CVE-2018-10655": {"epss_score": 0.02103, "epss_percentile": 0.8361}, "CVE-2018-10657": {"epss_score": 0.00402, "epss_percentile": 0.60297}, "CVE-2018-10658": {"epss_score": 0.00605, "epss_percentile": 0.68993}, "CVE-2018-10659": {"epss_score": 0.0119, "epss_percentile": 0.78393}, "CVE-2018-10660": {"epss_score": 0.92267, "epss_percentile": 0.99704}, "CVE-2018-10661": {"epss_score": 0.90019, "epss_percentile": 0.99557}, "CVE-2018-10662": {"epss_score": 0.88615, "epss_percentile": 0.99481}, "CVE-2018-10663": {"epss_score": 0.00451, "epss_percentile": 0.63128}, "CVE-2018-10664": {"epss_score": 0.00605, "epss_percentile": 0.68993}, "CVE-2018-10665": {"epss_score": 0.00284, "epss_percentile": 0.51471}, "CVE-2018-10666": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-10675": {"epss_score": 0.00035, "epss_percentile": 0.09879}, "CVE-2018-10676": {"epss_score": 0.00518, "epss_percentile": 0.66126}, "CVE-2018-10677": {"epss_score": 0.00568, "epss_percentile": 0.67904}, "CVE-2018-10678": {"epss_score": 0.00234, "epss_percentile": 0.46103}, "CVE-2018-10680": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-10682": {"epss_score": 0.09593, "epss_percentile": 0.92613}, "CVE-2018-10683": {"epss_score": 0.00358, "epss_percentile": 0.57521}, "CVE-2018-10685": {"epss_score": 0.00559, "epss_percentile": 0.67624}, "CVE-2018-10686": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2018-10689": {"epss_score": 0.00298, "epss_percentile": 0.52837}, "CVE-2018-10690": {"epss_score": 0.00264, "epss_percentile": 0.49712}, "CVE-2018-10691": {"epss_score": 0.00888, "epss_percentile": 0.74997}, "CVE-2018-10692": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2018-10693": {"epss_score": 0.00693, "epss_percentile": 0.71328}, "CVE-2018-10694": {"epss_score": 0.00163, "epss_percentile": 0.37792}, "CVE-2018-10695": {"epss_score": 0.00607, "epss_percentile": 0.69032}, "CVE-2018-10696": {"epss_score": 0.00254, "epss_percentile": 0.48513}, "CVE-2018-10697": {"epss_score": 0.00852, "epss_percentile": 0.74415}, "CVE-2018-10698": {"epss_score": 0.00202, "epss_percentile": 0.42451}, "CVE-2018-10699": {"epss_score": 0.00553, "epss_percentile": 0.67423}, "CVE-2018-10700": {"epss_score": 0.02541, "epss_percentile": 0.85051}, "CVE-2018-10701": {"epss_score": 0.00706, "epss_percentile": 0.71639}, "CVE-2018-10702": {"epss_score": 0.02404, "epss_percentile": 0.84646}, "CVE-2018-10703": {"epss_score": 0.00693, "epss_percentile": 0.71328}, "CVE-2018-10704": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-10705": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-10706": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-10709": {"epss_score": 0.00224, "epss_percentile": 0.45038}, "CVE-2018-10710": {"epss_score": 0.00139, "epss_percentile": 0.34592}, "CVE-2018-10711": {"epss_score": 0.00394, "epss_percentile": 0.59785}, "CVE-2018-10712": {"epss_score": 0.00535, "epss_percentile": 0.66803}, "CVE-2018-10713": {"epss_score": 0.00504, "epss_percentile": 0.65539}, "CVE-2018-10716": {"epss_score": 0.00048, "epss_percentile": 0.15028}, "CVE-2018-10717": {"epss_score": 0.00568, "epss_percentile": 0.67904}, "CVE-2018-10718": {"epss_score": 0.57548, "epss_percentile": 0.98069}, "CVE-2018-10722": {"epss_score": 0.00056, "epss_percentile": 0.1787}, "CVE-2018-10723": {"epss_score": 0.00457, "epss_percentile": 0.63385}, "CVE-2018-10726": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-10727": {"epss_score": 0.00404, "epss_percentile": 0.60454}, "CVE-2018-10728": {"epss_score": 0.01307, "epss_percentile": 0.79342}, "CVE-2018-10729": {"epss_score": 0.00234, "epss_percentile": 0.46104}, "CVE-2018-10730": {"epss_score": 0.03381, "epss_percentile": 0.87033}, "CVE-2018-10731": {"epss_score": 0.01398, "epss_percentile": 0.79991}, "CVE-2018-10732": {"epss_score": 0.00502, "epss_percentile": 0.65379}, "CVE-2018-10733": {"epss_score": 0.00799, "epss_percentile": 0.73521}, "CVE-2018-10734": {"epss_score": 0.00386, "epss_percentile": 0.5924}, "CVE-2018-10735": {"epss_score": 0.86271, "epss_percentile": 0.99375}, "CVE-2018-10736": {"epss_score": 0.83161, "epss_percentile": 0.99235}, "CVE-2018-10737": {"epss_score": 0.83161, "epss_percentile": 0.99235}, "CVE-2018-10738": {"epss_score": 0.83161, "epss_percentile": 0.99235}, "CVE-2018-10739": {"epss_score": 0.00048, "epss_percentile": 0.15028}, "CVE-2018-10740": {"epss_score": 0.02732, "epss_percentile": 0.85541}, "CVE-2018-10746": {"epss_score": 0.00644, "epss_percentile": 0.70084}, "CVE-2018-10747": {"epss_score": 0.00644, "epss_percentile": 0.70084}, "CVE-2018-10748": {"epss_score": 0.00644, "epss_percentile": 0.70084}, "CVE-2018-10749": {"epss_score": 0.00644, "epss_percentile": 0.70084}, "CVE-2018-10750": {"epss_score": 0.00677, "epss_percentile": 0.70949}, "CVE-2018-10751": {"epss_score": 0.14356, "epss_percentile": 0.94193}, "CVE-2018-10752": {"epss_score": 0.00167, "epss_percentile": 0.38293}, "CVE-2018-10753": {"epss_score": 0.00908, "epss_percentile": 0.75273}, "CVE-2018-10756": {"epss_score": 0.02384, "epss_percentile": 0.84574}, "CVE-2018-10757": {"epss_score": 0.04978, "epss_percentile": 0.89358}, "CVE-2018-10758": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2018-10759": {"epss_score": 0.01161, "epss_percentile": 0.78141}, "CVE-2018-10760": {"epss_score": 0.00607, "epss_percentile": 0.6905}, "CVE-2018-10763": {"epss_score": 0.00222, "epss_percentile": 0.44723}, "CVE-2018-10767": {"epss_score": 0.00854, "epss_percentile": 0.74456}, "CVE-2018-10768": {"epss_score": 0.01853, "epss_percentile": 0.82547}, "CVE-2018-10769": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-10770": {"epss_score": 0.00596, "epss_percentile": 0.68734}, "CVE-2018-10771": {"epss_score": 0.00908, "epss_percentile": 0.75273}, "CVE-2018-10772": {"epss_score": 0.00563, "epss_percentile": 0.67738}, "CVE-2018-10773": {"epss_score": 0.00607, "epss_percentile": 0.69059}, "CVE-2018-10774": {"epss_score": 0.00605, "epss_percentile": 0.68997}, "CVE-2018-10775": {"epss_score": 0.00607, "epss_percentile": 0.69059}, "CVE-2018-10776": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2018-10777": {"epss_score": 0.00301, "epss_percentile": 0.52997}, "CVE-2018-10778": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2018-10779": {"epss_score": 0.003, "epss_percentile": 0.52972}, "CVE-2018-10780": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2018-10790": {"epss_score": 0.00559, "epss_percentile": 0.6762}, "CVE-2018-10795": {"epss_score": 0.00337, "epss_percentile": 0.56058}, "CVE-2018-10796": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-10798": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2018-10799": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2018-10801": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2018-10803": {"epss_score": 0.00274, "epss_percentile": 0.50557}, "CVE-2018-10804": {"epss_score": 0.001, "epss_percentile": 0.28508}, "CVE-2018-10805": {"epss_score": 0.00143, "epss_percentile": 0.3521}, "CVE-2018-10806": {"epss_score": 0.00096, "epss_percentile": 0.27442}, "CVE-2018-10809": {"epss_score": 0.00101, "epss_percentile": 0.28591}, "CVE-2018-10810": {"epss_score": 0.0028, "epss_percentile": 0.51042}, "CVE-2018-10811": {"epss_score": 0.16951, "epss_percentile": 0.94752}, "CVE-2018-10812": {"epss_score": 0.00028, "epss_percentile": 0.07285}, "CVE-2018-10813": {"epss_score": 0.00197, "epss_percentile": 0.4193}, "CVE-2018-10814": {"epss_score": 0.00196, "epss_percentile": 0.41762}, "CVE-2018-10815": {"epss_score": 0.0027, "epss_percentile": 0.50236}, "CVE-2018-10817": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-10821": {"epss_score": 0.00334, "epss_percentile": 0.557}, "CVE-2018-10822": {"epss_score": 0.86728, "epss_percentile": 0.99394}, "CVE-2018-10823": {"epss_score": 0.9396, "epss_percentile": 0.99874}, "CVE-2018-10824": {"epss_score": 0.44031, "epss_percentile": 0.97416}, "CVE-2018-10825": {"epss_score": 0.00019, "epss_percentile": 0.04169}, "CVE-2018-10827": {"epss_score": 0.00563, "epss_percentile": 0.67718}, "CVE-2018-10828": {"epss_score": 0.00219, "epss_percentile": 0.44468}, "CVE-2018-10830": {"epss_score": 0.00333, "epss_percentile": 0.55655}, "CVE-2018-10831": {"epss_score": 0.00137, "epss_percentile": 0.34303}, "CVE-2018-10832": {"epss_score": 0.01747, "epss_percentile": 0.82073}, "CVE-2018-10839": {"epss_score": 0.01561, "epss_percentile": 0.81044}, "CVE-2018-10840": {"epss_score": 0.00103, "epss_percentile": 0.28928}, "CVE-2018-10841": {"epss_score": 0.00296, "epss_percentile": 0.52559}, "CVE-2018-10843": {"epss_score": 0.00281, "epss_percentile": 0.51193}, "CVE-2018-10844": {"epss_score": 0.00194, "epss_percentile": 0.41574}, "CVE-2018-10845": {"epss_score": 0.01093, "epss_percentile": 0.7748}, "CVE-2018-10846": {"epss_score": 0.00014, "epss_percentile": 0.01922}, "CVE-2018-10847": {"epss_score": 0.00963, "epss_percentile": 0.76023}, "CVE-2018-10850": {"epss_score": 0.02052, "epss_percentile": 0.83412}, "CVE-2018-10851": {"epss_score": 0.00088, "epss_percentile": 0.25743}, "CVE-2018-10852": {"epss_score": 0.00302, "epss_percentile": 0.53124}, "CVE-2018-10853": {"epss_score": 0.0003, "epss_percentile": 0.08189}, "CVE-2018-10854": {"epss_score": 0.0027, "epss_percentile": 0.5027}, "CVE-2018-10855": {"epss_score": 0.03546, "epss_percentile": 0.87327}, "CVE-2018-10856": {"epss_score": 0.00216, "epss_percentile": 0.44195}, "CVE-2018-10857": {"epss_score": 0.00528, "epss_percentile": 0.66538}, "CVE-2018-10858": {"epss_score": 0.05698, "epss_percentile": 0.90129}, "CVE-2018-10859": {"epss_score": 0.00528, "epss_percentile": 0.66538}, "CVE-2018-10860": {"epss_score": 0.05737, "epss_percentile": 0.90165}, "CVE-2018-10861": {"epss_score": 0.0058, "epss_percentile": 0.68244}, "CVE-2018-10862": {"epss_score": 0.00325, "epss_percentile": 0.55032}, "CVE-2018-10863": {"epss_score": 0.00235, "epss_percentile": 0.46226}, "CVE-2018-10864": {"epss_score": 0.00632, "epss_percentile": 0.69736}, "CVE-2018-10865": {"epss_score": 0.00977, "epss_percentile": 0.76223}, "CVE-2018-10866": {"epss_score": 0.00925, "epss_percentile": 0.75534}, "CVE-2018-10867": {"epss_score": 0.00341, "epss_percentile": 0.56341}, "CVE-2018-10868": {"epss_score": 0.0117, "epss_percentile": 0.78206}, "CVE-2018-10869": {"epss_score": 0.0056, "epss_percentile": 0.67643}, "CVE-2018-10870": {"epss_score": 0.01881, "epss_percentile": 0.82691}, "CVE-2018-10871": {"epss_score": 0.00377, "epss_percentile": 0.58693}, "CVE-2018-10872": {"epss_score": 0.0008, "epss_percentile": 0.24116}, "CVE-2018-10873": {"epss_score": 0.0127, "epss_percentile": 0.7905}, "CVE-2018-10874": {"epss_score": 0.00047, "epss_percentile": 0.14579}, "CVE-2018-10875": {"epss_score": 0.00043, "epss_percentile": 0.13238}, "CVE-2018-10876": {"epss_score": 0.00027, "epss_percentile": 0.0674}, "CVE-2018-10877": {"epss_score": 0.0024, "epss_percentile": 0.47232}, "CVE-2018-10878": {"epss_score": 0.00039, "epss_percentile": 0.11734}, "CVE-2018-10879": {"epss_score": 0.00033, "epss_percentile": 0.09351}, "CVE-2018-10880": {"epss_score": 0.00946, "epss_percentile": 0.75812}, "CVE-2018-10881": {"epss_score": 0.00049, "epss_percentile": 0.15362}, "CVE-2018-10882": {"epss_score": 0.00062, "epss_percentile": 0.19634}, "CVE-2018-10883": {"epss_score": 0.0005, "epss_percentile": 0.15682}, "CVE-2018-10884": {"epss_score": 0.00175, "epss_percentile": 0.39268}, "CVE-2018-10885": {"epss_score": 0.00378, "epss_percentile": 0.58795}, "CVE-2018-10887": {"epss_score": 0.00414, "epss_percentile": 0.61016}, "CVE-2018-10888": {"epss_score": 0.0062, "epss_percentile": 0.69456}, "CVE-2018-10889": {"epss_score": 0.00379, "epss_percentile": 0.58895}, "CVE-2018-10890": {"epss_score": 0.00202, "epss_percentile": 0.42415}, "CVE-2018-10891": {"epss_score": 0.00291, "epss_percentile": 0.52212}, "CVE-2018-10892": {"epss_score": 0.00189, "epss_percentile": 0.40987}, "CVE-2018-10893": {"epss_score": 0.00348, "epss_percentile": 0.56847}, "CVE-2018-10894": {"epss_score": 0.00054, "epss_percentile": 0.17362}, "CVE-2018-10895": {"epss_score": 0.00178, "epss_percentile": 0.39713}, "CVE-2018-10896": {"epss_score": 0.00114, "epss_percentile": 0.30778}, "CVE-2018-10897": {"epss_score": 0.02756, "epss_percentile": 0.85591}, "CVE-2018-10898": {"epss_score": 0.00177, "epss_percentile": 0.39589}, "CVE-2018-10899": {"epss_score": 0.02129, "epss_percentile": 0.83706}, "CVE-2018-10900": {"epss_score": 0.14681, "epss_percentile": 0.94263}, "CVE-2018-10901": {"epss_score": 0.0016, "epss_percentile": 0.37495}, "CVE-2018-10902": {"epss_score": 0.00079, "epss_percentile": 0.23877}, "CVE-2018-10903": {"epss_score": 0.00215, "epss_percentile": 0.44026}, "CVE-2018-10904": {"epss_score": 0.01255, "epss_percentile": 0.78931}, "CVE-2018-10905": {"epss_score": 0.00286, "epss_percentile": 0.51717}, "CVE-2018-10906": {"epss_score": 0.00054, "epss_percentile": 0.17204}, "CVE-2018-10907": {"epss_score": 0.0211, "epss_percentile": 0.83643}, "CVE-2018-10908": {"epss_score": 0.0032, "epss_percentile": 0.546}, "CVE-2018-10910": {"epss_score": 0.00057, "epss_percentile": 0.18077}, "CVE-2018-10911": {"epss_score": 0.04259, "epss_percentile": 0.88461}, "CVE-2018-10912": {"epss_score": 0.00474, "epss_percentile": 0.64111}, "CVE-2018-10913": {"epss_score": 0.00939, "epss_percentile": 0.7572}, "CVE-2018-10914": {"epss_score": 0.0387, "epss_percentile": 0.87881}, "CVE-2018-10915": {"epss_score": 0.01845, "epss_percentile": 0.82511}, "CVE-2018-10916": {"epss_score": 0.00696, "epss_percentile": 0.71395}, "CVE-2018-10917": {"epss_score": 0.00271, "epss_percentile": 0.50308}, "CVE-2018-10918": {"epss_score": 0.04347, "epss_percentile": 0.88577}, "CVE-2018-10919": {"epss_score": 0.01733, "epss_percentile": 0.81999}, "CVE-2018-10920": {"epss_score": 0.12203, "epss_percentile": 0.93601}, "CVE-2018-10921": {"epss_score": 0.00198, "epss_percentile": 0.42035}, "CVE-2018-10922": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2018-10923": {"epss_score": 0.00914, "epss_percentile": 0.75384}, "CVE-2018-10924": {"epss_score": 0.00753, "epss_percentile": 0.72671}, "CVE-2018-10925": {"epss_score": 0.00404, "epss_percentile": 0.60411}, "CVE-2018-10926": {"epss_score": 0.00788, "epss_percentile": 0.73345}, "CVE-2018-10927": {"epss_score": 0.01357, "epss_percentile": 0.79717}, "CVE-2018-10928": {"epss_score": 0.00845, "epss_percentile": 0.74283}, "CVE-2018-10929": {"epss_score": 0.0086, "epss_percentile": 0.74527}, "CVE-2018-10930": {"epss_score": 0.00631, "epss_percentile": 0.69728}, "CVE-2018-10931": {"epss_score": 0.67782, "epss_percentile": 0.98521}, "CVE-2018-10932": {"epss_score": 0.00074, "epss_percentile": 0.22822}, "CVE-2018-10933": {"epss_score": 0.78329, "epss_percentile": 0.98981}, "CVE-2018-10934": {"epss_score": 0.00439, "epss_percentile": 0.62601}, "CVE-2018-10935": {"epss_score": 0.00436, "epss_percentile": 0.62384}, "CVE-2018-10936": {"epss_score": 0.00892, "epss_percentile": 0.75057}, "CVE-2018-10937": {"epss_score": 0.00329, "epss_percentile": 0.55414}, "CVE-2018-10938": {"epss_score": 0.04369, "epss_percentile": 0.88607}, "CVE-2018-10939": {"epss_score": 0.01593, "epss_percentile": 0.81227}, "CVE-2018-10940": {"epss_score": 0.0008, "epss_percentile": 0.24116}, "CVE-2018-10942": {"epss_score": 0.85677, "epss_percentile": 0.99342}, "CVE-2018-10943": {"epss_score": 0.0032, "epss_percentile": 0.54576}, "CVE-2018-10944": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2018-10945": {"epss_score": 0.00652, "epss_percentile": 0.70313}, "CVE-2018-10946": {"epss_score": 0.00101, "epss_percentile": 0.2858}, "CVE-2018-10947": {"epss_score": 0.00077, "epss_percentile": 0.23551}, "CVE-2018-10948": {"epss_score": 0.00228, "epss_percentile": 0.45544}, "CVE-2018-10949": {"epss_score": 0.09917, "epss_percentile": 0.92769}, "CVE-2018-10950": {"epss_score": 0.00492, "epss_percentile": 0.64982}, "CVE-2018-10951": {"epss_score": 0.00456, "epss_percentile": 0.6332}, "CVE-2018-10952": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-10953": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-10954": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-10955": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-10956": {"epss_score": 0.92823, "epss_percentile": 0.99753}, "CVE-2018-10957": {"epss_score": 0.00428, "epss_percentile": 0.61949}, "CVE-2018-10958": {"epss_score": 0.0162, "epss_percentile": 0.81386}, "CVE-2018-10959": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2018-10962": {"epss_score": 0.00048, "epss_percentile": 0.15028}, "CVE-2018-10963": {"epss_score": 0.00356, "epss_percentile": 0.57355}, "CVE-2018-10966": {"epss_score": 0.00284, "epss_percentile": 0.51492}, "CVE-2018-10967": {"epss_score": 0.02646, "epss_percentile": 0.85323}, "CVE-2018-10968": {"epss_score": 0.00433, "epss_percentile": 0.62189}, "CVE-2018-10969": {"epss_score": 0.18728, "epss_percentile": 0.9506}, "CVE-2018-10971": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2018-10972": {"epss_score": 0.00261, "epss_percentile": 0.49246}, "CVE-2018-10973": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-10974": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-10975": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-10976": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-10977": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-10981": {"epss_score": 0.00071, "epss_percentile": 0.22083}, "CVE-2018-10982": {"epss_score": 0.00069, "epss_percentile": 0.21476}, "CVE-2018-10986": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2018-10987": {"epss_score": 0.01151, "epss_percentile": 0.7804}, "CVE-2018-10988": {"epss_score": 0.00022, "epss_percentile": 0.05247}, "CVE-2018-10989": {"epss_score": 0.00355, "epss_percentile": 0.57282}, "CVE-2018-10990": {"epss_score": 0.00324, "epss_percentile": 0.54952}, "CVE-2018-10992": {"epss_score": 0.00729, "epss_percentile": 0.72122}, "CVE-2018-10994": {"epss_score": 0.00323, "epss_percentile": 0.54893}, "CVE-2018-10995": {"epss_score": 0.0046, "epss_percentile": 0.63526}, "CVE-2018-10996": {"epss_score": 0.00732, "epss_percentile": 0.72188}, "CVE-2018-10997": {"epss_score": 0.00608, "epss_percentile": 0.69062}, "CVE-2018-10998": {"epss_score": 0.00915, "epss_percentile": 0.75396}, "CVE-2018-10999": {"epss_score": 0.0162, "epss_percentile": 0.81386}, "CVE-2018-11002": {"epss_score": 0.00117, "epss_percentile": 0.31328}, "CVE-2018-11003": {"epss_score": 0.00114, "epss_percentile": 0.30787}, "CVE-2018-11004": {"epss_score": 0.00204, "epss_percentile": 0.42623}, "CVE-2018-11005": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2018-11006": {"epss_score": 0.00102, "epss_percentile": 0.28868}, "CVE-2018-11007": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2018-11008": {"epss_score": 0.00136, "epss_percentile": 0.34194}, "CVE-2018-11009": {"epss_score": 0.00243, "epss_percentile": 0.47488}, "CVE-2018-11010": {"epss_score": 0.00243, "epss_percentile": 0.47488}, "CVE-2018-11011": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-11012": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-11013": {"epss_score": 0.05147, "epss_percentile": 0.89544}, "CVE-2018-11017": {"epss_score": 0.00444, "epss_percentile": 0.62845}, "CVE-2018-11018": {"epss_score": 0.00198, "epss_percentile": 0.4203}, "CVE-2018-11019": {"epss_score": 0.0401, "epss_percentile": 0.88111}, "CVE-2018-11020": {"epss_score": 0.0187, "epss_percentile": 0.82631}, "CVE-2018-11021": {"epss_score": 0.0401, "epss_percentile": 0.88111}, "CVE-2018-11022": {"epss_score": 0.0401, "epss_percentile": 0.88111}, "CVE-2018-11023": {"epss_score": 0.0401, "epss_percentile": 0.88111}, "CVE-2018-11024": {"epss_score": 0.0401, "epss_percentile": 0.88111}, "CVE-2018-11025": {"epss_score": 0.0401, "epss_percentile": 0.88111}, "CVE-2018-11027": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-11031": {"epss_score": 0.00754, "epss_percentile": 0.72704}, "CVE-2018-11032": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-11033": {"epss_score": 0.00216, "epss_percentile": 0.44205}, "CVE-2018-11034": {"epss_score": 0.00085, "epss_percentile": 0.25051}, "CVE-2018-11035": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-11036": {"epss_score": 0.00289, "epss_percentile": 0.51999}, "CVE-2018-11037": {"epss_score": 0.00484, "epss_percentile": 0.64657}, "CVE-2018-11039": {"epss_score": 0.02602, "epss_percentile": 0.8521}, "CVE-2018-11040": {"epss_score": 0.07316, "epss_percentile": 0.91404}, "CVE-2018-11041": {"epss_score": 0.00215, "epss_percentile": 0.44082}, "CVE-2018-11044": {"epss_score": 0.00232, "epss_percentile": 0.45909}, "CVE-2018-11045": {"epss_score": 0.00303, "epss_percentile": 0.53222}, "CVE-2018-11046": {"epss_score": 0.00337, "epss_percentile": 0.56008}, "CVE-2018-11047": {"epss_score": 0.00278, "epss_percentile": 0.50903}, "CVE-2018-11048": {"epss_score": 0.0041, "epss_percentile": 0.60831}, "CVE-2018-11049": {"epss_score": 0.00051, "epss_percentile": 0.15992}, "CVE-2018-11050": {"epss_score": 0.00654, "epss_percentile": 0.70344}, "CVE-2018-11051": {"epss_score": 0.04355, "epss_percentile": 0.8859}, "CVE-2018-11052": {"epss_score": 0.06707, "epss_percentile": 0.9096}, "CVE-2018-11053": {"epss_score": 0.00097, "epss_percentile": 0.27463}, "CVE-2018-11054": {"epss_score": 0.0235, "epss_percentile": 0.84467}, "CVE-2018-11055": {"epss_score": 0.00088, "epss_percentile": 0.25651}, "CVE-2018-11056": {"epss_score": 0.01961, "epss_percentile": 0.83063}, "CVE-2018-11057": {"epss_score": 0.0062, "epss_percentile": 0.69446}, "CVE-2018-11058": {"epss_score": 0.01725, "epss_percentile": 0.81953}, "CVE-2018-11059": {"epss_score": 0.00323, "epss_percentile": 0.54866}, "CVE-2018-11060": {"epss_score": 0.00523, "epss_percentile": 0.66312}, "CVE-2018-11061": {"epss_score": 0.0108, "epss_percentile": 0.77365}, "CVE-2018-11062": {"epss_score": 0.0048, "epss_percentile": 0.6445}, "CVE-2018-11063": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2018-11064": {"epss_score": 0.0004, "epss_percentile": 0.12061}, "CVE-2018-11065": {"epss_score": 0.00219, "epss_percentile": 0.44525}, "CVE-2018-11066": {"epss_score": 0.40954, "epss_percentile": 0.97246}, "CVE-2018-11067": {"epss_score": 0.00509, "epss_percentile": 0.6573}, "CVE-2018-11068": {"epss_score": 0.00081, "epss_percentile": 0.24259}, "CVE-2018-11069": {"epss_score": 0.00279, "epss_percentile": 0.50984}, "CVE-2018-11070": {"epss_score": 0.00352, "epss_percentile": 0.5713}, "CVE-2018-11071": {"epss_score": 0.0042, "epss_percentile": 0.61416}, "CVE-2018-11072": {"epss_score": 0.00077, "epss_percentile": 0.23309}, "CVE-2018-11073": {"epss_score": 0.00483, "epss_percentile": 0.64572}, "CVE-2018-11074": {"epss_score": 0.00746, "epss_percentile": 0.72538}, "CVE-2018-11075": {"epss_score": 0.00815, "epss_percentile": 0.7378}, "CVE-2018-11076": {"epss_score": 0.00386, "epss_percentile": 0.59273}, "CVE-2018-11077": {"epss_score": 0.00367, "epss_percentile": 0.58133}, "CVE-2018-11078": {"epss_score": 0.00107, "epss_percentile": 0.2959}, "CVE-2018-11079": {"epss_score": 0.00055, "epss_percentile": 0.17555}, "CVE-2018-11080": {"epss_score": 0.00047, "epss_percentile": 0.14654}, "CVE-2018-11081": {"epss_score": 0.00161, "epss_percentile": 0.37566}, "CVE-2018-11082": {"epss_score": 0.00294, "epss_percentile": 0.52386}, "CVE-2018-11083": {"epss_score": 0.00647, "epss_percentile": 0.70199}, "CVE-2018-11084": {"epss_score": 0.00255, "epss_percentile": 0.48631}, "CVE-2018-11086": {"epss_score": 0.00335, "epss_percentile": 0.55847}, "CVE-2018-11087": {"epss_score": 0.00519, "epss_percentile": 0.66164}, "CVE-2018-11088": {"epss_score": 0.00335, "epss_percentile": 0.55847}, "CVE-2018-11090": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-11091": {"epss_score": 0.01686, "epss_percentile": 0.81753}, "CVE-2018-11092": {"epss_score": 0.00197, "epss_percentile": 0.41822}, "CVE-2018-11093": {"epss_score": 0.00308, "epss_percentile": 0.53591}, "CVE-2018-11094": {"epss_score": 0.67224, "epss_percentile": 0.98499}, "CVE-2018-11095": {"epss_score": 0.00493, "epss_percentile": 0.65058}, "CVE-2018-11096": {"epss_score": 0.00113, "epss_percentile": 0.30631}, "CVE-2018-11097": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-11098": {"epss_score": 0.00406, "epss_percentile": 0.60541}, "CVE-2018-11099": {"epss_score": 0.00437, "epss_percentile": 0.62522}, "CVE-2018-11100": {"epss_score": 0.00493, "epss_percentile": 0.65058}, "CVE-2018-11101": {"epss_score": 0.00428, "epss_percentile": 0.61932}, "CVE-2018-11102": {"epss_score": 0.00464, "epss_percentile": 0.63733}, "CVE-2018-11105": {"epss_score": 0.00401, "epss_percentile": 0.60208}, "CVE-2018-11106": {"epss_score": 0.02629, "epss_percentile": 0.85276}, "CVE-2018-11116": {"epss_score": 0.01562, "epss_percentile": 0.81046}, "CVE-2018-11117": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-11118": {"epss_score": 0.00314, "epss_percentile": 0.54157}, "CVE-2018-11119": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2018-11120": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-11124": {"epss_score": 0.00194, "epss_percentile": 0.41539}, "CVE-2018-11126": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2018-11127": {"epss_score": 0.00117, "epss_percentile": 0.31326}, "CVE-2018-11128": {"epss_score": 0.00723, "epss_percentile": 0.72016}, "CVE-2018-11129": {"epss_score": 0.00427, "epss_percentile": 0.61824}, "CVE-2018-11130": {"epss_score": 0.03721, "epss_percentile": 0.87621}, "CVE-2018-11132": {"epss_score": 0.09656, "epss_percentile": 0.92642}, "CVE-2018-11133": {"epss_score": 0.00223, "epss_percentile": 0.44854}, "CVE-2018-11134": {"epss_score": 0.00555, "epss_percentile": 0.67461}, "CVE-2018-11135": {"epss_score": 0.0048, "epss_percentile": 0.64463}, "CVE-2018-11136": {"epss_score": 0.00311, "epss_percentile": 0.53826}, "CVE-2018-11137": {"epss_score": 0.00443, "epss_percentile": 0.62804}, "CVE-2018-11138": {"epss_score": 0.92008, "epss_percentile": 0.99685}, "CVE-2018-11139": {"epss_score": 0.25176, "epss_percentile": 0.95993}, "CVE-2018-11140": {"epss_score": 0.00311, "epss_percentile": 0.53826}, "CVE-2018-11141": {"epss_score": 0.00742, "epss_percentile": 0.72457}, "CVE-2018-11142": {"epss_score": 0.00056, "epss_percentile": 0.17743}, "CVE-2018-11143": {"epss_score": 0.19325, "epss_percentile": 0.95163}, "CVE-2018-11144": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11145": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11146": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11147": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11148": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11149": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11150": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11151": {"epss_score": 0.06771, "epss_percentile": 0.91015}, "CVE-2018-11152": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11153": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11154": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11155": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11156": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11157": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11158": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11159": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11160": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11161": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11162": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11163": {"epss_score": 0.06771, "epss_percentile": 0.91015}, "CVE-2018-11164": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11165": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11166": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11167": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11168": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11169": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11170": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11171": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11172": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11173": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11174": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11175": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11176": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11177": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11178": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11179": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11180": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11181": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11182": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11183": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11184": {"epss_score": 0.06771, "epss_percentile": 0.91015}, "CVE-2018-11185": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11186": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11187": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11188": {"epss_score": 0.07271, "epss_percentile": 0.91374}, "CVE-2018-11189": {"epss_score": 0.01443, "epss_percentile": 0.80313}, "CVE-2018-11190": {"epss_score": 0.00962, "epss_percentile": 0.75993}, "CVE-2018-11191": {"epss_score": 0.00962, "epss_percentile": 0.75993}, "CVE-2018-11192": {"epss_score": 0.00962, "epss_percentile": 0.75993}, "CVE-2018-11193": {"epss_score": 0.00962, "epss_percentile": 0.75993}, "CVE-2018-11194": {"epss_score": 0.00303, "epss_percentile": 0.53217}, "CVE-2018-11195": {"epss_score": 0.00118, "epss_percentile": 0.31387}, "CVE-2018-11196": {"epss_score": 0.00176, "epss_percentile": 0.39401}, "CVE-2018-11198": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-11200": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-11202": {"epss_score": 0.01323, "epss_percentile": 0.79455}, "CVE-2018-11203": {"epss_score": 0.01144, "epss_percentile": 0.77988}, "CVE-2018-11204": {"epss_score": 0.00611, "epss_percentile": 0.69196}, "CVE-2018-11205": {"epss_score": 0.00771, "epss_percentile": 0.7303}, "CVE-2018-11206": {"epss_score": 0.00739, "epss_percentile": 0.72356}, "CVE-2018-11207": {"epss_score": 0.00509, "epss_percentile": 0.65754}, "CVE-2018-11208": {"epss_score": 0.00258, "epss_percentile": 0.48994}, "CVE-2018-11209": {"epss_score": 0.00085, "epss_percentile": 0.25231}, "CVE-2018-11210": {"epss_score": 0.00455, "epss_percentile": 0.63295}, "CVE-2018-11212": {"epss_score": 0.01902, "epss_percentile": 0.82782}, "CVE-2018-11213": {"epss_score": 0.00914, "epss_percentile": 0.75386}, "CVE-2018-11214": {"epss_score": 0.01054, "epss_percentile": 0.77104}, "CVE-2018-11215": {"epss_score": 0.03063, "epss_percentile": 0.86319}, "CVE-2018-11218": {"epss_score": 0.80304, "epss_percentile": 0.99081}, "CVE-2018-11219": {"epss_score": 0.02594, "epss_percentile": 0.85189}, "CVE-2018-11220": {"epss_score": 0.40704, "epss_percentile": 0.97234}, "CVE-2018-11221": {"epss_score": 0.08711, "epss_percentile": 0.92222}, "CVE-2018-11222": {"epss_score": 0.03828, "epss_percentile": 0.87796}, "CVE-2018-11223": {"epss_score": 0.00423, "epss_percentile": 0.61584}, "CVE-2018-11224": {"epss_score": 0.00308, "epss_percentile": 0.53627}, "CVE-2018-11225": {"epss_score": 0.00496, "epss_percentile": 0.65161}, "CVE-2018-11226": {"epss_score": 0.00448, "epss_percentile": 0.63007}, "CVE-2018-11227": {"epss_score": 0.04502, "epss_percentile": 0.88767}, "CVE-2018-11228": {"epss_score": 0.07411, "epss_percentile": 0.91458}, "CVE-2018-11229": {"epss_score": 0.0366, "epss_percentile": 0.87527}, "CVE-2018-11230": {"epss_score": 0.00601, "epss_percentile": 0.68853}, "CVE-2018-11231": {"epss_score": 0.795, "epss_percentile": 0.99041}, "CVE-2018-11232": {"epss_score": 0.0011, "epss_percentile": 0.30211}, "CVE-2018-11233": {"epss_score": 0.00276, "epss_percentile": 0.50751}, "CVE-2018-11235": {"epss_score": 0.39682, "epss_percentile": 0.97175}, "CVE-2018-11236": {"epss_score": 0.00894, "epss_percentile": 0.75088}, "CVE-2018-11237": {"epss_score": 0.00797, "epss_percentile": 0.73503}, "CVE-2018-11239": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-11240": {"epss_score": 0.00614, "epss_percentile": 0.69288}, "CVE-2018-11241": {"epss_score": 0.03614, "epss_percentile": 0.87435}, "CVE-2018-11242": {"epss_score": 0.04084, "epss_percentile": 0.88223}, "CVE-2018-11243": {"epss_score": 0.00508, "epss_percentile": 0.65701}, "CVE-2018-11244": {"epss_score": 0.00207, "epss_percentile": 0.43189}, "CVE-2018-11245": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-11246": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2018-11247": {"epss_score": 0.05976, "epss_percentile": 0.90376}, "CVE-2018-11248": {"epss_score": 0.00459, "epss_percentile": 0.63477}, "CVE-2018-11251": {"epss_score": 0.00309, "epss_percentile": 0.53697}, "CVE-2018-11254": {"epss_score": 0.00374, "epss_percentile": 0.58583}, "CVE-2018-11255": {"epss_score": 0.00232, "epss_percentile": 0.45941}, "CVE-2018-11256": {"epss_score": 0.00565, "epss_percentile": 0.67798}, "CVE-2018-11257": {"epss_score": 0.00077, "epss_percentile": 0.23452}, "CVE-2018-11258": {"epss_score": 0.0009, "epss_percentile": 0.26039}, "CVE-2018-11259": {"epss_score": 0.0009, "epss_percentile": 0.26135}, "CVE-2018-11260": {"epss_score": 0.0004, "epss_percentile": 0.12155}, "CVE-2018-11261": {"epss_score": 0.00073, "epss_percentile": 0.22595}, "CVE-2018-11262": {"epss_score": 0.00032, "epss_percentile": 0.08809}, "CVE-2018-11263": {"epss_score": 0.00075, "epss_percentile": 0.22969}, "CVE-2018-11264": {"epss_score": 0.0004, "epss_percentile": 0.12053}, "CVE-2018-11265": {"epss_score": 0.00028, "epss_percentile": 0.07573}, "CVE-2018-11266": {"epss_score": 0.00031, "epss_percentile": 0.08415}, "CVE-2018-11267": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11268": {"epss_score": 0.0004, "epss_percentile": 0.12053}, "CVE-2018-11269": {"epss_score": 0.0004, "epss_percentile": 0.12053}, "CVE-2018-11270": {"epss_score": 0.00064, "epss_percentile": 0.20265}, "CVE-2018-11271": {"epss_score": 0.00271, "epss_percentile": 0.50319}, "CVE-2018-11273": {"epss_score": 0.00033, "epss_percentile": 0.09363}, "CVE-2018-11274": {"epss_score": 0.00016, "epss_percentile": 0.0292}, "CVE-2018-11275": {"epss_score": 0.00039, "epss_percentile": 0.11633}, "CVE-2018-11276": {"epss_score": 0.00027, "epss_percentile": 0.0685}, "CVE-2018-11277": {"epss_score": 0.00037, "epss_percentile": 0.10678}, "CVE-2018-11278": {"epss_score": 0.00015, "epss_percentile": 0.02544}, "CVE-2018-11279": {"epss_score": 0.00113, "epss_percentile": 0.30608}, "CVE-2018-11280": {"epss_score": 0.00031, "epss_percentile": 0.08419}, "CVE-2018-11281": {"epss_score": 0.00026, "epss_percentile": 0.06669}, "CVE-2018-11284": {"epss_score": 0.00264, "epss_percentile": 0.49684}, "CVE-2018-11285": {"epss_score": 0.00214, "epss_percentile": 0.43999}, "CVE-2018-11286": {"epss_score": 0.00021, "epss_percentile": 0.04947}, "CVE-2018-11287": {"epss_score": 0.00272, "epss_percentile": 0.50355}, "CVE-2018-11288": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2018-11289": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2018-11290": {"epss_score": 0.00375, "epss_percentile": 0.58608}, "CVE-2018-11291": {"epss_score": 0.0022, "epss_percentile": 0.44588}, "CVE-2018-11292": {"epss_score": 0.00128, "epss_percentile": 0.32995}, "CVE-2018-11293": {"epss_score": 0.00057, "epss_percentile": 0.18079}, "CVE-2018-11294": {"epss_score": 0.00071, "epss_percentile": 0.22}, "CVE-2018-11295": {"epss_score": 0.00022, "epss_percentile": 0.05313}, "CVE-2018-11296": {"epss_score": 0.00022, "epss_percentile": 0.05313}, "CVE-2018-11297": {"epss_score": 0.00022, "epss_percentile": 0.05313}, "CVE-2018-11298": {"epss_score": 0.00028, "epss_percentile": 0.07573}, "CVE-2018-11299": {"epss_score": 0.00025, "epss_percentile": 0.06283}, "CVE-2018-11300": {"epss_score": 0.00031, "epss_percentile": 0.08715}, "CVE-2018-11301": {"epss_score": 0.00027, "epss_percentile": 0.0685}, "CVE-2018-11302": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2018-11304": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2018-11305": {"epss_score": 0.00048, "epss_percentile": 0.14982}, "CVE-2018-11307": {"epss_score": 0.12636, "epss_percentile": 0.93736}, "CVE-2018-11309": {"epss_score": 0.01522, "epss_percentile": 0.80837}, "CVE-2018-11311": {"epss_score": 0.40714, "epss_percentile": 0.97235}, "CVE-2018-11314": {"epss_score": 0.00479, "epss_percentile": 0.6442}, "CVE-2018-11315": {"epss_score": 0.00084, "epss_percentile": 0.24862}, "CVE-2018-11316": {"epss_score": 0.00278, "epss_percentile": 0.50846}, "CVE-2018-11317": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-11319": {"epss_score": 0.00837, "epss_percentile": 0.74162}, "CVE-2018-11320": {"epss_score": 0.00274, "epss_percentile": 0.50518}, "CVE-2018-11321": {"epss_score": 0.00213, "epss_percentile": 0.43837}, "CVE-2018-11322": {"epss_score": 0.00205, "epss_percentile": 0.42686}, "CVE-2018-11323": {"epss_score": 0.00581, "epss_percentile": 0.68275}, "CVE-2018-11324": {"epss_score": 0.00033, "epss_percentile": 0.09187}, "CVE-2018-11325": {"epss_score": 0.00108, "epss_percentile": 0.29828}, "CVE-2018-11326": {"epss_score": 0.00066, "epss_percentile": 0.20869}, "CVE-2018-11327": {"epss_score": 0.00015, "epss_percentile": 0.02581}, "CVE-2018-11328": {"epss_score": 0.00058, "epss_percentile": 0.18273}, "CVE-2018-11329": {"epss_score": 0.00294, "epss_percentile": 0.52389}, "CVE-2018-11330": {"epss_score": 0.00265, "epss_percentile": 0.49807}, "CVE-2018-11331": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2018-11332": {"epss_score": 0.00228, "epss_percentile": 0.45526}, "CVE-2018-11334": {"epss_score": 0.00044, "epss_percentile": 0.13658}, "CVE-2018-11335": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-11338": {"epss_score": 0.0058, "epss_percentile": 0.68258}, "CVE-2018-11339": {"epss_score": 0.05584, "epss_percentile": 0.90021}, "CVE-2018-11340": {"epss_score": 0.00718, "epss_percentile": 0.71938}, "CVE-2018-11341": {"epss_score": 0.00432, "epss_percentile": 0.62096}, "CVE-2018-11342": {"epss_score": 0.00312, "epss_percentile": 0.53957}, "CVE-2018-11343": {"epss_score": 0.00339, "epss_percentile": 0.56201}, "CVE-2018-11344": {"epss_score": 0.00442, "epss_percentile": 0.62734}, "CVE-2018-11345": {"epss_score": 0.00187, "epss_percentile": 0.40763}, "CVE-2018-11346": {"epss_score": 0.00152, "epss_percentile": 0.36461}, "CVE-2018-11347": {"epss_score": 0.00354, "epss_percentile": 0.57233}, "CVE-2018-11348": {"epss_score": 0.00198, "epss_percentile": 0.42052}, "CVE-2018-11349": {"epss_score": 0.00177, "epss_percentile": 0.39553}, "CVE-2018-11350": {"epss_score": 0.00353, "epss_percentile": 0.57157}, "CVE-2018-11351": {"epss_score": 0.00259, "epss_percentile": 0.49038}, "CVE-2018-11352": {"epss_score": 0.00453, "epss_percentile": 0.63212}, "CVE-2018-11354": {"epss_score": 0.00558, "epss_percentile": 0.67579}, "CVE-2018-11355": {"epss_score": 0.00583, "epss_percentile": 0.68331}, "CVE-2018-11356": {"epss_score": 0.01183, "epss_percentile": 0.78324}, "CVE-2018-11357": {"epss_score": 0.01179, "epss_percentile": 0.78295}, "CVE-2018-11358": {"epss_score": 0.01586, "epss_percentile": 0.81168}, "CVE-2018-11359": {"epss_score": 0.0119, "epss_percentile": 0.7838}, "CVE-2018-11360": {"epss_score": 0.0109, "epss_percentile": 0.77452}, "CVE-2018-11361": {"epss_score": 0.0058, "epss_percentile": 0.68258}, "CVE-2018-11362": {"epss_score": 0.01586, "epss_percentile": 0.81168}, "CVE-2018-11363": {"epss_score": 0.00229, "epss_percentile": 0.45663}, "CVE-2018-11364": {"epss_score": 0.00362, "epss_percentile": 0.5775}, "CVE-2018-11365": {"epss_score": 0.00362, "epss_percentile": 0.5775}, "CVE-2018-11366": {"epss_score": 0.03207, "epss_percentile": 0.86636}, "CVE-2018-11367": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2018-11369": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-11371": {"epss_score": 0.00155, "epss_percentile": 0.36796}, "CVE-2018-11372": {"epss_score": 0.00292, "epss_percentile": 0.52221}, "CVE-2018-11373": {"epss_score": 0.00292, "epss_percentile": 0.52221}, "CVE-2018-11375": {"epss_score": 0.00232, "epss_percentile": 0.45932}, "CVE-2018-11376": {"epss_score": 0.00248, "epss_percentile": 0.4792}, "CVE-2018-11377": {"epss_score": 0.00256, "epss_percentile": 0.48801}, "CVE-2018-11378": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-11379": {"epss_score": 0.00248, "epss_percentile": 0.4792}, "CVE-2018-11380": {"epss_score": 0.00248, "epss_percentile": 0.4792}, "CVE-2018-11381": {"epss_score": 0.00248, "epss_percentile": 0.4792}, "CVE-2018-11382": {"epss_score": 0.00232, "epss_percentile": 0.45932}, "CVE-2018-11383": {"epss_score": 0.00248, "epss_percentile": 0.4792}, "CVE-2018-11384": {"epss_score": 0.00248, "epss_percentile": 0.4792}, "CVE-2018-11385": {"epss_score": 0.00904, "epss_percentile": 0.75211}, "CVE-2018-11386": {"epss_score": 0.01086, "epss_percentile": 0.77421}, "CVE-2018-11392": {"epss_score": 0.01918, "epss_percentile": 0.82882}, "CVE-2018-11396": {"epss_score": 0.00685, "epss_percentile": 0.71138}, "CVE-2018-11399": {"epss_score": 0.00032, "epss_percentile": 0.08783}, "CVE-2018-11400": {"epss_score": 0.0005, "epss_percentile": 0.15743}, "CVE-2018-11401": {"epss_score": 0.00138, "epss_percentile": 0.34515}, "CVE-2018-11402": {"epss_score": 0.00029, "epss_percentile": 0.07924}, "CVE-2018-11403": {"epss_score": 0.00428, "epss_percentile": 0.61925}, "CVE-2018-11404": {"epss_score": 0.0046, "epss_percentile": 0.63528}, "CVE-2018-11405": {"epss_score": 0.00112, "epss_percentile": 0.30489}, "CVE-2018-11406": {"epss_score": 0.00184, "epss_percentile": 0.40439}, "CVE-2018-11407": {"epss_score": 0.00187, "epss_percentile": 0.40805}, "CVE-2018-11408": {"epss_score": 0.00307, "epss_percentile": 0.53529}, "CVE-2018-11409": {"epss_score": 0.93374, "epss_percentile": 0.998}, "CVE-2018-11410": {"epss_score": 0.00798, "epss_percentile": 0.73515}, "CVE-2018-11411": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-11412": {"epss_score": 0.11201, "epss_percentile": 0.93263}, "CVE-2018-11413": {"epss_score": 0.00412, "epss_percentile": 0.60927}, "CVE-2018-11414": {"epss_score": 0.00232, "epss_percentile": 0.45894}, "CVE-2018-11415": {"epss_score": 0.02523, "epss_percentile": 0.85009}, "CVE-2018-11416": {"epss_score": 0.00382, "epss_percentile": 0.59054}, "CVE-2018-11418": {"epss_score": 0.00376, "epss_percentile": 0.58684}, "CVE-2018-11419": {"epss_score": 0.00376, "epss_percentile": 0.58684}, "CVE-2018-11420": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-11421": {"epss_score": 0.01113, "epss_percentile": 0.77691}, "CVE-2018-11422": {"epss_score": 0.0023, "epss_percentile": 0.45709}, "CVE-2018-11423": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2018-11424": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2018-11425": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-11426": {"epss_score": 0.00425, "epss_percentile": 0.61697}, "CVE-2018-11427": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2018-11429": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-11430": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-11432": {"epss_score": 0.00308, "epss_percentile": 0.5359}, "CVE-2018-11433": {"epss_score": 0.00308, "epss_percentile": 0.5359}, "CVE-2018-11434": {"epss_score": 0.00308, "epss_percentile": 0.5359}, "CVE-2018-11435": {"epss_score": 0.00308, "epss_percentile": 0.5359}, "CVE-2018-11436": {"epss_score": 0.00308, "epss_percentile": 0.5359}, "CVE-2018-11437": {"epss_score": 0.00308, "epss_percentile": 0.5359}, "CVE-2018-11438": {"epss_score": 0.02184, "epss_percentile": 0.83915}, "CVE-2018-11439": {"epss_score": 0.00615, "epss_percentile": 0.69307}, "CVE-2018-11440": {"epss_score": 0.00292, "epss_percentile": 0.52285}, "CVE-2018-11442": {"epss_score": 0.00233, "epss_percentile": 0.45997}, "CVE-2018-11443": {"epss_score": 0.02095, "epss_percentile": 0.83583}, "CVE-2018-11444": {"epss_score": 0.02537, "epss_percentile": 0.8504}, "CVE-2018-11445": {"epss_score": 0.00233, "epss_percentile": 0.45997}, "CVE-2018-11446": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-11447": {"epss_score": 0.00167, "epss_percentile": 0.38349}, "CVE-2018-11448": {"epss_score": 0.00218, "epss_percentile": 0.4441}, "CVE-2018-11449": {"epss_score": 0.0012, "epss_percentile": 0.31774}, "CVE-2018-11450": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-11451": {"epss_score": 0.00615, "epss_percentile": 0.69302}, "CVE-2018-11452": {"epss_score": 0.00453, "epss_percentile": 0.63225}, "CVE-2018-11453": {"epss_score": 0.00049, "epss_percentile": 0.15607}, "CVE-2018-11454": {"epss_score": 0.00057, "epss_percentile": 0.18099}, "CVE-2018-11455": {"epss_score": 0.02657, "epss_percentile": 0.85359}, "CVE-2018-11456": {"epss_score": 0.00178, "epss_percentile": 0.39718}, "CVE-2018-11457": {"epss_score": 0.01262, "epss_percentile": 0.7898}, "CVE-2018-11458": {"epss_score": 0.01319, "epss_percentile": 0.79434}, "CVE-2018-11459": {"epss_score": 0.00043, "epss_percentile": 0.13339}, "CVE-2018-11460": {"epss_score": 0.00043, "epss_percentile": 0.13339}, "CVE-2018-11461": {"epss_score": 0.00053, "epss_percentile": 0.16954}, "CVE-2018-11462": {"epss_score": 0.10541, "epss_percentile": 0.93022}, "CVE-2018-11463": {"epss_score": 0.00099, "epss_percentile": 0.27867}, "CVE-2018-11464": {"epss_score": 0.00435, "epss_percentile": 0.62371}, "CVE-2018-11465": {"epss_score": 0.0006, "epss_percentile": 0.19102}, "CVE-2018-11466": {"epss_score": 0.02424, "epss_percentile": 0.84713}, "CVE-2018-11468": {"epss_score": 0.00515, "epss_percentile": 0.65998}, "CVE-2018-11469": {"epss_score": 0.00028, "epss_percentile": 0.07363}, "CVE-2018-11470": {"epss_score": 0.00232, "epss_percentile": 0.45894}, "CVE-2018-11471": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-11472": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-11473": {"epss_score": 0.01086, "epss_percentile": 0.77422}, "CVE-2018-11474": {"epss_score": 0.00246, "epss_percentile": 0.47793}, "CVE-2018-11475": {"epss_score": 0.00246, "epss_percentile": 0.47793}, "CVE-2018-11476": {"epss_score": 0.00044, "epss_percentile": 0.13389}, "CVE-2018-11477": {"epss_score": 0.00043, "epss_percentile": 0.13059}, "CVE-2018-11478": {"epss_score": 0.00114, "epss_percentile": 0.3078}, "CVE-2018-11479": {"epss_score": 0.28652, "epss_percentile": 0.96375}, "CVE-2018-11481": {"epss_score": 0.01677, "epss_percentile": 0.81716}, "CVE-2018-11482": {"epss_score": 0.00457, "epss_percentile": 0.63385}, "CVE-2018-11485": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-11486": {"epss_score": 0.00327, "epss_percentile": 0.55135}, "CVE-2018-11487": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-11488": {"epss_score": 0.12292, "epss_percentile": 0.93624}, "CVE-2018-11489": {"epss_score": 0.00503, "epss_percentile": 0.65444}, "CVE-2018-11490": {"epss_score": 0.00209, "epss_percentile": 0.43328}, "CVE-2018-11491": {"epss_score": 0.0558, "epss_percentile": 0.90018}, "CVE-2018-11492": {"epss_score": 0.08924, "epss_percentile": 0.92321}, "CVE-2018-11493": {"epss_score": 0.00168, "epss_percentile": 0.38428}, "CVE-2018-11494": {"epss_score": 0.005, "epss_percentile": 0.65295}, "CVE-2018-11495": {"epss_score": 0.00588, "epss_percentile": 0.68496}, "CVE-2018-11496": {"epss_score": 0.00842, "epss_percentile": 0.74242}, "CVE-2018-11498": {"epss_score": 0.02511, "epss_percentile": 0.84951}, "CVE-2018-11499": {"epss_score": 0.03034, "epss_percentile": 0.86254}, "CVE-2018-11500": {"epss_score": 0.00156, "epss_percentile": 0.36971}, "CVE-2018-11501": {"epss_score": 0.00149, "epss_percentile": 0.35934}, "CVE-2018-11502": {"epss_score": 0.0021, "epss_percentile": 0.43489}, "CVE-2018-11503": {"epss_score": 0.00515, "epss_percentile": 0.65998}, "CVE-2018-11504": {"epss_score": 0.00241, "epss_percentile": 0.47269}, "CVE-2018-11505": {"epss_score": 0.18661, "epss_percentile": 0.95048}, "CVE-2018-11506": {"epss_score": 0.00083, "epss_percentile": 0.24798}, "CVE-2018-11507": {"epss_score": 0.00311, "epss_percentile": 0.53846}, "CVE-2018-11508": {"epss_score": 0.01537, "epss_percentile": 0.80922}, "CVE-2018-11509": {"epss_score": 0.10305, "epss_percentile": 0.92936}, "CVE-2018-11510": {"epss_score": 0.89548, "epss_percentile": 0.99531}, "CVE-2018-11511": {"epss_score": 0.14317, "epss_percentile": 0.94185}, "CVE-2018-11512": {"epss_score": 0.0025, "epss_percentile": 0.48242}, "CVE-2018-11514": {"epss_score": 0.00381, "epss_percentile": 0.58996}, "CVE-2018-11515": {"epss_score": 0.00526, "epss_percentile": 0.66412}, "CVE-2018-11516": {"epss_score": 0.00605, "epss_percentile": 0.6898}, "CVE-2018-11517": {"epss_score": 0.03433, "epss_percentile": 0.87127}, "CVE-2018-11518": {"epss_score": 0.00567, "epss_percentile": 0.67846}, "CVE-2018-11522": {"epss_score": 0.02708, "epss_percentile": 0.85478}, "CVE-2018-11523": {"epss_score": 0.21263, "epss_percentile": 0.9549}, "CVE-2018-11525": {"epss_score": 0.0213, "epss_percentile": 0.83708}, "CVE-2018-11526": {"epss_score": 0.0213, "epss_percentile": 0.83708}, "CVE-2018-11527": {"epss_score": 0.00198, "epss_percentile": 0.4203}, "CVE-2018-11528": {"epss_score": 0.00292, "epss_percentile": 0.52221}, "CVE-2018-11529": {"epss_score": 0.74516, "epss_percentile": 0.98806}, "CVE-2018-11531": {"epss_score": 0.0144, "epss_percentile": 0.80298}, "CVE-2018-11532": {"epss_score": 0.00764, "epss_percentile": 0.72907}, "CVE-2018-11535": {"epss_score": 0.01606, "epss_percentile": 0.81295}, "CVE-2018-11536": {"epss_score": 0.00436, "epss_percentile": 0.62455}, "CVE-2018-11537": {"epss_score": 0.00463, "epss_percentile": 0.63685}, "CVE-2018-11538": {"epss_score": 0.00093, "epss_percentile": 0.2669}, "CVE-2018-11541": {"epss_score": 0.00299, "epss_percentile": 0.52886}, "CVE-2018-11542": {"epss_score": 0.02139, "epss_percentile": 0.83744}, "CVE-2018-11543": {"epss_score": 0.00454, "epss_percentile": 0.63245}, "CVE-2018-11544": {"epss_score": 0.00308, "epss_percentile": 0.53609}, "CVE-2018-11545": {"epss_score": 0.00436, "epss_percentile": 0.62455}, "CVE-2018-11546": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2018-11547": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2018-11548": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2018-11549": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-11551": {"epss_score": 0.0143, "epss_percentile": 0.80238}, "CVE-2018-11552": {"epss_score": 0.00307, "epss_percentile": 0.53503}, "CVE-2018-11553": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-11554": {"epss_score": 0.00691, "epss_percentile": 0.7128}, "CVE-2018-11555": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-11556": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-11557": {"epss_score": 0.00298, "epss_percentile": 0.52804}, "CVE-2018-11558": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-11559": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-11560": {"epss_score": 0.00436, "epss_percentile": 0.62455}, "CVE-2018-11561": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-11562": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-11563": {"epss_score": 0.00305, "epss_percentile": 0.53314}, "CVE-2018-11564": {"epss_score": 0.0039, "epss_percentile": 0.59526}, "CVE-2018-11565": {"epss_score": 0.00173, "epss_percentile": 0.39054}, "CVE-2018-11567": {"epss_score": 0.00201, "epss_percentile": 0.4235}, "CVE-2018-11568": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2018-11569": {"epss_score": 0.00405, "epss_percentile": 0.60494}, "CVE-2018-11571": {"epss_score": 0.00315, "epss_percentile": 0.54203}, "CVE-2018-11572": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-11574": {"epss_score": 0.00406, "epss_percentile": 0.60552}, "CVE-2018-11575": {"epss_score": 0.00436, "epss_percentile": 0.62455}, "CVE-2018-11576": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2018-11577": {"epss_score": 0.00245, "epss_percentile": 0.47688}, "CVE-2018-11578": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-11579": {"epss_score": 0.00217, "epss_percentile": 0.44244}, "CVE-2018-11580": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2018-11581": {"epss_score": 0.0028, "epss_percentile": 0.51098}, "CVE-2018-11583": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-11586": {"epss_score": 0.32607, "epss_percentile": 0.96711}, "CVE-2018-11587": {"epss_score": 0.01141, "epss_percentile": 0.77956}, "CVE-2018-11588": {"epss_score": 0.00073, "epss_percentile": 0.22637}, "CVE-2018-11589": {"epss_score": 0.00165, "epss_percentile": 0.38049}, "CVE-2018-11590": {"epss_score": 0.00155, "epss_percentile": 0.36825}, "CVE-2018-11591": {"epss_score": 0.00155, "epss_percentile": 0.36825}, "CVE-2018-11592": {"epss_score": 0.00155, "epss_percentile": 0.36825}, "CVE-2018-11593": {"epss_score": 0.0023, "epss_percentile": 0.45734}, "CVE-2018-11594": {"epss_score": 0.00156, "epss_percentile": 0.36915}, "CVE-2018-11595": {"epss_score": 0.0028, "epss_percentile": 0.51101}, "CVE-2018-11596": {"epss_score": 0.0012, "epss_percentile": 0.31752}, "CVE-2018-11597": {"epss_score": 0.0012, "epss_percentile": 0.31752}, "CVE-2018-11598": {"epss_score": 0.0028, "epss_percentile": 0.51101}, "CVE-2018-11614": {"epss_score": 0.00498, "epss_percentile": 0.65215}, "CVE-2018-11615": {"epss_score": 0.12358, "epss_percentile": 0.93649}, "CVE-2018-11616": {"epss_score": 0.02201, "epss_percentile": 0.83978}, "CVE-2018-11617": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-11618": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-11619": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-11620": {"epss_score": 0.00201, "epss_percentile": 0.42284}, "CVE-2018-11621": {"epss_score": 0.00201, "epss_percentile": 0.42284}, "CVE-2018-11622": {"epss_score": 0.00543, "epss_percentile": 0.67102}, "CVE-2018-11623": {"epss_score": 0.00298, "epss_percentile": 0.52811}, "CVE-2018-11624": {"epss_score": 0.00478, "epss_percentile": 0.64396}, "CVE-2018-11625": {"epss_score": 0.00348, "epss_percentile": 0.56809}, "CVE-2018-11626": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2018-11627": {"epss_score": 0.00398, "epss_percentile": 0.60064}, "CVE-2018-11628": {"epss_score": 0.02271, "epss_percentile": 0.84209}, "CVE-2018-11629": {"epss_score": 0.02151, "epss_percentile": 0.83787}, "CVE-2018-11631": {"epss_score": 0.0942, "epss_percentile": 0.9254}, "CVE-2018-11632": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2018-11633": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2018-11634": {"epss_score": 0.00054, "epss_percentile": 0.17318}, "CVE-2018-11635": {"epss_score": 0.01104, "epss_percentile": 0.77602}, "CVE-2018-11636": {"epss_score": 0.00215, "epss_percentile": 0.4406}, "CVE-2018-11637": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2018-11638": {"epss_score": 0.02384, "epss_percentile": 0.84574}, "CVE-2018-11639": {"epss_score": 0.00475, "epss_percentile": 0.64201}, "CVE-2018-11640": {"epss_score": 0.00667, "epss_percentile": 0.707}, "CVE-2018-11641": {"epss_score": 0.00783, "epss_percentile": 0.73217}, "CVE-2018-11642": {"epss_score": 0.00046, "epss_percentile": 0.14347}, "CVE-2018-11643": {"epss_score": 0.0045, "epss_percentile": 0.63105}, "CVE-2018-11645": {"epss_score": 0.00538, "epss_percentile": 0.66949}, "CVE-2018-11646": {"epss_score": 0.75346, "epss_percentile": 0.98839}, "CVE-2018-11647": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-11649": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-11650": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-11651": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-11652": {"epss_score": 0.21655, "epss_percentile": 0.95544}, "CVE-2018-11653": {"epss_score": 0.02388, "epss_percentile": 0.84589}, "CVE-2018-11654": {"epss_score": 0.00944, "epss_percentile": 0.75794}, "CVE-2018-11655": {"epss_score": 0.001, "epss_percentile": 0.28495}, "CVE-2018-11656": {"epss_score": 0.00187, "epss_percentile": 0.40795}, "CVE-2018-11657": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2018-11670": {"epss_score": 0.00233, "epss_percentile": 0.45997}, "CVE-2018-11671": {"epss_score": 0.00233, "epss_percentile": 0.45997}, "CVE-2018-11678": {"epss_score": 0.00418, "epss_percentile": 0.61284}, "CVE-2018-11679": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2018-11680": {"epss_score": 0.00101, "epss_percentile": 0.28652}, "CVE-2018-11681": {"epss_score": 0.02692, "epss_percentile": 0.8544}, "CVE-2018-11682": {"epss_score": 0.02151, "epss_percentile": 0.83787}, "CVE-2018-11683": {"epss_score": 0.00551, "epss_percentile": 0.67363}, "CVE-2018-11684": {"epss_score": 0.00292, "epss_percentile": 0.52285}, "CVE-2018-11685": {"epss_score": 0.00292, "epss_percentile": 0.52285}, "CVE-2018-11686": {"epss_score": 0.92639, "epss_percentile": 0.99732}, "CVE-2018-11687": {"epss_score": 0.00445, "epss_percentile": 0.62853}, "CVE-2018-11688": {"epss_score": 0.03576, "epss_percentile": 0.87379}, "CVE-2018-11689": {"epss_score": 0.00556, "epss_percentile": 0.67513}, "CVE-2018-11690": {"epss_score": 0.09257, "epss_percentile": 0.92468}, "CVE-2018-11691": {"epss_score": 0.00485, "epss_percentile": 0.64735}, "CVE-2018-11692": {"epss_score": 0.03654, "epss_percentile": 0.87512}, "CVE-2018-11693": {"epss_score": 0.00377, "epss_percentile": 0.58762}, "CVE-2018-11694": {"epss_score": 0.00416, "epss_percentile": 0.61215}, "CVE-2018-11695": {"epss_score": 0.00337, "epss_percentile": 0.56013}, "CVE-2018-11696": {"epss_score": 0.00346, "epss_percentile": 0.56641}, "CVE-2018-11697": {"epss_score": 0.00307, "epss_percentile": 0.535}, "CVE-2018-11698": {"epss_score": 0.0033, "epss_percentile": 0.55433}, "CVE-2018-11701": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-11702": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-11703": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-11704": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-11705": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-11706": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-11707": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-11709": {"epss_score": 0.15008, "epss_percentile": 0.9434}, "CVE-2018-11710": {"epss_score": 0.01229, "epss_percentile": 0.7871}, "CVE-2018-11711": {"epss_score": 0.06293, "epss_percentile": 0.9065}, "CVE-2018-11712": {"epss_score": 0.00216, "epss_percentile": 0.44185}, "CVE-2018-11713": {"epss_score": 0.00406, "epss_percentile": 0.60519}, "CVE-2018-11714": {"epss_score": 0.05658, "epss_percentile": 0.90094}, "CVE-2018-11715": {"epss_score": 0.00189, "epss_percentile": 0.40924}, "CVE-2018-11716": {"epss_score": 0.09483, "epss_percentile": 0.92567}, "CVE-2018-11717": {"epss_score": 0.09607, "epss_percentile": 0.9262}, "CVE-2018-11718": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2018-11719": {"epss_score": 0.00216, "epss_percentile": 0.44154}, "CVE-2018-11720": {"epss_score": 0.00423, "epss_percentile": 0.61581}, "CVE-2018-11722": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-11723": {"epss_score": 0.00138, "epss_percentile": 0.34461}, "CVE-2018-11724": {"epss_score": 0.00387, "epss_percentile": 0.59316}, "CVE-2018-11725": {"epss_score": 0.00691, "epss_percentile": 0.71269}, "CVE-2018-11726": {"epss_score": 0.00718, "epss_percentile": 0.71937}, "CVE-2018-11727": {"epss_score": 0.00174, "epss_percentile": 0.39146}, "CVE-2018-11728": {"epss_score": 0.00176, "epss_percentile": 0.39459}, "CVE-2018-11729": {"epss_score": 0.00138, "epss_percentile": 0.34461}, "CVE-2018-11730": {"epss_score": 0.00158, "epss_percentile": 0.37155}, "CVE-2018-11731": {"epss_score": 0.00138, "epss_percentile": 0.34461}, "CVE-2018-11734": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-11735": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-11736": {"epss_score": 0.11915, "epss_percentile": 0.93515}, "CVE-2018-11737": {"epss_score": 0.00295, "epss_percentile": 0.5248}, "CVE-2018-11738": {"epss_score": 0.00295, "epss_percentile": 0.5248}, "CVE-2018-11739": {"epss_score": 0.00295, "epss_percentile": 0.5248}, "CVE-2018-11740": {"epss_score": 0.00295, "epss_percentile": 0.5248}, "CVE-2018-11741": {"epss_score": 0.57485, "epss_percentile": 0.98065}, "CVE-2018-11742": {"epss_score": 0.45947, "epss_percentile": 0.97511}, "CVE-2018-11743": {"epss_score": 0.00567, "epss_percentile": 0.67841}, "CVE-2018-11744": {"epss_score": 0.00386, "epss_percentile": 0.59236}, "CVE-2018-11746": {"epss_score": 0.00229, "epss_percentile": 0.45609}, "CVE-2018-11747": {"epss_score": 0.00265, "epss_percentile": 0.49764}, "CVE-2018-11748": {"epss_score": 0.00047, "epss_percentile": 0.14787}, "CVE-2018-11749": {"epss_score": 0.00154, "epss_percentile": 0.36714}, "CVE-2018-11750": {"epss_score": 0.0027, "epss_percentile": 0.50236}, "CVE-2018-11751": {"epss_score": 0.00223, "epss_percentile": 0.44855}, "CVE-2018-11752": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2018-11756": {"epss_score": 0.06136, "epss_percentile": 0.90509}, "CVE-2018-11757": {"epss_score": 0.0147, "epss_percentile": 0.80492}, "CVE-2018-11758": {"epss_score": 0.00357, "epss_percentile": 0.57467}, "CVE-2018-11759": {"epss_score": 0.94254, "epss_percentile": 0.99927}, "CVE-2018-11760": {"epss_score": 0.00471, "epss_percentile": 0.64025}, "CVE-2018-11761": {"epss_score": 0.09946, "epss_percentile": 0.92786}, "CVE-2018-11762": {"epss_score": 0.01532, "epss_percentile": 0.80894}, "CVE-2018-11763": {"epss_score": 0.17401, "epss_percentile": 0.94845}, "CVE-2018-11764": {"epss_score": 0.00185, "epss_percentile": 0.40469}, "CVE-2018-11765": {"epss_score": 0.01147, "epss_percentile": 0.7801}, "CVE-2018-11766": {"epss_score": 0.00486, "epss_percentile": 0.6477}, "CVE-2018-11767": {"epss_score": 0.02158, "epss_percentile": 0.83818}, "CVE-2018-11768": {"epss_score": 0.01294, "epss_percentile": 0.79243}, "CVE-2018-11769": {"epss_score": 0.06347, "epss_percentile": 0.90688}, "CVE-2018-11770": {"epss_score": 0.87702, "epss_percentile": 0.9944}, "CVE-2018-11771": {"epss_score": 0.01296, "epss_percentile": 0.79259}, "CVE-2018-11772": {"epss_score": 0.0046, "epss_percentile": 0.63535}, "CVE-2018-11773": {"epss_score": 0.00877, "epss_percentile": 0.74805}, "CVE-2018-11774": {"epss_score": 0.0046, "epss_percentile": 0.63535}, "CVE-2018-11775": {"epss_score": 0.00492, "epss_percentile": 0.64981}, "CVE-2018-11776": {"epss_score": 0.94431, "epss_percentile": 0.99983}, "CVE-2018-11777": {"epss_score": 0.00413, "epss_percentile": 0.60966}, "CVE-2018-11778": {"epss_score": 0.01101, "epss_percentile": 0.77572}, "CVE-2018-11779": {"epss_score": 0.01473, "epss_percentile": 0.80514}, "CVE-2018-11780": {"epss_score": 0.07098, "epss_percentile": 0.91248}, "CVE-2018-11781": {"epss_score": 0.00252, "epss_percentile": 0.48341}, "CVE-2018-11782": {"epss_score": 0.01167, "epss_percentile": 0.78189}, "CVE-2018-11783": {"epss_score": 0.01124, "epss_percentile": 0.77799}, "CVE-2018-11784": {"epss_score": 0.85117, "epss_percentile": 0.99319}, "CVE-2018-11785": {"epss_score": 0.00108, "epss_percentile": 0.29799}, "CVE-2018-11786": {"epss_score": 0.00795, "epss_percentile": 0.73475}, "CVE-2018-11787": {"epss_score": 0.00697, "epss_percentile": 0.71401}, "CVE-2018-11788": {"epss_score": 0.24747, "epss_percentile": 0.9595}, "CVE-2018-11789": {"epss_score": 0.0165, "epss_percentile": 0.8156}, "CVE-2018-11790": {"epss_score": 0.00741, "epss_percentile": 0.72413}, "CVE-2018-11792": {"epss_score": 0.0055, "epss_percentile": 0.67335}, "CVE-2018-11793": {"epss_score": 0.07409, "epss_percentile": 0.91457}, "CVE-2018-11796": {"epss_score": 0.0192, "epss_percentile": 0.82896}, "CVE-2018-11797": {"epss_score": 0.01245, "epss_percentile": 0.78843}, "CVE-2018-11798": {"epss_score": 0.00565, "epss_percentile": 0.67784}, "CVE-2018-11799": {"epss_score": 0.00241, "epss_percentile": 0.47264}, "CVE-2018-11800": {"epss_score": 0.03316, "epss_percentile": 0.86902}, "CVE-2018-11801": {"epss_score": 0.03316, "epss_percentile": 0.86902}, "CVE-2018-11802": {"epss_score": 0.00151, "epss_percentile": 0.36188}, "CVE-2018-11803": {"epss_score": 0.00814, "epss_percentile": 0.73769}, "CVE-2018-11804": {"epss_score": 0.00716, "epss_percentile": 0.71865}, "CVE-2018-11805": {"epss_score": 0.00033, "epss_percentile": 0.09296}, "CVE-2018-11806": {"epss_score": 0.0005, "epss_percentile": 0.15961}, "CVE-2018-11808": {"epss_score": 0.0423, "epss_percentile": 0.88422}, "CVE-2018-11813": {"epss_score": 0.00337, "epss_percentile": 0.56028}, "CVE-2018-11816": {"epss_score": 0.00041, "epss_percentile": 0.12197}, "CVE-2018-11818": {"epss_score": 0.00024, "epss_percentile": 0.0579}, "CVE-2018-11819": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2018-11820": {"epss_score": 0.00051, "epss_percentile": 0.16187}, "CVE-2018-11821": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11822": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11823": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2018-11824": {"epss_score": 0.00121, "epss_percentile": 0.31879}, "CVE-2018-11826": {"epss_score": 0.00027, "epss_percentile": 0.06783}, "CVE-2018-11827": {"epss_score": 0.00025, "epss_percentile": 0.06283}, "CVE-2018-11828": {"epss_score": 0.00236, "epss_percentile": 0.46417}, "CVE-2018-11830": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11832": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2018-11836": {"epss_score": 0.00064, "epss_percentile": 0.20265}, "CVE-2018-11838": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2018-11840": {"epss_score": 0.00025, "epss_percentile": 0.06283}, "CVE-2018-11842": {"epss_score": 0.00064, "epss_percentile": 0.20265}, "CVE-2018-11843": {"epss_score": 0.00018, "epss_percentile": 0.03795}, "CVE-2018-11845": {"epss_score": 0.00051, "epss_percentile": 0.16187}, "CVE-2018-11846": {"epss_score": 0.00096, "epss_percentile": 0.27304}, "CVE-2018-11847": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11849": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11850": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11851": {"epss_score": 0.00032, "epss_percentile": 0.08809}, "CVE-2018-11852": {"epss_score": 0.00015, "epss_percentile": 0.02543}, "CVE-2018-11853": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11854": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11855": {"epss_score": 0.00121, "epss_percentile": 0.31879}, "CVE-2018-11856": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11857": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2018-11858": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2018-11859": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11860": {"epss_score": 0.00032, "epss_percentile": 0.08809}, "CVE-2018-11861": {"epss_score": 0.0004, "epss_percentile": 0.12053}, "CVE-2018-11862": {"epss_score": 0.0004, "epss_percentile": 0.12053}, "CVE-2018-11863": {"epss_score": 0.00015, "epss_percentile": 0.02543}, "CVE-2018-11864": {"epss_score": 0.00051, "epss_percentile": 0.16187}, "CVE-2018-11865": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2018-11866": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2018-11867": {"epss_score": 0.0004, "epss_percentile": 0.12053}, "CVE-2018-11868": {"epss_score": 0.00034, "epss_percentile": 0.09519}, "CVE-2018-11869": {"epss_score": 0.00034, "epss_percentile": 0.09519}, "CVE-2018-11870": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11871": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11872": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11873": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11874": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2018-11875": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2018-11876": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2018-11877": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11878": {"epss_score": 0.00032, "epss_percentile": 0.08809}, "CVE-2018-11879": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11880": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11882": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11883": {"epss_score": 0.00015, "epss_percentile": 0.02543}, "CVE-2018-11884": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2018-11886": {"epss_score": 0.00016, "epss_percentile": 0.0292}, "CVE-2018-11888": {"epss_score": 0.00025, "epss_percentile": 0.06204}, "CVE-2018-11889": {"epss_score": 0.00032, "epss_percentile": 0.08809}, "CVE-2018-11891": {"epss_score": 0.0032, "epss_percentile": 0.54609}, "CVE-2018-11893": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2018-11894": {"epss_score": 0.00034, "epss_percentile": 0.09519}, "CVE-2018-11895": {"epss_score": 0.00032, "epss_percentile": 0.08809}, "CVE-2018-11897": {"epss_score": 0.00032, "epss_percentile": 0.08809}, "CVE-2018-11898": {"epss_score": 0.00064, "epss_percentile": 0.20265}, "CVE-2018-11899": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2018-11902": {"epss_score": 0.00032, "epss_percentile": 0.08809}, "CVE-2018-11903": {"epss_score": 0.00015, "epss_percentile": 0.02543}, "CVE-2018-11904": {"epss_score": 0.0005, "epss_percentile": 0.15657}, "CVE-2018-11905": {"epss_score": 0.0012, "epss_percentile": 0.3181}, "CVE-2018-11906": {"epss_score": 0.00027, "epss_percentile": 0.06844}, "CVE-2018-11907": {"epss_score": 0.00014, "epss_percentile": 0.01921}, "CVE-2018-11908": {"epss_score": 0.00014, "epss_percentile": 0.01921}, "CVE-2018-11909": {"epss_score": 0.00014, "epss_percentile": 0.01921}, "CVE-2018-11910": {"epss_score": 0.00014, "epss_percentile": 0.01921}, "CVE-2018-11911": {"epss_score": 0.00014, "epss_percentile": 0.01921}, "CVE-2018-11912": {"epss_score": 0.00014, "epss_percentile": 0.01921}, "CVE-2018-11913": {"epss_score": 0.00023, "epss_percentile": 0.05606}, "CVE-2018-11914": {"epss_score": 0.00023, "epss_percentile": 0.05606}, "CVE-2018-11918": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2018-11919": {"epss_score": 0.0004, "epss_percentile": 0.1187}, "CVE-2018-11921": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11922": {"epss_score": 0.00124, "epss_percentile": 0.32363}, "CVE-2018-11923": {"epss_score": 0.00045, "epss_percentile": 0.13758}, "CVE-2018-11924": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2018-11925": {"epss_score": 0.00037, "epss_percentile": 0.10966}, "CVE-2018-11927": {"epss_score": 0.00035, "epss_percentile": 0.10064}, "CVE-2018-11928": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2018-11929": {"epss_score": 0.00045, "epss_percentile": 0.13758}, "CVE-2018-11930": {"epss_score": 0.00266, "epss_percentile": 0.49846}, "CVE-2018-11931": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11932": {"epss_score": 0.00221, "epss_percentile": 0.44663}, "CVE-2018-11934": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2018-11935": {"epss_score": 0.00182, "epss_percentile": 0.40229}, "CVE-2018-11936": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2018-11937": {"epss_score": 0.00266, "epss_percentile": 0.49846}, "CVE-2018-11938": {"epss_score": 0.00062, "epss_percentile": 0.19701}, "CVE-2018-11939": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2018-11940": {"epss_score": 0.00266, "epss_percentile": 0.49846}, "CVE-2018-11942": {"epss_score": 0.00043, "epss_percentile": 0.13285}, "CVE-2018-11943": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2018-11945": {"epss_score": 0.00354, "epss_percentile": 0.57209}, "CVE-2018-11946": {"epss_score": 0.00041, "epss_percentile": 0.12476}, "CVE-2018-11947": {"epss_score": 0.00043, "epss_percentile": 0.13285}, "CVE-2018-11948": {"epss_score": 0.00056, "epss_percentile": 0.17727}, "CVE-2018-11949": {"epss_score": 0.00266, "epss_percentile": 0.49846}, "CVE-2018-11950": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2018-11951": {"epss_score": 0.00093, "epss_percentile": 0.26717}, "CVE-2018-11952": {"epss_score": 0.00049, "epss_percentile": 0.15506}, "CVE-2018-11953": {"epss_score": 0.00266, "epss_percentile": 0.49846}, "CVE-2018-11955": {"epss_score": 0.00322, "epss_percentile": 0.54823}, "CVE-2018-11956": {"epss_score": 0.00015, "epss_percentile": 0.02543}, "CVE-2018-11958": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2018-11960": {"epss_score": 0.00022, "epss_percentile": 0.05184}, "CVE-2018-11961": {"epss_score": 0.00019, "epss_percentile": 0.04178}, "CVE-2018-11962": {"epss_score": 0.00022, "epss_percentile": 0.05184}, "CVE-2018-11963": {"epss_score": 0.00019, "epss_percentile": 0.04178}, "CVE-2018-11964": {"epss_score": 0.00014, "epss_percentile": 0.01921}, "CVE-2018-11965": {"epss_score": 0.00014, "epss_percentile": 0.01921}, "CVE-2018-11966": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11967": {"epss_score": 0.00035, "epss_percentile": 0.10064}, "CVE-2018-11968": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11970": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-11971": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2018-11976": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2018-11980": {"epss_score": 0.00121, "epss_percentile": 0.31879}, "CVE-2018-11982": {"epss_score": 0.00081, "epss_percentile": 0.2423}, "CVE-2018-11983": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2018-11984": {"epss_score": 0.00021, "epss_percentile": 0.04947}, "CVE-2018-11985": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2018-11986": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2018-11987": {"epss_score": 0.00035, "epss_percentile": 0.10152}, "CVE-2018-11988": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2018-11993": {"epss_score": 0.00186, "epss_percentile": 0.40608}, "CVE-2018-11994": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11995": {"epss_score": 0.00032, "epss_percentile": 0.08809}, "CVE-2018-11996": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-11998": {"epss_score": 0.00057, "epss_percentile": 0.18141}, "CVE-2018-11999": {"epss_score": 0.00046, "epss_percentile": 0.14101}, "CVE-2018-12004": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2018-12005": {"epss_score": 0.0004, "epss_percentile": 0.1193}, "CVE-2018-12006": {"epss_score": 0.00019, "epss_percentile": 0.04165}, "CVE-2018-12010": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2018-12011": {"epss_score": 0.00019, "epss_percentile": 0.04165}, "CVE-2018-12012": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-12013": {"epss_score": 0.00035, "epss_percentile": 0.09911}, "CVE-2018-12014": {"epss_score": 0.00019, "epss_percentile": 0.04178}, "CVE-2018-12015": {"epss_score": 0.15065, "epss_percentile": 0.94354}, "CVE-2018-12016": {"epss_score": 0.00894, "epss_percentile": 0.75084}, "CVE-2018-12018": {"epss_score": 0.1185, "epss_percentile": 0.93495}, "CVE-2018-12019": {"epss_score": 0.00487, "epss_percentile": 0.64825}, "CVE-2018-12020": {"epss_score": 0.01639, "epss_percentile": 0.81495}, "CVE-2018-12021": {"epss_score": 0.00516, "epss_percentile": 0.66051}, "CVE-2018-12022": {"epss_score": 0.03035, "epss_percentile": 0.8626}, "CVE-2018-12023": {"epss_score": 0.04812, "epss_percentile": 0.89167}, "CVE-2018-12025": {"epss_score": 0.00517, "epss_percentile": 0.66071}, "CVE-2018-12026": {"epss_score": 0.01123, "epss_percentile": 0.77792}, "CVE-2018-12027": {"epss_score": 0.00275, "epss_percentile": 0.50629}, "CVE-2018-12028": {"epss_score": 0.00175, "epss_percentile": 0.39373}, "CVE-2018-12029": {"epss_score": 0.00099, "epss_percentile": 0.28341}, "CVE-2018-12030": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-12031": {"epss_score": 0.74839, "epss_percentile": 0.9882}, "CVE-2018-12034": {"epss_score": 0.00314, "epss_percentile": 0.54149}, "CVE-2018-12035": {"epss_score": 0.00314, "epss_percentile": 0.54149}, "CVE-2018-12036": {"epss_score": 0.00176, "epss_percentile": 0.39396}, "CVE-2018-12037": {"epss_score": 0.00148, "epss_percentile": 0.35864}, "CVE-2018-12038": {"epss_score": 0.07016, "epss_percentile": 0.91188}, "CVE-2018-12039": {"epss_score": 0.08311, "epss_percentile": 0.91985}, "CVE-2018-12040": {"epss_score": 0.00287, "epss_percentile": 0.5181}, "CVE-2018-12041": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-12042": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2018-12043": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12045": {"epss_score": 0.00557, "epss_percentile": 0.67553}, "CVE-2018-12046": {"epss_score": 0.00174, "epss_percentile": 0.39157}, "CVE-2018-12047": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12048": {"epss_score": 0.06293, "epss_percentile": 0.9065}, "CVE-2018-12049": {"epss_score": 0.06293, "epss_percentile": 0.9065}, "CVE-2018-12051": {"epss_score": 0.02322, "epss_percentile": 0.84372}, "CVE-2018-12052": {"epss_score": 0.02537, "epss_percentile": 0.8504}, "CVE-2018-12053": {"epss_score": 0.43844, "epss_percentile": 0.97405}, "CVE-2018-12054": {"epss_score": 0.76183, "epss_percentile": 0.98881}, "CVE-2018-12055": {"epss_score": 0.02114, "epss_percentile": 0.83656}, "CVE-2018-12056": {"epss_score": 0.00315, "epss_percentile": 0.54173}, "CVE-2018-12062": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12063": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12064": {"epss_score": 0.00403, "epss_percentile": 0.60364}, "CVE-2018-12065": {"epss_score": 0.00729, "epss_percentile": 0.72134}, "CVE-2018-12066": {"epss_score": 0.00065, "epss_percentile": 0.20589}, "CVE-2018-12067": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12068": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12070": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12071": {"epss_score": 0.00242, "epss_percentile": 0.47403}, "CVE-2018-12072": {"epss_score": 0.00339, "epss_percentile": 0.5618}, "CVE-2018-12073": {"epss_score": 0.00141, "epss_percentile": 0.34837}, "CVE-2018-12076": {"epss_score": 0.00188, "epss_percentile": 0.40833}, "CVE-2018-12078": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12079": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12080": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12081": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12082": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12083": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12084": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12085": {"epss_score": 0.00292, "epss_percentile": 0.52285}, "CVE-2018-12086": {"epss_score": 0.25733, "epss_percentile": 0.9606}, "CVE-2018-12087": {"epss_score": 0.00033, "epss_percentile": 0.0939}, "CVE-2018-12088": {"epss_score": 0.00267, "epss_percentile": 0.49993}, "CVE-2018-12089": {"epss_score": 0.00283, "epss_percentile": 0.51351}, "CVE-2018-12090": {"epss_score": 0.0068, "epss_percentile": 0.71026}, "CVE-2018-12092": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2018-12093": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-12094": {"epss_score": 0.00455, "epss_percentile": 0.6328}, "CVE-2018-12095": {"epss_score": 0.12697, "epss_percentile": 0.93752}, "CVE-2018-12096": {"epss_score": 0.00099, "epss_percentile": 0.28316}, "CVE-2018-12097": {"epss_score": 0.00099, "epss_percentile": 0.28316}, "CVE-2018-12098": {"epss_score": 0.00261, "epss_percentile": 0.49256}, "CVE-2018-12099": {"epss_score": 0.00675, "epss_percentile": 0.70897}, "CVE-2018-12100": {"epss_score": 0.00342, "epss_percentile": 0.56379}, "CVE-2018-12101": {"epss_score": 0.00346, "epss_percentile": 0.56622}, "CVE-2018-12102": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2018-12103": {"epss_score": 0.00301, "epss_percentile": 0.53046}, "CVE-2018-12104": {"epss_score": 0.00206, "epss_percentile": 0.43049}, "CVE-2018-12108": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2018-12109": {"epss_score": 0.00261, "epss_percentile": 0.49246}, "CVE-2018-12110": {"epss_score": 0.00247, "epss_percentile": 0.47867}, "CVE-2018-12111": {"epss_score": 0.00349, "epss_percentile": 0.56911}, "CVE-2018-12112": {"epss_score": 0.00234, "epss_percentile": 0.46192}, "CVE-2018-12113": {"epss_score": 0.1276, "epss_percentile": 0.93766}, "CVE-2018-12114": {"epss_score": 0.00319, "epss_percentile": 0.54476}, "CVE-2018-12115": {"epss_score": 0.0145, "epss_percentile": 0.80354}, "CVE-2018-12116": {"epss_score": 0.00619, "epss_percentile": 0.69401}, "CVE-2018-12120": {"epss_score": 0.00419, "epss_percentile": 0.61389}, "CVE-2018-12121": {"epss_score": 0.04278, "epss_percentile": 0.88484}, "CVE-2018-12122": {"epss_score": 0.03643, "epss_percentile": 0.87495}, "CVE-2018-12123": {"epss_score": 0.06059, "epss_percentile": 0.90441}, "CVE-2018-12126": {"epss_score": 0.00432, "epss_percentile": 0.62121}, "CVE-2018-12127": {"epss_score": 0.00432, "epss_percentile": 0.62121}, "CVE-2018-12130": {"epss_score": 0.00405, "epss_percentile": 0.60483}, "CVE-2018-12131": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2018-12147": {"epss_score": 0.00045, "epss_percentile": 0.13794}, "CVE-2018-12148": {"epss_score": 0.00031, "epss_percentile": 0.08529}, "CVE-2018-12149": {"epss_score": 0.00053, "epss_percentile": 0.16977}, "CVE-2018-12150": {"epss_score": 0.00058, "epss_percentile": 0.18526}, "CVE-2018-12151": {"epss_score": 0.0005, "epss_percentile": 0.15681}, "CVE-2018-12152": {"epss_score": 0.0176, "epss_percentile": 0.82148}, "CVE-2018-12153": {"epss_score": 0.00227, "epss_percentile": 0.45393}, "CVE-2018-12154": {"epss_score": 0.00312, "epss_percentile": 0.53936}, "CVE-2018-12155": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-12158": {"epss_score": 0.00043, "epss_percentile": 0.13333}, "CVE-2018-12159": {"epss_score": 0.0005, "epss_percentile": 0.15681}, "CVE-2018-12160": {"epss_score": 0.00038, "epss_percentile": 0.11283}, "CVE-2018-12161": {"epss_score": 0.00294, "epss_percentile": 0.5237}, "CVE-2018-12162": {"epss_score": 0.0004, "epss_percentile": 0.12072}, "CVE-2018-12163": {"epss_score": 0.00169, "epss_percentile": 0.38621}, "CVE-2018-12166": {"epss_score": 0.00049, "epss_percentile": 0.15309}, "CVE-2018-12167": {"epss_score": 0.00049, "epss_percentile": 0.15309}, "CVE-2018-12168": {"epss_score": 0.00031, "epss_percentile": 0.08529}, "CVE-2018-12169": {"epss_score": 0.00055, "epss_percentile": 0.17598}, "CVE-2018-12171": {"epss_score": 0.00743, "epss_percentile": 0.72475}, "CVE-2018-12172": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-12173": {"epss_score": 0.00042, "epss_percentile": 0.1259}, "CVE-2018-12174": {"epss_score": 0.00083, "epss_percentile": 0.24825}, "CVE-2018-12175": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2018-12176": {"epss_score": 0.00042, "epss_percentile": 0.12745}, "CVE-2018-12177": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2018-12178": {"epss_score": 0.00518, "epss_percentile": 0.66124}, "CVE-2018-12179": {"epss_score": 0.00125, "epss_percentile": 0.3248}, "CVE-2018-12180": {"epss_score": 0.01535, "epss_percentile": 0.80911}, "CVE-2018-12181": {"epss_score": 0.00161, "epss_percentile": 0.37532}, "CVE-2018-12182": {"epss_score": 0.00096, "epss_percentile": 0.27412}, "CVE-2018-12183": {"epss_score": 0.00089, "epss_percentile": 0.25875}, "CVE-2018-12185": {"epss_score": 0.00152, "epss_percentile": 0.36392}, "CVE-2018-12187": {"epss_score": 0.00382, "epss_percentile": 0.59077}, "CVE-2018-12188": {"epss_score": 0.00111, "epss_percentile": 0.30267}, "CVE-2018-12189": {"epss_score": 0.0012, "epss_percentile": 0.31768}, "CVE-2018-12190": {"epss_score": 0.00133, "epss_percentile": 0.33642}, "CVE-2018-12191": {"epss_score": 0.00239, "epss_percentile": 0.46882}, "CVE-2018-12192": {"epss_score": 0.00071, "epss_percentile": 0.22128}, "CVE-2018-12193": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-12196": {"epss_score": 0.00159, "epss_percentile": 0.37397}, "CVE-2018-12198": {"epss_score": 0.00133, "epss_percentile": 0.33644}, "CVE-2018-12199": {"epss_score": 0.00152, "epss_percentile": 0.36445}, "CVE-2018-12200": {"epss_score": 0.00112, "epss_percentile": 0.30566}, "CVE-2018-12201": {"epss_score": 0.00321, "epss_percentile": 0.54734}, "CVE-2018-12202": {"epss_score": 0.00156, "epss_percentile": 0.36915}, "CVE-2018-12203": {"epss_score": 0.00176, "epss_percentile": 0.39431}, "CVE-2018-12204": {"epss_score": 0.00156, "epss_percentile": 0.36915}, "CVE-2018-12205": {"epss_score": 0.00131, "epss_percentile": 0.33412}, "CVE-2018-12206": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2018-12207": {"epss_score": 0.00262, "epss_percentile": 0.49344}, "CVE-2018-12208": {"epss_score": 0.00332, "epss_percentile": 0.55594}, "CVE-2018-12209": {"epss_score": 0.00102, "epss_percentile": 0.28743}, "CVE-2018-12210": {"epss_score": 0.00122, "epss_percentile": 0.3215}, "CVE-2018-12211": {"epss_score": 0.00122, "epss_percentile": 0.3215}, "CVE-2018-12212": {"epss_score": 0.00146, "epss_percentile": 0.35586}, "CVE-2018-12213": {"epss_score": 0.00158, "epss_percentile": 0.37165}, "CVE-2018-12214": {"epss_score": 0.00177, "epss_percentile": 0.396}, "CVE-2018-12215": {"epss_score": 0.00134, "epss_percentile": 0.33831}, "CVE-2018-12216": {"epss_score": 0.00177, "epss_percentile": 0.396}, "CVE-2018-12217": {"epss_score": 0.0011, "epss_percentile": 0.30153}, "CVE-2018-12218": {"epss_score": 0.00054, "epss_percentile": 0.17226}, "CVE-2018-12219": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-12220": {"epss_score": 0.00054, "epss_percentile": 0.17233}, "CVE-2018-12221": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2018-12222": {"epss_score": 0.00054, "epss_percentile": 0.17226}, "CVE-2018-12223": {"epss_score": 0.00046, "epss_percentile": 0.14174}, "CVE-2018-12224": {"epss_score": 0.00037, "epss_percentile": 0.10684}, "CVE-2018-12227": {"epss_score": 0.0106, "epss_percentile": 0.77162}, "CVE-2018-12228": {"epss_score": 0.00422, "epss_percentile": 0.61573}, "CVE-2018-12229": {"epss_score": 0.00402, "epss_percentile": 0.60299}, "CVE-2018-12230": {"epss_score": 0.00294, "epss_percentile": 0.52389}, "CVE-2018-12232": {"epss_score": 0.03298, "epss_percentile": 0.86859}, "CVE-2018-12233": {"epss_score": 0.00084, "epss_percentile": 0.24903}, "CVE-2018-12234": {"epss_score": 0.0477, "epss_percentile": 0.89127}, "CVE-2018-12237": {"epss_score": 0.02444, "epss_percentile": 0.84762}, "CVE-2018-12238": {"epss_score": 0.00082, "epss_percentile": 0.24539}, "CVE-2018-12239": {"epss_score": 0.00087, "epss_percentile": 0.2547}, "CVE-2018-12240": {"epss_score": 0.00307, "epss_percentile": 0.53522}, "CVE-2018-12241": {"epss_score": 0.00367, "epss_percentile": 0.58132}, "CVE-2018-12242": {"epss_score": 0.06452, "epss_percentile": 0.90766}, "CVE-2018-12243": {"epss_score": 0.00226, "epss_percentile": 0.45329}, "CVE-2018-12244": {"epss_score": 0.00377, "epss_percentile": 0.58715}, "CVE-2018-12245": {"epss_score": 0.00236, "epss_percentile": 0.46374}, "CVE-2018-12246": {"epss_score": 0.00367, "epss_percentile": 0.58132}, "CVE-2018-12247": {"epss_score": 0.00275, "epss_percentile": 0.50682}, "CVE-2018-12248": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2018-12249": {"epss_score": 0.00659, "epss_percentile": 0.70516}, "CVE-2018-12250": {"epss_score": 0.00124, "epss_percentile": 0.32389}, "CVE-2018-12254": {"epss_score": 0.00365, "epss_percentile": 0.57982}, "CVE-2018-12255": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12256": {"epss_score": 0.02407, "epss_percentile": 0.84656}, "CVE-2018-12257": {"epss_score": 0.00064, "epss_percentile": 0.20389}, "CVE-2018-12258": {"epss_score": 0.00049, "epss_percentile": 0.15329}, "CVE-2018-12259": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2018-12260": {"epss_score": 0.00066, "epss_percentile": 0.20869}, "CVE-2018-12261": {"epss_score": 0.00052, "epss_percentile": 0.16443}, "CVE-2018-12263": {"epss_score": 0.00381, "epss_percentile": 0.58996}, "CVE-2018-12264": {"epss_score": 0.00734, "epss_percentile": 0.72238}, "CVE-2018-12265": {"epss_score": 0.00734, "epss_percentile": 0.72238}, "CVE-2018-12266": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12268": {"epss_score": 0.12517, "epss_percentile": 0.93704}, "CVE-2018-12270": {"epss_score": 0.00238, "epss_percentile": 0.46802}, "CVE-2018-12271": {"epss_score": 0.00036, "epss_percentile": 0.10253}, "CVE-2018-12272": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12273": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12290": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12291": {"epss_score": 0.002, "epss_percentile": 0.42211}, "CVE-2018-12292": {"epss_score": 0.11314, "epss_percentile": 0.93303}, "CVE-2018-12293": {"epss_score": 0.38999, "epss_percentile": 0.97133}, "CVE-2018-12294": {"epss_score": 0.00712, "epss_percentile": 0.71757}, "CVE-2018-12295": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-12296": {"epss_score": 0.75166, "epss_percentile": 0.98831}, "CVE-2018-12297": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12298": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2018-12299": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-12300": {"epss_score": 0.20557, "epss_percentile": 0.95377}, "CVE-2018-12301": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-12302": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12303": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-12304": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12305": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12306": {"epss_score": 0.00561, "epss_percentile": 0.67679}, "CVE-2018-12307": {"epss_score": 0.1198, "epss_percentile": 0.93534}, "CVE-2018-12308": {"epss_score": 0.00151, "epss_percentile": 0.36254}, "CVE-2018-12309": {"epss_score": 0.00456, "epss_percentile": 0.63343}, "CVE-2018-12310": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-12311": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-12312": {"epss_score": 0.1198, "epss_percentile": 0.93534}, "CVE-2018-12313": {"epss_score": 0.05628, "epss_percentile": 0.90064}, "CVE-2018-12314": {"epss_score": 0.00993, "epss_percentile": 0.76402}, "CVE-2018-12315": {"epss_score": 0.00146, "epss_percentile": 0.35554}, "CVE-2018-12316": {"epss_score": 0.1198, "epss_percentile": 0.93534}, "CVE-2018-12317": {"epss_score": 0.1198, "epss_percentile": 0.93534}, "CVE-2018-12318": {"epss_score": 0.00305, "epss_percentile": 0.53378}, "CVE-2018-12319": {"epss_score": 0.00396, "epss_percentile": 0.59861}, "CVE-2018-12320": {"epss_score": 0.00169, "epss_percentile": 0.38527}, "CVE-2018-12321": {"epss_score": 0.00169, "epss_percentile": 0.38527}, "CVE-2018-12322": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2018-12323": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2018-12326": {"epss_score": 0.28107, "epss_percentile": 0.96311}, "CVE-2018-12327": {"epss_score": 0.15004, "epss_percentile": 0.94339}, "CVE-2018-12329": {"epss_score": 0.00296, "epss_percentile": 0.52564}, "CVE-2018-12330": {"epss_score": 0.00114, "epss_percentile": 0.30804}, "CVE-2018-12331": {"epss_score": 0.00175, "epss_percentile": 0.39273}, "CVE-2018-12332": {"epss_score": 0.00034, "epss_percentile": 0.09462}, "CVE-2018-12333": {"epss_score": 0.00137, "epss_percentile": 0.34341}, "CVE-2018-12334": {"epss_score": 0.00179, "epss_percentile": 0.39849}, "CVE-2018-12335": {"epss_score": 0.00078, "epss_percentile": 0.23578}, "CVE-2018-12336": {"epss_score": 0.00358, "epss_percentile": 0.57487}, "CVE-2018-12337": {"epss_score": 0.00064, "epss_percentile": 0.20301}, "CVE-2018-12338": {"epss_score": 0.00358, "epss_percentile": 0.57487}, "CVE-2018-12339": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-12353": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12354": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2018-12355": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2018-12356": {"epss_score": 0.02614, "epss_percentile": 0.8524}, "CVE-2018-12357": {"epss_score": 0.00134, "epss_percentile": 0.33842}, "CVE-2018-12358": {"epss_score": 0.00286, "epss_percentile": 0.51695}, "CVE-2018-12359": {"epss_score": 0.04016, "epss_percentile": 0.88122}, "CVE-2018-12360": {"epss_score": 0.02562, "epss_percentile": 0.85108}, "CVE-2018-12361": {"epss_score": 0.0117, "epss_percentile": 0.78206}, "CVE-2018-12362": {"epss_score": 0.02424, "epss_percentile": 0.84711}, "CVE-2018-12363": {"epss_score": 0.02562, "epss_percentile": 0.85108}, "CVE-2018-12364": {"epss_score": 0.0267, "epss_percentile": 0.85386}, "CVE-2018-12365": {"epss_score": 0.02054, "epss_percentile": 0.83419}, "CVE-2018-12366": {"epss_score": 0.01075, "epss_percentile": 0.77305}, "CVE-2018-12367": {"epss_score": 0.01271, "epss_percentile": 0.79057}, "CVE-2018-12368": {"epss_score": 0.01952, "epss_percentile": 0.8302}, "CVE-2018-12369": {"epss_score": 0.00559, "epss_percentile": 0.67624}, "CVE-2018-12370": {"epss_score": 0.00344, "epss_percentile": 0.56545}, "CVE-2018-12371": {"epss_score": 0.00495, "epss_percentile": 0.65124}, "CVE-2018-12372": {"epss_score": 0.00786, "epss_percentile": 0.733}, "CVE-2018-12373": {"epss_score": 0.01098, "epss_percentile": 0.77545}, "CVE-2018-12374": {"epss_score": 0.00763, "epss_percentile": 0.72887}, "CVE-2018-12375": {"epss_score": 0.00512, "epss_percentile": 0.65858}, "CVE-2018-12376": {"epss_score": 0.03107, "epss_percentile": 0.8642}, "CVE-2018-12377": {"epss_score": 0.03107, "epss_percentile": 0.8642}, "CVE-2018-12378": {"epss_score": 0.03107, "epss_percentile": 0.8642}, "CVE-2018-12379": {"epss_score": 0.00098, "epss_percentile": 0.27788}, "CVE-2018-12381": {"epss_score": 0.00637, "epss_percentile": 0.69897}, "CVE-2018-12382": {"epss_score": 0.00368, "epss_percentile": 0.58212}, "CVE-2018-12383": {"epss_score": 0.0008, "epss_percentile": 0.24057}, "CVE-2018-12384": {"epss_score": 0.01017, "epss_percentile": 0.76694}, "CVE-2018-12385": {"epss_score": 0.0006, "epss_percentile": 0.1897}, "CVE-2018-12386": {"epss_score": 0.39099, "epss_percentile": 0.97138}, "CVE-2018-12387": {"epss_score": 0.3422, "epss_percentile": 0.96832}, "CVE-2018-12388": {"epss_score": 0.00534, "epss_percentile": 0.66791}, "CVE-2018-12389": {"epss_score": 0.01795, "epss_percentile": 0.82295}, "CVE-2018-12390": {"epss_score": 0.09479, "epss_percentile": 0.92565}, "CVE-2018-12391": {"epss_score": 0.00569, "epss_percentile": 0.67912}, "CVE-2018-12392": {"epss_score": 0.07965, "epss_percentile": 0.91794}, "CVE-2018-12393": {"epss_score": 0.05865, "epss_percentile": 0.90276}, "CVE-2018-12395": {"epss_score": 0.02963, "epss_percentile": 0.86075}, "CVE-2018-12396": {"epss_score": 0.01157, "epss_percentile": 0.78113}, "CVE-2018-12397": {"epss_score": 0.00069, "epss_percentile": 0.21524}, "CVE-2018-12398": {"epss_score": 0.00355, "epss_percentile": 0.57281}, "CVE-2018-12399": {"epss_score": 0.00423, "epss_percentile": 0.61635}, "CVE-2018-12400": {"epss_score": 0.0031, "epss_percentile": 0.53751}, "CVE-2018-12401": {"epss_score": 0.00912, "epss_percentile": 0.75364}, "CVE-2018-12402": {"epss_score": 0.00373, "epss_percentile": 0.58465}, "CVE-2018-12403": {"epss_score": 0.00523, "epss_percentile": 0.6629}, "CVE-2018-12404": {"epss_score": 0.33931, "epss_percentile": 0.96817}, "CVE-2018-12405": {"epss_score": 0.10439, "epss_percentile": 0.92987}, "CVE-2018-12406": {"epss_score": 0.00387, "epss_percentile": 0.59288}, "CVE-2018-12407": {"epss_score": 0.04624, "epss_percentile": 0.88935}, "CVE-2018-12408": {"epss_score": 0.00285, "epss_percentile": 0.51502}, "CVE-2018-12409": {"epss_score": 0.00307, "epss_percentile": 0.53565}, "CVE-2018-12410": {"epss_score": 0.02232, "epss_percentile": 0.84092}, "CVE-2018-12411": {"epss_score": 0.00159, "epss_percentile": 0.37369}, "CVE-2018-12412": {"epss_score": 0.00159, "epss_percentile": 0.37369}, "CVE-2018-12413": {"epss_score": 0.00215, "epss_percentile": 0.44031}, "CVE-2018-12414": {"epss_score": 0.00159, "epss_percentile": 0.37369}, "CVE-2018-12415": {"epss_score": 0.00159, "epss_percentile": 0.37369}, "CVE-2018-12416": {"epss_score": 0.00125, "epss_percentile": 0.32477}, "CVE-2018-12418": {"epss_score": 0.00414, "epss_percentile": 0.61018}, "CVE-2018-12420": {"epss_score": 0.0014, "epss_percentile": 0.34739}, "CVE-2018-12421": {"epss_score": 0.00983, "epss_percentile": 0.76308}, "CVE-2018-12422": {"epss_score": 0.0051, "epss_percentile": 0.65766}, "CVE-2018-12423": {"epss_score": 0.00349, "epss_percentile": 0.56881}, "CVE-2018-12426": {"epss_score": 0.1059, "epss_percentile": 0.93037}, "CVE-2018-12429": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-12431": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-12432": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12433": {"epss_score": 0.0008, "epss_percentile": 0.24007}, "CVE-2018-12434": {"epss_score": 0.0015, "epss_percentile": 0.36068}, "CVE-2018-12435": {"epss_score": 0.00153, "epss_percentile": 0.36615}, "CVE-2018-12436": {"epss_score": 0.00139, "epss_percentile": 0.34637}, "CVE-2018-12437": {"epss_score": 0.00082, "epss_percentile": 0.24557}, "CVE-2018-12438": {"epss_score": 0.0008, "epss_percentile": 0.24007}, "CVE-2018-12439": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2018-12440": {"epss_score": 0.00019, "epss_percentile": 0.04165}, "CVE-2018-12441": {"epss_score": 0.00034, "epss_percentile": 0.0947}, "CVE-2018-12445": {"epss_score": 0.0005, "epss_percentile": 0.15852}, "CVE-2018-12446": {"epss_score": 0.00048, "epss_percentile": 0.15126}, "CVE-2018-12447": {"epss_score": 0.01343, "epss_percentile": 0.79606}, "CVE-2018-12448": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2018-12449": {"epss_score": 0.00225, "epss_percentile": 0.45107}, "CVE-2018-12453": {"epss_score": 0.31963, "epss_percentile": 0.96663}, "CVE-2018-12454": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2018-12455": {"epss_score": 0.24004, "epss_percentile": 0.95841}, "CVE-2018-12456": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-12457": {"epss_score": 0.00524, "epss_percentile": 0.66341}, "CVE-2018-12458": {"epss_score": 0.00962, "epss_percentile": 0.75997}, "CVE-2018-12459": {"epss_score": 0.00436, "epss_percentile": 0.62386}, "CVE-2018-12460": {"epss_score": 0.00404, "epss_percentile": 0.60433}, "CVE-2018-12461": {"epss_score": 0.00095, "epss_percentile": 0.27111}, "CVE-2018-12462": {"epss_score": 0.00165, "epss_percentile": 0.38134}, "CVE-2018-12463": {"epss_score": 0.24192, "epss_percentile": 0.95884}, "CVE-2018-12464": {"epss_score": 0.77067, "epss_percentile": 0.9892}, "CVE-2018-12465": {"epss_score": 0.82669, "epss_percentile": 0.99206}, "CVE-2018-12466": {"epss_score": 0.00176, "epss_percentile": 0.39384}, "CVE-2018-12467": {"epss_score": 0.00111, "epss_percentile": 0.30362}, "CVE-2018-12468": {"epss_score": 0.01132, "epss_percentile": 0.77874}, "CVE-2018-12469": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2018-12470": {"epss_score": 0.00393, "epss_percentile": 0.59747}, "CVE-2018-12471": {"epss_score": 0.00538, "epss_percentile": 0.6694}, "CVE-2018-12472": {"epss_score": 0.00378, "epss_percentile": 0.58835}, "CVE-2018-12473": {"epss_score": 0.00302, "epss_percentile": 0.5311}, "CVE-2018-12474": {"epss_score": 0.00385, "epss_percentile": 0.59203}, "CVE-2018-12475": {"epss_score": 0.00418, "epss_percentile": 0.61267}, "CVE-2018-12476": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2018-12477": {"epss_score": 0.00315, "epss_percentile": 0.54192}, "CVE-2018-12478": {"epss_score": 0.00295, "epss_percentile": 0.52444}, "CVE-2018-12479": {"epss_score": 0.00485, "epss_percentile": 0.64728}, "CVE-2018-12480": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12481": {"epss_score": 0.00327, "epss_percentile": 0.55127}, "CVE-2018-12482": {"epss_score": 0.0167, "epss_percentile": 0.81671}, "CVE-2018-12483": {"epss_score": 0.01736, "epss_percentile": 0.82013}, "CVE-2018-12491": {"epss_score": 0.00397, "epss_percentile": 0.59986}, "CVE-2018-12492": {"epss_score": 0.00244, "epss_percentile": 0.47615}, "CVE-2018-12493": {"epss_score": 0.00539, "epss_percentile": 0.66987}, "CVE-2018-12494": {"epss_score": 0.00515, "epss_percentile": 0.65974}, "CVE-2018-12495": {"epss_score": 0.00538, "epss_percentile": 0.66947}, "CVE-2018-12498": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-12499": {"epss_score": 0.00117, "epss_percentile": 0.31371}, "CVE-2018-12501": {"epss_score": 0.03262, "epss_percentile": 0.86774}, "CVE-2018-12503": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2018-12504": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-12511": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12519": {"epss_score": 0.09441, "epss_percentile": 0.9255}, "CVE-2018-12520": {"epss_score": 0.07697, "epss_percentile": 0.91632}, "CVE-2018-12522": {"epss_score": 0.03269, "epss_percentile": 0.8679}, "CVE-2018-12523": {"epss_score": 0.03269, "epss_percentile": 0.8679}, "CVE-2018-12524": {"epss_score": 0.03269, "epss_percentile": 0.8679}, "CVE-2018-12525": {"epss_score": 0.03269, "epss_percentile": 0.8679}, "CVE-2018-12526": {"epss_score": 0.01503, "epss_percentile": 0.80725}, "CVE-2018-12528": {"epss_score": 0.0052, "epss_percentile": 0.66213}, "CVE-2018-12529": {"epss_score": 0.00275, "epss_percentile": 0.5065}, "CVE-2018-12530": {"epss_score": 0.00459, "epss_percentile": 0.6348}, "CVE-2018-12531": {"epss_score": 0.00944, "epss_percentile": 0.75783}, "CVE-2018-12532": {"epss_score": 0.03296, "epss_percentile": 0.86858}, "CVE-2018-12533": {"epss_score": 0.75469, "epss_percentile": 0.98847}, "CVE-2018-12534": {"epss_score": 0.00487, "epss_percentile": 0.64808}, "CVE-2018-12536": {"epss_score": 0.03306, "epss_percentile": 0.86877}, "CVE-2018-12537": {"epss_score": 0.01089, "epss_percentile": 0.77446}, "CVE-2018-12538": {"epss_score": 0.00515, "epss_percentile": 0.65982}, "CVE-2018-12539": {"epss_score": 0.00042, "epss_percentile": 0.12482}, "CVE-2018-12540": {"epss_score": 0.02579, "epss_percentile": 0.8515}, "CVE-2018-12541": {"epss_score": 0.01294, "epss_percentile": 0.79242}, "CVE-2018-12542": {"epss_score": 0.00926, "epss_percentile": 0.75546}, "CVE-2018-12543": {"epss_score": 0.02818, "epss_percentile": 0.8574}, "CVE-2018-12544": {"epss_score": 0.00618, "epss_percentile": 0.69387}, "CVE-2018-12545": {"epss_score": 0.03084, "epss_percentile": 0.86377}, "CVE-2018-12546": {"epss_score": 0.00252, "epss_percentile": 0.48339}, "CVE-2018-12547": {"epss_score": 0.00818, "epss_percentile": 0.73852}, "CVE-2018-12548": {"epss_score": 0.00422, "epss_percentile": 0.61553}, "CVE-2018-12549": {"epss_score": 0.00747, "epss_percentile": 0.72576}, "CVE-2018-12550": {"epss_score": 0.0047, "epss_percentile": 0.63968}, "CVE-2018-12551": {"epss_score": 0.00708, "epss_percentile": 0.71666}, "CVE-2018-12556": {"epss_score": 0.0034, "epss_percentile": 0.56231}, "CVE-2018-12557": {"epss_score": 0.00426, "epss_percentile": 0.61747}, "CVE-2018-12558": {"epss_score": 0.00525, "epss_percentile": 0.66392}, "CVE-2018-12559": {"epss_score": 0.00383, "epss_percentile": 0.59079}, "CVE-2018-12560": {"epss_score": 0.00253, "epss_percentile": 0.48437}, "CVE-2018-12561": {"epss_score": 0.00348, "epss_percentile": 0.5684}, "CVE-2018-12562": {"epss_score": 0.00376, "epss_percentile": 0.58663}, "CVE-2018-12563": {"epss_score": 0.00259, "epss_percentile": 0.49064}, "CVE-2018-12564": {"epss_score": 0.00308, "epss_percentile": 0.53603}, "CVE-2018-12565": {"epss_score": 0.025, "epss_percentile": 0.84919}, "CVE-2018-12571": {"epss_score": 0.11925, "epss_percentile": 0.93517}, "CVE-2018-12572": {"epss_score": 0.00034, "epss_percentile": 0.09697}, "CVE-2018-12574": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2018-12575": {"epss_score": 0.00764, "epss_percentile": 0.72903}, "CVE-2018-12576": {"epss_score": 0.00278, "epss_percentile": 0.50875}, "CVE-2018-12577": {"epss_score": 0.03121, "epss_percentile": 0.8645}, "CVE-2018-12578": {"epss_score": 0.00342, "epss_percentile": 0.56371}, "CVE-2018-12579": {"epss_score": 0.0042, "epss_percentile": 0.6141}, "CVE-2018-12580": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-12581": {"epss_score": 0.00815, "epss_percentile": 0.73786}, "CVE-2018-12582": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2018-12583": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2018-12584": {"epss_score": 0.2838, "epss_percentile": 0.96348}, "CVE-2018-12585": {"epss_score": 0.0062, "epss_percentile": 0.69442}, "CVE-2018-12587": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2018-12588": {"epss_score": 0.00412, "epss_percentile": 0.60934}, "CVE-2018-12589": {"epss_score": 0.02437, "epss_percentile": 0.84742}, "CVE-2018-12590": {"epss_score": 0.00508, "epss_percentile": 0.65682}, "CVE-2018-12591": {"epss_score": 0.006, "epss_percentile": 0.68828}, "CVE-2018-12592": {"epss_score": 0.00307, "epss_percentile": 0.53484}, "CVE-2018-12594": {"epss_score": 0.00302, "epss_percentile": 0.53134}, "CVE-2018-12596": {"epss_score": 0.47919, "epss_percentile": 0.97609}, "CVE-2018-12599": {"epss_score": 0.00329, "epss_percentile": 0.55385}, "CVE-2018-12600": {"epss_score": 0.00329, "epss_percentile": 0.55385}, "CVE-2018-12601": {"epss_score": 0.00496, "epss_percentile": 0.65151}, "CVE-2018-12602": {"epss_score": 0.00276, "epss_percentile": 0.50737}, "CVE-2018-12603": {"epss_score": 0.00446, "epss_percentile": 0.6293}, "CVE-2018-12604": {"epss_score": 0.1868, "epss_percentile": 0.95052}, "CVE-2018-12605": {"epss_score": 0.00064, "epss_percentile": 0.20104}, "CVE-2018-12606": {"epss_score": 0.0005, "epss_percentile": 0.15952}, "CVE-2018-12607": {"epss_score": 0.00055, "epss_percentile": 0.17533}, "CVE-2018-12608": {"epss_score": 0.0045, "epss_percentile": 0.63073}, "CVE-2018-12609": {"epss_score": 0.00364, "epss_percentile": 0.57954}, "CVE-2018-12610": {"epss_score": 0.00281, "epss_percentile": 0.51122}, "CVE-2018-12611": {"epss_score": 0.0047, "epss_percentile": 0.63966}, "CVE-2018-12613": {"epss_score": 0.94294, "epss_percentile": 0.99937}, "CVE-2018-12615": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2018-12617": {"epss_score": 0.10988, "epss_percentile": 0.93183}, "CVE-2018-12621": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2018-12622": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12623": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12624": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12625": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12626": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12627": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12628": {"epss_score": 0.00305, "epss_percentile": 0.53355}, "CVE-2018-12630": {"epss_score": 0.00238, "epss_percentile": 0.46759}, "CVE-2018-12631": {"epss_score": 0.02681, "epss_percentile": 0.85417}, "CVE-2018-12632": {"epss_score": 0.00206, "epss_percentile": 0.42936}, "CVE-2018-12633": {"epss_score": 0.00025, "epss_percentile": 0.06044}, "CVE-2018-12634": {"epss_score": 0.92847, "epss_percentile": 0.99754}, "CVE-2018-12635": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12636": {"epss_score": 0.47276, "epss_percentile": 0.9758}, "CVE-2018-12638": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-12640": {"epss_score": 0.00436, "epss_percentile": 0.62455}, "CVE-2018-12641": {"epss_score": 0.00716, "epss_percentile": 0.71868}, "CVE-2018-12642": {"epss_score": 0.00265, "epss_percentile": 0.49837}, "CVE-2018-12648": {"epss_score": 0.00415, "epss_percentile": 0.61139}, "CVE-2018-12649": {"epss_score": 0.0029, "epss_percentile": 0.52084}, "CVE-2018-12650": {"epss_score": 0.00545, "epss_percentile": 0.67159}, "CVE-2018-12651": {"epss_score": 0.00226, "epss_percentile": 0.45249}, "CVE-2018-12652": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12653": {"epss_score": 0.00545, "epss_percentile": 0.67159}, "CVE-2018-12654": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12655": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12656": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12657": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12658": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12659": {"epss_score": 0.00101, "epss_percentile": 0.28629}, "CVE-2018-12666": {"epss_score": 0.01104, "epss_percentile": 0.77602}, "CVE-2018-12667": {"epss_score": 0.00764, "epss_percentile": 0.72903}, "CVE-2018-12668": {"epss_score": 0.00795, "epss_percentile": 0.73468}, "CVE-2018-12669": {"epss_score": 0.00708, "epss_percentile": 0.71677}, "CVE-2018-12670": {"epss_score": 0.12488, "epss_percentile": 0.93689}, "CVE-2018-12671": {"epss_score": 0.00353, "epss_percentile": 0.57182}, "CVE-2018-12672": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-12673": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-12674": {"epss_score": 0.00048, "epss_percentile": 0.14969}, "CVE-2018-12675": {"epss_score": 0.08842, "epss_percentile": 0.92281}, "CVE-2018-12678": {"epss_score": 0.00345, "epss_percentile": 0.56582}, "CVE-2018-12679": {"epss_score": 0.00372, "epss_percentile": 0.58454}, "CVE-2018-12680": {"epss_score": 0.00175, "epss_percentile": 0.39352}, "CVE-2018-12684": {"epss_score": 0.00189, "epss_percentile": 0.40928}, "CVE-2018-12687": {"epss_score": 0.00366, "epss_percentile": 0.58025}, "CVE-2018-12688": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2018-12689": {"epss_score": 0.00427, "epss_percentile": 0.61885}, "CVE-2018-12691": {"epss_score": 0.00183, "epss_percentile": 0.40326}, "CVE-2018-12692": {"epss_score": 0.07132, "epss_percentile": 0.91271}, "CVE-2018-12693": {"epss_score": 0.01149, "epss_percentile": 0.78019}, "CVE-2018-12694": {"epss_score": 0.00828, "epss_percentile": 0.7399}, "CVE-2018-12695": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12696": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12697": {"epss_score": 0.01561, "epss_percentile": 0.81042}, "CVE-2018-12698": {"epss_score": 0.01455, "epss_percentile": 0.8039}, "CVE-2018-12699": {"epss_score": 0.00504, "epss_percentile": 0.65524}, "CVE-2018-12702": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12703": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12705": {"epss_score": 0.00364, "epss_percentile": 0.57952}, "CVE-2018-12706": {"epss_score": 0.19133, "epss_percentile": 0.95137}, "CVE-2018-12710": {"epss_score": 0.59492, "epss_percentile": 0.98167}, "CVE-2018-12711": {"epss_score": 0.01238, "epss_percentile": 0.78787}, "CVE-2018-12712": {"epss_score": 0.01585, "epss_percentile": 0.81167}, "CVE-2018-12713": {"epss_score": 0.0032, "epss_percentile": 0.54601}, "CVE-2018-12714": {"epss_score": 0.01143, "epss_percentile": 0.77982}, "CVE-2018-12715": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-12716": {"epss_score": 0.00194, "epss_percentile": 0.41564}, "CVE-2018-12735": {"epss_score": 0.00333, "epss_percentile": 0.55617}, "CVE-2018-12739": {"epss_score": 0.00249, "epss_percentile": 0.48059}, "CVE-2018-12754": {"epss_score": 0.23877, "epss_percentile": 0.95829}, "CVE-2018-12755": {"epss_score": 0.23877, "epss_percentile": 0.95829}, "CVE-2018-12756": {"epss_score": 0.03711, "epss_percentile": 0.87609}, "CVE-2018-12757": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-12758": {"epss_score": 0.06343, "epss_percentile": 0.90684}, "CVE-2018-12759": {"epss_score": 0.01535, "epss_percentile": 0.8091}, "CVE-2018-12760": {"epss_score": 0.06343, "epss_percentile": 0.90684}, "CVE-2018-12761": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-12762": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-12763": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-12764": {"epss_score": 0.23856, "epss_percentile": 0.95825}, "CVE-2018-12765": {"epss_score": 0.23856, "epss_percentile": 0.95825}, "CVE-2018-12766": {"epss_score": 0.23856, "epss_percentile": 0.95825}, "CVE-2018-12767": {"epss_score": 0.23856, "epss_percentile": 0.95825}, "CVE-2018-12768": {"epss_score": 0.23856, "epss_percentile": 0.95825}, "CVE-2018-12769": {"epss_score": 0.01691, "epss_percentile": 0.81777}, "CVE-2018-12770": {"epss_score": 0.09436, "epss_percentile": 0.92546}, "CVE-2018-12771": {"epss_score": 0.08358, "epss_percentile": 0.92008}, "CVE-2018-12772": {"epss_score": 0.09436, "epss_percentile": 0.92546}, "CVE-2018-12773": {"epss_score": 0.09436, "epss_percentile": 0.92546}, "CVE-2018-12774": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-12775": {"epss_score": 0.02199, "epss_percentile": 0.83972}, "CVE-2018-12776": {"epss_score": 0.09436, "epss_percentile": 0.92546}, "CVE-2018-12777": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-12778": {"epss_score": 0.02199, "epss_percentile": 0.83972}, "CVE-2018-12779": {"epss_score": 0.02199, "epss_percentile": 0.83972}, "CVE-2018-12780": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-12781": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-12782": {"epss_score": 0.25572, "epss_percentile": 0.96046}, "CVE-2018-12783": {"epss_score": 0.09436, "epss_percentile": 0.92546}, "CVE-2018-12784": {"epss_score": 0.22866, "epss_percentile": 0.95701}, "CVE-2018-12785": {"epss_score": 0.15497, "epss_percentile": 0.94439}, "CVE-2018-12786": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-12787": {"epss_score": 0.06343, "epss_percentile": 0.90684}, "CVE-2018-12788": {"epss_score": 0.13655, "epss_percentile": 0.94027}, "CVE-2018-12789": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-12790": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-12791": {"epss_score": 0.05931, "epss_percentile": 0.90337}, "CVE-2018-12792": {"epss_score": 0.05931, "epss_percentile": 0.90337}, "CVE-2018-12793": {"epss_score": 0.09858, "epss_percentile": 0.92739}, "CVE-2018-12794": {"epss_score": 0.28071, "epss_percentile": 0.96306}, "CVE-2018-12795": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-12796": {"epss_score": 0.04557, "epss_percentile": 0.88849}, "CVE-2018-12797": {"epss_score": 0.04557, "epss_percentile": 0.88849}, "CVE-2018-12798": {"epss_score": 0.24682, "epss_percentile": 0.95946}, "CVE-2018-12799": {"epss_score": 0.03227, "epss_percentile": 0.86689}, "CVE-2018-12801": {"epss_score": 0.02199, "epss_percentile": 0.83972}, "CVE-2018-12802": {"epss_score": 0.08376, "epss_percentile": 0.92017}, "CVE-2018-12803": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-12804": {"epss_score": 0.00637, "epss_percentile": 0.69883}, "CVE-2018-12805": {"epss_score": 0.01988, "epss_percentile": 0.83165}, "CVE-2018-12806": {"epss_score": 0.01386, "epss_percentile": 0.79913}, "CVE-2018-12807": {"epss_score": 0.04987, "epss_percentile": 0.89365}, "CVE-2018-12808": {"epss_score": 0.02246, "epss_percentile": 0.8413}, "CVE-2018-12809": {"epss_score": 0.02001, "epss_percentile": 0.83219}, "CVE-2018-12810": {"epss_score": 0.16853, "epss_percentile": 0.94738}, "CVE-2018-12811": {"epss_score": 0.16853, "epss_percentile": 0.94738}, "CVE-2018-12812": {"epss_score": 0.07646, "epss_percentile": 0.91599}, "CVE-2018-12813": {"epss_score": 0.21792, "epss_percentile": 0.95562}, "CVE-2018-12814": {"epss_score": 0.21792, "epss_percentile": 0.95562}, "CVE-2018-12815": {"epss_score": 0.02441, "epss_percentile": 0.84755}, "CVE-2018-12816": {"epss_score": 0.03634, "epss_percentile": 0.8748}, "CVE-2018-12817": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2018-12818": {"epss_score": 0.03634, "epss_percentile": 0.8748}, "CVE-2018-12819": {"epss_score": 0.03634, "epss_percentile": 0.8748}, "CVE-2018-12820": {"epss_score": 0.03634, "epss_percentile": 0.8748}, "CVE-2018-12821": {"epss_score": 0.03634, "epss_percentile": 0.8748}, "CVE-2018-12822": {"epss_score": 0.02308, "epss_percentile": 0.84329}, "CVE-2018-12823": {"epss_score": 0.27342, "epss_percentile": 0.96238}, "CVE-2018-12824": {"epss_score": 0.02076, "epss_percentile": 0.83508}, "CVE-2018-12825": {"epss_score": 0.01348, "epss_percentile": 0.79663}, "CVE-2018-12826": {"epss_score": 0.02076, "epss_percentile": 0.83508}, "CVE-2018-12827": {"epss_score": 0.08652, "epss_percentile": 0.92173}, "CVE-2018-12828": {"epss_score": 0.01549, "epss_percentile": 0.80981}, "CVE-2018-12829": {"epss_score": 0.01546, "epss_percentile": 0.80969}, "CVE-2018-12830": {"epss_score": 0.03375, "epss_percentile": 0.87017}, "CVE-2018-12831": {"epss_score": 0.03453, "epss_percentile": 0.87168}, "CVE-2018-12832": {"epss_score": 0.03224, "epss_percentile": 0.86681}, "CVE-2018-12833": {"epss_score": 0.03075, "epss_percentile": 0.86359}, "CVE-2018-12834": {"epss_score": 0.0183, "epss_percentile": 0.82444}, "CVE-2018-12835": {"epss_score": 0.03949, "epss_percentile": 0.87998}, "CVE-2018-12836": {"epss_score": 0.03224, "epss_percentile": 0.86681}, "CVE-2018-12837": {"epss_score": 0.03224, "epss_percentile": 0.86681}, "CVE-2018-12838": {"epss_score": 0.01265, "epss_percentile": 0.79003}, "CVE-2018-12839": {"epss_score": 0.16463, "epss_percentile": 0.94673}, "CVE-2018-12840": {"epss_score": 0.17949, "epss_percentile": 0.94932}, "CVE-2018-12841": {"epss_score": 0.02857, "epss_percentile": 0.85842}, "CVE-2018-12842": {"epss_score": 0.0183, "epss_percentile": 0.82444}, "CVE-2018-12843": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-12844": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-12845": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-12846": {"epss_score": 0.04531, "epss_percentile": 0.88811}, "CVE-2018-12847": {"epss_score": 0.08448, "epss_percentile": 0.92056}, "CVE-2018-12848": {"epss_score": 0.18357, "epss_percentile": 0.95002}, "CVE-2018-12849": {"epss_score": 0.25292, "epss_percentile": 0.96009}, "CVE-2018-12850": {"epss_score": 0.25292, "epss_percentile": 0.96009}, "CVE-2018-12851": {"epss_score": 0.03224, "epss_percentile": 0.86681}, "CVE-2018-12852": {"epss_score": 0.02001, "epss_percentile": 0.83221}, "CVE-2018-12853": {"epss_score": 0.11466, "epss_percentile": 0.93375}, "CVE-2018-12855": {"epss_score": 0.03371, "epss_percentile": 0.87012}, "CVE-2018-12856": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-12857": {"epss_score": 0.25364, "epss_percentile": 0.96021}, "CVE-2018-12858": {"epss_score": 0.04648, "epss_percentile": 0.88963}, "CVE-2018-12859": {"epss_score": 0.16463, "epss_percentile": 0.94673}, "CVE-2018-12860": {"epss_score": 0.32809, "epss_percentile": 0.96729}, "CVE-2018-12861": {"epss_score": 0.23883, "epss_percentile": 0.9583}, "CVE-2018-12862": {"epss_score": 0.32809, "epss_percentile": 0.96729}, "CVE-2018-12863": {"epss_score": 0.21484, "epss_percentile": 0.95524}, "CVE-2018-12864": {"epss_score": 0.23883, "epss_percentile": 0.9583}, "CVE-2018-12865": {"epss_score": 0.23883, "epss_percentile": 0.9583}, "CVE-2018-12866": {"epss_score": 0.25364, "epss_percentile": 0.96021}, "CVE-2018-12867": {"epss_score": 0.16463, "epss_percentile": 0.94673}, "CVE-2018-12868": {"epss_score": 0.01535, "epss_percentile": 0.8091}, "CVE-2018-12869": {"epss_score": 0.16463, "epss_percentile": 0.94673}, "CVE-2018-12870": {"epss_score": 0.16463, "epss_percentile": 0.94673}, "CVE-2018-12871": {"epss_score": 0.16463, "epss_percentile": 0.94673}, "CVE-2018-12872": {"epss_score": 0.16463, "epss_percentile": 0.94673}, "CVE-2018-12873": {"epss_score": 0.25364, "epss_percentile": 0.96021}, "CVE-2018-12874": {"epss_score": 0.25364, "epss_percentile": 0.96021}, "CVE-2018-12875": {"epss_score": 0.25364, "epss_percentile": 0.96021}, "CVE-2018-12876": {"epss_score": 0.04648, "epss_percentile": 0.88963}, "CVE-2018-12877": {"epss_score": 0.0246, "epss_percentile": 0.84823}, "CVE-2018-12878": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-12879": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-12880": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-12881": {"epss_score": 0.0167, "epss_percentile": 0.81668}, "CVE-2018-12882": {"epss_score": 0.05973, "epss_percentile": 0.90374}, "CVE-2018-12884": {"epss_score": 0.00146, "epss_percentile": 0.35586}, "CVE-2018-12885": {"epss_score": 0.0045, "epss_percentile": 0.63104}, "CVE-2018-12886": {"epss_score": 0.00171, "epss_percentile": 0.38837}, "CVE-2018-12889": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2018-12891": {"epss_score": 0.00073, "epss_percentile": 0.22556}, "CVE-2018-12892": {"epss_score": 0.02916, "epss_percentile": 0.85979}, "CVE-2018-12893": {"epss_score": 0.00071, "epss_percentile": 0.21997}, "CVE-2018-12895": {"epss_score": 0.88902, "epss_percentile": 0.99498}, "CVE-2018-12896": {"epss_score": 0.00033, "epss_percentile": 0.09194}, "CVE-2018-12897": {"epss_score": 0.00599, "epss_percentile": 0.68791}, "CVE-2018-12900": {"epss_score": 0.10812, "epss_percentile": 0.93119}, "CVE-2018-12901": {"epss_score": 0.00255, "epss_percentile": 0.48663}, "CVE-2018-12902": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12903": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-12904": {"epss_score": 0.00182, "epss_percentile": 0.40272}, "CVE-2018-12905": {"epss_score": 0.02037, "epss_percentile": 0.83357}, "CVE-2018-12907": {"epss_score": 0.00333, "epss_percentile": 0.55681}, "CVE-2018-12908": {"epss_score": 0.20688, "epss_percentile": 0.95402}, "CVE-2018-12909": {"epss_score": 0.88176, "epss_percentile": 0.99461}, "CVE-2018-12910": {"epss_score": 0.08216, "epss_percentile": 0.91934}, "CVE-2018-12911": {"epss_score": 0.00521, "epss_percentile": 0.66236}, "CVE-2018-12912": {"epss_score": 0.01873, "epss_percentile": 0.82643}, "CVE-2018-12913": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2018-12914": {"epss_score": 0.02493, "epss_percentile": 0.84902}, "CVE-2018-12915": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2018-12916": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2018-12917": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2018-12918": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2018-12919": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-12920": {"epss_score": 0.0033, "epss_percentile": 0.55493}, "CVE-2018-12921": {"epss_score": 0.00333, "epss_percentile": 0.55617}, "CVE-2018-12922": {"epss_score": 0.00345, "epss_percentile": 0.56579}, "CVE-2018-12923": {"epss_score": 0.0033, "epss_percentile": 0.55493}, "CVE-2018-12924": {"epss_score": 0.00299, "epss_percentile": 0.52886}, "CVE-2018-12925": {"epss_score": 0.00299, "epss_percentile": 0.52886}, "CVE-2018-12926": {"epss_score": 0.00333, "epss_percentile": 0.55617}, "CVE-2018-12927": {"epss_score": 0.00333, "epss_percentile": 0.55617}, "CVE-2018-12928": {"epss_score": 0.00094, "epss_percentile": 0.2699}, "CVE-2018-12929": {"epss_score": 0.0012, "epss_percentile": 0.31782}, "CVE-2018-12930": {"epss_score": 0.00113, "epss_percentile": 0.30714}, "CVE-2018-12931": {"epss_score": 0.00113, "epss_percentile": 0.30714}, "CVE-2018-12932": {"epss_score": 0.00474, "epss_percentile": 0.64111}, "CVE-2018-12933": {"epss_score": 0.00487, "epss_percentile": 0.64814}, "CVE-2018-12934": {"epss_score": 0.007, "epss_percentile": 0.71484}, "CVE-2018-12939": {"epss_score": 0.006, "epss_percentile": 0.68812}, "CVE-2018-12940": {"epss_score": 0.01893, "epss_percentile": 0.82739}, "CVE-2018-12941": {"epss_score": 0.02076, "epss_percentile": 0.83509}, "CVE-2018-12942": {"epss_score": 0.00226, "epss_percentile": 0.45238}, "CVE-2018-12943": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2018-12944": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2018-12959": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-12971": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2018-12972": {"epss_score": 0.0073, "epss_percentile": 0.7215}, "CVE-2018-12973": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-12975": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2018-12976": {"epss_score": 0.02804, "epss_percentile": 0.85704}, "CVE-2018-12977": {"epss_score": 0.00468, "epss_percentile": 0.63893}, "CVE-2018-12979": {"epss_score": 0.04881, "epss_percentile": 0.89247}, "CVE-2018-12980": {"epss_score": 0.21305, "epss_percentile": 0.95498}, "CVE-2018-12981": {"epss_score": 0.02155, "epss_percentile": 0.83807}, "CVE-2018-12982": {"epss_score": 0.00374, "epss_percentile": 0.58583}, "CVE-2018-12983": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2018-12984": {"epss_score": 0.05119, "epss_percentile": 0.89517}, "CVE-2018-12988": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-12989": {"epss_score": 0.00032, "epss_percentile": 0.09035}, "CVE-2018-12990": {"epss_score": 0.00244, "epss_percentile": 0.47619}, "CVE-2018-12992": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-12993": {"epss_score": 0.00518, "epss_percentile": 0.66093}, "CVE-2018-12994": {"epss_score": 0.00475, "epss_percentile": 0.64183}, "CVE-2018-12995": {"epss_score": 0.00475, "epss_percentile": 0.64183}, "CVE-2018-12996": {"epss_score": 0.01451, "epss_percentile": 0.80358}, "CVE-2018-12997": {"epss_score": 0.03686, "epss_percentile": 0.8757}, "CVE-2018-12998": {"epss_score": 0.47663, "epss_percentile": 0.97595}, "CVE-2018-12999": {"epss_score": 0.09656, "epss_percentile": 0.92642}, "CVE-2018-13000": {"epss_score": 0.00361, "epss_percentile": 0.57698}, "CVE-2018-13001": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-13002": {"epss_score": 0.00332, "epss_percentile": 0.55584}, "CVE-2018-13003": {"epss_score": 0.0017, "epss_percentile": 0.38747}, "CVE-2018-13005": {"epss_score": 0.00596, "epss_percentile": 0.68713}, "CVE-2018-13006": {"epss_score": 0.00701, "epss_percentile": 0.71492}, "CVE-2018-13007": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-13008": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-13009": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-13010": {"epss_score": 0.00175, "epss_percentile": 0.3935}, "CVE-2018-13011": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-13012": {"epss_score": 0.00275, "epss_percentile": 0.5069}, "CVE-2018-13013": {"epss_score": 0.00029, "epss_percentile": 0.07972}, "CVE-2018-13014": {"epss_score": 0.00042, "epss_percentile": 0.12714}, "CVE-2018-13021": {"epss_score": 0.01438, "epss_percentile": 0.80288}, "CVE-2018-13022": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13023": {"epss_score": 0.2042, "epss_percentile": 0.95341}, "CVE-2018-13024": {"epss_score": 0.00787, "epss_percentile": 0.7332}, "CVE-2018-13025": {"epss_score": 0.00263, "epss_percentile": 0.49501}, "CVE-2018-13026": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2018-13030": {"epss_score": 0.00314, "epss_percentile": 0.54104}, "CVE-2018-13031": {"epss_score": 0.00227, "epss_percentile": 0.45418}, "CVE-2018-13032": {"epss_score": 0.00269, "epss_percentile": 0.5019}, "CVE-2018-13033": {"epss_score": 0.01475, "epss_percentile": 0.80529}, "CVE-2018-13034": {"epss_score": 0.00166, "epss_percentile": 0.38161}, "CVE-2018-13037": {"epss_score": 0.00314, "epss_percentile": 0.54104}, "CVE-2018-13038": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-13039": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13040": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-13041": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13042": {"epss_score": 0.10158, "epss_percentile": 0.92869}, "CVE-2018-13043": {"epss_score": 0.01277, "epss_percentile": 0.79113}, "CVE-2018-13045": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-13049": {"epss_score": 0.00281, "epss_percentile": 0.51128}, "CVE-2018-13050": {"epss_score": 0.00744, "epss_percentile": 0.72507}, "CVE-2018-13052": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-13053": {"epss_score": 0.0003, "epss_percentile": 0.0803}, "CVE-2018-13054": {"epss_score": 0.00251, "epss_percentile": 0.48305}, "CVE-2018-13055": {"epss_score": 0.00349, "epss_percentile": 0.56893}, "CVE-2018-13056": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13060": {"epss_score": 0.00315, "epss_percentile": 0.54193}, "CVE-2018-13063": {"epss_score": 0.0036, "epss_percentile": 0.57649}, "CVE-2018-13065": {"epss_score": 0.00284, "epss_percentile": 0.51471}, "CVE-2018-13066": {"epss_score": 0.00381, "epss_percentile": 0.58999}, "CVE-2018-13067": {"epss_score": 0.00555, "epss_percentile": 0.67469}, "CVE-2018-13068": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13069": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13070": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13071": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13072": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13073": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13074": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13075": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-13076": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13077": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13078": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13079": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13080": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13081": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13082": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13083": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13084": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13085": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13086": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13087": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13088": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13089": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13090": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13091": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13092": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13093": {"epss_score": 0.00136, "epss_percentile": 0.3417}, "CVE-2018-13094": {"epss_score": 0.00266, "epss_percentile": 0.4988}, "CVE-2018-13095": {"epss_score": 0.00301, "epss_percentile": 0.53003}, "CVE-2018-13096": {"epss_score": 0.00574, "epss_percentile": 0.68068}, "CVE-2018-13097": {"epss_score": 0.00216, "epss_percentile": 0.44206}, "CVE-2018-13098": {"epss_score": 0.00322, "epss_percentile": 0.54819}, "CVE-2018-13099": {"epss_score": 0.01605, "epss_percentile": 0.81293}, "CVE-2018-13100": {"epss_score": 0.00294, "epss_percentile": 0.52406}, "CVE-2018-13101": {"epss_score": 0.00733, "epss_percentile": 0.72206}, "CVE-2018-13102": {"epss_score": 0.00256, "epss_percentile": 0.48739}, "CVE-2018-13103": {"epss_score": 0.00212, "epss_percentile": 0.43818}, "CVE-2018-13104": {"epss_score": 0.00195, "epss_percentile": 0.41621}, "CVE-2018-13106": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-13108": {"epss_score": 0.00577, "epss_percentile": 0.68172}, "CVE-2018-13109": {"epss_score": 0.05545, "epss_percentile": 0.89982}, "CVE-2018-13110": {"epss_score": 0.08156, "epss_percentile": 0.91907}, "CVE-2018-13111": {"epss_score": 0.00415, "epss_percentile": 0.61145}, "CVE-2018-13112": {"epss_score": 0.00664, "epss_percentile": 0.70639}, "CVE-2018-13113": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-13114": {"epss_score": 0.02135, "epss_percentile": 0.83725}, "CVE-2018-13115": {"epss_score": 0.00217, "epss_percentile": 0.44256}, "CVE-2018-13116": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-13121": {"epss_score": 0.00245, "epss_percentile": 0.47695}, "CVE-2018-13122": {"epss_score": 0.00111, "epss_percentile": 0.30337}, "CVE-2018-13123": {"epss_score": 0.00345, "epss_percentile": 0.56564}, "CVE-2018-13126": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13127": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13128": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13129": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13130": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13131": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13132": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13133": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2018-13134": {"epss_score": 0.00364, "epss_percentile": 0.57952}, "CVE-2018-13136": {"epss_score": 0.00347, "epss_percentile": 0.5676}, "CVE-2018-13137": {"epss_score": 0.00505, "epss_percentile": 0.65599}, "CVE-2018-13139": {"epss_score": 0.01753, "epss_percentile": 0.8211}, "CVE-2018-13140": {"epss_score": 0.0919, "epss_percentile": 0.9244}, "CVE-2018-13144": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-13145": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13146": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13153": {"epss_score": 0.00151, "epss_percentile": 0.36193}, "CVE-2018-13155": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13156": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13157": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13158": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13159": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13160": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-13161": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13162": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13163": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13164": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13165": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13166": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13167": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13168": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13169": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13170": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13171": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13172": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13173": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13174": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13175": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13176": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13177": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13178": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13179": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13180": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13181": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13182": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13183": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13184": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13185": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13186": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13187": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13188": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13189": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13190": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13191": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13192": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13193": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13194": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13195": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13196": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13197": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13198": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13199": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13200": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13201": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-13202": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13203": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13204": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13205": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13206": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13207": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13208": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13209": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13210": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13211": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13212": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13213": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13214": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13215": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13216": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13217": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13218": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13219": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13220": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13221": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13222": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13223": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13224": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13225": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13226": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13227": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13228": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13229": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13230": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13231": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13232": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13233": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13250": {"epss_score": 0.0036, "epss_percentile": 0.5765}, "CVE-2018-13251": {"epss_score": 0.00359, "epss_percentile": 0.57551}, "CVE-2018-13252": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13256": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-13257": {"epss_score": 0.02839, "epss_percentile": 0.85797}, "CVE-2018-13258": {"epss_score": 0.00136, "epss_percentile": 0.3409}, "CVE-2018-13259": {"epss_score": 0.01175, "epss_percentile": 0.78261}, "CVE-2018-13280": {"epss_score": 0.00167, "epss_percentile": 0.38401}, "CVE-2018-13281": {"epss_score": 0.00133, "epss_percentile": 0.33704}, "CVE-2018-13282": {"epss_score": 0.00276, "epss_percentile": 0.50766}, "CVE-2018-13283": {"epss_score": 0.00298, "epss_percentile": 0.52809}, "CVE-2018-13284": {"epss_score": 0.00711, "epss_percentile": 0.71732}, "CVE-2018-13285": {"epss_score": 0.0089, "epss_percentile": 0.75025}, "CVE-2018-13286": {"epss_score": 0.00217, "epss_percentile": 0.44293}, "CVE-2018-13287": {"epss_score": 0.00279, "epss_percentile": 0.50992}, "CVE-2018-13288": {"epss_score": 0.00362, "epss_percentile": 0.57818}, "CVE-2018-13289": {"epss_score": 0.00454, "epss_percentile": 0.63243}, "CVE-2018-13290": {"epss_score": 0.00311, "epss_percentile": 0.53812}, "CVE-2018-13291": {"epss_score": 0.00241, "epss_percentile": 0.47298}, "CVE-2018-13292": {"epss_score": 0.00311, "epss_percentile": 0.53812}, "CVE-2018-13293": {"epss_score": 0.00185, "epss_percentile": 0.40463}, "CVE-2018-13294": {"epss_score": 0.00312, "epss_percentile": 0.53955}, "CVE-2018-13295": {"epss_score": 0.00312, "epss_percentile": 0.53955}, "CVE-2018-13296": {"epss_score": 0.00705, "epss_percentile": 0.71575}, "CVE-2018-13297": {"epss_score": 0.00362, "epss_percentile": 0.57818}, "CVE-2018-13298": {"epss_score": 0.0023, "epss_percentile": 0.45678}, "CVE-2018-13299": {"epss_score": 0.00221, "epss_percentile": 0.44632}, "CVE-2018-13300": {"epss_score": 0.00699, "epss_percentile": 0.71454}, "CVE-2018-13301": {"epss_score": 0.00434, "epss_percentile": 0.62314}, "CVE-2018-13302": {"epss_score": 0.0064, "epss_percentile": 0.69976}, "CVE-2018-13303": {"epss_score": 0.00434, "epss_percentile": 0.62314}, "CVE-2018-13304": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2018-13305": {"epss_score": 0.00425, "epss_percentile": 0.6171}, "CVE-2018-13306": {"epss_score": 0.15297, "epss_percentile": 0.94405}, "CVE-2018-13307": {"epss_score": 0.15297, "epss_percentile": 0.94405}, "CVE-2018-13308": {"epss_score": 0.00212, "epss_percentile": 0.43787}, "CVE-2018-13309": {"epss_score": 0.00212, "epss_percentile": 0.43787}, "CVE-2018-13310": {"epss_score": 0.00212, "epss_percentile": 0.43787}, "CVE-2018-13311": {"epss_score": 0.06475, "epss_percentile": 0.90782}, "CVE-2018-13312": {"epss_score": 0.00212, "epss_percentile": 0.43787}, "CVE-2018-13313": {"epss_score": 0.00419, "epss_percentile": 0.61352}, "CVE-2018-13314": {"epss_score": 0.15297, "epss_percentile": 0.94405}, "CVE-2018-13315": {"epss_score": 0.00737, "epss_percentile": 0.72321}, "CVE-2018-13316": {"epss_score": 0.15297, "epss_percentile": 0.94405}, "CVE-2018-13317": {"epss_score": 0.00262, "epss_percentile": 0.494}, "CVE-2018-13318": {"epss_score": 0.09959, "epss_percentile": 0.92794}, "CVE-2018-13319": {"epss_score": 0.00491, "epss_percentile": 0.64967}, "CVE-2018-13320": {"epss_score": 0.09959, "epss_percentile": 0.92794}, "CVE-2018-13321": {"epss_score": 0.00377, "epss_percentile": 0.58692}, "CVE-2018-13322": {"epss_score": 0.00485, "epss_percentile": 0.64727}, "CVE-2018-13323": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13324": {"epss_score": 0.01047, "epss_percentile": 0.7704}, "CVE-2018-13325": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13326": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13327": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13328": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13329": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13330": {"epss_score": 0.12645, "epss_percentile": 0.93738}, "CVE-2018-13331": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13332": {"epss_score": 0.00456, "epss_percentile": 0.63343}, "CVE-2018-13333": {"epss_score": 0.00181, "epss_percentile": 0.40114}, "CVE-2018-13334": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13335": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-13336": {"epss_score": 0.12488, "epss_percentile": 0.93689}, "CVE-2018-13337": {"epss_score": 0.00199, "epss_percentile": 0.42149}, "CVE-2018-13338": {"epss_score": 0.12488, "epss_percentile": 0.93689}, "CVE-2018-13339": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-13340": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2018-13341": {"epss_score": 0.02586, "epss_percentile": 0.85169}, "CVE-2018-13342": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2018-13346": {"epss_score": 0.00349, "epss_percentile": 0.56874}, "CVE-2018-13347": {"epss_score": 0.0122, "epss_percentile": 0.78623}, "CVE-2018-13348": {"epss_score": 0.00613, "epss_percentile": 0.6925}, "CVE-2018-13349": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13350": {"epss_score": 0.01913, "epss_percentile": 0.82837}, "CVE-2018-13351": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-13352": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-13353": {"epss_score": 0.16269, "epss_percentile": 0.94607}, "CVE-2018-13354": {"epss_score": 0.16211, "epss_percentile": 0.94595}, "CVE-2018-13355": {"epss_score": 0.00146, "epss_percentile": 0.35554}, "CVE-2018-13356": {"epss_score": 0.00484, "epss_percentile": 0.6463}, "CVE-2018-13357": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-13358": {"epss_score": 0.15585, "epss_percentile": 0.94465}, "CVE-2018-13359": {"epss_score": 0.02581, "epss_percentile": 0.85153}, "CVE-2018-13360": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13361": {"epss_score": 0.01637, "epss_percentile": 0.81481}, "CVE-2018-13365": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2018-13366": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2018-13367": {"epss_score": 0.00445, "epss_percentile": 0.62871}, "CVE-2018-13368": {"epss_score": 0.00108, "epss_percentile": 0.2983}, "CVE-2018-13371": {"epss_score": 0.00526, "epss_percentile": 0.66436}, "CVE-2018-13374": {"epss_score": 0.02355, "epss_percentile": 0.84481}, "CVE-2018-13375": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-13376": {"epss_score": 0.01062, "epss_percentile": 0.77186}, "CVE-2018-13378": {"epss_score": 0.0034, "epss_percentile": 0.56272}, "CVE-2018-13379": {"epss_score": 0.94475, "epss_percentile": 0.99998}, "CVE-2018-13380": {"epss_score": 0.34498, "epss_percentile": 0.9685}, "CVE-2018-13381": {"epss_score": 0.00537, "epss_percentile": 0.66895}, "CVE-2018-13382": {"epss_score": 0.87043, "epss_percentile": 0.9941}, "CVE-2018-13383": {"epss_score": 0.01315, "epss_percentile": 0.79402}, "CVE-2018-13384": {"epss_score": 0.00282, "epss_percentile": 0.51238}, "CVE-2018-13385": {"epss_score": 0.00452, "epss_percentile": 0.63169}, "CVE-2018-13386": {"epss_score": 0.00457, "epss_percentile": 0.63389}, "CVE-2018-13387": {"epss_score": 0.00191, "epss_percentile": 0.41185}, "CVE-2018-13388": {"epss_score": 0.00167, "epss_percentile": 0.38385}, "CVE-2018-13389": {"epss_score": 0.0016, "epss_percentile": 0.37439}, "CVE-2018-13390": {"epss_score": 0.00107, "epss_percentile": 0.29647}, "CVE-2018-13391": {"epss_score": 0.00155, "epss_percentile": 0.36822}, "CVE-2018-13392": {"epss_score": 0.00395, "epss_percentile": 0.59846}, "CVE-2018-13393": {"epss_score": 0.00154, "epss_percentile": 0.36677}, "CVE-2018-13394": {"epss_score": 0.0017, "epss_percentile": 0.38715}, "CVE-2018-13395": {"epss_score": 0.00231, "epss_percentile": 0.45828}, "CVE-2018-13396": {"epss_score": 0.01052, "epss_percentile": 0.77096}, "CVE-2018-13397": {"epss_score": 0.00954, "epss_percentile": 0.75894}, "CVE-2018-13398": {"epss_score": 0.00136, "epss_percentile": 0.34059}, "CVE-2018-13399": {"epss_score": 0.00023, "epss_percentile": 0.05621}, "CVE-2018-13400": {"epss_score": 0.00259, "epss_percentile": 0.49047}, "CVE-2018-13401": {"epss_score": 0.00087, "epss_percentile": 0.25466}, "CVE-2018-13402": {"epss_score": 0.00087, "epss_percentile": 0.25466}, "CVE-2018-13403": {"epss_score": 0.00173, "epss_percentile": 0.3906}, "CVE-2018-13404": {"epss_score": 0.00145, "epss_percentile": 0.35401}, "CVE-2018-13405": {"epss_score": 0.00165, "epss_percentile": 0.38085}, "CVE-2018-13406": {"epss_score": 0.0004, "epss_percentile": 0.11893}, "CVE-2018-13407": {"epss_score": 0.0015, "epss_percentile": 0.36152}, "CVE-2018-13408": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-13409": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-13410": {"epss_score": 0.08591, "epss_percentile": 0.92139}, "CVE-2018-13411": {"epss_score": 0.02802, "epss_percentile": 0.85699}, "CVE-2018-13412": {"epss_score": 0.00064, "epss_percentile": 0.20297}, "CVE-2018-13415": {"epss_score": 0.33361, "epss_percentile": 0.96766}, "CVE-2018-13416": {"epss_score": 0.56893, "epss_percentile": 0.9804}, "CVE-2018-13417": {"epss_score": 0.48503, "epss_percentile": 0.97641}, "CVE-2018-13418": {"epss_score": 0.1198, "epss_percentile": 0.93534}, "CVE-2018-13419": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2018-13420": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2018-13421": {"epss_score": 0.00468, "epss_percentile": 0.63913}, "CVE-2018-13422": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13423": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13433": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13434": {"epss_score": 0.00061, "epss_percentile": 0.19332}, "CVE-2018-13435": {"epss_score": 0.00061, "epss_percentile": 0.19332}, "CVE-2018-13439": {"epss_score": 0.00353, "epss_percentile": 0.57151}, "CVE-2018-13440": {"epss_score": 0.09117, "epss_percentile": 0.92407}, "CVE-2018-13441": {"epss_score": 0.00222, "epss_percentile": 0.44723}, "CVE-2018-13442": {"epss_score": 0.00709, "epss_percentile": 0.71692}, "CVE-2018-13443": {"epss_score": 0.00559, "epss_percentile": 0.67622}, "CVE-2018-13444": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-13445": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-13446": {"epss_score": 0.00061, "epss_percentile": 0.19332}, "CVE-2018-13447": {"epss_score": 0.00306, "epss_percentile": 0.53402}, "CVE-2018-13448": {"epss_score": 0.00306, "epss_percentile": 0.53402}, "CVE-2018-13449": {"epss_score": 0.00306, "epss_percentile": 0.53402}, "CVE-2018-13450": {"epss_score": 0.00361, "epss_percentile": 0.57695}, "CVE-2018-13457": {"epss_score": 0.00574, "epss_percentile": 0.68085}, "CVE-2018-13458": {"epss_score": 0.00574, "epss_percentile": 0.68085}, "CVE-2018-13462": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13463": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13464": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-13465": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13466": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13467": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13468": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13469": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13470": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13471": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13472": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13473": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13474": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13475": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13476": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13477": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13478": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13479": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13480": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13481": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13482": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13483": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13484": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13485": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13486": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13487": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13488": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13489": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13490": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13491": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13492": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-13493": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13494": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13495": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13496": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13497": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13498": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13499": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13500": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13501": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13502": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13503": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13504": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13505": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13506": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13507": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13508": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13509": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13510": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13511": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13512": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-13513": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13514": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13515": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13516": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13517": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13518": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13519": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13520": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13521": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13522": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13523": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13524": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13525": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13526": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13527": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13528": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13529": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13530": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13531": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13532": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13533": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13534": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13535": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13536": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13537": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13538": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13539": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13540": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13541": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13542": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13543": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13544": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13545": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13546": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13547": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13548": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13549": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13550": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13551": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13552": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13553": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13554": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13555": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13556": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13557": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13558": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13559": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13560": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13561": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13562": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13563": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13564": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13565": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13566": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13567": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13568": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13569": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13570": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13571": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13572": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13573": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13574": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13575": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13576": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13577": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13578": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13579": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13580": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13581": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13582": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13583": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13584": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13585": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13586": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13587": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13588": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13589": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13590": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13591": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13592": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13593": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13594": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13595": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13596": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13597": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13598": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13599": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13600": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13601": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13602": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-13603": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13604": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13605": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13606": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13607": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13608": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13609": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13610": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13611": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13612": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13613": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13614": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13615": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13616": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13617": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13618": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13619": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13620": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13621": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13622": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13623": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13624": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13625": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13626": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13627": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13628": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13629": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13630": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13631": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13632": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13633": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13634": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13635": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13636": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13637": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13638": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13639": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13640": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13641": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13642": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13643": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13644": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13645": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13646": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13647": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13648": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13649": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13650": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13651": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13652": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13653": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13654": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13655": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13656": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13657": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13658": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13659": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13660": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13661": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13662": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13663": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13664": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13665": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13666": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13667": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13668": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13669": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13670": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13671": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13672": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13673": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13674": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13675": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13676": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13677": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13678": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13679": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13680": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13681": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13682": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13683": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13684": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13685": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13686": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13687": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13688": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13689": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13690": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13691": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13692": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13693": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13694": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13695": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13696": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13697": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13698": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13699": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13700": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13701": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13702": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13703": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13704": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13705": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13706": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13707": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13708": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13709": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13710": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13711": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13712": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13713": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13714": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13715": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13716": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13717": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13718": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13719": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13720": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13721": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13722": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13723": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13724": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13725": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13726": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13727": {"epss_score": 0.00247, "epss_percentile": 0.47832}, "CVE-2018-13728": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13729": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13730": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13731": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13732": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13733": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13734": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13735": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13736": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13737": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13738": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13739": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13740": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13741": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13742": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13743": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13744": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13745": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-13746": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13747": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13748": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13749": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13750": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13751": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13752": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13753": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13754": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13755": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13756": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13757": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13758": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13759": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13760": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13761": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13762": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13763": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13764": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13765": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13766": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13767": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13768": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13769": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13770": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13771": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13772": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13773": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13774": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13775": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13776": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13777": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13778": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13779": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13780": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13781": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13782": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13783": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2018-13784": {"epss_score": 0.50647, "epss_percentile": 0.97743}, "CVE-2018-13785": {"epss_score": 0.02919, "epss_percentile": 0.85989}, "CVE-2018-13787": {"epss_score": 0.00159, "epss_percentile": 0.37388}, "CVE-2018-13789": {"epss_score": 0.00323, "epss_percentile": 0.54912}, "CVE-2018-13790": {"epss_score": 0.00353, "epss_percentile": 0.57173}, "CVE-2018-13791": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2018-13792": {"epss_score": 0.00348, "epss_percentile": 0.56834}, "CVE-2018-13793": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2018-13794": {"epss_score": 0.00496, "epss_percentile": 0.65171}, "CVE-2018-13795": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-13796": {"epss_score": 0.00478, "epss_percentile": 0.64404}, "CVE-2018-13797": {"epss_score": 0.11814, "epss_percentile": 0.93484}, "CVE-2018-13798": {"epss_score": 0.00653, "epss_percentile": 0.70321}, "CVE-2018-13799": {"epss_score": 0.00643, "epss_percentile": 0.7005}, "CVE-2018-13800": {"epss_score": 0.00191, "epss_percentile": 0.41165}, "CVE-2018-13801": {"epss_score": 0.00948, "epss_percentile": 0.75832}, "CVE-2018-13802": {"epss_score": 0.00844, "epss_percentile": 0.74273}, "CVE-2018-13804": {"epss_score": 0.03384, "epss_percentile": 0.87037}, "CVE-2018-13805": {"epss_score": 0.00495, "epss_percentile": 0.65112}, "CVE-2018-13806": {"epss_score": 0.00232, "epss_percentile": 0.45899}, "CVE-2018-13807": {"epss_score": 0.01153, "epss_percentile": 0.78059}, "CVE-2018-13808": {"epss_score": 0.00566, "epss_percentile": 0.67809}, "CVE-2018-13809": {"epss_score": 0.00311, "epss_percentile": 0.53925}, "CVE-2018-13810": {"epss_score": 0.00165, "epss_percentile": 0.3804}, "CVE-2018-13811": {"epss_score": 0.00028, "epss_percentile": 0.07226}, "CVE-2018-13812": {"epss_score": 0.07897, "epss_percentile": 0.91751}, "CVE-2018-13813": {"epss_score": 0.00255, "epss_percentile": 0.48654}, "CVE-2018-13814": {"epss_score": 0.00429, "epss_percentile": 0.61984}, "CVE-2018-13815": {"epss_score": 0.00451, "epss_percentile": 0.63118}, "CVE-2018-13816": {"epss_score": 0.02916, "epss_percentile": 0.85982}, "CVE-2018-13818": {"epss_score": 0.00565, "epss_percentile": 0.67781}, "CVE-2018-13819": {"epss_score": 0.00262, "epss_percentile": 0.4938}, "CVE-2018-13820": {"epss_score": 0.00262, "epss_percentile": 0.4938}, "CVE-2018-13821": {"epss_score": 0.05021, "epss_percentile": 0.89401}, "CVE-2018-13822": {"epss_score": 0.00262, "epss_percentile": 0.4938}, "CVE-2018-13823": {"epss_score": 0.00432, "epss_percentile": 0.62125}, "CVE-2018-13824": {"epss_score": 0.00706, "epss_percentile": 0.71612}, "CVE-2018-13825": {"epss_score": 0.00239, "epss_percentile": 0.46881}, "CVE-2018-13826": {"epss_score": 0.00397, "epss_percentile": 0.59982}, "CVE-2018-13832": {"epss_score": 0.00172, "epss_percentile": 0.38926}, "CVE-2018-13833": {"epss_score": 0.00314, "epss_percentile": 0.54104}, "CVE-2018-13836": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-13843": {"epss_score": 0.00366, "epss_percentile": 0.58025}, "CVE-2018-13844": {"epss_score": 0.00366, "epss_percentile": 0.58025}, "CVE-2018-13845": {"epss_score": 0.0046, "epss_percentile": 0.63517}, "CVE-2018-13846": {"epss_score": 0.00474, "epss_percentile": 0.64142}, "CVE-2018-13847": {"epss_score": 0.00366, "epss_percentile": 0.58025}, "CVE-2018-13848": {"epss_score": 0.00366, "epss_percentile": 0.58025}, "CVE-2018-13849": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-13850": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-13858": {"epss_score": 0.01589, "epss_percentile": 0.81193}, "CVE-2018-13859": {"epss_score": 0.64183, "epss_percentile": 0.98369}, "CVE-2018-13860": {"epss_score": 0.00314, "epss_percentile": 0.54077}, "CVE-2018-13861": {"epss_score": 0.0187, "epss_percentile": 0.82632}, "CVE-2018-13862": {"epss_score": 0.66893, "epss_percentile": 0.98485}, "CVE-2018-13863": {"epss_score": 0.00387, "epss_percentile": 0.59312}, "CVE-2018-13864": {"epss_score": 0.01327, "epss_percentile": 0.79492}, "CVE-2018-13865": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-13866": {"epss_score": 0.00425, "epss_percentile": 0.61703}, "CVE-2018-13867": {"epss_score": 0.00576, "epss_percentile": 0.6813}, "CVE-2018-13868": {"epss_score": 0.00425, "epss_percentile": 0.61703}, "CVE-2018-13869": {"epss_score": 0.00672, "epss_percentile": 0.70817}, "CVE-2018-13870": {"epss_score": 0.00672, "epss_percentile": 0.70817}, "CVE-2018-13871": {"epss_score": 0.0045, "epss_percentile": 0.63092}, "CVE-2018-13872": {"epss_score": 0.0045, "epss_percentile": 0.63092}, "CVE-2018-13873": {"epss_score": 0.00418, "epss_percentile": 0.61288}, "CVE-2018-13874": {"epss_score": 0.00414, "epss_percentile": 0.61016}, "CVE-2018-13875": {"epss_score": 0.00273, "epss_percentile": 0.50457}, "CVE-2018-13876": {"epss_score": 0.00416, "epss_percentile": 0.61185}, "CVE-2018-13877": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-13878": {"epss_score": 0.00208, "epss_percentile": 0.43265}, "CVE-2018-13879": {"epss_score": 0.00192, "epss_percentile": 0.41298}, "CVE-2018-13885": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2018-13886": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2018-13887": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2018-13888": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2018-13889": {"epss_score": 0.00019, "epss_percentile": 0.04178}, "CVE-2018-13893": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2018-13895": {"epss_score": 0.00021, "epss_percentile": 0.04943}, "CVE-2018-13896": {"epss_score": 0.00035, "epss_percentile": 0.09911}, "CVE-2018-13897": {"epss_score": 0.00235, "epss_percentile": 0.46227}, "CVE-2018-13898": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2018-13899": {"epss_score": 0.00035, "epss_percentile": 0.10064}, "CVE-2018-13900": {"epss_score": 0.00051, "epss_percentile": 0.16131}, "CVE-2018-13901": {"epss_score": 0.00034, "epss_percentile": 0.09523}, "CVE-2018-13902": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2018-13903": {"epss_score": 0.00219, "epss_percentile": 0.44508}, "CVE-2018-13904": {"epss_score": 0.00391, "epss_percentile": 0.59589}, "CVE-2018-13905": {"epss_score": 0.00051, "epss_percentile": 0.16131}, "CVE-2018-13906": {"epss_score": 0.00233, "epss_percentile": 0.45978}, "CVE-2018-13907": {"epss_score": 0.00224, "epss_percentile": 0.44979}, "CVE-2018-13908": {"epss_score": 0.00045, "epss_percentile": 0.13961}, "CVE-2018-13909": {"epss_score": 0.00026, "epss_percentile": 0.06412}, "CVE-2018-13910": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2018-13911": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2018-13912": {"epss_score": 0.00047, "epss_percentile": 0.14629}, "CVE-2018-13913": {"epss_score": 0.0005, "epss_percentile": 0.1593}, "CVE-2018-13914": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2018-13916": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2018-13918": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2018-13919": {"epss_score": 0.00041, "epss_percentile": 0.12417}, "CVE-2018-13920": {"epss_score": 0.00041, "epss_percentile": 0.12417}, "CVE-2018-13924": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2018-13925": {"epss_score": 0.00464, "epss_percentile": 0.6373}, "CVE-2018-13927": {"epss_score": 0.00028, "epss_percentile": 0.07525}, "CVE-2018-13980": {"epss_score": 0.11342, "epss_percentile": 0.93316}, "CVE-2018-13981": {"epss_score": 0.37798, "epss_percentile": 0.9707}, "CVE-2018-13982": {"epss_score": 0.02453, "epss_percentile": 0.84793}, "CVE-2018-13983": {"epss_score": 0.00347, "epss_percentile": 0.56776}, "CVE-2018-13988": {"epss_score": 0.00841, "epss_percentile": 0.74229}, "CVE-2018-13989": {"epss_score": 0.0038, "epss_percentile": 0.58955}, "CVE-2018-13990": {"epss_score": 0.0128, "epss_percentile": 0.79142}, "CVE-2018-13991": {"epss_score": 0.00145, "epss_percentile": 0.35355}, "CVE-2018-13992": {"epss_score": 0.00168, "epss_percentile": 0.38426}, "CVE-2018-13993": {"epss_score": 0.00124, "epss_percentile": 0.3245}, "CVE-2018-13994": {"epss_score": 0.00426, "epss_percentile": 0.61745}, "CVE-2018-13996": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-13997": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-13998": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-13999": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14001": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-14002": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-14003": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-14004": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-14005": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-14006": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-14007": {"epss_score": 0.04529, "epss_percentile": 0.8881}, "CVE-2018-14008": {"epss_score": 0.00177, "epss_percentile": 0.39592}, "CVE-2018-14009": {"epss_score": 0.51527, "epss_percentile": 0.97785}, "CVE-2018-14010": {"epss_score": 0.11264, "epss_percentile": 0.93283}, "CVE-2018-14012": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2018-14013": {"epss_score": 0.41164, "epss_percentile": 0.97256}, "CVE-2018-14014": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-14015": {"epss_score": 0.00226, "epss_percentile": 0.45309}, "CVE-2018-14016": {"epss_score": 0.00226, "epss_percentile": 0.45309}, "CVE-2018-14017": {"epss_score": 0.00226, "epss_percentile": 0.45309}, "CVE-2018-14020": {"epss_score": 0.00202, "epss_percentile": 0.42399}, "CVE-2018-14023": {"epss_score": 0.00069, "epss_percentile": 0.21614}, "CVE-2018-14027": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14028": {"epss_score": 0.02507, "epss_percentile": 0.8494}, "CVE-2018-14029": {"epss_score": 0.00245, "epss_percentile": 0.47706}, "CVE-2018-14031": {"epss_score": 0.00625, "epss_percentile": 0.69595}, "CVE-2018-14033": {"epss_score": 0.00579, "epss_percentile": 0.68232}, "CVE-2018-14034": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-14035": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-14036": {"epss_score": 0.01305, "epss_percentile": 0.7933}, "CVE-2018-14037": {"epss_score": 0.00094, "epss_percentile": 0.26983}, "CVE-2018-14040": {"epss_score": 0.01633, "epss_percentile": 0.81462}, "CVE-2018-14041": {"epss_score": 0.07723, "epss_percentile": 0.91645}, "CVE-2018-14042": {"epss_score": 0.01985, "epss_percentile": 0.83154}, "CVE-2018-14043": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2018-14044": {"epss_score": 0.00705, "epss_percentile": 0.71577}, "CVE-2018-14045": {"epss_score": 0.00705, "epss_percentile": 0.71577}, "CVE-2018-14046": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-14047": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-14048": {"epss_score": 0.01169, "epss_percentile": 0.78201}, "CVE-2018-14049": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-14050": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-14051": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-14052": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-14054": {"epss_score": 0.00576, "epss_percentile": 0.68136}, "CVE-2018-14055": {"epss_score": 0.00377, "epss_percentile": 0.58742}, "CVE-2018-14056": {"epss_score": 0.00686, "epss_percentile": 0.71153}, "CVE-2018-14057": {"epss_score": 8e-05, "epss_percentile": 0.00484}, "CVE-2018-14058": {"epss_score": 0.01587, "epss_percentile": 0.81183}, "CVE-2018-14059": {"epss_score": 6e-05, "epss_percentile": 0.00279}, "CVE-2018-14060": {"epss_score": 0.11264, "epss_percentile": 0.93283}, "CVE-2018-14062": {"epss_score": 0.00757, "epss_percentile": 0.72755}, "CVE-2018-14063": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-14064": {"epss_score": 0.7971, "epss_percentile": 0.99052}, "CVE-2018-14065": {"epss_score": 0.00418, "epss_percentile": 0.61282}, "CVE-2018-14066": {"epss_score": 0.00101, "epss_percentile": 0.28596}, "CVE-2018-14067": {"epss_score": 0.08469, "epss_percentile": 0.92068}, "CVE-2018-14068": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-14069": {"epss_score": 0.00134, "epss_percentile": 0.33859}, "CVE-2018-14071": {"epss_score": 0.01543, "epss_percentile": 0.80954}, "CVE-2018-14072": {"epss_score": 0.00366, "epss_percentile": 0.58025}, "CVE-2018-14073": {"epss_score": 0.00366, "epss_percentile": 0.58025}, "CVE-2018-14077": {"epss_score": 0.00333, "epss_percentile": 0.55617}, "CVE-2018-14078": {"epss_score": 0.01542, "epss_percentile": 0.80952}, "CVE-2018-14079": {"epss_score": 0.00333, "epss_percentile": 0.55617}, "CVE-2018-14080": {"epss_score": 0.00761, "epss_percentile": 0.72831}, "CVE-2018-14081": {"epss_score": 0.0086, "epss_percentile": 0.74533}, "CVE-2018-14082": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-14083": {"epss_score": 0.07236, "epss_percentile": 0.91341}, "CVE-2018-14084": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-14085": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-14086": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-14087": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-14088": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-14089": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-14241": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14242": {"epss_score": 0.00298, "epss_percentile": 0.52811}, "CVE-2018-14243": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14244": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14245": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14246": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14247": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14248": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14249": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14250": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14251": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14252": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14253": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14254": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14255": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14256": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14257": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14258": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14259": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14260": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14261": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14262": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14263": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14264": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14265": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14266": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14267": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14268": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14269": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14270": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14271": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14272": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14273": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14274": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14275": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14276": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14277": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14278": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14279": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14280": {"epss_score": 0.0107, "epss_percentile": 0.77252}, "CVE-2018-14281": {"epss_score": 0.0107, "epss_percentile": 0.77252}, "CVE-2018-14282": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14283": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14284": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14285": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14286": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14287": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14288": {"epss_score": 0.00264, "epss_percentile": 0.49582}, "CVE-2018-14289": {"epss_score": 0.00223, "epss_percentile": 0.44901}, "CVE-2018-14290": {"epss_score": 0.00474, "epss_percentile": 0.64151}, "CVE-2018-14291": {"epss_score": 0.00345, "epss_percentile": 0.56599}, "CVE-2018-14292": {"epss_score": 0.00345, "epss_percentile": 0.56599}, "CVE-2018-14293": {"epss_score": 0.00345, "epss_percentile": 0.56599}, "CVE-2018-14294": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14295": {"epss_score": 0.23206, "epss_percentile": 0.9575}, "CVE-2018-14296": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14297": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14298": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14299": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14300": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14301": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14302": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14303": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14304": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14305": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14306": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14307": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14308": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14309": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14310": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14311": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14312": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14313": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14314": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14315": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2018-14316": {"epss_score": 0.00201, "epss_percentile": 0.42284}, "CVE-2018-14317": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-14318": {"epss_score": 0.01009, "epss_percentile": 0.76582}, "CVE-2018-14320": {"epss_score": 0.00525, "epss_percentile": 0.66382}, "CVE-2018-14324": {"epss_score": 0.02457, "epss_percentile": 0.84804}, "CVE-2018-14325": {"epss_score": 0.00586, "epss_percentile": 0.68445}, "CVE-2018-14326": {"epss_score": 0.00454, "epss_percentile": 0.63263}, "CVE-2018-14327": {"epss_score": 0.00792, "epss_percentile": 0.73397}, "CVE-2018-14328": {"epss_score": 0.20688, "epss_percentile": 0.95402}, "CVE-2018-14329": {"epss_score": 0.00041, "epss_percentile": 0.12205}, "CVE-2018-14331": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-14332": {"epss_score": 0.00069, "epss_percentile": 0.21538}, "CVE-2018-14333": {"epss_score": 0.00252, "epss_percentile": 0.4836}, "CVE-2018-14334": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-14335": {"epss_score": 0.08596, "epss_percentile": 0.92143}, "CVE-2018-14336": {"epss_score": 0.17791, "epss_percentile": 0.94906}, "CVE-2018-14337": {"epss_score": 0.00384, "epss_percentile": 0.59123}, "CVE-2018-14338": {"epss_score": 0.00414, "epss_percentile": 0.61016}, "CVE-2018-14339": {"epss_score": 0.0172, "epss_percentile": 0.81929}, "CVE-2018-14340": {"epss_score": 0.01091, "epss_percentile": 0.77462}, "CVE-2018-14341": {"epss_score": 0.01335, "epss_percentile": 0.79548}, "CVE-2018-14342": {"epss_score": 0.01335, "epss_percentile": 0.79548}, "CVE-2018-14343": {"epss_score": 0.00583, "epss_percentile": 0.68332}, "CVE-2018-14344": {"epss_score": 0.00565, "epss_percentile": 0.67793}, "CVE-2018-14345": {"epss_score": 0.00255, "epss_percentile": 0.48633}, "CVE-2018-14346": {"epss_score": 0.00523, "epss_percentile": 0.66297}, "CVE-2018-14347": {"epss_score": 0.00566, "epss_percentile": 0.67818}, "CVE-2018-14348": {"epss_score": 0.00447, "epss_percentile": 0.62981}, "CVE-2018-14349": {"epss_score": 0.01347, "epss_percentile": 0.79649}, "CVE-2018-14350": {"epss_score": 0.04405, "epss_percentile": 0.88651}, "CVE-2018-14351": {"epss_score": 0.01161, "epss_percentile": 0.78141}, "CVE-2018-14352": {"epss_score": 0.04488, "epss_percentile": 0.88753}, "CVE-2018-14353": {"epss_score": 0.02134, "epss_percentile": 0.83722}, "CVE-2018-14354": {"epss_score": 0.03502, "epss_percentile": 0.8725}, "CVE-2018-14355": {"epss_score": 0.00433, "epss_percentile": 0.62187}, "CVE-2018-14356": {"epss_score": 0.00907, "epss_percentile": 0.75268}, "CVE-2018-14357": {"epss_score": 0.02975, "epss_percentile": 0.86105}, "CVE-2018-14358": {"epss_score": 0.01601, "epss_percentile": 0.81261}, "CVE-2018-14359": {"epss_score": 0.04488, "epss_percentile": 0.88753}, "CVE-2018-14360": {"epss_score": 0.00606, "epss_percentile": 0.69016}, "CVE-2018-14361": {"epss_score": 0.01211, "epss_percentile": 0.78556}, "CVE-2018-14362": {"epss_score": 0.02201, "epss_percentile": 0.83979}, "CVE-2018-14363": {"epss_score": 0.00531, "epss_percentile": 0.66646}, "CVE-2018-14364": {"epss_score": 0.39281, "epss_percentile": 0.97151}, "CVE-2018-14366": {"epss_score": 0.001, "epss_percentile": 0.28516}, "CVE-2018-14367": {"epss_score": 0.00565, "epss_percentile": 0.67793}, "CVE-2018-14368": {"epss_score": 0.01346, "epss_percentile": 0.79641}, "CVE-2018-14369": {"epss_score": 0.0083, "epss_percentile": 0.74021}, "CVE-2018-14370": {"epss_score": 0.0057, "epss_percentile": 0.67943}, "CVE-2018-14371": {"epss_score": 0.02605, "epss_percentile": 0.8522}, "CVE-2018-14379": {"epss_score": 0.00575, "epss_percentile": 0.68106}, "CVE-2018-14380": {"epss_score": 0.00265, "epss_percentile": 0.49822}, "CVE-2018-14381": {"epss_score": 0.00199, "epss_percentile": 0.42149}, "CVE-2018-14382": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-14383": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2018-14384": {"epss_score": 0.00153, "epss_percentile": 0.36614}, "CVE-2018-14387": {"epss_score": 0.00257, "epss_percentile": 0.4886}, "CVE-2018-14388": {"epss_score": 0.00149, "epss_percentile": 0.36001}, "CVE-2018-14389": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-14392": {"epss_score": 0.08341, "epss_percentile": 0.91999}, "CVE-2018-14394": {"epss_score": 0.00473, "epss_percentile": 0.6411}, "CVE-2018-14395": {"epss_score": 0.00819, "epss_percentile": 0.73868}, "CVE-2018-14396": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2018-14397": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2018-14398": {"epss_score": 0.00274, "epss_percentile": 0.50545}, "CVE-2018-14399": {"epss_score": 0.00763, "epss_percentile": 0.72883}, "CVE-2018-14401": {"epss_score": 0.00204, "epss_percentile": 0.42627}, "CVE-2018-14402": {"epss_score": 0.00204, "epss_percentile": 0.42627}, "CVE-2018-14403": {"epss_score": 0.00472, "epss_percentile": 0.64044}, "CVE-2018-14404": {"epss_score": 0.20012, "epss_percentile": 0.95275}, "CVE-2018-14415": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14417": {"epss_score": 0.71897, "epss_percentile": 0.98685}, "CVE-2018-14418": {"epss_score": 0.04771, "epss_percentile": 0.89127}, "CVE-2018-14419": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14420": {"epss_score": 0.00177, "epss_percentile": 0.39553}, "CVE-2018-14421": {"epss_score": 0.00385, "epss_percentile": 0.59207}, "CVE-2018-14422": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14423": {"epss_score": 0.01616, "epss_percentile": 0.81355}, "CVE-2018-14424": {"epss_score": 0.00074, "epss_percentile": 0.22761}, "CVE-2018-14425": {"epss_score": 0.0062, "epss_percentile": 0.69454}, "CVE-2018-14429": {"epss_score": 0.01241, "epss_percentile": 0.78814}, "CVE-2018-14430": {"epss_score": 0.0082, "epss_percentile": 0.7388}, "CVE-2018-14432": {"epss_score": 0.012, "epss_percentile": 0.78468}, "CVE-2018-14434": {"epss_score": 0.00193, "epss_percentile": 0.41452}, "CVE-2018-14435": {"epss_score": 0.00178, "epss_percentile": 0.39666}, "CVE-2018-14436": {"epss_score": 0.00136, "epss_percentile": 0.34125}, "CVE-2018-14437": {"epss_score": 0.00178, "epss_percentile": 0.39666}, "CVE-2018-14438": {"epss_score": 0.00122, "epss_percentile": 0.3214}, "CVE-2018-14439": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-14440": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-14441": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-14442": {"epss_score": 0.05697, "epss_percentile": 0.90128}, "CVE-2018-14443": {"epss_score": 0.00425, "epss_percentile": 0.61696}, "CVE-2018-14444": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2018-14445": {"epss_score": 0.00333, "epss_percentile": 0.55679}, "CVE-2018-14446": {"epss_score": 0.00877, "epss_percentile": 0.74808}, "CVE-2018-14447": {"epss_score": 0.00472, "epss_percentile": 0.64031}, "CVE-2018-14448": {"epss_score": 0.00285, "epss_percentile": 0.51681}, "CVE-2018-14449": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-14450": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-14451": {"epss_score": 0.0042, "epss_percentile": 0.61444}, "CVE-2018-14452": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-14453": {"epss_score": 0.0042, "epss_percentile": 0.61444}, "CVE-2018-14454": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-14455": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-14456": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-14457": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-14458": {"epss_score": 0.0042, "epss_percentile": 0.61444}, "CVE-2018-14459": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-14460": {"epss_score": 0.00569, "epss_percentile": 0.67923}, "CVE-2018-14461": {"epss_score": 0.00335, "epss_percentile": 0.55833}, "CVE-2018-14462": {"epss_score": 0.02283, "epss_percentile": 0.84259}, "CVE-2018-14463": {"epss_score": 0.00618, "epss_percentile": 0.6938}, "CVE-2018-14464": {"epss_score": 0.02005, "epss_percentile": 0.83231}, "CVE-2018-14465": {"epss_score": 0.01758, "epss_percentile": 0.82135}, "CVE-2018-14466": {"epss_score": 0.02005, "epss_percentile": 0.83231}, "CVE-2018-14467": {"epss_score": 0.00455, "epss_percentile": 0.63291}, "CVE-2018-14468": {"epss_score": 0.00678, "epss_percentile": 0.70989}, "CVE-2018-14469": {"epss_score": 0.01735, "epss_percentile": 0.82007}, "CVE-2018-14470": {"epss_score": 0.02005, "epss_percentile": 0.83231}, "CVE-2018-14471": {"epss_score": 0.00348, "epss_percentile": 0.56799}, "CVE-2018-14472": {"epss_score": 0.00576, "epss_percentile": 0.68127}, "CVE-2018-14473": {"epss_score": 0.02755, "epss_percentile": 0.8559}, "CVE-2018-14474": {"epss_score": 0.02192, "epss_percentile": 0.83942}, "CVE-2018-14476": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-14478": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-14481": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-14485": {"epss_score": 0.217, "epss_percentile": 0.95549}, "CVE-2018-14486": {"epss_score": 0.00479, "epss_percentile": 0.64446}, "CVE-2018-14492": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2018-14493": {"epss_score": 0.0162, "epss_percentile": 0.81382}, "CVE-2018-14494": {"epss_score": 0.0896, "epss_percentile": 0.92338}, "CVE-2018-14495": {"epss_score": 0.18805, "epss_percentile": 0.95072}, "CVE-2018-14496": {"epss_score": 0.04783, "epss_percentile": 0.89139}, "CVE-2018-14497": {"epss_score": 0.00188, "epss_percentile": 0.40879}, "CVE-2018-14498": {"epss_score": 0.00391, "epss_percentile": 0.5958}, "CVE-2018-14499": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14500": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14501": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-14502": {"epss_score": 0.04484, "epss_percentile": 0.88745}, "CVE-2018-14503": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-14504": {"epss_score": 0.00482, "epss_percentile": 0.64547}, "CVE-2018-14505": {"epss_score": 0.00355, "epss_percentile": 0.57318}, "CVE-2018-14512": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2018-14513": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-14514": {"epss_score": 0.00482, "epss_percentile": 0.6454}, "CVE-2018-14515": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2018-14517": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14519": {"epss_score": 0.00164, "epss_percentile": 0.37894}, "CVE-2018-14520": {"epss_score": 0.0022, "epss_percentile": 0.44603}, "CVE-2018-14521": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-14522": {"epss_score": 0.00448, "epss_percentile": 0.62991}, "CVE-2018-14523": {"epss_score": 0.00448, "epss_percentile": 0.62991}, "CVE-2018-14524": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2018-14526": {"epss_score": 0.01138, "epss_percentile": 0.77932}, "CVE-2018-14527": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14528": {"epss_score": 0.01044, "epss_percentile": 0.77}, "CVE-2018-14529": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-14531": {"epss_score": 0.00468, "epss_percentile": 0.63913}, "CVE-2018-14532": {"epss_score": 0.00474, "epss_percentile": 0.64142}, "CVE-2018-14533": {"epss_score": 0.01704, "epss_percentile": 0.81847}, "CVE-2018-14541": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-14543": {"epss_score": 0.0018, "epss_percentile": 0.39991}, "CVE-2018-14544": {"epss_score": 0.00178, "epss_percentile": 0.39744}, "CVE-2018-14545": {"epss_score": 0.00178, "epss_percentile": 0.39744}, "CVE-2018-14549": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-14550": {"epss_score": 0.01778, "epss_percentile": 0.82229}, "CVE-2018-14551": {"epss_score": 0.00276, "epss_percentile": 0.50718}, "CVE-2018-14553": {"epss_score": 0.00815, "epss_percentile": 0.73787}, "CVE-2018-14557": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2018-14558": {"epss_score": 0.76772, "epss_percentile": 0.98904}, "CVE-2018-14559": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2018-14562": {"epss_score": 0.00372, "epss_percentile": 0.58439}, "CVE-2018-14563": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-14564": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-14565": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-14567": {"epss_score": 0.00581, "epss_percentile": 0.68271}, "CVE-2018-14568": {"epss_score": 0.00281, "epss_percentile": 0.51129}, "CVE-2018-14570": {"epss_score": 0.00885, "epss_percentile": 0.74939}, "CVE-2018-14572": {"epss_score": 0.00844, "epss_percentile": 0.74274}, "CVE-2018-14573": {"epss_score": 0.00054, "epss_percentile": 0.17339}, "CVE-2018-14574": {"epss_score": 0.09501, "epss_percentile": 0.92574}, "CVE-2018-14575": {"epss_score": 0.02903, "epss_percentile": 0.85959}, "CVE-2018-14576": {"epss_score": 0.00224, "epss_percentile": 0.4498}, "CVE-2018-14579": {"epss_score": 0.00994, "epss_percentile": 0.76426}, "CVE-2018-14581": {"epss_score": 0.0041, "epss_percentile": 0.60822}, "CVE-2018-14582": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-14583": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-14584": {"epss_score": 0.00429, "epss_percentile": 0.61981}, "CVE-2018-14585": {"epss_score": 0.00429, "epss_percentile": 0.61981}, "CVE-2018-14586": {"epss_score": 0.00429, "epss_percentile": 0.61981}, "CVE-2018-14587": {"epss_score": 0.00429, "epss_percentile": 0.61981}, "CVE-2018-14588": {"epss_score": 0.00367, "epss_percentile": 0.58112}, "CVE-2018-14589": {"epss_score": 0.00429, "epss_percentile": 0.61981}, "CVE-2018-14590": {"epss_score": 0.00366, "epss_percentile": 0.58025}, "CVE-2018-14592": {"epss_score": 0.05385, "epss_percentile": 0.89818}, "CVE-2018-14593": {"epss_score": 0.00681, "epss_percentile": 0.7104}, "CVE-2018-14596": {"epss_score": 0.0065, "epss_percentile": 0.70268}, "CVE-2018-14597": {"epss_score": 0.00203, "epss_percentile": 0.42499}, "CVE-2018-14598": {"epss_score": 0.0314, "epss_percentile": 0.86485}, "CVE-2018-14599": {"epss_score": 0.0246, "epss_percentile": 0.84822}, "CVE-2018-14600": {"epss_score": 0.09365, "epss_percentile": 0.92517}, "CVE-2018-14601": {"epss_score": 0.00233, "epss_percentile": 0.46054}, "CVE-2018-14602": {"epss_score": 0.00098, "epss_percentile": 0.27694}, "CVE-2018-14603": {"epss_score": 0.00034, "epss_percentile": 0.0973}, "CVE-2018-14604": {"epss_score": 0.0007, "epss_percentile": 0.21755}, "CVE-2018-14605": {"epss_score": 0.00063, "epss_percentile": 0.20092}, "CVE-2018-14606": {"epss_score": 0.00059, "epss_percentile": 0.18839}, "CVE-2018-14607": {"epss_score": 0.00397, "epss_percentile": 0.60019}, "CVE-2018-14608": {"epss_score": 0.00187, "epss_percentile": 0.40727}, "CVE-2018-14609": {"epss_score": 0.00308, "epss_percentile": 0.53569}, "CVE-2018-14610": {"epss_score": 0.00089, "epss_percentile": 0.25799}, "CVE-2018-14611": {"epss_score": 0.00258, "epss_percentile": 0.48984}, "CVE-2018-14612": {"epss_score": 0.00092, "epss_percentile": 0.26447}, "CVE-2018-14613": {"epss_score": 0.00105, "epss_percentile": 0.29272}, "CVE-2018-14614": {"epss_score": 0.00264, "epss_percentile": 0.49711}, "CVE-2018-14615": {"epss_score": 0.0026, "epss_percentile": 0.49162}, "CVE-2018-14616": {"epss_score": 0.00159, "epss_percentile": 0.3734}, "CVE-2018-14617": {"epss_score": 0.00258, "epss_percentile": 0.48984}, "CVE-2018-14618": {"epss_score": 0.00368, "epss_percentile": 0.58169}, "CVE-2018-14619": {"epss_score": 0.00113, "epss_percentile": 0.30693}, "CVE-2018-14620": {"epss_score": 0.00131, "epss_percentile": 0.33416}, "CVE-2018-14621": {"epss_score": 0.0048, "epss_percentile": 0.64456}, "CVE-2018-14622": {"epss_score": 0.02344, "epss_percentile": 0.84445}, "CVE-2018-14623": {"epss_score": 0.00245, "epss_percentile": 0.47677}, "CVE-2018-14624": {"epss_score": 0.01478, "epss_percentile": 0.80555}, "CVE-2018-14625": {"epss_score": 0.00064, "epss_percentile": 0.20313}, "CVE-2018-14626": {"epss_score": 0.00124, "epss_percentile": 0.32453}, "CVE-2018-14627": {"epss_score": 0.0024, "epss_percentile": 0.46952}, "CVE-2018-14628": {"epss_score": 0.00412, "epss_percentile": 0.60921}, "CVE-2018-14629": {"epss_score": 0.13621, "epss_percentile": 0.94017}, "CVE-2018-14630": {"epss_score": 0.01545, "epss_percentile": 0.80963}, "CVE-2018-14631": {"epss_score": 0.00607, "epss_percentile": 0.69053}, "CVE-2018-14632": {"epss_score": 0.00847, "epss_percentile": 0.74345}, "CVE-2018-14633": {"epss_score": 0.07984, "epss_percentile": 0.91802}, "CVE-2018-14634": {"epss_score": 0.03488, "epss_percentile": 0.87228}, "CVE-2018-14635": {"epss_score": 0.00306, "epss_percentile": 0.53457}, "CVE-2018-14636": {"epss_score": 0.00214, "epss_percentile": 0.43987}, "CVE-2018-14637": {"epss_score": 0.00252, "epss_percentile": 0.48366}, "CVE-2018-14638": {"epss_score": 0.00863, "epss_percentile": 0.74586}, "CVE-2018-14641": {"epss_score": 0.01355, "epss_percentile": 0.79709}, "CVE-2018-14642": {"epss_score": 0.00746, "epss_percentile": 0.72545}, "CVE-2018-14643": {"epss_score": 0.08948, "epss_percentile": 0.92334}, "CVE-2018-14644": {"epss_score": 0.00043, "epss_percentile": 0.13184}, "CVE-2018-14645": {"epss_score": 0.00225, "epss_percentile": 0.45105}, "CVE-2018-14646": {"epss_score": 0.0004, "epss_percentile": 0.12164}, "CVE-2018-14647": {"epss_score": 0.01898, "epss_percentile": 0.82761}, "CVE-2018-14648": {"epss_score": 0.10171, "epss_percentile": 0.92879}, "CVE-2018-14649": {"epss_score": 0.58114, "epss_percentile": 0.981}, "CVE-2018-14650": {"epss_score": 0.00044, "epss_percentile": 0.13427}, "CVE-2018-14651": {"epss_score": 0.03565, "epss_percentile": 0.8736}, "CVE-2018-14652": {"epss_score": 0.02777, "epss_percentile": 0.85643}, "CVE-2018-14653": {"epss_score": 0.00875, "epss_percentile": 0.7478}, "CVE-2018-14654": {"epss_score": 0.0209, "epss_percentile": 0.83569}, "CVE-2018-14655": {"epss_score": 0.0022, "epss_percentile": 0.44612}, "CVE-2018-14656": {"epss_score": 0.0009, "epss_percentile": 0.26082}, "CVE-2018-14657": {"epss_score": 0.00365, "epss_percentile": 0.57986}, "CVE-2018-14658": {"epss_score": 0.0024, "epss_percentile": 0.46962}, "CVE-2018-14659": {"epss_score": 0.02588, "epss_percentile": 0.85174}, "CVE-2018-14660": {"epss_score": 0.01655, "epss_percentile": 0.81591}, "CVE-2018-14661": {"epss_score": 0.03095, "epss_percentile": 0.86402}, "CVE-2018-14662": {"epss_score": 0.00093, "epss_percentile": 0.26686}, "CVE-2018-14663": {"epss_score": 9e-05, "epss_percentile": 0.00608}, "CVE-2018-14664": {"epss_score": 0.00291, "epss_percentile": 0.52182}, "CVE-2018-14665": {"epss_score": 0.07133, "epss_percentile": 0.91273}, "CVE-2018-14666": {"epss_score": 0.00353, "epss_percentile": 0.57165}, "CVE-2018-14667": {"epss_score": 0.89374, "epss_percentile": 0.99523}, "CVE-2018-14668": {"epss_score": 0.00214, "epss_percentile": 0.43997}, "CVE-2018-14669": {"epss_score": 0.00437, "epss_percentile": 0.6249}, "CVE-2018-14670": {"epss_score": 0.0042, "epss_percentile": 0.6141}, "CVE-2018-14671": {"epss_score": 0.01158, "epss_percentile": 0.78116}, "CVE-2018-14672": {"epss_score": 0.00435, "epss_percentile": 0.62343}, "CVE-2018-14678": {"epss_score": 0.00087, "epss_percentile": 0.25527}, "CVE-2018-14679": {"epss_score": 0.01075, "epss_percentile": 0.77317}, "CVE-2018-14680": {"epss_score": 0.02774, "epss_percentile": 0.85633}, "CVE-2018-14681": {"epss_score": 0.03303, "epss_percentile": 0.86869}, "CVE-2018-14682": {"epss_score": 0.03303, "epss_percentile": 0.86869}, "CVE-2018-14683": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-14685": {"epss_score": 0.00557, "epss_percentile": 0.67554}, "CVE-2018-14686": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14688": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14689": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14690": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14691": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14695": {"epss_score": 0.00487, "epss_percentile": 0.64814}, "CVE-2018-14696": {"epss_score": 0.00487, "epss_percentile": 0.64814}, "CVE-2018-14697": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14698": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14699": {"epss_score": 0.69475, "epss_percentile": 0.98588}, "CVE-2018-14700": {"epss_score": 0.00487, "epss_percentile": 0.64814}, "CVE-2018-14701": {"epss_score": 0.50208, "epss_percentile": 0.97726}, "CVE-2018-14702": {"epss_score": 0.00487, "epss_percentile": 0.64814}, "CVE-2018-14703": {"epss_score": 0.02042, "epss_percentile": 0.83375}, "CVE-2018-14704": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14705": {"epss_score": 0.00413, "epss_percentile": 0.60996}, "CVE-2018-14706": {"epss_score": 0.63856, "epss_percentile": 0.98353}, "CVE-2018-14707": {"epss_score": 0.02784, "epss_percentile": 0.85655}, "CVE-2018-14708": {"epss_score": 0.00482, "epss_percentile": 0.6454}, "CVE-2018-14709": {"epss_score": 0.00623, "epss_percentile": 0.69552}, "CVE-2018-14710": {"epss_score": 0.0028, "epss_percentile": 0.51004}, "CVE-2018-14711": {"epss_score": 0.00137, "epss_percentile": 0.34217}, "CVE-2018-14712": {"epss_score": 0.00405, "epss_percentile": 0.60483}, "CVE-2018-14713": {"epss_score": 0.00854, "epss_percentile": 0.7445}, "CVE-2018-14714": {"epss_score": 0.79723, "epss_percentile": 0.99052}, "CVE-2018-14715": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2018-14716": {"epss_score": 0.61605, "epss_percentile": 0.98254}, "CVE-2018-14718": {"epss_score": 0.14515, "epss_percentile": 0.94228}, "CVE-2018-14719": {"epss_score": 0.02605, "epss_percentile": 0.85219}, "CVE-2018-14720": {"epss_score": 0.02518, "epss_percentile": 0.84993}, "CVE-2018-14721": {"epss_score": 0.09436, "epss_percentile": 0.92547}, "CVE-2018-14722": {"epss_score": 0.00613, "epss_percentile": 0.69249}, "CVE-2018-14724": {"epss_score": 0.00192, "epss_percentile": 0.41288}, "CVE-2018-14728": {"epss_score": 0.90868, "epss_percentile": 0.99606}, "CVE-2018-14729": {"epss_score": 0.5838, "epss_percentile": 0.98113}, "CVE-2018-14730": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-14731": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2018-14732": {"epss_score": 0.00205, "epss_percentile": 0.4274}, "CVE-2018-14733": {"epss_score": 0.00879, "epss_percentile": 0.74845}, "CVE-2018-14734": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2018-14735": {"epss_score": 0.00314, "epss_percentile": 0.54077}, "CVE-2018-14736": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-14737": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2018-14738": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2018-14739": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2018-14740": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2018-14741": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2018-14742": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2018-14743": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-14744": {"epss_score": 0.00509, "epss_percentile": 0.65724}, "CVE-2018-14745": {"epss_score": 0.00215, "epss_percentile": 0.44062}, "CVE-2018-14746": {"epss_score": 0.03495, "epss_percentile": 0.87235}, "CVE-2018-14747": {"epss_score": 0.00918, "epss_percentile": 0.75437}, "CVE-2018-14748": {"epss_score": 0.00622, "epss_percentile": 0.69509}, "CVE-2018-14749": {"epss_score": 0.00543, "epss_percentile": 0.67119}, "CVE-2018-14767": {"epss_score": 0.01209, "epss_percentile": 0.78544}, "CVE-2018-14768": {"epss_score": 0.03022, "epss_percentile": 0.86228}, "CVE-2018-14769": {"epss_score": 0.00157, "epss_percentile": 0.37113}, "CVE-2018-14770": {"epss_score": 0.03453, "epss_percentile": 0.87168}, "CVE-2018-14771": {"epss_score": 0.03453, "epss_percentile": 0.87168}, "CVE-2018-14772": {"epss_score": 0.33819, "epss_percentile": 0.96806}, "CVE-2018-14773": {"epss_score": 0.16652, "epss_percentile": 0.94708}, "CVE-2018-14774": {"epss_score": 0.00102, "epss_percentile": 0.28811}, "CVE-2018-14775": {"epss_score": 0.00046, "epss_percentile": 0.14123}, "CVE-2018-14776": {"epss_score": 0.00294, "epss_percentile": 0.52397}, "CVE-2018-14777": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-14779": {"epss_score": 0.00149, "epss_percentile": 0.36038}, "CVE-2018-14780": {"epss_score": 0.00147, "epss_percentile": 0.35684}, "CVE-2018-14781": {"epss_score": 0.00321, "epss_percentile": 0.54691}, "CVE-2018-14782": {"epss_score": 0.00298, "epss_percentile": 0.52788}, "CVE-2018-14783": {"epss_score": 0.00138, "epss_percentile": 0.34516}, "CVE-2018-14784": {"epss_score": 0.00142, "epss_percentile": 0.34968}, "CVE-2018-14785": {"epss_score": 0.0159, "epss_percentile": 0.81198}, "CVE-2018-14786": {"epss_score": 0.07322, "epss_percentile": 0.91408}, "CVE-2018-14787": {"epss_score": 0.00055, "epss_percentile": 0.17588}, "CVE-2018-14788": {"epss_score": 0.00244, "epss_percentile": 0.4762}, "CVE-2018-14789": {"epss_score": 0.00094, "epss_percentile": 0.2704}, "CVE-2018-14790": {"epss_score": 0.03475, "epss_percentile": 0.87207}, "CVE-2018-14791": {"epss_score": 0.0008, "epss_percentile": 0.24203}, "CVE-2018-14792": {"epss_score": 0.00251, "epss_percentile": 0.48314}, "CVE-2018-14793": {"epss_score": 0.00247, "epss_percentile": 0.47823}, "CVE-2018-14794": {"epss_score": 0.00665, "epss_percentile": 0.70665}, "CVE-2018-14795": {"epss_score": 0.01801, "epss_percentile": 0.82326}, "CVE-2018-14796": {"epss_score": 0.00233, "epss_percentile": 0.46053}, "CVE-2018-14797": {"epss_score": 0.00225, "epss_percentile": 0.45096}, "CVE-2018-14798": {"epss_score": 0.00232, "epss_percentile": 0.4596}, "CVE-2018-14799": {"epss_score": 0.00163, "epss_percentile": 0.3783}, "CVE-2018-14800": {"epss_score": 0.00195, "epss_percentile": 0.41673}, "CVE-2018-14801": {"epss_score": 0.00102, "epss_percentile": 0.28755}, "CVE-2018-14802": {"epss_score": 0.03062, "epss_percentile": 0.86317}, "CVE-2018-14803": {"epss_score": 0.00362, "epss_percentile": 0.57774}, "CVE-2018-14804": {"epss_score": 0.05211, "epss_percentile": 0.89616}, "CVE-2018-14805": {"epss_score": 0.01319, "epss_percentile": 0.79432}, "CVE-2018-14806": {"epss_score": 0.09761, "epss_percentile": 0.92693}, "CVE-2018-14807": {"epss_score": 0.04628, "epss_percentile": 0.8894}, "CVE-2018-14808": {"epss_score": 0.0023, "epss_percentile": 0.4567}, "CVE-2018-14809": {"epss_score": 0.01264, "epss_percentile": 0.78993}, "CVE-2018-14810": {"epss_score": 0.00259, "epss_percentile": 0.49033}, "CVE-2018-14811": {"epss_score": 0.0245, "epss_percentile": 0.84781}, "CVE-2018-14812": {"epss_score": 0.00176, "epss_percentile": 0.39435}, "CVE-2018-14813": {"epss_score": 0.04675, "epss_percentile": 0.88991}, "CVE-2018-14814": {"epss_score": 0.00476, "epss_percentile": 0.64266}, "CVE-2018-14815": {"epss_score": 0.02842, "epss_percentile": 0.85807}, "CVE-2018-14816": {"epss_score": 0.03464, "epss_percentile": 0.87187}, "CVE-2018-14817": {"epss_score": 0.02822, "epss_percentile": 0.85747}, "CVE-2018-14818": {"epss_score": 0.01262, "epss_percentile": 0.78982}, "CVE-2018-14819": {"epss_score": 0.02842, "epss_percentile": 0.85807}, "CVE-2018-14820": {"epss_score": 0.00952, "epss_percentile": 0.75874}, "CVE-2018-14821": {"epss_score": 0.01686, "epss_percentile": 0.81752}, "CVE-2018-14822": {"epss_score": 0.00828, "epss_percentile": 0.74004}, "CVE-2018-14823": {"epss_score": 0.04675, "epss_percentile": 0.88991}, "CVE-2018-14824": {"epss_score": 0.00577, "epss_percentile": 0.68151}, "CVE-2018-14825": {"epss_score": 0.00161, "epss_percentile": 0.37552}, "CVE-2018-14826": {"epss_score": 0.24234, "epss_percentile": 0.95895}, "CVE-2018-14827": {"epss_score": 0.0023, "epss_percentile": 0.45687}, "CVE-2018-14828": {"epss_score": 0.00053, "epss_percentile": 0.16883}, "CVE-2018-14829": {"epss_score": 0.48375, "epss_percentile": 0.97635}, "CVE-2018-14831": {"epss_score": 0.00257, "epss_percentile": 0.48921}, "CVE-2018-14833": {"epss_score": 0.00371, "epss_percentile": 0.58409}, "CVE-2018-14835": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-14836": {"epss_score": 0.00207, "epss_percentile": 0.43112}, "CVE-2018-14837": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14838": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14839": {"epss_score": 0.90301, "epss_percentile": 0.99576}, "CVE-2018-14840": {"epss_score": 0.03066, "epss_percentile": 0.86338}, "CVE-2018-14846": {"epss_score": 0.00218, "epss_percentile": 0.44356}, "CVE-2018-14847": {"epss_score": 0.93645, "epss_percentile": 0.99829}, "CVE-2018-14849": {"epss_score": 0.00244, "epss_percentile": 0.47524}, "CVE-2018-14850": {"epss_score": 0.00401, "epss_percentile": 0.60247}, "CVE-2018-14851": {"epss_score": 0.00407, "epss_percentile": 0.60621}, "CVE-2018-14852": {"epss_score": 0.00146, "epss_percentile": 0.35548}, "CVE-2018-14853": {"epss_score": 0.00158, "epss_percentile": 0.37211}, "CVE-2018-14854": {"epss_score": 0.00154, "epss_percentile": 0.36747}, "CVE-2018-14855": {"epss_score": 0.00154, "epss_percentile": 0.36747}, "CVE-2018-14856": {"epss_score": 0.00154, "epss_percentile": 0.36747}, "CVE-2018-14857": {"epss_score": 0.05083, "epss_percentile": 0.89474}, "CVE-2018-14858": {"epss_score": 0.00371, "epss_percentile": 0.58409}, "CVE-2018-14859": {"epss_score": 0.00348, "epss_percentile": 0.56841}, "CVE-2018-14860": {"epss_score": 0.0224, "epss_percentile": 0.84112}, "CVE-2018-14861": {"epss_score": 0.00359, "epss_percentile": 0.57591}, "CVE-2018-14862": {"epss_score": 0.00254, "epss_percentile": 0.48505}, "CVE-2018-14863": {"epss_score": 0.00348, "epss_percentile": 0.56841}, "CVE-2018-14864": {"epss_score": 0.00134, "epss_percentile": 0.3377}, "CVE-2018-14865": {"epss_score": 0.00225, "epss_percentile": 0.45148}, "CVE-2018-14866": {"epss_score": 0.00262, "epss_percentile": 0.49347}, "CVE-2018-14867": {"epss_score": 0.00258, "epss_percentile": 0.48972}, "CVE-2018-14868": {"epss_score": 0.0019, "epss_percentile": 0.41058}, "CVE-2018-14869": {"epss_score": 0.00108, "epss_percentile": 0.29842}, "CVE-2018-14872": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-14873": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-14874": {"epss_score": 0.0042, "epss_percentile": 0.61434}, "CVE-2018-14875": {"epss_score": 0.0042, "epss_percentile": 0.61413}, "CVE-2018-14876": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-14877": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-14878": {"epss_score": 4e-05, "epss_percentile": 0.00133}, "CVE-2018-14879": {"epss_score": 0.0052, "epss_percentile": 0.6619}, "CVE-2018-14880": {"epss_score": 0.00986, "epss_percentile": 0.76328}, "CVE-2018-14881": {"epss_score": 0.05465, "epss_percentile": 0.89903}, "CVE-2018-14882": {"epss_score": 0.02378, "epss_percentile": 0.84556}, "CVE-2018-14883": {"epss_score": 0.20292, "epss_percentile": 0.95315}, "CVE-2018-14884": {"epss_score": 0.00974, "epss_percentile": 0.76168}, "CVE-2018-14885": {"epss_score": 0.00726, "epss_percentile": 0.72071}, "CVE-2018-14886": {"epss_score": 0.00282, "epss_percentile": 0.51213}, "CVE-2018-14887": {"epss_score": 0.00431, "epss_percentile": 0.62092}, "CVE-2018-14888": {"epss_score": 0.05927, "epss_percentile": 0.90333}, "CVE-2018-14889": {"epss_score": 0.00036, "epss_percentile": 0.10514}, "CVE-2018-14890": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2018-14891": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2018-14892": {"epss_score": 0.01814, "epss_percentile": 0.82379}, "CVE-2018-14893": {"epss_score": 0.11662, "epss_percentile": 0.93437}, "CVE-2018-14894": {"epss_score": 0.00333, "epss_percentile": 0.55656}, "CVE-2018-14899": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14900": {"epss_score": 0.00249, "epss_percentile": 0.48044}, "CVE-2018-14901": {"epss_score": 0.00371, "epss_percentile": 0.58409}, "CVE-2018-14902": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-14903": {"epss_score": 0.00127, "epss_percentile": 0.3278}, "CVE-2018-14904": {"epss_score": 0.00446, "epss_percentile": 0.6293}, "CVE-2018-14905": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14906": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14907": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2018-14908": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-14910": {"epss_score": 0.00465, "epss_percentile": 0.63754}, "CVE-2018-14911": {"epss_score": 0.00358, "epss_percentile": 0.57529}, "CVE-2018-14912": {"epss_score": 0.91584, "epss_percentile": 0.99654}, "CVE-2018-14916": {"epss_score": 0.68248, "epss_percentile": 0.98537}, "CVE-2018-14918": {"epss_score": 0.73138, "epss_percentile": 0.98738}, "CVE-2018-14919": {"epss_score": 0.01791, "epss_percentile": 0.82282}, "CVE-2018-14922": {"epss_score": 0.00343, "epss_percentile": 0.56471}, "CVE-2018-14923": {"epss_score": 0.00233, "epss_percentile": 0.46049}, "CVE-2018-14924": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14925": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-14926": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2018-14927": {"epss_score": 0.00426, "epss_percentile": 0.61759}, "CVE-2018-14928": {"epss_score": 0.00615, "epss_percentile": 0.69291}, "CVE-2018-14929": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-14930": {"epss_score": 0.00182, "epss_percentile": 0.40246}, "CVE-2018-14931": {"epss_score": 0.07006, "epss_percentile": 0.9118}, "CVE-2018-14933": {"epss_score": 0.93755, "epss_percentile": 0.9984}, "CVE-2018-14934": {"epss_score": 0.00111, "epss_percentile": 0.30248}, "CVE-2018-14935": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-14936": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14937": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14938": {"epss_score": 0.00489, "epss_percentile": 0.64896}, "CVE-2018-14939": {"epss_score": 0.00533, "epss_percentile": 0.66763}, "CVE-2018-14940": {"epss_score": 0.0065, "epss_percentile": 0.70268}, "CVE-2018-14941": {"epss_score": 0.00216, "epss_percentile": 0.44148}, "CVE-2018-14942": {"epss_score": 0.00413, "epss_percentile": 0.60997}, "CVE-2018-14943": {"epss_score": 0.00299, "epss_percentile": 0.52886}, "CVE-2018-14944": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-14945": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2018-14946": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2018-14947": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2018-14948": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-14950": {"epss_score": 0.00493, "epss_percentile": 0.65033}, "CVE-2018-14951": {"epss_score": 0.00533, "epss_percentile": 0.66758}, "CVE-2018-14952": {"epss_score": 0.00493, "epss_percentile": 0.65033}, "CVE-2018-14953": {"epss_score": 0.00493, "epss_percentile": 0.65033}, "CVE-2018-14954": {"epss_score": 0.00533, "epss_percentile": 0.66758}, "CVE-2018-14955": {"epss_score": 0.00533, "epss_percentile": 0.66758}, "CVE-2018-14956": {"epss_score": 0.00415, "epss_percentile": 0.61156}, "CVE-2018-14957": {"epss_score": 0.00243, "epss_percentile": 0.47428}, "CVE-2018-14958": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2018-14959": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2018-14960": {"epss_score": 0.0018, "epss_percentile": 0.39979}, "CVE-2018-14961": {"epss_score": 0.00264, "epss_percentile": 0.49574}, "CVE-2018-14962": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-14963": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-14964": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-14965": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-14966": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-14967": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2018-14968": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-14969": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14970": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14971": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14972": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14973": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14974": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14975": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14976": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-14977": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-14978": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-14979": {"epss_score": 0.0007, "epss_percentile": 0.21685}, "CVE-2018-14980": {"epss_score": 0.00052, "epss_percentile": 0.16462}, "CVE-2018-14981": {"epss_score": 0.00093, "epss_percentile": 0.26747}, "CVE-2018-14982": {"epss_score": 0.00093, "epss_percentile": 0.26747}, "CVE-2018-14983": {"epss_score": 0.00081, "epss_percentile": 0.24328}, "CVE-2018-14984": {"epss_score": 0.00222, "epss_percentile": 0.44772}, "CVE-2018-14985": {"epss_score": 0.00031, "epss_percentile": 0.08436}, "CVE-2018-14986": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-14987": {"epss_score": 0.00031, "epss_percentile": 0.08436}, "CVE-2018-14988": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2018-14989": {"epss_score": 0.00286, "epss_percentile": 0.51693}, "CVE-2018-14990": {"epss_score": 0.00289, "epss_percentile": 0.51984}, "CVE-2018-14991": {"epss_score": 0.00528, "epss_percentile": 0.66577}, "CVE-2018-14992": {"epss_score": 0.00048, "epss_percentile": 0.15056}, "CVE-2018-14993": {"epss_score": 0.00069, "epss_percentile": 0.21431}, "CVE-2018-14994": {"epss_score": 0.00286, "epss_percentile": 0.51693}, "CVE-2018-14995": {"epss_score": 0.00053, "epss_percentile": 0.1675}, "CVE-2018-14996": {"epss_score": 0.00061, "epss_percentile": 0.19423}, "CVE-2018-14997": {"epss_score": 0.00083, "epss_percentile": 0.24789}, "CVE-2018-14998": {"epss_score": 0.00251, "epss_percentile": 0.48313}, "CVE-2018-14999": {"epss_score": 0.00418, "epss_percentile": 0.61295}, "CVE-2018-15000": {"epss_score": 0.00082, "epss_percentile": 0.24436}, "CVE-2018-15001": {"epss_score": 0.00053, "epss_percentile": 0.17039}, "CVE-2018-15002": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2018-15003": {"epss_score": 0.00247, "epss_percentile": 0.47905}, "CVE-2018-15004": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-15005": {"epss_score": 0.00055, "epss_percentile": 0.17419}, "CVE-2018-15006": {"epss_score": 0.00076, "epss_percentile": 0.23226}, "CVE-2018-15007": {"epss_score": 0.00136, "epss_percentile": 0.34166}, "CVE-2018-15120": {"epss_score": 0.08019, "epss_percentile": 0.91833}, "CVE-2018-15121": {"epss_score": 0.00149, "epss_percentile": 0.35994}, "CVE-2018-15122": {"epss_score": 0.0032, "epss_percentile": 0.54597}, "CVE-2018-15123": {"epss_score": 0.00319, "epss_percentile": 0.54529}, "CVE-2018-15124": {"epss_score": 0.00369, "epss_percentile": 0.58254}, "CVE-2018-15125": {"epss_score": 0.0031, "epss_percentile": 0.53801}, "CVE-2018-15126": {"epss_score": 0.059, "epss_percentile": 0.90308}, "CVE-2018-15127": {"epss_score": 0.15138, "epss_percentile": 0.94372}, "CVE-2018-15128": {"epss_score": 0.02284, "epss_percentile": 0.84263}, "CVE-2018-15129": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-15130": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-15131": {"epss_score": 0.02609, "epss_percentile": 0.85232}, "CVE-2018-15132": {"epss_score": 0.02542, "epss_percentile": 0.85053}, "CVE-2018-15133": {"epss_score": 0.84383, "epss_percentile": 0.99287}, "CVE-2018-15136": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2018-15137": {"epss_score": 0.2616, "epss_percentile": 0.96118}, "CVE-2018-15138": {"epss_score": 0.50624, "epss_percentile": 0.97743}, "CVE-2018-15139": {"epss_score": 0.80616, "epss_percentile": 0.99097}, "CVE-2018-15140": {"epss_score": 0.0202, "epss_percentile": 0.83293}, "CVE-2018-15141": {"epss_score": 0.02037, "epss_percentile": 0.83355}, "CVE-2018-15142": {"epss_score": 0.023, "epss_percentile": 0.84307}, "CVE-2018-15143": {"epss_score": 0.00017, "epss_percentile": 0.03405}, "CVE-2018-15144": {"epss_score": 0.00016, "epss_percentile": 0.0285}, "CVE-2018-15145": {"epss_score": 0.00017, "epss_percentile": 0.03405}, "CVE-2018-15146": {"epss_score": 0.00052, "epss_percentile": 0.16602}, "CVE-2018-15147": {"epss_score": 0.00052, "epss_percentile": 0.16602}, "CVE-2018-15148": {"epss_score": 0.00052, "epss_percentile": 0.16602}, "CVE-2018-15149": {"epss_score": 0.00052, "epss_percentile": 0.16602}, "CVE-2018-15150": {"epss_score": 0.00052, "epss_percentile": 0.16602}, "CVE-2018-15151": {"epss_score": 0.00052, "epss_percentile": 0.16602}, "CVE-2018-15152": {"epss_score": 0.09059, "epss_percentile": 0.92383}, "CVE-2018-15153": {"epss_score": 0.69728, "epss_percentile": 0.98601}, "CVE-2018-15154": {"epss_score": 0.08783, "epss_percentile": 0.92253}, "CVE-2018-15155": {"epss_score": 0.07546, "epss_percentile": 0.9153}, "CVE-2018-15156": {"epss_score": 0.07546, "epss_percentile": 0.9153}, "CVE-2018-15157": {"epss_score": 0.00421, "epss_percentile": 0.61486}, "CVE-2018-15158": {"epss_score": 0.00421, "epss_percentile": 0.61486}, "CVE-2018-15159": {"epss_score": 0.00421, "epss_percentile": 0.61486}, "CVE-2018-15160": {"epss_score": 0.00421, "epss_percentile": 0.61486}, "CVE-2018-15161": {"epss_score": 0.00388, "epss_percentile": 0.5936}, "CVE-2018-15168": {"epss_score": 0.01856, "epss_percentile": 0.82568}, "CVE-2018-15169": {"epss_score": 0.00417, "epss_percentile": 0.61236}, "CVE-2018-15172": {"epss_score": 0.101, "epss_percentile": 0.9285}, "CVE-2018-15173": {"epss_score": 0.00801, "epss_percentile": 0.7357}, "CVE-2018-15174": {"epss_score": 0.00234, "epss_percentile": 0.46192}, "CVE-2018-15175": {"epss_score": 0.00234, "epss_percentile": 0.46192}, "CVE-2018-15176": {"epss_score": 0.00234, "epss_percentile": 0.46192}, "CVE-2018-15177": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2018-15178": {"epss_score": 0.0023, "epss_percentile": 0.4567}, "CVE-2018-15180": {"epss_score": 0.0027, "epss_percentile": 0.50257}, "CVE-2018-15181": {"epss_score": 0.00792, "epss_percentile": 0.73405}, "CVE-2018-15182": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-15183": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-15184": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-15185": {"epss_score": 0.00137, "epss_percentile": 0.34242}, "CVE-2018-15186": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-15187": {"epss_score": 0.00135, "epss_percentile": 0.33929}, "CVE-2018-15188": {"epss_score": 0.00137, "epss_percentile": 0.34242}, "CVE-2018-15189": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-15190": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-15191": {"epss_score": 0.00539, "epss_percentile": 0.66974}, "CVE-2018-15192": {"epss_score": 0.00292, "epss_percentile": 0.52241}, "CVE-2018-15193": {"epss_score": 0.00209, "epss_percentile": 0.43333}, "CVE-2018-15197": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2018-15198": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2018-15199": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-15202": {"epss_score": 0.00101, "epss_percentile": 0.28699}, "CVE-2018-15203": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2018-15206": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-15207": {"epss_score": 0.00451, "epss_percentile": 0.63157}, "CVE-2018-15208": {"epss_score": 0.00441, "epss_percentile": 0.62682}, "CVE-2018-15209": {"epss_score": 0.00662, "epss_percentile": 0.70597}, "CVE-2018-15310": {"epss_score": 0.00283, "epss_percentile": 0.51388}, "CVE-2018-15311": {"epss_score": 0.03533, "epss_percentile": 0.87307}, "CVE-2018-15312": {"epss_score": 0.00259, "epss_percentile": 0.49093}, "CVE-2018-15313": {"epss_score": 0.00343, "epss_percentile": 0.56448}, "CVE-2018-15314": {"epss_score": 0.00343, "epss_percentile": 0.56448}, "CVE-2018-15315": {"epss_score": 0.00259, "epss_percentile": 0.49045}, "CVE-2018-15316": {"epss_score": 0.00123, "epss_percentile": 0.32261}, "CVE-2018-15317": {"epss_score": 0.00821, "epss_percentile": 0.73904}, "CVE-2018-15318": {"epss_score": 0.00611, "epss_percentile": 0.69187}, "CVE-2018-15319": {"epss_score": 0.00588, "epss_percentile": 0.68492}, "CVE-2018-15320": {"epss_score": 0.00682, "epss_percentile": 0.71072}, "CVE-2018-15321": {"epss_score": 0.00188, "epss_percentile": 0.40897}, "CVE-2018-15322": {"epss_score": 0.00304, "epss_percentile": 0.5329}, "CVE-2018-15323": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2018-15324": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2018-15325": {"epss_score": 0.00281, "epss_percentile": 0.51106}, "CVE-2018-15326": {"epss_score": 0.00156, "epss_percentile": 0.36969}, "CVE-2018-15327": {"epss_score": 0.00276, "epss_percentile": 0.50739}, "CVE-2018-15328": {"epss_score": 0.02179, "epss_percentile": 0.83892}, "CVE-2018-15329": {"epss_score": 0.00276, "epss_percentile": 0.50739}, "CVE-2018-15330": {"epss_score": 0.00611, "epss_percentile": 0.69187}, "CVE-2018-15331": {"epss_score": 0.00221, "epss_percentile": 0.44685}, "CVE-2018-15332": {"epss_score": 0.00123, "epss_percentile": 0.3229}, "CVE-2018-15333": {"epss_score": 0.00124, "epss_percentile": 0.32346}, "CVE-2018-15334": {"epss_score": 0.00279, "epss_percentile": 0.50924}, "CVE-2018-15335": {"epss_score": 0.0051, "epss_percentile": 0.65767}, "CVE-2018-15350": {"epss_score": 0.00712, "epss_percentile": 0.71749}, "CVE-2018-15351": {"epss_score": 0.00441, "epss_percentile": 0.62671}, "CVE-2018-15352": {"epss_score": 0.0033, "epss_percentile": 0.55495}, "CVE-2018-15353": {"epss_score": 0.03618, "epss_percentile": 0.87438}, "CVE-2018-15354": {"epss_score": 0.00437, "epss_percentile": 0.62506}, "CVE-2018-15355": {"epss_score": 0.0007, "epss_percentile": 0.21775}, "CVE-2018-15356": {"epss_score": 0.00308, "epss_percentile": 0.53572}, "CVE-2018-15357": {"epss_score": 0.00424, "epss_percentile": 0.61678}, "CVE-2018-15358": {"epss_score": 0.005, "epss_percentile": 0.65297}, "CVE-2018-15359": {"epss_score": 0.00527, "epss_percentile": 0.6653}, "CVE-2018-15360": {"epss_score": 0.00104, "epss_percentile": 0.29168}, "CVE-2018-15361": {"epss_score": 0.01304, "epss_percentile": 0.79317}, "CVE-2018-15362": {"epss_score": 0.01566, "epss_percentile": 0.81067}, "CVE-2018-15363": {"epss_score": 0.0006, "epss_percentile": 0.19185}, "CVE-2018-15364": {"epss_score": 0.00111, "epss_percentile": 0.30297}, "CVE-2018-15365": {"epss_score": 0.00602, "epss_percentile": 0.68894}, "CVE-2018-15366": {"epss_score": 0.00105, "epss_percentile": 0.29383}, "CVE-2018-15367": {"epss_score": 0.00111, "epss_percentile": 0.30254}, "CVE-2018-15368": {"epss_score": 0.00112, "epss_percentile": 0.30504}, "CVE-2018-15369": {"epss_score": 0.00187, "epss_percentile": 0.40775}, "CVE-2018-15370": {"epss_score": 0.00071, "epss_percentile": 0.22125}, "CVE-2018-15371": {"epss_score": 0.00048, "epss_percentile": 0.15068}, "CVE-2018-15372": {"epss_score": 0.00228, "epss_percentile": 0.45465}, "CVE-2018-15373": {"epss_score": 0.00252, "epss_percentile": 0.48363}, "CVE-2018-15374": {"epss_score": 0.00032, "epss_percentile": 0.09022}, "CVE-2018-15375": {"epss_score": 0.00062, "epss_percentile": 0.19751}, "CVE-2018-15376": {"epss_score": 0.00062, "epss_percentile": 0.19751}, "CVE-2018-15377": {"epss_score": 0.00578, "epss_percentile": 0.68205}, "CVE-2018-15378": {"epss_score": 0.01696, "epss_percentile": 0.81809}, "CVE-2018-15379": {"epss_score": 0.89824, "epss_percentile": 0.99544}, "CVE-2018-15380": {"epss_score": 0.00165, "epss_percentile": 0.38029}, "CVE-2018-15381": {"epss_score": 0.4291, "epss_percentile": 0.97361}, "CVE-2018-15382": {"epss_score": 0.00676, "epss_percentile": 0.70928}, "CVE-2018-15383": {"epss_score": 0.00941, "epss_percentile": 0.75753}, "CVE-2018-15386": {"epss_score": 0.00258, "epss_percentile": 0.48997}, "CVE-2018-15387": {"epss_score": 0.00161, "epss_percentile": 0.37543}, "CVE-2018-15388": {"epss_score": 0.00436, "epss_percentile": 0.62471}, "CVE-2018-15389": {"epss_score": 0.00808, "epss_percentile": 0.73699}, "CVE-2018-15390": {"epss_score": 0.00351, "epss_percentile": 0.57017}, "CVE-2018-15391": {"epss_score": 0.00503, "epss_percentile": 0.65481}, "CVE-2018-15392": {"epss_score": 0.00104, "epss_percentile": 0.29123}, "CVE-2018-15393": {"epss_score": 0.00087, "epss_percentile": 0.25454}, "CVE-2018-15394": {"epss_score": 0.00141, "epss_percentile": 0.34805}, "CVE-2018-15395": {"epss_score": 0.00116, "epss_percentile": 0.31124}, "CVE-2018-15396": {"epss_score": 0.00613, "epss_percentile": 0.69244}, "CVE-2018-15397": {"epss_score": 0.00244, "epss_percentile": 0.4756}, "CVE-2018-15398": {"epss_score": 0.00317, "epss_percentile": 0.54364}, "CVE-2018-15399": {"epss_score": 0.00453, "epss_percentile": 0.63223}, "CVE-2018-15400": {"epss_score": 0.00319, "epss_percentile": 0.54563}, "CVE-2018-15401": {"epss_score": 0.00155, "epss_percentile": 0.36814}, "CVE-2018-15402": {"epss_score": 0.00095, "epss_percentile": 0.27238}, "CVE-2018-15403": {"epss_score": 0.00158, "epss_percentile": 0.37159}, "CVE-2018-15404": {"epss_score": 0.00475, "epss_percentile": 0.64181}, "CVE-2018-15405": {"epss_score": 0.00119, "epss_percentile": 0.31538}, "CVE-2018-15406": {"epss_score": 0.0036, "epss_percentile": 0.57635}, "CVE-2018-15407": {"epss_score": 0.00061, "epss_percentile": 0.19258}, "CVE-2018-15408": {"epss_score": 0.00224, "epss_percentile": 0.45029}, "CVE-2018-15409": {"epss_score": 0.00407, "epss_percentile": 0.60583}, "CVE-2018-15410": {"epss_score": 0.00218, "epss_percentile": 0.44345}, "CVE-2018-15411": {"epss_score": 0.00218, "epss_percentile": 0.44345}, "CVE-2018-15412": {"epss_score": 0.00224, "epss_percentile": 0.45029}, "CVE-2018-15413": {"epss_score": 0.00224, "epss_percentile": 0.45029}, "CVE-2018-15414": {"epss_score": 0.00224, "epss_percentile": 0.45029}, "CVE-2018-15415": {"epss_score": 0.00224, "epss_percentile": 0.45029}, "CVE-2018-15416": {"epss_score": 0.00224, "epss_percentile": 0.45029}, "CVE-2018-15417": {"epss_score": 0.00224, "epss_percentile": 0.45029}, "CVE-2018-15418": {"epss_score": 0.00218, "epss_percentile": 0.44345}, "CVE-2018-15419": {"epss_score": 0.00218, "epss_percentile": 0.44345}, "CVE-2018-15420": {"epss_score": 0.00224, "epss_percentile": 0.45029}, "CVE-2018-15421": {"epss_score": 0.00218, "epss_percentile": 0.44345}, "CVE-2018-15422": {"epss_score": 0.00218, "epss_percentile": 0.44345}, "CVE-2018-15423": {"epss_score": 0.00105, "epss_percentile": 0.29262}, "CVE-2018-15424": {"epss_score": 0.00226, "epss_percentile": 0.45331}, "CVE-2018-15425": {"epss_score": 0.00294, "epss_percentile": 0.52399}, "CVE-2018-15426": {"epss_score": 0.00176, "epss_percentile": 0.39391}, "CVE-2018-15427": {"epss_score": 0.07516, "epss_percentile": 0.91514}, "CVE-2018-15428": {"epss_score": 0.00541, "epss_percentile": 0.67055}, "CVE-2018-15429": {"epss_score": 0.00385, "epss_percentile": 0.59204}, "CVE-2018-15430": {"epss_score": 0.01581, "epss_percentile": 0.81136}, "CVE-2018-15431": {"epss_score": 0.0009, "epss_percentile": 0.26146}, "CVE-2018-15432": {"epss_score": 0.00152, "epss_percentile": 0.36384}, "CVE-2018-15433": {"epss_score": 0.00152, "epss_percentile": 0.36384}, "CVE-2018-15434": {"epss_score": 0.00319, "epss_percentile": 0.54563}, "CVE-2018-15435": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2018-15436": {"epss_score": 0.00281, "epss_percentile": 0.51101}, "CVE-2018-15437": {"epss_score": 0.00891, "epss_percentile": 0.75053}, "CVE-2018-15438": {"epss_score": 0.00237, "epss_percentile": 0.46645}, "CVE-2018-15439": {"epss_score": 0.40601, "epss_percentile": 0.97225}, "CVE-2018-15440": {"epss_score": 0.00481, "epss_percentile": 0.64515}, "CVE-2018-15441": {"epss_score": 0.00424, "epss_percentile": 0.61663}, "CVE-2018-15442": {"epss_score": 0.47221, "epss_percentile": 0.97577}, "CVE-2018-15443": {"epss_score": 0.00778, "epss_percentile": 0.73136}, "CVE-2018-15444": {"epss_score": 0.01307, "epss_percentile": 0.7934}, "CVE-2018-15445": {"epss_score": 0.00484, "epss_percentile": 0.64648}, "CVE-2018-15446": {"epss_score": 0.01216, "epss_percentile": 0.78594}, "CVE-2018-15447": {"epss_score": 0.01311, "epss_percentile": 0.79368}, "CVE-2018-15448": {"epss_score": 0.01216, "epss_percentile": 0.78594}, "CVE-2018-15449": {"epss_score": 0.00451, "epss_percentile": 0.63125}, "CVE-2018-15450": {"epss_score": 0.0028, "epss_percentile": 0.51083}, "CVE-2018-15451": {"epss_score": 0.00144, "epss_percentile": 0.353}, "CVE-2018-15452": {"epss_score": 0.00066, "epss_percentile": 0.20709}, "CVE-2018-15453": {"epss_score": 0.00286, "epss_percentile": 0.51742}, "CVE-2018-15454": {"epss_score": 0.04645, "epss_percentile": 0.88958}, "CVE-2018-15455": {"epss_score": 0.00215, "epss_percentile": 0.44052}, "CVE-2018-15456": {"epss_score": 0.00141, "epss_percentile": 0.34934}, "CVE-2018-15457": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2018-15458": {"epss_score": 0.04647, "epss_percentile": 0.88961}, "CVE-2018-15459": {"epss_score": 0.0014, "epss_percentile": 0.34721}, "CVE-2018-15460": {"epss_score": 0.00384, "epss_percentile": 0.59175}, "CVE-2018-15461": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2018-15462": {"epss_score": 0.00387, "epss_percentile": 0.59329}, "CVE-2018-15463": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2018-15464": {"epss_score": 0.00454, "epss_percentile": 0.63242}, "CVE-2018-15465": {"epss_score": 0.00289, "epss_percentile": 0.51998}, "CVE-2018-15466": {"epss_score": 0.00605, "epss_percentile": 0.68972}, "CVE-2018-15467": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2018-15468": {"epss_score": 0.00115, "epss_percentile": 0.30971}, "CVE-2018-15469": {"epss_score": 0.00182, "epss_percentile": 0.40229}, "CVE-2018-15470": {"epss_score": 0.00182, "epss_percentile": 0.40229}, "CVE-2018-15471": {"epss_score": 0.00088, "epss_percentile": 0.2569}, "CVE-2018-15472": {"epss_score": 0.00108, "epss_percentile": 0.29832}, "CVE-2018-15473": {"epss_score": 0.89957, "epss_percentile": 0.99553}, "CVE-2018-15474": {"epss_score": 0.01073, "epss_percentile": 0.77292}, "CVE-2018-15476": {"epss_score": 0.00137, "epss_percentile": 0.3424}, "CVE-2018-15477": {"epss_score": 0.0038, "epss_percentile": 0.58969}, "CVE-2018-15478": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2018-15479": {"epss_score": 0.00191, "epss_percentile": 0.41173}, "CVE-2018-15480": {"epss_score": 0.00577, "epss_percentile": 0.68158}, "CVE-2018-15481": {"epss_score": 0.00756, "epss_percentile": 0.72733}, "CVE-2018-15482": {"epss_score": 0.00093, "epss_percentile": 0.26747}, "CVE-2018-15483": {"epss_score": 0.00353, "epss_percentile": 0.57183}, "CVE-2018-15484": {"epss_score": 0.06348, "epss_percentile": 0.90689}, "CVE-2018-15485": {"epss_score": 0.01131, "epss_percentile": 0.7786}, "CVE-2018-15486": {"epss_score": 0.00275, "epss_percentile": 0.50673}, "CVE-2018-15490": {"epss_score": 0.00087, "epss_percentile": 0.25494}, "CVE-2018-15491": {"epss_score": 0.00233, "epss_percentile": 0.46038}, "CVE-2018-15492": {"epss_score": 0.00353, "epss_percentile": 0.57164}, "CVE-2018-15493": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2018-15494": {"epss_score": 0.0064, "epss_percentile": 0.69969}, "CVE-2018-15495": {"epss_score": 0.00414, "epss_percentile": 0.6102}, "CVE-2018-15497": {"epss_score": 0.09355, "epss_percentile": 0.92514}, "CVE-2018-15498": {"epss_score": 0.00482, "epss_percentile": 0.6454}, "CVE-2018-15499": {"epss_score": 0.00727, "epss_percentile": 0.72098}, "CVE-2018-15501": {"epss_score": 0.00342, "epss_percentile": 0.56382}, "CVE-2018-15502": {"epss_score": 0.00258, "epss_percentile": 0.49012}, "CVE-2018-15503": {"epss_score": 0.01465, "epss_percentile": 0.80453}, "CVE-2018-15504": {"epss_score": 0.00416, "epss_percentile": 0.61168}, "CVE-2018-15505": {"epss_score": 0.00147, "epss_percentile": 0.35692}, "CVE-2018-15506": {"epss_score": 0.02879, "epss_percentile": 0.85894}, "CVE-2018-15508": {"epss_score": 0.00667, "epss_percentile": 0.70701}, "CVE-2018-15509": {"epss_score": 0.00482, "epss_percentile": 0.6454}, "CVE-2018-15510": {"epss_score": 0.0012, "epss_percentile": 0.31754}, "CVE-2018-15511": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-15512": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-15513": {"epss_score": 0.00206, "epss_percentile": 0.42787}, "CVE-2018-15514": {"epss_score": 0.03348, "epss_percentile": 0.86956}, "CVE-2018-15515": {"epss_score": 0.0064, "epss_percentile": 0.69977}, "CVE-2018-15516": {"epss_score": 0.02731, "epss_percentile": 0.8554}, "CVE-2018-15517": {"epss_score": 0.76866, "epss_percentile": 0.98909}, "CVE-2018-15518": {"epss_score": 0.02142, "epss_percentile": 0.83753}, "CVE-2018-15519": {"epss_score": 0.00543, "epss_percentile": 0.67119}, "CVE-2018-15520": {"epss_score": 0.00543, "epss_percentile": 0.67119}, "CVE-2018-15528": {"epss_score": 0.00243, "epss_percentile": 0.4743}, "CVE-2018-15529": {"epss_score": 0.22297, "epss_percentile": 0.9562}, "CVE-2018-15530": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-15531": {"epss_score": 0.18991, "epss_percentile": 0.95108}, "CVE-2018-15532": {"epss_score": 0.00153, "epss_percentile": 0.36535}, "CVE-2018-15533": {"epss_score": 0.01004, "epss_percentile": 0.76524}, "CVE-2018-15534": {"epss_score": 0.20056, "epss_percentile": 0.95282}, "CVE-2018-15535": {"epss_score": 0.81247, "epss_percentile": 0.9913}, "CVE-2018-15536": {"epss_score": 0.06618, "epss_percentile": 0.90892}, "CVE-2018-15537": {"epss_score": 0.0229, "epss_percentile": 0.84281}, "CVE-2018-15538": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-15539": {"epss_score": 0.00197, "epss_percentile": 0.41888}, "CVE-2018-15540": {"epss_score": 0.00437, "epss_percentile": 0.62532}, "CVE-2018-15542": {"epss_score": 0.00047, "epss_percentile": 0.14593}, "CVE-2018-15543": {"epss_score": 0.00061, "epss_percentile": 0.19349}, "CVE-2018-15546": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-15552": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2018-15553": {"epss_score": 0.05978, "epss_percentile": 0.90377}, "CVE-2018-15555": {"epss_score": 0.01156, "epss_percentile": 0.781}, "CVE-2018-15556": {"epss_score": 0.02542, "epss_percentile": 0.85052}, "CVE-2018-15557": {"epss_score": 0.02916, "epss_percentile": 0.8598}, "CVE-2018-15559": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-15560": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2018-15562": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-15563": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-15564": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2018-15565": {"epss_score": 0.00096, "epss_percentile": 0.27396}, "CVE-2018-15566": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-15567": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-15568": {"epss_score": 0.00177, "epss_percentile": 0.39555}, "CVE-2018-15569": {"epss_score": 0.00117, "epss_percentile": 0.31326}, "CVE-2018-15570": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-15571": {"epss_score": 0.00486, "epss_percentile": 0.64747}, "CVE-2018-15572": {"epss_score": 0.00074, "epss_percentile": 0.2285}, "CVE-2018-15573": {"epss_score": 0.00716, "epss_percentile": 0.71862}, "CVE-2018-15574": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-15576": {"epss_score": 0.08152, "epss_percentile": 0.91904}, "CVE-2018-15580": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-15581": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-15582": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2018-15583": {"epss_score": 0.00304, "epss_percentile": 0.53273}, "CVE-2018-15584": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2018-15585": {"epss_score": 0.0037, "epss_percentile": 0.58319}, "CVE-2018-15586": {"epss_score": 0.00227, "epss_percentile": 0.45399}, "CVE-2018-15587": {"epss_score": 0.01202, "epss_percentile": 0.78491}, "CVE-2018-15588": {"epss_score": 0.00497, "epss_percentile": 0.65208}, "CVE-2018-15590": {"epss_score": 0.00068, "epss_percentile": 0.21423}, "CVE-2018-15591": {"epss_score": 0.00291, "epss_percentile": 0.52192}, "CVE-2018-15592": {"epss_score": 0.00159, "epss_percentile": 0.37416}, "CVE-2018-15593": {"epss_score": 0.00138, "epss_percentile": 0.34379}, "CVE-2018-15594": {"epss_score": 0.0007, "epss_percentile": 0.21744}, "CVE-2018-15596": {"epss_score": 0.01303, "epss_percentile": 0.79311}, "CVE-2018-15598": {"epss_score": 0.00389, "epss_percentile": 0.59471}, "CVE-2018-15599": {"epss_score": 0.00838, "epss_percentile": 0.74168}, "CVE-2018-15601": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-15602": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-15603": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-15605": {"epss_score": 0.00675, "epss_percentile": 0.7089}, "CVE-2018-15606": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-15607": {"epss_score": 0.00908, "epss_percentile": 0.75288}, "CVE-2018-15608": {"epss_score": 0.015, "epss_percentile": 0.80709}, "CVE-2018-15610": {"epss_score": 0.00617, "epss_percentile": 0.6934}, "CVE-2018-15611": {"epss_score": 0.00034, "epss_percentile": 0.09633}, "CVE-2018-15612": {"epss_score": 0.00116, "epss_percentile": 0.31097}, "CVE-2018-15613": {"epss_score": 0.00247, "epss_percentile": 0.47857}, "CVE-2018-15614": {"epss_score": 0.00197, "epss_percentile": 0.41957}, "CVE-2018-15615": {"epss_score": 0.00056, "epss_percentile": 0.17686}, "CVE-2018-15616": {"epss_score": 0.03691, "epss_percentile": 0.87577}, "CVE-2018-15617": {"epss_score": 0.00375, "epss_percentile": 0.58595}, "CVE-2018-15631": {"epss_score": 0.00211, "epss_percentile": 0.43641}, "CVE-2018-15632": {"epss_score": 0.00576, "epss_percentile": 0.6813}, "CVE-2018-15633": {"epss_score": 0.00288, "epss_percentile": 0.51879}, "CVE-2018-15634": {"epss_score": 0.00288, "epss_percentile": 0.51879}, "CVE-2018-15635": {"epss_score": 0.0029, "epss_percentile": 0.52082}, "CVE-2018-15638": {"epss_score": 0.00211, "epss_percentile": 0.43687}, "CVE-2018-15640": {"epss_score": 0.21442, "epss_percentile": 0.95519}, "CVE-2018-15641": {"epss_score": 0.00206, "epss_percentile": 0.43003}, "CVE-2018-15645": {"epss_score": 0.00202, "epss_percentile": 0.42435}, "CVE-2018-15655": {"epss_score": 0.00334, "epss_percentile": 0.55708}, "CVE-2018-15656": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-15657": {"epss_score": 0.07182, "epss_percentile": 0.91303}, "CVE-2018-15658": {"epss_score": 0.00612, "epss_percentile": 0.69224}, "CVE-2018-15659": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2018-15660": {"epss_score": 0.00297, "epss_percentile": 0.52685}, "CVE-2018-15661": {"epss_score": 0.00314, "epss_percentile": 0.5415}, "CVE-2018-15664": {"epss_score": 0.07851, "epss_percentile": 0.91719}, "CVE-2018-15665": {"epss_score": 0.0035, "epss_percentile": 0.56928}, "CVE-2018-15667": {"epss_score": 0.00232, "epss_percentile": 0.45895}, "CVE-2018-15668": {"epss_score": 0.00295, "epss_percentile": 0.52492}, "CVE-2018-15669": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-15670": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2018-15671": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2018-15676": {"epss_score": 0.00167, "epss_percentile": 0.38352}, "CVE-2018-15677": {"epss_score": 0.00154, "epss_percentile": 0.36674}, "CVE-2018-15678": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-15679": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-15680": {"epss_score": 0.00174, "epss_percentile": 0.39197}, "CVE-2018-15681": {"epss_score": 0.00205, "epss_percentile": 0.42698}, "CVE-2018-15682": {"epss_score": 0.00259, "epss_percentile": 0.49042}, "CVE-2018-15683": {"epss_score": 0.00199, "epss_percentile": 0.42149}, "CVE-2018-15684": {"epss_score": 0.00245, "epss_percentile": 0.47686}, "CVE-2018-15685": {"epss_score": 0.13253, "epss_percentile": 0.93914}, "CVE-2018-15686": {"epss_score": 0.01134, "epss_percentile": 0.77885}, "CVE-2018-15687": {"epss_score": 0.00332, "epss_percentile": 0.55567}, "CVE-2018-15688": {"epss_score": 0.00727, "epss_percentile": 0.72097}, "CVE-2018-15691": {"epss_score": 0.428, "epss_percentile": 0.97354}, "CVE-2018-15692": {"epss_score": 0.00195, "epss_percentile": 0.41692}, "CVE-2018-15693": {"epss_score": 0.00245, "epss_percentile": 0.47668}, "CVE-2018-15694": {"epss_score": 0.02118, "epss_percentile": 0.83667}, "CVE-2018-15695": {"epss_score": 0.00488, "epss_percentile": 0.64858}, "CVE-2018-15696": {"epss_score": 0.0031, "epss_percentile": 0.53753}, "CVE-2018-15697": {"epss_score": 0.00425, "epss_percentile": 0.61688}, "CVE-2018-15698": {"epss_score": 0.00734, "epss_percentile": 0.72236}, "CVE-2018-15699": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-15700": {"epss_score": 0.00176, "epss_percentile": 0.39412}, "CVE-2018-15701": {"epss_score": 0.00221, "epss_percentile": 0.44669}, "CVE-2018-15702": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2018-15703": {"epss_score": 0.00346, "epss_percentile": 0.56635}, "CVE-2018-15704": {"epss_score": 0.12642, "epss_percentile": 0.93737}, "CVE-2018-15705": {"epss_score": 0.06646, "epss_percentile": 0.90913}, "CVE-2018-15706": {"epss_score": 0.00486, "epss_percentile": 0.64767}, "CVE-2018-15707": {"epss_score": 0.01294, "epss_percentile": 0.79243}, "CVE-2018-15708": {"epss_score": 0.91808, "epss_percentile": 0.99668}, "CVE-2018-15709": {"epss_score": 0.11157, "epss_percentile": 0.93249}, "CVE-2018-15710": {"epss_score": 0.78361, "epss_percentile": 0.98983}, "CVE-2018-15711": {"epss_score": 0.31734, "epss_percentile": 0.96643}, "CVE-2018-15712": {"epss_score": 0.26766, "epss_percentile": 0.96178}, "CVE-2018-15713": {"epss_score": 0.03705, "epss_percentile": 0.87597}, "CVE-2018-15714": {"epss_score": 0.21371, "epss_percentile": 0.9551}, "CVE-2018-15715": {"epss_score": 0.014, "epss_percentile": 0.80003}, "CVE-2018-15716": {"epss_score": 0.54044, "epss_percentile": 0.97909}, "CVE-2018-15717": {"epss_score": 0.00096, "epss_percentile": 0.2734}, "CVE-2018-15718": {"epss_score": 0.00412, "epss_percentile": 0.60938}, "CVE-2018-15719": {"epss_score": 0.00305, "epss_percentile": 0.53383}, "CVE-2018-15720": {"epss_score": 0.00817, "epss_percentile": 0.7384}, "CVE-2018-15721": {"epss_score": 0.01104, "epss_percentile": 0.77602}, "CVE-2018-15722": {"epss_score": 0.02393, "epss_percentile": 0.84607}, "CVE-2018-15723": {"epss_score": 0.07318, "epss_percentile": 0.91406}, "CVE-2018-15726": {"epss_score": 0.00152, "epss_percentile": 0.36453}, "CVE-2018-15727": {"epss_score": 0.76773, "epss_percentile": 0.98904}, "CVE-2018-15728": {"epss_score": 0.0142, "epss_percentile": 0.80167}, "CVE-2018-15729": {"epss_score": 0.00085, "epss_percentile": 0.25172}, "CVE-2018-15730": {"epss_score": 0.00085, "epss_percentile": 0.25172}, "CVE-2018-15731": {"epss_score": 0.00085, "epss_percentile": 0.25172}, "CVE-2018-15732": {"epss_score": 0.00064, "epss_percentile": 0.20332}, "CVE-2018-15733": {"epss_score": 0.00085, "epss_percentile": 0.25172}, "CVE-2018-15734": {"epss_score": 0.00064, "epss_percentile": 0.20332}, "CVE-2018-15735": {"epss_score": 0.00064, "epss_percentile": 0.20332}, "CVE-2018-15736": {"epss_score": 0.00085, "epss_percentile": 0.25172}, "CVE-2018-15737": {"epss_score": 0.00085, "epss_percentile": 0.25172}, "CVE-2018-15738": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2018-15740": {"epss_score": 0.00815, "epss_percentile": 0.73783}, "CVE-2018-15745": {"epss_score": 0.91321, "epss_percentile": 0.99634}, "CVE-2018-15746": {"epss_score": 0.00053, "epss_percentile": 0.16955}, "CVE-2018-15747": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2018-15748": {"epss_score": 0.00834, "epss_percentile": 0.74097}, "CVE-2018-15749": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2018-15750": {"epss_score": 0.00917, "epss_percentile": 0.75432}, "CVE-2018-15751": {"epss_score": 0.00657, "epss_percentile": 0.70461}, "CVE-2018-15752": {"epss_score": 0.00136, "epss_percentile": 0.34113}, "CVE-2018-15753": {"epss_score": 0.00371, "epss_percentile": 0.58409}, "CVE-2018-15754": {"epss_score": 0.00393, "epss_percentile": 0.59731}, "CVE-2018-15755": {"epss_score": 0.00565, "epss_percentile": 0.67799}, "CVE-2018-15756": {"epss_score": 0.22777, "epss_percentile": 0.95685}, "CVE-2018-15758": {"epss_score": 0.0038, "epss_percentile": 0.5897}, "CVE-2018-15759": {"epss_score": 0.00324, "epss_percentile": 0.54956}, "CVE-2018-15761": {"epss_score": 0.0053, "epss_percentile": 0.66627}, "CVE-2018-15762": {"epss_score": 0.00222, "epss_percentile": 0.44732}, "CVE-2018-15763": {"epss_score": 0.00229, "epss_percentile": 0.45609}, "CVE-2018-15764": {"epss_score": 0.0954, "epss_percentile": 0.92589}, "CVE-2018-15765": {"epss_score": 0.00145, "epss_percentile": 0.35506}, "CVE-2018-15766": {"epss_score": 0.00111, "epss_percentile": 0.30303}, "CVE-2018-15767": {"epss_score": 0.40344, "epss_percentile": 0.97213}, "CVE-2018-15768": {"epss_score": 0.24235, "epss_percentile": 0.95895}, "CVE-2018-15769": {"epss_score": 0.01484, "epss_percentile": 0.8059}, "CVE-2018-15771": {"epss_score": 0.0008, "epss_percentile": 0.24013}, "CVE-2018-15772": {"epss_score": 0.00149, "epss_percentile": 0.36012}, "CVE-2018-15773": {"epss_score": 0.00034, "epss_percentile": 0.09798}, "CVE-2018-15774": {"epss_score": 0.003, "epss_percentile": 0.52973}, "CVE-2018-15776": {"epss_score": 0.00724, "epss_percentile": 0.72039}, "CVE-2018-15778": {"epss_score": 0.00039, "epss_percentile": 0.11767}, "CVE-2018-15780": {"epss_score": 0.00256, "epss_percentile": 0.48742}, "CVE-2018-15781": {"epss_score": 0.00241, "epss_percentile": 0.47245}, "CVE-2018-15782": {"epss_score": 0.00028, "epss_percentile": 0.07504}, "CVE-2018-15784": {"epss_score": 0.00093, "epss_percentile": 0.26722}, "CVE-2018-15795": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2018-15796": {"epss_score": 0.00438, "epss_percentile": 0.62538}, "CVE-2018-15797": {"epss_score": 0.00338, "epss_percentile": 0.56152}, "CVE-2018-15798": {"epss_score": 0.00562, "epss_percentile": 0.67701}, "CVE-2018-15800": {"epss_score": 0.00292, "epss_percentile": 0.52233}, "CVE-2018-15801": {"epss_score": 0.00124, "epss_percentile": 0.32463}, "CVE-2018-15804": {"epss_score": 0.00318, "epss_percentile": 0.544}, "CVE-2018-15805": {"epss_score": 0.00418, "epss_percentile": 0.61347}, "CVE-2018-15807": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2018-15808": {"epss_score": 0.00773, "epss_percentile": 0.73059}, "CVE-2018-15809": {"epss_score": 0.00039, "epss_percentile": 0.11618}, "CVE-2018-15810": {"epss_score": 0.01052, "epss_percentile": 0.77095}, "CVE-2018-15811": {"epss_score": 0.91142, "epss_percentile": 0.99622}, "CVE-2018-15812": {"epss_score": 0.82374, "epss_percentile": 0.99192}, "CVE-2018-15813": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-15814": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-15815": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-15816": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-15817": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-15818": {"epss_score": 0.00852, "epss_percentile": 0.74416}, "CVE-2018-15819": {"epss_score": 0.00685, "epss_percentile": 0.71139}, "CVE-2018-15820": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-15822": {"epss_score": 0.01526, "epss_percentile": 0.80865}, "CVE-2018-15832": {"epss_score": 0.01612, "epss_percentile": 0.81335}, "CVE-2018-15833": {"epss_score": 0.00187, "epss_percentile": 0.40763}, "CVE-2018-15834": {"epss_score": 0.00146, "epss_percentile": 0.35639}, "CVE-2018-15835": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2018-15836": {"epss_score": 0.00149, "epss_percentile": 0.35964}, "CVE-2018-15839": {"epss_score": 0.69662, "epss_percentile": 0.98597}, "CVE-2018-15840": {"epss_score": 0.0065, "epss_percentile": 0.70268}, "CVE-2018-15842": {"epss_score": 0.0026, "epss_percentile": 0.49193}, "CVE-2018-15843": {"epss_score": 0.00242, "epss_percentile": 0.47365}, "CVE-2018-15844": {"epss_score": 0.00414, "epss_percentile": 0.61022}, "CVE-2018-15845": {"epss_score": 0.00654, "epss_percentile": 0.70356}, "CVE-2018-15846": {"epss_score": 0.00133, "epss_percentile": 0.33682}, "CVE-2018-15847": {"epss_score": 0.00217, "epss_percentile": 0.44303}, "CVE-2018-15848": {"epss_score": 0.00143, "epss_percentile": 0.35173}, "CVE-2018-15849": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2018-15850": {"epss_score": 0.00171, "epss_percentile": 0.38802}, "CVE-2018-15851": {"epss_score": 0.00143, "epss_percentile": 0.35173}, "CVE-2018-15852": {"epss_score": 0.00264, "epss_percentile": 0.49719}, "CVE-2018-15853": {"epss_score": 0.00031, "epss_percentile": 0.08531}, "CVE-2018-15854": {"epss_score": 0.00045, "epss_percentile": 0.14061}, "CVE-2018-15855": {"epss_score": 0.00045, "epss_percentile": 0.14061}, "CVE-2018-15856": {"epss_score": 0.00044, "epss_percentile": 0.1352}, "CVE-2018-15857": {"epss_score": 0.00061, "epss_percentile": 0.19312}, "CVE-2018-15858": {"epss_score": 0.00057, "epss_percentile": 0.18186}, "CVE-2018-15859": {"epss_score": 0.00035, "epss_percentile": 0.10075}, "CVE-2018-15861": {"epss_score": 0.00031, "epss_percentile": 0.08531}, "CVE-2018-15862": {"epss_score": 0.00044, "epss_percentile": 0.13432}, "CVE-2018-15863": {"epss_score": 0.00031, "epss_percentile": 0.08531}, "CVE-2018-15864": {"epss_score": 0.00044, "epss_percentile": 0.13432}, "CVE-2018-15865": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2018-15868": {"epss_score": 0.00739, "epss_percentile": 0.72394}, "CVE-2018-15869": {"epss_score": 0.00553, "epss_percentile": 0.67424}, "CVE-2018-15870": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2018-15871": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2018-15873": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-15874": {"epss_score": 0.00299, "epss_percentile": 0.52882}, "CVE-2018-15875": {"epss_score": 0.00299, "epss_percentile": 0.52882}, "CVE-2018-15876": {"epss_score": 0.00207, "epss_percentile": 0.43189}, "CVE-2018-15877": {"epss_score": 0.82713, "epss_percentile": 0.9921}, "CVE-2018-15880": {"epss_score": 0.00129, "epss_percentile": 0.3317}, "CVE-2018-15881": {"epss_score": 0.00048, "epss_percentile": 0.14968}, "CVE-2018-15882": {"epss_score": 0.0051, "epss_percentile": 0.65808}, "CVE-2018-15884": {"epss_score": 0.00416, "epss_percentile": 0.61164}, "CVE-2018-15885": {"epss_score": 0.00392, "epss_percentile": 0.59692}, "CVE-2018-15886": {"epss_score": 0.00506, "epss_percentile": 0.65631}, "CVE-2018-15887": {"epss_score": 0.07798, "epss_percentile": 0.91688}, "CVE-2018-15888": {"epss_score": 0.00987, "epss_percentile": 0.76339}, "CVE-2018-15890": {"epss_score": 0.00787, "epss_percentile": 0.73302}, "CVE-2018-15891": {"epss_score": 0.00346, "epss_percentile": 0.56624}, "CVE-2018-15892": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2018-15893": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-15894": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-15895": {"epss_score": 0.00371, "epss_percentile": 0.58409}, "CVE-2018-15896": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-15897": {"epss_score": 0.00516, "epss_percentile": 0.66056}, "CVE-2018-15898": {"epss_score": 0.0027, "epss_percentile": 0.50212}, "CVE-2018-15899": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-15901": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2018-15903": {"epss_score": 0.00452, "epss_percentile": 0.6318}, "CVE-2018-15904": {"epss_score": 0.00367, "epss_percentile": 0.58143}, "CVE-2018-15906": {"epss_score": 0.04489, "epss_percentile": 0.88754}, "CVE-2018-15907": {"epss_score": 0.00264, "epss_percentile": 0.49719}, "CVE-2018-15908": {"epss_score": 0.00234, "epss_percentile": 0.46168}, "CVE-2018-15909": {"epss_score": 0.02274, "epss_percentile": 0.84224}, "CVE-2018-15910": {"epss_score": 0.04834, "epss_percentile": 0.89192}, "CVE-2018-15911": {"epss_score": 0.02697, "epss_percentile": 0.85447}, "CVE-2018-15912": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2018-15913": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2018-15917": {"epss_score": 0.00609, "epss_percentile": 0.69089}, "CVE-2018-15918": {"epss_score": 0.0022, "epss_percentile": 0.44607}, "CVE-2018-15919": {"epss_score": 0.02073, "epss_percentile": 0.83494}, "CVE-2018-15920": {"epss_score": 0.0246, "epss_percentile": 0.84823}, "CVE-2018-15922": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-15923": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-15924": {"epss_score": 0.0246, "epss_percentile": 0.84823}, "CVE-2018-15925": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-15926": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-15927": {"epss_score": 0.25364, "epss_percentile": 0.96021}, "CVE-2018-15928": {"epss_score": 0.23883, "epss_percentile": 0.9583}, "CVE-2018-15929": {"epss_score": 0.32809, "epss_percentile": 0.96729}, "CVE-2018-15930": {"epss_score": 0.49476, "epss_percentile": 0.9769}, "CVE-2018-15931": {"epss_score": 0.49476, "epss_percentile": 0.9769}, "CVE-2018-15932": {"epss_score": 0.16393, "epss_percentile": 0.94644}, "CVE-2018-15933": {"epss_score": 0.32809, "epss_percentile": 0.96729}, "CVE-2018-15934": {"epss_score": 0.32809, "epss_percentile": 0.96729}, "CVE-2018-15935": {"epss_score": 0.32809, "epss_percentile": 0.96729}, "CVE-2018-15936": {"epss_score": 0.32809, "epss_percentile": 0.96729}, "CVE-2018-15937": {"epss_score": 0.50371, "epss_percentile": 0.97734}, "CVE-2018-15938": {"epss_score": 0.32809, "epss_percentile": 0.96729}, "CVE-2018-15939": {"epss_score": 0.03711, "epss_percentile": 0.87608}, "CVE-2018-15940": {"epss_score": 0.03711, "epss_percentile": 0.87608}, "CVE-2018-15941": {"epss_score": 0.03711, "epss_percentile": 0.87608}, "CVE-2018-15942": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-15943": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-15944": {"epss_score": 0.03711, "epss_percentile": 0.87608}, "CVE-2018-15945": {"epss_score": 0.03711, "epss_percentile": 0.87608}, "CVE-2018-15946": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-15947": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-15948": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2018-15949": {"epss_score": 0.01535, "epss_percentile": 0.80909}, "CVE-2018-15950": {"epss_score": 0.0183, "epss_percentile": 0.82444}, "CVE-2018-15951": {"epss_score": 0.02857, "epss_percentile": 0.85842}, "CVE-2018-15952": {"epss_score": 0.28759, "epss_percentile": 0.96382}, "CVE-2018-15953": {"epss_score": 0.16463, "epss_percentile": 0.94673}, "CVE-2018-15954": {"epss_score": 0.20517, "epss_percentile": 0.95362}, "CVE-2018-15955": {"epss_score": 0.20435, "epss_percentile": 0.95345}, "CVE-2018-15956": {"epss_score": 0.25364, "epss_percentile": 0.96021}, "CVE-2018-15957": {"epss_score": 0.57069, "epss_percentile": 0.98047}, "CVE-2018-15958": {"epss_score": 0.36302, "epss_percentile": 0.96968}, "CVE-2018-15959": {"epss_score": 0.36302, "epss_percentile": 0.96968}, "CVE-2018-15960": {"epss_score": 0.06484, "epss_percentile": 0.9079}, "CVE-2018-15961": {"epss_score": 0.94422, "epss_percentile": 0.99979}, "CVE-2018-15962": {"epss_score": 0.02012, "epss_percentile": 0.83252}, "CVE-2018-15963": {"epss_score": 0.05211, "epss_percentile": 0.89615}, "CVE-2018-15964": {"epss_score": 0.09037, "epss_percentile": 0.92376}, "CVE-2018-15965": {"epss_score": 0.36302, "epss_percentile": 0.96968}, "CVE-2018-15966": {"epss_score": 0.01508, "epss_percentile": 0.8076}, "CVE-2018-15967": {"epss_score": 0.09983, "epss_percentile": 0.92803}, "CVE-2018-15968": {"epss_score": 0.02633, "epss_percentile": 0.85287}, "CVE-2018-15969": {"epss_score": 0.01145, "epss_percentile": 0.77991}, "CVE-2018-15970": {"epss_score": 0.01145, "epss_percentile": 0.77991}, "CVE-2018-15971": {"epss_score": 0.01145, "epss_percentile": 0.77991}, "CVE-2018-15972": {"epss_score": 0.00982, "epss_percentile": 0.76296}, "CVE-2018-15973": {"epss_score": 0.01011, "epss_percentile": 0.76614}, "CVE-2018-15974": {"epss_score": 0.01914, "epss_percentile": 0.82847}, "CVE-2018-15976": {"epss_score": 0.02148, "epss_percentile": 0.83769}, "CVE-2018-15978": {"epss_score": 0.02064, "epss_percentile": 0.83451}, "CVE-2018-15979": {"epss_score": 0.02199, "epss_percentile": 0.83972}, "CVE-2018-15980": {"epss_score": 0.08191, "epss_percentile": 0.91923}, "CVE-2018-15981": {"epss_score": 0.27143, "epss_percentile": 0.96212}, "CVE-2018-15982": {"epss_score": 0.93817, "epss_percentile": 0.99852}, "CVE-2018-15983": {"epss_score": 0.00525, "epss_percentile": 0.66369}, "CVE-2018-15984": {"epss_score": 0.01517, "epss_percentile": 0.80809}, "CVE-2018-15985": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2018-15986": {"epss_score": 0.01517, "epss_percentile": 0.80809}, "CVE-2018-15987": {"epss_score": 0.02559, "epss_percentile": 0.85101}, "CVE-2018-15988": {"epss_score": 0.03354, "epss_percentile": 0.86971}, "CVE-2018-15989": {"epss_score": 0.01517, "epss_percentile": 0.80809}, "CVE-2018-15990": {"epss_score": 0.02384, "epss_percentile": 0.84576}, "CVE-2018-15991": {"epss_score": 0.02375, "epss_percentile": 0.84542}, "CVE-2018-15992": {"epss_score": 0.02375, "epss_percentile": 0.84542}, "CVE-2018-15993": {"epss_score": 0.02375, "epss_percentile": 0.84542}, "CVE-2018-15994": {"epss_score": 0.02375, "epss_percentile": 0.84542}, "CVE-2018-15995": {"epss_score": 0.01914, "epss_percentile": 0.82851}, "CVE-2018-15996": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2018-15997": {"epss_score": 0.02049, "epss_percentile": 0.83393}, "CVE-2018-15998": {"epss_score": 0.02671, "epss_percentile": 0.85388}, "CVE-2018-15999": {"epss_score": 0.03354, "epss_percentile": 0.86971}, "CVE-2018-16000": {"epss_score": 0.03354, "epss_percentile": 0.86971}, "CVE-2018-16001": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2018-16002": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2018-16003": {"epss_score": 0.02489, "epss_percentile": 0.84893}, "CVE-2018-16004": {"epss_score": 0.14287, "epss_percentile": 0.94179}, "CVE-2018-16005": {"epss_score": 0.01925, "epss_percentile": 0.82924}, "CVE-2018-16006": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2018-16007": {"epss_score": 0.01914, "epss_percentile": 0.82851}, "CVE-2018-16008": {"epss_score": 0.02389, "epss_percentile": 0.84592}, "CVE-2018-16009": {"epss_score": 0.01914, "epss_percentile": 0.82851}, "CVE-2018-16010": {"epss_score": 0.02242, "epss_percentile": 0.84118}, "CVE-2018-16011": {"epss_score": 0.0221, "epss_percentile": 0.84013}, "CVE-2018-16012": {"epss_score": 0.01694, "epss_percentile": 0.81803}, "CVE-2018-16013": {"epss_score": 0.01694, "epss_percentile": 0.81803}, "CVE-2018-16014": {"epss_score": 0.02375, "epss_percentile": 0.84542}, "CVE-2018-16015": {"epss_score": 0.01694, "epss_percentile": 0.81803}, "CVE-2018-16016": {"epss_score": 0.06419, "epss_percentile": 0.90747}, "CVE-2018-16017": {"epss_score": 0.01694, "epss_percentile": 0.81803}, "CVE-2018-16018": {"epss_score": 0.0152, "epss_percentile": 0.80825}, "CVE-2018-16019": {"epss_score": 0.01694, "epss_percentile": 0.81803}, "CVE-2018-16020": {"epss_score": 0.01517, "epss_percentile": 0.80809}, "CVE-2018-16021": {"epss_score": 0.04708, "epss_percentile": 0.89035}, "CVE-2018-16022": {"epss_score": 0.01517, "epss_percentile": 0.80809}, "CVE-2018-16023": {"epss_score": 0.01925, "epss_percentile": 0.82924}, "CVE-2018-16024": {"epss_score": 0.01925, "epss_percentile": 0.82924}, "CVE-2018-16025": {"epss_score": 0.02375, "epss_percentile": 0.84542}, "CVE-2018-16026": {"epss_score": 0.02375, "epss_percentile": 0.84542}, "CVE-2018-16027": {"epss_score": 0.03531, "epss_percentile": 0.87303}, "CVE-2018-16028": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2018-16029": {"epss_score": 0.03531, "epss_percentile": 0.87303}, "CVE-2018-16030": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2018-16031": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2018-16032": {"epss_score": 0.01584, "epss_percentile": 0.81163}, "CVE-2018-16033": {"epss_score": 0.01584, "epss_percentile": 0.81163}, "CVE-2018-16034": {"epss_score": 0.01584, "epss_percentile": 0.81163}, "CVE-2018-16035": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2018-16036": {"epss_score": 0.02017, "epss_percentile": 0.83281}, "CVE-2018-16037": {"epss_score": 0.02017, "epss_percentile": 0.83281}, "CVE-2018-16038": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2018-16039": {"epss_score": 0.02017, "epss_percentile": 0.83281}, "CVE-2018-16040": {"epss_score": 0.02017, "epss_percentile": 0.83281}, "CVE-2018-16041": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2018-16042": {"epss_score": 0.04638, "epss_percentile": 0.88951}, "CVE-2018-16043": {"epss_score": 0.01925, "epss_percentile": 0.82924}, "CVE-2018-16044": {"epss_score": 0.05439, "epss_percentile": 0.89884}, "CVE-2018-16045": {"epss_score": 0.07488, "epss_percentile": 0.91499}, "CVE-2018-16046": {"epss_score": 0.05774, "epss_percentile": 0.90196}, "CVE-2018-16047": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2018-16048": {"epss_score": 0.00098, "epss_percentile": 0.27794}, "CVE-2018-16049": {"epss_score": 0.00208, "epss_percentile": 0.43294}, "CVE-2018-16050": {"epss_score": 0.00069, "epss_percentile": 0.21557}, "CVE-2018-16051": {"epss_score": 0.00096, "epss_percentile": 0.27321}, "CVE-2018-16055": {"epss_score": 0.13502, "epss_percentile": 0.93982}, "CVE-2018-16056": {"epss_score": 0.00527, "epss_percentile": 0.66445}, "CVE-2018-16057": {"epss_score": 0.01278, "epss_percentile": 0.79121}, "CVE-2018-16058": {"epss_score": 0.01051, "epss_percentile": 0.77086}, "CVE-2018-16059": {"epss_score": 0.37052, "epss_percentile": 0.97017}, "CVE-2018-16060": {"epss_score": 0.13448, "epss_percentile": 0.93967}, "CVE-2018-16061": {"epss_score": 0.01286, "epss_percentile": 0.79181}, "CVE-2018-16062": {"epss_score": 0.0009, "epss_percentile": 0.26156}, "CVE-2018-16064": {"epss_score": 0.00103, "epss_percentile": 0.29055}, "CVE-2018-16065": {"epss_score": 0.02399, "epss_percentile": 0.84635}, "CVE-2018-16066": {"epss_score": 0.01413, "epss_percentile": 0.80121}, "CVE-2018-16067": {"epss_score": 0.01303, "epss_percentile": 0.7931}, "CVE-2018-16068": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-16069": {"epss_score": 0.00197, "epss_percentile": 0.41824}, "CVE-2018-16070": {"epss_score": 0.00327, "epss_percentile": 0.55126}, "CVE-2018-16071": {"epss_score": 0.19029, "epss_percentile": 0.95114}, "CVE-2018-16072": {"epss_score": 0.00146, "epss_percentile": 0.35556}, "CVE-2018-16073": {"epss_score": 0.00155, "epss_percentile": 0.36768}, "CVE-2018-16074": {"epss_score": 0.00155, "epss_percentile": 0.36768}, "CVE-2018-16075": {"epss_score": 0.00197, "epss_percentile": 0.41824}, "CVE-2018-16076": {"epss_score": 0.00573, "epss_percentile": 0.68044}, "CVE-2018-16077": {"epss_score": 0.00098, "epss_percentile": 0.27695}, "CVE-2018-16078": {"epss_score": 0.00446, "epss_percentile": 0.62901}, "CVE-2018-16079": {"epss_score": 0.00264, "epss_percentile": 0.49695}, "CVE-2018-16080": {"epss_score": 0.00403, "epss_percentile": 0.60354}, "CVE-2018-16081": {"epss_score": 0.00205, "epss_percentile": 0.42701}, "CVE-2018-16082": {"epss_score": 0.00481, "epss_percentile": 0.64517}, "CVE-2018-16083": {"epss_score": 0.19029, "epss_percentile": 0.95114}, "CVE-2018-16084": {"epss_score": 0.00321, "epss_percentile": 0.5468}, "CVE-2018-16085": {"epss_score": 0.00573, "epss_percentile": 0.68044}, "CVE-2018-16086": {"epss_score": 0.00083, "epss_percentile": 0.24624}, "CVE-2018-16087": {"epss_score": 0.00214, "epss_percentile": 0.43991}, "CVE-2018-16088": {"epss_score": 0.00405, "epss_percentile": 0.60499}, "CVE-2018-16089": {"epss_score": 0.0116, "epss_percentile": 0.78135}, "CVE-2018-16090": {"epss_score": 0.00972, "epss_percentile": 0.76136}, "CVE-2018-16091": {"epss_score": 0.00378, "epss_percentile": 0.58793}, "CVE-2018-16092": {"epss_score": 0.0033, "epss_percentile": 0.55457}, "CVE-2018-16093": {"epss_score": 0.0022, "epss_percentile": 0.4456}, "CVE-2018-16094": {"epss_score": 0.00543, "epss_percentile": 0.67119}, "CVE-2018-16095": {"epss_score": 0.00313, "epss_percentile": 0.54012}, "CVE-2018-16096": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-16097": {"epss_score": 0.00121, "epss_percentile": 0.3201}, "CVE-2018-16098": {"epss_score": 0.00055, "epss_percentile": 0.17383}, "CVE-2018-16115": {"epss_score": 0.00368, "epss_percentile": 0.58179}, "CVE-2018-16116": {"epss_score": 0.00271, "epss_percentile": 0.50339}, "CVE-2018-16117": {"epss_score": 0.04088, "epss_percentile": 0.88229}, "CVE-2018-16118": {"epss_score": 0.00427, "epss_percentile": 0.61878}, "CVE-2018-16119": {"epss_score": 0.42571, "epss_percentile": 0.97341}, "CVE-2018-16130": {"epss_score": 0.2042, "epss_percentile": 0.95341}, "CVE-2018-16131": {"epss_score": 0.01343, "epss_percentile": 0.79605}, "CVE-2018-16132": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2018-16133": {"epss_score": 0.57542, "epss_percentile": 0.98069}, "CVE-2018-16134": {"epss_score": 0.03778, "epss_percentile": 0.87711}, "CVE-2018-16135": {"epss_score": 0.00178, "epss_percentile": 0.39709}, "CVE-2018-16136": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-16137": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2018-16138": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16139": {"epss_score": 0.02063, "epss_percentile": 0.83449}, "CVE-2018-16140": {"epss_score": 0.00322, "epss_percentile": 0.54826}, "CVE-2018-16141": {"epss_score": 0.00314, "epss_percentile": 0.54156}, "CVE-2018-16142": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16144": {"epss_score": 0.23981, "epss_percentile": 0.9584}, "CVE-2018-16145": {"epss_score": 0.01021, "epss_percentile": 0.76748}, "CVE-2018-16146": {"epss_score": 0.11078, "epss_percentile": 0.93212}, "CVE-2018-16147": {"epss_score": 0.00501, "epss_percentile": 0.65333}, "CVE-2018-16148": {"epss_score": 0.00501, "epss_percentile": 0.65333}, "CVE-2018-16149": {"epss_score": 0.00648, "epss_percentile": 0.70222}, "CVE-2018-16150": {"epss_score": 0.00165, "epss_percentile": 0.3814}, "CVE-2018-16151": {"epss_score": 0.0169, "epss_percentile": 0.81775}, "CVE-2018-16152": {"epss_score": 0.0169, "epss_percentile": 0.81775}, "CVE-2018-16153": {"epss_score": 0.00227, "epss_percentile": 0.45379}, "CVE-2018-16156": {"epss_score": 0.1305, "epss_percentile": 0.93858}, "CVE-2018-16157": {"epss_score": 0.00198, "epss_percentile": 0.42035}, "CVE-2018-16158": {"epss_score": 0.70807, "epss_percentile": 0.98642}, "CVE-2018-16159": {"epss_score": 0.70496, "epss_percentile": 0.98634}, "CVE-2018-16160": {"epss_score": 0.00051, "epss_percentile": 0.1614}, "CVE-2018-16161": {"epss_score": 0.00494, "epss_percentile": 0.65087}, "CVE-2018-16162": {"epss_score": 0.00384, "epss_percentile": 0.59129}, "CVE-2018-16163": {"epss_score": 0.00249, "epss_percentile": 0.48083}, "CVE-2018-16164": {"epss_score": 0.002, "epss_percentile": 0.42242}, "CVE-2018-16165": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2018-16166": {"epss_score": 0.00537, "epss_percentile": 0.6692}, "CVE-2018-16167": {"epss_score": 0.87006, "epss_percentile": 0.99408}, "CVE-2018-16168": {"epss_score": 0.00745, "epss_percentile": 0.72519}, "CVE-2018-16169": {"epss_score": 0.00851, "epss_percentile": 0.74395}, "CVE-2018-16170": {"epss_score": 0.00603, "epss_percentile": 0.68934}, "CVE-2018-16171": {"epss_score": 0.01054, "epss_percentile": 0.77112}, "CVE-2018-16172": {"epss_score": 0.00095, "epss_percentile": 0.27154}, "CVE-2018-16173": {"epss_score": 0.00209, "epss_percentile": 0.4338}, "CVE-2018-16174": {"epss_score": 0.00201, "epss_percentile": 0.42353}, "CVE-2018-16175": {"epss_score": 0.00614, "epss_percentile": 0.69272}, "CVE-2018-16176": {"epss_score": 0.00346, "epss_percentile": 0.56611}, "CVE-2018-16177": {"epss_score": 0.00071, "epss_percentile": 0.22157}, "CVE-2018-16178": {"epss_score": 0.0023, "epss_percentile": 0.45726}, "CVE-2018-16179": {"epss_score": 0.00128, "epss_percentile": 0.33}, "CVE-2018-16180": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2018-16181": {"epss_score": 0.00272, "epss_percentile": 0.50359}, "CVE-2018-16182": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2018-16183": {"epss_score": 0.00338, "epss_percentile": 0.56147}, "CVE-2018-16184": {"epss_score": 0.04359, "epss_percentile": 0.88593}, "CVE-2018-16185": {"epss_score": 0.00294, "epss_percentile": 0.52409}, "CVE-2018-16186": {"epss_score": 0.00116, "epss_percentile": 0.31105}, "CVE-2018-16187": {"epss_score": 0.00126, "epss_percentile": 0.32728}, "CVE-2018-16188": {"epss_score": 0.00743, "epss_percentile": 0.7247}, "CVE-2018-16189": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2018-16190": {"epss_score": 0.00294, "epss_percentile": 0.52371}, "CVE-2018-16191": {"epss_score": 0.00308, "epss_percentile": 0.53571}, "CVE-2018-16192": {"epss_score": 0.00095, "epss_percentile": 0.27148}, "CVE-2018-16193": {"epss_score": 0.00288, "epss_percentile": 0.51921}, "CVE-2018-16194": {"epss_score": 0.0059, "epss_percentile": 0.68571}, "CVE-2018-16195": {"epss_score": 0.00315, "epss_percentile": 0.54188}, "CVE-2018-16196": {"epss_score": 0.01899, "epss_percentile": 0.82766}, "CVE-2018-16197": {"epss_score": 0.00095, "epss_percentile": 0.27148}, "CVE-2018-16198": {"epss_score": 0.00255, "epss_percentile": 0.48697}, "CVE-2018-16199": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2018-16200": {"epss_score": 0.00377, "epss_percentile": 0.58716}, "CVE-2018-16201": {"epss_score": 0.00116, "epss_percentile": 0.31105}, "CVE-2018-16202": {"epss_score": 0.01526, "epss_percentile": 0.80863}, "CVE-2018-16203": {"epss_score": 0.00921, "epss_percentile": 0.75481}, "CVE-2018-16204": {"epss_score": 0.0015, "epss_percentile": 0.36142}, "CVE-2018-16205": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2018-16206": {"epss_score": 0.00209, "epss_percentile": 0.4338}, "CVE-2018-16207": {"epss_score": 0.00263, "epss_percentile": 0.49518}, "CVE-2018-16210": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-16216": {"epss_score": 0.0303, "epss_percentile": 0.86246}, "CVE-2018-16217": {"epss_score": 0.06902, "epss_percentile": 0.91104}, "CVE-2018-16218": {"epss_score": 0.00597, "epss_percentile": 0.68747}, "CVE-2018-16219": {"epss_score": 0.00182, "epss_percentile": 0.4019}, "CVE-2018-16220": {"epss_score": 0.00226, "epss_percentile": 0.45249}, "CVE-2018-16221": {"epss_score": 0.00696, "epss_percentile": 0.71383}, "CVE-2018-16222": {"epss_score": 0.00077, "epss_percentile": 0.23285}, "CVE-2018-16223": {"epss_score": 0.00696, "epss_percentile": 0.71397}, "CVE-2018-16224": {"epss_score": 0.01813, "epss_percentile": 0.82374}, "CVE-2018-16225": {"epss_score": 0.00067, "epss_percentile": 0.21032}, "CVE-2018-16226": {"epss_score": 0.00231, "epss_percentile": 0.45772}, "CVE-2018-16227": {"epss_score": 0.04519, "epss_percentile": 0.88797}, "CVE-2018-16228": {"epss_score": 0.02169, "epss_percentile": 0.83864}, "CVE-2018-16229": {"epss_score": 0.0297, "epss_percentile": 0.86092}, "CVE-2018-16230": {"epss_score": 0.00474, "epss_percentile": 0.64165}, "CVE-2018-16231": {"epss_score": 0.00563, "epss_percentile": 0.67718}, "CVE-2018-16232": {"epss_score": 0.38479, "epss_percentile": 0.97102}, "CVE-2018-16233": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16234": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16235": {"epss_score": 0.00356, "epss_percentile": 0.57393}, "CVE-2018-16236": {"epss_score": 0.00258, "epss_percentile": 0.48965}, "CVE-2018-16237": {"epss_score": 0.00255, "epss_percentile": 0.48649}, "CVE-2018-16238": {"epss_score": 0.02151, "epss_percentile": 0.83786}, "CVE-2018-16239": {"epss_score": 0.00441, "epss_percentile": 0.6265}, "CVE-2018-16242": {"epss_score": 0.00069, "epss_percentile": 0.21577}, "CVE-2018-16243": {"epss_score": 0.03502, "epss_percentile": 0.87247}, "CVE-2018-16247": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2018-16248": {"epss_score": 0.00213, "epss_percentile": 0.43885}, "CVE-2018-16249": {"epss_score": 0.00446, "epss_percentile": 0.62911}, "CVE-2018-16250": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-16251": {"epss_score": 0.00235, "epss_percentile": 0.46206}, "CVE-2018-16252": {"epss_score": 0.0092, "epss_percentile": 0.75468}, "CVE-2018-16253": {"epss_score": 0.00165, "epss_percentile": 0.3814}, "CVE-2018-16254": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-16255": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-16256": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16257": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16258": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16259": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16261": {"epss_score": 0.0003, "epss_percentile": 0.08275}, "CVE-2018-16262": {"epss_score": 0.00218, "epss_percentile": 0.44409}, "CVE-2018-16263": {"epss_score": 0.00117, "epss_percentile": 0.31372}, "CVE-2018-16264": {"epss_score": 0.0021, "epss_percentile": 0.43613}, "CVE-2018-16265": {"epss_score": 0.00179, "epss_percentile": 0.3984}, "CVE-2018-16266": {"epss_score": 0.00188, "epss_percentile": 0.40869}, "CVE-2018-16267": {"epss_score": 0.00208, "epss_percentile": 0.43267}, "CVE-2018-16268": {"epss_score": 0.00179, "epss_percentile": 0.3984}, "CVE-2018-16269": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2018-16270": {"epss_score": 0.0036, "epss_percentile": 0.57667}, "CVE-2018-16271": {"epss_score": 0.00189, "epss_percentile": 0.40932}, "CVE-2018-16272": {"epss_score": 0.00366, "epss_percentile": 0.58067}, "CVE-2018-16275": {"epss_score": 0.003, "epss_percentile": 0.52919}, "CVE-2018-16276": {"epss_score": 0.00083, "epss_percentile": 0.24725}, "CVE-2018-16277": {"epss_score": 0.00183, "epss_percentile": 0.40342}, "CVE-2018-16278": {"epss_score": 0.01804, "epss_percentile": 0.82345}, "CVE-2018-16281": {"epss_score": 0.00591, "epss_percentile": 0.68601}, "CVE-2018-16282": {"epss_score": 0.04231, "epss_percentile": 0.88423}, "CVE-2018-16283": {"epss_score": 0.77894, "epss_percentile": 0.98958}, "CVE-2018-16285": {"epss_score": 0.01634, "epss_percentile": 0.81465}, "CVE-2018-16286": {"epss_score": 0.00436, "epss_percentile": 0.62485}, "CVE-2018-16287": {"epss_score": 0.02581, "epss_percentile": 0.85153}, "CVE-2018-16288": {"epss_score": 0.6366, "epss_percentile": 0.98343}, "CVE-2018-16291": {"epss_score": 0.00546, "epss_percentile": 0.67214}, "CVE-2018-16292": {"epss_score": 0.00546, "epss_percentile": 0.67214}, "CVE-2018-16293": {"epss_score": 0.00546, "epss_percentile": 0.67214}, "CVE-2018-16294": {"epss_score": 0.00546, "epss_percentile": 0.67214}, "CVE-2018-16295": {"epss_score": 0.00546, "epss_percentile": 0.67214}, "CVE-2018-16296": {"epss_score": 0.00546, "epss_percentile": 0.67214}, "CVE-2018-16297": {"epss_score": 0.00546, "epss_percentile": 0.67214}, "CVE-2018-16298": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16299": {"epss_score": 0.84841, "epss_percentile": 0.99307}, "CVE-2018-16300": {"epss_score": 0.0028, "epss_percentile": 0.5109}, "CVE-2018-16301": {"epss_score": 0.00064, "epss_percentile": 0.20212}, "CVE-2018-16302": {"epss_score": 0.01332, "epss_percentile": 0.79521}, "CVE-2018-16303": {"epss_score": 0.00594, "epss_percentile": 0.68666}, "CVE-2018-16307": {"epss_score": 0.003, "epss_percentile": 0.52973}, "CVE-2018-16308": {"epss_score": 0.00358, "epss_percentile": 0.57514}, "CVE-2018-16310": {"epss_score": 0.00264, "epss_percentile": 0.49719}, "CVE-2018-16313": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16314": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-16315": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2018-16316": {"epss_score": 0.00168, "epss_percentile": 0.38477}, "CVE-2018-16320": {"epss_score": 0.00845, "epss_percentile": 0.74286}, "CVE-2018-16323": {"epss_score": 0.8778, "epss_percentile": 0.99442}, "CVE-2018-16324": {"epss_score": 0.0035, "epss_percentile": 0.56947}, "CVE-2018-16325": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-16326": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16327": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-16328": {"epss_score": 0.00189, "epss_percentile": 0.40985}, "CVE-2018-16329": {"epss_score": 0.00392, "epss_percentile": 0.59678}, "CVE-2018-16330": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-16331": {"epss_score": 0.00177, "epss_percentile": 0.39553}, "CVE-2018-16332": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-16333": {"epss_score": 0.00647, "epss_percentile": 0.70206}, "CVE-2018-16334": {"epss_score": 0.04126, "epss_percentile": 0.88289}, "CVE-2018-16335": {"epss_score": 0.01698, "epss_percentile": 0.81821}, "CVE-2018-16336": {"epss_score": 0.01056, "epss_percentile": 0.77126}, "CVE-2018-16337": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2018-16338": {"epss_score": 0.00118, "epss_percentile": 0.31461}, "CVE-2018-16339": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2018-16342": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-16343": {"epss_score": 0.03181, "epss_percentile": 0.86582}, "CVE-2018-16344": {"epss_score": 0.00869, "epss_percentile": 0.7469}, "CVE-2018-16345": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-16346": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16347": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-16348": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16349": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16350": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16352": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-16353": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-16354": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-16356": {"epss_score": 0.00642, "epss_percentile": 0.70039}, "CVE-2018-16357": {"epss_score": 0.00642, "epss_percentile": 0.70039}, "CVE-2018-16358": {"epss_score": 0.00203, "epss_percentile": 0.42571}, "CVE-2018-16359": {"epss_score": 0.00117, "epss_percentile": 0.31224}, "CVE-2018-16361": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16362": {"epss_score": 0.00443, "epss_percentile": 0.62757}, "CVE-2018-16363": {"epss_score": 0.00219, "epss_percentile": 0.44467}, "CVE-2018-16364": {"epss_score": 0.02361, "epss_percentile": 0.845}, "CVE-2018-16365": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-16366": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-16367": {"epss_score": 0.00921, "epss_percentile": 0.75482}, "CVE-2018-16368": {"epss_score": 0.00402, "epss_percentile": 0.60314}, "CVE-2018-16369": {"epss_score": 0.00976, "epss_percentile": 0.76207}, "CVE-2018-16370": {"epss_score": 0.01344, "epss_percentile": 0.79612}, "CVE-2018-16371": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16372": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16373": {"epss_score": 0.00263, "epss_percentile": 0.49472}, "CVE-2018-16374": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16375": {"epss_score": 0.00437, "epss_percentile": 0.6249}, "CVE-2018-16376": {"epss_score": 0.00566, "epss_percentile": 0.67835}, "CVE-2018-16379": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16380": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-16381": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16382": {"epss_score": 0.00156, "epss_percentile": 0.36943}, "CVE-2018-16384": {"epss_score": 0.00058, "epss_percentile": 0.18609}, "CVE-2018-16385": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2018-16386": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-16387": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2018-16388": {"epss_score": 0.00774, "epss_percentile": 0.73076}, "CVE-2018-16389": {"epss_score": 0.0028, "epss_percentile": 0.51096}, "CVE-2018-16391": {"epss_score": 0.00144, "epss_percentile": 0.35278}, "CVE-2018-16392": {"epss_score": 0.00144, "epss_percentile": 0.35278}, "CVE-2018-16393": {"epss_score": 0.00144, "epss_percentile": 0.35278}, "CVE-2018-16395": {"epss_score": 0.04424, "epss_percentile": 0.88673}, "CVE-2018-16396": {"epss_score": 0.03288, "epss_percentile": 0.86831}, "CVE-2018-16397": {"epss_score": 0.00374, "epss_percentile": 0.5858}, "CVE-2018-16398": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-16402": {"epss_score": 0.01524, "epss_percentile": 0.80849}, "CVE-2018-16403": {"epss_score": 0.00106, "epss_percentile": 0.29498}, "CVE-2018-16405": {"epss_score": 0.00317, "epss_percentile": 0.54328}, "CVE-2018-16406": {"epss_score": 0.00272, "epss_percentile": 0.50396}, "CVE-2018-16407": {"epss_score": 0.0029, "epss_percentile": 0.52094}, "CVE-2018-16408": {"epss_score": 0.04569, "epss_percentile": 0.88861}, "CVE-2018-16409": {"epss_score": 0.00234, "epss_percentile": 0.46162}, "CVE-2018-16410": {"epss_score": 0.00319, "epss_percentile": 0.5456}, "CVE-2018-16412": {"epss_score": 0.01089, "epss_percentile": 0.77445}, "CVE-2018-16413": {"epss_score": 0.00369, "epss_percentile": 0.5824}, "CVE-2018-16416": {"epss_score": 0.00277, "epss_percentile": 0.50816}, "CVE-2018-16417": {"epss_score": 0.03946, "epss_percentile": 0.87996}, "CVE-2018-16418": {"epss_score": 0.00177, "epss_percentile": 0.39603}, "CVE-2018-16419": {"epss_score": 0.00177, "epss_percentile": 0.39603}, "CVE-2018-16420": {"epss_score": 0.00177, "epss_percentile": 0.39603}, "CVE-2018-16421": {"epss_score": 0.00177, "epss_percentile": 0.39603}, "CVE-2018-16422": {"epss_score": 0.00177, "epss_percentile": 0.39603}, "CVE-2018-16423": {"epss_score": 0.00194, "epss_percentile": 0.41589}, "CVE-2018-16424": {"epss_score": 0.00194, "epss_percentile": 0.41589}, "CVE-2018-16425": {"epss_score": 0.0017, "epss_percentile": 0.38719}, "CVE-2018-16426": {"epss_score": 0.00178, "epss_percentile": 0.39728}, "CVE-2018-16427": {"epss_score": 0.00178, "epss_percentile": 0.39728}, "CVE-2018-16428": {"epss_score": 0.00685, "epss_percentile": 0.71134}, "CVE-2018-16429": {"epss_score": 0.00458, "epss_percentile": 0.63433}, "CVE-2018-16430": {"epss_score": 0.01431, "epss_percentile": 0.8024}, "CVE-2018-16431": {"epss_score": 0.01004, "epss_percentile": 0.76525}, "CVE-2018-16432": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-16435": {"epss_score": 0.0045, "epss_percentile": 0.63087}, "CVE-2018-16436": {"epss_score": 0.00265, "epss_percentile": 0.49837}, "CVE-2018-16437": {"epss_score": 0.00835, "epss_percentile": 0.74113}, "CVE-2018-16438": {"epss_score": 0.00579, "epss_percentile": 0.68232}, "CVE-2018-16444": {"epss_score": 0.00341, "epss_percentile": 0.56317}, "CVE-2018-16445": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-16446": {"epss_score": 0.00869, "epss_percentile": 0.7469}, "CVE-2018-16447": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-16448": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-16449": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2018-16450": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16451": {"epss_score": 0.00474, "epss_percentile": 0.64165}, "CVE-2018-16452": {"epss_score": 0.01235, "epss_percentile": 0.78767}, "CVE-2018-16453": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16454": {"epss_score": 0.00238, "epss_percentile": 0.46837}, "CVE-2018-16455": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16456": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16457": {"epss_score": 0.00248, "epss_percentile": 0.47922}, "CVE-2018-16458": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2018-16459": {"epss_score": 0.00174, "epss_percentile": 0.39195}, "CVE-2018-16460": {"epss_score": 0.03672, "epss_percentile": 0.8754}, "CVE-2018-16461": {"epss_score": 0.01492, "epss_percentile": 0.80637}, "CVE-2018-16462": {"epss_score": 0.02298, "epss_percentile": 0.84301}, "CVE-2018-16463": {"epss_score": 0.00132, "epss_percentile": 0.3352}, "CVE-2018-16464": {"epss_score": 0.00222, "epss_percentile": 0.44844}, "CVE-2018-16465": {"epss_score": 0.00149, "epss_percentile": 0.35966}, "CVE-2018-16466": {"epss_score": 0.00126, "epss_percentile": 0.32687}, "CVE-2018-16467": {"epss_score": 0.00243, "epss_percentile": 0.47424}, "CVE-2018-16468": {"epss_score": 0.00314, "epss_percentile": 0.54141}, "CVE-2018-16469": {"epss_score": 0.00408, "epss_percentile": 0.60678}, "CVE-2018-16470": {"epss_score": 0.00177, "epss_percentile": 0.39581}, "CVE-2018-16471": {"epss_score": 0.00168, "epss_percentile": 0.38426}, "CVE-2018-16472": {"epss_score": 0.00519, "epss_percentile": 0.66166}, "CVE-2018-16473": {"epss_score": 0.00339, "epss_percentile": 0.56186}, "CVE-2018-16474": {"epss_score": 0.00224, "epss_percentile": 0.45072}, "CVE-2018-16475": {"epss_score": 0.00611, "epss_percentile": 0.69198}, "CVE-2018-16476": {"epss_score": 0.00791, "epss_percentile": 0.73385}, "CVE-2018-16477": {"epss_score": 0.0026, "epss_percentile": 0.49218}, "CVE-2018-16478": {"epss_score": 0.00215, "epss_percentile": 0.44087}, "CVE-2018-16479": {"epss_score": 0.00678, "epss_percentile": 0.70972}, "CVE-2018-16480": {"epss_score": 0.0015, "epss_percentile": 0.3608}, "CVE-2018-16481": {"epss_score": 0.0015, "epss_percentile": 0.3608}, "CVE-2018-16482": {"epss_score": 0.0053, "epss_percentile": 0.66615}, "CVE-2018-16483": {"epss_score": 0.00247, "epss_percentile": 0.47903}, "CVE-2018-16484": {"epss_score": 0.00162, "epss_percentile": 0.37682}, "CVE-2018-16485": {"epss_score": 0.00607, "epss_percentile": 0.69058}, "CVE-2018-16486": {"epss_score": 0.00437, "epss_percentile": 0.62491}, "CVE-2018-16487": {"epss_score": 0.00409, "epss_percentile": 0.60736}, "CVE-2018-16489": {"epss_score": 0.00437, "epss_percentile": 0.62491}, "CVE-2018-16490": {"epss_score": 0.00186, "epss_percentile": 0.40595}, "CVE-2018-16491": {"epss_score": 0.00384, "epss_percentile": 0.59134}, "CVE-2018-16492": {"epss_score": 0.02519, "epss_percentile": 0.84998}, "CVE-2018-16493": {"epss_score": 0.00611, "epss_percentile": 0.69198}, "CVE-2018-16494": {"epss_score": 0.00825, "epss_percentile": 0.73945}, "CVE-2018-16495": {"epss_score": 0.00303, "epss_percentile": 0.53175}, "CVE-2018-16496": {"epss_score": 0.0019, "epss_percentile": 0.4111}, "CVE-2018-16497": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2018-16498": {"epss_score": 0.00027, "epss_percentile": 0.07093}, "CVE-2018-16499": {"epss_score": 0.00067, "epss_percentile": 0.21185}, "CVE-2018-16509": {"epss_score": 0.91758, "epss_percentile": 0.99666}, "CVE-2018-16510": {"epss_score": 0.00223, "epss_percentile": 0.44864}, "CVE-2018-16511": {"epss_score": 0.00371, "epss_percentile": 0.58343}, "CVE-2018-16513": {"epss_score": 0.00255, "epss_percentile": 0.48661}, "CVE-2018-16514": {"epss_score": 0.00253, "epss_percentile": 0.48447}, "CVE-2018-16515": {"epss_score": 0.00569, "epss_percentile": 0.6791}, "CVE-2018-16516": {"epss_score": 0.00314, "epss_percentile": 0.54157}, "CVE-2018-16517": {"epss_score": 0.01508, "epss_percentile": 0.80757}, "CVE-2018-16518": {"epss_score": 0.02277, "epss_percentile": 0.84231}, "CVE-2018-16519": {"epss_score": 0.01845, "epss_percentile": 0.82507}, "CVE-2018-16521": {"epss_score": 0.00312, "epss_percentile": 0.53996}, "CVE-2018-16522": {"epss_score": 0.00586, "epss_percentile": 0.68432}, "CVE-2018-16523": {"epss_score": 0.00586, "epss_percentile": 0.68432}, "CVE-2018-16524": {"epss_score": 0.00427, "epss_percentile": 0.61901}, "CVE-2018-16525": {"epss_score": 0.07264, "epss_percentile": 0.91358}, "CVE-2018-16526": {"epss_score": 0.05747, "epss_percentile": 0.90176}, "CVE-2018-16527": {"epss_score": 0.00427, "epss_percentile": 0.61901}, "CVE-2018-16528": {"epss_score": 0.02823, "epss_percentile": 0.85751}, "CVE-2018-16529": {"epss_score": 0.00362, "epss_percentile": 0.57787}, "CVE-2018-16530": {"epss_score": 0.04975, "epss_percentile": 0.89353}, "CVE-2018-16539": {"epss_score": 0.00352, "epss_percentile": 0.57084}, "CVE-2018-16540": {"epss_score": 0.00284, "epss_percentile": 0.51491}, "CVE-2018-16541": {"epss_score": 0.00454, "epss_percentile": 0.63259}, "CVE-2018-16542": {"epss_score": 0.00426, "epss_percentile": 0.6174}, "CVE-2018-16543": {"epss_score": 0.00219, "epss_percentile": 0.44524}, "CVE-2018-16545": {"epss_score": 0.00853, "epss_percentile": 0.74426}, "CVE-2018-16546": {"epss_score": 0.00341, "epss_percentile": 0.56313}, "CVE-2018-16548": {"epss_score": 0.00497, "epss_percentile": 0.65201}, "CVE-2018-16549": {"epss_score": 0.00713, "epss_percentile": 0.71783}, "CVE-2018-16550": {"epss_score": 0.00173, "epss_percentile": 0.39065}, "CVE-2018-16551": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-16552": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2018-16553": {"epss_score": 0.01825, "epss_percentile": 0.82432}, "CVE-2018-16554": {"epss_score": 0.00296, "epss_percentile": 0.52528}, "CVE-2018-16555": {"epss_score": 0.00297, "epss_percentile": 0.52754}, "CVE-2018-16556": {"epss_score": 0.00188, "epss_percentile": 0.40912}, "CVE-2018-16557": {"epss_score": 0.00093, "epss_percentile": 0.2668}, "CVE-2018-16558": {"epss_score": 0.01124, "epss_percentile": 0.77798}, "CVE-2018-16559": {"epss_score": 0.01124, "epss_percentile": 0.77798}, "CVE-2018-16561": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2018-16563": {"epss_score": 0.00491, "epss_percentile": 0.64966}, "CVE-2018-16585": {"epss_score": 0.00496, "epss_percentile": 0.65147}, "CVE-2018-16586": {"epss_score": 0.00583, "epss_percentile": 0.68331}, "CVE-2018-16587": {"epss_score": 0.0049, "epss_percentile": 0.64915}, "CVE-2018-16588": {"epss_score": 0.00044, "epss_percentile": 0.13592}, "CVE-2018-16590": {"epss_score": 0.00704, "epss_percentile": 0.71558}, "CVE-2018-16591": {"epss_score": 0.03934, "epss_percentile": 0.87979}, "CVE-2018-16593": {"epss_score": 0.00278, "epss_percentile": 0.50878}, "CVE-2018-16594": {"epss_score": 0.00151, "epss_percentile": 0.36349}, "CVE-2018-16595": {"epss_score": 0.00136, "epss_percentile": 0.34179}, "CVE-2018-16596": {"epss_score": 0.00355, "epss_percentile": 0.57296}, "CVE-2018-16597": {"epss_score": 0.00088, "epss_percentile": 0.25761}, "CVE-2018-16598": {"epss_score": 0.00268, "epss_percentile": 0.50066}, "CVE-2018-16599": {"epss_score": 0.00427, "epss_percentile": 0.61901}, "CVE-2018-16600": {"epss_score": 0.00427, "epss_percentile": 0.61901}, "CVE-2018-16601": {"epss_score": 0.03278, "epss_percentile": 0.86808}, "CVE-2018-16602": {"epss_score": 0.00427, "epss_percentile": 0.61901}, "CVE-2018-16603": {"epss_score": 0.00427, "epss_percentile": 0.61901}, "CVE-2018-16604": {"epss_score": 0.00506, "epss_percentile": 0.65631}, "CVE-2018-16605": {"epss_score": 0.00379, "epss_percentile": 0.58863}, "CVE-2018-16606": {"epss_score": 0.03343, "epss_percentile": 0.86947}, "CVE-2018-16607": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2018-16608": {"epss_score": 0.00307, "epss_percentile": 0.53497}, "CVE-2018-16613": {"epss_score": 0.0153, "epss_percentile": 0.80885}, "CVE-2018-16618": {"epss_score": 0.16166, "epss_percentile": 0.94586}, "CVE-2018-16619": {"epss_score": 0.00353, "epss_percentile": 0.57157}, "CVE-2018-16620": {"epss_score": 0.00342, "epss_percentile": 0.56366}, "CVE-2018-16621": {"epss_score": 0.00569, "epss_percentile": 0.67929}, "CVE-2018-16622": {"epss_score": 0.00197, "epss_percentile": 0.41866}, "CVE-2018-16623": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16624": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-16625": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16626": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16627": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16628": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-16629": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2018-16630": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16631": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-16632": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16633": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-16634": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2018-16635": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-16636": {"epss_score": 0.00261, "epss_percentile": 0.49281}, "CVE-2018-16637": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-16638": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-16639": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-16640": {"epss_score": 0.00295, "epss_percentile": 0.52495}, "CVE-2018-16641": {"epss_score": 0.00408, "epss_percentile": 0.60658}, "CVE-2018-16642": {"epss_score": 0.00307, "epss_percentile": 0.53526}, "CVE-2018-16643": {"epss_score": 0.00338, "epss_percentile": 0.56116}, "CVE-2018-16644": {"epss_score": 0.00241, "epss_percentile": 0.4727}, "CVE-2018-16645": {"epss_score": 0.0056, "epss_percentile": 0.67647}, "CVE-2018-16646": {"epss_score": 0.00681, "epss_percentile": 0.71047}, "CVE-2018-16647": {"epss_score": 0.00454, "epss_percentile": 0.63265}, "CVE-2018-16648": {"epss_score": 0.00236, "epss_percentile": 0.46425}, "CVE-2018-16650": {"epss_score": 0.00161, "epss_percentile": 0.37523}, "CVE-2018-16651": {"epss_score": 0.0086, "epss_percentile": 0.74529}, "CVE-2018-16653": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16654": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16655": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16656": {"epss_score": 0.0014, "epss_percentile": 0.34739}, "CVE-2018-16657": {"epss_score": 0.00274, "epss_percentile": 0.50514}, "CVE-2018-16658": {"epss_score": 0.00017, "epss_percentile": 0.03299}, "CVE-2018-16659": {"epss_score": 0.02105, "epss_percentile": 0.83623}, "CVE-2018-16660": {"epss_score": 0.65028, "epss_percentile": 0.98401}, "CVE-2018-16663": {"epss_score": 0.0005, "epss_percentile": 0.15937}, "CVE-2018-16664": {"epss_score": 0.0005, "epss_percentile": 0.15937}, "CVE-2018-16665": {"epss_score": 0.00048, "epss_percentile": 0.14989}, "CVE-2018-16666": {"epss_score": 0.0005, "epss_percentile": 0.15937}, "CVE-2018-16667": {"epss_score": 0.00126, "epss_percentile": 0.32727}, "CVE-2018-16668": {"epss_score": 0.43027, "epss_percentile": 0.97366}, "CVE-2018-16669": {"epss_score": 0.00984, "epss_percentile": 0.76316}, "CVE-2018-16670": {"epss_score": 0.45583, "epss_percentile": 0.97492}, "CVE-2018-16671": {"epss_score": 0.42489, "epss_percentile": 0.97334}, "CVE-2018-16672": {"epss_score": 0.01288, "epss_percentile": 0.79204}, "CVE-2018-16703": {"epss_score": 0.00605, "epss_percentile": 0.68987}, "CVE-2018-16704": {"epss_score": 0.00153, "epss_percentile": 0.36618}, "CVE-2018-16705": {"epss_score": 0.00628, "epss_percentile": 0.69656}, "CVE-2018-16706": {"epss_score": 0.03798, "epss_percentile": 0.87737}, "CVE-2018-16709": {"epss_score": 0.008, "epss_percentile": 0.73535}, "CVE-2018-16710": {"epss_score": 0.00661, "epss_percentile": 0.70573}, "CVE-2018-16711": {"epss_score": 0.08722, "epss_percentile": 0.92227}, "CVE-2018-16712": {"epss_score": 0.00917, "epss_percentile": 0.75427}, "CVE-2018-16713": {"epss_score": 0.06153, "epss_percentile": 0.90522}, "CVE-2018-16715": {"epss_score": 0.00241, "epss_percentile": 0.47261}, "CVE-2018-16716": {"epss_score": 0.44536, "epss_percentile": 0.97443}, "CVE-2018-16717": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2018-16718": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16719": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2018-16720": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2018-16721": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2018-16722": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2018-16723": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2018-16724": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-16725": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16726": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-16727": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-16728": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-16729": {"epss_score": 0.00236, "epss_percentile": 0.46385}, "CVE-2018-16730": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16731": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-16732": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2018-16733": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-16736": {"epss_score": 0.00232, "epss_percentile": 0.45937}, "CVE-2018-16737": {"epss_score": 0.00377, "epss_percentile": 0.58691}, "CVE-2018-16738": {"epss_score": 0.00324, "epss_percentile": 0.54947}, "CVE-2018-16739": {"epss_score": 0.00237, "epss_percentile": 0.4669}, "CVE-2018-16741": {"epss_score": 0.00646, "epss_percentile": 0.70145}, "CVE-2018-16742": {"epss_score": 0.00063, "epss_percentile": 0.1999}, "CVE-2018-16743": {"epss_score": 0.00063, "epss_percentile": 0.1999}, "CVE-2018-16744": {"epss_score": 0.00645, "epss_percentile": 0.70126}, "CVE-2018-16745": {"epss_score": 0.00063, "epss_percentile": 0.1999}, "CVE-2018-16749": {"epss_score": 0.00241, "epss_percentile": 0.47327}, "CVE-2018-16750": {"epss_score": 0.00132, "epss_percentile": 0.33511}, "CVE-2018-16752": {"epss_score": 0.49862, "epss_percentile": 0.97709}, "CVE-2018-16758": {"epss_score": 0.00163, "epss_percentile": 0.37791}, "CVE-2018-16759": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16761": {"epss_score": 0.02174, "epss_percentile": 0.83878}, "CVE-2018-16762": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-16763": {"epss_score": 0.93933, "epss_percentile": 0.9987}, "CVE-2018-16764": {"epss_score": 0.00311, "epss_percentile": 0.53863}, "CVE-2018-16765": {"epss_score": 0.00311, "epss_percentile": 0.53863}, "CVE-2018-16766": {"epss_score": 0.00311, "epss_percentile": 0.53863}, "CVE-2018-16767": {"epss_score": 0.00311, "epss_percentile": 0.53863}, "CVE-2018-16768": {"epss_score": 0.00311, "epss_percentile": 0.53863}, "CVE-2018-16769": {"epss_score": 0.00311, "epss_percentile": 0.53863}, "CVE-2018-16770": {"epss_score": 0.00311, "epss_percentile": 0.53863}, "CVE-2018-16771": {"epss_score": 0.01201, "epss_percentile": 0.78484}, "CVE-2018-16772": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16773": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16774": {"epss_score": 0.00523, "epss_percentile": 0.66306}, "CVE-2018-16775": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16776": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-16778": {"epss_score": 0.00315, "epss_percentile": 0.54184}, "CVE-2018-16779": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16780": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-16781": {"epss_score": 0.0065, "epss_percentile": 0.70245}, "CVE-2018-16782": {"epss_score": 0.00414, "epss_percentile": 0.61033}, "CVE-2018-16784": {"epss_score": 0.02891, "epss_percentile": 0.85917}, "CVE-2018-16785": {"epss_score": 0.00676, "epss_percentile": 0.70922}, "CVE-2018-16786": {"epss_score": 0.00206, "epss_percentile": 0.4294}, "CVE-2018-16789": {"epss_score": 0.00895, "epss_percentile": 0.75107}, "CVE-2018-16790": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2018-16791": {"epss_score": 0.00347, "epss_percentile": 0.56787}, "CVE-2018-16792": {"epss_score": 0.00397, "epss_percentile": 0.60032}, "CVE-2018-16793": {"epss_score": 0.00824, "epss_percentile": 0.73934}, "CVE-2018-16794": {"epss_score": 0.00637, "epss_percentile": 0.69887}, "CVE-2018-16795": {"epss_score": 0.00019, "epss_percentile": 0.04325}, "CVE-2018-16796": {"epss_score": 0.00758, "epss_percentile": 0.72775}, "CVE-2018-16797": {"epss_score": 0.01622, "epss_percentile": 0.814}, "CVE-2018-16802": {"epss_score": 0.00971, "epss_percentile": 0.76127}, "CVE-2018-16803": {"epss_score": 0.00479, "epss_percentile": 0.6442}, "CVE-2018-16804": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16805": {"epss_score": 0.00159, "epss_percentile": 0.3742}, "CVE-2018-16806": {"epss_score": 0.00082, "epss_percentile": 0.24467}, "CVE-2018-16807": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2018-16808": {"epss_score": 0.00199, "epss_percentile": 0.42182}, "CVE-2018-16809": {"epss_score": 0.00707, "epss_percentile": 0.71662}, "CVE-2018-16819": {"epss_score": 0.00451, "epss_percentile": 0.63126}, "CVE-2018-16820": {"epss_score": 0.0039, "epss_percentile": 0.59525}, "CVE-2018-16821": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2018-16822": {"epss_score": 0.00419, "epss_percentile": 0.61401}, "CVE-2018-16831": {"epss_score": 0.00378, "epss_percentile": 0.58832}, "CVE-2018-16832": {"epss_score": 0.00161, "epss_percentile": 0.37584}, "CVE-2018-16833": {"epss_score": 0.02674, "epss_percentile": 0.85396}, "CVE-2018-16836": {"epss_score": 0.87379, "epss_percentile": 0.99426}, "CVE-2018-16837": {"epss_score": 0.0004, "epss_percentile": 0.12171}, "CVE-2018-16838": {"epss_score": 0.01054, "epss_percentile": 0.7711}, "CVE-2018-16839": {"epss_score": 0.00293, "epss_percentile": 0.52354}, "CVE-2018-16840": {"epss_score": 0.00277, "epss_percentile": 0.50791}, "CVE-2018-16841": {"epss_score": 0.09418, "epss_percentile": 0.92539}, "CVE-2018-16842": {"epss_score": 0.00126, "epss_percentile": 0.32679}, "CVE-2018-16843": {"epss_score": 0.55541, "epss_percentile": 0.97982}, "CVE-2018-16844": {"epss_score": 0.10883, "epss_percentile": 0.93145}, "CVE-2018-16845": {"epss_score": 0.06332, "epss_percentile": 0.90675}, "CVE-2018-16846": {"epss_score": 0.04603, "epss_percentile": 0.88905}, "CVE-2018-16847": {"epss_score": 0.00091, "epss_percentile": 0.26203}, "CVE-2018-16848": {"epss_score": 0.00286, "epss_percentile": 0.51778}, "CVE-2018-16849": {"epss_score": 0.0014, "epss_percentile": 0.34696}, "CVE-2018-16850": {"epss_score": 0.01537, "epss_percentile": 0.80923}, "CVE-2018-16851": {"epss_score": 0.13555, "epss_percentile": 0.93995}, "CVE-2018-16852": {"epss_score": 0.06397, "epss_percentile": 0.90723}, "CVE-2018-16853": {"epss_score": 0.03579, "epss_percentile": 0.87382}, "CVE-2018-16854": {"epss_score": 0.01457, "epss_percentile": 0.80401}, "CVE-2018-16855": {"epss_score": 0.19834, "epss_percentile": 0.95248}, "CVE-2018-16856": {"epss_score": 0.00267, "epss_percentile": 0.49961}, "CVE-2018-16857": {"epss_score": 0.025, "epss_percentile": 0.84918}, "CVE-2018-16858": {"epss_score": 0.92343, "epss_percentile": 0.9971}, "CVE-2018-16859": {"epss_score": 0.00096, "epss_percentile": 0.27252}, "CVE-2018-16860": {"epss_score": 0.02792, "epss_percentile": 0.8567}, "CVE-2018-16861": {"epss_score": 0.00388, "epss_percentile": 0.59353}, "CVE-2018-16862": {"epss_score": 0.00027, "epss_percentile": 0.06953}, "CVE-2018-16863": {"epss_score": 0.00083, "epss_percentile": 0.24816}, "CVE-2018-16864": {"epss_score": 0.00146, "epss_percentile": 0.35584}, "CVE-2018-16865": {"epss_score": 0.01222, "epss_percentile": 0.7866}, "CVE-2018-16866": {"epss_score": 0.00061, "epss_percentile": 0.19249}, "CVE-2018-16867": {"epss_score": 0.00142, "epss_percentile": 0.34998}, "CVE-2018-16868": {"epss_score": 0.00042, "epss_percentile": 0.1273}, "CVE-2018-16869": {"epss_score": 0.00106, "epss_percentile": 0.29406}, "CVE-2018-16870": {"epss_score": 0.00186, "epss_percentile": 0.40668}, "CVE-2018-16871": {"epss_score": 0.01525, "epss_percentile": 0.80857}, "CVE-2018-16872": {"epss_score": 0.00274, "epss_percentile": 0.50542}, "CVE-2018-16873": {"epss_score": 0.36424, "epss_percentile": 0.96977}, "CVE-2018-16874": {"epss_score": 0.01674, "epss_percentile": 0.81692}, "CVE-2018-16875": {"epss_score": 0.01298, "epss_percentile": 0.79275}, "CVE-2018-16876": {"epss_score": 0.00638, "epss_percentile": 0.69921}, "CVE-2018-16877": {"epss_score": 0.00041, "epss_percentile": 0.1221}, "CVE-2018-16878": {"epss_score": 0.00022, "epss_percentile": 0.05304}, "CVE-2018-16879": {"epss_score": 0.00229, "epss_percentile": 0.45637}, "CVE-2018-16880": {"epss_score": 0.00099, "epss_percentile": 0.27865}, "CVE-2018-16881": {"epss_score": 0.02616, "epss_percentile": 0.85246}, "CVE-2018-16882": {"epss_score": 0.00107, "epss_percentile": 0.29615}, "CVE-2018-16883": {"epss_score": 0.00126, "epss_percentile": 0.32623}, "CVE-2018-16884": {"epss_score": 0.00048, "epss_percentile": 0.15175}, "CVE-2018-16885": {"epss_score": 0.00095, "epss_percentile": 0.27138}, "CVE-2018-16886": {"epss_score": 0.00757, "epss_percentile": 0.72748}, "CVE-2018-16887": {"epss_score": 0.00261, "epss_percentile": 0.4928}, "CVE-2018-16888": {"epss_score": 0.00158, "epss_percentile": 0.37259}, "CVE-2018-16889": {"epss_score": 0.00068, "epss_percentile": 0.2127}, "CVE-2018-16890": {"epss_score": 0.01397, "epss_percentile": 0.79985}, "CVE-2018-16946": {"epss_score": 0.11515, "epss_percentile": 0.9339}, "CVE-2018-16947": {"epss_score": 0.01565, "epss_percentile": 0.81063}, "CVE-2018-16948": {"epss_score": 0.00376, "epss_percentile": 0.58664}, "CVE-2018-16949": {"epss_score": 0.04608, "epss_percentile": 0.88912}, "CVE-2018-16950": {"epss_score": 0.0024, "epss_percentile": 0.47208}, "CVE-2018-16951": {"epss_score": 0.00388, "epss_percentile": 0.59359}, "CVE-2018-16952": {"epss_score": 0.00216, "epss_percentile": 0.44146}, "CVE-2018-16953": {"epss_score": 0.00179, "epss_percentile": 0.3979}, "CVE-2018-16954": {"epss_score": 0.00155, "epss_percentile": 0.36815}, "CVE-2018-16955": {"epss_score": 0.00179, "epss_percentile": 0.3979}, "CVE-2018-16956": {"epss_score": 0.0028, "epss_percentile": 0.51007}, "CVE-2018-16957": {"epss_score": 0.08189, "epss_percentile": 0.9192}, "CVE-2018-16958": {"epss_score": 0.00206, "epss_percentile": 0.43056}, "CVE-2018-16959": {"epss_score": 0.00167, "epss_percentile": 0.38273}, "CVE-2018-16960": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16961": {"epss_score": 0.00394, "epss_percentile": 0.59762}, "CVE-2018-16962": {"epss_score": 0.00653, "epss_percentile": 0.70331}, "CVE-2018-16965": {"epss_score": 0.0133, "epss_percentile": 0.79513}, "CVE-2018-16966": {"epss_score": 0.00242, "epss_percentile": 0.47361}, "CVE-2018-16967": {"epss_score": 0.00361, "epss_percentile": 0.57738}, "CVE-2018-16968": {"epss_score": 0.03545, "epss_percentile": 0.87325}, "CVE-2018-16969": {"epss_score": 0.00222, "epss_percentile": 0.44786}, "CVE-2018-16970": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2018-16971": {"epss_score": 0.00138, "epss_percentile": 0.34344}, "CVE-2018-16974": {"epss_score": 0.00258, "epss_percentile": 0.48952}, "CVE-2018-16975": {"epss_score": 0.00604, "epss_percentile": 0.68941}, "CVE-2018-16976": {"epss_score": 0.00232, "epss_percentile": 0.45876}, "CVE-2018-16977": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2018-16978": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-16979": {"epss_score": 0.0833, "epss_percentile": 0.91993}, "CVE-2018-16980": {"epss_score": 0.00308, "epss_percentile": 0.53591}, "CVE-2018-16981": {"epss_score": 0.00344, "epss_percentile": 0.56517}, "CVE-2018-16982": {"epss_score": 0.00297, "epss_percentile": 0.52767}, "CVE-2018-16983": {"epss_score": 0.00396, "epss_percentile": 0.59923}, "CVE-2018-16984": {"epss_score": 0.00769, "epss_percentile": 0.72985}, "CVE-2018-16985": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2018-16986": {"epss_score": 0.04346, "epss_percentile": 0.88574}, "CVE-2018-16987": {"epss_score": 0.00796, "epss_percentile": 0.73489}, "CVE-2018-16988": {"epss_score": 0.00305, "epss_percentile": 0.53347}, "CVE-2018-16994": {"epss_score": 0.00873, "epss_percentile": 0.74742}, "CVE-2018-16999": {"epss_score": 0.00301, "epss_percentile": 0.53002}, "CVE-2018-17000": {"epss_score": 0.01208, "epss_percentile": 0.78534}, "CVE-2018-17001": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-17002": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-17003": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-17004": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17005": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17006": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17007": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17008": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17009": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17010": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17011": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17012": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17013": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17014": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17015": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17016": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17017": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17018": {"epss_score": 0.0052, "epss_percentile": 0.66209}, "CVE-2018-17019": {"epss_score": 0.00423, "epss_percentile": 0.61617}, "CVE-2018-17020": {"epss_score": 0.0072, "epss_percentile": 0.71965}, "CVE-2018-17021": {"epss_score": 0.0026, "epss_percentile": 0.49217}, "CVE-2018-17022": {"epss_score": 0.00683, "epss_percentile": 0.71098}, "CVE-2018-17023": {"epss_score": 0.00168, "epss_percentile": 0.38502}, "CVE-2018-17024": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-17025": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17026": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-17030": {"epss_score": 0.02417, "epss_percentile": 0.84691}, "CVE-2018-17031": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17034": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17035": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-17036": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2018-17037": {"epss_score": 0.00377, "epss_percentile": 0.58692}, "CVE-2018-17039": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17042": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-17043": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2018-17044": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-17045": {"epss_score": 0.00118, "epss_percentile": 0.31461}, "CVE-2018-17046": {"epss_score": 0.00247, "epss_percentile": 0.47854}, "CVE-2018-17048": {"epss_score": 0.00317, "epss_percentile": 0.54315}, "CVE-2018-17049": {"epss_score": 0.0028, "epss_percentile": 0.51042}, "CVE-2018-17050": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-17051": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-17053": {"epss_score": 0.00027, "epss_percentile": 0.07095}, "CVE-2018-17054": {"epss_score": 0.00027, "epss_percentile": 0.07095}, "CVE-2018-17055": {"epss_score": 0.00302, "epss_percentile": 0.53162}, "CVE-2018-17056": {"epss_score": 0.00042, "epss_percentile": 0.12884}, "CVE-2018-17057": {"epss_score": 0.59386, "epss_percentile": 0.98162}, "CVE-2018-17058": {"epss_score": 0.00208, "epss_percentile": 0.43225}, "CVE-2018-17060": {"epss_score": 0.00222, "epss_percentile": 0.44842}, "CVE-2018-17061": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-17062": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17063": {"epss_score": 0.14541, "epss_percentile": 0.94237}, "CVE-2018-17064": {"epss_score": 0.14541, "epss_percentile": 0.94237}, "CVE-2018-17065": {"epss_score": 0.007, "epss_percentile": 0.71474}, "CVE-2018-17066": {"epss_score": 0.2949, "epss_percentile": 0.96448}, "CVE-2018-17067": {"epss_score": 0.007, "epss_percentile": 0.71474}, "CVE-2018-17068": {"epss_score": 0.14541, "epss_percentile": 0.94237}, "CVE-2018-17069": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2018-17070": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2018-17071": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-17072": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-17073": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2018-17074": {"epss_score": 0.0026, "epss_percentile": 0.49181}, "CVE-2018-17075": {"epss_score": 0.00716, "epss_percentile": 0.71869}, "CVE-2018-17076": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2018-17077": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-17079": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-17081": {"epss_score": 0.00209, "epss_percentile": 0.43384}, "CVE-2018-17082": {"epss_score": 0.081, "epss_percentile": 0.91878}, "CVE-2018-17085": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17086": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17088": {"epss_score": 0.00255, "epss_percentile": 0.48662}, "CVE-2018-17090": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-17091": {"epss_score": 0.00159, "epss_percentile": 0.37412}, "CVE-2018-17092": {"epss_score": 0.00162, "epss_percentile": 0.37639}, "CVE-2018-17095": {"epss_score": 0.18183, "epss_percentile": 0.94971}, "CVE-2018-17096": {"epss_score": 0.00902, "epss_percentile": 0.75187}, "CVE-2018-17097": {"epss_score": 0.00911, "epss_percentile": 0.75332}, "CVE-2018-17098": {"epss_score": 0.01606, "epss_percentile": 0.81297}, "CVE-2018-17100": {"epss_score": 0.00374, "epss_percentile": 0.58571}, "CVE-2018-17101": {"epss_score": 0.00525, "epss_percentile": 0.66378}, "CVE-2018-17102": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2018-17103": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-17104": {"epss_score": 0.0022, "epss_percentile": 0.44605}, "CVE-2018-17106": {"epss_score": 0.00251, "epss_percentile": 0.48276}, "CVE-2018-17107": {"epss_score": 0.00519, "epss_percentile": 0.66172}, "CVE-2018-17108": {"epss_score": 0.00366, "epss_percentile": 0.58094}, "CVE-2018-17110": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-17111": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-17113": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2018-17125": {"epss_score": 0.00332, "epss_percentile": 0.55597}, "CVE-2018-17126": {"epss_score": 0.02731, "epss_percentile": 0.85539}, "CVE-2018-17127": {"epss_score": 0.00962, "epss_percentile": 0.75997}, "CVE-2018-17128": {"epss_score": 0.01121, "epss_percentile": 0.77772}, "CVE-2018-17129": {"epss_score": 0.00299, "epss_percentile": 0.52848}, "CVE-2018-17130": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2018-17131": {"epss_score": 0.0042, "epss_percentile": 0.61442}, "CVE-2018-17132": {"epss_score": 0.0042, "epss_percentile": 0.61442}, "CVE-2018-17133": {"epss_score": 0.0042, "epss_percentile": 0.61442}, "CVE-2018-17134": {"epss_score": 0.0042, "epss_percentile": 0.61442}, "CVE-2018-17136": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-17137": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-17138": {"epss_score": 0.00149, "epss_percentile": 0.36004}, "CVE-2018-17139": {"epss_score": 0.04246, "epss_percentile": 0.88442}, "CVE-2018-17140": {"epss_score": 0.00149, "epss_percentile": 0.36004}, "CVE-2018-17141": {"epss_score": 0.06165, "epss_percentile": 0.90527}, "CVE-2018-17142": {"epss_score": 0.00747, "epss_percentile": 0.72561}, "CVE-2018-17143": {"epss_score": 0.0065, "epss_percentile": 0.70271}, "CVE-2018-17144": {"epss_score": 0.51467, "epss_percentile": 0.9778}, "CVE-2018-17145": {"epss_score": 0.01133, "epss_percentile": 0.77884}, "CVE-2018-17146": {"epss_score": 0.03026, "epss_percentile": 0.8624}, "CVE-2018-17147": {"epss_score": 0.03198, "epss_percentile": 0.86616}, "CVE-2018-17148": {"epss_score": 0.00262, "epss_percentile": 0.49364}, "CVE-2018-17150": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-17151": {"epss_score": 0.00212, "epss_percentile": 0.43818}, "CVE-2018-17152": {"epss_score": 0.00212, "epss_percentile": 0.43818}, "CVE-2018-17153": {"epss_score": 0.92205, "epss_percentile": 0.997}, "CVE-2018-17154": {"epss_score": 0.0004, "epss_percentile": 0.12169}, "CVE-2018-17155": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2018-17156": {"epss_score": 0.00382, "epss_percentile": 0.59047}, "CVE-2018-17157": {"epss_score": 0.12118, "epss_percentile": 0.9357}, "CVE-2018-17158": {"epss_score": 0.05265, "epss_percentile": 0.89673}, "CVE-2018-17159": {"epss_score": 0.05265, "epss_percentile": 0.89673}, "CVE-2018-17160": {"epss_score": 0.00791, "epss_percentile": 0.7339}, "CVE-2018-17161": {"epss_score": 0.01958, "epss_percentile": 0.83046}, "CVE-2018-17167": {"epss_score": 0.0042, "epss_percentile": 0.61413}, "CVE-2018-17168": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2018-17169": {"epss_score": 0.00478, "epss_percentile": 0.64396}, "CVE-2018-17170": {"epss_score": 0.02918, "epss_percentile": 0.85987}, "CVE-2018-17172": {"epss_score": 0.02036, "epss_percentile": 0.83353}, "CVE-2018-17173": {"epss_score": 0.76568, "epss_percentile": 0.98896}, "CVE-2018-17174": {"epss_score": 0.00432, "epss_percentile": 0.62103}, "CVE-2018-17175": {"epss_score": 0.00189, "epss_percentile": 0.4096}, "CVE-2018-17176": {"epss_score": 0.00314, "epss_percentile": 0.54144}, "CVE-2018-17177": {"epss_score": 0.00019, "epss_percentile": 0.04205}, "CVE-2018-17178": {"epss_score": 0.00096, "epss_percentile": 0.27375}, "CVE-2018-17179": {"epss_score": 0.11666, "epss_percentile": 0.93439}, "CVE-2018-17180": {"epss_score": 0.00098, "epss_percentile": 0.2779}, "CVE-2018-17181": {"epss_score": 0.00012, "epss_percentile": 0.01426}, "CVE-2018-17182": {"epss_score": 0.03392, "epss_percentile": 0.87053}, "CVE-2018-17183": {"epss_score": 0.00771, "epss_percentile": 0.73026}, "CVE-2018-17184": {"epss_score": 0.01003, "epss_percentile": 0.76516}, "CVE-2018-17186": {"epss_score": 0.00616, "epss_percentile": 0.69339}, "CVE-2018-17187": {"epss_score": 0.00488, "epss_percentile": 0.64859}, "CVE-2018-17188": {"epss_score": 0.02825, "epss_percentile": 0.85756}, "CVE-2018-17189": {"epss_score": 0.04393, "epss_percentile": 0.88637}, "CVE-2018-17190": {"epss_score": 0.0121, "epss_percentile": 0.78547}, "CVE-2018-17191": {"epss_score": 0.03031, "epss_percentile": 0.8625}, "CVE-2018-17192": {"epss_score": 0.00321, "epss_percentile": 0.54641}, "CVE-2018-17193": {"epss_score": 0.0114, "epss_percentile": 0.77949}, "CVE-2018-17194": {"epss_score": 0.01215, "epss_percentile": 0.7859}, "CVE-2018-17195": {"epss_score": 0.00202, "epss_percentile": 0.42427}, "CVE-2018-17196": {"epss_score": 0.00381, "epss_percentile": 0.58985}, "CVE-2018-17197": {"epss_score": 0.02312, "epss_percentile": 0.84342}, "CVE-2018-17198": {"epss_score": 0.00468, "epss_percentile": 0.63879}, "CVE-2018-17199": {"epss_score": 0.10294, "epss_percentile": 0.92931}, "CVE-2018-17200": {"epss_score": 0.02972, "epss_percentile": 0.86095}, "CVE-2018-17201": {"epss_score": 0.02687, "epss_percentile": 0.85432}, "CVE-2018-17202": {"epss_score": 0.02054, "epss_percentile": 0.83419}, "CVE-2018-17204": {"epss_score": 0.01127, "epss_percentile": 0.77822}, "CVE-2018-17205": {"epss_score": 0.00771, "epss_percentile": 0.73021}, "CVE-2018-17206": {"epss_score": 0.02077, "epss_percentile": 0.83514}, "CVE-2018-17207": {"epss_score": 0.91343, "epss_percentile": 0.99636}, "CVE-2018-17208": {"epss_score": 0.16694, "epss_percentile": 0.94716}, "CVE-2018-17210": {"epss_score": 0.00264, "epss_percentile": 0.49551}, "CVE-2018-17211": {"epss_score": 0.03119, "epss_percentile": 0.86443}, "CVE-2018-17213": {"epss_score": 0.0064, "epss_percentile": 0.69966}, "CVE-2018-17215": {"epss_score": 0.00216, "epss_percentile": 0.442}, "CVE-2018-17216": {"epss_score": 0.00384, "epss_percentile": 0.59179}, "CVE-2018-17217": {"epss_score": 0.00184, "epss_percentile": 0.40402}, "CVE-2018-17218": {"epss_score": 0.00337, "epss_percentile": 0.56038}, "CVE-2018-17228": {"epss_score": 0.02154, "epss_percentile": 0.83796}, "CVE-2018-17229": {"epss_score": 0.00547, "epss_percentile": 0.67229}, "CVE-2018-17230": {"epss_score": 0.00547, "epss_percentile": 0.67229}, "CVE-2018-17231": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-17232": {"epss_score": 0.00444, "epss_percentile": 0.62837}, "CVE-2018-17233": {"epss_score": 0.00371, "epss_percentile": 0.58385}, "CVE-2018-17234": {"epss_score": 0.00101, "epss_percentile": 0.28693}, "CVE-2018-17235": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2018-17236": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2018-17237": {"epss_score": 0.00138, "epss_percentile": 0.34373}, "CVE-2018-17240": {"epss_score": 0.31015, "epss_percentile": 0.96583}, "CVE-2018-17243": {"epss_score": 0.07391, "epss_percentile": 0.91449}, "CVE-2018-17244": {"epss_score": 0.00863, "epss_percentile": 0.74588}, "CVE-2018-17245": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2018-17246": {"epss_score": 0.93783, "epss_percentile": 0.99845}, "CVE-2018-17247": {"epss_score": 0.00294, "epss_percentile": 0.52395}, "CVE-2018-17254": {"epss_score": 0.89425, "epss_percentile": 0.99525}, "CVE-2018-17256": {"epss_score": 0.00387, "epss_percentile": 0.59312}, "CVE-2018-17281": {"epss_score": 0.80258, "epss_percentile": 0.99078}, "CVE-2018-17282": {"epss_score": 0.00527, "epss_percentile": 0.66521}, "CVE-2018-17283": {"epss_score": 0.28841, "epss_percentile": 0.96394}, "CVE-2018-17287": {"epss_score": 0.0007, "epss_percentile": 0.21949}, "CVE-2018-17288": {"epss_score": 0.0042, "epss_percentile": 0.61413}, "CVE-2018-17289": {"epss_score": 0.00478, "epss_percentile": 0.64396}, "CVE-2018-17292": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-17293": {"epss_score": 0.00319, "epss_percentile": 0.54495}, "CVE-2018-17294": {"epss_score": 0.0051, "epss_percentile": 0.65765}, "CVE-2018-17297": {"epss_score": 0.00544, "epss_percentile": 0.67129}, "CVE-2018-17298": {"epss_score": 0.00384, "epss_percentile": 0.59172}, "CVE-2018-17300": {"epss_score": 0.00295, "epss_percentile": 0.52469}, "CVE-2018-17301": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-17302": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-17305": {"epss_score": 0.01805, "epss_percentile": 0.82348}, "CVE-2018-17309": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-17310": {"epss_score": 0.00651, "epss_percentile": 0.70294}, "CVE-2018-17311": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-17312": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-17313": {"epss_score": 0.00651, "epss_percentile": 0.70294}, "CVE-2018-17314": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-17315": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-17316": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-17317": {"epss_score": 0.04947, "epss_percentile": 0.89319}, "CVE-2018-17320": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17321": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17322": {"epss_score": 0.00208, "epss_percentile": 0.43222}, "CVE-2018-17332": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-17333": {"epss_score": 0.0086, "epss_percentile": 0.74532}, "CVE-2018-17334": {"epss_score": 0.01022, "epss_percentile": 0.76762}, "CVE-2018-17336": {"epss_score": 0.00344, "epss_percentile": 0.56481}, "CVE-2018-17337": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17338": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2018-17341": {"epss_score": 0.00461, "epss_percentile": 0.6356}, "CVE-2018-17358": {"epss_score": 0.00447, "epss_percentile": 0.62947}, "CVE-2018-17359": {"epss_score": 0.00314, "epss_percentile": 0.54145}, "CVE-2018-17360": {"epss_score": 0.00439, "epss_percentile": 0.62599}, "CVE-2018-17361": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-17364": {"epss_score": 0.00722, "epss_percentile": 0.71992}, "CVE-2018-17365": {"epss_score": 0.01227, "epss_percentile": 0.78703}, "CVE-2018-17366": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2018-17368": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2018-17369": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-17374": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2018-17375": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17376": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17377": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17378": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17379": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17380": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17381": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-17382": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17383": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17384": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17385": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17386": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-17387": {"epss_score": 0.00183, "epss_percentile": 0.40355}, "CVE-2018-17388": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-17389": {"epss_score": 0.00183, "epss_percentile": 0.40355}, "CVE-2018-17391": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17393": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-17394": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17397": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-17398": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2018-17399": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2018-17400": {"epss_score": 0.00063, "epss_percentile": 0.19813}, "CVE-2018-17401": {"epss_score": 0.00324, "epss_percentile": 0.54975}, "CVE-2018-17402": {"epss_score": 0.00334, "epss_percentile": 0.55708}, "CVE-2018-17403": {"epss_score": 0.00366, "epss_percentile": 0.58094}, "CVE-2018-17404": {"epss_score": 0.00334, "epss_percentile": 0.55708}, "CVE-2018-17407": {"epss_score": 0.01357, "epss_percentile": 0.79724}, "CVE-2018-17408": {"epss_score": 0.6203, "epss_percentile": 0.98274}, "CVE-2018-17410": {"epss_score": 0.00248, "epss_percentile": 0.47989}, "CVE-2018-17411": {"epss_score": 0.00663, "epss_percentile": 0.70614}, "CVE-2018-17412": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-17413": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17414": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2018-17415": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2018-17416": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2018-17418": {"epss_score": 0.14496, "epss_percentile": 0.94223}, "CVE-2018-17419": {"epss_score": 0.00386, "epss_percentile": 0.59235}, "CVE-2018-17420": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2018-17421": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17422": {"epss_score": 0.10795, "epss_percentile": 0.93105}, "CVE-2018-17423": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-17425": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-17426": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-17427": {"epss_score": 0.00421, "epss_percentile": 0.61486}, "CVE-2018-17428": {"epss_score": 0.01486, "epss_percentile": 0.80603}, "CVE-2018-17429": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-17431": {"epss_score": 0.9241, "epss_percentile": 0.99713}, "CVE-2018-17432": {"epss_score": 0.00759, "epss_percentile": 0.72794}, "CVE-2018-17433": {"epss_score": 0.00367, "epss_percentile": 0.58134}, "CVE-2018-17434": {"epss_score": 0.00273, "epss_percentile": 0.50468}, "CVE-2018-17435": {"epss_score": 0.00809, "epss_percentile": 0.73703}, "CVE-2018-17436": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2018-17437": {"epss_score": 0.00101, "epss_percentile": 0.28693}, "CVE-2018-17438": {"epss_score": 0.00605, "epss_percentile": 0.68997}, "CVE-2018-17439": {"epss_score": 0.00686, "epss_percentile": 0.71162}, "CVE-2018-17440": {"epss_score": 0.15176, "epss_percentile": 0.94379}, "CVE-2018-17441": {"epss_score": 0.39102, "epss_percentile": 0.97139}, "CVE-2018-17442": {"epss_score": 0.07008, "epss_percentile": 0.91182}, "CVE-2018-17443": {"epss_score": 0.39102, "epss_percentile": 0.97139}, "CVE-2018-17444": {"epss_score": 0.04147, "epss_percentile": 0.88315}, "CVE-2018-17445": {"epss_score": 0.04521, "epss_percentile": 0.88799}, "CVE-2018-17446": {"epss_score": 0.00504, "epss_percentile": 0.65526}, "CVE-2018-17447": {"epss_score": 0.00342, "epss_percentile": 0.56366}, "CVE-2018-17448": {"epss_score": 0.00608, "epss_percentile": 0.69082}, "CVE-2018-17449": {"epss_score": 0.0011, "epss_percentile": 0.30221}, "CVE-2018-17450": {"epss_score": 0.00125, "epss_percentile": 0.32505}, "CVE-2018-17451": {"epss_score": 0.00103, "epss_percentile": 0.28958}, "CVE-2018-17452": {"epss_score": 0.00133, "epss_percentile": 0.33672}, "CVE-2018-17453": {"epss_score": 0.00207, "epss_percentile": 0.43087}, "CVE-2018-17454": {"epss_score": 0.00238, "epss_percentile": 0.46764}, "CVE-2018-17455": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2018-17456": {"epss_score": 0.62494, "epss_percentile": 0.98295}, "CVE-2018-17457": {"epss_score": 0.0077, "epss_percentile": 0.72996}, "CVE-2018-17458": {"epss_score": 0.01152, "epss_percentile": 0.78045}, "CVE-2018-17459": {"epss_score": 0.00254, "epss_percentile": 0.48557}, "CVE-2018-17460": {"epss_score": 0.00159, "epss_percentile": 0.3733}, "CVE-2018-17461": {"epss_score": 0.00377, "epss_percentile": 0.58755}, "CVE-2018-17462": {"epss_score": 0.01313, "epss_percentile": 0.79387}, "CVE-2018-17463": {"epss_score": 0.91943, "epss_percentile": 0.9968}, "CVE-2018-17464": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-17465": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-17466": {"epss_score": 0.01106, "epss_percentile": 0.77616}, "CVE-2018-17467": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-17468": {"epss_score": 0.00936, "epss_percentile": 0.75685}, "CVE-2018-17469": {"epss_score": 0.01156, "epss_percentile": 0.78101}, "CVE-2018-17470": {"epss_score": 0.01511, "epss_percentile": 0.80774}, "CVE-2018-17471": {"epss_score": 0.00838, "epss_percentile": 0.74173}, "CVE-2018-17472": {"epss_score": 0.01002, "epss_percentile": 0.76511}, "CVE-2018-17473": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-17474": {"epss_score": 0.01332, "epss_percentile": 0.79525}, "CVE-2018-17475": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-17476": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-17477": {"epss_score": 0.00774, "epss_percentile": 0.73064}, "CVE-2018-17478": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2018-17479": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2018-17480": {"epss_score": 0.27293, "epss_percentile": 0.96232}, "CVE-2018-17481": {"epss_score": 0.01652, "epss_percentile": 0.81575}, "CVE-2018-17482": {"epss_score": 0.00054, "epss_percentile": 0.17248}, "CVE-2018-17483": {"epss_score": 0.00054, "epss_percentile": 0.17248}, "CVE-2018-17484": {"epss_score": 0.00055, "epss_percentile": 0.17558}, "CVE-2018-17485": {"epss_score": 0.00061, "epss_percentile": 0.19503}, "CVE-2018-17486": {"epss_score": 0.00055, "epss_percentile": 0.17547}, "CVE-2018-17487": {"epss_score": 0.00056, "epss_percentile": 0.17691}, "CVE-2018-17488": {"epss_score": 0.00056, "epss_percentile": 0.17691}, "CVE-2018-17489": {"epss_score": 0.00049, "epss_percentile": 0.15415}, "CVE-2018-17490": {"epss_score": 0.00046, "epss_percentile": 0.14461}, "CVE-2018-17491": {"epss_score": 0.00041, "epss_percentile": 0.12296}, "CVE-2018-17492": {"epss_score": 0.00061, "epss_percentile": 0.19452}, "CVE-2018-17493": {"epss_score": 0.00046, "epss_percentile": 0.14436}, "CVE-2018-17494": {"epss_score": 0.00046, "epss_percentile": 0.14436}, "CVE-2018-17495": {"epss_score": 0.00046, "epss_percentile": 0.14436}, "CVE-2018-17496": {"epss_score": 0.00046, "epss_percentile": 0.14436}, "CVE-2018-17497": {"epss_score": 0.00061, "epss_percentile": 0.19503}, "CVE-2018-17499": {"epss_score": 0.00049, "epss_percentile": 0.15415}, "CVE-2018-17500": {"epss_score": 0.0005, "epss_percentile": 0.15673}, "CVE-2018-17502": {"epss_score": 0.00051, "epss_percentile": 0.1627}, "CVE-2018-17532": {"epss_score": 0.53771, "epss_percentile": 0.97896}, "CVE-2018-17533": {"epss_score": 0.00396, "epss_percentile": 0.59865}, "CVE-2018-17534": {"epss_score": 0.0025, "epss_percentile": 0.48101}, "CVE-2018-17536": {"epss_score": 0.00238, "epss_percentile": 0.46764}, "CVE-2018-17537": {"epss_score": 0.00238, "epss_percentile": 0.46764}, "CVE-2018-17538": {"epss_score": 0.00499, "epss_percentile": 0.65254}, "CVE-2018-17539": {"epss_score": 0.0115, "epss_percentile": 0.7803}, "CVE-2018-17540": {"epss_score": 0.03978, "epss_percentile": 0.88054}, "CVE-2018-17542": {"epss_score": 0.00128, "epss_percentile": 0.32973}, "CVE-2018-17552": {"epss_score": 0.88398, "epss_percentile": 0.9947}, "CVE-2018-17553": {"epss_score": 0.80078, "epss_percentile": 0.99071}, "CVE-2018-17555": {"epss_score": 0.00317, "epss_percentile": 0.54313}, "CVE-2018-17556": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-17558": {"epss_score": 0.02543, "epss_percentile": 0.85055}, "CVE-2018-17559": {"epss_score": 0.00177, "epss_percentile": 0.39528}, "CVE-2018-17560": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17562": {"epss_score": 0.00514, "epss_percentile": 0.65964}, "CVE-2018-17563": {"epss_score": 0.0017, "epss_percentile": 0.3868}, "CVE-2018-17564": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2018-17565": {"epss_score": 0.00515, "epss_percentile": 0.66005}, "CVE-2018-17566": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-17567": {"epss_score": 0.00453, "epss_percentile": 0.63228}, "CVE-2018-17568": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-17569": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-17570": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-17571": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17572": {"epss_score": 0.00321, "epss_percentile": 0.54686}, "CVE-2018-17573": {"epss_score": 0.01813, "epss_percentile": 0.82377}, "CVE-2018-17574": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-17575": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-17580": {"epss_score": 0.00217, "epss_percentile": 0.44297}, "CVE-2018-17581": {"epss_score": 0.00197, "epss_percentile": 0.41886}, "CVE-2018-17582": {"epss_score": 0.00217, "epss_percentile": 0.44297}, "CVE-2018-17583": {"epss_score": 0.00264, "epss_percentile": 0.4971}, "CVE-2018-17584": {"epss_score": 0.00242, "epss_percentile": 0.47361}, "CVE-2018-17585": {"epss_score": 0.00264, "epss_percentile": 0.4971}, "CVE-2018-17586": {"epss_score": 0.00264, "epss_percentile": 0.4971}, "CVE-2018-17587": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-17588": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-17589": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-17590": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-17591": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-17593": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-17594": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-17595": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-17596": {"epss_score": 0.01964, "epss_percentile": 0.83075}, "CVE-2018-17605": {"epss_score": 0.00451, "epss_percentile": 0.63146}, "CVE-2018-17607": {"epss_score": 0.00398, "epss_percentile": 0.60085}, "CVE-2018-17608": {"epss_score": 0.00398, "epss_percentile": 0.60085}, "CVE-2018-17609": {"epss_score": 0.00398, "epss_percentile": 0.60085}, "CVE-2018-17610": {"epss_score": 0.00398, "epss_percentile": 0.60085}, "CVE-2018-17611": {"epss_score": 0.00398, "epss_percentile": 0.60085}, "CVE-2018-17612": {"epss_score": 0.00717, "epss_percentile": 0.71878}, "CVE-2018-17613": {"epss_score": 0.00305, "epss_percentile": 0.53383}, "CVE-2018-17614": {"epss_score": 0.01699, "epss_percentile": 0.81823}, "CVE-2018-17615": {"epss_score": 0.00598, "epss_percentile": 0.68759}, "CVE-2018-17616": {"epss_score": 0.00609, "epss_percentile": 0.69132}, "CVE-2018-17617": {"epss_score": 0.00609, "epss_percentile": 0.69132}, "CVE-2018-17618": {"epss_score": 0.00598, "epss_percentile": 0.68759}, "CVE-2018-17619": {"epss_score": 0.00609, "epss_percentile": 0.69132}, "CVE-2018-17620": {"epss_score": 0.00609, "epss_percentile": 0.69132}, "CVE-2018-17621": {"epss_score": 0.00654, "epss_percentile": 0.70344}, "CVE-2018-17622": {"epss_score": 0.01853, "epss_percentile": 0.82546}, "CVE-2018-17623": {"epss_score": 0.00598, "epss_percentile": 0.68759}, "CVE-2018-17624": {"epss_score": 0.00598, "epss_percentile": 0.68759}, "CVE-2018-17625": {"epss_score": 0.00586, "epss_percentile": 0.68454}, "CVE-2018-17626": {"epss_score": 0.00586, "epss_percentile": 0.68454}, "CVE-2018-17627": {"epss_score": 0.00586, "epss_percentile": 0.68454}, "CVE-2018-17628": {"epss_score": 0.00586, "epss_percentile": 0.68454}, "CVE-2018-17629": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17630": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17631": {"epss_score": 0.00912, "epss_percentile": 0.7536}, "CVE-2018-17632": {"epss_score": 0.00912, "epss_percentile": 0.7536}, "CVE-2018-17633": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17634": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17635": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17636": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17637": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17638": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17639": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17640": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17641": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17642": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17643": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17644": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17645": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17646": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17647": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17648": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17649": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17650": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17651": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17652": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17653": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17654": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17655": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17656": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17657": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17658": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17659": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17660": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17661": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17662": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17663": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17664": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17665": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17666": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17667": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17668": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17669": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17670": {"epss_score": 0.00641, "epss_percentile": 0.7001}, "CVE-2018-17671": {"epss_score": 0.00912, "epss_percentile": 0.7536}, "CVE-2018-17672": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17673": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17674": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17675": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17676": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17677": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17678": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17679": {"epss_score": 0.00345, "epss_percentile": 0.56599}, "CVE-2018-17680": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17681": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17682": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17683": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17684": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17685": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2018-17686": {"epss_score": 0.10952, "epss_percentile": 0.93174}, "CVE-2018-17687": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17688": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17689": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17690": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17691": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17692": {"epss_score": 0.00603, "epss_percentile": 0.68938}, "CVE-2018-17693": {"epss_score": 0.00603, "epss_percentile": 0.68938}, "CVE-2018-17694": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17695": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17696": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17697": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17698": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17699": {"epss_score": 0.04017, "epss_percentile": 0.88123}, "CVE-2018-17700": {"epss_score": 0.00866, "epss_percentile": 0.74636}, "CVE-2018-17701": {"epss_score": 0.00603, "epss_percentile": 0.68938}, "CVE-2018-17702": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17703": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17704": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17705": {"epss_score": 0.00424, "epss_percentile": 0.6165}, "CVE-2018-17706": {"epss_score": 0.00621, "epss_percentile": 0.69476}, "CVE-2018-17707": {"epss_score": 0.02201, "epss_percentile": 0.83978}, "CVE-2018-17765": {"epss_score": 0.00087, "epss_percentile": 0.2545}, "CVE-2018-17766": {"epss_score": 0.00084, "epss_percentile": 0.24922}, "CVE-2018-17767": {"epss_score": 0.00077, "epss_percentile": 0.23522}, "CVE-2018-17768": {"epss_score": 0.00087, "epss_percentile": 0.2545}, "CVE-2018-17769": {"epss_score": 0.00097, "epss_percentile": 0.27627}, "CVE-2018-17770": {"epss_score": 0.00096, "epss_percentile": 0.27266}, "CVE-2018-17771": {"epss_score": 0.0007, "epss_percentile": 0.21944}, "CVE-2018-17772": {"epss_score": 0.0011, "epss_percentile": 0.30185}, "CVE-2018-17773": {"epss_score": 0.001, "epss_percentile": 0.28509}, "CVE-2018-17774": {"epss_score": 0.00087, "epss_percentile": 0.2545}, "CVE-2018-17775": {"epss_score": 0.00182, "epss_percentile": 0.40238}, "CVE-2018-17776": {"epss_score": 0.00434, "epss_percentile": 0.62319}, "CVE-2018-17777": {"epss_score": 0.00563, "epss_percentile": 0.67727}, "CVE-2018-17780": {"epss_score": 0.0037, "epss_percentile": 0.58308}, "CVE-2018-17781": {"epss_score": 0.00084, "epss_percentile": 0.24994}, "CVE-2018-17782": {"epss_score": 0.00177, "epss_percentile": 0.39549}, "CVE-2018-17783": {"epss_score": 0.00177, "epss_percentile": 0.39549}, "CVE-2018-17784": {"epss_score": 0.03724, "epss_percentile": 0.8763}, "CVE-2018-17785": {"epss_score": 0.00575, "epss_percentile": 0.68101}, "CVE-2018-17786": {"epss_score": 0.14226, "epss_percentile": 0.94167}, "CVE-2018-17787": {"epss_score": 0.23204, "epss_percentile": 0.9575}, "CVE-2018-17789": {"epss_score": 0.00113, "epss_percentile": 0.30631}, "CVE-2018-17790": {"epss_score": 0.00206, "epss_percentile": 0.43041}, "CVE-2018-17791": {"epss_score": 0.00322, "epss_percentile": 0.54783}, "CVE-2018-17792": {"epss_score": 0.00198, "epss_percentile": 0.41987}, "CVE-2018-17794": {"epss_score": 0.00459, "epss_percentile": 0.6346}, "CVE-2018-17795": {"epss_score": 0.01251, "epss_percentile": 0.78899}, "CVE-2018-17796": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-17797": {"epss_score": 0.00258, "epss_percentile": 0.49001}, "CVE-2018-17798": {"epss_score": 0.00259, "epss_percentile": 0.49067}, "CVE-2018-17825": {"epss_score": 0.0048, "epss_percentile": 0.64448}, "CVE-2018-17826": {"epss_score": 0.0018, "epss_percentile": 0.39979}, "CVE-2018-17827": {"epss_score": 0.0093, "epss_percentile": 0.75603}, "CVE-2018-17828": {"epss_score": 0.00593, "epss_percentile": 0.68646}, "CVE-2018-17830": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-17831": {"epss_score": 0.00418, "epss_percentile": 0.61282}, "CVE-2018-17832": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-17835": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-17836": {"epss_score": 0.01189, "epss_percentile": 0.7837}, "CVE-2018-17837": {"epss_score": 0.00523, "epss_percentile": 0.66306}, "CVE-2018-17838": {"epss_score": 0.00419, "epss_percentile": 0.61376}, "CVE-2018-17840": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-17841": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-17842": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-17843": {"epss_score": 0.00694, "epss_percentile": 0.71352}, "CVE-2018-17846": {"epss_score": 0.00592, "epss_percentile": 0.68606}, "CVE-2018-17847": {"epss_score": 0.00906, "epss_percentile": 0.75253}, "CVE-2018-17848": {"epss_score": 0.01025, "epss_percentile": 0.76792}, "CVE-2018-17849": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-17852": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-17854": {"epss_score": 0.00421, "epss_percentile": 0.61486}, "CVE-2018-17855": {"epss_score": 0.00242, "epss_percentile": 0.47357}, "CVE-2018-17856": {"epss_score": 0.0369, "epss_percentile": 0.87575}, "CVE-2018-17857": {"epss_score": 0.00016, "epss_percentile": 0.0285}, "CVE-2018-17858": {"epss_score": 0.00094, "epss_percentile": 0.27077}, "CVE-2018-17859": {"epss_score": 0.00019, "epss_percentile": 0.04282}, "CVE-2018-17860": {"epss_score": 0.00282, "epss_percentile": 0.5123}, "CVE-2018-17861": {"epss_score": 0.00467, "epss_percentile": 0.63852}, "CVE-2018-17862": {"epss_score": 0.00467, "epss_percentile": 0.63852}, "CVE-2018-17865": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2018-17866": {"epss_score": 0.00248, "epss_percentile": 0.47908}, "CVE-2018-17867": {"epss_score": 0.04642, "epss_percentile": 0.88954}, "CVE-2018-17868": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-17869": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2018-17870": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2018-17871": {"epss_score": 0.00634, "epss_percentile": 0.69805}, "CVE-2018-17872": {"epss_score": 0.01457, "epss_percentile": 0.80401}, "CVE-2018-17873": {"epss_score": 0.0501, "epss_percentile": 0.8939}, "CVE-2018-17874": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-17875": {"epss_score": 0.0687, "epss_percentile": 0.91084}, "CVE-2018-17876": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-17877": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-17878": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2018-17879": {"epss_score": 0.48683, "epss_percentile": 0.97649}, "CVE-2018-17880": {"epss_score": 0.0129, "epss_percentile": 0.79218}, "CVE-2018-17881": {"epss_score": 0.01368, "epss_percentile": 0.79792}, "CVE-2018-17882": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-17883": {"epss_score": 0.00684, "epss_percentile": 0.71118}, "CVE-2018-17884": {"epss_score": 0.00254, "epss_percentile": 0.4853}, "CVE-2018-17886": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-17888": {"epss_score": 0.41857, "epss_percentile": 0.97297}, "CVE-2018-17889": {"epss_score": 0.0028, "epss_percentile": 0.51033}, "CVE-2018-17890": {"epss_score": 0.00711, "epss_percentile": 0.71743}, "CVE-2018-17891": {"epss_score": 0.00168, "epss_percentile": 0.38504}, "CVE-2018-17892": {"epss_score": 0.03961, "epss_percentile": 0.88013}, "CVE-2018-17893": {"epss_score": 0.05716, "epss_percentile": 0.90146}, "CVE-2018-17894": {"epss_score": 0.00525, "epss_percentile": 0.66371}, "CVE-2018-17895": {"epss_score": 0.05359, "epss_percentile": 0.89781}, "CVE-2018-17896": {"epss_score": 0.00247, "epss_percentile": 0.47868}, "CVE-2018-17897": {"epss_score": 0.08684, "epss_percentile": 0.92199}, "CVE-2018-17898": {"epss_score": 0.00283, "epss_percentile": 0.51396}, "CVE-2018-17899": {"epss_score": 0.06336, "epss_percentile": 0.90679}, "CVE-2018-17900": {"epss_score": 0.00262, "epss_percentile": 0.49405}, "CVE-2018-17901": {"epss_score": 0.00286, "epss_percentile": 0.51685}, "CVE-2018-17902": {"epss_score": 0.00249, "epss_percentile": 0.48059}, "CVE-2018-17903": {"epss_score": 0.00495, "epss_percentile": 0.65117}, "CVE-2018-17904": {"epss_score": 0.0018, "epss_percentile": 0.39982}, "CVE-2018-17905": {"epss_score": 0.00178, "epss_percentile": 0.39658}, "CVE-2018-17906": {"epss_score": 0.00431, "epss_percentile": 0.62062}, "CVE-2018-17907": {"epss_score": 0.00139, "epss_percentile": 0.3455}, "CVE-2018-17908": {"epss_score": 0.00119, "epss_percentile": 0.31601}, "CVE-2018-17909": {"epss_score": 0.00193, "epss_percentile": 0.41385}, "CVE-2018-17910": {"epss_score": 0.02689, "epss_percentile": 0.85434}, "CVE-2018-17911": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2018-17912": {"epss_score": 0.00404, "epss_percentile": 0.6045}, "CVE-2018-17913": {"epss_score": 0.00191, "epss_percentile": 0.4121}, "CVE-2018-17914": {"epss_score": 0.03895, "epss_percentile": 0.87915}, "CVE-2018-17915": {"epss_score": 0.0015, "epss_percentile": 0.36056}, "CVE-2018-17916": {"epss_score": 0.09835, "epss_percentile": 0.92725}, "CVE-2018-17917": {"epss_score": 0.00174, "epss_percentile": 0.39141}, "CVE-2018-17918": {"epss_score": 0.00055, "epss_percentile": 0.17616}, "CVE-2018-17919": {"epss_score": 0.00125, "epss_percentile": 0.32486}, "CVE-2018-17921": {"epss_score": 0.00217, "epss_percentile": 0.44307}, "CVE-2018-17922": {"epss_score": 0.00229, "epss_percentile": 0.45646}, "CVE-2018-17923": {"epss_score": 0.00066, "epss_percentile": 0.2086}, "CVE-2018-17924": {"epss_score": 0.00087, "epss_percentile": 0.25551}, "CVE-2018-17925": {"epss_score": 0.00055, "epss_percentile": 0.17522}, "CVE-2018-17926": {"epss_score": 0.00063, "epss_percentile": 0.19994}, "CVE-2018-17927": {"epss_score": 0.00472, "epss_percentile": 0.64032}, "CVE-2018-17928": {"epss_score": 0.00265, "epss_percentile": 0.49798}, "CVE-2018-17929": {"epss_score": 0.00496, "epss_percentile": 0.65157}, "CVE-2018-17930": {"epss_score": 0.11684, "epss_percentile": 0.93446}, "CVE-2018-17931": {"epss_score": 0.00042, "epss_percentile": 0.12748}, "CVE-2018-17932": {"epss_score": 0.00235, "epss_percentile": 0.46235}, "CVE-2018-17933": {"epss_score": 0.00288, "epss_percentile": 0.5198}, "CVE-2018-17934": {"epss_score": 0.67751, "epss_percentile": 0.98519}, "CVE-2018-17935": {"epss_score": 0.0026, "epss_percentile": 0.49198}, "CVE-2018-17936": {"epss_score": 0.67158, "epss_percentile": 0.98497}, "CVE-2018-17937": {"epss_score": 0.04032, "epss_percentile": 0.88153}, "CVE-2018-17938": {"epss_score": 0.00607, "epss_percentile": 0.69054}, "CVE-2018-17939": {"epss_score": 0.00064, "epss_percentile": 0.20401}, "CVE-2018-17942": {"epss_score": 0.01675, "epss_percentile": 0.81704}, "CVE-2018-17944": {"epss_score": 0.00281, "epss_percentile": 0.51138}, "CVE-2018-17946": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-17947": {"epss_score": 0.00254, "epss_percentile": 0.4853}, "CVE-2018-17948": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2018-17949": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17950": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2018-17952": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-17953": {"epss_score": 0.00434, "epss_percentile": 0.62286}, "CVE-2018-17954": {"epss_score": 0.00042, "epss_percentile": 0.12601}, "CVE-2018-17955": {"epss_score": 0.0004, "epss_percentile": 0.11911}, "CVE-2018-17956": {"epss_score": 0.00045, "epss_percentile": 0.1399}, "CVE-2018-17957": {"epss_score": 0.00044, "epss_percentile": 0.13591}, "CVE-2018-17958": {"epss_score": 0.00888, "epss_percentile": 0.74995}, "CVE-2018-17960": {"epss_score": 0.02024, "epss_percentile": 0.83308}, "CVE-2018-17961": {"epss_score": 0.11327, "epss_percentile": 0.9331}, "CVE-2018-17962": {"epss_score": 0.00264, "epss_percentile": 0.49715}, "CVE-2018-17963": {"epss_score": 0.01526, "epss_percentile": 0.80862}, "CVE-2018-17964": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-17965": {"epss_score": 0.0039, "epss_percentile": 0.59559}, "CVE-2018-17966": {"epss_score": 0.00131, "epss_percentile": 0.33384}, "CVE-2018-17967": {"epss_score": 0.0038, "epss_percentile": 0.58913}, "CVE-2018-17968": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-17969": {"epss_score": 0.00475, "epss_percentile": 0.64201}, "CVE-2018-17972": {"epss_score": 0.00056, "epss_percentile": 0.17741}, "CVE-2018-17974": {"epss_score": 0.00224, "epss_percentile": 0.45007}, "CVE-2018-17975": {"epss_score": 0.00113, "epss_percentile": 0.30692}, "CVE-2018-17976": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2018-17977": {"epss_score": 0.00122, "epss_percentile": 0.32055}, "CVE-2018-17980": {"epss_score": 0.03667, "epss_percentile": 0.87535}, "CVE-2018-17981": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2018-17983": {"epss_score": 0.00448, "epss_percentile": 0.62992}, "CVE-2018-17984": {"epss_score": 0.00427, "epss_percentile": 0.61878}, "CVE-2018-17985": {"epss_score": 0.00174, "epss_percentile": 0.39188}, "CVE-2018-17986": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-17987": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-17988": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-17989": {"epss_score": 0.00204, "epss_percentile": 0.4265}, "CVE-2018-17990": {"epss_score": 0.02265, "epss_percentile": 0.84197}, "CVE-2018-17996": {"epss_score": 0.00451, "epss_percentile": 0.63143}, "CVE-2018-17997": {"epss_score": 0.026, "epss_percentile": 0.85205}, "CVE-2018-18004": {"epss_score": 0.00228, "epss_percentile": 0.45477}, "CVE-2018-18005": {"epss_score": 0.00272, "epss_percentile": 0.50359}, "CVE-2018-18006": {"epss_score": 0.02493, "epss_percentile": 0.849}, "CVE-2018-18007": {"epss_score": 0.03025, "epss_percentile": 0.86237}, "CVE-2018-18008": {"epss_score": 0.01175, "epss_percentile": 0.78258}, "CVE-2018-18009": {"epss_score": 0.01175, "epss_percentile": 0.78258}, "CVE-2018-18013": {"epss_score": 0.00241, "epss_percentile": 0.47326}, "CVE-2018-18014": {"epss_score": 0.00039, "epss_percentile": 0.1173}, "CVE-2018-18016": {"epss_score": 0.00085, "epss_percentile": 0.25122}, "CVE-2018-18017": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-18018": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2018-18019": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2018-18020": {"epss_score": 0.00107, "epss_percentile": 0.29748}, "CVE-2018-18021": {"epss_score": 0.00088, "epss_percentile": 0.25728}, "CVE-2018-18023": {"epss_score": 0.00377, "epss_percentile": 0.58759}, "CVE-2018-18024": {"epss_score": 0.00321, "epss_percentile": 0.54687}, "CVE-2018-18025": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2018-18026": {"epss_score": 0.02048, "epss_percentile": 0.83393}, "CVE-2018-18029": {"epss_score": 0.00193, "epss_percentile": 0.41466}, "CVE-2018-18035": {"epss_score": 0.01636, "epss_percentile": 0.81479}, "CVE-2018-18056": {"epss_score": 0.00059, "epss_percentile": 0.1863}, "CVE-2018-18058": {"epss_score": 0.00447, "epss_percentile": 0.62956}, "CVE-2018-18059": {"epss_score": 0.00332, "epss_percentile": 0.55573}, "CVE-2018-18060": {"epss_score": 0.00332, "epss_percentile": 0.55573}, "CVE-2018-18061": {"epss_score": 0.00204, "epss_percentile": 0.42657}, "CVE-2018-18062": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-18064": {"epss_score": 0.0051, "epss_percentile": 0.65801}, "CVE-2018-18065": {"epss_score": 0.11463, "epss_percentile": 0.93374}, "CVE-2018-18066": {"epss_score": 0.0059, "epss_percentile": 0.68566}, "CVE-2018-18068": {"epss_score": 0.01921, "epss_percentile": 0.82897}, "CVE-2018-18069": {"epss_score": 0.14198, "epss_percentile": 0.94161}, "CVE-2018-18070": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2018-18071": {"epss_score": 0.01534, "epss_percentile": 0.80903}, "CVE-2018-18073": {"epss_score": 0.00281, "epss_percentile": 0.51116}, "CVE-2018-18074": {"epss_score": 0.00176, "epss_percentile": 0.39474}, "CVE-2018-18075": {"epss_score": 0.00602, "epss_percentile": 0.68895}, "CVE-2018-18082": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18083": {"epss_score": 0.01185, "epss_percentile": 0.78338}, "CVE-2018-18084": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18086": {"epss_score": 0.00401, "epss_percentile": 0.6026}, "CVE-2018-18087": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-18088": {"epss_score": 0.00879, "epss_percentile": 0.74847}, "CVE-2018-18089": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-18090": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2018-18091": {"epss_score": 0.00056, "epss_percentile": 0.1788}, "CVE-2018-18093": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2018-18094": {"epss_score": 0.00043, "epss_percentile": 0.1306}, "CVE-2018-18095": {"epss_score": 0.00167, "epss_percentile": 0.38388}, "CVE-2018-18096": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2018-18097": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2018-18098": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2018-18190": {"epss_score": 0.00286, "epss_percentile": 0.51783}, "CVE-2018-18191": {"epss_score": 0.00215, "epss_percentile": 0.4406}, "CVE-2018-18192": {"epss_score": 0.00285, "epss_percentile": 0.51681}, "CVE-2018-18193": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2018-18194": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2018-18195": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-18196": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2018-18197": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-18198": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-18199": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-18200": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18201": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-18202": {"epss_score": 0.00396, "epss_percentile": 0.59885}, "CVE-2018-18203": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2018-18205": {"epss_score": 0.00893, "epss_percentile": 0.75073}, "CVE-2018-18206": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2018-18207": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18208": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18209": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18210": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18211": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18215": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-18223": {"epss_score": 0.01014, "epss_percentile": 0.76651}, "CVE-2018-18224": {"epss_score": 0.01014, "epss_percentile": 0.76651}, "CVE-2018-18225": {"epss_score": 0.01179, "epss_percentile": 0.78295}, "CVE-2018-18226": {"epss_score": 0.01477, "epss_percentile": 0.80549}, "CVE-2018-18227": {"epss_score": 0.01842, "epss_percentile": 0.82498}, "CVE-2018-18240": {"epss_score": 0.02706, "epss_percentile": 0.85467}, "CVE-2018-18242": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18244": {"epss_score": 0.00272, "epss_percentile": 0.50359}, "CVE-2018-18245": {"epss_score": 0.0531, "epss_percentile": 0.89716}, "CVE-2018-18246": {"epss_score": 0.00117, "epss_percentile": 0.31307}, "CVE-2018-18247": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-18248": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18249": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2018-18250": {"epss_score": 0.00238, "epss_percentile": 0.46811}, "CVE-2018-18251": {"epss_score": 0.00794, "epss_percentile": 0.73451}, "CVE-2018-18252": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2018-18253": {"epss_score": 0.00037, "epss_percentile": 0.10673}, "CVE-2018-18254": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2018-18255": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2018-18256": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2018-18257": {"epss_score": 0.00336, "epss_percentile": 0.55943}, "CVE-2018-18258": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2018-18259": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-18260": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-18261": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-18262": {"epss_score": 0.01205, "epss_percentile": 0.78512}, "CVE-2018-18264": {"epss_score": 0.9085, "epss_percentile": 0.99604}, "CVE-2018-18270": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18271": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18274": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2018-18276": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18281": {"epss_score": 0.00396, "epss_percentile": 0.59928}, "CVE-2018-18282": {"epss_score": 0.00257, "epss_percentile": 0.48888}, "CVE-2018-18284": {"epss_score": 0.00331, "epss_percentile": 0.55549}, "CVE-2018-18285": {"epss_score": 0.00597, "epss_percentile": 0.68744}, "CVE-2018-18286": {"epss_score": 0.00597, "epss_percentile": 0.68744}, "CVE-2018-18287": {"epss_score": 0.00416, "epss_percentile": 0.61168}, "CVE-2018-18288": {"epss_score": 0.00271, "epss_percentile": 0.50299}, "CVE-2018-18289": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-18290": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18291": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-18296": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18307": {"epss_score": 0.00395, "epss_percentile": 0.59839}, "CVE-2018-18308": {"epss_score": 0.04598, "epss_percentile": 0.88901}, "CVE-2018-18309": {"epss_score": 0.00294, "epss_percentile": 0.52438}, "CVE-2018-18310": {"epss_score": 0.00093, "epss_percentile": 0.26689}, "CVE-2018-18311": {"epss_score": 0.11355, "epss_percentile": 0.93322}, "CVE-2018-18312": {"epss_score": 0.1085, "epss_percentile": 0.93134}, "CVE-2018-18313": {"epss_score": 0.04198, "epss_percentile": 0.88385}, "CVE-2018-18314": {"epss_score": 0.05205, "epss_percentile": 0.89608}, "CVE-2018-18315": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-18316": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-18317": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-18318": {"epss_score": 0.00447, "epss_percentile": 0.62971}, "CVE-2018-18319": {"epss_score": 0.13278, "epss_percentile": 0.9392}, "CVE-2018-18320": {"epss_score": 0.13278, "epss_percentile": 0.9392}, "CVE-2018-18322": {"epss_score": 0.16161, "epss_percentile": 0.94582}, "CVE-2018-18323": {"epss_score": 0.84291, "epss_percentile": 0.99282}, "CVE-2018-18324": {"epss_score": 0.039, "epss_percentile": 0.87919}, "CVE-2018-18325": {"epss_score": 0.91084, "epss_percentile": 0.99618}, "CVE-2018-18326": {"epss_score": 0.76537, "epss_percentile": 0.98895}, "CVE-2018-18327": {"epss_score": 0.00081, "epss_percentile": 0.24376}, "CVE-2018-18328": {"epss_score": 0.00081, "epss_percentile": 0.24376}, "CVE-2018-18329": {"epss_score": 0.00081, "epss_percentile": 0.24376}, "CVE-2018-18330": {"epss_score": 0.00341, "epss_percentile": 0.56326}, "CVE-2018-18331": {"epss_score": 0.00227, "epss_percentile": 0.45366}, "CVE-2018-18332": {"epss_score": 0.00227, "epss_percentile": 0.45366}, "CVE-2018-18333": {"epss_score": 0.00562, "epss_percentile": 0.67704}, "CVE-2018-18334": {"epss_score": 0.00335, "epss_percentile": 0.55805}, "CVE-2018-18335": {"epss_score": 0.01594, "epss_percentile": 0.81232}, "CVE-2018-18336": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-18337": {"epss_score": 0.02777, "epss_percentile": 0.8564}, "CVE-2018-18338": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-18339": {"epss_score": 0.01442, "epss_percentile": 0.80309}, "CVE-2018-18340": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-18341": {"epss_score": 0.01671, "epss_percentile": 0.81675}, "CVE-2018-18342": {"epss_score": 0.01886, "epss_percentile": 0.8271}, "CVE-2018-18343": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-18344": {"epss_score": 0.0096, "epss_percentile": 0.75963}, "CVE-2018-18345": {"epss_score": 0.0072, "epss_percentile": 0.71959}, "CVE-2018-18346": {"epss_score": 0.00838, "epss_percentile": 0.74173}, "CVE-2018-18347": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-18348": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-18349": {"epss_score": 0.00511, "epss_percentile": 0.65822}, "CVE-2018-18350": {"epss_score": 0.00625, "epss_percentile": 0.69582}, "CVE-2018-18351": {"epss_score": 0.0072, "epss_percentile": 0.71959}, "CVE-2018-18352": {"epss_score": 0.00738, "epss_percentile": 0.72341}, "CVE-2018-18353": {"epss_score": 0.01221, "epss_percentile": 0.78647}, "CVE-2018-18354": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-18355": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-18356": {"epss_score": 0.02565, "epss_percentile": 0.85114}, "CVE-2018-18357": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-18358": {"epss_score": 0.00112, "epss_percentile": 0.30444}, "CVE-2018-18359": {"epss_score": 0.01156, "epss_percentile": 0.78101}, "CVE-2018-18361": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18362": {"epss_score": 0.00432, "epss_percentile": 0.62097}, "CVE-2018-18363": {"epss_score": 0.00069, "epss_percentile": 0.21574}, "CVE-2018-18364": {"epss_score": 0.0026, "epss_percentile": 0.49193}, "CVE-2018-18365": {"epss_score": 0.00301, "epss_percentile": 0.53008}, "CVE-2018-18366": {"epss_score": 0.00086, "epss_percentile": 0.25276}, "CVE-2018-18367": {"epss_score": 0.00397, "epss_percentile": 0.5994}, "CVE-2018-18368": {"epss_score": 0.00495, "epss_percentile": 0.65108}, "CVE-2018-18369": {"epss_score": 0.00397, "epss_percentile": 0.5994}, "CVE-2018-18370": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2018-18371": {"epss_score": 0.00249, "epss_percentile": 0.48062}, "CVE-2018-18372": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-18373": {"epss_score": 0.00149, "epss_percentile": 0.36004}, "CVE-2018-18374": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-18375": {"epss_score": 0.00353, "epss_percentile": 0.57182}, "CVE-2018-18376": {"epss_score": 0.00333, "epss_percentile": 0.55617}, "CVE-2018-18377": {"epss_score": 0.00246, "epss_percentile": 0.47735}, "CVE-2018-18379": {"epss_score": 0.00611, "epss_percentile": 0.69182}, "CVE-2018-18380": {"epss_score": 0.00236, "epss_percentile": 0.46444}, "CVE-2018-18381": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-18382": {"epss_score": 0.0193, "epss_percentile": 0.82937}, "CVE-2018-18384": {"epss_score": 0.03223, "epss_percentile": 0.86677}, "CVE-2018-18385": {"epss_score": 0.00625, "epss_percentile": 0.69593}, "CVE-2018-18386": {"epss_score": 0.00041, "epss_percentile": 0.1221}, "CVE-2018-18387": {"epss_score": 0.00814, "epss_percentile": 0.73766}, "CVE-2018-18388": {"epss_score": 0.00638, "epss_percentile": 0.69912}, "CVE-2018-18389": {"epss_score": 0.00764, "epss_percentile": 0.72903}, "CVE-2018-18390": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-18391": {"epss_score": 0.00401, "epss_percentile": 0.6026}, "CVE-2018-18392": {"epss_score": 0.00401, "epss_percentile": 0.6026}, "CVE-2018-18393": {"epss_score": 0.00345, "epss_percentile": 0.56564}, "CVE-2018-18394": {"epss_score": 0.00161, "epss_percentile": 0.37561}, "CVE-2018-18395": {"epss_score": 0.00357, "epss_percentile": 0.5746}, "CVE-2018-18396": {"epss_score": 0.02002, "epss_percentile": 0.83223}, "CVE-2018-18397": {"epss_score": 0.00067, "epss_percentile": 0.21171}, "CVE-2018-18398": {"epss_score": 0.0005, "epss_percentile": 0.15889}, "CVE-2018-18399": {"epss_score": 0.01037, "epss_percentile": 0.76929}, "CVE-2018-18405": {"epss_score": 0.00298, "epss_percentile": 0.528}, "CVE-2018-18406": {"epss_score": 0.00692, "epss_percentile": 0.71298}, "CVE-2018-18407": {"epss_score": 0.00282, "epss_percentile": 0.51252}, "CVE-2018-18408": {"epss_score": 0.00386, "epss_percentile": 0.5924}, "CVE-2018-18409": {"epss_score": 0.00323, "epss_percentile": 0.54908}, "CVE-2018-18416": {"epss_score": 0.00222, "epss_percentile": 0.44723}, "CVE-2018-18417": {"epss_score": 0.00188, "epss_percentile": 0.40879}, "CVE-2018-18419": {"epss_score": 0.00188, "epss_percentile": 0.40879}, "CVE-2018-18420": {"epss_score": 0.00134, "epss_percentile": 0.33835}, "CVE-2018-18422": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-18425": {"epss_score": 0.00193, "epss_percentile": 0.4141}, "CVE-2018-18426": {"epss_score": 0.02057, "epss_percentile": 0.83429}, "CVE-2018-18427": {"epss_score": 0.00419, "epss_percentile": 0.61401}, "CVE-2018-18428": {"epss_score": 0.30723, "epss_percentile": 0.96563}, "CVE-2018-18430": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18431": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18432": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-18433": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18434": {"epss_score": 0.00612, "epss_percentile": 0.69235}, "CVE-2018-18435": {"epss_score": 0.008, "epss_percentile": 0.73547}, "CVE-2018-18436": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-18437": {"epss_score": 0.00651, "epss_percentile": 0.70294}, "CVE-2018-18438": {"epss_score": 0.00091, "epss_percentile": 0.26275}, "CVE-2018-18439": {"epss_score": 0.00471, "epss_percentile": 0.64014}, "CVE-2018-18440": {"epss_score": 0.00051, "epss_percentile": 0.16015}, "CVE-2018-18441": {"epss_score": 0.01256, "epss_percentile": 0.78942}, "CVE-2018-18442": {"epss_score": 0.00982, "epss_percentile": 0.76287}, "CVE-2018-18443": {"epss_score": 0.00363, "epss_percentile": 0.57831}, "CVE-2018-18444": {"epss_score": 0.00749, "epss_percentile": 0.72596}, "CVE-2018-18445": {"epss_score": 0.00045, "epss_percentile": 0.13769}, "CVE-2018-18446": {"epss_score": 0.0116, "epss_percentile": 0.78134}, "CVE-2018-18447": {"epss_score": 0.02314, "epss_percentile": 0.84353}, "CVE-2018-18449": {"epss_score": 0.00177, "epss_percentile": 0.39553}, "CVE-2018-18450": {"epss_score": 0.0037, "epss_percentile": 0.58324}, "CVE-2018-18454": {"epss_score": 0.00526, "epss_percentile": 0.66428}, "CVE-2018-18455": {"epss_score": 0.00413, "epss_percentile": 0.60998}, "CVE-2018-18456": {"epss_score": 0.00526, "epss_percentile": 0.66428}, "CVE-2018-18457": {"epss_score": 0.00215, "epss_percentile": 0.44033}, "CVE-2018-18458": {"epss_score": 0.00215, "epss_percentile": 0.44033}, "CVE-2018-18459": {"epss_score": 0.00215, "epss_percentile": 0.44033}, "CVE-2018-18460": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2018-18461": {"epss_score": 0.11349, "epss_percentile": 0.93319}, "CVE-2018-18466": {"epss_score": 0.00139, "epss_percentile": 0.34541}, "CVE-2018-18467": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-18471": {"epss_score": 0.15524, "epss_percentile": 0.94445}, "CVE-2018-18472": {"epss_score": 0.05803, "epss_percentile": 0.90221}, "CVE-2018-18473": {"epss_score": 0.07003, "epss_percentile": 0.91175}, "CVE-2018-18475": {"epss_score": 0.04678, "epss_percentile": 0.88998}, "CVE-2018-18476": {"epss_score": 0.00307, "epss_percentile": 0.53486}, "CVE-2018-18478": {"epss_score": 0.00022, "epss_percentile": 0.05258}, "CVE-2018-18480": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-18481": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-18482": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-18483": {"epss_score": 0.00252, "epss_percentile": 0.48385}, "CVE-2018-18484": {"epss_score": 0.00151, "epss_percentile": 0.36329}, "CVE-2018-18485": {"epss_score": 0.00869, "epss_percentile": 0.7469}, "CVE-2018-18486": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18487": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-18488": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18489": {"epss_score": 0.00731, "epss_percentile": 0.72181}, "CVE-2018-18492": {"epss_score": 0.3418, "epss_percentile": 0.96829}, "CVE-2018-18493": {"epss_score": 0.26117, "epss_percentile": 0.96114}, "CVE-2018-18494": {"epss_score": 0.0109, "epss_percentile": 0.77452}, "CVE-2018-18495": {"epss_score": 0.00341, "epss_percentile": 0.56347}, "CVE-2018-18496": {"epss_score": 0.00433, "epss_percentile": 0.62201}, "CVE-2018-18497": {"epss_score": 0.00226, "epss_percentile": 0.45295}, "CVE-2018-18498": {"epss_score": 0.07965, "epss_percentile": 0.91794}, "CVE-2018-18499": {"epss_score": 0.00098, "epss_percentile": 0.27698}, "CVE-2018-18500": {"epss_score": 0.28229, "epss_percentile": 0.96334}, "CVE-2018-18501": {"epss_score": 0.04635, "epss_percentile": 0.88948}, "CVE-2018-18502": {"epss_score": 0.04505, "epss_percentile": 0.8877}, "CVE-2018-18503": {"epss_score": 0.02301, "epss_percentile": 0.84311}, "CVE-2018-18504": {"epss_score": 0.03129, "epss_percentile": 0.86463}, "CVE-2018-18505": {"epss_score": 0.03141, "epss_percentile": 0.86488}, "CVE-2018-18506": {"epss_score": 0.0236, "epss_percentile": 0.84494}, "CVE-2018-18508": {"epss_score": 0.00315, "epss_percentile": 0.54163}, "CVE-2018-18509": {"epss_score": 0.00262, "epss_percentile": 0.49368}, "CVE-2018-18510": {"epss_score": 0.0025, "epss_percentile": 0.48141}, "CVE-2018-18511": {"epss_score": 0.00832, "epss_percentile": 0.74058}, "CVE-2018-18512": {"epss_score": 0.00442, "epss_percentile": 0.62752}, "CVE-2018-18513": {"epss_score": 0.00398, "epss_percentile": 0.6006}, "CVE-2018-18517": {"epss_score": 0.0038, "epss_percentile": 0.58946}, "CVE-2018-18519": {"epss_score": 0.00165, "epss_percentile": 0.38046}, "CVE-2018-18520": {"epss_score": 0.01158, "epss_percentile": 0.78122}, "CVE-2018-18521": {"epss_score": 0.00105, "epss_percentile": 0.2929}, "CVE-2018-18524": {"epss_score": 0.00583, "epss_percentile": 0.68339}, "CVE-2018-18527": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2018-18529": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18530": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18531": {"epss_score": 0.00359, "epss_percentile": 0.57618}, "CVE-2018-18535": {"epss_score": 0.00125, "epss_percentile": 0.32546}, "CVE-2018-18536": {"epss_score": 0.00125, "epss_percentile": 0.32546}, "CVE-2018-18537": {"epss_score": 0.00112, "epss_percentile": 0.30551}, "CVE-2018-18540": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18541": {"epss_score": 0.01877, "epss_percentile": 0.82666}, "CVE-2018-18544": {"epss_score": 0.00151, "epss_percentile": 0.36193}, "CVE-2018-18545": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-18546": {"epss_score": 0.0037, "epss_percentile": 0.58324}, "CVE-2018-18547": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-18548": {"epss_score": 0.02243, "epss_percentile": 0.84121}, "CVE-2018-18550": {"epss_score": 0.00336, "epss_percentile": 0.5593}, "CVE-2018-18551": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-18552": {"epss_score": 0.02202, "epss_percentile": 0.83986}, "CVE-2018-18553": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18555": {"epss_score": 0.01449, "epss_percentile": 0.80343}, "CVE-2018-18556": {"epss_score": 0.68881, "epss_percentile": 0.98566}, "CVE-2018-18557": {"epss_score": 0.32235, "epss_percentile": 0.96681}, "CVE-2018-18558": {"epss_score": 0.00036, "epss_percentile": 0.10228}, "CVE-2018-18559": {"epss_score": 0.0114, "epss_percentile": 0.77948}, "CVE-2018-18561": {"epss_score": 0.00262, "epss_percentile": 0.49392}, "CVE-2018-18562": {"epss_score": 0.00222, "epss_percentile": 0.44747}, "CVE-2018-18563": {"epss_score": 0.00216, "epss_percentile": 0.44235}, "CVE-2018-18564": {"epss_score": 0.00154, "epss_percentile": 0.36683}, "CVE-2018-18565": {"epss_score": 0.00188, "epss_percentile": 0.40891}, "CVE-2018-18566": {"epss_score": 0.00376, "epss_percentile": 0.58646}, "CVE-2018-18567": {"epss_score": 0.00729, "epss_percentile": 0.72129}, "CVE-2018-18568": {"epss_score": 0.00133, "epss_percentile": 0.33654}, "CVE-2018-18569": {"epss_score": 0.00461, "epss_percentile": 0.63555}, "CVE-2018-18570": {"epss_score": 0.11047, "epss_percentile": 0.93201}, "CVE-2018-18571": {"epss_score": 0.00335, "epss_percentile": 0.558}, "CVE-2018-18572": {"epss_score": 0.0188, "epss_percentile": 0.82684}, "CVE-2018-18573": {"epss_score": 0.02215, "epss_percentile": 0.84027}, "CVE-2018-18576": {"epss_score": 0.00237, "epss_percentile": 0.46731}, "CVE-2018-18578": {"epss_score": 0.0024, "epss_percentile": 0.47197}, "CVE-2018-18579": {"epss_score": 0.0024, "epss_percentile": 0.47197}, "CVE-2018-18581": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2018-18582": {"epss_score": 0.0042, "epss_percentile": 0.61459}, "CVE-2018-18583": {"epss_score": 0.0042, "epss_percentile": 0.61459}, "CVE-2018-18584": {"epss_score": 0.06374, "epss_percentile": 0.90706}, "CVE-2018-18585": {"epss_score": 0.01461, "epss_percentile": 0.80431}, "CVE-2018-18586": {"epss_score": 0.00515, "epss_percentile": 0.65987}, "CVE-2018-18587": {"epss_score": 0.00091, "epss_percentile": 0.26225}, "CVE-2018-18589": {"epss_score": 0.0146, "epss_percentile": 0.80422}, "CVE-2018-18590": {"epss_score": 0.00248, "epss_percentile": 0.47984}, "CVE-2018-18591": {"epss_score": 0.00215, "epss_percentile": 0.44026}, "CVE-2018-18593": {"epss_score": 0.01526, "epss_percentile": 0.80864}, "CVE-2018-18599": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2018-18600": {"epss_score": 0.02799, "epss_percentile": 0.8569}, "CVE-2018-18601": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2018-18602": {"epss_score": 0.00345, "epss_percentile": 0.56564}, "CVE-2018-18603": {"epss_score": 0.00261, "epss_percentile": 0.49309}, "CVE-2018-18605": {"epss_score": 0.00419, "epss_percentile": 0.6136}, "CVE-2018-18606": {"epss_score": 0.00678, "epss_percentile": 0.70974}, "CVE-2018-18607": {"epss_score": 0.00373, "epss_percentile": 0.58474}, "CVE-2018-18608": {"epss_score": 0.07885, "epss_percentile": 0.91743}, "CVE-2018-18619": {"epss_score": 0.03304, "epss_percentile": 0.86869}, "CVE-2018-18621": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-18622": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18623": {"epss_score": 0.00419, "epss_percentile": 0.61377}, "CVE-2018-18624": {"epss_score": 0.00563, "epss_percentile": 0.67737}, "CVE-2018-18625": {"epss_score": 0.00825, "epss_percentile": 0.73952}, "CVE-2018-18626": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-18628": {"epss_score": 0.04385, "epss_percentile": 0.88631}, "CVE-2018-18629": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2018-18630": {"epss_score": 0.0004, "epss_percentile": 0.12077}, "CVE-2018-18631": {"epss_score": 0.00478, "epss_percentile": 0.64387}, "CVE-2018-18635": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18636": {"epss_score": 0.00281, "epss_percentile": 0.51113}, "CVE-2018-18638": {"epss_score": 0.05088, "epss_percentile": 0.8948}, "CVE-2018-18640": {"epss_score": 0.00112, "epss_percentile": 0.30436}, "CVE-2018-18641": {"epss_score": 0.00061, "epss_percentile": 0.19488}, "CVE-2018-18642": {"epss_score": 0.00069, "epss_percentile": 0.21557}, "CVE-2018-18643": {"epss_score": 0.00117, "epss_percentile": 0.31288}, "CVE-2018-18644": {"epss_score": 0.00113, "epss_percentile": 0.3066}, "CVE-2018-18645": {"epss_score": 0.00097, "epss_percentile": 0.27513}, "CVE-2018-18646": {"epss_score": 0.00226, "epss_percentile": 0.45345}, "CVE-2018-18647": {"epss_score": 0.00082, "epss_percentile": 0.24546}, "CVE-2018-18648": {"epss_score": 0.00106, "epss_percentile": 0.29502}, "CVE-2018-18649": {"epss_score": 0.54969, "epss_percentile": 0.97955}, "CVE-2018-18650": {"epss_score": 0.00178, "epss_percentile": 0.39744}, "CVE-2018-18651": {"epss_score": 0.00178, "epss_percentile": 0.39744}, "CVE-2018-18652": {"epss_score": 0.00701, "epss_percentile": 0.71493}, "CVE-2018-18653": {"epss_score": 0.00023, "epss_percentile": 0.05348}, "CVE-2018-18654": {"epss_score": 0.00028, "epss_percentile": 0.07533}, "CVE-2018-18655": {"epss_score": 0.00205, "epss_percentile": 0.42757}, "CVE-2018-18656": {"epss_score": 0.00044, "epss_percentile": 0.13397}, "CVE-2018-18657": {"epss_score": 0.00365, "epss_percentile": 0.57977}, "CVE-2018-18658": {"epss_score": 0.00365, "epss_percentile": 0.57977}, "CVE-2018-18659": {"epss_score": 0.00312, "epss_percentile": 0.53997}, "CVE-2018-18660": {"epss_score": 0.00309, "epss_percentile": 0.53677}, "CVE-2018-18661": {"epss_score": 0.00185, "epss_percentile": 0.40471}, "CVE-2018-18662": {"epss_score": 0.00347, "epss_percentile": 0.56756}, "CVE-2018-18665": {"epss_score": 0.00396, "epss_percentile": 0.59882}, "CVE-2018-18666": {"epss_score": 0.00272, "epss_percentile": 0.5039}, "CVE-2018-18667": {"epss_score": 0.00272, "epss_percentile": 0.5039}, "CVE-2018-18668": {"epss_score": 0.0027, "epss_percentile": 0.50196}, "CVE-2018-18669": {"epss_score": 0.0037, "epss_percentile": 0.58319}, "CVE-2018-18670": {"epss_score": 0.0037, "epss_percentile": 0.58319}, "CVE-2018-18671": {"epss_score": 0.0037, "epss_percentile": 0.58319}, "CVE-2018-18672": {"epss_score": 0.0037, "epss_percentile": 0.58319}, "CVE-2018-18673": {"epss_score": 0.0037, "epss_percentile": 0.58319}, "CVE-2018-18674": {"epss_score": 0.00664, "epss_percentile": 0.70646}, "CVE-2018-18675": {"epss_score": 0.0037, "epss_percentile": 0.58319}, "CVE-2018-18676": {"epss_score": 0.0037, "epss_percentile": 0.58319}, "CVE-2018-18678": {"epss_score": 0.00664, "epss_percentile": 0.70646}, "CVE-2018-18688": {"epss_score": 2e-05, "epss_percentile": 0.00026}, "CVE-2018-18689": {"epss_score": 2e-05, "epss_percentile": 0.00041}, "CVE-2018-18690": {"epss_score": 0.00058, "epss_percentile": 0.18536}, "CVE-2018-18692": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-18694": {"epss_score": 0.00179, "epss_percentile": 0.39804}, "CVE-2018-18695": {"epss_score": 0.00165, "epss_percentile": 0.38039}, "CVE-2018-18696": {"epss_score": 0.00229, "epss_percentile": 0.45658}, "CVE-2018-18698": {"epss_score": 0.00305, "epss_percentile": 0.53383}, "CVE-2018-18699": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2018-18700": {"epss_score": 0.0063, "epss_percentile": 0.69696}, "CVE-2018-18701": {"epss_score": 0.00442, "epss_percentile": 0.62708}, "CVE-2018-18702": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18703": {"epss_score": 0.04181, "epss_percentile": 0.88357}, "CVE-2018-18704": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2018-18705": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2018-18706": {"epss_score": 0.00503, "epss_percentile": 0.65456}, "CVE-2018-18707": {"epss_score": 0.00503, "epss_percentile": 0.65456}, "CVE-2018-18708": {"epss_score": 0.00644, "epss_percentile": 0.70068}, "CVE-2018-18709": {"epss_score": 0.00503, "epss_percentile": 0.65456}, "CVE-2018-18710": {"epss_score": 0.0004, "epss_percentile": 0.11905}, "CVE-2018-18711": {"epss_score": 0.00177, "epss_percentile": 0.39535}, "CVE-2018-18712": {"epss_score": 0.00177, "epss_percentile": 0.39535}, "CVE-2018-18713": {"epss_score": 0.01054, "epss_percentile": 0.77106}, "CVE-2018-18714": {"epss_score": 0.01716, "epss_percentile": 0.81906}, "CVE-2018-18715": {"epss_score": 0.00524, "epss_percentile": 0.66318}, "CVE-2018-18716": {"epss_score": 0.0101, "epss_percentile": 0.76602}, "CVE-2018-18717": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18718": {"epss_score": 0.00134, "epss_percentile": 0.3376}, "CVE-2018-18720": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18721": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18722": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18723": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18724": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18725": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18726": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18727": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2018-18728": {"epss_score": 0.03112, "epss_percentile": 0.86428}, "CVE-2018-18729": {"epss_score": 0.00449, "epss_percentile": 0.63033}, "CVE-2018-18730": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2018-18731": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2018-18732": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2018-18733": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-18734": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-18735": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-18736": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-18737": {"epss_score": 0.00371, "epss_percentile": 0.58409}, "CVE-2018-18738": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18739": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18740": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18741": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18742": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-18743": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18744": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18745": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18748": {"epss_score": 0.00803, "epss_percentile": 0.73601}, "CVE-2018-18749": {"epss_score": 0.00286, "epss_percentile": 0.51783}, "CVE-2018-18751": {"epss_score": 0.00633, "epss_percentile": 0.69755}, "CVE-2018-18752": {"epss_score": 0.00412, "epss_percentile": 0.60924}, "CVE-2018-18753": {"epss_score": 0.02593, "epss_percentile": 0.85187}, "CVE-2018-18754": {"epss_score": 0.00305, "epss_percentile": 0.53383}, "CVE-2018-18755": {"epss_score": 0.02501, "epss_percentile": 0.84922}, "CVE-2018-18756": {"epss_score": 0.00341, "epss_percentile": 0.56315}, "CVE-2018-18757": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-18758": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2018-18759": {"epss_score": 0.2157, "epss_percentile": 0.95535}, "CVE-2018-18760": {"epss_score": 0.00691, "epss_percentile": 0.71264}, "CVE-2018-18761": {"epss_score": 0.01335, "epss_percentile": 0.79549}, "CVE-2018-18762": {"epss_score": 0.09943, "epss_percentile": 0.92784}, "CVE-2018-18763": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-18764": {"epss_score": 0.00378, "epss_percentile": 0.5883}, "CVE-2018-18765": {"epss_score": 0.00378, "epss_percentile": 0.5883}, "CVE-2018-18766": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2018-18767": {"epss_score": 0.00169, "epss_percentile": 0.38618}, "CVE-2018-18771": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-18772": {"epss_score": 0.00503, "epss_percentile": 0.65438}, "CVE-2018-18773": {"epss_score": 0.00402, "epss_percentile": 0.6031}, "CVE-2018-18774": {"epss_score": 0.03786, "epss_percentile": 0.87726}, "CVE-2018-18775": {"epss_score": 0.16021, "epss_percentile": 0.94561}, "CVE-2018-18776": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-18777": {"epss_score": 0.69525, "epss_percentile": 0.98591}, "CVE-2018-18778": {"epss_score": 0.92777, "epss_percentile": 0.99747}, "CVE-2018-18781": {"epss_score": 0.00206, "epss_percentile": 0.4294}, "CVE-2018-18782": {"epss_score": 0.00206, "epss_percentile": 0.4294}, "CVE-2018-18783": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18784": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2018-18785": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18786": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18787": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18788": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2018-18789": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18790": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2018-18791": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18792": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18793": {"epss_score": 0.18905, "epss_percentile": 0.95094}, "CVE-2018-18794": {"epss_score": 0.00249, "epss_percentile": 0.48059}, "CVE-2018-18795": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-18796": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2018-18797": {"epss_score": 0.00249, "epss_percentile": 0.48059}, "CVE-2018-18798": {"epss_score": 0.03032, "epss_percentile": 0.86251}, "CVE-2018-18799": {"epss_score": 0.00249, "epss_percentile": 0.48059}, "CVE-2018-18800": {"epss_score": 0.03032, "epss_percentile": 0.86251}, "CVE-2018-18801": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-18802": {"epss_score": 0.00227, "epss_percentile": 0.45405}, "CVE-2018-18803": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-18804": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2018-18805": {"epss_score": 0.03786, "epss_percentile": 0.87725}, "CVE-2018-18806": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2018-18807": {"epss_score": 0.00245, "epss_percentile": 0.4765}, "CVE-2018-18808": {"epss_score": 0.00354, "epss_percentile": 0.57218}, "CVE-2018-18809": {"epss_score": 0.94068, "epss_percentile": 0.99897}, "CVE-2018-18810": {"epss_score": 0.00183, "epss_percentile": 0.403}, "CVE-2018-18812": {"epss_score": 0.00148, "epss_percentile": 0.35825}, "CVE-2018-18813": {"epss_score": 0.00272, "epss_percentile": 0.50348}, "CVE-2018-18814": {"epss_score": 0.01953, "epss_percentile": 0.83024}, "CVE-2018-18815": {"epss_score": 0.00252, "epss_percentile": 0.48376}, "CVE-2018-18816": {"epss_score": 0.00254, "epss_percentile": 0.48531}, "CVE-2018-18817": {"epss_score": 0.00235, "epss_percentile": 0.46213}, "CVE-2018-18819": {"epss_score": 0.00343, "epss_percentile": 0.56445}, "CVE-2018-18820": {"epss_score": 0.63676, "epss_percentile": 0.98344}, "CVE-2018-18822": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2018-18823": {"epss_score": 0.00302, "epss_percentile": 0.53129}, "CVE-2018-18824": {"epss_score": 0.00302, "epss_percentile": 0.53129}, "CVE-2018-18825": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18826": {"epss_score": 0.00252, "epss_percentile": 0.48388}, "CVE-2018-18827": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2018-18828": {"epss_score": 0.00252, "epss_percentile": 0.48388}, "CVE-2018-18829": {"epss_score": 0.00239, "epss_percentile": 0.46868}, "CVE-2018-18830": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-18831": {"epss_score": 0.00456, "epss_percentile": 0.63343}, "CVE-2018-18832": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18834": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2018-18835": {"epss_score": 0.00994, "epss_percentile": 0.76426}, "CVE-2018-18836": {"epss_score": 0.00636, "epss_percentile": 0.69862}, "CVE-2018-18837": {"epss_score": 0.0062, "epss_percentile": 0.69446}, "CVE-2018-18838": {"epss_score": 0.00505, "epss_percentile": 0.65602}, "CVE-2018-18839": {"epss_score": 0.00366, "epss_percentile": 0.58064}, "CVE-2018-18840": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2018-18841": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18842": {"epss_score": 0.00221, "epss_percentile": 0.44641}, "CVE-2018-18843": {"epss_score": 0.0025, "epss_percentile": 0.48244}, "CVE-2018-18845": {"epss_score": 0.00641, "epss_percentile": 0.69995}, "CVE-2018-18849": {"epss_score": 0.00047, "epss_percentile": 0.14631}, "CVE-2018-18850": {"epss_score": 0.53425, "epss_percentile": 0.97876}, "CVE-2018-18852": {"epss_score": 0.70822, "epss_percentile": 0.98643}, "CVE-2018-18853": {"epss_score": 0.00838, "epss_percentile": 0.74182}, "CVE-2018-18854": {"epss_score": 0.00838, "epss_percentile": 0.74182}, "CVE-2018-18856": {"epss_score": 0.01424, "epss_percentile": 0.80193}, "CVE-2018-18857": {"epss_score": 0.00496, "epss_percentile": 0.65149}, "CVE-2018-18858": {"epss_score": 0.00496, "epss_percentile": 0.65149}, "CVE-2018-18859": {"epss_score": 0.00496, "epss_percentile": 0.65149}, "CVE-2018-18860": {"epss_score": 0.00424, "epss_percentile": 0.61675}, "CVE-2018-18861": {"epss_score": 0.02576, "epss_percentile": 0.85143}, "CVE-2018-18862": {"epss_score": 0.00577, "epss_percentile": 0.68159}, "CVE-2018-18863": {"epss_score": 0.0051, "epss_percentile": 0.65766}, "CVE-2018-18864": {"epss_score": 0.00931, "epss_percentile": 0.75618}, "CVE-2018-18865": {"epss_score": 0.23919, "epss_percentile": 0.95833}, "CVE-2018-18867": {"epss_score": 0.00371, "epss_percentile": 0.58409}, "CVE-2018-18868": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18869": {"epss_score": 0.03782, "epss_percentile": 0.87721}, "CVE-2018-18871": {"epss_score": 0.00622, "epss_percentile": 0.69496}, "CVE-2018-18872": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2018-18873": {"epss_score": 0.00445, "epss_percentile": 0.62867}, "CVE-2018-18874": {"epss_score": 0.00705, "epss_percentile": 0.716}, "CVE-2018-18875": {"epss_score": 0.00118, "epss_percentile": 0.31432}, "CVE-2018-18876": {"epss_score": 0.00136, "epss_percentile": 0.34124}, "CVE-2018-18877": {"epss_score": 0.00177, "epss_percentile": 0.39518}, "CVE-2018-18878": {"epss_score": 0.02814, "epss_percentile": 0.85726}, "CVE-2018-18879": {"epss_score": 0.00423, "epss_percentile": 0.61616}, "CVE-2018-18880": {"epss_score": 0.00118, "epss_percentile": 0.31432}, "CVE-2018-18881": {"epss_score": 0.00734, "epss_percentile": 0.72238}, "CVE-2018-18882": {"epss_score": 0.00397, "epss_percentile": 0.60033}, "CVE-2018-18883": {"epss_score": 0.00172, "epss_percentile": 0.38936}, "CVE-2018-18886": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18887": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-18888": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-18890": {"epss_score": 0.00366, "epss_percentile": 0.58091}, "CVE-2018-18891": {"epss_score": 0.0038, "epss_percentile": 0.58944}, "CVE-2018-18892": {"epss_score": 0.01185, "epss_percentile": 0.78338}, "CVE-2018-18893": {"epss_score": 0.00453, "epss_percentile": 0.63221}, "CVE-2018-18894": {"epss_score": 0.00271, "epss_percentile": 0.5029}, "CVE-2018-18897": {"epss_score": 0.00197, "epss_percentile": 0.41831}, "CVE-2018-18898": {"epss_score": 0.01443, "epss_percentile": 0.80314}, "CVE-2018-18903": {"epss_score": 0.04855, "epss_percentile": 0.89218}, "CVE-2018-18907": {"epss_score": 0.00199, "epss_percentile": 0.42147}, "CVE-2018-18908": {"epss_score": 0.00125, "epss_percentile": 0.32622}, "CVE-2018-18909": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-18912": {"epss_score": 0.02868, "epss_percentile": 0.85868}, "CVE-2018-18913": {"epss_score": 0.00047, "epss_percentile": 0.14583}, "CVE-2018-18915": {"epss_score": 0.00605, "epss_percentile": 0.68997}, "CVE-2018-18919": {"epss_score": 0.00458, "epss_percentile": 0.63442}, "CVE-2018-18920": {"epss_score": 0.0075, "epss_percentile": 0.72614}, "CVE-2018-18921": {"epss_score": 0.00128, "epss_percentile": 0.3302}, "CVE-2018-18922": {"epss_score": 0.03141, "epss_percentile": 0.86486}, "CVE-2018-18923": {"epss_score": 0.0267, "epss_percentile": 0.85386}, "CVE-2018-18924": {"epss_score": 0.03384, "epss_percentile": 0.87038}, "CVE-2018-18925": {"epss_score": 0.93737, "epss_percentile": 0.99838}, "CVE-2018-18926": {"epss_score": 0.07092, "epss_percentile": 0.91244}, "CVE-2018-18927": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18928": {"epss_score": 0.02103, "epss_percentile": 0.83609}, "CVE-2018-18929": {"epss_score": 0.00288, "epss_percentile": 0.51883}, "CVE-2018-18930": {"epss_score": 0.01491, "epss_percentile": 0.80635}, "CVE-2018-18931": {"epss_score": 0.00242, "epss_percentile": 0.47362}, "CVE-2018-18933": {"epss_score": 0.01651, "epss_percentile": 0.81568}, "CVE-2018-18934": {"epss_score": 0.00129, "epss_percentile": 0.33133}, "CVE-2018-18935": {"epss_score": 0.00118, "epss_percentile": 0.31448}, "CVE-2018-18936": {"epss_score": 0.00553, "epss_percentile": 0.67405}, "CVE-2018-18937": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2018-18938": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18939": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-18940": {"epss_score": 0.00444, "epss_percentile": 0.62834}, "CVE-2018-18941": {"epss_score": 0.00805, "epss_percentile": 0.73641}, "CVE-2018-18942": {"epss_score": 0.02445, "epss_percentile": 0.84767}, "CVE-2018-18943": {"epss_score": 0.00329, "epss_percentile": 0.5539}, "CVE-2018-18944": {"epss_score": 0.00168, "epss_percentile": 0.38443}, "CVE-2018-18949": {"epss_score": 0.12833, "epss_percentile": 0.93798}, "CVE-2018-18950": {"epss_score": 0.00592, "epss_percentile": 0.68625}, "CVE-2018-18952": {"epss_score": 0.00064, "epss_percentile": 0.20421}, "CVE-2018-18954": {"epss_score": 0.00119, "epss_percentile": 0.31633}, "CVE-2018-18955": {"epss_score": 0.1222, "epss_percentile": 0.93606}, "CVE-2018-18956": {"epss_score": 0.01143, "epss_percentile": 0.77985}, "CVE-2018-18957": {"epss_score": 0.04683, "epss_percentile": 0.89003}, "CVE-2018-18958": {"epss_score": 0.00125, "epss_percentile": 0.32598}, "CVE-2018-18959": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-18960": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-18963": {"epss_score": 0.00367, "epss_percentile": 0.58122}, "CVE-2018-18964": {"epss_score": 0.0022, "epss_percentile": 0.44627}, "CVE-2018-18965": {"epss_score": 0.0022, "epss_percentile": 0.44627}, "CVE-2018-18966": {"epss_score": 0.0022, "epss_percentile": 0.44627}, "CVE-2018-18975": {"epss_score": 0.00211, "epss_percentile": 0.4367}, "CVE-2018-18976": {"epss_score": 0.00205, "epss_percentile": 0.4273}, "CVE-2018-18977": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-18978": {"epss_score": 0.00183, "epss_percentile": 0.40362}, "CVE-2018-18979": {"epss_score": 0.00341, "epss_percentile": 0.56317}, "CVE-2018-18980": {"epss_score": 0.30508, "epss_percentile": 0.96546}, "CVE-2018-18981": {"epss_score": 0.0017, "epss_percentile": 0.38734}, "CVE-2018-18982": {"epss_score": 0.66827, "epss_percentile": 0.98481}, "CVE-2018-18983": {"epss_score": 0.01114, "epss_percentile": 0.777}, "CVE-2018-18984": {"epss_score": 0.00084, "epss_percentile": 0.24851}, "CVE-2018-18985": {"epss_score": 0.00206, "epss_percentile": 0.42782}, "CVE-2018-18986": {"epss_score": 0.00469, "epss_percentile": 0.63951}, "CVE-2018-18987": {"epss_score": 0.01025, "epss_percentile": 0.76786}, "CVE-2018-18988": {"epss_score": 0.01101, "epss_percentile": 0.77572}, "CVE-2018-18989": {"epss_score": 0.00193, "epss_percentile": 0.41385}, "CVE-2018-18990": {"epss_score": 0.04258, "epss_percentile": 0.8846}, "CVE-2018-18991": {"epss_score": 0.0018, "epss_percentile": 0.39982}, "CVE-2018-18992": {"epss_score": 0.00435, "epss_percentile": 0.62379}, "CVE-2018-18993": {"epss_score": 0.0056, "epss_percentile": 0.67636}, "CVE-2018-18994": {"epss_score": 0.0013, "epss_percentile": 0.33328}, "CVE-2018-18995": {"epss_score": 0.01317, "epss_percentile": 0.79417}, "CVE-2018-18996": {"epss_score": 0.0062, "epss_percentile": 0.69455}, "CVE-2018-18997": {"epss_score": 0.00255, "epss_percentile": 0.48634}, "CVE-2018-18998": {"epss_score": 0.00625, "epss_percentile": 0.69598}, "CVE-2018-18999": {"epss_score": 0.00379, "epss_percentile": 0.58893}, "CVE-2018-1999001": {"epss_score": 0.27312, "epss_percentile": 0.96235}, "CVE-2018-1999002": {"epss_score": 0.92067, "epss_percentile": 0.99689}, "CVE-2018-1999003": {"epss_score": 0.00146, "epss_percentile": 0.35578}, "CVE-2018-1999004": {"epss_score": 0.002, "epss_percentile": 0.4224}, "CVE-2018-1999005": {"epss_score": 0.00158, "epss_percentile": 0.37292}, "CVE-2018-1999006": {"epss_score": 0.00161, "epss_percentile": 0.37578}, "CVE-2018-1999007": {"epss_score": 0.00158, "epss_percentile": 0.37292}, "CVE-2018-1999008": {"epss_score": 0.0033, "epss_percentile": 0.55436}, "CVE-2018-1999009": {"epss_score": 0.01893, "epss_percentile": 0.82739}, "CVE-2018-1999010": {"epss_score": 0.00497, "epss_percentile": 0.65195}, "CVE-2018-1999011": {"epss_score": 0.033, "epss_percentile": 0.86866}, "CVE-2018-1999012": {"epss_score": 0.00512, "epss_percentile": 0.65853}, "CVE-2018-1999013": {"epss_score": 0.00364, "epss_percentile": 0.57948}, "CVE-2018-1999014": {"epss_score": 0.0044, "epss_percentile": 0.62648}, "CVE-2018-1999015": {"epss_score": 0.00398, "epss_percentile": 0.60076}, "CVE-2018-1999016": {"epss_score": 0.00187, "epss_percentile": 0.40722}, "CVE-2018-1999017": {"epss_score": 0.00352, "epss_percentile": 0.57092}, "CVE-2018-1999018": {"epss_score": 0.02815, "epss_percentile": 0.85729}, "CVE-2018-1999019": {"epss_score": 0.01773, "epss_percentile": 0.82204}, "CVE-2018-1999020": {"epss_score": 0.0084, "epss_percentile": 0.74209}, "CVE-2018-1999021": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-1999022": {"epss_score": 0.01399, "epss_percentile": 0.79994}, "CVE-2018-1999023": {"epss_score": 0.00448, "epss_percentile": 0.62994}, "CVE-2018-1999024": {"epss_score": 0.00239, "epss_percentile": 0.46917}, "CVE-2018-1999025": {"epss_score": 0.00042, "epss_percentile": 0.12905}, "CVE-2018-1999026": {"epss_score": 0.0003, "epss_percentile": 0.08076}, "CVE-2018-1999027": {"epss_score": 0.00066, "epss_percentile": 0.20748}, "CVE-2018-1999028": {"epss_score": 0.00113, "epss_percentile": 0.30666}, "CVE-2018-1999029": {"epss_score": 0.00058, "epss_percentile": 0.18534}, "CVE-2018-1999030": {"epss_score": 0.00035, "epss_percentile": 0.1004}, "CVE-2018-1999031": {"epss_score": 0.00072, "epss_percentile": 0.22416}, "CVE-2018-1999032": {"epss_score": 0.00127, "epss_percentile": 0.329}, "CVE-2018-1999033": {"epss_score": 0.00273, "epss_percentile": 0.50444}, "CVE-2018-1999034": {"epss_score": 0.00042, "epss_percentile": 0.12905}, "CVE-2018-1999035": {"epss_score": 0.00042, "epss_percentile": 0.12905}, "CVE-2018-1999036": {"epss_score": 0.00204, "epss_percentile": 0.42605}, "CVE-2018-1999037": {"epss_score": 0.00088, "epss_percentile": 0.25699}, "CVE-2018-1999038": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2018-1999039": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2018-1999040": {"epss_score": 0.00379, "epss_percentile": 0.589}, "CVE-2018-1999041": {"epss_score": 0.00015, "epss_percentile": 0.02601}, "CVE-2018-1999042": {"epss_score": 0.00227, "epss_percentile": 0.45441}, "CVE-2018-1999043": {"epss_score": 0.00328, "epss_percentile": 0.55185}, "CVE-2018-1999044": {"epss_score": 0.00136, "epss_percentile": 0.34177}, "CVE-2018-1999045": {"epss_score": 0.00119, "epss_percentile": 0.31569}, "CVE-2018-1999046": {"epss_score": 0.00188, "epss_percentile": 0.40921}, "CVE-2018-1999047": {"epss_score": 0.00114, "epss_percentile": 0.30881}, "CVE-2018-19000": {"epss_score": 0.00452, "epss_percentile": 0.6319}, "CVE-2018-19001": {"epss_score": 0.00017, "epss_percentile": 0.03253}, "CVE-2018-19002": {"epss_score": 0.00469, "epss_percentile": 0.63949}, "CVE-2018-19003": {"epss_score": 0.01804, "epss_percentile": 0.82343}, "CVE-2018-19004": {"epss_score": 0.00139, "epss_percentile": 0.34648}, "CVE-2018-19005": {"epss_score": 0.00204, "epss_percentile": 0.42596}, "CVE-2018-19006": {"epss_score": 0.0016, "epss_percentile": 0.3746}, "CVE-2018-19007": {"epss_score": 0.01999, "epss_percentile": 0.83212}, "CVE-2018-19008": {"epss_score": 0.00269, "epss_percentile": 0.50105}, "CVE-2018-19009": {"epss_score": 0.00033, "epss_percentile": 0.09346}, "CVE-2018-19010": {"epss_score": 0.00179, "epss_percentile": 0.39804}, "CVE-2018-19011": {"epss_score": 0.00506, "epss_percentile": 0.6564}, "CVE-2018-19012": {"epss_score": 0.00067, "epss_percentile": 0.21108}, "CVE-2018-19013": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2018-19014": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2018-19015": {"epss_score": 0.00173, "epss_percentile": 0.39086}, "CVE-2018-19016": {"epss_score": 0.00041, "epss_percentile": 0.12372}, "CVE-2018-19017": {"epss_score": 0.00535, "epss_percentile": 0.66833}, "CVE-2018-19018": {"epss_score": 0.0023, "epss_percentile": 0.45727}, "CVE-2018-19019": {"epss_score": 0.0018, "epss_percentile": 0.39992}, "CVE-2018-19020": {"epss_score": 0.00149, "epss_percentile": 0.35958}, "CVE-2018-19021": {"epss_score": 0.00495, "epss_percentile": 0.65109}, "CVE-2018-19023": {"epss_score": 0.0026, "epss_percentile": 0.49194}, "CVE-2018-19025": {"epss_score": 0.00235, "epss_percentile": 0.46235}, "CVE-2018-19027": {"epss_score": 0.00263, "epss_percentile": 0.4952}, "CVE-2018-19029": {"epss_score": 0.00469, "epss_percentile": 0.63951}, "CVE-2018-19031": {"epss_score": 0.03819, "epss_percentile": 0.87772}, "CVE-2018-19036": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2018-19037": {"epss_score": 0.00322, "epss_percentile": 0.54783}, "CVE-2018-19039": {"epss_score": 0.09218, "epss_percentile": 0.92454}, "CVE-2018-19040": {"epss_score": 0.10254, "epss_percentile": 0.92914}, "CVE-2018-19041": {"epss_score": 0.0016, "epss_percentile": 0.37434}, "CVE-2018-19042": {"epss_score": 0.04965, "epss_percentile": 0.89341}, "CVE-2018-19043": {"epss_score": 0.04965, "epss_percentile": 0.89341}, "CVE-2018-19044": {"epss_score": 0.00088, "epss_percentile": 0.2564}, "CVE-2018-19045": {"epss_score": 0.0045, "epss_percentile": 0.6309}, "CVE-2018-19046": {"epss_score": 0.00145, "epss_percentile": 0.35433}, "CVE-2018-19047": {"epss_score": 0.00349, "epss_percentile": 0.56887}, "CVE-2018-19048": {"epss_score": 0.00308, "epss_percentile": 0.53624}, "CVE-2018-19050": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19051": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19052": {"epss_score": 0.49517, "epss_percentile": 0.97692}, "CVE-2018-19053": {"epss_score": 0.0093, "epss_percentile": 0.75603}, "CVE-2018-19056": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-19057": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-19058": {"epss_score": 0.00276, "epss_percentile": 0.5075}, "CVE-2018-19059": {"epss_score": 0.00129, "epss_percentile": 0.33074}, "CVE-2018-19060": {"epss_score": 0.00147, "epss_percentile": 0.35797}, "CVE-2018-19061": {"epss_score": 0.00601, "epss_percentile": 0.68843}, "CVE-2018-19063": {"epss_score": 0.01223, "epss_percentile": 0.78669}, "CVE-2018-19064": {"epss_score": 0.01223, "epss_percentile": 0.78669}, "CVE-2018-19065": {"epss_score": 0.00564, "epss_percentile": 0.67744}, "CVE-2018-19066": {"epss_score": 0.00564, "epss_percentile": 0.67744}, "CVE-2018-19067": {"epss_score": 0.01223, "epss_percentile": 0.78669}, "CVE-2018-19068": {"epss_score": 0.00233, "epss_percentile": 0.46063}, "CVE-2018-19069": {"epss_score": 0.01223, "epss_percentile": 0.78669}, "CVE-2018-19070": {"epss_score": 0.02641, "epss_percentile": 0.85304}, "CVE-2018-19071": {"epss_score": 0.00109, "epss_percentile": 0.29986}, "CVE-2018-19072": {"epss_score": 0.00068, "epss_percentile": 0.2124}, "CVE-2018-19073": {"epss_score": 0.00803, "epss_percentile": 0.73599}, "CVE-2018-19074": {"epss_score": 0.0034, "epss_percentile": 0.56264}, "CVE-2018-19075": {"epss_score": 0.00568, "epss_percentile": 0.679}, "CVE-2018-19076": {"epss_score": 0.00607, "epss_percentile": 0.69053}, "CVE-2018-19077": {"epss_score": 0.01563, "epss_percentile": 0.81057}, "CVE-2018-19078": {"epss_score": 0.00579, "epss_percentile": 0.68209}, "CVE-2018-19079": {"epss_score": 0.00394, "epss_percentile": 0.59749}, "CVE-2018-19080": {"epss_score": 0.00275, "epss_percentile": 0.50627}, "CVE-2018-19081": {"epss_score": 0.0629, "epss_percentile": 0.90647}, "CVE-2018-19082": {"epss_score": 0.01891, "epss_percentile": 0.82729}, "CVE-2018-19083": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19084": {"epss_score": 0.00112, "epss_percentile": 0.30462}, "CVE-2018-19085": {"epss_score": 0.00112, "epss_percentile": 0.30462}, "CVE-2018-19086": {"epss_score": 0.00112, "epss_percentile": 0.30462}, "CVE-2018-19087": {"epss_score": 0.00112, "epss_percentile": 0.30462}, "CVE-2018-19089": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-19090": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-19091": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-19092": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19093": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-19104": {"epss_score": 0.00459, "epss_percentile": 0.6347}, "CVE-2018-19105": {"epss_score": 0.00908, "epss_percentile": 0.75276}, "CVE-2018-19106": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2018-19107": {"epss_score": 0.00302, "epss_percentile": 0.53158}, "CVE-2018-19108": {"epss_score": 0.00411, "epss_percentile": 0.60853}, "CVE-2018-19109": {"epss_score": 0.00346, "epss_percentile": 0.56608}, "CVE-2018-19110": {"epss_score": 0.00158, "epss_percentile": 0.37152}, "CVE-2018-19111": {"epss_score": 0.00048, "epss_percentile": 0.15101}, "CVE-2018-19113": {"epss_score": 0.0041, "epss_percentile": 0.60801}, "CVE-2018-19114": {"epss_score": 0.00336, "epss_percentile": 0.55952}, "CVE-2018-19115": {"epss_score": 0.06203, "epss_percentile": 0.90564}, "CVE-2018-19118": {"epss_score": 0.0708, "epss_percentile": 0.91237}, "CVE-2018-19120": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2018-19121": {"epss_score": 0.00222, "epss_percentile": 0.44801}, "CVE-2018-19122": {"epss_score": 0.0026, "epss_percentile": 0.49184}, "CVE-2018-19124": {"epss_score": 0.00412, "epss_percentile": 0.60937}, "CVE-2018-19125": {"epss_score": 0.15949, "epss_percentile": 0.94541}, "CVE-2018-19126": {"epss_score": 0.54746, "epss_percentile": 0.97941}, "CVE-2018-19127": {"epss_score": 0.84845, "epss_percentile": 0.99307}, "CVE-2018-19128": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2018-19129": {"epss_score": 0.00239, "epss_percentile": 0.46868}, "CVE-2018-19130": {"epss_score": 0.00257, "epss_percentile": 0.48943}, "CVE-2018-19131": {"epss_score": 0.06829, "epss_percentile": 0.91054}, "CVE-2018-19132": {"epss_score": 0.11349, "epss_percentile": 0.9332}, "CVE-2018-19133": {"epss_score": 0.00406, "epss_percentile": 0.60531}, "CVE-2018-19134": {"epss_score": 0.0131, "epss_percentile": 0.79359}, "CVE-2018-19135": {"epss_score": 0.00261, "epss_percentile": 0.49266}, "CVE-2018-19136": {"epss_score": 0.02193, "epss_percentile": 0.83945}, "CVE-2018-19137": {"epss_score": 0.01684, "epss_percentile": 0.81741}, "CVE-2018-19138": {"epss_score": 0.00228, "epss_percentile": 0.4552}, "CVE-2018-19139": {"epss_score": 0.00445, "epss_percentile": 0.62867}, "CVE-2018-19141": {"epss_score": 0.00269, "epss_percentile": 0.50114}, "CVE-2018-19142": {"epss_score": 0.00295, "epss_percentile": 0.52469}, "CVE-2018-19143": {"epss_score": 0.00126, "epss_percentile": 0.32647}, "CVE-2018-19145": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19146": {"epss_score": 0.0039, "epss_percentile": 0.59509}, "CVE-2018-19148": {"epss_score": 0.00158, "epss_percentile": 0.37183}, "CVE-2018-19149": {"epss_score": 0.00261, "epss_percentile": 0.4931}, "CVE-2018-19150": {"epss_score": 0.00474, "epss_percentile": 0.6415}, "CVE-2018-19151": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19152": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19153": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19154": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19155": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19156": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19157": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19158": {"epss_score": 0.00952, "epss_percentile": 0.7588}, "CVE-2018-19159": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19160": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19161": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19162": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19163": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19164": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19165": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19166": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19167": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2018-19168": {"epss_score": 0.1261, "epss_percentile": 0.93728}, "CVE-2018-19170": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19178": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2018-19180": {"epss_score": 0.0078, "epss_percentile": 0.73162}, "CVE-2018-19181": {"epss_score": 0.00613, "epss_percentile": 0.69249}, "CVE-2018-19182": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2018-19183": {"epss_score": 0.00625, "epss_percentile": 0.69589}, "CVE-2018-19184": {"epss_score": 0.00421, "epss_percentile": 0.61509}, "CVE-2018-19185": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2018-19186": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-19187": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-19188": {"epss_score": 0.00396, "epss_percentile": 0.59865}, "CVE-2018-19189": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-19190": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-19191": {"epss_score": 0.01753, "epss_percentile": 0.82111}, "CVE-2018-19192": {"epss_score": 0.00177, "epss_percentile": 0.39553}, "CVE-2018-19193": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19194": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2018-19195": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19196": {"epss_score": 0.00587, "epss_percentile": 0.68475}, "CVE-2018-19197": {"epss_score": 0.00764, "epss_percentile": 0.72902}, "CVE-2018-19198": {"epss_score": 0.00684, "epss_percentile": 0.71109}, "CVE-2018-19199": {"epss_score": 0.00697, "epss_percentile": 0.71399}, "CVE-2018-19200": {"epss_score": 0.01119, "epss_percentile": 0.77758}, "CVE-2018-19201": {"epss_score": 0.00272, "epss_percentile": 0.50359}, "CVE-2018-19202": {"epss_score": 0.00257, "epss_percentile": 0.48848}, "CVE-2018-19203": {"epss_score": 0.00797, "epss_percentile": 0.73498}, "CVE-2018-19204": {"epss_score": 0.01621, "epss_percentile": 0.81393}, "CVE-2018-19205": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2018-19206": {"epss_score": 0.02357, "epss_percentile": 0.84485}, "CVE-2018-19207": {"epss_score": 0.91939, "epss_percentile": 0.9968}, "CVE-2018-19208": {"epss_score": 0.00406, "epss_percentile": 0.60564}, "CVE-2018-19209": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2018-19210": {"epss_score": 0.04911, "epss_percentile": 0.8928}, "CVE-2018-19211": {"epss_score": 0.00278, "epss_percentile": 0.50901}, "CVE-2018-19212": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2018-19213": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2018-19214": {"epss_score": 0.00211, "epss_percentile": 0.43632}, "CVE-2018-19215": {"epss_score": 0.00211, "epss_percentile": 0.43632}, "CVE-2018-19216": {"epss_score": 0.00225, "epss_percentile": 0.45139}, "CVE-2018-19217": {"epss_score": 0.00404, "epss_percentile": 0.60433}, "CVE-2018-19218": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2018-19219": {"epss_score": 0.00257, "epss_percentile": 0.48943}, "CVE-2018-19220": {"epss_score": 0.00994, "epss_percentile": 0.76426}, "CVE-2018-19221": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-19222": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2018-19223": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19224": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-19225": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-19226": {"epss_score": 0.00244, "epss_percentile": 0.47619}, "CVE-2018-19227": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-19228": {"epss_score": 0.00718, "epss_percentile": 0.71923}, "CVE-2018-19229": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-19232": {"epss_score": 0.00623, "epss_percentile": 0.6954}, "CVE-2018-19233": {"epss_score": 0.00078, "epss_percentile": 0.23674}, "CVE-2018-19234": {"epss_score": 0.05409, "epss_percentile": 0.89843}, "CVE-2018-19239": {"epss_score": 0.03367, "epss_percentile": 0.87005}, "CVE-2018-19240": {"epss_score": 0.031, "epss_percentile": 0.86408}, "CVE-2018-19241": {"epss_score": 0.00771, "epss_percentile": 0.73026}, "CVE-2018-19242": {"epss_score": 0.0288, "epss_percentile": 0.85895}, "CVE-2018-19244": {"epss_score": 0.00547, "epss_percentile": 0.6725}, "CVE-2018-19246": {"epss_score": 0.55881, "epss_percentile": 0.98001}, "CVE-2018-19248": {"epss_score": 0.01084, "epss_percentile": 0.77399}, "CVE-2018-19249": {"epss_score": 0.0025, "epss_percentile": 0.48245}, "CVE-2018-19271": {"epss_score": 0.00301, "epss_percentile": 0.53009}, "CVE-2018-19274": {"epss_score": 0.14464, "epss_percentile": 0.94217}, "CVE-2018-19275": {"epss_score": 0.03102, "epss_percentile": 0.86411}, "CVE-2018-19276": {"epss_score": 0.9321, "epss_percentile": 0.99784}, "CVE-2018-19277": {"epss_score": 0.03159, "epss_percentile": 0.86522}, "CVE-2018-19278": {"epss_score": 0.03349, "epss_percentile": 0.86961}, "CVE-2018-19279": {"epss_score": 0.00028, "epss_percentile": 0.07447}, "CVE-2018-19280": {"epss_score": 0.00058, "epss_percentile": 0.18383}, "CVE-2018-19281": {"epss_score": 0.00208, "epss_percentile": 0.4321}, "CVE-2018-19282": {"epss_score": 0.00396, "epss_percentile": 0.59924}, "CVE-2018-19286": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19287": {"epss_score": 0.07673, "epss_percentile": 0.91617}, "CVE-2018-19288": {"epss_score": 0.01206, "epss_percentile": 0.78519}, "CVE-2018-19289": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2018-19290": {"epss_score": 0.0295, "epss_percentile": 0.86051}, "CVE-2018-19291": {"epss_score": 0.00083, "epss_percentile": 0.24717}, "CVE-2018-19295": {"epss_score": 0.00119, "epss_percentile": 0.31655}, "CVE-2018-19296": {"epss_score": 0.01345, "epss_percentile": 0.79622}, "CVE-2018-19300": {"epss_score": 0.20754, "epss_percentile": 0.95408}, "CVE-2018-19301": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19311": {"epss_score": 0.00067, "epss_percentile": 0.211}, "CVE-2018-19312": {"epss_score": 0.00151, "epss_percentile": 0.36215}, "CVE-2018-19318": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-19319": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2018-19320": {"epss_score": 0.38677, "epss_percentile": 0.97114}, "CVE-2018-19321": {"epss_score": 0.36681, "epss_percentile": 0.96995}, "CVE-2018-19322": {"epss_score": 0.03645, "epss_percentile": 0.87499}, "CVE-2018-19323": {"epss_score": 0.14716, "epss_percentile": 0.94269}, "CVE-2018-19324": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-19326": {"epss_score": 0.57635, "epss_percentile": 0.98076}, "CVE-2018-19327": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-19328": {"epss_score": 0.00562, "epss_percentile": 0.67682}, "CVE-2018-19329": {"epss_score": 0.00511, "epss_percentile": 0.65831}, "CVE-2018-19331": {"epss_score": 0.00332, "epss_percentile": 0.55562}, "CVE-2018-19332": {"epss_score": 0.00144, "epss_percentile": 0.35308}, "CVE-2018-19333": {"epss_score": 0.00166, "epss_percentile": 0.38162}, "CVE-2018-19334": {"epss_score": 0.00105, "epss_percentile": 0.29395}, "CVE-2018-19335": {"epss_score": 0.00105, "epss_percentile": 0.29395}, "CVE-2018-19340": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19341": {"epss_score": 0.00071, "epss_percentile": 0.22215}, "CVE-2018-19342": {"epss_score": 0.00139, "epss_percentile": 0.34587}, "CVE-2018-19343": {"epss_score": 0.00071, "epss_percentile": 0.22215}, "CVE-2018-19344": {"epss_score": 0.00071, "epss_percentile": 0.22215}, "CVE-2018-19345": {"epss_score": 0.00071, "epss_percentile": 0.22215}, "CVE-2018-19346": {"epss_score": 0.00071, "epss_percentile": 0.22215}, "CVE-2018-19347": {"epss_score": 0.00071, "epss_percentile": 0.22215}, "CVE-2018-19348": {"epss_score": 0.00139, "epss_percentile": 0.34587}, "CVE-2018-19349": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2018-19350": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-19351": {"epss_score": 0.00307, "epss_percentile": 0.53486}, "CVE-2018-19352": {"epss_score": 0.00283, "epss_percentile": 0.51351}, "CVE-2018-19353": {"epss_score": 0.00432, "epss_percentile": 0.62114}, "CVE-2018-19355": {"epss_score": 0.11017, "epss_percentile": 0.9319}, "CVE-2018-19357": {"epss_score": 0.16807, "epss_percentile": 0.94734}, "CVE-2018-19358": {"epss_score": 0.00114, "epss_percentile": 0.30785}, "CVE-2018-19359": {"epss_score": 0.00342, "epss_percentile": 0.56359}, "CVE-2018-19360": {"epss_score": 0.04124, "epss_percentile": 0.88287}, "CVE-2018-19361": {"epss_score": 0.02435, "epss_percentile": 0.84738}, "CVE-2018-19362": {"epss_score": 0.03079, "epss_percentile": 0.86369}, "CVE-2018-19364": {"epss_score": 0.00075, "epss_percentile": 0.23006}, "CVE-2018-19365": {"epss_score": 0.8708, "epss_percentile": 0.99413}, "CVE-2018-19367": {"epss_score": 0.00283, "epss_percentile": 0.51362}, "CVE-2018-19370": {"epss_score": 0.0013, "epss_percentile": 0.3329}, "CVE-2018-19371": {"epss_score": 0.05789, "epss_percentile": 0.90212}, "CVE-2018-19374": {"epss_score": 0.00103, "epss_percentile": 0.29001}, "CVE-2018-19376": {"epss_score": 0.00098, "epss_percentile": 0.27733}, "CVE-2018-19386": {"epss_score": 0.23271, "epss_percentile": 0.95759}, "CVE-2018-19388": {"epss_score": 0.0004, "epss_percentile": 0.11917}, "CVE-2018-19389": {"epss_score": 0.0004, "epss_percentile": 0.11917}, "CVE-2018-19390": {"epss_score": 0.0004, "epss_percentile": 0.11917}, "CVE-2018-19391": {"epss_score": 0.00489, "epss_percentile": 0.64907}, "CVE-2018-19392": {"epss_score": 0.00967, "epss_percentile": 0.76071}, "CVE-2018-19393": {"epss_score": 0.00395, "epss_percentile": 0.5981}, "CVE-2018-19394": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2018-19395": {"epss_score": 0.01303, "epss_percentile": 0.79307}, "CVE-2018-19396": {"epss_score": 0.01915, "epss_percentile": 0.82852}, "CVE-2018-19404": {"epss_score": 0.00784, "epss_percentile": 0.73237}, "CVE-2018-19406": {"epss_score": 0.00109, "epss_percentile": 0.30025}, "CVE-2018-19407": {"epss_score": 0.00082, "epss_percentile": 0.24429}, "CVE-2018-19409": {"epss_score": 0.10203, "epss_percentile": 0.92891}, "CVE-2018-19410": {"epss_score": 0.91753, "epss_percentile": 0.99666}, "CVE-2018-19411": {"epss_score": 0.00328, "epss_percentile": 0.55187}, "CVE-2018-19413": {"epss_score": 0.00541, "epss_percentile": 0.67032}, "CVE-2018-19414": {"epss_score": 0.02565, "epss_percentile": 0.85113}, "CVE-2018-19415": {"epss_score": 0.00527, "epss_percentile": 0.66468}, "CVE-2018-19416": {"epss_score": 0.00273, "epss_percentile": 0.50457}, "CVE-2018-19417": {"epss_score": 0.06154, "epss_percentile": 0.90523}, "CVE-2018-19418": {"epss_score": 0.04883, "epss_percentile": 0.89251}, "CVE-2018-19420": {"epss_score": 0.00221, "epss_percentile": 0.44658}, "CVE-2018-19421": {"epss_score": 0.00221, "epss_percentile": 0.44658}, "CVE-2018-19422": {"epss_score": 0.86014, "epss_percentile": 0.99362}, "CVE-2018-19423": {"epss_score": 0.25876, "epss_percentile": 0.96089}, "CVE-2018-19424": {"epss_score": 0.00682, "epss_percentile": 0.71063}, "CVE-2018-19432": {"epss_score": 0.00965, "epss_percentile": 0.76048}, "CVE-2018-19433": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19434": {"epss_score": 0.00277, "epss_percentile": 0.50805}, "CVE-2018-19435": {"epss_score": 0.00277, "epss_percentile": 0.50805}, "CVE-2018-19436": {"epss_score": 0.00277, "epss_percentile": 0.50805}, "CVE-2018-19437": {"epss_score": 0.00314, "epss_percentile": 0.54124}, "CVE-2018-19439": {"epss_score": 0.38875, "epss_percentile": 0.97124}, "CVE-2018-19440": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2018-19441": {"epss_score": 0.00112, "epss_percentile": 0.30581}, "CVE-2018-19442": {"epss_score": 0.18243, "epss_percentile": 0.94979}, "CVE-2018-19443": {"epss_score": 0.00196, "epss_percentile": 0.41809}, "CVE-2018-19444": {"epss_score": 0.00335, "epss_percentile": 0.55797}, "CVE-2018-19445": {"epss_score": 0.00489, "epss_percentile": 0.64901}, "CVE-2018-19446": {"epss_score": 0.00354, "epss_percentile": 0.57206}, "CVE-2018-19447": {"epss_score": 0.00322, "epss_percentile": 0.54796}, "CVE-2018-19448": {"epss_score": 0.00361, "epss_percentile": 0.57731}, "CVE-2018-19449": {"epss_score": 0.00313, "epss_percentile": 0.54024}, "CVE-2018-19450": {"epss_score": 0.00279, "epss_percentile": 0.50938}, "CVE-2018-19451": {"epss_score": 0.00674, "epss_percentile": 0.7086}, "CVE-2018-19452": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2018-19453": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2018-19456": {"epss_score": 0.00646, "epss_percentile": 0.70141}, "CVE-2018-19457": {"epss_score": 0.09502, "epss_percentile": 0.92575}, "CVE-2018-19458": {"epss_score": 0.79968, "epss_percentile": 0.99065}, "CVE-2018-19459": {"epss_score": 0.01753, "epss_percentile": 0.82111}, "CVE-2018-19461": {"epss_score": 0.00295, "epss_percentile": 0.52494}, "CVE-2018-19462": {"epss_score": 0.00312, "epss_percentile": 0.53954}, "CVE-2018-19463": {"epss_score": 0.01174, "epss_percentile": 0.78256}, "CVE-2018-19464": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19465": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19466": {"epss_score": 0.1342, "epss_percentile": 0.93959}, "CVE-2018-19468": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-19469": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-19475": {"epss_score": 0.63587, "epss_percentile": 0.98339}, "CVE-2018-19476": {"epss_score": 0.00823, "epss_percentile": 0.73923}, "CVE-2018-19477": {"epss_score": 0.00823, "epss_percentile": 0.73923}, "CVE-2018-19478": {"epss_score": 0.00643, "epss_percentile": 0.70052}, "CVE-2018-19486": {"epss_score": 0.00665, "epss_percentile": 0.70661}, "CVE-2018-19487": {"epss_score": 0.2626, "epss_percentile": 0.96131}, "CVE-2018-19488": {"epss_score": 0.2475, "epss_percentile": 0.95951}, "CVE-2018-19489": {"epss_score": 0.0004, "epss_percentile": 0.12048}, "CVE-2018-19490": {"epss_score": 0.00165, "epss_percentile": 0.38102}, "CVE-2018-19491": {"epss_score": 0.00165, "epss_percentile": 0.38102}, "CVE-2018-19492": {"epss_score": 0.00165, "epss_percentile": 0.38102}, "CVE-2018-19493": {"epss_score": 0.00096, "epss_percentile": 0.27282}, "CVE-2018-19494": {"epss_score": 0.00085, "epss_percentile": 0.25117}, "CVE-2018-19495": {"epss_score": 0.00092, "epss_percentile": 0.26564}, "CVE-2018-19496": {"epss_score": 0.00082, "epss_percentile": 0.24573}, "CVE-2018-19497": {"epss_score": 0.02413, "epss_percentile": 0.84677}, "CVE-2018-19498": {"epss_score": 0.00473, "epss_percentile": 0.64094}, "CVE-2018-19499": {"epss_score": 0.0231, "epss_percentile": 0.84336}, "CVE-2018-19502": {"epss_score": 0.00286, "epss_percentile": 0.51686}, "CVE-2018-19503": {"epss_score": 0.00378, "epss_percentile": 0.58802}, "CVE-2018-19504": {"epss_score": 0.00308, "epss_percentile": 0.53638}, "CVE-2018-19505": {"epss_score": 0.00382, "epss_percentile": 0.59067}, "CVE-2018-19506": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19507": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19508": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19509": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19510": {"epss_score": 0.01664, "epss_percentile": 0.81642}, "CVE-2018-19511": {"epss_score": 0.00166, "epss_percentile": 0.3824}, "CVE-2018-19512": {"epss_score": 0.04453, "epss_percentile": 0.88708}, "CVE-2018-19513": {"epss_score": 0.00691, "epss_percentile": 0.71263}, "CVE-2018-19514": {"epss_score": 0.05263, "epss_percentile": 0.89671}, "CVE-2018-19515": {"epss_score": 0.06487, "epss_percentile": 0.90791}, "CVE-2018-19516": {"epss_score": 0.00391, "epss_percentile": 0.59566}, "CVE-2018-19517": {"epss_score": 0.00266, "epss_percentile": 0.49917}, "CVE-2018-19518": {"epss_score": 0.93956, "epss_percentile": 0.99874}, "CVE-2018-19519": {"epss_score": 0.00383, "epss_percentile": 0.59104}, "CVE-2018-19520": {"epss_score": 0.01016, "epss_percentile": 0.76676}, "CVE-2018-19522": {"epss_score": 0.00059, "epss_percentile": 0.18873}, "CVE-2018-19523": {"epss_score": 0.00059, "epss_percentile": 0.18873}, "CVE-2018-19524": {"epss_score": 0.20891, "epss_percentile": 0.95434}, "CVE-2018-19525": {"epss_score": 0.00551, "epss_percentile": 0.67372}, "CVE-2018-19527": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19528": {"epss_score": 0.02506, "epss_percentile": 0.84937}, "CVE-2018-19530": {"epss_score": 0.0566, "epss_percentile": 0.90095}, "CVE-2018-19531": {"epss_score": 0.0566, "epss_percentile": 0.90095}, "CVE-2018-19532": {"epss_score": 0.00336, "epss_percentile": 0.55932}, "CVE-2018-19535": {"epss_score": 0.00358, "epss_percentile": 0.57508}, "CVE-2018-19537": {"epss_score": 0.19618, "epss_percentile": 0.95215}, "CVE-2018-19539": {"epss_score": 0.00962, "epss_percentile": 0.75997}, "CVE-2018-19540": {"epss_score": 0.00676, "epss_percentile": 0.7094}, "CVE-2018-19541": {"epss_score": 0.01179, "epss_percentile": 0.78297}, "CVE-2018-19542": {"epss_score": 0.00965, "epss_percentile": 0.76048}, "CVE-2018-19543": {"epss_score": 0.00344, "epss_percentile": 0.5653}, "CVE-2018-19544": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2018-19545": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-19546": {"epss_score": 0.00146, "epss_percentile": 0.35624}, "CVE-2018-19547": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19548": {"epss_score": 0.00398, "epss_percentile": 0.6007}, "CVE-2018-19549": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2018-19550": {"epss_score": 0.03519, "epss_percentile": 0.87282}, "CVE-2018-19551": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2018-19552": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2018-19553": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2018-19554": {"epss_score": 0.00162, "epss_percentile": 0.37682}, "CVE-2018-19555": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-19556": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2018-19557": {"epss_score": 0.00581, "epss_percentile": 0.68281}, "CVE-2018-19558": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-19559": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2018-19560": {"epss_score": 0.0015, "epss_percentile": 0.36106}, "CVE-2018-19561": {"epss_score": 0.00122, "epss_percentile": 0.32025}, "CVE-2018-19562": {"epss_score": 0.01251, "epss_percentile": 0.78893}, "CVE-2018-19564": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2018-19565": {"epss_score": 0.0031, "epss_percentile": 0.53765}, "CVE-2018-19566": {"epss_score": 0.00297, "epss_percentile": 0.52683}, "CVE-2018-19567": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2018-19568": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2018-19569": {"epss_score": 0.0026, "epss_percentile": 0.49153}, "CVE-2018-19570": {"epss_score": 0.00088, "epss_percentile": 0.25694}, "CVE-2018-19571": {"epss_score": 0.3523, "epss_percentile": 0.96895}, "CVE-2018-19572": {"epss_score": 0.00098, "epss_percentile": 0.2776}, "CVE-2018-19573": {"epss_score": 0.00088, "epss_percentile": 0.25694}, "CVE-2018-19574": {"epss_score": 0.00088, "epss_percentile": 0.25694}, "CVE-2018-19575": {"epss_score": 0.00132, "epss_percentile": 0.33519}, "CVE-2018-19576": {"epss_score": 0.0017, "epss_percentile": 0.38662}, "CVE-2018-19577": {"epss_score": 0.00249, "epss_percentile": 0.48072}, "CVE-2018-19578": {"epss_score": 0.00092, "epss_percentile": 0.26564}, "CVE-2018-19579": {"epss_score": 0.00068, "epss_percentile": 0.21372}, "CVE-2018-19580": {"epss_score": 0.00101, "epss_percentile": 0.28564}, "CVE-2018-19581": {"epss_score": 0.00095, "epss_percentile": 0.27091}, "CVE-2018-19582": {"epss_score": 0.00101, "epss_percentile": 0.28711}, "CVE-2018-19583": {"epss_score": 0.00163, "epss_percentile": 0.37807}, "CVE-2018-19584": {"epss_score": 0.00199, "epss_percentile": 0.42112}, "CVE-2018-19585": {"epss_score": 0.13618, "epss_percentile": 0.94015}, "CVE-2018-19586": {"epss_score": 0.04086, "epss_percentile": 0.88227}, "CVE-2018-19587": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-19588": {"epss_score": 0.00766, "epss_percentile": 0.72934}, "CVE-2018-19589": {"epss_score": 0.00156, "epss_percentile": 0.36916}, "CVE-2018-19591": {"epss_score": 0.01455, "epss_percentile": 0.80388}, "CVE-2018-19592": {"epss_score": 0.00711, "epss_percentile": 0.71746}, "CVE-2018-19595": {"epss_score": 0.04855, "epss_percentile": 0.89218}, "CVE-2018-19596": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19597": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19598": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19599": {"epss_score": 0.00353, "epss_percentile": 0.5716}, "CVE-2018-19600": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-19601": {"epss_score": 0.00378, "epss_percentile": 0.58811}, "CVE-2018-19607": {"epss_score": 0.00638, "epss_percentile": 0.6991}, "CVE-2018-19608": {"epss_score": 0.0024, "epss_percentile": 0.46963}, "CVE-2018-19609": {"epss_score": 0.00225, "epss_percentile": 0.45148}, "CVE-2018-19612": {"epss_score": 0.0075, "epss_percentile": 0.72614}, "CVE-2018-19613": {"epss_score": 0.00165, "epss_percentile": 0.38039}, "CVE-2018-19614": {"epss_score": 0.00311, "epss_percentile": 0.53925}, "CVE-2018-19615": {"epss_score": 0.00275, "epss_percentile": 0.50632}, "CVE-2018-19616": {"epss_score": 0.04056, "epss_percentile": 0.88185}, "CVE-2018-19620": {"epss_score": 0.00132, "epss_percentile": 0.33547}, "CVE-2018-19621": {"epss_score": 0.00117, "epss_percentile": 0.31307}, "CVE-2018-19622": {"epss_score": 0.01345, "epss_percentile": 0.7962}, "CVE-2018-19623": {"epss_score": 0.02063, "epss_percentile": 0.83449}, "CVE-2018-19624": {"epss_score": 0.00274, "epss_percentile": 0.50531}, "CVE-2018-19625": {"epss_score": 0.00274, "epss_percentile": 0.50531}, "CVE-2018-19626": {"epss_score": 0.00274, "epss_percentile": 0.50531}, "CVE-2018-19627": {"epss_score": 0.18644, "epss_percentile": 0.95047}, "CVE-2018-19628": {"epss_score": 0.00918, "epss_percentile": 0.75445}, "CVE-2018-19629": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-19630": {"epss_score": 0.00326, "epss_percentile": 0.55066}, "CVE-2018-19634": {"epss_score": 0.00262, "epss_percentile": 0.4938}, "CVE-2018-19635": {"epss_score": 0.00492, "epss_percentile": 0.64985}, "CVE-2018-19636": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2018-19637": {"epss_score": 0.0004, "epss_percentile": 0.11911}, "CVE-2018-19638": {"epss_score": 0.00042, "epss_percentile": 0.12919}, "CVE-2018-19639": {"epss_score": 0.00185, "epss_percentile": 0.40527}, "CVE-2018-19640": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2018-19641": {"epss_score": 0.00632, "epss_percentile": 0.6975}, "CVE-2018-19642": {"epss_score": 0.00165, "epss_percentile": 0.38036}, "CVE-2018-19643": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2018-19644": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2018-19645": {"epss_score": 0.00425, "epss_percentile": 0.61697}, "CVE-2018-19646": {"epss_score": 0.02614, "epss_percentile": 0.85241}, "CVE-2018-19648": {"epss_score": 0.00297, "epss_percentile": 0.52767}, "CVE-2018-19649": {"epss_score": 0.00177, "epss_percentile": 0.39533}, "CVE-2018-19650": {"epss_score": 0.00074, "epss_percentile": 0.22829}, "CVE-2018-19651": {"epss_score": 0.00207, "epss_percentile": 0.43112}, "CVE-2018-19653": {"epss_score": 0.00427, "epss_percentile": 0.61914}, "CVE-2018-19654": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-19655": {"epss_score": 0.00713, "epss_percentile": 0.71785}, "CVE-2018-19658": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2018-19659": {"epss_score": 0.00493, "epss_percentile": 0.65063}, "CVE-2018-19660": {"epss_score": 0.02219, "epss_percentile": 0.84046}, "CVE-2018-19661": {"epss_score": 0.00944, "epss_percentile": 0.75793}, "CVE-2018-19662": {"epss_score": 0.00699, "epss_percentile": 0.71454}, "CVE-2018-19664": {"epss_score": 0.00219, "epss_percentile": 0.44527}, "CVE-2018-19665": {"epss_score": 0.00206, "epss_percentile": 0.42939}, "CVE-2018-19666": {"epss_score": 0.00024, "epss_percentile": 0.05803}, "CVE-2018-19692": {"epss_score": 0.00842, "epss_percentile": 0.74233}, "CVE-2018-19693": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19694": {"epss_score": 0.0053, "epss_percentile": 0.66629}, "CVE-2018-19698": {"epss_score": 0.02029, "epss_percentile": 0.83326}, "CVE-2018-19699": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2018-19700": {"epss_score": 0.02029, "epss_percentile": 0.83326}, "CVE-2018-19701": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2018-19702": {"epss_score": 0.03704, "epss_percentile": 0.87595}, "CVE-2018-19703": {"epss_score": 0.01584, "epss_percentile": 0.81163}, "CVE-2018-19704": {"epss_score": 0.01517, "epss_percentile": 0.80809}, "CVE-2018-19705": {"epss_score": 0.01584, "epss_percentile": 0.81163}, "CVE-2018-19706": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2018-19707": {"epss_score": 0.02017, "epss_percentile": 0.83281}, "CVE-2018-19708": {"epss_score": 0.02017, "epss_percentile": 0.83281}, "CVE-2018-19709": {"epss_score": 0.01517, "epss_percentile": 0.80809}, "CVE-2018-19710": {"epss_score": 0.01517, "epss_percentile": 0.80809}, "CVE-2018-19711": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2018-19712": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2018-19713": {"epss_score": 0.02375, "epss_percentile": 0.84542}, "CVE-2018-19714": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2018-19715": {"epss_score": 0.02017, "epss_percentile": 0.83281}, "CVE-2018-19716": {"epss_score": 0.07376, "epss_percentile": 0.91441}, "CVE-2018-19717": {"epss_score": 0.01517, "epss_percentile": 0.80809}, "CVE-2018-19718": {"epss_score": 0.01752, "epss_percentile": 0.82109}, "CVE-2018-19719": {"epss_score": 0.02242, "epss_percentile": 0.84118}, "CVE-2018-19720": {"epss_score": 0.1595, "epss_percentile": 0.94542}, "CVE-2018-19721": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2018-19722": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2018-19723": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2018-19724": {"epss_score": 0.01145, "epss_percentile": 0.77991}, "CVE-2018-19725": {"epss_score": 0.00531, "epss_percentile": 0.66652}, "CVE-2018-19726": {"epss_score": 0.01145, "epss_percentile": 0.77991}, "CVE-2018-19727": {"epss_score": 0.01145, "epss_percentile": 0.77991}, "CVE-2018-19728": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2018-19748": {"epss_score": 0.01032, "epss_percentile": 0.7686}, "CVE-2018-19749": {"epss_score": 0.00236, "epss_percentile": 0.46427}, "CVE-2018-19750": {"epss_score": 0.00188, "epss_percentile": 0.40879}, "CVE-2018-19751": {"epss_score": 0.00236, "epss_percentile": 0.46427}, "CVE-2018-19752": {"epss_score": 0.00236, "epss_percentile": 0.46427}, "CVE-2018-19753": {"epss_score": 0.73324, "epss_percentile": 0.98747}, "CVE-2018-19754": {"epss_score": 0.01107, "epss_percentile": 0.77628}, "CVE-2018-19755": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2018-19756": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2018-19757": {"epss_score": 0.00261, "epss_percentile": 0.49296}, "CVE-2018-19758": {"epss_score": 0.00884, "epss_percentile": 0.7493}, "CVE-2018-19759": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2018-19760": {"epss_score": 0.00332, "epss_percentile": 0.55577}, "CVE-2018-19761": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2018-19762": {"epss_score": 0.0017, "epss_percentile": 0.3873}, "CVE-2018-19763": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2018-19765": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19766": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19767": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19768": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19769": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19770": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19771": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19772": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19773": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19774": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19775": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19777": {"epss_score": 0.00266, "epss_percentile": 0.49902}, "CVE-2018-19782": {"epss_score": 0.05662, "epss_percentile": 0.90096}, "CVE-2018-19783": {"epss_score": 0.05657, "epss_percentile": 0.90093}, "CVE-2018-19784": {"epss_score": 0.0016, "epss_percentile": 0.37452}, "CVE-2018-19785": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19786": {"epss_score": 0.00306, "epss_percentile": 0.5341}, "CVE-2018-19787": {"epss_score": 0.00381, "epss_percentile": 0.59008}, "CVE-2018-19788": {"epss_score": 0.59639, "epss_percentile": 0.98173}, "CVE-2018-19789": {"epss_score": 0.00869, "epss_percentile": 0.74691}, "CVE-2018-19790": {"epss_score": 0.00447, "epss_percentile": 0.62968}, "CVE-2018-19791": {"epss_score": 0.00292, "epss_percentile": 0.5228}, "CVE-2018-19792": {"epss_score": 0.00062, "epss_percentile": 0.19595}, "CVE-2018-19793": {"epss_score": 0.02624, "epss_percentile": 0.85262}, "CVE-2018-19794": {"epss_score": 0.00322, "epss_percentile": 0.54754}, "CVE-2018-19795": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2018-19796": {"epss_score": 0.00249, "epss_percentile": 0.4804}, "CVE-2018-19797": {"epss_score": 0.0025, "epss_percentile": 0.4811}, "CVE-2018-19798": {"epss_score": 0.09393, "epss_percentile": 0.9253}, "CVE-2018-19799": {"epss_score": 0.02494, "epss_percentile": 0.84905}, "CVE-2018-19800": {"epss_score": 0.00778, "epss_percentile": 0.73124}, "CVE-2018-19801": {"epss_score": 0.00611, "epss_percentile": 0.69183}, "CVE-2018-19802": {"epss_score": 0.01098, "epss_percentile": 0.77545}, "CVE-2018-19809": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19810": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19811": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19812": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19813": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19814": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19815": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19816": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19817": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19818": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19819": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19820": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-19821": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-19822": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-19824": {"epss_score": 0.00056, "epss_percentile": 0.17828}, "CVE-2018-19826": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2018-19827": {"epss_score": 0.00615, "epss_percentile": 0.69291}, "CVE-2018-19828": {"epss_score": 0.00651, "epss_percentile": 0.70294}, "CVE-2018-19829": {"epss_score": 0.0032, "epss_percentile": 0.54584}, "CVE-2018-19830": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2018-19831": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2018-19832": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2018-19833": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2018-19834": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2018-19835": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19836": {"epss_score": 0.00201, "epss_percentile": 0.42279}, "CVE-2018-19837": {"epss_score": 0.00683, "epss_percentile": 0.71093}, "CVE-2018-19838": {"epss_score": 0.00575, "epss_percentile": 0.68101}, "CVE-2018-19839": {"epss_score": 0.00241, "epss_percentile": 0.47322}, "CVE-2018-19840": {"epss_score": 0.00347, "epss_percentile": 0.56745}, "CVE-2018-19841": {"epss_score": 0.00593, "epss_percentile": 0.6864}, "CVE-2018-19842": {"epss_score": 0.00313, "epss_percentile": 0.54051}, "CVE-2018-19843": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-19844": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19845": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-19849": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-19853": {"epss_score": 0.00284, "epss_percentile": 0.51432}, "CVE-2018-19854": {"epss_score": 0.00086, "epss_percentile": 0.25319}, "CVE-2018-19855": {"epss_score": 0.0026, "epss_percentile": 0.49241}, "CVE-2018-19856": {"epss_score": 0.00134, "epss_percentile": 0.33831}, "CVE-2018-19857": {"epss_score": 0.01486, "epss_percentile": 0.80609}, "CVE-2018-19858": {"epss_score": 0.00463, "epss_percentile": 0.6369}, "CVE-2018-19859": {"epss_score": 0.10611, "epss_percentile": 0.93046}, "CVE-2018-19860": {"epss_score": 0.00607, "epss_percentile": 0.69054}, "CVE-2018-19861": {"epss_score": 0.31948, "epss_percentile": 0.96661}, "CVE-2018-19862": {"epss_score": 0.31948, "epss_percentile": 0.96661}, "CVE-2018-19863": {"epss_score": 0.00059, "epss_percentile": 0.18628}, "CVE-2018-19864": {"epss_score": 0.32576, "epss_percentile": 0.96709}, "CVE-2018-19865": {"epss_score": 0.00784, "epss_percentile": 0.73238}, "CVE-2018-19869": {"epss_score": 0.00649, "epss_percentile": 0.70226}, "CVE-2018-19870": {"epss_score": 0.0217, "epss_percentile": 0.83867}, "CVE-2018-19871": {"epss_score": 0.00857, "epss_percentile": 0.7449}, "CVE-2018-19872": {"epss_score": 0.00271, "epss_percentile": 0.50288}, "CVE-2018-19873": {"epss_score": 0.08233, "epss_percentile": 0.91941}, "CVE-2018-19876": {"epss_score": 0.00223, "epss_percentile": 0.44865}, "CVE-2018-19877": {"epss_score": 0.12683, "epss_percentile": 0.93748}, "CVE-2018-19878": {"epss_score": 0.0039, "epss_percentile": 0.59519}, "CVE-2018-19879": {"epss_score": 0.00517, "epss_percentile": 0.66076}, "CVE-2018-19881": {"epss_score": 0.0043, "epss_percentile": 0.62008}, "CVE-2018-19882": {"epss_score": 0.00441, "epss_percentile": 0.62696}, "CVE-2018-19886": {"epss_score": 0.00299, "epss_percentile": 0.52881}, "CVE-2018-19887": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2018-19888": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2018-19889": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2018-19890": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2018-19891": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2018-19892": {"epss_score": 0.01183, "epss_percentile": 0.78326}, "CVE-2018-19893": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-19894": {"epss_score": 0.00277, "epss_percentile": 0.50805}, "CVE-2018-19895": {"epss_score": 0.00277, "epss_percentile": 0.50805}, "CVE-2018-19896": {"epss_score": 0.00277, "epss_percentile": 0.50805}, "CVE-2018-19897": {"epss_score": 0.00277, "epss_percentile": 0.50805}, "CVE-2018-19898": {"epss_score": 0.0034, "epss_percentile": 0.56284}, "CVE-2018-19901": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19902": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19903": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19904": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19905": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-19906": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-19907": {"epss_score": 0.00475, "epss_percentile": 0.64183}, "CVE-2018-19908": {"epss_score": 0.4382, "epss_percentile": 0.97405}, "CVE-2018-19911": {"epss_score": 0.1338, "epss_percentile": 0.93947}, "CVE-2018-19913": {"epss_score": 0.00222, "epss_percentile": 0.44723}, "CVE-2018-19914": {"epss_score": 0.00255, "epss_percentile": 0.48687}, "CVE-2018-19915": {"epss_score": 0.00392, "epss_percentile": 0.59693}, "CVE-2018-19917": {"epss_score": 0.00698, "epss_percentile": 0.71426}, "CVE-2018-19918": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2018-19919": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-19921": {"epss_score": 0.0129, "epss_percentile": 0.79221}, "CVE-2018-19922": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-19923": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-19924": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-19925": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-19926": {"epss_score": 0.00161, "epss_percentile": 0.37564}, "CVE-2018-19927": {"epss_score": 0.00155, "epss_percentile": 0.36778}, "CVE-2018-19931": {"epss_score": 0.00497, "epss_percentile": 0.6518}, "CVE-2018-19932": {"epss_score": 0.0042, "epss_percentile": 0.61448}, "CVE-2018-19933": {"epss_score": 0.02243, "epss_percentile": 0.84121}, "CVE-2018-19934": {"epss_score": 0.01802, "epss_percentile": 0.82333}, "CVE-2018-19935": {"epss_score": 0.23723, "epss_percentile": 0.95809}, "CVE-2018-19936": {"epss_score": 0.00303, "epss_percentile": 0.5323}, "CVE-2018-19937": {"epss_score": 0.00039, "epss_percentile": 0.1145}, "CVE-2018-19939": {"epss_score": 0.00281, "epss_percentile": 0.51137}, "CVE-2018-19941": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2018-19942": {"epss_score": 0.00327, "epss_percentile": 0.551}, "CVE-2018-19943": {"epss_score": 0.055, "epss_percentile": 0.89937}, "CVE-2018-19944": {"epss_score": 0.00146, "epss_percentile": 0.35528}, "CVE-2018-19945": {"epss_score": 0.00399, "epss_percentile": 0.60096}, "CVE-2018-19946": {"epss_score": 0.001, "epss_percentile": 0.28507}, "CVE-2018-19947": {"epss_score": 0.00311, "epss_percentile": 0.53825}, "CVE-2018-19948": {"epss_score": 0.00124, "epss_percentile": 0.32415}, "CVE-2018-19949": {"epss_score": 0.44166, "epss_percentile": 0.97422}, "CVE-2018-19950": {"epss_score": 0.03358, "epss_percentile": 0.8698}, "CVE-2018-19951": {"epss_score": 0.0027, "epss_percentile": 0.50233}, "CVE-2018-19952": {"epss_score": 0.00304, "epss_percentile": 0.53261}, "CVE-2018-19953": {"epss_score": 0.31524, "epss_percentile": 0.96625}, "CVE-2018-19954": {"epss_score": 0.00415, "epss_percentile": 0.6115}, "CVE-2018-19955": {"epss_score": 0.00415, "epss_percentile": 0.6115}, "CVE-2018-19956": {"epss_score": 0.00415, "epss_percentile": 0.6115}, "CVE-2018-19957": {"epss_score": 0.00317, "epss_percentile": 0.54351}, "CVE-2018-19960": {"epss_score": 0.00024, "epss_percentile": 0.05987}, "CVE-2018-19961": {"epss_score": 0.00181, "epss_percentile": 0.40057}, "CVE-2018-19962": {"epss_score": 0.00181, "epss_percentile": 0.40057}, "CVE-2018-19963": {"epss_score": 0.00051, "epss_percentile": 0.16178}, "CVE-2018-19964": {"epss_score": 0.00124, "epss_percentile": 0.32416}, "CVE-2018-19965": {"epss_score": 0.0018, "epss_percentile": 0.39874}, "CVE-2018-19966": {"epss_score": 0.00123, "epss_percentile": 0.32337}, "CVE-2018-19967": {"epss_score": 0.00072, "epss_percentile": 0.22348}, "CVE-2018-19968": {"epss_score": 0.02543, "epss_percentile": 0.85058}, "CVE-2018-19969": {"epss_score": 0.00458, "epss_percentile": 0.63416}, "CVE-2018-19970": {"epss_score": 0.01501, "epss_percentile": 0.80714}, "CVE-2018-19971": {"epss_score": 0.00895, "epss_percentile": 0.75093}, "CVE-2018-19974": {"epss_score": 0.00253, "epss_percentile": 0.48486}, "CVE-2018-19975": {"epss_score": 0.00227, "epss_percentile": 0.45456}, "CVE-2018-19976": {"epss_score": 0.00253, "epss_percentile": 0.48486}, "CVE-2018-19977": {"epss_score": 0.03034, "epss_percentile": 0.86255}, "CVE-2018-19978": {"epss_score": 0.00552, "epss_percentile": 0.67398}, "CVE-2018-19980": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2018-19981": {"epss_score": 0.00666, "epss_percentile": 0.70698}, "CVE-2018-19982": {"epss_score": 0.00049, "epss_percentile": 0.15467}, "CVE-2018-19983": {"epss_score": 0.00084, "epss_percentile": 0.24975}, "CVE-2018-19985": {"epss_score": 0.00042, "epss_percentile": 0.12904}, "CVE-2018-19986": {"epss_score": 0.54881, "epss_percentile": 0.97949}, "CVE-2018-19987": {"epss_score": 0.81826, "epss_percentile": 0.99159}, "CVE-2018-19988": {"epss_score": 0.25527, "epss_percentile": 0.96037}, "CVE-2018-19989": {"epss_score": 0.32754, "epss_percentile": 0.96722}, "CVE-2018-19990": {"epss_score": 0.10752, "epss_percentile": 0.93094}, "CVE-2018-19991": {"epss_score": 0.00481, "epss_percentile": 0.64509}, "CVE-2018-19992": {"epss_score": 0.00124, "epss_percentile": 0.32347}, "CVE-2018-19993": {"epss_score": 0.00171, "epss_percentile": 0.38821}, "CVE-2018-19994": {"epss_score": 0.00251, "epss_percentile": 0.48306}, "CVE-2018-19995": {"epss_score": 0.00132, "epss_percentile": 0.33553}, "CVE-2018-19998": {"epss_score": 0.00258, "epss_percentile": 0.48976}, "CVE-2018-19999": {"epss_score": 0.00056, "epss_percentile": 0.17732}, "CVE-2018-1000": {"epss_score": 0.31631, "epss_percentile": 0.9664}, "CVE-2018-1001": {"epss_score": 0.29935, "epss_percentile": 0.96487}, "CVE-2018-1003": {"epss_score": 0.29165, "epss_percentile": 0.96422}, "CVE-2018-1004": {"epss_score": 0.3447, "epss_percentile": 0.96848}, "CVE-2018-1005": {"epss_score": 0.01102, "epss_percentile": 0.77588}, "CVE-2018-1007": {"epss_score": 0.25571, "epss_percentile": 0.96046}, "CVE-2018-1008": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2018-1009": {"epss_score": 0.00353, "epss_percentile": 0.57141}, "CVE-2018-1010": {"epss_score": 0.37036, "epss_percentile": 0.97016}, "CVE-2018-1011": {"epss_score": 0.3391, "epss_percentile": 0.96816}, "CVE-2018-1012": {"epss_score": 0.36001, "epss_percentile": 0.96948}, "CVE-2018-1013": {"epss_score": 0.36001, "epss_percentile": 0.96948}, "CVE-2018-1014": {"epss_score": 0.01491, "epss_percentile": 0.80632}, "CVE-2018-1015": {"epss_score": 0.36001, "epss_percentile": 0.96948}, "CVE-2018-1016": {"epss_score": 0.36001, "epss_percentile": 0.96948}, "CVE-2018-1018": {"epss_score": 0.24025, "epss_percentile": 0.95847}, "CVE-2018-1019": {"epss_score": 0.22672, "epss_percentile": 0.95669}, "CVE-2018-1020": {"epss_score": 0.22389, "epss_percentile": 0.9563}, "CVE-2018-1021": {"epss_score": 0.12825, "epss_percentile": 0.93792}, "CVE-2018-1022": {"epss_score": 0.15814, "epss_percentile": 0.94514}, "CVE-2018-1023": {"epss_score": 0.25435, "epss_percentile": 0.96027}, "CVE-2018-1025": {"epss_score": 0.08718, "epss_percentile": 0.92225}, "CVE-2018-1026": {"epss_score": 0.4743, "epss_percentile": 0.97587}, "CVE-2018-1027": {"epss_score": 0.37412, "epss_percentile": 0.97045}, "CVE-2018-1028": {"epss_score": 0.33418, "epss_percentile": 0.96772}, "CVE-2018-1029": {"epss_score": 0.37412, "epss_percentile": 0.97045}, "CVE-2018-1030": {"epss_score": 0.36403, "epss_percentile": 0.96977}, "CVE-2018-1032": {"epss_score": 0.01102, "epss_percentile": 0.77588}, "CVE-2018-1034": {"epss_score": 0.01102, "epss_percentile": 0.77588}, "CVE-2018-1035": {"epss_score": 0.017, "epss_percentile": 0.81826}, "CVE-2018-1036": {"epss_score": 0.00904, "epss_percentile": 0.75221}, "CVE-2018-1037": {"epss_score": 0.09465, "epss_percentile": 0.9256}, "CVE-2018-1038": {"epss_score": 0.61277, "epss_percentile": 0.98242}, "CVE-2018-1039": {"epss_score": 0.0054, "epss_percentile": 0.67009}, "CVE-2018-1040": {"epss_score": 0.23214, "epss_percentile": 0.95751}, "CVE-2018-1041": {"epss_score": 0.14129, "epss_percentile": 0.94142}, "CVE-2018-1042": {"epss_score": 0.18988, "epss_percentile": 0.95107}, "CVE-2018-1043": {"epss_score": 0.00211, "epss_percentile": 0.4364}, "CVE-2018-1044": {"epss_score": 0.00347, "epss_percentile": 0.56744}, "CVE-2018-1045": {"epss_score": 0.00297, "epss_percentile": 0.52741}, "CVE-2018-1046": {"epss_score": 7e-05, "epss_percentile": 0.00444}, "CVE-2018-1047": {"epss_score": 0.00307, "epss_percentile": 0.53468}, "CVE-2018-1048": {"epss_score": 0.0039, "epss_percentile": 0.59545}, "CVE-2018-1049": {"epss_score": 0.00667, "epss_percentile": 0.70715}, "CVE-2018-1050": {"epss_score": 0.27175, "epss_percentile": 0.96217}, "CVE-2018-1051": {"epss_score": 0.00688, "epss_percentile": 0.71211}, "CVE-2018-1052": {"epss_score": 0.00472, "epss_percentile": 0.64063}, "CVE-2018-1053": {"epss_score": 0.00095, "epss_percentile": 0.27083}, "CVE-2018-1054": {"epss_score": 0.09626, "epss_percentile": 0.92629}, "CVE-2018-1056": {"epss_score": 0.00417, "epss_percentile": 0.61246}, "CVE-2018-1057": {"epss_score": 0.05067, "epss_percentile": 0.89458}, "CVE-2018-1058": {"epss_score": 0.82687, "epss_percentile": 0.99207}, "CVE-2018-1059": {"epss_score": 0.0013, "epss_percentile": 0.33292}, "CVE-2018-1060": {"epss_score": 0.00961, "epss_percentile": 0.75978}, "CVE-2018-1061": {"epss_score": 0.01476, "epss_percentile": 0.80535}, "CVE-2018-1062": {"epss_score": 0.00434, "epss_percentile": 0.62298}, "CVE-2018-1063": {"epss_score": 0.00117, "epss_percentile": 0.31374}, "CVE-2018-1064": {"epss_score": 0.01291, "epss_percentile": 0.79223}, "CVE-2018-1065": {"epss_score": 0.00042, "epss_percentile": 0.12897}, "CVE-2018-1066": {"epss_score": 0.05036, "epss_percentile": 0.89419}, "CVE-2018-1067": {"epss_score": 0.00626, "epss_percentile": 0.69605}, "CVE-2018-1068": {"epss_score": 0.0004, "epss_percentile": 0.11989}, "CVE-2018-1069": {"epss_score": 0.00087, "epss_percentile": 0.25603}, "CVE-2018-1070": {"epss_score": 0.00158, "epss_percentile": 0.37218}, "CVE-2018-1071": {"epss_score": 0.00039, "epss_percentile": 0.11591}, "CVE-2018-1072": {"epss_score": 0.00146, "epss_percentile": 0.35643}, "CVE-2018-1073": {"epss_score": 0.00269, "epss_percentile": 0.50107}, "CVE-2018-1074": {"epss_score": 0.00249, "epss_percentile": 0.48061}, "CVE-2018-1075": {"epss_score": 0.00043, "epss_percentile": 0.12996}, "CVE-2018-1077": {"epss_score": 0.00222, "epss_percentile": 0.44791}, "CVE-2018-1078": {"epss_score": 0.00369, "epss_percentile": 0.5826}, "CVE-2018-1079": {"epss_score": 0.00408, "epss_percentile": 0.60642}, "CVE-2018-1080": {"epss_score": 0.00458, "epss_percentile": 0.6343}, "CVE-2018-1081": {"epss_score": 0.00927, "epss_percentile": 0.75558}, "CVE-2018-1082": {"epss_score": 0.02064, "epss_percentile": 0.83451}, "CVE-2018-1083": {"epss_score": 0.00083, "epss_percentile": 0.24715}, "CVE-2018-1084": {"epss_score": 0.00257, "epss_percentile": 0.48894}, "CVE-2018-1085": {"epss_score": 0.01403, "epss_percentile": 0.8003}, "CVE-2018-1086": {"epss_score": 0.002, "epss_percentile": 0.42256}, "CVE-2018-1087": {"epss_score": 0.00038, "epss_percentile": 0.11219}, "CVE-2018-1088": {"epss_score": 0.08237, "epss_percentile": 0.91944}, "CVE-2018-1089": {"epss_score": 0.14569, "epss_percentile": 0.94243}, "CVE-2018-1090": {"epss_score": 0.00274, "epss_percentile": 0.50554}, "CVE-2018-1091": {"epss_score": 0.00082, "epss_percentile": 0.24503}, "CVE-2018-1092": {"epss_score": 0.00238, "epss_percentile": 0.46762}, "CVE-2018-1093": {"epss_score": 0.00092, "epss_percentile": 0.26533}, "CVE-2018-1094": {"epss_score": 0.00285, "epss_percentile": 0.5155}, "CVE-2018-1095": {"epss_score": 0.00153, "epss_percentile": 0.3651}, "CVE-2018-1096": {"epss_score": 0.00315, "epss_percentile": 0.54182}, "CVE-2018-1097": {"epss_score": 0.00435, "epss_percentile": 0.62377}, "CVE-2018-1098": {"epss_score": 0.00209, "epss_percentile": 0.43385}, "CVE-2018-1099": {"epss_score": 0.00062, "epss_percentile": 0.19742}, "CVE-2018-1100": {"epss_score": 0.00063, "epss_percentile": 0.19959}, "CVE-2018-1101": {"epss_score": 0.00432, "epss_percentile": 0.62102}, "CVE-2018-1102": {"epss_score": 0.01263, "epss_percentile": 0.7899}, "CVE-2018-1103": {"epss_score": 0.00268, "epss_percentile": 0.50077}, "CVE-2018-1104": {"epss_score": 0.00417, "epss_percentile": 0.61223}, "CVE-2018-1106": {"epss_score": 0.00025, "epss_percentile": 0.06281}, "CVE-2018-1107": {"epss_score": 0.00255, "epss_percentile": 0.48675}, "CVE-2018-1108": {"epss_score": 0.00459, "epss_percentile": 0.63453}, "CVE-2018-1109": {"epss_score": 0.00357, "epss_percentile": 0.57455}, "CVE-2018-1110": {"epss_score": 0.00502, "epss_percentile": 0.65403}, "CVE-2018-1111": {"epss_score": 0.89183, "epss_percentile": 0.99513}, "CVE-2018-1112": {"epss_score": 0.01953, "epss_percentile": 0.83028}, "CVE-2018-1113": {"epss_score": 0.00044, "epss_percentile": 0.13633}, "CVE-2018-1114": {"epss_score": 0.00707, "epss_percentile": 0.71652}, "CVE-2018-1115": {"epss_score": 0.00483, "epss_percentile": 0.64594}, "CVE-2018-1116": {"epss_score": 0.00065, "epss_percentile": 0.20459}, "CVE-2018-1117": {"epss_score": 0.00203, "epss_percentile": 0.42567}, "CVE-2018-1118": {"epss_score": 0.00108, "epss_percentile": 0.29819}, "CVE-2018-1120": {"epss_score": 0.00986, "epss_percentile": 0.76338}, "CVE-2018-1121": {"epss_score": 0.01883, "epss_percentile": 0.82698}, "CVE-2018-1122": {"epss_score": 0.00317, "epss_percentile": 0.54338}, "CVE-2018-1123": {"epss_score": 0.03619, "epss_percentile": 0.8744}, "CVE-2018-1124": {"epss_score": 0.00432, "epss_percentile": 0.62118}, "CVE-2018-1125": {"epss_score": 0.00364, "epss_percentile": 0.57946}, "CVE-2018-1126": {"epss_score": 0.0049, "epss_percentile": 0.64919}, "CVE-2018-1127": {"epss_score": 0.00456, "epss_percentile": 0.63329}, "CVE-2018-1128": {"epss_score": 0.01031, "epss_percentile": 0.76854}, "CVE-2018-1129": {"epss_score": 0.00404, "epss_percentile": 0.60398}, "CVE-2018-1130": {"epss_score": 0.00041, "epss_percentile": 0.12231}, "CVE-2018-1131": {"epss_score": 0.0053, "epss_percentile": 0.66636}, "CVE-2018-1132": {"epss_score": 0.01894, "epss_percentile": 0.82744}, "CVE-2018-1133": {"epss_score": 0.67087, "epss_percentile": 0.98494}, "CVE-2018-1134": {"epss_score": 0.00184, "epss_percentile": 0.40374}, "CVE-2018-1135": {"epss_score": 0.00279, "epss_percentile": 0.50993}, "CVE-2018-1136": {"epss_score": 0.00265, "epss_percentile": 0.49783}, "CVE-2018-1137": {"epss_score": 0.00401, "epss_percentile": 0.6025}, "CVE-2018-1139": {"epss_score": 0.01526, "epss_percentile": 0.80862}, "CVE-2018-1140": {"epss_score": 0.17346, "epss_percentile": 0.94831}, "CVE-2018-1141": {"epss_score": 0.00037, "epss_percentile": 0.10642}, "CVE-2018-1142": {"epss_score": 0.00288, "epss_percentile": 0.51921}, "CVE-2018-1143": {"epss_score": 0.33598, "epss_percentile": 0.96787}, "CVE-2018-1144": {"epss_score": 0.29113, "epss_percentile": 0.96419}, "CVE-2018-1145": {"epss_score": 0.35002, "epss_percentile": 0.96882}, "CVE-2018-1146": {"epss_score": 0.0364, "epss_percentile": 0.8749}, "CVE-2018-1147": {"epss_score": 0.00363, "epss_percentile": 0.57824}, "CVE-2018-1148": {"epss_score": 0.00159, "epss_percentile": 0.37382}, "CVE-2018-1149": {"epss_score": 0.16744, "epss_percentile": 0.94726}, "CVE-2018-1150": {"epss_score": 0.00635, "epss_percentile": 0.69814}, "CVE-2018-1151": {"epss_score": 0.25325, "epss_percentile": 0.96013}, "CVE-2018-1152": {"epss_score": 0.0097, "epss_percentile": 0.76107}, "CVE-2018-1153": {"epss_score": 0.0011, "epss_percentile": 0.30129}, "CVE-2018-1154": {"epss_score": 0.00416, "epss_percentile": 0.61196}, "CVE-2018-1155": {"epss_score": 0.0029, "epss_percentile": 0.52116}, "CVE-2018-1156": {"epss_score": 0.02831, "epss_percentile": 0.85776}, "CVE-2018-1157": {"epss_score": 0.0228, "epss_percentile": 0.84243}, "CVE-2018-1158": {"epss_score": 0.01223, "epss_percentile": 0.78662}, "CVE-2018-1159": {"epss_score": 0.01067, "epss_percentile": 0.77223}, "CVE-2018-1160": {"epss_score": 0.88786, "epss_percentile": 0.9949}, "CVE-2018-1161": {"epss_score": 0.40555, "epss_percentile": 0.97223}, "CVE-2018-1162": {"epss_score": 0.20482, "epss_percentile": 0.95353}, "CVE-2018-1163": {"epss_score": 0.43582, "epss_percentile": 0.97392}, "CVE-2018-1164": {"epss_score": 0.14805, "epss_percentile": 0.94289}, "CVE-2018-1165": {"epss_score": 0.00299, "epss_percentile": 0.52866}, "CVE-2018-1166": {"epss_score": 0.0006, "epss_percentile": 0.19102}, "CVE-2018-1167": {"epss_score": 0.02091, "epss_percentile": 0.83569}, "CVE-2018-1168": {"epss_score": 0.00101, "epss_percentile": 0.28714}, "CVE-2018-1169": {"epss_score": 0.02308, "epss_percentile": 0.8433}, "CVE-2018-1170": {"epss_score": 0.00264, "epss_percentile": 0.49738}, "CVE-2018-1171": {"epss_score": 0.00201, "epss_percentile": 0.42324}, "CVE-2018-1172": {"epss_score": 0.11212, "epss_percentile": 0.93266}, "CVE-2018-1173": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-1174": {"epss_score": 0.0019, "epss_percentile": 0.41125}, "CVE-2018-1175": {"epss_score": 0.0019, "epss_percentile": 0.41125}, "CVE-2018-1176": {"epss_score": 0.00664, "epss_percentile": 0.70633}, "CVE-2018-1177": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-1178": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-1179": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-1180": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-1182": {"epss_score": 0.00057, "epss_percentile": 0.18097}, "CVE-2018-1183": {"epss_score": 0.00397, "epss_percentile": 0.5995}, "CVE-2018-1184": {"epss_score": 0.00248, "epss_percentile": 0.47925}, "CVE-2018-1185": {"epss_score": 0.01306, "epss_percentile": 0.79331}, "CVE-2018-1186": {"epss_score": 0.02156, "epss_percentile": 0.83809}, "CVE-2018-1187": {"epss_score": 0.02178, "epss_percentile": 0.8389}, "CVE-2018-1188": {"epss_score": 0.02156, "epss_percentile": 0.83809}, "CVE-2018-1189": {"epss_score": 0.05616, "epss_percentile": 0.90054}, "CVE-2018-1190": {"epss_score": 0.00217, "epss_percentile": 0.44303}, "CVE-2018-1191": {"epss_score": 0.00346, "epss_percentile": 0.56628}, "CVE-2018-1192": {"epss_score": 0.00473, "epss_percentile": 0.64088}, "CVE-2018-1193": {"epss_score": 0.00169, "epss_percentile": 0.38619}, "CVE-2018-1195": {"epss_score": 0.00272, "epss_percentile": 0.50404}, "CVE-2018-1196": {"epss_score": 0.00604, "epss_percentile": 0.68956}, "CVE-2018-1197": {"epss_score": 0.00302, "epss_percentile": 0.53166}, "CVE-2018-1198": {"epss_score": 0.00416, "epss_percentile": 0.61219}, "CVE-2018-1199": {"epss_score": 0.01511, "epss_percentile": 0.80777}, "CVE-2018-1200": {"epss_score": 0.00379, "epss_percentile": 0.58878}, "CVE-2018-1201": {"epss_score": 0.02156, "epss_percentile": 0.83809}, "CVE-2018-1202": {"epss_score": 0.02156, "epss_percentile": 0.83809}, "CVE-2018-1203": {"epss_score": 0.01083, "epss_percentile": 0.77389}, "CVE-2018-1204": {"epss_score": 0.00949, "epss_percentile": 0.75851}, "CVE-2018-1205": {"epss_score": 0.02136, "epss_percentile": 0.83728}, "CVE-2018-1206": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2018-1207": {"epss_score": 0.9379, "epss_percentile": 0.99846}, "CVE-2018-1211": {"epss_score": 0.01064, "epss_percentile": 0.77203}, "CVE-2018-1212": {"epss_score": 0.00933, "epss_percentile": 0.75641}, "CVE-2018-1213": {"epss_score": 0.00355, "epss_percentile": 0.57277}, "CVE-2018-1214": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2018-1215": {"epss_score": 0.10247, "epss_percentile": 0.92911}, "CVE-2018-1216": {"epss_score": 0.06202, "epss_percentile": 0.90561}, "CVE-2018-1217": {"epss_score": 0.65914, "epss_percentile": 0.98443}, "CVE-2018-1218": {"epss_score": 0.22381, "epss_percentile": 0.95628}, "CVE-2018-1219": {"epss_score": 0.00202, "epss_percentile": 0.42438}, "CVE-2018-1220": {"epss_score": 0.00331, "epss_percentile": 0.55515}, "CVE-2018-1221": {"epss_score": 0.00357, "epss_percentile": 0.57408}, "CVE-2018-1223": {"epss_score": 0.00416, "epss_percentile": 0.61219}, "CVE-2018-1227": {"epss_score": 0.00326, "epss_percentile": 0.55082}, "CVE-2018-1229": {"epss_score": 0.00304, "epss_percentile": 0.53248}, "CVE-2018-1230": {"epss_score": 0.00149, "epss_percentile": 0.35957}, "CVE-2018-1231": {"epss_score": 0.00291, "epss_percentile": 0.52202}, "CVE-2018-1232": {"epss_score": 0.02206, "epss_percentile": 0.84002}, "CVE-2018-1233": {"epss_score": 0.00318, "epss_percentile": 0.54432}, "CVE-2018-1234": {"epss_score": 0.00106, "epss_percentile": 0.29554}, "CVE-2018-1235": {"epss_score": 0.5175, "epss_percentile": 0.97796}, "CVE-2018-1237": {"epss_score": 0.0032, "epss_percentile": 0.54639}, "CVE-2018-1238": {"epss_score": 0.02446, "epss_percentile": 0.84769}, "CVE-2018-1239": {"epss_score": 0.02505, "epss_percentile": 0.84935}, "CVE-2018-1240": {"epss_score": 0.00145, "epss_percentile": 0.35406}, "CVE-2018-1241": {"epss_score": 0.00765, "epss_percentile": 0.72921}, "CVE-2018-1242": {"epss_score": 0.04972, "epss_percentile": 0.89352}, "CVE-2018-1243": {"epss_score": 0.00619, "epss_percentile": 0.69394}, "CVE-2018-1244": {"epss_score": 0.01407, "epss_percentile": 0.80055}, "CVE-2018-1245": {"epss_score": 0.00481, "epss_percentile": 0.64504}, "CVE-2018-1246": {"epss_score": 0.0025, "epss_percentile": 0.48209}, "CVE-2018-1247": {"epss_score": 0.35298, "epss_percentile": 0.96899}, "CVE-2018-1248": {"epss_score": 0.00406, "epss_percentile": 0.60553}, "CVE-2018-1249": {"epss_score": 0.0054, "epss_percentile": 0.66994}, "CVE-2018-1250": {"epss_score": 0.00103, "epss_percentile": 0.29005}, "CVE-2018-1251": {"epss_score": 0.003, "epss_percentile": 0.52986}, "CVE-2018-1252": {"epss_score": 0.00641, "epss_percentile": 0.70012}, "CVE-2018-1253": {"epss_score": 0.00354, "epss_percentile": 0.57203}, "CVE-2018-1254": {"epss_score": 0.00746, "epss_percentile": 0.72538}, "CVE-2018-1255": {"epss_score": 0.00366, "epss_percentile": 0.58078}, "CVE-2018-1256": {"epss_score": 0.00308, "epss_percentile": 0.53578}, "CVE-2018-1257": {"epss_score": 0.01334, "epss_percentile": 0.79533}, "CVE-2018-1258": {"epss_score": 0.00348, "epss_percentile": 0.56829}, "CVE-2018-1259": {"epss_score": 0.09831, "epss_percentile": 0.92723}, "CVE-2018-1260": {"epss_score": 0.61665, "epss_percentile": 0.98258}, "CVE-2018-1261": {"epss_score": 0.00351, "epss_percentile": 0.57015}, "CVE-2018-1262": {"epss_score": 0.00392, "epss_percentile": 0.59654}, "CVE-2018-1263": {"epss_score": 0.00732, "epss_percentile": 0.72195}, "CVE-2018-1264": {"epss_score": 0.00642, "epss_percentile": 0.70026}, "CVE-2018-1265": {"epss_score": 0.00647, "epss_percentile": 0.70186}, "CVE-2018-1266": {"epss_score": 0.00387, "epss_percentile": 0.59311}, "CVE-2018-1267": {"epss_score": 0.00332, "epss_percentile": 0.55613}, "CVE-2018-1268": {"epss_score": 0.00273, "epss_percentile": 0.50467}, "CVE-2018-1269": {"epss_score": 0.0067, "epss_percentile": 0.70769}, "CVE-2018-1270": {"epss_score": 0.89954, "epss_percentile": 0.99552}, "CVE-2018-1271": {"epss_score": 0.91006, "epss_percentile": 0.99614}, "CVE-2018-1272": {"epss_score": 0.01243, "epss_percentile": 0.7883}, "CVE-2018-1273": {"epss_score": 0.94288, "epss_percentile": 0.99935}, "CVE-2018-1274": {"epss_score": 0.00967, "epss_percentile": 0.76067}, "CVE-2018-1275": {"epss_score": 0.38064, "epss_percentile": 0.97083}, "CVE-2018-1276": {"epss_score": 0.00224, "epss_percentile": 0.45067}, "CVE-2018-1277": {"epss_score": 0.00515, "epss_percentile": 0.66005}, "CVE-2018-1278": {"epss_score": 0.00313, "epss_percentile": 0.54066}, "CVE-2018-1279": {"epss_score": 0.00324, "epss_percentile": 0.54968}, "CVE-2018-1280": {"epss_score": 0.00257, "epss_percentile": 0.48885}, "CVE-2018-1281": {"epss_score": 0.00448, "epss_percentile": 0.6302}, "CVE-2018-1282": {"epss_score": 0.00508, "epss_percentile": 0.65711}, "CVE-2018-1283": {"epss_score": 0.02927, "epss_percentile": 0.86009}, "CVE-2018-1284": {"epss_score": 0.00469, "epss_percentile": 0.63936}, "CVE-2018-1285": {"epss_score": 0.49024, "epss_percentile": 0.97663}, "CVE-2018-1286": {"epss_score": 0.00176, "epss_percentile": 0.39477}, "CVE-2018-1287": {"epss_score": 0.01389, "epss_percentile": 0.7993}, "CVE-2018-1288": {"epss_score": 0.00688, "epss_percentile": 0.71194}, "CVE-2018-1289": {"epss_score": 0.00533, "epss_percentile": 0.66771}, "CVE-2018-1290": {"epss_score": 0.00585, "epss_percentile": 0.68411}, "CVE-2018-1291": {"epss_score": 0.00251, "epss_percentile": 0.48308}, "CVE-2018-1292": {"epss_score": 0.00569, "epss_percentile": 0.67931}, "CVE-2018-1294": {"epss_score": 0.00996, "epss_percentile": 0.76452}, "CVE-2018-1295": {"epss_score": 0.05578, "epss_percentile": 0.90015}, "CVE-2018-1296": {"epss_score": 0.00574, "epss_percentile": 0.68076}, "CVE-2018-1297": {"epss_score": 0.23187, "epss_percentile": 0.95747}, "CVE-2018-1298": {"epss_score": 0.01205, "epss_percentile": 0.78514}, "CVE-2018-1299": {"epss_score": 0.00651, "epss_percentile": 0.70279}, "CVE-2018-1301": {"epss_score": 0.06301, "epss_percentile": 0.90656}, "CVE-2018-1302": {"epss_score": 0.10291, "epss_percentile": 0.9293}, "CVE-2018-1303": {"epss_score": 0.36123, "epss_percentile": 0.96958}, "CVE-2018-1304": {"epss_score": 0.0179, "epss_percentile": 0.82278}, "CVE-2018-1305": {"epss_score": 0.15394, "epss_percentile": 0.94423}, "CVE-2018-1306": {"epss_score": 0.69813, "epss_percentile": 0.98605}, "CVE-2018-1307": {"epss_score": 0.01116, "epss_percentile": 0.77718}, "CVE-2018-1308": {"epss_score": 0.05778, "epss_percentile": 0.90198}, "CVE-2018-1309": {"epss_score": 0.02699, "epss_percentile": 0.85449}, "CVE-2018-1310": {"epss_score": 0.01625, "epss_percentile": 0.81419}, "CVE-2018-1311": {"epss_score": 0.04171, "epss_percentile": 0.88348}, "CVE-2018-1312": {"epss_score": 0.0605, "epss_percentile": 0.90434}, "CVE-2018-1313": {"epss_score": 0.00715, "epss_percentile": 0.7184}, "CVE-2018-1314": {"epss_score": 0.00692, "epss_percentile": 0.71285}, "CVE-2018-1315": {"epss_score": 0.01026, "epss_percentile": 0.768}, "CVE-2018-1316": {"epss_score": 0.01967, "epss_percentile": 0.83084}, "CVE-2018-1317": {"epss_score": 0.03478, "epss_percentile": 0.87212}, "CVE-2018-1318": {"epss_score": 0.14594, "epss_percentile": 0.94248}, "CVE-2018-1319": {"epss_score": 0.00752, "epss_percentile": 0.72661}, "CVE-2018-1320": {"epss_score": 0.0011, "epss_percentile": 0.30082}, "CVE-2018-1321": {"epss_score": 0.06394, "epss_percentile": 0.90721}, "CVE-2018-1322": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2018-1323": {"epss_score": 0.57341, "epss_percentile": 0.98059}, "CVE-2018-1324": {"epss_score": 0.01186, "epss_percentile": 0.78351}, "CVE-2018-1325": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-1327": {"epss_score": 0.03356, "epss_percentile": 0.86975}, "CVE-2018-1328": {"epss_score": 0.01059, "epss_percentile": 0.77159}, "CVE-2018-1330": {"epss_score": 0.00836, "epss_percentile": 0.74134}, "CVE-2018-1331": {"epss_score": 0.05366, "epss_percentile": 0.8979}, "CVE-2018-1332": {"epss_score": 0.0043, "epss_percentile": 0.62036}, "CVE-2018-1333": {"epss_score": 0.15119, "epss_percentile": 0.94367}, "CVE-2018-1334": {"epss_score": 0.00098, "epss_percentile": 0.27832}, "CVE-2018-1335": {"epss_score": 0.93516, "epss_percentile": 0.99813}, "CVE-2018-1336": {"epss_score": 0.15005, "epss_percentile": 0.9434}, "CVE-2018-1337": {"epss_score": 0.02801, "epss_percentile": 0.85697}, "CVE-2018-1338": {"epss_score": 0.02232, "epss_percentile": 0.84093}, "CVE-2018-1339": {"epss_score": 0.04517, "epss_percentile": 0.88793}, "CVE-2018-1340": {"epss_score": 0.00633, "epss_percentile": 0.6976}, "CVE-2018-1342": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2018-1343": {"epss_score": 0.00449, "epss_percentile": 0.63057}, "CVE-2018-1344": {"epss_score": 0.00225, "epss_percentile": 0.45233}, "CVE-2018-1345": {"epss_score": 0.00131, "epss_percentile": 0.33387}, "CVE-2018-1346": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-1347": {"epss_score": 0.00191, "epss_percentile": 0.41212}, "CVE-2018-1348": {"epss_score": 0.00196, "epss_percentile": 0.41795}, "CVE-2018-1349": {"epss_score": 0.00162, "epss_percentile": 0.37627}, "CVE-2018-1350": {"epss_score": 0.00162, "epss_percentile": 0.37627}, "CVE-2018-1351": {"epss_score": 0.00297, "epss_percentile": 0.52748}, "CVE-2018-1352": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2018-1353": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2018-1354": {"epss_score": 0.00204, "epss_percentile": 0.42628}, "CVE-2018-1355": {"epss_score": 0.00227, "epss_percentile": 0.45438}, "CVE-2018-1356": {"epss_score": 0.00233, "epss_percentile": 0.46065}, "CVE-2018-1360": {"epss_score": 0.00144, "epss_percentile": 0.35226}, "CVE-2018-1361": {"epss_score": 0.00405, "epss_percentile": 0.60475}, "CVE-2018-1362": {"epss_score": 0.00256, "epss_percentile": 0.48774}, "CVE-2018-1363": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2018-1364": {"epss_score": 0.00528, "epss_percentile": 0.66534}, "CVE-2018-1366": {"epss_score": 0.00165, "epss_percentile": 0.38021}, "CVE-2018-1368": {"epss_score": 0.00047, "epss_percentile": 0.14688}, "CVE-2018-1369": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2018-1370": {"epss_score": 0.00067, "epss_percentile": 0.21099}, "CVE-2018-1371": {"epss_score": 0.0041, "epss_percentile": 0.60791}, "CVE-2018-1372": {"epss_score": 0.00312, "epss_percentile": 0.53999}, "CVE-2018-1373": {"epss_score": 0.01994, "epss_percentile": 0.83189}, "CVE-2018-1374": {"epss_score": 0.00216, "epss_percentile": 0.44148}, "CVE-2018-1375": {"epss_score": 0.00149, "epss_percentile": 0.35937}, "CVE-2018-1376": {"epss_score": 0.00131, "epss_percentile": 0.33423}, "CVE-2018-1377": {"epss_score": 0.00045, "epss_percentile": 0.13797}, "CVE-2018-1380": {"epss_score": 0.00202, "epss_percentile": 0.42435}, "CVE-2018-1382": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2018-1383": {"epss_score": 0.00512, "epss_percentile": 0.65865}, "CVE-2018-1384": {"epss_score": 0.0039, "epss_percentile": 0.59558}, "CVE-2018-1386": {"epss_score": 0.00026, "epss_percentile": 0.06517}, "CVE-2018-1387": {"epss_score": 0.00191, "epss_percentile": 0.41188}, "CVE-2018-1388": {"epss_score": 0.00312, "epss_percentile": 0.53988}, "CVE-2018-1389": {"epss_score": 0.00215, "epss_percentile": 0.44045}, "CVE-2018-1390": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1391": {"epss_score": 0.00532, "epss_percentile": 0.66697}, "CVE-2018-1392": {"epss_score": 0.00156, "epss_percentile": 0.3694}, "CVE-2018-1393": {"epss_score": 0.00212, "epss_percentile": 0.43805}, "CVE-2018-1394": {"epss_score": 0.00105, "epss_percentile": 0.29265}, "CVE-2018-1395": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1396": {"epss_score": 0.0018, "epss_percentile": 0.39919}, "CVE-2018-1398": {"epss_score": 0.0021, "epss_percentile": 0.43433}, "CVE-2018-1399": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2018-1401": {"epss_score": 0.00405, "epss_percentile": 0.60475}, "CVE-2018-1403": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1404": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1405": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1407": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2018-1408": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2018-1409": {"epss_score": 0.0003, "epss_percentile": 0.08112}, "CVE-2018-1410": {"epss_score": 0.00042, "epss_percentile": 0.12788}, "CVE-2018-1411": {"epss_score": 0.0003, "epss_percentile": 0.08112}, "CVE-2018-1413": {"epss_score": 0.00673, "epss_percentile": 0.70845}, "CVE-2018-1414": {"epss_score": 0.00615, "epss_percentile": 0.69311}, "CVE-2018-1415": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2018-1416": {"epss_score": 0.00248, "epss_percentile": 0.47995}, "CVE-2018-1417": {"epss_score": 0.01417, "epss_percentile": 0.80149}, "CVE-2018-1418": {"epss_score": 0.7, "epss_percentile": 0.98612}, "CVE-2018-1419": {"epss_score": 0.00933, "epss_percentile": 0.75641}, "CVE-2018-1420": {"epss_score": 0.00141, "epss_percentile": 0.34903}, "CVE-2018-1421": {"epss_score": 0.00307, "epss_percentile": 0.53487}, "CVE-2018-1422": {"epss_score": 0.00151, "epss_percentile": 0.36362}, "CVE-2018-1423": {"epss_score": 0.00186, "epss_percentile": 0.40638}, "CVE-2018-1424": {"epss_score": 0.00491, "epss_percentile": 0.64969}, "CVE-2018-1425": {"epss_score": 0.00137, "epss_percentile": 0.3432}, "CVE-2018-1426": {"epss_score": 0.00677, "epss_percentile": 0.70948}, "CVE-2018-1427": {"epss_score": 0.00067, "epss_percentile": 0.21014}, "CVE-2018-1428": {"epss_score": 0.00031, "epss_percentile": 0.08679}, "CVE-2018-1429": {"epss_score": 0.00403, "epss_percentile": 0.60349}, "CVE-2018-1430": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2018-1431": {"epss_score": 0.0005, "epss_percentile": 0.15769}, "CVE-2018-1432": {"epss_score": 0.00086, "epss_percentile": 0.25303}, "CVE-2018-1433": {"epss_score": 0.00432, "epss_percentile": 0.62122}, "CVE-2018-1434": {"epss_score": 0.00203, "epss_percentile": 0.42544}, "CVE-2018-1435": {"epss_score": 0.00991, "epss_percentile": 0.76385}, "CVE-2018-1437": {"epss_score": 0.00234, "epss_percentile": 0.46124}, "CVE-2018-1438": {"epss_score": 0.0051, "epss_percentile": 0.65763}, "CVE-2018-1439": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1440": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1441": {"epss_score": 0.00131, "epss_percentile": 0.33423}, "CVE-2018-1442": {"epss_score": 0.00116, "epss_percentile": 0.31193}, "CVE-2018-1443": {"epss_score": 0.00061, "epss_percentile": 0.19249}, "CVE-2018-1444": {"epss_score": 0.00316, "epss_percentile": 0.54293}, "CVE-2018-1445": {"epss_score": 0.00269, "epss_percentile": 0.50148}, "CVE-2018-1447": {"epss_score": 0.00081, "epss_percentile": 0.24211}, "CVE-2018-1448": {"epss_score": 0.00047, "epss_percentile": 0.14859}, "CVE-2018-1449": {"epss_score": 0.00066, "epss_percentile": 0.20844}, "CVE-2018-1450": {"epss_score": 0.00066, "epss_percentile": 0.20844}, "CVE-2018-1451": {"epss_score": 0.00066, "epss_percentile": 0.20844}, "CVE-2018-1452": {"epss_score": 0.00066, "epss_percentile": 0.20844}, "CVE-2018-1453": {"epss_score": 0.00315, "epss_percentile": 0.5419}, "CVE-2018-1454": {"epss_score": 0.00294, "epss_percentile": 0.52357}, "CVE-2018-1455": {"epss_score": 0.0018, "epss_percentile": 0.39905}, "CVE-2018-1456": {"epss_score": 0.00164, "epss_percentile": 0.37894}, "CVE-2018-1457": {"epss_score": 0.00387, "epss_percentile": 0.59317}, "CVE-2018-1458": {"epss_score": 0.00284, "epss_percentile": 0.51465}, "CVE-2018-1459": {"epss_score": 0.00129, "epss_percentile": 0.33091}, "CVE-2018-1460": {"epss_score": 0.00082, "epss_percentile": 0.24581}, "CVE-2018-1461": {"epss_score": 0.00307, "epss_percentile": 0.53521}, "CVE-2018-1462": {"epss_score": 0.00446, "epss_percentile": 0.62903}, "CVE-2018-1463": {"epss_score": 0.00165, "epss_percentile": 0.3806}, "CVE-2018-1464": {"epss_score": 0.00251, "epss_percentile": 0.48288}, "CVE-2018-1465": {"epss_score": 0.00251, "epss_percentile": 0.48288}, "CVE-2018-1466": {"epss_score": 0.00116, "epss_percentile": 0.31154}, "CVE-2018-1467": {"epss_score": 0.00284, "epss_percentile": 0.51434}, "CVE-2018-1468": {"epss_score": 0.00156, "epss_percentile": 0.36883}, "CVE-2018-1469": {"epss_score": 0.00442, "epss_percentile": 0.62743}, "CVE-2018-1470": {"epss_score": 0.00128, "epss_percentile": 0.33072}, "CVE-2018-1473": {"epss_score": 0.00182, "epss_percentile": 0.40276}, "CVE-2018-1474": {"epss_score": 0.00187, "epss_percentile": 0.40715}, "CVE-2018-1475": {"epss_score": 0.00365, "epss_percentile": 0.57969}, "CVE-2018-1476": {"epss_score": 0.0018, "epss_percentile": 0.39871}, "CVE-2018-1478": {"epss_score": 0.00149, "epss_percentile": 0.36018}, "CVE-2018-1479": {"epss_score": 0.00131, "epss_percentile": 0.3345}, "CVE-2018-1480": {"epss_score": 0.0012, "epss_percentile": 0.31747}, "CVE-2018-1481": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2018-1483": {"epss_score": 0.00248, "epss_percentile": 0.47995}, "CVE-2018-1484": {"epss_score": 0.00139, "epss_percentile": 0.34651}, "CVE-2018-1485": {"epss_score": 0.00114, "epss_percentile": 0.30831}, "CVE-2018-1487": {"epss_score": 0.00077, "epss_percentile": 0.23449}, "CVE-2018-1488": {"epss_score": 0.00066, "epss_percentile": 0.2096}, "CVE-2018-1492": {"epss_score": 0.00051, "epss_percentile": 0.16153}, "CVE-2018-1494": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2018-1495": {"epss_score": 0.00271, "epss_percentile": 0.50331}, "CVE-2018-1496": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1498": {"epss_score": 0.00043, "epss_percentile": 0.13029}, "CVE-2018-1501": {"epss_score": 0.00154, "epss_percentile": 0.36661}, "CVE-2018-1502": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2018-1503": {"epss_score": 0.00324, "epss_percentile": 0.54949}, "CVE-2018-1504": {"epss_score": 0.00149, "epss_percentile": 0.36018}, "CVE-2018-1505": {"epss_score": 0.00042, "epss_percentile": 0.12651}, "CVE-2018-1507": {"epss_score": 0.00234, "epss_percentile": 0.46124}, "CVE-2018-1509": {"epss_score": 0.00108, "epss_percentile": 0.29792}, "CVE-2018-1513": {"epss_score": 0.02374, "epss_percentile": 0.84536}, "CVE-2018-1514": {"epss_score": 0.00089, "epss_percentile": 0.25972}, "CVE-2018-1515": {"epss_score": 0.0005, "epss_percentile": 0.15769}, "CVE-2018-1517": {"epss_score": 0.00588, "epss_percentile": 0.68509}, "CVE-2018-1518": {"epss_score": 0.00011, "epss_percentile": 0.01013}, "CVE-2018-1521": {"epss_score": 0.0018, "epss_percentile": 0.39919}, "CVE-2018-1522": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1523": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2018-1524": {"epss_score": 0.00393, "epss_percentile": 0.59721}, "CVE-2018-1525": {"epss_score": 0.00122, "epss_percentile": 0.32108}, "CVE-2018-1528": {"epss_score": 0.00163, "epss_percentile": 0.37756}, "CVE-2018-1529": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2018-1532": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2018-1533": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2018-1534": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1535": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1536": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1539": {"epss_score": 0.00123, "epss_percentile": 0.32325}, "CVE-2018-1541": {"epss_score": 0.00151, "epss_percentile": 0.36362}, "CVE-2018-1542": {"epss_score": 0.00457, "epss_percentile": 0.63368}, "CVE-2018-1543": {"epss_score": 0.00108, "epss_percentile": 0.29772}, "CVE-2018-1544": {"epss_score": 0.00061, "epss_percentile": 0.19346}, "CVE-2018-1545": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2018-1546": {"epss_score": 0.00218, "epss_percentile": 0.44432}, "CVE-2018-1547": {"epss_score": 0.01219, "epss_percentile": 0.78616}, "CVE-2018-1548": {"epss_score": 0.00163, "epss_percentile": 0.37756}, "CVE-2018-1549": {"epss_score": 0.00109, "epss_percentile": 0.30059}, "CVE-2018-1550": {"epss_score": 0.00036, "epss_percentile": 0.10384}, "CVE-2018-1551": {"epss_score": 0.00219, "epss_percentile": 0.44499}, "CVE-2018-1552": {"epss_score": 0.01874, "epss_percentile": 0.82653}, "CVE-2018-1553": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2018-1554": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1555": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1556": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1557": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1558": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1560": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1563": {"epss_score": 0.02112, "epss_percentile": 0.83648}, "CVE-2018-1564": {"epss_score": 0.00046, "epss_percentile": 0.14316}, "CVE-2018-1565": {"epss_score": 0.00061, "epss_percentile": 0.19346}, "CVE-2018-1566": {"epss_score": 0.00083, "epss_percentile": 0.24697}, "CVE-2018-1567": {"epss_score": 0.0078, "epss_percentile": 0.73168}, "CVE-2018-1568": {"epss_score": 0.00042, "epss_percentile": 0.12651}, "CVE-2018-1571": {"epss_score": 0.03717, "epss_percentile": 0.87614}, "CVE-2018-1583": {"epss_score": 0.00173, "epss_percentile": 0.39113}, "CVE-2018-1584": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1585": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1587": {"epss_score": 0.00151, "epss_percentile": 0.36332}, "CVE-2018-1588": {"epss_score": 0.00359, "epss_percentile": 0.57616}, "CVE-2018-1593": {"epss_score": 0.00046, "epss_percentile": 0.14126}, "CVE-2018-1595": {"epss_score": 0.00192, "epss_percentile": 0.41328}, "CVE-2018-1599": {"epss_score": 0.00092, "epss_percentile": 0.26425}, "CVE-2018-1600": {"epss_score": 0.00091, "epss_percentile": 0.26385}, "CVE-2018-1601": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1602": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1603": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1604": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1605": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1606": {"epss_score": 0.00184, "epss_percentile": 0.40398}, "CVE-2018-1607": {"epss_score": 0.00359, "epss_percentile": 0.57616}, "CVE-2018-1608": {"epss_score": 0.00136, "epss_percentile": 0.34148}, "CVE-2018-1610": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1612": {"epss_score": 0.78368, "epss_percentile": 0.98984}, "CVE-2018-1614": {"epss_score": 0.00583, "epss_percentile": 0.68334}, "CVE-2018-1618": {"epss_score": 0.00462, "epss_percentile": 0.63626}, "CVE-2018-1621": {"epss_score": 0.00054, "epss_percentile": 0.17099}, "CVE-2018-1622": {"epss_score": 0.00127, "epss_percentile": 0.32867}, "CVE-2018-1623": {"epss_score": 0.00085, "epss_percentile": 0.25234}, "CVE-2018-1625": {"epss_score": 0.00221, "epss_percentile": 0.44684}, "CVE-2018-1626": {"epss_score": 0.0019, "epss_percentile": 0.41062}, "CVE-2018-1630": {"epss_score": 0.00058, "epss_percentile": 0.18411}, "CVE-2018-1631": {"epss_score": 0.00058, "epss_percentile": 0.18411}, "CVE-2018-1632": {"epss_score": 0.00058, "epss_percentile": 0.18411}, "CVE-2018-1633": {"epss_score": 0.00126, "epss_percentile": 0.32628}, "CVE-2018-1634": {"epss_score": 0.00058, "epss_percentile": 0.18411}, "CVE-2018-1635": {"epss_score": 0.00074, "epss_percentile": 0.2268}, "CVE-2018-1636": {"epss_score": 0.00074, "epss_percentile": 0.2268}, "CVE-2018-1638": {"epss_score": 0.00205, "epss_percentile": 0.42699}, "CVE-2018-1639": {"epss_score": 0.00162, "epss_percentile": 0.3766}, "CVE-2018-1640": {"epss_score": 0.03389, "epss_percentile": 0.87046}, "CVE-2018-1643": {"epss_score": 0.00411, "epss_percentile": 0.60899}, "CVE-2018-1644": {"epss_score": 0.00156, "epss_percentile": 0.3694}, "CVE-2018-1647": {"epss_score": 0.00243, "epss_percentile": 0.47416}, "CVE-2018-1648": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2018-1649": {"epss_score": 0.0034, "epss_percentile": 0.56215}, "CVE-2018-1650": {"epss_score": 0.00057, "epss_percentile": 0.17967}, "CVE-2018-1652": {"epss_score": 0.00047, "epss_percentile": 0.14859}, "CVE-2018-1653": {"epss_score": 0.00151, "epss_percentile": 0.36362}, "CVE-2018-1654": {"epss_score": 0.00179, "epss_percentile": 0.3981}, "CVE-2018-1655": {"epss_score": 0.00067, "epss_percentile": 0.21107}, "CVE-2018-1656": {"epss_score": 0.00527, "epss_percentile": 0.66464}, "CVE-2018-1657": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1658": {"epss_score": 0.00126, "epss_percentile": 0.32664}, "CVE-2018-1659": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2018-1660": {"epss_score": 0.00403, "epss_percentile": 0.60349}, "CVE-2018-1661": {"epss_score": 0.00146, "epss_percentile": 0.35623}, "CVE-2018-1663": {"epss_score": 0.00263, "epss_percentile": 0.49533}, "CVE-2018-1664": {"epss_score": 0.00043, "epss_percentile": 0.13022}, "CVE-2018-1665": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2018-1666": {"epss_score": 0.00165, "epss_percentile": 0.38121}, "CVE-2018-1667": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2018-1668": {"epss_score": 0.00154, "epss_percentile": 0.36661}, "CVE-2018-1669": {"epss_score": 0.00403, "epss_percentile": 0.60376}, "CVE-2018-1670": {"epss_score": 0.00212, "epss_percentile": 0.43805}, "CVE-2018-1671": {"epss_score": 0.00264, "epss_percentile": 0.49725}, "CVE-2018-1672": {"epss_score": 0.00228, "epss_percentile": 0.45518}, "CVE-2018-1673": {"epss_score": 0.00248, "epss_percentile": 0.47995}, "CVE-2018-1674": {"epss_score": 0.00293, "epss_percentile": 0.52297}, "CVE-2018-1675": {"epss_score": 0.00206, "epss_percentile": 0.43047}, "CVE-2018-1676": {"epss_score": 0.00166, "epss_percentile": 0.38177}, "CVE-2018-1677": {"epss_score": 0.00047, "epss_percentile": 0.14859}, "CVE-2018-1679": {"epss_score": 0.00191, "epss_percentile": 0.41193}, "CVE-2018-1680": {"epss_score": 0.00245, "epss_percentile": 0.47681}, "CVE-2018-1682": {"epss_score": 0.0026, "epss_percentile": 0.49234}, "CVE-2018-1683": {"epss_score": 0.00178, "epss_percentile": 0.39704}, "CVE-2018-1684": {"epss_score": 0.00356, "epss_percentile": 0.57395}, "CVE-2018-1685": {"epss_score": 0.00061, "epss_percentile": 0.19483}, "CVE-2018-1686": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1688": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1690": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2018-1691": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1692": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1694": {"epss_score": 0.00266, "epss_percentile": 0.49951}, "CVE-2018-1695": {"epss_score": 0.00474, "epss_percentile": 0.64147}, "CVE-2018-1697": {"epss_score": 0.00057, "epss_percentile": 0.18015}, "CVE-2018-1698": {"epss_score": 0.00191, "epss_percentile": 0.41193}, "CVE-2018-1699": {"epss_score": 0.00492, "epss_percentile": 0.65014}, "CVE-2018-1701": {"epss_score": 0.00255, "epss_percentile": 0.48629}, "CVE-2018-1702": {"epss_score": 0.00351, "epss_percentile": 0.57018}, "CVE-2018-1704": {"epss_score": 0.00082, "epss_percentile": 0.24441}, "CVE-2018-1705": {"epss_score": 0.00177, "epss_percentile": 0.39538}, "CVE-2018-1706": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2018-1708": {"epss_score": 0.00177, "epss_percentile": 0.39538}, "CVE-2018-1710": {"epss_score": 0.00107, "epss_percentile": 0.29751}, "CVE-2018-1711": {"epss_score": 0.00072, "epss_percentile": 0.22474}, "CVE-2018-1712": {"epss_score": 0.00108, "epss_percentile": 0.29887}, "CVE-2018-1715": {"epss_score": 0.0021, "epss_percentile": 0.43588}, "CVE-2018-1716": {"epss_score": 0.00226, "epss_percentile": 0.45267}, "CVE-2018-1718": {"epss_score": 0.00214, "epss_percentile": 0.43999}, "CVE-2018-1719": {"epss_score": 0.00256, "epss_percentile": 0.48768}, "CVE-2018-1720": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2018-1721": {"epss_score": 0.00485, "epss_percentile": 0.64716}, "CVE-2018-1722": {"epss_score": 0.2847, "epss_percentile": 0.9636}, "CVE-2018-1723": {"epss_score": 0.00136, "epss_percentile": 0.34132}, "CVE-2018-1724": {"epss_score": 0.00055, "epss_percentile": 0.17523}, "CVE-2018-1725": {"epss_score": 0.00055, "epss_percentile": 0.17374}, "CVE-2018-1727": {"epss_score": 0.00416, "epss_percentile": 0.61192}, "CVE-2018-1728": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1729": {"epss_score": 0.00202, "epss_percentile": 0.42483}, "CVE-2018-1730": {"epss_score": 0.00359, "epss_percentile": 0.57616}, "CVE-2018-1731": {"epss_score": 0.00207, "epss_percentile": 0.43127}, "CVE-2018-1732": {"epss_score": 0.0018, "epss_percentile": 0.39871}, "CVE-2018-1733": {"epss_score": 0.00214, "epss_percentile": 0.43976}, "CVE-2018-1734": {"epss_score": 0.00156, "epss_percentile": 0.36883}, "CVE-2018-1736": {"epss_score": 0.00465, "epss_percentile": 0.63762}, "CVE-2018-1738": {"epss_score": 0.0013, "epss_percentile": 0.33321}, "CVE-2018-1740": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1741": {"epss_score": 0.00218, "epss_percentile": 0.44337}, "CVE-2018-1742": {"epss_score": 0.00017, "epss_percentile": 0.03209}, "CVE-2018-1743": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2018-1744": {"epss_score": 0.00358, "epss_percentile": 0.57489}, "CVE-2018-1745": {"epss_score": 0.00411, "epss_percentile": 0.60903}, "CVE-2018-1747": {"epss_score": 0.00351, "epss_percentile": 0.57018}, "CVE-2018-1749": {"epss_score": 0.00126, "epss_percentile": 0.32748}, "CVE-2018-1750": {"epss_score": 0.00131, "epss_percentile": 0.33469}, "CVE-2018-1751": {"epss_score": 0.00152, "epss_percentile": 0.3645}, "CVE-2018-1753": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2018-1755": {"epss_score": 0.00386, "epss_percentile": 0.59238}, "CVE-2018-1756": {"epss_score": 0.27784, "epss_percentile": 0.96283}, "CVE-2018-1757": {"epss_score": 0.00099, "epss_percentile": 0.284}, "CVE-2018-1758": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2018-1759": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1760": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2018-1761": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1762": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1763": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1764": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1766": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2018-1767": {"epss_score": 0.00303, "epss_percentile": 0.53206}, "CVE-2018-1768": {"epss_score": 0.00053, "epss_percentile": 0.16863}, "CVE-2018-1770": {"epss_score": 0.00484, "epss_percentile": 0.64635}, "CVE-2018-1771": {"epss_score": 0.00033, "epss_percentile": 0.09297}, "CVE-2018-1772": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2018-1773": {"epss_score": 0.0016, "epss_percentile": 0.37517}, "CVE-2018-1774": {"epss_score": 0.0011, "epss_percentile": 0.30159}, "CVE-2018-1775": {"epss_score": 0.0045, "epss_percentile": 0.63081}, "CVE-2018-1777": {"epss_score": 0.00297, "epss_percentile": 0.52758}, "CVE-2018-1778": {"epss_score": 0.00349, "epss_percentile": 0.56877}, "CVE-2018-1779": {"epss_score": 0.00376, "epss_percentile": 0.58683}, "CVE-2018-1780": {"epss_score": 0.00075, "epss_percentile": 0.23062}, "CVE-2018-1781": {"epss_score": 0.00041, "epss_percentile": 0.12387}, "CVE-2018-1782": {"epss_score": 0.00048, "epss_percentile": 0.15219}, "CVE-2018-1783": {"epss_score": 0.0005, "epss_percentile": 0.1588}, "CVE-2018-1784": {"epss_score": 0.00246, "epss_percentile": 0.47799}, "CVE-2018-1785": {"epss_score": 0.00132, "epss_percentile": 0.33534}, "CVE-2018-1786": {"epss_score": 0.00361, "epss_percentile": 0.57692}, "CVE-2018-1787": {"epss_score": 0.00033, "epss_percentile": 0.09356}, "CVE-2018-1788": {"epss_score": 0.00064, "epss_percentile": 0.20358}, "CVE-2018-1789": {"epss_score": 0.00183, "epss_percentile": 0.4032}, "CVE-2018-1790": {"epss_score": 0.00094, "epss_percentile": 0.27031}, "CVE-2018-1791": {"epss_score": 0.00166, "epss_percentile": 0.38164}, "CVE-2018-1792": {"epss_score": 0.00286, "epss_percentile": 0.51747}, "CVE-2018-1793": {"epss_score": 0.00303, "epss_percentile": 0.53206}, "CVE-2018-1794": {"epss_score": 0.00333, "epss_percentile": 0.55668}, "CVE-2018-1795": {"epss_score": 0.00166, "epss_percentile": 0.38177}, "CVE-2018-1796": {"epss_score": 0.00038, "epss_percentile": 0.11169}, "CVE-2018-1797": {"epss_score": 0.00444, "epss_percentile": 0.62828}, "CVE-2018-1798": {"epss_score": 0.00453, "epss_percentile": 0.63203}, "CVE-2018-1799": {"epss_score": 0.00062, "epss_percentile": 0.19657}, "CVE-2018-1800": {"epss_score": 0.00046, "epss_percentile": 0.14125}, "CVE-2018-1801": {"epss_score": 0.00275, "epss_percentile": 0.50694}, "CVE-2018-1802": {"epss_score": 0.00094, "epss_percentile": 0.26978}, "CVE-2018-1803": {"epss_score": 0.00145, "epss_percentile": 0.35405}, "CVE-2018-1804": {"epss_score": 0.00139, "epss_percentile": 0.34651}, "CVE-2018-1805": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2018-1808": {"epss_score": 0.00257, "epss_percentile": 0.48891}, "CVE-2018-1812": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2018-1813": {"epss_score": 0.00126, "epss_percentile": 0.32748}, "CVE-2018-1814": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2018-1815": {"epss_score": 0.00166, "epss_percentile": 0.38177}, "CVE-2018-1817": {"epss_score": 0.00166, "epss_percentile": 0.38177}, "CVE-2018-1818": {"epss_score": 0.0004, "epss_percentile": 0.11904}, "CVE-2018-1819": {"epss_score": 0.00444, "epss_percentile": 0.62842}, "CVE-2018-1820": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2018-1821": {"epss_score": 0.2688, "epss_percentile": 0.96187}, "CVE-2018-1822": {"epss_score": 0.0014, "epss_percentile": 0.34754}, "CVE-2018-1823": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1824": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1825": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1826": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2018-1827": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2018-1828": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2018-1829": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1833": {"epss_score": 0.00137, "epss_percentile": 0.34258}, "CVE-2018-1834": {"epss_score": 0.00039, "epss_percentile": 0.11621}, "CVE-2018-1835": {"epss_score": 0.00286, "epss_percentile": 0.51707}, "CVE-2018-1836": {"epss_score": 0.00157, "epss_percentile": 0.37136}, "CVE-2018-1838": {"epss_score": 0.0017, "epss_percentile": 0.38724}, "CVE-2018-1840": {"epss_score": 0.00671, "epss_percentile": 0.70808}, "CVE-2018-1841": {"epss_score": 0.00049, "epss_percentile": 0.1558}, "CVE-2018-1842": {"epss_score": 0.00071, "epss_percentile": 0.21993}, "CVE-2018-1843": {"epss_score": 0.00047, "epss_percentile": 0.14878}, "CVE-2018-1844": {"epss_score": 0.00351, "epss_percentile": 0.57018}, "CVE-2018-1845": {"epss_score": 0.00433, "epss_percentile": 0.62202}, "CVE-2018-1846": {"epss_score": 0.00351, "epss_percentile": 0.57018}, "CVE-2018-1847": {"epss_score": 0.00311, "epss_percentile": 0.53828}, "CVE-2018-1848": {"epss_score": 0.00226, "epss_percentile": 0.45267}, "CVE-2018-1850": {"epss_score": 0.00505, "epss_percentile": 0.65603}, "CVE-2018-1851": {"epss_score": 0.03826, "epss_percentile": 0.87793}, "CVE-2018-1853": {"epss_score": 0.00126, "epss_percentile": 0.32741}, "CVE-2018-1857": {"epss_score": 0.00386, "epss_percentile": 0.59263}, "CVE-2018-1858": {"epss_score": 0.00175, "epss_percentile": 0.39284}, "CVE-2018-1859": {"epss_score": 0.0019, "epss_percentile": 0.41094}, "CVE-2018-1871": {"epss_score": 0.00151, "epss_percentile": 0.36362}, "CVE-2018-1872": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1874": {"epss_score": 0.00136, "epss_percentile": 0.34115}, "CVE-2018-1875": {"epss_score": 0.00141, "epss_percentile": 0.34812}, "CVE-2018-1876": {"epss_score": 0.00047, "epss_percentile": 0.14476}, "CVE-2018-1877": {"epss_score": 0.00017, "epss_percentile": 0.03379}, "CVE-2018-1878": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2018-1882": {"epss_score": 0.0003, "epss_percentile": 0.08154}, "CVE-2018-1883": {"epss_score": 0.00361, "epss_percentile": 0.57692}, "CVE-2018-1884": {"epss_score": 0.00858, "epss_percentile": 0.7451}, "CVE-2018-1885": {"epss_score": 0.00202, "epss_percentile": 0.42489}, "CVE-2018-1886": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2018-1887": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2018-1888": {"epss_score": 0.00384, "epss_percentile": 0.59166}, "CVE-2018-1889": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1890": {"epss_score": 0.00154, "epss_percentile": 0.36727}, "CVE-2018-1891": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1892": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2018-1893": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2018-1895": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1896": {"epss_score": 0.00151, "epss_percentile": 0.36362}, "CVE-2018-1897": {"epss_score": 0.00101, "epss_percentile": 0.28619}, "CVE-2018-1899": {"epss_score": 0.00079, "epss_percentile": 0.23805}, "CVE-2018-1900": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1901": {"epss_score": 0.00739, "epss_percentile": 0.72395}, "CVE-2018-1902": {"epss_score": 0.00271, "epss_percentile": 0.50345}, "CVE-2018-1903": {"epss_score": 0.0004, "epss_percentile": 0.12036}, "CVE-2018-1904": {"epss_score": 0.0078, "epss_percentile": 0.73168}, "CVE-2018-1905": {"epss_score": 0.00456, "epss_percentile": 0.63316}, "CVE-2018-1906": {"epss_score": 0.0039, "epss_percentile": 0.59498}, "CVE-2018-1908": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1910": {"epss_score": 0.00247, "epss_percentile": 0.47821}, "CVE-2018-1911": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1912": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2018-1913": {"epss_score": 0.00229, "epss_percentile": 0.45551}, "CVE-2018-1914": {"epss_score": 0.00247, "epss_percentile": 0.47821}, "CVE-2018-1916": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1917": {"epss_score": 0.0038, "epss_percentile": 0.58947}, "CVE-2018-1918": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1920": {"epss_score": 0.00491, "epss_percentile": 0.64969}, "CVE-2018-1921": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2018-1922": {"epss_score": 0.00137, "epss_percentile": 0.34275}, "CVE-2018-1923": {"epss_score": 0.00137, "epss_percentile": 0.34275}, "CVE-2018-1925": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2018-1926": {"epss_score": 0.00171, "epss_percentile": 0.38792}, "CVE-2018-1927": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2018-1928": {"epss_score": 0.00045, "epss_percentile": 0.13948}, "CVE-2018-1929": {"epss_score": 0.0022, "epss_percentile": 0.44595}, "CVE-2018-1932": {"epss_score": 0.05725, "epss_percentile": 0.90155}, "CVE-2018-1933": {"epss_score": 0.00229, "epss_percentile": 0.45551}, "CVE-2018-1934": {"epss_score": 0.00127, "epss_percentile": 0.32867}, "CVE-2018-1935": {"epss_score": 0.00163, "epss_percentile": 0.37756}, "CVE-2018-1936": {"epss_score": 0.00058, "epss_percentile": 0.18282}, "CVE-2018-1937": {"epss_score": 0.00027, "epss_percentile": 0.06786}, "CVE-2018-1938": {"epss_score": 0.00027, "epss_percentile": 0.06786}, "CVE-2018-1939": {"epss_score": 0.00191, "epss_percentile": 0.41165}, "CVE-2018-1941": {"epss_score": 0.00027, "epss_percentile": 0.07077}, "CVE-2018-1943": {"epss_score": 0.00133, "epss_percentile": 0.33728}, "CVE-2018-1944": {"epss_score": 0.00073, "epss_percentile": 0.2265}, "CVE-2018-1945": {"epss_score": 0.00149, "epss_percentile": 0.36018}, "CVE-2018-1946": {"epss_score": 0.00034, "epss_percentile": 0.09474}, "CVE-2018-1947": {"epss_score": 0.00131, "epss_percentile": 0.33423}, "CVE-2018-1948": {"epss_score": 0.00147, "epss_percentile": 0.35748}, "CVE-2018-1949": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2018-1950": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2018-1951": {"epss_score": 0.00216, "epss_percentile": 0.44135}, "CVE-2018-1952": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1956": {"epss_score": 0.00241, "epss_percentile": 0.47322}, "CVE-2018-1957": {"epss_score": 0.00066, "epss_percentile": 0.20924}, "CVE-2018-1959": {"epss_score": 0.00022, "epss_percentile": 0.05194}, "CVE-2018-1961": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2018-1962": {"epss_score": 0.00044, "epss_percentile": 0.13483}, "CVE-2018-1967": {"epss_score": 0.00226, "epss_percentile": 0.45267}, "CVE-2018-1968": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2018-1969": {"epss_score": 0.00361, "epss_percentile": 0.57742}, "CVE-2018-1970": {"epss_score": 0.00359, "epss_percentile": 0.57616}, "CVE-2018-1973": {"epss_score": 0.00291, "epss_percentile": 0.52188}, "CVE-2018-1974": {"epss_score": 0.00255, "epss_percentile": 0.48693}, "CVE-2018-1975": {"epss_score": 0.00186, "epss_percentile": 0.40588}, "CVE-2018-1976": {"epss_score": 0.00246, "epss_percentile": 0.47795}, "CVE-2018-1977": {"epss_score": 0.00292, "epss_percentile": 0.52253}, "CVE-2018-1978": {"epss_score": 0.00075, "epss_percentile": 0.23058}, "CVE-2018-1980": {"epss_score": 0.00075, "epss_percentile": 0.23058}, "CVE-2018-1982": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1983": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1984": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2018-1985": {"epss_score": 0.00046, "epss_percentile": 0.14387}, "CVE-2018-1987": {"epss_score": 0.0004, "epss_percentile": 0.12158}, "CVE-2018-1990": {"epss_score": 0.0009, "epss_percentile": 0.26005}, "CVE-2018-1991": {"epss_score": 0.00141, "epss_percentile": 0.34836}, "CVE-2018-1992": {"epss_score": 0.00042, "epss_percentile": 0.12917}, "CVE-2018-1993": {"epss_score": 0.00054, "epss_percentile": 0.17336}, "CVE-2018-1994": {"epss_score": 0.00358, "epss_percentile": 0.57539}, "CVE-2018-1996": {"epss_score": 0.00093, "epss_percentile": 0.26621}, "CVE-2018-1997": {"epss_score": 0.00188, "epss_percentile": 0.40881}, "CVE-2018-1998": {"epss_score": 0.00102, "epss_percentile": 0.28741}, "CVE-2018-1999": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2018-20000": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2018-20001": {"epss_score": 0.003, "epss_percentile": 0.52978}, "CVE-2018-20002": {"epss_score": 0.00315, "epss_percentile": 0.54202}, "CVE-2018-20004": {"epss_score": 0.00711, "epss_percentile": 0.71728}, "CVE-2018-20005": {"epss_score": 0.00176, "epss_percentile": 0.39427}, "CVE-2018-20006": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-20007": {"epss_score": 0.00042, "epss_percentile": 0.12605}, "CVE-2018-20008": {"epss_score": 0.00033, "epss_percentile": 0.09188}, "CVE-2018-20009": {"epss_score": 0.00511, "epss_percentile": 0.65847}, "CVE-2018-20010": {"epss_score": 0.00511, "epss_percentile": 0.65847}, "CVE-2018-20011": {"epss_score": 0.00511, "epss_percentile": 0.65847}, "CVE-2018-20012": {"epss_score": 0.00257, "epss_percentile": 0.48847}, "CVE-2018-20013": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2018-20014": {"epss_score": 0.0047, "epss_percentile": 0.63974}, "CVE-2018-20015": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-20017": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20018": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2018-20019": {"epss_score": 0.168, "epss_percentile": 0.94733}, "CVE-2018-20020": {"epss_score": 0.2103, "epss_percentile": 0.95454}, "CVE-2018-20021": {"epss_score": 0.02552, "epss_percentile": 0.85081}, "CVE-2018-20022": {"epss_score": 0.06177, "epss_percentile": 0.90536}, "CVE-2018-20023": {"epss_score": 0.00856, "epss_percentile": 0.74472}, "CVE-2018-20024": {"epss_score": 0.03729, "epss_percentile": 0.87638}, "CVE-2018-20025": {"epss_score": 0.01506, "epss_percentile": 0.80744}, "CVE-2018-20026": {"epss_score": 0.01405, "epss_percentile": 0.80044}, "CVE-2018-20027": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2018-20028": {"epss_score": 0.0027, "epss_percentile": 0.50236}, "CVE-2018-20029": {"epss_score": 0.0004, "epss_percentile": 0.12169}, "CVE-2018-20030": {"epss_score": 0.01037, "epss_percentile": 0.7693}, "CVE-2018-20031": {"epss_score": 0.01223, "epss_percentile": 0.78663}, "CVE-2018-20032": {"epss_score": 0.01223, "epss_percentile": 0.78663}, "CVE-2018-20033": {"epss_score": 0.04532, "epss_percentile": 0.88813}, "CVE-2018-20034": {"epss_score": 0.01223, "epss_percentile": 0.78663}, "CVE-2018-20050": {"epss_score": 0.00619, "epss_percentile": 0.69396}, "CVE-2018-20051": {"epss_score": 0.00535, "epss_percentile": 0.66841}, "CVE-2018-20052": {"epss_score": 0.00049, "epss_percentile": 0.15489}, "CVE-2018-20053": {"epss_score": 0.04277, "epss_percentile": 0.88484}, "CVE-2018-20056": {"epss_score": 0.46441, "epss_percentile": 0.97546}, "CVE-2018-20057": {"epss_score": 0.13435, "epss_percentile": 0.93962}, "CVE-2018-20058": {"epss_score": 0.00428, "epss_percentile": 0.61919}, "CVE-2018-20059": {"epss_score": 0.00404, "epss_percentile": 0.60397}, "CVE-2018-20060": {"epss_score": 0.00471, "epss_percentile": 0.64019}, "CVE-2018-20061": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2018-20062": {"epss_score": 0.94307, "epss_percentile": 0.99942}, "CVE-2018-20063": {"epss_score": 0.01568, "epss_percentile": 0.81076}, "CVE-2018-20064": {"epss_score": 0.00334, "epss_percentile": 0.55744}, "CVE-2018-20065": {"epss_score": 0.00377, "epss_percentile": 0.58755}, "CVE-2018-20066": {"epss_score": 0.00377, "epss_percentile": 0.58755}, "CVE-2018-20067": {"epss_score": 0.00146, "epss_percentile": 0.35597}, "CVE-2018-20068": {"epss_score": 0.00159, "epss_percentile": 0.3733}, "CVE-2018-20069": {"epss_score": 0.00159, "epss_percentile": 0.3733}, "CVE-2018-20070": {"epss_score": 0.00159, "epss_percentile": 0.3733}, "CVE-2018-20071": {"epss_score": 0.00152, "epss_percentile": 0.36489}, "CVE-2018-20072": {"epss_score": 0.00186, "epss_percentile": 0.40666}, "CVE-2018-20073": {"epss_score": 0.00029, "epss_percentile": 0.07814}, "CVE-2018-20090": {"epss_score": 0.00317, "epss_percentile": 0.54381}, "CVE-2018-20091": {"epss_score": 0.00865, "epss_percentile": 0.7462}, "CVE-2018-20092": {"epss_score": 0.00423, "epss_percentile": 0.61581}, "CVE-2018-20094": {"epss_score": 0.0039, "epss_percentile": 0.59525}, "CVE-2018-20095": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2018-20096": {"epss_score": 0.01233, "epss_percentile": 0.78742}, "CVE-2018-20097": {"epss_score": 0.00636, "epss_percentile": 0.69875}, "CVE-2018-20098": {"epss_score": 0.01025, "epss_percentile": 0.76793}, "CVE-2018-20099": {"epss_score": 0.00868, "epss_percentile": 0.74671}, "CVE-2018-20100": {"epss_score": 0.00161, "epss_percentile": 0.37561}, "CVE-2018-20101": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2018-20102": {"epss_score": 0.00032, "epss_percentile": 0.0877}, "CVE-2018-20103": {"epss_score": 0.001, "epss_percentile": 0.28455}, "CVE-2018-20105": {"epss_score": 0.00143, "epss_percentile": 0.3522}, "CVE-2018-20106": {"epss_score": 0.00135, "epss_percentile": 0.33995}, "CVE-2018-20114": {"epss_score": 0.06732, "epss_percentile": 0.90989}, "CVE-2018-20121": {"epss_score": 0.0052, "epss_percentile": 0.66214}, "CVE-2018-20122": {"epss_score": 0.05907, "epss_percentile": 0.90314}, "CVE-2018-20123": {"epss_score": 0.00154, "epss_percentile": 0.36716}, "CVE-2018-20124": {"epss_score": 0.00151, "epss_percentile": 0.36365}, "CVE-2018-20125": {"epss_score": 0.005, "epss_percentile": 0.65292}, "CVE-2018-20126": {"epss_score": 0.00111, "epss_percentile": 0.30306}, "CVE-2018-20127": {"epss_score": 0.00768, "epss_percentile": 0.72971}, "CVE-2018-20128": {"epss_score": 0.00883, "epss_percentile": 0.74912}, "CVE-2018-20129": {"epss_score": 0.69561, "epss_percentile": 0.98593}, "CVE-2018-20131": {"epss_score": 0.00041, "epss_percentile": 0.12373}, "CVE-2018-20133": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2018-20135": {"epss_score": 0.00973, "epss_percentile": 0.76156}, "CVE-2018-20136": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20137": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20138": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20140": {"epss_score": 0.00918, "epss_percentile": 0.75446}, "CVE-2018-20141": {"epss_score": 0.0034, "epss_percentile": 0.56281}, "CVE-2018-20144": {"epss_score": 0.0029, "epss_percentile": 0.52114}, "CVE-2018-20145": {"epss_score": 0.00213, "epss_percentile": 0.43922}, "CVE-2018-20146": {"epss_score": 0.00036, "epss_percentile": 0.10256}, "CVE-2018-20147": {"epss_score": 0.05788, "epss_percentile": 0.90211}, "CVE-2018-20148": {"epss_score": 0.54862, "epss_percentile": 0.97948}, "CVE-2018-20149": {"epss_score": 0.04428, "epss_percentile": 0.88677}, "CVE-2018-20150": {"epss_score": 0.07368, "epss_percentile": 0.91437}, "CVE-2018-20151": {"epss_score": 0.06796, "epss_percentile": 0.91032}, "CVE-2018-20152": {"epss_score": 0.11676, "epss_percentile": 0.93443}, "CVE-2018-20153": {"epss_score": 0.05377, "epss_percentile": 0.898}, "CVE-2018-20154": {"epss_score": 0.00196, "epss_percentile": 0.41732}, "CVE-2018-20155": {"epss_score": 0.00131, "epss_percentile": 0.33391}, "CVE-2018-20156": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2018-20157": {"epss_score": 0.00413, "epss_percentile": 0.60995}, "CVE-2018-20159": {"epss_score": 0.06493, "epss_percentile": 0.90798}, "CVE-2018-20160": {"epss_score": 0.01679, "epss_percentile": 0.81721}, "CVE-2018-20161": {"epss_score": 0.00095, "epss_percentile": 0.27184}, "CVE-2018-20162": {"epss_score": 0.04506, "epss_percentile": 0.8877}, "CVE-2018-20164": {"epss_score": 0.01005, "epss_percentile": 0.76538}, "CVE-2018-20165": {"epss_score": 0.0095, "epss_percentile": 0.7586}, "CVE-2018-20166": {"epss_score": 0.03819, "epss_percentile": 0.87773}, "CVE-2018-20167": {"epss_score": 0.01424, "epss_percentile": 0.80192}, "CVE-2018-20168": {"epss_score": 0.0005, "epss_percentile": 0.15847}, "CVE-2018-20169": {"epss_score": 0.00111, "epss_percentile": 0.30305}, "CVE-2018-20170": {"epss_score": 0.00194, "epss_percentile": 0.41594}, "CVE-2018-20171": {"epss_score": 0.03828, "epss_percentile": 0.87797}, "CVE-2018-20172": {"epss_score": 0.03828, "epss_percentile": 0.87797}, "CVE-2018-20173": {"epss_score": 0.12833, "epss_percentile": 0.93798}, "CVE-2018-20174": {"epss_score": 0.00477, "epss_percentile": 0.64321}, "CVE-2018-20175": {"epss_score": 0.00574, "epss_percentile": 0.68092}, "CVE-2018-20176": {"epss_score": 0.00508, "epss_percentile": 0.65717}, "CVE-2018-20177": {"epss_score": 0.05024, "epss_percentile": 0.89408}, "CVE-2018-20178": {"epss_score": 0.00574, "epss_percentile": 0.68092}, "CVE-2018-20179": {"epss_score": 0.07516, "epss_percentile": 0.91514}, "CVE-2018-20180": {"epss_score": 0.15109, "epss_percentile": 0.94365}, "CVE-2018-20181": {"epss_score": 0.09899, "epss_percentile": 0.92762}, "CVE-2018-20182": {"epss_score": 0.09899, "epss_percentile": 0.92762}, "CVE-2018-20184": {"epss_score": 0.00265, "epss_percentile": 0.49816}, "CVE-2018-20185": {"epss_score": 0.00846, "epss_percentile": 0.74328}, "CVE-2018-20186": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2018-20187": {"epss_score": 0.00507, "epss_percentile": 0.65647}, "CVE-2018-20188": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2018-20189": {"epss_score": 0.00633, "epss_percentile": 0.6976}, "CVE-2018-20190": {"epss_score": 0.00278, "epss_percentile": 0.50871}, "CVE-2018-20191": {"epss_score": 0.00725, "epss_percentile": 0.72048}, "CVE-2018-20193": {"epss_score": 0.00505, "epss_percentile": 0.6561}, "CVE-2018-20194": {"epss_score": 0.00289, "epss_percentile": 0.5201}, "CVE-2018-20195": {"epss_score": 0.00323, "epss_percentile": 0.54908}, "CVE-2018-20196": {"epss_score": 0.00333, "epss_percentile": 0.55679}, "CVE-2018-20197": {"epss_score": 0.00311, "epss_percentile": 0.53864}, "CVE-2018-20198": {"epss_score": 0.00329, "epss_percentile": 0.55388}, "CVE-2018-20199": {"epss_score": 0.00479, "epss_percentile": 0.64411}, "CVE-2018-20200": {"epss_score": 0.00305, "epss_percentile": 0.53314}, "CVE-2018-20201": {"epss_score": 0.00189, "epss_percentile": 0.40928}, "CVE-2018-20211": {"epss_score": 0.00202, "epss_percentile": 0.42453}, "CVE-2018-20212": {"epss_score": 0.0037, "epss_percentile": 0.58285}, "CVE-2018-20213": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2018-20216": {"epss_score": 0.00498, "epss_percentile": 0.65231}, "CVE-2018-20217": {"epss_score": 0.01585, "epss_percentile": 0.81167}, "CVE-2018-20218": {"epss_score": 0.36863, "epss_percentile": 0.97005}, "CVE-2018-20219": {"epss_score": 0.43734, "epss_percentile": 0.97401}, "CVE-2018-20220": {"epss_score": 0.44435, "epss_percentile": 0.97435}, "CVE-2018-20221": {"epss_score": 0.04561, "epss_percentile": 0.88852}, "CVE-2018-20222": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2018-20225": {"epss_score": 0.02885, "epss_percentile": 0.8591}, "CVE-2018-20226": {"epss_score": 0.00443, "epss_percentile": 0.62792}, "CVE-2018-20227": {"epss_score": 0.01411, "epss_percentile": 0.80085}, "CVE-2018-20228": {"epss_score": 0.00137, "epss_percentile": 0.34275}, "CVE-2018-20229": {"epss_score": 0.00055, "epss_percentile": 0.17421}, "CVE-2018-20230": {"epss_score": 0.00156, "epss_percentile": 0.36884}, "CVE-2018-20231": {"epss_score": 0.00137, "epss_percentile": 0.34242}, "CVE-2018-20232": {"epss_score": 0.0018, "epss_percentile": 0.39923}, "CVE-2018-20233": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2018-20234": {"epss_score": 0.04305, "epss_percentile": 0.88521}, "CVE-2018-20235": {"epss_score": 0.05634, "epss_percentile": 0.9007}, "CVE-2018-20236": {"epss_score": 0.02451, "epss_percentile": 0.84788}, "CVE-2018-20237": {"epss_score": 0.00387, "epss_percentile": 0.59314}, "CVE-2018-20238": {"epss_score": 0.00205, "epss_percentile": 0.42704}, "CVE-2018-20239": {"epss_score": 0.00558, "epss_percentile": 0.67598}, "CVE-2018-20240": {"epss_score": 0.00184, "epss_percentile": 0.40413}, "CVE-2018-20241": {"epss_score": 0.00203, "epss_percentile": 0.42559}, "CVE-2018-20242": {"epss_score": 0.01372, "epss_percentile": 0.79813}, "CVE-2018-20243": {"epss_score": 0.00681, "epss_percentile": 0.71059}, "CVE-2018-20244": {"epss_score": 0.0088, "epss_percentile": 0.74855}, "CVE-2018-20245": {"epss_score": 0.00359, "epss_percentile": 0.57569}, "CVE-2018-20247": {"epss_score": 0.44944, "epss_percentile": 0.97462}, "CVE-2018-20248": {"epss_score": 0.00145, "epss_percentile": 0.35401}, "CVE-2018-20249": {"epss_score": 0.01421, "epss_percentile": 0.80172}, "CVE-2018-20250": {"epss_score": 0.93462, "epss_percentile": 0.99809}, "CVE-2018-20251": {"epss_score": 0.00548, "epss_percentile": 0.67273}, "CVE-2018-20252": {"epss_score": 0.00733, "epss_percentile": 0.72215}, "CVE-2018-20253": {"epss_score": 0.00649, "epss_percentile": 0.70225}, "CVE-2018-20298": {"epss_score": 0.00482, "epss_percentile": 0.64542}, "CVE-2018-20299": {"epss_score": 0.0128, "epss_percentile": 0.79141}, "CVE-2018-20300": {"epss_score": 0.00994, "epss_percentile": 0.76426}, "CVE-2018-20301": {"epss_score": 0.00161, "epss_percentile": 0.37608}, "CVE-2018-20302": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-20303": {"epss_score": 0.02468, "epss_percentile": 0.84841}, "CVE-2018-20304": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2018-20305": {"epss_score": 0.1199, "epss_percentile": 0.93538}, "CVE-2018-20306": {"epss_score": 0.00182, "epss_percentile": 0.40192}, "CVE-2018-20307": {"epss_score": 0.00155, "epss_percentile": 0.36853}, "CVE-2018-20309": {"epss_score": 0.00026, "epss_percentile": 0.06666}, "CVE-2018-20310": {"epss_score": 0.00026, "epss_percentile": 0.06666}, "CVE-2018-20311": {"epss_score": 0.00026, "epss_percentile": 0.06666}, "CVE-2018-20312": {"epss_score": 0.00026, "epss_percentile": 0.06666}, "CVE-2018-20313": {"epss_score": 0.00026, "epss_percentile": 0.06666}, "CVE-2018-20314": {"epss_score": 0.00026, "epss_percentile": 0.06666}, "CVE-2018-20315": {"epss_score": 0.00026, "epss_percentile": 0.06666}, "CVE-2018-20316": {"epss_score": 0.00026, "epss_percentile": 0.06666}, "CVE-2018-20318": {"epss_score": 0.00482, "epss_percentile": 0.6454}, "CVE-2018-20321": {"epss_score": 0.00442, "epss_percentile": 0.62734}, "CVE-2018-20322": {"epss_score": 0.00408, "epss_percentile": 0.60643}, "CVE-2018-20323": {"epss_score": 0.7532, "epss_percentile": 0.98837}, "CVE-2018-20325": {"epss_score": 0.0353, "epss_percentile": 0.873}, "CVE-2018-20326": {"epss_score": 0.03078, "epss_percentile": 0.86365}, "CVE-2018-20327": {"epss_score": 0.00191, "epss_percentile": 0.41258}, "CVE-2018-20328": {"epss_score": 0.00188, "epss_percentile": 0.40914}, "CVE-2018-20329": {"epss_score": 0.00222, "epss_percentile": 0.44734}, "CVE-2018-20330": {"epss_score": 0.00334, "epss_percentile": 0.55692}, "CVE-2018-20331": {"epss_score": 0.00074, "epss_percentile": 0.22829}, "CVE-2018-20332": {"epss_score": 0.005, "epss_percentile": 0.65293}, "CVE-2018-20333": {"epss_score": 0.00526, "epss_percentile": 0.6643}, "CVE-2018-20334": {"epss_score": 0.03913, "epss_percentile": 0.87938}, "CVE-2018-20335": {"epss_score": 0.01679, "epss_percentile": 0.81723}, "CVE-2018-20336": {"epss_score": 0.00418, "epss_percentile": 0.61294}, "CVE-2018-20337": {"epss_score": 0.00363, "epss_percentile": 0.57828}, "CVE-2018-20338": {"epss_score": 0.05224, "epss_percentile": 0.89631}, "CVE-2018-20339": {"epss_score": 0.01206, "epss_percentile": 0.78519}, "CVE-2018-20340": {"epss_score": 0.00196, "epss_percentile": 0.41714}, "CVE-2018-20341": {"epss_score": 0.00059, "epss_percentile": 0.18845}, "CVE-2018-20342": {"epss_score": 0.00058, "epss_percentile": 0.18545}, "CVE-2018-20343": {"epss_score": 0.06763, "epss_percentile": 0.9101}, "CVE-2018-20345": {"epss_score": 0.00356, "epss_percentile": 0.57364}, "CVE-2018-20346": {"epss_score": 0.13215, "epss_percentile": 0.93903}, "CVE-2018-20348": {"epss_score": 0.00058, "epss_percentile": 0.18462}, "CVE-2018-20349": {"epss_score": 0.00342, "epss_percentile": 0.56397}, "CVE-2018-20351": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-20352": {"epss_score": 0.01266, "epss_percentile": 0.79009}, "CVE-2018-20353": {"epss_score": 0.02678, "epss_percentile": 0.85411}, "CVE-2018-20354": {"epss_score": 0.02678, "epss_percentile": 0.85411}, "CVE-2018-20355": {"epss_score": 0.02678, "epss_percentile": 0.85411}, "CVE-2018-20356": {"epss_score": 0.02678, "epss_percentile": 0.85411}, "CVE-2018-20357": {"epss_score": 0.00323, "epss_percentile": 0.54908}, "CVE-2018-20358": {"epss_score": 0.00323, "epss_percentile": 0.54908}, "CVE-2018-20359": {"epss_score": 0.00323, "epss_percentile": 0.54908}, "CVE-2018-20360": {"epss_score": 0.005, "epss_percentile": 0.65313}, "CVE-2018-20361": {"epss_score": 0.00338, "epss_percentile": 0.56126}, "CVE-2018-20362": {"epss_score": 0.00344, "epss_percentile": 0.56493}, "CVE-2018-20363": {"epss_score": 0.0049, "epss_percentile": 0.64935}, "CVE-2018-20364": {"epss_score": 0.00493, "epss_percentile": 0.65052}, "CVE-2018-20365": {"epss_score": 0.00445, "epss_percentile": 0.62882}, "CVE-2018-20367": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-20368": {"epss_score": 0.0027, "epss_percentile": 0.50213}, "CVE-2018-20369": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-20370": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20371": {"epss_score": 0.00368, "epss_percentile": 0.58217}, "CVE-2018-20372": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20373": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20374": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-20375": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-20376": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-20377": {"epss_score": 0.37122, "epss_percentile": 0.97021}, "CVE-2018-20378": {"epss_score": 0.00698, "epss_percentile": 0.71419}, "CVE-2018-20379": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20380": {"epss_score": 0.00629, "epss_percentile": 0.69668}, "CVE-2018-20381": {"epss_score": 0.00629, "epss_percentile": 0.69668}, "CVE-2018-20382": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20383": {"epss_score": 0.00821, "epss_percentile": 0.73896}, "CVE-2018-20384": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20385": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20386": {"epss_score": 0.00821, "epss_percentile": 0.73896}, "CVE-2018-20387": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20388": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20389": {"epss_score": 0.01378, "epss_percentile": 0.79848}, "CVE-2018-20390": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20391": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20392": {"epss_score": 0.00618, "epss_percentile": 0.69365}, "CVE-2018-20393": {"epss_score": 0.00629, "epss_percentile": 0.69668}, "CVE-2018-20394": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20395": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20396": {"epss_score": 0.00821, "epss_percentile": 0.73896}, "CVE-2018-20397": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20398": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20399": {"epss_score": 0.03366, "epss_percentile": 0.87003}, "CVE-2018-20400": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20401": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2018-20402": {"epss_score": 0.00485, "epss_percentile": 0.64712}, "CVE-2018-20404": {"epss_score": 0.00316, "epss_percentile": 0.54219}, "CVE-2018-20405": {"epss_score": 0.00196, "epss_percentile": 0.41803}, "CVE-2018-20406": {"epss_score": 0.02005, "epss_percentile": 0.8323}, "CVE-2018-20407": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2018-20408": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2018-20409": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2018-20410": {"epss_score": 0.01069, "epss_percentile": 0.77245}, "CVE-2018-20418": {"epss_score": 0.00471, "epss_percentile": 0.64006}, "CVE-2018-20419": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2018-20420": {"epss_score": 0.00202, "epss_percentile": 0.42463}, "CVE-2018-20421": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-20422": {"epss_score": 0.00284, "epss_percentile": 0.51486}, "CVE-2018-20423": {"epss_score": 0.00297, "epss_percentile": 0.52693}, "CVE-2018-20424": {"epss_score": 0.00156, "epss_percentile": 0.36985}, "CVE-2018-20425": {"epss_score": 0.0034, "epss_percentile": 0.56258}, "CVE-2018-20426": {"epss_score": 0.0034, "epss_percentile": 0.56258}, "CVE-2018-20427": {"epss_score": 0.00261, "epss_percentile": 0.49261}, "CVE-2018-20428": {"epss_score": 0.0034, "epss_percentile": 0.56258}, "CVE-2018-20429": {"epss_score": 0.0034, "epss_percentile": 0.56258}, "CVE-2018-20430": {"epss_score": 0.0057, "epss_percentile": 0.67958}, "CVE-2018-20431": {"epss_score": 0.00572, "epss_percentile": 0.6802}, "CVE-2018-20432": {"epss_score": 0.16527, "epss_percentile": 0.94686}, "CVE-2018-20433": {"epss_score": 0.02404, "epss_percentile": 0.84646}, "CVE-2018-20434": {"epss_score": 0.66987, "epss_percentile": 0.98489}, "CVE-2018-20436": {"epss_score": 0.00482, "epss_percentile": 0.6454}, "CVE-2018-20437": {"epss_score": 0.00502, "epss_percentile": 0.65377}, "CVE-2018-20438": {"epss_score": 0.00475, "epss_percentile": 0.64201}, "CVE-2018-20439": {"epss_score": 0.00372, "epss_percentile": 0.58442}, "CVE-2018-20440": {"epss_score": 0.00475, "epss_percentile": 0.64201}, "CVE-2018-20441": {"epss_score": 0.00475, "epss_percentile": 0.64201}, "CVE-2018-20442": {"epss_score": 0.00475, "epss_percentile": 0.64201}, "CVE-2018-20443": {"epss_score": 0.00475, "epss_percentile": 0.64201}, "CVE-2018-20444": {"epss_score": 0.00372, "epss_percentile": 0.58442}, "CVE-2018-20445": {"epss_score": 0.00548, "epss_percentile": 0.67268}, "CVE-2018-20448": {"epss_score": 0.00188, "epss_percentile": 0.40879}, "CVE-2018-20449": {"epss_score": 0.00071, "epss_percentile": 0.22018}, "CVE-2018-20450": {"epss_score": 0.00257, "epss_percentile": 0.48943}, "CVE-2018-20451": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2018-20452": {"epss_score": 0.00402, "epss_percentile": 0.60281}, "CVE-2018-20453": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2018-20454": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20455": {"epss_score": 0.00178, "epss_percentile": 0.39693}, "CVE-2018-20456": {"epss_score": 0.0018, "epss_percentile": 0.39991}, "CVE-2018-20457": {"epss_score": 0.00164, "epss_percentile": 0.3795}, "CVE-2018-20458": {"epss_score": 0.00179, "epss_percentile": 0.39853}, "CVE-2018-20459": {"epss_score": 0.00179, "epss_percentile": 0.39853}, "CVE-2018-20460": {"epss_score": 0.00191, "epss_percentile": 0.41254}, "CVE-2018-20461": {"epss_score": 0.00178, "epss_percentile": 0.39744}, "CVE-2018-20462": {"epss_score": 0.01584, "epss_percentile": 0.81159}, "CVE-2018-20463": {"epss_score": 0.7612, "epss_percentile": 0.98879}, "CVE-2018-20464": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20465": {"epss_score": 0.00664, "epss_percentile": 0.7063}, "CVE-2018-20467": {"epss_score": 0.00374, "epss_percentile": 0.58562}, "CVE-2018-20468": {"epss_score": 0.00376, "epss_percentile": 0.58649}, "CVE-2018-20469": {"epss_score": 0.11603, "epss_percentile": 0.93417}, "CVE-2018-20470": {"epss_score": 0.90404, "epss_percentile": 0.99581}, "CVE-2018-20472": {"epss_score": 0.00306, "epss_percentile": 0.53455}, "CVE-2018-20476": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20477": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-20478": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-20479": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-20480": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-20481": {"epss_score": 0.0119, "epss_percentile": 0.78381}, "CVE-2018-20482": {"epss_score": 0.0002, "epss_percentile": 0.04608}, "CVE-2018-20483": {"epss_score": 0.00055, "epss_percentile": 0.1756}, "CVE-2018-20484": {"epss_score": 0.017, "epss_percentile": 0.81828}, "CVE-2018-20485": {"epss_score": 0.017, "epss_percentile": 0.81828}, "CVE-2018-20486": {"epss_score": 0.0028, "epss_percentile": 0.51042}, "CVE-2018-20487": {"epss_score": 0.00681, "epss_percentile": 0.71055}, "CVE-2018-20488": {"epss_score": 0.00106, "epss_percentile": 0.294}, "CVE-2018-20489": {"epss_score": 0.001, "epss_percentile": 0.28443}, "CVE-2018-20490": {"epss_score": 0.00122, "epss_percentile": 0.32127}, "CVE-2018-20491": {"epss_score": 0.00122, "epss_percentile": 0.32127}, "CVE-2018-20492": {"epss_score": 0.00114, "epss_percentile": 0.30854}, "CVE-2018-20493": {"epss_score": 0.00112, "epss_percentile": 0.30565}, "CVE-2018-20494": {"epss_score": 0.00334, "epss_percentile": 0.55739}, "CVE-2018-20495": {"epss_score": 0.00115, "epss_percentile": 0.30953}, "CVE-2018-20496": {"epss_score": 0.00122, "epss_percentile": 0.32127}, "CVE-2018-20497": {"epss_score": 0.00094, "epss_percentile": 0.27012}, "CVE-2018-20498": {"epss_score": 0.00103, "epss_percentile": 0.2901}, "CVE-2018-20499": {"epss_score": 0.001, "epss_percentile": 0.28443}, "CVE-2018-20500": {"epss_score": 0.00095, "epss_percentile": 0.27232}, "CVE-2018-20501": {"epss_score": 0.00119, "epss_percentile": 0.31611}, "CVE-2018-20502": {"epss_score": 0.00257, "epss_percentile": 0.48943}, "CVE-2018-20503": {"epss_score": 0.02807, "epss_percentile": 0.8571}, "CVE-2018-20505": {"epss_score": 0.08887, "epss_percentile": 0.92301}, "CVE-2018-20506": {"epss_score": 0.0864, "epss_percentile": 0.92168}, "CVE-2018-20507": {"epss_score": 0.00114, "epss_percentile": 0.30873}, "CVE-2018-20508": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-20509": {"epss_score": 0.00057, "epss_percentile": 0.18232}, "CVE-2018-20510": {"epss_score": 0.00056, "epss_percentile": 0.17949}, "CVE-2018-20511": {"epss_score": 0.00072, "epss_percentile": 0.22437}, "CVE-2018-20512": {"epss_score": 0.00715, "epss_percentile": 0.71849}, "CVE-2018-20519": {"epss_score": 0.00183, "epss_percentile": 0.40308}, "CVE-2018-20520": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20523": {"epss_score": 0.06192, "epss_percentile": 0.9055}, "CVE-2018-20524": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20525": {"epss_score": 0.32535, "epss_percentile": 0.96707}, "CVE-2018-20526": {"epss_score": 0.8767, "epss_percentile": 0.99437}, "CVE-2018-20528": {"epss_score": 0.00207, "epss_percentile": 0.43112}, "CVE-2018-20530": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20532": {"epss_score": 0.00499, "epss_percentile": 0.65276}, "CVE-2018-20533": {"epss_score": 0.00547, "epss_percentile": 0.67233}, "CVE-2018-20534": {"epss_score": 0.00912, "epss_percentile": 0.75359}, "CVE-2018-20535": {"epss_score": 0.00131, "epss_percentile": 0.33374}, "CVE-2018-20536": {"epss_score": 0.00269, "epss_percentile": 0.50152}, "CVE-2018-20537": {"epss_score": 0.0027, "epss_percentile": 0.50218}, "CVE-2018-20538": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2018-20539": {"epss_score": 0.00269, "epss_percentile": 0.50152}, "CVE-2018-20540": {"epss_score": 0.00269, "epss_percentile": 0.50116}, "CVE-2018-20541": {"epss_score": 0.00471, "epss_percentile": 0.63997}, "CVE-2018-20542": {"epss_score": 0.00455, "epss_percentile": 0.63314}, "CVE-2018-20543": {"epss_score": 0.0026, "epss_percentile": 0.49231}, "CVE-2018-20544": {"epss_score": 0.00979, "epss_percentile": 0.7626}, "CVE-2018-20545": {"epss_score": 0.01633, "epss_percentile": 0.81464}, "CVE-2018-20546": {"epss_score": 0.02273, "epss_percentile": 0.84221}, "CVE-2018-20547": {"epss_score": 0.0086, "epss_percentile": 0.74541}, "CVE-2018-20548": {"epss_score": 0.00617, "epss_percentile": 0.69343}, "CVE-2018-20549": {"epss_score": 0.00793, "epss_percentile": 0.73423}, "CVE-2018-20551": {"epss_score": 0.00309, "epss_percentile": 0.53697}, "CVE-2018-20552": {"epss_score": 0.00213, "epss_percentile": 0.43944}, "CVE-2018-20553": {"epss_score": 0.00204, "epss_percentile": 0.4265}, "CVE-2018-20555": {"epss_score": 0.46217, "epss_percentile": 0.97537}, "CVE-2018-20556": {"epss_score": 0.14445, "epss_percentile": 0.94213}, "CVE-2018-20557": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20558": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20559": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20560": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20561": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20562": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20563": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20564": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20565": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20566": {"epss_score": 0.00366, "epss_percentile": 0.58091}, "CVE-2018-20567": {"epss_score": 0.00269, "epss_percentile": 0.50172}, "CVE-2018-20568": {"epss_score": 0.0073, "epss_percentile": 0.72143}, "CVE-2018-20569": {"epss_score": 0.0073, "epss_percentile": 0.72143}, "CVE-2018-20570": {"epss_score": 0.00967, "epss_percentile": 0.76066}, "CVE-2018-20571": {"epss_score": 0.00333, "epss_percentile": 0.55617}, "CVE-2018-20572": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-20573": {"epss_score": 0.00682, "epss_percentile": 0.71087}, "CVE-2018-20574": {"epss_score": 0.00682, "epss_percentile": 0.71087}, "CVE-2018-20575": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-20576": {"epss_score": 0.00112, "epss_percentile": 0.30432}, "CVE-2018-20577": {"epss_score": 0.00139, "epss_percentile": 0.34656}, "CVE-2018-20578": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-20579": {"epss_score": 0.00057, "epss_percentile": 0.181}, "CVE-2018-20580": {"epss_score": 0.30875, "epss_percentile": 0.96573}, "CVE-2018-20582": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-20583": {"epss_score": 0.0031, "epss_percentile": 0.53772}, "CVE-2018-20584": {"epss_score": 0.0042, "epss_percentile": 0.61425}, "CVE-2018-20586": {"epss_score": 0.00353, "epss_percentile": 0.57171}, "CVE-2018-20587": {"epss_score": 0.00048, "epss_percentile": 0.15098}, "CVE-2018-20588": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2018-20589": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20590": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20591": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2018-20592": {"epss_score": 0.00336, "epss_percentile": 0.55936}, "CVE-2018-20593": {"epss_score": 0.00237, "epss_percentile": 0.46463}, "CVE-2018-20594": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-20595": {"epss_score": 0.00081, "epss_percentile": 0.24225}, "CVE-2018-20596": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2018-20597": {"epss_score": 0.00215, "epss_percentile": 0.44051}, "CVE-2018-20598": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-20599": {"epss_score": 0.00873, "epss_percentile": 0.74745}, "CVE-2018-20600": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20601": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20602": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-20603": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-20604": {"epss_score": 0.00554, "epss_percentile": 0.67449}, "CVE-2018-20605": {"epss_score": 0.00994, "epss_percentile": 0.76426}, "CVE-2018-20606": {"epss_score": 0.07033, "epss_percentile": 0.91202}, "CVE-2018-20607": {"epss_score": 0.03433, "epss_percentile": 0.87127}, "CVE-2018-20608": {"epss_score": 0.63562, "epss_percentile": 0.98337}, "CVE-2018-20609": {"epss_score": 0.03433, "epss_percentile": 0.87127}, "CVE-2018-20610": {"epss_score": 0.01074, "epss_percentile": 0.77296}, "CVE-2018-20611": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-20612": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-20613": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-20614": {"epss_score": 0.0065, "epss_percentile": 0.70268}, "CVE-2018-20615": {"epss_score": 0.00172, "epss_percentile": 0.38985}, "CVE-2018-20616": {"epss_score": 0.0042, "epss_percentile": 0.61459}, "CVE-2018-20617": {"epss_score": 0.0042, "epss_percentile": 0.61459}, "CVE-2018-20618": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2018-20621": {"epss_score": 0.00555, "epss_percentile": 0.67472}, "CVE-2018-20622": {"epss_score": 0.01291, "epss_percentile": 0.79223}, "CVE-2018-20623": {"epss_score": 0.00324, "epss_percentile": 0.54929}, "CVE-2018-20626": {"epss_score": 0.00494, "epss_percentile": 0.65077}, "CVE-2018-20627": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20628": {"epss_score": 0.00571, "epss_percentile": 0.67991}, "CVE-2018-20629": {"epss_score": 0.00195, "epss_percentile": 0.41637}, "CVE-2018-20630": {"epss_score": 0.00315, "epss_percentile": 0.54189}, "CVE-2018-20631": {"epss_score": 0.00366, "epss_percentile": 0.58091}, "CVE-2018-20632": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20633": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-20634": {"epss_score": 0.00539, "epss_percentile": 0.66974}, "CVE-2018-20635": {"epss_score": 0.00167, "epss_percentile": 0.38343}, "CVE-2018-20636": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20637": {"epss_score": 0.00516, "epss_percentile": 0.66056}, "CVE-2018-20638": {"epss_score": 0.00355, "epss_percentile": 0.57317}, "CVE-2018-20639": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20640": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20641": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-20642": {"epss_score": 0.00539, "epss_percentile": 0.66974}, "CVE-2018-20643": {"epss_score": 0.00494, "epss_percentile": 0.65077}, "CVE-2018-20644": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2018-20645": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20646": {"epss_score": 0.00494, "epss_percentile": 0.65077}, "CVE-2018-20647": {"epss_score": 0.00494, "epss_percentile": 0.65077}, "CVE-2018-20648": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-20650": {"epss_score": 0.00355, "epss_percentile": 0.57266}, "CVE-2018-20651": {"epss_score": 0.0076, "epss_percentile": 0.72805}, "CVE-2018-20652": {"epss_score": 0.00421, "epss_percentile": 0.61486}, "CVE-2018-20655": {"epss_score": 0.0054, "epss_percentile": 0.67008}, "CVE-2018-20657": {"epss_score": 0.0026, "epss_percentile": 0.49235}, "CVE-2018-20658": {"epss_score": 0.19818, "epss_percentile": 0.95246}, "CVE-2018-20659": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2018-20662": {"epss_score": 0.0059, "epss_percentile": 0.68573}, "CVE-2018-20663": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20664": {"epss_score": 0.03906, "epss_percentile": 0.87928}, "CVE-2018-20669": {"epss_score": 0.00086, "epss_percentile": 0.25405}, "CVE-2018-20671": {"epss_score": 0.0011, "epss_percentile": 0.30154}, "CVE-2018-20673": {"epss_score": 0.00119, "epss_percentile": 0.31654}, "CVE-2018-20674": {"epss_score": 0.00586, "epss_percentile": 0.68433}, "CVE-2018-20675": {"epss_score": 0.00421, "epss_percentile": 0.61513}, "CVE-2018-20676": {"epss_score": 0.06144, "epss_percentile": 0.90516}, "CVE-2018-20677": {"epss_score": 0.11866, "epss_percentile": 0.935}, "CVE-2018-20678": {"epss_score": 0.00014, "epss_percentile": 0.01833}, "CVE-2018-20679": {"epss_score": 0.09589, "epss_percentile": 0.92611}, "CVE-2018-20680": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-20681": {"epss_score": 0.0016, "epss_percentile": 0.37443}, "CVE-2018-20682": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20683": {"epss_score": 0.00484, "epss_percentile": 0.64635}, "CVE-2018-20684": {"epss_score": 0.0057, "epss_percentile": 0.67941}, "CVE-2018-20685": {"epss_score": 0.03377, "epss_percentile": 0.87024}, "CVE-2018-20687": {"epss_score": 0.0159, "epss_percentile": 0.81201}, "CVE-2018-20698": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2018-20699": {"epss_score": 0.00163, "epss_percentile": 0.37844}, "CVE-2018-20703": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20712": {"epss_score": 0.0101, "epss_percentile": 0.76605}, "CVE-2018-20713": {"epss_score": 0.0062, "epss_percentile": 0.69454}, "CVE-2018-20714": {"epss_score": 0.01392, "epss_percentile": 0.79958}, "CVE-2018-20715": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-20716": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2018-20717": {"epss_score": 0.02992, "epss_percentile": 0.86146}, "CVE-2018-20718": {"epss_score": 0.09386, "epss_percentile": 0.92528}, "CVE-2018-20719": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2018-20720": {"epss_score": 0.01073, "epss_percentile": 0.77288}, "CVE-2018-20721": {"epss_score": 0.00513, "epss_percentile": 0.65938}, "CVE-2018-20723": {"epss_score": 0.00496, "epss_percentile": 0.65166}, "CVE-2018-20724": {"epss_score": 0.00583, "epss_percentile": 0.68333}, "CVE-2018-20725": {"epss_score": 0.00496, "epss_percentile": 0.65166}, "CVE-2018-20726": {"epss_score": 0.0051, "epss_percentile": 0.65796}, "CVE-2018-20727": {"epss_score": 0.03953, "epss_percentile": 0.88002}, "CVE-2018-20728": {"epss_score": 0.00215, "epss_percentile": 0.4406}, "CVE-2018-20729": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2018-20730": {"epss_score": 0.00289, "epss_percentile": 0.52}, "CVE-2018-20731": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2018-20732": {"epss_score": 0.04279, "epss_percentile": 0.88487}, "CVE-2018-20733": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2018-20735": {"epss_score": 0.38007, "epss_percentile": 0.97082}, "CVE-2018-20736": {"epss_score": 0.00312, "epss_percentile": 0.53987}, "CVE-2018-20737": {"epss_score": 0.00318, "epss_percentile": 0.54445}, "CVE-2018-20742": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-20743": {"epss_score": 0.07129, "epss_percentile": 0.91269}, "CVE-2018-20744": {"epss_score": 0.00146, "epss_percentile": 0.3558}, "CVE-2018-20745": {"epss_score": 0.00118, "epss_percentile": 0.31439}, "CVE-2018-20748": {"epss_score": 0.10572, "epss_percentile": 0.93031}, "CVE-2018-20749": {"epss_score": 0.10369, "epss_percentile": 0.92962}, "CVE-2018-20750": {"epss_score": 0.10369, "epss_percentile": 0.92962}, "CVE-2018-20751": {"epss_score": 0.00437, "epss_percentile": 0.62488}, "CVE-2018-20752": {"epss_score": 0.02918, "epss_percentile": 0.85986}, "CVE-2018-20753": {"epss_score": 0.44443, "epss_percentile": 0.97437}, "CVE-2018-20755": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20756": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20757": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20758": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20760": {"epss_score": 0.00273, "epss_percentile": 0.50441}, "CVE-2018-20761": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2018-20762": {"epss_score": 0.00233, "epss_percentile": 0.45995}, "CVE-2018-20763": {"epss_score": 0.00273, "epss_percentile": 0.50441}, "CVE-2018-20764": {"epss_score": 0.00543, "epss_percentile": 0.67119}, "CVE-2018-20767": {"epss_score": 0.01685, "epss_percentile": 0.81749}, "CVE-2018-20768": {"epss_score": 0.00638, "epss_percentile": 0.69902}, "CVE-2018-20769": {"epss_score": 0.0038, "epss_percentile": 0.58952}, "CVE-2018-20770": {"epss_score": 0.00348, "epss_percentile": 0.56834}, "CVE-2018-20771": {"epss_score": 0.0212, "epss_percentile": 0.83673}, "CVE-2018-20772": {"epss_score": 0.01114, "epss_percentile": 0.77694}, "CVE-2018-20773": {"epss_score": 0.01114, "epss_percentile": 0.77694}, "CVE-2018-20774": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20775": {"epss_score": 0.01114, "epss_percentile": 0.77694}, "CVE-2018-20776": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-20777": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-20778": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20779": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2018-20780": {"epss_score": 0.00138, "epss_percentile": 0.34426}, "CVE-2018-20781": {"epss_score": 0.05441, "epss_percentile": 0.89884}, "CVE-2018-20782": {"epss_score": 0.14672, "epss_percentile": 0.94261}, "CVE-2018-20783": {"epss_score": 0.06535, "epss_percentile": 0.90827}, "CVE-2018-20784": {"epss_score": 0.00716, "epss_percentile": 0.71866}, "CVE-2018-20785": {"epss_score": 0.00077, "epss_percentile": 0.23305}, "CVE-2018-20786": {"epss_score": 0.00334, "epss_percentile": 0.55734}, "CVE-2018-20787": {"epss_score": 0.00149, "epss_percentile": 0.35982}, "CVE-2018-20788": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2018-20789": {"epss_score": 0.00634, "epss_percentile": 0.6979}, "CVE-2018-20790": {"epss_score": 0.00634, "epss_percentile": 0.6979}, "CVE-2018-20791": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-20792": {"epss_score": 0.00938, "epss_percentile": 0.75705}, "CVE-2018-20793": {"epss_score": 0.01378, "epss_percentile": 0.79846}, "CVE-2018-20794": {"epss_score": 0.0061, "epss_percentile": 0.69143}, "CVE-2018-20795": {"epss_score": 0.00938, "epss_percentile": 0.75705}, "CVE-2018-20796": {"epss_score": 0.01669, "epss_percentile": 0.81666}, "CVE-2018-20797": {"epss_score": 0.00138, "epss_percentile": 0.34375}, "CVE-2018-20798": {"epss_score": 0.00167, "epss_percentile": 0.38376}, "CVE-2018-20799": {"epss_score": 0.00227, "epss_percentile": 0.45406}, "CVE-2018-20800": {"epss_score": 0.00231, "epss_percentile": 0.45849}, "CVE-2018-20801": {"epss_score": 0.01296, "epss_percentile": 0.79259}, "CVE-2018-20802": {"epss_score": 0.00426, "epss_percentile": 0.61758}, "CVE-2018-20803": {"epss_score": 0.00426, "epss_percentile": 0.61758}, "CVE-2018-20804": {"epss_score": 0.00426, "epss_percentile": 0.61758}, "CVE-2018-20805": {"epss_score": 0.00426, "epss_percentile": 0.61758}, "CVE-2018-20806": {"epss_score": 0.0024, "epss_percentile": 0.46957}, "CVE-2018-20807": {"epss_score": 0.0012, "epss_percentile": 0.31689}, "CVE-2018-20808": {"epss_score": 0.0012, "epss_percentile": 0.31689}, "CVE-2018-20809": {"epss_score": 0.03312, "epss_percentile": 0.86895}, "CVE-2018-20810": {"epss_score": 0.01536, "epss_percentile": 0.80913}, "CVE-2018-20811": {"epss_score": 0.00714, "epss_percentile": 0.7183}, "CVE-2018-20812": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2018-20813": {"epss_score": 0.03845, "epss_percentile": 0.87841}, "CVE-2018-20814": {"epss_score": 0.00105, "epss_percentile": 0.29392}, "CVE-2018-20815": {"epss_score": 0.03933, "epss_percentile": 0.87978}, "CVE-2018-20816": {"epss_score": 0.00156, "epss_percentile": 0.37002}, "CVE-2018-20817": {"epss_score": 0.02359, "epss_percentile": 0.84491}, "CVE-2018-20818": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2018-20819": {"epss_score": 0.00219, "epss_percentile": 0.44497}, "CVE-2018-20820": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2018-20821": {"epss_score": 0.00322, "epss_percentile": 0.5479}, "CVE-2018-20822": {"epss_score": 0.00521, "epss_percentile": 0.66234}, "CVE-2018-20823": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2018-20824": {"epss_score": 0.46419, "epss_percentile": 0.97545}, "CVE-2018-20826": {"epss_score": 0.00135, "epss_percentile": 0.33936}, "CVE-2018-20827": {"epss_score": 0.00175, "epss_percentile": 0.39367}, "CVE-2018-20834": {"epss_score": 0.00417, "epss_percentile": 0.61245}, "CVE-2018-20835": {"epss_score": 0.00288, "epss_percentile": 0.5195}, "CVE-2018-20836": {"epss_score": 0.03963, "epss_percentile": 0.88016}, "CVE-2018-20837": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-20838": {"epss_score": 0.00316, "epss_percentile": 0.54228}, "CVE-2018-20839": {"epss_score": 0.00668, "epss_percentile": 0.70726}, "CVE-2018-20840": {"epss_score": 0.00222, "epss_percentile": 0.44767}, "CVE-2018-20841": {"epss_score": 0.41926, "epss_percentile": 0.97301}, "CVE-2018-20843": {"epss_score": 0.05826, "epss_percentile": 0.90239}, "CVE-2018-20845": {"epss_score": 0.00609, "epss_percentile": 0.69125}, "CVE-2018-20846": {"epss_score": 0.00456, "epss_percentile": 0.63318}, "CVE-2018-20847": {"epss_score": 0.00738, "epss_percentile": 0.72344}, "CVE-2018-20848": {"epss_score": 0.00139, "epss_percentile": 0.34605}, "CVE-2018-20849": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2018-20850": {"epss_score": 0.00129, "epss_percentile": 0.33158}, "CVE-2018-20851": {"epss_score": 0.00401, "epss_percentile": 0.6026}, "CVE-2018-20852": {"epss_score": 0.01697, "epss_percentile": 0.81817}, "CVE-2018-20853": {"epss_score": 0.00282, "epss_percentile": 0.51266}, "CVE-2018-20854": {"epss_score": 0.00074, "epss_percentile": 0.22821}, "CVE-2018-20855": {"epss_score": 0.00109, "epss_percentile": 0.30041}, "CVE-2018-20856": {"epss_score": 0.00095, "epss_percentile": 0.27119}, "CVE-2018-20857": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-20858": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-20859": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2018-20860": {"epss_score": 0.00341, "epss_percentile": 0.56286}, "CVE-2018-20861": {"epss_score": 0.00411, "epss_percentile": 0.60882}, "CVE-2018-20862": {"epss_score": 0.0006, "epss_percentile": 0.19164}, "CVE-2018-20863": {"epss_score": 0.03015, "epss_percentile": 0.86211}, "CVE-2018-20864": {"epss_score": 0.00448, "epss_percentile": 0.63008}, "CVE-2018-20865": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2018-20866": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2018-20867": {"epss_score": 0.00211, "epss_percentile": 0.43704}, "CVE-2018-20868": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2018-20869": {"epss_score": 0.00065, "epss_percentile": 0.20568}, "CVE-2018-20870": {"epss_score": 0.00082, "epss_percentile": 0.24563}, "CVE-2018-20871": {"epss_score": 0.00308, "epss_percentile": 0.53642}, "CVE-2018-20872": {"epss_score": 0.00117, "epss_percentile": 0.31326}, "CVE-2018-20873": {"epss_score": 0.00044, "epss_percentile": 0.13462}, "CVE-2018-20874": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2018-20875": {"epss_score": 0.00221, "epss_percentile": 0.44666}, "CVE-2018-20876": {"epss_score": 0.00221, "epss_percentile": 0.44666}, "CVE-2018-20877": {"epss_score": 0.00221, "epss_percentile": 0.44666}, "CVE-2018-20878": {"epss_score": 0.00221, "epss_percentile": 0.44666}, "CVE-2018-20879": {"epss_score": 0.00711, "epss_percentile": 0.71734}, "CVE-2018-20880": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2018-20881": {"epss_score": 0.00221, "epss_percentile": 0.44666}, "CVE-2018-20882": {"epss_score": 0.00056, "epss_percentile": 0.17961}, "CVE-2018-20883": {"epss_score": 0.00277, "epss_percentile": 0.50792}, "CVE-2018-20884": {"epss_score": 0.00221, "epss_percentile": 0.44666}, "CVE-2018-20885": {"epss_score": 0.00464, "epss_percentile": 0.63718}, "CVE-2018-20886": {"epss_score": 0.00067, "epss_percentile": 0.21095}, "CVE-2018-20887": {"epss_score": 0.00379, "epss_percentile": 0.58839}, "CVE-2018-20888": {"epss_score": 0.00072, "epss_percentile": 0.22397}, "CVE-2018-20889": {"epss_score": 0.00065, "epss_percentile": 0.20444}, "CVE-2018-20890": {"epss_score": 0.00144, "epss_percentile": 0.35289}, "CVE-2018-20891": {"epss_score": 0.00074, "epss_percentile": 0.22697}, "CVE-2018-20892": {"epss_score": 0.00219, "epss_percentile": 0.44515}, "CVE-2018-20893": {"epss_score": 0.0008, "epss_percentile": 0.24153}, "CVE-2018-20894": {"epss_score": 0.00044, "epss_percentile": 0.13383}, "CVE-2018-20895": {"epss_score": 0.00497, "epss_percentile": 0.65202}, "CVE-2018-20896": {"epss_score": 0.00196, "epss_percentile": 0.41815}, "CVE-2018-20897": {"epss_score": 0.00072, "epss_percentile": 0.22242}, "CVE-2018-20898": {"epss_score": 0.00272, "epss_percentile": 0.50349}, "CVE-2018-20899": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-20900": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-20901": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2018-20902": {"epss_score": 0.00082, "epss_percentile": 0.24563}, "CVE-2018-20903": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2018-20904": {"epss_score": 0.00144, "epss_percentile": 0.35289}, "CVE-2018-20905": {"epss_score": 0.00144, "epss_percentile": 0.35321}, "CVE-2018-20906": {"epss_score": 0.00144, "epss_percentile": 0.35289}, "CVE-2018-20907": {"epss_score": 0.00144, "epss_percentile": 0.35289}, "CVE-2018-20908": {"epss_score": 0.00063, "epss_percentile": 0.1996}, "CVE-2018-20909": {"epss_score": 0.00061, "epss_percentile": 0.19484}, "CVE-2018-20910": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2018-20911": {"epss_score": 0.01929, "epss_percentile": 0.82934}, "CVE-2018-20912": {"epss_score": 0.00914, "epss_percentile": 0.75384}, "CVE-2018-20913": {"epss_score": 0.00342, "epss_percentile": 0.56376}, "CVE-2018-20914": {"epss_score": 0.00493, "epss_percentile": 0.65025}, "CVE-2018-20915": {"epss_score": 0.00378, "epss_percentile": 0.58804}, "CVE-2018-20916": {"epss_score": 0.00378, "epss_percentile": 0.58804}, "CVE-2018-20917": {"epss_score": 0.00058, "epss_percentile": 0.18414}, "CVE-2018-20918": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2018-20919": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2018-20920": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2018-20921": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2018-20922": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2018-20923": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2018-20924": {"epss_score": 0.00214, "epss_percentile": 0.43951}, "CVE-2018-20925": {"epss_score": 0.00049, "epss_percentile": 0.15614}, "CVE-2018-20926": {"epss_score": 0.00044, "epss_percentile": 0.13463}, "CVE-2018-20927": {"epss_score": 0.00057, "epss_percentile": 0.18123}, "CVE-2018-20928": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2018-20929": {"epss_score": 0.00171, "epss_percentile": 0.38866}, "CVE-2018-20930": {"epss_score": 0.00186, "epss_percentile": 0.40659}, "CVE-2018-20931": {"epss_score": 0.00688, "epss_percentile": 0.71212}, "CVE-2018-20932": {"epss_score": 0.00232, "epss_percentile": 0.45936}, "CVE-2018-20933": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2018-20934": {"epss_score": 0.00314, "epss_percentile": 0.54143}, "CVE-2018-20935": {"epss_score": 0.0025, "epss_percentile": 0.4814}, "CVE-2018-20936": {"epss_score": 0.00057, "epss_percentile": 0.18123}, "CVE-2018-20937": {"epss_score": 0.00144, "epss_percentile": 0.35289}, "CVE-2018-20938": {"epss_score": 0.00187, "epss_percentile": 0.40775}, "CVE-2018-20939": {"epss_score": 0.00043, "epss_percentile": 0.12998}, "CVE-2018-20940": {"epss_score": 0.00033, "epss_percentile": 0.09307}, "CVE-2018-20941": {"epss_score": 0.00047, "epss_percentile": 0.14804}, "CVE-2018-20942": {"epss_score": 0.00066, "epss_percentile": 0.20963}, "CVE-2018-20943": {"epss_score": 0.00066, "epss_percentile": 0.20963}, "CVE-2018-20944": {"epss_score": 0.00043, "epss_percentile": 0.12998}, "CVE-2018-20945": {"epss_score": 0.00174, "epss_percentile": 0.39155}, "CVE-2018-20946": {"epss_score": 0.00043, "epss_percentile": 0.12998}, "CVE-2018-20947": {"epss_score": 0.00068, "epss_percentile": 0.21233}, "CVE-2018-20948": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2018-20949": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2018-20950": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2018-20951": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2018-20952": {"epss_score": 0.0031, "epss_percentile": 0.53787}, "CVE-2018-20953": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-20954": {"epss_score": 0.00214, "epss_percentile": 0.43952}, "CVE-2018-20955": {"epss_score": 0.01044, "epss_percentile": 0.77}, "CVE-2018-20956": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2018-20957": {"epss_score": 0.00139, "epss_percentile": 0.34566}, "CVE-2018-20958": {"epss_score": 0.00095, "epss_percentile": 0.27148}, "CVE-2018-20959": {"epss_score": 0.00095, "epss_percentile": 0.27184}, "CVE-2018-20960": {"epss_score": 0.00095, "epss_percentile": 0.27184}, "CVE-2018-20961": {"epss_score": 0.05773, "epss_percentile": 0.90196}, "CVE-2018-20962": {"epss_score": 0.00308, "epss_percentile": 0.53636}, "CVE-2018-20963": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-20964": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2018-20965": {"epss_score": 0.00345, "epss_percentile": 0.56555}, "CVE-2018-20966": {"epss_score": 0.07004, "epss_percentile": 0.91179}, "CVE-2018-20967": {"epss_score": 0.00169, "epss_percentile": 0.38611}, "CVE-2018-20968": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2018-20969": {"epss_score": 0.0041, "epss_percentile": 0.60837}, "CVE-2018-20970": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-20971": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2018-20972": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2018-20973": {"epss_score": 0.00763, "epss_percentile": 0.72856}, "CVE-2018-20974": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2018-20975": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2018-20976": {"epss_score": 0.00097, "epss_percentile": 0.27616}, "CVE-2018-20977": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-20978": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-20979": {"epss_score": 0.00337, "epss_percentile": 0.56015}, "CVE-2018-20980": {"epss_score": 0.00282, "epss_percentile": 0.51221}, "CVE-2018-20981": {"epss_score": 0.00596, "epss_percentile": 0.68718}, "CVE-2018-20982": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-20983": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-20984": {"epss_score": 0.00795, "epss_percentile": 0.73474}, "CVE-2018-20985": {"epss_score": 0.42918, "epss_percentile": 0.97362}, "CVE-2018-20986": {"epss_score": 0.00227, "epss_percentile": 0.45456}, "CVE-2018-20987": {"epss_score": 0.01077, "epss_percentile": 0.77339}, "CVE-2018-20988": {"epss_score": 0.00284, "epss_percentile": 0.51439}, "CVE-2018-20989": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-20990": {"epss_score": 0.00299, "epss_percentile": 0.52903}, "CVE-2018-20991": {"epss_score": 0.00425, "epss_percentile": 0.61703}, "CVE-2018-20992": {"epss_score": 0.00301, "epss_percentile": 0.5302}, "CVE-2018-20993": {"epss_score": 0.00361, "epss_percentile": 0.57697}, "CVE-2018-20994": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-20995": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-20996": {"epss_score": 0.00425, "epss_percentile": 0.61703}, "CVE-2018-20997": {"epss_score": 0.00499, "epss_percentile": 0.65247}, "CVE-2018-20998": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-20999": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-21000": {"epss_score": 0.00425, "epss_percentile": 0.61703}, "CVE-2018-21001": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-21002": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2018-21003": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2018-21004": {"epss_score": 0.00652, "epss_percentile": 0.70315}, "CVE-2018-21005": {"epss_score": 0.00994, "epss_percentile": 0.76419}, "CVE-2018-21006": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2018-21007": {"epss_score": 0.00706, "epss_percentile": 0.71605}, "CVE-2018-21008": {"epss_score": 0.00086, "epss_percentile": 0.2536}, "CVE-2018-21009": {"epss_score": 0.00355, "epss_percentile": 0.57258}, "CVE-2018-21010": {"epss_score": 0.00846, "epss_percentile": 0.74318}, "CVE-2018-21011": {"epss_score": 0.00747, "epss_percentile": 0.72562}, "CVE-2018-21012": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-21013": {"epss_score": 0.008, "epss_percentile": 0.73541}, "CVE-2018-21014": {"epss_score": 0.00197, "epss_percentile": 0.41908}, "CVE-2018-21015": {"epss_score": 0.00867, "epss_percentile": 0.74653}, "CVE-2018-21016": {"epss_score": 0.00513, "epss_percentile": 0.65897}, "CVE-2018-21017": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2018-21018": {"epss_score": 0.01641, "epss_percentile": 0.81502}, "CVE-2018-21019": {"epss_score": 0.01325, "epss_percentile": 0.79471}, "CVE-2018-21020": {"epss_score": 0.00081, "epss_percentile": 0.24323}, "CVE-2018-21021": {"epss_score": 0.00264, "epss_percentile": 0.49718}, "CVE-2018-21022": {"epss_score": 0.00264, "epss_percentile": 0.49718}, "CVE-2018-21023": {"epss_score": 0.01728, "epss_percentile": 0.81972}, "CVE-2018-21024": {"epss_score": 0.00302, "epss_percentile": 0.53118}, "CVE-2018-21025": {"epss_score": 0.00218, "epss_percentile": 0.44417}, "CVE-2018-21026": {"epss_score": 0.00467, "epss_percentile": 0.63845}, "CVE-2018-21027": {"epss_score": 0.00748, "epss_percentile": 0.72582}, "CVE-2018-21028": {"epss_score": 0.00578, "epss_percentile": 0.68183}, "CVE-2018-21029": {"epss_score": 0.0156, "epss_percentile": 0.81041}, "CVE-2018-21030": {"epss_score": 0.00368, "epss_percentile": 0.58194}, "CVE-2018-21031": {"epss_score": 0.00192, "epss_percentile": 0.41329}, "CVE-2018-21032": {"epss_score": 0.0021, "epss_percentile": 0.43472}, "CVE-2018-21033": {"epss_score": 0.00112, "epss_percentile": 0.30576}, "CVE-2018-21034": {"epss_score": 0.00884, "epss_percentile": 0.74926}, "CVE-2018-21035": {"epss_score": 0.00465, "epss_percentile": 0.63785}, "CVE-2018-21036": {"epss_score": 0.00714, "epss_percentile": 0.71813}, "CVE-2018-21037": {"epss_score": 0.00177, "epss_percentile": 0.39535}, "CVE-2018-21038": {"epss_score": 0.00156, "epss_percentile": 0.36892}, "CVE-2018-21039": {"epss_score": 0.00114, "epss_percentile": 0.30879}, "CVE-2018-21040": {"epss_score": 0.00134, "epss_percentile": 0.33792}, "CVE-2018-21041": {"epss_score": 0.00118, "epss_percentile": 0.31513}, "CVE-2018-21042": {"epss_score": 0.00164, "epss_percentile": 0.38005}, "CVE-2018-21043": {"epss_score": 0.00018, "epss_percentile": 0.03527}, "CVE-2018-21044": {"epss_score": 0.00222, "epss_percentile": 0.44756}, "CVE-2018-21045": {"epss_score": 0.0002, "epss_percentile": 0.04651}, "CVE-2018-21046": {"epss_score": 0.00019, "epss_percentile": 0.04194}, "CVE-2018-21047": {"epss_score": 0.00081, "epss_percentile": 0.24322}, "CVE-2018-21048": {"epss_score": 0.0002, "epss_percentile": 0.04651}, "CVE-2018-21049": {"epss_score": 0.0017, "epss_percentile": 0.38684}, "CVE-2018-21050": {"epss_score": 0.00231, "epss_percentile": 0.45794}, "CVE-2018-21051": {"epss_score": 0.00401, "epss_percentile": 0.60212}, "CVE-2018-21052": {"epss_score": 0.00195, "epss_percentile": 0.41614}, "CVE-2018-21053": {"epss_score": 0.0002, "epss_percentile": 0.04651}, "CVE-2018-21054": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2018-21055": {"epss_score": 0.00195, "epss_percentile": 0.41614}, "CVE-2018-21056": {"epss_score": 0.0002, "epss_percentile": 0.04651}, "CVE-2018-21057": {"epss_score": 0.00183, "epss_percentile": 0.40334}, "CVE-2018-21058": {"epss_score": 0.0008, "epss_percentile": 0.24017}, "CVE-2018-21059": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2018-21060": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2018-21061": {"epss_score": 0.00017, "epss_percentile": 0.03173}, "CVE-2018-21062": {"epss_score": 0.00022, "epss_percentile": 0.04983}, "CVE-2018-21063": {"epss_score": 0.0017, "epss_percentile": 0.38684}, "CVE-2018-21064": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2018-21065": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2018-21066": {"epss_score": 0.00183, "epss_percentile": 0.40334}, "CVE-2018-21067": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2018-21068": {"epss_score": 0.00018, "epss_percentile": 0.03765}, "CVE-2018-21069": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2018-21070": {"epss_score": 7e-05, "epss_percentile": 0.00378}, "CVE-2018-21071": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2018-21072": {"epss_score": 0.00195, "epss_percentile": 0.41614}, "CVE-2018-21073": {"epss_score": 0.00018, "epss_percentile": 0.04025}, "CVE-2018-21074": {"epss_score": 0.00018, "epss_percentile": 0.03527}, "CVE-2018-21075": {"epss_score": 0.00187, "epss_percentile": 0.40754}, "CVE-2018-21076": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2018-21077": {"epss_score": 0.00018, "epss_percentile": 0.04025}, "CVE-2018-21078": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2018-21079": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2018-21080": {"epss_score": 0.00011, "epss_percentile": 0.01056}, "CVE-2018-21081": {"epss_score": 0.00079, "epss_percentile": 0.23994}, "CVE-2018-21082": {"epss_score": 0.00017, "epss_percentile": 0.03173}, "CVE-2018-21083": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2018-21084": {"epss_score": 0.00114, "epss_percentile": 0.308}, "CVE-2018-21085": {"epss_score": 0.00134, "epss_percentile": 0.33792}, "CVE-2018-21086": {"epss_score": 0.00114, "epss_percentile": 0.308}, "CVE-2018-21087": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2018-21088": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2018-21089": {"epss_score": 0.00195, "epss_percentile": 0.41614}, "CVE-2018-21090": {"epss_score": 0.00195, "epss_percentile": 0.41635}, "CVE-2018-21091": {"epss_score": 0.00188, "epss_percentile": 0.40835}, "CVE-2018-21092": {"epss_score": 0.00066, "epss_percentile": 0.20842}, "CVE-2018-21093": {"epss_score": 0.00089, "epss_percentile": 0.25884}, "CVE-2018-21094": {"epss_score": 0.00349, "epss_percentile": 0.56889}, "CVE-2018-21095": {"epss_score": 0.00068, "epss_percentile": 0.21307}, "CVE-2018-21096": {"epss_score": 0.00105, "epss_percentile": 0.29273}, "CVE-2018-21097": {"epss_score": 0.00385, "epss_percentile": 0.59219}, "CVE-2018-21098": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2018-21099": {"epss_score": 0.00347, "epss_percentile": 0.56749}, "CVE-2018-21100": {"epss_score": 0.00174, "epss_percentile": 0.39137}, "CVE-2018-21101": {"epss_score": 0.00183, "epss_percentile": 0.4028}, "CVE-2018-21102": {"epss_score": 0.0021, "epss_percentile": 0.43452}, "CVE-2018-21103": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2018-21104": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2018-21105": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2018-21106": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2018-21107": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2018-21108": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2018-21109": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2018-21110": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2018-21111": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2018-21112": {"epss_score": 0.00182, "epss_percentile": 0.40183}, "CVE-2018-21113": {"epss_score": 0.00194, "epss_percentile": 0.41546}, "CVE-2018-21114": {"epss_score": 0.00136, "epss_percentile": 0.34088}, "CVE-2018-21115": {"epss_score": 0.00297, "epss_percentile": 0.5275}, "CVE-2018-21116": {"epss_score": 0.00297, "epss_percentile": 0.5275}, "CVE-2018-21117": {"epss_score": 0.00239, "epss_percentile": 0.46916}, "CVE-2018-21118": {"epss_score": 0.00122, "epss_percentile": 0.32039}, "CVE-2018-21119": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2018-21120": {"epss_score": 0.0017, "epss_percentile": 0.38665}, "CVE-2018-21121": {"epss_score": 0.00122, "epss_percentile": 0.32039}, "CVE-2018-21122": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2018-21123": {"epss_score": 0.00701, "epss_percentile": 0.71501}, "CVE-2018-21124": {"epss_score": 0.00115, "epss_percentile": 0.30987}, "CVE-2018-21125": {"epss_score": 0.00122, "epss_percentile": 0.32039}, "CVE-2018-21126": {"epss_score": 0.00701, "epss_percentile": 0.71501}, "CVE-2018-21127": {"epss_score": 0.00244, "epss_percentile": 0.47522}, "CVE-2018-21128": {"epss_score": 0.00067, "epss_percentile": 0.21125}, "CVE-2018-21129": {"epss_score": 0.00097, "epss_percentile": 0.2757}, "CVE-2018-21130": {"epss_score": 0.00696, "epss_percentile": 0.71391}, "CVE-2018-21131": {"epss_score": 0.00278, "epss_percentile": 0.50888}, "CVE-2018-21132": {"epss_score": 0.0057, "epss_percentile": 0.67941}, "CVE-2018-21133": {"epss_score": 0.00556, "epss_percentile": 0.67529}, "CVE-2018-21134": {"epss_score": 0.00528, "epss_percentile": 0.66547}, "CVE-2018-21135": {"epss_score": 0.00603, "epss_percentile": 0.68917}, "CVE-2018-21136": {"epss_score": 0.00059, "epss_percentile": 0.18919}, "CVE-2018-21137": {"epss_score": 0.00272, "epss_percentile": 0.50415}, "CVE-2018-21138": {"epss_score": 0.00164, "epss_percentile": 0.37995}, "CVE-2018-21139": {"epss_score": 0.0026, "epss_percentile": 0.49152}, "CVE-2018-21140": {"epss_score": 0.00301, "epss_percentile": 0.53069}, "CVE-2018-21141": {"epss_score": 0.00126, "epss_percentile": 0.32646}, "CVE-2018-21142": {"epss_score": 0.00337, "epss_percentile": 0.5604}, "CVE-2018-21143": {"epss_score": 0.00182, "epss_percentile": 0.40235}, "CVE-2018-21144": {"epss_score": 0.0024, "epss_percentile": 0.4722}, "CVE-2018-21145": {"epss_score": 0.0034, "epss_percentile": 0.5627}, "CVE-2018-21146": {"epss_score": 0.00192, "epss_percentile": 0.41315}, "CVE-2018-21147": {"epss_score": 0.003, "epss_percentile": 0.52983}, "CVE-2018-21148": {"epss_score": 0.00161, "epss_percentile": 0.37544}, "CVE-2018-21149": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2018-21150": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2018-21151": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2018-21152": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2018-21153": {"epss_score": 0.00592, "epss_percentile": 0.68618}, "CVE-2018-21154": {"epss_score": 0.00136, "epss_percentile": 0.34088}, "CVE-2018-21155": {"epss_score": 0.00191, "epss_percentile": 0.41168}, "CVE-2018-21156": {"epss_score": 0.00334, "epss_percentile": 0.55731}, "CVE-2018-21157": {"epss_score": 0.00405, "epss_percentile": 0.60505}, "CVE-2018-21158": {"epss_score": 0.00255, "epss_percentile": 0.48697}, "CVE-2018-21159": {"epss_score": 0.00096, "epss_percentile": 0.27409}, "CVE-2018-21160": {"epss_score": 0.00202, "epss_percentile": 0.42424}, "CVE-2018-21161": {"epss_score": 0.00308, "epss_percentile": 0.53605}, "CVE-2018-21162": {"epss_score": 0.00372, "epss_percentile": 0.58458}, "CVE-2018-21163": {"epss_score": 0.00334, "epss_percentile": 0.55731}, "CVE-2018-21164": {"epss_score": 0.01038, "epss_percentile": 0.76939}, "CVE-2018-21165": {"epss_score": 0.00382, "epss_percentile": 0.59049}, "CVE-2018-21166": {"epss_score": 0.00337, "epss_percentile": 0.5604}, "CVE-2018-21167": {"epss_score": 0.00066, "epss_percentile": 0.20855}, "CVE-2018-21168": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2018-21169": {"epss_score": 0.00129, "epss_percentile": 0.33129}, "CVE-2018-21170": {"epss_score": 0.00096, "epss_percentile": 0.27272}, "CVE-2018-21171": {"epss_score": 0.00068, "epss_percentile": 0.21257}, "CVE-2018-21172": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2018-21173": {"epss_score": 0.00105, "epss_percentile": 0.29336}, "CVE-2018-21174": {"epss_score": 0.00231, "epss_percentile": 0.45814}, "CVE-2018-21175": {"epss_score": 0.00815, "epss_percentile": 0.7379}, "CVE-2018-21176": {"epss_score": 0.00815, "epss_percentile": 0.7379}, "CVE-2018-21177": {"epss_score": 0.005, "epss_percentile": 0.65321}, "CVE-2018-21178": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2018-21179": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2018-21180": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2018-21181": {"epss_score": 0.00334, "epss_percentile": 0.55731}, "CVE-2018-21182": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2018-21183": {"epss_score": 0.00231, "epss_percentile": 0.45786}, "CVE-2018-21184": {"epss_score": 0.00095, "epss_percentile": 0.27128}, "CVE-2018-21185": {"epss_score": 0.00142, "epss_percentile": 0.35033}, "CVE-2018-21186": {"epss_score": 0.00104, "epss_percentile": 0.29217}, "CVE-2018-21187": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2018-21188": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2018-21189": {"epss_score": 0.00194, "epss_percentile": 0.41558}, "CVE-2018-21190": {"epss_score": 0.00231, "epss_percentile": 0.45786}, "CVE-2018-21191": {"epss_score": 0.00142, "epss_percentile": 0.35033}, "CVE-2018-21192": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2018-21193": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2018-21194": {"epss_score": 0.00105, "epss_percentile": 0.29336}, "CVE-2018-21195": {"epss_score": 0.00176, "epss_percentile": 0.39489}, "CVE-2018-21196": {"epss_score": 0.00242, "epss_percentile": 0.47405}, "CVE-2018-21197": {"epss_score": 0.0013, "epss_percentile": 0.33262}, "CVE-2018-21198": {"epss_score": 0.00125, "epss_percentile": 0.32611}, "CVE-2018-21199": {"epss_score": 0.00095, "epss_percentile": 0.27128}, "CVE-2018-21200": {"epss_score": 0.00275, "epss_percentile": 0.50646}, "CVE-2018-21201": {"epss_score": 0.00275, "epss_percentile": 0.50646}, "CVE-2018-21202": {"epss_score": 0.0016, "epss_percentile": 0.37425}, "CVE-2018-21203": {"epss_score": 0.0062, "epss_percentile": 0.69441}, "CVE-2018-21204": {"epss_score": 0.0014, "epss_percentile": 0.34673}, "CVE-2018-21205": {"epss_score": 0.0084, "epss_percentile": 0.74211}, "CVE-2018-21206": {"epss_score": 0.0014, "epss_percentile": 0.34673}, "CVE-2018-21207": {"epss_score": 0.00131, "epss_percentile": 0.33396}, "CVE-2018-21208": {"epss_score": 0.0056, "epss_percentile": 0.67637}, "CVE-2018-21209": {"epss_score": 0.00321, "epss_percentile": 0.54683}, "CVE-2018-21210": {"epss_score": 0.0014, "epss_percentile": 0.34673}, "CVE-2018-21211": {"epss_score": 0.0084, "epss_percentile": 0.74211}, "CVE-2018-21212": {"epss_score": 0.00423, "epss_percentile": 0.61583}, "CVE-2018-21213": {"epss_score": 0.00097, "epss_percentile": 0.2756}, "CVE-2018-21214": {"epss_score": 0.00131, "epss_percentile": 0.33396}, "CVE-2018-21215": {"epss_score": 0.00131, "epss_percentile": 0.33396}, "CVE-2018-21216": {"epss_score": 0.0013, "epss_percentile": 0.33272}, "CVE-2018-21217": {"epss_score": 0.00131, "epss_percentile": 0.33396}, "CVE-2018-21218": {"epss_score": 0.00471, "epss_percentile": 0.64009}, "CVE-2018-21219": {"epss_score": 0.0014, "epss_percentile": 0.34673}, "CVE-2018-21220": {"epss_score": 0.0014, "epss_percentile": 0.34673}, "CVE-2018-21221": {"epss_score": 0.00131, "epss_percentile": 0.33396}, "CVE-2018-21222": {"epss_score": 0.0014, "epss_percentile": 0.34673}, "CVE-2018-21223": {"epss_score": 0.0014, "epss_percentile": 0.34673}, "CVE-2018-21224": {"epss_score": 0.00468, "epss_percentile": 0.63874}, "CVE-2018-21225": {"epss_score": 0.00136, "epss_percentile": 0.34088}, "CVE-2018-21226": {"epss_score": 0.00122, "epss_percentile": 0.32039}, "CVE-2018-21227": {"epss_score": 0.00136, "epss_percentile": 0.34088}, "CVE-2018-21228": {"epss_score": 0.00136, "epss_percentile": 0.34088}, "CVE-2018-21229": {"epss_score": 0.00087, "epss_percentile": 0.25466}, "CVE-2018-21230": {"epss_score": 0.00073, "epss_percentile": 0.22529}, "CVE-2018-21231": {"epss_score": 0.00073, "epss_percentile": 0.22529}, "CVE-2018-21232": {"epss_score": 0.00101, "epss_percentile": 0.28624}, "CVE-2018-21233": {"epss_score": 0.00128, "epss_percentile": 0.32943}, "CVE-2018-21234": {"epss_score": 0.25246, "epss_percentile": 0.96003}, "CVE-2018-21235": {"epss_score": 0.00013, "epss_percentile": 0.01479}, "CVE-2018-21236": {"epss_score": 0.00018, "epss_percentile": 0.03636}, "CVE-2018-21237": {"epss_score": 0.0001, "epss_percentile": 0.00813}, "CVE-2018-21238": {"epss_score": 0.00018, "epss_percentile": 0.03636}, "CVE-2018-21239": {"epss_score": 0.0001, "epss_percentile": 0.00813}, "CVE-2018-21240": {"epss_score": 0.00018, "epss_percentile": 0.03636}, "CVE-2018-21241": {"epss_score": 0.0002, "epss_percentile": 0.04593}, "CVE-2018-21242": {"epss_score": 0.03645, "epss_percentile": 0.87498}, "CVE-2018-21243": {"epss_score": 0.00038, "epss_percentile": 0.11204}, "CVE-2018-21244": {"epss_score": 0.0005, "epss_percentile": 0.15674}, "CVE-2018-21245": {"epss_score": 0.00287, "epss_percentile": 0.51807}, "CVE-2018-21246": {"epss_score": 0.00525, "epss_percentile": 0.6638}, "CVE-2018-21247": {"epss_score": 0.01477, "epss_percentile": 0.80544}, "CVE-2018-21248": {"epss_score": 0.00251, "epss_percentile": 0.48273}, "CVE-2018-21249": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2018-21250": {"epss_score": 0.00388, "epss_percentile": 0.59375}, "CVE-2018-21251": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2018-21252": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2018-21253": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2018-21254": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2018-21255": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2018-21256": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2018-21257": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2018-21258": {"epss_score": 0.005, "epss_percentile": 0.65288}, "CVE-2018-21259": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2018-21260": {"epss_score": 0.00232, "epss_percentile": 0.45936}, "CVE-2018-21261": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2018-21262": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2018-21263": {"epss_score": 0.00336, "epss_percentile": 0.55939}, "CVE-2018-21264": {"epss_score": 0.00511, "epss_percentile": 0.65827}, "CVE-2018-21265": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2018-21268": {"epss_score": 0.06517, "epss_percentile": 0.90815}, "CVE-2018-21269": {"epss_score": 0.00141, "epss_percentile": 0.34906}, "CVE-2018-21270": {"epss_score": 0.0036, "epss_percentile": 0.57631}, "CVE-2018-25001": {"epss_score": 0.00215, "epss_percentile": 0.44089}, "CVE-2018-25002": {"epss_score": 0.00516, "epss_percentile": 0.66036}, "CVE-2018-25004": {"epss_score": 0.00437, "epss_percentile": 0.62523}, "CVE-2018-25007": {"epss_score": 0.00288, "epss_percentile": 0.51872}, "CVE-2018-25008": {"epss_score": 0.00213, "epss_percentile": 0.43896}, "CVE-2018-25009": {"epss_score": 0.00447, "epss_percentile": 0.62959}, "CVE-2018-25010": {"epss_score": 0.0051, "epss_percentile": 0.65788}, "CVE-2018-25011": {"epss_score": 0.00376, "epss_percentile": 0.58647}, "CVE-2018-25012": {"epss_score": 0.00575, "epss_percentile": 0.68108}, "CVE-2018-25013": {"epss_score": 0.00139, "epss_percentile": 0.34552}, "CVE-2018-25014": {"epss_score": 0.00578, "epss_percentile": 0.68188}, "CVE-2018-25015": {"epss_score": 0.00069, "epss_percentile": 0.21555}, "CVE-2018-25016": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2018-25017": {"epss_score": 0.0055, "epss_percentile": 0.67334}, "CVE-2018-25018": {"epss_score": 0.0041, "epss_percentile": 0.60831}, "CVE-2018-25019": {"epss_score": 0.00247, "epss_percentile": 0.47859}, "CVE-2018-25020": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2018-25021": {"epss_score": 0.00976, "epss_percentile": 0.76216}, "CVE-2018-25022": {"epss_score": 0.00297, "epss_percentile": 0.52771}, "CVE-2018-25023": {"epss_score": 0.00231, "epss_percentile": 0.45798}, "CVE-2018-25024": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2018-25025": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2018-25026": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2018-25027": {"epss_score": 0.00414, "epss_percentile": 0.61102}, "CVE-2018-25028": {"epss_score": 0.00478, "epss_percentile": 0.64408}, "CVE-2018-25029": {"epss_score": 0.00094, "epss_percentile": 0.2677}, "CVE-2018-25030": {"epss_score": 0.00245, "epss_percentile": 0.47704}, "CVE-2018-25031": {"epss_score": 0.83676, "epss_percentile": 0.99257}, "CVE-2018-25032": {"epss_score": 0.00089, "epss_percentile": 0.25925}, "CVE-2018-25033": {"epss_score": 0.00484, "epss_percentile": 0.64672}, "CVE-2018-25034": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2018-25035": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-25036": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-25037": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-25038": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-25039": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-25040": {"epss_score": 0.00346, "epss_percentile": 0.56623}, "CVE-2018-25041": {"epss_score": 0.00381, "epss_percentile": 0.59006}, "CVE-2018-25042": {"epss_score": 0.00444, "epss_percentile": 0.62809}, "CVE-2018-25043": {"epss_score": 0.00409, "epss_percentile": 0.60762}, "CVE-2018-25044": {"epss_score": 0.00502, "epss_percentile": 0.6538}, "CVE-2018-25045": {"epss_score": 0.00328, "epss_percentile": 0.55256}, "CVE-2018-25046": {"epss_score": 0.00598, "epss_percentile": 0.6876}, "CVE-2018-25047": {"epss_score": 0.00337, "epss_percentile": 0.56065}, "CVE-2018-25048": {"epss_score": 0.00443, "epss_percentile": 0.62793}, "CVE-2018-25049": {"epss_score": 0.00442, "epss_percentile": 0.62737}, "CVE-2018-25050": {"epss_score": 0.00381, "epss_percentile": 0.5898}, "CVE-2018-25051": {"epss_score": 0.00311, "epss_percentile": 0.53921}, "CVE-2018-25052": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2018-25053": {"epss_score": 0.00301, "epss_percentile": 0.53072}, "CVE-2018-25054": {"epss_score": 0.0032, "epss_percentile": 0.54621}, "CVE-2018-25055": {"epss_score": 0.00285, "epss_percentile": 0.51646}, "CVE-2018-25056": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2018-25057": {"epss_score": 0.00297, "epss_percentile": 0.52711}, "CVE-2018-25058": {"epss_score": 0.00413, "epss_percentile": 0.60993}, "CVE-2018-25059": {"epss_score": 0.00404, "epss_percentile": 0.60452}, "CVE-2018-25060": {"epss_score": 0.00226, "epss_percentile": 0.45239}, "CVE-2018-25061": {"epss_score": 0.00469, "epss_percentile": 0.63916}, "CVE-2018-25062": {"epss_score": 0.00477, "epss_percentile": 0.64355}, "CVE-2018-25063": {"epss_score": 0.00352, "epss_percentile": 0.57124}, "CVE-2018-25064": {"epss_score": 0.00346, "epss_percentile": 0.5665}, "CVE-2018-25065": {"epss_score": 0.00346, "epss_percentile": 0.5665}, "CVE-2018-25066": {"epss_score": 0.00064, "epss_percentile": 0.20365}, "CVE-2018-25067": {"epss_score": 0.00279, "epss_percentile": 0.50996}, "CVE-2018-25068": {"epss_score": 0.00067, "epss_percentile": 0.21153}, "CVE-2018-25069": {"epss_score": 0.00086, "epss_percentile": 0.2539}, "CVE-2018-25070": {"epss_score": 0.00064, "epss_percentile": 0.20365}, "CVE-2018-25071": {"epss_score": 0.00064, "epss_percentile": 0.20365}, "CVE-2018-25072": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2018-25073": {"epss_score": 0.00085, "epss_percentile": 0.25112}, "CVE-2018-25074": {"epss_score": 0.00068, "epss_percentile": 0.21334}, "CVE-2018-25075": {"epss_score": 0.00198, "epss_percentile": 0.4205}, "CVE-2018-25076": {"epss_score": 0.0006, "epss_percentile": 0.19155}, "CVE-2018-25077": {"epss_score": 0.00069, "epss_percentile": 0.21613}, "CVE-2018-25078": {"epss_score": 0.00057, "epss_percentile": 0.1817}, "CVE-2018-25079": {"epss_score": 0.00066, "epss_percentile": 0.2087}, "CVE-2018-25080": {"epss_score": 0.0073, "epss_percentile": 0.72154}, "CVE-2018-25081": {"epss_score": 0.00259, "epss_percentile": 0.49079}, "CVE-2018-25082": {"epss_score": 0.00134, "epss_percentile": 0.3385}, "CVE-2018-25083": {"epss_score": 0.01045, "epss_percentile": 0.77013}, "CVE-2018-25084": {"epss_score": 0.0007, "epss_percentile": 0.2172}, "CVE-2018-25085": {"epss_score": 0.00297, "epss_percentile": 0.52747}, "CVE-2018-25086": {"epss_score": 0.00058, "epss_percentile": 0.18461}, "CVE-2018-25087": {"epss_score": 0.00043, "epss_percentile": 0.13263}, "CVE-2018-25088": {"epss_score": 0.00042, "epss_percentile": 0.12832}, "CVE-2018-25089": {"epss_score": 0.00044, "epss_percentile": 0.13528}, "CVE-2018-25090": {"epss_score": 0.00094, "epss_percentile": 0.26967}, "CVE-2018-25091": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-25092": {"epss_score": 0.00057, "epss_percentile": 0.18215}, "CVE-2018-25093": {"epss_score": 0.00057, "epss_percentile": 0.18215}, "CVE-2018-25094": {"epss_score": 0.00128, "epss_percentile": 0.33044}, "CVE-2018-25095": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2018-25096": {"epss_score": 0.0005, "epss_percentile": 0.15767}, "CVE-2018-25097": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2018-25098": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2018-25099": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2018-25100": {"epss_score": 0.00077, "epss_percentile": 0.23317}, "CVE-2018-25101": {"epss_score": 0.00144, "epss_percentile": 0.35298}, "CVE-2018-25103": {"epss_score": 0.00342, "epss_percentile": 0.56363}, "CVE-2018-25104": {"epss_score": 0.0012, "epss_percentile": 0.3178}, "CVE-2018-25105": {"epss_score": 0.01701, "epss_percentile": 0.81837}, "CVE-2018-25106": {"epss_score": 0.00095, "epss_percentile": 0.27138}, "CVE-2018-25107": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2018-25108": {"epss_score": 0.00225, "epss_percentile": 0.45233}, "CVE-2018-25109": {"epss_score": 0.00021, "epss_percentile": 0.04737}, "CVE-2018-25110": {"epss_score": 0.00277, "epss_percentile": 0.50835}, "CVE-2018-25111": {"epss_score": 0.0002, "epss_percentile": 0.04428}, "CVE-2018-25112": {"epss_score": 0.00117, "epss_percentile": 0.31263}, "CVE-2018-25113": {"epss_score": 0.58964, "epss_percentile": 0.98142}, "CVE-2018-25114": {"epss_score": 0.75339, "epss_percentile": 0.98838}, "CVE-2018-25115": {"epss_score": 0.00815, "epss_percentile": 0.73778}, "CVE-2018-25117": {"epss_score": 0.00075, "epss_percentile": 0.22964}, "CVE-2018-25118": {"epss_score": 0.01216, "epss_percentile": 0.78592}, "CVE-2018-25119": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2018-25120": {"epss_score": 0.01047, "epss_percentile": 0.77041}, "CVE-2018-25121": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2018-25122": {"epss_score": 0.01441, "epss_percentile": 0.80306}, "CVE-2018-25123": {"epss_score": 0.00024, "epss_percentile": 0.06003}, "CVE-2018-25124": {"epss_score": 0.0171, "epss_percentile": 0.81875}, "CVE-2018-25125": {"epss_score": 0.00194, "epss_percentile": 0.41582}, "CVE-2018-25126": {"epss_score": 0.01518, "epss_percentile": 0.80812}, "CVE-2018-25127": {"epss_score": 0.00018, "epss_percentile": 0.03749}, "CVE-2018-25128": {"epss_score": 0.00075, "epss_percentile": 0.2293}, "CVE-2018-25129": {"epss_score": 0.00045, "epss_percentile": 0.13934}, "CVE-2018-25130": {"epss_score": 0.0002, "epss_percentile": 0.04564}, "CVE-2018-25131": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2018-25133": {"epss_score": 0.00015, "epss_percentile": 0.02439}, "CVE-2018-25134": {"epss_score": 0.00231, "epss_percentile": 0.45838}, "CVE-2018-25135": {"epss_score": 0.00078, "epss_percentile": 0.23668}, "CVE-2018-25136": {"epss_score": 0.00054, "epss_percentile": 0.17057}, "CVE-2018-25137": {"epss_score": 0.00066, "epss_percentile": 0.20809}, "CVE-2018-25138": {"epss_score": 0.00128, "epss_percentile": 0.33035}, "CVE-2018-25139": {"epss_score": 0.00122, "epss_percentile": 0.32112}, "CVE-2018-25140": {"epss_score": 0.00077, "epss_percentile": 0.23436}, "CVE-2018-25141": {"epss_score": 0.00109, "epss_percentile": 0.29917}, "CVE-2018-25142": {"epss_score": 0.00044, "epss_percentile": 0.13615}, "CVE-2018-25143": {"epss_score": 0.0009, "epss_percentile": 0.26058}, "CVE-2018-25144": {"epss_score": 0.00059, "epss_percentile": 0.18867}, "CVE-2018-25145": {"epss_score": 0.00032, "epss_percentile": 0.09074}, "CVE-2018-25146": {"epss_score": 0.00039, "epss_percentile": 0.11449}, "CVE-2018-25147": {"epss_score": 0.00039, "epss_percentile": 0.1172}, "CVE-2018-25148": {"epss_score": 0.00242, "epss_percentile": 0.47336}, "CVE-2018-25149": {"epss_score": 0.00015, "epss_percentile": 0.02439}, "CVE-2018-25150": {"epss_score": 0.00019, "epss_percentile": 0.04052}, "CVE-2018-25151": {"epss_score": 0.00016, "epss_percentile": 0.02848}, "CVE-2018-25152": {"epss_score": 0.00019, "epss_percentile": 0.04052}, "CVE-2018-25154": {"epss_score": 0.00068, "epss_percentile": 0.21336}, "CVE-2018-25155": {"epss_score": 0.00018, "epss_percentile": 0.03749}, "CVE-2018-25156": {"epss_score": 0.00018, "epss_percentile": 0.03749}, "CVE-2018-2000": {"epss_score": 0.00155, "epss_percentile": 0.36826}, "CVE-2018-2001": {"epss_score": 0.00094, "epss_percentile": 0.27031}, "CVE-2018-2004": {"epss_score": 0.00229, "epss_percentile": 0.45551}, "CVE-2018-2005": {"epss_score": 0.00031, "epss_percentile": 0.0865}, "CVE-2018-2006": {"epss_score": 0.00213, "epss_percentile": 0.43895}, "CVE-2018-2007": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2018-2008": {"epss_score": 0.00172, "epss_percentile": 0.39008}, "CVE-2018-2009": {"epss_score": 0.00251, "epss_percentile": 0.48289}, "CVE-2018-2011": {"epss_score": 0.00546, "epss_percentile": 0.67203}, "CVE-2018-2013": {"epss_score": 0.00235, "epss_percentile": 0.46311}, "CVE-2018-2015": {"epss_score": 0.00201, "epss_percentile": 0.42281}, "CVE-2018-2019": {"epss_score": 0.00515, "epss_percentile": 0.65988}, "CVE-2018-2021": {"epss_score": 0.00166, "epss_percentile": 0.38177}, "CVE-2018-2022": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2018-2024": {"epss_score": 0.00102, "epss_percentile": 0.28735}, "CVE-2018-2025": {"epss_score": 0.00033, "epss_percentile": 0.09407}, "CVE-2018-2026": {"epss_score": 0.00173, "epss_percentile": 0.39042}, "CVE-2018-2028": {"epss_score": 0.00083, "epss_percentile": 0.24608}, "CVE-2018-2360": {"epss_score": 0.01672, "epss_percentile": 0.81682}, "CVE-2018-2361": {"epss_score": 0.00392, "epss_percentile": 0.59685}, "CVE-2018-2362": {"epss_score": 0.0028, "epss_percentile": 0.51067}, "CVE-2018-2363": {"epss_score": 0.0074, "epss_percentile": 0.72411}, "CVE-2018-2364": {"epss_score": 0.00313, "epss_percentile": 0.54069}, "CVE-2018-2365": {"epss_score": 0.00313, "epss_percentile": 0.54069}, "CVE-2018-2366": {"epss_score": 0.00849, "epss_percentile": 0.74374}, "CVE-2018-2367": {"epss_score": 0.01807, "epss_percentile": 0.82353}, "CVE-2018-2368": {"epss_score": 0.02241, "epss_percentile": 0.84115}, "CVE-2018-2369": {"epss_score": 0.00742, "epss_percentile": 0.72451}, "CVE-2018-2370": {"epss_score": 0.00211, "epss_percentile": 0.43682}, "CVE-2018-2371": {"epss_score": 0.00313, "epss_percentile": 0.54069}, "CVE-2018-2372": {"epss_score": 0.00294, "epss_percentile": 0.52426}, "CVE-2018-2373": {"epss_score": 0.00774, "epss_percentile": 0.73067}, "CVE-2018-2374": {"epss_score": 0.00317, "epss_percentile": 0.54347}, "CVE-2018-2375": {"epss_score": 0.00286, "epss_percentile": 0.51696}, "CVE-2018-2376": {"epss_score": 0.00286, "epss_percentile": 0.51696}, "CVE-2018-2377": {"epss_score": 0.00294, "epss_percentile": 0.52426}, "CVE-2018-2378": {"epss_score": 0.00294, "epss_percentile": 0.52426}, "CVE-2018-2379": {"epss_score": 0.00745, "epss_percentile": 0.72522}, "CVE-2018-2380": {"epss_score": 0.45533, "epss_percentile": 0.9749}, "CVE-2018-2381": {"epss_score": 0.00403, "epss_percentile": 0.6035}, "CVE-2018-2382": {"epss_score": 0.00256, "epss_percentile": 0.48815}, "CVE-2018-2383": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2018-2384": {"epss_score": 0.00372, "epss_percentile": 0.58425}, "CVE-2018-2385": {"epss_score": 0.0037, "epss_percentile": 0.5834}, "CVE-2018-2386": {"epss_score": 0.00448, "epss_percentile": 0.63019}, "CVE-2018-2387": {"epss_score": 0.00256, "epss_percentile": 0.48815}, "CVE-2018-2388": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2018-2389": {"epss_score": 0.00202, "epss_percentile": 0.42399}, "CVE-2018-2390": {"epss_score": 0.0037, "epss_percentile": 0.5834}, "CVE-2018-2391": {"epss_score": 0.0037, "epss_percentile": 0.5834}, "CVE-2018-2392": {"epss_score": 0.86959, "epss_percentile": 0.99405}, "CVE-2018-2393": {"epss_score": 0.17888, "epss_percentile": 0.94922}, "CVE-2018-2394": {"epss_score": 0.00444, "epss_percentile": 0.62815}, "CVE-2018-2395": {"epss_score": 0.00596, "epss_percentile": 0.68719}, "CVE-2018-2396": {"epss_score": 0.0037, "epss_percentile": 0.5834}, "CVE-2018-2397": {"epss_score": 0.00169, "epss_percentile": 0.38535}, "CVE-2018-2398": {"epss_score": 0.00163, "epss_percentile": 0.37831}, "CVE-2018-2399": {"epss_score": 0.00199, "epss_percentile": 0.421}, "CVE-2018-2400": {"epss_score": 0.00329, "epss_percentile": 0.55404}, "CVE-2018-2401": {"epss_score": 0.0025, "epss_percentile": 0.48241}, "CVE-2018-2402": {"epss_score": 0.00271, "epss_percentile": 0.50277}, "CVE-2018-2403": {"epss_score": 0.00232, "epss_percentile": 0.4593}, "CVE-2018-2404": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2018-2405": {"epss_score": 0.00169, "epss_percentile": 0.38535}, "CVE-2018-2406": {"epss_score": 0.00071, "epss_percentile": 0.21988}, "CVE-2018-2408": {"epss_score": 0.00209, "epss_percentile": 0.43348}, "CVE-2018-2409": {"epss_score": 0.00231, "epss_percentile": 0.45814}, "CVE-2018-2410": {"epss_score": 0.00281, "epss_percentile": 0.51181}, "CVE-2018-2412": {"epss_score": 0.00408, "epss_percentile": 0.60651}, "CVE-2018-2413": {"epss_score": 0.00393, "epss_percentile": 0.59738}, "CVE-2018-2415": {"epss_score": 0.00278, "epss_percentile": 0.50879}, "CVE-2018-2416": {"epss_score": 0.00748, "epss_percentile": 0.7259}, "CVE-2018-2417": {"epss_score": 0.00247, "epss_percentile": 0.47841}, "CVE-2018-2418": {"epss_score": 0.00492, "epss_percentile": 0.64988}, "CVE-2018-2419": {"epss_score": 0.00182, "epss_percentile": 0.40239}, "CVE-2018-2420": {"epss_score": 0.00619, "epss_percentile": 0.69434}, "CVE-2018-2421": {"epss_score": 0.00511, "epss_percentile": 0.65814}, "CVE-2018-2422": {"epss_score": 0.00511, "epss_percentile": 0.65814}, "CVE-2018-2423": {"epss_score": 0.00511, "epss_percentile": 0.65814}, "CVE-2018-2424": {"epss_score": 0.00292, "epss_percentile": 0.52259}, "CVE-2018-2425": {"epss_score": 0.00055, "epss_percentile": 0.17481}, "CVE-2018-2427": {"epss_score": 0.00677, "epss_percentile": 0.70965}, "CVE-2018-2428": {"epss_score": 0.00213, "epss_percentile": 0.43827}, "CVE-2018-2431": {"epss_score": 0.00418, "epss_percentile": 0.61278}, "CVE-2018-2432": {"epss_score": 0.00399, "epss_percentile": 0.60116}, "CVE-2018-2433": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2018-2434": {"epss_score": 0.0013, "epss_percentile": 0.33322}, "CVE-2018-2435": {"epss_score": 0.00418, "epss_percentile": 0.61278}, "CVE-2018-2436": {"epss_score": 0.00414, "epss_percentile": 0.61108}, "CVE-2018-2437": {"epss_score": 0.00605, "epss_percentile": 0.68991}, "CVE-2018-2438": {"epss_score": 0.00511, "epss_percentile": 0.65814}, "CVE-2018-2439": {"epss_score": 0.0046, "epss_percentile": 0.6352}, "CVE-2018-2440": {"epss_score": 0.0005, "epss_percentile": 0.15899}, "CVE-2018-2441": {"epss_score": 0.00293, "epss_percentile": 0.52354}, "CVE-2018-2442": {"epss_score": 0.0018, "epss_percentile": 0.39911}, "CVE-2018-2444": {"epss_score": 0.00418, "epss_percentile": 0.61278}, "CVE-2018-2445": {"epss_score": 0.00213, "epss_percentile": 0.43893}, "CVE-2018-2446": {"epss_score": 0.00709, "epss_percentile": 0.7169}, "CVE-2018-2447": {"epss_score": 0.00414, "epss_percentile": 0.61015}, "CVE-2018-2448": {"epss_score": 0.00247, "epss_percentile": 0.47841}, "CVE-2018-2449": {"epss_score": 0.01304, "epss_percentile": 0.79319}, "CVE-2018-2450": {"epss_score": 0.00614, "epss_percentile": 0.69265}, "CVE-2018-2451": {"epss_score": 0.00394, "epss_percentile": 0.59783}, "CVE-2018-2452": {"epss_score": 0.00568, "epss_percentile": 0.67878}, "CVE-2018-2454": {"epss_score": 0.00414, "epss_percentile": 0.61108}, "CVE-2018-2455": {"epss_score": 0.00414, "epss_percentile": 0.61108}, "CVE-2018-2457": {"epss_score": 0.0027, "epss_percentile": 0.50236}, "CVE-2018-2458": {"epss_score": 0.00347, "epss_percentile": 0.5677}, "CVE-2018-2459": {"epss_score": 0.00347, "epss_percentile": 0.5677}, "CVE-2018-2460": {"epss_score": 0.00136, "epss_percentile": 0.34102}, "CVE-2018-2461": {"epss_score": 0.00414, "epss_percentile": 0.61108}, "CVE-2018-2462": {"epss_score": 0.00628, "epss_percentile": 0.69661}, "CVE-2018-2463": {"epss_score": 0.00297, "epss_percentile": 0.52713}, "CVE-2018-2464": {"epss_score": 0.00418, "epss_percentile": 0.61278}, "CVE-2018-2465": {"epss_score": 0.00511, "epss_percentile": 0.65814}, "CVE-2018-2466": {"epss_score": 0.00399, "epss_percentile": 0.60116}, "CVE-2018-2467": {"epss_score": 0.00247, "epss_percentile": 0.47841}, "CVE-2018-2468": {"epss_score": 0.00347, "epss_percentile": 0.5677}, "CVE-2018-2469": {"epss_score": 0.00347, "epss_percentile": 0.5677}, "CVE-2018-2470": {"epss_score": 0.00418, "epss_percentile": 0.61278}, "CVE-2018-2471": {"epss_score": 0.00347, "epss_percentile": 0.5677}, "CVE-2018-2472": {"epss_score": 0.00418, "epss_percentile": 0.61278}, "CVE-2018-2473": {"epss_score": 0.00553, "epss_percentile": 0.67409}, "CVE-2018-2474": {"epss_score": 0.0015, "epss_percentile": 0.36067}, "CVE-2018-2475": {"epss_score": 0.00765, "epss_percentile": 0.7292}, "CVE-2018-2476": {"epss_score": 0.00205, "epss_percentile": 0.42707}, "CVE-2018-2477": {"epss_score": 0.00806, "epss_percentile": 0.73657}, "CVE-2018-2478": {"epss_score": 0.0036, "epss_percentile": 0.57635}, "CVE-2018-2479": {"epss_score": 0.00369, "epss_percentile": 0.58237}, "CVE-2018-2481": {"epss_score": 0.0059, "epss_percentile": 0.68569}, "CVE-2018-2482": {"epss_score": 0.00608, "epss_percentile": 0.69072}, "CVE-2018-2483": {"epss_score": 0.00155, "epss_percentile": 0.36791}, "CVE-2018-2484": {"epss_score": 0.00494, "epss_percentile": 0.65071}, "CVE-2018-2485": {"epss_score": 0.00205, "epss_percentile": 0.42675}, "CVE-2018-2486": {"epss_score": 0.00399, "epss_percentile": 0.60116}, "CVE-2018-2487": {"epss_score": 0.00681, "epss_percentile": 0.71052}, "CVE-2018-2488": {"epss_score": 0.00189, "epss_percentile": 0.40946}, "CVE-2018-2489": {"epss_score": 0.00132, "epss_percentile": 0.33617}, "CVE-2018-2490": {"epss_score": 0.00115, "epss_percentile": 0.31031}, "CVE-2018-2491": {"epss_score": 0.00221, "epss_percentile": 0.44704}, "CVE-2018-2492": {"epss_score": 0.00363, "epss_percentile": 0.57903}, "CVE-2018-2494": {"epss_score": 0.00293, "epss_percentile": 0.52355}, "CVE-2018-2497": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2018-2499": {"epss_score": 0.0043, "epss_percentile": 0.62003}, "CVE-2018-2500": {"epss_score": 0.00074, "epss_percentile": 0.22822}, "CVE-2018-2502": {"epss_score": 0.00369, "epss_percentile": 0.58237}, "CVE-2018-2503": {"epss_score": 0.00186, "epss_percentile": 0.40605}, "CVE-2018-2504": {"epss_score": 0.00369, "epss_percentile": 0.58237}, "CVE-2018-2505": {"epss_score": 0.00418, "epss_percentile": 0.61278}, "CVE-2018-2560": {"epss_score": 0.00115, "epss_percentile": 0.31026}, "CVE-2018-2561": {"epss_score": 0.02262, "epss_percentile": 0.84189}, "CVE-2018-2562": {"epss_score": 0.00784, "epss_percentile": 0.73239}, "CVE-2018-2563": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2018-2564": {"epss_score": 0.00873, "epss_percentile": 0.74751}, "CVE-2018-2565": {"epss_score": 0.00584, "epss_percentile": 0.68398}, "CVE-2018-2566": {"epss_score": 0.00883, "epss_percentile": 0.74903}, "CVE-2018-2567": {"epss_score": 0.00646, "epss_percentile": 0.70151}, "CVE-2018-2568": {"epss_score": 0.00551, "epss_percentile": 0.67378}, "CVE-2018-2569": {"epss_score": 0.00187, "epss_percentile": 0.40758}, "CVE-2018-2570": {"epss_score": 0.00301, "epss_percentile": 0.53024}, "CVE-2018-2571": {"epss_score": 0.00302, "epss_percentile": 0.53123}, "CVE-2018-2572": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2018-2573": {"epss_score": 0.01047, "epss_percentile": 0.77033}, "CVE-2018-2574": {"epss_score": 0.00524, "epss_percentile": 0.66332}, "CVE-2018-2575": {"epss_score": 0.0032, "epss_percentile": 0.54633}, "CVE-2018-2576": {"epss_score": 0.00584, "epss_percentile": 0.68398}, "CVE-2018-2577": {"epss_score": 0.00217, "epss_percentile": 0.44279}, "CVE-2018-2578": {"epss_score": 0.00163, "epss_percentile": 0.37859}, "CVE-2018-2579": {"epss_score": 0.00113, "epss_percentile": 0.30603}, "CVE-2018-2580": {"epss_score": 0.0023, "epss_percentile": 0.45727}, "CVE-2018-2581": {"epss_score": 0.00492, "epss_percentile": 0.65008}, "CVE-2018-2582": {"epss_score": 0.00156, "epss_percentile": 0.36932}, "CVE-2018-2583": {"epss_score": 0.00323, "epss_percentile": 0.54892}, "CVE-2018-2584": {"epss_score": 0.00204, "epss_percentile": 0.42652}, "CVE-2018-2585": {"epss_score": 0.1202, "epss_percentile": 0.93549}, "CVE-2018-2586": {"epss_score": 0.00658, "epss_percentile": 0.70489}, "CVE-2018-2587": {"epss_score": 0.01392, "epss_percentile": 0.79959}, "CVE-2018-2588": {"epss_score": 0.00477, "epss_percentile": 0.64301}, "CVE-2018-2589": {"epss_score": 0.01494, "epss_percentile": 0.80647}, "CVE-2018-2590": {"epss_score": 0.00598, "epss_percentile": 0.68755}, "CVE-2018-2591": {"epss_score": 0.00297, "epss_percentile": 0.52698}, "CVE-2018-2592": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-2593": {"epss_score": 0.01253, "epss_percentile": 0.78913}, "CVE-2018-2594": {"epss_score": 0.00407, "epss_percentile": 0.60577}, "CVE-2018-2595": {"epss_score": 0.00259, "epss_percentile": 0.49066}, "CVE-2018-2596": {"epss_score": 0.00873, "epss_percentile": 0.74751}, "CVE-2018-2597": {"epss_score": 0.01021, "epss_percentile": 0.76747}, "CVE-2018-2598": {"epss_score": 0.0054, "epss_percentile": 0.67012}, "CVE-2018-2599": {"epss_score": 0.00127, "epss_percentile": 0.32935}, "CVE-2018-2600": {"epss_score": 0.00658, "epss_percentile": 0.70489}, "CVE-2018-2601": {"epss_score": 0.00486, "epss_percentile": 0.64742}, "CVE-2018-2602": {"epss_score": 0.00065, "epss_percentile": 0.20494}, "CVE-2018-2603": {"epss_score": 0.00095, "epss_percentile": 0.27221}, "CVE-2018-2604": {"epss_score": 0.01497, "epss_percentile": 0.80693}, "CVE-2018-2605": {"epss_score": 0.00905, "epss_percentile": 0.75243}, "CVE-2018-2606": {"epss_score": 0.00547, "epss_percentile": 0.67265}, "CVE-2018-2607": {"epss_score": 0.00327, "epss_percentile": 0.55104}, "CVE-2018-2608": {"epss_score": 0.00949, "epss_percentile": 0.75842}, "CVE-2018-2609": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2018-2610": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2611": {"epss_score": 0.04946, "epss_percentile": 0.89318}, "CVE-2018-2612": {"epss_score": 0.00277, "epss_percentile": 0.50786}, "CVE-2018-2613": {"epss_score": 0.00921, "epss_percentile": 0.75482}, "CVE-2018-2614": {"epss_score": 0.00354, "epss_percentile": 0.57248}, "CVE-2018-2615": {"epss_score": 0.00713, "epss_percentile": 0.71784}, "CVE-2018-2616": {"epss_score": 0.05812, "epss_percentile": 0.90226}, "CVE-2018-2617": {"epss_score": 0.01497, "epss_percentile": 0.80693}, "CVE-2018-2618": {"epss_score": 0.00162, "epss_percentile": 0.37719}, "CVE-2018-2619": {"epss_score": 0.00555, "epss_percentile": 0.67459}, "CVE-2018-2620": {"epss_score": 0.00496, "epss_percentile": 0.65161}, "CVE-2018-2621": {"epss_score": 0.01021, "epss_percentile": 0.76747}, "CVE-2018-2622": {"epss_score": 0.00398, "epss_percentile": 0.60064}, "CVE-2018-2623": {"epss_score": 0.01742, "epss_percentile": 0.82052}, "CVE-2018-2624": {"epss_score": 0.00993, "epss_percentile": 0.76412}, "CVE-2018-2625": {"epss_score": 0.00689, "epss_percentile": 0.71231}, "CVE-2018-2626": {"epss_score": 0.00646, "epss_percentile": 0.70151}, "CVE-2018-2627": {"epss_score": 0.00507, "epss_percentile": 0.6565}, "CVE-2018-2628": {"epss_score": 0.94422, "epss_percentile": 0.99979}, "CVE-2018-2629": {"epss_score": 0.0047, "epss_percentile": 0.63965}, "CVE-2018-2630": {"epss_score": 0.00302, "epss_percentile": 0.53123}, "CVE-2018-2631": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2018-2632": {"epss_score": 0.00425, "epss_percentile": 0.61726}, "CVE-2018-2633": {"epss_score": 0.0083, "epss_percentile": 0.74024}, "CVE-2018-2634": {"epss_score": 0.00162, "epss_percentile": 0.37719}, "CVE-2018-2635": {"epss_score": 0.00637, "epss_percentile": 0.69881}, "CVE-2018-2636": {"epss_score": 0.65872, "epss_percentile": 0.98441}, "CVE-2018-2637": {"epss_score": 0.00192, "epss_percentile": 0.41314}, "CVE-2018-2638": {"epss_score": 0.00748, "epss_percentile": 0.72576}, "CVE-2018-2639": {"epss_score": 0.00596, "epss_percentile": 0.6871}, "CVE-2018-2640": {"epss_score": 0.00464, "epss_percentile": 0.63711}, "CVE-2018-2641": {"epss_score": 0.00169, "epss_percentile": 0.38565}, "CVE-2018-2642": {"epss_score": 0.00335, "epss_percentile": 0.55816}, "CVE-2018-2643": {"epss_score": 0.00307, "epss_percentile": 0.53493}, "CVE-2018-2644": {"epss_score": 0.00676, "epss_percentile": 0.70937}, "CVE-2018-2645": {"epss_score": 0.0034, "epss_percentile": 0.56222}, "CVE-2018-2646": {"epss_score": 0.00584, "epss_percentile": 0.68398}, "CVE-2018-2647": {"epss_score": 0.00694, "epss_percentile": 0.71349}, "CVE-2018-2648": {"epss_score": 0.00804, "epss_percentile": 0.73616}, "CVE-2018-2649": {"epss_score": 0.01891, "epss_percentile": 0.82731}, "CVE-2018-2650": {"epss_score": 0.00247, "epss_percentile": 0.47888}, "CVE-2018-2651": {"epss_score": 0.01344, "epss_percentile": 0.79609}, "CVE-2018-2652": {"epss_score": 0.02348, "epss_percentile": 0.84462}, "CVE-2018-2653": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2654": {"epss_score": 0.00646, "epss_percentile": 0.70151}, "CVE-2018-2655": {"epss_score": 0.01017, "epss_percentile": 0.76688}, "CVE-2018-2656": {"epss_score": 0.01017, "epss_percentile": 0.76688}, "CVE-2018-2657": {"epss_score": 0.00513, "epss_percentile": 0.65918}, "CVE-2018-2658": {"epss_score": 0.00511, "epss_percentile": 0.6582}, "CVE-2018-2659": {"epss_score": 0.00511, "epss_percentile": 0.6582}, "CVE-2018-2660": {"epss_score": 0.00414, "epss_percentile": 0.61103}, "CVE-2018-2661": {"epss_score": 0.00756, "epss_percentile": 0.7273}, "CVE-2018-2662": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2018-2663": {"epss_score": 0.00112, "epss_percentile": 0.30568}, "CVE-2018-2664": {"epss_score": 0.01104, "epss_percentile": 0.77599}, "CVE-2018-2665": {"epss_score": 0.00441, "epss_percentile": 0.62695}, "CVE-2018-2666": {"epss_score": 0.00524, "epss_percentile": 0.66332}, "CVE-2018-2667": {"epss_score": 0.00584, "epss_percentile": 0.68398}, "CVE-2018-2668": {"epss_score": 0.00355, "epss_percentile": 0.57281}, "CVE-2018-2669": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2018-2670": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2671": {"epss_score": 0.00753, "epss_percentile": 0.72681}, "CVE-2018-2672": {"epss_score": 0.01284, "epss_percentile": 0.79172}, "CVE-2018-2673": {"epss_score": 0.01084, "epss_percentile": 0.77394}, "CVE-2018-2674": {"epss_score": 0.00851, "epss_percentile": 0.74407}, "CVE-2018-2675": {"epss_score": 0.01089, "epss_percentile": 0.77441}, "CVE-2018-2676": {"epss_score": 0.00165, "epss_percentile": 0.38042}, "CVE-2018-2677": {"epss_score": 0.00112, "epss_percentile": 0.30568}, "CVE-2018-2678": {"epss_score": 0.00112, "epss_percentile": 0.30568}, "CVE-2018-2679": {"epss_score": 0.00496, "epss_percentile": 0.65161}, "CVE-2018-2680": {"epss_score": 0.01383, "epss_percentile": 0.79893}, "CVE-2018-2681": {"epss_score": 0.00302, "epss_percentile": 0.53123}, "CVE-2018-2682": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2683": {"epss_score": 0.01656, "epss_percentile": 0.81596}, "CVE-2018-2684": {"epss_score": 0.00863, "epss_percentile": 0.74591}, "CVE-2018-2685": {"epss_score": 0.00178, "epss_percentile": 0.39645}, "CVE-2018-2686": {"epss_score": 0.00178, "epss_percentile": 0.39645}, "CVE-2018-2687": {"epss_score": 0.00178, "epss_percentile": 0.39645}, "CVE-2018-2688": {"epss_score": 0.00178, "epss_percentile": 0.39645}, "CVE-2018-2689": {"epss_score": 0.00178, "epss_percentile": 0.39645}, "CVE-2018-2690": {"epss_score": 0.00178, "epss_percentile": 0.39645}, "CVE-2018-2691": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2018-2692": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2693": {"epss_score": 0.00082, "epss_percentile": 0.2459}, "CVE-2018-2694": {"epss_score": 0.00082, "epss_percentile": 0.2459}, "CVE-2018-2695": {"epss_score": 0.00753, "epss_percentile": 0.72681}, "CVE-2018-2696": {"epss_score": 0.05876, "epss_percentile": 0.90286}, "CVE-2018-2697": {"epss_score": 0.0121, "epss_percentile": 0.78551}, "CVE-2018-2698": {"epss_score": 0.00753, "epss_percentile": 0.72681}, "CVE-2018-2699": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2700": {"epss_score": 0.01284, "epss_percentile": 0.79172}, "CVE-2018-2701": {"epss_score": 0.00346, "epss_percentile": 0.56631}, "CVE-2018-2702": {"epss_score": 0.00753, "epss_percentile": 0.72681}, "CVE-2018-2703": {"epss_score": 0.01047, "epss_percentile": 0.77033}, "CVE-2018-2704": {"epss_score": 0.00766, "epss_percentile": 0.72939}, "CVE-2018-2705": {"epss_score": 0.02138, "epss_percentile": 0.8374}, "CVE-2018-2706": {"epss_score": 0.02138, "epss_percentile": 0.8374}, "CVE-2018-2707": {"epss_score": 0.00477, "epss_percentile": 0.64339}, "CVE-2018-2708": {"epss_score": 0.00555, "epss_percentile": 0.67494}, "CVE-2018-2709": {"epss_score": 0.00349, "epss_percentile": 0.56902}, "CVE-2018-2710": {"epss_score": 0.05561, "epss_percentile": 0.89994}, "CVE-2018-2711": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2018-2712": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2713": {"epss_score": 0.00873, "epss_percentile": 0.74751}, "CVE-2018-2714": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2715": {"epss_score": 0.00753, "epss_percentile": 0.72681}, "CVE-2018-2716": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2717": {"epss_score": 0.0008, "epss_percentile": 0.24023}, "CVE-2018-2718": {"epss_score": 0.05561, "epss_percentile": 0.89994}, "CVE-2018-2719": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2720": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-2721": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-2722": {"epss_score": 0.00851, "epss_percentile": 0.74407}, "CVE-2018-2723": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-2724": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-2725": {"epss_score": 0.01284, "epss_percentile": 0.79173}, "CVE-2018-2726": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2018-2727": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-2728": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2729": {"epss_score": 0.00616, "epss_percentile": 0.69339}, "CVE-2018-2730": {"epss_score": 0.00187, "epss_percentile": 0.40747}, "CVE-2018-2731": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2018-2732": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2733": {"epss_score": 0.02148, "epss_percentile": 0.83769}, "CVE-2018-2737": {"epss_score": 0.00496, "epss_percentile": 0.65174}, "CVE-2018-2738": {"epss_score": 0.00496, "epss_percentile": 0.65174}, "CVE-2018-2739": {"epss_score": 0.02086, "epss_percentile": 0.8355}, "CVE-2018-2742": {"epss_score": 0.00551, "epss_percentile": 0.67378}, "CVE-2018-2746": {"epss_score": 0.00671, "epss_percentile": 0.70796}, "CVE-2018-2747": {"epss_score": 0.00753, "epss_percentile": 0.72681}, "CVE-2018-2748": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2749": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2018-2750": {"epss_score": 0.00488, "epss_percentile": 0.64833}, "CVE-2018-2752": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2018-2753": {"epss_score": 0.0008, "epss_percentile": 0.24023}, "CVE-2018-2754": {"epss_score": 0.00199, "epss_percentile": 0.421}, "CVE-2018-2755": {"epss_score": 0.00192, "epss_percentile": 0.41339}, "CVE-2018-2756": {"epss_score": 0.00522, "epss_percentile": 0.66277}, "CVE-2018-2758": {"epss_score": 0.00874, "epss_percentile": 0.74754}, "CVE-2018-2759": {"epss_score": 0.00104, "epss_percentile": 0.29245}, "CVE-2018-2760": {"epss_score": 0.01834, "epss_percentile": 0.82463}, "CVE-2018-2761": {"epss_score": 0.00247, "epss_percentile": 0.47837}, "CVE-2018-2762": {"epss_score": 0.00107, "epss_percentile": 0.296}, "CVE-2018-2763": {"epss_score": 0.00072, "epss_percentile": 0.22381}, "CVE-2018-2764": {"epss_score": 0.05561, "epss_percentile": 0.89994}, "CVE-2018-2765": {"epss_score": 0.01344, "epss_percentile": 0.79609}, "CVE-2018-2766": {"epss_score": 0.00169, "epss_percentile": 0.38606}, "CVE-2018-2767": {"epss_score": 0.00421, "epss_percentile": 0.61494}, "CVE-2018-2768": {"epss_score": 0.03196, "epss_percentile": 0.86612}, "CVE-2018-2769": {"epss_score": 0.0038, "epss_percentile": 0.58965}, "CVE-2018-2770": {"epss_score": 0.00522, "epss_percentile": 0.66277}, "CVE-2018-2771": {"epss_score": 0.0014, "epss_percentile": 0.34747}, "CVE-2018-2772": {"epss_score": 0.02138, "epss_percentile": 0.8374}, "CVE-2018-2773": {"epss_score": 0.00037, "epss_percentile": 0.10679}, "CVE-2018-2774": {"epss_score": 0.00551, "epss_percentile": 0.67378}, "CVE-2018-2775": {"epss_score": 0.00494, "epss_percentile": 0.65084}, "CVE-2018-2776": {"epss_score": 0.0038, "epss_percentile": 0.58965}, "CVE-2018-2777": {"epss_score": 0.00104, "epss_percentile": 0.29245}, "CVE-2018-2778": {"epss_score": 0.0038, "epss_percentile": 0.58965}, "CVE-2018-2779": {"epss_score": 0.0038, "epss_percentile": 0.58965}, "CVE-2018-2780": {"epss_score": 0.00494, "epss_percentile": 0.65084}, "CVE-2018-2781": {"epss_score": 0.00133, "epss_percentile": 0.33737}, "CVE-2018-2782": {"epss_score": 0.00247, "epss_percentile": 0.47864}, "CVE-2018-2783": {"epss_score": 0.00453, "epss_percentile": 0.63227}, "CVE-2018-2784": {"epss_score": 0.00247, "epss_percentile": 0.47864}, "CVE-2018-2785": {"epss_score": 0.01058, "epss_percentile": 0.77145}, "CVE-2018-2786": {"epss_score": 0.00077, "epss_percentile": 0.23381}, "CVE-2018-2787": {"epss_score": 0.00088, "epss_percentile": 0.2575}, "CVE-2018-2788": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2789": {"epss_score": 0.0021, "epss_percentile": 0.43487}, "CVE-2018-2790": {"epss_score": 0.00221, "epss_percentile": 0.44661}, "CVE-2018-2791": {"epss_score": 0.87017, "epss_percentile": 0.99409}, "CVE-2018-2792": {"epss_score": 0.00193, "epss_percentile": 0.41422}, "CVE-2018-2793": {"epss_score": 0.00255, "epss_percentile": 0.48704}, "CVE-2018-2794": {"epss_score": 0.00047, "epss_percentile": 0.14772}, "CVE-2018-2795": {"epss_score": 0.00102, "epss_percentile": 0.28804}, "CVE-2018-2796": {"epss_score": 0.00319, "epss_percentile": 0.54565}, "CVE-2018-2797": {"epss_score": 0.00102, "epss_percentile": 0.28804}, "CVE-2018-2798": {"epss_score": 0.00181, "epss_percentile": 0.40087}, "CVE-2018-2799": {"epss_score": 0.00124, "epss_percentile": 0.32388}, "CVE-2018-2800": {"epss_score": 0.00293, "epss_percentile": 0.523}, "CVE-2018-2801": {"epss_score": 0.03196, "epss_percentile": 0.86612}, "CVE-2018-2802": {"epss_score": 0.00187, "epss_percentile": 0.40747}, "CVE-2018-2803": {"epss_score": 0.00474, "epss_percentile": 0.64143}, "CVE-2018-2804": {"epss_score": 0.01715, "epss_percentile": 0.819}, "CVE-2018-2805": {"epss_score": 0.00371, "epss_percentile": 0.58355}, "CVE-2018-2806": {"epss_score": 0.03196, "epss_percentile": 0.86612}, "CVE-2018-2807": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2808": {"epss_score": 0.00095, "epss_percentile": 0.27233}, "CVE-2018-2809": {"epss_score": 0.01058, "epss_percentile": 0.77145}, "CVE-2018-2810": {"epss_score": 0.00104, "epss_percentile": 0.29245}, "CVE-2018-2811": {"epss_score": 0.00161, "epss_percentile": 0.37587}, "CVE-2018-2812": {"epss_score": 0.00401, "epss_percentile": 0.60248}, "CVE-2018-2813": {"epss_score": 0.00284, "epss_percentile": 0.51499}, "CVE-2018-2814": {"epss_score": 0.00495, "epss_percentile": 0.65123}, "CVE-2018-2815": {"epss_score": 0.00756, "epss_percentile": 0.72746}, "CVE-2018-2816": {"epss_score": 0.0038, "epss_percentile": 0.58965}, "CVE-2018-2817": {"epss_score": 0.00245, "epss_percentile": 0.47662}, "CVE-2018-2818": {"epss_score": 0.00984, "epss_percentile": 0.76313}, "CVE-2018-2819": {"epss_score": 0.00245, "epss_percentile": 0.47662}, "CVE-2018-2820": {"epss_score": 0.00223, "epss_percentile": 0.44861}, "CVE-2018-2821": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2822": {"epss_score": 0.00121, "epss_percentile": 0.31942}, "CVE-2018-2823": {"epss_score": 0.0027, "epss_percentile": 0.5024}, "CVE-2018-2824": {"epss_score": 0.00368, "epss_percentile": 0.58176}, "CVE-2018-2825": {"epss_score": 0.01133, "epss_percentile": 0.77883}, "CVE-2018-2826": {"epss_score": 0.03769, "epss_percentile": 0.87699}, "CVE-2018-2827": {"epss_score": 0.00578, "epss_percentile": 0.68176}, "CVE-2018-2828": {"epss_score": 0.00682, "epss_percentile": 0.71068}, "CVE-2018-2829": {"epss_score": 0.01982, "epss_percentile": 0.8314}, "CVE-2018-2830": {"epss_score": 0.00135, "epss_percentile": 0.34008}, "CVE-2018-2831": {"epss_score": 0.00108, "epss_percentile": 0.29852}, "CVE-2018-2832": {"epss_score": 0.00949, "epss_percentile": 0.75842}, "CVE-2018-2833": {"epss_score": 0.00474, "epss_percentile": 0.64143}, "CVE-2018-2834": {"epss_score": 0.00194, "epss_percentile": 0.41579}, "CVE-2018-2835": {"epss_score": 0.00135, "epss_percentile": 0.34008}, "CVE-2018-2836": {"epss_score": 0.00135, "epss_percentile": 0.34008}, "CVE-2018-2837": {"epss_score": 0.00135, "epss_percentile": 0.34008}, "CVE-2018-2838": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2839": {"epss_score": 0.0038, "epss_percentile": 0.58965}, "CVE-2018-2840": {"epss_score": 0.01741, "epss_percentile": 0.82047}, "CVE-2018-2841": {"epss_score": 0.01093, "epss_percentile": 0.77484}, "CVE-2018-2842": {"epss_score": 0.00135, "epss_percentile": 0.34008}, "CVE-2018-2843": {"epss_score": 0.00137, "epss_percentile": 0.34262}, "CVE-2018-2844": {"epss_score": 0.03312, "epss_percentile": 0.86893}, "CVE-2018-2845": {"epss_score": 0.00117, "epss_percentile": 0.313}, "CVE-2018-2846": {"epss_score": 0.0038, "epss_percentile": 0.58965}, "CVE-2018-2847": {"epss_score": 0.00368, "epss_percentile": 0.58176}, "CVE-2018-2848": {"epss_score": 0.01284, "epss_percentile": 0.79172}, "CVE-2018-2849": {"epss_score": 0.00337, "epss_percentile": 0.56059}, "CVE-2018-2850": {"epss_score": 0.00678, "epss_percentile": 0.71002}, "CVE-2018-2851": {"epss_score": 0.00474, "epss_percentile": 0.64143}, "CVE-2018-2852": {"epss_score": 0.00187, "epss_percentile": 0.40747}, "CVE-2018-2853": {"epss_score": 0.00187, "epss_percentile": 0.40747}, "CVE-2018-2854": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2855": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-2856": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-2857": {"epss_score": 0.00301, "epss_percentile": 0.53024}, "CVE-2018-2858": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2859": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2860": {"epss_score": 0.00156, "epss_percentile": 0.36969}, "CVE-2018-2861": {"epss_score": 0.00947, "epss_percentile": 0.75824}, "CVE-2018-2862": {"epss_score": 0.00327, "epss_percentile": 0.55148}, "CVE-2018-2863": {"epss_score": 0.00223, "epss_percentile": 0.44861}, "CVE-2018-2864": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2865": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2866": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2867": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2868": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2869": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2870": {"epss_score": 0.02197, "epss_percentile": 0.83959}, "CVE-2018-2871": {"epss_score": 0.02197, "epss_percentile": 0.83959}, "CVE-2018-2872": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2873": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2874": {"epss_score": 0.00139, "epss_percentile": 0.3464}, "CVE-2018-2875": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2018-2876": {"epss_score": 0.00553, "epss_percentile": 0.67413}, "CVE-2018-2877": {"epss_score": 0.001, "epss_percentile": 0.28442}, "CVE-2018-2878": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2879": {"epss_score": 0.44453, "epss_percentile": 0.97437}, "CVE-2018-2880": {"epss_score": 0.01494, "epss_percentile": 0.80647}, "CVE-2018-2881": {"epss_score": 0.00266, "epss_percentile": 0.49908}, "CVE-2018-2882": {"epss_score": 0.00231, "epss_percentile": 0.45854}, "CVE-2018-2883": {"epss_score": 0.00217, "epss_percentile": 0.4425}, "CVE-2018-2887": {"epss_score": 0.00496, "epss_percentile": 0.65174}, "CVE-2018-2888": {"epss_score": 0.00162, "epss_percentile": 0.37695}, "CVE-2018-2889": {"epss_score": 0.01284, "epss_percentile": 0.79172}, "CVE-2018-2891": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2018-2892": {"epss_score": 0.01522, "epss_percentile": 0.80835}, "CVE-2018-2893": {"epss_score": 0.94277, "epss_percentile": 0.99933}, "CVE-2018-2894": {"epss_score": 0.94295, "epss_percentile": 0.99938}, "CVE-2018-2895": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2896": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2897": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2898": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2899": {"epss_score": 0.00851, "epss_percentile": 0.74407}, "CVE-2018-2900": {"epss_score": 0.00782, "epss_percentile": 0.7321}, "CVE-2018-2901": {"epss_score": 0.01465, "epss_percentile": 0.80452}, "CVE-2018-2902": {"epss_score": 0.00204, "epss_percentile": 0.42652}, "CVE-2018-2903": {"epss_score": 0.00148, "epss_percentile": 0.3592}, "CVE-2018-2904": {"epss_score": 0.00403, "epss_percentile": 0.60381}, "CVE-2018-2905": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2906": {"epss_score": 0.00516, "epss_percentile": 0.66047}, "CVE-2018-2907": {"epss_score": 0.01742, "epss_percentile": 0.82052}, "CVE-2018-2908": {"epss_score": 0.00336, "epss_percentile": 0.55928}, "CVE-2018-2909": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-2911": {"epss_score": 0.0123, "epss_percentile": 0.78722}, "CVE-2018-2912": {"epss_score": 0.06006, "epss_percentile": 0.90397}, "CVE-2018-2913": {"epss_score": 0.08257, "epss_percentile": 0.91955}, "CVE-2018-2914": {"epss_score": 0.06006, "epss_percentile": 0.90397}, "CVE-2018-2915": {"epss_score": 0.00416, "epss_percentile": 0.61161}, "CVE-2018-2916": {"epss_score": 0.00426, "epss_percentile": 0.61749}, "CVE-2018-2917": {"epss_score": 0.02507, "epss_percentile": 0.8494}, "CVE-2018-2918": {"epss_score": 0.03709, "epss_percentile": 0.87602}, "CVE-2018-2919": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2920": {"epss_score": 0.00315, "epss_percentile": 0.54196}, "CVE-2018-2921": {"epss_score": 0.00416, "epss_percentile": 0.61161}, "CVE-2018-2922": {"epss_score": 0.00085, "epss_percentile": 0.25061}, "CVE-2018-2923": {"epss_score": 0.00088, "epss_percentile": 0.25692}, "CVE-2018-2924": {"epss_score": 0.00065, "epss_percentile": 0.20597}, "CVE-2018-2925": {"epss_score": 0.00691, "epss_percentile": 0.71272}, "CVE-2018-2926": {"epss_score": 0.00426, "epss_percentile": 0.61765}, "CVE-2018-2927": {"epss_score": 0.00223, "epss_percentile": 0.44861}, "CVE-2018-2928": {"epss_score": 0.00939, "epss_percentile": 0.75721}, "CVE-2018-2929": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2930": {"epss_score": 0.04946, "epss_percentile": 0.89318}, "CVE-2018-2932": {"epss_score": 0.0332, "epss_percentile": 0.86909}, "CVE-2018-2933": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2018-2934": {"epss_score": 0.0041, "epss_percentile": 0.60789}, "CVE-2018-2935": {"epss_score": 0.01117, "epss_percentile": 0.77738}, "CVE-2018-2936": {"epss_score": 0.00488, "epss_percentile": 0.64848}, "CVE-2018-2937": {"epss_score": 0.00519, "epss_percentile": 0.66183}, "CVE-2018-2938": {"epss_score": 0.00573, "epss_percentile": 0.68059}, "CVE-2018-2939": {"epss_score": 0.0012, "epss_percentile": 0.31723}, "CVE-2018-2940": {"epss_score": 0.00271, "epss_percentile": 0.50291}, "CVE-2018-2941": {"epss_score": 0.01275, "epss_percentile": 0.79103}, "CVE-2018-2942": {"epss_score": 0.00605, "epss_percentile": 0.68991}, "CVE-2018-2943": {"epss_score": 0.02487, "epss_percentile": 0.84889}, "CVE-2018-2944": {"epss_score": 0.02348, "epss_percentile": 0.84462}, "CVE-2018-2945": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2018-2946": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2018-2947": {"epss_score": 0.00691, "epss_percentile": 0.71272}, "CVE-2018-2948": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2018-2949": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2018-2950": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2018-2951": {"epss_score": 0.00255, "epss_percentile": 0.48704}, "CVE-2018-2952": {"epss_score": 0.00073, "epss_percentile": 0.2262}, "CVE-2018-2953": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2018-2954": {"epss_score": 0.00076, "epss_percentile": 0.23107}, "CVE-2018-2955": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2956": {"epss_score": 0.00157, "epss_percentile": 0.37136}, "CVE-2018-2957": {"epss_score": 0.02348, "epss_percentile": 0.84462}, "CVE-2018-2958": {"epss_score": 0.00782, "epss_percentile": 0.7321}, "CVE-2018-2959": {"epss_score": 0.00702, "epss_percentile": 0.71512}, "CVE-2018-2960": {"epss_score": 0.00511, "epss_percentile": 0.6582}, "CVE-2018-2961": {"epss_score": 0.00511, "epss_percentile": 0.6582}, "CVE-2018-2962": {"epss_score": 0.00198, "epss_percentile": 0.41976}, "CVE-2018-2963": {"epss_score": 0.00193, "epss_percentile": 0.41388}, "CVE-2018-2964": {"epss_score": 0.00439, "epss_percentile": 0.62597}, "CVE-2018-2965": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2018-2966": {"epss_score": 0.00999, "epss_percentile": 0.76482}, "CVE-2018-2967": {"epss_score": 0.00084, "epss_percentile": 0.24835}, "CVE-2018-2968": {"epss_score": 0.00999, "epss_percentile": 0.76482}, "CVE-2018-2969": {"epss_score": 0.0021, "epss_percentile": 0.43487}, "CVE-2018-2970": {"epss_score": 0.0021, "epss_percentile": 0.43487}, "CVE-2018-2971": {"epss_score": 0.00223, "epss_percentile": 0.44861}, "CVE-2018-2972": {"epss_score": 0.0064, "epss_percentile": 0.69965}, "CVE-2018-2973": {"epss_score": 0.0016, "epss_percentile": 0.37501}, "CVE-2018-2974": {"epss_score": 0.00301, "epss_percentile": 0.53024}, "CVE-2018-2975": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2976": {"epss_score": 0.01692, "epss_percentile": 0.81789}, "CVE-2018-2977": {"epss_score": 0.02289, "epss_percentile": 0.84273}, "CVE-2018-2978": {"epss_score": 0.00857, "epss_percentile": 0.74494}, "CVE-2018-2979": {"epss_score": 0.00764, "epss_percentile": 0.72906}, "CVE-2018-2980": {"epss_score": 0.00467, "epss_percentile": 0.63846}, "CVE-2018-2981": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2018-2982": {"epss_score": 0.00555, "epss_percentile": 0.67494}, "CVE-2018-2984": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-2985": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2986": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-2987": {"epss_score": 0.00427, "epss_percentile": 0.61877}, "CVE-2018-2988": {"epss_score": 0.01508, "epss_percentile": 0.80757}, "CVE-2018-2989": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2018-2990": {"epss_score": 0.01715, "epss_percentile": 0.819}, "CVE-2018-2991": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2018-2992": {"epss_score": 0.13481, "epss_percentile": 0.93977}, "CVE-2018-2993": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2018-2994": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-2995": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2018-2996": {"epss_score": 0.02348, "epss_percentile": 0.84462}, "CVE-2018-2997": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2018-2998": {"epss_score": 0.00259, "epss_percentile": 0.49028}, "CVE-2018-2999": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2018-3000": {"epss_score": 0.00246, "epss_percentile": 0.47746}, "CVE-2018-3001": {"epss_score": 0.00255, "epss_percentile": 0.48704}, "CVE-2018-3002": {"epss_score": 0.00188, "epss_percentile": 0.40852}, "CVE-2018-3003": {"epss_score": 0.00255, "epss_percentile": 0.48704}, "CVE-2018-3004": {"epss_score": 0.00522, "epss_percentile": 0.66274}, "CVE-2018-3005": {"epss_score": 0.00377, "epss_percentile": 0.58696}, "CVE-2018-3006": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2018-3007": {"epss_score": 0.01742, "epss_percentile": 0.82052}, "CVE-2018-3008": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2018-3009": {"epss_score": 0.03196, "epss_percentile": 0.86612}, "CVE-2018-3010": {"epss_score": 0.03196, "epss_percentile": 0.86612}, "CVE-2018-3011": {"epss_score": 0.0173, "epss_percentile": 0.81986}, "CVE-2018-3012": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2018-3013": {"epss_score": 0.00753, "epss_percentile": 0.72681}, "CVE-2018-3014": {"epss_score": 0.00753, "epss_percentile": 0.72681}, "CVE-2018-3015": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-3016": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2018-3017": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2018-3018": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2018-3019": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2018-3020": {"epss_score": 0.00301, "epss_percentile": 0.53024}, "CVE-2018-3021": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-3022": {"epss_score": 0.00764, "epss_percentile": 0.72906}, "CVE-2018-3023": {"epss_score": 0.00467, "epss_percentile": 0.63846}, "CVE-2018-3024": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2018-3025": {"epss_score": 0.00555, "epss_percentile": 0.67494}, "CVE-2018-3026": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2018-3027": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-3028": {"epss_score": 0.00301, "epss_percentile": 0.53024}, "CVE-2018-3029": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-3030": {"epss_score": 0.00764, "epss_percentile": 0.72906}, "CVE-2018-3031": {"epss_score": 0.00467, "epss_percentile": 0.63846}, "CVE-2018-3032": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2018-3033": {"epss_score": 0.00555, "epss_percentile": 0.67494}, "CVE-2018-3034": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2018-3035": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-3036": {"epss_score": 0.00301, "epss_percentile": 0.53024}, "CVE-2018-3037": {"epss_score": 0.00301, "epss_percentile": 0.53024}, "CVE-2018-3038": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-3039": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-3040": {"epss_score": 0.00764, "epss_percentile": 0.72906}, "CVE-2018-3041": {"epss_score": 0.00764, "epss_percentile": 0.72906}, "CVE-2018-3042": {"epss_score": 0.00467, "epss_percentile": 0.63846}, "CVE-2018-3043": {"epss_score": 0.00467, "epss_percentile": 0.63846}, "CVE-2018-3044": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2018-3045": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2018-3046": {"epss_score": 0.00555, "epss_percentile": 0.67494}, "CVE-2018-3047": {"epss_score": 0.00555, "epss_percentile": 0.67494}, "CVE-2018-3048": {"epss_score": 0.0034, "epss_percentile": 0.56264}, "CVE-2018-3049": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2018-3050": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-3051": {"epss_score": 0.00969, "epss_percentile": 0.76095}, "CVE-2018-3052": {"epss_score": 0.00338, "epss_percentile": 0.56071}, "CVE-2018-3053": {"epss_score": 0.00338, "epss_percentile": 0.56071}, "CVE-2018-3054": {"epss_score": 0.0041, "epss_percentile": 0.60829}, "CVE-2018-3055": {"epss_score": 0.00391, "epss_percentile": 0.5962}, "CVE-2018-3056": {"epss_score": 0.00408, "epss_percentile": 0.60672}, "CVE-2018-3057": {"epss_score": 0.00093, "epss_percentile": 0.26625}, "CVE-2018-3058": {"epss_score": 0.0016, "epss_percentile": 0.37475}, "CVE-2018-3059": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2018-3060": {"epss_score": 0.00119, "epss_percentile": 0.31566}, "CVE-2018-3061": {"epss_score": 0.00456, "epss_percentile": 0.63337}, "CVE-2018-3062": {"epss_score": 0.00533, "epss_percentile": 0.66716}, "CVE-2018-3063": {"epss_score": 0.00141, "epss_percentile": 0.34917}, "CVE-2018-3064": {"epss_score": 0.00145, "epss_percentile": 0.35524}, "CVE-2018-3065": {"epss_score": 0.00533, "epss_percentile": 0.66716}, "CVE-2018-3066": {"epss_score": 0.00139, "epss_percentile": 0.34618}, "CVE-2018-3067": {"epss_score": 0.00288, "epss_percentile": 0.51937}, "CVE-2018-3068": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3069": {"epss_score": 0.00216, "epss_percentile": 0.44127}, "CVE-2018-3070": {"epss_score": 0.00372, "epss_percentile": 0.5844}, "CVE-2018-3071": {"epss_score": 0.00456, "epss_percentile": 0.63337}, "CVE-2018-3072": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-3073": {"epss_score": 0.00364, "epss_percentile": 0.57951}, "CVE-2018-3074": {"epss_score": 0.00364, "epss_percentile": 0.57951}, "CVE-2018-3075": {"epss_score": 0.00288, "epss_percentile": 0.51937}, "CVE-2018-3076": {"epss_score": 0.00217, "epss_percentile": 0.44267}, "CVE-2018-3077": {"epss_score": 0.0041, "epss_percentile": 0.60829}, "CVE-2018-3078": {"epss_score": 0.00288, "epss_percentile": 0.51937}, "CVE-2018-3079": {"epss_score": 0.00288, "epss_percentile": 0.51937}, "CVE-2018-3080": {"epss_score": 0.00793, "epss_percentile": 0.73435}, "CVE-2018-3081": {"epss_score": 0.00118, "epss_percentile": 0.31464}, "CVE-2018-3082": {"epss_score": 0.00322, "epss_percentile": 0.5483}, "CVE-2018-3084": {"epss_score": 0.00181, "epss_percentile": 0.40098}, "CVE-2018-3085": {"epss_score": 0.00568, "epss_percentile": 0.67879}, "CVE-2018-3086": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3087": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3088": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3089": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3090": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3091": {"epss_score": 0.00246, "epss_percentile": 0.47737}, "CVE-2018-3092": {"epss_score": 0.01618, "epss_percentile": 0.81376}, "CVE-2018-3093": {"epss_score": 0.01618, "epss_percentile": 0.81376}, "CVE-2018-3094": {"epss_score": 0.01618, "epss_percentile": 0.81376}, "CVE-2018-3095": {"epss_score": 0.01618, "epss_percentile": 0.81376}, "CVE-2018-3096": {"epss_score": 0.01618, "epss_percentile": 0.81376}, "CVE-2018-3097": {"epss_score": 0.01618, "epss_percentile": 0.81376}, "CVE-2018-3098": {"epss_score": 0.01618, "epss_percentile": 0.81376}, "CVE-2018-3099": {"epss_score": 0.02106, "epss_percentile": 0.83625}, "CVE-2018-3100": {"epss_score": 0.02197, "epss_percentile": 0.83959}, "CVE-2018-3101": {"epss_score": 0.00689, "epss_percentile": 0.71231}, "CVE-2018-3102": {"epss_score": 0.02106, "epss_percentile": 0.83625}, "CVE-2018-3103": {"epss_score": 0.02106, "epss_percentile": 0.83625}, "CVE-2018-3104": {"epss_score": 0.02106, "epss_percentile": 0.83625}, "CVE-2018-3105": {"epss_score": 0.00197, "epss_percentile": 0.41896}, "CVE-2018-3108": {"epss_score": 0.00555, "epss_percentile": 0.67494}, "CVE-2018-3109": {"epss_score": 0.00753, "epss_percentile": 0.72681}, "CVE-2018-3110": {"epss_score": 0.00804, "epss_percentile": 0.73616}, "CVE-2018-3111": {"epss_score": 0.02279, "epss_percentile": 0.84236}, "CVE-2018-3115": {"epss_score": 0.00919, "epss_percentile": 0.75462}, "CVE-2018-3120": {"epss_score": 0.00737, "epss_percentile": 0.72324}, "CVE-2018-3122": {"epss_score": 0.00643, "epss_percentile": 0.70051}, "CVE-2018-3123": {"epss_score": 0.00643, "epss_percentile": 0.70052}, "CVE-2018-3125": {"epss_score": 0.00496, "epss_percentile": 0.65174}, "CVE-2018-3126": {"epss_score": 0.00655, "epss_percentile": 0.70366}, "CVE-2018-3127": {"epss_score": 0.00702, "epss_percentile": 0.71512}, "CVE-2018-3128": {"epss_score": 0.00643, "epss_percentile": 0.70051}, "CVE-2018-3129": {"epss_score": 0.01111, "epss_percentile": 0.77668}, "CVE-2018-3130": {"epss_score": 0.00198, "epss_percentile": 0.42076}, "CVE-2018-3131": {"epss_score": 0.00107, "epss_percentile": 0.29718}, "CVE-2018-3132": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3133": {"epss_score": 0.00471, "epss_percentile": 0.63996}, "CVE-2018-3134": {"epss_score": 0.00092, "epss_percentile": 0.26489}, "CVE-2018-3135": {"epss_score": 0.01111, "epss_percentile": 0.77668}, "CVE-2018-3136": {"epss_score": 0.00232, "epss_percentile": 0.4586}, "CVE-2018-3137": {"epss_score": 0.00422, "epss_percentile": 0.61552}, "CVE-2018-3138": {"epss_score": 0.0173, "epss_percentile": 0.81986}, "CVE-2018-3139": {"epss_score": 0.00093, "epss_percentile": 0.26714}, "CVE-2018-3140": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3141": {"epss_score": 0.01528, "epss_percentile": 0.80873}, "CVE-2018-3142": {"epss_score": 0.00791, "epss_percentile": 0.73383}, "CVE-2018-3143": {"epss_score": 0.00265, "epss_percentile": 0.4978}, "CVE-2018-3144": {"epss_score": 0.0052, "epss_percentile": 0.66213}, "CVE-2018-3145": {"epss_score": 0.00422, "epss_percentile": 0.61552}, "CVE-2018-3146": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2018-3147": {"epss_score": 0.00701, "epss_percentile": 0.71491}, "CVE-2018-3148": {"epss_score": 0.00511, "epss_percentile": 0.6582}, "CVE-2018-3149": {"epss_score": 0.00344, "epss_percentile": 0.56483}, "CVE-2018-3150": {"epss_score": 0.00783, "epss_percentile": 0.73225}, "CVE-2018-3151": {"epss_score": 0.02462, "epss_percentile": 0.84829}, "CVE-2018-3152": {"epss_score": 0.01519, "epss_percentile": 0.80819}, "CVE-2018-3153": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3154": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3155": {"epss_score": 0.00253, "epss_percentile": 0.4844}, "CVE-2018-3156": {"epss_score": 0.00252, "epss_percentile": 0.48374}, "CVE-2018-3157": {"epss_score": 0.0076, "epss_percentile": 0.72816}, "CVE-2018-3158": {"epss_score": 0.00327, "epss_percentile": 0.55148}, "CVE-2018-3159": {"epss_score": 0.00107, "epss_percentile": 0.29718}, "CVE-2018-3160": {"epss_score": 0.00086, "epss_percentile": 0.25335}, "CVE-2018-3161": {"epss_score": 0.00362, "epss_percentile": 0.57811}, "CVE-2018-3162": {"epss_score": 0.00148, "epss_percentile": 0.35927}, "CVE-2018-3163": {"epss_score": 0.00947, "epss_percentile": 0.75824}, "CVE-2018-3164": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3165": {"epss_score": 0.02251, "epss_percentile": 0.8416}, "CVE-2018-3166": {"epss_score": 0.0027, "epss_percentile": 0.5024}, "CVE-2018-3167": {"epss_score": 0.68033, "epss_percentile": 0.98528}, "CVE-2018-3168": {"epss_score": 0.00247, "epss_percentile": 0.47888}, "CVE-2018-3169": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2018-3170": {"epss_score": 0.00325, "epss_percentile": 0.5499}, "CVE-2018-3171": {"epss_score": 0.0041, "epss_percentile": 0.60829}, "CVE-2018-3172": {"epss_score": 0.02629, "epss_percentile": 0.85276}, "CVE-2018-3173": {"epss_score": 0.00166, "epss_percentile": 0.38253}, "CVE-2018-3174": {"epss_score": 0.00031, "epss_percentile": 0.08325}, "CVE-2018-3175": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3176": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3177": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3178": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3179": {"epss_score": 0.00699, "epss_percentile": 0.71447}, "CVE-2018-3180": {"epss_score": 0.00085, "epss_percentile": 0.25057}, "CVE-2018-3181": {"epss_score": 0.0015, "epss_percentile": 0.36127}, "CVE-2018-3182": {"epss_score": 0.00422, "epss_percentile": 0.61552}, "CVE-2018-3183": {"epss_score": 0.00697, "epss_percentile": 0.71414}, "CVE-2018-3184": {"epss_score": 0.00249, "epss_percentile": 0.48038}, "CVE-2018-3185": {"epss_score": 0.00111, "epss_percentile": 0.30303}, "CVE-2018-3186": {"epss_score": 0.00325, "epss_percentile": 0.5499}, "CVE-2018-3187": {"epss_score": 0.00138, "epss_percentile": 0.34367}, "CVE-2018-3188": {"epss_score": 0.01685, "epss_percentile": 0.81749}, "CVE-2018-3189": {"epss_score": 0.0173, "epss_percentile": 0.81986}, "CVE-2018-3190": {"epss_score": 0.0173, "epss_percentile": 0.81986}, "CVE-2018-3191": {"epss_score": 0.92002, "epss_percentile": 0.99685}, "CVE-2018-3192": {"epss_score": 0.02251, "epss_percentile": 0.8416}, "CVE-2018-3193": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3194": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3195": {"epss_score": 0.00343, "epss_percentile": 0.56402}, "CVE-2018-3196": {"epss_score": 0.0173, "epss_percentile": 0.81986}, "CVE-2018-3197": {"epss_score": 0.07783, "epss_percentile": 0.91679}, "CVE-2018-3198": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-3200": {"epss_score": 0.00166, "epss_percentile": 0.38253}, "CVE-2018-3201": {"epss_score": 0.07783, "epss_percentile": 0.91679}, "CVE-2018-3202": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-3203": {"epss_score": 0.00364, "epss_percentile": 0.57951}, "CVE-2018-3204": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2018-3205": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3206": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3207": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3208": {"epss_score": 0.00791, "epss_percentile": 0.73383}, "CVE-2018-3209": {"epss_score": 0.01242, "epss_percentile": 0.78824}, "CVE-2018-3210": {"epss_score": 0.00572, "epss_percentile": 0.68018}, "CVE-2018-3211": {"epss_score": 0.00187, "epss_percentile": 0.40711}, "CVE-2018-3212": {"epss_score": 0.00325, "epss_percentile": 0.5499}, "CVE-2018-3213": {"epss_score": 0.01962, "epss_percentile": 0.83066}, "CVE-2018-3214": {"epss_score": 0.00431, "epss_percentile": 0.6206}, "CVE-2018-3215": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2018-3217": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2018-3218": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2018-3219": {"epss_score": 0.02416, "epss_percentile": 0.8469}, "CVE-2018-3220": {"epss_score": 0.02416, "epss_percentile": 0.8469}, "CVE-2018-3221": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3222": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3223": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3224": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3225": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3226": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3227": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3228": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3229": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3230": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3231": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3232": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3233": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3234": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3235": {"epss_score": 0.0173, "epss_percentile": 0.81986}, "CVE-2018-3236": {"epss_score": 0.01165, "epss_percentile": 0.7817}, "CVE-2018-3237": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-3238": {"epss_score": 0.30481, "epss_percentile": 0.96544}, "CVE-2018-3239": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-3241": {"epss_score": 0.00511, "epss_percentile": 0.6582}, "CVE-2018-3242": {"epss_score": 0.0173, "epss_percentile": 0.81986}, "CVE-2018-3243": {"epss_score": 0.0173, "epss_percentile": 0.81986}, "CVE-2018-3244": {"epss_score": 0.01528, "epss_percentile": 0.80873}, "CVE-2018-3245": {"epss_score": 0.91765, "epss_percentile": 0.99667}, "CVE-2018-3246": {"epss_score": 0.03242, "epss_percentile": 0.86735}, "CVE-2018-3247": {"epss_score": 0.00143, "epss_percentile": 0.35186}, "CVE-2018-3248": {"epss_score": 0.03082, "epss_percentile": 0.86374}, "CVE-2018-3249": {"epss_score": 0.00964, "epss_percentile": 0.76024}, "CVE-2018-3250": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2018-3251": {"epss_score": 0.00388, "epss_percentile": 0.59359}, "CVE-2018-3252": {"epss_score": 0.85731, "epss_percentile": 0.99346}, "CVE-2018-3253": {"epss_score": 0.00774, "epss_percentile": 0.73072}, "CVE-2018-3254": {"epss_score": 0.00848, "epss_percentile": 0.74354}, "CVE-2018-3255": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3256": {"epss_score": 0.01111, "epss_percentile": 0.77668}, "CVE-2018-3257": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3258": {"epss_score": 0.04867, "epss_percentile": 0.89229}, "CVE-2018-3259": {"epss_score": 0.05822, "epss_percentile": 0.90235}, "CVE-2018-3261": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-3262": {"epss_score": 0.01111, "epss_percentile": 0.77668}, "CVE-2018-3263": {"epss_score": 0.00504, "epss_percentile": 0.65549}, "CVE-2018-3264": {"epss_score": 0.0008, "epss_percentile": 0.24201}, "CVE-2018-3265": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2018-3266": {"epss_score": 0.00071, "epss_percentile": 0.2207}, "CVE-2018-3267": {"epss_score": 0.00564, "epss_percentile": 0.67764}, "CVE-2018-3268": {"epss_score": 0.02629, "epss_percentile": 0.85276}, "CVE-2018-3269": {"epss_score": 0.00505, "epss_percentile": 0.65612}, "CVE-2018-3270": {"epss_score": 0.00138, "epss_percentile": 0.34387}, "CVE-2018-3271": {"epss_score": 0.00103, "epss_percentile": 0.29068}, "CVE-2018-3272": {"epss_score": 0.00231, "epss_percentile": 0.45808}, "CVE-2018-3273": {"epss_score": 0.03159, "epss_percentile": 0.86528}, "CVE-2018-3274": {"epss_score": 0.00451, "epss_percentile": 0.63113}, "CVE-2018-3275": {"epss_score": 0.02538, "epss_percentile": 0.85043}, "CVE-2018-3276": {"epss_score": 0.00138, "epss_percentile": 0.34367}, "CVE-2018-3277": {"epss_score": 0.00166, "epss_percentile": 0.38253}, "CVE-2018-3278": {"epss_score": 0.00138, "epss_percentile": 0.34367}, "CVE-2018-3279": {"epss_score": 0.00325, "epss_percentile": 0.5499}, "CVE-2018-3280": {"epss_score": 0.00325, "epss_percentile": 0.5499}, "CVE-2018-3281": {"epss_score": 0.00511, "epss_percentile": 0.6582}, "CVE-2018-3282": {"epss_score": 0.0014, "epss_percentile": 0.34729}, "CVE-2018-3283": {"epss_score": 0.0041, "epss_percentile": 0.60829}, "CVE-2018-3284": {"epss_score": 0.00226, "epss_percentile": 0.45314}, "CVE-2018-3285": {"epss_score": 0.00325, "epss_percentile": 0.5499}, "CVE-2018-3286": {"epss_score": 0.00324, "epss_percentile": 0.54969}, "CVE-2018-3287": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3288": {"epss_score": 0.00444, "epss_percentile": 0.62818}, "CVE-2018-3289": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3290": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3291": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3292": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3293": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3294": {"epss_score": 0.0054, "epss_percentile": 0.67001}, "CVE-2018-3295": {"epss_score": 0.11289, "epss_percentile": 0.93294}, "CVE-2018-3296": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3297": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3298": {"epss_score": 0.0045, "epss_percentile": 0.63085}, "CVE-2018-3299": {"epss_score": 0.01988, "epss_percentile": 0.83166}, "CVE-2018-3300": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2018-3301": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2018-3302": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2018-3303": {"epss_score": 0.00496, "epss_percentile": 0.65174}, "CVE-2018-3304": {"epss_score": 0.01286, "epss_percentile": 0.79186}, "CVE-2018-3305": {"epss_score": 0.00284, "epss_percentile": 0.51443}, "CVE-2018-3309": {"epss_score": 0.00149, "epss_percentile": 0.36008}, "CVE-2018-3311": {"epss_score": 0.01982, "epss_percentile": 0.8314}, "CVE-2018-3312": {"epss_score": 0.00279, "epss_percentile": 0.5094}, "CVE-2018-3314": {"epss_score": 0.00711, "epss_percentile": 0.71734}, "CVE-2018-3315": {"epss_score": 0.00715, "epss_percentile": 0.71832}, "CVE-2018-3316": {"epss_score": 0.00754, "epss_percentile": 0.72696}, "CVE-2018-3560": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2018-3561": {"epss_score": 0.00015, "epss_percentile": 0.02299}, "CVE-2018-3562": {"epss_score": 0.00121, "epss_percentile": 0.31938}, "CVE-2018-3563": {"epss_score": 0.00087, "epss_percentile": 0.25595}, "CVE-2018-3564": {"epss_score": 0.00064, "epss_percentile": 0.20265}, "CVE-2018-3565": {"epss_score": 0.00107, "epss_percentile": 0.29586}, "CVE-2018-3566": {"epss_score": 0.00083, "epss_percentile": 0.247}, "CVE-2018-3567": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2018-3568": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2018-3569": {"epss_score": 0.00069, "epss_percentile": 0.21473}, "CVE-2018-3570": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2018-3571": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2018-3572": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2018-3573": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2018-3574": {"epss_score": 0.00047, "epss_percentile": 0.14876}, "CVE-2018-3576": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2018-3577": {"epss_score": 0.00258, "epss_percentile": 0.49017}, "CVE-2018-3578": {"epss_score": 0.00172, "epss_percentile": 0.39039}, "CVE-2018-3579": {"epss_score": 0.0004, "epss_percentile": 0.12083}, "CVE-2018-3580": {"epss_score": 0.00107, "epss_percentile": 0.29586}, "CVE-2018-3581": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2018-3582": {"epss_score": 0.00056, "epss_percentile": 0.17711}, "CVE-2018-3583": {"epss_score": 0.00037, "epss_percentile": 0.10966}, "CVE-2018-3584": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2018-3586": {"epss_score": 0.00195, "epss_percentile": 0.41635}, "CVE-2018-3587": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2018-3588": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2018-3589": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2018-3590": {"epss_score": 0.00242, "epss_percentile": 0.47371}, "CVE-2018-3591": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2018-3592": {"epss_score": 0.00177, "epss_percentile": 0.39524}, "CVE-2018-3593": {"epss_score": 0.00206, "epss_percentile": 0.43029}, "CVE-2018-3594": {"epss_score": 0.00247, "epss_percentile": 0.47861}, "CVE-2018-3595": {"epss_score": 0.00055, "epss_percentile": 0.17569}, "CVE-2018-3596": {"epss_score": 0.0014, "epss_percentile": 0.34691}, "CVE-2018-3597": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2018-3598": {"epss_score": 0.00117, "epss_percentile": 0.31255}, "CVE-2018-3599": {"epss_score": 0.00164, "epss_percentile": 0.37911}, "CVE-2018-3600": {"epss_score": 0.00305, "epss_percentile": 0.53375}, "CVE-2018-3601": {"epss_score": 0.03274, "epss_percentile": 0.86799}, "CVE-2018-3602": {"epss_score": 0.04554, "epss_percentile": 0.88843}, "CVE-2018-3603": {"epss_score": 0.04554, "epss_percentile": 0.88843}, "CVE-2018-3604": {"epss_score": 0.2232, "epss_percentile": 0.95623}, "CVE-2018-3605": {"epss_score": 0.09079, "epss_percentile": 0.92391}, "CVE-2018-3606": {"epss_score": 0.21839, "epss_percentile": 0.95566}, "CVE-2018-3607": {"epss_score": 0.09919, "epss_percentile": 0.9277}, "CVE-2018-3608": {"epss_score": 0.03863, "epss_percentile": 0.87868}, "CVE-2018-3609": {"epss_score": 0.16268, "epss_percentile": 0.94606}, "CVE-2018-3610": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2018-3611": {"epss_score": 0.00272, "epss_percentile": 0.50412}, "CVE-2018-3612": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2018-3613": {"epss_score": 0.00096, "epss_percentile": 0.27404}, "CVE-2018-3615": {"epss_score": 0.01369, "epss_percentile": 0.79796}, "CVE-2018-3616": {"epss_score": 0.0155, "epss_percentile": 0.80986}, "CVE-2018-3619": {"epss_score": 0.00035, "epss_percentile": 0.10122}, "CVE-2018-3620": {"epss_score": 0.03037, "epss_percentile": 0.86265}, "CVE-2018-3621": {"epss_score": 0.00096, "epss_percentile": 0.2733}, "CVE-2018-3624": {"epss_score": 0.00521, "epss_percentile": 0.66228}, "CVE-2018-3626": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2018-3627": {"epss_score": 0.00288, "epss_percentile": 0.51917}, "CVE-2018-3628": {"epss_score": 0.01013, "epss_percentile": 0.76636}, "CVE-2018-3629": {"epss_score": 0.0045, "epss_percentile": 0.63065}, "CVE-2018-3632": {"epss_score": 0.00076, "epss_percentile": 0.23129}, "CVE-2018-3634": {"epss_score": 0.00052, "epss_percentile": 0.16554}, "CVE-2018-3635": {"epss_score": 0.00062, "epss_percentile": 0.19674}, "CVE-2018-3638": {"epss_score": 0.00041, "epss_percentile": 0.1242}, "CVE-2018-3639": {"epss_score": 0.39094, "epss_percentile": 0.97137}, "CVE-2018-3640": {"epss_score": 0.00902, "epss_percentile": 0.75186}, "CVE-2018-3641": {"epss_score": 0.00425, "epss_percentile": 0.61709}, "CVE-2018-3643": {"epss_score": 0.00167, "epss_percentile": 0.38328}, "CVE-2018-3645": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2018-3646": {"epss_score": 0.03877, "epss_percentile": 0.87892}, "CVE-2018-3649": {"epss_score": 0.00162, "epss_percentile": 0.37655}, "CVE-2018-3650": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2018-3652": {"epss_score": 0.00145, "epss_percentile": 0.35411}, "CVE-2018-3655": {"epss_score": 0.00173, "epss_percentile": 0.3907}, "CVE-2018-3657": {"epss_score": 0.00264, "epss_percentile": 0.49582}, "CVE-2018-3658": {"epss_score": 0.01128, "epss_percentile": 0.77832}, "CVE-2018-3659": {"epss_score": 0.00411, "epss_percentile": 0.60868}, "CVE-2018-3661": {"epss_score": 0.00049, "epss_percentile": 0.1534}, "CVE-2018-3662": {"epss_score": 0.00136, "epss_percentile": 0.34153}, "CVE-2018-3663": {"epss_score": 0.00091, "epss_percentile": 0.26386}, "CVE-2018-3665": {"epss_score": 0.01258, "epss_percentile": 0.78954}, "CVE-2018-3666": {"epss_score": 0.00041, "epss_percentile": 0.1242}, "CVE-2018-3667": {"epss_score": 0.00052, "epss_percentile": 0.1635}, "CVE-2018-3668": {"epss_score": 0.00054, "epss_percentile": 0.17088}, "CVE-2018-3669": {"epss_score": 0.00433, "epss_percentile": 0.6218}, "CVE-2018-3670": {"epss_score": 0.00044, "epss_percentile": 0.13446}, "CVE-2018-3671": {"epss_score": 0.00091, "epss_percentile": 0.26386}, "CVE-2018-3672": {"epss_score": 0.00041, "epss_percentile": 0.1242}, "CVE-2018-3679": {"epss_score": 0.00376, "epss_percentile": 0.58666}, "CVE-2018-3682": {"epss_score": 0.00047, "epss_percentile": 0.1477}, "CVE-2018-3683": {"epss_score": 0.00057, "epss_percentile": 0.18151}, "CVE-2018-3684": {"epss_score": 0.00057, "epss_percentile": 0.18151}, "CVE-2018-3686": {"epss_score": 0.00163, "epss_percentile": 0.37759}, "CVE-2018-3687": {"epss_score": 0.00057, "epss_percentile": 0.18151}, "CVE-2018-3688": {"epss_score": 0.00057, "epss_percentile": 0.18151}, "CVE-2018-3689": {"epss_score": 0.00045, "epss_percentile": 0.13765}, "CVE-2018-3691": {"epss_score": 0.00062, "epss_percentile": 0.19714}, "CVE-2018-3693": {"epss_score": 0.00916, "epss_percentile": 0.75413}, "CVE-2018-3696": {"epss_score": 0.00212, "epss_percentile": 0.43776}, "CVE-2018-3697": {"epss_score": 0.00037, "epss_percentile": 0.10909}, "CVE-2018-3698": {"epss_score": 0.0005, "epss_percentile": 0.15765}, "CVE-2018-3699": {"epss_score": 0.00299, "epss_percentile": 0.52893}, "CVE-2018-3700": {"epss_score": 0.00137, "epss_percentile": 0.3422}, "CVE-2018-3701": {"epss_score": 0.00068, "epss_percentile": 0.21304}, "CVE-2018-3702": {"epss_score": 0.00043, "epss_percentile": 0.1306}, "CVE-2018-3703": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2018-3704": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2018-3705": {"epss_score": 0.00033, "epss_percentile": 0.09158}, "CVE-2018-3710": {"epss_score": 0.05239, "epss_percentile": 0.8965}, "CVE-2018-3711": {"epss_score": 0.00776, "epss_percentile": 0.73098}, "CVE-2018-3712": {"epss_score": 0.00678, "epss_percentile": 0.70982}, "CVE-2018-3713": {"epss_score": 0.0063, "epss_percentile": 0.69701}, "CVE-2018-3714": {"epss_score": 0.74418, "epss_percentile": 0.98798}, "CVE-2018-3715": {"epss_score": 0.00316, "epss_percentile": 0.54244}, "CVE-2018-3716": {"epss_score": 0.00302, "epss_percentile": 0.53159}, "CVE-2018-3717": {"epss_score": 0.00332, "epss_percentile": 0.5559}, "CVE-2018-3718": {"epss_score": 0.00243, "epss_percentile": 0.4741}, "CVE-2018-3719": {"epss_score": 0.00639, "epss_percentile": 0.69944}, "CVE-2018-3720": {"epss_score": 0.00674, "epss_percentile": 0.70877}, "CVE-2018-3721": {"epss_score": 0.00165, "epss_percentile": 0.3801}, "CVE-2018-3722": {"epss_score": 0.0047, "epss_percentile": 0.63963}, "CVE-2018-3723": {"epss_score": 0.0043, "epss_percentile": 0.62006}, "CVE-2018-3724": {"epss_score": 0.00529, "epss_percentile": 0.66578}, "CVE-2018-3725": {"epss_score": 0.00607, "epss_percentile": 0.69049}, "CVE-2018-3726": {"epss_score": 0.00491, "epss_percentile": 0.64959}, "CVE-2018-3727": {"epss_score": 0.00607, "epss_percentile": 0.69049}, "CVE-2018-3728": {"epss_score": 0.01675, "epss_percentile": 0.81699}, "CVE-2018-3729": {"epss_score": 0.00754, "epss_percentile": 0.72692}, "CVE-2018-3730": {"epss_score": 0.00607, "epss_percentile": 0.69049}, "CVE-2018-3731": {"epss_score": 0.00607, "epss_percentile": 0.69049}, "CVE-2018-3732": {"epss_score": 0.00663, "epss_percentile": 0.70619}, "CVE-2018-3733": {"epss_score": 0.00368, "epss_percentile": 0.58176}, "CVE-2018-3734": {"epss_score": 0.00565, "epss_percentile": 0.67781}, "CVE-2018-3735": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2018-3737": {"epss_score": 0.00562, "epss_percentile": 0.67694}, "CVE-2018-3738": {"epss_score": 0.00385, "epss_percentile": 0.59229}, "CVE-2018-3739": {"epss_score": 0.00431, "epss_percentile": 0.62037}, "CVE-2018-3740": {"epss_score": 0.00251, "epss_percentile": 0.48312}, "CVE-2018-3741": {"epss_score": 0.00476, "epss_percentile": 0.64282}, "CVE-2018-3743": {"epss_score": 0.0032, "epss_percentile": 0.54622}, "CVE-2018-3744": {"epss_score": 0.00634, "epss_percentile": 0.69793}, "CVE-2018-3745": {"epss_score": 0.00968, "epss_percentile": 0.76088}, "CVE-2018-3746": {"epss_score": 0.02299, "epss_percentile": 0.84307}, "CVE-2018-3747": {"epss_score": 0.00268, "epss_percentile": 0.5006}, "CVE-2018-3748": {"epss_score": 0.00268, "epss_percentile": 0.5006}, "CVE-2018-3749": {"epss_score": 0.00332, "epss_percentile": 0.55593}, "CVE-2018-3750": {"epss_score": 0.00405, "epss_percentile": 0.60459}, "CVE-2018-3751": {"epss_score": 0.00332, "epss_percentile": 0.55593}, "CVE-2018-3752": {"epss_score": 0.00363, "epss_percentile": 0.57869}, "CVE-2018-3753": {"epss_score": 0.00332, "epss_percentile": 0.55593}, "CVE-2018-3754": {"epss_score": 0.00248, "epss_percentile": 0.47907}, "CVE-2018-3755": {"epss_score": 0.00449, "epss_percentile": 0.63054}, "CVE-2018-3756": {"epss_score": 0.0011, "epss_percentile": 0.30228}, "CVE-2018-3757": {"epss_score": 0.07956, "epss_percentile": 0.91788}, "CVE-2018-3758": {"epss_score": 0.06567, "epss_percentile": 0.90851}, "CVE-2018-3759": {"epss_score": 0.0018, "epss_percentile": 0.39887}, "CVE-2018-3760": {"epss_score": 0.93911, "epss_percentile": 0.99867}, "CVE-2018-3761": {"epss_score": 0.00571, "epss_percentile": 0.67985}, "CVE-2018-3762": {"epss_score": 0.00425, "epss_percentile": 0.6169}, "CVE-2018-3763": {"epss_score": 0.00348, "epss_percentile": 0.56815}, "CVE-2018-3764": {"epss_score": 0.00348, "epss_percentile": 0.56815}, "CVE-2018-3766": {"epss_score": 0.00595, "epss_percentile": 0.68691}, "CVE-2018-3767": {"epss_score": 0.00407, "epss_percentile": 0.60608}, "CVE-2018-3769": {"epss_score": 0.00398, "epss_percentile": 0.60064}, "CVE-2018-3770": {"epss_score": 0.0027, "epss_percentile": 0.50248}, "CVE-2018-3771": {"epss_score": 0.00387, "epss_percentile": 0.59337}, "CVE-2018-3772": {"epss_score": 0.00622, "epss_percentile": 0.69506}, "CVE-2018-3773": {"epss_score": 0.00449, "epss_percentile": 0.63054}, "CVE-2018-3774": {"epss_score": 0.00971, "epss_percentile": 0.7612}, "CVE-2018-3775": {"epss_score": 0.00185, "epss_percentile": 0.40552}, "CVE-2018-3776": {"epss_score": 0.0055, "epss_percentile": 0.67324}, "CVE-2018-3777": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2018-3778": {"epss_score": 0.00332, "epss_percentile": 0.55553}, "CVE-2018-3779": {"epss_score": 0.05117, "epss_percentile": 0.89515}, "CVE-2018-3780": {"epss_score": 0.00543, "epss_percentile": 0.67099}, "CVE-2018-3781": {"epss_score": 0.0039, "epss_percentile": 0.5952}, "CVE-2018-3783": {"epss_score": 0.04398, "epss_percentile": 0.88643}, "CVE-2018-3784": {"epss_score": 0.00606, "epss_percentile": 0.69002}, "CVE-2018-3785": {"epss_score": 0.03575, "epss_percentile": 0.87378}, "CVE-2018-3786": {"epss_score": 0.10474, "epss_percentile": 0.92998}, "CVE-2018-3787": {"epss_score": 0.0064, "epss_percentile": 0.69955}, "CVE-2018-3809": {"epss_score": 0.00222, "epss_percentile": 0.44746}, "CVE-2018-3810": {"epss_score": 0.92243, "epss_percentile": 0.99702}, "CVE-2018-3811": {"epss_score": 0.31405, "epss_percentile": 0.96618}, "CVE-2018-3813": {"epss_score": 0.00418, "epss_percentile": 0.61284}, "CVE-2018-3814": {"epss_score": 0.00698, "epss_percentile": 0.71425}, "CVE-2018-3815": {"epss_score": 0.00238, "epss_percentile": 0.46759}, "CVE-2018-3817": {"epss_score": 0.00294, "epss_percentile": 0.52426}, "CVE-2018-3818": {"epss_score": 0.00375, "epss_percentile": 0.58618}, "CVE-2018-3819": {"epss_score": 0.00213, "epss_percentile": 0.43841}, "CVE-2018-3820": {"epss_score": 0.00353, "epss_percentile": 0.57157}, "CVE-2018-3821": {"epss_score": 0.00375, "epss_percentile": 0.58618}, "CVE-2018-3822": {"epss_score": 0.00468, "epss_percentile": 0.63875}, "CVE-2018-3823": {"epss_score": 0.00202, "epss_percentile": 0.42461}, "CVE-2018-3824": {"epss_score": 0.00271, "epss_percentile": 0.50303}, "CVE-2018-3825": {"epss_score": 0.00129, "epss_percentile": 0.33158}, "CVE-2018-3826": {"epss_score": 0.004, "epss_percentile": 0.6018}, "CVE-2018-3827": {"epss_score": 0.00312, "epss_percentile": 0.53951}, "CVE-2018-3828": {"epss_score": 0.0019, "epss_percentile": 0.41127}, "CVE-2018-3829": {"epss_score": 0.0022, "epss_percentile": 0.4457}, "CVE-2018-3830": {"epss_score": 0.00713, "epss_percentile": 0.71784}, "CVE-2018-3831": {"epss_score": 0.00861, "epss_percentile": 0.74545}, "CVE-2018-3832": {"epss_score": 0.00425, "epss_percentile": 0.61699}, "CVE-2018-3833": {"epss_score": 0.00499, "epss_percentile": 0.65248}, "CVE-2018-3834": {"epss_score": 0.00217, "epss_percentile": 0.4429}, "CVE-2018-3835": {"epss_score": 0.00569, "epss_percentile": 0.67914}, "CVE-2018-3836": {"epss_score": 0.00106, "epss_percentile": 0.29563}, "CVE-2018-3837": {"epss_score": 0.00354, "epss_percentile": 0.57206}, "CVE-2018-3838": {"epss_score": 0.00424, "epss_percentile": 0.61681}, "CVE-2018-3839": {"epss_score": 0.01163, "epss_percentile": 0.78156}, "CVE-2018-3840": {"epss_score": 0.00305, "epss_percentile": 0.53354}, "CVE-2018-3841": {"epss_score": 0.00307, "epss_percentile": 0.53517}, "CVE-2018-3842": {"epss_score": 0.02613, "epss_percentile": 0.85239}, "CVE-2018-3843": {"epss_score": 0.38075, "epss_percentile": 0.97085}, "CVE-2018-3844": {"epss_score": 0.00123, "epss_percentile": 0.32327}, "CVE-2018-3845": {"epss_score": 0.00538, "epss_percentile": 0.66938}, "CVE-2018-3846": {"epss_score": 0.0095, "epss_percentile": 0.75856}, "CVE-2018-3847": {"epss_score": 0.00414, "epss_percentile": 0.61091}, "CVE-2018-3848": {"epss_score": 0.01312, "epss_percentile": 0.79374}, "CVE-2018-3849": {"epss_score": 0.00869, "epss_percentile": 0.74688}, "CVE-2018-3850": {"epss_score": 0.03355, "epss_percentile": 0.86971}, "CVE-2018-3851": {"epss_score": 0.01065, "epss_percentile": 0.7721}, "CVE-2018-3852": {"epss_score": 0.00381, "epss_percentile": 0.59}, "CVE-2018-3853": {"epss_score": 0.05742, "epss_percentile": 0.90172}, "CVE-2018-3854": {"epss_score": 0.00056, "epss_percentile": 0.17953}, "CVE-2018-3855": {"epss_score": 0.0031, "epss_percentile": 0.53807}, "CVE-2018-3856": {"epss_score": 0.05048, "epss_percentile": 0.89437}, "CVE-2018-3857": {"epss_score": 0.00653, "epss_percentile": 0.70326}, "CVE-2018-3858": {"epss_score": 0.00653, "epss_percentile": 0.70326}, "CVE-2018-3859": {"epss_score": 0.00416, "epss_percentile": 0.6119}, "CVE-2018-3860": {"epss_score": 0.00416, "epss_percentile": 0.6119}, "CVE-2018-3861": {"epss_score": 0.00435, "epss_percentile": 0.62348}, "CVE-2018-3862": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-3863": {"epss_score": 0.00402, "epss_percentile": 0.60266}, "CVE-2018-3864": {"epss_score": 0.00377, "epss_percentile": 0.58752}, "CVE-2018-3865": {"epss_score": 0.00377, "epss_percentile": 0.58752}, "CVE-2018-3866": {"epss_score": 0.00483, "epss_percentile": 0.64595}, "CVE-2018-3867": {"epss_score": 0.00402, "epss_percentile": 0.60266}, "CVE-2018-3868": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2018-3870": {"epss_score": 0.00335, "epss_percentile": 0.55851}, "CVE-2018-3871": {"epss_score": 0.00335, "epss_percentile": 0.55851}, "CVE-2018-3872": {"epss_score": 0.00402, "epss_percentile": 0.60266}, "CVE-2018-3873": {"epss_score": 0.00377, "epss_percentile": 0.58752}, "CVE-2018-3874": {"epss_score": 0.00402, "epss_percentile": 0.60266}, "CVE-2018-3875": {"epss_score": 0.0039, "epss_percentile": 0.59542}, "CVE-2018-3876": {"epss_score": 0.0039, "epss_percentile": 0.59542}, "CVE-2018-3877": {"epss_score": 0.00377, "epss_percentile": 0.58752}, "CVE-2018-3878": {"epss_score": 0.0039, "epss_percentile": 0.59542}, "CVE-2018-3879": {"epss_score": 0.00171, "epss_percentile": 0.38863}, "CVE-2018-3880": {"epss_score": 0.00201, "epss_percentile": 0.42326}, "CVE-2018-3881": {"epss_score": 0.01975, "epss_percentile": 0.83117}, "CVE-2018-3882": {"epss_score": 0.00361, "epss_percentile": 0.57712}, "CVE-2018-3883": {"epss_score": 0.00361, "epss_percentile": 0.57712}, "CVE-2018-3884": {"epss_score": 0.00361, "epss_percentile": 0.57712}, "CVE-2018-3885": {"epss_score": 0.00361, "epss_percentile": 0.57712}, "CVE-2018-3886": {"epss_score": 0.00416, "epss_percentile": 0.6119}, "CVE-2018-3887": {"epss_score": 0.00416, "epss_percentile": 0.6119}, "CVE-2018-3888": {"epss_score": 0.00416, "epss_percentile": 0.6119}, "CVE-2018-3889": {"epss_score": 0.0035, "epss_percentile": 0.56961}, "CVE-2018-3890": {"epss_score": 0.00374, "epss_percentile": 0.5856}, "CVE-2018-3891": {"epss_score": 0.00127, "epss_percentile": 0.32849}, "CVE-2018-3892": {"epss_score": 0.01614, "epss_percentile": 0.81344}, "CVE-2018-3893": {"epss_score": 0.00402, "epss_percentile": 0.60266}, "CVE-2018-3894": {"epss_score": 0.00402, "epss_percentile": 0.60266}, "CVE-2018-3895": {"epss_score": 0.00402, "epss_percentile": 0.60266}, "CVE-2018-3896": {"epss_score": 0.00402, "epss_percentile": 0.60266}, "CVE-2018-3897": {"epss_score": 0.00402, "epss_percentile": 0.60266}, "CVE-2018-3898": {"epss_score": 0.00585, "epss_percentile": 0.68403}, "CVE-2018-3899": {"epss_score": 0.00725, "epss_percentile": 0.72059}, "CVE-2018-3900": {"epss_score": 0.00846, "epss_percentile": 0.74329}, "CVE-2018-3902": {"epss_score": 0.00377, "epss_percentile": 0.58752}, "CVE-2018-3903": {"epss_score": 0.0039, "epss_percentile": 0.59542}, "CVE-2018-3904": {"epss_score": 0.00377, "epss_percentile": 0.58752}, "CVE-2018-3905": {"epss_score": 0.00377, "epss_percentile": 0.58752}, "CVE-2018-3906": {"epss_score": 0.00148, "epss_percentile": 0.35887}, "CVE-2018-3907": {"epss_score": 0.0048, "epss_percentile": 0.64471}, "CVE-2018-3908": {"epss_score": 0.00425, "epss_percentile": 0.61716}, "CVE-2018-3909": {"epss_score": 0.00425, "epss_percentile": 0.61716}, "CVE-2018-3910": {"epss_score": 0.00144, "epss_percentile": 0.35322}, "CVE-2018-3911": {"epss_score": 0.00643, "epss_percentile": 0.70055}, "CVE-2018-3912": {"epss_score": 0.00152, "epss_percentile": 0.36465}, "CVE-2018-3913": {"epss_score": 0.00142, "epss_percentile": 0.34982}, "CVE-2018-3914": {"epss_score": 0.00172, "epss_percentile": 0.39039}, "CVE-2018-3915": {"epss_score": 0.00053, "epss_percentile": 0.17028}, "CVE-2018-3916": {"epss_score": 0.00161, "epss_percentile": 0.37521}, "CVE-2018-3917": {"epss_score": 0.00332, "epss_percentile": 0.55598}, "CVE-2018-3918": {"epss_score": 0.00755, "epss_percentile": 0.72719}, "CVE-2018-3919": {"epss_score": 0.00298, "epss_percentile": 0.52788}, "CVE-2018-3920": {"epss_score": 0.00132, "epss_percentile": 0.33556}, "CVE-2018-3921": {"epss_score": 0.0055, "epss_percentile": 0.6733}, "CVE-2018-3922": {"epss_score": 0.00526, "epss_percentile": 0.66427}, "CVE-2018-3923": {"epss_score": 0.00315, "epss_percentile": 0.54173}, "CVE-2018-3924": {"epss_score": 0.48335, "epss_percentile": 0.97631}, "CVE-2018-3925": {"epss_score": 0.00419, "epss_percentile": 0.6137}, "CVE-2018-3926": {"epss_score": 0.00163, "epss_percentile": 0.3777}, "CVE-2018-3927": {"epss_score": 0.00371, "epss_percentile": 0.58409}, "CVE-2018-3928": {"epss_score": 0.00547, "epss_percentile": 0.67256}, "CVE-2018-3929": {"epss_score": 0.01672, "epss_percentile": 0.81679}, "CVE-2018-3930": {"epss_score": 0.01123, "epss_percentile": 0.7779}, "CVE-2018-3931": {"epss_score": 0.01672, "epss_percentile": 0.81679}, "CVE-2018-3932": {"epss_score": 0.01429, "epss_percentile": 0.80226}, "CVE-2018-3933": {"epss_score": 0.00773, "epss_percentile": 0.73054}, "CVE-2018-3934": {"epss_score": 0.00224, "epss_percentile": 0.45026}, "CVE-2018-3935": {"epss_score": 0.00441, "epss_percentile": 0.62665}, "CVE-2018-3936": {"epss_score": 0.00773, "epss_percentile": 0.73054}, "CVE-2018-3937": {"epss_score": 0.04098, "epss_percentile": 0.88255}, "CVE-2018-3938": {"epss_score": 0.02547, "epss_percentile": 0.85064}, "CVE-2018-3939": {"epss_score": 0.12954, "epss_percentile": 0.93829}, "CVE-2018-3940": {"epss_score": 0.02803, "epss_percentile": 0.85702}, "CVE-2018-3941": {"epss_score": 0.00268, "epss_percentile": 0.50092}, "CVE-2018-3942": {"epss_score": 0.00268, "epss_percentile": 0.50092}, "CVE-2018-3943": {"epss_score": 0.003, "epss_percentile": 0.52955}, "CVE-2018-3944": {"epss_score": 0.003, "epss_percentile": 0.52955}, "CVE-2018-3945": {"epss_score": 0.00271, "epss_percentile": 0.50303}, "CVE-2018-3946": {"epss_score": 0.00268, "epss_percentile": 0.50092}, "CVE-2018-3947": {"epss_score": 0.00502, "epss_percentile": 0.65396}, "CVE-2018-3948": {"epss_score": 0.03357, "epss_percentile": 0.86977}, "CVE-2018-3949": {"epss_score": 0.23382, "epss_percentile": 0.95772}, "CVE-2018-3950": {"epss_score": 0.05642, "epss_percentile": 0.90078}, "CVE-2018-3951": {"epss_score": 0.10156, "epss_percentile": 0.92867}, "CVE-2018-3952": {"epss_score": 0.00195, "epss_percentile": 0.41602}, "CVE-2018-3953": {"epss_score": 0.68454, "epss_percentile": 0.98549}, "CVE-2018-3954": {"epss_score": 0.07957, "epss_percentile": 0.91789}, "CVE-2018-3955": {"epss_score": 0.01531, "epss_percentile": 0.80891}, "CVE-2018-3956": {"epss_score": 0.13578, "epss_percentile": 0.94}, "CVE-2018-3957": {"epss_score": 0.0022, "epss_percentile": 0.446}, "CVE-2018-3958": {"epss_score": 0.0022, "epss_percentile": 0.446}, "CVE-2018-3959": {"epss_score": 0.06944, "epss_percentile": 0.91133}, "CVE-2018-3960": {"epss_score": 0.06944, "epss_percentile": 0.91133}, "CVE-2018-3961": {"epss_score": 0.06944, "epss_percentile": 0.91133}, "CVE-2018-3962": {"epss_score": 0.00127, "epss_percentile": 0.32881}, "CVE-2018-3963": {"epss_score": 0.00815, "epss_percentile": 0.73785}, "CVE-2018-3964": {"epss_score": 0.16041, "epss_percentile": 0.94563}, "CVE-2018-3965": {"epss_score": 0.15916, "epss_percentile": 0.94532}, "CVE-2018-3966": {"epss_score": 0.15916, "epss_percentile": 0.94532}, "CVE-2018-3967": {"epss_score": 0.16041, "epss_percentile": 0.94563}, "CVE-2018-3968": {"epss_score": 0.00029, "epss_percentile": 0.07608}, "CVE-2018-3969": {"epss_score": 0.00122, "epss_percentile": 0.32093}, "CVE-2018-3970": {"epss_score": 0.0004, "epss_percentile": 0.12188}, "CVE-2018-3971": {"epss_score": 0.00055, "epss_percentile": 0.1748}, "CVE-2018-3972": {"epss_score": 0.00767, "epss_percentile": 0.7296}, "CVE-2018-3973": {"epss_score": 0.0031, "epss_percentile": 0.53807}, "CVE-2018-3974": {"epss_score": 0.0011, "epss_percentile": 0.30236}, "CVE-2018-3975": {"epss_score": 0.00611, "epss_percentile": 0.69195}, "CVE-2018-3976": {"epss_score": 0.00386, "epss_percentile": 0.59235}, "CVE-2018-3977": {"epss_score": 0.00935, "epss_percentile": 0.75663}, "CVE-2018-3978": {"epss_score": 0.00258, "epss_percentile": 0.48975}, "CVE-2018-3979": {"epss_score": 0.00437, "epss_percentile": 0.625}, "CVE-2018-3980": {"epss_score": 0.00611, "epss_percentile": 0.69195}, "CVE-2018-3981": {"epss_score": 0.00562, "epss_percentile": 0.67683}, "CVE-2018-3982": {"epss_score": 0.00645, "epss_percentile": 0.70122}, "CVE-2018-3983": {"epss_score": 0.0052, "epss_percentile": 0.66203}, "CVE-2018-3984": {"epss_score": 0.00612, "epss_percentile": 0.69217}, "CVE-2018-3985": {"epss_score": 0.01217, "epss_percentile": 0.786}, "CVE-2018-3986": {"epss_score": 0.00159, "epss_percentile": 0.37304}, "CVE-2018-3987": {"epss_score": 0.00169, "epss_percentile": 0.38608}, "CVE-2018-3988": {"epss_score": 0.00119, "epss_percentile": 0.31676}, "CVE-2018-3989": {"epss_score": 0.00138, "epss_percentile": 0.34402}, "CVE-2018-3990": {"epss_score": 0.00172, "epss_percentile": 0.39006}, "CVE-2018-3991": {"epss_score": 0.79315, "epss_percentile": 0.99031}, "CVE-2018-3992": {"epss_score": 0.00229, "epss_percentile": 0.4566}, "CVE-2018-3993": {"epss_score": 0.00268, "epss_percentile": 0.50092}, "CVE-2018-3994": {"epss_score": 0.00268, "epss_percentile": 0.50092}, "CVE-2018-3995": {"epss_score": 0.003, "epss_percentile": 0.52955}, "CVE-2018-3996": {"epss_score": 0.00268, "epss_percentile": 0.50092}, "CVE-2018-3997": {"epss_score": 0.00271, "epss_percentile": 0.50303}, "CVE-2018-3998": {"epss_score": 0.00425, "epss_percentile": 0.61691}, "CVE-2018-3999": {"epss_score": 0.00444, "epss_percentile": 0.62814}, "CVE-2018-4000": {"epss_score": 0.00435, "epss_percentile": 0.62377}, "CVE-2018-4001": {"epss_score": 0.00841, "epss_percentile": 0.74228}, "CVE-2018-4002": {"epss_score": 0.01174, "epss_percentile": 0.78251}, "CVE-2018-4003": {"epss_score": 0.03006, "epss_percentile": 0.86185}, "CVE-2018-4004": {"epss_score": 0.00049, "epss_percentile": 0.153}, "CVE-2018-4005": {"epss_score": 0.00039, "epss_percentile": 0.11429}, "CVE-2018-4006": {"epss_score": 0.00039, "epss_percentile": 0.11429}, "CVE-2018-4007": {"epss_score": 0.00048, "epss_percentile": 0.14938}, "CVE-2018-4008": {"epss_score": 0.00109, "epss_percentile": 0.30005}, "CVE-2018-4009": {"epss_score": 0.00019, "epss_percentile": 0.04096}, "CVE-2018-4010": {"epss_score": 0.00833, "epss_percentile": 0.74077}, "CVE-2018-4011": {"epss_score": 0.01299, "epss_percentile": 0.7928}, "CVE-2018-4012": {"epss_score": 0.03509, "epss_percentile": 0.87263}, "CVE-2018-4013": {"epss_score": 0.51636, "epss_percentile": 0.97791}, "CVE-2018-4014": {"epss_score": 0.02331, "epss_percentile": 0.84402}, "CVE-2018-4015": {"epss_score": 0.00195, "epss_percentile": 0.41689}, "CVE-2018-4016": {"epss_score": 0.00239, "epss_percentile": 0.46875}, "CVE-2018-4017": {"epss_score": 0.00099, "epss_percentile": 0.28392}, "CVE-2018-4018": {"epss_score": 0.00426, "epss_percentile": 0.6173}, "CVE-2018-4019": {"epss_score": 0.84194, "epss_percentile": 0.99279}, "CVE-2018-4020": {"epss_score": 0.84194, "epss_percentile": 0.99279}, "CVE-2018-4021": {"epss_score": 0.84766, "epss_percentile": 0.99304}, "CVE-2018-4022": {"epss_score": 0.00703, "epss_percentile": 0.71549}, "CVE-2018-4023": {"epss_score": 0.02577, "epss_percentile": 0.85144}, "CVE-2018-4024": {"epss_score": 0.004, "epss_percentile": 0.60186}, "CVE-2018-4025": {"epss_score": 0.00435, "epss_percentile": 0.62379}, "CVE-2018-4026": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2018-4027": {"epss_score": 0.00399, "epss_percentile": 0.60115}, "CVE-2018-4028": {"epss_score": 0.00272, "epss_percentile": 0.50399}, "CVE-2018-4029": {"epss_score": 0.02115, "epss_percentile": 0.83658}, "CVE-2018-4030": {"epss_score": 0.00221, "epss_percentile": 0.44689}, "CVE-2018-4031": {"epss_score": 0.0041, "epss_percentile": 0.60846}, "CVE-2018-4032": {"epss_score": 0.00038, "epss_percentile": 0.11219}, "CVE-2018-4033": {"epss_score": 0.00038, "epss_percentile": 0.11219}, "CVE-2018-4034": {"epss_score": 0.00044, "epss_percentile": 0.13478}, "CVE-2018-4035": {"epss_score": 0.00044, "epss_percentile": 0.13478}, "CVE-2018-4036": {"epss_score": 0.00044, "epss_percentile": 0.13368}, "CVE-2018-4037": {"epss_score": 0.00044, "epss_percentile": 0.13368}, "CVE-2018-4038": {"epss_score": 0.00936, "epss_percentile": 0.75688}, "CVE-2018-4039": {"epss_score": 0.00936, "epss_percentile": 0.75688}, "CVE-2018-4040": {"epss_score": 0.00243, "epss_percentile": 0.47489}, "CVE-2018-4041": {"epss_score": 0.00044, "epss_percentile": 0.13478}, "CVE-2018-4042": {"epss_score": 0.00044, "epss_percentile": 0.13478}, "CVE-2018-4043": {"epss_score": 0.00044, "epss_percentile": 0.13478}, "CVE-2018-4044": {"epss_score": 0.00044, "epss_percentile": 0.13478}, "CVE-2018-4045": {"epss_score": 0.00044, "epss_percentile": 0.13478}, "CVE-2018-4046": {"epss_score": 0.00041, "epss_percentile": 0.12381}, "CVE-2018-4047": {"epss_score": 0.00044, "epss_percentile": 0.13478}, "CVE-2018-4048": {"epss_score": 0.00053, "epss_percentile": 0.16901}, "CVE-2018-4049": {"epss_score": 0.00083, "epss_percentile": 0.24799}, "CVE-2018-4050": {"epss_score": 0.00076, "epss_percentile": 0.23083}, "CVE-2018-4051": {"epss_score": 0.00077, "epss_percentile": 0.23534}, "CVE-2018-4052": {"epss_score": 0.00125, "epss_percentile": 0.32595}, "CVE-2018-4053": {"epss_score": 0.00131, "epss_percentile": 0.33395}, "CVE-2018-4054": {"epss_score": 0.00046, "epss_percentile": 0.14393}, "CVE-2018-4055": {"epss_score": 0.00047, "epss_percentile": 0.14852}, "CVE-2018-4056": {"epss_score": 0.00487, "epss_percentile": 0.64779}, "CVE-2018-4058": {"epss_score": 0.00175, "epss_percentile": 0.39372}, "CVE-2018-4059": {"epss_score": 0.00798, "epss_percentile": 0.73504}, "CVE-2018-4061": {"epss_score": 0.0018, "epss_percentile": 0.399}, "CVE-2018-4062": {"epss_score": 0.00306, "epss_percentile": 0.53409}, "CVE-2018-4063": {"epss_score": 0.00934, "epss_percentile": 0.75651}, "CVE-2018-4064": {"epss_score": 0.00036, "epss_percentile": 0.10373}, "CVE-2018-4065": {"epss_score": 0.00038, "epss_percentile": 0.11403}, "CVE-2018-4066": {"epss_score": 0.71852, "epss_percentile": 0.98683}, "CVE-2018-4067": {"epss_score": 0.00453, "epss_percentile": 0.63229}, "CVE-2018-4068": {"epss_score": 0.0013, "epss_percentile": 0.33289}, "CVE-2018-4069": {"epss_score": 0.00026, "epss_percentile": 0.06562}, "CVE-2018-4070": {"epss_score": 0.38873, "epss_percentile": 0.97124}, "CVE-2018-4071": {"epss_score": 0.38873, "epss_percentile": 0.97124}, "CVE-2018-4072": {"epss_score": 0.41984, "epss_percentile": 0.97304}, "CVE-2018-4073": {"epss_score": 0.41984, "epss_percentile": 0.97304}, "CVE-2018-4082": {"epss_score": 0.00187, "epss_percentile": 0.40698}, "CVE-2018-4083": {"epss_score": 0.0078, "epss_percentile": 0.73158}, "CVE-2018-4084": {"epss_score": 0.0234, "epss_percentile": 0.8443}, "CVE-2018-4085": {"epss_score": 0.00766, "epss_percentile": 0.72945}, "CVE-2018-4086": {"epss_score": 0.00326, "epss_percentile": 0.55075}, "CVE-2018-4087": {"epss_score": 0.19947, "epss_percentile": 0.95265}, "CVE-2018-4088": {"epss_score": 0.00638, "epss_percentile": 0.69921}, "CVE-2018-4089": {"epss_score": 0.02217, "epss_percentile": 0.84037}, "CVE-2018-4090": {"epss_score": 0.04499, "epss_percentile": 0.88764}, "CVE-2018-4091": {"epss_score": 0.01792, "epss_percentile": 0.82289}, "CVE-2018-4092": {"epss_score": 0.00209, "epss_percentile": 0.43384}, "CVE-2018-4093": {"epss_score": 0.0027, "epss_percentile": 0.50237}, "CVE-2018-4094": {"epss_score": 0.00516, "epss_percentile": 0.66029}, "CVE-2018-4095": {"epss_score": 0.00207, "epss_percentile": 0.43125}, "CVE-2018-4096": {"epss_score": 0.00638, "epss_percentile": 0.69921}, "CVE-2018-4097": {"epss_score": 0.01321, "epss_percentile": 0.79446}, "CVE-2018-4098": {"epss_score": 0.00165, "epss_percentile": 0.38055}, "CVE-2018-4100": {"epss_score": 0.04117, "epss_percentile": 0.88279}, "CVE-2018-4101": {"epss_score": 0.00549, "epss_percentile": 0.67316}, "CVE-2018-4102": {"epss_score": 0.00527, "epss_percentile": 0.66467}, "CVE-2018-4104": {"epss_score": 0.00238, "epss_percentile": 0.46744}, "CVE-2018-4105": {"epss_score": 0.01792, "epss_percentile": 0.82289}, "CVE-2018-4106": {"epss_score": 0.01234, "epss_percentile": 0.78755}, "CVE-2018-4107": {"epss_score": 0.00681, "epss_percentile": 0.71044}, "CVE-2018-4108": {"epss_score": 0.01792, "epss_percentile": 0.82289}, "CVE-2018-4109": {"epss_score": 0.0024, "epss_percentile": 0.46944}, "CVE-2018-4110": {"epss_score": 0.03118, "epss_percentile": 0.86437}, "CVE-2018-4111": {"epss_score": 0.00439, "epss_percentile": 0.62606}, "CVE-2018-4112": {"epss_score": 0.01125, "epss_percentile": 0.77802}, "CVE-2018-4113": {"epss_score": 0.01156, "epss_percentile": 0.78099}, "CVE-2018-4114": {"epss_score": 0.00538, "epss_percentile": 0.66934}, "CVE-2018-4115": {"epss_score": 0.01162, "epss_percentile": 0.78147}, "CVE-2018-4116": {"epss_score": 0.00217, "epss_percentile": 0.44312}, "CVE-2018-4117": {"epss_score": 0.00953, "epss_percentile": 0.7589}, "CVE-2018-4118": {"epss_score": 0.00549, "epss_percentile": 0.67316}, "CVE-2018-4119": {"epss_score": 0.00549, "epss_percentile": 0.67316}, "CVE-2018-4120": {"epss_score": 0.00549, "epss_percentile": 0.67316}, "CVE-2018-4121": {"epss_score": 0.3861, "epss_percentile": 0.97109}, "CVE-2018-4122": {"epss_score": 0.00538, "epss_percentile": 0.66934}, "CVE-2018-4123": {"epss_score": 0.00075, "epss_percentile": 0.22892}, "CVE-2018-4124": {"epss_score": 0.26216, "epss_percentile": 0.96124}, "CVE-2018-4125": {"epss_score": 0.00538, "epss_percentile": 0.66934}, "CVE-2018-4126": {"epss_score": 0.00757, "epss_percentile": 0.72763}, "CVE-2018-4127": {"epss_score": 0.00549, "epss_percentile": 0.67316}, "CVE-2018-4128": {"epss_score": 0.00549, "epss_percentile": 0.67316}, "CVE-2018-4129": {"epss_score": 0.00538, "epss_percentile": 0.66934}, "CVE-2018-4130": {"epss_score": 0.00789, "epss_percentile": 0.73352}, "CVE-2018-4131": {"epss_score": 0.00224, "epss_percentile": 0.45071}, "CVE-2018-4132": {"epss_score": 0.00165, "epss_percentile": 0.38055}, "CVE-2018-4133": {"epss_score": 0.00501, "epss_percentile": 0.65338}, "CVE-2018-4134": {"epss_score": 0.01577, "epss_percentile": 0.81119}, "CVE-2018-4135": {"epss_score": 0.00165, "epss_percentile": 0.38055}, "CVE-2018-4136": {"epss_score": 0.00165, "epss_percentile": 0.38055}, "CVE-2018-4137": {"epss_score": 0.00347, "epss_percentile": 0.5679}, "CVE-2018-4138": {"epss_score": 0.00249, "epss_percentile": 0.48013}, "CVE-2018-4139": {"epss_score": 0.01266, "epss_percentile": 0.79009}, "CVE-2018-4140": {"epss_score": 0.01471, "epss_percentile": 0.80502}, "CVE-2018-4141": {"epss_score": 0.00198, "epss_percentile": 0.42029}, "CVE-2018-4142": {"epss_score": 0.03008, "epss_percentile": 0.86189}, "CVE-2018-4143": {"epss_score": 0.00183, "epss_percentile": 0.40323}, "CVE-2018-4144": {"epss_score": 0.00406, "epss_percentile": 0.60526}, "CVE-2018-4145": {"epss_score": 0.00699, "epss_percentile": 0.71458}, "CVE-2018-4146": {"epss_score": 0.00848, "epss_percentile": 0.74361}, "CVE-2018-4147": {"epss_score": 0.00636, "epss_percentile": 0.6987}, "CVE-2018-4148": {"epss_score": 0.08417, "epss_percentile": 0.92041}, "CVE-2018-4149": {"epss_score": 0.01577, "epss_percentile": 0.81119}, "CVE-2018-4150": {"epss_score": 0.23703, "epss_percentile": 0.95806}, "CVE-2018-4151": {"epss_score": 0.00169, "epss_percentile": 0.38613}, "CVE-2018-4152": {"epss_score": 0.00148, "epss_percentile": 0.3584}, "CVE-2018-4153": {"epss_score": 0.00229, "epss_percentile": 0.45661}, "CVE-2018-4154": {"epss_score": 0.00155, "epss_percentile": 0.36759}, "CVE-2018-4155": {"epss_score": 0.00152, "epss_percentile": 0.36382}, "CVE-2018-4156": {"epss_score": 0.00169, "epss_percentile": 0.38613}, "CVE-2018-4157": {"epss_score": 0.00152, "epss_percentile": 0.36382}, "CVE-2018-4158": {"epss_score": 0.00155, "epss_percentile": 0.36759}, "CVE-2018-4159": {"epss_score": 0.00198, "epss_percentile": 0.42029}, "CVE-2018-4160": {"epss_score": 0.00165, "epss_percentile": 0.38055}, "CVE-2018-4161": {"epss_score": 0.00721, "epss_percentile": 0.7197}, "CVE-2018-4162": {"epss_score": 0.38907, "epss_percentile": 0.97126}, "CVE-2018-4163": {"epss_score": 0.00538, "epss_percentile": 0.66934}, "CVE-2018-4164": {"epss_score": 0.02899, "epss_percentile": 0.8595}, "CVE-2018-4165": {"epss_score": 0.00549, "epss_percentile": 0.67316}, "CVE-2018-4166": {"epss_score": 0.00152, "epss_percentile": 0.36382}, "CVE-2018-4167": {"epss_score": 0.00152, "epss_percentile": 0.36382}, "CVE-2018-4168": {"epss_score": 0.00095, "epss_percentile": 0.27098}, "CVE-2018-4169": {"epss_score": 0.00442, "epss_percentile": 0.62751}, "CVE-2018-4170": {"epss_score": 0.00053, "epss_percentile": 0.16836}, "CVE-2018-4171": {"epss_score": 0.00286, "epss_percentile": 0.51752}, "CVE-2018-4172": {"epss_score": 0.0008, "epss_percentile": 0.24014}, "CVE-2018-4173": {"epss_score": 0.00136, "epss_percentile": 0.34194}, "CVE-2018-4174": {"epss_score": 0.00803, "epss_percentile": 0.73598}, "CVE-2018-4175": {"epss_score": 0.00238, "epss_percentile": 0.46832}, "CVE-2018-4176": {"epss_score": 0.00216, "epss_percentile": 0.44143}, "CVE-2018-4178": {"epss_score": 0.00084, "epss_percentile": 0.24827}, "CVE-2018-4179": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-4180": {"epss_score": 0.0019, "epss_percentile": 0.41134}, "CVE-2018-4181": {"epss_score": 0.00179, "epss_percentile": 0.39773}, "CVE-2018-4182": {"epss_score": 0.00148, "epss_percentile": 0.35807}, "CVE-2018-4183": {"epss_score": 0.00148, "epss_percentile": 0.35807}, "CVE-2018-4184": {"epss_score": 0.00232, "epss_percentile": 0.45885}, "CVE-2018-4185": {"epss_score": 0.03739, "epss_percentile": 0.87655}, "CVE-2018-4186": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2018-4187": {"epss_score": 0.00638, "epss_percentile": 0.69914}, "CVE-2018-4188": {"epss_score": 0.01288, "epss_percentile": 0.79205}, "CVE-2018-4189": {"epss_score": 0.00714, "epss_percentile": 0.71825}, "CVE-2018-4190": {"epss_score": 0.00983, "epss_percentile": 0.76307}, "CVE-2018-4191": {"epss_score": 0.00704, "epss_percentile": 0.71555}, "CVE-2018-4192": {"epss_score": 0.22584, "epss_percentile": 0.95654}, "CVE-2018-4193": {"epss_score": 0.18056, "epss_percentile": 0.9495}, "CVE-2018-4194": {"epss_score": 0.00503, "epss_percentile": 0.65438}, "CVE-2018-4195": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2018-4196": {"epss_score": 0.00708, "epss_percentile": 0.71684}, "CVE-2018-4197": {"epss_score": 0.15917, "epss_percentile": 0.94534}, "CVE-2018-4198": {"epss_score": 0.0046, "epss_percentile": 0.63511}, "CVE-2018-4199": {"epss_score": 0.0231, "epss_percentile": 0.84334}, "CVE-2018-4200": {"epss_score": 0.35682, "epss_percentile": 0.96926}, "CVE-2018-4201": {"epss_score": 0.01609, "epss_percentile": 0.81318}, "CVE-2018-4202": {"epss_score": 0.00396, "epss_percentile": 0.59918}, "CVE-2018-4203": {"epss_score": 0.00373, "epss_percentile": 0.58497}, "CVE-2018-4204": {"epss_score": 0.03136, "epss_percentile": 0.8648}, "CVE-2018-4205": {"epss_score": 0.00506, "epss_percentile": 0.65639}, "CVE-2018-4206": {"epss_score": 0.07649, "epss_percentile": 0.91603}, "CVE-2018-4207": {"epss_score": 0.00612, "epss_percentile": 0.69215}, "CVE-2018-4208": {"epss_score": 0.00612, "epss_percentile": 0.69215}, "CVE-2018-4209": {"epss_score": 0.00443, "epss_percentile": 0.62773}, "CVE-2018-4210": {"epss_score": 0.00844, "epss_percentile": 0.74274}, "CVE-2018-4211": {"epss_score": 0.00488, "epss_percentile": 0.64847}, "CVE-2018-4212": {"epss_score": 0.00612, "epss_percentile": 0.69215}, "CVE-2018-4213": {"epss_score": 0.00633, "epss_percentile": 0.69773}, "CVE-2018-4214": {"epss_score": 0.0165, "epss_percentile": 0.81561}, "CVE-2018-4215": {"epss_score": 0.00212, "epss_percentile": 0.43819}, "CVE-2018-4216": {"epss_score": 0.00194, "epss_percentile": 0.41528}, "CVE-2018-4217": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2018-4218": {"epss_score": 0.19495, "epss_percentile": 0.95192}, "CVE-2018-4219": {"epss_score": 0.00294, "epss_percentile": 0.52437}, "CVE-2018-4220": {"epss_score": 0.00413, "epss_percentile": 0.61005}, "CVE-2018-4221": {"epss_score": 0.00271, "epss_percentile": 0.50281}, "CVE-2018-4222": {"epss_score": 0.45452, "epss_percentile": 0.97488}, "CVE-2018-4223": {"epss_score": 0.00133, "epss_percentile": 0.33685}, "CVE-2018-4224": {"epss_score": 0.00044, "epss_percentile": 0.13562}, "CVE-2018-4225": {"epss_score": 0.00046, "epss_percentile": 0.14309}, "CVE-2018-4226": {"epss_score": 0.00064, "epss_percentile": 0.20161}, "CVE-2018-4227": {"epss_score": 0.00358, "epss_percentile": 0.57496}, "CVE-2018-4228": {"epss_score": 0.00303, "epss_percentile": 0.53216}, "CVE-2018-4229": {"epss_score": 0.00304, "epss_percentile": 0.53244}, "CVE-2018-4230": {"epss_score": 0.04062, "epss_percentile": 0.88191}, "CVE-2018-4232": {"epss_score": 0.01364, "epss_percentile": 0.79769}, "CVE-2018-4233": {"epss_score": 0.89897, "epss_percentile": 0.99548}, "CVE-2018-4234": {"epss_score": 0.00369, "epss_percentile": 0.58248}, "CVE-2018-4235": {"epss_score": 0.00181, "epss_percentile": 0.40018}, "CVE-2018-4236": {"epss_score": 0.00369, "epss_percentile": 0.58248}, "CVE-2018-4237": {"epss_score": 0.65746, "epss_percentile": 0.98437}, "CVE-2018-4238": {"epss_score": 0.00059, "epss_percentile": 0.18927}, "CVE-2018-4239": {"epss_score": 0.00072, "epss_percentile": 0.22443}, "CVE-2018-4240": {"epss_score": 0.23346, "epss_percentile": 0.95768}, "CVE-2018-4241": {"epss_score": 0.32986, "epss_percentile": 0.96739}, "CVE-2018-4242": {"epss_score": 0.08031, "epss_percentile": 0.91842}, "CVE-2018-4243": {"epss_score": 0.28347, "epss_percentile": 0.96345}, "CVE-2018-4244": {"epss_score": 0.00072, "epss_percentile": 0.22443}, "CVE-2018-4246": {"epss_score": 0.03013, "epss_percentile": 0.86203}, "CVE-2018-4247": {"epss_score": 0.01134, "epss_percentile": 0.77895}, "CVE-2018-4248": {"epss_score": 0.02821, "epss_percentile": 0.85743}, "CVE-2018-4249": {"epss_score": 0.01057, "epss_percentile": 0.77137}, "CVE-2018-4250": {"epss_score": 0.00406, "epss_percentile": 0.60512}, "CVE-2018-4251": {"epss_score": 0.00144, "epss_percentile": 0.35327}, "CVE-2018-4252": {"epss_score": 0.00072, "epss_percentile": 0.22443}, "CVE-2018-4253": {"epss_score": 0.0013, "epss_percentile": 0.33295}, "CVE-2018-4254": {"epss_score": 0.00442, "epss_percentile": 0.62751}, "CVE-2018-4255": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-4256": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-4257": {"epss_score": 0.00477, "epss_percentile": 0.64345}, "CVE-2018-4258": {"epss_score": 0.00477, "epss_percentile": 0.64345}, "CVE-2018-4259": {"epss_score": 0.00628, "epss_percentile": 0.69661}, "CVE-2018-4260": {"epss_score": 0.00222, "epss_percentile": 0.44753}, "CVE-2018-4261": {"epss_score": 0.00536, "epss_percentile": 0.66855}, "CVE-2018-4262": {"epss_score": 0.00592, "epss_percentile": 0.68626}, "CVE-2018-4263": {"epss_score": 0.00536, "epss_percentile": 0.66855}, "CVE-2018-4264": {"epss_score": 0.00704, "epss_percentile": 0.71555}, "CVE-2018-4265": {"epss_score": 0.00536, "epss_percentile": 0.66855}, "CVE-2018-4266": {"epss_score": 0.00668, "epss_percentile": 0.70743}, "CVE-2018-4267": {"epss_score": 0.00536, "epss_percentile": 0.66855}, "CVE-2018-4268": {"epss_score": 0.00442, "epss_percentile": 0.62751}, "CVE-2018-4269": {"epss_score": 0.00305, "epss_percentile": 0.53341}, "CVE-2018-4270": {"epss_score": 0.00741, "epss_percentile": 0.72448}, "CVE-2018-4271": {"epss_score": 0.00737, "epss_percentile": 0.72326}, "CVE-2018-4272": {"epss_score": 0.00704, "epss_percentile": 0.71555}, "CVE-2018-4273": {"epss_score": 0.00741, "epss_percentile": 0.72448}, "CVE-2018-4274": {"epss_score": 0.0021, "epss_percentile": 0.43478}, "CVE-2018-4275": {"epss_score": 0.00255, "epss_percentile": 0.48722}, "CVE-2018-4276": {"epss_score": 0.0039, "epss_percentile": 0.59533}, "CVE-2018-4277": {"epss_score": 0.0053, "epss_percentile": 0.66613}, "CVE-2018-4278": {"epss_score": 0.00514, "epss_percentile": 0.65946}, "CVE-2018-4279": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2018-4280": {"epss_score": 0.19414, "epss_percentile": 0.95177}, "CVE-2018-4281": {"epss_score": 0.00543, "epss_percentile": 0.67119}, "CVE-2018-4282": {"epss_score": 0.00068, "epss_percentile": 0.21425}, "CVE-2018-4283": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-4284": {"epss_score": 0.00699, "epss_percentile": 0.71458}, "CVE-2018-4285": {"epss_score": 0.00151, "epss_percentile": 0.3625}, "CVE-2018-4286": {"epss_score": 0.00717, "epss_percentile": 0.71876}, "CVE-2018-4287": {"epss_score": 0.00717, "epss_percentile": 0.71876}, "CVE-2018-4288": {"epss_score": 0.00717, "epss_percentile": 0.71876}, "CVE-2018-4289": {"epss_score": 0.00216, "epss_percentile": 0.44164}, "CVE-2018-4290": {"epss_score": 0.00367, "epss_percentile": 0.58139}, "CVE-2018-4291": {"epss_score": 0.00717, "epss_percentile": 0.71876}, "CVE-2018-4293": {"epss_score": 0.00543, "epss_percentile": 0.67111}, "CVE-2018-4295": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2018-4296": {"epss_score": 0.00381, "epss_percentile": 0.58997}, "CVE-2018-4298": {"epss_score": 0.00334, "epss_percentile": 0.55795}, "CVE-2018-4299": {"epss_score": 0.0076, "epss_percentile": 0.72814}, "CVE-2018-4300": {"epss_score": 0.00381, "epss_percentile": 0.59001}, "CVE-2018-4301": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2018-4302": {"epss_score": 0.00424, "epss_percentile": 0.61673}, "CVE-2018-4303": {"epss_score": 0.00259, "epss_percentile": 0.49048}, "CVE-2018-4304": {"epss_score": 0.00212, "epss_percentile": 0.43752}, "CVE-2018-4305": {"epss_score": 0.00087, "epss_percentile": 0.25609}, "CVE-2018-4306": {"epss_score": 0.15917, "epss_percentile": 0.94534}, "CVE-2018-4307": {"epss_score": 0.00218, "epss_percentile": 0.44391}, "CVE-2018-4308": {"epss_score": 0.00197, "epss_percentile": 0.41865}, "CVE-2018-4309": {"epss_score": 0.00944, "epss_percentile": 0.7579}, "CVE-2018-4310": {"epss_score": 0.01139, "epss_percentile": 0.77937}, "CVE-2018-4311": {"epss_score": 0.00443, "epss_percentile": 0.62767}, "CVE-2018-4312": {"epss_score": 0.15917, "epss_percentile": 0.94534}, "CVE-2018-4313": {"epss_score": 0.00068, "epss_percentile": 0.21425}, "CVE-2018-4314": {"epss_score": 0.34513, "epss_percentile": 0.96852}, "CVE-2018-4315": {"epss_score": 0.15917, "epss_percentile": 0.94534}, "CVE-2018-4316": {"epss_score": 0.00536, "epss_percentile": 0.66855}, "CVE-2018-4317": {"epss_score": 0.15917, "epss_percentile": 0.94534}, "CVE-2018-4318": {"epss_score": 0.15917, "epss_percentile": 0.94534}, "CVE-2018-4319": {"epss_score": 0.00208, "epss_percentile": 0.43226}, "CVE-2018-4321": {"epss_score": 0.00298, "epss_percentile": 0.5278}, "CVE-2018-4322": {"epss_score": 0.00054, "epss_percentile": 0.17226}, "CVE-2018-4323": {"epss_score": 0.15917, "epss_percentile": 0.94534}, "CVE-2018-4324": {"epss_score": 0.00146, "epss_percentile": 0.35616}, "CVE-2018-4325": {"epss_score": 0.00057, "epss_percentile": 0.18106}, "CVE-2018-4326": {"epss_score": 0.00306, "epss_percentile": 0.53406}, "CVE-2018-4327": {"epss_score": 0.15106, "epss_percentile": 0.94364}, "CVE-2018-4328": {"epss_score": 0.15917, "epss_percentile": 0.94534}, "CVE-2018-4329": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2018-4330": {"epss_score": 0.15271, "epss_percentile": 0.94396}, "CVE-2018-4331": {"epss_score": 0.19923, "epss_percentile": 0.95261}, "CVE-2018-4332": {"epss_score": 0.00992, "epss_percentile": 0.76393}, "CVE-2018-4333": {"epss_score": 0.00197, "epss_percentile": 0.41865}, "CVE-2018-4334": {"epss_score": 0.00149, "epss_percentile": 0.35987}, "CVE-2018-4335": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2018-4336": {"epss_score": 0.00185, "epss_percentile": 0.40571}, "CVE-2018-4337": {"epss_score": 0.00185, "epss_percentile": 0.40571}, "CVE-2018-4338": {"epss_score": 0.01242, "epss_percentile": 0.78824}, "CVE-2018-4339": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2018-4340": {"epss_score": 0.00197, "epss_percentile": 0.41901}, "CVE-2018-4341": {"epss_score": 0.00335, "epss_percentile": 0.55842}, "CVE-2018-4342": {"epss_score": 0.00055, "epss_percentile": 0.17525}, "CVE-2018-4343": {"epss_score": 0.03814, "epss_percentile": 0.87763}, "CVE-2018-4344": {"epss_score": 0.0019, "epss_percentile": 0.41098}, "CVE-2018-4345": {"epss_score": 0.00944, "epss_percentile": 0.7579}, "CVE-2018-4346": {"epss_score": 0.00197, "epss_percentile": 0.41865}, "CVE-2018-4347": {"epss_score": 0.00301, "epss_percentile": 0.5302}, "CVE-2018-4348": {"epss_score": 0.00107, "epss_percentile": 0.29579}, "CVE-2018-4350": {"epss_score": 0.00144, "epss_percentile": 0.35291}, "CVE-2018-4351": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2018-4352": {"epss_score": 0.00054, "epss_percentile": 0.17226}, "CVE-2018-4353": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2018-4354": {"epss_score": 0.00335, "epss_percentile": 0.55842}, "CVE-2018-4355": {"epss_score": 0.00197, "epss_percentile": 0.41865}, "CVE-2018-4356": {"epss_score": 0.00179, "epss_percentile": 0.39816}, "CVE-2018-4357": {"epss_score": 0.00171, "epss_percentile": 0.38876}, "CVE-2018-4358": {"epss_score": 0.00704, "epss_percentile": 0.71555}, "CVE-2018-4359": {"epss_score": 0.0076, "epss_percentile": 0.72814}, "CVE-2018-4360": {"epss_score": 0.00704, "epss_percentile": 0.71555}, "CVE-2018-4361": {"epss_score": 0.00704, "epss_percentile": 0.71555}, "CVE-2018-4362": {"epss_score": 0.00222, "epss_percentile": 0.44753}, "CVE-2018-4363": {"epss_score": 0.00247, "epss_percentile": 0.47871}, "CVE-2018-4365": {"epss_score": 0.00164, "epss_percentile": 0.3795}, "CVE-2018-4366": {"epss_score": 0.0969, "epss_percentile": 0.92664}, "CVE-2018-4367": {"epss_score": 0.06785, "epss_percentile": 0.91026}, "CVE-2018-4368": {"epss_score": 0.00702, "epss_percentile": 0.71517}, "CVE-2018-4369": {"epss_score": 0.00339, "epss_percentile": 0.56194}, "CVE-2018-4371": {"epss_score": 0.00259, "epss_percentile": 0.49048}, "CVE-2018-4372": {"epss_score": 0.00699, "epss_percentile": 0.71448}, "CVE-2018-4373": {"epss_score": 0.00522, "epss_percentile": 0.66279}, "CVE-2018-4374": {"epss_score": 0.00517, "epss_percentile": 0.66075}, "CVE-2018-4375": {"epss_score": 0.00522, "epss_percentile": 0.66279}, "CVE-2018-4376": {"epss_score": 0.00522, "epss_percentile": 0.66279}, "CVE-2018-4377": {"epss_score": 0.0054, "epss_percentile": 0.67009}, "CVE-2018-4378": {"epss_score": 0.00706, "epss_percentile": 0.71621}, "CVE-2018-4379": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-4380": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-4381": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2018-4382": {"epss_score": 0.19518, "epss_percentile": 0.95198}, "CVE-2018-4383": {"epss_score": 0.00185, "epss_percentile": 0.40571}, "CVE-2018-4384": {"epss_score": 0.03773, "epss_percentile": 0.87705}, "CVE-2018-4385": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2018-4386": {"epss_score": 0.27778, "epss_percentile": 0.96281}, "CVE-2018-4387": {"epss_score": 0.00057, "epss_percentile": 0.18106}, "CVE-2018-4388": {"epss_score": 0.00063, "epss_percentile": 0.19948}, "CVE-2018-4389": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2018-4390": {"epss_score": 0.00232, "epss_percentile": 0.45901}, "CVE-2018-4391": {"epss_score": 0.00232, "epss_percentile": 0.45901}, "CVE-2018-4392": {"epss_score": 0.00695, "epss_percentile": 0.71376}, "CVE-2018-4393": {"epss_score": 0.00149, "epss_percentile": 0.35987}, "CVE-2018-4394": {"epss_score": 0.00335, "epss_percentile": 0.55842}, "CVE-2018-4395": {"epss_score": 0.00069, "epss_percentile": 0.21581}, "CVE-2018-4396": {"epss_score": 0.00197, "epss_percentile": 0.41865}, "CVE-2018-4397": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2018-4398": {"epss_score": 0.00526, "epss_percentile": 0.66411}, "CVE-2018-4399": {"epss_score": 0.00296, "epss_percentile": 0.52573}, "CVE-2018-4400": {"epss_score": 0.00196, "epss_percentile": 0.4182}, "CVE-2018-4401": {"epss_score": 0.00204, "epss_percentile": 0.4262}, "CVE-2018-4402": {"epss_score": 0.00171, "epss_percentile": 0.38876}, "CVE-2018-4403": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2018-4404": {"epss_score": 0.69803, "epss_percentile": 0.98604}, "CVE-2018-4406": {"epss_score": 0.0037, "epss_percentile": 0.5834}, "CVE-2018-4407": {"epss_score": 0.90882, "epss_percentile": 0.99607}, "CVE-2018-4408": {"epss_score": 0.00204, "epss_percentile": 0.4262}, "CVE-2018-4409": {"epss_score": 0.00439, "epss_percentile": 0.62599}, "CVE-2018-4410": {"epss_score": 0.00171, "epss_percentile": 0.38876}, "CVE-2018-4411": {"epss_score": 0.00452, "epss_percentile": 0.63167}, "CVE-2018-4412": {"epss_score": 0.00402, "epss_percentile": 0.60299}, "CVE-2018-4413": {"epss_score": 0.00371, "epss_percentile": 0.58385}, "CVE-2018-4414": {"epss_score": 0.00402, "epss_percentile": 0.60299}, "CVE-2018-4415": {"epss_score": 0.00288, "epss_percentile": 0.51978}, "CVE-2018-4416": {"epss_score": 0.42398, "epss_percentile": 0.9733}, "CVE-2018-4417": {"epss_score": 0.00197, "epss_percentile": 0.41865}, "CVE-2018-4418": {"epss_score": 0.00197, "epss_percentile": 0.41865}, "CVE-2018-4419": {"epss_score": 0.00185, "epss_percentile": 0.40571}, "CVE-2018-4420": {"epss_score": 0.00185, "epss_percentile": 0.40571}, "CVE-2018-4421": {"epss_score": 0.00251, "epss_percentile": 0.48278}, "CVE-2018-4422": {"epss_score": 0.00387, "epss_percentile": 0.59336}, "CVE-2018-4423": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2018-4424": {"epss_score": 0.00157, "epss_percentile": 0.37085}, "CVE-2018-4425": {"epss_score": 0.00204, "epss_percentile": 0.4262}, "CVE-2018-4426": {"epss_score": 0.00204, "epss_percentile": 0.4262}, "CVE-2018-4427": {"epss_score": 0.00185, "epss_percentile": 0.40571}, "CVE-2018-4428": {"epss_score": 0.00052, "epss_percentile": 0.16369}, "CVE-2018-4429": {"epss_score": 0.00222, "epss_percentile": 0.44753}, "CVE-2018-4430": {"epss_score": 0.00057, "epss_percentile": 0.18106}, "CVE-2018-4431": {"epss_score": 0.0209, "epss_percentile": 0.83568}, "CVE-2018-4433": {"epss_score": 0.00302, "epss_percentile": 0.53111}, "CVE-2018-4434": {"epss_score": 0.00044, "epss_percentile": 0.13617}, "CVE-2018-4435": {"epss_score": 0.02792, "epss_percentile": 0.85669}, "CVE-2018-4436": {"epss_score": 0.00126, "epss_percentile": 0.3266}, "CVE-2018-4437": {"epss_score": 0.00699, "epss_percentile": 0.71448}, "CVE-2018-4438": {"epss_score": 0.23521, "epss_percentile": 0.95788}, "CVE-2018-4439": {"epss_score": 0.00344, "epss_percentile": 0.5654}, "CVE-2018-4440": {"epss_score": 0.00344, "epss_percentile": 0.5654}, "CVE-2018-4441": {"epss_score": 0.56611, "epss_percentile": 0.9803}, "CVE-2018-4442": {"epss_score": 0.19518, "epss_percentile": 0.95198}, "CVE-2018-4443": {"epss_score": 0.19518, "epss_percentile": 0.95198}, "CVE-2018-4444": {"epss_score": 0.00457, "epss_percentile": 0.63391}, "CVE-2018-4445": {"epss_score": 0.00191, "epss_percentile": 0.41175}, "CVE-2018-4446": {"epss_score": 0.0019, "epss_percentile": 0.41108}, "CVE-2018-4447": {"epss_score": 0.00185, "epss_percentile": 0.40571}, "CVE-2018-4448": {"epss_score": 0.00068, "epss_percentile": 0.21189}, "CVE-2018-4449": {"epss_score": 0.00171, "epss_percentile": 0.38876}, "CVE-2018-4450": {"epss_score": 0.00171, "epss_percentile": 0.38876}, "CVE-2018-4451": {"epss_score": 0.00339, "epss_percentile": 0.56197}, "CVE-2018-4452": {"epss_score": 0.00358, "epss_percentile": 0.57527}, "CVE-2018-4456": {"epss_score": 0.00393, "epss_percentile": 0.59726}, "CVE-2018-4460": {"epss_score": 0.00702, "epss_percentile": 0.71517}, "CVE-2018-4461": {"epss_score": 0.00185, "epss_percentile": 0.40571}, "CVE-2018-4462": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2018-4463": {"epss_score": 0.00171, "epss_percentile": 0.38876}, "CVE-2018-4464": {"epss_score": 0.00751, "epss_percentile": 0.72646}, "CVE-2018-4465": {"epss_score": 0.00149, "epss_percentile": 0.35987}, "CVE-2018-4467": {"epss_score": 0.00222, "epss_percentile": 0.44795}, "CVE-2018-4468": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2018-4470": {"epss_score": 0.0019, "epss_percentile": 0.41108}, "CVE-2018-4474": {"epss_score": 0.00862, "epss_percentile": 0.74573}, "CVE-2018-4478": {"epss_score": 0.00042, "epss_percentile": 0.12605}, "CVE-2018-4832": {"epss_score": 0.00433, "epss_percentile": 0.62173}, "CVE-2018-4833": {"epss_score": 0.00956, "epss_percentile": 0.75926}, "CVE-2018-4834": {"epss_score": 0.01504, "epss_percentile": 0.80736}, "CVE-2018-4835": {"epss_score": 0.00359, "epss_percentile": 0.5754}, "CVE-2018-4836": {"epss_score": 0.00671, "epss_percentile": 0.70798}, "CVE-2018-4837": {"epss_score": 0.01482, "epss_percentile": 0.80573}, "CVE-2018-4838": {"epss_score": 0.00254, "epss_percentile": 0.48558}, "CVE-2018-4839": {"epss_score": 0.00128, "epss_percentile": 0.33017}, "CVE-2018-4840": {"epss_score": 0.0024, "epss_percentile": 0.47206}, "CVE-2018-4841": {"epss_score": 0.02854, "epss_percentile": 0.85834}, "CVE-2018-4842": {"epss_score": 0.00199, "epss_percentile": 0.42168}, "CVE-2018-4843": {"epss_score": 0.0025, "epss_percentile": 0.48254}, "CVE-2018-4844": {"epss_score": 0.00151, "epss_percentile": 0.36338}, "CVE-2018-4845": {"epss_score": 0.00808, "epss_percentile": 0.73688}, "CVE-2018-4846": {"epss_score": 0.00299, "epss_percentile": 0.52886}, "CVE-2018-4847": {"epss_score": 0.00034, "epss_percentile": 0.09608}, "CVE-2018-4848": {"epss_score": 0.00313, "epss_percentile": 0.54052}, "CVE-2018-4849": {"epss_score": 0.00104, "epss_percentile": 0.29223}, "CVE-2018-4850": {"epss_score": 0.00511, "epss_percentile": 0.65814}, "CVE-2018-4851": {"epss_score": 0.00443, "epss_percentile": 0.62763}, "CVE-2018-4852": {"epss_score": 0.02285, "epss_percentile": 0.84265}, "CVE-2018-4853": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2018-4854": {"epss_score": 0.00479, "epss_percentile": 0.64443}, "CVE-2018-4855": {"epss_score": 0.00142, "epss_percentile": 0.35029}, "CVE-2018-4856": {"epss_score": 0.00232, "epss_percentile": 0.45963}, "CVE-2018-4858": {"epss_score": 0.0043, "epss_percentile": 0.62002}, "CVE-2018-4859": {"epss_score": 0.01121, "epss_percentile": 0.77774}, "CVE-2018-4860": {"epss_score": 0.01121, "epss_percentile": 0.77774}, "CVE-2018-4861": {"epss_score": 0.00422, "epss_percentile": 0.61552}, "CVE-2018-4862": {"epss_score": 0.00192, "epss_percentile": 0.41285}, "CVE-2018-4863": {"epss_score": 0.00038, "epss_percentile": 0.11333}, "CVE-2018-4868": {"epss_score": 0.00384, "epss_percentile": 0.59173}, "CVE-2018-4871": {"epss_score": 0.01297, "epss_percentile": 0.79265}, "CVE-2018-4872": {"epss_score": 0.05191, "epss_percentile": 0.89595}, "CVE-2018-4873": {"epss_score": 0.00375, "epss_percentile": 0.58604}, "CVE-2018-4875": {"epss_score": 0.00941, "epss_percentile": 0.75757}, "CVE-2018-4876": {"epss_score": 0.00441, "epss_percentile": 0.62671}, "CVE-2018-4877": {"epss_score": 0.05038, "epss_percentile": 0.89424}, "CVE-2018-4878": {"epss_score": 0.93125, "epss_percentile": 0.99777}, "CVE-2018-4879": {"epss_score": 0.30399, "epss_percentile": 0.96536}, "CVE-2018-4880": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4881": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4882": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4883": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4884": {"epss_score": 0.01891, "epss_percentile": 0.8273}, "CVE-2018-4885": {"epss_score": 0.01891, "epss_percentile": 0.8273}, "CVE-2018-4886": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4887": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4888": {"epss_score": 0.02538, "epss_percentile": 0.85041}, "CVE-2018-4889": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4890": {"epss_score": 0.01558, "epss_percentile": 0.81026}, "CVE-2018-4891": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4892": {"epss_score": 0.02538, "epss_percentile": 0.85041}, "CVE-2018-4893": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4894": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4895": {"epss_score": 0.03823, "epss_percentile": 0.87788}, "CVE-2018-4896": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4897": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4898": {"epss_score": 0.04194, "epss_percentile": 0.88379}, "CVE-2018-4899": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4900": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4901": {"epss_score": 0.07855, "epss_percentile": 0.91721}, "CVE-2018-4902": {"epss_score": 0.02538, "epss_percentile": 0.85041}, "CVE-2018-4903": {"epss_score": 0.02968, "epss_percentile": 0.86091}, "CVE-2018-4904": {"epss_score": 0.05245, "epss_percentile": 0.89659}, "CVE-2018-4905": {"epss_score": 0.01891, "epss_percentile": 0.8273}, "CVE-2018-4906": {"epss_score": 0.02951, "epss_percentile": 0.86052}, "CVE-2018-4907": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4908": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4909": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4910": {"epss_score": 0.01485, "epss_percentile": 0.80595}, "CVE-2018-4911": {"epss_score": 0.01043, "epss_percentile": 0.76987}, "CVE-2018-4912": {"epss_score": 0.0188, "epss_percentile": 0.82682}, "CVE-2018-4913": {"epss_score": 0.0229, "epss_percentile": 0.84281}, "CVE-2018-4914": {"epss_score": 0.01891, "epss_percentile": 0.8273}, "CVE-2018-4915": {"epss_score": 0.04194, "epss_percentile": 0.88379}, "CVE-2018-4916": {"epss_score": 0.04194, "epss_percentile": 0.88379}, "CVE-2018-4917": {"epss_score": 0.03241, "epss_percentile": 0.86731}, "CVE-2018-4918": {"epss_score": 0.01935, "epss_percentile": 0.82959}, "CVE-2018-4919": {"epss_score": 0.01977, "epss_percentile": 0.83124}, "CVE-2018-4920": {"epss_score": 0.07186, "epss_percentile": 0.91307}, "CVE-2018-4921": {"epss_score": 0.00612, "epss_percentile": 0.69227}, "CVE-2018-4923": {"epss_score": 0.10873, "epss_percentile": 0.93141}, "CVE-2018-4924": {"epss_score": 0.26836, "epss_percentile": 0.96184}, "CVE-2018-4925": {"epss_score": 0.03456, "epss_percentile": 0.87174}, "CVE-2018-4926": {"epss_score": 0.03359, "epss_percentile": 0.86986}, "CVE-2018-4927": {"epss_score": 0.01724, "epss_percentile": 0.81949}, "CVE-2018-4928": {"epss_score": 0.02216, "epss_percentile": 0.84037}, "CVE-2018-4929": {"epss_score": 0.0102, "epss_percentile": 0.76739}, "CVE-2018-4930": {"epss_score": 0.0102, "epss_percentile": 0.76739}, "CVE-2018-4931": {"epss_score": 0.0102, "epss_percentile": 0.76739}, "CVE-2018-4932": {"epss_score": 0.01554, "epss_percentile": 0.81002}, "CVE-2018-4933": {"epss_score": 0.03259, "epss_percentile": 0.86767}, "CVE-2018-4934": {"epss_score": 0.29318, "epss_percentile": 0.96432}, "CVE-2018-4935": {"epss_score": 0.7418, "epss_percentile": 0.98791}, "CVE-2018-4936": {"epss_score": 0.41839, "epss_percentile": 0.97297}, "CVE-2018-4937": {"epss_score": 0.7418, "epss_percentile": 0.98791}, "CVE-2018-4938": {"epss_score": 0.00195, "epss_percentile": 0.41669}, "CVE-2018-4939": {"epss_score": 0.76955, "epss_percentile": 0.98912}, "CVE-2018-4940": {"epss_score": 0.01145, "epss_percentile": 0.77991}, "CVE-2018-4941": {"epss_score": 0.01145, "epss_percentile": 0.77991}, "CVE-2018-4942": {"epss_score": 0.00856, "epss_percentile": 0.7448}, "CVE-2018-4943": {"epss_score": 0.12132, "epss_percentile": 0.93576}, "CVE-2018-4944": {"epss_score": 0.24003, "epss_percentile": 0.95841}, "CVE-2018-4945": {"epss_score": 0.03172, "epss_percentile": 0.86549}, "CVE-2018-4946": {"epss_score": 0.08358, "epss_percentile": 0.92008}, "CVE-2018-4947": {"epss_score": 0.04322, "epss_percentile": 0.88546}, "CVE-2018-4948": {"epss_score": 0.04322, "epss_percentile": 0.88546}, "CVE-2018-4949": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4950": {"epss_score": 0.02177, "epss_percentile": 0.83888}, "CVE-2018-4951": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4952": {"epss_score": 0.02184, "epss_percentile": 0.83914}, "CVE-2018-4953": {"epss_score": 0.03758, "epss_percentile": 0.87683}, "CVE-2018-4954": {"epss_score": 0.02184, "epss_percentile": 0.83914}, "CVE-2018-4955": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4956": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4957": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4958": {"epss_score": 0.02337, "epss_percentile": 0.8442}, "CVE-2018-4959": {"epss_score": 0.02337, "epss_percentile": 0.8442}, "CVE-2018-4960": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4961": {"epss_score": 0.02337, "epss_percentile": 0.8442}, "CVE-2018-4962": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4963": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4964": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4965": {"epss_score": 0.02067, "epss_percentile": 0.8346}, "CVE-2018-4966": {"epss_score": 0.04322, "epss_percentile": 0.88546}, "CVE-2018-4967": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4968": {"epss_score": 0.04322, "epss_percentile": 0.88546}, "CVE-2018-4969": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4970": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4971": {"epss_score": 0.03294, "epss_percentile": 0.86846}, "CVE-2018-4972": {"epss_score": 0.02225, "epss_percentile": 0.84069}, "CVE-2018-4973": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4974": {"epss_score": 0.03294, "epss_percentile": 0.86846}, "CVE-2018-4975": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4976": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4977": {"epss_score": 0.02337, "epss_percentile": 0.8442}, "CVE-2018-4978": {"epss_score": 0.04322, "epss_percentile": 0.88546}, "CVE-2018-4979": {"epss_score": 0.03884, "epss_percentile": 0.87901}, "CVE-2018-4980": {"epss_score": 0.03294, "epss_percentile": 0.86846}, "CVE-2018-4981": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4982": {"epss_score": 0.04423, "epss_percentile": 0.88671}, "CVE-2018-4983": {"epss_score": 0.02337, "epss_percentile": 0.8442}, "CVE-2018-4984": {"epss_score": 0.04322, "epss_percentile": 0.88546}, "CVE-2018-4985": {"epss_score": 0.14535, "epss_percentile": 0.94234}, "CVE-2018-4986": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2018-4987": {"epss_score": 0.05621, "epss_percentile": 0.90061}, "CVE-2018-4988": {"epss_score": 0.02337, "epss_percentile": 0.8442}, "CVE-2018-4989": {"epss_score": 0.02337, "epss_percentile": 0.8442}, "CVE-2018-4990": {"epss_score": 0.62033, "epss_percentile": 0.98274}, "CVE-2018-4991": {"epss_score": 0.02158, "epss_percentile": 0.83816}, "CVE-2018-4992": {"epss_score": 0.00306, "epss_percentile": 0.53456}, "CVE-2018-4993": {"epss_score": 0.72754, "epss_percentile": 0.98725}, "CVE-2018-4994": {"epss_score": 0.03417, "epss_percentile": 0.87094}, "CVE-2018-4995": {"epss_score": 0.00325, "epss_percentile": 0.54984}, "CVE-2018-4996": {"epss_score": 0.02615, "epss_percentile": 0.85245}, "CVE-2018-4997": {"epss_score": 0.0519, "epss_percentile": 0.89594}, "CVE-2018-4998": {"epss_score": 0.04624, "epss_percentile": 0.88937}, "CVE-2018-4999": {"epss_score": 0.08684, "epss_percentile": 0.922}, "CVE-2018-5000": {"epss_score": 0.02046, "epss_percentile": 0.83387}, "CVE-2018-5001": {"epss_score": 0.0103, "epss_percentile": 0.76845}, "CVE-2018-5002": {"epss_score": 0.48477, "epss_percentile": 0.9764}, "CVE-2018-5003": {"epss_score": 0.01357, "epss_percentile": 0.79726}, "CVE-2018-5004": {"epss_score": 0.01103, "epss_percentile": 0.77589}, "CVE-2018-5005": {"epss_score": 0.01386, "epss_percentile": 0.79913}, "CVE-2018-5006": {"epss_score": 0.01036, "epss_percentile": 0.76909}, "CVE-2018-5007": {"epss_score": 0.02158, "epss_percentile": 0.83816}, "CVE-2018-5008": {"epss_score": 0.02064, "epss_percentile": 0.83451}, "CVE-2018-5009": {"epss_score": 0.05931, "epss_percentile": 0.90337}, "CVE-2018-5010": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-5011": {"epss_score": 0.05931, "epss_percentile": 0.90337}, "CVE-2018-5012": {"epss_score": 0.16367, "epss_percentile": 0.94637}, "CVE-2018-5014": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5015": {"epss_score": 0.13655, "epss_percentile": 0.94027}, "CVE-2018-5016": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5017": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5018": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5019": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5020": {"epss_score": 0.08358, "epss_percentile": 0.92008}, "CVE-2018-5021": {"epss_score": 0.06343, "epss_percentile": 0.90684}, "CVE-2018-5022": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-5023": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-5024": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-5025": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-5026": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-5027": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5028": {"epss_score": 0.13655, "epss_percentile": 0.94027}, "CVE-2018-5029": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5030": {"epss_score": 0.03227, "epss_percentile": 0.86689}, "CVE-2018-5031": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5032": {"epss_score": 0.13655, "epss_percentile": 0.94027}, "CVE-2018-5033": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5034": {"epss_score": 0.22661, "epss_percentile": 0.95667}, "CVE-2018-5035": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5036": {"epss_score": 0.13655, "epss_percentile": 0.94027}, "CVE-2018-5037": {"epss_score": 0.22661, "epss_percentile": 0.95667}, "CVE-2018-5038": {"epss_score": 0.13655, "epss_percentile": 0.94027}, "CVE-2018-5039": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5040": {"epss_score": 0.13655, "epss_percentile": 0.94027}, "CVE-2018-5041": {"epss_score": 0.13655, "epss_percentile": 0.94027}, "CVE-2018-5042": {"epss_score": 0.08358, "epss_percentile": 0.92008}, "CVE-2018-5043": {"epss_score": 0.22661, "epss_percentile": 0.95667}, "CVE-2018-5044": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5045": {"epss_score": 0.13655, "epss_percentile": 0.94027}, "CVE-2018-5046": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5047": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5048": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5049": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5050": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5051": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5052": {"epss_score": 0.13655, "epss_percentile": 0.94027}, "CVE-2018-5053": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5054": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5055": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5056": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5057": {"epss_score": 0.11187, "epss_percentile": 0.93259}, "CVE-2018-5058": {"epss_score": 0.13655, "epss_percentile": 0.94027}, "CVE-2018-5059": {"epss_score": 0.08358, "epss_percentile": 0.92008}, "CVE-2018-5060": {"epss_score": 0.08708, "epss_percentile": 0.9222}, "CVE-2018-5061": {"epss_score": 0.08755, "epss_percentile": 0.92242}, "CVE-2018-5062": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-5063": {"epss_score": 0.23856, "epss_percentile": 0.95825}, "CVE-2018-5064": {"epss_score": 0.23877, "epss_percentile": 0.95829}, "CVE-2018-5065": {"epss_score": 0.19158, "epss_percentile": 0.95141}, "CVE-2018-5066": {"epss_score": 0.07838, "epss_percentile": 0.91709}, "CVE-2018-5067": {"epss_score": 0.13655, "epss_percentile": 0.94027}, "CVE-2018-5068": {"epss_score": 0.23856, "epss_percentile": 0.95825}, "CVE-2018-5069": {"epss_score": 0.23877, "epss_percentile": 0.95829}, "CVE-2018-5070": {"epss_score": 0.23877, "epss_percentile": 0.95829}, "CVE-2018-5071": {"epss_score": 0.00158, "epss_percentile": 0.37223}, "CVE-2018-5072": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-5073": {"epss_score": 0.00111, "epss_percentile": 0.30246}, "CVE-2018-5074": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-5075": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-5076": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-5077": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-5078": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2018-5079": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5080": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5081": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5082": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5083": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5084": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5085": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5086": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5087": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5088": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5089": {"epss_score": 0.02992, "epss_percentile": 0.86147}, "CVE-2018-5090": {"epss_score": 0.02026, "epss_percentile": 0.83315}, "CVE-2018-5091": {"epss_score": 0.02595, "epss_percentile": 0.85191}, "CVE-2018-5092": {"epss_score": 0.01772, "epss_percentile": 0.82202}, "CVE-2018-5093": {"epss_score": 0.3543, "epss_percentile": 0.96908}, "CVE-2018-5094": {"epss_score": 0.3543, "epss_percentile": 0.96908}, "CVE-2018-5095": {"epss_score": 0.02935, "epss_percentile": 0.86024}, "CVE-2018-5096": {"epss_score": 0.01564, "epss_percentile": 0.81059}, "CVE-2018-5097": {"epss_score": 0.24112, "epss_percentile": 0.95876}, "CVE-2018-5098": {"epss_score": 0.02935, "epss_percentile": 0.86024}, "CVE-2018-5099": {"epss_score": 0.02974, "epss_percentile": 0.86103}, "CVE-2018-5100": {"epss_score": 0.22039, "epss_percentile": 0.95587}, "CVE-2018-5101": {"epss_score": 0.01534, "epss_percentile": 0.80904}, "CVE-2018-5102": {"epss_score": 0.24112, "epss_percentile": 0.95876}, "CVE-2018-5103": {"epss_score": 0.02935, "epss_percentile": 0.86024}, "CVE-2018-5104": {"epss_score": 0.24112, "epss_percentile": 0.95876}, "CVE-2018-5105": {"epss_score": 0.00068, "epss_percentile": 0.21229}, "CVE-2018-5106": {"epss_score": 0.00454, "epss_percentile": 0.6326}, "CVE-2018-5107": {"epss_score": 0.01157, "epss_percentile": 0.78114}, "CVE-2018-5108": {"epss_score": 0.00304, "epss_percentile": 0.53269}, "CVE-2018-5109": {"epss_score": 0.00477, "epss_percentile": 0.64349}, "CVE-2018-5110": {"epss_score": 0.00981, "epss_percentile": 0.76284}, "CVE-2018-5111": {"epss_score": 0.00781, "epss_percentile": 0.73176}, "CVE-2018-5112": {"epss_score": 0.01411, "epss_percentile": 0.80087}, "CVE-2018-5113": {"epss_score": 0.01419, "epss_percentile": 0.8016}, "CVE-2018-5114": {"epss_score": 0.00471, "epss_percentile": 0.64}, "CVE-2018-5115": {"epss_score": 0.0171, "epss_percentile": 0.81874}, "CVE-2018-5116": {"epss_score": 0.00462, "epss_percentile": 0.63596}, "CVE-2018-5117": {"epss_score": 0.02154, "epss_percentile": 0.83796}, "CVE-2018-5118": {"epss_score": 0.00506, "epss_percentile": 0.65621}, "CVE-2018-5119": {"epss_score": 0.00431, "epss_percentile": 0.62042}, "CVE-2018-5121": {"epss_score": 0.00981, "epss_percentile": 0.76284}, "CVE-2018-5122": {"epss_score": 0.02388, "epss_percentile": 0.8459}, "CVE-2018-5123": {"epss_score": 0.0014, "epss_percentile": 0.34732}, "CVE-2018-5124": {"epss_score": 0.00557, "epss_percentile": 0.67551}, "CVE-2018-5125": {"epss_score": 0.01069, "epss_percentile": 0.77246}, "CVE-2018-5126": {"epss_score": 0.02042, "epss_percentile": 0.83374}, "CVE-2018-5127": {"epss_score": 0.20177, "epss_percentile": 0.95299}, "CVE-2018-5128": {"epss_score": 0.01513, "epss_percentile": 0.80787}, "CVE-2018-5129": {"epss_score": 0.02331, "epss_percentile": 0.84403}, "CVE-2018-5130": {"epss_score": 0.01156, "epss_percentile": 0.78082}, "CVE-2018-5131": {"epss_score": 0.01281, "epss_percentile": 0.79148}, "CVE-2018-5132": {"epss_score": 0.00913, "epss_percentile": 0.75378}, "CVE-2018-5133": {"epss_score": 0.00639, "epss_percentile": 0.69949}, "CVE-2018-5134": {"epss_score": 0.01171, "epss_percentile": 0.78217}, "CVE-2018-5135": {"epss_score": 0.00964, "epss_percentile": 0.76029}, "CVE-2018-5136": {"epss_score": 0.00858, "epss_percentile": 0.74502}, "CVE-2018-5137": {"epss_score": 0.01362, "epss_percentile": 0.79758}, "CVE-2018-5138": {"epss_score": 0.00807, "epss_percentile": 0.73674}, "CVE-2018-5140": {"epss_score": 0.00454, "epss_percentile": 0.6326}, "CVE-2018-5141": {"epss_score": 0.01071, "epss_percentile": 0.77269}, "CVE-2018-5142": {"epss_score": 0.01178, "epss_percentile": 0.78282}, "CVE-2018-5143": {"epss_score": 0.00468, "epss_percentile": 0.63876}, "CVE-2018-5144": {"epss_score": 0.05728, "epss_percentile": 0.90159}, "CVE-2018-5145": {"epss_score": 0.03916, "epss_percentile": 0.87947}, "CVE-2018-5146": {"epss_score": 0.60166, "epss_percentile": 0.98195}, "CVE-2018-5147": {"epss_score": 0.01425, "epss_percentile": 0.80201}, "CVE-2018-5148": {"epss_score": 0.01596, "epss_percentile": 0.81242}, "CVE-2018-5150": {"epss_score": 0.03916, "epss_percentile": 0.87947}, "CVE-2018-5151": {"epss_score": 0.0372, "epss_percentile": 0.87619}, "CVE-2018-5152": {"epss_score": 0.00457, "epss_percentile": 0.63355}, "CVE-2018-5153": {"epss_score": 0.01246, "epss_percentile": 0.78857}, "CVE-2018-5154": {"epss_score": 0.02921, "epss_percentile": 0.85993}, "CVE-2018-5155": {"epss_score": 0.02921, "epss_percentile": 0.85993}, "CVE-2018-5156": {"epss_score": 0.03107, "epss_percentile": 0.8642}, "CVE-2018-5157": {"epss_score": 0.00587, "epss_percentile": 0.68467}, "CVE-2018-5158": {"epss_score": 0.47796, "epss_percentile": 0.97602}, "CVE-2018-5159": {"epss_score": 0.37556, "epss_percentile": 0.97057}, "CVE-2018-5160": {"epss_score": 0.02374, "epss_percentile": 0.84537}, "CVE-2018-5161": {"epss_score": 0.00925, "epss_percentile": 0.75539}, "CVE-2018-5162": {"epss_score": 0.00918, "epss_percentile": 0.75442}, "CVE-2018-5163": {"epss_score": 0.0198, "epss_percentile": 0.83134}, "CVE-2018-5164": {"epss_score": 0.00374, "epss_percentile": 0.58537}, "CVE-2018-5165": {"epss_score": 0.00769, "epss_percentile": 0.72992}, "CVE-2018-5166": {"epss_score": 0.00752, "epss_percentile": 0.72666}, "CVE-2018-5167": {"epss_score": 0.00646, "epss_percentile": 0.70128}, "CVE-2018-5168": {"epss_score": 0.01032, "epss_percentile": 0.76861}, "CVE-2018-5169": {"epss_score": 0.00587, "epss_percentile": 0.68464}, "CVE-2018-5170": {"epss_score": 0.00881, "epss_percentile": 0.74879}, "CVE-2018-5172": {"epss_score": 0.00694, "epss_percentile": 0.71362}, "CVE-2018-5173": {"epss_score": 0.01028, "epss_percentile": 0.76822}, "CVE-2018-5174": {"epss_score": 0.0054, "epss_percentile": 0.66993}, "CVE-2018-5175": {"epss_score": 0.00574, "epss_percentile": 0.68074}, "CVE-2018-5176": {"epss_score": 0.00387, "epss_percentile": 0.59289}, "CVE-2018-5177": {"epss_score": 0.00305, "epss_percentile": 0.53347}, "CVE-2018-5178": {"epss_score": 0.18164, "epss_percentile": 0.94968}, "CVE-2018-5179": {"epss_score": 0.00348, "epss_percentile": 0.56852}, "CVE-2018-5180": {"epss_score": 0.01761, "epss_percentile": 0.82152}, "CVE-2018-5181": {"epss_score": 0.01262, "epss_percentile": 0.78983}, "CVE-2018-5182": {"epss_score": 0.01014, "epss_percentile": 0.76646}, "CVE-2018-5183": {"epss_score": 0.03916, "epss_percentile": 0.87947}, "CVE-2018-5184": {"epss_score": 0.01035, "epss_percentile": 0.76903}, "CVE-2018-5185": {"epss_score": 0.00329, "epss_percentile": 0.55412}, "CVE-2018-5186": {"epss_score": 0.02154, "epss_percentile": 0.83795}, "CVE-2018-5187": {"epss_score": 0.02336, "epss_percentile": 0.84416}, "CVE-2018-5188": {"epss_score": 0.03842, "epss_percentile": 0.87834}, "CVE-2018-5189": {"epss_score": 0.00199, "epss_percentile": 0.42113}, "CVE-2018-5190": {"epss_score": 0.00441, "epss_percentile": 0.62678}, "CVE-2018-5195": {"epss_score": 0.01136, "epss_percentile": 0.77914}, "CVE-2018-5196": {"epss_score": 0.00545, "epss_percentile": 0.67165}, "CVE-2018-5197": {"epss_score": 0.01092, "epss_percentile": 0.77463}, "CVE-2018-5198": {"epss_score": 0.01048, "epss_percentile": 0.77052}, "CVE-2018-5199": {"epss_score": 0.00502, "epss_percentile": 0.65374}, "CVE-2018-5200": {"epss_score": 0.03147, "epss_percentile": 0.86498}, "CVE-2018-5201": {"epss_score": 0.00163, "epss_percentile": 0.37789}, "CVE-2018-5202": {"epss_score": 0.006, "epss_percentile": 0.68821}, "CVE-2018-5203": {"epss_score": 0.02002, "epss_percentile": 0.83223}, "CVE-2018-5204": {"epss_score": 0.02002, "epss_percentile": 0.83223}, "CVE-2018-5205": {"epss_score": 0.00593, "epss_percentile": 0.68635}, "CVE-2018-5206": {"epss_score": 0.00584, "epss_percentile": 0.68394}, "CVE-2018-5207": {"epss_score": 0.00525, "epss_percentile": 0.66386}, "CVE-2018-5208": {"epss_score": 0.00919, "epss_percentile": 0.75456}, "CVE-2018-5210": {"epss_score": 0.01357, "epss_percentile": 0.79722}, "CVE-2018-5211": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5212": {"epss_score": 0.00415, "epss_percentile": 0.61113}, "CVE-2018-5213": {"epss_score": 0.00415, "epss_percentile": 0.61113}, "CVE-2018-5214": {"epss_score": 0.00247, "epss_percentile": 0.47836}, "CVE-2018-5215": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2018-5216": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2018-5217": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5218": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5219": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5220": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5221": {"epss_score": 0.07231, "epss_percentile": 0.91338}, "CVE-2018-5223": {"epss_score": 0.00909, "epss_percentile": 0.753}, "CVE-2018-5224": {"epss_score": 0.00929, "epss_percentile": 0.75595}, "CVE-2018-5225": {"epss_score": 0.02693, "epss_percentile": 0.8544}, "CVE-2018-5226": {"epss_score": 0.00528, "epss_percentile": 0.66537}, "CVE-2018-5227": {"epss_score": 0.00158, "epss_percentile": 0.37234}, "CVE-2018-5228": {"epss_score": 0.00264, "epss_percentile": 0.4975}, "CVE-2018-5229": {"epss_score": 0.00175, "epss_percentile": 0.39367}, "CVE-2018-5230": {"epss_score": 0.24983, "epss_percentile": 0.95975}, "CVE-2018-5231": {"epss_score": 0.00979, "epss_percentile": 0.76263}, "CVE-2018-5232": {"epss_score": 0.00231, "epss_percentile": 0.45828}, "CVE-2018-5233": {"epss_score": 0.18828, "epss_percentile": 0.95076}, "CVE-2018-5234": {"epss_score": 0.18694, "epss_percentile": 0.95055}, "CVE-2018-5235": {"epss_score": 0.00156, "epss_percentile": 0.36917}, "CVE-2018-5236": {"epss_score": 0.00512, "epss_percentile": 0.65858}, "CVE-2018-5237": {"epss_score": 0.01262, "epss_percentile": 0.78979}, "CVE-2018-5238": {"epss_score": 0.00496, "epss_percentile": 0.65148}, "CVE-2018-5239": {"epss_score": 0.00069, "epss_percentile": 0.21574}, "CVE-2018-5240": {"epss_score": 0.00511, "epss_percentile": 0.65838}, "CVE-2018-5241": {"epss_score": 0.09312, "epss_percentile": 0.92496}, "CVE-2018-5242": {"epss_score": 0.00069, "epss_percentile": 0.21574}, "CVE-2018-5243": {"epss_score": 0.00629, "epss_percentile": 0.6967}, "CVE-2018-5244": {"epss_score": 0.00059, "epss_percentile": 0.18804}, "CVE-2018-5246": {"epss_score": 0.00215, "epss_percentile": 0.44095}, "CVE-2018-5247": {"epss_score": 0.00436, "epss_percentile": 0.62468}, "CVE-2018-5248": {"epss_score": 0.00661, "epss_percentile": 0.70578}, "CVE-2018-5249": {"epss_score": 0.0031, "epss_percentile": 0.53772}, "CVE-2018-5251": {"epss_score": 0.00561, "epss_percentile": 0.67674}, "CVE-2018-5252": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2018-5253": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2018-5254": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2018-5255": {"epss_score": 0.00605, "epss_percentile": 0.68988}, "CVE-2018-5256": {"epss_score": 0.00608, "epss_percentile": 0.69083}, "CVE-2018-5258": {"epss_score": 0.00231, "epss_percentile": 0.45807}, "CVE-2018-5259": {"epss_score": 0.00104, "epss_percentile": 0.29246}, "CVE-2018-5261": {"epss_score": 0.00047, "epss_percentile": 0.14616}, "CVE-2018-5262": {"epss_score": 0.40916, "epss_percentile": 0.97244}, "CVE-2018-5263": {"epss_score": 0.00226, "epss_percentile": 0.45272}, "CVE-2018-5264": {"epss_score": 0.00662, "epss_percentile": 0.7059}, "CVE-2018-5265": {"epss_score": 0.02743, "epss_percentile": 0.85565}, "CVE-2018-5266": {"epss_score": 0.00339, "epss_percentile": 0.56174}, "CVE-2018-5267": {"epss_score": 0.00167, "epss_percentile": 0.38309}, "CVE-2018-5268": {"epss_score": 0.00336, "epss_percentile": 0.55916}, "CVE-2018-5269": {"epss_score": 0.005, "epss_percentile": 0.65313}, "CVE-2018-5270": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5271": {"epss_score": 0.00047, "epss_percentile": 0.14592}, "CVE-2018-5272": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5273": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5274": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5275": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5276": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5277": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5278": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-5279": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-5280": {"epss_score": 0.00302, "epss_percentile": 0.53136}, "CVE-2018-5281": {"epss_score": 0.0034, "epss_percentile": 0.56233}, "CVE-2018-5282": {"epss_score": 0.0098, "epss_percentile": 0.76273}, "CVE-2018-5283": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2018-5284": {"epss_score": 0.00267, "epss_percentile": 0.49972}, "CVE-2018-5285": {"epss_score": 0.00164, "epss_percentile": 0.38001}, "CVE-2018-5286": {"epss_score": 0.00252, "epss_percentile": 0.48386}, "CVE-2018-5287": {"epss_score": 0.11137, "epss_percentile": 0.93235}, "CVE-2018-5288": {"epss_score": 0.00378, "epss_percentile": 0.58802}, "CVE-2018-5289": {"epss_score": 0.11137, "epss_percentile": 0.93235}, "CVE-2018-5290": {"epss_score": 0.11137, "epss_percentile": 0.93235}, "CVE-2018-5291": {"epss_score": 0.11137, "epss_percentile": 0.93235}, "CVE-2018-5292": {"epss_score": 0.00252, "epss_percentile": 0.48386}, "CVE-2018-5293": {"epss_score": 0.00252, "epss_percentile": 0.48386}, "CVE-2018-5294": {"epss_score": 0.00623, "epss_percentile": 0.6955}, "CVE-2018-5295": {"epss_score": 0.00374, "epss_percentile": 0.58583}, "CVE-2018-5296": {"epss_score": 0.00374, "epss_percentile": 0.58583}, "CVE-2018-5298": {"epss_score": 0.00075, "epss_percentile": 0.23037}, "CVE-2018-5299": {"epss_score": 0.02465, "epss_percentile": 0.84835}, "CVE-2018-5301": {"epss_score": 0.0003, "epss_percentile": 0.08145}, "CVE-2018-5303": {"epss_score": 0.00188, "epss_percentile": 0.40868}, "CVE-2018-5304": {"epss_score": 0.00259, "epss_percentile": 0.49097}, "CVE-2018-5306": {"epss_score": 0.00329, "epss_percentile": 0.55394}, "CVE-2018-5307": {"epss_score": 0.0032, "epss_percentile": 0.54611}, "CVE-2018-5308": {"epss_score": 0.00957, "epss_percentile": 0.75932}, "CVE-2018-5309": {"epss_score": 0.00325, "epss_percentile": 0.55004}, "CVE-2018-5310": {"epss_score": 0.0058, "epss_percentile": 0.6824}, "CVE-2018-5311": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2018-5312": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2018-5313": {"epss_score": 0.0004, "epss_percentile": 0.11953}, "CVE-2018-5314": {"epss_score": 0.03308, "epss_percentile": 0.86882}, "CVE-2018-5315": {"epss_score": 0.06691, "epss_percentile": 0.9095}, "CVE-2018-5316": {"epss_score": 0.02338, "epss_percentile": 0.84422}, "CVE-2018-5319": {"epss_score": 0.4578, "epss_percentile": 0.97502}, "CVE-2018-5326": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2018-5327": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2018-5328": {"epss_score": 0.00457, "epss_percentile": 0.63385}, "CVE-2018-5329": {"epss_score": 0.00246, "epss_percentile": 0.47731}, "CVE-2018-5330": {"epss_score": 0.00595, "epss_percentile": 0.68697}, "CVE-2018-5331": {"epss_score": 0.00231, "epss_percentile": 0.45767}, "CVE-2018-5332": {"epss_score": 0.00028, "epss_percentile": 0.0724}, "CVE-2018-5333": {"epss_score": 0.01291, "epss_percentile": 0.7923}, "CVE-2018-5334": {"epss_score": 0.00865, "epss_percentile": 0.74619}, "CVE-2018-5335": {"epss_score": 0.00865, "epss_percentile": 0.74619}, "CVE-2018-5336": {"epss_score": 0.01005, "epss_percentile": 0.7654}, "CVE-2018-5337": {"epss_score": 0.1045, "epss_percentile": 0.9299}, "CVE-2018-5338": {"epss_score": 0.04131, "epss_percentile": 0.88297}, "CVE-2018-5339": {"epss_score": 0.02382, "epss_percentile": 0.84567}, "CVE-2018-5340": {"epss_score": 0.07061, "epss_percentile": 0.9122}, "CVE-2018-5341": {"epss_score": 0.07753, "epss_percentile": 0.9166}, "CVE-2018-5342": {"epss_score": 0.02065, "epss_percentile": 0.83455}, "CVE-2018-5344": {"epss_score": 0.00064, "epss_percentile": 0.20393}, "CVE-2018-5345": {"epss_score": 0.00752, "epss_percentile": 0.72653}, "CVE-2018-5347": {"epss_score": 0.37778, "epss_percentile": 0.97068}, "CVE-2018-5349": {"epss_score": 0.00036, "epss_percentile": 0.10323}, "CVE-2018-5353": {"epss_score": 0.15292, "epss_percentile": 0.94402}, "CVE-2018-5354": {"epss_score": 0.0392, "epss_percentile": 0.87951}, "CVE-2018-5357": {"epss_score": 0.00502, "epss_percentile": 0.65374}, "CVE-2018-5358": {"epss_score": 0.00408, "epss_percentile": 0.60658}, "CVE-2018-5359": {"epss_score": 0.29265, "epss_percentile": 0.96429}, "CVE-2018-5360": {"epss_score": 0.00456, "epss_percentile": 0.63341}, "CVE-2018-5361": {"epss_score": 0.00489, "epss_percentile": 0.6491}, "CVE-2018-5362": {"epss_score": 0.00413, "epss_percentile": 0.60996}, "CVE-2018-5363": {"epss_score": 0.0031, "epss_percentile": 0.53766}, "CVE-2018-5364": {"epss_score": 0.00413, "epss_percentile": 0.60996}, "CVE-2018-5365": {"epss_score": 0.0031, "epss_percentile": 0.53766}, "CVE-2018-5366": {"epss_score": 0.0031, "epss_percentile": 0.53766}, "CVE-2018-5367": {"epss_score": 0.00421, "epss_percentile": 0.61499}, "CVE-2018-5368": {"epss_score": 0.00216, "epss_percentile": 0.44226}, "CVE-2018-5369": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2018-5370": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-5371": {"epss_score": 0.18029, "epss_percentile": 0.94946}, "CVE-2018-5372": {"epss_score": 0.00479, "epss_percentile": 0.64445}, "CVE-2018-5373": {"epss_score": 0.00479, "epss_percentile": 0.64445}, "CVE-2018-5374": {"epss_score": 0.00479, "epss_percentile": 0.64445}, "CVE-2018-5375": {"epss_score": 0.00286, "epss_percentile": 0.51749}, "CVE-2018-5376": {"epss_score": 0.00286, "epss_percentile": 0.51749}, "CVE-2018-5377": {"epss_score": 0.0011, "epss_percentile": 0.30077}, "CVE-2018-5378": {"epss_score": 0.09623, "epss_percentile": 0.92628}, "CVE-2018-5379": {"epss_score": 0.05495, "epss_percentile": 0.89932}, "CVE-2018-5380": {"epss_score": 0.00861, "epss_percentile": 0.74555}, "CVE-2018-5381": {"epss_score": 0.04351, "epss_percentile": 0.88585}, "CVE-2018-5382": {"epss_score": 0.00153, "epss_percentile": 0.36539}, "CVE-2018-5383": {"epss_score": 0.00875, "epss_percentile": 0.74779}, "CVE-2018-5384": {"epss_score": 0.03313, "epss_percentile": 0.86896}, "CVE-2018-5385": {"epss_score": 0.01242, "epss_percentile": 0.78821}, "CVE-2018-5386": {"epss_score": 0.03342, "epss_percentile": 0.86944}, "CVE-2018-5387": {"epss_score": 0.00227, "epss_percentile": 0.45458}, "CVE-2018-5388": {"epss_score": 0.04302, "epss_percentile": 0.88517}, "CVE-2018-5389": {"epss_score": 0.01402, "epss_percentile": 0.80011}, "CVE-2018-5390": {"epss_score": 0.06836, "epss_percentile": 0.91058}, "CVE-2018-5391": {"epss_score": 0.05102, "epss_percentile": 0.89498}, "CVE-2018-5392": {"epss_score": 0.0025, "epss_percentile": 0.48101}, "CVE-2018-5393": {"epss_score": 0.15741, "epss_percentile": 0.94497}, "CVE-2018-5399": {"epss_score": 0.00205, "epss_percentile": 0.42757}, "CVE-2018-5400": {"epss_score": 0.00112, "epss_percentile": 0.30429}, "CVE-2018-5401": {"epss_score": 0.00096, "epss_percentile": 0.27274}, "CVE-2018-5402": {"epss_score": 0.00097, "epss_percentile": 0.27632}, "CVE-2018-5403": {"epss_score": 0.0467, "epss_percentile": 0.88985}, "CVE-2018-5404": {"epss_score": 0.00463, "epss_percentile": 0.63674}, "CVE-2018-5405": {"epss_score": 0.04351, "epss_percentile": 0.88585}, "CVE-2018-5406": {"epss_score": 0.16595, "epss_percentile": 0.94699}, "CVE-2018-5407": {"epss_score": 0.00643, "epss_percentile": 0.70055}, "CVE-2018-5408": {"epss_score": 0.00123, "epss_percentile": 0.32255}, "CVE-2018-5409": {"epss_score": 0.00193, "epss_percentile": 0.41429}, "CVE-2018-5410": {"epss_score": 0.00959, "epss_percentile": 0.75959}, "CVE-2018-5411": {"epss_score": 0.00215, "epss_percentile": 0.44117}, "CVE-2018-5412": {"epss_score": 0.00164, "epss_percentile": 0.37937}, "CVE-2018-5413": {"epss_score": 0.00358, "epss_percentile": 0.575}, "CVE-2018-5428": {"epss_score": 0.00486, "epss_percentile": 0.64775}, "CVE-2018-5429": {"epss_score": 0.0094, "epss_percentile": 0.75728}, "CVE-2018-5430": {"epss_score": 0.54955, "epss_percentile": 0.97954}, "CVE-2018-5431": {"epss_score": 0.0025, "epss_percentile": 0.48098}, "CVE-2018-5432": {"epss_score": 0.00196, "epss_percentile": 0.41729}, "CVE-2018-5433": {"epss_score": 0.0022, "epss_percentile": 0.44582}, "CVE-2018-5434": {"epss_score": 0.0022, "epss_percentile": 0.44582}, "CVE-2018-5435": {"epss_score": 0.01478, "epss_percentile": 0.80557}, "CVE-2018-5436": {"epss_score": 0.00199, "epss_percentile": 0.4216}, "CVE-2018-5437": {"epss_score": 0.00333, "epss_percentile": 0.55647}, "CVE-2018-5438": {"epss_score": 0.00326, "epss_percentile": 0.55061}, "CVE-2018-5439": {"epss_score": 0.01249, "epss_percentile": 0.78874}, "CVE-2018-5440": {"epss_score": 0.01311, "epss_percentile": 0.79368}, "CVE-2018-5441": {"epss_score": 0.00037, "epss_percentile": 0.10732}, "CVE-2018-5442": {"epss_score": 0.04785, "epss_percentile": 0.89141}, "CVE-2018-5443": {"epss_score": 0.00135, "epss_percentile": 0.33938}, "CVE-2018-5445": {"epss_score": 0.0107, "epss_percentile": 0.77259}, "CVE-2018-5446": {"epss_score": 0.0009, "epss_percentile": 0.26153}, "CVE-2018-5447": {"epss_score": 0.00412, "epss_percentile": 0.60918}, "CVE-2018-5448": {"epss_score": 0.00123, "epss_percentile": 0.32211}, "CVE-2018-5449": {"epss_score": 0.00071, "epss_percentile": 0.22104}, "CVE-2018-5451": {"epss_score": 0.00659, "epss_percentile": 0.70514}, "CVE-2018-5452": {"epss_score": 0.01689, "epss_percentile": 0.81767}, "CVE-2018-5453": {"epss_score": 0.0023, "epss_percentile": 0.45729}, "CVE-2018-5454": {"epss_score": 0.01542, "epss_percentile": 0.80951}, "CVE-2018-5455": {"epss_score": 0.00447, "epss_percentile": 0.6296}, "CVE-2018-5457": {"epss_score": 0.00073, "epss_percentile": 0.22653}, "CVE-2018-5458": {"epss_score": 0.00113, "epss_percentile": 0.30649}, "CVE-2018-5459": {"epss_score": 0.00907, "epss_percentile": 0.75265}, "CVE-2018-5461": {"epss_score": 0.00019, "epss_percentile": 0.04274}, "CVE-2018-5462": {"epss_score": 0.00283, "epss_percentile": 0.51365}, "CVE-2018-5463": {"epss_score": 0.00102, "epss_percentile": 0.28772}, "CVE-2018-5464": {"epss_score": 0.00283, "epss_percentile": 0.51365}, "CVE-2018-5465": {"epss_score": 0.00046, "epss_percentile": 0.14145}, "CVE-2018-5466": {"epss_score": 0.00283, "epss_percentile": 0.51365}, "CVE-2018-5467": {"epss_score": 0.00041, "epss_percentile": 0.12244}, "CVE-2018-5468": {"epss_score": 0.02149, "epss_percentile": 0.83777}, "CVE-2018-5469": {"epss_score": 0.00194, "epss_percentile": 0.41599}, "CVE-2018-5470": {"epss_score": 0.00129, "epss_percentile": 0.33118}, "CVE-2018-5471": {"epss_score": 0.00049, "epss_percentile": 0.15608}, "CVE-2018-5472": {"epss_score": 0.01843, "epss_percentile": 0.82501}, "CVE-2018-5473": {"epss_score": 0.04056, "epss_percentile": 0.88186}, "CVE-2018-5474": {"epss_score": 0.05763, "epss_percentile": 0.90185}, "CVE-2018-5475": {"epss_score": 0.04449, "epss_percentile": 0.88701}, "CVE-2018-5476": {"epss_score": 0.00389, "epss_percentile": 0.59462}, "CVE-2018-5477": {"epss_score": 0.00219, "epss_percentile": 0.44446}, "CVE-2018-5478": {"epss_score": 0.00076, "epss_percentile": 0.23229}, "CVE-2018-5479": {"epss_score": 0.00259, "epss_percentile": 0.49043}, "CVE-2018-5481": {"epss_score": 0.00124, "epss_percentile": 0.32434}, "CVE-2018-5482": {"epss_score": 0.00142, "epss_percentile": 0.35014}, "CVE-2018-5485": {"epss_score": 0.00168, "epss_percentile": 0.38505}, "CVE-2018-5486": {"epss_score": 0.00107, "epss_percentile": 0.29726}, "CVE-2018-5487": {"epss_score": 0.02362, "epss_percentile": 0.84505}, "CVE-2018-5488": {"epss_score": 0.02125, "epss_percentile": 0.83691}, "CVE-2018-5489": {"epss_score": 0.00204, "epss_percentile": 0.4266}, "CVE-2018-5490": {"epss_score": 0.0032, "epss_percentile": 0.54574}, "CVE-2018-5492": {"epss_score": 0.02126, "epss_percentile": 0.83694}, "CVE-2018-5493": {"epss_score": 0.00636, "epss_percentile": 0.69873}, "CVE-2018-5495": {"epss_score": 0.00735, "epss_percentile": 0.72299}, "CVE-2018-5496": {"epss_score": 0.00174, "epss_percentile": 0.39158}, "CVE-2018-5497": {"epss_score": 0.00145, "epss_percentile": 0.35519}, "CVE-2018-5498": {"epss_score": 0.00513, "epss_percentile": 0.65891}, "CVE-2018-5499": {"epss_score": 0.00482, "epss_percentile": 0.64532}, "CVE-2018-5500": {"epss_score": 0.00675, "epss_percentile": 0.7091}, "CVE-2018-5501": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2018-5502": {"epss_score": 0.00418, "epss_percentile": 0.61264}, "CVE-2018-5503": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2018-5504": {"epss_score": 0.02912, "epss_percentile": 0.85973}, "CVE-2018-5505": {"epss_score": 0.01179, "epss_percentile": 0.78291}, "CVE-2018-5506": {"epss_score": 0.00193, "epss_percentile": 0.41441}, "CVE-2018-5507": {"epss_score": 0.00509, "epss_percentile": 0.65745}, "CVE-2018-5508": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2018-5509": {"epss_score": 0.01338, "epss_percentile": 0.79567}, "CVE-2018-5510": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2018-5511": {"epss_score": 0.05754, "epss_percentile": 0.90179}, "CVE-2018-5512": {"epss_score": 0.02225, "epss_percentile": 0.8407}, "CVE-2018-5513": {"epss_score": 0.00749, "epss_percentile": 0.72607}, "CVE-2018-5514": {"epss_score": 0.02678, "epss_percentile": 0.85412}, "CVE-2018-5515": {"epss_score": 0.04029, "epss_percentile": 0.88147}, "CVE-2018-5516": {"epss_score": 0.00115, "epss_percentile": 0.30909}, "CVE-2018-5517": {"epss_score": 0.00749, "epss_percentile": 0.72607}, "CVE-2018-5518": {"epss_score": 0.00112, "epss_percentile": 0.30522}, "CVE-2018-5519": {"epss_score": 0.00197, "epss_percentile": 0.41823}, "CVE-2018-5520": {"epss_score": 0.00189, "epss_percentile": 0.4099}, "CVE-2018-5521": {"epss_score": 0.00345, "epss_percentile": 0.56584}, "CVE-2018-5522": {"epss_score": 0.00675, "epss_percentile": 0.7091}, "CVE-2018-5523": {"epss_score": 0.00396, "epss_percentile": 0.59864}, "CVE-2018-5524": {"epss_score": 0.00604, "epss_percentile": 0.68958}, "CVE-2018-5525": {"epss_score": 0.00162, "epss_percentile": 0.37731}, "CVE-2018-5526": {"epss_score": 0.01243, "epss_percentile": 0.78826}, "CVE-2018-5527": {"epss_score": 0.00969, "epss_percentile": 0.76104}, "CVE-2018-5528": {"epss_score": 0.00301, "epss_percentile": 0.53049}, "CVE-2018-5529": {"epss_score": 0.00231, "epss_percentile": 0.45841}, "CVE-2018-5530": {"epss_score": 0.00749, "epss_percentile": 0.72607}, "CVE-2018-5531": {"epss_score": 0.00177, "epss_percentile": 0.39609}, "CVE-2018-5532": {"epss_score": 0.00387, "epss_percentile": 0.59301}, "CVE-2018-5533": {"epss_score": 0.00749, "epss_percentile": 0.72607}, "CVE-2018-5534": {"epss_score": 0.00749, "epss_percentile": 0.72607}, "CVE-2018-5535": {"epss_score": 0.01305, "epss_percentile": 0.7932}, "CVE-2018-5536": {"epss_score": 0.0115, "epss_percentile": 0.7803}, "CVE-2018-5537": {"epss_score": 0.0069, "epss_percentile": 0.71248}, "CVE-2018-5538": {"epss_score": 0.00378, "epss_percentile": 0.58809}, "CVE-2018-5539": {"epss_score": 0.00749, "epss_percentile": 0.72607}, "CVE-2018-5540": {"epss_score": 0.00124, "epss_percentile": 0.32388}, "CVE-2018-5541": {"epss_score": 0.00588, "epss_percentile": 0.68492}, "CVE-2018-5542": {"epss_score": 0.00837, "epss_percentile": 0.74155}, "CVE-2018-5543": {"epss_score": 0.00195, "epss_percentile": 0.41656}, "CVE-2018-5544": {"epss_score": 0.01673, "epss_percentile": 0.81687}, "CVE-2018-5545": {"epss_score": 0.00792, "epss_percentile": 0.73411}, "CVE-2018-5546": {"epss_score": 0.00127, "epss_percentile": 0.32782}, "CVE-2018-5547": {"epss_score": 0.00132, "epss_percentile": 0.33535}, "CVE-2018-5548": {"epss_score": 0.00209, "epss_percentile": 0.43416}, "CVE-2018-5549": {"epss_score": 0.00749, "epss_percentile": 0.72607}, "CVE-2018-5550": {"epss_score": 0.02188, "epss_percentile": 0.83928}, "CVE-2018-5551": {"epss_score": 0.00731, "epss_percentile": 0.72173}, "CVE-2018-5552": {"epss_score": 0.00025, "epss_percentile": 0.06068}, "CVE-2018-5553": {"epss_score": 0.08477, "epss_percentile": 0.92072}, "CVE-2018-5559": {"epss_score": 0.00149, "epss_percentile": 0.35977}, "CVE-2018-5560": {"epss_score": 0.00472, "epss_percentile": 0.64031}, "CVE-2018-5650": {"epss_score": 0.00402, "epss_percentile": 0.60314}, "CVE-2018-5651": {"epss_score": 0.00314, "epss_percentile": 0.54122}, "CVE-2018-5652": {"epss_score": 0.00267, "epss_percentile": 0.49981}, "CVE-2018-5653": {"epss_score": 0.00211, "epss_percentile": 0.43673}, "CVE-2018-5654": {"epss_score": 0.00193, "epss_percentile": 0.41438}, "CVE-2018-5655": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-5656": {"epss_score": 0.00113, "epss_percentile": 0.30726}, "CVE-2018-5657": {"epss_score": 0.00338, "epss_percentile": 0.5607}, "CVE-2018-5658": {"epss_score": 0.00146, "epss_percentile": 0.35539}, "CVE-2018-5659": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2018-5660": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2018-5661": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2018-5662": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2018-5663": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2018-5664": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2018-5665": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2018-5666": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2018-5667": {"epss_score": 0.00338, "epss_percentile": 0.5607}, "CVE-2018-5668": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2018-5669": {"epss_score": 0.00216, "epss_percentile": 0.44226}, "CVE-2018-5670": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2018-5671": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2018-5672": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2018-5673": {"epss_score": 0.00216, "epss_percentile": 0.44226}, "CVE-2018-5674": {"epss_score": 0.01503, "epss_percentile": 0.8073}, "CVE-2018-5675": {"epss_score": 0.01293, "epss_percentile": 0.79238}, "CVE-2018-5676": {"epss_score": 0.01503, "epss_percentile": 0.8073}, "CVE-2018-5677": {"epss_score": 0.01431, "epss_percentile": 0.80245}, "CVE-2018-5678": {"epss_score": 0.01503, "epss_percentile": 0.8073}, "CVE-2018-5679": {"epss_score": 0.01431, "epss_percentile": 0.80245}, "CVE-2018-5680": {"epss_score": 0.01431, "epss_percentile": 0.80245}, "CVE-2018-5681": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-5682": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2018-5683": {"epss_score": 0.00027, "epss_percentile": 0.07139}, "CVE-2018-5684": {"epss_score": 0.00436, "epss_percentile": 0.62482}, "CVE-2018-5685": {"epss_score": 0.00373, "epss_percentile": 0.58513}, "CVE-2018-5686": {"epss_score": 0.0038, "epss_percentile": 0.58948}, "CVE-2018-5687": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-5688": {"epss_score": 0.0353, "epss_percentile": 0.87301}, "CVE-2018-5689": {"epss_score": 0.00164, "epss_percentile": 0.37969}, "CVE-2018-5690": {"epss_score": 0.00164, "epss_percentile": 0.37969}, "CVE-2018-5691": {"epss_score": 0.00359, "epss_percentile": 0.57594}, "CVE-2018-5692": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-5693": {"epss_score": 0.00048, "epss_percentile": 0.1512}, "CVE-2018-5694": {"epss_score": 0.01326, "epss_percentile": 0.79478}, "CVE-2018-5695": {"epss_score": 0.00511, "epss_percentile": 0.65834}, "CVE-2018-5696": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-5697": {"epss_score": 0.00247, "epss_percentile": 0.47867}, "CVE-2018-5698": {"epss_score": 0.00218, "epss_percentile": 0.44358}, "CVE-2018-5700": {"epss_score": 0.03936, "epss_percentile": 0.87985}, "CVE-2018-5701": {"epss_score": 0.19659, "epss_percentile": 0.95222}, "CVE-2018-5702": {"epss_score": 0.27224, "epss_percentile": 0.96222}, "CVE-2018-5703": {"epss_score": 0.00489, "epss_percentile": 0.6491}, "CVE-2018-5704": {"epss_score": 0.0189, "epss_percentile": 0.82725}, "CVE-2018-5705": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-5706": {"epss_score": 0.00196, "epss_percentile": 0.41818}, "CVE-2018-5708": {"epss_score": 0.04198, "epss_percentile": 0.88382}, "CVE-2018-5709": {"epss_score": 0.00463, "epss_percentile": 0.63635}, "CVE-2018-5710": {"epss_score": 0.00563, "epss_percentile": 0.67741}, "CVE-2018-5711": {"epss_score": 0.10274, "epss_percentile": 0.92922}, "CVE-2018-5712": {"epss_score": 0.8761, "epss_percentile": 0.99435}, "CVE-2018-5713": {"epss_score": 0.00209, "epss_percentile": 0.4338}, "CVE-2018-5714": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5715": {"epss_score": 0.06802, "epss_percentile": 0.91035}, "CVE-2018-5716": {"epss_score": 0.00427, "epss_percentile": 0.61915}, "CVE-2018-5717": {"epss_score": 0.00694, "epss_percentile": 0.7136}, "CVE-2018-5718": {"epss_score": 0.0004, "epss_percentile": 0.12169}, "CVE-2018-5720": {"epss_score": 0.00258, "epss_percentile": 0.49014}, "CVE-2018-5721": {"epss_score": 0.01725, "epss_percentile": 0.81955}, "CVE-2018-5723": {"epss_score": 0.38026, "epss_percentile": 0.97082}, "CVE-2018-5724": {"epss_score": 0.38661, "epss_percentile": 0.97112}, "CVE-2018-5725": {"epss_score": 0.19489, "epss_percentile": 0.95192}, "CVE-2018-5726": {"epss_score": 0.57603, "epss_percentile": 0.98074}, "CVE-2018-5727": {"epss_score": 0.00724, "epss_percentile": 0.7204}, "CVE-2018-5728": {"epss_score": 0.00291, "epss_percentile": 0.52195}, "CVE-2018-5729": {"epss_score": 0.00076, "epss_percentile": 0.23264}, "CVE-2018-5730": {"epss_score": 0.00425, "epss_percentile": 0.61687}, "CVE-2018-5731": {"epss_score": 0.00086, "epss_percentile": 0.2542}, "CVE-2018-5732": {"epss_score": 0.01756, "epss_percentile": 0.82123}, "CVE-2018-5733": {"epss_score": 0.28413, "epss_percentile": 0.96354}, "CVE-2018-5734": {"epss_score": 0.07264, "epss_percentile": 0.91357}, "CVE-2018-5735": {"epss_score": 0.00635, "epss_percentile": 0.69819}, "CVE-2018-5736": {"epss_score": 0.42906, "epss_percentile": 0.9736}, "CVE-2018-5737": {"epss_score": 0.01186, "epss_percentile": 0.78347}, "CVE-2018-5738": {"epss_score": 0.02389, "epss_percentile": 0.84593}, "CVE-2018-5739": {"epss_score": 0.0327, "epss_percentile": 0.86791}, "CVE-2018-5740": {"epss_score": 0.6902, "epss_percentile": 0.98574}, "CVE-2018-5741": {"epss_score": 0.00431, "epss_percentile": 0.62058}, "CVE-2018-5742": {"epss_score": 0.01301, "epss_percentile": 0.79292}, "CVE-2018-5743": {"epss_score": 0.01766, "epss_percentile": 0.82171}, "CVE-2018-5744": {"epss_score": 0.04466, "epss_percentile": 0.88728}, "CVE-2018-5745": {"epss_score": 0.00562, "epss_percentile": 0.67691}, "CVE-2018-5747": {"epss_score": 0.00236, "epss_percentile": 0.46375}, "CVE-2018-5748": {"epss_score": 0.01359, "epss_percentile": 0.79737}, "CVE-2018-5749": {"epss_score": 0.02343, "epss_percentile": 0.84441}, "CVE-2018-5750": {"epss_score": 0.00037, "epss_percentile": 0.10884}, "CVE-2018-5751": {"epss_score": 0.01278, "epss_percentile": 0.79129}, "CVE-2018-5752": {"epss_score": 0.01576, "epss_percentile": 0.81112}, "CVE-2018-5753": {"epss_score": 0.01747, "epss_percentile": 0.82072}, "CVE-2018-5754": {"epss_score": 0.00322, "epss_percentile": 0.54746}, "CVE-2018-5755": {"epss_score": 0.00616, "epss_percentile": 0.69318}, "CVE-2018-5756": {"epss_score": 0.00718, "epss_percentile": 0.71935}, "CVE-2018-5757": {"epss_score": 0.13065, "epss_percentile": 0.93863}, "CVE-2018-5758": {"epss_score": 0.06142, "epss_percentile": 0.90514}, "CVE-2018-5759": {"epss_score": 0.03779, "epss_percentile": 0.87714}, "CVE-2018-5761": {"epss_score": 0.00132, "epss_percentile": 0.33609}, "CVE-2018-5762": {"epss_score": 0.00297, "epss_percentile": 0.5277}, "CVE-2018-5763": {"epss_score": 0.00504, "epss_percentile": 0.65551}, "CVE-2018-5764": {"epss_score": 0.0769, "epss_percentile": 0.91629}, "CVE-2018-5766": {"epss_score": 0.00773, "epss_percentile": 0.73052}, "CVE-2018-5767": {"epss_score": 0.66661, "epss_percentile": 0.98473}, "CVE-2018-5768": {"epss_score": 0.02231, "epss_percentile": 0.84087}, "CVE-2018-5770": {"epss_score": 0.03666, "epss_percentile": 0.87534}, "CVE-2018-5772": {"epss_score": 0.00427, "epss_percentile": 0.61887}, "CVE-2018-5773": {"epss_score": 0.00358, "epss_percentile": 0.57534}, "CVE-2018-5776": {"epss_score": 0.03133, "epss_percentile": 0.86477}, "CVE-2018-5777": {"epss_score": 0.00096, "epss_percentile": 0.27343}, "CVE-2018-5778": {"epss_score": 0.00105, "epss_percentile": 0.29268}, "CVE-2018-5779": {"epss_score": 0.02123, "epss_percentile": 0.83685}, "CVE-2018-5780": {"epss_score": 0.01117, "epss_percentile": 0.77742}, "CVE-2018-5781": {"epss_score": 0.01117, "epss_percentile": 0.77742}, "CVE-2018-5782": {"epss_score": 0.32341, "epss_percentile": 0.96691}, "CVE-2018-5783": {"epss_score": 0.00374, "epss_percentile": 0.58583}, "CVE-2018-5784": {"epss_score": 0.00285, "epss_percentile": 0.51635}, "CVE-2018-5785": {"epss_score": 0.00684, "epss_percentile": 0.71126}, "CVE-2018-5786": {"epss_score": 0.00409, "epss_percentile": 0.60733}, "CVE-2018-5787": {"epss_score": 0.01524, "epss_percentile": 0.80848}, "CVE-2018-5788": {"epss_score": 0.01414, "epss_percentile": 0.80127}, "CVE-2018-5789": {"epss_score": 0.00403, "epss_percentile": 0.60347}, "CVE-2018-5790": {"epss_score": 0.00305, "epss_percentile": 0.53323}, "CVE-2018-5791": {"epss_score": 0.0168, "epss_percentile": 0.81724}, "CVE-2018-5792": {"epss_score": 0.0168, "epss_percentile": 0.81724}, "CVE-2018-5793": {"epss_score": 0.0168, "epss_percentile": 0.81724}, "CVE-2018-5794": {"epss_score": 0.00297, "epss_percentile": 0.52706}, "CVE-2018-5795": {"epss_score": 0.00435, "epss_percentile": 0.62367}, "CVE-2018-5796": {"epss_score": 0.00282, "epss_percentile": 0.5128}, "CVE-2018-5797": {"epss_score": 0.00136, "epss_percentile": 0.34201}, "CVE-2018-5798": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2018-5799": {"epss_score": 0.00627, "epss_percentile": 0.69637}, "CVE-2018-5800": {"epss_score": 0.01483, "epss_percentile": 0.80585}, "CVE-2018-5801": {"epss_score": 0.01527, "epss_percentile": 0.80867}, "CVE-2018-5802": {"epss_score": 0.00583, "epss_percentile": 0.68336}, "CVE-2018-5803": {"epss_score": 0.00089, "epss_percentile": 0.25796}, "CVE-2018-5804": {"epss_score": 0.00314, "epss_percentile": 0.54132}, "CVE-2018-5805": {"epss_score": 0.00505, "epss_percentile": 0.65606}, "CVE-2018-5806": {"epss_score": 0.00508, "epss_percentile": 0.65716}, "CVE-2018-5807": {"epss_score": 0.00481, "epss_percentile": 0.64492}, "CVE-2018-5808": {"epss_score": 0.02316, "epss_percentile": 0.84356}, "CVE-2018-5809": {"epss_score": 0.01917, "epss_percentile": 0.82871}, "CVE-2018-5810": {"epss_score": 0.00502, "epss_percentile": 0.65409}, "CVE-2018-5811": {"epss_score": 0.00507, "epss_percentile": 0.65653}, "CVE-2018-5812": {"epss_score": 0.00508, "epss_percentile": 0.65716}, "CVE-2018-5813": {"epss_score": 0.00455, "epss_percentile": 0.63305}, "CVE-2018-5814": {"epss_score": 0.00029, "epss_percentile": 0.07926}, "CVE-2018-5815": {"epss_score": 0.00563, "epss_percentile": 0.67709}, "CVE-2018-5816": {"epss_score": 0.00622, "epss_percentile": 0.69495}, "CVE-2018-5817": {"epss_score": 0.01213, "epss_percentile": 0.78567}, "CVE-2018-5818": {"epss_score": 0.00525, "epss_percentile": 0.66375}, "CVE-2018-5819": {"epss_score": 0.00446, "epss_percentile": 0.62895}, "CVE-2018-5820": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2018-5821": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2018-5822": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2018-5823": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2018-5824": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2018-5825": {"epss_score": 0.00019, "epss_percentile": 0.04292}, "CVE-2018-5826": {"epss_score": 0.00106, "epss_percentile": 0.29496}, "CVE-2018-5827": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2018-5828": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2018-5829": {"epss_score": 0.00242, "epss_percentile": 0.47383}, "CVE-2018-5830": {"epss_score": 0.00072, "epss_percentile": 0.22459}, "CVE-2018-5831": {"epss_score": 0.00069, "epss_percentile": 0.21473}, "CVE-2018-5832": {"epss_score": 0.00034, "epss_percentile": 0.09524}, "CVE-2018-5834": {"epss_score": 0.00079, "epss_percentile": 0.23813}, "CVE-2018-5835": {"epss_score": 0.00071, "epss_percentile": 0.22126}, "CVE-2018-5836": {"epss_score": 0.00068, "epss_percentile": 0.21364}, "CVE-2018-5837": {"epss_score": 0.00269, "epss_percentile": 0.50106}, "CVE-2018-5838": {"epss_score": 0.0011, "epss_percentile": 0.30112}, "CVE-2018-5839": {"epss_score": 0.00082, "epss_percentile": 0.24507}, "CVE-2018-5840": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2018-5841": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2018-5842": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2018-5843": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2018-5844": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2018-5845": {"epss_score": 0.00068, "epss_percentile": 0.21316}, "CVE-2018-5846": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2018-5847": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2018-5848": {"epss_score": 0.00126, "epss_percentile": 0.32739}, "CVE-2018-5849": {"epss_score": 0.00034, "epss_percentile": 0.09524}, "CVE-2018-5850": {"epss_score": 0.00086, "epss_percentile": 0.25354}, "CVE-2018-5851": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2018-5852": {"epss_score": 0.00041, "epss_percentile": 0.12197}, "CVE-2018-5853": {"epss_score": 0.0005, "epss_percentile": 0.15654}, "CVE-2018-5854": {"epss_score": 0.00048, "epss_percentile": 0.15228}, "CVE-2018-5855": {"epss_score": 0.00265, "epss_percentile": 0.49817}, "CVE-2018-5856": {"epss_score": 0.00058, "epss_percentile": 0.18562}, "CVE-2018-5857": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2018-5858": {"epss_score": 0.00033, "epss_percentile": 0.09363}, "CVE-2018-5859": {"epss_score": 0.00024, "epss_percentile": 0.06023}, "CVE-2018-5860": {"epss_score": 0.00015, "epss_percentile": 0.02274}, "CVE-2018-5861": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2018-5862": {"epss_score": 0.00027, "epss_percentile": 0.0685}, "CVE-2018-5863": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2018-5864": {"epss_score": 0.00032, "epss_percentile": 0.08793}, "CVE-2018-5865": {"epss_score": 0.00032, "epss_percentile": 0.08793}, "CVE-2018-5866": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2018-5867": {"epss_score": 0.0004, "epss_percentile": 0.12053}, "CVE-2018-5868": {"epss_score": 0.0004, "epss_percentile": 0.12053}, "CVE-2018-5869": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-5870": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-5871": {"epss_score": 0.00151, "epss_percentile": 0.36265}, "CVE-2018-5872": {"epss_score": 0.0014, "epss_percentile": 0.34726}, "CVE-2018-5873": {"epss_score": 0.00152, "epss_percentile": 0.36491}, "CVE-2018-5874": {"epss_score": 0.00506, "epss_percentile": 0.65628}, "CVE-2018-5875": {"epss_score": 0.00506, "epss_percentile": 0.65628}, "CVE-2018-5876": {"epss_score": 0.00506, "epss_percentile": 0.65628}, "CVE-2018-5877": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2018-5878": {"epss_score": 0.00313, "epss_percentile": 0.54051}, "CVE-2018-5879": {"epss_score": 0.00078, "epss_percentile": 0.23677}, "CVE-2018-5880": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2018-5881": {"epss_score": 0.00078, "epss_percentile": 0.23677}, "CVE-2018-5882": {"epss_score": 0.0038, "epss_percentile": 0.58954}, "CVE-2018-5883": {"epss_score": 0.00037, "epss_percentile": 0.10966}, "CVE-2018-5884": {"epss_score": 0.001, "epss_percentile": 0.28562}, "CVE-2018-5885": {"epss_score": 0.00315, "epss_percentile": 0.54187}, "CVE-2018-5886": {"epss_score": 0.00121, "epss_percentile": 0.31834}, "CVE-2018-5887": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2018-5888": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2018-5889": {"epss_score": 0.0004, "epss_percentile": 0.12059}, "CVE-2018-5890": {"epss_score": 0.00014, "epss_percentile": 0.01963}, "CVE-2018-5891": {"epss_score": 0.00099, "epss_percentile": 0.2834}, "CVE-2018-5892": {"epss_score": 0.00299, "epss_percentile": 0.52847}, "CVE-2018-5893": {"epss_score": 0.00064, "epss_percentile": 0.20265}, "CVE-2018-5894": {"epss_score": 0.00299, "epss_percentile": 0.52847}, "CVE-2018-5895": {"epss_score": 0.00041, "epss_percentile": 0.12425}, "CVE-2018-5896": {"epss_score": 0.00042, "epss_percentile": 0.12579}, "CVE-2018-5897": {"epss_score": 0.00153, "epss_percentile": 0.36528}, "CVE-2018-5898": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2018-5899": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2018-5903": {"epss_score": 0.00101, "epss_percentile": 0.28595}, "CVE-2018-5904": {"epss_score": 0.00036, "epss_percentile": 0.10369}, "CVE-2018-5905": {"epss_score": 0.00026, "epss_percentile": 0.06467}, "CVE-2018-5906": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2018-5907": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2018-5908": {"epss_score": 0.00033, "epss_percentile": 0.09121}, "CVE-2018-5909": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2018-5910": {"epss_score": 0.00031, "epss_percentile": 0.08415}, "CVE-2018-5911": {"epss_score": 0.00104, "epss_percentile": 0.29211}, "CVE-2018-5912": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2018-5913": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2018-5914": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2018-5915": {"epss_score": 0.00217, "epss_percentile": 0.44315}, "CVE-2018-5916": {"epss_score": 0.00135, "epss_percentile": 0.33934}, "CVE-2018-5917": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2018-5918": {"epss_score": 0.00126, "epss_percentile": 0.3274}, "CVE-2018-5919": {"epss_score": 0.00018, "epss_percentile": 0.03796}, "CVE-2018-5921": {"epss_score": 0.00217, "epss_percentile": 0.44281}, "CVE-2018-5923": {"epss_score": 0.01541, "epss_percentile": 0.80945}, "CVE-2018-5924": {"epss_score": 0.67259, "epss_percentile": 0.985}, "CVE-2018-5925": {"epss_score": 0.40991, "epss_percentile": 0.97249}, "CVE-2018-5926": {"epss_score": 0.00223, "epss_percentile": 0.44857}, "CVE-2018-5927": {"epss_score": 0.00062, "epss_percentile": 0.19561}, "CVE-2018-5950": {"epss_score": 0.05096, "epss_percentile": 0.89493}, "CVE-2018-5951": {"epss_score": 0.15503, "epss_percentile": 0.94441}, "CVE-2018-5953": {"epss_score": 0.00115, "epss_percentile": 0.3099}, "CVE-2018-5954": {"epss_score": 0.19872, "epss_percentile": 0.95253}, "CVE-2018-5955": {"epss_score": 0.86574, "epss_percentile": 0.99389}, "CVE-2018-5956": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5957": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2018-5958": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-5960": {"epss_score": 0.00232, "epss_percentile": 0.45894}, "CVE-2018-5961": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2018-5962": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-5963": {"epss_score": 0.00388, "epss_percentile": 0.59348}, "CVE-2018-5964": {"epss_score": 0.00279, "epss_percentile": 0.50975}, "CVE-2018-5965": {"epss_score": 0.00472, "epss_percentile": 0.64068}, "CVE-2018-5967": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2018-5968": {"epss_score": 0.01965, "epss_percentile": 0.8308}, "CVE-2018-5969": {"epss_score": 0.00256, "epss_percentile": 0.48769}, "CVE-2018-5970": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5971": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5972": {"epss_score": 0.01646, "epss_percentile": 0.81533}, "CVE-2018-5973": {"epss_score": 0.02548, "epss_percentile": 0.85066}, "CVE-2018-5974": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5975": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5976": {"epss_score": 0.00256, "epss_percentile": 0.48769}, "CVE-2018-5977": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5978": {"epss_score": 0.02589, "epss_percentile": 0.85178}, "CVE-2018-5979": {"epss_score": 0.05102, "epss_percentile": 0.895}, "CVE-2018-5980": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5981": {"epss_score": 0.0045, "epss_percentile": 0.63067}, "CVE-2018-5982": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5983": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5984": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5985": {"epss_score": 0.01646, "epss_percentile": 0.81533}, "CVE-2018-5986": {"epss_score": 0.01085, "epss_percentile": 0.77411}, "CVE-2018-5987": {"epss_score": 0.02589, "epss_percentile": 0.85178}, "CVE-2018-5988": {"epss_score": 0.05102, "epss_percentile": 0.895}, "CVE-2018-5989": {"epss_score": 0.01085, "epss_percentile": 0.77411}, "CVE-2018-5990": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5991": {"epss_score": 0.0045, "epss_percentile": 0.63067}, "CVE-2018-5992": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5993": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5994": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-5995": {"epss_score": 0.00054, "epss_percentile": 0.17297}, "CVE-2018-5996": {"epss_score": 0.04477, "epss_percentile": 0.8874}, "CVE-2018-5997": {"epss_score": 0.32565, "epss_percentile": 0.96708}, "CVE-2018-5999": {"epss_score": 0.90791, "epss_percentile": 0.996}, "CVE-2018-6000": {"epss_score": 0.90654, "epss_percentile": 0.99594}, "CVE-2018-6001": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-6002": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-6003": {"epss_score": 0.01584, "epss_percentile": 0.8116}, "CVE-2018-6004": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6005": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6006": {"epss_score": 0.05102, "epss_percentile": 0.895}, "CVE-2018-6007": {"epss_score": 0.00306, "epss_percentile": 0.53463}, "CVE-2018-6008": {"epss_score": 0.75568, "epss_percentile": 0.98854}, "CVE-2018-6009": {"epss_score": 0.00168, "epss_percentile": 0.38428}, "CVE-2018-6010": {"epss_score": 0.01012, "epss_percentile": 0.76629}, "CVE-2018-6011": {"epss_score": 0.00586, "epss_percentile": 0.68458}, "CVE-2018-6012": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2018-6013": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2018-6014": {"epss_score": 0.00317, "epss_percentile": 0.54335}, "CVE-2018-6015": {"epss_score": 0.01731, "epss_percentile": 0.81995}, "CVE-2018-6016": {"epss_score": 0.00059, "epss_percentile": 0.18719}, "CVE-2018-6017": {"epss_score": 0.00136, "epss_percentile": 0.34121}, "CVE-2018-6018": {"epss_score": 0.00136, "epss_percentile": 0.34121}, "CVE-2018-6019": {"epss_score": 0.00071, "epss_percentile": 0.22131}, "CVE-2018-6020": {"epss_score": 0.00249, "epss_percentile": 0.48053}, "CVE-2018-6021": {"epss_score": 0.00554, "epss_percentile": 0.67451}, "CVE-2018-6022": {"epss_score": 0.00403, "epss_percentile": 0.60355}, "CVE-2018-6023": {"epss_score": 0.00236, "epss_percentile": 0.46445}, "CVE-2018-6024": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2018-6029": {"epss_score": 0.00323, "epss_percentile": 0.54923}, "CVE-2018-6031": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-6032": {"epss_score": 0.00797, "epss_percentile": 0.73492}, "CVE-2018-6033": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-6034": {"epss_score": 0.01066, "epss_percentile": 0.77218}, "CVE-2018-6035": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-6036": {"epss_score": 0.00936, "epss_percentile": 0.75685}, "CVE-2018-6037": {"epss_score": 0.00936, "epss_percentile": 0.75685}, "CVE-2018-6038": {"epss_score": 0.0103, "epss_percentile": 0.76845}, "CVE-2018-6039": {"epss_score": 0.00909, "epss_percentile": 0.75294}, "CVE-2018-6040": {"epss_score": 0.00606, "epss_percentile": 0.69018}, "CVE-2018-6041": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6042": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6043": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-6045": {"epss_score": 0.00936, "epss_percentile": 0.75685}, "CVE-2018-6046": {"epss_score": 0.00909, "epss_percentile": 0.75294}, "CVE-2018-6047": {"epss_score": 0.00838, "epss_percentile": 0.74168}, "CVE-2018-6048": {"epss_score": 0.00773, "epss_percentile": 0.73061}, "CVE-2018-6049": {"epss_score": 0.00688, "epss_percentile": 0.71212}, "CVE-2018-6050": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6051": {"epss_score": 0.0057, "epss_percentile": 0.67962}, "CVE-2018-6052": {"epss_score": 0.00838, "epss_percentile": 0.74168}, "CVE-2018-6053": {"epss_score": 0.0017, "epss_percentile": 0.38748}, "CVE-2018-6054": {"epss_score": 0.01442, "epss_percentile": 0.80309}, "CVE-2018-6055": {"epss_score": 0.00564, "epss_percentile": 0.67773}, "CVE-2018-6056": {"epss_score": 0.06916, "epss_percentile": 0.91115}, "CVE-2018-6057": {"epss_score": 0.00532, "epss_percentile": 0.66677}, "CVE-2018-6060": {"epss_score": 0.01524, "epss_percentile": 0.80847}, "CVE-2018-6061": {"epss_score": 0.00969, "epss_percentile": 0.76098}, "CVE-2018-6062": {"epss_score": 0.01095, "epss_percentile": 0.77512}, "CVE-2018-6063": {"epss_score": 0.00936, "epss_percentile": 0.75679}, "CVE-2018-6064": {"epss_score": 0.21037, "epss_percentile": 0.95455}, "CVE-2018-6065": {"epss_score": 0.86799, "epss_percentile": 0.99397}, "CVE-2018-6066": {"epss_score": 0.1839, "epss_percentile": 0.95009}, "CVE-2018-6067": {"epss_score": 0.00936, "epss_percentile": 0.75679}, "CVE-2018-6068": {"epss_score": 0.00572, "epss_percentile": 0.68021}, "CVE-2018-6069": {"epss_score": 0.0057, "epss_percentile": 0.6794}, "CVE-2018-6070": {"epss_score": 0.00373, "epss_percentile": 0.58519}, "CVE-2018-6071": {"epss_score": 0.0069, "epss_percentile": 0.71257}, "CVE-2018-6072": {"epss_score": 0.00936, "epss_percentile": 0.75679}, "CVE-2018-6073": {"epss_score": 0.0101, "epss_percentile": 0.76595}, "CVE-2018-6074": {"epss_score": 0.00548, "epss_percentile": 0.67277}, "CVE-2018-6075": {"epss_score": 0.00729, "epss_percentile": 0.72131}, "CVE-2018-6076": {"epss_score": 0.00486, "epss_percentile": 0.64755}, "CVE-2018-6077": {"epss_score": 0.00729, "epss_percentile": 0.72131}, "CVE-2018-6078": {"epss_score": 0.0066, "epss_percentile": 0.70518}, "CVE-2018-6079": {"epss_score": 0.00672, "epss_percentile": 0.70818}, "CVE-2018-6080": {"epss_score": 0.00748, "epss_percentile": 0.72579}, "CVE-2018-6081": {"epss_score": 0.00373, "epss_percentile": 0.58519}, "CVE-2018-6082": {"epss_score": 0.00659, "epss_percentile": 0.70515}, "CVE-2018-6083": {"epss_score": 0.00936, "epss_percentile": 0.75679}, "CVE-2018-6084": {"epss_score": 0.00123, "epss_percentile": 0.32267}, "CVE-2018-6085": {"epss_score": 0.02399, "epss_percentile": 0.84635}, "CVE-2018-6086": {"epss_score": 0.02399, "epss_percentile": 0.84635}, "CVE-2018-6087": {"epss_score": 0.0169, "epss_percentile": 0.81774}, "CVE-2018-6088": {"epss_score": 0.02399, "epss_percentile": 0.84635}, "CVE-2018-6089": {"epss_score": 0.00936, "epss_percentile": 0.75685}, "CVE-2018-6090": {"epss_score": 0.01904, "epss_percentile": 0.82791}, "CVE-2018-6091": {"epss_score": 0.01102, "epss_percentile": 0.7758}, "CVE-2018-6092": {"epss_score": 0.18337, "epss_percentile": 0.94997}, "CVE-2018-6093": {"epss_score": 0.00936, "epss_percentile": 0.75685}, "CVE-2018-6094": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-6095": {"epss_score": 0.00936, "epss_percentile": 0.75685}, "CVE-2018-6096": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6097": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6098": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6099": {"epss_score": 0.00936, "epss_percentile": 0.75685}, "CVE-2018-6100": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6101": {"epss_score": 0.02033, "epss_percentile": 0.83342}, "CVE-2018-6102": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6103": {"epss_score": 0.00625, "epss_percentile": 0.69582}, "CVE-2018-6104": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6105": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6106": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-6107": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6108": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6109": {"epss_score": 0.00797, "epss_percentile": 0.73492}, "CVE-2018-6110": {"epss_score": 0.00909, "epss_percentile": 0.75294}, "CVE-2018-6111": {"epss_score": 0.00682, "epss_percentile": 0.71074}, "CVE-2018-6112": {"epss_score": 0.01187, "epss_percentile": 0.78354}, "CVE-2018-6113": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6114": {"epss_score": 0.00625, "epss_percentile": 0.69582}, "CVE-2018-6115": {"epss_score": 0.00239, "epss_percentile": 0.46938}, "CVE-2018-6116": {"epss_score": 0.01515, "epss_percentile": 0.80795}, "CVE-2018-6117": {"epss_score": 0.00936, "epss_percentile": 0.75685}, "CVE-2018-6118": {"epss_score": 0.01033, "epss_percentile": 0.76875}, "CVE-2018-6119": {"epss_score": 0.00275, "epss_percentile": 0.50655}, "CVE-2018-6120": {"epss_score": 0.02399, "epss_percentile": 0.84635}, "CVE-2018-6121": {"epss_score": 0.00327, "epss_percentile": 0.55126}, "CVE-2018-6122": {"epss_score": 0.00313, "epss_percentile": 0.54059}, "CVE-2018-6123": {"epss_score": 0.01818, "epss_percentile": 0.82401}, "CVE-2018-6124": {"epss_score": 0.01313, "epss_percentile": 0.79387}, "CVE-2018-6125": {"epss_score": 0.00296, "epss_percentile": 0.52568}, "CVE-2018-6126": {"epss_score": 0.45608, "epss_percentile": 0.97493}, "CVE-2018-6127": {"epss_score": 0.01313, "epss_percentile": 0.79387}, "CVE-2018-6128": {"epss_score": 0.00244, "epss_percentile": 0.47581}, "CVE-2018-6129": {"epss_score": 0.06227, "epss_percentile": 0.90585}, "CVE-2018-6130": {"epss_score": 0.07868, "epss_percentile": 0.9173}, "CVE-2018-6131": {"epss_score": 0.00328, "epss_percentile": 0.55167}, "CVE-2018-6132": {"epss_score": 0.00214, "epss_percentile": 0.44007}, "CVE-2018-6133": {"epss_score": 0.0079, "epss_percentile": 0.73367}, "CVE-2018-6134": {"epss_score": 0.00082, "epss_percentile": 0.24445}, "CVE-2018-6135": {"epss_score": 0.0079, "epss_percentile": 0.73367}, "CVE-2018-6136": {"epss_score": 0.00396, "epss_percentile": 0.59921}, "CVE-2018-6137": {"epss_score": 0.00639, "epss_percentile": 0.69938}, "CVE-2018-6138": {"epss_score": 0.00067, "epss_percentile": 0.21054}, "CVE-2018-6139": {"epss_score": 0.0076, "epss_percentile": 0.72818}, "CVE-2018-6140": {"epss_score": 0.01184, "epss_percentile": 0.78329}, "CVE-2018-6141": {"epss_score": 0.00971, "epss_percentile": 0.76119}, "CVE-2018-6142": {"epss_score": 0.00298, "epss_percentile": 0.52792}, "CVE-2018-6143": {"epss_score": 0.01099, "epss_percentile": 0.77548}, "CVE-2018-6144": {"epss_score": 0.01313, "epss_percentile": 0.79387}, "CVE-2018-6145": {"epss_score": 0.00083, "epss_percentile": 0.24601}, "CVE-2018-6147": {"epss_score": 0.00047, "epss_percentile": 0.14713}, "CVE-2018-6148": {"epss_score": 0.00094, "epss_percentile": 0.26793}, "CVE-2018-6149": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2018-6150": {"epss_score": 0.00197, "epss_percentile": 0.41824}, "CVE-2018-6151": {"epss_score": 0.00637, "epss_percentile": 0.69899}, "CVE-2018-6152": {"epss_score": 0.00864, "epss_percentile": 0.74611}, "CVE-2018-6153": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-6154": {"epss_score": 0.00301, "epss_percentile": 0.53065}, "CVE-2018-6155": {"epss_score": 0.00234, "epss_percentile": 0.46193}, "CVE-2018-6156": {"epss_score": 0.00627, "epss_percentile": 0.69626}, "CVE-2018-6157": {"epss_score": 0.00301, "epss_percentile": 0.53065}, "CVE-2018-6158": {"epss_score": 0.01298, "epss_percentile": 0.79275}, "CVE-2018-6159": {"epss_score": 0.00197, "epss_percentile": 0.41824}, "CVE-2018-6160": {"epss_score": 0.00377, "epss_percentile": 0.58711}, "CVE-2018-6161": {"epss_score": 0.00191, "epss_percentile": 0.41179}, "CVE-2018-6162": {"epss_score": 0.0152, "epss_percentile": 0.80823}, "CVE-2018-6163": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6164": {"epss_score": 0.00936, "epss_percentile": 0.75685}, "CVE-2018-6165": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6166": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6167": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6168": {"epss_score": 0.00213, "epss_percentile": 0.43833}, "CVE-2018-6169": {"epss_score": 0.00774, "epss_percentile": 0.73064}, "CVE-2018-6170": {"epss_score": 0.01563, "epss_percentile": 0.81055}, "CVE-2018-6171": {"epss_score": 0.00046, "epss_percentile": 0.14329}, "CVE-2018-6172": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6173": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6174": {"epss_score": 0.01904, "epss_percentile": 0.82791}, "CVE-2018-6175": {"epss_score": 0.00909, "epss_percentile": 0.7531}, "CVE-2018-6176": {"epss_score": 0.00085, "epss_percentile": 0.25089}, "CVE-2018-6177": {"epss_score": 0.00144, "epss_percentile": 0.35333}, "CVE-2018-6178": {"epss_score": 0.00469, "epss_percentile": 0.63945}, "CVE-2018-6179": {"epss_score": 0.00531, "epss_percentile": 0.66654}, "CVE-2018-6180": {"epss_score": 0.15375, "epss_percentile": 0.94418}, "CVE-2018-6182": {"epss_score": 0.0028, "epss_percentile": 0.51042}, "CVE-2018-6183": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2018-6184": {"epss_score": 0.49051, "epss_percentile": 0.97665}, "CVE-2018-6185": {"epss_score": 0.00111, "epss_percentile": 0.30335}, "CVE-2018-6186": {"epss_score": 0.01334, "epss_percentile": 0.79534}, "CVE-2018-6187": {"epss_score": 0.00348, "epss_percentile": 0.56851}, "CVE-2018-6188": {"epss_score": 0.00702, "epss_percentile": 0.71523}, "CVE-2018-6189": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-6190": {"epss_score": 0.00188, "epss_percentile": 0.40879}, "CVE-2018-6191": {"epss_score": 0.03214, "epss_percentile": 0.86659}, "CVE-2018-6192": {"epss_score": 0.00359, "epss_percentile": 0.57594}, "CVE-2018-6193": {"epss_score": 0.0055, "epss_percentile": 0.67338}, "CVE-2018-6194": {"epss_score": 0.00389, "epss_percentile": 0.59485}, "CVE-2018-6195": {"epss_score": 0.05847, "epss_percentile": 0.90259}, "CVE-2018-6196": {"epss_score": 0.00587, "epss_percentile": 0.68463}, "CVE-2018-6197": {"epss_score": 0.01145, "epss_percentile": 0.77992}, "CVE-2018-6198": {"epss_score": 0.00179, "epss_percentile": 0.39824}, "CVE-2018-6200": {"epss_score": 0.29986, "epss_percentile": 0.96492}, "CVE-2018-6201": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6202": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-6203": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-6204": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-6205": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-6206": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-6207": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-6208": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-6209": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-6210": {"epss_score": 0.01324, "epss_percentile": 0.79466}, "CVE-2018-6211": {"epss_score": 0.15926, "epss_percentile": 0.94537}, "CVE-2018-6212": {"epss_score": 0.00389, "epss_percentile": 0.59459}, "CVE-2018-6213": {"epss_score": 0.02191, "epss_percentile": 0.83936}, "CVE-2018-6217": {"epss_score": 0.00235, "epss_percentile": 0.46236}, "CVE-2018-6218": {"epss_score": 0.00358, "epss_percentile": 0.5754}, "CVE-2018-6219": {"epss_score": 0.01426, "epss_percentile": 0.80202}, "CVE-2018-6220": {"epss_score": 0.096, "epss_percentile": 0.92617}, "CVE-2018-6221": {"epss_score": 0.04505, "epss_percentile": 0.8877}, "CVE-2018-6222": {"epss_score": 0.00524, "epss_percentile": 0.6633}, "CVE-2018-6223": {"epss_score": 0.05245, "epss_percentile": 0.89659}, "CVE-2018-6224": {"epss_score": 0.00157, "epss_percentile": 0.37018}, "CVE-2018-6225": {"epss_score": 0.01591, "epss_percentile": 0.81222}, "CVE-2018-6226": {"epss_score": 0.00163, "epss_percentile": 0.37777}, "CVE-2018-6227": {"epss_score": 0.00163, "epss_percentile": 0.37777}, "CVE-2018-6228": {"epss_score": 0.03467, "epss_percentile": 0.87192}, "CVE-2018-6229": {"epss_score": 0.03467, "epss_percentile": 0.87192}, "CVE-2018-6230": {"epss_score": 0.01807, "epss_percentile": 0.82354}, "CVE-2018-6231": {"epss_score": 0.20287, "epss_percentile": 0.95314}, "CVE-2018-6232": {"epss_score": 0.00064, "epss_percentile": 0.20262}, "CVE-2018-6233": {"epss_score": 0.00064, "epss_percentile": 0.20262}, "CVE-2018-6234": {"epss_score": 0.00111, "epss_percentile": 0.30297}, "CVE-2018-6235": {"epss_score": 0.0006, "epss_percentile": 0.19185}, "CVE-2018-6236": {"epss_score": 0.00047, "epss_percentile": 0.14601}, "CVE-2018-6237": {"epss_score": 0.0654, "epss_percentile": 0.90834}, "CVE-2018-6239": {"epss_score": 0.00058, "epss_percentile": 0.18568}, "CVE-2018-6240": {"epss_score": 0.00024, "epss_percentile": 0.05772}, "CVE-2018-6241": {"epss_score": 0.00032, "epss_percentile": 0.08761}, "CVE-2018-6242": {"epss_score": 0.11821, "epss_percentile": 0.93486}, "CVE-2018-6243": {"epss_score": 0.00013, "epss_percentile": 0.0165}, "CVE-2018-6246": {"epss_score": 0.00139, "epss_percentile": 0.34567}, "CVE-2018-6247": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2018-6248": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2018-6249": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2018-6250": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2018-6251": {"epss_score": 0.00044, "epss_percentile": 0.13376}, "CVE-2018-6252": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2018-6253": {"epss_score": 0.00049, "epss_percentile": 0.15479}, "CVE-2018-6254": {"epss_score": 0.00038, "epss_percentile": 0.11275}, "CVE-2018-6257": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2018-6258": {"epss_score": 0.00051, "epss_percentile": 0.16133}, "CVE-2018-6259": {"epss_score": 0.00119, "epss_percentile": 0.31551}, "CVE-2018-6260": {"epss_score": 0.00031, "epss_percentile": 0.08323}, "CVE-2018-6261": {"epss_score": 0.00044, "epss_percentile": 0.13541}, "CVE-2018-6262": {"epss_score": 0.00054, "epss_percentile": 0.17226}, "CVE-2018-6263": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2018-6265": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2018-6266": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2018-6267": {"epss_score": 0.00054, "epss_percentile": 0.17055}, "CVE-2018-6268": {"epss_score": 0.00054, "epss_percentile": 0.17055}, "CVE-2018-6269": {"epss_score": 0.00052, "epss_percentile": 0.16358}, "CVE-2018-6271": {"epss_score": 0.00054, "epss_percentile": 0.17055}, "CVE-2018-6288": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2018-6289": {"epss_score": 0.02269, "epss_percentile": 0.84204}, "CVE-2018-6290": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2018-6291": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-6292": {"epss_score": 0.03579, "epss_percentile": 0.87382}, "CVE-2018-6293": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2018-6294": {"epss_score": 0.00428, "epss_percentile": 0.6193}, "CVE-2018-6295": {"epss_score": 0.00239, "epss_percentile": 0.46865}, "CVE-2018-6296": {"epss_score": 0.00294, "epss_percentile": 0.52389}, "CVE-2018-6297": {"epss_score": 0.00541, "epss_percentile": 0.67043}, "CVE-2018-6298": {"epss_score": 0.03224, "epss_percentile": 0.86682}, "CVE-2018-6299": {"epss_score": 0.005, "epss_percentile": 0.6532}, "CVE-2018-6300": {"epss_score": 0.00406, "epss_percentile": 0.60542}, "CVE-2018-6301": {"epss_score": 0.00372, "epss_percentile": 0.58453}, "CVE-2018-6302": {"epss_score": 0.00415, "epss_percentile": 0.61145}, "CVE-2018-6303": {"epss_score": 0.00415, "epss_percentile": 0.61145}, "CVE-2018-6304": {"epss_score": 0.00786, "epss_percentile": 0.73287}, "CVE-2018-6305": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2018-6306": {"epss_score": 0.0037, "epss_percentile": 0.58319}, "CVE-2018-6307": {"epss_score": 0.09475, "epss_percentile": 0.92564}, "CVE-2018-6308": {"epss_score": 0.00311, "epss_percentile": 0.53826}, "CVE-2018-6311": {"epss_score": 0.00049, "epss_percentile": 0.15329}, "CVE-2018-6312": {"epss_score": 0.00293, "epss_percentile": 0.52301}, "CVE-2018-6313": {"epss_score": 0.00171, "epss_percentile": 0.38899}, "CVE-2018-6315": {"epss_score": 0.00725, "epss_percentile": 0.72065}, "CVE-2018-6316": {"epss_score": 0.00571, "epss_percentile": 0.67981}, "CVE-2018-6317": {"epss_score": 0.72662, "epss_percentile": 0.98721}, "CVE-2018-6318": {"epss_score": 0.0005, "epss_percentile": 0.159}, "CVE-2018-6319": {"epss_score": 0.00017, "epss_percentile": 0.03217}, "CVE-2018-6320": {"epss_score": 0.03322, "epss_percentile": 0.86914}, "CVE-2018-6321": {"epss_score": 0.00052, "epss_percentile": 0.1646}, "CVE-2018-6322": {"epss_score": 0.00042, "epss_percentile": 0.12587}, "CVE-2018-6323": {"epss_score": 0.01844, "epss_percentile": 0.82507}, "CVE-2018-6324": {"epss_score": 0.00195, "epss_percentile": 0.41618}, "CVE-2018-6328": {"epss_score": 0.70958, "epss_percentile": 0.98648}, "CVE-2018-6329": {"epss_score": 0.78992, "epss_percentile": 0.99014}, "CVE-2018-6330": {"epss_score": 0.00303, "epss_percentile": 0.53176}, "CVE-2018-6331": {"epss_score": 0.0044, "epss_percentile": 0.62612}, "CVE-2018-6332": {"epss_score": 0.00439, "epss_percentile": 0.62602}, "CVE-2018-6333": {"epss_score": 0.01115, "epss_percentile": 0.77708}, "CVE-2018-6334": {"epss_score": 0.0063, "epss_percentile": 0.69708}, "CVE-2018-6335": {"epss_score": 0.00695, "epss_percentile": 0.71367}, "CVE-2018-6336": {"epss_score": 0.00094, "epss_percentile": 0.26955}, "CVE-2018-6337": {"epss_score": 0.00273, "epss_percentile": 0.50423}, "CVE-2018-6339": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2018-6340": {"epss_score": 0.00393, "epss_percentile": 0.59719}, "CVE-2018-6341": {"epss_score": 0.16684, "epss_percentile": 0.94714}, "CVE-2018-6342": {"epss_score": 0.00794, "epss_percentile": 0.73459}, "CVE-2018-6343": {"epss_score": 0.00271, "epss_percentile": 0.5029}, "CVE-2018-6344": {"epss_score": 0.00555, "epss_percentile": 0.67495}, "CVE-2018-6345": {"epss_score": 0.00922, "epss_percentile": 0.75493}, "CVE-2018-6346": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-6347": {"epss_score": 0.00432, "epss_percentile": 0.62112}, "CVE-2018-6349": {"epss_score": 0.01312, "epss_percentile": 0.79375}, "CVE-2018-6350": {"epss_score": 0.00398, "epss_percentile": 0.60057}, "CVE-2018-6352": {"epss_score": 0.00374, "epss_percentile": 0.58583}, "CVE-2018-6353": {"epss_score": 0.00107, "epss_percentile": 0.29601}, "CVE-2018-6354": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2018-6355": {"epss_score": 0.00373, "epss_percentile": 0.58507}, "CVE-2018-6356": {"epss_score": 0.37846, "epss_percentile": 0.97073}, "CVE-2018-6357": {"epss_score": 0.00147, "epss_percentile": 0.35664}, "CVE-2018-6358": {"epss_score": 0.0058, "epss_percentile": 0.68239}, "CVE-2018-6359": {"epss_score": 0.00983, "epss_percentile": 0.76305}, "CVE-2018-6360": {"epss_score": 0.00564, "epss_percentile": 0.67753}, "CVE-2018-6361": {"epss_score": 0.00279, "epss_percentile": 0.50967}, "CVE-2018-6362": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-6363": {"epss_score": 0.02377, "epss_percentile": 0.84552}, "CVE-2018-6364": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2018-6365": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2018-6367": {"epss_score": 0.02512, "epss_percentile": 0.84975}, "CVE-2018-6368": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6370": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6372": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6373": {"epss_score": 0.01085, "epss_percentile": 0.77411}, "CVE-2018-6374": {"epss_score": 0.00153, "epss_percentile": 0.36641}, "CVE-2018-6376": {"epss_score": 0.01797, "epss_percentile": 0.82308}, "CVE-2018-6377": {"epss_score": 0.06973, "epss_percentile": 0.91155}, "CVE-2018-6378": {"epss_score": 0.01889, "epss_percentile": 0.82724}, "CVE-2018-6379": {"epss_score": 0.01031, "epss_percentile": 0.76857}, "CVE-2018-6380": {"epss_score": 0.01031, "epss_percentile": 0.76857}, "CVE-2018-6381": {"epss_score": 0.00317, "epss_percentile": 0.54392}, "CVE-2018-6382": {"epss_score": 0.00094, "epss_percentile": 0.26976}, "CVE-2018-6383": {"epss_score": 0.09996, "epss_percentile": 0.92808}, "CVE-2018-6384": {"epss_score": 0.0006, "epss_percentile": 0.19197}, "CVE-2018-6387": {"epss_score": 0.00719, "epss_percentile": 0.71949}, "CVE-2018-6388": {"epss_score": 0.0711, "epss_percentile": 0.91258}, "CVE-2018-6389": {"epss_score": 0.88556, "epss_percentile": 0.99477}, "CVE-2018-6390": {"epss_score": 0.00403, "epss_percentile": 0.60363}, "CVE-2018-6391": {"epss_score": 0.00501, "epss_percentile": 0.65352}, "CVE-2018-6392": {"epss_score": 0.00566, "epss_percentile": 0.67819}, "CVE-2018-6393": {"epss_score": 0.02345, "epss_percentile": 0.84449}, "CVE-2018-6394": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6395": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6396": {"epss_score": 0.11605, "epss_percentile": 0.93418}, "CVE-2018-6397": {"epss_score": 0.17828, "epss_percentile": 0.94913}, "CVE-2018-6398": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6400": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2018-6401": {"epss_score": 0.00457, "epss_percentile": 0.63385}, "CVE-2018-6402": {"epss_score": 0.00063, "epss_percentile": 0.19822}, "CVE-2018-6405": {"epss_score": 0.00757, "epss_percentile": 0.72749}, "CVE-2018-6406": {"epss_score": 0.00445, "epss_percentile": 0.62881}, "CVE-2018-6407": {"epss_score": 0.22187, "epss_percentile": 0.95606}, "CVE-2018-6408": {"epss_score": 0.00104, "epss_percentile": 0.29156}, "CVE-2018-6409": {"epss_score": 0.12669, "epss_percentile": 0.93744}, "CVE-2018-6410": {"epss_score": 0.07655, "epss_percentile": 0.91607}, "CVE-2018-6411": {"epss_score": 0.111, "epss_percentile": 0.93219}, "CVE-2018-6412": {"epss_score": 0.00242, "epss_percentile": 0.47398}, "CVE-2018-6413": {"epss_score": 0.011, "epss_percentile": 0.77563}, "CVE-2018-6414": {"epss_score": 0.00382, "epss_percentile": 0.59064}, "CVE-2018-6433": {"epss_score": 0.00025, "epss_percentile": 0.06253}, "CVE-2018-6434": {"epss_score": 0.00391, "epss_percentile": 0.59587}, "CVE-2018-6435": {"epss_score": 0.00178, "epss_percentile": 0.39642}, "CVE-2018-6436": {"epss_score": 0.00178, "epss_percentile": 0.39642}, "CVE-2018-6437": {"epss_score": 0.00178, "epss_percentile": 0.39642}, "CVE-2018-6438": {"epss_score": 0.00178, "epss_percentile": 0.39642}, "CVE-2018-6439": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2018-6440": {"epss_score": 0.00601, "epss_percentile": 0.68835}, "CVE-2018-6441": {"epss_score": 0.00019, "epss_percentile": 0.04398}, "CVE-2018-6442": {"epss_score": 0.01458, "epss_percentile": 0.80405}, "CVE-2018-6443": {"epss_score": 0.07538, "epss_percentile": 0.91524}, "CVE-2018-6444": {"epss_score": 0.02879, "epss_percentile": 0.85893}, "CVE-2018-6445": {"epss_score": 0.00516, "epss_percentile": 0.66032}, "CVE-2018-6446": {"epss_score": 0.0085, "epss_percentile": 0.74388}, "CVE-2018-6447": {"epss_score": 0.00303, "epss_percentile": 0.53212}, "CVE-2018-6448": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2018-6449": {"epss_score": 0.0027, "epss_percentile": 0.50233}, "CVE-2018-6458": {"epss_score": 0.0039, "epss_percentile": 0.59517}, "CVE-2018-6459": {"epss_score": 0.00229, "epss_percentile": 0.4559}, "CVE-2018-6460": {"epss_score": 0.20389, "epss_percentile": 0.95337}, "CVE-2018-6461": {"epss_score": 0.00134, "epss_percentile": 0.33801}, "CVE-2018-6462": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2018-6464": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-6465": {"epss_score": 0.00738, "epss_percentile": 0.72347}, "CVE-2018-6466": {"epss_score": 0.00196, "epss_percentile": 0.41746}, "CVE-2018-6467": {"epss_score": 0.00216, "epss_percentile": 0.44226}, "CVE-2018-6468": {"epss_score": 0.00196, "epss_percentile": 0.41746}, "CVE-2018-6469": {"epss_score": 0.00196, "epss_percentile": 0.41746}, "CVE-2018-6470": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2018-6471": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6472": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6473": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6474": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6475": {"epss_score": 0.00141, "epss_percentile": 0.34945}, "CVE-2018-6476": {"epss_score": 0.00468, "epss_percentile": 0.63878}, "CVE-2018-6479": {"epss_score": 0.36643, "epss_percentile": 0.96991}, "CVE-2018-6480": {"epss_score": 0.00376, "epss_percentile": 0.58686}, "CVE-2018-6481": {"epss_score": 0.21121, "epss_percentile": 0.95465}, "CVE-2018-6484": {"epss_score": 0.00416, "epss_percentile": 0.61169}, "CVE-2018-6485": {"epss_score": 0.00583, "epss_percentile": 0.68333}, "CVE-2018-6486": {"epss_score": 0.00211, "epss_percentile": 0.4372}, "CVE-2018-6487": {"epss_score": 0.00249, "epss_percentile": 0.48041}, "CVE-2018-6488": {"epss_score": 0.00665, "epss_percentile": 0.70667}, "CVE-2018-6489": {"epss_score": 0.00296, "epss_percentile": 0.52598}, "CVE-2018-6490": {"epss_score": 0.00547, "epss_percentile": 0.67253}, "CVE-2018-6491": {"epss_score": 0.00137, "epss_percentile": 0.34315}, "CVE-2018-6492": {"epss_score": 0.00427, "epss_percentile": 0.61784}, "CVE-2018-6493": {"epss_score": 0.00162, "epss_percentile": 0.37728}, "CVE-2018-6494": {"epss_score": 0.00117, "epss_percentile": 0.31308}, "CVE-2018-6495": {"epss_score": 0.00251, "epss_percentile": 0.48333}, "CVE-2018-6496": {"epss_score": 0.00157, "epss_percentile": 0.37017}, "CVE-2018-6497": {"epss_score": 0.00139, "epss_percentile": 0.34546}, "CVE-2018-6498": {"epss_score": 0.03266, "epss_percentile": 0.86783}, "CVE-2018-6499": {"epss_score": 0.01553, "epss_percentile": 0.80997}, "CVE-2018-6500": {"epss_score": 0.01497, "epss_percentile": 0.8069}, "CVE-2018-6501": {"epss_score": 0.0026, "epss_percentile": 0.49168}, "CVE-2018-6502": {"epss_score": 0.00288, "epss_percentile": 0.5193}, "CVE-2018-6503": {"epss_score": 0.00276, "epss_percentile": 0.50713}, "CVE-2018-6504": {"epss_score": 0.00112, "epss_percentile": 0.30479}, "CVE-2018-6505": {"epss_score": 0.00933, "epss_percentile": 0.75642}, "CVE-2018-6506": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-6508": {"epss_score": 0.00905, "epss_percentile": 0.75238}, "CVE-2018-6510": {"epss_score": 0.00254, "epss_percentile": 0.48499}, "CVE-2018-6511": {"epss_score": 0.00254, "epss_percentile": 0.48499}, "CVE-2018-6512": {"epss_score": 0.0112, "epss_percentile": 0.77766}, "CVE-2018-6513": {"epss_score": 0.00355, "epss_percentile": 0.57276}, "CVE-2018-6514": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2018-6515": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2018-6516": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2018-6517": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2018-6518": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2018-6519": {"epss_score": 0.00402, "epss_percentile": 0.60315}, "CVE-2018-6520": {"epss_score": 0.00165, "epss_percentile": 0.38057}, "CVE-2018-6521": {"epss_score": 0.00585, "epss_percentile": 0.68412}, "CVE-2018-6522": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2018-6523": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2018-6524": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2018-6525": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2018-6526": {"epss_score": 0.0024, "epss_percentile": 0.47194}, "CVE-2018-6527": {"epss_score": 0.00632, "epss_percentile": 0.69743}, "CVE-2018-6528": {"epss_score": 0.00632, "epss_percentile": 0.69743}, "CVE-2018-6529": {"epss_score": 0.00632, "epss_percentile": 0.69743}, "CVE-2018-6530": {"epss_score": 0.94038, "epss_percentile": 0.99891}, "CVE-2018-6532": {"epss_score": 0.00712, "epss_percentile": 0.71772}, "CVE-2018-6533": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2018-6534": {"epss_score": 0.00435, "epss_percentile": 0.62332}, "CVE-2018-6535": {"epss_score": 0.00381, "epss_percentile": 0.59022}, "CVE-2018-6536": {"epss_score": 0.0003, "epss_percentile": 0.08252}, "CVE-2018-6537": {"epss_score": 0.06709, "epss_percentile": 0.90962}, "CVE-2018-6540": {"epss_score": 0.00416, "epss_percentile": 0.61169}, "CVE-2018-6541": {"epss_score": 0.00442, "epss_percentile": 0.62722}, "CVE-2018-6542": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2018-6543": {"epss_score": 0.00147, "epss_percentile": 0.35683}, "CVE-2018-6544": {"epss_score": 0.00359, "epss_percentile": 0.57594}, "CVE-2018-6545": {"epss_score": 0.00013, "epss_percentile": 0.0151}, "CVE-2018-6546": {"epss_score": 0.42795, "epss_percentile": 0.97354}, "CVE-2018-6547": {"epss_score": 0.00493, "epss_percentile": 0.65061}, "CVE-2018-6548": {"epss_score": 0.00528, "epss_percentile": 0.66534}, "CVE-2018-6550": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-6551": {"epss_score": 0.00419, "epss_percentile": 0.61369}, "CVE-2018-6552": {"epss_score": 0.00032, "epss_percentile": 0.09001}, "CVE-2018-6553": {"epss_score": 0.00147, "epss_percentile": 0.35709}, "CVE-2018-6554": {"epss_score": 0.00051, "epss_percentile": 0.16034}, "CVE-2018-6555": {"epss_score": 0.00055, "epss_percentile": 0.17567}, "CVE-2018-6556": {"epss_score": 0.00043, "epss_percentile": 0.13133}, "CVE-2018-6557": {"epss_score": 0.0011, "epss_percentile": 0.30127}, "CVE-2018-6558": {"epss_score": 0.00206, "epss_percentile": 0.43065}, "CVE-2018-6559": {"epss_score": 0.00084, "epss_percentile": 0.25025}, "CVE-2018-6560": {"epss_score": 0.00094, "epss_percentile": 0.26778}, "CVE-2018-6561": {"epss_score": 0.00199, "epss_percentile": 0.42132}, "CVE-2018-6562": {"epss_score": 0.00178, "epss_percentile": 0.3971}, "CVE-2018-6563": {"epss_score": 0.00176, "epss_percentile": 0.39385}, "CVE-2018-6569": {"epss_score": 0.00364, "epss_percentile": 0.57928}, "CVE-2018-6574": {"epss_score": 0.36789, "epss_percentile": 0.97001}, "CVE-2018-6575": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6576": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6577": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6578": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6579": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6580": {"epss_score": 0.24124, "epss_percentile": 0.95878}, "CVE-2018-6581": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6582": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6583": {"epss_score": 0.05102, "epss_percentile": 0.895}, "CVE-2018-6584": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6585": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6586": {"epss_score": 0.00446, "epss_percentile": 0.62917}, "CVE-2018-6587": {"epss_score": 0.00446, "epss_percentile": 0.62917}, "CVE-2018-6588": {"epss_score": 0.00446, "epss_percentile": 0.62917}, "CVE-2018-6589": {"epss_score": 0.01315, "epss_percentile": 0.79404}, "CVE-2018-6590": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2018-6591": {"epss_score": 0.00265, "epss_percentile": 0.49792}, "CVE-2018-6592": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2018-6593": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2018-6594": {"epss_score": 0.00573, "epss_percentile": 0.68063}, "CVE-2018-6596": {"epss_score": 0.00506, "epss_percentile": 0.65642}, "CVE-2018-6597": {"epss_score": 0.00067, "epss_percentile": 0.21172}, "CVE-2018-6598": {"epss_score": 0.00041, "epss_percentile": 0.12226}, "CVE-2018-6599": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2018-6603": {"epss_score": 0.00315, "epss_percentile": 0.54184}, "CVE-2018-6604": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-6605": {"epss_score": 0.90109, "epss_percentile": 0.99561}, "CVE-2018-6606": {"epss_score": 0.01457, "epss_percentile": 0.80398}, "CVE-2018-6608": {"epss_score": 0.00513, "epss_percentile": 0.65939}, "CVE-2018-6609": {"epss_score": 0.02589, "epss_percentile": 0.85178}, "CVE-2018-6610": {"epss_score": 0.15026, "epss_percentile": 0.94348}, "CVE-2018-6611": {"epss_score": 0.00396, "epss_percentile": 0.59855}, "CVE-2018-6612": {"epss_score": 0.00162, "epss_percentile": 0.37668}, "CVE-2018-6616": {"epss_score": 0.00081, "epss_percentile": 0.24236}, "CVE-2018-6617": {"epss_score": 0.00072, "epss_percentile": 0.22468}, "CVE-2018-6618": {"epss_score": 0.00072, "epss_percentile": 0.22468}, "CVE-2018-6619": {"epss_score": 0.00038, "epss_percentile": 0.11201}, "CVE-2018-6621": {"epss_score": 0.00682, "epss_percentile": 0.71066}, "CVE-2018-6622": {"epss_score": 0.00222, "epss_percentile": 0.44791}, "CVE-2018-6623": {"epss_score": 0.00269, "epss_percentile": 0.50169}, "CVE-2018-6624": {"epss_score": 0.00789, "epss_percentile": 0.73357}, "CVE-2018-6625": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6626": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6627": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6628": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6629": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6630": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6631": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6632": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6633": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6634": {"epss_score": 0.00521, "epss_percentile": 0.66226}, "CVE-2018-6635": {"epss_score": 0.00825, "epss_percentile": 0.73953}, "CVE-2018-6638": {"epss_score": 0.0661, "epss_percentile": 0.90887}, "CVE-2018-6639": {"epss_score": 0.04033, "epss_percentile": 0.88154}, "CVE-2018-6640": {"epss_score": 0.0661, "epss_percentile": 0.90887}, "CVE-2018-6641": {"epss_score": 0.04033, "epss_percentile": 0.88154}, "CVE-2018-6643": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-6644": {"epss_score": 0.00768, "epss_percentile": 0.72963}, "CVE-2018-6651": {"epss_score": 0.00437, "epss_percentile": 0.62509}, "CVE-2018-6653": {"epss_score": 0.00058, "epss_percentile": 0.1841}, "CVE-2018-6654": {"epss_score": 0.00114, "epss_percentile": 0.30782}, "CVE-2018-6655": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-6656": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2018-6659": {"epss_score": 0.00186, "epss_percentile": 0.40584}, "CVE-2018-6660": {"epss_score": 0.01028, "epss_percentile": 0.76815}, "CVE-2018-6661": {"epss_score": 0.00209, "epss_percentile": 0.43319}, "CVE-2018-6662": {"epss_score": 0.00067, "epss_percentile": 0.21101}, "CVE-2018-6664": {"epss_score": 0.00267, "epss_percentile": 0.49978}, "CVE-2018-6667": {"epss_score": 0.02332, "epss_percentile": 0.84406}, "CVE-2018-6668": {"epss_score": 0.00047, "epss_percentile": 0.14795}, "CVE-2018-6669": {"epss_score": 0.00063, "epss_percentile": 0.19921}, "CVE-2018-6670": {"epss_score": 0.00041, "epss_percentile": 0.1227}, "CVE-2018-6671": {"epss_score": 0.01047, "epss_percentile": 0.77034}, "CVE-2018-6672": {"epss_score": 0.00544, "epss_percentile": 0.67138}, "CVE-2018-6674": {"epss_score": 0.00022, "epss_percentile": 0.05}, "CVE-2018-6677": {"epss_score": 0.00637, "epss_percentile": 0.699}, "CVE-2018-6678": {"epss_score": 0.00324, "epss_percentile": 0.54948}, "CVE-2018-6681": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2018-6682": {"epss_score": 0.0041, "epss_percentile": 0.6084}, "CVE-2018-6683": {"epss_score": 0.00041, "epss_percentile": 0.12221}, "CVE-2018-6686": {"epss_score": 0.0002, "epss_percentile": 0.04568}, "CVE-2018-6687": {"epss_score": 0.0014, "epss_percentile": 0.34737}, "CVE-2018-6689": {"epss_score": 0.00038, "epss_percentile": 0.11339}, "CVE-2018-6690": {"epss_score": 0.00031, "epss_percentile": 0.0841}, "CVE-2018-6692": {"epss_score": 0.00957, "epss_percentile": 0.75939}, "CVE-2018-6693": {"epss_score": 0.00077, "epss_percentile": 0.23525}, "CVE-2018-6695": {"epss_score": 0.00186, "epss_percentile": 0.40639}, "CVE-2018-6700": {"epss_score": 0.0037, "epss_percentile": 0.58333}, "CVE-2018-6703": {"epss_score": 0.02819, "epss_percentile": 0.85742}, "CVE-2018-6704": {"epss_score": 0.00043, "epss_percentile": 0.13127}, "CVE-2018-6705": {"epss_score": 0.00108, "epss_percentile": 0.2978}, "CVE-2018-6706": {"epss_score": 0.00239, "epss_percentile": 0.46918}, "CVE-2018-6707": {"epss_score": 0.00037, "epss_percentile": 0.1088}, "CVE-2018-6755": {"epss_score": 0.00124, "epss_percentile": 0.32362}, "CVE-2018-6756": {"epss_score": 0.00142, "epss_percentile": 0.35027}, "CVE-2018-6757": {"epss_score": 0.00131, "epss_percentile": 0.33496}, "CVE-2018-6758": {"epss_score": 0.00548, "epss_percentile": 0.67292}, "CVE-2018-6759": {"epss_score": 0.00237, "epss_percentile": 0.46646}, "CVE-2018-6764": {"epss_score": 0.00038, "epss_percentile": 0.11185}, "CVE-2018-6765": {"epss_score": 0.00214, "epss_percentile": 0.44002}, "CVE-2018-6766": {"epss_score": 0.00214, "epss_percentile": 0.44002}, "CVE-2018-6767": {"epss_score": 0.00879, "epss_percentile": 0.74842}, "CVE-2018-6768": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6769": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6770": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6771": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6772": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6773": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6774": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6775": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6776": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6777": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6778": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6779": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6780": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6781": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6782": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6783": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6784": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6785": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6786": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6787": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6788": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2018-6789": {"epss_score": 0.86439, "epss_percentile": 0.99383}, "CVE-2018-6790": {"epss_score": 0.00393, "epss_percentile": 0.59727}, "CVE-2018-6791": {"epss_score": 0.00213, "epss_percentile": 0.439}, "CVE-2018-6792": {"epss_score": 0.00546, "epss_percentile": 0.67226}, "CVE-2018-6794": {"epss_score": 0.37431, "epss_percentile": 0.97046}, "CVE-2018-6795": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-6796": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-6797": {"epss_score": 0.01475, "epss_percentile": 0.80524}, "CVE-2018-6798": {"epss_score": 0.00967, "epss_percentile": 0.76069}, "CVE-2018-6799": {"epss_score": 0.00781, "epss_percentile": 0.73188}, "CVE-2018-6806": {"epss_score": 0.0059, "epss_percentile": 0.68546}, "CVE-2018-6808": {"epss_score": 0.00315, "epss_percentile": 0.54204}, "CVE-2018-6809": {"epss_score": 0.03405, "epss_percentile": 0.87075}, "CVE-2018-6810": {"epss_score": 0.04751, "epss_percentile": 0.89103}, "CVE-2018-6811": {"epss_score": 0.00255, "epss_percentile": 0.48734}, "CVE-2018-6822": {"epss_score": 0.00339, "epss_percentile": 0.5618}, "CVE-2018-6823": {"epss_score": 0.00339, "epss_percentile": 0.5618}, "CVE-2018-6824": {"epss_score": 0.00233, "epss_percentile": 0.46044}, "CVE-2018-6825": {"epss_score": 0.00991, "epss_percentile": 0.76383}, "CVE-2018-6826": {"epss_score": 0.01352, "epss_percentile": 0.79692}, "CVE-2018-6827": {"epss_score": 0.00493, "epss_percentile": 0.65057}, "CVE-2018-6829": {"epss_score": 0.00577, "epss_percentile": 0.68162}, "CVE-2018-6830": {"epss_score": 0.00923, "epss_percentile": 0.75507}, "CVE-2018-6831": {"epss_score": 0.01436, "epss_percentile": 0.80278}, "CVE-2018-6832": {"epss_score": 0.01212, "epss_percentile": 0.78562}, "CVE-2018-6834": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2018-6835": {"epss_score": 0.0012, "epss_percentile": 0.31702}, "CVE-2018-6836": {"epss_score": 0.00317, "epss_percentile": 0.5436}, "CVE-2018-6842": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-6843": {"epss_score": 0.00247, "epss_percentile": 0.47867}, "CVE-2018-6844": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2018-6845": {"epss_score": 0.00453, "epss_percentile": 0.63235}, "CVE-2018-6846": {"epss_score": 0.00205, "epss_percentile": 0.42675}, "CVE-2018-6849": {"epss_score": 0.76795, "epss_percentile": 0.98906}, "CVE-2018-6851": {"epss_score": 0.00019, "epss_percentile": 0.04144}, "CVE-2018-6852": {"epss_score": 0.00019, "epss_percentile": 0.04144}, "CVE-2018-6853": {"epss_score": 0.00019, "epss_percentile": 0.04144}, "CVE-2018-6854": {"epss_score": 0.00019, "epss_percentile": 0.04144}, "CVE-2018-6855": {"epss_score": 0.00016, "epss_percentile": 0.02733}, "CVE-2018-6856": {"epss_score": 0.00019, "epss_percentile": 0.04144}, "CVE-2018-6857": {"epss_score": 0.00019, "epss_percentile": 0.04144}, "CVE-2018-6858": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-6859": {"epss_score": 0.00572, "epss_percentile": 0.68005}, "CVE-2018-6860": {"epss_score": 0.0218, "epss_percentile": 0.83901}, "CVE-2018-6861": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-6862": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-6863": {"epss_score": 0.00238, "epss_percentile": 0.46759}, "CVE-2018-6864": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-6866": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-6867": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-6868": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-6869": {"epss_score": 0.01067, "epss_percentile": 0.77234}, "CVE-2018-6870": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-6871": {"epss_score": 0.4268, "epss_percentile": 0.97346}, "CVE-2018-6872": {"epss_score": 0.00198, "epss_percentile": 0.42078}, "CVE-2018-6873": {"epss_score": 0.04363, "epss_percentile": 0.886}, "CVE-2018-6874": {"epss_score": 0.00172, "epss_percentile": 0.39}, "CVE-2018-6875": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2018-6876": {"epss_score": 0.00545, "epss_percentile": 0.6717}, "CVE-2018-6878": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-6879": {"epss_score": 0.00285, "epss_percentile": 0.51676}, "CVE-2018-6880": {"epss_score": 0.00333, "epss_percentile": 0.55635}, "CVE-2018-6881": {"epss_score": 0.00494, "epss_percentile": 0.65078}, "CVE-2018-6882": {"epss_score": 0.61776, "epss_percentile": 0.98261}, "CVE-2018-6883": {"epss_score": 0.00263, "epss_percentile": 0.49546}, "CVE-2018-6885": {"epss_score": 0.00561, "epss_percentile": 0.67661}, "CVE-2018-6888": {"epss_score": 0.00132, "epss_percentile": 0.33598}, "CVE-2018-6889": {"epss_score": 0.02772, "epss_percentile": 0.85622}, "CVE-2018-6890": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2018-6891": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-6892": {"epss_score": 0.90167, "epss_percentile": 0.99566}, "CVE-2018-6893": {"epss_score": 0.00465, "epss_percentile": 0.63757}, "CVE-2018-6900": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-6902": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-6903": {"epss_score": 0.00298, "epss_percentile": 0.52799}, "CVE-2018-6904": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-6905": {"epss_score": 0.02274, "epss_percentile": 0.84222}, "CVE-2018-6906": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-6907": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2018-6908": {"epss_score": 0.04283, "epss_percentile": 0.88492}, "CVE-2018-6909": {"epss_score": 0.00226, "epss_percentile": 0.4526}, "CVE-2018-6910": {"epss_score": 0.91889, "epss_percentile": 0.99676}, "CVE-2018-6911": {"epss_score": 0.29181, "epss_percentile": 0.96423}, "CVE-2018-6912": {"epss_score": 0.00698, "epss_percentile": 0.71423}, "CVE-2018-6913": {"epss_score": 0.03896, "epss_percentile": 0.87916}, "CVE-2018-6914": {"epss_score": 0.02372, "epss_percentile": 0.84529}, "CVE-2018-6916": {"epss_score": 0.00501, "epss_percentile": 0.65336}, "CVE-2018-6917": {"epss_score": 0.00961, "epss_percentile": 0.75974}, "CVE-2018-6918": {"epss_score": 0.02748, "epss_percentile": 0.85576}, "CVE-2018-6919": {"epss_score": 0.00307, "epss_percentile": 0.53484}, "CVE-2018-6920": {"epss_score": 0.00059, "epss_percentile": 0.18668}, "CVE-2018-6921": {"epss_score": 0.00059, "epss_percentile": 0.18668}, "CVE-2018-6922": {"epss_score": 0.00697, "epss_percentile": 0.71407}, "CVE-2018-6923": {"epss_score": 0.01821, "epss_percentile": 0.82409}, "CVE-2018-6924": {"epss_score": 0.00055, "epss_percentile": 0.17531}, "CVE-2018-6925": {"epss_score": 0.0004, "epss_percentile": 0.12169}, "CVE-2018-6926": {"epss_score": 0.00533, "epss_percentile": 0.66714}, "CVE-2018-6927": {"epss_score": 0.00031, "epss_percentile": 0.0839}, "CVE-2018-6928": {"epss_score": 0.00233, "epss_percentile": 0.46062}, "CVE-2018-6930": {"epss_score": 0.00571, "epss_percentile": 0.67979}, "CVE-2018-6934": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2018-6935": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-6936": {"epss_score": 0.00249, "epss_percentile": 0.48048}, "CVE-2018-6940": {"epss_score": 0.08087, "epss_percentile": 0.91874}, "CVE-2018-6941": {"epss_score": 0.02547, "epss_percentile": 0.85066}, "CVE-2018-6942": {"epss_score": 0.00258, "epss_percentile": 0.48956}, "CVE-2018-6943": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2018-6944": {"epss_score": 0.00285, "epss_percentile": 0.51649}, "CVE-2018-6947": {"epss_score": 0.01503, "epss_percentile": 0.80726}, "CVE-2018-6948": {"epss_score": 0.00436, "epss_percentile": 0.62455}, "CVE-2018-6951": {"epss_score": 0.13556, "epss_percentile": 0.93996}, "CVE-2018-6952": {"epss_score": 0.11805, "epss_percentile": 0.93482}, "CVE-2018-6953": {"epss_score": 0.00436, "epss_percentile": 0.62455}, "CVE-2018-6954": {"epss_score": 0.00104, "epss_percentile": 0.29153}, "CVE-2018-6957": {"epss_score": 0.00379, "epss_percentile": 0.58901}, "CVE-2018-6958": {"epss_score": 0.00222, "epss_percentile": 0.4484}, "CVE-2018-6959": {"epss_score": 0.01235, "epss_percentile": 0.78761}, "CVE-2018-6960": {"epss_score": 0.04304, "epss_percentile": 0.88518}, "CVE-2018-6961": {"epss_score": 0.93224, "epss_percentile": 0.99785}, "CVE-2018-6962": {"epss_score": 0.00048, "epss_percentile": 0.15123}, "CVE-2018-6963": {"epss_score": 0.00064, "epss_percentile": 0.20271}, "CVE-2018-6964": {"epss_score": 0.00048, "epss_percentile": 0.15123}, "CVE-2018-6965": {"epss_score": 0.00392, "epss_percentile": 0.59651}, "CVE-2018-6966": {"epss_score": 0.00392, "epss_percentile": 0.59651}, "CVE-2018-6967": {"epss_score": 0.00392, "epss_percentile": 0.59651}, "CVE-2018-6968": {"epss_score": 0.09505, "epss_percentile": 0.92576}, "CVE-2018-6969": {"epss_score": 0.00073, "epss_percentile": 0.22595}, "CVE-2018-6970": {"epss_score": 0.0075, "epss_percentile": 0.72616}, "CVE-2018-6971": {"epss_score": 0.00074, "epss_percentile": 0.22801}, "CVE-2018-6972": {"epss_score": 0.02794, "epss_percentile": 0.85675}, "CVE-2018-6973": {"epss_score": 0.00164, "epss_percentile": 0.37874}, "CVE-2018-6974": {"epss_score": 0.0006, "epss_percentile": 0.1908}, "CVE-2018-6975": {"epss_score": 0.00035, "epss_percentile": 0.10142}, "CVE-2018-6976": {"epss_score": 0.00155, "epss_percentile": 0.36861}, "CVE-2018-6977": {"epss_score": 0.00066, "epss_percentile": 0.20744}, "CVE-2018-6978": {"epss_score": 0.0002, "epss_percentile": 0.04523}, "CVE-2018-6979": {"epss_score": 0.00282, "epss_percentile": 0.51217}, "CVE-2018-6980": {"epss_score": 0.003, "epss_percentile": 0.52945}, "CVE-2018-6981": {"epss_score": 0.06893, "epss_percentile": 0.91097}, "CVE-2018-6982": {"epss_score": 0.00335, "epss_percentile": 0.55846}, "CVE-2018-6983": {"epss_score": 0.00058, "epss_percentile": 0.1845}, "CVE-2018-7032": {"epss_score": 0.00385, "epss_percentile": 0.5923}, "CVE-2018-7033": {"epss_score": 0.00297, "epss_percentile": 0.527}, "CVE-2018-7034": {"epss_score": 0.00843, "epss_percentile": 0.74263}, "CVE-2018-7035": {"epss_score": 0.00229, "epss_percentile": 0.45552}, "CVE-2018-7039": {"epss_score": 0.00626, "epss_percentile": 0.69615}, "CVE-2018-7046": {"epss_score": 0.01977, "epss_percentile": 0.83125}, "CVE-2018-7047": {"epss_score": 0.02839, "epss_percentile": 0.85795}, "CVE-2018-7048": {"epss_score": 0.01564, "epss_percentile": 0.8106}, "CVE-2018-7049": {"epss_score": 0.00301, "epss_percentile": 0.53021}, "CVE-2018-7050": {"epss_score": 0.01142, "epss_percentile": 0.77976}, "CVE-2018-7051": {"epss_score": 0.00637, "epss_percentile": 0.69895}, "CVE-2018-7052": {"epss_score": 0.01142, "epss_percentile": 0.77976}, "CVE-2018-7053": {"epss_score": 0.00821, "epss_percentile": 0.73895}, "CVE-2018-7054": {"epss_score": 0.00805, "epss_percentile": 0.73642}, "CVE-2018-7055": {"epss_score": 0.00352, "epss_percentile": 0.57128}, "CVE-2018-7056": {"epss_score": 0.00244, "epss_percentile": 0.47619}, "CVE-2018-7057": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-7058": {"epss_score": 0.00917, "epss_percentile": 0.75426}, "CVE-2018-7059": {"epss_score": 0.00385, "epss_percentile": 0.59232}, "CVE-2018-7060": {"epss_score": 0.00168, "epss_percentile": 0.38417}, "CVE-2018-7063": {"epss_score": 0.00487, "epss_percentile": 0.64781}, "CVE-2018-7064": {"epss_score": 0.00392, "epss_percentile": 0.5965}, "CVE-2018-7065": {"epss_score": 0.00304, "epss_percentile": 0.53271}, "CVE-2018-7066": {"epss_score": 0.01836, "epss_percentile": 0.82473}, "CVE-2018-7067": {"epss_score": 0.00632, "epss_percentile": 0.69749}, "CVE-2018-7068": {"epss_score": 0.0034, "epss_percentile": 0.56229}, "CVE-2018-7069": {"epss_score": 0.00736, "epss_percentile": 0.72313}, "CVE-2018-7070": {"epss_score": 0.00547, "epss_percentile": 0.67249}, "CVE-2018-7071": {"epss_score": 0.00274, "epss_percentile": 0.50546}, "CVE-2018-7072": {"epss_score": 0.00453, "epss_percentile": 0.63225}, "CVE-2018-7073": {"epss_score": 0.00727, "epss_percentile": 0.72092}, "CVE-2018-7074": {"epss_score": 0.35782, "epss_percentile": 0.96935}, "CVE-2018-7075": {"epss_score": 0.00453, "epss_percentile": 0.63233}, "CVE-2018-7076": {"epss_score": 0.20335, "epss_percentile": 0.95327}, "CVE-2018-7077": {"epss_score": 0.02874, "epss_percentile": 0.8588}, "CVE-2018-7078": {"epss_score": 0.03424, "epss_percentile": 0.8711}, "CVE-2018-7079": {"epss_score": 0.00338, "epss_percentile": 0.56143}, "CVE-2018-7080": {"epss_score": 0.00241, "epss_percentile": 0.47323}, "CVE-2018-7081": {"epss_score": 0.01939, "epss_percentile": 0.82974}, "CVE-2018-7082": {"epss_score": 0.01211, "epss_percentile": 0.78555}, "CVE-2018-7083": {"epss_score": 0.00536, "epss_percentile": 0.66855}, "CVE-2018-7084": {"epss_score": 0.03129, "epss_percentile": 0.86462}, "CVE-2018-7090": {"epss_score": 0.00453, "epss_percentile": 0.63233}, "CVE-2018-7091": {"epss_score": 0.00245, "epss_percentile": 0.4769}, "CVE-2018-7092": {"epss_score": 0.20921, "epss_percentile": 0.95443}, "CVE-2018-7093": {"epss_score": 0.03969, "epss_percentile": 0.88034}, "CVE-2018-7094": {"epss_score": 0.00094, "epss_percentile": 0.27002}, "CVE-2018-7095": {"epss_score": 0.00769, "epss_percentile": 0.72993}, "CVE-2018-7096": {"epss_score": 0.05583, "epss_percentile": 0.90021}, "CVE-2018-7097": {"epss_score": 0.00896, "epss_percentile": 0.75114}, "CVE-2018-7098": {"epss_score": 0.00959, "epss_percentile": 0.75951}, "CVE-2018-7099": {"epss_score": 0.0044, "epss_percentile": 0.62617}, "CVE-2018-7100": {"epss_score": 0.0044, "epss_percentile": 0.62617}, "CVE-2018-7101": {"epss_score": 0.0474, "epss_percentile": 0.89079}, "CVE-2018-7102": {"epss_score": 0.01434, "epss_percentile": 0.80265}, "CVE-2018-7103": {"epss_score": 0.21544, "epss_percentile": 0.95531}, "CVE-2018-7104": {"epss_score": 0.21544, "epss_percentile": 0.95531}, "CVE-2018-7105": {"epss_score": 0.01583, "epss_percentile": 0.81146}, "CVE-2018-7107": {"epss_score": 0.00298, "epss_percentile": 0.52794}, "CVE-2018-7108": {"epss_score": 0.01125, "epss_percentile": 0.77802}, "CVE-2018-7109": {"epss_score": 0.00284, "epss_percentile": 0.51441}, "CVE-2018-7110": {"epss_score": 0.0025, "epss_percentile": 0.48094}, "CVE-2018-7111": {"epss_score": 0.03656, "epss_percentile": 0.87517}, "CVE-2018-7112": {"epss_score": 0.0017, "epss_percentile": 0.38706}, "CVE-2018-7113": {"epss_score": 0.0011, "epss_percentile": 0.30202}, "CVE-2018-7114": {"epss_score": 0.61648, "epss_percentile": 0.98256}, "CVE-2018-7115": {"epss_score": 0.09013, "epss_percentile": 0.92365}, "CVE-2018-7116": {"epss_score": 0.06176, "epss_percentile": 0.90533}, "CVE-2018-7117": {"epss_score": 0.0099, "epss_percentile": 0.76378}, "CVE-2018-7118": {"epss_score": 0.001, "epss_percentile": 0.28551}, "CVE-2018-7119": {"epss_score": 0.0026, "epss_percentile": 0.49219}, "CVE-2018-7120": {"epss_score": 0.01025, "epss_percentile": 0.76788}, "CVE-2018-7121": {"epss_score": 0.4384, "epss_percentile": 0.97405}, "CVE-2018-7122": {"epss_score": 0.01439, "epss_percentile": 0.80292}, "CVE-2018-7123": {"epss_score": 0.32252, "epss_percentile": 0.96682}, "CVE-2018-7124": {"epss_score": 0.20374, "epss_percentile": 0.95334}, "CVE-2018-7125": {"epss_score": 0.0053, "epss_percentile": 0.66632}, "CVE-2018-7158": {"epss_score": 0.01772, "epss_percentile": 0.82201}, "CVE-2018-7159": {"epss_score": 0.00702, "epss_percentile": 0.71522}, "CVE-2018-7160": {"epss_score": 0.01501, "epss_percentile": 0.80715}, "CVE-2018-7161": {"epss_score": 0.01023, "epss_percentile": 0.76765}, "CVE-2018-7162": {"epss_score": 0.01507, "epss_percentile": 0.80756}, "CVE-2018-7164": {"epss_score": 0.00905, "epss_percentile": 0.75237}, "CVE-2018-7166": {"epss_score": 0.00598, "epss_percentile": 0.68764}, "CVE-2018-7167": {"epss_score": 0.00815, "epss_percentile": 0.73787}, "CVE-2018-7169": {"epss_score": 0.00196, "epss_percentile": 0.41792}, "CVE-2018-7170": {"epss_score": 0.00536, "epss_percentile": 0.66865}, "CVE-2018-7171": {"epss_score": 0.48295, "epss_percentile": 0.97629}, "CVE-2018-7172": {"epss_score": 0.01368, "epss_percentile": 0.7979}, "CVE-2018-7173": {"epss_score": 0.00148, "epss_percentile": 0.3593}, "CVE-2018-7174": {"epss_score": 0.00177, "epss_percentile": 0.39617}, "CVE-2018-7175": {"epss_score": 0.00177, "epss_percentile": 0.39617}, "CVE-2018-7176": {"epss_score": 0.00176, "epss_percentile": 0.39408}, "CVE-2018-7177": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-7178": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-7179": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-7180": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-7182": {"epss_score": 0.14259, "epss_percentile": 0.94175}, "CVE-2018-7183": {"epss_score": 0.2629, "epss_percentile": 0.96136}, "CVE-2018-7184": {"epss_score": 0.13062, "epss_percentile": 0.93862}, "CVE-2018-7185": {"epss_score": 0.03774, "epss_percentile": 0.87707}, "CVE-2018-7186": {"epss_score": 0.03118, "epss_percentile": 0.86438}, "CVE-2018-7187": {"epss_score": 0.15136, "epss_percentile": 0.94371}, "CVE-2018-7188": {"epss_score": 0.00339, "epss_percentile": 0.56177}, "CVE-2018-7191": {"epss_score": 0.00077, "epss_percentile": 0.2329}, "CVE-2018-7192": {"epss_score": 0.00775, "epss_percentile": 0.73089}, "CVE-2018-7193": {"epss_score": 0.0013, "epss_percentile": 0.33262}, "CVE-2018-7194": {"epss_score": 0.00574, "epss_percentile": 0.68095}, "CVE-2018-7195": {"epss_score": 0.00353, "epss_percentile": 0.57141}, "CVE-2018-7196": {"epss_score": 0.0013, "epss_percentile": 0.33262}, "CVE-2018-7197": {"epss_score": 0.00384, "epss_percentile": 0.59174}, "CVE-2018-7198": {"epss_score": 0.00495, "epss_percentile": 0.65102}, "CVE-2018-7201": {"epss_score": 0.00415, "epss_percentile": 0.6113}, "CVE-2018-7202": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-7203": {"epss_score": 0.00322, "epss_percentile": 0.54745}, "CVE-2018-7204": {"epss_score": 0.00745, "epss_percentile": 0.72524}, "CVE-2018-7205": {"epss_score": 0.00157, "epss_percentile": 0.37125}, "CVE-2018-7206": {"epss_score": 0.00651, "epss_percentile": 0.70292}, "CVE-2018-7208": {"epss_score": 0.00201, "epss_percentile": 0.42347}, "CVE-2018-7209": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2018-7210": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2018-7211": {"epss_score": 0.00103, "epss_percentile": 0.29078}, "CVE-2018-7212": {"epss_score": 0.00278, "epss_percentile": 0.50921}, "CVE-2018-7213": {"epss_score": 0.0016, "epss_percentile": 0.37482}, "CVE-2018-7216": {"epss_score": 0.0023, "epss_percentile": 0.45666}, "CVE-2018-7217": {"epss_score": 0.00368, "epss_percentile": 0.58165}, "CVE-2018-7218": {"epss_score": 0.05897, "epss_percentile": 0.90305}, "CVE-2018-7219": {"epss_score": 0.00168, "epss_percentile": 0.38442}, "CVE-2018-7225": {"epss_score": 0.04263, "epss_percentile": 0.88464}, "CVE-2018-7226": {"epss_score": 0.00448, "epss_percentile": 0.62993}, "CVE-2018-7227": {"epss_score": 0.00184, "epss_percentile": 0.40432}, "CVE-2018-7228": {"epss_score": 0.00693, "epss_percentile": 0.71331}, "CVE-2018-7229": {"epss_score": 0.00511, "epss_percentile": 0.65836}, "CVE-2018-7230": {"epss_score": 0.00342, "epss_percentile": 0.564}, "CVE-2018-7231": {"epss_score": 0.01142, "epss_percentile": 0.7797}, "CVE-2018-7232": {"epss_score": 0.01142, "epss_percentile": 0.7797}, "CVE-2018-7233": {"epss_score": 0.01142, "epss_percentile": 0.7797}, "CVE-2018-7234": {"epss_score": 0.00134, "epss_percentile": 0.33866}, "CVE-2018-7235": {"epss_score": 0.00292, "epss_percentile": 0.52239}, "CVE-2018-7236": {"epss_score": 0.00235, "epss_percentile": 0.46241}, "CVE-2018-7237": {"epss_score": 0.00527, "epss_percentile": 0.66521}, "CVE-2018-7238": {"epss_score": 0.02595, "epss_percentile": 0.8519}, "CVE-2018-7239": {"epss_score": 0.00248, "epss_percentile": 0.47957}, "CVE-2018-7240": {"epss_score": 0.00414, "epss_percentile": 0.61043}, "CVE-2018-7241": {"epss_score": 0.00552, "epss_percentile": 0.67394}, "CVE-2018-7242": {"epss_score": 0.00247, "epss_percentile": 0.47891}, "CVE-2018-7243": {"epss_score": 0.02233, "epss_percentile": 0.84094}, "CVE-2018-7244": {"epss_score": 0.00212, "epss_percentile": 0.43808}, "CVE-2018-7245": {"epss_score": 0.00435, "epss_percentile": 0.62347}, "CVE-2018-7246": {"epss_score": 0.00151, "epss_percentile": 0.36188}, "CVE-2018-7247": {"epss_score": 0.00394, "epss_percentile": 0.59787}, "CVE-2018-7248": {"epss_score": 0.05186, "epss_percentile": 0.89588}, "CVE-2018-7249": {"epss_score": 0.02337, "epss_percentile": 0.84421}, "CVE-2018-7250": {"epss_score": 0.11777, "epss_percentile": 0.93471}, "CVE-2018-7251": {"epss_score": 0.92809, "epss_percentile": 0.99751}, "CVE-2018-7253": {"epss_score": 0.00879, "epss_percentile": 0.74842}, "CVE-2018-7254": {"epss_score": 0.21314, "epss_percentile": 0.955}, "CVE-2018-7259": {"epss_score": 0.00182, "epss_percentile": 0.40187}, "CVE-2018-7260": {"epss_score": 0.00302, "epss_percentile": 0.53083}, "CVE-2018-7261": {"epss_score": 0.00195, "epss_percentile": 0.41621}, "CVE-2018-7262": {"epss_score": 0.01398, "epss_percentile": 0.79988}, "CVE-2018-7263": {"epss_score": 0.00864, "epss_percentile": 0.74599}, "CVE-2018-7264": {"epss_score": 0.1289, "epss_percentile": 0.93813}, "CVE-2018-7265": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-7268": {"epss_score": 0.00059, "epss_percentile": 0.18758}, "CVE-2018-7269": {"epss_score": 0.0061, "epss_percentile": 0.69153}, "CVE-2018-7271": {"epss_score": 0.00837, "epss_percentile": 0.74163}, "CVE-2018-7272": {"epss_score": 0.00294, "epss_percentile": 0.52426}, "CVE-2018-7273": {"epss_score": 0.01682, "epss_percentile": 0.81736}, "CVE-2018-7274": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2018-7276": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2018-7277": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-7278": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-7279": {"epss_score": 0.02396, "epss_percentile": 0.84616}, "CVE-2018-7280": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2018-7281": {"epss_score": 0.00432, "epss_percentile": 0.62133}, "CVE-2018-7282": {"epss_score": 0.74238, "epss_percentile": 0.98793}, "CVE-2018-7284": {"epss_score": 0.65243, "epss_percentile": 0.98408}, "CVE-2018-7285": {"epss_score": 0.00536, "epss_percentile": 0.66852}, "CVE-2018-7286": {"epss_score": 0.54632, "epss_percentile": 0.97937}, "CVE-2018-7287": {"epss_score": 0.33107, "epss_percentile": 0.96747}, "CVE-2018-7289": {"epss_score": 0.01997, "epss_percentile": 0.83198}, "CVE-2018-7290": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-7295": {"epss_score": 0.00176, "epss_percentile": 0.39472}, "CVE-2018-7296": {"epss_score": 0.00241, "epss_percentile": 0.47249}, "CVE-2018-7297": {"epss_score": 0.46567, "epss_percentile": 0.97552}, "CVE-2018-7298": {"epss_score": 0.00107, "epss_percentile": 0.29684}, "CVE-2018-7299": {"epss_score": 0.00197, "epss_percentile": 0.41949}, "CVE-2018-7300": {"epss_score": 0.12405, "epss_percentile": 0.9366}, "CVE-2018-7301": {"epss_score": 0.00221, "epss_percentile": 0.44633}, "CVE-2018-7302": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-7303": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-7304": {"epss_score": 0.0045, "epss_percentile": 0.63107}, "CVE-2018-7305": {"epss_score": 0.00103, "epss_percentile": 0.29086}, "CVE-2018-7307": {"epss_score": 0.00203, "epss_percentile": 0.42546}, "CVE-2018-7308": {"epss_score": 0.002, "epss_percentile": 0.42224}, "CVE-2018-7311": {"epss_score": 0.0061, "epss_percentile": 0.69154}, "CVE-2018-7312": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-7313": {"epss_score": 0.01646, "epss_percentile": 0.81533}, "CVE-2018-7314": {"epss_score": 0.9227, "epss_percentile": 0.99704}, "CVE-2018-7315": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-7316": {"epss_score": 0.11091, "epss_percentile": 0.93216}, "CVE-2018-7317": {"epss_score": 0.23058, "epss_percentile": 0.95726}, "CVE-2018-7318": {"epss_score": 0.25318, "epss_percentile": 0.96011}, "CVE-2018-7319": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-7320": {"epss_score": 0.007, "epss_percentile": 0.71465}, "CVE-2018-7321": {"epss_score": 0.00428, "epss_percentile": 0.6194}, "CVE-2018-7322": {"epss_score": 0.00538, "epss_percentile": 0.66932}, "CVE-2018-7323": {"epss_score": 0.00538, "epss_percentile": 0.66932}, "CVE-2018-7324": {"epss_score": 0.00538, "epss_percentile": 0.66932}, "CVE-2018-7325": {"epss_score": 0.00376, "epss_percentile": 0.58656}, "CVE-2018-7326": {"epss_score": 0.00388, "epss_percentile": 0.59397}, "CVE-2018-7327": {"epss_score": 0.00355, "epss_percentile": 0.57315}, "CVE-2018-7328": {"epss_score": 0.00355, "epss_percentile": 0.57315}, "CVE-2018-7329": {"epss_score": 0.00355, "epss_percentile": 0.57315}, "CVE-2018-7330": {"epss_score": 0.00355, "epss_percentile": 0.57315}, "CVE-2018-7331": {"epss_score": 0.01301, "epss_percentile": 0.79291}, "CVE-2018-7332": {"epss_score": 0.00374, "epss_percentile": 0.58533}, "CVE-2018-7333": {"epss_score": 0.00355, "epss_percentile": 0.57315}, "CVE-2018-7334": {"epss_score": 0.01005, "epss_percentile": 0.7654}, "CVE-2018-7335": {"epss_score": 0.01005, "epss_percentile": 0.7654}, "CVE-2018-7336": {"epss_score": 0.01008, "epss_percentile": 0.76571}, "CVE-2018-7337": {"epss_score": 0.007, "epss_percentile": 0.71465}, "CVE-2018-7339": {"epss_score": 0.00444, "epss_percentile": 0.62845}, "CVE-2018-7340": {"epss_score": 0.0013, "epss_percentile": 0.33307}, "CVE-2018-7355": {"epss_score": 0.00957, "epss_percentile": 0.75928}, "CVE-2018-7356": {"epss_score": 0.00188, "epss_percentile": 0.40913}, "CVE-2018-7357": {"epss_score": 0.39173, "epss_percentile": 0.97144}, "CVE-2018-7358": {"epss_score": 0.31994, "epss_percentile": 0.96665}, "CVE-2018-7359": {"epss_score": 0.00814, "epss_percentile": 0.7377}, "CVE-2018-7360": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2018-7361": {"epss_score": 0.00079, "epss_percentile": 0.23947}, "CVE-2018-7362": {"epss_score": 0.002, "epss_percentile": 0.42216}, "CVE-2018-7363": {"epss_score": 0.00079, "epss_percentile": 0.23801}, "CVE-2018-7364": {"epss_score": 0.08178, "epss_percentile": 0.91916}, "CVE-2018-7365": {"epss_score": 0.00302, "epss_percentile": 0.5309}, "CVE-2018-7366": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2018-7405": {"epss_score": 0.00479, "epss_percentile": 0.64412}, "CVE-2018-7406": {"epss_score": 0.01231, "epss_percentile": 0.78731}, "CVE-2018-7407": {"epss_score": 0.00601, "epss_percentile": 0.68839}, "CVE-2018-7408": {"epss_score": 0.00042, "epss_percentile": 0.126}, "CVE-2018-7409": {"epss_score": 0.00302, "epss_percentile": 0.53139}, "CVE-2018-7417": {"epss_score": 0.00401, "epss_percentile": 0.60253}, "CVE-2018-7418": {"epss_score": 0.01005, "epss_percentile": 0.7654}, "CVE-2018-7419": {"epss_score": 0.02017, "epss_percentile": 0.83278}, "CVE-2018-7420": {"epss_score": 0.02017, "epss_percentile": 0.83278}, "CVE-2018-7421": {"epss_score": 0.00428, "epss_percentile": 0.6194}, "CVE-2018-7422": {"epss_score": 0.91394, "epss_percentile": 0.99639}, "CVE-2018-7427": {"epss_score": 0.00213, "epss_percentile": 0.43906}, "CVE-2018-7429": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2018-7431": {"epss_score": 0.00395, "epss_percentile": 0.59842}, "CVE-2018-7432": {"epss_score": 0.00577, "epss_percentile": 0.68156}, "CVE-2018-7433": {"epss_score": 0.00583, "epss_percentile": 0.68338}, "CVE-2018-7434": {"epss_score": 0.00296, "epss_percentile": 0.52539}, "CVE-2018-7435": {"epss_score": 0.01006, "epss_percentile": 0.76548}, "CVE-2018-7436": {"epss_score": 0.00771, "epss_percentile": 0.73023}, "CVE-2018-7437": {"epss_score": 0.00665, "epss_percentile": 0.70662}, "CVE-2018-7438": {"epss_score": 0.00665, "epss_percentile": 0.70662}, "CVE-2018-7439": {"epss_score": 0.01006, "epss_percentile": 0.76548}, "CVE-2018-7440": {"epss_score": 0.01791, "epss_percentile": 0.82281}, "CVE-2018-7441": {"epss_score": 0.00043, "epss_percentile": 0.13344}, "CVE-2018-7442": {"epss_score": 0.00204, "epss_percentile": 0.426}, "CVE-2018-7443": {"epss_score": 0.00441, "epss_percentile": 0.62652}, "CVE-2018-7445": {"epss_score": 0.86241, "epss_percentile": 0.99375}, "CVE-2018-7447": {"epss_score": 0.00229, "epss_percentile": 0.4565}, "CVE-2018-7448": {"epss_score": 0.42075, "epss_percentile": 0.97311}, "CVE-2018-7449": {"epss_score": 0.20849, "epss_percentile": 0.95428}, "CVE-2018-7452": {"epss_score": 0.00137, "epss_percentile": 0.3431}, "CVE-2018-7453": {"epss_score": 0.00444, "epss_percentile": 0.62834}, "CVE-2018-7454": {"epss_score": 0.00148, "epss_percentile": 0.3593}, "CVE-2018-7455": {"epss_score": 0.00148, "epss_percentile": 0.3593}, "CVE-2018-7456": {"epss_score": 0.00656, "epss_percentile": 0.70436}, "CVE-2018-7463": {"epss_score": 0.00421, "epss_percentile": 0.61529}, "CVE-2018-7465": {"epss_score": 0.00278, "epss_percentile": 0.50875}, "CVE-2018-7466": {"epss_score": 0.10683, "epss_percentile": 0.93069}, "CVE-2018-7467": {"epss_score": 0.10699, "epss_percentile": 0.93075}, "CVE-2018-7469": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-7470": {"epss_score": 0.00252, "epss_percentile": 0.48342}, "CVE-2018-7471": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2018-7472": {"epss_score": 0.00137, "epss_percentile": 0.34317}, "CVE-2018-7473": {"epss_score": 0.00214, "epss_percentile": 0.43967}, "CVE-2018-7474": {"epss_score": 0.17139, "epss_percentile": 0.94781}, "CVE-2018-7475": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2018-7476": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-7477": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2018-7479": {"epss_score": 0.00396, "epss_percentile": 0.59924}, "CVE-2018-7480": {"epss_score": 0.00071, "epss_percentile": 0.22213}, "CVE-2018-7482": {"epss_score": 0.0054, "epss_percentile": 0.67014}, "CVE-2018-7484": {"epss_score": 0.00188, "epss_percentile": 0.40914}, "CVE-2018-7485": {"epss_score": 0.00419, "epss_percentile": 0.61389}, "CVE-2018-7486": {"epss_score": 0.04331, "epss_percentile": 0.88559}, "CVE-2018-7487": {"epss_score": 0.00198, "epss_percentile": 0.42096}, "CVE-2018-7489": {"epss_score": 0.36207, "epss_percentile": 0.9696}, "CVE-2018-7490": {"epss_score": 0.94105, "epss_percentile": 0.99903}, "CVE-2018-7491": {"epss_score": 0.00164, "epss_percentile": 0.37865}, "CVE-2018-7492": {"epss_score": 0.00071, "epss_percentile": 0.21987}, "CVE-2018-7493": {"epss_score": 0.00339, "epss_percentile": 0.5618}, "CVE-2018-7494": {"epss_score": 0.01058, "epss_percentile": 0.7714}, "CVE-2018-7495": {"epss_score": 0.03023, "epss_percentile": 0.8623}, "CVE-2018-7496": {"epss_score": 0.00231, "epss_percentile": 0.45775}, "CVE-2018-7497": {"epss_score": 0.0068, "epss_percentile": 0.71032}, "CVE-2018-7498": {"epss_score": 0.00087, "epss_percentile": 0.25614}, "CVE-2018-7499": {"epss_score": 0.01439, "epss_percentile": 0.8029}, "CVE-2018-7500": {"epss_score": 0.00474, "epss_percentile": 0.64154}, "CVE-2018-7501": {"epss_score": 0.00267, "epss_percentile": 0.49987}, "CVE-2018-7502": {"epss_score": 0.00172, "epss_percentile": 0.3893}, "CVE-2018-7503": {"epss_score": 0.01713, "epss_percentile": 0.81889}, "CVE-2018-7504": {"epss_score": 0.0018, "epss_percentile": 0.39982}, "CVE-2018-7505": {"epss_score": 0.00786, "epss_percentile": 0.73294}, "CVE-2018-7506": {"epss_score": 0.01079, "epss_percentile": 0.77356}, "CVE-2018-7507": {"epss_score": 0.01058, "epss_percentile": 0.7714}, "CVE-2018-7508": {"epss_score": 0.0018, "epss_percentile": 0.39982}, "CVE-2018-7509": {"epss_score": 0.01058, "epss_percentile": 0.7714}, "CVE-2018-7510": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2018-7511": {"epss_score": 0.01422, "epss_percentile": 0.80175}, "CVE-2018-7512": {"epss_score": 0.0009, "epss_percentile": 0.26139}, "CVE-2018-7513": {"epss_score": 0.00103, "epss_percentile": 0.29008}, "CVE-2018-7514": {"epss_score": 0.00113, "epss_percentile": 0.30598}, "CVE-2018-7515": {"epss_score": 0.00065, "epss_percentile": 0.20652}, "CVE-2018-7516": {"epss_score": 0.00137, "epss_percentile": 0.34211}, "CVE-2018-7517": {"epss_score": 0.0009, "epss_percentile": 0.26122}, "CVE-2018-7518": {"epss_score": 0.00236, "epss_percentile": 0.46369}, "CVE-2018-7519": {"epss_score": 0.00103, "epss_percentile": 0.29008}, "CVE-2018-7520": {"epss_score": 0.00295, "epss_percentile": 0.52485}, "CVE-2018-7521": {"epss_score": 0.00106, "epss_percentile": 0.29439}, "CVE-2018-7522": {"epss_score": 0.00067, "epss_percentile": 0.21096}, "CVE-2018-7523": {"epss_score": 0.0009, "epss_percentile": 0.26122}, "CVE-2018-7524": {"epss_score": 0.00072, "epss_percentile": 0.2241}, "CVE-2018-7525": {"epss_score": 0.0009, "epss_percentile": 0.26122}, "CVE-2018-7526": {"epss_score": 0.00216, "epss_percentile": 0.44188}, "CVE-2018-7527": {"epss_score": 0.00129, "epss_percentile": 0.33183}, "CVE-2018-7528": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2018-7529": {"epss_score": 0.00611, "epss_percentile": 0.69193}, "CVE-2018-7530": {"epss_score": 0.00058, "epss_percentile": 0.18275}, "CVE-2018-7531": {"epss_score": 0.0041, "epss_percentile": 0.60806}, "CVE-2018-7532": {"epss_score": 0.18431, "epss_percentile": 0.95015}, "CVE-2018-7533": {"epss_score": 0.00037, "epss_percentile": 0.10994}, "CVE-2018-7534": {"epss_score": 0.00034, "epss_percentile": 0.09798}, "CVE-2018-7535": {"epss_score": 0.00027, "epss_percentile": 0.06804}, "CVE-2018-7536": {"epss_score": 0.01293, "epss_percentile": 0.79239}, "CVE-2018-7537": {"epss_score": 0.01201, "epss_percentile": 0.78479}, "CVE-2018-7538": {"epss_score": 0.11993, "epss_percentile": 0.9354}, "CVE-2018-7539": {"epss_score": 0.18366, "epss_percentile": 0.95006}, "CVE-2018-7540": {"epss_score": 0.0009, "epss_percentile": 0.26136}, "CVE-2018-7541": {"epss_score": 0.00092, "epss_percentile": 0.26547}, "CVE-2018-7542": {"epss_score": 0.00054, "epss_percentile": 0.17215}, "CVE-2018-7543": {"epss_score": 0.01419, "epss_percentile": 0.80161}, "CVE-2018-7544": {"epss_score": 0.00377, "epss_percentile": 0.58775}, "CVE-2018-7546": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2018-7547": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-7548": {"epss_score": 0.00372, "epss_percentile": 0.58449}, "CVE-2018-7549": {"epss_score": 0.00206, "epss_percentile": 0.42934}, "CVE-2018-7550": {"epss_score": 0.00084, "epss_percentile": 0.24909}, "CVE-2018-7551": {"epss_score": 0.00567, "epss_percentile": 0.67841}, "CVE-2018-7552": {"epss_score": 0.00567, "epss_percentile": 0.67841}, "CVE-2018-7553": {"epss_score": 0.00559, "epss_percentile": 0.67613}, "CVE-2018-7554": {"epss_score": 0.00567, "epss_percentile": 0.67841}, "CVE-2018-7556": {"epss_score": 0.00289, "epss_percentile": 0.51999}, "CVE-2018-7557": {"epss_score": 0.01067, "epss_percentile": 0.77234}, "CVE-2018-7559": {"epss_score": 0.00265, "epss_percentile": 0.49802}, "CVE-2018-7560": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-7561": {"epss_score": 0.00837, "epss_percentile": 0.74159}, "CVE-2018-7562": {"epss_score": 0.00811, "epss_percentile": 0.73734}, "CVE-2018-7563": {"epss_score": 0.00328, "epss_percentile": 0.55165}, "CVE-2018-7564": {"epss_score": 0.00283, "epss_percentile": 0.51382}, "CVE-2018-7565": {"epss_score": 0.00149, "epss_percentile": 0.36005}, "CVE-2018-7566": {"epss_score": 0.00051, "epss_percentile": 0.16281}, "CVE-2018-7567": {"epss_score": 0.02239, "epss_percentile": 0.84109}, "CVE-2018-7568": {"epss_score": 0.00172, "epss_percentile": 0.38929}, "CVE-2018-7569": {"epss_score": 0.00147, "epss_percentile": 0.35748}, "CVE-2018-7570": {"epss_score": 0.00461, "epss_percentile": 0.63566}, "CVE-2018-7572": {"epss_score": 0.00036, "epss_percentile": 0.10251}, "CVE-2018-7573": {"epss_score": 0.77954, "epss_percentile": 0.98961}, "CVE-2018-7575": {"epss_score": 0.00176, "epss_percentile": 0.39383}, "CVE-2018-7576": {"epss_score": 0.00109, "epss_percentile": 0.29989}, "CVE-2018-7577": {"epss_score": 0.00166, "epss_percentile": 0.38171}, "CVE-2018-7579": {"epss_score": 0.00247, "epss_percentile": 0.47867}, "CVE-2018-7580": {"epss_score": 0.01658, "epss_percentile": 0.8161}, "CVE-2018-7581": {"epss_score": 0.0009, "epss_percentile": 0.26009}, "CVE-2018-7582": {"epss_score": 0.36028, "epss_percentile": 0.96951}, "CVE-2018-7583": {"epss_score": 0.21556, "epss_percentile": 0.95533}, "CVE-2018-7584": {"epss_score": 0.80641, "epss_percentile": 0.99098}, "CVE-2018-7586": {"epss_score": 0.0157, "epss_percentile": 0.81092}, "CVE-2018-7587": {"epss_score": 0.00273, "epss_percentile": 0.50457}, "CVE-2018-7588": {"epss_score": 0.00308, "epss_percentile": 0.53638}, "CVE-2018-7589": {"epss_score": 0.00308, "epss_percentile": 0.53638}, "CVE-2018-7590": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2018-7600": {"epss_score": 0.94489, "epss_percentile": 0.99999}, "CVE-2018-7602": {"epss_score": 0.94337, "epss_percentile": 0.99951}, "CVE-2018-7603": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-7631": {"epss_score": 0.01015, "epss_percentile": 0.76669}, "CVE-2018-7632": {"epss_score": 0.0033, "epss_percentile": 0.5545}, "CVE-2018-7633": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2018-7634": {"epss_score": 0.00185, "epss_percentile": 0.40471}, "CVE-2018-7635": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-7636": {"epss_score": 0.00348, "epss_percentile": 0.56827}, "CVE-2018-7637": {"epss_score": 0.00227, "epss_percentile": 0.4543}, "CVE-2018-7638": {"epss_score": 0.00227, "epss_percentile": 0.4543}, "CVE-2018-7639": {"epss_score": 0.00227, "epss_percentile": 0.4543}, "CVE-2018-7640": {"epss_score": 0.00227, "epss_percentile": 0.4543}, "CVE-2018-7641": {"epss_score": 0.00227, "epss_percentile": 0.4543}, "CVE-2018-7642": {"epss_score": 0.00193, "epss_percentile": 0.41381}, "CVE-2018-7643": {"epss_score": 0.00173, "epss_percentile": 0.39136}, "CVE-2018-7644": {"epss_score": 0.00068, "epss_percentile": 0.21333}, "CVE-2018-7648": {"epss_score": 0.00562, "epss_percentile": 0.67697}, "CVE-2018-7649": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-7650": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-7651": {"epss_score": 0.00377, "epss_percentile": 0.58741}, "CVE-2018-7652": {"epss_score": 0.00342, "epss_percentile": 0.56363}, "CVE-2018-7653": {"epss_score": 0.01096, "epss_percentile": 0.77514}, "CVE-2018-7654": {"epss_score": 0.00384, "epss_percentile": 0.59171}, "CVE-2018-7658": {"epss_score": 0.17994, "epss_percentile": 0.94939}, "CVE-2018-7659": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-7660": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-7661": {"epss_score": 0.00128, "epss_percentile": 0.32965}, "CVE-2018-7662": {"epss_score": 0.89626, "epss_percentile": 0.99535}, "CVE-2018-7663": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-7664": {"epss_score": 0.00723, "epss_percentile": 0.72012}, "CVE-2018-7665": {"epss_score": 0.71111, "epss_percentile": 0.98653}, "CVE-2018-7666": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-7667": {"epss_score": 0.10995, "epss_percentile": 0.93185}, "CVE-2018-7668": {"epss_score": 0.00315, "epss_percentile": 0.54213}, "CVE-2018-7669": {"epss_score": 0.2446, "epss_percentile": 0.95924}, "CVE-2018-7673": {"epss_score": 0.00165, "epss_percentile": 0.38036}, "CVE-2018-7674": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2018-7675": {"epss_score": 0.00182, "epss_percentile": 0.40151}, "CVE-2018-7676": {"epss_score": 0.00275, "epss_percentile": 0.50628}, "CVE-2018-7677": {"epss_score": 0.00131, "epss_percentile": 0.33364}, "CVE-2018-7678": {"epss_score": 0.00207, "epss_percentile": 0.43195}, "CVE-2018-7679": {"epss_score": 0.01689, "epss_percentile": 0.81765}, "CVE-2018-7680": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-7681": {"epss_score": 0.00207, "epss_percentile": 0.43195}, "CVE-2018-7682": {"epss_score": 0.00259, "epss_percentile": 0.49064}, "CVE-2018-7683": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2018-7685": {"epss_score": 0.00073, "epss_percentile": 0.22589}, "CVE-2018-7686": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2018-7687": {"epss_score": 0.00044, "epss_percentile": 0.13663}, "CVE-2018-7688": {"epss_score": 0.00165, "epss_percentile": 0.38065}, "CVE-2018-7689": {"epss_score": 0.00165, "epss_percentile": 0.38065}, "CVE-2018-7690": {"epss_score": 0.07369, "epss_percentile": 0.91439}, "CVE-2018-7691": {"epss_score": 0.07369, "epss_percentile": 0.91439}, "CVE-2018-7692": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2018-7698": {"epss_score": 0.00298, "epss_percentile": 0.52806}, "CVE-2018-7700": {"epss_score": 0.93575, "epss_percentile": 0.99819}, "CVE-2018-7701": {"epss_score": 0.00193, "epss_percentile": 0.41419}, "CVE-2018-7702": {"epss_score": 0.49507, "epss_percentile": 0.97692}, "CVE-2018-7703": {"epss_score": 0.07868, "epss_percentile": 0.91733}, "CVE-2018-7704": {"epss_score": 0.18472, "epss_percentile": 0.95019}, "CVE-2018-7705": {"epss_score": 0.07864, "epss_percentile": 0.91728}, "CVE-2018-7706": {"epss_score": 0.138, "epss_percentile": 0.94059}, "CVE-2018-7707": {"epss_score": 0.07868, "epss_percentile": 0.91733}, "CVE-2018-7711": {"epss_score": 0.00208, "epss_percentile": 0.43298}, "CVE-2018-7712": {"epss_score": 0.00409, "epss_percentile": 0.60786}, "CVE-2018-7713": {"epss_score": 0.00409, "epss_percentile": 0.60786}, "CVE-2018-7714": {"epss_score": 0.00409, "epss_percentile": 0.60786}, "CVE-2018-7715": {"epss_score": 0.00695, "epss_percentile": 0.71379}, "CVE-2018-7716": {"epss_score": 0.00695, "epss_percentile": 0.71379}, "CVE-2018-7717": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-7718": {"epss_score": 0.00278, "epss_percentile": 0.50851}, "CVE-2018-7719": {"epss_score": 0.86831, "epss_percentile": 0.99401}, "CVE-2018-7720": {"epss_score": 0.00324, "epss_percentile": 0.54964}, "CVE-2018-7721": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-7722": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-7723": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-7724": {"epss_score": 0.00096, "epss_percentile": 0.27442}, "CVE-2018-7725": {"epss_score": 0.00498, "epss_percentile": 0.65231}, "CVE-2018-7726": {"epss_score": 0.00498, "epss_percentile": 0.65231}, "CVE-2018-7727": {"epss_score": 0.00102, "epss_percentile": 0.28763}, "CVE-2018-7728": {"epss_score": 0.005, "epss_percentile": 0.65313}, "CVE-2018-7729": {"epss_score": 0.00344, "epss_percentile": 0.5653}, "CVE-2018-7730": {"epss_score": 0.001, "epss_percentile": 0.28495}, "CVE-2018-7731": {"epss_score": 0.00366, "epss_percentile": 0.58068}, "CVE-2018-7732": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-7733": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2018-7734": {"epss_score": 0.00859, "epss_percentile": 0.7452}, "CVE-2018-7735": {"epss_score": 0.00859, "epss_percentile": 0.7452}, "CVE-2018-7736": {"epss_score": 0.02794, "epss_percentile": 0.85677}, "CVE-2018-7737": {"epss_score": 0.16126, "epss_percentile": 0.94576}, "CVE-2018-7738": {"epss_score": 0.00058, "epss_percentile": 0.1847}, "CVE-2018-7739": {"epss_score": 0.089, "epss_percentile": 0.92306}, "CVE-2018-7740": {"epss_score": 0.0009, "epss_percentile": 0.26006}, "CVE-2018-7741": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-7745": {"epss_score": 0.17299, "epss_percentile": 0.94818}, "CVE-2018-7746": {"epss_score": 0.01271, "epss_percentile": 0.79056}, "CVE-2018-7747": {"epss_score": 0.00941, "epss_percentile": 0.7575}, "CVE-2018-7748": {"epss_score": 0.02992, "epss_percentile": 0.86146}, "CVE-2018-7749": {"epss_score": 0.00389, "epss_percentile": 0.59455}, "CVE-2018-7750": {"epss_score": 0.16054, "epss_percentile": 0.94565}, "CVE-2018-7751": {"epss_score": 0.01066, "epss_percentile": 0.77217}, "CVE-2018-7752": {"epss_score": 0.00176, "epss_percentile": 0.39423}, "CVE-2018-7753": {"epss_score": 0.00511, "epss_percentile": 0.65843}, "CVE-2018-7754": {"epss_score": 0.00102, "epss_percentile": 0.28741}, "CVE-2018-7755": {"epss_score": 7e-05, "epss_percentile": 0.00334}, "CVE-2018-7756": {"epss_score": 0.40378, "epss_percentile": 0.97216}, "CVE-2018-7757": {"epss_score": 0.00101, "epss_percentile": 0.28598}, "CVE-2018-7758": {"epss_score": 0.00131, "epss_percentile": 0.33463}, "CVE-2018-7759": {"epss_score": 0.00821, "epss_percentile": 0.73906}, "CVE-2018-7760": {"epss_score": 0.00142, "epss_percentile": 0.35073}, "CVE-2018-7761": {"epss_score": 0.00548, "epss_percentile": 0.67286}, "CVE-2018-7762": {"epss_score": 0.00821, "epss_percentile": 0.73906}, "CVE-2018-7763": {"epss_score": 0.00104, "epss_percentile": 0.29128}, "CVE-2018-7764": {"epss_score": 0.00104, "epss_percentile": 0.29128}, "CVE-2018-7765": {"epss_score": 0.00126, "epss_percentile": 0.32624}, "CVE-2018-7766": {"epss_score": 0.00346, "epss_percentile": 0.5661}, "CVE-2018-7767": {"epss_score": 0.00346, "epss_percentile": 0.5661}, "CVE-2018-7768": {"epss_score": 0.00346, "epss_percentile": 0.5661}, "CVE-2018-7769": {"epss_score": 0.00346, "epss_percentile": 0.5661}, "CVE-2018-7770": {"epss_score": 0.00308, "epss_percentile": 0.53626}, "CVE-2018-7771": {"epss_score": 0.00483, "epss_percentile": 0.64618}, "CVE-2018-7772": {"epss_score": 0.00346, "epss_percentile": 0.5661}, "CVE-2018-7773": {"epss_score": 0.00346, "epss_percentile": 0.5661}, "CVE-2018-7774": {"epss_score": 0.00346, "epss_percentile": 0.5661}, "CVE-2018-7776": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2018-7777": {"epss_score": 0.08619, "epss_percentile": 0.92156}, "CVE-2018-7778": {"epss_score": 0.00693, "epss_percentile": 0.71323}, "CVE-2018-7779": {"epss_score": 0.00385, "epss_percentile": 0.59184}, "CVE-2018-7780": {"epss_score": 0.00543, "epss_percentile": 0.67119}, "CVE-2018-7781": {"epss_score": 0.00149, "epss_percentile": 0.3595}, "CVE-2018-7782": {"epss_score": 0.00209, "epss_percentile": 0.43399}, "CVE-2018-7783": {"epss_score": 0.00307, "epss_percentile": 0.53501}, "CVE-2018-7784": {"epss_score": 0.00784, "epss_percentile": 0.73229}, "CVE-2018-7785": {"epss_score": 0.14467, "epss_percentile": 0.94218}, "CVE-2018-7786": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2018-7787": {"epss_score": 0.00208, "epss_percentile": 0.43299}, "CVE-2018-7788": {"epss_score": 0.00415, "epss_percentile": 0.61129}, "CVE-2018-7789": {"epss_score": 0.00465, "epss_percentile": 0.6378}, "CVE-2018-7790": {"epss_score": 0.00492, "epss_percentile": 0.65005}, "CVE-2018-7791": {"epss_score": 0.00335, "epss_percentile": 0.5581}, "CVE-2018-7792": {"epss_score": 0.00273, "epss_percentile": 0.5043}, "CVE-2018-7793": {"epss_score": 0.0006, "epss_percentile": 0.19201}, "CVE-2018-7794": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2018-7795": {"epss_score": 0.00311, "epss_percentile": 0.53823}, "CVE-2018-7796": {"epss_score": 0.00284, "epss_percentile": 0.51472}, "CVE-2018-7797": {"epss_score": 0.00173, "epss_percentile": 0.39085}, "CVE-2018-7798": {"epss_score": 0.00157, "epss_percentile": 0.37123}, "CVE-2018-7799": {"epss_score": 0.00149, "epss_percentile": 0.36005}, "CVE-2018-7800": {"epss_score": 0.00961, "epss_percentile": 0.75976}, "CVE-2018-7801": {"epss_score": 0.16586, "epss_percentile": 0.94698}, "CVE-2018-7802": {"epss_score": 0.0082, "epss_percentile": 0.73877}, "CVE-2018-7803": {"epss_score": 0.00666, "epss_percentile": 0.70697}, "CVE-2018-7804": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2018-7806": {"epss_score": 0.00757, "epss_percentile": 0.72757}, "CVE-2018-7807": {"epss_score": 0.00757, "epss_percentile": 0.72757}, "CVE-2018-7809": {"epss_score": 0.01984, "epss_percentile": 0.83152}, "CVE-2018-7810": {"epss_score": 0.00311, "epss_percentile": 0.53925}, "CVE-2018-7811": {"epss_score": 0.01533, "epss_percentile": 0.80901}, "CVE-2018-7812": {"epss_score": 0.00833, "epss_percentile": 0.74096}, "CVE-2018-7813": {"epss_score": 0.00189, "epss_percentile": 0.40978}, "CVE-2018-7814": {"epss_score": 0.00244, "epss_percentile": 0.47553}, "CVE-2018-7815": {"epss_score": 0.00189, "epss_percentile": 0.40978}, "CVE-2018-7816": {"epss_score": 0.0015, "epss_percentile": 0.36177}, "CVE-2018-7817": {"epss_score": 0.0067, "epss_percentile": 0.70772}, "CVE-2018-7820": {"epss_score": 0.00282, "epss_percentile": 0.51285}, "CVE-2018-7821": {"epss_score": 0.0054, "epss_percentile": 0.66997}, "CVE-2018-7822": {"epss_score": 0.001, "epss_percentile": 0.28447}, "CVE-2018-7823": {"epss_score": 0.00522, "epss_percentile": 0.66284}, "CVE-2018-7824": {"epss_score": 0.00191, "epss_percentile": 0.41254}, "CVE-2018-7825": {"epss_score": 0.01048, "epss_percentile": 0.77058}, "CVE-2018-7826": {"epss_score": 0.01048, "epss_percentile": 0.77058}, "CVE-2018-7827": {"epss_score": 0.00227, "epss_percentile": 0.45377}, "CVE-2018-7828": {"epss_score": 0.00241, "epss_percentile": 0.47254}, "CVE-2018-7829": {"epss_score": 0.00523, "epss_percentile": 0.66307}, "CVE-2018-7830": {"epss_score": 0.02668, "epss_percentile": 0.8538}, "CVE-2018-7831": {"epss_score": 0.00223, "epss_percentile": 0.44939}, "CVE-2018-7832": {"epss_score": 0.01205, "epss_percentile": 0.78513}, "CVE-2018-7833": {"epss_score": 0.00455, "epss_percentile": 0.63294}, "CVE-2018-7834": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-7835": {"epss_score": 0.00408, "epss_percentile": 0.60655}, "CVE-2018-7836": {"epss_score": 0.02316, "epss_percentile": 0.84357}, "CVE-2018-7837": {"epss_score": 0.00307, "epss_percentile": 0.53501}, "CVE-2018-7838": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2018-7839": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-7840": {"epss_score": 0.00237, "epss_percentile": 0.46643}, "CVE-2018-7841": {"epss_score": 0.53349, "epss_percentile": 0.97873}, "CVE-2018-7842": {"epss_score": 0.08169, "epss_percentile": 0.91913}, "CVE-2018-7843": {"epss_score": 0.12918, "epss_percentile": 0.93817}, "CVE-2018-7844": {"epss_score": 0.13834, "epss_percentile": 0.94072}, "CVE-2018-7845": {"epss_score": 0.03746, "epss_percentile": 0.87664}, "CVE-2018-7846": {"epss_score": 0.43317, "epss_percentile": 0.97381}, "CVE-2018-7847": {"epss_score": 0.00962, "epss_percentile": 0.75987}, "CVE-2018-7848": {"epss_score": 0.11544, "epss_percentile": 0.934}, "CVE-2018-7849": {"epss_score": 0.12918, "epss_percentile": 0.93817}, "CVE-2018-7850": {"epss_score": 0.00172, "epss_percentile": 0.38911}, "CVE-2018-7851": {"epss_score": 0.00334, "epss_percentile": 0.55686}, "CVE-2018-7852": {"epss_score": 0.12918, "epss_percentile": 0.93817}, "CVE-2018-7853": {"epss_score": 0.00388, "epss_percentile": 0.59349}, "CVE-2018-7854": {"epss_score": 0.01633, "epss_percentile": 0.8146}, "CVE-2018-7855": {"epss_score": 0.00464, "epss_percentile": 0.63711}, "CVE-2018-7856": {"epss_score": 0.00494, "epss_percentile": 0.6509}, "CVE-2018-7857": {"epss_score": 0.00494, "epss_percentile": 0.6509}, "CVE-2018-7858": {"epss_score": 0.00055, "epss_percentile": 0.17453}, "CVE-2018-7859": {"epss_score": 0.00161, "epss_percentile": 0.37574}, "CVE-2018-7866": {"epss_score": 0.01407, "epss_percentile": 0.80054}, "CVE-2018-7867": {"epss_score": 0.00563, "epss_percentile": 0.6772}, "CVE-2018-7868": {"epss_score": 0.00571, "epss_percentile": 0.67975}, "CVE-2018-7869": {"epss_score": 0.00635, "epss_percentile": 0.69819}, "CVE-2018-7870": {"epss_score": 0.00664, "epss_percentile": 0.70648}, "CVE-2018-7871": {"epss_score": 0.00529, "epss_percentile": 0.66596}, "CVE-2018-7872": {"epss_score": 0.00664, "epss_percentile": 0.70648}, "CVE-2018-7873": {"epss_score": 0.01383, "epss_percentile": 0.79894}, "CVE-2018-7874": {"epss_score": 0.00551, "epss_percentile": 0.67364}, "CVE-2018-7875": {"epss_score": 0.00571, "epss_percentile": 0.67975}, "CVE-2018-7876": {"epss_score": 0.01379, "epss_percentile": 0.79853}, "CVE-2018-7877": {"epss_score": 0.00544, "epss_percentile": 0.67125}, "CVE-2018-7884": {"epss_score": 0.00141, "epss_percentile": 0.34945}, "CVE-2018-7886": {"epss_score": 0.00114, "epss_percentile": 0.30802}, "CVE-2018-7889": {"epss_score": 0.0332, "epss_percentile": 0.86907}, "CVE-2018-7890": {"epss_score": 0.86279, "epss_percentile": 0.99375}, "CVE-2018-7891": {"epss_score": 0.02682, "epss_percentile": 0.85419}, "CVE-2018-7893": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-7894": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-7899": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2018-7900": {"epss_score": 0.0018, "epss_percentile": 0.39879}, "CVE-2018-7901": {"epss_score": 0.00081, "epss_percentile": 0.24206}, "CVE-2018-7902": {"epss_score": 0.00128, "epss_percentile": 0.3295}, "CVE-2018-7903": {"epss_score": 0.00128, "epss_percentile": 0.3295}, "CVE-2018-7904": {"epss_score": 0.00128, "epss_percentile": 0.3295}, "CVE-2018-7906": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2018-7907": {"epss_score": 0.00106, "epss_percentile": 0.29423}, "CVE-2018-7910": {"epss_score": 0.0003, "epss_percentile": 0.08067}, "CVE-2018-7911": {"epss_score": 0.00027, "epss_percentile": 0.07205}, "CVE-2018-7920": {"epss_score": 0.00277, "epss_percentile": 0.50809}, "CVE-2018-7921": {"epss_score": 0.03544, "epss_percentile": 0.87321}, "CVE-2018-7922": {"epss_score": 0.00123, "epss_percentile": 0.32303}, "CVE-2018-7923": {"epss_score": 0.00123, "epss_percentile": 0.32303}, "CVE-2018-7924": {"epss_score": 0.00025, "epss_percentile": 0.0631}, "CVE-2018-7925": {"epss_score": 0.0003, "epss_percentile": 0.08216}, "CVE-2018-7926": {"epss_score": 0.00024, "epss_percentile": 0.06005}, "CVE-2018-7928": {"epss_score": 0.00058, "epss_percentile": 0.18434}, "CVE-2018-7929": {"epss_score": 0.00025, "epss_percentile": 0.0637}, "CVE-2018-7930": {"epss_score": 0.00045, "epss_percentile": 0.137}, "CVE-2018-7931": {"epss_score": 0.00119, "epss_percentile": 0.31629}, "CVE-2018-7932": {"epss_score": 0.00074, "epss_percentile": 0.22814}, "CVE-2018-7933": {"epss_score": 0.00219, "epss_percentile": 0.44529}, "CVE-2018-7934": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2018-7935": {"epss_score": 0.02181, "epss_percentile": 0.83902}, "CVE-2018-7936": {"epss_score": 0.00027, "epss_percentile": 0.07205}, "CVE-2018-7937": {"epss_score": 0.00068, "epss_percentile": 0.21309}, "CVE-2018-7938": {"epss_score": 0.00089, "epss_percentile": 0.25873}, "CVE-2018-7939": {"epss_score": 0.00027, "epss_percentile": 0.07205}, "CVE-2018-7940": {"epss_score": 0.00021, "epss_percentile": 0.04819}, "CVE-2018-7941": {"epss_score": 0.00077, "epss_percentile": 0.23469}, "CVE-2018-7942": {"epss_score": 0.00376, "epss_percentile": 0.58679}, "CVE-2018-7943": {"epss_score": 0.00262, "epss_percentile": 0.49402}, "CVE-2018-7944": {"epss_score": 0.00022, "epss_percentile": 0.05155}, "CVE-2018-7946": {"epss_score": 0.00029, "epss_percentile": 0.07766}, "CVE-2018-7947": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2018-7949": {"epss_score": 0.00197, "epss_percentile": 0.41859}, "CVE-2018-7950": {"epss_score": 0.00315, "epss_percentile": 0.54199}, "CVE-2018-7951": {"epss_score": 0.00315, "epss_percentile": 0.54199}, "CVE-2018-7956": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2018-7957": {"epss_score": 0.00022, "epss_percentile": 0.05041}, "CVE-2018-7958": {"epss_score": 0.00164, "epss_percentile": 0.3795}, "CVE-2018-7959": {"epss_score": 0.00061, "epss_percentile": 0.19484}, "CVE-2018-7960": {"epss_score": 0.00059, "epss_percentile": 0.18918}, "CVE-2018-7961": {"epss_score": 0.00159, "epss_percentile": 0.37392}, "CVE-2018-7976": {"epss_score": 0.00094, "epss_percentile": 0.26973}, "CVE-2018-7977": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2018-7987": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2018-7988": {"epss_score": 0.00024, "epss_percentile": 0.06005}, "CVE-2018-7989": {"epss_score": 0.00028, "epss_percentile": 0.0757}, "CVE-2018-7990": {"epss_score": 0.00027, "epss_percentile": 0.07205}, "CVE-2018-7991": {"epss_score": 0.00027, "epss_percentile": 0.07001}, "CVE-2018-7992": {"epss_score": 0.00077, "epss_percentile": 0.23411}, "CVE-2018-7993": {"epss_score": 0.00165, "epss_percentile": 0.38024}, "CVE-2018-7994": {"epss_score": 0.00281, "epss_percentile": 0.51134}, "CVE-2018-7995": {"epss_score": 0.00032, "epss_percentile": 0.08788}, "CVE-2018-7996": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-7997": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-7998": {"epss_score": 0.00346, "epss_percentile": 0.56653}, "CVE-2018-7999": {"epss_score": 0.00465, "epss_percentile": 0.63742}, "CVE-2018-8000": {"epss_score": 0.03337, "epss_percentile": 0.86937}, "CVE-2018-8001": {"epss_score": 0.00527, "epss_percentile": 0.66527}, "CVE-2018-8002": {"epss_score": 0.01945, "epss_percentile": 0.83001}, "CVE-2018-8003": {"epss_score": 0.01901, "epss_percentile": 0.82776}, "CVE-2018-8004": {"epss_score": 0.02594, "epss_percentile": 0.85189}, "CVE-2018-8005": {"epss_score": 0.06689, "epss_percentile": 0.90948}, "CVE-2018-8006": {"epss_score": 0.80061, "epss_percentile": 0.9907}, "CVE-2018-8007": {"epss_score": 0.23876, "epss_percentile": 0.95827}, "CVE-2018-8008": {"epss_score": 0.1535, "epss_percentile": 0.94414}, "CVE-2018-8009": {"epss_score": 0.10296, "epss_percentile": 0.92932}, "CVE-2018-8010": {"epss_score": 0.01708, "epss_percentile": 0.81865}, "CVE-2018-8011": {"epss_score": 0.54627, "epss_percentile": 0.97936}, "CVE-2018-8012": {"epss_score": 0.01372, "epss_percentile": 0.79814}, "CVE-2018-8013": {"epss_score": 0.01328, "epss_percentile": 0.79493}, "CVE-2018-8014": {"epss_score": 0.48785, "epss_percentile": 0.97654}, "CVE-2018-8015": {"epss_score": 0.04145, "epss_percentile": 0.88313}, "CVE-2018-8016": {"epss_score": 0.00642, "epss_percentile": 0.70022}, "CVE-2018-8017": {"epss_score": 0.03647, "epss_percentile": 0.87501}, "CVE-2018-8018": {"epss_score": 0.04675, "epss_percentile": 0.88991}, "CVE-2018-8019": {"epss_score": 0.00897, "epss_percentile": 0.7513}, "CVE-2018-8020": {"epss_score": 0.01582, "epss_percentile": 0.81141}, "CVE-2018-8021": {"epss_score": 0.78272, "epss_percentile": 0.98976}, "CVE-2018-8022": {"epss_score": 0.06136, "epss_percentile": 0.9051}, "CVE-2018-8023": {"epss_score": 0.00825, "epss_percentile": 0.73947}, "CVE-2018-8024": {"epss_score": 0.5025, "epss_percentile": 0.97728}, "CVE-2018-8025": {"epss_score": 0.00669, "epss_percentile": 0.70754}, "CVE-2018-8026": {"epss_score": 0.04341, "epss_percentile": 0.8857}, "CVE-2018-8027": {"epss_score": 0.02968, "epss_percentile": 0.8609}, "CVE-2018-8028": {"epss_score": 0.00137, "epss_percentile": 0.34217}, "CVE-2018-8029": {"epss_score": 0.02193, "epss_percentile": 0.83946}, "CVE-2018-8030": {"epss_score": 0.00906, "epss_percentile": 0.75248}, "CVE-2018-8031": {"epss_score": 0.02255, "epss_percentile": 0.84168}, "CVE-2018-8032": {"epss_score": 0.02343, "epss_percentile": 0.84443}, "CVE-2018-8033": {"epss_score": 0.92044, "epss_percentile": 0.99687}, "CVE-2018-8034": {"epss_score": 0.20786, "epss_percentile": 0.95411}, "CVE-2018-8035": {"epss_score": 0.03823, "epss_percentile": 0.87789}, "CVE-2018-8036": {"epss_score": 0.00568, "epss_percentile": 0.67892}, "CVE-2018-8037": {"epss_score": 0.08852, "epss_percentile": 0.92285}, "CVE-2018-8038": {"epss_score": 0.40655, "epss_percentile": 0.9723}, "CVE-2018-8039": {"epss_score": 0.02771, "epss_percentile": 0.85621}, "CVE-2018-8040": {"epss_score": 0.07825, "epss_percentile": 0.917}, "CVE-2018-8041": {"epss_score": 0.02474, "epss_percentile": 0.84854}, "CVE-2018-8042": {"epss_score": 0.00686, "epss_percentile": 0.71168}, "CVE-2018-8043": {"epss_score": 0.00081, "epss_percentile": 0.24338}, "CVE-2018-8044": {"epss_score": 0.00061, "epss_percentile": 0.19393}, "CVE-2018-8045": {"epss_score": 0.37232, "epss_percentile": 0.97028}, "CVE-2018-8046": {"epss_score": 0.00239, "epss_percentile": 0.46923}, "CVE-2018-8047": {"epss_score": 0.00317, "epss_percentile": 0.54337}, "CVE-2018-8048": {"epss_score": 0.00611, "epss_percentile": 0.69206}, "CVE-2018-8049": {"epss_score": 0.00777, "epss_percentile": 0.73108}, "CVE-2018-8050": {"epss_score": 0.01328, "epss_percentile": 0.79496}, "CVE-2018-8056": {"epss_score": 0.02945, "epss_percentile": 0.8604}, "CVE-2018-8057": {"epss_score": 0.06693, "epss_percentile": 0.90951}, "CVE-2018-8058": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-8059": {"epss_score": 0.00052, "epss_percentile": 0.16617}, "CVE-2018-8060": {"epss_score": 0.00798, "epss_percentile": 0.73517}, "CVE-2018-8061": {"epss_score": 0.00056, "epss_percentile": 0.17953}, "CVE-2018-8062": {"epss_score": 0.0018, "epss_percentile": 0.39908}, "CVE-2018-8065": {"epss_score": 0.77166, "epss_percentile": 0.98925}, "CVE-2018-8069": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-8070": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-8071": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-8072": {"epss_score": 0.00327, "epss_percentile": 0.55139}, "CVE-2018-8073": {"epss_score": 0.00911, "epss_percentile": 0.75329}, "CVE-2018-8074": {"epss_score": 0.00853, "epss_percentile": 0.74427}, "CVE-2018-8076": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2018-8078": {"epss_score": 0.00893, "epss_percentile": 0.75074}, "CVE-2018-8087": {"epss_score": 0.00044, "epss_percentile": 0.13472}, "CVE-2018-8088": {"epss_score": 0.00836, "epss_percentile": 0.74139}, "CVE-2018-8090": {"epss_score": 0.00444, "epss_percentile": 0.62846}, "CVE-2018-8092": {"epss_score": 0.00486, "epss_percentile": 0.64774}, "CVE-2018-8096": {"epss_score": 0.07421, "epss_percentile": 0.91466}, "CVE-2018-8097": {"epss_score": 0.19107, "epss_percentile": 0.9513}, "CVE-2018-8098": {"epss_score": 0.00741, "epss_percentile": 0.72442}, "CVE-2018-8099": {"epss_score": 0.00945, "epss_percentile": 0.75801}, "CVE-2018-8100": {"epss_score": 0.0022, "epss_percentile": 0.44623}, "CVE-2018-8101": {"epss_score": 0.00148, "epss_percentile": 0.3593}, "CVE-2018-8102": {"epss_score": 0.00148, "epss_percentile": 0.3593}, "CVE-2018-8103": {"epss_score": 0.00148, "epss_percentile": 0.3593}, "CVE-2018-8104": {"epss_score": 0.00148, "epss_percentile": 0.3593}, "CVE-2018-8105": {"epss_score": 0.00137, "epss_percentile": 0.3431}, "CVE-2018-8106": {"epss_score": 0.00137, "epss_percentile": 0.3431}, "CVE-2018-8107": {"epss_score": 0.00137, "epss_percentile": 0.3431}, "CVE-2018-8108": {"epss_score": 0.01433, "epss_percentile": 0.80256}, "CVE-2018-8110": {"epss_score": 0.45916, "epss_percentile": 0.97509}, "CVE-2018-8111": {"epss_score": 0.45916, "epss_percentile": 0.97509}, "CVE-2018-8112": {"epss_score": 0.02227, "epss_percentile": 0.84073}, "CVE-2018-8113": {"epss_score": 0.36985, "epss_percentile": 0.97012}, "CVE-2018-8114": {"epss_score": 0.172, "epss_percentile": 0.94798}, "CVE-2018-8115": {"epss_score": 0.05357, "epss_percentile": 0.8978}, "CVE-2018-8116": {"epss_score": 0.00369, "epss_percentile": 0.58231}, "CVE-2018-8117": {"epss_score": 0.00199, "epss_percentile": 0.42185}, "CVE-2018-8118": {"epss_score": 0.1505, "epss_percentile": 0.94351}, "CVE-2018-8119": {"epss_score": 0.01253, "epss_percentile": 0.78912}, "CVE-2018-8120": {"epss_score": 0.94149, "epss_percentile": 0.99909}, "CVE-2018-8121": {"epss_score": 0.00844, "epss_percentile": 0.74272}, "CVE-2018-8122": {"epss_score": 0.18322, "epss_percentile": 0.94994}, "CVE-2018-8123": {"epss_score": 0.11388, "epss_percentile": 0.93329}, "CVE-2018-8124": {"epss_score": 0.01203, "epss_percentile": 0.78497}, "CVE-2018-8125": {"epss_score": 0.53697, "epss_percentile": 0.97893}, "CVE-2018-8126": {"epss_score": 0.17816, "epss_percentile": 0.94912}, "CVE-2018-8127": {"epss_score": 0.04657, "epss_percentile": 0.88973}, "CVE-2018-8128": {"epss_score": 0.21715, "epss_percentile": 0.95551}, "CVE-2018-8129": {"epss_score": 0.017, "epss_percentile": 0.81826}, "CVE-2018-8130": {"epss_score": 0.27304, "epss_percentile": 0.96234}, "CVE-2018-8132": {"epss_score": 0.017, "epss_percentile": 0.81826}, "CVE-2018-8133": {"epss_score": 0.61153, "epss_percentile": 0.98237}, "CVE-2018-8134": {"epss_score": 0.09191, "epss_percentile": 0.9244}, "CVE-2018-8136": {"epss_score": 0.27952, "epss_percentile": 0.96299}, "CVE-2018-8137": {"epss_score": 0.21715, "epss_percentile": 0.95551}, "CVE-2018-8139": {"epss_score": 0.76997, "epss_percentile": 0.98915}, "CVE-2018-8140": {"epss_score": 0.01868, "epss_percentile": 0.82623}, "CVE-2018-8141": {"epss_score": 0.03404, "epss_percentile": 0.87071}, "CVE-2018-8142": {"epss_score": 0.00788, "epss_percentile": 0.73343}, "CVE-2018-8145": {"epss_score": 0.72098, "epss_percentile": 0.98695}, "CVE-2018-8147": {"epss_score": 0.3391, "epss_percentile": 0.96816}, "CVE-2018-8148": {"epss_score": 0.3391, "epss_percentile": 0.96816}, "CVE-2018-8149": {"epss_score": 0.01184, "epss_percentile": 0.78331}, "CVE-2018-8150": {"epss_score": 0.15266, "epss_percentile": 0.94394}, "CVE-2018-8151": {"epss_score": 0.09443, "epss_percentile": 0.92551}, "CVE-2018-8152": {"epss_score": 0.02379, "epss_percentile": 0.84562}, "CVE-2018-8153": {"epss_score": 0.0147, "epss_percentile": 0.80498}, "CVE-2018-8154": {"epss_score": 0.26565, "epss_percentile": 0.96158}, "CVE-2018-8155": {"epss_score": 0.01184, "epss_percentile": 0.78331}, "CVE-2018-8156": {"epss_score": 0.01184, "epss_percentile": 0.78331}, "CVE-2018-8157": {"epss_score": 0.3391, "epss_percentile": 0.96816}, "CVE-2018-8158": {"epss_score": 0.3391, "epss_percentile": 0.96816}, "CVE-2018-8159": {"epss_score": 0.02379, "epss_percentile": 0.84562}, "CVE-2018-8160": {"epss_score": 0.18311, "epss_percentile": 0.94992}, "CVE-2018-8161": {"epss_score": 0.32436, "epss_percentile": 0.967}, "CVE-2018-8162": {"epss_score": 0.3391, "epss_percentile": 0.96816}, "CVE-2018-8163": {"epss_score": 0.23479, "epss_percentile": 0.95784}, "CVE-2018-8164": {"epss_score": 0.00845, "epss_percentile": 0.7429}, "CVE-2018-8165": {"epss_score": 0.00714, "epss_percentile": 0.71806}, "CVE-2018-8166": {"epss_score": 0.00832, "epss_percentile": 0.74076}, "CVE-2018-8167": {"epss_score": 0.00394, "epss_percentile": 0.59799}, "CVE-2018-8168": {"epss_score": 0.013, "epss_percentile": 0.79287}, "CVE-2018-8169": {"epss_score": 0.01524, "epss_percentile": 0.80852}, "CVE-2018-8170": {"epss_score": 0.01078, "epss_percentile": 0.77351}, "CVE-2018-8171": {"epss_score": 0.16829, "epss_percentile": 0.94735}, "CVE-2018-8172": {"epss_score": 0.22056, "epss_percentile": 0.95589}, "CVE-2018-8173": {"epss_score": 0.3391, "epss_percentile": 0.96816}, "CVE-2018-8174": {"epss_score": 0.94283, "epss_percentile": 0.99934}, "CVE-2018-8175": {"epss_score": 0.17627, "epss_percentile": 0.94877}, "CVE-2018-8176": {"epss_score": 0.36403, "epss_percentile": 0.96977}, "CVE-2018-8177": {"epss_score": 0.20983, "epss_percentile": 0.95448}, "CVE-2018-8178": {"epss_score": 0.19503, "epss_percentile": 0.95194}, "CVE-2018-8179": {"epss_score": 0.28809, "epss_percentile": 0.96388}, "CVE-2018-8200": {"epss_score": 0.00995, "epss_percentile": 0.76436}, "CVE-2018-8201": {"epss_score": 0.01133, "epss_percentile": 0.7788}, "CVE-2018-8202": {"epss_score": 0.01073, "epss_percentile": 0.77294}, "CVE-2018-8204": {"epss_score": 0.00995, "epss_percentile": 0.76436}, "CVE-2018-8205": {"epss_score": 0.00485, "epss_percentile": 0.64715}, "CVE-2018-8206": {"epss_score": 0.15167, "epss_percentile": 0.94378}, "CVE-2018-8207": {"epss_score": 0.01413, "epss_percentile": 0.80119}, "CVE-2018-8208": {"epss_score": 0.4074, "epss_percentile": 0.97236}, "CVE-2018-8209": {"epss_score": 0.0295, "epss_percentile": 0.86051}, "CVE-2018-8210": {"epss_score": 0.09014, "epss_percentile": 0.92366}, "CVE-2018-8211": {"epss_score": 0.0116, "epss_percentile": 0.78138}, "CVE-2018-8212": {"epss_score": 0.0266, "epss_percentile": 0.85366}, "CVE-2018-8213": {"epss_score": 0.09168, "epss_percentile": 0.92429}, "CVE-2018-8214": {"epss_score": 0.46044, "epss_percentile": 0.97518}, "CVE-2018-8215": {"epss_score": 0.0116, "epss_percentile": 0.78138}, "CVE-2018-8216": {"epss_score": 0.0116, "epss_percentile": 0.78138}, "CVE-2018-8217": {"epss_score": 0.0116, "epss_percentile": 0.78138}, "CVE-2018-8218": {"epss_score": 0.02406, "epss_percentile": 0.84653}, "CVE-2018-8219": {"epss_score": 0.00624, "epss_percentile": 0.69575}, "CVE-2018-8221": {"epss_score": 0.0116, "epss_percentile": 0.78138}, "CVE-2018-8222": {"epss_score": 0.00396, "epss_percentile": 0.59862}, "CVE-2018-8224": {"epss_score": 0.01524, "epss_percentile": 0.80852}, "CVE-2018-8225": {"epss_score": 0.58248, "epss_percentile": 0.98103}, "CVE-2018-8226": {"epss_score": 0.11454, "epss_percentile": 0.93366}, "CVE-2018-8227": {"epss_score": 0.49183, "epss_percentile": 0.97673}, "CVE-2018-8229": {"epss_score": 0.8146, "epss_percentile": 0.9914}, "CVE-2018-8231": {"epss_score": 0.48777, "epss_percentile": 0.97654}, "CVE-2018-8232": {"epss_score": 0.00335, "epss_percentile": 0.55829}, "CVE-2018-8233": {"epss_score": 0.00792, "epss_percentile": 0.73416}, "CVE-2018-8234": {"epss_score": 0.11411, "epss_percentile": 0.93341}, "CVE-2018-8235": {"epss_score": 0.13594, "epss_percentile": 0.94006}, "CVE-2018-8236": {"epss_score": 0.45916, "epss_percentile": 0.97509}, "CVE-2018-8238": {"epss_score": 0.07077, "epss_percentile": 0.91233}, "CVE-2018-8239": {"epss_score": 0.6198, "epss_percentile": 0.9827}, "CVE-2018-8242": {"epss_score": 0.53697, "epss_percentile": 0.97893}, "CVE-2018-8243": {"epss_score": 0.42988, "epss_percentile": 0.97365}, "CVE-2018-8244": {"epss_score": 0.15093, "epss_percentile": 0.9436}, "CVE-2018-8245": {"epss_score": 0.39047, "epss_percentile": 0.97136}, "CVE-2018-8246": {"epss_score": 0.20464, "epss_percentile": 0.9535}, "CVE-2018-8247": {"epss_score": 0.02933, "epss_percentile": 0.8602}, "CVE-2018-8248": {"epss_score": 0.5207, "epss_percentile": 0.97806}, "CVE-2018-8249": {"epss_score": 0.49183, "epss_percentile": 0.97673}, "CVE-2018-8251": {"epss_score": 0.21304, "epss_percentile": 0.95498}, "CVE-2018-8252": {"epss_score": 0.03084, "epss_percentile": 0.86381}, "CVE-2018-8253": {"epss_score": 0.01143, "epss_percentile": 0.77982}, "CVE-2018-8254": {"epss_score": 0.03084, "epss_percentile": 0.86381}, "CVE-2018-8256": {"epss_score": 0.26626, "epss_percentile": 0.96163}, "CVE-2018-8260": {"epss_score": 0.56321, "epss_percentile": 0.98018}, "CVE-2018-8262": {"epss_score": 0.54322, "epss_percentile": 0.9792}, "CVE-2018-8265": {"epss_score": 0.17605, "epss_percentile": 0.94873}, "CVE-2018-8266": {"epss_score": 0.61216, "epss_percentile": 0.98239}, "CVE-2018-8267": {"epss_score": 0.48774, "epss_percentile": 0.97653}, "CVE-2018-8269": {"epss_score": 0.1693, "epss_percentile": 0.94749}, "CVE-2018-8271": {"epss_score": 0.0223, "epss_percentile": 0.84083}, "CVE-2018-8273": {"epss_score": 0.36025, "epss_percentile": 0.9695}, "CVE-2018-8274": {"epss_score": 0.54322, "epss_percentile": 0.9792}, "CVE-2018-8275": {"epss_score": 0.4944, "epss_percentile": 0.97686}, "CVE-2018-8276": {"epss_score": 0.19948, "epss_percentile": 0.95266}, "CVE-2018-8278": {"epss_score": 0.00644, "epss_percentile": 0.70069}, "CVE-2018-8279": {"epss_score": 0.85081, "epss_percentile": 0.99316}, "CVE-2018-8280": {"epss_score": 0.50499, "epss_percentile": 0.97739}, "CVE-2018-8281": {"epss_score": 0.52124, "epss_percentile": 0.97809}, "CVE-2018-8282": {"epss_score": 0.00436, "epss_percentile": 0.62457}, "CVE-2018-8283": {"epss_score": 0.41033, "epss_percentile": 0.9725}, "CVE-2018-8284": {"epss_score": 0.54218, "epss_percentile": 0.97915}, "CVE-2018-8286": {"epss_score": 0.28157, "epss_percentile": 0.96327}, "CVE-2018-8287": {"epss_score": 0.5496, "epss_percentile": 0.97954}, "CVE-2018-8288": {"epss_score": 0.83682, "epss_percentile": 0.99258}, "CVE-2018-8289": {"epss_score": 0.09271, "epss_percentile": 0.92476}, "CVE-2018-8290": {"epss_score": 0.28157, "epss_percentile": 0.96327}, "CVE-2018-8291": {"epss_score": 0.83682, "epss_percentile": 0.99258}, "CVE-2018-8292": {"epss_score": 0.05465, "epss_percentile": 0.89904}, "CVE-2018-8294": {"epss_score": 0.28157, "epss_percentile": 0.96327}, "CVE-2018-8296": {"epss_score": 0.43954, "epss_percentile": 0.97411}, "CVE-2018-8297": {"epss_score": 0.09271, "epss_percentile": 0.92476}, "CVE-2018-8298": {"epss_score": 0.90143, "epss_percentile": 0.99565}, "CVE-2018-8299": {"epss_score": 0.00822, "epss_percentile": 0.73912}, "CVE-2018-8300": {"epss_score": 0.25457, "epss_percentile": 0.96029}, "CVE-2018-8301": {"epss_score": 0.54322, "epss_percentile": 0.9792}, "CVE-2018-8302": {"epss_score": 0.4399, "epss_percentile": 0.97414}, "CVE-2018-8304": {"epss_score": 0.22515, "epss_percentile": 0.95647}, "CVE-2018-8305": {"epss_score": 0.20496, "epss_percentile": 0.95356}, "CVE-2018-8306": {"epss_score": 0.00853, "epss_percentile": 0.74426}, "CVE-2018-8307": {"epss_score": 0.03675, "epss_percentile": 0.87551}, "CVE-2018-8308": {"epss_score": 0.05849, "epss_percentile": 0.9026}, "CVE-2018-8309": {"epss_score": 0.0035, "epss_percentile": 0.5692}, "CVE-2018-8310": {"epss_score": 0.10914, "epss_percentile": 0.93155}, "CVE-2018-8311": {"epss_score": 0.35114, "epss_percentile": 0.96888}, "CVE-2018-8312": {"epss_score": 0.3587, "epss_percentile": 0.96939}, "CVE-2018-8313": {"epss_score": 0.0026, "epss_percentile": 0.4915}, "CVE-2018-8314": {"epss_score": 0.01207, "epss_percentile": 0.78529}, "CVE-2018-8315": {"epss_score": 0.01817, "epss_percentile": 0.82396}, "CVE-2018-8316": {"epss_score": 0.30663, "epss_percentile": 0.9656}, "CVE-2018-8319": {"epss_score": 0.14293, "epss_percentile": 0.94179}, "CVE-2018-8320": {"epss_score": 0.03377, "epss_percentile": 0.87023}, "CVE-2018-8323": {"epss_score": 0.00822, "epss_percentile": 0.73912}, "CVE-2018-8324": {"epss_score": 0.09271, "epss_percentile": 0.92476}, "CVE-2018-8325": {"epss_score": 0.09271, "epss_percentile": 0.92476}, "CVE-2018-8326": {"epss_score": 0.00822, "epss_percentile": 0.73912}, "CVE-2018-8327": {"epss_score": 0.2537, "epss_percentile": 0.96021}, "CVE-2018-8329": {"epss_score": 0.00397, "epss_percentile": 0.60047}, "CVE-2018-8330": {"epss_score": 0.03026, "epss_percentile": 0.86239}, "CVE-2018-8331": {"epss_score": 0.28958, "epss_percentile": 0.96405}, "CVE-2018-8332": {"epss_score": 0.31895, "epss_percentile": 0.96657}, "CVE-2018-8333": {"epss_score": 0.0114, "epss_percentile": 0.7795}, "CVE-2018-8335": {"epss_score": 0.14372, "epss_percentile": 0.94196}, "CVE-2018-8336": {"epss_score": 0.02581, "epss_percentile": 0.85154}, "CVE-2018-8337": {"epss_score": 0.0048, "epss_percentile": 0.64476}, "CVE-2018-8339": {"epss_score": 0.00458, "epss_percentile": 0.63444}, "CVE-2018-8340": {"epss_score": 0.14518, "epss_percentile": 0.94228}, "CVE-2018-8341": {"epss_score": 0.02634, "epss_percentile": 0.85288}, "CVE-2018-8342": {"epss_score": 0.00619, "epss_percentile": 0.69433}, "CVE-2018-8343": {"epss_score": 0.00619, "epss_percentile": 0.69433}, "CVE-2018-8344": {"epss_score": 0.3207, "epss_percentile": 0.9667}, "CVE-2018-8345": {"epss_score": 0.2914, "epss_percentile": 0.9642}, "CVE-2018-8346": {"epss_score": 0.35708, "epss_percentile": 0.96927}, "CVE-2018-8347": {"epss_score": 0.00334, "epss_percentile": 0.55707}, "CVE-2018-8348": {"epss_score": 0.02634, "epss_percentile": 0.85288}, "CVE-2018-8349": {"epss_score": 0.26497, "epss_percentile": 0.96151}, "CVE-2018-8350": {"epss_score": 0.32455, "epss_percentile": 0.96701}, "CVE-2018-8351": {"epss_score": 0.17379, "epss_percentile": 0.94842}, "CVE-2018-8353": {"epss_score": 0.81818, "epss_percentile": 0.99159}, "CVE-2018-8354": {"epss_score": 0.1776, "epss_percentile": 0.94901}, "CVE-2018-8355": {"epss_score": 0.80106, "epss_percentile": 0.99071}, "CVE-2018-8356": {"epss_score": 0.00686, "epss_percentile": 0.71158}, "CVE-2018-8357": {"epss_score": 0.08567, "epss_percentile": 0.92128}, "CVE-2018-8358": {"epss_score": 0.11506, "epss_percentile": 0.93386}, "CVE-2018-8359": {"epss_score": 0.22506, "epss_percentile": 0.95645}, "CVE-2018-8360": {"epss_score": 0.09745, "epss_percentile": 0.92688}, "CVE-2018-8366": {"epss_score": 0.05563, "epss_percentile": 0.89999}, "CVE-2018-8367": {"epss_score": 0.1776, "epss_percentile": 0.94901}, "CVE-2018-8370": {"epss_score": 0.09979, "epss_percentile": 0.928}, "CVE-2018-8371": {"epss_score": 0.22506, "epss_percentile": 0.95645}, "CVE-2018-8372": {"epss_score": 0.56253, "epss_percentile": 0.98014}, "CVE-2018-8373": {"epss_score": 0.82417, "epss_percentile": 0.99193}, "CVE-2018-8374": {"epss_score": 0.02489, "epss_percentile": 0.84893}, "CVE-2018-8375": {"epss_score": 0.34597, "epss_percentile": 0.9686}, "CVE-2018-8376": {"epss_score": 0.32455, "epss_percentile": 0.96701}, "CVE-2018-8377": {"epss_score": 0.15416, "epss_percentile": 0.94427}, "CVE-2018-8378": {"epss_score": 0.2694, "epss_percentile": 0.96194}, "CVE-2018-8379": {"epss_score": 0.32803, "epss_percentile": 0.96726}, "CVE-2018-8380": {"epss_score": 0.17483, "epss_percentile": 0.94856}, "CVE-2018-8381": {"epss_score": 0.17483, "epss_percentile": 0.94856}, "CVE-2018-8382": {"epss_score": 0.21048, "epss_percentile": 0.95457}, "CVE-2018-8383": {"epss_score": 0.03564, "epss_percentile": 0.87359}, "CVE-2018-8384": {"epss_score": 0.83017, "epss_percentile": 0.99226}, "CVE-2018-8385": {"epss_score": 0.18752, "epss_percentile": 0.95064}, "CVE-2018-8387": {"epss_score": 0.15416, "epss_percentile": 0.94427}, "CVE-2018-8388": {"epss_score": 0.02071, "epss_percentile": 0.8348}, "CVE-2018-8389": {"epss_score": 0.57155, "epss_percentile": 0.98051}, "CVE-2018-8390": {"epss_score": 0.22506, "epss_percentile": 0.95645}, "CVE-2018-8391": {"epss_score": 0.1237, "epss_percentile": 0.93652}, "CVE-2018-8392": {"epss_score": 0.25893, "epss_percentile": 0.96091}, "CVE-2018-8393": {"epss_score": 0.25893, "epss_percentile": 0.96091}, "CVE-2018-8394": {"epss_score": 0.25038, "epss_percentile": 0.95982}, "CVE-2018-8396": {"epss_score": 0.02947, "epss_percentile": 0.86043}, "CVE-2018-8397": {"epss_score": 0.38544, "epss_percentile": 0.97104}, "CVE-2018-8398": {"epss_score": 0.25038, "epss_percentile": 0.95982}, "CVE-2018-8399": {"epss_score": 0.02363, "epss_percentile": 0.84505}, "CVE-2018-8400": {"epss_score": 0.00821, "epss_percentile": 0.73909}, "CVE-2018-8401": {"epss_score": 0.00821, "epss_percentile": 0.73909}, "CVE-2018-8403": {"epss_score": 0.19945, "epss_percentile": 0.95264}, "CVE-2018-8404": {"epss_score": 0.00955, "epss_percentile": 0.75911}, "CVE-2018-8405": {"epss_score": 0.4999, "epss_percentile": 0.97713}, "CVE-2018-8406": {"epss_score": 0.4999, "epss_percentile": 0.97713}, "CVE-2018-8407": {"epss_score": 0.01205, "epss_percentile": 0.78511}, "CVE-2018-8408": {"epss_score": 0.01205, "epss_percentile": 0.78511}, "CVE-2018-8409": {"epss_score": 0.14749, "epss_percentile": 0.94273}, "CVE-2018-8410": {"epss_score": 0.31862, "epss_percentile": 0.96656}, "CVE-2018-8411": {"epss_score": 0.0855, "epss_percentile": 0.92119}, "CVE-2018-8412": {"epss_score": 0.0106, "epss_percentile": 0.7717}, "CVE-2018-8413": {"epss_score": 0.53539, "epss_percentile": 0.9788}, "CVE-2018-8414": {"epss_score": 0.8793, "epss_percentile": 0.9945}, "CVE-2018-8415": {"epss_score": 0.00403, "epss_percentile": 0.6032}, "CVE-2018-8416": {"epss_score": 0.06577, "epss_percentile": 0.90858}, "CVE-2018-8417": {"epss_score": 0.00421, "epss_percentile": 0.61493}, "CVE-2018-8419": {"epss_score": 0.00997, "epss_percentile": 0.7646}, "CVE-2018-8420": {"epss_score": 0.54233, "epss_percentile": 0.97916}, "CVE-2018-8421": {"epss_score": 0.49695, "epss_percentile": 0.977}, "CVE-2018-8422": {"epss_score": 0.25321, "epss_percentile": 0.96013}, "CVE-2018-8423": {"epss_score": 0.56981, "epss_percentile": 0.98042}, "CVE-2018-8424": {"epss_score": 0.22114, "epss_percentile": 0.95596}, "CVE-2018-8425": {"epss_score": 0.01535, "epss_percentile": 0.80909}, "CVE-2018-8426": {"epss_score": 0.00642, "epss_percentile": 0.70034}, "CVE-2018-8427": {"epss_score": 0.04231, "epss_percentile": 0.88424}, "CVE-2018-8428": {"epss_score": 0.01209, "epss_percentile": 0.78537}, "CVE-2018-8429": {"epss_score": 0.22597, "epss_percentile": 0.95655}, "CVE-2018-8430": {"epss_score": 0.28958, "epss_percentile": 0.96405}, "CVE-2018-8431": {"epss_score": 0.0076, "epss_percentile": 0.72817}, "CVE-2018-8432": {"epss_score": 0.23487, "epss_percentile": 0.95785}, "CVE-2018-8433": {"epss_score": 0.01916, "epss_percentile": 0.82856}, "CVE-2018-8434": {"epss_score": 0.01426, "epss_percentile": 0.80203}, "CVE-2018-8435": {"epss_score": 0.00655, "epss_percentile": 0.70364}, "CVE-2018-8436": {"epss_score": 0.00354, "epss_percentile": 0.57221}, "CVE-2018-8437": {"epss_score": 0.00354, "epss_percentile": 0.57221}, "CVE-2018-8438": {"epss_score": 0.00876, "epss_percentile": 0.74792}, "CVE-2018-8439": {"epss_score": 0.00578, "epss_percentile": 0.68177}, "CVE-2018-8440": {"epss_score": 0.75484, "epss_percentile": 0.98848}, "CVE-2018-8441": {"epss_score": 0.01025, "epss_percentile": 0.76785}, "CVE-2018-8442": {"epss_score": 0.02581, "epss_percentile": 0.85154}, "CVE-2018-8443": {"epss_score": 0.02581, "epss_percentile": 0.85154}, "CVE-2018-8444": {"epss_score": 0.09126, "epss_percentile": 0.92412}, "CVE-2018-8445": {"epss_score": 0.03634, "epss_percentile": 0.87477}, "CVE-2018-8446": {"epss_score": 0.02581, "epss_percentile": 0.85154}, "CVE-2018-8447": {"epss_score": 0.14606, "epss_percentile": 0.94249}, "CVE-2018-8448": {"epss_score": 0.00997, "epss_percentile": 0.76456}, "CVE-2018-8449": {"epss_score": 0.03022, "epss_percentile": 0.86228}, "CVE-2018-8450": {"epss_score": 0.2455, "epss_percentile": 0.95932}, "CVE-2018-8452": {"epss_score": 0.07007, "epss_percentile": 0.91181}, "CVE-2018-8453": {"epss_score": 0.78157, "epss_percentile": 0.9897}, "CVE-2018-8454": {"epss_score": 0.04231, "epss_percentile": 0.88424}, "CVE-2018-8455": {"epss_score": 0.00411, "epss_percentile": 0.609}, "CVE-2018-8456": {"epss_score": 0.1776, "epss_percentile": 0.94901}, "CVE-2018-8457": {"epss_score": 0.13387, "epss_percentile": 0.93949}, "CVE-2018-8459": {"epss_score": 0.1776, "epss_percentile": 0.94901}, "CVE-2018-8460": {"epss_score": 0.16897, "epss_percentile": 0.94744}, "CVE-2018-8461": {"epss_score": 0.18909, "epss_percentile": 0.95095}, "CVE-2018-8462": {"epss_score": 0.00537, "epss_percentile": 0.66914}, "CVE-2018-8463": {"epss_score": 0.17641, "epss_percentile": 0.94883}, "CVE-2018-8464": {"epss_score": 0.82168, "epss_percentile": 0.99177}, "CVE-2018-8465": {"epss_score": 0.1776, "epss_percentile": 0.94901}, "CVE-2018-8466": {"epss_score": 0.77602, "epss_percentile": 0.98942}, "CVE-2018-8467": {"epss_score": 0.79871, "epss_percentile": 0.99059}, "CVE-2018-8468": {"epss_score": 0.07843, "epss_percentile": 0.91716}, "CVE-2018-8469": {"epss_score": 0.17641, "epss_percentile": 0.94883}, "CVE-2018-8470": {"epss_score": 0.00627, "epss_percentile": 0.69629}, "CVE-2018-8471": {"epss_score": 0.00615, "epss_percentile": 0.69304}, "CVE-2018-8472": {"epss_score": 0.00782, "epss_percentile": 0.73208}, "CVE-2018-8473": {"epss_score": 0.13005, "epss_percentile": 0.93844}, "CVE-2018-8474": {"epss_score": 0.24441, "epss_percentile": 0.95921}, "CVE-2018-8475": {"epss_score": 0.3074, "epss_percentile": 0.96564}, "CVE-2018-8476": {"epss_score": 0.51789, "epss_percentile": 0.97798}, "CVE-2018-8477": {"epss_score": 0.00412, "epss_percentile": 0.6095}, "CVE-2018-8479": {"epss_score": 0.01733, "epss_percentile": 0.82}, "CVE-2018-8480": {"epss_score": 0.00473, "epss_percentile": 0.64101}, "CVE-2018-8481": {"epss_score": 0.04175, "epss_percentile": 0.88351}, "CVE-2018-8482": {"epss_score": 0.04175, "epss_percentile": 0.88351}, "CVE-2018-8484": {"epss_score": 0.00615, "epss_percentile": 0.69304}, "CVE-2018-8485": {"epss_score": 0.00644, "epss_percentile": 0.70073}, "CVE-2018-8486": {"epss_score": 0.01113, "epss_percentile": 0.77691}, "CVE-2018-8488": {"epss_score": 0.00473, "epss_percentile": 0.64101}, "CVE-2018-8489": {"epss_score": 0.0056, "epss_percentile": 0.67654}, "CVE-2018-8490": {"epss_score": 0.00585, "epss_percentile": 0.6841}, "CVE-2018-8491": {"epss_score": 0.13005, "epss_percentile": 0.93844}, "CVE-2018-8492": {"epss_score": 0.00261, "epss_percentile": 0.4929}, "CVE-2018-8493": {"epss_score": 0.10428, "epss_percentile": 0.92985}, "CVE-2018-8494": {"epss_score": 0.36, "epss_percentile": 0.96946}, "CVE-2018-8495": {"epss_score": 0.62808, "epss_percentile": 0.98308}, "CVE-2018-8497": {"epss_score": 0.00229, "epss_percentile": 0.45607}, "CVE-2018-8498": {"epss_score": 0.00473, "epss_percentile": 0.64101}, "CVE-2018-8500": {"epss_score": 0.22754, "epss_percentile": 0.95677}, "CVE-2018-8501": {"epss_score": 0.26322, "epss_percentile": 0.96137}, "CVE-2018-8502": {"epss_score": 0.25818, "epss_percentile": 0.96075}, "CVE-2018-8503": {"epss_score": 0.13005, "epss_percentile": 0.93844}, "CVE-2018-8504": {"epss_score": 0.2307, "epss_percentile": 0.95729}, "CVE-2018-8505": {"epss_score": 0.13005, "epss_percentile": 0.93844}, "CVE-2018-8506": {"epss_score": 0.18891, "epss_percentile": 0.95087}, "CVE-2018-8509": {"epss_score": 0.13005, "epss_percentile": 0.93844}, "CVE-2018-8510": {"epss_score": 0.13005, "epss_percentile": 0.93844}, "CVE-2018-8511": {"epss_score": 0.13005, "epss_percentile": 0.93844}, "CVE-2018-8512": {"epss_score": 0.01238, "epss_percentile": 0.78783}, "CVE-2018-8513": {"epss_score": 0.13005, "epss_percentile": 0.93844}, "CVE-2018-8514": {"epss_score": 0.01034, "epss_percentile": 0.76893}, "CVE-2018-8517": {"epss_score": 0.1398, "epss_percentile": 0.94105}, "CVE-2018-8518": {"epss_score": 0.00386, "epss_percentile": 0.59236}, "CVE-2018-8522": {"epss_score": 0.2472, "epss_percentile": 0.95949}, "CVE-2018-8524": {"epss_score": 0.24873, "epss_percentile": 0.95962}, "CVE-2018-8527": {"epss_score": 0.54788, "epss_percentile": 0.97945}, "CVE-2018-8529": {"epss_score": 0.35738, "epss_percentile": 0.96929}, "CVE-2018-8530": {"epss_score": 0.05796, "epss_percentile": 0.90218}, "CVE-2018-8531": {"epss_score": 0.1868, "epss_percentile": 0.95051}, "CVE-2018-8532": {"epss_score": 0.54788, "epss_percentile": 0.97945}, "CVE-2018-8533": {"epss_score": 0.54788, "epss_percentile": 0.97945}, "CVE-2018-8539": {"epss_score": 0.27738, "epss_percentile": 0.96278}, "CVE-2018-8540": {"epss_score": 0.19415, "epss_percentile": 0.95178}, "CVE-2018-8541": {"epss_score": 0.09765, "epss_percentile": 0.92694}, "CVE-2018-8542": {"epss_score": 0.09841, "epss_percentile": 0.92729}, "CVE-2018-8543": {"epss_score": 0.09841, "epss_percentile": 0.92729}, "CVE-2018-8544": {"epss_score": 0.72861, "epss_percentile": 0.98727}, "CVE-2018-8545": {"epss_score": 0.06705, "epss_percentile": 0.90958}, "CVE-2018-8546": {"epss_score": 0.10666, "epss_percentile": 0.93063}, "CVE-2018-8547": {"epss_score": 0.00787, "epss_percentile": 0.73301}, "CVE-2018-8549": {"epss_score": 0.00325, "epss_percentile": 0.54982}, "CVE-2018-8550": {"epss_score": 0.11772, "epss_percentile": 0.93469}, "CVE-2018-8551": {"epss_score": 0.09841, "epss_percentile": 0.92729}, "CVE-2018-8552": {"epss_score": 0.614, "epss_percentile": 0.98245}, "CVE-2018-8553": {"epss_score": 0.24873, "epss_percentile": 0.95962}, "CVE-2018-8554": {"epss_score": 0.00628, "epss_percentile": 0.69662}, "CVE-2018-8555": {"epss_score": 0.09841, "epss_percentile": 0.92729}, "CVE-2018-8556": {"epss_score": 0.09841, "epss_percentile": 0.92729}, "CVE-2018-8557": {"epss_score": 0.09841, "epss_percentile": 0.92729}, "CVE-2018-8558": {"epss_score": 0.12038, "epss_percentile": 0.93552}, "CVE-2018-8561": {"epss_score": 0.00644, "epss_percentile": 0.70073}, "CVE-2018-8562": {"epss_score": 0.00566, "epss_percentile": 0.67808}, "CVE-2018-8563": {"epss_score": 0.00952, "epss_percentile": 0.75879}, "CVE-2018-8564": {"epss_score": 0.03836, "epss_percentile": 0.87823}, "CVE-2018-8565": {"epss_score": 0.02204, "epss_percentile": 0.83998}, "CVE-2018-8566": {"epss_score": 0.00181, "epss_percentile": 0.40058}, "CVE-2018-8567": {"epss_score": 0.01238, "epss_percentile": 0.78783}, "CVE-2018-8568": {"epss_score": 0.00457, "epss_percentile": 0.63367}, "CVE-2018-8569": {"epss_score": 0.1999, "epss_percentile": 0.95271}, "CVE-2018-8570": {"epss_score": 0.09841, "epss_percentile": 0.92729}, "CVE-2018-8572": {"epss_score": 0.00787, "epss_percentile": 0.73301}, "CVE-2018-8573": {"epss_score": 0.24873, "epss_percentile": 0.95962}, "CVE-2018-8574": {"epss_score": 0.24873, "epss_percentile": 0.95962}, "CVE-2018-8575": {"epss_score": 0.2472, "epss_percentile": 0.95949}, "CVE-2018-8576": {"epss_score": 0.24873, "epss_percentile": 0.95962}, "CVE-2018-8577": {"epss_score": 0.24873, "epss_percentile": 0.95962}, "CVE-2018-8578": {"epss_score": 0.04306, "epss_percentile": 0.88522}, "CVE-2018-8579": {"epss_score": 0.11736, "epss_percentile": 0.93462}, "CVE-2018-8580": {"epss_score": 0.0838, "epss_percentile": 0.92018}, "CVE-2018-8581": {"epss_score": 0.915, "epss_percentile": 0.99648}, "CVE-2018-8582": {"epss_score": 0.26277, "epss_percentile": 0.96133}, "CVE-2018-8583": {"epss_score": 0.07986, "epss_percentile": 0.91805}, "CVE-2018-8584": {"epss_score": 0.04122, "epss_percentile": 0.88284}, "CVE-2018-8587": {"epss_score": 0.46758, "epss_percentile": 0.97557}, "CVE-2018-8588": {"epss_score": 0.09841, "epss_percentile": 0.92729}, "CVE-2018-8589": {"epss_score": 0.46257, "epss_percentile": 0.97539}, "CVE-2018-8592": {"epss_score": 0.0094, "epss_percentile": 0.75729}, "CVE-2018-8595": {"epss_score": 0.2445, "epss_percentile": 0.95923}, "CVE-2018-8596": {"epss_score": 0.27405, "epss_percentile": 0.96243}, "CVE-2018-8597": {"epss_score": 0.31336, "epss_percentile": 0.96613}, "CVE-2018-8598": {"epss_score": 0.09197, "epss_percentile": 0.92444}, "CVE-2018-8599": {"epss_score": 0.00362, "epss_percentile": 0.57761}, "CVE-2018-8600": {"epss_score": 0.00851, "epss_percentile": 0.74399}, "CVE-2018-8602": {"epss_score": 0.00813, "epss_percentile": 0.73755}, "CVE-2018-8604": {"epss_score": 0.03652, "epss_percentile": 0.8751}, "CVE-2018-8605": {"epss_score": 0.00765, "epss_percentile": 0.72919}, "CVE-2018-8606": {"epss_score": 0.00765, "epss_percentile": 0.72919}, "CVE-2018-8607": {"epss_score": 0.00765, "epss_percentile": 0.72919}, "CVE-2018-8608": {"epss_score": 0.00765, "epss_percentile": 0.72919}, "CVE-2018-8609": {"epss_score": 0.3099, "epss_percentile": 0.9658}, "CVE-2018-8611": {"epss_score": 0.16358, "epss_percentile": 0.94635}, "CVE-2018-8612": {"epss_score": 0.00399, "epss_percentile": 0.60093}, "CVE-2018-8617": {"epss_score": 0.8983, "epss_percentile": 0.99545}, "CVE-2018-8618": {"epss_score": 0.07986, "epss_percentile": 0.91805}, "CVE-2018-8619": {"epss_score": 0.5832, "epss_percentile": 0.98109}, "CVE-2018-8621": {"epss_score": 0.00546, "epss_percentile": 0.67222}, "CVE-2018-8622": {"epss_score": 0.01004, "epss_percentile": 0.76529}, "CVE-2018-8624": {"epss_score": 0.12632, "epss_percentile": 0.93735}, "CVE-2018-8625": {"epss_score": 0.59423, "epss_percentile": 0.98163}, "CVE-2018-8626": {"epss_score": 0.27555, "epss_percentile": 0.96259}, "CVE-2018-8627": {"epss_score": 0.25107, "epss_percentile": 0.95986}, "CVE-2018-8628": {"epss_score": 0.34534, "epss_percentile": 0.96854}, "CVE-2018-8629": {"epss_score": 0.44915, "epss_percentile": 0.9746}, "CVE-2018-8631": {"epss_score": 0.83265, "epss_percentile": 0.9924}, "CVE-2018-8634": {"epss_score": 0.32912, "epss_percentile": 0.96735}, "CVE-2018-8635": {"epss_score": 0.1972, "epss_percentile": 0.95231}, "CVE-2018-8636": {"epss_score": 0.31336, "epss_percentile": 0.96613}, "CVE-2018-8637": {"epss_score": 0.01004, "epss_percentile": 0.76529}, "CVE-2018-8638": {"epss_score": 0.01004, "epss_percentile": 0.76529}, "CVE-2018-8639": {"epss_score": 0.34334, "epss_percentile": 0.96843}, "CVE-2018-8641": {"epss_score": 0.00397, "epss_percentile": 0.60047}, "CVE-2018-8643": {"epss_score": 0.09408, "epss_percentile": 0.92535}, "CVE-2018-8649": {"epss_score": 0.00326, "epss_percentile": 0.55085}, "CVE-2018-8650": {"epss_score": 0.00893, "epss_percentile": 0.75071}, "CVE-2018-8651": {"epss_score": 0.00868, "epss_percentile": 0.74679}, "CVE-2018-8652": {"epss_score": 0.00793, "epss_percentile": 0.73435}, "CVE-2018-8653": {"epss_score": 0.22985, "epss_percentile": 0.95713}, "CVE-2018-8654": {"epss_score": 0.06625, "epss_percentile": 0.90899}, "CVE-2018-8710": {"epss_score": 0.28903, "epss_percentile": 0.96399}, "CVE-2018-8711": {"epss_score": 0.01119, "epss_percentile": 0.77754}, "CVE-2018-8712": {"epss_score": 0.00788, "epss_percentile": 0.7334}, "CVE-2018-8714": {"epss_score": 0.00134, "epss_percentile": 0.33755}, "CVE-2018-8715": {"epss_score": 0.92326, "epss_percentile": 0.99708}, "CVE-2018-8716": {"epss_score": 0.00956, "epss_percentile": 0.75922}, "CVE-2018-8717": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2018-8718": {"epss_score": 0.00739, "epss_percentile": 0.72358}, "CVE-2018-8719": {"epss_score": 0.1532, "epss_percentile": 0.94408}, "CVE-2018-8720": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2018-8721": {"epss_score": 0.01454, "epss_percentile": 0.80383}, "CVE-2018-8722": {"epss_score": 0.01874, "epss_percentile": 0.82648}, "CVE-2018-8724": {"epss_score": 0.00056, "epss_percentile": 0.1795}, "CVE-2018-8725": {"epss_score": 0.00098, "epss_percentile": 0.27795}, "CVE-2018-8726": {"epss_score": 0.00098, "epss_percentile": 0.27795}, "CVE-2018-8727": {"epss_score": 0.52255, "epss_percentile": 0.97815}, "CVE-2018-8728": {"epss_score": 0.00264, "epss_percentile": 0.49728}, "CVE-2018-8729": {"epss_score": 0.03257, "epss_percentile": 0.86765}, "CVE-2018-8732": {"epss_score": 0.00168, "epss_percentile": 0.38438}, "CVE-2018-8733": {"epss_score": 0.77102, "epss_percentile": 0.98921}, "CVE-2018-8734": {"epss_score": 0.79015, "epss_percentile": 0.99015}, "CVE-2018-8735": {"epss_score": 0.72459, "epss_percentile": 0.98712}, "CVE-2018-8736": {"epss_score": 0.64608, "epss_percentile": 0.98386}, "CVE-2018-8737": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-8738": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-8739": {"epss_score": 0.00445, "epss_percentile": 0.62866}, "CVE-2018-8740": {"epss_score": 0.12221, "epss_percentile": 0.93606}, "CVE-2018-8741": {"epss_score": 0.01736, "epss_percentile": 0.82017}, "CVE-2018-8753": {"epss_score": 0.00359, "epss_percentile": 0.57543}, "CVE-2018-8754": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2018-8755": {"epss_score": 0.00305, "epss_percentile": 0.53383}, "CVE-2018-8756": {"epss_score": 0.03025, "epss_percentile": 0.86237}, "CVE-2018-8761": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2018-8763": {"epss_score": 0.00447, "epss_percentile": 0.62979}, "CVE-2018-8764": {"epss_score": 0.00356, "epss_percentile": 0.57326}, "CVE-2018-8765": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8766": {"epss_score": 0.02516, "epss_percentile": 0.84984}, "CVE-2018-8767": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-8768": {"epss_score": 0.0012, "epss_percentile": 0.31721}, "CVE-2018-8769": {"epss_score": 0.00168, "epss_percentile": 0.38503}, "CVE-2018-8770": {"epss_score": 0.58047, "epss_percentile": 0.98097}, "CVE-2018-8772": {"epss_score": 0.00362, "epss_percentile": 0.57772}, "CVE-2018-8777": {"epss_score": 0.01729, "epss_percentile": 0.81977}, "CVE-2018-8778": {"epss_score": 0.00497, "epss_percentile": 0.6519}, "CVE-2018-8779": {"epss_score": 0.0119, "epss_percentile": 0.78374}, "CVE-2018-8780": {"epss_score": 0.01246, "epss_percentile": 0.78848}, "CVE-2018-8781": {"epss_score": 0.00101, "epss_percentile": 0.28629}, "CVE-2018-8784": {"epss_score": 0.13, "epss_percentile": 0.9384}, "CVE-2018-8785": {"epss_score": 0.13, "epss_percentile": 0.9384}, "CVE-2018-8786": {"epss_score": 0.17754, "epss_percentile": 0.94899}, "CVE-2018-8787": {"epss_score": 0.12733, "epss_percentile": 0.93761}, "CVE-2018-8788": {"epss_score": 0.07228, "epss_percentile": 0.91335}, "CVE-2018-8789": {"epss_score": 0.01654, "epss_percentile": 0.81584}, "CVE-2018-8790": {"epss_score": 0.00062, "epss_percentile": 0.19776}, "CVE-2018-8791": {"epss_score": 0.00703, "epss_percentile": 0.71547}, "CVE-2018-8792": {"epss_score": 0.0075, "epss_percentile": 0.72615}, "CVE-2018-8793": {"epss_score": 0.07955, "epss_percentile": 0.91788}, "CVE-2018-8794": {"epss_score": 0.05959, "epss_percentile": 0.90365}, "CVE-2018-8795": {"epss_score": 0.06669, "epss_percentile": 0.90931}, "CVE-2018-8796": {"epss_score": 0.00574, "epss_percentile": 0.68092}, "CVE-2018-8797": {"epss_score": 0.06669, "epss_percentile": 0.90931}, "CVE-2018-8798": {"epss_score": 0.00539, "epss_percentile": 0.66964}, "CVE-2018-8799": {"epss_score": 0.00574, "epss_percentile": 0.68092}, "CVE-2018-8800": {"epss_score": 0.06669, "epss_percentile": 0.90931}, "CVE-2018-8801": {"epss_score": 0.00175, "epss_percentile": 0.39353}, "CVE-2018-8802": {"epss_score": 0.00528, "epss_percentile": 0.66543}, "CVE-2018-8804": {"epss_score": 0.00426, "epss_percentile": 0.61754}, "CVE-2018-8805": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-8806": {"epss_score": 0.00421, "epss_percentile": 0.61498}, "CVE-2018-8807": {"epss_score": 0.00421, "epss_percentile": 0.61498}, "CVE-2018-8808": {"epss_score": 0.00226, "epss_percentile": 0.45309}, "CVE-2018-8809": {"epss_score": 0.00226, "epss_percentile": 0.45309}, "CVE-2018-8810": {"epss_score": 0.00226, "epss_percentile": 0.45309}, "CVE-2018-8811": {"epss_score": 0.00209, "epss_percentile": 0.43424}, "CVE-2018-8813": {"epss_score": 0.01443, "epss_percentile": 0.80314}, "CVE-2018-8814": {"epss_score": 0.00196, "epss_percentile": 0.41741}, "CVE-2018-8815": {"epss_score": 0.00194, "epss_percentile": 0.41539}, "CVE-2018-8817": {"epss_score": 0.00427, "epss_percentile": 0.61772}, "CVE-2018-8819": {"epss_score": 0.01471, "epss_percentile": 0.80507}, "CVE-2018-8820": {"epss_score": 0.10513, "epss_percentile": 0.93015}, "CVE-2018-8821": {"epss_score": 0.00295, "epss_percentile": 0.52455}, "CVE-2018-8822": {"epss_score": 0.00049, "epss_percentile": 0.15509}, "CVE-2018-8823": {"epss_score": 0.90063, "epss_percentile": 0.99559}, "CVE-2018-8824": {"epss_score": 0.00585, "epss_percentile": 0.68415}, "CVE-2018-8825": {"epss_score": 0.00245, "epss_percentile": 0.47673}, "CVE-2018-8826": {"epss_score": 0.05548, "epss_percentile": 0.89983}, "CVE-2018-8827": {"epss_score": 0.01896, "epss_percentile": 0.82754}, "CVE-2018-8828": {"epss_score": 0.03292, "epss_percentile": 0.86839}, "CVE-2018-8831": {"epss_score": 0.14156, "epss_percentile": 0.94146}, "CVE-2018-8832": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-8833": {"epss_score": 0.00778, "epss_percentile": 0.73133}, "CVE-2018-8834": {"epss_score": 0.00113, "epss_percentile": 0.30598}, "CVE-2018-8835": {"epss_score": 0.0035, "epss_percentile": 0.56941}, "CVE-2018-8836": {"epss_score": 0.03324, "epss_percentile": 0.86919}, "CVE-2018-8837": {"epss_score": 0.0035, "epss_percentile": 0.56941}, "CVE-2018-8838": {"epss_score": 0.00063, "epss_percentile": 0.19872}, "CVE-2018-8839": {"epss_score": 0.00107, "epss_percentile": 0.29696}, "CVE-2018-8840": {"epss_score": 0.3757, "epss_percentile": 0.97058}, "CVE-2018-8841": {"epss_score": 0.001, "epss_percentile": 0.28483}, "CVE-2018-8842": {"epss_score": 0.00435, "epss_percentile": 0.62366}, "CVE-2018-8843": {"epss_score": 0.00015, "epss_percentile": 0.02283}, "CVE-2018-8844": {"epss_score": 0.00157, "epss_percentile": 0.37053}, "CVE-2018-8845": {"epss_score": 0.01164, "epss_percentile": 0.7817}, "CVE-2018-8846": {"epss_score": 0.00345, "epss_percentile": 0.56602}, "CVE-2018-8847": {"epss_score": 0.13865, "epss_percentile": 0.94079}, "CVE-2018-8848": {"epss_score": 0.00596, "epss_percentile": 0.68702}, "CVE-2018-8849": {"epss_score": 0.00083, "epss_percentile": 0.24769}, "CVE-2018-8850": {"epss_score": 0.02383, "epss_percentile": 0.84571}, "CVE-2018-8851": {"epss_score": 0.00235, "epss_percentile": 0.46341}, "CVE-2018-8852": {"epss_score": 0.0067, "epss_percentile": 0.70771}, "CVE-2018-8853": {"epss_score": 0.00095, "epss_percentile": 0.27222}, "CVE-2018-8854": {"epss_score": 0.01345, "epss_percentile": 0.79625}, "CVE-2018-8855": {"epss_score": 0.00156, "epss_percentile": 0.3698}, "CVE-2018-8856": {"epss_score": 0.00385, "epss_percentile": 0.59218}, "CVE-2018-8857": {"epss_score": 0.00061, "epss_percentile": 0.19321}, "CVE-2018-8858": {"epss_score": 0.00235, "epss_percentile": 0.46341}, "CVE-2018-8859": {"epss_score": 0.00328, "epss_percentile": 0.55163}, "CVE-2018-8860": {"epss_score": 0.00194, "epss_percentile": 0.41524}, "CVE-2018-8861": {"epss_score": 0.00144, "epss_percentile": 0.35323}, "CVE-2018-8862": {"epss_score": 0.00198, "epss_percentile": 0.41989}, "CVE-2018-8863": {"epss_score": 0.0013, "epss_percentile": 0.33247}, "CVE-2018-8864": {"epss_score": 0.00024, "epss_percentile": 0.05748}, "CVE-2018-8865": {"epss_score": 0.04581, "epss_percentile": 0.88876}, "CVE-2018-8866": {"epss_score": 0.01286, "epss_percentile": 0.79184}, "CVE-2018-8867": {"epss_score": 0.0207, "epss_percentile": 0.83472}, "CVE-2018-8868": {"epss_score": 0.00048, "epss_percentile": 0.15107}, "CVE-2018-8869": {"epss_score": 0.00616, "epss_percentile": 0.69319}, "CVE-2018-8870": {"epss_score": 0.00044, "epss_percentile": 0.13548}, "CVE-2018-8871": {"epss_score": 0.0565, "epss_percentile": 0.90084}, "CVE-2018-8872": {"epss_score": 0.00759, "epss_percentile": 0.72794}, "CVE-2018-8873": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8874": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8875": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8876": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8877": {"epss_score": 0.00481, "epss_percentile": 0.64505}, "CVE-2018-8878": {"epss_score": 0.00481, "epss_percentile": 0.64505}, "CVE-2018-8879": {"epss_score": 0.32014, "epss_percentile": 0.96666}, "CVE-2018-8880": {"epss_score": 0.431, "epss_percentile": 0.9737}, "CVE-2018-8881": {"epss_score": 0.00215, "epss_percentile": 0.44103}, "CVE-2018-8882": {"epss_score": 0.00145, "epss_percentile": 0.35451}, "CVE-2018-8883": {"epss_score": 0.00145, "epss_percentile": 0.35451}, "CVE-2018-8885": {"epss_score": 0.0004, "epss_percentile": 0.11907}, "CVE-2018-8888": {"epss_score": 0.00277, "epss_percentile": 0.50823}, "CVE-2018-8889": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2018-8890": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2018-8891": {"epss_score": 0.00277, "epss_percentile": 0.50823}, "CVE-2018-8892": {"epss_score": 0.00112, "epss_percentile": 0.30572}, "CVE-2018-8893": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2018-8894": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8895": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8896": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8897": {"epss_score": 0.24796, "epss_percentile": 0.95955}, "CVE-2018-8898": {"epss_score": 0.2294, "epss_percentile": 0.95708}, "CVE-2018-8899": {"epss_score": 0.00294, "epss_percentile": 0.524}, "CVE-2018-8900": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2018-8901": {"epss_score": 0.00143, "epss_percentile": 0.35185}, "CVE-2018-8902": {"epss_score": 0.00187, "epss_percentile": 0.40762}, "CVE-2018-8903": {"epss_score": 0.00188, "epss_percentile": 0.40879}, "CVE-2018-8904": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8905": {"epss_score": 0.00595, "epss_percentile": 0.68686}, "CVE-2018-8906": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-8908": {"epss_score": 0.00236, "epss_percentile": 0.46445}, "CVE-2018-8909": {"epss_score": 0.00513, "epss_percentile": 0.65895}, "CVE-2018-8910": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2018-8911": {"epss_score": 0.00133, "epss_percentile": 0.33708}, "CVE-2018-8912": {"epss_score": 0.00133, "epss_percentile": 0.33708}, "CVE-2018-8913": {"epss_score": 0.00294, "epss_percentile": 0.5239}, "CVE-2018-8914": {"epss_score": 0.00323, "epss_percentile": 0.54921}, "CVE-2018-8915": {"epss_score": 0.00133, "epss_percentile": 0.33708}, "CVE-2018-8916": {"epss_score": 0.0028, "epss_percentile": 0.51008}, "CVE-2018-8917": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2018-8918": {"epss_score": 0.00143, "epss_percentile": 0.3519}, "CVE-2018-8919": {"epss_score": 0.00262, "epss_percentile": 0.49396}, "CVE-2018-8920": {"epss_score": 0.004, "epss_percentile": 0.60148}, "CVE-2018-8921": {"epss_score": 0.00133, "epss_percentile": 0.33708}, "CVE-2018-8922": {"epss_score": 0.00149, "epss_percentile": 0.35998}, "CVE-2018-8923": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2018-8924": {"epss_score": 0.00133, "epss_percentile": 0.33708}, "CVE-2018-8925": {"epss_score": 0.00138, "epss_percentile": 0.34422}, "CVE-2018-8926": {"epss_score": 0.00406, "epss_percentile": 0.60543}, "CVE-2018-8927": {"epss_score": 0.00119, "epss_percentile": 0.31572}, "CVE-2018-8928": {"epss_score": 0.00133, "epss_percentile": 0.33708}, "CVE-2018-8929": {"epss_score": 0.00187, "epss_percentile": 0.40758}, "CVE-2018-8930": {"epss_score": 0.00573, "epss_percentile": 0.68061}, "CVE-2018-8931": {"epss_score": 0.00465, "epss_percentile": 0.63741}, "CVE-2018-8932": {"epss_score": 0.00465, "epss_percentile": 0.63741}, "CVE-2018-8933": {"epss_score": 0.00465, "epss_percentile": 0.63741}, "CVE-2018-8934": {"epss_score": 0.00573, "epss_percentile": 0.68061}, "CVE-2018-8935": {"epss_score": 0.00573, "epss_percentile": 0.68061}, "CVE-2018-8936": {"epss_score": 0.00573, "epss_percentile": 0.68061}, "CVE-2018-8937": {"epss_score": 0.00199, "epss_percentile": 0.42149}, "CVE-2018-8938": {"epss_score": 0.00203, "epss_percentile": 0.42544}, "CVE-2018-8939": {"epss_score": 0.00069, "epss_percentile": 0.21515}, "CVE-2018-8940": {"epss_score": 0.00622, "epss_percentile": 0.69502}, "CVE-2018-8941": {"epss_score": 0.23681, "epss_percentile": 0.95802}, "CVE-2018-8942": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-8943": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-8944": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2018-8945": {"epss_score": 0.0017, "epss_percentile": 0.38716}, "CVE-2018-8947": {"epss_score": 0.16169, "epss_percentile": 0.94586}, "CVE-2018-8948": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-8949": {"epss_score": 0.00193, "epss_percentile": 0.4141}, "CVE-2018-8953": {"epss_score": 0.0122, "epss_percentile": 0.78622}, "CVE-2018-8954": {"epss_score": 0.0474, "epss_percentile": 0.89078}, "CVE-2018-8955": {"epss_score": 0.0515, "epss_percentile": 0.89548}, "CVE-2018-8956": {"epss_score": 0.01954, "epss_percentile": 0.8303}, "CVE-2018-8957": {"epss_score": 0.00248, "epss_percentile": 0.47979}, "CVE-2018-8960": {"epss_score": 0.00349, "epss_percentile": 0.56854}, "CVE-2018-8961": {"epss_score": 0.00421, "epss_percentile": 0.61498}, "CVE-2018-8962": {"epss_score": 0.00421, "epss_percentile": 0.61498}, "CVE-2018-8963": {"epss_score": 0.00421, "epss_percentile": 0.61498}, "CVE-2018-8964": {"epss_score": 0.00421, "epss_percentile": 0.61498}, "CVE-2018-8965": {"epss_score": 0.00634, "epss_percentile": 0.69797}, "CVE-2018-8966": {"epss_score": 0.00456, "epss_percentile": 0.6335}, "CVE-2018-8967": {"epss_score": 0.00381, "epss_percentile": 0.59015}, "CVE-2018-8968": {"epss_score": 0.00585, "epss_percentile": 0.68413}, "CVE-2018-8969": {"epss_score": 0.00585, "epss_percentile": 0.68413}, "CVE-2018-8970": {"epss_score": 0.00713, "epss_percentile": 0.71794}, "CVE-2018-8971": {"epss_score": 0.00175, "epss_percentile": 0.39374}, "CVE-2018-8972": {"epss_score": 0.00204, "epss_percentile": 0.42623}, "CVE-2018-8973": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-8974": {"epss_score": 0.01693, "epss_percentile": 0.81793}, "CVE-2018-8975": {"epss_score": 0.00454, "epss_percentile": 0.63265}, "CVE-2018-8976": {"epss_score": 0.00313, "epss_percentile": 0.54025}, "CVE-2018-8977": {"epss_score": 0.00339, "epss_percentile": 0.56188}, "CVE-2018-8978": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-8979": {"epss_score": 0.00356, "epss_percentile": 0.57387}, "CVE-2018-8988": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8989": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8990": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8991": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8992": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8993": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8994": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8995": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8996": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8997": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8998": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-8999": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9000": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9001": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9002": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9003": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9004": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9005": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9006": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9007": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9009": {"epss_score": 0.00625, "epss_percentile": 0.69578}, "CVE-2018-9010": {"epss_score": 0.13109, "epss_percentile": 0.93876}, "CVE-2018-9014": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2018-9015": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-9016": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-9017": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-9018": {"epss_score": 0.00498, "epss_percentile": 0.65235}, "CVE-2018-9019": {"epss_score": 0.01997, "epss_percentile": 0.83197}, "CVE-2018-9020": {"epss_score": 0.00219, "epss_percentile": 0.44467}, "CVE-2018-9021": {"epss_score": 0.16926, "epss_percentile": 0.94748}, "CVE-2018-9022": {"epss_score": 0.30136, "epss_percentile": 0.96514}, "CVE-2018-9023": {"epss_score": 0.00446, "epss_percentile": 0.62925}, "CVE-2018-9024": {"epss_score": 0.00798, "epss_percentile": 0.73511}, "CVE-2018-9025": {"epss_score": 0.00203, "epss_percentile": 0.42578}, "CVE-2018-9026": {"epss_score": 0.00219, "epss_percentile": 0.44496}, "CVE-2018-9027": {"epss_score": 0.00239, "epss_percentile": 0.46881}, "CVE-2018-9028": {"epss_score": 0.00136, "epss_percentile": 0.34095}, "CVE-2018-9029": {"epss_score": 0.00502, "epss_percentile": 0.65421}, "CVE-2018-9031": {"epss_score": 0.00737, "epss_percentile": 0.72322}, "CVE-2018-9032": {"epss_score": 0.87275, "epss_percentile": 0.99421}, "CVE-2018-9034": {"epss_score": 0.00143, "epss_percentile": 0.3512}, "CVE-2018-9035": {"epss_score": 0.08414, "epss_percentile": 0.92038}, "CVE-2018-9036": {"epss_score": 0.00207, "epss_percentile": 0.43195}, "CVE-2018-9037": {"epss_score": 0.02034, "epss_percentile": 0.83346}, "CVE-2018-9038": {"epss_score": 0.027, "epss_percentile": 0.85451}, "CVE-2018-9039": {"epss_score": 0.00246, "epss_percentile": 0.47756}, "CVE-2018-9040": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9041": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9042": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9043": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9044": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9045": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9046": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9047": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9048": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9049": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9050": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9051": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9052": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9053": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9054": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2018-9055": {"epss_score": 0.00454, "epss_percentile": 0.63252}, "CVE-2018-9056": {"epss_score": 0.00122, "epss_percentile": 0.32113}, "CVE-2018-9057": {"epss_score": 0.00465, "epss_percentile": 0.63742}, "CVE-2018-9058": {"epss_score": 0.00421, "epss_percentile": 0.61465}, "CVE-2018-9059": {"epss_score": 0.81606, "epss_percentile": 0.99148}, "CVE-2018-9062": {"epss_score": 0.00147, "epss_percentile": 0.35699}, "CVE-2018-9063": {"epss_score": 0.00091, "epss_percentile": 0.26382}, "CVE-2018-9064": {"epss_score": 0.00336, "epss_percentile": 0.55935}, "CVE-2018-9065": {"epss_score": 0.00148, "epss_percentile": 0.35913}, "CVE-2018-9066": {"epss_score": 0.00704, "epss_percentile": 0.7157}, "CVE-2018-9067": {"epss_score": 0.0034, "epss_percentile": 0.56265}, "CVE-2018-9068": {"epss_score": 0.00248, "epss_percentile": 0.47938}, "CVE-2018-9069": {"epss_score": 0.00211, "epss_percentile": 0.43624}, "CVE-2018-9070": {"epss_score": 0.00047, "epss_percentile": 0.14583}, "CVE-2018-9071": {"epss_score": 0.00308, "epss_percentile": 0.5363}, "CVE-2018-9072": {"epss_score": 0.00311, "epss_percentile": 0.53844}, "CVE-2018-9073": {"epss_score": 0.00148, "epss_percentile": 0.35914}, "CVE-2018-9074": {"epss_score": 0.00343, "epss_percentile": 0.56433}, "CVE-2018-9075": {"epss_score": 0.26448, "epss_percentile": 0.96147}, "CVE-2018-9076": {"epss_score": 0.0187, "epss_percentile": 0.82632}, "CVE-2018-9077": {"epss_score": 0.0187, "epss_percentile": 0.82632}, "CVE-2018-9078": {"epss_score": 0.0047, "epss_percentile": 0.63986}, "CVE-2018-9079": {"epss_score": 0.00543, "epss_percentile": 0.67104}, "CVE-2018-9080": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2018-9081": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2018-9082": {"epss_score": 0.00209, "epss_percentile": 0.43399}, "CVE-2018-9083": {"epss_score": 0.00358, "epss_percentile": 0.57529}, "CVE-2018-9084": {"epss_score": 0.00219, "epss_percentile": 0.44515}, "CVE-2018-9085": {"epss_score": 0.00137, "epss_percentile": 0.34313}, "CVE-2018-9086": {"epss_score": 0.02088, "epss_percentile": 0.83557}, "CVE-2018-9090": {"epss_score": 0.00275, "epss_percentile": 0.507}, "CVE-2018-9091": {"epss_score": 0.01122, "epss_percentile": 0.77781}, "CVE-2018-9092": {"epss_score": 0.00302, "epss_percentile": 0.53103}, "CVE-2018-9101": {"epss_score": 0.00325, "epss_percentile": 0.55022}, "CVE-2018-9102": {"epss_score": 0.00261, "epss_percentile": 0.4925}, "CVE-2018-9103": {"epss_score": 0.00325, "epss_percentile": 0.55022}, "CVE-2018-9104": {"epss_score": 0.00325, "epss_percentile": 0.55022}, "CVE-2018-9105": {"epss_score": 0.00672, "epss_percentile": 0.70815}, "CVE-2018-9106": {"epss_score": 0.068, "epss_percentile": 0.91034}, "CVE-2018-9107": {"epss_score": 0.11988, "epss_percentile": 0.93538}, "CVE-2018-9108": {"epss_score": 0.00195, "epss_percentile": 0.41628}, "CVE-2018-9109": {"epss_score": 0.00847, "epss_percentile": 0.74352}, "CVE-2018-9110": {"epss_score": 0.00847, "epss_percentile": 0.74352}, "CVE-2018-9111": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-9112": {"epss_score": 0.00457, "epss_percentile": 0.63385}, "CVE-2018-9113": {"epss_score": 0.01693, "epss_percentile": 0.81793}, "CVE-2018-9115": {"epss_score": 0.20356, "epss_percentile": 0.95331}, "CVE-2018-9116": {"epss_score": 0.01091, "epss_percentile": 0.77456}, "CVE-2018-9117": {"epss_score": 0.00691, "epss_percentile": 0.71281}, "CVE-2018-9118": {"epss_score": 0.71307, "epss_percentile": 0.98663}, "CVE-2018-9119": {"epss_score": 0.00116, "epss_percentile": 0.31101}, "CVE-2018-9120": {"epss_score": 0.00188, "epss_percentile": 0.40868}, "CVE-2018-9121": {"epss_score": 0.00188, "epss_percentile": 0.40868}, "CVE-2018-9122": {"epss_score": 0.00188, "epss_percentile": 0.40868}, "CVE-2018-9123": {"epss_score": 0.00188, "epss_percentile": 0.40868}, "CVE-2018-9126": {"epss_score": 0.81946, "epss_percentile": 0.99166}, "CVE-2018-9127": {"epss_score": 0.00179, "epss_percentile": 0.39772}, "CVE-2018-9128": {"epss_score": 0.16671, "epss_percentile": 0.94711}, "CVE-2018-9129": {"epss_score": 0.00273, "epss_percentile": 0.50423}, "CVE-2018-9130": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-9132": {"epss_score": 0.00649, "epss_percentile": 0.70239}, "CVE-2018-9133": {"epss_score": 0.00321, "epss_percentile": 0.54677}, "CVE-2018-9134": {"epss_score": 0.003, "epss_percentile": 0.52937}, "CVE-2018-9135": {"epss_score": 0.00304, "epss_percentile": 0.53288}, "CVE-2018-9136": {"epss_score": 0.00149, "epss_percentile": 0.35982}, "CVE-2018-9137": {"epss_score": 0.02315, "epss_percentile": 0.84355}, "CVE-2018-9138": {"epss_score": 0.00301, "epss_percentile": 0.53002}, "CVE-2018-9139": {"epss_score": 0.0128, "epss_percentile": 0.7914}, "CVE-2018-9140": {"epss_score": 0.0036, "epss_percentile": 0.57667}, "CVE-2018-9141": {"epss_score": 0.0076, "epss_percentile": 0.7281}, "CVE-2018-9142": {"epss_score": 0.00118, "epss_percentile": 0.31401}, "CVE-2018-9143": {"epss_score": 0.01074, "epss_percentile": 0.773}, "CVE-2018-9144": {"epss_score": 0.00365, "epss_percentile": 0.57976}, "CVE-2018-9145": {"epss_score": 0.00348, "epss_percentile": 0.56816}, "CVE-2018-9147": {"epss_score": 0.00215, "epss_percentile": 0.44038}, "CVE-2018-9148": {"epss_score": 0.04112, "epss_percentile": 0.88275}, "CVE-2018-9149": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2018-9151": {"epss_score": 0.00049, "epss_percentile": 0.153}, "CVE-2018-9153": {"epss_score": 0.00647, "epss_percentile": 0.70186}, "CVE-2018-9154": {"epss_score": 0.00486, "epss_percentile": 0.64743}, "CVE-2018-9155": {"epss_score": 0.00194, "epss_percentile": 0.41539}, "CVE-2018-9156": {"epss_score": 0.01878, "epss_percentile": 0.8267}, "CVE-2018-9157": {"epss_score": 0.01671, "epss_percentile": 0.81677}, "CVE-2018-9158": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2018-9159": {"epss_score": 0.00372, "epss_percentile": 0.5842}, "CVE-2018-9160": {"epss_score": 0.62739, "epss_percentile": 0.98306}, "CVE-2018-9161": {"epss_score": 0.63057, "epss_percentile": 0.98319}, "CVE-2018-9162": {"epss_score": 0.03725, "epss_percentile": 0.87632}, "CVE-2018-9163": {"epss_score": 0.02437, "epss_percentile": 0.84742}, "CVE-2018-9165": {"epss_score": 0.00239, "epss_percentile": 0.46868}, "CVE-2018-9169": {"epss_score": 0.00207, "epss_percentile": 0.43195}, "CVE-2018-9172": {"epss_score": 0.02542, "epss_percentile": 0.85052}, "CVE-2018-9173": {"epss_score": 0.005, "epss_percentile": 0.65321}, "CVE-2018-9174": {"epss_score": 0.01105, "epss_percentile": 0.77605}, "CVE-2018-9175": {"epss_score": 0.02109, "epss_percentile": 0.83642}, "CVE-2018-9177": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-9182": {"epss_score": 0.00208, "epss_percentile": 0.43222}, "CVE-2018-9183": {"epss_score": 0.00271, "epss_percentile": 0.50294}, "CVE-2018-9185": {"epss_score": 0.00975, "epss_percentile": 0.76201}, "CVE-2018-9186": {"epss_score": 0.00265, "epss_percentile": 0.49769}, "CVE-2018-9190": {"epss_score": 0.00145, "epss_percentile": 0.35376}, "CVE-2018-9191": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2018-9192": {"epss_score": 0.00174, "epss_percentile": 0.39222}, "CVE-2018-9193": {"epss_score": 0.00031, "epss_percentile": 0.08439}, "CVE-2018-9194": {"epss_score": 0.00174, "epss_percentile": 0.39222}, "CVE-2018-9195": {"epss_score": 0.00297, "epss_percentile": 0.52681}, "CVE-2018-9205": {"epss_score": 0.81446, "epss_percentile": 0.99138}, "CVE-2018-9206": {"epss_score": 0.93931, "epss_percentile": 0.99869}, "CVE-2018-9207": {"epss_score": 0.28553, "epss_percentile": 0.96367}, "CVE-2018-9208": {"epss_score": 0.15218, "epss_percentile": 0.94387}, "CVE-2018-9209": {"epss_score": 0.01487, "epss_percentile": 0.80611}, "CVE-2018-9230": {"epss_score": 0.42719, "epss_percentile": 0.97348}, "CVE-2018-9232": {"epss_score": 0.00188, "epss_percentile": 0.40914}, "CVE-2018-9233": {"epss_score": 0.00055, "epss_percentile": 0.17495}, "CVE-2018-9234": {"epss_score": 0.00121, "epss_percentile": 0.31824}, "CVE-2018-9235": {"epss_score": 0.01265, "epss_percentile": 0.79002}, "CVE-2018-9236": {"epss_score": 0.01095, "epss_percentile": 0.7751}, "CVE-2018-9237": {"epss_score": 0.01095, "epss_percentile": 0.7751}, "CVE-2018-9238": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-9240": {"epss_score": 0.00436, "epss_percentile": 0.62459}, "CVE-2018-9242": {"epss_score": 0.001, "epss_percentile": 0.28493}, "CVE-2018-9243": {"epss_score": 0.0008, "epss_percentile": 0.24175}, "CVE-2018-9244": {"epss_score": 0.00076, "epss_percentile": 0.23087}, "CVE-2018-9245": {"epss_score": 0.12496, "epss_percentile": 0.93692}, "CVE-2018-9246": {"epss_score": 0.00971, "epss_percentile": 0.76118}, "CVE-2018-9247": {"epss_score": 0.00944, "epss_percentile": 0.75783}, "CVE-2018-9248": {"epss_score": 0.73772, "epss_percentile": 0.98772}, "CVE-2018-9249": {"epss_score": 0.00496, "epss_percentile": 0.65162}, "CVE-2018-9250": {"epss_score": 0.25248, "epss_percentile": 0.96003}, "CVE-2018-9251": {"epss_score": 0.00969, "epss_percentile": 0.76097}, "CVE-2018-9252": {"epss_score": 0.00489, "epss_percentile": 0.64869}, "CVE-2018-9256": {"epss_score": 0.00474, "epss_percentile": 0.64163}, "CVE-2018-9257": {"epss_score": 0.00355, "epss_percentile": 0.57287}, "CVE-2018-9258": {"epss_score": 0.00688, "epss_percentile": 0.71192}, "CVE-2018-9259": {"epss_score": 0.00739, "epss_percentile": 0.7239}, "CVE-2018-9260": {"epss_score": 0.00483, "epss_percentile": 0.64562}, "CVE-2018-9261": {"epss_score": 0.00663, "epss_percentile": 0.70615}, "CVE-2018-9262": {"epss_score": 0.00463, "epss_percentile": 0.63662}, "CVE-2018-9263": {"epss_score": 0.00528, "epss_percentile": 0.66534}, "CVE-2018-9264": {"epss_score": 0.00702, "epss_percentile": 0.71507}, "CVE-2018-9265": {"epss_score": 0.007, "epss_percentile": 0.71476}, "CVE-2018-9266": {"epss_score": 0.00382, "epss_percentile": 0.59052}, "CVE-2018-9267": {"epss_score": 0.007, "epss_percentile": 0.71476}, "CVE-2018-9268": {"epss_score": 0.00713, "epss_percentile": 0.71782}, "CVE-2018-9269": {"epss_score": 0.00713, "epss_percentile": 0.71782}, "CVE-2018-9270": {"epss_score": 0.00752, "epss_percentile": 0.72659}, "CVE-2018-9271": {"epss_score": 0.00382, "epss_percentile": 0.59052}, "CVE-2018-9272": {"epss_score": 0.00382, "epss_percentile": 0.59052}, "CVE-2018-9273": {"epss_score": 0.007, "epss_percentile": 0.71476}, "CVE-2018-9274": {"epss_score": 0.00382, "epss_percentile": 0.59052}, "CVE-2018-9275": {"epss_score": 0.00492, "epss_percentile": 0.64981}, "CVE-2018-9276": {"epss_score": 0.81539, "epss_percentile": 0.99143}, "CVE-2018-9279": {"epss_score": 0.00309, "epss_percentile": 0.53679}, "CVE-2018-9280": {"epss_score": 0.00309, "epss_percentile": 0.53679}, "CVE-2018-9281": {"epss_score": 0.00178, "epss_percentile": 0.39694}, "CVE-2018-9282": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2018-9283": {"epss_score": 0.00251, "epss_percentile": 0.4829}, "CVE-2018-9284": {"epss_score": 0.04018, "epss_percentile": 0.88124}, "CVE-2018-9285": {"epss_score": 0.02805, "epss_percentile": 0.85706}, "CVE-2018-9302": {"epss_score": 0.10915, "epss_percentile": 0.93156}, "CVE-2018-9303": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2018-9304": {"epss_score": 0.00455, "epss_percentile": 0.6328}, "CVE-2018-9305": {"epss_score": 0.00452, "epss_percentile": 0.63186}, "CVE-2018-9307": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-9309": {"epss_score": 0.00381, "epss_percentile": 0.59002}, "CVE-2018-9310": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2018-9311": {"epss_score": 0.00838, "epss_percentile": 0.74178}, "CVE-2018-9312": {"epss_score": 0.0016, "epss_percentile": 0.37505}, "CVE-2018-9313": {"epss_score": 0.00313, "epss_percentile": 0.54048}, "CVE-2018-9314": {"epss_score": 0.00074, "epss_percentile": 0.22847}, "CVE-2018-9318": {"epss_score": 0.00843, "epss_percentile": 0.74263}, "CVE-2018-9320": {"epss_score": 0.00065, "epss_percentile": 0.20479}, "CVE-2018-9322": {"epss_score": 0.00053, "epss_percentile": 0.16996}, "CVE-2018-9325": {"epss_score": 0.00306, "epss_percentile": 0.53421}, "CVE-2018-9326": {"epss_score": 0.0104, "epss_percentile": 0.76957}, "CVE-2018-9327": {"epss_score": 0.0104, "epss_percentile": 0.76957}, "CVE-2018-9328": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-9330": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-9331": {"epss_score": 0.00585, "epss_percentile": 0.68413}, "CVE-2018-9332": {"epss_score": 0.00056, "epss_percentile": 0.1795}, "CVE-2018-9333": {"epss_score": 0.00084, "epss_percentile": 0.24964}, "CVE-2018-9334": {"epss_score": 0.00109, "epss_percentile": 0.30028}, "CVE-2018-9335": {"epss_score": 0.00355, "epss_percentile": 0.57312}, "CVE-2018-9336": {"epss_score": 0.00087, "epss_percentile": 0.25459}, "CVE-2018-9337": {"epss_score": 0.00355, "epss_percentile": 0.57312}, "CVE-2018-9338": {"epss_score": 0.00054, "epss_percentile": 0.17344}, "CVE-2018-9339": {"epss_score": 0.00045, "epss_percentile": 0.14}, "CVE-2018-9340": {"epss_score": 0.00138, "epss_percentile": 0.34402}, "CVE-2018-9341": {"epss_score": 0.00871, "epss_percentile": 0.74717}, "CVE-2018-9344": {"epss_score": 0.00049, "epss_percentile": 0.15605}, "CVE-2018-9345": {"epss_score": 0.00041, "epss_percentile": 0.12395}, "CVE-2018-9346": {"epss_score": 0.00041, "epss_percentile": 0.12395}, "CVE-2018-9347": {"epss_score": 0.0021, "epss_percentile": 0.43464}, "CVE-2018-9348": {"epss_score": 0.02712, "epss_percentile": 0.855}, "CVE-2018-9349": {"epss_score": 0.00081, "epss_percentile": 0.24357}, "CVE-2018-9350": {"epss_score": 0.00062, "epss_percentile": 0.19717}, "CVE-2018-9351": {"epss_score": 0.00881, "epss_percentile": 0.74871}, "CVE-2018-9352": {"epss_score": 0.01193, "epss_percentile": 0.78405}, "CVE-2018-9353": {"epss_score": 0.00881, "epss_percentile": 0.74871}, "CVE-2018-9354": {"epss_score": 0.01193, "epss_percentile": 0.78405}, "CVE-2018-9355": {"epss_score": 0.07834, "epss_percentile": 0.91705}, "CVE-2018-9356": {"epss_score": 0.17243, "epss_percentile": 0.94805}, "CVE-2018-9357": {"epss_score": 0.00071, "epss_percentile": 0.21985}, "CVE-2018-9358": {"epss_score": 0.02405, "epss_percentile": 0.8465}, "CVE-2018-9359": {"epss_score": 0.01609, "epss_percentile": 0.81317}, "CVE-2018-9360": {"epss_score": 0.02405, "epss_percentile": 0.8465}, "CVE-2018-9361": {"epss_score": 0.01609, "epss_percentile": 0.81317}, "CVE-2018-9362": {"epss_score": 0.02771, "epss_percentile": 0.85621}, "CVE-2018-9363": {"epss_score": 0.0003, "epss_percentile": 0.08171}, "CVE-2018-9364": {"epss_score": 0.00032, "epss_percentile": 0.09002}, "CVE-2018-9365": {"epss_score": 0.02743, "epss_percentile": 0.85566}, "CVE-2018-9366": {"epss_score": 0.0006, "epss_percentile": 0.18953}, "CVE-2018-9367": {"epss_score": 0.00044, "epss_percentile": 0.13473}, "CVE-2018-9368": {"epss_score": 0.00025, "epss_percentile": 0.06254}, "CVE-2018-9369": {"epss_score": 0.00038, "epss_percentile": 0.11384}, "CVE-2018-9370": {"epss_score": 0.00057, "epss_percentile": 0.18013}, "CVE-2018-9371": {"epss_score": 0.00094, "epss_percentile": 0.2697}, "CVE-2018-9372": {"epss_score": 0.00056, "epss_percentile": 0.17689}, "CVE-2018-9373": {"epss_score": 0.00647, "epss_percentile": 0.70196}, "CVE-2018-9374": {"epss_score": 4e-05, "epss_percentile": 0.00144}, "CVE-2018-9375": {"epss_score": 0.0004, "epss_percentile": 0.12009}, "CVE-2018-9376": {"epss_score": 9e-05, "epss_percentile": 0.00639}, "CVE-2018-9377": {"epss_score": 0.00019, "epss_percentile": 0.0435}, "CVE-2018-9378": {"epss_score": 0.00019, "epss_percentile": 0.04085}, "CVE-2018-9379": {"epss_score": 0.00018, "epss_percentile": 0.03638}, "CVE-2018-9380": {"epss_score": 0.01064, "epss_percentile": 0.77193}, "CVE-2018-9381": {"epss_score": 0.00082, "epss_percentile": 0.24571}, "CVE-2018-9382": {"epss_score": 0.00023, "epss_percentile": 0.05416}, "CVE-2018-9383": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2018-9384": {"epss_score": 9e-05, "epss_percentile": 0.00641}, "CVE-2018-9385": {"epss_score": 0.00088, "epss_percentile": 0.25789}, "CVE-2018-9386": {"epss_score": 0.00031, "epss_percentile": 0.08413}, "CVE-2018-9387": {"epss_score": 0.0003, "epss_percentile": 0.08288}, "CVE-2018-9388": {"epss_score": 0.00064, "epss_percentile": 0.20129}, "CVE-2018-9389": {"epss_score": 0.00026, "epss_percentile": 0.06616}, "CVE-2018-9390": {"epss_score": 0.00033, "epss_percentile": 0.09337}, "CVE-2018-9391": {"epss_score": 0.00025, "epss_percentile": 0.06363}, "CVE-2018-9392": {"epss_score": 0.00022, "epss_percentile": 0.05277}, "CVE-2018-9393": {"epss_score": 0.00022, "epss_percentile": 0.05277}, "CVE-2018-9394": {"epss_score": 0.00022, "epss_percentile": 0.05277}, "CVE-2018-9395": {"epss_score": 0.00022, "epss_percentile": 0.05277}, "CVE-2018-9396": {"epss_score": 0.00022, "epss_percentile": 0.05277}, "CVE-2018-9397": {"epss_score": 0.00022, "epss_percentile": 0.05277}, "CVE-2018-9398": {"epss_score": 0.00022, "epss_percentile": 0.05277}, "CVE-2018-9399": {"epss_score": 0.00022, "epss_percentile": 0.05277}, "CVE-2018-9400": {"epss_score": 0.00022, "epss_percentile": 0.05277}, "CVE-2018-9401": {"epss_score": 0.00023, "epss_percentile": 0.05416}, "CVE-2018-9402": {"epss_score": 0.00033, "epss_percentile": 0.09137}, "CVE-2018-9403": {"epss_score": 0.00027, "epss_percentile": 0.06902}, "CVE-2018-9404": {"epss_score": 0.00022, "epss_percentile": 0.05277}, "CVE-2018-9405": {"epss_score": 0.00025, "epss_percentile": 0.06048}, "CVE-2018-9406": {"epss_score": 0.00016, "epss_percentile": 0.02939}, "CVE-2018-9407": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2018-9408": {"epss_score": 0.00021, "epss_percentile": 0.04843}, "CVE-2018-9409": {"epss_score": 0.00056, "epss_percentile": 0.17689}, "CVE-2018-9410": {"epss_score": 0.00073, "epss_percentile": 0.22618}, "CVE-2018-9411": {"epss_score": 0.07309, "epss_percentile": 0.91398}, "CVE-2018-9412": {"epss_score": 0.00048, "epss_percentile": 0.15251}, "CVE-2018-9413": {"epss_score": 0.00065, "epss_percentile": 0.20599}, "CVE-2018-9414": {"epss_score": 0.00011, "epss_percentile": 0.01079}, "CVE-2018-9415": {"epss_score": 0.00061, "epss_percentile": 0.19488}, "CVE-2018-9416": {"epss_score": 0.00046, "epss_percentile": 0.14269}, "CVE-2018-9417": {"epss_score": 0.00064, "epss_percentile": 0.20158}, "CVE-2018-9418": {"epss_score": 0.0011, "epss_percentile": 0.30168}, "CVE-2018-9419": {"epss_score": 0.01346, "epss_percentile": 0.79646}, "CVE-2018-9420": {"epss_score": 0.00041, "epss_percentile": 0.12395}, "CVE-2018-9421": {"epss_score": 0.00041, "epss_percentile": 0.12395}, "CVE-2018-9422": {"epss_score": 0.00066, "epss_percentile": 0.207}, "CVE-2018-9423": {"epss_score": 0.00024, "epss_percentile": 0.05864}, "CVE-2018-9424": {"epss_score": 0.0006, "epss_percentile": 0.18953}, "CVE-2018-9425": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2018-9426": {"epss_score": 0.0008, "epss_percentile": 0.24116}, "CVE-2018-9427": {"epss_score": 0.03058, "epss_percentile": 0.86303}, "CVE-2018-9428": {"epss_score": 0.0006, "epss_percentile": 0.19137}, "CVE-2018-9429": {"epss_score": 0.00072, "epss_percentile": 0.22428}, "CVE-2018-9430": {"epss_score": 0.01222, "epss_percentile": 0.78655}, "CVE-2018-9431": {"epss_score": 0.00025, "epss_percentile": 0.06295}, "CVE-2018-9432": {"epss_score": 7e-05, "epss_percentile": 0.00386}, "CVE-2018-9433": {"epss_score": 0.02935, "epss_percentile": 0.86023}, "CVE-2018-9434": {"epss_score": 7e-05, "epss_percentile": 0.0034}, "CVE-2018-9435": {"epss_score": 0.00013, "epss_percentile": 0.01675}, "CVE-2018-9436": {"epss_score": 0.02686, "epss_percentile": 0.85427}, "CVE-2018-9437": {"epss_score": 0.02009, "epss_percentile": 0.83244}, "CVE-2018-9438": {"epss_score": 0.00092, "epss_percentile": 0.26532}, "CVE-2018-9439": {"epss_score": 0.00012, "epss_percentile": 0.01129}, "CVE-2018-9440": {"epss_score": 0.00157, "epss_percentile": 0.37081}, "CVE-2018-9441": {"epss_score": 0.0001, "epss_percentile": 0.00832}, "CVE-2018-9444": {"epss_score": 0.00077, "epss_percentile": 0.23315}, "CVE-2018-9445": {"epss_score": 0.0084, "epss_percentile": 0.74202}, "CVE-2018-9446": {"epss_score": 0.00977, "epss_percentile": 0.76222}, "CVE-2018-9447": {"epss_score": 9e-05, "epss_percentile": 0.00739}, "CVE-2018-9448": {"epss_score": 0.02686, "epss_percentile": 0.85427}, "CVE-2018-9449": {"epss_score": 0.00021, "epss_percentile": 0.04773}, "CVE-2018-9450": {"epss_score": 0.07035, "epss_percentile": 0.91203}, "CVE-2018-9451": {"epss_score": 0.00095, "epss_percentile": 0.27188}, "CVE-2018-9452": {"epss_score": 0.00374, "epss_percentile": 0.58588}, "CVE-2018-9453": {"epss_score": 0.00095, "epss_percentile": 0.27188}, "CVE-2018-9454": {"epss_score": 0.00095, "epss_percentile": 0.27188}, "CVE-2018-9455": {"epss_score": 0.05327, "epss_percentile": 0.89735}, "CVE-2018-9456": {"epss_score": 0.05435, "epss_percentile": 0.89881}, "CVE-2018-9457": {"epss_score": 0.00019, "epss_percentile": 0.04235}, "CVE-2018-9458": {"epss_score": 0.00152, "epss_percentile": 0.36423}, "CVE-2018-9459": {"epss_score": 0.0419, "epss_percentile": 0.88375}, "CVE-2018-9461": {"epss_score": 0.00013, "epss_percentile": 0.01564}, "CVE-2018-9462": {"epss_score": 0.0002, "epss_percentile": 0.04517}, "CVE-2018-9463": {"epss_score": 0.0002, "epss_percentile": 0.04517}, "CVE-2018-9464": {"epss_score": 0.00022, "epss_percentile": 0.05159}, "CVE-2018-9465": {"epss_score": 0.00075, "epss_percentile": 0.22944}, "CVE-2018-9466": {"epss_score": 0.05336, "epss_percentile": 0.89743}, "CVE-2018-9467": {"epss_score": 0.00185, "epss_percentile": 0.40523}, "CVE-2018-9468": {"epss_score": 0.00029, "epss_percentile": 0.07933}, "CVE-2018-9469": {"epss_score": 0.00027, "epss_percentile": 0.06947}, "CVE-2018-9470": {"epss_score": 0.03776, "epss_percentile": 0.87709}, "CVE-2018-9471": {"epss_score": 0.00139, "epss_percentile": 0.34594}, "CVE-2018-9472": {"epss_score": 0.01944, "epss_percentile": 0.82998}, "CVE-2018-9473": {"epss_score": 0.00325, "epss_percentile": 0.55018}, "CVE-2018-9474": {"epss_score": 0.00025, "epss_percentile": 0.06218}, "CVE-2018-9475": {"epss_score": 0.03037, "epss_percentile": 0.86266}, "CVE-2018-9476": {"epss_score": 0.06064, "epss_percentile": 0.90446}, "CVE-2018-9477": {"epss_score": 6e-05, "epss_percentile": 0.00249}, "CVE-2018-9478": {"epss_score": 0.05044, "epss_percentile": 0.8943}, "CVE-2018-9479": {"epss_score": 0.10769, "epss_percentile": 0.93098}, "CVE-2018-9480": {"epss_score": 0.00546, "epss_percentile": 0.6721}, "CVE-2018-9481": {"epss_score": 0.00088, "epss_percentile": 0.25757}, "CVE-2018-9482": {"epss_score": 0.00074, "epss_percentile": 0.22774}, "CVE-2018-9483": {"epss_score": 0.00326, "epss_percentile": 0.55055}, "CVE-2018-9484": {"epss_score": 0.00529, "epss_percentile": 0.666}, "CVE-2018-9485": {"epss_score": 0.00305, "epss_percentile": 0.53337}, "CVE-2018-9486": {"epss_score": 0.00108, "epss_percentile": 0.29786}, "CVE-2018-9487": {"epss_score": 0.00073, "epss_percentile": 0.22525}, "CVE-2018-9488": {"epss_score": 0.00024, "epss_percentile": 0.05688}, "CVE-2018-9489": {"epss_score": 0.00289, "epss_percentile": 0.52037}, "CVE-2018-9490": {"epss_score": 0.00418, "epss_percentile": 0.61262}, "CVE-2018-9491": {"epss_score": 0.00325, "epss_percentile": 0.55018}, "CVE-2018-9492": {"epss_score": 0.00025, "epss_percentile": 0.06275}, "CVE-2018-9493": {"epss_score": 0.00727, "epss_percentile": 0.72093}, "CVE-2018-9496": {"epss_score": 0.01221, "epss_percentile": 0.7865}, "CVE-2018-9497": {"epss_score": 0.00406, "epss_percentile": 0.60553}, "CVE-2018-9498": {"epss_score": 0.00406, "epss_percentile": 0.60553}, "CVE-2018-9499": {"epss_score": 0.00037, "epss_percentile": 0.10921}, "CVE-2018-9501": {"epss_score": 0.00025, "epss_percentile": 0.06114}, "CVE-2018-9502": {"epss_score": 0.0028, "epss_percentile": 0.51092}, "CVE-2018-9503": {"epss_score": 0.00828, "epss_percentile": 0.73998}, "CVE-2018-9504": {"epss_score": 0.00561, "epss_percentile": 0.67656}, "CVE-2018-9505": {"epss_score": 0.00286, "epss_percentile": 0.51711}, "CVE-2018-9506": {"epss_score": 0.00279, "epss_percentile": 0.50992}, "CVE-2018-9507": {"epss_score": 0.00286, "epss_percentile": 0.51711}, "CVE-2018-9508": {"epss_score": 0.00263, "epss_percentile": 0.49545}, "CVE-2018-9509": {"epss_score": 0.00286, "epss_percentile": 0.51711}, "CVE-2018-9510": {"epss_score": 0.00286, "epss_percentile": 0.51711}, "CVE-2018-9511": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2018-9513": {"epss_score": 0.00018, "epss_percentile": 0.03882}, "CVE-2018-9514": {"epss_score": 0.00021, "epss_percentile": 0.04898}, "CVE-2018-9515": {"epss_score": 0.00735, "epss_percentile": 0.72296}, "CVE-2018-9516": {"epss_score": 0.00041, "epss_percentile": 0.12267}, "CVE-2018-9517": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2018-9518": {"epss_score": 0.00069, "epss_percentile": 0.21491}, "CVE-2018-9519": {"epss_score": 0.0001, "epss_percentile": 0.00906}, "CVE-2018-9521": {"epss_score": 0.00481, "epss_percentile": 0.64494}, "CVE-2018-9522": {"epss_score": 0.00018, "epss_percentile": 0.03882}, "CVE-2018-9523": {"epss_score": 0.00017, "epss_percentile": 0.03494}, "CVE-2018-9524": {"epss_score": 0.00019, "epss_percentile": 0.04071}, "CVE-2018-9525": {"epss_score": 0.00016, "epss_percentile": 0.02634}, "CVE-2018-9526": {"epss_score": 0.0029, "epss_percentile": 0.52136}, "CVE-2018-9527": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2018-9528": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2018-9529": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2018-9530": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2018-9531": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2018-9532": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2018-9533": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2018-9534": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2018-9535": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2018-9536": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2018-9537": {"epss_score": 0.00481, "epss_percentile": 0.64494}, "CVE-2018-9538": {"epss_score": 0.00022, "epss_percentile": 0.04994}, "CVE-2018-9539": {"epss_score": 0.00173, "epss_percentile": 0.39116}, "CVE-2018-9540": {"epss_score": 0.00386, "epss_percentile": 0.59256}, "CVE-2018-9541": {"epss_score": 0.00386, "epss_percentile": 0.59256}, "CVE-2018-9542": {"epss_score": 0.00386, "epss_percentile": 0.59256}, "CVE-2018-9543": {"epss_score": 0.00038, "epss_percentile": 0.11223}, "CVE-2018-9544": {"epss_score": 0.00024, "epss_percentile": 0.05802}, "CVE-2018-9545": {"epss_score": 0.00022, "epss_percentile": 0.05021}, "CVE-2018-9547": {"epss_score": 0.00022, "epss_percentile": 0.04994}, "CVE-2018-9548": {"epss_score": 0.00027, "epss_percentile": 0.06739}, "CVE-2018-9549": {"epss_score": 0.00253, "epss_percentile": 0.48474}, "CVE-2018-9550": {"epss_score": 0.00253, "epss_percentile": 0.48474}, "CVE-2018-9551": {"epss_score": 0.00253, "epss_percentile": 0.48474}, "CVE-2018-9552": {"epss_score": 0.00116, "epss_percentile": 0.31073}, "CVE-2018-9553": {"epss_score": 0.00253, "epss_percentile": 0.48474}, "CVE-2018-9554": {"epss_score": 0.0002, "epss_percentile": 0.04661}, "CVE-2018-9555": {"epss_score": 0.0036, "epss_percentile": 0.57622}, "CVE-2018-9556": {"epss_score": 0.01165, "epss_percentile": 0.78173}, "CVE-2018-9557": {"epss_score": 0.00019, "epss_percentile": 0.04169}, "CVE-2018-9558": {"epss_score": 0.00022, "epss_percentile": 0.04994}, "CVE-2018-9559": {"epss_score": 0.00022, "epss_percentile": 0.05021}, "CVE-2018-9560": {"epss_score": 0.00026, "epss_percentile": 0.06514}, "CVE-2018-9561": {"epss_score": 0.00131, "epss_percentile": 0.33465}, "CVE-2018-9562": {"epss_score": 0.00587, "epss_percentile": 0.68479}, "CVE-2018-9563": {"epss_score": 0.00131, "epss_percentile": 0.33465}, "CVE-2018-9564": {"epss_score": 0.00131, "epss_percentile": 0.33465}, "CVE-2018-9565": {"epss_score": 0.00587, "epss_percentile": 0.68479}, "CVE-2018-9566": {"epss_score": 0.003, "epss_percentile": 0.52987}, "CVE-2018-9567": {"epss_score": 0.00011, "epss_percentile": 0.00951}, "CVE-2018-9568": {"epss_score": 0.00461, "epss_percentile": 0.63546}, "CVE-2018-9569": {"epss_score": 0.0037, "epss_percentile": 0.5829}, "CVE-2018-9570": {"epss_score": 0.00177, "epss_percentile": 0.39606}, "CVE-2018-9571": {"epss_score": 0.0037, "epss_percentile": 0.5829}, "CVE-2018-9572": {"epss_score": 0.0037, "epss_percentile": 0.5829}, "CVE-2018-9573": {"epss_score": 0.00177, "epss_percentile": 0.39606}, "CVE-2018-9574": {"epss_score": 0.00177, "epss_percentile": 0.39606}, "CVE-2018-9575": {"epss_score": 0.00177, "epss_percentile": 0.39606}, "CVE-2018-9576": {"epss_score": 0.00177, "epss_percentile": 0.39606}, "CVE-2018-9577": {"epss_score": 0.00177, "epss_percentile": 0.39606}, "CVE-2018-9578": {"epss_score": 0.00646, "epss_percentile": 0.70144}, "CVE-2018-9580": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2018-9581": {"epss_score": 0.00031, "epss_percentile": 0.08659}, "CVE-2018-9582": {"epss_score": 0.00022, "epss_percentile": 0.05021}, "CVE-2018-9583": {"epss_score": 0.00977, "epss_percentile": 0.76222}, "CVE-2018-9584": {"epss_score": 0.00022, "epss_percentile": 0.05021}, "CVE-2018-9585": {"epss_score": 0.00022, "epss_percentile": 0.05021}, "CVE-2018-9586": {"epss_score": 0.00017, "epss_percentile": 0.03227}, "CVE-2018-9587": {"epss_score": 0.00022, "epss_percentile": 0.05021}, "CVE-2018-9588": {"epss_score": 0.00164, "epss_percentile": 0.37938}, "CVE-2018-9589": {"epss_score": 0.00024, "epss_percentile": 0.05802}, "CVE-2018-9590": {"epss_score": 0.00386, "epss_percentile": 0.59256}, "CVE-2018-9591": {"epss_score": 0.00386, "epss_percentile": 0.59256}, "CVE-2018-9592": {"epss_score": 0.00386, "epss_percentile": 0.59256}, "CVE-2018-9593": {"epss_score": 0.00049, "epss_percentile": 0.15461}, "CVE-2018-9594": {"epss_score": 0.00049, "epss_percentile": 0.15461}, "CVE-2018-9838": {"epss_score": 0.03589, "epss_percentile": 0.87397}, "CVE-2018-9839": {"epss_score": 0.00229, "epss_percentile": 0.45555}, "CVE-2018-9840": {"epss_score": 0.00058, "epss_percentile": 0.18363}, "CVE-2018-9841": {"epss_score": 0.00557, "epss_percentile": 0.67559}, "CVE-2018-9842": {"epss_score": 0.60885, "epss_percentile": 0.98225}, "CVE-2018-9843": {"epss_score": 0.23987, "epss_percentile": 0.9584}, "CVE-2018-9844": {"epss_score": 0.10771, "epss_percentile": 0.93098}, "CVE-2018-9845": {"epss_score": 0.65759, "epss_percentile": 0.98438}, "CVE-2018-9846": {"epss_score": 0.00742, "epss_percentile": 0.7246}, "CVE-2018-9847": {"epss_score": 0.00944, "epss_percentile": 0.75783}, "CVE-2018-9848": {"epss_score": 0.00944, "epss_percentile": 0.75783}, "CVE-2018-9849": {"epss_score": 0.00444, "epss_percentile": 0.62845}, "CVE-2018-9850": {"epss_score": 0.00425, "epss_percentile": 0.61724}, "CVE-2018-9851": {"epss_score": 0.00374, "epss_percentile": 0.58537}, "CVE-2018-9852": {"epss_score": 0.00437, "epss_percentile": 0.62511}, "CVE-2018-9853": {"epss_score": 0.0035, "epss_percentile": 0.56975}, "CVE-2018-9856": {"epss_score": 0.00134, "epss_percentile": 0.33789}, "CVE-2018-9857": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2018-9859": {"epss_score": 0.00478, "epss_percentile": 0.64385}, "CVE-2018-9860": {"epss_score": 0.00499, "epss_percentile": 0.65256}, "CVE-2018-9861": {"epss_score": 0.00369, "epss_percentile": 0.58254}, "CVE-2018-9862": {"epss_score": 0.00058, "epss_percentile": 0.18545}, "CVE-2018-9864": {"epss_score": 0.0038, "epss_percentile": 0.5893}, "CVE-2018-9866": {"epss_score": 0.11744, "epss_percentile": 0.93464}, "CVE-2018-9867": {"epss_score": 0.00022, "epss_percentile": 0.05137}, "CVE-2018-9918": {"epss_score": 0.00794, "epss_percentile": 0.73441}, "CVE-2018-9919": {"epss_score": 0.04704, "epss_percentile": 0.89029}, "CVE-2018-9920": {"epss_score": 0.00166, "epss_percentile": 0.38194}, "CVE-2018-9921": {"epss_score": 0.00353, "epss_percentile": 0.57189}, "CVE-2018-9922": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2018-9923": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2018-9924": {"epss_score": 0.0025, "epss_percentile": 0.4824}, "CVE-2018-9925": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2018-9926": {"epss_score": 0.00314, "epss_percentile": 0.5411}, "CVE-2018-9927": {"epss_score": 0.00134, "epss_percentile": 0.33789}, "CVE-2018-9928": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2018-9934": {"epss_score": 0.00399, "epss_percentile": 0.60108}, "CVE-2018-9935": {"epss_score": 0.00529, "epss_percentile": 0.66594}, "CVE-2018-9936": {"epss_score": 0.00223, "epss_percentile": 0.44894}, "CVE-2018-9937": {"epss_score": 0.00223, "epss_percentile": 0.44894}, "CVE-2018-9938": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2018-9939": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2018-9940": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2018-9941": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2018-9942": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2018-9943": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2018-9944": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9945": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9946": {"epss_score": 0.0019, "epss_percentile": 0.41125}, "CVE-2018-9947": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2018-9948": {"epss_score": 0.87256, "epss_percentile": 0.9942}, "CVE-2018-9949": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2018-9950": {"epss_score": 0.00362, "epss_percentile": 0.57795}, "CVE-2018-9951": {"epss_score": 0.00787, "epss_percentile": 0.73322}, "CVE-2018-9952": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9953": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9954": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9955": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9956": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9957": {"epss_score": 0.00328, "epss_percentile": 0.5517}, "CVE-2018-9958": {"epss_score": 0.86463, "epss_percentile": 0.99384}, "CVE-2018-9959": {"epss_score": 0.00328, "epss_percentile": 0.5517}, "CVE-2018-9960": {"epss_score": 0.00328, "epss_percentile": 0.5517}, "CVE-2018-9961": {"epss_score": 0.00328, "epss_percentile": 0.5517}, "CVE-2018-9962": {"epss_score": 0.00328, "epss_percentile": 0.5517}, "CVE-2018-9963": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-9964": {"epss_score": 0.00328, "epss_percentile": 0.5517}, "CVE-2018-9965": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9966": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9967": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9968": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9969": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9970": {"epss_score": 0.00529, "epss_percentile": 0.66594}, "CVE-2018-9971": {"epss_score": 0.0218, "epss_percentile": 0.83897}, "CVE-2018-9972": {"epss_score": 0.00391, "epss_percentile": 0.59569}, "CVE-2018-9973": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-9974": {"epss_score": 0.00515, "epss_percentile": 0.65998}, "CVE-2018-9975": {"epss_score": 0.00367, "epss_percentile": 0.58155}, "CVE-2018-9976": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-9977": {"epss_score": 0.00328, "epss_percentile": 0.5517}, "CVE-2018-9978": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-9979": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-9980": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-9981": {"epss_score": 0.00328, "epss_percentile": 0.5517}, "CVE-2018-9982": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2018-9983": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-9984": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2018-9985": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2018-9986": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-9987": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-9988": {"epss_score": 0.00652, "epss_percentile": 0.70313}, "CVE-2018-9989": {"epss_score": 0.00403, "epss_percentile": 0.6035}, "CVE-2018-9990": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2018-9991": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-9992": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-9993": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2018-9995": {"epss_score": 0.94122, "epss_percentile": 0.99906}, "CVE-2018-9996": {"epss_score": 0.00385, "epss_percentile": 0.59192}, "CVE-2018-9997": {"epss_score": 0.00278, "epss_percentile": 0.50866}, "CVE-2018-9998": {"epss_score": 0.00396, "epss_percentile": 0.59906}, "CVE-2018-9999": {"epss_score": 0.00254, "epss_percentile": 0.48499}, "CVE-2019-0001": {"epss_score": 0.00623, "epss_percentile": 0.69535}, "CVE-2019-0002": {"epss_score": 0.00273, "epss_percentile": 0.50444}, "CVE-2019-0003": {"epss_score": 0.0054, "epss_percentile": 0.66997}, "CVE-2019-0004": {"epss_score": 0.00049, "epss_percentile": 0.15436}, "CVE-2019-0005": {"epss_score": 0.00209, "epss_percentile": 0.43408}, "CVE-2019-0006": {"epss_score": 0.05923, "epss_percentile": 0.90324}, "CVE-2019-0007": {"epss_score": 0.00502, "epss_percentile": 0.65412}, "CVE-2019-0008": {"epss_score": 0.04767, "epss_percentile": 0.89124}, "CVE-2019-0009": {"epss_score": 0.00051, "epss_percentile": 0.1627}, "CVE-2019-0010": {"epss_score": 0.01114, "epss_percentile": 0.77704}, "CVE-2019-0011": {"epss_score": 0.00195, "epss_percentile": 0.41632}, "CVE-2019-0012": {"epss_score": 0.00406, "epss_percentile": 0.60539}, "CVE-2019-0013": {"epss_score": 0.00308, "epss_percentile": 0.53594}, "CVE-2019-0014": {"epss_score": 0.00476, "epss_percentile": 0.64254}, "CVE-2019-0015": {"epss_score": 0.00193, "epss_percentile": 0.41402}, "CVE-2019-0016": {"epss_score": 0.00168, "epss_percentile": 0.38493}, "CVE-2019-0017": {"epss_score": 0.00229, "epss_percentile": 0.45609}, "CVE-2019-0018": {"epss_score": 0.00262, "epss_percentile": 0.49347}, "CVE-2019-0019": {"epss_score": 0.00494, "epss_percentile": 0.6509}, "CVE-2019-0020": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2019-0021": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2019-0022": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2019-0023": {"epss_score": 0.00262, "epss_percentile": 0.49347}, "CVE-2019-0024": {"epss_score": 0.00291, "epss_percentile": 0.52186}, "CVE-2019-0025": {"epss_score": 0.00231, "epss_percentile": 0.45801}, "CVE-2019-0026": {"epss_score": 0.00231, "epss_percentile": 0.45801}, "CVE-2019-0027": {"epss_score": 0.00231, "epss_percentile": 0.45801}, "CVE-2019-0028": {"epss_score": 0.00566, "epss_percentile": 0.67824}, "CVE-2019-0029": {"epss_score": 0.00049, "epss_percentile": 0.15436}, "CVE-2019-0030": {"epss_score": 0.00064, "epss_percentile": 0.20424}, "CVE-2019-0031": {"epss_score": 0.00519, "epss_percentile": 0.66179}, "CVE-2019-0032": {"epss_score": 0.0016, "epss_percentile": 0.3748}, "CVE-2019-0033": {"epss_score": 0.00494, "epss_percentile": 0.6509}, "CVE-2019-0035": {"epss_score": 0.00039, "epss_percentile": 0.11571}, "CVE-2019-0036": {"epss_score": 0.00255, "epss_percentile": 0.48639}, "CVE-2019-0037": {"epss_score": 0.00802, "epss_percentile": 0.7359}, "CVE-2019-0038": {"epss_score": 0.00088, "epss_percentile": 0.25692}, "CVE-2019-0039": {"epss_score": 0.00288, "epss_percentile": 0.5198}, "CVE-2019-0040": {"epss_score": 0.00544, "epss_percentile": 0.67149}, "CVE-2019-0041": {"epss_score": 0.00277, "epss_percentile": 0.50792}, "CVE-2019-0042": {"epss_score": 0.00047, "epss_percentile": 0.14662}, "CVE-2019-0043": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-0044": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2019-0046": {"epss_score": 0.00109, "epss_percentile": 0.30025}, "CVE-2019-0047": {"epss_score": 0.00646, "epss_percentile": 0.70149}, "CVE-2019-0048": {"epss_score": 0.00208, "epss_percentile": 0.43238}, "CVE-2019-0049": {"epss_score": 0.00495, "epss_percentile": 0.65121}, "CVE-2019-0050": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-0051": {"epss_score": 0.00236, "epss_percentile": 0.46423}, "CVE-2019-0052": {"epss_score": 0.00353, "epss_percentile": 0.57183}, "CVE-2019-0053": {"epss_score": 0.00071, "epss_percentile": 0.22162}, "CVE-2019-0054": {"epss_score": 0.00081, "epss_percentile": 0.24333}, "CVE-2019-0055": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2019-0056": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-0057": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2019-0058": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2019-0059": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-0060": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2019-0061": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2019-0062": {"epss_score": 0.00357, "epss_percentile": 0.57475}, "CVE-2019-0063": {"epss_score": 0.00205, "epss_percentile": 0.42752}, "CVE-2019-0064": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-0065": {"epss_score": 0.00277, "epss_percentile": 0.50844}, "CVE-2019-0066": {"epss_score": 0.00467, "epss_percentile": 0.63836}, "CVE-2019-0067": {"epss_score": 0.00076, "epss_percentile": 0.23113}, "CVE-2019-0068": {"epss_score": 0.00277, "epss_percentile": 0.50844}, "CVE-2019-0069": {"epss_score": 0.0002, "epss_percentile": 0.04686}, "CVE-2019-0070": {"epss_score": 0.00028, "epss_percentile": 0.07521}, "CVE-2019-0071": {"epss_score": 8e-05, "epss_percentile": 0.00489}, "CVE-2019-0072": {"epss_score": 0.00023, "epss_percentile": 0.05342}, "CVE-2019-0073": {"epss_score": 0.00033, "epss_percentile": 0.09361}, "CVE-2019-0074": {"epss_score": 0.00041, "epss_percentile": 0.12271}, "CVE-2019-0075": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-0086": {"epss_score": 0.00126, "epss_percentile": 0.3275}, "CVE-2019-0088": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2019-0089": {"epss_score": 0.00133, "epss_percentile": 0.33642}, "CVE-2019-0090": {"epss_score": 0.00445, "epss_percentile": 0.62888}, "CVE-2019-0091": {"epss_score": 0.00118, "epss_percentile": 0.31401}, "CVE-2019-0092": {"epss_score": 0.00136, "epss_percentile": 0.34128}, "CVE-2019-0093": {"epss_score": 0.00124, "epss_percentile": 0.32461}, "CVE-2019-0094": {"epss_score": 0.0018, "epss_percentile": 0.3997}, "CVE-2019-0096": {"epss_score": 0.00246, "epss_percentile": 0.47733}, "CVE-2019-0097": {"epss_score": 0.00341, "epss_percentile": 0.56292}, "CVE-2019-0098": {"epss_score": 0.00165, "epss_percentile": 0.38125}, "CVE-2019-0099": {"epss_score": 0.00064, "epss_percentile": 0.20184}, "CVE-2019-0101": {"epss_score": 0.00842, "epss_percentile": 0.74237}, "CVE-2019-0102": {"epss_score": 0.02606, "epss_percentile": 0.85225}, "CVE-2019-0103": {"epss_score": 0.0032, "epss_percentile": 0.54599}, "CVE-2019-0104": {"epss_score": 0.0018, "epss_percentile": 0.39887}, "CVE-2019-0105": {"epss_score": 0.00132, "epss_percentile": 0.33574}, "CVE-2019-0106": {"epss_score": 0.00244, "epss_percentile": 0.47527}, "CVE-2019-0107": {"epss_score": 0.00244, "epss_percentile": 0.47527}, "CVE-2019-0108": {"epss_score": 0.00116, "epss_percentile": 0.31187}, "CVE-2019-0109": {"epss_score": 0.00131, "epss_percentile": 0.33344}, "CVE-2019-0110": {"epss_score": 0.0018, "epss_percentile": 0.39887}, "CVE-2019-0111": {"epss_score": 0.00116, "epss_percentile": 0.31187}, "CVE-2019-0112": {"epss_score": 0.00277, "epss_percentile": 0.50781}, "CVE-2019-0113": {"epss_score": 0.00058, "epss_percentile": 0.18359}, "CVE-2019-0114": {"epss_score": 0.00045, "epss_percentile": 0.13759}, "CVE-2019-0115": {"epss_score": 0.00122, "epss_percentile": 0.3215}, "CVE-2019-0116": {"epss_score": 0.00056, "epss_percentile": 0.17726}, "CVE-2019-0117": {"epss_score": 0.00129, "epss_percentile": 0.33144}, "CVE-2019-0119": {"epss_score": 0.00138, "epss_percentile": 0.3441}, "CVE-2019-0120": {"epss_score": 0.00115, "epss_percentile": 0.30902}, "CVE-2019-0121": {"epss_score": 0.00044, "epss_percentile": 0.13366}, "CVE-2019-0122": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2019-0123": {"epss_score": 0.00136, "epss_percentile": 0.34168}, "CVE-2019-0124": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2019-0126": {"epss_score": 0.00131, "epss_percentile": 0.33477}, "CVE-2019-0127": {"epss_score": 0.0006, "epss_percentile": 0.19018}, "CVE-2019-0128": {"epss_score": 0.00071, "epss_percentile": 0.22123}, "CVE-2019-0129": {"epss_score": 0.00104, "epss_percentile": 0.29155}, "CVE-2019-0130": {"epss_score": 0.01066, "epss_percentile": 0.77221}, "CVE-2019-0131": {"epss_score": 0.0021, "epss_percentile": 0.43466}, "CVE-2019-0132": {"epss_score": 0.00536, "epss_percentile": 0.66867}, "CVE-2019-0134": {"epss_score": 0.00082, "epss_percentile": 0.24546}, "CVE-2019-0135": {"epss_score": 0.00104, "epss_percentile": 0.29155}, "CVE-2019-0136": {"epss_score": 0.0105, "epss_percentile": 0.77066}, "CVE-2019-0138": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2019-0139": {"epss_score": 0.00124, "epss_percentile": 0.3243}, "CVE-2019-0140": {"epss_score": 0.00366, "epss_percentile": 0.5809}, "CVE-2019-0142": {"epss_score": 0.00116, "epss_percentile": 0.31084}, "CVE-2019-0143": {"epss_score": 0.00171, "epss_percentile": 0.38862}, "CVE-2019-0144": {"epss_score": 0.00171, "epss_percentile": 0.38862}, "CVE-2019-0145": {"epss_score": 0.00048, "epss_percentile": 0.15258}, "CVE-2019-0146": {"epss_score": 0.00147, "epss_percentile": 0.35654}, "CVE-2019-0147": {"epss_score": 0.00053, "epss_percentile": 0.16883}, "CVE-2019-0148": {"epss_score": 0.00147, "epss_percentile": 0.35654}, "CVE-2019-0149": {"epss_score": 0.00143, "epss_percentile": 0.35202}, "CVE-2019-0150": {"epss_score": 0.00049, "epss_percentile": 0.15309}, "CVE-2019-0151": {"epss_score": 0.00153, "epss_percentile": 0.36507}, "CVE-2019-0152": {"epss_score": 0.00335, "epss_percentile": 0.55803}, "CVE-2019-0153": {"epss_score": 0.005, "epss_percentile": 0.65305}, "CVE-2019-0154": {"epss_score": 0.00106, "epss_percentile": 0.29506}, "CVE-2019-0155": {"epss_score": 0.00092, "epss_percentile": 0.26448}, "CVE-2019-0157": {"epss_score": 0.00088, "epss_percentile": 0.25665}, "CVE-2019-0158": {"epss_score": 0.00066, "epss_percentile": 0.20828}, "CVE-2019-0159": {"epss_score": 0.00377, "epss_percentile": 0.58772}, "CVE-2019-0160": {"epss_score": 0.0028, "epss_percentile": 0.51065}, "CVE-2019-0161": {"epss_score": 0.00046, "epss_percentile": 0.14345}, "CVE-2019-0162": {"epss_score": 0.01456, "epss_percentile": 0.80393}, "CVE-2019-0163": {"epss_score": 0.00052, "epss_percentile": 0.16512}, "CVE-2019-0164": {"epss_score": 0.00071, "epss_percentile": 0.22123}, "CVE-2019-0165": {"epss_score": 0.00134, "epss_percentile": 0.33831}, "CVE-2019-0166": {"epss_score": 0.00928, "epss_percentile": 0.75584}, "CVE-2019-0168": {"epss_score": 0.00141, "epss_percentile": 0.34899}, "CVE-2019-0169": {"epss_score": 0.00278, "epss_percentile": 0.50923}, "CVE-2019-0170": {"epss_score": 0.00164, "epss_percentile": 0.37913}, "CVE-2019-0171": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2019-0172": {"epss_score": 0.00775, "epss_percentile": 0.73083}, "CVE-2019-0173": {"epss_score": 0.00389, "epss_percentile": 0.59409}, "CVE-2019-0174": {"epss_score": 0.00188, "epss_percentile": 0.40874}, "CVE-2019-0175": {"epss_score": 0.00045, "epss_percentile": 0.1389}, "CVE-2019-0177": {"epss_score": 0.00046, "epss_percentile": 0.14133}, "CVE-2019-0178": {"epss_score": 0.00045, "epss_percentile": 0.1389}, "CVE-2019-0179": {"epss_score": 0.00045, "epss_percentile": 0.1389}, "CVE-2019-0180": {"epss_score": 0.00045, "epss_percentile": 0.1389}, "CVE-2019-0181": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2019-0182": {"epss_score": 0.00046, "epss_percentile": 0.14419}, "CVE-2019-0183": {"epss_score": 0.00046, "epss_percentile": 0.14419}, "CVE-2019-0184": {"epss_score": 0.00139, "epss_percentile": 0.34544}, "CVE-2019-0185": {"epss_score": 0.00139, "epss_percentile": 0.34544}, "CVE-2019-0186": {"epss_score": 0.06783, "epss_percentile": 0.91025}, "CVE-2019-0187": {"epss_score": 0.00635, "epss_percentile": 0.69823}, "CVE-2019-0188": {"epss_score": 0.00969, "epss_percentile": 0.76097}, "CVE-2019-0189": {"epss_score": 0.30507, "epss_percentile": 0.96546}, "CVE-2019-0190": {"epss_score": 0.18924, "epss_percentile": 0.95097}, "CVE-2019-0191": {"epss_score": 0.03764, "epss_percentile": 0.87694}, "CVE-2019-0192": {"epss_score": 0.9304, "epss_percentile": 0.99769}, "CVE-2019-0193": {"epss_score": 0.93202, "epss_percentile": 0.99782}, "CVE-2019-0194": {"epss_score": 0.0257, "epss_percentile": 0.85127}, "CVE-2019-0195": {"epss_score": 0.15518, "epss_percentile": 0.94444}, "CVE-2019-0196": {"epss_score": 0.09659, "epss_percentile": 0.92644}, "CVE-2019-0197": {"epss_score": 0.02274, "epss_percentile": 0.84223}, "CVE-2019-0199": {"epss_score": 0.66569, "epss_percentile": 0.98469}, "CVE-2019-0200": {"epss_score": 0.02923, "epss_percentile": 0.86001}, "CVE-2019-0201": {"epss_score": 0.00216, "epss_percentile": 0.44204}, "CVE-2019-0202": {"epss_score": 0.00641, "epss_percentile": 0.70012}, "CVE-2019-0203": {"epss_score": 0.06638, "epss_percentile": 0.90909}, "CVE-2019-0204": {"epss_score": 0.00183, "epss_percentile": 0.40349}, "CVE-2019-0205": {"epss_score": 0.00698, "epss_percentile": 0.71428}, "CVE-2019-0207": {"epss_score": 0.01011, "epss_percentile": 0.7661}, "CVE-2019-0210": {"epss_score": 0.00365, "epss_percentile": 0.57995}, "CVE-2019-0211": {"epss_score": 0.89519, "epss_percentile": 0.9953}, "CVE-2019-0212": {"epss_score": 0.04214, "epss_percentile": 0.88404}, "CVE-2019-0213": {"epss_score": 0.00611, "epss_percentile": 0.69192}, "CVE-2019-0214": {"epss_score": 0.01743, "epss_percentile": 0.82058}, "CVE-2019-0215": {"epss_score": 0.08965, "epss_percentile": 0.9234}, "CVE-2019-0216": {"epss_score": 0.00704, "epss_percentile": 0.71557}, "CVE-2019-0217": {"epss_score": 0.47204, "epss_percentile": 0.97575}, "CVE-2019-0218": {"epss_score": 0.01799, "epss_percentile": 0.82316}, "CVE-2019-0219": {"epss_score": 0.08908, "epss_percentile": 0.92311}, "CVE-2019-0220": {"epss_score": 0.20573, "epss_percentile": 0.95378}, "CVE-2019-0221": {"epss_score": 0.43363, "epss_percentile": 0.97382}, "CVE-2019-0222": {"epss_score": 0.10459, "epss_percentile": 0.92993}, "CVE-2019-0223": {"epss_score": 0.00407, "epss_percentile": 0.60605}, "CVE-2019-0224": {"epss_score": 0.02548, "epss_percentile": 0.85067}, "CVE-2019-0225": {"epss_score": 0.03593, "epss_percentile": 0.87402}, "CVE-2019-0226": {"epss_score": 0.01615, "epss_percentile": 0.81347}, "CVE-2019-0227": {"epss_score": 0.90738, "epss_percentile": 0.99598}, "CVE-2019-0228": {"epss_score": 0.13424, "epss_percentile": 0.93959}, "CVE-2019-0229": {"epss_score": 0.00401, "epss_percentile": 0.60205}, "CVE-2019-0230": {"epss_score": 0.93727, "epss_percentile": 0.99837}, "CVE-2019-0231": {"epss_score": 0.00707, "epss_percentile": 0.71644}, "CVE-2019-0232": {"epss_score": 0.94225, "epss_percentile": 0.99919}, "CVE-2019-0233": {"epss_score": 0.09311, "epss_percentile": 0.92496}, "CVE-2019-0234": {"epss_score": 0.00976, "epss_percentile": 0.76209}, "CVE-2019-0235": {"epss_score": 0.26016, "epss_percentile": 0.961}, "CVE-2019-0238": {"epss_score": 0.00313, "epss_percentile": 0.54069}, "CVE-2019-0240": {"epss_score": 0.00608, "epss_percentile": 0.69072}, "CVE-2019-0241": {"epss_score": 0.00608, "epss_percentile": 0.69072}, "CVE-2019-0243": {"epss_score": 0.00494, "epss_percentile": 0.65071}, "CVE-2019-0244": {"epss_score": 0.00299, "epss_percentile": 0.52889}, "CVE-2019-0245": {"epss_score": 0.00299, "epss_percentile": 0.52889}, "CVE-2019-0246": {"epss_score": 0.03169, "epss_percentile": 0.86546}, "CVE-2019-0247": {"epss_score": 0.00569, "epss_percentile": 0.67935}, "CVE-2019-0248": {"epss_score": 0.00365, "epss_percentile": 0.5796}, "CVE-2019-0249": {"epss_score": 0.00365, "epss_percentile": 0.5796}, "CVE-2019-0251": {"epss_score": 0.00327, "epss_percentile": 0.55113}, "CVE-2019-0254": {"epss_score": 0.00312, "epss_percentile": 0.53987}, "CVE-2019-0255": {"epss_score": 0.00354, "epss_percentile": 0.57218}, "CVE-2019-0256": {"epss_score": 0.00077, "epss_percentile": 0.23433}, "CVE-2019-0257": {"epss_score": 0.00587, "epss_percentile": 0.68478}, "CVE-2019-0258": {"epss_score": 0.00452, "epss_percentile": 0.63172}, "CVE-2019-0259": {"epss_score": 0.00712, "epss_percentile": 0.71746}, "CVE-2019-0261": {"epss_score": 0.03289, "epss_percentile": 0.86834}, "CVE-2019-0262": {"epss_score": 0.00312, "epss_percentile": 0.53987}, "CVE-2019-0265": {"epss_score": 0.01214, "epss_percentile": 0.7858}, "CVE-2019-0266": {"epss_score": 0.00378, "epss_percentile": 0.58835}, "CVE-2019-0267": {"epss_score": 0.00196, "epss_percentile": 0.41809}, "CVE-2019-0268": {"epss_score": 0.0074, "epss_percentile": 0.72406}, "CVE-2019-0269": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2019-0270": {"epss_score": 0.00452, "epss_percentile": 0.63172}, "CVE-2019-0271": {"epss_score": 0.00604, "epss_percentile": 0.68964}, "CVE-2019-0274": {"epss_score": 0.00632, "epss_percentile": 0.6974}, "CVE-2019-0275": {"epss_score": 0.00247, "epss_percentile": 0.47901}, "CVE-2019-0276": {"epss_score": 0.00513, "epss_percentile": 0.65925}, "CVE-2019-0277": {"epss_score": 0.00762, "epss_percentile": 0.72835}, "CVE-2019-0278": {"epss_score": 0.00197, "epss_percentile": 0.41875}, "CVE-2019-0279": {"epss_score": 0.00335, "epss_percentile": 0.55851}, "CVE-2019-0280": {"epss_score": 0.00384, "epss_percentile": 0.59169}, "CVE-2019-0281": {"epss_score": 0.00293, "epss_percentile": 0.52333}, "CVE-2019-0282": {"epss_score": 0.00152, "epss_percentile": 0.36437}, "CVE-2019-0283": {"epss_score": 0.00126, "epss_percentile": 0.32625}, "CVE-2019-0284": {"epss_score": 0.00044, "epss_percentile": 0.13639}, "CVE-2019-0285": {"epss_score": 0.07545, "epss_percentile": 0.91529}, "CVE-2019-0287": {"epss_score": 0.00498, "epss_percentile": 0.65238}, "CVE-2019-0289": {"epss_score": 0.00288, "epss_percentile": 0.51875}, "CVE-2019-0291": {"epss_score": 0.00079, "epss_percentile": 0.23823}, "CVE-2019-0293": {"epss_score": 0.0022, "epss_percentile": 0.44604}, "CVE-2019-0298": {"epss_score": 0.00293, "epss_percentile": 0.52333}, "CVE-2019-0301": {"epss_score": 0.00334, "epss_percentile": 0.5574}, "CVE-2019-0303": {"epss_score": 0.00231, "epss_percentile": 0.45811}, "CVE-2019-0304": {"epss_score": 0.00503, "epss_percentile": 0.65443}, "CVE-2019-0305": {"epss_score": 0.00162, "epss_percentile": 0.3766}, "CVE-2019-0306": {"epss_score": 0.00197, "epss_percentile": 0.41961}, "CVE-2019-0307": {"epss_score": 0.06135, "epss_percentile": 0.90507}, "CVE-2019-0308": {"epss_score": 0.00221, "epss_percentile": 0.44653}, "CVE-2019-0311": {"epss_score": 0.00231, "epss_percentile": 0.45811}, "CVE-2019-0312": {"epss_score": 0.00176, "epss_percentile": 0.39491}, "CVE-2019-0314": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2019-0315": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2019-0316": {"epss_score": 0.002, "epss_percentile": 0.42212}, "CVE-2019-0318": {"epss_score": 0.00335, "epss_percentile": 0.55853}, "CVE-2019-0319": {"epss_score": 0.00817, "epss_percentile": 0.73844}, "CVE-2019-0321": {"epss_score": 0.00293, "epss_percentile": 0.52333}, "CVE-2019-0322": {"epss_score": 0.00644, "epss_percentile": 0.7009}, "CVE-2019-0325": {"epss_score": 0.00159, "epss_percentile": 0.37407}, "CVE-2019-0326": {"epss_score": 0.00293, "epss_percentile": 0.52333}, "CVE-2019-0327": {"epss_score": 0.00718, "epss_percentile": 0.71932}, "CVE-2019-0328": {"epss_score": 0.00867, "epss_percentile": 0.74656}, "CVE-2019-0329": {"epss_score": 0.00293, "epss_percentile": 0.52333}, "CVE-2019-0330": {"epss_score": 0.00774, "epss_percentile": 0.73068}, "CVE-2019-0331": {"epss_score": 0.00206, "epss_percentile": 0.43053}, "CVE-2019-0332": {"epss_score": 0.00231, "epss_percentile": 0.45811}, "CVE-2019-0333": {"epss_score": 0.0027, "epss_percentile": 0.50236}, "CVE-2019-0334": {"epss_score": 0.00221, "epss_percentile": 0.44639}, "CVE-2019-0335": {"epss_score": 0.00231, "epss_percentile": 0.45811}, "CVE-2019-0337": {"epss_score": 0.00208, "epss_percentile": 0.43289}, "CVE-2019-0338": {"epss_score": 0.00206, "epss_percentile": 0.43053}, "CVE-2019-0340": {"epss_score": 0.00126, "epss_percentile": 0.32625}, "CVE-2019-0341": {"epss_score": 0.00219, "epss_percentile": 0.44481}, "CVE-2019-0343": {"epss_score": 0.00485, "epss_percentile": 0.64718}, "CVE-2019-0344": {"epss_score": 0.52444, "epss_percentile": 0.97826}, "CVE-2019-0345": {"epss_score": 0.01025, "epss_percentile": 0.76786}, "CVE-2019-0346": {"epss_score": 0.00171, "epss_percentile": 0.38889}, "CVE-2019-0348": {"epss_score": 0.00126, "epss_percentile": 0.32725}, "CVE-2019-0349": {"epss_score": 0.00354, "epss_percentile": 0.57213}, "CVE-2019-0350": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2019-0351": {"epss_score": 0.02165, "epss_percentile": 0.83845}, "CVE-2019-0352": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2019-0353": {"epss_score": 0.00047, "epss_percentile": 0.14771}, "CVE-2019-0355": {"epss_score": 0.00447, "epss_percentile": 0.62948}, "CVE-2019-0356": {"epss_score": 0.00197, "epss_percentile": 0.41875}, "CVE-2019-0357": {"epss_score": 0.00029, "epss_percentile": 0.07634}, "CVE-2019-0361": {"epss_score": 0.00262, "epss_percentile": 0.49357}, "CVE-2019-0363": {"epss_score": 0.00371, "epss_percentile": 0.58372}, "CVE-2019-0364": {"epss_score": 0.00197, "epss_percentile": 0.41875}, "CVE-2019-0365": {"epss_score": 0.0032, "epss_percentile": 0.54576}, "CVE-2019-0367": {"epss_score": 0.00174, "epss_percentile": 0.39204}, "CVE-2019-0368": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2019-0369": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2019-0370": {"epss_score": 0.0034, "epss_percentile": 0.56217}, "CVE-2019-0374": {"epss_score": 0.00462, "epss_percentile": 0.63579}, "CVE-2019-0375": {"epss_score": 0.00462, "epss_percentile": 0.63579}, "CVE-2019-0376": {"epss_score": 0.00298, "epss_percentile": 0.52816}, "CVE-2019-0377": {"epss_score": 0.00298, "epss_percentile": 0.52816}, "CVE-2019-0378": {"epss_score": 0.00298, "epss_percentile": 0.52816}, "CVE-2019-0379": {"epss_score": 0.00154, "epss_percentile": 0.36746}, "CVE-2019-0380": {"epss_score": 0.00335, "epss_percentile": 0.55895}, "CVE-2019-0381": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2019-0382": {"epss_score": 0.0035, "epss_percentile": 0.56921}, "CVE-2019-0383": {"epss_score": 0.00406, "epss_percentile": 0.60523}, "CVE-2019-0384": {"epss_score": 0.00352, "epss_percentile": 0.57127}, "CVE-2019-0385": {"epss_score": 0.0035, "epss_percentile": 0.56921}, "CVE-2019-0386": {"epss_score": 0.00251, "epss_percentile": 0.48315}, "CVE-2019-0388": {"epss_score": 0.00247, "epss_percentile": 0.47893}, "CVE-2019-0389": {"epss_score": 0.00457, "epss_percentile": 0.63383}, "CVE-2019-0390": {"epss_score": 0.00302, "epss_percentile": 0.53106}, "CVE-2019-0391": {"epss_score": 0.00272, "epss_percentile": 0.50373}, "CVE-2019-0393": {"epss_score": 0.00315, "epss_percentile": 0.54202}, "CVE-2019-0395": {"epss_score": 0.00496, "epss_percentile": 0.65167}, "CVE-2019-0396": {"epss_score": 0.00425, "epss_percentile": 0.61715}, "CVE-2019-0398": {"epss_score": 0.00168, "epss_percentile": 0.38417}, "CVE-2019-0399": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2019-0402": {"epss_score": 0.0005, "epss_percentile": 0.15899}, "CVE-2019-0403": {"epss_score": 0.06684, "epss_percentile": 0.90942}, "CVE-2019-0404": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2019-0405": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2019-0536": {"epss_score": 0.0031, "epss_percentile": 0.53761}, "CVE-2019-0537": {"epss_score": 0.26918, "epss_percentile": 0.96192}, "CVE-2019-0538": {"epss_score": 0.35437, "epss_percentile": 0.96909}, "CVE-2019-0539": {"epss_score": 0.9097, "epss_percentile": 0.99612}, "CVE-2019-0540": {"epss_score": 0.22182, "epss_percentile": 0.95604}, "CVE-2019-0541": {"epss_score": 0.80937, "epss_percentile": 0.99112}, "CVE-2019-0542": {"epss_score": 0.01687, "epss_percentile": 0.81755}, "CVE-2019-0543": {"epss_score": 0.16595, "epss_percentile": 0.94698}, "CVE-2019-0545": {"epss_score": 0.08427, "epss_percentile": 0.92047}, "CVE-2019-0546": {"epss_score": 0.2762, "epss_percentile": 0.96266}, "CVE-2019-0547": {"epss_score": 0.73119, "epss_percentile": 0.98737}, "CVE-2019-0548": {"epss_score": 0.06706, "epss_percentile": 0.90959}, "CVE-2019-0549": {"epss_score": 0.00998, "epss_percentile": 0.76475}, "CVE-2019-0550": {"epss_score": 0.00676, "epss_percentile": 0.70942}, "CVE-2019-0551": {"epss_score": 0.00676, "epss_percentile": 0.70942}, "CVE-2019-0552": {"epss_score": 0.00819, "epss_percentile": 0.73869}, "CVE-2019-0553": {"epss_score": 0.0031, "epss_percentile": 0.53761}, "CVE-2019-0554": {"epss_score": 0.0031, "epss_percentile": 0.53761}, "CVE-2019-0555": {"epss_score": 0.00772, "epss_percentile": 0.73036}, "CVE-2019-0556": {"epss_score": 0.0078, "epss_percentile": 0.73161}, "CVE-2019-0557": {"epss_score": 0.00792, "epss_percentile": 0.7341}, "CVE-2019-0558": {"epss_score": 0.00792, "epss_percentile": 0.7341}, "CVE-2019-0559": {"epss_score": 0.25751, "epss_percentile": 0.96065}, "CVE-2019-0560": {"epss_score": 0.26918, "epss_percentile": 0.96192}, "CVE-2019-0561": {"epss_score": 0.23103, "epss_percentile": 0.95735}, "CVE-2019-0562": {"epss_score": 0.0091, "epss_percentile": 0.75321}, "CVE-2019-0564": {"epss_score": 0.07639, "epss_percentile": 0.91593}, "CVE-2019-0565": {"epss_score": 0.09408, "epss_percentile": 0.92535}, "CVE-2019-0566": {"epss_score": 0.47662, "epss_percentile": 0.97595}, "CVE-2019-0567": {"epss_score": 0.89567, "epss_percentile": 0.99532}, "CVE-2019-0568": {"epss_score": 0.81478, "epss_percentile": 0.99141}, "CVE-2019-0569": {"epss_score": 0.0031, "epss_percentile": 0.53761}, "CVE-2019-0570": {"epss_score": 0.0084, "epss_percentile": 0.74206}, "CVE-2019-0571": {"epss_score": 0.08206, "epss_percentile": 0.9193}, "CVE-2019-0572": {"epss_score": 0.06361, "epss_percentile": 0.90699}, "CVE-2019-0573": {"epss_score": 0.14247, "epss_percentile": 0.94171}, "CVE-2019-0574": {"epss_score": 0.04024, "epss_percentile": 0.88138}, "CVE-2019-0575": {"epss_score": 0.2762, "epss_percentile": 0.96266}, "CVE-2019-0576": {"epss_score": 0.3427, "epss_percentile": 0.96838}, "CVE-2019-0577": {"epss_score": 0.30326, "epss_percentile": 0.96529}, "CVE-2019-0578": {"epss_score": 0.2762, "epss_percentile": 0.96266}, "CVE-2019-0579": {"epss_score": 0.30326, "epss_percentile": 0.96529}, "CVE-2019-0580": {"epss_score": 0.30326, "epss_percentile": 0.96529}, "CVE-2019-0581": {"epss_score": 0.2762, "epss_percentile": 0.96266}, "CVE-2019-0582": {"epss_score": 0.27254, "epss_percentile": 0.96228}, "CVE-2019-0583": {"epss_score": 0.2762, "epss_percentile": 0.96266}, "CVE-2019-0584": {"epss_score": 0.2762, "epss_percentile": 0.96266}, "CVE-2019-0585": {"epss_score": 0.28156, "epss_percentile": 0.96326}, "CVE-2019-0586": {"epss_score": 0.20842, "epss_percentile": 0.95423}, "CVE-2019-0588": {"epss_score": 0.02042, "epss_percentile": 0.83376}, "CVE-2019-0590": {"epss_score": 0.06192, "epss_percentile": 0.90553}, "CVE-2019-0591": {"epss_score": 0.06192, "epss_percentile": 0.90553}, "CVE-2019-0592": {"epss_score": 0.38317, "epss_percentile": 0.97095}, "CVE-2019-0593": {"epss_score": 0.34826, "epss_percentile": 0.96875}, "CVE-2019-0594": {"epss_score": 0.25766, "epss_percentile": 0.96067}, "CVE-2019-0595": {"epss_score": 0.30192, "epss_percentile": 0.96517}, "CVE-2019-0596": {"epss_score": 0.29762, "epss_percentile": 0.96473}, "CVE-2019-0597": {"epss_score": 0.29762, "epss_percentile": 0.96473}, "CVE-2019-0598": {"epss_score": 0.29762, "epss_percentile": 0.96473}, "CVE-2019-0599": {"epss_score": 0.29762, "epss_percentile": 0.96473}, "CVE-2019-0600": {"epss_score": 0.00357, "epss_percentile": 0.57459}, "CVE-2019-0601": {"epss_score": 0.00397, "epss_percentile": 0.59971}, "CVE-2019-0602": {"epss_score": 0.25751, "epss_percentile": 0.96065}, "CVE-2019-0603": {"epss_score": 0.40592, "epss_percentile": 0.97224}, "CVE-2019-0604": {"epss_score": 0.94441, "epss_percentile": 0.99988}, "CVE-2019-0605": {"epss_score": 0.06328, "epss_percentile": 0.90673}, "CVE-2019-0606": {"epss_score": 0.04701, "epss_percentile": 0.89026}, "CVE-2019-0607": {"epss_score": 0.06192, "epss_percentile": 0.90553}, "CVE-2019-0608": {"epss_score": 0.0217, "epss_percentile": 0.83868}, "CVE-2019-0609": {"epss_score": 0.0349, "epss_percentile": 0.8723}, "CVE-2019-0610": {"epss_score": 0.06192, "epss_percentile": 0.90553}, "CVE-2019-0611": {"epss_score": 0.04657, "epss_percentile": 0.88975}, "CVE-2019-0612": {"epss_score": 0.13975, "epss_percentile": 0.94104}, "CVE-2019-0613": {"epss_score": 0.1868, "epss_percentile": 0.95051}, "CVE-2019-0614": {"epss_score": 0.20668, "epss_percentile": 0.95399}, "CVE-2019-0615": {"epss_score": 0.25751, "epss_percentile": 0.96065}, "CVE-2019-0616": {"epss_score": 0.25751, "epss_percentile": 0.96065}, "CVE-2019-0617": {"epss_score": 0.25636, "epss_percentile": 0.96052}, "CVE-2019-0618": {"epss_score": 0.36292, "epss_percentile": 0.96966}, "CVE-2019-0619": {"epss_score": 0.25751, "epss_percentile": 0.96065}, "CVE-2019-0620": {"epss_score": 0.00401, "epss_percentile": 0.60247}, "CVE-2019-0621": {"epss_score": 0.00549, "epss_percentile": 0.6732}, "CVE-2019-0622": {"epss_score": 0.00481, "epss_percentile": 0.64481}, "CVE-2019-0623": {"epss_score": 0.34234, "epss_percentile": 0.96834}, "CVE-2019-0624": {"epss_score": 0.00431, "epss_percentile": 0.62064}, "CVE-2019-0625": {"epss_score": 0.31336, "epss_percentile": 0.96613}, "CVE-2019-0626": {"epss_score": 0.60814, "epss_percentile": 0.98222}, "CVE-2019-0627": {"epss_score": 0.00281, "epss_percentile": 0.5112}, "CVE-2019-0628": {"epss_score": 0.00495, "epss_percentile": 0.65103}, "CVE-2019-0630": {"epss_score": 0.35777, "epss_percentile": 0.96933}, "CVE-2019-0631": {"epss_score": 0.00288, "epss_percentile": 0.51868}, "CVE-2019-0632": {"epss_score": 0.00288, "epss_percentile": 0.51868}, "CVE-2019-0633": {"epss_score": 0.35777, "epss_percentile": 0.96933}, "CVE-2019-0634": {"epss_score": 0.05539, "epss_percentile": 0.89977}, "CVE-2019-0635": {"epss_score": 0.00423, "epss_percentile": 0.61618}, "CVE-2019-0636": {"epss_score": 0.00495, "epss_percentile": 0.65103}, "CVE-2019-0637": {"epss_score": 0.11646, "epss_percentile": 0.93427}, "CVE-2019-0639": {"epss_score": 0.11137, "epss_percentile": 0.93236}, "CVE-2019-0640": {"epss_score": 0.06192, "epss_percentile": 0.90553}, "CVE-2019-0641": {"epss_score": 0.11982, "epss_percentile": 0.93535}, "CVE-2019-0642": {"epss_score": 0.06192, "epss_percentile": 0.90553}, "CVE-2019-0643": {"epss_score": 0.09903, "epss_percentile": 0.92764}, "CVE-2019-0644": {"epss_score": 0.06192, "epss_percentile": 0.90553}, "CVE-2019-0645": {"epss_score": 0.05539, "epss_percentile": 0.89977}, "CVE-2019-0646": {"epss_score": 0.00431, "epss_percentile": 0.62064}, "CVE-2019-0647": {"epss_score": 0.08059, "epss_percentile": 0.91858}, "CVE-2019-0648": {"epss_score": 0.10949, "epss_percentile": 0.93171}, "CVE-2019-0649": {"epss_score": 0.0548, "epss_percentile": 0.89919}, "CVE-2019-0650": {"epss_score": 0.54023, "epss_percentile": 0.97908}, "CVE-2019-0651": {"epss_score": 0.05263, "epss_percentile": 0.8967}, "CVE-2019-0652": {"epss_score": 0.06192, "epss_percentile": 0.90553}, "CVE-2019-0654": {"epss_score": 0.03573, "epss_percentile": 0.87375}, "CVE-2019-0655": {"epss_score": 0.05263, "epss_percentile": 0.8967}, "CVE-2019-0656": {"epss_score": 0.00527, "epss_percentile": 0.66522}, "CVE-2019-0657": {"epss_score": 0.04981, "epss_percentile": 0.8936}, "CVE-2019-0658": {"epss_score": 0.27849, "epss_percentile": 0.96287}, "CVE-2019-0659": {"epss_score": 0.0029, "epss_percentile": 0.52124}, "CVE-2019-0660": {"epss_score": 0.25751, "epss_percentile": 0.96065}, "CVE-2019-0661": {"epss_score": 0.00495, "epss_percentile": 0.65103}, "CVE-2019-0662": {"epss_score": 0.30341, "epss_percentile": 0.96532}, "CVE-2019-0663": {"epss_score": 0.01706, "epss_percentile": 0.81854}, "CVE-2019-0664": {"epss_score": 0.25751, "epss_percentile": 0.96065}, "CVE-2019-0665": {"epss_score": 0.04162, "epss_percentile": 0.88338}, "CVE-2019-0666": {"epss_score": 0.0563, "epss_percentile": 0.90068}, "CVE-2019-0667": {"epss_score": 0.45267, "epss_percentile": 0.97479}, "CVE-2019-0668": {"epss_score": 0.05484, "epss_percentile": 0.89921}, "CVE-2019-0669": {"epss_score": 0.25751, "epss_percentile": 0.96065}, "CVE-2019-0670": {"epss_score": 0.00421, "epss_percentile": 0.61466}, "CVE-2019-0671": {"epss_score": 0.31336, "epss_percentile": 0.96613}, "CVE-2019-0672": {"epss_score": 0.29762, "epss_percentile": 0.96473}, "CVE-2019-0673": {"epss_score": 0.29762, "epss_percentile": 0.96473}, "CVE-2019-0674": {"epss_score": 0.31336, "epss_percentile": 0.96613}, "CVE-2019-0675": {"epss_score": 0.29762, "epss_percentile": 0.96473}, "CVE-2019-0676": {"epss_score": 0.15148, "epss_percentile": 0.94373}, "CVE-2019-0678": {"epss_score": 0.04595, "epss_percentile": 0.88895}, "CVE-2019-0680": {"epss_score": 0.04162, "epss_percentile": 0.88338}, "CVE-2019-0682": {"epss_score": 0.004, "epss_percentile": 0.60195}, "CVE-2019-0683": {"epss_score": 0.04281, "epss_percentile": 0.8849}, "CVE-2019-0685": {"epss_score": 0.00549, "epss_percentile": 0.67302}, "CVE-2019-0686": {"epss_score": 0.03231, "epss_percentile": 0.86698}, "CVE-2019-0688": {"epss_score": 0.10301, "epss_percentile": 0.92934}, "CVE-2019-0689": {"epss_score": 0.004, "epss_percentile": 0.60195}, "CVE-2019-0690": {"epss_score": 0.00375, "epss_percentile": 0.58617}, "CVE-2019-0692": {"epss_score": 0.004, "epss_percentile": 0.60195}, "CVE-2019-0693": {"epss_score": 0.004, "epss_percentile": 0.60195}, "CVE-2019-0694": {"epss_score": 0.004, "epss_percentile": 0.60195}, "CVE-2019-0695": {"epss_score": 0.00375, "epss_percentile": 0.58617}, "CVE-2019-0696": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-0697": {"epss_score": 0.30454, "epss_percentile": 0.96541}, "CVE-2019-0698": {"epss_score": 0.46058, "epss_percentile": 0.97519}, "CVE-2019-0701": {"epss_score": 0.00375, "epss_percentile": 0.58617}, "CVE-2019-0702": {"epss_score": 0.00881, "epss_percentile": 0.74871}, "CVE-2019-0703": {"epss_score": 0.19868, "epss_percentile": 0.95253}, "CVE-2019-0704": {"epss_score": 0.14208, "epss_percentile": 0.94163}, "CVE-2019-0707": {"epss_score": 0.00249, "epss_percentile": 0.48048}, "CVE-2019-0708": {"epss_score": 0.94456, "epss_percentile": 0.99992}, "CVE-2019-0709": {"epss_score": 0.40137, "epss_percentile": 0.97198}, "CVE-2019-0710": {"epss_score": 0.00492, "epss_percentile": 0.64986}, "CVE-2019-0711": {"epss_score": 0.00492, "epss_percentile": 0.64986}, "CVE-2019-0712": {"epss_score": 0.00983, "epss_percentile": 0.763}, "CVE-2019-0713": {"epss_score": 0.00492, "epss_percentile": 0.64986}, "CVE-2019-0714": {"epss_score": 0.01023, "epss_percentile": 0.76773}, "CVE-2019-0715": {"epss_score": 0.01229, "epss_percentile": 0.78715}, "CVE-2019-0716": {"epss_score": 0.00916, "epss_percentile": 0.75413}, "CVE-2019-0717": {"epss_score": 0.01023, "epss_percentile": 0.76773}, "CVE-2019-0718": {"epss_score": 0.01259, "epss_percentile": 0.78964}, "CVE-2019-0719": {"epss_score": 0.01463, "epss_percentile": 0.80444}, "CVE-2019-0720": {"epss_score": 0.00738, "epss_percentile": 0.72344}, "CVE-2019-0721": {"epss_score": 0.0173, "epss_percentile": 0.81987}, "CVE-2019-0722": {"epss_score": 0.13264, "epss_percentile": 0.93917}, "CVE-2019-0723": {"epss_score": 0.01229, "epss_percentile": 0.78715}, "CVE-2019-0724": {"epss_score": 0.60235, "epss_percentile": 0.98199}, "CVE-2019-0725": {"epss_score": 0.29764, "epss_percentile": 0.96474}, "CVE-2019-0726": {"epss_score": 0.33065, "epss_percentile": 0.96744}, "CVE-2019-0727": {"epss_score": 0.00226, "epss_percentile": 0.45278}, "CVE-2019-0728": {"epss_score": 0.11584, "epss_percentile": 0.93411}, "CVE-2019-0729": {"epss_score": 0.01573, "epss_percentile": 0.81101}, "CVE-2019-0730": {"epss_score": 0.06227, "epss_percentile": 0.90585}, "CVE-2019-0731": {"epss_score": 0.04684, "epss_percentile": 0.89005}, "CVE-2019-0732": {"epss_score": 0.04188, "epss_percentile": 0.88367}, "CVE-2019-0733": {"epss_score": 0.00333, "epss_percentile": 0.55635}, "CVE-2019-0734": {"epss_score": 0.07049, "epss_percentile": 0.91211}, "CVE-2019-0735": {"epss_score": 0.08201, "epss_percentile": 0.91927}, "CVE-2019-0736": {"epss_score": 0.16743, "epss_percentile": 0.94725}, "CVE-2019-0739": {"epss_score": 0.0522, "epss_percentile": 0.89624}, "CVE-2019-0741": {"epss_score": 0.0346, "epss_percentile": 0.87179}, "CVE-2019-0742": {"epss_score": 0.00454, "epss_percentile": 0.63257}, "CVE-2019-0743": {"epss_score": 0.00454, "epss_percentile": 0.63257}, "CVE-2019-0746": {"epss_score": 0.22506, "epss_percentile": 0.95644}, "CVE-2019-0748": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0752": {"epss_score": 0.92074, "epss_percentile": 0.9969}, "CVE-2019-0753": {"epss_score": 0.05727, "epss_percentile": 0.90158}, "CVE-2019-0754": {"epss_score": 0.00337, "epss_percentile": 0.56063}, "CVE-2019-0755": {"epss_score": 0.00603, "epss_percentile": 0.68938}, "CVE-2019-0756": {"epss_score": 0.16363, "epss_percentile": 0.94635}, "CVE-2019-0757": {"epss_score": 0.05388, "epss_percentile": 0.89822}, "CVE-2019-0758": {"epss_score": 0.22134, "epss_percentile": 0.95598}, "CVE-2019-0759": {"epss_score": 0.00401, "epss_percentile": 0.60261}, "CVE-2019-0761": {"epss_score": 0.08313, "epss_percentile": 0.91987}, "CVE-2019-0762": {"epss_score": 0.04465, "epss_percentile": 0.88728}, "CVE-2019-0763": {"epss_score": 0.04162, "epss_percentile": 0.88338}, "CVE-2019-0764": {"epss_score": 0.06811, "epss_percentile": 0.91041}, "CVE-2019-0765": {"epss_score": 0.19221, "epss_percentile": 0.9515}, "CVE-2019-0766": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-0767": {"epss_score": 0.00908, "epss_percentile": 0.75274}, "CVE-2019-0768": {"epss_score": 0.85898, "epss_percentile": 0.99355}, "CVE-2019-0769": {"epss_score": 0.03945, "epss_percentile": 0.87996}, "CVE-2019-0770": {"epss_score": 0.04162, "epss_percentile": 0.88338}, "CVE-2019-0771": {"epss_score": 0.03945, "epss_percentile": 0.87996}, "CVE-2019-0772": {"epss_score": 0.14664, "epss_percentile": 0.9426}, "CVE-2019-0773": {"epss_score": 0.03945, "epss_percentile": 0.87996}, "CVE-2019-0774": {"epss_score": 0.25343, "epss_percentile": 0.96016}, "CVE-2019-0775": {"epss_score": 0.00347, "epss_percentile": 0.56777}, "CVE-2019-0776": {"epss_score": 0.00881, "epss_percentile": 0.74871}, "CVE-2019-0777": {"epss_score": 0.00455, "epss_percentile": 0.63275}, "CVE-2019-0778": {"epss_score": 0.00486, "epss_percentile": 0.64754}, "CVE-2019-0779": {"epss_score": 0.04162, "epss_percentile": 0.88338}, "CVE-2019-0780": {"epss_score": 0.03553, "epss_percentile": 0.87345}, "CVE-2019-0782": {"epss_score": 0.00908, "epss_percentile": 0.75274}, "CVE-2019-0783": {"epss_score": 0.04162, "epss_percentile": 0.88338}, "CVE-2019-0784": {"epss_score": 0.03492, "epss_percentile": 0.87232}, "CVE-2019-0785": {"epss_score": 0.51524, "epss_percentile": 0.97784}, "CVE-2019-0786": {"epss_score": 0.0993, "epss_percentile": 0.92776}, "CVE-2019-0787": {"epss_score": 0.32912, "epss_percentile": 0.96735}, "CVE-2019-0788": {"epss_score": 0.30341, "epss_percentile": 0.96532}, "CVE-2019-0790": {"epss_score": 0.28171, "epss_percentile": 0.96329}, "CVE-2019-0791": {"epss_score": 0.28007, "epss_percentile": 0.96302}, "CVE-2019-0792": {"epss_score": 0.32248, "epss_percentile": 0.96682}, "CVE-2019-0793": {"epss_score": 0.28007, "epss_percentile": 0.96302}, "CVE-2019-0794": {"epss_score": 0.27063, "epss_percentile": 0.96202}, "CVE-2019-0795": {"epss_score": 0.32248, "epss_percentile": 0.96682}, "CVE-2019-0796": {"epss_score": 0.03427, "epss_percentile": 0.87116}, "CVE-2019-0797": {"epss_score": 0.06091, "epss_percentile": 0.90474}, "CVE-2019-0798": {"epss_score": 0.00465, "epss_percentile": 0.63745}, "CVE-2019-0801": {"epss_score": 0.23515, "epss_percentile": 0.95787}, "CVE-2019-0802": {"epss_score": 0.21992, "epss_percentile": 0.95582}, "CVE-2019-0803": {"epss_score": 0.90359, "epss_percentile": 0.99579}, "CVE-2019-0804": {"epss_score": 0.04412, "epss_percentile": 0.88661}, "CVE-2019-0805": {"epss_score": 0.00477, "epss_percentile": 0.6433}, "CVE-2019-0806": {"epss_score": 0.04657, "epss_percentile": 0.88975}, "CVE-2019-0808": {"epss_score": 0.74494, "epss_percentile": 0.98803}, "CVE-2019-0809": {"epss_score": 0.13282, "epss_percentile": 0.93921}, "CVE-2019-0810": {"epss_score": 0.08513, "epss_percentile": 0.92097}, "CVE-2019-0811": {"epss_score": 0.0859, "epss_percentile": 0.92138}, "CVE-2019-0812": {"epss_score": 0.44847, "epss_percentile": 0.97456}, "CVE-2019-0813": {"epss_score": 0.1066, "epss_percentile": 0.93061}, "CVE-2019-0814": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2019-0815": {"epss_score": 0.05323, "epss_percentile": 0.8973}, "CVE-2019-0816": {"epss_score": 0.0009, "epss_percentile": 0.26127}, "CVE-2019-0817": {"epss_score": 0.01701, "epss_percentile": 0.81834}, "CVE-2019-0819": {"epss_score": 0.05728, "epss_percentile": 0.90158}, "CVE-2019-0820": {"epss_score": 0.02652, "epss_percentile": 0.85346}, "CVE-2019-0821": {"epss_score": 0.137, "epss_percentile": 0.94037}, "CVE-2019-0822": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0823": {"epss_score": 0.19127, "epss_percentile": 0.95135}, "CVE-2019-0824": {"epss_score": 0.19127, "epss_percentile": 0.95135}, "CVE-2019-0825": {"epss_score": 0.19127, "epss_percentile": 0.95135}, "CVE-2019-0826": {"epss_score": 0.19127, "epss_percentile": 0.95135}, "CVE-2019-0827": {"epss_score": 0.19127, "epss_percentile": 0.95135}, "CVE-2019-0828": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0829": {"epss_score": 0.04657, "epss_percentile": 0.88975}, "CVE-2019-0830": {"epss_score": 0.00485, "epss_percentile": 0.64733}, "CVE-2019-0831": {"epss_score": 0.00494, "epss_percentile": 0.6507}, "CVE-2019-0833": {"epss_score": 0.31011, "epss_percentile": 0.96582}, "CVE-2019-0835": {"epss_score": 0.25343, "epss_percentile": 0.96016}, "CVE-2019-0836": {"epss_score": 0.42685, "epss_percentile": 0.97346}, "CVE-2019-0837": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2019-0838": {"epss_score": 0.00627, "epss_percentile": 0.69621}, "CVE-2019-0839": {"epss_score": 0.00689, "epss_percentile": 0.71233}, "CVE-2019-0840": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2019-0841": {"epss_score": 0.82809, "epss_percentile": 0.99216}, "CVE-2019-0842": {"epss_score": 0.24058, "epss_percentile": 0.95851}, "CVE-2019-0844": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2019-0845": {"epss_score": 0.22095, "epss_percentile": 0.95594}, "CVE-2019-0846": {"epss_score": 0.2548, "epss_percentile": 0.96033}, "CVE-2019-0847": {"epss_score": 0.2548, "epss_percentile": 0.96033}, "CVE-2019-0848": {"epss_score": 0.00996, "epss_percentile": 0.76452}, "CVE-2019-0849": {"epss_score": 0.22134, "epss_percentile": 0.95598}, "CVE-2019-0851": {"epss_score": 0.2548, "epss_percentile": 0.96033}, "CVE-2019-0853": {"epss_score": 0.16006, "epss_percentile": 0.94553}, "CVE-2019-0856": {"epss_score": 0.09586, "epss_percentile": 0.92609}, "CVE-2019-0857": {"epss_score": 0.16381, "epss_percentile": 0.94641}, "CVE-2019-0858": {"epss_score": 0.00427, "epss_percentile": 0.61891}, "CVE-2019-0859": {"epss_score": 0.09881, "epss_percentile": 0.92751}, "CVE-2019-0860": {"epss_score": 0.06192, "epss_percentile": 0.90553}, "CVE-2019-0861": {"epss_score": 0.06192, "epss_percentile": 0.90553}, "CVE-2019-0862": {"epss_score": 0.07579, "epss_percentile": 0.91552}, "CVE-2019-0863": {"epss_score": 0.06934, "epss_percentile": 0.91125}, "CVE-2019-0864": {"epss_score": 0.00134, "epss_percentile": 0.33924}, "CVE-2019-0865": {"epss_score": 0.0859, "epss_percentile": 0.92138}, "CVE-2019-0866": {"epss_score": 0.00359, "epss_percentile": 0.57566}, "CVE-2019-0867": {"epss_score": 0.00475, "epss_percentile": 0.64245}, "CVE-2019-0868": {"epss_score": 0.00475, "epss_percentile": 0.64245}, "CVE-2019-0869": {"epss_score": 0.00494, "epss_percentile": 0.65096}, "CVE-2019-0870": {"epss_score": 0.00475, "epss_percentile": 0.64245}, "CVE-2019-0871": {"epss_score": 0.00475, "epss_percentile": 0.64245}, "CVE-2019-0872": {"epss_score": 0.00455, "epss_percentile": 0.63275}, "CVE-2019-0874": {"epss_score": 0.00451, "epss_percentile": 0.63152}, "CVE-2019-0875": {"epss_score": 0.03437, "epss_percentile": 0.87134}, "CVE-2019-0876": {"epss_score": 0.00483, "epss_percentile": 0.64572}, "CVE-2019-0877": {"epss_score": 0.02318, "epss_percentile": 0.84361}, "CVE-2019-0879": {"epss_score": 0.02263, "epss_percentile": 0.8419}, "CVE-2019-0880": {"epss_score": 0.04003, "epss_percentile": 0.88095}, "CVE-2019-0881": {"epss_score": 0.01913, "epss_percentile": 0.82842}, "CVE-2019-0882": {"epss_score": 0.25343, "epss_percentile": 0.96016}, "CVE-2019-0884": {"epss_score": 0.04621, "epss_percentile": 0.88933}, "CVE-2019-0885": {"epss_score": 0.22903, "epss_percentile": 0.95704}, "CVE-2019-0886": {"epss_score": 0.0078, "epss_percentile": 0.73164}, "CVE-2019-0887": {"epss_score": 0.5322, "epss_percentile": 0.97864}, "CVE-2019-0888": {"epss_score": 0.57073, "epss_percentile": 0.98047}, "CVE-2019-0889": {"epss_score": 0.28094, "epss_percentile": 0.96309}, "CVE-2019-0890": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0891": {"epss_score": 0.28094, "epss_percentile": 0.96309}, "CVE-2019-0892": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-0893": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0894": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0895": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0896": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0897": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0898": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0899": {"epss_score": 0.28094, "epss_percentile": 0.96309}, "CVE-2019-0900": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0901": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0902": {"epss_score": 0.29592, "epss_percentile": 0.9646}, "CVE-2019-0903": {"epss_score": 0.34444, "epss_percentile": 0.96847}, "CVE-2019-0904": {"epss_score": 0.10107, "epss_percentile": 0.92852}, "CVE-2019-0905": {"epss_score": 0.10107, "epss_percentile": 0.92852}, "CVE-2019-0906": {"epss_score": 0.09822, "epss_percentile": 0.92718}, "CVE-2019-0907": {"epss_score": 0.10107, "epss_percentile": 0.92852}, "CVE-2019-0908": {"epss_score": 0.07323, "epss_percentile": 0.91409}, "CVE-2019-0909": {"epss_score": 0.07186, "epss_percentile": 0.91308}, "CVE-2019-0911": {"epss_score": 0.03877, "epss_percentile": 0.8789}, "CVE-2019-0912": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-0913": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-0914": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-0915": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-0916": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-0917": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-0918": {"epss_score": 0.03461, "epss_percentile": 0.87181}, "CVE-2019-0920": {"epss_score": 0.05979, "epss_percentile": 0.90378}, "CVE-2019-0921": {"epss_score": 0.12618, "epss_percentile": 0.93731}, "CVE-2019-0922": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-0923": {"epss_score": 0.04049, "epss_percentile": 0.88175}, "CVE-2019-0924": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-0925": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-0926": {"epss_score": 0.04054, "epss_percentile": 0.88183}, "CVE-2019-0927": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-0928": {"epss_score": 0.00199, "epss_percentile": 0.42183}, "CVE-2019-0929": {"epss_score": 0.04054, "epss_percentile": 0.88183}, "CVE-2019-0930": {"epss_score": 0.20668, "epss_percentile": 0.95399}, "CVE-2019-0931": {"epss_score": 0.00268, "epss_percentile": 0.50089}, "CVE-2019-0932": {"epss_score": 0.03923, "epss_percentile": 0.87956}, "CVE-2019-0933": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-0936": {"epss_score": 0.00416, "epss_percentile": 0.61198}, "CVE-2019-0937": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-0938": {"epss_score": 0.00663, "epss_percentile": 0.70614}, "CVE-2019-0940": {"epss_score": 0.46501, "epss_percentile": 0.97549}, "CVE-2019-0941": {"epss_score": 0.02839, "epss_percentile": 0.85795}, "CVE-2019-0942": {"epss_score": 0.00346, "epss_percentile": 0.56648}, "CVE-2019-0943": {"epss_score": 0.04447, "epss_percentile": 0.887}, "CVE-2019-0945": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0946": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0947": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0948": {"epss_score": 0.42662, "epss_percentile": 0.97345}, "CVE-2019-0949": {"epss_score": 0.07913, "epss_percentile": 0.9176}, "CVE-2019-0950": {"epss_score": 0.07913, "epss_percentile": 0.9176}, "CVE-2019-0951": {"epss_score": 0.00486, "epss_percentile": 0.64754}, "CVE-2019-0952": {"epss_score": 0.36107, "epss_percentile": 0.96956}, "CVE-2019-0953": {"epss_score": 0.24224, "epss_percentile": 0.95894}, "CVE-2019-0956": {"epss_score": 0.10464, "epss_percentile": 0.92995}, "CVE-2019-0957": {"epss_score": 0.08939, "epss_percentile": 0.92329}, "CVE-2019-0958": {"epss_score": 0.04021, "epss_percentile": 0.88131}, "CVE-2019-0959": {"epss_score": 0.03032, "epss_percentile": 0.86252}, "CVE-2019-0960": {"epss_score": 0.00167, "epss_percentile": 0.38304}, "CVE-2019-0961": {"epss_score": 0.25343, "epss_percentile": 0.96016}, "CVE-2019-0962": {"epss_score": 0.04427, "epss_percentile": 0.88676}, "CVE-2019-0963": {"epss_score": 0.00485, "epss_percentile": 0.64733}, "CVE-2019-0965": {"epss_score": 0.00538, "epss_percentile": 0.6695}, "CVE-2019-0966": {"epss_score": 0.00322, "epss_percentile": 0.54758}, "CVE-2019-0968": {"epss_score": 0.29578, "epss_percentile": 0.96459}, "CVE-2019-0971": {"epss_score": 0.10099, "epss_percentile": 0.92847}, "CVE-2019-0972": {"epss_score": 0.17272, "epss_percentile": 0.94814}, "CVE-2019-0973": {"epss_score": 0.00245, "epss_percentile": 0.47727}, "CVE-2019-0974": {"epss_score": 0.13023, "epss_percentile": 0.93848}, "CVE-2019-0975": {"epss_score": 0.01775, "epss_percentile": 0.82218}, "CVE-2019-0976": {"epss_score": 0.00274, "epss_percentile": 0.50484}, "CVE-2019-0977": {"epss_score": 0.07622, "epss_percentile": 0.91579}, "CVE-2019-0979": {"epss_score": 0.00455, "epss_percentile": 0.63275}, "CVE-2019-0980": {"epss_score": 0.03215, "epss_percentile": 0.8666}, "CVE-2019-0981": {"epss_score": 0.03215, "epss_percentile": 0.8666}, "CVE-2019-0982": {"epss_score": 0.04508, "epss_percentile": 0.88775}, "CVE-2019-0983": {"epss_score": 0.00666, "epss_percentile": 0.70687}, "CVE-2019-0984": {"epss_score": 0.00167, "epss_percentile": 0.38304}, "CVE-2019-0985": {"epss_score": 0.15526, "epss_percentile": 0.94452}, "CVE-2019-0986": {"epss_score": 0.03671, "epss_percentile": 0.87539}, "CVE-2019-0988": {"epss_score": 0.0577, "epss_percentile": 0.90193}, "CVE-2019-0989": {"epss_score": 0.01427, "epss_percentile": 0.80208}, "CVE-2019-0990": {"epss_score": 0.12446, "epss_percentile": 0.93675}, "CVE-2019-0991": {"epss_score": 0.01427, "epss_percentile": 0.80208}, "CVE-2019-0992": {"epss_score": 0.00793, "epss_percentile": 0.73432}, "CVE-2019-0993": {"epss_score": 0.01427, "epss_percentile": 0.80208}, "CVE-2019-0995": {"epss_score": 0.11758, "epss_percentile": 0.93466}, "CVE-2019-0996": {"epss_score": 0.08129, "epss_percentile": 0.91894}, "CVE-2019-0998": {"epss_score": 0.00666, "epss_percentile": 0.70687}, "CVE-2019-0999": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-1000001": {"epss_score": 0.00338, "epss_percentile": 0.56118}, "CVE-2019-1000002": {"epss_score": 0.0029, "epss_percentile": 0.52126}, "CVE-2019-1000003": {"epss_score": 0.00112, "epss_percentile": 0.30514}, "CVE-2019-1000004": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-1000005": {"epss_score": 0.00318, "epss_percentile": 0.54406}, "CVE-2019-1000006": {"epss_score": 0.00385, "epss_percentile": 0.59189}, "CVE-2019-1000007": {"epss_score": 0.00362, "epss_percentile": 0.5775}, "CVE-2019-1000008": {"epss_score": 0.0023, "epss_percentile": 0.45675}, "CVE-2019-1000009": {"epss_score": 0.00354, "epss_percentile": 0.57249}, "CVE-2019-1000010": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-1000011": {"epss_score": 0.00161, "epss_percentile": 0.37608}, "CVE-2019-1000012": {"epss_score": 0.00233, "epss_percentile": 0.4604}, "CVE-2019-1000013": {"epss_score": 0.00233, "epss_percentile": 0.4604}, "CVE-2019-1000014": {"epss_score": 0.00548, "epss_percentile": 0.67279}, "CVE-2019-1000015": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-1000016": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2019-1000017": {"epss_score": 0.00234, "epss_percentile": 0.46123}, "CVE-2019-1000018": {"epss_score": 0.00285, "epss_percentile": 0.51538}, "CVE-2019-1000019": {"epss_score": 0.0281, "epss_percentile": 0.85714}, "CVE-2019-1000020": {"epss_score": 0.04887, "epss_percentile": 0.89255}, "CVE-2019-1000021": {"epss_score": 0.00342, "epss_percentile": 0.56402}, "CVE-2019-1000022": {"epss_score": 0.00165, "epss_percentile": 0.38027}, "CVE-2019-1000023": {"epss_score": 0.00298, "epss_percentile": 0.52797}, "CVE-2019-1000024": {"epss_score": 0.00284, "epss_percentile": 0.51471}, "CVE-2019-1000031": {"epss_score": 0.01805, "epss_percentile": 0.82348}, "CVE-2019-1002100": {"epss_score": 0.08652, "epss_percentile": 0.92172}, "CVE-2019-1002101": {"epss_score": 0.49122, "epss_percentile": 0.97668}, "CVE-2019-1003000": {"epss_score": 0.94441, "epss_percentile": 0.99988}, "CVE-2019-1003001": {"epss_score": 0.93976, "epss_percentile": 0.99877}, "CVE-2019-1003002": {"epss_score": 0.93893, "epss_percentile": 0.99864}, "CVE-2019-1003003": {"epss_score": 0.01946, "epss_percentile": 0.83001}, "CVE-2019-1003004": {"epss_score": 0.01802, "epss_percentile": 0.8233}, "CVE-2019-1003005": {"epss_score": 0.74186, "epss_percentile": 0.98791}, "CVE-2019-1003006": {"epss_score": 0.0006, "epss_percentile": 0.19145}, "CVE-2019-1003007": {"epss_score": 0.00067, "epss_percentile": 0.21032}, "CVE-2019-1003008": {"epss_score": 0.00067, "epss_percentile": 0.21034}, "CVE-2019-1003009": {"epss_score": 0.0003, "epss_percentile": 0.08182}, "CVE-2019-1003010": {"epss_score": 0.00651, "epss_percentile": 0.7028}, "CVE-2019-1003011": {"epss_score": 0.00556, "epss_percentile": 0.67505}, "CVE-2019-1003012": {"epss_score": 0.00154, "epss_percentile": 0.36718}, "CVE-2019-1003013": {"epss_score": 0.00061, "epss_percentile": 0.19311}, "CVE-2019-1003014": {"epss_score": 0.00064, "epss_percentile": 0.20155}, "CVE-2019-1003015": {"epss_score": 0.0011, "epss_percentile": 0.30171}, "CVE-2019-1003016": {"epss_score": 0.00156, "epss_percentile": 0.3691}, "CVE-2019-1003017": {"epss_score": 0.0008, "epss_percentile": 0.24181}, "CVE-2019-1003018": {"epss_score": 0.00038, "epss_percentile": 0.11314}, "CVE-2019-1003019": {"epss_score": 0.00032, "epss_percentile": 0.09079}, "CVE-2019-1003020": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-1003021": {"epss_score": 0.00038, "epss_percentile": 0.11314}, "CVE-2019-1003022": {"epss_score": 0.0006, "epss_percentile": 0.1914}, "CVE-2019-1003023": {"epss_score": 0.00042, "epss_percentile": 0.1275}, "CVE-2019-1003024": {"epss_score": 0.00314, "epss_percentile": 0.54121}, "CVE-2019-1003025": {"epss_score": 0.00067, "epss_percentile": 0.21042}, "CVE-2019-1003026": {"epss_score": 0.0003, "epss_percentile": 0.08076}, "CVE-2019-1003027": {"epss_score": 0.0003, "epss_percentile": 0.08052}, "CVE-2019-1003028": {"epss_score": 0.00021, "epss_percentile": 0.0475}, "CVE-2019-1003029": {"epss_score": 0.92784, "epss_percentile": 0.99749}, "CVE-2019-1003030": {"epss_score": 0.93021, "epss_percentile": 0.99768}, "CVE-2019-1003031": {"epss_score": 0.12188, "epss_percentile": 0.93598}, "CVE-2019-1003032": {"epss_score": 0.00093, "epss_percentile": 0.26703}, "CVE-2019-1003033": {"epss_score": 0.00093, "epss_percentile": 0.26703}, "CVE-2019-1003034": {"epss_score": 0.01879, "epss_percentile": 0.82673}, "CVE-2019-1003035": {"epss_score": 0.00027, "epss_percentile": 0.06957}, "CVE-2019-1003036": {"epss_score": 0.0003, "epss_percentile": 0.08076}, "CVE-2019-1003037": {"epss_score": 0.00045, "epss_percentile": 0.13799}, "CVE-2019-1003038": {"epss_score": 0.00011, "epss_percentile": 0.01076}, "CVE-2019-1003039": {"epss_score": 0.00067, "epss_percentile": 0.21042}, "CVE-2019-1003040": {"epss_score": 0.02252, "epss_percentile": 0.84161}, "CVE-2019-1003041": {"epss_score": 0.02252, "epss_percentile": 0.84161}, "CVE-2019-1003042": {"epss_score": 0.00107, "epss_percentile": 0.29676}, "CVE-2019-1003043": {"epss_score": 0.00176, "epss_percentile": 0.3943}, "CVE-2019-1003044": {"epss_score": 0.00316, "epss_percentile": 0.54215}, "CVE-2019-1003045": {"epss_score": 0.00734, "epss_percentile": 0.72248}, "CVE-2019-1003046": {"epss_score": 0.00469, "epss_percentile": 0.63941}, "CVE-2019-1003047": {"epss_score": 0.00084, "epss_percentile": 0.24872}, "CVE-2019-1003048": {"epss_score": 0.00015, "epss_percentile": 0.02228}, "CVE-2019-1003049": {"epss_score": 0.00502, "epss_percentile": 0.65414}, "CVE-2019-1003050": {"epss_score": 0.00986, "epss_percentile": 0.76329}, "CVE-2019-1003051": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003052": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003053": {"epss_score": 0.00112, "epss_percentile": 0.30483}, "CVE-2019-1003054": {"epss_score": 0.00112, "epss_percentile": 0.30483}, "CVE-2019-1003055": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003056": {"epss_score": 0.00112, "epss_percentile": 0.30483}, "CVE-2019-1003057": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003058": {"epss_score": 0.00515, "epss_percentile": 0.65971}, "CVE-2019-1003059": {"epss_score": 0.00055, "epss_percentile": 0.17415}, "CVE-2019-1003060": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003061": {"epss_score": 0.00112, "epss_percentile": 0.30483}, "CVE-2019-1003062": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003063": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003064": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003065": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003066": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003067": {"epss_score": 0.00112, "epss_percentile": 0.30483}, "CVE-2019-1003068": {"epss_score": 0.00112, "epss_percentile": 0.30483}, "CVE-2019-1003069": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003070": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003071": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003072": {"epss_score": 0.00112, "epss_percentile": 0.30483}, "CVE-2019-1003073": {"epss_score": 0.00112, "epss_percentile": 0.30483}, "CVE-2019-1003074": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003075": {"epss_score": 0.00081, "epss_percentile": 0.24393}, "CVE-2019-1003076": {"epss_score": 0.00156, "epss_percentile": 0.36953}, "CVE-2019-1003077": {"epss_score": 0.00055, "epss_percentile": 0.17415}, "CVE-2019-1003078": {"epss_score": 0.00068, "epss_percentile": 0.21192}, "CVE-2019-1003079": {"epss_score": 0.00084, "epss_percentile": 0.24872}, "CVE-2019-1003080": {"epss_score": 0.00142, "epss_percentile": 0.35035}, "CVE-2019-1003081": {"epss_score": 0.00084, "epss_percentile": 0.24872}, "CVE-2019-1003082": {"epss_score": 0.00156, "epss_percentile": 0.36953}, "CVE-2019-1003083": {"epss_score": 0.00055, "epss_percentile": 0.17415}, "CVE-2019-1003084": {"epss_score": 0.00156, "epss_percentile": 0.36953}, "CVE-2019-1003085": {"epss_score": 0.00084, "epss_percentile": 0.24872}, "CVE-2019-1003086": {"epss_score": 0.00156, "epss_percentile": 0.36953}, "CVE-2019-1003087": {"epss_score": 0.00084, "epss_percentile": 0.24872}, "CVE-2019-1003088": {"epss_score": 0.00176, "epss_percentile": 0.3938}, "CVE-2019-1003089": {"epss_score": 0.00176, "epss_percentile": 0.3938}, "CVE-2019-1003090": {"epss_score": 0.00156, "epss_percentile": 0.36953}, "CVE-2019-1003091": {"epss_score": 0.00055, "epss_percentile": 0.17415}, "CVE-2019-1003092": {"epss_score": 0.00156, "epss_percentile": 0.36953}, "CVE-2019-1003093": {"epss_score": 0.00084, "epss_percentile": 0.24872}, "CVE-2019-1003094": {"epss_score": 0.00128, "epss_percentile": 0.32984}, "CVE-2019-1003095": {"epss_score": 0.00128, "epss_percentile": 0.32984}, "CVE-2019-1003096": {"epss_score": 0.0017, "epss_percentile": 0.38757}, "CVE-2019-1003097": {"epss_score": 0.00111, "epss_percentile": 0.3034}, "CVE-2019-1003098": {"epss_score": 0.00156, "epss_percentile": 0.36953}, "CVE-2019-1003099": {"epss_score": 0.00084, "epss_percentile": 0.24872}, "CVE-2019-1010003": {"epss_score": 0.00211, "epss_percentile": 0.43629}, "CVE-2019-1010004": {"epss_score": 0.00432, "epss_percentile": 0.6213}, "CVE-2019-1010005": {"epss_score": 0.00398, "epss_percentile": 0.60054}, "CVE-2019-1010006": {"epss_score": 0.00531, "epss_percentile": 0.66656}, "CVE-2019-1010008": {"epss_score": 0.00344, "epss_percentile": 0.56491}, "CVE-2019-1010009": {"epss_score": 0.01783, "epss_percentile": 0.82246}, "CVE-2019-1010016": {"epss_score": 0.00267, "epss_percentile": 0.49989}, "CVE-2019-1010017": {"epss_score": 0.00558, "epss_percentile": 0.67578}, "CVE-2019-1010018": {"epss_score": 0.00361, "epss_percentile": 0.57701}, "CVE-2019-1010022": {"epss_score": 0.00145, "epss_percentile": 0.35439}, "CVE-2019-1010023": {"epss_score": 0.00346, "epss_percentile": 0.56676}, "CVE-2019-1010024": {"epss_score": 0.00375, "epss_percentile": 0.58625}, "CVE-2019-1010025": {"epss_score": 0.00253, "epss_percentile": 0.4845}, "CVE-2019-1010028": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-1010034": {"epss_score": 0.00466, "epss_percentile": 0.63791}, "CVE-2019-1010038": {"epss_score": 0.01097, "epss_percentile": 0.77528}, "CVE-2019-1010039": {"epss_score": 0.00861, "epss_percentile": 0.74562}, "CVE-2019-1010043": {"epss_score": 0.00861, "epss_percentile": 0.74562}, "CVE-2019-1010044": {"epss_score": 0.00778, "epss_percentile": 0.73132}, "CVE-2019-1010054": {"epss_score": 0.00751, "epss_percentile": 0.72644}, "CVE-2019-1010057": {"epss_score": 0.00633, "epss_percentile": 0.69786}, "CVE-2019-1010060": {"epss_score": 0.31291, "epss_percentile": 0.96606}, "CVE-2019-1010062": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-1010065": {"epss_score": 0.01178, "epss_percentile": 0.7828}, "CVE-2019-1010066": {"epss_score": 0.00198, "epss_percentile": 0.42005}, "CVE-2019-1010069": {"epss_score": 0.0014, "epss_percentile": 0.34717}, "CVE-2019-1010083": {"epss_score": 0.00305, "epss_percentile": 0.53353}, "CVE-2019-1010084": {"epss_score": 0.00238, "epss_percentile": 0.46765}, "CVE-2019-1010091": {"epss_score": 0.01139, "epss_percentile": 0.77941}, "CVE-2019-1010094": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-1010095": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-1010096": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-1010100": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2019-1010101": {"epss_score": 0.00677, "epss_percentile": 0.70962}, "CVE-2019-1010104": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2019-1010112": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-1010113": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-1010123": {"epss_score": 0.0021, "epss_percentile": 0.43478}, "CVE-2019-1010124": {"epss_score": 0.00265, "epss_percentile": 0.4984}, "CVE-2019-1010127": {"epss_score": 0.00627, "epss_percentile": 0.69638}, "CVE-2019-1010136": {"epss_score": 0.01212, "epss_percentile": 0.78563}, "CVE-2019-1010142": {"epss_score": 0.01928, "epss_percentile": 0.82929}, "CVE-2019-1010147": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2019-1010148": {"epss_score": 0.00621, "epss_percentile": 0.69492}, "CVE-2019-1010149": {"epss_score": 0.0113, "epss_percentile": 0.77852}, "CVE-2019-1010150": {"epss_score": 0.0113, "epss_percentile": 0.77852}, "CVE-2019-1010151": {"epss_score": 0.00491, "epss_percentile": 0.6498}, "CVE-2019-1010152": {"epss_score": 0.00473, "epss_percentile": 0.64098}, "CVE-2019-1010153": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-1010155": {"epss_score": 0.00584, "epss_percentile": 0.68379}, "CVE-2019-1010161": {"epss_score": 0.0023, "epss_percentile": 0.45709}, "CVE-2019-1010162": {"epss_score": 0.00164, "epss_percentile": 0.3795}, "CVE-2019-1010163": {"epss_score": 0.00209, "epss_percentile": 0.43423}, "CVE-2019-1010169": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2019-1010170": {"epss_score": 0.00536, "epss_percentile": 0.66851}, "CVE-2019-1010171": {"epss_score": 0.00532, "epss_percentile": 0.66676}, "CVE-2019-1010172": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2019-1010173": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2019-1010174": {"epss_score": 0.13115, "epss_percentile": 0.93878}, "CVE-2019-1010176": {"epss_score": 0.00928, "epss_percentile": 0.75586}, "CVE-2019-1010177": {"epss_score": 0.01297, "epss_percentile": 0.7926}, "CVE-2019-1010178": {"epss_score": 0.02373, "epss_percentile": 0.84532}, "CVE-2019-1010179": {"epss_score": 0.05492, "epss_percentile": 0.89931}, "CVE-2019-1010180": {"epss_score": 0.00293, "epss_percentile": 0.52351}, "CVE-2019-1010182": {"epss_score": 0.00308, "epss_percentile": 0.53579}, "CVE-2019-1010183": {"epss_score": 0.00364, "epss_percentile": 0.57918}, "CVE-2019-1010189": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2019-1010190": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2019-1010191": {"epss_score": 0.00282, "epss_percentile": 0.51264}, "CVE-2019-1010193": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-1010199": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-1010200": {"epss_score": 0.0239, "epss_percentile": 0.84598}, "CVE-2019-1010201": {"epss_score": 0.00328, "epss_percentile": 0.55158}, "CVE-2019-1010202": {"epss_score": 0.00568, "epss_percentile": 0.67879}, "CVE-2019-1010204": {"epss_score": 0.00143, "epss_percentile": 0.35107}, "CVE-2019-1010205": {"epss_score": 0.00402, "epss_percentile": 0.6028}, "CVE-2019-1010206": {"epss_score": 0.00107, "epss_percentile": 0.29578}, "CVE-2019-1010207": {"epss_score": 0.00347, "epss_percentile": 0.56776}, "CVE-2019-1010208": {"epss_score": 0.00056, "epss_percentile": 0.17709}, "CVE-2019-1010209": {"epss_score": 0.00892, "epss_percentile": 0.75065}, "CVE-2019-1010218": {"epss_score": 0.00624, "epss_percentile": 0.69556}, "CVE-2019-1010220": {"epss_score": 0.00293, "epss_percentile": 0.52287}, "CVE-2019-1010221": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2019-1010228": {"epss_score": 0.00239, "epss_percentile": 0.46873}, "CVE-2019-1010232": {"epss_score": 0.00252, "epss_percentile": 0.48407}, "CVE-2019-1010234": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-1010235": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-1010237": {"epss_score": 0.00509, "epss_percentile": 0.65749}, "CVE-2019-1010238": {"epss_score": 0.04916, "epss_percentile": 0.89286}, "CVE-2019-1010239": {"epss_score": 0.00467, "epss_percentile": 0.63814}, "CVE-2019-1010241": {"epss_score": 0.00227, "epss_percentile": 0.45422}, "CVE-2019-1010245": {"epss_score": 0.03374, "epss_percentile": 0.87015}, "CVE-2019-1010246": {"epss_score": 0.00485, "epss_percentile": 0.64729}, "CVE-2019-1010247": {"epss_score": 0.00356, "epss_percentile": 0.57337}, "CVE-2019-1010248": {"epss_score": 0.0042, "epss_percentile": 0.61404}, "CVE-2019-1010249": {"epss_score": 0.00182, "epss_percentile": 0.40152}, "CVE-2019-1010250": {"epss_score": 0.00182, "epss_percentile": 0.40152}, "CVE-2019-1010251": {"epss_score": 0.00397, "epss_percentile": 0.59983}, "CVE-2019-1010252": {"epss_score": 0.00199, "epss_percentile": 0.42112}, "CVE-2019-1010257": {"epss_score": 0.05182, "epss_percentile": 0.89582}, "CVE-2019-1010258": {"epss_score": 0.0042, "epss_percentile": 0.61426}, "CVE-2019-1010259": {"epss_score": 0.0037, "epss_percentile": 0.58312}, "CVE-2019-1010260": {"epss_score": 0.00216, "epss_percentile": 0.44218}, "CVE-2019-1010261": {"epss_score": 0.00262, "epss_percentile": 0.49391}, "CVE-2019-1010263": {"epss_score": 0.00251, "epss_percentile": 0.48328}, "CVE-2019-1010266": {"epss_score": 0.00214, "epss_percentile": 0.44022}, "CVE-2019-1010268": {"epss_score": 0.13242, "epss_percentile": 0.9391}, "CVE-2019-1010275": {"epss_score": 0.00303, "epss_percentile": 0.53219}, "CVE-2019-1010279": {"epss_score": 0.00193, "epss_percentile": 0.4143}, "CVE-2019-1010283": {"epss_score": 0.0027, "epss_percentile": 0.50228}, "CVE-2019-1010287": {"epss_score": 0.20584, "epss_percentile": 0.95381}, "CVE-2019-1010290": {"epss_score": 0.21947, "epss_percentile": 0.95575}, "CVE-2019-1010292": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-1010293": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-1010294": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-1010295": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2019-1010296": {"epss_score": 0.01072, "epss_percentile": 0.77279}, "CVE-2019-1010297": {"epss_score": 0.01072, "epss_percentile": 0.77279}, "CVE-2019-1010298": {"epss_score": 0.05456, "epss_percentile": 0.89897}, "CVE-2019-1010299": {"epss_score": 0.00175, "epss_percentile": 0.39343}, "CVE-2019-1010300": {"epss_score": 0.00297, "epss_percentile": 0.52695}, "CVE-2019-1010301": {"epss_score": 0.00111, "epss_percentile": 0.30345}, "CVE-2019-1010302": {"epss_score": 0.00094, "epss_percentile": 0.27032}, "CVE-2019-1010304": {"epss_score": 0.00389, "epss_percentile": 0.59476}, "CVE-2019-1010305": {"epss_score": 0.00587, "epss_percentile": 0.68465}, "CVE-2019-1010306": {"epss_score": 0.0182, "epss_percentile": 0.82407}, "CVE-2019-1010307": {"epss_score": 0.00253, "epss_percentile": 0.48488}, "CVE-2019-1010308": {"epss_score": 0.00305, "epss_percentile": 0.53383}, "CVE-2019-1010310": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-1010314": {"epss_score": 0.00262, "epss_percentile": 0.49391}, "CVE-2019-1010315": {"epss_score": 0.00831, "epss_percentile": 0.74053}, "CVE-2019-1010316": {"epss_score": 0.0004, "epss_percentile": 0.1193}, "CVE-2019-1010317": {"epss_score": 0.01382, "epss_percentile": 0.79872}, "CVE-2019-1010319": {"epss_score": 0.01382, "epss_percentile": 0.79872}, "CVE-2019-1020001": {"epss_score": 0.00246, "epss_percentile": 0.4779}, "CVE-2019-1020002": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-1020003": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-1020004": {"epss_score": 0.00238, "epss_percentile": 0.46811}, "CVE-2019-1020005": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-1020006": {"epss_score": 0.00226, "epss_percentile": 0.45249}, "CVE-2019-1020007": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-1020008": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-1020009": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2019-1020010": {"epss_score": 0.00389, "epss_percentile": 0.59463}, "CVE-2019-1020011": {"epss_score": 0.00428, "epss_percentile": 0.61934}, "CVE-2019-1020012": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-1020013": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2019-1020014": {"epss_score": 0.00079, "epss_percentile": 0.23996}, "CVE-2019-1020015": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-1020016": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2019-1020017": {"epss_score": 0.00294, "epss_percentile": 0.52436}, "CVE-2019-1020018": {"epss_score": 0.00294, "epss_percentile": 0.52394}, "CVE-2019-1020019": {"epss_score": 0.00226, "epss_percentile": 0.45249}, "CVE-2019-10008": {"epss_score": 0.09112, "epss_percentile": 0.92405}, "CVE-2019-10009": {"epss_score": 0.06279, "epss_percentile": 0.90635}, "CVE-2019-10010": {"epss_score": 0.00326, "epss_percentile": 0.55086}, "CVE-2019-10011": {"epss_score": 0.00627, "epss_percentile": 0.69627}, "CVE-2019-10012": {"epss_score": 0.00691, "epss_percentile": 0.71276}, "CVE-2019-10013": {"epss_score": 0.01186, "epss_percentile": 0.78344}, "CVE-2019-10014": {"epss_score": 0.00108, "epss_percentile": 0.29789}, "CVE-2019-10015": {"epss_score": 0.00805, "epss_percentile": 0.73645}, "CVE-2019-10016": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-10017": {"epss_score": 0.00254, "epss_percentile": 0.48499}, "CVE-2019-10018": {"epss_score": 0.00635, "epss_percentile": 0.69816}, "CVE-2019-10019": {"epss_score": 0.00177, "epss_percentile": 0.39617}, "CVE-2019-10020": {"epss_score": 0.00164, "epss_percentile": 0.37915}, "CVE-2019-10021": {"epss_score": 0.00164, "epss_percentile": 0.37915}, "CVE-2019-10022": {"epss_score": 0.00177, "epss_percentile": 0.39617}, "CVE-2019-10023": {"epss_score": 0.00164, "epss_percentile": 0.37915}, "CVE-2019-10024": {"epss_score": 0.00164, "epss_percentile": 0.37915}, "CVE-2019-10025": {"epss_score": 0.00164, "epss_percentile": 0.37915}, "CVE-2019-10026": {"epss_score": 0.00164, "epss_percentile": 0.37915}, "CVE-2019-10027": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-10028": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-10038": {"epss_score": 0.02299, "epss_percentile": 0.84306}, "CVE-2019-10039": {"epss_score": 0.01213, "epss_percentile": 0.78566}, "CVE-2019-10040": {"epss_score": 0.01304, "epss_percentile": 0.79316}, "CVE-2019-10041": {"epss_score": 0.00923, "epss_percentile": 0.75498}, "CVE-2019-10042": {"epss_score": 0.00789, "epss_percentile": 0.73356}, "CVE-2019-10044": {"epss_score": 0.00764, "epss_percentile": 0.72894}, "CVE-2019-10045": {"epss_score": 0.00188, "epss_percentile": 0.40913}, "CVE-2019-10046": {"epss_score": 0.00528, "epss_percentile": 0.66567}, "CVE-2019-10047": {"epss_score": 0.0042, "epss_percentile": 0.61413}, "CVE-2019-10048": {"epss_score": 0.02114, "epss_percentile": 0.83653}, "CVE-2019-10049": {"epss_score": 0.00282, "epss_percentile": 0.51239}, "CVE-2019-10050": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2019-10051": {"epss_score": 0.00597, "epss_percentile": 0.68743}, "CVE-2019-10052": {"epss_score": 0.00597, "epss_percentile": 0.68743}, "CVE-2019-10053": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2019-10054": {"epss_score": 0.00499, "epss_percentile": 0.65275}, "CVE-2019-10055": {"epss_score": 0.00513, "epss_percentile": 0.65939}, "CVE-2019-10056": {"epss_score": 0.00499, "epss_percentile": 0.65275}, "CVE-2019-10057": {"epss_score": 0.0012, "epss_percentile": 0.317}, "CVE-2019-10058": {"epss_score": 0.00313, "epss_percentile": 0.54034}, "CVE-2019-10059": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2019-10060": {"epss_score": 0.01387, "epss_percentile": 0.79918}, "CVE-2019-10061": {"epss_score": 0.08416, "epss_percentile": 0.9204}, "CVE-2019-10062": {"epss_score": 0.00739, "epss_percentile": 0.72355}, "CVE-2019-10063": {"epss_score": 0.00103, "epss_percentile": 0.28968}, "CVE-2019-10064": {"epss_score": 0.01405, "epss_percentile": 0.80043}, "CVE-2019-10065": {"epss_score": 0.00197, "epss_percentile": 0.41875}, "CVE-2019-10066": {"epss_score": 0.00444, "epss_percentile": 0.62836}, "CVE-2019-10067": {"epss_score": 0.00401, "epss_percentile": 0.60214}, "CVE-2019-10068": {"epss_score": 0.93898, "epss_percentile": 0.99865}, "CVE-2019-10069": {"epss_score": 0.06601, "epss_percentile": 0.90879}, "CVE-2019-10070": {"epss_score": 0.0144, "epss_percentile": 0.80295}, "CVE-2019-10071": {"epss_score": 0.09816, "epss_percentile": 0.92715}, "CVE-2019-10072": {"epss_score": 0.71585, "epss_percentile": 0.98674}, "CVE-2019-10073": {"epss_score": 0.02991, "epss_percentile": 0.86142}, "CVE-2019-10074": {"epss_score": 0.02057, "epss_percentile": 0.83429}, "CVE-2019-10076": {"epss_score": 0.03224, "epss_percentile": 0.86681}, "CVE-2019-10077": {"epss_score": 0.03189, "epss_percentile": 0.86594}, "CVE-2019-10078": {"epss_score": 0.03225, "epss_percentile": 0.86684}, "CVE-2019-10079": {"epss_score": 0.05102, "epss_percentile": 0.89499}, "CVE-2019-10080": {"epss_score": 0.00512, "epss_percentile": 0.65868}, "CVE-2019-10081": {"epss_score": 0.23332, "epss_percentile": 0.95767}, "CVE-2019-10082": {"epss_score": 0.47892, "epss_percentile": 0.97607}, "CVE-2019-10083": {"epss_score": 0.00266, "epss_percentile": 0.49889}, "CVE-2019-10084": {"epss_score": 0.00099, "epss_percentile": 0.28409}, "CVE-2019-10085": {"epss_score": 0.01862, "epss_percentile": 0.82595}, "CVE-2019-10086": {"epss_score": 0.00317, "epss_percentile": 0.54386}, "CVE-2019-10087": {"epss_score": 0.05213, "epss_percentile": 0.89618}, "CVE-2019-10088": {"epss_score": 0.01364, "epss_percentile": 0.79769}, "CVE-2019-10089": {"epss_score": 0.05158, "epss_percentile": 0.89555}, "CVE-2019-10090": {"epss_score": 0.05158, "epss_percentile": 0.89555}, "CVE-2019-10091": {"epss_score": 0.00095, "epss_percentile": 0.27229}, "CVE-2019-10092": {"epss_score": 0.82379, "epss_percentile": 0.99192}, "CVE-2019-10093": {"epss_score": 0.01451, "epss_percentile": 0.80359}, "CVE-2019-10094": {"epss_score": 0.00549, "epss_percentile": 0.67313}, "CVE-2019-10095": {"epss_score": 0.03018, "epss_percentile": 0.86219}, "CVE-2019-10097": {"epss_score": 0.26406, "epss_percentile": 0.96144}, "CVE-2019-10098": {"epss_score": 0.77919, "epss_percentile": 0.9896}, "CVE-2019-10099": {"epss_score": 0.00542, "epss_percentile": 0.67074}, "CVE-2019-10100": {"epss_score": 9e-05, "epss_percentile": 0.00712}, "CVE-2019-10101": {"epss_score": 0.00012, "epss_percentile": 0.01264}, "CVE-2019-10102": {"epss_score": 3e-05, "epss_percentile": 0.00089}, "CVE-2019-10103": {"epss_score": 3e-05, "epss_percentile": 0.0011}, "CVE-2019-10104": {"epss_score": 0.00021, "epss_percentile": 0.04915}, "CVE-2019-10105": {"epss_score": 0.00254, "epss_percentile": 0.48499}, "CVE-2019-10106": {"epss_score": 0.00254, "epss_percentile": 0.48499}, "CVE-2019-10107": {"epss_score": 0.00254, "epss_percentile": 0.48499}, "CVE-2019-10108": {"epss_score": 0.00155, "epss_percentile": 0.36781}, "CVE-2019-10109": {"epss_score": 0.00165, "epss_percentile": 0.38123}, "CVE-2019-10110": {"epss_score": 0.00117, "epss_percentile": 0.31277}, "CVE-2019-10111": {"epss_score": 0.00107, "epss_percentile": 0.29749}, "CVE-2019-10112": {"epss_score": 0.0008, "epss_percentile": 0.2401}, "CVE-2019-10113": {"epss_score": 0.00223, "epss_percentile": 0.44848}, "CVE-2019-10114": {"epss_score": 0.00284, "epss_percentile": 0.51449}, "CVE-2019-10115": {"epss_score": 0.00174, "epss_percentile": 0.39199}, "CVE-2019-10116": {"epss_score": 0.00121, "epss_percentile": 0.31836}, "CVE-2019-10117": {"epss_score": 0.0016, "epss_percentile": 0.37485}, "CVE-2019-10118": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2019-10119": {"epss_score": 0.00274, "epss_percentile": 0.50538}, "CVE-2019-10120": {"epss_score": 0.00183, "epss_percentile": 0.40309}, "CVE-2019-10121": {"epss_score": 0.00382, "epss_percentile": 0.59033}, "CVE-2019-10122": {"epss_score": 0.03506, "epss_percentile": 0.87258}, "CVE-2019-10123": {"epss_score": 0.72742, "epss_percentile": 0.98724}, "CVE-2019-10125": {"epss_score": 0.04265, "epss_percentile": 0.88469}, "CVE-2019-10126": {"epss_score": 0.03836, "epss_percentile": 0.87825}, "CVE-2019-10127": {"epss_score": 0.00088, "epss_percentile": 0.25674}, "CVE-2019-10128": {"epss_score": 0.00065, "epss_percentile": 0.20456}, "CVE-2019-10129": {"epss_score": 0.00442, "epss_percentile": 0.62741}, "CVE-2019-10130": {"epss_score": 0.00177, "epss_percentile": 0.39585}, "CVE-2019-10131": {"epss_score": 0.00137, "epss_percentile": 0.34218}, "CVE-2019-10132": {"epss_score": 0.00894, "epss_percentile": 0.75085}, "CVE-2019-10133": {"epss_score": 0.00165, "epss_percentile": 0.38021}, "CVE-2019-10134": {"epss_score": 0.00191, "epss_percentile": 0.41275}, "CVE-2019-10135": {"epss_score": 0.00727, "epss_percentile": 0.72101}, "CVE-2019-10136": {"epss_score": 0.00102, "epss_percentile": 0.28721}, "CVE-2019-10137": {"epss_score": 0.0715, "epss_percentile": 0.91286}, "CVE-2019-10138": {"epss_score": 0.00442, "epss_percentile": 0.62712}, "CVE-2019-10139": {"epss_score": 0.00059, "epss_percentile": 0.18682}, "CVE-2019-10140": {"epss_score": 0.00032, "epss_percentile": 0.09041}, "CVE-2019-10141": {"epss_score": 0.00757, "epss_percentile": 0.72759}, "CVE-2019-10142": {"epss_score": 0.00054, "epss_percentile": 0.173}, "CVE-2019-10143": {"epss_score": 0.00077, "epss_percentile": 0.23326}, "CVE-2019-10144": {"epss_score": 0.00037, "epss_percentile": 0.10906}, "CVE-2019-10145": {"epss_score": 0.00037, "epss_percentile": 0.10906}, "CVE-2019-10146": {"epss_score": 0.00261, "epss_percentile": 0.49307}, "CVE-2019-10147": {"epss_score": 0.0004, "epss_percentile": 0.12105}, "CVE-2019-10149": {"epss_score": 0.93927, "epss_percentile": 0.99868}, "CVE-2019-10150": {"epss_score": 0.00304, "epss_percentile": 0.53242}, "CVE-2019-10152": {"epss_score": 0.00357, "epss_percentile": 0.57477}, "CVE-2019-10153": {"epss_score": 0.00465, "epss_percentile": 0.63762}, "CVE-2019-10154": {"epss_score": 0.00236, "epss_percentile": 0.46456}, "CVE-2019-10155": {"epss_score": 0.00226, "epss_percentile": 0.45282}, "CVE-2019-10156": {"epss_score": 0.00601, "epss_percentile": 0.68842}, "CVE-2019-10157": {"epss_score": 0.00019, "epss_percentile": 0.04255}, "CVE-2019-10158": {"epss_score": 0.00509, "epss_percentile": 0.65735}, "CVE-2019-10159": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2019-10160": {"epss_score": 0.01797, "epss_percentile": 0.82309}, "CVE-2019-10161": {"epss_score": 0.00264, "epss_percentile": 0.49691}, "CVE-2019-10162": {"epss_score": 7e-05, "epss_percentile": 0.00459}, "CVE-2019-10163": {"epss_score": 8e-05, "epss_percentile": 0.00507}, "CVE-2019-10164": {"epss_score": 0.05903, "epss_percentile": 0.90311}, "CVE-2019-10165": {"epss_score": 0.00059, "epss_percentile": 0.18915}, "CVE-2019-10166": {"epss_score": 0.00142, "epss_percentile": 0.3499}, "CVE-2019-10167": {"epss_score": 0.00169, "epss_percentile": 0.38566}, "CVE-2019-10168": {"epss_score": 0.0023, "epss_percentile": 0.45669}, "CVE-2019-10169": {"epss_score": 0.00608, "epss_percentile": 0.69068}, "CVE-2019-10170": {"epss_score": 0.00742, "epss_percentile": 0.7246}, "CVE-2019-10171": {"epss_score": 0.00249, "epss_percentile": 0.4808}, "CVE-2019-10172": {"epss_score": 0.00563, "epss_percentile": 0.6771}, "CVE-2019-10173": {"epss_score": 0.91872, "epss_percentile": 0.99674}, "CVE-2019-10174": {"epss_score": 0.01037, "epss_percentile": 0.76929}, "CVE-2019-10175": {"epss_score": 0.00173, "epss_percentile": 0.39092}, "CVE-2019-10176": {"epss_score": 0.0012, "epss_percentile": 0.31721}, "CVE-2019-10177": {"epss_score": 0.00335, "epss_percentile": 0.55863}, "CVE-2019-10178": {"epss_score": 0.01178, "epss_percentile": 0.78282}, "CVE-2019-10179": {"epss_score": 0.00616, "epss_percentile": 0.6933}, "CVE-2019-10180": {"epss_score": 0.00708, "epss_percentile": 0.71683}, "CVE-2019-10181": {"epss_score": 0.00334, "epss_percentile": 0.55732}, "CVE-2019-10182": {"epss_score": 0.01428, "epss_percentile": 0.80222}, "CVE-2019-10183": {"epss_score": 0.00139, "epss_percentile": 0.34647}, "CVE-2019-10184": {"epss_score": 0.0068, "epss_percentile": 0.71026}, "CVE-2019-10185": {"epss_score": 0.01563, "epss_percentile": 0.81049}, "CVE-2019-10186": {"epss_score": 0.00309, "epss_percentile": 0.53669}, "CVE-2019-10187": {"epss_score": 0.00159, "epss_percentile": 0.37353}, "CVE-2019-10188": {"epss_score": 0.00159, "epss_percentile": 0.37353}, "CVE-2019-10189": {"epss_score": 0.00159, "epss_percentile": 0.37353}, "CVE-2019-10190": {"epss_score": 0.00262, "epss_percentile": 0.49331}, "CVE-2019-10191": {"epss_score": 0.00268, "epss_percentile": 0.50022}, "CVE-2019-10192": {"epss_score": 0.21637, "epss_percentile": 0.95542}, "CVE-2019-10193": {"epss_score": 0.33463, "epss_percentile": 0.96775}, "CVE-2019-10194": {"epss_score": 0.00082, "epss_percentile": 0.24465}, "CVE-2019-10195": {"epss_score": 0.00879, "epss_percentile": 0.74843}, "CVE-2019-10196": {"epss_score": 0.00364, "epss_percentile": 0.57957}, "CVE-2019-10197": {"epss_score": 0.04729, "epss_percentile": 0.89068}, "CVE-2019-10198": {"epss_score": 0.01423, "epss_percentile": 0.80188}, "CVE-2019-10199": {"epss_score": 0.00095, "epss_percentile": 0.27143}, "CVE-2019-10200": {"epss_score": 0.0039, "epss_percentile": 0.59543}, "CVE-2019-10201": {"epss_score": 0.00136, "epss_percentile": 0.3411}, "CVE-2019-10202": {"epss_score": 0.0724, "epss_percentile": 0.91343}, "CVE-2019-10203": {"epss_score": 0.00022, "epss_percentile": 0.05065}, "CVE-2019-10205": {"epss_score": 0.00109, "epss_percentile": 0.29984}, "CVE-2019-10206": {"epss_score": 0.00214, "epss_percentile": 0.4399}, "CVE-2019-10207": {"epss_score": 0.00703, "epss_percentile": 0.71544}, "CVE-2019-10208": {"epss_score": 0.00309, "epss_percentile": 0.53655}, "CVE-2019-10209": {"epss_score": 0.00442, "epss_percentile": 0.6271}, "CVE-2019-10210": {"epss_score": 0.00282, "epss_percentile": 0.51267}, "CVE-2019-10211": {"epss_score": 0.01186, "epss_percentile": 0.7835}, "CVE-2019-10212": {"epss_score": 0.0029, "epss_percentile": 0.52109}, "CVE-2019-10213": {"epss_score": 0.00451, "epss_percentile": 0.63126}, "CVE-2019-10214": {"epss_score": 0.0041, "epss_percentile": 0.60815}, "CVE-2019-10215": {"epss_score": 0.00428, "epss_percentile": 0.61948}, "CVE-2019-10216": {"epss_score": 0.00526, "epss_percentile": 0.6641}, "CVE-2019-10217": {"epss_score": 0.00449, "epss_percentile": 0.63054}, "CVE-2019-10218": {"epss_score": 0.04508, "epss_percentile": 0.88776}, "CVE-2019-10219": {"epss_score": 0.01674, "epss_percentile": 0.81693}, "CVE-2019-10220": {"epss_score": 0.00744, "epss_percentile": 0.72511}, "CVE-2019-10221": {"epss_score": 0.00669, "epss_percentile": 0.70751}, "CVE-2019-10222": {"epss_score": 0.02656, "epss_percentile": 0.85357}, "CVE-2019-10223": {"epss_score": 0.01162, "epss_percentile": 0.78151}, "CVE-2019-10224": {"epss_score": 0.00052, "epss_percentile": 0.16538}, "CVE-2019-10225": {"epss_score": 0.00147, "epss_percentile": 0.35785}, "CVE-2019-10226": {"epss_score": 0.02501, "epss_percentile": 0.84923}, "CVE-2019-10227": {"epss_score": 0.00391, "epss_percentile": 0.59576}, "CVE-2019-10229": {"epss_score": 0.00336, "epss_percentile": 0.55939}, "CVE-2019-10231": {"epss_score": 0.00313, "epss_percentile": 0.54063}, "CVE-2019-10232": {"epss_score": 0.89565, "epss_percentile": 0.99531}, "CVE-2019-10233": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-10237": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-10238": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-10239": {"epss_score": 0.00137, "epss_percentile": 0.34305}, "CVE-2019-10240": {"epss_score": 0.00082, "epss_percentile": 0.24406}, "CVE-2019-10241": {"epss_score": 0.09852, "epss_percentile": 0.92735}, "CVE-2019-10242": {"epss_score": 0.00929, "epss_percentile": 0.75593}, "CVE-2019-10243": {"epss_score": 0.00174, "epss_percentile": 0.39223}, "CVE-2019-10244": {"epss_score": 0.00219, "epss_percentile": 0.44529}, "CVE-2019-10245": {"epss_score": 0.01619, "epss_percentile": 0.81381}, "CVE-2019-10246": {"epss_score": 0.02675, "epss_percentile": 0.854}, "CVE-2019-10247": {"epss_score": 0.06593, "epss_percentile": 0.90874}, "CVE-2019-10248": {"epss_score": 0.00165, "epss_percentile": 0.38062}, "CVE-2019-10249": {"epss_score": 0.0016, "epss_percentile": 0.37445}, "CVE-2019-10250": {"epss_score": 0.00156, "epss_percentile": 0.36883}, "CVE-2019-10251": {"epss_score": 0.00156, "epss_percentile": 0.36883}, "CVE-2019-10253": {"epss_score": 0.00206, "epss_percentile": 0.43069}, "CVE-2019-10254": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-10255": {"epss_score": 0.00489, "epss_percentile": 0.64904}, "CVE-2019-10256": {"epss_score": 0.00626, "epss_percentile": 0.6961}, "CVE-2019-10257": {"epss_score": 0.0231, "epss_percentile": 0.84333}, "CVE-2019-10260": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-10261": {"epss_score": 0.00617, "epss_percentile": 0.69342}, "CVE-2019-10262": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-10263": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-10264": {"epss_score": 0.00451, "epss_percentile": 0.63157}, "CVE-2019-10265": {"epss_score": 0.00724, "epss_percentile": 0.72043}, "CVE-2019-10266": {"epss_score": 0.1855, "epss_percentile": 0.95031}, "CVE-2019-10267": {"epss_score": 0.64364, "epss_percentile": 0.98375}, "CVE-2019-10269": {"epss_score": 0.00833, "epss_percentile": 0.74077}, "CVE-2019-10270": {"epss_score": 0.00168, "epss_percentile": 0.38437}, "CVE-2019-10271": {"epss_score": 0.00222, "epss_percentile": 0.44773}, "CVE-2019-10272": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2019-10273": {"epss_score": 0.13926, "epss_percentile": 0.94094}, "CVE-2019-10276": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2019-10277": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10278": {"epss_score": 0.00156, "epss_percentile": 0.36953}, "CVE-2019-10279": {"epss_score": 0.00055, "epss_percentile": 0.17415}, "CVE-2019-10280": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10281": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10282": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10283": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10284": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10285": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10286": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10287": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10288": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10289": {"epss_score": 0.00142, "epss_percentile": 0.35035}, "CVE-2019-10290": {"epss_score": 0.00084, "epss_percentile": 0.24872}, "CVE-2019-10291": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10292": {"epss_score": 0.00156, "epss_percentile": 0.36953}, "CVE-2019-10293": {"epss_score": 0.00055, "epss_percentile": 0.17415}, "CVE-2019-10294": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10295": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10296": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10297": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10298": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10299": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10300": {"epss_score": 0.00089, "epss_percentile": 0.25905}, "CVE-2019-10301": {"epss_score": 0.00067, "epss_percentile": 0.21042}, "CVE-2019-10302": {"epss_score": 0.00067, "epss_percentile": 0.21042}, "CVE-2019-10303": {"epss_score": 0.00067, "epss_percentile": 0.21042}, "CVE-2019-10304": {"epss_score": 0.00066, "epss_percentile": 0.20803}, "CVE-2019-10305": {"epss_score": 0.0003, "epss_percentile": 0.08076}, "CVE-2019-10306": {"epss_score": 0.0028, "epss_percentile": 0.51023}, "CVE-2019-10307": {"epss_score": 0.00194, "epss_percentile": 0.41587}, "CVE-2019-10308": {"epss_score": 0.00084, "epss_percentile": 0.24872}, "CVE-2019-10309": {"epss_score": 0.00072, "epss_percentile": 0.2247}, "CVE-2019-10310": {"epss_score": 0.00149, "epss_percentile": 0.35949}, "CVE-2019-10311": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10312": {"epss_score": 0.0004, "epss_percentile": 0.12186}, "CVE-2019-10313": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10314": {"epss_score": 0.00063, "epss_percentile": 0.19913}, "CVE-2019-10315": {"epss_score": 0.00113, "epss_percentile": 0.30671}, "CVE-2019-10316": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10317": {"epss_score": 0.00063, "epss_percentile": 0.19913}, "CVE-2019-10318": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10319": {"epss_score": 0.00036, "epss_percentile": 0.10437}, "CVE-2019-10320": {"epss_score": 0.00118, "epss_percentile": 0.31447}, "CVE-2019-10321": {"epss_score": 0.00128, "epss_percentile": 0.32952}, "CVE-2019-10322": {"epss_score": 0.00264, "epss_percentile": 0.49701}, "CVE-2019-10323": {"epss_score": 0.00264, "epss_percentile": 0.49701}, "CVE-2019-10324": {"epss_score": 0.00133, "epss_percentile": 0.33738}, "CVE-2019-10325": {"epss_score": 0.00058, "epss_percentile": 0.18535}, "CVE-2019-10326": {"epss_score": 0.00277, "epss_percentile": 0.50806}, "CVE-2019-10327": {"epss_score": 0.00148, "epss_percentile": 0.35872}, "CVE-2019-10328": {"epss_score": 0.00282, "epss_percentile": 0.51222}, "CVE-2019-10329": {"epss_score": 0.00311, "epss_percentile": 0.53808}, "CVE-2019-10330": {"epss_score": 0.00823, "epss_percentile": 0.73926}, "CVE-2019-10331": {"epss_score": 0.0022, "epss_percentile": 0.44568}, "CVE-2019-10332": {"epss_score": 0.0013, "epss_percentile": 0.33263}, "CVE-2019-10333": {"epss_score": 0.00041, "epss_percentile": 0.12336}, "CVE-2019-10334": {"epss_score": 0.00055, "epss_percentile": 0.17579}, "CVE-2019-10335": {"epss_score": 0.00058, "epss_percentile": 0.18535}, "CVE-2019-10336": {"epss_score": 0.00065, "epss_percentile": 0.20467}, "CVE-2019-10337": {"epss_score": 0.00237, "epss_percentile": 0.4672}, "CVE-2019-10338": {"epss_score": 0.00097, "epss_percentile": 0.27495}, "CVE-2019-10339": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10340": {"epss_score": 0.00133, "epss_percentile": 0.33724}, "CVE-2019-10341": {"epss_score": 0.0017, "epss_percentile": 0.38757}, "CVE-2019-10342": {"epss_score": 0.0004, "epss_percentile": 0.12186}, "CVE-2019-10343": {"epss_score": 0.00015, "epss_percentile": 0.02158}, "CVE-2019-10344": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-10345": {"epss_score": 0.00011, "epss_percentile": 0.01071}, "CVE-2019-10346": {"epss_score": 0.00249, "epss_percentile": 0.4807}, "CVE-2019-10347": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2019-10348": {"epss_score": 0.00088, "epss_percentile": 0.25652}, "CVE-2019-10349": {"epss_score": 0.00791, "epss_percentile": 0.73389}, "CVE-2019-10350": {"epss_score": 0.00088, "epss_percentile": 0.25652}, "CVE-2019-10351": {"epss_score": 0.00088, "epss_percentile": 0.25652}, "CVE-2019-10352": {"epss_score": 0.40371, "epss_percentile": 0.97216}, "CVE-2019-10353": {"epss_score": 0.00169, "epss_percentile": 0.38558}, "CVE-2019-10354": {"epss_score": 0.00196, "epss_percentile": 0.41769}, "CVE-2019-10355": {"epss_score": 0.00042, "epss_percentile": 0.1267}, "CVE-2019-10356": {"epss_score": 0.00042, "epss_percentile": 0.1267}, "CVE-2019-10357": {"epss_score": 0.00064, "epss_percentile": 0.20282}, "CVE-2019-10358": {"epss_score": 0.00139, "epss_percentile": 0.34565}, "CVE-2019-10359": {"epss_score": 0.00136, "epss_percentile": 0.34133}, "CVE-2019-10360": {"epss_score": 0.00102, "epss_percentile": 0.28765}, "CVE-2019-10361": {"epss_score": 0.00018, "epss_percentile": 0.0388}, "CVE-2019-10362": {"epss_score": 0.00119, "epss_percentile": 0.31681}, "CVE-2019-10363": {"epss_score": 0.00051, "epss_percentile": 0.16251}, "CVE-2019-10364": {"epss_score": 0.00029, "epss_percentile": 0.07944}, "CVE-2019-10365": {"epss_score": 0.00086, "epss_percentile": 0.25433}, "CVE-2019-10366": {"epss_score": 0.0017, "epss_percentile": 0.38757}, "CVE-2019-10367": {"epss_score": 0.00022, "epss_percentile": 0.04949}, "CVE-2019-10368": {"epss_score": 0.00087, "epss_percentile": 0.25524}, "CVE-2019-10369": {"epss_score": 0.00068, "epss_percentile": 0.21253}, "CVE-2019-10370": {"epss_score": 0.00128, "epss_percentile": 0.33059}, "CVE-2019-10371": {"epss_score": 0.00055, "epss_percentile": 0.17593}, "CVE-2019-10372": {"epss_score": 0.00054, "epss_percentile": 0.17111}, "CVE-2019-10373": {"epss_score": 0.00102, "epss_percentile": 0.28765}, "CVE-2019-10374": {"epss_score": 0.00102, "epss_percentile": 0.28765}, "CVE-2019-10375": {"epss_score": 0.0027, "epss_percentile": 0.502}, "CVE-2019-10376": {"epss_score": 0.00113, "epss_percentile": 0.30664}, "CVE-2019-10377": {"epss_score": 0.00031, "epss_percentile": 0.08662}, "CVE-2019-10378": {"epss_score": 0.00016, "epss_percentile": 0.02869}, "CVE-2019-10379": {"epss_score": 0.00085, "epss_percentile": 0.25046}, "CVE-2019-10380": {"epss_score": 0.00248, "epss_percentile": 0.47929}, "CVE-2019-10381": {"epss_score": 0.00053, "epss_percentile": 0.16702}, "CVE-2019-10382": {"epss_score": 0.0005, "epss_percentile": 0.15722}, "CVE-2019-10383": {"epss_score": 0.00539, "epss_percentile": 0.66973}, "CVE-2019-10384": {"epss_score": 0.00152, "epss_percentile": 0.36485}, "CVE-2019-10385": {"epss_score": 0.0017, "epss_percentile": 0.38757}, "CVE-2019-10386": {"epss_score": 0.00127, "epss_percentile": 0.32939}, "CVE-2019-10387": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2019-10388": {"epss_score": 0.00528, "epss_percentile": 0.66561}, "CVE-2019-10389": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-10390": {"epss_score": 0.00052, "epss_percentile": 0.16563}, "CVE-2019-10391": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2019-10392": {"epss_score": 0.83284, "epss_percentile": 0.99242}, "CVE-2019-10393": {"epss_score": 0.00221, "epss_percentile": 0.44647}, "CVE-2019-10394": {"epss_score": 0.00221, "epss_percentile": 0.44647}, "CVE-2019-10395": {"epss_score": 0.00102, "epss_percentile": 0.28765}, "CVE-2019-10396": {"epss_score": 0.00102, "epss_percentile": 0.28765}, "CVE-2019-10397": {"epss_score": 0.00033, "epss_percentile": 0.09325}, "CVE-2019-10398": {"epss_score": 0.00011, "epss_percentile": 0.01071}, "CVE-2019-10399": {"epss_score": 0.00221, "epss_percentile": 0.44647}, "CVE-2019-10400": {"epss_score": 0.00221, "epss_percentile": 0.44647}, "CVE-2019-10401": {"epss_score": 0.00541, "epss_percentile": 0.67057}, "CVE-2019-10402": {"epss_score": 0.00541, "epss_percentile": 0.67057}, "CVE-2019-10403": {"epss_score": 0.00541, "epss_percentile": 0.67057}, "CVE-2019-10404": {"epss_score": 0.00541, "epss_percentile": 0.67057}, "CVE-2019-10405": {"epss_score": 0.81459, "epss_percentile": 0.99139}, "CVE-2019-10406": {"epss_score": 0.00556, "epss_percentile": 0.67507}, "CVE-2019-10407": {"epss_score": 0.00191, "epss_percentile": 0.41262}, "CVE-2019-10408": {"epss_score": 0.00377, "epss_percentile": 0.58755}, "CVE-2019-10409": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-10410": {"epss_score": 0.00136, "epss_percentile": 0.34161}, "CVE-2019-10411": {"epss_score": 0.00068, "epss_percentile": 0.2132}, "CVE-2019-10412": {"epss_score": 0.00068, "epss_percentile": 0.2132}, "CVE-2019-10413": {"epss_score": 0.00065, "epss_percentile": 0.20555}, "CVE-2019-10414": {"epss_score": 0.00065, "epss_percentile": 0.20555}, "CVE-2019-10415": {"epss_score": 0.00065, "epss_percentile": 0.20555}, "CVE-2019-10416": {"epss_score": 0.00065, "epss_percentile": 0.20555}, "CVE-2019-10417": {"epss_score": 0.00184, "epss_percentile": 0.40385}, "CVE-2019-10418": {"epss_score": 0.00101, "epss_percentile": 0.28568}, "CVE-2019-10419": {"epss_score": 0.00026, "epss_percentile": 0.06729}, "CVE-2019-10420": {"epss_score": 0.00026, "epss_percentile": 0.06729}, "CVE-2019-10421": {"epss_score": 0.00056, "epss_percentile": 0.17786}, "CVE-2019-10422": {"epss_score": 0.00065, "epss_percentile": 0.20555}, "CVE-2019-10423": {"epss_score": 0.00026, "epss_percentile": 0.06729}, "CVE-2019-10424": {"epss_score": 0.00026, "epss_percentile": 0.06729}, "CVE-2019-10425": {"epss_score": 0.00065, "epss_percentile": 0.20555}, "CVE-2019-10426": {"epss_score": 0.00026, "epss_percentile": 0.06729}, "CVE-2019-10427": {"epss_score": 0.00048, "epss_percentile": 0.15229}, "CVE-2019-10428": {"epss_score": 0.00068, "epss_percentile": 0.2132}, "CVE-2019-10429": {"epss_score": 0.00026, "epss_percentile": 0.06729}, "CVE-2019-10430": {"epss_score": 0.00025, "epss_percentile": 0.06264}, "CVE-2019-10431": {"epss_score": 0.00407, "epss_percentile": 0.60606}, "CVE-2019-10432": {"epss_score": 0.00193, "epss_percentile": 0.41485}, "CVE-2019-10433": {"epss_score": 0.00011, "epss_percentile": 0.01058}, "CVE-2019-10434": {"epss_score": 0.00049, "epss_percentile": 0.15612}, "CVE-2019-10435": {"epss_score": 0.00049, "epss_percentile": 0.15612}, "CVE-2019-10436": {"epss_score": 0.00146, "epss_percentile": 0.35583}, "CVE-2019-10437": {"epss_score": 0.00093, "epss_percentile": 0.26627}, "CVE-2019-10438": {"epss_score": 0.00048, "epss_percentile": 0.15045}, "CVE-2019-10439": {"epss_score": 0.00031, "epss_percentile": 0.08662}, "CVE-2019-10440": {"epss_score": 0.00086, "epss_percentile": 0.25382}, "CVE-2019-10441": {"epss_score": 0.00253, "epss_percentile": 0.48453}, "CVE-2019-10442": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-10443": {"epss_score": 0.00118, "epss_percentile": 0.31504}, "CVE-2019-10444": {"epss_score": 0.00036, "epss_percentile": 0.10395}, "CVE-2019-10445": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-10446": {"epss_score": 0.0005, "epss_percentile": 0.15722}, "CVE-2019-10447": {"epss_score": 0.00024, "epss_percentile": 0.05863}, "CVE-2019-10448": {"epss_score": 0.00067, "epss_percentile": 0.21042}, "CVE-2019-10449": {"epss_score": 0.0009, "epss_percentile": 0.26121}, "CVE-2019-10450": {"epss_score": 7e-05, "epss_percentile": 0.0037}, "CVE-2019-10451": {"epss_score": 0.00023, "epss_percentile": 0.05369}, "CVE-2019-10452": {"epss_score": 0.00023, "epss_percentile": 0.05369}, "CVE-2019-10453": {"epss_score": 0.00011, "epss_percentile": 0.01012}, "CVE-2019-10454": {"epss_score": 0.00253, "epss_percentile": 0.48453}, "CVE-2019-10455": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-10456": {"epss_score": 0.00231, "epss_percentile": 0.45847}, "CVE-2019-10457": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-10458": {"epss_score": 0.00326, "epss_percentile": 0.55057}, "CVE-2019-10459": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2019-10460": {"epss_score": 0.00012, "epss_percentile": 0.01122}, "CVE-2019-10461": {"epss_score": 0.00012, "epss_percentile": 0.01122}, "CVE-2019-10462": {"epss_score": 0.0012, "epss_percentile": 0.31792}, "CVE-2019-10463": {"epss_score": 0.00048, "epss_percentile": 0.15045}, "CVE-2019-10464": {"epss_score": 0.0011, "epss_percentile": 0.30124}, "CVE-2019-10465": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-10466": {"epss_score": 0.00124, "epss_percentile": 0.32353}, "CVE-2019-10467": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2019-10468": {"epss_score": 0.00093, "epss_percentile": 0.26627}, "CVE-2019-10469": {"epss_score": 0.00048, "epss_percentile": 0.15045}, "CVE-2019-10470": {"epss_score": 0.00048, "epss_percentile": 0.15045}, "CVE-2019-10471": {"epss_score": 0.00093, "epss_percentile": 0.26627}, "CVE-2019-10472": {"epss_score": 0.00048, "epss_percentile": 0.15045}, "CVE-2019-10473": {"epss_score": 0.00031, "epss_percentile": 0.08662}, "CVE-2019-10474": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-10475": {"epss_score": 0.91969, "epss_percentile": 0.99682}, "CVE-2019-10476": {"epss_score": 0.00012, "epss_percentile": 0.01122}, "CVE-2019-10477": {"epss_score": 0.00308, "epss_percentile": 0.53634}, "CVE-2019-10478": {"epss_score": 0.00726, "epss_percentile": 0.72072}, "CVE-2019-10479": {"epss_score": 0.02954, "epss_percentile": 0.86059}, "CVE-2019-10480": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-10481": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-10482": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2019-10483": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2019-10484": {"epss_score": 0.00049, "epss_percentile": 0.15543}, "CVE-2019-10485": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2019-10486": {"epss_score": 0.00033, "epss_percentile": 0.09339}, "CVE-2019-10487": {"epss_score": 0.00396, "epss_percentile": 0.59859}, "CVE-2019-10488": {"epss_score": 0.0044, "epss_percentile": 0.62619}, "CVE-2019-10489": {"epss_score": 0.00369, "epss_percentile": 0.58256}, "CVE-2019-10490": {"epss_score": 0.00102, "epss_percentile": 0.28778}, "CVE-2019-10491": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-10492": {"epss_score": 0.00017, "epss_percentile": 0.0311}, "CVE-2019-10493": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-10494": {"epss_score": 0.00161, "epss_percentile": 0.37519}, "CVE-2019-10495": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-10496": {"epss_score": 0.00045, "epss_percentile": 0.13758}, "CVE-2019-10497": {"epss_score": 0.0005, "epss_percentile": 0.15654}, "CVE-2019-10498": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2019-10499": {"epss_score": 0.00035, "epss_percentile": 0.10064}, "CVE-2019-10500": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-10501": {"epss_score": 0.00101, "epss_percentile": 0.28595}, "CVE-2019-10502": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2019-10503": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-10504": {"epss_score": 0.00249, "epss_percentile": 0.48023}, "CVE-2019-10505": {"epss_score": 0.00322, "epss_percentile": 0.54823}, "CVE-2019-10506": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-10507": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-10508": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-10509": {"epss_score": 0.00266, "epss_percentile": 0.49846}, "CVE-2019-10510": {"epss_score": 0.0028, "epss_percentile": 0.51008}, "CVE-2019-10511": {"epss_score": 0.00312, "epss_percentile": 0.53991}, "CVE-2019-10512": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-10513": {"epss_score": 0.0011, "epss_percentile": 0.3018}, "CVE-2019-10515": {"epss_score": 0.00042, "epss_percentile": 0.12926}, "CVE-2019-10516": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-10517": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-10518": {"epss_score": 0.00044, "epss_percentile": 0.13562}, "CVE-2019-10520": {"epss_score": 0.00042, "epss_percentile": 0.12926}, "CVE-2019-10522": {"epss_score": 0.00441, "epss_percentile": 0.62672}, "CVE-2019-10523": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2019-10524": {"epss_score": 0.0005, "epss_percentile": 0.15654}, "CVE-2019-10525": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-10526": {"epss_score": 0.00312, "epss_percentile": 0.53991}, "CVE-2019-10527": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2019-10528": {"epss_score": 0.00395, "epss_percentile": 0.5983}, "CVE-2019-10529": {"epss_score": 0.09057, "epss_percentile": 0.92382}, "CVE-2019-10530": {"epss_score": 0.00045, "epss_percentile": 0.13758}, "CVE-2019-10531": {"epss_score": 0.00271, "epss_percentile": 0.50331}, "CVE-2019-10532": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-10533": {"epss_score": 0.00251, "epss_percentile": 0.48323}, "CVE-2019-10534": {"epss_score": 0.00216, "epss_percentile": 0.44138}, "CVE-2019-10535": {"epss_score": 0.00044, "epss_percentile": 0.13513}, "CVE-2019-10536": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-10537": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-10538": {"epss_score": 0.0033, "epss_percentile": 0.5543}, "CVE-2019-10539": {"epss_score": 0.00427, "epss_percentile": 0.61873}, "CVE-2019-10540": {"epss_score": 0.00761, "epss_percentile": 0.72821}, "CVE-2019-10541": {"epss_score": 0.00301, "epss_percentile": 0.53068}, "CVE-2019-10542": {"epss_score": 0.00336, "epss_percentile": 0.56001}, "CVE-2019-10544": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-10545": {"epss_score": 0.00107, "epss_percentile": 0.29663}, "CVE-2019-10546": {"epss_score": 0.00427, "epss_percentile": 0.61873}, "CVE-2019-10547": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-10548": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2019-10549": {"epss_score": 0.00246, "epss_percentile": 0.47772}, "CVE-2019-10550": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2019-10551": {"epss_score": 0.00263, "epss_percentile": 0.49484}, "CVE-2019-10552": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2019-10553": {"epss_score": 0.00219, "epss_percentile": 0.44503}, "CVE-2019-10554": {"epss_score": 0.00219, "epss_percentile": 0.44503}, "CVE-2019-10555": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2019-10556": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2019-10557": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-10558": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-10559": {"epss_score": 0.00317, "epss_percentile": 0.54366}, "CVE-2019-10561": {"epss_score": 0.00236, "epss_percentile": 0.46431}, "CVE-2019-10562": {"epss_score": 0.00016, "epss_percentile": 0.02798}, "CVE-2019-10563": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-10564": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-10565": {"epss_score": 0.00322, "epss_percentile": 0.54823}, "CVE-2019-10566": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2019-10567": {"epss_score": 0.00203, "epss_percentile": 0.42554}, "CVE-2019-10569": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2019-10571": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-10572": {"epss_score": 0.00363, "epss_percentile": 0.57862}, "CVE-2019-10574": {"epss_score": 0.00059, "epss_percentile": 0.18683}, "CVE-2019-10575": {"epss_score": 0.00015, "epss_percentile": 0.02151}, "CVE-2019-10577": {"epss_score": 0.00263, "epss_percentile": 0.49484}, "CVE-2019-10578": {"epss_score": 0.00369, "epss_percentile": 0.58256}, "CVE-2019-10579": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2019-10580": {"epss_score": 0.00096, "epss_percentile": 0.27446}, "CVE-2019-10581": {"epss_score": 0.00388, "epss_percentile": 0.5934}, "CVE-2019-10582": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2019-10583": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2019-10584": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-10585": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2019-10586": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-10587": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-10588": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-10589": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-10590": {"epss_score": 0.00396, "epss_percentile": 0.59859}, "CVE-2019-10591": {"epss_score": 0.00369, "epss_percentile": 0.58256}, "CVE-2019-10592": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-10593": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-10594": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-10595": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-10596": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-10597": {"epss_score": 0.00035, "epss_percentile": 0.10064}, "CVE-2019-10598": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-10600": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-10601": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-10602": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2019-10603": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2019-10604": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-10605": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-10606": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-10607": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-10608": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2019-10609": {"epss_score": 0.00312, "epss_percentile": 0.53991}, "CVE-2019-10610": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2019-10611": {"epss_score": 0.00427, "epss_percentile": 0.61873}, "CVE-2019-10612": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-10614": {"epss_score": 0.00294, "epss_percentile": 0.52436}, "CVE-2019-10615": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2019-10616": {"epss_score": 0.0004, "epss_percentile": 0.1193}, "CVE-2019-10617": {"epss_score": 0.00083, "epss_percentile": 0.24752}, "CVE-2019-10618": {"epss_score": 0.00087, "epss_percentile": 0.25449}, "CVE-2019-10620": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-10621": {"epss_score": 0.00044, "epss_percentile": 0.13562}, "CVE-2019-10622": {"epss_score": 0.00176, "epss_percentile": 0.39442}, "CVE-2019-10623": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-10624": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2019-10625": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-10626": {"epss_score": 0.00043, "epss_percentile": 0.13285}, "CVE-2019-10627": {"epss_score": 0.0056, "epss_percentile": 0.67636}, "CVE-2019-10628": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-10629": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-10630": {"epss_score": 0.00307, "epss_percentile": 0.53497}, "CVE-2019-10631": {"epss_score": 0.00917, "epss_percentile": 0.75429}, "CVE-2019-10632": {"epss_score": 0.00202, "epss_percentile": 0.42409}, "CVE-2019-10633": {"epss_score": 0.0238, "epss_percentile": 0.84563}, "CVE-2019-10634": {"epss_score": 0.00157, "epss_percentile": 0.37034}, "CVE-2019-10636": {"epss_score": 0.00061, "epss_percentile": 0.193}, "CVE-2019-10637": {"epss_score": 0.00058, "epss_percentile": 0.18434}, "CVE-2019-10638": {"epss_score": 0.0103, "epss_percentile": 0.76847}, "CVE-2019-10639": {"epss_score": 0.01541, "epss_percentile": 0.80944}, "CVE-2019-10640": {"epss_score": 0.00212, "epss_percentile": 0.43745}, "CVE-2019-10641": {"epss_score": 0.00266, "epss_percentile": 0.49909}, "CVE-2019-10642": {"epss_score": 0.00146, "epss_percentile": 0.35528}, "CVE-2019-10643": {"epss_score": 0.00428, "epss_percentile": 0.61936}, "CVE-2019-10644": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2019-10646": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-10647": {"epss_score": 0.61932, "epss_percentile": 0.98268}, "CVE-2019-10648": {"epss_score": 0.00726, "epss_percentile": 0.72071}, "CVE-2019-10649": {"epss_score": 0.00582, "epss_percentile": 0.68309}, "CVE-2019-10650": {"epss_score": 0.00503, "epss_percentile": 0.65444}, "CVE-2019-10651": {"epss_score": 0.23329, "epss_percentile": 0.95765}, "CVE-2019-10652": {"epss_score": 0.02356, "epss_percentile": 0.84484}, "CVE-2019-10653": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-10654": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2019-10655": {"epss_score": 0.72588, "epss_percentile": 0.98717}, "CVE-2019-10656": {"epss_score": 0.02829, "epss_percentile": 0.85771}, "CVE-2019-10657": {"epss_score": 0.00227, "epss_percentile": 0.45387}, "CVE-2019-10658": {"epss_score": 0.0223, "epss_percentile": 0.84086}, "CVE-2019-10659": {"epss_score": 0.02417, "epss_percentile": 0.84691}, "CVE-2019-10660": {"epss_score": 0.02417, "epss_percentile": 0.84691}, "CVE-2019-10661": {"epss_score": 0.00393, "epss_percentile": 0.59724}, "CVE-2019-10662": {"epss_score": 0.10164, "epss_percentile": 0.92871}, "CVE-2019-10663": {"epss_score": 0.00535, "epss_percentile": 0.66832}, "CVE-2019-10664": {"epss_score": 0.03598, "epss_percentile": 0.87408}, "CVE-2019-10665": {"epss_score": 5e-05, "epss_percentile": 0.00193}, "CVE-2019-10666": {"epss_score": 4e-05, "epss_percentile": 0.00146}, "CVE-2019-10667": {"epss_score": 4e-05, "epss_percentile": 0.00147}, "CVE-2019-10668": {"epss_score": 4e-05, "epss_percentile": 0.00144}, "CVE-2019-10669": {"epss_score": 0.68361, "epss_percentile": 0.98543}, "CVE-2019-10670": {"epss_score": 3e-05, "epss_percentile": 0.00061}, "CVE-2019-10671": {"epss_score": 8e-05, "epss_percentile": 0.00575}, "CVE-2019-10672": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2019-10673": {"epss_score": 0.00428, "epss_percentile": 0.6194}, "CVE-2019-10676": {"epss_score": 0.01497, "epss_percentile": 0.80688}, "CVE-2019-10677": {"epss_score": 0.05501, "epss_percentile": 0.89938}, "CVE-2019-10678": {"epss_score": 0.14367, "epss_percentile": 0.94195}, "CVE-2019-10679": {"epss_score": 0.00096, "epss_percentile": 0.27408}, "CVE-2019-10682": {"epss_score": 0.00218, "epss_percentile": 0.44347}, "CVE-2019-10684": {"epss_score": 0.00778, "epss_percentile": 0.73127}, "CVE-2019-10685": {"epss_score": 0.0044, "epss_percentile": 0.62642}, "CVE-2019-10686": {"epss_score": 0.0035, "epss_percentile": 0.56975}, "CVE-2019-10687": {"epss_score": 0.0128, "epss_percentile": 0.79141}, "CVE-2019-10688": {"epss_score": 0.00054, "epss_percentile": 0.1726}, "CVE-2019-10689": {"epss_score": 0.00333, "epss_percentile": 0.55621}, "CVE-2019-10691": {"epss_score": 0.00809, "epss_percentile": 0.73712}, "CVE-2019-10692": {"epss_score": 0.89356, "epss_percentile": 0.99521}, "CVE-2019-10694": {"epss_score": 0.0042, "epss_percentile": 0.6141}, "CVE-2019-10695": {"epss_score": 0.00405, "epss_percentile": 0.6049}, "CVE-2019-10705": {"epss_score": 0.00346, "epss_percentile": 0.56635}, "CVE-2019-10706": {"epss_score": 0.00116, "epss_percentile": 0.31185}, "CVE-2019-10707": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-10708": {"epss_score": 0.04314, "epss_percentile": 0.88536}, "CVE-2019-10709": {"epss_score": 0.0969, "epss_percentile": 0.92663}, "CVE-2019-10710": {"epss_score": 0.00301, "epss_percentile": 0.53021}, "CVE-2019-10711": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-10712": {"epss_score": 0.00983, "epss_percentile": 0.76299}, "CVE-2019-10714": {"epss_score": 0.00495, "epss_percentile": 0.651}, "CVE-2019-10715": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-10716": {"epss_score": 0.0689, "epss_percentile": 0.91095}, "CVE-2019-10717": {"epss_score": 0.1493, "epss_percentile": 0.94326}, "CVE-2019-10718": {"epss_score": 0.00241, "epss_percentile": 0.47269}, "CVE-2019-10719": {"epss_score": 0.06352, "epss_percentile": 0.90692}, "CVE-2019-10720": {"epss_score": 0.06352, "epss_percentile": 0.90692}, "CVE-2019-10721": {"epss_score": 0.00199, "epss_percentile": 0.42149}, "CVE-2019-10723": {"epss_score": 0.00066, "epss_percentile": 0.20736}, "CVE-2019-10724": {"epss_score": 0.0029, "epss_percentile": 0.52131}, "CVE-2019-10732": {"epss_score": 0.0019, "epss_percentile": 0.41005}, "CVE-2019-10734": {"epss_score": 0.00117, "epss_percentile": 0.31216}, "CVE-2019-10735": {"epss_score": 0.00135, "epss_percentile": 0.33942}, "CVE-2019-10740": {"epss_score": 0.0018, "epss_percentile": 0.39984}, "CVE-2019-10741": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2019-10742": {"epss_score": 0.1374, "epss_percentile": 0.94046}, "CVE-2019-10743": {"epss_score": 0.01238, "epss_percentile": 0.78794}, "CVE-2019-10744": {"epss_score": 0.02441, "epss_percentile": 0.84754}, "CVE-2019-10745": {"epss_score": 0.00235, "epss_percentile": 0.46242}, "CVE-2019-10746": {"epss_score": 0.00868, "epss_percentile": 0.74662}, "CVE-2019-10747": {"epss_score": 0.00503, "epss_percentile": 0.65461}, "CVE-2019-10748": {"epss_score": 0.00427, "epss_percentile": 0.61916}, "CVE-2019-10749": {"epss_score": 0.00357, "epss_percentile": 0.57465}, "CVE-2019-10750": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-10751": {"epss_score": 0.00492, "epss_percentile": 0.65007}, "CVE-2019-10752": {"epss_score": 0.00427, "epss_percentile": 0.61916}, "CVE-2019-10753": {"epss_score": 0.00259, "epss_percentile": 0.49032}, "CVE-2019-10754": {"epss_score": 0.004, "epss_percentile": 0.60187}, "CVE-2019-10755": {"epss_score": 0.00312, "epss_percentile": 0.53962}, "CVE-2019-10756": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-10757": {"epss_score": 0.00281, "epss_percentile": 0.51103}, "CVE-2019-10758": {"epss_score": 0.94062, "epss_percentile": 0.99896}, "CVE-2019-10759": {"epss_score": 0.01018, "epss_percentile": 0.76717}, "CVE-2019-10760": {"epss_score": 0.11349, "epss_percentile": 0.9332}, "CVE-2019-10761": {"epss_score": 0.00818, "epss_percentile": 0.7385}, "CVE-2019-10762": {"epss_score": 0.00582, "epss_percentile": 0.68311}, "CVE-2019-10763": {"epss_score": 8e-05, "epss_percentile": 0.00531}, "CVE-2019-10764": {"epss_score": 0.00361, "epss_percentile": 0.57696}, "CVE-2019-10765": {"epss_score": 0.00537, "epss_percentile": 0.66914}, "CVE-2019-10766": {"epss_score": 0.00327, "epss_percentile": 0.55108}, "CVE-2019-10767": {"epss_score": 0.006, "epss_percentile": 0.68815}, "CVE-2019-10768": {"epss_score": 0.00328, "epss_percentile": 0.55279}, "CVE-2019-10769": {"epss_score": 0.00525, "epss_percentile": 0.6638}, "CVE-2019-10770": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-10771": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-10772": {"epss_score": 0.00159, "epss_percentile": 0.37398}, "CVE-2019-10773": {"epss_score": 0.00546, "epss_percentile": 0.67218}, "CVE-2019-10774": {"epss_score": 0.01111, "epss_percentile": 0.77672}, "CVE-2019-10775": {"epss_score": 0.00436, "epss_percentile": 0.62451}, "CVE-2019-10776": {"epss_score": 0.00195, "epss_percentile": 0.4171}, "CVE-2019-10777": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2019-10778": {"epss_score": 0.01921, "epss_percentile": 0.82899}, "CVE-2019-10779": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2019-10780": {"epss_score": 0.02842, "epss_percentile": 0.85808}, "CVE-2019-10781": {"epss_score": 0.0015, "epss_percentile": 0.36053}, "CVE-2019-10782": {"epss_score": 0.00488, "epss_percentile": 0.64845}, "CVE-2019-10783": {"epss_score": 0.03665, "epss_percentile": 0.87532}, "CVE-2019-10784": {"epss_score": 0.00431, "epss_percentile": 0.6209}, "CVE-2019-10785": {"epss_score": 0.00243, "epss_percentile": 0.47476}, "CVE-2019-10786": {"epss_score": 0.01357, "epss_percentile": 0.79717}, "CVE-2019-10787": {"epss_score": 0.0334, "epss_percentile": 0.86941}, "CVE-2019-10788": {"epss_score": 0.01843, "epss_percentile": 0.82502}, "CVE-2019-10789": {"epss_score": 0.08278, "epss_percentile": 0.91965}, "CVE-2019-10790": {"epss_score": 0.00394, "epss_percentile": 0.59764}, "CVE-2019-10791": {"epss_score": 0.03343, "epss_percentile": 0.86948}, "CVE-2019-10792": {"epss_score": 0.0034, "epss_percentile": 0.56279}, "CVE-2019-10793": {"epss_score": 0.00352, "epss_percentile": 0.57115}, "CVE-2019-10794": {"epss_score": 0.00276, "epss_percentile": 0.5072}, "CVE-2019-10795": {"epss_score": 0.0034, "epss_percentile": 0.56279}, "CVE-2019-10796": {"epss_score": 0.00578, "epss_percentile": 0.6818}, "CVE-2019-10797": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2019-10798": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2019-10799": {"epss_score": 0.00432, "epss_percentile": 0.62162}, "CVE-2019-10800": {"epss_score": 0.0039, "epss_percentile": 0.59509}, "CVE-2019-10801": {"epss_score": 0.00578, "epss_percentile": 0.6818}, "CVE-2019-10802": {"epss_score": 0.00646, "epss_percentile": 0.7013}, "CVE-2019-10803": {"epss_score": 0.00578, "epss_percentile": 0.6818}, "CVE-2019-10804": {"epss_score": 0.00578, "epss_percentile": 0.6818}, "CVE-2019-10805": {"epss_score": 0.00227, "epss_percentile": 0.45418}, "CVE-2019-10806": {"epss_score": 0.00329, "epss_percentile": 0.55409}, "CVE-2019-10807": {"epss_score": 0.00578, "epss_percentile": 0.6818}, "CVE-2019-10808": {"epss_score": 0.0039, "epss_percentile": 0.5953}, "CVE-2019-10842": {"epss_score": 0.09368, "epss_percentile": 0.92519}, "CVE-2019-10844": {"epss_score": 0.00389, "epss_percentile": 0.59471}, "CVE-2019-10845": {"epss_score": 0.00561, "epss_percentile": 0.67659}, "CVE-2019-10846": {"epss_score": 0.02285, "epss_percentile": 0.84266}, "CVE-2019-10847": {"epss_score": 0.0047, "epss_percentile": 0.63973}, "CVE-2019-10848": {"epss_score": 0.05234, "epss_percentile": 0.89645}, "CVE-2019-10849": {"epss_score": 0.1213, "epss_percentile": 0.93575}, "CVE-2019-10850": {"epss_score": 0.00393, "epss_percentile": 0.59724}, "CVE-2019-10851": {"epss_score": 0.00114, "epss_percentile": 0.30845}, "CVE-2019-10852": {"epss_score": 0.00465, "epss_percentile": 0.63759}, "CVE-2019-10853": {"epss_score": 0.00414, "epss_percentile": 0.61029}, "CVE-2019-10854": {"epss_score": 0.13057, "epss_percentile": 0.93859}, "CVE-2019-10855": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2019-10856": {"epss_score": 0.00167, "epss_percentile": 0.38341}, "CVE-2019-10863": {"epss_score": 0.18887, "epss_percentile": 0.95087}, "CVE-2019-10864": {"epss_score": 0.00255, "epss_percentile": 0.48696}, "CVE-2019-10866": {"epss_score": 0.18099, "epss_percentile": 0.94957}, "CVE-2019-10867": {"epss_score": 0.53534, "epss_percentile": 0.9788}, "CVE-2019-10868": {"epss_score": 0.00283, "epss_percentile": 0.51357}, "CVE-2019-10869": {"epss_score": 0.48001, "epss_percentile": 0.97613}, "CVE-2019-10871": {"epss_score": 0.00666, "epss_percentile": 0.70684}, "CVE-2019-10872": {"epss_score": 0.0099, "epss_percentile": 0.7638}, "CVE-2019-10873": {"epss_score": 0.00959, "epss_percentile": 0.75952}, "CVE-2019-10874": {"epss_score": 0.00415, "epss_percentile": 0.61117}, "CVE-2019-10875": {"epss_score": 0.00725, "epss_percentile": 0.72064}, "CVE-2019-10876": {"epss_score": 0.00661, "epss_percentile": 0.70584}, "CVE-2019-10877": {"epss_score": 0.00704, "epss_percentile": 0.7155}, "CVE-2019-10878": {"epss_score": 0.02664, "epss_percentile": 0.85375}, "CVE-2019-10879": {"epss_score": 0.04619, "epss_percentile": 0.88928}, "CVE-2019-10880": {"epss_score": 0.0498, "epss_percentile": 0.89359}, "CVE-2019-10881": {"epss_score": 0.00477, "epss_percentile": 0.64323}, "CVE-2019-10882": {"epss_score": 0.00047, "epss_percentile": 0.14803}, "CVE-2019-10883": {"epss_score": 0.42243, "epss_percentile": 0.97321}, "CVE-2019-10884": {"epss_score": 0.00324, "epss_percentile": 0.54975}, "CVE-2019-10885": {"epss_score": 0.00166, "epss_percentile": 0.38158}, "CVE-2019-10886": {"epss_score": 0.00769, "epss_percentile": 0.72984}, "CVE-2019-10887": {"epss_score": 0.05706, "epss_percentile": 0.90137}, "CVE-2019-10888": {"epss_score": 0.00122, "epss_percentile": 0.32025}, "CVE-2019-10891": {"epss_score": 0.63081, "epss_percentile": 0.9832}, "CVE-2019-10892": {"epss_score": 0.00583, "epss_percentile": 0.6835}, "CVE-2019-10893": {"epss_score": 0.00384, "epss_percentile": 0.59157}, "CVE-2019-10894": {"epss_score": 0.13043, "epss_percentile": 0.93855}, "CVE-2019-10895": {"epss_score": 0.12832, "epss_percentile": 0.93797}, "CVE-2019-10896": {"epss_score": 0.12255, "epss_percentile": 0.93613}, "CVE-2019-10897": {"epss_score": 0.00649, "epss_percentile": 0.70237}, "CVE-2019-10898": {"epss_score": 0.00649, "epss_percentile": 0.70237}, "CVE-2019-10899": {"epss_score": 0.13043, "epss_percentile": 0.93855}, "CVE-2019-10900": {"epss_score": 0.00649, "epss_percentile": 0.70237}, "CVE-2019-10901": {"epss_score": 0.14797, "epss_percentile": 0.94286}, "CVE-2019-10902": {"epss_score": 0.00649, "epss_percentile": 0.70237}, "CVE-2019-10903": {"epss_score": 0.13043, "epss_percentile": 0.93855}, "CVE-2019-10904": {"epss_score": 0.00631, "epss_percentile": 0.69721}, "CVE-2019-10905": {"epss_score": 0.00521, "epss_percentile": 0.66241}, "CVE-2019-10906": {"epss_score": 0.02615, "epss_percentile": 0.85245}, "CVE-2019-10907": {"epss_score": 0.00161, "epss_percentile": 0.37561}, "CVE-2019-10908": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-10909": {"epss_score": 0.00376, "epss_percentile": 0.58658}, "CVE-2019-10910": {"epss_score": 0.12502, "epss_percentile": 0.93694}, "CVE-2019-10911": {"epss_score": 0.00289, "epss_percentile": 0.51997}, "CVE-2019-10912": {"epss_score": 0.01157, "epss_percentile": 0.78111}, "CVE-2019-10913": {"epss_score": 0.00257, "epss_percentile": 0.4888}, "CVE-2019-10914": {"epss_score": 0.00395, "epss_percentile": 0.59835}, "CVE-2019-10915": {"epss_score": 0.05857, "epss_percentile": 0.90268}, "CVE-2019-10916": {"epss_score": 0.00369, "epss_percentile": 0.58246}, "CVE-2019-10917": {"epss_score": 0.00045, "epss_percentile": 0.14041}, "CVE-2019-10918": {"epss_score": 0.00379, "epss_percentile": 0.58899}, "CVE-2019-10919": {"epss_score": 0.00631, "epss_percentile": 0.6971}, "CVE-2019-10920": {"epss_score": 0.00809, "epss_percentile": 0.73704}, "CVE-2019-10921": {"epss_score": 0.00687, "epss_percentile": 0.71187}, "CVE-2019-10922": {"epss_score": 0.01264, "epss_percentile": 0.78992}, "CVE-2019-10923": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2019-10924": {"epss_score": 0.00373, "epss_percentile": 0.58522}, "CVE-2019-10925": {"epss_score": 0.0089, "epss_percentile": 0.75027}, "CVE-2019-10926": {"epss_score": 0.00355, "epss_percentile": 0.57268}, "CVE-2019-10927": {"epss_score": 0.00578, "epss_percentile": 0.68203}, "CVE-2019-10928": {"epss_score": 0.00132, "epss_percentile": 0.33538}, "CVE-2019-10929": {"epss_score": 0.00139, "epss_percentile": 0.34615}, "CVE-2019-10930": {"epss_score": 0.00472, "epss_percentile": 0.64071}, "CVE-2019-10931": {"epss_score": 0.00362, "epss_percentile": 0.57768}, "CVE-2019-10933": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2019-10934": {"epss_score": 0.00103, "epss_percentile": 0.29044}, "CVE-2019-10935": {"epss_score": 0.00517, "epss_percentile": 0.66067}, "CVE-2019-10936": {"epss_score": 0.01992, "epss_percentile": 0.8318}, "CVE-2019-10937": {"epss_score": 0.0077, "epss_percentile": 0.72997}, "CVE-2019-10938": {"epss_score": 0.00487, "epss_percentile": 0.6481}, "CVE-2019-10939": {"epss_score": 0.00444, "epss_percentile": 0.62846}, "CVE-2019-10940": {"epss_score": 0.0018, "epss_percentile": 0.39894}, "CVE-2019-10941": {"epss_score": 0.00184, "epss_percentile": 0.40432}, "CVE-2019-10942": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2019-10943": {"epss_score": 0.00113, "epss_percentile": 0.30687}, "CVE-2019-10945": {"epss_score": 0.84523, "epss_percentile": 0.99293}, "CVE-2019-10946": {"epss_score": 0.00045, "epss_percentile": 0.14011}, "CVE-2019-10947": {"epss_score": 0.007, "epss_percentile": 0.71466}, "CVE-2019-10948": {"epss_score": 0.00229, "epss_percentile": 0.45555}, "CVE-2019-10949": {"epss_score": 0.00376, "epss_percentile": 0.58685}, "CVE-2019-10950": {"epss_score": 0.0113, "epss_percentile": 0.77847}, "CVE-2019-10951": {"epss_score": 0.00918, "epss_percentile": 0.75443}, "CVE-2019-10952": {"epss_score": 0.00531, "epss_percentile": 0.66657}, "CVE-2019-10953": {"epss_score": 0.00202, "epss_percentile": 0.42434}, "CVE-2019-10954": {"epss_score": 0.00039, "epss_percentile": 0.11713}, "CVE-2019-10955": {"epss_score": 0.02993, "epss_percentile": 0.86147}, "CVE-2019-10956": {"epss_score": 0.00134, "epss_percentile": 0.33858}, "CVE-2019-10957": {"epss_score": 0.00325, "epss_percentile": 0.55008}, "CVE-2019-10958": {"epss_score": 0.00757, "epss_percentile": 0.72758}, "CVE-2019-10959": {"epss_score": 0.01062, "epss_percentile": 0.77186}, "CVE-2019-10960": {"epss_score": 0.00163, "epss_percentile": 0.3778}, "CVE-2019-10961": {"epss_score": 0.00817, "epss_percentile": 0.73839}, "CVE-2019-10962": {"epss_score": 0.0015, "epss_percentile": 0.36142}, "CVE-2019-10963": {"epss_score": 0.0312, "epss_percentile": 0.86447}, "CVE-2019-10964": {"epss_score": 0.00337, "epss_percentile": 0.56035}, "CVE-2019-10965": {"epss_score": 0.09781, "epss_percentile": 0.92699}, "CVE-2019-10966": {"epss_score": 0.00311, "epss_percentile": 0.53808}, "CVE-2019-10967": {"epss_score": 0.06131, "epss_percentile": 0.90502}, "CVE-2019-10968": {"epss_score": 0.00055, "epss_percentile": 0.17441}, "CVE-2019-10969": {"epss_score": 0.05154, "epss_percentile": 0.8955}, "CVE-2019-10970": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2019-10971": {"epss_score": 0.00182, "epss_percentile": 0.40268}, "CVE-2019-10972": {"epss_score": 0.00156, "epss_percentile": 0.36965}, "CVE-2019-10973": {"epss_score": 0.00646, "epss_percentile": 0.70131}, "CVE-2019-10974": {"epss_score": 0.00055, "epss_percentile": 0.17425}, "CVE-2019-10975": {"epss_score": 0.00094, "epss_percentile": 0.26796}, "CVE-2019-10976": {"epss_score": 0.00206, "epss_percentile": 0.42782}, "CVE-2019-10977": {"epss_score": 0.03306, "epss_percentile": 0.86876}, "CVE-2019-10978": {"epss_score": 0.00156, "epss_percentile": 0.37003}, "CVE-2019-10979": {"epss_score": 0.01627, "epss_percentile": 0.81433}, "CVE-2019-10980": {"epss_score": 0.00155, "epss_percentile": 0.36836}, "CVE-2019-10981": {"epss_score": 0.0008, "epss_percentile": 0.24201}, "CVE-2019-10982": {"epss_score": 0.00926, "epss_percentile": 0.75556}, "CVE-2019-10983": {"epss_score": 0.00478, "epss_percentile": 0.64386}, "CVE-2019-10984": {"epss_score": 0.00155, "epss_percentile": 0.36836}, "CVE-2019-10985": {"epss_score": 0.03347, "epss_percentile": 0.86954}, "CVE-2019-10987": {"epss_score": 0.02557, "epss_percentile": 0.85098}, "CVE-2019-10988": {"epss_score": 0.00052, "epss_percentile": 0.16569}, "CVE-2019-10989": {"epss_score": 0.12042, "epss_percentile": 0.93553}, "CVE-2019-10990": {"epss_score": 0.00214, "epss_percentile": 0.44014}, "CVE-2019-10991": {"epss_score": 0.24592, "epss_percentile": 0.95937}, "CVE-2019-10992": {"epss_score": 0.00201, "epss_percentile": 0.42338}, "CVE-2019-10993": {"epss_score": 0.23916, "epss_percentile": 0.95833}, "CVE-2019-10994": {"epss_score": 0.00145, "epss_percentile": 0.35398}, "CVE-2019-10995": {"epss_score": 0.00128, "epss_percentile": 0.32949}, "CVE-2019-10996": {"epss_score": 0.00156, "epss_percentile": 0.37003}, "CVE-2019-10997": {"epss_score": 0.00519, "epss_percentile": 0.66172}, "CVE-2019-10998": {"epss_score": 0.00054, "epss_percentile": 0.17256}, "CVE-2019-10999": {"epss_score": 0.35804, "epss_percentile": 0.96935}, "CVE-2019-11000": {"epss_score": 0.00609, "epss_percentile": 0.69094}, "CVE-2019-11001": {"epss_score": 0.5061, "epss_percentile": 0.97742}, "CVE-2019-11002": {"epss_score": 0.00244, "epss_percentile": 0.4757}, "CVE-2019-11003": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-11004": {"epss_score": 0.00244, "epss_percentile": 0.4757}, "CVE-2019-11005": {"epss_score": 0.02597, "epss_percentile": 0.852}, "CVE-2019-11006": {"epss_score": 0.0063, "epss_percentile": 0.69702}, "CVE-2019-11007": {"epss_score": 0.02228, "epss_percentile": 0.84079}, "CVE-2019-11008": {"epss_score": 0.02349, "epss_percentile": 0.84465}, "CVE-2019-11009": {"epss_score": 0.01377, "epss_percentile": 0.79842}, "CVE-2019-11010": {"epss_score": 0.00641, "epss_percentile": 0.69984}, "CVE-2019-11011": {"epss_score": 0.03734, "epss_percentile": 0.87648}, "CVE-2019-11013": {"epss_score": 0.87349, "epss_percentile": 0.99425}, "CVE-2019-11014": {"epss_score": 0.00765, "epss_percentile": 0.72909}, "CVE-2019-11015": {"epss_score": 0.00086, "epss_percentile": 0.25248}, "CVE-2019-11016": {"epss_score": 0.00247, "epss_percentile": 0.47861}, "CVE-2019-11017": {"epss_score": 0.0102, "epss_percentile": 0.76733}, "CVE-2019-11018": {"epss_score": 0.00348, "epss_percentile": 0.568}, "CVE-2019-11019": {"epss_score": 0.0029, "epss_percentile": 0.52128}, "CVE-2019-11020": {"epss_score": 0.0029, "epss_percentile": 0.52128}, "CVE-2019-11021": {"epss_score": 0.03263, "epss_percentile": 0.86777}, "CVE-2019-11023": {"epss_score": 0.01942, "epss_percentile": 0.82989}, "CVE-2019-11024": {"epss_score": 0.00178, "epss_percentile": 0.39744}, "CVE-2019-11025": {"epss_score": 0.00446, "epss_percentile": 0.62932}, "CVE-2019-11026": {"epss_score": 0.00545, "epss_percentile": 0.67172}, "CVE-2019-11027": {"epss_score": 0.01832, "epss_percentile": 0.82454}, "CVE-2019-11028": {"epss_score": 0.00772, "epss_percentile": 0.73034}, "CVE-2019-11029": {"epss_score": 0.00744, "epss_percentile": 0.72512}, "CVE-2019-11030": {"epss_score": 0.00368, "epss_percentile": 0.58177}, "CVE-2019-11031": {"epss_score": 0.00443, "epss_percentile": 0.62804}, "CVE-2019-11032": {"epss_score": 0.00202, "epss_percentile": 0.42442}, "CVE-2019-11033": {"epss_score": 0.00353, "epss_percentile": 0.57157}, "CVE-2019-11034": {"epss_score": 0.0279, "epss_percentile": 0.85666}, "CVE-2019-11035": {"epss_score": 0.03024, "epss_percentile": 0.86232}, "CVE-2019-11036": {"epss_score": 0.01721, "epss_percentile": 0.81934}, "CVE-2019-11037": {"epss_score": 0.01178, "epss_percentile": 0.78287}, "CVE-2019-11038": {"epss_score": 0.10719, "epss_percentile": 0.93082}, "CVE-2019-11039": {"epss_score": 0.01439, "epss_percentile": 0.80289}, "CVE-2019-11040": {"epss_score": 0.01239, "epss_percentile": 0.78796}, "CVE-2019-11041": {"epss_score": 0.03327, "epss_percentile": 0.86925}, "CVE-2019-11042": {"epss_score": 0.03882, "epss_percentile": 0.87897}, "CVE-2019-11043": {"epss_score": 0.94105, "epss_percentile": 0.99903}, "CVE-2019-11044": {"epss_score": 0.07969, "epss_percentile": 0.91798}, "CVE-2019-11045": {"epss_score": 0.40952, "epss_percentile": 0.97246}, "CVE-2019-11046": {"epss_score": 0.08245, "epss_percentile": 0.91947}, "CVE-2019-11047": {"epss_score": 0.03174, "epss_percentile": 0.86556}, "CVE-2019-11048": {"epss_score": 0.12716, "epss_percentile": 0.93756}, "CVE-2019-11049": {"epss_score": 0.02733, "epss_percentile": 0.85547}, "CVE-2019-11050": {"epss_score": 0.03121, "epss_percentile": 0.86449}, "CVE-2019-11057": {"epss_score": 0.00599, "epss_percentile": 0.68792}, "CVE-2019-11059": {"epss_score": 0.00439, "epss_percentile": 0.62605}, "CVE-2019-11060": {"epss_score": 0.01342, "epss_percentile": 0.79596}, "CVE-2019-11061": {"epss_score": 0.11613, "epss_percentile": 0.9342}, "CVE-2019-11062": {"epss_score": 0.05568, "epss_percentile": 0.90004}, "CVE-2019-11063": {"epss_score": 0.01077, "epss_percentile": 0.77334}, "CVE-2019-11064": {"epss_score": 0.00458, "epss_percentile": 0.63399}, "CVE-2019-11065": {"epss_score": 0.0037, "epss_percentile": 0.58334}, "CVE-2019-11066": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2019-11068": {"epss_score": 0.01011, "epss_percentile": 0.76607}, "CVE-2019-11069": {"epss_score": 0.00292, "epss_percentile": 0.52253}, "CVE-2019-11070": {"epss_score": 0.02015, "epss_percentile": 0.83273}, "CVE-2019-11071": {"epss_score": 0.02601, "epss_percentile": 0.85208}, "CVE-2019-11072": {"epss_score": 0.12284, "epss_percentile": 0.93623}, "CVE-2019-11073": {"epss_score": 0.12676, "epss_percentile": 0.93746}, "CVE-2019-11074": {"epss_score": 0.0372, "epss_percentile": 0.87619}, "CVE-2019-11076": {"epss_score": 0.16995, "epss_percentile": 0.94758}, "CVE-2019-11077": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-11078": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-11080": {"epss_score": 0.41774, "epss_percentile": 0.97294}, "CVE-2019-11081": {"epss_score": 0.00316, "epss_percentile": 0.54231}, "CVE-2019-11082": {"epss_score": 0.00798, "epss_percentile": 0.73514}, "CVE-2019-11084": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-11085": {"epss_score": 0.00124, "epss_percentile": 0.32439}, "CVE-2019-11086": {"epss_score": 0.0014, "epss_percentile": 0.34776}, "CVE-2019-11087": {"epss_score": 0.00141, "epss_percentile": 0.34835}, "CVE-2019-11088": {"epss_score": 0.00224, "epss_percentile": 0.45037}, "CVE-2019-11089": {"epss_score": 0.00158, "epss_percentile": 0.37191}, "CVE-2019-11090": {"epss_score": 0.0078, "epss_percentile": 0.73172}, "CVE-2019-11091": {"epss_score": 0.0173, "epss_percentile": 0.81986}, "CVE-2019-11092": {"epss_score": 0.00045, "epss_percentile": 0.1389}, "CVE-2019-11093": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2019-11094": {"epss_score": 0.00066, "epss_percentile": 0.2082}, "CVE-2019-11095": {"epss_score": 0.00058, "epss_percentile": 0.18373}, "CVE-2019-11096": {"epss_score": 0.00118, "epss_percentile": 0.31392}, "CVE-2019-11097": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2019-11098": {"epss_score": 0.00052, "epss_percentile": 0.16349}, "CVE-2019-11100": {"epss_score": 0.00277, "epss_percentile": 0.50776}, "CVE-2019-11101": {"epss_score": 0.00141, "epss_percentile": 0.34899}, "CVE-2019-11102": {"epss_score": 0.00141, "epss_percentile": 0.34899}, "CVE-2019-11103": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2019-11104": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2019-11105": {"epss_score": 0.0015, "epss_percentile": 0.36147}, "CVE-2019-11106": {"epss_score": 0.00127, "epss_percentile": 0.32923}, "CVE-2019-11107": {"epss_score": 0.00456, "epss_percentile": 0.6334}, "CVE-2019-11108": {"epss_score": 0.0015, "epss_percentile": 0.36147}, "CVE-2019-11109": {"epss_score": 0.00099, "epss_percentile": 0.2839}, "CVE-2019-11110": {"epss_score": 0.00072, "epss_percentile": 0.22455}, "CVE-2019-11111": {"epss_score": 0.00224, "epss_percentile": 0.45052}, "CVE-2019-11112": {"epss_score": 0.00244, "epss_percentile": 0.47523}, "CVE-2019-11113": {"epss_score": 0.00249, "epss_percentile": 0.48041}, "CVE-2019-11114": {"epss_score": 0.00049, "epss_percentile": 0.15309}, "CVE-2019-11117": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2019-11119": {"epss_score": 0.00503, "epss_percentile": 0.65466}, "CVE-2019-11120": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2019-11121": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2019-11123": {"epss_score": 0.00068, "epss_percentile": 0.21207}, "CVE-2019-11124": {"epss_score": 0.00068, "epss_percentile": 0.21207}, "CVE-2019-11125": {"epss_score": 0.00068, "epss_percentile": 0.21207}, "CVE-2019-11126": {"epss_score": 0.00068, "epss_percentile": 0.21207}, "CVE-2019-11127": {"epss_score": 0.0007, "epss_percentile": 0.21839}, "CVE-2019-11128": {"epss_score": 0.00077, "epss_percentile": 0.23532}, "CVE-2019-11129": {"epss_score": 0.00068, "epss_percentile": 0.21207}, "CVE-2019-11131": {"epss_score": 0.00587, "epss_percentile": 0.68474}, "CVE-2019-11132": {"epss_score": 0.00491, "epss_percentile": 0.64962}, "CVE-2019-11133": {"epss_score": 0.00083, "epss_percentile": 0.24723}, "CVE-2019-11135": {"epss_score": 0.00319, "epss_percentile": 0.54498}, "CVE-2019-11136": {"epss_score": 0.00144, "epss_percentile": 0.35312}, "CVE-2019-11137": {"epss_score": 0.00144, "epss_percentile": 0.35312}, "CVE-2019-11139": {"epss_score": 0.00117, "epss_percentile": 0.31281}, "CVE-2019-11140": {"epss_score": 0.00059, "epss_percentile": 0.18729}, "CVE-2019-11143": {"epss_score": 0.00042, "epss_percentile": 0.12735}, "CVE-2019-11145": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2019-11146": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2019-11147": {"epss_score": 0.00278, "epss_percentile": 0.5087}, "CVE-2019-11148": {"epss_score": 0.00044, "epss_percentile": 0.13366}, "CVE-2019-11151": {"epss_score": 0.00152, "epss_percentile": 0.36375}, "CVE-2019-11152": {"epss_score": 0.00184, "epss_percentile": 0.40435}, "CVE-2019-11153": {"epss_score": 0.00152, "epss_percentile": 0.36375}, "CVE-2019-11154": {"epss_score": 0.00083, "epss_percentile": 0.24798}, "CVE-2019-11155": {"epss_score": 0.00083, "epss_percentile": 0.24798}, "CVE-2019-11156": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2019-11157": {"epss_score": 0.0031, "epss_percentile": 0.5379}, "CVE-2019-11162": {"epss_score": 0.00049, "epss_percentile": 0.15547}, "CVE-2019-11163": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2019-11165": {"epss_score": 0.00166, "epss_percentile": 0.38244}, "CVE-2019-11166": {"epss_score": 0.00036, "epss_percentile": 0.10235}, "CVE-2019-11167": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2019-11168": {"epss_score": 0.0103, "epss_percentile": 0.7685}, "CVE-2019-11170": {"epss_score": 0.00044, "epss_percentile": 0.1345}, "CVE-2019-11171": {"epss_score": 0.0055, "epss_percentile": 0.67336}, "CVE-2019-11172": {"epss_score": 0.00489, "epss_percentile": 0.64873}, "CVE-2019-11173": {"epss_score": 0.00243, "epss_percentile": 0.4748}, "CVE-2019-11174": {"epss_score": 0.00489, "epss_percentile": 0.64873}, "CVE-2019-11175": {"epss_score": 0.00877, "epss_percentile": 0.74816}, "CVE-2019-11177": {"epss_score": 0.00626, "epss_percentile": 0.696}, "CVE-2019-11178": {"epss_score": 0.00751, "epss_percentile": 0.72641}, "CVE-2019-11179": {"epss_score": 0.00406, "epss_percentile": 0.60536}, "CVE-2019-11180": {"epss_score": 0.00903, "epss_percentile": 0.75199}, "CVE-2019-11181": {"epss_score": 0.00174, "epss_percentile": 0.39262}, "CVE-2019-11182": {"epss_score": 0.00626, "epss_percentile": 0.696}, "CVE-2019-11184": {"epss_score": 0.00192, "epss_percentile": 0.4136}, "CVE-2019-11185": {"epss_score": 0.06056, "epss_percentile": 0.90438}, "CVE-2019-11187": {"epss_score": 0.00375, "epss_percentile": 0.58628}, "CVE-2019-11189": {"epss_score": 0.00171, "epss_percentile": 0.38771}, "CVE-2019-11190": {"epss_score": 0.0001, "epss_percentile": 0.00767}, "CVE-2019-11191": {"epss_score": 9e-05, "epss_percentile": 0.00617}, "CVE-2019-11193": {"epss_score": 0.01495, "epss_percentile": 0.80654}, "CVE-2019-11196": {"epss_score": 0.08095, "epss_percentile": 0.91877}, "CVE-2019-11198": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2019-11199": {"epss_score": 0.00487, "epss_percentile": 0.64781}, "CVE-2019-11200": {"epss_score": 0.01547, "epss_percentile": 0.80971}, "CVE-2019-11201": {"epss_score": 0.00747, "epss_percentile": 0.72574}, "CVE-2019-11202": {"epss_score": 0.00428, "epss_percentile": 0.61936}, "CVE-2019-11203": {"epss_score": 0.00167, "epss_percentile": 0.38384}, "CVE-2019-11204": {"epss_score": 0.00473, "epss_percentile": 0.64104}, "CVE-2019-11205": {"epss_score": 0.00421, "epss_percentile": 0.61467}, "CVE-2019-11206": {"epss_score": 0.00278, "epss_percentile": 0.50875}, "CVE-2019-11207": {"epss_score": 0.00137, "epss_percentile": 0.34246}, "CVE-2019-11208": {"epss_score": 0.00167, "epss_percentile": 0.38378}, "CVE-2019-11209": {"epss_score": 0.00508, "epss_percentile": 0.65714}, "CVE-2019-11210": {"epss_score": 0.02816, "epss_percentile": 0.85734}, "CVE-2019-11211": {"epss_score": 0.0298, "epss_percentile": 0.86116}, "CVE-2019-11212": {"epss_score": 0.00239, "epss_percentile": 0.46857}, "CVE-2019-11213": {"epss_score": 0.0262, "epss_percentile": 0.85254}, "CVE-2019-11215": {"epss_score": 0.00463, "epss_percentile": 0.63665}, "CVE-2019-11216": {"epss_score": 0.00643, "epss_percentile": 0.70064}, "CVE-2019-11217": {"epss_score": 0.0681, "epss_percentile": 0.9104}, "CVE-2019-11218": {"epss_score": 0.00865, "epss_percentile": 0.74614}, "CVE-2019-11219": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2019-11220": {"epss_score": 0.00298, "epss_percentile": 0.52774}, "CVE-2019-11221": {"epss_score": 0.00185, "epss_percentile": 0.4046}, "CVE-2019-11222": {"epss_score": 0.00458, "epss_percentile": 0.63396}, "CVE-2019-11223": {"epss_score": 0.45297, "epss_percentile": 0.97481}, "CVE-2019-11224": {"epss_score": 0.26819, "epss_percentile": 0.96183}, "CVE-2019-11226": {"epss_score": 0.00289, "epss_percentile": 0.52001}, "CVE-2019-11228": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-11229": {"epss_score": 0.30836, "epss_percentile": 0.9657}, "CVE-2019-11230": {"epss_score": 0.00112, "epss_percentile": 0.30444}, "CVE-2019-11231": {"epss_score": 0.61684, "epss_percentile": 0.98259}, "CVE-2019-11232": {"epss_score": 0.00714, "epss_percentile": 0.71807}, "CVE-2019-11233": {"epss_score": 0.00474, "epss_percentile": 0.64167}, "CVE-2019-11234": {"epss_score": 0.21563, "epss_percentile": 0.95534}, "CVE-2019-11235": {"epss_score": 0.0601, "epss_percentile": 0.90408}, "CVE-2019-11236": {"epss_score": 0.00586, "epss_percentile": 0.68444}, "CVE-2019-11242": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2019-11243": {"epss_score": 0.00253, "epss_percentile": 0.48448}, "CVE-2019-11244": {"epss_score": 0.00102, "epss_percentile": 0.28897}, "CVE-2019-11245": {"epss_score": 0.00154, "epss_percentile": 0.36748}, "CVE-2019-11246": {"epss_score": 0.0163, "epss_percentile": 0.81442}, "CVE-2019-11247": {"epss_score": 0.00613, "epss_percentile": 0.69258}, "CVE-2019-11248": {"epss_score": 0.91212, "epss_percentile": 0.99628}, "CVE-2019-11249": {"epss_score": 0.03519, "epss_percentile": 0.87281}, "CVE-2019-11250": {"epss_score": 0.00828, "epss_percentile": 0.74003}, "CVE-2019-11251": {"epss_score": 0.03448, "epss_percentile": 0.8716}, "CVE-2019-11252": {"epss_score": 0.00355, "epss_percentile": 0.57298}, "CVE-2019-11253": {"epss_score": 0.86289, "epss_percentile": 0.99376}, "CVE-2019-11254": {"epss_score": 0.0011, "epss_percentile": 0.30086}, "CVE-2019-11255": {"epss_score": 0.00703, "epss_percentile": 0.71549}, "CVE-2019-11268": {"epss_score": 0.00357, "epss_percentile": 0.57405}, "CVE-2019-11269": {"epss_score": 0.06695, "epss_percentile": 0.90951}, "CVE-2019-11270": {"epss_score": 0.00229, "epss_percentile": 0.45591}, "CVE-2019-11271": {"epss_score": 0.00044, "epss_percentile": 0.13369}, "CVE-2019-11272": {"epss_score": 0.00407, "epss_percentile": 0.60621}, "CVE-2019-11273": {"epss_score": 0.00177, "epss_percentile": 0.39541}, "CVE-2019-11274": {"epss_score": 0.00305, "epss_percentile": 0.53336}, "CVE-2019-11275": {"epss_score": 0.00203, "epss_percentile": 0.42492}, "CVE-2019-11276": {"epss_score": 0.00046, "epss_percentile": 0.14165}, "CVE-2019-11277": {"epss_score": 0.00876, "epss_percentile": 0.74788}, "CVE-2019-11278": {"epss_score": 0.00422, "epss_percentile": 0.61575}, "CVE-2019-11279": {"epss_score": 0.00469, "epss_percentile": 0.63915}, "CVE-2019-11280": {"epss_score": 0.00557, "epss_percentile": 0.6755}, "CVE-2019-11281": {"epss_score": 0.0102, "epss_percentile": 0.76744}, "CVE-2019-11282": {"epss_score": 0.00303, "epss_percentile": 0.53236}, "CVE-2019-11283": {"epss_score": 0.00492, "epss_percentile": 0.65009}, "CVE-2019-11284": {"epss_score": 0.00392, "epss_percentile": 0.5969}, "CVE-2019-11286": {"epss_score": 0.02727, "epss_percentile": 0.85531}, "CVE-2019-11287": {"epss_score": 0.00704, "epss_percentile": 0.71556}, "CVE-2019-11288": {"epss_score": 0.00093, "epss_percentile": 0.26604}, "CVE-2019-11289": {"epss_score": 0.00726, "epss_percentile": 0.72067}, "CVE-2019-11290": {"epss_score": 0.00459, "epss_percentile": 0.6348}, "CVE-2019-11291": {"epss_score": 0.00484, "epss_percentile": 0.6464}, "CVE-2019-11292": {"epss_score": 0.00491, "epss_percentile": 0.64955}, "CVE-2019-11293": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2019-11294": {"epss_score": 0.00228, "epss_percentile": 0.45498}, "CVE-2019-11318": {"epss_score": 0.01634, "epss_percentile": 0.81465}, "CVE-2019-11319": {"epss_score": 0.04516, "epss_percentile": 0.88791}, "CVE-2019-11320": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-11321": {"epss_score": 0.00267, "epss_percentile": 0.49954}, "CVE-2019-11322": {"epss_score": 0.04516, "epss_percentile": 0.88791}, "CVE-2019-11323": {"epss_score": 8e-05, "epss_percentile": 0.0058}, "CVE-2019-11324": {"epss_score": 0.01415, "epss_percentile": 0.80138}, "CVE-2019-11325": {"epss_score": 0.04687, "epss_percentile": 0.89009}, "CVE-2019-11326": {"epss_score": 0.00284, "epss_percentile": 0.51432}, "CVE-2019-11327": {"epss_score": 0.00517, "epss_percentile": 0.66067}, "CVE-2019-11328": {"epss_score": 0.00841, "epss_percentile": 0.74216}, "CVE-2019-11331": {"epss_score": 0.02236, "epss_percentile": 0.84101}, "CVE-2019-11332": {"epss_score": 0.00586, "epss_percentile": 0.68447}, "CVE-2019-11334": {"epss_score": 0.00162, "epss_percentile": 0.37687}, "CVE-2019-11336": {"epss_score": 0.00594, "epss_percentile": 0.68675}, "CVE-2019-11338": {"epss_score": 0.02066, "epss_percentile": 0.83459}, "CVE-2019-11339": {"epss_score": 0.00664, "epss_percentile": 0.7065}, "CVE-2019-11340": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2019-11341": {"epss_score": 0.00017, "epss_percentile": 0.03103}, "CVE-2019-11343": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-11344": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2019-11345": {"epss_score": 0.0039, "epss_percentile": 0.59555}, "CVE-2019-11350": {"epss_score": 0.00365, "epss_percentile": 0.58004}, "CVE-2019-11351": {"epss_score": 0.00899, "epss_percentile": 0.75156}, "CVE-2019-11353": {"epss_score": 0.02451, "epss_percentile": 0.84788}, "CVE-2019-11354": {"epss_score": 0.47341, "epss_percentile": 0.97584}, "CVE-2019-11355": {"epss_score": 0.00534, "epss_percentile": 0.66792}, "CVE-2019-11356": {"epss_score": 0.2861, "epss_percentile": 0.96371}, "CVE-2019-11358": {"epss_score": 0.00854, "epss_percentile": 0.74449}, "CVE-2019-11359": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2019-11360": {"epss_score": 0.01431, "epss_percentile": 0.80244}, "CVE-2019-11361": {"epss_score": 0.00215, "epss_percentile": 0.44122}, "CVE-2019-11362": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-11363": {"epss_score": 0.00577, "epss_percentile": 0.68159}, "CVE-2019-11364": {"epss_score": 0.03698, "epss_percentile": 0.87587}, "CVE-2019-11365": {"epss_score": 0.03705, "epss_percentile": 0.87595}, "CVE-2019-11366": {"epss_score": 0.01358, "epss_percentile": 0.7973}, "CVE-2019-11367": {"epss_score": 0.03667, "epss_percentile": 0.87534}, "CVE-2019-11368": {"epss_score": 0.00768, "epss_percentile": 0.72963}, "CVE-2019-11369": {"epss_score": 0.08106, "epss_percentile": 0.91881}, "CVE-2019-11370": {"epss_score": 0.07622, "epss_percentile": 0.91579}, "CVE-2019-11371": {"epss_score": 0.00502, "epss_percentile": 0.65402}, "CVE-2019-11372": {"epss_score": 0.02819, "epss_percentile": 0.85741}, "CVE-2019-11373": {"epss_score": 0.02819, "epss_percentile": 0.85741}, "CVE-2019-11374": {"epss_score": 0.03045, "epss_percentile": 0.86281}, "CVE-2019-11375": {"epss_score": 0.00375, "epss_percentile": 0.58597}, "CVE-2019-11376": {"epss_score": 0.00955, "epss_percentile": 0.75911}, "CVE-2019-11377": {"epss_score": 0.00401, "epss_percentile": 0.6026}, "CVE-2019-11378": {"epss_score": 0.03399, "epss_percentile": 0.87066}, "CVE-2019-11380": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-11383": {"epss_score": 0.00353, "epss_percentile": 0.57182}, "CVE-2019-11384": {"epss_score": 0.00165, "epss_percentile": 0.38081}, "CVE-2019-11387": {"epss_score": 0.00465, "epss_percentile": 0.63768}, "CVE-2019-11388": {"epss_score": 0.0051, "epss_percentile": 0.65757}, "CVE-2019-11389": {"epss_score": 0.0051, "epss_percentile": 0.65757}, "CVE-2019-11390": {"epss_score": 0.0051, "epss_percentile": 0.65757}, "CVE-2019-11391": {"epss_score": 0.00413, "epss_percentile": 0.61009}, "CVE-2019-11392": {"epss_score": 0.00463, "epss_percentile": 0.63665}, "CVE-2019-11393": {"epss_score": 0.0044, "epss_percentile": 0.62616}, "CVE-2019-11395": {"epss_score": 0.14143, "epss_percentile": 0.94144}, "CVE-2019-11396": {"epss_score": 0.00062, "epss_percentile": 0.19671}, "CVE-2019-11397": {"epss_score": 0.05678, "epss_percentile": 0.90114}, "CVE-2019-11398": {"epss_score": 0.03906, "epss_percentile": 0.87929}, "CVE-2019-11399": {"epss_score": 0.04956, "epss_percentile": 0.89328}, "CVE-2019-11400": {"epss_score": 0.08285, "epss_percentile": 0.91969}, "CVE-2019-11401": {"epss_score": 0.02331, "epss_percentile": 0.84406}, "CVE-2019-11402": {"epss_score": 0.0034, "epss_percentile": 0.56277}, "CVE-2019-11403": {"epss_score": 0.00346, "epss_percentile": 0.56645}, "CVE-2019-11404": {"epss_score": 0.00319, "epss_percentile": 0.54563}, "CVE-2019-11405": {"epss_score": 0.00196, "epss_percentile": 0.41799}, "CVE-2019-11406": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-11407": {"epss_score": 0.0086, "epss_percentile": 0.74528}, "CVE-2019-11408": {"epss_score": 0.01617, "epss_percentile": 0.81362}, "CVE-2019-11409": {"epss_score": 0.85799, "epss_percentile": 0.99349}, "CVE-2019-11410": {"epss_score": 0.02238, "epss_percentile": 0.84106}, "CVE-2019-11411": {"epss_score": 0.02477, "epss_percentile": 0.84865}, "CVE-2019-11412": {"epss_score": 0.0176, "epss_percentile": 0.82146}, "CVE-2019-11413": {"epss_score": 0.00889, "epss_percentile": 0.75024}, "CVE-2019-11414": {"epss_score": 0.00431, "epss_percentile": 0.6204}, "CVE-2019-11415": {"epss_score": 0.34379, "epss_percentile": 0.96845}, "CVE-2019-11416": {"epss_score": 0.01888, "epss_percentile": 0.82719}, "CVE-2019-11417": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2019-11418": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2019-11419": {"epss_score": 0.03227, "epss_percentile": 0.86687}, "CVE-2019-11426": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-11427": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-11428": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-11429": {"epss_score": 0.00358, "epss_percentile": 0.57513}, "CVE-2019-11444": {"epss_score": 0.44691, "epss_percentile": 0.97449}, "CVE-2019-11445": {"epss_score": 0.232, "epss_percentile": 0.95749}, "CVE-2019-11446": {"epss_score": 0.0383, "epss_percentile": 0.87807}, "CVE-2019-11447": {"epss_score": 0.73971, "epss_percentile": 0.98778}, "CVE-2019-11448": {"epss_score": 0.19378, "epss_percentile": 0.95171}, "CVE-2019-11449": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-11450": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-11451": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2019-11452": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2019-11454": {"epss_score": 0.01184, "epss_percentile": 0.7833}, "CVE-2019-11455": {"epss_score": 0.0187, "epss_percentile": 0.82628}, "CVE-2019-11456": {"epss_score": 0.00182, "epss_percentile": 0.40246}, "CVE-2019-11457": {"epss_score": 0.00219, "epss_percentile": 0.4448}, "CVE-2019-11458": {"epss_score": 0.00558, "epss_percentile": 0.67582}, "CVE-2019-11459": {"epss_score": 0.0073, "epss_percentile": 0.7215}, "CVE-2019-11460": {"epss_score": 0.00465, "epss_percentile": 0.6377}, "CVE-2019-11461": {"epss_score": 0.00056, "epss_percentile": 0.17707}, "CVE-2019-11463": {"epss_score": 0.00196, "epss_percentile": 0.41822}, "CVE-2019-11464": {"epss_score": 0.00244, "epss_percentile": 0.47516}, "CVE-2019-11465": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2019-11466": {"epss_score": 0.00311, "epss_percentile": 0.5383}, "CVE-2019-11467": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2019-11469": {"epss_score": 0.04678, "epss_percentile": 0.88997}, "CVE-2019-11470": {"epss_score": 0.00756, "epss_percentile": 0.72729}, "CVE-2019-11471": {"epss_score": 0.00272, "epss_percentile": 0.50368}, "CVE-2019-11472": {"epss_score": 0.00404, "epss_percentile": 0.60415}, "CVE-2019-11473": {"epss_score": 0.0132, "epss_percentile": 0.79438}, "CVE-2019-11474": {"epss_score": 0.03085, "epss_percentile": 0.86383}, "CVE-2019-11476": {"epss_score": 0.00059, "epss_percentile": 0.18848}, "CVE-2019-11477": {"epss_score": 0.70216, "epss_percentile": 0.98623}, "CVE-2019-11478": {"epss_score": 0.30132, "epss_percentile": 0.96513}, "CVE-2019-11479": {"epss_score": 0.13578, "epss_percentile": 0.94}, "CVE-2019-11480": {"epss_score": 0.00427, "epss_percentile": 0.61784}, "CVE-2019-11481": {"epss_score": 0.00133, "epss_percentile": 0.33703}, "CVE-2019-11482": {"epss_score": 0.00087, "epss_percentile": 0.25621}, "CVE-2019-11483": {"epss_score": 0.0007, "epss_percentile": 0.2197}, "CVE-2019-11484": {"epss_score": 0.00103, "epss_percentile": 0.2899}, "CVE-2019-11485": {"epss_score": 0.00093, "epss_percentile": 0.26641}, "CVE-2019-11486": {"epss_score": 0.00048, "epss_percentile": 0.15104}, "CVE-2019-11487": {"epss_score": 0.0005, "epss_percentile": 0.15651}, "CVE-2019-11488": {"epss_score": 0.00598, "epss_percentile": 0.68768}, "CVE-2019-11489": {"epss_score": 0.00675, "epss_percentile": 0.70894}, "CVE-2019-11490": {"epss_score": 0.00034, "epss_percentile": 0.09475}, "CVE-2019-11492": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-11493": {"epss_score": 0.00492, "epss_percentile": 0.65016}, "CVE-2019-11494": {"epss_score": 0.00733, "epss_percentile": 0.72203}, "CVE-2019-11495": {"epss_score": 0.00589, "epss_percentile": 0.6853}, "CVE-2019-11496": {"epss_score": 0.00287, "epss_percentile": 0.51802}, "CVE-2019-11497": {"epss_score": 0.00153, "epss_percentile": 0.36552}, "CVE-2019-11498": {"epss_score": 0.0197, "epss_percentile": 0.83095}, "CVE-2019-11499": {"epss_score": 0.00873, "epss_percentile": 0.74741}, "CVE-2019-11500": {"epss_score": 0.38847, "epss_percentile": 0.97123}, "CVE-2019-11502": {"epss_score": 0.00604, "epss_percentile": 0.6895}, "CVE-2019-11503": {"epss_score": 0.00475, "epss_percentile": 0.6418}, "CVE-2019-11504": {"epss_score": 0.00358, "epss_percentile": 0.57513}, "CVE-2019-11505": {"epss_score": 0.01266, "epss_percentile": 0.79008}, "CVE-2019-11506": {"epss_score": 0.01717, "epss_percentile": 0.81916}, "CVE-2019-11507": {"epss_score": 0.00741, "epss_percentile": 0.72444}, "CVE-2019-11508": {"epss_score": 0.04324, "epss_percentile": 0.88551}, "CVE-2019-11509": {"epss_score": 0.06923, "epss_percentile": 0.91119}, "CVE-2019-11510": {"epss_score": 0.9438, "epss_percentile": 0.99965}, "CVE-2019-11511": {"epss_score": 0.02604, "epss_percentile": 0.85215}, "CVE-2019-11512": {"epss_score": 0.00307, "epss_percentile": 0.53524}, "CVE-2019-11513": {"epss_score": 0.00242, "epss_percentile": 0.47365}, "CVE-2019-11514": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-11515": {"epss_score": 0.00414, "epss_percentile": 0.61026}, "CVE-2019-11516": {"epss_score": 0.00622, "epss_percentile": 0.69499}, "CVE-2019-11517": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2019-11518": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2019-11519": {"epss_score": 0.00276, "epss_percentile": 0.50703}, "CVE-2019-11521": {"epss_score": 0.00258, "epss_percentile": 0.48976}, "CVE-2019-11522": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2019-11523": {"epss_score": 0.02511, "epss_percentile": 0.84952}, "CVE-2019-11526": {"epss_score": 0.00346, "epss_percentile": 0.56647}, "CVE-2019-11527": {"epss_score": 0.09246, "epss_percentile": 0.92465}, "CVE-2019-11528": {"epss_score": 0.00206, "epss_percentile": 0.42918}, "CVE-2019-11533": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2019-11535": {"epss_score": 0.03363, "epss_percentile": 0.86997}, "CVE-2019-11536": {"epss_score": 0.00385, "epss_percentile": 0.5921}, "CVE-2019-11537": {"epss_score": 0.05941, "epss_percentile": 0.90349}, "CVE-2019-11538": {"epss_score": 0.04586, "epss_percentile": 0.88886}, "CVE-2019-11539": {"epss_score": 0.93911, "epss_percentile": 0.99867}, "CVE-2019-11540": {"epss_score": 0.10815, "epss_percentile": 0.9312}, "CVE-2019-11541": {"epss_score": 0.01765, "epss_percentile": 0.82162}, "CVE-2019-11542": {"epss_score": 0.48797, "epss_percentile": 0.97655}, "CVE-2019-11543": {"epss_score": 0.00179, "epss_percentile": 0.39793}, "CVE-2019-11544": {"epss_score": 0.00114, "epss_percentile": 0.3075}, "CVE-2019-11545": {"epss_score": 0.00114, "epss_percentile": 0.3075}, "CVE-2019-11546": {"epss_score": 0.00071, "epss_percentile": 0.22223}, "CVE-2019-11547": {"epss_score": 0.00159, "epss_percentile": 0.37395}, "CVE-2019-11548": {"epss_score": 0.00068, "epss_percentile": 0.21372}, "CVE-2019-11549": {"epss_score": 0.00167, "epss_percentile": 0.38381}, "CVE-2019-11550": {"epss_score": 0.00144, "epss_percentile": 0.35297}, "CVE-2019-11551": {"epss_score": 0.00048, "epss_percentile": 0.15055}, "CVE-2019-11552": {"epss_score": 0.00161, "epss_percentile": 0.37581}, "CVE-2019-11553": {"epss_score": 0.00214, "epss_percentile": 0.44018}, "CVE-2019-11554": {"epss_score": 0.00206, "epss_percentile": 0.43062}, "CVE-2019-11555": {"epss_score": 0.09076, "epss_percentile": 0.92389}, "CVE-2019-11556": {"epss_score": 0.00587, "epss_percentile": 0.68467}, "CVE-2019-11557": {"epss_score": 0.00243, "epss_percentile": 0.4751}, "CVE-2019-11559": {"epss_score": 0.00429, "epss_percentile": 0.61969}, "CVE-2019-11560": {"epss_score": 0.00712, "epss_percentile": 0.71753}, "CVE-2019-11561": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-11564": {"epss_score": 0.01718, "epss_percentile": 0.81922}, "CVE-2019-11565": {"epss_score": 0.02527, "epss_percentile": 0.85015}, "CVE-2019-11567": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2019-11568": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2019-11569": {"epss_score": 0.00269, "epss_percentile": 0.5019}, "CVE-2019-11574": {"epss_score": 0.00656, "epss_percentile": 0.70442}, "CVE-2019-11576": {"epss_score": 0.00397, "epss_percentile": 0.60029}, "CVE-2019-11577": {"epss_score": 0.09039, "epss_percentile": 0.92377}, "CVE-2019-11578": {"epss_score": 0.00477, "epss_percentile": 0.6435}, "CVE-2019-11579": {"epss_score": 0.0047, "epss_percentile": 0.6399}, "CVE-2019-11580": {"epss_score": 0.94386, "epss_percentile": 0.99968}, "CVE-2019-11581": {"epss_score": 0.94355, "epss_percentile": 0.99956}, "CVE-2019-11582": {"epss_score": 0.01879, "epss_percentile": 0.8267}, "CVE-2019-11583": {"epss_score": 0.00479, "epss_percentile": 0.64413}, "CVE-2019-11584": {"epss_score": 0.00231, "epss_percentile": 0.45828}, "CVE-2019-11585": {"epss_score": 0.00158, "epss_percentile": 0.37254}, "CVE-2019-11586": {"epss_score": 0.00087, "epss_percentile": 0.25574}, "CVE-2019-11587": {"epss_score": 0.00087, "epss_percentile": 0.25574}, "CVE-2019-11588": {"epss_score": 0.0013, "epss_percentile": 0.33254}, "CVE-2019-11589": {"epss_score": 0.00172, "epss_percentile": 0.38959}, "CVE-2019-11590": {"epss_score": 0.00345, "epss_percentile": 0.5659}, "CVE-2019-11591": {"epss_score": 0.00277, "epss_percentile": 0.50799}, "CVE-2019-11592": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-11593": {"epss_score": 0.00776, "epss_percentile": 0.73106}, "CVE-2019-11594": {"epss_score": 0.01161, "epss_percentile": 0.78146}, "CVE-2019-11595": {"epss_score": 0.00944, "epss_percentile": 0.75791}, "CVE-2019-11596": {"epss_score": 0.01644, "epss_percentile": 0.8152}, "CVE-2019-11597": {"epss_score": 0.00226, "epss_percentile": 0.45285}, "CVE-2019-11598": {"epss_score": 0.00226, "epss_percentile": 0.45285}, "CVE-2019-11599": {"epss_score": 0.0056, "epss_percentile": 0.67635}, "CVE-2019-11600": {"epss_score": 0.80674, "epss_percentile": 0.99101}, "CVE-2019-11601": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2019-11602": {"epss_score": 0.002, "epss_percentile": 0.42248}, "CVE-2019-11603": {"epss_score": 0.00371, "epss_percentile": 0.58405}, "CVE-2019-11604": {"epss_score": 0.00503, "epss_percentile": 0.65437}, "CVE-2019-11605": {"epss_score": 0.00088, "epss_percentile": 0.25776}, "CVE-2019-11606": {"epss_score": 0.00731, "epss_percentile": 0.72164}, "CVE-2019-11607": {"epss_score": 0.00731, "epss_percentile": 0.72164}, "CVE-2019-11608": {"epss_score": 0.01309, "epss_percentile": 0.79352}, "CVE-2019-11609": {"epss_score": 0.01309, "epss_percentile": 0.79352}, "CVE-2019-11610": {"epss_score": 0.00731, "epss_percentile": 0.72164}, "CVE-2019-11611": {"epss_score": 0.00731, "epss_percentile": 0.72164}, "CVE-2019-11612": {"epss_score": 0.06696, "epss_percentile": 0.90952}, "CVE-2019-11613": {"epss_score": 0.00228, "epss_percentile": 0.45545}, "CVE-2019-11614": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2019-11615": {"epss_score": 0.00401, "epss_percentile": 0.6026}, "CVE-2019-11616": {"epss_score": 0.00974, "epss_percentile": 0.76194}, "CVE-2019-11617": {"epss_score": 0.00209, "epss_percentile": 0.43333}, "CVE-2019-11618": {"epss_score": 0.00842, "epss_percentile": 0.74233}, "CVE-2019-11619": {"epss_score": 0.00261, "epss_percentile": 0.49288}, "CVE-2019-11620": {"epss_score": 0.00261, "epss_percentile": 0.49288}, "CVE-2019-11621": {"epss_score": 0.00261, "epss_percentile": 0.49288}, "CVE-2019-11622": {"epss_score": 0.00261, "epss_percentile": 0.49288}, "CVE-2019-11623": {"epss_score": 0.00261, "epss_percentile": 0.49288}, "CVE-2019-11624": {"epss_score": 0.00746, "epss_percentile": 0.72544}, "CVE-2019-11625": {"epss_score": 0.00321, "epss_percentile": 0.54695}, "CVE-2019-11626": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2019-11627": {"epss_score": 0.00498, "epss_percentile": 0.65213}, "CVE-2019-11628": {"epss_score": 0.0034, "epss_percentile": 0.56228}, "CVE-2019-11629": {"epss_score": 0.00375, "epss_percentile": 0.58618}, "CVE-2019-11632": {"epss_score": 0.0033, "epss_percentile": 0.55454}, "CVE-2019-11633": {"epss_score": 0.00285, "epss_percentile": 0.51538}, "CVE-2019-11634": {"epss_score": 0.52839, "epss_percentile": 0.97844}, "CVE-2019-11636": {"epss_score": 0.00518, "epss_percentile": 0.6613}, "CVE-2019-11637": {"epss_score": 0.00272, "epss_percentile": 0.50375}, "CVE-2019-11638": {"epss_score": 0.00165, "epss_percentile": 0.38023}, "CVE-2019-11639": {"epss_score": 0.00243, "epss_percentile": 0.47412}, "CVE-2019-11640": {"epss_score": 0.00243, "epss_percentile": 0.47412}, "CVE-2019-11641": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2019-11642": {"epss_score": 0.00439, "epss_percentile": 0.62579}, "CVE-2019-11643": {"epss_score": 0.0088, "epss_percentile": 0.7486}, "CVE-2019-11644": {"epss_score": 0.00398, "epss_percentile": 0.60066}, "CVE-2019-11646": {"epss_score": 0.00537, "epss_percentile": 0.66921}, "CVE-2019-11647": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-11648": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-11649": {"epss_score": 0.00172, "epss_percentile": 0.38906}, "CVE-2019-11650": {"epss_score": 0.003, "epss_percentile": 0.52981}, "CVE-2019-11651": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-11652": {"epss_score": 0.00519, "epss_percentile": 0.66143}, "CVE-2019-11653": {"epss_score": 0.00125, "epss_percentile": 0.32577}, "CVE-2019-11654": {"epss_score": 0.01436, "epss_percentile": 0.80275}, "CVE-2019-11655": {"epss_score": 0.00484, "epss_percentile": 0.64658}, "CVE-2019-11656": {"epss_score": 0.00239, "epss_percentile": 0.46864}, "CVE-2019-11657": {"epss_score": 0.00177, "epss_percentile": 0.39555}, "CVE-2019-11658": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2019-11660": {"epss_score": 0.34221, "epss_percentile": 0.96833}, "CVE-2019-11661": {"epss_score": 0.00423, "epss_percentile": 0.61625}, "CVE-2019-11662": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2019-11663": {"epss_score": 0.00097, "epss_percentile": 0.27458}, "CVE-2019-11664": {"epss_score": 0.00097, "epss_percentile": 0.27458}, "CVE-2019-11665": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-11666": {"epss_score": 0.00242, "epss_percentile": 0.4736}, "CVE-2019-11667": {"epss_score": 0.00377, "epss_percentile": 0.58716}, "CVE-2019-11668": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-11669": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-11674": {"epss_score": 0.00155, "epss_percentile": 0.36804}, "CVE-2019-11675": {"epss_score": 0.00033, "epss_percentile": 0.09152}, "CVE-2019-11676": {"epss_score": 0.0129, "epss_percentile": 0.79221}, "CVE-2019-11677": {"epss_score": 0.02347, "epss_percentile": 0.84456}, "CVE-2019-11678": {"epss_score": 0.12833, "epss_percentile": 0.93798}, "CVE-2019-11680": {"epss_score": 0.01192, "epss_percentile": 0.784}, "CVE-2019-11682": {"epss_score": 0.00463, "epss_percentile": 0.63663}, "CVE-2019-11683": {"epss_score": 0.10551, "epss_percentile": 0.93026}, "CVE-2019-11684": {"epss_score": 0.00205, "epss_percentile": 0.427}, "CVE-2019-11686": {"epss_score": 0.001, "epss_percentile": 0.28443}, "CVE-2019-11687": {"epss_score": 0.12419, "epss_percentile": 0.93664}, "CVE-2019-11688": {"epss_score": 0.00391, "epss_percentile": 0.59589}, "CVE-2019-11689": {"epss_score": 0.02414, "epss_percentile": 0.84679}, "CVE-2019-11690": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-11691": {"epss_score": 0.00516, "epss_percentile": 0.66031}, "CVE-2019-11692": {"epss_score": 0.00516, "epss_percentile": 0.66031}, "CVE-2019-11693": {"epss_score": 0.00598, "epss_percentile": 0.68771}, "CVE-2019-11694": {"epss_score": 0.00398, "epss_percentile": 0.60059}, "CVE-2019-11695": {"epss_score": 0.00186, "epss_percentile": 0.40602}, "CVE-2019-11696": {"epss_score": 0.00158, "epss_percentile": 0.37199}, "CVE-2019-11697": {"epss_score": 0.00203, "epss_percentile": 0.42541}, "CVE-2019-11698": {"epss_score": 0.00379, "epss_percentile": 0.58894}, "CVE-2019-11699": {"epss_score": 0.00203, "epss_percentile": 0.42541}, "CVE-2019-11700": {"epss_score": 0.00383, "epss_percentile": 0.5911}, "CVE-2019-11701": {"epss_score": 0.00235, "epss_percentile": 0.46233}, "CVE-2019-11702": {"epss_score": 0.00379, "epss_percentile": 0.58885}, "CVE-2019-11703": {"epss_score": 0.08297, "epss_percentile": 0.91977}, "CVE-2019-11704": {"epss_score": 0.08297, "epss_percentile": 0.91977}, "CVE-2019-11705": {"epss_score": 0.08708, "epss_percentile": 0.92221}, "CVE-2019-11706": {"epss_score": 0.04094, "epss_percentile": 0.88245}, "CVE-2019-11707": {"epss_score": 0.81818, "epss_percentile": 0.99158}, "CVE-2019-11708": {"epss_score": 0.68885, "epss_percentile": 0.98566}, "CVE-2019-11709": {"epss_score": 0.02576, "epss_percentile": 0.85142}, "CVE-2019-11710": {"epss_score": 0.01311, "epss_percentile": 0.79369}, "CVE-2019-11711": {"epss_score": 0.0147, "epss_percentile": 0.80493}, "CVE-2019-11712": {"epss_score": 0.00376, "epss_percentile": 0.58661}, "CVE-2019-11713": {"epss_score": 0.0149, "epss_percentile": 0.80627}, "CVE-2019-11714": {"epss_score": 0.00756, "epss_percentile": 0.72742}, "CVE-2019-11715": {"epss_score": 0.00646, "epss_percentile": 0.7013}, "CVE-2019-11716": {"epss_score": 0.00583, "epss_percentile": 0.68355}, "CVE-2019-11717": {"epss_score": 0.05007, "epss_percentile": 0.89386}, "CVE-2019-11718": {"epss_score": 0.00614, "epss_percentile": 0.69286}, "CVE-2019-11719": {"epss_score": 0.00447, "epss_percentile": 0.62959}, "CVE-2019-11720": {"epss_score": 0.00743, "epss_percentile": 0.72497}, "CVE-2019-11721": {"epss_score": 0.00572, "epss_percentile": 0.68017}, "CVE-2019-11723": {"epss_score": 0.00309, "epss_percentile": 0.53696}, "CVE-2019-11724": {"epss_score": 0.00412, "epss_percentile": 0.60955}, "CVE-2019-11725": {"epss_score": 0.00232, "epss_percentile": 0.45941}, "CVE-2019-11727": {"epss_score": 0.00248, "epss_percentile": 0.47988}, "CVE-2019-11728": {"epss_score": 0.00639, "epss_percentile": 0.69935}, "CVE-2019-11729": {"epss_score": 0.00684, "epss_percentile": 0.71113}, "CVE-2019-11730": {"epss_score": 0.1971, "epss_percentile": 0.95229}, "CVE-2019-11733": {"epss_score": 0.0039, "epss_percentile": 0.59559}, "CVE-2019-11734": {"epss_score": 0.00434, "epss_percentile": 0.62282}, "CVE-2019-11735": {"epss_score": 0.00458, "epss_percentile": 0.63425}, "CVE-2019-11736": {"epss_score": 0.00057, "epss_percentile": 0.17983}, "CVE-2019-11737": {"epss_score": 0.00133, "epss_percentile": 0.33694}, "CVE-2019-11738": {"epss_score": 0.00585, "epss_percentile": 0.68405}, "CVE-2019-11739": {"epss_score": 0.00266, "epss_percentile": 0.49912}, "CVE-2019-11740": {"epss_score": 0.015, "epss_percentile": 0.80709}, "CVE-2019-11741": {"epss_score": 0.0029, "epss_percentile": 0.52127}, "CVE-2019-11742": {"epss_score": 0.0053, "epss_percentile": 0.66617}, "CVE-2019-11743": {"epss_score": 0.00989, "epss_percentile": 0.7636}, "CVE-2019-11744": {"epss_score": 0.00786, "epss_percentile": 0.73291}, "CVE-2019-11745": {"epss_score": 0.00806, "epss_percentile": 0.73648}, "CVE-2019-11746": {"epss_score": 0.00651, "epss_percentile": 0.70296}, "CVE-2019-11747": {"epss_score": 0.00352, "epss_percentile": 0.57115}, "CVE-2019-11748": {"epss_score": 0.003, "epss_percentile": 0.52938}, "CVE-2019-11749": {"epss_score": 0.00369, "epss_percentile": 0.58264}, "CVE-2019-11750": {"epss_score": 0.00376, "epss_percentile": 0.58647}, "CVE-2019-11751": {"epss_score": 0.00596, "epss_percentile": 0.68733}, "CVE-2019-11752": {"epss_score": 0.00893, "epss_percentile": 0.75079}, "CVE-2019-11753": {"epss_score": 0.00062, "epss_percentile": 0.1975}, "CVE-2019-11754": {"epss_score": 0.00186, "epss_percentile": 0.40589}, "CVE-2019-11755": {"epss_score": 0.00406, "epss_percentile": 0.60541}, "CVE-2019-11756": {"epss_score": 0.00171, "epss_percentile": 0.38857}, "CVE-2019-11757": {"epss_score": 0.01379, "epss_percentile": 0.79853}, "CVE-2019-11758": {"epss_score": 0.00849, "epss_percentile": 0.74374}, "CVE-2019-11759": {"epss_score": 0.03057, "epss_percentile": 0.86302}, "CVE-2019-11760": {"epss_score": 0.01524, "epss_percentile": 0.80848}, "CVE-2019-11761": {"epss_score": 0.00442, "epss_percentile": 0.62739}, "CVE-2019-11762": {"epss_score": 0.00379, "epss_percentile": 0.58851}, "CVE-2019-11763": {"epss_score": 0.0223, "epss_percentile": 0.84085}, "CVE-2019-11764": {"epss_score": 0.00976, "epss_percentile": 0.76213}, "CVE-2019-11765": {"epss_score": 0.00309, "epss_percentile": 0.53677}, "CVE-2019-11766": {"epss_score": 0.00777, "epss_percentile": 0.73118}, "CVE-2019-11767": {"epss_score": 0.00222, "epss_percentile": 0.44805}, "CVE-2019-11768": {"epss_score": 0.01413, "epss_percentile": 0.80122}, "CVE-2019-11769": {"epss_score": 0.00122, "epss_percentile": 0.32051}, "CVE-2019-11770": {"epss_score": 0.00446, "epss_percentile": 0.62894}, "CVE-2019-11771": {"epss_score": 0.00043, "epss_percentile": 0.13072}, "CVE-2019-11772": {"epss_score": 0.00871, "epss_percentile": 0.74712}, "CVE-2019-11773": {"epss_score": 0.00054, "epss_percentile": 0.17175}, "CVE-2019-11774": {"epss_score": 0.00458, "epss_percentile": 0.63437}, "CVE-2019-11775": {"epss_score": 0.01505, "epss_percentile": 0.80742}, "CVE-2019-11776": {"epss_score": 0.00248, "epss_percentile": 0.4791}, "CVE-2019-11777": {"epss_score": 0.01765, "epss_percentile": 0.82161}, "CVE-2019-11778": {"epss_score": 0.00348, "epss_percentile": 0.56851}, "CVE-2019-11779": {"epss_score": 0.06791, "epss_percentile": 0.91029}, "CVE-2019-11780": {"epss_score": 0.00217, "epss_percentile": 0.44241}, "CVE-2019-11781": {"epss_score": 0.00234, "epss_percentile": 0.46198}, "CVE-2019-11782": {"epss_score": 0.0013, "epss_percentile": 0.33265}, "CVE-2019-11783": {"epss_score": 0.00333, "epss_percentile": 0.55654}, "CVE-2019-11784": {"epss_score": 0.00208, "epss_percentile": 0.4328}, "CVE-2019-11785": {"epss_score": 0.00198, "epss_percentile": 0.42016}, "CVE-2019-11786": {"epss_score": 0.00147, "epss_percentile": 0.3571}, "CVE-2019-11806": {"epss_score": 0.00078, "epss_percentile": 0.23652}, "CVE-2019-11807": {"epss_score": 0.00404, "epss_percentile": 0.60437}, "CVE-2019-11808": {"epss_score": 0.00297, "epss_percentile": 0.52751}, "CVE-2019-11809": {"epss_score": 0.00276, "epss_percentile": 0.50719}, "CVE-2019-11810": {"epss_score": 0.01876, "epss_percentile": 0.82658}, "CVE-2019-11811": {"epss_score": 0.00071, "epss_percentile": 0.2202}, "CVE-2019-11812": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-11813": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2019-11814": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-11815": {"epss_score": 0.01422, "epss_percentile": 0.80185}, "CVE-2019-11816": {"epss_score": 0.02128, "epss_percentile": 0.83702}, "CVE-2019-11818": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-11819": {"epss_score": 0.00203, "epss_percentile": 0.42522}, "CVE-2019-11820": {"epss_score": 0.00036, "epss_percentile": 0.10296}, "CVE-2019-11821": {"epss_score": 0.0058, "epss_percentile": 0.6825}, "CVE-2019-11822": {"epss_score": 0.00194, "epss_percentile": 0.41547}, "CVE-2019-11823": {"epss_score": 0.01097, "epss_percentile": 0.77531}, "CVE-2019-11825": {"epss_score": 0.00133, "epss_percentile": 0.33708}, "CVE-2019-11826": {"epss_score": 0.00857, "epss_percentile": 0.74487}, "CVE-2019-11827": {"epss_score": 0.00133, "epss_percentile": 0.33708}, "CVE-2019-11828": {"epss_score": 0.00133, "epss_percentile": 0.33708}, "CVE-2019-11829": {"epss_score": 0.02189, "epss_percentile": 0.8393}, "CVE-2019-11830": {"epss_score": 0.02541, "epss_percentile": 0.85049}, "CVE-2019-11831": {"epss_score": 0.10662, "epss_percentile": 0.93062}, "CVE-2019-11832": {"epss_score": 0.00898, "epss_percentile": 0.7515}, "CVE-2019-11833": {"epss_score": 0.00025, "epss_percentile": 0.06045}, "CVE-2019-11834": {"epss_score": 0.00621, "epss_percentile": 0.69476}, "CVE-2019-11835": {"epss_score": 0.00671, "epss_percentile": 0.70801}, "CVE-2019-11836": {"epss_score": 0.0003, "epss_percentile": 0.08193}, "CVE-2019-11837": {"epss_score": 0.00283, "epss_percentile": 0.51408}, "CVE-2019-11838": {"epss_score": 0.00389, "epss_percentile": 0.59491}, "CVE-2019-11839": {"epss_score": 0.00389, "epss_percentile": 0.59491}, "CVE-2019-11840": {"epss_score": 0.02757, "epss_percentile": 0.85593}, "CVE-2019-11841": {"epss_score": 0.0039, "epss_percentile": 0.59536}, "CVE-2019-11842": {"epss_score": 0.00535, "epss_percentile": 0.66836}, "CVE-2019-11843": {"epss_score": 0.00454, "epss_percentile": 0.63254}, "CVE-2019-11844": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-11845": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-11846": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2019-11847": {"epss_score": 8e-05, "epss_percentile": 0.00535}, "CVE-2019-11848": {"epss_score": 0.00016, "epss_percentile": 0.0283}, "CVE-2019-11849": {"epss_score": 3e-05, "epss_percentile": 0.0011}, "CVE-2019-11850": {"epss_score": 3e-05, "epss_percentile": 0.0011}, "CVE-2019-11851": {"epss_score": 0.00077, "epss_percentile": 0.23353}, "CVE-2019-11852": {"epss_score": 0.00019, "epss_percentile": 0.04408}, "CVE-2019-11853": {"epss_score": 0.00022, "epss_percentile": 0.05273}, "CVE-2019-11855": {"epss_score": 0.00019, "epss_percentile": 0.04408}, "CVE-2019-11856": {"epss_score": 0.00021, "epss_percentile": 0.04818}, "CVE-2019-11857": {"epss_score": 0.00016, "epss_percentile": 0.02911}, "CVE-2019-11858": {"epss_score": 0.00022, "epss_percentile": 0.05163}, "CVE-2019-11859": {"epss_score": 0.00017, "epss_percentile": 0.03247}, "CVE-2019-11862": {"epss_score": 0.00012, "epss_percentile": 0.01133}, "CVE-2019-11867": {"epss_score": 0.00122, "epss_percentile": 0.3215}, "CVE-2019-11868": {"epss_score": 0.00128, "epss_percentile": 0.33033}, "CVE-2019-11869": {"epss_score": 0.05601, "epss_percentile": 0.90039}, "CVE-2019-11870": {"epss_score": 0.00435, "epss_percentile": 0.6234}, "CVE-2019-11871": {"epss_score": 0.00279, "epss_percentile": 0.50981}, "CVE-2019-11872": {"epss_score": 0.0105, "epss_percentile": 0.77071}, "CVE-2019-11873": {"epss_score": 0.06896, "epss_percentile": 0.911}, "CVE-2019-11875": {"epss_score": 0.00339, "epss_percentile": 0.56188}, "CVE-2019-11876": {"epss_score": 0.00212, "epss_percentile": 0.43741}, "CVE-2019-11877": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2019-11878": {"epss_score": 0.00203, "epss_percentile": 0.42581}, "CVE-2019-11879": {"epss_score": 0.00036, "epss_percentile": 0.10321}, "CVE-2019-11880": {"epss_score": 0.00309, "epss_percentile": 0.53668}, "CVE-2019-11881": {"epss_score": 0.05541, "epss_percentile": 0.89978}, "CVE-2019-11884": {"epss_score": 0.00049, "epss_percentile": 0.15342}, "CVE-2019-11885": {"epss_score": 0.00071, "epss_percentile": 0.2209}, "CVE-2019-11886": {"epss_score": 0.28566, "epss_percentile": 0.96368}, "CVE-2019-11887": {"epss_score": 0.02126, "epss_percentile": 0.83694}, "CVE-2019-11888": {"epss_score": 0.0042, "epss_percentile": 0.6141}, "CVE-2019-11889": {"epss_score": 0.014, "epss_percentile": 0.80003}, "CVE-2019-11890": {"epss_score": 0.03642, "epss_percentile": 0.87492}, "CVE-2019-11891": {"epss_score": 0.0011, "epss_percentile": 0.30187}, "CVE-2019-11892": {"epss_score": 0.00373, "epss_percentile": 0.58529}, "CVE-2019-11893": {"epss_score": 0.00054, "epss_percentile": 0.1705}, "CVE-2019-11894": {"epss_score": 0.00086, "epss_percentile": 0.25428}, "CVE-2019-11895": {"epss_score": 0.00223, "epss_percentile": 0.44873}, "CVE-2019-11896": {"epss_score": 0.00162, "epss_percentile": 0.37616}, "CVE-2019-11897": {"epss_score": 0.00321, "epss_percentile": 0.54742}, "CVE-2019-11898": {"epss_score": 0.00319, "epss_percentile": 0.54485}, "CVE-2019-11899": {"epss_score": 0.00427, "epss_percentile": 0.61907}, "CVE-2019-11921": {"epss_score": 0.00488, "epss_percentile": 0.64849}, "CVE-2019-11922": {"epss_score": 0.0063, "epss_percentile": 0.697}, "CVE-2019-11923": {"epss_score": 0.00642, "epss_percentile": 0.70019}, "CVE-2019-11924": {"epss_score": 0.0051, "epss_percentile": 0.65792}, "CVE-2019-11925": {"epss_score": 0.00974, "epss_percentile": 0.76173}, "CVE-2019-11926": {"epss_score": 0.00974, "epss_percentile": 0.76173}, "CVE-2019-11927": {"epss_score": 0.00282, "epss_percentile": 0.51225}, "CVE-2019-11928": {"epss_score": 0.00158, "epss_percentile": 0.37221}, "CVE-2019-11929": {"epss_score": 0.04726, "epss_percentile": 0.89066}, "CVE-2019-11930": {"epss_score": 0.02498, "epss_percentile": 0.84913}, "CVE-2019-11931": {"epss_score": 0.00472, "epss_percentile": 0.64063}, "CVE-2019-11932": {"epss_score": 0.67424, "epss_percentile": 0.98506}, "CVE-2019-11933": {"epss_score": 0.07307, "epss_percentile": 0.91397}, "CVE-2019-11934": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-11935": {"epss_score": 0.00644, "epss_percentile": 0.70077}, "CVE-2019-11936": {"epss_score": 0.00644, "epss_percentile": 0.70077}, "CVE-2019-11937": {"epss_score": 0.00642, "epss_percentile": 0.70019}, "CVE-2019-11938": {"epss_score": 0.00642, "epss_percentile": 0.70019}, "CVE-2019-11939": {"epss_score": 0.00615, "epss_percentile": 0.69292}, "CVE-2019-11940": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-11941": {"epss_score": 0.01738, "epss_percentile": 0.82025}, "CVE-2019-11942": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11943": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11944": {"epss_score": 0.33037, "epss_percentile": 0.96741}, "CVE-2019-11945": {"epss_score": 0.627, "epss_percentile": 0.98303}, "CVE-2019-11946": {"epss_score": 0.00195, "epss_percentile": 0.41645}, "CVE-2019-11947": {"epss_score": 0.02314, "epss_percentile": 0.84352}, "CVE-2019-11948": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11949": {"epss_score": 0.1903, "epss_percentile": 0.95115}, "CVE-2019-11950": {"epss_score": 0.32372, "epss_percentile": 0.96693}, "CVE-2019-11951": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11952": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11953": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11954": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11955": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11956": {"epss_score": 0.32372, "epss_percentile": 0.96693}, "CVE-2019-11957": {"epss_score": 0.02375, "epss_percentile": 0.84543}, "CVE-2019-11958": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11959": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11960": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11961": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11962": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11963": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11964": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11965": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11966": {"epss_score": 0.00367, "epss_percentile": 0.58117}, "CVE-2019-11967": {"epss_score": 0.03357, "epss_percentile": 0.86976}, "CVE-2019-11968": {"epss_score": 0.03357, "epss_percentile": 0.86976}, "CVE-2019-11969": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11970": {"epss_score": 0.00678, "epss_percentile": 0.70977}, "CVE-2019-11971": {"epss_score": 0.00678, "epss_percentile": 0.70977}, "CVE-2019-11972": {"epss_score": 0.00678, "epss_percentile": 0.70977}, "CVE-2019-11973": {"epss_score": 0.00678, "epss_percentile": 0.70977}, "CVE-2019-11974": {"epss_score": 0.00678, "epss_percentile": 0.70977}, "CVE-2019-11975": {"epss_score": 0.00678, "epss_percentile": 0.70977}, "CVE-2019-11976": {"epss_score": 0.00678, "epss_percentile": 0.70977}, "CVE-2019-11977": {"epss_score": 0.00678, "epss_percentile": 0.70977}, "CVE-2019-11978": {"epss_score": 0.00678, "epss_percentile": 0.70977}, "CVE-2019-11979": {"epss_score": 0.00678, "epss_percentile": 0.70977}, "CVE-2019-11980": {"epss_score": 0.00506, "epss_percentile": 0.65621}, "CVE-2019-11982": {"epss_score": 0.00603, "epss_percentile": 0.68916}, "CVE-2019-11983": {"epss_score": 0.00661, "epss_percentile": 0.70588}, "CVE-2019-11984": {"epss_score": 0.00678, "epss_percentile": 0.70977}, "CVE-2019-11985": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11986": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-11987": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2019-11988": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2019-11989": {"epss_score": 0.00637, "epss_percentile": 0.69886}, "CVE-2019-11990": {"epss_score": 0.00385, "epss_percentile": 0.59226}, "CVE-2019-11991": {"epss_score": 0.02909, "epss_percentile": 0.85967}, "CVE-2019-11992": {"epss_score": 0.01178, "epss_percentile": 0.78284}, "CVE-2019-11993": {"epss_score": 0.005, "epss_percentile": 0.65296}, "CVE-2019-11994": {"epss_score": 0.04306, "epss_percentile": 0.88522}, "CVE-2019-11995": {"epss_score": 0.01979, "epss_percentile": 0.83134}, "CVE-2019-11996": {"epss_score": 0.00442, "epss_percentile": 0.62751}, "CVE-2019-11997": {"epss_score": 0.00419, "epss_percentile": 0.6136}, "CVE-2019-11998": {"epss_score": 0.0019, "epss_percentile": 0.41109}, "CVE-2019-11999": {"epss_score": 0.0026, "epss_percentile": 0.49217}, "CVE-2019-12000": {"epss_score": 0.00307, "epss_percentile": 0.53559}, "CVE-2019-12001": {"epss_score": 0.0011, "epss_percentile": 0.30198}, "CVE-2019-12002": {"epss_score": 0.00196, "epss_percentile": 0.41764}, "CVE-2019-12017": {"epss_score": 0.02528, "epss_percentile": 0.8502}, "CVE-2019-12041": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2019-12042": {"epss_score": 0.00708, "epss_percentile": 0.71669}, "CVE-2019-12043": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-12044": {"epss_score": 0.00573, "epss_percentile": 0.68054}, "CVE-2019-12046": {"epss_score": 0.01744, "epss_percentile": 0.82061}, "CVE-2019-12047": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2019-12067": {"epss_score": 0.00165, "epss_percentile": 0.38011}, "CVE-2019-12068": {"epss_score": 0.00086, "epss_percentile": 0.25296}, "CVE-2019-12083": {"epss_score": 0.00784, "epss_percentile": 0.73232}, "CVE-2019-12086": {"epss_score": 0.13566, "epss_percentile": 0.93998}, "CVE-2019-12087": {"epss_score": 0.00049, "epss_percentile": 0.153}, "CVE-2019-12091": {"epss_score": 0.00212, "epss_percentile": 0.43729}, "CVE-2019-12094": {"epss_score": 0.00953, "epss_percentile": 0.75885}, "CVE-2019-12095": {"epss_score": 0.00478, "epss_percentile": 0.64394}, "CVE-2019-12097": {"epss_score": 0.00012, "epss_percentile": 0.01302}, "CVE-2019-12098": {"epss_score": 0.04803, "epss_percentile": 0.89159}, "CVE-2019-12099": {"epss_score": 0.41741, "epss_percentile": 0.97291}, "CVE-2019-12101": {"epss_score": 0.00757, "epss_percentile": 0.72754}, "CVE-2019-12102": {"epss_score": 0.00221, "epss_percentile": 0.44699}, "CVE-2019-12103": {"epss_score": 0.03525, "epss_percentile": 0.87295}, "CVE-2019-12104": {"epss_score": 0.06934, "epss_percentile": 0.91125}, "CVE-2019-12105": {"epss_score": 0.02031, "epss_percentile": 0.83333}, "CVE-2019-12106": {"epss_score": 0.00689, "epss_percentile": 0.71232}, "CVE-2019-12107": {"epss_score": 0.00334, "epss_percentile": 0.55705}, "CVE-2019-12108": {"epss_score": 0.00539, "epss_percentile": 0.66968}, "CVE-2019-12109": {"epss_score": 0.00539, "epss_percentile": 0.66968}, "CVE-2019-12110": {"epss_score": 0.00603, "epss_percentile": 0.68917}, "CVE-2019-12111": {"epss_score": 0.0103, "epss_percentile": 0.76836}, "CVE-2019-12112": {"epss_score": 0.01668, "epss_percentile": 0.8166}, "CVE-2019-12113": {"epss_score": 0.00674, "epss_percentile": 0.70862}, "CVE-2019-12114": {"epss_score": 0.01146, "epss_percentile": 0.78}, "CVE-2019-12115": {"epss_score": 0.01146, "epss_percentile": 0.78}, "CVE-2019-12116": {"epss_score": 0.01146, "epss_percentile": 0.78}, "CVE-2019-12117": {"epss_score": 0.01146, "epss_percentile": 0.78}, "CVE-2019-12118": {"epss_score": 0.01146, "epss_percentile": 0.78}, "CVE-2019-12119": {"epss_score": 0.01146, "epss_percentile": 0.78}, "CVE-2019-12120": {"epss_score": 0.01146, "epss_percentile": 0.78}, "CVE-2019-12121": {"epss_score": 0.00187, "epss_percentile": 0.40713}, "CVE-2019-12122": {"epss_score": 0.00189, "epss_percentile": 0.40989}, "CVE-2019-12123": {"epss_score": 0.00674, "epss_percentile": 0.70862}, "CVE-2019-12124": {"epss_score": 0.00565, "epss_percentile": 0.67798}, "CVE-2019-12125": {"epss_score": 0.00336, "epss_percentile": 0.56007}, "CVE-2019-12126": {"epss_score": 0.00336, "epss_percentile": 0.56007}, "CVE-2019-12127": {"epss_score": 0.00336, "epss_percentile": 0.56007}, "CVE-2019-12128": {"epss_score": 0.00427, "epss_percentile": 0.61903}, "CVE-2019-12129": {"epss_score": 0.00427, "epss_percentile": 0.61903}, "CVE-2019-12130": {"epss_score": 0.00427, "epss_percentile": 0.61903}, "CVE-2019-12131": {"epss_score": 0.00297, "epss_percentile": 0.52708}, "CVE-2019-12132": {"epss_score": 0.01668, "epss_percentile": 0.8166}, "CVE-2019-12133": {"epss_score": 0.00056, "epss_percentile": 0.17659}, "CVE-2019-12134": {"epss_score": 0.00475, "epss_percentile": 0.64183}, "CVE-2019-12135": {"epss_score": 0.01394, "epss_percentile": 0.79972}, "CVE-2019-12136": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2019-12137": {"epss_score": 0.04581, "epss_percentile": 0.88877}, "CVE-2019-12138": {"epss_score": 0.00091, "epss_percentile": 0.2621}, "CVE-2019-12139": {"epss_score": 0.00311, "epss_percentile": 0.53925}, "CVE-2019-12143": {"epss_score": 0.00012, "epss_percentile": 0.01253}, "CVE-2019-12144": {"epss_score": 0.00253, "epss_percentile": 0.48426}, "CVE-2019-12145": {"epss_score": 0.00012, "epss_percentile": 0.01153}, "CVE-2019-12146": {"epss_score": 0.00014, "epss_percentile": 0.02052}, "CVE-2019-12147": {"epss_score": 0.03276, "epss_percentile": 0.86802}, "CVE-2019-12148": {"epss_score": 0.00632, "epss_percentile": 0.69736}, "CVE-2019-12149": {"epss_score": 0.00307, "epss_percentile": 0.53524}, "CVE-2019-12150": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2019-12153": {"epss_score": 0.00357, "epss_percentile": 0.574}, "CVE-2019-12154": {"epss_score": 0.00543, "epss_percentile": 0.67091}, "CVE-2019-12155": {"epss_score": 0.0117, "epss_percentile": 0.78206}, "CVE-2019-12156": {"epss_score": 3e-05, "epss_percentile": 0.00107}, "CVE-2019-12157": {"epss_score": 4e-05, "epss_percentile": 0.0017}, "CVE-2019-12158": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2019-12159": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-12160": {"epss_score": 0.00509, "epss_percentile": 0.65724}, "CVE-2019-12161": {"epss_score": 0.00189, "epss_percentile": 0.4095}, "CVE-2019-12162": {"epss_score": 0.00078, "epss_percentile": 0.23567}, "CVE-2019-12163": {"epss_score": 0.01156, "epss_percentile": 0.78082}, "CVE-2019-12164": {"epss_score": 0.02573, "epss_percentile": 0.85137}, "CVE-2019-12165": {"epss_score": 0.00782, "epss_percentile": 0.73207}, "CVE-2019-12167": {"epss_score": 0.00333, "epss_percentile": 0.55673}, "CVE-2019-12168": {"epss_score": 0.1197, "epss_percentile": 0.93529}, "CVE-2019-12169": {"epss_score": 0.79009, "epss_percentile": 0.99015}, "CVE-2019-12170": {"epss_score": 0.15293, "epss_percentile": 0.94403}, "CVE-2019-12171": {"epss_score": 0.00119, "epss_percentile": 0.31557}, "CVE-2019-12172": {"epss_score": 0.00937, "epss_percentile": 0.757}, "CVE-2019-12173": {"epss_score": 0.03141, "epss_percentile": 0.86486}, "CVE-2019-12174": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2019-12175": {"epss_score": 0.00329, "epss_percentile": 0.55323}, "CVE-2019-12176": {"epss_score": 0.00034, "epss_percentile": 0.09558}, "CVE-2019-12177": {"epss_score": 0.00106, "epss_percentile": 0.2954}, "CVE-2019-12180": {"epss_score": 0.08951, "epss_percentile": 0.92334}, "CVE-2019-12181": {"epss_score": 0.52558, "epss_percentile": 0.97831}, "CVE-2019-12182": {"epss_score": 0.11789, "epss_percentile": 0.93477}, "CVE-2019-12183": {"epss_score": 0.00687, "epss_percentile": 0.71175}, "CVE-2019-12184": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-12185": {"epss_score": 0.26432, "epss_percentile": 0.96147}, "CVE-2019-12186": {"epss_score": 0.00351, "epss_percentile": 0.57077}, "CVE-2019-12189": {"epss_score": 0.04978, "epss_percentile": 0.89357}, "CVE-2019-12190": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-12193": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-12195": {"epss_score": 0.00303, "epss_percentile": 0.53228}, "CVE-2019-12196": {"epss_score": 0.24096, "epss_percentile": 0.95869}, "CVE-2019-12198": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2019-12203": {"epss_score": 0.00054, "epss_percentile": 0.17113}, "CVE-2019-12204": {"epss_score": 0.00832, "epss_percentile": 0.74062}, "CVE-2019-12205": {"epss_score": 0.0045, "epss_percentile": 0.631}, "CVE-2019-12206": {"epss_score": 0.004, "epss_percentile": 0.60187}, "CVE-2019-12207": {"epss_score": 0.00439, "epss_percentile": 0.62588}, "CVE-2019-12208": {"epss_score": 0.00465, "epss_percentile": 0.63758}, "CVE-2019-12209": {"epss_score": 0.00629, "epss_percentile": 0.69671}, "CVE-2019-12210": {"epss_score": 0.00359, "epss_percentile": 0.57566}, "CVE-2019-12211": {"epss_score": 0.01052, "epss_percentile": 0.77096}, "CVE-2019-12212": {"epss_score": 0.0065, "epss_percentile": 0.70268}, "CVE-2019-12213": {"epss_score": 0.00337, "epss_percentile": 0.56053}, "CVE-2019-12214": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-12215": {"epss_score": 0.00226, "epss_percentile": 0.45287}, "CVE-2019-12216": {"epss_score": 0.01121, "epss_percentile": 0.7777}, "CVE-2019-12217": {"epss_score": 0.00627, "epss_percentile": 0.69624}, "CVE-2019-12218": {"epss_score": 0.00749, "epss_percentile": 0.72603}, "CVE-2019-12219": {"epss_score": 0.0065, "epss_percentile": 0.70272}, "CVE-2019-12220": {"epss_score": 0.00778, "epss_percentile": 0.73133}, "CVE-2019-12221": {"epss_score": 0.02112, "epss_percentile": 0.83649}, "CVE-2019-12222": {"epss_score": 0.00747, "epss_percentile": 0.72561}, "CVE-2019-12223": {"epss_score": 0.0053, "epss_percentile": 0.66621}, "CVE-2019-12239": {"epss_score": 0.00128, "epss_percentile": 0.32943}, "CVE-2019-12240": {"epss_score": 0.00798, "epss_percentile": 0.73516}, "CVE-2019-12241": {"epss_score": 0.00786, "epss_percentile": 0.73299}, "CVE-2019-12243": {"epss_score": 0.00122, "epss_percentile": 0.32063}, "CVE-2019-12245": {"epss_score": 0.00255, "epss_percentile": 0.48637}, "CVE-2019-12246": {"epss_score": 0.00156, "epss_percentile": 0.3688}, "CVE-2019-12247": {"epss_score": 0.00528, "epss_percentile": 0.66546}, "CVE-2019-12248": {"epss_score": 0.00681, "epss_percentile": 0.71043}, "CVE-2019-12250": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-12251": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2019-12252": {"epss_score": 0.07166, "epss_percentile": 0.91295}, "CVE-2019-12253": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2019-12254": {"epss_score": 0.00812, "epss_percentile": 0.73743}, "CVE-2019-12255": {"epss_score": 0.80153, "epss_percentile": 0.99073}, "CVE-2019-12256": {"epss_score": 0.13843, "epss_percentile": 0.94074}, "CVE-2019-12257": {"epss_score": 0.15499, "epss_percentile": 0.94439}, "CVE-2019-12258": {"epss_score": 0.07932, "epss_percentile": 0.91768}, "CVE-2019-12259": {"epss_score": 0.24457, "epss_percentile": 0.95924}, "CVE-2019-12260": {"epss_score": 0.25599, "epss_percentile": 0.96048}, "CVE-2019-12261": {"epss_score": 0.22314, "epss_percentile": 0.95622}, "CVE-2019-12262": {"epss_score": 0.00163, "epss_percentile": 0.37767}, "CVE-2019-12263": {"epss_score": 0.00547, "epss_percentile": 0.6723}, "CVE-2019-12264": {"epss_score": 0.00055, "epss_percentile": 0.17543}, "CVE-2019-12265": {"epss_score": 0.1287, "epss_percentile": 0.93806}, "CVE-2019-12266": {"epss_score": 0.00471, "epss_percentile": 0.64018}, "CVE-2019-12269": {"epss_score": 0.00284, "epss_percentile": 0.51492}, "CVE-2019-12270": {"epss_score": 0.00173, "epss_percentile": 0.39129}, "CVE-2019-12271": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-12272": {"epss_score": 0.37652, "epss_percentile": 0.97062}, "CVE-2019-12273": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2019-12274": {"epss_score": 0.00191, "epss_percentile": 0.41173}, "CVE-2019-12276": {"epss_score": 0.91643, "epss_percentile": 0.9966}, "CVE-2019-12277": {"epss_score": 0.00657, "epss_percentile": 0.70456}, "CVE-2019-12278": {"epss_score": 0.00351, "epss_percentile": 0.57031}, "CVE-2019-12279": {"epss_score": 0.21399, "epss_percentile": 0.95512}, "CVE-2019-12280": {"epss_score": 0.0073, "epss_percentile": 0.72161}, "CVE-2019-12288": {"epss_score": 0.00336, "epss_percentile": 0.56007}, "CVE-2019-12289": {"epss_score": 0.0059, "epss_percentile": 0.68551}, "CVE-2019-12290": {"epss_score": 0.02528, "epss_percentile": 0.85019}, "CVE-2019-12291": {"epss_score": 0.0042, "epss_percentile": 0.61439}, "CVE-2019-12292": {"epss_score": 0.0064, "epss_percentile": 0.69973}, "CVE-2019-12293": {"epss_score": 0.00713, "epss_percentile": 0.71798}, "CVE-2019-12295": {"epss_score": 0.025, "epss_percentile": 0.84915}, "CVE-2019-12297": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-12298": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2019-12299": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-12300": {"epss_score": 0.00499, "epss_percentile": 0.65255}, "CVE-2019-12301": {"epss_score": 0.00295, "epss_percentile": 0.52445}, "CVE-2019-12303": {"epss_score": 0.00732, "epss_percentile": 0.72185}, "CVE-2019-12305": {"epss_score": 0.00096, "epss_percentile": 0.27413}, "CVE-2019-12308": {"epss_score": 0.01482, "epss_percentile": 0.80575}, "CVE-2019-12309": {"epss_score": 0.00329, "epss_percentile": 0.55386}, "CVE-2019-12310": {"epss_score": 0.0049, "epss_percentile": 0.6492}, "CVE-2019-12311": {"epss_score": 0.00278, "epss_percentile": 0.50886}, "CVE-2019-12312": {"epss_score": 0.00542, "epss_percentile": 0.67079}, "CVE-2019-12313": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2019-12314": {"epss_score": 0.89957, "epss_percentile": 0.99552}, "CVE-2019-12315": {"epss_score": 0.00287, "epss_percentile": 0.51834}, "CVE-2019-12323": {"epss_score": 0.17253, "epss_percentile": 0.94809}, "CVE-2019-12324": {"epss_score": 0.14483, "epss_percentile": 0.94221}, "CVE-2019-12325": {"epss_score": 0.01844, "epss_percentile": 0.82505}, "CVE-2019-12326": {"epss_score": 0.01565, "epss_percentile": 0.81065}, "CVE-2019-12327": {"epss_score": 0.00825, "epss_percentile": 0.73946}, "CVE-2019-12328": {"epss_score": 0.06221, "epss_percentile": 0.90579}, "CVE-2019-12331": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2019-12345": {"epss_score": 0.00468, "epss_percentile": 0.63873}, "CVE-2019-12346": {"epss_score": 0.00141, "epss_percentile": 0.34926}, "CVE-2019-12347": {"epss_score": 0.75529, "epss_percentile": 0.98851}, "CVE-2019-12348": {"epss_score": 0.00402, "epss_percentile": 0.60291}, "CVE-2019-12349": {"epss_score": 0.00374, "epss_percentile": 0.58548}, "CVE-2019-12350": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2019-12351": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2019-12352": {"epss_score": 0.00239, "epss_percentile": 0.46936}, "CVE-2019-12353": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2019-12354": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2019-12355": {"epss_score": 0.00239, "epss_percentile": 0.46936}, "CVE-2019-12356": {"epss_score": 0.00279, "epss_percentile": 0.50967}, "CVE-2019-12357": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2019-12358": {"epss_score": 0.00239, "epss_percentile": 0.46936}, "CVE-2019-12359": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2019-12360": {"epss_score": 0.00358, "epss_percentile": 0.57518}, "CVE-2019-12361": {"epss_score": 0.00113, "epss_percentile": 0.30583}, "CVE-2019-12362": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-12363": {"epss_score": 0.00083, "epss_percentile": 0.24737}, "CVE-2019-12365": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2019-12366": {"epss_score": 0.00528, "epss_percentile": 0.66542}, "CVE-2019-12367": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2019-12368": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2019-12369": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2019-12370": {"epss_score": 0.00527, "epss_percentile": 0.66439}, "CVE-2019-12372": {"epss_score": 0.0026, "epss_percentile": 0.4923}, "CVE-2019-12373": {"epss_score": 0.00058, "epss_percentile": 0.18276}, "CVE-2019-12374": {"epss_score": 0.00657, "epss_percentile": 0.70474}, "CVE-2019-12375": {"epss_score": 0.00244, "epss_percentile": 0.47555}, "CVE-2019-12376": {"epss_score": 0.00027, "epss_percentile": 0.07085}, "CVE-2019-12377": {"epss_score": 0.08261, "epss_percentile": 0.91956}, "CVE-2019-12378": {"epss_score": 0.00117, "epss_percentile": 0.31282}, "CVE-2019-12379": {"epss_score": 0.00062, "epss_percentile": 0.19789}, "CVE-2019-12380": {"epss_score": 0.00052, "epss_percentile": 0.16595}, "CVE-2019-12381": {"epss_score": 0.00089, "epss_percentile": 0.2593}, "CVE-2019-12382": {"epss_score": 0.0012, "epss_percentile": 0.31768}, "CVE-2019-12383": {"epss_score": 0.00736, "epss_percentile": 0.72316}, "CVE-2019-12384": {"epss_score": 0.51675, "epss_percentile": 0.97793}, "CVE-2019-12385": {"epss_score": 0.00703, "epss_percentile": 0.71526}, "CVE-2019-12386": {"epss_score": 0.00251, "epss_percentile": 0.48304}, "CVE-2019-12387": {"epss_score": 0.00531, "epss_percentile": 0.6665}, "CVE-2019-12388": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2019-12389": {"epss_score": 0.00542, "epss_percentile": 0.67071}, "CVE-2019-12390": {"epss_score": 0.00423, "epss_percentile": 0.61635}, "CVE-2019-12391": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2019-12392": {"epss_score": 0.00704, "epss_percentile": 0.71567}, "CVE-2019-12393": {"epss_score": 0.00288, "epss_percentile": 0.5193}, "CVE-2019-12394": {"epss_score": 0.00904, "epss_percentile": 0.75213}, "CVE-2019-12395": {"epss_score": 0.00325, "epss_percentile": 0.55004}, "CVE-2019-12397": {"epss_score": 0.01756, "epss_percentile": 0.8213}, "CVE-2019-12398": {"epss_score": 0.0067, "epss_percentile": 0.70782}, "CVE-2019-12399": {"epss_score": 0.02307, "epss_percentile": 0.84328}, "CVE-2019-12400": {"epss_score": 0.00587, "epss_percentile": 0.6847}, "CVE-2019-12401": {"epss_score": 0.28199, "epss_percentile": 0.96331}, "CVE-2019-12402": {"epss_score": 0.00382, "epss_percentile": 0.59075}, "CVE-2019-12404": {"epss_score": 0.05213, "epss_percentile": 0.89618}, "CVE-2019-12405": {"epss_score": 0.01172, "epss_percentile": 0.78228}, "CVE-2019-12406": {"epss_score": 0.04835, "epss_percentile": 0.89194}, "CVE-2019-12407": {"epss_score": 0.05213, "epss_percentile": 0.89618}, "CVE-2019-12408": {"epss_score": 0.04462, "epss_percentile": 0.88726}, "CVE-2019-12409": {"epss_score": 0.8277, "epss_percentile": 0.99214}, "CVE-2019-12410": {"epss_score": 0.05281, "epss_percentile": 0.89688}, "CVE-2019-12412": {"epss_score": 0.02448, "epss_percentile": 0.84773}, "CVE-2019-12413": {"epss_score": 0.0067, "epss_percentile": 0.70771}, "CVE-2019-12414": {"epss_score": 0.00145, "epss_percentile": 0.35415}, "CVE-2019-12415": {"epss_score": 0.00022, "epss_percentile": 0.05325}, "CVE-2019-12416": {"epss_score": 0.00859, "epss_percentile": 0.74516}, "CVE-2019-12417": {"epss_score": 0.00745, "epss_percentile": 0.72524}, "CVE-2019-12418": {"epss_score": 0.00642, "epss_percentile": 0.70029}, "CVE-2019-12419": {"epss_score": 0.17995, "epss_percentile": 0.9494}, "CVE-2019-12420": {"epss_score": 0.13675, "epss_percentile": 0.94032}, "CVE-2019-12421": {"epss_score": 0.00316, "epss_percentile": 0.54298}, "CVE-2019-12422": {"epss_score": 0.56421, "epss_percentile": 0.98021}, "CVE-2019-12423": {"epss_score": 0.01164, "epss_percentile": 0.78169}, "CVE-2019-12425": {"epss_score": 0.02178, "epss_percentile": 0.83891}, "CVE-2019-12426": {"epss_score": 0.0302, "epss_percentile": 0.86223}, "CVE-2019-12427": {"epss_score": 0.00998, "epss_percentile": 0.76466}, "CVE-2019-12428": {"epss_score": 0.002, "epss_percentile": 0.42228}, "CVE-2019-12429": {"epss_score": 0.00075, "epss_percentile": 0.22944}, "CVE-2019-12430": {"epss_score": 0.03738, "epss_percentile": 0.87652}, "CVE-2019-12431": {"epss_score": 0.00069, "epss_percentile": 0.21506}, "CVE-2019-12432": {"epss_score": 0.00069, "epss_percentile": 0.21506}, "CVE-2019-12433": {"epss_score": 0.00073, "epss_percentile": 0.22531}, "CVE-2019-12434": {"epss_score": 0.00069, "epss_percentile": 0.21506}, "CVE-2019-12435": {"epss_score": 0.06371, "epss_percentile": 0.90705}, "CVE-2019-12436": {"epss_score": 0.0437, "epss_percentile": 0.88608}, "CVE-2019-12437": {"epss_score": 0.002, "epss_percentile": 0.42253}, "CVE-2019-12439": {"epss_score": 0.00153, "epss_percentile": 0.36613}, "CVE-2019-12440": {"epss_score": 0.00674, "epss_percentile": 0.70883}, "CVE-2019-12441": {"epss_score": 0.00068, "epss_percentile": 0.21424}, "CVE-2019-12442": {"epss_score": 0.001, "epss_percentile": 0.28555}, "CVE-2019-12443": {"epss_score": 0.00136, "epss_percentile": 0.34195}, "CVE-2019-12444": {"epss_score": 0.001, "epss_percentile": 0.28555}, "CVE-2019-12445": {"epss_score": 0.00092, "epss_percentile": 0.26557}, "CVE-2019-12446": {"epss_score": 0.00077, "epss_percentile": 0.23384}, "CVE-2019-12447": {"epss_score": 0.00598, "epss_percentile": 0.68766}, "CVE-2019-12448": {"epss_score": 0.00513, "epss_percentile": 0.65926}, "CVE-2019-12449": {"epss_score": 0.00598, "epss_percentile": 0.68766}, "CVE-2019-12450": {"epss_score": 0.00941, "epss_percentile": 0.75757}, "CVE-2019-12452": {"epss_score": 0.00345, "epss_percentile": 0.56584}, "CVE-2019-12453": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2019-12454": {"epss_score": 0.00084, "epss_percentile": 0.25021}, "CVE-2019-12455": {"epss_score": 0.00066, "epss_percentile": 0.20817}, "CVE-2019-12456": {"epss_score": 0.00077, "epss_percentile": 0.2329}, "CVE-2019-12457": {"epss_score": 0.0035, "epss_percentile": 0.56957}, "CVE-2019-12458": {"epss_score": 0.0035, "epss_percentile": 0.56957}, "CVE-2019-12459": {"epss_score": 0.0035, "epss_percentile": 0.56957}, "CVE-2019-12460": {"epss_score": 0.05282, "epss_percentile": 0.8969}, "CVE-2019-12461": {"epss_score": 0.55026, "epss_percentile": 0.97957}, "CVE-2019-12463": {"epss_score": 5e-05, "epss_percentile": 0.00222}, "CVE-2019-12464": {"epss_score": 8e-05, "epss_percentile": 0.0048}, "CVE-2019-12465": {"epss_score": 6e-05, "epss_percentile": 0.00274}, "CVE-2019-12466": {"epss_score": 0.0018, "epss_percentile": 0.39892}, "CVE-2019-12467": {"epss_score": 0.00298, "epss_percentile": 0.52817}, "CVE-2019-12468": {"epss_score": 0.00519, "epss_percentile": 0.66142}, "CVE-2019-12469": {"epss_score": 0.00153, "epss_percentile": 0.36635}, "CVE-2019-12470": {"epss_score": 0.00168, "epss_percentile": 0.38459}, "CVE-2019-12471": {"epss_score": 0.00359, "epss_percentile": 0.57553}, "CVE-2019-12472": {"epss_score": 0.00151, "epss_percentile": 0.36357}, "CVE-2019-12473": {"epss_score": 0.00469, "epss_percentile": 0.63955}, "CVE-2019-12474": {"epss_score": 0.00261, "epss_percentile": 0.49251}, "CVE-2019-12475": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2019-12476": {"epss_score": 0.01223, "epss_percentile": 0.78666}, "CVE-2019-12477": {"epss_score": 0.33135, "epss_percentile": 0.96749}, "CVE-2019-12479": {"epss_score": 0.00503, "epss_percentile": 0.65468}, "CVE-2019-12480": {"epss_score": 0.22508, "epss_percentile": 0.95646}, "CVE-2019-12481": {"epss_score": 0.00272, "epss_percentile": 0.50378}, "CVE-2019-12482": {"epss_score": 0.00552, "epss_percentile": 0.67401}, "CVE-2019-12483": {"epss_score": 0.00263, "epss_percentile": 0.49512}, "CVE-2019-12489": {"epss_score": 0.11489, "epss_percentile": 0.93382}, "CVE-2019-12490": {"epss_score": 0.00362, "epss_percentile": 0.57774}, "CVE-2019-12491": {"epss_score": 0.00295, "epss_percentile": 0.52441}, "CVE-2019-12492": {"epss_score": 0.00207, "epss_percentile": 0.43185}, "CVE-2019-12493": {"epss_score": 0.00301, "epss_percentile": 0.53048}, "CVE-2019-12494": {"epss_score": 0.00314, "epss_percentile": 0.54091}, "CVE-2019-12495": {"epss_score": 0.00198, "epss_percentile": 0.41992}, "CVE-2019-12496": {"epss_score": 0.00212, "epss_percentile": 0.43816}, "CVE-2019-12497": {"epss_score": 0.00682, "epss_percentile": 0.71086}, "CVE-2019-12498": {"epss_score": 0.00843, "epss_percentile": 0.74268}, "CVE-2019-12499": {"epss_score": 0.01367, "epss_percentile": 0.79782}, "CVE-2019-12500": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2019-12502": {"epss_score": 0.00185, "epss_percentile": 0.40466}, "CVE-2019-12503": {"epss_score": 0.00343, "epss_percentile": 0.56432}, "CVE-2019-12504": {"epss_score": 0.00582, "epss_percentile": 0.68287}, "CVE-2019-12505": {"epss_score": 0.0052, "epss_percentile": 0.66191}, "CVE-2019-12506": {"epss_score": 0.00624, "epss_percentile": 0.69569}, "CVE-2019-12507": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-12510": {"epss_score": 0.00071, "epss_percentile": 0.21997}, "CVE-2019-12511": {"epss_score": 0.00431, "epss_percentile": 0.62038}, "CVE-2019-12512": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-12513": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-12515": {"epss_score": 0.00296, "epss_percentile": 0.52602}, "CVE-2019-12516": {"epss_score": 0.00464, "epss_percentile": 0.63708}, "CVE-2019-12517": {"epss_score": 0.00878, "epss_percentile": 0.74817}, "CVE-2019-12518": {"epss_score": 0.74844, "epss_percentile": 0.9882}, "CVE-2019-12519": {"epss_score": 0.07536, "epss_percentile": 0.91523}, "CVE-2019-12520": {"epss_score": 0.06184, "epss_percentile": 0.9054}, "CVE-2019-12521": {"epss_score": 0.00565, "epss_percentile": 0.67797}, "CVE-2019-12522": {"epss_score": 0.0018, "epss_percentile": 0.39925}, "CVE-2019-12523": {"epss_score": 0.00557, "epss_percentile": 0.67559}, "CVE-2019-12524": {"epss_score": 0.00549, "epss_percentile": 0.67305}, "CVE-2019-12525": {"epss_score": 0.55249, "epss_percentile": 0.97967}, "CVE-2019-12526": {"epss_score": 0.33643, "epss_percentile": 0.96789}, "CVE-2019-12527": {"epss_score": 0.12361, "epss_percentile": 0.9365}, "CVE-2019-12528": {"epss_score": 0.20521, "epss_percentile": 0.95364}, "CVE-2019-12529": {"epss_score": 0.16208, "epss_percentile": 0.94594}, "CVE-2019-12530": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2019-12532": {"epss_score": 0.00066, "epss_percentile": 0.20752}, "CVE-2019-12537": {"epss_score": 0.0157, "epss_percentile": 0.81083}, "CVE-2019-12538": {"epss_score": 0.01693, "epss_percentile": 0.81793}, "CVE-2019-12539": {"epss_score": 0.03144, "epss_percentile": 0.86492}, "CVE-2019-12540": {"epss_score": 0.02685, "epss_percentile": 0.85425}, "CVE-2019-12541": {"epss_score": 0.01693, "epss_percentile": 0.81793}, "CVE-2019-12542": {"epss_score": 0.01693, "epss_percentile": 0.81793}, "CVE-2019-12543": {"epss_score": 0.01693, "epss_percentile": 0.81793}, "CVE-2019-12548": {"epss_score": 0.02293, "epss_percentile": 0.84288}, "CVE-2019-12549": {"epss_score": 0.0084, "epss_percentile": 0.74206}, "CVE-2019-12550": {"epss_score": 0.00581, "epss_percentile": 0.68269}, "CVE-2019-12551": {"epss_score": 0.00591, "epss_percentile": 0.68583}, "CVE-2019-12552": {"epss_score": 0.00231, "epss_percentile": 0.45856}, "CVE-2019-12553": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2019-12554": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2019-12555": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2019-12562": {"epss_score": 0.38668, "epss_percentile": 0.97113}, "CVE-2019-12564": {"epss_score": 0.00381, "epss_percentile": 0.59007}, "CVE-2019-12566": {"epss_score": 0.00331, "epss_percentile": 0.55508}, "CVE-2019-12567": {"epss_score": 0.02739, "epss_percentile": 0.85556}, "CVE-2019-12568": {"epss_score": 0.02739, "epss_percentile": 0.85556}, "CVE-2019-12569": {"epss_score": 0.0322, "epss_percentile": 0.86673}, "CVE-2019-12570": {"epss_score": 0.01202, "epss_percentile": 0.78487}, "CVE-2019-12571": {"epss_score": 0.00032, "epss_percentile": 0.09011}, "CVE-2019-12572": {"epss_score": 0.00151, "epss_percentile": 0.36333}, "CVE-2019-12573": {"epss_score": 0.00032, "epss_percentile": 0.09011}, "CVE-2019-12574": {"epss_score": 0.00423, "epss_percentile": 0.61591}, "CVE-2019-12575": {"epss_score": 0.00051, "epss_percentile": 0.15991}, "CVE-2019-12576": {"epss_score": 0.00054, "epss_percentile": 0.17315}, "CVE-2019-12577": {"epss_score": 0.00036, "epss_percentile": 0.10423}, "CVE-2019-12578": {"epss_score": 0.00085, "epss_percentile": 0.2524}, "CVE-2019-12579": {"epss_score": 0.00085, "epss_percentile": 0.2524}, "CVE-2019-12581": {"epss_score": 0.55651, "epss_percentile": 0.97988}, "CVE-2019-12583": {"epss_score": 0.59063, "epss_percentile": 0.98147}, "CVE-2019-12584": {"epss_score": 0.04715, "epss_percentile": 0.89042}, "CVE-2019-12585": {"epss_score": 0.11683, "epss_percentile": 0.93445}, "CVE-2019-12586": {"epss_score": 0.03703, "epss_percentile": 0.87593}, "CVE-2019-12587": {"epss_score": 0.00102, "epss_percentile": 0.28738}, "CVE-2019-12588": {"epss_score": 0.00206, "epss_percentile": 0.42928}, "CVE-2019-12589": {"epss_score": 0.00079, "epss_percentile": 0.23995}, "CVE-2019-12591": {"epss_score": 0.00801, "epss_percentile": 0.7356}, "CVE-2019-12592": {"epss_score": 0.00286, "epss_percentile": 0.51694}, "CVE-2019-12593": {"epss_score": 0.75083, "epss_percentile": 0.9883}, "CVE-2019-12594": {"epss_score": 0.28038, "epss_percentile": 0.96303}, "CVE-2019-12595": {"epss_score": 0.0157, "epss_percentile": 0.81083}, "CVE-2019-12596": {"epss_score": 0.0157, "epss_percentile": 0.81083}, "CVE-2019-12597": {"epss_score": 0.0157, "epss_percentile": 0.81083}, "CVE-2019-12598": {"epss_score": 0.00348, "epss_percentile": 0.56834}, "CVE-2019-12599": {"epss_score": 0.00348, "epss_percentile": 0.56834}, "CVE-2019-12600": {"epss_score": 0.00348, "epss_percentile": 0.56834}, "CVE-2019-12601": {"epss_score": 0.00348, "epss_percentile": 0.56834}, "CVE-2019-12611": {"epss_score": 0.0008, "epss_percentile": 0.24184}, "CVE-2019-12612": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2019-12614": {"epss_score": 0.00086, "epss_percentile": 0.25342}, "CVE-2019-12615": {"epss_score": 0.01098, "epss_percentile": 0.77544}, "CVE-2019-12616": {"epss_score": 0.55745, "epss_percentile": 0.97993}, "CVE-2019-12617": {"epss_score": 0.00304, "epss_percentile": 0.53264}, "CVE-2019-12618": {"epss_score": 0.00703, "epss_percentile": 0.71545}, "CVE-2019-12619": {"epss_score": 0.00264, "epss_percentile": 0.49678}, "CVE-2019-12620": {"epss_score": 0.00233, "epss_percentile": 0.46061}, "CVE-2019-12621": {"epss_score": 0.00076, "epss_percentile": 0.23119}, "CVE-2019-12622": {"epss_score": 0.00055, "epss_percentile": 0.17488}, "CVE-2019-12623": {"epss_score": 0.00147, "epss_percentile": 0.35692}, "CVE-2019-12624": {"epss_score": 0.02811, "epss_percentile": 0.85722}, "CVE-2019-12625": {"epss_score": 0.01801, "epss_percentile": 0.82326}, "CVE-2019-12626": {"epss_score": 0.0017, "epss_percentile": 0.38656}, "CVE-2019-12627": {"epss_score": 0.00524, "epss_percentile": 0.66365}, "CVE-2019-12629": {"epss_score": 0.00743, "epss_percentile": 0.72496}, "CVE-2019-12630": {"epss_score": 0.32488, "epss_percentile": 0.96705}, "CVE-2019-12631": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2019-12632": {"epss_score": 0.00565, "epss_percentile": 0.67801}, "CVE-2019-12633": {"epss_score": 0.00514, "epss_percentile": 0.65956}, "CVE-2019-12634": {"epss_score": 0.02327, "epss_percentile": 0.84392}, "CVE-2019-12635": {"epss_score": 0.00095, "epss_percentile": 0.27181}, "CVE-2019-12636": {"epss_score": 0.005, "epss_percentile": 0.65306}, "CVE-2019-12637": {"epss_score": 0.00287, "epss_percentile": 0.51802}, "CVE-2019-12638": {"epss_score": 0.00287, "epss_percentile": 0.51802}, "CVE-2019-12643": {"epss_score": 0.19631, "epss_percentile": 0.95217}, "CVE-2019-12644": {"epss_score": 0.00307, "epss_percentile": 0.53491}, "CVE-2019-12645": {"epss_score": 0.00034, "epss_percentile": 0.09571}, "CVE-2019-12646": {"epss_score": 0.01033, "epss_percentile": 0.7687}, "CVE-2019-12647": {"epss_score": 0.0116, "epss_percentile": 0.78133}, "CVE-2019-12648": {"epss_score": 0.0111, "epss_percentile": 0.77659}, "CVE-2019-12649": {"epss_score": 0.00026, "epss_percentile": 0.06474}, "CVE-2019-12650": {"epss_score": 0.13421, "epss_percentile": 0.93959}, "CVE-2019-12651": {"epss_score": 0.26917, "epss_percentile": 0.96192}, "CVE-2019-12652": {"epss_score": 0.03181, "epss_percentile": 0.8658}, "CVE-2019-12653": {"epss_score": 0.00806, "epss_percentile": 0.73658}, "CVE-2019-12654": {"epss_score": 0.0116, "epss_percentile": 0.78133}, "CVE-2019-12655": {"epss_score": 0.01251, "epss_percentile": 0.78896}, "CVE-2019-12656": {"epss_score": 0.01474, "epss_percentile": 0.80521}, "CVE-2019-12657": {"epss_score": 0.01447, "epss_percentile": 0.80333}, "CVE-2019-12658": {"epss_score": 0.01033, "epss_percentile": 0.7687}, "CVE-2019-12659": {"epss_score": 0.00521, "epss_percentile": 0.66229}, "CVE-2019-12660": {"epss_score": 0.00066, "epss_percentile": 0.2086}, "CVE-2019-12661": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2019-12662": {"epss_score": 0.00033, "epss_percentile": 0.09176}, "CVE-2019-12663": {"epss_score": 0.00265, "epss_percentile": 0.4982}, "CVE-2019-12664": {"epss_score": 0.00682, "epss_percentile": 0.71075}, "CVE-2019-12665": {"epss_score": 0.00288, "epss_percentile": 0.51866}, "CVE-2019-12666": {"epss_score": 0.00016, "epss_percentile": 0.02811}, "CVE-2019-12667": {"epss_score": 0.00159, "epss_percentile": 0.37321}, "CVE-2019-12668": {"epss_score": 0.00182, "epss_percentile": 0.40233}, "CVE-2019-12669": {"epss_score": 0.00459, "epss_percentile": 0.63456}, "CVE-2019-12670": {"epss_score": 0.00034, "epss_percentile": 0.09548}, "CVE-2019-12671": {"epss_score": 0.00071, "epss_percentile": 0.2213}, "CVE-2019-12672": {"epss_score": 0.00037, "epss_percentile": 0.10957}, "CVE-2019-12673": {"epss_score": 0.00641, "epss_percentile": 0.69988}, "CVE-2019-12674": {"epss_score": 0.00028, "epss_percentile": 0.07309}, "CVE-2019-12675": {"epss_score": 0.00032, "epss_percentile": 0.09073}, "CVE-2019-12676": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2019-12677": {"epss_score": 0.00515, "epss_percentile": 0.66005}, "CVE-2019-12678": {"epss_score": 0.00915, "epss_percentile": 0.75399}, "CVE-2019-12679": {"epss_score": 0.00897, "epss_percentile": 0.75139}, "CVE-2019-12680": {"epss_score": 0.00897, "epss_percentile": 0.75139}, "CVE-2019-12681": {"epss_score": 0.00897, "epss_percentile": 0.75139}, "CVE-2019-12682": {"epss_score": 0.00897, "epss_percentile": 0.75139}, "CVE-2019-12683": {"epss_score": 0.00897, "epss_percentile": 0.75139}, "CVE-2019-12684": {"epss_score": 0.00897, "epss_percentile": 0.75139}, "CVE-2019-12685": {"epss_score": 0.00897, "epss_percentile": 0.75139}, "CVE-2019-12686": {"epss_score": 0.00897, "epss_percentile": 0.75139}, "CVE-2019-12687": {"epss_score": 0.01126, "epss_percentile": 0.77815}, "CVE-2019-12688": {"epss_score": 0.01126, "epss_percentile": 0.77815}, "CVE-2019-12689": {"epss_score": 0.0164, "epss_percentile": 0.81502}, "CVE-2019-12690": {"epss_score": 0.00958, "epss_percentile": 0.75948}, "CVE-2019-12691": {"epss_score": 0.00062, "epss_percentile": 0.19661}, "CVE-2019-12693": {"epss_score": 0.00359, "epss_percentile": 0.57596}, "CVE-2019-12694": {"epss_score": 0.00025, "epss_percentile": 0.06061}, "CVE-2019-12695": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2019-12696": {"epss_score": 0.00279, "epss_percentile": 0.50973}, "CVE-2019-12697": {"epss_score": 0.00279, "epss_percentile": 0.50973}, "CVE-2019-12698": {"epss_score": 0.00517, "epss_percentile": 0.66065}, "CVE-2019-12699": {"epss_score": 0.00174, "epss_percentile": 0.39217}, "CVE-2019-12700": {"epss_score": 0.0135, "epss_percentile": 0.79677}, "CVE-2019-12701": {"epss_score": 0.00088, "epss_percentile": 0.25735}, "CVE-2019-12702": {"epss_score": 0.00287, "epss_percentile": 0.51802}, "CVE-2019-12703": {"epss_score": 0.00158, "epss_percentile": 0.37197}, "CVE-2019-12704": {"epss_score": 0.0028, "epss_percentile": 0.51007}, "CVE-2019-12705": {"epss_score": 0.00319, "epss_percentile": 0.54468}, "CVE-2019-12706": {"epss_score": 0.00386, "epss_percentile": 0.59243}, "CVE-2019-12707": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2019-12708": {"epss_score": 0.00483, "epss_percentile": 0.64593}, "CVE-2019-12709": {"epss_score": 0.00045, "epss_percentile": 0.13821}, "CVE-2019-12710": {"epss_score": 0.00214, "epss_percentile": 0.43997}, "CVE-2019-12711": {"epss_score": 0.00507, "epss_percentile": 0.65664}, "CVE-2019-12712": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2019-12713": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2019-12714": {"epss_score": 0.00365, "epss_percentile": 0.58001}, "CVE-2019-12715": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2019-12716": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2019-12717": {"epss_score": 0.00125, "epss_percentile": 0.32533}, "CVE-2019-12718": {"epss_score": 0.00319, "epss_percentile": 0.54468}, "CVE-2019-12719": {"epss_score": 0.00632, "epss_percentile": 0.6974}, "CVE-2019-12720": {"epss_score": 0.00325, "epss_percentile": 0.55029}, "CVE-2019-12723": {"epss_score": 0.00769, "epss_percentile": 0.72993}, "CVE-2019-12724": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2019-12725": {"epss_score": 0.94144, "epss_percentile": 0.99908}, "CVE-2019-12727": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2019-12728": {"epss_score": 0.00151, "epss_percentile": 0.36262}, "CVE-2019-12730": {"epss_score": 0.01704, "epss_percentile": 0.81845}, "CVE-2019-12731": {"epss_score": 0.00035, "epss_percentile": 0.10054}, "CVE-2019-12732": {"epss_score": 0.00247, "epss_percentile": 0.47854}, "CVE-2019-12733": {"epss_score": 0.17379, "epss_percentile": 0.94842}, "CVE-2019-12734": {"epss_score": 0.00496, "epss_percentile": 0.65174}, "CVE-2019-12735": {"epss_score": 0.66838, "epss_percentile": 0.98484}, "CVE-2019-12736": {"epss_score": 0.00027, "epss_percentile": 0.06879}, "CVE-2019-12737": {"epss_score": 2e-05, "epss_percentile": 0.00034}, "CVE-2019-12739": {"epss_score": 0.01409, "epss_percentile": 0.80068}, "CVE-2019-12741": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2019-12742": {"epss_score": 0.00284, "epss_percentile": 0.51432}, "CVE-2019-12743": {"epss_score": 0.00244, "epss_percentile": 0.47619}, "CVE-2019-12744": {"epss_score": 0.30988, "epss_percentile": 0.96579}, "CVE-2019-12745": {"epss_score": 0.00276, "epss_percentile": 0.50709}, "CVE-2019-12746": {"epss_score": 0.00535, "epss_percentile": 0.6684}, "CVE-2019-12747": {"epss_score": 0.01559, "epss_percentile": 0.81032}, "CVE-2019-12748": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2019-12749": {"epss_score": 0.00043, "epss_percentile": 0.13063}, "CVE-2019-12750": {"epss_score": 0.00777, "epss_percentile": 0.73112}, "CVE-2019-12751": {"epss_score": 0.00757, "epss_percentile": 0.72753}, "CVE-2019-12752": {"epss_score": 0.00103, "epss_percentile": 0.29046}, "CVE-2019-12753": {"epss_score": 0.00333, "epss_percentile": 0.55618}, "CVE-2019-12754": {"epss_score": 0.00405, "epss_percentile": 0.60458}, "CVE-2019-12755": {"epss_score": 0.00075, "epss_percentile": 0.22893}, "CVE-2019-12756": {"epss_score": 0.00066, "epss_percentile": 0.20881}, "CVE-2019-12757": {"epss_score": 0.00072, "epss_percentile": 0.22272}, "CVE-2019-12758": {"epss_score": 0.00079, "epss_percentile": 0.23956}, "CVE-2019-12759": {"epss_score": 0.00055, "epss_percentile": 0.17552}, "CVE-2019-12760": {"epss_score": 0.0067, "epss_percentile": 0.70777}, "CVE-2019-12761": {"epss_score": 0.00645, "epss_percentile": 0.70116}, "CVE-2019-12762": {"epss_score": 0.00023, "epss_percentile": 0.0539}, "CVE-2019-12763": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-12764": {"epss_score": 0.00022, "epss_percentile": 0.05146}, "CVE-2019-12765": {"epss_score": 0.30929, "epss_percentile": 0.96576}, "CVE-2019-12766": {"epss_score": 0.00063, "epss_percentile": 0.19985}, "CVE-2019-12767": {"epss_score": 0.00941, "epss_percentile": 0.75743}, "CVE-2019-12768": {"epss_score": 0.00227, "epss_percentile": 0.45397}, "CVE-2019-12769": {"epss_score": 0.00627, "epss_percentile": 0.69636}, "CVE-2019-12771": {"epss_score": 0.13082, "epss_percentile": 0.93868}, "CVE-2019-12773": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2019-12774": {"epss_score": 0.00489, "epss_percentile": 0.64907}, "CVE-2019-12775": {"epss_score": 0.00833, "epss_percentile": 0.74089}, "CVE-2019-12776": {"epss_score": 0.01044, "epss_percentile": 0.77}, "CVE-2019-12777": {"epss_score": 0.0003, "epss_percentile": 0.08178}, "CVE-2019-12779": {"epss_score": 0.00032, "epss_percentile": 0.09104}, "CVE-2019-12780": {"epss_score": 0.85243, "epss_percentile": 0.99324}, "CVE-2019-12781": {"epss_score": 0.03851, "epss_percentile": 0.87849}, "CVE-2019-12782": {"epss_score": 0.00335, "epss_percentile": 0.55828}, "CVE-2019-12783": {"epss_score": 0.00195, "epss_percentile": 0.41618}, "CVE-2019-12784": {"epss_score": 0.00227, "epss_percentile": 0.45405}, "CVE-2019-12786": {"epss_score": 0.02367, "epss_percentile": 0.84516}, "CVE-2019-12787": {"epss_score": 0.02367, "epss_percentile": 0.84516}, "CVE-2019-12788": {"epss_score": 0.03277, "epss_percentile": 0.86806}, "CVE-2019-12789": {"epss_score": 0.00139, "epss_percentile": 0.34643}, "CVE-2019-12790": {"epss_score": 0.0049, "epss_percentile": 0.64941}, "CVE-2019-12791": {"epss_score": 0.05814, "epss_percentile": 0.90228}, "CVE-2019-12792": {"epss_score": 0.08257, "epss_percentile": 0.91954}, "CVE-2019-12794": {"epss_score": 0.0034, "epss_percentile": 0.56265}, "CVE-2019-12795": {"epss_score": 0.00083, "epss_percentile": 0.24705}, "CVE-2019-12797": {"epss_score": 0.0035, "epss_percentile": 0.56975}, "CVE-2019-12798": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-12799": {"epss_score": 0.2902, "epss_percentile": 0.96412}, "CVE-2019-12801": {"epss_score": 0.00426, "epss_percentile": 0.61753}, "CVE-2019-12802": {"epss_score": 0.00469, "epss_percentile": 0.63952}, "CVE-2019-12803": {"epss_score": 0.00357, "epss_percentile": 0.5746}, "CVE-2019-12804": {"epss_score": 0.00096, "epss_percentile": 0.2735}, "CVE-2019-12805": {"epss_score": 0.02413, "epss_percentile": 0.84677}, "CVE-2019-12806": {"epss_score": 0.04054, "epss_percentile": 0.88179}, "CVE-2019-12807": {"epss_score": 0.0088, "epss_percentile": 0.74856}, "CVE-2019-12808": {"epss_score": 0.00058, "epss_percentile": 0.18504}, "CVE-2019-12809": {"epss_score": 0.00382, "epss_percentile": 0.59065}, "CVE-2019-12810": {"epss_score": 0.00341, "epss_percentile": 0.56322}, "CVE-2019-12811": {"epss_score": 0.01044, "epss_percentile": 0.76998}, "CVE-2019-12812": {"epss_score": 0.01467, "epss_percentile": 0.80469}, "CVE-2019-12813": {"epss_score": 0.00176, "epss_percentile": 0.39376}, "CVE-2019-12814": {"epss_score": 0.18339, "epss_percentile": 0.94998}, "CVE-2019-12815": {"epss_score": 0.78813, "epss_percentile": 0.99005}, "CVE-2019-12816": {"epss_score": 0.0271, "epss_percentile": 0.85492}, "CVE-2019-12817": {"epss_score": 0.00066, "epss_percentile": 0.20763}, "CVE-2019-12818": {"epss_score": 0.05643, "epss_percentile": 0.90079}, "CVE-2019-12819": {"epss_score": 0.00076, "epss_percentile": 0.23271}, "CVE-2019-12820": {"epss_score": 0.00166, "epss_percentile": 0.38241}, "CVE-2019-12821": {"epss_score": 0.00389, "epss_percentile": 0.59406}, "CVE-2019-12822": {"epss_score": 0.00703, "epss_percentile": 0.71538}, "CVE-2019-12823": {"epss_score": 0.00212, "epss_percentile": 0.43814}, "CVE-2019-12825": {"epss_score": 0.00057, "epss_percentile": 0.18161}, "CVE-2019-12826": {"epss_score": 0.00313, "epss_percentile": 0.54076}, "CVE-2019-12827": {"epss_score": 0.18818, "epss_percentile": 0.95074}, "CVE-2019-12828": {"epss_score": 0.1356, "epss_percentile": 0.93996}, "CVE-2019-12829": {"epss_score": 0.00784, "epss_percentile": 0.73235}, "CVE-2019-12830": {"epss_score": 0.00348, "epss_percentile": 0.56796}, "CVE-2019-12831": {"epss_score": 0.00522, "epss_percentile": 0.66249}, "CVE-2019-12834": {"epss_score": 0.00227, "epss_percentile": 0.45423}, "CVE-2019-12835": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2019-12836": {"epss_score": 0.06889, "epss_percentile": 0.91093}, "CVE-2019-12837": {"epss_score": 0.00216, "epss_percentile": 0.44238}, "CVE-2019-12838": {"epss_score": 0.03254, "epss_percentile": 0.86757}, "CVE-2019-12839": {"epss_score": 0.02115, "epss_percentile": 0.83658}, "CVE-2019-12840": {"epss_score": 0.89819, "epss_percentile": 0.99543}, "CVE-2019-12841": {"epss_score": 4e-05, "epss_percentile": 0.00139}, "CVE-2019-12842": {"epss_score": 7e-05, "epss_percentile": 0.00348}, "CVE-2019-12843": {"epss_score": 3e-05, "epss_percentile": 0.00115}, "CVE-2019-12844": {"epss_score": 3e-05, "epss_percentile": 0.00115}, "CVE-2019-12845": {"epss_score": 3e-05, "epss_percentile": 0.00112}, "CVE-2019-12846": {"epss_score": 3e-05, "epss_percentile": 0.00083}, "CVE-2019-12847": {"epss_score": 3e-05, "epss_percentile": 0.00088}, "CVE-2019-12850": {"epss_score": 5e-05, "epss_percentile": 0.00189}, "CVE-2019-12851": {"epss_score": 2e-05, "epss_percentile": 0.00048}, "CVE-2019-12852": {"epss_score": 4e-05, "epss_percentile": 0.00159}, "CVE-2019-12854": {"epss_score": 0.44493, "epss_percentile": 0.9744}, "CVE-2019-12855": {"epss_score": 0.00659, "epss_percentile": 0.70503}, "CVE-2019-12863": {"epss_score": 0.01855, "epss_percentile": 0.82559}, "CVE-2019-12864": {"epss_score": 0.00223, "epss_percentile": 0.4496}, "CVE-2019-12865": {"epss_score": 0.00262, "epss_percentile": 0.49329}, "CVE-2019-12866": {"epss_score": 4e-05, "epss_percentile": 0.00159}, "CVE-2019-12867": {"epss_score": 5e-05, "epss_percentile": 0.00205}, "CVE-2019-12868": {"epss_score": 0.0196, "epss_percentile": 0.83057}, "CVE-2019-12869": {"epss_score": 0.01728, "epss_percentile": 0.81975}, "CVE-2019-12870": {"epss_score": 0.01728, "epss_percentile": 0.81975}, "CVE-2019-12871": {"epss_score": 0.02021, "epss_percentile": 0.83298}, "CVE-2019-12872": {"epss_score": 0.00261, "epss_percentile": 0.49308}, "CVE-2019-12874": {"epss_score": 0.02534, "epss_percentile": 0.85035}, "CVE-2019-12875": {"epss_score": 0.00269, "epss_percentile": 0.50155}, "CVE-2019-12876": {"epss_score": 0.001, "epss_percentile": 0.28494}, "CVE-2019-12880": {"epss_score": 0.00247, "epss_percentile": 0.4787}, "CVE-2019-12881": {"epss_score": 0.00566, "epss_percentile": 0.67832}, "CVE-2019-12887": {"epss_score": 0.0035, "epss_percentile": 0.56975}, "CVE-2019-12889": {"epss_score": 0.00259, "epss_percentile": 0.49057}, "CVE-2019-12890": {"epss_score": 0.52916, "epss_percentile": 0.97846}, "CVE-2019-12893": {"epss_score": 0.00348, "epss_percentile": 0.56845}, "CVE-2019-12894": {"epss_score": 0.00348, "epss_percentile": 0.56845}, "CVE-2019-12895": {"epss_score": 0.00348, "epss_percentile": 0.56845}, "CVE-2019-12896": {"epss_score": 0.00436, "epss_percentile": 0.62451}, "CVE-2019-12897": {"epss_score": 0.00436, "epss_percentile": 0.62451}, "CVE-2019-12898": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-12899": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-12900": {"epss_score": 0.01132, "epss_percentile": 0.77874}, "CVE-2019-12901": {"epss_score": 0.00685, "epss_percentile": 0.71134}, "CVE-2019-12902": {"epss_score": 0.0031, "epss_percentile": 0.53787}, "CVE-2019-12903": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2019-12904": {"epss_score": 0.00191, "epss_percentile": 0.41164}, "CVE-2019-12905": {"epss_score": 0.03673, "epss_percentile": 0.87547}, "CVE-2019-12911": {"epss_score": 0.00408, "epss_percentile": 0.60637}, "CVE-2019-12912": {"epss_score": 0.00074, "epss_percentile": 0.22697}, "CVE-2019-12913": {"epss_score": 0.00074, "epss_percentile": 0.22697}, "CVE-2019-12914": {"epss_score": 0.00408, "epss_percentile": 0.60637}, "CVE-2019-12917": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2019-12918": {"epss_score": 0.00394, "epss_percentile": 0.59789}, "CVE-2019-12919": {"epss_score": 0.00074, "epss_percentile": 0.22825}, "CVE-2019-12920": {"epss_score": 0.00351, "epss_percentile": 0.57055}, "CVE-2019-12921": {"epss_score": 0.06531, "epss_percentile": 0.90825}, "CVE-2019-12922": {"epss_score": 0.4225, "epss_percentile": 0.97322}, "CVE-2019-12923": {"epss_score": 0.00042, "epss_percentile": 0.12629}, "CVE-2019-12924": {"epss_score": 0.00136, "epss_percentile": 0.34171}, "CVE-2019-12925": {"epss_score": 0.0021, "epss_percentile": 0.43471}, "CVE-2019-12926": {"epss_score": 0.00191, "epss_percentile": 0.41268}, "CVE-2019-12927": {"epss_score": 0.0011, "epss_percentile": 0.30186}, "CVE-2019-12928": {"epss_score": 0.54092, "epss_percentile": 0.97911}, "CVE-2019-12929": {"epss_score": 0.03423, "epss_percentile": 0.87109}, "CVE-2019-12930": {"epss_score": 0.00521, "epss_percentile": 0.66248}, "CVE-2019-12932": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-12934": {"epss_score": 0.00735, "epss_percentile": 0.72286}, "CVE-2019-12935": {"epss_score": 0.00556, "epss_percentile": 0.67519}, "CVE-2019-12936": {"epss_score": 0.00253, "epss_percentile": 0.48457}, "CVE-2019-12937": {"epss_score": 0.00045, "epss_percentile": 0.13722}, "CVE-2019-12938": {"epss_score": 0.00189, "epss_percentile": 0.40999}, "CVE-2019-12939": {"epss_score": 0.00344, "epss_percentile": 0.56534}, "CVE-2019-12940": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2019-12941": {"epss_score": 0.00448, "epss_percentile": 0.62995}, "CVE-2019-12942": {"epss_score": 0.00157, "epss_percentile": 0.37037}, "CVE-2019-12943": {"epss_score": 0.00356, "epss_percentile": 0.57355}, "CVE-2019-12944": {"epss_score": 0.0029, "epss_percentile": 0.52112}, "CVE-2019-12946": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2019-12948": {"epss_score": 0.01194, "epss_percentile": 0.78422}, "CVE-2019-12949": {"epss_score": 0.12389, "epss_percentile": 0.93657}, "CVE-2019-12950": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-12951": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2019-12953": {"epss_score": 0.0029, "epss_percentile": 0.52078}, "CVE-2019-12954": {"epss_score": 0.02887, "epss_percentile": 0.85912}, "CVE-2019-12957": {"epss_score": 0.00296, "epss_percentile": 0.52602}, "CVE-2019-12958": {"epss_score": 0.00201, "epss_percentile": 0.42303}, "CVE-2019-12959": {"epss_score": 0.00293, "epss_percentile": 0.52348}, "CVE-2019-12960": {"epss_score": 0.00307, "epss_percentile": 0.53524}, "CVE-2019-12961": {"epss_score": 0.00415, "epss_percentile": 0.6113}, "CVE-2019-12962": {"epss_score": 0.06302, "epss_percentile": 0.90657}, "CVE-2019-12963": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2019-12964": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2019-12966": {"epss_score": 0.01119, "epss_percentile": 0.77752}, "CVE-2019-12967": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2019-12968": {"epss_score": 0.01057, "epss_percentile": 0.7713}, "CVE-2019-12970": {"epss_score": 0.00925, "epss_percentile": 0.75526}, "CVE-2019-12971": {"epss_score": 0.00715, "epss_percentile": 0.71849}, "CVE-2019-12972": {"epss_score": 0.00213, "epss_percentile": 0.43827}, "CVE-2019-12973": {"epss_score": 0.00054, "epss_percentile": 0.17049}, "CVE-2019-12974": {"epss_score": 0.00196, "epss_percentile": 0.41736}, "CVE-2019-12975": {"epss_score": 0.00128, "epss_percentile": 0.32976}, "CVE-2019-12976": {"epss_score": 0.00128, "epss_percentile": 0.32976}, "CVE-2019-12977": {"epss_score": 0.00298, "epss_percentile": 0.52776}, "CVE-2019-12978": {"epss_score": 0.0015, "epss_percentile": 0.3605}, "CVE-2019-12979": {"epss_score": 0.0021, "epss_percentile": 0.43483}, "CVE-2019-12980": {"epss_score": 0.00456, "epss_percentile": 0.63332}, "CVE-2019-12981": {"epss_score": 0.00518, "epss_percentile": 0.66128}, "CVE-2019-12982": {"epss_score": 0.00497, "epss_percentile": 0.65211}, "CVE-2019-12984": {"epss_score": 0.00569, "epss_percentile": 0.6791}, "CVE-2019-12985": {"epss_score": 0.92571, "epss_percentile": 0.99727}, "CVE-2019-12986": {"epss_score": 0.92422, "epss_percentile": 0.99714}, "CVE-2019-12987": {"epss_score": 0.92769, "epss_percentile": 0.99745}, "CVE-2019-12988": {"epss_score": 0.92769, "epss_percentile": 0.99745}, "CVE-2019-12989": {"epss_score": 0.91054, "epss_percentile": 0.99616}, "CVE-2019-12990": {"epss_score": 0.91507, "epss_percentile": 0.99649}, "CVE-2019-12991": {"epss_score": 0.86507, "epss_percentile": 0.99385}, "CVE-2019-12992": {"epss_score": 0.02067, "epss_percentile": 0.83462}, "CVE-2019-12994": {"epss_score": 0.03018, "epss_percentile": 0.8622}, "CVE-2019-12995": {"epss_score": 0.00652, "epss_percentile": 0.70315}, "CVE-2019-12996": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2019-12997": {"epss_score": 0.00725, "epss_percentile": 0.72058}, "CVE-2019-12998": {"epss_score": 0.00432, "epss_percentile": 0.62116}, "CVE-2019-12999": {"epss_score": 0.00817, "epss_percentile": 0.73848}, "CVE-2019-13000": {"epss_score": 0.00695, "epss_percentile": 0.7138}, "CVE-2019-13001": {"epss_score": 0.00077, "epss_percentile": 0.23376}, "CVE-2019-13002": {"epss_score": 0.00038, "epss_percentile": 0.1121}, "CVE-2019-13003": {"epss_score": 0.00046, "epss_percentile": 0.14275}, "CVE-2019-13004": {"epss_score": 0.00114, "epss_percentile": 0.30779}, "CVE-2019-13005": {"epss_score": 0.00102, "epss_percentile": 0.28873}, "CVE-2019-13006": {"epss_score": 0.00069, "epss_percentile": 0.21506}, "CVE-2019-13007": {"epss_score": 0.00138, "epss_percentile": 0.34523}, "CVE-2019-13009": {"epss_score": 0.00116, "epss_percentile": 0.31092}, "CVE-2019-13010": {"epss_score": 0.00127, "epss_percentile": 0.32913}, "CVE-2019-13011": {"epss_score": 0.00069, "epss_percentile": 0.21506}, "CVE-2019-13012": {"epss_score": 0.00842, "epss_percentile": 0.74237}, "CVE-2019-13013": {"epss_score": 0.00042, "epss_percentile": 0.12623}, "CVE-2019-13014": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2019-13020": {"epss_score": 0.00389, "epss_percentile": 0.59495}, "CVE-2019-13021": {"epss_score": 0.00134, "epss_percentile": 0.33899}, "CVE-2019-13022": {"epss_score": 0.00186, "epss_percentile": 0.40632}, "CVE-2019-13023": {"epss_score": 0.00218, "epss_percentile": 0.44391}, "CVE-2019-13024": {"epss_score": 0.64215, "epss_percentile": 0.9837}, "CVE-2019-13025": {"epss_score": 0.10808, "epss_percentile": 0.93111}, "CVE-2019-13026": {"epss_score": 0.00331, "epss_percentile": 0.5551}, "CVE-2019-13027": {"epss_score": 0.06308, "epss_percentile": 0.90661}, "CVE-2019-13028": {"epss_score": 0.01506, "epss_percentile": 0.80748}, "CVE-2019-13029": {"epss_score": 0.00327, "epss_percentile": 0.5514}, "CVE-2019-13030": {"epss_score": 0.00349, "epss_percentile": 0.56872}, "CVE-2019-13031": {"epss_score": 0.00323, "epss_percentile": 0.54903}, "CVE-2019-13032": {"epss_score": 0.00165, "epss_percentile": 0.3813}, "CVE-2019-13033": {"epss_score": 0.00072, "epss_percentile": 0.22393}, "CVE-2019-13035": {"epss_score": 0.0011, "epss_percentile": 0.3018}, "CVE-2019-13038": {"epss_score": 0.00116, "epss_percentile": 0.31112}, "CVE-2019-13045": {"epss_score": 0.05965, "epss_percentile": 0.90369}, "CVE-2019-13046": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2019-13047": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2019-13048": {"epss_score": 0.00049, "epss_percentile": 0.153}, "CVE-2019-13049": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2019-13050": {"epss_score": 0.00738, "epss_percentile": 0.72339}, "CVE-2019-13051": {"epss_score": 0.31589, "epss_percentile": 0.96629}, "CVE-2019-13052": {"epss_score": 0.0011, "epss_percentile": 0.30077}, "CVE-2019-13053": {"epss_score": 0.00046, "epss_percentile": 0.14175}, "CVE-2019-13054": {"epss_score": 0.00035, "epss_percentile": 0.09938}, "CVE-2019-13055": {"epss_score": 0.00179, "epss_percentile": 0.39848}, "CVE-2019-13056": {"epss_score": 0.00164, "epss_percentile": 0.37873}, "CVE-2019-13057": {"epss_score": 0.00582, "epss_percentile": 0.68287}, "CVE-2019-13063": {"epss_score": 0.15875, "epss_percentile": 0.94524}, "CVE-2019-13066": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2019-13067": {"epss_score": 0.00367, "epss_percentile": 0.58143}, "CVE-2019-13068": {"epss_score": 0.06596, "epss_percentile": 0.90875}, "CVE-2019-13069": {"epss_score": 0.00082, "epss_percentile": 0.24418}, "CVE-2019-13070": {"epss_score": 0.00223, "epss_percentile": 0.44884}, "CVE-2019-13071": {"epss_score": 0.0033, "epss_percentile": 0.55425}, "CVE-2019-13072": {"epss_score": 0.0027, "epss_percentile": 0.50251}, "CVE-2019-13074": {"epss_score": 0.00852, "epss_percentile": 0.74416}, "CVE-2019-13075": {"epss_score": 0.00146, "epss_percentile": 0.35569}, "CVE-2019-13076": {"epss_score": 0.00358, "epss_percentile": 0.57499}, "CVE-2019-13077": {"epss_score": 0.00422, "epss_percentile": 0.61536}, "CVE-2019-13078": {"epss_score": 0.00358, "epss_percentile": 0.57499}, "CVE-2019-13079": {"epss_score": 0.00358, "epss_percentile": 0.57499}, "CVE-2019-13080": {"epss_score": 0.00403, "epss_percentile": 0.60325}, "CVE-2019-13081": {"epss_score": 0.00403, "epss_percentile": 0.60325}, "CVE-2019-13082": {"epss_score": 0.03509, "epss_percentile": 0.87263}, "CVE-2019-13083": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13084": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13085": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13086": {"epss_score": 0.50772, "epss_percentile": 0.97748}, "CVE-2019-13096": {"epss_score": 0.00197, "epss_percentile": 0.41872}, "CVE-2019-13097": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-13098": {"epss_score": 0.00557, "epss_percentile": 0.67534}, "CVE-2019-13099": {"epss_score": 0.00128, "epss_percentile": 0.32943}, "CVE-2019-13100": {"epss_score": 0.00128, "epss_percentile": 0.32943}, "CVE-2019-13101": {"epss_score": 0.85471, "epss_percentile": 0.99334}, "CVE-2019-13103": {"epss_score": 0.00073, "epss_percentile": 0.22581}, "CVE-2019-13104": {"epss_score": 0.0029, "epss_percentile": 0.52108}, "CVE-2019-13105": {"epss_score": 0.00259, "epss_percentile": 0.49096}, "CVE-2019-13106": {"epss_score": 0.00845, "epss_percentile": 0.74289}, "CVE-2019-13107": {"epss_score": 0.00609, "epss_percentile": 0.69097}, "CVE-2019-13108": {"epss_score": 0.00482, "epss_percentile": 0.64536}, "CVE-2019-13109": {"epss_score": 0.00141, "epss_percentile": 0.34802}, "CVE-2019-13110": {"epss_score": 0.00193, "epss_percentile": 0.41401}, "CVE-2019-13111": {"epss_score": 0.00106, "epss_percentile": 0.29539}, "CVE-2019-13112": {"epss_score": 0.00262, "epss_percentile": 0.49364}, "CVE-2019-13113": {"epss_score": 0.00295, "epss_percentile": 0.52521}, "CVE-2019-13114": {"epss_score": 0.00403, "epss_percentile": 0.60365}, "CVE-2019-13115": {"epss_score": 0.42816, "epss_percentile": 0.97356}, "CVE-2019-13116": {"epss_score": 0.02389, "epss_percentile": 0.84593}, "CVE-2019-13117": {"epss_score": 0.04457, "epss_percentile": 0.88714}, "CVE-2019-13118": {"epss_score": 0.01027, "epss_percentile": 0.76808}, "CVE-2019-13120": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-13121": {"epss_score": 0.00068, "epss_percentile": 0.21424}, "CVE-2019-13122": {"epss_score": 0.00722, "epss_percentile": 0.72002}, "CVE-2019-13123": {"epss_score": 0.00028, "epss_percentile": 0.07216}, "CVE-2019-13124": {"epss_score": 0.00028, "epss_percentile": 0.07216}, "CVE-2019-13125": {"epss_score": 0.00169, "epss_percentile": 0.38527}, "CVE-2019-13126": {"epss_score": 0.00678, "epss_percentile": 0.70991}, "CVE-2019-13127": {"epss_score": 0.00332, "epss_percentile": 0.55567}, "CVE-2019-13128": {"epss_score": 0.12086, "epss_percentile": 0.93564}, "CVE-2019-13129": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2019-13131": {"epss_score": 0.0211, "epss_percentile": 0.83643}, "CVE-2019-13132": {"epss_score": 0.28165, "epss_percentile": 0.96328}, "CVE-2019-13133": {"epss_score": 0.00097, "epss_percentile": 0.27502}, "CVE-2019-13134": {"epss_score": 0.00097, "epss_percentile": 0.27502}, "CVE-2019-13135": {"epss_score": 0.02637, "epss_percentile": 0.85296}, "CVE-2019-13136": {"epss_score": 0.00306, "epss_percentile": 0.53461}, "CVE-2019-13137": {"epss_score": 0.01518, "epss_percentile": 0.80813}, "CVE-2019-13139": {"epss_score": 0.00202, "epss_percentile": 0.42392}, "CVE-2019-13140": {"epss_score": 0.01158, "epss_percentile": 0.78118}, "CVE-2019-13142": {"epss_score": 0.00042, "epss_percentile": 0.12643}, "CVE-2019-13143": {"epss_score": 0.04111, "epss_percentile": 0.88273}, "CVE-2019-13144": {"epss_score": 0.01052, "epss_percentile": 0.77092}, "CVE-2019-13146": {"epss_score": 0.00257, "epss_percentile": 0.48865}, "CVE-2019-13147": {"epss_score": 0.00129, "epss_percentile": 0.33089}, "CVE-2019-13148": {"epss_score": 0.04612, "epss_percentile": 0.88919}, "CVE-2019-13149": {"epss_score": 0.04612, "epss_percentile": 0.88919}, "CVE-2019-13150": {"epss_score": 0.04612, "epss_percentile": 0.88919}, "CVE-2019-13151": {"epss_score": 0.04612, "epss_percentile": 0.88919}, "CVE-2019-13152": {"epss_score": 0.04612, "epss_percentile": 0.88919}, "CVE-2019-13153": {"epss_score": 0.04612, "epss_percentile": 0.88919}, "CVE-2019-13154": {"epss_score": 0.04612, "epss_percentile": 0.88919}, "CVE-2019-13155": {"epss_score": 0.04612, "epss_percentile": 0.88919}, "CVE-2019-13156": {"epss_score": 0.00462, "epss_percentile": 0.63622}, "CVE-2019-13157": {"epss_score": 0.00429, "epss_percentile": 0.61998}, "CVE-2019-13161": {"epss_score": 0.02171, "epss_percentile": 0.83873}, "CVE-2019-13163": {"epss_score": 0.00128, "epss_percentile": 0.33017}, "CVE-2019-13164": {"epss_score": 0.00021, "epss_percentile": 0.04721}, "CVE-2019-13165": {"epss_score": 0.01279, "epss_percentile": 0.79134}, "CVE-2019-13166": {"epss_score": 0.00342, "epss_percentile": 0.56366}, "CVE-2019-13167": {"epss_score": 0.0057, "epss_percentile": 0.67955}, "CVE-2019-13168": {"epss_score": 0.01018, "epss_percentile": 0.76707}, "CVE-2019-13169": {"epss_score": 0.01529, "epss_percentile": 0.80875}, "CVE-2019-13170": {"epss_score": 0.00165, "epss_percentile": 0.3804}, "CVE-2019-13171": {"epss_score": 0.01347, "epss_percentile": 0.79655}, "CVE-2019-13172": {"epss_score": 0.0186, "epss_percentile": 0.82589}, "CVE-2019-13173": {"epss_score": 0.0043, "epss_percentile": 0.62031}, "CVE-2019-13175": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2019-13176": {"epss_score": 0.00371, "epss_percentile": 0.58409}, "CVE-2019-13177": {"epss_score": 0.00405, "epss_percentile": 0.60491}, "CVE-2019-13178": {"epss_score": 0.01971, "epss_percentile": 0.83098}, "CVE-2019-13179": {"epss_score": 0.00849, "epss_percentile": 0.74381}, "CVE-2019-13181": {"epss_score": 0.01814, "epss_percentile": 0.8238}, "CVE-2019-13182": {"epss_score": 0.02405, "epss_percentile": 0.84651}, "CVE-2019-13183": {"epss_score": 0.002, "epss_percentile": 0.42253}, "CVE-2019-13186": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-13187": {"epss_score": 0.01008, "epss_percentile": 0.76565}, "CVE-2019-13188": {"epss_score": 0.04036, "epss_percentile": 0.88158}, "CVE-2019-13189": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2019-13190": {"epss_score": 0.0027, "epss_percentile": 0.50211}, "CVE-2019-13191": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2019-13192": {"epss_score": 0.03853, "epss_percentile": 0.87855}, "CVE-2019-13193": {"epss_score": 0.02201, "epss_percentile": 0.8398}, "CVE-2019-13194": {"epss_score": 0.00549, "epss_percentile": 0.67313}, "CVE-2019-13195": {"epss_score": 0.00186, "epss_percentile": 0.40589}, "CVE-2019-13196": {"epss_score": 0.00197, "epss_percentile": 0.41828}, "CVE-2019-13197": {"epss_score": 0.00262, "epss_percentile": 0.49377}, "CVE-2019-13198": {"epss_score": 0.00048, "epss_percentile": 0.15195}, "CVE-2019-13199": {"epss_score": 0.00024, "epss_percentile": 0.05819}, "CVE-2019-13200": {"epss_score": 0.00048, "epss_percentile": 0.15195}, "CVE-2019-13201": {"epss_score": 0.00171, "epss_percentile": 0.38807}, "CVE-2019-13202": {"epss_score": 0.00209, "epss_percentile": 0.43376}, "CVE-2019-13203": {"epss_score": 0.00139, "epss_percentile": 0.34665}, "CVE-2019-13204": {"epss_score": 0.00171, "epss_percentile": 0.38807}, "CVE-2019-13205": {"epss_score": 0.0009, "epss_percentile": 0.26031}, "CVE-2019-13206": {"epss_score": 0.0019, "epss_percentile": 0.4109}, "CVE-2019-13207": {"epss_score": 0.00502, "epss_percentile": 0.65402}, "CVE-2019-13208": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2019-13209": {"epss_score": 0.00236, "epss_percentile": 0.46385}, "CVE-2019-13217": {"epss_score": 0.00256, "epss_percentile": 0.48819}, "CVE-2019-13218": {"epss_score": 0.00168, "epss_percentile": 0.38496}, "CVE-2019-13219": {"epss_score": 0.00184, "epss_percentile": 0.40399}, "CVE-2019-13220": {"epss_score": 0.00141, "epss_percentile": 0.34912}, "CVE-2019-13221": {"epss_score": 0.00249, "epss_percentile": 0.48023}, "CVE-2019-13222": {"epss_score": 0.00141, "epss_percentile": 0.34912}, "CVE-2019-13223": {"epss_score": 0.00098, "epss_percentile": 0.27798}, "CVE-2019-13224": {"epss_score": 0.00548, "epss_percentile": 0.67274}, "CVE-2019-13225": {"epss_score": 0.00134, "epss_percentile": 0.33786}, "CVE-2019-13226": {"epss_score": 0.0005, "epss_percentile": 0.15841}, "CVE-2019-13227": {"epss_score": 0.00082, "epss_percentile": 0.24548}, "CVE-2019-13228": {"epss_score": 0.00101, "epss_percentile": 0.28592}, "CVE-2019-13229": {"epss_score": 0.00082, "epss_percentile": 0.24548}, "CVE-2019-13232": {"epss_score": 0.00046, "epss_percentile": 0.14139}, "CVE-2019-13233": {"epss_score": 0.00054, "epss_percentile": 0.17096}, "CVE-2019-13234": {"epss_score": 0.02035, "epss_percentile": 0.83352}, "CVE-2019-13235": {"epss_score": 0.04252, "epss_percentile": 0.88453}, "CVE-2019-13236": {"epss_score": 0.04252, "epss_percentile": 0.88453}, "CVE-2019-13237": {"epss_score": 0.04138, "epss_percentile": 0.88308}, "CVE-2019-13238": {"epss_score": 0.00503, "epss_percentile": 0.65458}, "CVE-2019-13239": {"epss_score": 0.00336, "epss_percentile": 0.55914}, "CVE-2019-13240": {"epss_score": 0.00544, "epss_percentile": 0.67141}, "CVE-2019-13241": {"epss_score": 0.01144, "epss_percentile": 0.77987}, "CVE-2019-13242": {"epss_score": 0.00413, "epss_percentile": 0.6099}, "CVE-2019-13243": {"epss_score": 0.00261, "epss_percentile": 0.49302}, "CVE-2019-13244": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13245": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13246": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13247": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13248": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13249": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13250": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13251": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13252": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13253": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13254": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13255": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13256": {"epss_score": 0.0012, "epss_percentile": 0.31757}, "CVE-2019-13257": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13258": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13259": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13260": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13261": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13262": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2019-13263": {"epss_score": 0.00277, "epss_percentile": 0.50827}, "CVE-2019-13264": {"epss_score": 0.00277, "epss_percentile": 0.50827}, "CVE-2019-13265": {"epss_score": 0.00277, "epss_percentile": 0.50827}, "CVE-2019-13266": {"epss_score": 0.00115, "epss_percentile": 0.30941}, "CVE-2019-13267": {"epss_score": 0.00115, "epss_percentile": 0.30941}, "CVE-2019-13268": {"epss_score": 0.00115, "epss_percentile": 0.30941}, "CVE-2019-13269": {"epss_score": 0.00115, "epss_percentile": 0.30941}, "CVE-2019-13270": {"epss_score": 0.00115, "epss_percentile": 0.30941}, "CVE-2019-13271": {"epss_score": 0.00115, "epss_percentile": 0.30941}, "CVE-2019-13272": {"epss_score": 0.79258, "epss_percentile": 0.99027}, "CVE-2019-13273": {"epss_score": 0.00474, "epss_percentile": 0.6417}, "CVE-2019-13274": {"epss_score": 0.00248, "epss_percentile": 0.47935}, "CVE-2019-13275": {"epss_score": 0.01256, "epss_percentile": 0.78939}, "CVE-2019-13276": {"epss_score": 0.0391, "epss_percentile": 0.87933}, "CVE-2019-13277": {"epss_score": 0.01701, "epss_percentile": 0.81835}, "CVE-2019-13278": {"epss_score": 0.50729, "epss_percentile": 0.97747}, "CVE-2019-13279": {"epss_score": 0.05217, "epss_percentile": 0.8962}, "CVE-2019-13280": {"epss_score": 0.02366, "epss_percentile": 0.84515}, "CVE-2019-13281": {"epss_score": 0.00347, "epss_percentile": 0.56757}, "CVE-2019-13282": {"epss_score": 0.00296, "epss_percentile": 0.52602}, "CVE-2019-13283": {"epss_score": 0.00286, "epss_percentile": 0.51719}, "CVE-2019-13285": {"epss_score": 0.00238, "epss_percentile": 0.46811}, "CVE-2019-13286": {"epss_score": 0.00321, "epss_percentile": 0.54681}, "CVE-2019-13287": {"epss_score": 0.002, "epss_percentile": 0.42233}, "CVE-2019-13288": {"epss_score": 0.31539, "epss_percentile": 0.96626}, "CVE-2019-13289": {"epss_score": 0.00288, "epss_percentile": 0.51878}, "CVE-2019-13290": {"epss_score": 0.01248, "epss_percentile": 0.78865}, "CVE-2019-13291": {"epss_score": 0.00245, "epss_percentile": 0.47628}, "CVE-2019-13292": {"epss_score": 0.1092, "epss_percentile": 0.93158}, "CVE-2019-13294": {"epss_score": 0.3431, "epss_percentile": 0.96841}, "CVE-2019-13295": {"epss_score": 0.00303, "epss_percentile": 0.53186}, "CVE-2019-13296": {"epss_score": 0.00467, "epss_percentile": 0.63849}, "CVE-2019-13297": {"epss_score": 0.00303, "epss_percentile": 0.53186}, "CVE-2019-13298": {"epss_score": 0.00524, "epss_percentile": 0.6632}, "CVE-2019-13299": {"epss_score": 0.0049, "epss_percentile": 0.64921}, "CVE-2019-13300": {"epss_score": 0.00202, "epss_percentile": 0.42407}, "CVE-2019-13301": {"epss_score": 0.00206, "epss_percentile": 0.43061}, "CVE-2019-13302": {"epss_score": 0.00439, "epss_percentile": 0.62575}, "CVE-2019-13303": {"epss_score": 0.0049, "epss_percentile": 0.64921}, "CVE-2019-13304": {"epss_score": 0.00134, "epss_percentile": 0.33834}, "CVE-2019-13305": {"epss_score": 0.00134, "epss_percentile": 0.33834}, "CVE-2019-13306": {"epss_score": 0.00102, "epss_percentile": 0.28856}, "CVE-2019-13307": {"epss_score": 0.00102, "epss_percentile": 0.28856}, "CVE-2019-13308": {"epss_score": 0.01115, "epss_percentile": 0.77709}, "CVE-2019-13309": {"epss_score": 0.00199, "epss_percentile": 0.4219}, "CVE-2019-13310": {"epss_score": 0.00108, "epss_percentile": 0.29887}, "CVE-2019-13311": {"epss_score": 0.00199, "epss_percentile": 0.4219}, "CVE-2019-13312": {"epss_score": 0.00582, "epss_percentile": 0.68299}, "CVE-2019-13313": {"epss_score": 0.00044, "epss_percentile": 0.13625}, "CVE-2019-13314": {"epss_score": 0.00055, "epss_percentile": 0.1749}, "CVE-2019-13315": {"epss_score": 0.0086, "epss_percentile": 0.74536}, "CVE-2019-13316": {"epss_score": 0.0086, "epss_percentile": 0.74536}, "CVE-2019-13317": {"epss_score": 0.0086, "epss_percentile": 0.74536}, "CVE-2019-13318": {"epss_score": 0.00911, "epss_percentile": 0.75329}, "CVE-2019-13319": {"epss_score": 0.00606, "epss_percentile": 0.6902}, "CVE-2019-13320": {"epss_score": 0.00606, "epss_percentile": 0.6902}, "CVE-2019-13321": {"epss_score": 0.00128, "epss_percentile": 0.32952}, "CVE-2019-13322": {"epss_score": 0.0057, "epss_percentile": 0.67966}, "CVE-2019-13323": {"epss_score": 0.02165, "epss_percentile": 0.83844}, "CVE-2019-13324": {"epss_score": 0.02165, "epss_percentile": 0.83844}, "CVE-2019-13325": {"epss_score": 0.01836, "epss_percentile": 0.82467}, "CVE-2019-13326": {"epss_score": 0.02338, "epss_percentile": 0.84423}, "CVE-2019-13327": {"epss_score": 0.02338, "epss_percentile": 0.84423}, "CVE-2019-13328": {"epss_score": 0.02338, "epss_percentile": 0.84423}, "CVE-2019-13329": {"epss_score": 0.00374, "epss_percentile": 0.58565}, "CVE-2019-13330": {"epss_score": 0.00122, "epss_percentile": 0.32134}, "CVE-2019-13331": {"epss_score": 0.00405, "epss_percentile": 0.60508}, "CVE-2019-13332": {"epss_score": 0.02338, "epss_percentile": 0.84423}, "CVE-2019-13333": {"epss_score": 0.01326, "epss_percentile": 0.79482}, "CVE-2019-13334": {"epss_score": 0.01326, "epss_percentile": 0.79482}, "CVE-2019-13335": {"epss_score": 0.00588, "epss_percentile": 0.68499}, "CVE-2019-13336": {"epss_score": 0.01168, "epss_percentile": 0.78192}, "CVE-2019-13337": {"epss_score": 0.00232, "epss_percentile": 0.45895}, "CVE-2019-13338": {"epss_score": 0.00341, "epss_percentile": 0.56313}, "CVE-2019-13339": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2019-13340": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2019-13341": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2019-13343": {"epss_score": 0.00746, "epss_percentile": 0.72536}, "CVE-2019-13344": {"epss_score": 0.6077, "epss_percentile": 0.9822}, "CVE-2019-13345": {"epss_score": 0.79528, "epss_percentile": 0.99044}, "CVE-2019-13346": {"epss_score": 0.00259, "epss_percentile": 0.49043}, "CVE-2019-13347": {"epss_score": 0.00408, "epss_percentile": 0.60674}, "CVE-2019-13348": {"epss_score": 0.01113, "epss_percentile": 0.77692}, "CVE-2019-13349": {"epss_score": 0.01044, "epss_percentile": 0.77007}, "CVE-2019-13351": {"epss_score": 0.00468, "epss_percentile": 0.63913}, "CVE-2019-13352": {"epss_score": 0.00903, "epss_percentile": 0.752}, "CVE-2019-13354": {"epss_score": 0.00728, "epss_percentile": 0.72117}, "CVE-2019-13355": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2019-13356": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2019-13357": {"epss_score": 0.00078, "epss_percentile": 0.23775}, "CVE-2019-13358": {"epss_score": 0.41682, "epss_percentile": 0.97289}, "CVE-2019-13359": {"epss_score": 0.28166, "epss_percentile": 0.96328}, "CVE-2019-13360": {"epss_score": 0.27295, "epss_percentile": 0.96233}, "CVE-2019-13361": {"epss_score": 0.01936, "epss_percentile": 0.82961}, "CVE-2019-13362": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2019-13363": {"epss_score": 0.003, "epss_percentile": 0.5298}, "CVE-2019-13364": {"epss_score": 0.003, "epss_percentile": 0.5298}, "CVE-2019-13370": {"epss_score": 0.00134, "epss_percentile": 0.33776}, "CVE-2019-13372": {"epss_score": 0.93075, "epss_percentile": 0.99774}, "CVE-2019-13373": {"epss_score": 0.90075, "epss_percentile": 0.9956}, "CVE-2019-13374": {"epss_score": 0.00197, "epss_percentile": 0.4197}, "CVE-2019-13375": {"epss_score": 0.02753, "epss_percentile": 0.85586}, "CVE-2019-13376": {"epss_score": 0.00068, "epss_percentile": 0.21419}, "CVE-2019-13377": {"epss_score": 0.00705, "epss_percentile": 0.71583}, "CVE-2019-13379": {"epss_score": 0.08412, "epss_percentile": 0.92037}, "CVE-2019-13380": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-13382": {"epss_score": 0.00285, "epss_percentile": 0.51638}, "CVE-2019-13383": {"epss_score": 0.20738, "epss_percentile": 0.95407}, "CVE-2019-13385": {"epss_score": 0.00779, "epss_percentile": 0.73152}, "CVE-2019-13386": {"epss_score": 0.0071, "epss_percentile": 0.7172}, "CVE-2019-13387": {"epss_score": 0.02729, "epss_percentile": 0.85536}, "CVE-2019-13389": {"epss_score": 0.00199, "epss_percentile": 0.42131}, "CVE-2019-13390": {"epss_score": 0.00412, "epss_percentile": 0.60921}, "CVE-2019-13391": {"epss_score": 0.00631, "epss_percentile": 0.6972}, "CVE-2019-13392": {"epss_score": 0.06053, "epss_percentile": 0.90437}, "CVE-2019-13393": {"epss_score": 0.00419, "epss_percentile": 0.61358}, "CVE-2019-13394": {"epss_score": 0.0018, "epss_percentile": 0.39913}, "CVE-2019-13395": {"epss_score": 0.00182, "epss_percentile": 0.40246}, "CVE-2019-13396": {"epss_score": 0.66535, "epss_percentile": 0.98467}, "CVE-2019-13397": {"epss_score": 0.00215, "epss_percentile": 0.44038}, "CVE-2019-13398": {"epss_score": 0.03173, "epss_percentile": 0.86555}, "CVE-2019-13399": {"epss_score": 0.00371, "epss_percentile": 0.58409}, "CVE-2019-13400": {"epss_score": 0.00415, "epss_percentile": 0.61138}, "CVE-2019-13401": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-13402": {"epss_score": 0.00401, "epss_percentile": 0.6026}, "CVE-2019-13403": {"epss_score": 0.00614, "epss_percentile": 0.69284}, "CVE-2019-13404": {"epss_score": 0.00157, "epss_percentile": 0.37068}, "CVE-2019-13405": {"epss_score": 0.00866, "epss_percentile": 0.74636}, "CVE-2019-13406": {"epss_score": 0.0037, "epss_percentile": 0.58323}, "CVE-2019-13407": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2019-13408": {"epss_score": 0.00533, "epss_percentile": 0.66775}, "CVE-2019-13409": {"epss_score": 0.00257, "epss_percentile": 0.48915}, "CVE-2019-13410": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-13411": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-13412": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2019-13413": {"epss_score": 0.00665, "epss_percentile": 0.70658}, "CVE-2019-13414": {"epss_score": 0.00243, "epss_percentile": 0.47415}, "CVE-2019-13415": {"epss_score": 0.00204, "epss_percentile": 0.42601}, "CVE-2019-13416": {"epss_score": 0.00204, "epss_percentile": 0.42601}, "CVE-2019-13417": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2019-13418": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2019-13419": {"epss_score": 0.00131, "epss_percentile": 0.33424}, "CVE-2019-13420": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2019-13421": {"epss_score": 0.00388, "epss_percentile": 0.59399}, "CVE-2019-13422": {"epss_score": 0.00185, "epss_percentile": 0.40551}, "CVE-2019-13423": {"epss_score": 0.0024, "epss_percentile": 0.47216}, "CVE-2019-13445": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2019-13447": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-13448": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-13449": {"epss_score": 0.00625, "epss_percentile": 0.69595}, "CVE-2019-13450": {"epss_score": 0.00629, "epss_percentile": 0.69679}, "CVE-2019-13451": {"epss_score": 0.00962, "epss_percentile": 0.76001}, "CVE-2019-13452": {"epss_score": 0.00962, "epss_percentile": 0.76001}, "CVE-2019-13453": {"epss_score": 0.00581, "epss_percentile": 0.6828}, "CVE-2019-13454": {"epss_score": 0.00357, "epss_percentile": 0.57471}, "CVE-2019-13455": {"epss_score": 0.01049, "epss_percentile": 0.77064}, "CVE-2019-13456": {"epss_score": 0.00237, "epss_percentile": 0.4671}, "CVE-2019-13457": {"epss_score": 0.00443, "epss_percentile": 0.62774}, "CVE-2019-13458": {"epss_score": 0.00383, "epss_percentile": 0.59085}, "CVE-2019-13461": {"epss_score": 0.00366, "epss_percentile": 0.58087}, "CVE-2019-13462": {"epss_score": 0.79483, "epss_percentile": 0.9904}, "CVE-2019-13463": {"epss_score": 0.0029, "epss_percentile": 0.5213}, "CVE-2019-13464": {"epss_score": 0.00419, "epss_percentile": 0.61366}, "CVE-2019-13465": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2019-13466": {"epss_score": 0.00237, "epss_percentile": 0.46727}, "CVE-2019-13467": {"epss_score": 0.00239, "epss_percentile": 0.46854}, "CVE-2019-13470": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-13472": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-13473": {"epss_score": 0.00719, "epss_percentile": 0.7194}, "CVE-2019-13474": {"epss_score": 0.01533, "epss_percentile": 0.80901}, "CVE-2019-13475": {"epss_score": 0.0089, "epss_percentile": 0.75033}, "CVE-2019-13476": {"epss_score": 0.00161, "epss_percentile": 0.37523}, "CVE-2019-13477": {"epss_score": 0.00112, "epss_percentile": 0.3052}, "CVE-2019-13478": {"epss_score": 0.00263, "epss_percentile": 0.49409}, "CVE-2019-13481": {"epss_score": 0.09015, "epss_percentile": 0.92367}, "CVE-2019-13482": {"epss_score": 0.09015, "epss_percentile": 0.92367}, "CVE-2019-13483": {"epss_score": 0.00141, "epss_percentile": 0.34947}, "CVE-2019-13484": {"epss_score": 0.00962, "epss_percentile": 0.76001}, "CVE-2019-13485": {"epss_score": 0.00962, "epss_percentile": 0.76001}, "CVE-2019-13486": {"epss_score": 0.00962, "epss_percentile": 0.76001}, "CVE-2019-13488": {"epss_score": 0.0025, "epss_percentile": 0.48225}, "CVE-2019-13489": {"epss_score": 0.00307, "epss_percentile": 0.53524}, "CVE-2019-13493": {"epss_score": 0.00188, "epss_percentile": 0.40809}, "CVE-2019-13494": {"epss_score": 0.02794, "epss_percentile": 0.85675}, "CVE-2019-13495": {"epss_score": 0.00212, "epss_percentile": 0.43732}, "CVE-2019-13496": {"epss_score": 0.00633, "epss_percentile": 0.69754}, "CVE-2019-13497": {"epss_score": 0.01236, "epss_percentile": 0.78775}, "CVE-2019-13498": {"epss_score": 0.01492, "epss_percentile": 0.80636}, "CVE-2019-13503": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-13504": {"epss_score": 0.00205, "epss_percentile": 0.42712}, "CVE-2019-13505": {"epss_score": 0.00363, "epss_percentile": 0.57845}, "CVE-2019-13506": {"epss_score": 0.00561, "epss_percentile": 0.67661}, "CVE-2019-13507": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2019-13508": {"epss_score": 0.00573, "epss_percentile": 0.68047}, "CVE-2019-13509": {"epss_score": 0.02212, "epss_percentile": 0.84022}, "CVE-2019-13510": {"epss_score": 0.02259, "epss_percentile": 0.84179}, "CVE-2019-13511": {"epss_score": 0.00032, "epss_percentile": 0.09009}, "CVE-2019-13512": {"epss_score": 0.00145, "epss_percentile": 0.35398}, "CVE-2019-13513": {"epss_score": 0.00862, "epss_percentile": 0.74571}, "CVE-2019-13514": {"epss_score": 0.00571, "epss_percentile": 0.67978}, "CVE-2019-13515": {"epss_score": 0.00222, "epss_percentile": 0.44788}, "CVE-2019-13516": {"epss_score": 0.00088, "epss_percentile": 0.25719}, "CVE-2019-13517": {"epss_score": 0.00222, "epss_percentile": 0.44844}, "CVE-2019-13518": {"epss_score": 0.00265, "epss_percentile": 0.49801}, "CVE-2019-13519": {"epss_score": 0.00046, "epss_percentile": 0.14142}, "CVE-2019-13520": {"epss_score": 0.00787, "epss_percentile": 0.73309}, "CVE-2019-13521": {"epss_score": 0.00046, "epss_percentile": 0.14142}, "CVE-2019-13522": {"epss_score": 0.00265, "epss_percentile": 0.49801}, "CVE-2019-13523": {"epss_score": 0.00269, "epss_percentile": 0.50168}, "CVE-2019-13524": {"epss_score": 0.00404, "epss_percentile": 0.60436}, "CVE-2019-13525": {"epss_score": 0.00157, "epss_percentile": 0.37024}, "CVE-2019-13526": {"epss_score": 0.00617, "epss_percentile": 0.69353}, "CVE-2019-13527": {"epss_score": 0.06041, "epss_percentile": 0.90429}, "CVE-2019-13528": {"epss_score": 0.00111, "epss_percentile": 0.30349}, "CVE-2019-13529": {"epss_score": 0.00151, "epss_percentile": 0.36316}, "CVE-2019-13530": {"epss_score": 0.00244, "epss_percentile": 0.47611}, "CVE-2019-13531": {"epss_score": 0.00134, "epss_percentile": 0.33824}, "CVE-2019-13532": {"epss_score": 0.02387, "epss_percentile": 0.84584}, "CVE-2019-13533": {"epss_score": 0.00276, "epss_percentile": 0.50705}, "CVE-2019-13534": {"epss_score": 0.00109, "epss_percentile": 0.30027}, "CVE-2019-13535": {"epss_score": 0.00449, "epss_percentile": 0.63034}, "CVE-2019-13536": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-2019-13537": {"epss_score": 0.00529, "epss_percentile": 0.66601}, "CVE-2019-13538": {"epss_score": 0.00232, "epss_percentile": 0.45956}, "CVE-2019-13539": {"epss_score": 0.00213, "epss_percentile": 0.43846}, "CVE-2019-13540": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-2019-13541": {"epss_score": 0.0029, "epss_percentile": 0.52096}, "CVE-2019-13542": {"epss_score": 0.00226, "epss_percentile": 0.45328}, "CVE-2019-13543": {"epss_score": 0.00665, "epss_percentile": 0.70672}, "CVE-2019-13544": {"epss_score": 0.00401, "epss_percentile": 0.60215}, "CVE-2019-13545": {"epss_score": 0.0029, "epss_percentile": 0.52096}, "CVE-2019-13546": {"epss_score": 0.00094, "epss_percentile": 0.26971}, "CVE-2019-13547": {"epss_score": 0.00288, "epss_percentile": 0.51925}, "CVE-2019-13548": {"epss_score": 0.03809, "epss_percentile": 0.87754}, "CVE-2019-13549": {"epss_score": 0.00343, "epss_percentile": 0.56407}, "CVE-2019-13550": {"epss_score": 0.00726, "epss_percentile": 0.72081}, "CVE-2019-13551": {"epss_score": 0.00992, "epss_percentile": 0.76399}, "CVE-2019-13552": {"epss_score": 0.01498, "epss_percentile": 0.80698}, "CVE-2019-13553": {"epss_score": 0.00184, "epss_percentile": 0.40395}, "CVE-2019-13554": {"epss_score": 0.00231, "epss_percentile": 0.45803}, "CVE-2019-13555": {"epss_score": 0.0051, "epss_percentile": 0.65783}, "CVE-2019-13556": {"epss_score": 0.01112, "epss_percentile": 0.77675}, "CVE-2019-13557": {"epss_score": 0.00168, "epss_percentile": 0.38455}, "CVE-2019-13558": {"epss_score": 0.00797, "epss_percentile": 0.73496}, "CVE-2019-13559": {"epss_score": 0.00076, "epss_percentile": 0.23255}, "CVE-2019-13560": {"epss_score": 0.02078, "epss_percentile": 0.83517}, "CVE-2019-13561": {"epss_score": 0.21756, "epss_percentile": 0.95555}, "CVE-2019-13562": {"epss_score": 0.00785, "epss_percentile": 0.73258}, "CVE-2019-13563": {"epss_score": 0.0017, "epss_percentile": 0.38699}, "CVE-2019-13564": {"epss_score": 0.00522, "epss_percentile": 0.66272}, "CVE-2019-13565": {"epss_score": 0.03132, "epss_percentile": 0.86475}, "CVE-2019-13566": {"epss_score": 0.00889, "epss_percentile": 0.75014}, "CVE-2019-13567": {"epss_score": 0.01509, "epss_percentile": 0.80768}, "CVE-2019-13568": {"epss_score": 0.00549, "epss_percentile": 0.67303}, "CVE-2019-13569": {"epss_score": 0.02692, "epss_percentile": 0.85438}, "CVE-2019-13570": {"epss_score": 0.0064, "epss_percentile": 0.69972}, "CVE-2019-13571": {"epss_score": 0.02868, "epss_percentile": 0.85866}, "CVE-2019-13572": {"epss_score": 0.00652, "epss_percentile": 0.70315}, "CVE-2019-13573": {"epss_score": 0.04723, "epss_percentile": 0.89057}, "CVE-2019-13574": {"epss_score": 0.29491, "epss_percentile": 0.96448}, "CVE-2019-13575": {"epss_score": 0.02087, "epss_percentile": 0.83553}, "CVE-2019-13577": {"epss_score": 0.41114, "epss_percentile": 0.97255}, "CVE-2019-13578": {"epss_score": 0.03036, "epss_percentile": 0.86261}, "CVE-2019-13581": {"epss_score": 0.03745, "epss_percentile": 0.8766}, "CVE-2019-13582": {"epss_score": 0.01203, "epss_percentile": 0.78498}, "CVE-2019-13584": {"epss_score": 0.00715, "epss_percentile": 0.71836}, "CVE-2019-13585": {"epss_score": 0.03314, "epss_percentile": 0.86897}, "CVE-2019-13588": {"epss_score": 0.0028, "epss_percentile": 0.51094}, "CVE-2019-13589": {"epss_score": 0.06233, "epss_percentile": 0.90588}, "CVE-2019-13590": {"epss_score": 0.00237, "epss_percentile": 0.46666}, "CVE-2019-13594": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-13597": {"epss_score": 0.50447, "epss_percentile": 0.97737}, "CVE-2019-13598": {"epss_score": 0.07684, "epss_percentile": 0.91625}, "CVE-2019-13599": {"epss_score": 0.04574, "epss_percentile": 0.88866}, "CVE-2019-13602": {"epss_score": 0.0052, "epss_percentile": 0.66186}, "CVE-2019-13603": {"epss_score": 0.00299, "epss_percentile": 0.52858}, "CVE-2019-13604": {"epss_score": 0.00218, "epss_percentile": 0.44347}, "CVE-2019-13605": {"epss_score": 0.0462, "epss_percentile": 0.8893}, "CVE-2019-13607": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-13608": {"epss_score": 0.28877, "epss_percentile": 0.96396}, "CVE-2019-13611": {"epss_score": 0.00141, "epss_percentile": 0.34843}, "CVE-2019-13612": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-13613": {"epss_score": 0.02452, "epss_percentile": 0.84789}, "CVE-2019-13614": {"epss_score": 0.02452, "epss_percentile": 0.84789}, "CVE-2019-13615": {"epss_score": 0.003, "epss_percentile": 0.52914}, "CVE-2019-13616": {"epss_score": 0.06355, "epss_percentile": 0.90694}, "CVE-2019-13617": {"epss_score": 0.00288, "epss_percentile": 0.51915}, "CVE-2019-13618": {"epss_score": 0.004, "epss_percentile": 0.60182}, "CVE-2019-13619": {"epss_score": 0.09818, "epss_percentile": 0.92715}, "CVE-2019-13623": {"epss_score": 0.04099, "epss_percentile": 0.88256}, "CVE-2019-13624": {"epss_score": 0.00428, "epss_percentile": 0.61922}, "CVE-2019-13625": {"epss_score": 0.00325, "epss_percentile": 0.5501}, "CVE-2019-13626": {"epss_score": 0.00902, "epss_percentile": 0.75191}, "CVE-2019-13627": {"epss_score": 0.00039, "epss_percentile": 0.11644}, "CVE-2019-13628": {"epss_score": 0.00145, "epss_percentile": 0.35413}, "CVE-2019-13629": {"epss_score": 0.00272, "epss_percentile": 0.50417}, "CVE-2019-13631": {"epss_score": 0.00019, "epss_percentile": 0.04333}, "CVE-2019-13633": {"epss_score": 0.00487, "epss_percentile": 0.64807}, "CVE-2019-13635": {"epss_score": 0.02805, "epss_percentile": 0.85705}, "CVE-2019-13636": {"epss_score": 0.04407, "epss_percentile": 0.88652}, "CVE-2019-13637": {"epss_score": 0.01328, "epss_percentile": 0.795}, "CVE-2019-13638": {"epss_score": 0.02089, "epss_percentile": 0.83561}, "CVE-2019-13640": {"epss_score": 0.20816, "epss_percentile": 0.95417}, "CVE-2019-13643": {"epss_score": 0.00249, "epss_percentile": 0.48038}, "CVE-2019-13644": {"epss_score": 0.00225, "epss_percentile": 0.45121}, "CVE-2019-13645": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-13646": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-13647": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-13648": {"epss_score": 0.00089, "epss_percentile": 0.25874}, "CVE-2019-13649": {"epss_score": 0.04013, "epss_percentile": 0.88116}, "CVE-2019-13650": {"epss_score": 0.04013, "epss_percentile": 0.88116}, "CVE-2019-13651": {"epss_score": 0.02665, "epss_percentile": 0.85376}, "CVE-2019-13652": {"epss_score": 0.04013, "epss_percentile": 0.88116}, "CVE-2019-13653": {"epss_score": 0.01091, "epss_percentile": 0.77458}, "CVE-2019-13655": {"epss_score": 0.00414, "epss_percentile": 0.61026}, "CVE-2019-13656": {"epss_score": 0.14551, "epss_percentile": 0.94238}, "CVE-2019-13657": {"epss_score": 0.00532, "epss_percentile": 0.6671}, "CVE-2019-13658": {"epss_score": 0.01272, "epss_percentile": 0.79078}, "CVE-2019-13659": {"epss_score": 0.00166, "epss_percentile": 0.38166}, "CVE-2019-13660": {"epss_score": 0.00226, "epss_percentile": 0.45277}, "CVE-2019-13661": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2019-13662": {"epss_score": 0.00093, "epss_percentile": 0.26642}, "CVE-2019-13663": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2019-13664": {"epss_score": 0.00068, "epss_percentile": 0.21203}, "CVE-2019-13665": {"epss_score": 0.00093, "epss_percentile": 0.26642}, "CVE-2019-13666": {"epss_score": 0.00336, "epss_percentile": 0.55903}, "CVE-2019-13667": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2019-13668": {"epss_score": 0.00344, "epss_percentile": 0.56521}, "CVE-2019-13669": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2019-13670": {"epss_score": 0.00396, "epss_percentile": 0.59921}, "CVE-2019-13671": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2019-13672": {"epss_score": 0.00254, "epss_percentile": 0.48553}, "CVE-2019-13673": {"epss_score": 0.00344, "epss_percentile": 0.56521}, "CVE-2019-13674": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2019-13675": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2019-13676": {"epss_score": 0.00228, "epss_percentile": 0.45548}, "CVE-2019-13677": {"epss_score": 0.00084, "epss_percentile": 0.24853}, "CVE-2019-13678": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2019-13679": {"epss_score": 0.00172, "epss_percentile": 0.38947}, "CVE-2019-13680": {"epss_score": 0.00208, "epss_percentile": 0.43265}, "CVE-2019-13681": {"epss_score": 0.00093, "epss_percentile": 0.26642}, "CVE-2019-13682": {"epss_score": 0.00115, "epss_percentile": 0.31033}, "CVE-2019-13683": {"epss_score": 0.00336, "epss_percentile": 0.55903}, "CVE-2019-13684": {"epss_score": 0.00266, "epss_percentile": 0.49946}, "CVE-2019-13685": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2019-13686": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2019-13687": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2019-13688": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2019-13689": {"epss_score": 0.00183, "epss_percentile": 0.40301}, "CVE-2019-13690": {"epss_score": 0.0026, "epss_percentile": 0.49186}, "CVE-2019-13691": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2019-13692": {"epss_score": 0.00088, "epss_percentile": 0.25646}, "CVE-2019-13693": {"epss_score": 0.0194, "epss_percentile": 0.82977}, "CVE-2019-13694": {"epss_score": 0.00354, "epss_percentile": 0.57205}, "CVE-2019-13695": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2019-13696": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2019-13697": {"epss_score": 0.00336, "epss_percentile": 0.55903}, "CVE-2019-13698": {"epss_score": 0.00385, "epss_percentile": 0.59197}, "CVE-2019-13699": {"epss_score": 0.0065, "epss_percentile": 0.7027}, "CVE-2019-13700": {"epss_score": 0.0065, "epss_percentile": 0.7027}, "CVE-2019-13701": {"epss_score": 0.00308, "epss_percentile": 0.53609}, "CVE-2019-13702": {"epss_score": 0.00177, "epss_percentile": 0.39628}, "CVE-2019-13703": {"epss_score": 0.00308, "epss_percentile": 0.53609}, "CVE-2019-13704": {"epss_score": 0.00231, "epss_percentile": 0.45799}, "CVE-2019-13705": {"epss_score": 0.00226, "epss_percentile": 0.45354}, "CVE-2019-13706": {"epss_score": 0.00358, "epss_percentile": 0.57518}, "CVE-2019-13707": {"epss_score": 0.00189, "epss_percentile": 0.40975}, "CVE-2019-13708": {"epss_score": 0.00308, "epss_percentile": 0.53609}, "CVE-2019-13709": {"epss_score": 0.00231, "epss_percentile": 0.45799}, "CVE-2019-13710": {"epss_score": 0.00323, "epss_percentile": 0.54915}, "CVE-2019-13711": {"epss_score": 0.00355, "epss_percentile": 0.57317}, "CVE-2019-13713": {"epss_score": 0.00452, "epss_percentile": 0.63185}, "CVE-2019-13714": {"epss_score": 0.00317, "epss_percentile": 0.54385}, "CVE-2019-13715": {"epss_score": 0.00308, "epss_percentile": 0.53609}, "CVE-2019-13716": {"epss_score": 0.00231, "epss_percentile": 0.45799}, "CVE-2019-13717": {"epss_score": 0.00317, "epss_percentile": 0.54393}, "CVE-2019-13718": {"epss_score": 0.00317, "epss_percentile": 0.54393}, "CVE-2019-13719": {"epss_score": 0.00493, "epss_percentile": 0.65056}, "CVE-2019-13720": {"epss_score": 0.89672, "epss_percentile": 0.99537}, "CVE-2019-13721": {"epss_score": 0.0065, "epss_percentile": 0.7027}, "CVE-2019-13722": {"epss_score": 0.00356, "epss_percentile": 0.57334}, "CVE-2019-13723": {"epss_score": 0.01205, "epss_percentile": 0.7851}, "CVE-2019-13724": {"epss_score": 0.00787, "epss_percentile": 0.73307}, "CVE-2019-13725": {"epss_score": 0.0702, "epss_percentile": 0.91192}, "CVE-2019-13726": {"epss_score": 0.074, "epss_percentile": 0.91452}, "CVE-2019-13727": {"epss_score": 0.01281, "epss_percentile": 0.79147}, "CVE-2019-13728": {"epss_score": 0.03148, "epss_percentile": 0.86499}, "CVE-2019-13729": {"epss_score": 0.03545, "epss_percentile": 0.87326}, "CVE-2019-13730": {"epss_score": 0.01911, "epss_percentile": 0.8283}, "CVE-2019-13732": {"epss_score": 0.03525, "epss_percentile": 0.87294}, "CVE-2019-13734": {"epss_score": 0.05904, "epss_percentile": 0.90311}, "CVE-2019-13735": {"epss_score": 0.06077, "epss_percentile": 0.90458}, "CVE-2019-13736": {"epss_score": 0.02375, "epss_percentile": 0.84543}, "CVE-2019-13737": {"epss_score": 0.02568, "epss_percentile": 0.85121}, "CVE-2019-13738": {"epss_score": 0.00889, "epss_percentile": 0.75011}, "CVE-2019-13739": {"epss_score": 0.01851, "epss_percentile": 0.82541}, "CVE-2019-13740": {"epss_score": 0.00973, "epss_percentile": 0.76164}, "CVE-2019-13741": {"epss_score": 0.01702, "epss_percentile": 0.8184}, "CVE-2019-13742": {"epss_score": 0.0234, "epss_percentile": 0.84432}, "CVE-2019-13743": {"epss_score": 0.01851, "epss_percentile": 0.82541}, "CVE-2019-13744": {"epss_score": 0.02568, "epss_percentile": 0.85121}, "CVE-2019-13745": {"epss_score": 0.0241, "epss_percentile": 0.84661}, "CVE-2019-13746": {"epss_score": 0.01851, "epss_percentile": 0.82541}, "CVE-2019-13747": {"epss_score": 0.02356, "epss_percentile": 0.84484}, "CVE-2019-13748": {"epss_score": 0.00846, "epss_percentile": 0.74324}, "CVE-2019-13749": {"epss_score": 0.01851, "epss_percentile": 0.82541}, "CVE-2019-13750": {"epss_score": 0.00233, "epss_percentile": 0.46061}, "CVE-2019-13751": {"epss_score": 0.01395, "epss_percentile": 0.79977}, "CVE-2019-13752": {"epss_score": 0.04173, "epss_percentile": 0.88349}, "CVE-2019-13753": {"epss_score": 0.04173, "epss_percentile": 0.88349}, "CVE-2019-13754": {"epss_score": 0.00282, "epss_percentile": 0.51218}, "CVE-2019-13755": {"epss_score": 0.01851, "epss_percentile": 0.82541}, "CVE-2019-13756": {"epss_score": 0.01851, "epss_percentile": 0.82541}, "CVE-2019-13757": {"epss_score": 0.01851, "epss_percentile": 0.82541}, "CVE-2019-13758": {"epss_score": 0.01003, "epss_percentile": 0.76516}, "CVE-2019-13759": {"epss_score": 0.0234, "epss_percentile": 0.84432}, "CVE-2019-13761": {"epss_score": 0.0234, "epss_percentile": 0.84432}, "CVE-2019-13762": {"epss_score": 0.00032, "epss_percentile": 0.08793}, "CVE-2019-13763": {"epss_score": 0.02019, "epss_percentile": 0.83291}, "CVE-2019-13764": {"epss_score": 0.38935, "epss_percentile": 0.97128}, "CVE-2019-13765": {"epss_score": 0.00429, "epss_percentile": 0.61961}, "CVE-2019-13766": {"epss_score": 0.00457, "epss_percentile": 0.63377}, "CVE-2019-13767": {"epss_score": 0.07423, "epss_percentile": 0.91467}, "CVE-2019-13768": {"epss_score": 0.04091, "epss_percentile": 0.88237}, "CVE-2019-13915": {"epss_score": 0.00334, "epss_percentile": 0.55741}, "CVE-2019-13916": {"epss_score": 0.00257, "epss_percentile": 0.48858}, "CVE-2019-13917": {"epss_score": 0.1889, "epss_percentile": 0.95087}, "CVE-2019-13918": {"epss_score": 0.00479, "epss_percentile": 0.64439}, "CVE-2019-13919": {"epss_score": 0.00149, "epss_percentile": 0.35948}, "CVE-2019-13920": {"epss_score": 0.0012, "epss_percentile": 0.317}, "CVE-2019-13921": {"epss_score": 0.00441, "epss_percentile": 0.62664}, "CVE-2019-13922": {"epss_score": 0.00096, "epss_percentile": 0.27322}, "CVE-2019-13923": {"epss_score": 0.00416, "epss_percentile": 0.61187}, "CVE-2019-13924": {"epss_score": 0.00273, "epss_percentile": 0.50421}, "CVE-2019-13925": {"epss_score": 0.00381, "epss_percentile": 0.58975}, "CVE-2019-13926": {"epss_score": 0.00316, "epss_percentile": 0.54294}, "CVE-2019-13927": {"epss_score": 0.00592, "epss_percentile": 0.6861}, "CVE-2019-13929": {"epss_score": 0.00196, "epss_percentile": 0.41794}, "CVE-2019-13930": {"epss_score": 0.00173, "epss_percentile": 0.39091}, "CVE-2019-13931": {"epss_score": 0.00403, "epss_percentile": 0.60325}, "CVE-2019-13932": {"epss_score": 0.00369, "epss_percentile": 0.58241}, "CVE-2019-13933": {"epss_score": 0.00716, "epss_percentile": 0.71853}, "CVE-2019-13934": {"epss_score": 0.00402, "epss_percentile": 0.6028}, "CVE-2019-13935": {"epss_score": 0.00402, "epss_percentile": 0.6028}, "CVE-2019-13936": {"epss_score": 0.00402, "epss_percentile": 0.6028}, "CVE-2019-13939": {"epss_score": 0.00345, "epss_percentile": 0.56562}, "CVE-2019-13940": {"epss_score": 0.00604, "epss_percentile": 0.68954}, "CVE-2019-13941": {"epss_score": 0.00469, "epss_percentile": 0.6392}, "CVE-2019-13942": {"epss_score": 0.00201, "epss_percentile": 0.42349}, "CVE-2019-13943": {"epss_score": 0.00414, "epss_percentile": 0.61035}, "CVE-2019-13944": {"epss_score": 0.00256, "epss_percentile": 0.4884}, "CVE-2019-13945": {"epss_score": 0.00145, "epss_percentile": 0.35411}, "CVE-2019-13946": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2019-13947": {"epss_score": 0.00181, "epss_percentile": 0.40027}, "CVE-2019-13948": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-13949": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-13950": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-13951": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2019-13952": {"epss_score": 0.00403, "epss_percentile": 0.60379}, "CVE-2019-13953": {"epss_score": 0.00153, "epss_percentile": 0.36635}, "CVE-2019-13954": {"epss_score": 0.00873, "epss_percentile": 0.74749}, "CVE-2019-13955": {"epss_score": 0.00974, "epss_percentile": 0.76167}, "CVE-2019-13956": {"epss_score": 0.43409, "epss_percentile": 0.97385}, "CVE-2019-13957": {"epss_score": 0.00441, "epss_percentile": 0.62684}, "CVE-2019-13959": {"epss_score": 0.00312, "epss_percentile": 0.53966}, "CVE-2019-13960": {"epss_score": 0.00285, "epss_percentile": 0.51516}, "CVE-2019-13961": {"epss_score": 0.0014, "epss_percentile": 0.34718}, "CVE-2019-13962": {"epss_score": 0.03288, "epss_percentile": 0.8683}, "CVE-2019-13965": {"epss_score": 0.00469, "epss_percentile": 0.63917}, "CVE-2019-13966": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-13967": {"epss_score": 0.00716, "epss_percentile": 0.71856}, "CVE-2019-13969": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2019-13970": {"epss_score": 0.00506, "epss_percentile": 0.65625}, "CVE-2019-13971": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-13972": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-13973": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-13974": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-13975": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-13976": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-13977": {"epss_score": 0.00768, "epss_percentile": 0.72963}, "CVE-2019-13978": {"epss_score": 0.00285, "epss_percentile": 0.51516}, "CVE-2019-13979": {"epss_score": 0.01077, "epss_percentile": 0.77333}, "CVE-2019-13980": {"epss_score": 0.01049, "epss_percentile": 0.77065}, "CVE-2019-13981": {"epss_score": 0.00423, "epss_percentile": 0.61617}, "CVE-2019-13982": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2019-13983": {"epss_score": 0.00256, "epss_percentile": 0.48737}, "CVE-2019-13984": {"epss_score": 0.0255, "epss_percentile": 0.85075}, "CVE-2019-13988": {"epss_score": 4e-05, "epss_percentile": 0.00139}, "CVE-2019-13989": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2019-13990": {"epss_score": 0.08578, "epss_percentile": 0.92131}, "CVE-2019-13991": {"epss_score": 0.00122, "epss_percentile": 0.3212}, "CVE-2019-13992": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-13994": {"epss_score": 0.00111, "epss_percentile": 0.30321}, "CVE-2019-13995": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2019-13998": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2019-13999": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2019-14000": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2019-14001": {"epss_score": 0.0002, "epss_percentile": 0.04594}, "CVE-2019-14002": {"epss_score": 0.00025, "epss_percentile": 0.06204}, "CVE-2019-14003": {"epss_score": 0.00369, "epss_percentile": 0.58256}, "CVE-2019-14004": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-14005": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-14006": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-14007": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2019-14008": {"epss_score": 0.00246, "epss_percentile": 0.47772}, "CVE-2019-14009": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14010": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2019-14011": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2019-14012": {"epss_score": 0.00246, "epss_percentile": 0.47772}, "CVE-2019-14013": {"epss_score": 0.00396, "epss_percentile": 0.59859}, "CVE-2019-14014": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-14015": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2019-14016": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-14017": {"epss_score": 0.00427, "epss_percentile": 0.61873}, "CVE-2019-14018": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14019": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2019-14020": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2019-14021": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14022": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2019-14023": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14024": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14025": {"epss_score": 0.00048, "epss_percentile": 0.15143}, "CVE-2019-14026": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2019-14027": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2019-14028": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14029": {"epss_score": 0.0009, "epss_percentile": 0.26039}, "CVE-2019-14030": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14031": {"epss_score": 0.00427, "epss_percentile": 0.61873}, "CVE-2019-14032": {"epss_score": 0.0009, "epss_percentile": 0.26039}, "CVE-2019-14033": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2019-14034": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2019-14036": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2019-14037": {"epss_score": 0.00096, "epss_percentile": 0.27446}, "CVE-2019-14038": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-14039": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-14040": {"epss_score": 0.01431, "epss_percentile": 0.80246}, "CVE-2019-14041": {"epss_score": 0.01229, "epss_percentile": 0.78713}, "CVE-2019-14042": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-14043": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-14044": {"epss_score": 0.00034, "epss_percentile": 0.09698}, "CVE-2019-14045": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-14046": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14047": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14048": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-14049": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14050": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2019-14051": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2019-14052": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-14053": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-14054": {"epss_score": 0.00025, "epss_percentile": 0.06233}, "CVE-2019-14055": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2019-14056": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14057": {"epss_score": 0.00286, "epss_percentile": 0.5172}, "CVE-2019-14060": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14061": {"epss_score": 0.00286, "epss_percentile": 0.51711}, "CVE-2019-14062": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-14063": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2019-14065": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14066": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14067": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2019-14068": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-14070": {"epss_score": 0.00029, "epss_percentile": 0.07611}, "CVE-2019-14071": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14072": {"epss_score": 0.00073, "epss_percentile": 0.22568}, "CVE-2019-14073": {"epss_score": 0.00309, "epss_percentile": 0.53673}, "CVE-2019-14074": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2019-14075": {"epss_score": 0.0004, "epss_percentile": 0.1193}, "CVE-2019-14076": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2019-14077": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-14078": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-14079": {"epss_score": 0.02099, "epss_percentile": 0.83593}, "CVE-2019-14080": {"epss_score": 0.0037, "epss_percentile": 0.58306}, "CVE-2019-14081": {"epss_score": 0.00033, "epss_percentile": 0.09283}, "CVE-2019-14082": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2019-14083": {"epss_score": 0.00396, "epss_percentile": 0.59859}, "CVE-2019-14085": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14086": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-14087": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14088": {"epss_score": 0.00042, "epss_percentile": 0.12882}, "CVE-2019-14089": {"epss_score": 0.00016, "epss_percentile": 0.02637}, "CVE-2019-14091": {"epss_score": 0.00033, "epss_percentile": 0.09339}, "CVE-2019-14092": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2019-14093": {"epss_score": 0.0011, "epss_percentile": 0.30112}, "CVE-2019-14094": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-14095": {"epss_score": 0.00379, "epss_percentile": 0.58857}, "CVE-2019-14097": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-14098": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-14099": {"epss_score": 0.0011, "epss_percentile": 0.30112}, "CVE-2019-14100": {"epss_score": 0.0011, "epss_percentile": 0.30112}, "CVE-2019-14101": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-14104": {"epss_score": 0.00033, "epss_percentile": 0.09283}, "CVE-2019-14105": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14110": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-14111": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-14112": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-14113": {"epss_score": 0.00427, "epss_percentile": 0.61873}, "CVE-2019-14114": {"epss_score": 0.00427, "epss_percentile": 0.61873}, "CVE-2019-14115": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2019-14116": {"epss_score": 0.00028, "epss_percentile": 0.07525}, "CVE-2019-14117": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2019-14119": {"epss_score": 0.0003, "epss_percentile": 0.08207}, "CVE-2019-14122": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-14123": {"epss_score": 0.00124, "epss_percentile": 0.32357}, "CVE-2019-14124": {"epss_score": 0.0011, "epss_percentile": 0.30112}, "CVE-2019-14127": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-14130": {"epss_score": 0.00129, "epss_percentile": 0.33183}, "CVE-2019-14131": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-14132": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-14134": {"epss_score": 0.00312, "epss_percentile": 0.53991}, "CVE-2019-14135": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2019-14192": {"epss_score": 0.00329, "epss_percentile": 0.55317}, "CVE-2019-14193": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-14194": {"epss_score": 0.00418, "epss_percentile": 0.61288}, "CVE-2019-14195": {"epss_score": 0.00418, "epss_percentile": 0.61288}, "CVE-2019-14196": {"epss_score": 0.00585, "epss_percentile": 0.68428}, "CVE-2019-14197": {"epss_score": 0.00491, "epss_percentile": 0.6495}, "CVE-2019-14198": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-14199": {"epss_score": 0.0054, "epss_percentile": 0.67008}, "CVE-2019-14200": {"epss_score": 0.00437, "epss_percentile": 0.62505}, "CVE-2019-14201": {"epss_score": 0.00437, "epss_percentile": 0.62505}, "CVE-2019-14202": {"epss_score": 0.00437, "epss_percentile": 0.62505}, "CVE-2019-14203": {"epss_score": 0.00437, "epss_percentile": 0.62505}, "CVE-2019-14204": {"epss_score": 0.00437, "epss_percentile": 0.62505}, "CVE-2019-14205": {"epss_score": 0.67086, "epss_percentile": 0.98493}, "CVE-2019-14206": {"epss_score": 0.01676, "epss_percentile": 0.81712}, "CVE-2019-14207": {"epss_score": 0.00049, "epss_percentile": 0.1545}, "CVE-2019-14208": {"epss_score": 0.00035, "epss_percentile": 0.10156}, "CVE-2019-14209": {"epss_score": 0.00036, "epss_percentile": 0.10227}, "CVE-2019-14210": {"epss_score": 0.00028, "epss_percentile": 0.0722}, "CVE-2019-14211": {"epss_score": 0.00021, "epss_percentile": 0.0489}, "CVE-2019-14212": {"epss_score": 0.00047, "epss_percentile": 0.14657}, "CVE-2019-14213": {"epss_score": 0.0006, "epss_percentile": 0.19033}, "CVE-2019-14214": {"epss_score": 0.00028, "epss_percentile": 0.0722}, "CVE-2019-14215": {"epss_score": 0.00028, "epss_percentile": 0.0722}, "CVE-2019-14216": {"epss_score": 0.003, "epss_percentile": 0.52964}, "CVE-2019-14220": {"epss_score": 0.01152, "epss_percentile": 0.78046}, "CVE-2019-14221": {"epss_score": 0.00224, "epss_percentile": 0.45055}, "CVE-2019-14222": {"epss_score": 0.02579, "epss_percentile": 0.85148}, "CVE-2019-14223": {"epss_score": 0.59279, "epss_percentile": 0.98158}, "CVE-2019-14224": {"epss_score": 0.00884, "epss_percentile": 0.74931}, "CVE-2019-14225": {"epss_score": 0.00221, "epss_percentile": 0.44668}, "CVE-2019-14226": {"epss_score": 0.00195, "epss_percentile": 0.41662}, "CVE-2019-14227": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2019-14228": {"epss_score": 0.00113, "epss_percentile": 0.30583}, "CVE-2019-14230": {"epss_score": 0.06645, "epss_percentile": 0.90912}, "CVE-2019-14231": {"epss_score": 0.06645, "epss_percentile": 0.90912}, "CVE-2019-14232": {"epss_score": 0.03026, "epss_percentile": 0.86241}, "CVE-2019-14233": {"epss_score": 0.04536, "epss_percentile": 0.88817}, "CVE-2019-14234": {"epss_score": 0.21486, "epss_percentile": 0.95525}, "CVE-2019-14235": {"epss_score": 0.04536, "epss_percentile": 0.88817}, "CVE-2019-14236": {"epss_score": 0.00935, "epss_percentile": 0.75662}, "CVE-2019-14237": {"epss_score": 0.00935, "epss_percentile": 0.75662}, "CVE-2019-14238": {"epss_score": 0.00065, "epss_percentile": 0.2061}, "CVE-2019-14239": {"epss_score": 0.00065, "epss_percentile": 0.2061}, "CVE-2019-14240": {"epss_score": 0.00334, "epss_percentile": 0.55714}, "CVE-2019-14241": {"epss_score": 0.37036, "epss_percentile": 0.97016}, "CVE-2019-14242": {"epss_score": 0.00031, "epss_percentile": 0.08621}, "CVE-2019-14243": {"epss_score": 0.00378, "epss_percentile": 0.58801}, "CVE-2019-14245": {"epss_score": 0.00377, "epss_percentile": 0.58729}, "CVE-2019-14246": {"epss_score": 0.00695, "epss_percentile": 0.71372}, "CVE-2019-14247": {"epss_score": 0.00209, "epss_percentile": 0.4339}, "CVE-2019-14248": {"epss_score": 0.00137, "epss_percentile": 0.3431}, "CVE-2019-14249": {"epss_score": 0.00472, "epss_percentile": 0.64064}, "CVE-2019-14250": {"epss_score": 0.00254, "epss_percentile": 0.48563}, "CVE-2019-14251": {"epss_score": 0.64701, "epss_percentile": 0.98389}, "CVE-2019-14252": {"epss_score": 0.00995, "epss_percentile": 0.76434}, "CVE-2019-14253": {"epss_score": 0.00207, "epss_percentile": 0.43134}, "CVE-2019-14254": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-14255": {"epss_score": 0.00555, "epss_percentile": 0.6747}, "CVE-2019-14257": {"epss_score": 0.00045, "epss_percentile": 0.13896}, "CVE-2019-14258": {"epss_score": 0.00641, "epss_percentile": 0.70011}, "CVE-2019-14259": {"epss_score": 0.03399, "epss_percentile": 0.87065}, "CVE-2019-14260": {"epss_score": 0.02896, "epss_percentile": 0.85927}, "CVE-2019-14261": {"epss_score": 0.01256, "epss_percentile": 0.78936}, "CVE-2019-14262": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2019-14266": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2019-14267": {"epss_score": 0.17319, "epss_percentile": 0.94822}, "CVE-2019-14268": {"epss_score": 0.00589, "epss_percentile": 0.68533}, "CVE-2019-14270": {"epss_score": 0.00056, "epss_percentile": 0.17809}, "CVE-2019-14271": {"epss_score": 0.72198, "epss_percentile": 0.98699}, "CVE-2019-14272": {"epss_score": 0.00413, "epss_percentile": 0.61013}, "CVE-2019-14273": {"epss_score": 0.00336, "epss_percentile": 0.55933}, "CVE-2019-14274": {"epss_score": 0.00126, "epss_percentile": 0.32754}, "CVE-2019-14275": {"epss_score": 0.00119, "epss_percentile": 0.31589}, "CVE-2019-14276": {"epss_score": 0.00319, "epss_percentile": 0.54475}, "CVE-2019-14277": {"epss_score": 0.12517, "epss_percentile": 0.93705}, "CVE-2019-14278": {"epss_score": 0.00505, "epss_percentile": 0.65553}, "CVE-2019-14280": {"epss_score": 0.15895, "epss_percentile": 0.94526}, "CVE-2019-14281": {"epss_score": 0.01216, "epss_percentile": 0.78596}, "CVE-2019-14282": {"epss_score": 0.01431, "epss_percentile": 0.80243}, "CVE-2019-14283": {"epss_score": 0.00051, "epss_percentile": 0.16143}, "CVE-2019-14284": {"epss_score": 0.00048, "epss_percentile": 0.15052}, "CVE-2019-14286": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-14287": {"epss_score": 0.86126, "epss_percentile": 0.99369}, "CVE-2019-14288": {"epss_score": 0.00201, "epss_percentile": 0.42349}, "CVE-2019-14289": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2019-14290": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2019-14291": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2019-14292": {"epss_score": 0.00168, "epss_percentile": 0.38408}, "CVE-2019-14293": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2019-14294": {"epss_score": 0.00194, "epss_percentile": 0.41534}, "CVE-2019-14295": {"epss_score": 0.0025, "epss_percentile": 0.4821}, "CVE-2019-14296": {"epss_score": 0.0046, "epss_percentile": 0.63522}, "CVE-2019-14297": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2019-14298": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2019-14299": {"epss_score": 0.00371, "epss_percentile": 0.58415}, "CVE-2019-14300": {"epss_score": 0.01287, "epss_percentile": 0.79192}, "CVE-2019-14301": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2019-14302": {"epss_score": 0.00134, "epss_percentile": 0.33775}, "CVE-2019-14303": {"epss_score": 0.0054, "epss_percentile": 0.66997}, "CVE-2019-14304": {"epss_score": 0.00211, "epss_percentile": 0.43671}, "CVE-2019-14305": {"epss_score": 0.01282, "epss_percentile": 0.79153}, "CVE-2019-14306": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2019-14307": {"epss_score": 0.01221, "epss_percentile": 0.78652}, "CVE-2019-14308": {"epss_score": 0.01287, "epss_percentile": 0.79192}, "CVE-2019-14309": {"epss_score": 0.00344, "epss_percentile": 0.56504}, "CVE-2019-14310": {"epss_score": 0.00521, "epss_percentile": 0.66247}, "CVE-2019-14312": {"epss_score": 0.39761, "epss_percentile": 0.97178}, "CVE-2019-14313": {"epss_score": 0.0414, "epss_percentile": 0.88311}, "CVE-2019-14314": {"epss_score": 0.32413, "epss_percentile": 0.96698}, "CVE-2019-14315": {"epss_score": 0.00189, "epss_percentile": 0.40934}, "CVE-2019-14317": {"epss_score": 0.00392, "epss_percentile": 0.59653}, "CVE-2019-14318": {"epss_score": 0.02374, "epss_percentile": 0.84538}, "CVE-2019-14319": {"epss_score": 0.01452, "epss_percentile": 0.80368}, "CVE-2019-14322": {"epss_score": 0.90059, "epss_percentile": 0.99559}, "CVE-2019-14323": {"epss_score": 0.00297, "epss_percentile": 0.52695}, "CVE-2019-14326": {"epss_score": 0.00614, "epss_percentile": 0.69269}, "CVE-2019-14327": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2019-14328": {"epss_score": 0.00473, "epss_percentile": 0.64086}, "CVE-2019-14329": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2019-14330": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2019-14331": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2019-14332": {"epss_score": 0.00058, "epss_percentile": 0.18302}, "CVE-2019-14333": {"epss_score": 0.0004, "epss_percentile": 0.11941}, "CVE-2019-14334": {"epss_score": 0.00026, "epss_percentile": 0.06726}, "CVE-2019-14335": {"epss_score": 0.00095, "epss_percentile": 0.27215}, "CVE-2019-14336": {"epss_score": 0.00054, "epss_percentile": 0.17048}, "CVE-2019-14337": {"epss_score": 0.00083, "epss_percentile": 0.24704}, "CVE-2019-14338": {"epss_score": 0.0069, "epss_percentile": 0.7124}, "CVE-2019-14339": {"epss_score": 0.04518, "epss_percentile": 0.88794}, "CVE-2019-14343": {"epss_score": 0.00378, "epss_percentile": 0.58837}, "CVE-2019-14344": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-14345": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2019-14346": {"epss_score": 0.00401, "epss_percentile": 0.60244}, "CVE-2019-14347": {"epss_score": 0.03084, "epss_percentile": 0.86379}, "CVE-2019-14348": {"epss_score": 0.42638, "epss_percentile": 0.97344}, "CVE-2019-14349": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-14350": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-14351": {"epss_score": 0.00575, "epss_percentile": 0.68108}, "CVE-2019-14352": {"epss_score": 0.00189, "epss_percentile": 0.40936}, "CVE-2019-14353": {"epss_score": 0.00064, "epss_percentile": 0.20301}, "CVE-2019-14354": {"epss_score": 0.00058, "epss_percentile": 0.18393}, "CVE-2019-14355": {"epss_score": 0.00058, "epss_percentile": 0.18393}, "CVE-2019-14356": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2019-14357": {"epss_score": 0.00058, "epss_percentile": 0.18393}, "CVE-2019-14358": {"epss_score": 0.00138, "epss_percentile": 0.3443}, "CVE-2019-14359": {"epss_score": 0.00058, "epss_percentile": 0.18393}, "CVE-2019-14360": {"epss_score": 0.00138, "epss_percentile": 0.3443}, "CVE-2019-14362": {"epss_score": 0.00287, "epss_percentile": 0.51789}, "CVE-2019-14363": {"epss_score": 0.01298, "epss_percentile": 0.79273}, "CVE-2019-14364": {"epss_score": 0.0026, "epss_percentile": 0.492}, "CVE-2019-14365": {"epss_score": 0.01192, "epss_percentile": 0.78398}, "CVE-2019-14366": {"epss_score": 0.00737, "epss_percentile": 0.72324}, "CVE-2019-14367": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2019-14368": {"epss_score": 0.00254, "epss_percentile": 0.48551}, "CVE-2019-14369": {"epss_score": 0.00193, "epss_percentile": 0.4146}, "CVE-2019-14370": {"epss_score": 0.00142, "epss_percentile": 0.35045}, "CVE-2019-14371": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2019-14372": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2019-14373": {"epss_score": 0.00168, "epss_percentile": 0.38503}, "CVE-2019-14378": {"epss_score": 0.0868, "epss_percentile": 0.92196}, "CVE-2019-14379": {"epss_score": 0.01455, "epss_percentile": 0.8039}, "CVE-2019-14380": {"epss_score": 0.00294, "epss_percentile": 0.52397}, "CVE-2019-14381": {"epss_score": 0.0039, "epss_percentile": 0.59533}, "CVE-2019-14382": {"epss_score": 0.00531, "epss_percentile": 0.66645}, "CVE-2019-14383": {"epss_score": 0.0044, "epss_percentile": 0.62614}, "CVE-2019-14386": {"epss_score": 0.00333, "epss_percentile": 0.5568}, "CVE-2019-14387": {"epss_score": 0.00349, "epss_percentile": 0.56893}, "CVE-2019-14388": {"epss_score": 0.00471, "epss_percentile": 0.64012}, "CVE-2019-14389": {"epss_score": 0.00039, "epss_percentile": 0.11842}, "CVE-2019-14390": {"epss_score": 0.00333, "epss_percentile": 0.5568}, "CVE-2019-14391": {"epss_score": 0.00082, "epss_percentile": 0.24493}, "CVE-2019-14392": {"epss_score": 0.02592, "epss_percentile": 0.85185}, "CVE-2019-14393": {"epss_score": 0.00085, "epss_percentile": 0.25134}, "CVE-2019-14394": {"epss_score": 0.00047, "epss_percentile": 0.14879}, "CVE-2019-14395": {"epss_score": 0.00051, "epss_percentile": 0.16044}, "CVE-2019-14396": {"epss_score": 0.00082, "epss_percentile": 0.24493}, "CVE-2019-14397": {"epss_score": 0.0047, "epss_percentile": 0.63977}, "CVE-2019-14398": {"epss_score": 0.01414, "epss_percentile": 0.80125}, "CVE-2019-14399": {"epss_score": 0.00047, "epss_percentile": 0.14879}, "CVE-2019-14400": {"epss_score": 0.00038, "epss_percentile": 0.11286}, "CVE-2019-14401": {"epss_score": 0.01324, "epss_percentile": 0.79463}, "CVE-2019-14402": {"epss_score": 0.00082, "epss_percentile": 0.24493}, "CVE-2019-14403": {"epss_score": 0.00222, "epss_percentile": 0.44741}, "CVE-2019-14404": {"epss_score": 0.00082, "epss_percentile": 0.24563}, "CVE-2019-14405": {"epss_score": 0.01324, "epss_percentile": 0.79463}, "CVE-2019-14406": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2019-14407": {"epss_score": 0.00323, "epss_percentile": 0.549}, "CVE-2019-14408": {"epss_score": 0.00314, "epss_percentile": 0.54159}, "CVE-2019-14409": {"epss_score": 0.00082, "epss_percentile": 0.24563}, "CVE-2019-14410": {"epss_score": 0.00082, "epss_percentile": 0.24493}, "CVE-2019-14411": {"epss_score": 0.0047, "epss_percentile": 0.63977}, "CVE-2019-14412": {"epss_score": 0.00082, "epss_percentile": 0.24493}, "CVE-2019-14413": {"epss_score": 0.00314, "epss_percentile": 0.54159}, "CVE-2019-14414": {"epss_score": 0.00082, "epss_percentile": 0.24493}, "CVE-2019-14415": {"epss_score": 0.00369, "epss_percentile": 0.58265}, "CVE-2019-14416": {"epss_score": 0.00997, "epss_percentile": 0.76458}, "CVE-2019-14417": {"epss_score": 0.00465, "epss_percentile": 0.63746}, "CVE-2019-14418": {"epss_score": 0.04995, "epss_percentile": 0.89372}, "CVE-2019-14422": {"epss_score": 0.05438, "epss_percentile": 0.89882}, "CVE-2019-14423": {"epss_score": 0.07781, "epss_percentile": 0.91679}, "CVE-2019-14424": {"epss_score": 0.00328, "epss_percentile": 0.55157}, "CVE-2019-14427": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2019-14430": {"epss_score": 0.01848, "epss_percentile": 0.82528}, "CVE-2019-14431": {"epss_score": 0.055, "epss_percentile": 0.89937}, "CVE-2019-14432": {"epss_score": 0.02103, "epss_percentile": 0.8361}, "CVE-2019-14433": {"epss_score": 0.01327, "epss_percentile": 0.79485}, "CVE-2019-14437": {"epss_score": 0.00343, "epss_percentile": 0.56454}, "CVE-2019-14438": {"epss_score": 0.00494, "epss_percentile": 0.6508}, "CVE-2019-14439": {"epss_score": 0.10318, "epss_percentile": 0.92942}, "CVE-2019-14441": {"epss_score": 0.00325, "epss_percentile": 0.55001}, "CVE-2019-14442": {"epss_score": 0.00222, "epss_percentile": 0.44729}, "CVE-2019-14443": {"epss_score": 0.00505, "epss_percentile": 0.65597}, "CVE-2019-14444": {"epss_score": 0.00429, "epss_percentile": 0.61995}, "CVE-2019-14449": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2019-14450": {"epss_score": 0.47493, "epss_percentile": 0.97589}, "CVE-2019-14451": {"epss_score": 0.03752, "epss_percentile": 0.87677}, "CVE-2019-14452": {"epss_score": 0.03043, "epss_percentile": 0.86276}, "CVE-2019-14453": {"epss_score": 0.00385, "epss_percentile": 0.59228}, "CVE-2019-14454": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2019-14456": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-14457": {"epss_score": 0.00672, "epss_percentile": 0.70821}, "CVE-2019-14458": {"epss_score": 0.00622, "epss_percentile": 0.69504}, "CVE-2019-14459": {"epss_score": 0.02072, "epss_percentile": 0.83491}, "CVE-2019-14462": {"epss_score": 0.00917, "epss_percentile": 0.75435}, "CVE-2019-14463": {"epss_score": 0.00917, "epss_percentile": 0.75435}, "CVE-2019-14464": {"epss_score": 0.00406, "epss_percentile": 0.60537}, "CVE-2019-14465": {"epss_score": 0.00511, "epss_percentile": 0.6583}, "CVE-2019-14466": {"epss_score": 0.00238, "epss_percentile": 0.46749}, "CVE-2019-14467": {"epss_score": 0.08613, "epss_percentile": 0.92153}, "CVE-2019-14468": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2019-14469": {"epss_score": 0.00254, "epss_percentile": 0.48499}, "CVE-2019-14470": {"epss_score": 0.30592, "epss_percentile": 0.96554}, "CVE-2019-14471": {"epss_score": 0.00187, "epss_percentile": 0.40733}, "CVE-2019-14472": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-14473": {"epss_score": 0.00615, "epss_percentile": 0.69294}, "CVE-2019-14474": {"epss_score": 0.00218, "epss_percentile": 0.44398}, "CVE-2019-14475": {"epss_score": 0.00488, "epss_percentile": 0.64834}, "CVE-2019-14476": {"epss_score": 0.00223, "epss_percentile": 0.44897}, "CVE-2019-14477": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2019-14478": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2019-14479": {"epss_score": 0.06655, "epss_percentile": 0.90919}, "CVE-2019-14480": {"epss_score": 0.00291, "epss_percentile": 0.52152}, "CVE-2019-14481": {"epss_score": 0.00115, "epss_percentile": 0.30976}, "CVE-2019-14482": {"epss_score": 0.02181, "epss_percentile": 0.83902}, "CVE-2019-14483": {"epss_score": 0.0039, "epss_percentile": 0.59545}, "CVE-2019-14486": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2019-14491": {"epss_score": 0.00537, "epss_percentile": 0.66902}, "CVE-2019-14492": {"epss_score": 0.00528, "epss_percentile": 0.66546}, "CVE-2019-14493": {"epss_score": 0.00606, "epss_percentile": 0.69001}, "CVE-2019-14494": {"epss_score": 0.01969, "epss_percentile": 0.83092}, "CVE-2019-14495": {"epss_score": 0.00538, "epss_percentile": 0.66941}, "CVE-2019-14496": {"epss_score": 0.00346, "epss_percentile": 0.56619}, "CVE-2019-14497": {"epss_score": 0.00346, "epss_percentile": 0.56619}, "CVE-2019-14498": {"epss_score": 0.0035, "epss_percentile": 0.56926}, "CVE-2019-14510": {"epss_score": 0.00088, "epss_percentile": 0.25648}, "CVE-2019-14511": {"epss_score": 0.00754, "epss_percentile": 0.72702}, "CVE-2019-14512": {"epss_score": 0.00538, "epss_percentile": 0.66932}, "CVE-2019-14513": {"epss_score": 0.00047, "epss_percentile": 0.14806}, "CVE-2019-14514": {"epss_score": 0.10369, "epss_percentile": 0.92961}, "CVE-2019-14516": {"epss_score": 0.00154, "epss_percentile": 0.36673}, "CVE-2019-14517": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-14518": {"epss_score": 0.00346, "epss_percentile": 0.56622}, "CVE-2019-14521": {"epss_score": 0.00316, "epss_percentile": 0.54225}, "CVE-2019-14523": {"epss_score": 0.00448, "epss_percentile": 0.63023}, "CVE-2019-14524": {"epss_score": 0.00484, "epss_percentile": 0.64643}, "CVE-2019-14525": {"epss_score": 0.00437, "epss_percentile": 0.6252}, "CVE-2019-14526": {"epss_score": 0.00157, "epss_percentile": 0.37019}, "CVE-2019-14527": {"epss_score": 0.00647, "epss_percentile": 0.7019}, "CVE-2019-14528": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2019-14529": {"epss_score": 0.02108, "epss_percentile": 0.8364}, "CVE-2019-14530": {"epss_score": 0.78542, "epss_percentile": 0.98991}, "CVE-2019-14531": {"epss_score": 0.00397, "epss_percentile": 0.60043}, "CVE-2019-14532": {"epss_score": 0.00609, "epss_percentile": 0.69097}, "CVE-2019-14533": {"epss_score": 0.00298, "epss_percentile": 0.52795}, "CVE-2019-14534": {"epss_score": 0.00334, "epss_percentile": 0.55684}, "CVE-2019-14535": {"epss_score": 0.0035, "epss_percentile": 0.56926}, "CVE-2019-14537": {"epss_score": 0.14963, "epss_percentile": 0.94335}, "CVE-2019-14540": {"epss_score": 0.07082, "epss_percentile": 0.91239}, "CVE-2019-14541": {"epss_score": 0.00296, "epss_percentile": 0.52543}, "CVE-2019-14544": {"epss_score": 0.00304, "epss_percentile": 0.53275}, "CVE-2019-14546": {"epss_score": 0.00372, "epss_percentile": 0.58443}, "CVE-2019-14547": {"epss_score": 0.0036, "epss_percentile": 0.57627}, "CVE-2019-14548": {"epss_score": 0.0036, "epss_percentile": 0.57627}, "CVE-2019-14549": {"epss_score": 0.0036, "epss_percentile": 0.57627}, "CVE-2019-14550": {"epss_score": 0.00264, "epss_percentile": 0.49737}, "CVE-2019-14551": {"epss_score": 0.00375, "epss_percentile": 0.58596}, "CVE-2019-14553": {"epss_score": 0.00113, "epss_percentile": 0.30652}, "CVE-2019-14556": {"epss_score": 0.00049, "epss_percentile": 0.15309}, "CVE-2019-14557": {"epss_score": 0.00143, "epss_percentile": 0.35187}, "CVE-2019-14558": {"epss_score": 0.0012, "epss_percentile": 0.31764}, "CVE-2019-14559": {"epss_score": 0.00688, "epss_percentile": 0.71194}, "CVE-2019-14562": {"epss_score": 0.00044, "epss_percentile": 0.13585}, "CVE-2019-14563": {"epss_score": 0.00054, "epss_percentile": 0.17272}, "CVE-2019-14565": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2019-14566": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2019-14568": {"epss_score": 0.00126, "epss_percentile": 0.32703}, "CVE-2019-14569": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2019-14570": {"epss_score": 0.00063, "epss_percentile": 0.20082}, "CVE-2019-14574": {"epss_score": 0.00147, "epss_percentile": 0.35697}, "CVE-2019-14575": {"epss_score": 0.00061, "epss_percentile": 0.19398}, "CVE-2019-14584": {"epss_score": 0.00227, "epss_percentile": 0.45378}, "CVE-2019-14586": {"epss_score": 0.00135, "epss_percentile": 0.33969}, "CVE-2019-14587": {"epss_score": 0.00188, "epss_percentile": 0.40831}, "CVE-2019-14590": {"epss_score": 0.00194, "epss_percentile": 0.41532}, "CVE-2019-14591": {"epss_score": 0.00158, "epss_percentile": 0.37191}, "CVE-2019-14596": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2019-14598": {"epss_score": 0.00255, "epss_percentile": 0.48728}, "CVE-2019-14599": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2019-14600": {"epss_score": 0.00065, "epss_percentile": 0.20584}, "CVE-2019-14601": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2019-14602": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2019-14603": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2019-14604": {"epss_score": 0.00166, "epss_percentile": 0.38244}, "CVE-2019-14605": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2019-14607": {"epss_score": 0.00154, "epss_percentile": 0.36719}, "CVE-2019-14608": {"epss_score": 0.00187, "epss_percentile": 0.40728}, "CVE-2019-14609": {"epss_score": 0.0015, "epss_percentile": 0.36147}, "CVE-2019-14610": {"epss_score": 0.00187, "epss_percentile": 0.40728}, "CVE-2019-14611": {"epss_score": 0.00133, "epss_percentile": 0.33642}, "CVE-2019-14612": {"epss_score": 0.00133, "epss_percentile": 0.33642}, "CVE-2019-14613": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2019-14615": {"epss_score": 0.05005, "epss_percentile": 0.89382}, "CVE-2019-14620": {"epss_score": 0.00097, "epss_percentile": 0.27493}, "CVE-2019-14625": {"epss_score": 0.00049, "epss_percentile": 0.15309}, "CVE-2019-14626": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2019-14629": {"epss_score": 0.00039, "epss_percentile": 0.11578}, "CVE-2019-14630": {"epss_score": 0.00085, "epss_percentile": 0.25068}, "CVE-2019-14652": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2019-14653": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-14654": {"epss_score": 0.00453, "epss_percentile": 0.63219}, "CVE-2019-14656": {"epss_score": 0.00427, "epss_percentile": 0.61876}, "CVE-2019-14657": {"epss_score": 0.01922, "epss_percentile": 0.82903}, "CVE-2019-14662": {"epss_score": 0.00177, "epss_percentile": 0.39581}, "CVE-2019-14663": {"epss_score": 0.00177, "epss_percentile": 0.39581}, "CVE-2019-14664": {"epss_score": 0.0018, "epss_percentile": 0.39985}, "CVE-2019-14665": {"epss_score": 0.00177, "epss_percentile": 0.39581}, "CVE-2019-14666": {"epss_score": 0.02851, "epss_percentile": 0.85829}, "CVE-2019-14667": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2019-14668": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-14669": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-14670": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-14671": {"epss_score": 0.00053, "epss_percentile": 0.16685}, "CVE-2019-14672": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-14678": {"epss_score": 0.00798, "epss_percentile": 0.73511}, "CVE-2019-14679": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2019-14680": {"epss_score": 0.00114, "epss_percentile": 0.30771}, "CVE-2019-14681": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2019-14682": {"epss_score": 0.00125, "epss_percentile": 0.32588}, "CVE-2019-14683": {"epss_score": 0.00138, "epss_percentile": 0.34396}, "CVE-2019-14684": {"epss_score": 0.00394, "epss_percentile": 0.59775}, "CVE-2019-14685": {"epss_score": 0.00101, "epss_percentile": 0.28653}, "CVE-2019-14686": {"epss_score": 0.00302, "epss_percentile": 0.53091}, "CVE-2019-14687": {"epss_score": 0.00302, "epss_percentile": 0.53091}, "CVE-2019-14688": {"epss_score": 0.00479, "epss_percentile": 0.64417}, "CVE-2019-14690": {"epss_score": 0.0054, "epss_percentile": 0.67004}, "CVE-2019-14691": {"epss_score": 0.0054, "epss_percentile": 0.67004}, "CVE-2019-14692": {"epss_score": 0.0054, "epss_percentile": 0.67004}, "CVE-2019-14693": {"epss_score": 0.00802, "epss_percentile": 0.7358}, "CVE-2019-14694": {"epss_score": 0.00044, "epss_percentile": 0.13555}, "CVE-2019-14695": {"epss_score": 0.0139, "epss_percentile": 0.79946}, "CVE-2019-14696": {"epss_score": 0.13448, "epss_percentile": 0.93968}, "CVE-2019-14697": {"epss_score": 0.00288, "epss_percentile": 0.51931}, "CVE-2019-14698": {"epss_score": 0.06248, "epss_percentile": 0.90607}, "CVE-2019-14699": {"epss_score": 0.08487, "epss_percentile": 0.92079}, "CVE-2019-14700": {"epss_score": 0.00962, "epss_percentile": 0.75995}, "CVE-2019-14701": {"epss_score": 0.00564, "epss_percentile": 0.67765}, "CVE-2019-14702": {"epss_score": 0.00443, "epss_percentile": 0.6277}, "CVE-2019-14703": {"epss_score": 0.002, "epss_percentile": 0.42256}, "CVE-2019-14704": {"epss_score": 0.00588, "epss_percentile": 0.68499}, "CVE-2019-14705": {"epss_score": 0.00551, "epss_percentile": 0.67361}, "CVE-2019-14706": {"epss_score": 0.00614, "epss_percentile": 0.69269}, "CVE-2019-14707": {"epss_score": 0.02762, "epss_percentile": 0.85604}, "CVE-2019-14708": {"epss_score": 0.06741, "epss_percentile": 0.90995}, "CVE-2019-14709": {"epss_score": 0.00407, "epss_percentile": 0.60611}, "CVE-2019-14711": {"epss_score": 0.00044, "epss_percentile": 0.13502}, "CVE-2019-14712": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2019-14713": {"epss_score": 0.00053, "epss_percentile": 0.17039}, "CVE-2019-14715": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2019-14716": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2019-14717": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2019-14718": {"epss_score": 0.00066, "epss_percentile": 0.20809}, "CVE-2019-14719": {"epss_score": 0.00423, "epss_percentile": 0.61601}, "CVE-2019-14721": {"epss_score": 0.00621, "epss_percentile": 0.69478}, "CVE-2019-14722": {"epss_score": 0.00582, "epss_percentile": 0.68286}, "CVE-2019-14723": {"epss_score": 0.00582, "epss_percentile": 0.68286}, "CVE-2019-14724": {"epss_score": 0.09681, "epss_percentile": 0.92661}, "CVE-2019-14725": {"epss_score": 0.00214, "epss_percentile": 0.43983}, "CVE-2019-14726": {"epss_score": 0.0022, "epss_percentile": 0.44553}, "CVE-2019-14727": {"epss_score": 0.00582, "epss_percentile": 0.68286}, "CVE-2019-14728": {"epss_score": 0.00582, "epss_percentile": 0.68286}, "CVE-2019-14729": {"epss_score": 0.00582, "epss_percentile": 0.68286}, "CVE-2019-14730": {"epss_score": 0.00582, "epss_percentile": 0.68286}, "CVE-2019-14731": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2019-14732": {"epss_score": 0.00502, "epss_percentile": 0.65406}, "CVE-2019-14733": {"epss_score": 0.0054, "epss_percentile": 0.67004}, "CVE-2019-14734": {"epss_score": 0.0054, "epss_percentile": 0.67004}, "CVE-2019-14737": {"epss_score": 0.00153, "epss_percentile": 0.36506}, "CVE-2019-14743": {"epss_score": 0.0002, "epss_percentile": 0.04562}, "CVE-2019-14744": {"epss_score": 0.01309, "epss_percentile": 0.79353}, "CVE-2019-14745": {"epss_score": 0.07084, "epss_percentile": 0.9124}, "CVE-2019-14746": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2019-14747": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-14748": {"epss_score": 0.00525, "epss_percentile": 0.66394}, "CVE-2019-14749": {"epss_score": 0.14555, "epss_percentile": 0.9424}, "CVE-2019-14750": {"epss_score": 0.03327, "epss_percentile": 0.86924}, "CVE-2019-14751": {"epss_score": 0.03222, "epss_percentile": 0.86675}, "CVE-2019-14752": {"epss_score": 0.00312, "epss_percentile": 0.53995}, "CVE-2019-14753": {"epss_score": 0.0044, "epss_percentile": 0.62623}, "CVE-2019-14754": {"epss_score": 0.0037, "epss_percentile": 0.58324}, "CVE-2019-14755": {"epss_score": 0.00698, "epss_percentile": 0.71426}, "CVE-2019-14756": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-14757": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-14758": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-14759": {"epss_score": 0.00101, "epss_percentile": 0.28578}, "CVE-2019-14760": {"epss_score": 0.00101, "epss_percentile": 0.28578}, "CVE-2019-14761": {"epss_score": 0.00101, "epss_percentile": 0.28578}, "CVE-2019-14763": {"epss_score": 0.00064, "epss_percentile": 0.20397}, "CVE-2019-14765": {"epss_score": 0.00602, "epss_percentile": 0.68896}, "CVE-2019-14766": {"epss_score": 0.00556, "epss_percentile": 0.67526}, "CVE-2019-14767": {"epss_score": 0.01542, "epss_percentile": 0.80952}, "CVE-2019-14768": {"epss_score": 0.02749, "epss_percentile": 0.85578}, "CVE-2019-14769": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2019-14770": {"epss_score": 0.00201, "epss_percentile": 0.42284}, "CVE-2019-14771": {"epss_score": 0.00975, "epss_percentile": 0.76199}, "CVE-2019-14772": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-14773": {"epss_score": 0.00254, "epss_percentile": 0.48537}, "CVE-2019-14774": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-14776": {"epss_score": 0.00417, "epss_percentile": 0.61245}, "CVE-2019-14777": {"epss_score": 0.00298, "epss_percentile": 0.52795}, "CVE-2019-14778": {"epss_score": 0.00298, "epss_percentile": 0.52795}, "CVE-2019-14782": {"epss_score": 0.00419, "epss_percentile": 0.61367}, "CVE-2019-14783": {"epss_score": 0.00044, "epss_percentile": 0.13559}, "CVE-2019-14784": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-14785": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2019-14786": {"epss_score": 0.00195, "epss_percentile": 0.41645}, "CVE-2019-14787": {"epss_score": 0.00279, "epss_percentile": 0.50981}, "CVE-2019-14788": {"epss_score": 0.01612, "epss_percentile": 0.81336}, "CVE-2019-14789": {"epss_score": 0.00628, "epss_percentile": 0.6965}, "CVE-2019-14790": {"epss_score": 0.00238, "epss_percentile": 0.46784}, "CVE-2019-14791": {"epss_score": 0.00243, "epss_percentile": 0.47415}, "CVE-2019-14792": {"epss_score": 0.00208, "epss_percentile": 0.43252}, "CVE-2019-14793": {"epss_score": 0.00157, "epss_percentile": 0.37067}, "CVE-2019-14794": {"epss_score": 0.00455, "epss_percentile": 0.63273}, "CVE-2019-14795": {"epss_score": 0.00255, "epss_percentile": 0.4866}, "CVE-2019-14796": {"epss_score": 0.00204, "epss_percentile": 0.4263}, "CVE-2019-14797": {"epss_score": 0.00351, "epss_percentile": 0.57046}, "CVE-2019-14798": {"epss_score": 0.0069, "epss_percentile": 0.71245}, "CVE-2019-14799": {"epss_score": 0.02994, "epss_percentile": 0.86152}, "CVE-2019-14800": {"epss_score": 0.00249, "epss_percentile": 0.48079}, "CVE-2019-14801": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2019-14802": {"epss_score": 0.00363, "epss_percentile": 0.57849}, "CVE-2019-14804": {"epss_score": 0.0033, "epss_percentile": 0.5545}, "CVE-2019-14805": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2019-14806": {"epss_score": 0.00264, "epss_percentile": 0.49574}, "CVE-2019-14807": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-14808": {"epss_score": 0.0018, "epss_percentile": 0.39978}, "CVE-2019-14809": {"epss_score": 0.02582, "epss_percentile": 0.85158}, "CVE-2019-14810": {"epss_score": 0.00284, "epss_percentile": 0.51489}, "CVE-2019-14811": {"epss_score": 0.01726, "epss_percentile": 0.8196}, "CVE-2019-14812": {"epss_score": 0.00545, "epss_percentile": 0.67177}, "CVE-2019-14813": {"epss_score": 0.08454, "epss_percentile": 0.92059}, "CVE-2019-14814": {"epss_score": 0.00217, "epss_percentile": 0.4431}, "CVE-2019-14815": {"epss_score": 0.00182, "epss_percentile": 0.40256}, "CVE-2019-14816": {"epss_score": 0.00234, "epss_percentile": 0.4615}, "CVE-2019-14817": {"epss_score": 0.00362, "epss_percentile": 0.57816}, "CVE-2019-14818": {"epss_score": 0.01137, "epss_percentile": 0.77924}, "CVE-2019-14819": {"epss_score": 0.00357, "epss_percentile": 0.57404}, "CVE-2019-14820": {"epss_score": 0.0031, "epss_percentile": 0.53799}, "CVE-2019-14821": {"epss_score": 0.00107, "epss_percentile": 0.29696}, "CVE-2019-14822": {"epss_score": 0.00165, "epss_percentile": 0.38119}, "CVE-2019-14823": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2019-14824": {"epss_score": 0.00204, "epss_percentile": 0.42642}, "CVE-2019-14825": {"epss_score": 0.00152, "epss_percentile": 0.365}, "CVE-2019-14826": {"epss_score": 0.00113, "epss_percentile": 0.30634}, "CVE-2019-14827": {"epss_score": 0.00301, "epss_percentile": 0.5305}, "CVE-2019-14828": {"epss_score": 0.00164, "epss_percentile": 0.37942}, "CVE-2019-14829": {"epss_score": 0.00214, "epss_percentile": 0.44006}, "CVE-2019-14830": {"epss_score": 0.01746, "epss_percentile": 0.8207}, "CVE-2019-14831": {"epss_score": 0.00192, "epss_percentile": 0.41293}, "CVE-2019-14832": {"epss_score": 0.00383, "epss_percentile": 0.59105}, "CVE-2019-14833": {"epss_score": 0.01267, "epss_percentile": 0.79019}, "CVE-2019-14834": {"epss_score": 0.00042, "epss_percentile": 0.12661}, "CVE-2019-14835": {"epss_score": 0.0008, "epss_percentile": 0.2419}, "CVE-2019-14836": {"epss_score": 0.00301, "epss_percentile": 0.53081}, "CVE-2019-14837": {"epss_score": 0.01008, "epss_percentile": 0.76565}, "CVE-2019-14838": {"epss_score": 0.00402, "epss_percentile": 0.60269}, "CVE-2019-14839": {"epss_score": 0.0027, "epss_percentile": 0.50228}, "CVE-2019-14840": {"epss_score": 0.00209, "epss_percentile": 0.43325}, "CVE-2019-14841": {"epss_score": 0.00338, "epss_percentile": 0.56071}, "CVE-2019-14842": {"epss_score": 0.0021, "epss_percentile": 0.43469}, "CVE-2019-14843": {"epss_score": 0.00187, "epss_percentile": 0.40697}, "CVE-2019-14844": {"epss_score": 0.11696, "epss_percentile": 0.93453}, "CVE-2019-14845": {"epss_score": 0.00043, "epss_percentile": 0.13277}, "CVE-2019-14846": {"epss_score": 0.00141, "epss_percentile": 0.3483}, "CVE-2019-14847": {"epss_score": 0.02561, "epss_percentile": 0.85105}, "CVE-2019-14849": {"epss_score": 0.00374, "epss_percentile": 0.58536}, "CVE-2019-14850": {"epss_score": 0.00395, "epss_percentile": 0.59804}, "CVE-2019-14851": {"epss_score": 0.00332, "epss_percentile": 0.55549}, "CVE-2019-14852": {"epss_score": 0.0007, "epss_percentile": 0.2167}, "CVE-2019-14853": {"epss_score": 0.00068, "epss_percentile": 0.21297}, "CVE-2019-14854": {"epss_score": 0.00362, "epss_percentile": 0.57819}, "CVE-2019-14855": {"epss_score": 0.00404, "epss_percentile": 0.6041}, "CVE-2019-14856": {"epss_score": 0.00365, "epss_percentile": 0.58003}, "CVE-2019-14857": {"epss_score": 0.00811, "epss_percentile": 0.73733}, "CVE-2019-14858": {"epss_score": 0.00059, "epss_percentile": 0.18708}, "CVE-2019-14859": {"epss_score": 0.00065, "epss_percentile": 0.20673}, "CVE-2019-14860": {"epss_score": 0.00278, "epss_percentile": 0.5092}, "CVE-2019-14861": {"epss_score": 0.01649, "epss_percentile": 0.81558}, "CVE-2019-14862": {"epss_score": 0.00149, "epss_percentile": 0.35976}, "CVE-2019-14863": {"epss_score": 0.0022, "epss_percentile": 0.44605}, "CVE-2019-14864": {"epss_score": 0.00935, "epss_percentile": 0.75668}, "CVE-2019-14865": {"epss_score": 0.00038, "epss_percentile": 0.11215}, "CVE-2019-14866": {"epss_score": 0.00032, "epss_percentile": 0.08987}, "CVE-2019-14867": {"epss_score": 0.02605, "epss_percentile": 0.85219}, "CVE-2019-14868": {"epss_score": 0.00204, "epss_percentile": 0.42606}, "CVE-2019-14869": {"epss_score": 0.0027, "epss_percentile": 0.50237}, "CVE-2019-14870": {"epss_score": 0.04669, "epss_percentile": 0.88983}, "CVE-2019-14871": {"epss_score": 0.00465, "epss_percentile": 0.63762}, "CVE-2019-14872": {"epss_score": 0.00414, "epss_percentile": 0.61099}, "CVE-2019-14873": {"epss_score": 0.00401, "epss_percentile": 0.60198}, "CVE-2019-14874": {"epss_score": 0.00401, "epss_percentile": 0.60198}, "CVE-2019-14875": {"epss_score": 0.00401, "epss_percentile": 0.60198}, "CVE-2019-14876": {"epss_score": 0.00309, "epss_percentile": 0.53689}, "CVE-2019-14877": {"epss_score": 0.00309, "epss_percentile": 0.53689}, "CVE-2019-14878": {"epss_score": 0.00309, "epss_percentile": 0.53689}, "CVE-2019-14879": {"epss_score": 0.00205, "epss_percentile": 0.42748}, "CVE-2019-14880": {"epss_score": 0.00202, "epss_percentile": 0.42434}, "CVE-2019-14881": {"epss_score": 0.00518, "epss_percentile": 0.66138}, "CVE-2019-14882": {"epss_score": 0.00379, "epss_percentile": 0.58848}, "CVE-2019-14883": {"epss_score": 0.00289, "epss_percentile": 0.52021}, "CVE-2019-14884": {"epss_score": 0.00345, "epss_percentile": 0.56578}, "CVE-2019-14885": {"epss_score": 0.00323, "epss_percentile": 0.54868}, "CVE-2019-14886": {"epss_score": 0.00095, "epss_percentile": 0.27101}, "CVE-2019-14887": {"epss_score": 0.00177, "epss_percentile": 0.39512}, "CVE-2019-14888": {"epss_score": 0.00235, "epss_percentile": 0.4633}, "CVE-2019-14889": {"epss_score": 0.00624, "epss_percentile": 0.69558}, "CVE-2019-14890": {"epss_score": 0.00023, "epss_percentile": 0.05433}, "CVE-2019-14891": {"epss_score": 0.00316, "epss_percentile": 0.54297}, "CVE-2019-14892": {"epss_score": 0.00873, "epss_percentile": 0.74741}, "CVE-2019-14893": {"epss_score": 0.00698, "epss_percentile": 0.71422}, "CVE-2019-14894": {"epss_score": 0.00654, "epss_percentile": 0.70351}, "CVE-2019-14895": {"epss_score": 0.02995, "epss_percentile": 0.86153}, "CVE-2019-14896": {"epss_score": 0.01784, "epss_percentile": 0.82251}, "CVE-2019-14897": {"epss_score": 0.00872, "epss_percentile": 0.74727}, "CVE-2019-14898": {"epss_score": 0.00103, "epss_percentile": 0.29087}, "CVE-2019-14899": {"epss_score": 0.00053, "epss_percentile": 0.1693}, "CVE-2019-14900": {"epss_score": 0.01405, "epss_percentile": 0.80044}, "CVE-2019-14901": {"epss_score": 0.06732, "epss_percentile": 0.9099}, "CVE-2019-14902": {"epss_score": 0.02934, "epss_percentile": 0.86021}, "CVE-2019-14904": {"epss_score": 0.0004, "epss_percentile": 0.12189}, "CVE-2019-14905": {"epss_score": 0.0005, "epss_percentile": 0.15979}, "CVE-2019-14906": {"epss_score": 0.0107, "epss_percentile": 0.77251}, "CVE-2019-14907": {"epss_score": 0.10242, "epss_percentile": 0.92908}, "CVE-2019-14909": {"epss_score": 0.0029, "epss_percentile": 0.52079}, "CVE-2019-14910": {"epss_score": 0.00436, "epss_percentile": 0.62463}, "CVE-2019-14911": {"epss_score": 0.00053, "epss_percentile": 0.16734}, "CVE-2019-14912": {"epss_score": 0.00093, "epss_percentile": 0.26643}, "CVE-2019-14913": {"epss_score": 0.00033, "epss_percentile": 0.09189}, "CVE-2019-14914": {"epss_score": 0.00716, "epss_percentile": 0.71857}, "CVE-2019-14915": {"epss_score": 0.00129, "epss_percentile": 0.33142}, "CVE-2019-14916": {"epss_score": 0.00219, "epss_percentile": 0.44515}, "CVE-2019-14918": {"epss_score": 0.00186, "epss_percentile": 0.40605}, "CVE-2019-14919": {"epss_score": 0.00234, "epss_percentile": 0.46077}, "CVE-2019-14920": {"epss_score": 0.00688, "epss_percentile": 0.7119}, "CVE-2019-14923": {"epss_score": 0.12598, "epss_percentile": 0.93724}, "CVE-2019-14924": {"epss_score": 0.00401, "epss_percentile": 0.6023}, "CVE-2019-14925": {"epss_score": 0.0028, "epss_percentile": 0.51088}, "CVE-2019-14926": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2019-14927": {"epss_score": 0.25332, "epss_percentile": 0.96014}, "CVE-2019-14928": {"epss_score": 0.0207, "epss_percentile": 0.83471}, "CVE-2019-14929": {"epss_score": 0.0215, "epss_percentile": 0.8378}, "CVE-2019-14930": {"epss_score": 0.00389, "epss_percentile": 0.59454}, "CVE-2019-14931": {"epss_score": 0.69382, "epss_percentile": 0.98585}, "CVE-2019-14932": {"epss_score": 0.00327, "epss_percentile": 0.55102}, "CVE-2019-14933": {"epss_score": 0.0014, "epss_percentile": 0.34732}, "CVE-2019-14934": {"epss_score": 0.00378, "epss_percentile": 0.58789}, "CVE-2019-14935": {"epss_score": 0.00035, "epss_percentile": 0.10152}, "CVE-2019-14936": {"epss_score": 0.00249, "epss_percentile": 0.48079}, "CVE-2019-14937": {"epss_score": 0.00384, "epss_percentile": 0.59159}, "CVE-2019-14939": {"epss_score": 0.00059, "epss_percentile": 0.18669}, "CVE-2019-14940": {"epss_score": 0.00292, "epss_percentile": 0.5228}, "CVE-2019-14941": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2019-14942": {"epss_score": 0.00068, "epss_percentile": 0.21222}, "CVE-2019-14943": {"epss_score": 0.00303, "epss_percentile": 0.53174}, "CVE-2019-14944": {"epss_score": 0.01383, "epss_percentile": 0.79895}, "CVE-2019-14945": {"epss_score": 0.00575, "epss_percentile": 0.68121}, "CVE-2019-14946": {"epss_score": 0.00384, "epss_percentile": 0.5918}, "CVE-2019-14947": {"epss_score": 0.00575, "epss_percentile": 0.68121}, "CVE-2019-14948": {"epss_score": 0.00204, "epss_percentile": 0.4263}, "CVE-2019-14949": {"epss_score": 0.00403, "epss_percentile": 0.60318}, "CVE-2019-14950": {"epss_score": 0.05959, "epss_percentile": 0.90365}, "CVE-2019-14951": {"epss_score": 0.00621, "epss_percentile": 0.69493}, "CVE-2019-14952": {"epss_score": 6e-05, "epss_percentile": 0.00267}, "CVE-2019-14953": {"epss_score": 7e-05, "epss_percentile": 0.00347}, "CVE-2019-14954": {"epss_score": 2e-05, "epss_percentile": 0.00041}, "CVE-2019-14955": {"epss_score": 3e-05, "epss_percentile": 0.00072}, "CVE-2019-14956": {"epss_score": 2e-05, "epss_percentile": 0.00033}, "CVE-2019-14957": {"epss_score": 3e-05, "epss_percentile": 0.00107}, "CVE-2019-14958": {"epss_score": 5e-05, "epss_percentile": 0.00182}, "CVE-2019-14959": {"epss_score": 2e-05, "epss_percentile": 0.00058}, "CVE-2019-14960": {"epss_score": 1e-05, "epss_percentile": 8e-05}, "CVE-2019-14961": {"epss_score": 6e-05, "epss_percentile": 0.00267}, "CVE-2019-14965": {"epss_score": 0.01802, "epss_percentile": 0.82332}, "CVE-2019-14966": {"epss_score": 0.01014, "epss_percentile": 0.76655}, "CVE-2019-14967": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2019-14968": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-14969": {"epss_score": 0.00047, "epss_percentile": 0.14647}, "CVE-2019-14970": {"epss_score": 0.00636, "epss_percentile": 0.69871}, "CVE-2019-14973": {"epss_score": 0.00821, "epss_percentile": 0.73903}, "CVE-2019-14974": {"epss_score": 0.32775, "epss_percentile": 0.96724}, "CVE-2019-14975": {"epss_score": 0.0022, "epss_percentile": 0.44595}, "CVE-2019-14976": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-14978": {"epss_score": 0.00187, "epss_percentile": 0.40739}, "CVE-2019-14979": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2019-14980": {"epss_score": 0.00197, "epss_percentile": 0.41867}, "CVE-2019-14981": {"epss_score": 0.00665, "epss_percentile": 0.70655}, "CVE-2019-14982": {"epss_score": 0.00616, "epss_percentile": 0.69332}, "CVE-2019-14984": {"epss_score": 0.10704, "epss_percentile": 0.93076}, "CVE-2019-14985": {"epss_score": 0.49415, "epss_percentile": 0.97685}, "CVE-2019-14986": {"epss_score": 0.02056, "epss_percentile": 0.83426}, "CVE-2019-14987": {"epss_score": 0.00207, "epss_percentile": 0.43195}, "CVE-2019-14993": {"epss_score": 0.00785, "epss_percentile": 0.73257}, "CVE-2019-14994": {"epss_score": 0.0168, "epss_percentile": 0.81726}, "CVE-2019-14995": {"epss_score": 0.00472, "epss_percentile": 0.64052}, "CVE-2019-14996": {"epss_score": 0.00257, "epss_percentile": 0.48917}, "CVE-2019-14997": {"epss_score": 0.00204, "epss_percentile": 0.4262}, "CVE-2019-14998": {"epss_score": 0.00197, "epss_percentile": 0.41962}, "CVE-2019-14999": {"epss_score": 0.00087, "epss_percentile": 0.25574}, "CVE-2019-15000": {"epss_score": 0.11111, "epss_percentile": 0.93225}, "CVE-2019-15001": {"epss_score": 0.11506, "epss_percentile": 0.93386}, "CVE-2019-15002": {"epss_score": 0.00056, "epss_percentile": 0.17666}, "CVE-2019-15003": {"epss_score": 0.0051, "epss_percentile": 0.65767}, "CVE-2019-15004": {"epss_score": 0.05644, "epss_percentile": 0.9008}, "CVE-2019-15005": {"epss_score": 0.00208, "epss_percentile": 0.43289}, "CVE-2019-15006": {"epss_score": 0.02177, "epss_percentile": 0.83888}, "CVE-2019-15007": {"epss_score": 0.0022, "epss_percentile": 0.44616}, "CVE-2019-15008": {"epss_score": 0.00409, "epss_percentile": 0.60733}, "CVE-2019-15009": {"epss_score": 0.00261, "epss_percentile": 0.49325}, "CVE-2019-15010": {"epss_score": 0.02057, "epss_percentile": 0.83429}, "CVE-2019-15011": {"epss_score": 0.00172, "epss_percentile": 0.39004}, "CVE-2019-15012": {"epss_score": 0.0192, "epss_percentile": 0.82895}, "CVE-2019-15013": {"epss_score": 0.00262, "epss_percentile": 0.49342}, "CVE-2019-15014": {"epss_score": 0.0184, "epss_percentile": 0.82492}, "CVE-2019-15015": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2019-15016": {"epss_score": 0.00417, "epss_percentile": 0.61224}, "CVE-2019-15017": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2019-15018": {"epss_score": 0.0019, "epss_percentile": 0.4111}, "CVE-2019-15019": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-15020": {"epss_score": 0.01577, "epss_percentile": 0.81118}, "CVE-2019-15021": {"epss_score": 0.00206, "epss_percentile": 0.42787}, "CVE-2019-15022": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2019-15023": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2019-15024": {"epss_score": 0.00348, "epss_percentile": 0.56799}, "CVE-2019-15025": {"epss_score": 0.00508, "epss_percentile": 0.65682}, "CVE-2019-15026": {"epss_score": 0.00927, "epss_percentile": 0.75573}, "CVE-2019-15027": {"epss_score": 0.02356, "epss_percentile": 0.84483}, "CVE-2019-15028": {"epss_score": 0.0002, "epss_percentile": 0.04634}, "CVE-2019-15029": {"epss_score": 0.21116, "epss_percentile": 0.95464}, "CVE-2019-15030": {"epss_score": 0.00073, "epss_percentile": 0.22616}, "CVE-2019-15031": {"epss_score": 0.00069, "epss_percentile": 0.21485}, "CVE-2019-15032": {"epss_score": 0.00438, "epss_percentile": 0.62555}, "CVE-2019-15033": {"epss_score": 0.0031, "epss_percentile": 0.53757}, "CVE-2019-15034": {"epss_score": 0.00191, "epss_percentile": 0.41209}, "CVE-2019-15035": {"epss_score": 4e-05, "epss_percentile": 0.00145}, "CVE-2019-15036": {"epss_score": 7e-05, "epss_percentile": 0.00344}, "CVE-2019-15037": {"epss_score": 8e-05, "epss_percentile": 0.005}, "CVE-2019-15038": {"epss_score": 4e-05, "epss_percentile": 0.00137}, "CVE-2019-15039": {"epss_score": 0.00229, "epss_percentile": 0.45591}, "CVE-2019-15040": {"epss_score": 2e-05, "epss_percentile": 0.00048}, "CVE-2019-15041": {"epss_score": 3e-05, "epss_percentile": 0.00078}, "CVE-2019-15042": {"epss_score": 2e-05, "epss_percentile": 0.00036}, "CVE-2019-15043": {"epss_score": 0.90497, "epss_percentile": 0.99587}, "CVE-2019-15045": {"epss_score": 0.02514, "epss_percentile": 0.8498}, "CVE-2019-15046": {"epss_score": 0.05351, "epss_percentile": 0.89773}, "CVE-2019-15047": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2019-15048": {"epss_score": 0.00414, "epss_percentile": 0.61033}, "CVE-2019-15049": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-15050": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-15051": {"epss_score": 0.03102, "epss_percentile": 0.86411}, "CVE-2019-15052": {"epss_score": 0.0024, "epss_percentile": 0.46953}, "CVE-2019-15053": {"epss_score": 0.01478, "epss_percentile": 0.80555}, "CVE-2019-15054": {"epss_score": 0.00419, "epss_percentile": 0.61386}, "CVE-2019-15055": {"epss_score": 0.00449, "epss_percentile": 0.63056}, "CVE-2019-15058": {"epss_score": 0.01186, "epss_percentile": 0.78349}, "CVE-2019-15059": {"epss_score": 0.00229, "epss_percentile": 0.45624}, "CVE-2019-15060": {"epss_score": 0.02992, "epss_percentile": 0.86146}, "CVE-2019-15062": {"epss_score": 0.00122, "epss_percentile": 0.32026}, "CVE-2019-15064": {"epss_score": 0.00404, "epss_percentile": 0.60414}, "CVE-2019-15065": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2019-15066": {"epss_score": 0.00443, "epss_percentile": 0.62804}, "CVE-2019-15067": {"epss_score": 0.00388, "epss_percentile": 0.59392}, "CVE-2019-15068": {"epss_score": 0.00305, "epss_percentile": 0.53362}, "CVE-2019-15069": {"epss_score": 0.00469, "epss_percentile": 0.63939}, "CVE-2019-15071": {"epss_score": 0.0103, "epss_percentile": 0.7685}, "CVE-2019-15072": {"epss_score": 0.00772, "epss_percentile": 0.73043}, "CVE-2019-15073": {"epss_score": 0.00783, "epss_percentile": 0.73228}, "CVE-2019-15074": {"epss_score": 0.00745, "epss_percentile": 0.72525}, "CVE-2019-15075": {"epss_score": 0.00087, "epss_percentile": 0.25558}, "CVE-2019-15078": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2019-15079": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2019-15080": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-15081": {"epss_score": 0.00172, "epss_percentile": 0.38914}, "CVE-2019-15082": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-15083": {"epss_score": 0.01902, "epss_percentile": 0.82783}, "CVE-2019-15084": {"epss_score": 0.00249, "epss_percentile": 0.48086}, "CVE-2019-15085": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-15086": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-15087": {"epss_score": 0.03102, "epss_percentile": 0.86412}, "CVE-2019-15088": {"epss_score": 0.00514, "epss_percentile": 0.65949}, "CVE-2019-15089": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2019-15090": {"epss_score": 0.00106, "epss_percentile": 0.29445}, "CVE-2019-15091": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-15092": {"epss_score": 0.08413, "epss_percentile": 0.92037}, "CVE-2019-15095": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-15098": {"epss_score": 0.00163, "epss_percentile": 0.37772}, "CVE-2019-15099": {"epss_score": 0.0166, "epss_percentile": 0.81618}, "CVE-2019-15102": {"epss_score": 0.0454, "epss_percentile": 0.88828}, "CVE-2019-15104": {"epss_score": 0.03272, "epss_percentile": 0.86796}, "CVE-2019-15105": {"epss_score": 0.03467, "epss_percentile": 0.87192}, "CVE-2019-15106": {"epss_score": 0.3724, "epss_percentile": 0.97029}, "CVE-2019-15107": {"epss_score": 0.94461, "epss_percentile": 0.99994}, "CVE-2019-15108": {"epss_score": 0.0026, "epss_percentile": 0.49193}, "CVE-2019-15109": {"epss_score": 0.00148, "epss_percentile": 0.35806}, "CVE-2019-15110": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-15111": {"epss_score": 0.00337, "epss_percentile": 0.56015}, "CVE-2019-15112": {"epss_score": 0.00311, "epss_percentile": 0.53815}, "CVE-2019-15113": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2019-15114": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2019-15115": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2019-15116": {"epss_score": 0.00176, "epss_percentile": 0.3947}, "CVE-2019-15117": {"epss_score": 0.00095, "epss_percentile": 0.27227}, "CVE-2019-15118": {"epss_score": 0.00133, "epss_percentile": 0.33737}, "CVE-2019-15119": {"epss_score": 0.0009, "epss_percentile": 0.26076}, "CVE-2019-15120": {"epss_score": 0.01427, "epss_percentile": 0.80216}, "CVE-2019-15123": {"epss_score": 0.02631, "epss_percentile": 0.85283}, "CVE-2019-15124": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2019-15126": {"epss_score": 0.08564, "epss_percentile": 0.92127}, "CVE-2019-15127": {"epss_score": 0.00287, "epss_percentile": 0.51858}, "CVE-2019-15128": {"epss_score": 0.00104, "epss_percentile": 0.29112}, "CVE-2019-15129": {"epss_score": 0.00986, "epss_percentile": 0.76336}, "CVE-2019-15130": {"epss_score": 0.03389, "epss_percentile": 0.87047}, "CVE-2019-15131": {"epss_score": 0.01132, "epss_percentile": 0.77873}, "CVE-2019-15132": {"epss_score": 0.00412, "epss_percentile": 0.60943}, "CVE-2019-15133": {"epss_score": 0.00202, "epss_percentile": 0.42473}, "CVE-2019-15134": {"epss_score": 0.00446, "epss_percentile": 0.629}, "CVE-2019-15135": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2019-15136": {"epss_score": 0.0015, "epss_percentile": 0.36072}, "CVE-2019-15137": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-15138": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-15139": {"epss_score": 0.00385, "epss_percentile": 0.59207}, "CVE-2019-15140": {"epss_score": 0.00846, "epss_percentile": 0.74319}, "CVE-2019-15141": {"epss_score": 0.00089, "epss_percentile": 0.25946}, "CVE-2019-15142": {"epss_score": 0.00867, "epss_percentile": 0.7465}, "CVE-2019-15143": {"epss_score": 0.00867, "epss_percentile": 0.7465}, "CVE-2019-15144": {"epss_score": 0.00649, "epss_percentile": 0.7024}, "CVE-2019-15145": {"epss_score": 0.00225, "epss_percentile": 0.45083}, "CVE-2019-15146": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2019-15147": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2019-15148": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2019-15149": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-15150": {"epss_score": 0.00288, "epss_percentile": 0.51914}, "CVE-2019-15151": {"epss_score": 0.005, "epss_percentile": 0.65312}, "CVE-2019-15160": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-15161": {"epss_score": 0.02527, "epss_percentile": 0.85017}, "CVE-2019-15162": {"epss_score": 0.01042, "epss_percentile": 0.76972}, "CVE-2019-15163": {"epss_score": 0.0078, "epss_percentile": 0.7316}, "CVE-2019-15164": {"epss_score": 0.01656, "epss_percentile": 0.81601}, "CVE-2019-15165": {"epss_score": 0.01191, "epss_percentile": 0.78395}, "CVE-2019-15166": {"epss_score": 0.01018, "epss_percentile": 0.76718}, "CVE-2019-15167": {"epss_score": 0.00078, "epss_percentile": 0.23632}, "CVE-2019-15211": {"epss_score": 0.00113, "epss_percentile": 0.30702}, "CVE-2019-15212": {"epss_score": 0.00106, "epss_percentile": 0.29508}, "CVE-2019-15213": {"epss_score": 0.00176, "epss_percentile": 0.39434}, "CVE-2019-15214": {"epss_score": 0.00084, "epss_percentile": 0.2497}, "CVE-2019-15215": {"epss_score": 0.0004, "epss_percentile": 0.11918}, "CVE-2019-15216": {"epss_score": 0.00053, "epss_percentile": 0.16873}, "CVE-2019-15217": {"epss_score": 0.00063, "epss_percentile": 0.20087}, "CVE-2019-15218": {"epss_score": 0.00097, "epss_percentile": 0.27517}, "CVE-2019-15219": {"epss_score": 0.00108, "epss_percentile": 0.29889}, "CVE-2019-15220": {"epss_score": 0.00041, "epss_percentile": 0.12437}, "CVE-2019-15221": {"epss_score": 0.00147, "epss_percentile": 0.35775}, "CVE-2019-15222": {"epss_score": 0.00073, "epss_percentile": 0.22659}, "CVE-2019-15223": {"epss_score": 0.0006, "epss_percentile": 0.19103}, "CVE-2019-15224": {"epss_score": 0.02163, "epss_percentile": 0.83835}, "CVE-2019-15225": {"epss_score": 0.00145, "epss_percentile": 0.355}, "CVE-2019-15226": {"epss_score": 0.16964, "epss_percentile": 0.94754}, "CVE-2019-15227": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-15228": {"epss_score": 0.0042, "epss_percentile": 0.61413}, "CVE-2019-15229": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2019-15230": {"epss_score": 0.00039, "epss_percentile": 0.11654}, "CVE-2019-15232": {"epss_score": 0.00712, "epss_percentile": 0.71748}, "CVE-2019-15233": {"epss_score": 0.0104, "epss_percentile": 0.76959}, "CVE-2019-15234": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2019-15235": {"epss_score": 0.00419, "epss_percentile": 0.61367}, "CVE-2019-15237": {"epss_score": 0.00139, "epss_percentile": 0.34638}, "CVE-2019-15238": {"epss_score": 0.003, "epss_percentile": 0.52964}, "CVE-2019-15239": {"epss_score": 0.00035, "epss_percentile": 0.09881}, "CVE-2019-15240": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15241": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15242": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15243": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15244": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15245": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15246": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15247": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15248": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15249": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15250": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15251": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15252": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2019-15253": {"epss_score": 0.00165, "epss_percentile": 0.38114}, "CVE-2019-15255": {"epss_score": 0.002, "epss_percentile": 0.42216}, "CVE-2019-15256": {"epss_score": 0.01156, "epss_percentile": 0.78087}, "CVE-2019-15257": {"epss_score": 0.00483, "epss_percentile": 0.64593}, "CVE-2019-15258": {"epss_score": 0.00463, "epss_percentile": 0.63626}, "CVE-2019-15259": {"epss_score": 0.00208, "epss_percentile": 0.43279}, "CVE-2019-15260": {"epss_score": 0.07153, "epss_percentile": 0.91289}, "CVE-2019-15261": {"epss_score": 0.01447, "epss_percentile": 0.80333}, "CVE-2019-15262": {"epss_score": 0.02925, "epss_percentile": 0.86004}, "CVE-2019-15264": {"epss_score": 0.00317, "epss_percentile": 0.54345}, "CVE-2019-15265": {"epss_score": 0.00237, "epss_percentile": 0.46464}, "CVE-2019-15266": {"epss_score": 0.0009, "epss_percentile": 0.26058}, "CVE-2019-15268": {"epss_score": 0.0026, "epss_percentile": 0.49106}, "CVE-2019-15269": {"epss_score": 0.0026, "epss_percentile": 0.49106}, "CVE-2019-15270": {"epss_score": 0.00185, "epss_percentile": 0.40511}, "CVE-2019-15271": {"epss_score": 0.05878, "epss_percentile": 0.90287}, "CVE-2019-15272": {"epss_score": 0.00074, "epss_percentile": 0.22864}, "CVE-2019-15273": {"epss_score": 0.00221, "epss_percentile": 0.44683}, "CVE-2019-15274": {"epss_score": 0.00288, "epss_percentile": 0.51874}, "CVE-2019-15275": {"epss_score": 0.00079, "epss_percentile": 0.23877}, "CVE-2019-15276": {"epss_score": 0.26988, "epss_percentile": 0.96196}, "CVE-2019-15277": {"epss_score": 0.00093, "epss_percentile": 0.26706}, "CVE-2019-15278": {"epss_score": 0.00704, "epss_percentile": 0.71558}, "CVE-2019-15280": {"epss_score": 0.0026, "epss_percentile": 0.49106}, "CVE-2019-15281": {"epss_score": 0.0026, "epss_percentile": 0.49106}, "CVE-2019-15282": {"epss_score": 0.01094, "epss_percentile": 0.77492}, "CVE-2019-15283": {"epss_score": 0.00341, "epss_percentile": 0.56289}, "CVE-2019-15284": {"epss_score": 0.00472, "epss_percentile": 0.64029}, "CVE-2019-15285": {"epss_score": 0.00341, "epss_percentile": 0.56289}, "CVE-2019-15286": {"epss_score": 0.00472, "epss_percentile": 0.64029}, "CVE-2019-15287": {"epss_score": 0.00341, "epss_percentile": 0.56289}, "CVE-2019-15288": {"epss_score": 0.00749, "epss_percentile": 0.72595}, "CVE-2019-15289": {"epss_score": 0.00564, "epss_percentile": 0.67777}, "CVE-2019-15291": {"epss_score": 0.00101, "epss_percentile": 0.28677}, "CVE-2019-15292": {"epss_score": 0.01013, "epss_percentile": 0.7663}, "CVE-2019-15293": {"epss_score": 0.00029, "epss_percentile": 0.07656}, "CVE-2019-15294": {"epss_score": 0.00346, "epss_percentile": 0.56645}, "CVE-2019-15295": {"epss_score": 0.00165, "epss_percentile": 0.38114}, "CVE-2019-15296": {"epss_score": 0.00421, "epss_percentile": 0.615}, "CVE-2019-15297": {"epss_score": 0.01814, "epss_percentile": 0.8238}, "CVE-2019-15298": {"epss_score": 0.08911, "epss_percentile": 0.92312}, "CVE-2019-15299": {"epss_score": 0.0006, "epss_percentile": 0.19155}, "CVE-2019-15300": {"epss_score": 0.00281, "epss_percentile": 0.5119}, "CVE-2019-15301": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15302": {"epss_score": 0.00106, "epss_percentile": 0.29566}, "CVE-2019-15304": {"epss_score": 0.01818, "epss_percentile": 0.82401}, "CVE-2019-15310": {"epss_score": 0.11928, "epss_percentile": 0.93519}, "CVE-2019-15311": {"epss_score": 0.086, "epss_percentile": 0.92144}, "CVE-2019-15312": {"epss_score": 0.00612, "epss_percentile": 0.69218}, "CVE-2019-15313": {"epss_score": 0.02165, "epss_percentile": 0.83846}, "CVE-2019-15314": {"epss_score": 0.00157, "epss_percentile": 0.37034}, "CVE-2019-15315": {"epss_score": 0.00035, "epss_percentile": 0.10054}, "CVE-2019-15316": {"epss_score": 0.00051, "epss_percentile": 0.16159}, "CVE-2019-15317": {"epss_score": 0.00334, "epss_percentile": 0.55738}, "CVE-2019-15318": {"epss_score": 0.00994, "epss_percentile": 0.76419}, "CVE-2019-15319": {"epss_score": 0.01077, "epss_percentile": 0.77339}, "CVE-2019-15320": {"epss_score": 0.01077, "epss_percentile": 0.77339}, "CVE-2019-15321": {"epss_score": 0.01077, "epss_percentile": 0.77339}, "CVE-2019-15322": {"epss_score": 0.0091, "epss_percentile": 0.75319}, "CVE-2019-15323": {"epss_score": 0.00734, "epss_percentile": 0.7222}, "CVE-2019-15324": {"epss_score": 0.08066, "epss_percentile": 0.91865}, "CVE-2019-15325": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-15326": {"epss_score": 0.00295, "epss_percentile": 0.52443}, "CVE-2019-15327": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-15328": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-15329": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2019-15330": {"epss_score": 0.00554, "epss_percentile": 0.67441}, "CVE-2019-15331": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-15332": {"epss_score": 0.00108, "epss_percentile": 0.29867}, "CVE-2019-15333": {"epss_score": 0.00108, "epss_percentile": 0.29867}, "CVE-2019-15334": {"epss_score": 0.00108, "epss_percentile": 0.29867}, "CVE-2019-15335": {"epss_score": 0.00108, "epss_percentile": 0.29867}, "CVE-2019-15336": {"epss_score": 0.00108, "epss_percentile": 0.29867}, "CVE-2019-15337": {"epss_score": 0.00108, "epss_percentile": 0.29867}, "CVE-2019-15338": {"epss_score": 0.00108, "epss_percentile": 0.29867}, "CVE-2019-15339": {"epss_score": 0.00108, "epss_percentile": 0.29867}, "CVE-2019-15340": {"epss_score": 0.00116, "epss_percentile": 0.31178}, "CVE-2019-15341": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-15342": {"epss_score": 0.00132, "epss_percentile": 0.33576}, "CVE-2019-15343": {"epss_score": 0.00132, "epss_percentile": 0.33576}, "CVE-2019-15344": {"epss_score": 0.00377, "epss_percentile": 0.58744}, "CVE-2019-15345": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-15346": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-15347": {"epss_score": 0.00132, "epss_percentile": 0.33576}, "CVE-2019-15348": {"epss_score": 0.00114, "epss_percentile": 0.30749}, "CVE-2019-15349": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-15350": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-15351": {"epss_score": 0.00132, "epss_percentile": 0.33576}, "CVE-2019-15352": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15353": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15354": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15355": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15356": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15357": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15358": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15359": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15360": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15361": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15362": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15363": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15364": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15365": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15366": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15367": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15368": {"epss_score": 0.0013, "epss_percentile": 0.3327}, "CVE-2019-15369": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15370": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15371": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15372": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15373": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15374": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15375": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15376": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15377": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15378": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15379": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15380": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15381": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15382": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15383": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15384": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15385": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15386": {"epss_score": 0.00108, "epss_percentile": 0.29867}, "CVE-2019-15387": {"epss_score": 0.00108, "epss_percentile": 0.29867}, "CVE-2019-15388": {"epss_score": 0.00377, "epss_percentile": 0.58744}, "CVE-2019-15389": {"epss_score": 0.00377, "epss_percentile": 0.58744}, "CVE-2019-15390": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15391": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15392": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15393": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15394": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-15395": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15396": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15397": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15398": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15399": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15400": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15401": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15402": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15403": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15404": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15405": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15406": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15407": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15408": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15409": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15410": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15411": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2019-15412": {"epss_score": 0.00121, "epss_percentile": 0.31922}, "CVE-2019-15413": {"epss_score": 0.00096, "epss_percentile": 0.27288}, "CVE-2019-15414": {"epss_score": 0.00107, "epss_percentile": 0.2959}, "CVE-2019-15415": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15416": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15417": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-15418": {"epss_score": 0.00119, "epss_percentile": 0.31661}, "CVE-2019-15419": {"epss_score": 0.00119, "epss_percentile": 0.31661}, "CVE-2019-15420": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15421": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15422": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15423": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15424": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15425": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15426": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15427": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15428": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15429": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-15430": {"epss_score": 0.00091, "epss_percentile": 0.2639}, "CVE-2019-15431": {"epss_score": 0.00091, "epss_percentile": 0.2639}, "CVE-2019-15432": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15433": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15434": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15435": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15436": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15437": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15438": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15439": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15440": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15441": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15442": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15443": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15444": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15445": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15446": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15447": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15448": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15449": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15450": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15451": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15452": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15453": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15454": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15455": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15456": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15457": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15458": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15459": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15460": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15461": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15462": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15463": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15464": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15465": {"epss_score": 0.00102, "epss_percentile": 0.28891}, "CVE-2019-15466": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15467": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15468": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15469": {"epss_score": 0.00095, "epss_percentile": 0.271}, "CVE-2019-15470": {"epss_score": 0.00095, "epss_percentile": 0.271}, "CVE-2019-15471": {"epss_score": 0.00044, "epss_percentile": 0.13511}, "CVE-2019-15472": {"epss_score": 0.00135, "epss_percentile": 0.33947}, "CVE-2019-15473": {"epss_score": 0.00125, "epss_percentile": 0.32595}, "CVE-2019-15474": {"epss_score": 0.00125, "epss_percentile": 0.32595}, "CVE-2019-15475": {"epss_score": 0.00125, "epss_percentile": 0.32595}, "CVE-2019-15476": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2019-15477": {"epss_score": 0.00321, "epss_percentile": 0.54644}, "CVE-2019-15478": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-15479": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-15480": {"epss_score": 0.00176, "epss_percentile": 0.39464}, "CVE-2019-15481": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-15482": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-15483": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-15484": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2019-15485": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2019-15486": {"epss_score": 0.0024, "epss_percentile": 0.46957}, "CVE-2019-15487": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-15488": {"epss_score": 0.00221, "epss_percentile": 0.44681}, "CVE-2019-15489": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-15490": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2019-15491": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2019-15492": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-15493": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-15494": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2019-15496": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-15497": {"epss_score": 0.01542, "epss_percentile": 0.80952}, "CVE-2019-15498": {"epss_score": 0.01512, "epss_percentile": 0.8078}, "CVE-2019-15499": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-15501": {"epss_score": 0.09038, "epss_percentile": 0.92377}, "CVE-2019-15502": {"epss_score": 0.00642, "epss_percentile": 0.70019}, "CVE-2019-15503": {"epss_score": 0.01179, "epss_percentile": 0.78289}, "CVE-2019-15504": {"epss_score": 0.0412, "epss_percentile": 0.88283}, "CVE-2019-15505": {"epss_score": 0.00613, "epss_percentile": 0.6926}, "CVE-2019-15506": {"epss_score": 0.0056, "epss_percentile": 0.67629}, "CVE-2019-15507": {"epss_score": 0.00231, "epss_percentile": 0.45789}, "CVE-2019-15508": {"epss_score": 0.00318, "epss_percentile": 0.54428}, "CVE-2019-15510": {"epss_score": 0.03816, "epss_percentile": 0.87768}, "CVE-2019-15511": {"epss_score": 0.00534, "epss_percentile": 0.668}, "CVE-2019-15513": {"epss_score": 0.00484, "epss_percentile": 0.64672}, "CVE-2019-15514": {"epss_score": 0.03331, "epss_percentile": 0.86928}, "CVE-2019-15515": {"epss_score": 0.00157, "epss_percentile": 0.37031}, "CVE-2019-15516": {"epss_score": 0.00504, "epss_percentile": 0.65538}, "CVE-2019-15517": {"epss_score": 0.00172, "epss_percentile": 0.38914}, "CVE-2019-15518": {"epss_score": 0.00217, "epss_percentile": 0.44322}, "CVE-2019-15519": {"epss_score": 0.00805, "epss_percentile": 0.73639}, "CVE-2019-15520": {"epss_score": 0.00217, "epss_percentile": 0.44322}, "CVE-2019-15521": {"epss_score": 0.00678, "epss_percentile": 0.70973}, "CVE-2019-15522": {"epss_score": 0.00521, "epss_percentile": 0.66221}, "CVE-2019-15523": {"epss_score": 0.0067, "epss_percentile": 0.70771}, "CVE-2019-15524": {"epss_score": 0.02419, "epss_percentile": 0.84699}, "CVE-2019-15525": {"epss_score": 0.00277, "epss_percentile": 0.50825}, "CVE-2019-15526": {"epss_score": 0.03084, "epss_percentile": 0.86378}, "CVE-2019-15527": {"epss_score": 0.03586, "epss_percentile": 0.87393}, "CVE-2019-15528": {"epss_score": 0.03084, "epss_percentile": 0.86378}, "CVE-2019-15529": {"epss_score": 0.12086, "epss_percentile": 0.93564}, "CVE-2019-15530": {"epss_score": 0.03084, "epss_percentile": 0.86378}, "CVE-2019-15531": {"epss_score": 0.01106, "epss_percentile": 0.77614}, "CVE-2019-15532": {"epss_score": 0.00458, "epss_percentile": 0.63442}, "CVE-2019-15533": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-15534": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-15535": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2019-15536": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15537": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15538": {"epss_score": 0.16428, "epss_percentile": 0.94659}, "CVE-2019-15539": {"epss_score": 0.00522, "epss_percentile": 0.66282}, "CVE-2019-15540": {"epss_score": 0.00095, "epss_percentile": 0.27221}, "CVE-2019-15541": {"epss_score": 0.00482, "epss_percentile": 0.64553}, "CVE-2019-15542": {"epss_score": 0.00366, "epss_percentile": 0.58025}, "CVE-2019-15543": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-15544": {"epss_score": 0.02695, "epss_percentile": 0.85442}, "CVE-2019-15545": {"epss_score": 0.00145, "epss_percentile": 0.35402}, "CVE-2019-15546": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2019-15547": {"epss_score": 0.00238, "epss_percentile": 0.46762}, "CVE-2019-15548": {"epss_score": 0.00587, "epss_percentile": 0.68477}, "CVE-2019-15549": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-15550": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-15551": {"epss_score": 0.00425, "epss_percentile": 0.61703}, "CVE-2019-15552": {"epss_score": 0.01748, "epss_percentile": 0.82081}, "CVE-2019-15553": {"epss_score": 0.00285, "epss_percentile": 0.51522}, "CVE-2019-15554": {"epss_score": 0.0042, "epss_percentile": 0.61456}, "CVE-2019-15555": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-15556": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-15557": {"epss_score": 0.00683, "epss_percentile": 0.71092}, "CVE-2019-15558": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-15559": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15560": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15561": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15562": {"epss_score": 0.00454, "epss_percentile": 0.63259}, "CVE-2019-15563": {"epss_score": 0.00378, "epss_percentile": 0.58814}, "CVE-2019-15564": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15565": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15566": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15567": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15568": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15569": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-15570": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-15571": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-15572": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15573": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-15574": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-15575": {"epss_score": 0.02675, "epss_percentile": 0.854}, "CVE-2019-15576": {"epss_score": 0.00566, "epss_percentile": 0.67834}, "CVE-2019-15577": {"epss_score": 0.00125, "epss_percentile": 0.32534}, "CVE-2019-15578": {"epss_score": 0.00182, "epss_percentile": 0.40258}, "CVE-2019-15579": {"epss_score": 0.00182, "epss_percentile": 0.40258}, "CVE-2019-15580": {"epss_score": 0.00324, "epss_percentile": 0.54935}, "CVE-2019-15581": {"epss_score": 0.00197, "epss_percentile": 0.41901}, "CVE-2019-15582": {"epss_score": 0.00121, "epss_percentile": 0.31816}, "CVE-2019-15583": {"epss_score": 0.00177, "epss_percentile": 0.39542}, "CVE-2019-15584": {"epss_score": 0.00108, "epss_percentile": 0.29766}, "CVE-2019-15585": {"epss_score": 0.0027, "epss_percentile": 0.50246}, "CVE-2019-15586": {"epss_score": 0.00143, "epss_percentile": 0.35189}, "CVE-2019-15587": {"epss_score": 0.03032, "epss_percentile": 0.86251}, "CVE-2019-15588": {"epss_score": 0.07654, "epss_percentile": 0.91606}, "CVE-2019-15589": {"epss_score": 0.00105, "epss_percentile": 0.29298}, "CVE-2019-15590": {"epss_score": 0.00109, "epss_percentile": 0.29975}, "CVE-2019-15591": {"epss_score": 0.00212, "epss_percentile": 0.43774}, "CVE-2019-15592": {"epss_score": 0.00736, "epss_percentile": 0.72302}, "CVE-2019-15593": {"epss_score": 0.00138, "epss_percentile": 0.34506}, "CVE-2019-15594": {"epss_score": 0.00339, "epss_percentile": 0.56195}, "CVE-2019-15595": {"epss_score": 0.0066, "epss_percentile": 0.70533}, "CVE-2019-15596": {"epss_score": 0.00595, "epss_percentile": 0.68691}, "CVE-2019-15597": {"epss_score": 0.03754, "epss_percentile": 0.87681}, "CVE-2019-15598": {"epss_score": 0.03754, "epss_percentile": 0.87681}, "CVE-2019-15599": {"epss_score": 0.03754, "epss_percentile": 0.87681}, "CVE-2019-15600": {"epss_score": 0.01457, "epss_percentile": 0.80403}, "CVE-2019-15602": {"epss_score": 0.00268, "epss_percentile": 0.5006}, "CVE-2019-15603": {"epss_score": 0.00268, "epss_percentile": 0.5006}, "CVE-2019-15604": {"epss_score": 0.04722, "epss_percentile": 0.89056}, "CVE-2019-15605": {"epss_score": 0.32252, "epss_percentile": 0.96682}, "CVE-2019-15606": {"epss_score": 0.0174, "epss_percentile": 0.82044}, "CVE-2019-15607": {"epss_score": 0.00197, "epss_percentile": 0.41829}, "CVE-2019-15608": {"epss_score": 0.00463, "epss_percentile": 0.63687}, "CVE-2019-15609": {"epss_score": 0.05001, "epss_percentile": 0.89379}, "CVE-2019-15610": {"epss_score": 0.00561, "epss_percentile": 0.67678}, "CVE-2019-15611": {"epss_score": 0.00662, "epss_percentile": 0.70606}, "CVE-2019-15612": {"epss_score": 0.0018, "epss_percentile": 0.39975}, "CVE-2019-15613": {"epss_score": 0.00264, "epss_percentile": 0.49578}, "CVE-2019-15614": {"epss_score": 0.00252, "epss_percentile": 0.48383}, "CVE-2019-15615": {"epss_score": 0.00051, "epss_percentile": 0.1632}, "CVE-2019-15616": {"epss_score": 0.00268, "epss_percentile": 0.50083}, "CVE-2019-15617": {"epss_score": 0.00107, "epss_percentile": 0.29683}, "CVE-2019-15618": {"epss_score": 0.00196, "epss_percentile": 0.41791}, "CVE-2019-15619": {"epss_score": 0.0025, "epss_percentile": 0.48256}, "CVE-2019-15620": {"epss_score": 0.00162, "epss_percentile": 0.37721}, "CVE-2019-15621": {"epss_score": 0.00121, "epss_percentile": 0.31886}, "CVE-2019-15622": {"epss_score": 0.00129, "epss_percentile": 0.33127}, "CVE-2019-15623": {"epss_score": 0.00322, "epss_percentile": 0.5482}, "CVE-2019-15624": {"epss_score": 0.00315, "epss_percentile": 0.54185}, "CVE-2019-15625": {"epss_score": 0.00211, "epss_percentile": 0.43643}, "CVE-2019-15626": {"epss_score": 0.00251, "epss_percentile": 0.48332}, "CVE-2019-15627": {"epss_score": 0.00771, "epss_percentile": 0.73025}, "CVE-2019-15628": {"epss_score": 0.00242, "epss_percentile": 0.47396}, "CVE-2019-15629": {"epss_score": 0.0058, "epss_percentile": 0.6825}, "CVE-2019-15630": {"epss_score": 0.00429, "epss_percentile": 0.61972}, "CVE-2019-15631": {"epss_score": 0.02509, "epss_percentile": 0.84946}, "CVE-2019-15635": {"epss_score": 0.0022, "epss_percentile": 0.44608}, "CVE-2019-15637": {"epss_score": 0.22725, "epss_percentile": 0.95674}, "CVE-2019-15638": {"epss_score": 0.00082, "epss_percentile": 0.24398}, "CVE-2019-15639": {"epss_score": 0.088, "epss_percentile": 0.92259}, "CVE-2019-15640": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-15641": {"epss_score": 0.00839, "epss_percentile": 0.74197}, "CVE-2019-15642": {"epss_score": 0.92499, "epss_percentile": 0.9972}, "CVE-2019-15643": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-15644": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-15645": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2019-15646": {"epss_score": 0.00652, "epss_percentile": 0.70315}, "CVE-2019-15647": {"epss_score": 0.10479, "epss_percentile": 0.93}, "CVE-2019-15648": {"epss_score": 0.00176, "epss_percentile": 0.39394}, "CVE-2019-15649": {"epss_score": 0.00779, "epss_percentile": 0.73154}, "CVE-2019-15650": {"epss_score": 0.00152, "epss_percentile": 0.36496}, "CVE-2019-15651": {"epss_score": 0.00225, "epss_percentile": 0.45134}, "CVE-2019-15652": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-15653": {"epss_score": 0.00805, "epss_percentile": 0.73631}, "CVE-2019-15654": {"epss_score": 0.00405, "epss_percentile": 0.6051}, "CVE-2019-15655": {"epss_score": 0.01312, "epss_percentile": 0.79378}, "CVE-2019-15656": {"epss_score": 0.01151, "epss_percentile": 0.78035}, "CVE-2019-15657": {"epss_score": 0.01031, "epss_percentile": 0.76854}, "CVE-2019-15658": {"epss_score": 0.00204, "epss_percentile": 0.42664}, "CVE-2019-15659": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2019-15660": {"epss_score": 0.00148, "epss_percentile": 0.35822}, "CVE-2019-15661": {"epss_score": 0.02295, "epss_percentile": 0.84291}, "CVE-2019-15662": {"epss_score": 0.00286, "epss_percentile": 0.51699}, "CVE-2019-15663": {"epss_score": 0.00292, "epss_percentile": 0.52217}, "CVE-2019-15664": {"epss_score": 0.00292, "epss_percentile": 0.52217}, "CVE-2019-15665": {"epss_score": 0.01248, "epss_percentile": 0.78866}, "CVE-2019-15666": {"epss_score": 0.06419, "epss_percentile": 0.90748}, "CVE-2019-15678": {"epss_score": 0.01494, "epss_percentile": 0.80649}, "CVE-2019-15679": {"epss_score": 0.01494, "epss_percentile": 0.80649}, "CVE-2019-15680": {"epss_score": 0.00337, "epss_percentile": 0.56039}, "CVE-2019-15681": {"epss_score": 0.06191, "epss_percentile": 0.90548}, "CVE-2019-15682": {"epss_score": 0.00435, "epss_percentile": 0.62381}, "CVE-2019-15683": {"epss_score": 0.03001, "epss_percentile": 0.86166}, "CVE-2019-15684": {"epss_score": 0.00092, "epss_percentile": 0.26504}, "CVE-2019-15685": {"epss_score": 0.00327, "epss_percentile": 0.55125}, "CVE-2019-15686": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2019-15687": {"epss_score": 0.0045, "epss_percentile": 0.63066}, "CVE-2019-15688": {"epss_score": 0.001, "epss_percentile": 0.28447}, "CVE-2019-15689": {"epss_score": 0.00055, "epss_percentile": 0.17505}, "CVE-2019-15690": {"epss_score": 0.01662, "epss_percentile": 0.81636}, "CVE-2019-15691": {"epss_score": 0.03872, "epss_percentile": 0.87883}, "CVE-2019-15692": {"epss_score": 0.05295, "epss_percentile": 0.89701}, "CVE-2019-15693": {"epss_score": 0.0938, "epss_percentile": 0.92524}, "CVE-2019-15694": {"epss_score": 0.06309, "epss_percentile": 0.90661}, "CVE-2019-15695": {"epss_score": 0.03424, "epss_percentile": 0.87111}, "CVE-2019-15698": {"epss_score": 0.00284, "epss_percentile": 0.51461}, "CVE-2019-15699": {"epss_score": 0.00562, "epss_percentile": 0.67699}, "CVE-2019-15700": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-15701": {"epss_score": 0.00655, "epss_percentile": 0.70425}, "CVE-2019-15702": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-15703": {"epss_score": 0.003, "epss_percentile": 0.52984}, "CVE-2019-15704": {"epss_score": 0.00025, "epss_percentile": 0.06236}, "CVE-2019-15705": {"epss_score": 0.00576, "epss_percentile": 0.68124}, "CVE-2019-15706": {"epss_score": 0.00053, "epss_percentile": 0.16899}, "CVE-2019-15707": {"epss_score": 0.00682, "epss_percentile": 0.71075}, "CVE-2019-15708": {"epss_score": 0.00234, "epss_percentile": 0.46159}, "CVE-2019-15709": {"epss_score": 0.00564, "epss_percentile": 0.67765}, "CVE-2019-15710": {"epss_score": 0.02755, "epss_percentile": 0.85591}, "CVE-2019-15711": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2019-15712": {"epss_score": 0.00539, "epss_percentile": 0.66966}, "CVE-2019-15713": {"epss_score": 0.04716, "epss_percentile": 0.89044}, "CVE-2019-15714": {"epss_score": 0.00147, "epss_percentile": 0.35672}, "CVE-2019-15715": {"epss_score": 0.24155, "epss_percentile": 0.9588}, "CVE-2019-15716": {"epss_score": 0.00046, "epss_percentile": 0.14416}, "CVE-2019-15717": {"epss_score": 0.00763, "epss_percentile": 0.7285}, "CVE-2019-15718": {"epss_score": 0.00105, "epss_percentile": 0.2935}, "CVE-2019-15719": {"epss_score": 0.01394, "epss_percentile": 0.79971}, "CVE-2019-15720": {"epss_score": 0.00031, "epss_percentile": 0.0839}, "CVE-2019-15721": {"epss_score": 0.00079, "epss_percentile": 0.23946}, "CVE-2019-15722": {"epss_score": 0.00296, "epss_percentile": 0.52545}, "CVE-2019-15723": {"epss_score": 0.00241, "epss_percentile": 0.47284}, "CVE-2019-15724": {"epss_score": 0.00189, "epss_percentile": 0.40976}, "CVE-2019-15725": {"epss_score": 0.00463, "epss_percentile": 0.63666}, "CVE-2019-15726": {"epss_score": 0.00264, "epss_percentile": 0.49705}, "CVE-2019-15727": {"epss_score": 0.00264, "epss_percentile": 0.49705}, "CVE-2019-15728": {"epss_score": 0.00241, "epss_percentile": 0.47284}, "CVE-2019-15729": {"epss_score": 0.00463, "epss_percentile": 0.63666}, "CVE-2019-15730": {"epss_score": 0.00241, "epss_percentile": 0.47284}, "CVE-2019-15731": {"epss_score": 0.00241, "epss_percentile": 0.47284}, "CVE-2019-15732": {"epss_score": 0.00264, "epss_percentile": 0.49705}, "CVE-2019-15733": {"epss_score": 0.00141, "epss_percentile": 0.34911}, "CVE-2019-15734": {"epss_score": 0.00143, "epss_percentile": 0.3515}, "CVE-2019-15736": {"epss_score": 0.00296, "epss_percentile": 0.52545}, "CVE-2019-15737": {"epss_score": 0.00321, "epss_percentile": 0.54735}, "CVE-2019-15738": {"epss_score": 0.00264, "epss_percentile": 0.49705}, "CVE-2019-15739": {"epss_score": 0.00189, "epss_percentile": 0.40976}, "CVE-2019-15740": {"epss_score": 0.00264, "epss_percentile": 0.49705}, "CVE-2019-15741": {"epss_score": 0.00317, "epss_percentile": 0.54358}, "CVE-2019-15742": {"epss_score": 0.08764, "epss_percentile": 0.92245}, "CVE-2019-15743": {"epss_score": 0.00125, "epss_percentile": 0.32595}, "CVE-2019-15744": {"epss_score": 0.00121, "epss_percentile": 0.31912}, "CVE-2019-15745": {"epss_score": 0.0019, "epss_percentile": 0.41142}, "CVE-2019-15746": {"epss_score": 0.00368, "epss_percentile": 0.58174}, "CVE-2019-15747": {"epss_score": 0.00299, "epss_percentile": 0.52865}, "CVE-2019-15748": {"epss_score": 0.02031, "epss_percentile": 0.83335}, "CVE-2019-15749": {"epss_score": 0.00209, "epss_percentile": 0.43412}, "CVE-2019-15750": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2019-15751": {"epss_score": 0.07923, "epss_percentile": 0.91764}, "CVE-2019-15752": {"epss_score": 0.44567, "epss_percentile": 0.97444}, "CVE-2019-15753": {"epss_score": 0.00965, "epss_percentile": 0.76038}, "CVE-2019-15757": {"epss_score": 0.00378, "epss_percentile": 0.58805}, "CVE-2019-15758": {"epss_score": 0.00311, "epss_percentile": 0.53846}, "CVE-2019-15759": {"epss_score": 0.00312, "epss_percentile": 0.53966}, "CVE-2019-15766": {"epss_score": 0.02289, "epss_percentile": 0.84274}, "CVE-2019-15767": {"epss_score": 0.00305, "epss_percentile": 0.53385}, "CVE-2019-15769": {"epss_score": 0.00131, "epss_percentile": 0.33411}, "CVE-2019-15770": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2019-15771": {"epss_score": 0.00342, "epss_percentile": 0.56369}, "CVE-2019-15772": {"epss_score": 0.00201, "epss_percentile": 0.42356}, "CVE-2019-15773": {"epss_score": 0.00201, "epss_percentile": 0.42356}, "CVE-2019-15774": {"epss_score": 0.00933, "epss_percentile": 0.75645}, "CVE-2019-15775": {"epss_score": 0.00201, "epss_percentile": 0.42356}, "CVE-2019-15776": {"epss_score": 0.00201, "epss_percentile": 0.42356}, "CVE-2019-15777": {"epss_score": 0.00208, "epss_percentile": 0.43252}, "CVE-2019-15778": {"epss_score": 0.00325, "epss_percentile": 0.55012}, "CVE-2019-15779": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2019-15780": {"epss_score": 0.01105, "epss_percentile": 0.77605}, "CVE-2019-15781": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2019-15782": {"epss_score": 0.00208, "epss_percentile": 0.43208}, "CVE-2019-15783": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2019-15784": {"epss_score": 0.00434, "epss_percentile": 0.62315}, "CVE-2019-15785": {"epss_score": 0.00587, "epss_percentile": 0.68481}, "CVE-2019-15786": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2019-15787": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2019-15788": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-15789": {"epss_score": 0.00045, "epss_percentile": 0.14061}, "CVE-2019-15790": {"epss_score": 0.00049, "epss_percentile": 0.15379}, "CVE-2019-15791": {"epss_score": 0.0013, "epss_percentile": 0.3323}, "CVE-2019-15792": {"epss_score": 0.00214, "epss_percentile": 0.43953}, "CVE-2019-15793": {"epss_score": 0.00034, "epss_percentile": 0.0945}, "CVE-2019-15794": {"epss_score": 0.00375, "epss_percentile": 0.58632}, "CVE-2019-15795": {"epss_score": 0.00184, "epss_percentile": 0.4045}, "CVE-2019-15796": {"epss_score": 0.00174, "epss_percentile": 0.39178}, "CVE-2019-15799": {"epss_score": 0.00398, "epss_percentile": 0.60061}, "CVE-2019-15800": {"epss_score": 0.0308, "epss_percentile": 0.86372}, "CVE-2019-15801": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2019-15802": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2019-15803": {"epss_score": 0.00376, "epss_percentile": 0.58687}, "CVE-2019-15804": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-15805": {"epss_score": 0.0023, "epss_percentile": 0.45709}, "CVE-2019-15806": {"epss_score": 0.0023, "epss_percentile": 0.45709}, "CVE-2019-15807": {"epss_score": 0.00088, "epss_percentile": 0.25756}, "CVE-2019-15809": {"epss_score": 0.00105, "epss_percentile": 0.29295}, "CVE-2019-15810": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-15811": {"epss_score": 0.01196, "epss_percentile": 0.78439}, "CVE-2019-15813": {"epss_score": 0.04186, "epss_percentile": 0.88361}, "CVE-2019-15814": {"epss_score": 0.00224, "epss_percentile": 0.4498}, "CVE-2019-15815": {"epss_score": 0.00215, "epss_percentile": 0.44054}, "CVE-2019-15816": {"epss_score": 0.00261, "epss_percentile": 0.49271}, "CVE-2019-15817": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-15818": {"epss_score": 0.00194, "epss_percentile": 0.41577}, "CVE-2019-15819": {"epss_score": 0.01736, "epss_percentile": 0.82012}, "CVE-2019-15820": {"epss_score": 0.00194, "epss_percentile": 0.41577}, "CVE-2019-15821": {"epss_score": 0.0031, "epss_percentile": 0.53752}, "CVE-2019-15822": {"epss_score": 0.01801, "epss_percentile": 0.82328}, "CVE-2019-15823": {"epss_score": 0.61914, "epss_percentile": 0.98267}, "CVE-2019-15824": {"epss_score": 0.01024, "epss_percentile": 0.76781}, "CVE-2019-15825": {"epss_score": 0.01024, "epss_percentile": 0.76781}, "CVE-2019-15826": {"epss_score": 0.01118, "epss_percentile": 0.77747}, "CVE-2019-15827": {"epss_score": 0.00267, "epss_percentile": 0.49994}, "CVE-2019-15828": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2019-15829": {"epss_score": 0.01087, "epss_percentile": 0.77432}, "CVE-2019-15830": {"epss_score": 0.00208, "epss_percentile": 0.43252}, "CVE-2019-15831": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2019-15832": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2019-15833": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-15834": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2019-15835": {"epss_score": 0.0024, "epss_percentile": 0.46944}, "CVE-2019-15836": {"epss_score": 0.00259, "epss_percentile": 0.49047}, "CVE-2019-15837": {"epss_score": 0.00352, "epss_percentile": 0.57084}, "CVE-2019-15838": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2019-15839": {"epss_score": 0.00796, "epss_percentile": 0.73486}, "CVE-2019-15840": {"epss_score": 0.00132, "epss_percentile": 0.33619}, "CVE-2019-15841": {"epss_score": 0.00132, "epss_percentile": 0.33619}, "CVE-2019-15842": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2019-15843": {"epss_score": 0.00266, "epss_percentile": 0.49895}, "CVE-2019-15845": {"epss_score": 0.00321, "epss_percentile": 0.54741}, "CVE-2019-15846": {"epss_score": 0.66505, "epss_percentile": 0.98465}, "CVE-2019-15847": {"epss_score": 0.00567, "epss_percentile": 0.67854}, "CVE-2019-15848": {"epss_score": 7e-05, "epss_percentile": 0.00324}, "CVE-2019-15849": {"epss_score": 0.00126, "epss_percentile": 0.32733}, "CVE-2019-15850": {"epss_score": 0.04534, "epss_percentile": 0.88814}, "CVE-2019-15854": {"epss_score": 0.00796, "epss_percentile": 0.73489}, "CVE-2019-15855": {"epss_score": 0.0134, "epss_percentile": 0.79577}, "CVE-2019-15858": {"epss_score": 0.59563, "epss_percentile": 0.9817}, "CVE-2019-15859": {"epss_score": 0.7572, "epss_percentile": 0.98861}, "CVE-2019-15860": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2019-15862": {"epss_score": 0.00371, "epss_percentile": 0.5838}, "CVE-2019-15863": {"epss_score": 0.00389, "epss_percentile": 0.59402}, "CVE-2019-15864": {"epss_score": 0.00368, "epss_percentile": 0.58206}, "CVE-2019-15865": {"epss_score": 0.0024, "epss_percentile": 0.46944}, "CVE-2019-15866": {"epss_score": 0.00462, "epss_percentile": 0.63586}, "CVE-2019-15867": {"epss_score": 0.01084, "epss_percentile": 0.77395}, "CVE-2019-15868": {"epss_score": 0.00175, "epss_percentile": 0.39337}, "CVE-2019-15869": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2019-15870": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2019-15871": {"epss_score": 0.00115, "epss_percentile": 0.30992}, "CVE-2019-15872": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2019-15873": {"epss_score": 0.09583, "epss_percentile": 0.92608}, "CVE-2019-15874": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2019-15875": {"epss_score": 0.00119, "epss_percentile": 0.31551}, "CVE-2019-15876": {"epss_score": 0.00115, "epss_percentile": 0.30901}, "CVE-2019-15877": {"epss_score": 0.00047, "epss_percentile": 0.14806}, "CVE-2019-15878": {"epss_score": 0.00053, "epss_percentile": 0.16754}, "CVE-2019-15879": {"epss_score": 0.00327, "epss_percentile": 0.55107}, "CVE-2019-15880": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2019-15889": {"epss_score": 0.04269, "epss_percentile": 0.88473}, "CVE-2019-15890": {"epss_score": 0.00424, "epss_percentile": 0.61653}, "CVE-2019-15891": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2019-15892": {"epss_score": 0.05554, "epss_percentile": 0.89988}, "CVE-2019-15893": {"epss_score": 0.0301, "epss_percentile": 0.86196}, "CVE-2019-15894": {"epss_score": 0.00053, "epss_percentile": 0.16752}, "CVE-2019-15895": {"epss_score": 0.00442, "epss_percentile": 0.6272}, "CVE-2019-15896": {"epss_score": 0.0372, "epss_percentile": 0.87619}, "CVE-2019-15897": {"epss_score": 0.00182, "epss_percentile": 0.40238}, "CVE-2019-15898": {"epss_score": 0.03828, "epss_percentile": 0.87797}, "CVE-2019-15900": {"epss_score": 0.00346, "epss_percentile": 0.56624}, "CVE-2019-15901": {"epss_score": 0.00575, "epss_percentile": 0.68111}, "CVE-2019-15902": {"epss_score": 0.00088, "epss_percentile": 0.2565}, "CVE-2019-15903": {"epss_score": 0.00208, "epss_percentile": 0.43304}, "CVE-2019-15910": {"epss_score": 0.00436, "epss_percentile": 0.62451}, "CVE-2019-15911": {"epss_score": 0.00673, "epss_percentile": 0.70841}, "CVE-2019-15912": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2019-15913": {"epss_score": 0.00341, "epss_percentile": 0.56296}, "CVE-2019-15914": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2019-15915": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2019-15916": {"epss_score": 0.02605, "epss_percentile": 0.85221}, "CVE-2019-15917": {"epss_score": 0.00087, "epss_percentile": 0.25524}, "CVE-2019-15918": {"epss_score": 0.001, "epss_percentile": 0.28469}, "CVE-2019-15919": {"epss_score": 0.00057, "epss_percentile": 0.18003}, "CVE-2019-15920": {"epss_score": 0.00548, "epss_percentile": 0.67288}, "CVE-2019-15921": {"epss_score": 0.00073, "epss_percentile": 0.22475}, "CVE-2019-15922": {"epss_score": 0.00091, "epss_percentile": 0.26202}, "CVE-2019-15923": {"epss_score": 0.00046, "epss_percentile": 0.14464}, "CVE-2019-15924": {"epss_score": 0.00071, "epss_percentile": 0.22219}, "CVE-2019-15925": {"epss_score": 0.00108, "epss_percentile": 0.29845}, "CVE-2019-15926": {"epss_score": 0.05955, "epss_percentile": 0.90361}, "CVE-2019-15927": {"epss_score": 0.0012, "epss_percentile": 0.31754}, "CVE-2019-15929": {"epss_score": 0.00358, "epss_percentile": 0.57516}, "CVE-2019-15930": {"epss_score": 0.0036, "epss_percentile": 0.57649}, "CVE-2019-15931": {"epss_score": 0.00729, "epss_percentile": 0.72126}, "CVE-2019-15932": {"epss_score": 0.00444, "epss_percentile": 0.6281}, "CVE-2019-15933": {"epss_score": 0.00375, "epss_percentile": 0.58611}, "CVE-2019-15934": {"epss_score": 0.00164, "epss_percentile": 0.3787}, "CVE-2019-15935": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2019-15936": {"epss_score": 0.005, "epss_percentile": 0.65328}, "CVE-2019-15937": {"epss_score": 0.00756, "epss_percentile": 0.72746}, "CVE-2019-15938": {"epss_score": 0.00756, "epss_percentile": 0.72746}, "CVE-2019-15939": {"epss_score": 0.01026, "epss_percentile": 0.76795}, "CVE-2019-15940": {"epss_score": 0.00478, "epss_percentile": 0.64377}, "CVE-2019-15941": {"epss_score": 0.00548, "epss_percentile": 0.67288}, "CVE-2019-15942": {"epss_score": 0.005, "epss_percentile": 0.65312}, "CVE-2019-15943": {"epss_score": 0.21687, "epss_percentile": 0.95547}, "CVE-2019-15944": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-15945": {"epss_score": 0.0006, "epss_percentile": 0.19212}, "CVE-2019-15946": {"epss_score": 0.00049, "epss_percentile": 0.15499}, "CVE-2019-15947": {"epss_score": 0.00281, "epss_percentile": 0.51187}, "CVE-2019-15948": {"epss_score": 0.08374, "epss_percentile": 0.92016}, "CVE-2019-15949": {"epss_score": 0.87055, "epss_percentile": 0.99411}, "CVE-2019-15950": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2019-15952": {"epss_score": 0.07576, "epss_percentile": 0.91548}, "CVE-2019-15953": {"epss_score": 0.00705, "epss_percentile": 0.71583}, "CVE-2019-15954": {"epss_score": 0.56909, "epss_percentile": 0.9804}, "CVE-2019-15955": {"epss_score": 0.00128, "epss_percentile": 0.32943}, "CVE-2019-15956": {"epss_score": 0.00195, "epss_percentile": 0.41649}, "CVE-2019-15957": {"epss_score": 0.01101, "epss_percentile": 0.77577}, "CVE-2019-15958": {"epss_score": 0.02481, "epss_percentile": 0.84874}, "CVE-2019-15959": {"epss_score": 0.00179, "epss_percentile": 0.39824}, "CVE-2019-15960": {"epss_score": 0.00213, "epss_percentile": 0.43843}, "CVE-2019-15961": {"epss_score": 0.02219, "epss_percentile": 0.84046}, "CVE-2019-15962": {"epss_score": 0.00154, "epss_percentile": 0.36687}, "CVE-2019-15963": {"epss_score": 0.00202, "epss_percentile": 0.42417}, "CVE-2019-15966": {"epss_score": 0.00851, "epss_percentile": 0.74411}, "CVE-2019-15967": {"epss_score": 0.00152, "epss_percentile": 0.36422}, "CVE-2019-15968": {"epss_score": 0.00287, "epss_percentile": 0.51802}, "CVE-2019-15969": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2019-15971": {"epss_score": 0.0017, "epss_percentile": 0.38688}, "CVE-2019-15972": {"epss_score": 0.04005, "epss_percentile": 0.88098}, "CVE-2019-15973": {"epss_score": 0.00234, "epss_percentile": 0.46198}, "CVE-2019-15974": {"epss_score": 0.00249, "epss_percentile": 0.4804}, "CVE-2019-15975": {"epss_score": 0.85137, "epss_percentile": 0.99321}, "CVE-2019-15976": {"epss_score": 0.28235, "epss_percentile": 0.96335}, "CVE-2019-15977": {"epss_score": 0.39388, "epss_percentile": 0.97158}, "CVE-2019-15978": {"epss_score": 0.15914, "epss_percentile": 0.94531}, "CVE-2019-15979": {"epss_score": 0.02217, "epss_percentile": 0.84039}, "CVE-2019-15980": {"epss_score": 0.20848, "epss_percentile": 0.95428}, "CVE-2019-15981": {"epss_score": 0.20848, "epss_percentile": 0.95428}, "CVE-2019-15982": {"epss_score": 0.20848, "epss_percentile": 0.95428}, "CVE-2019-15983": {"epss_score": 0.00816, "epss_percentile": 0.73797}, "CVE-2019-15984": {"epss_score": 0.15914, "epss_percentile": 0.94531}, "CVE-2019-15985": {"epss_score": 0.02217, "epss_percentile": 0.84039}, "CVE-2019-15986": {"epss_score": 0.00147, "epss_percentile": 0.3579}, "CVE-2019-15987": {"epss_score": 0.00904, "epss_percentile": 0.75213}, "CVE-2019-15988": {"epss_score": 0.00336, "epss_percentile": 0.55945}, "CVE-2019-15989": {"epss_score": 0.02503, "epss_percentile": 0.84929}, "CVE-2019-15990": {"epss_score": 0.00311, "epss_percentile": 0.53844}, "CVE-2019-15992": {"epss_score": 0.05024, "epss_percentile": 0.89406}, "CVE-2019-15993": {"epss_score": 0.20581, "epss_percentile": 0.9538}, "CVE-2019-15994": {"epss_score": 0.00234, "epss_percentile": 0.46198}, "CVE-2019-15995": {"epss_score": 0.00578, "epss_percentile": 0.68191}, "CVE-2019-15996": {"epss_score": 0.00093, "epss_percentile": 0.26706}, "CVE-2019-15997": {"epss_score": 0.00164, "epss_percentile": 0.37959}, "CVE-2019-15998": {"epss_score": 0.00359, "epss_percentile": 0.57616}, "CVE-2019-15999": {"epss_score": 0.03155, "epss_percentile": 0.86513}, "CVE-2019-16000": {"epss_score": 0.00025, "epss_percentile": 0.06343}, "CVE-2019-16001": {"epss_score": 0.0019, "epss_percentile": 0.41068}, "CVE-2019-16002": {"epss_score": 0.0033, "epss_percentile": 0.55479}, "CVE-2019-16003": {"epss_score": 0.01094, "epss_percentile": 0.77492}, "CVE-2019-16004": {"epss_score": 0.00247, "epss_percentile": 0.47819}, "CVE-2019-16005": {"epss_score": 0.00728, "epss_percentile": 0.72103}, "CVE-2019-16007": {"epss_score": 0.00172, "epss_percentile": 0.38965}, "CVE-2019-16008": {"epss_score": 0.00287, "epss_percentile": 0.51802}, "CVE-2019-16009": {"epss_score": 0.02786, "epss_percentile": 0.85658}, "CVE-2019-16010": {"epss_score": 0.00239, "epss_percentile": 0.46877}, "CVE-2019-16011": {"epss_score": 0.00099, "epss_percentile": 0.28348}, "CVE-2019-16012": {"epss_score": 0.06718, "epss_percentile": 0.90965}, "CVE-2019-16015": {"epss_score": 0.00319, "epss_percentile": 0.54468}, "CVE-2019-16017": {"epss_score": 0.00104, "epss_percentile": 0.29101}, "CVE-2019-16018": {"epss_score": 0.01921, "epss_percentile": 0.82899}, "CVE-2019-16019": {"epss_score": 0.01625, "epss_percentile": 0.81423}, "CVE-2019-16020": {"epss_score": 0.02503, "epss_percentile": 0.84929}, "CVE-2019-16021": {"epss_score": 0.01625, "epss_percentile": 0.81423}, "CVE-2019-16022": {"epss_score": 0.02503, "epss_percentile": 0.84929}, "CVE-2019-16023": {"epss_score": 0.01625, "epss_percentile": 0.81423}, "CVE-2019-16024": {"epss_score": 0.00234, "epss_percentile": 0.46198}, "CVE-2019-16025": {"epss_score": 0.00152, "epss_percentile": 0.36371}, "CVE-2019-16026": {"epss_score": 0.00698, "epss_percentile": 0.71422}, "CVE-2019-16027": {"epss_score": 0.01067, "epss_percentile": 0.77229}, "CVE-2019-16028": {"epss_score": 0.03423, "epss_percentile": 0.87107}, "CVE-2019-16029": {"epss_score": 0.00491, "epss_percentile": 0.64969}, "CVE-2019-16056": {"epss_score": 0.00912, "epss_percentile": 0.75362}, "CVE-2019-16057": {"epss_score": 0.9375, "epss_percentile": 0.99839}, "CVE-2019-16058": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2019-16059": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-16060": {"epss_score": 0.00312, "epss_percentile": 0.5396}, "CVE-2019-16061": {"epss_score": 0.00226, "epss_percentile": 0.45334}, "CVE-2019-16062": {"epss_score": 0.00172, "epss_percentile": 0.39007}, "CVE-2019-16063": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2019-16064": {"epss_score": 0.01025, "epss_percentile": 0.76791}, "CVE-2019-16065": {"epss_score": 0.0134, "epss_percentile": 0.7958}, "CVE-2019-16066": {"epss_score": 0.00401, "epss_percentile": 0.60203}, "CVE-2019-16067": {"epss_score": 0.00153, "epss_percentile": 0.3654}, "CVE-2019-16068": {"epss_score": 0.00457, "epss_percentile": 0.63378}, "CVE-2019-16069": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-16070": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2019-16071": {"epss_score": 0.00107, "epss_percentile": 0.29664}, "CVE-2019-16072": {"epss_score": 0.85675, "epss_percentile": 0.99342}, "CVE-2019-16088": {"epss_score": 0.00418, "epss_percentile": 0.61292}, "CVE-2019-16089": {"epss_score": 0.00109, "epss_percentile": 0.30042}, "CVE-2019-16091": {"epss_score": 0.00457, "epss_percentile": 0.63365}, "CVE-2019-16092": {"epss_score": 0.00408, "epss_percentile": 0.60636}, "CVE-2019-16093": {"epss_score": 0.0047, "epss_percentile": 0.63975}, "CVE-2019-16094": {"epss_score": 0.00452, "epss_percentile": 0.63163}, "CVE-2019-16095": {"epss_score": 0.00457, "epss_percentile": 0.63365}, "CVE-2019-16096": {"epss_score": 0.00594, "epss_percentile": 0.68655}, "CVE-2019-16097": {"epss_score": 0.93503, "epss_percentile": 0.99812}, "CVE-2019-16098": {"epss_score": 0.77006, "epss_percentile": 0.98915}, "CVE-2019-16099": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-16100": {"epss_score": 0.00623, "epss_percentile": 0.6954}, "CVE-2019-16101": {"epss_score": 0.00244, "epss_percentile": 0.47619}, "CVE-2019-16102": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-16103": {"epss_score": 0.00726, "epss_percentile": 0.72072}, "CVE-2019-16104": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-16105": {"epss_score": 0.00425, "epss_percentile": 0.6172}, "CVE-2019-16106": {"epss_score": 0.00447, "epss_percentile": 0.62944}, "CVE-2019-16107": {"epss_score": 0.00089, "epss_percentile": 0.25878}, "CVE-2019-16108": {"epss_score": 0.00253, "epss_percentile": 0.48463}, "CVE-2019-16109": {"epss_score": 0.00297, "epss_percentile": 0.52713}, "CVE-2019-16110": {"epss_score": 0.02379, "epss_percentile": 0.84562}, "CVE-2019-16112": {"epss_score": 0.01994, "epss_percentile": 0.83189}, "CVE-2019-16113": {"epss_score": 0.89959, "epss_percentile": 0.99553}, "CVE-2019-16114": {"epss_score": 0.20795, "epss_percentile": 0.95413}, "CVE-2019-16115": {"epss_score": 0.0018, "epss_percentile": 0.39919}, "CVE-2019-16116": {"epss_score": 0.03009, "epss_percentile": 0.86193}, "CVE-2019-16117": {"epss_score": 0.01645, "epss_percentile": 0.81526}, "CVE-2019-16118": {"epss_score": 0.02552, "epss_percentile": 0.85079}, "CVE-2019-16119": {"epss_score": 0.29386, "epss_percentile": 0.96439}, "CVE-2019-16120": {"epss_score": 0.02856, "epss_percentile": 0.85841}, "CVE-2019-16123": {"epss_score": 0.36652, "epss_percentile": 0.96993}, "CVE-2019-16124": {"epss_score": 0.02121, "epss_percentile": 0.83676}, "CVE-2019-16125": {"epss_score": 0.00622, "epss_percentile": 0.6953}, "CVE-2019-16126": {"epss_score": 0.00613, "epss_percentile": 0.69254}, "CVE-2019-16127": {"epss_score": 0.00374, "epss_percentile": 0.5859}, "CVE-2019-16128": {"epss_score": 0.001, "epss_percentile": 0.28463}, "CVE-2019-16129": {"epss_score": 0.001, "epss_percentile": 0.28463}, "CVE-2019-16130": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-16131": {"epss_score": 0.16451, "epss_percentile": 0.94663}, "CVE-2019-16132": {"epss_score": 0.06784, "epss_percentile": 0.91026}, "CVE-2019-16133": {"epss_score": 0.00266, "epss_percentile": 0.49882}, "CVE-2019-16137": {"epss_score": 0.00324, "epss_percentile": 0.54951}, "CVE-2019-16138": {"epss_score": 0.02203, "epss_percentile": 0.83994}, "CVE-2019-16139": {"epss_score": 0.00382, "epss_percentile": 0.5906}, "CVE-2019-16140": {"epss_score": 0.00509, "epss_percentile": 0.65724}, "CVE-2019-16141": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2019-16142": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-16143": {"epss_score": 0.00203, "epss_percentile": 0.42502}, "CVE-2019-16144": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2019-16145": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-16146": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-16147": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-16148": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-16149": {"epss_score": 0.00047, "epss_percentile": 0.1489}, "CVE-2019-16150": {"epss_score": 0.00214, "epss_percentile": 0.44006}, "CVE-2019-16151": {"epss_score": 0.00087, "epss_percentile": 0.25502}, "CVE-2019-16152": {"epss_score": 0.00352, "epss_percentile": 0.57079}, "CVE-2019-16153": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2019-16154": {"epss_score": 0.00529, "epss_percentile": 0.66585}, "CVE-2019-16155": {"epss_score": 0.00044, "epss_percentile": 0.13673}, "CVE-2019-16156": {"epss_score": 0.01032, "epss_percentile": 0.76863}, "CVE-2019-16157": {"epss_score": 0.00328, "epss_percentile": 0.55177}, "CVE-2019-16159": {"epss_score": 0.05295, "epss_percentile": 0.89702}, "CVE-2019-16160": {"epss_score": 0.01282, "epss_percentile": 0.79157}, "CVE-2019-16161": {"epss_score": 0.00259, "epss_percentile": 0.49061}, "CVE-2019-16162": {"epss_score": 0.00256, "epss_percentile": 0.48776}, "CVE-2019-16163": {"epss_score": 0.00085, "epss_percentile": 0.25069}, "CVE-2019-16164": {"epss_score": 0.00285, "epss_percentile": 0.51681}, "CVE-2019-16165": {"epss_score": 0.00516, "epss_percentile": 0.66049}, "CVE-2019-16166": {"epss_score": 0.00513, "epss_percentile": 0.65914}, "CVE-2019-16167": {"epss_score": 0.01477, "epss_percentile": 0.80544}, "CVE-2019-16168": {"epss_score": 0.00843, "epss_percentile": 0.74256}, "CVE-2019-16170": {"epss_score": 0.00138, "epss_percentile": 0.34376}, "CVE-2019-16171": {"epss_score": 6e-05, "epss_percentile": 0.00267}, "CVE-2019-16172": {"epss_score": 0.01355, "epss_percentile": 0.79711}, "CVE-2019-16173": {"epss_score": 0.005, "epss_percentile": 0.65291}, "CVE-2019-16174": {"epss_score": 0.01128, "epss_percentile": 0.77834}, "CVE-2019-16175": {"epss_score": 0.00206, "epss_percentile": 0.43072}, "CVE-2019-16176": {"epss_score": 0.00294, "epss_percentile": 0.524}, "CVE-2019-16177": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-16178": {"epss_score": 0.00336, "epss_percentile": 0.55941}, "CVE-2019-16179": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2019-16180": {"epss_score": 0.00375, "epss_percentile": 0.58594}, "CVE-2019-16181": {"epss_score": 0.00225, "epss_percentile": 0.45133}, "CVE-2019-16182": {"epss_score": 0.00332, "epss_percentile": 0.55583}, "CVE-2019-16183": {"epss_score": 0.00131, "epss_percentile": 0.3335}, "CVE-2019-16184": {"epss_score": 0.00577, "epss_percentile": 0.6817}, "CVE-2019-16185": {"epss_score": 0.00297, "epss_percentile": 0.52744}, "CVE-2019-16186": {"epss_score": 0.00348, "epss_percentile": 0.5684}, "CVE-2019-16187": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2019-16188": {"epss_score": 0.00149, "epss_percentile": 0.36035}, "CVE-2019-16190": {"epss_score": 0.00896, "epss_percentile": 0.75113}, "CVE-2019-16192": {"epss_score": 0.00842, "epss_percentile": 0.74233}, "CVE-2019-16193": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2019-16194": {"epss_score": 0.00154, "epss_percentile": 0.36744}, "CVE-2019-16195": {"epss_score": 0.00066, "epss_percentile": 0.2073}, "CVE-2019-16197": {"epss_score": 0.00184, "epss_percentile": 0.40427}, "CVE-2019-16198": {"epss_score": 0.00372, "epss_percentile": 0.58449}, "CVE-2019-16199": {"epss_score": 0.49415, "epss_percentile": 0.97685}, "CVE-2019-16200": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2019-16201": {"epss_score": 0.00605, "epss_percentile": 0.68987}, "CVE-2019-16202": {"epss_score": 0.00227, "epss_percentile": 0.45444}, "CVE-2019-16203": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-16204": {"epss_score": 0.00348, "epss_percentile": 0.56815}, "CVE-2019-16205": {"epss_score": 0.00352, "epss_percentile": 0.57118}, "CVE-2019-16206": {"epss_score": 0.00023, "epss_percentile": 0.0561}, "CVE-2019-16207": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2019-16208": {"epss_score": 0.00081, "epss_percentile": 0.24302}, "CVE-2019-16209": {"epss_score": 0.00215, "epss_percentile": 0.44111}, "CVE-2019-16210": {"epss_score": 0.00028, "epss_percentile": 0.07447}, "CVE-2019-16211": {"epss_score": 0.00282, "epss_percentile": 0.51285}, "CVE-2019-16212": {"epss_score": 0.00146, "epss_percentile": 0.35553}, "CVE-2019-16213": {"epss_score": 0.02929, "epss_percentile": 0.86013}, "CVE-2019-16214": {"epss_score": 0.00249, "epss_percentile": 0.48015}, "CVE-2019-16215": {"epss_score": 0.00488, "epss_percentile": 0.64828}, "CVE-2019-16216": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2019-16217": {"epss_score": 0.02575, "epss_percentile": 0.85141}, "CVE-2019-16218": {"epss_score": 0.02449, "epss_percentile": 0.84777}, "CVE-2019-16219": {"epss_score": 0.04685, "epss_percentile": 0.89006}, "CVE-2019-16220": {"epss_score": 0.00821, "epss_percentile": 0.73895}, "CVE-2019-16221": {"epss_score": 0.02449, "epss_percentile": 0.84777}, "CVE-2019-16222": {"epss_score": 0.02958, "epss_percentile": 0.86065}, "CVE-2019-16223": {"epss_score": 0.04337, "epss_percentile": 0.88564}, "CVE-2019-16224": {"epss_score": 0.00418, "epss_percentile": 0.61288}, "CVE-2019-16225": {"epss_score": 0.00418, "epss_percentile": 0.61288}, "CVE-2019-16226": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2019-16227": {"epss_score": 0.00399, "epss_percentile": 0.60147}, "CVE-2019-16228": {"epss_score": 0.00172, "epss_percentile": 0.39003}, "CVE-2019-16229": {"epss_score": 0.00031, "epss_percentile": 0.08412}, "CVE-2019-16230": {"epss_score": 0.00065, "epss_percentile": 0.20639}, "CVE-2019-16231": {"epss_score": 0.00045, "epss_percentile": 0.13794}, "CVE-2019-16232": {"epss_score": 0.00045, "epss_percentile": 0.14059}, "CVE-2019-16233": {"epss_score": 0.001, "epss_percentile": 0.2855}, "CVE-2019-16234": {"epss_score": 0.00059, "epss_percentile": 0.18929}, "CVE-2019-16235": {"epss_score": 0.00318, "epss_percentile": 0.54396}, "CVE-2019-16236": {"epss_score": 0.00814, "epss_percentile": 0.73772}, "CVE-2019-16237": {"epss_score": 0.00423, "epss_percentile": 0.61624}, "CVE-2019-16238": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2019-16239": {"epss_score": 0.08525, "epss_percentile": 0.92102}, "CVE-2019-16240": {"epss_score": 0.00602, "epss_percentile": 0.68873}, "CVE-2019-16241": {"epss_score": 0.00059, "epss_percentile": 0.18805}, "CVE-2019-16242": {"epss_score": 0.00626, "epss_percentile": 0.69608}, "CVE-2019-16243": {"epss_score": 0.00207, "epss_percentile": 0.43155}, "CVE-2019-16244": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2019-16245": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2019-16246": {"epss_score": 0.01284, "epss_percentile": 0.79171}, "CVE-2019-16247": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2019-16248": {"epss_score": 0.00068, "epss_percentile": 0.21272}, "CVE-2019-16249": {"epss_score": 0.00168, "epss_percentile": 0.38452}, "CVE-2019-16250": {"epss_score": 0.00396, "epss_percentile": 0.59855}, "CVE-2019-16251": {"epss_score": 0.00505, "epss_percentile": 0.65607}, "CVE-2019-16252": {"epss_score": 0.00159, "epss_percentile": 0.37354}, "CVE-2019-16253": {"epss_score": 0.19878, "epss_percentile": 0.95254}, "CVE-2019-16254": {"epss_score": 0.00707, "epss_percentile": 0.7164}, "CVE-2019-16255": {"epss_score": 0.01267, "epss_percentile": 0.79015}, "CVE-2019-16256": {"epss_score": 0.61187, "epss_percentile": 0.98238}, "CVE-2019-16257": {"epss_score": 0.00806, "epss_percentile": 0.73665}, "CVE-2019-16258": {"epss_score": 0.00119, "epss_percentile": 0.31673}, "CVE-2019-16261": {"epss_score": 0.00393, "epss_percentile": 0.5971}, "CVE-2019-16263": {"epss_score": 0.00204, "epss_percentile": 0.42592}, "CVE-2019-16264": {"epss_score": 0.00328, "epss_percentile": 0.55268}, "CVE-2019-16265": {"epss_score": 0.0057, "epss_percentile": 0.67948}, "CVE-2019-16268": {"epss_score": 0.12442, "epss_percentile": 0.93673}, "CVE-2019-16271": {"epss_score": 0.00303, "epss_percentile": 0.53219}, "CVE-2019-16272": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-16273": {"epss_score": 0.00857, "epss_percentile": 0.74488}, "CVE-2019-16274": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2019-16275": {"epss_score": 0.00433, "epss_percentile": 0.62197}, "CVE-2019-16276": {"epss_score": 0.10834, "epss_percentile": 0.93128}, "CVE-2019-16277": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2019-16278": {"epss_score": 0.94393, "epss_percentile": 0.9997}, "CVE-2019-16279": {"epss_score": 0.90223, "epss_percentile": 0.9957}, "CVE-2019-16281": {"epss_score": 0.00352, "epss_percentile": 0.57079}, "CVE-2019-16282": {"epss_score": 0.00391, "epss_percentile": 0.59577}, "CVE-2019-16283": {"epss_score": 0.00265, "epss_percentile": 0.49797}, "CVE-2019-16284": {"epss_score": 0.00322, "epss_percentile": 0.54756}, "CVE-2019-16285": {"epss_score": 0.00533, "epss_percentile": 0.66712}, "CVE-2019-16286": {"epss_score": 0.00241, "epss_percentile": 0.47274}, "CVE-2019-16287": {"epss_score": 0.00163, "epss_percentile": 0.37818}, "CVE-2019-16288": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2019-16289": {"epss_score": 0.00569, "epss_percentile": 0.67925}, "CVE-2019-16293": {"epss_score": 0.00901, "epss_percentile": 0.75179}, "CVE-2019-16294": {"epss_score": 0.12995, "epss_percentile": 0.93838}, "CVE-2019-16295": {"epss_score": 0.00099, "epss_percentile": 0.28307}, "CVE-2019-16297": {"epss_score": 0.00611, "epss_percentile": 0.6921}, "CVE-2019-16298": {"epss_score": 0.00611, "epss_percentile": 0.6921}, "CVE-2019-16299": {"epss_score": 0.00611, "epss_percentile": 0.6921}, "CVE-2019-16300": {"epss_score": 0.00611, "epss_percentile": 0.6921}, "CVE-2019-16301": {"epss_score": 0.00611, "epss_percentile": 0.6921}, "CVE-2019-16302": {"epss_score": 0.00611, "epss_percentile": 0.6921}, "CVE-2019-16303": {"epss_score": 0.01904, "epss_percentile": 0.82789}, "CVE-2019-16305": {"epss_score": 0.00497, "epss_percentile": 0.65203}, "CVE-2019-16307": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2019-16309": {"epss_score": 0.45915, "epss_percentile": 0.97507}, "CVE-2019-16310": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-16311": {"epss_score": 0.00182, "epss_percentile": 0.40246}, "CVE-2019-16312": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-16313": {"epss_score": 0.93949, "epss_percentile": 0.99873}, "CVE-2019-16314": {"epss_score": 0.50022, "epss_percentile": 0.97714}, "CVE-2019-16317": {"epss_score": 0.00011, "epss_percentile": 0.01059}, "CVE-2019-16318": {"epss_score": 8e-05, "epss_percentile": 0.00558}, "CVE-2019-16319": {"epss_score": 0.00768, "epss_percentile": 0.72976}, "CVE-2019-16320": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2019-16321": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-16326": {"epss_score": 0.00816, "epss_percentile": 0.73835}, "CVE-2019-16327": {"epss_score": 0.0018, "epss_percentile": 0.39911}, "CVE-2019-16328": {"epss_score": 0.73039, "epss_percentile": 0.98734}, "CVE-2019-16330": {"epss_score": 0.00369, "epss_percentile": 0.58251}, "CVE-2019-16332": {"epss_score": 0.15861, "epss_percentile": 0.94521}, "CVE-2019-16333": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-16334": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-16335": {"epss_score": 0.00651, "epss_percentile": 0.70284}, "CVE-2019-16336": {"epss_score": 0.00531, "epss_percentile": 0.6665}, "CVE-2019-16337": {"epss_score": 0.00333, "epss_percentile": 0.55636}, "CVE-2019-16338": {"epss_score": 0.00318, "epss_percentile": 0.5446}, "CVE-2019-16340": {"epss_score": 0.00853, "epss_percentile": 0.74429}, "CVE-2019-16344": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2019-16346": {"epss_score": 0.00414, "epss_percentile": 0.61033}, "CVE-2019-16347": {"epss_score": 0.00437, "epss_percentile": 0.62505}, "CVE-2019-16348": {"epss_score": 0.00404, "epss_percentile": 0.60448}, "CVE-2019-16349": {"epss_score": 0.0031, "epss_percentile": 0.53745}, "CVE-2019-16350": {"epss_score": 0.00437, "epss_percentile": 0.62527}, "CVE-2019-16351": {"epss_score": 0.00437, "epss_percentile": 0.62527}, "CVE-2019-16352": {"epss_score": 0.00397, "epss_percentile": 0.60034}, "CVE-2019-16353": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-16354": {"epss_score": 0.0003, "epss_percentile": 0.08051}, "CVE-2019-16355": {"epss_score": 0.00043, "epss_percentile": 0.13362}, "CVE-2019-16366": {"epss_score": 0.00385, "epss_percentile": 0.59189}, "CVE-2019-16370": {"epss_score": 0.00162, "epss_percentile": 0.37625}, "CVE-2019-16371": {"epss_score": 0.00262, "epss_percentile": 0.49328}, "CVE-2019-16374": {"epss_score": 0.01174, "epss_percentile": 0.78252}, "CVE-2019-16375": {"epss_score": 0.00647, "epss_percentile": 0.70206}, "CVE-2019-16377": {"epss_score": 0.01344, "epss_percentile": 0.79612}, "CVE-2019-16378": {"epss_score": 0.0125, "epss_percentile": 0.78878}, "CVE-2019-16382": {"epss_score": 0.13538, "epss_percentile": 0.9399}, "CVE-2019-16383": {"epss_score": 0.01672, "epss_percentile": 0.81677}, "CVE-2019-16384": {"epss_score": 0.00323, "epss_percentile": 0.54868}, "CVE-2019-16385": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2019-16386": {"epss_score": 0.0024, "epss_percentile": 0.46971}, "CVE-2019-16387": {"epss_score": 0.00298, "epss_percentile": 0.52789}, "CVE-2019-16388": {"epss_score": 0.0024, "epss_percentile": 0.46971}, "CVE-2019-16391": {"epss_score": 0.00928, "epss_percentile": 0.75583}, "CVE-2019-16392": {"epss_score": 0.01019, "epss_percentile": 0.7673}, "CVE-2019-16393": {"epss_score": 0.0055, "epss_percentile": 0.67338}, "CVE-2019-16394": {"epss_score": 0.50492, "epss_percentile": 0.97738}, "CVE-2019-16395": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2019-16396": {"epss_score": 0.00236, "epss_percentile": 0.46454}, "CVE-2019-16398": {"epss_score": 0.00162, "epss_percentile": 0.37665}, "CVE-2019-16399": {"epss_score": 0.10897, "epss_percentile": 0.93147}, "CVE-2019-16400": {"epss_score": 0.00244, "epss_percentile": 0.47517}, "CVE-2019-16401": {"epss_score": 0.00184, "epss_percentile": 0.40401}, "CVE-2019-16403": {"epss_score": 0.00284, "epss_percentile": 0.51465}, "CVE-2019-16404": {"epss_score": 0.00013, "epss_percentile": 0.01516}, "CVE-2019-16405": {"epss_score": 0.08968, "epss_percentile": 0.92343}, "CVE-2019-16406": {"epss_score": 0.00038, "epss_percentile": 0.11124}, "CVE-2019-16407": {"epss_score": 1e-05, "epss_percentile": 8e-05}, "CVE-2019-16409": {"epss_score": 0.00298, "epss_percentile": 0.5278}, "CVE-2019-16410": {"epss_score": 0.00672, "epss_percentile": 0.70824}, "CVE-2019-16411": {"epss_score": 0.00619, "epss_percentile": 0.69436}, "CVE-2019-16412": {"epss_score": 0.00446, "epss_percentile": 0.629}, "CVE-2019-16413": {"epss_score": 0.01206, "epss_percentile": 0.78523}, "CVE-2019-16414": {"epss_score": 0.00405, "epss_percentile": 0.60484}, "CVE-2019-16416": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-16417": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-16444": {"epss_score": 0.01247, "epss_percentile": 0.7886}, "CVE-2019-16445": {"epss_score": 0.04819, "epss_percentile": 0.89175}, "CVE-2019-16446": {"epss_score": 0.02615, "epss_percentile": 0.85243}, "CVE-2019-16448": {"epss_score": 0.04819, "epss_percentile": 0.89175}, "CVE-2019-16449": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-16450": {"epss_score": 0.02574, "epss_percentile": 0.85138}, "CVE-2019-16451": {"epss_score": 0.17176, "epss_percentile": 0.94792}, "CVE-2019-16452": {"epss_score": 0.05693, "epss_percentile": 0.90126}, "CVE-2019-16453": {"epss_score": 0.01363, "epss_percentile": 0.79768}, "CVE-2019-16454": {"epss_score": 0.02574, "epss_percentile": 0.85138}, "CVE-2019-16455": {"epss_score": 0.02615, "epss_percentile": 0.85243}, "CVE-2019-16456": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-16457": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-16458": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-16459": {"epss_score": 0.04819, "epss_percentile": 0.89175}, "CVE-2019-16460": {"epss_score": 0.02615, "epss_percentile": 0.85243}, "CVE-2019-16461": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-16462": {"epss_score": 0.03619, "epss_percentile": 0.8744}, "CVE-2019-16463": {"epss_score": 0.02615, "epss_percentile": 0.85243}, "CVE-2019-16464": {"epss_score": 0.04819, "epss_percentile": 0.89175}, "CVE-2019-16465": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-16466": {"epss_score": 0.01639, "epss_percentile": 0.81495}, "CVE-2019-16467": {"epss_score": 0.01639, "epss_percentile": 0.81495}, "CVE-2019-16468": {"epss_score": 0.04248, "epss_percentile": 0.88447}, "CVE-2019-16469": {"epss_score": 0.73573, "epss_percentile": 0.98762}, "CVE-2019-16470": {"epss_score": 0.00116, "epss_percentile": 0.31105}, "CVE-2019-16471": {"epss_score": 0.00113, "epss_percentile": 0.30595}, "CVE-2019-16508": {"epss_score": 0.00062, "epss_percentile": 0.19607}, "CVE-2019-16510": {"epss_score": 0.00393, "epss_percentile": 0.59709}, "CVE-2019-16511": {"epss_score": 0.04452, "epss_percentile": 0.88708}, "CVE-2019-16512": {"epss_score": 0.00435, "epss_percentile": 0.62359}, "CVE-2019-16513": {"epss_score": 0.00224, "epss_percentile": 0.45}, "CVE-2019-16514": {"epss_score": 0.08954, "epss_percentile": 0.92336}, "CVE-2019-16515": {"epss_score": 0.00444, "epss_percentile": 0.62831}, "CVE-2019-16516": {"epss_score": 0.38214, "epss_percentile": 0.97089}, "CVE-2019-16517": {"epss_score": 0.00224, "epss_percentile": 0.45}, "CVE-2019-16518": {"epss_score": 0.00077, "epss_percentile": 0.23551}, "CVE-2019-16519": {"epss_score": 0.00109, "epss_percentile": 0.29924}, "CVE-2019-16520": {"epss_score": 0.01136, "epss_percentile": 0.77918}, "CVE-2019-16521": {"epss_score": 0.00266, "epss_percentile": 0.49941}, "CVE-2019-16522": {"epss_score": 0.00355, "epss_percentile": 0.57325}, "CVE-2019-16523": {"epss_score": 0.00311, "epss_percentile": 0.53859}, "CVE-2019-16524": {"epss_score": 0.0026, "epss_percentile": 0.49165}, "CVE-2019-16525": {"epss_score": 0.07197, "epss_percentile": 0.91315}, "CVE-2019-16528": {"epss_score": 0.00468, "epss_percentile": 0.6391}, "CVE-2019-16529": {"epss_score": 0.00179, "epss_percentile": 0.39816}, "CVE-2019-16530": {"epss_score": 0.04026, "epss_percentile": 0.88141}, "CVE-2019-16531": {"epss_score": 0.0028, "epss_percentile": 0.51097}, "CVE-2019-16532": {"epss_score": 0.00316, "epss_percentile": 0.54296}, "CVE-2019-16533": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-16534": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-16535": {"epss_score": 0.01068, "epss_percentile": 0.77237}, "CVE-2019-16536": {"epss_score": 0.00093, "epss_percentile": 0.26716}, "CVE-2019-16538": {"epss_score": 0.00176, "epss_percentile": 0.39405}, "CVE-2019-16539": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-16540": {"epss_score": 0.00362, "epss_percentile": 0.57812}, "CVE-2019-16541": {"epss_score": 0.00475, "epss_percentile": 0.64181}, "CVE-2019-16542": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2019-16543": {"epss_score": 0.00011, "epss_percentile": 0.01071}, "CVE-2019-16544": {"epss_score": 0.00277, "epss_percentile": 0.5082}, "CVE-2019-16545": {"epss_score": 0.00134, "epss_percentile": 0.33899}, "CVE-2019-16546": {"epss_score": 0.00045, "epss_percentile": 0.13765}, "CVE-2019-16547": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-16548": {"epss_score": 0.0011, "epss_percentile": 0.30124}, "CVE-2019-16549": {"epss_score": 0.00085, "epss_percentile": 0.25103}, "CVE-2019-16550": {"epss_score": 0.00122, "epss_percentile": 0.32127}, "CVE-2019-16551": {"epss_score": 0.0011, "epss_percentile": 0.30124}, "CVE-2019-16552": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-16553": {"epss_score": 0.0011, "epss_percentile": 0.30124}, "CVE-2019-16554": {"epss_score": 0.00058, "epss_percentile": 0.18571}, "CVE-2019-16555": {"epss_score": 0.00125, "epss_percentile": 0.32514}, "CVE-2019-16556": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2019-16557": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2019-16558": {"epss_score": 0.00027, "epss_percentile": 0.07091}, "CVE-2019-16559": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-16560": {"epss_score": 0.0011, "epss_percentile": 0.30124}, "CVE-2019-16561": {"epss_score": 0.00026, "epss_percentile": 0.06518}, "CVE-2019-16562": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2019-16563": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2019-16564": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2019-16565": {"epss_score": 0.00103, "epss_percentile": 0.29042}, "CVE-2019-16566": {"epss_score": 0.00048, "epss_percentile": 0.15045}, "CVE-2019-16567": {"epss_score": 0.00031, "epss_percentile": 0.08662}, "CVE-2019-16568": {"epss_score": 0.00027, "epss_percentile": 0.0681}, "CVE-2019-16569": {"epss_score": 0.00484, "epss_percentile": 0.64631}, "CVE-2019-16570": {"epss_score": 0.0011, "epss_percentile": 0.30124}, "CVE-2019-16571": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2019-16572": {"epss_score": 0.00036, "epss_percentile": 0.10321}, "CVE-2019-16573": {"epss_score": 0.0011, "epss_percentile": 0.30124}, "CVE-2019-16574": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2019-16575": {"epss_score": 0.0011, "epss_percentile": 0.30124}, "CVE-2019-16576": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2019-16638": {"epss_score": 0.00107, "epss_percentile": 0.29732}, "CVE-2019-16639": {"epss_score": 0.00115, "epss_percentile": 0.30906}, "CVE-2019-16640": {"epss_score": 0.00037, "epss_percentile": 0.10972}, "CVE-2019-16641": {"epss_score": 0.00031, "epss_percentile": 0.0845}, "CVE-2019-16642": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-16643": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2019-16644": {"epss_score": 0.00286, "epss_percentile": 0.51719}, "CVE-2019-16645": {"epss_score": 0.16676, "epss_percentile": 0.94713}, "CVE-2019-16647": {"epss_score": 0.00639, "epss_percentile": 0.69939}, "CVE-2019-16649": {"epss_score": 0.00101, "epss_percentile": 0.28637}, "CVE-2019-16650": {"epss_score": 0.00654, "epss_percentile": 0.7034}, "CVE-2019-16651": {"epss_score": 0.00097, "epss_percentile": 0.27529}, "CVE-2019-16652": {"epss_score": 0.00441, "epss_percentile": 0.62696}, "CVE-2019-16653": {"epss_score": 0.00817, "epss_percentile": 0.73837}, "CVE-2019-16655": {"epss_score": 0.00198, "epss_percentile": 0.42035}, "CVE-2019-16656": {"epss_score": 0.00705, "epss_percentile": 0.716}, "CVE-2019-16657": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-16658": {"epss_score": 0.00122, "epss_percentile": 0.32025}, "CVE-2019-16659": {"epss_score": 0.0017, "epss_percentile": 0.38648}, "CVE-2019-16660": {"epss_score": 0.00122, "epss_percentile": 0.32025}, "CVE-2019-16661": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2019-16662": {"epss_score": 0.94452, "epss_percentile": 0.99991}, "CVE-2019-16663": {"epss_score": 0.93721, "epss_percentile": 0.99836}, "CVE-2019-16664": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2019-16665": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-16667": {"epss_score": 0.56098, "epss_percentile": 0.98008}, "CVE-2019-16669": {"epss_score": 0.00194, "epss_percentile": 0.41594}, "CVE-2019-16670": {"epss_score": 0.00471, "epss_percentile": 0.64003}, "CVE-2019-16671": {"epss_score": 0.01059, "epss_percentile": 0.77158}, "CVE-2019-16672": {"epss_score": 0.00328, "epss_percentile": 0.55278}, "CVE-2019-16673": {"epss_score": 0.00362, "epss_percentile": 0.5777}, "CVE-2019-16674": {"epss_score": 0.00446, "epss_percentile": 0.62931}, "CVE-2019-16675": {"epss_score": 0.07002, "epss_percentile": 0.91175}, "CVE-2019-16676": {"epss_score": 0.0083, "epss_percentile": 0.74025}, "CVE-2019-16677": {"epss_score": 0.0015, "epss_percentile": 0.36122}, "CVE-2019-16678": {"epss_score": 0.00121, "epss_percentile": 0.32016}, "CVE-2019-16679": {"epss_score": 0.02739, "epss_percentile": 0.85556}, "CVE-2019-16680": {"epss_score": 0.01789, "epss_percentile": 0.82275}, "CVE-2019-16681": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-16682": {"epss_score": 0.00192, "epss_percentile": 0.41354}, "CVE-2019-16683": {"epss_score": 0.00389, "epss_percentile": 0.59489}, "CVE-2019-16684": {"epss_score": 0.00389, "epss_percentile": 0.59489}, "CVE-2019-16685": {"epss_score": 0.00156, "epss_percentile": 0.36932}, "CVE-2019-16686": {"epss_score": 0.00229, "epss_percentile": 0.45607}, "CVE-2019-16687": {"epss_score": 0.00169, "epss_percentile": 0.38536}, "CVE-2019-16688": {"epss_score": 0.00173, "epss_percentile": 0.39084}, "CVE-2019-16692": {"epss_score": 0.16281, "epss_percentile": 0.9461}, "CVE-2019-16693": {"epss_score": 0.15878, "epss_percentile": 0.94525}, "CVE-2019-16694": {"epss_score": 0.00761, "epss_percentile": 0.72822}, "CVE-2019-16695": {"epss_score": 0.01037, "epss_percentile": 0.76923}, "CVE-2019-16696": {"epss_score": 0.01037, "epss_percentile": 0.76923}, "CVE-2019-16698": {"epss_score": 0.00114, "epss_percentile": 0.308}, "CVE-2019-16699": {"epss_score": 0.02481, "epss_percentile": 0.84874}, "CVE-2019-16700": {"epss_score": 0.02148, "epss_percentile": 0.83774}, "CVE-2019-16701": {"epss_score": 0.20456, "epss_percentile": 0.95347}, "CVE-2019-16702": {"epss_score": 0.19171, "epss_percentile": 0.95143}, "CVE-2019-16703": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-16704": {"epss_score": 0.00323, "epss_percentile": 0.54896}, "CVE-2019-16705": {"epss_score": 0.00425, "epss_percentile": 0.61703}, "CVE-2019-16706": {"epss_score": 0.00182, "epss_percentile": 0.40246}, "CVE-2019-16707": {"epss_score": 0.0053, "epss_percentile": 0.66625}, "CVE-2019-16708": {"epss_score": 0.00194, "epss_percentile": 0.41574}, "CVE-2019-16709": {"epss_score": 0.00188, "epss_percentile": 0.40851}, "CVE-2019-16710": {"epss_score": 0.00194, "epss_percentile": 0.41574}, "CVE-2019-16711": {"epss_score": 0.00194, "epss_percentile": 0.41574}, "CVE-2019-16712": {"epss_score": 0.00093, "epss_percentile": 0.26646}, "CVE-2019-16713": {"epss_score": 0.00194, "epss_percentile": 0.41574}, "CVE-2019-16714": {"epss_score": 0.01117, "epss_percentile": 0.77743}, "CVE-2019-16716": {"epss_score": 0.00386, "epss_percentile": 0.59267}, "CVE-2019-16717": {"epss_score": 0.00364, "epss_percentile": 0.57907}, "CVE-2019-16718": {"epss_score": 0.0134, "epss_percentile": 0.79577}, "CVE-2019-16719": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2019-16720": {"epss_score": 0.00282, "epss_percentile": 0.51221}, "CVE-2019-16721": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2019-16722": {"epss_score": 0.03559, "epss_percentile": 0.87351}, "CVE-2019-16723": {"epss_score": 0.00205, "epss_percentile": 0.42709}, "CVE-2019-16724": {"epss_score": 0.8573, "epss_percentile": 0.99345}, "CVE-2019-16725": {"epss_score": 0.04635, "epss_percentile": 0.88949}, "CVE-2019-16728": {"epss_score": 0.01188, "epss_percentile": 0.78368}, "CVE-2019-16729": {"epss_score": 0.00112, "epss_percentile": 0.3042}, "CVE-2019-16730": {"epss_score": 0.03271, "epss_percentile": 0.86794}, "CVE-2019-16731": {"epss_score": 0.0036, "epss_percentile": 0.57666}, "CVE-2019-16732": {"epss_score": 0.00179, "epss_percentile": 0.39779}, "CVE-2019-16733": {"epss_score": 0.03271, "epss_percentile": 0.86794}, "CVE-2019-16734": {"epss_score": 0.0351, "epss_percentile": 0.87264}, "CVE-2019-16735": {"epss_score": 0.02823, "epss_percentile": 0.85753}, "CVE-2019-16736": {"epss_score": 0.02823, "epss_percentile": 0.85753}, "CVE-2019-16737": {"epss_score": 0.03271, "epss_percentile": 0.86794}, "CVE-2019-16738": {"epss_score": 0.00415, "epss_percentile": 0.61147}, "CVE-2019-16743": {"epss_score": 0.003, "epss_percentile": 0.52923}, "CVE-2019-16744": {"epss_score": 0.00316, "epss_percentile": 0.5429}, "CVE-2019-16745": {"epss_score": 0.00316, "epss_percentile": 0.5429}, "CVE-2019-16746": {"epss_score": 0.02601, "epss_percentile": 0.85207}, "CVE-2019-16747": {"epss_score": 0.00408, "epss_percentile": 0.60647}, "CVE-2019-16748": {"epss_score": 0.00905, "epss_percentile": 0.75237}, "CVE-2019-16751": {"epss_score": 0.00759, "epss_percentile": 0.72791}, "CVE-2019-16752": {"epss_score": 0.0017, "epss_percentile": 0.3875}, "CVE-2019-16753": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2019-16754": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2019-16755": {"epss_score": 0.03504, "epss_percentile": 0.87254}, "CVE-2019-16758": {"epss_score": 0.18841, "epss_percentile": 0.95079}, "CVE-2019-16759": {"epss_score": 0.94407, "epss_percentile": 0.99974}, "CVE-2019-16760": {"epss_score": 0.00181, "epss_percentile": 0.401}, "CVE-2019-16761": {"epss_score": 0.00392, "epss_percentile": 0.59662}, "CVE-2019-16762": {"epss_score": 0.00392, "epss_percentile": 0.59662}, "CVE-2019-16763": {"epss_score": 0.00691, "epss_percentile": 0.71262}, "CVE-2019-16764": {"epss_score": 0.00441, "epss_percentile": 0.62679}, "CVE-2019-16765": {"epss_score": 0.00841, "epss_percentile": 0.74226}, "CVE-2019-16766": {"epss_score": 0.0017, "epss_percentile": 0.38755}, "CVE-2019-16767": {"epss_score": 0.003, "epss_percentile": 0.52991}, "CVE-2019-16768": {"epss_score": 0.00347, "epss_percentile": 0.5679}, "CVE-2019-16769": {"epss_score": 0.00406, "epss_percentile": 0.60533}, "CVE-2019-16770": {"epss_score": 0.01587, "epss_percentile": 0.81185}, "CVE-2019-16771": {"epss_score": 0.00416, "epss_percentile": 0.61192}, "CVE-2019-16772": {"epss_score": 0.00298, "epss_percentile": 0.52787}, "CVE-2019-16774": {"epss_score": 0.00379, "epss_percentile": 0.5885}, "CVE-2019-16775": {"epss_score": 0.00299, "epss_percentile": 0.52872}, "CVE-2019-16776": {"epss_score": 0.00353, "epss_percentile": 0.57138}, "CVE-2019-16777": {"epss_score": 0.00292, "epss_percentile": 0.52226}, "CVE-2019-16778": {"epss_score": 0.00336, "epss_percentile": 0.55944}, "CVE-2019-16779": {"epss_score": 0.00556, "epss_percentile": 0.67506}, "CVE-2019-16780": {"epss_score": 0.03606, "epss_percentile": 0.87418}, "CVE-2019-16781": {"epss_score": 0.03427, "epss_percentile": 0.87117}, "CVE-2019-16782": {"epss_score": 0.01634, "epss_percentile": 0.81466}, "CVE-2019-16784": {"epss_score": 0.03223, "epss_percentile": 0.86676}, "CVE-2019-16785": {"epss_score": 0.00433, "epss_percentile": 0.62205}, "CVE-2019-16786": {"epss_score": 0.00516, "epss_percentile": 0.66037}, "CVE-2019-16789": {"epss_score": 0.00603, "epss_percentile": 0.68915}, "CVE-2019-16790": {"epss_score": 0.02173, "epss_percentile": 0.83876}, "CVE-2019-16791": {"epss_score": 0.003, "epss_percentile": 0.5299}, "CVE-2019-16792": {"epss_score": 0.00851, "epss_percentile": 0.74405}, "CVE-2019-16860": {"epss_score": 0.00048, "epss_percentile": 0.14935}, "CVE-2019-16861": {"epss_score": 0.00051, "epss_percentile": 0.16009}, "CVE-2019-16862": {"epss_score": 0.04738, "epss_percentile": 0.89075}, "CVE-2019-16863": {"epss_score": 0.00311, "epss_percentile": 0.5383}, "CVE-2019-16864": {"epss_score": 0.22819, "epss_percentile": 0.95695}, "CVE-2019-16865": {"epss_score": 0.05198, "epss_percentile": 0.896}, "CVE-2019-16866": {"epss_score": 0.01836, "epss_percentile": 0.82472}, "CVE-2019-16867": {"epss_score": 0.00314, "epss_percentile": 0.54156}, "CVE-2019-16868": {"epss_score": 0.02784, "epss_percentile": 0.85655}, "CVE-2019-16869": {"epss_score": 0.03007, "epss_percentile": 0.86186}, "CVE-2019-16871": {"epss_score": 0.05877, "epss_percentile": 0.90287}, "CVE-2019-16872": {"epss_score": 0.00524, "epss_percentile": 0.66339}, "CVE-2019-16873": {"epss_score": 0.005, "epss_percentile": 0.65289}, "CVE-2019-16874": {"epss_score": 0.00443, "epss_percentile": 0.62802}, "CVE-2019-16876": {"epss_score": 0.00703, "epss_percentile": 0.71527}, "CVE-2019-16877": {"epss_score": 0.00636, "epss_percentile": 0.69865}, "CVE-2019-16878": {"epss_score": 0.0035, "epss_percentile": 0.56937}, "CVE-2019-16879": {"epss_score": 0.00178, "epss_percentile": 0.39705}, "CVE-2019-16880": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-16881": {"epss_score": 0.01192, "epss_percentile": 0.78403}, "CVE-2019-16882": {"epss_score": 0.00285, "epss_percentile": 0.51538}, "CVE-2019-16884": {"epss_score": 0.00565, "epss_percentile": 0.67791}, "CVE-2019-16885": {"epss_score": 0.16895, "epss_percentile": 0.94744}, "CVE-2019-16887": {"epss_score": 0.00354, "epss_percentile": 0.57206}, "CVE-2019-16889": {"epss_score": 0.11494, "epss_percentile": 0.93384}, "CVE-2019-16890": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-16891": {"epss_score": 0.73432, "epss_percentile": 0.98754}, "CVE-2019-16892": {"epss_score": 0.0018, "epss_percentile": 0.3992}, "CVE-2019-16893": {"epss_score": 0.29514, "epss_percentile": 0.96449}, "CVE-2019-16894": {"epss_score": 0.01153, "epss_percentile": 0.78055}, "CVE-2019-16896": {"epss_score": 0.00221, "epss_percentile": 0.44702}, "CVE-2019-16897": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2019-16899": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-16900": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-16901": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-16902": {"epss_score": 0.14736, "epss_percentile": 0.94271}, "CVE-2019-16903": {"epss_score": 0.00147, "epss_percentile": 0.35672}, "CVE-2019-16904": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-16905": {"epss_score": 0.00199, "epss_percentile": 0.42189}, "CVE-2019-16906": {"epss_score": 0.00365, "epss_percentile": 0.57967}, "CVE-2019-16907": {"epss_score": 0.00344, "epss_percentile": 0.56524}, "CVE-2019-16908": {"epss_score": 0.00384, "epss_percentile": 0.59155}, "CVE-2019-16909": {"epss_score": 0.00281, "epss_percentile": 0.51181}, "CVE-2019-16910": {"epss_score": 0.00925, "epss_percentile": 0.75535}, "CVE-2019-16913": {"epss_score": 0.0003, "epss_percentile": 0.08178}, "CVE-2019-16914": {"epss_score": 0.01833, "epss_percentile": 0.82456}, "CVE-2019-16915": {"epss_score": 0.02722, "epss_percentile": 0.8552}, "CVE-2019-16917": {"epss_score": 0.00659, "epss_percentile": 0.70513}, "CVE-2019-16919": {"epss_score": 0.00409, "epss_percentile": 0.60737}, "CVE-2019-16920": {"epss_score": 0.94187, "epss_percentile": 0.99914}, "CVE-2019-16921": {"epss_score": 0.00272, "epss_percentile": 0.50374}, "CVE-2019-16922": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2019-16923": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-16924": {"epss_score": 0.00098, "epss_percentile": 0.27814}, "CVE-2019-16925": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-16926": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-16927": {"epss_score": 0.00164, "epss_percentile": 0.3795}, "CVE-2019-16928": {"epss_score": 0.90398, "epss_percentile": 0.99581}, "CVE-2019-16929": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2019-16930": {"epss_score": 0.00356, "epss_percentile": 0.57389}, "CVE-2019-16931": {"epss_score": 0.01991, "epss_percentile": 0.83177}, "CVE-2019-16932": {"epss_score": 0.82175, "epss_percentile": 0.99178}, "CVE-2019-16935": {"epss_score": 0.01719, "epss_percentile": 0.81927}, "CVE-2019-16941": {"epss_score": 0.22862, "epss_percentile": 0.957}, "CVE-2019-16942": {"epss_score": 0.00415, "epss_percentile": 0.61117}, "CVE-2019-16943": {"epss_score": 0.01841, "epss_percentile": 0.82494}, "CVE-2019-16948": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2019-16949": {"epss_score": 0.00296, "epss_percentile": 0.52555}, "CVE-2019-16950": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-16951": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2019-16954": {"epss_score": 0.01433, "epss_percentile": 0.80254}, "CVE-2019-16955": {"epss_score": 0.01934, "epss_percentile": 0.82955}, "CVE-2019-16956": {"epss_score": 0.01934, "epss_percentile": 0.82955}, "CVE-2019-16957": {"epss_score": 0.02185, "epss_percentile": 0.83919}, "CVE-2019-16958": {"epss_score": 0.0175, "epss_percentile": 0.82098}, "CVE-2019-16959": {"epss_score": 0.00943, "epss_percentile": 0.7578}, "CVE-2019-16960": {"epss_score": 0.01934, "epss_percentile": 0.82955}, "CVE-2019-16961": {"epss_score": 0.02185, "epss_percentile": 0.83919}, "CVE-2019-16962": {"epss_score": 0.01961, "epss_percentile": 0.83062}, "CVE-2019-16964": {"epss_score": 0.03624, "epss_percentile": 0.87454}, "CVE-2019-16965": {"epss_score": 0.02889, "epss_percentile": 0.85916}, "CVE-2019-16966": {"epss_score": 0.00397, "epss_percentile": 0.60045}, "CVE-2019-16967": {"epss_score": 0.00397, "epss_percentile": 0.60045}, "CVE-2019-16968": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16969": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16970": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16971": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16972": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16973": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16974": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16975": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-16976": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-16977": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-16978": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16979": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16980": {"epss_score": 0.00374, "epss_percentile": 0.58573}, "CVE-2019-16981": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16982": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16983": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16984": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16985": {"epss_score": 0.00427, "epss_percentile": 0.6189}, "CVE-2019-16986": {"epss_score": 0.00528, "epss_percentile": 0.66552}, "CVE-2019-16987": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16988": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16989": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16990": {"epss_score": 0.00441, "epss_percentile": 0.62691}, "CVE-2019-16991": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-16992": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2019-16993": {"epss_score": 0.00222, "epss_percentile": 0.44788}, "CVE-2019-16994": {"epss_score": 0.00076, "epss_percentile": 0.23174}, "CVE-2019-16995": {"epss_score": 0.01997, "epss_percentile": 0.83198}, "CVE-2019-16996": {"epss_score": 0.92241, "epss_percentile": 0.99702}, "CVE-2019-16997": {"epss_score": 0.93646, "epss_percentile": 0.99829}, "CVE-2019-16999": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-17000": {"epss_score": 0.00162, "epss_percentile": 0.37732}, "CVE-2019-17001": {"epss_score": 0.00221, "epss_percentile": 0.44664}, "CVE-2019-17002": {"epss_score": 0.00284, "epss_percentile": 0.51463}, "CVE-2019-17003": {"epss_score": 0.0067, "epss_percentile": 0.70787}, "CVE-2019-17005": {"epss_score": 0.02867, "epss_percentile": 0.85863}, "CVE-2019-17006": {"epss_score": 0.03036, "epss_percentile": 0.86263}, "CVE-2019-17007": {"epss_score": 0.00308, "epss_percentile": 0.53579}, "CVE-2019-17008": {"epss_score": 0.00854, "epss_percentile": 0.74454}, "CVE-2019-17009": {"epss_score": 0.00144, "epss_percentile": 0.3529}, "CVE-2019-17010": {"epss_score": 0.01329, "epss_percentile": 0.79507}, "CVE-2019-17011": {"epss_score": 0.01329, "epss_percentile": 0.79507}, "CVE-2019-17012": {"epss_score": 0.02152, "epss_percentile": 0.83791}, "CVE-2019-17013": {"epss_score": 0.00401, "epss_percentile": 0.60243}, "CVE-2019-17014": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2019-17015": {"epss_score": 0.00932, "epss_percentile": 0.75626}, "CVE-2019-17016": {"epss_score": 0.03465, "epss_percentile": 0.87189}, "CVE-2019-17017": {"epss_score": 0.0263, "epss_percentile": 0.85277}, "CVE-2019-17018": {"epss_score": 0.00156, "epss_percentile": 0.36887}, "CVE-2019-17019": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2019-17020": {"epss_score": 0.00232, "epss_percentile": 0.45903}, "CVE-2019-17021": {"epss_score": 0.00472, "epss_percentile": 0.64039}, "CVE-2019-17022": {"epss_score": 0.04633, "epss_percentile": 0.88947}, "CVE-2019-17023": {"epss_score": 0.00899, "epss_percentile": 0.75156}, "CVE-2019-17024": {"epss_score": 0.03276, "epss_percentile": 0.86803}, "CVE-2019-17025": {"epss_score": 0.00704, "epss_percentile": 0.71573}, "CVE-2019-17026": {"epss_score": 0.64805, "epss_percentile": 0.98392}, "CVE-2019-17040": {"epss_score": 0.00503, "epss_percentile": 0.65461}, "CVE-2019-17041": {"epss_score": 0.01108, "epss_percentile": 0.7763}, "CVE-2019-17042": {"epss_score": 0.00405, "epss_percentile": 0.60492}, "CVE-2019-17043": {"epss_score": 0.00165, "epss_percentile": 0.38033}, "CVE-2019-17044": {"epss_score": 0.00052, "epss_percentile": 0.1662}, "CVE-2019-17045": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-17046": {"epss_score": 0.04205, "epss_percentile": 0.88395}, "CVE-2019-17049": {"epss_score": 0.00261, "epss_percentile": 0.49294}, "CVE-2019-17050": {"epss_score": 0.00558, "epss_percentile": 0.67582}, "CVE-2019-17051": {"epss_score": 0.0039, "epss_percentile": 0.59498}, "CVE-2019-17052": {"epss_score": 0.00087, "epss_percentile": 0.25618}, "CVE-2019-17053": {"epss_score": 0.00099, "epss_percentile": 0.28351}, "CVE-2019-17054": {"epss_score": 0.00099, "epss_percentile": 0.28351}, "CVE-2019-17055": {"epss_score": 0.00088, "epss_percentile": 0.25704}, "CVE-2019-17056": {"epss_score": 0.00074, "epss_percentile": 0.22833}, "CVE-2019-17057": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2019-17058": {"epss_score": 0.0034, "epss_percentile": 0.56267}, "CVE-2019-17059": {"epss_score": 0.05584, "epss_percentile": 0.90022}, "CVE-2019-17060": {"epss_score": 0.00504, "epss_percentile": 0.65519}, "CVE-2019-17061": {"epss_score": 0.00699, "epss_percentile": 0.7145}, "CVE-2019-17062": {"epss_score": 0.00461, "epss_percentile": 0.63543}, "CVE-2019-17063": {"epss_score": 0.00164, "epss_percentile": 0.3795}, "CVE-2019-17064": {"epss_score": 0.00368, "epss_percentile": 0.5822}, "CVE-2019-17066": {"epss_score": 0.00118, "epss_percentile": 0.3144}, "CVE-2019-17067": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-17068": {"epss_score": 0.00467, "epss_percentile": 0.63814}, "CVE-2019-17069": {"epss_score": 0.00474, "epss_percentile": 0.64161}, "CVE-2019-17070": {"epss_score": 0.00439, "epss_percentile": 0.62595}, "CVE-2019-17071": {"epss_score": 0.00439, "epss_percentile": 0.62595}, "CVE-2019-17072": {"epss_score": 0.0091, "epss_percentile": 0.75317}, "CVE-2019-17073": {"epss_score": 0.00298, "epss_percentile": 0.52785}, "CVE-2019-17074": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2019-17075": {"epss_score": 0.00861, "epss_percentile": 0.7456}, "CVE-2019-17076": {"epss_score": 0.05535, "epss_percentile": 0.8997}, "CVE-2019-17080": {"epss_score": 0.10834, "epss_percentile": 0.93128}, "CVE-2019-17082": {"epss_score": 0.00035, "epss_percentile": 0.10154}, "CVE-2019-17085": {"epss_score": 0.00218, "epss_percentile": 0.44364}, "CVE-2019-17087": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-17091": {"epss_score": 0.0842, "epss_percentile": 0.92042}, "CVE-2019-17092": {"epss_score": 0.0055, "epss_percentile": 0.67334}, "CVE-2019-17093": {"epss_score": 0.00046, "epss_percentile": 0.1414}, "CVE-2019-17094": {"epss_score": 0.00167, "epss_percentile": 0.38307}, "CVE-2019-17095": {"epss_score": 0.04414, "epss_percentile": 0.88664}, "CVE-2019-17096": {"epss_score": 0.00812, "epss_percentile": 0.73743}, "CVE-2019-17098": {"epss_score": 0.00079, "epss_percentile": 0.23861}, "CVE-2019-17099": {"epss_score": 0.00241, "epss_percentile": 0.47236}, "CVE-2019-17100": {"epss_score": 0.00207, "epss_percentile": 0.43076}, "CVE-2019-17101": {"epss_score": 0.00553, "epss_percentile": 0.67416}, "CVE-2019-17102": {"epss_score": 0.00339, "epss_percentile": 0.56164}, "CVE-2019-17103": {"epss_score": 0.00076, "epss_percentile": 0.23175}, "CVE-2019-17104": {"epss_score": 0.00076, "epss_percentile": 0.23163}, "CVE-2019-17105": {"epss_score": 0.0006, "epss_percentile": 0.19201}, "CVE-2019-17106": {"epss_score": 0.00134, "epss_percentile": 0.33839}, "CVE-2019-17107": {"epss_score": 0.01694, "epss_percentile": 0.81802}, "CVE-2019-17108": {"epss_score": 0.00091, "epss_percentile": 0.26255}, "CVE-2019-17109": {"epss_score": 0.00862, "epss_percentile": 0.74571}, "CVE-2019-17112": {"epss_score": 0.00689, "epss_percentile": 0.7123}, "CVE-2019-17113": {"epss_score": 0.01642, "epss_percentile": 0.81509}, "CVE-2019-17114": {"epss_score": 0.01038, "epss_percentile": 0.76938}, "CVE-2019-17115": {"epss_score": 0.01038, "epss_percentile": 0.76938}, "CVE-2019-17116": {"epss_score": 0.01038, "epss_percentile": 0.76938}, "CVE-2019-17117": {"epss_score": 0.00628, "epss_percentile": 0.69657}, "CVE-2019-17118": {"epss_score": 0.00342, "epss_percentile": 0.56362}, "CVE-2019-17119": {"epss_score": 0.00628, "epss_percentile": 0.69657}, "CVE-2019-17120": {"epss_score": 0.06017, "epss_percentile": 0.90413}, "CVE-2019-17121": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-17123": {"epss_score": 0.00441, "epss_percentile": 0.62688}, "CVE-2019-17124": {"epss_score": 0.23812, "epss_percentile": 0.9582}, "CVE-2019-17125": {"epss_score": 0.02825, "epss_percentile": 0.85755}, "CVE-2019-17127": {"epss_score": 0.02263, "epss_percentile": 0.84191}, "CVE-2019-17128": {"epss_score": 0.00294, "epss_percentile": 0.52411}, "CVE-2019-17130": {"epss_score": 0.00356, "epss_percentile": 0.57385}, "CVE-2019-17131": {"epss_score": 0.0024, "epss_percentile": 0.4694}, "CVE-2019-17132": {"epss_score": 0.25202, "epss_percentile": 0.95997}, "CVE-2019-17133": {"epss_score": 0.0156, "epss_percentile": 0.8104}, "CVE-2019-17134": {"epss_score": 0.00958, "epss_percentile": 0.75946}, "CVE-2019-17135": {"epss_score": 0.00823, "epss_percentile": 0.73922}, "CVE-2019-17136": {"epss_score": 0.01326, "epss_percentile": 0.79482}, "CVE-2019-17137": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-17138": {"epss_score": 0.01787, "epss_percentile": 0.82261}, "CVE-2019-17139": {"epss_score": 0.01854, "epss_percentile": 0.82555}, "CVE-2019-17140": {"epss_score": 0.0062, "epss_percentile": 0.6944}, "CVE-2019-17141": {"epss_score": 0.0062, "epss_percentile": 0.6944}, "CVE-2019-17142": {"epss_score": 0.01469, "epss_percentile": 0.80488}, "CVE-2019-17143": {"epss_score": 0.00424, "epss_percentile": 0.61653}, "CVE-2019-17144": {"epss_score": 0.01326, "epss_percentile": 0.79482}, "CVE-2019-17145": {"epss_score": 0.01326, "epss_percentile": 0.79482}, "CVE-2019-17146": {"epss_score": 0.17711, "epss_percentile": 0.94894}, "CVE-2019-17147": {"epss_score": 0.21995, "epss_percentile": 0.95582}, "CVE-2019-17148": {"epss_score": 0.00127, "epss_percentile": 0.32802}, "CVE-2019-17151": {"epss_score": 0.00871, "epss_percentile": 0.74717}, "CVE-2019-17175": {"epss_score": 0.00419, "epss_percentile": 0.61376}, "CVE-2019-17176": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-17177": {"epss_score": 0.00872, "epss_percentile": 0.74739}, "CVE-2019-17178": {"epss_score": 0.00827, "epss_percentile": 0.73986}, "CVE-2019-17179": {"epss_score": 0.01546, "epss_percentile": 0.80968}, "CVE-2019-17180": {"epss_score": 0.00095, "epss_percentile": 0.27158}, "CVE-2019-17181": {"epss_score": 0.74079, "epss_percentile": 0.98788}, "CVE-2019-17183": {"epss_score": 0.00018, "epss_percentile": 0.03636}, "CVE-2019-17184": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2019-17185": {"epss_score": 0.00542, "epss_percentile": 0.67073}, "CVE-2019-17186": {"epss_score": 0.00301, "epss_percentile": 0.53075}, "CVE-2019-17187": {"epss_score": 0.00035, "epss_percentile": 0.09899}, "CVE-2019-17188": {"epss_score": 0.00358, "epss_percentile": 0.57529}, "CVE-2019-17189": {"epss_score": 0.00474, "epss_percentile": 0.64152}, "CVE-2019-17190": {"epss_score": 0.00124, "epss_percentile": 0.32458}, "CVE-2019-17191": {"epss_score": 0.00319, "epss_percentile": 0.54498}, "CVE-2019-17192": {"epss_score": 0.01152, "epss_percentile": 0.78048}, "CVE-2019-17195": {"epss_score": 0.10618, "epss_percentile": 0.93051}, "CVE-2019-17197": {"epss_score": 8e-05, "epss_percentile": 0.00519}, "CVE-2019-17199": {"epss_score": 0.57654, "epss_percentile": 0.98076}, "CVE-2019-17201": {"epss_score": 0.001, "epss_percentile": 0.28519}, "CVE-2019-17202": {"epss_score": 0.00125, "epss_percentile": 0.3257}, "CVE-2019-17203": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2019-17204": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2019-17205": {"epss_score": 0.00427, "epss_percentile": 0.61888}, "CVE-2019-17206": {"epss_score": 0.0074, "epss_percentile": 0.7241}, "CVE-2019-17207": {"epss_score": 0.00294, "epss_percentile": 0.52427}, "CVE-2019-17210": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2019-17211": {"epss_score": 0.01158, "epss_percentile": 0.78123}, "CVE-2019-17212": {"epss_score": 0.01791, "epss_percentile": 0.82281}, "CVE-2019-17213": {"epss_score": 0.00529, "epss_percentile": 0.66593}, "CVE-2019-17214": {"epss_score": 0.00436, "epss_percentile": 0.62462}, "CVE-2019-17215": {"epss_score": 0.0031, "epss_percentile": 0.53778}, "CVE-2019-17216": {"epss_score": 0.00189, "epss_percentile": 0.40947}, "CVE-2019-17217": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2019-17218": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2019-17219": {"epss_score": 0.00098, "epss_percentile": 0.27827}, "CVE-2019-17220": {"epss_score": 0.0229, "epss_percentile": 0.84279}, "CVE-2019-17221": {"epss_score": 0.08713, "epss_percentile": 0.92223}, "CVE-2019-17222": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-17223": {"epss_score": 0.00413, "epss_percentile": 0.60992}, "CVE-2019-17224": {"epss_score": 0.00426, "epss_percentile": 0.61759}, "CVE-2019-17225": {"epss_score": 0.00542, "epss_percentile": 0.67081}, "CVE-2019-17226": {"epss_score": 0.00288, "epss_percentile": 0.51979}, "CVE-2019-17228": {"epss_score": 0.02088, "epss_percentile": 0.83555}, "CVE-2019-17229": {"epss_score": 0.00332, "epss_percentile": 0.55575}, "CVE-2019-17230": {"epss_score": 0.0849, "epss_percentile": 0.92081}, "CVE-2019-17231": {"epss_score": 0.00296, "epss_percentile": 0.52568}, "CVE-2019-17232": {"epss_score": 0.18776, "epss_percentile": 0.95067}, "CVE-2019-17233": {"epss_score": 0.03149, "epss_percentile": 0.86503}, "CVE-2019-17234": {"epss_score": 0.23298, "epss_percentile": 0.95761}, "CVE-2019-17235": {"epss_score": 0.00608, "epss_percentile": 0.69072}, "CVE-2019-17236": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2019-17237": {"epss_score": 0.00323, "epss_percentile": 0.54899}, "CVE-2019-17239": {"epss_score": 0.00302, "epss_percentile": 0.53087}, "CVE-2019-17240": {"epss_score": 0.72401, "epss_percentile": 0.98707}, "CVE-2019-17241": {"epss_score": 0.00092, "epss_percentile": 0.26507}, "CVE-2019-17242": {"epss_score": 0.00092, "epss_percentile": 0.26507}, "CVE-2019-17243": {"epss_score": 0.00347, "epss_percentile": 0.56775}, "CVE-2019-17244": {"epss_score": 0.00347, "epss_percentile": 0.56775}, "CVE-2019-17245": {"epss_score": 0.00092, "epss_percentile": 0.26507}, "CVE-2019-17246": {"epss_score": 0.00347, "epss_percentile": 0.56775}, "CVE-2019-17247": {"epss_score": 0.00347, "epss_percentile": 0.56775}, "CVE-2019-17248": {"epss_score": 0.00347, "epss_percentile": 0.56775}, "CVE-2019-17249": {"epss_score": 0.00347, "epss_percentile": 0.56775}, "CVE-2019-17250": {"epss_score": 0.00347, "epss_percentile": 0.56775}, "CVE-2019-17251": {"epss_score": 0.00347, "epss_percentile": 0.56775}, "CVE-2019-17252": {"epss_score": 0.00379, "epss_percentile": 0.58849}, "CVE-2019-17253": {"epss_score": 0.00347, "epss_percentile": 0.56775}, "CVE-2019-17254": {"epss_score": 0.00379, "epss_percentile": 0.58849}, "CVE-2019-17255": {"epss_score": 0.00347, "epss_percentile": 0.56775}, "CVE-2019-17256": {"epss_score": 0.00347, "epss_percentile": 0.56775}, "CVE-2019-17257": {"epss_score": 0.00193, "epss_percentile": 0.41463}, "CVE-2019-17258": {"epss_score": 0.00347, "epss_percentile": 0.56775}, "CVE-2019-17259": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2019-17260": {"epss_score": 0.00091, "epss_percentile": 0.2622}, "CVE-2019-17261": {"epss_score": 0.00091, "epss_percentile": 0.2622}, "CVE-2019-17262": {"epss_score": 0.00091, "epss_percentile": 0.2622}, "CVE-2019-17263": {"epss_score": 0.00163, "epss_percentile": 0.37816}, "CVE-2019-17264": {"epss_score": 0.00134, "epss_percentile": 0.33848}, "CVE-2019-17266": {"epss_score": 0.00942, "epss_percentile": 0.75766}, "CVE-2019-17267": {"epss_score": 0.01195, "epss_percentile": 0.78428}, "CVE-2019-17268": {"epss_score": 0.00649, "epss_percentile": 0.70243}, "CVE-2019-17269": {"epss_score": 0.015, "epss_percentile": 0.80713}, "CVE-2019-17270": {"epss_score": 0.93937, "epss_percentile": 0.99871}, "CVE-2019-17271": {"epss_score": 0.00436, "epss_percentile": 0.62433}, "CVE-2019-17272": {"epss_score": 0.00463, "epss_percentile": 0.63631}, "CVE-2019-17273": {"epss_score": 0.00125, "epss_percentile": 0.32495}, "CVE-2019-17274": {"epss_score": 0.00192, "epss_percentile": 0.4132}, "CVE-2019-17275": {"epss_score": 0.02486, "epss_percentile": 0.84887}, "CVE-2019-17276": {"epss_score": 0.00355, "epss_percentile": 0.57296}, "CVE-2019-17292": {"epss_score": 0.00381, "epss_percentile": 0.58999}, "CVE-2019-17293": {"epss_score": 0.00371, "epss_percentile": 0.58403}, "CVE-2019-17294": {"epss_score": 0.00371, "epss_percentile": 0.58403}, "CVE-2019-17295": {"epss_score": 0.00371, "epss_percentile": 0.58403}, "CVE-2019-17296": {"epss_score": 0.00371, "epss_percentile": 0.58403}, "CVE-2019-17297": {"epss_score": 0.00371, "epss_percentile": 0.58403}, "CVE-2019-17298": {"epss_score": 0.00371, "epss_percentile": 0.58403}, "CVE-2019-17299": {"epss_score": 0.00594, "epss_percentile": 0.68668}, "CVE-2019-17300": {"epss_score": 0.00579, "epss_percentile": 0.68227}, "CVE-2019-17301": {"epss_score": 0.00525, "epss_percentile": 0.66366}, "CVE-2019-17302": {"epss_score": 0.00579, "epss_percentile": 0.68227}, "CVE-2019-17303": {"epss_score": 0.00579, "epss_percentile": 0.68227}, "CVE-2019-17304": {"epss_score": 0.00525, "epss_percentile": 0.66366}, "CVE-2019-17305": {"epss_score": 0.00579, "epss_percentile": 0.68227}, "CVE-2019-17306": {"epss_score": 0.00525, "epss_percentile": 0.66366}, "CVE-2019-17307": {"epss_score": 0.00525, "epss_percentile": 0.66366}, "CVE-2019-17308": {"epss_score": 0.00579, "epss_percentile": 0.68227}, "CVE-2019-17309": {"epss_score": 0.00594, "epss_percentile": 0.68668}, "CVE-2019-17310": {"epss_score": 0.00594, "epss_percentile": 0.68668}, "CVE-2019-17311": {"epss_score": 0.00662, "epss_percentile": 0.7061}, "CVE-2019-17312": {"epss_score": 0.00662, "epss_percentile": 0.7061}, "CVE-2019-17313": {"epss_score": 0.00662, "epss_percentile": 0.7061}, "CVE-2019-17314": {"epss_score": 0.006, "epss_percentile": 0.68824}, "CVE-2019-17315": {"epss_score": 0.01259, "epss_percentile": 0.78964}, "CVE-2019-17316": {"epss_score": 0.01228, "epss_percentile": 0.78706}, "CVE-2019-17317": {"epss_score": 0.01113, "epss_percentile": 0.77689}, "CVE-2019-17318": {"epss_score": 0.00371, "epss_percentile": 0.58403}, "CVE-2019-17319": {"epss_score": 0.00371, "epss_percentile": 0.58403}, "CVE-2019-17320": {"epss_score": 0.01028, "epss_percentile": 0.76815}, "CVE-2019-17321": {"epss_score": 0.00332, "epss_percentile": 0.55556}, "CVE-2019-17322": {"epss_score": 0.00547, "epss_percentile": 0.67261}, "CVE-2019-17323": {"epss_score": 0.00418, "epss_percentile": 0.61267}, "CVE-2019-17324": {"epss_score": 0.00553, "epss_percentile": 0.67428}, "CVE-2019-17325": {"epss_score": 0.00468, "epss_percentile": 0.63868}, "CVE-2019-17326": {"epss_score": 0.00479, "epss_percentile": 0.64416}, "CVE-2019-17327": {"epss_score": 0.01955, "epss_percentile": 0.83033}, "CVE-2019-17330": {"epss_score": 0.00302, "epss_percentile": 0.53164}, "CVE-2019-17331": {"epss_score": 0.00389, "epss_percentile": 0.59465}, "CVE-2019-17332": {"epss_score": 0.00365, "epss_percentile": 0.57982}, "CVE-2019-17333": {"epss_score": 0.00399, "epss_percentile": 0.60143}, "CVE-2019-17334": {"epss_score": 0.0039, "epss_percentile": 0.59536}, "CVE-2019-17335": {"epss_score": 0.00287, "epss_percentile": 0.51864}, "CVE-2019-17336": {"epss_score": 0.00353, "epss_percentile": 0.57137}, "CVE-2019-17337": {"epss_score": 0.00384, "epss_percentile": 0.59136}, "CVE-2019-17338": {"epss_score": 0.00389, "epss_percentile": 0.59465}, "CVE-2019-17339": {"epss_score": 0.00267, "epss_percentile": 0.49981}, "CVE-2019-17340": {"epss_score": 0.00077, "epss_percentile": 0.23452}, "CVE-2019-17341": {"epss_score": 0.00111, "epss_percentile": 0.30396}, "CVE-2019-17342": {"epss_score": 0.00121, "epss_percentile": 0.31839}, "CVE-2019-17343": {"epss_score": 0.00121, "epss_percentile": 0.31837}, "CVE-2019-17344": {"epss_score": 0.00148, "epss_percentile": 0.35911}, "CVE-2019-17345": {"epss_score": 0.00076, "epss_percentile": 0.23076}, "CVE-2019-17346": {"epss_score": 0.00177, "epss_percentile": 0.39531}, "CVE-2019-17347": {"epss_score": 0.00143, "epss_percentile": 0.35198}, "CVE-2019-17348": {"epss_score": 0.00205, "epss_percentile": 0.42677}, "CVE-2019-17349": {"epss_score": 0.00142, "epss_percentile": 0.35026}, "CVE-2019-17350": {"epss_score": 0.00142, "epss_percentile": 0.35026}, "CVE-2019-17351": {"epss_score": 0.00086, "epss_percentile": 0.25286}, "CVE-2019-17352": {"epss_score": 0.00289, "epss_percentile": 0.52015}, "CVE-2019-17353": {"epss_score": 0.0047, "epss_percentile": 0.63986}, "CVE-2019-17354": {"epss_score": 0.00297, "epss_percentile": 0.52706}, "CVE-2019-17355": {"epss_score": 0.00374, "epss_percentile": 0.58592}, "CVE-2019-17356": {"epss_score": 0.00035, "epss_percentile": 0.0996}, "CVE-2019-17357": {"epss_score": 0.16157, "epss_percentile": 0.94581}, "CVE-2019-17358": {"epss_score": 0.02418, "epss_percentile": 0.84696}, "CVE-2019-17359": {"epss_score": 0.07634, "epss_percentile": 0.91587}, "CVE-2019-17360": {"epss_score": 0.0071, "epss_percentile": 0.71702}, "CVE-2019-17361": {"epss_score": 0.17854, "epss_percentile": 0.94917}, "CVE-2019-17362": {"epss_score": 0.00473, "epss_percentile": 0.64085}, "CVE-2019-17364": {"epss_score": 0.03271, "epss_percentile": 0.86794}, "CVE-2019-17365": {"epss_score": 0.00049, "epss_percentile": 0.15543}, "CVE-2019-17366": {"epss_score": 0.00539, "epss_percentile": 0.66981}, "CVE-2019-17367": {"epss_score": 0.00177, "epss_percentile": 0.39553}, "CVE-2019-17368": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-17369": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2019-17370": {"epss_score": 0.01173, "epss_percentile": 0.78238}, "CVE-2019-17371": {"epss_score": 0.0041, "epss_percentile": 0.60813}, "CVE-2019-17372": {"epss_score": 0.0051, "epss_percentile": 0.65763}, "CVE-2019-17373": {"epss_score": 0.00933, "epss_percentile": 0.7564}, "CVE-2019-17375": {"epss_score": 0.00292, "epss_percentile": 0.5227}, "CVE-2019-17376": {"epss_score": 0.0017, "epss_percentile": 0.38732}, "CVE-2019-17377": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2019-17378": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2019-17379": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2019-17380": {"epss_score": 0.00416, "epss_percentile": 0.61197}, "CVE-2019-17382": {"epss_score": 0.93651, "epss_percentile": 0.9983}, "CVE-2019-17383": {"epss_score": 0.00265, "epss_percentile": 0.49774}, "CVE-2019-17384": {"epss_score": 0.00439, "epss_percentile": 0.62595}, "CVE-2019-17385": {"epss_score": 0.00439, "epss_percentile": 0.62595}, "CVE-2019-17386": {"epss_score": 0.00123, "epss_percentile": 0.32295}, "CVE-2019-17387": {"epss_score": 0.00255, "epss_percentile": 0.48634}, "CVE-2019-17388": {"epss_score": 0.00109, "epss_percentile": 0.29953}, "CVE-2019-17389": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2019-17390": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2019-17391": {"epss_score": 0.00155, "epss_percentile": 0.36798}, "CVE-2019-17392": {"epss_score": 0.00485, "epss_percentile": 0.64709}, "CVE-2019-17393": {"epss_score": 0.00198, "epss_percentile": 0.42093}, "CVE-2019-17394": {"epss_score": 0.00374, "epss_percentile": 0.58592}, "CVE-2019-17395": {"epss_score": 0.00374, "epss_percentile": 0.58592}, "CVE-2019-17396": {"epss_score": 0.00374, "epss_percentile": 0.58592}, "CVE-2019-17397": {"epss_score": 0.00374, "epss_percentile": 0.58592}, "CVE-2019-17398": {"epss_score": 0.00374, "epss_percentile": 0.58592}, "CVE-2019-17399": {"epss_score": 0.00733, "epss_percentile": 0.72205}, "CVE-2019-17400": {"epss_score": 0.00438, "epss_percentile": 0.62547}, "CVE-2019-17401": {"epss_score": 0.0014, "epss_percentile": 0.34707}, "CVE-2019-17402": {"epss_score": 0.00221, "epss_percentile": 0.44659}, "CVE-2019-17403": {"epss_score": 0.04593, "epss_percentile": 0.88893}, "CVE-2019-17404": {"epss_score": 0.00272, "epss_percentile": 0.50379}, "CVE-2019-17405": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2019-17406": {"epss_score": 0.00435, "epss_percentile": 0.62343}, "CVE-2019-17408": {"epss_score": 0.01969, "epss_percentile": 0.83089}, "CVE-2019-17409": {"epss_score": 0.01436, "epss_percentile": 0.80274}, "CVE-2019-17414": {"epss_score": 0.00933, "epss_percentile": 0.75633}, "CVE-2019-17415": {"epss_score": 0.05119, "epss_percentile": 0.89517}, "CVE-2019-17417": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-17418": {"epss_score": 0.9357, "epss_percentile": 0.99819}, "CVE-2019-17419": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2019-17420": {"epss_score": 0.00242, "epss_percentile": 0.47357}, "CVE-2019-17421": {"epss_score": 0.00114, "epss_percentile": 0.30767}, "CVE-2019-17424": {"epss_score": 0.2837, "epss_percentile": 0.96347}, "CVE-2019-17426": {"epss_score": 0.00237, "epss_percentile": 0.46689}, "CVE-2019-17427": {"epss_score": 0.02167, "epss_percentile": 0.83856}, "CVE-2019-17428": {"epss_score": 0.00115, "epss_percentile": 0.30929}, "CVE-2019-17429": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-17430": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2019-17431": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-17432": {"epss_score": 0.00118, "epss_percentile": 0.31458}, "CVE-2019-17433": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2019-17434": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2019-17435": {"epss_score": 0.00044, "epss_percentile": 0.13558}, "CVE-2019-17436": {"epss_score": 0.0004, "epss_percentile": 0.11879}, "CVE-2019-17437": {"epss_score": 0.00127, "epss_percentile": 0.329}, "CVE-2019-17440": {"epss_score": 0.0045, "epss_percentile": 0.63095}, "CVE-2019-17444": {"epss_score": 0.92338, "epss_percentile": 0.99709}, "CVE-2019-17445": {"epss_score": 0.00053, "epss_percentile": 0.16931}, "CVE-2019-17446": {"epss_score": 0.00051, "epss_percentile": 0.16188}, "CVE-2019-17449": {"epss_score": 0.00178, "epss_percentile": 0.39683}, "CVE-2019-17450": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2019-17451": {"epss_score": 0.01063, "epss_percentile": 0.77191}, "CVE-2019-17452": {"epss_score": 0.00285, "epss_percentile": 0.51681}, "CVE-2019-17453": {"epss_score": 0.00285, "epss_percentile": 0.51681}, "CVE-2019-17454": {"epss_score": 0.00285, "epss_percentile": 0.51681}, "CVE-2019-17455": {"epss_score": 0.07078, "epss_percentile": 0.91234}, "CVE-2019-17488": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-17489": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2019-17490": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2019-17491": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2019-17493": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2019-17494": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-17495": {"epss_score": 0.13709, "epss_percentile": 0.94039}, "CVE-2019-17496": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-17497": {"epss_score": 0.02302, "epss_percentile": 0.84315}, "CVE-2019-17498": {"epss_score": 0.02198, "epss_percentile": 0.83966}, "CVE-2019-17499": {"epss_score": 0.01617, "epss_percentile": 0.81363}, "CVE-2019-17501": {"epss_score": 0.00491, "epss_percentile": 0.64966}, "CVE-2019-17502": {"epss_score": 0.00435, "epss_percentile": 0.62332}, "CVE-2019-17503": {"epss_score": 0.9022, "epss_percentile": 0.99569}, "CVE-2019-17504": {"epss_score": 0.00396, "epss_percentile": 0.59883}, "CVE-2019-17505": {"epss_score": 0.00516, "epss_percentile": 0.66048}, "CVE-2019-17506": {"epss_score": 0.93847, "epss_percentile": 0.99857}, "CVE-2019-17507": {"epss_score": 0.00602, "epss_percentile": 0.68877}, "CVE-2019-17508": {"epss_score": 0.68977, "epss_percentile": 0.98572}, "CVE-2019-17509": {"epss_score": 0.04707, "epss_percentile": 0.89033}, "CVE-2019-17510": {"epss_score": 0.04707, "epss_percentile": 0.89033}, "CVE-2019-17511": {"epss_score": 0.04374, "epss_percentile": 0.88614}, "CVE-2019-17512": {"epss_score": 0.04046, "epss_percentile": 0.88173}, "CVE-2019-17513": {"epss_score": 0.0125, "epss_percentile": 0.78876}, "CVE-2019-17514": {"epss_score": 0.0171, "epss_percentile": 0.81871}, "CVE-2019-17515": {"epss_score": 0.00332, "epss_percentile": 0.55575}, "CVE-2019-17517": {"epss_score": 0.00211, "epss_percentile": 0.4371}, "CVE-2019-17518": {"epss_score": 0.00193, "epss_percentile": 0.4141}, "CVE-2019-17519": {"epss_score": 0.00081, "epss_percentile": 0.24373}, "CVE-2019-17520": {"epss_score": 0.00146, "epss_percentile": 0.35601}, "CVE-2019-17521": {"epss_score": 0.00161, "epss_percentile": 0.37584}, "CVE-2019-17522": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2019-17523": {"epss_score": 0.00212, "epss_percentile": 0.43732}, "CVE-2019-17524": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2019-17525": {"epss_score": 0.16198, "epss_percentile": 0.94592}, "CVE-2019-17526": {"epss_score": 0.00638, "epss_percentile": 0.6993}, "CVE-2019-17527": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-17528": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2019-17529": {"epss_score": 0.00165, "epss_percentile": 0.38112}, "CVE-2019-17530": {"epss_score": 0.00165, "epss_percentile": 0.38112}, "CVE-2019-17531": {"epss_score": 0.0119, "epss_percentile": 0.78376}, "CVE-2019-17532": {"epss_score": 0.00989, "epss_percentile": 0.76367}, "CVE-2019-17533": {"epss_score": 0.00547, "epss_percentile": 0.67264}, "CVE-2019-17534": {"epss_score": 0.00988, "epss_percentile": 0.76358}, "CVE-2019-17535": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2019-17536": {"epss_score": 0.00425, "epss_percentile": 0.61705}, "CVE-2019-17537": {"epss_score": 0.01051, "epss_percentile": 0.77077}, "CVE-2019-17538": {"epss_score": 0.91153, "epss_percentile": 0.99623}, "CVE-2019-17539": {"epss_score": 0.00668, "epss_percentile": 0.70737}, "CVE-2019-17540": {"epss_score": 0.0034, "epss_percentile": 0.56275}, "CVE-2019-17541": {"epss_score": 0.00201, "epss_percentile": 0.42337}, "CVE-2019-17542": {"epss_score": 0.00815, "epss_percentile": 0.73784}, "CVE-2019-17543": {"epss_score": 0.01442, "epss_percentile": 0.80311}, "CVE-2019-17544": {"epss_score": 0.0036, "epss_percentile": 0.57632}, "CVE-2019-17545": {"epss_score": 0.02245, "epss_percentile": 0.84126}, "CVE-2019-17546": {"epss_score": 0.00373, "epss_percentile": 0.58507}, "CVE-2019-17547": {"epss_score": 0.0048, "epss_percentile": 0.64477}, "CVE-2019-17549": {"epss_score": 0.00365, "epss_percentile": 0.57984}, "CVE-2019-17550": {"epss_score": 0.00332, "epss_percentile": 0.55575}, "CVE-2019-17551": {"epss_score": 0.00521, "epss_percentile": 0.6624}, "CVE-2019-17552": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-17553": {"epss_score": 0.00683, "epss_percentile": 0.71093}, "CVE-2019-17554": {"epss_score": 0.52533, "epss_percentile": 0.97831}, "CVE-2019-17555": {"epss_score": 0.02203, "epss_percentile": 0.83987}, "CVE-2019-17556": {"epss_score": 0.00782, "epss_percentile": 0.73201}, "CVE-2019-17557": {"epss_score": 0.01193, "epss_percentile": 0.78408}, "CVE-2019-17558": {"epss_score": 0.94454, "epss_percentile": 0.99992}, "CVE-2019-17559": {"epss_score": 0.01409, "epss_percentile": 0.80065}, "CVE-2019-17560": {"epss_score": 0.0142, "epss_percentile": 0.80169}, "CVE-2019-17561": {"epss_score": 0.0073, "epss_percentile": 0.72143}, "CVE-2019-17562": {"epss_score": 0.01905, "epss_percentile": 0.82796}, "CVE-2019-17563": {"epss_score": 0.02427, "epss_percentile": 0.84717}, "CVE-2019-17564": {"epss_score": 0.94048, "epss_percentile": 0.99892}, "CVE-2019-17565": {"epss_score": 0.01208, "epss_percentile": 0.78533}, "CVE-2019-17566": {"epss_score": 0.00815, "epss_percentile": 0.73791}, "CVE-2019-17567": {"epss_score": 0.12438, "epss_percentile": 0.93671}, "CVE-2019-17569": {"epss_score": 0.06063, "epss_percentile": 0.90445}, "CVE-2019-17570": {"epss_score": 0.70524, "epss_percentile": 0.98635}, "CVE-2019-17571": {"epss_score": 0.48455, "epss_percentile": 0.97639}, "CVE-2019-17572": {"epss_score": 0.01144, "epss_percentile": 0.77986}, "CVE-2019-17573": {"epss_score": 0.15538, "epss_percentile": 0.94453}, "CVE-2019-17574": {"epss_score": 0.86894, "epss_percentile": 0.99403}, "CVE-2019-17575": {"epss_score": 0.00266, "epss_percentile": 0.49923}, "CVE-2019-17576": {"epss_score": 0.00313, "epss_percentile": 0.54028}, "CVE-2019-17577": {"epss_score": 0.00313, "epss_percentile": 0.54028}, "CVE-2019-17578": {"epss_score": 0.00313, "epss_percentile": 0.54028}, "CVE-2019-17579": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-17580": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-17581": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-17582": {"epss_score": 0.00834, "epss_percentile": 0.741}, "CVE-2019-17583": {"epss_score": 0.00807, "epss_percentile": 0.73684}, "CVE-2019-17584": {"epss_score": 0.0067, "epss_percentile": 0.70781}, "CVE-2019-17590": {"epss_score": 0.00047, "epss_percentile": 0.14657}, "CVE-2019-17592": {"epss_score": 0.00577, "epss_percentile": 0.68164}, "CVE-2019-17593": {"epss_score": 0.00165, "epss_percentile": 0.38027}, "CVE-2019-17594": {"epss_score": 0.00032, "epss_percentile": 0.0901}, "CVE-2019-17595": {"epss_score": 0.00086, "epss_percentile": 0.25371}, "CVE-2019-17596": {"epss_score": 0.0234, "epss_percentile": 0.8443}, "CVE-2019-17598": {"epss_score": 0.0015, "epss_percentile": 0.36173}, "CVE-2019-17599": {"epss_score": 0.00737, "epss_percentile": 0.72323}, "CVE-2019-17600": {"epss_score": 0.00195, "epss_percentile": 0.41643}, "CVE-2019-17601": {"epss_score": 0.00573, "epss_percentile": 0.68047}, "CVE-2019-17602": {"epss_score": 0.58634, "epss_percentile": 0.98129}, "CVE-2019-17603": {"epss_score": 0.0022, "epss_percentile": 0.44582}, "CVE-2019-17604": {"epss_score": 0.00229, "epss_percentile": 0.45644}, "CVE-2019-17605": {"epss_score": 0.00359, "epss_percentile": 0.57543}, "CVE-2019-17606": {"epss_score": 0.00344, "epss_percentile": 0.56505}, "CVE-2019-17607": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2019-17608": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2019-17609": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2019-17610": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2019-17611": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2019-17612": {"epss_score": 0.0032, "epss_percentile": 0.54591}, "CVE-2019-17613": {"epss_score": 0.03282, "epss_percentile": 0.8682}, "CVE-2019-17621": {"epss_score": 0.93302, "epss_percentile": 0.99795}, "CVE-2019-17624": {"epss_score": 0.16233, "epss_percentile": 0.94598}, "CVE-2019-17625": {"epss_score": 0.05057, "epss_percentile": 0.89449}, "CVE-2019-17626": {"epss_score": 0.16839, "epss_percentile": 0.94736}, "CVE-2019-17627": {"epss_score": 0.00158, "epss_percentile": 0.37158}, "CVE-2019-17629": {"epss_score": 0.00359, "epss_percentile": 0.57551}, "CVE-2019-17630": {"epss_score": 0.00359, "epss_percentile": 0.57551}, "CVE-2019-17631": {"epss_score": 0.005, "epss_percentile": 0.65293}, "CVE-2019-17632": {"epss_score": 0.01455, "epss_percentile": 0.80385}, "CVE-2019-17633": {"epss_score": 0.00536, "epss_percentile": 0.66863}, "CVE-2019-17634": {"epss_score": 0.01282, "epss_percentile": 0.79152}, "CVE-2019-17635": {"epss_score": 0.00466, "epss_percentile": 0.63797}, "CVE-2019-17636": {"epss_score": 0.0012, "epss_percentile": 0.31793}, "CVE-2019-17637": {"epss_score": 0.00165, "epss_percentile": 0.38058}, "CVE-2019-17638": {"epss_score": 0.30928, "epss_percentile": 0.96576}, "CVE-2019-17639": {"epss_score": 0.00632, "epss_percentile": 0.69735}, "CVE-2019-17640": {"epss_score": 0.0169, "epss_percentile": 0.81772}, "CVE-2019-17642": {"epss_score": 0.0028, "epss_percentile": 0.5109}, "CVE-2019-17643": {"epss_score": 0.00048, "epss_percentile": 0.1525}, "CVE-2019-17644": {"epss_score": 0.00057, "epss_percentile": 0.18104}, "CVE-2019-17645": {"epss_score": 0.0007, "epss_percentile": 0.21754}, "CVE-2019-17646": {"epss_score": 0.00055, "epss_percentile": 0.17582}, "CVE-2019-17647": {"epss_score": 0.00072, "epss_percentile": 0.22342}, "CVE-2019-17650": {"epss_score": 0.00119, "epss_percentile": 0.31586}, "CVE-2019-17651": {"epss_score": 0.00203, "epss_percentile": 0.42571}, "CVE-2019-17652": {"epss_score": 0.00425, "epss_percentile": 0.61727}, "CVE-2019-17653": {"epss_score": 0.0027, "epss_percentile": 0.50262}, "CVE-2019-17654": {"epss_score": 0.00215, "epss_percentile": 0.44077}, "CVE-2019-17655": {"epss_score": 0.00183, "epss_percentile": 0.40317}, "CVE-2019-17656": {"epss_score": 0.02796, "epss_percentile": 0.8568}, "CVE-2019-17657": {"epss_score": 0.00777, "epss_percentile": 0.7311}, "CVE-2019-17658": {"epss_score": 0.00391, "epss_percentile": 0.59621}, "CVE-2019-17659": {"epss_score": 0.00156, "epss_percentile": 0.36933}, "CVE-2019-17660": {"epss_score": 0.00404, "epss_percentile": 0.60454}, "CVE-2019-17661": {"epss_score": 0.01448, "epss_percentile": 0.80333}, "CVE-2019-17662": {"epss_score": 0.94097, "epss_percentile": 0.99902}, "CVE-2019-17663": {"epss_score": 0.00414, "epss_percentile": 0.61042}, "CVE-2019-17664": {"epss_score": 0.00156, "epss_percentile": 0.36897}, "CVE-2019-17665": {"epss_score": 0.00139, "epss_percentile": 0.34643}, "CVE-2019-17666": {"epss_score": 0.00451, "epss_percentile": 0.63127}, "CVE-2019-17667": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-17668": {"epss_score": 0.00163, "epss_percentile": 0.37764}, "CVE-2019-17669": {"epss_score": 0.09505, "epss_percentile": 0.92576}, "CVE-2019-17670": {"epss_score": 0.0554, "epss_percentile": 0.89977}, "CVE-2019-17671": {"epss_score": 0.82836, "epss_percentile": 0.99218}, "CVE-2019-17672": {"epss_score": 0.05346, "epss_percentile": 0.8977}, "CVE-2019-17673": {"epss_score": 0.03574, "epss_percentile": 0.87377}, "CVE-2019-17674": {"epss_score": 0.02484, "epss_percentile": 0.84881}, "CVE-2019-17675": {"epss_score": 0.02591, "epss_percentile": 0.85183}, "CVE-2019-17676": {"epss_score": 0.00148, "epss_percentile": 0.35822}, "CVE-2019-18177": {"epss_score": 0.00365, "epss_percentile": 0.57975}, "CVE-2019-18178": {"epss_score": 0.00278, "epss_percentile": 0.50859}, "CVE-2019-18179": {"epss_score": 0.00521, "epss_percentile": 0.66218}, "CVE-2019-18180": {"epss_score": 0.01334, "epss_percentile": 0.79534}, "CVE-2019-18181": {"epss_score": 0.00044, "epss_percentile": 0.13366}, "CVE-2019-18182": {"epss_score": 0.07867, "epss_percentile": 0.91729}, "CVE-2019-18183": {"epss_score": 0.07867, "epss_percentile": 0.91729}, "CVE-2019-18184": {"epss_score": 0.21435, "epss_percentile": 0.95517}, "CVE-2019-18187": {"epss_score": 0.78453, "epss_percentile": 0.98987}, "CVE-2019-18188": {"epss_score": 0.02677, "epss_percentile": 0.85404}, "CVE-2019-18189": {"epss_score": 0.00595, "epss_percentile": 0.68695}, "CVE-2019-18190": {"epss_score": 0.00734, "epss_percentile": 0.7222}, "CVE-2019-18191": {"epss_score": 0.008, "epss_percentile": 0.73543}, "CVE-2019-18192": {"epss_score": 0.00105, "epss_percentile": 0.29379}, "CVE-2019-18193": {"epss_score": 0.00043, "epss_percentile": 0.13026}, "CVE-2019-18194": {"epss_score": 0.00714, "epss_percentile": 0.71813}, "CVE-2019-18195": {"epss_score": 0.00408, "epss_percentile": 0.60674}, "CVE-2019-18196": {"epss_score": 0.00158, "epss_percentile": 0.37244}, "CVE-2019-18197": {"epss_score": 0.04774, "epss_percentile": 0.89129}, "CVE-2019-18198": {"epss_score": 0.00142, "epss_percentile": 0.35043}, "CVE-2019-18199": {"epss_score": 0.00045, "epss_percentile": 0.13821}, "CVE-2019-18200": {"epss_score": 0.00326, "epss_percentile": 0.55091}, "CVE-2019-18201": {"epss_score": 0.00136, "epss_percentile": 0.34139}, "CVE-2019-18202": {"epss_score": 0.00636, "epss_percentile": 0.69861}, "CVE-2019-18203": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-18204": {"epss_score": 0.00966, "epss_percentile": 0.76051}, "CVE-2019-18205": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-18206": {"epss_score": 0.00177, "epss_percentile": 0.39555}, "CVE-2019-18207": {"epss_score": 0.0053, "epss_percentile": 0.66617}, "CVE-2019-18209": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-18210": {"epss_score": 0.0044, "epss_percentile": 0.62611}, "CVE-2019-18211": {"epss_score": 0.02812, "epss_percentile": 0.85723}, "CVE-2019-18212": {"epss_score": 0.00547, "epss_percentile": 0.67257}, "CVE-2019-18213": {"epss_score": 0.00624, "epss_percentile": 0.69557}, "CVE-2019-18214": {"epss_score": 0.00389, "epss_percentile": 0.5945}, "CVE-2019-18215": {"epss_score": 0.00073, "epss_percentile": 0.22569}, "CVE-2019-18216": {"epss_score": 0.00139, "epss_percentile": 0.34643}, "CVE-2019-18217": {"epss_score": 0.04693, "epss_percentile": 0.89014}, "CVE-2019-18218": {"epss_score": 0.00227, "epss_percentile": 0.4544}, "CVE-2019-18219": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-18220": {"epss_score": 0.00552, "epss_percentile": 0.67396}, "CVE-2019-18221": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-18222": {"epss_score": 0.00126, "epss_percentile": 0.32699}, "CVE-2019-18223": {"epss_score": 0.00573, "epss_percentile": 0.6805}, "CVE-2019-18224": {"epss_score": 0.02397, "epss_percentile": 0.84619}, "CVE-2019-18225": {"epss_score": 0.002, "epss_percentile": 0.42271}, "CVE-2019-18226": {"epss_score": 0.00178, "epss_percentile": 0.39705}, "CVE-2019-18227": {"epss_score": 0.03538, "epss_percentile": 0.87314}, "CVE-2019-18228": {"epss_score": 0.00553, "epss_percentile": 0.67414}, "CVE-2019-18229": {"epss_score": 0.00686, "epss_percentile": 0.71158}, "CVE-2019-18230": {"epss_score": 0.00256, "epss_percentile": 0.4877}, "CVE-2019-18231": {"epss_score": 0.00116, "epss_percentile": 0.31139}, "CVE-2019-18232": {"epss_score": 0.00246, "epss_percentile": 0.47803}, "CVE-2019-18233": {"epss_score": 0.00275, "epss_percentile": 0.5065}, "CVE-2019-18234": {"epss_score": 0.00206, "epss_percentile": 0.42768}, "CVE-2019-18235": {"epss_score": 0.00385, "epss_percentile": 0.59195}, "CVE-2019-18236": {"epss_score": 0.00976, "epss_percentile": 0.76211}, "CVE-2019-18238": {"epss_score": 0.00145, "epss_percentile": 0.35429}, "CVE-2019-18240": {"epss_score": 0.01505, "epss_percentile": 0.80743}, "CVE-2019-18241": {"epss_score": 0.00051, "epss_percentile": 0.1604}, "CVE-2019-18242": {"epss_score": 0.00339, "epss_percentile": 0.56176}, "CVE-2019-18243": {"epss_score": 0.00036, "epss_percentile": 0.10245}, "CVE-2019-18244": {"epss_score": 0.00125, "epss_percentile": 0.32595}, "CVE-2019-18245": {"epss_score": 0.00114, "epss_percentile": 0.30737}, "CVE-2019-18246": {"epss_score": 0.00049, "epss_percentile": 0.15318}, "CVE-2019-18247": {"epss_score": 0.00549, "epss_percentile": 0.67296}, "CVE-2019-18248": {"epss_score": 0.00027, "epss_percentile": 0.06762}, "CVE-2019-18249": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2019-18250": {"epss_score": 0.00123, "epss_percentile": 0.32194}, "CVE-2019-18251": {"epss_score": 0.00257, "epss_percentile": 0.48926}, "CVE-2019-18252": {"epss_score": 0.00049, "epss_percentile": 0.15318}, "CVE-2019-18253": {"epss_score": 0.00525, "epss_percentile": 0.66387}, "CVE-2019-18254": {"epss_score": 0.0003, "epss_percentile": 0.08306}, "CVE-2019-18255": {"epss_score": 0.00036, "epss_percentile": 0.10245}, "CVE-2019-18256": {"epss_score": 0.00056, "epss_percentile": 0.17733}, "CVE-2019-18257": {"epss_score": 0.01215, "epss_percentile": 0.78581}, "CVE-2019-18259": {"epss_score": 0.00328, "epss_percentile": 0.55258}, "CVE-2019-18261": {"epss_score": 0.00158, "epss_percentile": 0.37158}, "CVE-2019-18263": {"epss_score": 0.00051, "epss_percentile": 0.16255}, "CVE-2019-18265": {"epss_score": 0.0027, "epss_percentile": 0.50264}, "CVE-2019-18267": {"epss_score": 0.00712, "epss_percentile": 0.71774}, "CVE-2019-18269": {"epss_score": 0.00351, "epss_percentile": 0.57016}, "CVE-2019-18271": {"epss_score": 0.00094, "epss_percentile": 0.26783}, "CVE-2019-18273": {"epss_score": 0.00279, "epss_percentile": 0.50968}, "CVE-2019-18275": {"epss_score": 0.00132, "epss_percentile": 0.33515}, "CVE-2019-18276": {"epss_score": 0.49613, "epss_percentile": 0.97697}, "CVE-2019-18277": {"epss_score": 0.00834, "epss_percentile": 0.74105}, "CVE-2019-18278": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-18279": {"epss_score": 0.00593, "epss_percentile": 0.68636}, "CVE-2019-18280": {"epss_score": 0.00182, "epss_percentile": 0.40246}, "CVE-2019-18281": {"epss_score": 0.01749, "epss_percentile": 0.82089}, "CVE-2019-18282": {"epss_score": 0.00503, "epss_percentile": 0.65462}, "CVE-2019-18283": {"epss_score": 0.11462, "epss_percentile": 0.93373}, "CVE-2019-18284": {"epss_score": 0.0039, "epss_percentile": 0.59506}, "CVE-2019-18285": {"epss_score": 0.00176, "epss_percentile": 0.39375}, "CVE-2019-18286": {"epss_score": 0.00328, "epss_percentile": 0.55265}, "CVE-2019-18287": {"epss_score": 0.00328, "epss_percentile": 0.55265}, "CVE-2019-18288": {"epss_score": 0.07739, "epss_percentile": 0.91652}, "CVE-2019-18289": {"epss_score": 0.02552, "epss_percentile": 0.8508}, "CVE-2019-18290": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2019-18291": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2019-18292": {"epss_score": 0.00192, "epss_percentile": 0.41297}, "CVE-2019-18293": {"epss_score": 0.02552, "epss_percentile": 0.8508}, "CVE-2019-18294": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2019-18295": {"epss_score": 0.02552, "epss_percentile": 0.8508}, "CVE-2019-18296": {"epss_score": 0.02552, "epss_percentile": 0.8508}, "CVE-2019-18297": {"epss_score": 0.00073, "epss_percentile": 0.22477}, "CVE-2019-18298": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2019-18299": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2019-18300": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2019-18301": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2019-18302": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2019-18303": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2019-18304": {"epss_score": 0.00192, "epss_percentile": 0.41297}, "CVE-2019-18305": {"epss_score": 0.00192, "epss_percentile": 0.41297}, "CVE-2019-18306": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2019-18307": {"epss_score": 0.00192, "epss_percentile": 0.41297}, "CVE-2019-18308": {"epss_score": 0.00094, "epss_percentile": 0.2707}, "CVE-2019-18309": {"epss_score": 0.00094, "epss_percentile": 0.2707}, "CVE-2019-18310": {"epss_score": 0.00239, "epss_percentile": 0.46896}, "CVE-2019-18311": {"epss_score": 0.00205, "epss_percentile": 0.42671}, "CVE-2019-18312": {"epss_score": 0.00328, "epss_percentile": 0.55265}, "CVE-2019-18313": {"epss_score": 0.03948, "epss_percentile": 0.87998}, "CVE-2019-18314": {"epss_score": 0.02861, "epss_percentile": 0.85853}, "CVE-2019-18315": {"epss_score": 0.01023, "epss_percentile": 0.76764}, "CVE-2019-18316": {"epss_score": 0.01715, "epss_percentile": 0.81897}, "CVE-2019-18317": {"epss_score": 0.00485, "epss_percentile": 0.64704}, "CVE-2019-18318": {"epss_score": 0.00485, "epss_percentile": 0.64704}, "CVE-2019-18319": {"epss_score": 0.00485, "epss_percentile": 0.64704}, "CVE-2019-18320": {"epss_score": 0.00363, "epss_percentile": 0.57864}, "CVE-2019-18321": {"epss_score": 0.00122, "epss_percentile": 0.3202}, "CVE-2019-18322": {"epss_score": 0.00122, "epss_percentile": 0.3202}, "CVE-2019-18323": {"epss_score": 0.01425, "epss_percentile": 0.80201}, "CVE-2019-18324": {"epss_score": 0.01425, "epss_percentile": 0.80201}, "CVE-2019-18325": {"epss_score": 0.01425, "epss_percentile": 0.80201}, "CVE-2019-18326": {"epss_score": 0.01425, "epss_percentile": 0.80201}, "CVE-2019-18327": {"epss_score": 0.01425, "epss_percentile": 0.80201}, "CVE-2019-18328": {"epss_score": 0.01425, "epss_percentile": 0.80201}, "CVE-2019-18329": {"epss_score": 0.01425, "epss_percentile": 0.80201}, "CVE-2019-18330": {"epss_score": 0.01425, "epss_percentile": 0.80201}, "CVE-2019-18331": {"epss_score": 0.00165, "epss_percentile": 0.38137}, "CVE-2019-18332": {"epss_score": 0.00142, "epss_percentile": 0.34969}, "CVE-2019-18333": {"epss_score": 0.00165, "epss_percentile": 0.38137}, "CVE-2019-18334": {"epss_score": 0.00165, "epss_percentile": 0.38137}, "CVE-2019-18335": {"epss_score": 0.00165, "epss_percentile": 0.38137}, "CVE-2019-18336": {"epss_score": 0.0025, "epss_percentile": 0.48257}, "CVE-2019-18337": {"epss_score": 0.00074, "epss_percentile": 0.22852}, "CVE-2019-18338": {"epss_score": 0.00756, "epss_percentile": 0.72736}, "CVE-2019-18339": {"epss_score": 0.0015, "epss_percentile": 0.36068}, "CVE-2019-18340": {"epss_score": 0.00058, "epss_percentile": 0.18401}, "CVE-2019-18341": {"epss_score": 0.00064, "epss_percentile": 0.20395}, "CVE-2019-18342": {"epss_score": 0.00567, "epss_percentile": 0.67877}, "CVE-2019-18344": {"epss_score": 0.00617, "epss_percentile": 0.69345}, "CVE-2019-18345": {"epss_score": 0.01088, "epss_percentile": 0.77438}, "CVE-2019-18346": {"epss_score": 0.01108, "epss_percentile": 0.77637}, "CVE-2019-18347": {"epss_score": 0.0075, "epss_percentile": 0.7262}, "CVE-2019-18348": {"epss_score": 0.03165, "epss_percentile": 0.86539}, "CVE-2019-18349": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2019-18350": {"epss_score": 0.00293, "epss_percentile": 0.52299}, "CVE-2019-18352": {"epss_score": 0.00198, "epss_percentile": 0.42061}, "CVE-2019-18355": {"epss_score": 0.0042, "epss_percentile": 0.6141}, "CVE-2019-18356": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2019-18357": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2019-18359": {"epss_score": 0.00503, "epss_percentile": 0.65464}, "CVE-2019-18360": {"epss_score": 3e-05, "epss_percentile": 0.00107}, "CVE-2019-18361": {"epss_score": 1e-05, "epss_percentile": 9e-05}, "CVE-2019-18362": {"epss_score": 3e-05, "epss_percentile": 0.00107}, "CVE-2019-18363": {"epss_score": 4e-05, "epss_percentile": 0.00145}, "CVE-2019-18364": {"epss_score": 0.00048, "epss_percentile": 0.15054}, "CVE-2019-18365": {"epss_score": 3e-05, "epss_percentile": 0.00074}, "CVE-2019-18366": {"epss_score": 3e-05, "epss_percentile": 0.00114}, "CVE-2019-18367": {"epss_score": 3e-05, "epss_percentile": 0.00087}, "CVE-2019-18368": {"epss_score": 6e-05, "epss_percentile": 0.00245}, "CVE-2019-18369": {"epss_score": 3e-05, "epss_percentile": 0.00072}, "CVE-2019-18370": {"epss_score": 0.64013, "epss_percentile": 0.98359}, "CVE-2019-18371": {"epss_score": 0.91982, "epss_percentile": 0.99683}, "CVE-2019-18372": {"epss_score": 0.00055, "epss_percentile": 0.17552}, "CVE-2019-18373": {"epss_score": 0.00073, "epss_percentile": 0.22493}, "CVE-2019-18374": {"epss_score": 0.00536, "epss_percentile": 0.66883}, "CVE-2019-18375": {"epss_score": 0.00222, "epss_percentile": 0.44796}, "CVE-2019-18376": {"epss_score": 0.00228, "epss_percentile": 0.45525}, "CVE-2019-18377": {"epss_score": 0.0105, "epss_percentile": 0.77066}, "CVE-2019-18378": {"epss_score": 0.00315, "epss_percentile": 0.54193}, "CVE-2019-18379": {"epss_score": 0.00932, "epss_percentile": 0.75632}, "CVE-2019-18380": {"epss_score": 0.00082, "epss_percentile": 0.24413}, "CVE-2019-18381": {"epss_score": 0.00141, "epss_percentile": 0.34863}, "CVE-2019-18382": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2019-18383": {"epss_score": 0.00347, "epss_percentile": 0.56752}, "CVE-2019-18384": {"epss_score": 0.00726, "epss_percentile": 0.7207}, "CVE-2019-18385": {"epss_score": 0.00714, "epss_percentile": 0.71815}, "CVE-2019-18386": {"epss_score": 0.00494, "epss_percentile": 0.65087}, "CVE-2019-18387": {"epss_score": 0.00699, "epss_percentile": 0.71445}, "CVE-2019-18388": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2019-18389": {"epss_score": 0.00338, "epss_percentile": 0.56152}, "CVE-2019-18390": {"epss_score": 0.00113, "epss_percentile": 0.30636}, "CVE-2019-18391": {"epss_score": 0.0011, "epss_percentile": 0.3012}, "CVE-2019-18393": {"epss_score": 0.82521, "epss_percentile": 0.99197}, "CVE-2019-18394": {"epss_score": 0.9388, "epss_percentile": 0.99863}, "CVE-2019-18396": {"epss_score": 0.57848, "epss_percentile": 0.98086}, "CVE-2019-18397": {"epss_score": 0.00807, "epss_percentile": 0.73666}, "CVE-2019-18408": {"epss_score": 0.04588, "epss_percentile": 0.8889}, "CVE-2019-18409": {"epss_score": 0.00111, "epss_percentile": 0.30282}, "CVE-2019-18411": {"epss_score": 0.00174, "epss_percentile": 0.39193}, "CVE-2019-18412": {"epss_score": 3e-05, "epss_percentile": 0.00085}, "CVE-2019-18413": {"epss_score": 0.00114, "epss_percentile": 0.30762}, "CVE-2019-18414": {"epss_score": 0.00182, "epss_percentile": 0.40246}, "CVE-2019-18415": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-18416": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-18417": {"epss_score": 0.00966, "epss_percentile": 0.76051}, "CVE-2019-18418": {"epss_score": 0.1056, "epss_percentile": 0.93028}, "CVE-2019-18419": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2019-18420": {"epss_score": 0.04252, "epss_percentile": 0.88454}, "CVE-2019-18421": {"epss_score": 0.0196, "epss_percentile": 0.83058}, "CVE-2019-18422": {"epss_score": 0.03766, "epss_percentile": 0.87696}, "CVE-2019-18423": {"epss_score": 0.05447, "epss_percentile": 0.89889}, "CVE-2019-18424": {"epss_score": 0.00118, "epss_percentile": 0.31518}, "CVE-2019-18425": {"epss_score": 0.04874, "epss_percentile": 0.89235}, "CVE-2019-18426": {"epss_score": 0.54413, "epss_percentile": 0.97925}, "CVE-2019-18446": {"epss_score": 0.00066, "epss_percentile": 0.20685}, "CVE-2019-18447": {"epss_score": 0.00071, "epss_percentile": 0.22159}, "CVE-2019-18448": {"epss_score": 0.00093, "epss_percentile": 0.26636}, "CVE-2019-18449": {"epss_score": 0.00071, "epss_percentile": 0.22159}, "CVE-2019-18450": {"epss_score": 0.00071, "epss_percentile": 0.22159}, "CVE-2019-18451": {"epss_score": 0.001, "epss_percentile": 0.28443}, "CVE-2019-18452": {"epss_score": 0.00086, "epss_percentile": 0.25419}, "CVE-2019-18453": {"epss_score": 0.00066, "epss_percentile": 0.20685}, "CVE-2019-18454": {"epss_score": 0.00133, "epss_percentile": 0.33698}, "CVE-2019-18455": {"epss_score": 0.00267, "epss_percentile": 0.50011}, "CVE-2019-18456": {"epss_score": 0.00086, "epss_percentile": 0.25419}, "CVE-2019-18457": {"epss_score": 0.00081, "epss_percentile": 0.24336}, "CVE-2019-18458": {"epss_score": 0.0007, "epss_percentile": 0.21745}, "CVE-2019-18459": {"epss_score": 0.00086, "epss_percentile": 0.25419}, "CVE-2019-18460": {"epss_score": 0.00095, "epss_percentile": 0.27215}, "CVE-2019-18461": {"epss_score": 0.00106, "epss_percentile": 0.294}, "CVE-2019-18462": {"epss_score": 0.00071, "epss_percentile": 0.22159}, "CVE-2019-18463": {"epss_score": 0.00071, "epss_percentile": 0.22159}, "CVE-2019-18464": {"epss_score": 0.00253, "epss_percentile": 0.48439}, "CVE-2019-18465": {"epss_score": 0.00019, "epss_percentile": 0.04268}, "CVE-2019-18466": {"epss_score": 0.00839, "epss_percentile": 0.74185}, "CVE-2019-18567": {"epss_score": 0.0031, "epss_percentile": 0.53781}, "CVE-2019-18568": {"epss_score": 0.00118, "epss_percentile": 0.31466}, "CVE-2019-18571": {"epss_score": 0.00382, "epss_percentile": 0.59062}, "CVE-2019-18572": {"epss_score": 0.01314, "epss_percentile": 0.79393}, "CVE-2019-18573": {"epss_score": 0.00232, "epss_percentile": 0.45942}, "CVE-2019-18574": {"epss_score": 0.00248, "epss_percentile": 0.4797}, "CVE-2019-18575": {"epss_score": 0.00132, "epss_percentile": 0.33536}, "CVE-2019-18576": {"epss_score": 0.00119, "epss_percentile": 0.31628}, "CVE-2019-18577": {"epss_score": 0.00103, "epss_percentile": 0.29095}, "CVE-2019-18578": {"epss_score": 0.00562, "epss_percentile": 0.67693}, "CVE-2019-18579": {"epss_score": 0.00227, "epss_percentile": 0.4537}, "CVE-2019-18580": {"epss_score": 0.1184, "epss_percentile": 0.93492}, "CVE-2019-18581": {"epss_score": 0.02202, "epss_percentile": 0.83982}, "CVE-2019-18582": {"epss_score": 0.02386, "epss_percentile": 0.8458}, "CVE-2019-18588": {"epss_score": 0.00525, "epss_percentile": 0.66384}, "CVE-2019-18601": {"epss_score": 0.01102, "epss_percentile": 0.77587}, "CVE-2019-18602": {"epss_score": 0.00413, "epss_percentile": 0.60962}, "CVE-2019-18603": {"epss_score": 0.00413, "epss_percentile": 0.60962}, "CVE-2019-18604": {"epss_score": 0.00198, "epss_percentile": 0.42063}, "CVE-2019-18608": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2019-18609": {"epss_score": 0.02763, "epss_percentile": 0.85606}, "CVE-2019-18610": {"epss_score": 0.43014, "epss_percentile": 0.97365}, "CVE-2019-18611": {"epss_score": 0.00353, "epss_percentile": 0.57137}, "CVE-2019-18612": {"epss_score": 0.00316, "epss_percentile": 0.54278}, "CVE-2019-18614": {"epss_score": 0.00053, "epss_percentile": 0.17023}, "CVE-2019-18615": {"epss_score": 0.00106, "epss_percentile": 0.29497}, "CVE-2019-18618": {"epss_score": 0.00373, "epss_percentile": 0.58515}, "CVE-2019-18619": {"epss_score": 0.00138, "epss_percentile": 0.3438}, "CVE-2019-18622": {"epss_score": 0.00876, "epss_percentile": 0.74788}, "CVE-2019-18623": {"epss_score": 0.00473, "epss_percentile": 0.64082}, "CVE-2019-18624": {"epss_score": 0.00203, "epss_percentile": 0.42558}, "CVE-2019-18625": {"epss_score": 0.00254, "epss_percentile": 0.48515}, "CVE-2019-18626": {"epss_score": 0.0035, "epss_percentile": 0.56967}, "CVE-2019-18628": {"epss_score": 0.00172, "epss_percentile": 0.38979}, "CVE-2019-18629": {"epss_score": 0.00451, "epss_percentile": 0.63128}, "CVE-2019-18630": {"epss_score": 0.00254, "epss_percentile": 0.48505}, "CVE-2019-18631": {"epss_score": 0.00799, "epss_percentile": 0.73524}, "CVE-2019-18632": {"epss_score": 0.00196, "epss_percentile": 0.41734}, "CVE-2019-18633": {"epss_score": 0.00196, "epss_percentile": 0.41734}, "CVE-2019-18634": {"epss_score": 0.87268, "epss_percentile": 0.99421}, "CVE-2019-18635": {"epss_score": 0.00341, "epss_percentile": 0.56307}, "CVE-2019-18636": {"epss_score": 0.00236, "epss_percentile": 0.46379}, "CVE-2019-18641": {"epss_score": 0.03703, "epss_percentile": 0.87594}, "CVE-2019-18642": {"epss_score": 0.00412, "epss_percentile": 0.60924}, "CVE-2019-18643": {"epss_score": 0.01302, "epss_percentile": 0.79304}, "CVE-2019-18644": {"epss_score": 0.00266, "epss_percentile": 0.49918}, "CVE-2019-18645": {"epss_score": 0.00209, "epss_percentile": 0.43409}, "CVE-2019-18646": {"epss_score": 0.00444, "epss_percentile": 0.62832}, "CVE-2019-18647": {"epss_score": 0.01451, "epss_percentile": 0.80359}, "CVE-2019-18648": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2019-18649": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2019-18650": {"epss_score": 6e-05, "epss_percentile": 0.00288}, "CVE-2019-18651": {"epss_score": 0.00115, "epss_percentile": 0.31036}, "CVE-2019-18652": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2019-18653": {"epss_score": 0.00296, "epss_percentile": 0.52532}, "CVE-2019-18654": {"epss_score": 0.00296, "epss_percentile": 0.52532}, "CVE-2019-18655": {"epss_score": 0.43475, "epss_percentile": 0.97388}, "CVE-2019-18656": {"epss_score": 5e-05, "epss_percentile": 0.00206}, "CVE-2019-18657": {"epss_score": 0.00422, "epss_percentile": 0.61562}, "CVE-2019-18658": {"epss_score": 0.0057, "epss_percentile": 0.6795}, "CVE-2019-18659": {"epss_score": 0.00463, "epss_percentile": 0.63675}, "CVE-2019-18660": {"epss_score": 0.00027, "epss_percentile": 0.07154}, "CVE-2019-18661": {"epss_score": 0.00245, "epss_percentile": 0.47629}, "CVE-2019-18662": {"epss_score": 0.00178, "epss_percentile": 0.39646}, "CVE-2019-18663": {"epss_score": 0.01748, "epss_percentile": 0.8208}, "CVE-2019-18664": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-18665": {"epss_score": 0.57162, "epss_percentile": 0.98051}, "CVE-2019-18666": {"epss_score": 0.03522, "epss_percentile": 0.8729}, "CVE-2019-18667": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-18668": {"epss_score": 0.00159, "epss_percentile": 0.37406}, "CVE-2019-18670": {"epss_score": 0.00119, "epss_percentile": 0.31565}, "CVE-2019-18671": {"epss_score": 0.05931, "epss_percentile": 0.90338}, "CVE-2019-18672": {"epss_score": 0.00477, "epss_percentile": 0.64305}, "CVE-2019-18673": {"epss_score": 0.00138, "epss_percentile": 0.3443}, "CVE-2019-18674": {"epss_score": 8e-05, "epss_percentile": 0.0054}, "CVE-2019-18675": {"epss_score": 0.0013, "epss_percentile": 0.33269}, "CVE-2019-18676": {"epss_score": 0.01373, "epss_percentile": 0.7982}, "CVE-2019-18677": {"epss_score": 0.04214, "epss_percentile": 0.88405}, "CVE-2019-18678": {"epss_score": 0.09955, "epss_percentile": 0.92789}, "CVE-2019-18679": {"epss_score": 0.38425, "epss_percentile": 0.971}, "CVE-2019-18680": {"epss_score": 0.01696, "epss_percentile": 0.81808}, "CVE-2019-18683": {"epss_score": 0.01055, "epss_percentile": 0.77119}, "CVE-2019-18684": {"epss_score": 0.00103, "epss_percentile": 0.29085}, "CVE-2019-18780": {"epss_score": 0.06403, "epss_percentile": 0.9073}, "CVE-2019-18781": {"epss_score": 0.00409, "epss_percentile": 0.60755}, "CVE-2019-18782": {"epss_score": 0.00206, "epss_percentile": 0.43053}, "CVE-2019-18784": {"epss_score": 0.00343, "epss_percentile": 0.56455}, "CVE-2019-18785": {"epss_score": 0.0024, "epss_percentile": 0.47203}, "CVE-2019-18786": {"epss_score": 0.00107, "epss_percentile": 0.29737}, "CVE-2019-18790": {"epss_score": 0.07418, "epss_percentile": 0.91462}, "CVE-2019-18791": {"epss_score": 0.00298, "epss_percentile": 0.52816}, "CVE-2019-18792": {"epss_score": 0.00183, "epss_percentile": 0.40318}, "CVE-2019-18793": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-18794": {"epss_score": 0.00374, "epss_percentile": 0.58589}, "CVE-2019-18795": {"epss_score": 0.00319, "epss_percentile": 0.54544}, "CVE-2019-18796": {"epss_score": 0.00299, "epss_percentile": 0.52857}, "CVE-2019-18797": {"epss_score": 0.00608, "epss_percentile": 0.69072}, "CVE-2019-18798": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2019-18799": {"epss_score": 0.00434, "epss_percentile": 0.62314}, "CVE-2019-18800": {"epss_score": 0.00234, "epss_percentile": 0.46168}, "CVE-2019-18801": {"epss_score": 0.00044, "epss_percentile": 0.13615}, "CVE-2019-18802": {"epss_score": 0.00023, "epss_percentile": 0.05382}, "CVE-2019-18804": {"epss_score": 0.04581, "epss_percentile": 0.88878}, "CVE-2019-18805": {"epss_score": 0.0057, "epss_percentile": 0.67961}, "CVE-2019-18806": {"epss_score": 0.00107, "epss_percentile": 0.29663}, "CVE-2019-18807": {"epss_score": 0.01186, "epss_percentile": 0.78346}, "CVE-2019-18808": {"epss_score": 0.00016, "epss_percentile": 0.02923}, "CVE-2019-18809": {"epss_score": 0.00089, "epss_percentile": 0.25958}, "CVE-2019-18810": {"epss_score": 0.00746, "epss_percentile": 0.72542}, "CVE-2019-18811": {"epss_score": 0.00125, "epss_percentile": 0.32606}, "CVE-2019-18812": {"epss_score": 0.00554, "epss_percentile": 0.67439}, "CVE-2019-18813": {"epss_score": 0.01479, "epss_percentile": 0.80558}, "CVE-2019-18814": {"epss_score": 0.00504, "epss_percentile": 0.65522}, "CVE-2019-18815": {"epss_score": 0.00285, "epss_percentile": 0.51641}, "CVE-2019-18816": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-18817": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2019-18818": {"epss_score": 0.94045, "epss_percentile": 0.99892}, "CVE-2019-18819": {"epss_score": 0.00131, "epss_percentile": 0.33395}, "CVE-2019-18820": {"epss_score": 0.00131, "epss_percentile": 0.33395}, "CVE-2019-18821": {"epss_score": 0.00131, "epss_percentile": 0.33395}, "CVE-2019-18822": {"epss_score": 0.0032, "epss_percentile": 0.54618}, "CVE-2019-18823": {"epss_score": 0.02816, "epss_percentile": 0.85732}, "CVE-2019-18824": {"epss_score": 0.00073, "epss_percentile": 0.22675}, "CVE-2019-18825": {"epss_score": 0.00189, "epss_percentile": 0.40947}, "CVE-2019-18826": {"epss_score": 0.00226, "epss_percentile": 0.45268}, "CVE-2019-18827": {"epss_score": 0.00626, "epss_percentile": 0.69608}, "CVE-2019-18828": {"epss_score": 0.00098, "epss_percentile": 0.27804}, "CVE-2019-18829": {"epss_score": 0.0008, "epss_percentile": 0.24036}, "CVE-2019-18830": {"epss_score": 0.03348, "epss_percentile": 0.86955}, "CVE-2019-18831": {"epss_score": 0.00232, "epss_percentile": 0.45891}, "CVE-2019-18832": {"epss_score": 0.0013, "epss_percentile": 0.33302}, "CVE-2019-18833": {"epss_score": 0.00085, "epss_percentile": 0.25182}, "CVE-2019-18834": {"epss_score": 0.00461, "epss_percentile": 0.63569}, "CVE-2019-18835": {"epss_score": 0.00163, "epss_percentile": 0.37806}, "CVE-2019-18836": {"epss_score": 0.00155, "epss_percentile": 0.36805}, "CVE-2019-18837": {"epss_score": 0.00561, "epss_percentile": 0.67657}, "CVE-2019-18838": {"epss_score": 0.00099, "epss_percentile": 0.28388}, "CVE-2019-18839": {"epss_score": 0.01908, "epss_percentile": 0.82818}, "CVE-2019-18840": {"epss_score": 0.00411, "epss_percentile": 0.60871}, "CVE-2019-18841": {"epss_score": 0.00621, "epss_percentile": 0.69479}, "CVE-2019-18842": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-18844": {"epss_score": 0.00537, "epss_percentile": 0.66924}, "CVE-2019-18845": {"epss_score": 0.00087, "epss_percentile": 0.25618}, "CVE-2019-18846": {"epss_score": 0.00209, "epss_percentile": 0.43423}, "CVE-2019-18847": {"epss_score": 0.02612, "epss_percentile": 0.85238}, "CVE-2019-18848": {"epss_score": 0.00484, "epss_percentile": 0.64641}, "CVE-2019-18849": {"epss_score": 0.01023, "epss_percentile": 0.76764}, "CVE-2019-18850": {"epss_score": 0.00364, "epss_percentile": 0.57948}, "CVE-2019-18852": {"epss_score": 0.00817, "epss_percentile": 0.73841}, "CVE-2019-18853": {"epss_score": 0.00567, "epss_percentile": 0.67861}, "CVE-2019-18854": {"epss_score": 0.00629, "epss_percentile": 0.69686}, "CVE-2019-18855": {"epss_score": 0.00629, "epss_percentile": 0.69686}, "CVE-2019-18856": {"epss_score": 0.00384, "epss_percentile": 0.5913}, "CVE-2019-18857": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2019-18858": {"epss_score": 0.00522, "epss_percentile": 0.66255}, "CVE-2019-18859": {"epss_score": 0.00737, "epss_percentile": 0.72323}, "CVE-2019-18860": {"epss_score": 0.03435, "epss_percentile": 0.87132}, "CVE-2019-18862": {"epss_score": 0.00724, "epss_percentile": 0.72041}, "CVE-2019-18863": {"epss_score": 0.00111, "epss_percentile": 0.30395}, "CVE-2019-18864": {"epss_score": 0.00782, "epss_percentile": 0.73209}, "CVE-2019-18865": {"epss_score": 0.00428, "epss_percentile": 0.61921}, "CVE-2019-18866": {"epss_score": 0.00397, "epss_percentile": 0.60034}, "CVE-2019-18867": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-18868": {"epss_score": 0.00896, "epss_percentile": 0.75119}, "CVE-2019-18869": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-18870": {"epss_score": 0.00727, "epss_percentile": 0.72096}, "CVE-2019-18871": {"epss_score": 0.03435, "epss_percentile": 0.8713}, "CVE-2019-18872": {"epss_score": 0.00206, "epss_percentile": 0.42918}, "CVE-2019-18873": {"epss_score": 0.03424, "epss_percentile": 0.8711}, "CVE-2019-18874": {"epss_score": 0.00112, "epss_percentile": 0.30575}, "CVE-2019-18881": {"epss_score": 0.00424, "epss_percentile": 0.61673}, "CVE-2019-18882": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2019-18883": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-18884": {"epss_score": 0.00182, "epss_percentile": 0.40246}, "CVE-2019-18885": {"epss_score": 0.0073, "epss_percentile": 0.72155}, "CVE-2019-18886": {"epss_score": 0.01546, "epss_percentile": 0.80969}, "CVE-2019-18887": {"epss_score": 0.00813, "epss_percentile": 0.73755}, "CVE-2019-18888": {"epss_score": 0.02738, "epss_percentile": 0.85553}, "CVE-2019-18889": {"epss_score": 0.02554, "epss_percentile": 0.85086}, "CVE-2019-18890": {"epss_score": 0.28949, "epss_percentile": 0.96404}, "CVE-2019-18893": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2019-18894": {"epss_score": 0.00338, "epss_percentile": 0.56124}, "CVE-2019-18895": {"epss_score": 0.00129, "epss_percentile": 0.33078}, "CVE-2019-18897": {"epss_score": 0.00095, "epss_percentile": 0.27094}, "CVE-2019-18898": {"epss_score": 0.00148, "epss_percentile": 0.35926}, "CVE-2019-18899": {"epss_score": 0.0012, "epss_percentile": 0.31716}, "CVE-2019-18900": {"epss_score": 0.00098, "epss_percentile": 0.27694}, "CVE-2019-18901": {"epss_score": 0.00102, "epss_percentile": 0.2872}, "CVE-2019-18902": {"epss_score": 0.02819, "epss_percentile": 0.85742}, "CVE-2019-18903": {"epss_score": 0.02819, "epss_percentile": 0.85742}, "CVE-2019-18904": {"epss_score": 0.00933, "epss_percentile": 0.7564}, "CVE-2019-18905": {"epss_score": 0.00107, "epss_percentile": 0.29603}, "CVE-2019-18906": {"epss_score": 0.00328, "epss_percentile": 0.55265}, "CVE-2019-18909": {"epss_score": 0.00187, "epss_percentile": 0.40798}, "CVE-2019-18910": {"epss_score": 0.01024, "epss_percentile": 0.76783}, "CVE-2019-18912": {"epss_score": 0.00064, "epss_percentile": 0.2016}, "CVE-2019-18913": {"epss_score": 0.00081, "epss_percentile": 0.24303}, "CVE-2019-18914": {"epss_score": 0.003, "epss_percentile": 0.52944}, "CVE-2019-18915": {"epss_score": 0.00427, "epss_percentile": 0.61903}, "CVE-2019-18916": {"epss_score": 0.00051, "epss_percentile": 0.16021}, "CVE-2019-18917": {"epss_score": 0.01024, "epss_percentile": 0.76781}, "CVE-2019-18922": {"epss_score": 0.83925, "epss_percentile": 0.99265}, "CVE-2019-18923": {"epss_score": 0.00447, "epss_percentile": 0.62986}, "CVE-2019-18924": {"epss_score": 0.00237, "epss_percentile": 0.46731}, "CVE-2019-18925": {"epss_score": 0.00339, "epss_percentile": 0.56163}, "CVE-2019-18926": {"epss_score": 0.00618, "epss_percentile": 0.69373}, "CVE-2019-18928": {"epss_score": 0.005, "epss_percentile": 0.65293}, "CVE-2019-18929": {"epss_score": 0.00782, "epss_percentile": 0.73212}, "CVE-2019-18930": {"epss_score": 0.00782, "epss_percentile": 0.73212}, "CVE-2019-18931": {"epss_score": 0.00398, "epss_percentile": 0.60053}, "CVE-2019-18932": {"epss_score": 0.0004, "epss_percentile": 0.12026}, "CVE-2019-18933": {"epss_score": 0.00431, "epss_percentile": 0.62063}, "CVE-2019-18934": {"epss_score": 0.01234, "epss_percentile": 0.78756}, "CVE-2019-18935": {"epss_score": 0.935, "epss_percentile": 0.99812}, "CVE-2019-18936": {"epss_score": 0.00436, "epss_percentile": 0.62451}, "CVE-2019-18937": {"epss_score": 0.30108, "epss_percentile": 0.96512}, "CVE-2019-18938": {"epss_score": 0.30108, "epss_percentile": 0.96512}, "CVE-2019-18939": {"epss_score": 0.37144, "epss_percentile": 0.97022}, "CVE-2019-18942": {"epss_score": 0.00071, "epss_percentile": 0.22231}, "CVE-2019-18943": {"epss_score": 0.00153, "epss_percentile": 0.36573}, "CVE-2019-18944": {"epss_score": 0.00076, "epss_percentile": 0.23076}, "CVE-2019-18945": {"epss_score": 0.00155, "epss_percentile": 0.36797}, "CVE-2019-18946": {"epss_score": 0.00054, "epss_percentile": 0.17214}, "CVE-2019-18947": {"epss_score": 0.00065, "epss_percentile": 0.20598}, "CVE-2019-18948": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2019-18949": {"epss_score": 0.00323, "epss_percentile": 0.54918}, "CVE-2019-18951": {"epss_score": 0.63603, "epss_percentile": 0.9834}, "CVE-2019-18952": {"epss_score": 0.79908, "epss_percentile": 0.99062}, "CVE-2019-18954": {"epss_score": 0.00429, "epss_percentile": 0.61986}, "CVE-2019-18955": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-18956": {"epss_score": 0.15683, "epss_percentile": 0.94484}, "CVE-2019-18957": {"epss_score": 0.0764, "epss_percentile": 0.91594}, "CVE-2019-18958": {"epss_score": 5e-05, "epss_percentile": 0.00215}, "CVE-2019-18960": {"epss_score": 0.02085, "epss_percentile": 0.83548}, "CVE-2019-18976": {"epss_score": 0.00166, "epss_percentile": 0.38172}, "CVE-2019-18978": {"epss_score": 0.01017, "epss_percentile": 0.76693}, "CVE-2019-18979": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-18980": {"epss_score": 0.00112, "epss_percentile": 0.3057}, "CVE-2019-18981": {"epss_score": 9e-05, "epss_percentile": 0.00605}, "CVE-2019-18982": {"epss_score": 7e-05, "epss_percentile": 0.00337}, "CVE-2019-18985": {"epss_score": 7e-05, "epss_percentile": 0.00441}, "CVE-2019-18986": {"epss_score": 8e-05, "epss_percentile": 0.00523}, "CVE-2019-18987": {"epss_score": 0.00424, "epss_percentile": 0.6167}, "CVE-2019-18988": {"epss_score": 0.1041, "epss_percentile": 0.92978}, "CVE-2019-18989": {"epss_score": 0.00041, "epss_percentile": 0.1243}, "CVE-2019-18990": {"epss_score": 0.00041, "epss_percentile": 0.1243}, "CVE-2019-18991": {"epss_score": 0.00036, "epss_percentile": 0.10451}, "CVE-2019-18992": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-18993": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-18994": {"epss_score": 0.00205, "epss_percentile": 0.42745}, "CVE-2019-18995": {"epss_score": 0.00694, "epss_percentile": 0.71362}, "CVE-2019-18996": {"epss_score": 0.00107, "epss_percentile": 0.29656}, "CVE-2019-18997": {"epss_score": 0.00275, "epss_percentile": 0.50641}, "CVE-2019-18998": {"epss_score": 0.0013, "epss_percentile": 0.3325}, "CVE-2019-19000": {"epss_score": 0.00211, "epss_percentile": 0.43619}, "CVE-2019-19001": {"epss_score": 0.00379, "epss_percentile": 0.58858}, "CVE-2019-19002": {"epss_score": 0.00277, "epss_percentile": 0.50838}, "CVE-2019-19003": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2019-19004": {"epss_score": 0.00064, "epss_percentile": 0.20323}, "CVE-2019-19005": {"epss_score": 0.00117, "epss_percentile": 0.31353}, "CVE-2019-19006": {"epss_score": 0.02141, "epss_percentile": 0.83749}, "CVE-2019-19007": {"epss_score": 0.00464, "epss_percentile": 0.63722}, "CVE-2019-19010": {"epss_score": 0.00541, "epss_percentile": 0.6704}, "CVE-2019-19011": {"epss_score": 0.00498, "epss_percentile": 0.65244}, "CVE-2019-19012": {"epss_score": 0.14783, "epss_percentile": 0.94283}, "CVE-2019-19013": {"epss_score": 0.00178, "epss_percentile": 0.39683}, "CVE-2019-19014": {"epss_score": 0.00134, "epss_percentile": 0.33795}, "CVE-2019-19015": {"epss_score": 0.01111, "epss_percentile": 0.7767}, "CVE-2019-19016": {"epss_score": 0.00417, "epss_percentile": 0.61255}, "CVE-2019-19017": {"epss_score": 0.00413, "epss_percentile": 0.60994}, "CVE-2019-19018": {"epss_score": 0.00356, "epss_percentile": 0.57345}, "CVE-2019-19019": {"epss_score": 0.00761, "epss_percentile": 0.72825}, "CVE-2019-19020": {"epss_score": 0.01021, "epss_percentile": 0.76748}, "CVE-2019-19021": {"epss_score": 0.00436, "epss_percentile": 0.62384}, "CVE-2019-19022": {"epss_score": 0.00528, "epss_percentile": 0.66571}, "CVE-2019-19023": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2019-19025": {"epss_score": 0.00188, "epss_percentile": 0.40836}, "CVE-2019-19026": {"epss_score": 0.00336, "epss_percentile": 0.55917}, "CVE-2019-19029": {"epss_score": 0.00404, "epss_percentile": 0.60434}, "CVE-2019-19030": {"epss_score": 0.21619, "epss_percentile": 0.95541}, "CVE-2019-19031": {"epss_score": 0.06284, "epss_percentile": 0.90641}, "CVE-2019-19032": {"epss_score": 0.05639, "epss_percentile": 0.90074}, "CVE-2019-19033": {"epss_score": 0.00908, "epss_percentile": 0.75277}, "CVE-2019-19034": {"epss_score": 0.04377, "epss_percentile": 0.88619}, "CVE-2019-19035": {"epss_score": 0.00173, "epss_percentile": 0.39132}, "CVE-2019-19036": {"epss_score": 0.01143, "epss_percentile": 0.77983}, "CVE-2019-19037": {"epss_score": 0.01076, "epss_percentile": 0.77321}, "CVE-2019-19039": {"epss_score": 0.00471, "epss_percentile": 0.63999}, "CVE-2019-19040": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-19041": {"epss_score": 0.00453, "epss_percentile": 0.63235}, "CVE-2019-19043": {"epss_score": 0.0012, "epss_percentile": 0.31798}, "CVE-2019-19044": {"epss_score": 0.00771, "epss_percentile": 0.73013}, "CVE-2019-19045": {"epss_score": 0.00049, "epss_percentile": 0.15314}, "CVE-2019-19046": {"epss_score": 0.01323, "epss_percentile": 0.79458}, "CVE-2019-19047": {"epss_score": 0.00074, "epss_percentile": 0.22848}, "CVE-2019-19048": {"epss_score": 0.00875, "epss_percentile": 0.74773}, "CVE-2019-19049": {"epss_score": 0.00466, "epss_percentile": 0.6379}, "CVE-2019-19050": {"epss_score": 0.01083, "epss_percentile": 0.77388}, "CVE-2019-19051": {"epss_score": 0.00045, "epss_percentile": 0.13965}, "CVE-2019-19052": {"epss_score": 0.01511, "epss_percentile": 0.80773}, "CVE-2019-19053": {"epss_score": 0.00504, "epss_percentile": 0.65519}, "CVE-2019-19054": {"epss_score": 0.00065, "epss_percentile": 0.20579}, "CVE-2019-19055": {"epss_score": 0.00089, "epss_percentile": 0.25936}, "CVE-2019-19056": {"epss_score": 0.00087, "epss_percentile": 0.25536}, "CVE-2019-19057": {"epss_score": 0.00078, "epss_percentile": 0.23563}, "CVE-2019-19058": {"epss_score": 0.00092, "epss_percentile": 0.2647}, "CVE-2019-19059": {"epss_score": 0.00096, "epss_percentile": 0.2727}, "CVE-2019-19060": {"epss_score": 0.00839, "epss_percentile": 0.7419}, "CVE-2019-19061": {"epss_score": 0.0111, "epss_percentile": 0.77665}, "CVE-2019-19062": {"epss_score": 0.00098, "epss_percentile": 0.27683}, "CVE-2019-19063": {"epss_score": 0.00074, "epss_percentile": 0.22723}, "CVE-2019-19064": {"epss_score": 0.00515, "epss_percentile": 0.66}, "CVE-2019-19065": {"epss_score": 0.00036, "epss_percentile": 0.10322}, "CVE-2019-19066": {"epss_score": 0.00084, "epss_percentile": 0.2485}, "CVE-2019-19067": {"epss_score": 0.00082, "epss_percentile": 0.24588}, "CVE-2019-19068": {"epss_score": 0.00092, "epss_percentile": 0.26538}, "CVE-2019-19069": {"epss_score": 0.00649, "epss_percentile": 0.70234}, "CVE-2019-19070": {"epss_score": 0.00678, "epss_percentile": 0.70972}, "CVE-2019-19071": {"epss_score": 0.01131, "epss_percentile": 0.77861}, "CVE-2019-19072": {"epss_score": 0.00055, "epss_percentile": 0.1762}, "CVE-2019-19073": {"epss_score": 0.00081, "epss_percentile": 0.2436}, "CVE-2019-19074": {"epss_score": 0.00826, "epss_percentile": 0.7397}, "CVE-2019-19075": {"epss_score": 0.00672, "epss_percentile": 0.70826}, "CVE-2019-19076": {"epss_score": 0.02333, "epss_percentile": 0.84409}, "CVE-2019-19077": {"epss_score": 0.00117, "epss_percentile": 0.31227}, "CVE-2019-19078": {"epss_score": 0.03952, "epss_percentile": 0.88001}, "CVE-2019-19079": {"epss_score": 0.01267, "epss_percentile": 0.7902}, "CVE-2019-19080": {"epss_score": 0.01243, "epss_percentile": 0.78826}, "CVE-2019-19081": {"epss_score": 0.01243, "epss_percentile": 0.78826}, "CVE-2019-19082": {"epss_score": 0.00096, "epss_percentile": 0.2727}, "CVE-2019-19083": {"epss_score": 0.00031, "epss_percentile": 0.08617}, "CVE-2019-19084": {"epss_score": 0.00575, "epss_percentile": 0.68118}, "CVE-2019-19085": {"epss_score": 0.00212, "epss_percentile": 0.43732}, "CVE-2019-19086": {"epss_score": 0.00047, "epss_percentile": 0.14478}, "CVE-2019-19087": {"epss_score": 0.00047, "epss_percentile": 0.14478}, "CVE-2019-19088": {"epss_score": 0.00102, "epss_percentile": 0.28792}, "CVE-2019-19089": {"epss_score": 0.00522, "epss_percentile": 0.66282}, "CVE-2019-19090": {"epss_score": 0.00112, "epss_percentile": 0.30426}, "CVE-2019-19091": {"epss_score": 0.00149, "epss_percentile": 0.35948}, "CVE-2019-19092": {"epss_score": 0.002, "epss_percentile": 0.42233}, "CVE-2019-19093": {"epss_score": 0.00186, "epss_percentile": 0.40659}, "CVE-2019-19094": {"epss_score": 0.0035, "epss_percentile": 0.56944}, "CVE-2019-19095": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2019-19096": {"epss_score": 0.0005, "epss_percentile": 0.15729}, "CVE-2019-19097": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2019-19100": {"epss_score": 0.0004, "epss_percentile": 0.11902}, "CVE-2019-19101": {"epss_score": 0.00101, "epss_percentile": 0.28671}, "CVE-2019-19102": {"epss_score": 0.00699, "epss_percentile": 0.71455}, "CVE-2019-19104": {"epss_score": 0.00241, "epss_percentile": 0.47254}, "CVE-2019-19105": {"epss_score": 0.00057, "epss_percentile": 0.18157}, "CVE-2019-19106": {"epss_score": 0.00313, "epss_percentile": 0.54034}, "CVE-2019-19107": {"epss_score": 0.00028, "epss_percentile": 0.07447}, "CVE-2019-19108": {"epss_score": 0.00572, "epss_percentile": 0.68035}, "CVE-2019-19109": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2019-19110": {"epss_score": 0.00186, "epss_percentile": 0.406}, "CVE-2019-19111": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-19112": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-19113": {"epss_score": 0.00642, "epss_percentile": 0.70039}, "CVE-2019-19115": {"epss_score": 0.00062, "epss_percentile": 0.19721}, "CVE-2019-19117": {"epss_score": 0.16616, "epss_percentile": 0.94703}, "CVE-2019-19118": {"epss_score": 0.00293, "epss_percentile": 0.52315}, "CVE-2019-19119": {"epss_score": 0.00127, "epss_percentile": 0.32781}, "CVE-2019-19126": {"epss_score": 0.00024, "epss_percentile": 0.05732}, "CVE-2019-19127": {"epss_score": 0.00069, "epss_percentile": 0.21526}, "CVE-2019-19129": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-19133": {"epss_score": 0.00232, "epss_percentile": 0.45966}, "CVE-2019-19134": {"epss_score": 0.07948, "epss_percentile": 0.91783}, "CVE-2019-19135": {"epss_score": 0.00264, "epss_percentile": 0.49579}, "CVE-2019-19138": {"epss_score": 0.01633, "epss_percentile": 0.8146}, "CVE-2019-19141": {"epss_score": 0.03414, "epss_percentile": 0.8709}, "CVE-2019-19142": {"epss_score": 0.14613, "epss_percentile": 0.94251}, "CVE-2019-19143": {"epss_score": 0.02168, "epss_percentile": 0.83859}, "CVE-2019-19144": {"epss_score": 0.00026, "epss_percentile": 0.06723}, "CVE-2019-19145": {"epss_score": 0.0003, "epss_percentile": 0.08214}, "CVE-2019-19148": {"epss_score": 0.08633, "epss_percentile": 0.92164}, "CVE-2019-19150": {"epss_score": 0.00299, "epss_percentile": 0.52894}, "CVE-2019-19151": {"epss_score": 0.00184, "epss_percentile": 0.40429}, "CVE-2019-19160": {"epss_score": 0.00316, "epss_percentile": 0.54288}, "CVE-2019-19161": {"epss_score": 0.00555, "epss_percentile": 0.67468}, "CVE-2019-19162": {"epss_score": 0.00528, "epss_percentile": 0.66539}, "CVE-2019-19163": {"epss_score": 0.00137, "epss_percentile": 0.34203}, "CVE-2019-19164": {"epss_score": 0.00282, "epss_percentile": 0.51225}, "CVE-2019-19165": {"epss_score": 0.00245, "epss_percentile": 0.47638}, "CVE-2019-19166": {"epss_score": 0.00069, "epss_percentile": 0.21527}, "CVE-2019-19167": {"epss_score": 0.00464, "epss_percentile": 0.63716}, "CVE-2019-19168": {"epss_score": 0.01065, "epss_percentile": 0.77208}, "CVE-2019-19169": {"epss_score": 0.01065, "epss_percentile": 0.77208}, "CVE-2019-19191": {"epss_score": 0.00172, "epss_percentile": 0.38956}, "CVE-2019-19192": {"epss_score": 0.00089, "epss_percentile": 0.25984}, "CVE-2019-19193": {"epss_score": 0.00186, "epss_percentile": 0.40685}, "CVE-2019-19194": {"epss_score": 0.00448, "epss_percentile": 0.63004}, "CVE-2019-19195": {"epss_score": 0.00186, "epss_percentile": 0.40685}, "CVE-2019-19196": {"epss_score": 0.00141, "epss_percentile": 0.34944}, "CVE-2019-19197": {"epss_score": 0.00155, "epss_percentile": 0.36833}, "CVE-2019-19198": {"epss_score": 0.00787, "epss_percentile": 0.73315}, "CVE-2019-19199": {"epss_score": 0.00303, "epss_percentile": 0.53211}, "CVE-2019-19200": {"epss_score": 0.02097, "epss_percentile": 0.8359}, "CVE-2019-19202": {"epss_score": 0.00312, "epss_percentile": 0.53967}, "CVE-2019-19203": {"epss_score": 0.00733, "epss_percentile": 0.72213}, "CVE-2019-19204": {"epss_score": 0.08946, "epss_percentile": 0.92331}, "CVE-2019-19206": {"epss_score": 0.00719, "epss_percentile": 0.7194}, "CVE-2019-19207": {"epss_score": 0.07023, "epss_percentile": 0.91193}, "CVE-2019-19208": {"epss_score": 0.39123, "epss_percentile": 0.97141}, "CVE-2019-19209": {"epss_score": 0.01557, "epss_percentile": 0.81021}, "CVE-2019-19210": {"epss_score": 0.00606, "epss_percentile": 0.69022}, "CVE-2019-19211": {"epss_score": 0.02101, "epss_percentile": 0.83605}, "CVE-2019-19212": {"epss_score": 0.01154, "epss_percentile": 0.78064}, "CVE-2019-19215": {"epss_score": 0.00675, "epss_percentile": 0.70907}, "CVE-2019-19216": {"epss_score": 0.00306, "epss_percentile": 0.53422}, "CVE-2019-19217": {"epss_score": 0.01065, "epss_percentile": 0.77207}, "CVE-2019-19218": {"epss_score": 0.00347, "epss_percentile": 0.56752}, "CVE-2019-19219": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2019-19220": {"epss_score": 0.01065, "epss_percentile": 0.77207}, "CVE-2019-19221": {"epss_score": 0.00079, "epss_percentile": 0.2395}, "CVE-2019-19222": {"epss_score": 0.00812, "epss_percentile": 0.73751}, "CVE-2019-19223": {"epss_score": 0.06157, "epss_percentile": 0.90525}, "CVE-2019-19224": {"epss_score": 0.02409, "epss_percentile": 0.84659}, "CVE-2019-19225": {"epss_score": 0.03237, "epss_percentile": 0.86706}, "CVE-2019-19226": {"epss_score": 0.03237, "epss_percentile": 0.86706}, "CVE-2019-19227": {"epss_score": 0.00083, "epss_percentile": 0.24705}, "CVE-2019-19228": {"epss_score": 0.0024, "epss_percentile": 0.47194}, "CVE-2019-19229": {"epss_score": 0.00695, "epss_percentile": 0.71369}, "CVE-2019-19230": {"epss_score": 0.05646, "epss_percentile": 0.90081}, "CVE-2019-19231": {"epss_score": 0.00168, "epss_percentile": 0.38469}, "CVE-2019-19232": {"epss_score": 0.02811, "epss_percentile": 0.8572}, "CVE-2019-19234": {"epss_score": 0.03157, "epss_percentile": 0.86517}, "CVE-2019-19235": {"epss_score": 0.00204, "epss_percentile": 0.42593}, "CVE-2019-19240": {"epss_score": 0.00533, "epss_percentile": 0.66714}, "CVE-2019-19241": {"epss_score": 0.00935, "epss_percentile": 0.75661}, "CVE-2019-19242": {"epss_score": 0.002, "epss_percentile": 0.42274}, "CVE-2019-19244": {"epss_score": 0.00256, "epss_percentile": 0.48765}, "CVE-2019-19245": {"epss_score": 0.09739, "epss_percentile": 0.92682}, "CVE-2019-19246": {"epss_score": 0.00193, "epss_percentile": 0.41442}, "CVE-2019-19247": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2019-19248": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2019-19249": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-19250": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-19251": {"epss_score": 0.00151, "epss_percentile": 0.36231}, "CVE-2019-19252": {"epss_score": 0.00144, "epss_percentile": 0.35318}, "CVE-2019-19254": {"epss_score": 0.00181, "epss_percentile": 0.40076}, "CVE-2019-19255": {"epss_score": 0.00069, "epss_percentile": 0.21506}, "CVE-2019-19256": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2019-19257": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2019-19258": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2019-19259": {"epss_score": 0.0006, "epss_percentile": 0.18981}, "CVE-2019-19260": {"epss_score": 0.00067, "epss_percentile": 0.21048}, "CVE-2019-19261": {"epss_score": 0.00108, "epss_percentile": 0.29771}, "CVE-2019-19262": {"epss_score": 0.0008, "epss_percentile": 0.24107}, "CVE-2019-19263": {"epss_score": 0.00045, "epss_percentile": 0.1395}, "CVE-2019-19264": {"epss_score": 0.00565, "epss_percentile": 0.67787}, "CVE-2019-19265": {"epss_score": 0.00279, "epss_percentile": 0.50996}, "CVE-2019-19266": {"epss_score": 0.003, "epss_percentile": 0.52956}, "CVE-2019-19269": {"epss_score": 0.0178, "epss_percentile": 0.82233}, "CVE-2019-19270": {"epss_score": 0.00198, "epss_percentile": 0.42019}, "CVE-2019-19271": {"epss_score": 0.00927, "epss_percentile": 0.75558}, "CVE-2019-19272": {"epss_score": 0.00421, "epss_percentile": 0.61532}, "CVE-2019-19273": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2019-19274": {"epss_score": 0.0136, "epss_percentile": 0.79746}, "CVE-2019-19275": {"epss_score": 0.0136, "epss_percentile": 0.79746}, "CVE-2019-19276": {"epss_score": 0.00156, "epss_percentile": 0.3695}, "CVE-2019-19277": {"epss_score": 0.00287, "epss_percentile": 0.51811}, "CVE-2019-19278": {"epss_score": 0.00082, "epss_percentile": 0.24474}, "CVE-2019-19279": {"epss_score": 0.00269, "epss_percentile": 0.5015}, "CVE-2019-19281": {"epss_score": 0.00629, "epss_percentile": 0.69682}, "CVE-2019-19282": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2019-19283": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2019-19284": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2019-19285": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2019-19286": {"epss_score": 0.00381, "epss_percentile": 0.59005}, "CVE-2019-19287": {"epss_score": 0.00173, "epss_percentile": 0.39111}, "CVE-2019-19288": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2019-19289": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2019-19290": {"epss_score": 0.00319, "epss_percentile": 0.5455}, "CVE-2019-19291": {"epss_score": 0.00172, "epss_percentile": 0.38913}, "CVE-2019-19292": {"epss_score": 0.00553, "epss_percentile": 0.67416}, "CVE-2019-19293": {"epss_score": 0.0043, "epss_percentile": 0.62005}, "CVE-2019-19294": {"epss_score": 0.00216, "epss_percentile": 0.44171}, "CVE-2019-19295": {"epss_score": 0.00277, "epss_percentile": 0.50825}, "CVE-2019-19296": {"epss_score": 0.00396, "epss_percentile": 0.59891}, "CVE-2019-19297": {"epss_score": 0.00896, "epss_percentile": 0.75115}, "CVE-2019-19298": {"epss_score": 0.00752, "epss_percentile": 0.72665}, "CVE-2019-19299": {"epss_score": 0.0046, "epss_percentile": 0.63536}, "CVE-2019-19300": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2019-19301": {"epss_score": 0.0054, "epss_percentile": 0.66997}, "CVE-2019-19306": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2019-19307": {"epss_score": 0.02961, "epss_percentile": 0.8607}, "CVE-2019-19308": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2019-19309": {"epss_score": 0.00069, "epss_percentile": 0.21506}, "CVE-2019-19310": {"epss_score": 0.00071, "epss_percentile": 0.22169}, "CVE-2019-19311": {"epss_score": 0.00192, "epss_percentile": 0.41375}, "CVE-2019-19312": {"epss_score": 0.00181, "epss_percentile": 0.40076}, "CVE-2019-19313": {"epss_score": 0.00255, "epss_percentile": 0.48674}, "CVE-2019-19314": {"epss_score": 0.0006, "epss_percentile": 0.19005}, "CVE-2019-19315": {"epss_score": 0.02211, "epss_percentile": 0.84015}, "CVE-2019-19316": {"epss_score": 0.00184, "epss_percentile": 0.40414}, "CVE-2019-19317": {"epss_score": 0.00985, "epss_percentile": 0.76322}, "CVE-2019-19318": {"epss_score": 0.00353, "epss_percentile": 0.57177}, "CVE-2019-19319": {"epss_score": 0.00436, "epss_percentile": 0.62388}, "CVE-2019-19324": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2019-19325": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2019-19326": {"epss_score": 0.00209, "epss_percentile": 0.43416}, "CVE-2019-19327": {"epss_score": 0.00632, "epss_percentile": 0.69743}, "CVE-2019-19328": {"epss_score": 0.00632, "epss_percentile": 0.69743}, "CVE-2019-19329": {"epss_score": 0.00406, "epss_percentile": 0.60533}, "CVE-2019-19330": {"epss_score": 0.00911, "epss_percentile": 0.75329}, "CVE-2019-19331": {"epss_score": 0.00312, "epss_percentile": 0.53937}, "CVE-2019-19332": {"epss_score": 0.00023, "epss_percentile": 0.05423}, "CVE-2019-19333": {"epss_score": 0.00742, "epss_percentile": 0.72459}, "CVE-2019-19334": {"epss_score": 0.00781, "epss_percentile": 0.73185}, "CVE-2019-19335": {"epss_score": 0.00095, "epss_percentile": 0.27217}, "CVE-2019-19336": {"epss_score": 0.00307, "epss_percentile": 0.53495}, "CVE-2019-19337": {"epss_score": 0.00552, "epss_percentile": 0.6738}, "CVE-2019-19338": {"epss_score": 0.00091, "epss_percentile": 0.26175}, "CVE-2019-19339": {"epss_score": 0.00117, "epss_percentile": 0.3131}, "CVE-2019-19340": {"epss_score": 0.0041, "epss_percentile": 0.60792}, "CVE-2019-19341": {"epss_score": 0.00043, "epss_percentile": 0.13135}, "CVE-2019-19342": {"epss_score": 0.00198, "epss_percentile": 0.42085}, "CVE-2019-19343": {"epss_score": 0.00507, "epss_percentile": 0.65663}, "CVE-2019-19344": {"epss_score": 0.02308, "epss_percentile": 0.84329}, "CVE-2019-19345": {"epss_score": 0.00041, "epss_percentile": 0.12413}, "CVE-2019-19346": {"epss_score": 0.00041, "epss_percentile": 0.12413}, "CVE-2019-19348": {"epss_score": 0.00041, "epss_percentile": 0.12413}, "CVE-2019-19349": {"epss_score": 0.00036, "epss_percentile": 0.10364}, "CVE-2019-19350": {"epss_score": 0.00036, "epss_percentile": 0.10364}, "CVE-2019-19351": {"epss_score": 0.0011, "epss_percentile": 0.30079}, "CVE-2019-19352": {"epss_score": 0.00036, "epss_percentile": 0.10364}, "CVE-2019-19353": {"epss_score": 0.00036, "epss_percentile": 0.10548}, "CVE-2019-19354": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2019-19355": {"epss_score": 0.0011, "epss_percentile": 0.30079}, "CVE-2019-19356": {"epss_score": 0.91088, "epss_percentile": 0.99619}, "CVE-2019-19362": {"epss_score": 0.00405, "epss_percentile": 0.6046}, "CVE-2019-19363": {"epss_score": 0.03169, "epss_percentile": 0.86546}, "CVE-2019-19364": {"epss_score": 0.00221, "epss_percentile": 0.44678}, "CVE-2019-19366": {"epss_score": 0.00429, "epss_percentile": 0.61969}, "CVE-2019-19367": {"epss_score": 0.00429, "epss_percentile": 0.61969}, "CVE-2019-19368": {"epss_score": 0.75637, "epss_percentile": 0.98859}, "CVE-2019-19370": {"epss_score": 0.00751, "epss_percentile": 0.72637}, "CVE-2019-19371": {"epss_score": 0.00325, "epss_percentile": 0.54982}, "CVE-2019-19372": {"epss_score": 0.00181, "epss_percentile": 0.40137}, "CVE-2019-19373": {"epss_score": 0.03645, "epss_percentile": 0.87498}, "CVE-2019-19374": {"epss_score": 0.00334, "epss_percentile": 0.55728}, "CVE-2019-19375": {"epss_score": 0.00167, "epss_percentile": 0.38347}, "CVE-2019-19376": {"epss_score": 0.00231, "epss_percentile": 0.4583}, "CVE-2019-19377": {"epss_score": 0.00393, "epss_percentile": 0.59712}, "CVE-2019-19378": {"epss_score": 0.00467, "epss_percentile": 0.63833}, "CVE-2019-19379": {"epss_score": 0.00227, "epss_percentile": 0.45418}, "CVE-2019-19381": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-19382": {"epss_score": 0.00077, "epss_percentile": 0.23366}, "CVE-2019-19383": {"epss_score": 0.26075, "epss_percentile": 0.96107}, "CVE-2019-19384": {"epss_score": 0.00429, "epss_percentile": 0.61969}, "CVE-2019-19385": {"epss_score": 0.00429, "epss_percentile": 0.61969}, "CVE-2019-19386": {"epss_score": 0.00429, "epss_percentile": 0.61969}, "CVE-2019-19387": {"epss_score": 0.00429, "epss_percentile": 0.61969}, "CVE-2019-19388": {"epss_score": 0.00429, "epss_percentile": 0.61969}, "CVE-2019-19389": {"epss_score": 5e-05, "epss_percentile": 0.00177}, "CVE-2019-19390": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-19391": {"epss_score": 0.00272, "epss_percentile": 0.50376}, "CVE-2019-19392": {"epss_score": 0.00681, "epss_percentile": 0.71054}, "CVE-2019-19393": {"epss_score": 0.0042, "epss_percentile": 0.61415}, "CVE-2019-19394": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2019-19396": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2019-19397": {"epss_score": 0.00187, "epss_percentile": 0.40724}, "CVE-2019-19398": {"epss_score": 0.00375, "epss_percentile": 0.58594}, "CVE-2019-19411": {"epss_score": 0.02952, "epss_percentile": 0.86056}, "CVE-2019-19412": {"epss_score": 0.00027, "epss_percentile": 0.07001}, "CVE-2019-19413": {"epss_score": 0.00327, "epss_percentile": 0.55144}, "CVE-2019-19414": {"epss_score": 0.00327, "epss_percentile": 0.55144}, "CVE-2019-19415": {"epss_score": 0.00358, "epss_percentile": 0.57516}, "CVE-2019-19416": {"epss_score": 0.00358, "epss_percentile": 0.57516}, "CVE-2019-19417": {"epss_score": 0.00358, "epss_percentile": 0.57516}, "CVE-2019-19441": {"epss_score": 0.00085, "epss_percentile": 0.25053}, "CVE-2019-19447": {"epss_score": 0.01689, "epss_percentile": 0.81769}, "CVE-2019-19448": {"epss_score": 0.00777, "epss_percentile": 0.7312}, "CVE-2019-19449": {"epss_score": 0.0035, "epss_percentile": 0.56922}, "CVE-2019-19450": {"epss_score": 0.06404, "epss_percentile": 0.9073}, "CVE-2019-19451": {"epss_score": 0.00153, "epss_percentile": 0.36535}, "CVE-2019-19452": {"epss_score": 0.00133, "epss_percentile": 0.33671}, "CVE-2019-19453": {"epss_score": 0.00435, "epss_percentile": 0.62378}, "CVE-2019-19454": {"epss_score": 0.00734, "epss_percentile": 0.72251}, "CVE-2019-19455": {"epss_score": 0.00027, "epss_percentile": 0.06752}, "CVE-2019-19456": {"epss_score": 0.00264, "epss_percentile": 0.4971}, "CVE-2019-19457": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-19458": {"epss_score": 0.00877, "epss_percentile": 0.74802}, "CVE-2019-19459": {"epss_score": 0.01838, "epss_percentile": 0.82486}, "CVE-2019-19460": {"epss_score": 0.00086, "epss_percentile": 0.25337}, "CVE-2019-19461": {"epss_score": 0.00252, "epss_percentile": 0.48405}, "CVE-2019-19462": {"epss_score": 0.0011, "epss_percentile": 0.30229}, "CVE-2019-19463": {"epss_score": 0.00161, "epss_percentile": 0.3753}, "CVE-2019-19464": {"epss_score": 0.00166, "epss_percentile": 0.38241}, "CVE-2019-19466": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2019-19468": {"epss_score": 0.01778, "epss_percentile": 0.82225}, "CVE-2019-19469": {"epss_score": 0.0025, "epss_percentile": 0.48128}, "CVE-2019-19470": {"epss_score": 0.00837, "epss_percentile": 0.7416}, "CVE-2019-19475": {"epss_score": 0.00248, "epss_percentile": 0.4798}, "CVE-2019-19479": {"epss_score": 0.00045, "epss_percentile": 0.13933}, "CVE-2019-19480": {"epss_score": 0.00199, "epss_percentile": 0.42134}, "CVE-2019-19481": {"epss_score": 0.00123, "epss_percentile": 0.32226}, "CVE-2019-19484": {"epss_score": 0.00063, "epss_percentile": 0.19966}, "CVE-2019-19486": {"epss_score": 0.00167, "epss_percentile": 0.3834}, "CVE-2019-19487": {"epss_score": 0.01566, "epss_percentile": 0.81066}, "CVE-2019-19489": {"epss_score": 0.00323, "epss_percentile": 0.54914}, "CVE-2019-19490": {"epss_score": 0.00086, "epss_percentile": 0.25279}, "CVE-2019-19491": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-19492": {"epss_score": 0.78221, "epss_percentile": 0.98974}, "CVE-2019-19493": {"epss_score": 0.00657, "epss_percentile": 0.70455}, "CVE-2019-19494": {"epss_score": 0.7082, "epss_percentile": 0.98643}, "CVE-2019-19495": {"epss_score": 0.0695, "epss_percentile": 0.91138}, "CVE-2019-19496": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-19497": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-19499": {"epss_score": 0.37437, "epss_percentile": 0.97047}, "CVE-2019-19500": {"epss_score": 0.00305, "epss_percentile": 0.53318}, "CVE-2019-19501": {"epss_score": 0.00485, "epss_percentile": 0.64737}, "CVE-2019-19502": {"epss_score": 0.00853, "epss_percentile": 0.7443}, "CVE-2019-19505": {"epss_score": 0.04409, "epss_percentile": 0.88655}, "CVE-2019-19506": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2019-19507": {"epss_score": 0.00249, "epss_percentile": 0.48086}, "CVE-2019-19509": {"epss_score": 0.91605, "epss_percentile": 0.99657}, "CVE-2019-19513": {"epss_score": 0.0198, "epss_percentile": 0.83136}, "CVE-2019-19514": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-19515": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-19516": {"epss_score": 0.00786, "epss_percentile": 0.73266}, "CVE-2019-19517": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-19518": {"epss_score": 0.01287, "epss_percentile": 0.79191}, "CVE-2019-19519": {"epss_score": 0.00099, "epss_percentile": 0.28314}, "CVE-2019-19520": {"epss_score": 0.02229, "epss_percentile": 0.8408}, "CVE-2019-19521": {"epss_score": 0.00539, "epss_percentile": 0.66982}, "CVE-2019-19522": {"epss_score": 0.00198, "epss_percentile": 0.42082}, "CVE-2019-19523": {"epss_score": 0.00082, "epss_percentile": 0.24443}, "CVE-2019-19524": {"epss_score": 0.0005, "epss_percentile": 0.15673}, "CVE-2019-19525": {"epss_score": 0.00072, "epss_percentile": 0.22375}, "CVE-2019-19526": {"epss_score": 0.00046, "epss_percentile": 0.14139}, "CVE-2019-19527": {"epss_score": 0.00096, "epss_percentile": 0.27398}, "CVE-2019-19528": {"epss_score": 0.00076, "epss_percentile": 0.23157}, "CVE-2019-19529": {"epss_score": 0.00044, "epss_percentile": 0.13628}, "CVE-2019-19530": {"epss_score": 0.00042, "epss_percentile": 0.12632}, "CVE-2019-19531": {"epss_score": 0.00098, "epss_percentile": 0.27666}, "CVE-2019-19532": {"epss_score": 0.00103, "epss_percentile": 0.28996}, "CVE-2019-19533": {"epss_score": 0.00036, "epss_percentile": 0.10548}, "CVE-2019-19534": {"epss_score": 0.00071, "epss_percentile": 0.22012}, "CVE-2019-19535": {"epss_score": 0.00033, "epss_percentile": 0.09416}, "CVE-2019-19536": {"epss_score": 0.0008, "epss_percentile": 0.24169}, "CVE-2019-19537": {"epss_score": 0.00068, "epss_percentile": 0.21295}, "CVE-2019-19538": {"epss_score": 0.0153, "epss_percentile": 0.80884}, "CVE-2019-19539": {"epss_score": 0.00063, "epss_percentile": 0.20079}, "CVE-2019-19540": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-19541": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2019-19542": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2019-19543": {"epss_score": 0.00102, "epss_percentile": 0.28775}, "CVE-2019-19544": {"epss_score": 0.00148, "epss_percentile": 0.35883}, "CVE-2019-19545": {"epss_score": 0.00141, "epss_percentile": 0.34863}, "CVE-2019-19546": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2019-19547": {"epss_score": 0.01072, "epss_percentile": 0.77281}, "CVE-2019-19548": {"epss_score": 0.00072, "epss_percentile": 0.22272}, "CVE-2019-19550": {"epss_score": 0.00536, "epss_percentile": 0.66859}, "CVE-2019-19551": {"epss_score": 0.00351, "epss_percentile": 0.57077}, "CVE-2019-19552": {"epss_score": 0.00412, "epss_percentile": 0.60936}, "CVE-2019-19553": {"epss_score": 0.00656, "epss_percentile": 0.70438}, "CVE-2019-19555": {"epss_score": 0.00095, "epss_percentile": 0.27142}, "CVE-2019-19556": {"epss_score": 0.00076, "epss_percentile": 0.2315}, "CVE-2019-19557": {"epss_score": 0.00058, "epss_percentile": 0.18393}, "CVE-2019-19560": {"epss_score": 0.0007, "epss_percentile": 0.21723}, "CVE-2019-19561": {"epss_score": 0.00058, "epss_percentile": 0.18393}, "CVE-2019-19562": {"epss_score": 0.0007, "epss_percentile": 0.21723}, "CVE-2019-19563": {"epss_score": 0.00058, "epss_percentile": 0.18393}, "CVE-2019-19576": {"epss_score": 0.44137, "epss_percentile": 0.9742}, "CVE-2019-19577": {"epss_score": 0.00123, "epss_percentile": 0.32225}, "CVE-2019-19578": {"epss_score": 0.00131, "epss_percentile": 0.33401}, "CVE-2019-19579": {"epss_score": 0.0013, "epss_percentile": 0.33223}, "CVE-2019-19580": {"epss_score": 0.00655, "epss_percentile": 0.70425}, "CVE-2019-19581": {"epss_score": 0.00104, "epss_percentile": 0.291}, "CVE-2019-19582": {"epss_score": 0.00108, "epss_percentile": 0.29813}, "CVE-2019-19583": {"epss_score": 0.02069, "epss_percentile": 0.8347}, "CVE-2019-19585": {"epss_score": 0.00098, "epss_percentile": 0.27636}, "CVE-2019-19587": {"epss_score": 0.0028, "epss_percentile": 0.51001}, "CVE-2019-19588": {"epss_score": 0.00446, "epss_percentile": 0.629}, "CVE-2019-19589": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-19590": {"epss_score": 0.03052, "epss_percentile": 0.86293}, "CVE-2019-19592": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-19594": {"epss_score": 0.05556, "epss_percentile": 0.89991}, "CVE-2019-19595": {"epss_score": 0.05556, "epss_percentile": 0.89991}, "CVE-2019-19596": {"epss_score": 0.0027, "epss_percentile": 0.50213}, "CVE-2019-19597": {"epss_score": 0.08432, "epss_percentile": 0.92048}, "CVE-2019-19598": {"epss_score": 0.00374, "epss_percentile": 0.58535}, "CVE-2019-19601": {"epss_score": 0.00437, "epss_percentile": 0.62514}, "CVE-2019-19602": {"epss_score": 0.00034, "epss_percentile": 0.0969}, "CVE-2019-19603": {"epss_score": 0.01647, "epss_percentile": 0.81542}, "CVE-2019-19604": {"epss_score": 0.01339, "epss_percentile": 0.79573}, "CVE-2019-19605": {"epss_score": 0.00399, "epss_percentile": 0.60096}, "CVE-2019-19606": {"epss_score": 0.00453, "epss_percentile": 0.63223}, "CVE-2019-19607": {"epss_score": 0.00937, "epss_percentile": 0.75693}, "CVE-2019-19608": {"epss_score": 0.00937, "epss_percentile": 0.75693}, "CVE-2019-19609": {"epss_score": 0.816, "epss_percentile": 0.99146}, "CVE-2019-19610": {"epss_score": 0.0034, "epss_percentile": 0.56246}, "CVE-2019-19611": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2019-19612": {"epss_score": 0.00504, "epss_percentile": 0.65528}, "CVE-2019-19613": {"epss_score": 0.002, "epss_percentile": 0.42263}, "CVE-2019-19614": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2019-19615": {"epss_score": 0.00306, "epss_percentile": 0.53425}, "CVE-2019-19616": {"epss_score": 0.00217, "epss_percentile": 0.44285}, "CVE-2019-19617": {"epss_score": 0.01155, "epss_percentile": 0.78076}, "CVE-2019-19619": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2019-19620": {"epss_score": 0.00031, "epss_percentile": 0.0855}, "CVE-2019-19624": {"epss_score": 0.0023, "epss_percentile": 0.45678}, "CVE-2019-19625": {"epss_score": 0.00366, "epss_percentile": 0.58015}, "CVE-2019-19627": {"epss_score": 0.00485, "epss_percentile": 0.64732}, "CVE-2019-19628": {"epss_score": 0.02119, "epss_percentile": 0.83672}, "CVE-2019-19629": {"epss_score": 0.00088, "epss_percentile": 0.25776}, "CVE-2019-19630": {"epss_score": 0.00538, "epss_percentile": 0.6693}, "CVE-2019-19631": {"epss_score": 0.00949, "epss_percentile": 0.75849}, "CVE-2019-19632": {"epss_score": 0.01437, "epss_percentile": 0.8028}, "CVE-2019-19634": {"epss_score": 0.15025, "epss_percentile": 0.94347}, "CVE-2019-19635": {"epss_score": 0.00541, "epss_percentile": 0.67041}, "CVE-2019-19636": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-19637": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-19638": {"epss_score": 0.00541, "epss_percentile": 0.67041}, "CVE-2019-19642": {"epss_score": 0.25951, "epss_percentile": 0.96096}, "CVE-2019-19643": {"epss_score": 0.00398, "epss_percentile": 0.60081}, "CVE-2019-19645": {"epss_score": 0.00295, "epss_percentile": 0.52527}, "CVE-2019-19646": {"epss_score": 0.07192, "epss_percentile": 0.91311}, "CVE-2019-19647": {"epss_score": 0.0049, "epss_percentile": 0.64941}, "CVE-2019-19648": {"epss_score": 0.0056, "epss_percentile": 0.67645}, "CVE-2019-19649": {"epss_score": 0.61057, "epss_percentile": 0.98233}, "CVE-2019-19650": {"epss_score": 0.07394, "epss_percentile": 0.9145}, "CVE-2019-19659": {"epss_score": 0.00177, "epss_percentile": 0.39555}, "CVE-2019-19660": {"epss_score": 0.00161, "epss_percentile": 0.37599}, "CVE-2019-19661": {"epss_score": 0.00174, "epss_percentile": 0.39195}, "CVE-2019-19662": {"epss_score": 0.00161, "epss_percentile": 0.37599}, "CVE-2019-19663": {"epss_score": 0.00161, "epss_percentile": 0.37599}, "CVE-2019-19664": {"epss_score": 0.00169, "epss_percentile": 0.38553}, "CVE-2019-19665": {"epss_score": 0.00161, "epss_percentile": 0.37599}, "CVE-2019-19666": {"epss_score": 0.00161, "epss_percentile": 0.37599}, "CVE-2019-19667": {"epss_score": 0.00164, "epss_percentile": 0.37993}, "CVE-2019-19668": {"epss_score": 0.00161, "epss_percentile": 0.37599}, "CVE-2019-19669": {"epss_score": 0.00161, "epss_percentile": 0.37599}, "CVE-2019-19670": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-19675": {"epss_score": 0.00082, "epss_percentile": 0.24552}, "CVE-2019-19676": {"epss_score": 0.00443, "epss_percentile": 0.62804}, "CVE-2019-19677": {"epss_score": 0.00305, "epss_percentile": 0.53379}, "CVE-2019-19678": {"epss_score": 0.00246, "epss_percentile": 0.47773}, "CVE-2019-19679": {"epss_score": 0.00246, "epss_percentile": 0.47773}, "CVE-2019-19680": {"epss_score": 0.00353, "epss_percentile": 0.57177}, "CVE-2019-19681": {"epss_score": 0.01761, "epss_percentile": 0.82149}, "CVE-2019-19682": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-19683": {"epss_score": 0.00619, "epss_percentile": 0.69436}, "CVE-2019-19684": {"epss_score": 0.00394, "epss_percentile": 0.59782}, "CVE-2019-19685": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-19687": {"epss_score": 0.00766, "epss_percentile": 0.72946}, "CVE-2019-19688": {"epss_score": 0.00194, "epss_percentile": 0.41544}, "CVE-2019-19689": {"epss_score": 0.00202, "epss_percentile": 0.42395}, "CVE-2019-19690": {"epss_score": 0.00218, "epss_percentile": 0.44416}, "CVE-2019-19691": {"epss_score": 0.00533, "epss_percentile": 0.66752}, "CVE-2019-19692": {"epss_score": 0.00562, "epss_percentile": 0.67708}, "CVE-2019-19693": {"epss_score": 0.00175, "epss_percentile": 0.39346}, "CVE-2019-19694": {"epss_score": 0.00265, "epss_percentile": 0.4979}, "CVE-2019-19695": {"epss_score": 0.00379, "epss_percentile": 0.58862}, "CVE-2019-19696": {"epss_score": 0.00134, "epss_percentile": 0.33763}, "CVE-2019-19697": {"epss_score": 0.00293, "epss_percentile": 0.5232}, "CVE-2019-19698": {"epss_score": 0.00435, "epss_percentile": 0.62332}, "CVE-2019-19699": {"epss_score": 0.08905, "epss_percentile": 0.92309}, "CVE-2019-19702": {"epss_score": 0.00823, "epss_percentile": 0.73924}, "CVE-2019-19703": {"epss_score": 4e-05, "epss_percentile": 0.00129}, "CVE-2019-19704": {"epss_score": 3e-05, "epss_percentile": 0.00092}, "CVE-2019-19705": {"epss_score": 0.00134, "epss_percentile": 0.33775}, "CVE-2019-19707": {"epss_score": 0.00555, "epss_percentile": 0.67488}, "CVE-2019-19708": {"epss_score": 0.00366, "epss_percentile": 0.58076}, "CVE-2019-19709": {"epss_score": 0.00315, "epss_percentile": 0.54172}, "CVE-2019-19712": {"epss_score": 0.00133, "epss_percentile": 0.33724}, "CVE-2019-19714": {"epss_score": 0.0021, "epss_percentile": 0.43478}, "CVE-2019-19719": {"epss_score": 0.50112, "epss_percentile": 0.9772}, "CVE-2019-19720": {"epss_score": 0.00618, "epss_percentile": 0.69375}, "CVE-2019-19721": {"epss_score": 0.01303, "epss_percentile": 0.79312}, "CVE-2019-19722": {"epss_score": 0.01213, "epss_percentile": 0.7857}, "CVE-2019-19724": {"epss_score": 0.00313, "epss_percentile": 0.54069}, "CVE-2019-19725": {"epss_score": 0.00961, "epss_percentile": 0.75982}, "CVE-2019-19726": {"epss_score": 0.08202, "epss_percentile": 0.91928}, "CVE-2019-19727": {"epss_score": 0.00047, "epss_percentile": 0.14491}, "CVE-2019-19728": {"epss_score": 0.00435, "epss_percentile": 0.6237}, "CVE-2019-19729": {"epss_score": 0.00227, "epss_percentile": 0.45418}, "CVE-2019-19731": {"epss_score": 0.25357, "epss_percentile": 0.96018}, "CVE-2019-19732": {"epss_score": 0.0032, "epss_percentile": 0.54591}, "CVE-2019-19733": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-19734": {"epss_score": 0.003, "epss_percentile": 0.52943}, "CVE-2019-19735": {"epss_score": 0.00168, "epss_percentile": 0.38521}, "CVE-2019-19736": {"epss_score": 0.00275, "epss_percentile": 0.50638}, "CVE-2019-19737": {"epss_score": 0.00177, "epss_percentile": 0.39555}, "CVE-2019-19738": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-19739": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2019-19740": {"epss_score": 0.00908, "epss_percentile": 0.75288}, "CVE-2019-19741": {"epss_score": 0.00064, "epss_percentile": 0.20178}, "CVE-2019-19742": {"epss_score": 0.04588, "epss_percentile": 0.8889}, "CVE-2019-19743": {"epss_score": 0.1451, "epss_percentile": 0.94227}, "CVE-2019-19745": {"epss_score": 0.00476, "epss_percentile": 0.64291}, "CVE-2019-19746": {"epss_score": 0.00358, "epss_percentile": 0.57517}, "CVE-2019-19747": {"epss_score": 0.00484, "epss_percentile": 0.64648}, "CVE-2019-19748": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2019-19750": {"epss_score": 0.0035, "epss_percentile": 0.56975}, "CVE-2019-19751": {"epss_score": 0.00125, "epss_percentile": 0.32602}, "CVE-2019-19752": {"epss_score": 0.0017, "epss_percentile": 0.38714}, "CVE-2019-19753": {"epss_score": 0.00163, "epss_percentile": 0.37758}, "CVE-2019-19754": {"epss_score": 0.00087, "epss_percentile": 0.25529}, "CVE-2019-19755": {"epss_score": 0.00163, "epss_percentile": 0.37758}, "CVE-2019-19756": {"epss_score": 0.00141, "epss_percentile": 0.34899}, "CVE-2019-19757": {"epss_score": 0.00312, "epss_percentile": 0.53992}, "CVE-2019-19758": {"epss_score": 0.00417, "epss_percentile": 0.61255}, "CVE-2019-19766": {"epss_score": 0.00386, "epss_percentile": 0.59264}, "CVE-2019-19767": {"epss_score": 0.00382, "epss_percentile": 0.5907}, "CVE-2019-19768": {"epss_score": 0.01401, "epss_percentile": 0.80009}, "CVE-2019-19769": {"epss_score": 0.00327, "epss_percentile": 0.55092}, "CVE-2019-19770": {"epss_score": 0.01123, "epss_percentile": 0.7779}, "CVE-2019-19771": {"epss_score": 0.00443, "epss_percentile": 0.62804}, "CVE-2019-19772": {"epss_score": 0.00352, "epss_percentile": 0.57122}, "CVE-2019-19773": {"epss_score": 0.00352, "epss_percentile": 0.57122}, "CVE-2019-19774": {"epss_score": 0.25583, "epss_percentile": 0.96047}, "CVE-2019-19775": {"epss_score": 0.00271, "epss_percentile": 0.50299}, "CVE-2019-19777": {"epss_score": 0.0037, "epss_percentile": 0.58328}, "CVE-2019-19778": {"epss_score": 0.0037, "epss_percentile": 0.58328}, "CVE-2019-19781": {"epss_score": 0.94442, "epss_percentile": 0.99989}, "CVE-2019-19782": {"epss_score": 0.01134, "epss_percentile": 0.77893}, "CVE-2019-19783": {"epss_score": 0.01349, "epss_percentile": 0.79669}, "CVE-2019-19785": {"epss_score": 0.00369, "epss_percentile": 0.58258}, "CVE-2019-19786": {"epss_score": 0.00369, "epss_percentile": 0.58258}, "CVE-2019-19787": {"epss_score": 0.00369, "epss_percentile": 0.58258}, "CVE-2019-19788": {"epss_score": 0.00045, "epss_percentile": 0.13706}, "CVE-2019-19789": {"epss_score": 0.00464, "epss_percentile": 0.63717}, "CVE-2019-19790": {"epss_score": 0.00072, "epss_percentile": 0.22391}, "CVE-2019-19791": {"epss_score": 0.00041, "epss_percentile": 0.12235}, "CVE-2019-19792": {"epss_score": 0.00097, "epss_percentile": 0.27482}, "CVE-2019-19793": {"epss_score": 0.00612, "epss_percentile": 0.69235}, "CVE-2019-19794": {"epss_score": 0.00293, "epss_percentile": 0.52295}, "CVE-2019-19795": {"epss_score": 0.00312, "epss_percentile": 0.53939}, "CVE-2019-19796": {"epss_score": 0.00312, "epss_percentile": 0.53939}, "CVE-2019-19797": {"epss_score": 0.00082, "epss_percentile": 0.24409}, "CVE-2019-19799": {"epss_score": 0.06903, "epss_percentile": 0.91106}, "CVE-2019-19800": {"epss_score": 0.09892, "epss_percentile": 0.92756}, "CVE-2019-19801": {"epss_score": 0.00055, "epss_percentile": 0.17525}, "CVE-2019-19802": {"epss_score": 0.00215, "epss_percentile": 0.44106}, "CVE-2019-19805": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2019-19806": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2019-19807": {"epss_score": 0.00078, "epss_percentile": 0.23635}, "CVE-2019-19810": {"epss_score": 0.08679, "epss_percentile": 0.92195}, "CVE-2019-19813": {"epss_score": 0.01623, "epss_percentile": 0.81401}, "CVE-2019-19814": {"epss_score": 0.00629, "epss_percentile": 0.69684}, "CVE-2019-19815": {"epss_score": 0.00972, "epss_percentile": 0.76135}, "CVE-2019-19816": {"epss_score": 0.00251, "epss_percentile": 0.48259}, "CVE-2019-19817": {"epss_score": 0.00012, "epss_percentile": 0.01346}, "CVE-2019-19818": {"epss_score": 0.00012, "epss_percentile": 0.01415}, "CVE-2019-19819": {"epss_score": 0.00012, "epss_percentile": 0.01346}, "CVE-2019-19820": {"epss_score": 0.00186, "epss_percentile": 0.40612}, "CVE-2019-19821": {"epss_score": 0.00487, "epss_percentile": 0.64805}, "CVE-2019-19822": {"epss_score": 0.43036, "epss_percentile": 0.97368}, "CVE-2019-19823": {"epss_score": 0.33866, "epss_percentile": 0.9681}, "CVE-2019-19824": {"epss_score": 0.90206, "epss_percentile": 0.99568}, "CVE-2019-19825": {"epss_score": 0.28752, "epss_percentile": 0.96381}, "CVE-2019-19826": {"epss_score": 0.01547, "epss_percentile": 0.80971}, "CVE-2019-19829": {"epss_score": 0.01441, "epss_percentile": 0.80305}, "CVE-2019-19830": {"epss_score": 0.00573, "epss_percentile": 0.68055}, "CVE-2019-19832": {"epss_score": 0.00183, "epss_percentile": 0.40355}, "CVE-2019-19833": {"epss_score": 0.65522, "epss_percentile": 0.98424}, "CVE-2019-19834": {"epss_score": 0.01338, "epss_percentile": 0.79565}, "CVE-2019-19835": {"epss_score": 0.01326, "epss_percentile": 0.79484}, "CVE-2019-19836": {"epss_score": 0.02398, "epss_percentile": 0.84624}, "CVE-2019-19837": {"epss_score": 0.01208, "epss_percentile": 0.7853}, "CVE-2019-19838": {"epss_score": 0.23295, "epss_percentile": 0.9576}, "CVE-2019-19839": {"epss_score": 0.04274, "epss_percentile": 0.88481}, "CVE-2019-19840": {"epss_score": 0.21704, "epss_percentile": 0.95549}, "CVE-2019-19841": {"epss_score": 0.04274, "epss_percentile": 0.88481}, "CVE-2019-19842": {"epss_score": 0.06732, "epss_percentile": 0.9099}, "CVE-2019-19843": {"epss_score": 0.00646, "epss_percentile": 0.70134}, "CVE-2019-19844": {"epss_score": 0.13973, "epss_percentile": 0.94103}, "CVE-2019-19845": {"epss_score": 0.00011, "epss_percentile": 0.01024}, "CVE-2019-19846": {"epss_score": 0.00056, "epss_percentile": 0.1787}, "CVE-2019-19847": {"epss_score": 0.00479, "epss_percentile": 0.64436}, "CVE-2019-19848": {"epss_score": 0.00394, "epss_percentile": 0.59793}, "CVE-2019-19849": {"epss_score": 0.00786, "epss_percentile": 0.73289}, "CVE-2019-19850": {"epss_score": 0.00357, "epss_percentile": 0.57472}, "CVE-2019-19851": {"epss_score": 0.00285, "epss_percentile": 0.51513}, "CVE-2019-19852": {"epss_score": 0.00306, "epss_percentile": 0.53425}, "CVE-2019-19854": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-19855": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-19856": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-19857": {"epss_score": 0.00209, "epss_percentile": 0.43412}, "CVE-2019-19858": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2019-19859": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-19865": {"epss_score": 0.00367, "epss_percentile": 0.58115}, "CVE-2019-19866": {"epss_score": 0.00526, "epss_percentile": 0.66399}, "CVE-2019-19869": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-19872": {"epss_score": 0.00647, "epss_percentile": 0.70197}, "CVE-2019-19873": {"epss_score": 0.0033, "epss_percentile": 0.55482}, "CVE-2019-19874": {"epss_score": 0.01314, "epss_percentile": 0.79396}, "CVE-2019-19875": {"epss_score": 0.00695, "epss_percentile": 0.71373}, "CVE-2019-19876": {"epss_score": 0.00415, "epss_percentile": 0.61132}, "CVE-2019-19877": {"epss_score": 0.00144, "epss_percentile": 0.35266}, "CVE-2019-19878": {"epss_score": 0.0033, "epss_percentile": 0.55482}, "CVE-2019-19879": {"epss_score": 0.00733, "epss_percentile": 0.72212}, "CVE-2019-19880": {"epss_score": 0.06395, "epss_percentile": 0.90722}, "CVE-2019-19882": {"epss_score": 0.00094, "epss_percentile": 0.2678}, "CVE-2019-19885": {"epss_score": 0.00257, "epss_percentile": 0.48877}, "CVE-2019-19886": {"epss_score": 0.04013, "epss_percentile": 0.88114}, "CVE-2019-19887": {"epss_score": 0.00435, "epss_percentile": 0.62332}, "CVE-2019-19888": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2019-19889": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2019-19890": {"epss_score": 0.00168, "epss_percentile": 0.38461}, "CVE-2019-19891": {"epss_score": 0.0006, "epss_percentile": 0.1908}, "CVE-2019-19893": {"epss_score": 0.01827, "epss_percentile": 0.82439}, "CVE-2019-19894": {"epss_score": 0.00134, "epss_percentile": 0.33928}, "CVE-2019-19895": {"epss_score": 0.00142, "epss_percentile": 0.35}, "CVE-2019-19896": {"epss_score": 0.03617, "epss_percentile": 0.87437}, "CVE-2019-19897": {"epss_score": 0.21791, "epss_percentile": 0.95561}, "CVE-2019-19898": {"epss_score": 0.00168, "epss_percentile": 0.38461}, "CVE-2019-19899": {"epss_score": 0.0013, "epss_percentile": 0.33278}, "CVE-2019-19900": {"epss_score": 0.00412, "epss_percentile": 0.60936}, "CVE-2019-19901": {"epss_score": 0.00412, "epss_percentile": 0.60936}, "CVE-2019-19902": {"epss_score": 0.00613, "epss_percentile": 0.69246}, "CVE-2019-19903": {"epss_score": 0.00412, "epss_percentile": 0.60936}, "CVE-2019-19905": {"epss_score": 0.03358, "epss_percentile": 0.86981}, "CVE-2019-19906": {"epss_score": 0.00396, "epss_percentile": 0.5986}, "CVE-2019-19907": {"epss_score": 0.00215, "epss_percentile": 0.44121}, "CVE-2019-19908": {"epss_score": 0.54847, "epss_percentile": 0.97947}, "CVE-2019-19909": {"epss_score": 0.00874, "epss_percentile": 0.74756}, "CVE-2019-19910": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2019-19911": {"epss_score": 0.00965, "epss_percentile": 0.76049}, "CVE-2019-19912": {"epss_score": 0.00252, "epss_percentile": 0.48411}, "CVE-2019-19913": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2019-19915": {"epss_score": 0.00187, "epss_percentile": 0.40716}, "CVE-2019-19916": {"epss_score": 0.00273, "epss_percentile": 0.50442}, "CVE-2019-19917": {"epss_score": 0.00355, "epss_percentile": 0.57292}, "CVE-2019-19918": {"epss_score": 0.00355, "epss_percentile": 0.57292}, "CVE-2019-19919": {"epss_score": 0.17796, "epss_percentile": 0.94908}, "CVE-2019-19920": {"epss_score": 0.03759, "epss_percentile": 0.87686}, "CVE-2019-19921": {"epss_score": 0.00159, "epss_percentile": 0.37364}, "CVE-2019-19922": {"epss_score": 0.00057, "epss_percentile": 0.18109}, "CVE-2019-19923": {"epss_score": 0.062, "epss_percentile": 0.90558}, "CVE-2019-19924": {"epss_score": 0.04739, "epss_percentile": 0.89076}, "CVE-2019-19925": {"epss_score": 0.07012, "epss_percentile": 0.91186}, "CVE-2019-19926": {"epss_score": 0.06317, "epss_percentile": 0.90668}, "CVE-2019-19927": {"epss_score": 0.00205, "epss_percentile": 0.42687}, "CVE-2019-19929": {"epss_score": 0.00225, "epss_percentile": 0.45232}, "CVE-2019-19930": {"epss_score": 0.00436, "epss_percentile": 0.62451}, "CVE-2019-19931": {"epss_score": 0.00515, "epss_percentile": 0.66006}, "CVE-2019-19935": {"epss_score": 0.02161, "epss_percentile": 0.83825}, "CVE-2019-19937": {"epss_score": 0.00515, "epss_percentile": 0.65987}, "CVE-2019-19940": {"epss_score": 0.08117, "epss_percentile": 0.91888}, "CVE-2019-19941": {"epss_score": 0.00203, "epss_percentile": 0.42571}, "CVE-2019-19942": {"epss_score": 0.00276, "epss_percentile": 0.50712}, "CVE-2019-19943": {"epss_score": 0.02534, "epss_percentile": 0.85036}, "CVE-2019-19944": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2019-19945": {"epss_score": 0.00975, "epss_percentile": 0.76199}, "CVE-2019-19946": {"epss_score": 0.0028, "epss_percentile": 0.51088}, "CVE-2019-19947": {"epss_score": 0.00108, "epss_percentile": 0.2983}, "CVE-2019-19948": {"epss_score": 0.00387, "epss_percentile": 0.59301}, "CVE-2019-19949": {"epss_score": 0.00342, "epss_percentile": 0.56354}, "CVE-2019-19950": {"epss_score": 0.01204, "epss_percentile": 0.78502}, "CVE-2019-19951": {"epss_score": 0.0144, "epss_percentile": 0.80298}, "CVE-2019-19952": {"epss_score": 0.00457, "epss_percentile": 0.6338}, "CVE-2019-19953": {"epss_score": 0.01306, "epss_percentile": 0.79331}, "CVE-2019-19954": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-19956": {"epss_score": 0.00154, "epss_percentile": 0.36657}, "CVE-2019-19957": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2019-19958": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2019-19959": {"epss_score": 0.0052, "epss_percentile": 0.66192}, "CVE-2019-19960": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2019-19962": {"epss_score": 0.00184, "epss_percentile": 0.40414}, "CVE-2019-19963": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2019-19964": {"epss_score": 0.00158, "epss_percentile": 0.37259}, "CVE-2019-19965": {"epss_score": 0.00041, "epss_percentile": 0.12322}, "CVE-2019-19966": {"epss_score": 0.00138, "epss_percentile": 0.34385}, "CVE-2019-19967": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2019-19968": {"epss_score": 0.00309, "epss_percentile": 0.53672}, "CVE-2019-19977": {"epss_score": 0.00222, "epss_percentile": 0.44721}, "CVE-2019-19979": {"epss_score": 0.00196, "epss_percentile": 0.41769}, "CVE-2019-19980": {"epss_score": 0.00225, "epss_percentile": 0.45087}, "CVE-2019-19981": {"epss_score": 0.00142, "epss_percentile": 0.34979}, "CVE-2019-19982": {"epss_score": 0.00388, "epss_percentile": 0.59358}, "CVE-2019-19983": {"epss_score": 0.00328, "epss_percentile": 0.55269}, "CVE-2019-19984": {"epss_score": 0.00219, "epss_percentile": 0.44503}, "CVE-2019-19985": {"epss_score": 0.86715, "epss_percentile": 0.99393}, "CVE-2019-19986": {"epss_score": 0.00844, "epss_percentile": 0.74281}, "CVE-2019-19987": {"epss_score": 0.00197, "epss_percentile": 0.41909}, "CVE-2019-19988": {"epss_score": 0.00778, "epss_percentile": 0.73132}, "CVE-2019-19989": {"epss_score": 0.00425, "epss_percentile": 0.61693}, "CVE-2019-19990": {"epss_score": 0.00296, "epss_percentile": 0.52575}, "CVE-2019-19991": {"epss_score": 0.00296, "epss_percentile": 0.52575}, "CVE-2019-19992": {"epss_score": 0.00424, "epss_percentile": 0.61664}, "CVE-2019-19993": {"epss_score": 0.0031, "epss_percentile": 0.53764}, "CVE-2019-19994": {"epss_score": 0.07344, "epss_percentile": 0.91421}, "CVE-2019-19995": {"epss_score": 0.00188, "epss_percentile": 0.40835}, "CVE-2019-19996": {"epss_score": 0.00949, "epss_percentile": 0.75844}, "CVE-2019-19998": {"epss_score": 0.0036, "epss_percentile": 0.57649}, "CVE-2019-19999": {"epss_score": 0.00438, "epss_percentile": 0.6255}, "CVE-2019-1000": {"epss_score": 0.04334, "epss_percentile": 0.88562}, "CVE-2019-1001": {"epss_score": 0.03877, "epss_percentile": 0.8789}, "CVE-2019-1002": {"epss_score": 0.0117, "epss_percentile": 0.78205}, "CVE-2019-1003": {"epss_score": 0.01427, "epss_percentile": 0.80208}, "CVE-2019-1004": {"epss_score": 0.04054, "epss_percentile": 0.88183}, "CVE-2019-1005": {"epss_score": 0.03992, "epss_percentile": 0.88073}, "CVE-2019-1006": {"epss_score": 0.02931, "epss_percentile": 0.86016}, "CVE-2019-1007": {"epss_score": 0.00256, "epss_percentile": 0.48813}, "CVE-2019-1008": {"epss_score": 0.09201, "epss_percentile": 0.92446}, "CVE-2019-1009": {"epss_score": 0.19682, "epss_percentile": 0.95224}, "CVE-2019-1010": {"epss_score": 0.07622, "epss_percentile": 0.91579}, "CVE-2019-1011": {"epss_score": 0.07622, "epss_percentile": 0.91579}, "CVE-2019-1012": {"epss_score": 0.07622, "epss_percentile": 0.91579}, "CVE-2019-1013": {"epss_score": 0.14112, "epss_percentile": 0.94135}, "CVE-2019-1014": {"epss_score": 0.00167, "epss_percentile": 0.38304}, "CVE-2019-1015": {"epss_score": 0.07622, "epss_percentile": 0.91579}, "CVE-2019-1016": {"epss_score": 0.07622, "epss_percentile": 0.91579}, "CVE-2019-1017": {"epss_score": 0.00167, "epss_percentile": 0.38304}, "CVE-2019-1018": {"epss_score": 0.00167, "epss_percentile": 0.38304}, "CVE-2019-1019": {"epss_score": 0.03612, "epss_percentile": 0.87428}, "CVE-2019-1021": {"epss_score": 0.00299, "epss_percentile": 0.52856}, "CVE-2019-1022": {"epss_score": 0.00299, "epss_percentile": 0.52856}, "CVE-2019-1023": {"epss_score": 0.12446, "epss_percentile": 0.93675}, "CVE-2019-1024": {"epss_score": 0.01427, "epss_percentile": 0.80208}, "CVE-2019-1025": {"epss_score": 0.16561, "epss_percentile": 0.94691}, "CVE-2019-1026": {"epss_score": 0.00299, "epss_percentile": 0.52856}, "CVE-2019-1027": {"epss_score": 0.00299, "epss_percentile": 0.52856}, "CVE-2019-1028": {"epss_score": 0.00299, "epss_percentile": 0.52856}, "CVE-2019-1029": {"epss_score": 0.14394, "epss_percentile": 0.94203}, "CVE-2019-1030": {"epss_score": 0.17771, "epss_percentile": 0.94904}, "CVE-2019-1031": {"epss_score": 0.00443, "epss_percentile": 0.62796}, "CVE-2019-1032": {"epss_score": 0.00443, "epss_percentile": 0.62796}, "CVE-2019-1033": {"epss_score": 0.00443, "epss_percentile": 0.62796}, "CVE-2019-1034": {"epss_score": 0.13212, "epss_percentile": 0.93902}, "CVE-2019-1035": {"epss_score": 0.13047, "epss_percentile": 0.93857}, "CVE-2019-1036": {"epss_score": 0.00443, "epss_percentile": 0.62796}, "CVE-2019-1037": {"epss_score": 0.00268, "epss_percentile": 0.50089}, "CVE-2019-1038": {"epss_score": 0.03992, "epss_percentile": 0.88073}, "CVE-2019-1039": {"epss_score": 0.00538, "epss_percentile": 0.66945}, "CVE-2019-1040": {"epss_score": 0.89678, "epss_percentile": 0.99538}, "CVE-2019-1041": {"epss_score": 0.00167, "epss_percentile": 0.38304}, "CVE-2019-1043": {"epss_score": 0.02531, "epss_percentile": 0.85025}, "CVE-2019-1044": {"epss_score": 0.00277, "epss_percentile": 0.50834}, "CVE-2019-1045": {"epss_score": 0.00291, "epss_percentile": 0.52186}, "CVE-2019-1046": {"epss_score": 0.07622, "epss_percentile": 0.91579}, "CVE-2019-1047": {"epss_score": 0.07622, "epss_percentile": 0.91579}, "CVE-2019-1048": {"epss_score": 0.07622, "epss_percentile": 0.91579}, "CVE-2019-1049": {"epss_score": 0.07622, "epss_percentile": 0.91579}, "CVE-2019-1050": {"epss_score": 0.07622, "epss_percentile": 0.91579}, "CVE-2019-1051": {"epss_score": 0.13818, "epss_percentile": 0.94067}, "CVE-2019-1052": {"epss_score": 0.01427, "epss_percentile": 0.80208}, "CVE-2019-1053": {"epss_score": 0.00246, "epss_percentile": 0.47791}, "CVE-2019-1054": {"epss_score": 0.01088, "epss_percentile": 0.77437}, "CVE-2019-1055": {"epss_score": 0.03992, "epss_percentile": 0.88073}, "CVE-2019-1056": {"epss_score": 0.04054, "epss_percentile": 0.88183}, "CVE-2019-1057": {"epss_score": 0.04431, "epss_percentile": 0.88678}, "CVE-2019-1059": {"epss_score": 0.04054, "epss_percentile": 0.88183}, "CVE-2019-1060": {"epss_score": 0.2279, "epss_percentile": 0.95687}, "CVE-2019-1062": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-1063": {"epss_score": 0.04054, "epss_percentile": 0.88183}, "CVE-2019-1064": {"epss_score": 0.11342, "epss_percentile": 0.93316}, "CVE-2019-1065": {"epss_score": 0.00663, "epss_percentile": 0.70622}, "CVE-2019-1067": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-1068": {"epss_score": 0.41568, "epss_percentile": 0.97284}, "CVE-2019-1069": {"epss_score": 0.30456, "epss_percentile": 0.96542}, "CVE-2019-1070": {"epss_score": 0.01417, "epss_percentile": 0.80152}, "CVE-2019-1071": {"epss_score": 0.00667, "epss_percentile": 0.70719}, "CVE-2019-1072": {"epss_score": 0.24111, "epss_percentile": 0.95875}, "CVE-2019-1073": {"epss_score": 0.00667, "epss_percentile": 0.70719}, "CVE-2019-1074": {"epss_score": 0.00311, "epss_percentile": 0.53853}, "CVE-2019-1075": {"epss_score": 0.00417, "epss_percentile": 0.61231}, "CVE-2019-1076": {"epss_score": 0.00455, "epss_percentile": 0.63275}, "CVE-2019-1077": {"epss_score": 0.00557, "epss_percentile": 0.67539}, "CVE-2019-1078": {"epss_score": 0.00652, "epss_percentile": 0.70319}, "CVE-2019-1079": {"epss_score": 0.25343, "epss_percentile": 0.96016}, "CVE-2019-1080": {"epss_score": 0.03992, "epss_percentile": 0.88073}, "CVE-2019-1081": {"epss_score": 0.01125, "epss_percentile": 0.77807}, "CVE-2019-1082": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2019-1083": {"epss_score": 0.10562, "epss_percentile": 0.93029}, "CVE-2019-1084": {"epss_score": 0.09029, "epss_percentile": 0.92373}, "CVE-2019-1085": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2019-1086": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2019-1087": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2019-1088": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2019-1089": {"epss_score": 0.02912, "epss_percentile": 0.85973}, "CVE-2019-1090": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-1091": {"epss_score": 0.00933, "epss_percentile": 0.75634}, "CVE-2019-1092": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-1093": {"epss_score": 0.0143, "epss_percentile": 0.80237}, "CVE-2019-1094": {"epss_score": 0.12437, "epss_percentile": 0.93671}, "CVE-2019-1095": {"epss_score": 0.12437, "epss_percentile": 0.93671}, "CVE-2019-1096": {"epss_score": 0.34562, "epss_percentile": 0.96856}, "CVE-2019-1097": {"epss_score": 0.0143, "epss_percentile": 0.80237}, "CVE-2019-1098": {"epss_score": 0.12437, "epss_percentile": 0.93671}, "CVE-2019-1099": {"epss_score": 0.12437, "epss_percentile": 0.93671}, "CVE-2019-1100": {"epss_score": 0.12437, "epss_percentile": 0.93671}, "CVE-2019-1101": {"epss_score": 0.12437, "epss_percentile": 0.93671}, "CVE-2019-1102": {"epss_score": 0.24741, "epss_percentile": 0.9595}, "CVE-2019-1103": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-1104": {"epss_score": 0.03057, "epss_percentile": 0.86303}, "CVE-2019-1105": {"epss_score": 0.00443, "epss_percentile": 0.62796}, "CVE-2019-1106": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-1107": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-1108": {"epss_score": 0.23458, "epss_percentile": 0.95781}, "CVE-2019-1109": {"epss_score": 0.07967, "epss_percentile": 0.91795}, "CVE-2019-1110": {"epss_score": 0.24741, "epss_percentile": 0.9595}, "CVE-2019-1111": {"epss_score": 0.24741, "epss_percentile": 0.9595}, "CVE-2019-1112": {"epss_score": 0.10716, "epss_percentile": 0.93081}, "CVE-2019-1113": {"epss_score": 0.33725, "epss_percentile": 0.968}, "CVE-2019-1116": {"epss_score": 0.12437, "epss_percentile": 0.93671}, "CVE-2019-1117": {"epss_score": 0.39097, "epss_percentile": 0.97138}, "CVE-2019-1118": {"epss_score": 0.39097, "epss_percentile": 0.97138}, "CVE-2019-1119": {"epss_score": 0.33733, "epss_percentile": 0.968}, "CVE-2019-1120": {"epss_score": 0.34671, "epss_percentile": 0.96867}, "CVE-2019-1121": {"epss_score": 0.34671, "epss_percentile": 0.96867}, "CVE-2019-1122": {"epss_score": 0.34671, "epss_percentile": 0.96867}, "CVE-2019-1123": {"epss_score": 0.34671, "epss_percentile": 0.96867}, "CVE-2019-1124": {"epss_score": 0.30845, "epss_percentile": 0.96571}, "CVE-2019-1125": {"epss_score": 0.17044, "epss_percentile": 0.94765}, "CVE-2019-1126": {"epss_score": 0.01988, "epss_percentile": 0.83164}, "CVE-2019-1127": {"epss_score": 0.40075, "epss_percentile": 0.97194}, "CVE-2019-1128": {"epss_score": 0.34671, "epss_percentile": 0.96867}, "CVE-2019-1129": {"epss_score": 0.03114, "epss_percentile": 0.8643}, "CVE-2019-1130": {"epss_score": 0.01925, "epss_percentile": 0.82919}, "CVE-2019-1131": {"epss_score": 0.01327, "epss_percentile": 0.7949}, "CVE-2019-1132": {"epss_score": 0.32968, "epss_percentile": 0.96739}, "CVE-2019-1133": {"epss_score": 0.03992, "epss_percentile": 0.88073}, "CVE-2019-1134": {"epss_score": 0.00485, "epss_percentile": 0.64733}, "CVE-2019-1136": {"epss_score": 0.05403, "epss_percentile": 0.89835}, "CVE-2019-1137": {"epss_score": 0.00671, "epss_percentile": 0.70801}, "CVE-2019-1138": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-1139": {"epss_score": 0.01327, "epss_percentile": 0.7949}, "CVE-2019-1140": {"epss_score": 0.04699, "epss_percentile": 0.89022}, "CVE-2019-1141": {"epss_score": 0.01327, "epss_percentile": 0.7949}, "CVE-2019-1142": {"epss_score": 0.00463, "epss_percentile": 0.63671}, "CVE-2019-1143": {"epss_score": 0.00812, "epss_percentile": 0.73749}, "CVE-2019-1144": {"epss_score": 0.41601, "epss_percentile": 0.97285}, "CVE-2019-1145": {"epss_score": 0.3187, "epss_percentile": 0.96657}, "CVE-2019-1146": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2019-1147": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2019-1148": {"epss_score": 0.0245, "epss_percentile": 0.84782}, "CVE-2019-1149": {"epss_score": 0.3187, "epss_percentile": 0.96657}, "CVE-2019-1150": {"epss_score": 0.28074, "epss_percentile": 0.96307}, "CVE-2019-1151": {"epss_score": 0.28404, "epss_percentile": 0.96353}, "CVE-2019-1152": {"epss_score": 0.3187, "epss_percentile": 0.96657}, "CVE-2019-1153": {"epss_score": 0.02793, "epss_percentile": 0.85674}, "CVE-2019-1154": {"epss_score": 0.00652, "epss_percentile": 0.70319}, "CVE-2019-1155": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2019-1156": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2019-1157": {"epss_score": 0.04216, "epss_percentile": 0.88406}, "CVE-2019-1158": {"epss_score": 0.00807, "epss_percentile": 0.73667}, "CVE-2019-1159": {"epss_score": 0.00488, "epss_percentile": 0.64834}, "CVE-2019-1161": {"epss_score": 0.00563, "epss_percentile": 0.67742}, "CVE-2019-1162": {"epss_score": 0.00462, "epss_percentile": 0.63575}, "CVE-2019-1163": {"epss_score": 0.02237, "epss_percentile": 0.84104}, "CVE-2019-1164": {"epss_score": 0.00651, "epss_percentile": 0.70281}, "CVE-2019-1166": {"epss_score": 0.03534, "epss_percentile": 0.87309}, "CVE-2019-1167": {"epss_score": 0.00416, "epss_percentile": 0.6117}, "CVE-2019-1168": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-1169": {"epss_score": 0.01478, "epss_percentile": 0.80556}, "CVE-2019-1170": {"epss_score": 0.02231, "epss_percentile": 0.84087}, "CVE-2019-1171": {"epss_score": 0.00417, "epss_percentile": 0.61252}, "CVE-2019-1172": {"epss_score": 0.065, "epss_percentile": 0.90801}, "CVE-2019-1173": {"epss_score": 0.00229, "epss_percentile": 0.45569}, "CVE-2019-1174": {"epss_score": 0.00148, "epss_percentile": 0.35832}, "CVE-2019-1175": {"epss_score": 0.00148, "epss_percentile": 0.35832}, "CVE-2019-1176": {"epss_score": 0.00213, "epss_percentile": 0.43894}, "CVE-2019-1177": {"epss_score": 0.00148, "epss_percentile": 0.35832}, "CVE-2019-1178": {"epss_score": 0.00172, "epss_percentile": 0.39016}, "CVE-2019-1179": {"epss_score": 0.00172, "epss_percentile": 0.39016}, "CVE-2019-1180": {"epss_score": 0.00172, "epss_percentile": 0.39016}, "CVE-2019-1181": {"epss_score": 0.78294, "epss_percentile": 0.98978}, "CVE-2019-1182": {"epss_score": 0.16922, "epss_percentile": 0.94747}, "CVE-2019-1183": {"epss_score": 0.11939, "epss_percentile": 0.93522}, "CVE-2019-1184": {"epss_score": 0.04772, "epss_percentile": 0.89128}, "CVE-2019-1185": {"epss_score": 0.00798, "epss_percentile": 0.7351}, "CVE-2019-1186": {"epss_score": 0.00229, "epss_percentile": 0.45569}, "CVE-2019-1187": {"epss_score": 0.03246, "epss_percentile": 0.86743}, "CVE-2019-1188": {"epss_score": 0.06062, "epss_percentile": 0.90444}, "CVE-2019-1190": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2019-1192": {"epss_score": 0.02358, "epss_percentile": 0.84488}, "CVE-2019-1193": {"epss_score": 0.01382, "epss_percentile": 0.79888}, "CVE-2019-1194": {"epss_score": 0.0254, "epss_percentile": 0.85045}, "CVE-2019-1195": {"epss_score": 0.01327, "epss_percentile": 0.7949}, "CVE-2019-1196": {"epss_score": 0.01327, "epss_percentile": 0.7949}, "CVE-2019-1197": {"epss_score": 0.01327, "epss_percentile": 0.7949}, "CVE-2019-1198": {"epss_score": 0.00486, "epss_percentile": 0.64768}, "CVE-2019-1199": {"epss_score": 0.06891, "epss_percentile": 0.91096}, "CVE-2019-1200": {"epss_score": 0.07373, "epss_percentile": 0.9144}, "CVE-2019-1201": {"epss_score": 0.11304, "epss_percentile": 0.933}, "CVE-2019-1202": {"epss_score": 0.00599, "epss_percentile": 0.688}, "CVE-2019-1203": {"epss_score": 0.00444, "epss_percentile": 0.62816}, "CVE-2019-1204": {"epss_score": 0.08582, "epss_percentile": 0.92134}, "CVE-2019-1205": {"epss_score": 0.09473, "epss_percentile": 0.92563}, "CVE-2019-1206": {"epss_score": 0.22134, "epss_percentile": 0.95598}, "CVE-2019-1208": {"epss_score": 0.05399, "epss_percentile": 0.89832}, "CVE-2019-1209": {"epss_score": 0.13815, "epss_percentile": 0.94066}, "CVE-2019-1211": {"epss_score": 0.00426, "epss_percentile": 0.61754}, "CVE-2019-1212": {"epss_score": 0.17995, "epss_percentile": 0.9494}, "CVE-2019-1213": {"epss_score": 0.16743, "epss_percentile": 0.94725}, "CVE-2019-1214": {"epss_score": 0.03681, "epss_percentile": 0.87559}, "CVE-2019-1215": {"epss_score": 0.08083, "epss_percentile": 0.91873}, "CVE-2019-1216": {"epss_score": 0.01464, "epss_percentile": 0.8045}, "CVE-2019-1217": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-1218": {"epss_score": 0.07676, "epss_percentile": 0.91619}, "CVE-2019-1219": {"epss_score": 0.00955, "epss_percentile": 0.75914}, "CVE-2019-1220": {"epss_score": 0.05935, "epss_percentile": 0.90341}, "CVE-2019-1221": {"epss_score": 0.44847, "epss_percentile": 0.97456}, "CVE-2019-1222": {"epss_score": 0.13718, "epss_percentile": 0.94042}, "CVE-2019-1223": {"epss_score": 0.185, "epss_percentile": 0.95024}, "CVE-2019-1224": {"epss_score": 0.04963, "epss_percentile": 0.89337}, "CVE-2019-1225": {"epss_score": 0.04963, "epss_percentile": 0.89337}, "CVE-2019-1226": {"epss_score": 0.24163, "epss_percentile": 0.95881}, "CVE-2019-1227": {"epss_score": 0.00812, "epss_percentile": 0.73749}, "CVE-2019-1228": {"epss_score": 0.00812, "epss_percentile": 0.73749}, "CVE-2019-1229": {"epss_score": 0.09431, "epss_percentile": 0.92544}, "CVE-2019-1230": {"epss_score": 0.02836, "epss_percentile": 0.85791}, "CVE-2019-1231": {"epss_score": 0.00411, "epss_percentile": 0.60857}, "CVE-2019-1232": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2019-1233": {"epss_score": 0.11411, "epss_percentile": 0.9334}, "CVE-2019-1234": {"epss_score": 0.21323, "epss_percentile": 0.95501}, "CVE-2019-1235": {"epss_score": 0.00128, "epss_percentile": 0.32945}, "CVE-2019-1236": {"epss_score": 0.05399, "epss_percentile": 0.89832}, "CVE-2019-1237": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-1238": {"epss_score": 0.04555, "epss_percentile": 0.88845}, "CVE-2019-1239": {"epss_score": 0.09794, "epss_percentile": 0.92705}, "CVE-2019-1240": {"epss_score": 0.35463, "epss_percentile": 0.96914}, "CVE-2019-1241": {"epss_score": 0.29382, "epss_percentile": 0.96437}, "CVE-2019-1242": {"epss_score": 0.35463, "epss_percentile": 0.96914}, "CVE-2019-1243": {"epss_score": 0.303, "epss_percentile": 0.96526}, "CVE-2019-1244": {"epss_score": 0.19555, "epss_percentile": 0.95206}, "CVE-2019-1245": {"epss_score": 0.3048, "epss_percentile": 0.96544}, "CVE-2019-1246": {"epss_score": 0.35463, "epss_percentile": 0.96914}, "CVE-2019-1247": {"epss_score": 0.35463, "epss_percentile": 0.96914}, "CVE-2019-1248": {"epss_score": 0.35463, "epss_percentile": 0.96914}, "CVE-2019-1249": {"epss_score": 0.35463, "epss_percentile": 0.96914}, "CVE-2019-1250": {"epss_score": 0.303, "epss_percentile": 0.96526}, "CVE-2019-1251": {"epss_score": 0.01464, "epss_percentile": 0.8045}, "CVE-2019-1252": {"epss_score": 0.20144, "epss_percentile": 0.95293}, "CVE-2019-1253": {"epss_score": 0.28148, "epss_percentile": 0.96325}, "CVE-2019-1254": {"epss_score": 0.0059, "epss_percentile": 0.68566}, "CVE-2019-1255": {"epss_score": 0.09124, "epss_percentile": 0.9241}, "CVE-2019-1256": {"epss_score": 0.01395, "epss_percentile": 0.79976}, "CVE-2019-1257": {"epss_score": 0.22944, "epss_percentile": 0.95708}, "CVE-2019-1258": {"epss_score": 0.10646, "epss_percentile": 0.93057}, "CVE-2019-1259": {"epss_score": 0.05041, "epss_percentile": 0.89427}, "CVE-2019-1260": {"epss_score": 0.10726, "epss_percentile": 0.93084}, "CVE-2019-1261": {"epss_score": 0.05041, "epss_percentile": 0.89427}, "CVE-2019-1262": {"epss_score": 0.0048, "epss_percentile": 0.64474}, "CVE-2019-1263": {"epss_score": 0.16075, "epss_percentile": 0.94568}, "CVE-2019-1264": {"epss_score": 0.07973, "epss_percentile": 0.91798}, "CVE-2019-1265": {"epss_score": 0.05034, "epss_percentile": 0.89417}, "CVE-2019-1266": {"epss_score": 0.00382, "epss_percentile": 0.59061}, "CVE-2019-1267": {"epss_score": 0.00469, "epss_percentile": 0.63935}, "CVE-2019-1268": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2019-1269": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-1270": {"epss_score": 0.00428, "epss_percentile": 0.61925}, "CVE-2019-1271": {"epss_score": 0.00254, "epss_percentile": 0.48541}, "CVE-2019-1272": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2019-1273": {"epss_score": 0.00617, "epss_percentile": 0.69358}, "CVE-2019-1274": {"epss_score": 0.0059, "epss_percentile": 0.68566}, "CVE-2019-1277": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2019-1278": {"epss_score": 0.00399, "epss_percentile": 0.60129}, "CVE-2019-1280": {"epss_score": 0.13009, "epss_percentile": 0.93845}, "CVE-2019-1282": {"epss_score": 0.00573, "epss_percentile": 0.68046}, "CVE-2019-1283": {"epss_score": 0.00576, "epss_percentile": 0.68123}, "CVE-2019-1284": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-1285": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-1286": {"epss_score": 0.16, "epss_percentile": 0.94552}, "CVE-2019-1287": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2019-1289": {"epss_score": 0.00212, "epss_percentile": 0.43806}, "CVE-2019-1290": {"epss_score": 0.30341, "epss_percentile": 0.96532}, "CVE-2019-1291": {"epss_score": 0.30341, "epss_percentile": 0.96532}, "CVE-2019-1292": {"epss_score": 0.03497, "epss_percentile": 0.87238}, "CVE-2019-1293": {"epss_score": 0.00955, "epss_percentile": 0.75914}, "CVE-2019-1294": {"epss_score": 0.00936, "epss_percentile": 0.75689}, "CVE-2019-1295": {"epss_score": 0.37362, "epss_percentile": 0.97036}, "CVE-2019-1296": {"epss_score": 0.37362, "epss_percentile": 0.97036}, "CVE-2019-1297": {"epss_score": 0.30838, "epss_percentile": 0.96571}, "CVE-2019-1298": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2019-1299": {"epss_score": 0.26457, "epss_percentile": 0.96148}, "CVE-2019-1300": {"epss_score": 0.03843, "epss_percentile": 0.87836}, "CVE-2019-1301": {"epss_score": 0.02774, "epss_percentile": 0.85633}, "CVE-2019-1302": {"epss_score": 0.09908, "epss_percentile": 0.92766}, "CVE-2019-1303": {"epss_score": 0.00662, "epss_percentile": 0.7059}, "CVE-2019-1305": {"epss_score": 0.00603, "epss_percentile": 0.68901}, "CVE-2019-1306": {"epss_score": 0.26049, "epss_percentile": 0.96104}, "CVE-2019-1307": {"epss_score": 0.02612, "epss_percentile": 0.85238}, "CVE-2019-1308": {"epss_score": 0.02612, "epss_percentile": 0.85238}, "CVE-2019-1309": {"epss_score": 0.00983, "epss_percentile": 0.763}, "CVE-2019-1310": {"epss_score": 0.00983, "epss_percentile": 0.763}, "CVE-2019-1311": {"epss_score": 0.3741, "epss_percentile": 0.97044}, "CVE-2019-1313": {"epss_score": 0.07937, "epss_percentile": 0.91775}, "CVE-2019-1314": {"epss_score": 0.00325, "epss_percentile": 0.55012}, "CVE-2019-1315": {"epss_score": 0.07545, "epss_percentile": 0.91529}, "CVE-2019-1316": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2019-1317": {"epss_score": 0.00351, "epss_percentile": 0.56981}, "CVE-2019-1318": {"epss_score": 0.02685, "epss_percentile": 0.85425}, "CVE-2019-1319": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-1320": {"epss_score": 0.0018, "epss_percentile": 0.399}, "CVE-2019-1321": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-1322": {"epss_score": 0.35766, "epss_percentile": 0.96932}, "CVE-2019-1323": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-1324": {"epss_score": 0.02732, "epss_percentile": 0.85542}, "CVE-2019-1325": {"epss_score": 0.00317, "epss_percentile": 0.54385}, "CVE-2019-1326": {"epss_score": 0.11289, "epss_percentile": 0.93293}, "CVE-2019-1327": {"epss_score": 0.32735, "epss_percentile": 0.96721}, "CVE-2019-1328": {"epss_score": 0.00675, "epss_percentile": 0.70912}, "CVE-2019-1329": {"epss_score": 0.01111, "epss_percentile": 0.7767}, "CVE-2019-1330": {"epss_score": 0.11221, "epss_percentile": 0.93269}, "CVE-2019-1331": {"epss_score": 0.38312, "epss_percentile": 0.97094}, "CVE-2019-1332": {"epss_score": 0.02052, "epss_percentile": 0.83411}, "CVE-2019-1333": {"epss_score": 0.30341, "epss_percentile": 0.96532}, "CVE-2019-1334": {"epss_score": 0.01464, "epss_percentile": 0.8045}, "CVE-2019-1335": {"epss_score": 0.02324, "epss_percentile": 0.8438}, "CVE-2019-1336": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-1337": {"epss_score": 0.00737, "epss_percentile": 0.72329}, "CVE-2019-1338": {"epss_score": 0.06574, "epss_percentile": 0.90857}, "CVE-2019-1339": {"epss_score": 0.00595, "epss_percentile": 0.68696}, "CVE-2019-1340": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2019-1341": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2019-1342": {"epss_score": 0.00567, "epss_percentile": 0.67861}, "CVE-2019-1343": {"epss_score": 0.31325, "epss_percentile": 0.9661}, "CVE-2019-1344": {"epss_score": 0.05455, "epss_percentile": 0.89896}, "CVE-2019-1345": {"epss_score": 0.05333, "epss_percentile": 0.8974}, "CVE-2019-1346": {"epss_score": 0.24519, "epss_percentile": 0.95928}, "CVE-2019-1347": {"epss_score": 0.13114, "epss_percentile": 0.93877}, "CVE-2019-1348": {"epss_score": 0.00039, "epss_percentile": 0.11473}, "CVE-2019-1349": {"epss_score": 0.27489, "epss_percentile": 0.96252}, "CVE-2019-1350": {"epss_score": 0.39133, "epss_percentile": 0.97143}, "CVE-2019-1351": {"epss_score": 0.20285, "epss_percentile": 0.95313}, "CVE-2019-1352": {"epss_score": 0.11847, "epss_percentile": 0.93493}, "CVE-2019-1353": {"epss_score": 0.00178, "epss_percentile": 0.39695}, "CVE-2019-1354": {"epss_score": 0.27489, "epss_percentile": 0.96252}, "CVE-2019-1356": {"epss_score": 0.16, "epss_percentile": 0.94552}, "CVE-2019-1357": {"epss_score": 0.02102, "epss_percentile": 0.83608}, "CVE-2019-1358": {"epss_score": 0.56365, "epss_percentile": 0.98019}, "CVE-2019-1359": {"epss_score": 0.35463, "epss_percentile": 0.96914}, "CVE-2019-1361": {"epss_score": 0.30825, "epss_percentile": 0.9657}, "CVE-2019-1362": {"epss_score": 0.02128, "epss_percentile": 0.83702}, "CVE-2019-1363": {"epss_score": 0.01464, "epss_percentile": 0.8045}, "CVE-2019-1364": {"epss_score": 0.06189, "epss_percentile": 0.90546}, "CVE-2019-1365": {"epss_score": 0.02144, "epss_percentile": 0.83758}, "CVE-2019-1366": {"epss_score": 0.02324, "epss_percentile": 0.8438}, "CVE-2019-1367": {"epss_score": 0.8969, "epss_percentile": 0.99538}, "CVE-2019-1368": {"epss_score": 0.00936, "epss_percentile": 0.75689}, "CVE-2019-1369": {"epss_score": 0.00576, "epss_percentile": 0.68123}, "CVE-2019-1370": {"epss_score": 0.00639, "epss_percentile": 0.6995}, "CVE-2019-1371": {"epss_score": 0.05399, "epss_percentile": 0.89832}, "CVE-2019-1372": {"epss_score": 0.03273, "epss_percentile": 0.86798}, "CVE-2019-1373": {"epss_score": 0.12497, "epss_percentile": 0.93692}, "CVE-2019-1374": {"epss_score": 0.1377, "epss_percentile": 0.94055}, "CVE-2019-1375": {"epss_score": 0.01111, "epss_percentile": 0.7767}, "CVE-2019-1376": {"epss_score": 0.07937, "epss_percentile": 0.91775}, "CVE-2019-1378": {"epss_score": 0.00127, "epss_percentile": 0.32918}, "CVE-2019-1379": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2019-1380": {"epss_score": 0.0031, "epss_percentile": 0.53792}, "CVE-2019-1381": {"epss_score": 0.0106, "epss_percentile": 0.77165}, "CVE-2019-1382": {"epss_score": 0.00349, "epss_percentile": 0.56895}, "CVE-2019-1383": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2019-1384": {"epss_score": 0.02801, "epss_percentile": 0.85697}, "CVE-2019-1385": {"epss_score": 0.00378, "epss_percentile": 0.58787}, "CVE-2019-1387": {"epss_score": 0.0308, "epss_percentile": 0.86372}, "CVE-2019-1388": {"epss_score": 0.11465, "epss_percentile": 0.93375}, "CVE-2019-1389": {"epss_score": 0.01157, "epss_percentile": 0.78114}, "CVE-2019-1390": {"epss_score": 0.08386, "epss_percentile": 0.9202}, "CVE-2019-1391": {"epss_score": 0.00471, "epss_percentile": 0.6401}, "CVE-2019-1392": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2019-1393": {"epss_score": 0.00504, "epss_percentile": 0.65493}, "CVE-2019-1394": {"epss_score": 0.00504, "epss_percentile": 0.65493}, "CVE-2019-1395": {"epss_score": 0.00504, "epss_percentile": 0.65493}, "CVE-2019-1396": {"epss_score": 0.00504, "epss_percentile": 0.65493}, "CVE-2019-1397": {"epss_score": 0.01157, "epss_percentile": 0.78114}, "CVE-2019-1398": {"epss_score": 0.00854, "epss_percentile": 0.74457}, "CVE-2019-1399": {"epss_score": 0.00616, "epss_percentile": 0.69337}, "CVE-2019-1400": {"epss_score": 0.01654, "epss_percentile": 0.81588}, "CVE-2019-1402": {"epss_score": 0.02122, "epss_percentile": 0.83681}, "CVE-2019-1405": {"epss_score": 0.53613, "epss_percentile": 0.97885}, "CVE-2019-1406": {"epss_score": 0.33652, "epss_percentile": 0.96793}, "CVE-2019-1407": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2019-1408": {"epss_score": 0.00817, "epss_percentile": 0.73841}, "CVE-2019-1409": {"epss_score": 0.00655, "epss_percentile": 0.70428}, "CVE-2019-1411": {"epss_score": 0.26055, "epss_percentile": 0.96106}, "CVE-2019-1412": {"epss_score": 0.0064, "epss_percentile": 0.69971}, "CVE-2019-1413": {"epss_score": 0.02228, "epss_percentile": 0.84077}, "CVE-2019-1414": {"epss_score": 0.00526, "epss_percentile": 0.66398}, "CVE-2019-1415": {"epss_score": 0.0038, "epss_percentile": 0.58931}, "CVE-2019-1416": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2019-1417": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2019-1418": {"epss_score": 0.0141, "epss_percentile": 0.80081}, "CVE-2019-1419": {"epss_score": 0.23721, "epss_percentile": 0.95808}, "CVE-2019-1420": {"epss_score": 0.00386, "epss_percentile": 0.59263}, "CVE-2019-1422": {"epss_score": 0.10472, "epss_percentile": 0.92997}, "CVE-2019-1423": {"epss_score": 0.00323, "epss_percentile": 0.54918}, "CVE-2019-1424": {"epss_score": 0.03229, "epss_percentile": 0.86692}, "CVE-2019-1425": {"epss_score": 0.07567, "epss_percentile": 0.91544}, "CVE-2019-1426": {"epss_score": 0.07127, "epss_percentile": 0.91268}, "CVE-2019-1427": {"epss_score": 0.07127, "epss_percentile": 0.91268}, "CVE-2019-1428": {"epss_score": 0.07127, "epss_percentile": 0.91268}, "CVE-2019-1429": {"epss_score": 0.74474, "epss_percentile": 0.98801}, "CVE-2019-1430": {"epss_score": 0.33652, "epss_percentile": 0.96793}, "CVE-2019-1432": {"epss_score": 0.25898, "epss_percentile": 0.96091}, "CVE-2019-1433": {"epss_score": 0.00404, "epss_percentile": 0.60441}, "CVE-2019-1434": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2019-1435": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2019-1436": {"epss_score": 0.01624, "epss_percentile": 0.81407}, "CVE-2019-1437": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2019-1438": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2019-1439": {"epss_score": 0.3045, "epss_percentile": 0.96541}, "CVE-2019-1440": {"epss_score": 0.01624, "epss_percentile": 0.81407}, "CVE-2019-1441": {"epss_score": 0.20625, "epss_percentile": 0.95387}, "CVE-2019-1442": {"epss_score": 0.07105, "epss_percentile": 0.91255}, "CVE-2019-1443": {"epss_score": 0.15084, "epss_percentile": 0.94359}, "CVE-2019-1445": {"epss_score": 0.00791, "epss_percentile": 0.73389}, "CVE-2019-1446": {"epss_score": 0.09798, "epss_percentile": 0.92707}, "CVE-2019-1447": {"epss_score": 0.00791, "epss_percentile": 0.73389}, "CVE-2019-1448": {"epss_score": 0.38019, "epss_percentile": 0.97082}, "CVE-2019-1449": {"epss_score": 0.0573, "epss_percentile": 0.9016}, "CVE-2019-1453": {"epss_score": 0.10033, "epss_percentile": 0.92822}, "CVE-2019-1454": {"epss_score": 0.00281, "epss_percentile": 0.51131}, "CVE-2019-1456": {"epss_score": 0.14861, "epss_percentile": 0.94304}, "CVE-2019-1457": {"epss_score": 0.07716, "epss_percentile": 0.91641}, "CVE-2019-1458": {"epss_score": 0.92199, "epss_percentile": 0.99699}, "CVE-2019-1460": {"epss_score": 0.0194, "epss_percentile": 0.82978}, "CVE-2019-1461": {"epss_score": 0.16941, "epss_percentile": 0.9475}, "CVE-2019-1462": {"epss_score": 0.21311, "epss_percentile": 0.95499}, "CVE-2019-1463": {"epss_score": 0.01654, "epss_percentile": 0.81588}, "CVE-2019-1464": {"epss_score": 0.13324, "epss_percentile": 0.93934}, "CVE-2019-1465": {"epss_score": 0.26055, "epss_percentile": 0.96106}, "CVE-2019-1466": {"epss_score": 0.26055, "epss_percentile": 0.96106}, "CVE-2019-1467": {"epss_score": 0.13703, "epss_percentile": 0.94038}, "CVE-2019-1468": {"epss_score": 0.20625, "epss_percentile": 0.95387}, "CVE-2019-1469": {"epss_score": 0.0075, "epss_percentile": 0.72624}, "CVE-2019-1470": {"epss_score": 0.00946, "epss_percentile": 0.7581}, "CVE-2019-1471": {"epss_score": 0.01467, "epss_percentile": 0.80473}, "CVE-2019-1472": {"epss_score": 0.01624, "epss_percentile": 0.81407}, "CVE-2019-1474": {"epss_score": 0.01624, "epss_percentile": 0.81407}, "CVE-2019-1476": {"epss_score": 0.14661, "epss_percentile": 0.94259}, "CVE-2019-1477": {"epss_score": 0.00536, "epss_percentile": 0.66846}, "CVE-2019-1478": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2019-1480": {"epss_score": 0.10498, "epss_percentile": 0.9301}, "CVE-2019-1481": {"epss_score": 0.27887, "epss_percentile": 0.96291}, "CVE-2019-1483": {"epss_score": 0.00734, "epss_percentile": 0.72252}, "CVE-2019-1484": {"epss_score": 0.26234, "epss_percentile": 0.96127}, "CVE-2019-1485": {"epss_score": 0.04581, "epss_percentile": 0.88877}, "CVE-2019-1486": {"epss_score": 0.00292, "epss_percentile": 0.52267}, "CVE-2019-1487": {"epss_score": 0.03396, "epss_percentile": 0.8706}, "CVE-2019-1488": {"epss_score": 0.0046, "epss_percentile": 0.63537}, "CVE-2019-1489": {"epss_score": 0.06002, "epss_percentile": 0.90393}, "CVE-2019-1490": {"epss_score": 0.00528, "epss_percentile": 0.66559}, "CVE-2019-1543": {"epss_score": 0.03572, "epss_percentile": 0.87371}, "CVE-2019-1547": {"epss_score": 0.0026, "epss_percentile": 0.49167}, "CVE-2019-1549": {"epss_score": 0.02189, "epss_percentile": 0.8393}, "CVE-2019-1551": {"epss_score": 0.03092, "epss_percentile": 0.86397}, "CVE-2019-1552": {"epss_score": 0.0016, "epss_percentile": 0.37514}, "CVE-2019-1559": {"epss_score": 0.0496, "epss_percentile": 0.89333}, "CVE-2019-1563": {"epss_score": 0.02203, "epss_percentile": 0.83993}, "CVE-2019-1565": {"epss_score": 0.0032, "epss_percentile": 0.54621}, "CVE-2019-1566": {"epss_score": 0.01268, "epss_percentile": 0.79025}, "CVE-2019-1567": {"epss_score": 0.00388, "epss_percentile": 0.59372}, "CVE-2019-1568": {"epss_score": 0.00394, "epss_percentile": 0.59748}, "CVE-2019-1569": {"epss_score": 0.00692, "epss_percentile": 0.71308}, "CVE-2019-1570": {"epss_score": 0.00692, "epss_percentile": 0.71308}, "CVE-2019-1571": {"epss_score": 0.00692, "epss_percentile": 0.71308}, "CVE-2019-1572": {"epss_score": 0.00463, "epss_percentile": 0.63693}, "CVE-2019-1573": {"epss_score": 0.00238, "epss_percentile": 0.46788}, "CVE-2019-1574": {"epss_score": 0.0035, "epss_percentile": 0.56944}, "CVE-2019-1575": {"epss_score": 0.00684, "epss_percentile": 0.71112}, "CVE-2019-1576": {"epss_score": 0.03159, "epss_percentile": 0.86521}, "CVE-2019-1577": {"epss_score": 0.0052, "epss_percentile": 0.66204}, "CVE-2019-1578": {"epss_score": 0.0019, "epss_percentile": 0.41058}, "CVE-2019-1579": {"epss_score": 0.93028, "epss_percentile": 0.99768}, "CVE-2019-1580": {"epss_score": 0.02201, "epss_percentile": 0.83979}, "CVE-2019-1581": {"epss_score": 0.04072, "epss_percentile": 0.88206}, "CVE-2019-1582": {"epss_score": 0.00542, "epss_percentile": 0.67067}, "CVE-2019-1583": {"epss_score": 0.00411, "epss_percentile": 0.6088}, "CVE-2019-1584": {"epss_score": 0.02357, "epss_percentile": 0.84486}, "CVE-2019-1585": {"epss_score": 0.00187, "epss_percentile": 0.40759}, "CVE-2019-1586": {"epss_score": 0.00045, "epss_percentile": 0.13729}, "CVE-2019-1587": {"epss_score": 0.00392, "epss_percentile": 0.5966}, "CVE-2019-1588": {"epss_score": 0.00183, "epss_percentile": 0.40356}, "CVE-2019-1589": {"epss_score": 0.00043, "epss_percentile": 0.13011}, "CVE-2019-1590": {"epss_score": 0.00684, "epss_percentile": 0.71109}, "CVE-2019-1591": {"epss_score": 0.00237, "epss_percentile": 0.46659}, "CVE-2019-1592": {"epss_score": 0.00232, "epss_percentile": 0.45967}, "CVE-2019-1593": {"epss_score": 0.00148, "epss_percentile": 0.35931}, "CVE-2019-1594": {"epss_score": 0.0072, "epss_percentile": 0.71956}, "CVE-2019-1595": {"epss_score": 0.0043, "epss_percentile": 0.62027}, "CVE-2019-1596": {"epss_score": 0.00151, "epss_percentile": 0.36185}, "CVE-2019-1597": {"epss_score": 0.02348, "epss_percentile": 0.84463}, "CVE-2019-1598": {"epss_score": 0.02348, "epss_percentile": 0.84463}, "CVE-2019-1599": {"epss_score": 0.05861, "epss_percentile": 0.9027}, "CVE-2019-1600": {"epss_score": 0.00128, "epss_percentile": 0.33064}, "CVE-2019-1601": {"epss_score": 0.00066, "epss_percentile": 0.20929}, "CVE-2019-1602": {"epss_score": 0.00239, "epss_percentile": 0.46857}, "CVE-2019-1603": {"epss_score": 0.00216, "epss_percentile": 0.44172}, "CVE-2019-1604": {"epss_score": 0.00277, "epss_percentile": 0.50807}, "CVE-2019-1605": {"epss_score": 0.0019, "epss_percentile": 0.41056}, "CVE-2019-1606": {"epss_score": 0.00161, "epss_percentile": 0.37526}, "CVE-2019-1607": {"epss_score": 0.00115, "epss_percentile": 0.30885}, "CVE-2019-1608": {"epss_score": 0.00084, "epss_percentile": 0.2498}, "CVE-2019-1609": {"epss_score": 0.0027, "epss_percentile": 0.50211}, "CVE-2019-1610": {"epss_score": 0.00084, "epss_percentile": 0.2498}, "CVE-2019-1611": {"epss_score": 0.00084, "epss_percentile": 0.2498}, "CVE-2019-1612": {"epss_score": 0.00084, "epss_percentile": 0.2498}, "CVE-2019-1613": {"epss_score": 0.00062, "epss_percentile": 0.197}, "CVE-2019-1614": {"epss_score": 0.01897, "epss_percentile": 0.82758}, "CVE-2019-1615": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2019-1616": {"epss_score": 0.00818, "epss_percentile": 0.73851}, "CVE-2019-1617": {"epss_score": 0.00317, "epss_percentile": 0.54345}, "CVE-2019-1618": {"epss_score": 0.00188, "epss_percentile": 0.40902}, "CVE-2019-1619": {"epss_score": 0.7169, "epss_percentile": 0.98677}, "CVE-2019-1620": {"epss_score": 0.86022, "epss_percentile": 0.99362}, "CVE-2019-1621": {"epss_score": 0.63694, "epss_percentile": 0.98345}, "CVE-2019-1622": {"epss_score": 0.85997, "epss_percentile": 0.99361}, "CVE-2019-1623": {"epss_score": 0.00112, "epss_percentile": 0.30566}, "CVE-2019-1624": {"epss_score": 0.0151, "epss_percentile": 0.80769}, "CVE-2019-1625": {"epss_score": 0.00063, "epss_percentile": 0.19885}, "CVE-2019-1626": {"epss_score": 0.00428, "epss_percentile": 0.6194}, "CVE-2019-1627": {"epss_score": 0.00147, "epss_percentile": 0.35703}, "CVE-2019-1628": {"epss_score": 0.00146, "epss_percentile": 0.35555}, "CVE-2019-1629": {"epss_score": 0.00375, "epss_percentile": 0.58632}, "CVE-2019-1630": {"epss_score": 0.0007, "epss_percentile": 0.21948}, "CVE-2019-1631": {"epss_score": 0.00879, "epss_percentile": 0.74841}, "CVE-2019-1632": {"epss_score": 0.00076, "epss_percentile": 0.23128}, "CVE-2019-1634": {"epss_score": 0.01527, "epss_percentile": 0.80869}, "CVE-2019-1635": {"epss_score": 0.00977, "epss_percentile": 0.76232}, "CVE-2019-1636": {"epss_score": 0.06266, "epss_percentile": 0.90624}, "CVE-2019-1637": {"epss_score": 0.00301, "epss_percentile": 0.53054}, "CVE-2019-1638": {"epss_score": 0.00301, "epss_percentile": 0.53054}, "CVE-2019-1639": {"epss_score": 0.00301, "epss_percentile": 0.53054}, "CVE-2019-1640": {"epss_score": 0.00301, "epss_percentile": 0.53054}, "CVE-2019-1641": {"epss_score": 0.00301, "epss_percentile": 0.53054}, "CVE-2019-1642": {"epss_score": 0.0101, "epss_percentile": 0.76597}, "CVE-2019-1643": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2019-1644": {"epss_score": 0.01283, "epss_percentile": 0.79162}, "CVE-2019-1645": {"epss_score": 0.00075, "epss_percentile": 0.22972}, "CVE-2019-1646": {"epss_score": 0.00098, "epss_percentile": 0.2769}, "CVE-2019-1647": {"epss_score": 0.00853, "epss_percentile": 0.74426}, "CVE-2019-1648": {"epss_score": 0.00063, "epss_percentile": 0.19885}, "CVE-2019-1649": {"epss_score": 0.00237, "epss_percentile": 0.46686}, "CVE-2019-1650": {"epss_score": 0.0131, "epss_percentile": 0.79358}, "CVE-2019-1651": {"epss_score": 0.02083, "epss_percentile": 0.83541}, "CVE-2019-1652": {"epss_score": 0.92947, "epss_percentile": 0.99763}, "CVE-2019-1653": {"epss_score": 0.94378, "epss_percentile": 0.99963}, "CVE-2019-1654": {"epss_score": 0.00205, "epss_percentile": 0.42709}, "CVE-2019-1655": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2019-1656": {"epss_score": 0.00037, "epss_percentile": 0.10672}, "CVE-2019-1657": {"epss_score": 0.00173, "epss_percentile": 0.39042}, "CVE-2019-1658": {"epss_score": 0.00161, "epss_percentile": 0.37577}, "CVE-2019-1659": {"epss_score": 0.0019, "epss_percentile": 0.41007}, "CVE-2019-1660": {"epss_score": 0.01589, "epss_percentile": 0.81192}, "CVE-2019-1661": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2019-1662": {"epss_score": 0.01429, "epss_percentile": 0.80228}, "CVE-2019-1663": {"epss_score": 0.86932, "epss_percentile": 0.99404}, "CVE-2019-1664": {"epss_score": 0.00398, "epss_percentile": 0.60067}, "CVE-2019-1665": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2019-1666": {"epss_score": 0.01589, "epss_percentile": 0.81192}, "CVE-2019-1667": {"epss_score": 0.00028, "epss_percentile": 0.07531}, "CVE-2019-1668": {"epss_score": 0.00278, "epss_percentile": 0.5092}, "CVE-2019-1669": {"epss_score": 0.00558, "epss_percentile": 0.67576}, "CVE-2019-1670": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2019-1671": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2019-1672": {"epss_score": 0.00175, "epss_percentile": 0.39322}, "CVE-2019-1673": {"epss_score": 0.00195, "epss_percentile": 0.41641}, "CVE-2019-1674": {"epss_score": 0.36018, "epss_percentile": 0.9695}, "CVE-2019-1675": {"epss_score": 0.00965, "epss_percentile": 0.7604}, "CVE-2019-1676": {"epss_score": 0.00395, "epss_percentile": 0.59809}, "CVE-2019-1677": {"epss_score": 0.0006, "epss_percentile": 0.19154}, "CVE-2019-1678": {"epss_score": 0.00878, "epss_percentile": 0.74831}, "CVE-2019-1679": {"epss_score": 0.00136, "epss_percentile": 0.34116}, "CVE-2019-1680": {"epss_score": 0.00259, "epss_percentile": 0.49078}, "CVE-2019-1681": {"epss_score": 0.10523, "epss_percentile": 0.93018}, "CVE-2019-1682": {"epss_score": 0.00043, "epss_percentile": 0.13211}, "CVE-2019-1683": {"epss_score": 0.00167, "epss_percentile": 0.38338}, "CVE-2019-1684": {"epss_score": 0.00145, "epss_percentile": 0.35505}, "CVE-2019-1685": {"epss_score": 0.00136, "epss_percentile": 0.34104}, "CVE-2019-1686": {"epss_score": 0.0019, "epss_percentile": 0.41074}, "CVE-2019-1687": {"epss_score": 0.00211, "epss_percentile": 0.43677}, "CVE-2019-1688": {"epss_score": 0.00842, "epss_percentile": 0.74239}, "CVE-2019-1689": {"epss_score": 0.00337, "epss_percentile": 0.56038}, "CVE-2019-1690": {"epss_score": 0.00106, "epss_percentile": 0.29425}, "CVE-2019-1691": {"epss_score": 0.00454, "epss_percentile": 0.63242}, "CVE-2019-1692": {"epss_score": 0.00313, "epss_percentile": 0.5403}, "CVE-2019-1693": {"epss_score": 0.00418, "epss_percentile": 0.61346}, "CVE-2019-1694": {"epss_score": 0.00941, "epss_percentile": 0.75753}, "CVE-2019-1695": {"epss_score": 0.00056, "epss_percentile": 0.17782}, "CVE-2019-1696": {"epss_score": 0.00721, "epss_percentile": 0.7197}, "CVE-2019-1697": {"epss_score": 0.00497, "epss_percentile": 0.65177}, "CVE-2019-1698": {"epss_score": 0.00671, "epss_percentile": 0.70803}, "CVE-2019-1699": {"epss_score": 0.00146, "epss_percentile": 0.35602}, "CVE-2019-1700": {"epss_score": 0.00145, "epss_percentile": 0.35505}, "CVE-2019-1701": {"epss_score": 0.00155, "epss_percentile": 0.36817}, "CVE-2019-1702": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2019-1703": {"epss_score": 0.00496, "epss_percentile": 0.65142}, "CVE-2019-1704": {"epss_score": 0.00694, "epss_percentile": 0.71338}, "CVE-2019-1705": {"epss_score": 0.00443, "epss_percentile": 0.62792}, "CVE-2019-1706": {"epss_score": 0.00459, "epss_percentile": 0.63458}, "CVE-2019-1707": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2019-1708": {"epss_score": 0.00941, "epss_percentile": 0.75753}, "CVE-2019-1709": {"epss_score": 0.00081, "epss_percentile": 0.24279}, "CVE-2019-1710": {"epss_score": 0.0188, "epss_percentile": 0.82683}, "CVE-2019-1711": {"epss_score": 0.0068, "epss_percentile": 0.71027}, "CVE-2019-1712": {"epss_score": 0.00542, "epss_percentile": 0.67082}, "CVE-2019-1713": {"epss_score": 0.00248, "epss_percentile": 0.47967}, "CVE-2019-1714": {"epss_score": 0.01652, "epss_percentile": 0.81577}, "CVE-2019-1715": {"epss_score": 0.00399, "epss_percentile": 0.60145}, "CVE-2019-1716": {"epss_score": 0.07273, "epss_percentile": 0.91376}, "CVE-2019-1717": {"epss_score": 0.02842, "epss_percentile": 0.85808}, "CVE-2019-1718": {"epss_score": 0.0045, "epss_percentile": 0.63095}, "CVE-2019-1719": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2019-1720": {"epss_score": 0.00316, "epss_percentile": 0.54275}, "CVE-2019-1721": {"epss_score": 0.01117, "epss_percentile": 0.7774}, "CVE-2019-1722": {"epss_score": 0.00119, "epss_percentile": 0.31556}, "CVE-2019-1723": {"epss_score": 0.24997, "epss_percentile": 0.95976}, "CVE-2019-1724": {"epss_score": 0.00225, "epss_percentile": 0.45107}, "CVE-2019-1725": {"epss_score": 0.0007, "epss_percentile": 0.21943}, "CVE-2019-1726": {"epss_score": 0.00042, "epss_percentile": 0.12925}, "CVE-2019-1727": {"epss_score": 0.00099, "epss_percentile": 0.27868}, "CVE-2019-1728": {"epss_score": 0.0011, "epss_percentile": 0.30077}, "CVE-2019-1729": {"epss_score": 0.00098, "epss_percentile": 0.27763}, "CVE-2019-1730": {"epss_score": 0.00052, "epss_percentile": 0.16482}, "CVE-2019-1731": {"epss_score": 0.00179, "epss_percentile": 0.39836}, "CVE-2019-1732": {"epss_score": 0.00172, "epss_percentile": 0.38946}, "CVE-2019-1733": {"epss_score": 0.00311, "epss_percentile": 0.53921}, "CVE-2019-1734": {"epss_score": 0.002, "epss_percentile": 0.42204}, "CVE-2019-1735": {"epss_score": 0.00095, "epss_percentile": 0.27119}, "CVE-2019-1736": {"epss_score": 0.00033, "epss_percentile": 0.09198}, "CVE-2019-1737": {"epss_score": 0.00978, "epss_percentile": 0.76238}, "CVE-2019-1738": {"epss_score": 0.02348, "epss_percentile": 0.84463}, "CVE-2019-1739": {"epss_score": 0.02348, "epss_percentile": 0.84463}, "CVE-2019-1740": {"epss_score": 0.00889, "epss_percentile": 0.75013}, "CVE-2019-1741": {"epss_score": 0.00978, "epss_percentile": 0.76238}, "CVE-2019-1742": {"epss_score": 0.00969, "epss_percentile": 0.7609}, "CVE-2019-1743": {"epss_score": 0.00715, "epss_percentile": 0.71835}, "CVE-2019-1745": {"epss_score": 0.0009, "epss_percentile": 0.25988}, "CVE-2019-1746": {"epss_score": 0.00145, "epss_percentile": 0.35505}, "CVE-2019-1747": {"epss_score": 0.01283, "epss_percentile": 0.79162}, "CVE-2019-1748": {"epss_score": 0.00269, "epss_percentile": 0.50108}, "CVE-2019-1749": {"epss_score": 0.00378, "epss_percentile": 0.58807}, "CVE-2019-1750": {"epss_score": 0.00145, "epss_percentile": 0.35505}, "CVE-2019-1751": {"epss_score": 0.00941, "epss_percentile": 0.75753}, "CVE-2019-1752": {"epss_score": 0.01343, "epss_percentile": 0.79603}, "CVE-2019-1753": {"epss_score": 0.01379, "epss_percentile": 0.79855}, "CVE-2019-1754": {"epss_score": 0.01003, "epss_percentile": 0.76519}, "CVE-2019-1755": {"epss_score": 0.00329, "epss_percentile": 0.55397}, "CVE-2019-1756": {"epss_score": 0.00675, "epss_percentile": 0.7089}, "CVE-2019-1757": {"epss_score": 0.00328, "epss_percentile": 0.55287}, "CVE-2019-1758": {"epss_score": 0.0022, "epss_percentile": 0.44596}, "CVE-2019-1759": {"epss_score": 0.28477, "epss_percentile": 0.96361}, "CVE-2019-1760": {"epss_score": 0.00374, "epss_percentile": 0.58539}, "CVE-2019-1761": {"epss_score": 0.00074, "epss_percentile": 0.22764}, "CVE-2019-1762": {"epss_score": 0.00023, "epss_percentile": 0.05625}, "CVE-2019-1763": {"epss_score": 0.0113, "epss_percentile": 0.7785}, "CVE-2019-1764": {"epss_score": 0.00189, "epss_percentile": 0.41}, "CVE-2019-1765": {"epss_score": 0.00131, "epss_percentile": 0.33392}, "CVE-2019-1766": {"epss_score": 0.0271, "epss_percentile": 0.85492}, "CVE-2019-1767": {"epss_score": 0.00135, "epss_percentile": 0.3399}, "CVE-2019-1768": {"epss_score": 0.00135, "epss_percentile": 0.3399}, "CVE-2019-1769": {"epss_score": 0.00084, "epss_percentile": 0.24987}, "CVE-2019-1770": {"epss_score": 0.00035, "epss_percentile": 0.10115}, "CVE-2019-1771": {"epss_score": 0.00116, "epss_percentile": 0.31108}, "CVE-2019-1772": {"epss_score": 0.00274, "epss_percentile": 0.50566}, "CVE-2019-1773": {"epss_score": 0.00274, "epss_percentile": 0.50566}, "CVE-2019-1774": {"epss_score": 0.00115, "epss_percentile": 0.30898}, "CVE-2019-1775": {"epss_score": 0.00115, "epss_percentile": 0.30898}, "CVE-2019-1776": {"epss_score": 0.00115, "epss_percentile": 0.30898}, "CVE-2019-1777": {"epss_score": 0.00171, "epss_percentile": 0.38881}, "CVE-2019-1778": {"epss_score": 0.00115, "epss_percentile": 0.30898}, "CVE-2019-1779": {"epss_score": 0.00087, "epss_percentile": 0.25598}, "CVE-2019-1780": {"epss_score": 0.00064, "epss_percentile": 0.20381}, "CVE-2019-1781": {"epss_score": 0.00115, "epss_percentile": 0.30898}, "CVE-2019-1782": {"epss_score": 0.00115, "epss_percentile": 0.30898}, "CVE-2019-1783": {"epss_score": 0.00084, "epss_percentile": 0.24987}, "CVE-2019-1784": {"epss_score": 0.00115, "epss_percentile": 0.30898}, "CVE-2019-1785": {"epss_score": 0.00554, "epss_percentile": 0.67454}, "CVE-2019-1786": {"epss_score": 0.05795, "epss_percentile": 0.90216}, "CVE-2019-1787": {"epss_score": 0.08108, "epss_percentile": 0.91883}, "CVE-2019-1788": {"epss_score": 0.10422, "epss_percentile": 0.92983}, "CVE-2019-1789": {"epss_score": 0.00679, "epss_percentile": 0.71023}, "CVE-2019-1790": {"epss_score": 0.00115, "epss_percentile": 0.30898}, "CVE-2019-1791": {"epss_score": 0.00076, "epss_percentile": 0.23103}, "CVE-2019-1792": {"epss_score": 0.00136, "epss_percentile": 0.34104}, "CVE-2019-1794": {"epss_score": 0.00066, "epss_percentile": 0.20702}, "CVE-2019-1795": {"epss_score": 0.00115, "epss_percentile": 0.30898}, "CVE-2019-1796": {"epss_score": 0.00145, "epss_percentile": 0.35505}, "CVE-2019-1797": {"epss_score": 0.00187, "epss_percentile": 0.40769}, "CVE-2019-1798": {"epss_score": 0.02451, "epss_percentile": 0.84785}, "CVE-2019-1799": {"epss_score": 0.00145, "epss_percentile": 0.35505}, "CVE-2019-1800": {"epss_score": 0.00145, "epss_percentile": 0.35505}, "CVE-2019-1802": {"epss_score": 0.00176, "epss_percentile": 0.39391}, "CVE-2019-1803": {"epss_score": 0.00028, "epss_percentile": 0.07524}, "CVE-2019-1804": {"epss_score": 0.07201, "epss_percentile": 0.91318}, "CVE-2019-1805": {"epss_score": 0.00093, "epss_percentile": 0.26714}, "CVE-2019-1806": {"epss_score": 0.00877, "epss_percentile": 0.74806}, "CVE-2019-1807": {"epss_score": 0.00419, "epss_percentile": 0.61357}, "CVE-2019-1808": {"epss_score": 0.00086, "epss_percentile": 0.25384}, "CVE-2019-1809": {"epss_score": 0.00023, "epss_percentile": 0.05443}, "CVE-2019-1810": {"epss_score": 0.00077, "epss_percentile": 0.23463}, "CVE-2019-1811": {"epss_score": 0.00073, "epss_percentile": 0.22647}, "CVE-2019-1812": {"epss_score": 0.0007, "epss_percentile": 0.21814}, "CVE-2019-1813": {"epss_score": 0.0007, "epss_percentile": 0.21814}, "CVE-2019-1814": {"epss_score": 0.00334, "epss_percentile": 0.55695}, "CVE-2019-1815": {"epss_score": 0.00102, "epss_percentile": 0.28768}, "CVE-2019-1816": {"epss_score": 0.0007, "epss_percentile": 0.21753}, "CVE-2019-1817": {"epss_score": 0.0065, "epss_percentile": 0.70269}, "CVE-2019-1818": {"epss_score": 0.13887, "epss_percentile": 0.94087}, "CVE-2019-1819": {"epss_score": 0.13887, "epss_percentile": 0.94087}, "CVE-2019-1820": {"epss_score": 0.13887, "epss_percentile": 0.94087}, "CVE-2019-1821": {"epss_score": 0.94044, "epss_percentile": 0.99891}, "CVE-2019-1822": {"epss_score": 0.02953, "epss_percentile": 0.86057}, "CVE-2019-1823": {"epss_score": 0.02042, "epss_percentile": 0.83374}, "CVE-2019-1824": {"epss_score": 0.00317, "epss_percentile": 0.54346}, "CVE-2019-1825": {"epss_score": 0.00317, "epss_percentile": 0.54346}, "CVE-2019-1826": {"epss_score": 0.00132, "epss_percentile": 0.33574}, "CVE-2019-1827": {"epss_score": 0.00247, "epss_percentile": 0.47858}, "CVE-2019-1828": {"epss_score": 0.00063, "epss_percentile": 0.19808}, "CVE-2019-1829": {"epss_score": 0.00343, "epss_percentile": 0.56459}, "CVE-2019-1830": {"epss_score": 0.00169, "epss_percentile": 0.38537}, "CVE-2019-1831": {"epss_score": 0.00156, "epss_percentile": 0.3689}, "CVE-2019-1832": {"epss_score": 0.00115, "epss_percentile": 0.30881}, "CVE-2019-1833": {"epss_score": 0.00246, "epss_percentile": 0.47806}, "CVE-2019-1834": {"epss_score": 0.00186, "epss_percentile": 0.40591}, "CVE-2019-1835": {"epss_score": 0.00077, "epss_percentile": 0.23458}, "CVE-2019-1836": {"epss_score": 0.00196, "epss_percentile": 0.4176}, "CVE-2019-1837": {"epss_score": 0.00286, "epss_percentile": 0.51742}, "CVE-2019-1838": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2019-1839": {"epss_score": 0.001, "epss_percentile": 0.28532}, "CVE-2019-1840": {"epss_score": 0.00527, "epss_percentile": 0.66446}, "CVE-2019-1841": {"epss_score": 0.01152, "epss_percentile": 0.78051}, "CVE-2019-1842": {"epss_score": 0.00267, "epss_percentile": 0.49985}, "CVE-2019-1843": {"epss_score": 0.00416, "epss_percentile": 0.61163}, "CVE-2019-1844": {"epss_score": 0.00216, "epss_percentile": 0.44201}, "CVE-2019-1845": {"epss_score": 0.09319, "epss_percentile": 0.92499}, "CVE-2019-1846": {"epss_score": 0.00145, "epss_percentile": 0.35505}, "CVE-2019-1848": {"epss_score": 0.00371, "epss_percentile": 0.58357}, "CVE-2019-1849": {"epss_score": 0.00128, "epss_percentile": 0.32964}, "CVE-2019-1850": {"epss_score": 0.01223, "epss_percentile": 0.7867}, "CVE-2019-1851": {"epss_score": 0.00116, "epss_percentile": 0.31096}, "CVE-2019-1852": {"epss_score": 0.00179, "epss_percentile": 0.39806}, "CVE-2019-1853": {"epss_score": 0.00603, "epss_percentile": 0.68899}, "CVE-2019-1854": {"epss_score": 0.0005, "epss_percentile": 0.15967}, "CVE-2019-1855": {"epss_score": 0.00696, "epss_percentile": 0.71395}, "CVE-2019-1856": {"epss_score": 0.00179, "epss_percentile": 0.39806}, "CVE-2019-1857": {"epss_score": 0.00094, "epss_percentile": 0.26969}, "CVE-2019-1858": {"epss_score": 0.02994, "epss_percentile": 0.86151}, "CVE-2019-1859": {"epss_score": 0.0018, "epss_percentile": 0.39935}, "CVE-2019-1860": {"epss_score": 0.0027, "epss_percentile": 0.50224}, "CVE-2019-1861": {"epss_score": 0.0229, "epss_percentile": 0.84277}, "CVE-2019-1862": {"epss_score": 0.00979, "epss_percentile": 0.76257}, "CVE-2019-1863": {"epss_score": 0.00071, "epss_percentile": 0.22234}, "CVE-2019-1864": {"epss_score": 0.01394, "epss_percentile": 0.79968}, "CVE-2019-1865": {"epss_score": 0.01394, "epss_percentile": 0.79968}, "CVE-2019-1866": {"epss_score": 0.00125, "epss_percentile": 0.32474}, "CVE-2019-1867": {"epss_score": 0.2179, "epss_percentile": 0.9556}, "CVE-2019-1868": {"epss_score": 0.00496, "epss_percentile": 0.65167}, "CVE-2019-1869": {"epss_score": 0.01255, "epss_percentile": 0.78926}, "CVE-2019-1870": {"epss_score": 0.00124, "epss_percentile": 0.3243}, "CVE-2019-1871": {"epss_score": 0.01226, "epss_percentile": 0.78689}, "CVE-2019-1872": {"epss_score": 0.00375, "epss_percentile": 0.58632}, "CVE-2019-1873": {"epss_score": 0.00543, "epss_percentile": 0.67109}, "CVE-2019-1874": {"epss_score": 0.00676, "epss_percentile": 0.70926}, "CVE-2019-1875": {"epss_score": 0.00155, "epss_percentile": 0.36817}, "CVE-2019-1876": {"epss_score": 0.01967, "epss_percentile": 0.83085}, "CVE-2019-1877": {"epss_score": 0.01282, "epss_percentile": 0.79149}, "CVE-2019-1878": {"epss_score": 0.00215, "epss_percentile": 0.44111}, "CVE-2019-1879": {"epss_score": 0.00057, "epss_percentile": 0.18112}, "CVE-2019-1880": {"epss_score": 0.00025, "epss_percentile": 0.06343}, "CVE-2019-1881": {"epss_score": 0.00404, "epss_percentile": 0.6043}, "CVE-2019-1882": {"epss_score": 0.00179, "epss_percentile": 0.39787}, "CVE-2019-1883": {"epss_score": 0.00144, "epss_percentile": 0.3527}, "CVE-2019-1884": {"epss_score": 0.00356, "epss_percentile": 0.57354}, "CVE-2019-1885": {"epss_score": 0.00958, "epss_percentile": 0.75948}, "CVE-2019-1886": {"epss_score": 0.0085, "epss_percentile": 0.74393}, "CVE-2019-1887": {"epss_score": 0.00752, "epss_percentile": 0.7266}, "CVE-2019-1888": {"epss_score": 0.01464, "epss_percentile": 0.80447}, "CVE-2019-1889": {"epss_score": 0.01234, "epss_percentile": 0.7876}, "CVE-2019-1890": {"epss_score": 0.00098, "epss_percentile": 0.27799}, "CVE-2019-1891": {"epss_score": 0.00671, "epss_percentile": 0.70792}, "CVE-2019-1892": {"epss_score": 0.00671, "epss_percentile": 0.70792}, "CVE-2019-1893": {"epss_score": 0.00137, "epss_percentile": 0.34227}, "CVE-2019-1894": {"epss_score": 0.02549, "epss_percentile": 0.8507}, "CVE-2019-1895": {"epss_score": 0.02382, "epss_percentile": 0.84567}, "CVE-2019-1896": {"epss_score": 0.00776, "epss_percentile": 0.73098}, "CVE-2019-1897": {"epss_score": 0.05537, "epss_percentile": 0.89973}, "CVE-2019-1898": {"epss_score": 0.73548, "epss_percentile": 0.98761}, "CVE-2019-1899": {"epss_score": 0.01716, "epss_percentile": 0.81904}, "CVE-2019-1900": {"epss_score": 0.00268, "epss_percentile": 0.50088}, "CVE-2019-1901": {"epss_score": 0.00248, "epss_percentile": 0.47917}, "CVE-2019-1903": {"epss_score": 0.00839, "epss_percentile": 0.74188}, "CVE-2019-1904": {"epss_score": 0.00594, "epss_percentile": 0.68667}, "CVE-2019-1905": {"epss_score": 0.00152, "epss_percentile": 0.36393}, "CVE-2019-1906": {"epss_score": 0.00127, "epss_percentile": 0.32878}, "CVE-2019-1907": {"epss_score": 0.00149, "epss_percentile": 0.35982}, "CVE-2019-1908": {"epss_score": 0.01041, "epss_percentile": 0.7697}, "CVE-2019-1909": {"epss_score": 0.00527, "epss_percentile": 0.66465}, "CVE-2019-1910": {"epss_score": 0.00152, "epss_percentile": 0.36443}, "CVE-2019-1911": {"epss_score": 0.00055, "epss_percentile": 0.17405}, "CVE-2019-1912": {"epss_score": 0.14063, "epss_percentile": 0.94127}, "CVE-2019-1913": {"epss_score": 0.12717, "epss_percentile": 0.93757}, "CVE-2019-1914": {"epss_score": 0.0235, "epss_percentile": 0.84468}, "CVE-2019-1915": {"epss_score": 0.00184, "epss_percentile": 0.40387}, "CVE-2019-1917": {"epss_score": 0.14369, "epss_percentile": 0.94195}, "CVE-2019-1918": {"epss_score": 0.00103, "epss_percentile": 0.2909}, "CVE-2019-1919": {"epss_score": 0.00127, "epss_percentile": 0.32874}, "CVE-2019-1920": {"epss_score": 0.00921, "epss_percentile": 0.7548}, "CVE-2019-1921": {"epss_score": 0.0022, "epss_percentile": 0.44569}, "CVE-2019-1922": {"epss_score": 0.00783, "epss_percentile": 0.73221}, "CVE-2019-1923": {"epss_score": 0.00206, "epss_percentile": 0.42943}, "CVE-2019-1924": {"epss_score": 0.00301, "epss_percentile": 0.53054}, "CVE-2019-1925": {"epss_score": 0.00301, "epss_percentile": 0.53054}, "CVE-2019-1926": {"epss_score": 0.00301, "epss_percentile": 0.53054}, "CVE-2019-1927": {"epss_score": 0.00301, "epss_percentile": 0.53054}, "CVE-2019-1928": {"epss_score": 0.00301, "epss_percentile": 0.53054}, "CVE-2019-1929": {"epss_score": 0.00301, "epss_percentile": 0.53054}, "CVE-2019-1930": {"epss_score": 0.00136, "epss_percentile": 0.34115}, "CVE-2019-1931": {"epss_score": 0.00136, "epss_percentile": 0.34115}, "CVE-2019-1932": {"epss_score": 0.00026, "epss_percentile": 0.06456}, "CVE-2019-1933": {"epss_score": 0.0022, "epss_percentile": 0.44569}, "CVE-2019-1934": {"epss_score": 0.00385, "epss_percentile": 0.59202}, "CVE-2019-1935": {"epss_score": 0.89105, "epss_percentile": 0.99508}, "CVE-2019-1936": {"epss_score": 0.62361, "epss_percentile": 0.98289}, "CVE-2019-1937": {"epss_score": 0.90896, "epss_percentile": 0.99607}, "CVE-2019-1938": {"epss_score": 0.02549, "epss_percentile": 0.85072}, "CVE-2019-1939": {"epss_score": 0.02803, "epss_percentile": 0.85702}, "CVE-2019-1940": {"epss_score": 0.00113, "epss_percentile": 0.30652}, "CVE-2019-1941": {"epss_score": 0.00381, "epss_percentile": 0.59003}, "CVE-2019-1942": {"epss_score": 0.00172, "epss_percentile": 0.39036}, "CVE-2019-1943": {"epss_score": 0.22946, "epss_percentile": 0.95709}, "CVE-2019-1944": {"epss_score": 0.00047, "epss_percentile": 0.14615}, "CVE-2019-1945": {"epss_score": 0.00055, "epss_percentile": 0.17367}, "CVE-2019-1946": {"epss_score": 0.00302, "epss_percentile": 0.53092}, "CVE-2019-1947": {"epss_score": 0.02174, "epss_percentile": 0.83879}, "CVE-2019-1948": {"epss_score": 0.00111, "epss_percentile": 0.30302}, "CVE-2019-1949": {"epss_score": 0.0017, "epss_percentile": 0.38656}, "CVE-2019-1950": {"epss_score": 0.00385, "epss_percentile": 0.59192}, "CVE-2019-1951": {"epss_score": 0.00279, "epss_percentile": 0.50973}, "CVE-2019-1952": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2019-1953": {"epss_score": 0.00201, "epss_percentile": 0.42382}, "CVE-2019-1954": {"epss_score": 0.00249, "epss_percentile": 0.4804}, "CVE-2019-1955": {"epss_score": 0.0022, "epss_percentile": 0.44569}, "CVE-2019-1956": {"epss_score": 0.0017, "epss_percentile": 0.38656}, "CVE-2019-1957": {"epss_score": 0.00517, "epss_percentile": 0.66065}, "CVE-2019-1958": {"epss_score": 0.00242, "epss_percentile": 0.47408}, "CVE-2019-1959": {"epss_score": 0.00115, "epss_percentile": 0.30937}, "CVE-2019-1960": {"epss_score": 0.00115, "epss_percentile": 0.30937}, "CVE-2019-1961": {"epss_score": 0.00314, "epss_percentile": 0.54154}, "CVE-2019-1962": {"epss_score": 0.01447, "epss_percentile": 0.80333}, "CVE-2019-1963": {"epss_score": 0.00877, "epss_percentile": 0.74806}, "CVE-2019-1964": {"epss_score": 0.01447, "epss_percentile": 0.80333}, "CVE-2019-1965": {"epss_score": 0.00995, "epss_percentile": 0.76433}, "CVE-2019-1966": {"epss_score": 0.00232, "epss_percentile": 0.45967}, "CVE-2019-1967": {"epss_score": 0.02573, "epss_percentile": 0.85137}, "CVE-2019-1968": {"epss_score": 0.00436, "epss_percentile": 0.62469}, "CVE-2019-1969": {"epss_score": 0.00704, "epss_percentile": 0.71569}, "CVE-2019-1970": {"epss_score": 0.00088, "epss_percentile": 0.25735}, "CVE-2019-1971": {"epss_score": 0.01399, "epss_percentile": 0.79997}, "CVE-2019-1972": {"epss_score": 0.0003, "epss_percentile": 0.08071}, "CVE-2019-1973": {"epss_score": 0.0017, "epss_percentile": 0.38656}, "CVE-2019-1974": {"epss_score": 0.11595, "epss_percentile": 0.93414}, "CVE-2019-1975": {"epss_score": 0.00472, "epss_percentile": 0.64072}, "CVE-2019-1976": {"epss_score": 0.00472, "epss_percentile": 0.64055}, "CVE-2019-1977": {"epss_score": 0.00947, "epss_percentile": 0.75815}, "CVE-2019-1978": {"epss_score": 0.40159, "epss_percentile": 0.97201}, "CVE-2019-1980": {"epss_score": 0.00289, "epss_percentile": 0.52031}, "CVE-2019-1981": {"epss_score": 0.00405, "epss_percentile": 0.60461}, "CVE-2019-1982": {"epss_score": 0.00289, "epss_percentile": 0.52031}, "CVE-2019-1983": {"epss_score": 0.0107, "epss_percentile": 0.77258}, "CVE-2019-1984": {"epss_score": 0.00935, "epss_percentile": 0.75664}, "CVE-2019-1985": {"epss_score": 0.00015, "epss_percentile": 0.02281}, "CVE-2019-1986": {"epss_score": 0.00343, "epss_percentile": 0.56439}, "CVE-2019-1987": {"epss_score": 0.00164, "epss_percentile": 0.38003}, "CVE-2019-1988": {"epss_score": 0.00481, "epss_percentile": 0.64494}, "CVE-2019-1989": {"epss_score": 0.01673, "epss_percentile": 0.81684}, "CVE-2019-1990": {"epss_score": 0.01673, "epss_percentile": 0.81684}, "CVE-2019-1991": {"epss_score": 0.01005, "epss_percentile": 0.76539}, "CVE-2019-1992": {"epss_score": 0.00756, "epss_percentile": 0.72732}, "CVE-2019-1993": {"epss_score": 0.00018, "epss_percentile": 0.03882}, "CVE-2019-1994": {"epss_score": 0.00142, "epss_percentile": 0.34954}, "CVE-2019-1995": {"epss_score": 0.00024, "epss_percentile": 0.05802}, "CVE-2019-1996": {"epss_score": 0.00164, "epss_percentile": 0.37938}, "CVE-2019-1997": {"epss_score": 0.00175, "epss_percentile": 0.39293}, "CVE-2019-1998": {"epss_score": 0.00022, "epss_percentile": 0.04985}, "CVE-2019-1999": {"epss_score": 0.00484, "epss_percentile": 0.64666}, "CVE-2019-20000": {"epss_score": 0.00183, "epss_percentile": 0.40326}, "CVE-2019-20001": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2019-20002": {"epss_score": 0.01048, "epss_percentile": 0.77048}, "CVE-2019-20003": {"epss_score": 0.00378, "epss_percentile": 0.58791}, "CVE-2019-20004": {"epss_score": 0.00351, "epss_percentile": 0.57036}, "CVE-2019-20005": {"epss_score": 0.0068, "epss_percentile": 0.71029}, "CVE-2019-20006": {"epss_score": 0.00436, "epss_percentile": 0.62451}, "CVE-2019-20007": {"epss_score": 0.0085, "epss_percentile": 0.7439}, "CVE-2019-20008": {"epss_score": 0.0036, "epss_percentile": 0.57627}, "CVE-2019-20009": {"epss_score": 0.00556, "epss_percentile": 0.67509}, "CVE-2019-20010": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2019-20011": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2019-20012": {"epss_score": 0.00577, "epss_percentile": 0.68164}, "CVE-2019-20013": {"epss_score": 0.00556, "epss_percentile": 0.67509}, "CVE-2019-20014": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2019-20015": {"epss_score": 0.00577, "epss_percentile": 0.68164}, "CVE-2019-20016": {"epss_score": 0.00528, "epss_percentile": 0.66546}, "CVE-2019-20017": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2019-20018": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2019-20019": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2019-20020": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2019-20021": {"epss_score": 0.00339, "epss_percentile": 0.56186}, "CVE-2019-20022": {"epss_score": 0.00382, "epss_percentile": 0.59034}, "CVE-2019-20023": {"epss_score": 0.00438, "epss_percentile": 0.62562}, "CVE-2019-20024": {"epss_score": 0.00494, "epss_percentile": 0.65099}, "CVE-2019-20025": {"epss_score": 0.01995, "epss_percentile": 0.83191}, "CVE-2019-20026": {"epss_score": 0.00428, "epss_percentile": 0.6195}, "CVE-2019-20027": {"epss_score": 0.0035, "epss_percentile": 0.56975}, "CVE-2019-20028": {"epss_score": 0.00543, "epss_percentile": 0.67124}, "CVE-2019-20029": {"epss_score": 0.01619, "epss_percentile": 0.81382}, "CVE-2019-20030": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2019-20031": {"epss_score": 0.00257, "epss_percentile": 0.48877}, "CVE-2019-20032": {"epss_score": 0.00203, "epss_percentile": 0.42564}, "CVE-2019-20033": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2019-20041": {"epss_score": 0.01048, "epss_percentile": 0.77056}, "CVE-2019-20042": {"epss_score": 0.0505, "epss_percentile": 0.89439}, "CVE-2019-20043": {"epss_score": 0.0117, "epss_percentile": 0.78207}, "CVE-2019-20044": {"epss_score": 0.00068, "epss_percentile": 0.21291}, "CVE-2019-20045": {"epss_score": 0.00404, "epss_percentile": 0.60436}, "CVE-2019-20046": {"epss_score": 0.00169, "epss_percentile": 0.38549}, "CVE-2019-20047": {"epss_score": 0.02505, "epss_percentile": 0.84937}, "CVE-2019-20048": {"epss_score": 0.07632, "epss_percentile": 0.91585}, "CVE-2019-20049": {"epss_score": 0.25535, "epss_percentile": 0.96038}, "CVE-2019-20050": {"epss_score": 0.03761, "epss_percentile": 0.87688}, "CVE-2019-20051": {"epss_score": 0.00319, "epss_percentile": 0.54484}, "CVE-2019-20052": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2019-20053": {"epss_score": 0.00365, "epss_percentile": 0.57984}, "CVE-2019-20054": {"epss_score": 0.00126, "epss_percentile": 0.32726}, "CVE-2019-20055": {"epss_score": 0.00285, "epss_percentile": 0.51641}, "CVE-2019-20056": {"epss_score": 0.00468, "epss_percentile": 0.63891}, "CVE-2019-20057": {"epss_score": 0.00207, "epss_percentile": 0.4316}, "CVE-2019-20058": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-20059": {"epss_score": 0.0146, "epss_percentile": 0.80422}, "CVE-2019-20060": {"epss_score": 0.00468, "epss_percentile": 0.6391}, "CVE-2019-20061": {"epss_score": 0.00213, "epss_percentile": 0.43946}, "CVE-2019-20062": {"epss_score": 0.00373, "epss_percentile": 0.58525}, "CVE-2019-20063": {"epss_score": 0.00391, "epss_percentile": 0.59612}, "CVE-2019-20070": {"epss_score": 0.00422, "epss_percentile": 0.61558}, "CVE-2019-20071": {"epss_score": 0.00198, "epss_percentile": 0.42047}, "CVE-2019-20072": {"epss_score": 0.00422, "epss_percentile": 0.61558}, "CVE-2019-20073": {"epss_score": 0.00522, "epss_percentile": 0.66272}, "CVE-2019-20074": {"epss_score": 0.00174, "epss_percentile": 0.3926}, "CVE-2019-20075": {"epss_score": 0.00522, "epss_percentile": 0.66272}, "CVE-2019-20076": {"epss_score": 0.00422, "epss_percentile": 0.61558}, "CVE-2019-20077": {"epss_score": 0.00179, "epss_percentile": 0.39746}, "CVE-2019-20079": {"epss_score": 0.007, "epss_percentile": 0.71466}, "CVE-2019-20082": {"epss_score": 0.01166, "epss_percentile": 0.78181}, "CVE-2019-20085": {"epss_score": 0.94261, "epss_percentile": 0.99929}, "CVE-2019-20086": {"epss_score": 0.00389, "epss_percentile": 0.59471}, "CVE-2019-20087": {"epss_score": 0.00389, "epss_percentile": 0.59471}, "CVE-2019-20088": {"epss_score": 0.00266, "epss_percentile": 0.49871}, "CVE-2019-20089": {"epss_score": 0.00254, "epss_percentile": 0.48564}, "CVE-2019-20090": {"epss_score": 0.00254, "epss_percentile": 0.48564}, "CVE-2019-20091": {"epss_score": 0.00266, "epss_percentile": 0.4995}, "CVE-2019-20092": {"epss_score": 0.00266, "epss_percentile": 0.4995}, "CVE-2019-20093": {"epss_score": 0.00747, "epss_percentile": 0.72555}, "CVE-2019-20094": {"epss_score": 0.00476, "epss_percentile": 0.64284}, "CVE-2019-20095": {"epss_score": 0.00131, "epss_percentile": 0.33362}, "CVE-2019-20096": {"epss_score": 0.00074, "epss_percentile": 0.22712}, "CVE-2019-20097": {"epss_score": 0.02994, "epss_percentile": 0.86152}, "CVE-2019-20098": {"epss_score": 0.00433, "epss_percentile": 0.622}, "CVE-2019-20099": {"epss_score": 0.00238, "epss_percentile": 0.46742}, "CVE-2019-20100": {"epss_score": 0.003, "epss_percentile": 0.52953}, "CVE-2019-20101": {"epss_score": 0.01571, "epss_percentile": 0.81094}, "CVE-2019-20102": {"epss_score": 0.0042, "epss_percentile": 0.61423}, "CVE-2019-20104": {"epss_score": 0.02432, "epss_percentile": 0.84731}, "CVE-2019-20105": {"epss_score": 0.00198, "epss_percentile": 0.42015}, "CVE-2019-20106": {"epss_score": 0.00212, "epss_percentile": 0.43776}, "CVE-2019-20107": {"epss_score": 0.01782, "epss_percentile": 0.82245}, "CVE-2019-20138": {"epss_score": 0.00171, "epss_percentile": 0.38894}, "CVE-2019-20139": {"epss_score": 0.08324, "epss_percentile": 0.91991}, "CVE-2019-20140": {"epss_score": 0.00512, "epss_percentile": 0.6586}, "CVE-2019-20141": {"epss_score": 0.12494, "epss_percentile": 0.93692}, "CVE-2019-20142": {"epss_score": 0.00105, "epss_percentile": 0.29247}, "CVE-2019-20143": {"epss_score": 0.00075, "epss_percentile": 0.22898}, "CVE-2019-20144": {"epss_score": 0.00067, "epss_percentile": 0.21048}, "CVE-2019-20145": {"epss_score": 0.00067, "epss_percentile": 0.21048}, "CVE-2019-20146": {"epss_score": 0.00114, "epss_percentile": 0.30779}, "CVE-2019-20147": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2019-20148": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2019-20149": {"epss_score": 0.00184, "epss_percentile": 0.40453}, "CVE-2019-20150": {"epss_score": 0.00288, "epss_percentile": 0.51882}, "CVE-2019-20151": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-20152": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-20153": {"epss_score": 0.0076, "epss_percentile": 0.72807}, "CVE-2019-20154": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2019-20155": {"epss_score": 0.00932, "epss_percentile": 0.75624}, "CVE-2019-20159": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2019-20160": {"epss_score": 0.00323, "epss_percentile": 0.54894}, "CVE-2019-20161": {"epss_score": 0.0043, "epss_percentile": 0.62021}, "CVE-2019-20162": {"epss_score": 0.0043, "epss_percentile": 0.62021}, "CVE-2019-20163": {"epss_score": 0.00472, "epss_percentile": 0.64047}, "CVE-2019-20164": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2019-20165": {"epss_score": 0.00472, "epss_percentile": 0.64047}, "CVE-2019-20166": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2019-20167": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2019-20168": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2019-20169": {"epss_score": 0.00299, "epss_percentile": 0.52881}, "CVE-2019-20170": {"epss_score": 0.00472, "epss_percentile": 0.64047}, "CVE-2019-20171": {"epss_score": 0.00332, "epss_percentile": 0.55569}, "CVE-2019-20172": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-20173": {"epss_score": 0.09952, "epss_percentile": 0.92787}, "CVE-2019-20174": {"epss_score": 0.0046, "epss_percentile": 0.63512}, "CVE-2019-20175": {"epss_score": 0.00537, "epss_percentile": 0.66914}, "CVE-2019-20176": {"epss_score": 0.22328, "epss_percentile": 0.95623}, "CVE-2019-20178": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2019-20179": {"epss_score": 0.003, "epss_percentile": 0.52943}, "CVE-2019-20180": {"epss_score": 0.02881, "epss_percentile": 0.859}, "CVE-2019-20181": {"epss_score": 0.00254, "epss_percentile": 0.48558}, "CVE-2019-20182": {"epss_score": 0.00278, "epss_percentile": 0.50869}, "CVE-2019-20183": {"epss_score": 0.56083, "epss_percentile": 0.98007}, "CVE-2019-20184": {"epss_score": 0.00295, "epss_percentile": 0.52526}, "CVE-2019-20191": {"epss_score": 0.00347, "epss_percentile": 0.56752}, "CVE-2019-20197": {"epss_score": 0.43613, "epss_percentile": 0.97394}, "CVE-2019-20198": {"epss_score": 0.00732, "epss_percentile": 0.722}, "CVE-2019-20199": {"epss_score": 0.00791, "epss_percentile": 0.73393}, "CVE-2019-20200": {"epss_score": 0.00523, "epss_percentile": 0.66306}, "CVE-2019-20201": {"epss_score": 0.00405, "epss_percentile": 0.60509}, "CVE-2019-20202": {"epss_score": 0.00405, "epss_percentile": 0.60509}, "CVE-2019-20203": {"epss_score": 0.00666, "epss_percentile": 0.70681}, "CVE-2019-20204": {"epss_score": 0.01111, "epss_percentile": 0.77671}, "CVE-2019-20205": {"epss_score": 0.00421, "epss_percentile": 0.61464}, "CVE-2019-20208": {"epss_score": 0.00508, "epss_percentile": 0.65706}, "CVE-2019-20209": {"epss_score": 0.00993, "epss_percentile": 0.76414}, "CVE-2019-20210": {"epss_score": 0.00382, "epss_percentile": 0.59042}, "CVE-2019-20211": {"epss_score": 0.00756, "epss_percentile": 0.72732}, "CVE-2019-20212": {"epss_score": 0.00644, "epss_percentile": 0.70076}, "CVE-2019-20213": {"epss_score": 0.00841, "epss_percentile": 0.74231}, "CVE-2019-20215": {"epss_score": 0.90327, "epss_percentile": 0.99577}, "CVE-2019-20216": {"epss_score": 0.05128, "epss_percentile": 0.89526}, "CVE-2019-20217": {"epss_score": 0.05786, "epss_percentile": 0.90207}, "CVE-2019-20218": {"epss_score": 0.00402, "epss_percentile": 0.60267}, "CVE-2019-20219": {"epss_score": 0.00391, "epss_percentile": 0.59629}, "CVE-2019-20220": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-20221": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-20222": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-20223": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-20224": {"epss_score": 0.93568, "epss_percentile": 0.99819}, "CVE-2019-20225": {"epss_score": 0.00236, "epss_percentile": 0.46374}, "CVE-2019-20326": {"epss_score": 0.03961, "epss_percentile": 0.88013}, "CVE-2019-20327": {"epss_score": 0.00113, "epss_percentile": 0.30715}, "CVE-2019-20329": {"epss_score": 0.00213, "epss_percentile": 0.43832}, "CVE-2019-20330": {"epss_score": 0.01863, "epss_percentile": 0.82596}, "CVE-2019-20334": {"epss_score": 0.0023, "epss_percentile": 0.45736}, "CVE-2019-20336": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-20337": {"epss_score": 0.0032, "epss_percentile": 0.54591}, "CVE-2019-20343": {"epss_score": 0.00916, "epss_percentile": 0.75412}, "CVE-2019-20348": {"epss_score": 0.00138, "epss_percentile": 0.34352}, "CVE-2019-20352": {"epss_score": 0.00297, "epss_percentile": 0.52746}, "CVE-2019-20354": {"epss_score": 0.21249, "epss_percentile": 0.95486}, "CVE-2019-20357": {"epss_score": 0.00183, "epss_percentile": 0.40355}, "CVE-2019-20358": {"epss_score": 0.03625, "epss_percentile": 0.87456}, "CVE-2019-20360": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2019-20361": {"epss_score": 0.32445, "epss_percentile": 0.967}, "CVE-2019-20362": {"epss_score": 0.00116, "epss_percentile": 0.31062}, "CVE-2019-20363": {"epss_score": 0.01088, "epss_percentile": 0.77436}, "CVE-2019-20364": {"epss_score": 0.01231, "epss_percentile": 0.7873}, "CVE-2019-20365": {"epss_score": 0.01231, "epss_percentile": 0.7873}, "CVE-2019-20366": {"epss_score": 0.01664, "epss_percentile": 0.8164}, "CVE-2019-20367": {"epss_score": 0.01635, "epss_percentile": 0.81472}, "CVE-2019-20372": {"epss_score": 0.68429, "epss_percentile": 0.98548}, "CVE-2019-20373": {"epss_score": 0.00158, "epss_percentile": 0.37236}, "CVE-2019-20374": {"epss_score": 0.02172, "epss_percentile": 0.83874}, "CVE-2019-20375": {"epss_score": 0.00301, "epss_percentile": 0.53018}, "CVE-2019-20376": {"epss_score": 0.00301, "epss_percentile": 0.53018}, "CVE-2019-20377": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-20378": {"epss_score": 0.00354, "epss_percentile": 0.57248}, "CVE-2019-20379": {"epss_score": 0.00354, "epss_percentile": 0.57248}, "CVE-2019-20381": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2019-20382": {"epss_score": 0.00044, "epss_percentile": 0.13556}, "CVE-2019-20383": {"epss_score": 0.0005, "epss_percentile": 0.15731}, "CVE-2019-20384": {"epss_score": 0.0009, "epss_percentile": 0.26004}, "CVE-2019-20385": {"epss_score": 0.00408, "epss_percentile": 0.60674}, "CVE-2019-20386": {"epss_score": 0.00152, "epss_percentile": 0.36432}, "CVE-2019-20387": {"epss_score": 0.0023, "epss_percentile": 0.45686}, "CVE-2019-20388": {"epss_score": 0.00562, "epss_percentile": 0.67703}, "CVE-2019-20389": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2019-20390": {"epss_score": 0.00247, "epss_percentile": 0.47833}, "CVE-2019-20391": {"epss_score": 0.00203, "epss_percentile": 0.42539}, "CVE-2019-20392": {"epss_score": 0.00203, "epss_percentile": 0.42539}, "CVE-2019-20393": {"epss_score": 0.00288, "epss_percentile": 0.51912}, "CVE-2019-20394": {"epss_score": 0.00288, "epss_percentile": 0.51912}, "CVE-2019-20395": {"epss_score": 0.00205, "epss_percentile": 0.42706}, "CVE-2019-20396": {"epss_score": 0.00256, "epss_percentile": 0.4878}, "CVE-2019-20397": {"epss_score": 0.00397, "epss_percentile": 0.60022}, "CVE-2019-20398": {"epss_score": 0.00206, "epss_percentile": 0.42768}, "CVE-2019-20399": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2019-20400": {"epss_score": 0.00145, "epss_percentile": 0.35411}, "CVE-2019-20401": {"epss_score": 0.00325, "epss_percentile": 0.5502}, "CVE-2019-20402": {"epss_score": 0.00258, "epss_percentile": 0.4902}, "CVE-2019-20403": {"epss_score": 0.00436, "epss_percentile": 0.62486}, "CVE-2019-20404": {"epss_score": 0.01053, "epss_percentile": 0.771}, "CVE-2019-20405": {"epss_score": 0.0018, "epss_percentile": 0.39936}, "CVE-2019-20406": {"epss_score": 0.00162, "epss_percentile": 0.37637}, "CVE-2019-20407": {"epss_score": 0.00272, "epss_percentile": 0.50352}, "CVE-2019-20408": {"epss_score": 0.00305, "epss_percentile": 0.5331}, "CVE-2019-20409": {"epss_score": 0.03481, "epss_percentile": 0.87219}, "CVE-2019-20410": {"epss_score": 0.00331, "epss_percentile": 0.55524}, "CVE-2019-20411": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2019-20412": {"epss_score": 0.00312, "epss_percentile": 0.53996}, "CVE-2019-20413": {"epss_score": 0.00551, "epss_percentile": 0.67377}, "CVE-2019-20414": {"epss_score": 0.003, "epss_percentile": 0.52959}, "CVE-2019-20415": {"epss_score": 0.00147, "epss_percentile": 0.35676}, "CVE-2019-20416": {"epss_score": 0.00253, "epss_percentile": 0.48482}, "CVE-2019-20418": {"epss_score": 0.00419, "epss_percentile": 0.61351}, "CVE-2019-20419": {"epss_score": 0.00157, "epss_percentile": 0.37023}, "CVE-2019-20421": {"epss_score": 0.03067, "epss_percentile": 0.86339}, "CVE-2019-20422": {"epss_score": 0.00079, "epss_percentile": 0.23917}, "CVE-2019-20423": {"epss_score": 0.00619, "epss_percentile": 0.69429}, "CVE-2019-20424": {"epss_score": 0.00666, "epss_percentile": 0.70689}, "CVE-2019-20425": {"epss_score": 0.0066, "epss_percentile": 0.70529}, "CVE-2019-20426": {"epss_score": 0.0066, "epss_percentile": 0.70529}, "CVE-2019-20427": {"epss_score": 0.03517, "epss_percentile": 0.87276}, "CVE-2019-20428": {"epss_score": 0.0066, "epss_percentile": 0.70529}, "CVE-2019-20429": {"epss_score": 0.0066, "epss_percentile": 0.70529}, "CVE-2019-20430": {"epss_score": 0.00664, "epss_percentile": 0.70635}, "CVE-2019-20431": {"epss_score": 0.0066, "epss_percentile": 0.70529}, "CVE-2019-20432": {"epss_score": 0.00614, "epss_percentile": 0.69282}, "CVE-2019-20433": {"epss_score": 0.00644, "epss_percentile": 0.70085}, "CVE-2019-20434": {"epss_score": 0.00427, "epss_percentile": 0.61884}, "CVE-2019-20435": {"epss_score": 0.00427, "epss_percentile": 0.61884}, "CVE-2019-20436": {"epss_score": 0.00783, "epss_percentile": 0.73218}, "CVE-2019-20437": {"epss_score": 0.00783, "epss_percentile": 0.73218}, "CVE-2019-20438": {"epss_score": 0.00517, "epss_percentile": 0.66077}, "CVE-2019-20439": {"epss_score": 0.00456, "epss_percentile": 0.63347}, "CVE-2019-20440": {"epss_score": 0.00517, "epss_percentile": 0.66077}, "CVE-2019-20441": {"epss_score": 0.00517, "epss_percentile": 0.66077}, "CVE-2019-20442": {"epss_score": 0.00481, "epss_percentile": 0.64503}, "CVE-2019-20443": {"epss_score": 0.00517, "epss_percentile": 0.66077}, "CVE-2019-20444": {"epss_score": 0.11096, "epss_percentile": 0.93218}, "CVE-2019-20445": {"epss_score": 0.02837, "epss_percentile": 0.85792}, "CVE-2019-20446": {"epss_score": 0.0133, "epss_percentile": 0.7951}, "CVE-2019-20447": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2019-20451": {"epss_score": 0.12492, "epss_percentile": 0.93691}, "CVE-2019-20452": {"epss_score": 0.04371, "epss_percentile": 0.8861}, "CVE-2019-20453": {"epss_score": 0.04371, "epss_percentile": 0.8861}, "CVE-2019-20454": {"epss_score": 0.00089, "epss_percentile": 0.25931}, "CVE-2019-20455": {"epss_score": 0.00376, "epss_percentile": 0.58683}, "CVE-2019-20456": {"epss_score": 0.00136, "epss_percentile": 0.34184}, "CVE-2019-20457": {"epss_score": 0.00069, "epss_percentile": 0.21456}, "CVE-2019-20458": {"epss_score": 0.00033, "epss_percentile": 0.09136}, "CVE-2019-20459": {"epss_score": 0.00027, "epss_percentile": 0.07107}, "CVE-2019-20460": {"epss_score": 0.00028, "epss_percentile": 0.07498}, "CVE-2019-20461": {"epss_score": 0.00072, "epss_percentile": 0.22316}, "CVE-2019-20462": {"epss_score": 0.00032, "epss_percentile": 0.09105}, "CVE-2019-20463": {"epss_score": 0.00321, "epss_percentile": 0.5469}, "CVE-2019-20464": {"epss_score": 0.00392, "epss_percentile": 0.59669}, "CVE-2019-20465": {"epss_score": 0.00319, "epss_percentile": 0.54547}, "CVE-2019-20466": {"epss_score": 0.00078, "epss_percentile": 0.23571}, "CVE-2019-20467": {"epss_score": 0.01228, "epss_percentile": 0.78707}, "CVE-2019-20468": {"epss_score": 0.01095, "epss_percentile": 0.77499}, "CVE-2019-20469": {"epss_score": 0.00034, "epss_percentile": 0.09758}, "CVE-2019-20470": {"epss_score": 0.01214, "epss_percentile": 0.78578}, "CVE-2019-20471": {"epss_score": 0.00415, "epss_percentile": 0.61129}, "CVE-2019-20472": {"epss_score": 0.00026, "epss_percentile": 0.06623}, "CVE-2019-20473": {"epss_score": 0.00448, "epss_percentile": 0.6299}, "CVE-2019-20474": {"epss_score": 0.00183, "epss_percentile": 0.40294}, "CVE-2019-20477": {"epss_score": 0.00456, "epss_percentile": 0.63339}, "CVE-2019-20478": {"epss_score": 0.07299, "epss_percentile": 0.91392}, "CVE-2019-20479": {"epss_score": 0.00487, "epss_percentile": 0.64811}, "CVE-2019-20480": {"epss_score": 0.00321, "epss_percentile": 0.54644}, "CVE-2019-20481": {"epss_score": 0.00294, "epss_percentile": 0.52359}, "CVE-2019-20483": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-20484": {"epss_score": 0.00219, "epss_percentile": 0.44534}, "CVE-2019-20485": {"epss_score": 0.00192, "epss_percentile": 0.41294}, "CVE-2019-20486": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-20487": {"epss_score": 0.00334, "epss_percentile": 0.55722}, "CVE-2019-20488": {"epss_score": 0.05092, "epss_percentile": 0.89483}, "CVE-2019-20489": {"epss_score": 0.00198, "epss_percentile": 0.42082}, "CVE-2019-20490": {"epss_score": 0.00193, "epss_percentile": 0.41377}, "CVE-2019-20491": {"epss_score": 0.00159, "epss_percentile": 0.37373}, "CVE-2019-20492": {"epss_score": 0.00188, "epss_percentile": 0.40833}, "CVE-2019-20493": {"epss_score": 0.00423, "epss_percentile": 0.61615}, "CVE-2019-20494": {"epss_score": 0.00127, "epss_percentile": 0.32938}, "CVE-2019-20495": {"epss_score": 0.00419, "epss_percentile": 0.61367}, "CVE-2019-20496": {"epss_score": 0.00134, "epss_percentile": 0.33793}, "CVE-2019-20497": {"epss_score": 0.00415, "epss_percentile": 0.61155}, "CVE-2019-20498": {"epss_score": 0.00139, "epss_percentile": 0.34638}, "CVE-2019-20499": {"epss_score": 0.89938, "epss_percentile": 0.99551}, "CVE-2019-20500": {"epss_score": 0.92073, "epss_percentile": 0.99689}, "CVE-2019-20501": {"epss_score": 0.1295, "epss_percentile": 0.93828}, "CVE-2019-20502": {"epss_score": 0.00489, "epss_percentile": 0.64876}, "CVE-2019-20503": {"epss_score": 0.02474, "epss_percentile": 0.84855}, "CVE-2019-20504": {"epss_score": 0.55808, "epss_percentile": 0.97997}, "CVE-2019-20511": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-20512": {"epss_score": 0.00176, "epss_percentile": 0.39471}, "CVE-2019-20513": {"epss_score": 0.00169, "epss_percentile": 0.38619}, "CVE-2019-20514": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2019-20515": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2019-20516": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2019-20517": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2019-20518": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2019-20519": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2019-20520": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2019-20521": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2019-20522": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-20523": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-20524": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-20525": {"epss_score": 0.00471, "epss_percentile": 0.64022}, "CVE-2019-20526": {"epss_score": 0.00471, "epss_percentile": 0.64022}, "CVE-2019-20527": {"epss_score": 0.00471, "epss_percentile": 0.64022}, "CVE-2019-20528": {"epss_score": 0.00471, "epss_percentile": 0.64022}, "CVE-2019-20529": {"epss_score": 0.00365, "epss_percentile": 0.57967}, "CVE-2019-20530": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2019-20531": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2019-20532": {"epss_score": 0.00087, "epss_percentile": 0.25556}, "CVE-2019-20533": {"epss_score": 0.00017, "epss_percentile": 0.03116}, "CVE-2019-20534": {"epss_score": 0.00018, "epss_percentile": 0.04025}, "CVE-2019-20535": {"epss_score": 0.00019, "epss_percentile": 0.04156}, "CVE-2019-20536": {"epss_score": 0.00129, "epss_percentile": 0.33211}, "CVE-2019-20537": {"epss_score": 0.00195, "epss_percentile": 0.41614}, "CVE-2019-20538": {"epss_score": 0.0005, "epss_percentile": 0.15684}, "CVE-2019-20539": {"epss_score": 0.00139, "epss_percentile": 0.34567}, "CVE-2019-20540": {"epss_score": 0.00041, "epss_percentile": 0.12425}, "CVE-2019-20541": {"epss_score": 0.0005, "epss_percentile": 0.15684}, "CVE-2019-20542": {"epss_score": 0.0005, "epss_percentile": 0.15684}, "CVE-2019-20543": {"epss_score": 0.00018, "epss_percentile": 0.03704}, "CVE-2019-20544": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2019-20545": {"epss_score": 0.00183, "epss_percentile": 0.40334}, "CVE-2019-20546": {"epss_score": 0.00031, "epss_percentile": 0.08655}, "CVE-2019-20547": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2019-20548": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2019-20549": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2019-20550": {"epss_score": 0.00018, "epss_percentile": 0.03828}, "CVE-2019-20551": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2019-20552": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2019-20553": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2019-20554": {"epss_score": 0.00019, "epss_percentile": 0.04156}, "CVE-2019-20555": {"epss_score": 0.00084, "epss_percentile": 0.24955}, "CVE-2019-20556": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2019-20557": {"epss_score": 0.00019, "epss_percentile": 0.04156}, "CVE-2019-20558": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2019-20559": {"epss_score": 0.00019, "epss_percentile": 0.04194}, "CVE-2019-20560": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2019-20561": {"epss_score": 0.00151, "epss_percentile": 0.36337}, "CVE-2019-20562": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2019-20563": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2019-20564": {"epss_score": 0.00289, "epss_percentile": 0.52009}, "CVE-2019-20565": {"epss_score": 0.00089, "epss_percentile": 0.25816}, "CVE-2019-20566": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2019-20567": {"epss_score": 0.00231, "epss_percentile": 0.45794}, "CVE-2019-20568": {"epss_score": 0.00134, "epss_percentile": 0.33792}, "CVE-2019-20569": {"epss_score": 0.00019, "epss_percentile": 0.04156}, "CVE-2019-20570": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2019-20571": {"epss_score": 0.00187, "epss_percentile": 0.40754}, "CVE-2019-20572": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2019-20573": {"epss_score": 0.00037, "epss_percentile": 0.1084}, "CVE-2019-20574": {"epss_score": 0.00037, "epss_percentile": 0.1084}, "CVE-2019-20575": {"epss_score": 0.00015, "epss_percentile": 0.02487}, "CVE-2019-20576": {"epss_score": 0.00159, "epss_percentile": 0.37318}, "CVE-2019-20577": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2019-20578": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2019-20579": {"epss_score": 0.00019, "epss_percentile": 0.04194}, "CVE-2019-20580": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2019-20581": {"epss_score": 0.00222, "epss_percentile": 0.44756}, "CVE-2019-20582": {"epss_score": 0.00173, "epss_percentile": 0.39069}, "CVE-2019-20583": {"epss_score": 0.00195, "epss_percentile": 0.41614}, "CVE-2019-20584": {"epss_score": 0.00195, "epss_percentile": 0.41614}, "CVE-2019-20585": {"epss_score": 0.00195, "epss_percentile": 0.41614}, "CVE-2019-20586": {"epss_score": 0.00195, "epss_percentile": 0.41614}, "CVE-2019-20587": {"epss_score": 0.00195, "epss_percentile": 0.41614}, "CVE-2019-20588": {"epss_score": 0.00195, "epss_percentile": 0.41614}, "CVE-2019-20589": {"epss_score": 0.00195, "epss_percentile": 0.41614}, "CVE-2019-20590": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2019-20591": {"epss_score": 0.00037, "epss_percentile": 0.1084}, "CVE-2019-20592": {"epss_score": 0.00037, "epss_percentile": 0.1084}, "CVE-2019-20593": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2019-20594": {"epss_score": 0.00018, "epss_percentile": 0.03928}, "CVE-2019-20595": {"epss_score": 0.0002, "epss_percentile": 0.04527}, "CVE-2019-20596": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2019-20597": {"epss_score": 0.00065, "epss_percentile": 0.20458}, "CVE-2019-20598": {"epss_score": 0.00019, "epss_percentile": 0.04194}, "CVE-2019-20599": {"epss_score": 0.00081, "epss_percentile": 0.24322}, "CVE-2019-20600": {"epss_score": 0.00022, "epss_percentile": 0.05166}, "CVE-2019-20601": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2019-20602": {"epss_score": 0.00114, "epss_percentile": 0.30787}, "CVE-2019-20603": {"epss_score": 0.00114, "epss_percentile": 0.30787}, "CVE-2019-20604": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2019-20605": {"epss_score": 0.00183, "epss_percentile": 0.40334}, "CVE-2019-20606": {"epss_score": 0.00097, "epss_percentile": 0.27456}, "CVE-2019-20607": {"epss_score": 0.00231, "epss_percentile": 0.45794}, "CVE-2019-20608": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2019-20609": {"epss_score": 0.00037, "epss_percentile": 0.10929}, "CVE-2019-20610": {"epss_score": 0.00151, "epss_percentile": 0.36191}, "CVE-2019-20611": {"epss_score": 0.00231, "epss_percentile": 0.45794}, "CVE-2019-20612": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2019-20613": {"epss_score": 0.00159, "epss_percentile": 0.37318}, "CVE-2019-20614": {"epss_score": 0.00114, "epss_percentile": 0.30879}, "CVE-2019-20615": {"epss_score": 0.00019, "epss_percentile": 0.04156}, "CVE-2019-20616": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2019-20617": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2019-20618": {"epss_score": 0.00093, "epss_percentile": 0.26685}, "CVE-2019-20619": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2019-20620": {"epss_score": 0.00093, "epss_percentile": 0.26685}, "CVE-2019-20621": {"epss_score": 0.00183, "epss_percentile": 0.40334}, "CVE-2019-20622": {"epss_score": 0.00183, "epss_percentile": 0.40334}, "CVE-2019-20623": {"epss_score": 0.00019, "epss_percentile": 0.04409}, "CVE-2019-20624": {"epss_score": 0.00084, "epss_percentile": 0.24955}, "CVE-2019-20625": {"epss_score": 0.00018, "epss_percentile": 0.03527}, "CVE-2019-20626": {"epss_score": 0.00104, "epss_percentile": 0.29103}, "CVE-2019-20627": {"epss_score": 0.00446, "epss_percentile": 0.62919}, "CVE-2019-20628": {"epss_score": 0.00378, "epss_percentile": 0.58792}, "CVE-2019-20629": {"epss_score": 0.00324, "epss_percentile": 0.54933}, "CVE-2019-20630": {"epss_score": 0.00324, "epss_percentile": 0.54933}, "CVE-2019-20631": {"epss_score": 0.0031, "epss_percentile": 0.53745}, "CVE-2019-20632": {"epss_score": 0.00324, "epss_percentile": 0.54933}, "CVE-2019-20633": {"epss_score": 0.00115, "epss_percentile": 0.30942}, "CVE-2019-20634": {"epss_score": 0.0028, "epss_percentile": 0.51032}, "CVE-2019-20635": {"epss_score": 0.00386, "epss_percentile": 0.59277}, "CVE-2019-20636": {"epss_score": 0.00112, "epss_percentile": 0.30456}, "CVE-2019-20637": {"epss_score": 0.00478, "epss_percentile": 0.64369}, "CVE-2019-20638": {"epss_score": 0.00405, "epss_percentile": 0.6049}, "CVE-2019-20639": {"epss_score": 0.00426, "epss_percentile": 0.61761}, "CVE-2019-20640": {"epss_score": 0.0065, "epss_percentile": 0.70265}, "CVE-2019-20641": {"epss_score": 0.00223, "epss_percentile": 0.44961}, "CVE-2019-20642": {"epss_score": 0.00125, "epss_percentile": 0.32605}, "CVE-2019-20643": {"epss_score": 0.0041, "epss_percentile": 0.60826}, "CVE-2019-20644": {"epss_score": 0.00244, "epss_percentile": 0.47608}, "CVE-2019-20645": {"epss_score": 0.00363, "epss_percentile": 0.57871}, "CVE-2019-20646": {"epss_score": 0.00319, "epss_percentile": 0.54475}, "CVE-2019-20647": {"epss_score": 0.0013, "epss_percentile": 0.33332}, "CVE-2019-20648": {"epss_score": 0.00157, "epss_percentile": 0.37109}, "CVE-2019-20649": {"epss_score": 0.004, "epss_percentile": 0.60166}, "CVE-2019-20650": {"epss_score": 0.00176, "epss_percentile": 0.39434}, "CVE-2019-20651": {"epss_score": 0.00203, "epss_percentile": 0.42573}, "CVE-2019-20652": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2019-20653": {"epss_score": 0.00245, "epss_percentile": 0.47661}, "CVE-2019-20654": {"epss_score": 0.00404, "epss_percentile": 0.60452}, "CVE-2019-20655": {"epss_score": 0.00253, "epss_percentile": 0.48439}, "CVE-2019-20656": {"epss_score": 0.00365, "epss_percentile": 0.57996}, "CVE-2019-20657": {"epss_score": 0.00727, "epss_percentile": 0.72102}, "CVE-2019-20658": {"epss_score": 0.00168, "epss_percentile": 0.38422}, "CVE-2019-20659": {"epss_score": 0.00287, "epss_percentile": 0.51826}, "CVE-2019-20660": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2019-20661": {"epss_score": 0.00191, "epss_percentile": 0.41161}, "CVE-2019-20662": {"epss_score": 0.00122, "epss_percentile": 0.32021}, "CVE-2019-20663": {"epss_score": 0.00122, "epss_percentile": 0.32021}, "CVE-2019-20664": {"epss_score": 0.00252, "epss_percentile": 0.48364}, "CVE-2019-20665": {"epss_score": 0.00191, "epss_percentile": 0.41161}, "CVE-2019-20666": {"epss_score": 0.00252, "epss_percentile": 0.48364}, "CVE-2019-20667": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2019-20668": {"epss_score": 0.00465, "epss_percentile": 0.63744}, "CVE-2019-20669": {"epss_score": 0.00359, "epss_percentile": 0.57602}, "CVE-2019-20670": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2019-20671": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2019-20672": {"epss_score": 0.00344, "epss_percentile": 0.56482}, "CVE-2019-20673": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2019-20674": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2019-20675": {"epss_score": 0.00465, "epss_percentile": 0.63744}, "CVE-2019-20676": {"epss_score": 0.00102, "epss_percentile": 0.28895}, "CVE-2019-20677": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2019-20678": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2019-20679": {"epss_score": 0.00493, "epss_percentile": 0.65063}, "CVE-2019-20680": {"epss_score": 0.00181, "epss_percentile": 0.40125}, "CVE-2019-20681": {"epss_score": 0.00103, "epss_percentile": 0.2905}, "CVE-2019-20682": {"epss_score": 0.0065, "epss_percentile": 0.70265}, "CVE-2019-20683": {"epss_score": 0.0065, "epss_percentile": 0.70265}, "CVE-2019-20684": {"epss_score": 0.0065, "epss_percentile": 0.70265}, "CVE-2019-20685": {"epss_score": 0.0065, "epss_percentile": 0.70265}, "CVE-2019-20686": {"epss_score": 0.0065, "epss_percentile": 0.70265}, "CVE-2019-20687": {"epss_score": 0.00405, "epss_percentile": 0.60504}, "CVE-2019-20688": {"epss_score": 0.00207, "epss_percentile": 0.43192}, "CVE-2019-20689": {"epss_score": 0.00207, "epss_percentile": 0.43192}, "CVE-2019-20690": {"epss_score": 0.00063, "epss_percentile": 0.19875}, "CVE-2019-20691": {"epss_score": 0.0021, "epss_percentile": 0.43452}, "CVE-2019-20692": {"epss_score": 0.00229, "epss_percentile": 0.45588}, "CVE-2019-20693": {"epss_score": 0.00064, "epss_percentile": 0.20388}, "CVE-2019-20694": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2019-20695": {"epss_score": 0.00572, "epss_percentile": 0.68021}, "CVE-2019-20696": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2019-20697": {"epss_score": 0.00318, "epss_percentile": 0.54458}, "CVE-2019-20698": {"epss_score": 0.00181, "epss_percentile": 0.40088}, "CVE-2019-20699": {"epss_score": 0.00733, "epss_percentile": 0.72202}, "CVE-2019-20700": {"epss_score": 0.00392, "epss_percentile": 0.59694}, "CVE-2019-20701": {"epss_score": 0.00304, "epss_percentile": 0.53294}, "CVE-2019-20702": {"epss_score": 0.00344, "epss_percentile": 0.56532}, "CVE-2019-20703": {"epss_score": 0.00413, "epss_percentile": 0.61006}, "CVE-2019-20704": {"epss_score": 0.00344, "epss_percentile": 0.56532}, "CVE-2019-20705": {"epss_score": 0.00413, "epss_percentile": 0.61006}, "CVE-2019-20706": {"epss_score": 0.00282, "epss_percentile": 0.51283}, "CVE-2019-20707": {"epss_score": 0.00413, "epss_percentile": 0.61006}, "CVE-2019-20708": {"epss_score": 0.00208, "epss_percentile": 0.43239}, "CVE-2019-20709": {"epss_score": 0.00382, "epss_percentile": 0.59032}, "CVE-2019-20710": {"epss_score": 0.00304, "epss_percentile": 0.53294}, "CVE-2019-20711": {"epss_score": 0.00304, "epss_percentile": 0.53294}, "CVE-2019-20712": {"epss_score": 0.0024, "epss_percentile": 0.4722}, "CVE-2019-20713": {"epss_score": 0.003, "epss_percentile": 0.52983}, "CVE-2019-20714": {"epss_score": 0.00364, "epss_percentile": 0.57918}, "CVE-2019-20715": {"epss_score": 0.00242, "epss_percentile": 0.47343}, "CVE-2019-20716": {"epss_score": 0.00226, "epss_percentile": 0.45281}, "CVE-2019-20717": {"epss_score": 0.00195, "epss_percentile": 0.41632}, "CVE-2019-20718": {"epss_score": 0.00116, "epss_percentile": 0.31102}, "CVE-2019-20719": {"epss_score": 0.00155, "epss_percentile": 0.36789}, "CVE-2019-20720": {"epss_score": 0.00277, "epss_percentile": 0.50822}, "CVE-2019-20721": {"epss_score": 0.00242, "epss_percentile": 0.47343}, "CVE-2019-20722": {"epss_score": 0.0012, "epss_percentile": 0.31807}, "CVE-2019-20723": {"epss_score": 0.0024, "epss_percentile": 0.4722}, "CVE-2019-20724": {"epss_score": 0.00078, "epss_percentile": 0.23737}, "CVE-2019-20725": {"epss_score": 0.00342, "epss_percentile": 0.56396}, "CVE-2019-20726": {"epss_score": 0.00078, "epss_percentile": 0.23737}, "CVE-2019-20727": {"epss_score": 0.00242, "epss_percentile": 0.47376}, "CVE-2019-20728": {"epss_score": 0.00157, "epss_percentile": 0.37023}, "CVE-2019-20729": {"epss_score": 0.00141, "epss_percentile": 0.34899}, "CVE-2019-20730": {"epss_score": 0.00395, "epss_percentile": 0.59808}, "CVE-2019-20731": {"epss_score": 0.00124, "epss_percentile": 0.32358}, "CVE-2019-20732": {"epss_score": 0.00058, "epss_percentile": 0.18378}, "CVE-2019-20733": {"epss_score": 0.00271, "epss_percentile": 0.50298}, "CVE-2019-20734": {"epss_score": 0.00548, "epss_percentile": 0.67273}, "CVE-2019-20735": {"epss_score": 0.0024, "epss_percentile": 0.4722}, "CVE-2019-20736": {"epss_score": 0.0024, "epss_percentile": 0.4722}, "CVE-2019-20737": {"epss_score": 0.00271, "epss_percentile": 0.50298}, "CVE-2019-20738": {"epss_score": 0.0022, "epss_percentile": 0.44589}, "CVE-2019-20739": {"epss_score": 0.00336, "epss_percentile": 0.5595}, "CVE-2019-20740": {"epss_score": 0.00342, "epss_percentile": 0.56396}, "CVE-2019-20741": {"epss_score": 0.00304, "epss_percentile": 0.53291}, "CVE-2019-20742": {"epss_score": 0.00169, "epss_percentile": 0.38543}, "CVE-2019-20743": {"epss_score": 0.00169, "epss_percentile": 0.38543}, "CVE-2019-20744": {"epss_score": 0.00188, "epss_percentile": 0.40909}, "CVE-2019-20745": {"epss_score": 0.00273, "epss_percentile": 0.50455}, "CVE-2019-20746": {"epss_score": 0.00415, "epss_percentile": 0.6111}, "CVE-2019-20747": {"epss_score": 0.0024, "epss_percentile": 0.4722}, "CVE-2019-20748": {"epss_score": 0.003, "epss_percentile": 0.52983}, "CVE-2019-20749": {"epss_score": 0.00277, "epss_percentile": 0.50822}, "CVE-2019-20750": {"epss_score": 0.00364, "epss_percentile": 0.57918}, "CVE-2019-20751": {"epss_score": 0.00342, "epss_percentile": 0.56396}, "CVE-2019-20752": {"epss_score": 0.00415, "epss_percentile": 0.6111}, "CVE-2019-20753": {"epss_score": 0.00334, "epss_percentile": 0.55721}, "CVE-2019-20754": {"epss_score": 0.0024, "epss_percentile": 0.4722}, "CVE-2019-20755": {"epss_score": 0.0024, "epss_percentile": 0.4722}, "CVE-2019-20756": {"epss_score": 0.00441, "epss_percentile": 0.62669}, "CVE-2019-20757": {"epss_score": 0.00312, "epss_percentile": 0.53985}, "CVE-2019-20758": {"epss_score": 0.00332, "epss_percentile": 0.5556}, "CVE-2019-20759": {"epss_score": 0.00177, "epss_percentile": 0.39532}, "CVE-2019-20760": {"epss_score": 0.00174, "epss_percentile": 0.39194}, "CVE-2019-20761": {"epss_score": 0.00406, "epss_percentile": 0.60555}, "CVE-2019-20762": {"epss_score": 0.003, "epss_percentile": 0.52983}, "CVE-2019-20763": {"epss_score": 0.0034, "epss_percentile": 0.5627}, "CVE-2019-20764": {"epss_score": 0.0034, "epss_percentile": 0.5627}, "CVE-2019-20765": {"epss_score": 0.003, "epss_percentile": 0.52983}, "CVE-2019-20766": {"epss_score": 0.0034, "epss_percentile": 0.5627}, "CVE-2019-20767": {"epss_score": 0.00659, "epss_percentile": 0.70507}, "CVE-2019-20768": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-20769": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2019-20770": {"epss_score": 0.00018, "epss_percentile": 0.03721}, "CVE-2019-20771": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2019-20772": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2019-20773": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2019-20774": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2019-20775": {"epss_score": 8e-05, "epss_percentile": 0.00471}, "CVE-2019-20776": {"epss_score": 0.00016, "epss_percentile": 0.02625}, "CVE-2019-20777": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2019-20778": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2019-20779": {"epss_score": 0.00016, "epss_percentile": 0.02625}, "CVE-2019-20780": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2019-20781": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2019-20782": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2019-20783": {"epss_score": 0.00139, "epss_percentile": 0.34659}, "CVE-2019-20784": {"epss_score": 0.00018, "epss_percentile": 0.03704}, "CVE-2019-20785": {"epss_score": 0.00017, "epss_percentile": 0.03397}, "CVE-2019-20786": {"epss_score": 0.0122, "epss_percentile": 0.78617}, "CVE-2019-20787": {"epss_score": 0.00677, "epss_percentile": 0.70954}, "CVE-2019-20788": {"epss_score": 0.00796, "epss_percentile": 0.7348}, "CVE-2019-20789": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2019-20790": {"epss_score": 0.00226, "epss_percentile": 0.45277}, "CVE-2019-20791": {"epss_score": 0.00399, "epss_percentile": 0.60114}, "CVE-2019-20792": {"epss_score": 0.00165, "epss_percentile": 0.38061}, "CVE-2019-20794": {"epss_score": 0.00093, "epss_percentile": 0.26725}, "CVE-2019-20795": {"epss_score": 0.0003, "epss_percentile": 0.08094}, "CVE-2019-20797": {"epss_score": 0.01474, "epss_percentile": 0.80518}, "CVE-2019-20798": {"epss_score": 0.00857, "epss_percentile": 0.74495}, "CVE-2019-20799": {"epss_score": 0.04965, "epss_percentile": 0.89342}, "CVE-2019-20800": {"epss_score": 0.01312, "epss_percentile": 0.79375}, "CVE-2019-20801": {"epss_score": 0.00213, "epss_percentile": 0.43947}, "CVE-2019-20802": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-20803": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2019-20804": {"epss_score": 0.00219, "epss_percentile": 0.44489}, "CVE-2019-20805": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2019-20806": {"epss_score": 0.00119, "epss_percentile": 0.31574}, "CVE-2019-20807": {"epss_score": 0.00206, "epss_percentile": 0.42942}, "CVE-2019-20808": {"epss_score": 0.00121, "epss_percentile": 0.31945}, "CVE-2019-20809": {"epss_score": 0.0025, "epss_percentile": 0.48098}, "CVE-2019-20810": {"epss_score": 0.00069, "epss_percentile": 0.21447}, "CVE-2019-20811": {"epss_score": 0.00028, "epss_percentile": 0.07482}, "CVE-2019-20812": {"epss_score": 0.00069, "epss_percentile": 0.21486}, "CVE-2019-20813": {"epss_score": 0.00021, "epss_percentile": 0.04701}, "CVE-2019-20814": {"epss_score": 0.00021, "epss_percentile": 0.04701}, "CVE-2019-20815": {"epss_score": 0.00026, "epss_percentile": 0.06713}, "CVE-2019-20816": {"epss_score": 0.00026, "epss_percentile": 0.06713}, "CVE-2019-20817": {"epss_score": 0.00021, "epss_percentile": 0.04701}, "CVE-2019-20818": {"epss_score": 0.00021, "epss_percentile": 0.04701}, "CVE-2019-20819": {"epss_score": 0.00026, "epss_percentile": 0.06713}, "CVE-2019-20820": {"epss_score": 0.00026, "epss_percentile": 0.06713}, "CVE-2019-20821": {"epss_score": 0.00018, "epss_percentile": 0.03636}, "CVE-2019-20822": {"epss_score": 0.00023, "epss_percentile": 0.05415}, "CVE-2019-20823": {"epss_score": 0.00019, "epss_percentile": 0.04236}, "CVE-2019-20824": {"epss_score": 0.00018, "epss_percentile": 0.03636}, "CVE-2019-20825": {"epss_score": 0.00023, "epss_percentile": 0.05415}, "CVE-2019-20826": {"epss_score": 0.00018, "epss_percentile": 0.03636}, "CVE-2019-20827": {"epss_score": 0.00023, "epss_percentile": 0.05415}, "CVE-2019-20828": {"epss_score": 0.00022, "epss_percentile": 0.05198}, "CVE-2019-20829": {"epss_score": 0.00021, "epss_percentile": 0.04701}, "CVE-2019-20830": {"epss_score": 0.00027, "epss_percentile": 0.0675}, "CVE-2019-20831": {"epss_score": 0.00018, "epss_percentile": 0.03636}, "CVE-2019-20832": {"epss_score": 0.00031, "epss_percentile": 0.08338}, "CVE-2019-20833": {"epss_score": 0.00013, "epss_percentile": 0.01481}, "CVE-2019-20834": {"epss_score": 7e-05, "epss_percentile": 0.00401}, "CVE-2019-20835": {"epss_score": 0.00048, "epss_percentile": 0.15219}, "CVE-2019-20836": {"epss_score": 0.00015, "epss_percentile": 0.02171}, "CVE-2019-20837": {"epss_score": 7e-05, "epss_percentile": 0.0039}, "CVE-2019-20838": {"epss_score": 0.00306, "epss_percentile": 0.53425}, "CVE-2019-20839": {"epss_score": 0.04081, "epss_percentile": 0.88218}, "CVE-2019-20840": {"epss_score": 0.02026, "epss_percentile": 0.83316}, "CVE-2019-20841": {"epss_score": 0.00142, "epss_percentile": 0.34973}, "CVE-2019-20842": {"epss_score": 0.00432, "epss_percentile": 0.62107}, "CVE-2019-20843": {"epss_score": 0.00209, "epss_percentile": 0.43312}, "CVE-2019-20844": {"epss_score": 0.00131, "epss_percentile": 0.33366}, "CVE-2019-20845": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-20846": {"epss_score": 0.00209, "epss_percentile": 0.43312}, "CVE-2019-20847": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-20848": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-20849": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2019-20850": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2019-20851": {"epss_score": 0.00794, "epss_percentile": 0.73458}, "CVE-2019-20852": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-20853": {"epss_score": 0.02269, "epss_percentile": 0.84203}, "CVE-2019-20854": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2019-20855": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-20856": {"epss_score": 0.00446, "epss_percentile": 0.62901}, "CVE-2019-20857": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-20858": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-20859": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-20860": {"epss_score": 0.00241, "epss_percentile": 0.4729}, "CVE-2019-20861": {"epss_score": 0.00727, "epss_percentile": 0.721}, "CVE-2019-20862": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-20863": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-20864": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-20865": {"epss_score": 0.00171, "epss_percentile": 0.38802}, "CVE-2019-20866": {"epss_score": 0.00206, "epss_percentile": 0.42781}, "CVE-2019-20867": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-20868": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-20869": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-20870": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2019-20871": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-20872": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2019-20873": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2019-20874": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-20875": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2019-20876": {"epss_score": 0.00351, "epss_percentile": 0.57009}, "CVE-2019-20877": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2019-20878": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2019-20879": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2019-20880": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-20881": {"epss_score": 0.00283, "epss_percentile": 0.51359}, "CVE-2019-20882": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2019-20883": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2019-20884": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-20885": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2019-20886": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2019-20887": {"epss_score": 0.00112, "epss_percentile": 0.30556}, "CVE-2019-20888": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-20889": {"epss_score": 0.00148, "epss_percentile": 0.3582}, "CVE-2019-20890": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2019-20891": {"epss_score": 0.0013, "epss_percentile": 0.33279}, "CVE-2019-20892": {"epss_score": 0.00501, "epss_percentile": 0.65346}, "CVE-2019-20893": {"epss_score": 0.00853, "epss_percentile": 0.74425}, "CVE-2019-20894": {"epss_score": 0.00773, "epss_percentile": 0.73058}, "CVE-2019-20896": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2019-20897": {"epss_score": 0.00637, "epss_percentile": 0.69899}, "CVE-2019-20898": {"epss_score": 0.00292, "epss_percentile": 0.5223}, "CVE-2019-20899": {"epss_score": 0.00484, "epss_percentile": 0.64629}, "CVE-2019-20900": {"epss_score": 0.00277, "epss_percentile": 0.50812}, "CVE-2019-20901": {"epss_score": 0.00266, "epss_percentile": 0.49947}, "CVE-2019-20902": {"epss_score": 0.003, "epss_percentile": 0.52987}, "CVE-2019-20903": {"epss_score": 0.0041, "epss_percentile": 0.6083}, "CVE-2019-20907": {"epss_score": 0.00323, "epss_percentile": 0.54899}, "CVE-2019-20908": {"epss_score": 0.00021, "epss_percentile": 0.04737}, "CVE-2019-20909": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2019-20910": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2019-20911": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2019-20912": {"epss_score": 0.0042, "epss_percentile": 0.61459}, "CVE-2019-20913": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2019-20914": {"epss_score": 0.00372, "epss_percentile": 0.58439}, "CVE-2019-20915": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2019-20916": {"epss_score": 0.00622, "epss_percentile": 0.69506}, "CVE-2019-20917": {"epss_score": 0.00672, "epss_percentile": 0.70812}, "CVE-2019-20918": {"epss_score": 0.00797, "epss_percentile": 0.73491}, "CVE-2019-20919": {"epss_score": 0.00116, "epss_percentile": 0.31133}, "CVE-2019-20920": {"epss_score": 0.00343, "epss_percentile": 0.56405}, "CVE-2019-20921": {"epss_score": 0.00545, "epss_percentile": 0.67177}, "CVE-2019-20922": {"epss_score": 0.00226, "epss_percentile": 0.45271}, "CVE-2019-20923": {"epss_score": 0.00426, "epss_percentile": 0.61758}, "CVE-2019-20924": {"epss_score": 0.00426, "epss_percentile": 0.61758}, "CVE-2019-20925": {"epss_score": 0.00478, "epss_percentile": 0.64406}, "CVE-2019-20933": {"epss_score": 0.93968, "epss_percentile": 0.99876}, "CVE-2019-20934": {"epss_score": 0.00039, "epss_percentile": 0.11733}, "CVE-2019-25001": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2019-25002": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-25003": {"epss_score": 0.00285, "epss_percentile": 0.51538}, "CVE-2019-25004": {"epss_score": 0.00166, "epss_percentile": 0.38162}, "CVE-2019-25005": {"epss_score": 0.00285, "epss_percentile": 0.51538}, "CVE-2019-25006": {"epss_score": 0.00156, "epss_percentile": 0.36983}, "CVE-2019-25007": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-25009": {"epss_score": 0.00402, "epss_percentile": 0.6029}, "CVE-2019-25010": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-25011": {"epss_score": 0.00533, "epss_percentile": 0.66763}, "CVE-2019-25012": {"epss_score": 0.00294, "epss_percentile": 0.52419}, "CVE-2019-25013": {"epss_score": 0.00626, "epss_percentile": 0.69612}, "CVE-2019-25014": {"epss_score": 0.00154, "epss_percentile": 0.36653}, "CVE-2019-25015": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2019-25016": {"epss_score": 0.01024, "epss_percentile": 0.76782}, "CVE-2019-25017": {"epss_score": 0.00608, "epss_percentile": 0.69083}, "CVE-2019-25018": {"epss_score": 0.00059, "epss_percentile": 0.18779}, "CVE-2019-25019": {"epss_score": 0.00441, "epss_percentile": 0.62684}, "CVE-2019-25020": {"epss_score": 0.00238, "epss_percentile": 0.46763}, "CVE-2019-25021": {"epss_score": 0.00262, "epss_percentile": 0.49346}, "CVE-2019-25022": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-25023": {"epss_score": 0.00285, "epss_percentile": 0.51641}, "CVE-2019-25024": {"epss_score": 0.6835, "epss_percentile": 0.98543}, "CVE-2019-25025": {"epss_score": 0.00493, "epss_percentile": 0.65065}, "CVE-2019-25026": {"epss_score": 0.00435, "epss_percentile": 0.62358}, "CVE-2019-25027": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2019-25028": {"epss_score": 0.00347, "epss_percentile": 0.56749}, "CVE-2019-25029": {"epss_score": 0.02411, "epss_percentile": 0.84666}, "CVE-2019-25030": {"epss_score": 0.00047, "epss_percentile": 0.14686}, "CVE-2019-25031": {"epss_score": 0.00801, "epss_percentile": 0.73579}, "CVE-2019-25032": {"epss_score": 0.00184, "epss_percentile": 0.40434}, "CVE-2019-25033": {"epss_score": 0.00235, "epss_percentile": 0.46208}, "CVE-2019-25034": {"epss_score": 0.00729, "epss_percentile": 0.72136}, "CVE-2019-25035": {"epss_score": 0.00729, "epss_percentile": 0.72136}, "CVE-2019-25036": {"epss_score": 0.00929, "epss_percentile": 0.7559}, "CVE-2019-25037": {"epss_score": 0.00177, "epss_percentile": 0.39617}, "CVE-2019-25038": {"epss_score": 0.00184, "epss_percentile": 0.40434}, "CVE-2019-25039": {"epss_score": 0.00729, "epss_percentile": 0.72136}, "CVE-2019-25040": {"epss_score": 0.00929, "epss_percentile": 0.7559}, "CVE-2019-25041": {"epss_score": 0.00177, "epss_percentile": 0.39617}, "CVE-2019-25042": {"epss_score": 0.00729, "epss_percentile": 0.72136}, "CVE-2019-25043": {"epss_score": 0.00382, "epss_percentile": 0.59075}, "CVE-2019-25044": {"epss_score": 0.00133, "epss_percentile": 0.33716}, "CVE-2019-25045": {"epss_score": 0.00073, "epss_percentile": 0.22564}, "CVE-2019-25046": {"epss_score": 0.00419, "epss_percentile": 0.61401}, "CVE-2019-25047": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2019-25048": {"epss_score": 0.00221, "epss_percentile": 0.44679}, "CVE-2019-25049": {"epss_score": 0.00221, "epss_percentile": 0.44679}, "CVE-2019-25050": {"epss_score": 0.00089, "epss_percentile": 0.25924}, "CVE-2019-25051": {"epss_score": 0.00045, "epss_percentile": 0.13896}, "CVE-2019-25052": {"epss_score": 0.00203, "epss_percentile": 0.42502}, "CVE-2019-25053": {"epss_score": 0.00155, "epss_percentile": 0.36816}, "CVE-2019-25054": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2019-25055": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-25056": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2019-25057": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-25058": {"epss_score": 0.00029, "epss_percentile": 0.07612}, "CVE-2019-25059": {"epss_score": 0.00176, "epss_percentile": 0.3946}, "CVE-2019-25060": {"epss_score": 0.00513, "epss_percentile": 0.65926}, "CVE-2019-25061": {"epss_score": 0.00338, "epss_percentile": 0.5615}, "CVE-2019-25062": {"epss_score": 0.00087, "epss_percentile": 0.25595}, "CVE-2019-25063": {"epss_score": 0.00044, "epss_percentile": 0.13556}, "CVE-2019-25064": {"epss_score": 0.00077, "epss_percentile": 0.23376}, "CVE-2019-25065": {"epss_score": 0.73707, "epss_percentile": 0.98768}, "CVE-2019-25066": {"epss_score": 0.77639, "epss_percentile": 0.98945}, "CVE-2019-25067": {"epss_score": 0.00804, "epss_percentile": 0.73626}, "CVE-2019-25068": {"epss_score": 0.00221, "epss_percentile": 0.44698}, "CVE-2019-25069": {"epss_score": 0.00239, "epss_percentile": 0.46887}, "CVE-2019-25070": {"epss_score": 0.00353, "epss_percentile": 0.5716}, "CVE-2019-25071": {"epss_score": 0.00725, "epss_percentile": 0.72044}, "CVE-2019-25072": {"epss_score": 0.00271, "epss_percentile": 0.50315}, "CVE-2019-25073": {"epss_score": 0.00324, "epss_percentile": 0.54962}, "CVE-2019-25075": {"epss_score": 0.00364, "epss_percentile": 0.57944}, "CVE-2019-25076": {"epss_score": 0.00677, "epss_percentile": 0.70951}, "CVE-2019-25078": {"epss_score": 0.0019, "epss_percentile": 0.41091}, "CVE-2019-25084": {"epss_score": 0.00285, "epss_percentile": 0.51646}, "CVE-2019-25085": {"epss_score": 0.00525, "epss_percentile": 0.66366}, "CVE-2019-25086": {"epss_score": 0.01018, "epss_percentile": 0.76717}, "CVE-2019-25087": {"epss_score": 0.00504, "epss_percentile": 0.65548}, "CVE-2019-25088": {"epss_score": 0.00461, "epss_percentile": 0.63545}, "CVE-2019-25089": {"epss_score": 0.00292, "epss_percentile": 0.52223}, "CVE-2019-25090": {"epss_score": 0.00392, "epss_percentile": 0.59676}, "CVE-2019-25091": {"epss_score": 0.00253, "epss_percentile": 0.48427}, "CVE-2019-25092": {"epss_score": 0.00313, "epss_percentile": 0.54019}, "CVE-2019-25093": {"epss_score": 0.00396, "epss_percentile": 0.59905}, "CVE-2019-25094": {"epss_score": 0.00306, "epss_percentile": 0.53442}, "CVE-2019-25095": {"epss_score": 0.00333, "epss_percentile": 0.55615}, "CVE-2019-25096": {"epss_score": 0.003, "epss_percentile": 0.52965}, "CVE-2019-25097": {"epss_score": 0.0034, "epss_percentile": 0.56218}, "CVE-2019-25098": {"epss_score": 0.00333, "epss_percentile": 0.55667}, "CVE-2019-25099": {"epss_score": 0.00414, "epss_percentile": 0.61105}, "CVE-2019-25100": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2019-25101": {"epss_score": 0.0009, "epss_percentile": 0.2605}, "CVE-2019-25102": {"epss_score": 0.00107, "epss_percentile": 0.29648}, "CVE-2019-25103": {"epss_score": 0.00058, "epss_percentile": 0.18292}, "CVE-2019-25104": {"epss_score": 0.00074, "epss_percentile": 0.22863}, "CVE-2019-25105": {"epss_score": 0.00073, "epss_percentile": 0.2265}, "CVE-2019-25136": {"epss_score": 0.00325, "epss_percentile": 0.55017}, "CVE-2019-25137": {"epss_score": 0.31384, "epss_percentile": 0.96615}, "CVE-2019-25138": {"epss_score": 0.03579, "epss_percentile": 0.87382}, "CVE-2019-25139": {"epss_score": 0.00077, "epss_percentile": 0.23368}, "CVE-2019-25140": {"epss_score": 0.00573, "epss_percentile": 0.68065}, "CVE-2019-25141": {"epss_score": 0.59731, "epss_percentile": 0.98177}, "CVE-2019-25142": {"epss_score": 0.0044, "epss_percentile": 0.62618}, "CVE-2019-25143": {"epss_score": 0.0003, "epss_percentile": 0.08268}, "CVE-2019-25144": {"epss_score": 0.00252, "epss_percentile": 0.48359}, "CVE-2019-25145": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2019-25146": {"epss_score": 0.00859, "epss_percentile": 0.74518}, "CVE-2019-25147": {"epss_score": 0.00805, "epss_percentile": 0.73633}, "CVE-2019-25148": {"epss_score": 0.00327, "epss_percentile": 0.55138}, "CVE-2019-25149": {"epss_score": 0.00086, "epss_percentile": 0.25249}, "CVE-2019-25150": {"epss_score": 0.00339, "epss_percentile": 0.56206}, "CVE-2019-25151": {"epss_score": 0.0004, "epss_percentile": 0.12148}, "CVE-2019-25152": {"epss_score": 0.30617, "epss_percentile": 0.96556}, "CVE-2019-25154": {"epss_score": 0.00362, "epss_percentile": 0.57755}, "CVE-2019-25155": {"epss_score": 0.00242, "epss_percentile": 0.47382}, "CVE-2019-25156": {"epss_score": 0.00128, "epss_percentile": 0.32996}, "CVE-2019-25157": {"epss_score": 0.00054, "epss_percentile": 0.17148}, "CVE-2019-25158": {"epss_score": 0.00692, "epss_percentile": 0.71296}, "CVE-2019-25159": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2019-25160": {"epss_score": 0.00014, "epss_percentile": 0.01868}, "CVE-2019-25162": {"epss_score": 0.00051, "epss_percentile": 0.16023}, "CVE-2019-25210": {"epss_score": 0.00223, "epss_percentile": 0.44961}, "CVE-2019-25211": {"epss_score": 0.00355, "epss_percentile": 0.57282}, "CVE-2019-25212": {"epss_score": 0.00738, "epss_percentile": 0.72345}, "CVE-2019-25213": {"epss_score": 0.3958, "epss_percentile": 0.97169}, "CVE-2019-25214": {"epss_score": 0.00066, "epss_percentile": 0.20848}, "CVE-2019-25215": {"epss_score": 0.00035, "epss_percentile": 0.09992}, "CVE-2019-25216": {"epss_score": 0.00586, "epss_percentile": 0.68457}, "CVE-2019-25217": {"epss_score": 0.06209, "epss_percentile": 0.90568}, "CVE-2019-25218": {"epss_score": 0.00592, "epss_percentile": 0.68607}, "CVE-2019-25219": {"epss_score": 0.00223, "epss_percentile": 0.44944}, "CVE-2019-25220": {"epss_score": 0.00938, "epss_percentile": 0.75707}, "CVE-2019-25221": {"epss_score": 0.0061, "epss_percentile": 0.69146}, "CVE-2019-25222": {"epss_score": 0.00207, "epss_percentile": 0.43121}, "CVE-2019-25223": {"epss_score": 0.00054, "epss_percentile": 0.17097}, "CVE-2019-25224": {"epss_score": 0.78834, "epss_percentile": 0.99005}, "CVE-2019-25225": {"epss_score": 0.00069, "epss_percentile": 0.21539}, "CVE-2019-25226": {"epss_score": 0.00336, "epss_percentile": 0.55901}, "CVE-2019-25227": {"epss_score": 0.00316, "epss_percentile": 0.54224}, "CVE-2019-25228": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2019-25229": {"epss_score": 0.00039, "epss_percentile": 0.11542}, "CVE-2019-25230": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2019-25231": {"epss_score": 0.00012, "epss_percentile": 0.0132}, "CVE-2019-25233": {"epss_score": 0.00023, "epss_percentile": 0.05601}, "CVE-2019-25234": {"epss_score": 0.00016, "epss_percentile": 0.02836}, "CVE-2019-25235": {"epss_score": 0.00207, "epss_percentile": 0.43199}, "CVE-2019-25236": {"epss_score": 0.00107, "epss_percentile": 0.29639}, "CVE-2019-25237": {"epss_score": 0.00099, "epss_percentile": 0.28376}, "CVE-2019-25238": {"epss_score": 0.00015, "epss_percentile": 0.02439}, "CVE-2019-25239": {"epss_score": 0.00088, "epss_percentile": 0.25701}, "CVE-2019-25240": {"epss_score": 0.00097, "epss_percentile": 0.27631}, "CVE-2019-25241": {"epss_score": 0.0027, "epss_percentile": 0.50213}, "CVE-2019-25242": {"epss_score": 0.00021, "epss_percentile": 0.04897}, "CVE-2019-25243": {"epss_score": 0.00934, "epss_percentile": 0.75651}, "CVE-2019-25244": {"epss_score": 0.00034, "epss_percentile": 0.09615}, "CVE-2019-25245": {"epss_score": 0.00029, "epss_percentile": 0.07735}, "CVE-2019-25246": {"epss_score": 0.00028, "epss_percentile": 0.07485}, "CVE-2019-25247": {"epss_score": 0.00018, "epss_percentile": 0.03749}, "CVE-2019-25248": {"epss_score": 0.00145, "epss_percentile": 0.35412}, "CVE-2019-25249": {"epss_score": 0.00099, "epss_percentile": 0.28367}, "CVE-2019-25250": {"epss_score": 0.00018, "epss_percentile": 0.03749}, "CVE-2019-25251": {"epss_score": 0.00035, "epss_percentile": 0.09894}, "CVE-2019-25252": {"epss_score": 0.00018, "epss_percentile": 0.03749}, "CVE-2019-25253": {"epss_score": 0.00082, "epss_percentile": 0.24439}, "CVE-2019-25254": {"epss_score": 0.00018, "epss_percentile": 0.03749}, "CVE-2019-25255": {"epss_score": 0.0009, "epss_percentile": 0.26018}, "CVE-2019-25256": {"epss_score": 0.00373, "epss_percentile": 0.58526}, "CVE-2019-25257": {"epss_score": 0.00052, "epss_percentile": 0.16587}, "CVE-2019-25258": {"epss_score": 0.00659, "epss_percentile": 0.70507}, "CVE-2019-25259": {"epss_score": 0.00016, "epss_percentile": 0.02622}, "CVE-2019-25262": {"epss_score": 0.00028, "epss_percentile": 0.07232}, "CVE-2019-25268": {"epss_score": 0.00046, "epss_percentile": 0.14284}, "CVE-2019-25270": {"epss_score": 0.00033, "epss_percentile": 0.09176}, "CVE-2019-25277": {"epss_score": 0.00043, "epss_percentile": 0.1323}, "CVE-2019-25278": {"epss_score": 0.00067, "epss_percentile": 0.20974}, "CVE-2019-25279": {"epss_score": 0.00025, "epss_percentile": 0.06357}, "CVE-2019-25280": {"epss_score": 0.00041, "epss_percentile": 0.12211}, "CVE-2019-25282": {"epss_score": 0.00045, "epss_percentile": 0.13731}, "CVE-2019-25284": {"epss_score": 0.00036, "epss_percentile": 0.10354}, "CVE-2019-25289": {"epss_score": 0.00299, "epss_percentile": 0.52869}, "CVE-2019-25290": {"epss_score": 0.00027, "epss_percentile": 0.06915}, "CVE-2019-25291": {"epss_score": 0.0003, "epss_percentile": 0.0798}, "CVE-2019-25295": {"epss_score": 0.00185, "epss_percentile": 0.40487}, "CVE-2019-25296": {"epss_score": 0.00207, "epss_percentile": 0.43178}, "CVE-2019-2000": {"epss_score": 0.00872, "epss_percentile": 0.74735}, "CVE-2019-2001": {"epss_score": 0.00019, "epss_percentile": 0.04235}, "CVE-2019-2003": {"epss_score": 0.01673, "epss_percentile": 0.81684}, "CVE-2019-2004": {"epss_score": 0.00037, "epss_percentile": 0.10626}, "CVE-2019-2005": {"epss_score": 0.00114, "epss_percentile": 0.30837}, "CVE-2019-2006": {"epss_score": 0.00136, "epss_percentile": 0.34191}, "CVE-2019-2007": {"epss_score": 0.00165, "epss_percentile": 0.38056}, "CVE-2019-2008": {"epss_score": 0.00113, "epss_percentile": 0.30701}, "CVE-2019-2009": {"epss_score": 0.00676, "epss_percentile": 0.70927}, "CVE-2019-2010": {"epss_score": 0.00034, "epss_percentile": 0.09739}, "CVE-2019-2011": {"epss_score": 0.00034, "epss_percentile": 0.09739}, "CVE-2019-2012": {"epss_score": 0.00145, "epss_percentile": 0.35357}, "CVE-2019-2013": {"epss_score": 0.00145, "epss_percentile": 0.35357}, "CVE-2019-2014": {"epss_score": 0.00145, "epss_percentile": 0.35357}, "CVE-2019-2015": {"epss_score": 0.00145, "epss_percentile": 0.35357}, "CVE-2019-2016": {"epss_score": 0.00145, "epss_percentile": 0.35357}, "CVE-2019-2017": {"epss_score": 0.00034, "epss_percentile": 0.09739}, "CVE-2019-2018": {"epss_score": 0.0008, "epss_percentile": 0.24037}, "CVE-2019-2019": {"epss_score": 0.00103, "epss_percentile": 0.29002}, "CVE-2019-2020": {"epss_score": 0.00131, "epss_percentile": 0.33465}, "CVE-2019-2021": {"epss_score": 0.00131, "epss_percentile": 0.33465}, "CVE-2019-2022": {"epss_score": 0.00131, "epss_percentile": 0.33465}, "CVE-2019-2023": {"epss_score": 0.00223, "epss_percentile": 0.44877}, "CVE-2019-2024": {"epss_score": 0.00086, "epss_percentile": 0.25398}, "CVE-2019-2025": {"epss_score": 0.00252, "epss_percentile": 0.48386}, "CVE-2019-2026": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2019-2027": {"epss_score": 0.00343, "epss_percentile": 0.56439}, "CVE-2019-2028": {"epss_score": 0.0037, "epss_percentile": 0.5829}, "CVE-2019-2029": {"epss_score": 0.00564, "epss_percentile": 0.67769}, "CVE-2019-2030": {"epss_score": 0.00889, "epss_percentile": 0.75023}, "CVE-2019-2031": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2019-2032": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2019-2033": {"epss_score": 0.0001, "epss_percentile": 0.00756}, "CVE-2019-2034": {"epss_score": 0.00056, "epss_percentile": 0.17816}, "CVE-2019-2035": {"epss_score": 0.00056, "epss_percentile": 0.17816}, "CVE-2019-2036": {"epss_score": 0.00605, "epss_percentile": 0.6897}, "CVE-2019-2037": {"epss_score": 0.00314, "epss_percentile": 0.54137}, "CVE-2019-2038": {"epss_score": 0.00062, "epss_percentile": 0.19632}, "CVE-2019-2039": {"epss_score": 0.00036, "epss_percentile": 0.10307}, "CVE-2019-2040": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-2041": {"epss_score": 0.00013, "epss_percentile": 0.01592}, "CVE-2019-2043": {"epss_score": 0.00014, "epss_percentile": 0.01911}, "CVE-2019-2044": {"epss_score": 0.01214, "epss_percentile": 0.78576}, "CVE-2019-2045": {"epss_score": 0.00873, "epss_percentile": 0.74748}, "CVE-2019-2046": {"epss_score": 0.01182, "epss_percentile": 0.78318}, "CVE-2019-2047": {"epss_score": 0.00873, "epss_percentile": 0.74748}, "CVE-2019-2049": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2019-2050": {"epss_score": 0.00012, "epss_percentile": 0.01119}, "CVE-2019-2051": {"epss_score": 0.00396, "epss_percentile": 0.59889}, "CVE-2019-2052": {"epss_score": 0.00396, "epss_percentile": 0.59889}, "CVE-2019-2053": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-2054": {"epss_score": 0.00384, "epss_percentile": 0.59125}, "CVE-2019-2055": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2056": {"epss_score": 0.00034, "epss_percentile": 0.09653}, "CVE-2019-2058": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-2059": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2060": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2061": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2062": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2063": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2064": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2065": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2066": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2067": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2068": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2069": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2070": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2071": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2072": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2073": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2074": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2075": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2076": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2077": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2078": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2079": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2080": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2081": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2082": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2083": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2084": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2085": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2086": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2087": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2088": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-2089": {"epss_score": 0.00013, "epss_percentile": 0.0162}, "CVE-2019-2090": {"epss_score": 0.0001, "epss_percentile": 0.00897}, "CVE-2019-2091": {"epss_score": 9e-05, "epss_percentile": 0.00628}, "CVE-2019-2092": {"epss_score": 9e-05, "epss_percentile": 0.00628}, "CVE-2019-2093": {"epss_score": 0.0037, "epss_percentile": 0.5829}, "CVE-2019-2094": {"epss_score": 0.00177, "epss_percentile": 0.39606}, "CVE-2019-2095": {"epss_score": 0.00264, "epss_percentile": 0.4957}, "CVE-2019-2096": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2019-2097": {"epss_score": 0.00873, "epss_percentile": 0.74748}, "CVE-2019-2098": {"epss_score": 9e-05, "epss_percentile": 0.00628}, "CVE-2019-2099": {"epss_score": 0.00036, "epss_percentile": 0.10227}, "CVE-2019-2101": {"epss_score": 0.00107, "epss_percentile": 0.29645}, "CVE-2019-2102": {"epss_score": 0.00099, "epss_percentile": 0.28425}, "CVE-2019-2103": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2019-2104": {"epss_score": 0.00015, "epss_percentile": 0.02294}, "CVE-2019-2105": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2106": {"epss_score": 0.0037, "epss_percentile": 0.5829}, "CVE-2019-2107": {"epss_score": 0.44303, "epss_percentile": 0.97429}, "CVE-2019-2108": {"epss_score": 0.00177, "epss_percentile": 0.39606}, "CVE-2019-2109": {"epss_score": 0.00343, "epss_percentile": 0.56439}, "CVE-2019-2110": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2019-2111": {"epss_score": 0.00758, "epss_percentile": 0.72773}, "CVE-2019-2112": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2019-2113": {"epss_score": 0.00018, "epss_percentile": 0.03704}, "CVE-2019-2114": {"epss_score": 0.00015, "epss_percentile": 0.02548}, "CVE-2019-2115": {"epss_score": 0.00031, "epss_percentile": 0.08398}, "CVE-2019-2116": {"epss_score": 0.00314, "epss_percentile": 0.54137}, "CVE-2019-2117": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2019-2118": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-2119": {"epss_score": 0.00013, "epss_percentile": 0.01546}, "CVE-2019-2120": {"epss_score": 0.00013, "epss_percentile": 0.01592}, "CVE-2019-2121": {"epss_score": 0.0001, "epss_percentile": 0.00812}, "CVE-2019-2122": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2019-2123": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2019-2124": {"epss_score": 0.00017, "epss_percentile": 0.03378}, "CVE-2019-2125": {"epss_score": 0.00014, "epss_percentile": 0.01789}, "CVE-2019-2126": {"epss_score": 0.09309, "epss_percentile": 0.92494}, "CVE-2019-2127": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2019-2128": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2019-2129": {"epss_score": 0.00245, "epss_percentile": 0.47691}, "CVE-2019-2130": {"epss_score": 0.01098, "epss_percentile": 0.77535}, "CVE-2019-2131": {"epss_score": 0.0004, "epss_percentile": 0.11961}, "CVE-2019-2132": {"epss_score": 0.00038, "epss_percentile": 0.11392}, "CVE-2019-2133": {"epss_score": 0.00066, "epss_percentile": 0.20697}, "CVE-2019-2134": {"epss_score": 0.00038, "epss_percentile": 0.11392}, "CVE-2019-2135": {"epss_score": 0.00053, "epss_percentile": 0.16941}, "CVE-2019-2136": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-2137": {"epss_score": 0.00016, "epss_percentile": 0.02662}, "CVE-2019-2138": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2139": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2140": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2141": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2142": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2143": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2144": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2145": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2146": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2147": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2148": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2149": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2150": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2151": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2152": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2153": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2154": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2155": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2156": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2157": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2158": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2159": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-2160": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2161": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2162": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-2163": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2164": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2165": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2166": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2167": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2168": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2169": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2170": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2171": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2172": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-2173": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2019-2174": {"epss_score": 0.00012, "epss_percentile": 0.01119}, "CVE-2019-2175": {"epss_score": 0.00013, "epss_percentile": 0.0162}, "CVE-2019-2176": {"epss_score": 0.00177, "epss_percentile": 0.39606}, "CVE-2019-2177": {"epss_score": 0.00205, "epss_percentile": 0.42746}, "CVE-2019-2178": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2019-2179": {"epss_score": 0.00062, "epss_percentile": 0.19632}, "CVE-2019-2180": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-2181": {"epss_score": 0.00021, "epss_percentile": 0.04888}, "CVE-2019-2182": {"epss_score": 0.00034, "epss_percentile": 0.09518}, "CVE-2019-2183": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-2184": {"epss_score": 0.0037, "epss_percentile": 0.5829}, "CVE-2019-2185": {"epss_score": 0.0037, "epss_percentile": 0.5829}, "CVE-2019-2186": {"epss_score": 0.0037, "epss_percentile": 0.5829}, "CVE-2019-2187": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-2188": {"epss_score": 0.00011, "epss_percentile": 0.00978}, "CVE-2019-2189": {"epss_score": 0.00011, "epss_percentile": 0.00978}, "CVE-2019-2190": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-2191": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-2192": {"epss_score": 0.00011, "epss_percentile": 0.0103}, "CVE-2019-2193": {"epss_score": 0.0001, "epss_percentile": 0.00883}, "CVE-2019-2194": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2019-2195": {"epss_score": 0.00033, "epss_percentile": 0.09398}, "CVE-2019-2196": {"epss_score": 0.0069, "epss_percentile": 0.71256}, "CVE-2019-2197": {"epss_score": 0.00015, "epss_percentile": 0.02349}, "CVE-2019-2198": {"epss_score": 0.0069, "epss_percentile": 0.71256}, "CVE-2019-2199": {"epss_score": 0.00011, "epss_percentile": 0.00972}, "CVE-2019-2200": {"epss_score": 8e-05, "epss_percentile": 0.00553}, "CVE-2019-2201": {"epss_score": 0.01083, "epss_percentile": 0.77391}, "CVE-2019-2202": {"epss_score": 0.00035, "epss_percentile": 0.10158}, "CVE-2019-2203": {"epss_score": 0.00035, "epss_percentile": 0.10158}, "CVE-2019-2204": {"epss_score": 0.01253, "epss_percentile": 0.78918}, "CVE-2019-2205": {"epss_score": 0.07716, "epss_percentile": 0.9164}, "CVE-2019-2206": {"epss_score": 0.01238, "epss_percentile": 0.78786}, "CVE-2019-2207": {"epss_score": 0.00034, "epss_percentile": 0.09739}, "CVE-2019-2208": {"epss_score": 0.00417, "epss_percentile": 0.61259}, "CVE-2019-2209": {"epss_score": 0.00044, "epss_percentile": 0.13661}, "CVE-2019-2210": {"epss_score": 0.00035, "epss_percentile": 0.10158}, "CVE-2019-2211": {"epss_score": 0.00191, "epss_percentile": 0.41259}, "CVE-2019-2212": {"epss_score": 0.00044, "epss_percentile": 0.13661}, "CVE-2019-2213": {"epss_score": 0.00035, "epss_percentile": 0.10151}, "CVE-2019-2214": {"epss_score": 0.0005, "epss_percentile": 0.15772}, "CVE-2019-2215": {"epss_score": 0.53343, "epss_percentile": 0.97873}, "CVE-2019-2216": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2019-2217": {"epss_score": 0.00037, "epss_percentile": 0.10661}, "CVE-2019-2218": {"epss_score": 0.00013, "epss_percentile": 0.01535}, "CVE-2019-2219": {"epss_score": 0.00012, "epss_percentile": 0.01254}, "CVE-2019-2220": {"epss_score": 0.00015, "epss_percentile": 0.02349}, "CVE-2019-2221": {"epss_score": 0.0001, "epss_percentile": 0.00864}, "CVE-2019-2222": {"epss_score": 0.00665, "epss_percentile": 0.70654}, "CVE-2019-2223": {"epss_score": 0.00665, "epss_percentile": 0.70654}, "CVE-2019-2225": {"epss_score": 0.00636, "epss_percentile": 0.69832}, "CVE-2019-2226": {"epss_score": 0.00044, "epss_percentile": 0.13661}, "CVE-2019-2227": {"epss_score": 0.00439, "epss_percentile": 0.62608}, "CVE-2019-2228": {"epss_score": 0.00102, "epss_percentile": 0.28818}, "CVE-2019-2229": {"epss_score": 0.00032, "epss_percentile": 0.08776}, "CVE-2019-2230": {"epss_score": 0.01084, "epss_percentile": 0.77395}, "CVE-2019-2231": {"epss_score": 0.00024, "epss_percentile": 0.05959}, "CVE-2019-2232": {"epss_score": 0.00805, "epss_percentile": 0.73638}, "CVE-2019-2233": {"epss_score": 0.00049, "epss_percentile": 0.1547}, "CVE-2019-2235": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2019-2236": {"epss_score": 0.00044, "epss_percentile": 0.13513}, "CVE-2019-2237": {"epss_score": 0.00048, "epss_percentile": 0.15143}, "CVE-2019-2238": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-2239": {"epss_score": 0.00044, "epss_percentile": 0.13513}, "CVE-2019-2240": {"epss_score": 0.00048, "epss_percentile": 0.15143}, "CVE-2019-2241": {"epss_score": 0.00048, "epss_percentile": 0.15143}, "CVE-2019-2242": {"epss_score": 0.00379, "epss_percentile": 0.58857}, "CVE-2019-2243": {"epss_score": 0.00047, "epss_percentile": 0.14796}, "CVE-2019-2244": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-2245": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-2246": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-2247": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-2248": {"epss_score": 0.00045, "epss_percentile": 0.13758}, "CVE-2019-2249": {"epss_score": 0.00483, "epss_percentile": 0.64614}, "CVE-2019-2250": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-2251": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2019-2252": {"epss_score": 0.01204, "epss_percentile": 0.78501}, "CVE-2019-2253": {"epss_score": 0.0037, "epss_percentile": 0.58306}, "CVE-2019-2254": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2019-2255": {"epss_score": 0.00656, "epss_percentile": 0.70446}, "CVE-2019-2256": {"epss_score": 0.00656, "epss_percentile": 0.70446}, "CVE-2019-2257": {"epss_score": 0.00021, "epss_percentile": 0.04943}, "CVE-2019-2258": {"epss_score": 0.00251, "epss_percentile": 0.48323}, "CVE-2019-2259": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-2260": {"epss_score": 0.00032, "epss_percentile": 0.08956}, "CVE-2019-2261": {"epss_score": 0.00039, "epss_percentile": 0.11668}, "CVE-2019-2263": {"epss_score": 0.00044, "epss_percentile": 0.13562}, "CVE-2019-2264": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-2266": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2019-2267": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-2268": {"epss_score": 0.00336, "epss_percentile": 0.56001}, "CVE-2019-2269": {"epss_score": 0.00342, "epss_percentile": 0.5635}, "CVE-2019-2271": {"epss_score": 0.00374, "epss_percentile": 0.58566}, "CVE-2019-2272": {"epss_score": 0.00045, "epss_percentile": 0.13758}, "CVE-2019-2273": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2019-2274": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-2275": {"epss_score": 0.00047, "epss_percentile": 0.14796}, "CVE-2019-2276": {"epss_score": 0.00266, "epss_percentile": 0.49846}, "CVE-2019-2277": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-2278": {"epss_score": 0.00017, "epss_percentile": 0.03125}, "CVE-2019-2279": {"epss_score": 0.00322, "epss_percentile": 0.54823}, "CVE-2019-2281": {"epss_score": 0.00048, "epss_percentile": 0.15011}, "CVE-2019-2283": {"epss_score": 0.00312, "epss_percentile": 0.53991}, "CVE-2019-2284": {"epss_score": 0.00038, "epss_percentile": 0.11398}, "CVE-2019-2285": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-2287": {"epss_score": 0.00322, "epss_percentile": 0.54823}, "CVE-2019-2288": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-2289": {"epss_score": 0.00054, "epss_percentile": 0.17043}, "CVE-2019-2290": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-2292": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-2293": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-2294": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-2295": {"epss_score": 0.00096, "epss_percentile": 0.27304}, "CVE-2019-2297": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2019-2298": {"epss_score": 0.00044, "epss_percentile": 0.13562}, "CVE-2019-2299": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-2300": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-2301": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2019-2302": {"epss_score": 0.00402, "epss_percentile": 0.60307}, "CVE-2019-2303": {"epss_score": 0.00294, "epss_percentile": 0.52436}, "CVE-2019-2304": {"epss_score": 0.00121, "epss_percentile": 0.31879}, "CVE-2019-2305": {"epss_score": 0.00322, "epss_percentile": 0.54823}, "CVE-2019-2306": {"epss_score": 0.00023, "epss_percentile": 0.05354}, "CVE-2019-2307": {"epss_score": 0.00636, "epss_percentile": 0.69863}, "CVE-2019-2308": {"epss_score": 0.00035, "epss_percentile": 0.10064}, "CVE-2019-2309": {"epss_score": 0.00322, "epss_percentile": 0.54823}, "CVE-2019-2310": {"epss_score": 0.00297, "epss_percentile": 0.52709}, "CVE-2019-2311": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-2312": {"epss_score": 0.00045, "epss_percentile": 0.13758}, "CVE-2019-2314": {"epss_score": 0.00038, "epss_percentile": 0.11398}, "CVE-2019-2315": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-2316": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-2317": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2019-2318": {"epss_score": 0.00107, "epss_percentile": 0.29663}, "CVE-2019-2319": {"epss_score": 0.00102, "epss_percentile": 0.28812}, "CVE-2019-2320": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-2321": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-2322": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-2323": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-2324": {"epss_score": 0.00251, "epss_percentile": 0.48323}, "CVE-2019-2325": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-2326": {"epss_score": 0.00035, "epss_percentile": 0.10064}, "CVE-2019-2327": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2019-2328": {"epss_score": 0.00037, "epss_percentile": 0.10966}, "CVE-2019-2329": {"epss_score": 0.0009, "epss_percentile": 0.26039}, "CVE-2019-2330": {"epss_score": 0.00042, "epss_percentile": 0.12926}, "CVE-2019-2331": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-2332": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2019-2333": {"epss_score": 0.00045, "epss_percentile": 0.13758}, "CVE-2019-2334": {"epss_score": 0.00246, "epss_percentile": 0.47772}, "CVE-2019-2335": {"epss_score": 0.00359, "epss_percentile": 0.5755}, "CVE-2019-2336": {"epss_score": 0.00123, "epss_percentile": 0.32334}, "CVE-2019-2337": {"epss_score": 0.00369, "epss_percentile": 0.58253}, "CVE-2019-2338": {"epss_score": 0.00043, "epss_percentile": 0.13269}, "CVE-2019-2339": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2019-2341": {"epss_score": 0.00045, "epss_percentile": 0.13758}, "CVE-2019-2343": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2019-2345": {"epss_score": 0.00033, "epss_percentile": 0.09177}, "CVE-2019-2346": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2019-2386": {"epss_score": 0.00406, "epss_percentile": 0.60567}, "CVE-2019-2388": {"epss_score": 0.00285, "epss_percentile": 0.51525}, "CVE-2019-2389": {"epss_score": 0.0012, "epss_percentile": 0.31808}, "CVE-2019-2390": {"epss_score": 0.00381, "epss_percentile": 0.58981}, "CVE-2019-2391": {"epss_score": 0.00379, "epss_percentile": 0.58884}, "CVE-2019-2392": {"epss_score": 0.00426, "epss_percentile": 0.61758}, "CVE-2019-2393": {"epss_score": 0.00426, "epss_percentile": 0.61758}, "CVE-2019-2395": {"epss_score": 0.00327, "epss_percentile": 0.55133}, "CVE-2019-2396": {"epss_score": 0.00702, "epss_percentile": 0.71512}, "CVE-2019-2397": {"epss_score": 0.00061, "epss_percentile": 0.19321}, "CVE-2019-2398": {"epss_score": 0.00256, "epss_percentile": 0.48827}, "CVE-2019-2399": {"epss_score": 0.00947, "epss_percentile": 0.75824}, "CVE-2019-2400": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2019-2401": {"epss_score": 0.00872, "epss_percentile": 0.74721}, "CVE-2019-2402": {"epss_score": 0.01436, "epss_percentile": 0.80277}, "CVE-2019-2403": {"epss_score": 0.00496, "epss_percentile": 0.65174}, "CVE-2019-2404": {"epss_score": 0.00694, "epss_percentile": 0.71347}, "CVE-2019-2405": {"epss_score": 0.00826, "epss_percentile": 0.7397}, "CVE-2019-2406": {"epss_score": 0.01194, "epss_percentile": 0.78413}, "CVE-2019-2407": {"epss_score": 0.00107, "epss_percentile": 0.29718}, "CVE-2019-2408": {"epss_score": 0.00733, "epss_percentile": 0.72209}, "CVE-2019-2409": {"epss_score": 0.00081, "epss_percentile": 0.24265}, "CVE-2019-2410": {"epss_score": 0.00142, "epss_percentile": 0.34977}, "CVE-2019-2411": {"epss_score": 0.00308, "epss_percentile": 0.53632}, "CVE-2019-2412": {"epss_score": 0.00086, "epss_percentile": 0.25335}, "CVE-2019-2413": {"epss_score": 0.04759, "epss_percentile": 0.89117}, "CVE-2019-2414": {"epss_score": 0.00079, "epss_percentile": 0.23807}, "CVE-2019-2415": {"epss_score": 0.00237, "epss_percentile": 0.46685}, "CVE-2019-2416": {"epss_score": 0.01622, "epss_percentile": 0.81396}, "CVE-2019-2417": {"epss_score": 0.00496, "epss_percentile": 0.65174}, "CVE-2019-2418": {"epss_score": 0.00354, "epss_percentile": 0.57224}, "CVE-2019-2419": {"epss_score": 0.00198, "epss_percentile": 0.41976}, "CVE-2019-2420": {"epss_score": 0.00125, "epss_percentile": 0.32543}, "CVE-2019-2421": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2019-2422": {"epss_score": 0.00326, "epss_percentile": 0.55085}, "CVE-2019-2423": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2019-2424": {"epss_score": 0.00835, "epss_percentile": 0.74122}, "CVE-2019-2425": {"epss_score": 0.00496, "epss_percentile": 0.65174}, "CVE-2019-2426": {"epss_score": 0.00427, "epss_percentile": 0.61877}, "CVE-2019-2427": {"epss_score": 0.00812, "epss_percentile": 0.73743}, "CVE-2019-2429": {"epss_score": 0.00786, "epss_percentile": 0.73277}, "CVE-2019-2430": {"epss_score": 0.00368, "epss_percentile": 0.58176}, "CVE-2019-2431": {"epss_score": 0.00982, "epss_percentile": 0.76289}, "CVE-2019-2432": {"epss_score": 0.00187, "epss_percentile": 0.40747}, "CVE-2019-2433": {"epss_score": 0.01288, "epss_percentile": 0.79206}, "CVE-2019-2434": {"epss_score": 0.00221, "epss_percentile": 0.44645}, "CVE-2019-2435": {"epss_score": 0.03118, "epss_percentile": 0.8644}, "CVE-2019-2436": {"epss_score": 0.00405, "epss_percentile": 0.60456}, "CVE-2019-2437": {"epss_score": 0.01599, "epss_percentile": 0.81251}, "CVE-2019-2438": {"epss_score": 0.01001, "epss_percentile": 0.76501}, "CVE-2019-2439": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2019-2440": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2019-2441": {"epss_score": 0.00777, "epss_percentile": 0.73114}, "CVE-2019-2442": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2019-2443": {"epss_score": 0.01288, "epss_percentile": 0.79206}, "CVE-2019-2444": {"epss_score": 0.00079, "epss_percentile": 0.23807}, "CVE-2019-2445": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2019-2446": {"epss_score": 0.00158, "epss_percentile": 0.37205}, "CVE-2019-2447": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2019-2448": {"epss_score": 0.00158, "epss_percentile": 0.37205}, "CVE-2019-2449": {"epss_score": 0.02418, "epss_percentile": 0.84695}, "CVE-2019-2450": {"epss_score": 0.00116, "epss_percentile": 0.31167}, "CVE-2019-2451": {"epss_score": 0.00116, "epss_percentile": 0.31167}, "CVE-2019-2452": {"epss_score": 0.00456, "epss_percentile": 0.63332}, "CVE-2019-2453": {"epss_score": 0.01337, "epss_percentile": 0.79562}, "CVE-2019-2455": {"epss_score": 0.00175, "epss_percentile": 0.39363}, "CVE-2019-2456": {"epss_score": 0.00947, "epss_percentile": 0.75824}, "CVE-2019-2457": {"epss_score": 0.01469, "epss_percentile": 0.80487}, "CVE-2019-2458": {"epss_score": 0.01469, "epss_percentile": 0.80487}, "CVE-2019-2459": {"epss_score": 0.01469, "epss_percentile": 0.80487}, "CVE-2019-2460": {"epss_score": 0.01469, "epss_percentile": 0.80487}, "CVE-2019-2461": {"epss_score": 0.01469, "epss_percentile": 0.80487}, "CVE-2019-2462": {"epss_score": 0.00699, "epss_percentile": 0.71447}, "CVE-2019-2463": {"epss_score": 0.01054, "epss_percentile": 0.77111}, "CVE-2019-2464": {"epss_score": 0.00694, "epss_percentile": 0.71347}, "CVE-2019-2465": {"epss_score": 0.00694, "epss_percentile": 0.71347}, "CVE-2019-2466": {"epss_score": 0.00694, "epss_percentile": 0.71347}, "CVE-2019-2467": {"epss_score": 0.01656, "epss_percentile": 0.81596}, "CVE-2019-2468": {"epss_score": 0.01656, "epss_percentile": 0.81596}, "CVE-2019-2469": {"epss_score": 0.00813, "epss_percentile": 0.73753}, "CVE-2019-2470": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2019-2471": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2019-2472": {"epss_score": 0.01469, "epss_percentile": 0.80487}, "CVE-2019-2473": {"epss_score": 0.01656, "epss_percentile": 0.81596}, "CVE-2019-2474": {"epss_score": 0.01656, "epss_percentile": 0.81596}, "CVE-2019-2475": {"epss_score": 0.01656, "epss_percentile": 0.81596}, "CVE-2019-2476": {"epss_score": 0.01656, "epss_percentile": 0.81596}, "CVE-2019-2477": {"epss_score": 0.01656, "epss_percentile": 0.81596}, "CVE-2019-2478": {"epss_score": 0.01469, "epss_percentile": 0.80487}, "CVE-2019-2479": {"epss_score": 0.01656, "epss_percentile": 0.81596}, "CVE-2019-2480": {"epss_score": 0.01469, "epss_percentile": 0.80487}, "CVE-2019-2481": {"epss_score": 0.00107, "epss_percentile": 0.29684}, "CVE-2019-2482": {"epss_score": 0.00569, "epss_percentile": 0.67925}, "CVE-2019-2483": {"epss_score": 0.00142, "epss_percentile": 0.34978}, "CVE-2019-2484": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2019-2485": {"epss_score": 0.00702, "epss_percentile": 0.71512}, "CVE-2019-2486": {"epss_score": 0.00562, "epss_percentile": 0.677}, "CVE-2019-2487": {"epss_score": 0.0027, "epss_percentile": 0.5024}, "CVE-2019-2488": {"epss_score": 0.00694, "epss_percentile": 0.71347}, "CVE-2019-2489": {"epss_score": 0.0121, "epss_percentile": 0.78551}, "CVE-2019-2490": {"epss_score": 0.00702, "epss_percentile": 0.71512}, "CVE-2019-2491": {"epss_score": 0.00702, "epss_percentile": 0.71512}, "CVE-2019-2492": {"epss_score": 0.00702, "epss_percentile": 0.71512}, "CVE-2019-2493": {"epss_score": 0.00591, "epss_percentile": 0.68597}, "CVE-2019-2494": {"epss_score": 0.00405, "epss_percentile": 0.60456}, "CVE-2019-2495": {"epss_score": 0.00378, "epss_percentile": 0.58836}, "CVE-2019-2496": {"epss_score": 0.00702, "epss_percentile": 0.71512}, "CVE-2019-2497": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2019-2498": {"epss_score": 0.00973, "epss_percentile": 0.76155}, "CVE-2019-2499": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2019-2500": {"epss_score": 0.00136, "epss_percentile": 0.34187}, "CVE-2019-2501": {"epss_score": 0.00098, "epss_percentile": 0.27829}, "CVE-2019-2502": {"epss_score": 0.00215, "epss_percentile": 0.44032}, "CVE-2019-2503": {"epss_score": 0.00145, "epss_percentile": 0.35374}, "CVE-2019-2504": {"epss_score": 0.00096, "epss_percentile": 0.27281}, "CVE-2019-2505": {"epss_score": 0.00098, "epss_percentile": 0.27829}, "CVE-2019-2506": {"epss_score": 0.00114, "epss_percentile": 0.30818}, "CVE-2019-2507": {"epss_score": 0.00562, "epss_percentile": 0.677}, "CVE-2019-2508": {"epss_score": 0.00171, "epss_percentile": 0.38798}, "CVE-2019-2509": {"epss_score": 0.00171, "epss_percentile": 0.38798}, "CVE-2019-2510": {"epss_score": 0.00116, "epss_percentile": 0.31113}, "CVE-2019-2511": {"epss_score": 0.01525, "epss_percentile": 0.8086}, "CVE-2019-2512": {"epss_score": 0.00696, "epss_percentile": 0.71394}, "CVE-2019-2513": {"epss_score": 0.00206, "epss_percentile": 0.42926}, "CVE-2019-2516": {"epss_score": 0.00056, "epss_percentile": 0.17879}, "CVE-2019-2517": {"epss_score": 0.00499, "epss_percentile": 0.65255}, "CVE-2019-2518": {"epss_score": 0.00776, "epss_percentile": 0.73105}, "CVE-2019-2519": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2019-2520": {"epss_score": 0.00136, "epss_percentile": 0.34187}, "CVE-2019-2521": {"epss_score": 0.00136, "epss_percentile": 0.34187}, "CVE-2019-2522": {"epss_score": 0.00136, "epss_percentile": 0.34187}, "CVE-2019-2523": {"epss_score": 0.00136, "epss_percentile": 0.34187}, "CVE-2019-2524": {"epss_score": 0.00136, "epss_percentile": 0.34187}, "CVE-2019-2525": {"epss_score": 0.11022, "epss_percentile": 0.93192}, "CVE-2019-2526": {"epss_score": 0.00136, "epss_percentile": 0.34187}, "CVE-2019-2527": {"epss_score": 0.00203, "epss_percentile": 0.4251}, "CVE-2019-2528": {"epss_score": 0.00562, "epss_percentile": 0.677}, "CVE-2019-2529": {"epss_score": 0.00205, "epss_percentile": 0.42745}, "CVE-2019-2530": {"epss_score": 0.00389, "epss_percentile": 0.5949}, "CVE-2019-2531": {"epss_score": 0.00111, "epss_percentile": 0.30371}, "CVE-2019-2532": {"epss_score": 0.0012, "epss_percentile": 0.31781}, "CVE-2019-2533": {"epss_score": 0.00386, "epss_percentile": 0.59259}, "CVE-2019-2534": {"epss_score": 0.00209, "epss_percentile": 0.43332}, "CVE-2019-2535": {"epss_score": 0.00152, "epss_percentile": 0.36438}, "CVE-2019-2536": {"epss_score": 0.00207, "epss_percentile": 0.43084}, "CVE-2019-2537": {"epss_score": 0.00122, "epss_percentile": 0.32131}, "CVE-2019-2538": {"epss_score": 0.00247, "epss_percentile": 0.47888}, "CVE-2019-2539": {"epss_score": 0.00389, "epss_percentile": 0.5949}, "CVE-2019-2540": {"epss_score": 0.00531, "epss_percentile": 0.66671}, "CVE-2019-2541": {"epss_score": 0.00376, "epss_percentile": 0.58684}, "CVE-2019-2543": {"epss_score": 0.00862, "epss_percentile": 0.74579}, "CVE-2019-2544": {"epss_score": 0.00131, "epss_percentile": 0.33403}, "CVE-2019-2545": {"epss_score": 0.00178, "epss_percentile": 0.39687}, "CVE-2019-2546": {"epss_score": 0.00702, "epss_percentile": 0.71512}, "CVE-2019-2547": {"epss_score": 0.00283, "epss_percentile": 0.51392}, "CVE-2019-2548": {"epss_score": 0.0386, "epss_percentile": 0.87863}, "CVE-2019-2549": {"epss_score": 0.00524, "epss_percentile": 0.6636}, "CVE-2019-2550": {"epss_score": 0.00702, "epss_percentile": 0.71512}, "CVE-2019-2551": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2552": {"epss_score": 0.00136, "epss_percentile": 0.34187}, "CVE-2019-2553": {"epss_score": 0.00098, "epss_percentile": 0.27829}, "CVE-2019-2554": {"epss_score": 0.00116, "epss_percentile": 0.31167}, "CVE-2019-2555": {"epss_score": 0.00116, "epss_percentile": 0.31167}, "CVE-2019-2556": {"epss_score": 0.00098, "epss_percentile": 0.27787}, "CVE-2019-2557": {"epss_score": 0.55917, "epss_percentile": 0.98002}, "CVE-2019-2558": {"epss_score": 0.00835, "epss_percentile": 0.74122}, "CVE-2019-2561": {"epss_score": 0.01204, "epss_percentile": 0.78503}, "CVE-2019-2564": {"epss_score": 0.00277, "epss_percentile": 0.50802}, "CVE-2019-2565": {"epss_score": 0.01494, "epss_percentile": 0.80647}, "CVE-2019-2566": {"epss_score": 0.00409, "epss_percentile": 0.60788}, "CVE-2019-2567": {"epss_score": 0.01494, "epss_percentile": 0.80647}, "CVE-2019-2568": {"epss_score": 0.00277, "epss_percentile": 0.50815}, "CVE-2019-2569": {"epss_score": 0.00254, "epss_percentile": 0.48569}, "CVE-2019-2570": {"epss_score": 0.00373, "epss_percentile": 0.58472}, "CVE-2019-2571": {"epss_score": 0.00615, "epss_percentile": 0.69306}, "CVE-2019-2572": {"epss_score": 0.00994, "epss_percentile": 0.7643}, "CVE-2019-2573": {"epss_score": 0.00827, "epss_percentile": 0.73983}, "CVE-2019-2574": {"epss_score": 0.00149, "epss_percentile": 0.35962}, "CVE-2019-2575": {"epss_score": 0.00994, "epss_percentile": 0.7643}, "CVE-2019-2576": {"epss_score": 0.02116, "epss_percentile": 0.83659}, "CVE-2019-2577": {"epss_score": 0.00192, "epss_percentile": 0.41319}, "CVE-2019-2578": {"epss_score": 0.81391, "epss_percentile": 0.99135}, "CVE-2019-2579": {"epss_score": 0.72794, "epss_percentile": 0.98726}, "CVE-2019-2580": {"epss_score": 0.00568, "epss_percentile": 0.67886}, "CVE-2019-2581": {"epss_score": 0.00173, "epss_percentile": 0.39105}, "CVE-2019-2582": {"epss_score": 0.00651, "epss_percentile": 0.7029}, "CVE-2019-2583": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2584": {"epss_score": 0.0059, "epss_percentile": 0.68564}, "CVE-2019-2585": {"epss_score": 0.0059, "epss_percentile": 0.68564}, "CVE-2019-2586": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2019-2587": {"epss_score": 0.0032, "epss_percentile": 0.54583}, "CVE-2019-2588": {"epss_score": 0.85962, "epss_percentile": 0.99359}, "CVE-2019-2589": {"epss_score": 0.0032, "epss_percentile": 0.54583}, "CVE-2019-2590": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2591": {"epss_score": 0.00676, "epss_percentile": 0.70937}, "CVE-2019-2592": {"epss_score": 0.00173, "epss_percentile": 0.39105}, "CVE-2019-2593": {"epss_score": 0.0032, "epss_percentile": 0.54583}, "CVE-2019-2594": {"epss_score": 0.00711, "epss_percentile": 0.71734}, "CVE-2019-2595": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2596": {"epss_score": 0.00308, "epss_percentile": 0.53578}, "CVE-2019-2597": {"epss_score": 0.00676, "epss_percentile": 0.70937}, "CVE-2019-2598": {"epss_score": 0.00988, "epss_percentile": 0.76355}, "CVE-2019-2599": {"epss_score": 0.00429, "epss_percentile": 0.61973}, "CVE-2019-2600": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2601": {"epss_score": 0.00362, "epss_percentile": 0.57799}, "CVE-2019-2602": {"epss_score": 0.00172, "epss_percentile": 0.38929}, "CVE-2019-2603": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2604": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2605": {"epss_score": 0.00755, "epss_percentile": 0.72723}, "CVE-2019-2606": {"epss_score": 0.0059, "epss_percentile": 0.68564}, "CVE-2019-2607": {"epss_score": 0.0059, "epss_percentile": 0.68564}, "CVE-2019-2608": {"epss_score": 0.00835, "epss_percentile": 0.74122}, "CVE-2019-2609": {"epss_score": 0.01227, "epss_percentile": 0.78699}, "CVE-2019-2610": {"epss_score": 0.01227, "epss_percentile": 0.78699}, "CVE-2019-2611": {"epss_score": 0.01432, "epss_percentile": 0.8025}, "CVE-2019-2612": {"epss_score": 0.01432, "epss_percentile": 0.8025}, "CVE-2019-2613": {"epss_score": 0.01432, "epss_percentile": 0.8025}, "CVE-2019-2614": {"epss_score": 0.00163, "epss_percentile": 0.37779}, "CVE-2019-2615": {"epss_score": 0.58336, "epss_percentile": 0.9811}, "CVE-2019-2616": {"epss_score": 0.94278, "epss_percentile": 0.99933}, "CVE-2019-2617": {"epss_score": 0.00226, "epss_percentile": 0.45354}, "CVE-2019-2618": {"epss_score": 0.87254, "epss_percentile": 0.9942}, "CVE-2019-2619": {"epss_score": 0.00056, "epss_percentile": 0.17879}, "CVE-2019-2620": {"epss_score": 0.0059, "epss_percentile": 0.68564}, "CVE-2019-2621": {"epss_score": 0.00827, "epss_percentile": 0.73983}, "CVE-2019-2622": {"epss_score": 0.00827, "epss_percentile": 0.73983}, "CVE-2019-2623": {"epss_score": 0.0038, "epss_percentile": 0.58909}, "CVE-2019-2624": {"epss_score": 0.00207, "epss_percentile": 0.43132}, "CVE-2019-2625": {"epss_score": 0.00215, "epss_percentile": 0.44076}, "CVE-2019-2626": {"epss_score": 0.00215, "epss_percentile": 0.44076}, "CVE-2019-2627": {"epss_score": 0.00166, "epss_percentile": 0.38193}, "CVE-2019-2628": {"epss_score": 0.00114, "epss_percentile": 0.30808}, "CVE-2019-2629": {"epss_score": 0.00307, "epss_percentile": 0.53493}, "CVE-2019-2630": {"epss_score": 0.00421, "epss_percentile": 0.61518}, "CVE-2019-2631": {"epss_score": 0.00215, "epss_percentile": 0.44076}, "CVE-2019-2632": {"epss_score": 0.00472, "epss_percentile": 0.64062}, "CVE-2019-2633": {"epss_score": 0.01743, "epss_percentile": 0.82058}, "CVE-2019-2634": {"epss_score": 0.00196, "epss_percentile": 0.41734}, "CVE-2019-2635": {"epss_score": 0.00215, "epss_percentile": 0.44076}, "CVE-2019-2636": {"epss_score": 0.00215, "epss_percentile": 0.44076}, "CVE-2019-2637": {"epss_score": 0.00676, "epss_percentile": 0.70937}, "CVE-2019-2638": {"epss_score": 0.01743, "epss_percentile": 0.82058}, "CVE-2019-2639": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2640": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2641": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2642": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2643": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2644": {"epss_score": 0.00421, "epss_percentile": 0.61518}, "CVE-2019-2645": {"epss_score": 0.01715, "epss_percentile": 0.81896}, "CVE-2019-2646": {"epss_score": 0.01715, "epss_percentile": 0.81896}, "CVE-2019-2647": {"epss_score": 0.04575, "epss_percentile": 0.88867}, "CVE-2019-2648": {"epss_score": 0.03735, "epss_percentile": 0.87649}, "CVE-2019-2649": {"epss_score": 0.11931, "epss_percentile": 0.9352}, "CVE-2019-2650": {"epss_score": 0.1538, "epss_percentile": 0.9442}, "CVE-2019-2651": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2652": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2653": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2654": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2655": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2656": {"epss_score": 0.00139, "epss_percentile": 0.34535}, "CVE-2019-2657": {"epss_score": 0.00139, "epss_percentile": 0.34535}, "CVE-2019-2658": {"epss_score": 0.01715, "epss_percentile": 0.81896}, "CVE-2019-2659": {"epss_score": 0.00676, "epss_percentile": 0.70937}, "CVE-2019-2660": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2661": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2662": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2663": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2664": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2665": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2666": {"epss_score": 0.01277, "epss_percentile": 0.7912}, "CVE-2019-2668": {"epss_score": 0.01277, "epss_percentile": 0.7912}, "CVE-2019-2669": {"epss_score": 0.00827, "epss_percentile": 0.73983}, "CVE-2019-2670": {"epss_score": 0.00827, "epss_percentile": 0.73983}, "CVE-2019-2671": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2672": {"epss_score": 0.01277, "epss_percentile": 0.7912}, "CVE-2019-2673": {"epss_score": 0.00827, "epss_percentile": 0.73983}, "CVE-2019-2674": {"epss_score": 0.00827, "epss_percentile": 0.73983}, "CVE-2019-2675": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2676": {"epss_score": 0.00827, "epss_percentile": 0.73983}, "CVE-2019-2677": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2678": {"epss_score": 0.00149, "epss_percentile": 0.35962}, "CVE-2019-2679": {"epss_score": 0.00121, "epss_percentile": 0.3189}, "CVE-2019-2680": {"epss_score": 0.00139, "epss_percentile": 0.34535}, "CVE-2019-2681": {"epss_score": 0.00421, "epss_percentile": 0.61518}, "CVE-2019-2682": {"epss_score": 0.01018, "epss_percentile": 0.76716}, "CVE-2019-2683": {"epss_score": 0.00155, "epss_percentile": 0.36807}, "CVE-2019-2684": {"epss_score": 0.00994, "epss_percentile": 0.76424}, "CVE-2019-2685": {"epss_score": 0.00405, "epss_percentile": 0.60512}, "CVE-2019-2686": {"epss_score": 0.00421, "epss_percentile": 0.61518}, "CVE-2019-2687": {"epss_score": 0.00421, "epss_percentile": 0.61518}, "CVE-2019-2688": {"epss_score": 0.00405, "epss_percentile": 0.60512}, "CVE-2019-2689": {"epss_score": 0.00421, "epss_percentile": 0.61518}, "CVE-2019-2690": {"epss_score": 0.00139, "epss_percentile": 0.34535}, "CVE-2019-2691": {"epss_score": 0.00215, "epss_percentile": 0.44076}, "CVE-2019-2692": {"epss_score": 0.01248, "epss_percentile": 0.78865}, "CVE-2019-2693": {"epss_score": 0.0038, "epss_percentile": 0.58909}, "CVE-2019-2694": {"epss_score": 0.00714, "epss_percentile": 0.71825}, "CVE-2019-2695": {"epss_score": 0.00547, "epss_percentile": 0.67259}, "CVE-2019-2696": {"epss_score": 0.00139, "epss_percentile": 0.34535}, "CVE-2019-2697": {"epss_score": 0.04156, "epss_percentile": 0.88328}, "CVE-2019-2698": {"epss_score": 0.0576, "epss_percentile": 0.90183}, "CVE-2019-2699": {"epss_score": 0.01155, "epss_percentile": 0.78074}, "CVE-2019-2700": {"epss_score": 0.00277, "epss_percentile": 0.50815}, "CVE-2019-2701": {"epss_score": 0.00277, "epss_percentile": 0.50802}, "CVE-2019-2702": {"epss_score": 0.01242, "epss_percentile": 0.78823}, "CVE-2019-2703": {"epss_score": 0.00323, "epss_percentile": 0.5488}, "CVE-2019-2704": {"epss_score": 0.00994, "epss_percentile": 0.7643}, "CVE-2019-2705": {"epss_score": 0.01109, "epss_percentile": 0.77649}, "CVE-2019-2706": {"epss_score": 0.00892, "epss_percentile": 0.75064}, "CVE-2019-2707": {"epss_score": 0.00676, "epss_percentile": 0.70937}, "CVE-2019-2708": {"epss_score": 0.00939, "epss_percentile": 0.7572}, "CVE-2019-2709": {"epss_score": 0.00676, "epss_percentile": 0.70937}, "CVE-2019-2712": {"epss_score": 0.00676, "epss_percentile": 0.70937}, "CVE-2019-2713": {"epss_score": 0.00676, "epss_percentile": 0.70937}, "CVE-2019-2719": {"epss_score": 0.00658, "epss_percentile": 0.70497}, "CVE-2019-2720": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2019-2721": {"epss_score": 0.01324, "epss_percentile": 0.79461}, "CVE-2019-2722": {"epss_score": 0.00159, "epss_percentile": 0.37319}, "CVE-2019-2723": {"epss_score": 0.00159, "epss_percentile": 0.37319}, "CVE-2019-2725": {"epss_score": 0.9447, "epss_percentile": 0.99997}, "CVE-2019-2726": {"epss_score": 0.00256, "epss_percentile": 0.488}, "CVE-2019-2727": {"epss_score": 0.0092, "epss_percentile": 0.75469}, "CVE-2019-2728": {"epss_score": 0.00191, "epss_percentile": 0.41145}, "CVE-2019-2729": {"epss_score": 0.94326, "epss_percentile": 0.99948}, "CVE-2019-2730": {"epss_score": 0.00308, "epss_percentile": 0.5358}, "CVE-2019-2731": {"epss_score": 0.00571, "epss_percentile": 0.6798}, "CVE-2019-2732": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2019-2733": {"epss_score": 0.00191, "epss_percentile": 0.41145}, "CVE-2019-2734": {"epss_score": 0.00292, "epss_percentile": 0.5226}, "CVE-2019-2735": {"epss_score": 0.00214, "epss_percentile": 0.4395}, "CVE-2019-2736": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2019-2737": {"epss_score": 0.00182, "epss_percentile": 0.40155}, "CVE-2019-2738": {"epss_score": 0.00524, "epss_percentile": 0.66317}, "CVE-2019-2739": {"epss_score": 0.0003, "epss_percentile": 0.08281}, "CVE-2019-2740": {"epss_score": 0.00477, "epss_percentile": 0.64316}, "CVE-2019-2741": {"epss_score": 0.00728, "epss_percentile": 0.72105}, "CVE-2019-2742": {"epss_score": 0.00674, "epss_percentile": 0.70852}, "CVE-2019-2743": {"epss_score": 0.00447, "epss_percentile": 0.62936}, "CVE-2019-2744": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2019-2745": {"epss_score": 0.00082, "epss_percentile": 0.24441}, "CVE-2019-2746": {"epss_score": 0.00447, "epss_percentile": 0.62936}, "CVE-2019-2747": {"epss_score": 0.00353, "epss_percentile": 0.57194}, "CVE-2019-2748": {"epss_score": 0.00232, "epss_percentile": 0.459}, "CVE-2019-2749": {"epss_score": 0.00325, "epss_percentile": 0.55001}, "CVE-2019-2750": {"epss_score": 0.02591, "epss_percentile": 0.85183}, "CVE-2019-2751": {"epss_score": 0.01422, "epss_percentile": 0.80187}, "CVE-2019-2752": {"epss_score": 0.00627, "epss_percentile": 0.69623}, "CVE-2019-2753": {"epss_score": 0.00243, "epss_percentile": 0.47509}, "CVE-2019-2754": {"epss_score": 0.00968, "epss_percentile": 0.76087}, "CVE-2019-2755": {"epss_score": 0.00881, "epss_percentile": 0.74878}, "CVE-2019-2756": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2019-2757": {"epss_score": 0.01065, "epss_percentile": 0.77208}, "CVE-2019-2758": {"epss_score": 0.00142, "epss_percentile": 0.35007}, "CVE-2019-2759": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2019-2760": {"epss_score": 0.00111, "epss_percentile": 0.3031}, "CVE-2019-2761": {"epss_score": 0.00649, "epss_percentile": 0.70241}, "CVE-2019-2762": {"epss_score": 0.00771, "epss_percentile": 0.73019}, "CVE-2019-2763": {"epss_score": 0.0121, "epss_percentile": 0.78549}, "CVE-2019-2764": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2019-2765": {"epss_score": 0.00107, "epss_percentile": 0.29735}, "CVE-2019-2766": {"epss_score": 0.00773, "epss_percentile": 0.73063}, "CVE-2019-2767": {"epss_score": 0.53446, "epss_percentile": 0.97877}, "CVE-2019-2768": {"epss_score": 0.01684, "epss_percentile": 0.81745}, "CVE-2019-2769": {"epss_score": 0.00654, "epss_percentile": 0.70342}, "CVE-2019-2770": {"epss_score": 0.00443, "epss_percentile": 0.62794}, "CVE-2019-2771": {"epss_score": 0.00218, "epss_percentile": 0.44407}, "CVE-2019-2772": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2019-2773": {"epss_score": 0.00568, "epss_percentile": 0.67891}, "CVE-2019-2774": {"epss_score": 0.00559, "epss_percentile": 0.67605}, "CVE-2019-2775": {"epss_score": 0.01277, "epss_percentile": 0.79114}, "CVE-2019-2776": {"epss_score": 0.00372, "epss_percentile": 0.58423}, "CVE-2019-2777": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2019-2778": {"epss_score": 0.00625, "epss_percentile": 0.69588}, "CVE-2019-2779": {"epss_score": 0.00309, "epss_percentile": 0.5372}, "CVE-2019-2780": {"epss_score": 0.00627, "epss_percentile": 0.69623}, "CVE-2019-2781": {"epss_score": 0.00409, "epss_percentile": 0.60732}, "CVE-2019-2782": {"epss_score": 0.01684, "epss_percentile": 0.81745}, "CVE-2019-2783": {"epss_score": 0.00568, "epss_percentile": 0.67891}, "CVE-2019-2784": {"epss_score": 0.00627, "epss_percentile": 0.69623}, "CVE-2019-2785": {"epss_score": 0.00627, "epss_percentile": 0.69623}, "CVE-2019-2786": {"epss_score": 0.00536, "epss_percentile": 0.66852}, "CVE-2019-2787": {"epss_score": 0.00491, "epss_percentile": 0.64948}, "CVE-2019-2788": {"epss_score": 0.00097, "epss_percentile": 0.27535}, "CVE-2019-2789": {"epss_score": 0.00558, "epss_percentile": 0.67572}, "CVE-2019-2790": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2019-2791": {"epss_score": 0.00323, "epss_percentile": 0.54902}, "CVE-2019-2792": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2019-2793": {"epss_score": 0.00243, "epss_percentile": 0.47421}, "CVE-2019-2794": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2019-2795": {"epss_score": 0.01883, "epss_percentile": 0.827}, "CVE-2019-2796": {"epss_score": 0.00413, "epss_percentile": 0.60963}, "CVE-2019-2797": {"epss_score": 0.00141, "epss_percentile": 0.34839}, "CVE-2019-2798": {"epss_score": 0.00429, "epss_percentile": 0.61977}, "CVE-2019-2799": {"epss_score": 0.01137, "epss_percentile": 0.77927}, "CVE-2019-2800": {"epss_score": 0.00557, "epss_percentile": 0.67541}, "CVE-2019-2801": {"epss_score": 0.00429, "epss_percentile": 0.61977}, "CVE-2019-2802": {"epss_score": 0.00429, "epss_percentile": 0.61977}, "CVE-2019-2803": {"epss_score": 0.00429, "epss_percentile": 0.61977}, "CVE-2019-2804": {"epss_score": 0.0004, "epss_percentile": 0.119}, "CVE-2019-2805": {"epss_score": 0.0033, "epss_percentile": 0.55494}, "CVE-2019-2807": {"epss_score": 0.0006, "epss_percentile": 0.19073}, "CVE-2019-2808": {"epss_score": 0.00429, "epss_percentile": 0.61977}, "CVE-2019-2809": {"epss_score": 0.01491, "epss_percentile": 0.80633}, "CVE-2019-2810": {"epss_score": 0.00413, "epss_percentile": 0.60963}, "CVE-2019-2811": {"epss_score": 0.00429, "epss_percentile": 0.61977}, "CVE-2019-2812": {"epss_score": 0.00727, "epss_percentile": 0.72092}, "CVE-2019-2813": {"epss_score": 0.00351, "epss_percentile": 0.57054}, "CVE-2019-2814": {"epss_score": 0.00405, "epss_percentile": 0.605}, "CVE-2019-2815": {"epss_score": 0.00429, "epss_percentile": 0.61977}, "CVE-2019-2816": {"epss_score": 0.00263, "epss_percentile": 0.49526}, "CVE-2019-2817": {"epss_score": 0.00742, "epss_percentile": 0.72453}, "CVE-2019-2818": {"epss_score": 0.01272, "epss_percentile": 0.79084}, "CVE-2019-2819": {"epss_score": 0.00435, "epss_percentile": 0.62342}, "CVE-2019-2820": {"epss_score": 0.00051, "epss_percentile": 0.16314}, "CVE-2019-2821": {"epss_score": 0.01564, "epss_percentile": 0.81061}, "CVE-2019-2822": {"epss_score": 0.03401, "epss_percentile": 0.87069}, "CVE-2019-2823": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2019-2824": {"epss_score": 0.00497, "epss_percentile": 0.65185}, "CVE-2019-2825": {"epss_score": 0.00993, "epss_percentile": 0.76413}, "CVE-2019-2826": {"epss_score": 0.00429, "epss_percentile": 0.61977}, "CVE-2019-2827": {"epss_score": 0.00497, "epss_percentile": 0.65185}, "CVE-2019-2828": {"epss_score": 0.01337, "epss_percentile": 0.79559}, "CVE-2019-2829": {"epss_score": 0.01277, "epss_percentile": 0.7912}, "CVE-2019-2830": {"epss_score": 0.00385, "epss_percentile": 0.59216}, "CVE-2019-2831": {"epss_score": 0.00289, "epss_percentile": 0.52051}, "CVE-2019-2832": {"epss_score": 0.00051, "epss_percentile": 0.16314}, "CVE-2019-2833": {"epss_score": 0.00409, "epss_percentile": 0.60732}, "CVE-2019-2834": {"epss_score": 0.0092, "epss_percentile": 0.75467}, "CVE-2019-2835": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2019-2836": {"epss_score": 0.01684, "epss_percentile": 0.81745}, "CVE-2019-2837": {"epss_score": 0.01277, "epss_percentile": 0.7912}, "CVE-2019-2838": {"epss_score": 0.00826, "epss_percentile": 0.73976}, "CVE-2019-2839": {"epss_score": 0.00409, "epss_percentile": 0.60732}, "CVE-2019-2840": {"epss_score": 0.00432, "epss_percentile": 0.62124}, "CVE-2019-2841": {"epss_score": 0.00968, "epss_percentile": 0.76087}, "CVE-2019-2842": {"epss_score": 0.0048, "epss_percentile": 0.64466}, "CVE-2019-2843": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2019-2844": {"epss_score": 0.00051, "epss_percentile": 0.16314}, "CVE-2019-2845": {"epss_score": 0.00243, "epss_percentile": 0.47421}, "CVE-2019-2846": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2019-2847": {"epss_score": 0.00432, "epss_percentile": 0.62124}, "CVE-2019-2848": {"epss_score": 0.00145, "epss_percentile": 0.35432}, "CVE-2019-2850": {"epss_score": 0.00206, "epss_percentile": 0.42783}, "CVE-2019-2852": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2019-2853": {"epss_score": 0.00938, "epss_percentile": 0.75705}, "CVE-2019-2854": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2019-2855": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2019-2856": {"epss_score": 0.02708, "epss_percentile": 0.85478}, "CVE-2019-2857": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2019-2858": {"epss_score": 0.00191, "epss_percentile": 0.41145}, "CVE-2019-2859": {"epss_score": 0.00147, "epss_percentile": 0.35658}, "CVE-2019-2860": {"epss_score": 0.00635, "epss_percentile": 0.6982}, "CVE-2019-2861": {"epss_score": 0.02646, "epss_percentile": 0.85331}, "CVE-2019-2862": {"epss_score": 0.00879, "epss_percentile": 0.74838}, "CVE-2019-2863": {"epss_score": 0.00104, "epss_percentile": 0.29189}, "CVE-2019-2864": {"epss_score": 0.0016, "epss_percentile": 0.37505}, "CVE-2019-2865": {"epss_score": 0.0016, "epss_percentile": 0.37505}, "CVE-2019-2866": {"epss_score": 0.0016, "epss_percentile": 0.37505}, "CVE-2019-2867": {"epss_score": 0.00125, "epss_percentile": 0.3247}, "CVE-2019-2868": {"epss_score": 0.00111, "epss_percentile": 0.3031}, "CVE-2019-2869": {"epss_score": 0.00111, "epss_percentile": 0.3031}, "CVE-2019-2870": {"epss_score": 0.00111, "epss_percentile": 0.3031}, "CVE-2019-2871": {"epss_score": 0.00111, "epss_percentile": 0.3031}, "CVE-2019-2872": {"epss_score": 0.00147, "epss_percentile": 0.35785}, "CVE-2019-2873": {"epss_score": 0.00151, "epss_percentile": 0.36336}, "CVE-2019-2874": {"epss_score": 0.00151, "epss_percentile": 0.36336}, "CVE-2019-2875": {"epss_score": 0.00151, "epss_percentile": 0.36336}, "CVE-2019-2876": {"epss_score": 0.00151, "epss_percentile": 0.36336}, "CVE-2019-2877": {"epss_score": 0.00151, "epss_percentile": 0.36336}, "CVE-2019-2878": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2019-2879": {"epss_score": 0.00426, "epss_percentile": 0.6173}, "CVE-2019-2880": {"epss_score": 0.0137, "epss_percentile": 0.79798}, "CVE-2019-2883": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2019-2884": {"epss_score": 0.01971, "epss_percentile": 0.83099}, "CVE-2019-2886": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2019-2887": {"epss_score": 0.00333, "epss_percentile": 0.55649}, "CVE-2019-2888": {"epss_score": 0.78684, "epss_percentile": 0.98999}, "CVE-2019-2889": {"epss_score": 0.01163, "epss_percentile": 0.7816}, "CVE-2019-2890": {"epss_score": 0.90488, "epss_percentile": 0.99586}, "CVE-2019-2891": {"epss_score": 0.01045, "epss_percentile": 0.77016}, "CVE-2019-2894": {"epss_score": 0.00349, "epss_percentile": 0.56862}, "CVE-2019-2895": {"epss_score": 0.00872, "epss_percentile": 0.74726}, "CVE-2019-2896": {"epss_score": 0.01971, "epss_percentile": 0.83099}, "CVE-2019-2897": {"epss_score": 0.00332, "epss_percentile": 0.55574}, "CVE-2019-2898": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2019-2899": {"epss_score": 0.00369, "epss_percentile": 0.58275}, "CVE-2019-2900": {"epss_score": 0.02331, "epss_percentile": 0.84402}, "CVE-2019-2901": {"epss_score": 0.00988, "epss_percentile": 0.76355}, "CVE-2019-2902": {"epss_score": 0.00988, "epss_percentile": 0.76355}, "CVE-2019-2903": {"epss_score": 0.00988, "epss_percentile": 0.76355}, "CVE-2019-2904": {"epss_score": 0.12605, "epss_percentile": 0.93727}, "CVE-2019-2905": {"epss_score": 0.03319, "epss_percentile": 0.86907}, "CVE-2019-2906": {"epss_score": 0.02287, "epss_percentile": 0.84269}, "CVE-2019-2907": {"epss_score": 0.01141, "epss_percentile": 0.77963}, "CVE-2019-2909": {"epss_score": 0.01179, "epss_percentile": 0.78295}, "CVE-2019-2910": {"epss_score": 0.00476, "epss_percentile": 0.64251}, "CVE-2019-2911": {"epss_score": 0.00187, "epss_percentile": 0.40701}, "CVE-2019-2913": {"epss_score": 0.00425, "epss_percentile": 0.61726}, "CVE-2019-2914": {"epss_score": 0.00269, "epss_percentile": 0.5017}, "CVE-2019-2915": {"epss_score": 0.00935, "epss_percentile": 0.75667}, "CVE-2019-2920": {"epss_score": 0.02284, "epss_percentile": 0.84263}, "CVE-2019-2922": {"epss_score": 0.02382, "epss_percentile": 0.84568}, "CVE-2019-2923": {"epss_score": 0.0244, "epss_percentile": 0.84752}, "CVE-2019-2924": {"epss_score": 0.0244, "epss_percentile": 0.84752}, "CVE-2019-2925": {"epss_score": 0.00981, "epss_percentile": 0.76277}, "CVE-2019-2926": {"epss_score": 0.00174, "epss_percentile": 0.3919}, "CVE-2019-2927": {"epss_score": 0.01516, "epss_percentile": 0.80798}, "CVE-2019-2929": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2019-2930": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2019-2931": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2019-2932": {"epss_score": 0.00601, "epss_percentile": 0.68838}, "CVE-2019-2933": {"epss_score": 0.00507, "epss_percentile": 0.65675}, "CVE-2019-2934": {"epss_score": 0.01345, "epss_percentile": 0.79628}, "CVE-2019-2935": {"epss_score": 0.01373, "epss_percentile": 0.79817}, "CVE-2019-2936": {"epss_score": 0.00881, "epss_percentile": 0.74878}, "CVE-2019-2937": {"epss_score": 0.01193, "epss_percentile": 0.7841}, "CVE-2019-2938": {"epss_score": 0.00091, "epss_percentile": 0.26287}, "CVE-2019-2939": {"epss_score": 0.00425, "epss_percentile": 0.61726}, "CVE-2019-2940": {"epss_score": 0.00133, "epss_percentile": 0.33704}, "CVE-2019-2941": {"epss_score": 0.0019, "epss_percentile": 0.41092}, "CVE-2019-2942": {"epss_score": 0.01989, "epss_percentile": 0.83167}, "CVE-2019-2943": {"epss_score": 0.00776, "epss_percentile": 0.73104}, "CVE-2019-2944": {"epss_score": 0.00139, "epss_percentile": 0.34568}, "CVE-2019-2945": {"epss_score": 0.00296, "epss_percentile": 0.52541}, "CVE-2019-2946": {"epss_score": 0.00313, "epss_percentile": 0.5405}, "CVE-2019-2947": {"epss_score": 0.00561, "epss_percentile": 0.6766}, "CVE-2019-2948": {"epss_score": 0.00448, "epss_percentile": 0.63024}, "CVE-2019-2949": {"epss_score": 0.00551, "epss_percentile": 0.67352}, "CVE-2019-2950": {"epss_score": 0.01723, "epss_percentile": 0.81945}, "CVE-2019-2951": {"epss_score": 0.00425, "epss_percentile": 0.61726}, "CVE-2019-2952": {"epss_score": 0.00935, "epss_percentile": 0.75667}, "CVE-2019-2953": {"epss_score": 0.00561, "epss_percentile": 0.6766}, "CVE-2019-2954": {"epss_score": 0.0017, "epss_percentile": 0.38708}, "CVE-2019-2955": {"epss_score": 0.0017, "epss_percentile": 0.38708}, "CVE-2019-2956": {"epss_score": 0.0046, "epss_percentile": 0.63515}, "CVE-2019-2957": {"epss_score": 0.00112, "epss_percentile": 0.30521}, "CVE-2019-2958": {"epss_score": 0.01183, "epss_percentile": 0.78324}, "CVE-2019-2959": {"epss_score": 0.00426, "epss_percentile": 0.61735}, "CVE-2019-2960": {"epss_score": 0.0013, "epss_percentile": 0.33339}, "CVE-2019-2961": {"epss_score": 0.00125, "epss_percentile": 0.32551}, "CVE-2019-2962": {"epss_score": 0.00476, "epss_percentile": 0.64255}, "CVE-2019-2963": {"epss_score": 0.0013, "epss_percentile": 0.33339}, "CVE-2019-2964": {"epss_score": 0.00344, "epss_percentile": 0.56518}, "CVE-2019-2965": {"epss_score": 0.02982, "epss_percentile": 0.86124}, "CVE-2019-2966": {"epss_score": 0.00217, "epss_percentile": 0.44335}, "CVE-2019-2967": {"epss_score": 0.00313, "epss_percentile": 0.5405}, "CVE-2019-2968": {"epss_score": 0.0013, "epss_percentile": 0.33339}, "CVE-2019-2969": {"epss_score": 0.00376, "epss_percentile": 0.58643}, "CVE-2019-2970": {"epss_score": 0.01154, "epss_percentile": 0.78065}, "CVE-2019-2971": {"epss_score": 0.01154, "epss_percentile": 0.78065}, "CVE-2019-2972": {"epss_score": 0.01154, "epss_percentile": 0.78065}, "CVE-2019-2973": {"epss_score": 0.00576, "epss_percentile": 0.68128}, "CVE-2019-2974": {"epss_score": 0.00219, "epss_percentile": 0.44491}, "CVE-2019-2975": {"epss_score": 0.00488, "epss_percentile": 0.64832}, "CVE-2019-2976": {"epss_score": 0.00489, "epss_percentile": 0.64877}, "CVE-2019-2977": {"epss_score": 0.00709, "epss_percentile": 0.71694}, "CVE-2019-2978": {"epss_score": 0.00476, "epss_percentile": 0.6427}, "CVE-2019-2979": {"epss_score": 0.00427, "epss_percentile": 0.61772}, "CVE-2019-2980": {"epss_score": 0.00543, "epss_percentile": 0.67089}, "CVE-2019-2981": {"epss_score": 0.00333, "epss_percentile": 0.5564}, "CVE-2019-2982": {"epss_score": 0.0013, "epss_percentile": 0.33339}, "CVE-2019-2983": {"epss_score": 0.00344, "epss_percentile": 0.56518}, "CVE-2019-2984": {"epss_score": 0.00167, "epss_percentile": 0.38324}, "CVE-2019-2985": {"epss_score": 0.00935, "epss_percentile": 0.75667}, "CVE-2019-2986": {"epss_score": 0.0037, "epss_percentile": 0.58326}, "CVE-2019-2987": {"epss_score": 0.00503, "epss_percentile": 0.65464}, "CVE-2019-2988": {"epss_score": 0.00514, "epss_percentile": 0.65948}, "CVE-2019-2989": {"epss_score": 0.02288, "epss_percentile": 0.84273}, "CVE-2019-2990": {"epss_score": 0.01595, "epss_percentile": 0.81236}, "CVE-2019-2991": {"epss_score": 0.00445, "epss_percentile": 0.6288}, "CVE-2019-2992": {"epss_score": 0.00898, "epss_percentile": 0.75144}, "CVE-2019-2993": {"epss_score": 0.00313, "epss_percentile": 0.5405}, "CVE-2019-2994": {"epss_score": 0.01599, "epss_percentile": 0.81251}, "CVE-2019-2995": {"epss_score": 0.01599, "epss_percentile": 0.81251}, "CVE-2019-2996": {"epss_score": 0.01934, "epss_percentile": 0.82954}, "CVE-2019-2997": {"epss_score": 0.00091, "epss_percentile": 0.26201}, "CVE-2019-2998": {"epss_score": 0.0013, "epss_percentile": 0.33339}, "CVE-2019-2999": {"epss_score": 0.01308, "epss_percentile": 0.79349}, "CVE-2019-3000": {"epss_score": 0.01599, "epss_percentile": 0.81251}, "CVE-2019-3001": {"epss_score": 0.01373, "epss_percentile": 0.79817}, "CVE-2019-3002": {"epss_score": 0.00167, "epss_percentile": 0.38324}, "CVE-2019-3003": {"epss_score": 0.00448, "epss_percentile": 0.63024}, "CVE-2019-3004": {"epss_score": 0.00313, "epss_percentile": 0.5405}, "CVE-2019-3005": {"epss_score": 0.00167, "epss_percentile": 0.38324}, "CVE-2019-3008": {"epss_score": 0.00246, "epss_percentile": 0.47738}, "CVE-2019-3009": {"epss_score": 0.0013, "epss_percentile": 0.33339}, "CVE-2019-3010": {"epss_score": 0.47589, "epss_percentile": 0.97592}, "CVE-2019-3011": {"epss_score": 0.00313, "epss_percentile": 0.5405}, "CVE-2019-3012": {"epss_score": 0.0235, "epss_percentile": 0.84469}, "CVE-2019-3014": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2019-3015": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2019-3016": {"epss_score": 0.00061, "epss_percentile": 0.19334}, "CVE-2019-3017": {"epss_score": 0.00169, "epss_percentile": 0.38636}, "CVE-2019-3018": {"epss_score": 0.00445, "epss_percentile": 0.6288}, "CVE-2019-3019": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2019-3020": {"epss_score": 0.01771, "epss_percentile": 0.822}, "CVE-2019-3021": {"epss_score": 0.00168, "epss_percentile": 0.38451}, "CVE-2019-3022": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2019-3023": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2019-3024": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2019-3025": {"epss_score": 0.33216, "epss_percentile": 0.96753}, "CVE-2019-3026": {"epss_score": 0.00119, "epss_percentile": 0.31675}, "CVE-2019-3027": {"epss_score": 0.02051, "epss_percentile": 0.83408}, "CVE-2019-3028": {"epss_score": 0.00409, "epss_percentile": 0.60721}, "CVE-2019-3031": {"epss_score": 0.00127, "epss_percentile": 0.32873}, "CVE-2019-3394": {"epss_score": 0.77567, "epss_percentile": 0.98942}, "CVE-2019-3395": {"epss_score": 0.09584, "epss_percentile": 0.92608}, "CVE-2019-3396": {"epss_score": 0.94471, "epss_percentile": 0.99997}, "CVE-2019-3397": {"epss_score": 0.13175, "epss_percentile": 0.93893}, "CVE-2019-3398": {"epss_score": 0.93863, "epss_percentile": 0.99859}, "CVE-2019-3399": {"epss_score": 0.00322, "epss_percentile": 0.5482}, "CVE-2019-3400": {"epss_score": 0.00388, "epss_percentile": 0.59398}, "CVE-2019-3401": {"epss_score": 0.64371, "epss_percentile": 0.98376}, "CVE-2019-3402": {"epss_score": 0.12577, "epss_percentile": 0.9372}, "CVE-2019-3403": {"epss_score": 0.828, "epss_percentile": 0.99215}, "CVE-2019-3404": {"epss_score": 0.00225, "epss_percentile": 0.45118}, "CVE-2019-3405": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2019-3409": {"epss_score": 0.02722, "epss_percentile": 0.85519}, "CVE-2019-3410": {"epss_score": 0.00116, "epss_percentile": 0.31097}, "CVE-2019-3411": {"epss_score": 0.00282, "epss_percentile": 0.51285}, "CVE-2019-3412": {"epss_score": 0.00973, "epss_percentile": 0.76164}, "CVE-2019-3413": {"epss_score": 0.00162, "epss_percentile": 0.37663}, "CVE-2019-3414": {"epss_score": 0.00148, "epss_percentile": 0.35872}, "CVE-2019-3415": {"epss_score": 0.00106, "epss_percentile": 0.29439}, "CVE-2019-3416": {"epss_score": 0.00159, "epss_percentile": 0.37362}, "CVE-2019-3417": {"epss_score": 0.01237, "epss_percentile": 0.78775}, "CVE-2019-3418": {"epss_score": 0.00282, "epss_percentile": 0.5127}, "CVE-2019-3419": {"epss_score": 0.001, "epss_percentile": 0.2848}, "CVE-2019-3420": {"epss_score": 0.00093, "epss_percentile": 0.26653}, "CVE-2019-3421": {"epss_score": 0.00789, "epss_percentile": 0.73348}, "CVE-2019-3422": {"epss_score": 0.00071, "epss_percentile": 0.22004}, "CVE-2019-3423": {"epss_score": 0.00144, "epss_percentile": 0.35266}, "CVE-2019-3424": {"epss_score": 0.00292, "epss_percentile": 0.52213}, "CVE-2019-3425": {"epss_score": 0.00357, "epss_percentile": 0.57475}, "CVE-2019-3426": {"epss_score": 0.00441, "epss_percentile": 0.62686}, "CVE-2019-3427": {"epss_score": 0.00594, "epss_percentile": 0.68671}, "CVE-2019-3428": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2019-3429": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2019-3430": {"epss_score": 0.00296, "epss_percentile": 0.52579}, "CVE-2019-3431": {"epss_score": 0.00071, "epss_percentile": 0.22081}, "CVE-2019-3459": {"epss_score": 0.00482, "epss_percentile": 0.6453}, "CVE-2019-3460": {"epss_score": 0.00482, "epss_percentile": 0.6453}, "CVE-2019-3461": {"epss_score": 0.00052, "epss_percentile": 0.16532}, "CVE-2019-3462": {"epss_score": 0.06994, "epss_percentile": 0.9117}, "CVE-2019-3463": {"epss_score": 0.12799, "epss_percentile": 0.93777}, "CVE-2019-3464": {"epss_score": 0.1026, "epss_percentile": 0.92917}, "CVE-2019-3465": {"epss_score": 0.01971, "epss_percentile": 0.83097}, "CVE-2019-3466": {"epss_score": 0.00128, "epss_percentile": 0.33047}, "CVE-2019-3467": {"epss_score": 0.00085, "epss_percentile": 0.25099}, "CVE-2019-3474": {"epss_score": 0.03387, "epss_percentile": 0.87042}, "CVE-2019-3475": {"epss_score": 0.01467, "epss_percentile": 0.80467}, "CVE-2019-3476": {"epss_score": 0.01778, "epss_percentile": 0.82227}, "CVE-2019-3477": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2019-3479": {"epss_score": 0.07428, "epss_percentile": 0.91469}, "CVE-2019-3480": {"epss_score": 0.00362, "epss_percentile": 0.57751}, "CVE-2019-3481": {"epss_score": 0.00432, "epss_percentile": 0.62135}, "CVE-2019-3482": {"epss_score": 0.02079, "epss_percentile": 0.83528}, "CVE-2019-3483": {"epss_score": 0.00351, "epss_percentile": 0.57013}, "CVE-2019-3484": {"epss_score": 0.00448, "epss_percentile": 0.63016}, "CVE-2019-3485": {"epss_score": 0.00304, "epss_percentile": 0.53309}, "CVE-2019-3486": {"epss_score": 0.00304, "epss_percentile": 0.53309}, "CVE-2019-3489": {"epss_score": 0.01004, "epss_percentile": 0.7653}, "CVE-2019-3490": {"epss_score": 0.00215, "epss_percentile": 0.44038}, "CVE-2019-3493": {"epss_score": 0.01468, "epss_percentile": 0.8048}, "CVE-2019-3494": {"epss_score": 0.00184, "epss_percentile": 0.4042}, "CVE-2019-3495": {"epss_score": 0.01143, "epss_percentile": 0.7798}, "CVE-2019-3496": {"epss_score": 0.07366, "epss_percentile": 0.91436}, "CVE-2019-3497": {"epss_score": 0.07366, "epss_percentile": 0.91436}, "CVE-2019-3498": {"epss_score": 0.01943, "epss_percentile": 0.82991}, "CVE-2019-3500": {"epss_score": 0.0011, "epss_percentile": 0.30207}, "CVE-2019-3501": {"epss_score": 0.0026, "epss_percentile": 0.49243}, "CVE-2019-3552": {"epss_score": 0.004, "epss_percentile": 0.60182}, "CVE-2019-3553": {"epss_score": 0.00642, "epss_percentile": 0.70019}, "CVE-2019-3554": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-3556": {"epss_score": 0.01666, "epss_percentile": 0.81653}, "CVE-2019-3557": {"epss_score": 0.00746, "epss_percentile": 0.72539}, "CVE-2019-3558": {"epss_score": 0.00772, "epss_percentile": 0.73044}, "CVE-2019-3559": {"epss_score": 0.0056, "epss_percentile": 0.67652}, "CVE-2019-3560": {"epss_score": 0.00521, "epss_percentile": 0.66234}, "CVE-2019-3561": {"epss_score": 0.00746, "epss_percentile": 0.72539}, "CVE-2019-3562": {"epss_score": 0.00371, "epss_percentile": 0.58352}, "CVE-2019-3563": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-3564": {"epss_score": 0.0056, "epss_percentile": 0.67652}, "CVE-2019-3565": {"epss_score": 0.02127, "epss_percentile": 0.83699}, "CVE-2019-3566": {"epss_score": 0.00347, "epss_percentile": 0.56752}, "CVE-2019-3567": {"epss_score": 0.00433, "epss_percentile": 0.62177}, "CVE-2019-3568": {"epss_score": 0.45977, "epss_percentile": 0.97514}, "CVE-2019-3569": {"epss_score": 0.00366, "epss_percentile": 0.58078}, "CVE-2019-3570": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2019-3571": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-3572": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2019-3573": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2019-3574": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2019-3575": {"epss_score": 0.00113, "epss_percentile": 0.30614}, "CVE-2019-3576": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-3577": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-3578": {"epss_score": 0.00231, "epss_percentile": 0.45811}, "CVE-2019-3579": {"epss_score": 0.00256, "epss_percentile": 0.48782}, "CVE-2019-3580": {"epss_score": 0.00393, "epss_percentile": 0.5973}, "CVE-2019-3581": {"epss_score": 0.00504, "epss_percentile": 0.65485}, "CVE-2019-3582": {"epss_score": 0.0005, "epss_percentile": 0.15957}, "CVE-2019-3584": {"epss_score": 0.00074, "epss_percentile": 0.22848}, "CVE-2019-3585": {"epss_score": 0.00037, "epss_percentile": 0.10865}, "CVE-2019-3586": {"epss_score": 0.00271, "epss_percentile": 0.5032}, "CVE-2019-3587": {"epss_score": 0.00436, "epss_percentile": 0.62465}, "CVE-2019-3588": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2019-3591": {"epss_score": 0.00248, "epss_percentile": 0.47926}, "CVE-2019-3592": {"epss_score": 0.0006, "epss_percentile": 0.19232}, "CVE-2019-3593": {"epss_score": 0.00043, "epss_percentile": 0.13231}, "CVE-2019-3595": {"epss_score": 0.00192, "epss_percentile": 0.4136}, "CVE-2019-3597": {"epss_score": 0.00416, "epss_percentile": 0.61202}, "CVE-2019-3598": {"epss_score": 0.00372, "epss_percentile": 0.58419}, "CVE-2019-3599": {"epss_score": 0.00319, "epss_percentile": 0.5447}, "CVE-2019-3602": {"epss_score": 0.00265, "epss_percentile": 0.49842}, "CVE-2019-3604": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2019-3606": {"epss_score": 0.00029, "epss_percentile": 0.07636}, "CVE-2019-3610": {"epss_score": 0.00046, "epss_percentile": 0.14305}, "CVE-2019-3612": {"epss_score": 0.00048, "epss_percentile": 0.1515}, "CVE-2019-3613": {"epss_score": 0.00036, "epss_percentile": 0.10345}, "CVE-2019-3615": {"epss_score": 0.00054, "epss_percentile": 0.17337}, "CVE-2019-3617": {"epss_score": 0.00035, "epss_percentile": 0.10054}, "CVE-2019-3619": {"epss_score": 0.00163, "epss_percentile": 0.37845}, "CVE-2019-3621": {"epss_score": 0.00061, "epss_percentile": 0.19393}, "CVE-2019-3622": {"epss_score": 0.00085, "epss_percentile": 0.2513}, "CVE-2019-3628": {"epss_score": 0.00792, "epss_percentile": 0.73405}, "CVE-2019-3629": {"epss_score": 0.01376, "epss_percentile": 0.79838}, "CVE-2019-3630": {"epss_score": 0.02793, "epss_percentile": 0.85671}, "CVE-2019-3631": {"epss_score": 0.02793, "epss_percentile": 0.85671}, "CVE-2019-3632": {"epss_score": 0.01402, "epss_percentile": 0.80013}, "CVE-2019-3633": {"epss_score": 0.00046, "epss_percentile": 0.14144}, "CVE-2019-3634": {"epss_score": 0.00046, "epss_percentile": 0.14144}, "CVE-2019-3635": {"epss_score": 0.00318, "epss_percentile": 0.54446}, "CVE-2019-3636": {"epss_score": 0.00063, "epss_percentile": 0.20073}, "CVE-2019-3637": {"epss_score": 0.00049, "epss_percentile": 0.15456}, "CVE-2019-3638": {"epss_score": 0.01013, "epss_percentile": 0.76638}, "CVE-2019-3639": {"epss_score": 0.00273, "epss_percentile": 0.50452}, "CVE-2019-3640": {"epss_score": 0.00113, "epss_percentile": 0.30633}, "CVE-2019-3641": {"epss_score": 0.00244, "epss_percentile": 0.47623}, "CVE-2019-3643": {"epss_score": 0.00452, "epss_percentile": 0.63189}, "CVE-2019-3644": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2019-3646": {"epss_score": 0.00299, "epss_percentile": 0.52899}, "CVE-2019-3648": {"epss_score": 0.00168, "epss_percentile": 0.38518}, "CVE-2019-3649": {"epss_score": 0.0032, "epss_percentile": 0.54594}, "CVE-2019-3650": {"epss_score": 0.0032, "epss_percentile": 0.54594}, "CVE-2019-3651": {"epss_score": 0.00487, "epss_percentile": 0.64807}, "CVE-2019-3652": {"epss_score": 0.00121, "epss_percentile": 0.31836}, "CVE-2019-3653": {"epss_score": 0.00049, "epss_percentile": 0.15474}, "CVE-2019-3654": {"epss_score": 0.00088, "epss_percentile": 0.25668}, "CVE-2019-3660": {"epss_score": 0.00728, "epss_percentile": 0.72105}, "CVE-2019-3661": {"epss_score": 0.00182, "epss_percentile": 0.40138}, "CVE-2019-3662": {"epss_score": 0.0036, "epss_percentile": 0.57631}, "CVE-2019-3663": {"epss_score": 0.00439, "epss_percentile": 0.62605}, "CVE-2019-3665": {"epss_score": 0.00493, "epss_percentile": 0.65027}, "CVE-2019-3666": {"epss_score": 0.00376, "epss_percentile": 0.58642}, "CVE-2019-3667": {"epss_score": 0.00103, "epss_percentile": 0.29003}, "CVE-2019-3670": {"epss_score": 0.00847, "epss_percentile": 0.74353}, "CVE-2019-3681": {"epss_score": 0.00913, "epss_percentile": 0.75379}, "CVE-2019-3682": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2019-3683": {"epss_score": 0.00272, "epss_percentile": 0.50397}, "CVE-2019-3684": {"epss_score": 0.00171, "epss_percentile": 0.38809}, "CVE-2019-3685": {"epss_score": 0.0018, "epss_percentile": 0.39903}, "CVE-2019-3686": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2019-3687": {"epss_score": 0.00081, "epss_percentile": 0.24375}, "CVE-2019-3688": {"epss_score": 0.00057, "epss_percentile": 0.18074}, "CVE-2019-3689": {"epss_score": 0.00336, "epss_percentile": 0.55916}, "CVE-2019-3690": {"epss_score": 0.001, "epss_percentile": 0.28507}, "CVE-2019-3691": {"epss_score": 0.00147, "epss_percentile": 0.35724}, "CVE-2019-3692": {"epss_score": 0.00168, "epss_percentile": 0.38523}, "CVE-2019-3693": {"epss_score": 0.00168, "epss_percentile": 0.38523}, "CVE-2019-3694": {"epss_score": 0.0012, "epss_percentile": 0.31769}, "CVE-2019-3695": {"epss_score": 0.00118, "epss_percentile": 0.31395}, "CVE-2019-3696": {"epss_score": 0.00103, "epss_percentile": 0.29061}, "CVE-2019-3697": {"epss_score": 0.00129, "epss_percentile": 0.33161}, "CVE-2019-3698": {"epss_score": 0.00176, "epss_percentile": 0.39439}, "CVE-2019-3699": {"epss_score": 0.0012, "epss_percentile": 0.31769}, "CVE-2019-3700": {"epss_score": 0.00035, "epss_percentile": 0.0982}, "CVE-2019-3701": {"epss_score": 0.00056, "epss_percentile": 0.17806}, "CVE-2019-3702": {"epss_score": 0.10732, "epss_percentile": 0.93086}, "CVE-2019-3704": {"epss_score": 0.00563, "epss_percentile": 0.67719}, "CVE-2019-3705": {"epss_score": 0.0377, "epss_percentile": 0.87701}, "CVE-2019-3706": {"epss_score": 0.01791, "epss_percentile": 0.82284}, "CVE-2019-3707": {"epss_score": 0.01791, "epss_percentile": 0.82284}, "CVE-2019-3708": {"epss_score": 0.00564, "epss_percentile": 0.67766}, "CVE-2019-3709": {"epss_score": 0.00545, "epss_percentile": 0.67176}, "CVE-2019-3710": {"epss_score": 0.00362, "epss_percentile": 0.57791}, "CVE-2019-3711": {"epss_score": 0.01165, "epss_percentile": 0.78175}, "CVE-2019-3712": {"epss_score": 0.00153, "epss_percentile": 0.36582}, "CVE-2019-3715": {"epss_score": 0.00043, "epss_percentile": 0.13351}, "CVE-2019-3716": {"epss_score": 0.00051, "epss_percentile": 0.16316}, "CVE-2019-3717": {"epss_score": 0.00067, "epss_percentile": 0.21138}, "CVE-2019-3718": {"epss_score": 0.00232, "epss_percentile": 0.45963}, "CVE-2019-3719": {"epss_score": 0.26425, "epss_percentile": 0.96146}, "CVE-2019-3720": {"epss_score": 0.03856, "epss_percentile": 0.87857}, "CVE-2019-3721": {"epss_score": 0.00513, "epss_percentile": 0.65927}, "CVE-2019-3722": {"epss_score": 0.18574, "epss_percentile": 0.95035}, "CVE-2019-3723": {"epss_score": 0.00432, "epss_percentile": 0.62116}, "CVE-2019-3724": {"epss_score": 0.00155, "epss_percentile": 0.36821}, "CVE-2019-3725": {"epss_score": 0.04622, "epss_percentile": 0.88934}, "CVE-2019-3726": {"epss_score": 0.00058, "epss_percentile": 0.18469}, "CVE-2019-3727": {"epss_score": 0.00041, "epss_percentile": 0.12349}, "CVE-2019-3728": {"epss_score": 0.00861, "epss_percentile": 0.74566}, "CVE-2019-3729": {"epss_score": 0.00116, "epss_percentile": 0.3118}, "CVE-2019-3730": {"epss_score": 0.00113, "epss_percentile": 0.30655}, "CVE-2019-3731": {"epss_score": 0.00241, "epss_percentile": 0.47257}, "CVE-2019-3732": {"epss_score": 0.00313, "epss_percentile": 0.54018}, "CVE-2019-3733": {"epss_score": 0.00051, "epss_percentile": 0.1623}, "CVE-2019-3734": {"epss_score": 0.00129, "epss_percentile": 0.33146}, "CVE-2019-3735": {"epss_score": 0.00034, "epss_percentile": 0.09558}, "CVE-2019-3736": {"epss_score": 0.00073, "epss_percentile": 0.22479}, "CVE-2019-3737": {"epss_score": 0.00419, "epss_percentile": 0.61376}, "CVE-2019-3738": {"epss_score": 0.00968, "epss_percentile": 0.76084}, "CVE-2019-3739": {"epss_score": 0.01239, "epss_percentile": 0.78799}, "CVE-2019-3740": {"epss_score": 0.01239, "epss_percentile": 0.78799}, "CVE-2019-3741": {"epss_score": 0.00049, "epss_percentile": 0.15436}, "CVE-2019-3742": {"epss_score": 0.00126, "epss_percentile": 0.32625}, "CVE-2019-3744": {"epss_score": 0.00039, "epss_percentile": 0.11712}, "CVE-2019-3745": {"epss_score": 0.00024, "epss_percentile": 0.05687}, "CVE-2019-3746": {"epss_score": 0.00942, "epss_percentile": 0.75764}, "CVE-2019-3747": {"epss_score": 0.00452, "epss_percentile": 0.63168}, "CVE-2019-3749": {"epss_score": 0.00049, "epss_percentile": 0.15319}, "CVE-2019-3750": {"epss_score": 0.00049, "epss_percentile": 0.15319}, "CVE-2019-3751": {"epss_score": 0.00105, "epss_percentile": 0.29318}, "CVE-2019-3752": {"epss_score": 0.00376, "epss_percentile": 0.58677}, "CVE-2019-3753": {"epss_score": 0.00116, "epss_percentile": 0.31133}, "CVE-2019-3754": {"epss_score": 0.00209, "epss_percentile": 0.43381}, "CVE-2019-3756": {"epss_score": 0.00215, "epss_percentile": 0.44026}, "CVE-2019-3758": {"epss_score": 0.00619, "epss_percentile": 0.69398}, "CVE-2019-3759": {"epss_score": 0.01233, "epss_percentile": 0.78746}, "CVE-2019-3760": {"epss_score": 0.00167, "epss_percentile": 0.38319}, "CVE-2019-3761": {"epss_score": 0.00144, "epss_percentile": 0.35317}, "CVE-2019-3762": {"epss_score": 0.00232, "epss_percentile": 0.45894}, "CVE-2019-3763": {"epss_score": 0.00049, "epss_percentile": 0.15436}, "CVE-2019-3764": {"epss_score": 0.00239, "epss_percentile": 0.46889}, "CVE-2019-3765": {"epss_score": 0.00198, "epss_percentile": 0.41988}, "CVE-2019-3766": {"epss_score": 0.02015, "epss_percentile": 0.83271}, "CVE-2019-3767": {"epss_score": 0.00088, "epss_percentile": 0.2574}, "CVE-2019-3768": {"epss_score": 0.00526, "epss_percentile": 0.66434}, "CVE-2019-3769": {"epss_score": 0.0019, "epss_percentile": 0.41119}, "CVE-2019-3770": {"epss_score": 0.0019, "epss_percentile": 0.41119}, "CVE-2019-3772": {"epss_score": 0.02046, "epss_percentile": 0.83386}, "CVE-2019-3773": {"epss_score": 0.00334, "epss_percentile": 0.55718}, "CVE-2019-3774": {"epss_score": 0.02036, "epss_percentile": 0.83354}, "CVE-2019-3775": {"epss_score": 0.00132, "epss_percentile": 0.33533}, "CVE-2019-3776": {"epss_score": 0.00192, "epss_percentile": 0.41368}, "CVE-2019-3777": {"epss_score": 0.00611, "epss_percentile": 0.692}, "CVE-2019-3778": {"epss_score": 0.1727, "epss_percentile": 0.94813}, "CVE-2019-3779": {"epss_score": 0.00147, "epss_percentile": 0.35797}, "CVE-2019-3780": {"epss_score": 0.00379, "epss_percentile": 0.5885}, "CVE-2019-3781": {"epss_score": 0.00152, "epss_percentile": 0.36422}, "CVE-2019-3782": {"epss_score": 0.00074, "epss_percentile": 0.22748}, "CVE-2019-3783": {"epss_score": 0.00232, "epss_percentile": 0.45969}, "CVE-2019-3784": {"epss_score": 0.00181, "epss_percentile": 0.40028}, "CVE-2019-3785": {"epss_score": 0.0037, "epss_percentile": 0.58326}, "CVE-2019-3786": {"epss_score": 0.00092, "epss_percentile": 0.26554}, "CVE-2019-3787": {"epss_score": 0.00271, "epss_percentile": 0.50281}, "CVE-2019-3788": {"epss_score": 0.00502, "epss_percentile": 0.65405}, "CVE-2019-3789": {"epss_score": 0.00158, "epss_percentile": 0.37163}, "CVE-2019-3790": {"epss_score": 0.0006, "epss_percentile": 0.19084}, "CVE-2019-3792": {"epss_score": 0.00362, "epss_percentile": 0.57761}, "CVE-2019-3793": {"epss_score": 0.0025, "epss_percentile": 0.48111}, "CVE-2019-3794": {"epss_score": 0.00306, "epss_percentile": 0.53409}, "CVE-2019-3795": {"epss_score": 0.01961, "epss_percentile": 0.83061}, "CVE-2019-3797": {"epss_score": 0.00246, "epss_percentile": 0.47741}, "CVE-2019-3798": {"epss_score": 0.01948, "epss_percentile": 0.83008}, "CVE-2019-3799": {"epss_score": 0.9117, "epss_percentile": 0.99624}, "CVE-2019-3800": {"epss_score": 0.00205, "epss_percentile": 0.42726}, "CVE-2019-3801": {"epss_score": 0.00071, "epss_percentile": 0.22015}, "CVE-2019-3802": {"epss_score": 0.00243, "epss_percentile": 0.47473}, "CVE-2019-3803": {"epss_score": 0.00173, "epss_percentile": 0.39107}, "CVE-2019-3804": {"epss_score": 0.0455, "epss_percentile": 0.88839}, "CVE-2019-3805": {"epss_score": 0.00042, "epss_percentile": 0.12811}, "CVE-2019-3806": {"epss_score": 0.00024, "epss_percentile": 0.05662}, "CVE-2019-3807": {"epss_score": 3e-05, "epss_percentile": 0.00108}, "CVE-2019-3808": {"epss_score": 0.00275, "epss_percentile": 0.50639}, "CVE-2019-3809": {"epss_score": 0.00231, "epss_percentile": 0.45845}, "CVE-2019-3810": {"epss_score": 0.07723, "epss_percentile": 0.91645}, "CVE-2019-3811": {"epss_score": 0.00153, "epss_percentile": 0.36542}, "CVE-2019-3812": {"epss_score": 0.00076, "epss_percentile": 0.23256}, "CVE-2019-3813": {"epss_score": 0.00241, "epss_percentile": 0.47296}, "CVE-2019-3814": {"epss_score": 0.00475, "epss_percentile": 0.64246}, "CVE-2019-3815": {"epss_score": 0.00125, "epss_percentile": 0.32576}, "CVE-2019-3816": {"epss_score": 0.00961, "epss_percentile": 0.75974}, "CVE-2019-3817": {"epss_score": 0.00531, "epss_percentile": 0.66657}, "CVE-2019-3818": {"epss_score": 0.00075, "epss_percentile": 0.22912}, "CVE-2019-3819": {"epss_score": 9e-05, "epss_percentile": 0.00714}, "CVE-2019-3820": {"epss_score": 0.00045, "epss_percentile": 0.1374}, "CVE-2019-3821": {"epss_score": 0.00942, "epss_percentile": 0.75762}, "CVE-2019-3822": {"epss_score": 0.27871, "epss_percentile": 0.96289}, "CVE-2019-3823": {"epss_score": 0.01673, "epss_percentile": 0.8169}, "CVE-2019-3824": {"epss_score": 0.09569, "epss_percentile": 0.92604}, "CVE-2019-3825": {"epss_score": 0.00075, "epss_percentile": 0.23027}, "CVE-2019-3826": {"epss_score": 0.02019, "epss_percentile": 0.8329}, "CVE-2019-3827": {"epss_score": 0.00063, "epss_percentile": 0.19925}, "CVE-2019-3828": {"epss_score": 0.00039, "epss_percentile": 0.11604}, "CVE-2019-3829": {"epss_score": 0.02122, "epss_percentile": 0.83682}, "CVE-2019-3830": {"epss_score": 0.00115, "epss_percentile": 0.30973}, "CVE-2019-3831": {"epss_score": 0.00098, "epss_percentile": 0.27665}, "CVE-2019-3832": {"epss_score": 0.001, "epss_percentile": 0.28437}, "CVE-2019-3833": {"epss_score": 0.02982, "epss_percentile": 0.86124}, "CVE-2019-3834": {"epss_score": 0.0033, "epss_percentile": 0.55417}, "CVE-2019-3835": {"epss_score": 0.0167, "epss_percentile": 0.81671}, "CVE-2019-3836": {"epss_score": 0.00369, "epss_percentile": 0.58239}, "CVE-2019-3837": {"epss_score": 0.00093, "epss_percentile": 0.26622}, "CVE-2019-3838": {"epss_score": 0.01387, "epss_percentile": 0.79915}, "CVE-2019-3839": {"epss_score": 0.00173, "epss_percentile": 0.39074}, "CVE-2019-3840": {"epss_score": 0.00752, "epss_percentile": 0.72652}, "CVE-2019-3841": {"epss_score": 0.00116, "epss_percentile": 0.31189}, "CVE-2019-3842": {"epss_score": 0.001, "epss_percentile": 0.28432}, "CVE-2019-3843": {"epss_score": 0.00128, "epss_percentile": 0.33056}, "CVE-2019-3844": {"epss_score": 0.0016, "epss_percentile": 0.37476}, "CVE-2019-3845": {"epss_score": 0.00175, "epss_percentile": 0.3929}, "CVE-2019-3846": {"epss_score": 0.00375, "epss_percentile": 0.58595}, "CVE-2019-3847": {"epss_score": 0.01055, "epss_percentile": 0.77114}, "CVE-2019-3848": {"epss_score": 0.00133, "epss_percentile": 0.33652}, "CVE-2019-3849": {"epss_score": 0.00374, "epss_percentile": 0.58543}, "CVE-2019-3850": {"epss_score": 0.00126, "epss_percentile": 0.32631}, "CVE-2019-3851": {"epss_score": 0.00183, "epss_percentile": 0.4036}, "CVE-2019-3852": {"epss_score": 0.00228, "epss_percentile": 0.4553}, "CVE-2019-3855": {"epss_score": 0.10006, "epss_percentile": 0.92813}, "CVE-2019-3856": {"epss_score": 0.04601, "epss_percentile": 0.88902}, "CVE-2019-3857": {"epss_score": 0.03441, "epss_percentile": 0.8714}, "CVE-2019-3858": {"epss_score": 0.02187, "epss_percentile": 0.83922}, "CVE-2019-3859": {"epss_score": 0.00882, "epss_percentile": 0.7489}, "CVE-2019-3860": {"epss_score": 0.00813, "epss_percentile": 0.73757}, "CVE-2019-3861": {"epss_score": 0.01534, "epss_percentile": 0.80903}, "CVE-2019-3862": {"epss_score": 0.06559, "epss_percentile": 0.90848}, "CVE-2019-3863": {"epss_score": 0.08613, "epss_percentile": 0.92152}, "CVE-2019-3864": {"epss_score": 0.00158, "epss_percentile": 0.37212}, "CVE-2019-3865": {"epss_score": 0.00345, "epss_percentile": 0.56587}, "CVE-2019-3866": {"epss_score": 0.0006, "epss_percentile": 0.19195}, "CVE-2019-3867": {"epss_score": 0.00108, "epss_percentile": 0.29838}, "CVE-2019-3868": {"epss_score": 0.00291, "epss_percentile": 0.52193}, "CVE-2019-3869": {"epss_score": 0.00329, "epss_percentile": 0.55316}, "CVE-2019-3870": {"epss_score": 0.00459, "epss_percentile": 0.63481}, "CVE-2019-3871": {"epss_score": 0.00033, "epss_percentile": 0.09365}, "CVE-2019-3872": {"epss_score": 0.00196, "epss_percentile": 0.41795}, "CVE-2019-3873": {"epss_score": 0.00403, "epss_percentile": 0.60379}, "CVE-2019-3874": {"epss_score": 0.00181, "epss_percentile": 0.40124}, "CVE-2019-3875": {"epss_score": 0.00047, "epss_percentile": 0.14896}, "CVE-2019-3876": {"epss_score": 0.00203, "epss_percentile": 0.42547}, "CVE-2019-3877": {"epss_score": 0.0061, "epss_percentile": 0.69154}, "CVE-2019-3878": {"epss_score": 0.03208, "epss_percentile": 0.86641}, "CVE-2019-3879": {"epss_score": 0.00573, "epss_percentile": 0.68056}, "CVE-2019-3880": {"epss_score": 0.03735, "epss_percentile": 0.87649}, "CVE-2019-3881": {"epss_score": 0.00085, "epss_percentile": 0.25127}, "CVE-2019-3882": {"epss_score": 0.00041, "epss_percentile": 0.12367}, "CVE-2019-3883": {"epss_score": 0.00883, "epss_percentile": 0.74917}, "CVE-2019-3884": {"epss_score": 0.00111, "epss_percentile": 0.30401}, "CVE-2019-3885": {"epss_score": 0.00303, "epss_percentile": 0.53195}, "CVE-2019-3886": {"epss_score": 0.00525, "epss_percentile": 0.66382}, "CVE-2019-3887": {"epss_score": 0.0005, "epss_percentile": 0.15956}, "CVE-2019-3888": {"epss_score": 0.00569, "epss_percentile": 0.67913}, "CVE-2019-3889": {"epss_score": 0.00296, "epss_percentile": 0.52583}, "CVE-2019-3890": {"epss_score": 0.00227, "epss_percentile": 0.4546}, "CVE-2019-3891": {"epss_score": 0.00042, "epss_percentile": 0.1273}, "CVE-2019-3893": {"epss_score": 0.00399, "epss_percentile": 0.60143}, "CVE-2019-3894": {"epss_score": 0.01229, "epss_percentile": 0.78718}, "CVE-2019-3895": {"epss_score": 0.0054, "epss_percentile": 0.67001}, "CVE-2019-3896": {"epss_score": 0.0011, "epss_percentile": 0.30105}, "CVE-2019-3897": {"epss_score": 0.00179, "epss_percentile": 0.39787}, "CVE-2019-3899": {"epss_score": 0.00395, "epss_percentile": 0.59834}, "CVE-2019-3900": {"epss_score": 0.00081, "epss_percentile": 0.24367}, "CVE-2019-3901": {"epss_score": 0.00072, "epss_percentile": 0.22388}, "CVE-2019-3902": {"epss_score": 0.00764, "epss_percentile": 0.72894}, "CVE-2019-3905": {"epss_score": 0.03479, "epss_percentile": 0.87216}, "CVE-2019-3906": {"epss_score": 0.01989, "epss_percentile": 0.8317}, "CVE-2019-3907": {"epss_score": 0.00161, "epss_percentile": 0.37533}, "CVE-2019-3908": {"epss_score": 0.00639, "epss_percentile": 0.69935}, "CVE-2019-3909": {"epss_score": 0.01004, "epss_percentile": 0.76532}, "CVE-2019-3910": {"epss_score": 0.05464, "epss_percentile": 0.89902}, "CVE-2019-3911": {"epss_score": 0.01482, "epss_percentile": 0.80582}, "CVE-2019-3912": {"epss_score": 0.08738, "epss_percentile": 0.92234}, "CVE-2019-3913": {"epss_score": 0.00679, "epss_percentile": 0.71015}, "CVE-2019-3914": {"epss_score": 0.27902, "epss_percentile": 0.96293}, "CVE-2019-3915": {"epss_score": 0.00212, "epss_percentile": 0.43808}, "CVE-2019-3916": {"epss_score": 0.00961, "epss_percentile": 0.75978}, "CVE-2019-3917": {"epss_score": 0.00216, "epss_percentile": 0.44158}, "CVE-2019-3918": {"epss_score": 0.00346, "epss_percentile": 0.56647}, "CVE-2019-3919": {"epss_score": 0.10177, "epss_percentile": 0.92881}, "CVE-2019-3920": {"epss_score": 0.10177, "epss_percentile": 0.92881}, "CVE-2019-3921": {"epss_score": 0.0549, "epss_percentile": 0.8993}, "CVE-2019-3922": {"epss_score": 0.12561, "epss_percentile": 0.93716}, "CVE-2019-3923": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2019-3924": {"epss_score": 0.11155, "epss_percentile": 0.93247}, "CVE-2019-3925": {"epss_score": 0.25457, "epss_percentile": 0.9603}, "CVE-2019-3926": {"epss_score": 0.25457, "epss_percentile": 0.9603}, "CVE-2019-3927": {"epss_score": 0.01822, "epss_percentile": 0.82413}, "CVE-2019-3928": {"epss_score": 0.00706, "epss_percentile": 0.71638}, "CVE-2019-3929": {"epss_score": 0.94346, "epss_percentile": 0.99954}, "CVE-2019-3930": {"epss_score": 0.15231, "epss_percentile": 0.9439}, "CVE-2019-3931": {"epss_score": 0.04104, "epss_percentile": 0.88263}, "CVE-2019-3932": {"epss_score": 0.083, "epss_percentile": 0.91977}, "CVE-2019-3933": {"epss_score": 0.00369, "epss_percentile": 0.58249}, "CVE-2019-3934": {"epss_score": 0.00343, "epss_percentile": 0.56406}, "CVE-2019-3935": {"epss_score": 0.01438, "epss_percentile": 0.80287}, "CVE-2019-3936": {"epss_score": 0.01543, "epss_percentile": 0.80957}, "CVE-2019-3937": {"epss_score": 0.00023, "epss_percentile": 0.05432}, "CVE-2019-3938": {"epss_score": 0.00025, "epss_percentile": 0.06284}, "CVE-2019-3939": {"epss_score": 0.03597, "epss_percentile": 0.87405}, "CVE-2019-3940": {"epss_score": 0.04283, "epss_percentile": 0.88491}, "CVE-2019-3941": {"epss_score": 0.03081, "epss_percentile": 0.86374}, "CVE-2019-3942": {"epss_score": 0.00935, "epss_percentile": 0.75668}, "CVE-2019-3943": {"epss_score": 0.00575, "epss_percentile": 0.68098}, "CVE-2019-3944": {"epss_score": 0.0074, "epss_percentile": 0.72412}, "CVE-2019-3945": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2019-3946": {"epss_score": 0.0146, "epss_percentile": 0.80419}, "CVE-2019-3947": {"epss_score": 0.00415, "epss_percentile": 0.61138}, "CVE-2019-3948": {"epss_score": 0.37992, "epss_percentile": 0.9708}, "CVE-2019-3949": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2019-3950": {"epss_score": 0.0047, "epss_percentile": 0.63991}, "CVE-2019-3951": {"epss_score": 0.1184, "epss_percentile": 0.93491}, "CVE-2019-3953": {"epss_score": 0.05951, "epss_percentile": 0.90356}, "CVE-2019-3954": {"epss_score": 0.05951, "epss_percentile": 0.90356}, "CVE-2019-3955": {"epss_score": 0.11556, "epss_percentile": 0.93403}, "CVE-2019-3956": {"epss_score": 0.00853, "epss_percentile": 0.74431}, "CVE-2019-3957": {"epss_score": 0.06636, "epss_percentile": 0.90907}, "CVE-2019-3958": {"epss_score": 0.00157, "epss_percentile": 0.37034}, "CVE-2019-3959": {"epss_score": 0.00209, "epss_percentile": 0.4332}, "CVE-2019-3960": {"epss_score": 0.02331, "epss_percentile": 0.84406}, "CVE-2019-3961": {"epss_score": 0.00335, "epss_percentile": 0.55803}, "CVE-2019-3962": {"epss_score": 0.00227, "epss_percentile": 0.45403}, "CVE-2019-3963": {"epss_score": 0.21527, "epss_percentile": 0.95529}, "CVE-2019-3964": {"epss_score": 0.21527, "epss_percentile": 0.95529}, "CVE-2019-3965": {"epss_score": 0.28888, "epss_percentile": 0.96398}, "CVE-2019-3966": {"epss_score": 0.28888, "epss_percentile": 0.96398}, "CVE-2019-3967": {"epss_score": 0.33286, "epss_percentile": 0.9676}, "CVE-2019-3968": {"epss_score": 0.53587, "epss_percentile": 0.97883}, "CVE-2019-3969": {"epss_score": 0.00064, "epss_percentile": 0.20178}, "CVE-2019-3970": {"epss_score": 0.00048, "epss_percentile": 0.15186}, "CVE-2019-3971": {"epss_score": 0.00048, "epss_percentile": 0.15028}, "CVE-2019-3972": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2019-3973": {"epss_score": 0.00049, "epss_percentile": 0.153}, "CVE-2019-3974": {"epss_score": 0.00513, "epss_percentile": 0.65927}, "CVE-2019-3975": {"epss_score": 0.0998, "epss_percentile": 0.92801}, "CVE-2019-3976": {"epss_score": 0.00871, "epss_percentile": 0.74709}, "CVE-2019-3977": {"epss_score": 0.00859, "epss_percentile": 0.74515}, "CVE-2019-3978": {"epss_score": 0.16611, "epss_percentile": 0.94702}, "CVE-2019-3979": {"epss_score": 0.00223, "epss_percentile": 0.44845}, "CVE-2019-3980": {"epss_score": 0.40909, "epss_percentile": 0.97243}, "CVE-2019-3981": {"epss_score": 0.00323, "epss_percentile": 0.54911}, "CVE-2019-3982": {"epss_score": 0.00711, "epss_percentile": 0.7174}, "CVE-2019-3983": {"epss_score": 0.01714, "epss_percentile": 0.81892}, "CVE-2019-3984": {"epss_score": 0.03317, "epss_percentile": 0.86903}, "CVE-2019-3985": {"epss_score": 0.00731, "epss_percentile": 0.72183}, "CVE-2019-3986": {"epss_score": 0.0054, "epss_percentile": 0.67021}, "CVE-2019-3987": {"epss_score": 0.00731, "epss_percentile": 0.72183}, "CVE-2019-3988": {"epss_score": 0.00731, "epss_percentile": 0.72183}, "CVE-2019-3989": {"epss_score": 0.01403, "epss_percentile": 0.80031}, "CVE-2019-3990": {"epss_score": 0.00307, "epss_percentile": 0.53565}, "CVE-2019-3992": {"epss_score": 0.04031, "epss_percentile": 0.88151}, "CVE-2019-3993": {"epss_score": 0.11612, "epss_percentile": 0.9342}, "CVE-2019-3994": {"epss_score": 0.028, "epss_percentile": 0.85695}, "CVE-2019-3995": {"epss_score": 0.07962, "epss_percentile": 0.91791}, "CVE-2019-3996": {"epss_score": 0.03524, "epss_percentile": 0.87292}, "CVE-2019-3997": {"epss_score": 0.0006, "epss_percentile": 0.19178}, "CVE-2019-3998": {"epss_score": 0.00056, "epss_percentile": 0.17742}, "CVE-2019-3999": {"epss_score": 0.16557, "epss_percentile": 0.9469}, "CVE-2019-4000": {"epss_score": 0.00121, "epss_percentile": 0.31836}, "CVE-2019-4001": {"epss_score": 0.00133, "epss_percentile": 0.33704}, "CVE-2019-4008": {"epss_score": 0.00458, "epss_percentile": 0.63435}, "CVE-2019-4011": {"epss_score": 0.00211, "epss_percentile": 0.43684}, "CVE-2019-4012": {"epss_score": 0.00314, "epss_percentile": 0.5411}, "CVE-2019-4013": {"epss_score": 0.16831, "epss_percentile": 0.94736}, "CVE-2019-4014": {"epss_score": 0.0007, "epss_percentile": 0.21952}, "CVE-2019-4015": {"epss_score": 0.00096, "epss_percentile": 0.27324}, "CVE-2019-4016": {"epss_score": 0.00096, "epss_percentile": 0.27324}, "CVE-2019-4027": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2019-4028": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2019-4029": {"epss_score": 0.00224, "epss_percentile": 0.45035}, "CVE-2019-4030": {"epss_score": 0.0024, "epss_percentile": 0.47227}, "CVE-2019-4031": {"epss_score": 0.0011, "epss_percentile": 0.30213}, "CVE-2019-4032": {"epss_score": 0.00358, "epss_percentile": 0.57539}, "CVE-2019-4033": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2019-4034": {"epss_score": 0.00806, "epss_percentile": 0.73646}, "CVE-2019-4035": {"epss_score": 0.00126, "epss_percentile": 0.32637}, "CVE-2019-4036": {"epss_score": 0.00529, "epss_percentile": 0.66603}, "CVE-2019-4038": {"epss_score": 0.0009, "epss_percentile": 0.2613}, "CVE-2019-4039": {"epss_score": 0.00038, "epss_percentile": 0.11312}, "CVE-2019-4040": {"epss_score": 0.00226, "epss_percentile": 0.45267}, "CVE-2019-4043": {"epss_score": 0.00688, "epss_percentile": 0.712}, "CVE-2019-4045": {"epss_score": 0.00126, "epss_percentile": 0.32748}, "CVE-2019-4046": {"epss_score": 0.01155, "epss_percentile": 0.78074}, "CVE-2019-4047": {"epss_score": 0.00467, "epss_percentile": 0.63844}, "CVE-2019-4048": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2019-4049": {"epss_score": 0.00108, "epss_percentile": 0.29858}, "CVE-2019-4051": {"epss_score": 0.00202, "epss_percentile": 0.42483}, "CVE-2019-4052": {"epss_score": 0.00696, "epss_percentile": 0.71384}, "CVE-2019-4054": {"epss_score": 0.00041, "epss_percentile": 0.1241}, "CVE-2019-4055": {"epss_score": 0.00691, "epss_percentile": 0.71266}, "CVE-2019-4056": {"epss_score": 0.00126, "epss_percentile": 0.32748}, "CVE-2019-4057": {"epss_score": 0.00066, "epss_percentile": 0.20862}, "CVE-2019-4058": {"epss_score": 0.00097, "epss_percentile": 0.27538}, "CVE-2019-4059": {"epss_score": 0.00302, "epss_percentile": 0.5309}, "CVE-2019-4061": {"epss_score": 0.7919, "epss_percentile": 0.99023}, "CVE-2019-4062": {"epss_score": 0.00377, "epss_percentile": 0.58713}, "CVE-2019-4063": {"epss_score": 0.00134, "epss_percentile": 0.33906}, "CVE-2019-4066": {"epss_score": 0.01004, "epss_percentile": 0.76532}, "CVE-2019-4067": {"epss_score": 0.00205, "epss_percentile": 0.42711}, "CVE-2019-4068": {"epss_score": 0.00176, "epss_percentile": 0.39487}, "CVE-2019-4069": {"epss_score": 0.00434, "epss_percentile": 0.62297}, "CVE-2019-4070": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2019-4071": {"epss_score": 0.02297, "epss_percentile": 0.84298}, "CVE-2019-4072": {"epss_score": 0.00153, "epss_percentile": 0.36641}, "CVE-2019-4073": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2019-4074": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2019-4075": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2019-4076": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2019-4077": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2019-4078": {"epss_score": 0.0006, "epss_percentile": 0.19103}, "CVE-2019-4080": {"epss_score": 0.0134, "epss_percentile": 0.79577}, "CVE-2019-4083": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2019-4084": {"epss_score": 0.00156, "epss_percentile": 0.3694}, "CVE-2019-4086": {"epss_score": 0.00181, "epss_percentile": 0.40116}, "CVE-2019-4087": {"epss_score": 0.1405, "epss_percentile": 0.94121}, "CVE-2019-4088": {"epss_score": 0.00084, "epss_percentile": 0.24954}, "CVE-2019-4090": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2019-4091": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2019-4092": {"epss_score": 0.00152, "epss_percentile": 0.36471}, "CVE-2019-4093": {"epss_score": 0.00058, "epss_percentile": 0.18313}, "CVE-2019-4094": {"epss_score": 0.00044, "epss_percentile": 0.1359}, "CVE-2019-4095": {"epss_score": 0.00129, "epss_percentile": 0.33101}, "CVE-2019-4098": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2019-4101": {"epss_score": 0.00059, "epss_percentile": 0.18673}, "CVE-2019-4102": {"epss_score": 0.00142, "epss_percentile": 0.3509}, "CVE-2019-4103": {"epss_score": 0.01131, "epss_percentile": 0.77855}, "CVE-2019-4106": {"epss_score": 0.00213, "epss_percentile": 0.4391}, "CVE-2019-4109": {"epss_score": 0.00181, "epss_percentile": 0.40116}, "CVE-2019-4112": {"epss_score": 0.00046, "epss_percentile": 0.14324}, "CVE-2019-4115": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2019-4116": {"epss_score": 0.00054, "epss_percentile": 0.17104}, "CVE-2019-4117": {"epss_score": 0.00139, "epss_percentile": 0.3454}, "CVE-2019-4118": {"epss_score": 0.00058, "epss_percentile": 0.18527}, "CVE-2019-4119": {"epss_score": 0.0026, "epss_percentile": 0.49229}, "CVE-2019-4120": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2019-4129": {"epss_score": 0.00192, "epss_percentile": 0.41292}, "CVE-2019-4130": {"epss_score": 0.01801, "epss_percentile": 0.82326}, "CVE-2019-4131": {"epss_score": 0.0015, "epss_percentile": 0.36046}, "CVE-2019-4132": {"epss_score": 0.00048, "epss_percentile": 0.15231}, "CVE-2019-4133": {"epss_score": 0.00053, "epss_percentile": 0.16751}, "CVE-2019-4134": {"epss_score": 0.00182, "epss_percentile": 0.40276}, "CVE-2019-4135": {"epss_score": 0.00498, "epss_percentile": 0.65223}, "CVE-2019-4136": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2019-4137": {"epss_score": 0.00189, "epss_percentile": 0.40979}, "CVE-2019-4138": {"epss_score": 0.00286, "epss_percentile": 0.51743}, "CVE-2019-4139": {"epss_score": 0.00282, "epss_percentile": 0.51236}, "CVE-2019-4140": {"epss_score": 0.00045, "epss_percentile": 0.13707}, "CVE-2019-4141": {"epss_score": 0.00356, "epss_percentile": 0.57395}, "CVE-2019-4142": {"epss_score": 0.00128, "epss_percentile": 0.32983}, "CVE-2019-4143": {"epss_score": 0.00052, "epss_percentile": 0.16589}, "CVE-2019-4145": {"epss_score": 0.00045, "epss_percentile": 0.13707}, "CVE-2019-4146": {"epss_score": 0.00225, "epss_percentile": 0.45136}, "CVE-2019-4147": {"epss_score": 0.00413, "epss_percentile": 0.61004}, "CVE-2019-4148": {"epss_score": 0.00162, "epss_percentile": 0.37735}, "CVE-2019-4149": {"epss_score": 0.00232, "epss_percentile": 0.45965}, "CVE-2019-4150": {"epss_score": 0.00075, "epss_percentile": 0.22966}, "CVE-2019-4151": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2019-4152": {"epss_score": 0.00042, "epss_percentile": 0.12643}, "CVE-2019-4153": {"epss_score": 0.00092, "epss_percentile": 0.2642}, "CVE-2019-4154": {"epss_score": 0.00098, "epss_percentile": 0.277}, "CVE-2019-4155": {"epss_score": 0.00781, "epss_percentile": 0.73193}, "CVE-2019-4156": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2019-4157": {"epss_score": 0.00182, "epss_percentile": 0.40276}, "CVE-2019-4158": {"epss_score": 0.00089, "epss_percentile": 0.25841}, "CVE-2019-4160": {"epss_score": 0.00052, "epss_percentile": 0.16451}, "CVE-2019-4161": {"epss_score": 0.00042, "epss_percentile": 0.12651}, "CVE-2019-4162": {"epss_score": 0.0006, "epss_percentile": 0.1914}, "CVE-2019-4163": {"epss_score": 0.00156, "epss_percentile": 0.3694}, "CVE-2019-4165": {"epss_score": 0.00454, "epss_percentile": 0.63258}, "CVE-2019-4166": {"epss_score": 0.00204, "epss_percentile": 0.42643}, "CVE-2019-4167": {"epss_score": 0.0009, "epss_percentile": 0.26068}, "CVE-2019-4169": {"epss_score": 0.00268, "epss_percentile": 0.50065}, "CVE-2019-4171": {"epss_score": 0.0018, "epss_percentile": 0.39936}, "CVE-2019-4173": {"epss_score": 0.00292, "epss_percentile": 0.52248}, "CVE-2019-4174": {"epss_score": 0.00046, "epss_percentile": 0.14324}, "CVE-2019-4175": {"epss_score": 0.00146, "epss_percentile": 0.35574}, "CVE-2019-4176": {"epss_score": 0.00089, "epss_percentile": 0.25927}, "CVE-2019-4177": {"epss_score": 0.00046, "epss_percentile": 0.14324}, "CVE-2019-4178": {"epss_score": 0.00557, "epss_percentile": 0.67551}, "CVE-2019-4183": {"epss_score": 0.01142, "epss_percentile": 0.77975}, "CVE-2019-4184": {"epss_score": 0.00229, "epss_percentile": 0.45551}, "CVE-2019-4185": {"epss_score": 0.00209, "epss_percentile": 0.43364}, "CVE-2019-4186": {"epss_score": 0.00082, "epss_percentile": 0.24585}, "CVE-2019-4193": {"epss_score": 0.00299, "epss_percentile": 0.52867}, "CVE-2019-4194": {"epss_score": 0.00413, "epss_percentile": 0.61008}, "CVE-2019-4201": {"epss_score": 0.00176, "epss_percentile": 0.39428}, "CVE-2019-4202": {"epss_score": 0.02635, "epss_percentile": 0.8529}, "CVE-2019-4203": {"epss_score": 0.00483, "epss_percentile": 0.64595}, "CVE-2019-4204": {"epss_score": 0.00229, "epss_percentile": 0.45551}, "CVE-2019-4207": {"epss_score": 0.00041, "epss_percentile": 0.1241}, "CVE-2019-4208": {"epss_score": 0.00377, "epss_percentile": 0.58713}, "CVE-2019-4209": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2019-4210": {"epss_score": 0.00196, "epss_percentile": 0.41795}, "CVE-2019-4211": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2019-4212": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2019-4214": {"epss_score": 0.00154, "epss_percentile": 0.36724}, "CVE-2019-4215": {"epss_score": 0.00293, "epss_percentile": 0.52327}, "CVE-2019-4216": {"epss_score": 0.0009, "epss_percentile": 0.26101}, "CVE-2019-4217": {"epss_score": 0.00126, "epss_percentile": 0.32741}, "CVE-2019-4218": {"epss_score": 0.0004, "epss_percentile": 0.11864}, "CVE-2019-4219": {"epss_score": 0.00126, "epss_percentile": 0.32732}, "CVE-2019-4220": {"epss_score": 0.00026, "epss_percentile": 0.06446}, "CVE-2019-4222": {"epss_score": 0.00132, "epss_percentile": 0.33601}, "CVE-2019-4224": {"epss_score": 0.00215, "epss_percentile": 0.44078}, "CVE-2019-4225": {"epss_score": 0.0004, "epss_percentile": 0.12187}, "CVE-2019-4226": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2019-4227": {"epss_score": 0.00325, "epss_percentile": 0.55032}, "CVE-2019-4231": {"epss_score": 0.00177, "epss_percentile": 0.39572}, "CVE-2019-4234": {"epss_score": 0.00165, "epss_percentile": 0.38064}, "CVE-2019-4235": {"epss_score": 0.00267, "epss_percentile": 0.5001}, "CVE-2019-4236": {"epss_score": 0.00042, "epss_percentile": 0.12788}, "CVE-2019-4237": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2019-4238": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2019-4239": {"epss_score": 0.00044, "epss_percentile": 0.13465}, "CVE-2019-4241": {"epss_score": 0.0005, "epss_percentile": 0.15966}, "CVE-2019-4243": {"epss_score": 0.00085, "epss_percentile": 0.25234}, "CVE-2019-4244": {"epss_score": 0.00669, "epss_percentile": 0.70766}, "CVE-2019-4246": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2019-4249": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2019-4250": {"epss_score": 0.00174, "epss_percentile": 0.39211}, "CVE-2019-4252": {"epss_score": 0.00612, "epss_percentile": 0.69212}, "CVE-2019-4253": {"epss_score": 0.00145, "epss_percentile": 0.35453}, "CVE-2019-4256": {"epss_score": 0.00158, "epss_percentile": 0.37218}, "CVE-2019-4257": {"epss_score": 0.00156, "epss_percentile": 0.36883}, "CVE-2019-4258": {"epss_score": 0.00229, "epss_percentile": 0.45551}, "CVE-2019-4259": {"epss_score": 0.00044, "epss_percentile": 0.13557}, "CVE-2019-4260": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2019-4261": {"epss_score": 0.00295, "epss_percentile": 0.52469}, "CVE-2019-4262": {"epss_score": 0.00169, "epss_percentile": 0.38545}, "CVE-2019-4263": {"epss_score": 0.00133, "epss_percentile": 0.33663}, "CVE-2019-4264": {"epss_score": 0.00117, "epss_percentile": 0.31278}, "CVE-2019-4265": {"epss_score": 0.00051, "epss_percentile": 0.16139}, "CVE-2019-4266": {"epss_score": 0.00048, "epss_percentile": 0.15124}, "CVE-2019-4267": {"epss_score": 0.00098, "epss_percentile": 0.27806}, "CVE-2019-4268": {"epss_score": 0.00424, "epss_percentile": 0.61676}, "CVE-2019-4269": {"epss_score": 0.00358, "epss_percentile": 0.57481}, "CVE-2019-4270": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2019-4271": {"epss_score": 0.00174, "epss_percentile": 0.39202}, "CVE-2019-4275": {"epss_score": 0.00043, "epss_percentile": 0.13127}, "CVE-2019-4279": {"epss_score": 0.8408, "epss_percentile": 0.99272}, "CVE-2019-4280": {"epss_score": 0.00076, "epss_percentile": 0.23178}, "CVE-2019-4284": {"epss_score": 0.00044, "epss_percentile": 0.13624}, "CVE-2019-4285": {"epss_score": 0.00026, "epss_percentile": 0.06599}, "CVE-2019-4286": {"epss_score": 0.00054, "epss_percentile": 0.17104}, "CVE-2019-4288": {"epss_score": 0.00054, "epss_percentile": 0.17104}, "CVE-2019-4291": {"epss_score": 0.00064, "epss_percentile": 0.20139}, "CVE-2019-4292": {"epss_score": 0.03539, "epss_percentile": 0.87316}, "CVE-2019-4293": {"epss_score": 0.00202, "epss_percentile": 0.42483}, "CVE-2019-4294": {"epss_score": 0.001, "epss_percentile": 0.28555}, "CVE-2019-4295": {"epss_score": 0.00272, "epss_percentile": 0.50378}, "CVE-2019-4296": {"epss_score": 0.00093, "epss_percentile": 0.2664}, "CVE-2019-4297": {"epss_score": 0.0021, "epss_percentile": 0.43602}, "CVE-2019-4298": {"epss_score": 0.00101, "epss_percentile": 0.28603}, "CVE-2019-4299": {"epss_score": 0.00101, "epss_percentile": 0.28603}, "CVE-2019-4301": {"epss_score": 0.00528, "epss_percentile": 0.66535}, "CVE-2019-4303": {"epss_score": 0.00229, "epss_percentile": 0.45551}, "CVE-2019-4304": {"epss_score": 0.00084, "epss_percentile": 0.24866}, "CVE-2019-4305": {"epss_score": 0.00255, "epss_percentile": 0.48635}, "CVE-2019-4306": {"epss_score": 0.00182, "epss_percentile": 0.40255}, "CVE-2019-4307": {"epss_score": 0.00103, "epss_percentile": 0.29091}, "CVE-2019-4308": {"epss_score": 0.00156, "epss_percentile": 0.3694}, "CVE-2019-4309": {"epss_score": 0.00103, "epss_percentile": 0.29091}, "CVE-2019-4310": {"epss_score": 0.00305, "epss_percentile": 0.53316}, "CVE-2019-4311": {"epss_score": 0.00243, "epss_percentile": 0.47473}, "CVE-2019-4314": {"epss_score": 0.00134, "epss_percentile": 0.33803}, "CVE-2019-4321": {"epss_score": 0.00176, "epss_percentile": 0.39487}, "CVE-2019-4322": {"epss_score": 0.00098, "epss_percentile": 0.277}, "CVE-2019-4323": {"epss_score": 0.0018, "epss_percentile": 0.39874}, "CVE-2019-4324": {"epss_score": 0.00312, "epss_percentile": 0.53995}, "CVE-2019-4325": {"epss_score": 0.00111, "epss_percentile": 0.30267}, "CVE-2019-4326": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-4327": {"epss_score": 0.00408, "epss_percentile": 0.60638}, "CVE-2019-4329": {"epss_score": 0.00141, "epss_percentile": 0.34935}, "CVE-2019-4330": {"epss_score": 0.00284, "epss_percentile": 0.51458}, "CVE-2019-4334": {"epss_score": 0.00281, "epss_percentile": 0.51184}, "CVE-2019-4335": {"epss_score": 0.00088, "epss_percentile": 0.25659}, "CVE-2019-4336": {"epss_score": 0.00633, "epss_percentile": 0.69759}, "CVE-2019-4337": {"epss_score": 0.00213, "epss_percentile": 0.43893}, "CVE-2019-4338": {"epss_score": 0.00447, "epss_percentile": 0.62943}, "CVE-2019-4339": {"epss_score": 0.00146, "epss_percentile": 0.35574}, "CVE-2019-4340": {"epss_score": 0.00421, "epss_percentile": 0.61499}, "CVE-2019-4342": {"epss_score": 0.00229, "epss_percentile": 0.45551}, "CVE-2019-4343": {"epss_score": 0.00286, "epss_percentile": 0.51768}, "CVE-2019-4349": {"epss_score": 0.00049, "epss_percentile": 0.15629}, "CVE-2019-4351": {"epss_score": 0.00051, "epss_percentile": 0.1615}, "CVE-2019-4352": {"epss_score": 0.00051, "epss_percentile": 0.16139}, "CVE-2019-4357": {"epss_score": 0.00108, "epss_percentile": 0.29876}, "CVE-2019-4364": {"epss_score": 0.01296, "epss_percentile": 0.79255}, "CVE-2019-4366": {"epss_score": 0.00124, "epss_percentile": 0.32364}, "CVE-2019-4377": {"epss_score": 0.00224, "epss_percentile": 0.45072}, "CVE-2019-4378": {"epss_score": 0.00103, "epss_percentile": 0.28992}, "CVE-2019-4381": {"epss_score": 0.00052, "epss_percentile": 0.16589}, "CVE-2019-4382": {"epss_score": 0.00338, "epss_percentile": 0.5613}, "CVE-2019-4383": {"epss_score": 0.00064, "epss_percentile": 0.20287}, "CVE-2019-4384": {"epss_score": 0.00361, "epss_percentile": 0.57723}, "CVE-2019-4385": {"epss_score": 0.00067, "epss_percentile": 0.21173}, "CVE-2019-4386": {"epss_score": 0.0031, "epss_percentile": 0.53733}, "CVE-2019-4387": {"epss_score": 0.00339, "epss_percentile": 0.562}, "CVE-2019-4388": {"epss_score": 0.00207, "epss_percentile": 0.43195}, "CVE-2019-4391": {"epss_score": 0.00547, "epss_percentile": 0.67261}, "CVE-2019-4392": {"epss_score": 0.00391, "epss_percentile": 0.59578}, "CVE-2019-4393": {"epss_score": 0.00351, "epss_percentile": 0.57036}, "CVE-2019-4394": {"epss_score": 0.00094, "epss_percentile": 0.2697}, "CVE-2019-4395": {"epss_score": 0.00085, "epss_percentile": 0.25234}, "CVE-2019-4396": {"epss_score": 0.00177, "epss_percentile": 0.39589}, "CVE-2019-4397": {"epss_score": 0.00258, "epss_percentile": 0.4901}, "CVE-2019-4398": {"epss_score": 0.00085, "epss_percentile": 0.25234}, "CVE-2019-4399": {"epss_score": 0.00134, "epss_percentile": 0.33803}, "CVE-2019-4400": {"epss_score": 0.00247, "epss_percentile": 0.47811}, "CVE-2019-4402": {"epss_score": 0.00392, "epss_percentile": 0.59687}, "CVE-2019-4403": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2019-4406": {"epss_score": 0.00103, "epss_percentile": 0.28901}, "CVE-2019-4409": {"epss_score": 0.00322, "epss_percentile": 0.54815}, "CVE-2019-4410": {"epss_score": 0.00229, "epss_percentile": 0.45551}, "CVE-2019-4411": {"epss_score": 0.00222, "epss_percentile": 0.44726}, "CVE-2019-4412": {"epss_score": 0.00284, "epss_percentile": 0.51458}, "CVE-2019-4415": {"epss_score": 0.00046, "epss_percentile": 0.14316}, "CVE-2019-4419": {"epss_score": 0.00425, "epss_percentile": 0.61704}, "CVE-2019-4420": {"epss_score": 0.00052, "epss_percentile": 0.1638}, "CVE-2019-4422": {"epss_score": 0.00498, "epss_percentile": 0.65223}, "CVE-2019-4423": {"epss_score": 0.00343, "epss_percentile": 0.56422}, "CVE-2019-4424": {"epss_score": 0.0037, "epss_percentile": 0.58308}, "CVE-2019-4425": {"epss_score": 0.00262, "epss_percentile": 0.49368}, "CVE-2019-4426": {"epss_score": 0.00453, "epss_percentile": 0.63217}, "CVE-2019-4427": {"epss_score": 0.00078, "epss_percentile": 0.23787}, "CVE-2019-4428": {"epss_score": 0.00186, "epss_percentile": 0.40588}, "CVE-2019-4429": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2019-4430": {"epss_score": 0.00533, "epss_percentile": 0.6676}, "CVE-2019-4431": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2019-4433": {"epss_score": 0.00569, "epss_percentile": 0.67932}, "CVE-2019-4437": {"epss_score": 0.00209, "epss_percentile": 0.43316}, "CVE-2019-4439": {"epss_score": 0.00036, "epss_percentile": 0.10255}, "CVE-2019-4441": {"epss_score": 0.00362, "epss_percentile": 0.57797}, "CVE-2019-4442": {"epss_score": 0.0042, "epss_percentile": 0.61445}, "CVE-2019-4444": {"epss_score": 0.00101, "epss_percentile": 0.28603}, "CVE-2019-4446": {"epss_score": 0.00116, "epss_percentile": 0.31089}, "CVE-2019-4447": {"epss_score": 0.00035, "epss_percentile": 0.10003}, "CVE-2019-4448": {"epss_score": 0.0004, "epss_percentile": 0.12023}, "CVE-2019-4450": {"epss_score": 0.00329, "epss_percentile": 0.55387}, "CVE-2019-4451": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2019-4454": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2019-4456": {"epss_score": 0.00377, "epss_percentile": 0.58713}, "CVE-2019-4457": {"epss_score": 0.00246, "epss_percentile": 0.47776}, "CVE-2019-4459": {"epss_score": 0.00186, "epss_percentile": 0.40588}, "CVE-2019-4460": {"epss_score": 0.00375, "epss_percentile": 0.5862}, "CVE-2019-4461": {"epss_score": 0.00186, "epss_percentile": 0.40588}, "CVE-2019-4465": {"epss_score": 0.00081, "epss_percentile": 0.24232}, "CVE-2019-4467": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2019-4468": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2019-4470": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2019-4471": {"epss_score": 0.00116, "epss_percentile": 0.31135}, "CVE-2019-4473": {"epss_score": 0.00049, "epss_percentile": 0.15491}, "CVE-2019-4477": {"epss_score": 0.00151, "epss_percentile": 0.36346}, "CVE-2019-4478": {"epss_score": 0.00186, "epss_percentile": 0.40683}, "CVE-2019-4481": {"epss_score": 0.00452, "epss_percentile": 0.63174}, "CVE-2019-4482": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2019-4483": {"epss_score": 0.00452, "epss_percentile": 0.63174}, "CVE-2019-4484": {"epss_score": 0.00156, "epss_percentile": 0.36883}, "CVE-2019-4485": {"epss_score": 0.00156, "epss_percentile": 0.36883}, "CVE-2019-4486": {"epss_score": 0.00211, "epss_percentile": 0.43684}, "CVE-2019-4494": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2019-4495": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2019-4497": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2019-4505": {"epss_score": 0.00437, "epss_percentile": 0.62498}, "CVE-2019-4508": {"epss_score": 0.00086, "epss_percentile": 0.25411}, "CVE-2019-4509": {"epss_score": 0.0017, "epss_percentile": 0.38734}, "CVE-2019-4512": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2019-4513": {"epss_score": 0.00427, "epss_percentile": 0.61905}, "CVE-2019-4514": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2019-4515": {"epss_score": 0.0009, "epss_percentile": 0.26068}, "CVE-2019-4520": {"epss_score": 0.00305, "epss_percentile": 0.53316}, "CVE-2019-4521": {"epss_score": 0.0104, "epss_percentile": 0.76953}, "CVE-2019-4523": {"epss_score": 0.00212, "epss_percentile": 0.43774}, "CVE-2019-4530": {"epss_score": 0.00215, "epss_percentile": 0.44042}, "CVE-2019-4533": {"epss_score": 0.00191, "epss_percentile": 0.41177}, "CVE-2019-4536": {"epss_score": 0.0004, "epss_percentile": 0.12154}, "CVE-2019-4537": {"epss_score": 0.0026, "epss_percentile": 0.49234}, "CVE-2019-4538": {"epss_score": 0.00176, "epss_percentile": 0.39428}, "CVE-2019-4539": {"epss_score": 0.00404, "epss_percentile": 0.60447}, "CVE-2019-4540": {"epss_score": 0.00168, "epss_percentile": 0.38421}, "CVE-2019-4541": {"epss_score": 0.00128, "epss_percentile": 0.33068}, "CVE-2019-4542": {"epss_score": 0.00218, "epss_percentile": 0.44354}, "CVE-2019-4545": {"epss_score": 0.0021, "epss_percentile": 0.4359}, "CVE-2019-4546": {"epss_score": 0.00178, "epss_percentile": 0.39721}, "CVE-2019-4547": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2019-4548": {"epss_score": 0.00337, "epss_percentile": 0.56019}, "CVE-2019-4549": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2019-4550": {"epss_score": 0.00299, "epss_percentile": 0.52887}, "CVE-2019-4551": {"epss_score": 0.00255, "epss_percentile": 0.48641}, "CVE-2019-4552": {"epss_score": 0.0015, "epss_percentile": 0.36049}, "CVE-2019-4553": {"epss_score": 0.00146, "epss_percentile": 0.35574}, "CVE-2019-4555": {"epss_score": 0.00345, "epss_percentile": 0.56595}, "CVE-2019-4556": {"epss_score": 0.00173, "epss_percentile": 0.39123}, "CVE-2019-4557": {"epss_score": 0.00134, "epss_percentile": 0.33803}, "CVE-2019-4558": {"epss_score": 0.00177, "epss_percentile": 0.39547}, "CVE-2019-4559": {"epss_score": 0.0026, "epss_percentile": 0.49234}, "CVE-2019-4560": {"epss_score": 0.003, "epss_percentile": 0.52986}, "CVE-2019-4561": {"epss_score": 0.01584, "epss_percentile": 0.81155}, "CVE-2019-4562": {"epss_score": 0.00284, "epss_percentile": 0.51458}, "CVE-2019-4563": {"epss_score": 0.00139, "epss_percentile": 0.34651}, "CVE-2019-4564": {"epss_score": 0.00218, "epss_percentile": 0.44354}, "CVE-2019-4565": {"epss_score": 0.00205, "epss_percentile": 0.42711}, "CVE-2019-4566": {"epss_score": 0.00022, "epss_percentile": 0.04984}, "CVE-2019-4568": {"epss_score": 0.00714, "epss_percentile": 0.7182}, "CVE-2019-4569": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2019-4570": {"epss_score": 0.00284, "epss_percentile": 0.51458}, "CVE-2019-4571": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2019-4572": {"epss_score": 0.00095, "epss_percentile": 0.27086}, "CVE-2019-4575": {"epss_score": 0.00255, "epss_percentile": 0.48703}, "CVE-2019-4576": {"epss_score": 0.00182, "epss_percentile": 0.40189}, "CVE-2019-4579": {"epss_score": 0.00133, "epss_percentile": 0.33692}, "CVE-2019-4581": {"epss_score": 0.00221, "epss_percentile": 0.44691}, "CVE-2019-4582": {"epss_score": 0.00178, "epss_percentile": 0.3969}, "CVE-2019-4583": {"epss_score": 0.00222, "epss_percentile": 0.44726}, "CVE-2019-4588": {"epss_score": 0.00116, "epss_percentile": 0.31098}, "CVE-2019-4589": {"epss_score": 0.00082, "epss_percentile": 0.24579}, "CVE-2019-4591": {"epss_score": 0.00036, "epss_percentile": 0.10322}, "CVE-2019-4592": {"epss_score": 0.00467, "epss_percentile": 0.63836}, "CVE-2019-4593": {"epss_score": 0.00221, "epss_percentile": 0.44684}, "CVE-2019-4594": {"epss_score": 0.00141, "epss_percentile": 0.34807}, "CVE-2019-4595": {"epss_score": 0.0019, "epss_percentile": 0.41058}, "CVE-2019-4596": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2019-4597": {"epss_score": 0.00298, "epss_percentile": 0.52781}, "CVE-2019-4598": {"epss_score": 0.00298, "epss_percentile": 0.52781}, "CVE-2019-4600": {"epss_score": 0.00152, "epss_percentile": 0.36484}, "CVE-2019-4601": {"epss_score": 0.00119, "epss_percentile": 0.31669}, "CVE-2019-4602": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2019-4603": {"epss_score": 0.00102, "epss_percentile": 0.2888}, "CVE-2019-4606": {"epss_score": 0.00169, "epss_percentile": 0.38633}, "CVE-2019-4608": {"epss_score": 0.00211, "epss_percentile": 0.43684}, "CVE-2019-4609": {"epss_score": 0.00134, "epss_percentile": 0.33803}, "CVE-2019-4611": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2019-4612": {"epss_score": 0.00232, "epss_percentile": 0.45933}, "CVE-2019-4613": {"epss_score": 0.00139, "epss_percentile": 0.3454}, "CVE-2019-4614": {"epss_score": 0.00333, "epss_percentile": 0.5563}, "CVE-2019-4616": {"epss_score": 0.0006, "epss_percentile": 0.19137}, "CVE-2019-4617": {"epss_score": 0.0008, "epss_percentile": 0.24146}, "CVE-2019-4619": {"epss_score": 0.00091, "epss_percentile": 0.26237}, "CVE-2019-4620": {"epss_score": 0.00043, "epss_percentile": 0.13068}, "CVE-2019-4621": {"epss_score": 0.00808, "epss_percentile": 0.73691}, "CVE-2019-4623": {"epss_score": 0.00211, "epss_percentile": 0.43684}, "CVE-2019-4631": {"epss_score": 0.00284, "epss_percentile": 0.51496}, "CVE-2019-4632": {"epss_score": 0.00219, "epss_percentile": 0.44444}, "CVE-2019-4633": {"epss_score": 0.00284, "epss_percentile": 0.51458}, "CVE-2019-4635": {"epss_score": 0.01023, "epss_percentile": 0.76766}, "CVE-2019-4636": {"epss_score": 0.00246, "epss_percentile": 0.47776}, "CVE-2019-4637": {"epss_score": 0.00141, "epss_percentile": 0.34935}, "CVE-2019-4638": {"epss_score": 0.00284, "epss_percentile": 0.51458}, "CVE-2019-4639": {"epss_score": 0.00134, "epss_percentile": 0.33803}, "CVE-2019-4640": {"epss_score": 0.00116, "epss_percentile": 0.3117}, "CVE-2019-4644": {"epss_score": 0.00166, "epss_percentile": 0.38177}, "CVE-2019-4645": {"epss_score": 0.00329, "epss_percentile": 0.55387}, "CVE-2019-4650": {"epss_score": 0.00572, "epss_percentile": 0.68023}, "CVE-2019-4651": {"epss_score": 0.00264, "epss_percentile": 0.49572}, "CVE-2019-4652": {"epss_score": 0.0006, "epss_percentile": 0.1902}, "CVE-2019-4653": {"epss_score": 0.003, "epss_percentile": 0.52935}, "CVE-2019-4654": {"epss_score": 0.0012, "epss_percentile": 0.31789}, "CVE-2019-4655": {"epss_score": 0.0023, "epss_percentile": 0.45717}, "CVE-2019-4656": {"epss_score": 0.00334, "epss_percentile": 0.55683}, "CVE-2019-4663": {"epss_score": 0.00218, "epss_percentile": 0.44438}, "CVE-2019-4665": {"epss_score": 0.00186, "epss_percentile": 0.40588}, "CVE-2019-4666": {"epss_score": 0.00124, "epss_percentile": 0.32342}, "CVE-2019-4667": {"epss_score": 0.00106, "epss_percentile": 0.29558}, "CVE-2019-4668": {"epss_score": 0.00038, "epss_percentile": 0.11077}, "CVE-2019-4669": {"epss_score": 0.00265, "epss_percentile": 0.49773}, "CVE-2019-4670": {"epss_score": 0.00244, "epss_percentile": 0.47526}, "CVE-2019-4671": {"epss_score": 0.00148, "epss_percentile": 0.35925}, "CVE-2019-4672": {"epss_score": 0.00152, "epss_percentile": 0.36484}, "CVE-2019-4674": {"epss_score": 0.00251, "epss_percentile": 0.48308}, "CVE-2019-4675": {"epss_score": 0.00111, "epss_percentile": 0.30372}, "CVE-2019-4676": {"epss_score": 0.00089, "epss_percentile": 0.25885}, "CVE-2019-4679": {"epss_score": 0.00222, "epss_percentile": 0.44726}, "CVE-2019-4680": {"epss_score": 0.00456, "epss_percentile": 0.63349}, "CVE-2019-4681": {"epss_score": 0.00251, "epss_percentile": 0.48277}, "CVE-2019-4686": {"epss_score": 0.00041, "epss_percentile": 0.12328}, "CVE-2019-4687": {"epss_score": 0.00056, "epss_percentile": 0.17691}, "CVE-2019-4688": {"epss_score": 0.00088, "epss_percentile": 0.25643}, "CVE-2019-4689": {"epss_score": 0.00057, "epss_percentile": 0.18178}, "CVE-2019-4691": {"epss_score": 0.00062, "epss_percentile": 0.1956}, "CVE-2019-4692": {"epss_score": 0.00075, "epss_percentile": 0.23057}, "CVE-2019-4693": {"epss_score": 0.00019, "epss_percentile": 0.04354}, "CVE-2019-4694": {"epss_score": 0.00058, "epss_percentile": 0.18293}, "CVE-2019-4695": {"epss_score": 0.00024, "epss_percentile": 0.059}, "CVE-2019-4697": {"epss_score": 0.00079, "epss_percentile": 0.2394}, "CVE-2019-4698": {"epss_score": 0.0011, "epss_percentile": 0.30189}, "CVE-2019-4699": {"epss_score": 0.00076, "epss_percentile": 0.23105}, "CVE-2019-4701": {"epss_score": 0.00075, "epss_percentile": 0.23057}, "CVE-2019-4702": {"epss_score": 0.00057, "epss_percentile": 0.1814}, "CVE-2019-4703": {"epss_score": 0.00138, "epss_percentile": 0.34347}, "CVE-2019-4704": {"epss_score": 0.00076, "epss_percentile": 0.23178}, "CVE-2019-4705": {"epss_score": 0.00141, "epss_percentile": 0.34836}, "CVE-2019-4706": {"epss_score": 0.00141, "epss_percentile": 0.34836}, "CVE-2019-4707": {"epss_score": 0.00604, "epss_percentile": 0.68956}, "CVE-2019-4713": {"epss_score": 0.0677, "epss_percentile": 0.91013}, "CVE-2019-4715": {"epss_score": 0.05054, "epss_percentile": 0.89445}, "CVE-2019-4716": {"epss_score": 0.91546, "epss_percentile": 0.99651}, "CVE-2019-4718": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2019-4719": {"epss_score": 0.00091, "epss_percentile": 0.26237}, "CVE-2019-4720": {"epss_score": 0.00504, "epss_percentile": 0.65522}, "CVE-2019-4722": {"epss_score": 0.00162, "epss_percentile": 0.37755}, "CVE-2019-4723": {"epss_score": 0.00355, "epss_percentile": 0.57311}, "CVE-2019-4724": {"epss_score": 0.00355, "epss_percentile": 0.57311}, "CVE-2019-4725": {"epss_score": 0.00188, "epss_percentile": 0.40866}, "CVE-2019-4726": {"epss_score": 0.00129, "epss_percentile": 0.33101}, "CVE-2019-4728": {"epss_score": 0.1634, "epss_percentile": 0.94632}, "CVE-2019-4729": {"epss_score": 0.0013, "epss_percentile": 0.33341}, "CVE-2019-4730": {"epss_score": 0.0059, "epss_percentile": 0.68572}, "CVE-2019-4731": {"epss_score": 0.0004, "epss_percentile": 0.11952}, "CVE-2019-4732": {"epss_score": 0.00164, "epss_percentile": 0.37997}, "CVE-2019-4735": {"epss_score": 0.00054, "epss_percentile": 0.17109}, "CVE-2019-4736": {"epss_score": 0.00129, "epss_percentile": 0.33101}, "CVE-2019-4737": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2019-4738": {"epss_score": 0.00076, "epss_percentile": 0.23091}, "CVE-2019-4740": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2019-4741": {"epss_score": 0.00319, "epss_percentile": 0.54495}, "CVE-2019-4742": {"epss_score": 0.00217, "epss_percentile": 0.44316}, "CVE-2019-4743": {"epss_score": 0.00133, "epss_percentile": 0.33639}, "CVE-2019-4744": {"epss_score": 0.00288, "epss_percentile": 0.51926}, "CVE-2019-4745": {"epss_score": 0.00179, "epss_percentile": 0.39812}, "CVE-2019-4746": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2019-4747": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2019-4748": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2019-4749": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2019-4750": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2019-4751": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2019-4752": {"epss_score": 0.00618, "epss_percentile": 0.6938}, "CVE-2019-4762": {"epss_score": 0.00364, "epss_percentile": 0.57912}, "CVE-2019-5005": {"epss_score": 0.0008, "epss_percentile": 0.24148}, "CVE-2019-5006": {"epss_score": 0.0008, "epss_percentile": 0.24148}, "CVE-2019-5007": {"epss_score": 0.00141, "epss_percentile": 0.34862}, "CVE-2019-5008": {"epss_score": 0.01233, "epss_percentile": 0.78745}, "CVE-2019-5009": {"epss_score": 0.17219, "epss_percentile": 0.94801}, "CVE-2019-5010": {"epss_score": 0.0601, "epss_percentile": 0.90408}, "CVE-2019-5011": {"epss_score": 0.00048, "epss_percentile": 0.15148}, "CVE-2019-5012": {"epss_score": 0.00135, "epss_percentile": 0.33935}, "CVE-2019-5013": {"epss_score": 0.00135, "epss_percentile": 0.33935}, "CVE-2019-5014": {"epss_score": 0.0009, "epss_percentile": 0.26042}, "CVE-2019-5015": {"epss_score": 0.00047, "epss_percentile": 0.14784}, "CVE-2019-5016": {"epss_score": 0.02264, "epss_percentile": 0.84195}, "CVE-2019-5017": {"epss_score": 0.00379, "epss_percentile": 0.58851}, "CVE-2019-5018": {"epss_score": 0.02988, "epss_percentile": 0.86137}, "CVE-2019-5019": {"epss_score": 0.00909, "epss_percentile": 0.75315}, "CVE-2019-5020": {"epss_score": 0.00286, "epss_percentile": 0.51783}, "CVE-2019-5021": {"epss_score": 0.0371, "epss_percentile": 0.87606}, "CVE-2019-5023": {"epss_score": 0.00286, "epss_percentile": 0.51783}, "CVE-2019-5024": {"epss_score": 0.00049, "epss_percentile": 0.15329}, "CVE-2019-5029": {"epss_score": 0.80351, "epss_percentile": 0.99083}, "CVE-2019-5030": {"epss_score": 0.00756, "epss_percentile": 0.72735}, "CVE-2019-5031": {"epss_score": 0.01021, "epss_percentile": 0.76754}, "CVE-2019-5032": {"epss_score": 0.01151, "epss_percentile": 0.78037}, "CVE-2019-5033": {"epss_score": 0.01151, "epss_percentile": 0.78037}, "CVE-2019-5034": {"epss_score": 0.00089, "epss_percentile": 0.25834}, "CVE-2019-5035": {"epss_score": 0.00086, "epss_percentile": 0.2533}, "CVE-2019-5036": {"epss_score": 0.00029, "epss_percentile": 0.07669}, "CVE-2019-5037": {"epss_score": 0.00059, "epss_percentile": 0.18731}, "CVE-2019-5038": {"epss_score": 0.01052, "epss_percentile": 0.77094}, "CVE-2019-5039": {"epss_score": 0.00665, "epss_percentile": 0.7067}, "CVE-2019-5040": {"epss_score": 0.00121, "epss_percentile": 0.31834}, "CVE-2019-5041": {"epss_score": 0.02118, "epss_percentile": 0.83668}, "CVE-2019-5042": {"epss_score": 0.00573, "epss_percentile": 0.68066}, "CVE-2019-5043": {"epss_score": 0.00198, "epss_percentile": 0.42064}, "CVE-2019-5045": {"epss_score": 0.00051, "epss_percentile": 0.16118}, "CVE-2019-5046": {"epss_score": 0.00051, "epss_percentile": 0.16118}, "CVE-2019-5047": {"epss_score": 0.00012, "epss_percentile": 0.01136}, "CVE-2019-5048": {"epss_score": 0.00181, "epss_percentile": 0.4011}, "CVE-2019-5049": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2019-5050": {"epss_score": 0.0015, "epss_percentile": 0.36136}, "CVE-2019-5051": {"epss_score": 0.01593, "epss_percentile": 0.81227}, "CVE-2019-5052": {"epss_score": 0.01424, "epss_percentile": 0.8019}, "CVE-2019-5053": {"epss_score": 0.00012, "epss_percentile": 0.01136}, "CVE-2019-5054": {"epss_score": 0.11209, "epss_percentile": 0.93265}, "CVE-2019-5055": {"epss_score": 0.01706, "epss_percentile": 0.81856}, "CVE-2019-5057": {"epss_score": 0.00987, "epss_percentile": 0.76342}, "CVE-2019-5058": {"epss_score": 0.00987, "epss_percentile": 0.76342}, "CVE-2019-5059": {"epss_score": 0.00987, "epss_percentile": 0.76342}, "CVE-2019-5060": {"epss_score": 0.01344, "epss_percentile": 0.79619}, "CVE-2019-5061": {"epss_score": 0.00302, "epss_percentile": 0.5313}, "CVE-2019-5062": {"epss_score": 0.00093, "epss_percentile": 0.26671}, "CVE-2019-5063": {"epss_score": 0.05482, "epss_percentile": 0.8992}, "CVE-2019-5064": {"epss_score": 0.02639, "epss_percentile": 0.85298}, "CVE-2019-5065": {"epss_score": 0.00123, "epss_percentile": 0.32233}, "CVE-2019-5066": {"epss_score": 0.00619, "epss_percentile": 0.69426}, "CVE-2019-5067": {"epss_score": 0.01236, "epss_percentile": 0.78773}, "CVE-2019-5068": {"epss_score": 0.00075, "epss_percentile": 0.22941}, "CVE-2019-5069": {"epss_score": 0.0061, "epss_percentile": 0.69162}, "CVE-2019-5070": {"epss_score": 0.00283, "epss_percentile": 0.5141}, "CVE-2019-5071": {"epss_score": 0.00435, "epss_percentile": 0.62342}, "CVE-2019-5072": {"epss_score": 0.0059, "epss_percentile": 0.68562}, "CVE-2019-5073": {"epss_score": 0.00729, "epss_percentile": 0.72128}, "CVE-2019-5074": {"epss_score": 0.01016, "epss_percentile": 0.76669}, "CVE-2019-5075": {"epss_score": 0.00962, "epss_percentile": 0.75989}, "CVE-2019-5076": {"epss_score": 0.02248, "epss_percentile": 0.84139}, "CVE-2019-5077": {"epss_score": 0.006, "epss_percentile": 0.68821}, "CVE-2019-5078": {"epss_score": 0.00666, "epss_percentile": 0.70691}, "CVE-2019-5079": {"epss_score": 0.01081, "epss_percentile": 0.77379}, "CVE-2019-5080": {"epss_score": 0.00583, "epss_percentile": 0.68345}, "CVE-2019-5081": {"epss_score": 0.01861, "epss_percentile": 0.82591}, "CVE-2019-5082": {"epss_score": 0.01075, "epss_percentile": 0.77314}, "CVE-2019-5083": {"epss_score": 0.02248, "epss_percentile": 0.84139}, "CVE-2019-5084": {"epss_score": 0.00335, "epss_percentile": 0.55851}, "CVE-2019-5085": {"epss_score": 0.00385, "epss_percentile": 0.59227}, "CVE-2019-5086": {"epss_score": 0.00203, "epss_percentile": 0.42496}, "CVE-2019-5087": {"epss_score": 0.00185, "epss_percentile": 0.40546}, "CVE-2019-5088": {"epss_score": 0.00335, "epss_percentile": 0.55851}, "CVE-2019-5089": {"epss_score": 0.00335, "epss_percentile": 0.55851}, "CVE-2019-5090": {"epss_score": 0.00311, "epss_percentile": 0.53845}, "CVE-2019-5091": {"epss_score": 0.00363, "epss_percentile": 0.57903}, "CVE-2019-5092": {"epss_score": 0.00539, "epss_percentile": 0.66977}, "CVE-2019-5093": {"epss_score": 0.00298, "epss_percentile": 0.52836}, "CVE-2019-5094": {"epss_score": 0.00313, "epss_percentile": 0.54028}, "CVE-2019-5095": {"epss_score": 0.00393, "epss_percentile": 0.59735}, "CVE-2019-5096": {"epss_score": 0.77407, "epss_percentile": 0.98935}, "CVE-2019-5097": {"epss_score": 0.01141, "epss_percentile": 0.77967}, "CVE-2019-5098": {"epss_score": 0.0057, "epss_percentile": 0.67954}, "CVE-2019-5099": {"epss_score": 0.00335, "epss_percentile": 0.55851}, "CVE-2019-5100": {"epss_score": 0.00335, "epss_percentile": 0.55851}, "CVE-2019-5101": {"epss_score": 0.00215, "epss_percentile": 0.44063}, "CVE-2019-5102": {"epss_score": 0.00215, "epss_percentile": 0.44063}, "CVE-2019-5105": {"epss_score": 0.00339, "epss_percentile": 0.56185}, "CVE-2019-5106": {"epss_score": 0.00063, "epss_percentile": 0.19938}, "CVE-2019-5107": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2019-5108": {"epss_score": 0.00676, "epss_percentile": 0.70934}, "CVE-2019-5109": {"epss_score": 0.0049, "epss_percentile": 0.64927}, "CVE-2019-5110": {"epss_score": 0.0049, "epss_percentile": 0.64927}, "CVE-2019-5111": {"epss_score": 0.0049, "epss_percentile": 0.64927}, "CVE-2019-5112": {"epss_score": 0.00507, "epss_percentile": 0.65649}, "CVE-2019-5114": {"epss_score": 0.00557, "epss_percentile": 0.67536}, "CVE-2019-5116": {"epss_score": 0.0049, "epss_percentile": 0.64927}, "CVE-2019-5117": {"epss_score": 0.0049, "epss_percentile": 0.64927}, "CVE-2019-5119": {"epss_score": 0.00453, "epss_percentile": 0.63231}, "CVE-2019-5120": {"epss_score": 0.00507, "epss_percentile": 0.65649}, "CVE-2019-5121": {"epss_score": 0.0049, "epss_percentile": 0.64927}, "CVE-2019-5122": {"epss_score": 0.0049, "epss_percentile": 0.64927}, "CVE-2019-5123": {"epss_score": 0.00285, "epss_percentile": 0.51639}, "CVE-2019-5124": {"epss_score": 0.00446, "epss_percentile": 0.629}, "CVE-2019-5125": {"epss_score": 0.00526, "epss_percentile": 0.66427}, "CVE-2019-5126": {"epss_score": 0.04604, "epss_percentile": 0.88906}, "CVE-2019-5127": {"epss_score": 0.93982, "epss_percentile": 0.99879}, "CVE-2019-5128": {"epss_score": 0.92845, "epss_percentile": 0.99754}, "CVE-2019-5129": {"epss_score": 0.9306, "epss_percentile": 0.99773}, "CVE-2019-5130": {"epss_score": 0.03867, "epss_percentile": 0.87873}, "CVE-2019-5131": {"epss_score": 0.08485, "epss_percentile": 0.92076}, "CVE-2019-5132": {"epss_score": 0.02248, "epss_percentile": 0.84139}, "CVE-2019-5133": {"epss_score": 0.01713, "epss_percentile": 0.81888}, "CVE-2019-5134": {"epss_score": 0.00284, "epss_percentile": 0.51419}, "CVE-2019-5135": {"epss_score": 0.00164, "epss_percentile": 0.38007}, "CVE-2019-5136": {"epss_score": 0.00524, "epss_percentile": 0.66333}, "CVE-2019-5137": {"epss_score": 0.0048, "epss_percentile": 0.64475}, "CVE-2019-5138": {"epss_score": 0.03705, "epss_percentile": 0.87597}, "CVE-2019-5139": {"epss_score": 0.0013, "epss_percentile": 0.33323}, "CVE-2019-5140": {"epss_score": 0.01978, "epss_percentile": 0.83129}, "CVE-2019-5141": {"epss_score": 0.0575, "epss_percentile": 0.90178}, "CVE-2019-5142": {"epss_score": 0.0221, "epss_percentile": 0.84012}, "CVE-2019-5143": {"epss_score": 0.03064, "epss_percentile": 0.86321}, "CVE-2019-5144": {"epss_score": 0.0319, "epss_percentile": 0.866}, "CVE-2019-5145": {"epss_score": 0.08485, "epss_percentile": 0.92076}, "CVE-2019-5146": {"epss_score": 0.00446, "epss_percentile": 0.629}, "CVE-2019-5147": {"epss_score": 0.00446, "epss_percentile": 0.629}, "CVE-2019-5148": {"epss_score": 0.00507, "epss_percentile": 0.65646}, "CVE-2019-5149": {"epss_score": 0.00436, "epss_percentile": 0.62451}, "CVE-2019-5150": {"epss_score": 0.00371, "epss_percentile": 0.58354}, "CVE-2019-5151": {"epss_score": 0.00371, "epss_percentile": 0.58354}, "CVE-2019-5152": {"epss_score": 0.00339, "epss_percentile": 0.56184}, "CVE-2019-5153": {"epss_score": 0.02274, "epss_percentile": 0.84224}, "CVE-2019-5154": {"epss_score": 0.00891, "epss_percentile": 0.75055}, "CVE-2019-5155": {"epss_score": 0.02459, "epss_percentile": 0.84818}, "CVE-2019-5156": {"epss_score": 0.02855, "epss_percentile": 0.85835}, "CVE-2019-5157": {"epss_score": 0.02855, "epss_percentile": 0.85835}, "CVE-2019-5158": {"epss_score": 0.00256, "epss_percentile": 0.48829}, "CVE-2019-5159": {"epss_score": 0.00335, "epss_percentile": 0.55851}, "CVE-2019-5160": {"epss_score": 0.02165, "epss_percentile": 0.83845}, "CVE-2019-5161": {"epss_score": 0.04926, "epss_percentile": 0.89294}, "CVE-2019-5162": {"epss_score": 0.00524, "epss_percentile": 0.66333}, "CVE-2019-5163": {"epss_score": 0.00486, "epss_percentile": 0.64741}, "CVE-2019-5164": {"epss_score": 0.00429, "epss_percentile": 0.61981}, "CVE-2019-5165": {"epss_score": 0.00146, "epss_percentile": 0.35555}, "CVE-2019-5166": {"epss_score": 0.00053, "epss_percentile": 0.16977}, "CVE-2019-5167": {"epss_score": 0.00578, "epss_percentile": 0.68203}, "CVE-2019-5168": {"epss_score": 0.00469, "epss_percentile": 0.63946}, "CVE-2019-5169": {"epss_score": 0.00314, "epss_percentile": 0.5408}, "CVE-2019-5170": {"epss_score": 0.0035, "epss_percentile": 0.56927}, "CVE-2019-5171": {"epss_score": 0.00228, "epss_percentile": 0.45479}, "CVE-2019-5172": {"epss_score": 0.00269, "epss_percentile": 0.50153}, "CVE-2019-5173": {"epss_score": 0.0035, "epss_percentile": 0.56927}, "CVE-2019-5174": {"epss_score": 0.0035, "epss_percentile": 0.56927}, "CVE-2019-5175": {"epss_score": 0.0035, "epss_percentile": 0.56927}, "CVE-2019-5176": {"epss_score": 0.00066, "epss_percentile": 0.20689}, "CVE-2019-5177": {"epss_score": 0.00171, "epss_percentile": 0.38868}, "CVE-2019-5178": {"epss_score": 0.00066, "epss_percentile": 0.20689}, "CVE-2019-5179": {"epss_score": 0.00066, "epss_percentile": 0.20689}, "CVE-2019-5180": {"epss_score": 0.00066, "epss_percentile": 0.20689}, "CVE-2019-5181": {"epss_score": 0.00066, "epss_percentile": 0.20879}, "CVE-2019-5182": {"epss_score": 0.00066, "epss_percentile": 0.20689}, "CVE-2019-5183": {"epss_score": 0.00482, "epss_percentile": 0.64526}, "CVE-2019-5184": {"epss_score": 0.00054, "epss_percentile": 0.17319}, "CVE-2019-5185": {"epss_score": 0.00053, "epss_percentile": 0.16824}, "CVE-2019-5186": {"epss_score": 0.00053, "epss_percentile": 0.16824}, "CVE-2019-5187": {"epss_score": 0.02248, "epss_percentile": 0.84139}, "CVE-2019-5188": {"epss_score": 0.0004, "epss_percentile": 0.1217}, "CVE-2019-5210": {"epss_score": 0.00061, "epss_percentile": 0.19391}, "CVE-2019-5211": {"epss_score": 0.00081, "epss_percentile": 0.24238}, "CVE-2019-5212": {"epss_score": 0.0012, "epss_percentile": 0.31741}, "CVE-2019-5213": {"epss_score": 0.00051, "epss_percentile": 0.16053}, "CVE-2019-5214": {"epss_score": 0.00077, "epss_percentile": 0.23533}, "CVE-2019-5215": {"epss_score": 0.00037, "epss_percentile": 0.10681}, "CVE-2019-5216": {"epss_score": 0.00084, "epss_percentile": 0.24887}, "CVE-2019-5217": {"epss_score": 0.00028, "epss_percentile": 0.07343}, "CVE-2019-5218": {"epss_score": 0.00102, "epss_percentile": 0.2883}, "CVE-2019-5219": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2019-5220": {"epss_score": 0.00024, "epss_percentile": 0.06005}, "CVE-2019-5221": {"epss_score": 0.00045, "epss_percentile": 0.13782}, "CVE-2019-5222": {"epss_score": 0.0009, "epss_percentile": 0.26162}, "CVE-2019-5223": {"epss_score": 0.00259, "epss_percentile": 0.49041}, "CVE-2019-5224": {"epss_score": 0.0014, "epss_percentile": 0.34757}, "CVE-2019-5225": {"epss_score": 0.00396, "epss_percentile": 0.59853}, "CVE-2019-5226": {"epss_score": 0.00058, "epss_percentile": 0.18605}, "CVE-2019-5227": {"epss_score": 0.00058, "epss_percentile": 0.18605}, "CVE-2019-5228": {"epss_score": 0.00117, "epss_percentile": 0.31212}, "CVE-2019-5229": {"epss_score": 0.00024, "epss_percentile": 0.05994}, "CVE-2019-5230": {"epss_score": 0.00125, "epss_percentile": 0.32475}, "CVE-2019-5231": {"epss_score": 0.00055, "epss_percentile": 0.17463}, "CVE-2019-5232": {"epss_score": 0.00397, "epss_percentile": 0.60041}, "CVE-2019-5233": {"epss_score": 0.00174, "epss_percentile": 0.39152}, "CVE-2019-5235": {"epss_score": 0.00247, "epss_percentile": 0.47832}, "CVE-2019-5236": {"epss_score": 0.00133, "epss_percentile": 0.33658}, "CVE-2019-5237": {"epss_score": 0.00196, "epss_percentile": 0.41714}, "CVE-2019-5238": {"epss_score": 0.00196, "epss_percentile": 0.41714}, "CVE-2019-5239": {"epss_score": 0.00106, "epss_percentile": 0.29423}, "CVE-2019-5241": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2019-5242": {"epss_score": 0.00108, "epss_percentile": 0.29869}, "CVE-2019-5243": {"epss_score": 0.00096, "epss_percentile": 0.2744}, "CVE-2019-5244": {"epss_score": 0.00106, "epss_percentile": 0.29423}, "CVE-2019-5245": {"epss_score": 0.00054, "epss_percentile": 0.17231}, "CVE-2019-5246": {"epss_score": 0.00024, "epss_percentile": 0.05994}, "CVE-2019-5247": {"epss_score": 0.00073, "epss_percentile": 0.22643}, "CVE-2019-5248": {"epss_score": 0.00117, "epss_percentile": 0.31285}, "CVE-2019-5250": {"epss_score": 0.00054, "epss_percentile": 0.17255}, "CVE-2019-5251": {"epss_score": 0.00131, "epss_percentile": 0.33406}, "CVE-2019-5252": {"epss_score": 0.0005, "epss_percentile": 0.15861}, "CVE-2019-5253": {"epss_score": 0.00193, "epss_percentile": 0.41498}, "CVE-2019-5254": {"epss_score": 0.00251, "epss_percentile": 0.48296}, "CVE-2019-5255": {"epss_score": 0.00057, "epss_percentile": 0.18174}, "CVE-2019-5256": {"epss_score": 0.00057, "epss_percentile": 0.18174}, "CVE-2019-5257": {"epss_score": 0.00057, "epss_percentile": 0.18174}, "CVE-2019-5258": {"epss_score": 0.00073, "epss_percentile": 0.22643}, "CVE-2019-5259": {"epss_score": 0.0011, "epss_percentile": 0.30086}, "CVE-2019-5260": {"epss_score": 0.00151, "epss_percentile": 0.36318}, "CVE-2019-5263": {"epss_score": 0.00052, "epss_percentile": 0.16379}, "CVE-2019-5264": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2019-5265": {"epss_score": 0.00187, "epss_percentile": 0.40724}, "CVE-2019-5266": {"epss_score": 0.00163, "epss_percentile": 0.37808}, "CVE-2019-5267": {"epss_score": 0.0006, "epss_percentile": 0.19175}, "CVE-2019-5268": {"epss_score": 0.00079, "epss_percentile": 0.23894}, "CVE-2019-5269": {"epss_score": 0.00064, "epss_percentile": 0.20363}, "CVE-2019-5271": {"epss_score": 0.00077, "epss_percentile": 0.23386}, "CVE-2019-5272": {"epss_score": 0.00067, "epss_percentile": 0.21021}, "CVE-2019-5273": {"epss_score": 0.00183, "epss_percentile": 0.40352}, "CVE-2019-5274": {"epss_score": 0.00137, "epss_percentile": 0.34233}, "CVE-2019-5275": {"epss_score": 0.00258, "epss_percentile": 0.48957}, "CVE-2019-5276": {"epss_score": 0.00153, "epss_percentile": 0.36556}, "CVE-2019-5277": {"epss_score": 0.00187, "epss_percentile": 0.40724}, "CVE-2019-5278": {"epss_score": 0.0024, "epss_percentile": 0.47221}, "CVE-2019-5279": {"epss_score": 0.0014, "epss_percentile": 0.34757}, "CVE-2019-5280": {"epss_score": 0.0008, "epss_percentile": 0.24045}, "CVE-2019-5281": {"epss_score": 0.00026, "epss_percentile": 0.06662}, "CVE-2019-5282": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2019-5283": {"epss_score": 0.00027, "epss_percentile": 0.07001}, "CVE-2019-5284": {"epss_score": 0.0017, "epss_percentile": 0.38648}, "CVE-2019-5285": {"epss_score": 0.00167, "epss_percentile": 0.38314}, "CVE-2019-5286": {"epss_score": 0.00126, "epss_percentile": 0.32622}, "CVE-2019-5287": {"epss_score": 0.00142, "epss_percentile": 0.34973}, "CVE-2019-5288": {"epss_score": 0.00142, "epss_percentile": 0.34973}, "CVE-2019-5289": {"epss_score": 0.00251, "epss_percentile": 0.48296}, "CVE-2019-5290": {"epss_score": 0.00212, "epss_percentile": 0.43751}, "CVE-2019-5291": {"epss_score": 0.00221, "epss_percentile": 0.44695}, "CVE-2019-5292": {"epss_score": 0.00055, "epss_percentile": 0.1765}, "CVE-2019-5293": {"epss_score": 0.00385, "epss_percentile": 0.59206}, "CVE-2019-5294": {"epss_score": 0.00453, "epss_percentile": 0.63234}, "CVE-2019-5295": {"epss_score": 0.00028, "epss_percentile": 0.0757}, "CVE-2019-5296": {"epss_score": 0.00022, "epss_percentile": 0.05027}, "CVE-2019-5297": {"epss_score": 0.00027, "epss_percentile": 0.07001}, "CVE-2019-5298": {"epss_score": 0.0003, "epss_percentile": 0.08067}, "CVE-2019-5299": {"epss_score": 0.0008, "epss_percentile": 0.24147}, "CVE-2019-5300": {"epss_score": 0.00011, "epss_percentile": 0.0103}, "CVE-2019-5301": {"epss_score": 0.00089, "epss_percentile": 0.25873}, "CVE-2019-5302": {"epss_score": 0.00064, "epss_percentile": 0.20423}, "CVE-2019-5303": {"epss_score": 0.00064, "epss_percentile": 0.20423}, "CVE-2019-5304": {"epss_score": 0.0024, "epss_percentile": 0.4719}, "CVE-2019-5305": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2019-5306": {"epss_score": 0.00027, "epss_percentile": 0.07001}, "CVE-2019-5307": {"epss_score": 0.0003, "epss_percentile": 0.08311}, "CVE-2019-5308": {"epss_score": 0.00061, "epss_percentile": 0.19505}, "CVE-2019-5309": {"epss_score": 0.0006, "epss_percentile": 0.19094}, "CVE-2019-5310": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-5311": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-5312": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2019-5314": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2019-5315": {"epss_score": 0.01457, "epss_percentile": 0.80397}, "CVE-2019-5317": {"epss_score": 0.00056, "epss_percentile": 0.17918}, "CVE-2019-5318": {"epss_score": 0.00155, "epss_percentile": 0.36805}, "CVE-2019-5319": {"epss_score": 0.01729, "epss_percentile": 0.81977}, "CVE-2019-5320": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2019-5321": {"epss_score": 0.00453, "epss_percentile": 0.63231}, "CVE-2019-5322": {"epss_score": 0.00372, "epss_percentile": 0.58446}, "CVE-2019-5323": {"epss_score": 0.01117, "epss_percentile": 0.77724}, "CVE-2019-5326": {"epss_score": 0.02541, "epss_percentile": 0.8505}, "CVE-2019-5338": {"epss_score": 0.01738, "epss_percentile": 0.82025}, "CVE-2019-5339": {"epss_score": 0.01738, "epss_percentile": 0.82025}, "CVE-2019-5340": {"epss_score": 0.01738, "epss_percentile": 0.82025}, "CVE-2019-5341": {"epss_score": 0.01738, "epss_percentile": 0.82025}, "CVE-2019-5342": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5343": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5344": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5345": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5346": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5347": {"epss_score": 0.20926, "epss_percentile": 0.95444}, "CVE-2019-5348": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5349": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5350": {"epss_score": 0.32372, "epss_percentile": 0.96693}, "CVE-2019-5351": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5352": {"epss_score": 0.1903, "epss_percentile": 0.95115}, "CVE-2019-5353": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5354": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5355": {"epss_score": 0.07047, "epss_percentile": 0.9121}, "CVE-2019-5356": {"epss_score": 0.19723, "epss_percentile": 0.95232}, "CVE-2019-5357": {"epss_score": 0.01738, "epss_percentile": 0.82025}, "CVE-2019-5358": {"epss_score": 0.1903, "epss_percentile": 0.95115}, "CVE-2019-5359": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5360": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5361": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5362": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5363": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5364": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5365": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5366": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5367": {"epss_score": 0.20374, "epss_percentile": 0.95334}, "CVE-2019-5368": {"epss_score": 0.01738, "epss_percentile": 0.82025}, "CVE-2019-5369": {"epss_score": 0.01738, "epss_percentile": 0.82025}, "CVE-2019-5370": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5371": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5372": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5373": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5374": {"epss_score": 0.01738, "epss_percentile": 0.82025}, "CVE-2019-5375": {"epss_score": 0.01738, "epss_percentile": 0.82025}, "CVE-2019-5376": {"epss_score": 0.01738, "epss_percentile": 0.82025}, "CVE-2019-5377": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5378": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5379": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5380": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5381": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5382": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5383": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5384": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5385": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5386": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5387": {"epss_score": 0.1903, "epss_percentile": 0.95115}, "CVE-2019-5388": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5389": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2019-5390": {"epss_score": 0.20354, "epss_percentile": 0.9533}, "CVE-2019-5391": {"epss_score": 0.00987, "epss_percentile": 0.76343}, "CVE-2019-5392": {"epss_score": 0.13088, "epss_percentile": 0.9387}, "CVE-2019-5393": {"epss_score": 0.00572, "epss_percentile": 0.68004}, "CVE-2019-5394": {"epss_score": 0.00046, "epss_percentile": 0.1419}, "CVE-2019-5395": {"epss_score": 0.00423, "epss_percentile": 0.61601}, "CVE-2019-5396": {"epss_score": 0.01288, "epss_percentile": 0.79207}, "CVE-2019-5397": {"epss_score": 0.01284, "epss_percentile": 0.79166}, "CVE-2019-5398": {"epss_score": 0.00265, "epss_percentile": 0.49773}, "CVE-2019-5399": {"epss_score": 0.00646, "epss_percentile": 0.7015}, "CVE-2019-5400": {"epss_score": 0.0022, "epss_percentile": 0.44616}, "CVE-2019-5401": {"epss_score": 0.00308, "epss_percentile": 0.53593}, "CVE-2019-5402": {"epss_score": 0.03184, "epss_percentile": 0.86588}, "CVE-2019-5403": {"epss_score": 0.00272, "epss_percentile": 0.50351}, "CVE-2019-5404": {"epss_score": 0.00475, "epss_percentile": 0.64246}, "CVE-2019-5405": {"epss_score": 0.00296, "epss_percentile": 0.52569}, "CVE-2019-5406": {"epss_score": 0.00249, "epss_percentile": 0.48001}, "CVE-2019-5407": {"epss_score": 0.00242, "epss_percentile": 0.47356}, "CVE-2019-5408": {"epss_score": 0.00546, "epss_percentile": 0.6721}, "CVE-2019-5413": {"epss_score": 0.02026, "epss_percentile": 0.83316}, "CVE-2019-5414": {"epss_score": 0.00514, "epss_percentile": 0.65951}, "CVE-2019-5415": {"epss_score": 0.00318, "epss_percentile": 0.54461}, "CVE-2019-5416": {"epss_score": 0.00611, "epss_percentile": 0.69198}, "CVE-2019-5417": {"epss_score": 0.00611, "epss_percentile": 0.69198}, "CVE-2019-5418": {"epss_score": 0.9434, "epss_percentile": 0.99951}, "CVE-2019-5419": {"epss_score": 0.12492, "epss_percentile": 0.93691}, "CVE-2019-5420": {"epss_score": 0.93272, "epss_percentile": 0.99792}, "CVE-2019-5421": {"epss_score": 0.00229, "epss_percentile": 0.45644}, "CVE-2019-5422": {"epss_score": 0.00266, "epss_percentile": 0.49904}, "CVE-2019-5423": {"epss_score": 0.00607, "epss_percentile": 0.69049}, "CVE-2019-5424": {"epss_score": 0.01862, "epss_percentile": 0.82594}, "CVE-2019-5425": {"epss_score": 0.02184, "epss_percentile": 0.83912}, "CVE-2019-5426": {"epss_score": 0.0042, "epss_percentile": 0.6145}, "CVE-2019-5427": {"epss_score": 0.04135, "epss_percentile": 0.88307}, "CVE-2019-5429": {"epss_score": 0.0031, "epss_percentile": 0.53768}, "CVE-2019-5430": {"epss_score": 0.00187, "epss_percentile": 0.407}, "CVE-2019-5431": {"epss_score": 0.00076, "epss_percentile": 0.23076}, "CVE-2019-5432": {"epss_score": 0.00544, "epss_percentile": 0.67146}, "CVE-2019-5433": {"epss_score": 0.00161, "epss_percentile": 0.37545}, "CVE-2019-5434": {"epss_score": 0.91979, "epss_percentile": 0.99682}, "CVE-2019-5435": {"epss_score": 0.00177, "epss_percentile": 0.39629}, "CVE-2019-5436": {"epss_score": 0.13489, "epss_percentile": 0.9398}, "CVE-2019-5437": {"epss_score": 0.00222, "epss_percentile": 0.44746}, "CVE-2019-5438": {"epss_score": 0.00223, "epss_percentile": 0.44854}, "CVE-2019-5439": {"epss_score": 0.15839, "epss_percentile": 0.94516}, "CVE-2019-5440": {"epss_score": 0.00377, "epss_percentile": 0.58729}, "CVE-2019-5442": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-5443": {"epss_score": 0.00953, "epss_percentile": 0.75892}, "CVE-2019-5444": {"epss_score": 0.00232, "epss_percentile": 0.45898}, "CVE-2019-5445": {"epss_score": 0.00435, "epss_percentile": 0.62355}, "CVE-2019-5446": {"epss_score": 0.00865, "epss_percentile": 0.74625}, "CVE-2019-5447": {"epss_score": 0.00232, "epss_percentile": 0.45898}, "CVE-2019-5448": {"epss_score": 0.00107, "epss_percentile": 0.29723}, "CVE-2019-5449": {"epss_score": 0.003, "epss_percentile": 0.5292}, "CVE-2019-5450": {"epss_score": 0.00136, "epss_percentile": 0.34172}, "CVE-2019-5451": {"epss_score": 0.00069, "epss_percentile": 0.21467}, "CVE-2019-5452": {"epss_score": 0.00055, "epss_percentile": 0.17417}, "CVE-2019-5453": {"epss_score": 0.00051, "epss_percentile": 0.1632}, "CVE-2019-5454": {"epss_score": 0.00499, "epss_percentile": 0.65285}, "CVE-2019-5455": {"epss_score": 0.0005, "epss_percentile": 0.15775}, "CVE-2019-5456": {"epss_score": 0.00361, "epss_percentile": 0.57724}, "CVE-2019-5457": {"epss_score": 0.0014, "epss_percentile": 0.34697}, "CVE-2019-5458": {"epss_score": 0.0014, "epss_percentile": 0.34697}, "CVE-2019-5459": {"epss_score": 0.00944, "epss_percentile": 0.75792}, "CVE-2019-5460": {"epss_score": 0.00659, "epss_percentile": 0.70503}, "CVE-2019-5461": {"epss_score": 0.00083, "epss_percentile": 0.24744}, "CVE-2019-5462": {"epss_score": 0.0045, "epss_percentile": 0.63071}, "CVE-2019-5463": {"epss_score": 0.00169, "epss_percentile": 0.38632}, "CVE-2019-5464": {"epss_score": 0.0043, "epss_percentile": 0.62008}, "CVE-2019-5465": {"epss_score": 0.00476, "epss_percentile": 0.6429}, "CVE-2019-5466": {"epss_score": 0.0034, "epss_percentile": 0.56273}, "CVE-2019-5467": {"epss_score": 0.0007, "epss_percentile": 0.21656}, "CVE-2019-5468": {"epss_score": 0.00666, "epss_percentile": 0.70696}, "CVE-2019-5469": {"epss_score": 0.00101, "epss_percentile": 0.2871}, "CVE-2019-5470": {"epss_score": 0.00269, "epss_percentile": 0.50115}, "CVE-2019-5471": {"epss_score": 0.00069, "epss_percentile": 0.21527}, "CVE-2019-5472": {"epss_score": 0.00244, "epss_percentile": 0.47562}, "CVE-2019-5473": {"epss_score": 0.00193, "epss_percentile": 0.41456}, "CVE-2019-5474": {"epss_score": 0.00166, "epss_percentile": 0.3824}, "CVE-2019-5475": {"epss_score": 0.79317, "epss_percentile": 0.99032}, "CVE-2019-5476": {"epss_score": 0.00868, "epss_percentile": 0.74676}, "CVE-2019-5477": {"epss_score": 0.05874, "epss_percentile": 0.90282}, "CVE-2019-5478": {"epss_score": 0.00024, "epss_percentile": 0.06021}, "CVE-2019-5479": {"epss_score": 0.00175, "epss_percentile": 0.39326}, "CVE-2019-5480": {"epss_score": 0.00315, "epss_percentile": 0.54197}, "CVE-2019-5481": {"epss_score": 0.04691, "epss_percentile": 0.89012}, "CVE-2019-5482": {"epss_score": 0.08332, "epss_percentile": 0.91995}, "CVE-2019-5483": {"epss_score": 0.0045, "epss_percentile": 0.63104}, "CVE-2019-5484": {"epss_score": 0.00503, "epss_percentile": 0.65448}, "CVE-2019-5485": {"epss_score": 0.53857, "epss_percentile": 0.97898}, "CVE-2019-5486": {"epss_score": 0.0004, "epss_percentile": 0.12008}, "CVE-2019-5487": {"epss_score": 0.00347, "epss_percentile": 0.56768}, "CVE-2019-5488": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2019-5489": {"epss_score": 0.00208, "epss_percentile": 0.43227}, "CVE-2019-5490": {"epss_score": 0.01103, "epss_percentile": 0.77593}, "CVE-2019-5491": {"epss_score": 0.00435, "epss_percentile": 0.62333}, "CVE-2019-5492": {"epss_score": 0.00457, "epss_percentile": 0.63395}, "CVE-2019-5493": {"epss_score": 0.00542, "epss_percentile": 0.67072}, "CVE-2019-5494": {"epss_score": 0.00205, "epss_percentile": 0.42682}, "CVE-2019-5495": {"epss_score": 0.00291, "epss_percentile": 0.52156}, "CVE-2019-5496": {"epss_score": 0.00205, "epss_percentile": 0.42682}, "CVE-2019-5497": {"epss_score": 0.00957, "epss_percentile": 0.75935}, "CVE-2019-5498": {"epss_score": 0.00311, "epss_percentile": 0.53844}, "CVE-2019-5500": {"epss_score": 0.00844, "epss_percentile": 0.74279}, "CVE-2019-5501": {"epss_score": 0.0067, "epss_percentile": 0.70772}, "CVE-2019-5502": {"epss_score": 0.00199, "epss_percentile": 0.42104}, "CVE-2019-5503": {"epss_score": 0.00502, "epss_percentile": 0.65402}, "CVE-2019-5504": {"epss_score": 0.01242, "epss_percentile": 0.78823}, "CVE-2019-5505": {"epss_score": 0.00155, "epss_percentile": 0.36811}, "CVE-2019-5506": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2019-5507": {"epss_score": 0.0018, "epss_percentile": 0.3991}, "CVE-2019-5508": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2019-5509": {"epss_score": 0.0155, "epss_percentile": 0.80987}, "CVE-2019-5511": {"epss_score": 0.00042, "epss_percentile": 0.12726}, "CVE-2019-5512": {"epss_score": 0.00887, "epss_percentile": 0.74992}, "CVE-2019-5513": {"epss_score": 0.00306, "epss_percentile": 0.53412}, "CVE-2019-5514": {"epss_score": 0.0172, "epss_percentile": 0.8193}, "CVE-2019-5515": {"epss_score": 0.01009, "epss_percentile": 0.7659}, "CVE-2019-5516": {"epss_score": 0.00425, "epss_percentile": 0.61729}, "CVE-2019-5517": {"epss_score": 0.00401, "epss_percentile": 0.60257}, "CVE-2019-5518": {"epss_score": 0.00291, "epss_percentile": 0.52161}, "CVE-2019-5519": {"epss_score": 0.0018, "epss_percentile": 0.39881}, "CVE-2019-5520": {"epss_score": 0.0023, "epss_percentile": 0.45744}, "CVE-2019-5521": {"epss_score": 0.00418, "epss_percentile": 0.61271}, "CVE-2019-5522": {"epss_score": 0.00122, "epss_percentile": 0.32087}, "CVE-2019-5523": {"epss_score": 0.0068, "epss_percentile": 0.71037}, "CVE-2019-5524": {"epss_score": 0.00782, "epss_percentile": 0.73202}, "CVE-2019-5525": {"epss_score": 0.00101, "epss_percentile": 0.2866}, "CVE-2019-5526": {"epss_score": 0.12886, "epss_percentile": 0.93812}, "CVE-2019-5527": {"epss_score": 0.00034, "epss_percentile": 0.09438}, "CVE-2019-5528": {"epss_score": 0.00478, "epss_percentile": 0.64387}, "CVE-2019-5530": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2019-5531": {"epss_score": 0.00381, "epss_percentile": 0.58985}, "CVE-2019-5532": {"epss_score": 0.00463, "epss_percentile": 0.63698}, "CVE-2019-5533": {"epss_score": 0.01112, "epss_percentile": 0.77676}, "CVE-2019-5534": {"epss_score": 0.0036, "epss_percentile": 0.57625}, "CVE-2019-5535": {"epss_score": 0.00074, "epss_percentile": 0.22801}, "CVE-2019-5536": {"epss_score": 0.00699, "epss_percentile": 0.71434}, "CVE-2019-5537": {"epss_score": 0.00112, "epss_percentile": 0.30457}, "CVE-2019-5538": {"epss_score": 0.00112, "epss_percentile": 0.30457}, "CVE-2019-5539": {"epss_score": 0.00207, "epss_percentile": 0.4312}, "CVE-2019-5540": {"epss_score": 0.00234, "epss_percentile": 0.46088}, "CVE-2019-5541": {"epss_score": 0.00744, "epss_percentile": 0.72507}, "CVE-2019-5542": {"epss_score": 0.00313, "epss_percentile": 0.54017}, "CVE-2019-5543": {"epss_score": 0.00034, "epss_percentile": 0.09528}, "CVE-2019-5544": {"epss_score": 0.92481, "epss_percentile": 0.99718}, "CVE-2019-5585": {"epss_score": 0.00058, "epss_percentile": 0.18359}, "CVE-2019-5586": {"epss_score": 0.00265, "epss_percentile": 0.49838}, "CVE-2019-5587": {"epss_score": 0.00103, "epss_percentile": 0.28984}, "CVE-2019-5588": {"epss_score": 0.00265, "epss_percentile": 0.49838}, "CVE-2019-5589": {"epss_score": 0.00615, "epss_percentile": 0.69296}, "CVE-2019-5590": {"epss_score": 0.00233, "epss_percentile": 0.46065}, "CVE-2019-5591": {"epss_score": 0.49178, "epss_percentile": 0.97672}, "CVE-2019-5592": {"epss_score": 0.00115, "epss_percentile": 0.31028}, "CVE-2019-5593": {"epss_score": 0.00034, "epss_percentile": 0.09798}, "CVE-2019-5594": {"epss_score": 0.00394, "epss_percentile": 0.5976}, "CVE-2019-5595": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2019-5596": {"epss_score": 0.00553, "epss_percentile": 0.67426}, "CVE-2019-5597": {"epss_score": 0.02202, "epss_percentile": 0.83986}, "CVE-2019-5598": {"epss_score": 0.00355, "epss_percentile": 0.57267}, "CVE-2019-5599": {"epss_score": 0.09795, "epss_percentile": 0.92705}, "CVE-2019-5600": {"epss_score": 0.02275, "epss_percentile": 0.84226}, "CVE-2019-5601": {"epss_score": 0.00295, "epss_percentile": 0.52452}, "CVE-2019-5602": {"epss_score": 0.04148, "epss_percentile": 0.88317}, "CVE-2019-5603": {"epss_score": 0.00246, "epss_percentile": 0.47754}, "CVE-2019-5604": {"epss_score": 0.01812, "epss_percentile": 0.82374}, "CVE-2019-5605": {"epss_score": 0.01017, "epss_percentile": 0.76691}, "CVE-2019-5606": {"epss_score": 0.00072, "epss_percentile": 0.22431}, "CVE-2019-5607": {"epss_score": 0.00064, "epss_percentile": 0.20313}, "CVE-2019-5608": {"epss_score": 0.00932, "epss_percentile": 0.75631}, "CVE-2019-5609": {"epss_score": 0.00353, "epss_percentile": 0.57171}, "CVE-2019-5610": {"epss_score": 0.04023, "epss_percentile": 0.88136}, "CVE-2019-5611": {"epss_score": 0.05022, "epss_percentile": 0.89403}, "CVE-2019-5612": {"epss_score": 0.003, "epss_percentile": 0.52947}, "CVE-2019-5613": {"epss_score": 0.00224, "epss_percentile": 0.45017}, "CVE-2019-5614": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2019-5615": {"epss_score": 0.003, "epss_percentile": 0.52992}, "CVE-2019-5616": {"epss_score": 0.00228, "epss_percentile": 0.45474}, "CVE-2019-5617": {"epss_score": 0.01914, "epss_percentile": 0.82851}, "CVE-2019-5618": {"epss_score": 0.55247, "epss_percentile": 0.97967}, "CVE-2019-5619": {"epss_score": 0.65865, "epss_percentile": 0.9844}, "CVE-2019-5620": {"epss_score": 0.79326, "epss_percentile": 0.99033}, "CVE-2019-5621": {"epss_score": 0.55247, "epss_percentile": 0.97967}, "CVE-2019-5622": {"epss_score": 0.0035, "epss_percentile": 0.56975}, "CVE-2019-5623": {"epss_score": 0.01334, "epss_percentile": 0.79538}, "CVE-2019-5624": {"epss_score": 0.07747, "epss_percentile": 0.91657}, "CVE-2019-5625": {"epss_score": 0.00081, "epss_percentile": 0.2423}, "CVE-2019-5626": {"epss_score": 0.00058, "epss_percentile": 0.18537}, "CVE-2019-5627": {"epss_score": 0.00057, "epss_percentile": 0.18213}, "CVE-2019-5629": {"epss_score": 0.00062, "epss_percentile": 0.19607}, "CVE-2019-5630": {"epss_score": 0.01102, "epss_percentile": 0.77589}, "CVE-2019-5631": {"epss_score": 0.00111, "epss_percentile": 0.30379}, "CVE-2019-5632": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2019-5633": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2019-5634": {"epss_score": 0.00052, "epss_percentile": 0.16442}, "CVE-2019-5635": {"epss_score": 0.0004, "epss_percentile": 0.12099}, "CVE-2019-5636": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2019-5637": {"epss_score": 0.00566, "epss_percentile": 0.67824}, "CVE-2019-5638": {"epss_score": 0.00143, "epss_percentile": 0.35194}, "CVE-2019-5640": {"epss_score": 0.00171, "epss_percentile": 0.38806}, "CVE-2019-5641": {"epss_score": 0.00133, "epss_percentile": 0.33716}, "CVE-2019-5642": {"epss_score": 0.00095, "epss_percentile": 0.27086}, "CVE-2019-5643": {"epss_score": 0.0084, "epss_percentile": 0.74206}, "CVE-2019-5644": {"epss_score": 0.01914, "epss_percentile": 0.82851}, "CVE-2019-5645": {"epss_score": 0.87878, "epss_percentile": 0.99447}, "CVE-2019-5647": {"epss_score": 0.00117, "epss_percentile": 0.31244}, "CVE-2019-5648": {"epss_score": 0.0051, "epss_percentile": 0.65782}, "CVE-2019-5665": {"epss_score": 0.00059, "epss_percentile": 0.18633}, "CVE-2019-5666": {"epss_score": 0.00047, "epss_percentile": 0.1449}, "CVE-2019-5667": {"epss_score": 0.00046, "epss_percentile": 0.14413}, "CVE-2019-5668": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2019-5669": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2019-5670": {"epss_score": 0.00046, "epss_percentile": 0.14413}, "CVE-2019-5671": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2019-5672": {"epss_score": 0.00282, "epss_percentile": 0.51263}, "CVE-2019-5673": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2019-5674": {"epss_score": 0.00193, "epss_percentile": 0.41448}, "CVE-2019-5675": {"epss_score": 0.00119, "epss_percentile": 0.31573}, "CVE-2019-5676": {"epss_score": 0.00318, "epss_percentile": 0.54446}, "CVE-2019-5677": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2019-5678": {"epss_score": 0.00143, "epss_percentile": 0.3522}, "CVE-2019-5679": {"epss_score": 0.0004, "epss_percentile": 0.11949}, "CVE-2019-5680": {"epss_score": 0.00073, "epss_percentile": 0.22559}, "CVE-2019-5681": {"epss_score": 0.00046, "epss_percentile": 0.14413}, "CVE-2019-5682": {"epss_score": 0.00046, "epss_percentile": 0.14413}, "CVE-2019-5683": {"epss_score": 0.00076, "epss_percentile": 0.23261}, "CVE-2019-5684": {"epss_score": 0.02482, "epss_percentile": 0.84875}, "CVE-2019-5685": {"epss_score": 0.01771, "epss_percentile": 0.82196}, "CVE-2019-5686": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2019-5687": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2019-5688": {"epss_score": 0.00115, "epss_percentile": 0.30905}, "CVE-2019-5689": {"epss_score": 0.0005, "epss_percentile": 0.15886}, "CVE-2019-5690": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2019-5691": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2019-5692": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2019-5693": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2019-5694": {"epss_score": 0.00193, "epss_percentile": 0.41418}, "CVE-2019-5695": {"epss_score": 0.00059, "epss_percentile": 0.18666}, "CVE-2019-5696": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2019-5697": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2019-5698": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2019-5699": {"epss_score": 0.00054, "epss_percentile": 0.17251}, "CVE-2019-5700": {"epss_score": 0.00046, "epss_percentile": 0.14413}, "CVE-2019-5701": {"epss_score": 0.00043, "epss_percentile": 0.13344}, "CVE-2019-5702": {"epss_score": 0.00048, "epss_percentile": 0.15052}, "CVE-2019-5715": {"epss_score": 0.00322, "epss_percentile": 0.54813}, "CVE-2019-5716": {"epss_score": 0.00274, "epss_percentile": 0.50531}, "CVE-2019-5717": {"epss_score": 0.00274, "epss_percentile": 0.50531}, "CVE-2019-5718": {"epss_score": 0.00274, "epss_percentile": 0.50531}, "CVE-2019-5719": {"epss_score": 0.00129, "epss_percentile": 0.33209}, "CVE-2019-5720": {"epss_score": 0.00281, "epss_percentile": 0.51103}, "CVE-2019-5721": {"epss_score": 0.00179, "epss_percentile": 0.39847}, "CVE-2019-5722": {"epss_score": 0.06765, "epss_percentile": 0.91011}, "CVE-2019-5723": {"epss_score": 0.00148, "epss_percentile": 0.35882}, "CVE-2019-5725": {"epss_score": 0.00327, "epss_percentile": 0.55102}, "CVE-2019-5727": {"epss_score": 0.00224, "epss_percentile": 0.45025}, "CVE-2019-5729": {"epss_score": 0.00187, "epss_percentile": 0.40711}, "CVE-2019-5736": {"epss_score": 0.55565, "epss_percentile": 0.97984}, "CVE-2019-5737": {"epss_score": 0.36856, "epss_percentile": 0.97005}, "CVE-2019-5739": {"epss_score": 0.00431, "epss_percentile": 0.62059}, "CVE-2019-5747": {"epss_score": 0.00369, "epss_percentile": 0.58276}, "CVE-2019-5748": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2019-5754": {"epss_score": 0.00124, "epss_percentile": 0.32441}, "CVE-2019-5755": {"epss_score": 0.0086, "epss_percentile": 0.74543}, "CVE-2019-5756": {"epss_score": 0.02491, "epss_percentile": 0.84898}, "CVE-2019-5757": {"epss_score": 0.01624, "epss_percentile": 0.81412}, "CVE-2019-5758": {"epss_score": 0.01624, "epss_percentile": 0.81412}, "CVE-2019-5759": {"epss_score": 0.01624, "epss_percentile": 0.81412}, "CVE-2019-5760": {"epss_score": 0.01498, "epss_percentile": 0.80703}, "CVE-2019-5761": {"epss_score": 0.01228, "epss_percentile": 0.78704}, "CVE-2019-5762": {"epss_score": 0.02491, "epss_percentile": 0.84898}, "CVE-2019-5763": {"epss_score": 0.01624, "epss_percentile": 0.81412}, "CVE-2019-5764": {"epss_score": 0.01498, "epss_percentile": 0.80703}, "CVE-2019-5765": {"epss_score": 0.00131, "epss_percentile": 0.33398}, "CVE-2019-5766": {"epss_score": 0.0086, "epss_percentile": 0.74543}, "CVE-2019-5767": {"epss_score": 0.00479, "epss_percentile": 0.64414}, "CVE-2019-5768": {"epss_score": 0.00479, "epss_percentile": 0.64414}, "CVE-2019-5769": {"epss_score": 0.01624, "epss_percentile": 0.81412}, "CVE-2019-5770": {"epss_score": 0.01108, "epss_percentile": 0.77637}, "CVE-2019-5771": {"epss_score": 0.01497, "epss_percentile": 0.80689}, "CVE-2019-5772": {"epss_score": 0.01624, "epss_percentile": 0.81412}, "CVE-2019-5773": {"epss_score": 0.00283, "epss_percentile": 0.51351}, "CVE-2019-5774": {"epss_score": 0.009, "epss_percentile": 0.75159}, "CVE-2019-5775": {"epss_score": 0.00836, "epss_percentile": 0.74127}, "CVE-2019-5776": {"epss_score": 0.00836, "epss_percentile": 0.74127}, "CVE-2019-5777": {"epss_score": 0.00836, "epss_percentile": 0.74127}, "CVE-2019-5778": {"epss_score": 0.00483, "epss_percentile": 0.64594}, "CVE-2019-5779": {"epss_score": 0.00641, "epss_percentile": 0.69995}, "CVE-2019-5780": {"epss_score": 0.0003, "epss_percentile": 0.08225}, "CVE-2019-5781": {"epss_score": 0.00836, "epss_percentile": 0.74127}, "CVE-2019-5782": {"epss_score": 0.79607, "epss_percentile": 0.99048}, "CVE-2019-5783": {"epss_score": 0.00676, "epss_percentile": 0.70939}, "CVE-2019-5784": {"epss_score": 0.09298, "epss_percentile": 0.92489}, "CVE-2019-5785": {"epss_score": 0.00375, "epss_percentile": 0.58627}, "CVE-2019-5786": {"epss_score": 0.9028, "epss_percentile": 0.99575}, "CVE-2019-5787": {"epss_score": 0.01192, "epss_percentile": 0.78401}, "CVE-2019-5788": {"epss_score": 0.2052, "epss_percentile": 0.95363}, "CVE-2019-5789": {"epss_score": 0.2052, "epss_percentile": 0.95363}, "CVE-2019-5790": {"epss_score": 0.01736, "epss_percentile": 0.82017}, "CVE-2019-5791": {"epss_score": 0.01743, "epss_percentile": 0.82056}, "CVE-2019-5792": {"epss_score": 0.00598, "epss_percentile": 0.68767}, "CVE-2019-5793": {"epss_score": 0.00223, "epss_percentile": 0.44966}, "CVE-2019-5794": {"epss_score": 0.00223, "epss_percentile": 0.44966}, "CVE-2019-5795": {"epss_score": 0.00598, "epss_percentile": 0.68767}, "CVE-2019-5796": {"epss_score": 0.0737, "epss_percentile": 0.91439}, "CVE-2019-5797": {"epss_score": 0.02791, "epss_percentile": 0.85667}, "CVE-2019-5798": {"epss_score": 0.0128, "epss_percentile": 0.79137}, "CVE-2019-5799": {"epss_score": 0.00154, "epss_percentile": 0.36712}, "CVE-2019-5800": {"epss_score": 0.00154, "epss_percentile": 0.36712}, "CVE-2019-5801": {"epss_score": 0.00223, "epss_percentile": 0.44966}, "CVE-2019-5802": {"epss_score": 0.00223, "epss_percentile": 0.44966}, "CVE-2019-5803": {"epss_score": 0.00154, "epss_percentile": 0.36712}, "CVE-2019-5804": {"epss_score": 0.00046, "epss_percentile": 0.14272}, "CVE-2019-5805": {"epss_score": 0.02, "epss_percentile": 0.83215}, "CVE-2019-5806": {"epss_score": 0.01749, "epss_percentile": 0.82094}, "CVE-2019-5807": {"epss_score": 0.01749, "epss_percentile": 0.82094}, "CVE-2019-5808": {"epss_score": 0.02973, "epss_percentile": 0.86101}, "CVE-2019-5809": {"epss_score": 0.01749, "epss_percentile": 0.82094}, "CVE-2019-5810": {"epss_score": 0.00398, "epss_percentile": 0.6009}, "CVE-2019-5811": {"epss_score": 0.01001, "epss_percentile": 0.765}, "CVE-2019-5812": {"epss_score": 0.00481, "epss_percentile": 0.64508}, "CVE-2019-5813": {"epss_score": 0.01749, "epss_percentile": 0.82094}, "CVE-2019-5814": {"epss_score": 0.00455, "epss_percentile": 0.63296}, "CVE-2019-5815": {"epss_score": 0.00111, "epss_percentile": 0.30377}, "CVE-2019-5816": {"epss_score": 0.00607, "epss_percentile": 0.69047}, "CVE-2019-5817": {"epss_score": 0.01265, "epss_percentile": 0.79}, "CVE-2019-5818": {"epss_score": 0.00871, "epss_percentile": 0.7472}, "CVE-2019-5819": {"epss_score": 0.00036, "epss_percentile": 0.10542}, "CVE-2019-5820": {"epss_score": 0.01749, "epss_percentile": 0.82094}, "CVE-2019-5821": {"epss_score": 0.01749, "epss_percentile": 0.82094}, "CVE-2019-5822": {"epss_score": 0.01714, "epss_percentile": 0.81894}, "CVE-2019-5823": {"epss_score": 0.00619, "epss_percentile": 0.69393}, "CVE-2019-5824": {"epss_score": 0.01655, "epss_percentile": 0.81591}, "CVE-2019-5825": {"epss_score": 0.73662, "epss_percentile": 0.98765}, "CVE-2019-5826": {"epss_score": 0.00831, "epss_percentile": 0.74056}, "CVE-2019-5827": {"epss_score": 0.03832, "epss_percentile": 0.87811}, "CVE-2019-5828": {"epss_score": 0.01749, "epss_percentile": 0.82094}, "CVE-2019-5829": {"epss_score": 0.02152, "epss_percentile": 0.83792}, "CVE-2019-5830": {"epss_score": 0.00871, "epss_percentile": 0.7472}, "CVE-2019-5831": {"epss_score": 0.02152, "epss_percentile": 0.83792}, "CVE-2019-5832": {"epss_score": 0.01133, "epss_percentile": 0.77883}, "CVE-2019-5833": {"epss_score": 0.0078, "epss_percentile": 0.73164}, "CVE-2019-5834": {"epss_score": 0.00442, "epss_percentile": 0.62711}, "CVE-2019-5835": {"epss_score": 0.00504, "epss_percentile": 0.65524}, "CVE-2019-5836": {"epss_score": 0.02036, "epss_percentile": 0.83352}, "CVE-2019-5837": {"epss_score": 0.01133, "epss_percentile": 0.77883}, "CVE-2019-5838": {"epss_score": 0.00474, "epss_percentile": 0.64164}, "CVE-2019-5839": {"epss_score": 0.01034, "epss_percentile": 0.76883}, "CVE-2019-5840": {"epss_score": 0.00616, "epss_percentile": 0.69333}, "CVE-2019-5841": {"epss_score": 0.00385, "epss_percentile": 0.59197}, "CVE-2019-5842": {"epss_score": 0.00396, "epss_percentile": 0.59921}, "CVE-2019-5843": {"epss_score": 0.0041, "epss_percentile": 0.60842}, "CVE-2019-5844": {"epss_score": 0.00966, "epss_percentile": 0.76064}, "CVE-2019-5845": {"epss_score": 0.00966, "epss_percentile": 0.76064}, "CVE-2019-5846": {"epss_score": 0.00966, "epss_percentile": 0.76064}, "CVE-2019-5847": {"epss_score": 0.00396, "epss_percentile": 0.59921}, "CVE-2019-5848": {"epss_score": 0.00181, "epss_percentile": 0.40122}, "CVE-2019-5849": {"epss_score": 0.00486, "epss_percentile": 0.64758}, "CVE-2019-5850": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2019-5851": {"epss_score": 0.00328, "epss_percentile": 0.55167}, "CVE-2019-5852": {"epss_score": 0.00336, "epss_percentile": 0.55903}, "CVE-2019-5853": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2019-5854": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2019-5855": {"epss_score": 0.00396, "epss_percentile": 0.59921}, "CVE-2019-5856": {"epss_score": 0.00088, "epss_percentile": 0.25646}, "CVE-2019-5857": {"epss_score": 0.00396, "epss_percentile": 0.59921}, "CVE-2019-5858": {"epss_score": 0.003, "epss_percentile": 0.52988}, "CVE-2019-5859": {"epss_score": 0.00162, "epss_percentile": 0.37644}, "CVE-2019-5860": {"epss_score": 0.0022, "epss_percentile": 0.44623}, "CVE-2019-5861": {"epss_score": 0.00126, "epss_percentile": 0.32702}, "CVE-2019-5862": {"epss_score": 0.00096, "epss_percentile": 0.27265}, "CVE-2019-5864": {"epss_score": 0.00069, "epss_percentile": 0.21497}, "CVE-2019-5865": {"epss_score": 0.00126, "epss_percentile": 0.32702}, "CVE-2019-5866": {"epss_score": 0.00421, "epss_percentile": 0.61494}, "CVE-2019-5867": {"epss_score": 0.00271, "epss_percentile": 0.50276}, "CVE-2019-5868": {"epss_score": 0.00134, "epss_percentile": 0.33897}, "CVE-2019-5869": {"epss_score": 0.00396, "epss_percentile": 0.59921}, "CVE-2019-5870": {"epss_score": 0.00358, "epss_percentile": 0.57508}, "CVE-2019-5871": {"epss_score": 0.00425, "epss_percentile": 0.6172}, "CVE-2019-5872": {"epss_score": 0.00396, "epss_percentile": 0.59921}, "CVE-2019-5873": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2019-5874": {"epss_score": 0.00119, "epss_percentile": 0.31601}, "CVE-2019-5875": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2019-5876": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2019-5877": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2019-5878": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2019-5879": {"epss_score": 0.0011, "epss_percentile": 0.30226}, "CVE-2019-5880": {"epss_score": 0.00336, "epss_percentile": 0.55903}, "CVE-2019-5881": {"epss_score": 0.00483, "epss_percentile": 0.64617}, "CVE-2019-5882": {"epss_score": 0.00524, "epss_percentile": 0.66322}, "CVE-2019-5883": {"epss_score": 0.00142, "epss_percentile": 0.34967}, "CVE-2019-5884": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-5885": {"epss_score": 0.00785, "epss_percentile": 0.73256}, "CVE-2019-5886": {"epss_score": 0.00407, "epss_percentile": 0.6059}, "CVE-2019-5887": {"epss_score": 0.00718, "epss_percentile": 0.71923}, "CVE-2019-5888": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-5889": {"epss_score": 0.00866, "epss_percentile": 0.7463}, "CVE-2019-5890": {"epss_score": 0.0059, "epss_percentile": 0.68544}, "CVE-2019-5891": {"epss_score": 0.00866, "epss_percentile": 0.7463}, "CVE-2019-5892": {"epss_score": 0.03602, "epss_percentile": 0.87411}, "CVE-2019-5893": {"epss_score": 0.08506, "epss_percentile": 0.92088}, "CVE-2019-5909": {"epss_score": 0.1152, "epss_percentile": 0.93392}, "CVE-2019-5910": {"epss_score": 0.01027, "epss_percentile": 0.76806}, "CVE-2019-5911": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2019-5912": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2019-5913": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2019-5914": {"epss_score": 0.00101, "epss_percentile": 0.28664}, "CVE-2019-5915": {"epss_score": 0.00283, "epss_percentile": 0.5136}, "CVE-2019-5916": {"epss_score": 0.00868, "epss_percentile": 0.74672}, "CVE-2019-5917": {"epss_score": 0.21248, "epss_percentile": 0.95485}, "CVE-2019-5918": {"epss_score": 0.00581, "epss_percentile": 0.68261}, "CVE-2019-5919": {"epss_score": 0.00161, "epss_percentile": 0.3755}, "CVE-2019-5920": {"epss_score": 0.00234, "epss_percentile": 0.46092}, "CVE-2019-5921": {"epss_score": 0.01907, "epss_percentile": 0.82811}, "CVE-2019-5922": {"epss_score": 0.01907, "epss_percentile": 0.82811}, "CVE-2019-5923": {"epss_score": 0.00802, "epss_percentile": 0.73581}, "CVE-2019-5924": {"epss_score": 0.00355, "epss_percentile": 0.57324}, "CVE-2019-5925": {"epss_score": 0.00236, "epss_percentile": 0.46379}, "CVE-2019-5926": {"epss_score": 0.00349, "epss_percentile": 0.56867}, "CVE-2019-5927": {"epss_score": 0.00802, "epss_percentile": 0.73581}, "CVE-2019-5928": {"epss_score": 0.00278, "epss_percentile": 0.5087}, "CVE-2019-5929": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2019-5930": {"epss_score": 0.00153, "epss_percentile": 0.36571}, "CVE-2019-5931": {"epss_score": 0.00386, "epss_percentile": 0.59274}, "CVE-2019-5932": {"epss_score": 0.002, "epss_percentile": 0.42222}, "CVE-2019-5933": {"epss_score": 0.00153, "epss_percentile": 0.36571}, "CVE-2019-5934": {"epss_score": 0.00323, "epss_percentile": 0.54912}, "CVE-2019-5935": {"epss_score": 0.00179, "epss_percentile": 0.39785}, "CVE-2019-5936": {"epss_score": 0.00088, "epss_percentile": 0.25675}, "CVE-2019-5937": {"epss_score": 0.00195, "epss_percentile": 0.41641}, "CVE-2019-5938": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2019-5939": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2019-5940": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2019-5941": {"epss_score": 0.00179, "epss_percentile": 0.39785}, "CVE-2019-5942": {"epss_score": 0.00153, "epss_percentile": 0.36571}, "CVE-2019-5943": {"epss_score": 0.00153, "epss_percentile": 0.36571}, "CVE-2019-5944": {"epss_score": 0.00179, "epss_percentile": 0.39785}, "CVE-2019-5945": {"epss_score": 0.00844, "epss_percentile": 0.74277}, "CVE-2019-5946": {"epss_score": 0.00215, "epss_percentile": 0.44082}, "CVE-2019-5947": {"epss_score": 0.00195, "epss_percentile": 0.41641}, "CVE-2019-5953": {"epss_score": 0.0176, "epss_percentile": 0.82145}, "CVE-2019-5954": {"epss_score": 0.00223, "epss_percentile": 0.44962}, "CVE-2019-5955": {"epss_score": 0.0017, "epss_percentile": 0.38706}, "CVE-2019-5956": {"epss_score": 0.00291, "epss_percentile": 0.5218}, "CVE-2019-5957": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2019-5958": {"epss_score": 0.00255, "epss_percentile": 0.48659}, "CVE-2019-5960": {"epss_score": 0.00166, "epss_percentile": 0.38156}, "CVE-2019-5961": {"epss_score": 0.00116, "epss_percentile": 0.31083}, "CVE-2019-5962": {"epss_score": 0.00414, "epss_percentile": 0.61022}, "CVE-2019-5963": {"epss_score": 0.00102, "epss_percentile": 0.28744}, "CVE-2019-5964": {"epss_score": 0.00162, "epss_percentile": 0.37729}, "CVE-2019-5965": {"epss_score": 0.00215, "epss_percentile": 0.44082}, "CVE-2019-5966": {"epss_score": 0.00225, "epss_percentile": 0.45081}, "CVE-2019-5967": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2019-5968": {"epss_score": 0.00166, "epss_percentile": 0.38156}, "CVE-2019-5969": {"epss_score": 0.00215, "epss_percentile": 0.44082}, "CVE-2019-5970": {"epss_score": 0.00728, "epss_percentile": 0.72109}, "CVE-2019-5971": {"epss_score": 0.00119, "epss_percentile": 0.31631}, "CVE-2019-5972": {"epss_score": 0.00728, "epss_percentile": 0.72109}, "CVE-2019-5973": {"epss_score": 0.00094, "epss_percentile": 0.26956}, "CVE-2019-5974": {"epss_score": 0.00238, "epss_percentile": 0.46817}, "CVE-2019-5975": {"epss_score": 0.00195, "epss_percentile": 0.41641}, "CVE-2019-5976": {"epss_score": 0.00298, "epss_percentile": 0.52804}, "CVE-2019-5977": {"epss_score": 0.00196, "epss_percentile": 0.41791}, "CVE-2019-5978": {"epss_score": 0.00274, "epss_percentile": 0.50574}, "CVE-2019-5979": {"epss_score": 0.00188, "epss_percentile": 0.40842}, "CVE-2019-5980": {"epss_score": 0.00102, "epss_percentile": 0.28744}, "CVE-2019-5981": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2019-5982": {"epss_score": 0.00117, "epss_percentile": 0.31262}, "CVE-2019-5983": {"epss_score": 0.00111, "epss_percentile": 0.30335}, "CVE-2019-5984": {"epss_score": 0.00205, "epss_percentile": 0.42717}, "CVE-2019-5985": {"epss_score": 0.00292, "epss_percentile": 0.52243}, "CVE-2019-5986": {"epss_score": 0.00147, "epss_percentile": 0.35723}, "CVE-2019-5987": {"epss_score": 0.01956, "epss_percentile": 0.83039}, "CVE-2019-5988": {"epss_score": 0.00402, "epss_percentile": 0.60275}, "CVE-2019-5989": {"epss_score": 0.00402, "epss_percentile": 0.60275}, "CVE-2019-5990": {"epss_score": 0.00655, "epss_percentile": 0.70419}, "CVE-2019-5991": {"epss_score": 0.00441, "epss_percentile": 0.62676}, "CVE-2019-5992": {"epss_score": 0.00094, "epss_percentile": 0.26775}, "CVE-2019-5993": {"epss_score": 0.00094, "epss_percentile": 0.26775}, "CVE-2019-5994": {"epss_score": 0.00101, "epss_percentile": 0.28601}, "CVE-2019-5995": {"epss_score": 0.00025, "epss_percentile": 0.06341}, "CVE-2019-5996": {"epss_score": 0.0039, "epss_percentile": 0.59514}, "CVE-2019-5997": {"epss_score": 0.00201, "epss_percentile": 0.42351}, "CVE-2019-5998": {"epss_score": 0.00294, "epss_percentile": 0.5242}, "CVE-2019-5999": {"epss_score": 0.00323, "epss_percentile": 0.54916}, "CVE-2019-6000": {"epss_score": 0.00323, "epss_percentile": 0.54916}, "CVE-2019-6001": {"epss_score": 0.00233, "epss_percentile": 0.46009}, "CVE-2019-6002": {"epss_score": 0.00304, "epss_percentile": 0.53273}, "CVE-2019-6003": {"epss_score": 0.00332, "epss_percentile": 0.55583}, "CVE-2019-6004": {"epss_score": 0.00274, "epss_percentile": 0.50574}, "CVE-2019-6005": {"epss_score": 0.00481, "epss_percentile": 0.64509}, "CVE-2019-6007": {"epss_score": 0.00646, "epss_percentile": 0.7014}, "CVE-2019-6008": {"epss_score": 0.00381, "epss_percentile": 0.59018}, "CVE-2019-6009": {"epss_score": 0.00318, "epss_percentile": 0.54427}, "CVE-2019-6010": {"epss_score": 0.00562, "epss_percentile": 0.67692}, "CVE-2019-6011": {"epss_score": 0.00267, "epss_percentile": 0.49955}, "CVE-2019-6012": {"epss_score": 0.0108, "epss_percentile": 0.77368}, "CVE-2019-6013": {"epss_score": 0.00162, "epss_percentile": 0.37686}, "CVE-2019-6014": {"epss_score": 0.0159, "epss_percentile": 0.81198}, "CVE-2019-6015": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2019-6016": {"epss_score": 0.00402, "epss_percentile": 0.60275}, "CVE-2019-6017": {"epss_score": 0.005, "epss_percentile": 0.65292}, "CVE-2019-6018": {"epss_score": 0.00402, "epss_percentile": 0.60275}, "CVE-2019-6019": {"epss_score": 0.00329, "epss_percentile": 0.55389}, "CVE-2019-6020": {"epss_score": 0.0039, "epss_percentile": 0.59516}, "CVE-2019-6021": {"epss_score": 0.0039, "epss_percentile": 0.59516}, "CVE-2019-6022": {"epss_score": 0.00926, "epss_percentile": 0.75545}, "CVE-2019-6023": {"epss_score": 0.00147, "epss_percentile": 0.3579}, "CVE-2019-6024": {"epss_score": 0.00346, "epss_percentile": 0.56632}, "CVE-2019-6025": {"epss_score": 0.0039, "epss_percentile": 0.59516}, "CVE-2019-6026": {"epss_score": 0.00155, "epss_percentile": 0.36834}, "CVE-2019-6027": {"epss_score": 0.00126, "epss_percentile": 0.32745}, "CVE-2019-6029": {"epss_score": 0.00599, "epss_percentile": 0.688}, "CVE-2019-6030": {"epss_score": 0.00126, "epss_percentile": 0.32745}, "CVE-2019-6031": {"epss_score": 0.00402, "epss_percentile": 0.60275}, "CVE-2019-6032": {"epss_score": 0.00138, "epss_percentile": 0.34458}, "CVE-2019-6033": {"epss_score": 0.00402, "epss_percentile": 0.60275}, "CVE-2019-6034": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2019-6035": {"epss_score": 0.00522, "epss_percentile": 0.66259}, "CVE-2019-6036": {"epss_score": 0.00402, "epss_percentile": 0.60275}, "CVE-2019-6109": {"epss_score": 0.09738, "epss_percentile": 0.92682}, "CVE-2019-6110": {"epss_score": 0.51287, "epss_percentile": 0.97774}, "CVE-2019-6111": {"epss_score": 0.60044, "epss_percentile": 0.9819}, "CVE-2019-6112": {"epss_score": 0.32802, "epss_percentile": 0.96726}, "CVE-2019-6113": {"epss_score": 0.00429, "epss_percentile": 0.61972}, "CVE-2019-6114": {"epss_score": 0.00889, "epss_percentile": 0.75013}, "CVE-2019-6116": {"epss_score": 0.68998, "epss_percentile": 0.98572}, "CVE-2019-6117": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-6120": {"epss_score": 0.00508, "epss_percentile": 0.65709}, "CVE-2019-6121": {"epss_score": 0.00327, "epss_percentile": 0.55137}, "CVE-2019-6122": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2019-6126": {"epss_score": 0.0025, "epss_percentile": 0.48245}, "CVE-2019-6127": {"epss_score": 0.00576, "epss_percentile": 0.68127}, "CVE-2019-6128": {"epss_score": 0.02119, "epss_percentile": 0.83672}, "CVE-2019-6129": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2019-6130": {"epss_score": 0.00194, "epss_percentile": 0.4152}, "CVE-2019-6131": {"epss_score": 0.00239, "epss_percentile": 0.4686}, "CVE-2019-6132": {"epss_score": 0.00468, "epss_percentile": 0.63891}, "CVE-2019-6133": {"epss_score": 0.00025, "epss_percentile": 0.06305}, "CVE-2019-6135": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-6136": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-6137": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2019-6138": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-6139": {"epss_score": 0.02126, "epss_percentile": 0.83694}, "CVE-2019-6140": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2019-6142": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2019-6143": {"epss_score": 0.00267, "epss_percentile": 0.5002}, "CVE-2019-6144": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2019-6145": {"epss_score": 0.00157, "epss_percentile": 0.37018}, "CVE-2019-6146": {"epss_score": 0.01981, "epss_percentile": 0.83138}, "CVE-2019-6147": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-6149": {"epss_score": 0.00042, "epss_percentile": 0.1259}, "CVE-2019-6154": {"epss_score": 0.00239, "epss_percentile": 0.46867}, "CVE-2019-6155": {"epss_score": 0.00145, "epss_percentile": 0.35402}, "CVE-2019-6156": {"epss_score": 0.00043, "epss_percentile": 0.12999}, "CVE-2019-6157": {"epss_score": 0.00301, "epss_percentile": 0.53074}, "CVE-2019-6158": {"epss_score": 0.00318, "epss_percentile": 0.54429}, "CVE-2019-6159": {"epss_score": 0.00377, "epss_percentile": 0.58762}, "CVE-2019-6160": {"epss_score": 0.00487, "epss_percentile": 0.64825}, "CVE-2019-6161": {"epss_score": 0.00329, "epss_percentile": 0.55401}, "CVE-2019-6163": {"epss_score": 0.0027, "epss_percentile": 0.50246}, "CVE-2019-6165": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2019-6166": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2019-6167": {"epss_score": 0.01307, "epss_percentile": 0.79339}, "CVE-2019-6168": {"epss_score": 0.01307, "epss_percentile": 0.79339}, "CVE-2019-6169": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2019-6170": {"epss_score": 0.00074, "epss_percentile": 0.22773}, "CVE-2019-6171": {"epss_score": 0.00047, "epss_percentile": 0.14583}, "CVE-2019-6172": {"epss_score": 0.00093, "epss_percentile": 0.26644}, "CVE-2019-6173": {"epss_score": 0.0004, "epss_percentile": 0.12176}, "CVE-2019-6175": {"epss_score": 0.00555, "epss_percentile": 0.67488}, "CVE-2019-6176": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2019-6177": {"epss_score": 0.00225, "epss_percentile": 0.45119}, "CVE-2019-6178": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2019-6179": {"epss_score": 0.00293, "epss_percentile": 0.52287}, "CVE-2019-6180": {"epss_score": 0.0023, "epss_percentile": 0.45664}, "CVE-2019-6181": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2019-6182": {"epss_score": 0.00217, "epss_percentile": 0.44316}, "CVE-2019-6183": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2019-6184": {"epss_score": 0.00132, "epss_percentile": 0.33542}, "CVE-2019-6186": {"epss_score": 0.00599, "epss_percentile": 0.68792}, "CVE-2019-6187": {"epss_score": 0.00509, "epss_percentile": 0.65743}, "CVE-2019-6188": {"epss_score": 0.00621, "epss_percentile": 0.69482}, "CVE-2019-6189": {"epss_score": 0.00145, "epss_percentile": 0.35411}, "CVE-2019-6190": {"epss_score": 0.00116, "epss_percentile": 0.31074}, "CVE-2019-6191": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2019-6192": {"epss_score": 0.02015, "epss_percentile": 0.83272}, "CVE-2019-6193": {"epss_score": 0.00343, "epss_percentile": 0.56424}, "CVE-2019-6194": {"epss_score": 0.00252, "epss_percentile": 0.48366}, "CVE-2019-6195": {"epss_score": 0.00144, "epss_percentile": 0.35312}, "CVE-2019-6196": {"epss_score": 0.00039, "epss_percentile": 0.11767}, "CVE-2019-6197": {"epss_score": 0.00108, "epss_percentile": 0.29839}, "CVE-2019-6198": {"epss_score": 0.00108, "epss_percentile": 0.29839}, "CVE-2019-6200": {"epss_score": 0.00162, "epss_percentile": 0.37628}, "CVE-2019-6201": {"epss_score": 0.00882, "epss_percentile": 0.749}, "CVE-2019-6202": {"epss_score": 0.00254, "epss_percentile": 0.48529}, "CVE-2019-6203": {"epss_score": 0.10288, "epss_percentile": 0.92928}, "CVE-2019-6204": {"epss_score": 0.00323, "epss_percentile": 0.54888}, "CVE-2019-6205": {"epss_score": 0.09037, "epss_percentile": 0.92376}, "CVE-2019-6206": {"epss_score": 0.00378, "epss_percentile": 0.58794}, "CVE-2019-6207": {"epss_score": 0.00656, "epss_percentile": 0.70449}, "CVE-2019-6208": {"epss_score": 0.06357, "epss_percentile": 0.90695}, "CVE-2019-6209": {"epss_score": 0.04962, "epss_percentile": 0.89336}, "CVE-2019-6210": {"epss_score": 0.00447, "epss_percentile": 0.62979}, "CVE-2019-6211": {"epss_score": 0.00643, "epss_percentile": 0.70058}, "CVE-2019-6212": {"epss_score": 0.00533, "epss_percentile": 0.6677}, "CVE-2019-6213": {"epss_score": 0.04884, "epss_percentile": 0.89252}, "CVE-2019-6214": {"epss_score": 0.08716, "epss_percentile": 0.92224}, "CVE-2019-6215": {"epss_score": 0.331, "epss_percentile": 0.96746}, "CVE-2019-6216": {"epss_score": 0.00629, "epss_percentile": 0.69678}, "CVE-2019-6217": {"epss_score": 0.00639, "epss_percentile": 0.69936}, "CVE-2019-6218": {"epss_score": 0.06679, "epss_percentile": 0.90938}, "CVE-2019-6219": {"epss_score": 0.01022, "epss_percentile": 0.76758}, "CVE-2019-6220": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2019-6221": {"epss_score": 0.00254, "epss_percentile": 0.48529}, "CVE-2019-6222": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2019-6223": {"epss_score": 0.00165, "epss_percentile": 0.3808}, "CVE-2019-6224": {"epss_score": 0.3068, "epss_percentile": 0.9656}, "CVE-2019-6225": {"epss_score": 0.69072, "epss_percentile": 0.98576}, "CVE-2019-6226": {"epss_score": 0.00635, "epss_percentile": 0.69822}, "CVE-2019-6227": {"epss_score": 0.00639, "epss_percentile": 0.69936}, "CVE-2019-6228": {"epss_score": 0.00327, "epss_percentile": 0.55113}, "CVE-2019-6229": {"epss_score": 0.007, "epss_percentile": 0.71459}, "CVE-2019-6230": {"epss_score": 0.00346, "epss_percentile": 0.5662}, "CVE-2019-6231": {"epss_score": 0.00352, "epss_percentile": 0.57118}, "CVE-2019-6232": {"epss_score": 0.00364, "epss_percentile": 0.57943}, "CVE-2019-6233": {"epss_score": 0.00638, "epss_percentile": 0.69928}, "CVE-2019-6234": {"epss_score": 0.00638, "epss_percentile": 0.69928}, "CVE-2019-6235": {"epss_score": 0.00798, "epss_percentile": 0.73505}, "CVE-2019-6236": {"epss_score": 0.00371, "epss_percentile": 0.58386}, "CVE-2019-6237": {"epss_score": 0.00811, "epss_percentile": 0.73738}, "CVE-2019-6238": {"epss_score": 0.00343, "epss_percentile": 0.56461}, "CVE-2019-6239": {"epss_score": 0.0005, "epss_percentile": 0.15841}, "CVE-2019-6240": {"epss_score": 0.00122, "epss_percentile": 0.32173}, "CVE-2019-6241": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2019-6242": {"epss_score": 0.00459, "epss_percentile": 0.63457}, "CVE-2019-6243": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-6244": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-6245": {"epss_score": 0.0032, "epss_percentile": 0.54598}, "CVE-2019-6246": {"epss_score": 0.00242, "epss_percentile": 0.47349}, "CVE-2019-6247": {"epss_score": 0.01849, "epss_percentile": 0.82529}, "CVE-2019-6248": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-6249": {"epss_score": 0.00412, "epss_percentile": 0.60934}, "CVE-2019-6250": {"epss_score": 0.28551, "epss_percentile": 0.96366}, "CVE-2019-6251": {"epss_score": 0.02448, "epss_percentile": 0.84772}, "CVE-2019-6256": {"epss_score": 0.00555, "epss_percentile": 0.67478}, "CVE-2019-6257": {"epss_score": 0.00207, "epss_percentile": 0.43112}, "CVE-2019-6258": {"epss_score": 0.01357, "epss_percentile": 0.79718}, "CVE-2019-6259": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-6260": {"epss_score": 0.02012, "epss_percentile": 0.83252}, "CVE-2019-6261": {"epss_score": 0.00429, "epss_percentile": 0.61994}, "CVE-2019-6262": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2019-6263": {"epss_score": 0.00123, "epss_percentile": 0.3226}, "CVE-2019-6264": {"epss_score": 0.00429, "epss_percentile": 0.61994}, "CVE-2019-6265": {"epss_score": 0.00209, "epss_percentile": 0.43422}, "CVE-2019-6266": {"epss_score": 0.00258, "epss_percentile": 0.49014}, "CVE-2019-6267": {"epss_score": 0.00245, "epss_percentile": 0.47727}, "CVE-2019-6268": {"epss_score": 0.00506, "epss_percentile": 0.65614}, "CVE-2019-6272": {"epss_score": 0.07011, "epss_percentile": 0.91185}, "CVE-2019-6273": {"epss_score": 0.07156, "epss_percentile": 0.91289}, "CVE-2019-6274": {"epss_score": 0.03836, "epss_percentile": 0.87824}, "CVE-2019-6275": {"epss_score": 0.07011, "epss_percentile": 0.91185}, "CVE-2019-6278": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2019-6279": {"epss_score": 0.15781, "epss_percentile": 0.94508}, "CVE-2019-6282": {"epss_score": 0.00591, "epss_percentile": 0.68579}, "CVE-2019-6283": {"epss_score": 0.00301, "epss_percentile": 0.53042}, "CVE-2019-6284": {"epss_score": 0.00218, "epss_percentile": 0.44439}, "CVE-2019-6285": {"epss_score": 0.00689, "epss_percentile": 0.71223}, "CVE-2019-6286": {"epss_score": 0.0028, "epss_percentile": 0.51085}, "CVE-2019-6287": {"epss_score": 0.00172, "epss_percentile": 0.38994}, "CVE-2019-6288": {"epss_score": 0.18595, "epss_percentile": 0.95039}, "CVE-2019-6289": {"epss_score": 0.00909, "epss_percentile": 0.75311}, "CVE-2019-6290": {"epss_score": 0.00175, "epss_percentile": 0.39322}, "CVE-2019-6291": {"epss_score": 0.00374, "epss_percentile": 0.58583}, "CVE-2019-6292": {"epss_score": 0.00454, "epss_percentile": 0.63257}, "CVE-2019-6293": {"epss_score": 0.00452, "epss_percentile": 0.63165}, "CVE-2019-6294": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-6295": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2019-6296": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2019-6318": {"epss_score": 0.01541, "epss_percentile": 0.80945}, "CVE-2019-6319": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2019-6320": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2019-6321": {"epss_score": 0.00358, "epss_percentile": 0.57521}, "CVE-2019-6322": {"epss_score": 0.00314, "epss_percentile": 0.54092}, "CVE-2019-6323": {"epss_score": 0.004, "epss_percentile": 0.60168}, "CVE-2019-6324": {"epss_score": 0.00272, "epss_percentile": 0.50346}, "CVE-2019-6325": {"epss_score": 0.00217, "epss_percentile": 0.44281}, "CVE-2019-6326": {"epss_score": 0.00514, "epss_percentile": 0.65948}, "CVE-2019-6327": {"epss_score": 0.00816, "epss_percentile": 0.73801}, "CVE-2019-6328": {"epss_score": 0.00063, "epss_percentile": 0.19819}, "CVE-2019-6329": {"epss_score": 0.02565, "epss_percentile": 0.85115}, "CVE-2019-6330": {"epss_score": 0.01025, "epss_percentile": 0.76788}, "CVE-2019-6331": {"epss_score": 0.00081, "epss_percentile": 0.24252}, "CVE-2019-6332": {"epss_score": 0.00236, "epss_percentile": 0.46455}, "CVE-2019-6333": {"epss_score": 0.00068, "epss_percentile": 0.2131}, "CVE-2019-6334": {"epss_score": 0.03168, "epss_percentile": 0.86542}, "CVE-2019-6335": {"epss_score": 0.00947, "epss_percentile": 0.75818}, "CVE-2019-6337": {"epss_score": 0.00405, "epss_percentile": 0.60479}, "CVE-2019-6338": {"epss_score": 0.01047, "epss_percentile": 0.7704}, "CVE-2019-6339": {"epss_score": 0.80782, "epss_percentile": 0.99105}, "CVE-2019-6340": {"epss_score": 0.94436, "epss_percentile": 0.99985}, "CVE-2019-6341": {"epss_score": 0.54564, "epss_percentile": 0.97933}, "CVE-2019-6342": {"epss_score": 0.002, "epss_percentile": 0.42265}, "CVE-2019-6438": {"epss_score": 0.00531, "epss_percentile": 0.66648}, "CVE-2019-6439": {"epss_score": 0.01141, "epss_percentile": 0.77963}, "CVE-2019-6440": {"epss_score": 0.10645, "epss_percentile": 0.93056}, "CVE-2019-6441": {"epss_score": 0.4809, "epss_percentile": 0.9762}, "CVE-2019-6442": {"epss_score": 0.10199, "epss_percentile": 0.92889}, "CVE-2019-6443": {"epss_score": 0.30797, "epss_percentile": 0.96569}, "CVE-2019-6444": {"epss_score": 0.12577, "epss_percentile": 0.93719}, "CVE-2019-6445": {"epss_score": 0.1167, "epss_percentile": 0.93441}, "CVE-2019-6446": {"epss_score": 0.5973, "epss_percentile": 0.98177}, "CVE-2019-6447": {"epss_score": 0.79426, "epss_percentile": 0.99037}, "CVE-2019-6451": {"epss_score": 0.00307, "epss_percentile": 0.53525}, "CVE-2019-6452": {"epss_score": 0.00093, "epss_percentile": 0.26667}, "CVE-2019-6453": {"epss_score": 0.84944, "epss_percentile": 0.99312}, "CVE-2019-6454": {"epss_score": 0.00111, "epss_percentile": 0.30399}, "CVE-2019-6455": {"epss_score": 0.00164, "epss_percentile": 0.37934}, "CVE-2019-6456": {"epss_score": 0.00165, "epss_percentile": 0.38023}, "CVE-2019-6457": {"epss_score": 0.00164, "epss_percentile": 0.37934}, "CVE-2019-6458": {"epss_score": 0.00164, "epss_percentile": 0.37934}, "CVE-2019-6459": {"epss_score": 0.00164, "epss_percentile": 0.37934}, "CVE-2019-6460": {"epss_score": 0.00165, "epss_percentile": 0.38023}, "CVE-2019-6461": {"epss_score": 0.00051, "epss_percentile": 0.1602}, "CVE-2019-6462": {"epss_score": 0.00131, "epss_percentile": 0.33373}, "CVE-2019-6465": {"epss_score": 0.00602, "epss_percentile": 0.68874}, "CVE-2019-6467": {"epss_score": 0.17224, "epss_percentile": 0.94802}, "CVE-2019-6468": {"epss_score": 0.01057, "epss_percentile": 0.77134}, "CVE-2019-6469": {"epss_score": 0.01057, "epss_percentile": 0.77134}, "CVE-2019-6470": {"epss_score": 0.00265, "epss_percentile": 0.49808}, "CVE-2019-6471": {"epss_score": 0.01259, "epss_percentile": 0.78966}, "CVE-2019-6472": {"epss_score": 0.00677, "epss_percentile": 0.70957}, "CVE-2019-6473": {"epss_score": 0.00677, "epss_percentile": 0.70957}, "CVE-2019-6474": {"epss_score": 0.01595, "epss_percentile": 0.81234}, "CVE-2019-6475": {"epss_score": 0.00621, "epss_percentile": 0.69481}, "CVE-2019-6476": {"epss_score": 0.01269, "epss_percentile": 0.79035}, "CVE-2019-6477": {"epss_score": 0.05682, "epss_percentile": 0.90118}, "CVE-2019-6481": {"epss_score": 0.01042, "epss_percentile": 0.7698}, "CVE-2019-6485": {"epss_score": 0.00463, "epss_percentile": 0.63677}, "CVE-2019-6486": {"epss_score": 0.02315, "epss_percentile": 0.84355}, "CVE-2019-6487": {"epss_score": 0.24931, "epss_percentile": 0.95968}, "CVE-2019-6488": {"epss_score": 0.00154, "epss_percentile": 0.36688}, "CVE-2019-6489": {"epss_score": 0.00599, "epss_percentile": 0.68794}, "CVE-2019-6491": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2019-6492": {"epss_score": 0.00113, "epss_percentile": 0.3069}, "CVE-2019-6493": {"epss_score": 0.00136, "epss_percentile": 0.34173}, "CVE-2019-6494": {"epss_score": 0.0023, "epss_percentile": 0.45682}, "CVE-2019-6496": {"epss_score": 0.03167, "epss_percentile": 0.86542}, "CVE-2019-6497": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2019-6498": {"epss_score": 0.07937, "epss_percentile": 0.91775}, "CVE-2019-6499": {"epss_score": 0.00299, "epss_percentile": 0.52886}, "CVE-2019-6500": {"epss_score": 0.0848, "epss_percentile": 0.92073}, "CVE-2019-6501": {"epss_score": 0.00124, "epss_percentile": 0.32382}, "CVE-2019-6502": {"epss_score": 0.00189, "epss_percentile": 0.41005}, "CVE-2019-6503": {"epss_score": 0.00147, "epss_percentile": 0.35693}, "CVE-2019-6504": {"epss_score": 0.00881, "epss_percentile": 0.74875}, "CVE-2019-6506": {"epss_score": 0.00396, "epss_percentile": 0.59883}, "CVE-2019-6507": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-6508": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-6509": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-6510": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-6512": {"epss_score": 0.00224, "epss_percentile": 0.45021}, "CVE-2019-6513": {"epss_score": 0.00309, "epss_percentile": 0.53722}, "CVE-2019-6514": {"epss_score": 0.00261, "epss_percentile": 0.49285}, "CVE-2019-6515": {"epss_score": 0.00608, "epss_percentile": 0.69082}, "CVE-2019-6516": {"epss_score": 0.00147, "epss_percentile": 0.35744}, "CVE-2019-6517": {"epss_score": 0.00118, "epss_percentile": 0.31444}, "CVE-2019-6518": {"epss_score": 0.00107, "epss_percentile": 0.29658}, "CVE-2019-6519": {"epss_score": 0.03059, "epss_percentile": 0.86305}, "CVE-2019-6520": {"epss_score": 0.00284, "epss_percentile": 0.51427}, "CVE-2019-6521": {"epss_score": 0.01663, "epss_percentile": 0.81639}, "CVE-2019-6522": {"epss_score": 0.00302, "epss_percentile": 0.53163}, "CVE-2019-6523": {"epss_score": 0.0074, "epss_percentile": 0.72403}, "CVE-2019-6524": {"epss_score": 0.00247, "epss_percentile": 0.47902}, "CVE-2019-6525": {"epss_score": 0.00148, "epss_percentile": 0.35892}, "CVE-2019-6526": {"epss_score": 0.00124, "epss_percentile": 0.32453}, "CVE-2019-6527": {"epss_score": 0.00296, "epss_percentile": 0.52542}, "CVE-2019-6528": {"epss_score": 0.00877, "epss_percentile": 0.74801}, "CVE-2019-6529": {"epss_score": 0.00198, "epss_percentile": 0.42047}, "CVE-2019-6530": {"epss_score": 0.017, "epss_percentile": 0.81832}, "CVE-2019-6531": {"epss_score": 0.00239, "epss_percentile": 0.46888}, "CVE-2019-6532": {"epss_score": 0.00684, "epss_percentile": 0.71125}, "CVE-2019-6533": {"epss_score": 0.00162, "epss_percentile": 0.37684}, "CVE-2019-6534": {"epss_score": 0.00744, "epss_percentile": 0.72514}, "CVE-2019-6535": {"epss_score": 0.03925, "epss_percentile": 0.87963}, "CVE-2019-6536": {"epss_score": 0.00156, "epss_percentile": 0.37003}, "CVE-2019-6537": {"epss_score": 0.00365, "epss_percentile": 0.58006}, "CVE-2019-6538": {"epss_score": 0.0022, "epss_percentile": 0.44567}, "CVE-2019-6539": {"epss_score": 0.00238, "epss_percentile": 0.46803}, "CVE-2019-6540": {"epss_score": 0.00018, "epss_percentile": 0.03898}, "CVE-2019-6541": {"epss_score": 0.00193, "epss_percentile": 0.41385}, "CVE-2019-6542": {"epss_score": 0.00322, "epss_percentile": 0.54818}, "CVE-2019-6543": {"epss_score": 0.35859, "epss_percentile": 0.96938}, "CVE-2019-6544": {"epss_score": 0.0035, "epss_percentile": 0.56956}, "CVE-2019-6545": {"epss_score": 0.21114, "epss_percentile": 0.95464}, "CVE-2019-6546": {"epss_score": 0.00155, "epss_percentile": 0.36836}, "CVE-2019-6547": {"epss_score": 0.00124, "epss_percentile": 0.32456}, "CVE-2019-6548": {"epss_score": 0.00263, "epss_percentile": 0.49547}, "CVE-2019-6549": {"epss_score": 0.00091, "epss_percentile": 0.26213}, "CVE-2019-6550": {"epss_score": 0.03608, "epss_percentile": 0.87421}, "CVE-2019-6551": {"epss_score": 0.0098, "epss_percentile": 0.76273}, "CVE-2019-6552": {"epss_score": 0.01621, "epss_percentile": 0.81391}, "CVE-2019-6553": {"epss_score": 0.17249, "epss_percentile": 0.94808}, "CVE-2019-6554": {"epss_score": 0.00228, "epss_percentile": 0.45533}, "CVE-2019-6555": {"epss_score": 0.00204, "epss_percentile": 0.42596}, "CVE-2019-6556": {"epss_score": 0.00207, "epss_percentile": 0.43159}, "CVE-2019-6557": {"epss_score": 0.06913, "epss_percentile": 0.91114}, "CVE-2019-6558": {"epss_score": 0.00216, "epss_percentile": 0.44149}, "CVE-2019-6559": {"epss_score": 0.01363, "epss_percentile": 0.79767}, "CVE-2019-6560": {"epss_score": 0.00198, "epss_percentile": 0.4205}, "CVE-2019-6561": {"epss_score": 0.00191, "epss_percentile": 0.41212}, "CVE-2019-6562": {"epss_score": 0.00159, "epss_percentile": 0.37308}, "CVE-2019-6563": {"epss_score": 0.00137, "epss_percentile": 0.34255}, "CVE-2019-6564": {"epss_score": 0.00049, "epss_percentile": 0.15613}, "CVE-2019-6565": {"epss_score": 0.0058, "epss_percentile": 0.68251}, "CVE-2019-6566": {"epss_score": 0.00035, "epss_percentile": 0.0996}, "CVE-2019-6567": {"epss_score": 0.00111, "epss_percentile": 0.3024}, "CVE-2019-6568": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2019-6569": {"epss_score": 0.00482, "epss_percentile": 0.64554}, "CVE-2019-6570": {"epss_score": 0.00241, "epss_percentile": 0.47265}, "CVE-2019-6571": {"epss_score": 0.00229, "epss_percentile": 0.45598}, "CVE-2019-6572": {"epss_score": 0.00904, "epss_percentile": 0.75219}, "CVE-2019-6574": {"epss_score": 0.00793, "epss_percentile": 0.73422}, "CVE-2019-6575": {"epss_score": 0.01124, "epss_percentile": 0.77798}, "CVE-2019-6576": {"epss_score": 0.00386, "epss_percentile": 0.59253}, "CVE-2019-6577": {"epss_score": 0.00318, "epss_percentile": 0.54454}, "CVE-2019-6578": {"epss_score": 0.00361, "epss_percentile": 0.57737}, "CVE-2019-6579": {"epss_score": 0.01326, "epss_percentile": 0.7948}, "CVE-2019-6580": {"epss_score": 0.00379, "epss_percentile": 0.58896}, "CVE-2019-6581": {"epss_score": 0.00296, "epss_percentile": 0.52604}, "CVE-2019-6582": {"epss_score": 0.00169, "epss_percentile": 0.38537}, "CVE-2019-6584": {"epss_score": 0.0042, "epss_percentile": 0.61424}, "CVE-2019-6585": {"epss_score": 0.00481, "epss_percentile": 0.64514}, "CVE-2019-6588": {"epss_score": 0.00691, "epss_percentile": 0.71264}, "CVE-2019-6589": {"epss_score": 0.00294, "epss_percentile": 0.52432}, "CVE-2019-6590": {"epss_score": 0.00553, "epss_percentile": 0.67415}, "CVE-2019-6591": {"epss_score": 0.00195, "epss_percentile": 0.41657}, "CVE-2019-6592": {"epss_score": 0.00327, "epss_percentile": 0.55131}, "CVE-2019-6593": {"epss_score": 0.00407, "epss_percentile": 0.60575}, "CVE-2019-6594": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2019-6595": {"epss_score": 0.00259, "epss_percentile": 0.49045}, "CVE-2019-6596": {"epss_score": 0.00778, "epss_percentile": 0.73135}, "CVE-2019-6597": {"epss_score": 0.00466, "epss_percentile": 0.63796}, "CVE-2019-6598": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2019-6599": {"epss_score": 0.00294, "epss_percentile": 0.52432}, "CVE-2019-6600": {"epss_score": 0.00363, "epss_percentile": 0.57845}, "CVE-2019-6601": {"epss_score": 0.00074, "epss_percentile": 0.22805}, "CVE-2019-6602": {"epss_score": 0.0051, "epss_percentile": 0.65767}, "CVE-2019-6603": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6604": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2019-6605": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6606": {"epss_score": 0.00269, "epss_percentile": 0.50179}, "CVE-2019-6607": {"epss_score": 0.00173, "epss_percentile": 0.3912}, "CVE-2019-6608": {"epss_score": 0.00611, "epss_percentile": 0.69187}, "CVE-2019-6609": {"epss_score": 0.0047, "epss_percentile": 0.63986}, "CVE-2019-6610": {"epss_score": 0.00417, "epss_percentile": 0.61254}, "CVE-2019-6611": {"epss_score": 0.00749, "epss_percentile": 0.72607}, "CVE-2019-6612": {"epss_score": 0.00743, "epss_percentile": 0.72463}, "CVE-2019-6613": {"epss_score": 0.00108, "epss_percentile": 0.29817}, "CVE-2019-6614": {"epss_score": 0.00488, "epss_percentile": 0.64855}, "CVE-2019-6615": {"epss_score": 0.00273, "epss_percentile": 0.50473}, "CVE-2019-6616": {"epss_score": 0.00582, "epss_percentile": 0.6831}, "CVE-2019-6617": {"epss_score": 0.00801, "epss_percentile": 0.73579}, "CVE-2019-6618": {"epss_score": 0.00162, "epss_percentile": 0.37668}, "CVE-2019-6619": {"epss_score": 0.00743, "epss_percentile": 0.72463}, "CVE-2019-6620": {"epss_score": 0.01504, "epss_percentile": 0.80737}, "CVE-2019-6621": {"epss_score": 0.03126, "epss_percentile": 0.86455}, "CVE-2019-6622": {"epss_score": 0.01504, "epss_percentile": 0.80737}, "CVE-2019-6623": {"epss_score": 0.01069, "epss_percentile": 0.77248}, "CVE-2019-6624": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2019-6625": {"epss_score": 0.00294, "epss_percentile": 0.52432}, "CVE-2019-6626": {"epss_score": 0.00294, "epss_percentile": 0.52432}, "CVE-2019-6627": {"epss_score": 0.00501, "epss_percentile": 0.65352}, "CVE-2019-6628": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6629": {"epss_score": 0.00702, "epss_percentile": 0.71508}, "CVE-2019-6630": {"epss_score": 0.00778, "epss_percentile": 0.73135}, "CVE-2019-6631": {"epss_score": 0.01069, "epss_percentile": 0.77248}, "CVE-2019-6632": {"epss_score": 0.00114, "epss_percentile": 0.30868}, "CVE-2019-6633": {"epss_score": 0.00115, "epss_percentile": 0.30984}, "CVE-2019-6634": {"epss_score": 0.00335, "epss_percentile": 0.55845}, "CVE-2019-6635": {"epss_score": 0.00132, "epss_percentile": 0.33537}, "CVE-2019-6636": {"epss_score": 0.0019, "epss_percentile": 0.41074}, "CVE-2019-6637": {"epss_score": 0.00335, "epss_percentile": 0.55845}, "CVE-2019-6638": {"epss_score": 0.00478, "epss_percentile": 0.644}, "CVE-2019-6639": {"epss_score": 0.00187, "epss_percentile": 0.40709}, "CVE-2019-6640": {"epss_score": 0.00132, "epss_percentile": 0.33574}, "CVE-2019-6641": {"epss_score": 0.00626, "epss_percentile": 0.69621}, "CVE-2019-6642": {"epss_score": 0.00495, "epss_percentile": 0.6512}, "CVE-2019-6643": {"epss_score": 0.00577, "epss_percentile": 0.68163}, "CVE-2019-6644": {"epss_score": 0.00789, "epss_percentile": 0.73353}, "CVE-2019-6645": {"epss_score": 0.00778, "epss_percentile": 0.73135}, "CVE-2019-6646": {"epss_score": 0.00396, "epss_percentile": 0.59882}, "CVE-2019-6647": {"epss_score": 0.00461, "epss_percentile": 0.63566}, "CVE-2019-6648": {"epss_score": 0.00109, "epss_percentile": 0.29988}, "CVE-2019-6649": {"epss_score": 0.00521, "epss_percentile": 0.66226}, "CVE-2019-6650": {"epss_score": 0.00521, "epss_percentile": 0.66226}, "CVE-2019-6651": {"epss_score": 0.00403, "epss_percentile": 0.60327}, "CVE-2019-6652": {"epss_score": 0.00144, "epss_percentile": 0.35346}, "CVE-2019-6653": {"epss_score": 0.00247, "epss_percentile": 0.47831}, "CVE-2019-6654": {"epss_score": 0.00127, "epss_percentile": 0.32892}, "CVE-2019-6655": {"epss_score": 0.00247, "epss_percentile": 0.47868}, "CVE-2019-6656": {"epss_score": 0.00537, "epss_percentile": 0.66892}, "CVE-2019-6657": {"epss_score": 0.00466, "epss_percentile": 0.63802}, "CVE-2019-6658": {"epss_score": 0.00296, "epss_percentile": 0.52628}, "CVE-2019-6659": {"epss_score": 0.00896, "epss_percentile": 0.75117}, "CVE-2019-6660": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6661": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6662": {"epss_score": 0.00331, "epss_percentile": 0.55503}, "CVE-2019-6663": {"epss_score": 0.00444, "epss_percentile": 0.62832}, "CVE-2019-6664": {"epss_score": 0.00584, "epss_percentile": 0.68377}, "CVE-2019-6665": {"epss_score": 0.00838, "epss_percentile": 0.74177}, "CVE-2019-6666": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6667": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6668": {"epss_score": 0.00184, "epss_percentile": 0.40429}, "CVE-2019-6669": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6670": {"epss_score": 0.00097, "epss_percentile": 0.2752}, "CVE-2019-6671": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6672": {"epss_score": 0.00896, "epss_percentile": 0.75117}, "CVE-2019-6673": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6674": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6675": {"epss_score": 0.00135, "epss_percentile": 0.34012}, "CVE-2019-6676": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6677": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6678": {"epss_score": 0.00868, "epss_percentile": 0.7467}, "CVE-2019-6679": {"epss_score": 0.00094, "epss_percentile": 0.27035}, "CVE-2019-6680": {"epss_score": 0.00916, "epss_percentile": 0.75421}, "CVE-2019-6681": {"epss_score": 0.00916, "epss_percentile": 0.75421}, "CVE-2019-6682": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6683": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6684": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2019-6685": {"epss_score": 0.00175, "epss_percentile": 0.39315}, "CVE-2019-6686": {"epss_score": 0.00868, "epss_percentile": 0.7467}, "CVE-2019-6687": {"epss_score": 0.00267, "epss_percentile": 0.49985}, "CVE-2019-6688": {"epss_score": 0.00185, "epss_percentile": 0.40474}, "CVE-2019-6689": {"epss_score": 0.00312, "epss_percentile": 0.53938}, "CVE-2019-6690": {"epss_score": 0.21696, "epss_percentile": 0.95548}, "CVE-2019-6691": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2019-6692": {"epss_score": 0.00137, "epss_percentile": 0.3422}, "CVE-2019-6693": {"epss_score": 0.70196, "epss_percentile": 0.98622}, "CVE-2019-6695": {"epss_score": 0.00259, "epss_percentile": 0.49098}, "CVE-2019-6696": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2019-6697": {"epss_score": 0.00094, "epss_percentile": 0.26792}, "CVE-2019-6698": {"epss_score": 0.01002, "epss_percentile": 0.76504}, "CVE-2019-6699": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2019-6700": {"epss_score": 0.0025, "epss_percentile": 0.48091}, "CVE-2019-6702": {"epss_score": 0.00746, "epss_percentile": 0.72543}, "CVE-2019-6703": {"epss_score": 0.54383, "epss_percentile": 0.97923}, "CVE-2019-6706": {"epss_score": 0.00904, "epss_percentile": 0.75212}, "CVE-2019-6707": {"epss_score": 0.00242, "epss_percentile": 0.47391}, "CVE-2019-6708": {"epss_score": 0.00242, "epss_percentile": 0.47391}, "CVE-2019-6710": {"epss_score": 0.00554, "epss_percentile": 0.67434}, "CVE-2019-6713": {"epss_score": 0.01155, "epss_percentile": 0.78072}, "CVE-2019-6714": {"epss_score": 0.17198, "epss_percentile": 0.94796}, "CVE-2019-6715": {"epss_score": 0.90796, "epss_percentile": 0.99601}, "CVE-2019-6716": {"epss_score": 0.03507, "epss_percentile": 0.87259}, "CVE-2019-6719": {"epss_score": 0.00393, "epss_percentile": 0.59709}, "CVE-2019-6724": {"epss_score": 0.00232, "epss_percentile": 0.45891}, "CVE-2019-6725": {"epss_score": 0.00436, "epss_percentile": 0.62434}, "CVE-2019-6726": {"epss_score": 0.03912, "epss_percentile": 0.87935}, "CVE-2019-6727": {"epss_score": 0.06202, "epss_percentile": 0.90562}, "CVE-2019-6728": {"epss_score": 0.00878, "epss_percentile": 0.74819}, "CVE-2019-6729": {"epss_score": 0.00737, "epss_percentile": 0.72332}, "CVE-2019-6730": {"epss_score": 0.06202, "epss_percentile": 0.90562}, "CVE-2019-6731": {"epss_score": 0.00737, "epss_percentile": 0.72332}, "CVE-2019-6732": {"epss_score": 0.00894, "epss_percentile": 0.75081}, "CVE-2019-6733": {"epss_score": 0.00894, "epss_percentile": 0.75081}, "CVE-2019-6734": {"epss_score": 0.00982, "epss_percentile": 0.76287}, "CVE-2019-6735": {"epss_score": 0.00894, "epss_percentile": 0.75081}, "CVE-2019-6736": {"epss_score": 0.01929, "epss_percentile": 0.82933}, "CVE-2019-6737": {"epss_score": 0.01225, "epss_percentile": 0.78683}, "CVE-2019-6738": {"epss_score": 0.01929, "epss_percentile": 0.82933}, "CVE-2019-6739": {"epss_score": 0.03088, "epss_percentile": 0.86391}, "CVE-2019-6740": {"epss_score": 0.01547, "epss_percentile": 0.80973}, "CVE-2019-6741": {"epss_score": 0.00672, "epss_percentile": 0.70817}, "CVE-2019-6742": {"epss_score": 0.19212, "epss_percentile": 0.95149}, "CVE-2019-6743": {"epss_score": 0.00608, "epss_percentile": 0.69078}, "CVE-2019-6744": {"epss_score": 0.00103, "epss_percentile": 0.28902}, "CVE-2019-6746": {"epss_score": 0.00236, "epss_percentile": 0.46451}, "CVE-2019-6747": {"epss_score": 0.00401, "epss_percentile": 0.60235}, "CVE-2019-6748": {"epss_score": 0.00401, "epss_percentile": 0.60235}, "CVE-2019-6749": {"epss_score": 0.00401, "epss_percentile": 0.60235}, "CVE-2019-6750": {"epss_score": 0.00401, "epss_percentile": 0.60235}, "CVE-2019-6751": {"epss_score": 0.00401, "epss_percentile": 0.60235}, "CVE-2019-6752": {"epss_score": 0.00128, "epss_percentile": 0.33013}, "CVE-2019-6753": {"epss_score": 0.0055, "epss_percentile": 0.67333}, "CVE-2019-6754": {"epss_score": 0.01281, "epss_percentile": 0.79149}, "CVE-2019-6755": {"epss_score": 0.00401, "epss_percentile": 0.60235}, "CVE-2019-6756": {"epss_score": 0.00128, "epss_percentile": 0.33013}, "CVE-2019-6757": {"epss_score": 0.00445, "epss_percentile": 0.6287}, "CVE-2019-6758": {"epss_score": 0.00236, "epss_percentile": 0.46451}, "CVE-2019-6759": {"epss_score": 0.00401, "epss_percentile": 0.60235}, "CVE-2019-6760": {"epss_score": 0.00401, "epss_percentile": 0.60235}, "CVE-2019-6761": {"epss_score": 0.00445, "epss_percentile": 0.6287}, "CVE-2019-6762": {"epss_score": 0.00445, "epss_percentile": 0.6287}, "CVE-2019-6763": {"epss_score": 0.00445, "epss_percentile": 0.6287}, "CVE-2019-6764": {"epss_score": 0.00401, "epss_percentile": 0.60235}, "CVE-2019-6765": {"epss_score": 0.00401, "epss_percentile": 0.60235}, "CVE-2019-6766": {"epss_score": 0.00236, "epss_percentile": 0.46451}, "CVE-2019-6767": {"epss_score": 0.0062, "epss_percentile": 0.6944}, "CVE-2019-6768": {"epss_score": 0.00445, "epss_percentile": 0.6287}, "CVE-2019-6769": {"epss_score": 0.0062, "epss_percentile": 0.6944}, "CVE-2019-6770": {"epss_score": 0.00236, "epss_percentile": 0.46451}, "CVE-2019-6771": {"epss_score": 0.00236, "epss_percentile": 0.46451}, "CVE-2019-6772": {"epss_score": 0.00236, "epss_percentile": 0.46451}, "CVE-2019-6773": {"epss_score": 0.01012, "epss_percentile": 0.76627}, "CVE-2019-6774": {"epss_score": 0.00606, "epss_percentile": 0.6902}, "CVE-2019-6775": {"epss_score": 0.00606, "epss_percentile": 0.6902}, "CVE-2019-6776": {"epss_score": 0.00606, "epss_percentile": 0.6902}, "CVE-2019-6777": {"epss_score": 0.00134, "epss_percentile": 0.33853}, "CVE-2019-6778": {"epss_score": 0.00076, "epss_percentile": 0.23133}, "CVE-2019-6779": {"epss_score": 0.00169, "epss_percentile": 0.38553}, "CVE-2019-6780": {"epss_score": 0.03625, "epss_percentile": 0.87455}, "CVE-2019-6781": {"epss_score": 0.00113, "epss_percentile": 0.30665}, "CVE-2019-6782": {"epss_score": 0.0039, "epss_percentile": 0.59505}, "CVE-2019-6783": {"epss_score": 0.02085, "epss_percentile": 0.83545}, "CVE-2019-6784": {"epss_score": 0.00147, "epss_percentile": 0.35799}, "CVE-2019-6785": {"epss_score": 0.00284, "epss_percentile": 0.51423}, "CVE-2019-6786": {"epss_score": 0.001, "epss_percentile": 0.2854}, "CVE-2019-6787": {"epss_score": 0.00123, "epss_percentile": 0.32334}, "CVE-2019-6788": {"epss_score": 0.202, "epss_percentile": 0.95302}, "CVE-2019-6789": {"epss_score": 0.00087, "epss_percentile": 0.25514}, "CVE-2019-6790": {"epss_score": 0.00117, "epss_percentile": 0.31211}, "CVE-2019-6791": {"epss_score": 0.00077, "epss_percentile": 0.2336}, "CVE-2019-6792": {"epss_score": 0.00264, "epss_percentile": 0.49705}, "CVE-2019-6793": {"epss_score": 0.03925, "epss_percentile": 0.87962}, "CVE-2019-6794": {"epss_score": 0.00101, "epss_percentile": 0.28684}, "CVE-2019-6795": {"epss_score": 0.00201, "epss_percentile": 0.42278}, "CVE-2019-6796": {"epss_score": 0.00127, "epss_percentile": 0.32939}, "CVE-2019-6797": {"epss_score": 0.00127, "epss_percentile": 0.32847}, "CVE-2019-6798": {"epss_score": 0.00538, "epss_percentile": 0.66937}, "CVE-2019-6799": {"epss_score": 0.72448, "epss_percentile": 0.98709}, "CVE-2019-6800": {"epss_score": 0.00689, "epss_percentile": 0.71222}, "CVE-2019-6802": {"epss_score": 0.01051, "epss_percentile": 0.77083}, "CVE-2019-6803": {"epss_score": 0.02309, "epss_percentile": 0.84331}, "CVE-2019-6804": {"epss_score": 0.08615, "epss_percentile": 0.92154}, "CVE-2019-6805": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-6806": {"epss_score": 0.00421, "epss_percentile": 0.6153}, "CVE-2019-6807": {"epss_score": 0.00262, "epss_percentile": 0.49336}, "CVE-2019-6808": {"epss_score": 0.02391, "epss_percentile": 0.846}, "CVE-2019-6809": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2019-6810": {"epss_score": 0.00514, "epss_percentile": 0.65942}, "CVE-2019-6811": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-6812": {"epss_score": 0.00311, "epss_percentile": 0.53858}, "CVE-2019-6813": {"epss_score": 0.0051, "epss_percentile": 0.65792}, "CVE-2019-6814": {"epss_score": 0.66933, "epss_percentile": 0.98486}, "CVE-2019-6815": {"epss_score": 0.00294, "epss_percentile": 0.52393}, "CVE-2019-6816": {"epss_score": 0.0037, "epss_percentile": 0.5831}, "CVE-2019-6819": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2019-6820": {"epss_score": 0.00384, "epss_percentile": 0.59179}, "CVE-2019-6821": {"epss_score": 0.00239, "epss_percentile": 0.46891}, "CVE-2019-6822": {"epss_score": 0.00866, "epss_percentile": 0.74632}, "CVE-2019-6823": {"epss_score": 0.15676, "epss_percentile": 0.94483}, "CVE-2019-6824": {"epss_score": 0.11669, "epss_percentile": 0.9344}, "CVE-2019-6825": {"epss_score": 0.00491, "epss_percentile": 0.64967}, "CVE-2019-6826": {"epss_score": 0.00432, "epss_percentile": 0.62105}, "CVE-2019-6827": {"epss_score": 0.00189, "epss_percentile": 0.40978}, "CVE-2019-6828": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2019-6829": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2019-6830": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2019-6831": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2019-6832": {"epss_score": 0.00343, "epss_percentile": 0.56423}, "CVE-2019-6833": {"epss_score": 0.00344, "epss_percentile": 0.56475}, "CVE-2019-6834": {"epss_score": 0.00284, "epss_percentile": 0.51423}, "CVE-2019-6835": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2019-6836": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2019-6837": {"epss_score": 0.00253, "epss_percentile": 0.48491}, "CVE-2019-6838": {"epss_score": 0.00146, "epss_percentile": 0.35587}, "CVE-2019-6839": {"epss_score": 0.00485, "epss_percentile": 0.64712}, "CVE-2019-6840": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2019-6841": {"epss_score": 0.00524, "epss_percentile": 0.66361}, "CVE-2019-6842": {"epss_score": 0.00382, "epss_percentile": 0.59049}, "CVE-2019-6843": {"epss_score": 0.00382, "epss_percentile": 0.59049}, "CVE-2019-6844": {"epss_score": 0.00382, "epss_percentile": 0.59049}, "CVE-2019-6845": {"epss_score": 0.00205, "epss_percentile": 0.42682}, "CVE-2019-6846": {"epss_score": 0.00216, "epss_percentile": 0.44207}, "CVE-2019-6847": {"epss_score": 0.00382, "epss_percentile": 0.59049}, "CVE-2019-6848": {"epss_score": 0.00459, "epss_percentile": 0.63497}, "CVE-2019-6849": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-6850": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-6851": {"epss_score": 0.00443, "epss_percentile": 0.6277}, "CVE-2019-6852": {"epss_score": 0.00348, "epss_percentile": 0.56805}, "CVE-2019-6853": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2019-6854": {"epss_score": 0.00028, "epss_percentile": 0.07305}, "CVE-2019-6855": {"epss_score": 0.00191, "epss_percentile": 0.41146}, "CVE-2019-6856": {"epss_score": 0.00491, "epss_percentile": 0.64947}, "CVE-2019-6857": {"epss_score": 0.00491, "epss_percentile": 0.64947}, "CVE-2019-6858": {"epss_score": 0.00162, "epss_percentile": 0.37661}, "CVE-2019-6859": {"epss_score": 0.00344, "epss_percentile": 0.56504}, "CVE-2019-6956": {"epss_score": 0.00339, "epss_percentile": 0.56177}, "CVE-2019-6957": {"epss_score": 0.01096, "epss_percentile": 0.77514}, "CVE-2019-6958": {"epss_score": 0.0033, "epss_percentile": 0.55435}, "CVE-2019-6960": {"epss_score": 0.00718, "epss_percentile": 0.71935}, "CVE-2019-6961": {"epss_score": 0.00146, "epss_percentile": 0.35587}, "CVE-2019-6962": {"epss_score": 0.00458, "epss_percentile": 0.63438}, "CVE-2019-6963": {"epss_score": 0.02077, "epss_percentile": 0.83514}, "CVE-2019-6964": {"epss_score": 0.00821, "epss_percentile": 0.73901}, "CVE-2019-6965": {"epss_score": 0.01465, "epss_percentile": 0.80459}, "CVE-2019-6966": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2019-6967": {"epss_score": 0.00658, "epss_percentile": 0.70492}, "CVE-2019-6968": {"epss_score": 0.00248, "epss_percentile": 0.47963}, "CVE-2019-6969": {"epss_score": 0.00421, "epss_percentile": 0.61495}, "CVE-2019-6970": {"epss_score": 0.0036, "epss_percentile": 0.57655}, "CVE-2019-6971": {"epss_score": 0.14994, "epss_percentile": 0.94338}, "CVE-2019-6972": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2019-6973": {"epss_score": 0.13995, "epss_percentile": 0.94111}, "CVE-2019-6974": {"epss_score": 0.07138, "epss_percentile": 0.91275}, "CVE-2019-6975": {"epss_score": 0.07654, "epss_percentile": 0.91606}, "CVE-2019-6976": {"epss_score": 0.00475, "epss_percentile": 0.64183}, "CVE-2019-6977": {"epss_score": 0.87771, "epss_percentile": 0.99441}, "CVE-2019-6978": {"epss_score": 0.03608, "epss_percentile": 0.87421}, "CVE-2019-6979": {"epss_score": 0.00494, "epss_percentile": 0.65091}, "CVE-2019-6980": {"epss_score": 0.40854, "epss_percentile": 0.9724}, "CVE-2019-6981": {"epss_score": 0.00264, "epss_percentile": 0.49678}, "CVE-2019-6982": {"epss_score": 0.00042, "epss_percentile": 0.12919}, "CVE-2019-6983": {"epss_score": 0.0004, "epss_percentile": 0.12034}, "CVE-2019-6984": {"epss_score": 0.00043, "epss_percentile": 0.13129}, "CVE-2019-6985": {"epss_score": 0.00128, "epss_percentile": 0.3306}, "CVE-2019-6986": {"epss_score": 0.01079, "epss_percentile": 0.77358}, "CVE-2019-6988": {"epss_score": 0.00565, "epss_percentile": 0.67801}, "CVE-2019-6989": {"epss_score": 0.19084, "epss_percentile": 0.95126}, "CVE-2019-6990": {"epss_score": 0.00092, "epss_percentile": 0.26475}, "CVE-2019-6991": {"epss_score": 0.02409, "epss_percentile": 0.8466}, "CVE-2019-6992": {"epss_score": 0.00104, "epss_percentile": 0.29198}, "CVE-2019-6995": {"epss_score": 0.00098, "epss_percentile": 0.27802}, "CVE-2019-6996": {"epss_score": 0.00098, "epss_percentile": 0.27662}, "CVE-2019-6997": {"epss_score": 0.00101, "epss_percentile": 0.28684}, "CVE-2019-7000": {"epss_score": 0.00357, "epss_percentile": 0.57467}, "CVE-2019-7001": {"epss_score": 0.00296, "epss_percentile": 0.52603}, "CVE-2019-7003": {"epss_score": 0.00744, "epss_percentile": 0.72511}, "CVE-2019-7004": {"epss_score": 0.00557, "epss_percentile": 0.67538}, "CVE-2019-7005": {"epss_score": 0.00419, "epss_percentile": 0.61351}, "CVE-2019-7006": {"epss_score": 0.0006, "epss_percentile": 0.18982}, "CVE-2019-7007": {"epss_score": 0.01362, "epss_percentile": 0.79761}, "CVE-2019-7018": {"epss_score": 0.04675, "epss_percentile": 0.88996}, "CVE-2019-7019": {"epss_score": 0.02761, "epss_percentile": 0.85604}, "CVE-2019-7020": {"epss_score": 0.05579, "epss_percentile": 0.90016}, "CVE-2019-7021": {"epss_score": 0.02413, "epss_percentile": 0.84676}, "CVE-2019-7022": {"epss_score": 0.02413, "epss_percentile": 0.84676}, "CVE-2019-7023": {"epss_score": 0.02413, "epss_percentile": 0.84676}, "CVE-2019-7024": {"epss_score": 0.02413, "epss_percentile": 0.84676}, "CVE-2019-7025": {"epss_score": 0.04675, "epss_percentile": 0.88996}, "CVE-2019-7026": {"epss_score": 0.04675, "epss_percentile": 0.88996}, "CVE-2019-7027": {"epss_score": 0.02761, "epss_percentile": 0.85604}, "CVE-2019-7028": {"epss_score": 0.02413, "epss_percentile": 0.84676}, "CVE-2019-7029": {"epss_score": 0.04675, "epss_percentile": 0.88996}, "CVE-2019-7030": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-7031": {"epss_score": 0.04675, "epss_percentile": 0.88996}, "CVE-2019-7032": {"epss_score": 0.05227, "epss_percentile": 0.89634}, "CVE-2019-7033": {"epss_score": 0.02413, "epss_percentile": 0.84676}, "CVE-2019-7034": {"epss_score": 0.02413, "epss_percentile": 0.84676}, "CVE-2019-7035": {"epss_score": 0.02413, "epss_percentile": 0.84676}, "CVE-2019-7036": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7037": {"epss_score": 0.02745, "epss_percentile": 0.8557}, "CVE-2019-7038": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7039": {"epss_score": 0.02745, "epss_percentile": 0.8557}, "CVE-2019-7040": {"epss_score": 0.10795, "epss_percentile": 0.93106}, "CVE-2019-7041": {"epss_score": 0.01032, "epss_percentile": 0.76866}, "CVE-2019-7042": {"epss_score": 0.02673, "epss_percentile": 0.85395}, "CVE-2019-7043": {"epss_score": 0.03517, "epss_percentile": 0.87278}, "CVE-2019-7044": {"epss_score": 0.03517, "epss_percentile": 0.87278}, "CVE-2019-7045": {"epss_score": 0.02307, "epss_percentile": 0.84327}, "CVE-2019-7046": {"epss_score": 0.02789, "epss_percentile": 0.85663}, "CVE-2019-7047": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7048": {"epss_score": 0.03517, "epss_percentile": 0.87278}, "CVE-2019-7049": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7050": {"epss_score": 0.04675, "epss_percentile": 0.88996}, "CVE-2019-7051": {"epss_score": 0.02789, "epss_percentile": 0.85663}, "CVE-2019-7052": {"epss_score": 0.02745, "epss_percentile": 0.8557}, "CVE-2019-7053": {"epss_score": 0.02577, "epss_percentile": 0.85146}, "CVE-2019-7054": {"epss_score": 0.02805, "epss_percentile": 0.85706}, "CVE-2019-7055": {"epss_score": 0.02577, "epss_percentile": 0.85146}, "CVE-2019-7056": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-7057": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-7058": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-7059": {"epss_score": 0.02413, "epss_percentile": 0.84676}, "CVE-2019-7060": {"epss_score": 0.02761, "epss_percentile": 0.85604}, "CVE-2019-7061": {"epss_score": 0.02044, "epss_percentile": 0.8338}, "CVE-2019-7062": {"epss_score": 0.04675, "epss_percentile": 0.88996}, "CVE-2019-7063": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-7064": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-7065": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-7066": {"epss_score": 0.02789, "epss_percentile": 0.85663}, "CVE-2019-7067": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-7068": {"epss_score": 0.04675, "epss_percentile": 0.88996}, "CVE-2019-7069": {"epss_score": 0.03324, "epss_percentile": 0.86915}, "CVE-2019-7070": {"epss_score": 0.02438, "epss_percentile": 0.84748}, "CVE-2019-7071": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-7072": {"epss_score": 0.02438, "epss_percentile": 0.84748}, "CVE-2019-7073": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-7074": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-7075": {"epss_score": 0.02548, "epss_percentile": 0.85068}, "CVE-2019-7076": {"epss_score": 0.02789, "epss_percentile": 0.85663}, "CVE-2019-7077": {"epss_score": 0.03517, "epss_percentile": 0.87278}, "CVE-2019-7078": {"epss_score": 0.03517, "epss_percentile": 0.87278}, "CVE-2019-7079": {"epss_score": 0.03501, "epss_percentile": 0.87247}, "CVE-2019-7080": {"epss_score": 0.02789, "epss_percentile": 0.85663}, "CVE-2019-7081": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-7082": {"epss_score": 0.04675, "epss_percentile": 0.88996}, "CVE-2019-7083": {"epss_score": 0.04675, "epss_percentile": 0.88996}, "CVE-2019-7084": {"epss_score": 0.04675, "epss_percentile": 0.88996}, "CVE-2019-7085": {"epss_score": 0.05579, "epss_percentile": 0.90016}, "CVE-2019-7086": {"epss_score": 0.03856, "epss_percentile": 0.87858}, "CVE-2019-7087": {"epss_score": 0.03856, "epss_percentile": 0.87858}, "CVE-2019-7088": {"epss_score": 0.01858, "epss_percentile": 0.82578}, "CVE-2019-7089": {"epss_score": 0.02167, "epss_percentile": 0.83855}, "CVE-2019-7090": {"epss_score": 0.01229, "epss_percentile": 0.78717}, "CVE-2019-7091": {"epss_score": 0.63074, "epss_percentile": 0.9832}, "CVE-2019-7092": {"epss_score": 0.01219, "epss_percentile": 0.78613}, "CVE-2019-7093": {"epss_score": 0.01124, "epss_percentile": 0.778}, "CVE-2019-7094": {"epss_score": 0.20613, "epss_percentile": 0.95384}, "CVE-2019-7095": {"epss_score": 0.0815, "epss_percentile": 0.91904}, "CVE-2019-7096": {"epss_score": 0.06773, "epss_percentile": 0.91017}, "CVE-2019-7097": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2019-7098": {"epss_score": 0.07841, "epss_percentile": 0.91713}, "CVE-2019-7099": {"epss_score": 0.07841, "epss_percentile": 0.91713}, "CVE-2019-7100": {"epss_score": 0.07841, "epss_percentile": 0.91713}, "CVE-2019-7101": {"epss_score": 0.07532, "epss_percentile": 0.91521}, "CVE-2019-7102": {"epss_score": 0.07532, "epss_percentile": 0.91521}, "CVE-2019-7103": {"epss_score": 0.07841, "epss_percentile": 0.91713}, "CVE-2019-7104": {"epss_score": 0.02499, "epss_percentile": 0.84914}, "CVE-2019-7105": {"epss_score": 0.27651, "epss_percentile": 0.96269}, "CVE-2019-7106": {"epss_score": 0.27651, "epss_percentile": 0.96269}, "CVE-2019-7107": {"epss_score": 0.06387, "epss_percentile": 0.90716}, "CVE-2019-7108": {"epss_score": 0.03145, "epss_percentile": 0.86493}, "CVE-2019-7109": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7110": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7111": {"epss_score": 0.05138, "epss_percentile": 0.89536}, "CVE-2019-7112": {"epss_score": 0.04675, "epss_percentile": 0.88996}, "CVE-2019-7113": {"epss_score": 0.02591, "epss_percentile": 0.85181}, "CVE-2019-7114": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7115": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7116": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7117": {"epss_score": 0.07605, "epss_percentile": 0.91564}, "CVE-2019-7118": {"epss_score": 0.04222, "epss_percentile": 0.88413}, "CVE-2019-7119": {"epss_score": 0.04222, "epss_percentile": 0.88413}, "CVE-2019-7120": {"epss_score": 0.04222, "epss_percentile": 0.88413}, "CVE-2019-7121": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7122": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7123": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7124": {"epss_score": 0.04222, "epss_percentile": 0.88413}, "CVE-2019-7125": {"epss_score": 0.06322, "epss_percentile": 0.9067}, "CVE-2019-7127": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2019-7128": {"epss_score": 0.07605, "epss_percentile": 0.91564}, "CVE-2019-7129": {"epss_score": 0.01379, "epss_percentile": 0.79856}, "CVE-2019-7130": {"epss_score": 0.12297, "epss_percentile": 0.93625}, "CVE-2019-7131": {"epss_score": 0.03906, "epss_percentile": 0.87928}, "CVE-2019-7132": {"epss_score": 0.03563, "epss_percentile": 0.87357}, "CVE-2019-7133": {"epss_score": 0.02988, "epss_percentile": 0.86139}, "CVE-2019-7134": {"epss_score": 0.02988, "epss_percentile": 0.86139}, "CVE-2019-7135": {"epss_score": 0.02988, "epss_percentile": 0.86139}, "CVE-2019-7136": {"epss_score": 0.02479, "epss_percentile": 0.84869}, "CVE-2019-7137": {"epss_score": 0.01579, "epss_percentile": 0.8113}, "CVE-2019-7138": {"epss_score": 0.02988, "epss_percentile": 0.86139}, "CVE-2019-7139": {"epss_score": 0.62993, "epss_percentile": 0.98315}, "CVE-2019-7140": {"epss_score": 0.09739, "epss_percentile": 0.92686}, "CVE-2019-7141": {"epss_score": 0.09739, "epss_percentile": 0.92686}, "CVE-2019-7142": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7143": {"epss_score": 0.1231, "epss_percentile": 0.93632}, "CVE-2019-7144": {"epss_score": 0.09739, "epss_percentile": 0.92686}, "CVE-2019-7145": {"epss_score": 0.09739, "epss_percentile": 0.92686}, "CVE-2019-7146": {"epss_score": 0.00445, "epss_percentile": 0.62859}, "CVE-2019-7147": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2019-7148": {"epss_score": 0.00886, "epss_percentile": 0.7495}, "CVE-2019-7149": {"epss_score": 0.00333, "epss_percentile": 0.55631}, "CVE-2019-7150": {"epss_score": 0.00102, "epss_percentile": 0.28808}, "CVE-2019-7151": {"epss_score": 0.00309, "epss_percentile": 0.53648}, "CVE-2019-7152": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2019-7153": {"epss_score": 0.00309, "epss_percentile": 0.53648}, "CVE-2019-7154": {"epss_score": 0.00427, "epss_percentile": 0.6178}, "CVE-2019-7155": {"epss_score": 0.00123, "epss_percentile": 0.32177}, "CVE-2019-7156": {"epss_score": 0.00468, "epss_percentile": 0.63891}, "CVE-2019-7158": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2019-7159": {"epss_score": 0.00402, "epss_percentile": 0.60289}, "CVE-2019-7160": {"epss_score": 0.01067, "epss_percentile": 0.77233}, "CVE-2019-7161": {"epss_score": 0.02196, "epss_percentile": 0.83956}, "CVE-2019-7162": {"epss_score": 0.07776, "epss_percentile": 0.91676}, "CVE-2019-7163": {"epss_score": 0.03824, "epss_percentile": 0.87791}, "CVE-2019-7164": {"epss_score": 0.01941, "epss_percentile": 0.82983}, "CVE-2019-7165": {"epss_score": 0.03981, "epss_percentile": 0.8806}, "CVE-2019-7167": {"epss_score": 0.00511, "epss_percentile": 0.65843}, "CVE-2019-7168": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2019-7169": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2019-7170": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2019-7171": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2019-7172": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-7173": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2019-7174": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-7175": {"epss_score": 0.0023, "epss_percentile": 0.45742}, "CVE-2019-7176": {"epss_score": 0.00131, "epss_percentile": 0.33479}, "CVE-2019-7177": {"epss_score": 0.00633, "epss_percentile": 0.69767}, "CVE-2019-7178": {"epss_score": 0.00494, "epss_percentile": 0.65097}, "CVE-2019-7181": {"epss_score": 0.14533, "epss_percentile": 0.94234}, "CVE-2019-7183": {"epss_score": 0.01246, "epss_percentile": 0.78849}, "CVE-2019-7184": {"epss_score": 0.00209, "epss_percentile": 0.43329}, "CVE-2019-7185": {"epss_score": 0.00209, "epss_percentile": 0.43329}, "CVE-2019-7192": {"epss_score": 0.9408, "epss_percentile": 0.99898}, "CVE-2019-7193": {"epss_score": 0.2579, "epss_percentile": 0.9607}, "CVE-2019-7194": {"epss_score": 0.93938, "epss_percentile": 0.99871}, "CVE-2019-7195": {"epss_score": 0.93454, "epss_percentile": 0.99808}, "CVE-2019-7197": {"epss_score": 0.00364, "epss_percentile": 0.57918}, "CVE-2019-7198": {"epss_score": 0.03068, "epss_percentile": 0.8634}, "CVE-2019-7201": {"epss_score": 0.00041, "epss_percentile": 0.1242}, "CVE-2019-7211": {"epss_score": 0.00301, "epss_percentile": 0.53041}, "CVE-2019-7212": {"epss_score": 0.00482, "epss_percentile": 0.64535}, "CVE-2019-7213": {"epss_score": 0.1338, "epss_percentile": 0.93947}, "CVE-2019-7214": {"epss_score": 0.8308, "epss_percentile": 0.9923}, "CVE-2019-7215": {"epss_score": 7e-05, "epss_percentile": 0.00428}, "CVE-2019-7216": {"epss_score": 0.01877, "epss_percentile": 0.82662}, "CVE-2019-7217": {"epss_score": 0.00446, "epss_percentile": 0.62915}, "CVE-2019-7218": {"epss_score": 0.00269, "epss_percentile": 0.50118}, "CVE-2019-7219": {"epss_score": 0.43975, "epss_percentile": 0.97412}, "CVE-2019-7220": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2019-7221": {"epss_score": 0.00054, "epss_percentile": 0.17273}, "CVE-2019-7222": {"epss_score": 0.00042, "epss_percentile": 0.12803}, "CVE-2019-7223": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-7225": {"epss_score": 0.00224, "epss_percentile": 0.44985}, "CVE-2019-7226": {"epss_score": 0.00343, "epss_percentile": 0.56432}, "CVE-2019-7227": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2019-7228": {"epss_score": 0.02257, "epss_percentile": 0.84175}, "CVE-2019-7229": {"epss_score": 0.00085, "epss_percentile": 0.25058}, "CVE-2019-7230": {"epss_score": 0.02475, "epss_percentile": 0.84858}, "CVE-2019-7231": {"epss_score": 0.01933, "epss_percentile": 0.82948}, "CVE-2019-7232": {"epss_score": 0.08822, "epss_percentile": 0.9227}, "CVE-2019-7233": {"epss_score": 0.00368, "epss_percentile": 0.5818}, "CVE-2019-7234": {"epss_score": 0.01237, "epss_percentile": 0.78776}, "CVE-2019-7235": {"epss_score": 0.00456, "epss_percentile": 0.63343}, "CVE-2019-7236": {"epss_score": 0.01032, "epss_percentile": 0.7686}, "CVE-2019-7237": {"epss_score": 0.01032, "epss_percentile": 0.7686}, "CVE-2019-7238": {"epss_score": 0.94379, "epss_percentile": 0.99964}, "CVE-2019-7240": {"epss_score": 0.00427, "epss_percentile": 0.61882}, "CVE-2019-7244": {"epss_score": 0.00427, "epss_percentile": 0.61882}, "CVE-2019-7245": {"epss_score": 0.00427, "epss_percentile": 0.61882}, "CVE-2019-7246": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2019-7247": {"epss_score": 0.00944, "epss_percentile": 0.75788}, "CVE-2019-7249": {"epss_score": 0.01998, "epss_percentile": 0.83208}, "CVE-2019-7250": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-7251": {"epss_score": 0.04411, "epss_percentile": 0.88661}, "CVE-2019-7252": {"epss_score": 0.00402, "epss_percentile": 0.60294}, "CVE-2019-7253": {"epss_score": 0.00895, "epss_percentile": 0.7511}, "CVE-2019-7254": {"epss_score": 0.90623, "epss_percentile": 0.99592}, "CVE-2019-7255": {"epss_score": 0.58012, "epss_percentile": 0.98095}, "CVE-2019-7256": {"epss_score": 0.94406, "epss_percentile": 0.99973}, "CVE-2019-7257": {"epss_score": 0.37714, "epss_percentile": 0.97064}, "CVE-2019-7258": {"epss_score": 0.04605, "epss_percentile": 0.88908}, "CVE-2019-7259": {"epss_score": 0.00111, "epss_percentile": 0.30322}, "CVE-2019-7260": {"epss_score": 0.00476, "epss_percentile": 0.64269}, "CVE-2019-7261": {"epss_score": 0.00999, "epss_percentile": 0.76478}, "CVE-2019-7262": {"epss_score": 0.39547, "epss_percentile": 0.97167}, "CVE-2019-7263": {"epss_score": 0.00403, "epss_percentile": 0.6032}, "CVE-2019-7264": {"epss_score": 0.00424, "epss_percentile": 0.61683}, "CVE-2019-7265": {"epss_score": 0.42224, "epss_percentile": 0.97319}, "CVE-2019-7266": {"epss_score": 0.03906, "epss_percentile": 0.87926}, "CVE-2019-7267": {"epss_score": 0.01659, "epss_percentile": 0.81612}, "CVE-2019-7268": {"epss_score": 0.01016, "epss_percentile": 0.76671}, "CVE-2019-7269": {"epss_score": 0.19802, "epss_percentile": 0.95244}, "CVE-2019-7270": {"epss_score": 0.00151, "epss_percentile": 0.36326}, "CVE-2019-7271": {"epss_score": 0.00356, "epss_percentile": 0.57352}, "CVE-2019-7272": {"epss_score": 0.15727, "epss_percentile": 0.94494}, "CVE-2019-7273": {"epss_score": 0.00949, "epss_percentile": 0.75848}, "CVE-2019-7274": {"epss_score": 0.65714, "epss_percentile": 0.98435}, "CVE-2019-7275": {"epss_score": 0.6577, "epss_percentile": 0.98438}, "CVE-2019-7276": {"epss_score": 0.91771, "epss_percentile": 0.99667}, "CVE-2019-7277": {"epss_score": 0.00667, "epss_percentile": 0.70722}, "CVE-2019-7278": {"epss_score": 0.00436, "epss_percentile": 0.62488}, "CVE-2019-7279": {"epss_score": 0.00314, "epss_percentile": 0.54155}, "CVE-2019-7280": {"epss_score": 0.0126, "epss_percentile": 0.78968}, "CVE-2019-7281": {"epss_score": 0.0028, "epss_percentile": 0.51003}, "CVE-2019-7282": {"epss_score": 0.00829, "epss_percentile": 0.74015}, "CVE-2019-7283": {"epss_score": 0.00191, "epss_percentile": 0.41277}, "CVE-2019-7284": {"epss_score": 0.00351, "epss_percentile": 0.57031}, "CVE-2019-7285": {"epss_score": 0.0128, "epss_percentile": 0.79142}, "CVE-2019-7286": {"epss_score": 0.02022, "epss_percentile": 0.833}, "CVE-2019-7287": {"epss_score": 0.0456, "epss_percentile": 0.88851}, "CVE-2019-7288": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2019-7289": {"epss_score": 0.00121, "epss_percentile": 0.31882}, "CVE-2019-7290": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2019-7291": {"epss_score": 0.0039, "epss_percentile": 0.5955}, "CVE-2019-7292": {"epss_score": 0.00627, "epss_percentile": 0.6964}, "CVE-2019-7293": {"epss_score": 0.00174, "epss_percentile": 0.39164}, "CVE-2019-7295": {"epss_score": 0.00906, "epss_percentile": 0.75255}, "CVE-2019-7296": {"epss_score": 0.00906, "epss_percentile": 0.75255}, "CVE-2019-7297": {"epss_score": 0.21272, "epss_percentile": 0.95492}, "CVE-2019-7298": {"epss_score": 0.39849, "epss_percentile": 0.97182}, "CVE-2019-7299": {"epss_score": 0.0027, "epss_percentile": 0.50258}, "CVE-2019-7300": {"epss_score": 0.02722, "epss_percentile": 0.85519}, "CVE-2019-7301": {"epss_score": 0.0277, "epss_percentile": 0.85617}, "CVE-2019-7303": {"epss_score": 0.01122, "epss_percentile": 0.77782}, "CVE-2019-7304": {"epss_score": 0.82702, "epss_percentile": 0.99209}, "CVE-2019-7305": {"epss_score": 0.01166, "epss_percentile": 0.7818}, "CVE-2019-7306": {"epss_score": 0.00524, "epss_percentile": 0.66327}, "CVE-2019-7307": {"epss_score": 0.00019, "epss_percentile": 0.04079}, "CVE-2019-7308": {"epss_score": 0.00027, "epss_percentile": 0.07106}, "CVE-2019-7309": {"epss_score": 0.00217, "epss_percentile": 0.44304}, "CVE-2019-7310": {"epss_score": 0.003, "epss_percentile": 0.52914}, "CVE-2019-7311": {"epss_score": 0.00012, "epss_percentile": 0.0114}, "CVE-2019-7312": {"epss_score": 0.00209, "epss_percentile": 0.43415}, "CVE-2019-7313": {"epss_score": 0.00209, "epss_percentile": 0.43398}, "CVE-2019-7314": {"epss_score": 0.02638, "epss_percentile": 0.85297}, "CVE-2019-7315": {"epss_score": 0.61225, "epss_percentile": 0.9824}, "CVE-2019-7316": {"epss_score": 0.00347, "epss_percentile": 0.56767}, "CVE-2019-7317": {"epss_score": 0.00565, "epss_percentile": 0.67786}, "CVE-2019-7319": {"epss_score": 0.0059, "epss_percentile": 0.68558}, "CVE-2019-7321": {"epss_score": 0.02615, "epss_percentile": 0.85246}, "CVE-2019-7323": {"epss_score": 0.00245, "epss_percentile": 0.47635}, "CVE-2019-7324": {"epss_score": 0.00285, "epss_percentile": 0.51682}, "CVE-2019-7325": {"epss_score": 0.00112, "epss_percentile": 0.30506}, "CVE-2019-7326": {"epss_score": 0.00112, "epss_percentile": 0.30506}, "CVE-2019-7327": {"epss_score": 0.00122, "epss_percentile": 0.3216}, "CVE-2019-7328": {"epss_score": 0.00122, "epss_percentile": 0.3216}, "CVE-2019-7329": {"epss_score": 0.00144, "epss_percentile": 0.35316}, "CVE-2019-7330": {"epss_score": 0.00122, "epss_percentile": 0.3216}, "CVE-2019-7331": {"epss_score": 0.00112, "epss_percentile": 0.30506}, "CVE-2019-7332": {"epss_score": 0.00122, "epss_percentile": 0.3216}, "CVE-2019-7333": {"epss_score": 0.00358, "epss_percentile": 0.57534}, "CVE-2019-7334": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-7335": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-7336": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-7337": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2019-7338": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-7339": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-7340": {"epss_score": 0.00358, "epss_percentile": 0.57534}, "CVE-2019-7341": {"epss_score": 0.00358, "epss_percentile": 0.57534}, "CVE-2019-7342": {"epss_score": 0.00328, "epss_percentile": 0.55161}, "CVE-2019-7343": {"epss_score": 0.00358, "epss_percentile": 0.57534}, "CVE-2019-7344": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-7345": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-7346": {"epss_score": 0.00177, "epss_percentile": 0.39535}, "CVE-2019-7347": {"epss_score": 0.00534, "epss_percentile": 0.66778}, "CVE-2019-7348": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-7349": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-7350": {"epss_score": 0.00313, "epss_percentile": 0.54053}, "CVE-2019-7351": {"epss_score": 0.00252, "epss_percentile": 0.48354}, "CVE-2019-7352": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-7353": {"epss_score": 0.00142, "epss_percentile": 0.34967}, "CVE-2019-7356": {"epss_score": 0.00251, "epss_percentile": 0.48304}, "CVE-2019-7357": {"epss_score": 0.01618, "epss_percentile": 0.8137}, "CVE-2019-7358": {"epss_score": 0.00853, "epss_percentile": 0.74433}, "CVE-2019-7359": {"epss_score": 0.0075, "epss_percentile": 0.72622}, "CVE-2019-7360": {"epss_score": 0.00678, "epss_percentile": 0.70981}, "CVE-2019-7361": {"epss_score": 0.00361, "epss_percentile": 0.57715}, "CVE-2019-7362": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2019-7363": {"epss_score": 0.00515, "epss_percentile": 0.65975}, "CVE-2019-7364": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2019-7365": {"epss_score": 0.00068, "epss_percentile": 0.21237}, "CVE-2019-7366": {"epss_score": 0.00157, "epss_percentile": 0.37085}, "CVE-2019-7383": {"epss_score": 0.00403, "epss_percentile": 0.60339}, "CVE-2019-7384": {"epss_score": 0.00365, "epss_percentile": 0.57963}, "CVE-2019-7385": {"epss_score": 0.0514, "epss_percentile": 0.89538}, "CVE-2019-7386": {"epss_score": 0.02608, "epss_percentile": 0.8523}, "CVE-2019-7387": {"epss_score": 0.00392, "epss_percentile": 0.59668}, "CVE-2019-7388": {"epss_score": 0.01814, "epss_percentile": 0.8238}, "CVE-2019-7389": {"epss_score": 0.03727, "epss_percentile": 0.87635}, "CVE-2019-7390": {"epss_score": 0.01227, "epss_percentile": 0.78702}, "CVE-2019-7391": {"epss_score": 0.00799, "epss_percentile": 0.73525}, "CVE-2019-7392": {"epss_score": 0.00449, "epss_percentile": 0.63052}, "CVE-2019-7393": {"epss_score": 0.01452, "epss_percentile": 0.80366}, "CVE-2019-7394": {"epss_score": 0.0217, "epss_percentile": 0.83868}, "CVE-2019-7395": {"epss_score": 0.03348, "epss_percentile": 0.86955}, "CVE-2019-7396": {"epss_score": 0.03348, "epss_percentile": 0.86955}, "CVE-2019-7397": {"epss_score": 0.00282, "epss_percentile": 0.51276}, "CVE-2019-7398": {"epss_score": 0.00239, "epss_percentile": 0.4693}, "CVE-2019-7399": {"epss_score": 0.0024, "epss_percentile": 0.47228}, "CVE-2019-7400": {"epss_score": 0.07, "epss_percentile": 0.91174}, "CVE-2019-7401": {"epss_score": 0.03359, "epss_percentile": 0.86989}, "CVE-2019-7402": {"epss_score": 0.00154, "epss_percentile": 0.36674}, "CVE-2019-7403": {"epss_score": 0.00341, "epss_percentile": 0.56311}, "CVE-2019-7404": {"epss_score": 0.00805, "epss_percentile": 0.73636}, "CVE-2019-7409": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2019-7410": {"epss_score": 0.00528, "epss_percentile": 0.66572}, "CVE-2019-7411": {"epss_score": 0.00116, "epss_percentile": 0.3115}, "CVE-2019-7412": {"epss_score": 0.00841, "epss_percentile": 0.74226}, "CVE-2019-7413": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2019-7416": {"epss_score": 0.00279, "epss_percentile": 0.50983}, "CVE-2019-7417": {"epss_score": 0.00334, "epss_percentile": 0.5572}, "CVE-2019-7418": {"epss_score": 0.00555, "epss_percentile": 0.67489}, "CVE-2019-7419": {"epss_score": 0.00555, "epss_percentile": 0.67489}, "CVE-2019-7420": {"epss_score": 0.00555, "epss_percentile": 0.67489}, "CVE-2019-7421": {"epss_score": 0.00555, "epss_percentile": 0.67489}, "CVE-2019-7422": {"epss_score": 0.01257, "epss_percentile": 0.78948}, "CVE-2019-7423": {"epss_score": 0.01257, "epss_percentile": 0.78948}, "CVE-2019-7424": {"epss_score": 0.01257, "epss_percentile": 0.78948}, "CVE-2019-7425": {"epss_score": 0.01257, "epss_percentile": 0.78948}, "CVE-2019-7426": {"epss_score": 0.01562, "epss_percentile": 0.81045}, "CVE-2019-7427": {"epss_score": 0.01562, "epss_percentile": 0.81045}, "CVE-2019-7429": {"epss_score": 0.00397, "epss_percentile": 0.60039}, "CVE-2019-7430": {"epss_score": 0.00238, "epss_percentile": 0.46811}, "CVE-2019-7431": {"epss_score": 0.00397, "epss_percentile": 0.60039}, "CVE-2019-7432": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-7433": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-7434": {"epss_score": 0.00397, "epss_percentile": 0.60039}, "CVE-2019-7435": {"epss_score": 0.00238, "epss_percentile": 0.46811}, "CVE-2019-7436": {"epss_score": 0.00397, "epss_percentile": 0.60039}, "CVE-2019-7437": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-7438": {"epss_score": 0.07537, "epss_percentile": 0.91523}, "CVE-2019-7439": {"epss_score": 0.15024, "epss_percentile": 0.94347}, "CVE-2019-7440": {"epss_score": 0.00186, "epss_percentile": 0.40634}, "CVE-2019-7441": {"epss_score": 0.0177, "epss_percentile": 0.82191}, "CVE-2019-7442": {"epss_score": 0.1679, "epss_percentile": 0.94732}, "CVE-2019-7443": {"epss_score": 0.01661, "epss_percentile": 0.81627}, "CVE-2019-7474": {"epss_score": 0.0022, "epss_percentile": 0.44589}, "CVE-2019-7475": {"epss_score": 0.00249, "epss_percentile": 0.48008}, "CVE-2019-7476": {"epss_score": 0.00447, "epss_percentile": 0.62941}, "CVE-2019-7477": {"epss_score": 0.00196, "epss_percentile": 0.41762}, "CVE-2019-7478": {"epss_score": 0.0057, "epss_percentile": 0.67948}, "CVE-2019-7479": {"epss_score": 0.00245, "epss_percentile": 0.47667}, "CVE-2019-7481": {"epss_score": 0.9438, "epss_percentile": 0.99964}, "CVE-2019-7482": {"epss_score": 0.64583, "epss_percentile": 0.98384}, "CVE-2019-7483": {"epss_score": 0.33986, "epss_percentile": 0.96819}, "CVE-2019-7484": {"epss_score": 0.00476, "epss_percentile": 0.64277}, "CVE-2019-7485": {"epss_score": 0.00667, "epss_percentile": 0.70698}, "CVE-2019-7486": {"epss_score": 0.00683, "epss_percentile": 0.71101}, "CVE-2019-7487": {"epss_score": 0.00038, "epss_percentile": 0.11156}, "CVE-2019-7488": {"epss_score": 0.00503, "epss_percentile": 0.65465}, "CVE-2019-7489": {"epss_score": 0.21072, "epss_percentile": 0.9546}, "CVE-2019-7524": {"epss_score": 0.00029, "epss_percentile": 0.07859}, "CVE-2019-7535": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2019-7537": {"epss_score": 0.03539, "epss_percentile": 0.87315}, "CVE-2019-7539": {"epss_score": 0.00281, "epss_percentile": 0.51136}, "CVE-2019-7541": {"epss_score": 0.02244, "epss_percentile": 0.84123}, "CVE-2019-7543": {"epss_score": 0.02849, "epss_percentile": 0.85826}, "CVE-2019-7544": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-7545": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-7546": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-7547": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-7548": {"epss_score": 0.01088, "epss_percentile": 0.77438}, "CVE-2019-7549": {"epss_score": 0.00131, "epss_percentile": 0.33356}, "CVE-2019-7550": {"epss_score": 0.00374, "epss_percentile": 0.58556}, "CVE-2019-7551": {"epss_score": 0.0041, "epss_percentile": 0.60799}, "CVE-2019-7552": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-7553": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-7554": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2019-7559": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2019-7560": {"epss_score": 0.0021, "epss_percentile": 0.43432}, "CVE-2019-7564": {"epss_score": 0.05119, "epss_percentile": 0.89517}, "CVE-2019-7566": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2019-7567": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-7568": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-7569": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-7570": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2019-7572": {"epss_score": 0.07118, "epss_percentile": 0.91262}, "CVE-2019-7573": {"epss_score": 0.07672, "epss_percentile": 0.91616}, "CVE-2019-7574": {"epss_score": 0.07672, "epss_percentile": 0.91616}, "CVE-2019-7575": {"epss_score": 0.02617, "epss_percentile": 0.8525}, "CVE-2019-7576": {"epss_score": 0.05566, "epss_percentile": 0.9}, "CVE-2019-7577": {"epss_score": 0.07672, "epss_percentile": 0.91616}, "CVE-2019-7578": {"epss_score": 0.07025, "epss_percentile": 0.91195}, "CVE-2019-7579": {"epss_score": 0.01444, "epss_percentile": 0.80319}, "CVE-2019-7580": {"epss_score": 0.58651, "epss_percentile": 0.9813}, "CVE-2019-7581": {"epss_score": 0.005, "epss_percentile": 0.65301}, "CVE-2019-7582": {"epss_score": 0.005, "epss_percentile": 0.65301}, "CVE-2019-7585": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-7587": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-7588": {"epss_score": 0.00278, "epss_percentile": 0.50894}, "CVE-2019-7589": {"epss_score": 0.00268, "epss_percentile": 0.50068}, "CVE-2019-7590": {"epss_score": 0.00105, "epss_percentile": 0.29349}, "CVE-2019-7593": {"epss_score": 0.00111, "epss_percentile": 0.30299}, "CVE-2019-7594": {"epss_score": 0.00111, "epss_percentile": 0.30299}, "CVE-2019-7608": {"epss_score": 0.0052, "epss_percentile": 0.66198}, "CVE-2019-7609": {"epss_score": 0.94446, "epss_percentile": 0.9999}, "CVE-2019-7610": {"epss_score": 0.01098, "epss_percentile": 0.77543}, "CVE-2019-7611": {"epss_score": 0.00713, "epss_percentile": 0.71791}, "CVE-2019-7612": {"epss_score": 0.00467, "epss_percentile": 0.63817}, "CVE-2019-7613": {"epss_score": 0.00179, "epss_percentile": 0.39855}, "CVE-2019-7614": {"epss_score": 0.00247, "epss_percentile": 0.47899}, "CVE-2019-7615": {"epss_score": 0.00136, "epss_percentile": 0.34151}, "CVE-2019-7616": {"epss_score": 0.09087, "epss_percentile": 0.92395}, "CVE-2019-7617": {"epss_score": 0.00211, "epss_percentile": 0.43685}, "CVE-2019-7618": {"epss_score": 0.00214, "epss_percentile": 0.43977}, "CVE-2019-7619": {"epss_score": 0.01601, "epss_percentile": 0.81267}, "CVE-2019-7620": {"epss_score": 0.01406, "epss_percentile": 0.80051}, "CVE-2019-7621": {"epss_score": 0.00349, "epss_percentile": 0.56901}, "CVE-2019-7628": {"epss_score": 0.00208, "epss_percentile": 0.43227}, "CVE-2019-7629": {"epss_score": 0.06578, "epss_percentile": 0.90859}, "CVE-2019-7630": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2019-7632": {"epss_score": 0.05425, "epss_percentile": 0.89866}, "CVE-2019-7634": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2019-7635": {"epss_score": 0.09085, "epss_percentile": 0.92394}, "CVE-2019-7636": {"epss_score": 0.07025, "epss_percentile": 0.91195}, "CVE-2019-7637": {"epss_score": 0.04094, "epss_percentile": 0.88245}, "CVE-2019-7638": {"epss_score": 0.07118, "epss_percentile": 0.91262}, "CVE-2019-7639": {"epss_score": 0.0035, "epss_percentile": 0.56951}, "CVE-2019-7642": {"epss_score": 0.1087, "epss_percentile": 0.93141}, "CVE-2019-7644": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2019-7646": {"epss_score": 0.00404, "epss_percentile": 0.60446}, "CVE-2019-7648": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2019-7649": {"epss_score": 0.00124, "epss_percentile": 0.32342}, "CVE-2019-7651": {"epss_score": 0.04197, "epss_percentile": 0.88382}, "CVE-2019-7652": {"epss_score": 0.03271, "epss_percentile": 0.86795}, "CVE-2019-7653": {"epss_score": 0.01041, "epss_percentile": 0.76962}, "CVE-2019-7654": {"epss_score": 0.00574, "epss_percentile": 0.68072}, "CVE-2019-7655": {"epss_score": 0.00654, "epss_percentile": 0.70348}, "CVE-2019-7656": {"epss_score": 0.00085, "epss_percentile": 0.25153}, "CVE-2019-7659": {"epss_score": 0.00666, "epss_percentile": 0.7068}, "CVE-2019-7660": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-7661": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-7662": {"epss_score": 0.004, "epss_percentile": 0.6018}, "CVE-2019-7663": {"epss_score": 0.00698, "epss_percentile": 0.71417}, "CVE-2019-7664": {"epss_score": 0.00358, "epss_percentile": 0.57509}, "CVE-2019-7665": {"epss_score": 0.00141, "epss_percentile": 0.34825}, "CVE-2019-7666": {"epss_score": 0.20132, "epss_percentile": 0.95291}, "CVE-2019-7667": {"epss_score": 0.03717, "epss_percentile": 0.87613}, "CVE-2019-7668": {"epss_score": 0.00345, "epss_percentile": 0.56564}, "CVE-2019-7669": {"epss_score": 0.10051, "epss_percentile": 0.92828}, "CVE-2019-7670": {"epss_score": 0.27173, "epss_percentile": 0.96216}, "CVE-2019-7671": {"epss_score": 0.13715, "epss_percentile": 0.94041}, "CVE-2019-7672": {"epss_score": 0.01101, "epss_percentile": 0.77573}, "CVE-2019-7673": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2019-7674": {"epss_score": 0.00412, "epss_percentile": 0.60919}, "CVE-2019-7675": {"epss_score": 0.00231, "epss_percentile": 0.45856}, "CVE-2019-7676": {"epss_score": 0.00407, "epss_percentile": 0.60589}, "CVE-2019-7677": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-7678": {"epss_score": 0.00762, "epss_percentile": 0.72833}, "CVE-2019-7684": {"epss_score": 0.00715, "epss_percentile": 0.71849}, "CVE-2019-7687": {"epss_score": 0.00839, "epss_percentile": 0.74194}, "CVE-2019-7690": {"epss_score": 0.00456, "epss_percentile": 0.63336}, "CVE-2019-7692": {"epss_score": 0.00994, "epss_percentile": 0.76426}, "CVE-2019-7693": {"epss_score": 0.00266, "epss_percentile": 0.49856}, "CVE-2019-7697": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2019-7698": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2019-7699": {"epss_score": 0.00388, "epss_percentile": 0.5936}, "CVE-2019-7700": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2019-7701": {"epss_score": 0.00311, "epss_percentile": 0.53846}, "CVE-2019-7702": {"epss_score": 0.00312, "epss_percentile": 0.53966}, "CVE-2019-7703": {"epss_score": 0.00494, "epss_percentile": 0.65071}, "CVE-2019-7704": {"epss_score": 0.00311, "epss_percentile": 0.53846}, "CVE-2019-7711": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-7712": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-7713": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2019-7714": {"epss_score": 0.00742, "epss_percentile": 0.72457}, "CVE-2019-7715": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-7718": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2019-7719": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2019-7720": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2019-7721": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-7722": {"epss_score": 0.00451, "epss_percentile": 0.63154}, "CVE-2019-7725": {"epss_score": 0.00681, "epss_percentile": 0.71055}, "CVE-2019-7726": {"epss_score": 0.00743, "epss_percentile": 0.72477}, "CVE-2019-7727": {"epss_score": 0.02505, "epss_percentile": 0.84935}, "CVE-2019-7728": {"epss_score": 0.00163, "epss_percentile": 0.37845}, "CVE-2019-7729": {"epss_score": 0.00035, "epss_percentile": 0.10003}, "CVE-2019-7730": {"epss_score": 0.00096, "epss_percentile": 0.27261}, "CVE-2019-7731": {"epss_score": 0.02808, "epss_percentile": 0.85712}, "CVE-2019-7732": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2019-7733": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2019-7736": {"epss_score": 0.0103, "epss_percentile": 0.76846}, "CVE-2019-7737": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-7738": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2019-7739": {"epss_score": 0.00074, "epss_percentile": 0.22872}, "CVE-2019-7740": {"epss_score": 0.00163, "epss_percentile": 0.37767}, "CVE-2019-7741": {"epss_score": 0.00069, "epss_percentile": 0.21541}, "CVE-2019-7742": {"epss_score": 0.00142, "epss_percentile": 0.34966}, "CVE-2019-7743": {"epss_score": 0.01449, "epss_percentile": 0.80343}, "CVE-2019-7744": {"epss_score": 0.00163, "epss_percentile": 0.37767}, "CVE-2019-7745": {"epss_score": 0.03525, "epss_percentile": 0.87294}, "CVE-2019-7746": {"epss_score": 0.0032, "epss_percentile": 0.54586}, "CVE-2019-7747": {"epss_score": 0.00441, "epss_percentile": 0.62682}, "CVE-2019-7748": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-7751": {"epss_score": 0.12732, "epss_percentile": 0.9376}, "CVE-2019-7753": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-7755": {"epss_score": 0.00621, "epss_percentile": 0.69485}, "CVE-2019-7758": {"epss_score": 0.09739, "epss_percentile": 0.92686}, "CVE-2019-7759": {"epss_score": 0.07011, "epss_percentile": 0.91184}, "CVE-2019-7760": {"epss_score": 0.07011, "epss_percentile": 0.91184}, "CVE-2019-7761": {"epss_score": 0.07607, "epss_percentile": 0.91565}, "CVE-2019-7762": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7763": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7764": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7765": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7766": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7767": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7768": {"epss_score": 0.17198, "epss_percentile": 0.94797}, "CVE-2019-7769": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7770": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7771": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7772": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7773": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7774": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7775": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7776": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7777": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7778": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7779": {"epss_score": 0.09056, "epss_percentile": 0.92382}, "CVE-2019-7780": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7781": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7782": {"epss_score": 0.17198, "epss_percentile": 0.94797}, "CVE-2019-7783": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7784": {"epss_score": 0.05456, "epss_percentile": 0.89896}, "CVE-2019-7785": {"epss_score": 0.11534, "epss_percentile": 0.93398}, "CVE-2019-7786": {"epss_score": 0.07011, "epss_percentile": 0.91184}, "CVE-2019-7787": {"epss_score": 0.09739, "epss_percentile": 0.92686}, "CVE-2019-7788": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7789": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7790": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7791": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7792": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7793": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7794": {"epss_score": 0.09739, "epss_percentile": 0.92686}, "CVE-2019-7795": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7796": {"epss_score": 0.07011, "epss_percentile": 0.91184}, "CVE-2019-7797": {"epss_score": 0.02933, "epss_percentile": 0.8602}, "CVE-2019-7798": {"epss_score": 0.1231, "epss_percentile": 0.93632}, "CVE-2019-7799": {"epss_score": 0.09739, "epss_percentile": 0.92686}, "CVE-2019-7800": {"epss_score": 0.06488, "epss_percentile": 0.90793}, "CVE-2019-7801": {"epss_score": 0.09739, "epss_percentile": 0.92686}, "CVE-2019-7802": {"epss_score": 0.09739, "epss_percentile": 0.92686}, "CVE-2019-7803": {"epss_score": 0.09739, "epss_percentile": 0.92686}, "CVE-2019-7804": {"epss_score": 0.04197, "epss_percentile": 0.88382}, "CVE-2019-7805": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7806": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7807": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7808": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7809": {"epss_score": 0.07311, "epss_percentile": 0.91402}, "CVE-2019-7810": {"epss_score": 0.09739, "epss_percentile": 0.92686}, "CVE-2019-7811": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7812": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7813": {"epss_score": 0.02667, "epss_percentile": 0.85378}, "CVE-2019-7814": {"epss_score": 0.07011, "epss_percentile": 0.91184}, "CVE-2019-7815": {"epss_score": 0.04063, "epss_percentile": 0.88192}, "CVE-2019-7816": {"epss_score": 0.04339, "epss_percentile": 0.88567}, "CVE-2019-7817": {"epss_score": 0.07011, "epss_percentile": 0.91184}, "CVE-2019-7818": {"epss_score": 0.06488, "epss_percentile": 0.90793}, "CVE-2019-7819": {"epss_score": 0.00015, "epss_percentile": 0.02287}, "CVE-2019-7820": {"epss_score": 0.19285, "epss_percentile": 0.9516}, "CVE-2019-7821": {"epss_score": 0.07311, "epss_percentile": 0.91402}, "CVE-2019-7822": {"epss_score": 0.06488, "epss_percentile": 0.90793}, "CVE-2019-7823": {"epss_score": 0.07311, "epss_percentile": 0.91402}, "CVE-2019-7824": {"epss_score": 0.14763, "epss_percentile": 0.94277}, "CVE-2019-7825": {"epss_score": 0.06488, "epss_percentile": 0.90793}, "CVE-2019-7826": {"epss_score": 0.1231, "epss_percentile": 0.93632}, "CVE-2019-7827": {"epss_score": 0.05041, "epss_percentile": 0.89427}, "CVE-2019-7828": {"epss_score": 0.05041, "epss_percentile": 0.89427}, "CVE-2019-7829": {"epss_score": 0.06488, "epss_percentile": 0.90793}, "CVE-2019-7830": {"epss_score": 0.07011, "epss_percentile": 0.91184}, "CVE-2019-7831": {"epss_score": 0.0881, "epss_percentile": 0.92264}, "CVE-2019-7832": {"epss_score": 0.079, "epss_percentile": 0.91753}, "CVE-2019-7833": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7834": {"epss_score": 0.06602, "epss_percentile": 0.90879}, "CVE-2019-7835": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2019-7836": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7837": {"epss_score": 0.01421, "epss_percentile": 0.80174}, "CVE-2019-7838": {"epss_score": 0.30353, "epss_percentile": 0.96533}, "CVE-2019-7839": {"epss_score": 0.46366, "epss_percentile": 0.97542}, "CVE-2019-7840": {"epss_score": 0.49528, "epss_percentile": 0.97693}, "CVE-2019-7841": {"epss_score": 0.02898, "epss_percentile": 0.85934}, "CVE-2019-7842": {"epss_score": 0.10289, "epss_percentile": 0.92929}, "CVE-2019-7843": {"epss_score": 0.0446, "epss_percentile": 0.88721}, "CVE-2019-7844": {"epss_score": 0.10806, "epss_percentile": 0.93109}, "CVE-2019-7845": {"epss_score": 0.10976, "epss_percentile": 0.93181}, "CVE-2019-7846": {"epss_score": 0.0446, "epss_percentile": 0.88721}, "CVE-2019-7847": {"epss_score": 0.01153, "epss_percentile": 0.78061}, "CVE-2019-7848": {"epss_score": 0.0446, "epss_percentile": 0.88721}, "CVE-2019-7849": {"epss_score": 0.00048, "epss_percentile": 0.14951}, "CVE-2019-7850": {"epss_score": 0.11567, "epss_percentile": 0.93406}, "CVE-2019-7851": {"epss_score": 0.0003, "epss_percentile": 0.08145}, "CVE-2019-7852": {"epss_score": 0.00059, "epss_percentile": 0.18686}, "CVE-2019-7853": {"epss_score": 0.0008, "epss_percentile": 0.24065}, "CVE-2019-7854": {"epss_score": 0.00086, "epss_percentile": 0.2538}, "CVE-2019-7855": {"epss_score": 0.00238, "epss_percentile": 0.46739}, "CVE-2019-7857": {"epss_score": 0.00032, "epss_percentile": 0.08834}, "CVE-2019-7858": {"epss_score": 0.00047, "epss_percentile": 0.14777}, "CVE-2019-7859": {"epss_score": 0.00139, "epss_percentile": 0.34559}, "CVE-2019-7860": {"epss_score": 0.00101, "epss_percentile": 0.28587}, "CVE-2019-7861": {"epss_score": 0.00059, "epss_percentile": 0.18686}, "CVE-2019-7862": {"epss_score": 0.0008, "epss_percentile": 0.24091}, "CVE-2019-7863": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7864": {"epss_score": 0.0006, "epss_percentile": 0.19085}, "CVE-2019-7865": {"epss_score": 0.00059, "epss_percentile": 0.18902}, "CVE-2019-7866": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7867": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7868": {"epss_score": 0.00069, "epss_percentile": 0.21601}, "CVE-2019-7869": {"epss_score": 0.00069, "epss_percentile": 0.21601}, "CVE-2019-7870": {"epss_score": 0.07872, "epss_percentile": 0.91737}, "CVE-2019-7871": {"epss_score": 0.00211, "epss_percentile": 0.43667}, "CVE-2019-7872": {"epss_score": 0.00092, "epss_percentile": 0.26525}, "CVE-2019-7873": {"epss_score": 0.00028, "epss_percentile": 0.07277}, "CVE-2019-7874": {"epss_score": 0.00032, "epss_percentile": 0.08834}, "CVE-2019-7875": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7876": {"epss_score": 0.00841, "epss_percentile": 0.7423}, "CVE-2019-7877": {"epss_score": 0.00068, "epss_percentile": 0.2123}, "CVE-2019-7880": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7881": {"epss_score": 0.00086, "epss_percentile": 0.25306}, "CVE-2019-7882": {"epss_score": 0.00086, "epss_percentile": 0.25306}, "CVE-2019-7885": {"epss_score": 0.00632, "epss_percentile": 0.69737}, "CVE-2019-7886": {"epss_score": 0.00101, "epss_percentile": 0.28587}, "CVE-2019-7887": {"epss_score": 0.0008, "epss_percentile": 0.24091}, "CVE-2019-7888": {"epss_score": 0.00112, "epss_percentile": 0.30567}, "CVE-2019-7889": {"epss_score": 0.00081, "epss_percentile": 0.24338}, "CVE-2019-7890": {"epss_score": 0.00086, "epss_percentile": 0.25366}, "CVE-2019-7892": {"epss_score": 0.00826, "epss_percentile": 0.73975}, "CVE-2019-7895": {"epss_score": 0.00897, "epss_percentile": 0.75132}, "CVE-2019-7896": {"epss_score": 0.00897, "epss_percentile": 0.75132}, "CVE-2019-7897": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7898": {"epss_score": 0.00059, "epss_percentile": 0.18686}, "CVE-2019-7899": {"epss_score": 0.00059, "epss_percentile": 0.18686}, "CVE-2019-7903": {"epss_score": 0.0092, "epss_percentile": 0.75469}, "CVE-2019-7904": {"epss_score": 0.00057, "epss_percentile": 0.18155}, "CVE-2019-7908": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7909": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7911": {"epss_score": 0.00329, "epss_percentile": 0.55388}, "CVE-2019-7912": {"epss_score": 0.0033, "epss_percentile": 0.55483}, "CVE-2019-7913": {"epss_score": 0.00254, "epss_percentile": 0.48511}, "CVE-2019-7915": {"epss_score": 0.00348, "epss_percentile": 0.56829}, "CVE-2019-7921": {"epss_score": 0.00086, "epss_percentile": 0.25306}, "CVE-2019-7923": {"epss_score": 0.00254, "epss_percentile": 0.48511}, "CVE-2019-7925": {"epss_score": 0.00047, "epss_percentile": 0.14671}, "CVE-2019-7926": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7927": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7928": {"epss_score": 0.00348, "epss_percentile": 0.56829}, "CVE-2019-7929": {"epss_score": 0.00061, "epss_percentile": 0.19526}, "CVE-2019-7930": {"epss_score": 0.00398, "epss_percentile": 0.60068}, "CVE-2019-7931": {"epss_score": 0.01497, "epss_percentile": 0.80693}, "CVE-2019-7932": {"epss_score": 0.00897, "epss_percentile": 0.75132}, "CVE-2019-7934": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7935": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7936": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7937": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7938": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2019-7939": {"epss_score": 0.00127, "epss_percentile": 0.32843}, "CVE-2019-7940": {"epss_score": 0.0008, "epss_percentile": 0.24065}, "CVE-2019-7941": {"epss_score": 0.0446, "epss_percentile": 0.88721}, "CVE-2019-7942": {"epss_score": 0.00897, "epss_percentile": 0.75132}, "CVE-2019-7944": {"epss_score": 0.00075, "epss_percentile": 0.22908}, "CVE-2019-7945": {"epss_score": 0.00086, "epss_percentile": 0.25306}, "CVE-2019-7947": {"epss_score": 0.00032, "epss_percentile": 0.08834}, "CVE-2019-7950": {"epss_score": 0.00391, "epss_percentile": 0.59613}, "CVE-2019-7951": {"epss_score": 0.00101, "epss_percentile": 0.28587}, "CVE-2019-7953": {"epss_score": 0.01117, "epss_percentile": 0.77723}, "CVE-2019-7954": {"epss_score": 0.01182, "epss_percentile": 0.78316}, "CVE-2019-7955": {"epss_score": 0.00934, "epss_percentile": 0.75647}, "CVE-2019-7956": {"epss_score": 0.01124, "epss_percentile": 0.778}, "CVE-2019-7957": {"epss_score": 0.01407, "epss_percentile": 0.80054}, "CVE-2019-7958": {"epss_score": 0.00782, "epss_percentile": 0.73208}, "CVE-2019-7959": {"epss_score": 0.1772, "epss_percentile": 0.94895}, "CVE-2019-7960": {"epss_score": 0.00289, "epss_percentile": 0.52052}, "CVE-2019-7961": {"epss_score": 0.01635, "epss_percentile": 0.81469}, "CVE-2019-7962": {"epss_score": 0.00302, "epss_percentile": 0.53162}, "CVE-2019-7963": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-7964": {"epss_score": 0.44281, "epss_percentile": 0.97428}, "CVE-2019-7965": {"epss_score": 0.16163, "epss_percentile": 0.94585}, "CVE-2019-7968": {"epss_score": 0.19068, "epss_percentile": 0.95124}, "CVE-2019-7969": {"epss_score": 0.27473, "epss_percentile": 0.96249}, "CVE-2019-7970": {"epss_score": 0.27473, "epss_percentile": 0.96249}, "CVE-2019-7971": {"epss_score": 0.27473, "epss_percentile": 0.96249}, "CVE-2019-7972": {"epss_score": 0.27473, "epss_percentile": 0.96249}, "CVE-2019-7973": {"epss_score": 0.27473, "epss_percentile": 0.96249}, "CVE-2019-7974": {"epss_score": 0.27473, "epss_percentile": 0.96249}, "CVE-2019-7975": {"epss_score": 0.27473, "epss_percentile": 0.96249}, "CVE-2019-7976": {"epss_score": 0.20867, "epss_percentile": 0.9543}, "CVE-2019-7977": {"epss_score": 0.03359, "epss_percentile": 0.86988}, "CVE-2019-7978": {"epss_score": 0.33762, "epss_percentile": 0.96802}, "CVE-2019-7979": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2019-7980": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2019-7981": {"epss_score": 0.03359, "epss_percentile": 0.86988}, "CVE-2019-7982": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2019-7983": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2019-7984": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2019-7985": {"epss_score": 0.33762, "epss_percentile": 0.96802}, "CVE-2019-7986": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2019-7987": {"epss_score": 0.03359, "epss_percentile": 0.86988}, "CVE-2019-7988": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2019-7989": {"epss_score": 0.02371, "epss_percentile": 0.84526}, "CVE-2019-7990": {"epss_score": 0.26365, "epss_percentile": 0.96141}, "CVE-2019-7991": {"epss_score": 0.02022, "epss_percentile": 0.833}, "CVE-2019-7992": {"epss_score": 0.11913, "epss_percentile": 0.93514}, "CVE-2019-7993": {"epss_score": 0.26365, "epss_percentile": 0.96141}, "CVE-2019-7994": {"epss_score": 0.20867, "epss_percentile": 0.9543}, "CVE-2019-7995": {"epss_score": 0.0357, "epss_percentile": 0.87369}, "CVE-2019-7996": {"epss_score": 0.0357, "epss_percentile": 0.87369}, "CVE-2019-7997": {"epss_score": 0.21658, "epss_percentile": 0.95545}, "CVE-2019-7998": {"epss_score": 0.21658, "epss_percentile": 0.95545}, "CVE-2019-7999": {"epss_score": 0.02676, "epss_percentile": 0.85403}, "CVE-2019-8000": {"epss_score": 0.03359, "epss_percentile": 0.86988}, "CVE-2019-8001": {"epss_score": 0.21658, "epss_percentile": 0.95545}, "CVE-2019-8002": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8003": {"epss_score": 0.30099, "epss_percentile": 0.9651}, "CVE-2019-8004": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8005": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8006": {"epss_score": 0.27873, "epss_percentile": 0.9629}, "CVE-2019-8007": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8008": {"epss_score": 0.13552, "epss_percentile": 0.93994}, "CVE-2019-8009": {"epss_score": 0.16163, "epss_percentile": 0.94585}, "CVE-2019-8010": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8011": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8012": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8013": {"epss_score": 0.21743, "epss_percentile": 0.95554}, "CVE-2019-8014": {"epss_score": 0.46202, "epss_percentile": 0.97536}, "CVE-2019-8015": {"epss_score": 0.33243, "epss_percentile": 0.96755}, "CVE-2019-8016": {"epss_score": 0.07289, "epss_percentile": 0.91386}, "CVE-2019-8017": {"epss_score": 0.35342, "epss_percentile": 0.96902}, "CVE-2019-8018": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8019": {"epss_score": 0.11996, "epss_percentile": 0.93541}, "CVE-2019-8020": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8021": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8022": {"epss_score": 0.16163, "epss_percentile": 0.94585}, "CVE-2019-8023": {"epss_score": 0.16163, "epss_percentile": 0.94585}, "CVE-2019-8024": {"epss_score": 0.35342, "epss_percentile": 0.96902}, "CVE-2019-8025": {"epss_score": 0.30099, "epss_percentile": 0.9651}, "CVE-2019-8026": {"epss_score": 0.30099, "epss_percentile": 0.9651}, "CVE-2019-8027": {"epss_score": 0.06634, "epss_percentile": 0.90906}, "CVE-2019-8028": {"epss_score": 0.30099, "epss_percentile": 0.9651}, "CVE-2019-8029": {"epss_score": 0.30099, "epss_percentile": 0.9651}, "CVE-2019-8030": {"epss_score": 0.30099, "epss_percentile": 0.9651}, "CVE-2019-8031": {"epss_score": 0.30099, "epss_percentile": 0.9651}, "CVE-2019-8032": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8033": {"epss_score": 0.24497, "epss_percentile": 0.95927}, "CVE-2019-8034": {"epss_score": 0.24497, "epss_percentile": 0.95927}, "CVE-2019-8035": {"epss_score": 0.02393, "epss_percentile": 0.84611}, "CVE-2019-8036": {"epss_score": 0.30099, "epss_percentile": 0.9651}, "CVE-2019-8037": {"epss_score": 0.02393, "epss_percentile": 0.84611}, "CVE-2019-8038": {"epss_score": 0.17686, "epss_percentile": 0.94888}, "CVE-2019-8039": {"epss_score": 0.15502, "epss_percentile": 0.94441}, "CVE-2019-8040": {"epss_score": 0.03746, "epss_percentile": 0.87663}, "CVE-2019-8041": {"epss_score": 0.39724, "epss_percentile": 0.97177}, "CVE-2019-8042": {"epss_score": 0.39724, "epss_percentile": 0.97177}, "CVE-2019-8043": {"epss_score": 0.06247, "epss_percentile": 0.90606}, "CVE-2019-8044": {"epss_score": 0.37209, "epss_percentile": 0.97027}, "CVE-2019-8045": {"epss_score": 0.42505, "epss_percentile": 0.97334}, "CVE-2019-8046": {"epss_score": 0.39724, "epss_percentile": 0.97177}, "CVE-2019-8047": {"epss_score": 0.30099, "epss_percentile": 0.9651}, "CVE-2019-8048": {"epss_score": 0.09796, "epss_percentile": 0.92706}, "CVE-2019-8049": {"epss_score": 0.41502, "epss_percentile": 0.97278}, "CVE-2019-8050": {"epss_score": 0.31403, "epss_percentile": 0.96618}, "CVE-2019-8051": {"epss_score": 0.11319, "epss_percentile": 0.93306}, "CVE-2019-8052": {"epss_score": 0.02393, "epss_percentile": 0.84611}, "CVE-2019-8053": {"epss_score": 0.11319, "epss_percentile": 0.93306}, "CVE-2019-8054": {"epss_score": 0.11319, "epss_percentile": 0.93306}, "CVE-2019-8055": {"epss_score": 0.30099, "epss_percentile": 0.9651}, "CVE-2019-8056": {"epss_score": 0.11319, "epss_percentile": 0.93306}, "CVE-2019-8057": {"epss_score": 0.21743, "epss_percentile": 0.95554}, "CVE-2019-8058": {"epss_score": 0.11319, "epss_percentile": 0.93306}, "CVE-2019-8059": {"epss_score": 0.11319, "epss_percentile": 0.93306}, "CVE-2019-8060": {"epss_score": 0.11538, "epss_percentile": 0.93398}, "CVE-2019-8061": {"epss_score": 0.30099, "epss_percentile": 0.9651}, "CVE-2019-8062": {"epss_score": 0.01635, "epss_percentile": 0.81469}, "CVE-2019-8063": {"epss_score": 0.03454, "epss_percentile": 0.8717}, "CVE-2019-8064": {"epss_score": 0.01736, "epss_percentile": 0.82016}, "CVE-2019-8066": {"epss_score": 0.28878, "epss_percentile": 0.96397}, "CVE-2019-8069": {"epss_score": 0.03432, "epss_percentile": 0.87125}, "CVE-2019-8070": {"epss_score": 0.0203, "epss_percentile": 0.83331}, "CVE-2019-8071": {"epss_score": 0.0065, "epss_percentile": 0.70246}, "CVE-2019-8072": {"epss_score": 0.0446, "epss_percentile": 0.88721}, "CVE-2019-8073": {"epss_score": 0.14776, "epss_percentile": 0.94281}, "CVE-2019-8074": {"epss_score": 0.07732, "epss_percentile": 0.91649}, "CVE-2019-8075": {"epss_score": 0.01398, "epss_percentile": 0.79992}, "CVE-2019-8076": {"epss_score": 0.07483, "epss_percentile": 0.91497}, "CVE-2019-8077": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8078": {"epss_score": 0.0126, "epss_percentile": 0.78969}, "CVE-2019-8079": {"epss_score": 0.01639, "epss_percentile": 0.81495}, "CVE-2019-8080": {"epss_score": 0.01012, "epss_percentile": 0.76621}, "CVE-2019-8081": {"epss_score": 0.04562, "epss_percentile": 0.88853}, "CVE-2019-8082": {"epss_score": 0.00954, "epss_percentile": 0.75897}, "CVE-2019-8083": {"epss_score": 0.01639, "epss_percentile": 0.81495}, "CVE-2019-8084": {"epss_score": 0.01639, "epss_percentile": 0.81495}, "CVE-2019-8085": {"epss_score": 0.01639, "epss_percentile": 0.81495}, "CVE-2019-8086": {"epss_score": 0.54798, "epss_percentile": 0.97945}, "CVE-2019-8087": {"epss_score": 0.01035, "epss_percentile": 0.76906}, "CVE-2019-8088": {"epss_score": 0.12685, "epss_percentile": 0.93748}, "CVE-2019-8089": {"epss_score": 0.01639, "epss_percentile": 0.81495}, "CVE-2019-8090": {"epss_score": 0.00108, "epss_percentile": 0.29764}, "CVE-2019-8091": {"epss_score": 0.0106, "epss_percentile": 0.77166}, "CVE-2019-8092": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8093": {"epss_score": 0.00201, "epss_percentile": 0.42349}, "CVE-2019-8094": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8095": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8096": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8097": {"epss_score": 0.0286, "epss_percentile": 0.85848}, "CVE-2019-8098": {"epss_score": 0.16163, "epss_percentile": 0.94585}, "CVE-2019-8099": {"epss_score": 0.0446, "epss_percentile": 0.88721}, "CVE-2019-8100": {"epss_score": 0.16163, "epss_percentile": 0.94585}, "CVE-2019-8101": {"epss_score": 0.0446, "epss_percentile": 0.88721}, "CVE-2019-8102": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8103": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8104": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8105": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8106": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2019-8107": {"epss_score": 0.00116, "epss_percentile": 0.311}, "CVE-2019-8108": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2019-8109": {"epss_score": 0.00415, "epss_percentile": 0.61141}, "CVE-2019-8110": {"epss_score": 0.01125, "epss_percentile": 0.77807}, "CVE-2019-8111": {"epss_score": 0.01125, "epss_percentile": 0.77807}, "CVE-2019-8112": {"epss_score": 0.00095, "epss_percentile": 0.27092}, "CVE-2019-8113": {"epss_score": 0.001, "epss_percentile": 0.28513}, "CVE-2019-8114": {"epss_score": 0.01199, "epss_percentile": 0.78463}, "CVE-2019-8115": {"epss_score": 0.02138, "epss_percentile": 0.83736}, "CVE-2019-8116": {"epss_score": 0.00388, "epss_percentile": 0.59351}, "CVE-2019-8117": {"epss_score": 0.00154, "epss_percentile": 0.36685}, "CVE-2019-8118": {"epss_score": 0.00047, "epss_percentile": 0.14642}, "CVE-2019-8119": {"epss_score": 0.01814, "epss_percentile": 0.82378}, "CVE-2019-8120": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8121": {"epss_score": 0.0018, "epss_percentile": 0.39931}, "CVE-2019-8122": {"epss_score": 0.01125, "epss_percentile": 0.77807}, "CVE-2019-8123": {"epss_score": 0.00092, "epss_percentile": 0.26554}, "CVE-2019-8124": {"epss_score": 0.00196, "epss_percentile": 0.41809}, "CVE-2019-8125": {"epss_score": 0.0106, "epss_percentile": 0.77166}, "CVE-2019-8126": {"epss_score": 0.00108, "epss_percentile": 0.29829}, "CVE-2019-8127": {"epss_score": 0.00135, "epss_percentile": 0.34}, "CVE-2019-8128": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8129": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8130": {"epss_score": 0.00133, "epss_percentile": 0.33723}, "CVE-2019-8131": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8132": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8133": {"epss_score": 0.00052, "epss_percentile": 0.16366}, "CVE-2019-8134": {"epss_score": 0.00133, "epss_percentile": 0.33723}, "CVE-2019-8135": {"epss_score": 0.01001, "epss_percentile": 0.76498}, "CVE-2019-8136": {"epss_score": 0.0018, "epss_percentile": 0.39931}, "CVE-2019-8137": {"epss_score": 0.00543, "epss_percentile": 0.67088}, "CVE-2019-8138": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8139": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8140": {"epss_score": 0.00241, "epss_percentile": 0.47324}, "CVE-2019-8141": {"epss_score": 0.01586, "epss_percentile": 0.81177}, "CVE-2019-8142": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8143": {"epss_score": 0.00162, "epss_percentile": 0.37683}, "CVE-2019-8144": {"epss_score": 0.02899, "epss_percentile": 0.85951}, "CVE-2019-8145": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8146": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8147": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8148": {"epss_score": 0.02138, "epss_percentile": 0.83736}, "CVE-2019-8149": {"epss_score": 0.00424, "epss_percentile": 0.61652}, "CVE-2019-8150": {"epss_score": 0.01125, "epss_percentile": 0.77807}, "CVE-2019-8151": {"epss_score": 0.01105, "epss_percentile": 0.77607}, "CVE-2019-8152": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8153": {"epss_score": 0.00056, "epss_percentile": 0.1792}, "CVE-2019-8154": {"epss_score": 0.01125, "epss_percentile": 0.77807}, "CVE-2019-8155": {"epss_score": 0.00065, "epss_percentile": 0.20574}, "CVE-2019-8156": {"epss_score": 0.01105, "epss_percentile": 0.77607}, "CVE-2019-8157": {"epss_score": 0.00177, "epss_percentile": 0.39511}, "CVE-2019-8158": {"epss_score": 0.00187, "epss_percentile": 0.40714}, "CVE-2019-8159": {"epss_score": 0.01627, "epss_percentile": 0.81434}, "CVE-2019-8160": {"epss_score": 0.013, "epss_percentile": 0.79288}, "CVE-2019-8161": {"epss_score": 0.03176, "epss_percentile": 0.8657}, "CVE-2019-8162": {"epss_score": 0.0138, "epss_percentile": 0.79861}, "CVE-2019-8163": {"epss_score": 0.01736, "epss_percentile": 0.82016}, "CVE-2019-8164": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8165": {"epss_score": 0.03162, "epss_percentile": 0.86533}, "CVE-2019-8166": {"epss_score": 0.03955, "epss_percentile": 0.88003}, "CVE-2019-8167": {"epss_score": 0.03176, "epss_percentile": 0.8657}, "CVE-2019-8168": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8169": {"epss_score": 0.03176, "epss_percentile": 0.8657}, "CVE-2019-8170": {"epss_score": 0.06066, "epss_percentile": 0.90448}, "CVE-2019-8171": {"epss_score": 0.03162, "epss_percentile": 0.86533}, "CVE-2019-8172": {"epss_score": 0.01736, "epss_percentile": 0.82016}, "CVE-2019-8173": {"epss_score": 0.01736, "epss_percentile": 0.82016}, "CVE-2019-8174": {"epss_score": 0.03977, "epss_percentile": 0.88049}, "CVE-2019-8175": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8176": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8177": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8178": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8179": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8180": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8181": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8182": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8183": {"epss_score": 0.03128, "epss_percentile": 0.8646}, "CVE-2019-8184": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8185": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8186": {"epss_score": 0.02559, "epss_percentile": 0.85101}, "CVE-2019-8187": {"epss_score": 0.02912, "epss_percentile": 0.85972}, "CVE-2019-8188": {"epss_score": 0.02912, "epss_percentile": 0.85972}, "CVE-2019-8189": {"epss_score": 0.01736, "epss_percentile": 0.82016}, "CVE-2019-8190": {"epss_score": 0.01736, "epss_percentile": 0.82016}, "CVE-2019-8191": {"epss_score": 0.03162, "epss_percentile": 0.86533}, "CVE-2019-8192": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8193": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8194": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8195": {"epss_score": 0.2978, "epss_percentile": 0.96475}, "CVE-2019-8196": {"epss_score": 0.2978, "epss_percentile": 0.96475}, "CVE-2019-8197": {"epss_score": 0.39724, "epss_percentile": 0.97177}, "CVE-2019-8198": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8199": {"epss_score": 0.05645, "epss_percentile": 0.90081}, "CVE-2019-8200": {"epss_score": 0.03176, "epss_percentile": 0.8657}, "CVE-2019-8201": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8202": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8203": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8204": {"epss_score": 0.01795, "epss_percentile": 0.82295}, "CVE-2019-8205": {"epss_score": 0.04124, "epss_percentile": 0.88287}, "CVE-2019-8206": {"epss_score": 0.03299, "epss_percentile": 0.86862}, "CVE-2019-8207": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8208": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8209": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8210": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8211": {"epss_score": 0.0527, "epss_percentile": 0.89678}, "CVE-2019-8212": {"epss_score": 0.0527, "epss_percentile": 0.89678}, "CVE-2019-8213": {"epss_score": 0.0527, "epss_percentile": 0.89678}, "CVE-2019-8214": {"epss_score": 0.0527, "epss_percentile": 0.89678}, "CVE-2019-8215": {"epss_score": 0.0527, "epss_percentile": 0.89678}, "CVE-2019-8216": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8217": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8218": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8219": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8220": {"epss_score": 0.0527, "epss_percentile": 0.89678}, "CVE-2019-8221": {"epss_score": 0.0527, "epss_percentile": 0.89678}, "CVE-2019-8222": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8223": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8224": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8225": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2019-8226": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2019-8227": {"epss_score": 0.02138, "epss_percentile": 0.83736}, "CVE-2019-8228": {"epss_score": 0.02138, "epss_percentile": 0.83736}, "CVE-2019-8229": {"epss_score": 0.00188, "epss_percentile": 0.40906}, "CVE-2019-8230": {"epss_score": 0.00188, "epss_percentile": 0.40906}, "CVE-2019-8231": {"epss_score": 0.00188, "epss_percentile": 0.40906}, "CVE-2019-8232": {"epss_score": 0.00148, "epss_percentile": 0.35803}, "CVE-2019-8233": {"epss_score": 0.00527, "epss_percentile": 0.6653}, "CVE-2019-8234": {"epss_score": 0.0141, "epss_percentile": 0.80082}, "CVE-2019-8235": {"epss_score": 0.00207, "epss_percentile": 0.43187}, "CVE-2019-8236": {"epss_score": 0.00796, "epss_percentile": 0.73486}, "CVE-2019-8237": {"epss_score": 0.0101, "epss_percentile": 0.76594}, "CVE-2019-8238": {"epss_score": 0.03212, "epss_percentile": 0.86656}, "CVE-2019-8239": {"epss_score": 0.01535, "epss_percentile": 0.80911}, "CVE-2019-8240": {"epss_score": 0.01535, "epss_percentile": 0.80911}, "CVE-2019-8241": {"epss_score": 0.00963, "epss_percentile": 0.76016}, "CVE-2019-8242": {"epss_score": 0.01747, "epss_percentile": 0.82072}, "CVE-2019-8243": {"epss_score": 0.00963, "epss_percentile": 0.76016}, "CVE-2019-8244": {"epss_score": 0.00963, "epss_percentile": 0.76016}, "CVE-2019-8246": {"epss_score": 0.01707, "epss_percentile": 0.81859}, "CVE-2019-8247": {"epss_score": 0.01861, "epss_percentile": 0.82593}, "CVE-2019-8248": {"epss_score": 0.01861, "epss_percentile": 0.82593}, "CVE-2019-8249": {"epss_score": 0.08304, "epss_percentile": 0.9198}, "CVE-2019-8250": {"epss_score": 0.08304, "epss_percentile": 0.9198}, "CVE-2019-8251": {"epss_score": 0.01808, "epss_percentile": 0.82355}, "CVE-2019-8252": {"epss_score": 0.01808, "epss_percentile": 0.82355}, "CVE-2019-8253": {"epss_score": 0.01212, "epss_percentile": 0.78558}, "CVE-2019-8254": {"epss_score": 0.01212, "epss_percentile": 0.78558}, "CVE-2019-8255": {"epss_score": 0.05196, "epss_percentile": 0.89599}, "CVE-2019-8256": {"epss_score": 0.00661, "epss_percentile": 0.70574}, "CVE-2019-8257": {"epss_score": 0.17814, "epss_percentile": 0.94911}, "CVE-2019-8258": {"epss_score": 0.04506, "epss_percentile": 0.88772}, "CVE-2019-8259": {"epss_score": 0.00853, "epss_percentile": 0.74431}, "CVE-2019-8260": {"epss_score": 0.01024, "epss_percentile": 0.76778}, "CVE-2019-8261": {"epss_score": 0.01024, "epss_percentile": 0.76778}, "CVE-2019-8262": {"epss_score": 0.06068, "epss_percentile": 0.90449}, "CVE-2019-8263": {"epss_score": 0.00943, "epss_percentile": 0.75772}, "CVE-2019-8264": {"epss_score": 0.01707, "epss_percentile": 0.81861}, "CVE-2019-8265": {"epss_score": 0.01707, "epss_percentile": 0.81861}, "CVE-2019-8266": {"epss_score": 0.01304, "epss_percentile": 0.79317}, "CVE-2019-8267": {"epss_score": 0.00393, "epss_percentile": 0.59704}, "CVE-2019-8268": {"epss_score": 0.01458, "epss_percentile": 0.80408}, "CVE-2019-8269": {"epss_score": 0.0083, "epss_percentile": 0.74019}, "CVE-2019-8270": {"epss_score": 0.00393, "epss_percentile": 0.59704}, "CVE-2019-8271": {"epss_score": 0.04506, "epss_percentile": 0.88772}, "CVE-2019-8272": {"epss_score": 0.01458, "epss_percentile": 0.80408}, "CVE-2019-8273": {"epss_score": 0.04506, "epss_percentile": 0.88772}, "CVE-2019-8274": {"epss_score": 0.04506, "epss_percentile": 0.88772}, "CVE-2019-8275": {"epss_score": 0.04492, "epss_percentile": 0.88758}, "CVE-2019-8276": {"epss_score": 0.0083, "epss_percentile": 0.74019}, "CVE-2019-8277": {"epss_score": 0.00853, "epss_percentile": 0.74431}, "CVE-2019-8278": {"epss_score": 0.0034, "epss_percentile": 0.56284}, "CVE-2019-8279": {"epss_score": 0.00157, "epss_percentile": 0.37034}, "CVE-2019-8280": {"epss_score": 0.01707, "epss_percentile": 0.81861}, "CVE-2019-8282": {"epss_score": 0.00127, "epss_percentile": 0.32915}, "CVE-2019-8283": {"epss_score": 0.00296, "epss_percentile": 0.52535}, "CVE-2019-8285": {"epss_score": 0.02509, "epss_percentile": 0.84947}, "CVE-2019-8286": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2019-8287": {"epss_score": 0.02145, "epss_percentile": 0.83764}, "CVE-2019-8288": {"epss_score": 0.00258, "epss_percentile": 0.49004}, "CVE-2019-8289": {"epss_score": 0.00258, "epss_percentile": 0.49004}, "CVE-2019-8290": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2019-8291": {"epss_score": 0.00293, "epss_percentile": 0.52299}, "CVE-2019-8292": {"epss_score": 0.00398, "epss_percentile": 0.60066}, "CVE-2019-8293": {"epss_score": 0.00578, "epss_percentile": 0.6818}, "CVE-2019-8308": {"epss_score": 0.00067, "epss_percentile": 0.20986}, "CVE-2019-8312": {"epss_score": 0.01524, "epss_percentile": 0.80852}, "CVE-2019-8313": {"epss_score": 0.01524, "epss_percentile": 0.80852}, "CVE-2019-8314": {"epss_score": 0.01524, "epss_percentile": 0.80852}, "CVE-2019-8315": {"epss_score": 0.01524, "epss_percentile": 0.80852}, "CVE-2019-8316": {"epss_score": 0.01533, "epss_percentile": 0.80902}, "CVE-2019-8317": {"epss_score": 0.01524, "epss_percentile": 0.80852}, "CVE-2019-8318": {"epss_score": 0.01524, "epss_percentile": 0.80852}, "CVE-2019-8319": {"epss_score": 0.01524, "epss_percentile": 0.80852}, "CVE-2019-8320": {"epss_score": 0.08767, "epss_percentile": 0.92246}, "CVE-2019-8321": {"epss_score": 0.00254, "epss_percentile": 0.4857}, "CVE-2019-8322": {"epss_score": 0.00254, "epss_percentile": 0.4857}, "CVE-2019-8323": {"epss_score": 0.00254, "epss_percentile": 0.4857}, "CVE-2019-8324": {"epss_score": 0.00511, "epss_percentile": 0.6582}, "CVE-2019-8325": {"epss_score": 0.00254, "epss_percentile": 0.4857}, "CVE-2019-8331": {"epss_score": 0.01307, "epss_percentile": 0.79341}, "CVE-2019-8334": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-8335": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-8336": {"epss_score": 0.00362, "epss_percentile": 0.57758}, "CVE-2019-8337": {"epss_score": 0.0015, "epss_percentile": 0.36106}, "CVE-2019-8338": {"epss_score": 0.00345, "epss_percentile": 0.56551}, "CVE-2019-8339": {"epss_score": 0.00101, "epss_percentile": 0.28703}, "CVE-2019-8341": {"epss_score": 0.37397, "epss_percentile": 0.97042}, "CVE-2019-8342": {"epss_score": 9e-05, "epss_percentile": 0.00629}, "CVE-2019-8343": {"epss_score": 0.00137, "epss_percentile": 0.34288}, "CVE-2019-8345": {"epss_score": 0.00035, "epss_percentile": 0.09848}, "CVE-2019-8346": {"epss_score": 0.03163, "epss_percentile": 0.86534}, "CVE-2019-8347": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-8349": {"epss_score": 0.00491, "epss_percentile": 0.64958}, "CVE-2019-8350": {"epss_score": 0.00053, "epss_percentile": 0.16677}, "CVE-2019-8351": {"epss_score": 0.0027, "epss_percentile": 0.50212}, "CVE-2019-8352": {"epss_score": 0.03828, "epss_percentile": 0.87796}, "CVE-2019-8354": {"epss_score": 0.0079, "epss_percentile": 0.73369}, "CVE-2019-8355": {"epss_score": 0.00746, "epss_percentile": 0.72549}, "CVE-2019-8356": {"epss_score": 0.01304, "epss_percentile": 0.79316}, "CVE-2019-8357": {"epss_score": 0.0045, "epss_percentile": 0.63101}, "CVE-2019-8358": {"epss_score": 0.00969, "epss_percentile": 0.76096}, "CVE-2019-8359": {"epss_score": 0.00656, "epss_percentile": 0.70436}, "CVE-2019-8360": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-8361": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-8362": {"epss_score": 0.00207, "epss_percentile": 0.43136}, "CVE-2019-8363": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-8368": {"epss_score": 0.38788, "epss_percentile": 0.9712}, "CVE-2019-8371": {"epss_score": 0.00419, "epss_percentile": 0.61383}, "CVE-2019-8372": {"epss_score": 0.00133, "epss_percentile": 0.33726}, "CVE-2019-8375": {"epss_score": 0.212, "epss_percentile": 0.95475}, "CVE-2019-8376": {"epss_score": 0.0021, "epss_percentile": 0.43498}, "CVE-2019-8377": {"epss_score": 0.00206, "epss_percentile": 0.42767}, "CVE-2019-8378": {"epss_score": 0.00402, "epss_percentile": 0.60281}, "CVE-2019-8379": {"epss_score": 0.00264, "epss_percentile": 0.49692}, "CVE-2019-8380": {"epss_score": 0.00345, "epss_percentile": 0.56556}, "CVE-2019-8381": {"epss_score": 0.00226, "epss_percentile": 0.45242}, "CVE-2019-8382": {"epss_score": 0.00345, "epss_percentile": 0.56556}, "CVE-2019-8383": {"epss_score": 0.00264, "epss_percentile": 0.49692}, "CVE-2019-8385": {"epss_score": 0.10677, "epss_percentile": 0.93067}, "CVE-2019-8387": {"epss_score": 0.65249, "epss_percentile": 0.98409}, "CVE-2019-8389": {"epss_score": 0.04841, "epss_percentile": 0.89201}, "CVE-2019-8390": {"epss_score": 0.02661, "epss_percentile": 0.85367}, "CVE-2019-8391": {"epss_score": 0.01478, "epss_percentile": 0.8055}, "CVE-2019-8392": {"epss_score": 0.00365, "epss_percentile": 0.5797}, "CVE-2019-8393": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-8394": {"epss_score": 0.87276, "epss_percentile": 0.99421}, "CVE-2019-8395": {"epss_score": 0.12191, "epss_percentile": 0.93599}, "CVE-2019-8396": {"epss_score": 0.00307, "epss_percentile": 0.53524}, "CVE-2019-8397": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2019-8398": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2019-8400": {"epss_score": 0.00336, "epss_percentile": 0.55934}, "CVE-2019-8404": {"epss_score": 0.19068, "epss_percentile": 0.95123}, "CVE-2019-8407": {"epss_score": 0.00497, "epss_percentile": 0.65191}, "CVE-2019-8408": {"epss_score": 0.00182, "epss_percentile": 0.40195}, "CVE-2019-8410": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2019-8411": {"epss_score": 0.00869, "epss_percentile": 0.7469}, "CVE-2019-8412": {"epss_score": 0.01109, "epss_percentile": 0.77645}, "CVE-2019-8413": {"epss_score": 0.00049, "epss_percentile": 0.153}, "CVE-2019-8418": {"epss_score": 0.00381, "epss_percentile": 0.58981}, "CVE-2019-8419": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-8421": {"epss_score": 0.00282, "epss_percentile": 0.51272}, "CVE-2019-8422": {"epss_score": 0.00303, "epss_percentile": 0.53232}, "CVE-2019-8423": {"epss_score": 0.00306, "epss_percentile": 0.53398}, "CVE-2019-8424": {"epss_score": 0.00329, "epss_percentile": 0.55307}, "CVE-2019-8425": {"epss_score": 0.0033, "epss_percentile": 0.55426}, "CVE-2019-8426": {"epss_score": 0.0033, "epss_percentile": 0.55426}, "CVE-2019-8427": {"epss_score": 0.03002, "epss_percentile": 0.86169}, "CVE-2019-8428": {"epss_score": 0.00329, "epss_percentile": 0.55307}, "CVE-2019-8429": {"epss_score": 0.00329, "epss_percentile": 0.55307}, "CVE-2019-8432": {"epss_score": 0.0021, "epss_percentile": 0.43455}, "CVE-2019-8433": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2019-8434": {"epss_score": 0.0021, "epss_percentile": 0.43455}, "CVE-2019-8435": {"epss_score": 0.00281, "epss_percentile": 0.51142}, "CVE-2019-8436": {"epss_score": 0.0018, "epss_percentile": 0.3989}, "CVE-2019-8437": {"epss_score": 0.00177, "epss_percentile": 0.39553}, "CVE-2019-8438": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-8439": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-8440": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-8442": {"epss_score": 0.93279, "epss_percentile": 0.99793}, "CVE-2019-8443": {"epss_score": 0.00573, "epss_percentile": 0.68049}, "CVE-2019-8444": {"epss_score": 0.00327, "epss_percentile": 0.55107}, "CVE-2019-8445": {"epss_score": 0.00589, "epss_percentile": 0.68535}, "CVE-2019-8446": {"epss_score": 0.72961, "epss_percentile": 0.9873}, "CVE-2019-8447": {"epss_score": 0.00107, "epss_percentile": 0.29679}, "CVE-2019-8448": {"epss_score": 0.00217, "epss_percentile": 0.44251}, "CVE-2019-8449": {"epss_score": 0.68722, "epss_percentile": 0.9856}, "CVE-2019-8450": {"epss_score": 0.00237, "epss_percentile": 0.46711}, "CVE-2019-8451": {"epss_score": 0.92505, "epss_percentile": 0.99722}, "CVE-2019-8452": {"epss_score": 0.00224, "epss_percentile": 0.45007}, "CVE-2019-8453": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2019-8454": {"epss_score": 0.00033, "epss_percentile": 0.09349}, "CVE-2019-8455": {"epss_score": 0.0008, "epss_percentile": 0.24119}, "CVE-2019-8456": {"epss_score": 0.01772, "epss_percentile": 0.82202}, "CVE-2019-8457": {"epss_score": 0.2714, "epss_percentile": 0.96211}, "CVE-2019-8458": {"epss_score": 0.00474, "epss_percentile": 0.64153}, "CVE-2019-8459": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2019-8460": {"epss_score": 0.00688, "epss_percentile": 0.71201}, "CVE-2019-8461": {"epss_score": 0.00164, "epss_percentile": 0.37906}, "CVE-2019-8462": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2019-8463": {"epss_score": 0.00478, "epss_percentile": 0.64409}, "CVE-2019-8502": {"epss_score": 0.00319, "epss_percentile": 0.54558}, "CVE-2019-8503": {"epss_score": 0.00862, "epss_percentile": 0.7457}, "CVE-2019-8504": {"epss_score": 0.00112, "epss_percentile": 0.30536}, "CVE-2019-8505": {"epss_score": 0.00323, "epss_percentile": 0.54888}, "CVE-2019-8506": {"epss_score": 0.07299, "epss_percentile": 0.91391}, "CVE-2019-8507": {"epss_score": 0.00059, "epss_percentile": 0.18836}, "CVE-2019-8508": {"epss_score": 0.00118, "epss_percentile": 0.31478}, "CVE-2019-8509": {"epss_score": 0.00256, "epss_percentile": 0.48821}, "CVE-2019-8510": {"epss_score": 0.00068, "epss_percentile": 0.21332}, "CVE-2019-8511": {"epss_score": 0.00513, "epss_percentile": 0.65894}, "CVE-2019-8512": {"epss_score": 0.00258, "epss_percentile": 0.48955}, "CVE-2019-8513": {"epss_score": 0.11275, "epss_percentile": 0.93289}, "CVE-2019-8514": {"epss_score": 0.05227, "epss_percentile": 0.89635}, "CVE-2019-8515": {"epss_score": 0.0048, "epss_percentile": 0.64479}, "CVE-2019-8516": {"epss_score": 0.00642, "epss_percentile": 0.70019}, "CVE-2019-8517": {"epss_score": 0.00478, "epss_percentile": 0.64384}, "CVE-2019-8518": {"epss_score": 0.43284, "epss_percentile": 0.9738}, "CVE-2019-8519": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2019-8520": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2019-8521": {"epss_score": 0.00306, "epss_percentile": 0.53412}, "CVE-2019-8522": {"epss_score": 0.00107, "epss_percentile": 0.29606}, "CVE-2019-8523": {"epss_score": 0.01288, "epss_percentile": 0.792}, "CVE-2019-8524": {"epss_score": 0.00838, "epss_percentile": 0.74171}, "CVE-2019-8525": {"epss_score": 0.00057, "epss_percentile": 0.18196}, "CVE-2019-8526": {"epss_score": 0.00678, "epss_percentile": 0.70978}, "CVE-2019-8527": {"epss_score": 0.00967, "epss_percentile": 0.76071}, "CVE-2019-8528": {"epss_score": 0.00075, "epss_percentile": 0.23059}, "CVE-2019-8529": {"epss_score": 0.00144, "epss_percentile": 0.35254}, "CVE-2019-8530": {"epss_score": 0.0042, "epss_percentile": 0.61455}, "CVE-2019-8531": {"epss_score": 0.00317, "epss_percentile": 0.54335}, "CVE-2019-8532": {"epss_score": 0.00149, "epss_percentile": 0.35954}, "CVE-2019-8533": {"epss_score": 0.00118, "epss_percentile": 0.31421}, "CVE-2019-8534": {"epss_score": 0.00045, "epss_percentile": 0.13794}, "CVE-2019-8535": {"epss_score": 0.02231, "epss_percentile": 0.84087}, "CVE-2019-8536": {"epss_score": 0.01589, "epss_percentile": 0.81197}, "CVE-2019-8537": {"epss_score": 0.00048, "epss_percentile": 0.1518}, "CVE-2019-8538": {"epss_score": 0.00196, "epss_percentile": 0.4182}, "CVE-2019-8539": {"epss_score": 0.00279, "epss_percentile": 0.50977}, "CVE-2019-8540": {"epss_score": 0.0085, "epss_percentile": 0.74385}, "CVE-2019-8541": {"epss_score": 0.00149, "epss_percentile": 0.3604}, "CVE-2019-8542": {"epss_score": 0.0048, "epss_percentile": 0.64462}, "CVE-2019-8544": {"epss_score": 0.01683, "epss_percentile": 0.8174}, "CVE-2019-8545": {"epss_score": 0.00171, "epss_percentile": 0.38834}, "CVE-2019-8546": {"epss_score": 0.00148, "epss_percentile": 0.35824}, "CVE-2019-8547": {"epss_score": 0.01002, "epss_percentile": 0.76505}, "CVE-2019-8548": {"epss_score": 0.00125, "epss_percentile": 0.32555}, "CVE-2019-8549": {"epss_score": 0.00456, "epss_percentile": 0.63334}, "CVE-2019-8550": {"epss_score": 0.00456, "epss_percentile": 0.63327}, "CVE-2019-8551": {"epss_score": 0.00861, "epss_percentile": 0.74561}, "CVE-2019-8552": {"epss_score": 0.00352, "epss_percentile": 0.57132}, "CVE-2019-8553": {"epss_score": 0.00818, "epss_percentile": 0.7385}, "CVE-2019-8554": {"epss_score": 0.00302, "epss_percentile": 0.53111}, "CVE-2019-8555": {"epss_score": 0.00465, "epss_percentile": 0.63763}, "CVE-2019-8556": {"epss_score": 0.00758, "epss_percentile": 0.72766}, "CVE-2019-8558": {"epss_score": 0.15256, "epss_percentile": 0.94393}, "CVE-2019-8559": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8560": {"epss_score": 0.00269, "epss_percentile": 0.50161}, "CVE-2019-8561": {"epss_score": 0.14091, "epss_percentile": 0.94131}, "CVE-2019-8562": {"epss_score": 0.00475, "epss_percentile": 0.64198}, "CVE-2019-8563": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8564": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-8565": {"epss_score": 0.29576, "epss_percentile": 0.96458}, "CVE-2019-8566": {"epss_score": 0.00276, "epss_percentile": 0.50739}, "CVE-2019-8567": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2019-8568": {"epss_score": 0.00063, "epss_percentile": 0.19837}, "CVE-2019-8569": {"epss_score": 0.00047, "epss_percentile": 0.14776}, "CVE-2019-8570": {"epss_score": 0.00478, "epss_percentile": 0.64384}, "CVE-2019-8571": {"epss_score": 0.00811, "epss_percentile": 0.73738}, "CVE-2019-8572": {"epss_score": 0.01639, "epss_percentile": 0.8149}, "CVE-2019-8573": {"epss_score": 0.00537, "epss_percentile": 0.66914}, "CVE-2019-8574": {"epss_score": 0.0036, "epss_percentile": 0.57684}, "CVE-2019-8575": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2019-8576": {"epss_score": 0.00052, "epss_percentile": 0.16523}, "CVE-2019-8577": {"epss_score": 0.00724, "epss_percentile": 0.72029}, "CVE-2019-8578": {"epss_score": 0.02931, "epss_percentile": 0.86016}, "CVE-2019-8579": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2019-8580": {"epss_score": 0.0021, "epss_percentile": 0.43478}, "CVE-2019-8581": {"epss_score": 0.0061, "epss_percentile": 0.69144}, "CVE-2019-8582": {"epss_score": 0.00296, "epss_percentile": 0.52573}, "CVE-2019-8583": {"epss_score": 0.0082, "epss_percentile": 0.73892}, "CVE-2019-8584": {"epss_score": 0.00811, "epss_percentile": 0.73738}, "CVE-2019-8585": {"epss_score": 0.00679, "epss_percentile": 0.71006}, "CVE-2019-8586": {"epss_score": 0.00811, "epss_percentile": 0.73738}, "CVE-2019-8587": {"epss_score": 0.00811, "epss_percentile": 0.73738}, "CVE-2019-8588": {"epss_score": 0.00397, "epss_percentile": 0.6005}, "CVE-2019-8589": {"epss_score": 0.00194, "epss_percentile": 0.41528}, "CVE-2019-8590": {"epss_score": 0.00404, "epss_percentile": 0.60412}, "CVE-2019-8591": {"epss_score": 0.07151, "epss_percentile": 0.91286}, "CVE-2019-8592": {"epss_score": 0.00433, "epss_percentile": 0.62181}, "CVE-2019-8593": {"epss_score": 0.00384, "epss_percentile": 0.59132}, "CVE-2019-8594": {"epss_score": 0.00811, "epss_percentile": 0.73738}, "CVE-2019-8595": {"epss_score": 0.00811, "epss_percentile": 0.73738}, "CVE-2019-8596": {"epss_score": 0.00811, "epss_percentile": 0.73738}, "CVE-2019-8597": {"epss_score": 0.00728, "epss_percentile": 0.72114}, "CVE-2019-8598": {"epss_score": 0.03391, "epss_percentile": 0.87052}, "CVE-2019-8599": {"epss_score": 0.00057, "epss_percentile": 0.18106}, "CVE-2019-8600": {"epss_score": 0.14684, "epss_percentile": 0.94263}, "CVE-2019-8601": {"epss_score": 0.09556, "epss_percentile": 0.92598}, "CVE-2019-8602": {"epss_score": 0.041, "epss_percentile": 0.88257}, "CVE-2019-8603": {"epss_score": 0.00441, "epss_percentile": 0.62686}, "CVE-2019-8604": {"epss_score": 0.0021, "epss_percentile": 0.43456}, "CVE-2019-8605": {"epss_score": 0.14409, "epss_percentile": 0.94206}, "CVE-2019-8606": {"epss_score": 0.00098, "epss_percentile": 0.27775}, "CVE-2019-8607": {"epss_score": 0.00683, "epss_percentile": 0.71107}, "CVE-2019-8608": {"epss_score": 0.00767, "epss_percentile": 0.7296}, "CVE-2019-8609": {"epss_score": 0.00811, "epss_percentile": 0.73738}, "CVE-2019-8610": {"epss_score": 0.00811, "epss_percentile": 0.73738}, "CVE-2019-8611": {"epss_score": 0.25276, "epss_percentile": 0.96007}, "CVE-2019-8612": {"epss_score": 0.00323, "epss_percentile": 0.54883}, "CVE-2019-8613": {"epss_score": 0.04088, "epss_percentile": 0.8823}, "CVE-2019-8615": {"epss_score": 0.00728, "epss_percentile": 0.72114}, "CVE-2019-8616": {"epss_score": 0.00119, "epss_percentile": 0.31647}, "CVE-2019-8617": {"epss_score": 0.00496, "epss_percentile": 0.65139}, "CVE-2019-8618": {"epss_score": 0.00289, "epss_percentile": 0.52015}, "CVE-2019-8619": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8620": {"epss_score": 0.00386, "epss_percentile": 0.59253}, "CVE-2019-8622": {"epss_score": 0.27094, "epss_percentile": 0.96206}, "CVE-2019-8623": {"epss_score": 0.27094, "epss_percentile": 0.96206}, "CVE-2019-8624": {"epss_score": 0.02194, "epss_percentile": 0.8395}, "CVE-2019-8625": {"epss_score": 0.00267, "epss_percentile": 0.4996}, "CVE-2019-8626": {"epss_score": 0.00447, "epss_percentile": 0.62956}, "CVE-2019-8628": {"epss_score": 0.00588, "epss_percentile": 0.68507}, "CVE-2019-8629": {"epss_score": 0.00297, "epss_percentile": 0.52752}, "CVE-2019-8630": {"epss_score": 0.00124, "epss_percentile": 0.3246}, "CVE-2019-8631": {"epss_score": 0.00289, "epss_percentile": 0.52015}, "CVE-2019-8632": {"epss_score": 0.00228, "epss_percentile": 0.45546}, "CVE-2019-8633": {"epss_score": 0.00378, "epss_percentile": 0.58822}, "CVE-2019-8634": {"epss_score": 0.0034, "epss_percentile": 0.56238}, "CVE-2019-8635": {"epss_score": 0.00119, "epss_percentile": 0.31647}, "CVE-2019-8637": {"epss_score": 0.0033, "epss_percentile": 0.55449}, "CVE-2019-8638": {"epss_score": 0.00758, "epss_percentile": 0.72766}, "CVE-2019-8639": {"epss_score": 0.00758, "epss_percentile": 0.72766}, "CVE-2019-8640": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-8641": {"epss_score": 0.21227, "epss_percentile": 0.9548}, "CVE-2019-8642": {"epss_score": 0.00088, "epss_percentile": 0.25645}, "CVE-2019-8643": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2019-8644": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8645": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2019-8646": {"epss_score": 0.05228, "epss_percentile": 0.89636}, "CVE-2019-8647": {"epss_score": 0.04465, "epss_percentile": 0.88728}, "CVE-2019-8648": {"epss_score": 0.01127, "epss_percentile": 0.77824}, "CVE-2019-8649": {"epss_score": 0.0982, "epss_percentile": 0.92717}, "CVE-2019-8654": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2019-8656": {"epss_score": 0.03766, "epss_percentile": 0.87696}, "CVE-2019-8657": {"epss_score": 0.00645, "epss_percentile": 0.70119}, "CVE-2019-8658": {"epss_score": 0.00924, "epss_percentile": 0.75524}, "CVE-2019-8659": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-8660": {"epss_score": 0.03335, "epss_percentile": 0.86934}, "CVE-2019-8661": {"epss_score": 0.05817, "epss_percentile": 0.90233}, "CVE-2019-8662": {"epss_score": 0.14427, "epss_percentile": 0.9421}, "CVE-2019-8663": {"epss_score": 0.0453, "epss_percentile": 0.88811}, "CVE-2019-8664": {"epss_score": 0.00299, "epss_percentile": 0.52863}, "CVE-2019-8665": {"epss_score": 0.00683, "epss_percentile": 0.7109}, "CVE-2019-8666": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8667": {"epss_score": 0.0013, "epss_percentile": 0.33249}, "CVE-2019-8668": {"epss_score": 0.00196, "epss_percentile": 0.4182}, "CVE-2019-8669": {"epss_score": 0.03566, "epss_percentile": 0.87365}, "CVE-2019-8670": {"epss_score": 0.00222, "epss_percentile": 0.44753}, "CVE-2019-8671": {"epss_score": 0.25381, "epss_percentile": 0.96022}, "CVE-2019-8672": {"epss_score": 0.40339, "epss_percentile": 0.97212}, "CVE-2019-8673": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8674": {"epss_score": 0.00624, "epss_percentile": 0.69568}, "CVE-2019-8675": {"epss_score": 0.01419, "epss_percentile": 0.80163}, "CVE-2019-8676": {"epss_score": 0.03566, "epss_percentile": 0.87365}, "CVE-2019-8677": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8678": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8679": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8680": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8681": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8682": {"epss_score": 0.00045, "epss_percentile": 0.13947}, "CVE-2019-8683": {"epss_score": 0.00825, "epss_percentile": 0.73954}, "CVE-2019-8684": {"epss_score": 0.03566, "epss_percentile": 0.87365}, "CVE-2019-8685": {"epss_score": 0.00974, "epss_percentile": 0.76195}, "CVE-2019-8686": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8687": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2019-8688": {"epss_score": 0.04267, "epss_percentile": 0.88471}, "CVE-2019-8689": {"epss_score": 0.28818, "epss_percentile": 0.9639}, "CVE-2019-8690": {"epss_score": 0.08113, "epss_percentile": 0.91885}, "CVE-2019-8691": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2019-8692": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2019-8693": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2019-8694": {"epss_score": 0.00297, "epss_percentile": 0.52752}, "CVE-2019-8695": {"epss_score": 0.00297, "epss_percentile": 0.52752}, "CVE-2019-8696": {"epss_score": 0.01419, "epss_percentile": 0.80163}, "CVE-2019-8697": {"epss_score": 0.00122, "epss_percentile": 0.3203}, "CVE-2019-8698": {"epss_score": 0.00252, "epss_percentile": 0.48349}, "CVE-2019-8699": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2019-8701": {"epss_score": 0.00131, "epss_percentile": 0.33368}, "CVE-2019-8702": {"epss_score": 0.00061, "epss_percentile": 0.19357}, "CVE-2019-8703": {"epss_score": 0.00868, "epss_percentile": 0.74682}, "CVE-2019-8704": {"epss_score": 0.00047, "epss_percentile": 0.14483}, "CVE-2019-8705": {"epss_score": 0.0021, "epss_percentile": 0.43469}, "CVE-2019-8706": {"epss_score": 0.00485, "epss_percentile": 0.6472}, "CVE-2019-8707": {"epss_score": 0.0114, "epss_percentile": 0.77952}, "CVE-2019-8708": {"epss_score": 0.00061, "epss_percentile": 0.19357}, "CVE-2019-8709": {"epss_score": 0.00501, "epss_percentile": 0.65334}, "CVE-2019-8710": {"epss_score": 0.00512, "epss_percentile": 0.65864}, "CVE-2019-8711": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2019-8712": {"epss_score": 0.00988, "epss_percentile": 0.76354}, "CVE-2019-8715": {"epss_score": 0.00257, "epss_percentile": 0.48868}, "CVE-2019-8716": {"epss_score": 0.00567, "epss_percentile": 0.67852}, "CVE-2019-8717": {"epss_score": 0.00727, "epss_percentile": 0.7209}, "CVE-2019-8718": {"epss_score": 0.00271, "epss_percentile": 0.50322}, "CVE-2019-8719": {"epss_score": 0.00728, "epss_percentile": 0.72111}, "CVE-2019-8720": {"epss_score": 0.07842, "epss_percentile": 0.91715}, "CVE-2019-8721": {"epss_score": 0.00601, "epss_percentile": 0.68847}, "CVE-2019-8722": {"epss_score": 0.00601, "epss_percentile": 0.68847}, "CVE-2019-8723": {"epss_score": 0.00464, "epss_percentile": 0.63738}, "CVE-2019-8724": {"epss_score": 0.00464, "epss_percentile": 0.63738}, "CVE-2019-8725": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2019-8726": {"epss_score": 0.01106, "epss_percentile": 0.7762}, "CVE-2019-8727": {"epss_score": 0.00351, "epss_percentile": 0.57031}, "CVE-2019-8728": {"epss_score": 0.00588, "epss_percentile": 0.68507}, "CVE-2019-8730": {"epss_score": 0.00115, "epss_percentile": 0.31032}, "CVE-2019-8731": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2019-8732": {"epss_score": 0.00057, "epss_percentile": 0.18106}, "CVE-2019-8733": {"epss_score": 0.0114, "epss_percentile": 0.77952}, "CVE-2019-8734": {"epss_score": 0.00588, "epss_percentile": 0.68507}, "CVE-2019-8735": {"epss_score": 0.01106, "epss_percentile": 0.7762}, "CVE-2019-8736": {"epss_score": 0.00353, "epss_percentile": 0.57137}, "CVE-2019-8737": {"epss_score": 0.00447, "epss_percentile": 0.62973}, "CVE-2019-8738": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2019-8739": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2019-8740": {"epss_score": 0.00501, "epss_percentile": 0.65334}, "CVE-2019-8741": {"epss_score": 0.02749, "epss_percentile": 0.85579}, "CVE-2019-8742": {"epss_score": 0.00057, "epss_percentile": 0.18106}, "CVE-2019-8743": {"epss_score": 0.00534, "epss_percentile": 0.66796}, "CVE-2019-8744": {"epss_score": 0.00314, "epss_percentile": 0.54127}, "CVE-2019-8745": {"epss_score": 0.0109, "epss_percentile": 0.77448}, "CVE-2019-8746": {"epss_score": 0.02306, "epss_percentile": 0.84324}, "CVE-2019-8747": {"epss_score": 0.00298, "epss_percentile": 0.52777}, "CVE-2019-8748": {"epss_score": 0.00131, "epss_percentile": 0.33368}, "CVE-2019-8749": {"epss_score": 0.01253, "epss_percentile": 0.78914}, "CVE-2019-8750": {"epss_score": 0.00981, "epss_percentile": 0.76278}, "CVE-2019-8751": {"epss_score": 0.00588, "epss_percentile": 0.68507}, "CVE-2019-8752": {"epss_score": 0.00588, "epss_percentile": 0.68507}, "CVE-2019-8753": {"epss_score": 0.00433, "epss_percentile": 0.62197}, "CVE-2019-8754": {"epss_score": 0.0016, "epss_percentile": 0.37446}, "CVE-2019-8755": {"epss_score": 0.00136, "epss_percentile": 0.34168}, "CVE-2019-8756": {"epss_score": 0.01253, "epss_percentile": 0.78914}, "CVE-2019-8757": {"epss_score": 0.00104, "epss_percentile": 0.29102}, "CVE-2019-8758": {"epss_score": 0.00131, "epss_percentile": 0.33368}, "CVE-2019-8759": {"epss_score": 0.0011, "epss_percentile": 0.30213}, "CVE-2019-8760": {"epss_score": 0.00129, "epss_percentile": 0.33206}, "CVE-2019-8761": {"epss_score": 0.01275, "epss_percentile": 0.79103}, "CVE-2019-8762": {"epss_score": 0.00721, "epss_percentile": 0.71975}, "CVE-2019-8763": {"epss_score": 0.01106, "epss_percentile": 0.7762}, "CVE-2019-8764": {"epss_score": 0.0017, "epss_percentile": 0.38748}, "CVE-2019-8765": {"epss_score": 0.14694, "epss_percentile": 0.94267}, "CVE-2019-8766": {"epss_score": 0.00546, "epss_percentile": 0.67222}, "CVE-2019-8767": {"epss_score": 0.00451, "epss_percentile": 0.63128}, "CVE-2019-8768": {"epss_score": 0.0039, "epss_percentile": 0.59546}, "CVE-2019-8769": {"epss_score": 0.00151, "epss_percentile": 0.36317}, "CVE-2019-8770": {"epss_score": 0.00227, "epss_percentile": 0.4538}, "CVE-2019-8771": {"epss_score": 0.00258, "epss_percentile": 0.49012}, "CVE-2019-8772": {"epss_score": 0.00348, "epss_percentile": 0.56805}, "CVE-2019-8773": {"epss_score": 0.00588, "epss_percentile": 0.68507}, "CVE-2019-8774": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2019-8775": {"epss_score": 0.00119, "epss_percentile": 0.31636}, "CVE-2019-8776": {"epss_score": 0.00326, "epss_percentile": 0.5504}, "CVE-2019-8777": {"epss_score": 0.00043, "epss_percentile": 0.1332}, "CVE-2019-8779": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2019-8780": {"epss_score": 0.00129, "epss_percentile": 0.33075}, "CVE-2019-8781": {"epss_score": 0.15909, "epss_percentile": 0.94529}, "CVE-2019-8782": {"epss_score": 0.00272, "epss_percentile": 0.50346}, "CVE-2019-8783": {"epss_score": 0.00408, "epss_percentile": 0.6065}, "CVE-2019-8784": {"epss_score": 0.00499, "epss_percentile": 0.6526}, "CVE-2019-8785": {"epss_score": 0.00456, "epss_percentile": 0.63334}, "CVE-2019-8786": {"epss_score": 0.00477, "epss_percentile": 0.64296}, "CVE-2019-8787": {"epss_score": 0.00689, "epss_percentile": 0.71226}, "CVE-2019-8788": {"epss_score": 0.0035, "epss_percentile": 0.56928}, "CVE-2019-8789": {"epss_score": 0.00255, "epss_percentile": 0.48661}, "CVE-2019-8790": {"epss_score": 0.00074, "epss_percentile": 0.22697}, "CVE-2019-8791": {"epss_score": 0.00362, "epss_percentile": 0.57763}, "CVE-2019-8792": {"epss_score": 0.00562, "epss_percentile": 0.67687}, "CVE-2019-8793": {"epss_score": 0.00139, "epss_percentile": 0.34544}, "CVE-2019-8794": {"epss_score": 0.00359, "epss_percentile": 0.57597}, "CVE-2019-8795": {"epss_score": 0.00374, "epss_percentile": 0.58589}, "CVE-2019-8796": {"epss_score": 0.00336, "epss_percentile": 0.55933}, "CVE-2019-8797": {"epss_score": 0.00456, "epss_percentile": 0.63334}, "CVE-2019-8798": {"epss_score": 0.00173, "epss_percentile": 0.39089}, "CVE-2019-8799": {"epss_score": 0.0007, "epss_percentile": 0.21741}, "CVE-2019-8800": {"epss_score": 0.00343, "epss_percentile": 0.56461}, "CVE-2019-8801": {"epss_score": 0.00161, "epss_percentile": 0.37581}, "CVE-2019-8802": {"epss_score": 0.00288, "epss_percentile": 0.51928}, "CVE-2019-8803": {"epss_score": 0.00159, "epss_percentile": 0.3738}, "CVE-2019-8804": {"epss_score": 0.00155, "epss_percentile": 0.36833}, "CVE-2019-8805": {"epss_score": 0.12917, "epss_percentile": 0.93816}, "CVE-2019-8806": {"epss_score": 0.00343, "epss_percentile": 0.56461}, "CVE-2019-8807": {"epss_score": 0.00317, "epss_percentile": 0.54339}, "CVE-2019-8808": {"epss_score": 0.00331, "epss_percentile": 0.55536}, "CVE-2019-8809": {"epss_score": 0.00071, "epss_percentile": 0.22009}, "CVE-2019-8811": {"epss_score": 0.00337, "epss_percentile": 0.56047}, "CVE-2019-8812": {"epss_score": 0.00274, "epss_percentile": 0.50542}, "CVE-2019-8813": {"epss_score": 0.00336, "epss_percentile": 0.55916}, "CVE-2019-8814": {"epss_score": 0.00704, "epss_percentile": 0.71552}, "CVE-2019-8815": {"epss_score": 0.00849, "epss_percentile": 0.74374}, "CVE-2019-8816": {"epss_score": 0.00493, "epss_percentile": 0.65036}, "CVE-2019-8817": {"epss_score": 0.00314, "epss_percentile": 0.54078}, "CVE-2019-8819": {"epss_score": 0.00518, "epss_percentile": 0.66115}, "CVE-2019-8820": {"epss_score": 0.04919, "epss_percentile": 0.8929}, "CVE-2019-8821": {"epss_score": 0.01007, "epss_percentile": 0.76558}, "CVE-2019-8822": {"epss_score": 0.00861, "epss_percentile": 0.74567}, "CVE-2019-8823": {"epss_score": 0.00518, "epss_percentile": 0.66115}, "CVE-2019-8824": {"epss_score": 0.00367, "epss_percentile": 0.58111}, "CVE-2019-8825": {"epss_score": 0.00547, "epss_percentile": 0.67247}, "CVE-2019-8826": {"epss_score": 0.00681, "epss_percentile": 0.71039}, "CVE-2019-8827": {"epss_score": 0.00609, "epss_percentile": 0.69133}, "CVE-2019-8828": {"epss_score": 0.00484, "epss_percentile": 0.64656}, "CVE-2019-8829": {"epss_score": 0.00182, "epss_percentile": 0.4019}, "CVE-2019-8830": {"epss_score": 0.01747, "epss_percentile": 0.82078}, "CVE-2019-8831": {"epss_score": 0.00245, "epss_percentile": 0.47726}, "CVE-2019-8832": {"epss_score": 0.00484, "epss_percentile": 0.64656}, "CVE-2019-8833": {"epss_score": 0.00484, "epss_percentile": 0.64656}, "CVE-2019-8834": {"epss_score": 0.00317, "epss_percentile": 0.54379}, "CVE-2019-8835": {"epss_score": 0.0057, "epss_percentile": 0.67953}, "CVE-2019-8836": {"epss_score": 0.00484, "epss_percentile": 0.64656}, "CVE-2019-8837": {"epss_score": 0.00179, "epss_percentile": 0.39807}, "CVE-2019-8838": {"epss_score": 0.00484, "epss_percentile": 0.64656}, "CVE-2019-8839": {"epss_score": 0.00313, "epss_percentile": 0.54015}, "CVE-2019-8840": {"epss_score": 0.00976, "epss_percentile": 0.76211}, "CVE-2019-8841": {"epss_score": 0.00061, "epss_percentile": 0.19397}, "CVE-2019-8842": {"epss_score": 0.00195, "epss_percentile": 0.41605}, "CVE-2019-8844": {"epss_score": 0.02465, "epss_percentile": 0.84834}, "CVE-2019-8846": {"epss_score": 0.0057, "epss_percentile": 0.67953}, "CVE-2019-8847": {"epss_score": 0.00326, "epss_percentile": 0.5504}, "CVE-2019-8848": {"epss_score": 0.00297, "epss_percentile": 0.52693}, "CVE-2019-8849": {"epss_score": 0.00593, "epss_percentile": 0.6863}, "CVE-2019-8850": {"epss_score": 0.00299, "epss_percentile": 0.52868}, "CVE-2019-8851": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-8852": {"epss_score": 0.04795, "epss_percentile": 0.89154}, "CVE-2019-8853": {"epss_score": 0.00236, "epss_percentile": 0.46457}, "CVE-2019-8854": {"epss_score": 0.00378, "epss_percentile": 0.58822}, "CVE-2019-8855": {"epss_score": 0.00278, "epss_percentile": 0.50905}, "CVE-2019-8856": {"epss_score": 0.0021, "epss_percentile": 0.43481}, "CVE-2019-8857": {"epss_score": 0.00066, "epss_percentile": 0.20963}, "CVE-2019-8858": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2019-8898": {"epss_score": 0.00456, "epss_percentile": 0.63327}, "CVE-2019-8900": {"epss_score": 0.00405, "epss_percentile": 0.60487}, "CVE-2019-8901": {"epss_score": 0.00153, "epss_percentile": 0.36544}, "CVE-2019-8902": {"epss_score": 0.0008, "epss_percentile": 0.24112}, "CVE-2019-8903": {"epss_score": 0.53251, "epss_percentile": 0.97868}, "CVE-2019-8904": {"epss_score": 0.00596, "epss_percentile": 0.68711}, "CVE-2019-8905": {"epss_score": 0.001, "epss_percentile": 0.28442}, "CVE-2019-8906": {"epss_score": 0.0008, "epss_percentile": 0.24092}, "CVE-2019-8907": {"epss_score": 0.00878, "epss_percentile": 0.74826}, "CVE-2019-8908": {"epss_score": 0.00842, "epss_percentile": 0.74233}, "CVE-2019-8909": {"epss_score": 0.0065, "epss_percentile": 0.70268}, "CVE-2019-8910": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-8911": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-8912": {"epss_score": 0.00357, "epss_percentile": 0.57409}, "CVE-2019-8917": {"epss_score": 0.4535, "epss_percentile": 0.97483}, "CVE-2019-8919": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-8920": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-8921": {"epss_score": 0.00032, "epss_percentile": 0.08784}, "CVE-2019-8922": {"epss_score": 0.0007, "epss_percentile": 0.21705}, "CVE-2019-8923": {"epss_score": 0.12405, "epss_percentile": 0.9366}, "CVE-2019-8924": {"epss_score": 0.02284, "epss_percentile": 0.84262}, "CVE-2019-8925": {"epss_score": 0.0918, "epss_percentile": 0.92434}, "CVE-2019-8926": {"epss_score": 0.02167, "epss_percentile": 0.83852}, "CVE-2019-8927": {"epss_score": 0.02897, "epss_percentile": 0.85927}, "CVE-2019-8928": {"epss_score": 0.02167, "epss_percentile": 0.83852}, "CVE-2019-8929": {"epss_score": 0.02897, "epss_percentile": 0.85927}, "CVE-2019-8931": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2019-8932": {"epss_score": 0.0034, "epss_percentile": 0.56274}, "CVE-2019-8933": {"epss_score": 0.24353, "epss_percentile": 0.95909}, "CVE-2019-8934": {"epss_score": 0.00106, "epss_percentile": 0.29575}, "CVE-2019-8935": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-8936": {"epss_score": 0.24493, "epss_percentile": 0.95926}, "CVE-2019-8937": {"epss_score": 0.50859, "epss_percentile": 0.97753}, "CVE-2019-8938": {"epss_score": 0.0034, "epss_percentile": 0.56281}, "CVE-2019-8939": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2019-8942": {"epss_score": 0.92796, "epss_percentile": 0.9975}, "CVE-2019-8943": {"epss_score": 0.93904, "epss_percentile": 0.99866}, "CVE-2019-8944": {"epss_score": 0.0024, "epss_percentile": 0.47225}, "CVE-2019-8945": {"epss_score": 0.02343, "epss_percentile": 0.84444}, "CVE-2019-8946": {"epss_score": 0.02343, "epss_percentile": 0.84444}, "CVE-2019-8947": {"epss_score": 0.02343, "epss_percentile": 0.84444}, "CVE-2019-8948": {"epss_score": 0.00274, "epss_percentile": 0.50559}, "CVE-2019-8950": {"epss_score": 0.00892, "epss_percentile": 0.75065}, "CVE-2019-8951": {"epss_score": 0.00318, "epss_percentile": 0.54442}, "CVE-2019-8952": {"epss_score": 0.0026, "epss_percentile": 0.49233}, "CVE-2019-8953": {"epss_score": 0.75428, "epss_percentile": 0.98845}, "CVE-2019-8954": {"epss_score": 0.02191, "epss_percentile": 0.83937}, "CVE-2019-8955": {"epss_score": 0.02004, "epss_percentile": 0.83228}, "CVE-2019-8956": {"epss_score": 0.01164, "epss_percentile": 0.78169}, "CVE-2019-8960": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2019-8961": {"epss_score": 0.00677, "epss_percentile": 0.70949}, "CVE-2019-8963": {"epss_score": 0.00197, "epss_percentile": 0.41951}, "CVE-2019-8978": {"epss_score": 0.26062, "epss_percentile": 0.96106}, "CVE-2019-8979": {"epss_score": 0.0841, "epss_percentile": 0.92036}, "CVE-2019-8980": {"epss_score": 0.02157, "epss_percentile": 0.83813}, "CVE-2019-8981": {"epss_score": 0.00611, "epss_percentile": 0.69188}, "CVE-2019-8982": {"epss_score": 0.85711, "epss_percentile": 0.99344}, "CVE-2019-8983": {"epss_score": 0.00285, "epss_percentile": 0.51652}, "CVE-2019-8984": {"epss_score": 0.00285, "epss_percentile": 0.51652}, "CVE-2019-8985": {"epss_score": 0.71811, "epss_percentile": 0.98682}, "CVE-2019-8986": {"epss_score": 0.00294, "epss_percentile": 0.52433}, "CVE-2019-8987": {"epss_score": 0.0038, "epss_percentile": 0.58959}, "CVE-2019-8988": {"epss_score": 0.00246, "epss_percentile": 0.4773}, "CVE-2019-8989": {"epss_score": 0.00204, "epss_percentile": 0.42618}, "CVE-2019-8990": {"epss_score": 0.02196, "epss_percentile": 0.83955}, "CVE-2019-8991": {"epss_score": 0.00214, "epss_percentile": 0.43983}, "CVE-2019-8992": {"epss_score": 0.00793, "epss_percentile": 0.73418}, "CVE-2019-8993": {"epss_score": 0.00774, "epss_percentile": 0.73073}, "CVE-2019-8994": {"epss_score": 0.00197, "epss_percentile": 0.41832}, "CVE-2019-8995": {"epss_score": 0.00198, "epss_percentile": 0.41999}, "CVE-2019-8996": {"epss_score": 0.0057, "epss_percentile": 0.67948}, "CVE-2019-8997": {"epss_score": 0.09018, "epss_percentile": 0.92368}, "CVE-2019-8998": {"epss_score": 0.00047, "epss_percentile": 0.14829}, "CVE-2019-8999": {"epss_score": 0.0044, "epss_percentile": 0.6262}, "CVE-2019-9002": {"epss_score": 0.00838, "epss_percentile": 0.7418}, "CVE-2019-9003": {"epss_score": 0.07009, "epss_percentile": 0.91182}, "CVE-2019-9004": {"epss_score": 0.00349, "epss_percentile": 0.56863}, "CVE-2019-9005": {"epss_score": 0.0053, "epss_percentile": 0.66628}, "CVE-2019-9008": {"epss_score": 0.00653, "epss_percentile": 0.70335}, "CVE-2019-9009": {"epss_score": 0.00381, "epss_percentile": 0.59015}, "CVE-2019-9010": {"epss_score": 0.00468, "epss_percentile": 0.63892}, "CVE-2019-9011": {"epss_score": 0.0022, "epss_percentile": 0.44612}, "CVE-2019-9012": {"epss_score": 0.00283, "epss_percentile": 0.51396}, "CVE-2019-9013": {"epss_score": 0.00205, "epss_percentile": 0.42686}, "CVE-2019-9015": {"epss_score": 0.00417, "epss_percentile": 0.61234}, "CVE-2019-9016": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2019-9017": {"epss_score": 0.16529, "epss_percentile": 0.94686}, "CVE-2019-9019": {"epss_score": 0.00062, "epss_percentile": 0.19623}, "CVE-2019-9020": {"epss_score": 0.03101, "epss_percentile": 0.86409}, "CVE-2019-9021": {"epss_score": 0.30029, "epss_percentile": 0.96497}, "CVE-2019-9022": {"epss_score": 0.08191, "epss_percentile": 0.91922}, "CVE-2019-9023": {"epss_score": 0.11518, "epss_percentile": 0.93391}, "CVE-2019-9024": {"epss_score": 0.17036, "epss_percentile": 0.94763}, "CVE-2019-9025": {"epss_score": 0.00993, "epss_percentile": 0.76416}, "CVE-2019-9026": {"epss_score": 0.00395, "epss_percentile": 0.59799}, "CVE-2019-9027": {"epss_score": 0.00395, "epss_percentile": 0.59799}, "CVE-2019-9028": {"epss_score": 0.00454, "epss_percentile": 0.63249}, "CVE-2019-9029": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2019-9030": {"epss_score": 0.00454, "epss_percentile": 0.63249}, "CVE-2019-9031": {"epss_score": 0.00434, "epss_percentile": 0.62314}, "CVE-2019-9032": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2019-9033": {"epss_score": 0.00454, "epss_percentile": 0.63249}, "CVE-2019-9034": {"epss_score": 0.00454, "epss_percentile": 0.63249}, "CVE-2019-9035": {"epss_score": 0.00196, "epss_percentile": 0.41765}, "CVE-2019-9036": {"epss_score": 0.00209, "epss_percentile": 0.43377}, "CVE-2019-9037": {"epss_score": 0.00196, "epss_percentile": 0.41765}, "CVE-2019-9038": {"epss_score": 0.00229, "epss_percentile": 0.45654}, "CVE-2019-9039": {"epss_score": 0.0034, "epss_percentile": 0.56213}, "CVE-2019-9040": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2019-9041": {"epss_score": 0.85327, "epss_percentile": 0.99329}, "CVE-2019-9042": {"epss_score": 0.00943, "epss_percentile": 0.75775}, "CVE-2019-9047": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-9048": {"epss_score": 0.00161, "epss_percentile": 0.37584}, "CVE-2019-9049": {"epss_score": 0.00161, "epss_percentile": 0.37584}, "CVE-2019-9050": {"epss_score": 0.00943, "epss_percentile": 0.75775}, "CVE-2019-9051": {"epss_score": 0.00117, "epss_percentile": 0.31307}, "CVE-2019-9052": {"epss_score": 0.00117, "epss_percentile": 0.31307}, "CVE-2019-9053": {"epss_score": 0.92582, "epss_percentile": 0.99729}, "CVE-2019-9055": {"epss_score": 0.27554, "epss_percentile": 0.96258}, "CVE-2019-9056": {"epss_score": 0.01225, "epss_percentile": 0.78683}, "CVE-2019-9057": {"epss_score": 0.00905, "epss_percentile": 0.75236}, "CVE-2019-9058": {"epss_score": 0.01005, "epss_percentile": 0.76538}, "CVE-2019-9059": {"epss_score": 0.05294, "epss_percentile": 0.897}, "CVE-2019-9060": {"epss_score": 0.00415, "epss_percentile": 0.61159}, "CVE-2019-9061": {"epss_score": 0.00905, "epss_percentile": 0.75236}, "CVE-2019-9062": {"epss_score": 0.00135, "epss_percentile": 0.33929}, "CVE-2019-9063": {"epss_score": 0.00193, "epss_percentile": 0.4141}, "CVE-2019-9064": {"epss_score": 0.00353, "epss_percentile": 0.57189}, "CVE-2019-9065": {"epss_score": 0.00193, "epss_percentile": 0.4141}, "CVE-2019-9066": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-9070": {"epss_score": 0.00469, "epss_percentile": 0.63948}, "CVE-2019-9071": {"epss_score": 0.00495, "epss_percentile": 0.65113}, "CVE-2019-9072": {"epss_score": 0.00271, "epss_percentile": 0.50332}, "CVE-2019-9073": {"epss_score": 0.00279, "epss_percentile": 0.50967}, "CVE-2019-9074": {"epss_score": 0.00149, "epss_percentile": 0.36038}, "CVE-2019-9075": {"epss_score": 0.00279, "epss_percentile": 0.50971}, "CVE-2019-9076": {"epss_score": 0.002, "epss_percentile": 0.42275}, "CVE-2019-9077": {"epss_score": 0.00295, "epss_percentile": 0.52442}, "CVE-2019-9078": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-9080": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2019-9082": {"epss_score": 0.93965, "epss_percentile": 0.99876}, "CVE-2019-9083": {"epss_score": 0.01979, "epss_percentile": 0.83133}, "CVE-2019-9084": {"epss_score": 0.00735, "epss_percentile": 0.72299}, "CVE-2019-9085": {"epss_score": 0.00717, "epss_percentile": 0.7188}, "CVE-2019-9086": {"epss_score": 0.0043, "epss_percentile": 0.62025}, "CVE-2019-9087": {"epss_score": 0.0043, "epss_percentile": 0.62025}, "CVE-2019-9093": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-9094": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-9095": {"epss_score": 0.00116, "epss_percentile": 0.31156}, "CVE-2019-9096": {"epss_score": 0.00285, "epss_percentile": 0.51523}, "CVE-2019-9097": {"epss_score": 0.0033, "epss_percentile": 0.5549}, "CVE-2019-9098": {"epss_score": 0.00906, "epss_percentile": 0.75251}, "CVE-2019-9099": {"epss_score": 0.07019, "epss_percentile": 0.9119}, "CVE-2019-9101": {"epss_score": 0.00095, "epss_percentile": 0.27172}, "CVE-2019-9102": {"epss_score": 0.00154, "epss_percentile": 0.36699}, "CVE-2019-9103": {"epss_score": 0.00295, "epss_percentile": 0.52442}, "CVE-2019-9104": {"epss_score": 0.00133, "epss_percentile": 0.3368}, "CVE-2019-9105": {"epss_score": 0.00516, "epss_percentile": 0.66032}, "CVE-2019-9106": {"epss_score": 0.01655, "epss_percentile": 0.81592}, "CVE-2019-9107": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-9108": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-9109": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-9110": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2019-9111": {"epss_score": 0.00149, "epss_percentile": 0.35982}, "CVE-2019-9112": {"epss_score": 0.00149, "epss_percentile": 0.35982}, "CVE-2019-9113": {"epss_score": 0.00285, "epss_percentile": 0.51527}, "CVE-2019-9114": {"epss_score": 0.00332, "epss_percentile": 0.55577}, "CVE-2019-9115": {"epss_score": 0.01115, "epss_percentile": 0.77708}, "CVE-2019-9116": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2019-9117": {"epss_score": 0.09273, "epss_percentile": 0.92478}, "CVE-2019-9118": {"epss_score": 0.09273, "epss_percentile": 0.92478}, "CVE-2019-9119": {"epss_score": 0.09273, "epss_percentile": 0.92478}, "CVE-2019-9120": {"epss_score": 0.09273, "epss_percentile": 0.92478}, "CVE-2019-9121": {"epss_score": 0.03998, "epss_percentile": 0.88085}, "CVE-2019-9122": {"epss_score": 0.11294, "epss_percentile": 0.93295}, "CVE-2019-9123": {"epss_score": 0.00559, "epss_percentile": 0.67621}, "CVE-2019-9124": {"epss_score": 0.00783, "epss_percentile": 0.73222}, "CVE-2019-9125": {"epss_score": 0.01457, "epss_percentile": 0.80402}, "CVE-2019-9126": {"epss_score": 0.00533, "epss_percentile": 0.66715}, "CVE-2019-9132": {"epss_score": 0.01667, "epss_percentile": 0.81656}, "CVE-2019-9133": {"epss_score": 0.00128, "epss_percentile": 0.33063}, "CVE-2019-9134": {"epss_score": 0.01428, "epss_percentile": 0.80222}, "CVE-2019-9135": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2019-9136": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2019-9137": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2019-9138": {"epss_score": 0.00319, "epss_percentile": 0.54475}, "CVE-2019-9139": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2019-9140": {"epss_score": 0.0031, "epss_percentile": 0.53764}, "CVE-2019-9141": {"epss_score": 0.01229, "epss_percentile": 0.7872}, "CVE-2019-9142": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-9143": {"epss_score": 0.00468, "epss_percentile": 0.63889}, "CVE-2019-9144": {"epss_score": 0.01442, "epss_percentile": 0.80311}, "CVE-2019-9145": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-9146": {"epss_score": 0.00102, "epss_percentile": 0.2883}, "CVE-2019-9147": {"epss_score": 0.00251, "epss_percentile": 0.4826}, "CVE-2019-9148": {"epss_score": 0.00265, "epss_percentile": 0.49807}, "CVE-2019-9149": {"epss_score": 0.00114, "epss_percentile": 0.30839}, "CVE-2019-9150": {"epss_score": 0.00283, "epss_percentile": 0.51393}, "CVE-2019-9151": {"epss_score": 0.00418, "epss_percentile": 0.61288}, "CVE-2019-9152": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2019-9153": {"epss_score": 0.00362, "epss_percentile": 0.57816}, "CVE-2019-9154": {"epss_score": 0.00389, "epss_percentile": 0.59469}, "CVE-2019-9155": {"epss_score": 0.00309, "epss_percentile": 0.53705}, "CVE-2019-9156": {"epss_score": 0.01531, "epss_percentile": 0.80889}, "CVE-2019-9157": {"epss_score": 0.0012, "epss_percentile": 0.31688}, "CVE-2019-9158": {"epss_score": 0.00139, "epss_percentile": 0.34636}, "CVE-2019-9160": {"epss_score": 0.01816, "epss_percentile": 0.82392}, "CVE-2019-9161": {"epss_score": 0.03677, "epss_percentile": 0.87554}, "CVE-2019-9162": {"epss_score": 0.00209, "epss_percentile": 0.43308}, "CVE-2019-9163": {"epss_score": 0.02622, "epss_percentile": 0.85257}, "CVE-2019-9164": {"epss_score": 0.65671, "epss_percentile": 0.98432}, "CVE-2019-9165": {"epss_score": 0.0663, "epss_percentile": 0.90903}, "CVE-2019-9166": {"epss_score": 0.00035, "epss_percentile": 0.09902}, "CVE-2019-9167": {"epss_score": 0.1422, "epss_percentile": 0.94166}, "CVE-2019-9168": {"epss_score": 0.00192, "epss_percentile": 0.41365}, "CVE-2019-9169": {"epss_score": 0.13732, "epss_percentile": 0.94045}, "CVE-2019-9170": {"epss_score": 0.00193, "epss_percentile": 0.41492}, "CVE-2019-9171": {"epss_score": 0.00193, "epss_percentile": 0.41492}, "CVE-2019-9172": {"epss_score": 0.00216, "epss_percentile": 0.44201}, "CVE-2019-9174": {"epss_score": 0.00355, "epss_percentile": 0.57262}, "CVE-2019-9175": {"epss_score": 0.00195, "epss_percentile": 0.41647}, "CVE-2019-9176": {"epss_score": 0.00105, "epss_percentile": 0.29378}, "CVE-2019-9178": {"epss_score": 0.00195, "epss_percentile": 0.41647}, "CVE-2019-9179": {"epss_score": 0.00195, "epss_percentile": 0.41647}, "CVE-2019-9181": {"epss_score": 0.00943, "epss_percentile": 0.75775}, "CVE-2019-9182": {"epss_score": 0.00171, "epss_percentile": 0.38771}, "CVE-2019-9183": {"epss_score": 0.00585, "epss_percentile": 0.68414}, "CVE-2019-9184": {"epss_score": 0.25611, "epss_percentile": 0.9605}, "CVE-2019-9185": {"epss_score": 0.01076, "epss_percentile": 0.77324}, "CVE-2019-9186": {"epss_score": 0.00012, "epss_percentile": 0.01138}, "CVE-2019-9187": {"epss_score": 0.0033, "epss_percentile": 0.55484}, "CVE-2019-9189": {"epss_score": 0.22186, "epss_percentile": 0.95605}, "CVE-2019-9191": {"epss_score": 0.00665, "epss_percentile": 0.7066}, "CVE-2019-9192": {"epss_score": 0.00942, "epss_percentile": 0.7576}, "CVE-2019-9193": {"epss_score": 0.93587, "epss_percentile": 0.99822}, "CVE-2019-9194": {"epss_score": 0.93033, "epss_percentile": 0.99769}, "CVE-2019-9195": {"epss_score": 0.00587, "epss_percentile": 0.68483}, "CVE-2019-9196": {"epss_score": 0.00352, "epss_percentile": 0.57108}, "CVE-2019-9197": {"epss_score": 0.03483, "epss_percentile": 0.87222}, "CVE-2019-9199": {"epss_score": 0.0045, "epss_percentile": 0.63096}, "CVE-2019-9200": {"epss_score": 0.0538, "epss_percentile": 0.8981}, "CVE-2019-9201": {"epss_score": 0.00764, "epss_percentile": 0.72895}, "CVE-2019-9202": {"epss_score": 0.4252, "epss_percentile": 0.97335}, "CVE-2019-9203": {"epss_score": 0.05494, "epss_percentile": 0.89932}, "CVE-2019-9204": {"epss_score": 0.0403, "epss_percentile": 0.8815}, "CVE-2019-9206": {"epss_score": 0.00193, "epss_percentile": 0.41438}, "CVE-2019-9207": {"epss_score": 0.00193, "epss_percentile": 0.41438}, "CVE-2019-9208": {"epss_score": 0.04306, "epss_percentile": 0.88522}, "CVE-2019-9209": {"epss_score": 0.00575, "epss_percentile": 0.68097}, "CVE-2019-9210": {"epss_score": 0.00452, "epss_percentile": 0.63163}, "CVE-2019-9211": {"epss_score": 0.00518, "epss_percentile": 0.66098}, "CVE-2019-9212": {"epss_score": 0.0088, "epss_percentile": 0.74852}, "CVE-2019-9213": {"epss_score": 0.05303, "epss_percentile": 0.89709}, "CVE-2019-9214": {"epss_score": 0.04984, "epss_percentile": 0.89363}, "CVE-2019-9215": {"epss_score": 0.00936, "epss_percentile": 0.75687}, "CVE-2019-9217": {"epss_score": 0.00145, "epss_percentile": 0.3542}, "CVE-2019-9218": {"epss_score": 0.00228, "epss_percentile": 0.4552}, "CVE-2019-9219": {"epss_score": 0.00193, "epss_percentile": 0.41492}, "CVE-2019-9220": {"epss_score": 0.00314, "epss_percentile": 0.54117}, "CVE-2019-9221": {"epss_score": 0.00024, "epss_percentile": 0.05735}, "CVE-2019-9222": {"epss_score": 0.00291, "epss_percentile": 0.52194}, "CVE-2019-9223": {"epss_score": 0.002, "epss_percentile": 0.42228}, "CVE-2019-9224": {"epss_score": 0.00193, "epss_percentile": 0.41492}, "CVE-2019-9225": {"epss_score": 0.00195, "epss_percentile": 0.41647}, "CVE-2019-9226": {"epss_score": 0.00315, "epss_percentile": 0.54184}, "CVE-2019-9227": {"epss_score": 0.03112, "epss_percentile": 0.86428}, "CVE-2019-9228": {"epss_score": 0.00563, "epss_percentile": 0.67718}, "CVE-2019-9229": {"epss_score": 0.00103, "epss_percentile": 0.28921}, "CVE-2019-9230": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2019-9231": {"epss_score": 0.00197, "epss_percentile": 0.41834}, "CVE-2019-9232": {"epss_score": 0.09266, "epss_percentile": 0.92471}, "CVE-2019-9233": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9234": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9235": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9236": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9237": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9238": {"epss_score": 0.00012, "epss_percentile": 0.01308}, "CVE-2019-9239": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9240": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9241": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9242": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9243": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-9244": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9245": {"epss_score": 0.00047, "epss_percentile": 0.14477}, "CVE-2019-9246": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9247": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9248": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2019-9249": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-9250": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9251": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9252": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9253": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2019-9254": {"epss_score": 0.00104, "epss_percentile": 0.29187}, "CVE-2019-9256": {"epss_score": 0.00222, "epss_percentile": 0.44782}, "CVE-2019-9257": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2019-9258": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2019-9259": {"epss_score": 0.00014, "epss_percentile": 0.02035}, "CVE-2019-9260": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9261": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-9262": {"epss_score": 0.00222, "epss_percentile": 0.44782}, "CVE-2019-9263": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2019-9264": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-9265": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9266": {"epss_score": 0.00012, "epss_percentile": 0.01308}, "CVE-2019-9268": {"epss_score": 0.00013, "epss_percentile": 0.01582}, "CVE-2019-9269": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2019-9270": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2019-9271": {"epss_score": 0.00017, "epss_percentile": 0.03183}, "CVE-2019-9272": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2019-9273": {"epss_score": 0.00015, "epss_percentile": 0.02315}, "CVE-2019-9274": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2019-9275": {"epss_score": 0.00086, "epss_percentile": 0.25343}, "CVE-2019-9276": {"epss_score": 0.00019, "epss_percentile": 0.04322}, "CVE-2019-9277": {"epss_score": 0.00015, "epss_percentile": 0.02311}, "CVE-2019-9278": {"epss_score": 0.03749, "epss_percentile": 0.87672}, "CVE-2019-9279": {"epss_score": 0.00501, "epss_percentile": 0.65337}, "CVE-2019-9280": {"epss_score": 0.00014, "epss_percentile": 0.02103}, "CVE-2019-9281": {"epss_score": 0.00177, "epss_percentile": 0.39507}, "CVE-2019-9282": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9283": {"epss_score": 0.00319, "epss_percentile": 0.54482}, "CVE-2019-9284": {"epss_score": 0.0018, "epss_percentile": 0.39931}, "CVE-2019-9285": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9286": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9287": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-9288": {"epss_score": 0.00016, "epss_percentile": 0.02757}, "CVE-2019-9289": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-9290": {"epss_score": 0.00011, "epss_percentile": 0.01021}, "CVE-2019-9291": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9292": {"epss_score": 0.00015, "epss_percentile": 0.02311}, "CVE-2019-9293": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9294": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9295": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2019-9296": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9297": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9298": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9299": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9300": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9301": {"epss_score": 0.00646, "epss_percentile": 0.70144}, "CVE-2019-9302": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9303": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9304": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9305": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9306": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9307": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9308": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9309": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2019-9310": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9311": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9312": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-9313": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9314": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9315": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9316": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9317": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9318": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9319": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9320": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9321": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9322": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9323": {"epss_score": 0.00107, "epss_percentile": 0.29651}, "CVE-2019-9325": {"epss_score": 0.0889, "epss_percentile": 0.92303}, "CVE-2019-9326": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9327": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9328": {"epss_score": 0.0018, "epss_percentile": 0.39931}, "CVE-2019-9329": {"epss_score": 0.0018, "epss_percentile": 0.39931}, "CVE-2019-9330": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9331": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9332": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9333": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9334": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9335": {"epss_score": 0.00279, "epss_percentile": 0.50932}, "CVE-2019-9336": {"epss_score": 0.00279, "epss_percentile": 0.50932}, "CVE-2019-9337": {"epss_score": 0.00279, "epss_percentile": 0.50932}, "CVE-2019-9338": {"epss_score": 0.00279, "epss_percentile": 0.50932}, "CVE-2019-9341": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9342": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9343": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9344": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9345": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2019-9346": {"epss_score": 0.00761, "epss_percentile": 0.72818}, "CVE-2019-9347": {"epss_score": 0.00019, "epss_percentile": 0.04358}, "CVE-2019-9348": {"epss_score": 0.00346, "epss_percentile": 0.56653}, "CVE-2019-9349": {"epss_score": 0.00346, "epss_percentile": 0.56653}, "CVE-2019-9350": {"epss_score": 0.00018, "epss_percentile": 0.03602}, "CVE-2019-9351": {"epss_score": 0.00016, "epss_percentile": 0.02655}, "CVE-2019-9352": {"epss_score": 0.00294, "epss_percentile": 0.52364}, "CVE-2019-9353": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9354": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-9355": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9356": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9357": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9358": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2019-9359": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9360": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2019-9361": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9362": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9363": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9364": {"epss_score": 0.00012, "epss_percentile": 0.01262}, "CVE-2019-9365": {"epss_score": 0.01445, "epss_percentile": 0.80322}, "CVE-2019-9366": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9367": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9368": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-9369": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-9370": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9371": {"epss_score": 0.17758, "epss_percentile": 0.94899}, "CVE-2019-9372": {"epss_score": 0.00403, "epss_percentile": 0.60384}, "CVE-2019-9373": {"epss_score": 0.00027, "epss_percentile": 0.06896}, "CVE-2019-9375": {"epss_score": 0.0001, "epss_percentile": 0.0075}, "CVE-2019-9376": {"epss_score": 0.00015, "epss_percentile": 0.0233}, "CVE-2019-9377": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2019-9378": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2019-9379": {"epss_score": 0.00346, "epss_percentile": 0.56653}, "CVE-2019-9380": {"epss_score": 0.00082, "epss_percentile": 0.24532}, "CVE-2019-9381": {"epss_score": 0.00366, "epss_percentile": 0.58092}, "CVE-2019-9382": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9383": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9384": {"epss_score": 0.0001, "epss_percentile": 0.00912}, "CVE-2019-9385": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9386": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2019-9387": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9388": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9389": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9390": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9391": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2019-9393": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9394": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9395": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9396": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9397": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9398": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9399": {"epss_score": 0.00195, "epss_percentile": 0.41653}, "CVE-2019-9400": {"epss_score": 0.00501, "epss_percentile": 0.65337}, "CVE-2019-9401": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9402": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9403": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9404": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9405": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2019-9406": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9407": {"epss_score": 0.00013, "epss_percentile": 0.01556}, "CVE-2019-9408": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9409": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9410": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9411": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9412": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9413": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9414": {"epss_score": 0.00143, "epss_percentile": 0.35115}, "CVE-2019-9415": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9416": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9417": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-9418": {"epss_score": 0.00346, "epss_percentile": 0.56653}, "CVE-2019-9419": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9420": {"epss_score": 0.00294, "epss_percentile": 0.52364}, "CVE-2019-9421": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2019-9422": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9423": {"epss_score": 0.0003, "epss_percentile": 0.08201}, "CVE-2019-9424": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2019-9425": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9426": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2019-9427": {"epss_score": 0.00019, "epss_percentile": 0.04358}, "CVE-2019-9428": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2019-9429": {"epss_score": 0.00011, "epss_percentile": 0.01021}, "CVE-2019-9430": {"epss_score": 0.00501, "epss_percentile": 0.65337}, "CVE-2019-9431": {"epss_score": 0.00252, "epss_percentile": 0.48366}, "CVE-2019-9432": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9433": {"epss_score": 0.08604, "epss_percentile": 0.92146}, "CVE-2019-9434": {"epss_score": 0.00215, "epss_percentile": 0.44025}, "CVE-2019-9435": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-9436": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2019-9438": {"epss_score": 0.00015, "epss_percentile": 0.02311}, "CVE-2019-9440": {"epss_score": 0.00015, "epss_percentile": 0.02311}, "CVE-2019-9441": {"epss_score": 0.00018, "epss_percentile": 0.0402}, "CVE-2019-9442": {"epss_score": 0.00019, "epss_percentile": 0.04099}, "CVE-2019-9443": {"epss_score": 0.00013, "epss_percentile": 0.01573}, "CVE-2019-9444": {"epss_score": 0.00088, "epss_percentile": 0.2571}, "CVE-2019-9445": {"epss_score": 0.0006, "epss_percentile": 0.1897}, "CVE-2019-9446": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2019-9447": {"epss_score": 0.00015, "epss_percentile": 0.02315}, "CVE-2019-9448": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2019-9449": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2019-9450": {"epss_score": 0.00013, "epss_percentile": 0.01522}, "CVE-2019-9451": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2019-9452": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2019-9453": {"epss_score": 0.00036, "epss_percentile": 0.10406}, "CVE-2019-9454": {"epss_score": 0.00021, "epss_percentile": 0.04899}, "CVE-2019-9455": {"epss_score": 0.00023, "epss_percentile": 0.05433}, "CVE-2019-9456": {"epss_score": 0.00036, "epss_percentile": 0.10317}, "CVE-2019-9458": {"epss_score": 0.00018, "epss_percentile": 0.03665}, "CVE-2019-9459": {"epss_score": 0.00762, "epss_percentile": 0.72843}, "CVE-2019-9461": {"epss_score": 0.00634, "epss_percentile": 0.69801}, "CVE-2019-9462": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2019-9463": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2019-9464": {"epss_score": 0.00075, "epss_percentile": 0.22969}, "CVE-2019-9465": {"epss_score": 0.00032, "epss_percentile": 0.08819}, "CVE-2019-9467": {"epss_score": 0.00095, "epss_percentile": 0.27139}, "CVE-2019-9468": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2019-9469": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2019-9470": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2019-9471": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2019-9472": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2019-9473": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9474": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2019-9475": {"epss_score": 0.00013, "epss_percentile": 0.01523}, "CVE-2019-9482": {"epss_score": 0.00359, "epss_percentile": 0.57591}, "CVE-2019-9483": {"epss_score": 0.00077, "epss_percentile": 0.23414}, "CVE-2019-9484": {"epss_score": 0.00278, "epss_percentile": 0.5089}, "CVE-2019-9485": {"epss_score": 0.00181, "epss_percentile": 0.40057}, "CVE-2019-9486": {"epss_score": 0.00723, "epss_percentile": 0.72026}, "CVE-2019-9488": {"epss_score": 0.00596, "epss_percentile": 0.68734}, "CVE-2019-9489": {"epss_score": 0.00566, "epss_percentile": 0.67828}, "CVE-2019-9490": {"epss_score": 0.00696, "epss_percentile": 0.71393}, "CVE-2019-9491": {"epss_score": 0.21524, "epss_percentile": 0.95529}, "CVE-2019-9492": {"epss_score": 0.00105, "epss_percentile": 0.29262}, "CVE-2019-9493": {"epss_score": 0.09171, "epss_percentile": 0.92431}, "CVE-2019-9494": {"epss_score": 0.01473, "epss_percentile": 0.80517}, "CVE-2019-9495": {"epss_score": 0.04536, "epss_percentile": 0.88816}, "CVE-2019-9496": {"epss_score": 0.02156, "epss_percentile": 0.8381}, "CVE-2019-9497": {"epss_score": 0.08116, "epss_percentile": 0.91887}, "CVE-2019-9498": {"epss_score": 0.01063, "epss_percentile": 0.77189}, "CVE-2019-9499": {"epss_score": 0.01063, "epss_percentile": 0.77189}, "CVE-2019-9500": {"epss_score": 0.03469, "epss_percentile": 0.87195}, "CVE-2019-9501": {"epss_score": 0.02274, "epss_percentile": 0.84224}, "CVE-2019-9502": {"epss_score": 0.01413, "epss_percentile": 0.80121}, "CVE-2019-9503": {"epss_score": 0.00823, "epss_percentile": 0.73932}, "CVE-2019-9505": {"epss_score": 0.02, "epss_percentile": 0.83216}, "CVE-2019-9506": {"epss_score": 0.03044, "epss_percentile": 0.86278}, "CVE-2019-9507": {"epss_score": 0.00692, "epss_percentile": 0.713}, "CVE-2019-9508": {"epss_score": 0.00179, "epss_percentile": 0.39748}, "CVE-2019-9509": {"epss_score": 0.0035, "epss_percentile": 0.56959}, "CVE-2019-9510": {"epss_score": 0.00983, "epss_percentile": 0.76309}, "CVE-2019-9511": {"epss_score": 0.13948, "epss_percentile": 0.94098}, "CVE-2019-9512": {"epss_score": 0.51232, "epss_percentile": 0.9777}, "CVE-2019-9513": {"epss_score": 0.04784, "epss_percentile": 0.89139}, "CVE-2019-9514": {"epss_score": 0.09483, "epss_percentile": 0.92568}, "CVE-2019-9515": {"epss_score": 0.10394, "epss_percentile": 0.92973}, "CVE-2019-9516": {"epss_score": 0.02393, "epss_percentile": 0.84612}, "CVE-2019-9517": {"epss_score": 0.04564, "epss_percentile": 0.88855}, "CVE-2019-9518": {"epss_score": 0.03674, "epss_percentile": 0.8755}, "CVE-2019-9529": {"epss_score": 0.00171, "epss_percentile": 0.38839}, "CVE-2019-9530": {"epss_score": 0.001, "epss_percentile": 0.28478}, "CVE-2019-9531": {"epss_score": 0.01588, "epss_percentile": 0.81186}, "CVE-2019-9532": {"epss_score": 0.00079, "epss_percentile": 0.23859}, "CVE-2019-9533": {"epss_score": 0.00633, "epss_percentile": 0.69764}, "CVE-2019-9534": {"epss_score": 0.00061, "epss_percentile": 0.19329}, "CVE-2019-9535": {"epss_score": 0.01688, "epss_percentile": 0.81761}, "CVE-2019-9536": {"epss_score": 0.00166, "epss_percentile": 0.38255}, "CVE-2019-9537": {"epss_score": 0.00279, "epss_percentile": 0.50952}, "CVE-2019-9538": {"epss_score": 0.00279, "epss_percentile": 0.50952}, "CVE-2019-9539": {"epss_score": 0.00279, "epss_percentile": 0.50952}, "CVE-2019-9540": {"epss_score": 0.00279, "epss_percentile": 0.50952}, "CVE-2019-9541": {"epss_score": 0.00279, "epss_percentile": 0.50952}, "CVE-2019-9542": {"epss_score": 0.00279, "epss_percentile": 0.50952}, "CVE-2019-9543": {"epss_score": 0.00665, "epss_percentile": 0.70659}, "CVE-2019-9544": {"epss_score": 0.00402, "epss_percentile": 0.60281}, "CVE-2019-9545": {"epss_score": 0.00333, "epss_percentile": 0.55652}, "CVE-2019-9546": {"epss_score": 0.01791, "epss_percentile": 0.82283}, "CVE-2019-9547": {"epss_score": 0.00305, "epss_percentile": 0.53327}, "CVE-2019-9548": {"epss_score": 0.00527, "epss_percentile": 0.66521}, "CVE-2019-9549": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-9550": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-9551": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-9552": {"epss_score": 0.00817, "epss_percentile": 0.7384}, "CVE-2019-9553": {"epss_score": 0.00993, "epss_percentile": 0.76409}, "CVE-2019-9554": {"epss_score": 0.01546, "epss_percentile": 0.8097}, "CVE-2019-9555": {"epss_score": 0.00245, "epss_percentile": 0.47686}, "CVE-2019-9556": {"epss_score": 0.00497, "epss_percentile": 0.65178}, "CVE-2019-9557": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2019-9558": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2019-9563": {"epss_score": 0.00237, "epss_percentile": 0.46707}, "CVE-2019-9564": {"epss_score": 0.00379, "epss_percentile": 0.58844}, "CVE-2019-9565": {"epss_score": 0.00326, "epss_percentile": 0.55069}, "CVE-2019-9566": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-9567": {"epss_score": 0.00591, "epss_percentile": 0.68585}, "CVE-2019-9568": {"epss_score": 0.00638, "epss_percentile": 0.69918}, "CVE-2019-9569": {"epss_score": 0.06938, "epss_percentile": 0.91129}, "CVE-2019-9570": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-9572": {"epss_score": 0.00943, "epss_percentile": 0.75775}, "CVE-2019-9573": {"epss_score": 0.00298, "epss_percentile": 0.52809}, "CVE-2019-9574": {"epss_score": 0.00922, "epss_percentile": 0.75488}, "CVE-2019-9575": {"epss_score": 0.00391, "epss_percentile": 0.59634}, "CVE-2019-9576": {"epss_score": 0.00238, "epss_percentile": 0.46771}, "CVE-2019-9578": {"epss_score": 0.01501, "epss_percentile": 0.8072}, "CVE-2019-9579": {"epss_score": 0.00686, "epss_percentile": 0.71154}, "CVE-2019-9580": {"epss_score": 0.10724, "epss_percentile": 0.93083}, "CVE-2019-9581": {"epss_score": 0.17653, "epss_percentile": 0.94885}, "CVE-2019-9582": {"epss_score": 0.00173, "epss_percentile": 0.39058}, "CVE-2019-9583": {"epss_score": 0.00147, "epss_percentile": 0.35697}, "CVE-2019-9584": {"epss_score": 0.00448, "epss_percentile": 0.6299}, "CVE-2019-9585": {"epss_score": 0.00448, "epss_percentile": 0.6299}, "CVE-2019-9587": {"epss_score": 0.00337, "epss_percentile": 0.56039}, "CVE-2019-9588": {"epss_score": 0.00337, "epss_percentile": 0.56039}, "CVE-2019-9589": {"epss_score": 0.00248, "epss_percentile": 0.47976}, "CVE-2019-9590": {"epss_score": 0.0065, "epss_percentile": 0.70268}, "CVE-2019-9591": {"epss_score": 0.02798, "epss_percentile": 0.85688}, "CVE-2019-9592": {"epss_score": 0.02798, "epss_percentile": 0.85688}, "CVE-2019-9593": {"epss_score": 0.01677, "epss_percentile": 0.81714}, "CVE-2019-9594": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2019-9595": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-9596": {"epss_score": 0.02074, "epss_percentile": 0.835}, "CVE-2019-9597": {"epss_score": 0.00287, "epss_percentile": 0.51806}, "CVE-2019-9598": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2019-9599": {"epss_score": 0.2006, "epss_percentile": 0.95282}, "CVE-2019-9600": {"epss_score": 0.19845, "epss_percentile": 0.95249}, "CVE-2019-9601": {"epss_score": 0.19845, "epss_percentile": 0.95249}, "CVE-2019-9603": {"epss_score": 0.00098, "epss_percentile": 0.27733}, "CVE-2019-9604": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-9605": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-9606": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-9607": {"epss_score": 0.00264, "epss_percentile": 0.49569}, "CVE-2019-9608": {"epss_score": 0.02191, "epss_percentile": 0.83937}, "CVE-2019-9609": {"epss_score": 0.02191, "epss_percentile": 0.83937}, "CVE-2019-9610": {"epss_score": 0.00167, "epss_percentile": 0.38343}, "CVE-2019-9611": {"epss_score": 0.00372, "epss_percentile": 0.58453}, "CVE-2019-9612": {"epss_score": 0.02191, "epss_percentile": 0.83937}, "CVE-2019-9613": {"epss_score": 0.02331, "epss_percentile": 0.84406}, "CVE-2019-9614": {"epss_score": 0.03168, "epss_percentile": 0.86543}, "CVE-2019-9615": {"epss_score": 0.0026, "epss_percentile": 0.4924}, "CVE-2019-9616": {"epss_score": 0.02331, "epss_percentile": 0.84406}, "CVE-2019-9617": {"epss_score": 0.02191, "epss_percentile": 0.83937}, "CVE-2019-9618": {"epss_score": 0.88158, "epss_percentile": 0.99461}, "CVE-2019-9621": {"epss_score": 0.94119, "epss_percentile": 0.99906}, "CVE-2019-9622": {"epss_score": 0.03566, "epss_percentile": 0.87362}, "CVE-2019-9623": {"epss_score": 0.19266, "epss_percentile": 0.95157}, "CVE-2019-9624": {"epss_score": 0.51258, "epss_percentile": 0.97771}, "CVE-2019-9625": {"epss_score": 0.00245, "epss_percentile": 0.47706}, "CVE-2019-9626": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2019-9627": {"epss_score": 0.00061, "epss_percentile": 0.19524}, "CVE-2019-9628": {"epss_score": 0.00845, "epss_percentile": 0.74288}, "CVE-2019-9629": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2019-9630": {"epss_score": 0.01059, "epss_percentile": 0.77149}, "CVE-2019-9631": {"epss_score": 0.02178, "epss_percentile": 0.83889}, "CVE-2019-9632": {"epss_score": 0.79234, "epss_percentile": 0.99025}, "CVE-2019-9633": {"epss_score": 0.00654, "epss_percentile": 0.70355}, "CVE-2019-9634": {"epss_score": 0.00552, "epss_percentile": 0.67388}, "CVE-2019-9635": {"epss_score": 0.00119, "epss_percentile": 0.31639}, "CVE-2019-9636": {"epss_score": 0.08764, "epss_percentile": 0.92245}, "CVE-2019-9637": {"epss_score": 0.12424, "epss_percentile": 0.93666}, "CVE-2019-9638": {"epss_score": 0.15914, "epss_percentile": 0.9453}, "CVE-2019-9639": {"epss_score": 0.18, "epss_percentile": 0.94941}, "CVE-2019-9640": {"epss_score": 0.16236, "epss_percentile": 0.94598}, "CVE-2019-9641": {"epss_score": 0.52083, "epss_percentile": 0.97807}, "CVE-2019-9642": {"epss_score": 0.02015, "epss_percentile": 0.83272}, "CVE-2019-9644": {"epss_score": 0.01017, "epss_percentile": 0.7669}, "CVE-2019-9646": {"epss_score": 0.00238, "epss_percentile": 0.46771}, "CVE-2019-9647": {"epss_score": 0.01231, "epss_percentile": 0.78729}, "CVE-2019-9648": {"epss_score": 0.20313, "epss_percentile": 0.9532}, "CVE-2019-9649": {"epss_score": 0.29681, "epss_percentile": 0.96465}, "CVE-2019-9650": {"epss_score": 0.03321, "epss_percentile": 0.86909}, "CVE-2019-9651": {"epss_score": 0.01201, "epss_percentile": 0.78484}, "CVE-2019-9652": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-9653": {"epss_score": 0.77845, "epss_percentile": 0.98957}, "CVE-2019-9656": {"epss_score": 0.00925, "epss_percentile": 0.75534}, "CVE-2019-9657": {"epss_score": 0.00037, "epss_percentile": 0.10775}, "CVE-2019-9658": {"epss_score": 0.0374, "epss_percentile": 0.87657}, "CVE-2019-9659": {"epss_score": 0.0028, "epss_percentile": 0.51083}, "CVE-2019-9660": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-9661": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2019-9662": {"epss_score": 0.00332, "epss_percentile": 0.55597}, "CVE-2019-9668": {"epss_score": 0.01063, "epss_percentile": 0.77193}, "CVE-2019-9669": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2019-9670": {"epss_score": 0.9443, "epss_percentile": 0.99982}, "CVE-2019-9673": {"epss_score": 0.16422, "epss_percentile": 0.94658}, "CVE-2019-9674": {"epss_score": 0.01156, "epss_percentile": 0.78087}, "CVE-2019-9675": {"epss_score": 0.00554, "epss_percentile": 0.67445}, "CVE-2019-9676": {"epss_score": 0.00118, "epss_percentile": 0.31478}, "CVE-2019-9677": {"epss_score": 0.0086, "epss_percentile": 0.74544}, "CVE-2019-9678": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2019-9679": {"epss_score": 0.00328, "epss_percentile": 0.55186}, "CVE-2019-9680": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2019-9681": {"epss_score": 0.0017, "epss_percentile": 0.3868}, "CVE-2019-9682": {"epss_score": 0.0042, "epss_percentile": 0.6141}, "CVE-2019-9686": {"epss_score": 0.00505, "epss_percentile": 0.65598}, "CVE-2019-9687": {"epss_score": 0.00559, "epss_percentile": 0.67607}, "CVE-2019-9688": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2019-9689": {"epss_score": 0.00475, "epss_percentile": 0.64176}, "CVE-2019-9692": {"epss_score": 0.55746, "epss_percentile": 0.97994}, "CVE-2019-9693": {"epss_score": 0.00357, "epss_percentile": 0.57456}, "CVE-2019-9694": {"epss_score": 0.00041, "epss_percentile": 0.12385}, "CVE-2019-9695": {"epss_score": 0.00098, "epss_percentile": 0.27831}, "CVE-2019-9696": {"epss_score": 0.00381, "epss_percentile": 0.58988}, "CVE-2019-9697": {"epss_score": 0.00387, "epss_percentile": 0.59337}, "CVE-2019-9698": {"epss_score": 0.00054, "epss_percentile": 0.17196}, "CVE-2019-9699": {"epss_score": 0.0013, "epss_percentile": 0.33231}, "CVE-2019-9700": {"epss_score": 0.00051, "epss_percentile": 0.16006}, "CVE-2019-9701": {"epss_score": 0.00485, "epss_percentile": 0.64673}, "CVE-2019-9702": {"epss_score": 0.00121, "epss_percentile": 0.31925}, "CVE-2019-9703": {"epss_score": 0.00121, "epss_percentile": 0.31925}, "CVE-2019-9704": {"epss_score": 0.00161, "epss_percentile": 0.37589}, "CVE-2019-9705": {"epss_score": 0.00161, "epss_percentile": 0.37589}, "CVE-2019-9706": {"epss_score": 0.00054, "epss_percentile": 0.17141}, "CVE-2019-9708": {"epss_score": 0.00366, "epss_percentile": 0.58021}, "CVE-2019-9709": {"epss_score": 0.00267, "epss_percentile": 0.5001}, "CVE-2019-9710": {"epss_score": 0.00363, "epss_percentile": 0.57846}, "CVE-2019-9711": {"epss_score": 0.00429, "epss_percentile": 0.61994}, "CVE-2019-9712": {"epss_score": 0.00033, "epss_percentile": 0.09283}, "CVE-2019-9713": {"epss_score": 0.00036, "epss_percentile": 0.10325}, "CVE-2019-9714": {"epss_score": 0.00429, "epss_percentile": 0.61994}, "CVE-2019-9717": {"epss_score": 0.00258, "epss_percentile": 0.49017}, "CVE-2019-9718": {"epss_score": 0.01657, "epss_percentile": 0.81602}, "CVE-2019-9719": {"epss_score": 0.00516, "epss_percentile": 0.66055}, "CVE-2019-9720": {"epss_score": 0.00295, "epss_percentile": 0.52476}, "CVE-2019-9721": {"epss_score": 0.00521, "epss_percentile": 0.66224}, "CVE-2019-9723": {"epss_score": 0.00435, "epss_percentile": 0.62355}, "CVE-2019-9724": {"epss_score": 0.00333, "epss_percentile": 0.55681}, "CVE-2019-9725": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-9726": {"epss_score": 0.58772, "epss_percentile": 0.98136}, "CVE-2019-9727": {"epss_score": 0.00372, "epss_percentile": 0.58435}, "CVE-2019-9729": {"epss_score": 0.02419, "epss_percentile": 0.847}, "CVE-2019-9730": {"epss_score": 0.07212, "epss_percentile": 0.91328}, "CVE-2019-9732": {"epss_score": 0.00239, "epss_percentile": 0.46918}, "CVE-2019-9733": {"epss_score": 0.91735, "epss_percentile": 0.99665}, "CVE-2019-9734": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2019-9735": {"epss_score": 0.01965, "epss_percentile": 0.83079}, "CVE-2019-9736": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-9737": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-9738": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-9740": {"epss_score": 0.0991, "epss_percentile": 0.92767}, "CVE-2019-9741": {"epss_score": 0.03468, "epss_percentile": 0.87194}, "CVE-2019-9742": {"epss_score": 0.00198, "epss_percentile": 0.42005}, "CVE-2019-9743": {"epss_score": 0.03326, "epss_percentile": 0.86924}, "CVE-2019-9744": {"epss_score": 0.00438, "epss_percentile": 0.62542}, "CVE-2019-9745": {"epss_score": 0.00091, "epss_percentile": 0.26218}, "CVE-2019-9746": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2019-9747": {"epss_score": 0.00432, "epss_percentile": 0.62112}, "CVE-2019-9748": {"epss_score": 0.00509, "epss_percentile": 0.65738}, "CVE-2019-9749": {"epss_score": 0.01009, "epss_percentile": 0.76582}, "CVE-2019-9750": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2019-9751": {"epss_score": 0.00403, "epss_percentile": 0.60348}, "CVE-2019-9752": {"epss_score": 0.00612, "epss_percentile": 0.69232}, "CVE-2019-9753": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2019-9754": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2019-9755": {"epss_score": 0.00081, "epss_percentile": 0.24343}, "CVE-2019-9756": {"epss_score": 0.00471, "epss_percentile": 0.63996}, "CVE-2019-9757": {"epss_score": 0.86103, "epss_percentile": 0.99366}, "CVE-2019-9758": {"epss_score": 0.00183, "epss_percentile": 0.40283}, "CVE-2019-9759": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2019-9760": {"epss_score": 0.73808, "epss_percentile": 0.98773}, "CVE-2019-9761": {"epss_score": 0.00621, "epss_percentile": 0.69493}, "CVE-2019-9762": {"epss_score": 0.59667, "epss_percentile": 0.98174}, "CVE-2019-9763": {"epss_score": 0.00414, "epss_percentile": 0.61042}, "CVE-2019-9764": {"epss_score": 0.00183, "epss_percentile": 0.40296}, "CVE-2019-9765": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-9766": {"epss_score": 0.20148, "epss_percentile": 0.95294}, "CVE-2019-9767": {"epss_score": 0.03104, "epss_percentile": 0.86414}, "CVE-2019-9768": {"epss_score": 0.37197, "epss_percentile": 0.97027}, "CVE-2019-9769": {"epss_score": 0.00269, "epss_percentile": 0.5019}, "CVE-2019-9770": {"epss_score": 0.0284, "epss_percentile": 0.85798}, "CVE-2019-9771": {"epss_score": 0.02476, "epss_percentile": 0.84862}, "CVE-2019-9772": {"epss_score": 0.02396, "epss_percentile": 0.84618}, "CVE-2019-9773": {"epss_score": 0.02749, "epss_percentile": 0.85577}, "CVE-2019-9774": {"epss_score": 0.03071, "epss_percentile": 0.86347}, "CVE-2019-9775": {"epss_score": 0.03071, "epss_percentile": 0.86347}, "CVE-2019-9776": {"epss_score": 0.02396, "epss_percentile": 0.84618}, "CVE-2019-9777": {"epss_score": 0.02388, "epss_percentile": 0.8459}, "CVE-2019-9778": {"epss_score": 0.02388, "epss_percentile": 0.8459}, "CVE-2019-9779": {"epss_score": 0.02396, "epss_percentile": 0.84618}, "CVE-2019-9785": {"epss_score": 0.00536, "epss_percentile": 0.66845}, "CVE-2019-9787": {"epss_score": 0.85079, "epss_percentile": 0.99316}, "CVE-2019-9788": {"epss_score": 0.02189, "epss_percentile": 0.83929}, "CVE-2019-9789": {"epss_score": 0.00442, "epss_percentile": 0.62752}, "CVE-2019-9790": {"epss_score": 0.00756, "epss_percentile": 0.72742}, "CVE-2019-9791": {"epss_score": 0.39295, "epss_percentile": 0.97152}, "CVE-2019-9792": {"epss_score": 0.19723, "epss_percentile": 0.95232}, "CVE-2019-9793": {"epss_score": 0.0041, "epss_percentile": 0.60834}, "CVE-2019-9794": {"epss_score": 0.00444, "epss_percentile": 0.62807}, "CVE-2019-9795": {"epss_score": 0.00756, "epss_percentile": 0.72742}, "CVE-2019-9796": {"epss_score": 0.00756, "epss_percentile": 0.72742}, "CVE-2019-9797": {"epss_score": 0.00498, "epss_percentile": 0.65243}, "CVE-2019-9798": {"epss_score": 0.00194, "epss_percentile": 0.41545}, "CVE-2019-9799": {"epss_score": 0.00235, "epss_percentile": 0.46226}, "CVE-2019-9800": {"epss_score": 0.00554, "epss_percentile": 0.67448}, "CVE-2019-9801": {"epss_score": 0.0039, "epss_percentile": 0.59553}, "CVE-2019-9802": {"epss_score": 0.00212, "epss_percentile": 0.43741}, "CVE-2019-9803": {"epss_score": 0.0013, "epss_percentile": 0.33247}, "CVE-2019-9804": {"epss_score": 0.01151, "epss_percentile": 0.78042}, "CVE-2019-9805": {"epss_score": 0.00419, "epss_percentile": 0.614}, "CVE-2019-9806": {"epss_score": 0.00341, "epss_percentile": 0.56341}, "CVE-2019-9807": {"epss_score": 0.00201, "epss_percentile": 0.42304}, "CVE-2019-9808": {"epss_score": 0.00092, "epss_percentile": 0.26461}, "CVE-2019-9809": {"epss_score": 0.00507, "epss_percentile": 0.65663}, "CVE-2019-9810": {"epss_score": 0.69406, "epss_percentile": 0.98586}, "CVE-2019-9811": {"epss_score": 0.00733, "epss_percentile": 0.72209}, "CVE-2019-9812": {"epss_score": 0.0052, "epss_percentile": 0.66196}, "CVE-2019-9813": {"epss_score": 0.51921, "epss_percentile": 0.97802}, "CVE-2019-9814": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2019-9815": {"epss_score": 0.0102, "epss_percentile": 0.76735}, "CVE-2019-9816": {"epss_score": 0.38245, "epss_percentile": 0.97092}, "CVE-2019-9817": {"epss_score": 0.00191, "epss_percentile": 0.41214}, "CVE-2019-9818": {"epss_score": 0.00343, "epss_percentile": 0.56462}, "CVE-2019-9819": {"epss_score": 0.00554, "epss_percentile": 0.67448}, "CVE-2019-9820": {"epss_score": 0.00554, "epss_percentile": 0.67448}, "CVE-2019-9821": {"epss_score": 0.00424, "epss_percentile": 0.61667}, "CVE-2019-9823": {"epss_score": 1e-05, "epss_percentile": 0.00016}, "CVE-2019-9824": {"epss_score": 0.00106, "epss_percentile": 0.29477}, "CVE-2019-9825": {"epss_score": 0.00748, "epss_percentile": 0.72582}, "CVE-2019-9826": {"epss_score": 0.0068, "epss_percentile": 0.71037}, "CVE-2019-9827": {"epss_score": 0.00825, "epss_percentile": 0.73952}, "CVE-2019-9829": {"epss_score": 0.00719, "epss_percentile": 0.71954}, "CVE-2019-9831": {"epss_score": 0.18369, "epss_percentile": 0.95006}, "CVE-2019-9832": {"epss_score": 0.17967, "epss_percentile": 0.94935}, "CVE-2019-9833": {"epss_score": 0.19596, "epss_percentile": 0.95213}, "CVE-2019-9834": {"epss_score": 0.08129, "epss_percentile": 0.91893}, "CVE-2019-9835": {"epss_score": 0.00062, "epss_percentile": 0.19633}, "CVE-2019-9836": {"epss_score": 0.00269, "epss_percentile": 0.50116}, "CVE-2019-9837": {"epss_score": 0.00271, "epss_percentile": 0.50285}, "CVE-2019-9838": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2019-9839": {"epss_score": 0.00233, "epss_percentile": 0.46065}, "CVE-2019-9841": {"epss_score": 0.00333, "epss_percentile": 0.55673}, "CVE-2019-9842": {"epss_score": 0.00808, "epss_percentile": 0.73696}, "CVE-2019-9843": {"epss_score": 0.00343, "epss_percentile": 0.56456}, "CVE-2019-9844": {"epss_score": 0.00374, "epss_percentile": 0.58572}, "CVE-2019-9845": {"epss_score": 0.00864, "epss_percentile": 0.74599}, "CVE-2019-9846": {"epss_score": 0.00225, "epss_percentile": 0.45079}, "CVE-2019-9847": {"epss_score": 0.00237, "epss_percentile": 0.46704}, "CVE-2019-9848": {"epss_score": 0.86558, "epss_percentile": 0.99388}, "CVE-2019-9849": {"epss_score": 0.03556, "epss_percentile": 0.87347}, "CVE-2019-9850": {"epss_score": 0.02907, "epss_percentile": 0.85965}, "CVE-2019-9851": {"epss_score": 0.85784, "epss_percentile": 0.99348}, "CVE-2019-9852": {"epss_score": 0.00107, "epss_percentile": 0.29696}, "CVE-2019-9853": {"epss_score": 0.00292, "epss_percentile": 0.52261}, "CVE-2019-9854": {"epss_score": 0.0076, "epss_percentile": 0.72803}, "CVE-2019-9855": {"epss_score": 0.00669, "epss_percentile": 0.70766}, "CVE-2019-9857": {"epss_score": 0.00071, "epss_percentile": 0.2214}, "CVE-2019-9858": {"epss_score": 0.80409, "epss_percentile": 0.99087}, "CVE-2019-9859": {"epss_score": 0.00803, "epss_percentile": 0.73606}, "CVE-2019-9860": {"epss_score": 0.00156, "epss_percentile": 0.36983}, "CVE-2019-9861": {"epss_score": 0.00831, "epss_percentile": 0.74054}, "CVE-2019-9862": {"epss_score": 0.00045, "epss_percentile": 0.13931}, "CVE-2019-9863": {"epss_score": 0.00715, "epss_percentile": 0.71849}, "CVE-2019-9864": {"epss_score": 0.00193, "epss_percentile": 0.4141}, "CVE-2019-9865": {"epss_score": 0.01771, "epss_percentile": 0.82197}, "CVE-2019-9866": {"epss_score": 0.00139, "epss_percentile": 0.34617}, "CVE-2019-9867": {"epss_score": 0.00253, "epss_percentile": 0.48415}, "CVE-2019-9868": {"epss_score": 0.00302, "epss_percentile": 0.53097}, "CVE-2019-9870": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2019-9871": {"epss_score": 0.06893, "epss_percentile": 0.91097}, "CVE-2019-9872": {"epss_score": 1e-05, "epss_percentile": 0.00016}, "CVE-2019-9873": {"epss_score": 1e-05, "epss_percentile": 0.00016}, "CVE-2019-9874": {"epss_score": 0.75396, "epss_percentile": 0.98842}, "CVE-2019-9875": {"epss_score": 0.24766, "epss_percentile": 0.95953}, "CVE-2019-9877": {"epss_score": 0.0022, "epss_percentile": 0.4455}, "CVE-2019-9878": {"epss_score": 0.00229, "epss_percentile": 0.45662}, "CVE-2019-9879": {"epss_score": 0.77634, "epss_percentile": 0.98944}, "CVE-2019-9880": {"epss_score": 0.6462, "epss_percentile": 0.98386}, "CVE-2019-9881": {"epss_score": 0.1924, "epss_percentile": 0.95154}, "CVE-2019-9882": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-9883": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2019-9884": {"epss_score": 0.00393, "epss_percentile": 0.59746}, "CVE-2019-9885": {"epss_score": 0.00625, "epss_percentile": 0.69584}, "CVE-2019-9886": {"epss_score": 0.0047, "epss_percentile": 0.63966}, "CVE-2019-9889": {"epss_score": 0.00422, "epss_percentile": 0.61561}, "CVE-2019-9890": {"epss_score": 0.00056, "epss_percentile": 0.17952}, "CVE-2019-9891": {"epss_score": 0.00738, "epss_percentile": 0.72335}, "CVE-2019-9892": {"epss_score": 0.00458, "epss_percentile": 0.6344}, "CVE-2019-9893": {"epss_score": 0.00794, "epss_percentile": 0.73453}, "CVE-2019-9894": {"epss_score": 0.00921, "epss_percentile": 0.75485}, "CVE-2019-9895": {"epss_score": 0.01037, "epss_percentile": 0.76925}, "CVE-2019-9896": {"epss_score": 0.0224, "epss_percentile": 0.84114}, "CVE-2019-9897": {"epss_score": 0.01983, "epss_percentile": 0.83143}, "CVE-2019-9898": {"epss_score": 0.04359, "epss_percentile": 0.88594}, "CVE-2019-9900": {"epss_score": 0.00036, "epss_percentile": 0.10381}, "CVE-2019-9901": {"epss_score": 0.00095, "epss_percentile": 0.27216}, "CVE-2019-9903": {"epss_score": 0.00761, "epss_percentile": 0.72827}, "CVE-2019-9904": {"epss_score": 0.00181, "epss_percentile": 0.40114}, "CVE-2019-9908": {"epss_score": 0.00261, "epss_percentile": 0.49301}, "CVE-2019-9909": {"epss_score": 0.00239, "epss_percentile": 0.4689}, "CVE-2019-9910": {"epss_score": 0.00238, "epss_percentile": 0.46771}, "CVE-2019-9911": {"epss_score": 0.00238, "epss_percentile": 0.46771}, "CVE-2019-9912": {"epss_score": 0.00387, "epss_percentile": 0.59307}, "CVE-2019-9913": {"epss_score": 0.00238, "epss_percentile": 0.46771}, "CVE-2019-9914": {"epss_score": 0.00238, "epss_percentile": 0.46771}, "CVE-2019-9915": {"epss_score": 0.08964, "epss_percentile": 0.9234}, "CVE-2019-9917": {"epss_score": 0.01604, "epss_percentile": 0.81281}, "CVE-2019-9918": {"epss_score": 0.00233, "epss_percentile": 0.46035}, "CVE-2019-9919": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2019-9920": {"epss_score": 0.0032, "epss_percentile": 0.546}, "CVE-2019-9921": {"epss_score": 0.00207, "epss_percentile": 0.43112}, "CVE-2019-9922": {"epss_score": 0.87141, "epss_percentile": 0.99417}, "CVE-2019-9923": {"epss_score": 0.004, "epss_percentile": 0.60152}, "CVE-2019-9924": {"epss_score": 0.00326, "epss_percentile": 0.55049}, "CVE-2019-9925": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2019-9926": {"epss_score": 0.01874, "epss_percentile": 0.82654}, "CVE-2019-9927": {"epss_score": 0.08743, "epss_percentile": 0.92236}, "CVE-2019-9928": {"epss_score": 0.14533, "epss_percentile": 0.94233}, "CVE-2019-9929": {"epss_score": 0.00665, "epss_percentile": 0.70666}, "CVE-2019-9930": {"epss_score": 0.00442, "epss_percentile": 0.62751}, "CVE-2019-9931": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2019-9932": {"epss_score": 0.00477, "epss_percentile": 0.64345}, "CVE-2019-9933": {"epss_score": 0.00477, "epss_percentile": 0.64345}, "CVE-2019-9934": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2019-9935": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2019-9936": {"epss_score": 0.0471, "epss_percentile": 0.89037}, "CVE-2019-9937": {"epss_score": 0.031, "epss_percentile": 0.86408}, "CVE-2019-9938": {"epss_score": 0.00156, "epss_percentile": 0.36934}, "CVE-2019-9939": {"epss_score": 0.00325, "epss_percentile": 0.54997}, "CVE-2019-9942": {"epss_score": 0.00321, "epss_percentile": 0.5468}, "CVE-2019-9943": {"epss_score": 0.00148, "epss_percentile": 0.3582}, "CVE-2019-9944": {"epss_score": 0.00244, "epss_percentile": 0.47529}, "CVE-2019-9945": {"epss_score": 0.02383, "epss_percentile": 0.8457}, "CVE-2019-9946": {"epss_score": 0.00418, "epss_percentile": 0.61264}, "CVE-2019-9947": {"epss_score": 0.01161, "epss_percentile": 0.78145}, "CVE-2019-9948": {"epss_score": 0.00918, "epss_percentile": 0.75449}, "CVE-2019-9949": {"epss_score": 0.02505, "epss_percentile": 0.84935}, "CVE-2019-9950": {"epss_score": 0.00795, "epss_percentile": 0.73464}, "CVE-2019-9951": {"epss_score": 0.01333, "epss_percentile": 0.79528}, "CVE-2019-9955": {"epss_score": 0.11615, "epss_percentile": 0.93421}, "CVE-2019-9956": {"epss_score": 0.00789, "epss_percentile": 0.73362}, "CVE-2019-9957": {"epss_score": 0.00157, "epss_percentile": 0.37034}, "CVE-2019-9958": {"epss_score": 0.00206, "epss_percentile": 0.42937}, "CVE-2019-9959": {"epss_score": 0.01488, "epss_percentile": 0.80614}, "CVE-2019-9960": {"epss_score": 0.70082, "epss_percentile": 0.98614}, "CVE-2019-9961": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2019-9962": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2019-9963": {"epss_score": 0.0028, "epss_percentile": 0.51072}, "CVE-2019-9964": {"epss_score": 0.0028, "epss_percentile": 0.51072}, "CVE-2019-9965": {"epss_score": 0.00275, "epss_percentile": 0.50699}, "CVE-2019-9966": {"epss_score": 0.0028, "epss_percentile": 0.51072}, "CVE-2019-9967": {"epss_score": 0.0028, "epss_percentile": 0.51072}, "CVE-2019-9968": {"epss_score": 0.0028, "epss_percentile": 0.51072}, "CVE-2019-9969": {"epss_score": 0.0028, "epss_percentile": 0.51072}, "CVE-2019-9970": {"epss_score": 0.00423, "epss_percentile": 0.61601}, "CVE-2019-9971": {"epss_score": 0.00324, "epss_percentile": 0.54959}, "CVE-2019-9972": {"epss_score": 0.00553, "epss_percentile": 0.67426}, "CVE-2019-9974": {"epss_score": 0.06334, "epss_percentile": 0.90677}, "CVE-2019-9975": {"epss_score": 0.01299, "epss_percentile": 0.79279}, "CVE-2019-9976": {"epss_score": 0.00298, "epss_percentile": 0.52794}, "CVE-2019-9977": {"epss_score": 0.00627, "epss_percentile": 0.69643}, "CVE-2019-9978": {"epss_score": 0.87417, "epss_percentile": 0.99429}, "CVE-2020-0001": {"epss_score": 0.00104, "epss_percentile": 0.29181}, "CVE-2020-0002": {"epss_score": 0.00288, "epss_percentile": 0.51909}, "CVE-2020-0003": {"epss_score": 0.0001, "epss_percentile": 0.00864}, "CVE-2020-0004": {"epss_score": 0.00037, "epss_percentile": 0.10994}, "CVE-2020-0005": {"epss_score": 0.00037, "epss_percentile": 0.11008}, "CVE-2020-0006": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0007": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0008": {"epss_score": 0.00035, "epss_percentile": 0.09921}, "CVE-2020-0009": {"epss_score": 0.00115, "epss_percentile": 0.30991}, "CVE-2020-0010": {"epss_score": 0.00033, "epss_percentile": 0.09321}, "CVE-2020-0011": {"epss_score": 0.00033, "epss_percentile": 0.09321}, "CVE-2020-0012": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2020-0014": {"epss_score": 0.01172, "epss_percentile": 0.78231}, "CVE-2020-0015": {"epss_score": 0.00013, "epss_percentile": 0.01564}, "CVE-2020-0016": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2020-0017": {"epss_score": 0.00034, "epss_percentile": 0.09799}, "CVE-2020-0018": {"epss_score": 0.00037, "epss_percentile": 0.10892}, "CVE-2020-0019": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0020": {"epss_score": 0.00034, "epss_percentile": 0.09653}, "CVE-2020-0021": {"epss_score": 0.01902, "epss_percentile": 0.82781}, "CVE-2020-0022": {"epss_score": 0.06206, "epss_percentile": 0.90566}, "CVE-2020-0023": {"epss_score": 0.00114, "epss_percentile": 0.30873}, "CVE-2020-0024": {"epss_score": 0.00013, "epss_percentile": 0.0162}, "CVE-2020-0025": {"epss_score": 0.00013, "epss_percentile": 0.01556}, "CVE-2020-0026": {"epss_score": 0.00037, "epss_percentile": 0.10661}, "CVE-2020-0027": {"epss_score": 0.00034, "epss_percentile": 0.09739}, "CVE-2020-0028": {"epss_score": 0.00868, "epss_percentile": 0.74682}, "CVE-2020-0029": {"epss_score": 0.00032, "epss_percentile": 0.08748}, "CVE-2020-0030": {"epss_score": 0.00034, "epss_percentile": 0.09476}, "CVE-2020-0031": {"epss_score": 0.00037, "epss_percentile": 0.10626}, "CVE-2020-0032": {"epss_score": 0.01765, "epss_percentile": 0.82165}, "CVE-2020-0033": {"epss_score": 0.00037, "epss_percentile": 0.10738}, "CVE-2020-0034": {"epss_score": 0.0451, "epss_percentile": 0.8878}, "CVE-2020-0035": {"epss_score": 0.00034, "epss_percentile": 0.09657}, "CVE-2020-0036": {"epss_score": 8e-05, "epss_percentile": 0.00553}, "CVE-2020-0037": {"epss_score": 0.01282, "epss_percentile": 0.79154}, "CVE-2020-0038": {"epss_score": 0.01282, "epss_percentile": 0.79154}, "CVE-2020-0039": {"epss_score": 0.01282, "epss_percentile": 0.79154}, "CVE-2020-0041": {"epss_score": 0.21241, "epss_percentile": 0.95484}, "CVE-2020-0042": {"epss_score": 0.00043, "epss_percentile": 0.13087}, "CVE-2020-0043": {"epss_score": 0.00043, "epss_percentile": 0.13087}, "CVE-2020-0044": {"epss_score": 0.00043, "epss_percentile": 0.13087}, "CVE-2020-0045": {"epss_score": 0.00026, "epss_percentile": 0.06542}, "CVE-2020-0046": {"epss_score": 0.00035, "epss_percentile": 0.10158}, "CVE-2020-0047": {"epss_score": 0.00031, "epss_percentile": 0.08339}, "CVE-2020-0048": {"epss_score": 0.00034, "epss_percentile": 0.09653}, "CVE-2020-0049": {"epss_score": 0.00872, "epss_percentile": 0.74728}, "CVE-2020-0050": {"epss_score": 0.00037, "epss_percentile": 0.11008}, "CVE-2020-0051": {"epss_score": 0.00035, "epss_percentile": 0.09995}, "CVE-2020-0052": {"epss_score": 0.0001, "epss_percentile": 0.008}, "CVE-2020-0053": {"epss_score": 0.00033, "epss_percentile": 0.09321}, "CVE-2020-0054": {"epss_score": 0.00032, "epss_percentile": 0.08848}, "CVE-2020-0055": {"epss_score": 0.0006, "epss_percentile": 0.19179}, "CVE-2020-0056": {"epss_score": 0.00044, "epss_percentile": 0.13661}, "CVE-2020-0057": {"epss_score": 0.00044, "epss_percentile": 0.13661}, "CVE-2020-0058": {"epss_score": 0.00049, "epss_percentile": 0.15314}, "CVE-2020-0059": {"epss_score": 0.00044, "epss_percentile": 0.13661}, "CVE-2020-0060": {"epss_score": 0.00012, "epss_percentile": 0.01407}, "CVE-2020-0061": {"epss_score": 0.00013, "epss_percentile": 0.01548}, "CVE-2020-0062": {"epss_score": 0.00548, "epss_percentile": 0.67272}, "CVE-2020-0063": {"epss_score": 0.00034, "epss_percentile": 0.09739}, "CVE-2020-0064": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2020-0065": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2020-0066": {"epss_score": 0.00027, "epss_percentile": 0.06881}, "CVE-2020-0067": {"epss_score": 0.00056, "epss_percentile": 0.17869}, "CVE-2020-0068": {"epss_score": 0.00035, "epss_percentile": 0.09907}, "CVE-2020-0069": {"epss_score": 0.00708, "epss_percentile": 0.7167}, "CVE-2020-0070": {"epss_score": 0.02282, "epss_percentile": 0.84254}, "CVE-2020-0071": {"epss_score": 0.02282, "epss_percentile": 0.84254}, "CVE-2020-0072": {"epss_score": 0.02282, "epss_percentile": 0.84254}, "CVE-2020-0073": {"epss_score": 0.02282, "epss_percentile": 0.84254}, "CVE-2020-0074": {"epss_score": 5e-05, "epss_percentile": 0.00212}, "CVE-2020-0075": {"epss_score": 0.00044, "epss_percentile": 0.13377}, "CVE-2020-0076": {"epss_score": 0.00036, "epss_percentile": 0.1045}, "CVE-2020-0077": {"epss_score": 0.00044, "epss_percentile": 0.13377}, "CVE-2020-0078": {"epss_score": 0.00034, "epss_percentile": 0.09739}, "CVE-2020-0079": {"epss_score": 0.00034, "epss_percentile": 0.09739}, "CVE-2020-0080": {"epss_score": 0.00085, "epss_percentile": 0.25151}, "CVE-2020-0081": {"epss_score": 0.00046, "epss_percentile": 0.14474}, "CVE-2020-0082": {"epss_score": 0.00212, "epss_percentile": 0.43794}, "CVE-2020-0083": {"epss_score": 0.02439, "epss_percentile": 0.84749}, "CVE-2020-0084": {"epss_score": 0.00034, "epss_percentile": 0.09741}, "CVE-2020-0085": {"epss_score": 0.00012, "epss_percentile": 0.01269}, "CVE-2020-0086": {"epss_score": 0.00187, "epss_percentile": 0.40754}, "CVE-2020-0087": {"epss_score": 0.00037, "epss_percentile": 0.10686}, "CVE-2020-0088": {"epss_score": 0.00294, "epss_percentile": 0.52364}, "CVE-2020-0089": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2020-0090": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2020-0091": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2020-0092": {"epss_score": 0.00013, "epss_percentile": 0.01548}, "CVE-2020-0093": {"epss_score": 0.00127, "epss_percentile": 0.32925}, "CVE-2020-0094": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0096": {"epss_score": 0.02502, "epss_percentile": 0.84926}, "CVE-2020-0097": {"epss_score": 0.00021, "epss_percentile": 0.04736}, "CVE-2020-0098": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0099": {"epss_score": 0.00037, "epss_percentile": 0.10781}, "CVE-2020-0100": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0101": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0102": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0103": {"epss_score": 0.0301, "epss_percentile": 0.86196}, "CVE-2020-0104": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0105": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2020-0106": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0107": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2020-0108": {"epss_score": 0.01836, "epss_percentile": 0.82468}, "CVE-2020-0109": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2020-0110": {"epss_score": 0.0002, "epss_percentile": 0.0455}, "CVE-2020-0113": {"epss_score": 0.00107, "epss_percentile": 0.29694}, "CVE-2020-0114": {"epss_score": 0.00034, "epss_percentile": 0.09483}, "CVE-2020-0115": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2020-0116": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2020-0117": {"epss_score": 0.00873, "epss_percentile": 0.74748}, "CVE-2020-0118": {"epss_score": 0.00013, "epss_percentile": 0.01651}, "CVE-2020-0119": {"epss_score": 0.00144, "epss_percentile": 0.35282}, "CVE-2020-0120": {"epss_score": 0.00016, "epss_percentile": 0.02804}, "CVE-2020-0121": {"epss_score": 0.00032, "epss_percentile": 0.08819}, "CVE-2020-0122": {"epss_score": 0.00011, "epss_percentile": 0.01007}, "CVE-2020-0123": {"epss_score": 0.00144, "epss_percentile": 0.353}, "CVE-2020-0124": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2020-0125": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0126": {"epss_score": 0.00013, "epss_percentile": 0.01446}, "CVE-2020-0127": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0128": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2020-0129": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0130": {"epss_score": 0.00125, "epss_percentile": 0.32528}, "CVE-2020-0131": {"epss_score": 0.00481, "epss_percentile": 0.64492}, "CVE-2020-0132": {"epss_score": 0.00034, "epss_percentile": 0.09601}, "CVE-2020-0133": {"epss_score": 6e-05, "epss_percentile": 0.00305}, "CVE-2020-0134": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0135": {"epss_score": 0.00015, "epss_percentile": 0.02227}, "CVE-2020-0136": {"epss_score": 0.00015, "epss_percentile": 0.02368}, "CVE-2020-0137": {"epss_score": 0.00012, "epss_percentile": 0.01276}, "CVE-2020-0138": {"epss_score": 0.0552, "epss_percentile": 0.89957}, "CVE-2020-0139": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2020-0140": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2020-0141": {"epss_score": 0.00175, "epss_percentile": 0.39324}, "CVE-2020-0142": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2020-0143": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0144": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0145": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0146": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0147": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2020-0148": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2020-0149": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0150": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0151": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0152": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0153": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2020-0154": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0155": {"epss_score": 0.00015, "epss_percentile": 0.02368}, "CVE-2020-0156": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0157": {"epss_score": 0.00256, "epss_percentile": 0.48819}, "CVE-2020-0158": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0159": {"epss_score": 0.00062, "epss_percentile": 0.19671}, "CVE-2020-0160": {"epss_score": 0.01689, "epss_percentile": 0.81768}, "CVE-2020-0161": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2020-0162": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2020-0163": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2020-0164": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0165": {"epss_score": 0.00014, "epss_percentile": 0.01848}, "CVE-2020-0166": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0167": {"epss_score": 0.00062, "epss_percentile": 0.19632}, "CVE-2020-0168": {"epss_score": 0.00481, "epss_percentile": 0.64492}, "CVE-2020-0169": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2020-0170": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2020-0171": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2020-0172": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2020-0173": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2020-0174": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2020-0175": {"epss_score": 0.00313, "epss_percentile": 0.54033}, "CVE-2020-0176": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2020-0177": {"epss_score": 0.00011, "epss_percentile": 0.01025}, "CVE-2020-0178": {"epss_score": 0.00019, "epss_percentile": 0.04255}, "CVE-2020-0179": {"epss_score": 0.0004, "epss_percentile": 0.1204}, "CVE-2020-0180": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0181": {"epss_score": 0.09453, "epss_percentile": 0.92554}, "CVE-2020-0182": {"epss_score": 0.00478, "epss_percentile": 0.6437}, "CVE-2020-0183": {"epss_score": 0.00016, "epss_percentile": 0.02825}, "CVE-2020-0184": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2020-0185": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0186": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2020-0187": {"epss_score": 0.00033, "epss_percentile": 0.09388}, "CVE-2020-0188": {"epss_score": 7e-05, "epss_percentile": 0.00426}, "CVE-2020-0189": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2020-0190": {"epss_score": 0.00892, "epss_percentile": 0.75069}, "CVE-2020-0191": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0192": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0193": {"epss_score": 0.0041, "epss_percentile": 0.60825}, "CVE-2020-0194": {"epss_score": 0.00481, "epss_percentile": 0.64492}, "CVE-2020-0195": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0196": {"epss_score": 0.0016, "epss_percentile": 0.37461}, "CVE-2020-0197": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0198": {"epss_score": 0.11111, "epss_percentile": 0.93225}, "CVE-2020-0199": {"epss_score": 0.00016, "epss_percentile": 0.03017}, "CVE-2020-0200": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0201": {"epss_score": 0.02455, "epss_percentile": 0.84798}, "CVE-2020-0202": {"epss_score": 0.00049, "epss_percentile": 0.15602}, "CVE-2020-0203": {"epss_score": 0.00015, "epss_percentile": 0.02368}, "CVE-2020-0204": {"epss_score": 0.00043, "epss_percentile": 0.13337}, "CVE-2020-0205": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0206": {"epss_score": 0.00014, "epss_percentile": 0.02044}, "CVE-2020-0207": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0208": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2020-0209": {"epss_score": 6e-05, "epss_percentile": 0.00264}, "CVE-2020-0210": {"epss_score": 0.00013, "epss_percentile": 0.01556}, "CVE-2020-0211": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0212": {"epss_score": 0.00286, "epss_percentile": 0.5174}, "CVE-2020-0213": {"epss_score": 0.0041, "epss_percentile": 0.60825}, "CVE-2020-0214": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2020-0215": {"epss_score": 0.00013, "epss_percentile": 0.01617}, "CVE-2020-0216": {"epss_score": 0.00016, "epss_percentile": 0.02757}, "CVE-2020-0217": {"epss_score": 0.00759, "epss_percentile": 0.72783}, "CVE-2020-0218": {"epss_score": 0.00012, "epss_percentile": 0.01203}, "CVE-2020-0219": {"epss_score": 0.00017, "epss_percentile": 0.03147}, "CVE-2020-0220": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2020-0221": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-0223": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-0224": {"epss_score": 0.00644, "epss_percentile": 0.70084}, "CVE-2020-0225": {"epss_score": 0.056, "epss_percentile": 0.90037}, "CVE-2020-0226": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2020-0227": {"epss_score": 0.0001, "epss_percentile": 0.00853}, "CVE-2020-0228": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2020-0229": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2020-0230": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-0231": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-0232": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-0233": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2020-0234": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0235": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-0236": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2020-0238": {"epss_score": 0.00019, "epss_percentile": 0.04167}, "CVE-2020-0239": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2020-0240": {"epss_score": 0.01575, "epss_percentile": 0.81109}, "CVE-2020-0241": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2020-0242": {"epss_score": 5e-05, "epss_percentile": 0.00197}, "CVE-2020-0243": {"epss_score": 0.00012, "epss_percentile": 0.01119}, "CVE-2020-0244": {"epss_score": 0.00062, "epss_percentile": 0.19632}, "CVE-2020-0245": {"epss_score": 0.041, "epss_percentile": 0.88257}, "CVE-2020-0246": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0247": {"epss_score": 0.00015, "epss_percentile": 0.0233}, "CVE-2020-0248": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0249": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0250": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0251": {"epss_score": 0.00118, "epss_percentile": 0.31384}, "CVE-2020-0252": {"epss_score": 0.00199, "epss_percentile": 0.42173}, "CVE-2020-0253": {"epss_score": 0.00199, "epss_percentile": 0.42173}, "CVE-2020-0254": {"epss_score": 0.00118, "epss_percentile": 0.31384}, "CVE-2020-0256": {"epss_score": 0.00046, "epss_percentile": 0.14329}, "CVE-2020-0257": {"epss_score": 0.00011, "epss_percentile": 0.00994}, "CVE-2020-0258": {"epss_score": 0.00023, "epss_percentile": 0.05342}, "CVE-2020-0259": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2020-0260": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-0261": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2020-0262": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0263": {"epss_score": 0.00014, "epss_percentile": 0.02044}, "CVE-2020-0264": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2020-0265": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0266": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2020-0267": {"epss_score": 0.00034, "epss_percentile": 0.09582}, "CVE-2020-0268": {"epss_score": 0.00013, "epss_percentile": 0.01646}, "CVE-2020-0269": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0270": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0271": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0272": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2020-0273": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0274": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0275": {"epss_score": 0.0001, "epss_percentile": 0.00853}, "CVE-2020-0276": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0277": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2020-0278": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2020-0279": {"epss_score": 0.00313, "epss_percentile": 0.54028}, "CVE-2020-0280": {"epss_score": 0.00018, "epss_percentile": 0.03961}, "CVE-2020-0281": {"epss_score": 0.002, "epss_percentile": 0.42233}, "CVE-2020-0282": {"epss_score": 0.002, "epss_percentile": 0.42233}, "CVE-2020-0283": {"epss_score": 0.00192, "epss_percentile": 0.4133}, "CVE-2020-0284": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0285": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0286": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2020-0287": {"epss_score": 0.00294, "epss_percentile": 0.52364}, "CVE-2020-0288": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0289": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0290": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0291": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0292": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0293": {"epss_score": 0.00023, "epss_percentile": 0.05618}, "CVE-2020-0294": {"epss_score": 0.00013, "epss_percentile": 0.01525}, "CVE-2020-0295": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0296": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0297": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0298": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2020-0299": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2020-0300": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2020-0301": {"epss_score": 0.00294, "epss_percentile": 0.52364}, "CVE-2020-0302": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0303": {"epss_score": 0.00372, "epss_percentile": 0.58446}, "CVE-2020-0304": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0305": {"epss_score": 0.00039, "epss_percentile": 0.11593}, "CVE-2020-0306": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0307": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0308": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0309": {"epss_score": 0.00016, "epss_percentile": 0.02812}, "CVE-2020-0310": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0311": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0312": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0313": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0314": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0315": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0316": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0317": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0318": {"epss_score": 0.00017, "epss_percentile": 0.03186}, "CVE-2020-0319": {"epss_score": 0.00056, "epss_percentile": 0.17816}, "CVE-2020-0320": {"epss_score": 0.00294, "epss_percentile": 0.52364}, "CVE-2020-0321": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2020-0322": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0323": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0324": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0325": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0326": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2020-0327": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0328": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2020-0329": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0330": {"epss_score": 0.00017, "epss_percentile": 0.03274}, "CVE-2020-0331": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2020-0332": {"epss_score": 0.00294, "epss_percentile": 0.52364}, "CVE-2020-0333": {"epss_score": 0.00646, "epss_percentile": 0.70144}, "CVE-2020-0334": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2020-0335": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2020-0336": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2020-0337": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2020-0338": {"epss_score": 0.0001, "epss_percentile": 0.00792}, "CVE-2020-0339": {"epss_score": 0.00123, "epss_percentile": 0.32187}, "CVE-2020-0340": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0341": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2020-0342": {"epss_score": 0.0017, "epss_percentile": 0.38684}, "CVE-2020-0343": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0344": {"epss_score": 0.00026, "epss_percentile": 0.06516}, "CVE-2020-0345": {"epss_score": 0.00016, "epss_percentile": 0.02757}, "CVE-2020-0346": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0347": {"epss_score": 0.00026, "epss_percentile": 0.06597}, "CVE-2020-0348": {"epss_score": 0.00256, "epss_percentile": 0.48819}, "CVE-2020-0349": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0350": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2020-0351": {"epss_score": 0.00346, "epss_percentile": 0.56653}, "CVE-2020-0352": {"epss_score": 0.00026, "epss_percentile": 0.06516}, "CVE-2020-0353": {"epss_score": 0.00294, "epss_percentile": 0.52364}, "CVE-2020-0354": {"epss_score": 0.00646, "epss_percentile": 0.70144}, "CVE-2020-0355": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0356": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2020-0357": {"epss_score": 0.00014, "epss_percentile": 0.01827}, "CVE-2020-0358": {"epss_score": 0.00015, "epss_percentile": 0.02315}, "CVE-2020-0359": {"epss_score": 0.00017, "epss_percentile": 0.03515}, "CVE-2020-0360": {"epss_score": 0.00048, "epss_percentile": 0.15046}, "CVE-2020-0361": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0362": {"epss_score": 0.00294, "epss_percentile": 0.52364}, "CVE-2020-0363": {"epss_score": 0.00294, "epss_percentile": 0.52364}, "CVE-2020-0364": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0365": {"epss_score": 0.00044, "epss_percentile": 0.13395}, "CVE-2020-0366": {"epss_score": 0.00042, "epss_percentile": 0.12798}, "CVE-2020-0367": {"epss_score": 0.00165, "epss_percentile": 0.38051}, "CVE-2020-0368": {"epss_score": 0.00015, "epss_percentile": 0.02311}, "CVE-2020-0369": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0370": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0371": {"epss_score": 0.00123, "epss_percentile": 0.32187}, "CVE-2020-0372": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0373": {"epss_score": 0.00012, "epss_percentile": 0.01164}, "CVE-2020-0374": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2020-0375": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2020-0376": {"epss_score": 0.00123, "epss_percentile": 0.32187}, "CVE-2020-0377": {"epss_score": 0.02028, "epss_percentile": 0.83322}, "CVE-2020-0378": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0379": {"epss_score": 0.00103, "epss_percentile": 0.29004}, "CVE-2020-0380": {"epss_score": 0.05022, "epss_percentile": 0.89403}, "CVE-2020-0381": {"epss_score": 0.01617, "epss_percentile": 0.81367}, "CVE-2020-0382": {"epss_score": 0.00014, "epss_percentile": 0.02108}, "CVE-2020-0383": {"epss_score": 0.00136, "epss_percentile": 0.34144}, "CVE-2020-0384": {"epss_score": 0.00136, "epss_percentile": 0.34144}, "CVE-2020-0385": {"epss_score": 0.00136, "epss_percentile": 0.34144}, "CVE-2020-0386": {"epss_score": 0.00042, "epss_percentile": 0.12733}, "CVE-2020-0387": {"epss_score": 0.00034, "epss_percentile": 0.09549}, "CVE-2020-0388": {"epss_score": 0.0001, "epss_percentile": 0.00853}, "CVE-2020-0389": {"epss_score": 0.00015, "epss_percentile": 0.02363}, "CVE-2020-0390": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2020-0391": {"epss_score": 0.00187, "epss_percentile": 0.4077}, "CVE-2020-0392": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2020-0393": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0394": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2020-0395": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0396": {"epss_score": 0.00014, "epss_percentile": 0.01988}, "CVE-2020-0397": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0398": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0399": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0400": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0401": {"epss_score": 8e-05, "epss_percentile": 0.00575}, "CVE-2020-0403": {"epss_score": 0.00013, "epss_percentile": 0.01488}, "CVE-2020-0404": {"epss_score": 0.00182, "epss_percentile": 0.40264}, "CVE-2020-0405": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2020-0406": {"epss_score": 0.00056, "epss_percentile": 0.17816}, "CVE-2020-0407": {"epss_score": 0.0001, "epss_percentile": 0.00873}, "CVE-2020-0408": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2020-0409": {"epss_score": 0.0002, "epss_percentile": 0.0455}, "CVE-2020-0410": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0411": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0412": {"epss_score": 0.00011, "epss_percentile": 0.01057}, "CVE-2020-0413": {"epss_score": 0.01617, "epss_percentile": 0.81367}, "CVE-2020-0414": {"epss_score": 0.00253, "epss_percentile": 0.4846}, "CVE-2020-0415": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0416": {"epss_score": 0.00132, "epss_percentile": 0.3355}, "CVE-2020-0417": {"epss_score": 5e-05, "epss_percentile": 0.00218}, "CVE-2020-0418": {"epss_score": 0.00015, "epss_percentile": 0.02368}, "CVE-2020-0419": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0420": {"epss_score": 0.0001, "epss_percentile": 0.00835}, "CVE-2020-0421": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2020-0422": {"epss_score": 0.00013, "epss_percentile": 0.01531}, "CVE-2020-0423": {"epss_score": 0.00949, "epss_percentile": 0.75838}, "CVE-2020-0424": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0425": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0426": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0427": {"epss_score": 0.00158, "epss_percentile": 0.37183}, "CVE-2020-0428": {"epss_score": 0.00015, "epss_percentile": 0.02315}, "CVE-2020-0429": {"epss_score": 0.00019, "epss_percentile": 0.04296}, "CVE-2020-0430": {"epss_score": 0.0002, "epss_percentile": 0.0455}, "CVE-2020-0431": {"epss_score": 0.00036, "epss_percentile": 0.10317}, "CVE-2020-0432": {"epss_score": 0.00033, "epss_percentile": 0.09193}, "CVE-2020-0433": {"epss_score": 0.00025, "epss_percentile": 0.06118}, "CVE-2020-0434": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2020-0437": {"epss_score": 0.00013, "epss_percentile": 0.0167}, "CVE-2020-0438": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-0439": {"epss_score": 9e-05, "epss_percentile": 0.00704}, "CVE-2020-0440": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2020-0441": {"epss_score": 0.0129, "epss_percentile": 0.79221}, "CVE-2020-0442": {"epss_score": 0.00805, "epss_percentile": 0.73638}, "CVE-2020-0443": {"epss_score": 0.0023, "epss_percentile": 0.45741}, "CVE-2020-0444": {"epss_score": 0.00016, "epss_percentile": 0.02941}, "CVE-2020-0445": {"epss_score": 0.00164, "epss_percentile": 0.37959}, "CVE-2020-0446": {"epss_score": 0.00164, "epss_percentile": 0.37959}, "CVE-2020-0447": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-0448": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0449": {"epss_score": 0.00288, "epss_percentile": 0.51909}, "CVE-2020-0450": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0451": {"epss_score": 0.02865, "epss_percentile": 0.85859}, "CVE-2020-0452": {"epss_score": 0.14912, "epss_percentile": 0.94321}, "CVE-2020-0453": {"epss_score": 0.00032, "epss_percentile": 0.08819}, "CVE-2020-0454": {"epss_score": 0.00026, "epss_percentile": 0.06486}, "CVE-2020-0455": {"epss_score": 0.00164, "epss_percentile": 0.37959}, "CVE-2020-0456": {"epss_score": 0.00164, "epss_percentile": 0.37959}, "CVE-2020-0457": {"epss_score": 0.00164, "epss_percentile": 0.37959}, "CVE-2020-0458": {"epss_score": 0.00351, "epss_percentile": 0.57038}, "CVE-2020-0459": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2020-0460": {"epss_score": 0.00172, "epss_percentile": 0.38988}, "CVE-2020-0463": {"epss_score": 0.01617, "epss_percentile": 0.81367}, "CVE-2020-0464": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0465": {"epss_score": 0.00023, "epss_percentile": 0.05593}, "CVE-2020-0466": {"epss_score": 0.00029, "epss_percentile": 0.07858}, "CVE-2020-0467": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0468": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2020-0469": {"epss_score": 0.00014, "epss_percentile": 0.02044}, "CVE-2020-0470": {"epss_score": 0.00694, "epss_percentile": 0.71361}, "CVE-2020-0471": {"epss_score": 0.02455, "epss_percentile": 0.84798}, "CVE-2020-0473": {"epss_score": 0.00012, "epss_percentile": 0.01283}, "CVE-2020-0474": {"epss_score": 0.00014, "epss_percentile": 0.01827}, "CVE-2020-0475": {"epss_score": 0.00049, "epss_percentile": 0.15602}, "CVE-2020-0476": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-0477": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0478": {"epss_score": 0.00056, "epss_percentile": 0.17816}, "CVE-2020-0479": {"epss_score": 0.00042, "epss_percentile": 0.12798}, "CVE-2020-0480": {"epss_score": 0.00047, "epss_percentile": 0.1483}, "CVE-2020-0481": {"epss_score": 0.00012, "epss_percentile": 0.01141}, "CVE-2020-0482": {"epss_score": 0.00048, "epss_percentile": 0.1497}, "CVE-2020-0483": {"epss_score": 0.00019, "epss_percentile": 0.04322}, "CVE-2020-0484": {"epss_score": 0.00019, "epss_percentile": 0.04322}, "CVE-2020-0485": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2020-0486": {"epss_score": 0.00012, "epss_percentile": 0.01269}, "CVE-2020-0488": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0489": {"epss_score": 0.00481, "epss_percentile": 0.64492}, "CVE-2020-0490": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2020-0491": {"epss_score": 0.00294, "epss_percentile": 0.52364}, "CVE-2020-0492": {"epss_score": 0.0041, "epss_percentile": 0.60825}, "CVE-2020-0493": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0494": {"epss_score": 0.0041, "epss_percentile": 0.60825}, "CVE-2020-0495": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0496": {"epss_score": 0.00019, "epss_percentile": 0.04358}, "CVE-2020-0497": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-0498": {"epss_score": 0.00229, "epss_percentile": 0.45642}, "CVE-2020-0499": {"epss_score": 0.05474, "epss_percentile": 0.8991}, "CVE-2020-0500": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-0501": {"epss_score": 0.00059, "epss_percentile": 0.18688}, "CVE-2020-0502": {"epss_score": 0.00055, "epss_percentile": 0.17375}, "CVE-2020-0503": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-0504": {"epss_score": 0.00075, "epss_percentile": 0.23004}, "CVE-2020-0505": {"epss_score": 0.00058, "epss_percentile": 0.18525}, "CVE-2020-0506": {"epss_score": 0.00053, "epss_percentile": 0.16679}, "CVE-2020-0507": {"epss_score": 0.00049, "epss_percentile": 0.15309}, "CVE-2020-0508": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-0510": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-0511": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-0512": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-0513": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-0514": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-0515": {"epss_score": 0.00077, "epss_percentile": 0.23521}, "CVE-2020-0516": {"epss_score": 0.00103, "epss_percentile": 0.28982}, "CVE-2020-0517": {"epss_score": 0.00055, "epss_percentile": 0.17375}, "CVE-2020-0518": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-0519": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-0520": {"epss_score": 0.00078, "epss_percentile": 0.23752}, "CVE-2020-0521": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-0522": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-0523": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-0524": {"epss_score": 0.00033, "epss_percentile": 0.09158}, "CVE-2020-0525": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-0526": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2020-0527": {"epss_score": 0.00058, "epss_percentile": 0.18373}, "CVE-2020-0528": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-0529": {"epss_score": 0.00072, "epss_percentile": 0.22297}, "CVE-2020-0530": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-0531": {"epss_score": 0.00449, "epss_percentile": 0.63046}, "CVE-2020-0532": {"epss_score": 0.00252, "epss_percentile": 0.48406}, "CVE-2020-0533": {"epss_score": 0.00042, "epss_percentile": 0.12627}, "CVE-2020-0534": {"epss_score": 0.00916, "epss_percentile": 0.75419}, "CVE-2020-0535": {"epss_score": 0.00859, "epss_percentile": 0.74519}, "CVE-2020-0536": {"epss_score": 0.00725, "epss_percentile": 0.72054}, "CVE-2020-0537": {"epss_score": 0.00425, "epss_percentile": 0.61697}, "CVE-2020-0538": {"epss_score": 0.01402, "epss_percentile": 0.80021}, "CVE-2020-0539": {"epss_score": 0.00053, "epss_percentile": 0.16942}, "CVE-2020-0540": {"epss_score": 0.01991, "epss_percentile": 0.83174}, "CVE-2020-0541": {"epss_score": 0.00077, "epss_percentile": 0.23445}, "CVE-2020-0542": {"epss_score": 0.00068, "epss_percentile": 0.21301}, "CVE-2020-0543": {"epss_score": 0.00481, "epss_percentile": 0.64503}, "CVE-2020-0544": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-0545": {"epss_score": 0.00104, "epss_percentile": 0.29185}, "CVE-2020-0546": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-0547": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2020-0548": {"epss_score": 0.00491, "epss_percentile": 0.64949}, "CVE-2020-0549": {"epss_score": 0.00118, "epss_percentile": 0.31444}, "CVE-2020-0550": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-0551": {"epss_score": 0.01947, "epss_percentile": 0.83005}, "CVE-2020-0553": {"epss_score": 0.00052, "epss_percentile": 0.16539}, "CVE-2020-0554": {"epss_score": 0.01476, "epss_percentile": 0.80536}, "CVE-2020-0555": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-0556": {"epss_score": 0.00161, "epss_percentile": 0.37585}, "CVE-2020-0557": {"epss_score": 0.00074, "epss_percentile": 0.22845}, "CVE-2020-0558": {"epss_score": 0.00472, "epss_percentile": 0.64043}, "CVE-2020-0559": {"epss_score": 0.00026, "epss_percentile": 0.06542}, "CVE-2020-0560": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2020-0561": {"epss_score": 0.00169, "epss_percentile": 0.38608}, "CVE-2020-0562": {"epss_score": 0.00121, "epss_percentile": 0.31895}, "CVE-2020-0563": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2020-0564": {"epss_score": 0.00121, "epss_percentile": 0.31895}, "CVE-2020-0565": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2020-0566": {"epss_score": 0.00225, "epss_percentile": 0.45147}, "CVE-2020-0567": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-0568": {"epss_score": 0.00113, "epss_percentile": 0.30721}, "CVE-2020-0569": {"epss_score": 0.0033, "epss_percentile": 0.55488}, "CVE-2020-0570": {"epss_score": 0.00329, "epss_percentile": 0.55389}, "CVE-2020-0571": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-0572": {"epss_score": 0.00054, "epss_percentile": 0.17219}, "CVE-2020-0573": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-0574": {"epss_score": 0.00062, "epss_percentile": 0.19606}, "CVE-2020-0575": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-0576": {"epss_score": 0.00351, "epss_percentile": 0.57055}, "CVE-2020-0577": {"epss_score": 0.00289, "epss_percentile": 0.52003}, "CVE-2020-0578": {"epss_score": 0.00278, "epss_percentile": 0.5086}, "CVE-2020-0583": {"epss_score": 0.00341, "epss_percentile": 0.56314}, "CVE-2020-0584": {"epss_score": 0.0007, "epss_percentile": 0.21676}, "CVE-2020-0586": {"epss_score": 0.00072, "epss_percentile": 0.22424}, "CVE-2020-0587": {"epss_score": 0.0015, "epss_percentile": 0.36147}, "CVE-2020-0588": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2020-0590": {"epss_score": 0.00349, "epss_percentile": 0.56858}, "CVE-2020-0591": {"epss_score": 0.00164, "epss_percentile": 0.3787}, "CVE-2020-0592": {"epss_score": 0.0013, "epss_percentile": 0.3326}, "CVE-2020-0593": {"epss_score": 0.0015, "epss_percentile": 0.36147}, "CVE-2020-0594": {"epss_score": 0.02777, "epss_percentile": 0.8564}, "CVE-2020-0595": {"epss_score": 0.02777, "epss_percentile": 0.8564}, "CVE-2020-0596": {"epss_score": 0.01259, "epss_percentile": 0.78962}, "CVE-2020-0597": {"epss_score": 0.02727, "epss_percentile": 0.85529}, "CVE-2020-0598": {"epss_score": 0.00071, "epss_percentile": 0.22157}, "CVE-2020-0599": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2020-0600": {"epss_score": 0.00148, "epss_percentile": 0.35828}, "CVE-2020-0601": {"epss_score": 0.94093, "epss_percentile": 0.99901}, "CVE-2020-0602": {"epss_score": 0.04034, "epss_percentile": 0.88155}, "CVE-2020-0603": {"epss_score": 0.10943, "epss_percentile": 0.93167}, "CVE-2020-0604": {"epss_score": 0.09238, "epss_percentile": 0.92461}, "CVE-2020-0605": {"epss_score": 0.34056, "epss_percentile": 0.96824}, "CVE-2020-0606": {"epss_score": 0.32267, "epss_percentile": 0.96685}, "CVE-2020-0607": {"epss_score": 0.17621, "epss_percentile": 0.94876}, "CVE-2020-0608": {"epss_score": 0.00881, "epss_percentile": 0.74871}, "CVE-2020-0609": {"epss_score": 0.85824, "epss_percentile": 0.99351}, "CVE-2020-0610": {"epss_score": 0.87446, "epss_percentile": 0.9943}, "CVE-2020-0611": {"epss_score": 0.08104, "epss_percentile": 0.91881}, "CVE-2020-0612": {"epss_score": 0.10033, "epss_percentile": 0.92822}, "CVE-2020-0613": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0614": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0615": {"epss_score": 0.00614, "epss_percentile": 0.69266}, "CVE-2020-0616": {"epss_score": 0.00696, "epss_percentile": 0.71392}, "CVE-2020-0617": {"epss_score": 0.00413, "epss_percentile": 0.60989}, "CVE-2020-0618": {"epss_score": 0.94252, "epss_percentile": 0.99926}, "CVE-2020-0620": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0621": {"epss_score": 0.00183, "epss_percentile": 0.40296}, "CVE-2020-0622": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2020-0623": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0624": {"epss_score": 0.14766, "epss_percentile": 0.94279}, "CVE-2020-0625": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0626": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0627": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0628": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0629": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0630": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0631": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0632": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0633": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0634": {"epss_score": 0.00504, "epss_percentile": 0.65493}, "CVE-2020-0635": {"epss_score": 0.00365, "epss_percentile": 0.57997}, "CVE-2020-0636": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0637": {"epss_score": 0.1386, "epss_percentile": 0.94077}, "CVE-2020-0638": {"epss_score": 0.01479, "epss_percentile": 0.80561}, "CVE-2020-0639": {"epss_score": 0.00479, "epss_percentile": 0.64423}, "CVE-2020-0640": {"epss_score": 0.03426, "epss_percentile": 0.87115}, "CVE-2020-0641": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0642": {"epss_score": 0.00486, "epss_percentile": 0.64755}, "CVE-2020-0643": {"epss_score": 0.00881, "epss_percentile": 0.74871}, "CVE-2020-0644": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0645": {"epss_score": 0.0948, "epss_percentile": 0.92566}, "CVE-2020-0646": {"epss_score": 0.93865, "epss_percentile": 0.99859}, "CVE-2020-0647": {"epss_score": 0.00791, "epss_percentile": 0.73389}, "CVE-2020-0648": {"epss_score": 0.00408, "epss_percentile": 0.60686}, "CVE-2020-0650": {"epss_score": 0.33652, "epss_percentile": 0.96793}, "CVE-2020-0651": {"epss_score": 0.33652, "epss_percentile": 0.96793}, "CVE-2020-0652": {"epss_score": 0.1667, "epss_percentile": 0.94711}, "CVE-2020-0653": {"epss_score": 0.33652, "epss_percentile": 0.96793}, "CVE-2020-0654": {"epss_score": 0.1193, "epss_percentile": 0.93519}, "CVE-2020-0655": {"epss_score": 0.51831, "epss_percentile": 0.97799}, "CVE-2020-0656": {"epss_score": 0.00723, "epss_percentile": 0.72009}, "CVE-2020-0657": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0658": {"epss_score": 0.00636, "epss_percentile": 0.69867}, "CVE-2020-0659": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0660": {"epss_score": 0.07585, "epss_percentile": 0.91556}, "CVE-2020-0661": {"epss_score": 0.00601, "epss_percentile": 0.68842}, "CVE-2020-0662": {"epss_score": 0.34804, "epss_percentile": 0.96874}, "CVE-2020-0663": {"epss_score": 0.01395, "epss_percentile": 0.79973}, "CVE-2020-0664": {"epss_score": 0.15376, "epss_percentile": 0.94419}, "CVE-2020-0665": {"epss_score": 0.07353, "epss_percentile": 0.91427}, "CVE-2020-0666": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0667": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0668": {"epss_score": 0.79394, "epss_percentile": 0.99036}, "CVE-2020-0669": {"epss_score": 0.00773, "epss_percentile": 0.7305}, "CVE-2020-0670": {"epss_score": 0.00735, "epss_percentile": 0.72298}, "CVE-2020-0671": {"epss_score": 0.00735, "epss_percentile": 0.72298}, "CVE-2020-0672": {"epss_score": 0.00735, "epss_percentile": 0.72298}, "CVE-2020-0673": {"epss_score": 0.03017, "epss_percentile": 0.86217}, "CVE-2020-0674": {"epss_score": 0.93638, "epss_percentile": 0.99828}, "CVE-2020-0675": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2020-0676": {"epss_score": 0.00532, "epss_percentile": 0.66681}, "CVE-2020-0677": {"epss_score": 0.00532, "epss_percentile": 0.66681}, "CVE-2020-0678": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0679": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0680": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0681": {"epss_score": 0.07422, "epss_percentile": 0.91467}, "CVE-2020-0682": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0683": {"epss_score": 0.32732, "epss_percentile": 0.96721}, "CVE-2020-0684": {"epss_score": 0.38563, "epss_percentile": 0.97105}, "CVE-2020-0685": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0686": {"epss_score": 0.00475, "epss_percentile": 0.64187}, "CVE-2020-0687": {"epss_score": 0.43743, "epss_percentile": 0.97401}, "CVE-2020-0688": {"epss_score": 0.94396, "epss_percentile": 0.99972}, "CVE-2020-0689": {"epss_score": 0.00132, "epss_percentile": 0.33612}, "CVE-2020-0690": {"epss_score": 0.13249, "epss_percentile": 0.93913}, "CVE-2020-0691": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0692": {"epss_score": 0.05465, "epss_percentile": 0.89904}, "CVE-2020-0693": {"epss_score": 0.00698, "epss_percentile": 0.71421}, "CVE-2020-0694": {"epss_score": 0.00923, "epss_percentile": 0.75511}, "CVE-2020-0695": {"epss_score": 0.00791, "epss_percentile": 0.73389}, "CVE-2020-0696": {"epss_score": 0.05593, "epss_percentile": 0.90031}, "CVE-2020-0697": {"epss_score": 0.00243, "epss_percentile": 0.47416}, "CVE-2020-0698": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2020-0699": {"epss_score": 0.00542, "epss_percentile": 0.67078}, "CVE-2020-0700": {"epss_score": 0.00527, "epss_percentile": 0.66472}, "CVE-2020-0701": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0702": {"epss_score": 0.00228, "epss_percentile": 0.45517}, "CVE-2020-0703": {"epss_score": 0.00628, "epss_percentile": 0.69655}, "CVE-2020-0704": {"epss_score": 0.00463, "epss_percentile": 0.6366}, "CVE-2020-0705": {"epss_score": 0.00965, "epss_percentile": 0.76039}, "CVE-2020-0706": {"epss_score": 0.09895, "epss_percentile": 0.9276}, "CVE-2020-0707": {"epss_score": 0.00463, "epss_percentile": 0.6366}, "CVE-2020-0708": {"epss_score": 0.20172, "epss_percentile": 0.95298}, "CVE-2020-0709": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0710": {"epss_score": 0.03811, "epss_percentile": 0.87762}, "CVE-2020-0711": {"epss_score": 0.03811, "epss_percentile": 0.87762}, "CVE-2020-0712": {"epss_score": 0.03811, "epss_percentile": 0.87762}, "CVE-2020-0713": {"epss_score": 0.03811, "epss_percentile": 0.87762}, "CVE-2020-0714": {"epss_score": 0.00392, "epss_percentile": 0.59659}, "CVE-2020-0715": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0716": {"epss_score": 0.00532, "epss_percentile": 0.66681}, "CVE-2020-0717": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2020-0718": {"epss_score": 0.11137, "epss_percentile": 0.93237}, "CVE-2020-0719": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0720": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0721": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0722": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0723": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0724": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0725": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0726": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0727": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0728": {"epss_score": 0.13946, "epss_percentile": 0.94098}, "CVE-2020-0729": {"epss_score": 0.26771, "epss_percentile": 0.96178}, "CVE-2020-0730": {"epss_score": 0.00569, "epss_percentile": 0.67933}, "CVE-2020-0731": {"epss_score": 0.00544, "epss_percentile": 0.67144}, "CVE-2020-0732": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0733": {"epss_score": 0.0038, "epss_percentile": 0.58931}, "CVE-2020-0734": {"epss_score": 0.38649, "epss_percentile": 0.97111}, "CVE-2020-0735": {"epss_score": 0.00399, "epss_percentile": 0.60099}, "CVE-2020-0736": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2020-0737": {"epss_score": 0.00399, "epss_percentile": 0.60099}, "CVE-2020-0738": {"epss_score": 0.24193, "epss_percentile": 0.95885}, "CVE-2020-0739": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0740": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0741": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0742": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0743": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0744": {"epss_score": 0.00766, "epss_percentile": 0.72932}, "CVE-2020-0745": {"epss_score": 0.00401, "epss_percentile": 0.6022}, "CVE-2020-0746": {"epss_score": 0.1459, "epss_percentile": 0.94246}, "CVE-2020-0747": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0748": {"epss_score": 0.0053, "epss_percentile": 0.66606}, "CVE-2020-0749": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0750": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0751": {"epss_score": 0.00284, "epss_percentile": 0.51418}, "CVE-2020-0752": {"epss_score": 0.00399, "epss_percentile": 0.60099}, "CVE-2020-0753": {"epss_score": 0.19322, "epss_percentile": 0.95163}, "CVE-2020-0754": {"epss_score": 0.15333, "epss_percentile": 0.94411}, "CVE-2020-0755": {"epss_score": 0.0053, "epss_percentile": 0.66606}, "CVE-2020-0756": {"epss_score": 0.0053, "epss_percentile": 0.66606}, "CVE-2020-0757": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-0758": {"epss_score": 0.05427, "epss_percentile": 0.89869}, "CVE-2020-0759": {"epss_score": 0.32912, "epss_percentile": 0.96735}, "CVE-2020-0760": {"epss_score": 0.34566, "epss_percentile": 0.96856}, "CVE-2020-0761": {"epss_score": 0.11137, "epss_percentile": 0.93237}, "CVE-2020-0762": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0763": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-0764": {"epss_score": 0.00399, "epss_percentile": 0.60129}, "CVE-2020-0765": {"epss_score": 0.17372, "epss_percentile": 0.94841}, "CVE-2020-0766": {"epss_score": 0.00278, "epss_percentile": 0.50919}, "CVE-2020-0767": {"epss_score": 0.45715, "epss_percentile": 0.97499}, "CVE-2020-0768": {"epss_score": 0.06248, "epss_percentile": 0.90606}, "CVE-2020-0769": {"epss_score": 0.00521, "epss_percentile": 0.66242}, "CVE-2020-0770": {"epss_score": 0.00707, "epss_percentile": 0.71655}, "CVE-2020-0771": {"epss_score": 0.00707, "epss_percentile": 0.71655}, "CVE-2020-0772": {"epss_score": 0.0041, "epss_percentile": 0.6079}, "CVE-2020-0773": {"epss_score": 0.00707, "epss_percentile": 0.71655}, "CVE-2020-0774": {"epss_score": 0.23346, "epss_percentile": 0.95769}, "CVE-2020-0775": {"epss_score": 0.00965, "epss_percentile": 0.76039}, "CVE-2020-0776": {"epss_score": 0.00495, "epss_percentile": 0.65129}, "CVE-2020-0777": {"epss_score": 0.00399, "epss_percentile": 0.60104}, "CVE-2020-0778": {"epss_score": 0.00399, "epss_percentile": 0.60104}, "CVE-2020-0779": {"epss_score": 0.00615, "epss_percentile": 0.69314}, "CVE-2020-0780": {"epss_score": 0.00541, "epss_percentile": 0.67048}, "CVE-2020-0781": {"epss_score": 0.00544, "epss_percentile": 0.67144}, "CVE-2020-0782": {"epss_score": 0.00367, "epss_percentile": 0.58109}, "CVE-2020-0783": {"epss_score": 0.00544, "epss_percentile": 0.67144}, "CVE-2020-0784": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2020-0785": {"epss_score": 0.00465, "epss_percentile": 0.63771}, "CVE-2020-0786": {"epss_score": 0.00406, "epss_percentile": 0.60521}, "CVE-2020-0787": {"epss_score": 0.7244, "epss_percentile": 0.98709}, "CVE-2020-0788": {"epss_score": 0.00544, "epss_percentile": 0.67144}, "CVE-2020-0789": {"epss_score": 0.00304, "epss_percentile": 0.53302}, "CVE-2020-0790": {"epss_score": 0.00262, "epss_percentile": 0.49339}, "CVE-2020-0791": {"epss_score": 0.00531, "epss_percentile": 0.66663}, "CVE-2020-0792": {"epss_score": 0.00432, "epss_percentile": 0.62133}, "CVE-2020-0793": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0794": {"epss_score": 0.00232, "epss_percentile": 0.45901}, "CVE-2020-0795": {"epss_score": 0.00469, "epss_percentile": 0.63951}, "CVE-2020-0796": {"epss_score": 0.94408, "epss_percentile": 0.99974}, "CVE-2020-0797": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0798": {"epss_score": 0.00536, "epss_percentile": 0.66846}, "CVE-2020-0799": {"epss_score": 0.00624, "epss_percentile": 0.69575}, "CVE-2020-0800": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0801": {"epss_score": 0.13434, "epss_percentile": 0.93962}, "CVE-2020-0802": {"epss_score": 0.00531, "epss_percentile": 0.66663}, "CVE-2020-0803": {"epss_score": 0.00544, "epss_percentile": 0.67144}, "CVE-2020-0804": {"epss_score": 0.00544, "epss_percentile": 0.67144}, "CVE-2020-0805": {"epss_score": 0.00323, "epss_percentile": 0.54901}, "CVE-2020-0806": {"epss_score": 0.00399, "epss_percentile": 0.60099}, "CVE-2020-0807": {"epss_score": 0.17369, "epss_percentile": 0.94839}, "CVE-2020-0808": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0809": {"epss_score": 0.17369, "epss_percentile": 0.94839}, "CVE-2020-0810": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0811": {"epss_score": 0.03426, "epss_percentile": 0.87115}, "CVE-2020-0812": {"epss_score": 0.03426, "epss_percentile": 0.87115}, "CVE-2020-0813": {"epss_score": 0.09201, "epss_percentile": 0.92446}, "CVE-2020-0814": {"epss_score": 0.00631, "epss_percentile": 0.69727}, "CVE-2020-0815": {"epss_score": 0.05427, "epss_percentile": 0.89869}, "CVE-2020-0816": {"epss_score": 0.20625, "epss_percentile": 0.95387}, "CVE-2020-0819": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0820": {"epss_score": 0.00996, "epss_percentile": 0.76452}, "CVE-2020-0821": {"epss_score": 0.00407, "epss_percentile": 0.6061}, "CVE-2020-0822": {"epss_score": 0.00541, "epss_percentile": 0.67048}, "CVE-2020-0823": {"epss_score": 0.03843, "epss_percentile": 0.87836}, "CVE-2020-0824": {"epss_score": 0.04353, "epss_percentile": 0.88587}, "CVE-2020-0825": {"epss_score": 0.28794, "epss_percentile": 0.96384}, "CVE-2020-0826": {"epss_score": 0.03843, "epss_percentile": 0.87836}, "CVE-2020-0827": {"epss_score": 0.28794, "epss_percentile": 0.96384}, "CVE-2020-0828": {"epss_score": 0.03843, "epss_percentile": 0.87836}, "CVE-2020-0829": {"epss_score": 0.03843, "epss_percentile": 0.87836}, "CVE-2020-0830": {"epss_score": 0.08249, "epss_percentile": 0.91949}, "CVE-2020-0831": {"epss_score": 0.03843, "epss_percentile": 0.87836}, "CVE-2020-0832": {"epss_score": 0.03253, "epss_percentile": 0.86754}, "CVE-2020-0833": {"epss_score": 0.03253, "epss_percentile": 0.86754}, "CVE-2020-0834": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0835": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-0836": {"epss_score": 0.17989, "epss_percentile": 0.94938}, "CVE-2020-0837": {"epss_score": 0.0144, "epss_percentile": 0.80299}, "CVE-2020-0838": {"epss_score": 0.00363, "epss_percentile": 0.57835}, "CVE-2020-0839": {"epss_score": 0.00278, "epss_percentile": 0.50919}, "CVE-2020-0840": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0841": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0842": {"epss_score": 0.00544, "epss_percentile": 0.6714}, "CVE-2020-0843": {"epss_score": 0.00544, "epss_percentile": 0.6714}, "CVE-2020-0844": {"epss_score": 0.00399, "epss_percentile": 0.60099}, "CVE-2020-0845": {"epss_score": 0.00408, "epss_percentile": 0.60686}, "CVE-2020-0847": {"epss_score": 0.07988, "epss_percentile": 0.91808}, "CVE-2020-0848": {"epss_score": 0.03811, "epss_percentile": 0.87762}, "CVE-2020-0849": {"epss_score": 0.00401, "epss_percentile": 0.6022}, "CVE-2020-0850": {"epss_score": 0.33494, "epss_percentile": 0.96779}, "CVE-2020-0851": {"epss_score": 0.33652, "epss_percentile": 0.96793}, "CVE-2020-0852": {"epss_score": 0.33652, "epss_percentile": 0.96793}, "CVE-2020-0853": {"epss_score": 0.305, "epss_percentile": 0.96546}, "CVE-2020-0854": {"epss_score": 0.00371, "epss_percentile": 0.58356}, "CVE-2020-0855": {"epss_score": 0.33652, "epss_percentile": 0.96793}, "CVE-2020-0856": {"epss_score": 0.19192, "epss_percentile": 0.95146}, "CVE-2020-0857": {"epss_score": 0.00399, "epss_percentile": 0.60099}, "CVE-2020-0858": {"epss_score": 0.00463, "epss_percentile": 0.6366}, "CVE-2020-0859": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2020-0860": {"epss_score": 0.00468, "epss_percentile": 0.63872}, "CVE-2020-0861": {"epss_score": 0.00459, "epss_percentile": 0.63452}, "CVE-2020-0863": {"epss_score": 0.00392, "epss_percentile": 0.59659}, "CVE-2020-0864": {"epss_score": 0.00379, "epss_percentile": 0.58856}, "CVE-2020-0865": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-0866": {"epss_score": 0.00379, "epss_percentile": 0.58856}, "CVE-2020-0867": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0868": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0869": {"epss_score": 0.16946, "epss_percentile": 0.94752}, "CVE-2020-0870": {"epss_score": 0.00363, "epss_percentile": 0.57835}, "CVE-2020-0871": {"epss_score": 0.01772, "epss_percentile": 0.82201}, "CVE-2020-0872": {"epss_score": 0.04009, "epss_percentile": 0.88107}, "CVE-2020-0874": {"epss_score": 0.01241, "epss_percentile": 0.78816}, "CVE-2020-0875": {"epss_score": 0.23687, "epss_percentile": 0.95804}, "CVE-2020-0876": {"epss_score": 0.15157, "epss_percentile": 0.94375}, "CVE-2020-0877": {"epss_score": 0.00401, "epss_percentile": 0.6022}, "CVE-2020-0878": {"epss_score": 0.09821, "epss_percentile": 0.92718}, "CVE-2020-0879": {"epss_score": 0.00429, "epss_percentile": 0.61985}, "CVE-2020-0880": {"epss_score": 0.28799, "epss_percentile": 0.96385}, "CVE-2020-0881": {"epss_score": 0.40788, "epss_percentile": 0.97238}, "CVE-2020-0882": {"epss_score": 0.28799, "epss_percentile": 0.96385}, "CVE-2020-0883": {"epss_score": 0.5282, "epss_percentile": 0.97841}, "CVE-2020-0884": {"epss_score": 0.01635, "epss_percentile": 0.81473}, "CVE-2020-0885": {"epss_score": 0.09898, "epss_percentile": 0.92761}, "CVE-2020-0886": {"epss_score": 0.0026, "epss_percentile": 0.4918}, "CVE-2020-0887": {"epss_score": 0.13883, "epss_percentile": 0.94084}, "CVE-2020-0888": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-0889": {"epss_score": 0.33401, "epss_percentile": 0.9677}, "CVE-2020-0890": {"epss_score": 0.11148, "epss_percentile": 0.93239}, "CVE-2020-0891": {"epss_score": 0.00622, "epss_percentile": 0.69498}, "CVE-2020-0892": {"epss_score": 0.40161, "epss_percentile": 0.97203}, "CVE-2020-0893": {"epss_score": 0.00898, "epss_percentile": 0.75147}, "CVE-2020-0894": {"epss_score": 0.00898, "epss_percentile": 0.75147}, "CVE-2020-0895": {"epss_score": 0.09339, "epss_percentile": 0.92507}, "CVE-2020-0896": {"epss_score": 0.00354, "epss_percentile": 0.57219}, "CVE-2020-0897": {"epss_score": 0.00379, "epss_percentile": 0.58856}, "CVE-2020-0898": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0899": {"epss_score": 0.00248, "epss_percentile": 0.47921}, "CVE-2020-0900": {"epss_score": 0.00328, "epss_percentile": 0.55166}, "CVE-2020-0901": {"epss_score": 0.45859, "epss_percentile": 0.97505}, "CVE-2020-0902": {"epss_score": 0.16044, "epss_percentile": 0.94564}, "CVE-2020-0903": {"epss_score": 0.00732, "epss_percentile": 0.72185}, "CVE-2020-0904": {"epss_score": 0.00657, "epss_percentile": 0.70455}, "CVE-2020-0905": {"epss_score": 0.32922, "epss_percentile": 0.96736}, "CVE-2020-0906": {"epss_score": 0.32912, "epss_percentile": 0.96735}, "CVE-2020-0907": {"epss_score": 0.35207, "epss_percentile": 0.96894}, "CVE-2020-0908": {"epss_score": 0.04169, "epss_percentile": 0.88345}, "CVE-2020-0909": {"epss_score": 0.12366, "epss_percentile": 0.9365}, "CVE-2020-0910": {"epss_score": 0.14773, "epss_percentile": 0.9428}, "CVE-2020-0911": {"epss_score": 0.00429, "epss_percentile": 0.61984}, "CVE-2020-0912": {"epss_score": 0.00162, "epss_percentile": 0.37683}, "CVE-2020-0913": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0914": {"epss_score": 0.00889, "epss_percentile": 0.75011}, "CVE-2020-0915": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0916": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0917": {"epss_score": 0.01196, "epss_percentile": 0.78438}, "CVE-2020-0918": {"epss_score": 0.00794, "epss_percentile": 0.73458}, "CVE-2020-0919": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0920": {"epss_score": 0.20663, "epss_percentile": 0.95397}, "CVE-2020-0921": {"epss_score": 0.00694, "epss_percentile": 0.71353}, "CVE-2020-0922": {"epss_score": 0.1417, "epss_percentile": 0.94148}, "CVE-2020-0923": {"epss_score": 0.00824, "epss_percentile": 0.73944}, "CVE-2020-0924": {"epss_score": 0.01102, "epss_percentile": 0.77579}, "CVE-2020-0925": {"epss_score": 0.00824, "epss_percentile": 0.73944}, "CVE-2020-0926": {"epss_score": 0.00893, "epss_percentile": 0.75079}, "CVE-2020-0927": {"epss_score": 0.00824, "epss_percentile": 0.73944}, "CVE-2020-0928": {"epss_score": 0.00656, "epss_percentile": 0.70433}, "CVE-2020-0929": {"epss_score": 0.20663, "epss_percentile": 0.95397}, "CVE-2020-0930": {"epss_score": 0.00824, "epss_percentile": 0.73944}, "CVE-2020-0931": {"epss_score": 0.20663, "epss_percentile": 0.95397}, "CVE-2020-0932": {"epss_score": 0.33585, "epss_percentile": 0.96785}, "CVE-2020-0933": {"epss_score": 0.00824, "epss_percentile": 0.73944}, "CVE-2020-0934": {"epss_score": 0.00505, "epss_percentile": 0.65584}, "CVE-2020-0935": {"epss_score": 0.00475, "epss_percentile": 0.64192}, "CVE-2020-0936": {"epss_score": 0.00371, "epss_percentile": 0.58356}, "CVE-2020-0937": {"epss_score": 0.27512, "epss_percentile": 0.96254}, "CVE-2020-0938": {"epss_score": 0.89307, "epss_percentile": 0.99519}, "CVE-2020-0939": {"epss_score": 0.27512, "epss_percentile": 0.96254}, "CVE-2020-0940": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0941": {"epss_score": 0.00775, "epss_percentile": 0.73091}, "CVE-2020-0942": {"epss_score": 0.00371, "epss_percentile": 0.58356}, "CVE-2020-0943": {"epss_score": 0.00217, "epss_percentile": 0.44254}, "CVE-2020-0944": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-0945": {"epss_score": 0.27512, "epss_percentile": 0.96254}, "CVE-2020-0946": {"epss_score": 0.30613, "epss_percentile": 0.96555}, "CVE-2020-0947": {"epss_score": 0.27512, "epss_percentile": 0.96254}, "CVE-2020-0948": {"epss_score": 0.2125, "epss_percentile": 0.95487}, "CVE-2020-0949": {"epss_score": 0.2125, "epss_percentile": 0.95487}, "CVE-2020-0950": {"epss_score": 0.2125, "epss_percentile": 0.95487}, "CVE-2020-0951": {"epss_score": 0.00533, "epss_percentile": 0.66772}, "CVE-2020-0952": {"epss_score": 0.305, "epss_percentile": 0.96546}, "CVE-2020-0953": {"epss_score": 0.40161, "epss_percentile": 0.97203}, "CVE-2020-0954": {"epss_score": 0.00824, "epss_percentile": 0.73944}, "CVE-2020-0955": {"epss_score": 0.00565, "epss_percentile": 0.67796}, "CVE-2020-0956": {"epss_score": 0.00277, "epss_percentile": 0.50783}, "CVE-2020-0957": {"epss_score": 0.00277, "epss_percentile": 0.50783}, "CVE-2020-0958": {"epss_score": 0.00277, "epss_percentile": 0.50783}, "CVE-2020-0959": {"epss_score": 0.40161, "epss_percentile": 0.97203}, "CVE-2020-0960": {"epss_score": 0.40161, "epss_percentile": 0.97203}, "CVE-2020-0961": {"epss_score": 0.33652, "epss_percentile": 0.96793}, "CVE-2020-0962": {"epss_score": 0.00869, "epss_percentile": 0.74692}, "CVE-2020-0963": {"epss_score": 0.29795, "epss_percentile": 0.96476}, "CVE-2020-0964": {"epss_score": 0.32484, "epss_percentile": 0.96704}, "CVE-2020-0965": {"epss_score": 0.0125, "epss_percentile": 0.78891}, "CVE-2020-0966": {"epss_score": 0.31833, "epss_percentile": 0.96652}, "CVE-2020-0967": {"epss_score": 0.17912, "epss_percentile": 0.94926}, "CVE-2020-0968": {"epss_score": 0.33411, "epss_percentile": 0.96771}, "CVE-2020-0969": {"epss_score": 0.38317, "epss_percentile": 0.97095}, "CVE-2020-0970": {"epss_score": 0.38317, "epss_percentile": 0.97095}, "CVE-2020-0971": {"epss_score": 0.22501, "epss_percentile": 0.95644}, "CVE-2020-0972": {"epss_score": 0.00612, "epss_percentile": 0.69226}, "CVE-2020-0973": {"epss_score": 0.0097, "epss_percentile": 0.76109}, "CVE-2020-0974": {"epss_score": 0.20663, "epss_percentile": 0.95397}, "CVE-2020-0975": {"epss_score": 0.00612, "epss_percentile": 0.69226}, "CVE-2020-0976": {"epss_score": 0.00587, "epss_percentile": 0.68483}, "CVE-2020-0977": {"epss_score": 0.00612, "epss_percentile": 0.69226}, "CVE-2020-0978": {"epss_score": 0.00824, "epss_percentile": 0.73944}, "CVE-2020-0979": {"epss_score": 0.32912, "epss_percentile": 0.96735}, "CVE-2020-0980": {"epss_score": 0.40161, "epss_percentile": 0.97203}, "CVE-2020-0981": {"epss_score": 0.00042, "epss_percentile": 0.12913}, "CVE-2020-0982": {"epss_score": 0.00973, "epss_percentile": 0.76165}, "CVE-2020-0983": {"epss_score": 0.00549, "epss_percentile": 0.67302}, "CVE-2020-0984": {"epss_score": 0.00399, "epss_percentile": 0.60129}, "CVE-2020-0985": {"epss_score": 0.00404, "epss_percentile": 0.60441}, "CVE-2020-0986": {"epss_score": 0.2065, "epss_percentile": 0.95395}, "CVE-2020-0987": {"epss_score": 0.01997, "epss_percentile": 0.83206}, "CVE-2020-0988": {"epss_score": 0.33401, "epss_percentile": 0.9677}, "CVE-2020-0989": {"epss_score": 0.00763, "epss_percentile": 0.72851}, "CVE-2020-0991": {"epss_score": 0.33652, "epss_percentile": 0.96793}, "CVE-2020-0992": {"epss_score": 0.33401, "epss_percentile": 0.9677}, "CVE-2020-0993": {"epss_score": 0.09389, "epss_percentile": 0.92529}, "CVE-2020-0994": {"epss_score": 0.40161, "epss_percentile": 0.97203}, "CVE-2020-0995": {"epss_score": 0.34064, "epss_percentile": 0.96825}, "CVE-2020-0996": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-0997": {"epss_score": 0.09268, "epss_percentile": 0.92473}, "CVE-2020-0998": {"epss_score": 0.00363, "epss_percentile": 0.57835}, "CVE-2020-0999": {"epss_score": 0.33401, "epss_percentile": 0.9677}, "CVE-2020-10001": {"epss_score": 0.00086, "epss_percentile": 0.25314}, "CVE-2020-10002": {"epss_score": 0.00108, "epss_percentile": 0.29794}, "CVE-2020-10003": {"epss_score": 0.00177, "epss_percentile": 0.39501}, "CVE-2020-10004": {"epss_score": 0.00559, "epss_percentile": 0.67623}, "CVE-2020-10005": {"epss_score": 0.00243, "epss_percentile": 0.47467}, "CVE-2020-10006": {"epss_score": 0.003, "epss_percentile": 0.52951}, "CVE-2020-10007": {"epss_score": 0.00148, "epss_percentile": 0.35824}, "CVE-2020-10008": {"epss_score": 0.00466, "epss_percentile": 0.63795}, "CVE-2020-10009": {"epss_score": 0.00289, "epss_percentile": 0.52037}, "CVE-2020-10010": {"epss_score": 0.00105, "epss_percentile": 0.29301}, "CVE-2020-10011": {"epss_score": 0.00716, "epss_percentile": 0.71862}, "CVE-2020-10012": {"epss_score": 0.00891, "epss_percentile": 0.75049}, "CVE-2020-10013": {"epss_score": 0.00246, "epss_percentile": 0.47794}, "CVE-2020-10014": {"epss_score": 0.00755, "epss_percentile": 0.72724}, "CVE-2020-10015": {"epss_score": 0.00235, "epss_percentile": 0.46244}, "CVE-2020-10016": {"epss_score": 0.00564, "epss_percentile": 0.67774}, "CVE-2020-10017": {"epss_score": 0.00646, "epss_percentile": 0.70135}, "CVE-2020-10018": {"epss_score": 0.02039, "epss_percentile": 0.83363}, "CVE-2020-10019": {"epss_score": 0.00089, "epss_percentile": 0.2585}, "CVE-2020-10021": {"epss_score": 0.00077, "epss_percentile": 0.23364}, "CVE-2020-10022": {"epss_score": 0.01697, "epss_percentile": 0.81818}, "CVE-2020-10023": {"epss_score": 0.00099, "epss_percentile": 0.28373}, "CVE-2020-10024": {"epss_score": 0.00092, "epss_percentile": 0.26441}, "CVE-2020-10027": {"epss_score": 0.00092, "epss_percentile": 0.26441}, "CVE-2020-10028": {"epss_score": 0.00077, "epss_percentile": 0.23364}, "CVE-2020-10029": {"epss_score": 0.0005, "epss_percentile": 0.15976}, "CVE-2020-10030": {"epss_score": 0.00029, "epss_percentile": 0.07657}, "CVE-2020-10037": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-10038": {"epss_score": 0.00392, "epss_percentile": 0.59657}, "CVE-2020-10039": {"epss_score": 0.002, "epss_percentile": 0.42261}, "CVE-2020-10040": {"epss_score": 0.00025, "epss_percentile": 0.06236}, "CVE-2020-10041": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2020-10042": {"epss_score": 0.01297, "epss_percentile": 0.79264}, "CVE-2020-10043": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-10044": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2020-10045": {"epss_score": 0.00331, "epss_percentile": 0.5551}, "CVE-2020-10048": {"epss_score": 0.00057, "epss_percentile": 0.18136}, "CVE-2020-10049": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2020-10050": {"epss_score": 0.00034, "epss_percentile": 0.09558}, "CVE-2020-10051": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2020-10052": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2020-10053": {"epss_score": 0.00025, "epss_percentile": 0.06236}, "CVE-2020-10054": {"epss_score": 0.00045, "epss_percentile": 0.13765}, "CVE-2020-10055": {"epss_score": 0.02702, "epss_percentile": 0.85456}, "CVE-2020-10056": {"epss_score": 0.00047, "epss_percentile": 0.14493}, "CVE-2020-10057": {"epss_score": 0.00177, "epss_percentile": 0.39553}, "CVE-2020-10058": {"epss_score": 0.00081, "epss_percentile": 0.24211}, "CVE-2020-10059": {"epss_score": 0.00373, "epss_percentile": 0.58471}, "CVE-2020-10060": {"epss_score": 0.02972, "epss_percentile": 0.86097}, "CVE-2020-10061": {"epss_score": 0.00097, "epss_percentile": 0.275}, "CVE-2020-10062": {"epss_score": 0.05817, "epss_percentile": 0.90232}, "CVE-2020-10063": {"epss_score": 0.0187, "epss_percentile": 0.82632}, "CVE-2020-10064": {"epss_score": 0.00438, "epss_percentile": 0.62549}, "CVE-2020-10065": {"epss_score": 0.00109, "epss_percentile": 0.30062}, "CVE-2020-10066": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2020-10067": {"epss_score": 0.00062, "epss_percentile": 0.19554}, "CVE-2020-10068": {"epss_score": 0.00075, "epss_percentile": 0.22915}, "CVE-2020-10069": {"epss_score": 0.00095, "epss_percentile": 0.27184}, "CVE-2020-10070": {"epss_score": 0.06474, "epss_percentile": 0.90781}, "CVE-2020-10071": {"epss_score": 0.13899, "epss_percentile": 0.94089}, "CVE-2020-10072": {"epss_score": 0.00036, "epss_percentile": 0.10319}, "CVE-2020-10073": {"epss_score": 0.00107, "epss_percentile": 0.29631}, "CVE-2020-10074": {"epss_score": 0.00145, "epss_percentile": 0.3542}, "CVE-2020-10075": {"epss_score": 0.001, "epss_percentile": 0.28555}, "CVE-2020-10076": {"epss_score": 0.001, "epss_percentile": 0.28555}, "CVE-2020-10077": {"epss_score": 0.00136, "epss_percentile": 0.34195}, "CVE-2020-10078": {"epss_score": 0.001, "epss_percentile": 0.28555}, "CVE-2020-10079": {"epss_score": 0.00076, "epss_percentile": 0.23211}, "CVE-2020-10080": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2020-10081": {"epss_score": 0.00075, "epss_percentile": 0.22944}, "CVE-2020-10082": {"epss_score": 0.00114, "epss_percentile": 0.30779}, "CVE-2020-10083": {"epss_score": 0.00053, "epss_percentile": 0.1691}, "CVE-2020-10084": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2020-10085": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2020-10086": {"epss_score": 0.00046, "epss_percentile": 0.1411}, "CVE-2020-10087": {"epss_score": 0.00077, "epss_percentile": 0.23384}, "CVE-2020-10088": {"epss_score": 0.00049, "epss_percentile": 0.1548}, "CVE-2020-10089": {"epss_score": 0.00141, "epss_percentile": 0.34932}, "CVE-2020-10090": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2020-10091": {"epss_score": 0.001, "epss_percentile": 0.28555}, "CVE-2020-10092": {"epss_score": 0.001, "epss_percentile": 0.28555}, "CVE-2020-10093": {"epss_score": 0.00352, "epss_percentile": 0.57122}, "CVE-2020-10094": {"epss_score": 0.00352, "epss_percentile": 0.57122}, "CVE-2020-10095": {"epss_score": 0.00038, "epss_percentile": 0.11152}, "CVE-2020-10096": {"epss_score": 0.00458, "epss_percentile": 0.63438}, "CVE-2020-10097": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2020-10098": {"epss_score": 0.00402, "epss_percentile": 0.6028}, "CVE-2020-10099": {"epss_score": 0.00402, "epss_percentile": 0.6028}, "CVE-2020-10100": {"epss_score": 0.00405, "epss_percentile": 0.6049}, "CVE-2020-10101": {"epss_score": 0.00692, "epss_percentile": 0.71294}, "CVE-2020-10102": {"epss_score": 0.00405, "epss_percentile": 0.6049}, "CVE-2020-10103": {"epss_score": 0.00402, "epss_percentile": 0.6028}, "CVE-2020-10104": {"epss_score": 0.00323, "epss_percentile": 0.54894}, "CVE-2020-10105": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2020-10106": {"epss_score": 0.0011, "epss_percentile": 0.30125}, "CVE-2020-10107": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-10108": {"epss_score": 0.03411, "epss_percentile": 0.87083}, "CVE-2020-10109": {"epss_score": 0.03518, "epss_percentile": 0.87281}, "CVE-2020-10110": {"epss_score": 0.00586, "epss_percentile": 0.68435}, "CVE-2020-10111": {"epss_score": 0.00501, "epss_percentile": 0.65349}, "CVE-2020-10112": {"epss_score": 0.00501, "epss_percentile": 0.65345}, "CVE-2020-10113": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2020-10114": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2020-10115": {"epss_score": 0.00518, "epss_percentile": 0.66106}, "CVE-2020-10116": {"epss_score": 0.00188, "epss_percentile": 0.40809}, "CVE-2020-10117": {"epss_score": 0.00368, "epss_percentile": 0.58179}, "CVE-2020-10118": {"epss_score": 0.00341, "epss_percentile": 0.56346}, "CVE-2020-10119": {"epss_score": 0.03407, "epss_percentile": 0.87077}, "CVE-2020-10120": {"epss_score": 0.04836, "epss_percentile": 0.89194}, "CVE-2020-10121": {"epss_score": 0.00589, "epss_percentile": 0.6853}, "CVE-2020-10122": {"epss_score": 0.0054, "epss_percentile": 0.66993}, "CVE-2020-10123": {"epss_score": 0.00104, "epss_percentile": 0.29141}, "CVE-2020-10124": {"epss_score": 0.0257, "epss_percentile": 0.85127}, "CVE-2020-10125": {"epss_score": 0.00024, "epss_percentile": 0.05817}, "CVE-2020-10126": {"epss_score": 0.00029, "epss_percentile": 0.07741}, "CVE-2020-10128": {"epss_score": 0.00211, "epss_percentile": 0.43618}, "CVE-2020-10129": {"epss_score": 0.00173, "epss_percentile": 0.39131}, "CVE-2020-10130": {"epss_score": 0.00153, "epss_percentile": 0.36567}, "CVE-2020-10131": {"epss_score": 0.08838, "epss_percentile": 0.92278}, "CVE-2020-10132": {"epss_score": 0.04446, "epss_percentile": 0.88699}, "CVE-2020-10134": {"epss_score": 0.00118, "epss_percentile": 0.31446}, "CVE-2020-10135": {"epss_score": 0.26913, "epss_percentile": 0.96191}, "CVE-2020-10136": {"epss_score": 0.24274, "epss_percentile": 0.95898}, "CVE-2020-10137": {"epss_score": 0.00151, "epss_percentile": 0.36315}, "CVE-2020-10138": {"epss_score": 0.00045, "epss_percentile": 0.13795}, "CVE-2020-10139": {"epss_score": 0.00045, "epss_percentile": 0.13795}, "CVE-2020-10140": {"epss_score": 0.00045, "epss_percentile": 0.13795}, "CVE-2020-10143": {"epss_score": 0.00045, "epss_percentile": 0.13966}, "CVE-2020-10145": {"epss_score": 0.0007, "epss_percentile": 0.218}, "CVE-2020-10146": {"epss_score": 0.00516, "epss_percentile": 0.66051}, "CVE-2020-10148": {"epss_score": 0.94304, "epss_percentile": 0.99942}, "CVE-2020-10173": {"epss_score": 0.65176, "epss_percentile": 0.98407}, "CVE-2020-10174": {"epss_score": 0.00124, "epss_percentile": 0.32401}, "CVE-2020-10176": {"epss_score": 0.00453, "epss_percentile": 0.63226}, "CVE-2020-10177": {"epss_score": 0.0012, "epss_percentile": 0.31751}, "CVE-2020-10180": {"epss_score": 0.00469, "epss_percentile": 0.63934}, "CVE-2020-10181": {"epss_score": 0.20551, "epss_percentile": 0.95376}, "CVE-2020-10184": {"epss_score": 0.00592, "epss_percentile": 0.6861}, "CVE-2020-10185": {"epss_score": 0.00589, "epss_percentile": 0.68516}, "CVE-2020-10187": {"epss_score": 0.00425, "epss_percentile": 0.61711}, "CVE-2020-10188": {"epss_score": 0.08553, "epss_percentile": 0.9212}, "CVE-2020-10189": {"epss_score": 0.94248, "epss_percentile": 0.99925}, "CVE-2020-10190": {"epss_score": 0.00515, "epss_percentile": 0.66003}, "CVE-2020-10191": {"epss_score": 0.00573, "epss_percentile": 0.6805}, "CVE-2020-10192": {"epss_score": 0.00668, "epss_percentile": 0.70727}, "CVE-2020-10193": {"epss_score": 0.00496, "epss_percentile": 0.65177}, "CVE-2020-10194": {"epss_score": 0.0024, "epss_percentile": 0.47191}, "CVE-2020-10195": {"epss_score": 0.00461, "epss_percentile": 0.63543}, "CVE-2020-10196": {"epss_score": 0.00229, "epss_percentile": 0.45663}, "CVE-2020-10199": {"epss_score": 0.94379, "epss_percentile": 0.99964}, "CVE-2020-10203": {"epss_score": 0.00351, "epss_percentile": 0.57077}, "CVE-2020-10204": {"epss_score": 0.53428, "epss_percentile": 0.97876}, "CVE-2020-10206": {"epss_score": 0.00043, "epss_percentile": 0.1301}, "CVE-2020-10207": {"epss_score": 0.03958, "epss_percentile": 0.88007}, "CVE-2020-10208": {"epss_score": 0.08336, "epss_percentile": 0.91996}, "CVE-2020-10209": {"epss_score": 0.0313, "epss_percentile": 0.86463}, "CVE-2020-10210": {"epss_score": 0.00455, "epss_percentile": 0.63311}, "CVE-2020-10211": {"epss_score": 0.01677, "epss_percentile": 0.81716}, "CVE-2020-10212": {"epss_score": 0.00982, "epss_percentile": 0.76285}, "CVE-2020-10213": {"epss_score": 0.03411, "epss_percentile": 0.87084}, "CVE-2020-10214": {"epss_score": 0.01998, "epss_percentile": 0.8321}, "CVE-2020-10215": {"epss_score": 0.03073, "epss_percentile": 0.86354}, "CVE-2020-10216": {"epss_score": 0.03434, "epss_percentile": 0.87129}, "CVE-2020-10218": {"epss_score": 0.00229, "epss_percentile": 0.45589}, "CVE-2020-10220": {"epss_score": 0.94024, "epss_percentile": 0.99888}, "CVE-2020-10221": {"epss_score": 0.91391, "epss_percentile": 0.99639}, "CVE-2020-10222": {"epss_score": 0.0002, "epss_percentile": 0.04624}, "CVE-2020-10223": {"epss_score": 0.0002, "epss_percentile": 0.04624}, "CVE-2020-10224": {"epss_score": 0.13529, "epss_percentile": 0.93989}, "CVE-2020-10225": {"epss_score": 0.09353, "epss_percentile": 0.92513}, "CVE-2020-10227": {"epss_score": 0.00509, "epss_percentile": 0.65739}, "CVE-2020-10228": {"epss_score": 0.0681, "epss_percentile": 0.9104}, "CVE-2020-10229": {"epss_score": 0.00304, "epss_percentile": 0.53249}, "CVE-2020-10230": {"epss_score": 0.28895, "epss_percentile": 0.96398}, "CVE-2020-10231": {"epss_score": 0.01402, "epss_percentile": 0.80013}, "CVE-2020-10232": {"epss_score": 0.01411, "epss_percentile": 0.80111}, "CVE-2020-10233": {"epss_score": 0.00546, "epss_percentile": 0.67216}, "CVE-2020-10234": {"epss_score": 0.00488, "epss_percentile": 0.64843}, "CVE-2020-10235": {"epss_score": 0.007, "epss_percentile": 0.71473}, "CVE-2020-10236": {"epss_score": 0.00139, "epss_percentile": 0.34645}, "CVE-2020-10237": {"epss_score": 0.00077, "epss_percentile": 0.23529}, "CVE-2020-10238": {"epss_score": 0.03013, "epss_percentile": 0.86203}, "CVE-2020-10239": {"epss_score": 0.01726, "epss_percentile": 0.81958}, "CVE-2020-10240": {"epss_score": 0.0003, "epss_percentile": 0.08095}, "CVE-2020-10241": {"epss_score": 0.00037, "epss_percentile": 0.10682}, "CVE-2020-10242": {"epss_score": 0.01258, "epss_percentile": 0.78956}, "CVE-2020-10243": {"epss_score": 0.00149, "epss_percentile": 0.35997}, "CVE-2020-10244": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2020-10245": {"epss_score": 0.00825, "epss_percentile": 0.73947}, "CVE-2020-10246": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-10247": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-10248": {"epss_score": 0.00542, "epss_percentile": 0.67071}, "CVE-2020-10249": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2020-10250": {"epss_score": 0.03253, "epss_percentile": 0.86755}, "CVE-2020-10251": {"epss_score": 0.00542, "epss_percentile": 0.67075}, "CVE-2020-10252": {"epss_score": 0.00584, "epss_percentile": 0.6837}, "CVE-2020-10254": {"epss_score": 0.00319, "epss_percentile": 0.54481}, "CVE-2020-10255": {"epss_score": 0.01543, "epss_percentile": 0.80956}, "CVE-2020-10256": {"epss_score": 0.00264, "epss_percentile": 0.4971}, "CVE-2020-10257": {"epss_score": 0.47784, "epss_percentile": 0.97601}, "CVE-2020-10262": {"epss_score": 0.00153, "epss_percentile": 0.36579}, "CVE-2020-10263": {"epss_score": 0.00137, "epss_percentile": 0.34235}, "CVE-2020-10264": {"epss_score": 0.00115, "epss_percentile": 0.30987}, "CVE-2020-10265": {"epss_score": 0.00358, "epss_percentile": 0.57513}, "CVE-2020-10266": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2020-10267": {"epss_score": 0.00124, "epss_percentile": 0.32342}, "CVE-2020-10268": {"epss_score": 0.00055, "epss_percentile": 0.17571}, "CVE-2020-10269": {"epss_score": 0.00305, "epss_percentile": 0.53383}, "CVE-2020-10270": {"epss_score": 0.00466, "epss_percentile": 0.638}, "CVE-2020-10271": {"epss_score": 0.00441, "epss_percentile": 0.6265}, "CVE-2020-10272": {"epss_score": 0.00473, "epss_percentile": 0.64103}, "CVE-2020-10273": {"epss_score": 0.00124, "epss_percentile": 0.32342}, "CVE-2020-10274": {"epss_score": 0.00279, "epss_percentile": 0.50979}, "CVE-2020-10275": {"epss_score": 0.0017, "epss_percentile": 0.38682}, "CVE-2020-10276": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2020-10277": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2020-10278": {"epss_score": 0.00223, "epss_percentile": 0.44863}, "CVE-2020-10279": {"epss_score": 0.00287, "epss_percentile": 0.51841}, "CVE-2020-10280": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-10281": {"epss_score": 0.00099, "epss_percentile": 0.28405}, "CVE-2020-10282": {"epss_score": 0.00442, "epss_percentile": 0.6273}, "CVE-2020-10283": {"epss_score": 0.0042, "epss_percentile": 0.61425}, "CVE-2020-10284": {"epss_score": 0.00459, "epss_percentile": 0.63461}, "CVE-2020-10285": {"epss_score": 0.0037, "epss_percentile": 0.5832}, "CVE-2020-10286": {"epss_score": 0.00195, "epss_percentile": 0.41689}, "CVE-2020-10287": {"epss_score": 0.00384, "epss_percentile": 0.59149}, "CVE-2020-10288": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2020-10289": {"epss_score": 0.00775, "epss_percentile": 0.7309}, "CVE-2020-10290": {"epss_score": 0.00036, "epss_percentile": 0.10546}, "CVE-2020-10291": {"epss_score": 0.00301, "epss_percentile": 0.52998}, "CVE-2020-10292": {"epss_score": 0.00655, "epss_percentile": 0.70368}, "CVE-2020-10364": {"epss_score": 0.02151, "epss_percentile": 0.83788}, "CVE-2020-10365": {"epss_score": 0.00445, "epss_percentile": 0.62859}, "CVE-2020-10366": {"epss_score": 0.00406, "epss_percentile": 0.60558}, "CVE-2020-10367": {"epss_score": 0.0006, "epss_percentile": 0.19102}, "CVE-2020-10368": {"epss_score": 0.00056, "epss_percentile": 0.17907}, "CVE-2020-10369": {"epss_score": 0.0006, "epss_percentile": 0.19102}, "CVE-2020-10370": {"epss_score": 0.00075, "epss_percentile": 0.23015}, "CVE-2020-10372": {"epss_score": 0.00592, "epss_percentile": 0.68627}, "CVE-2020-10374": {"epss_score": 0.04889, "epss_percentile": 0.89258}, "CVE-2020-10375": {"epss_score": 0.00027, "epss_percentile": 0.07093}, "CVE-2020-10376": {"epss_score": 0.00225, "epss_percentile": 0.451}, "CVE-2020-10377": {"epss_score": 0.00109, "epss_percentile": 0.30038}, "CVE-2020-10378": {"epss_score": 0.00333, "epss_percentile": 0.55667}, "CVE-2020-10379": {"epss_score": 0.00403, "epss_percentile": 0.60386}, "CVE-2020-10380": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-10381": {"epss_score": 0.00294, "epss_percentile": 0.52434}, "CVE-2020-10382": {"epss_score": 0.02398, "epss_percentile": 0.84621}, "CVE-2020-10383": {"epss_score": 0.02486, "epss_percentile": 0.84887}, "CVE-2020-10384": {"epss_score": 0.00034, "epss_percentile": 0.09558}, "CVE-2020-10385": {"epss_score": 0.00574, "epss_percentile": 0.68071}, "CVE-2020-10386": {"epss_score": 0.18696, "epss_percentile": 0.95055}, "CVE-2020-10387": {"epss_score": 0.12786, "epss_percentile": 0.93773}, "CVE-2020-10388": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-10389": {"epss_score": 0.09039, "epss_percentile": 0.92377}, "CVE-2020-10390": {"epss_score": 0.047, "epss_percentile": 0.89023}, "CVE-2020-10391": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10392": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10393": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10394": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10395": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10396": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10397": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10398": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10399": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10400": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10401": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10402": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10403": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10404": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10405": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10406": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10407": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10408": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10409": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10410": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10411": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10412": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10413": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10414": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10415": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10416": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10417": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10418": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10419": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10420": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10421": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10422": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10423": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10424": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10425": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10426": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10427": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10428": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10429": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10430": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10431": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10432": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10433": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10434": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10435": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10436": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10437": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10438": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10439": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10440": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10441": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10442": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10443": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10444": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10445": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10446": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10447": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10448": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10449": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10450": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10451": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10452": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10453": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10454": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10455": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10456": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10457": {"epss_score": 0.00405, "epss_percentile": 0.60457}, "CVE-2020-10458": {"epss_score": 0.00461, "epss_percentile": 0.63538}, "CVE-2020-10459": {"epss_score": 0.00418, "epss_percentile": 0.61261}, "CVE-2020-10460": {"epss_score": 0.00338, "epss_percentile": 0.56129}, "CVE-2020-10461": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-10462": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10463": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10464": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10465": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10466": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10467": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10468": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10469": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10470": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10471": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10472": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10473": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10474": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10475": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10476": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10477": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-10478": {"epss_score": 0.00189, "epss_percentile": 0.40949}, "CVE-2020-10479": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10480": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10481": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10482": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10483": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10484": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10485": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10486": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10487": {"epss_score": 0.00144, "epss_percentile": 0.35322}, "CVE-2020-10488": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10489": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10490": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10491": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10492": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10493": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10494": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10495": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10496": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10497": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10498": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10499": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10500": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10501": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10502": {"epss_score": 0.00147, "epss_percentile": 0.35708}, "CVE-2020-10503": {"epss_score": 0.00147, "epss_percentile": 0.35708}, "CVE-2020-10504": {"epss_score": 0.00147, "epss_percentile": 0.35721}, "CVE-2020-10505": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2020-10506": {"epss_score": 0.00469, "epss_percentile": 0.63919}, "CVE-2020-10507": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2020-10508": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-10509": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-10510": {"epss_score": 0.00218, "epss_percentile": 0.44391}, "CVE-2020-10511": {"epss_score": 0.00517, "epss_percentile": 0.66083}, "CVE-2020-10512": {"epss_score": 0.00364, "epss_percentile": 0.57941}, "CVE-2020-10513": {"epss_score": 0.00255, "epss_percentile": 0.48712}, "CVE-2020-10514": {"epss_score": 0.00408, "epss_percentile": 0.60674}, "CVE-2020-10515": {"epss_score": 0.00991, "epss_percentile": 0.76382}, "CVE-2020-10516": {"epss_score": 0.0038, "epss_percentile": 0.58941}, "CVE-2020-10517": {"epss_score": 0.00214, "epss_percentile": 0.44012}, "CVE-2020-10518": {"epss_score": 0.03152, "epss_percentile": 0.86508}, "CVE-2020-10519": {"epss_score": 0.01898, "epss_percentile": 0.82762}, "CVE-2020-10531": {"epss_score": 0.0079, "epss_percentile": 0.73372}, "CVE-2020-10532": {"epss_score": 0.00317, "epss_percentile": 0.54379}, "CVE-2020-10534": {"epss_score": 0.00321, "epss_percentile": 0.54679}, "CVE-2020-10535": {"epss_score": 0.00164, "epss_percentile": 0.37875}, "CVE-2020-10537": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2020-10538": {"epss_score": 0.00027, "epss_percentile": 0.07093}, "CVE-2020-10539": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2020-10540": {"epss_score": 0.0021, "epss_percentile": 0.43452}, "CVE-2020-10541": {"epss_score": 0.02312, "epss_percentile": 0.84341}, "CVE-2020-10543": {"epss_score": 0.03944, "epss_percentile": 0.87991}, "CVE-2020-10544": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-10546": {"epss_score": 0.91387, "epss_percentile": 0.99638}, "CVE-2020-10547": {"epss_score": 0.89969, "epss_percentile": 0.99554}, "CVE-2020-10548": {"epss_score": 0.92752, "epss_percentile": 0.99743}, "CVE-2020-10549": {"epss_score": 0.92992, "epss_percentile": 0.99766}, "CVE-2020-10551": {"epss_score": 0.09598, "epss_percentile": 0.92615}, "CVE-2020-10552": {"epss_score": 0.00279, "epss_percentile": 0.50979}, "CVE-2020-10553": {"epss_score": 0.00043, "epss_percentile": 0.12972}, "CVE-2020-10554": {"epss_score": 0.00131, "epss_percentile": 0.33367}, "CVE-2020-10557": {"epss_score": 0.00146, "epss_percentile": 0.35575}, "CVE-2020-10558": {"epss_score": 0.28298, "epss_percentile": 0.9634}, "CVE-2020-10560": {"epss_score": 0.06058, "epss_percentile": 0.9044}, "CVE-2020-10561": {"epss_score": 0.01566, "epss_percentile": 0.81067}, "CVE-2020-10562": {"epss_score": 0.0053, "epss_percentile": 0.66642}, "CVE-2020-10563": {"epss_score": 0.005, "epss_percentile": 0.65328}, "CVE-2020-10564": {"epss_score": 0.31747, "epss_percentile": 0.96645}, "CVE-2020-10565": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2020-10566": {"epss_score": 0.00225, "epss_percentile": 0.45097}, "CVE-2020-10567": {"epss_score": 0.1787, "epss_percentile": 0.9492}, "CVE-2020-10568": {"epss_score": 0.02264, "epss_percentile": 0.84194}, "CVE-2020-10569": {"epss_score": 0.02051, "epss_percentile": 0.83401}, "CVE-2020-10570": {"epss_score": 0.00067, "epss_percentile": 0.21086}, "CVE-2020-10571": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2020-10573": {"epss_score": 0.00335, "epss_percentile": 0.55898}, "CVE-2020-10574": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2020-10575": {"epss_score": 0.00254, "epss_percentile": 0.48525}, "CVE-2020-10576": {"epss_score": 0.00335, "epss_percentile": 0.55898}, "CVE-2020-10577": {"epss_score": 0.00254, "epss_percentile": 0.48525}, "CVE-2020-10578": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2020-10579": {"epss_score": 0.00429, "epss_percentile": 0.61984}, "CVE-2020-10580": {"epss_score": 0.11232, "epss_percentile": 0.93272}, "CVE-2020-10581": {"epss_score": 0.00292, "epss_percentile": 0.52246}, "CVE-2020-10582": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2020-10583": {"epss_score": 0.02357, "epss_percentile": 0.84487}, "CVE-2020-10584": {"epss_score": 0.00429, "epss_percentile": 0.61984}, "CVE-2020-10587": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2020-10588": {"epss_score": 0.00113, "epss_percentile": 0.30698}, "CVE-2020-10589": {"epss_score": 0.00113, "epss_percentile": 0.30698}, "CVE-2020-10590": {"epss_score": 0.00348, "epss_percentile": 0.5682}, "CVE-2020-10591": {"epss_score": 0.00723, "epss_percentile": 0.72015}, "CVE-2020-10592": {"epss_score": 0.02, "epss_percentile": 0.83217}, "CVE-2020-10593": {"epss_score": 0.01218, "epss_percentile": 0.78609}, "CVE-2020-10594": {"epss_score": 0.00368, "epss_percentile": 0.58221}, "CVE-2020-10595": {"epss_score": 0.07295, "epss_percentile": 0.91389}, "CVE-2020-10596": {"epss_score": 0.01247, "epss_percentile": 0.78859}, "CVE-2020-10597": {"epss_score": 0.00156, "epss_percentile": 0.37003}, "CVE-2020-10598": {"epss_score": 0.00093, "epss_percentile": 0.26682}, "CVE-2020-10599": {"epss_score": 0.00332, "epss_percentile": 0.55551}, "CVE-2020-10600": {"epss_score": 0.00265, "epss_percentile": 0.49826}, "CVE-2020-10601": {"epss_score": 0.00015, "epss_percentile": 0.02416}, "CVE-2020-10602": {"epss_score": 0.00232, "epss_percentile": 0.45938}, "CVE-2020-10603": {"epss_score": 0.00386, "epss_percentile": 0.59264}, "CVE-2020-10604": {"epss_score": 0.00786, "epss_percentile": 0.73294}, "CVE-2020-10605": {"epss_score": 0.00326, "epss_percentile": 0.55077}, "CVE-2020-10606": {"epss_score": 0.00058, "epss_percentile": 0.18363}, "CVE-2020-10607": {"epss_score": 0.00793, "epss_percentile": 0.73421}, "CVE-2020-10608": {"epss_score": 0.00031, "epss_percentile": 0.08439}, "CVE-2020-10609": {"epss_score": 0.00132, "epss_percentile": 0.33579}, "CVE-2020-10610": {"epss_score": 0.00107, "epss_percentile": 0.29746}, "CVE-2020-10611": {"epss_score": 0.09013, "epss_percentile": 0.92364}, "CVE-2020-10612": {"epss_score": 0.00216, "epss_percentile": 0.44194}, "CVE-2020-10613": {"epss_score": 0.00697, "epss_percentile": 0.71414}, "CVE-2020-10614": {"epss_score": 0.00108, "epss_percentile": 0.2984}, "CVE-2020-10615": {"epss_score": 0.00766, "epss_percentile": 0.72935}, "CVE-2020-10616": {"epss_score": 0.00473, "epss_percentile": 0.64075}, "CVE-2020-10617": {"epss_score": 0.00282, "epss_percentile": 0.51215}, "CVE-2020-10618": {"epss_score": 0.00171, "epss_percentile": 0.38828}, "CVE-2020-10619": {"epss_score": 0.02006, "epss_percentile": 0.83235}, "CVE-2020-10620": {"epss_score": 0.0028, "epss_percentile": 0.51079}, "CVE-2020-10621": {"epss_score": 0.00216, "epss_percentile": 0.44221}, "CVE-2020-10622": {"epss_score": 0.00155, "epss_percentile": 0.36836}, "CVE-2020-10623": {"epss_score": 0.00144, "epss_percentile": 0.35328}, "CVE-2020-10624": {"epss_score": 0.00114, "epss_percentile": 0.30778}, "CVE-2020-10625": {"epss_score": 0.00248, "epss_percentile": 0.47939}, "CVE-2020-10626": {"epss_score": 0.00065, "epss_percentile": 0.20499}, "CVE-2020-10627": {"epss_score": 0.00085, "epss_percentile": 0.25157}, "CVE-2020-10628": {"epss_score": 0.00114, "epss_percentile": 0.30778}, "CVE-2020-10629": {"epss_score": 0.00162, "epss_percentile": 0.37647}, "CVE-2020-10630": {"epss_score": 0.00174, "epss_percentile": 0.39172}, "CVE-2020-10631": {"epss_score": 0.0026, "epss_percentile": 0.49231}, "CVE-2020-10632": {"epss_score": 0.0008, "epss_percentile": 0.2408}, "CVE-2020-10633": {"epss_score": 0.00308, "epss_percentile": 0.5364}, "CVE-2020-10634": {"epss_score": 0.00472, "epss_percentile": 0.64066}, "CVE-2020-10635": {"epss_score": 0.00076, "epss_percentile": 0.23259}, "CVE-2020-10636": {"epss_score": 0.00033, "epss_percentile": 0.09239}, "CVE-2020-10637": {"epss_score": 0.00144, "epss_percentile": 0.35329}, "CVE-2020-10638": {"epss_score": 0.26718, "epss_percentile": 0.96169}, "CVE-2020-10639": {"epss_score": 0.00183, "epss_percentile": 0.40305}, "CVE-2020-10640": {"epss_score": 0.00863, "epss_percentile": 0.74595}, "CVE-2020-10641": {"epss_score": 0.00251, "epss_percentile": 0.4831}, "CVE-2020-10642": {"epss_score": 5e-05, "epss_percentile": 0.00217}, "CVE-2020-10643": {"epss_score": 0.0013, "epss_percentile": 0.33238}, "CVE-2020-10644": {"epss_score": 0.20891, "epss_percentile": 0.95433}, "CVE-2020-10646": {"epss_score": 0.00183, "epss_percentile": 0.40305}, "CVE-2020-10648": {"epss_score": 0.00123, "epss_percentile": 0.32294}, "CVE-2020-10649": {"epss_score": 0.00281, "epss_percentile": 0.51184}, "CVE-2020-10650": {"epss_score": 0.08631, "epss_percentile": 0.92163}, "CVE-2020-10654": {"epss_score": 0.07479, "epss_percentile": 0.91495}, "CVE-2020-10655": {"epss_score": 0.06601, "epss_percentile": 0.90879}, "CVE-2020-10656": {"epss_score": 0.06601, "epss_percentile": 0.90879}, "CVE-2020-10657": {"epss_score": 0.04585, "epss_percentile": 0.88884}, "CVE-2020-10658": {"epss_score": 0.06601, "epss_percentile": 0.90879}, "CVE-2020-10659": {"epss_score": 0.00124, "epss_percentile": 0.32366}, "CVE-2020-10660": {"epss_score": 0.00229, "epss_percentile": 0.45648}, "CVE-2020-10661": {"epss_score": 0.00393, "epss_percentile": 0.59711}, "CVE-2020-10663": {"epss_score": 0.06536, "epss_percentile": 0.90829}, "CVE-2020-10664": {"epss_score": 0.0039, "epss_percentile": 0.59533}, "CVE-2020-10665": {"epss_score": 0.00605, "epss_percentile": 0.68996}, "CVE-2020-10666": {"epss_score": 0.01401, "epss_percentile": 0.80006}, "CVE-2020-10667": {"epss_score": 0.00496, "epss_percentile": 0.65138}, "CVE-2020-10668": {"epss_score": 0.00496, "epss_percentile": 0.65138}, "CVE-2020-10669": {"epss_score": 0.01246, "epss_percentile": 0.78855}, "CVE-2020-10670": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-10671": {"epss_score": 0.00182, "epss_percentile": 0.40246}, "CVE-2020-10672": {"epss_score": 0.35286, "epss_percentile": 0.96898}, "CVE-2020-10673": {"epss_score": 0.20473, "epss_percentile": 0.95351}, "CVE-2020-10674": {"epss_score": 0.00499, "epss_percentile": 0.65269}, "CVE-2020-10675": {"epss_score": 0.00275, "epss_percentile": 0.50627}, "CVE-2020-10676": {"epss_score": 0.00185, "epss_percentile": 0.40506}, "CVE-2020-10678": {"epss_score": 0.00768, "epss_percentile": 0.72979}, "CVE-2020-10681": {"epss_score": 0.00415, "epss_percentile": 0.61155}, "CVE-2020-10682": {"epss_score": 0.01856, "epss_percentile": 0.8257}, "CVE-2020-10683": {"epss_score": 0.07684, "epss_percentile": 0.91626}, "CVE-2020-10684": {"epss_score": 0.00022, "epss_percentile": 0.05216}, "CVE-2020-10685": {"epss_score": 0.00174, "epss_percentile": 0.39161}, "CVE-2020-10686": {"epss_score": 0.00238, "epss_percentile": 0.4676}, "CVE-2020-10687": {"epss_score": 0.0021, "epss_percentile": 0.43434}, "CVE-2020-10688": {"epss_score": 0.00222, "epss_percentile": 0.44771}, "CVE-2020-10689": {"epss_score": 0.00077, "epss_percentile": 0.23548}, "CVE-2020-10690": {"epss_score": 0.00126, "epss_percentile": 0.32737}, "CVE-2020-10691": {"epss_score": 0.00098, "epss_percentile": 0.27704}, "CVE-2020-10693": {"epss_score": 0.0007, "epss_percentile": 0.21658}, "CVE-2020-10695": {"epss_score": 0.00041, "epss_percentile": 0.12413}, "CVE-2020-10696": {"epss_score": 0.00793, "epss_percentile": 0.73429}, "CVE-2020-10697": {"epss_score": 0.0004, "epss_percentile": 0.12158}, "CVE-2020-10698": {"epss_score": 0.00041, "epss_percentile": 0.12282}, "CVE-2020-10699": {"epss_score": 0.00137, "epss_percentile": 0.3421}, "CVE-2020-10700": {"epss_score": 0.02857, "epss_percentile": 0.85845}, "CVE-2020-10701": {"epss_score": 0.0025, "epss_percentile": 0.48257}, "CVE-2020-10702": {"epss_score": 0.00036, "epss_percentile": 0.10307}, "CVE-2020-10703": {"epss_score": 0.00689, "epss_percentile": 0.71229}, "CVE-2020-10704": {"epss_score": 0.08934, "epss_percentile": 0.92326}, "CVE-2020-10705": {"epss_score": 0.00384, "epss_percentile": 0.59175}, "CVE-2020-10706": {"epss_score": 0.00015, "epss_percentile": 0.02479}, "CVE-2020-10709": {"epss_score": 0.00038, "epss_percentile": 0.11278}, "CVE-2020-10710": {"epss_score": 0.00047, "epss_percentile": 0.14795}, "CVE-2020-10711": {"epss_score": 0.05079, "epss_percentile": 0.8947}, "CVE-2020-10712": {"epss_score": 0.00189, "epss_percentile": 0.40943}, "CVE-2020-10713": {"epss_score": 0.00259, "epss_percentile": 0.49069}, "CVE-2020-10714": {"epss_score": 0.00366, "epss_percentile": 0.58048}, "CVE-2020-10715": {"epss_score": 0.00213, "epss_percentile": 0.4394}, "CVE-2020-10716": {"epss_score": 0.00156, "epss_percentile": 0.37015}, "CVE-2020-10717": {"epss_score": 0.00163, "epss_percentile": 0.37857}, "CVE-2020-10718": {"epss_score": 0.0027, "epss_percentile": 0.50228}, "CVE-2020-10719": {"epss_score": 0.00167, "epss_percentile": 0.38336}, "CVE-2020-10720": {"epss_score": 0.00129, "epss_percentile": 0.33163}, "CVE-2020-10721": {"epss_score": 0.00062, "epss_percentile": 0.19644}, "CVE-2020-10722": {"epss_score": 0.00125, "epss_percentile": 0.32497}, "CVE-2020-10723": {"epss_score": 0.00125, "epss_percentile": 0.32497}, "CVE-2020-10724": {"epss_score": 0.0008, "epss_percentile": 0.24197}, "CVE-2020-10725": {"epss_score": 0.00606, "epss_percentile": 0.69015}, "CVE-2020-10726": {"epss_score": 0.00112, "epss_percentile": 0.30443}, "CVE-2020-10727": {"epss_score": 0.00075, "epss_percentile": 0.23012}, "CVE-2020-10728": {"epss_score": 0.00034, "epss_percentile": 0.0978}, "CVE-2020-10729": {"epss_score": 0.00091, "epss_percentile": 0.26234}, "CVE-2020-10730": {"epss_score": 0.00966, "epss_percentile": 0.76061}, "CVE-2020-10731": {"epss_score": 0.00281, "epss_percentile": 0.51185}, "CVE-2020-10732": {"epss_score": 0.00047, "epss_percentile": 0.14646}, "CVE-2020-10733": {"epss_score": 0.00249, "epss_percentile": 0.48076}, "CVE-2020-10734": {"epss_score": 0.0002, "epss_percentile": 0.04442}, "CVE-2020-10735": {"epss_score": 0.00313, "epss_percentile": 0.54018}, "CVE-2020-10736": {"epss_score": 0.00068, "epss_percentile": 0.21345}, "CVE-2020-10737": {"epss_score": 0.00114, "epss_percentile": 0.30779}, "CVE-2020-10738": {"epss_score": 0.0234, "epss_percentile": 0.84433}, "CVE-2020-10739": {"epss_score": 0.00615, "epss_percentile": 0.69301}, "CVE-2020-10740": {"epss_score": 0.00373, "epss_percentile": 0.58469}, "CVE-2020-10742": {"epss_score": 0.00051, "epss_percentile": 0.16129}, "CVE-2020-10743": {"epss_score": 0.00134, "epss_percentile": 0.33752}, "CVE-2020-10744": {"epss_score": 0.00038, "epss_percentile": 0.11394}, "CVE-2020-10745": {"epss_score": 0.16334, "epss_percentile": 0.94631}, "CVE-2020-10746": {"epss_score": 0.00042, "epss_percentile": 0.1281}, "CVE-2020-10748": {"epss_score": 0.00271, "epss_percentile": 0.50296}, "CVE-2020-10749": {"epss_score": 0.03832, "epss_percentile": 0.87808}, "CVE-2020-10750": {"epss_score": 0.0006, "epss_percentile": 0.19072}, "CVE-2020-10751": {"epss_score": 0.00084, "epss_percentile": 0.2492}, "CVE-2020-10752": {"epss_score": 0.00299, "epss_percentile": 0.52865}, "CVE-2020-10753": {"epss_score": 0.00407, "epss_percentile": 0.60616}, "CVE-2020-10754": {"epss_score": 0.00252, "epss_percentile": 0.48356}, "CVE-2020-10755": {"epss_score": 0.00315, "epss_percentile": 0.54199}, "CVE-2020-10756": {"epss_score": 0.00025, "epss_percentile": 0.06146}, "CVE-2020-10757": {"epss_score": 0.00435, "epss_percentile": 0.62327}, "CVE-2020-10758": {"epss_score": 0.00529, "epss_percentile": 0.66602}, "CVE-2020-10759": {"epss_score": 7e-05, "epss_percentile": 0.00438}, "CVE-2020-10760": {"epss_score": 0.02545, "epss_percentile": 0.85061}, "CVE-2020-10761": {"epss_score": 0.00841, "epss_percentile": 0.74218}, "CVE-2020-10762": {"epss_score": 0.00081, "epss_percentile": 0.24283}, "CVE-2020-10763": {"epss_score": 0.00129, "epss_percentile": 0.33167}, "CVE-2020-10766": {"epss_score": 0.0004, "epss_percentile": 0.11984}, "CVE-2020-10767": {"epss_score": 0.00041, "epss_percentile": 0.12322}, "CVE-2020-10768": {"epss_score": 0.0003, "epss_percentile": 0.0816}, "CVE-2020-10769": {"epss_score": 0.00177, "epss_percentile": 0.39524}, "CVE-2020-10770": {"epss_score": 0.92282, "epss_percentile": 0.99705}, "CVE-2020-10771": {"epss_score": 0.00085, "epss_percentile": 0.25055}, "CVE-2020-10772": {"epss_score": 0.00303, "epss_percentile": 0.53181}, "CVE-2020-10773": {"epss_score": 0.00016, "epss_percentile": 0.02849}, "CVE-2020-10774": {"epss_score": 0.00038, "epss_percentile": 0.1127}, "CVE-2020-10775": {"epss_score": 0.0041, "epss_percentile": 0.60807}, "CVE-2020-10776": {"epss_score": 0.00271, "epss_percentile": 0.50312}, "CVE-2020-10777": {"epss_score": 0.00245, "epss_percentile": 0.4764}, "CVE-2020-10778": {"epss_score": 0.0036, "epss_percentile": 0.57653}, "CVE-2020-10779": {"epss_score": 0.0018, "epss_percentile": 0.39888}, "CVE-2020-10780": {"epss_score": 0.00401, "epss_percentile": 0.60202}, "CVE-2020-10781": {"epss_score": 0.00102, "epss_percentile": 0.28892}, "CVE-2020-10782": {"epss_score": 0.00037, "epss_percentile": 0.10997}, "CVE-2020-10783": {"epss_score": 0.00351, "epss_percentile": 0.57014}, "CVE-2020-10786": {"epss_score": 0.02424, "epss_percentile": 0.84714}, "CVE-2020-10787": {"epss_score": 0.00433, "epss_percentile": 0.62186}, "CVE-2020-10788": {"epss_score": 0.00257, "epss_percentile": 0.48877}, "CVE-2020-10789": {"epss_score": 0.00593, "epss_percentile": 0.68649}, "CVE-2020-10790": {"epss_score": 0.00379, "epss_percentile": 0.58905}, "CVE-2020-10791": {"epss_score": 0.00139, "epss_percentile": 0.34552}, "CVE-2020-10792": {"epss_score": 0.00464, "epss_percentile": 0.63718}, "CVE-2020-10793": {"epss_score": 0.00538, "epss_percentile": 0.66942}, "CVE-2020-10794": {"epss_score": 0.01354, "epss_percentile": 0.79703}, "CVE-2020-10795": {"epss_score": 0.04757, "epss_percentile": 0.89114}, "CVE-2020-10797": {"epss_score": 0.02605, "epss_percentile": 0.85218}, "CVE-2020-10799": {"epss_score": 0.00338, "epss_percentile": 0.56155}, "CVE-2020-10800": {"epss_score": 0.0041, "epss_percentile": 0.60798}, "CVE-2020-10802": {"epss_score": 0.01622, "epss_percentile": 0.81395}, "CVE-2020-10803": {"epss_score": 0.03554, "epss_percentile": 0.87346}, "CVE-2020-10804": {"epss_score": 0.02444, "epss_percentile": 0.84763}, "CVE-2020-10806": {"epss_score": 0.02833, "epss_percentile": 0.85779}, "CVE-2020-10807": {"epss_score": 0.00297, "epss_percentile": 0.52755}, "CVE-2020-10808": {"epss_score": 0.84554, "epss_percentile": 0.99295}, "CVE-2020-10809": {"epss_score": 0.00492, "epss_percentile": 0.64998}, "CVE-2020-10810": {"epss_score": 0.00383, "epss_percentile": 0.59119}, "CVE-2020-10811": {"epss_score": 0.00449, "epss_percentile": 0.63045}, "CVE-2020-10812": {"epss_score": 0.00127, "epss_percentile": 0.32783}, "CVE-2020-10813": {"epss_score": 0.00299, "epss_percentile": 0.52891}, "CVE-2020-10814": {"epss_score": 0.01683, "epss_percentile": 0.8174}, "CVE-2020-10816": {"epss_score": 0.2501, "epss_percentile": 0.95978}, "CVE-2020-10817": {"epss_score": 0.00666, "epss_percentile": 0.70695}, "CVE-2020-10818": {"epss_score": 0.07561, "epss_percentile": 0.91542}, "CVE-2020-10819": {"epss_score": 0.24173, "epss_percentile": 0.95883}, "CVE-2020-10820": {"epss_score": 0.04489, "epss_percentile": 0.88754}, "CVE-2020-10821": {"epss_score": 0.24173, "epss_percentile": 0.95883}, "CVE-2020-10823": {"epss_score": 0.09583, "epss_percentile": 0.92608}, "CVE-2020-10824": {"epss_score": 0.05519, "epss_percentile": 0.89956}, "CVE-2020-10825": {"epss_score": 0.05519, "epss_percentile": 0.89956}, "CVE-2020-10826": {"epss_score": 0.2996, "epss_percentile": 0.9649}, "CVE-2020-10827": {"epss_score": 0.13418, "epss_percentile": 0.93957}, "CVE-2020-10828": {"epss_score": 0.13418, "epss_percentile": 0.93957}, "CVE-2020-10829": {"epss_score": 0.00018, "epss_percentile": 0.03721}, "CVE-2020-10830": {"epss_score": 0.00018, "epss_percentile": 0.04025}, "CVE-2020-10831": {"epss_score": 0.00043, "epss_percentile": 0.13307}, "CVE-2020-10832": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2020-10833": {"epss_score": 0.00114, "epss_percentile": 0.30879}, "CVE-2020-10834": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2020-10835": {"epss_score": 0.00626, "epss_percentile": 0.69616}, "CVE-2020-10836": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-10837": {"epss_score": 0.00231, "epss_percentile": 0.45794}, "CVE-2020-10838": {"epss_score": 0.0002, "epss_percentile": 0.04498}, "CVE-2020-10839": {"epss_score": 0.00017, "epss_percentile": 0.03397}, "CVE-2020-10840": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2020-10841": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2020-10842": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2020-10843": {"epss_score": 0.00013, "epss_percentile": 0.01515}, "CVE-2020-10844": {"epss_score": 0.00105, "epss_percentile": 0.29324}, "CVE-2020-10845": {"epss_score": 0.00016, "epss_percentile": 0.02722}, "CVE-2020-10846": {"epss_score": 0.00018, "epss_percentile": 0.03828}, "CVE-2020-10847": {"epss_score": 0.00017, "epss_percentile": 0.03173}, "CVE-2020-10848": {"epss_score": 0.0017, "epss_percentile": 0.38684}, "CVE-2020-10849": {"epss_score": 0.00117, "epss_percentile": 0.31311}, "CVE-2020-10850": {"epss_score": 0.00231, "epss_percentile": 0.45794}, "CVE-2020-10851": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2020-10852": {"epss_score": 0.0005, "epss_percentile": 0.15684}, "CVE-2020-10853": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2020-10854": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2020-10855": {"epss_score": 0.00019, "epss_percentile": 0.04156}, "CVE-2020-10857": {"epss_score": 0.02608, "epss_percentile": 0.8523}, "CVE-2020-10858": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2020-10859": {"epss_score": 0.04316, "epss_percentile": 0.88537}, "CVE-2020-10860": {"epss_score": 0.00642, "epss_percentile": 0.70019}, "CVE-2020-10861": {"epss_score": 0.00425, "epss_percentile": 0.61687}, "CVE-2020-10862": {"epss_score": 0.00143, "epss_percentile": 0.35094}, "CVE-2020-10863": {"epss_score": 0.00642, "epss_percentile": 0.70019}, "CVE-2020-10864": {"epss_score": 0.00456, "epss_percentile": 0.63347}, "CVE-2020-10865": {"epss_score": 0.00379, "epss_percentile": 0.58846}, "CVE-2020-10866": {"epss_score": 0.00196, "epss_percentile": 0.41802}, "CVE-2020-10867": {"epss_score": 0.00396, "epss_percentile": 0.59926}, "CVE-2020-10868": {"epss_score": 0.00379, "epss_percentile": 0.58846}, "CVE-2020-10870": {"epss_score": 0.00131, "epss_percentile": 0.33395}, "CVE-2020-10871": {"epss_score": 0.00853, "epss_percentile": 0.74436}, "CVE-2020-10874": {"epss_score": 0.00339, "epss_percentile": 0.56177}, "CVE-2020-10875": {"epss_score": 0.00565, "epss_percentile": 0.67787}, "CVE-2020-10876": {"epss_score": 0.00206, "epss_percentile": 0.42918}, "CVE-2020-10878": {"epss_score": 0.00107, "epss_percentile": 0.29736}, "CVE-2020-10879": {"epss_score": 0.86178, "epss_percentile": 0.99371}, "CVE-2020-10881": {"epss_score": 0.48408, "epss_percentile": 0.97635}, "CVE-2020-10882": {"epss_score": 0.45816, "epss_percentile": 0.97503}, "CVE-2020-10883": {"epss_score": 0.02605, "epss_percentile": 0.85218}, "CVE-2020-10884": {"epss_score": 0.29001, "epss_percentile": 0.96409}, "CVE-2020-10885": {"epss_score": 0.02757, "epss_percentile": 0.85594}, "CVE-2020-10886": {"epss_score": 0.0629, "epss_percentile": 0.90647}, "CVE-2020-10887": {"epss_score": 0.004, "epss_percentile": 0.60153}, "CVE-2020-10888": {"epss_score": 0.00223, "epss_percentile": 0.44898}, "CVE-2020-10889": {"epss_score": 0.00374, "epss_percentile": 0.58577}, "CVE-2020-10890": {"epss_score": 0.01624, "epss_percentile": 0.81415}, "CVE-2020-10891": {"epss_score": 0.00374, "epss_percentile": 0.58577}, "CVE-2020-10892": {"epss_score": 0.01624, "epss_percentile": 0.81415}, "CVE-2020-10893": {"epss_score": 0.0284, "epss_percentile": 0.85802}, "CVE-2020-10894": {"epss_score": 0.11393, "epss_percentile": 0.93332}, "CVE-2020-10895": {"epss_score": 0.0284, "epss_percentile": 0.85802}, "CVE-2020-10896": {"epss_score": 0.0284, "epss_percentile": 0.85802}, "CVE-2020-10897": {"epss_score": 0.0284, "epss_percentile": 0.85802}, "CVE-2020-10898": {"epss_score": 0.0284, "epss_percentile": 0.85802}, "CVE-2020-10899": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2020-10900": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2020-10901": {"epss_score": 0.11393, "epss_percentile": 0.93332}, "CVE-2020-10902": {"epss_score": 0.0284, "epss_percentile": 0.85802}, "CVE-2020-10903": {"epss_score": 0.11393, "epss_percentile": 0.93332}, "CVE-2020-10904": {"epss_score": 0.0284, "epss_percentile": 0.85802}, "CVE-2020-10905": {"epss_score": 0.11393, "epss_percentile": 0.93332}, "CVE-2020-10906": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2020-10907": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2020-10908": {"epss_score": 0.00374, "epss_percentile": 0.58577}, "CVE-2020-10909": {"epss_score": 0.00374, "epss_percentile": 0.58577}, "CVE-2020-10910": {"epss_score": 0.00374, "epss_percentile": 0.58577}, "CVE-2020-10911": {"epss_score": 0.00374, "epss_percentile": 0.58577}, "CVE-2020-10912": {"epss_score": 0.00374, "epss_percentile": 0.58577}, "CVE-2020-10913": {"epss_score": 0.0079, "epss_percentile": 0.73375}, "CVE-2020-10914": {"epss_score": 0.79592, "epss_percentile": 0.99046}, "CVE-2020-10915": {"epss_score": 0.83865, "epss_percentile": 0.99263}, "CVE-2020-10916": {"epss_score": 0.0083, "epss_percentile": 0.74023}, "CVE-2020-10917": {"epss_score": 0.30524, "epss_percentile": 0.96548}, "CVE-2020-10918": {"epss_score": 0.04791, "epss_percentile": 0.89149}, "CVE-2020-10919": {"epss_score": 0.01041, "epss_percentile": 0.76963}, "CVE-2020-10920": {"epss_score": 0.21554, "epss_percentile": 0.95532}, "CVE-2020-10921": {"epss_score": 0.09469, "epss_percentile": 0.92561}, "CVE-2020-10922": {"epss_score": 0.06752, "epss_percentile": 0.91002}, "CVE-2020-10923": {"epss_score": 0.34136, "epss_percentile": 0.96827}, "CVE-2020-10924": {"epss_score": 0.45282, "epss_percentile": 0.9748}, "CVE-2020-10925": {"epss_score": 0.00102, "epss_percentile": 0.28878}, "CVE-2020-10926": {"epss_score": 0.00064, "epss_percentile": 0.20152}, "CVE-2020-10927": {"epss_score": 0.00052, "epss_percentile": 0.16523}, "CVE-2020-10928": {"epss_score": 0.00169, "epss_percentile": 0.38629}, "CVE-2020-10929": {"epss_score": 0.00214, "epss_percentile": 0.43964}, "CVE-2020-10930": {"epss_score": 0.00332, "epss_percentile": 0.55587}, "CVE-2020-10931": {"epss_score": 0.17285, "epss_percentile": 0.94816}, "CVE-2020-10932": {"epss_score": 0.00047, "epss_percentile": 0.14856}, "CVE-2020-10933": {"epss_score": 0.00377, "epss_percentile": 0.5875}, "CVE-2020-10934": {"epss_score": 0.00539, "epss_percentile": 0.66966}, "CVE-2020-10935": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2020-10936": {"epss_score": 0.00105, "epss_percentile": 0.29307}, "CVE-2020-10937": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2020-10938": {"epss_score": 0.01678, "epss_percentile": 0.81719}, "CVE-2020-10939": {"epss_score": 0.00086, "epss_percentile": 0.25279}, "CVE-2020-10940": {"epss_score": 0.00113, "epss_percentile": 0.30698}, "CVE-2020-10941": {"epss_score": 0.00705, "epss_percentile": 0.71584}, "CVE-2020-10942": {"epss_score": 0.00073, "epss_percentile": 0.22675}, "CVE-2020-10944": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-10945": {"epss_score": 0.00042, "epss_percentile": 0.1267}, "CVE-2020-10946": {"epss_score": 0.00088, "epss_percentile": 0.2576}, "CVE-2020-10947": {"epss_score": 0.00221, "epss_percentile": 0.44653}, "CVE-2020-10948": {"epss_score": 0.18069, "epss_percentile": 0.94952}, "CVE-2020-10951": {"epss_score": 0.00247, "epss_percentile": 0.4787}, "CVE-2020-10952": {"epss_score": 0.00073, "epss_percentile": 0.22531}, "CVE-2020-10953": {"epss_score": 0.00102, "epss_percentile": 0.28802}, "CVE-2020-10954": {"epss_score": 0.00141, "epss_percentile": 0.34932}, "CVE-2020-10955": {"epss_score": 0.00179, "epss_percentile": 0.39845}, "CVE-2020-10956": {"epss_score": 0.00136, "epss_percentile": 0.34195}, "CVE-2020-10957": {"epss_score": 0.10653, "epss_percentile": 0.93059}, "CVE-2020-10958": {"epss_score": 0.01052, "epss_percentile": 0.77095}, "CVE-2020-10959": {"epss_score": 0.00273, "epss_percentile": 0.50436}, "CVE-2020-10960": {"epss_score": 0.00209, "epss_percentile": 0.43397}, "CVE-2020-10962": {"epss_score": 0.00041, "epss_percentile": 0.12426}, "CVE-2020-10963": {"epss_score": 0.27747, "epss_percentile": 0.96279}, "CVE-2020-10964": {"epss_score": 0.03798, "epss_percentile": 0.8774}, "CVE-2020-10965": {"epss_score": 0.01656, "epss_percentile": 0.81597}, "CVE-2020-10966": {"epss_score": 0.00505, "epss_percentile": 0.65603}, "CVE-2020-10967": {"epss_score": 0.02643, "epss_percentile": 0.85317}, "CVE-2020-10968": {"epss_score": 0.04028, "epss_percentile": 0.88147}, "CVE-2020-10969": {"epss_score": 0.01401, "epss_percentile": 0.80007}, "CVE-2020-10971": {"epss_score": 0.00482, "epss_percentile": 0.64533}, "CVE-2020-10972": {"epss_score": 0.00305, "epss_percentile": 0.5332}, "CVE-2020-10973": {"epss_score": 0.37103, "epss_percentile": 0.97019}, "CVE-2020-10974": {"epss_score": 0.0034, "epss_percentile": 0.56227}, "CVE-2020-10975": {"epss_score": 0.00069, "epss_percentile": 0.21506}, "CVE-2020-10976": {"epss_score": 0.00077, "epss_percentile": 0.23384}, "CVE-2020-10977": {"epss_score": 0.05872, "epss_percentile": 0.90279}, "CVE-2020-10978": {"epss_score": 0.00112, "epss_percentile": 0.30411}, "CVE-2020-10979": {"epss_score": 0.00069, "epss_percentile": 0.21506}, "CVE-2020-10980": {"epss_score": 0.00154, "epss_percentile": 0.36664}, "CVE-2020-10981": {"epss_score": 0.00075, "epss_percentile": 0.2303}, "CVE-2020-10982": {"epss_score": 0.00384, "epss_percentile": 0.59133}, "CVE-2020-10983": {"epss_score": 0.00384, "epss_percentile": 0.59133}, "CVE-2020-10984": {"epss_score": 0.00539, "epss_percentile": 0.66961}, "CVE-2020-10985": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-10986": {"epss_score": 0.00167, "epss_percentile": 0.38272}, "CVE-2020-10987": {"epss_score": 0.93625, "epss_percentile": 0.99825}, "CVE-2020-10988": {"epss_score": 0.06405, "epss_percentile": 0.90731}, "CVE-2020-10989": {"epss_score": 0.00317, "epss_percentile": 0.5439}, "CVE-2020-10990": {"epss_score": 0.0035, "epss_percentile": 0.56975}, "CVE-2020-10991": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2020-10992": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2020-10993": {"epss_score": 0.00417, "epss_percentile": 0.61257}, "CVE-2020-10994": {"epss_score": 0.00443, "epss_percentile": 0.62767}, "CVE-2020-10995": {"epss_score": 0.00091, "epss_percentile": 0.26207}, "CVE-2020-10996": {"epss_score": 0.00573, "epss_percentile": 0.68044}, "CVE-2020-10997": {"epss_score": 0.00284, "epss_percentile": 0.51486}, "CVE-2020-11000": {"epss_score": 0.00256, "epss_percentile": 0.48776}, "CVE-2020-11001": {"epss_score": 0.00406, "epss_percentile": 0.60557}, "CVE-2020-11002": {"epss_score": 0.01256, "epss_percentile": 0.78934}, "CVE-2020-11003": {"epss_score": 0.00138, "epss_percentile": 0.34424}, "CVE-2020-11004": {"epss_score": 0.00287, "epss_percentile": 0.51861}, "CVE-2020-11005": {"epss_score": 0.00019, "epss_percentile": 0.04335}, "CVE-2020-11006": {"epss_score": 0.00267, "epss_percentile": 0.50013}, "CVE-2020-11007": {"epss_score": 0.00296, "epss_percentile": 0.52555}, "CVE-2020-11008": {"epss_score": 0.01523, "epss_percentile": 0.8084}, "CVE-2020-11009": {"epss_score": 0.00498, "epss_percentile": 0.65244}, "CVE-2020-11010": {"epss_score": 0.00245, "epss_percentile": 0.47643}, "CVE-2020-11011": {"epss_score": 0.00899, "epss_percentile": 0.75158}, "CVE-2020-11012": {"epss_score": 0.00192, "epss_percentile": 0.41332}, "CVE-2020-11013": {"epss_score": 0.00273, "epss_percentile": 0.50467}, "CVE-2020-11014": {"epss_score": 0.00292, "epss_percentile": 0.52253}, "CVE-2020-11015": {"epss_score": 0.00244, "epss_percentile": 0.47526}, "CVE-2020-11016": {"epss_score": 0.01367, "epss_percentile": 0.79783}, "CVE-2020-11017": {"epss_score": 0.00234, "epss_percentile": 0.46087}, "CVE-2020-11018": {"epss_score": 0.00222, "epss_percentile": 0.44808}, "CVE-2020-11019": {"epss_score": 0.00376, "epss_percentile": 0.58641}, "CVE-2020-11020": {"epss_score": 0.00365, "epss_percentile": 0.57962}, "CVE-2020-11021": {"epss_score": 0.00434, "epss_percentile": 0.62283}, "CVE-2020-11022": {"epss_score": 0.18632, "epss_percentile": 0.95046}, "CVE-2020-11023": {"epss_score": 0.32295, "epss_percentile": 0.96687}, "CVE-2020-11024": {"epss_score": 0.00219, "epss_percentile": 0.44522}, "CVE-2020-11025": {"epss_score": 0.01403, "epss_percentile": 0.80028}, "CVE-2020-11026": {"epss_score": 0.0441, "epss_percentile": 0.88658}, "CVE-2020-11027": {"epss_score": 0.42551, "epss_percentile": 0.97338}, "CVE-2020-11028": {"epss_score": 0.00932, "epss_percentile": 0.75628}, "CVE-2020-11029": {"epss_score": 0.02605, "epss_percentile": 0.85221}, "CVE-2020-11030": {"epss_score": 0.01037, "epss_percentile": 0.76926}, "CVE-2020-11031": {"epss_score": 0.00055, "epss_percentile": 0.17459}, "CVE-2020-11032": {"epss_score": 0.00311, "epss_percentile": 0.53865}, "CVE-2020-11033": {"epss_score": 0.00446, "epss_percentile": 0.62911}, "CVE-2020-11034": {"epss_score": 0.55796, "epss_percentile": 0.97996}, "CVE-2020-11035": {"epss_score": 0.00244, "epss_percentile": 0.47594}, "CVE-2020-11036": {"epss_score": 0.00789, "epss_percentile": 0.73348}, "CVE-2020-11037": {"epss_score": 0.00052, "epss_percentile": 0.16595}, "CVE-2020-11038": {"epss_score": 0.00184, "epss_percentile": 0.40394}, "CVE-2020-11039": {"epss_score": 0.0017, "epss_percentile": 0.38673}, "CVE-2020-11040": {"epss_score": 0.00117, "epss_percentile": 0.31288}, "CVE-2020-11041": {"epss_score": 0.00173, "epss_percentile": 0.3909}, "CVE-2020-11042": {"epss_score": 0.00125, "epss_percentile": 0.32474}, "CVE-2020-11043": {"epss_score": 0.00134, "epss_percentile": 0.33926}, "CVE-2020-11044": {"epss_score": 0.00124, "epss_percentile": 0.32381}, "CVE-2020-11045": {"epss_score": 0.00168, "epss_percentile": 0.38464}, "CVE-2020-11046": {"epss_score": 0.00124, "epss_percentile": 0.32365}, "CVE-2020-11047": {"epss_score": 0.00099, "epss_percentile": 0.28365}, "CVE-2020-11048": {"epss_score": 0.00124, "epss_percentile": 0.32418}, "CVE-2020-11049": {"epss_score": 0.00183, "epss_percentile": 0.4029}, "CVE-2020-11050": {"epss_score": 0.00191, "epss_percentile": 0.41268}, "CVE-2020-11051": {"epss_score": 0.00323, "epss_percentile": 0.54877}, "CVE-2020-11052": {"epss_score": 0.00532, "epss_percentile": 0.66684}, "CVE-2020-11053": {"epss_score": 0.0023, "epss_percentile": 0.45682}, "CVE-2020-11054": {"epss_score": 0.0065, "epss_percentile": 0.70248}, "CVE-2020-11055": {"epss_score": 0.00391, "epss_percentile": 0.59626}, "CVE-2020-11056": {"epss_score": 0.00557, "epss_percentile": 0.67554}, "CVE-2020-11057": {"epss_score": 0.01753, "epss_percentile": 0.82113}, "CVE-2020-11058": {"epss_score": 0.00124, "epss_percentile": 0.32418}, "CVE-2020-11059": {"epss_score": 0.00373, "epss_percentile": 0.58469}, "CVE-2020-11060": {"epss_score": 0.07013, "epss_percentile": 0.91186}, "CVE-2020-11061": {"epss_score": 0.00913, "epss_percentile": 0.7537}, "CVE-2020-11062": {"epss_score": 0.00195, "epss_percentile": 0.41625}, "CVE-2020-11063": {"epss_score": 0.00292, "epss_percentile": 0.52227}, "CVE-2020-11064": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-11065": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-11066": {"epss_score": 0.00528, "epss_percentile": 0.66551}, "CVE-2020-11067": {"epss_score": 0.01181, "epss_percentile": 0.78306}, "CVE-2020-11068": {"epss_score": 0.00426, "epss_percentile": 0.61759}, "CVE-2020-11069": {"epss_score": 0.00398, "epss_percentile": 0.6008}, "CVE-2020-11070": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-11071": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-11072": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-11073": {"epss_score": 0.00264, "epss_percentile": 0.49577}, "CVE-2020-11074": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-11075": {"epss_score": 0.01061, "epss_percentile": 0.77171}, "CVE-2020-11076": {"epss_score": 0.01782, "epss_percentile": 0.82244}, "CVE-2020-11077": {"epss_score": 0.00821, "epss_percentile": 0.73894}, "CVE-2020-11078": {"epss_score": 0.03194, "epss_percentile": 0.86606}, "CVE-2020-11079": {"epss_score": 0.05686, "epss_percentile": 0.90119}, "CVE-2020-11080": {"epss_score": 0.00683, "epss_percentile": 0.71088}, "CVE-2020-11081": {"epss_score": 0.00052, "epss_percentile": 0.16349}, "CVE-2020-11082": {"epss_score": 0.00452, "epss_percentile": 0.63191}, "CVE-2020-11083": {"epss_score": 0.00432, "epss_percentile": 0.62159}, "CVE-2020-11084": {"epss_score": 0.01102, "epss_percentile": 0.77589}, "CVE-2020-11085": {"epss_score": 0.00119, "epss_percentile": 0.31641}, "CVE-2020-11086": {"epss_score": 0.0019, "epss_percentile": 0.41116}, "CVE-2020-11087": {"epss_score": 0.0019, "epss_percentile": 0.41116}, "CVE-2020-11088": {"epss_score": 0.00207, "epss_percentile": 0.43113}, "CVE-2020-11089": {"epss_score": 0.00249, "epss_percentile": 0.4803}, "CVE-2020-11090": {"epss_score": 0.00408, "epss_percentile": 0.60647}, "CVE-2020-11091": {"epss_score": 0.00166, "epss_percentile": 0.38249}, "CVE-2020-11093": {"epss_score": 0.00162, "epss_percentile": 0.37694}, "CVE-2020-11094": {"epss_score": 0.00548, "epss_percentile": 0.67273}, "CVE-2020-11095": {"epss_score": 0.00264, "epss_percentile": 0.49582}, "CVE-2020-11096": {"epss_score": 0.00212, "epss_percentile": 0.43725}, "CVE-2020-11097": {"epss_score": 0.00134, "epss_percentile": 0.33921}, "CVE-2020-11098": {"epss_score": 0.00171, "epss_percentile": 0.38792}, "CVE-2020-11099": {"epss_score": 0.00178, "epss_percentile": 0.39634}, "CVE-2020-11100": {"epss_score": 0.75554, "epss_percentile": 0.98853}, "CVE-2020-11101": {"epss_score": 0.00077, "epss_percentile": 0.23325}, "CVE-2020-11102": {"epss_score": 0.00401, "epss_percentile": 0.60214}, "CVE-2020-11103": {"epss_score": 0.01322, "epss_percentile": 0.79448}, "CVE-2020-11104": {"epss_score": 0.00323, "epss_percentile": 0.54865}, "CVE-2020-11105": {"epss_score": 0.0052, "epss_percentile": 0.66212}, "CVE-2020-11106": {"epss_score": 0.00471, "epss_percentile": 0.64022}, "CVE-2020-11107": {"epss_score": 0.33303, "epss_percentile": 0.96762}, "CVE-2020-11108": {"epss_score": 0.8959, "epss_percentile": 0.99533}, "CVE-2020-11110": {"epss_score": 0.72691, "epss_percentile": 0.98723}, "CVE-2020-11111": {"epss_score": 0.02196, "epss_percentile": 0.83954}, "CVE-2020-11112": {"epss_score": 0.06772, "epss_percentile": 0.91016}, "CVE-2020-11113": {"epss_score": 0.60714, "epss_percentile": 0.98217}, "CVE-2020-11114": {"epss_score": 0.00078, "epss_percentile": 0.23567}, "CVE-2020-11115": {"epss_score": 0.0024, "epss_percentile": 0.46949}, "CVE-2020-11116": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-11117": {"epss_score": 0.03589, "epss_percentile": 0.87398}, "CVE-2020-11118": {"epss_score": 0.0024, "epss_percentile": 0.46949}, "CVE-2020-11119": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2020-11120": {"epss_score": 0.00044, "epss_percentile": 0.13562}, "CVE-2020-11121": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2020-11122": {"epss_score": 0.00143, "epss_percentile": 0.35221}, "CVE-2020-11123": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2020-11124": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2020-11125": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-11126": {"epss_score": 0.00286, "epss_percentile": 0.5172}, "CVE-2020-11127": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2020-11128": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11129": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2020-11130": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2020-11131": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2020-11132": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-11133": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-11134": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-11135": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2020-11136": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-11137": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-11138": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-11139": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2020-11140": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-11141": {"epss_score": 0.00073, "epss_percentile": 0.22616}, "CVE-2020-11143": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-11144": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2020-11145": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2020-11146": {"epss_score": 0.00051, "epss_percentile": 0.16247}, "CVE-2020-11147": {"epss_score": 0.00048, "epss_percentile": 0.15198}, "CVE-2020-11148": {"epss_score": 0.0004, "epss_percentile": 0.12115}, "CVE-2020-11149": {"epss_score": 0.00036, "epss_percentile": 0.10385}, "CVE-2020-11150": {"epss_score": 0.00036, "epss_percentile": 0.10385}, "CVE-2020-11151": {"epss_score": 0.00031, "epss_percentile": 0.0864}, "CVE-2020-11152": {"epss_score": 0.00028, "epss_percentile": 0.07346}, "CVE-2020-11153": {"epss_score": 0.03827, "epss_percentile": 0.87794}, "CVE-2020-11154": {"epss_score": 0.00186, "epss_percentile": 0.40608}, "CVE-2020-11155": {"epss_score": 0.00186, "epss_percentile": 0.40608}, "CVE-2020-11156": {"epss_score": 0.00145, "epss_percentile": 0.35409}, "CVE-2020-11157": {"epss_score": 0.00157, "epss_percentile": 0.37108}, "CVE-2020-11158": {"epss_score": 0.00246, "epss_percentile": 0.47772}, "CVE-2020-11159": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2020-11160": {"epss_score": 0.00047, "epss_percentile": 0.14627}, "CVE-2020-11161": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-11162": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2020-11163": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2020-11164": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-11165": {"epss_score": 0.00041, "epss_percentile": 0.12356}, "CVE-2020-11166": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2020-11167": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-11168": {"epss_score": 0.00283, "epss_percentile": 0.51396}, "CVE-2020-11169": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2020-11170": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-11171": {"epss_score": 0.0037, "epss_percentile": 0.58306}, "CVE-2020-11172": {"epss_score": 0.00309, "epss_percentile": 0.53673}, "CVE-2020-11173": {"epss_score": 0.00033, "epss_percentile": 0.09339}, "CVE-2020-11174": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-11175": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2020-11176": {"epss_score": 0.00223, "epss_percentile": 0.44964}, "CVE-2020-11177": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11178": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11179": {"epss_score": 0.02099, "epss_percentile": 0.83593}, "CVE-2020-11180": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11181": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11182": {"epss_score": 0.00427, "epss_percentile": 0.61873}, "CVE-2020-11183": {"epss_score": 0.00038, "epss_percentile": 0.11317}, "CVE-2020-11184": {"epss_score": 0.00427, "epss_percentile": 0.61873}, "CVE-2020-11185": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11186": {"epss_score": 0.00044, "epss_percentile": 0.13513}, "CVE-2020-11187": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2020-11188": {"epss_score": 0.0037, "epss_percentile": 0.58306}, "CVE-2020-11189": {"epss_score": 0.0037, "epss_percentile": 0.58306}, "CVE-2020-11190": {"epss_score": 0.0037, "epss_percentile": 0.58306}, "CVE-2020-11191": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2020-11192": {"epss_score": 0.00396, "epss_percentile": 0.59859}, "CVE-2020-11193": {"epss_score": 0.00396, "epss_percentile": 0.59859}, "CVE-2020-11194": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11195": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11196": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2020-11197": {"epss_score": 0.0037, "epss_percentile": 0.58306}, "CVE-2020-11198": {"epss_score": 0.00021, "epss_percentile": 0.04816}, "CVE-2020-11199": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2020-11200": {"epss_score": 0.00335, "epss_percentile": 0.55866}, "CVE-2020-11201": {"epss_score": 0.00052, "epss_percentile": 0.16403}, "CVE-2020-11202": {"epss_score": 0.0006, "epss_percentile": 0.19035}, "CVE-2020-11203": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2020-11204": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2020-11205": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2020-11206": {"epss_score": 0.0006, "epss_percentile": 0.19035}, "CVE-2020-11207": {"epss_score": 0.0006, "epss_percentile": 0.19035}, "CVE-2020-11208": {"epss_score": 0.00052, "epss_percentile": 0.16403}, "CVE-2020-11209": {"epss_score": 0.00065, "epss_percentile": 0.20516}, "CVE-2020-11210": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2020-11212": {"epss_score": 0.00272, "epss_percentile": 0.50387}, "CVE-2020-11213": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2020-11214": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2020-11215": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2020-11216": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2020-11217": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-11218": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2020-11220": {"epss_score": 0.00036, "epss_percentile": 0.10494}, "CVE-2020-11221": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2020-11222": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2020-11223": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11225": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-11226": {"epss_score": 0.0024, "epss_percentile": 0.46949}, "CVE-2020-11227": {"epss_score": 0.0037, "epss_percentile": 0.58306}, "CVE-2020-11228": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-11230": {"epss_score": 0.00043, "epss_percentile": 0.12998}, "CVE-2020-11231": {"epss_score": 0.00047, "epss_percentile": 0.14627}, "CVE-2020-11233": {"epss_score": 0.00026, "epss_percentile": 0.06412}, "CVE-2020-11234": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2020-11235": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2020-11236": {"epss_score": 0.00167, "epss_percentile": 0.38317}, "CVE-2020-11237": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11238": {"epss_score": 0.00317, "epss_percentile": 0.54338}, "CVE-2020-11239": {"epss_score": 0.00063, "epss_percentile": 0.1998}, "CVE-2020-11240": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2020-11241": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2020-11242": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11243": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2020-11245": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11246": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11247": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2020-11250": {"epss_score": 0.00029, "epss_percentile": 0.07611}, "CVE-2020-11251": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2020-11252": {"epss_score": 0.00043, "epss_percentile": 0.13082}, "CVE-2020-11253": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11254": {"epss_score": 0.00052, "epss_percentile": 0.16404}, "CVE-2020-11255": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2020-11256": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2020-11257": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2020-11258": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2020-11259": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2020-11260": {"epss_score": 0.00036, "epss_percentile": 0.10381}, "CVE-2020-11261": {"epss_score": 0.01197, "epss_percentile": 0.78447}, "CVE-2020-11262": {"epss_score": 0.00034, "epss_percentile": 0.09712}, "CVE-2020-11263": {"epss_score": 0.00112, "epss_percentile": 0.30438}, "CVE-2020-11264": {"epss_score": 0.00263, "epss_percentile": 0.49488}, "CVE-2020-11265": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2020-11266": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2020-11267": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-11268": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2020-11269": {"epss_score": 0.00074, "epss_percentile": 0.22718}, "CVE-2020-11270": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2020-11271": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11272": {"epss_score": 0.00388, "epss_percentile": 0.5934}, "CVE-2020-11273": {"epss_score": 0.00246, "epss_percentile": 0.47772}, "CVE-2020-11274": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2020-11275": {"epss_score": 0.00286, "epss_percentile": 0.5172}, "CVE-2020-11276": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2020-11277": {"epss_score": 0.00027, "epss_percentile": 0.06898}, "CVE-2020-11278": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2020-11279": {"epss_score": 0.00322, "epss_percentile": 0.54789}, "CVE-2020-11280": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2020-11281": {"epss_score": 0.0024, "epss_percentile": 0.46949}, "CVE-2020-11282": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-11283": {"epss_score": 0.00309, "epss_percentile": 0.53673}, "CVE-2020-11284": {"epss_score": 0.00026, "epss_percentile": 0.06412}, "CVE-2020-11285": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2020-11286": {"epss_score": 0.00045, "epss_percentile": 0.13919}, "CVE-2020-11287": {"epss_score": 0.00268, "epss_percentile": 0.50039}, "CVE-2020-11288": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11289": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-11290": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2020-11291": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2020-11292": {"epss_score": 0.00048, "epss_percentile": 0.15057}, "CVE-2020-11293": {"epss_score": 0.00047, "epss_percentile": 0.14627}, "CVE-2020-11294": {"epss_score": 0.00041, "epss_percentile": 0.12272}, "CVE-2020-11295": {"epss_score": 0.00044, "epss_percentile": 0.13562}, "CVE-2020-11296": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2020-11297": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2020-11298": {"epss_score": 0.00019, "epss_percentile": 0.04395}, "CVE-2020-11299": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2020-11301": {"epss_score": 0.02348, "epss_percentile": 0.84456}, "CVE-2020-11303": {"epss_score": 0.0024, "epss_percentile": 0.46949}, "CVE-2020-11304": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-11305": {"epss_score": 0.00045, "epss_percentile": 0.13919}, "CVE-2020-11306": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-11307": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2020-11308": {"epss_score": 0.00037, "epss_percentile": 0.10736}, "CVE-2020-11309": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2020-11414": {"epss_score": 0.00423, "epss_percentile": 0.61585}, "CVE-2020-11415": {"epss_score": 0.0032, "epss_percentile": 0.54616}, "CVE-2020-11416": {"epss_score": 7e-05, "epss_percentile": 0.004}, "CVE-2020-11420": {"epss_score": 0.00586, "epss_percentile": 0.68456}, "CVE-2020-11431": {"epss_score": 0.01743, "epss_percentile": 0.82057}, "CVE-2020-11436": {"epss_score": 0.00737, "epss_percentile": 0.7233}, "CVE-2020-11437": {"epss_score": 0.00378, "epss_percentile": 0.58791}, "CVE-2020-11438": {"epss_score": 0.002, "epss_percentile": 0.42244}, "CVE-2020-11439": {"epss_score": 0.00757, "epss_percentile": 0.72761}, "CVE-2020-11440": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-11441": {"epss_score": 0.00653, "epss_percentile": 0.70334}, "CVE-2020-11443": {"epss_score": 0.00443, "epss_percentile": 0.62797}, "CVE-2020-11444": {"epss_score": 0.58746, "epss_percentile": 0.98135}, "CVE-2020-11445": {"epss_score": 0.00223, "epss_percentile": 0.44869}, "CVE-2020-11446": {"epss_score": 0.00066, "epss_percentile": 0.20735}, "CVE-2020-11447": {"epss_score": 0.00066, "epss_percentile": 0.20853}, "CVE-2020-11448": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2020-11449": {"epss_score": 0.0036, "epss_percentile": 0.57649}, "CVE-2020-11450": {"epss_score": 0.86821, "epss_percentile": 0.99399}, "CVE-2020-11451": {"epss_score": 0.00644, "epss_percentile": 0.70091}, "CVE-2020-11452": {"epss_score": 0.00297, "epss_percentile": 0.52714}, "CVE-2020-11453": {"epss_score": 0.01564, "epss_percentile": 0.81059}, "CVE-2020-11454": {"epss_score": 0.00504, "epss_percentile": 0.65528}, "CVE-2020-11455": {"epss_score": 0.93403, "epss_percentile": 0.99803}, "CVE-2020-11456": {"epss_score": 0.00284, "epss_percentile": 0.51445}, "CVE-2020-11457": {"epss_score": 0.03815, "epss_percentile": 0.87767}, "CVE-2020-11458": {"epss_score": 0.00407, "epss_percentile": 0.6061}, "CVE-2020-11462": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-11463": {"epss_score": 0.00425, "epss_percentile": 0.61693}, "CVE-2020-11464": {"epss_score": 0.0033, "epss_percentile": 0.55435}, "CVE-2020-11465": {"epss_score": 0.00531, "epss_percentile": 0.66661}, "CVE-2020-11466": {"epss_score": 0.00353, "epss_percentile": 0.57152}, "CVE-2020-11467": {"epss_score": 0.03989, "epss_percentile": 0.88068}, "CVE-2020-11469": {"epss_score": 0.00139, "epss_percentile": 0.34557}, "CVE-2020-11470": {"epss_score": 0.00071, "epss_percentile": 0.22116}, "CVE-2020-11474": {"epss_score": 0.00185, "epss_percentile": 0.40569}, "CVE-2020-11476": {"epss_score": 0.0102, "epss_percentile": 0.76738}, "CVE-2020-11483": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2020-11484": {"epss_score": 0.00336, "epss_percentile": 0.55986}, "CVE-2020-11485": {"epss_score": 0.00276, "epss_percentile": 0.50763}, "CVE-2020-11486": {"epss_score": 0.02126, "epss_percentile": 0.83694}, "CVE-2020-11487": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2020-11488": {"epss_score": 0.00045, "epss_percentile": 0.13736}, "CVE-2020-11489": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-11490": {"epss_score": 0.01338, "epss_percentile": 0.79568}, "CVE-2020-11491": {"epss_score": 0.65467, "epss_percentile": 0.9842}, "CVE-2020-11492": {"epss_score": 0.01809, "epss_percentile": 0.82358}, "CVE-2020-11493": {"epss_score": 0.00075, "epss_percentile": 0.23027}, "CVE-2020-11494": {"epss_score": 0.00071, "epss_percentile": 0.22028}, "CVE-2020-11496": {"epss_score": 0.00129, "epss_percentile": 0.33116}, "CVE-2020-11497": {"epss_score": 0.00097, "epss_percentile": 0.27512}, "CVE-2020-11498": {"epss_score": 0.00313, "epss_percentile": 0.54024}, "CVE-2020-11499": {"epss_score": 0.00249, "epss_percentile": 0.48061}, "CVE-2020-11500": {"epss_score": 0.00135, "epss_percentile": 0.33975}, "CVE-2020-11501": {"epss_score": 0.11487, "epss_percentile": 0.93382}, "CVE-2020-11503": {"epss_score": 0.00291, "epss_percentile": 0.52151}, "CVE-2020-11505": {"epss_score": 0.00067, "epss_percentile": 0.21029}, "CVE-2020-11506": {"epss_score": 0.00067, "epss_percentile": 0.21029}, "CVE-2020-11507": {"epss_score": 0.0014, "epss_percentile": 0.348}, "CVE-2020-11508": {"epss_score": 0.00174, "epss_percentile": 0.39162}, "CVE-2020-11509": {"epss_score": 0.0152, "epss_percentile": 0.80826}, "CVE-2020-11511": {"epss_score": 0.02816, "epss_percentile": 0.85735}, "CVE-2020-11512": {"epss_score": 0.00252, "epss_percentile": 0.48414}, "CVE-2020-11514": {"epss_score": 0.56628, "epss_percentile": 0.98031}, "CVE-2020-11515": {"epss_score": 0.00857, "epss_percentile": 0.74496}, "CVE-2020-11516": {"epss_score": 0.00343, "epss_percentile": 0.56447}, "CVE-2020-11518": {"epss_score": 0.10352, "epss_percentile": 0.92955}, "CVE-2020-11519": {"epss_score": 0.0109, "epss_percentile": 0.77448}, "CVE-2020-11520": {"epss_score": 0.00115, "epss_percentile": 0.30979}, "CVE-2020-11521": {"epss_score": 0.0139, "epss_percentile": 0.79947}, "CVE-2020-11522": {"epss_score": 0.01047, "epss_percentile": 0.77037}, "CVE-2020-11523": {"epss_score": 0.0139, "epss_percentile": 0.79947}, "CVE-2020-11524": {"epss_score": 0.00636, "epss_percentile": 0.69863}, "CVE-2020-11525": {"epss_score": 0.02215, "epss_percentile": 0.84029}, "CVE-2020-11526": {"epss_score": 0.00243, "epss_percentile": 0.47487}, "CVE-2020-11527": {"epss_score": 0.13621, "epss_percentile": 0.94016}, "CVE-2020-11528": {"epss_score": 0.00489, "epss_percentile": 0.64876}, "CVE-2020-11529": {"epss_score": 0.70199, "epss_percentile": 0.98622}, "CVE-2020-11530": {"epss_score": 0.93134, "epss_percentile": 0.99778}, "CVE-2020-11531": {"epss_score": 0.08226, "epss_percentile": 0.91939}, "CVE-2020-11532": {"epss_score": 0.89079, "epss_percentile": 0.99508}, "CVE-2020-11533": {"epss_score": 0.00235, "epss_percentile": 0.46206}, "CVE-2020-11534": {"epss_score": 0.00646, "epss_percentile": 0.7013}, "CVE-2020-11535": {"epss_score": 0.00646, "epss_percentile": 0.7013}, "CVE-2020-11536": {"epss_score": 0.00545, "epss_percentile": 0.67174}, "CVE-2020-11537": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2020-11538": {"epss_score": 0.0043, "epss_percentile": 0.62032}, "CVE-2020-11539": {"epss_score": 0.01337, "epss_percentile": 0.79559}, "CVE-2020-11541": {"epss_score": 0.00087, "epss_percentile": 0.25497}, "CVE-2020-11542": {"epss_score": 0.00064, "epss_percentile": 0.20329}, "CVE-2020-11543": {"epss_score": 0.00529, "epss_percentile": 0.66587}, "CVE-2020-11544": {"epss_score": 0.00435, "epss_percentile": 0.62368}, "CVE-2020-11545": {"epss_score": 0.00117, "epss_percentile": 0.31337}, "CVE-2020-11546": {"epss_score": 0.93122, "epss_percentile": 0.99776}, "CVE-2020-11547": {"epss_score": 0.87328, "epss_percentile": 0.99423}, "CVE-2020-11548": {"epss_score": 0.10725, "epss_percentile": 0.93084}, "CVE-2020-11549": {"epss_score": 0.00747, "epss_percentile": 0.72554}, "CVE-2020-11550": {"epss_score": 0.00168, "epss_percentile": 0.38416}, "CVE-2020-11551": {"epss_score": 0.00297, "epss_percentile": 0.52712}, "CVE-2020-11552": {"epss_score": 0.05317, "epss_percentile": 0.89723}, "CVE-2020-11553": {"epss_score": 0.00177, "epss_percentile": 0.39553}, "CVE-2020-11554": {"epss_score": 0.00528, "epss_percentile": 0.66571}, "CVE-2020-11555": {"epss_score": 0.00542, "epss_percentile": 0.67071}, "CVE-2020-11556": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-11557": {"epss_score": 0.00168, "epss_percentile": 0.38461}, "CVE-2020-11558": {"epss_score": 0.00418, "epss_percentile": 0.61288}, "CVE-2020-11560": {"epss_score": 0.02043, "epss_percentile": 0.83379}, "CVE-2020-11561": {"epss_score": 0.00381, "epss_percentile": 0.58991}, "CVE-2020-11565": {"epss_score": 0.00083, "epss_percentile": 0.24718}, "CVE-2020-11576": {"epss_score": 0.00247, "epss_percentile": 0.47889}, "CVE-2020-11579": {"epss_score": 0.36683, "epss_percentile": 0.96995}, "CVE-2020-11580": {"epss_score": 0.00248, "epss_percentile": 0.4797}, "CVE-2020-11581": {"epss_score": 0.39323, "epss_percentile": 0.97154}, "CVE-2020-11582": {"epss_score": 0.00135, "epss_percentile": 0.33999}, "CVE-2020-11583": {"epss_score": 0.01874, "epss_percentile": 0.82652}, "CVE-2020-11584": {"epss_score": 0.01226, "epss_percentile": 0.78692}, "CVE-2020-11585": {"epss_score": 0.0024, "epss_percentile": 0.46971}, "CVE-2020-11586": {"epss_score": 0.01914, "epss_percentile": 0.82851}, "CVE-2020-11587": {"epss_score": 0.00967, "epss_percentile": 0.76075}, "CVE-2020-11588": {"epss_score": 0.0088, "epss_percentile": 0.7486}, "CVE-2020-11589": {"epss_score": 0.00923, "epss_percentile": 0.75507}, "CVE-2020-11590": {"epss_score": 0.00649, "epss_percentile": 0.70243}, "CVE-2020-11591": {"epss_score": 0.0088, "epss_percentile": 0.7486}, "CVE-2020-11592": {"epss_score": 0.00967, "epss_percentile": 0.76075}, "CVE-2020-11593": {"epss_score": 0.01114, "epss_percentile": 0.77695}, "CVE-2020-11594": {"epss_score": 0.00714, "epss_percentile": 0.71815}, "CVE-2020-11595": {"epss_score": 0.00967, "epss_percentile": 0.76075}, "CVE-2020-11596": {"epss_score": 0.01898, "epss_percentile": 0.82763}, "CVE-2020-11597": {"epss_score": 0.02424, "epss_percentile": 0.84712}, "CVE-2020-11598": {"epss_score": 0.03189, "epss_percentile": 0.86593}, "CVE-2020-11599": {"epss_score": 0.0036, "epss_percentile": 0.57649}, "CVE-2020-11600": {"epss_score": 0.00154, "epss_percentile": 0.36739}, "CVE-2020-11601": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2020-11602": {"epss_score": 0.00018, "epss_percentile": 0.04025}, "CVE-2020-11603": {"epss_score": 0.00222, "epss_percentile": 0.44799}, "CVE-2020-11604": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-11605": {"epss_score": 0.00153, "epss_percentile": 0.36528}, "CVE-2020-11606": {"epss_score": 0.00029, "epss_percentile": 0.07904}, "CVE-2020-11607": {"epss_score": 0.00132, "epss_percentile": 0.33591}, "CVE-2020-11608": {"epss_score": 0.00062, "epss_percentile": 0.19572}, "CVE-2020-11609": {"epss_score": 0.00052, "epss_percentile": 0.16363}, "CVE-2020-11610": {"epss_score": 0.00227, "epss_percentile": 0.45428}, "CVE-2020-11611": {"epss_score": 0.00257, "epss_percentile": 0.48911}, "CVE-2020-11612": {"epss_score": 0.04678, "epss_percentile": 0.88998}, "CVE-2020-11613": {"epss_score": 0.00058, "epss_percentile": 0.18274}, "CVE-2020-11614": {"epss_score": 0.00077, "epss_percentile": 0.23411}, "CVE-2020-11615": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2020-11616": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-11617": {"epss_score": 0.00161, "epss_percentile": 0.3754}, "CVE-2020-11618": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2020-11619": {"epss_score": 0.01731, "epss_percentile": 0.81992}, "CVE-2020-11620": {"epss_score": 0.02124, "epss_percentile": 0.83688}, "CVE-2020-11622": {"epss_score": 0.00345, "epss_percentile": 0.56593}, "CVE-2020-11623": {"epss_score": 0.00049, "epss_percentile": 0.15329}, "CVE-2020-11624": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2020-11625": {"epss_score": 0.00471, "epss_percentile": 0.64007}, "CVE-2020-11626": {"epss_score": 0.00226, "epss_percentile": 0.45333}, "CVE-2020-11627": {"epss_score": 0.0021, "epss_percentile": 0.43452}, "CVE-2020-11628": {"epss_score": 0.00151, "epss_percentile": 0.36263}, "CVE-2020-11629": {"epss_score": 0.00223, "epss_percentile": 0.44872}, "CVE-2020-11630": {"epss_score": 0.00899, "epss_percentile": 0.75153}, "CVE-2020-11631": {"epss_score": 0.00555, "epss_percentile": 0.67475}, "CVE-2020-11632": {"epss_score": 0.00072, "epss_percentile": 0.22295}, "CVE-2020-11633": {"epss_score": 0.01073, "epss_percentile": 0.77292}, "CVE-2020-11634": {"epss_score": 0.00064, "epss_percentile": 0.20389}, "CVE-2020-11635": {"epss_score": 0.00116, "epss_percentile": 0.3119}, "CVE-2020-11637": {"epss_score": 0.0029, "epss_percentile": 0.521}, "CVE-2020-11639": {"epss_score": 0.00141, "epss_percentile": 0.34902}, "CVE-2020-11640": {"epss_score": 0.0046, "epss_percentile": 0.63527}, "CVE-2020-11641": {"epss_score": 0.00224, "epss_percentile": 0.45038}, "CVE-2020-11642": {"epss_score": 0.00308, "epss_percentile": 0.53578}, "CVE-2020-11643": {"epss_score": 0.00252, "epss_percentile": 0.48382}, "CVE-2020-11644": {"epss_score": 0.00226, "epss_percentile": 0.45361}, "CVE-2020-11645": {"epss_score": 0.00193, "epss_percentile": 0.4143}, "CVE-2020-11646": {"epss_score": 0.00142, "epss_percentile": 0.34967}, "CVE-2020-11647": {"epss_score": 0.01672, "epss_percentile": 0.81683}, "CVE-2020-11649": {"epss_score": 0.00067, "epss_percentile": 0.21044}, "CVE-2020-11650": {"epss_score": 0.11916, "epss_percentile": 0.93516}, "CVE-2020-11651": {"epss_score": 0.94421, "epss_percentile": 0.99978}, "CVE-2020-11652": {"epss_score": 0.94265, "epss_percentile": 0.9993}, "CVE-2020-11653": {"epss_score": 0.0126, "epss_percentile": 0.78968}, "CVE-2020-11655": {"epss_score": 0.0489, "epss_percentile": 0.89259}, "CVE-2020-11656": {"epss_score": 0.0847, "epss_percentile": 0.9207}, "CVE-2020-11658": {"epss_score": 0.00243, "epss_percentile": 0.475}, "CVE-2020-11659": {"epss_score": 0.00198, "epss_percentile": 0.41992}, "CVE-2020-11660": {"epss_score": 0.00363, "epss_percentile": 0.57828}, "CVE-2020-11661": {"epss_score": 0.0034, "epss_percentile": 0.56277}, "CVE-2020-11662": {"epss_score": 0.00754, "epss_percentile": 0.72703}, "CVE-2020-11663": {"epss_score": 0.00259, "epss_percentile": 0.49081}, "CVE-2020-11664": {"epss_score": 0.00259, "epss_percentile": 0.49081}, "CVE-2020-11665": {"epss_score": 0.00261, "epss_percentile": 0.49265}, "CVE-2020-11666": {"epss_score": 0.00936, "epss_percentile": 0.75686}, "CVE-2020-11668": {"epss_score": 0.00047, "epss_percentile": 0.1462}, "CVE-2020-11669": {"epss_score": 0.0008, "epss_percentile": 0.2411}, "CVE-2020-11671": {"epss_score": 0.003, "epss_percentile": 0.52983}, "CVE-2020-11673": {"epss_score": 0.05536, "epss_percentile": 0.89972}, "CVE-2020-11674": {"epss_score": 0.00213, "epss_percentile": 0.43924}, "CVE-2020-11675": {"epss_score": 0.00259, "epss_percentile": 0.49062}, "CVE-2020-11676": {"epss_score": 0.00259, "epss_percentile": 0.49062}, "CVE-2020-11677": {"epss_score": 0.00259, "epss_percentile": 0.49062}, "CVE-2020-11679": {"epss_score": 0.00186, "epss_percentile": 0.40604}, "CVE-2020-11680": {"epss_score": 0.00188, "epss_percentile": 0.40848}, "CVE-2020-11681": {"epss_score": 0.00258, "epss_percentile": 0.48982}, "CVE-2020-11682": {"epss_score": 0.00168, "epss_percentile": 0.38453}, "CVE-2020-11683": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2020-11684": {"epss_score": 0.00172, "epss_percentile": 0.3896}, "CVE-2020-11685": {"epss_score": 2e-05, "epss_percentile": 0.00041}, "CVE-2020-11686": {"epss_score": 3e-05, "epss_percentile": 0.00117}, "CVE-2020-11687": {"epss_score": 4e-05, "epss_percentile": 0.00151}, "CVE-2020-11688": {"epss_score": 5e-05, "epss_percentile": 0.00194}, "CVE-2020-11689": {"epss_score": 2e-05, "epss_percentile": 0.0005}, "CVE-2020-11690": {"epss_score": 5e-05, "epss_percentile": 0.00215}, "CVE-2020-11691": {"epss_score": 3e-05, "epss_percentile": 0.00101}, "CVE-2020-11692": {"epss_score": 3e-05, "epss_percentile": 0.00108}, "CVE-2020-11693": {"epss_score": 5e-05, "epss_percentile": 0.00182}, "CVE-2020-11694": {"epss_score": 2e-05, "epss_percentile": 0.00041}, "CVE-2020-11696": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-11697": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-11698": {"epss_score": 0.83123, "epss_percentile": 0.99232}, "CVE-2020-11699": {"epss_score": 0.16879, "epss_percentile": 0.9474}, "CVE-2020-11700": {"epss_score": 0.12111, "epss_percentile": 0.93569}, "CVE-2020-11701": {"epss_score": 0.00216, "epss_percentile": 0.44196}, "CVE-2020-11702": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2020-11703": {"epss_score": 0.00441, "epss_percentile": 0.62688}, "CVE-2020-11704": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2020-11705": {"epss_score": 0.00328, "epss_percentile": 0.55167}, "CVE-2020-11706": {"epss_score": 0.00216, "epss_percentile": 0.44196}, "CVE-2020-11707": {"epss_score": 0.00359, "epss_percentile": 0.57543}, "CVE-2020-11708": {"epss_score": 0.0042, "epss_percentile": 0.6141}, "CVE-2020-11709": {"epss_score": 0.00163, "epss_percentile": 0.37812}, "CVE-2020-11710": {"epss_score": 0.94027, "epss_percentile": 0.99888}, "CVE-2020-11711": {"epss_score": 0.00355, "epss_percentile": 0.573}, "CVE-2020-11712": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2020-11713": {"epss_score": 0.00394, "epss_percentile": 0.59751}, "CVE-2020-11714": {"epss_score": 0.00305, "epss_percentile": 0.53318}, "CVE-2020-11715": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2020-11716": {"epss_score": 0.00308, "epss_percentile": 0.53642}, "CVE-2020-11717": {"epss_score": 0.01786, "epss_percentile": 0.82258}, "CVE-2020-11718": {"epss_score": 0.00231, "epss_percentile": 0.45837}, "CVE-2020-11719": {"epss_score": 0.00272, "epss_percentile": 0.50379}, "CVE-2020-11720": {"epss_score": 0.00656, "epss_percentile": 0.70438}, "CVE-2020-11721": {"epss_score": 0.00468, "epss_percentile": 0.63891}, "CVE-2020-11722": {"epss_score": 0.03645, "epss_percentile": 0.87498}, "CVE-2020-11723": {"epss_score": 0.00111, "epss_percentile": 0.3024}, "CVE-2020-11724": {"epss_score": 0.01068, "epss_percentile": 0.77242}, "CVE-2020-11725": {"epss_score": 0.00126, "epss_percentile": 0.32687}, "CVE-2020-11727": {"epss_score": 0.00484, "epss_percentile": 0.64635}, "CVE-2020-11728": {"epss_score": 0.0045, "epss_percentile": 0.63065}, "CVE-2020-11729": {"epss_score": 0.00472, "epss_percentile": 0.6404}, "CVE-2020-11731": {"epss_score": 0.00431, "epss_percentile": 0.62054}, "CVE-2020-11732": {"epss_score": 0.3478, "epss_percentile": 0.96873}, "CVE-2020-11733": {"epss_score": 0.00177, "epss_percentile": 0.39589}, "CVE-2020-11734": {"epss_score": 0.00528, "epss_percentile": 0.66542}, "CVE-2020-11735": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2020-11736": {"epss_score": 0.0006, "epss_percentile": 0.18981}, "CVE-2020-11737": {"epss_score": 0.02052, "epss_percentile": 0.83413}, "CVE-2020-11738": {"epss_score": 0.94233, "epss_percentile": 0.99922}, "CVE-2020-11739": {"epss_score": 0.00087, "epss_percentile": 0.2562}, "CVE-2020-11740": {"epss_score": 0.00108, "epss_percentile": 0.29874}, "CVE-2020-11741": {"epss_score": 0.00113, "epss_percentile": 0.30661}, "CVE-2020-11742": {"epss_score": 0.00091, "epss_percentile": 0.26385}, "CVE-2020-11743": {"epss_score": 0.00094, "epss_percentile": 0.27076}, "CVE-2020-11749": {"epss_score": 0.05582, "epss_percentile": 0.9002}, "CVE-2020-11753": {"epss_score": 0.01245, "epss_percentile": 0.78843}, "CVE-2020-11758": {"epss_score": 0.00642, "epss_percentile": 0.70024}, "CVE-2020-11759": {"epss_score": 0.01059, "epss_percentile": 0.77149}, "CVE-2020-11760": {"epss_score": 0.00642, "epss_percentile": 0.70024}, "CVE-2020-11761": {"epss_score": 0.00576, "epss_percentile": 0.68139}, "CVE-2020-11762": {"epss_score": 0.00576, "epss_percentile": 0.68139}, "CVE-2020-11763": {"epss_score": 0.00576, "epss_percentile": 0.68139}, "CVE-2020-11764": {"epss_score": 0.00781, "epss_percentile": 0.73193}, "CVE-2020-11765": {"epss_score": 0.00576, "epss_percentile": 0.68139}, "CVE-2020-11766": {"epss_score": 0.0428, "epss_percentile": 0.88488}, "CVE-2020-11767": {"epss_score": 0.00087, "epss_percentile": 0.25565}, "CVE-2020-11768": {"epss_score": 0.00253, "epss_percentile": 0.4847}, "CVE-2020-11769": {"epss_score": 0.00253, "epss_percentile": 0.4847}, "CVE-2020-11770": {"epss_score": 0.01072, "epss_percentile": 0.77283}, "CVE-2020-11771": {"epss_score": 0.00426, "epss_percentile": 0.61761}, "CVE-2020-11772": {"epss_score": 0.00253, "epss_percentile": 0.4847}, "CVE-2020-11773": {"epss_score": 0.00213, "epss_percentile": 0.43904}, "CVE-2020-11774": {"epss_score": 0.00426, "epss_percentile": 0.61761}, "CVE-2020-11775": {"epss_score": 0.00426, "epss_percentile": 0.61761}, "CVE-2020-11776": {"epss_score": 0.00426, "epss_percentile": 0.61761}, "CVE-2020-11777": {"epss_score": 0.00376, "epss_percentile": 0.5867}, "CVE-2020-11778": {"epss_score": 0.00376, "epss_percentile": 0.5867}, "CVE-2020-11779": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2020-11780": {"epss_score": 0.00359, "epss_percentile": 0.57602}, "CVE-2020-11781": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2020-11782": {"epss_score": 0.00359, "epss_percentile": 0.57602}, "CVE-2020-11783": {"epss_score": 0.00359, "epss_percentile": 0.57602}, "CVE-2020-11784": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2020-11785": {"epss_score": 0.00344, "epss_percentile": 0.56482}, "CVE-2020-11786": {"epss_score": 0.00359, "epss_percentile": 0.57602}, "CVE-2020-11787": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2020-11788": {"epss_score": 0.00088, "epss_percentile": 0.2564}, "CVE-2020-11789": {"epss_score": 0.03584, "epss_percentile": 0.87389}, "CVE-2020-11790": {"epss_score": 0.05983, "epss_percentile": 0.90381}, "CVE-2020-11791": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2020-11792": {"epss_score": 0.00184, "epss_percentile": 0.40402}, "CVE-2020-11793": {"epss_score": 0.00816, "epss_percentile": 0.73834}, "CVE-2020-11795": {"epss_score": 3e-05, "epss_percentile": 0.00072}, "CVE-2020-11796": {"epss_score": 4e-05, "epss_percentile": 0.00146}, "CVE-2020-11797": {"epss_score": 0.00508, "epss_percentile": 0.65713}, "CVE-2020-11798": {"epss_score": 0.85152, "epss_percentile": 0.99322}, "CVE-2020-11799": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2020-11800": {"epss_score": 0.47881, "epss_percentile": 0.97606}, "CVE-2020-11803": {"epss_score": 0.05012, "epss_percentile": 0.89392}, "CVE-2020-11804": {"epss_score": 0.05736, "epss_percentile": 0.90165}, "CVE-2020-11805": {"epss_score": 0.00442, "epss_percentile": 0.62751}, "CVE-2020-11806": {"epss_score": 0.00148, "epss_percentile": 0.35914}, "CVE-2020-11807": {"epss_score": 0.0007, "epss_percentile": 0.21952}, "CVE-2020-11810": {"epss_score": 0.02372, "epss_percentile": 0.8453}, "CVE-2020-11811": {"epss_score": 0.00938, "epss_percentile": 0.75703}, "CVE-2020-11812": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2020-11813": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-11814": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2020-11815": {"epss_score": 0.00878, "epss_percentile": 0.74818}, "CVE-2020-11816": {"epss_score": 0.00642, "epss_percentile": 0.70039}, "CVE-2020-11817": {"epss_score": 0.00873, "epss_percentile": 0.7474}, "CVE-2020-11818": {"epss_score": 0.00053, "epss_percentile": 0.16705}, "CVE-2020-11819": {"epss_score": 0.27004, "epss_percentile": 0.96198}, "CVE-2020-11820": {"epss_score": 0.00642, "epss_percentile": 0.70039}, "CVE-2020-11821": {"epss_score": 0.00674, "epss_percentile": 0.70875}, "CVE-2020-11822": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2020-11823": {"epss_score": 0.00313, "epss_percentile": 0.54028}, "CVE-2020-11825": {"epss_score": 0.00197, "epss_percentile": 0.41862}, "CVE-2020-11826": {"epss_score": 0.00098, "epss_percentile": 0.27806}, "CVE-2020-11827": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2020-11828": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-11829": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2020-11830": {"epss_score": 0.00442, "epss_percentile": 0.62751}, "CVE-2020-11831": {"epss_score": 0.00358, "epss_percentile": 0.57529}, "CVE-2020-11832": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-11833": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-11834": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-11835": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-11836": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2020-11838": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-11839": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-11840": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2020-11841": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2020-11842": {"epss_score": 0.00685, "epss_percentile": 0.71152}, "CVE-2020-11843": {"epss_score": 0.00377, "epss_percentile": 0.58693}, "CVE-2020-11844": {"epss_score": 0.01028, "epss_percentile": 0.76824}, "CVE-2020-11845": {"epss_score": 0.00213, "epss_percentile": 0.43926}, "CVE-2020-11846": {"epss_score": 0.00153, "epss_percentile": 0.36522}, "CVE-2020-11847": {"epss_score": 0.00128, "epss_percentile": 0.33067}, "CVE-2020-11848": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-11849": {"epss_score": 0.00517, "epss_percentile": 0.66071}, "CVE-2020-11850": {"epss_score": 0.00132, "epss_percentile": 0.33606}, "CVE-2020-11851": {"epss_score": 0.03885, "epss_percentile": 0.87903}, "CVE-2020-11852": {"epss_score": 0.00423, "epss_percentile": 0.61595}, "CVE-2020-11853": {"epss_score": 0.92549, "epss_percentile": 0.99726}, "CVE-2020-11854": {"epss_score": 0.92403, "epss_percentile": 0.99713}, "CVE-2020-11855": {"epss_score": 0.03019, "epss_percentile": 0.86221}, "CVE-2020-11856": {"epss_score": 0.03533, "epss_percentile": 0.87307}, "CVE-2020-11857": {"epss_score": 0.6319, "epss_percentile": 0.98323}, "CVE-2020-11858": {"epss_score": 0.01754, "epss_percentile": 0.82118}, "CVE-2020-11859": {"epss_score": 0.00149, "epss_percentile": 0.3598}, "CVE-2020-11860": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-11861": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2020-11862": {"epss_score": 0.00169, "epss_percentile": 0.38615}, "CVE-2020-11863": {"epss_score": 0.00437, "epss_percentile": 0.62524}, "CVE-2020-11864": {"epss_score": 0.00437, "epss_percentile": 0.62524}, "CVE-2020-11865": {"epss_score": 0.0041, "epss_percentile": 0.60818}, "CVE-2020-11866": {"epss_score": 0.0041, "epss_percentile": 0.60818}, "CVE-2020-11867": {"epss_score": 0.00051, "epss_percentile": 0.16136}, "CVE-2020-11868": {"epss_score": 0.01301, "epss_percentile": 0.79293}, "CVE-2020-11869": {"epss_score": 0.00093, "epss_percentile": 0.26612}, "CVE-2020-11872": {"epss_score": 0.00092, "epss_percentile": 0.26593}, "CVE-2020-11873": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2020-11874": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2020-11875": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2020-11876": {"epss_score": 0.00166, "epss_percentile": 0.38181}, "CVE-2020-11877": {"epss_score": 0.00289, "epss_percentile": 0.51997}, "CVE-2020-11878": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2020-11879": {"epss_score": 0.00538, "epss_percentile": 0.66958}, "CVE-2020-11880": {"epss_score": 0.00366, "epss_percentile": 0.58059}, "CVE-2020-11881": {"epss_score": 0.21166, "epss_percentile": 0.95471}, "CVE-2020-11882": {"epss_score": 0.00139, "epss_percentile": 0.34654}, "CVE-2020-11883": {"epss_score": 0.02734, "epss_percentile": 0.85549}, "CVE-2020-11884": {"epss_score": 0.0004, "epss_percentile": 0.12189}, "CVE-2020-11885": {"epss_score": 0.00394, "epss_percentile": 0.59757}, "CVE-2020-11886": {"epss_score": 0.00243, "epss_percentile": 0.47506}, "CVE-2020-11887": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-11888": {"epss_score": 0.0065, "epss_percentile": 0.70248}, "CVE-2020-11889": {"epss_score": 9e-05, "epss_percentile": 0.00653}, "CVE-2020-11890": {"epss_score": 0.00271, "epss_percentile": 0.50288}, "CVE-2020-11891": {"epss_score": 9e-05, "epss_percentile": 0.00653}, "CVE-2020-11894": {"epss_score": 0.00454, "epss_percentile": 0.63249}, "CVE-2020-11895": {"epss_score": 0.00454, "epss_percentile": 0.63249}, "CVE-2020-11896": {"epss_score": 0.39369, "epss_percentile": 0.97157}, "CVE-2020-11897": {"epss_score": 0.01631, "epss_percentile": 0.81453}, "CVE-2020-11898": {"epss_score": 0.70613, "epss_percentile": 0.98638}, "CVE-2020-11899": {"epss_score": 0.3325, "epss_percentile": 0.96757}, "CVE-2020-11900": {"epss_score": 0.07587, "epss_percentile": 0.91556}, "CVE-2020-11901": {"epss_score": 0.3559, "epss_percentile": 0.96921}, "CVE-2020-11902": {"epss_score": 0.05056, "epss_percentile": 0.89448}, "CVE-2020-11903": {"epss_score": 0.00713, "epss_percentile": 0.71782}, "CVE-2020-11904": {"epss_score": 0.03445, "epss_percentile": 0.87146}, "CVE-2020-11905": {"epss_score": 0.00574, "epss_percentile": 0.68093}, "CVE-2020-11906": {"epss_score": 0.00802, "epss_percentile": 0.73593}, "CVE-2020-11907": {"epss_score": 0.01087, "epss_percentile": 0.7743}, "CVE-2020-11908": {"epss_score": 0.00562, "epss_percentile": 0.67688}, "CVE-2020-11909": {"epss_score": 0.02433, "epss_percentile": 0.84732}, "CVE-2020-11910": {"epss_score": 0.04483, "epss_percentile": 0.88745}, "CVE-2020-11911": {"epss_score": 0.02944, "epss_percentile": 0.86037}, "CVE-2020-11912": {"epss_score": 0.01543, "epss_percentile": 0.80957}, "CVE-2020-11913": {"epss_score": 0.03177, "epss_percentile": 0.86572}, "CVE-2020-11914": {"epss_score": 0.0051, "epss_percentile": 0.65766}, "CVE-2020-11915": {"epss_score": 0.00293, "epss_percentile": 0.52309}, "CVE-2020-11916": {"epss_score": 0.00022, "epss_percentile": 0.05239}, "CVE-2020-11917": {"epss_score": 0.00051, "epss_percentile": 0.16151}, "CVE-2020-11918": {"epss_score": 0.00023, "epss_percentile": 0.05371}, "CVE-2020-11919": {"epss_score": 0.00044, "epss_percentile": 0.13547}, "CVE-2020-11920": {"epss_score": 0.04409, "epss_percentile": 0.88655}, "CVE-2020-11921": {"epss_score": 0.00031, "epss_percentile": 0.08691}, "CVE-2020-11922": {"epss_score": 0.00324, "epss_percentile": 0.54972}, "CVE-2020-11923": {"epss_score": 0.00061, "epss_percentile": 0.19545}, "CVE-2020-11924": {"epss_score": 0.00109, "epss_percentile": 0.30004}, "CVE-2020-11925": {"epss_score": 0.00298, "epss_percentile": 0.52805}, "CVE-2020-11926": {"epss_score": 0.00103, "epss_percentile": 0.28929}, "CVE-2020-11928": {"epss_score": 0.0755, "epss_percentile": 0.91533}, "CVE-2020-11930": {"epss_score": 0.04451, "epss_percentile": 0.88705}, "CVE-2020-11931": {"epss_score": 0.00044, "epss_percentile": 0.13461}, "CVE-2020-11932": {"epss_score": 0.01714, "epss_percentile": 0.81893}, "CVE-2020-11933": {"epss_score": 0.00026, "epss_percentile": 0.06533}, "CVE-2020-11934": {"epss_score": 0.00045, "epss_percentile": 0.13991}, "CVE-2020-11935": {"epss_score": 0.00032, "epss_percentile": 0.08856}, "CVE-2020-11936": {"epss_score": 0.00087, "epss_percentile": 0.25564}, "CVE-2020-11937": {"epss_score": 0.00081, "epss_percentile": 0.24222}, "CVE-2020-11938": {"epss_score": 4e-05, "epss_percentile": 0.00154}, "CVE-2020-11939": {"epss_score": 0.08342, "epss_percentile": 0.92001}, "CVE-2020-11940": {"epss_score": 0.00473, "epss_percentile": 0.6411}, "CVE-2020-11941": {"epss_score": 0.03955, "epss_percentile": 0.88004}, "CVE-2020-11942": {"epss_score": 0.00394, "epss_percentile": 0.59789}, "CVE-2020-11943": {"epss_score": 0.03783, "epss_percentile": 0.87722}, "CVE-2020-11944": {"epss_score": 0.00371, "epss_percentile": 0.58366}, "CVE-2020-11945": {"epss_score": 0.28475, "epss_percentile": 0.96361}, "CVE-2020-11946": {"epss_score": 0.67005, "epss_percentile": 0.9849}, "CVE-2020-11947": {"epss_score": 0.00053, "epss_percentile": 0.16717}, "CVE-2020-11949": {"epss_score": 0.00328, "epss_percentile": 0.55177}, "CVE-2020-11950": {"epss_score": 0.01465, "epss_percentile": 0.80453}, "CVE-2020-11951": {"epss_score": 0.00346, "epss_percentile": 0.56647}, "CVE-2020-11952": {"epss_score": 0.00064, "epss_percentile": 0.20301}, "CVE-2020-11953": {"epss_score": 0.00846, "epss_percentile": 0.74335}, "CVE-2020-11955": {"epss_score": 0.00221, "epss_percentile": 0.44701}, "CVE-2020-11956": {"epss_score": 0.00346, "epss_percentile": 0.56647}, "CVE-2020-11957": {"epss_score": 0.0011, "epss_percentile": 0.30083}, "CVE-2020-11958": {"epss_score": 0.00462, "epss_percentile": 0.63582}, "CVE-2020-11959": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-11960": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2020-11961": {"epss_score": 0.00251, "epss_percentile": 0.48273}, "CVE-2020-11963": {"epss_score": 0.00715, "epss_percentile": 0.71836}, "CVE-2020-11964": {"epss_score": 0.0059, "epss_percentile": 0.68544}, "CVE-2020-11965": {"epss_score": 0.00427, "epss_percentile": 0.61913}, "CVE-2020-11966": {"epss_score": 0.00807, "epss_percentile": 0.73665}, "CVE-2020-11967": {"epss_score": 0.00842, "epss_percentile": 0.74234}, "CVE-2020-11968": {"epss_score": 0.00682, "epss_percentile": 0.71063}, "CVE-2020-11969": {"epss_score": 0.01111, "epss_percentile": 0.77666}, "CVE-2020-11971": {"epss_score": 0.10713, "epss_percentile": 0.93081}, "CVE-2020-11972": {"epss_score": 0.08393, "epss_percentile": 0.92027}, "CVE-2020-11973": {"epss_score": 0.0842, "epss_percentile": 0.92042}, "CVE-2020-11974": {"epss_score": 0.11349, "epss_percentile": 0.93321}, "CVE-2020-11975": {"epss_score": 0.8271, "epss_percentile": 0.99209}, "CVE-2020-11976": {"epss_score": 0.02033, "epss_percentile": 0.83343}, "CVE-2020-11977": {"epss_score": 0.00589, "epss_percentile": 0.6853}, "CVE-2020-11978": {"epss_score": 0.94272, "epss_percentile": 0.99931}, "CVE-2020-11979": {"epss_score": 0.00827, "epss_percentile": 0.73988}, "CVE-2020-11980": {"epss_score": 0.00514, "epss_percentile": 0.65949}, "CVE-2020-11981": {"epss_score": 0.91588, "epss_percentile": 0.99655}, "CVE-2020-11982": {"epss_score": 0.05664, "epss_percentile": 0.90099}, "CVE-2020-11983": {"epss_score": 0.00411, "epss_percentile": 0.60879}, "CVE-2020-11984": {"epss_score": 0.75348, "epss_percentile": 0.98839}, "CVE-2020-11985": {"epss_score": 0.17306, "epss_percentile": 0.94819}, "CVE-2020-11986": {"epss_score": 0.0225, "epss_percentile": 0.84156}, "CVE-2020-11987": {"epss_score": 0.01358, "epss_percentile": 0.79729}, "CVE-2020-11988": {"epss_score": 0.0018, "epss_percentile": 0.39901}, "CVE-2020-11989": {"epss_score": 0.7778, "epss_percentile": 0.98953}, "CVE-2020-11990": {"epss_score": 0.00158, "epss_percentile": 0.37288}, "CVE-2020-11991": {"epss_score": 0.93142, "epss_percentile": 0.99779}, "CVE-2020-11993": {"epss_score": 0.38847, "epss_percentile": 0.97123}, "CVE-2020-11994": {"epss_score": 0.01547, "epss_percentile": 0.80975}, "CVE-2020-11995": {"epss_score": 0.01417, "epss_percentile": 0.80155}, "CVE-2020-11996": {"epss_score": 0.39413, "epss_percentile": 0.9716}, "CVE-2020-11997": {"epss_score": 0.00509, "epss_percentile": 0.65751}, "CVE-2020-11998": {"epss_score": 0.08028, "epss_percentile": 0.9184}, "CVE-2020-11999": {"epss_score": 0.00087, "epss_percentile": 0.25526}, "CVE-2020-12000": {"epss_score": 0.00399, "epss_percentile": 0.60093}, "CVE-2020-12001": {"epss_score": 0.0008, "epss_percentile": 0.24013}, "CVE-2020-12002": {"epss_score": 0.31454, "epss_percentile": 0.96621}, "CVE-2020-12003": {"epss_score": 0.00117, "epss_percentile": 0.31212}, "CVE-2020-12004": {"epss_score": 0.20359, "epss_percentile": 0.95333}, "CVE-2020-12005": {"epss_score": 0.00023, "epss_percentile": 0.05469}, "CVE-2020-12006": {"epss_score": 0.04154, "epss_percentile": 0.88325}, "CVE-2020-12007": {"epss_score": 0.0217, "epss_percentile": 0.83867}, "CVE-2020-12008": {"epss_score": 0.00114, "epss_percentile": 0.30778}, "CVE-2020-12009": {"epss_score": 0.00201, "epss_percentile": 0.42372}, "CVE-2020-12010": {"epss_score": 0.00578, "epss_percentile": 0.68197}, "CVE-2020-12011": {"epss_score": 0.10238, "epss_percentile": 0.92906}, "CVE-2020-12012": {"epss_score": 0.00067, "epss_percentile": 0.2112}, "CVE-2020-12013": {"epss_score": 0.00906, "epss_percentile": 0.75247}, "CVE-2020-12014": {"epss_score": 0.00333, "epss_percentile": 0.55682}, "CVE-2020-12015": {"epss_score": 0.00201, "epss_percentile": 0.42372}, "CVE-2020-12016": {"epss_score": 0.00206, "epss_percentile": 0.43058}, "CVE-2020-12017": {"epss_score": 0.00653, "epss_percentile": 0.70325}, "CVE-2020-12018": {"epss_score": 0.00334, "epss_percentile": 0.55683}, "CVE-2020-12019": {"epss_score": 0.00903, "epss_percentile": 0.75199}, "CVE-2020-12020": {"epss_score": 0.00055, "epss_percentile": 0.17379}, "CVE-2020-12021": {"epss_score": 0.00592, "epss_percentile": 0.68625}, "CVE-2020-12022": {"epss_score": 0.0046, "epss_percentile": 0.63521}, "CVE-2020-12023": {"epss_score": 0.00046, "epss_percentile": 0.14431}, "CVE-2020-12024": {"epss_score": 0.00067, "epss_percentile": 0.2112}, "CVE-2020-12025": {"epss_score": 0.00179, "epss_percentile": 0.39771}, "CVE-2020-12026": {"epss_score": 0.01886, "epss_percentile": 0.82712}, "CVE-2020-12027": {"epss_score": 0.23526, "epss_percentile": 0.95789}, "CVE-2020-12028": {"epss_score": 0.28302, "epss_percentile": 0.96341}, "CVE-2020-12029": {"epss_score": 0.2462, "epss_percentile": 0.9594}, "CVE-2020-12030": {"epss_score": 0.00285, "epss_percentile": 0.51645}, "CVE-2020-12031": {"epss_score": 8e-05, "epss_percentile": 0.00512}, "CVE-2020-12032": {"epss_score": 0.0011, "epss_percentile": 0.30223}, "CVE-2020-12033": {"epss_score": 0.01617, "epss_percentile": 0.81364}, "CVE-2020-12034": {"epss_score": 6e-05, "epss_percentile": 0.00246}, "CVE-2020-12035": {"epss_score": 0.00047, "epss_percentile": 0.14797}, "CVE-2020-12036": {"epss_score": 0.00079, "epss_percentile": 0.23981}, "CVE-2020-12037": {"epss_score": 0.0007, "epss_percentile": 0.21869}, "CVE-2020-12038": {"epss_score": 0.00012, "epss_percentile": 0.01276}, "CVE-2020-12039": {"epss_score": 0.00055, "epss_percentile": 0.17627}, "CVE-2020-12040": {"epss_score": 0.00199, "epss_percentile": 0.42121}, "CVE-2020-12041": {"epss_score": 0.0028, "epss_percentile": 0.51079}, "CVE-2020-12042": {"epss_score": 0.00073, "epss_percentile": 0.22622}, "CVE-2020-12043": {"epss_score": 0.00253, "epss_percentile": 0.48455}, "CVE-2020-12045": {"epss_score": 0.0028, "epss_percentile": 0.51079}, "CVE-2020-12046": {"epss_score": 0.00077, "epss_percentile": 0.23526}, "CVE-2020-12047": {"epss_score": 0.0028, "epss_percentile": 0.51079}, "CVE-2020-12048": {"epss_score": 0.00061, "epss_percentile": 0.19472}, "CVE-2020-12049": {"epss_score": 0.00093, "epss_percentile": 0.26643}, "CVE-2020-12050": {"epss_score": 0.00089, "epss_percentile": 0.25851}, "CVE-2020-12051": {"epss_score": 0.00513, "epss_percentile": 0.65891}, "CVE-2020-12052": {"epss_score": 0.00716, "epss_percentile": 0.71868}, "CVE-2020-12053": {"epss_score": 0.0022, "epss_percentile": 0.44537}, "CVE-2020-12054": {"epss_score": 0.04584, "epss_percentile": 0.88882}, "CVE-2020-12058": {"epss_score": 0.0045, "epss_percentile": 0.631}, "CVE-2020-12059": {"epss_score": 0.00284, "epss_percentile": 0.51486}, "CVE-2020-12061": {"epss_score": 0.00428, "epss_percentile": 0.6193}, "CVE-2020-12062": {"epss_score": 0.00828, "epss_percentile": 0.73996}, "CVE-2020-12063": {"epss_score": 0.00401, "epss_percentile": 0.60251}, "CVE-2020-12066": {"epss_score": 0.05727, "epss_percentile": 0.90157}, "CVE-2020-12067": {"epss_score": 0.00194, "epss_percentile": 0.41523}, "CVE-2020-12068": {"epss_score": 0.00242, "epss_percentile": 0.47339}, "CVE-2020-12069": {"epss_score": 0.00077, "epss_percentile": 0.23457}, "CVE-2020-12070": {"epss_score": 0.00881, "epss_percentile": 0.74873}, "CVE-2020-12071": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-12073": {"epss_score": 0.00853, "epss_percentile": 0.74429}, "CVE-2020-12074": {"epss_score": 0.00554, "epss_percentile": 0.6745}, "CVE-2020-12075": {"epss_score": 0.00423, "epss_percentile": 0.61583}, "CVE-2020-12076": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2020-12077": {"epss_score": 0.7169, "epss_percentile": 0.98678}, "CVE-2020-12078": {"epss_score": 0.63674, "epss_percentile": 0.98343}, "CVE-2020-12079": {"epss_score": 0.00597, "epss_percentile": 0.68735}, "CVE-2020-12080": {"epss_score": 0.00668, "epss_percentile": 0.70741}, "CVE-2020-12081": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-12082": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-12083": {"epss_score": 0.00511, "epss_percentile": 0.65827}, "CVE-2020-12100": {"epss_score": 0.10964, "epss_percentile": 0.93178}, "CVE-2020-12101": {"epss_score": 0.00345, "epss_percentile": 0.56565}, "CVE-2020-12102": {"epss_score": 0.0113, "epss_percentile": 0.77853}, "CVE-2020-12103": {"epss_score": 0.0069, "epss_percentile": 0.71244}, "CVE-2020-12104": {"epss_score": 0.00779, "epss_percentile": 0.73158}, "CVE-2020-12105": {"epss_score": 0.00171, "epss_percentile": 0.38799}, "CVE-2020-12106": {"epss_score": 0.0098, "epss_percentile": 0.76267}, "CVE-2020-12107": {"epss_score": 0.06562, "epss_percentile": 0.90849}, "CVE-2020-12108": {"epss_score": 0.05591, "epss_percentile": 0.90029}, "CVE-2020-12109": {"epss_score": 0.82221, "epss_percentile": 0.9918}, "CVE-2020-12110": {"epss_score": 0.01084, "epss_percentile": 0.77393}, "CVE-2020-12111": {"epss_score": 0.04509, "epss_percentile": 0.88778}, "CVE-2020-12112": {"epss_score": 0.09079, "epss_percentile": 0.9239}, "CVE-2020-12113": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2020-12114": {"epss_score": 0.00045, "epss_percentile": 0.1389}, "CVE-2020-12116": {"epss_score": 0.91736, "epss_percentile": 0.99665}, "CVE-2020-12117": {"epss_score": 0.00116, "epss_percentile": 0.31074}, "CVE-2020-12118": {"epss_score": 0.00304, "epss_percentile": 0.53264}, "CVE-2020-12119": {"epss_score": 0.002, "epss_percentile": 0.42248}, "CVE-2020-12120": {"epss_score": 0.00561, "epss_percentile": 0.67677}, "CVE-2020-12122": {"epss_score": 0.00054, "epss_percentile": 0.17231}, "CVE-2020-12123": {"epss_score": 0.00136, "epss_percentile": 0.34168}, "CVE-2020-12124": {"epss_score": 0.91801, "epss_percentile": 0.99668}, "CVE-2020-12125": {"epss_score": 0.05941, "epss_percentile": 0.9035}, "CVE-2020-12126": {"epss_score": 0.0065, "epss_percentile": 0.70273}, "CVE-2020-12127": {"epss_score": 0.1847, "epss_percentile": 0.95019}, "CVE-2020-12128": {"epss_score": 0.00482, "epss_percentile": 0.64525}, "CVE-2020-12129": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-12130": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-12131": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-12132": {"epss_score": 0.00521, "epss_percentile": 0.6624}, "CVE-2020-12133": {"epss_score": 0.08075, "epss_percentile": 0.91868}, "CVE-2020-12134": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2020-12135": {"epss_score": 0.00349, "epss_percentile": 0.56895}, "CVE-2020-12137": {"epss_score": 0.03675, "epss_percentile": 0.87551}, "CVE-2020-12138": {"epss_score": 0.00669, "epss_percentile": 0.7075}, "CVE-2020-12140": {"epss_score": 0.0011, "epss_percentile": 0.30175}, "CVE-2020-12141": {"epss_score": 0.00495, "epss_percentile": 0.65118}, "CVE-2020-12142": {"epss_score": 0.00215, "epss_percentile": 0.44108}, "CVE-2020-12143": {"epss_score": 0.00087, "epss_percentile": 0.25452}, "CVE-2020-12144": {"epss_score": 0.00075, "epss_percentile": 0.22991}, "CVE-2020-12145": {"epss_score": 0.5904, "epss_percentile": 0.98146}, "CVE-2020-12146": {"epss_score": 0.44649, "epss_percentile": 0.97447}, "CVE-2020-12147": {"epss_score": 0.01324, "epss_percentile": 0.79464}, "CVE-2020-12148": {"epss_score": 0.00251, "epss_percentile": 0.48309}, "CVE-2020-12149": {"epss_score": 0.00373, "epss_percentile": 0.58524}, "CVE-2020-12242": {"epss_score": 0.0039, "epss_percentile": 0.59539}, "CVE-2020-12243": {"epss_score": 0.10757, "epss_percentile": 0.93095}, "CVE-2020-12244": {"epss_score": 0.00094, "epss_percentile": 0.26969}, "CVE-2020-12245": {"epss_score": 0.03189, "epss_percentile": 0.86593}, "CVE-2020-12246": {"epss_score": 0.04581, "epss_percentile": 0.88875}, "CVE-2020-12247": {"epss_score": 0.00129, "epss_percentile": 0.33078}, "CVE-2020-12248": {"epss_score": 0.00527, "epss_percentile": 0.66447}, "CVE-2020-12251": {"epss_score": 0.00814, "epss_percentile": 0.73767}, "CVE-2020-12252": {"epss_score": 0.03507, "epss_percentile": 0.8726}, "CVE-2020-12254": {"epss_score": 0.00121, "epss_percentile": 0.31815}, "CVE-2020-12255": {"epss_score": 0.58581, "epss_percentile": 0.98125}, "CVE-2020-12256": {"epss_score": 0.54902, "epss_percentile": 0.97949}, "CVE-2020-12257": {"epss_score": 0.00574, "epss_percentile": 0.68096}, "CVE-2020-12258": {"epss_score": 0.01064, "epss_percentile": 0.77196}, "CVE-2020-12259": {"epss_score": 0.68306, "epss_percentile": 0.98541}, "CVE-2020-12261": {"epss_score": 0.00346, "epss_percentile": 0.56628}, "CVE-2020-12262": {"epss_score": 0.01038, "epss_percentile": 0.76936}, "CVE-2020-12265": {"epss_score": 0.00737, "epss_percentile": 0.72318}, "CVE-2020-12266": {"epss_score": 0.00423, "epss_percentile": 0.61636}, "CVE-2020-12267": {"epss_score": 0.00466, "epss_percentile": 0.63805}, "CVE-2020-12268": {"epss_score": 0.00813, "epss_percentile": 0.73764}, "CVE-2020-12270": {"epss_score": 0.00846, "epss_percentile": 0.74327}, "CVE-2020-12271": {"epss_score": 0.88487, "epss_percentile": 0.99474}, "CVE-2020-12272": {"epss_score": 0.01015, "epss_percentile": 0.76659}, "CVE-2020-12273": {"epss_score": 0.00166, "epss_percentile": 0.38172}, "CVE-2020-12274": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2020-12275": {"epss_score": 0.00124, "epss_percentile": 0.32451}, "CVE-2020-12276": {"epss_score": 0.00113, "epss_percentile": 0.30675}, "CVE-2020-12277": {"epss_score": 0.00079, "epss_percentile": 0.23849}, "CVE-2020-12278": {"epss_score": 0.05164, "epss_percentile": 0.89561}, "CVE-2020-12279": {"epss_score": 0.05577, "epss_percentile": 0.90014}, "CVE-2020-12280": {"epss_score": 0.00206, "epss_percentile": 0.43069}, "CVE-2020-12281": {"epss_score": 0.00206, "epss_percentile": 0.43069}, "CVE-2020-12282": {"epss_score": 0.00216, "epss_percentile": 0.44196}, "CVE-2020-12283": {"epss_score": 0.00257, "epss_percentile": 0.48918}, "CVE-2020-12284": {"epss_score": 0.06437, "epss_percentile": 0.90756}, "CVE-2020-12286": {"epss_score": 0.0039, "epss_percentile": 0.59556}, "CVE-2020-12287": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-12288": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12289": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12290": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12291": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12292": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12293": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12294": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12295": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12296": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12297": {"epss_score": 0.00084, "epss_percentile": 0.24869}, "CVE-2020-12299": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2020-12300": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2020-12301": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2020-12302": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-12303": {"epss_score": 0.00068, "epss_percentile": 0.21296}, "CVE-2020-12304": {"epss_score": 0.00071, "epss_percentile": 0.2218}, "CVE-2020-12306": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-12307": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-12308": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2020-12309": {"epss_score": 0.00078, "epss_percentile": 0.23632}, "CVE-2020-12310": {"epss_score": 0.00165, "epss_percentile": 0.38117}, "CVE-2020-12311": {"epss_score": 0.00165, "epss_percentile": 0.38117}, "CVE-2020-12312": {"epss_score": 0.00181, "epss_percentile": 0.40033}, "CVE-2020-12313": {"epss_score": 0.00334, "epss_percentile": 0.55735}, "CVE-2020-12314": {"epss_score": 0.00092, "epss_percentile": 0.26499}, "CVE-2020-12315": {"epss_score": 0.0149, "epss_percentile": 0.80629}, "CVE-2020-12316": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2020-12317": {"epss_score": 0.00277, "epss_percentile": 0.508}, "CVE-2020-12318": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12319": {"epss_score": 0.00277, "epss_percentile": 0.508}, "CVE-2020-12320": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2020-12321": {"epss_score": 0.00285, "epss_percentile": 0.51547}, "CVE-2020-12322": {"epss_score": 0.00092, "epss_percentile": 0.26499}, "CVE-2020-12323": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2020-12324": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12325": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12326": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-12327": {"epss_score": 0.00065, "epss_percentile": 0.20653}, "CVE-2020-12328": {"epss_score": 0.00065, "epss_percentile": 0.20653}, "CVE-2020-12329": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2020-12330": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-12331": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12332": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-12333": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2020-12334": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-12335": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-12336": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12337": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2020-12338": {"epss_score": 0.01807, "epss_percentile": 0.82354}, "CVE-2020-12339": {"epss_score": 0.00512, "epss_percentile": 0.65864}, "CVE-2020-12345": {"epss_score": 0.0028, "epss_percentile": 0.51033}, "CVE-2020-12346": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-12347": {"epss_score": 0.00512, "epss_percentile": 0.65864}, "CVE-2020-12349": {"epss_score": 0.00328, "epss_percentile": 0.55177}, "CVE-2020-12350": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12351": {"epss_score": 0.03752, "epss_percentile": 0.87676}, "CVE-2020-12352": {"epss_score": 0.01934, "epss_percentile": 0.82955}, "CVE-2020-12353": {"epss_score": 0.00185, "epss_percentile": 0.40547}, "CVE-2020-12354": {"epss_score": 0.00034, "epss_percentile": 0.09454}, "CVE-2020-12355": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2020-12356": {"epss_score": 0.00145, "epss_percentile": 0.35414}, "CVE-2020-12357": {"epss_score": 0.00114, "epss_percentile": 0.30798}, "CVE-2020-12358": {"epss_score": 0.00046, "epss_percentile": 0.14325}, "CVE-2020-12359": {"epss_score": 0.00369, "epss_percentile": 0.58244}, "CVE-2020-12360": {"epss_score": 0.00174, "epss_percentile": 0.39203}, "CVE-2020-12361": {"epss_score": 0.00056, "epss_percentile": 0.1788}, "CVE-2020-12362": {"epss_score": 0.00098, "epss_percentile": 0.27677}, "CVE-2020-12363": {"epss_score": 0.00123, "epss_percentile": 0.32176}, "CVE-2020-12364": {"epss_score": 0.0015, "epss_percentile": 0.36046}, "CVE-2020-12365": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12366": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12367": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12368": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12369": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12370": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12371": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12372": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12373": {"epss_score": 0.00059, "epss_percentile": 0.18729}, "CVE-2020-12374": {"epss_score": 0.0008, "epss_percentile": 0.24021}, "CVE-2020-12375": {"epss_score": 0.0007, "epss_percentile": 0.21832}, "CVE-2020-12376": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2020-12377": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12380": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12384": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12385": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12386": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12387": {"epss_score": 0.00998, "epss_percentile": 0.76468}, "CVE-2020-12388": {"epss_score": 0.01503, "epss_percentile": 0.80725}, "CVE-2020-12389": {"epss_score": 0.00554, "epss_percentile": 0.67448}, "CVE-2020-12390": {"epss_score": 0.01472, "epss_percentile": 0.80509}, "CVE-2020-12391": {"epss_score": 0.00697, "epss_percentile": 0.71412}, "CVE-2020-12392": {"epss_score": 0.00136, "epss_percentile": 0.34174}, "CVE-2020-12393": {"epss_score": 0.0048, "epss_percentile": 0.64471}, "CVE-2020-12394": {"epss_score": 0.0015, "epss_percentile": 0.36076}, "CVE-2020-12395": {"epss_score": 0.01465, "epss_percentile": 0.80453}, "CVE-2020-12396": {"epss_score": 0.00576, "epss_percentile": 0.68133}, "CVE-2020-12397": {"epss_score": 0.00197, "epss_percentile": 0.41835}, "CVE-2020-12398": {"epss_score": 0.00262, "epss_percentile": 0.49329}, "CVE-2020-12399": {"epss_score": 0.00101, "epss_percentile": 0.28708}, "CVE-2020-12400": {"epss_score": 0.00072, "epss_percentile": 0.22359}, "CVE-2020-12401": {"epss_score": 0.0007, "epss_percentile": 0.21706}, "CVE-2020-12402": {"epss_score": 0.00102, "epss_percentile": 0.28814}, "CVE-2020-12403": {"epss_score": 0.00191, "epss_percentile": 0.41216}, "CVE-2020-12404": {"epss_score": 0.00264, "epss_percentile": 0.49703}, "CVE-2020-12405": {"epss_score": 0.00664, "epss_percentile": 0.70643}, "CVE-2020-12406": {"epss_score": 0.00355, "epss_percentile": 0.57298}, "CVE-2020-12407": {"epss_score": 0.00325, "epss_percentile": 0.55031}, "CVE-2020-12408": {"epss_score": 0.00234, "epss_percentile": 0.46106}, "CVE-2020-12409": {"epss_score": 0.0033, "epss_percentile": 0.55495}, "CVE-2020-12410": {"epss_score": 0.00787, "epss_percentile": 0.73315}, "CVE-2020-12411": {"epss_score": 0.00465, "epss_percentile": 0.63755}, "CVE-2020-12412": {"epss_score": 0.00284, "epss_percentile": 0.51449}, "CVE-2020-12413": {"epss_score": 0.00116, "epss_percentile": 0.31044}, "CVE-2020-12414": {"epss_score": 0.00186, "epss_percentile": 0.40617}, "CVE-2020-12415": {"epss_score": 0.00353, "epss_percentile": 0.57136}, "CVE-2020-12416": {"epss_score": 0.00671, "epss_percentile": 0.70797}, "CVE-2020-12417": {"epss_score": 0.0043, "epss_percentile": 0.62004}, "CVE-2020-12418": {"epss_score": 0.01761, "epss_percentile": 0.82151}, "CVE-2020-12419": {"epss_score": 0.00443, "epss_percentile": 0.6277}, "CVE-2020-12420": {"epss_score": 0.00467, "epss_percentile": 0.63811}, "CVE-2020-12421": {"epss_score": 0.01493, "epss_percentile": 0.80643}, "CVE-2020-12422": {"epss_score": 0.00616, "epss_percentile": 0.69326}, "CVE-2020-12423": {"epss_score": 0.0028, "epss_percentile": 0.51073}, "CVE-2020-12424": {"epss_score": 0.0016, "epss_percentile": 0.37473}, "CVE-2020-12425": {"epss_score": 0.00537, "epss_percentile": 0.66923}, "CVE-2020-12426": {"epss_score": 0.00823, "epss_percentile": 0.73921}, "CVE-2020-12427": {"epss_score": 0.00146, "epss_percentile": 0.35529}, "CVE-2020-12429": {"epss_score": 0.00537, "epss_percentile": 0.66901}, "CVE-2020-12430": {"epss_score": 0.00947, "epss_percentile": 0.75816}, "CVE-2020-12431": {"epss_score": 0.00074, "epss_percentile": 0.22749}, "CVE-2020-12432": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2020-12438": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-12439": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-12441": {"epss_score": 0.08681, "epss_percentile": 0.92197}, "CVE-2020-12442": {"epss_score": 0.07732, "epss_percentile": 0.91649}, "CVE-2020-12443": {"epss_score": 0.00847, "epss_percentile": 0.74354}, "CVE-2020-12446": {"epss_score": 0.00096, "epss_percentile": 0.27266}, "CVE-2020-12447": {"epss_score": 0.79818, "epss_percentile": 0.99056}, "CVE-2020-12448": {"epss_score": 0.00334, "epss_percentile": 0.55689}, "CVE-2020-12456": {"epss_score": 0.01336, "epss_percentile": 0.79555}, "CVE-2020-12457": {"epss_score": 0.00468, "epss_percentile": 0.63891}, "CVE-2020-12458": {"epss_score": 0.00089, "epss_percentile": 0.2594}, "CVE-2020-12459": {"epss_score": 0.00088, "epss_percentile": 0.25702}, "CVE-2020-12460": {"epss_score": 0.14593, "epss_percentile": 0.94248}, "CVE-2020-12461": {"epss_score": 0.00164, "epss_percentile": 0.3799}, "CVE-2020-12462": {"epss_score": 0.00264, "epss_percentile": 0.49717}, "CVE-2020-12463": {"epss_score": 0.00044, "epss_percentile": 0.13636}, "CVE-2020-12464": {"epss_score": 0.00071, "epss_percentile": 0.22126}, "CVE-2020-12465": {"epss_score": 0.00169, "epss_percentile": 0.38637}, "CVE-2020-12467": {"epss_score": 0.00285, "epss_percentile": 0.51641}, "CVE-2020-12468": {"epss_score": 0.00273, "epss_percentile": 0.50472}, "CVE-2020-12469": {"epss_score": 0.00225, "epss_percentile": 0.45234}, "CVE-2020-12470": {"epss_score": 0.00443, "epss_percentile": 0.62763}, "CVE-2020-12471": {"epss_score": 0.0325, "epss_percentile": 0.8675}, "CVE-2020-12472": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-12473": {"epss_score": 0.00465, "epss_percentile": 0.63763}, "CVE-2020-12474": {"epss_score": 0.00795, "epss_percentile": 0.73471}, "CVE-2020-12475": {"epss_score": 0.00048, "epss_percentile": 0.15127}, "CVE-2020-12477": {"epss_score": 0.00812, "epss_percentile": 0.73748}, "CVE-2020-12478": {"epss_score": 0.38993, "epss_percentile": 0.97133}, "CVE-2020-12479": {"epss_score": 0.02422, "epss_percentile": 0.84707}, "CVE-2020-12480": {"epss_score": 0.00036, "epss_percentile": 0.10312}, "CVE-2020-12483": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2020-12484": {"epss_score": 0.00031, "epss_percentile": 0.08441}, "CVE-2020-12485": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2020-12487": {"epss_score": 0.00045, "epss_percentile": 0.13819}, "CVE-2020-12488": {"epss_score": 0.00057, "epss_percentile": 0.18157}, "CVE-2020-12491": {"epss_score": 0.0003, "epss_percentile": 0.08317}, "CVE-2020-12492": {"epss_score": 0.00038, "epss_percentile": 0.1113}, "CVE-2020-12493": {"epss_score": 0.00299, "epss_percentile": 0.52886}, "CVE-2020-12494": {"epss_score": 0.00339, "epss_percentile": 0.562}, "CVE-2020-12495": {"epss_score": 0.00354, "epss_percentile": 0.57225}, "CVE-2020-12496": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2020-12497": {"epss_score": 0.08365, "epss_percentile": 0.92009}, "CVE-2020-12498": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2020-12499": {"epss_score": 0.00096, "epss_percentile": 0.27344}, "CVE-2020-12500": {"epss_score": 0.00796, "epss_percentile": 0.73478}, "CVE-2020-12501": {"epss_score": 0.00944, "epss_percentile": 0.75784}, "CVE-2020-12502": {"epss_score": 0.00671, "epss_percentile": 0.70805}, "CVE-2020-12503": {"epss_score": 0.06424, "epss_percentile": 0.90752}, "CVE-2020-12504": {"epss_score": 0.00551, "epss_percentile": 0.6737}, "CVE-2020-12505": {"epss_score": 0.00269, "epss_percentile": 0.50162}, "CVE-2020-12506": {"epss_score": 0.00269, "epss_percentile": 0.50162}, "CVE-2020-12507": {"epss_score": 0.00705, "epss_percentile": 0.71602}, "CVE-2020-12508": {"epss_score": 0.01466, "epss_percentile": 0.80466}, "CVE-2020-12509": {"epss_score": 0.01084, "epss_percentile": 0.77398}, "CVE-2020-12510": {"epss_score": 0.00208, "epss_percentile": 0.43224}, "CVE-2020-12511": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2020-12512": {"epss_score": 0.0072, "epss_percentile": 0.71958}, "CVE-2020-12513": {"epss_score": 0.08889, "epss_percentile": 0.92302}, "CVE-2020-12514": {"epss_score": 0.00452, "epss_percentile": 0.63199}, "CVE-2020-12516": {"epss_score": 0.0037, "epss_percentile": 0.58307}, "CVE-2020-12517": {"epss_score": 0.00612, "epss_percentile": 0.69225}, "CVE-2020-12518": {"epss_score": 0.00191, "epss_percentile": 0.41144}, "CVE-2020-12519": {"epss_score": 0.00152, "epss_percentile": 0.36461}, "CVE-2020-12521": {"epss_score": 0.00084, "epss_percentile": 0.24975}, "CVE-2020-12522": {"epss_score": 0.00225, "epss_percentile": 0.45224}, "CVE-2020-12523": {"epss_score": 0.00378, "epss_percentile": 0.58824}, "CVE-2020-12524": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-12525": {"epss_score": 0.00106, "epss_percentile": 0.29439}, "CVE-2020-12526": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2020-12527": {"epss_score": 0.00146, "epss_percentile": 0.3555}, "CVE-2020-12528": {"epss_score": 0.00218, "epss_percentile": 0.44364}, "CVE-2020-12529": {"epss_score": 0.00185, "epss_percentile": 0.40554}, "CVE-2020-12530": {"epss_score": 0.00182, "epss_percentile": 0.40221}, "CVE-2020-12593": {"epss_score": 0.01513, "epss_percentile": 0.80788}, "CVE-2020-12594": {"epss_score": 0.00534, "epss_percentile": 0.66794}, "CVE-2020-12595": {"epss_score": 0.00297, "epss_percentile": 0.52697}, "CVE-2020-12603": {"epss_score": 0.00786, "epss_percentile": 0.73267}, "CVE-2020-12604": {"epss_score": 0.00437, "epss_percentile": 0.62535}, "CVE-2020-12605": {"epss_score": 0.00786, "epss_percentile": 0.73267}, "CVE-2020-12606": {"epss_score": 0.03636, "epss_percentile": 0.87482}, "CVE-2020-12607": {"epss_score": 0.00169, "epss_percentile": 0.38538}, "CVE-2020-12608": {"epss_score": 0.03633, "epss_percentile": 0.87476}, "CVE-2020-12612": {"epss_score": 0.00189, "epss_percentile": 0.40979}, "CVE-2020-12613": {"epss_score": 0.00196, "epss_percentile": 0.4174}, "CVE-2020-12614": {"epss_score": 0.0014, "epss_percentile": 0.34726}, "CVE-2020-12615": {"epss_score": 0.00154, "epss_percentile": 0.36751}, "CVE-2020-12618": {"epss_score": 0.00124, "epss_percentile": 0.32355}, "CVE-2020-12619": {"epss_score": 0.00189, "epss_percentile": 0.40947}, "CVE-2020-12620": {"epss_score": 0.00563, "epss_percentile": 0.67719}, "CVE-2020-12621": {"epss_score": 0.00123, "epss_percentile": 0.32297}, "CVE-2020-12624": {"epss_score": 0.00468, "epss_percentile": 0.63868}, "CVE-2020-12625": {"epss_score": 0.0231, "epss_percentile": 0.84333}, "CVE-2020-12626": {"epss_score": 0.01288, "epss_percentile": 0.79199}, "CVE-2020-12627": {"epss_score": 0.00132, "epss_percentile": 0.33592}, "CVE-2020-12629": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2020-12635": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-12637": {"epss_score": 0.0022, "epss_percentile": 0.44537}, "CVE-2020-12638": {"epss_score": 0.0004, "epss_percentile": 0.12004}, "CVE-2020-12639": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-12640": {"epss_score": 0.22659, "epss_percentile": 0.95665}, "CVE-2020-12641": {"epss_score": 0.93275, "epss_percentile": 0.99792}, "CVE-2020-12642": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2020-12643": {"epss_score": 0.00228, "epss_percentile": 0.45498}, "CVE-2020-12644": {"epss_score": 0.00149, "epss_percentile": 0.35948}, "CVE-2020-12645": {"epss_score": 0.0034, "epss_percentile": 0.56277}, "CVE-2020-12646": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-12647": {"epss_score": 0.00084, "epss_percentile": 0.24881}, "CVE-2020-12648": {"epss_score": 0.00217, "epss_percentile": 0.44257}, "CVE-2020-12649": {"epss_score": 0.00469, "epss_percentile": 0.6395}, "CVE-2020-12651": {"epss_score": 0.08487, "epss_percentile": 0.92079}, "CVE-2020-12652": {"epss_score": 0.00067, "epss_percentile": 0.21164}, "CVE-2020-12653": {"epss_score": 0.00195, "epss_percentile": 0.41683}, "CVE-2020-12654": {"epss_score": 0.004, "epss_percentile": 0.60196}, "CVE-2020-12655": {"epss_score": 0.00079, "epss_percentile": 0.23878}, "CVE-2020-12656": {"epss_score": 0.00108, "epss_percentile": 0.29861}, "CVE-2020-12657": {"epss_score": 0.0004, "epss_percentile": 0.12138}, "CVE-2020-12658": {"epss_score": 0.00572, "epss_percentile": 0.68024}, "CVE-2020-12659": {"epss_score": 0.00097, "epss_percentile": 0.27546}, "CVE-2020-12662": {"epss_score": 0.15507, "epss_percentile": 0.94441}, "CVE-2020-12663": {"epss_score": 0.09083, "epss_percentile": 0.92392}, "CVE-2020-12666": {"epss_score": 0.00159, "epss_percentile": 0.37373}, "CVE-2020-12667": {"epss_score": 0.00654, "epss_percentile": 0.70345}, "CVE-2020-12668": {"epss_score": 0.00328, "epss_percentile": 0.55285}, "CVE-2020-12669": {"epss_score": 0.00289, "epss_percentile": 0.52004}, "CVE-2020-12670": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-12672": {"epss_score": 0.00357, "epss_percentile": 0.57455}, "CVE-2020-12673": {"epss_score": 0.01131, "epss_percentile": 0.77862}, "CVE-2020-12674": {"epss_score": 0.08707, "epss_percentile": 0.9221}, "CVE-2020-12675": {"epss_score": 0.09093, "epss_percentile": 0.92399}, "CVE-2020-12676": {"epss_score": 0.00148, "epss_percentile": 0.35883}, "CVE-2020-12677": {"epss_score": 0.00079, "epss_percentile": 0.23909}, "CVE-2020-12679": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2020-12680": {"epss_score": 0.00121, "epss_percentile": 0.31991}, "CVE-2020-12681": {"epss_score": 0.00091, "epss_percentile": 0.26392}, "CVE-2020-12683": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-12684": {"epss_score": 0.00428, "epss_percentile": 0.61936}, "CVE-2020-12685": {"epss_score": 0.00319, "epss_percentile": 0.54559}, "CVE-2020-12687": {"epss_score": 0.00457, "epss_percentile": 0.63395}, "CVE-2020-12689": {"epss_score": 0.00621, "epss_percentile": 0.69481}, "CVE-2020-12690": {"epss_score": 0.00817, "epss_percentile": 0.73837}, "CVE-2020-12691": {"epss_score": 0.03566, "epss_percentile": 0.87366}, "CVE-2020-12692": {"epss_score": 0.0014, "epss_percentile": 0.34749}, "CVE-2020-12693": {"epss_score": 0.00194, "epss_percentile": 0.41554}, "CVE-2020-12695": {"epss_score": 0.0354, "epss_percentile": 0.87318}, "CVE-2020-12696": {"epss_score": 0.11038, "epss_percentile": 0.93196}, "CVE-2020-12697": {"epss_score": 0.00328, "epss_percentile": 0.55297}, "CVE-2020-12698": {"epss_score": 0.00129, "epss_percentile": 0.33197}, "CVE-2020-12699": {"epss_score": 0.00171, "epss_percentile": 0.38866}, "CVE-2020-12700": {"epss_score": 0.00129, "epss_percentile": 0.33197}, "CVE-2020-12702": {"epss_score": 0.0043, "epss_percentile": 0.62009}, "CVE-2020-12703": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-12704": {"epss_score": 0.00401, "epss_percentile": 0.60212}, "CVE-2020-12705": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-12706": {"epss_score": 0.01673, "epss_percentile": 0.81689}, "CVE-2020-12707": {"epss_score": 0.00363, "epss_percentile": 0.57825}, "CVE-2020-12708": {"epss_score": 0.00195, "epss_percentile": 0.41601}, "CVE-2020-12712": {"epss_score": 0.04538, "epss_percentile": 0.88827}, "CVE-2020-12713": {"epss_score": 0.03281, "epss_percentile": 0.86817}, "CVE-2020-12714": {"epss_score": 0.00264, "epss_percentile": 0.4957}, "CVE-2020-12715": {"epss_score": 0.00615, "epss_percentile": 0.69308}, "CVE-2020-12717": {"epss_score": 0.02195, "epss_percentile": 0.83951}, "CVE-2020-12718": {"epss_score": 0.00309, "epss_percentile": 0.53672}, "CVE-2020-12719": {"epss_score": 0.00403, "epss_percentile": 0.6034}, "CVE-2020-12720": {"epss_score": 0.9382, "epss_percentile": 0.99853}, "CVE-2020-12723": {"epss_score": 0.00191, "epss_percentile": 0.41143}, "CVE-2020-12725": {"epss_score": 0.00746, "epss_percentile": 0.72552}, "CVE-2020-12729": {"epss_score": 0.00064, "epss_percentile": 0.20301}, "CVE-2020-12730": {"epss_score": 0.00024, "epss_percentile": 0.06007}, "CVE-2020-12731": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2020-12732": {"epss_score": 0.00095, "epss_percentile": 0.27148}, "CVE-2020-12733": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2020-12734": {"epss_score": 0.00345, "epss_percentile": 0.566}, "CVE-2020-12735": {"epss_score": 0.0054, "epss_percentile": 0.6702}, "CVE-2020-12736": {"epss_score": 0.03111, "epss_percentile": 0.86424}, "CVE-2020-12737": {"epss_score": 0.00536, "epss_percentile": 0.6686}, "CVE-2020-12739": {"epss_score": 0.00801, "epss_percentile": 0.73578}, "CVE-2020-12740": {"epss_score": 0.00513, "epss_percentile": 0.65917}, "CVE-2020-12742": {"epss_score": 0.00469, "epss_percentile": 0.63943}, "CVE-2020-12743": {"epss_score": 0.00404, "epss_percentile": 0.60427}, "CVE-2020-12744": {"epss_score": 0.00042, "epss_percentile": 0.12809}, "CVE-2020-12745": {"epss_score": 0.00114, "epss_percentile": 0.30879}, "CVE-2020-12746": {"epss_score": 0.00288, "epss_percentile": 0.51865}, "CVE-2020-12747": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2020-12748": {"epss_score": 0.00109, "epss_percentile": 0.29922}, "CVE-2020-12749": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2020-12750": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2020-12751": {"epss_score": 0.00063, "epss_percentile": 0.19936}, "CVE-2020-12752": {"epss_score": 0.00114, "epss_percentile": 0.30879}, "CVE-2020-12753": {"epss_score": 0.06285, "epss_percentile": 0.90641}, "CVE-2020-12754": {"epss_score": 0.00061, "epss_percentile": 0.19412}, "CVE-2020-12755": {"epss_score": 0.0005, "epss_percentile": 0.15946}, "CVE-2020-12757": {"epss_score": 0.00365, "epss_percentile": 0.58}, "CVE-2020-12758": {"epss_score": 0.0063, "epss_percentile": 0.69694}, "CVE-2020-12759": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-12760": {"epss_score": 0.01503, "epss_percentile": 0.80727}, "CVE-2020-12761": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-12762": {"epss_score": 0.0028, "epss_percentile": 0.51065}, "CVE-2020-12763": {"epss_score": 0.03689, "epss_percentile": 0.87573}, "CVE-2020-12764": {"epss_score": 0.00147, "epss_percentile": 0.35672}, "CVE-2020-12765": {"epss_score": 0.00147, "epss_percentile": 0.35672}, "CVE-2020-12766": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-12767": {"epss_score": 0.00153, "epss_percentile": 0.36641}, "CVE-2020-12768": {"epss_score": 0.00056, "epss_percentile": 0.17965}, "CVE-2020-12769": {"epss_score": 0.00061, "epss_percentile": 0.1953}, "CVE-2020-12770": {"epss_score": 0.00082, "epss_percentile": 0.24561}, "CVE-2020-12771": {"epss_score": 0.00062, "epss_percentile": 0.19657}, "CVE-2020-12772": {"epss_score": 0.00842, "epss_percentile": 0.74232}, "CVE-2020-12773": {"epss_score": 0.00414, "epss_percentile": 0.61025}, "CVE-2020-12774": {"epss_score": 0.0058, "epss_percentile": 0.68248}, "CVE-2020-12775": {"epss_score": 0.04039, "epss_percentile": 0.88162}, "CVE-2020-12776": {"epss_score": 0.00442, "epss_percentile": 0.6272}, "CVE-2020-12777": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-12778": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2020-12779": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2020-12780": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2020-12781": {"epss_score": 0.00131, "epss_percentile": 0.33461}, "CVE-2020-12782": {"epss_score": 0.0543, "epss_percentile": 0.89874}, "CVE-2020-12783": {"epss_score": 0.01448, "epss_percentile": 0.80335}, "CVE-2020-12784": {"epss_score": 0.00524, "epss_percentile": 0.66319}, "CVE-2020-12785": {"epss_score": 0.00327, "epss_percentile": 0.55122}, "CVE-2020-12787": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-12788": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-12789": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2020-12790": {"epss_score": 0.00458, "epss_percentile": 0.63443}, "CVE-2020-12797": {"epss_score": 0.00407, "epss_percentile": 0.60614}, "CVE-2020-12798": {"epss_score": 0.0016, "epss_percentile": 0.37438}, "CVE-2020-12800": {"epss_score": 0.93936, "epss_percentile": 0.99871}, "CVE-2020-12801": {"epss_score": 0.00205, "epss_percentile": 0.42705}, "CVE-2020-12802": {"epss_score": 0.00473, "epss_percentile": 0.64103}, "CVE-2020-12803": {"epss_score": 0.01131, "epss_percentile": 0.77854}, "CVE-2020-12811": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2020-12812": {"epss_score": 0.46006, "epss_percentile": 0.97517}, "CVE-2020-12814": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2020-12815": {"epss_score": 0.0018, "epss_percentile": 0.39876}, "CVE-2020-12816": {"epss_score": 0.0037, "epss_percentile": 0.58278}, "CVE-2020-12817": {"epss_score": 0.00435, "epss_percentile": 0.62356}, "CVE-2020-12818": {"epss_score": 0.00278, "epss_percentile": 0.50857}, "CVE-2020-12819": {"epss_score": 0.00385, "epss_percentile": 0.59213}, "CVE-2020-12820": {"epss_score": 0.0065, "epss_percentile": 0.70251}, "CVE-2020-12821": {"epss_score": 0.00887, "epss_percentile": 0.74973}, "CVE-2020-12823": {"epss_score": 0.01506, "epss_percentile": 0.80746}, "CVE-2020-12824": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2020-12825": {"epss_score": 0.03705, "epss_percentile": 0.87596}, "CVE-2020-12826": {"epss_score": 0.00068, "epss_percentile": 0.21286}, "CVE-2020-12827": {"epss_score": 0.02387, "epss_percentile": 0.84583}, "CVE-2020-12828": {"epss_score": 0.14757, "epss_percentile": 0.94275}, "CVE-2020-12829": {"epss_score": 0.00117, "epss_percentile": 0.31369}, "CVE-2020-12830": {"epss_score": 0.0316, "epss_percentile": 0.86529}, "CVE-2020-12831": {"epss_score": 0.00259, "epss_percentile": 0.49041}, "CVE-2020-12832": {"epss_score": 0.73235, "epss_percentile": 0.98742}, "CVE-2020-12834": {"epss_score": 0.45806, "epss_percentile": 0.97503}, "CVE-2020-12835": {"epss_score": 0.13694, "epss_percentile": 0.94036}, "CVE-2020-12837": {"epss_score": 0.00351, "epss_percentile": 0.57031}, "CVE-2020-12838": {"epss_score": 0.00436, "epss_percentile": 0.62384}, "CVE-2020-12839": {"epss_score": 0.00436, "epss_percentile": 0.62384}, "CVE-2020-12840": {"epss_score": 0.00206, "epss_percentile": 0.43069}, "CVE-2020-12841": {"epss_score": 0.00206, "epss_percentile": 0.43069}, "CVE-2020-12842": {"epss_score": 0.00436, "epss_percentile": 0.62384}, "CVE-2020-12843": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2020-12845": {"epss_score": 0.08123, "epss_percentile": 0.91891}, "CVE-2020-12846": {"epss_score": 0.12026, "epss_percentile": 0.9355}, "CVE-2020-12847": {"epss_score": 0.01494, "epss_percentile": 0.80652}, "CVE-2020-12848": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2020-12849": {"epss_score": 0.0063, "epss_percentile": 0.69699}, "CVE-2020-12850": {"epss_score": 0.00077, "epss_percentile": 0.23531}, "CVE-2020-12851": {"epss_score": 0.01245, "epss_percentile": 0.78844}, "CVE-2020-12852": {"epss_score": 0.01409, "epss_percentile": 0.80077}, "CVE-2020-12853": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-12854": {"epss_score": 0.0277, "epss_percentile": 0.85616}, "CVE-2020-12855": {"epss_score": 0.01854, "epss_percentile": 0.82553}, "CVE-2020-12856": {"epss_score": 0.10755, "epss_percentile": 0.93094}, "CVE-2020-12857": {"epss_score": 0.00511, "epss_percentile": 0.6581}, "CVE-2020-12858": {"epss_score": 0.004, "epss_percentile": 0.60158}, "CVE-2020-12859": {"epss_score": 0.00137, "epss_percentile": 0.34316}, "CVE-2020-12860": {"epss_score": 0.00301, "epss_percentile": 0.53079}, "CVE-2020-12861": {"epss_score": 0.00588, "epss_percentile": 0.68495}, "CVE-2020-12862": {"epss_score": 0.00168, "epss_percentile": 0.3844}, "CVE-2020-12863": {"epss_score": 0.00168, "epss_percentile": 0.3844}, "CVE-2020-12864": {"epss_score": 0.00188, "epss_percentile": 0.4084}, "CVE-2020-12865": {"epss_score": 0.00295, "epss_percentile": 0.52491}, "CVE-2020-12866": {"epss_score": 0.00196, "epss_percentile": 0.41782}, "CVE-2020-12867": {"epss_score": 0.00125, "epss_percentile": 0.32586}, "CVE-2020-12869": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-12870": {"epss_score": 0.0103, "epss_percentile": 0.76843}, "CVE-2020-12872": {"epss_score": 0.00113, "epss_percentile": 0.30674}, "CVE-2020-12873": {"epss_score": 0.01446, "epss_percentile": 0.80325}, "CVE-2020-12874": {"epss_score": 0.00195, "epss_percentile": 0.41622}, "CVE-2020-12875": {"epss_score": 0.00193, "epss_percentile": 0.41441}, "CVE-2020-12876": {"epss_score": 0.00235, "epss_percentile": 0.46342}, "CVE-2020-12877": {"epss_score": 0.00354, "epss_percentile": 0.57228}, "CVE-2020-12878": {"epss_score": 0.00097, "epss_percentile": 0.27511}, "CVE-2020-12880": {"epss_score": 0.00079, "epss_percentile": 0.23828}, "CVE-2020-12882": {"epss_score": 0.00389, "epss_percentile": 0.594}, "CVE-2020-12883": {"epss_score": 0.00816, "epss_percentile": 0.73835}, "CVE-2020-12884": {"epss_score": 0.00559, "epss_percentile": 0.67626}, "CVE-2020-12885": {"epss_score": 0.00383, "epss_percentile": 0.59087}, "CVE-2020-12886": {"epss_score": 0.00559, "epss_percentile": 0.67626}, "CVE-2020-12887": {"epss_score": 0.00726, "epss_percentile": 0.72069}, "CVE-2020-12888": {"epss_score": 0.00095, "epss_percentile": 0.27241}, "CVE-2020-12889": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-12890": {"epss_score": 0.00045, "epss_percentile": 0.13794}, "CVE-2020-12891": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2020-12892": {"epss_score": 0.00075, "epss_percentile": 0.22921}, "CVE-2020-12893": {"epss_score": 0.00075, "epss_percentile": 0.23004}, "CVE-2020-12894": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12895": {"epss_score": 0.00075, "epss_percentile": 0.23004}, "CVE-2020-12897": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-12898": {"epss_score": 0.00075, "epss_percentile": 0.23004}, "CVE-2020-12899": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-12900": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-12901": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-12902": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-12903": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-12904": {"epss_score": 0.00054, "epss_percentile": 0.17191}, "CVE-2020-12905": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-12911": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2020-12912": {"epss_score": 0.00682, "epss_percentile": 0.71066}, "CVE-2020-12920": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12926": {"epss_score": 0.00044, "epss_percentile": 0.13509}, "CVE-2020-12927": {"epss_score": 0.00046, "epss_percentile": 0.14199}, "CVE-2020-12928": {"epss_score": 0.09438, "epss_percentile": 0.92548}, "CVE-2020-12929": {"epss_score": 0.00054, "epss_percentile": 0.17088}, "CVE-2020-12930": {"epss_score": 0.00128, "epss_percentile": 0.32997}, "CVE-2020-12931": {"epss_score": 0.00128, "epss_percentile": 0.32997}, "CVE-2020-12933": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2020-12944": {"epss_score": 0.00132, "epss_percentile": 0.33538}, "CVE-2020-12946": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2020-12951": {"epss_score": 0.00105, "epss_percentile": 0.29312}, "CVE-2020-12954": {"epss_score": 0.00055, "epss_percentile": 0.17525}, "CVE-2020-12960": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-12961": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12962": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-12963": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2020-12964": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-12965": {"epss_score": 0.00626, "epss_percentile": 0.69614}, "CVE-2020-12966": {"epss_score": 0.00139, "epss_percentile": 0.34544}, "CVE-2020-12967": {"epss_score": 0.01611, "epss_percentile": 0.81325}, "CVE-2020-12980": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2020-12981": {"epss_score": 0.00052, "epss_percentile": 0.16567}, "CVE-2020-12982": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2020-12983": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2020-12985": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2020-12986": {"epss_score": 0.0005, "epss_percentile": 0.15657}, "CVE-2020-12987": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2020-12988": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2020-13091": {"epss_score": 0.0048, "epss_percentile": 0.64453}, "CVE-2020-13092": {"epss_score": 0.00677, "epss_percentile": 0.70962}, "CVE-2020-13093": {"epss_score": 0.00144, "epss_percentile": 0.35266}, "CVE-2020-13094": {"epss_score": 0.01707, "epss_percentile": 0.81862}, "CVE-2020-13095": {"epss_score": 0.00578, "epss_percentile": 0.68192}, "CVE-2020-13100": {"epss_score": 0.00691, "epss_percentile": 0.71281}, "CVE-2020-13101": {"epss_score": 0.00132, "epss_percentile": 0.3351}, "CVE-2020-13109": {"epss_score": 0.02723, "epss_percentile": 0.85521}, "CVE-2020-13110": {"epss_score": 0.00068, "epss_percentile": 0.21355}, "CVE-2020-13111": {"epss_score": 0.00578, "epss_percentile": 0.68183}, "CVE-2020-13112": {"epss_score": 0.00978, "epss_percentile": 0.76234}, "CVE-2020-13113": {"epss_score": 0.00696, "epss_percentile": 0.71394}, "CVE-2020-13114": {"epss_score": 0.00774, "epss_percentile": 0.73072}, "CVE-2020-13116": {"epss_score": 0.00393, "epss_percentile": 0.59736}, "CVE-2020-13117": {"epss_score": 0.93939, "epss_percentile": 0.99872}, "CVE-2020-13118": {"epss_score": 0.03672, "epss_percentile": 0.87541}, "CVE-2020-13119": {"epss_score": 0.00303, "epss_percentile": 0.53209}, "CVE-2020-13121": {"epss_score": 0.1626, "epss_percentile": 0.94605}, "CVE-2020-13122": {"epss_score": 0.07496, "epss_percentile": 0.91502}, "CVE-2020-13124": {"epss_score": 0.09605, "epss_percentile": 0.92618}, "CVE-2020-13125": {"epss_score": 0.21581, "epss_percentile": 0.95535}, "CVE-2020-13126": {"epss_score": 0.67023, "epss_percentile": 0.9849}, "CVE-2020-13127": {"epss_score": 0.00824, "epss_percentile": 0.73939}, "CVE-2020-13128": {"epss_score": 0.00497, "epss_percentile": 0.65185}, "CVE-2020-13129": {"epss_score": 0.00423, "epss_percentile": 0.61618}, "CVE-2020-13131": {"epss_score": 0.0007, "epss_percentile": 0.21779}, "CVE-2020-13132": {"epss_score": 0.00056, "epss_percentile": 0.17734}, "CVE-2020-13133": {"epss_score": 0.01511, "epss_percentile": 0.80777}, "CVE-2020-13134": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-13135": {"epss_score": 0.00064, "epss_percentile": 0.20345}, "CVE-2020-13136": {"epss_score": 0.00235, "epss_percentile": 0.46231}, "CVE-2020-13143": {"epss_score": 0.03265, "epss_percentile": 0.86781}, "CVE-2020-13144": {"epss_score": 0.08797, "epss_percentile": 0.92258}, "CVE-2020-13145": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-13146": {"epss_score": 0.00444, "epss_percentile": 0.62819}, "CVE-2020-13149": {"epss_score": 0.00029, "epss_percentile": 0.07848}, "CVE-2020-13150": {"epss_score": 0.00042, "epss_percentile": 0.1292}, "CVE-2020-13151": {"epss_score": 0.9079, "epss_percentile": 0.996}, "CVE-2020-13152": {"epss_score": 0.01034, "epss_percentile": 0.76892}, "CVE-2020-13153": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-13154": {"epss_score": 0.00513, "epss_percentile": 0.65917}, "CVE-2020-13155": {"epss_score": 0.00159, "epss_percentile": 0.37355}, "CVE-2020-13156": {"epss_score": 0.00117, "epss_percentile": 0.31224}, "CVE-2020-13157": {"epss_score": 0.00117, "epss_percentile": 0.31224}, "CVE-2020-13158": {"epss_score": 0.92333, "epss_percentile": 0.99708}, "CVE-2020-13159": {"epss_score": 0.17647, "epss_percentile": 0.94884}, "CVE-2020-13160": {"epss_score": 0.77942, "epss_percentile": 0.9896}, "CVE-2020-13162": {"epss_score": 0.00347, "epss_percentile": 0.56759}, "CVE-2020-13163": {"epss_score": 0.00122, "epss_percentile": 0.32085}, "CVE-2020-13164": {"epss_score": 0.01829, "epss_percentile": 0.8244}, "CVE-2020-13166": {"epss_score": 0.77423, "epss_percentile": 0.98937}, "CVE-2020-13167": {"epss_score": 0.93127, "epss_percentile": 0.99777}, "CVE-2020-13168": {"epss_score": 0.00532, "epss_percentile": 0.66683}, "CVE-2020-13169": {"epss_score": 0.01534, "epss_percentile": 0.80903}, "CVE-2020-13170": {"epss_score": 0.00514, "epss_percentile": 0.65946}, "CVE-2020-13173": {"epss_score": 0.00045, "epss_percentile": 0.13706}, "CVE-2020-13174": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2020-13175": {"epss_score": 0.00296, "epss_percentile": 0.52528}, "CVE-2020-13176": {"epss_score": 0.00523, "epss_percentile": 0.66307}, "CVE-2020-13177": {"epss_score": 0.00068, "epss_percentile": 0.21237}, "CVE-2020-13178": {"epss_score": 0.00031, "epss_percentile": 0.08332}, "CVE-2020-13179": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-13183": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-13185": {"epss_score": 0.00231, "epss_percentile": 0.45769}, "CVE-2020-13186": {"epss_score": 0.0012, "epss_percentile": 0.317}, "CVE-2020-13223": {"epss_score": 0.004, "epss_percentile": 0.60152}, "CVE-2020-13224": {"epss_score": 0.01014, "epss_percentile": 0.76644}, "CVE-2020-13225": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-13226": {"epss_score": 0.00704, "epss_percentile": 0.71571}, "CVE-2020-13227": {"epss_score": 0.00526, "epss_percentile": 0.66423}, "CVE-2020-13228": {"epss_score": 0.02152, "epss_percentile": 0.83794}, "CVE-2020-13229": {"epss_score": 0.00319, "epss_percentile": 0.54568}, "CVE-2020-13230": {"epss_score": 0.00799, "epss_percentile": 0.7352}, "CVE-2020-13231": {"epss_score": 0.00456, "epss_percentile": 0.63335}, "CVE-2020-13238": {"epss_score": 0.00303, "epss_percentile": 0.53211}, "CVE-2020-13239": {"epss_score": 0.00229, "epss_percentile": 0.45607}, "CVE-2020-13240": {"epss_score": 0.00169, "epss_percentile": 0.38598}, "CVE-2020-13241": {"epss_score": 0.00049, "epss_percentile": 0.15489}, "CVE-2020-13245": {"epss_score": 0.00109, "epss_percentile": 0.29989}, "CVE-2020-13246": {"epss_score": 0.00543, "epss_percentile": 0.67113}, "CVE-2020-13247": {"epss_score": 0.00381, "epss_percentile": 0.58987}, "CVE-2020-13248": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-13249": {"epss_score": 0.00636, "epss_percentile": 0.69871}, "CVE-2020-13250": {"epss_score": 0.00867, "epss_percentile": 0.74661}, "CVE-2020-13252": {"epss_score": 0.0767, "epss_percentile": 0.91613}, "CVE-2020-13253": {"epss_score": 0.00025, "epss_percentile": 0.06298}, "CVE-2020-13254": {"epss_score": 0.08673, "epss_percentile": 0.92184}, "CVE-2020-13258": {"epss_score": 0.02668, "epss_percentile": 0.85381}, "CVE-2020-13259": {"epss_score": 0.01041, "epss_percentile": 0.76965}, "CVE-2020-13260": {"epss_score": 0.01771, "epss_percentile": 0.82198}, "CVE-2020-13261": {"epss_score": 0.00177, "epss_percentile": 0.39599}, "CVE-2020-13262": {"epss_score": 0.0021, "epss_percentile": 0.43439}, "CVE-2020-13263": {"epss_score": 0.00198, "epss_percentile": 0.42079}, "CVE-2020-13264": {"epss_score": 0.00118, "epss_percentile": 0.31455}, "CVE-2020-13265": {"epss_score": 0.00116, "epss_percentile": 0.31099}, "CVE-2020-13266": {"epss_score": 0.00055, "epss_percentile": 0.17624}, "CVE-2020-13267": {"epss_score": 0.00486, "epss_percentile": 0.64767}, "CVE-2020-13268": {"epss_score": 0.00118, "epss_percentile": 0.31455}, "CVE-2020-13269": {"epss_score": 0.00486, "epss_percentile": 0.64767}, "CVE-2020-13270": {"epss_score": 0.00358, "epss_percentile": 0.57495}, "CVE-2020-13271": {"epss_score": 0.00274, "epss_percentile": 0.50517}, "CVE-2020-13272": {"epss_score": 0.00126, "epss_percentile": 0.32774}, "CVE-2020-13273": {"epss_score": 0.00192, "epss_percentile": 0.41279}, "CVE-2020-13274": {"epss_score": 0.00178, "epss_percentile": 0.3964}, "CVE-2020-13275": {"epss_score": 0.00145, "epss_percentile": 0.35496}, "CVE-2020-13276": {"epss_score": 0.00103, "epss_percentile": 0.28958}, "CVE-2020-13277": {"epss_score": 0.04595, "epss_percentile": 0.88896}, "CVE-2020-13278": {"epss_score": 0.00664, "epss_percentile": 0.70646}, "CVE-2020-13279": {"epss_score": 0.00158, "epss_percentile": 0.37235}, "CVE-2020-13280": {"epss_score": 0.00106, "epss_percentile": 0.29557}, "CVE-2020-13281": {"epss_score": 0.00146, "epss_percentile": 0.3556}, "CVE-2020-13282": {"epss_score": 0.00148, "epss_percentile": 0.35849}, "CVE-2020-13283": {"epss_score": 0.00131, "epss_percentile": 0.33369}, "CVE-2020-13284": {"epss_score": 0.00154, "epss_percentile": 0.36725}, "CVE-2020-13285": {"epss_score": 0.00131, "epss_percentile": 0.33358}, "CVE-2020-13286": {"epss_score": 0.00139, "epss_percentile": 0.3454}, "CVE-2020-13287": {"epss_score": 0.00274, "epss_percentile": 0.50562}, "CVE-2020-13288": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2020-13289": {"epss_score": 0.00165, "epss_percentile": 0.38033}, "CVE-2020-13290": {"epss_score": 0.00181, "epss_percentile": 0.40123}, "CVE-2020-13291": {"epss_score": 0.00098, "epss_percentile": 0.27755}, "CVE-2020-13292": {"epss_score": 0.00093, "epss_percentile": 0.2669}, "CVE-2020-13293": {"epss_score": 0.0011, "epss_percentile": 0.30099}, "CVE-2020-13294": {"epss_score": 0.00268, "epss_percentile": 0.50039}, "CVE-2020-13295": {"epss_score": 0.00204, "epss_percentile": 0.42604}, "CVE-2020-13296": {"epss_score": 0.00327, "epss_percentile": 0.5514}, "CVE-2020-13297": {"epss_score": 0.00191, "epss_percentile": 0.41213}, "CVE-2020-13298": {"epss_score": 0.0032, "epss_percentile": 0.54617}, "CVE-2020-13299": {"epss_score": 0.00186, "epss_percentile": 0.4064}, "CVE-2020-13300": {"epss_score": 0.00232, "epss_percentile": 0.45929}, "CVE-2020-13301": {"epss_score": 0.00192, "epss_percentile": 0.41278}, "CVE-2020-13302": {"epss_score": 0.0022, "epss_percentile": 0.44593}, "CVE-2020-13303": {"epss_score": 0.00142, "epss_percentile": 0.34996}, "CVE-2020-13304": {"epss_score": 0.0029, "epss_percentile": 0.52117}, "CVE-2020-13305": {"epss_score": 0.00177, "epss_percentile": 0.39582}, "CVE-2020-13306": {"epss_score": 0.00159, "epss_percentile": 0.37343}, "CVE-2020-13307": {"epss_score": 0.0017, "epss_percentile": 0.38746}, "CVE-2020-13308": {"epss_score": 0.00293, "epss_percentile": 0.52309}, "CVE-2020-13309": {"epss_score": 0.00233, "epss_percentile": 0.46045}, "CVE-2020-13310": {"epss_score": 0.00312, "epss_percentile": 0.53959}, "CVE-2020-13311": {"epss_score": 0.00249, "epss_percentile": 0.48076}, "CVE-2020-13312": {"epss_score": 0.00112, "epss_percentile": 0.30476}, "CVE-2020-13313": {"epss_score": 0.00155, "epss_percentile": 0.3682}, "CVE-2020-13314": {"epss_score": 0.00275, "epss_percentile": 0.50671}, "CVE-2020-13315": {"epss_score": 0.00369, "epss_percentile": 0.58269}, "CVE-2020-13316": {"epss_score": 0.00307, "epss_percentile": 0.53487}, "CVE-2020-13317": {"epss_score": 0.00212, "epss_percentile": 0.43809}, "CVE-2020-13318": {"epss_score": 0.00129, "epss_percentile": 0.33116}, "CVE-2020-13319": {"epss_score": 0.00142, "epss_percentile": 0.34997}, "CVE-2020-13320": {"epss_score": 0.00057, "epss_percentile": 0.17983}, "CVE-2020-13321": {"epss_score": 0.00178, "epss_percentile": 0.39719}, "CVE-2020-13322": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2020-13323": {"epss_score": 0.00116, "epss_percentile": 0.31192}, "CVE-2020-13324": {"epss_score": 0.00093, "epss_percentile": 0.26631}, "CVE-2020-13325": {"epss_score": 0.00148, "epss_percentile": 0.3588}, "CVE-2020-13326": {"epss_score": 0.00077, "epss_percentile": 0.23365}, "CVE-2020-13327": {"epss_score": 0.00106, "epss_percentile": 0.29525}, "CVE-2020-13328": {"epss_score": 0.00098, "epss_percentile": 0.27817}, "CVE-2020-13329": {"epss_score": 0.00122, "epss_percentile": 0.32127}, "CVE-2020-13330": {"epss_score": 0.001, "epss_percentile": 0.28456}, "CVE-2020-13331": {"epss_score": 0.00122, "epss_percentile": 0.32113}, "CVE-2020-13333": {"epss_score": 0.00151, "epss_percentile": 0.3619}, "CVE-2020-13334": {"epss_score": 0.00174, "epss_percentile": 0.39173}, "CVE-2020-13335": {"epss_score": 0.00148, "epss_percentile": 0.3583}, "CVE-2020-13336": {"epss_score": 0.00121, "epss_percentile": 0.31959}, "CVE-2020-13337": {"epss_score": 0.0013, "epss_percentile": 0.33322}, "CVE-2020-13338": {"epss_score": 0.00091, "epss_percentile": 0.26206}, "CVE-2020-13339": {"epss_score": 0.00298, "epss_percentile": 0.52817}, "CVE-2020-13340": {"epss_score": 0.01393, "epss_percentile": 0.79967}, "CVE-2020-13341": {"epss_score": 0.00159, "epss_percentile": 0.37324}, "CVE-2020-13342": {"epss_score": 0.00128, "epss_percentile": 0.33032}, "CVE-2020-13343": {"epss_score": 0.00137, "epss_percentile": 0.34238}, "CVE-2020-13344": {"epss_score": 0.00066, "epss_percentile": 0.20882}, "CVE-2020-13345": {"epss_score": 0.00198, "epss_percentile": 0.42061}, "CVE-2020-13346": {"epss_score": 0.00127, "epss_percentile": 0.32917}, "CVE-2020-13347": {"epss_score": 0.01093, "epss_percentile": 0.77487}, "CVE-2020-13348": {"epss_score": 0.00072, "epss_percentile": 0.22327}, "CVE-2020-13349": {"epss_score": 0.00166, "epss_percentile": 0.38254}, "CVE-2020-13350": {"epss_score": 0.00146, "epss_percentile": 0.35568}, "CVE-2020-13351": {"epss_score": 0.00256, "epss_percentile": 0.4884}, "CVE-2020-13352": {"epss_score": 0.00237, "epss_percentile": 0.46648}, "CVE-2020-13353": {"epss_score": 0.00081, "epss_percentile": 0.24233}, "CVE-2020-13354": {"epss_score": 0.00562, "epss_percentile": 0.67707}, "CVE-2020-13355": {"epss_score": 0.00334, "epss_percentile": 0.55727}, "CVE-2020-13356": {"epss_score": 0.00176, "epss_percentile": 0.39491}, "CVE-2020-13357": {"epss_score": 0.00148, "epss_percentile": 0.35915}, "CVE-2020-13358": {"epss_score": 0.00047, "epss_percentile": 0.14484}, "CVE-2020-13359": {"epss_score": 0.00086, "epss_percentile": 0.25341}, "CVE-2020-13361": {"epss_score": 0.00098, "epss_percentile": 0.27637}, "CVE-2020-13362": {"epss_score": 0.00098, "epss_percentile": 0.27637}, "CVE-2020-13364": {"epss_score": 0.00235, "epss_percentile": 0.46234}, "CVE-2020-13365": {"epss_score": 0.00128, "epss_percentile": 0.32947}, "CVE-2020-13376": {"epss_score": 0.0137, "epss_percentile": 0.79802}, "CVE-2020-13377": {"epss_score": 0.00183, "epss_percentile": 0.40345}, "CVE-2020-13378": {"epss_score": 0.02072, "epss_percentile": 0.8349}, "CVE-2020-13379": {"epss_score": 0.93254, "epss_percentile": 0.99789}, "CVE-2020-13380": {"epss_score": 0.01485, "epss_percentile": 0.80601}, "CVE-2020-13381": {"epss_score": 0.36308, "epss_percentile": 0.96968}, "CVE-2020-13382": {"epss_score": 0.58623, "epss_percentile": 0.98127}, "CVE-2020-13383": {"epss_score": 0.39742, "epss_percentile": 0.97177}, "CVE-2020-13384": {"epss_score": 0.0074, "epss_percentile": 0.72401}, "CVE-2020-13386": {"epss_score": 0.00045, "epss_percentile": 0.13688}, "CVE-2020-13387": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2020-13388": {"epss_score": 0.01563, "epss_percentile": 0.81048}, "CVE-2020-13389": {"epss_score": 0.02148, "epss_percentile": 0.83774}, "CVE-2020-13390": {"epss_score": 0.02148, "epss_percentile": 0.83774}, "CVE-2020-13391": {"epss_score": 0.02148, "epss_percentile": 0.83774}, "CVE-2020-13392": {"epss_score": 0.02148, "epss_percentile": 0.83774}, "CVE-2020-13393": {"epss_score": 0.00808, "epss_percentile": 0.73697}, "CVE-2020-13394": {"epss_score": 0.01114, "epss_percentile": 0.77699}, "CVE-2020-13396": {"epss_score": 0.00501, "epss_percentile": 0.65351}, "CVE-2020-13397": {"epss_score": 0.00075, "epss_percentile": 0.22946}, "CVE-2020-13398": {"epss_score": 0.00455, "epss_percentile": 0.63315}, "CVE-2020-13401": {"epss_score": 0.1287, "epss_percentile": 0.93805}, "CVE-2020-13404": {"epss_score": 0.017, "epss_percentile": 0.81827}, "CVE-2020-13405": {"epss_score": 0.53325, "epss_percentile": 0.97871}, "CVE-2020-13407": {"epss_score": 0.00151, "epss_percentile": 0.36262}, "CVE-2020-13408": {"epss_score": 0.00151, "epss_percentile": 0.36262}, "CVE-2020-13409": {"epss_score": 0.00151, "epss_percentile": 0.36262}, "CVE-2020-13410": {"epss_score": 0.00537, "epss_percentile": 0.669}, "CVE-2020-13412": {"epss_score": 0.0013, "epss_percentile": 0.33253}, "CVE-2020-13413": {"epss_score": 0.00376, "epss_percentile": 0.58679}, "CVE-2020-13414": {"epss_score": 0.00557, "epss_percentile": 0.67545}, "CVE-2020-13415": {"epss_score": 0.00132, "epss_percentile": 0.33532}, "CVE-2020-13416": {"epss_score": 0.0019, "epss_percentile": 0.41078}, "CVE-2020-13417": {"epss_score": 0.01174, "epss_percentile": 0.78252}, "CVE-2020-13418": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-13419": {"epss_score": 0.00147, "epss_percentile": 0.35672}, "CVE-2020-13420": {"epss_score": 0.02136, "epss_percentile": 0.8373}, "CVE-2020-13421": {"epss_score": 0.00328, "epss_percentile": 0.55171}, "CVE-2020-13422": {"epss_score": 0.00146, "epss_percentile": 0.35584}, "CVE-2020-13423": {"epss_score": 0.00301, "epss_percentile": 0.53007}, "CVE-2020-13424": {"epss_score": 0.08212, "epss_percentile": 0.91932}, "CVE-2020-13425": {"epss_score": 0.0009, "epss_percentile": 0.26034}, "CVE-2020-13426": {"epss_score": 0.0044, "epss_percentile": 0.62635}, "CVE-2020-13427": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2020-13428": {"epss_score": 0.0692, "epss_percentile": 0.91117}, "CVE-2020-13429": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-13430": {"epss_score": 0.00403, "epss_percentile": 0.60329}, "CVE-2020-13431": {"epss_score": 0.00033, "epss_percentile": 0.09302}, "CVE-2020-13432": {"epss_score": 0.09309, "epss_percentile": 0.92494}, "CVE-2020-13433": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-13434": {"epss_score": 0.00055, "epss_percentile": 0.17424}, "CVE-2020-13435": {"epss_score": 0.00036, "epss_percentile": 0.10386}, "CVE-2020-13438": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2020-13439": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2020-13440": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2020-13442": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2020-13443": {"epss_score": 0.01121, "epss_percentile": 0.7777}, "CVE-2020-13444": {"epss_score": 0.00249, "epss_percentile": 0.4807}, "CVE-2020-13445": {"epss_score": 0.0371, "epss_percentile": 0.87604}, "CVE-2020-13448": {"epss_score": 0.44997, "epss_percentile": 0.97466}, "CVE-2020-13449": {"epss_score": 0.0065, "epss_percentile": 0.70244}, "CVE-2020-13450": {"epss_score": 0.01037, "epss_percentile": 0.76929}, "CVE-2020-13451": {"epss_score": 0.00578, "epss_percentile": 0.6818}, "CVE-2020-13452": {"epss_score": 0.00387, "epss_percentile": 0.59335}, "CVE-2020-13458": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2020-13459": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-13460": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2020-13461": {"epss_score": 0.00076, "epss_percentile": 0.23182}, "CVE-2020-13462": {"epss_score": 0.00079, "epss_percentile": 0.23818}, "CVE-2020-13463": {"epss_score": 0.00064, "epss_percentile": 0.20301}, "CVE-2020-13464": {"epss_score": 0.00053, "epss_percentile": 0.16712}, "CVE-2020-13465": {"epss_score": 0.00095, "epss_percentile": 0.27176}, "CVE-2020-13466": {"epss_score": 0.00054, "epss_percentile": 0.17304}, "CVE-2020-13467": {"epss_score": 0.00059, "epss_percentile": 0.18728}, "CVE-2020-13468": {"epss_score": 0.00049, "epss_percentile": 0.1543}, "CVE-2020-13469": {"epss_score": 0.00073, "epss_percentile": 0.226}, "CVE-2020-13470": {"epss_score": 0.00073, "epss_percentile": 0.226}, "CVE-2020-13471": {"epss_score": 0.00064, "epss_percentile": 0.2021}, "CVE-2020-13472": {"epss_score": 0.00073, "epss_percentile": 0.226}, "CVE-2020-13473": {"epss_score": 0.00029, "epss_percentile": 0.07786}, "CVE-2020-13474": {"epss_score": 0.00262, "epss_percentile": 0.49361}, "CVE-2020-13476": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-13480": {"epss_score": 0.00254, "epss_percentile": 0.48623}, "CVE-2020-13481": {"epss_score": 0.00139, "epss_percentile": 0.34653}, "CVE-2020-13482": {"epss_score": 0.00139, "epss_percentile": 0.34554}, "CVE-2020-13483": {"epss_score": 0.26042, "epss_percentile": 0.96102}, "CVE-2020-13484": {"epss_score": 0.00732, "epss_percentile": 0.72192}, "CVE-2020-13485": {"epss_score": 0.00307, "epss_percentile": 0.53488}, "CVE-2020-13486": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2020-13487": {"epss_score": 0.00579, "epss_percentile": 0.68215}, "CVE-2020-13493": {"epss_score": 0.00265, "epss_percentile": 0.49798}, "CVE-2020-13494": {"epss_score": 0.00224, "epss_percentile": 0.45022}, "CVE-2020-13495": {"epss_score": 0.00211, "epss_percentile": 0.43697}, "CVE-2020-13496": {"epss_score": 0.00395, "epss_percentile": 0.59836}, "CVE-2020-13497": {"epss_score": 0.00262, "epss_percentile": 0.49403}, "CVE-2020-13498": {"epss_score": 0.00262, "epss_percentile": 0.49403}, "CVE-2020-13499": {"epss_score": 0.00282, "epss_percentile": 0.51242}, "CVE-2020-13500": {"epss_score": 0.00282, "epss_percentile": 0.51242}, "CVE-2020-13501": {"epss_score": 0.00282, "epss_percentile": 0.51242}, "CVE-2020-13504": {"epss_score": 0.00453, "epss_percentile": 0.63238}, "CVE-2020-13505": {"epss_score": 0.00453, "epss_percentile": 0.63238}, "CVE-2020-13509": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2020-13510": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2020-13511": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2020-13512": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2020-13513": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2020-13514": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2020-13515": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2020-13516": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2020-13517": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2020-13518": {"epss_score": 0.00065, "epss_percentile": 0.20462}, "CVE-2020-13519": {"epss_score": 0.00136, "epss_percentile": 0.34129}, "CVE-2020-13520": {"epss_score": 0.00902, "epss_percentile": 0.75187}, "CVE-2020-13522": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2020-13523": {"epss_score": 0.00047, "epss_percentile": 0.14769}, "CVE-2020-13524": {"epss_score": 0.00411, "epss_percentile": 0.60887}, "CVE-2020-13525": {"epss_score": 0.01588, "epss_percentile": 0.81186}, "CVE-2020-13526": {"epss_score": 0.01588, "epss_percentile": 0.81186}, "CVE-2020-13527": {"epss_score": 0.00087, "epss_percentile": 0.25622}, "CVE-2020-13528": {"epss_score": 0.00687, "epss_percentile": 0.71182}, "CVE-2020-13529": {"epss_score": 0.00065, "epss_percentile": 0.20589}, "CVE-2020-13530": {"epss_score": 0.00413, "epss_percentile": 0.60958}, "CVE-2020-13531": {"epss_score": 0.01025, "epss_percentile": 0.76793}, "CVE-2020-13532": {"epss_score": 0.00052, "epss_percentile": 0.16393}, "CVE-2020-13533": {"epss_score": 0.00039, "epss_percentile": 0.1179}, "CVE-2020-13534": {"epss_score": 0.00217, "epss_percentile": 0.44332}, "CVE-2020-13535": {"epss_score": 0.00055, "epss_percentile": 0.17443}, "CVE-2020-13536": {"epss_score": 0.00032, "epss_percentile": 0.08746}, "CVE-2020-13537": {"epss_score": 0.00032, "epss_percentile": 0.08746}, "CVE-2020-13539": {"epss_score": 0.00055, "epss_percentile": 0.17452}, "CVE-2020-13540": {"epss_score": 0.00047, "epss_percentile": 0.14665}, "CVE-2020-13541": {"epss_score": 0.00052, "epss_percentile": 0.16364}, "CVE-2020-13542": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2020-13543": {"epss_score": 0.01497, "epss_percentile": 0.80689}, "CVE-2020-13544": {"epss_score": 0.00243, "epss_percentile": 0.47489}, "CVE-2020-13545": {"epss_score": 0.00396, "epss_percentile": 0.599}, "CVE-2020-13546": {"epss_score": 0.00258, "epss_percentile": 0.48975}, "CVE-2020-13547": {"epss_score": 0.01021, "epss_percentile": 0.76754}, "CVE-2020-13548": {"epss_score": 0.25714, "epss_percentile": 0.96059}, "CVE-2020-13549": {"epss_score": 0.00039, "epss_percentile": 0.11842}, "CVE-2020-13550": {"epss_score": 0.00264, "epss_percentile": 0.49739}, "CVE-2020-13551": {"epss_score": 0.00055, "epss_percentile": 0.17538}, "CVE-2020-13552": {"epss_score": 0.00055, "epss_percentile": 0.17538}, "CVE-2020-13553": {"epss_score": 0.00055, "epss_percentile": 0.17538}, "CVE-2020-13554": {"epss_score": 0.00089, "epss_percentile": 0.25811}, "CVE-2020-13555": {"epss_score": 0.00055, "epss_percentile": 0.17538}, "CVE-2020-13556": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2020-13557": {"epss_score": 0.14029, "epss_percentile": 0.94118}, "CVE-2020-13558": {"epss_score": 0.00599, "epss_percentile": 0.68789}, "CVE-2020-13559": {"epss_score": 0.0013, "epss_percentile": 0.33237}, "CVE-2020-13560": {"epss_score": 0.198, "epss_percentile": 0.95244}, "CVE-2020-13561": {"epss_score": 0.00706, "epss_percentile": 0.71609}, "CVE-2020-13562": {"epss_score": 0.19363, "epss_percentile": 0.95169}, "CVE-2020-13563": {"epss_score": 0.24941, "epss_percentile": 0.95971}, "CVE-2020-13564": {"epss_score": 0.24941, "epss_percentile": 0.95971}, "CVE-2020-13565": {"epss_score": 0.03344, "epss_percentile": 0.8695}, "CVE-2020-13566": {"epss_score": 0.00063, "epss_percentile": 0.20062}, "CVE-2020-13567": {"epss_score": 0.00054, "epss_percentile": 0.17094}, "CVE-2020-13568": {"epss_score": 0.00241, "epss_percentile": 0.47264}, "CVE-2020-13569": {"epss_score": 0.03199, "epss_percentile": 0.86617}, "CVE-2020-13570": {"epss_score": 0.05295, "epss_percentile": 0.897}, "CVE-2020-13571": {"epss_score": 0.00706, "epss_percentile": 0.71609}, "CVE-2020-13572": {"epss_score": 0.01182, "epss_percentile": 0.78315}, "CVE-2020-13573": {"epss_score": 0.0893, "epss_percentile": 0.92325}, "CVE-2020-13574": {"epss_score": 0.00153, "epss_percentile": 0.3652}, "CVE-2020-13575": {"epss_score": 0.0015, "epss_percentile": 0.36051}, "CVE-2020-13576": {"epss_score": 0.0076, "epss_percentile": 0.72813}, "CVE-2020-13577": {"epss_score": 0.00153, "epss_percentile": 0.3652}, "CVE-2020-13578": {"epss_score": 0.00153, "epss_percentile": 0.3652}, "CVE-2020-13579": {"epss_score": 0.03815, "epss_percentile": 0.87766}, "CVE-2020-13580": {"epss_score": 0.03815, "epss_percentile": 0.87766}, "CVE-2020-13581": {"epss_score": 0.00258, "epss_percentile": 0.48975}, "CVE-2020-13582": {"epss_score": 0.04904, "epss_percentile": 0.89276}, "CVE-2020-13583": {"epss_score": 0.04904, "epss_percentile": 0.89276}, "CVE-2020-13584": {"epss_score": 0.01162, "epss_percentile": 0.78151}, "CVE-2020-13585": {"epss_score": 0.00706, "epss_percentile": 0.71609}, "CVE-2020-13586": {"epss_score": 0.00312, "epss_percentile": 0.53964}, "CVE-2020-13587": {"epss_score": 0.03275, "epss_percentile": 0.86801}, "CVE-2020-13588": {"epss_score": 0.00967, "epss_percentile": 0.7607}, "CVE-2020-13589": {"epss_score": 0.00967, "epss_percentile": 0.7607}, "CVE-2020-13590": {"epss_score": 0.00875, "epss_percentile": 0.74771}, "CVE-2020-13591": {"epss_score": 0.03367, "epss_percentile": 0.87005}, "CVE-2020-13592": {"epss_score": 0.03174, "epss_percentile": 0.8656}, "CVE-2020-13593": {"epss_score": 0.00041, "epss_percentile": 0.12293}, "CVE-2020-13594": {"epss_score": 0.00152, "epss_percentile": 0.36463}, "CVE-2020-13595": {"epss_score": 0.00237, "epss_percentile": 0.46735}, "CVE-2020-13596": {"epss_score": 0.00992, "epss_percentile": 0.76398}, "CVE-2020-13597": {"epss_score": 0.00214, "epss_percentile": 0.44017}, "CVE-2020-13598": {"epss_score": 0.00057, "epss_percentile": 0.18185}, "CVE-2020-13599": {"epss_score": 0.0004, "epss_percentile": 0.11912}, "CVE-2020-13600": {"epss_score": 0.00052, "epss_percentile": 0.16342}, "CVE-2020-13601": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-13602": {"epss_score": 0.00112, "epss_percentile": 0.30505}, "CVE-2020-13603": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2020-13614": {"epss_score": 0.00576, "epss_percentile": 0.68137}, "CVE-2020-13615": {"epss_score": 0.00186, "epss_percentile": 0.40688}, "CVE-2020-13616": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2020-13617": {"epss_score": 0.00252, "epss_percentile": 0.48355}, "CVE-2020-13619": {"epss_score": 0.01216, "epss_percentile": 0.78596}, "CVE-2020-13620": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2020-13622": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2020-13623": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2020-13625": {"epss_score": 0.02741, "epss_percentile": 0.85559}, "CVE-2020-13626": {"epss_score": 0.00053, "epss_percentile": 0.16712}, "CVE-2020-13627": {"epss_score": 0.00058, "epss_percentile": 0.18467}, "CVE-2020-13628": {"epss_score": 0.00063, "epss_percentile": 0.19831}, "CVE-2020-13630": {"epss_score": 0.00076, "epss_percentile": 0.23123}, "CVE-2020-13631": {"epss_score": 0.00053, "epss_percentile": 0.16797}, "CVE-2020-13632": {"epss_score": 0.00024, "epss_percentile": 0.05901}, "CVE-2020-13633": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-13634": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2020-13637": {"epss_score": 0.00079, "epss_percentile": 0.23981}, "CVE-2020-13638": {"epss_score": 0.92196, "epss_percentile": 0.99699}, "CVE-2020-13639": {"epss_score": 0.00419, "epss_percentile": 0.61373}, "CVE-2020-13640": {"epss_score": 0.70234, "epss_percentile": 0.98624}, "CVE-2020-13641": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2020-13642": {"epss_score": 0.0012, "epss_percentile": 0.31706}, "CVE-2020-13643": {"epss_score": 0.0012, "epss_percentile": 0.31706}, "CVE-2020-13644": {"epss_score": 0.00251, "epss_percentile": 0.48273}, "CVE-2020-13645": {"epss_score": 0.0061, "epss_percentile": 0.69144}, "CVE-2020-13646": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2020-13649": {"epss_score": 0.00401, "epss_percentile": 0.60232}, "CVE-2020-13650": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2020-13651": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2020-13652": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-13653": {"epss_score": 0.02749, "epss_percentile": 0.85578}, "CVE-2020-13654": {"epss_score": 0.00096, "epss_percentile": 0.27366}, "CVE-2020-13655": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-13656": {"epss_score": 0.0126, "epss_percentile": 0.78971}, "CVE-2020-13657": {"epss_score": 0.00035, "epss_percentile": 0.09914}, "CVE-2020-13658": {"epss_score": 0.00142, "epss_percentile": 0.34992}, "CVE-2020-13659": {"epss_score": 0.00037, "epss_percentile": 0.10626}, "CVE-2020-13660": {"epss_score": 0.0031, "epss_percentile": 0.53775}, "CVE-2020-13661": {"epss_score": 0.00573, "epss_percentile": 0.68049}, "CVE-2020-13662": {"epss_score": 0.0066, "epss_percentile": 0.70536}, "CVE-2020-13663": {"epss_score": 0.0022, "epss_percentile": 0.44553}, "CVE-2020-13664": {"epss_score": 0.01962, "epss_percentile": 0.83067}, "CVE-2020-13665": {"epss_score": 0.00581, "epss_percentile": 0.68277}, "CVE-2020-13666": {"epss_score": 0.00512, "epss_percentile": 0.65864}, "CVE-2020-13667": {"epss_score": 0.00144, "epss_percentile": 0.3528}, "CVE-2020-13668": {"epss_score": 0.00617, "epss_percentile": 0.69361}, "CVE-2020-13669": {"epss_score": 0.00565, "epss_percentile": 0.67793}, "CVE-2020-13670": {"epss_score": 0.00427, "epss_percentile": 0.61823}, "CVE-2020-13671": {"epss_score": 0.04504, "epss_percentile": 0.88769}, "CVE-2020-13672": {"epss_score": 0.00766, "epss_percentile": 0.72932}, "CVE-2020-13673": {"epss_score": 0.00247, "epss_percentile": 0.47868}, "CVE-2020-13674": {"epss_score": 0.0014, "epss_percentile": 0.34783}, "CVE-2020-13675": {"epss_score": 0.00536, "epss_percentile": 0.66853}, "CVE-2020-13676": {"epss_score": 0.00285, "epss_percentile": 0.51501}, "CVE-2020-13677": {"epss_score": 0.00274, "epss_percentile": 0.50489}, "CVE-2020-13688": {"epss_score": 0.0034, "epss_percentile": 0.56241}, "CVE-2020-13692": {"epss_score": 0.06507, "epss_percentile": 0.90807}, "CVE-2020-13693": {"epss_score": 0.50401, "epss_percentile": 0.97735}, "CVE-2020-13694": {"epss_score": 0.00436, "epss_percentile": 0.6247}, "CVE-2020-13695": {"epss_score": 0.00384, "epss_percentile": 0.59141}, "CVE-2020-13696": {"epss_score": 0.00044, "epss_percentile": 0.13395}, "CVE-2020-13697": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2020-13699": {"epss_score": 0.69794, "epss_percentile": 0.98604}, "CVE-2020-13700": {"epss_score": 0.93725, "epss_percentile": 0.99837}, "CVE-2020-13702": {"epss_score": 0.00544, "epss_percentile": 0.67145}, "CVE-2020-13712": {"epss_score": 0.00127, "epss_percentile": 0.32887}, "CVE-2020-13753": {"epss_score": 0.01219, "epss_percentile": 0.78615}, "CVE-2020-13754": {"epss_score": 0.00031, "epss_percentile": 0.08323}, "CVE-2020-13756": {"epss_score": 0.26554, "epss_percentile": 0.96156}, "CVE-2020-13757": {"epss_score": 0.00083, "epss_percentile": 0.24814}, "CVE-2020-13758": {"epss_score": 0.00141, "epss_percentile": 0.34916}, "CVE-2020-13759": {"epss_score": 0.00385, "epss_percentile": 0.59197}, "CVE-2020-13760": {"epss_score": 8e-05, "epss_percentile": 0.00554}, "CVE-2020-13761": {"epss_score": 0.00226, "epss_percentile": 0.45346}, "CVE-2020-13762": {"epss_score": 0.00226, "epss_percentile": 0.45346}, "CVE-2020-13763": {"epss_score": 0.00011, "epss_percentile": 0.01068}, "CVE-2020-13764": {"epss_score": 0.00923, "epss_percentile": 0.75498}, "CVE-2020-13765": {"epss_score": 0.00371, "epss_percentile": 0.58373}, "CVE-2020-13767": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2020-13768": {"epss_score": 0.01183, "epss_percentile": 0.78327}, "CVE-2020-13769": {"epss_score": 0.0584, "epss_percentile": 0.90251}, "CVE-2020-13770": {"epss_score": 0.00105, "epss_percentile": 0.2938}, "CVE-2020-13771": {"epss_score": 0.00061, "epss_percentile": 0.19307}, "CVE-2020-13772": {"epss_score": 0.01978, "epss_percentile": 0.83131}, "CVE-2020-13773": {"epss_score": 0.00136, "epss_percentile": 0.34127}, "CVE-2020-13774": {"epss_score": 0.05174, "epss_percentile": 0.89573}, "CVE-2020-13775": {"epss_score": 0.00965, "epss_percentile": 0.76049}, "CVE-2020-13776": {"epss_score": 0.00128, "epss_percentile": 0.33015}, "CVE-2020-13777": {"epss_score": 0.01521, "epss_percentile": 0.80833}, "CVE-2020-13778": {"epss_score": 0.00937, "epss_percentile": 0.75697}, "CVE-2020-13782": {"epss_score": 0.10111, "epss_percentile": 0.92854}, "CVE-2020-13783": {"epss_score": 0.00635, "epss_percentile": 0.69824}, "CVE-2020-13784": {"epss_score": 0.01066, "epss_percentile": 0.77221}, "CVE-2020-13785": {"epss_score": 0.00342, "epss_percentile": 0.5638}, "CVE-2020-13786": {"epss_score": 0.00578, "epss_percentile": 0.68177}, "CVE-2020-13787": {"epss_score": 0.00635, "epss_percentile": 0.69824}, "CVE-2020-13788": {"epss_score": 0.002, "epss_percentile": 0.42262}, "CVE-2020-13790": {"epss_score": 0.00483, "epss_percentile": 0.64624}, "CVE-2020-13791": {"epss_score": 0.00173, "epss_percentile": 0.39052}, "CVE-2020-13792": {"epss_score": 0.00063, "epss_percentile": 0.19834}, "CVE-2020-13793": {"epss_score": 0.01408, "epss_percentile": 0.80062}, "CVE-2020-13794": {"epss_score": 0.002, "epss_percentile": 0.42262}, "CVE-2020-13795": {"epss_score": 0.00322, "epss_percentile": 0.54784}, "CVE-2020-13796": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-13797": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-13798": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-13799": {"epss_score": 0.00055, "epss_percentile": 0.17493}, "CVE-2020-13800": {"epss_score": 0.00104, "epss_percentile": 0.29215}, "CVE-2020-13802": {"epss_score": 0.01614, "epss_percentile": 0.81347}, "CVE-2020-13803": {"epss_score": 7e-05, "epss_percentile": 0.0039}, "CVE-2020-13804": {"epss_score": 0.00034, "epss_percentile": 0.09619}, "CVE-2020-13805": {"epss_score": 0.00015, "epss_percentile": 0.02364}, "CVE-2020-13806": {"epss_score": 0.00052, "epss_percentile": 0.16607}, "CVE-2020-13807": {"epss_score": 0.00021, "epss_percentile": 0.04701}, "CVE-2020-13808": {"epss_score": 0.00021, "epss_percentile": 0.04701}, "CVE-2020-13809": {"epss_score": 0.00021, "epss_percentile": 0.04701}, "CVE-2020-13810": {"epss_score": 7e-05, "epss_percentile": 0.0039}, "CVE-2020-13811": {"epss_score": 0.00119, "epss_percentile": 0.31589}, "CVE-2020-13812": {"epss_score": 0.00015, "epss_percentile": 0.02518}, "CVE-2020-13813": {"epss_score": 0.00015, "epss_percentile": 0.02518}, "CVE-2020-13814": {"epss_score": 0.00027, "epss_percentile": 0.06817}, "CVE-2020-13815": {"epss_score": 0.00018, "epss_percentile": 0.03636}, "CVE-2020-13817": {"epss_score": 0.00348, "epss_percentile": 0.56806}, "CVE-2020-13818": {"epss_score": 0.76573, "epss_percentile": 0.98896}, "CVE-2020-13819": {"epss_score": 0.00451, "epss_percentile": 0.6315}, "CVE-2020-13820": {"epss_score": 0.17063, "epss_percentile": 0.94768}, "CVE-2020-13821": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-13822": {"epss_score": 0.00187, "epss_percentile": 0.40732}, "CVE-2020-13825": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2020-13826": {"epss_score": 0.00692, "epss_percentile": 0.71299}, "CVE-2020-13827": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-13828": {"epss_score": 0.00132, "epss_percentile": 0.33609}, "CVE-2020-13829": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2020-13830": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2020-13831": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-13832": {"epss_score": 0.00187, "epss_percentile": 0.40754}, "CVE-2020-13833": {"epss_score": 0.00141, "epss_percentile": 0.3495}, "CVE-2020-13834": {"epss_score": 0.00081, "epss_percentile": 0.24322}, "CVE-2020-13835": {"epss_score": 0.00117, "epss_percentile": 0.31311}, "CVE-2020-13836": {"epss_score": 0.00163, "epss_percentile": 0.37857}, "CVE-2020-13837": {"epss_score": 0.00017, "epss_percentile": 0.03447}, "CVE-2020-13838": {"epss_score": 0.00017, "epss_percentile": 0.03447}, "CVE-2020-13839": {"epss_score": 0.00231, "epss_percentile": 0.45794}, "CVE-2020-13840": {"epss_score": 0.00222, "epss_percentile": 0.44756}, "CVE-2020-13841": {"epss_score": 0.00161, "epss_percentile": 0.37551}, "CVE-2020-13842": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2020-13843": {"epss_score": 0.00015, "epss_percentile": 0.02148}, "CVE-2020-13844": {"epss_score": 0.00079, "epss_percentile": 0.23978}, "CVE-2020-13845": {"epss_score": 0.00079, "epss_percentile": 0.23828}, "CVE-2020-13846": {"epss_score": 0.00368, "epss_percentile": 0.58216}, "CVE-2020-13847": {"epss_score": 0.00189, "epss_percentile": 0.40966}, "CVE-2020-13848": {"epss_score": 0.03242, "epss_percentile": 0.86735}, "CVE-2020-13849": {"epss_score": 0.00829, "epss_percentile": 0.74009}, "CVE-2020-13850": {"epss_score": 0.00756, "epss_percentile": 0.72733}, "CVE-2020-13851": {"epss_score": 0.93877, "epss_percentile": 0.99862}, "CVE-2020-13852": {"epss_score": 0.37446, "epss_percentile": 0.97048}, "CVE-2020-13853": {"epss_score": 0.00291, "epss_percentile": 0.52165}, "CVE-2020-13854": {"epss_score": 0.00327, "epss_percentile": 0.55097}, "CVE-2020-13855": {"epss_score": 0.37446, "epss_percentile": 0.97048}, "CVE-2020-13856": {"epss_score": 0.0029, "epss_percentile": 0.52128}, "CVE-2020-13857": {"epss_score": 0.00368, "epss_percentile": 0.58187}, "CVE-2020-13858": {"epss_score": 0.00492, "epss_percentile": 0.64985}, "CVE-2020-13859": {"epss_score": 0.0034, "epss_percentile": 0.56277}, "CVE-2020-13860": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-13863": {"epss_score": 0.00688, "epss_percentile": 0.71201}, "CVE-2020-13864": {"epss_score": 0.00128, "epss_percentile": 0.3301}, "CVE-2020-13865": {"epss_score": 0.00128, "epss_percentile": 0.3301}, "CVE-2020-13866": {"epss_score": 0.00256, "epss_percentile": 0.48785}, "CVE-2020-13867": {"epss_score": 0.00069, "epss_percentile": 0.21549}, "CVE-2020-13868": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2020-13869": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-13870": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-13871": {"epss_score": 0.02437, "epss_percentile": 0.84742}, "CVE-2020-13872": {"epss_score": 0.00645, "epss_percentile": 0.70119}, "CVE-2020-13873": {"epss_score": 0.12775, "epss_percentile": 0.9377}, "CVE-2020-13877": {"epss_score": 0.02153, "epss_percentile": 0.83795}, "CVE-2020-13878": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2020-13879": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2020-13880": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2020-13881": {"epss_score": 0.01239, "epss_percentile": 0.78797}, "CVE-2020-13882": {"epss_score": 0.00046, "epss_percentile": 0.14074}, "CVE-2020-13883": {"epss_score": 0.00279, "epss_percentile": 0.50956}, "CVE-2020-13884": {"epss_score": 0.0006, "epss_percentile": 0.19209}, "CVE-2020-13885": {"epss_score": 0.00163, "epss_percentile": 0.37768}, "CVE-2020-13886": {"epss_score": 0.01809, "epss_percentile": 0.82358}, "CVE-2020-13887": {"epss_score": 0.01707, "epss_percentile": 0.81861}, "CVE-2020-13888": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-13889": {"epss_score": 0.01693, "epss_percentile": 0.81794}, "CVE-2020-13890": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-13891": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-13892": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2020-13893": {"epss_score": 0.00393, "epss_percentile": 0.59736}, "CVE-2020-13894": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2020-13895": {"epss_score": 0.00185, "epss_percentile": 0.40574}, "CVE-2020-13896": {"epss_score": 0.02446, "epss_percentile": 0.84769}, "CVE-2020-13897": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-13898": {"epss_score": 0.0065, "epss_percentile": 0.70246}, "CVE-2020-13899": {"epss_score": 0.00452, "epss_percentile": 0.63199}, "CVE-2020-13900": {"epss_score": 0.0065, "epss_percentile": 0.70246}, "CVE-2020-13901": {"epss_score": 0.00703, "epss_percentile": 0.71533}, "CVE-2020-13902": {"epss_score": 0.00278, "epss_percentile": 0.5087}, "CVE-2020-13904": {"epss_score": 0.00475, "epss_percentile": 0.64173}, "CVE-2020-13905": {"epss_score": 0.00499, "epss_percentile": 0.65253}, "CVE-2020-13906": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2020-13909": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-13910": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-13911": {"epss_score": 0.0042, "epss_percentile": 0.61413}, "CVE-2020-13912": {"epss_score": 0.00728, "epss_percentile": 0.72115}, "CVE-2020-13913": {"epss_score": 0.00168, "epss_percentile": 0.38502}, "CVE-2020-13914": {"epss_score": 0.01278, "epss_percentile": 0.79125}, "CVE-2020-13915": {"epss_score": 0.00612, "epss_percentile": 0.69215}, "CVE-2020-13916": {"epss_score": 0.01165, "epss_percentile": 0.78174}, "CVE-2020-13917": {"epss_score": 0.01254, "epss_percentile": 0.7892}, "CVE-2020-13918": {"epss_score": 0.00596, "epss_percentile": 0.68722}, "CVE-2020-13919": {"epss_score": 0.00766, "epss_percentile": 0.72931}, "CVE-2020-13920": {"epss_score": 0.00153, "epss_percentile": 0.36536}, "CVE-2020-13921": {"epss_score": 0.06111, "epss_percentile": 0.90488}, "CVE-2020-13922": {"epss_score": 0.00831, "epss_percentile": 0.74042}, "CVE-2020-13923": {"epss_score": 0.02534, "epss_percentile": 0.85034}, "CVE-2020-13924": {"epss_score": 0.0084, "epss_percentile": 0.74203}, "CVE-2020-13925": {"epss_score": 0.84701, "epss_percentile": 0.99302}, "CVE-2020-13926": {"epss_score": 0.03106, "epss_percentile": 0.86419}, "CVE-2020-13927": {"epss_score": 0.94186, "epss_percentile": 0.99914}, "CVE-2020-13928": {"epss_score": 0.01889, "epss_percentile": 0.82723}, "CVE-2020-13929": {"epss_score": 0.00091, "epss_percentile": 0.26255}, "CVE-2020-13931": {"epss_score": 0.01368, "epss_percentile": 0.79787}, "CVE-2020-13932": {"epss_score": 0.02552, "epss_percentile": 0.85079}, "CVE-2020-13933": {"epss_score": 0.69494, "epss_percentile": 0.9859}, "CVE-2020-13934": {"epss_score": 0.2338, "epss_percentile": 0.95772}, "CVE-2020-13935": {"epss_score": 0.92155, "epss_percentile": 0.99694}, "CVE-2020-13936": {"epss_score": 0.16401, "epss_percentile": 0.94646}, "CVE-2020-13937": {"epss_score": 0.93845, "epss_percentile": 0.99856}, "CVE-2020-13938": {"epss_score": 0.00077, "epss_percentile": 0.23294}, "CVE-2020-13940": {"epss_score": 0.01636, "epss_percentile": 0.81477}, "CVE-2020-13941": {"epss_score": 0.02798, "epss_percentile": 0.85688}, "CVE-2020-13942": {"epss_score": 0.9432, "epss_percentile": 0.99946}, "CVE-2020-13943": {"epss_score": 0.09572, "epss_percentile": 0.92605}, "CVE-2020-13944": {"epss_score": 0.17227, "epss_percentile": 0.94802}, "CVE-2020-13945": {"epss_score": 0.93434, "epss_percentile": 0.99806}, "CVE-2020-13946": {"epss_score": 0.00472, "epss_percentile": 0.64036}, "CVE-2020-13947": {"epss_score": 0.08017, "epss_percentile": 0.91832}, "CVE-2020-13948": {"epss_score": 0.00732, "epss_percentile": 0.72194}, "CVE-2020-13949": {"epss_score": 0.00819, "epss_percentile": 0.73874}, "CVE-2020-13950": {"epss_score": 0.20842, "epss_percentile": 0.95422}, "CVE-2020-13951": {"epss_score": 0.73759, "epss_percentile": 0.98771}, "CVE-2020-13952": {"epss_score": 0.00122, "epss_percentile": 0.32146}, "CVE-2020-13953": {"epss_score": 0.01797, "epss_percentile": 0.82311}, "CVE-2020-13954": {"epss_score": 0.08034, "epss_percentile": 0.91845}, "CVE-2020-13955": {"epss_score": 0.00784, "epss_percentile": 0.73243}, "CVE-2020-13956": {"epss_score": 0.00505, "epss_percentile": 0.65553}, "CVE-2020-13957": {"epss_score": 0.84821, "epss_percentile": 0.99306}, "CVE-2020-13958": {"epss_score": 0.01017, "epss_percentile": 0.76695}, "CVE-2020-13959": {"epss_score": 0.03207, "epss_percentile": 0.86638}, "CVE-2020-13960": {"epss_score": 0.00429, "epss_percentile": 0.61978}, "CVE-2020-13961": {"epss_score": 0.00622, "epss_percentile": 0.69499}, "CVE-2020-13962": {"epss_score": 0.01567, "epss_percentile": 0.81074}, "CVE-2020-13963": {"epss_score": 0.00539, "epss_percentile": 0.66967}, "CVE-2020-13964": {"epss_score": 0.00872, "epss_percentile": 0.74727}, "CVE-2020-13965": {"epss_score": 0.82687, "epss_percentile": 0.99207}, "CVE-2020-13968": {"epss_score": 0.00779, "epss_percentile": 0.73141}, "CVE-2020-13969": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-13970": {"epss_score": 0.00357, "epss_percentile": 0.57428}, "CVE-2020-13971": {"epss_score": 0.00307, "epss_percentile": 0.53531}, "CVE-2020-13972": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-13973": {"epss_score": 0.00468, "epss_percentile": 0.6388}, "CVE-2020-13974": {"epss_score": 0.00056, "epss_percentile": 0.17755}, "CVE-2020-13976": {"epss_score": 0.00763, "epss_percentile": 0.72884}, "CVE-2020-13977": {"epss_score": 0.01872, "epss_percentile": 0.8264}, "CVE-2020-13978": {"epss_score": 0.00435, "epss_percentile": 0.62368}, "CVE-2020-13980": {"epss_score": 0.00252, "epss_percentile": 0.48411}, "CVE-2020-13984": {"epss_score": 0.00447, "epss_percentile": 0.62961}, "CVE-2020-13985": {"epss_score": 0.00548, "epss_percentile": 0.67276}, "CVE-2020-13986": {"epss_score": 0.0032, "epss_percentile": 0.54637}, "CVE-2020-13987": {"epss_score": 0.00186, "epss_percentile": 0.4066}, "CVE-2020-13988": {"epss_score": 0.00192, "epss_percentile": 0.41278}, "CVE-2020-13991": {"epss_score": 0.01107, "epss_percentile": 0.77621}, "CVE-2020-13992": {"epss_score": 0.00644, "epss_percentile": 0.70076}, "CVE-2020-13993": {"epss_score": 0.00566, "epss_percentile": 0.67827}, "CVE-2020-13994": {"epss_score": 0.04581, "epss_percentile": 0.88877}, "CVE-2020-13995": {"epss_score": 0.03742, "epss_percentile": 0.87658}, "CVE-2020-13996": {"epss_score": 0.01148, "epss_percentile": 0.78012}, "CVE-2020-13997": {"epss_score": 0.01045, "epss_percentile": 0.77019}, "CVE-2020-13998": {"epss_score": 0.01642, "epss_percentile": 0.81512}, "CVE-2020-13999": {"epss_score": 0.0033, "epss_percentile": 0.55487}, "CVE-2020-14000": {"epss_score": 0.06601, "epss_percentile": 0.90879}, "CVE-2020-14001": {"epss_score": 0.09348, "epss_percentile": 0.92511}, "CVE-2020-14002": {"epss_score": 0.00475, "epss_percentile": 0.64242}, "CVE-2020-14004": {"epss_score": 0.00319, "epss_percentile": 0.54572}, "CVE-2020-14005": {"epss_score": 0.11406, "epss_percentile": 0.93338}, "CVE-2020-14006": {"epss_score": 0.01059, "epss_percentile": 0.7716}, "CVE-2020-14007": {"epss_score": 0.01059, "epss_percentile": 0.7716}, "CVE-2020-14008": {"epss_score": 0.45043, "epss_percentile": 0.97469}, "CVE-2020-14009": {"epss_score": 0.00089, "epss_percentile": 0.25803}, "CVE-2020-14010": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2020-14011": {"epss_score": 0.3383, "epss_percentile": 0.96807}, "CVE-2020-14012": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-14014": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-14015": {"epss_score": 0.00245, "epss_percentile": 0.47672}, "CVE-2020-14016": {"epss_score": 0.00393, "epss_percentile": 0.59701}, "CVE-2020-14017": {"epss_score": 0.00387, "epss_percentile": 0.59293}, "CVE-2020-14018": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2020-14019": {"epss_score": 0.00103, "epss_percentile": 0.29017}, "CVE-2020-14021": {"epss_score": 0.00401, "epss_percentile": 0.60255}, "CVE-2020-14022": {"epss_score": 0.00794, "epss_percentile": 0.7345}, "CVE-2020-14023": {"epss_score": 0.00367, "epss_percentile": 0.58116}, "CVE-2020-14024": {"epss_score": 0.00389, "epss_percentile": 0.59452}, "CVE-2020-14025": {"epss_score": 0.00167, "epss_percentile": 0.38369}, "CVE-2020-14026": {"epss_score": 0.01031, "epss_percentile": 0.76854}, "CVE-2020-14027": {"epss_score": 0.00482, "epss_percentile": 0.64556}, "CVE-2020-14028": {"epss_score": 0.01091, "epss_percentile": 0.77456}, "CVE-2020-14029": {"epss_score": 0.00433, "epss_percentile": 0.62177}, "CVE-2020-14030": {"epss_score": 0.03001, "epss_percentile": 0.86168}, "CVE-2020-14031": {"epss_score": 0.00751, "epss_percentile": 0.72641}, "CVE-2020-14032": {"epss_score": 0.01179, "epss_percentile": 0.78296}, "CVE-2020-14033": {"epss_score": 0.00775, "epss_percentile": 0.73081}, "CVE-2020-14034": {"epss_score": 0.00717, "epss_percentile": 0.71881}, "CVE-2020-14039": {"epss_score": 0.0041, "epss_percentile": 0.60845}, "CVE-2020-14040": {"epss_score": 8e-05, "epss_percentile": 0.00473}, "CVE-2020-14042": {"epss_score": 0.00458, "epss_percentile": 0.63442}, "CVE-2020-14043": {"epss_score": 0.00397, "epss_percentile": 0.59965}, "CVE-2020-14044": {"epss_score": 0.02395, "epss_percentile": 0.84615}, "CVE-2020-14048": {"epss_score": 0.2501, "epss_percentile": 0.95978}, "CVE-2020-14049": {"epss_score": 0.00548, "epss_percentile": 0.67266}, "CVE-2020-14054": {"epss_score": 0.00582, "epss_percentile": 0.68309}, "CVE-2020-14055": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-14056": {"epss_score": 0.00492, "epss_percentile": 0.64985}, "CVE-2020-14057": {"epss_score": 0.03074, "epss_percentile": 0.86355}, "CVE-2020-14058": {"epss_score": 0.00426, "epss_percentile": 0.61767}, "CVE-2020-14059": {"epss_score": 0.04216, "epss_percentile": 0.88407}, "CVE-2020-14060": {"epss_score": 0.08718, "epss_percentile": 0.92225}, "CVE-2020-14061": {"epss_score": 0.0615, "epss_percentile": 0.90521}, "CVE-2020-14062": {"epss_score": 0.07706, "epss_percentile": 0.91637}, "CVE-2020-14063": {"epss_score": 0.00604, "epss_percentile": 0.68951}, "CVE-2020-14064": {"epss_score": 0.00671, "epss_percentile": 0.70807}, "CVE-2020-14065": {"epss_score": 0.0232, "epss_percentile": 0.84366}, "CVE-2020-14066": {"epss_score": 0.02942, "epss_percentile": 0.86035}, "CVE-2020-14067": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-14068": {"epss_score": 0.0095, "epss_percentile": 0.75857}, "CVE-2020-14069": {"epss_score": 0.00137, "epss_percentile": 0.34257}, "CVE-2020-14070": {"epss_score": 0.00354, "epss_percentile": 0.5723}, "CVE-2020-14071": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-14072": {"epss_score": 0.02747, "epss_percentile": 0.85574}, "CVE-2020-14073": {"epss_score": 0.00454, "epss_percentile": 0.63256}, "CVE-2020-14074": {"epss_score": 0.0385, "epss_percentile": 0.87845}, "CVE-2020-14075": {"epss_score": 0.12273, "epss_percentile": 0.93619}, "CVE-2020-14076": {"epss_score": 0.06399, "epss_percentile": 0.90726}, "CVE-2020-14077": {"epss_score": 0.03384, "epss_percentile": 0.87038}, "CVE-2020-14078": {"epss_score": 0.0385, "epss_percentile": 0.87845}, "CVE-2020-14079": {"epss_score": 0.04895, "epss_percentile": 0.89269}, "CVE-2020-14080": {"epss_score": 0.03756, "epss_percentile": 0.87681}, "CVE-2020-14081": {"epss_score": 0.07475, "epss_percentile": 0.91492}, "CVE-2020-14092": {"epss_score": 0.85956, "epss_percentile": 0.99357}, "CVE-2020-14093": {"epss_score": 0.03861, "epss_percentile": 0.87866}, "CVE-2020-14094": {"epss_score": 0.02368, "epss_percentile": 0.84519}, "CVE-2020-14095": {"epss_score": 0.02219, "epss_percentile": 0.84043}, "CVE-2020-14096": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2020-14097": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-14098": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-14099": {"epss_score": 0.00148, "epss_percentile": 0.35914}, "CVE-2020-14100": {"epss_score": 0.01836, "epss_percentile": 0.82473}, "CVE-2020-14101": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-14102": {"epss_score": 0.02395, "epss_percentile": 0.84614}, "CVE-2020-14103": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2020-14104": {"epss_score": 0.0039, "epss_percentile": 0.59538}, "CVE-2020-14105": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-14106": {"epss_score": 0.00231, "epss_percentile": 0.45802}, "CVE-2020-14107": {"epss_score": 0.00419, "epss_percentile": 0.614}, "CVE-2020-14109": {"epss_score": 0.00962, "epss_percentile": 0.75994}, "CVE-2020-14110": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2020-14111": {"epss_score": 0.00042, "epss_percentile": 0.12928}, "CVE-2020-14112": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2020-14114": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-14115": {"epss_score": 0.00737, "epss_percentile": 0.72331}, "CVE-2020-14116": {"epss_score": 0.00113, "epss_percentile": 0.30687}, "CVE-2020-14117": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-14118": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2020-14119": {"epss_score": 0.0381, "epss_percentile": 0.87759}, "CVE-2020-14120": {"epss_score": 0.00142, "epss_percentile": 0.34977}, "CVE-2020-14121": {"epss_score": 0.00047, "epss_percentile": 0.14806}, "CVE-2020-14122": {"epss_score": 0.00028, "epss_percentile": 0.07498}, "CVE-2020-14123": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-14124": {"epss_score": 0.00679, "epss_percentile": 0.71016}, "CVE-2020-14125": {"epss_score": 0.00393, "epss_percentile": 0.59739}, "CVE-2020-14126": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-14127": {"epss_score": 0.00639, "epss_percentile": 0.69948}, "CVE-2020-14129": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2020-14130": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-14131": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2020-14140": {"epss_score": 0.00357, "epss_percentile": 0.57454}, "CVE-2020-14144": {"epss_score": 0.93388, "epss_percentile": 0.99803}, "CVE-2020-14145": {"epss_score": 0.01254, "epss_percentile": 0.78921}, "CVE-2020-14146": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-14147": {"epss_score": 0.00271, "epss_percentile": 0.5032}, "CVE-2020-14148": {"epss_score": 0.01815, "epss_percentile": 0.82384}, "CVE-2020-14149": {"epss_score": 0.00564, "epss_percentile": 0.67778}, "CVE-2020-14150": {"epss_score": 0.00102, "epss_percentile": 0.28762}, "CVE-2020-14152": {"epss_score": 0.00981, "epss_percentile": 0.76283}, "CVE-2020-14153": {"epss_score": 0.00369, "epss_percentile": 0.58246}, "CVE-2020-14154": {"epss_score": 0.00661, "epss_percentile": 0.70586}, "CVE-2020-14155": {"epss_score": 0.0023, "epss_percentile": 0.45683}, "CVE-2020-14156": {"epss_score": 0.00313, "epss_percentile": 0.54024}, "CVE-2020-14157": {"epss_score": 0.00098, "epss_percentile": 0.27675}, "CVE-2020-14158": {"epss_score": 0.0037, "epss_percentile": 0.58313}, "CVE-2020-14159": {"epss_score": 0.0078, "epss_percentile": 0.73169}, "CVE-2020-14160": {"epss_score": 0.00526, "epss_percentile": 0.66403}, "CVE-2020-14161": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2020-14162": {"epss_score": 0.00115, "epss_percentile": 0.30903}, "CVE-2020-14163": {"epss_score": 0.00399, "epss_percentile": 0.60121}, "CVE-2020-14164": {"epss_score": 0.00389, "epss_percentile": 0.59458}, "CVE-2020-14165": {"epss_score": 0.00297, "epss_percentile": 0.52709}, "CVE-2020-14166": {"epss_score": 0.0076, "epss_percentile": 0.72818}, "CVE-2020-14167": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2020-14168": {"epss_score": 0.00328, "epss_percentile": 0.55275}, "CVE-2020-14169": {"epss_score": 0.00334, "epss_percentile": 0.55795}, "CVE-2020-14170": {"epss_score": 0.00198, "epss_percentile": 0.42078}, "CVE-2020-14171": {"epss_score": 0.00308, "epss_percentile": 0.53616}, "CVE-2020-14172": {"epss_score": 0.04634, "epss_percentile": 0.88947}, "CVE-2020-14173": {"epss_score": 0.00231, "epss_percentile": 0.45831}, "CVE-2020-14174": {"epss_score": 0.00139, "epss_percentile": 0.34591}, "CVE-2020-14175": {"epss_score": 0.0028, "epss_percentile": 0.51017}, "CVE-2020-14177": {"epss_score": 0.00832, "epss_percentile": 0.74071}, "CVE-2020-14178": {"epss_score": 0.00576, "epss_percentile": 0.68124}, "CVE-2020-14179": {"epss_score": 0.92855, "epss_percentile": 0.99755}, "CVE-2020-14180": {"epss_score": 0.00229, "epss_percentile": 0.45623}, "CVE-2020-14181": {"epss_score": 0.93124, "epss_percentile": 0.99777}, "CVE-2020-14183": {"epss_score": 0.00312, "epss_percentile": 0.53968}, "CVE-2020-14184": {"epss_score": 0.00228, "epss_percentile": 0.45471}, "CVE-2020-14185": {"epss_score": 0.00279, "epss_percentile": 0.50986}, "CVE-2020-14188": {"epss_score": 0.02136, "epss_percentile": 0.8373}, "CVE-2020-14189": {"epss_score": 0.02136, "epss_percentile": 0.8373}, "CVE-2020-14190": {"epss_score": 0.00816, "epss_percentile": 0.73827}, "CVE-2020-14191": {"epss_score": 0.00816, "epss_percentile": 0.73827}, "CVE-2020-14192": {"epss_score": 0.00196, "epss_percentile": 0.4179}, "CVE-2020-14193": {"epss_score": 0.00206, "epss_percentile": 0.42931}, "CVE-2020-14194": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2020-14195": {"epss_score": 0.09511, "epss_percentile": 0.92578}, "CVE-2020-14196": {"epss_score": 0.00025, "epss_percentile": 0.06061}, "CVE-2020-14198": {"epss_score": 0.02212, "epss_percentile": 0.84016}, "CVE-2020-14199": {"epss_score": 0.0018, "epss_percentile": 0.39979}, "CVE-2020-14201": {"epss_score": 0.00146, "epss_percentile": 0.35584}, "CVE-2020-14202": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-14203": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2020-14204": {"epss_score": 0.00491, "epss_percentile": 0.64965}, "CVE-2020-14205": {"epss_score": 0.00214, "epss_percentile": 0.43965}, "CVE-2020-14206": {"epss_score": 0.00362, "epss_percentile": 0.57765}, "CVE-2020-14207": {"epss_score": 0.01788, "epss_percentile": 0.82263}, "CVE-2020-14208": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2020-14209": {"epss_score": 0.09687, "epss_percentile": 0.92662}, "CVE-2020-14210": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2020-14212": {"epss_score": 0.00637, "epss_percentile": 0.69894}, "CVE-2020-14213": {"epss_score": 0.00144, "epss_percentile": 0.35321}, "CVE-2020-14214": {"epss_score": 0.00186, "epss_percentile": 0.40659}, "CVE-2020-14215": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2020-14221": {"epss_score": 0.00335, "epss_percentile": 0.55895}, "CVE-2020-14222": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-14223": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-14224": {"epss_score": 0.01673, "epss_percentile": 0.81689}, "CVE-2020-14225": {"epss_score": 0.00555, "epss_percentile": 0.67479}, "CVE-2020-14230": {"epss_score": 0.00387, "epss_percentile": 0.59299}, "CVE-2020-14231": {"epss_score": 0.00632, "epss_percentile": 0.69744}, "CVE-2020-14232": {"epss_score": 0.00843, "epss_percentile": 0.74253}, "CVE-2020-14234": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2020-14240": {"epss_score": 0.00322, "epss_percentile": 0.54815}, "CVE-2020-14244": {"epss_score": 0.01673, "epss_percentile": 0.81689}, "CVE-2020-14245": {"epss_score": 0.00392, "epss_percentile": 0.59657}, "CVE-2020-14246": {"epss_score": 0.0014, "epss_percentile": 0.34777}, "CVE-2020-14247": {"epss_score": 0.00186, "epss_percentile": 0.40659}, "CVE-2020-14248": {"epss_score": 0.00131, "epss_percentile": 0.33446}, "CVE-2020-14254": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2020-14255": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-14258": {"epss_score": 0.00387, "epss_percentile": 0.59299}, "CVE-2020-14260": {"epss_score": 0.00477, "epss_percentile": 0.64345}, "CVE-2020-14263": {"epss_score": 0.00055, "epss_percentile": 0.17652}, "CVE-2020-14264": {"epss_score": 0.00031, "epss_percentile": 0.08414}, "CVE-2020-14268": {"epss_score": 0.01673, "epss_percentile": 0.81689}, "CVE-2020-14270": {"epss_score": 0.00319, "epss_percentile": 0.54552}, "CVE-2020-14271": {"epss_score": 0.00766, "epss_percentile": 0.72942}, "CVE-2020-14273": {"epss_score": 0.00688, "epss_percentile": 0.71204}, "CVE-2020-14274": {"epss_score": 0.00312, "epss_percentile": 0.53936}, "CVE-2020-14275": {"epss_score": 0.00472, "epss_percentile": 0.64045}, "CVE-2020-14292": {"epss_score": 0.00258, "epss_percentile": 0.48981}, "CVE-2020-14293": {"epss_score": 0.28802, "epss_percentile": 0.96386}, "CVE-2020-14294": {"epss_score": 0.00615, "epss_percentile": 0.69306}, "CVE-2020-14295": {"epss_score": 0.81199, "epss_percentile": 0.99127}, "CVE-2020-14296": {"epss_score": 0.00152, "epss_percentile": 0.36418}, "CVE-2020-14297": {"epss_score": 0.00384, "epss_percentile": 0.59142}, "CVE-2020-14298": {"epss_score": 0.00142, "epss_percentile": 0.3499}, "CVE-2020-14299": {"epss_score": 0.00096, "epss_percentile": 0.27372}, "CVE-2020-14300": {"epss_score": 0.00287, "epss_percentile": 0.51859}, "CVE-2020-14301": {"epss_score": 0.00375, "epss_percentile": 0.58629}, "CVE-2020-14302": {"epss_score": 0.00154, "epss_percentile": 0.3671}, "CVE-2020-14303": {"epss_score": 0.26119, "epss_percentile": 0.96115}, "CVE-2020-14304": {"epss_score": 0.0006, "epss_percentile": 0.19158}, "CVE-2020-14305": {"epss_score": 0.01048, "epss_percentile": 0.77057}, "CVE-2020-14306": {"epss_score": 0.0029, "epss_percentile": 0.52117}, "CVE-2020-14307": {"epss_score": 0.00415, "epss_percentile": 0.61139}, "CVE-2020-14308": {"epss_score": 0.00044, "epss_percentile": 0.13593}, "CVE-2020-14309": {"epss_score": 0.00045, "epss_percentile": 0.13808}, "CVE-2020-14310": {"epss_score": 0.00054, "epss_percentile": 0.17229}, "CVE-2020-14311": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2020-14312": {"epss_score": 0.00112, "epss_percentile": 0.30538}, "CVE-2020-14313": {"epss_score": 0.00189, "epss_percentile": 0.40999}, "CVE-2020-14314": {"epss_score": 0.00055, "epss_percentile": 0.17545}, "CVE-2020-14315": {"epss_score": 0.00466, "epss_percentile": 0.63805}, "CVE-2020-14316": {"epss_score": 0.00393, "epss_percentile": 0.59715}, "CVE-2020-14317": {"epss_score": 0.0003, "epss_percentile": 0.07984}, "CVE-2020-14318": {"epss_score": 0.00145, "epss_percentile": 0.35377}, "CVE-2020-14319": {"epss_score": 0.00102, "epss_percentile": 0.28814}, "CVE-2020-14320": {"epss_score": 0.00753, "epss_percentile": 0.72669}, "CVE-2020-14321": {"epss_score": 0.38813, "epss_percentile": 0.97121}, "CVE-2020-14322": {"epss_score": 0.00548, "epss_percentile": 0.6727}, "CVE-2020-14323": {"epss_score": 0.00388, "epss_percentile": 0.59364}, "CVE-2020-14324": {"epss_score": 0.01127, "epss_percentile": 0.77821}, "CVE-2020-14325": {"epss_score": 0.00241, "epss_percentile": 0.47235}, "CVE-2020-14326": {"epss_score": 0.00499, "epss_percentile": 0.65256}, "CVE-2020-14327": {"epss_score": 0.00039, "epss_percentile": 0.1155}, "CVE-2020-14328": {"epss_score": 0.00035, "epss_percentile": 0.09988}, "CVE-2020-14329": {"epss_score": 0.00041, "epss_percentile": 0.12282}, "CVE-2020-14330": {"epss_score": 0.00123, "epss_percentile": 0.32191}, "CVE-2020-14331": {"epss_score": 0.00032, "epss_percentile": 0.09072}, "CVE-2020-14332": {"epss_score": 0.00137, "epss_percentile": 0.34235}, "CVE-2020-14333": {"epss_score": 0.00294, "epss_percentile": 0.52439}, "CVE-2020-14334": {"epss_score": 0.00201, "epss_percentile": 0.42333}, "CVE-2020-14335": {"epss_score": 0.00103, "epss_percentile": 0.28977}, "CVE-2020-14336": {"epss_score": 0.00329, "epss_percentile": 0.55378}, "CVE-2020-14337": {"epss_score": 0.00875, "epss_percentile": 0.74778}, "CVE-2020-14338": {"epss_score": 0.00588, "epss_percentile": 0.68494}, "CVE-2020-14339": {"epss_score": 0.00076, "epss_percentile": 0.23183}, "CVE-2020-14340": {"epss_score": 0.00309, "epss_percentile": 0.53655}, "CVE-2020-14341": {"epss_score": 0.00298, "epss_percentile": 0.52789}, "CVE-2020-14342": {"epss_score": 0.00134, "epss_percentile": 0.33897}, "CVE-2020-14343": {"epss_score": 0.13704, "epss_percentile": 0.94038}, "CVE-2020-14344": {"epss_score": 0.00162, "epss_percentile": 0.37646}, "CVE-2020-14345": {"epss_score": 0.0012, "epss_percentile": 0.31756}, "CVE-2020-14346": {"epss_score": 0.00182, "epss_percentile": 0.40259}, "CVE-2020-14347": {"epss_score": 0.00045, "epss_percentile": 0.1382}, "CVE-2020-14348": {"epss_score": 0.00235, "epss_percentile": 0.46237}, "CVE-2020-14349": {"epss_score": 0.00686, "epss_percentile": 0.71168}, "CVE-2020-14350": {"epss_score": 0.0003, "epss_percentile": 0.0829}, "CVE-2020-14351": {"epss_score": 0.0012, "epss_percentile": 0.31752}, "CVE-2020-14352": {"epss_score": 0.04035, "epss_percentile": 0.88156}, "CVE-2020-14354": {"epss_score": 0.00188, "epss_percentile": 0.40886}, "CVE-2020-14355": {"epss_score": 0.01111, "epss_percentile": 0.77666}, "CVE-2020-14356": {"epss_score": 0.00736, "epss_percentile": 0.72306}, "CVE-2020-14359": {"epss_score": 0.00259, "epss_percentile": 0.4904}, "CVE-2020-14360": {"epss_score": 0.00104, "epss_percentile": 0.29188}, "CVE-2020-14361": {"epss_score": 0.00233, "epss_percentile": 0.46025}, "CVE-2020-14362": {"epss_score": 0.00178, "epss_percentile": 0.39702}, "CVE-2020-14363": {"epss_score": 0.0015, "epss_percentile": 0.3607}, "CVE-2020-14364": {"epss_score": 0.11123, "epss_percentile": 0.9323}, "CVE-2020-14365": {"epss_score": 0.0007, "epss_percentile": 0.21948}, "CVE-2020-14366": {"epss_score": 0.00384, "epss_percentile": 0.59154}, "CVE-2020-14367": {"epss_score": 0.0027, "epss_percentile": 0.50255}, "CVE-2020-14368": {"epss_score": 0.00094, "epss_percentile": 0.27074}, "CVE-2020-14369": {"epss_score": 0.00115, "epss_percentile": 0.3103}, "CVE-2020-14370": {"epss_score": 0.00151, "epss_percentile": 0.36214}, "CVE-2020-14371": {"epss_score": 0.00274, "epss_percentile": 0.50511}, "CVE-2020-14372": {"epss_score": 0.01299, "epss_percentile": 0.79278}, "CVE-2020-14373": {"epss_score": 0.00128, "epss_percentile": 0.32951}, "CVE-2020-14374": {"epss_score": 0.00159, "epss_percentile": 0.37308}, "CVE-2020-14375": {"epss_score": 0.00048, "epss_percentile": 0.15109}, "CVE-2020-14376": {"epss_score": 0.00086, "epss_percentile": 0.25428}, "CVE-2020-14377": {"epss_score": 0.00064, "epss_percentile": 0.20165}, "CVE-2020-14378": {"epss_score": 0.00075, "epss_percentile": 0.22947}, "CVE-2020-14379": {"epss_score": 0.00037, "epss_percentile": 0.10918}, "CVE-2020-14380": {"epss_score": 0.00319, "epss_percentile": 0.54561}, "CVE-2020-14381": {"epss_score": 0.0064, "epss_percentile": 0.69956}, "CVE-2020-14382": {"epss_score": 0.00282, "epss_percentile": 0.51271}, "CVE-2020-14383": {"epss_score": 0.00428, "epss_percentile": 0.61925}, "CVE-2020-14384": {"epss_score": 0.00499, "epss_percentile": 0.65275}, "CVE-2020-14385": {"epss_score": 0.00126, "epss_percentile": 0.327}, "CVE-2020-14386": {"epss_score": 0.00548, "epss_percentile": 0.67275}, "CVE-2020-14387": {"epss_score": 0.00142, "epss_percentile": 0.34982}, "CVE-2020-14388": {"epss_score": 0.0018, "epss_percentile": 0.39984}, "CVE-2020-14389": {"epss_score": 0.00148, "epss_percentile": 0.35889}, "CVE-2020-14390": {"epss_score": 0.00172, "epss_percentile": 0.3893}, "CVE-2020-14391": {"epss_score": 0.00166, "epss_percentile": 0.38178}, "CVE-2020-14392": {"epss_score": 0.00101, "epss_percentile": 0.28647}, "CVE-2020-14393": {"epss_score": 0.0004, "epss_percentile": 0.12045}, "CVE-2020-14394": {"epss_score": 0.00022, "epss_percentile": 0.05278}, "CVE-2020-14396": {"epss_score": 0.01582, "epss_percentile": 0.81141}, "CVE-2020-14397": {"epss_score": 0.04438, "epss_percentile": 0.88691}, "CVE-2020-14398": {"epss_score": 0.02271, "epss_percentile": 0.84215}, "CVE-2020-14399": {"epss_score": 0.02477, "epss_percentile": 0.84864}, "CVE-2020-14400": {"epss_score": 0.02787, "epss_percentile": 0.85659}, "CVE-2020-14401": {"epss_score": 0.01613, "epss_percentile": 0.81342}, "CVE-2020-14402": {"epss_score": 0.02216, "epss_percentile": 0.84036}, "CVE-2020-14403": {"epss_score": 0.01113, "epss_percentile": 0.77687}, "CVE-2020-14404": {"epss_score": 0.01332, "epss_percentile": 0.79523}, "CVE-2020-14405": {"epss_score": 0.01448, "epss_percentile": 0.80334}, "CVE-2020-14408": {"epss_score": 0.01606, "epss_percentile": 0.81305}, "CVE-2020-14409": {"epss_score": 0.00118, "epss_percentile": 0.31443}, "CVE-2020-14410": {"epss_score": 0.00161, "epss_percentile": 0.37588}, "CVE-2020-14412": {"epss_score": 0.03782, "epss_percentile": 0.87721}, "CVE-2020-14413": {"epss_score": 0.15743, "epss_percentile": 0.94497}, "CVE-2020-14414": {"epss_score": 0.03782, "epss_percentile": 0.87721}, "CVE-2020-14415": {"epss_score": 0.0005, "epss_percentile": 0.15688}, "CVE-2020-14416": {"epss_score": 0.00091, "epss_percentile": 0.26248}, "CVE-2020-14418": {"epss_score": 0.00064, "epss_percentile": 0.20164}, "CVE-2020-14421": {"epss_score": 0.0557, "epss_percentile": 0.90006}, "CVE-2020-14422": {"epss_score": 0.00697, "epss_percentile": 0.71398}, "CVE-2020-14423": {"epss_score": 0.00298, "epss_percentile": 0.5278}, "CVE-2020-14424": {"epss_score": 0.00386, "epss_percentile": 0.59254}, "CVE-2020-14425": {"epss_score": 0.26569, "epss_percentile": 0.96158}, "CVE-2020-14426": {"epss_score": 0.00097, "epss_percentile": 0.2757}, "CVE-2020-14427": {"epss_score": 0.00097, "epss_percentile": 0.2757}, "CVE-2020-14428": {"epss_score": 0.00186, "epss_percentile": 0.40629}, "CVE-2020-14429": {"epss_score": 0.00244, "epss_percentile": 0.47564}, "CVE-2020-14430": {"epss_score": 0.00097, "epss_percentile": 0.2757}, "CVE-2020-14431": {"epss_score": 0.00195, "epss_percentile": 0.41651}, "CVE-2020-14432": {"epss_score": 0.00181, "epss_percentile": 0.40119}, "CVE-2020-14433": {"epss_score": 0.0052, "epss_percentile": 0.66211}, "CVE-2020-14434": {"epss_score": 0.00607, "epss_percentile": 0.69032}, "CVE-2020-14435": {"epss_score": 0.00211, "epss_percentile": 0.43674}, "CVE-2020-14436": {"epss_score": 0.01536, "epss_percentile": 0.80916}, "CVE-2020-14437": {"epss_score": 0.01536, "epss_percentile": 0.80916}, "CVE-2020-14438": {"epss_score": 0.01536, "epss_percentile": 0.80916}, "CVE-2020-14439": {"epss_score": 0.00788, "epss_percentile": 0.73343}, "CVE-2020-14440": {"epss_score": 0.01536, "epss_percentile": 0.80916}, "CVE-2020-14441": {"epss_score": 0.01536, "epss_percentile": 0.80916}, "CVE-2020-14442": {"epss_score": 0.01536, "epss_percentile": 0.80916}, "CVE-2020-14443": {"epss_score": 0.00295, "epss_percentile": 0.52499}, "CVE-2020-14444": {"epss_score": 0.00217, "epss_percentile": 0.44244}, "CVE-2020-14445": {"epss_score": 0.00217, "epss_percentile": 0.44244}, "CVE-2020-14446": {"epss_score": 0.00147, "epss_percentile": 0.35777}, "CVE-2020-14447": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-14448": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-14449": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-14450": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-14451": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-14452": {"epss_score": 0.00144, "epss_percentile": 0.35266}, "CVE-2020-14453": {"epss_score": 0.0015, "epss_percentile": 0.3615}, "CVE-2020-14454": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2020-14455": {"epss_score": 0.00255, "epss_percentile": 0.48702}, "CVE-2020-14456": {"epss_score": 0.00148, "epss_percentile": 0.35803}, "CVE-2020-14457": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2020-14458": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-14459": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-14460": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2020-14461": {"epss_score": 0.10595, "epss_percentile": 0.9304}, "CVE-2020-14462": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-14470": {"epss_score": 0.00543, "epss_percentile": 0.67088}, "CVE-2020-14472": {"epss_score": 0.03887, "epss_percentile": 0.87906}, "CVE-2020-14473": {"epss_score": 0.00891, "epss_percentile": 0.75049}, "CVE-2020-14474": {"epss_score": 0.01452, "epss_percentile": 0.80367}, "CVE-2020-14475": {"epss_score": 0.00259, "epss_percentile": 0.49044}, "CVE-2020-14477": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2020-14478": {"epss_score": 0.00093, "epss_percentile": 0.26634}, "CVE-2020-14479": {"epss_score": 0.00147, "epss_percentile": 0.35659}, "CVE-2020-14480": {"epss_score": 0.00025, "epss_percentile": 0.06038}, "CVE-2020-14481": {"epss_score": 0.00015, "epss_percentile": 0.02324}, "CVE-2020-14482": {"epss_score": 0.00346, "epss_percentile": 0.56628}, "CVE-2020-14483": {"epss_score": 0.00114, "epss_percentile": 0.30815}, "CVE-2020-14484": {"epss_score": 0.00235, "epss_percentile": 0.46341}, "CVE-2020-14485": {"epss_score": 0.00612, "epss_percentile": 0.69217}, "CVE-2020-14486": {"epss_score": 0.00061, "epss_percentile": 0.19248}, "CVE-2020-14487": {"epss_score": 0.0025, "epss_percentile": 0.48148}, "CVE-2020-14488": {"epss_score": 0.00355, "epss_percentile": 0.57259}, "CVE-2020-14489": {"epss_score": 0.00113, "epss_percentile": 0.30648}, "CVE-2020-14490": {"epss_score": 0.0019, "epss_percentile": 0.41065}, "CVE-2020-14491": {"epss_score": 0.00127, "epss_percentile": 0.32842}, "CVE-2020-14492": {"epss_score": 0.00164, "epss_percentile": 0.37944}, "CVE-2020-14493": {"epss_score": 0.00174, "epss_percentile": 0.39189}, "CVE-2020-14494": {"epss_score": 0.00214, "epss_percentile": 0.43974}, "CVE-2020-14496": {"epss_score": 0.00129, "epss_percentile": 0.33206}, "CVE-2020-14497": {"epss_score": 0.01682, "epss_percentile": 0.81735}, "CVE-2020-14498": {"epss_score": 0.00546, "epss_percentile": 0.67224}, "CVE-2020-14499": {"epss_score": 0.00418, "epss_percentile": 0.61278}, "CVE-2020-14500": {"epss_score": 0.00287, "epss_percentile": 0.51813}, "CVE-2020-14501": {"epss_score": 0.00336, "epss_percentile": 0.55999}, "CVE-2020-14502": {"epss_score": 0.00084, "epss_percentile": 0.2502}, "CVE-2020-14503": {"epss_score": 0.00867, "epss_percentile": 0.74653}, "CVE-2020-14504": {"epss_score": 0.0023, "epss_percentile": 0.45681}, "CVE-2020-14505": {"epss_score": 0.02996, "epss_percentile": 0.86156}, "CVE-2020-14506": {"epss_score": 0.00034, "epss_percentile": 0.09761}, "CVE-2020-14507": {"epss_score": 0.01728, "epss_percentile": 0.81975}, "CVE-2020-14508": {"epss_score": 0.00729, "epss_percentile": 0.7214}, "CVE-2020-14509": {"epss_score": 0.00276, "epss_percentile": 0.50737}, "CVE-2020-14510": {"epss_score": 0.00475, "epss_percentile": 0.64191}, "CVE-2020-14511": {"epss_score": 0.0023, "epss_percentile": 0.45733}, "CVE-2020-14512": {"epss_score": 0.00124, "epss_percentile": 0.32422}, "CVE-2020-14513": {"epss_score": 0.00258, "epss_percentile": 0.48981}, "CVE-2020-14514": {"epss_score": 0.00057, "epss_percentile": 0.18007}, "CVE-2020-14515": {"epss_score": 0.00085, "epss_percentile": 0.25154}, "CVE-2020-14516": {"epss_score": 0.00242, "epss_percentile": 0.47379}, "CVE-2020-14517": {"epss_score": 0.00085, "epss_percentile": 0.25242}, "CVE-2020-14518": {"epss_score": 0.00144, "epss_percentile": 0.35345}, "CVE-2020-14519": {"epss_score": 0.00086, "epss_percentile": 0.25247}, "CVE-2020-14520": {"epss_score": 0.00216, "epss_percentile": 0.44149}, "CVE-2020-14521": {"epss_score": 0.00243, "epss_percentile": 0.4743}, "CVE-2020-14522": {"epss_score": 0.00258, "epss_percentile": 0.48981}, "CVE-2020-14523": {"epss_score": 0.01264, "epss_percentile": 0.78999}, "CVE-2020-14524": {"epss_score": 0.0115, "epss_percentile": 0.78025}, "CVE-2020-14525": {"epss_score": 0.00067, "epss_percentile": 0.21159}, "CVE-2020-14527": {"epss_score": 0.01741, "epss_percentile": 0.82046}, "CVE-2020-14528": {"epss_score": 0.00567, "epss_percentile": 0.67856}, "CVE-2020-14529": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-14530": {"epss_score": 0.01882, "epss_percentile": 0.82697}, "CVE-2020-14531": {"epss_score": 0.01428, "epss_percentile": 0.80223}, "CVE-2020-14532": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2020-14533": {"epss_score": 0.0019, "epss_percentile": 0.41092}, "CVE-2020-14534": {"epss_score": 0.02194, "epss_percentile": 0.83948}, "CVE-2020-14535": {"epss_score": 0.01455, "epss_percentile": 0.80391}, "CVE-2020-14536": {"epss_score": 0.01455, "epss_percentile": 0.80391}, "CVE-2020-14537": {"epss_score": 0.00083, "epss_percentile": 0.24703}, "CVE-2020-14539": {"epss_score": 0.00788, "epss_percentile": 0.73335}, "CVE-2020-14540": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2020-14541": {"epss_score": 0.00218, "epss_percentile": 0.44359}, "CVE-2020-14542": {"epss_score": 0.00063, "epss_percentile": 0.19958}, "CVE-2020-14543": {"epss_score": 0.0007, "epss_percentile": 0.2168}, "CVE-2020-14544": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2020-14545": {"epss_score": 0.00063, "epss_percentile": 0.19867}, "CVE-2020-14546": {"epss_score": 0.00264, "epss_percentile": 0.49732}, "CVE-2020-14547": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2020-14548": {"epss_score": 0.00583, "epss_percentile": 0.68356}, "CVE-2020-14549": {"epss_score": 0.01741, "epss_percentile": 0.82046}, "CVE-2020-14550": {"epss_score": 0.00266, "epss_percentile": 0.49881}, "CVE-2020-14551": {"epss_score": 0.00201, "epss_percentile": 0.42321}, "CVE-2020-14552": {"epss_score": 0.00555, "epss_percentile": 0.67491}, "CVE-2020-14553": {"epss_score": 0.0048, "epss_percentile": 0.64465}, "CVE-2020-14554": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2020-14555": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2020-14556": {"epss_score": 0.00576, "epss_percentile": 0.68148}, "CVE-2020-14557": {"epss_score": 0.01871, "epss_percentile": 0.82636}, "CVE-2020-14558": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2020-14559": {"epss_score": 0.00574, "epss_percentile": 0.68069}, "CVE-2020-14560": {"epss_score": 0.00621, "epss_percentile": 0.69478}, "CVE-2020-14561": {"epss_score": 0.00065, "epss_percentile": 0.20619}, "CVE-2020-14562": {"epss_score": 0.00327, "epss_percentile": 0.55103}, "CVE-2020-14563": {"epss_score": 0.00829, "epss_percentile": 0.74016}, "CVE-2020-14564": {"epss_score": 0.00206, "epss_percentile": 0.42999}, "CVE-2020-14565": {"epss_score": 0.00286, "epss_percentile": 0.51716}, "CVE-2020-14566": {"epss_score": 0.00694, "epss_percentile": 0.71343}, "CVE-2020-14567": {"epss_score": 0.00365, "epss_percentile": 0.58001}, "CVE-2020-14568": {"epss_score": 0.00491, "epss_percentile": 0.6497}, "CVE-2020-14569": {"epss_score": 0.01267, "epss_percentile": 0.79024}, "CVE-2020-14570": {"epss_score": 0.02011, "epss_percentile": 0.83251}, "CVE-2020-14571": {"epss_score": 0.00823, "epss_percentile": 0.73932}, "CVE-2020-14572": {"epss_score": 0.00879, "epss_percentile": 0.74845}, "CVE-2020-14573": {"epss_score": 0.00295, "epss_percentile": 0.52448}, "CVE-2020-14574": {"epss_score": 0.00079, "epss_percentile": 0.2385}, "CVE-2020-14575": {"epss_score": 0.00487, "epss_percentile": 0.64778}, "CVE-2020-14576": {"epss_score": 0.00419, "epss_percentile": 0.61374}, "CVE-2020-14577": {"epss_score": 0.00283, "epss_percentile": 0.51389}, "CVE-2020-14578": {"epss_score": 0.00162, "epss_percentile": 0.3773}, "CVE-2020-14579": {"epss_score": 0.00162, "epss_percentile": 0.3773}, "CVE-2020-14580": {"epss_score": 0.00576, "epss_percentile": 0.68146}, "CVE-2020-14581": {"epss_score": 0.00385, "epss_percentile": 0.59183}, "CVE-2020-14582": {"epss_score": 0.02303, "epss_percentile": 0.84317}, "CVE-2020-14583": {"epss_score": 0.01018, "epss_percentile": 0.76718}, "CVE-2020-14584": {"epss_score": 0.03174, "epss_percentile": 0.86555}, "CVE-2020-14585": {"epss_score": 0.02913, "epss_percentile": 0.85975}, "CVE-2020-14586": {"epss_score": 0.00487, "epss_percentile": 0.64778}, "CVE-2020-14587": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2020-14588": {"epss_score": 0.02033, "epss_percentile": 0.83341}, "CVE-2020-14589": {"epss_score": 0.03213, "epss_percentile": 0.86658}, "CVE-2020-14590": {"epss_score": 0.00202, "epss_percentile": 0.42455}, "CVE-2020-14591": {"epss_score": 0.00641, "epss_percentile": 0.69986}, "CVE-2020-14592": {"epss_score": 0.00852, "epss_percentile": 0.74414}, "CVE-2020-14593": {"epss_score": 0.00409, "epss_percentile": 0.60703}, "CVE-2020-14594": {"epss_score": 0.00076, "epss_percentile": 0.23251}, "CVE-2020-14595": {"epss_score": 0.02985, "epss_percentile": 0.86131}, "CVE-2020-14596": {"epss_score": 0.02303, "epss_percentile": 0.84317}, "CVE-2020-14597": {"epss_score": 0.00487, "epss_percentile": 0.64778}, "CVE-2020-14598": {"epss_score": 0.01616, "epss_percentile": 0.81356}, "CVE-2020-14599": {"epss_score": 0.01616, "epss_percentile": 0.81356}, "CVE-2020-14600": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2020-14601": {"epss_score": 0.00852, "epss_percentile": 0.74414}, "CVE-2020-14602": {"epss_score": 0.00217, "epss_percentile": 0.44298}, "CVE-2020-14603": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2020-14604": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2020-14605": {"epss_score": 0.00244, "epss_percentile": 0.47568}, "CVE-2020-14606": {"epss_score": 0.02045, "epss_percentile": 0.83381}, "CVE-2020-14607": {"epss_score": 0.00852, "epss_percentile": 0.74414}, "CVE-2020-14608": {"epss_score": 0.00788, "epss_percentile": 0.73337}, "CVE-2020-14609": {"epss_score": 0.02621, "epss_percentile": 0.85255}, "CVE-2020-14610": {"epss_score": 0.00657, "epss_percentile": 0.70459}, "CVE-2020-14611": {"epss_score": 0.01229, "epss_percentile": 0.78718}, "CVE-2020-14612": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2020-14613": {"epss_score": 0.00879, "epss_percentile": 0.74845}, "CVE-2020-14614": {"epss_score": 0.00491, "epss_percentile": 0.6497}, "CVE-2020-14615": {"epss_score": 0.00997, "epss_percentile": 0.76458}, "CVE-2020-14616": {"epss_score": 0.00202, "epss_percentile": 0.42455}, "CVE-2020-14617": {"epss_score": 0.00605, "epss_percentile": 0.68989}, "CVE-2020-14618": {"epss_score": 0.01428, "epss_percentile": 0.80223}, "CVE-2020-14619": {"epss_score": 0.00632, "epss_percentile": 0.69735}, "CVE-2020-14620": {"epss_score": 0.00415, "epss_percentile": 0.61153}, "CVE-2020-14621": {"epss_score": 0.00461, "epss_percentile": 0.63546}, "CVE-2020-14622": {"epss_score": 0.00732, "epss_percentile": 0.72185}, "CVE-2020-14623": {"epss_score": 0.00256, "epss_percentile": 0.48822}, "CVE-2020-14624": {"epss_score": 0.00415, "epss_percentile": 0.61153}, "CVE-2020-14625": {"epss_score": 0.08272, "epss_percentile": 0.91961}, "CVE-2020-14626": {"epss_score": 0.02221, "epss_percentile": 0.84051}, "CVE-2020-14627": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2020-14628": {"epss_score": 0.00179, "epss_percentile": 0.39842}, "CVE-2020-14629": {"epss_score": 0.00164, "epss_percentile": 0.37898}, "CVE-2020-14630": {"epss_score": 0.00226, "epss_percentile": 0.45266}, "CVE-2020-14631": {"epss_score": 0.00415, "epss_percentile": 0.61153}, "CVE-2020-14632": {"epss_score": 0.00256, "epss_percentile": 0.48822}, "CVE-2020-14633": {"epss_score": 0.00362, "epss_percentile": 0.57754}, "CVE-2020-14634": {"epss_score": 0.00391, "epss_percentile": 0.59626}, "CVE-2020-14635": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2020-14636": {"epss_score": 0.00625, "epss_percentile": 0.69577}, "CVE-2020-14637": {"epss_score": 0.00625, "epss_percentile": 0.69577}, "CVE-2020-14638": {"epss_score": 0.00625, "epss_percentile": 0.69577}, "CVE-2020-14639": {"epss_score": 0.05244, "epss_percentile": 0.89656}, "CVE-2020-14640": {"epss_score": 0.00625, "epss_percentile": 0.69577}, "CVE-2020-14641": {"epss_score": 0.00502, "epss_percentile": 0.65403}, "CVE-2020-14642": {"epss_score": 0.01522, "epss_percentile": 0.80834}, "CVE-2020-14643": {"epss_score": 0.00383, "epss_percentile": 0.59083}, "CVE-2020-14644": {"epss_score": 0.9364, "epss_percentile": 0.99828}, "CVE-2020-14645": {"epss_score": 0.9232, "epss_percentile": 0.99707}, "CVE-2020-14646": {"epss_score": 0.0016, "epss_percentile": 0.37463}, "CVE-2020-14647": {"epss_score": 0.0016, "epss_percentile": 0.37463}, "CVE-2020-14648": {"epss_score": 0.00146, "epss_percentile": 0.35596}, "CVE-2020-14649": {"epss_score": 0.0016, "epss_percentile": 0.37463}, "CVE-2020-14650": {"epss_score": 0.00146, "epss_percentile": 0.35596}, "CVE-2020-14651": {"epss_score": 0.00383, "epss_percentile": 0.59083}, "CVE-2020-14652": {"epss_score": 0.00631, "epss_percentile": 0.69725}, "CVE-2020-14653": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2020-14654": {"epss_score": 0.00415, "epss_percentile": 0.61153}, "CVE-2020-14655": {"epss_score": 0.01353, "epss_percentile": 0.79697}, "CVE-2020-14656": {"epss_score": 0.00415, "epss_percentile": 0.61153}, "CVE-2020-14657": {"epss_score": 0.00505, "epss_percentile": 0.65585}, "CVE-2020-14658": {"epss_score": 0.01616, "epss_percentile": 0.81356}, "CVE-2020-14659": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2020-14660": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14661": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2020-14662": {"epss_score": 0.00266, "epss_percentile": 0.49908}, "CVE-2020-14663": {"epss_score": 0.00579, "epss_percentile": 0.68217}, "CVE-2020-14664": {"epss_score": 0.01068, "epss_percentile": 0.77243}, "CVE-2020-14665": {"epss_score": 0.01616, "epss_percentile": 0.81356}, "CVE-2020-14666": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14667": {"epss_score": 0.00505, "epss_percentile": 0.65585}, "CVE-2020-14668": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14669": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14670": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14671": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14672": {"epss_score": 0.01097, "epss_percentile": 0.7753}, "CVE-2020-14673": {"epss_score": 0.00146, "epss_percentile": 0.35596}, "CVE-2020-14674": {"epss_score": 0.00116, "epss_percentile": 0.31113}, "CVE-2020-14675": {"epss_score": 0.00124, "epss_percentile": 0.32377}, "CVE-2020-14676": {"epss_score": 0.0016, "epss_percentile": 0.37463}, "CVE-2020-14677": {"epss_score": 0.00124, "epss_percentile": 0.32377}, "CVE-2020-14678": {"epss_score": 0.00643, "epss_percentile": 0.70066}, "CVE-2020-14679": {"epss_score": 0.01311, "epss_percentile": 0.79373}, "CVE-2020-14680": {"epss_score": 0.00333, "epss_percentile": 0.55642}, "CVE-2020-14681": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14682": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14684": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2020-14685": {"epss_score": 0.00244, "epss_percentile": 0.47568}, "CVE-2020-14686": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14687": {"epss_score": 0.01898, "epss_percentile": 0.82763}, "CVE-2020-14688": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14690": {"epss_score": 0.02194, "epss_percentile": 0.83948}, "CVE-2020-14691": {"epss_score": 0.00217, "epss_percentile": 0.44298}, "CVE-2020-14692": {"epss_score": 0.00244, "epss_percentile": 0.47568}, "CVE-2020-14693": {"epss_score": 0.00244, "epss_percentile": 0.47568}, "CVE-2020-14694": {"epss_score": 0.00146, "epss_percentile": 0.35596}, "CVE-2020-14695": {"epss_score": 0.00146, "epss_percentile": 0.35596}, "CVE-2020-14696": {"epss_score": 0.00823, "epss_percentile": 0.73932}, "CVE-2020-14697": {"epss_score": 0.00681, "epss_percentile": 0.71038}, "CVE-2020-14698": {"epss_score": 0.00146, "epss_percentile": 0.35596}, "CVE-2020-14699": {"epss_score": 0.0016, "epss_percentile": 0.37463}, "CVE-2020-14700": {"epss_score": 0.00146, "epss_percentile": 0.35596}, "CVE-2020-14701": {"epss_score": 0.01786, "epss_percentile": 0.82257}, "CVE-2020-14702": {"epss_score": 0.00415, "epss_percentile": 0.61153}, "CVE-2020-14703": {"epss_score": 0.00164, "epss_percentile": 0.37898}, "CVE-2020-14704": {"epss_score": 0.00164, "epss_percentile": 0.37898}, "CVE-2020-14705": {"epss_score": 0.00457, "epss_percentile": 0.63362}, "CVE-2020-14706": {"epss_score": 0.01741, "epss_percentile": 0.82046}, "CVE-2020-14707": {"epss_score": 0.00221, "epss_percentile": 0.44681}, "CVE-2020-14708": {"epss_score": 0.00201, "epss_percentile": 0.42321}, "CVE-2020-14709": {"epss_score": 0.00217, "epss_percentile": 0.44298}, "CVE-2020-14710": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2020-14711": {"epss_score": 0.00374, "epss_percentile": 0.5857}, "CVE-2020-14712": {"epss_score": 0.00312, "epss_percentile": 0.53945}, "CVE-2020-14713": {"epss_score": 0.00086, "epss_percentile": 0.25353}, "CVE-2020-14714": {"epss_score": 0.00094, "epss_percentile": 0.26785}, "CVE-2020-14715": {"epss_score": 0.00094, "epss_percentile": 0.26785}, "CVE-2020-14716": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2020-14717": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2020-14718": {"epss_score": 0.01318, "epss_percentile": 0.79422}, "CVE-2020-14719": {"epss_score": 0.00228, "epss_percentile": 0.45537}, "CVE-2020-14720": {"epss_score": 0.00537, "epss_percentile": 0.66894}, "CVE-2020-14721": {"epss_score": 0.00234, "epss_percentile": 0.46115}, "CVE-2020-14722": {"epss_score": 0.00632, "epss_percentile": 0.69745}, "CVE-2020-14723": {"epss_score": 0.00797, "epss_percentile": 0.73497}, "CVE-2020-14724": {"epss_score": 0.00062, "epss_percentile": 0.19648}, "CVE-2020-14725": {"epss_score": 0.00163, "epss_percentile": 0.37834}, "CVE-2020-14728": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-14729": {"epss_score": 0.00248, "epss_percentile": 0.47971}, "CVE-2020-14731": {"epss_score": 0.00197, "epss_percentile": 0.41896}, "CVE-2020-14732": {"epss_score": 0.00184, "epss_percentile": 0.40455}, "CVE-2020-14734": {"epss_score": 0.01352, "epss_percentile": 0.79688}, "CVE-2020-14735": {"epss_score": 0.0004, "epss_percentile": 0.119}, "CVE-2020-14736": {"epss_score": 0.0018, "epss_percentile": 0.39892}, "CVE-2020-14740": {"epss_score": 0.00088, "epss_percentile": 0.25709}, "CVE-2020-14741": {"epss_score": 0.00213, "epss_percentile": 0.43943}, "CVE-2020-14742": {"epss_score": 0.00206, "epss_percentile": 0.42999}, "CVE-2020-14743": {"epss_score": 0.00181, "epss_percentile": 0.40078}, "CVE-2020-14744": {"epss_score": 0.00573, "epss_percentile": 0.68055}, "CVE-2020-14745": {"epss_score": 0.00197, "epss_percentile": 0.41896}, "CVE-2020-14746": {"epss_score": 0.00673, "epss_percentile": 0.70829}, "CVE-2020-14750": {"epss_score": 0.94438, "epss_percentile": 0.99986}, "CVE-2020-14752": {"epss_score": 0.00264, "epss_percentile": 0.49732}, "CVE-2020-14753": {"epss_score": 0.00114, "epss_percentile": 0.30771}, "CVE-2020-14754": {"epss_score": 0.00071, "epss_percentile": 0.22111}, "CVE-2020-14756": {"epss_score": 0.88846, "epss_percentile": 0.99494}, "CVE-2020-14757": {"epss_score": 0.01411, "epss_percentile": 0.80086}, "CVE-2020-14758": {"epss_score": 0.00148, "epss_percentile": 0.35903}, "CVE-2020-14759": {"epss_score": 0.00067, "epss_percentile": 0.21125}, "CVE-2020-14760": {"epss_score": 0.00206, "epss_percentile": 0.42779}, "CVE-2020-14761": {"epss_score": 0.00247, "epss_percentile": 0.4789}, "CVE-2020-14762": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-14763": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-14764": {"epss_score": 0.00264, "epss_percentile": 0.49732}, "CVE-2020-14765": {"epss_score": 0.01358, "epss_percentile": 0.79728}, "CVE-2020-14766": {"epss_score": 0.00478, "epss_percentile": 0.64383}, "CVE-2020-14767": {"epss_score": 0.00621, "epss_percentile": 0.69478}, "CVE-2020-14768": {"epss_score": 0.00096, "epss_percentile": 0.27275}, "CVE-2020-14769": {"epss_score": 0.01438, "epss_percentile": 0.80284}, "CVE-2020-14770": {"epss_score": 0.00214, "epss_percentile": 0.4395}, "CVE-2020-14771": {"epss_score": 0.00226, "epss_percentile": 0.45243}, "CVE-2020-14772": {"epss_score": 0.00264, "epss_percentile": 0.49732}, "CVE-2020-14773": {"epss_score": 0.00825, "epss_percentile": 0.73957}, "CVE-2020-14774": {"epss_score": 0.01537, "epss_percentile": 0.80921}, "CVE-2020-14775": {"epss_score": 0.01438, "epss_percentile": 0.80284}, "CVE-2020-14776": {"epss_score": 0.00633, "epss_percentile": 0.69784}, "CVE-2020-14777": {"epss_score": 0.00825, "epss_percentile": 0.73957}, "CVE-2020-14778": {"epss_score": 0.00266, "epss_percentile": 0.49908}, "CVE-2020-14779": {"epss_score": 0.002, "epss_percentile": 0.42234}, "CVE-2020-14780": {"epss_score": 0.02011, "epss_percentile": 0.83251}, "CVE-2020-14781": {"epss_score": 0.00101, "epss_percentile": 0.28703}, "CVE-2020-14782": {"epss_score": 0.00144, "epss_percentile": 0.35348}, "CVE-2020-14783": {"epss_score": 0.01181, "epss_percentile": 0.78308}, "CVE-2020-14784": {"epss_score": 0.02194, "epss_percentile": 0.83948}, "CVE-2020-14785": {"epss_score": 0.00825, "epss_percentile": 0.73957}, "CVE-2020-14786": {"epss_score": 0.00825, "epss_percentile": 0.73957}, "CVE-2020-14787": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-14788": {"epss_score": 0.00641, "epss_percentile": 0.70011}, "CVE-2020-14789": {"epss_score": 0.00633, "epss_percentile": 0.69784}, "CVE-2020-14790": {"epss_score": 0.00843, "epss_percentile": 0.74255}, "CVE-2020-14791": {"epss_score": 0.00423, "epss_percentile": 0.61605}, "CVE-2020-14792": {"epss_score": 0.00165, "epss_percentile": 0.3801}, "CVE-2020-14793": {"epss_score": 0.00843, "epss_percentile": 0.74255}, "CVE-2020-14794": {"epss_score": 0.00825, "epss_percentile": 0.73957}, "CVE-2020-14795": {"epss_score": 0.02348, "epss_percentile": 0.84457}, "CVE-2020-14796": {"epss_score": 0.00118, "epss_percentile": 0.31435}, "CVE-2020-14797": {"epss_score": 0.00151, "epss_percentile": 0.36264}, "CVE-2020-14798": {"epss_score": 0.00244, "epss_percentile": 0.47518}, "CVE-2020-14799": {"epss_score": 0.00307, "epss_percentile": 0.53566}, "CVE-2020-14800": {"epss_score": 0.00324, "epss_percentile": 0.54961}, "CVE-2020-14801": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2020-14802": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2020-14803": {"epss_score": 0.0004, "epss_percentile": 0.12098}, "CVE-2020-14804": {"epss_score": 0.00292, "epss_percentile": 0.52256}, "CVE-2020-14805": {"epss_score": 0.01616, "epss_percentile": 0.81356}, "CVE-2020-14806": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2020-14807": {"epss_score": 0.01648, "epss_percentile": 0.81543}, "CVE-2020-14808": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14809": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2020-14810": {"epss_score": 0.00567, "epss_percentile": 0.67856}, "CVE-2020-14811": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2020-14812": {"epss_score": 0.0077, "epss_percentile": 0.73005}, "CVE-2020-14813": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2020-14814": {"epss_score": 0.00206, "epss_percentile": 0.42779}, "CVE-2020-14815": {"epss_score": 0.84289, "epss_percentile": 0.99282}, "CVE-2020-14816": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14817": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14818": {"epss_score": 0.00264, "epss_percentile": 0.49712}, "CVE-2020-14819": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14820": {"epss_score": 0.05862, "epss_percentile": 0.9027}, "CVE-2020-14821": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2020-14822": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2020-14823": {"epss_score": 0.01387, "epss_percentile": 0.79916}, "CVE-2020-14824": {"epss_score": 0.01125, "epss_percentile": 0.77807}, "CVE-2020-14825": {"epss_score": 0.58433, "epss_percentile": 0.98116}, "CVE-2020-14826": {"epss_score": 0.01453, "epss_percentile": 0.80376}, "CVE-2020-14827": {"epss_score": 0.00455, "epss_percentile": 0.63285}, "CVE-2020-14828": {"epss_score": 0.00942, "epss_percentile": 0.75767}, "CVE-2020-14829": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2020-14830": {"epss_score": 0.00651, "epss_percentile": 0.70275}, "CVE-2020-14831": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14832": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2020-14833": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14834": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14835": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14836": {"epss_score": 0.00637, "epss_percentile": 0.69892}, "CVE-2020-14837": {"epss_score": 0.00206, "epss_percentile": 0.42779}, "CVE-2020-14838": {"epss_score": 0.0025, "epss_percentile": 0.48101}, "CVE-2020-14839": {"epss_score": 0.00206, "epss_percentile": 0.42779}, "CVE-2020-14840": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2020-14841": {"epss_score": 0.27044, "epss_percentile": 0.962}, "CVE-2020-14842": {"epss_score": 0.02194, "epss_percentile": 0.83948}, "CVE-2020-14843": {"epss_score": 0.00916, "epss_percentile": 0.7542}, "CVE-2020-14844": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2020-14845": {"epss_score": 0.00206, "epss_percentile": 0.42779}, "CVE-2020-14846": {"epss_score": 0.00651, "epss_percentile": 0.70275}, "CVE-2020-14847": {"epss_score": 0.00202, "epss_percentile": 0.42455}, "CVE-2020-14848": {"epss_score": 0.00109, "epss_percentile": 0.29915}, "CVE-2020-14849": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14850": {"epss_score": 0.01113, "epss_percentile": 0.77685}, "CVE-2020-14851": {"epss_score": 0.01113, "epss_percentile": 0.77685}, "CVE-2020-14852": {"epss_score": 0.00206, "epss_percentile": 0.42779}, "CVE-2020-14853": {"epss_score": 0.00225, "epss_percentile": 0.45099}, "CVE-2020-14854": {"epss_score": 0.00689, "epss_percentile": 0.71233}, "CVE-2020-14855": {"epss_score": 0.05089, "epss_percentile": 0.89481}, "CVE-2020-14856": {"epss_score": 0.01113, "epss_percentile": 0.77685}, "CVE-2020-14857": {"epss_score": 0.01586, "epss_percentile": 0.81176}, "CVE-2020-14858": {"epss_score": 0.01394, "epss_percentile": 0.79969}, "CVE-2020-14859": {"epss_score": 0.04774, "epss_percentile": 0.8913}, "CVE-2020-14860": {"epss_score": 0.00189, "epss_percentile": 0.40972}, "CVE-2020-14861": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2020-14862": {"epss_score": 0.0442, "epss_percentile": 0.88668}, "CVE-2020-14863": {"epss_score": 0.01113, "epss_percentile": 0.77685}, "CVE-2020-14864": {"epss_score": 0.94019, "epss_percentile": 0.99887}, "CVE-2020-14865": {"epss_score": 0.01095, "epss_percentile": 0.77502}, "CVE-2020-14866": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2020-14867": {"epss_score": 0.00206, "epss_percentile": 0.42779}, "CVE-2020-14868": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2020-14869": {"epss_score": 0.00206, "epss_percentile": 0.42779}, "CVE-2020-14870": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2020-14871": {"epss_score": 0.88872, "epss_percentile": 0.99497}, "CVE-2020-14872": {"epss_score": 0.00047, "epss_percentile": 0.14597}, "CVE-2020-14873": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2020-14874": {"epss_score": 0.00194, "epss_percentile": 0.41597}, "CVE-2020-14875": {"epss_score": 0.01994, "epss_percentile": 0.83187}, "CVE-2020-14876": {"epss_score": 0.02024, "epss_percentile": 0.83308}, "CVE-2020-14877": {"epss_score": 0.00972, "epss_percentile": 0.76136}, "CVE-2020-14878": {"epss_score": 0.00897, "epss_percentile": 0.75129}, "CVE-2020-14879": {"epss_score": 0.00334, "epss_percentile": 0.55686}, "CVE-2020-14880": {"epss_score": 0.00334, "epss_percentile": 0.55686}, "CVE-2020-14881": {"epss_score": 0.0014, "epss_percentile": 0.3478}, "CVE-2020-14882": {"epss_score": 0.94454, "epss_percentile": 0.99991}, "CVE-2020-14883": {"epss_score": 0.94439, "epss_percentile": 0.99987}, "CVE-2020-14884": {"epss_score": 0.00183, "epss_percentile": 0.40343}, "CVE-2020-14885": {"epss_score": 0.0014, "epss_percentile": 0.3478}, "CVE-2020-14886": {"epss_score": 0.0014, "epss_percentile": 0.3478}, "CVE-2020-14887": {"epss_score": 0.004, "epss_percentile": 0.60179}, "CVE-2020-14888": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2020-14889": {"epss_score": 0.00054, "epss_percentile": 0.17155}, "CVE-2020-14890": {"epss_score": 0.01653, "epss_percentile": 0.81578}, "CVE-2020-14891": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2020-14892": {"epss_score": 0.00057, "epss_percentile": 0.18148}, "CVE-2020-14893": {"epss_score": 0.00292, "epss_percentile": 0.52256}, "CVE-2020-14894": {"epss_score": 0.004, "epss_percentile": 0.60179}, "CVE-2020-14895": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2020-14896": {"epss_score": 0.004, "epss_percentile": 0.60179}, "CVE-2020-14897": {"epss_score": 0.01653, "epss_percentile": 0.81578}, "CVE-2020-14898": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-14899": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-14900": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-14901": {"epss_score": 0.00411, "epss_percentile": 0.60848}, "CVE-2020-14926": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2020-14927": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-14928": {"epss_score": 0.06354, "epss_percentile": 0.90693}, "CVE-2020-14929": {"epss_score": 0.00383, "epss_percentile": 0.59105}, "CVE-2020-14930": {"epss_score": 0.05816, "epss_percentile": 0.9023}, "CVE-2020-14931": {"epss_score": 0.00528, "epss_percentile": 0.66535}, "CVE-2020-14932": {"epss_score": 0.00468, "epss_percentile": 0.63883}, "CVE-2020-14933": {"epss_score": 0.00657, "epss_percentile": 0.70468}, "CVE-2020-14934": {"epss_score": 0.00593, "epss_percentile": 0.68633}, "CVE-2020-14935": {"epss_score": 0.02752, "epss_percentile": 0.85585}, "CVE-2020-14936": {"epss_score": 0.00593, "epss_percentile": 0.68633}, "CVE-2020-14937": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-14938": {"epss_score": 0.006, "epss_percentile": 0.6883}, "CVE-2020-14939": {"epss_score": 0.00363, "epss_percentile": 0.57851}, "CVE-2020-14940": {"epss_score": 0.00389, "epss_percentile": 0.5946}, "CVE-2020-14942": {"epss_score": 0.00405, "epss_percentile": 0.60494}, "CVE-2020-14943": {"epss_score": 0.00607, "epss_percentile": 0.69043}, "CVE-2020-14944": {"epss_score": 0.118, "epss_percentile": 0.93481}, "CVE-2020-14945": {"epss_score": 0.1585, "epss_percentile": 0.94519}, "CVE-2020-14946": {"epss_score": 0.08305, "epss_percentile": 0.9198}, "CVE-2020-14947": {"epss_score": 0.74707, "epss_percentile": 0.98814}, "CVE-2020-14950": {"epss_score": 0.02684, "epss_percentile": 0.85424}, "CVE-2020-14954": {"epss_score": 0.21703, "epss_percentile": 0.95549}, "CVE-2020-14955": {"epss_score": 0.00048, "epss_percentile": 0.15039}, "CVE-2020-14956": {"epss_score": 0.0004, "epss_percentile": 0.12026}, "CVE-2020-14957": {"epss_score": 0.0004, "epss_percentile": 0.12026}, "CVE-2020-14958": {"epss_score": 0.00154, "epss_percentile": 0.3669}, "CVE-2020-14959": {"epss_score": 0.00159, "epss_percentile": 0.37371}, "CVE-2020-14960": {"epss_score": 0.0039, "epss_percentile": 0.5953}, "CVE-2020-14961": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2020-14962": {"epss_score": 0.00159, "epss_percentile": 0.37371}, "CVE-2020-14965": {"epss_score": 0.00185, "epss_percentile": 0.4051}, "CVE-2020-14966": {"epss_score": 0.0028, "epss_percentile": 0.51012}, "CVE-2020-14967": {"epss_score": 0.00339, "epss_percentile": 0.56197}, "CVE-2020-14968": {"epss_score": 0.00546, "epss_percentile": 0.67203}, "CVE-2020-14969": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2020-14971": {"epss_score": 0.00067, "epss_percentile": 0.21146}, "CVE-2020-14972": {"epss_score": 0.00424, "epss_percentile": 0.61651}, "CVE-2020-14973": {"epss_score": 0.00315, "epss_percentile": 0.54163}, "CVE-2020-14974": {"epss_score": 0.02149, "epss_percentile": 0.83778}, "CVE-2020-14975": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2020-14976": {"epss_score": 0.00053, "epss_percentile": 0.17005}, "CVE-2020-14977": {"epss_score": 0.00802, "epss_percentile": 0.73586}, "CVE-2020-14978": {"epss_score": 0.00802, "epss_percentile": 0.73586}, "CVE-2020-14979": {"epss_score": 0.00426, "epss_percentile": 0.61736}, "CVE-2020-14980": {"epss_score": 0.00082, "epss_percentile": 0.24397}, "CVE-2020-14981": {"epss_score": 0.00186, "epss_percentile": 0.40688}, "CVE-2020-14982": {"epss_score": 0.00296, "epss_percentile": 0.5259}, "CVE-2020-14983": {"epss_score": 0.00681, "epss_percentile": 0.7104}, "CVE-2020-14987": {"epss_score": 0.06879, "epss_percentile": 0.91089}, "CVE-2020-14988": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-14989": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2020-14990": {"epss_score": 0.00079, "epss_percentile": 0.23836}, "CVE-2020-14993": {"epss_score": 0.06605, "epss_percentile": 0.90882}, "CVE-2020-14999": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-15000": {"epss_score": 0.00227, "epss_percentile": 0.45396}, "CVE-2020-15001": {"epss_score": 0.00084, "epss_percentile": 0.24976}, "CVE-2020-15002": {"epss_score": 0.09242, "epss_percentile": 0.92464}, "CVE-2020-15003": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2020-15004": {"epss_score": 0.08803, "epss_percentile": 0.92261}, "CVE-2020-15005": {"epss_score": 0.00737, "epss_percentile": 0.72321}, "CVE-2020-15006": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-15007": {"epss_score": 0.01995, "epss_percentile": 0.83194}, "CVE-2020-15008": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2020-15009": {"epss_score": 0.00245, "epss_percentile": 0.47635}, "CVE-2020-15011": {"epss_score": 0.01249, "epss_percentile": 0.7887}, "CVE-2020-15012": {"epss_score": 0.00809, "epss_percentile": 0.73701}, "CVE-2020-15014": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2020-15015": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-15016": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-15017": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-15018": {"epss_score": 0.002, "epss_percentile": 0.42264}, "CVE-2020-15020": {"epss_score": 0.00153, "epss_percentile": 0.36622}, "CVE-2020-15023": {"epss_score": 0.00335, "epss_percentile": 0.55802}, "CVE-2020-15024": {"epss_score": 0.00052, "epss_percentile": 0.16634}, "CVE-2020-15025": {"epss_score": 0.03011, "epss_percentile": 0.86197}, "CVE-2020-15026": {"epss_score": 0.00489, "epss_percentile": 0.64875}, "CVE-2020-15027": {"epss_score": 0.00383, "epss_percentile": 0.59117}, "CVE-2020-15028": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-15029": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-15030": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-15031": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-15032": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-15033": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-15034": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-15035": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-15036": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-15037": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-15038": {"epss_score": 0.00533, "epss_percentile": 0.66764}, "CVE-2020-15041": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-15043": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2020-15046": {"epss_score": 0.00646, "epss_percentile": 0.70147}, "CVE-2020-15047": {"epss_score": 0.00125, "epss_percentile": 0.3247}, "CVE-2020-15049": {"epss_score": 0.15653, "epss_percentile": 0.94476}, "CVE-2020-15050": {"epss_score": 0.79206, "epss_percentile": 0.99023}, "CVE-2020-15051": {"epss_score": 0.25842, "epss_percentile": 0.96078}, "CVE-2020-15052": {"epss_score": 0.09104, "epss_percentile": 0.92402}, "CVE-2020-15053": {"epss_score": 0.11797, "epss_percentile": 0.93479}, "CVE-2020-15054": {"epss_score": 0.00046, "epss_percentile": 0.1446}, "CVE-2020-15055": {"epss_score": 0.00094, "epss_percentile": 0.26805}, "CVE-2020-15056": {"epss_score": 0.00139, "epss_percentile": 0.34589}, "CVE-2020-15057": {"epss_score": 0.00113, "epss_percentile": 0.30653}, "CVE-2020-15058": {"epss_score": 0.00046, "epss_percentile": 0.1446}, "CVE-2020-15059": {"epss_score": 0.00094, "epss_percentile": 0.26805}, "CVE-2020-15060": {"epss_score": 0.00139, "epss_percentile": 0.34589}, "CVE-2020-15061": {"epss_score": 0.00084, "epss_percentile": 0.24975}, "CVE-2020-15062": {"epss_score": 0.00046, "epss_percentile": 0.1446}, "CVE-2020-15063": {"epss_score": 0.00094, "epss_percentile": 0.26805}, "CVE-2020-15064": {"epss_score": 0.00139, "epss_percentile": 0.34589}, "CVE-2020-15065": {"epss_score": 0.00084, "epss_percentile": 0.24975}, "CVE-2020-15069": {"epss_score": 0.82291, "epss_percentile": 0.99185}, "CVE-2020-15070": {"epss_score": 0.00656, "epss_percentile": 0.70444}, "CVE-2020-15071": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-15072": {"epss_score": 0.00606, "epss_percentile": 0.69024}, "CVE-2020-15073": {"epss_score": 0.0043, "epss_percentile": 0.62022}, "CVE-2020-15074": {"epss_score": 0.00188, "epss_percentile": 0.40832}, "CVE-2020-15075": {"epss_score": 0.00141, "epss_percentile": 0.349}, "CVE-2020-15076": {"epss_score": 0.00062, "epss_percentile": 0.19743}, "CVE-2020-15077": {"epss_score": 0.00092, "epss_percentile": 0.26531}, "CVE-2020-15078": {"epss_score": 0.00297, "epss_percentile": 0.52757}, "CVE-2020-15079": {"epss_score": 0.00146, "epss_percentile": 0.35621}, "CVE-2020-15080": {"epss_score": 0.00206, "epss_percentile": 0.42787}, "CVE-2020-15081": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2020-15082": {"epss_score": 0.00422, "epss_percentile": 0.61556}, "CVE-2020-15083": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-15084": {"epss_score": 0.00222, "epss_percentile": 0.448}, "CVE-2020-15085": {"epss_score": 0.00153, "epss_percentile": 0.36578}, "CVE-2020-15086": {"epss_score": 0.03678, "epss_percentile": 0.87556}, "CVE-2020-15087": {"epss_score": 0.00317, "epss_percentile": 0.54381}, "CVE-2020-15091": {"epss_score": 0.00154, "epss_percentile": 0.36702}, "CVE-2020-15092": {"epss_score": 0.01315, "epss_percentile": 0.79403}, "CVE-2020-15093": {"epss_score": 0.0012, "epss_percentile": 0.31728}, "CVE-2020-15094": {"epss_score": 0.02248, "epss_percentile": 0.84135}, "CVE-2020-15095": {"epss_score": 0.00044, "epss_percentile": 0.13548}, "CVE-2020-15096": {"epss_score": 0.00237, "epss_percentile": 0.4669}, "CVE-2020-15097": {"epss_score": 0.00465, "epss_percentile": 0.63756}, "CVE-2020-15098": {"epss_score": 0.02358, "epss_percentile": 0.8449}, "CVE-2020-15099": {"epss_score": 0.01187, "epss_percentile": 0.78357}, "CVE-2020-15100": {"epss_score": 0.00058, "epss_percentile": 0.18481}, "CVE-2020-15101": {"epss_score": 0.00174, "epss_percentile": 0.39215}, "CVE-2020-15102": {"epss_score": 0.00154, "epss_percentile": 0.3669}, "CVE-2020-15103": {"epss_score": 0.00281, "epss_percentile": 0.51152}, "CVE-2020-15104": {"epss_score": 0.00116, "epss_percentile": 0.31071}, "CVE-2020-15105": {"epss_score": 0.0016, "epss_percentile": 0.37504}, "CVE-2020-15106": {"epss_score": 0.00095, "epss_percentile": 0.27218}, "CVE-2020-15107": {"epss_score": 0.00096, "epss_percentile": 0.27415}, "CVE-2020-15108": {"epss_score": 0.00341, "epss_percentile": 0.56344}, "CVE-2020-15109": {"epss_score": 0.00206, "epss_percentile": 0.42918}, "CVE-2020-15110": {"epss_score": 0.00219, "epss_percentile": 0.44534}, "CVE-2020-15111": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-15112": {"epss_score": 0.00113, "epss_percentile": 0.30643}, "CVE-2020-15113": {"epss_score": 0.00023, "epss_percentile": 0.05495}, "CVE-2020-15114": {"epss_score": 0.00413, "epss_percentile": 0.6096}, "CVE-2020-15115": {"epss_score": 0.00332, "epss_percentile": 0.55591}, "CVE-2020-15117": {"epss_score": 0.00477, "epss_percentile": 0.64343}, "CVE-2020-15118": {"epss_score": 0.00595, "epss_percentile": 0.68693}, "CVE-2020-15119": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2020-15120": {"epss_score": 0.00223, "epss_percentile": 0.44943}, "CVE-2020-15121": {"epss_score": 0.00593, "epss_percentile": 0.68634}, "CVE-2020-15123": {"epss_score": 0.00147, "epss_percentile": 0.35693}, "CVE-2020-15124": {"epss_score": 0.00186, "epss_percentile": 0.40695}, "CVE-2020-15125": {"epss_score": 0.00308, "epss_percentile": 0.53636}, "CVE-2020-15126": {"epss_score": 0.00461, "epss_percentile": 0.63557}, "CVE-2020-15127": {"epss_score": 0.00311, "epss_percentile": 0.53935}, "CVE-2020-15128": {"epss_score": 0.00113, "epss_percentile": 0.3065}, "CVE-2020-15129": {"epss_score": 0.76842, "epss_percentile": 0.98908}, "CVE-2020-15130": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-15131": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-15132": {"epss_score": 0.00276, "epss_percentile": 0.50751}, "CVE-2020-15133": {"epss_score": 0.00143, "epss_percentile": 0.35204}, "CVE-2020-15134": {"epss_score": 0.00122, "epss_percentile": 0.32068}, "CVE-2020-15135": {"epss_score": 0.00122, "epss_percentile": 0.32155}, "CVE-2020-15136": {"epss_score": 0.00308, "epss_percentile": 0.53631}, "CVE-2020-15137": {"epss_score": 0.00067, "epss_percentile": 0.21033}, "CVE-2020-15138": {"epss_score": 0.00864, "epss_percentile": 0.74597}, "CVE-2020-15139": {"epss_score": 0.00593, "epss_percentile": 0.68638}, "CVE-2020-15140": {"epss_score": 0.00281, "epss_percentile": 0.51188}, "CVE-2020-15141": {"epss_score": 0.00362, "epss_percentile": 0.5781}, "CVE-2020-15142": {"epss_score": 0.00757, "epss_percentile": 0.7276}, "CVE-2020-15143": {"epss_score": 0.01064, "epss_percentile": 0.77195}, "CVE-2020-15145": {"epss_score": 0.00047, "epss_percentile": 0.14776}, "CVE-2020-15146": {"epss_score": 0.01064, "epss_percentile": 0.77195}, "CVE-2020-15147": {"epss_score": 0.02356, "epss_percentile": 0.84483}, "CVE-2020-15148": {"epss_score": 0.93433, "epss_percentile": 0.99806}, "CVE-2020-15149": {"epss_score": 0.00438, "epss_percentile": 0.62557}, "CVE-2020-15150": {"epss_score": 0.05345, "epss_percentile": 0.89767}, "CVE-2020-15151": {"epss_score": 0.00088, "epss_percentile": 0.25735}, "CVE-2020-15152": {"epss_score": 0.00215, "epss_percentile": 0.44055}, "CVE-2020-15153": {"epss_score": 0.02059, "epss_percentile": 0.83435}, "CVE-2020-15154": {"epss_score": 0.00784, "epss_percentile": 0.73245}, "CVE-2020-15155": {"epss_score": 0.00868, "epss_percentile": 0.74679}, "CVE-2020-15156": {"epss_score": 0.00206, "epss_percentile": 0.43056}, "CVE-2020-15157": {"epss_score": 0.0137, "epss_percentile": 0.79802}, "CVE-2020-15158": {"epss_score": 0.0238, "epss_percentile": 0.84563}, "CVE-2020-15159": {"epss_score": 0.01563, "epss_percentile": 0.81056}, "CVE-2020-15160": {"epss_score": 0.31624, "epss_percentile": 0.96639}, "CVE-2020-15161": {"epss_score": 0.00291, "epss_percentile": 0.52152}, "CVE-2020-15162": {"epss_score": 0.00249, "epss_percentile": 0.4806}, "CVE-2020-15163": {"epss_score": 0.00144, "epss_percentile": 0.35256}, "CVE-2020-15164": {"epss_score": 0.00259, "epss_percentile": 0.49044}, "CVE-2020-15165": {"epss_score": 0.00199, "epss_percentile": 0.42115}, "CVE-2020-15166": {"epss_score": 0.00303, "epss_percentile": 0.53233}, "CVE-2020-15167": {"epss_score": 0.00119, "epss_percentile": 0.31678}, "CVE-2020-15168": {"epss_score": 0.00114, "epss_percentile": 0.30735}, "CVE-2020-15169": {"epss_score": 0.0115, "epss_percentile": 0.78031}, "CVE-2020-15170": {"epss_score": 0.00276, "epss_percentile": 0.50752}, "CVE-2020-15171": {"epss_score": 0.00734, "epss_percentile": 0.72252}, "CVE-2020-15172": {"epss_score": 0.00396, "epss_percentile": 0.59875}, "CVE-2020-15173": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2020-15174": {"epss_score": 0.00189, "epss_percentile": 0.40951}, "CVE-2020-15175": {"epss_score": 0.09825, "epss_percentile": 0.9272}, "CVE-2020-15176": {"epss_score": 0.00281, "epss_percentile": 0.51144}, "CVE-2020-15177": {"epss_score": 0.00305, "epss_percentile": 0.53387}, "CVE-2020-15178": {"epss_score": 0.00583, "epss_percentile": 0.68357}, "CVE-2020-15179": {"epss_score": 0.00433, "epss_percentile": 0.62207}, "CVE-2020-15180": {"epss_score": 0.06796, "epss_percentile": 0.91032}, "CVE-2020-15181": {"epss_score": 0.0023, "epss_percentile": 0.45708}, "CVE-2020-15182": {"epss_score": 0.01174, "epss_percentile": 0.78255}, "CVE-2020-15183": {"epss_score": 0.00771, "epss_percentile": 0.73022}, "CVE-2020-15184": {"epss_score": 0.00234, "epss_percentile": 0.46111}, "CVE-2020-15185": {"epss_score": 0.00234, "epss_percentile": 0.46111}, "CVE-2020-15186": {"epss_score": 0.00234, "epss_percentile": 0.46111}, "CVE-2020-15187": {"epss_score": 0.00148, "epss_percentile": 0.35841}, "CVE-2020-15188": {"epss_score": 0.04693, "epss_percentile": 0.89014}, "CVE-2020-15189": {"epss_score": 0.05039, "epss_percentile": 0.89424}, "CVE-2020-15190": {"epss_score": 0.00189, "epss_percentile": 0.40931}, "CVE-2020-15191": {"epss_score": 0.00246, "epss_percentile": 0.47772}, "CVE-2020-15192": {"epss_score": 0.00226, "epss_percentile": 0.45286}, "CVE-2020-15193": {"epss_score": 0.00215, "epss_percentile": 0.44058}, "CVE-2020-15194": {"epss_score": 0.0022, "epss_percentile": 0.44572}, "CVE-2020-15195": {"epss_score": 0.00355, "epss_percentile": 0.57275}, "CVE-2020-15196": {"epss_score": 0.00302, "epss_percentile": 0.53107}, "CVE-2020-15197": {"epss_score": 0.0022, "epss_percentile": 0.44564}, "CVE-2020-15198": {"epss_score": 0.00169, "epss_percentile": 0.38538}, "CVE-2020-15199": {"epss_score": 0.00239, "epss_percentile": 0.46854}, "CVE-2020-15200": {"epss_score": 0.00276, "epss_percentile": 0.50722}, "CVE-2020-15201": {"epss_score": 0.00195, "epss_percentile": 0.41663}, "CVE-2020-15202": {"epss_score": 0.00502, "epss_percentile": 0.65393}, "CVE-2020-15203": {"epss_score": 0.0036, "epss_percentile": 0.57664}, "CVE-2020-15204": {"epss_score": 0.00221, "epss_percentile": 0.44637}, "CVE-2020-15205": {"epss_score": 0.00544, "epss_percentile": 0.6715}, "CVE-2020-15206": {"epss_score": 0.00472, "epss_percentile": 0.64067}, "CVE-2020-15207": {"epss_score": 0.01411, "epss_percentile": 0.80085}, "CVE-2020-15208": {"epss_score": 0.0033, "epss_percentile": 0.55483}, "CVE-2020-15209": {"epss_score": 0.00357, "epss_percentile": 0.5746}, "CVE-2020-15210": {"epss_score": 0.00329, "epss_percentile": 0.55408}, "CVE-2020-15211": {"epss_score": 0.00344, "epss_percentile": 0.56482}, "CVE-2020-15212": {"epss_score": 0.00238, "epss_percentile": 0.46841}, "CVE-2020-15213": {"epss_score": 0.00217, "epss_percentile": 0.4432}, "CVE-2020-15214": {"epss_score": 0.00261, "epss_percentile": 0.49262}, "CVE-2020-15215": {"epss_score": 0.00282, "epss_percentile": 0.51227}, "CVE-2020-15216": {"epss_score": 0.00209, "epss_percentile": 0.43331}, "CVE-2020-15217": {"epss_score": 0.00234, "epss_percentile": 0.46122}, "CVE-2020-15218": {"epss_score": 0.0023, "epss_percentile": 0.45725}, "CVE-2020-15219": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2020-15220": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2020-15221": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2020-15222": {"epss_score": 0.00117, "epss_percentile": 0.31331}, "CVE-2020-15223": {"epss_score": 0.00475, "epss_percentile": 0.64199}, "CVE-2020-15224": {"epss_score": 0.00102, "epss_percentile": 0.28873}, "CVE-2020-15225": {"epss_score": 0.00235, "epss_percentile": 0.46332}, "CVE-2020-15226": {"epss_score": 0.00293, "epss_percentile": 0.5233}, "CVE-2020-15227": {"epss_score": 0.93793, "epss_percentile": 0.99847}, "CVE-2020-15228": {"epss_score": 0.00322, "epss_percentile": 0.54783}, "CVE-2020-15229": {"epss_score": 0.00876, "epss_percentile": 0.74791}, "CVE-2020-15230": {"epss_score": 0.00567, "epss_percentile": 0.67859}, "CVE-2020-15231": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2020-15232": {"epss_score": 0.00342, "epss_percentile": 0.56353}, "CVE-2020-15233": {"epss_score": 0.00255, "epss_percentile": 0.48637}, "CVE-2020-15234": {"epss_score": 0.00255, "epss_percentile": 0.48637}, "CVE-2020-15235": {"epss_score": 0.00708, "epss_percentile": 0.71682}, "CVE-2020-15236": {"epss_score": 0.0047, "epss_percentile": 0.6397}, "CVE-2020-15237": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-15238": {"epss_score": 0.00451, "epss_percentile": 0.63151}, "CVE-2020-15239": {"epss_score": 0.00127, "epss_percentile": 0.32801}, "CVE-2020-15240": {"epss_score": 0.00087, "epss_percentile": 0.25487}, "CVE-2020-15241": {"epss_score": 0.00341, "epss_percentile": 0.56343}, "CVE-2020-15242": {"epss_score": 0.00211, "epss_percentile": 0.43712}, "CVE-2020-15243": {"epss_score": 0.00277, "epss_percentile": 0.50826}, "CVE-2020-15244": {"epss_score": 0.0087, "epss_percentile": 0.74703}, "CVE-2020-15245": {"epss_score": 0.00174, "epss_percentile": 0.39196}, "CVE-2020-15246": {"epss_score": 0.01094, "epss_percentile": 0.77487}, "CVE-2020-15247": {"epss_score": 0.00146, "epss_percentile": 0.35574}, "CVE-2020-15248": {"epss_score": 0.00049, "epss_percentile": 0.15325}, "CVE-2020-15249": {"epss_score": 0.00165, "epss_percentile": 0.38134}, "CVE-2020-15250": {"epss_score": 0.00056, "epss_percentile": 0.17738}, "CVE-2020-15251": {"epss_score": 0.00349, "epss_percentile": 0.56863}, "CVE-2020-15252": {"epss_score": 0.02703, "epss_percentile": 0.85458}, "CVE-2020-15253": {"epss_score": 0.00621, "epss_percentile": 0.69484}, "CVE-2020-15254": {"epss_score": 0.0051, "epss_percentile": 0.6576}, "CVE-2020-15255": {"epss_score": 0.01181, "epss_percentile": 0.78306}, "CVE-2020-15256": {"epss_score": 0.00175, "epss_percentile": 0.39334}, "CVE-2020-15257": {"epss_score": 0.11147, "epss_percentile": 0.93239}, "CVE-2020-15258": {"epss_score": 0.00729, "epss_percentile": 0.72129}, "CVE-2020-15259": {"epss_score": 0.00246, "epss_percentile": 0.47775}, "CVE-2020-15260": {"epss_score": 0.00185, "epss_percentile": 0.40516}, "CVE-2020-15261": {"epss_score": 0.08057, "epss_percentile": 0.91857}, "CVE-2020-15262": {"epss_score": 0.00159, "epss_percentile": 0.3737}, "CVE-2020-15263": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2020-15264": {"epss_score": 0.00271, "epss_percentile": 0.50281}, "CVE-2020-15265": {"epss_score": 0.00239, "epss_percentile": 0.46854}, "CVE-2020-15266": {"epss_score": 0.00129, "epss_percentile": 0.33191}, "CVE-2020-15269": {"epss_score": 0.00257, "epss_percentile": 0.48877}, "CVE-2020-15270": {"epss_score": 0.00253, "epss_percentile": 0.48475}, "CVE-2020-15271": {"epss_score": 0.00356, "epss_percentile": 0.57347}, "CVE-2020-15272": {"epss_score": 0.00343, "epss_percentile": 0.56453}, "CVE-2020-15273": {"epss_score": 0.00414, "epss_percentile": 0.61093}, "CVE-2020-15274": {"epss_score": 0.0059, "epss_percentile": 0.68558}, "CVE-2020-15275": {"epss_score": 0.00416, "epss_percentile": 0.61177}, "CVE-2020-15276": {"epss_score": 0.00592, "epss_percentile": 0.68605}, "CVE-2020-15277": {"epss_score": 0.03225, "epss_percentile": 0.86685}, "CVE-2020-15278": {"epss_score": 0.00261, "epss_percentile": 0.49307}, "CVE-2020-15279": {"epss_score": 0.00113, "epss_percentile": 0.30699}, "CVE-2020-15292": {"epss_score": 0.00045, "epss_percentile": 0.1375}, "CVE-2020-15293": {"epss_score": 0.00053, "epss_percentile": 0.16702}, "CVE-2020-15294": {"epss_score": 0.00063, "epss_percentile": 0.20076}, "CVE-2020-15297": {"epss_score": 0.00178, "epss_percentile": 0.39671}, "CVE-2020-15299": {"epss_score": 0.00236, "epss_percentile": 0.46434}, "CVE-2020-15300": {"epss_score": 0.00285, "epss_percentile": 0.51641}, "CVE-2020-15301": {"epss_score": 0.00273, "epss_percentile": 0.50472}, "CVE-2020-15302": {"epss_score": 0.00251, "epss_percentile": 0.48334}, "CVE-2020-15303": {"epss_score": 0.0039, "epss_percentile": 0.5955}, "CVE-2020-15304": {"epss_score": 0.00122, "epss_percentile": 0.32173}, "CVE-2020-15305": {"epss_score": 0.00113, "epss_percentile": 0.30598}, "CVE-2020-15306": {"epss_score": 0.0013, "epss_percentile": 0.333}, "CVE-2020-15307": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-15308": {"epss_score": 0.00365, "epss_percentile": 0.57978}, "CVE-2020-15309": {"epss_score": 0.00103, "epss_percentile": 0.29085}, "CVE-2020-15312": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2020-15313": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2020-15314": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2020-15315": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2020-15316": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2020-15317": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2020-15318": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2020-15319": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2020-15320": {"epss_score": 0.0051, "epss_percentile": 0.658}, "CVE-2020-15321": {"epss_score": 0.0051, "epss_percentile": 0.658}, "CVE-2020-15322": {"epss_score": 0.0051, "epss_percentile": 0.658}, "CVE-2020-15323": {"epss_score": 0.0051, "epss_percentile": 0.658}, "CVE-2020-15324": {"epss_score": 0.0051, "epss_percentile": 0.658}, "CVE-2020-15325": {"epss_score": 0.00111, "epss_percentile": 0.30267}, "CVE-2020-15326": {"epss_score": 0.00113, "epss_percentile": 0.30686}, "CVE-2020-15327": {"epss_score": 0.00232, "epss_percentile": 0.4596}, "CVE-2020-15328": {"epss_score": 0.00159, "epss_percentile": 0.37383}, "CVE-2020-15329": {"epss_score": 0.00159, "epss_percentile": 0.37383}, "CVE-2020-15330": {"epss_score": 0.00111, "epss_percentile": 0.30267}, "CVE-2020-15331": {"epss_score": 0.00284, "epss_percentile": 0.51449}, "CVE-2020-15332": {"epss_score": 0.00215, "epss_percentile": 0.44027}, "CVE-2020-15333": {"epss_score": 0.00309, "epss_percentile": 0.5366}, "CVE-2020-15334": {"epss_score": 0.00249, "epss_percentile": 0.4802}, "CVE-2020-15335": {"epss_score": 0.00217, "epss_percentile": 0.44313}, "CVE-2020-15336": {"epss_score": 0.00217, "epss_percentile": 0.44313}, "CVE-2020-15337": {"epss_score": 0.00209, "epss_percentile": 0.43382}, "CVE-2020-15338": {"epss_score": 0.00209, "epss_percentile": 0.43382}, "CVE-2020-15339": {"epss_score": 0.00326, "epss_percentile": 0.55069}, "CVE-2020-15340": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2020-15341": {"epss_score": 0.0031, "epss_percentile": 0.53802}, "CVE-2020-15342": {"epss_score": 0.00222, "epss_percentile": 0.44716}, "CVE-2020-15343": {"epss_score": 0.0012, "epss_percentile": 0.31744}, "CVE-2020-15344": {"epss_score": 0.0012, "epss_percentile": 0.31744}, "CVE-2020-15345": {"epss_score": 0.0012, "epss_percentile": 0.31744}, "CVE-2020-15346": {"epss_score": 0.00111, "epss_percentile": 0.30267}, "CVE-2020-15347": {"epss_score": 0.0051, "epss_percentile": 0.658}, "CVE-2020-15348": {"epss_score": 0.01236, "epss_percentile": 0.78772}, "CVE-2020-15349": {"epss_score": 0.00186, "epss_percentile": 0.4064}, "CVE-2020-15350": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2020-15351": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2020-15352": {"epss_score": 0.06555, "epss_percentile": 0.90845}, "CVE-2020-15357": {"epss_score": 0.06076, "epss_percentile": 0.90457}, "CVE-2020-15358": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2020-15360": {"epss_score": 0.00058, "epss_percentile": 0.18455}, "CVE-2020-15362": {"epss_score": 0.01201, "epss_percentile": 0.78484}, "CVE-2020-15363": {"epss_score": 0.20446, "epss_percentile": 0.95346}, "CVE-2020-15364": {"epss_score": 0.00818, "epss_percentile": 0.73854}, "CVE-2020-15365": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2020-15366": {"epss_score": 0.00331, "epss_percentile": 0.55541}, "CVE-2020-15367": {"epss_score": 0.02647, "epss_percentile": 0.85337}, "CVE-2020-15368": {"epss_score": 0.13651, "epss_percentile": 0.94021}, "CVE-2020-15369": {"epss_score": 0.0022, "epss_percentile": 0.44622}, "CVE-2020-15370": {"epss_score": 0.00249, "epss_percentile": 0.4807}, "CVE-2020-15371": {"epss_score": 0.00571, "epss_percentile": 0.67986}, "CVE-2020-15372": {"epss_score": 0.00072, "epss_percentile": 0.22295}, "CVE-2020-15373": {"epss_score": 0.00926, "epss_percentile": 0.75556}, "CVE-2020-15374": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2020-15375": {"epss_score": 0.00049, "epss_percentile": 0.15614}, "CVE-2020-15376": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2020-15377": {"epss_score": 0.00551, "epss_percentile": 0.67364}, "CVE-2020-15378": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2020-15379": {"epss_score": 0.00449, "epss_percentile": 0.63043}, "CVE-2020-15380": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-15381": {"epss_score": 0.00251, "epss_percentile": 0.48273}, "CVE-2020-15382": {"epss_score": 0.00273, "epss_percentile": 0.50476}, "CVE-2020-15383": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2020-15384": {"epss_score": 0.00111, "epss_percentile": 0.30267}, "CVE-2020-15385": {"epss_score": 0.0022, "epss_percentile": 0.44599}, "CVE-2020-15386": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2020-15387": {"epss_score": 0.00124, "epss_percentile": 0.32434}, "CVE-2020-15388": {"epss_score": 0.00232, "epss_percentile": 0.45879}, "CVE-2020-15389": {"epss_score": 0.00269, "epss_percentile": 0.50115}, "CVE-2020-15390": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2020-15391": {"epss_score": 0.02381, "epss_percentile": 0.84566}, "CVE-2020-15392": {"epss_score": 0.00376, "epss_percentile": 0.58679}, "CVE-2020-15393": {"epss_score": 0.00085, "epss_percentile": 0.25089}, "CVE-2020-15394": {"epss_score": 0.31375, "epss_percentile": 0.96615}, "CVE-2020-15395": {"epss_score": 0.00466, "epss_percentile": 0.63799}, "CVE-2020-15396": {"epss_score": 0.00073, "epss_percentile": 0.22673}, "CVE-2020-15397": {"epss_score": 0.00228, "epss_percentile": 0.45467}, "CVE-2020-15400": {"epss_score": 0.0017, "epss_percentile": 0.3873}, "CVE-2020-15401": {"epss_score": 0.00097, "epss_percentile": 0.27613}, "CVE-2020-15408": {"epss_score": 0.00328, "epss_percentile": 0.55187}, "CVE-2020-15411": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-15412": {"epss_score": 0.00154, "epss_percentile": 0.3669}, "CVE-2020-15415": {"epss_score": 0.93115, "epss_percentile": 0.99776}, "CVE-2020-15416": {"epss_score": 0.01528, "epss_percentile": 0.80871}, "CVE-2020-15417": {"epss_score": 0.00202, "epss_percentile": 0.42421}, "CVE-2020-15418": {"epss_score": 0.21848, "epss_percentile": 0.95567}, "CVE-2020-15419": {"epss_score": 0.23768, "epss_percentile": 0.95814}, "CVE-2020-15420": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15421": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15422": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15423": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15424": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15425": {"epss_score": 0.01985, "epss_percentile": 0.83155}, "CVE-2020-15426": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15427": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15428": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15429": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15430": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15431": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15432": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15433": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15434": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15435": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15436": {"epss_score": 0.00151, "epss_percentile": 0.36364}, "CVE-2020-15437": {"epss_score": 0.00043, "epss_percentile": 0.13123}, "CVE-2020-15466": {"epss_score": 0.00631, "epss_percentile": 0.69712}, "CVE-2020-15467": {"epss_score": 0.05534, "epss_percentile": 0.89969}, "CVE-2020-15468": {"epss_score": 0.0107, "epss_percentile": 0.77261}, "CVE-2020-15469": {"epss_score": 0.0004, "epss_percentile": 0.12096}, "CVE-2020-15470": {"epss_score": 0.00146, "epss_percentile": 0.35639}, "CVE-2020-15471": {"epss_score": 0.00559, "epss_percentile": 0.67626}, "CVE-2020-15472": {"epss_score": 0.00616, "epss_percentile": 0.69319}, "CVE-2020-15473": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-15474": {"epss_score": 0.00502, "epss_percentile": 0.65402}, "CVE-2020-15475": {"epss_score": 0.00694, "epss_percentile": 0.71344}, "CVE-2020-15476": {"epss_score": 0.01065, "epss_percentile": 0.77206}, "CVE-2020-15477": {"epss_score": 0.08172, "epss_percentile": 0.91914}, "CVE-2020-15478": {"epss_score": 0.11952, "epss_percentile": 0.93525}, "CVE-2020-15479": {"epss_score": 0.00086, "epss_percentile": 0.25348}, "CVE-2020-15480": {"epss_score": 0.00074, "epss_percentile": 0.22856}, "CVE-2020-15481": {"epss_score": 0.00174, "epss_percentile": 0.39161}, "CVE-2020-15482": {"epss_score": 0.00019, "epss_percentile": 0.04097}, "CVE-2020-15483": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2020-15484": {"epss_score": 0.00133, "epss_percentile": 0.33689}, "CVE-2020-15485": {"epss_score": 0.00028, "epss_percentile": 0.07447}, "CVE-2020-15486": {"epss_score": 0.00156, "epss_percentile": 0.36991}, "CVE-2020-15487": {"epss_score": 0.03147, "epss_percentile": 0.86497}, "CVE-2020-15488": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-15489": {"epss_score": 0.03602, "epss_percentile": 0.87412}, "CVE-2020-15490": {"epss_score": 0.03845, "epss_percentile": 0.8784}, "CVE-2020-15492": {"epss_score": 0.37735, "epss_percentile": 0.97066}, "CVE-2020-15495": {"epss_score": 0.00039, "epss_percentile": 0.11466}, "CVE-2020-15496": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2020-15497": {"epss_score": 0.0044, "epss_percentile": 0.62644}, "CVE-2020-15498": {"epss_score": 0.00107, "epss_percentile": 0.29578}, "CVE-2020-15499": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-15500": {"epss_score": 0.19227, "epss_percentile": 0.95152}, "CVE-2020-15501": {"epss_score": 0.00309, "epss_percentile": 0.53668}, "CVE-2020-15502": {"epss_score": 0.00561, "epss_percentile": 0.67659}, "CVE-2020-15503": {"epss_score": 0.0387, "epss_percentile": 0.87878}, "CVE-2020-15504": {"epss_score": 0.0011, "epss_percentile": 0.30114}, "CVE-2020-15505": {"epss_score": 0.94388, "epss_percentile": 0.99969}, "CVE-2020-15506": {"epss_score": 0.00713, "epss_percentile": 0.71782}, "CVE-2020-15507": {"epss_score": 0.01541, "epss_percentile": 0.80948}, "CVE-2020-15509": {"epss_score": 0.00051, "epss_percentile": 0.16268}, "CVE-2020-15511": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-15513": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2020-15514": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-15515": {"epss_score": 0.0216, "epss_percentile": 0.83823}, "CVE-2020-15516": {"epss_score": 0.00113, "epss_percentile": 0.30584}, "CVE-2020-15517": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-15518": {"epss_score": 0.00284, "epss_percentile": 0.5143}, "CVE-2020-15521": {"epss_score": 0.07335, "epss_percentile": 0.91417}, "CVE-2020-15522": {"epss_score": 0.0041, "epss_percentile": 0.60841}, "CVE-2020-15523": {"epss_score": 0.00115, "epss_percentile": 0.30949}, "CVE-2020-15525": {"epss_score": 0.00118, "epss_percentile": 0.31455}, "CVE-2020-15526": {"epss_score": 0.00126, "epss_percentile": 0.32728}, "CVE-2020-15528": {"epss_score": 0.00097, "epss_percentile": 0.27529}, "CVE-2020-15529": {"epss_score": 0.00082, "epss_percentile": 0.24446}, "CVE-2020-15530": {"epss_score": 0.00023, "epss_percentile": 0.05459}, "CVE-2020-15531": {"epss_score": 0.09724, "epss_percentile": 0.92677}, "CVE-2020-15532": {"epss_score": 0.00142, "epss_percentile": 0.34956}, "CVE-2020-15533": {"epss_score": 0.11446, "epss_percentile": 0.93363}, "CVE-2020-15535": {"epss_score": 0.0019, "epss_percentile": 0.41114}, "CVE-2020-15536": {"epss_score": 0.0019, "epss_percentile": 0.41114}, "CVE-2020-15537": {"epss_score": 0.00174, "epss_percentile": 0.39185}, "CVE-2020-15538": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2020-15539": {"epss_score": 0.00622, "epss_percentile": 0.6953}, "CVE-2020-15540": {"epss_score": 0.00622, "epss_percentile": 0.6953}, "CVE-2020-15541": {"epss_score": 0.21211, "epss_percentile": 0.95477}, "CVE-2020-15542": {"epss_score": 0.04449, "epss_percentile": 0.88702}, "CVE-2020-15543": {"epss_score": 0.04449, "epss_percentile": 0.88702}, "CVE-2020-15562": {"epss_score": 0.00861, "epss_percentile": 0.74563}, "CVE-2020-15563": {"epss_score": 0.00076, "epss_percentile": 0.23131}, "CVE-2020-15564": {"epss_score": 0.00081, "epss_percentile": 0.24323}, "CVE-2020-15565": {"epss_score": 0.00076, "epss_percentile": 0.23274}, "CVE-2020-15566": {"epss_score": 0.00055, "epss_percentile": 0.17467}, "CVE-2020-15567": {"epss_score": 0.00056, "epss_percentile": 0.17763}, "CVE-2020-15568": {"epss_score": 0.93438, "epss_percentile": 0.99807}, "CVE-2020-15569": {"epss_score": 0.002, "epss_percentile": 0.42261}, "CVE-2020-15570": {"epss_score": 0.00311, "epss_percentile": 0.53838}, "CVE-2020-15572": {"epss_score": 0.00505, "epss_percentile": 0.65586}, "CVE-2020-15573": {"epss_score": 0.03318, "epss_percentile": 0.86906}, "CVE-2020-15574": {"epss_score": 0.02906, "epss_percentile": 0.85963}, "CVE-2020-15575": {"epss_score": 0.03318, "epss_percentile": 0.86906}, "CVE-2020-15576": {"epss_score": 0.02906, "epss_percentile": 0.85963}, "CVE-2020-15577": {"epss_score": 0.0004, "epss_percentile": 0.12004}, "CVE-2020-15578": {"epss_score": 0.00013, "epss_percentile": 0.0148}, "CVE-2020-15579": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2020-15580": {"epss_score": 0.00018, "epss_percentile": 0.03704}, "CVE-2020-15581": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2020-15582": {"epss_score": 0.00054, "epss_percentile": 0.17218}, "CVE-2020-15583": {"epss_score": 0.00018, "epss_percentile": 0.03982}, "CVE-2020-15584": {"epss_score": 0.00053, "epss_percentile": 0.1669}, "CVE-2020-15586": {"epss_score": 0.00614, "epss_percentile": 0.69287}, "CVE-2020-15588": {"epss_score": 0.05976, "epss_percentile": 0.90375}, "CVE-2020-15589": {"epss_score": 0.03581, "epss_percentile": 0.87384}, "CVE-2020-15590": {"epss_score": 0.00523, "epss_percentile": 0.66305}, "CVE-2020-15591": {"epss_score": 0.05254, "epss_percentile": 0.89666}, "CVE-2020-15592": {"epss_score": 0.0102, "epss_percentile": 0.76734}, "CVE-2020-15593": {"epss_score": 0.00129, "epss_percentile": 0.33098}, "CVE-2020-15594": {"epss_score": 0.005, "epss_percentile": 0.65303}, "CVE-2020-15595": {"epss_score": 0.02179, "epss_percentile": 0.83895}, "CVE-2020-15596": {"epss_score": 0.0011, "epss_percentile": 0.30132}, "CVE-2020-15597": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-15598": {"epss_score": 0.03785, "epss_percentile": 0.87724}, "CVE-2020-15599": {"epss_score": 0.00236, "epss_percentile": 0.46458}, "CVE-2020-15600": {"epss_score": 0.00285, "epss_percentile": 0.51534}, "CVE-2020-15601": {"epss_score": 0.03824, "epss_percentile": 0.8779}, "CVE-2020-15602": {"epss_score": 0.01406, "epss_percentile": 0.80046}, "CVE-2020-15603": {"epss_score": 0.00801, "epss_percentile": 0.73561}, "CVE-2020-15604": {"epss_score": 0.00232, "epss_percentile": 0.45934}, "CVE-2020-15605": {"epss_score": 0.03824, "epss_percentile": 0.8779}, "CVE-2020-15606": {"epss_score": 0.01985, "epss_percentile": 0.83155}, "CVE-2020-15607": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15608": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15609": {"epss_score": 0.06624, "epss_percentile": 0.90898}, "CVE-2020-15610": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15611": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15612": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15613": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15614": {"epss_score": 0.0207, "epss_percentile": 0.83479}, "CVE-2020-15615": {"epss_score": 0.01985, "epss_percentile": 0.83155}, "CVE-2020-15616": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2020-15617": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2020-15618": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2020-15619": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2020-15620": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2020-15621": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2020-15622": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2020-15623": {"epss_score": 0.03181, "epss_percentile": 0.86581}, "CVE-2020-15624": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2020-15625": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2020-15626": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2020-15627": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2020-15628": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2020-15629": {"epss_score": 0.02325, "epss_percentile": 0.84387}, "CVE-2020-15630": {"epss_score": 0.05236, "epss_percentile": 0.89647}, "CVE-2020-15631": {"epss_score": 0.01744, "epss_percentile": 0.82063}, "CVE-2020-15632": {"epss_score": 0.04203, "epss_percentile": 0.8839}, "CVE-2020-15633": {"epss_score": 0.00706, "epss_percentile": 0.71636}, "CVE-2020-15634": {"epss_score": 0.00343, "epss_percentile": 0.56464}, "CVE-2020-15635": {"epss_score": 0.00345, "epss_percentile": 0.56585}, "CVE-2020-15636": {"epss_score": 0.19805, "epss_percentile": 0.95244}, "CVE-2020-15637": {"epss_score": 0.0176, "epss_percentile": 0.82148}, "CVE-2020-15638": {"epss_score": 0.00761, "epss_percentile": 0.72823}, "CVE-2020-15639": {"epss_score": 0.19374, "epss_percentile": 0.9517}, "CVE-2020-15640": {"epss_score": 0.0174, "epss_percentile": 0.82044}, "CVE-2020-15641": {"epss_score": 0.0174, "epss_percentile": 0.82044}, "CVE-2020-15642": {"epss_score": 0.11564, "epss_percentile": 0.93405}, "CVE-2020-15643": {"epss_score": 0.05359, "epss_percentile": 0.89782}, "CVE-2020-15644": {"epss_score": 0.10659, "epss_percentile": 0.93061}, "CVE-2020-15645": {"epss_score": 0.02778, "epss_percentile": 0.85645}, "CVE-2020-15646": {"epss_score": 0.00254, "epss_percentile": 0.48529}, "CVE-2020-15647": {"epss_score": 0.00248, "epss_percentile": 0.4796}, "CVE-2020-15648": {"epss_score": 0.00316, "epss_percentile": 0.54285}, "CVE-2020-15649": {"epss_score": 0.00243, "epss_percentile": 0.47424}, "CVE-2020-15650": {"epss_score": 0.00248, "epss_percentile": 0.47936}, "CVE-2020-15651": {"epss_score": 0.00186, "epss_percentile": 0.40602}, "CVE-2020-15652": {"epss_score": 0.01055, "epss_percentile": 0.7712}, "CVE-2020-15653": {"epss_score": 0.00284, "epss_percentile": 0.51477}, "CVE-2020-15654": {"epss_score": 0.00462, "epss_percentile": 0.63619}, "CVE-2020-15655": {"epss_score": 0.00229, "epss_percentile": 0.45659}, "CVE-2020-15656": {"epss_score": 0.00842, "epss_percentile": 0.74234}, "CVE-2020-15657": {"epss_score": 0.00199, "epss_percentile": 0.42162}, "CVE-2020-15658": {"epss_score": 0.00491, "epss_percentile": 0.64958}, "CVE-2020-15659": {"epss_score": 0.0093, "epss_percentile": 0.75596}, "CVE-2020-15660": {"epss_score": 0.0054, "epss_percentile": 0.67017}, "CVE-2020-15661": {"epss_score": 0.00212, "epss_percentile": 0.43812}, "CVE-2020-15662": {"epss_score": 0.00186, "epss_percentile": 0.40602}, "CVE-2020-15663": {"epss_score": 0.01674, "epss_percentile": 0.81695}, "CVE-2020-15664": {"epss_score": 0.00371, "epss_percentile": 0.58352}, "CVE-2020-15665": {"epss_score": 0.00186, "epss_percentile": 0.40589}, "CVE-2020-15666": {"epss_score": 0.00373, "epss_percentile": 0.58497}, "CVE-2020-15667": {"epss_score": 0.00891, "epss_percentile": 0.75052}, "CVE-2020-15668": {"epss_score": 0.00205, "epss_percentile": 0.42761}, "CVE-2020-15669": {"epss_score": 0.00451, "epss_percentile": 0.63151}, "CVE-2020-15670": {"epss_score": 0.00384, "epss_percentile": 0.59128}, "CVE-2020-15671": {"epss_score": 0.00141, "epss_percentile": 0.34908}, "CVE-2020-15673": {"epss_score": 0.00869, "epss_percentile": 0.74688}, "CVE-2020-15674": {"epss_score": 0.00311, "epss_percentile": 0.53812}, "CVE-2020-15675": {"epss_score": 0.00404, "epss_percentile": 0.60396}, "CVE-2020-15676": {"epss_score": 0.01265, "epss_percentile": 0.79006}, "CVE-2020-15677": {"epss_score": 0.00527, "epss_percentile": 0.66466}, "CVE-2020-15678": {"epss_score": 0.00869, "epss_percentile": 0.74688}, "CVE-2020-15679": {"epss_score": 0.00577, "epss_percentile": 0.68173}, "CVE-2020-15680": {"epss_score": 0.00318, "epss_percentile": 0.54432}, "CVE-2020-15681": {"epss_score": 0.00434, "epss_percentile": 0.6232}, "CVE-2020-15682": {"epss_score": 0.00133, "epss_percentile": 0.33694}, "CVE-2020-15683": {"epss_score": 0.01566, "epss_percentile": 0.8107}, "CVE-2020-15684": {"epss_score": 0.00419, "epss_percentile": 0.61382}, "CVE-2020-15685": {"epss_score": 0.00497, "epss_percentile": 0.65208}, "CVE-2020-15687": {"epss_score": 0.00408, "epss_percentile": 0.60647}, "CVE-2020-15688": {"epss_score": 0.00269, "epss_percentile": 0.50118}, "CVE-2020-15689": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2020-15690": {"epss_score": 0.02523, "epss_percentile": 0.85009}, "CVE-2020-15692": {"epss_score": 0.0209, "epss_percentile": 0.83565}, "CVE-2020-15693": {"epss_score": 0.00757, "epss_percentile": 0.72758}, "CVE-2020-15694": {"epss_score": 0.00757, "epss_percentile": 0.7276}, "CVE-2020-15695": {"epss_score": 6e-05, "epss_percentile": 0.00255}, "CVE-2020-15696": {"epss_score": 0.02779, "epss_percentile": 0.85646}, "CVE-2020-15697": {"epss_score": 9e-05, "epss_percentile": 0.00626}, "CVE-2020-15698": {"epss_score": 0.00011, "epss_percentile": 0.01017}, "CVE-2020-15699": {"epss_score": 8e-05, "epss_percentile": 0.00583}, "CVE-2020-15700": {"epss_score": 6e-05, "epss_percentile": 0.00255}, "CVE-2020-15701": {"epss_score": 0.00119, "epss_percentile": 0.31669}, "CVE-2020-15702": {"epss_score": 0.00044, "epss_percentile": 0.13472}, "CVE-2020-15703": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2020-15704": {"epss_score": 0.00052, "epss_percentile": 0.16454}, "CVE-2020-15705": {"epss_score": 0.00032, "epss_percentile": 0.09025}, "CVE-2020-15706": {"epss_score": 0.0006, "epss_percentile": 0.19117}, "CVE-2020-15707": {"epss_score": 0.00037, "epss_percentile": 0.10744}, "CVE-2020-15708": {"epss_score": 0.00142, "epss_percentile": 0.35091}, "CVE-2020-15709": {"epss_score": 0.00053, "epss_percentile": 0.17039}, "CVE-2020-15710": {"epss_score": 0.00032, "epss_percentile": 0.08971}, "CVE-2020-15711": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2020-15712": {"epss_score": 0.00143, "epss_percentile": 0.35198}, "CVE-2020-15713": {"epss_score": 0.00351, "epss_percentile": 0.5698}, "CVE-2020-15714": {"epss_score": 0.00351, "epss_percentile": 0.5698}, "CVE-2020-15715": {"epss_score": 0.02603, "epss_percentile": 0.85213}, "CVE-2020-15716": {"epss_score": 0.0105, "epss_percentile": 0.77071}, "CVE-2020-15717": {"epss_score": 0.00827, "epss_percentile": 0.73985}, "CVE-2020-15718": {"epss_score": 0.0105, "epss_percentile": 0.77071}, "CVE-2020-15719": {"epss_score": 0.00216, "epss_percentile": 0.44126}, "CVE-2020-15720": {"epss_score": 0.00186, "epss_percentile": 0.40664}, "CVE-2020-15721": {"epss_score": 0.00432, "epss_percentile": 0.62163}, "CVE-2020-15722": {"epss_score": 0.00126, "epss_percentile": 0.32659}, "CVE-2020-15723": {"epss_score": 0.00047, "epss_percentile": 0.14872}, "CVE-2020-15724": {"epss_score": 0.00047, "epss_percentile": 0.14872}, "CVE-2020-15731": {"epss_score": 0.00184, "epss_percentile": 0.40393}, "CVE-2020-15732": {"epss_score": 0.00082, "epss_percentile": 0.24401}, "CVE-2020-15733": {"epss_score": 0.0016, "epss_percentile": 0.37446}, "CVE-2020-15734": {"epss_score": 0.00024, "epss_percentile": 0.06023}, "CVE-2020-15744": {"epss_score": 0.00497, "epss_percentile": 0.65185}, "CVE-2020-15767": {"epss_score": 0.00135, "epss_percentile": 0.3403}, "CVE-2020-15768": {"epss_score": 0.00509, "epss_percentile": 0.65747}, "CVE-2020-15769": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-15770": {"epss_score": 0.00046, "epss_percentile": 0.14122}, "CVE-2020-15771": {"epss_score": 0.00107, "epss_percentile": 0.29754}, "CVE-2020-15772": {"epss_score": 0.00235, "epss_percentile": 0.46339}, "CVE-2020-15773": {"epss_score": 0.00153, "epss_percentile": 0.36625}, "CVE-2020-15774": {"epss_score": 0.00054, "epss_percentile": 0.1726}, "CVE-2020-15775": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-15776": {"epss_score": 0.00601, "epss_percentile": 0.68835}, "CVE-2020-15777": {"epss_score": 0.00656, "epss_percentile": 0.70432}, "CVE-2020-15778": {"epss_score": 0.61479, "epss_percentile": 0.9825}, "CVE-2020-15779": {"epss_score": 0.0046, "epss_percentile": 0.63516}, "CVE-2020-15780": {"epss_score": 0.00452, "epss_percentile": 0.63192}, "CVE-2020-15781": {"epss_score": 0.00504, "epss_percentile": 0.65549}, "CVE-2020-15782": {"epss_score": 0.00302, "epss_percentile": 0.53106}, "CVE-2020-15783": {"epss_score": 0.0019, "epss_percentile": 0.41113}, "CVE-2020-15784": {"epss_score": 0.00111, "epss_percentile": 0.30267}, "CVE-2020-15785": {"epss_score": 0.00355, "epss_percentile": 0.57278}, "CVE-2020-15786": {"epss_score": 0.00422, "epss_percentile": 0.61555}, "CVE-2020-15787": {"epss_score": 0.00422, "epss_percentile": 0.61555}, "CVE-2020-15788": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-15789": {"epss_score": 0.00178, "epss_percentile": 0.39691}, "CVE-2020-15790": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2020-15791": {"epss_score": 0.00081, "epss_percentile": 0.24375}, "CVE-2020-15792": {"epss_score": 0.00214, "epss_percentile": 0.44001}, "CVE-2020-15793": {"epss_score": 0.00333, "epss_percentile": 0.55666}, "CVE-2020-15794": {"epss_score": 0.00174, "epss_percentile": 0.39261}, "CVE-2020-15795": {"epss_score": 0.00686, "epss_percentile": 0.71157}, "CVE-2020-15796": {"epss_score": 0.01165, "epss_percentile": 0.78171}, "CVE-2020-15797": {"epss_score": 0.00283, "epss_percentile": 0.51389}, "CVE-2020-15798": {"epss_score": 0.01235, "epss_percentile": 0.78763}, "CVE-2020-15799": {"epss_score": 0.00489, "epss_percentile": 0.64908}, "CVE-2020-15800": {"epss_score": 0.00845, "epss_percentile": 0.74317}, "CVE-2020-15801": {"epss_score": 0.00617, "epss_percentile": 0.69352}, "CVE-2020-15802": {"epss_score": 0.4466, "epss_percentile": 0.97448}, "CVE-2020-15803": {"epss_score": 0.02092, "epss_percentile": 0.83574}, "CVE-2020-15806": {"epss_score": 0.00591, "epss_percentile": 0.68593}, "CVE-2020-15807": {"epss_score": 0.00411, "epss_percentile": 0.60905}, "CVE-2020-15809": {"epss_score": 0.00224, "epss_percentile": 0.44979}, "CVE-2020-15810": {"epss_score": 0.00211, "epss_percentile": 0.43626}, "CVE-2020-15811": {"epss_score": 0.00251, "epss_percentile": 0.48307}, "CVE-2020-15813": {"epss_score": 0.00192, "epss_percentile": 0.41331}, "CVE-2020-15816": {"epss_score": 0.0065, "epss_percentile": 0.7025}, "CVE-2020-15817": {"epss_score": 8e-05, "epss_percentile": 0.00533}, "CVE-2020-15818": {"epss_score": 3e-05, "epss_percentile": 0.00081}, "CVE-2020-15819": {"epss_score": 2e-05, "epss_percentile": 0.00059}, "CVE-2020-15820": {"epss_score": 3e-05, "epss_percentile": 0.00081}, "CVE-2020-15821": {"epss_score": 2e-05, "epss_percentile": 0.00031}, "CVE-2020-15822": {"epss_score": 5e-05, "epss_percentile": 0.00191}, "CVE-2020-15823": {"epss_score": 3e-05, "epss_percentile": 0.00067}, "CVE-2020-15824": {"epss_score": 0.00022, "epss_percentile": 0.05199}, "CVE-2020-15825": {"epss_score": 6e-05, "epss_percentile": 0.00238}, "CVE-2020-15826": {"epss_score": 2e-05, "epss_percentile": 0.00029}, "CVE-2020-15827": {"epss_score": 2e-05, "epss_percentile": 0.00022}, "CVE-2020-15828": {"epss_score": 3e-05, "epss_percentile": 0.00086}, "CVE-2020-15829": {"epss_score": 3e-05, "epss_percentile": 0.00093}, "CVE-2020-15830": {"epss_score": 6e-05, "epss_percentile": 0.00286}, "CVE-2020-15831": {"epss_score": 7e-05, "epss_percentile": 0.00342}, "CVE-2020-15832": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2020-15833": {"epss_score": 0.00358, "epss_percentile": 0.57529}, "CVE-2020-15834": {"epss_score": 0.00277, "epss_percentile": 0.5078}, "CVE-2020-15835": {"epss_score": 0.00365, "epss_percentile": 0.57999}, "CVE-2020-15836": {"epss_score": 0.00937, "epss_percentile": 0.757}, "CVE-2020-15838": {"epss_score": 0.00226, "epss_percentile": 0.45283}, "CVE-2020-15839": {"epss_score": 0.01076, "epss_percentile": 0.77324}, "CVE-2020-15840": {"epss_score": 0.00194, "epss_percentile": 0.4155}, "CVE-2020-15841": {"epss_score": 0.00337, "epss_percentile": 0.5604}, "CVE-2020-15842": {"epss_score": 0.0057, "epss_percentile": 0.67949}, "CVE-2020-15843": {"epss_score": 0.00029, "epss_percentile": 0.07848}, "CVE-2020-15849": {"epss_score": 0.01608, "epss_percentile": 0.81312}, "CVE-2020-15850": {"epss_score": 0.00023, "epss_percentile": 0.05521}, "CVE-2020-15851": {"epss_score": 0.01045, "epss_percentile": 0.77014}, "CVE-2020-15852": {"epss_score": 0.0016, "epss_percentile": 0.37439}, "CVE-2020-15853": {"epss_score": 0.00242, "epss_percentile": 0.47359}, "CVE-2020-15855": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2020-15858": {"epss_score": 0.00279, "epss_percentile": 0.50953}, "CVE-2020-15859": {"epss_score": 0.00026, "epss_percentile": 0.06519}, "CVE-2020-15860": {"epss_score": 0.02694, "epss_percentile": 0.85441}, "CVE-2020-15861": {"epss_score": 0.00403, "epss_percentile": 0.60334}, "CVE-2020-15862": {"epss_score": 0.00063, "epss_percentile": 0.19823}, "CVE-2020-15863": {"epss_score": 0.00045, "epss_percentile": 0.1395}, "CVE-2020-15864": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-15865": {"epss_score": 0.06779, "epss_percentile": 0.91021}, "CVE-2020-15866": {"epss_score": 0.00599, "epss_percentile": 0.68806}, "CVE-2020-15867": {"epss_score": 0.92751, "epss_percentile": 0.99743}, "CVE-2020-15868": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-15869": {"epss_score": 0.00312, "epss_percentile": 0.53995}, "CVE-2020-15870": {"epss_score": 0.00312, "epss_percentile": 0.53995}, "CVE-2020-15871": {"epss_score": 0.01451, "epss_percentile": 0.80357}, "CVE-2020-15873": {"epss_score": 0.0321, "epss_percentile": 0.86649}, "CVE-2020-15877": {"epss_score": 0.00059, "epss_percentile": 0.18921}, "CVE-2020-15879": {"epss_score": 0.00312, "epss_percentile": 0.54008}, "CVE-2020-15881": {"epss_score": 0.00664, "epss_percentile": 0.70646}, "CVE-2020-15882": {"epss_score": 0.00206, "epss_percentile": 0.42943}, "CVE-2020-15883": {"epss_score": 0.00528, "epss_percentile": 0.66572}, "CVE-2020-15884": {"epss_score": 0.00314, "epss_percentile": 0.54126}, "CVE-2020-15885": {"epss_score": 0.0027, "epss_percentile": 0.50228}, "CVE-2020-15886": {"epss_score": 0.00374, "epss_percentile": 0.58541}, "CVE-2020-15887": {"epss_score": 0.00374, "epss_percentile": 0.58541}, "CVE-2020-15888": {"epss_score": 0.01248, "epss_percentile": 0.78868}, "CVE-2020-15889": {"epss_score": 0.0051, "epss_percentile": 0.6576}, "CVE-2020-15890": {"epss_score": 0.01331, "epss_percentile": 0.7952}, "CVE-2020-15892": {"epss_score": 0.00922, "epss_percentile": 0.75486}, "CVE-2020-15893": {"epss_score": 0.84777, "epss_percentile": 0.99305}, "CVE-2020-15894": {"epss_score": 0.01272, "epss_percentile": 0.79077}, "CVE-2020-15895": {"epss_score": 0.41498, "epss_percentile": 0.97278}, "CVE-2020-15896": {"epss_score": 0.02592, "epss_percentile": 0.85185}, "CVE-2020-15897": {"epss_score": 0.00691, "epss_percentile": 0.71281}, "CVE-2020-15898": {"epss_score": 0.00212, "epss_percentile": 0.43792}, "CVE-2020-15899": {"epss_score": 0.00119, "epss_percentile": 0.31575}, "CVE-2020-15900": {"epss_score": 0.12139, "epss_percentile": 0.93583}, "CVE-2020-15901": {"epss_score": 0.38959, "epss_percentile": 0.97131}, "CVE-2020-15902": {"epss_score": 0.42821, "epss_percentile": 0.97357}, "CVE-2020-15903": {"epss_score": 0.06977, "epss_percentile": 0.91158}, "CVE-2020-15904": {"epss_score": 0.00373, "epss_percentile": 0.58518}, "CVE-2020-15906": {"epss_score": 0.91138, "epss_percentile": 0.99621}, "CVE-2020-15907": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-15908": {"epss_score": 0.00255, "epss_percentile": 0.48642}, "CVE-2020-15909": {"epss_score": 0.01403, "epss_percentile": 0.80031}, "CVE-2020-15910": {"epss_score": 0.00358, "epss_percentile": 0.57511}, "CVE-2020-15912": {"epss_score": 0.00207, "epss_percentile": 0.43121}, "CVE-2020-15914": {"epss_score": 0.00203, "epss_percentile": 0.42571}, "CVE-2020-15916": {"epss_score": 0.03632, "epss_percentile": 0.87475}, "CVE-2020-15917": {"epss_score": 0.02235, "epss_percentile": 0.84099}, "CVE-2020-15918": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-15919": {"epss_score": 0.0029, "epss_percentile": 0.52085}, "CVE-2020-15920": {"epss_score": 0.93927, "epss_percentile": 0.99869}, "CVE-2020-15921": {"epss_score": 0.1981, "epss_percentile": 0.95245}, "CVE-2020-15922": {"epss_score": 0.79167, "epss_percentile": 0.99022}, "CVE-2020-15923": {"epss_score": 0.03164, "epss_percentile": 0.86537}, "CVE-2020-15924": {"epss_score": 0.00763, "epss_percentile": 0.72878}, "CVE-2020-15925": {"epss_score": 0.00411, "epss_percentile": 0.60856}, "CVE-2020-15926": {"epss_score": 0.00758, "epss_percentile": 0.72769}, "CVE-2020-15927": {"epss_score": 0.01313, "epss_percentile": 0.79384}, "CVE-2020-15928": {"epss_score": 0.00738, "epss_percentile": 0.72342}, "CVE-2020-15929": {"epss_score": 0.08119, "epss_percentile": 0.91888}, "CVE-2020-15930": {"epss_score": 0.04221, "epss_percentile": 0.88411}, "CVE-2020-15931": {"epss_score": 0.06304, "epss_percentile": 0.90659}, "CVE-2020-15932": {"epss_score": 0.00508, "epss_percentile": 0.65718}, "CVE-2020-15933": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2020-15934": {"epss_score": 0.00033, "epss_percentile": 0.09368}, "CVE-2020-15935": {"epss_score": 0.00076, "epss_percentile": 0.23274}, "CVE-2020-15936": {"epss_score": 0.00335, "epss_percentile": 0.55895}, "CVE-2020-15937": {"epss_score": 0.00327, "epss_percentile": 0.551}, "CVE-2020-15938": {"epss_score": 0.00446, "epss_percentile": 0.62906}, "CVE-2020-15939": {"epss_score": 0.00227, "epss_percentile": 0.4539}, "CVE-2020-15940": {"epss_score": 0.00253, "epss_percentile": 0.48427}, "CVE-2020-15941": {"epss_score": 0.01115, "epss_percentile": 0.77712}, "CVE-2020-15942": {"epss_score": 0.00153, "epss_percentile": 0.36636}, "CVE-2020-15943": {"epss_score": 0.01669, "epss_percentile": 0.81664}, "CVE-2020-15944": {"epss_score": 0.01113, "epss_percentile": 0.77684}, "CVE-2020-15945": {"epss_score": 0.0015, "epss_percentile": 0.36177}, "CVE-2020-15947": {"epss_score": 0.00411, "epss_percentile": 0.60856}, "CVE-2020-15948": {"epss_score": 0.0019, "epss_percentile": 0.41097}, "CVE-2020-15949": {"epss_score": 0.00186, "epss_percentile": 0.40638}, "CVE-2020-15950": {"epss_score": 0.00413, "epss_percentile": 0.60992}, "CVE-2020-15951": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2020-15952": {"epss_score": 0.01009, "epss_percentile": 0.76574}, "CVE-2020-15953": {"epss_score": 0.01231, "epss_percentile": 0.78728}, "CVE-2020-15954": {"epss_score": 0.00142, "epss_percentile": 0.35027}, "CVE-2020-15955": {"epss_score": 0.00322, "epss_percentile": 0.54789}, "CVE-2020-15956": {"epss_score": 0.36095, "epss_percentile": 0.96955}, "CVE-2020-15957": {"epss_score": 0.00191, "epss_percentile": 0.41205}, "CVE-2020-15958": {"epss_score": 0.00937, "epss_percentile": 0.75699}, "CVE-2020-15959": {"epss_score": 0.00883, "epss_percentile": 0.74912}, "CVE-2020-15960": {"epss_score": 0.02264, "epss_percentile": 0.84193}, "CVE-2020-15961": {"epss_score": 0.01352, "epss_percentile": 0.79689}, "CVE-2020-15962": {"epss_score": 0.03112, "epss_percentile": 0.86428}, "CVE-2020-15963": {"epss_score": 0.01352, "epss_percentile": 0.79689}, "CVE-2020-15964": {"epss_score": 0.02266, "epss_percentile": 0.84198}, "CVE-2020-15965": {"epss_score": 0.13584, "epss_percentile": 0.94002}, "CVE-2020-15966": {"epss_score": 0.00883, "epss_percentile": 0.74912}, "CVE-2020-15967": {"epss_score": 0.01427, "epss_percentile": 0.80215}, "CVE-2020-15968": {"epss_score": 0.01485, "epss_percentile": 0.80598}, "CVE-2020-15969": {"epss_score": 0.03155, "epss_percentile": 0.86514}, "CVE-2020-15970": {"epss_score": 0.01427, "epss_percentile": 0.80215}, "CVE-2020-15971": {"epss_score": 0.01427, "epss_percentile": 0.80215}, "CVE-2020-15972": {"epss_score": 0.03497, "epss_percentile": 0.87239}, "CVE-2020-15973": {"epss_score": 0.00819, "epss_percentile": 0.7387}, "CVE-2020-15974": {"epss_score": 0.00908, "epss_percentile": 0.75287}, "CVE-2020-15975": {"epss_score": 0.01427, "epss_percentile": 0.80215}, "CVE-2020-15976": {"epss_score": 0.01648, "epss_percentile": 0.81544}, "CVE-2020-15977": {"epss_score": 0.0114, "epss_percentile": 0.77951}, "CVE-2020-15978": {"epss_score": 0.00923, "epss_percentile": 0.75495}, "CVE-2020-15979": {"epss_score": 0.01485, "epss_percentile": 0.80598}, "CVE-2020-15980": {"epss_score": 0.00027, "epss_percentile": 0.06776}, "CVE-2020-15981": {"epss_score": 0.00735, "epss_percentile": 0.72291}, "CVE-2020-15982": {"epss_score": 0.00996, "epss_percentile": 0.76445}, "CVE-2020-15983": {"epss_score": 0.00025, "epss_percentile": 0.06203}, "CVE-2020-15984": {"epss_score": 0.00821, "epss_percentile": 0.73906}, "CVE-2020-15985": {"epss_score": 0.00817, "epss_percentile": 0.73846}, "CVE-2020-15986": {"epss_score": 0.01312, "epss_percentile": 0.79378}, "CVE-2020-15987": {"epss_score": 0.016, "epss_percentile": 0.81261}, "CVE-2020-15988": {"epss_score": 0.0129, "epss_percentile": 0.79215}, "CVE-2020-15989": {"epss_score": 0.00436, "epss_percentile": 0.62458}, "CVE-2020-15990": {"epss_score": 0.01427, "epss_percentile": 0.80215}, "CVE-2020-15991": {"epss_score": 0.01427, "epss_percentile": 0.80215}, "CVE-2020-15992": {"epss_score": 0.00908, "epss_percentile": 0.75287}, "CVE-2020-15993": {"epss_score": 0.00967, "epss_percentile": 0.76068}, "CVE-2020-15994": {"epss_score": 0.05004, "epss_percentile": 0.89381}, "CVE-2020-15995": {"epss_score": 0.01308, "epss_percentile": 0.79346}, "CVE-2020-15996": {"epss_score": 0.00979, "epss_percentile": 0.76258}, "CVE-2020-15997": {"epss_score": 0.00979, "epss_percentile": 0.76258}, "CVE-2020-15998": {"epss_score": 0.00454, "epss_percentile": 0.63249}, "CVE-2020-15999": {"epss_score": 0.92931, "epss_percentile": 0.99762}, "CVE-2020-16000": {"epss_score": 0.01753, "epss_percentile": 0.82114}, "CVE-2020-16001": {"epss_score": 0.01907, "epss_percentile": 0.82814}, "CVE-2020-16002": {"epss_score": 0.01433, "epss_percentile": 0.80259}, "CVE-2020-16003": {"epss_score": 0.01907, "epss_percentile": 0.82814}, "CVE-2020-16004": {"epss_score": 0.01365, "epss_percentile": 0.79777}, "CVE-2020-16005": {"epss_score": 0.01365, "epss_percentile": 0.79777}, "CVE-2020-16006": {"epss_score": 0.01373, "epss_percentile": 0.7982}, "CVE-2020-16007": {"epss_score": 0.00025, "epss_percentile": 0.06337}, "CVE-2020-16008": {"epss_score": 0.01269, "epss_percentile": 0.79035}, "CVE-2020-16009": {"epss_score": 0.84383, "epss_percentile": 0.99286}, "CVE-2020-16010": {"epss_score": 0.26319, "epss_percentile": 0.96137}, "CVE-2020-16011": {"epss_score": 0.01598, "epss_percentile": 0.81249}, "CVE-2020-16012": {"epss_score": 0.04946, "epss_percentile": 0.89319}, "CVE-2020-16013": {"epss_score": 0.21006, "epss_percentile": 0.9545}, "CVE-2020-16014": {"epss_score": 0.0057, "epss_percentile": 0.67962}, "CVE-2020-16015": {"epss_score": 0.0042, "epss_percentile": 0.61441}, "CVE-2020-16016": {"epss_score": 0.00393, "epss_percentile": 0.59743}, "CVE-2020-16017": {"epss_score": 0.16945, "epss_percentile": 0.94751}, "CVE-2020-16018": {"epss_score": 0.00265, "epss_percentile": 0.49839}, "CVE-2020-16019": {"epss_score": 0.00191, "epss_percentile": 0.41197}, "CVE-2020-16020": {"epss_score": 0.00191, "epss_percentile": 0.41197}, "CVE-2020-16021": {"epss_score": 0.00411, "epss_percentile": 0.60873}, "CVE-2020-16022": {"epss_score": 0.00178, "epss_percentile": 0.39657}, "CVE-2020-16023": {"epss_score": 0.00525, "epss_percentile": 0.66391}, "CVE-2020-16024": {"epss_score": 0.00802, "epss_percentile": 0.73591}, "CVE-2020-16025": {"epss_score": 0.00807, "epss_percentile": 0.73673}, "CVE-2020-16026": {"epss_score": 0.00525, "epss_percentile": 0.66391}, "CVE-2020-16027": {"epss_score": 0.00151, "epss_percentile": 0.36262}, "CVE-2020-16028": {"epss_score": 0.00463, "epss_percentile": 0.63626}, "CVE-2020-16029": {"epss_score": 0.00185, "epss_percentile": 0.40566}, "CVE-2020-16030": {"epss_score": 0.00265, "epss_percentile": 0.4981}, "CVE-2020-16031": {"epss_score": 0.00251, "epss_percentile": 0.48302}, "CVE-2020-16032": {"epss_score": 0.0027, "epss_percentile": 0.50229}, "CVE-2020-16033": {"epss_score": 0.00249, "epss_percentile": 0.48008}, "CVE-2020-16034": {"epss_score": 0.00168, "epss_percentile": 0.38494}, "CVE-2020-16035": {"epss_score": 0.0014, "epss_percentile": 0.3479}, "CVE-2020-16036": {"epss_score": 0.00382, "epss_percentile": 0.59035}, "CVE-2020-16037": {"epss_score": 0.00457, "epss_percentile": 0.63363}, "CVE-2020-16038": {"epss_score": 0.00457, "epss_percentile": 0.63363}, "CVE-2020-16039": {"epss_score": 0.00457, "epss_percentile": 0.63363}, "CVE-2020-16040": {"epss_score": 0.78671, "epss_percentile": 0.98997}, "CVE-2020-16041": {"epss_score": 0.00692, "epss_percentile": 0.71282}, "CVE-2020-16042": {"epss_score": 0.00396, "epss_percentile": 0.59922}, "CVE-2020-16043": {"epss_score": 0.00373, "epss_percentile": 0.58475}, "CVE-2020-16044": {"epss_score": 0.00379, "epss_percentile": 0.589}, "CVE-2020-16045": {"epss_score": 0.00341, "epss_percentile": 0.56318}, "CVE-2020-16046": {"epss_score": 0.00482, "epss_percentile": 0.64524}, "CVE-2020-16048": {"epss_score": 0.00195, "epss_percentile": 0.41682}, "CVE-2020-16087": {"epss_score": 0.00168, "epss_percentile": 0.3841}, "CVE-2020-16088": {"epss_score": 0.00161, "epss_percentile": 0.37616}, "CVE-2020-16092": {"epss_score": 0.00039, "epss_percentile": 0.11459}, "CVE-2020-16093": {"epss_score": 0.0044, "epss_percentile": 0.62626}, "CVE-2020-16094": {"epss_score": 0.00485, "epss_percentile": 0.6471}, "CVE-2020-16095": {"epss_score": 0.00325, "epss_percentile": 0.5501}, "CVE-2020-16096": {"epss_score": 0.0022, "epss_percentile": 0.44574}, "CVE-2020-16097": {"epss_score": 0.0006, "epss_percentile": 0.18955}, "CVE-2020-16098": {"epss_score": 0.00468, "epss_percentile": 0.63891}, "CVE-2020-16099": {"epss_score": 0.00361, "epss_percentile": 0.57739}, "CVE-2020-16100": {"epss_score": 0.00446, "epss_percentile": 0.62914}, "CVE-2020-16101": {"epss_score": 0.0039, "epss_percentile": 0.59508}, "CVE-2020-16102": {"epss_score": 0.00977, "epss_percentile": 0.76223}, "CVE-2020-16103": {"epss_score": 0.0205, "epss_percentile": 0.83398}, "CVE-2020-16104": {"epss_score": 0.00608, "epss_percentile": 0.6907}, "CVE-2020-16116": {"epss_score": 0.00864, "epss_percentile": 0.74604}, "CVE-2020-16117": {"epss_score": 0.00454, "epss_percentile": 0.63252}, "CVE-2020-16118": {"epss_score": 0.00451, "epss_percentile": 0.63145}, "CVE-2020-16119": {"epss_score": 0.00089, "epss_percentile": 0.25912}, "CVE-2020-16120": {"epss_score": 0.00047, "epss_percentile": 0.1471}, "CVE-2020-16121": {"epss_score": 0.00109, "epss_percentile": 0.30026}, "CVE-2020-16122": {"epss_score": 0.00086, "epss_percentile": 0.25311}, "CVE-2020-16123": {"epss_score": 0.00086, "epss_percentile": 0.25249}, "CVE-2020-16124": {"epss_score": 0.0089, "epss_percentile": 0.75026}, "CVE-2020-16125": {"epss_score": 0.22102, "epss_percentile": 0.95596}, "CVE-2020-16126": {"epss_score": 0.01989, "epss_percentile": 0.8317}, "CVE-2020-16127": {"epss_score": 0.00172, "epss_percentile": 0.38979}, "CVE-2020-16128": {"epss_score": 0.00039, "epss_percentile": 0.11641}, "CVE-2020-16131": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-16134": {"epss_score": 0.00131, "epss_percentile": 0.33343}, "CVE-2020-16135": {"epss_score": 0.01407, "epss_percentile": 0.80053}, "CVE-2020-16136": {"epss_score": 0.01578, "epss_percentile": 0.81123}, "CVE-2020-16137": {"epss_score": 0.73245, "epss_percentile": 0.98743}, "CVE-2020-16138": {"epss_score": 0.74683, "epss_percentile": 0.98812}, "CVE-2020-16139": {"epss_score": 0.90386, "epss_percentile": 0.9958}, "CVE-2020-16140": {"epss_score": 0.00207, "epss_percentile": 0.43167}, "CVE-2020-16142": {"epss_score": 0.00087, "epss_percentile": 0.25464}, "CVE-2020-16143": {"epss_score": 0.00049, "epss_percentile": 0.15381}, "CVE-2020-16144": {"epss_score": 0.00182, "epss_percentile": 0.4025}, "CVE-2020-16145": {"epss_score": 0.00704, "epss_percentile": 0.71569}, "CVE-2020-16146": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2020-16147": {"epss_score": 0.00986, "epss_percentile": 0.76329}, "CVE-2020-16148": {"epss_score": 0.01071, "epss_percentile": 0.77266}, "CVE-2020-16150": {"epss_score": 0.00068, "epss_percentile": 0.2124}, "CVE-2020-16152": {"epss_score": 0.84896, "epss_percentile": 0.99309}, "CVE-2020-16154": {"epss_score": 0.00029, "epss_percentile": 0.0795}, "CVE-2020-16155": {"epss_score": 0.00203, "epss_percentile": 0.42551}, "CVE-2020-16156": {"epss_score": 0.00019, "epss_percentile": 0.04235}, "CVE-2020-16157": {"epss_score": 0.06779, "epss_percentile": 0.9102}, "CVE-2020-16158": {"epss_score": 0.00909, "epss_percentile": 0.75315}, "CVE-2020-16159": {"epss_score": 0.00412, "epss_percentile": 0.6094}, "CVE-2020-16160": {"epss_score": 0.00432, "epss_percentile": 0.62112}, "CVE-2020-16161": {"epss_score": 0.00691, "epss_percentile": 0.71262}, "CVE-2020-16162": {"epss_score": 0.00112, "epss_percentile": 0.30495}, "CVE-2020-16163": {"epss_score": 0.00241, "epss_percentile": 0.47276}, "CVE-2020-16164": {"epss_score": 0.0017, "epss_percentile": 0.38717}, "CVE-2020-16165": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2020-16166": {"epss_score": 0.01676, "epss_percentile": 0.81711}, "CVE-2020-16167": {"epss_score": 0.00494, "epss_percentile": 0.65095}, "CVE-2020-16168": {"epss_score": 0.00145, "epss_percentile": 0.3546}, "CVE-2020-16169": {"epss_score": 0.00523, "epss_percentile": 0.66308}, "CVE-2020-16170": {"epss_score": 0.00655, "epss_percentile": 0.70419}, "CVE-2020-16171": {"epss_score": 0.125, "epss_percentile": 0.93693}, "CVE-2020-16192": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-16193": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-16194": {"epss_score": 0.0084, "epss_percentile": 0.74206}, "CVE-2020-16197": {"epss_score": 0.00124, "epss_percentile": 0.32415}, "CVE-2020-16198": {"epss_score": 0.00036, "epss_percentile": 0.10502}, "CVE-2020-16199": {"epss_score": 0.01251, "epss_percentile": 0.78891}, "CVE-2020-16200": {"epss_score": 0.00057, "epss_percentile": 0.18146}, "CVE-2020-16201": {"epss_score": 0.00365, "epss_percentile": 0.57984}, "CVE-2020-16202": {"epss_score": 0.00028, "epss_percentile": 0.07581}, "CVE-2020-16203": {"epss_score": 0.00205, "epss_percentile": 0.42721}, "CVE-2020-16204": {"epss_score": 0.03238, "epss_percentile": 0.86725}, "CVE-2020-16205": {"epss_score": 0.55176, "epss_percentile": 0.97964}, "CVE-2020-16206": {"epss_score": 0.01521, "epss_percentile": 0.80828}, "CVE-2020-16207": {"epss_score": 0.02629, "epss_percentile": 0.85276}, "CVE-2020-16208": {"epss_score": 0.00256, "epss_percentile": 0.48835}, "CVE-2020-16209": {"epss_score": 0.00293, "epss_percentile": 0.52352}, "CVE-2020-16210": {"epss_score": 0.01521, "epss_percentile": 0.80828}, "CVE-2020-16211": {"epss_score": 0.00166, "epss_percentile": 0.3823}, "CVE-2020-16212": {"epss_score": 0.00059, "epss_percentile": 0.18821}, "CVE-2020-16213": {"epss_score": 0.00614, "epss_percentile": 0.69274}, "CVE-2020-16214": {"epss_score": 0.00141, "epss_percentile": 0.34801}, "CVE-2020-16215": {"epss_score": 0.00838, "epss_percentile": 0.74172}, "CVE-2020-16216": {"epss_score": 0.00063, "epss_percentile": 0.1985}, "CVE-2020-16217": {"epss_score": 0.00618, "epss_percentile": 0.69386}, "CVE-2020-16218": {"epss_score": 0.00105, "epss_percentile": 0.29351}, "CVE-2020-16219": {"epss_score": 0.00403, "epss_percentile": 0.60355}, "CVE-2020-16220": {"epss_score": 0.00035, "epss_percentile": 0.09896}, "CVE-2020-16221": {"epss_score": 0.00389, "epss_percentile": 0.59462}, "CVE-2020-16222": {"epss_score": 0.00076, "epss_percentile": 0.23237}, "CVE-2020-16223": {"epss_score": 0.00389, "epss_percentile": 0.59462}, "CVE-2020-16224": {"epss_score": 0.00071, "epss_percentile": 0.22045}, "CVE-2020-16225": {"epss_score": 0.00311, "epss_percentile": 0.53816}, "CVE-2020-16226": {"epss_score": 0.00477, "epss_percentile": 0.64297}, "CVE-2020-16227": {"epss_score": 0.00376, "epss_percentile": 0.58647}, "CVE-2020-16228": {"epss_score": 0.00036, "epss_percentile": 0.10324}, "CVE-2020-16229": {"epss_score": 0.00614, "epss_percentile": 0.69274}, "CVE-2020-16230": {"epss_score": 0.00044, "epss_percentile": 0.13427}, "CVE-2020-16231": {"epss_score": 0.00253, "epss_percentile": 0.48443}, "CVE-2020-16232": {"epss_score": 0.00217, "epss_percentile": 0.44315}, "CVE-2020-16233": {"epss_score": 0.00124, "epss_percentile": 0.32456}, "CVE-2020-16234": {"epss_score": 0.00553, "epss_percentile": 0.6741}, "CVE-2020-16235": {"epss_score": 0.00016, "epss_percentile": 0.02637}, "CVE-2020-16236": {"epss_score": 0.00352, "epss_percentile": 0.57083}, "CVE-2020-16237": {"epss_score": 0.00048, "epss_percentile": 0.14968}, "CVE-2020-16238": {"epss_score": 0.00078, "epss_percentile": 0.23751}, "CVE-2020-16239": {"epss_score": 0.00143, "epss_percentile": 0.35218}, "CVE-2020-16240": {"epss_score": 0.00159, "epss_percentile": 0.37307}, "CVE-2020-16241": {"epss_score": 0.00029, "epss_percentile": 0.07974}, "CVE-2020-16242": {"epss_score": 0.00188, "epss_percentile": 0.40898}, "CVE-2020-16243": {"epss_score": 0.00439, "epss_percentile": 0.62598}, "CVE-2020-16244": {"epss_score": 0.00243, "epss_percentile": 0.47505}, "CVE-2020-16245": {"epss_score": 0.15931, "epss_percentile": 0.94539}, "CVE-2020-16246": {"epss_score": 0.00188, "epss_percentile": 0.40898}, "CVE-2020-16247": {"epss_score": 0.00044, "epss_percentile": 0.1344}, "CVE-2020-16248": {"epss_score": 0.00422, "epss_percentile": 0.61571}, "CVE-2020-16250": {"epss_score": 0.01771, "epss_percentile": 0.82195}, "CVE-2020-16251": {"epss_score": 0.00923, "epss_percentile": 0.75511}, "CVE-2020-16252": {"epss_score": 0.00127, "epss_percentile": 0.32793}, "CVE-2020-16253": {"epss_score": 0.00101, "epss_percentile": 0.28646}, "CVE-2020-16254": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-16255": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2020-16256": {"epss_score": 0.00154, "epss_percentile": 0.36668}, "CVE-2020-16257": {"epss_score": 0.0627, "epss_percentile": 0.90629}, "CVE-2020-16258": {"epss_score": 0.0004, "epss_percentile": 0.11893}, "CVE-2020-16259": {"epss_score": 0.00398, "epss_percentile": 0.60072}, "CVE-2020-16260": {"epss_score": 0.00206, "epss_percentile": 0.42918}, "CVE-2020-16261": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2020-16262": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2020-16263": {"epss_score": 0.00307, "epss_percentile": 0.53488}, "CVE-2020-16266": {"epss_score": 0.00274, "epss_percentile": 0.50509}, "CVE-2020-16267": {"epss_score": 0.01313, "epss_percentile": 0.79384}, "CVE-2020-16268": {"epss_score": 0.00821, "epss_percentile": 0.73902}, "CVE-2020-16269": {"epss_score": 0.00343, "epss_percentile": 0.56423}, "CVE-2020-16270": {"epss_score": 0.2994, "epss_percentile": 0.96488}, "CVE-2020-16271": {"epss_score": 0.00372, "epss_percentile": 0.58433}, "CVE-2020-16272": {"epss_score": 0.00335, "epss_percentile": 0.55839}, "CVE-2020-16273": {"epss_score": 0.00063, "epss_percentile": 0.19989}, "CVE-2020-16275": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-16276": {"epss_score": 0.00706, "epss_percentile": 0.71637}, "CVE-2020-16277": {"epss_score": 0.00706, "epss_percentile": 0.71637}, "CVE-2020-16278": {"epss_score": 0.00271, "epss_percentile": 0.50323}, "CVE-2020-16279": {"epss_score": 0.02515, "epss_percentile": 0.84982}, "CVE-2020-16280": {"epss_score": 0.00046, "epss_percentile": 0.14397}, "CVE-2020-16281": {"epss_score": 0.00048, "epss_percentile": 0.15254}, "CVE-2020-16282": {"epss_score": 0.00101, "epss_percentile": 0.28641}, "CVE-2020-16287": {"epss_score": 0.01421, "epss_percentile": 0.80171}, "CVE-2020-16288": {"epss_score": 0.01091, "epss_percentile": 0.77457}, "CVE-2020-16289": {"epss_score": 0.01421, "epss_percentile": 0.80171}, "CVE-2020-16290": {"epss_score": 0.01421, "epss_percentile": 0.80171}, "CVE-2020-16291": {"epss_score": 0.01244, "epss_percentile": 0.78839}, "CVE-2020-16292": {"epss_score": 0.01091, "epss_percentile": 0.77457}, "CVE-2020-16293": {"epss_score": 0.01311, "epss_percentile": 0.79365}, "CVE-2020-16294": {"epss_score": 0.00743, "epss_percentile": 0.72497}, "CVE-2020-16295": {"epss_score": 0.00467, "epss_percentile": 0.63813}, "CVE-2020-16296": {"epss_score": 0.00434, "epss_percentile": 0.62281}, "CVE-2020-16297": {"epss_score": 0.00564, "epss_percentile": 0.67755}, "CVE-2020-16298": {"epss_score": 0.01421, "epss_percentile": 0.80171}, "CVE-2020-16299": {"epss_score": 0.00826, "epss_percentile": 0.73971}, "CVE-2020-16300": {"epss_score": 0.01091, "epss_percentile": 0.77457}, "CVE-2020-16301": {"epss_score": 0.0067, "epss_percentile": 0.70774}, "CVE-2020-16302": {"epss_score": 0.00791, "epss_percentile": 0.73388}, "CVE-2020-16303": {"epss_score": 0.02945, "epss_percentile": 0.8604}, "CVE-2020-16304": {"epss_score": 0.00474, "epss_percentile": 0.64139}, "CVE-2020-16305": {"epss_score": 0.00569, "epss_percentile": 0.67929}, "CVE-2020-16306": {"epss_score": 0.01771, "epss_percentile": 0.82193}, "CVE-2020-16307": {"epss_score": 0.01771, "epss_percentile": 0.82193}, "CVE-2020-16308": {"epss_score": 0.01091, "epss_percentile": 0.77457}, "CVE-2020-16309": {"epss_score": 0.01475, "epss_percentile": 0.80528}, "CVE-2020-16310": {"epss_score": 0.01789, "epss_percentile": 0.82275}, "CVE-2020-16587": {"epss_score": 0.00546, "epss_percentile": 0.67218}, "CVE-2020-16588": {"epss_score": 0.00288, "epss_percentile": 0.51864}, "CVE-2020-16589": {"epss_score": 0.00546, "epss_percentile": 0.67218}, "CVE-2020-16590": {"epss_score": 0.00333, "epss_percentile": 0.5565}, "CVE-2020-16591": {"epss_score": 0.00393, "epss_percentile": 0.59747}, "CVE-2020-16592": {"epss_score": 0.00339, "epss_percentile": 0.56186}, "CVE-2020-16593": {"epss_score": 0.00333, "epss_percentile": 0.5565}, "CVE-2020-16599": {"epss_score": 0.00076, "epss_percentile": 0.23264}, "CVE-2020-16600": {"epss_score": 0.00303, "epss_percentile": 0.53183}, "CVE-2020-16602": {"epss_score": 0.17837, "epss_percentile": 0.94914}, "CVE-2020-16608": {"epss_score": 0.03852, "epss_percentile": 0.87852}, "CVE-2020-16610": {"epss_score": 0.002, "epss_percentile": 0.42251}, "CVE-2020-16629": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-16630": {"epss_score": 0.00137, "epss_percentile": 0.34342}, "CVE-2020-16632": {"epss_score": 0.0036, "epss_percentile": 0.57679}, "CVE-2020-16839": {"epss_score": 0.00234, "epss_percentile": 0.46193}, "CVE-2020-16843": {"epss_score": 0.00497, "epss_percentile": 0.65184}, "CVE-2020-16844": {"epss_score": 0.00284, "epss_percentile": 0.51446}, "CVE-2020-16845": {"epss_score": 0.00084, "epss_percentile": 0.24996}, "CVE-2020-16846": {"epss_score": 0.94387, "epss_percentile": 0.99968}, "CVE-2020-16847": {"epss_score": 0.00313, "epss_percentile": 0.54043}, "CVE-2020-16849": {"epss_score": 0.0037, "epss_percentile": 0.58316}, "CVE-2020-16850": {"epss_score": 0.00307, "epss_percentile": 0.53559}, "CVE-2020-16851": {"epss_score": 0.00389, "epss_percentile": 0.59468}, "CVE-2020-16852": {"epss_score": 0.00266, "epss_percentile": 0.4986}, "CVE-2020-16853": {"epss_score": 0.00554, "epss_percentile": 0.6744}, "CVE-2020-16854": {"epss_score": 0.00432, "epss_percentile": 0.621}, "CVE-2020-16855": {"epss_score": 0.1987, "epss_percentile": 0.95253}, "CVE-2020-16856": {"epss_score": 0.12237, "epss_percentile": 0.93609}, "CVE-2020-16857": {"epss_score": 0.00259, "epss_percentile": 0.49035}, "CVE-2020-16858": {"epss_score": 0.00399, "epss_percentile": 0.60102}, "CVE-2020-16859": {"epss_score": 0.00399, "epss_percentile": 0.60102}, "CVE-2020-16860": {"epss_score": 0.02854, "epss_percentile": 0.85834}, "CVE-2020-16861": {"epss_score": 0.00541, "epss_percentile": 0.67046}, "CVE-2020-16862": {"epss_score": 0.02304, "epss_percentile": 0.84318}, "CVE-2020-16863": {"epss_score": 0.18405, "epss_percentile": 0.95012}, "CVE-2020-16864": {"epss_score": 0.00528, "epss_percentile": 0.66559}, "CVE-2020-16871": {"epss_score": 0.00399, "epss_percentile": 0.60102}, "CVE-2020-16872": {"epss_score": 0.00509, "epss_percentile": 0.65729}, "CVE-2020-16873": {"epss_score": 0.01399, "epss_percentile": 0.79993}, "CVE-2020-16874": {"epss_score": 0.09473, "epss_percentile": 0.92563}, "CVE-2020-16875": {"epss_score": 0.84693, "epss_percentile": 0.99301}, "CVE-2020-16876": {"epss_score": 0.00386, "epss_percentile": 0.59263}, "CVE-2020-16877": {"epss_score": 0.00371, "epss_percentile": 0.58357}, "CVE-2020-16878": {"epss_score": 0.00408, "epss_percentile": 0.60681}, "CVE-2020-16879": {"epss_score": 0.00728, "epss_percentile": 0.72111}, "CVE-2020-16881": {"epss_score": 0.16964, "epss_percentile": 0.94754}, "CVE-2020-16884": {"epss_score": 0.01891, "epss_percentile": 0.8273}, "CVE-2020-16885": {"epss_score": 0.00323, "epss_percentile": 0.54883}, "CVE-2020-16886": {"epss_score": 0.00306, "epss_percentile": 0.53429}, "CVE-2020-16887": {"epss_score": 0.0057, "epss_percentile": 0.67962}, "CVE-2020-16889": {"epss_score": 0.0081, "epss_percentile": 0.73721}, "CVE-2020-16890": {"epss_score": 0.00549, "epss_percentile": 0.67302}, "CVE-2020-16891": {"epss_score": 0.00402, "epss_percentile": 0.60283}, "CVE-2020-16892": {"epss_score": 0.00529, "epss_percentile": 0.66592}, "CVE-2020-16894": {"epss_score": 0.01299, "epss_percentile": 0.79284}, "CVE-2020-16895": {"epss_score": 0.00549, "epss_percentile": 0.67302}, "CVE-2020-16896": {"epss_score": 0.17065, "epss_percentile": 0.94769}, "CVE-2020-16897": {"epss_score": 0.00615, "epss_percentile": 0.69293}, "CVE-2020-16898": {"epss_score": 0.32694, "epss_percentile": 0.96717}, "CVE-2020-16899": {"epss_score": 0.42306, "epss_percentile": 0.97325}, "CVE-2020-16900": {"epss_score": 0.00254, "epss_percentile": 0.48544}, "CVE-2020-16901": {"epss_score": 0.01042, "epss_percentile": 0.7697}, "CVE-2020-16902": {"epss_score": 0.00492, "epss_percentile": 0.6499}, "CVE-2020-16904": {"epss_score": 0.02759, "epss_percentile": 0.85596}, "CVE-2020-16905": {"epss_score": 0.00845, "epss_percentile": 0.74288}, "CVE-2020-16907": {"epss_score": 0.00549, "epss_percentile": 0.67302}, "CVE-2020-16908": {"epss_score": 0.00526, "epss_percentile": 0.66398}, "CVE-2020-16909": {"epss_score": 0.00386, "epss_percentile": 0.59263}, "CVE-2020-16910": {"epss_score": 0.02985, "epss_percentile": 0.86132}, "CVE-2020-16911": {"epss_score": 0.17608, "epss_percentile": 0.94874}, "CVE-2020-16912": {"epss_score": 0.0043, "epss_percentile": 0.62035}, "CVE-2020-16913": {"epss_score": 0.00549, "epss_percentile": 0.67302}, "CVE-2020-16914": {"epss_score": 0.00671, "epss_percentile": 0.70807}, "CVE-2020-16915": {"epss_score": 0.14818, "epss_percentile": 0.94291}, "CVE-2020-16916": {"epss_score": 0.00555, "epss_percentile": 0.67461}, "CVE-2020-16918": {"epss_score": 0.1249, "epss_percentile": 0.9369}, "CVE-2020-16919": {"epss_score": 0.00455, "epss_percentile": 0.63294}, "CVE-2020-16920": {"epss_score": 0.10996, "epss_percentile": 0.93186}, "CVE-2020-16921": {"epss_score": 0.00551, "epss_percentile": 0.67361}, "CVE-2020-16922": {"epss_score": 0.00761, "epss_percentile": 0.72829}, "CVE-2020-16923": {"epss_score": 0.12686, "epss_percentile": 0.9375}, "CVE-2020-16924": {"epss_score": 0.14392, "epss_percentile": 0.94202}, "CVE-2020-16927": {"epss_score": 0.20405, "epss_percentile": 0.95339}, "CVE-2020-16928": {"epss_score": 0.10901, "epss_percentile": 0.93148}, "CVE-2020-16929": {"epss_score": 0.14523, "epss_percentile": 0.9423}, "CVE-2020-16930": {"epss_score": 0.1328, "epss_percentile": 0.93921}, "CVE-2020-16931": {"epss_score": 0.09611, "epss_percentile": 0.92622}, "CVE-2020-16932": {"epss_score": 0.09611, "epss_percentile": 0.92622}, "CVE-2020-16933": {"epss_score": 0.04404, "epss_percentile": 0.8865}, "CVE-2020-16934": {"epss_score": 0.03808, "epss_percentile": 0.87753}, "CVE-2020-16935": {"epss_score": 0.00741, "epss_percentile": 0.72433}, "CVE-2020-16936": {"epss_score": 0.0043, "epss_percentile": 0.62035}, "CVE-2020-16937": {"epss_score": 0.10158, "epss_percentile": 0.92869}, "CVE-2020-16938": {"epss_score": 0.10627, "epss_percentile": 0.93053}, "CVE-2020-16939": {"epss_score": 0.20891, "epss_percentile": 0.95433}, "CVE-2020-16940": {"epss_score": 0.00324, "epss_percentile": 0.54936}, "CVE-2020-16941": {"epss_score": 0.00333, "epss_percentile": 0.55668}, "CVE-2020-16942": {"epss_score": 0.00323, "epss_percentile": 0.54922}, "CVE-2020-16943": {"epss_score": 0.00574, "epss_percentile": 0.68071}, "CVE-2020-16944": {"epss_score": 0.00584, "epss_percentile": 0.68378}, "CVE-2020-16945": {"epss_score": 0.00452, "epss_percentile": 0.63198}, "CVE-2020-16946": {"epss_score": 0.006, "epss_percentile": 0.68831}, "CVE-2020-16947": {"epss_score": 0.45582, "epss_percentile": 0.97491}, "CVE-2020-16948": {"epss_score": 0.19192, "epss_percentile": 0.95146}, "CVE-2020-16949": {"epss_score": 0.0842, "epss_percentile": 0.92043}, "CVE-2020-16950": {"epss_score": 0.18728, "epss_percentile": 0.9506}, "CVE-2020-16951": {"epss_score": 0.01751, "epss_percentile": 0.82103}, "CVE-2020-16952": {"epss_score": 0.77814, "epss_percentile": 0.98955}, "CVE-2020-16953": {"epss_score": 0.25592, "epss_percentile": 0.96048}, "CVE-2020-16954": {"epss_score": 0.13831, "epss_percentile": 0.94072}, "CVE-2020-16955": {"epss_score": 0.10901, "epss_percentile": 0.93148}, "CVE-2020-16956": {"epss_score": 0.00717, "epss_percentile": 0.71871}, "CVE-2020-16957": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2020-16958": {"epss_score": 0.00934, "epss_percentile": 0.75658}, "CVE-2020-16959": {"epss_score": 0.00934, "epss_percentile": 0.75658}, "CVE-2020-16960": {"epss_score": 0.00695, "epss_percentile": 0.71377}, "CVE-2020-16961": {"epss_score": 0.00695, "epss_percentile": 0.71377}, "CVE-2020-16962": {"epss_score": 0.00934, "epss_percentile": 0.75658}, "CVE-2020-16963": {"epss_score": 0.00934, "epss_percentile": 0.75658}, "CVE-2020-16964": {"epss_score": 0.00934, "epss_percentile": 0.75658}, "CVE-2020-16967": {"epss_score": 0.12398, "epss_percentile": 0.93659}, "CVE-2020-16968": {"epss_score": 0.10589, "epss_percentile": 0.93036}, "CVE-2020-16969": {"epss_score": 0.00878, "epss_percentile": 0.74831}, "CVE-2020-16970": {"epss_score": 0.00197, "epss_percentile": 0.41873}, "CVE-2020-16971": {"epss_score": 0.02302, "epss_percentile": 0.84313}, "CVE-2020-16972": {"epss_score": 0.0043, "epss_percentile": 0.62035}, "CVE-2020-16973": {"epss_score": 0.00416, "epss_percentile": 0.61197}, "CVE-2020-16974": {"epss_score": 0.0043, "epss_percentile": 0.62035}, "CVE-2020-16975": {"epss_score": 0.0043, "epss_percentile": 0.62035}, "CVE-2020-16976": {"epss_score": 0.0043, "epss_percentile": 0.62035}, "CVE-2020-16977": {"epss_score": 0.05941, "epss_percentile": 0.9035}, "CVE-2020-16978": {"epss_score": 0.00734, "epss_percentile": 0.72236}, "CVE-2020-16979": {"epss_score": 0.07152, "epss_percentile": 0.91288}, "CVE-2020-16980": {"epss_score": 0.00386, "epss_percentile": 0.59263}, "CVE-2020-16981": {"epss_score": 0.00166, "epss_percentile": 0.38174}, "CVE-2020-16982": {"epss_score": 0.00371, "epss_percentile": 0.58371}, "CVE-2020-16983": {"epss_score": 0.00165, "epss_percentile": 0.38119}, "CVE-2020-16984": {"epss_score": 0.00199, "epss_percentile": 0.42187}, "CVE-2020-16985": {"epss_score": 0.00354, "epss_percentile": 0.57216}, "CVE-2020-16986": {"epss_score": 0.00208, "epss_percentile": 0.43299}, "CVE-2020-16987": {"epss_score": 0.00204, "epss_percentile": 0.42661}, "CVE-2020-16988": {"epss_score": 0.00158, "epss_percentile": 0.37202}, "CVE-2020-16989": {"epss_score": 0.00193, "epss_percentile": 0.41435}, "CVE-2020-16990": {"epss_score": 0.00374, "epss_percentile": 0.5856}, "CVE-2020-16991": {"epss_score": 0.00212, "epss_percentile": 0.43775}, "CVE-2020-16992": {"epss_score": 0.00125, "epss_percentile": 0.32571}, "CVE-2020-16993": {"epss_score": 0.00203, "epss_percentile": 0.42561}, "CVE-2020-16994": {"epss_score": 0.00217, "epss_percentile": 0.443}, "CVE-2020-16995": {"epss_score": 0.00481, "epss_percentile": 0.64482}, "CVE-2020-16996": {"epss_score": 0.09197, "epss_percentile": 0.92443}, "CVE-2020-16997": {"epss_score": 0.0241, "epss_percentile": 0.84665}, "CVE-2020-16998": {"epss_score": 0.00304, "epss_percentile": 0.53242}, "CVE-2020-16999": {"epss_score": 0.00446, "epss_percentile": 0.62929}, "CVE-2020-17000": {"epss_score": 0.00541, "epss_percentile": 0.67033}, "CVE-2020-17001": {"epss_score": 0.00377, "epss_percentile": 0.58701}, "CVE-2020-17002": {"epss_score": 0.06186, "epss_percentile": 0.90543}, "CVE-2020-17003": {"epss_score": 0.1249, "epss_percentile": 0.9369}, "CVE-2020-17004": {"epss_score": 0.00446, "epss_percentile": 0.62929}, "CVE-2020-17005": {"epss_score": 0.00803, "epss_percentile": 0.73604}, "CVE-2020-17006": {"epss_score": 0.00717, "epss_percentile": 0.71871}, "CVE-2020-17007": {"epss_score": 0.00229, "epss_percentile": 0.45613}, "CVE-2020-17010": {"epss_score": 0.00242, "epss_percentile": 0.47346}, "CVE-2020-17011": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-17012": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-17013": {"epss_score": 0.00541, "epss_percentile": 0.67033}, "CVE-2020-17014": {"epss_score": 0.00526, "epss_percentile": 0.66398}, "CVE-2020-17015": {"epss_score": 0.02928, "epss_percentile": 0.86012}, "CVE-2020-17016": {"epss_score": 0.16892, "epss_percentile": 0.94743}, "CVE-2020-17017": {"epss_score": 0.07152, "epss_percentile": 0.91288}, "CVE-2020-17018": {"epss_score": 0.00717, "epss_percentile": 0.71871}, "CVE-2020-17019": {"epss_score": 0.11698, "epss_percentile": 0.93454}, "CVE-2020-17020": {"epss_score": 0.00918, "epss_percentile": 0.75445}, "CVE-2020-17021": {"epss_score": 0.00803, "epss_percentile": 0.73604}, "CVE-2020-17022": {"epss_score": 0.10906, "epss_percentile": 0.93151}, "CVE-2020-17023": {"epss_score": 0.18013, "epss_percentile": 0.94944}, "CVE-2020-17024": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-17025": {"epss_score": 0.00379, "epss_percentile": 0.58856}, "CVE-2020-17026": {"epss_score": 0.00379, "epss_percentile": 0.58856}, "CVE-2020-17027": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-17028": {"epss_score": 0.00379, "epss_percentile": 0.58856}, "CVE-2020-17029": {"epss_score": 0.00603, "epss_percentile": 0.68916}, "CVE-2020-17030": {"epss_score": 0.00446, "epss_percentile": 0.62929}, "CVE-2020-17031": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-17032": {"epss_score": 0.00379, "epss_percentile": 0.58856}, "CVE-2020-17033": {"epss_score": 0.00379, "epss_percentile": 0.58856}, "CVE-2020-17034": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-17035": {"epss_score": 0.01353, "epss_percentile": 0.79696}, "CVE-2020-17036": {"epss_score": 0.00427, "epss_percentile": 0.61784}, "CVE-2020-17037": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-17038": {"epss_score": 0.00544, "epss_percentile": 0.67144}, "CVE-2020-17040": {"epss_score": 0.08112, "epss_percentile": 0.91885}, "CVE-2020-17041": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-17042": {"epss_score": 0.20418, "epss_percentile": 0.9534}, "CVE-2020-17043": {"epss_score": 0.11882, "epss_percentile": 0.93503}, "CVE-2020-17044": {"epss_score": 0.11882, "epss_percentile": 0.93503}, "CVE-2020-17045": {"epss_score": 0.00615, "epss_percentile": 0.69293}, "CVE-2020-17046": {"epss_score": 0.00366, "epss_percentile": 0.58059}, "CVE-2020-17047": {"epss_score": 0.22582, "epss_percentile": 0.95653}, "CVE-2020-17048": {"epss_score": 0.02207, "epss_percentile": 0.84005}, "CVE-2020-17049": {"epss_score": 0.267, "epss_percentile": 0.96168}, "CVE-2020-17051": {"epss_score": 0.16766, "epss_percentile": 0.9473}, "CVE-2020-17052": {"epss_score": 0.05837, "epss_percentile": 0.90249}, "CVE-2020-17053": {"epss_score": 0.04153, "epss_percentile": 0.88325}, "CVE-2020-17054": {"epss_score": 0.01658, "epss_percentile": 0.81609}, "CVE-2020-17055": {"epss_score": 0.10415, "epss_percentile": 0.92981}, "CVE-2020-17056": {"epss_score": 0.00446, "epss_percentile": 0.62929}, "CVE-2020-17057": {"epss_score": 0.10824, "epss_percentile": 0.93124}, "CVE-2020-17058": {"epss_score": 0.04153, "epss_percentile": 0.88325}, "CVE-2020-17060": {"epss_score": 0.00891, "epss_percentile": 0.75048}, "CVE-2020-17061": {"epss_score": 0.15717, "epss_percentile": 0.94492}, "CVE-2020-17062": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2020-17063": {"epss_score": 0.01445, "epss_percentile": 0.80324}, "CVE-2020-17064": {"epss_score": 0.13831, "epss_percentile": 0.94072}, "CVE-2020-17065": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2020-17066": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2020-17067": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2020-17068": {"epss_score": 0.00544, "epss_percentile": 0.67144}, "CVE-2020-17069": {"epss_score": 0.00426, "epss_percentile": 0.61734}, "CVE-2020-17070": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-17071": {"epss_score": 0.00402, "epss_percentile": 0.60289}, "CVE-2020-17073": {"epss_score": 0.00285, "epss_percentile": 0.51655}, "CVE-2020-17074": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2020-17075": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-17076": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2020-17077": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2020-17078": {"epss_score": 0.07497, "epss_percentile": 0.91504}, "CVE-2020-17079": {"epss_score": 0.07497, "epss_percentile": 0.91504}, "CVE-2020-17081": {"epss_score": 0.10913, "epss_percentile": 0.93155}, "CVE-2020-17082": {"epss_score": 0.09637, "epss_percentile": 0.92635}, "CVE-2020-17083": {"epss_score": 0.44019, "epss_percentile": 0.97415}, "CVE-2020-17084": {"epss_score": 0.00571, "epss_percentile": 0.67991}, "CVE-2020-17085": {"epss_score": 0.04097, "epss_percentile": 0.88252}, "CVE-2020-17086": {"epss_score": 0.23473, "epss_percentile": 0.95782}, "CVE-2020-17087": {"epss_score": 0.17833, "epss_percentile": 0.94914}, "CVE-2020-17088": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-17089": {"epss_score": 0.06207, "epss_percentile": 0.90567}, "CVE-2020-17090": {"epss_score": 0.0667, "epss_percentile": 0.90934}, "CVE-2020-17091": {"epss_score": 0.01425, "epss_percentile": 0.80197}, "CVE-2020-17092": {"epss_score": 0.00479, "epss_percentile": 0.64442}, "CVE-2020-17094": {"epss_score": 0.00778, "epss_percentile": 0.73125}, "CVE-2020-17095": {"epss_score": 0.01481, "epss_percentile": 0.8057}, "CVE-2020-17096": {"epss_score": 0.08663, "epss_percentile": 0.92177}, "CVE-2020-17097": {"epss_score": 0.00625, "epss_percentile": 0.6959}, "CVE-2020-17098": {"epss_score": 0.00499, "epss_percentile": 0.65276}, "CVE-2020-17099": {"epss_score": 0.00613, "epss_percentile": 0.69263}, "CVE-2020-17100": {"epss_score": 0.00271, "epss_percentile": 0.50288}, "CVE-2020-17101": {"epss_score": 0.00914, "epss_percentile": 0.75389}, "CVE-2020-17102": {"epss_score": 0.00551, "epss_percentile": 0.67364}, "CVE-2020-17103": {"epss_score": 0.00794, "epss_percentile": 0.73456}, "CVE-2020-17104": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2020-17105": {"epss_score": 0.07464, "epss_percentile": 0.91487}, "CVE-2020-17106": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2020-17107": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2020-17108": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2020-17109": {"epss_score": 0.09473, "epss_percentile": 0.92563}, "CVE-2020-17110": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2020-17113": {"epss_score": 0.01137, "epss_percentile": 0.77923}, "CVE-2020-17115": {"epss_score": 0.14558, "epss_percentile": 0.9424}, "CVE-2020-17117": {"epss_score": 0.03264, "epss_percentile": 0.8678}, "CVE-2020-17118": {"epss_score": 0.09442, "epss_percentile": 0.9255}, "CVE-2020-17119": {"epss_score": 0.15495, "epss_percentile": 0.94438}, "CVE-2020-17120": {"epss_score": 0.10921, "epss_percentile": 0.93159}, "CVE-2020-17121": {"epss_score": 0.13467, "epss_percentile": 0.93974}, "CVE-2020-17122": {"epss_score": 0.13212, "epss_percentile": 0.93902}, "CVE-2020-17123": {"epss_score": 0.1094, "epss_percentile": 0.93166}, "CVE-2020-17124": {"epss_score": 0.12927, "epss_percentile": 0.9382}, "CVE-2020-17125": {"epss_score": 0.12927, "epss_percentile": 0.9382}, "CVE-2020-17126": {"epss_score": 0.00655, "epss_percentile": 0.70369}, "CVE-2020-17127": {"epss_score": 0.12927, "epss_percentile": 0.9382}, "CVE-2020-17128": {"epss_score": 0.12659, "epss_percentile": 0.93742}, "CVE-2020-17129": {"epss_score": 0.12927, "epss_percentile": 0.9382}, "CVE-2020-17130": {"epss_score": 0.03433, "epss_percentile": 0.87127}, "CVE-2020-17131": {"epss_score": 0.01288, "epss_percentile": 0.79198}, "CVE-2020-17132": {"epss_score": 0.82345, "epss_percentile": 0.99189}, "CVE-2020-17133": {"epss_score": 0.10386, "epss_percentile": 0.9297}, "CVE-2020-17134": {"epss_score": 0.00691, "epss_percentile": 0.71263}, "CVE-2020-17135": {"epss_score": 0.00522, "epss_percentile": 0.66262}, "CVE-2020-17136": {"epss_score": 0.8165, "epss_percentile": 0.99149}, "CVE-2020-17137": {"epss_score": 0.00549, "epss_percentile": 0.67306}, "CVE-2020-17138": {"epss_score": 0.00591, "epss_percentile": 0.68597}, "CVE-2020-17139": {"epss_score": 0.00451, "epss_percentile": 0.63144}, "CVE-2020-17140": {"epss_score": 0.19473, "epss_percentile": 0.9519}, "CVE-2020-17141": {"epss_score": 0.33282, "epss_percentile": 0.9676}, "CVE-2020-17142": {"epss_score": 0.01159, "epss_percentile": 0.78126}, "CVE-2020-17143": {"epss_score": 0.81122, "epss_percentile": 0.99121}, "CVE-2020-17144": {"epss_score": 0.92725, "epss_percentile": 0.99739}, "CVE-2020-17145": {"epss_score": 0.00532, "epss_percentile": 0.6668}, "CVE-2020-17147": {"epss_score": 0.00612, "epss_percentile": 0.69225}, "CVE-2020-17148": {"epss_score": 0.11148, "epss_percentile": 0.93239}, "CVE-2020-17150": {"epss_score": 0.11469, "epss_percentile": 0.93377}, "CVE-2020-17152": {"epss_score": 0.11968, "epss_percentile": 0.93529}, "CVE-2020-17153": {"epss_score": 0.00591, "epss_percentile": 0.68584}, "CVE-2020-17156": {"epss_score": 0.14521, "epss_percentile": 0.94229}, "CVE-2020-17158": {"epss_score": 0.11968, "epss_percentile": 0.93529}, "CVE-2020-17159": {"epss_score": 0.08737, "epss_percentile": 0.92233}, "CVE-2020-17162": {"epss_score": 0.09415, "epss_percentile": 0.92537}, "CVE-2020-17163": {"epss_score": 0.00749, "epss_percentile": 0.72603}, "CVE-2020-17352": {"epss_score": 0.02228, "epss_percentile": 0.84077}, "CVE-2020-17353": {"epss_score": 0.01263, "epss_percentile": 0.78987}, "CVE-2020-17354": {"epss_score": 0.00016, "epss_percentile": 0.02962}, "CVE-2020-17355": {"epss_score": 0.0056, "epss_percentile": 0.67639}, "CVE-2020-17360": {"epss_score": 0.00335, "epss_percentile": 0.55829}, "CVE-2020-17361": {"epss_score": 0.00302, "epss_percentile": 0.5311}, "CVE-2020-17362": {"epss_score": 0.03781, "epss_percentile": 0.8772}, "CVE-2020-17363": {"epss_score": 0.05844, "epss_percentile": 0.90253}, "CVE-2020-17364": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2020-17365": {"epss_score": 0.00022, "epss_percentile": 0.04989}, "CVE-2020-17366": {"epss_score": 0.00248, "epss_percentile": 0.47976}, "CVE-2020-17367": {"epss_score": 0.00135, "epss_percentile": 0.34024}, "CVE-2020-17368": {"epss_score": 0.0449, "epss_percentile": 0.88756}, "CVE-2020-17372": {"epss_score": 0.00493, "epss_percentile": 0.6505}, "CVE-2020-17373": {"epss_score": 0.01166, "epss_percentile": 0.78179}, "CVE-2020-17376": {"epss_score": 0.00178, "epss_percentile": 0.39642}, "CVE-2020-17380": {"epss_score": 0.0007, "epss_percentile": 0.2165}, "CVE-2020-17381": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2020-17382": {"epss_score": 0.11307, "epss_percentile": 0.93301}, "CVE-2020-17383": {"epss_score": 0.06292, "epss_percentile": 0.90649}, "CVE-2020-17384": {"epss_score": 0.00483, "epss_percentile": 0.64596}, "CVE-2020-17385": {"epss_score": 0.00419, "epss_percentile": 0.61376}, "CVE-2020-17386": {"epss_score": 0.00239, "epss_percentile": 0.46903}, "CVE-2020-17387": {"epss_score": 0.12776, "epss_percentile": 0.93771}, "CVE-2020-17388": {"epss_score": 0.04291, "epss_percentile": 0.88502}, "CVE-2020-17389": {"epss_score": 0.12776, "epss_percentile": 0.93771}, "CVE-2020-17390": {"epss_score": 0.00084, "epss_percentile": 0.24854}, "CVE-2020-17391": {"epss_score": 0.0009, "epss_percentile": 0.2612}, "CVE-2020-17392": {"epss_score": 0.00099, "epss_percentile": 0.28384}, "CVE-2020-17393": {"epss_score": 0.0009, "epss_percentile": 0.2612}, "CVE-2020-17394": {"epss_score": 0.00087, "epss_percentile": 0.25541}, "CVE-2020-17395": {"epss_score": 0.00109, "epss_percentile": 0.29909}, "CVE-2020-17396": {"epss_score": 0.00099, "epss_percentile": 0.28384}, "CVE-2020-17397": {"epss_score": 0.00109, "epss_percentile": 0.29909}, "CVE-2020-17398": {"epss_score": 0.0009, "epss_percentile": 0.2612}, "CVE-2020-17399": {"epss_score": 0.00099, "epss_percentile": 0.28384}, "CVE-2020-17400": {"epss_score": 0.00099, "epss_percentile": 0.28384}, "CVE-2020-17401": {"epss_score": 0.00087, "epss_percentile": 0.25541}, "CVE-2020-17402": {"epss_score": 0.0006, "epss_percentile": 0.19094}, "CVE-2020-17403": {"epss_score": 0.0076, "epss_percentile": 0.72808}, "CVE-2020-17404": {"epss_score": 0.0076, "epss_percentile": 0.72808}, "CVE-2020-17405": {"epss_score": 0.01049, "epss_percentile": 0.77064}, "CVE-2020-17406": {"epss_score": 0.411, "epss_percentile": 0.97254}, "CVE-2020-17407": {"epss_score": 0.44899, "epss_percentile": 0.97458}, "CVE-2020-17408": {"epss_score": 0.14793, "epss_percentile": 0.94285}, "CVE-2020-17409": {"epss_score": 0.00299, "epss_percentile": 0.52841}, "CVE-2020-17410": {"epss_score": 0.01963, "epss_percentile": 0.83068}, "CVE-2020-17411": {"epss_score": 0.11393, "epss_percentile": 0.93332}, "CVE-2020-17412": {"epss_score": 0.0284, "epss_percentile": 0.85802}, "CVE-2020-17413": {"epss_score": 0.0284, "epss_percentile": 0.85802}, "CVE-2020-17414": {"epss_score": 0.00068, "epss_percentile": 0.21258}, "CVE-2020-17415": {"epss_score": 0.00068, "epss_percentile": 0.21258}, "CVE-2020-17416": {"epss_score": 0.01777, "epss_percentile": 0.82222}, "CVE-2020-17417": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2020-17418": {"epss_score": 0.0038, "epss_percentile": 0.5894}, "CVE-2020-17419": {"epss_score": 0.01473, "epss_percentile": 0.80513}, "CVE-2020-17420": {"epss_score": 0.01126, "epss_percentile": 0.77812}, "CVE-2020-17421": {"epss_score": 0.01473, "epss_percentile": 0.80513}, "CVE-2020-17422": {"epss_score": 0.01126, "epss_percentile": 0.77812}, "CVE-2020-17423": {"epss_score": 0.01473, "epss_percentile": 0.80513}, "CVE-2020-17424": {"epss_score": 0.00675, "epss_percentile": 0.70904}, "CVE-2020-17425": {"epss_score": 0.00675, "epss_percentile": 0.70904}, "CVE-2020-17426": {"epss_score": 0.01473, "epss_percentile": 0.80513}, "CVE-2020-17427": {"epss_score": 0.01473, "epss_percentile": 0.80513}, "CVE-2020-17428": {"epss_score": 0.01126, "epss_percentile": 0.77812}, "CVE-2020-17429": {"epss_score": 0.0131, "epss_percentile": 0.7936}, "CVE-2020-17430": {"epss_score": 0.00675, "epss_percentile": 0.70904}, "CVE-2020-17431": {"epss_score": 0.00675, "epss_percentile": 0.70904}, "CVE-2020-17432": {"epss_score": 0.00352, "epss_percentile": 0.57107}, "CVE-2020-17433": {"epss_score": 0.00352, "epss_percentile": 0.57107}, "CVE-2020-17434": {"epss_score": 0.00352, "epss_percentile": 0.57107}, "CVE-2020-17435": {"epss_score": 0.00352, "epss_percentile": 0.57107}, "CVE-2020-17436": {"epss_score": 0.00352, "epss_percentile": 0.57107}, "CVE-2020-17437": {"epss_score": 0.00341, "epss_percentile": 0.56311}, "CVE-2020-17438": {"epss_score": 0.00821, "epss_percentile": 0.739}, "CVE-2020-17439": {"epss_score": 0.00293, "epss_percentile": 0.52326}, "CVE-2020-17440": {"epss_score": 0.00577, "epss_percentile": 0.6816}, "CVE-2020-17441": {"epss_score": 0.00739, "epss_percentile": 0.72352}, "CVE-2020-17442": {"epss_score": 0.00744, "epss_percentile": 0.72513}, "CVE-2020-17443": {"epss_score": 0.00861, "epss_percentile": 0.7456}, "CVE-2020-17444": {"epss_score": 0.00447, "epss_percentile": 0.62961}, "CVE-2020-17445": {"epss_score": 0.00495, "epss_percentile": 0.65127}, "CVE-2020-17446": {"epss_score": 0.02141, "epss_percentile": 0.83751}, "CVE-2020-17448": {"epss_score": 0.00668, "epss_percentile": 0.70726}, "CVE-2020-17449": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-17450": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2020-17451": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-17452": {"epss_score": 0.00835, "epss_percentile": 0.74123}, "CVE-2020-17453": {"epss_score": 0.64438, "epss_percentile": 0.98379}, "CVE-2020-17454": {"epss_score": 0.0042, "epss_percentile": 0.61415}, "CVE-2020-17456": {"epss_score": 0.9004, "epss_percentile": 0.99558}, "CVE-2020-17457": {"epss_score": 0.00347, "epss_percentile": 0.56764}, "CVE-2020-17458": {"epss_score": 0.00347, "epss_percentile": 0.56764}, "CVE-2020-17462": {"epss_score": 0.00437, "epss_percentile": 0.62526}, "CVE-2020-17463": {"epss_score": 0.15269, "epss_percentile": 0.94395}, "CVE-2020-17465": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-17466": {"epss_score": 0.00719, "epss_percentile": 0.71948}, "CVE-2020-17467": {"epss_score": 0.01033, "epss_percentile": 0.76867}, "CVE-2020-17468": {"epss_score": 0.00693, "epss_percentile": 0.7133}, "CVE-2020-17469": {"epss_score": 0.00693, "epss_percentile": 0.7133}, "CVE-2020-17470": {"epss_score": 0.00446, "epss_percentile": 0.62919}, "CVE-2020-17473": {"epss_score": 0.00183, "epss_percentile": 0.40355}, "CVE-2020-17474": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2020-17475": {"epss_score": 0.0019, "epss_percentile": 0.4111}, "CVE-2020-17476": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-17477": {"epss_score": 0.00061, "epss_percentile": 0.19336}, "CVE-2020-17478": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-17479": {"epss_score": 0.00633, "epss_percentile": 0.69772}, "CVE-2020-17480": {"epss_score": 0.00881, "epss_percentile": 0.74877}, "CVE-2020-17482": {"epss_score": 0.00079, "epss_percentile": 0.23958}, "CVE-2020-17483": {"epss_score": 0.00199, "epss_percentile": 0.4212}, "CVE-2020-17484": {"epss_score": 0.00096, "epss_percentile": 0.27296}, "CVE-2020-17485": {"epss_score": 0.00313, "epss_percentile": 0.54011}, "CVE-2020-17487": {"epss_score": 0.00518, "epss_percentile": 0.66117}, "CVE-2020-17489": {"epss_score": 0.00149, "epss_percentile": 0.35977}, "CVE-2020-17490": {"epss_score": 0.0006, "epss_percentile": 0.18984}, "CVE-2020-17494": {"epss_score": 0.00153, "epss_percentile": 0.36546}, "CVE-2020-17495": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2020-17496": {"epss_score": 0.94036, "epss_percentile": 0.9989}, "CVE-2020-17497": {"epss_score": 0.00094, "epss_percentile": 0.2677}, "CVE-2020-17498": {"epss_score": 0.0023, "epss_percentile": 0.45726}, "CVE-2020-17500": {"epss_score": 0.04469, "epss_percentile": 0.88732}, "CVE-2020-17502": {"epss_score": 0.03987, "epss_percentile": 0.88066}, "CVE-2020-17503": {"epss_score": 0.04778, "epss_percentile": 0.89134}, "CVE-2020-17504": {"epss_score": 0.04778, "epss_percentile": 0.89134}, "CVE-2020-17505": {"epss_score": 0.90192, "epss_percentile": 0.99567}, "CVE-2020-17506": {"epss_score": 0.91971, "epss_percentile": 0.99682}, "CVE-2020-17507": {"epss_score": 0.02601, "epss_percentile": 0.85207}, "CVE-2020-17508": {"epss_score": 0.02656, "epss_percentile": 0.85356}, "CVE-2020-17509": {"epss_score": 0.03046, "epss_percentile": 0.86283}, "CVE-2020-17510": {"epss_score": 0.01109, "epss_percentile": 0.77652}, "CVE-2020-17511": {"epss_score": 0.00105, "epss_percentile": 0.29266}, "CVE-2020-17513": {"epss_score": 0.02135, "epss_percentile": 0.83726}, "CVE-2020-17514": {"epss_score": 0.00812, "epss_percentile": 0.7375}, "CVE-2020-17515": {"epss_score": 0.10185, "epss_percentile": 0.92884}, "CVE-2020-17516": {"epss_score": 0.00853, "epss_percentile": 0.74441}, "CVE-2020-17517": {"epss_score": 0.00416, "epss_percentile": 0.61174}, "CVE-2020-17518": {"epss_score": 0.93243, "epss_percentile": 0.99787}, "CVE-2020-17519": {"epss_score": 0.94383, "epss_percentile": 0.99966}, "CVE-2020-17520": {"epss_score": 0.00246, "epss_percentile": 0.47791}, "CVE-2020-17521": {"epss_score": 0.0179, "epss_percentile": 0.82277}, "CVE-2020-17522": {"epss_score": 0.02162, "epss_percentile": 0.83828}, "CVE-2020-17523": {"epss_score": 0.88767, "epss_percentile": 0.99489}, "CVE-2020-17525": {"epss_score": 0.12914, "epss_percentile": 0.93816}, "CVE-2020-17526": {"epss_score": 0.91172, "epss_percentile": 0.99625}, "CVE-2020-17527": {"epss_score": 0.11066, "epss_percentile": 0.93208}, "CVE-2020-17528": {"epss_score": 0.0174, "epss_percentile": 0.82043}, "CVE-2020-17529": {"epss_score": 0.0143, "epss_percentile": 0.80238}, "CVE-2020-17530": {"epss_score": 0.94362, "epss_percentile": 0.99959}, "CVE-2020-17531": {"epss_score": 0.36455, "epss_percentile": 0.96979}, "CVE-2020-17532": {"epss_score": 0.02854, "epss_percentile": 0.85835}, "CVE-2020-17533": {"epss_score": 0.05313, "epss_percentile": 0.8972}, "CVE-2020-17534": {"epss_score": 0.00068, "epss_percentile": 0.21334}, "CVE-2020-17538": {"epss_score": 0.0068, "epss_percentile": 0.71034}, "CVE-2020-17541": {"epss_score": 0.00316, "epss_percentile": 0.54299}, "CVE-2020-17542": {"epss_score": 0.00301, "epss_percentile": 0.53071}, "CVE-2020-17551": {"epss_score": 0.00327, "epss_percentile": 0.55104}, "CVE-2020-17563": {"epss_score": 0.11682, "epss_percentile": 0.93445}, "CVE-2020-17564": {"epss_score": 0.11682, "epss_percentile": 0.93445}, "CVE-2020-17752": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2020-17753": {"epss_score": 0.00506, "epss_percentile": 0.65638}, "CVE-2020-17759": {"epss_score": 0.00467, "epss_percentile": 0.63826}, "CVE-2020-17891": {"epss_score": 0.00567, "epss_percentile": 0.67851}, "CVE-2020-17901": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2020-17952": {"epss_score": 0.02228, "epss_percentile": 0.84076}, "CVE-2020-17999": {"epss_score": 0.01993, "epss_percentile": 0.83186}, "CVE-2020-18013": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-18019": {"epss_score": 0.00316, "epss_percentile": 0.54215}, "CVE-2020-18020": {"epss_score": 0.10359, "epss_percentile": 0.92958}, "CVE-2020-18022": {"epss_score": 0.00522, "epss_percentile": 0.66273}, "CVE-2020-18032": {"epss_score": 0.00408, "epss_percentile": 0.60653}, "CVE-2020-18035": {"epss_score": 0.00429, "epss_percentile": 0.61979}, "CVE-2020-18048": {"epss_score": 0.01821, "epss_percentile": 0.82411}, "CVE-2020-18065": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-18066": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2020-18070": {"epss_score": 0.04312, "epss_percentile": 0.88534}, "CVE-2020-18077": {"epss_score": 0.00391, "epss_percentile": 0.59575}, "CVE-2020-18078": {"epss_score": 0.00441, "epss_percentile": 0.6265}, "CVE-2020-18081": {"epss_score": 0.00318, "epss_percentile": 0.54453}, "CVE-2020-18084": {"epss_score": 0.00638, "epss_percentile": 0.69916}, "CVE-2020-18102": {"epss_score": 0.00567, "epss_percentile": 0.67851}, "CVE-2020-18106": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2020-18114": {"epss_score": 0.01137, "epss_percentile": 0.77925}, "CVE-2020-18116": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2020-18121": {"epss_score": 0.00361, "epss_percentile": 0.57748}, "CVE-2020-18123": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2020-18124": {"epss_score": 0.00084, "epss_percentile": 0.24982}, "CVE-2020-18125": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2020-18126": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2020-18127": {"epss_score": 0.0032, "epss_percentile": 0.54614}, "CVE-2020-18129": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2020-18131": {"epss_score": 0.00085, "epss_percentile": 0.25149}, "CVE-2020-18132": {"epss_score": 0.00056, "epss_percentile": 0.17699}, "CVE-2020-18144": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2020-18145": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2020-18151": {"epss_score": 0.00107, "epss_percentile": 0.29697}, "CVE-2020-18155": {"epss_score": 0.00261, "epss_percentile": 0.49277}, "CVE-2020-18157": {"epss_score": 0.00112, "epss_percentile": 0.30514}, "CVE-2020-18158": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2020-18164": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-18165": {"epss_score": 0.00389, "epss_percentile": 0.59454}, "CVE-2020-18166": {"epss_score": 0.00842, "epss_percentile": 0.74233}, "CVE-2020-18167": {"epss_score": 0.00422, "epss_percentile": 0.61573}, "CVE-2020-18169": {"epss_score": 0.00052, "epss_percentile": 0.16537}, "CVE-2020-18170": {"epss_score": 0.00328, "epss_percentile": 0.55171}, "CVE-2020-18171": {"epss_score": 0.00038, "epss_percentile": 0.11117}, "CVE-2020-18172": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-18173": {"epss_score": 0.00077, "epss_percentile": 0.23305}, "CVE-2020-18174": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-18175": {"epss_score": 0.00508, "epss_percentile": 0.65682}, "CVE-2020-18178": {"epss_score": 0.01781, "epss_percentile": 0.82239}, "CVE-2020-18184": {"epss_score": 0.00611, "epss_percentile": 0.69189}, "CVE-2020-18185": {"epss_score": 0.00475, "epss_percentile": 0.64196}, "CVE-2020-18190": {"epss_score": 0.03325, "epss_percentile": 0.86921}, "CVE-2020-18191": {"epss_score": 0.05176, "epss_percentile": 0.89574}, "CVE-2020-18194": {"epss_score": 0.00686, "epss_percentile": 0.71156}, "CVE-2020-18195": {"epss_score": 0.00346, "epss_percentile": 0.5663}, "CVE-2020-18198": {"epss_score": 0.00346, "epss_percentile": 0.5663}, "CVE-2020-18215": {"epss_score": 0.00561, "epss_percentile": 0.67673}, "CVE-2020-18220": {"epss_score": 0.0007, "epss_percentile": 0.2167}, "CVE-2020-18221": {"epss_score": 0.00389, "epss_percentile": 0.5941}, "CVE-2020-18229": {"epss_score": 0.00328, "epss_percentile": 0.55163}, "CVE-2020-18230": {"epss_score": 0.00361, "epss_percentile": 0.5772}, "CVE-2020-18232": {"epss_score": 0.01246, "epss_percentile": 0.78847}, "CVE-2020-18243": {"epss_score": 0.00168, "epss_percentile": 0.38479}, "CVE-2020-18259": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2020-18261": {"epss_score": 0.00907, "epss_percentile": 0.75266}, "CVE-2020-18262": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2020-18263": {"epss_score": 0.00246, "epss_percentile": 0.47765}, "CVE-2020-18264": {"epss_score": 0.00448, "epss_percentile": 0.63012}, "CVE-2020-18265": {"epss_score": 0.00448, "epss_percentile": 0.63012}, "CVE-2020-18268": {"epss_score": 0.06993, "epss_percentile": 0.91169}, "CVE-2020-18280": {"epss_score": 0.00073, "epss_percentile": 0.22544}, "CVE-2020-18282": {"epss_score": 0.00044, "epss_percentile": 0.13617}, "CVE-2020-18305": {"epss_score": 0.00335, "epss_percentile": 0.55867}, "CVE-2020-18324": {"epss_score": 0.06672, "epss_percentile": 0.90935}, "CVE-2020-18325": {"epss_score": 0.01709, "epss_percentile": 0.8187}, "CVE-2020-18326": {"epss_score": 0.0164, "epss_percentile": 0.815}, "CVE-2020-18327": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2020-18329": {"epss_score": 0.00359, "epss_percentile": 0.57544}, "CVE-2020-18330": {"epss_score": 0.00422, "epss_percentile": 0.61571}, "CVE-2020-18331": {"epss_score": 0.00675, "epss_percentile": 0.70886}, "CVE-2020-18336": {"epss_score": 0.00113, "epss_percentile": 0.30608}, "CVE-2020-18378": {"epss_score": 0.00105, "epss_percentile": 0.29309}, "CVE-2020-18382": {"epss_score": 0.00217, "epss_percentile": 0.44299}, "CVE-2020-18392": {"epss_score": 0.00251, "epss_percentile": 0.48315}, "CVE-2020-18395": {"epss_score": 0.00453, "epss_percentile": 0.63213}, "CVE-2020-18404": {"epss_score": 0.00054, "epss_percentile": 0.17269}, "CVE-2020-18406": {"epss_score": 0.00067, "epss_percentile": 0.21062}, "CVE-2020-18409": {"epss_score": 0.00039, "epss_percentile": 0.11673}, "CVE-2020-18410": {"epss_score": 0.00054, "epss_percentile": 0.17269}, "CVE-2020-18413": {"epss_score": 0.00056, "epss_percentile": 0.17699}, "CVE-2020-18414": {"epss_score": 0.00056, "epss_percentile": 0.17699}, "CVE-2020-18416": {"epss_score": 0.00047, "epss_percentile": 0.14637}, "CVE-2020-18418": {"epss_score": 0.00064, "epss_percentile": 0.20325}, "CVE-2020-18428": {"epss_score": 0.00306, "epss_percentile": 0.53432}, "CVE-2020-18430": {"epss_score": 0.00306, "epss_percentile": 0.53432}, "CVE-2020-18432": {"epss_score": 0.00501, "epss_percentile": 0.65349}, "CVE-2020-18438": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2020-18439": {"epss_score": 0.00257, "epss_percentile": 0.4886}, "CVE-2020-18440": {"epss_score": 0.00993, "epss_percentile": 0.76403}, "CVE-2020-18442": {"epss_score": 0.00058, "epss_percentile": 0.18314}, "CVE-2020-18445": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2020-18446": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-18449": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2020-18451": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-18454": {"epss_score": 0.00147, "epss_percentile": 0.35679}, "CVE-2020-18455": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-18456": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-18457": {"epss_score": 0.00184, "epss_percentile": 0.40421}, "CVE-2020-18458": {"epss_score": 0.00115, "epss_percentile": 0.31004}, "CVE-2020-18460": {"epss_score": 0.00122, "epss_percentile": 0.32025}, "CVE-2020-18462": {"epss_score": 0.00378, "epss_percentile": 0.58785}, "CVE-2020-18463": {"epss_score": 0.00096, "epss_percentile": 0.27404}, "CVE-2020-18464": {"epss_score": 0.00084, "epss_percentile": 0.24982}, "CVE-2020-18467": {"epss_score": 0.00199, "epss_percentile": 0.42142}, "CVE-2020-18468": {"epss_score": 0.00199, "epss_percentile": 0.42142}, "CVE-2020-18469": {"epss_score": 0.00114, "epss_percentile": 0.30754}, "CVE-2020-18470": {"epss_score": 0.00135, "epss_percentile": 0.33968}, "CVE-2020-18475": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2020-18476": {"epss_score": 0.00239, "epss_percentile": 0.46936}, "CVE-2020-18477": {"epss_score": 0.00239, "epss_percentile": 0.46936}, "CVE-2020-18494": {"epss_score": 0.0062, "epss_percentile": 0.69438}, "CVE-2020-18544": {"epss_score": 0.01632, "epss_percentile": 0.81456}, "CVE-2020-18568": {"epss_score": 0.44265, "epss_percentile": 0.97427}, "CVE-2020-18646": {"epss_score": 0.00232, "epss_percentile": 0.45957}, "CVE-2020-18647": {"epss_score": 0.00232, "epss_percentile": 0.45957}, "CVE-2020-18648": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2020-18651": {"epss_score": 0.01816, "epss_percentile": 0.82393}, "CVE-2020-18652": {"epss_score": 0.01758, "epss_percentile": 0.82138}, "CVE-2020-18654": {"epss_score": 0.00989, "epss_percentile": 0.76373}, "CVE-2020-18657": {"epss_score": 0.00375, "epss_percentile": 0.58603}, "CVE-2020-18658": {"epss_score": 0.00512, "epss_percentile": 0.65875}, "CVE-2020-18659": {"epss_score": 0.00375, "epss_percentile": 0.58603}, "CVE-2020-18660": {"epss_score": 0.00324, "epss_percentile": 0.54924}, "CVE-2020-18661": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2020-18662": {"epss_score": 0.00342, "epss_percentile": 0.56383}, "CVE-2020-18663": {"epss_score": 0.00275, "epss_percentile": 0.50686}, "CVE-2020-18664": {"epss_score": 0.00373, "epss_percentile": 0.58495}, "CVE-2020-18665": {"epss_score": 0.00657, "epss_percentile": 0.70474}, "CVE-2020-18667": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-18668": {"epss_score": 0.00461, "epss_percentile": 0.63567}, "CVE-2020-18670": {"epss_score": 0.00415, "epss_percentile": 0.61116}, "CVE-2020-18671": {"epss_score": 0.00386, "epss_percentile": 0.59254}, "CVE-2020-18683": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-18684": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-18685": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-18693": {"epss_score": 0.00263, "epss_percentile": 0.4955}, "CVE-2020-18694": {"epss_score": 0.01616, "epss_percentile": 0.8136}, "CVE-2020-18698": {"epss_score": 0.0062, "epss_percentile": 0.69457}, "CVE-2020-18699": {"epss_score": 0.00497, "epss_percentile": 0.65199}, "CVE-2020-18701": {"epss_score": 0.01243, "epss_percentile": 0.78827}, "CVE-2020-18702": {"epss_score": 0.00405, "epss_percentile": 0.60503}, "CVE-2020-18703": {"epss_score": 0.02571, "epss_percentile": 0.8513}, "CVE-2020-18704": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2020-18705": {"epss_score": 0.02571, "epss_percentile": 0.8513}, "CVE-2020-18713": {"epss_score": 0.00617, "epss_percentile": 0.69345}, "CVE-2020-18714": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2020-18716": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2020-18717": {"epss_score": 0.07212, "epss_percentile": 0.91329}, "CVE-2020-18723": {"epss_score": 0.032, "epss_percentile": 0.86623}, "CVE-2020-18724": {"epss_score": 0.00877, "epss_percentile": 0.74814}, "CVE-2020-18730": {"epss_score": 0.0039, "epss_percentile": 0.59514}, "CVE-2020-18731": {"epss_score": 0.0039, "epss_percentile": 0.59514}, "CVE-2020-18734": {"epss_score": 0.0066, "epss_percentile": 0.70537}, "CVE-2020-18735": {"epss_score": 0.00597, "epss_percentile": 0.68737}, "CVE-2020-18737": {"epss_score": 0.00463, "epss_percentile": 0.63628}, "CVE-2020-18741": {"epss_score": 0.00174, "epss_percentile": 0.39165}, "CVE-2020-18746": {"epss_score": 0.01443, "epss_percentile": 0.80315}, "CVE-2020-18748": {"epss_score": 0.00358, "epss_percentile": 0.57535}, "CVE-2020-18750": {"epss_score": 0.00059, "epss_percentile": 0.18705}, "CVE-2020-18753": {"epss_score": 0.00141, "epss_percentile": 0.34902}, "CVE-2020-18754": {"epss_score": 0.00285, "epss_percentile": 0.51538}, "CVE-2020-18756": {"epss_score": 0.00285, "epss_percentile": 0.51538}, "CVE-2020-18757": {"epss_score": 0.00138, "epss_percentile": 0.34428}, "CVE-2020-18758": {"epss_score": 0.00899, "epss_percentile": 0.75155}, "CVE-2020-18759": {"epss_score": 0.00133, "epss_percentile": 0.33689}, "CVE-2020-18766": {"epss_score": 0.00444, "epss_percentile": 0.62819}, "CVE-2020-18768": {"epss_score": 0.00031, "epss_percentile": 0.08713}, "CVE-2020-18770": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2020-18771": {"epss_score": 0.00222, "epss_percentile": 0.44772}, "CVE-2020-18773": {"epss_score": 0.00101, "epss_percentile": 0.28576}, "CVE-2020-18774": {"epss_score": 0.00102, "epss_percentile": 0.28724}, "CVE-2020-18775": {"epss_score": 0.00285, "epss_percentile": 0.51523}, "CVE-2020-18776": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2020-18778": {"epss_score": 0.00481, "epss_percentile": 0.64523}, "CVE-2020-18780": {"epss_score": 0.00025, "epss_percentile": 0.06119}, "CVE-2020-18781": {"epss_score": 0.00029, "epss_percentile": 0.0774}, "CVE-2020-18831": {"epss_score": 0.00557, "epss_percentile": 0.6755}, "CVE-2020-18839": {"epss_score": 0.00182, "epss_percentile": 0.40266}, "CVE-2020-18875": {"epss_score": 0.01299, "epss_percentile": 0.79283}, "CVE-2020-18877": {"epss_score": 0.00227, "epss_percentile": 0.45435}, "CVE-2020-18878": {"epss_score": 0.00252, "epss_percentile": 0.48378}, "CVE-2020-18879": {"epss_score": 0.09439, "epss_percentile": 0.92549}, "CVE-2020-18885": {"epss_score": 0.01653, "epss_percentile": 0.81577}, "CVE-2020-18886": {"epss_score": 0.02985, "epss_percentile": 0.86132}, "CVE-2020-18888": {"epss_score": 0.0016, "epss_percentile": 0.37498}, "CVE-2020-18889": {"epss_score": 0.00151, "epss_percentile": 0.36228}, "CVE-2020-18890": {"epss_score": 0.00638, "epss_percentile": 0.69901}, "CVE-2020-18897": {"epss_score": 0.00136, "epss_percentile": 0.34147}, "CVE-2020-18898": {"epss_score": 0.00216, "epss_percentile": 0.44186}, "CVE-2020-18899": {"epss_score": 0.00108, "epss_percentile": 0.29802}, "CVE-2020-18900": {"epss_score": 0.00053, "epss_percentile": 0.17037}, "CVE-2020-18912": {"epss_score": 0.01175, "epss_percentile": 0.78256}, "CVE-2020-18913": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2020-18917": {"epss_score": 0.00203, "epss_percentile": 0.42543}, "CVE-2020-18964": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2020-18971": {"epss_score": 0.00102, "epss_percentile": 0.28769}, "CVE-2020-18972": {"epss_score": 0.00167, "epss_percentile": 0.38356}, "CVE-2020-18974": {"epss_score": 0.00121, "epss_percentile": 0.31921}, "CVE-2020-18976": {"epss_score": 0.00161, "epss_percentile": 0.37591}, "CVE-2020-18979": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2020-18980": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-18982": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2020-18984": {"epss_score": 0.00849, "epss_percentile": 0.7437}, "CVE-2020-18985": {"epss_score": 0.00167, "epss_percentile": 0.38342}, "CVE-2020-18998": {"epss_score": 0.00463, "epss_percentile": 0.63628}, "CVE-2020-18999": {"epss_score": 0.00463, "epss_percentile": 0.63628}, "CVE-2020-19000": {"epss_score": 0.00427, "epss_percentile": 0.61778}, "CVE-2020-19001": {"epss_score": 0.07802, "epss_percentile": 0.91689}, "CVE-2020-19002": {"epss_score": 0.00427, "epss_percentile": 0.61778}, "CVE-2020-19003": {"epss_score": 0.00214, "epss_percentile": 0.43975}, "CVE-2020-19005": {"epss_score": 0.00193, "epss_percentile": 0.41389}, "CVE-2020-19007": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-19028": {"epss_score": 0.00341, "epss_percentile": 0.56314}, "CVE-2020-19037": {"epss_score": 0.00179, "epss_percentile": 0.39774}, "CVE-2020-19038": {"epss_score": 0.00252, "epss_percentile": 0.48338}, "CVE-2020-19042": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2020-19046": {"epss_score": 0.00324, "epss_percentile": 0.54951}, "CVE-2020-19047": {"epss_score": 0.00259, "epss_percentile": 0.49059}, "CVE-2020-19048": {"epss_score": 0.00154, "epss_percentile": 0.36698}, "CVE-2020-19049": {"epss_score": 0.00136, "epss_percentile": 0.34133}, "CVE-2020-19107": {"epss_score": 0.00621, "epss_percentile": 0.69492}, "CVE-2020-19108": {"epss_score": 0.00621, "epss_percentile": 0.69492}, "CVE-2020-19109": {"epss_score": 0.00621, "epss_percentile": 0.69492}, "CVE-2020-19110": {"epss_score": 0.00576, "epss_percentile": 0.68139}, "CVE-2020-19111": {"epss_score": 0.00461, "epss_percentile": 0.63545}, "CVE-2020-19112": {"epss_score": 0.00621, "epss_percentile": 0.69492}, "CVE-2020-19113": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2020-19114": {"epss_score": 0.00621, "epss_percentile": 0.69492}, "CVE-2020-19118": {"epss_score": 0.00236, "epss_percentile": 0.4637}, "CVE-2020-19131": {"epss_score": 0.00798, "epss_percentile": 0.73507}, "CVE-2020-19137": {"epss_score": 0.00129, "epss_percentile": 0.3317}, "CVE-2020-19138": {"epss_score": 0.09294, "epss_percentile": 0.92487}, "CVE-2020-19142": {"epss_score": 0.00394, "epss_percentile": 0.59792}, "CVE-2020-19143": {"epss_score": 0.00972, "epss_percentile": 0.76131}, "CVE-2020-19144": {"epss_score": 0.01504, "epss_percentile": 0.8074}, "CVE-2020-19146": {"epss_score": 0.00189, "epss_percentile": 0.40954}, "CVE-2020-19147": {"epss_score": 0.00289, "epss_percentile": 0.51984}, "CVE-2020-19148": {"epss_score": 0.00508, "epss_percentile": 0.6571}, "CVE-2020-19150": {"epss_score": 0.00584, "epss_percentile": 0.68394}, "CVE-2020-19151": {"epss_score": 0.01725, "epss_percentile": 0.81952}, "CVE-2020-19154": {"epss_score": 0.00128, "epss_percentile": 0.32957}, "CVE-2020-19155": {"epss_score": 0.03086, "epss_percentile": 0.86387}, "CVE-2020-19156": {"epss_score": 0.00324, "epss_percentile": 0.54951}, "CVE-2020-19157": {"epss_score": 0.00463, "epss_percentile": 0.63628}, "CVE-2020-19158": {"epss_score": 0.003, "epss_percentile": 0.5298}, "CVE-2020-19159": {"epss_score": 0.00448, "epss_percentile": 0.63012}, "CVE-2020-19165": {"epss_score": 0.0044, "epss_percentile": 0.62613}, "CVE-2020-19185": {"epss_score": 0.04825, "epss_percentile": 0.89184}, "CVE-2020-19186": {"epss_score": 0.04825, "epss_percentile": 0.89184}, "CVE-2020-19187": {"epss_score": 0.04825, "epss_percentile": 0.89184}, "CVE-2020-19188": {"epss_score": 0.07292, "epss_percentile": 0.91387}, "CVE-2020-19189": {"epss_score": 0.02546, "epss_percentile": 0.85062}, "CVE-2020-19190": {"epss_score": 0.06189, "epss_percentile": 0.90546}, "CVE-2020-19199": {"epss_score": 0.00237, "epss_percentile": 0.46733}, "CVE-2020-19201": {"epss_score": 0.00795, "epss_percentile": 0.7347}, "CVE-2020-19202": {"epss_score": 0.00308, "epss_percentile": 0.53616}, "CVE-2020-19203": {"epss_score": 0.012, "epss_percentile": 0.78467}, "CVE-2020-19204": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-19212": {"epss_score": 0.00256, "epss_percentile": 0.48793}, "CVE-2020-19213": {"epss_score": 0.0141, "epss_percentile": 0.80084}, "CVE-2020-19215": {"epss_score": 0.00255, "epss_percentile": 0.48636}, "CVE-2020-19216": {"epss_score": 0.00255, "epss_percentile": 0.48636}, "CVE-2020-19217": {"epss_score": 0.00239, "epss_percentile": 0.46936}, "CVE-2020-19228": {"epss_score": 0.0061, "epss_percentile": 0.69144}, "CVE-2020-19229": {"epss_score": 0.00345, "epss_percentile": 0.56588}, "CVE-2020-19248": {"epss_score": 0.00047, "epss_percentile": 0.14883}, "CVE-2020-19263": {"epss_score": 0.00174, "epss_percentile": 0.39177}, "CVE-2020-19264": {"epss_score": 0.00116, "epss_percentile": 0.31053}, "CVE-2020-19265": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2020-19266": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2020-19267": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2020-19268": {"epss_score": 0.00097, "epss_percentile": 0.27601}, "CVE-2020-19274": {"epss_score": 0.00358, "epss_percentile": 0.57535}, "CVE-2020-19275": {"epss_score": 0.00209, "epss_percentile": 0.43415}, "CVE-2020-19277": {"epss_score": 0.00213, "epss_percentile": 0.43842}, "CVE-2020-19278": {"epss_score": 0.00816, "epss_percentile": 0.7383}, "CVE-2020-19279": {"epss_score": 0.00328, "epss_percentile": 0.55277}, "CVE-2020-19280": {"epss_score": 0.00882, "epss_percentile": 0.74889}, "CVE-2020-19281": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-19282": {"epss_score": 0.06613, "epss_percentile": 0.90889}, "CVE-2020-19283": {"epss_score": 0.01992, "epss_percentile": 0.83181}, "CVE-2020-19284": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-19285": {"epss_score": 0.00264, "epss_percentile": 0.49679}, "CVE-2020-19286": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-19287": {"epss_score": 0.0017, "epss_percentile": 0.3866}, "CVE-2020-19288": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-19289": {"epss_score": 0.00264, "epss_percentile": 0.49679}, "CVE-2020-19290": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-19291": {"epss_score": 0.00151, "epss_percentile": 0.36342}, "CVE-2020-19292": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-19293": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-19294": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-19295": {"epss_score": 0.11021, "epss_percentile": 0.93192}, "CVE-2020-19301": {"epss_score": 0.00979, "epss_percentile": 0.76263}, "CVE-2020-19302": {"epss_score": 0.00614, "epss_percentile": 0.69273}, "CVE-2020-19303": {"epss_score": 0.00492, "epss_percentile": 0.65016}, "CVE-2020-19304": {"epss_score": 0.00839, "epss_percentile": 0.74184}, "CVE-2020-19305": {"epss_score": 0.00953, "epss_percentile": 0.75891}, "CVE-2020-19316": {"epss_score": 0.04286, "epss_percentile": 0.88493}, "CVE-2020-19318": {"epss_score": 0.00105, "epss_percentile": 0.29374}, "CVE-2020-19319": {"epss_score": 0.00438, "epss_percentile": 0.62552}, "CVE-2020-19320": {"epss_score": 0.01203, "epss_percentile": 0.78492}, "CVE-2020-19323": {"epss_score": 0.00325, "epss_percentile": 0.55021}, "CVE-2020-19360": {"epss_score": 0.87099, "epss_percentile": 0.99415}, "CVE-2020-19361": {"epss_score": 0.00361, "epss_percentile": 0.57701}, "CVE-2020-19362": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-19363": {"epss_score": 0.00407, "epss_percentile": 0.60596}, "CVE-2020-19364": {"epss_score": 0.00542, "epss_percentile": 0.67086}, "CVE-2020-19417": {"epss_score": 0.00805, "epss_percentile": 0.7363}, "CVE-2020-19419": {"epss_score": 0.01149, "epss_percentile": 0.78021}, "CVE-2020-19447": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2020-19450": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2020-19451": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2020-19455": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2020-19463": {"epss_score": 0.00161, "epss_percentile": 0.37612}, "CVE-2020-19464": {"epss_score": 0.00161, "epss_percentile": 0.37612}, "CVE-2020-19465": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-19466": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-19467": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-19468": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-19469": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-19470": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-19471": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-19472": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-19473": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-19474": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-19475": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-19481": {"epss_score": 0.00269, "epss_percentile": 0.50104}, "CVE-2020-19488": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2020-19490": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2020-19491": {"epss_score": 0.00188, "epss_percentile": 0.4091}, "CVE-2020-19492": {"epss_score": 0.00188, "epss_percentile": 0.4091}, "CVE-2020-19497": {"epss_score": 0.00371, "epss_percentile": 0.58406}, "CVE-2020-19498": {"epss_score": 0.00371, "epss_percentile": 0.58406}, "CVE-2020-19499": {"epss_score": 0.00371, "epss_percentile": 0.58406}, "CVE-2020-19510": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-19511": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2020-19513": {"epss_score": 0.00143, "epss_percentile": 0.3517}, "CVE-2020-19515": {"epss_score": 0.04532, "epss_percentile": 0.88812}, "CVE-2020-19527": {"epss_score": 0.00394, "epss_percentile": 0.59792}, "CVE-2020-19547": {"epss_score": 0.00393, "epss_percentile": 0.59747}, "CVE-2020-19551": {"epss_score": 0.00903, "epss_percentile": 0.75207}, "CVE-2020-19553": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-19554": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2020-19559": {"epss_score": 0.0135, "epss_percentile": 0.79676}, "CVE-2020-19586": {"epss_score": 0.01446, "epss_percentile": 0.80326}, "CVE-2020-19587": {"epss_score": 0.00211, "epss_percentile": 0.43719}, "CVE-2020-19595": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2020-19596": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2020-19609": {"epss_score": 0.00452, "epss_percentile": 0.63191}, "CVE-2020-19611": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-19613": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2020-19616": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-19617": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2020-19618": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2020-19619": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-19625": {"epss_score": 0.85769, "epss_percentile": 0.99347}, "CVE-2020-19626": {"epss_score": 0.00232, "epss_percentile": 0.45905}, "CVE-2020-19639": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2020-19640": {"epss_score": 0.01701, "epss_percentile": 0.81835}, "CVE-2020-19641": {"epss_score": 0.00984, "epss_percentile": 0.76311}, "CVE-2020-19642": {"epss_score": 0.00071, "epss_percentile": 0.22016}, "CVE-2020-19643": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2020-19660": {"epss_score": 0.00073, "epss_percentile": 0.22544}, "CVE-2020-19664": {"epss_score": 0.09234, "epss_percentile": 0.92459}, "CVE-2020-19667": {"epss_score": 0.00112, "epss_percentile": 0.30527}, "CVE-2020-19668": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2020-19669": {"epss_score": 0.00104, "epss_percentile": 0.29171}, "CVE-2020-19670": {"epss_score": 0.00213, "epss_percentile": 0.43922}, "CVE-2020-19672": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-19676": {"epss_score": 0.00379, "epss_percentile": 0.589}, "CVE-2020-19678": {"epss_score": 0.0022, "epss_percentile": 0.44606}, "CVE-2020-19682": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2020-19683": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-19692": {"epss_score": 0.01162, "epss_percentile": 0.78155}, "CVE-2020-19693": {"epss_score": 0.00097, "epss_percentile": 0.27467}, "CVE-2020-19695": {"epss_score": 0.0125, "epss_percentile": 0.78877}, "CVE-2020-19697": {"epss_score": 0.00289, "epss_percentile": 0.52077}, "CVE-2020-19698": {"epss_score": 0.00289, "epss_percentile": 0.52077}, "CVE-2020-19699": {"epss_score": 0.0027, "epss_percentile": 0.50263}, "CVE-2020-19703": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2020-19704": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2020-19705": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2020-19709": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2020-19716": {"epss_score": 0.00838, "epss_percentile": 0.74179}, "CVE-2020-19717": {"epss_score": 0.00285, "epss_percentile": 0.51681}, "CVE-2020-19718": {"epss_score": 0.00285, "epss_percentile": 0.51681}, "CVE-2020-19719": {"epss_score": 0.604, "epss_percentile": 0.98206}, "CVE-2020-19720": {"epss_score": 0.00285, "epss_percentile": 0.51681}, "CVE-2020-19721": {"epss_score": 0.00435, "epss_percentile": 0.62369}, "CVE-2020-19722": {"epss_score": 0.00285, "epss_percentile": 0.51681}, "CVE-2020-19724": {"epss_score": 0.0002, "epss_percentile": 0.04482}, "CVE-2020-19725": {"epss_score": 0.00527, "epss_percentile": 0.66469}, "CVE-2020-19726": {"epss_score": 0.00097, "epss_percentile": 0.27633}, "CVE-2020-19750": {"epss_score": 0.00335, "epss_percentile": 0.55892}, "CVE-2020-19751": {"epss_score": 0.00435, "epss_percentile": 0.62341}, "CVE-2020-19752": {"epss_score": 0.00329, "epss_percentile": 0.55414}, "CVE-2020-19762": {"epss_score": 0.0022, "epss_percentile": 0.44557}, "CVE-2020-19765": {"epss_score": 0.00206, "epss_percentile": 0.42918}, "CVE-2020-19766": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-19767": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-19768": {"epss_score": 0.00153, "epss_percentile": 0.36532}, "CVE-2020-19769": {"epss_score": 0.00153, "epss_percentile": 0.36532}, "CVE-2020-19770": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-19778": {"epss_score": 0.00864, "epss_percentile": 0.74599}, "CVE-2020-19786": {"epss_score": 0.00097, "epss_percentile": 0.27485}, "CVE-2020-19802": {"epss_score": 0.01697, "epss_percentile": 0.81817}, "CVE-2020-19803": {"epss_score": 0.00955, "epss_percentile": 0.75909}, "CVE-2020-19821": {"epss_score": 0.00239, "epss_percentile": 0.46936}, "CVE-2020-19822": {"epss_score": 0.0343, "epss_percentile": 0.87123}, "CVE-2020-19824": {"epss_score": 0.00024, "epss_percentile": 0.05846}, "CVE-2020-19825": {"epss_score": 0.00498, "epss_percentile": 0.65228}, "CVE-2020-19850": {"epss_score": 0.00308, "epss_percentile": 0.53571}, "CVE-2020-19853": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-19855": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-19858": {"epss_score": 0.00473, "epss_percentile": 0.64089}, "CVE-2020-19860": {"epss_score": 0.00131, "epss_percentile": 0.33459}, "CVE-2020-19861": {"epss_score": 0.00334, "epss_percentile": 0.55688}, "CVE-2020-19877": {"epss_score": 0.0063, "epss_percentile": 0.69704}, "CVE-2020-19878": {"epss_score": 0.00516, "epss_percentile": 0.66014}, "CVE-2020-19879": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-19880": {"epss_score": 0.00644, "epss_percentile": 0.70076}, "CVE-2020-19881": {"epss_score": 0.00252, "epss_percentile": 0.48411}, "CVE-2020-19882": {"epss_score": 0.00252, "epss_percentile": 0.48411}, "CVE-2020-19883": {"epss_score": 0.00252, "epss_percentile": 0.48411}, "CVE-2020-19884": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-19885": {"epss_score": 0.00223, "epss_percentile": 0.44898}, "CVE-2020-19886": {"epss_score": 0.00111, "epss_percentile": 0.30394}, "CVE-2020-19887": {"epss_score": 0.00223, "epss_percentile": 0.44898}, "CVE-2020-19888": {"epss_score": 0.00206, "epss_percentile": 0.42918}, "CVE-2020-19889": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2020-19890": {"epss_score": 0.00271, "epss_percentile": 0.50327}, "CVE-2020-19891": {"epss_score": 0.00795, "epss_percentile": 0.73465}, "CVE-2020-19896": {"epss_score": 0.00705, "epss_percentile": 0.716}, "CVE-2020-19897": {"epss_score": 0.00269, "epss_percentile": 0.50186}, "CVE-2020-19902": {"epss_score": 0.04553, "epss_percentile": 0.88842}, "CVE-2020-19907": {"epss_score": 0.09773, "epss_percentile": 0.92696}, "CVE-2020-19909": {"epss_score": 0.00017, "epss_percentile": 0.03503}, "CVE-2020-19914": {"epss_score": 0.00304, "epss_percentile": 0.53298}, "CVE-2020-19915": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-19924": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-19947": {"epss_score": 0.00492, "epss_percentile": 0.64997}, "CVE-2020-19949": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-19950": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-19951": {"epss_score": 0.00169, "epss_percentile": 0.38611}, "CVE-2020-19952": {"epss_score": 0.00047, "epss_percentile": 0.1463}, "CVE-2020-19954": {"epss_score": 0.00439, "epss_percentile": 0.62587}, "CVE-2020-19957": {"epss_score": 0.00403, "epss_percentile": 0.60344}, "CVE-2020-19959": {"epss_score": 0.00403, "epss_percentile": 0.60344}, "CVE-2020-19960": {"epss_score": 0.00403, "epss_percentile": 0.60344}, "CVE-2020-19961": {"epss_score": 0.00788, "epss_percentile": 0.73334}, "CVE-2020-19962": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-19964": {"epss_score": 0.00136, "epss_percentile": 0.34175}, "CVE-2020-1000": {"epss_score": 0.00409, "epss_percentile": 0.60697}, "CVE-2020-1001": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-1002": {"epss_score": 0.00329, "epss_percentile": 0.5532}, "CVE-2020-1003": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-1004": {"epss_score": 0.00277, "epss_percentile": 0.50783}, "CVE-2020-1005": {"epss_score": 0.00688, "epss_percentile": 0.71204}, "CVE-2020-1006": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-1007": {"epss_score": 0.00336, "epss_percentile": 0.55915}, "CVE-2020-1008": {"epss_score": 0.33401, "epss_percentile": 0.9677}, "CVE-2020-1009": {"epss_score": 0.00555, "epss_percentile": 0.67461}, "CVE-2020-1010": {"epss_score": 0.00228, "epss_percentile": 0.45533}, "CVE-2020-1011": {"epss_score": 0.00555, "epss_percentile": 0.67461}, "CVE-2020-1012": {"epss_score": 0.15324, "epss_percentile": 0.94409}, "CVE-2020-1013": {"epss_score": 0.29211, "epss_percentile": 0.96425}, "CVE-2020-1014": {"epss_score": 0.00467, "epss_percentile": 0.63819}, "CVE-2020-1015": {"epss_score": 0.09417, "epss_percentile": 0.92538}, "CVE-2020-1016": {"epss_score": 0.00633, "epss_percentile": 0.69775}, "CVE-2020-1017": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-1018": {"epss_score": 0.0392, "epss_percentile": 0.87952}, "CVE-2020-1019": {"epss_score": 0.00379, "epss_percentile": 0.58856}, "CVE-2020-1020": {"epss_score": 0.87984, "epss_percentile": 0.99453}, "CVE-2020-1021": {"epss_score": 0.00225, "epss_percentile": 0.4509}, "CVE-2020-1022": {"epss_score": 0.39214, "epss_percentile": 0.97146}, "CVE-2020-1023": {"epss_score": 0.28873, "epss_percentile": 0.96396}, "CVE-2020-1024": {"epss_score": 0.28873, "epss_percentile": 0.96396}, "CVE-2020-1025": {"epss_score": 0.13799, "epss_percentile": 0.94059}, "CVE-2020-1026": {"epss_score": 0.01462, "epss_percentile": 0.80433}, "CVE-2020-1027": {"epss_score": 0.06998, "epss_percentile": 0.91172}, "CVE-2020-1028": {"epss_score": 0.13814, "epss_percentile": 0.94066}, "CVE-2020-1029": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-1030": {"epss_score": 0.01539, "epss_percentile": 0.80937}, "CVE-2020-1031": {"epss_score": 0.18186, "epss_percentile": 0.94972}, "CVE-2020-1032": {"epss_score": 0.00647, "epss_percentile": 0.7018}, "CVE-2020-1033": {"epss_score": 0.00775, "epss_percentile": 0.73091}, "CVE-2020-1034": {"epss_score": 0.17023, "epss_percentile": 0.94761}, "CVE-2020-1035": {"epss_score": 0.05133, "epss_percentile": 0.89533}, "CVE-2020-1036": {"epss_score": 0.01075, "epss_percentile": 0.7732}, "CVE-2020-1037": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2020-1038": {"epss_score": 0.00463, "epss_percentile": 0.63684}, "CVE-2020-1039": {"epss_score": 0.11071, "epss_percentile": 0.93209}, "CVE-2020-1040": {"epss_score": 0.00213, "epss_percentile": 0.43849}, "CVE-2020-1041": {"epss_score": 0.00647, "epss_percentile": 0.7018}, "CVE-2020-1042": {"epss_score": 0.00647, "epss_percentile": 0.7018}, "CVE-2020-1043": {"epss_score": 0.00647, "epss_percentile": 0.7018}, "CVE-2020-1044": {"epss_score": 0.04445, "epss_percentile": 0.88698}, "CVE-2020-1045": {"epss_score": 0.20523, "epss_percentile": 0.95364}, "CVE-2020-1046": {"epss_score": 0.11304, "epss_percentile": 0.933}, "CVE-2020-1047": {"epss_score": 0.00549, "epss_percentile": 0.67302}, "CVE-2020-1048": {"epss_score": 0.73296, "epss_percentile": 0.98746}, "CVE-2020-1049": {"epss_score": 0.00979, "epss_percentile": 0.76262}, "CVE-2020-1050": {"epss_score": 0.01025, "epss_percentile": 0.76787}, "CVE-2020-1051": {"epss_score": 0.42055, "epss_percentile": 0.97309}, "CVE-2020-1052": {"epss_score": 0.00262, "epss_percentile": 0.49339}, "CVE-2020-1053": {"epss_score": 0.00278, "epss_percentile": 0.50919}, "CVE-2020-1054": {"epss_score": 0.82335, "epss_percentile": 0.99189}, "CVE-2020-1055": {"epss_score": 0.00713, "epss_percentile": 0.71799}, "CVE-2020-1056": {"epss_score": 0.14772, "epss_percentile": 0.9428}, "CVE-2020-1057": {"epss_score": 0.01006, "epss_percentile": 0.76556}, "CVE-2020-1058": {"epss_score": 0.05133, "epss_percentile": 0.89533}, "CVE-2020-1059": {"epss_score": 0.02333, "epss_percentile": 0.8441}, "CVE-2020-1060": {"epss_score": 0.05133, "epss_percentile": 0.89533}, "CVE-2020-1061": {"epss_score": 0.22869, "epss_percentile": 0.95702}, "CVE-2020-1062": {"epss_score": 0.30225, "epss_percentile": 0.96521}, "CVE-2020-1063": {"epss_score": 0.01111, "epss_percentile": 0.7767}, "CVE-2020-1064": {"epss_score": 0.09339, "epss_percentile": 0.92507}, "CVE-2020-1065": {"epss_score": 0.04538, "epss_percentile": 0.88826}, "CVE-2020-1066": {"epss_score": 0.29696, "epss_percentile": 0.96466}, "CVE-2020-1067": {"epss_score": 0.37874, "epss_percentile": 0.97074}, "CVE-2020-1068": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1069": {"epss_score": 0.34532, "epss_percentile": 0.96853}, "CVE-2020-1070": {"epss_score": 0.0024, "epss_percentile": 0.47188}, "CVE-2020-1071": {"epss_score": 0.00292, "epss_percentile": 0.52223}, "CVE-2020-1072": {"epss_score": 0.00688, "epss_percentile": 0.71204}, "CVE-2020-1073": {"epss_score": 0.13506, "epss_percentile": 0.93984}, "CVE-2020-1074": {"epss_score": 0.3131, "epss_percentile": 0.96607}, "CVE-2020-1075": {"epss_score": 0.00379, "epss_percentile": 0.58898}, "CVE-2020-1076": {"epss_score": 0.00193, "epss_percentile": 0.41487}, "CVE-2020-1077": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-1078": {"epss_score": 0.0041, "epss_percentile": 0.6079}, "CVE-2020-1079": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-1080": {"epss_score": 0.00549, "epss_percentile": 0.67302}, "CVE-2020-1081": {"epss_score": 0.00233, "epss_percentile": 0.46057}, "CVE-2020-1082": {"epss_score": 0.00285, "epss_percentile": 0.51527}, "CVE-2020-1083": {"epss_score": 0.00694, "epss_percentile": 0.71353}, "CVE-2020-1084": {"epss_score": 0.00184, "epss_percentile": 0.40419}, "CVE-2020-1085": {"epss_score": 0.00262, "epss_percentile": 0.49335}, "CVE-2020-1086": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1087": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1088": {"epss_score": 0.00278, "epss_percentile": 0.50919}, "CVE-2020-1090": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1091": {"epss_score": 0.24562, "epss_percentile": 0.95934}, "CVE-2020-1092": {"epss_score": 0.05133, "epss_percentile": 0.89533}, "CVE-2020-1093": {"epss_score": 0.05133, "epss_percentile": 0.89533}, "CVE-2020-1094": {"epss_score": 0.00401, "epss_percentile": 0.6022}, "CVE-2020-1096": {"epss_score": 0.09794, "epss_percentile": 0.92705}, "CVE-2020-1097": {"epss_score": 0.20002, "epss_percentile": 0.95273}, "CVE-2020-1098": {"epss_score": 0.00278, "epss_percentile": 0.50919}, "CVE-2020-1099": {"epss_score": 0.00783, "epss_percentile": 0.73223}, "CVE-2020-1100": {"epss_score": 0.00921, "epss_percentile": 0.75485}, "CVE-2020-1101": {"epss_score": 0.00783, "epss_percentile": 0.73223}, "CVE-2020-1102": {"epss_score": 0.46247, "epss_percentile": 0.97538}, "CVE-2020-1103": {"epss_score": 0.08862, "epss_percentile": 0.92291}, "CVE-2020-1104": {"epss_score": 0.00606, "epss_percentile": 0.69013}, "CVE-2020-1105": {"epss_score": 0.00967, "epss_percentile": 0.76069}, "CVE-2020-1106": {"epss_score": 0.01851, "epss_percentile": 0.82535}, "CVE-2020-1107": {"epss_score": 0.00675, "epss_percentile": 0.70912}, "CVE-2020-1108": {"epss_score": 0.03788, "epss_percentile": 0.87728}, "CVE-2020-1109": {"epss_score": 0.00404, "epss_percentile": 0.60441}, "CVE-2020-1110": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1111": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1112": {"epss_score": 0.01366, "epss_percentile": 0.7978}, "CVE-2020-1113": {"epss_score": 0.03194, "epss_percentile": 0.86608}, "CVE-2020-1114": {"epss_score": 0.00277, "epss_percentile": 0.50783}, "CVE-2020-1115": {"epss_score": 0.00268, "epss_percentile": 0.50076}, "CVE-2020-1116": {"epss_score": 0.00394, "epss_percentile": 0.59751}, "CVE-2020-1117": {"epss_score": 0.30341, "epss_percentile": 0.96532}, "CVE-2020-1118": {"epss_score": 0.11289, "epss_percentile": 0.93293}, "CVE-2020-1119": {"epss_score": 0.00889, "epss_percentile": 0.75011}, "CVE-2020-1120": {"epss_score": 0.00337, "epss_percentile": 0.56063}, "CVE-2020-1121": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1122": {"epss_score": 0.00436, "epss_percentile": 0.62387}, "CVE-2020-1123": {"epss_score": 0.00266, "epss_percentile": 0.49883}, "CVE-2020-1124": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1125": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2020-1126": {"epss_score": 0.2125, "epss_percentile": 0.95487}, "CVE-2020-1129": {"epss_score": 0.09341, "epss_percentile": 0.92507}, "CVE-2020-1130": {"epss_score": 0.0048, "epss_percentile": 0.64468}, "CVE-2020-1131": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1132": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1133": {"epss_score": 0.00407, "epss_percentile": 0.60577}, "CVE-2020-1134": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1135": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1136": {"epss_score": 0.13814, "epss_percentile": 0.94066}, "CVE-2020-1137": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1138": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1139": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2020-1140": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1141": {"epss_score": 0.00587, "epss_percentile": 0.68469}, "CVE-2020-1142": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1143": {"epss_score": 0.0014, "epss_percentile": 0.34681}, "CVE-2020-1144": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1145": {"epss_score": 0.00661, "epss_percentile": 0.70582}, "CVE-2020-1146": {"epss_score": 0.0048, "epss_percentile": 0.64468}, "CVE-2020-1147": {"epss_score": 0.9343, "epss_percentile": 0.99806}, "CVE-2020-1148": {"epss_score": 0.00931, "epss_percentile": 0.75617}, "CVE-2020-1149": {"epss_score": 0.12481, "epss_percentile": 0.93685}, "CVE-2020-1150": {"epss_score": 0.23905, "epss_percentile": 0.95831}, "CVE-2020-1151": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2020-1152": {"epss_score": 0.00186, "epss_percentile": 0.40653}, "CVE-2020-1153": {"epss_score": 0.42055, "epss_percentile": 0.97309}, "CVE-2020-1154": {"epss_score": 0.00277, "epss_percentile": 0.50783}, "CVE-2020-1155": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2020-1156": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2020-1157": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2020-1158": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2020-1159": {"epss_score": 0.00354, "epss_percentile": 0.57202}, "CVE-2020-1160": {"epss_score": 0.00432, "epss_percentile": 0.62161}, "CVE-2020-1161": {"epss_score": 0.03721, "epss_percentile": 0.8762}, "CVE-2020-1162": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-1163": {"epss_score": 0.00331, "epss_percentile": 0.55529}, "CVE-2020-1164": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2020-1165": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1166": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1167": {"epss_score": 0.109, "epss_percentile": 0.93148}, "CVE-2020-1169": {"epss_score": 0.09313, "epss_percentile": 0.92497}, "CVE-2020-1170": {"epss_score": 0.00238, "epss_percentile": 0.46816}, "CVE-2020-1171": {"epss_score": 0.35831, "epss_percentile": 0.96936}, "CVE-2020-1172": {"epss_score": 0.00763, "epss_percentile": 0.72886}, "CVE-2020-1173": {"epss_score": 0.01184, "epss_percentile": 0.78332}, "CVE-2020-1174": {"epss_score": 0.42055, "epss_percentile": 0.97309}, "CVE-2020-1175": {"epss_score": 0.42055, "epss_percentile": 0.97309}, "CVE-2020-1176": {"epss_score": 0.42055, "epss_percentile": 0.97309}, "CVE-2020-1177": {"epss_score": 0.01048, "epss_percentile": 0.7705}, "CVE-2020-1178": {"epss_score": 0.12125, "epss_percentile": 0.93573}, "CVE-2020-1179": {"epss_score": 0.31918, "epss_percentile": 0.96659}, "CVE-2020-1180": {"epss_score": 0.01658, "epss_percentile": 0.81609}, "CVE-2020-1181": {"epss_score": 0.5074, "epss_percentile": 0.97748}, "CVE-2020-1182": {"epss_score": 0.1591, "epss_percentile": 0.94529}, "CVE-2020-1183": {"epss_score": 0.01048, "epss_percentile": 0.7705}, "CVE-2020-1184": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1185": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1186": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1187": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1188": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1189": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1190": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1191": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1192": {"epss_score": 0.41223, "epss_percentile": 0.97261}, "CVE-2020-1193": {"epss_score": 0.10675, "epss_percentile": 0.93066}, "CVE-2020-1194": {"epss_score": 0.0013, "epss_percentile": 0.33282}, "CVE-2020-1195": {"epss_score": 0.0565, "epss_percentile": 0.90083}, "CVE-2020-1196": {"epss_score": 0.00399, "epss_percentile": 0.60099}, "CVE-2020-1197": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-1198": {"epss_score": 0.0059, "epss_percentile": 0.68575}, "CVE-2020-1199": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-1200": {"epss_score": 0.01152, "epss_percentile": 0.78048}, "CVE-2020-1201": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-1202": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-1203": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-1204": {"epss_score": 0.00503, "epss_percentile": 0.65467}, "CVE-2020-1205": {"epss_score": 0.0131, "epss_percentile": 0.79362}, "CVE-2020-1206": {"epss_score": 0.39453, "epss_percentile": 0.97161}, "CVE-2020-1207": {"epss_score": 0.00301, "epss_percentile": 0.53081}, "CVE-2020-1208": {"epss_score": 0.39459, "epss_percentile": 0.97162}, "CVE-2020-1209": {"epss_score": 0.13831, "epss_percentile": 0.94072}, "CVE-2020-1210": {"epss_score": 0.00427, "epss_percentile": 0.61884}, "CVE-2020-1211": {"epss_score": 0.13831, "epss_percentile": 0.94072}, "CVE-2020-1212": {"epss_score": 0.14751, "epss_percentile": 0.94274}, "CVE-2020-1213": {"epss_score": 0.04353, "epss_percentile": 0.88587}, "CVE-2020-1214": {"epss_score": 0.07988, "epss_percentile": 0.91808}, "CVE-2020-1215": {"epss_score": 0.07988, "epss_percentile": 0.91808}, "CVE-2020-1216": {"epss_score": 0.07988, "epss_percentile": 0.91808}, "CVE-2020-1217": {"epss_score": 0.11567, "epss_percentile": 0.93406}, "CVE-2020-1218": {"epss_score": 0.12172, "epss_percentile": 0.93591}, "CVE-2020-1219": {"epss_score": 0.22031, "epss_percentile": 0.95586}, "CVE-2020-1220": {"epss_score": 0.00292, "epss_percentile": 0.52235}, "CVE-2020-1222": {"epss_score": 0.00656, "epss_percentile": 0.7044}, "CVE-2020-1223": {"epss_score": 0.36771, "epss_percentile": 0.97}, "CVE-2020-1224": {"epss_score": 0.22521, "epss_percentile": 0.95647}, "CVE-2020-1225": {"epss_score": 0.20625, "epss_percentile": 0.95387}, "CVE-2020-1226": {"epss_score": 0.20625, "epss_percentile": 0.95387}, "CVE-2020-1227": {"epss_score": 0.00408, "epss_percentile": 0.60681}, "CVE-2020-1228": {"epss_score": 0.15699, "epss_percentile": 0.94486}, "CVE-2020-1229": {"epss_score": 0.06887, "epss_percentile": 0.91093}, "CVE-2020-1230": {"epss_score": 0.07988, "epss_percentile": 0.91808}, "CVE-2020-1231": {"epss_score": 0.08352, "epss_percentile": 0.92005}, "CVE-2020-1232": {"epss_score": 0.24484, "epss_percentile": 0.95926}, "CVE-2020-1233": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2020-1234": {"epss_score": 0.17656, "epss_percentile": 0.94885}, "CVE-2020-1235": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2020-1236": {"epss_score": 0.40161, "epss_percentile": 0.97203}, "CVE-2020-1237": {"epss_score": 0.1373, "epss_percentile": 0.94045}, "CVE-2020-1238": {"epss_score": 0.09805, "epss_percentile": 0.92708}, "CVE-2020-1239": {"epss_score": 0.32984, "epss_percentile": 0.96739}, "CVE-2020-1240": {"epss_score": 0.32735, "epss_percentile": 0.96721}, "CVE-2020-1241": {"epss_score": 0.06984, "epss_percentile": 0.91162}, "CVE-2020-1242": {"epss_score": 0.03715, "epss_percentile": 0.87612}, "CVE-2020-1243": {"epss_score": 0.00386, "epss_percentile": 0.59263}, "CVE-2020-1244": {"epss_score": 0.05147, "epss_percentile": 0.89544}, "CVE-2020-1245": {"epss_score": 0.00332, "epss_percentile": 0.5558}, "CVE-2020-1246": {"epss_score": 0.00555, "epss_percentile": 0.67461}, "CVE-2020-1247": {"epss_score": 0.00376, "epss_percentile": 0.58651}, "CVE-2020-1248": {"epss_score": 0.32912, "epss_percentile": 0.96735}, "CVE-2020-1249": {"epss_score": 0.0033, "epss_percentile": 0.55424}, "CVE-2020-1250": {"epss_score": 0.00982, "epss_percentile": 0.76291}, "CVE-2020-1251": {"epss_score": 0.00303, "epss_percentile": 0.53173}, "CVE-2020-1252": {"epss_score": 0.12172, "epss_percentile": 0.93591}, "CVE-2020-1253": {"epss_score": 0.00411, "epss_percentile": 0.60877}, "CVE-2020-1254": {"epss_score": 0.00401, "epss_percentile": 0.6022}, "CVE-2020-1255": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2020-1256": {"epss_score": 0.20649, "epss_percentile": 0.95395}, "CVE-2020-1257": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-1258": {"epss_score": 0.00589, "epss_percentile": 0.68519}, "CVE-2020-1259": {"epss_score": 0.05076, "epss_percentile": 0.89468}, "CVE-2020-1260": {"epss_score": 0.04353, "epss_percentile": 0.88587}, "CVE-2020-1261": {"epss_score": 0.00479, "epss_percentile": 0.64423}, "CVE-2020-1262": {"epss_score": 0.00409, "epss_percentile": 0.60697}, "CVE-2020-1263": {"epss_score": 0.00374, "epss_percentile": 0.58529}, "CVE-2020-1264": {"epss_score": 0.00653, "epss_percentile": 0.7032}, "CVE-2020-1265": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-1266": {"epss_score": 0.00404, "epss_percentile": 0.60441}, "CVE-2020-1267": {"epss_score": 0.03441, "epss_percentile": 0.87141}, "CVE-2020-1268": {"epss_score": 0.00881, "epss_percentile": 0.74871}, "CVE-2020-1269": {"epss_score": 0.00399, "epss_percentile": 0.601}, "CVE-2020-1270": {"epss_score": 0.00541, "epss_percentile": 0.67048}, "CVE-2020-1271": {"epss_score": 0.00707, "epss_percentile": 0.71655}, "CVE-2020-1272": {"epss_score": 0.00555, "epss_percentile": 0.67461}, "CVE-2020-1273": {"epss_score": 0.00377, "epss_percentile": 0.587}, "CVE-2020-1274": {"epss_score": 0.00511, "epss_percentile": 0.65848}, "CVE-2020-1275": {"epss_score": 0.00511, "epss_percentile": 0.65848}, "CVE-2020-1276": {"epss_score": 0.00405, "epss_percentile": 0.60476}, "CVE-2020-1277": {"epss_score": 0.00668, "epss_percentile": 0.70741}, "CVE-2020-1278": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-1279": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-1280": {"epss_score": 0.13831, "epss_percentile": 0.94072}, "CVE-2020-1281": {"epss_score": 0.26226, "epss_percentile": 0.96125}, "CVE-2020-1282": {"epss_score": 0.10952, "epss_percentile": 0.93175}, "CVE-2020-1283": {"epss_score": 0.28225, "epss_percentile": 0.96333}, "CVE-2020-1284": {"epss_score": 0.16452, "epss_percentile": 0.94665}, "CVE-2020-1285": {"epss_score": 0.11645, "epss_percentile": 0.93426}, "CVE-2020-1286": {"epss_score": 0.37979, "epss_percentile": 0.97079}, "CVE-2020-1287": {"epss_score": 0.15675, "epss_percentile": 0.94483}, "CVE-2020-1289": {"epss_score": 0.00675, "epss_percentile": 0.70912}, "CVE-2020-1290": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2020-1291": {"epss_score": 0.15675, "epss_percentile": 0.94483}, "CVE-2020-1292": {"epss_score": 0.13831, "epss_percentile": 0.94072}, "CVE-2020-1293": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-1294": {"epss_score": 0.13831, "epss_percentile": 0.94072}, "CVE-2020-1295": {"epss_score": 0.12824, "epss_percentile": 0.93787}, "CVE-2020-1296": {"epss_score": 0.00401, "epss_percentile": 0.60261}, "CVE-2020-1297": {"epss_score": 0.01048, "epss_percentile": 0.7705}, "CVE-2020-1298": {"epss_score": 0.00792, "epss_percentile": 0.73415}, "CVE-2020-1299": {"epss_score": 0.38498, "epss_percentile": 0.97102}, "CVE-2020-1300": {"epss_score": 0.34576, "epss_percentile": 0.96857}, "CVE-2020-1301": {"epss_score": 0.61621, "epss_percentile": 0.98255}, "CVE-2020-1302": {"epss_score": 0.0072, "epss_percentile": 0.71967}, "CVE-2020-1303": {"epss_score": 0.21147, "epss_percentile": 0.9547}, "CVE-2020-1304": {"epss_score": 0.12134, "epss_percentile": 0.9358}, "CVE-2020-1305": {"epss_score": 0.13831, "epss_percentile": 0.94072}, "CVE-2020-1306": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-1307": {"epss_score": 0.12398, "epss_percentile": 0.93659}, "CVE-2020-1308": {"epss_score": 0.00637, "epss_percentile": 0.69878}, "CVE-2020-1309": {"epss_score": 0.15841, "epss_percentile": 0.94517}, "CVE-2020-1310": {"epss_score": 0.00589, "epss_percentile": 0.68519}, "CVE-2020-1311": {"epss_score": 0.15675, "epss_percentile": 0.94483}, "CVE-2020-1312": {"epss_score": 0.00668, "epss_percentile": 0.70741}, "CVE-2020-1313": {"epss_score": 0.84643, "epss_percentile": 0.99299}, "CVE-2020-1314": {"epss_score": 0.15675, "epss_percentile": 0.94483}, "CVE-2020-1315": {"epss_score": 0.05496, "epss_percentile": 0.89933}, "CVE-2020-1316": {"epss_score": 0.00549, "epss_percentile": 0.67302}, "CVE-2020-1317": {"epss_score": 0.1501, "epss_percentile": 0.94341}, "CVE-2020-1318": {"epss_score": 0.01048, "epss_percentile": 0.7705}, "CVE-2020-1319": {"epss_score": 0.12207, "epss_percentile": 0.93602}, "CVE-2020-1320": {"epss_score": 0.00792, "epss_percentile": 0.73415}, "CVE-2020-1321": {"epss_score": 0.39264, "epss_percentile": 0.9715}, "CVE-2020-1322": {"epss_score": 0.25134, "epss_percentile": 0.95989}, "CVE-2020-1323": {"epss_score": 0.01645, "epss_percentile": 0.81525}, "CVE-2020-1324": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-1325": {"epss_score": 0.01556, "epss_percentile": 0.81016}, "CVE-2020-1326": {"epss_score": 0.00529, "epss_percentile": 0.66597}, "CVE-2020-1327": {"epss_score": 0.00606, "epss_percentile": 0.68997}, "CVE-2020-1329": {"epss_score": 0.08134, "epss_percentile": 0.91896}, "CVE-2020-1330": {"epss_score": 0.00881, "epss_percentile": 0.74871}, "CVE-2020-1331": {"epss_score": 0.0038, "epss_percentile": 0.58959}, "CVE-2020-1332": {"epss_score": 0.10675, "epss_percentile": 0.93066}, "CVE-2020-1333": {"epss_score": 0.0041, "epss_percentile": 0.60799}, "CVE-2020-1334": {"epss_score": 0.00243, "epss_percentile": 0.47421}, "CVE-2020-1335": {"epss_score": 0.10675, "epss_percentile": 0.93066}, "CVE-2020-1336": {"epss_score": 0.00285, "epss_percentile": 0.51655}, "CVE-2020-1337": {"epss_score": 0.53643, "epss_percentile": 0.97887}, "CVE-2020-1338": {"epss_score": 0.10675, "epss_percentile": 0.93066}, "CVE-2020-1339": {"epss_score": 0.141, "epss_percentile": 0.94132}, "CVE-2020-1340": {"epss_score": 0.00399, "epss_percentile": 0.60102}, "CVE-2020-1342": {"epss_score": 0.24813, "epss_percentile": 0.95957}, "CVE-2020-1343": {"epss_score": 0.03617, "epss_percentile": 0.87437}, "CVE-2020-1344": {"epss_score": 0.0037, "epss_percentile": 0.58301}, "CVE-2020-1345": {"epss_score": 0.00523, "epss_percentile": 0.66285}, "CVE-2020-1346": {"epss_score": 0.00262, "epss_percentile": 0.49335}, "CVE-2020-1347": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-1348": {"epss_score": 0.24232, "epss_percentile": 0.95894}, "CVE-2020-1349": {"epss_score": 0.25973, "epss_percentile": 0.96097}, "CVE-2020-1350": {"epss_score": 0.93808, "epss_percentile": 0.9985}, "CVE-2020-1351": {"epss_score": 0.00275, "epss_percentile": 0.50666}, "CVE-2020-1352": {"epss_score": 0.00353, "epss_percentile": 0.57165}, "CVE-2020-1353": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1354": {"epss_score": 0.00573, "epss_percentile": 0.68063}, "CVE-2020-1355": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2020-1356": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1357": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1358": {"epss_score": 0.00869, "epss_percentile": 0.74687}, "CVE-2020-1359": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1360": {"epss_score": 0.00262, "epss_percentile": 0.49335}, "CVE-2020-1361": {"epss_score": 0.00965, "epss_percentile": 0.76039}, "CVE-2020-1362": {"epss_score": 0.12863, "epss_percentile": 0.93804}, "CVE-2020-1363": {"epss_score": 0.00353, "epss_percentile": 0.57165}, "CVE-2020-1364": {"epss_score": 0.00229, "epss_percentile": 0.45617}, "CVE-2020-1365": {"epss_score": 0.00573, "epss_percentile": 0.68063}, "CVE-2020-1366": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1367": {"epss_score": 0.00479, "epss_percentile": 0.64423}, "CVE-2020-1368": {"epss_score": 0.00243, "epss_percentile": 0.47421}, "CVE-2020-1369": {"epss_score": 0.0037, "epss_percentile": 0.58301}, "CVE-2020-1370": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-1371": {"epss_score": 0.00332, "epss_percentile": 0.55564}, "CVE-2020-1372": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1373": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1374": {"epss_score": 0.13201, "epss_percentile": 0.939}, "CVE-2020-1375": {"epss_score": 0.02025, "epss_percentile": 0.83312}, "CVE-2020-1376": {"epss_score": 0.00399, "epss_percentile": 0.60104}, "CVE-2020-1377": {"epss_score": 0.00206, "epss_percentile": 0.42937}, "CVE-2020-1378": {"epss_score": 0.02876, "epss_percentile": 0.85882}, "CVE-2020-1379": {"epss_score": 0.25276, "epss_percentile": 0.96008}, "CVE-2020-1380": {"epss_score": 0.91733, "epss_percentile": 0.99664}, "CVE-2020-1381": {"epss_score": 0.01, "epss_percentile": 0.76489}, "CVE-2020-1382": {"epss_score": 0.00383, "epss_percentile": 0.59097}, "CVE-2020-1383": {"epss_score": 0.00694, "epss_percentile": 0.71353}, "CVE-2020-1384": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1385": {"epss_score": 0.00243, "epss_percentile": 0.47421}, "CVE-2020-1386": {"epss_score": 0.00479, "epss_percentile": 0.64423}, "CVE-2020-1387": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-1388": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-1389": {"epss_score": 0.00407, "epss_percentile": 0.60584}, "CVE-2020-1390": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1391": {"epss_score": 0.00881, "epss_percentile": 0.74871}, "CVE-2020-1392": {"epss_score": 0.00278, "epss_percentile": 0.50919}, "CVE-2020-1393": {"epss_score": 0.00285, "epss_percentile": 0.51655}, "CVE-2020-1394": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-1395": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1396": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1397": {"epss_score": 0.29795, "epss_percentile": 0.96476}, "CVE-2020-1398": {"epss_score": 0.0021, "epss_percentile": 0.43484}, "CVE-2020-1399": {"epss_score": 0.00243, "epss_percentile": 0.47421}, "CVE-2020-1400": {"epss_score": 0.26662, "epss_percentile": 0.96165}, "CVE-2020-1401": {"epss_score": 0.42055, "epss_percentile": 0.97309}, "CVE-2020-1402": {"epss_score": 0.00323, "epss_percentile": 0.54878}, "CVE-2020-1403": {"epss_score": 0.09339, "epss_percentile": 0.92507}, "CVE-2020-1404": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-1405": {"epss_score": 0.00361, "epss_percentile": 0.57699}, "CVE-2020-1406": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2020-1407": {"epss_score": 0.42055, "epss_percentile": 0.97309}, "CVE-2020-1408": {"epss_score": 0.15866, "epss_percentile": 0.94523}, "CVE-2020-1409": {"epss_score": 0.42055, "epss_percentile": 0.97309}, "CVE-2020-1410": {"epss_score": 0.42055, "epss_percentile": 0.97309}, "CVE-2020-1411": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2020-1412": {"epss_score": 0.22583, "epss_percentile": 0.95653}, "CVE-2020-1413": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-1414": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-1415": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-1416": {"epss_score": 0.10088, "epss_percentile": 0.92845}, "CVE-2020-1417": {"epss_score": 0.00848, "epss_percentile": 0.74363}, "CVE-2020-1418": {"epss_score": 0.00522, "epss_percentile": 0.66281}, "CVE-2020-1419": {"epss_score": 0.00644, "epss_percentile": 0.70085}, "CVE-2020-1420": {"epss_score": 0.00472, "epss_percentile": 0.64068}, "CVE-2020-1421": {"epss_score": 0.35043, "epss_percentile": 0.96885}, "CVE-2020-1422": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-1423": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1424": {"epss_score": 0.00274, "epss_percentile": 0.50504}, "CVE-2020-1425": {"epss_score": 0.23002, "epss_percentile": 0.95715}, "CVE-2020-1426": {"epss_score": 0.00479, "epss_percentile": 0.64423}, "CVE-2020-1427": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1428": {"epss_score": 0.00262, "epss_percentile": 0.49335}, "CVE-2020-1429": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2020-1430": {"epss_score": 0.00573, "epss_percentile": 0.68063}, "CVE-2020-1431": {"epss_score": 0.00324, "epss_percentile": 0.54959}, "CVE-2020-1432": {"epss_score": 0.09585, "epss_percentile": 0.92609}, "CVE-2020-1433": {"epss_score": 0.25321, "epss_percentile": 0.96013}, "CVE-2020-1434": {"epss_score": 0.00239, "epss_percentile": 0.46899}, "CVE-2020-1435": {"epss_score": 0.35773, "epss_percentile": 0.96933}, "CVE-2020-1436": {"epss_score": 0.10709, "epss_percentile": 0.93079}, "CVE-2020-1437": {"epss_score": 0.00262, "epss_percentile": 0.49335}, "CVE-2020-1438": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1439": {"epss_score": 0.31155, "epss_percentile": 0.96599}, "CVE-2020-1440": {"epss_score": 0.01772, "epss_percentile": 0.82203}, "CVE-2020-1442": {"epss_score": 0.00607, "epss_percentile": 0.69031}, "CVE-2020-1443": {"epss_score": 0.01523, "epss_percentile": 0.80841}, "CVE-2020-1444": {"epss_score": 0.15321, "epss_percentile": 0.94408}, "CVE-2020-1445": {"epss_score": 0.27512, "epss_percentile": 0.96254}, "CVE-2020-1446": {"epss_score": 0.3992, "epss_percentile": 0.97187}, "CVE-2020-1447": {"epss_score": 0.45953, "epss_percentile": 0.97511}, "CVE-2020-1448": {"epss_score": 0.39264, "epss_percentile": 0.9715}, "CVE-2020-1449": {"epss_score": 0.14767, "epss_percentile": 0.94279}, "CVE-2020-1450": {"epss_score": 0.00904, "epss_percentile": 0.75218}, "CVE-2020-1451": {"epss_score": 0.00904, "epss_percentile": 0.75218}, "CVE-2020-1452": {"epss_score": 0.01444, "epss_percentile": 0.80318}, "CVE-2020-1453": {"epss_score": 0.01068, "epss_percentile": 0.7724}, "CVE-2020-1454": {"epss_score": 0.00607, "epss_percentile": 0.69051}, "CVE-2020-1455": {"epss_score": 0.00813, "epss_percentile": 0.73765}, "CVE-2020-1456": {"epss_score": 0.00766, "epss_percentile": 0.72933}, "CVE-2020-1457": {"epss_score": 0.1433, "epss_percentile": 0.94188}, "CVE-2020-1458": {"epss_score": 0.08868, "epss_percentile": 0.92294}, "CVE-2020-1459": {"epss_score": 0.07152, "epss_percentile": 0.91287}, "CVE-2020-1460": {"epss_score": 0.04724, "epss_percentile": 0.89061}, "CVE-2020-1461": {"epss_score": 0.00217, "epss_percentile": 0.44245}, "CVE-2020-1462": {"epss_score": 0.09695, "epss_percentile": 0.92666}, "CVE-2020-1463": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1464": {"epss_score": 0.11843, "epss_percentile": 0.93493}, "CVE-2020-1465": {"epss_score": 0.00327, "epss_percentile": 0.55152}, "CVE-2020-1466": {"epss_score": 0.09788, "epss_percentile": 0.92702}, "CVE-2020-1467": {"epss_score": 0.01685, "epss_percentile": 0.81748}, "CVE-2020-1468": {"epss_score": 0.21495, "epss_percentile": 0.95525}, "CVE-2020-1469": {"epss_score": 0.06186, "epss_percentile": 0.90542}, "CVE-2020-1470": {"epss_score": 0.00593, "epss_percentile": 0.68651}, "CVE-2020-1471": {"epss_score": 0.00778, "epss_percentile": 0.73136}, "CVE-2020-1472": {"epss_score": 0.9438, "epss_percentile": 0.99966}, "CVE-2020-1473": {"epss_score": 0.06014, "epss_percentile": 0.90411}, "CVE-2020-1474": {"epss_score": 0.00781, "epss_percentile": 0.73181}, "CVE-2020-1475": {"epss_score": 0.00579, "epss_percentile": 0.6823}, "CVE-2020-1476": {"epss_score": 0.00982, "epss_percentile": 0.76291}, "CVE-2020-1477": {"epss_score": 0.0484, "epss_percentile": 0.89198}, "CVE-2020-1478": {"epss_score": 0.15021, "epss_percentile": 0.94345}, "CVE-2020-1479": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2020-1480": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-1481": {"epss_score": 0.40495, "epss_percentile": 0.97221}, "CVE-2020-1482": {"epss_score": 0.00428, "epss_percentile": 0.6192}, "CVE-2020-1483": {"epss_score": 0.19035, "epss_percentile": 0.95117}, "CVE-2020-1484": {"epss_score": 0.00399, "epss_percentile": 0.60099}, "CVE-2020-1485": {"epss_score": 0.0038, "epss_percentile": 0.58927}, "CVE-2020-1486": {"epss_score": 0.00376, "epss_percentile": 0.58651}, "CVE-2020-1487": {"epss_score": 0.21467, "epss_percentile": 0.95522}, "CVE-2020-1488": {"epss_score": 0.00213, "epss_percentile": 0.43841}, "CVE-2020-1489": {"epss_score": 0.00268, "epss_percentile": 0.50076}, "CVE-2020-1490": {"epss_score": 0.0037, "epss_percentile": 0.58298}, "CVE-2020-1491": {"epss_score": 0.00399, "epss_percentile": 0.60104}, "CVE-2020-1492": {"epss_score": 0.15, "epss_percentile": 0.94339}, "CVE-2020-1493": {"epss_score": 0.30325, "epss_percentile": 0.96528}, "CVE-2020-1494": {"epss_score": 0.15375, "epss_percentile": 0.94419}, "CVE-2020-1495": {"epss_score": 0.1773, "epss_percentile": 0.94897}, "CVE-2020-1496": {"epss_score": 0.15375, "epss_percentile": 0.94419}, "CVE-2020-1497": {"epss_score": 0.28459, "epss_percentile": 0.96359}, "CVE-2020-1498": {"epss_score": 0.15901, "epss_percentile": 0.94527}, "CVE-2020-1499": {"epss_score": 0.01556, "epss_percentile": 0.81016}, "CVE-2020-1500": {"epss_score": 0.02079, "epss_percentile": 0.83527}, "CVE-2020-1501": {"epss_score": 0.02079, "epss_percentile": 0.83527}, "CVE-2020-1502": {"epss_score": 0.25017, "epss_percentile": 0.95979}, "CVE-2020-1503": {"epss_score": 0.27295, "epss_percentile": 0.96232}, "CVE-2020-1504": {"epss_score": 0.15792, "epss_percentile": 0.9451}, "CVE-2020-1505": {"epss_score": 0.0158, "epss_percentile": 0.81134}, "CVE-2020-1506": {"epss_score": 0.03357, "epss_percentile": 0.86976}, "CVE-2020-1507": {"epss_score": 0.00949, "epss_percentile": 0.75839}, "CVE-2020-1508": {"epss_score": 0.01605, "epss_percentile": 0.81287}, "CVE-2020-1509": {"epss_score": 0.0772, "epss_percentile": 0.91643}, "CVE-2020-1510": {"epss_score": 0.14562, "epss_percentile": 0.94241}, "CVE-2020-1511": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2020-1512": {"epss_score": 0.19008, "epss_percentile": 0.9511}, "CVE-2020-1513": {"epss_score": 0.00268, "epss_percentile": 0.50076}, "CVE-2020-1514": {"epss_score": 0.00408, "epss_percentile": 0.60681}, "CVE-2020-1515": {"epss_score": 0.00268, "epss_percentile": 0.50076}, "CVE-2020-1516": {"epss_score": 0.00268, "epss_percentile": 0.50076}, "CVE-2020-1517": {"epss_score": 0.00541, "epss_percentile": 0.67048}, "CVE-2020-1518": {"epss_score": 0.00408, "epss_percentile": 0.60686}, "CVE-2020-1519": {"epss_score": 0.00408, "epss_percentile": 0.60686}, "CVE-2020-1520": {"epss_score": 0.00376, "epss_percentile": 0.58651}, "CVE-2020-1521": {"epss_score": 0.00378, "epss_percentile": 0.58819}, "CVE-2020-1522": {"epss_score": 0.00377, "epss_percentile": 0.58701}, "CVE-2020-1523": {"epss_score": 0.01389, "epss_percentile": 0.7993}, "CVE-2020-1524": {"epss_score": 0.00285, "epss_percentile": 0.51655}, "CVE-2020-1525": {"epss_score": 0.08623, "epss_percentile": 0.92158}, "CVE-2020-1526": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1527": {"epss_score": 0.00386, "epss_percentile": 0.59263}, "CVE-2020-1528": {"epss_score": 0.11602, "epss_percentile": 0.93417}, "CVE-2020-1529": {"epss_score": 0.00376, "epss_percentile": 0.58651}, "CVE-2020-1530": {"epss_score": 0.00382, "epss_percentile": 0.59073}, "CVE-2020-1531": {"epss_score": 0.11937, "epss_percentile": 0.93522}, "CVE-2020-1532": {"epss_score": 0.0037, "epss_percentile": 0.58301}, "CVE-2020-1533": {"epss_score": 0.00285, "epss_percentile": 0.51655}, "CVE-2020-1534": {"epss_score": 0.15021, "epss_percentile": 0.94345}, "CVE-2020-1535": {"epss_score": 0.00268, "epss_percentile": 0.50076}, "CVE-2020-1536": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1537": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1538": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1539": {"epss_score": 0.00268, "epss_percentile": 0.50076}, "CVE-2020-1540": {"epss_score": 0.00268, "epss_percentile": 0.50076}, "CVE-2020-1541": {"epss_score": 0.00268, "epss_percentile": 0.50076}, "CVE-2020-1542": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1543": {"epss_score": 0.00355, "epss_percentile": 0.57322}, "CVE-2020-1544": {"epss_score": 0.00268, "epss_percentile": 0.50076}, "CVE-2020-1545": {"epss_score": 0.00408, "epss_percentile": 0.60686}, "CVE-2020-1546": {"epss_score": 0.00408, "epss_percentile": 0.60686}, "CVE-2020-1547": {"epss_score": 0.00262, "epss_percentile": 0.49339}, "CVE-2020-1548": {"epss_score": 0.00455, "epss_percentile": 0.63292}, "CVE-2020-1549": {"epss_score": 0.00372, "epss_percentile": 0.58432}, "CVE-2020-1550": {"epss_score": 0.00418, "epss_percentile": 0.6129}, "CVE-2020-1551": {"epss_score": 0.00541, "epss_percentile": 0.67048}, "CVE-2020-1552": {"epss_score": 0.00792, "epss_percentile": 0.7341}, "CVE-2020-1553": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2020-1554": {"epss_score": 0.15675, "epss_percentile": 0.94483}, "CVE-2020-1555": {"epss_score": 0.1447, "epss_percentile": 0.94219}, "CVE-2020-1556": {"epss_score": 0.00278, "epss_percentile": 0.50919}, "CVE-2020-1557": {"epss_score": 0.13882, "epss_percentile": 0.94083}, "CVE-2020-1558": {"epss_score": 0.14496, "epss_percentile": 0.94224}, "CVE-2020-1559": {"epss_score": 0.00399, "epss_percentile": 0.60104}, "CVE-2020-1560": {"epss_score": 0.01236, "epss_percentile": 0.78772}, "CVE-2020-1561": {"epss_score": 0.15375, "epss_percentile": 0.94419}, "CVE-2020-1562": {"epss_score": 0.14496, "epss_percentile": 0.94224}, "CVE-2020-1563": {"epss_score": 0.1249, "epss_percentile": 0.9369}, "CVE-2020-1564": {"epss_score": 0.11304, "epss_percentile": 0.933}, "CVE-2020-1565": {"epss_score": 0.03365, "epss_percentile": 0.87}, "CVE-2020-1566": {"epss_score": 0.01794, "epss_percentile": 0.82293}, "CVE-2020-1567": {"epss_score": 0.02503, "epss_percentile": 0.84928}, "CVE-2020-1568": {"epss_score": 0.04169, "epss_percentile": 0.88345}, "CVE-2020-1569": {"epss_score": 0.02386, "epss_percentile": 0.84579}, "CVE-2020-1570": {"epss_score": 0.04546, "epss_percentile": 0.88833}, "CVE-2020-1571": {"epss_score": 0.00608, "epss_percentile": 0.69069}, "CVE-2020-1573": {"epss_score": 0.00818, "epss_percentile": 0.73853}, "CVE-2020-1574": {"epss_score": 0.00945, "epss_percentile": 0.75803}, "CVE-2020-1575": {"epss_score": 0.00408, "epss_percentile": 0.60681}, "CVE-2020-1576": {"epss_score": 0.00125, "epss_percentile": 0.3254}, "CVE-2020-1577": {"epss_score": 0.22151, "epss_percentile": 0.95602}, "CVE-2020-1578": {"epss_score": 0.0035, "epss_percentile": 0.5696}, "CVE-2020-1579": {"epss_score": 0.00401, "epss_percentile": 0.6022}, "CVE-2020-1580": {"epss_score": 0.00537, "epss_percentile": 0.66921}, "CVE-2020-1581": {"epss_score": 0.09677, "epss_percentile": 0.92654}, "CVE-2020-1582": {"epss_score": 0.11602, "epss_percentile": 0.93417}, "CVE-2020-1583": {"epss_score": 0.23013, "epss_percentile": 0.95717}, "CVE-2020-1584": {"epss_score": 0.00544, "epss_percentile": 0.67144}, "CVE-2020-1585": {"epss_score": 0.1665, "epss_percentile": 0.94707}, "CVE-2020-1587": {"epss_score": 0.00401, "epss_percentile": 0.6022}, "CVE-2020-1589": {"epss_score": 0.00384, "epss_percentile": 0.59176}, "CVE-2020-1590": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2020-1591": {"epss_score": 0.00717, "epss_percentile": 0.71871}, "CVE-2020-1592": {"epss_score": 0.00384, "epss_percentile": 0.59163}, "CVE-2020-1593": {"epss_score": 0.01255, "epss_percentile": 0.78926}, "CVE-2020-1594": {"epss_score": 0.10675, "epss_percentile": 0.93066}, "CVE-2020-1595": {"epss_score": 0.0038, "epss_percentile": 0.58949}, "CVE-2020-1596": {"epss_score": 0.00175, "epss_percentile": 0.3937}, "CVE-2020-1597": {"epss_score": 0.08524, "epss_percentile": 0.92102}, "CVE-2020-1598": {"epss_score": 0.01054, "epss_percentile": 0.77109}, "CVE-2020-1599": {"epss_score": 0.04286, "epss_percentile": 0.88494}, "CVE-2020-1600": {"epss_score": 0.00222, "epss_percentile": 0.4473}, "CVE-2020-1601": {"epss_score": 0.00405, "epss_percentile": 0.60504}, "CVE-2020-1602": {"epss_score": 0.0024, "epss_percentile": 0.47214}, "CVE-2020-1603": {"epss_score": 0.00643, "epss_percentile": 0.70047}, "CVE-2020-1604": {"epss_score": 0.00168, "epss_percentile": 0.38438}, "CVE-2020-1605": {"epss_score": 0.00205, "epss_percentile": 0.42748}, "CVE-2020-1606": {"epss_score": 0.00319, "epss_percentile": 0.54471}, "CVE-2020-1607": {"epss_score": 0.00336, "epss_percentile": 0.55942}, "CVE-2020-1608": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2020-1609": {"epss_score": 0.00203, "epss_percentile": 0.42531}, "CVE-2020-1611": {"epss_score": 0.05435, "epss_percentile": 0.8988}, "CVE-2020-1613": {"epss_score": 0.00453, "epss_percentile": 0.63213}, "CVE-2020-1614": {"epss_score": 0.00387, "epss_percentile": 0.59327}, "CVE-2020-1615": {"epss_score": 0.0047, "epss_percentile": 0.63991}, "CVE-2020-1616": {"epss_score": 0.00542, "epss_percentile": 0.67073}, "CVE-2020-1617": {"epss_score": 0.0066, "epss_percentile": 0.70529}, "CVE-2020-1618": {"epss_score": 0.0004, "epss_percentile": 0.11958}, "CVE-2020-1619": {"epss_score": 0.00039, "epss_percentile": 0.11584}, "CVE-2020-1620": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2020-1621": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2020-1622": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2020-1623": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2020-1624": {"epss_score": 0.00119, "epss_percentile": 0.31576}, "CVE-2020-1625": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2020-1626": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2020-1627": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-1628": {"epss_score": 0.00382, "epss_percentile": 0.59056}, "CVE-2020-1629": {"epss_score": 0.00314, "epss_percentile": 0.54111}, "CVE-2020-1630": {"epss_score": 0.0003, "epss_percentile": 0.08053}, "CVE-2020-1631": {"epss_score": 0.05297, "epss_percentile": 0.89704}, "CVE-2020-1632": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2020-1633": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2020-1634": {"epss_score": 0.0054, "epss_percentile": 0.66997}, "CVE-2020-1637": {"epss_score": 0.00186, "epss_percentile": 0.40659}, "CVE-2020-1638": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-1639": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2020-1640": {"epss_score": 0.00448, "epss_percentile": 0.63012}, "CVE-2020-1641": {"epss_score": 0.00063, "epss_percentile": 0.19806}, "CVE-2020-1643": {"epss_score": 0.00139, "epss_percentile": 0.34593}, "CVE-2020-1644": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-1645": {"epss_score": 0.0027, "epss_percentile": 0.50256}, "CVE-2020-1646": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-1647": {"epss_score": 0.01994, "epss_percentile": 0.8319}, "CVE-2020-1648": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-1649": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2020-1650": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-1651": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2020-1652": {"epss_score": 0.0048, "epss_percentile": 0.64469}, "CVE-2020-1653": {"epss_score": 0.00464, "epss_percentile": 0.63714}, "CVE-2020-1654": {"epss_score": 0.02129, "epss_percentile": 0.83704}, "CVE-2020-1655": {"epss_score": 0.00328, "epss_percentile": 0.55297}, "CVE-2020-1656": {"epss_score": 0.00447, "epss_percentile": 0.62967}, "CVE-2020-1657": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-1660": {"epss_score": 0.00287, "epss_percentile": 0.51816}, "CVE-2020-1661": {"epss_score": 0.00268, "epss_percentile": 0.50041}, "CVE-2020-1662": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-1664": {"epss_score": 0.00048, "epss_percentile": 0.15136}, "CVE-2020-1665": {"epss_score": 0.00233, "epss_percentile": 0.46029}, "CVE-2020-1666": {"epss_score": 0.00042, "epss_percentile": 0.12605}, "CVE-2020-1667": {"epss_score": 0.00311, "epss_percentile": 0.53921}, "CVE-2020-1668": {"epss_score": 0.00195, "epss_percentile": 0.41632}, "CVE-2020-1669": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2020-1670": {"epss_score": 0.00212, "epss_percentile": 0.43756}, "CVE-2020-1671": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-1672": {"epss_score": 0.00288, "epss_percentile": 0.51886}, "CVE-2020-1673": {"epss_score": 0.01407, "epss_percentile": 0.8006}, "CVE-2020-1675": {"epss_score": 0.00092, "epss_percentile": 0.26555}, "CVE-2020-1676": {"epss_score": 0.00609, "epss_percentile": 0.69135}, "CVE-2020-1677": {"epss_score": 0.00176, "epss_percentile": 0.39427}, "CVE-2020-1678": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2020-1679": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-1680": {"epss_score": 0.00299, "epss_percentile": 0.52877}, "CVE-2020-1681": {"epss_score": 0.00138, "epss_percentile": 0.34404}, "CVE-2020-1682": {"epss_score": 0.00047, "epss_percentile": 0.14662}, "CVE-2020-1683": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2020-1684": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-1685": {"epss_score": 0.00208, "epss_percentile": 0.43238}, "CVE-2020-1686": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2020-1687": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2020-1688": {"epss_score": 0.00054, "epss_percentile": 0.17342}, "CVE-2020-1689": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2020-1690": {"epss_score": 0.001, "epss_percentile": 0.28543}, "CVE-2020-1691": {"epss_score": 0.00708, "epss_percentile": 0.7168}, "CVE-2020-1692": {"epss_score": 0.00168, "epss_percentile": 0.38455}, "CVE-2020-1693": {"epss_score": 0.07131, "epss_percentile": 0.9127}, "CVE-2020-1694": {"epss_score": 0.00275, "epss_percentile": 0.50683}, "CVE-2020-1695": {"epss_score": 0.00751, "epss_percentile": 0.72638}, "CVE-2020-1696": {"epss_score": 0.00367, "epss_percentile": 0.58113}, "CVE-2020-1697": {"epss_score": 0.00283, "epss_percentile": 0.51352}, "CVE-2020-1698": {"epss_score": 0.00051, "epss_percentile": 0.16006}, "CVE-2020-1699": {"epss_score": 0.01822, "epss_percentile": 0.82412}, "CVE-2020-1700": {"epss_score": 0.00326, "epss_percentile": 0.55087}, "CVE-2020-1701": {"epss_score": 0.00141, "epss_percentile": 0.34845}, "CVE-2020-1702": {"epss_score": 0.00169, "epss_percentile": 0.38625}, "CVE-2020-1704": {"epss_score": 0.0011, "epss_percentile": 0.30079}, "CVE-2020-1705": {"epss_score": 0.00041, "epss_percentile": 0.12413}, "CVE-2020-1706": {"epss_score": 0.00094, "epss_percentile": 0.26973}, "CVE-2020-1707": {"epss_score": 0.00041, "epss_percentile": 0.12413}, "CVE-2020-1708": {"epss_score": 0.00108, "epss_percentile": 0.29763}, "CVE-2020-1709": {"epss_score": 0.00041, "epss_percentile": 0.12413}, "CVE-2020-1710": {"epss_score": 0.00242, "epss_percentile": 0.47373}, "CVE-2020-1711": {"epss_score": 0.00493, "epss_percentile": 0.65035}, "CVE-2020-1712": {"epss_score": 0.00104, "epss_percentile": 0.29101}, "CVE-2020-1714": {"epss_score": 0.02152, "epss_percentile": 0.8379}, "CVE-2020-1716": {"epss_score": 0.0063, "epss_percentile": 0.69706}, "CVE-2020-1717": {"epss_score": 0.00183, "epss_percentile": 0.40298}, "CVE-2020-1718": {"epss_score": 0.00367, "epss_percentile": 0.58105}, "CVE-2020-1719": {"epss_score": 0.00122, "epss_percentile": 0.32141}, "CVE-2020-1720": {"epss_score": 0.00198, "epss_percentile": 0.42082}, "CVE-2020-1721": {"epss_score": 0.01637, "epss_percentile": 0.81481}, "CVE-2020-1722": {"epss_score": 0.00368, "epss_percentile": 0.58193}, "CVE-2020-1723": {"epss_score": 0.00155, "epss_percentile": 0.36799}, "CVE-2020-1724": {"epss_score": 0.00136, "epss_percentile": 0.34134}, "CVE-2020-1725": {"epss_score": 0.00115, "epss_percentile": 0.3095}, "CVE-2020-1726": {"epss_score": 0.00163, "epss_percentile": 0.37774}, "CVE-2020-1727": {"epss_score": 0.00184, "epss_percentile": 0.40399}, "CVE-2020-1728": {"epss_score": 0.00134, "epss_percentile": 0.33761}, "CVE-2020-1729": {"epss_score": 0.00038, "epss_percentile": 0.11166}, "CVE-2020-1730": {"epss_score": 0.00076, "epss_percentile": 0.23164}, "CVE-2020-1731": {"epss_score": 0.00389, "epss_percentile": 0.59453}, "CVE-2020-1732": {"epss_score": 0.00132, "epss_percentile": 0.33567}, "CVE-2020-1733": {"epss_score": 0.00027, "epss_percentile": 0.06806}, "CVE-2020-1734": {"epss_score": 0.00131, "epss_percentile": 0.33462}, "CVE-2020-1735": {"epss_score": 0.00143, "epss_percentile": 0.35188}, "CVE-2020-1736": {"epss_score": 0.0004, "epss_percentile": 0.121}, "CVE-2020-1737": {"epss_score": 0.00119, "epss_percentile": 0.31593}, "CVE-2020-1738": {"epss_score": 0.00139, "epss_percentile": 0.34569}, "CVE-2020-1739": {"epss_score": 0.00041, "epss_percentile": 0.12445}, "CVE-2020-1740": {"epss_score": 0.00027, "epss_percentile": 0.06741}, "CVE-2020-1741": {"epss_score": 0.00235, "epss_percentile": 0.46334}, "CVE-2020-1742": {"epss_score": 0.0004, "epss_percentile": 0.1193}, "CVE-2020-1744": {"epss_score": 0.00333, "epss_percentile": 0.55675}, "CVE-2020-1745": {"epss_score": 0.00636, "epss_percentile": 0.69831}, "CVE-2020-1746": {"epss_score": 0.00056, "epss_percentile": 0.17772}, "CVE-2020-1747": {"epss_score": 0.0307, "epss_percentile": 0.86345}, "CVE-2020-1748": {"epss_score": 0.0031, "epss_percentile": 0.53751}, "CVE-2020-1749": {"epss_score": 0.00155, "epss_percentile": 0.36848}, "CVE-2020-1750": {"epss_score": 0.00258, "epss_percentile": 0.48983}, "CVE-2020-1751": {"epss_score": 0.00244, "epss_percentile": 0.47616}, "CVE-2020-1752": {"epss_score": 0.00134, "epss_percentile": 0.33776}, "CVE-2020-1753": {"epss_score": 0.00039, "epss_percentile": 0.11534}, "CVE-2020-1754": {"epss_score": 0.00198, "epss_percentile": 0.42086}, "CVE-2020-1755": {"epss_score": 0.0013, "epss_percentile": 0.33325}, "CVE-2020-1756": {"epss_score": 0.00743, "epss_percentile": 0.72476}, "CVE-2020-1757": {"epss_score": 0.00463, "epss_percentile": 0.637}, "CVE-2020-1758": {"epss_score": 0.00254, "epss_percentile": 0.48575}, "CVE-2020-1759": {"epss_score": 0.00412, "epss_percentile": 0.6092}, "CVE-2020-1760": {"epss_score": 0.00353, "epss_percentile": 0.572}, "CVE-2020-1761": {"epss_score": 0.00157, "epss_percentile": 0.3711}, "CVE-2020-1762": {"epss_score": 0.01304, "epss_percentile": 0.79314}, "CVE-2020-1763": {"epss_score": 0.04755, "epss_percentile": 0.8911}, "CVE-2020-1764": {"epss_score": 0.06053, "epss_percentile": 0.90437}, "CVE-2020-1765": {"epss_score": 0.0087, "epss_percentile": 0.74696}, "CVE-2020-1766": {"epss_score": 0.00777, "epss_percentile": 0.73108}, "CVE-2020-1767": {"epss_score": 0.00802, "epss_percentile": 0.73594}, "CVE-2020-1768": {"epss_score": 0.00313, "epss_percentile": 0.54023}, "CVE-2020-1769": {"epss_score": 0.00581, "epss_percentile": 0.68262}, "CVE-2020-1770": {"epss_score": 0.00364, "epss_percentile": 0.5792}, "CVE-2020-1771": {"epss_score": 0.0087, "epss_percentile": 0.74705}, "CVE-2020-1772": {"epss_score": 0.00587, "epss_percentile": 0.68464}, "CVE-2020-1773": {"epss_score": 0.00606, "epss_percentile": 0.69013}, "CVE-2020-1774": {"epss_score": 0.0019, "epss_percentile": 0.41059}, "CVE-2020-1775": {"epss_score": 0.00238, "epss_percentile": 0.46741}, "CVE-2020-1776": {"epss_score": 0.00305, "epss_percentile": 0.53334}, "CVE-2020-1777": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2020-1778": {"epss_score": 0.00233, "epss_percentile": 0.46046}, "CVE-2020-1779": {"epss_score": 0.00329, "epss_percentile": 0.5532}, "CVE-2020-1785": {"epss_score": 0.00137, "epss_percentile": 0.34255}, "CVE-2020-1786": {"epss_score": 0.00021, "epss_percentile": 0.04777}, "CVE-2020-1787": {"epss_score": 0.00051, "epss_percentile": 0.16323}, "CVE-2020-1788": {"epss_score": 0.00105, "epss_percentile": 0.29325}, "CVE-2020-1789": {"epss_score": 0.00061, "epss_percentile": 0.19302}, "CVE-2020-1790": {"epss_score": 0.00582, "epss_percentile": 0.6829}, "CVE-2020-1791": {"epss_score": 0.00061, "epss_percentile": 0.19505}, "CVE-2020-1792": {"epss_score": 0.00137, "epss_percentile": 0.34255}, "CVE-2020-1793": {"epss_score": 0.00055, "epss_percentile": 0.17369}, "CVE-2020-1794": {"epss_score": 0.00055, "epss_percentile": 0.17369}, "CVE-2020-1795": {"epss_score": 0.00022, "epss_percentile": 0.0519}, "CVE-2020-1796": {"epss_score": 0.00055, "epss_percentile": 0.17532}, "CVE-2020-1797": {"epss_score": 0.00027, "epss_percentile": 0.07001}, "CVE-2020-1798": {"epss_score": 0.00023, "epss_percentile": 0.05633}, "CVE-2020-1799": {"epss_score": 0.00068, "epss_percentile": 0.21227}, "CVE-2020-1800": {"epss_score": 0.00138, "epss_percentile": 0.34404}, "CVE-2020-1801": {"epss_score": 0.00105, "epss_percentile": 0.29325}, "CVE-2020-1802": {"epss_score": 0.00028, "epss_percentile": 0.0734}, "CVE-2020-1803": {"epss_score": 0.00037, "epss_percentile": 0.10633}, "CVE-2020-1804": {"epss_score": 0.00101, "epss_percentile": 0.28695}, "CVE-2020-1805": {"epss_score": 0.00101, "epss_percentile": 0.28695}, "CVE-2020-1806": {"epss_score": 0.00101, "epss_percentile": 0.28695}, "CVE-2020-1807": {"epss_score": 0.00026, "epss_percentile": 0.06535}, "CVE-2020-1808": {"epss_score": 0.00101, "epss_percentile": 0.28695}, "CVE-2020-1809": {"epss_score": 0.0003, "epss_percentile": 0.08028}, "CVE-2020-1810": {"epss_score": 0.00079, "epss_percentile": 0.23963}, "CVE-2020-1811": {"epss_score": 0.00272, "epss_percentile": 0.50375}, "CVE-2020-1812": {"epss_score": 0.00041, "epss_percentile": 0.12231}, "CVE-2020-1813": {"epss_score": 0.00024, "epss_percentile": 0.06022}, "CVE-2020-1814": {"epss_score": 0.00186, "epss_percentile": 0.40691}, "CVE-2020-1815": {"epss_score": 0.00251, "epss_percentile": 0.48296}, "CVE-2020-1816": {"epss_score": 0.00397, "epss_percentile": 0.6002}, "CVE-2020-1817": {"epss_score": 0.00021, "epss_percentile": 0.04887}, "CVE-2020-1818": {"epss_score": 0.00096, "epss_percentile": 0.27284}, "CVE-2020-1819": {"epss_score": 0.00096, "epss_percentile": 0.27284}, "CVE-2020-1820": {"epss_score": 0.00096, "epss_percentile": 0.27284}, "CVE-2020-1821": {"epss_score": 0.00096, "epss_percentile": 0.27284}, "CVE-2020-1822": {"epss_score": 0.00096, "epss_percentile": 0.27284}, "CVE-2020-1823": {"epss_score": 0.00096, "epss_percentile": 0.27284}, "CVE-2020-1824": {"epss_score": 0.00096, "epss_percentile": 0.27284}, "CVE-2020-1825": {"epss_score": 0.00174, "epss_percentile": 0.39177}, "CVE-2020-1826": {"epss_score": 0.00015, "epss_percentile": 0.02586}, "CVE-2020-1827": {"epss_score": 0.00251, "epss_percentile": 0.48296}, "CVE-2020-1828": {"epss_score": 0.00251, "epss_percentile": 0.48296}, "CVE-2020-1829": {"epss_score": 0.00251, "epss_percentile": 0.48296}, "CVE-2020-1830": {"epss_score": 0.00244, "epss_percentile": 0.47615}, "CVE-2020-1831": {"epss_score": 0.00024, "epss_percentile": 0.06005}, "CVE-2020-1832": {"epss_score": 0.00061, "epss_percentile": 0.19437}, "CVE-2020-1833": {"epss_score": 0.00023, "epss_percentile": 0.05454}, "CVE-2020-1834": {"epss_score": 0.00013, "epss_percentile": 0.01567}, "CVE-2020-1835": {"epss_score": 0.00044, "epss_percentile": 0.13665}, "CVE-2020-1836": {"epss_score": 0.00044, "epss_percentile": 0.13665}, "CVE-2020-1837": {"epss_score": 0.0005, "epss_percentile": 0.15778}, "CVE-2020-1838": {"epss_score": 0.00024, "epss_percentile": 0.05791}, "CVE-2020-1839": {"epss_score": 0.00021, "epss_percentile": 0.04893}, "CVE-2020-1840": {"epss_score": 0.00053, "epss_percentile": 0.16941}, "CVE-2020-1841": {"epss_score": 0.00397, "epss_percentile": 0.60041}, "CVE-2020-1842": {"epss_score": 0.00058, "epss_percentile": 0.18466}, "CVE-2020-1843": {"epss_score": 0.00068, "epss_percentile": 0.21237}, "CVE-2020-1844": {"epss_score": 0.00064, "epss_percentile": 0.20363}, "CVE-2020-1845": {"epss_score": 0.00023, "epss_percentile": 0.05519}, "CVE-2020-1847": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2020-1848": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2020-1853": {"epss_score": 0.00227, "epss_percentile": 0.45443}, "CVE-2020-1855": {"epss_score": 0.0006, "epss_percentile": 0.19194}, "CVE-2020-1856": {"epss_score": 0.00187, "epss_percentile": 0.40724}, "CVE-2020-1857": {"epss_score": 0.0006, "epss_percentile": 0.19175}, "CVE-2020-1858": {"epss_score": 0.00218, "epss_percentile": 0.44434}, "CVE-2020-1860": {"epss_score": 0.00108, "epss_percentile": 0.29854}, "CVE-2020-1861": {"epss_score": 0.00058, "epss_percentile": 0.18516}, "CVE-2020-1862": {"epss_score": 0.00058, "epss_percentile": 0.18475}, "CVE-2020-1863": {"epss_score": 0.00453, "epss_percentile": 0.63234}, "CVE-2020-1864": {"epss_score": 0.00378, "epss_percentile": 0.58812}, "CVE-2020-1865": {"epss_score": 0.00044, "epss_percentile": 0.13665}, "CVE-2020-1866": {"epss_score": 0.00041, "epss_percentile": 0.12332}, "CVE-2020-1870": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2020-1871": {"epss_score": 0.00172, "epss_percentile": 0.38972}, "CVE-2020-1872": {"epss_score": 0.00022, "epss_percentile": 0.0519}, "CVE-2020-1873": {"epss_score": 0.0019, "epss_percentile": 0.41062}, "CVE-2020-1874": {"epss_score": 0.00059, "epss_percentile": 0.18725}, "CVE-2020-1875": {"epss_score": 0.00057, "epss_percentile": 0.18174}, "CVE-2020-1876": {"epss_score": 0.00184, "epss_percentile": 0.4045}, "CVE-2020-1877": {"epss_score": 0.00064, "epss_percentile": 0.20402}, "CVE-2020-1878": {"epss_score": 0.00028, "epss_percentile": 0.07503}, "CVE-2020-1879": {"epss_score": 0.00012, "epss_percentile": 0.01251}, "CVE-2020-1880": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2020-1881": {"epss_score": 0.00218, "epss_percentile": 0.44434}, "CVE-2020-1882": {"epss_score": 0.00022, "epss_percentile": 0.0519}, "CVE-2020-1883": {"epss_score": 0.00157, "epss_percentile": 0.37141}, "CVE-2020-1885": {"epss_score": 0.00127, "epss_percentile": 0.3285}, "CVE-2020-1886": {"epss_score": 0.00476, "epss_percentile": 0.64275}, "CVE-2020-1887": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2020-1888": {"epss_score": 0.00609, "epss_percentile": 0.69133}, "CVE-2020-1889": {"epss_score": 0.01044, "epss_percentile": 0.77001}, "CVE-2020-1890": {"epss_score": 0.00752, "epss_percentile": 0.72655}, "CVE-2020-1891": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2020-1892": {"epss_score": 0.00611, "epss_percentile": 0.69199}, "CVE-2020-1893": {"epss_score": 0.00609, "epss_percentile": 0.69133}, "CVE-2020-1894": {"epss_score": 0.00727, "epss_percentile": 0.721}, "CVE-2020-1895": {"epss_score": 0.00473, "epss_percentile": 0.6408}, "CVE-2020-1896": {"epss_score": 0.02546, "epss_percentile": 0.85062}, "CVE-2020-1897": {"epss_score": 0.00591, "epss_percentile": 0.68591}, "CVE-2020-1898": {"epss_score": 0.00835, "epss_percentile": 0.74115}, "CVE-2020-1899": {"epss_score": 0.00361, "epss_percentile": 0.57703}, "CVE-2020-1900": {"epss_score": 0.00806, "epss_percentile": 0.73651}, "CVE-2020-1901": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2020-1902": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2020-1903": {"epss_score": 0.00164, "epss_percentile": 0.3795}, "CVE-2020-1904": {"epss_score": 0.00365, "epss_percentile": 0.57992}, "CVE-2020-1905": {"epss_score": 0.0019, "epss_percentile": 0.41108}, "CVE-2020-1906": {"epss_score": 0.00073, "epss_percentile": 0.22527}, "CVE-2020-1907": {"epss_score": 0.01667, "epss_percentile": 0.81656}, "CVE-2020-1908": {"epss_score": 0.00052, "epss_percentile": 0.16453}, "CVE-2020-1909": {"epss_score": 0.00938, "epss_percentile": 0.75713}, "CVE-2020-1910": {"epss_score": 0.02271, "epss_percentile": 0.84209}, "CVE-2020-1911": {"epss_score": 0.01017, "epss_percentile": 0.76688}, "CVE-2020-1912": {"epss_score": 0.01649, "epss_percentile": 0.81557}, "CVE-2020-1913": {"epss_score": 0.002, "epss_percentile": 0.42241}, "CVE-2020-1914": {"epss_score": 0.00846, "epss_percentile": 0.74336}, "CVE-2020-1915": {"epss_score": 0.01117, "epss_percentile": 0.77722}, "CVE-2020-1916": {"epss_score": 0.00806, "epss_percentile": 0.73651}, "CVE-2020-1917": {"epss_score": 0.00746, "epss_percentile": 0.72539}, "CVE-2020-1918": {"epss_score": 0.0033, "epss_percentile": 0.55462}, "CVE-2020-1919": {"epss_score": 0.00361, "epss_percentile": 0.57703}, "CVE-2020-1920": {"epss_score": 0.00208, "epss_percentile": 0.43284}, "CVE-2020-1921": {"epss_score": 0.00593, "epss_percentile": 0.6865}, "CVE-2020-1925": {"epss_score": 0.01178, "epss_percentile": 0.78284}, "CVE-2020-1926": {"epss_score": 0.00478, "epss_percentile": 0.6441}, "CVE-2020-1927": {"epss_score": 0.11302, "epss_percentile": 0.93298}, "CVE-2020-1928": {"epss_score": 0.00454, "epss_percentile": 0.63242}, "CVE-2020-1929": {"epss_score": 0.004, "epss_percentile": 0.60149}, "CVE-2020-1930": {"epss_score": 0.01382, "epss_percentile": 0.79889}, "CVE-2020-1931": {"epss_score": 0.01095, "epss_percentile": 0.77509}, "CVE-2020-1932": {"epss_score": 0.00234, "epss_percentile": 0.46173}, "CVE-2020-1933": {"epss_score": 0.00638, "epss_percentile": 0.69901}, "CVE-2020-1934": {"epss_score": 0.41871, "epss_percentile": 0.97298}, "CVE-2020-1935": {"epss_score": 0.0101, "epss_percentile": 0.76593}, "CVE-2020-1936": {"epss_score": 0.00885, "epss_percentile": 0.7494}, "CVE-2020-1937": {"epss_score": 0.10074, "epss_percentile": 0.9284}, "CVE-2020-1938": {"epss_score": 0.94469, "epss_percentile": 0.99997}, "CVE-2020-1939": {"epss_score": 0.00872, "epss_percentile": 0.74726}, "CVE-2020-1940": {"epss_score": 0.0069, "epss_percentile": 0.71258}, "CVE-2020-1941": {"epss_score": 0.05301, "epss_percentile": 0.89706}, "CVE-2020-1942": {"epss_score": 0.00165, "epss_percentile": 0.38105}, "CVE-2020-1943": {"epss_score": 0.86811, "epss_percentile": 0.99399}, "CVE-2020-1944": {"epss_score": 0.01208, "epss_percentile": 0.78533}, "CVE-2020-1945": {"epss_score": 0.00021, "epss_percentile": 0.04691}, "CVE-2020-1946": {"epss_score": 0.01495, "epss_percentile": 0.8068}, "CVE-2020-1947": {"epss_score": 0.88982, "epss_percentile": 0.99503}, "CVE-2020-1948": {"epss_score": 0.63597, "epss_percentile": 0.9834}, "CVE-2020-1949": {"epss_score": 0.01831, "epss_percentile": 0.8245}, "CVE-2020-1950": {"epss_score": 0.00251, "epss_percentile": 0.48284}, "CVE-2020-1951": {"epss_score": 0.00301, "epss_percentile": 0.53007}, "CVE-2020-1952": {"epss_score": 0.01653, "epss_percentile": 0.81579}, "CVE-2020-1953": {"epss_score": 0.02732, "epss_percentile": 0.85541}, "CVE-2020-1954": {"epss_score": 0.00112, "epss_percentile": 0.30496}, "CVE-2020-1955": {"epss_score": 0.01868, "epss_percentile": 0.8262}, "CVE-2020-1956": {"epss_score": 0.93559, "epss_percentile": 0.99818}, "CVE-2020-1957": {"epss_score": 0.86102, "epss_percentile": 0.99366}, "CVE-2020-1958": {"epss_score": 0.15565, "epss_percentile": 0.94459}, "CVE-2020-1959": {"epss_score": 0.01649, "epss_percentile": 0.81559}, "CVE-2020-1960": {"epss_score": 0.0009, "epss_percentile": 0.26001}, "CVE-2020-1961": {"epss_score": 0.07128, "epss_percentile": 0.91268}, "CVE-2020-1963": {"epss_score": 0.04667, "epss_percentile": 0.88982}, "CVE-2020-1964": {"epss_score": 0.09859, "epss_percentile": 0.92739}, "CVE-2020-1967": {"epss_score": 0.67307, "epss_percentile": 0.98501}, "CVE-2020-1968": {"epss_score": 0.00844, "epss_percentile": 0.74275}, "CVE-2020-1971": {"epss_score": 0.00348, "epss_percentile": 0.5682}, "CVE-2020-1975": {"epss_score": 0.00384, "epss_percentile": 0.59171}, "CVE-2020-1976": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2020-1977": {"epss_score": 0.00192, "epss_percentile": 0.4137}, "CVE-2020-1978": {"epss_score": 0.00094, "epss_percentile": 0.26777}, "CVE-2020-1979": {"epss_score": 0.00235, "epss_percentile": 0.4631}, "CVE-2020-1980": {"epss_score": 0.0027, "epss_percentile": 0.5021}, "CVE-2020-1981": {"epss_score": 0.00042, "epss_percentile": 0.12477}, "CVE-2020-1982": {"epss_score": 0.00236, "epss_percentile": 0.46391}, "CVE-2020-1983": {"epss_score": 0.00202, "epss_percentile": 0.42405}, "CVE-2020-1984": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2020-1985": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2020-1986": {"epss_score": 0.00119, "epss_percentile": 0.31627}, "CVE-2020-1987": {"epss_score": 0.00046, "epss_percentile": 0.14093}, "CVE-2020-1988": {"epss_score": 0.0013, "epss_percentile": 0.3332}, "CVE-2020-1989": {"epss_score": 0.00109, "epss_percentile": 0.29924}, "CVE-2020-1990": {"epss_score": 0.01381, "epss_percentile": 0.79866}, "CVE-2020-1991": {"epss_score": 0.00036, "epss_percentile": 0.10554}, "CVE-2020-1992": {"epss_score": 0.0205, "epss_percentile": 0.83396}, "CVE-2020-1993": {"epss_score": 0.00207, "epss_percentile": 0.43138}, "CVE-2020-1994": {"epss_score": 0.00056, "epss_percentile": 0.17812}, "CVE-2020-1995": {"epss_score": 0.0032, "epss_percentile": 0.54622}, "CVE-2020-1996": {"epss_score": 0.00701, "epss_percentile": 0.71504}, "CVE-2020-1997": {"epss_score": 0.00275, "epss_percentile": 0.50651}, "CVE-2020-1998": {"epss_score": 0.00216, "epss_percentile": 0.44217}, "CVE-2020-1999": {"epss_score": 0.00217, "epss_percentile": 0.44296}, "CVE-2020-20012": {"epss_score": 0.00126, "epss_percentile": 0.32701}, "CVE-2020-20021": {"epss_score": 0.00068, "epss_percentile": 0.21381}, "CVE-2020-20067": {"epss_score": 0.00808, "epss_percentile": 0.7369}, "CVE-2020-20070": {"epss_score": 0.00315, "epss_percentile": 0.5419}, "CVE-2020-20092": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-20093": {"epss_score": 0.04494, "epss_percentile": 0.88761}, "CVE-2020-20094": {"epss_score": 0.00409, "epss_percentile": 0.60726}, "CVE-2020-20095": {"epss_score": 0.00409, "epss_percentile": 0.60726}, "CVE-2020-20096": {"epss_score": 0.00409, "epss_percentile": 0.60726}, "CVE-2020-20118": {"epss_score": 0.00029, "epss_percentile": 0.07659}, "CVE-2020-20120": {"epss_score": 0.01107, "epss_percentile": 0.77628}, "CVE-2020-20122": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-20124": {"epss_score": 0.03146, "epss_percentile": 0.86495}, "CVE-2020-20125": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-20128": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2020-20129": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-20131": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-20136": {"epss_score": 0.00326, "epss_percentile": 0.55062}, "CVE-2020-20138": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-20139": {"epss_score": 0.0054, "epss_percentile": 0.67024}, "CVE-2020-20140": {"epss_score": 0.0054, "epss_percentile": 0.67024}, "CVE-2020-20141": {"epss_score": 0.0054, "epss_percentile": 0.67024}, "CVE-2020-20142": {"epss_score": 0.0054, "epss_percentile": 0.67024}, "CVE-2020-20178": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-20183": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2020-20184": {"epss_score": 0.06441, "epss_percentile": 0.9076}, "CVE-2020-20189": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-20210": {"epss_score": 0.00808, "epss_percentile": 0.7369}, "CVE-2020-20211": {"epss_score": 0.00222, "epss_percentile": 0.44804}, "CVE-2020-20212": {"epss_score": 0.00989, "epss_percentile": 0.76368}, "CVE-2020-20213": {"epss_score": 0.01047, "epss_percentile": 0.77041}, "CVE-2020-20214": {"epss_score": 0.00252, "epss_percentile": 0.48381}, "CVE-2020-20215": {"epss_score": 0.00854, "epss_percentile": 0.74451}, "CVE-2020-20216": {"epss_score": 0.00857, "epss_percentile": 0.7449}, "CVE-2020-20217": {"epss_score": 0.01943, "epss_percentile": 0.82995}, "CVE-2020-20218": {"epss_score": 0.00876, "epss_percentile": 0.74796}, "CVE-2020-20219": {"epss_score": 0.01107, "epss_percentile": 0.7763}, "CVE-2020-20220": {"epss_score": 0.01047, "epss_percentile": 0.7704}, "CVE-2020-20221": {"epss_score": 0.0111, "epss_percentile": 0.7766}, "CVE-2020-20222": {"epss_score": 0.00787, "epss_percentile": 0.73306}, "CVE-2020-20225": {"epss_score": 0.00248, "epss_percentile": 0.4794}, "CVE-2020-20227": {"epss_score": 0.01083, "epss_percentile": 0.77389}, "CVE-2020-20230": {"epss_score": 0.01215, "epss_percentile": 0.78584}, "CVE-2020-20231": {"epss_score": 0.00731, "epss_percentile": 0.72167}, "CVE-2020-20236": {"epss_score": 0.00809, "epss_percentile": 0.73701}, "CVE-2020-20237": {"epss_score": 0.00758, "epss_percentile": 0.72779}, "CVE-2020-20245": {"epss_score": 0.01047, "epss_percentile": 0.7704}, "CVE-2020-20246": {"epss_score": 0.01047, "epss_percentile": 0.7704}, "CVE-2020-20247": {"epss_score": 0.00646, "epss_percentile": 0.70142}, "CVE-2020-20248": {"epss_score": 0.00876, "epss_percentile": 0.74796}, "CVE-2020-20249": {"epss_score": 0.00311, "epss_percentile": 0.53821}, "CVE-2020-20250": {"epss_score": 0.0136, "epss_percentile": 0.79749}, "CVE-2020-20252": {"epss_score": 0.01013, "epss_percentile": 0.76638}, "CVE-2020-20253": {"epss_score": 0.00839, "epss_percentile": 0.74193}, "CVE-2020-20254": {"epss_score": 0.00839, "epss_percentile": 0.74193}, "CVE-2020-20262": {"epss_score": 0.00347, "epss_percentile": 0.56745}, "CVE-2020-20264": {"epss_score": 0.01561, "epss_percentile": 0.81044}, "CVE-2020-20265": {"epss_score": 0.00403, "epss_percentile": 0.60339}, "CVE-2020-20266": {"epss_score": 0.0114, "epss_percentile": 0.7795}, "CVE-2020-20267": {"epss_score": 0.0101, "epss_percentile": 0.76601}, "CVE-2020-20269": {"epss_score": 0.04329, "epss_percentile": 0.88557}, "CVE-2020-20276": {"epss_score": 0.04601, "epss_percentile": 0.88903}, "CVE-2020-20277": {"epss_score": 0.38913, "epss_percentile": 0.97126}, "CVE-2020-20285": {"epss_score": 0.06066, "epss_percentile": 0.90448}, "CVE-2020-20287": {"epss_score": 0.02994, "epss_percentile": 0.86151}, "CVE-2020-20289": {"epss_score": 0.005, "epss_percentile": 0.653}, "CVE-2020-20290": {"epss_score": 0.00456, "epss_percentile": 0.63343}, "CVE-2020-20294": {"epss_score": 0.01464, "epss_percentile": 0.80448}, "CVE-2020-20295": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-20296": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-20298": {"epss_score": 0.06441, "epss_percentile": 0.9076}, "CVE-2020-20299": {"epss_score": 0.00614, "epss_percentile": 0.69284}, "CVE-2020-20300": {"epss_score": 0.57146, "epss_percentile": 0.9805}, "CVE-2020-20335": {"epss_score": 0.0016, "epss_percentile": 0.37468}, "CVE-2020-20340": {"epss_score": 0.00238, "epss_percentile": 0.46824}, "CVE-2020-20341": {"epss_score": 0.00426, "epss_percentile": 0.61768}, "CVE-2020-20343": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2020-20344": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-20345": {"epss_score": 0.00296, "epss_percentile": 0.52568}, "CVE-2020-20347": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-20348": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-20349": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-20363": {"epss_score": 0.00363, "epss_percentile": 0.57899}, "CVE-2020-20389": {"epss_score": 0.0029, "epss_percentile": 0.5208}, "CVE-2020-20391": {"epss_score": 0.00253, "epss_percentile": 0.48488}, "CVE-2020-20392": {"epss_score": 0.01031, "epss_percentile": 0.76852}, "CVE-2020-20402": {"epss_score": 0.00048, "epss_percentile": 0.14971}, "CVE-2020-20406": {"epss_score": 0.00247, "epss_percentile": 0.47836}, "CVE-2020-20412": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2020-20413": {"epss_score": 0.00584, "epss_percentile": 0.68374}, "CVE-2020-20425": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2020-20426": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2020-20444": {"epss_score": 0.00285, "epss_percentile": 0.51533}, "CVE-2020-20445": {"epss_score": 0.01999, "epss_percentile": 0.83211}, "CVE-2020-20446": {"epss_score": 0.02065, "epss_percentile": 0.83457}, "CVE-2020-20448": {"epss_score": 0.00312, "epss_percentile": 0.53941}, "CVE-2020-20450": {"epss_score": 0.00517, "epss_percentile": 0.66085}, "CVE-2020-20451": {"epss_score": 0.01083, "epss_percentile": 0.77387}, "CVE-2020-20453": {"epss_score": 0.01593, "epss_percentile": 0.81228}, "CVE-2020-20466": {"epss_score": 0.00973, "epss_percentile": 0.76157}, "CVE-2020-20467": {"epss_score": 0.00254, "epss_percentile": 0.48559}, "CVE-2020-20468": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2020-20469": {"epss_score": 0.00256, "epss_percentile": 0.48792}, "CVE-2020-20470": {"epss_score": 0.0026, "epss_percentile": 0.49186}, "CVE-2020-20471": {"epss_score": 0.01579, "epss_percentile": 0.81131}, "CVE-2020-20472": {"epss_score": 0.00255, "epss_percentile": 0.48632}, "CVE-2020-20473": {"epss_score": 0.00256, "epss_percentile": 0.48792}, "CVE-2020-20474": {"epss_score": 0.00232, "epss_percentile": 0.4594}, "CVE-2020-20486": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2020-20490": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-20491": {"epss_score": 0.00564, "epss_percentile": 0.67746}, "CVE-2020-20495": {"epss_score": 0.00592, "epss_percentile": 0.68614}, "CVE-2020-20502": {"epss_score": 0.00352, "epss_percentile": 0.5708}, "CVE-2020-20508": {"epss_score": 0.00268, "epss_percentile": 0.50045}, "CVE-2020-20514": {"epss_score": 0.00153, "epss_percentile": 0.36541}, "CVE-2020-20521": {"epss_score": 0.00269, "epss_percentile": 0.50177}, "CVE-2020-20522": {"epss_score": 0.00269, "epss_percentile": 0.50177}, "CVE-2020-20523": {"epss_score": 0.00274, "epss_percentile": 0.50577}, "CVE-2020-20545": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-20582": {"epss_score": 0.00219, "epss_percentile": 0.44499}, "CVE-2020-20583": {"epss_score": 0.00238, "epss_percentile": 0.46824}, "CVE-2020-20584": {"epss_score": 0.00493, "epss_percentile": 0.65027}, "CVE-2020-20585": {"epss_score": 0.00849, "epss_percentile": 0.7437}, "CVE-2020-20586": {"epss_score": 0.00141, "epss_percentile": 0.34814}, "CVE-2020-20588": {"epss_score": 0.01105, "epss_percentile": 0.7761}, "CVE-2020-20589": {"epss_score": 0.00276, "epss_percentile": 0.50704}, "CVE-2020-20593": {"epss_score": 0.00112, "epss_percentile": 0.30509}, "CVE-2020-20595": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2020-20597": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2020-20598": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2020-20600": {"epss_score": 0.00291, "epss_percentile": 0.52165}, "CVE-2020-20601": {"epss_score": 0.48111, "epss_percentile": 0.97622}, "CVE-2020-20605": {"epss_score": 0.00307, "epss_percentile": 0.53495}, "CVE-2020-20625": {"epss_score": 0.00739, "epss_percentile": 0.72392}, "CVE-2020-20626": {"epss_score": 0.00469, "epss_percentile": 0.63945}, "CVE-2020-20627": {"epss_score": 0.06148, "epss_percentile": 0.9052}, "CVE-2020-20628": {"epss_score": 0.00645, "epss_percentile": 0.70105}, "CVE-2020-20633": {"epss_score": 0.00382, "epss_percentile": 0.59068}, "CVE-2020-20634": {"epss_score": 0.00487, "epss_percentile": 0.64783}, "CVE-2020-20636": {"epss_score": 0.00048, "epss_percentile": 0.1508}, "CVE-2020-20640": {"epss_score": 0.00168, "epss_percentile": 0.38521}, "CVE-2020-20642": {"epss_score": 0.00104, "epss_percentile": 0.29171}, "CVE-2020-20645": {"epss_score": 0.0027, "epss_percentile": 0.5027}, "CVE-2020-20657": {"epss_score": 0.00327, "epss_percentile": 0.55133}, "CVE-2020-20658": {"epss_score": 0.00297, "epss_percentile": 0.52695}, "CVE-2020-20662": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2020-20663": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2020-20664": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2020-20665": {"epss_score": 0.00348, "epss_percentile": 0.56807}, "CVE-2020-20670": {"epss_score": 0.00706, "epss_percentile": 0.71609}, "CVE-2020-20671": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2020-20672": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2020-20675": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-20691": {"epss_score": 0.0023, "epss_percentile": 0.45737}, "CVE-2020-20692": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2020-20693": {"epss_score": 0.00188, "epss_percentile": 0.40898}, "CVE-2020-20695": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-20696": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-20697": {"epss_score": 0.0013, "epss_percentile": 0.33319}, "CVE-2020-20698": {"epss_score": 0.02322, "epss_percentile": 0.84372}, "CVE-2020-20699": {"epss_score": 0.0029, "epss_percentile": 0.5208}, "CVE-2020-20700": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-20701": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-20703": {"epss_score": 0.03254, "epss_percentile": 0.86757}, "CVE-2020-20718": {"epss_score": 0.00605, "epss_percentile": 0.68987}, "CVE-2020-20725": {"epss_score": 0.00171, "epss_percentile": 0.38795}, "CVE-2020-20726": {"epss_score": 0.00613, "epss_percentile": 0.69246}, "CVE-2020-20735": {"epss_score": 0.01278, "epss_percentile": 0.79124}, "CVE-2020-20739": {"epss_score": 0.002, "epss_percentile": 0.42273}, "CVE-2020-20740": {"epss_score": 0.00356, "epss_percentile": 0.5735}, "CVE-2020-20741": {"epss_score": 0.0054, "epss_percentile": 0.67014}, "CVE-2020-20746": {"epss_score": 0.0347, "epss_percentile": 0.87196}, "CVE-2020-20781": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-20796": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2020-20797": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2020-20799": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-20800": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2020-20808": {"epss_score": 0.00228, "epss_percentile": 0.45499}, "CVE-2020-20813": {"epss_score": 0.00235, "epss_percentile": 0.4633}, "CVE-2020-20891": {"epss_score": 0.00329, "epss_percentile": 0.55402}, "CVE-2020-20892": {"epss_score": 0.00339, "epss_percentile": 0.56196}, "CVE-2020-20896": {"epss_score": 0.00237, "epss_percentile": 0.46728}, "CVE-2020-20898": {"epss_score": 0.00503, "epss_percentile": 0.65442}, "CVE-2020-20902": {"epss_score": 0.00393, "epss_percentile": 0.59702}, "CVE-2020-20907": {"epss_score": 0.00883, "epss_percentile": 0.74901}, "CVE-2020-20908": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-20913": {"epss_score": 0.03632, "epss_percentile": 0.87475}, "CVE-2020-20914": {"epss_score": 0.01157, "epss_percentile": 0.78112}, "CVE-2020-20915": {"epss_score": 0.01157, "epss_percentile": 0.78112}, "CVE-2020-20918": {"epss_score": 0.00254, "epss_percentile": 0.48565}, "CVE-2020-20919": {"epss_score": 0.00837, "epss_percentile": 0.74164}, "CVE-2020-20943": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2020-20944": {"epss_score": 0.01109, "epss_percentile": 0.77646}, "CVE-2020-20945": {"epss_score": 0.00146, "epss_percentile": 0.35567}, "CVE-2020-20946": {"epss_score": 0.00354, "epss_percentile": 0.5725}, "CVE-2020-20948": {"epss_score": 0.00515, "epss_percentile": 0.65968}, "CVE-2020-20949": {"epss_score": 0.0054, "epss_percentile": 0.67016}, "CVE-2020-20950": {"epss_score": 0.00467, "epss_percentile": 0.63827}, "CVE-2020-20951": {"epss_score": 0.07171, "epss_percentile": 0.91298}, "CVE-2020-20969": {"epss_score": 0.01202, "epss_percentile": 0.78487}, "CVE-2020-20971": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2020-20975": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-20977": {"epss_score": 0.00236, "epss_percentile": 0.4637}, "CVE-2020-20979": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2020-20981": {"epss_score": 0.00606, "epss_percentile": 0.69021}, "CVE-2020-20982": {"epss_score": 0.31953, "epss_percentile": 0.96662}, "CVE-2020-20988": {"epss_score": 0.02329, "epss_percentile": 0.84397}, "CVE-2020-20989": {"epss_score": 0.00143, "epss_percentile": 0.35181}, "CVE-2020-20990": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-21003": {"epss_score": 0.00269, "epss_percentile": 0.50178}, "CVE-2020-21005": {"epss_score": 0.00208, "epss_percentile": 0.4329}, "CVE-2020-21012": {"epss_score": 0.15187, "epss_percentile": 0.9438}, "CVE-2020-21013": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2020-21014": {"epss_score": 0.00284, "epss_percentile": 0.51471}, "CVE-2020-21016": {"epss_score": 0.10392, "epss_percentile": 0.92972}, "CVE-2020-21038": {"epss_score": 0.00063, "epss_percentile": 0.19874}, "CVE-2020-21041": {"epss_score": 0.01699, "epss_percentile": 0.81824}, "CVE-2020-21046": {"epss_score": 0.00037, "epss_percentile": 0.10885}, "CVE-2020-21047": {"epss_score": 5e-05, "epss_percentile": 0.00196}, "CVE-2020-21048": {"epss_score": 0.00412, "epss_percentile": 0.60953}, "CVE-2020-21049": {"epss_score": 0.00412, "epss_percentile": 0.60953}, "CVE-2020-21050": {"epss_score": 0.00937, "epss_percentile": 0.75694}, "CVE-2020-21052": {"epss_score": 0.00171, "epss_percentile": 0.38795}, "CVE-2020-21053": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-21054": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-21055": {"epss_score": 0.01408, "epss_percentile": 0.80061}, "CVE-2020-21056": {"epss_score": 0.01041, "epss_percentile": 0.76963}, "CVE-2020-21057": {"epss_score": 0.01259, "epss_percentile": 0.78961}, "CVE-2020-21058": {"epss_score": 0.00253, "epss_percentile": 0.48443}, "CVE-2020-21060": {"epss_score": 0.00313, "epss_percentile": 0.54046}, "CVE-2020-21066": {"epss_score": 0.0026, "epss_percentile": 0.49231}, "CVE-2020-21081": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2020-21082": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-21087": {"epss_score": 0.0051, "epss_percentile": 0.658}, "CVE-2020-21088": {"epss_score": 0.00264, "epss_percentile": 0.49696}, "CVE-2020-21101": {"epss_score": 0.0025, "epss_percentile": 0.48139}, "CVE-2020-21119": {"epss_score": 0.00338, "epss_percentile": 0.56132}, "CVE-2020-21120": {"epss_score": 0.00098, "epss_percentile": 0.27823}, "CVE-2020-21121": {"epss_score": 0.00304, "epss_percentile": 0.53267}, "CVE-2020-21122": {"epss_score": 0.00227, "epss_percentile": 0.45406}, "CVE-2020-21124": {"epss_score": 0.00743, "epss_percentile": 0.72474}, "CVE-2020-21125": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2020-21126": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2020-21127": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2020-21130": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-21131": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2020-21132": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2020-21133": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2020-21139": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2020-21141": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2020-21142": {"epss_score": 0.00275, "epss_percentile": 0.50654}, "CVE-2020-21146": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2020-21147": {"epss_score": 0.00224, "epss_percentile": 0.45005}, "CVE-2020-21152": {"epss_score": 0.00074, "epss_percentile": 0.22722}, "CVE-2020-21161": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2020-21174": {"epss_score": 0.01479, "epss_percentile": 0.80559}, "CVE-2020-21176": {"epss_score": 0.00527, "epss_percentile": 0.66468}, "CVE-2020-21179": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2020-21180": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2020-21219": {"epss_score": 0.00617, "epss_percentile": 0.69351}, "CVE-2020-21224": {"epss_score": 0.9214, "epss_percentile": 0.99693}, "CVE-2020-21228": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2020-21236": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2020-21237": {"epss_score": 0.00405, "epss_percentile": 0.60482}, "CVE-2020-21238": {"epss_score": 0.00339, "epss_percentile": 0.56187}, "CVE-2020-21244": {"epss_score": 0.00524, "epss_percentile": 0.66338}, "CVE-2020-21246": {"epss_score": 0.00171, "epss_percentile": 0.389}, "CVE-2020-21250": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2020-21252": {"epss_score": 0.00631, "epss_percentile": 0.69719}, "CVE-2020-21266": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2020-21268": {"epss_score": 0.00171, "epss_percentile": 0.38795}, "CVE-2020-21316": {"epss_score": 0.00632, "epss_percentile": 0.69738}, "CVE-2020-21321": {"epss_score": 0.00141, "epss_percentile": 0.34841}, "CVE-2020-21322": {"epss_score": 0.00932, "epss_percentile": 0.75626}, "CVE-2020-21325": {"epss_score": 0.01094, "epss_percentile": 0.77496}, "CVE-2020-21333": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-21342": {"epss_score": 0.00136, "epss_percentile": 0.3416}, "CVE-2020-21345": {"epss_score": 0.00223, "epss_percentile": 0.44892}, "CVE-2020-21353": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-21356": {"epss_score": 0.00194, "epss_percentile": 0.41594}, "CVE-2020-21357": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-21358": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2020-21359": {"epss_score": 0.0111, "epss_percentile": 0.77661}, "CVE-2020-21362": {"epss_score": 0.00236, "epss_percentile": 0.4637}, "CVE-2020-21363": {"epss_score": 0.00371, "epss_percentile": 0.58354}, "CVE-2020-21365": {"epss_score": 0.00457, "epss_percentile": 0.63377}, "CVE-2020-21366": {"epss_score": 0.0006, "epss_percentile": 0.18985}, "CVE-2020-21377": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2020-21378": {"epss_score": 0.0841, "epss_percentile": 0.92036}, "CVE-2020-21386": {"epss_score": 0.00159, "epss_percentile": 0.37325}, "CVE-2020-21387": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2020-21394": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2020-21400": {"epss_score": 0.00764, "epss_percentile": 0.72908}, "CVE-2020-21405": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2020-21406": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2020-21426": {"epss_score": 0.00523, "epss_percentile": 0.66309}, "CVE-2020-21427": {"epss_score": 0.00847, "epss_percentile": 0.74353}, "CVE-2020-21428": {"epss_score": 0.00061, "epss_percentile": 0.19474}, "CVE-2020-21431": {"epss_score": 0.00319, "epss_percentile": 0.5455}, "CVE-2020-21434": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-21452": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-21468": {"epss_score": 0.00497, "epss_percentile": 0.65195}, "CVE-2020-21469": {"epss_score": 0.00024, "epss_percentile": 0.05769}, "CVE-2020-21474": {"epss_score": 0.01094, "epss_percentile": 0.77487}, "CVE-2020-21480": {"epss_score": 0.00993, "epss_percentile": 0.76418}, "CVE-2020-21481": {"epss_score": 0.00993, "epss_percentile": 0.76418}, "CVE-2020-21482": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-21483": {"epss_score": 0.00993, "epss_percentile": 0.76418}, "CVE-2020-21485": {"epss_score": 0.00068, "epss_percentile": 0.21218}, "CVE-2020-21486": {"epss_score": 0.00041, "epss_percentile": 0.1233}, "CVE-2020-21487": {"epss_score": 0.00703, "epss_percentile": 0.71546}, "CVE-2020-21489": {"epss_score": 0.01175, "epss_percentile": 0.78265}, "CVE-2020-21490": {"epss_score": 0.00023, "epss_percentile": 0.05466}, "CVE-2020-21493": {"epss_score": 0.00194, "epss_percentile": 0.41594}, "CVE-2020-21494": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2020-21495": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2020-21496": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2020-21503": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-21504": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-21505": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-21506": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-21514": {"epss_score": 0.0014, "epss_percentile": 0.34688}, "CVE-2020-21516": {"epss_score": 0.00411, "epss_percentile": 0.60885}, "CVE-2020-21517": {"epss_score": 0.00264, "epss_percentile": 0.4971}, "CVE-2020-21522": {"epss_score": 0.00587, "epss_percentile": 0.68465}, "CVE-2020-21523": {"epss_score": 0.00837, "epss_percentile": 0.74151}, "CVE-2020-21524": {"epss_score": 0.00287, "epss_percentile": 0.51807}, "CVE-2020-21525": {"epss_score": 0.0117, "epss_percentile": 0.78209}, "CVE-2020-21526": {"epss_score": 0.01283, "epss_percentile": 0.79158}, "CVE-2020-21527": {"epss_score": 0.00509, "epss_percentile": 0.65734}, "CVE-2020-21528": {"epss_score": 0.00368, "epss_percentile": 0.5819}, "CVE-2020-21529": {"epss_score": 0.00181, "epss_percentile": 0.40052}, "CVE-2020-21530": {"epss_score": 0.00094, "epss_percentile": 0.26961}, "CVE-2020-21531": {"epss_score": 0.00119, "epss_percentile": 0.31589}, "CVE-2020-21532": {"epss_score": 0.00119, "epss_percentile": 0.31589}, "CVE-2020-21533": {"epss_score": 0.00105, "epss_percentile": 0.2937}, "CVE-2020-21534": {"epss_score": 0.00105, "epss_percentile": 0.2937}, "CVE-2020-21535": {"epss_score": 0.00113, "epss_percentile": 0.30653}, "CVE-2020-21547": {"epss_score": 0.00381, "epss_percentile": 0.58975}, "CVE-2020-21548": {"epss_score": 0.00381, "epss_percentile": 0.58975}, "CVE-2020-21554": {"epss_score": 0.00363, "epss_percentile": 0.57895}, "CVE-2020-21564": {"epss_score": 0.03726, "epss_percentile": 0.87632}, "CVE-2020-21572": {"epss_score": 0.00327, "epss_percentile": 0.55133}, "CVE-2020-21573": {"epss_score": 0.0015, "epss_percentile": 0.36057}, "CVE-2020-21574": {"epss_score": 0.00327, "epss_percentile": 0.55133}, "CVE-2020-21583": {"epss_score": 0.00033, "epss_percentile": 0.09372}, "CVE-2020-21585": {"epss_score": 0.12995, "epss_percentile": 0.93838}, "CVE-2020-21588": {"epss_score": 0.00051, "epss_percentile": 0.16036}, "CVE-2020-21590": {"epss_score": 0.00126, "epss_percentile": 0.32663}, "CVE-2020-21594": {"epss_score": 0.00142, "epss_percentile": 0.35035}, "CVE-2020-21595": {"epss_score": 0.00132, "epss_percentile": 0.33589}, "CVE-2020-21596": {"epss_score": 0.00269, "epss_percentile": 0.50119}, "CVE-2020-21597": {"epss_score": 0.00269, "epss_percentile": 0.50119}, "CVE-2020-21598": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-21599": {"epss_score": 0.00181, "epss_percentile": 0.40016}, "CVE-2020-21600": {"epss_score": 0.00175, "epss_percentile": 0.39356}, "CVE-2020-21601": {"epss_score": 0.00132, "epss_percentile": 0.33589}, "CVE-2020-21602": {"epss_score": 0.00175, "epss_percentile": 0.39356}, "CVE-2020-21603": {"epss_score": 0.00132, "epss_percentile": 0.33589}, "CVE-2020-21604": {"epss_score": 0.00132, "epss_percentile": 0.33589}, "CVE-2020-21605": {"epss_score": 0.00127, "epss_percentile": 0.32815}, "CVE-2020-21606": {"epss_score": 0.00132, "epss_percentile": 0.33589}, "CVE-2020-21627": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-21639": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-21641": {"epss_score": 0.04582, "epss_percentile": 0.88879}, "CVE-2020-21642": {"epss_score": 0.07111, "epss_percentile": 0.91259}, "CVE-2020-21643": {"epss_score": 0.00071, "epss_percentile": 0.22082}, "CVE-2020-21648": {"epss_score": 0.00356, "epss_percentile": 0.57389}, "CVE-2020-21649": {"epss_score": 0.00219, "epss_percentile": 0.44534}, "CVE-2020-21650": {"epss_score": 0.03674, "epss_percentile": 0.87549}, "CVE-2020-21651": {"epss_score": 0.03517, "epss_percentile": 0.87277}, "CVE-2020-21652": {"epss_score": 0.03282, "epss_percentile": 0.86818}, "CVE-2020-21653": {"epss_score": 0.00267, "epss_percentile": 0.49964}, "CVE-2020-21654": {"epss_score": 0.00378, "epss_percentile": 0.58785}, "CVE-2020-21656": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-21658": {"epss_score": 0.00117, "epss_percentile": 0.31237}, "CVE-2020-21662": {"epss_score": 0.00398, "epss_percentile": 0.60063}, "CVE-2020-21665": {"epss_score": 0.00436, "epss_percentile": 0.62485}, "CVE-2020-21667": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2020-21674": {"epss_score": 0.01655, "epss_percentile": 0.81589}, "CVE-2020-21675": {"epss_score": 0.00109, "epss_percentile": 0.3004}, "CVE-2020-21676": {"epss_score": 0.0012, "epss_percentile": 0.31731}, "CVE-2020-21677": {"epss_score": 0.00278, "epss_percentile": 0.50886}, "CVE-2020-21678": {"epss_score": 0.00322, "epss_percentile": 0.54745}, "CVE-2020-21679": {"epss_score": 0.00116, "epss_percentile": 0.31126}, "CVE-2020-21680": {"epss_score": 0.00169, "epss_percentile": 0.38556}, "CVE-2020-21681": {"epss_score": 0.00322, "epss_percentile": 0.54745}, "CVE-2020-21682": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2020-21683": {"epss_score": 0.00289, "epss_percentile": 0.52049}, "CVE-2020-21684": {"epss_score": 0.00322, "epss_percentile": 0.54745}, "CVE-2020-21685": {"epss_score": 0.00344, "epss_percentile": 0.56475}, "CVE-2020-21686": {"epss_score": 0.00175, "epss_percentile": 0.39349}, "CVE-2020-21687": {"epss_score": 0.00478, "epss_percentile": 0.64373}, "CVE-2020-21688": {"epss_score": 0.00262, "epss_percentile": 0.49332}, "CVE-2020-21697": {"epss_score": 0.00182, "epss_percentile": 0.40199}, "CVE-2020-21699": {"epss_score": 0.00232, "epss_percentile": 0.45876}, "CVE-2020-21710": {"epss_score": 0.00287, "epss_percentile": 0.51842}, "CVE-2020-21722": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2020-21723": {"epss_score": 0.00164, "epss_percentile": 0.37897}, "CVE-2020-21724": {"epss_score": 0.00044, "epss_percentile": 0.13502}, "CVE-2020-21725": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-21726": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-21729": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-21731": {"epss_score": 0.0045, "epss_percentile": 0.631}, "CVE-2020-21732": {"epss_score": 0.0045, "epss_percentile": 0.631}, "CVE-2020-21733": {"epss_score": 0.00433, "epss_percentile": 0.62197}, "CVE-2020-21783": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-21784": {"epss_score": 0.00592, "epss_percentile": 0.68609}, "CVE-2020-21785": {"epss_score": 0.05626, "epss_percentile": 0.90064}, "CVE-2020-21786": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2020-21787": {"epss_score": 0.00398, "epss_percentile": 0.60072}, "CVE-2020-21788": {"epss_score": 0.00141, "epss_percentile": 0.3487}, "CVE-2020-21806": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2020-21808": {"epss_score": 0.00571, "epss_percentile": 0.67973}, "CVE-2020-21809": {"epss_score": 0.00586, "epss_percentile": 0.68452}, "CVE-2020-21813": {"epss_score": 0.00306, "epss_percentile": 0.534}, "CVE-2020-21814": {"epss_score": 0.00385, "epss_percentile": 0.592}, "CVE-2020-21815": {"epss_score": 0.00239, "epss_percentile": 0.46886}, "CVE-2020-21816": {"epss_score": 0.00385, "epss_percentile": 0.592}, "CVE-2020-21817": {"epss_score": 0.00239, "epss_percentile": 0.46886}, "CVE-2020-21818": {"epss_score": 0.00385, "epss_percentile": 0.592}, "CVE-2020-21819": {"epss_score": 0.00385, "epss_percentile": 0.592}, "CVE-2020-21827": {"epss_score": 0.00279, "epss_percentile": 0.50956}, "CVE-2020-21830": {"epss_score": 0.00352, "epss_percentile": 0.57112}, "CVE-2020-21831": {"epss_score": 0.00401, "epss_percentile": 0.60211}, "CVE-2020-21832": {"epss_score": 0.00385, "epss_percentile": 0.592}, "CVE-2020-21833": {"epss_score": 0.00502, "epss_percentile": 0.65413}, "CVE-2020-21834": {"epss_score": 0.00261, "epss_percentile": 0.49296}, "CVE-2020-21835": {"epss_score": 0.00261, "epss_percentile": 0.49296}, "CVE-2020-21836": {"epss_score": 0.00352, "epss_percentile": 0.57112}, "CVE-2020-21838": {"epss_score": 0.0046, "epss_percentile": 0.63501}, "CVE-2020-21839": {"epss_score": 0.00383, "epss_percentile": 0.59084}, "CVE-2020-21840": {"epss_score": 0.00502, "epss_percentile": 0.65413}, "CVE-2020-21841": {"epss_score": 0.00497, "epss_percentile": 0.65183}, "CVE-2020-21842": {"epss_score": 0.00352, "epss_percentile": 0.57112}, "CVE-2020-21843": {"epss_score": 0.00385, "epss_percentile": 0.592}, "CVE-2020-21844": {"epss_score": 0.00591, "epss_percentile": 0.68595}, "CVE-2020-21845": {"epss_score": 0.0042, "epss_percentile": 0.61415}, "CVE-2020-21854": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2020-21861": {"epss_score": 0.00077, "epss_percentile": 0.2347}, "CVE-2020-21862": {"epss_score": 0.00184, "epss_percentile": 0.4044}, "CVE-2020-21865": {"epss_score": 0.02136, "epss_percentile": 0.8373}, "CVE-2020-21881": {"epss_score": 0.00046, "epss_percentile": 0.14109}, "CVE-2020-21883": {"epss_score": 0.112, "epss_percentile": 0.93262}, "CVE-2020-21884": {"epss_score": 0.00678, "epss_percentile": 0.71}, "CVE-2020-21890": {"epss_score": 0.01228, "epss_percentile": 0.78705}, "CVE-2020-21896": {"epss_score": 0.00209, "epss_percentile": 0.43403}, "CVE-2020-21913": {"epss_score": 0.001, "epss_percentile": 0.28519}, "CVE-2020-21929": {"epss_score": 0.00298, "epss_percentile": 0.5279}, "CVE-2020-21930": {"epss_score": 0.00298, "epss_percentile": 0.5279}, "CVE-2020-21932": {"epss_score": 0.00192, "epss_percentile": 0.4137}, "CVE-2020-21933": {"epss_score": 0.00285, "epss_percentile": 0.51538}, "CVE-2020-21934": {"epss_score": 0.00307, "epss_percentile": 0.53505}, "CVE-2020-21935": {"epss_score": 0.0334, "epss_percentile": 0.86941}, "CVE-2020-21936": {"epss_score": 0.00223, "epss_percentile": 0.44886}, "CVE-2020-21937": {"epss_score": 0.08071, "epss_percentile": 0.91867}, "CVE-2020-21967": {"epss_score": 0.00169, "epss_percentile": 0.38617}, "CVE-2020-21976": {"epss_score": 0.00831, "epss_percentile": 0.74041}, "CVE-2020-21987": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2020-21989": {"epss_score": 0.00169, "epss_percentile": 0.3854}, "CVE-2020-21990": {"epss_score": 0.01308, "epss_percentile": 0.79348}, "CVE-2020-21991": {"epss_score": 0.05284, "epss_percentile": 0.89692}, "CVE-2020-21992": {"epss_score": 0.03746, "epss_percentile": 0.87663}, "CVE-2020-21993": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-21994": {"epss_score": 0.04651, "epss_percentile": 0.88964}, "CVE-2020-21995": {"epss_score": 0.00656, "epss_percentile": 0.70438}, "CVE-2020-21996": {"epss_score": 0.05907, "epss_percentile": 0.90313}, "CVE-2020-21997": {"epss_score": 0.01224, "epss_percentile": 0.78678}, "CVE-2020-21998": {"epss_score": 0.01964, "epss_percentile": 0.83075}, "CVE-2020-21999": {"epss_score": 0.20286, "epss_percentile": 0.95314}, "CVE-2020-22000": {"epss_score": 0.0117, "epss_percentile": 0.78205}, "CVE-2020-22001": {"epss_score": 0.01868, "epss_percentile": 0.82621}, "CVE-2020-22002": {"epss_score": 0.00744, "epss_percentile": 0.72504}, "CVE-2020-22007": {"epss_score": 0.00226, "epss_percentile": 0.45284}, "CVE-2020-22015": {"epss_score": 0.0038, "epss_percentile": 0.58958}, "CVE-2020-22016": {"epss_score": 0.00982, "epss_percentile": 0.76292}, "CVE-2020-22017": {"epss_score": 0.00693, "epss_percentile": 0.71323}, "CVE-2020-22019": {"epss_score": 0.008, "epss_percentile": 0.73548}, "CVE-2020-22020": {"epss_score": 0.02331, "epss_percentile": 0.84404}, "CVE-2020-22021": {"epss_score": 0.00868, "epss_percentile": 0.74678}, "CVE-2020-22022": {"epss_score": 0.00988, "epss_percentile": 0.76351}, "CVE-2020-22023": {"epss_score": 0.00969, "epss_percentile": 0.76099}, "CVE-2020-22024": {"epss_score": 0.00247, "epss_percentile": 0.47843}, "CVE-2020-22025": {"epss_score": 0.00824, "epss_percentile": 0.73942}, "CVE-2020-22026": {"epss_score": 0.01354, "epss_percentile": 0.79702}, "CVE-2020-22027": {"epss_score": 0.00636, "epss_percentile": 0.69874}, "CVE-2020-22028": {"epss_score": 0.01391, "epss_percentile": 0.79951}, "CVE-2020-22029": {"epss_score": 0.00693, "epss_percentile": 0.71323}, "CVE-2020-22030": {"epss_score": 0.00452, "epss_percentile": 0.63164}, "CVE-2020-22031": {"epss_score": 0.01329, "epss_percentile": 0.79506}, "CVE-2020-22032": {"epss_score": 0.00824, "epss_percentile": 0.73942}, "CVE-2020-22033": {"epss_score": 0.00732, "epss_percentile": 0.72191}, "CVE-2020-22034": {"epss_score": 0.00693, "epss_percentile": 0.71323}, "CVE-2020-22035": {"epss_score": 0.00531, "epss_percentile": 0.6666}, "CVE-2020-22036": {"epss_score": 0.00964, "epss_percentile": 0.76036}, "CVE-2020-22037": {"epss_score": 0.00578, "epss_percentile": 0.68189}, "CVE-2020-22038": {"epss_score": 0.00193, "epss_percentile": 0.41432}, "CVE-2020-22039": {"epss_score": 0.00193, "epss_percentile": 0.41432}, "CVE-2020-22040": {"epss_score": 0.00209, "epss_percentile": 0.43371}, "CVE-2020-22041": {"epss_score": 0.00818, "epss_percentile": 0.73861}, "CVE-2020-22042": {"epss_score": 0.00787, "epss_percentile": 0.73314}, "CVE-2020-22043": {"epss_score": 0.00209, "epss_percentile": 0.43371}, "CVE-2020-22044": {"epss_score": 0.01033, "epss_percentile": 0.76871}, "CVE-2020-22046": {"epss_score": 0.00609, "epss_percentile": 0.69125}, "CVE-2020-22048": {"epss_score": 0.00876, "epss_percentile": 0.74788}, "CVE-2020-22049": {"epss_score": 0.01553, "epss_percentile": 0.80996}, "CVE-2020-22051": {"epss_score": 0.00209, "epss_percentile": 0.43371}, "CVE-2020-22054": {"epss_score": 0.01553, "epss_percentile": 0.80996}, "CVE-2020-22056": {"epss_score": 0.00437, "epss_percentile": 0.62531}, "CVE-2020-22057": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-22061": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2020-22079": {"epss_score": 0.06573, "epss_percentile": 0.90856}, "CVE-2020-22083": {"epss_score": 0.04696, "epss_percentile": 0.8902}, "CVE-2020-22120": {"epss_score": 0.0301, "epss_percentile": 0.86195}, "CVE-2020-22122": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2020-22124": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2020-22148": {"epss_score": 0.00435, "epss_percentile": 0.62375}, "CVE-2020-22150": {"epss_score": 0.00422, "epss_percentile": 0.61554}, "CVE-2020-22151": {"epss_score": 0.0481, "epss_percentile": 0.89165}, "CVE-2020-22152": {"epss_score": 0.00431, "epss_percentile": 0.62091}, "CVE-2020-22153": {"epss_score": 0.05303, "epss_percentile": 0.89708}, "CVE-2020-22158": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-22159": {"epss_score": 0.00132, "epss_percentile": 0.33599}, "CVE-2020-22164": {"epss_score": 0.0146, "epss_percentile": 0.80417}, "CVE-2020-22165": {"epss_score": 0.23655, "epss_percentile": 0.95799}, "CVE-2020-22166": {"epss_score": 0.0146, "epss_percentile": 0.80417}, "CVE-2020-22167": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-22168": {"epss_score": 0.01196, "epss_percentile": 0.7844}, "CVE-2020-22169": {"epss_score": 0.0146, "epss_percentile": 0.80417}, "CVE-2020-22170": {"epss_score": 0.0147, "epss_percentile": 0.80495}, "CVE-2020-22171": {"epss_score": 0.0147, "epss_percentile": 0.80495}, "CVE-2020-22172": {"epss_score": 0.0147, "epss_percentile": 0.80495}, "CVE-2020-22173": {"epss_score": 0.0147, "epss_percentile": 0.80495}, "CVE-2020-22174": {"epss_score": 0.0147, "epss_percentile": 0.80495}, "CVE-2020-22175": {"epss_score": 0.0147, "epss_percentile": 0.80495}, "CVE-2020-22176": {"epss_score": 0.00955, "epss_percentile": 0.75919}, "CVE-2020-22181": {"epss_score": 0.00833, "epss_percentile": 0.74078}, "CVE-2020-22198": {"epss_score": 0.0086, "epss_percentile": 0.74527}, "CVE-2020-22199": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-22200": {"epss_score": 0.00237, "epss_percentile": 0.46731}, "CVE-2020-22201": {"epss_score": 0.00373, "epss_percentile": 0.58508}, "CVE-2020-22203": {"epss_score": 0.00286, "epss_percentile": 0.51719}, "CVE-2020-22204": {"epss_score": 0.00508, "epss_percentile": 0.65682}, "CVE-2020-22205": {"epss_score": 0.00508, "epss_percentile": 0.65682}, "CVE-2020-22206": {"epss_score": 0.00508, "epss_percentile": 0.65682}, "CVE-2020-22208": {"epss_score": 0.40354, "epss_percentile": 0.97214}, "CVE-2020-22209": {"epss_score": 0.45915, "epss_percentile": 0.97507}, "CVE-2020-22210": {"epss_score": 0.45915, "epss_percentile": 0.97507}, "CVE-2020-22211": {"epss_score": 0.37126, "epss_percentile": 0.97021}, "CVE-2020-22212": {"epss_score": 0.00508, "epss_percentile": 0.65682}, "CVE-2020-22217": {"epss_score": 0.00115, "epss_percentile": 0.30943}, "CVE-2020-22218": {"epss_score": 0.00084, "epss_percentile": 0.24984}, "CVE-2020-22219": {"epss_score": 0.0038, "epss_percentile": 0.58941}, "CVE-2020-22222": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-22223": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-22224": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-22225": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-22226": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-22249": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2020-22251": {"epss_score": 0.00257, "epss_percentile": 0.48879}, "CVE-2020-22253": {"epss_score": 0.00619, "epss_percentile": 0.69433}, "CVE-2020-22273": {"epss_score": 0.00117, "epss_percentile": 0.31326}, "CVE-2020-22274": {"epss_score": 0.00613, "epss_percentile": 0.69255}, "CVE-2020-22275": {"epss_score": 0.01048, "epss_percentile": 0.77056}, "CVE-2020-22276": {"epss_score": 0.01209, "epss_percentile": 0.78543}, "CVE-2020-22277": {"epss_score": 0.01097, "epss_percentile": 0.77526}, "CVE-2020-22278": {"epss_score": 0.00409, "epss_percentile": 0.60731}, "CVE-2020-22283": {"epss_score": 0.00374, "epss_percentile": 0.58535}, "CVE-2020-22284": {"epss_score": 0.00401, "epss_percentile": 0.60248}, "CVE-2020-22312": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-22327": {"epss_score": 0.0034, "epss_percentile": 0.56222}, "CVE-2020-22330": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2020-22334": {"epss_score": 0.00056, "epss_percentile": 0.17818}, "CVE-2020-22336": {"epss_score": 0.00182, "epss_percentile": 0.40152}, "CVE-2020-22345": {"epss_score": 0.20167, "epss_percentile": 0.95296}, "CVE-2020-22352": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2020-22390": {"epss_score": 0.00789, "epss_percentile": 0.73351}, "CVE-2020-22392": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2020-22394": {"epss_score": 0.00196, "epss_percentile": 0.41731}, "CVE-2020-22402": {"epss_score": 0.00093, "epss_percentile": 0.26639}, "CVE-2020-22403": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2020-22421": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2020-22425": {"epss_score": 0.02745, "epss_percentile": 0.85569}, "CVE-2020-22427": {"epss_score": 0.39851, "epss_percentile": 0.97183}, "CVE-2020-22428": {"epss_score": 0.01049, "epss_percentile": 0.77062}, "CVE-2020-22429": {"epss_score": 0.00028, "epss_percentile": 0.07245}, "CVE-2020-22452": {"epss_score": 0.01564, "epss_percentile": 0.81062}, "CVE-2020-22453": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-22474": {"epss_score": 0.00281, "epss_percentile": 0.51127}, "CVE-2020-22475": {"epss_score": 0.00089, "epss_percentile": 0.25874}, "CVE-2020-22481": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2020-22524": {"epss_score": 0.00151, "epss_percentile": 0.36222}, "CVE-2020-22533": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2020-22535": {"epss_score": 0.00241, "epss_percentile": 0.47255}, "CVE-2020-22539": {"epss_score": 0.00133, "epss_percentile": 0.33687}, "CVE-2020-22540": {"epss_score": 0.00202, "epss_percentile": 0.42413}, "CVE-2020-22550": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2020-22552": {"epss_score": 0.00194, "epss_percentile": 0.41582}, "CVE-2020-22570": {"epss_score": 0.02068, "epss_percentile": 0.83466}, "CVE-2020-22597": {"epss_score": 0.00868, "epss_percentile": 0.74675}, "CVE-2020-22607": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2020-22608": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2020-22609": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-22612": {"epss_score": 0.00088, "epss_percentile": 0.25667}, "CVE-2020-22617": {"epss_score": 0.00566, "epss_percentile": 0.67826}, "CVE-2020-22623": {"epss_score": 0.00786, "epss_percentile": 0.73289}, "CVE-2020-22628": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2020-22643": {"epss_score": 0.02117, "epss_percentile": 0.83665}, "CVE-2020-22647": {"epss_score": 0.00091, "epss_percentile": 0.26224}, "CVE-2020-22650": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-22653": {"epss_score": 0.00141, "epss_percentile": 0.34831}, "CVE-2020-22654": {"epss_score": 0.00103, "epss_percentile": 0.29074}, "CVE-2020-22655": {"epss_score": 0.00136, "epss_percentile": 0.3414}, "CVE-2020-22656": {"epss_score": 0.00197, "epss_percentile": 0.41825}, "CVE-2020-22657": {"epss_score": 0.00124, "epss_percentile": 0.32394}, "CVE-2020-22658": {"epss_score": 0.00233, "epss_percentile": 0.45985}, "CVE-2020-22659": {"epss_score": 0.00079, "epss_percentile": 0.23802}, "CVE-2020-22660": {"epss_score": 0.00096, "epss_percentile": 0.2744}, "CVE-2020-22661": {"epss_score": 0.00113, "epss_percentile": 0.30641}, "CVE-2020-22662": {"epss_score": 0.00887, "epss_percentile": 0.74971}, "CVE-2020-22669": {"epss_score": 0.00059, "epss_percentile": 0.18828}, "CVE-2020-22673": {"epss_score": 0.00106, "epss_percentile": 0.29527}, "CVE-2020-22674": {"epss_score": 0.00239, "epss_percentile": 0.46898}, "CVE-2020-22675": {"epss_score": 0.00123, "epss_percentile": 0.32324}, "CVE-2020-22677": {"epss_score": 0.00133, "epss_percentile": 0.33745}, "CVE-2020-22678": {"epss_score": 0.00123, "epss_percentile": 0.32324}, "CVE-2020-22679": {"epss_score": 0.00239, "epss_percentile": 0.46898}, "CVE-2020-22719": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-22721": {"epss_score": 0.00066, "epss_percentile": 0.20895}, "CVE-2020-22722": {"epss_score": 0.00044, "epss_percentile": 0.13414}, "CVE-2020-22723": {"epss_score": 0.00304, "epss_percentile": 0.53273}, "CVE-2020-22724": {"epss_score": 0.14438, "epss_percentile": 0.94212}, "CVE-2020-22732": {"epss_score": 0.00321, "epss_percentile": 0.54683}, "CVE-2020-22741": {"epss_score": 0.00133, "epss_percentile": 0.33689}, "CVE-2020-22755": {"epss_score": 0.0009, "epss_percentile": 0.26164}, "CVE-2020-22761": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2020-22765": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2020-22781": {"epss_score": 0.00368, "epss_percentile": 0.58188}, "CVE-2020-22782": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-22783": {"epss_score": 0.00112, "epss_percentile": 0.30578}, "CVE-2020-22784": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-22785": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-22789": {"epss_score": 0.00575, "epss_percentile": 0.68105}, "CVE-2020-22790": {"epss_score": 0.00519, "epss_percentile": 0.66144}, "CVE-2020-22807": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-22808": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-22809": {"epss_score": 0.00065, "epss_percentile": 0.20561}, "CVE-2020-22818": {"epss_score": 0.00264, "epss_percentile": 0.49703}, "CVE-2020-22819": {"epss_score": 0.00264, "epss_percentile": 0.49703}, "CVE-2020-22820": {"epss_score": 0.00264, "epss_percentile": 0.49703}, "CVE-2020-22839": {"epss_score": 0.01038, "epss_percentile": 0.76938}, "CVE-2020-22840": {"epss_score": 0.35339, "epss_percentile": 0.96901}, "CVE-2020-22841": {"epss_score": 0.00445, "epss_percentile": 0.62877}, "CVE-2020-22842": {"epss_score": 0.00374, "epss_percentile": 0.58536}, "CVE-2020-22844": {"epss_score": 0.01156, "epss_percentile": 0.78099}, "CVE-2020-22845": {"epss_score": 0.01242, "epss_percentile": 0.78822}, "CVE-2020-22848": {"epss_score": 0.06472, "epss_percentile": 0.90779}, "CVE-2020-22864": {"epss_score": 0.00358, "epss_percentile": 0.57505}, "CVE-2020-22873": {"epss_score": 0.0251, "epss_percentile": 0.84948}, "CVE-2020-22874": {"epss_score": 0.0307, "epss_percentile": 0.86346}, "CVE-2020-22875": {"epss_score": 0.0307, "epss_percentile": 0.86346}, "CVE-2020-22876": {"epss_score": 0.00839, "epss_percentile": 0.74192}, "CVE-2020-22882": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-22884": {"epss_score": 0.03106, "epss_percentile": 0.86419}, "CVE-2020-22885": {"epss_score": 0.00618, "epss_percentile": 0.69377}, "CVE-2020-22886": {"epss_score": 0.00681, "epss_percentile": 0.71058}, "CVE-2020-22907": {"epss_score": 0.00839, "epss_percentile": 0.74192}, "CVE-2020-22916": {"epss_score": 0.00024, "epss_percentile": 0.05844}, "CVE-2020-22937": {"epss_score": 0.03365, "epss_percentile": 0.87002}, "CVE-2020-22983": {"epss_score": 0.02198, "epss_percentile": 0.83964}, "CVE-2020-22984": {"epss_score": 0.01873, "epss_percentile": 0.82644}, "CVE-2020-22985": {"epss_score": 0.01873, "epss_percentile": 0.82644}, "CVE-2020-22986": {"epss_score": 0.01905, "epss_percentile": 0.82795}, "CVE-2020-22987": {"epss_score": 0.01873, "epss_percentile": 0.82644}, "CVE-2020-23014": {"epss_score": 0.00573, "epss_percentile": 0.6805}, "CVE-2020-23015": {"epss_score": 0.07905, "epss_percentile": 0.91755}, "CVE-2020-23026": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2020-23036": {"epss_score": 0.00269, "epss_percentile": 0.50104}, "CVE-2020-23037": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-23038": {"epss_score": 0.00462, "epss_percentile": 0.63579}, "CVE-2020-23039": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-23040": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2020-23041": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-23042": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-23043": {"epss_score": 0.00932, "epss_percentile": 0.75631}, "CVE-2020-23044": {"epss_score": 0.00241, "epss_percentile": 0.47292}, "CVE-2020-23045": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2020-23046": {"epss_score": 0.00247, "epss_percentile": 0.47862}, "CVE-2020-23047": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-23048": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-23049": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-23050": {"epss_score": 0.00396, "epss_percentile": 0.59897}, "CVE-2020-23051": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-23052": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-23054": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-23055": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-23058": {"epss_score": 0.00079, "epss_percentile": 0.23891}, "CVE-2020-23060": {"epss_score": 0.0005, "epss_percentile": 0.15939}, "CVE-2020-23061": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2020-23065": {"epss_score": 0.00505, "epss_percentile": 0.65597}, "CVE-2020-23069": {"epss_score": 0.0139, "epss_percentile": 0.79935}, "CVE-2020-23079": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2020-23083": {"epss_score": 0.10612, "epss_percentile": 0.93047}, "CVE-2020-23109": {"epss_score": 0.00244, "epss_percentile": 0.47624}, "CVE-2020-23126": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2020-23127": {"epss_score": 0.00187, "epss_percentile": 0.40748}, "CVE-2020-23128": {"epss_score": 0.00189, "epss_percentile": 0.40967}, "CVE-2020-23136": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2020-23138": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-23139": {"epss_score": 0.00053, "epss_percentile": 0.16731}, "CVE-2020-23140": {"epss_score": 0.00271, "epss_percentile": 0.50341}, "CVE-2020-23148": {"epss_score": 0.00149, "epss_percentile": 0.35949}, "CVE-2020-23149": {"epss_score": 0.00139, "epss_percentile": 0.34539}, "CVE-2020-23150": {"epss_score": 0.00139, "epss_percentile": 0.34539}, "CVE-2020-23151": {"epss_score": 0.53056, "epss_percentile": 0.97854}, "CVE-2020-23160": {"epss_score": 0.23265, "epss_percentile": 0.95759}, "CVE-2020-23161": {"epss_score": 0.00626, "epss_percentile": 0.69609}, "CVE-2020-23162": {"epss_score": 0.0061, "epss_percentile": 0.69151}, "CVE-2020-23171": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2020-23172": {"epss_score": 0.00505, "epss_percentile": 0.65589}, "CVE-2020-23178": {"epss_score": 0.00127, "epss_percentile": 0.32882}, "CVE-2020-23179": {"epss_score": 0.00533, "epss_percentile": 0.66763}, "CVE-2020-23181": {"epss_score": 0.00533, "epss_percentile": 0.66763}, "CVE-2020-23182": {"epss_score": 0.00121, "epss_percentile": 0.31923}, "CVE-2020-23184": {"epss_score": 0.00481, "epss_percentile": 0.64484}, "CVE-2020-23185": {"epss_score": 0.00481, "epss_percentile": 0.64484}, "CVE-2020-23190": {"epss_score": 0.00533, "epss_percentile": 0.66763}, "CVE-2020-23192": {"epss_score": 0.00533, "epss_percentile": 0.66763}, "CVE-2020-23194": {"epss_score": 0.00481, "epss_percentile": 0.64484}, "CVE-2020-23205": {"epss_score": 0.00236, "epss_percentile": 0.4637}, "CVE-2020-23207": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-23208": {"epss_score": 0.00286, "epss_percentile": 0.51715}, "CVE-2020-23209": {"epss_score": 0.00258, "epss_percentile": 0.48954}, "CVE-2020-23214": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-23217": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-23219": {"epss_score": 0.01025, "epss_percentile": 0.76788}, "CVE-2020-23226": {"epss_score": 0.01245, "epss_percentile": 0.78839}, "CVE-2020-23234": {"epss_score": 0.0016, "epss_percentile": 0.37518}, "CVE-2020-23238": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-23239": {"epss_score": 0.00299, "epss_percentile": 0.52851}, "CVE-2020-23240": {"epss_score": 0.00305, "epss_percentile": 0.53346}, "CVE-2020-23241": {"epss_score": 0.00305, "epss_percentile": 0.53346}, "CVE-2020-23242": {"epss_score": 0.0029, "epss_percentile": 0.5208}, "CVE-2020-23243": {"epss_score": 0.00212, "epss_percentile": 0.43759}, "CVE-2020-23249": {"epss_score": 0.00108, "epss_percentile": 0.29888}, "CVE-2020-23250": {"epss_score": 0.00028, "epss_percentile": 0.07291}, "CVE-2020-23256": {"epss_score": 0.00112, "epss_percentile": 0.30485}, "CVE-2020-23257": {"epss_score": 0.00168, "epss_percentile": 0.38417}, "CVE-2020-23258": {"epss_score": 0.0024, "epss_percentile": 0.46949}, "CVE-2020-23259": {"epss_score": 0.00079, "epss_percentile": 0.23836}, "CVE-2020-23260": {"epss_score": 0.00067, "epss_percentile": 0.21059}, "CVE-2020-23262": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-23263": {"epss_score": 0.00368, "epss_percentile": 0.58187}, "CVE-2020-23264": {"epss_score": 0.00111, "epss_percentile": 0.30354}, "CVE-2020-23266": {"epss_score": 0.00175, "epss_percentile": 0.39266}, "CVE-2020-23267": {"epss_score": 0.00184, "epss_percentile": 0.40437}, "CVE-2020-23269": {"epss_score": 0.00161, "epss_percentile": 0.37591}, "CVE-2020-23273": {"epss_score": 0.00161, "epss_percentile": 0.37591}, "CVE-2020-23282": {"epss_score": 0.00238, "epss_percentile": 0.46824}, "CVE-2020-23283": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2020-23284": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-23302": {"epss_score": 0.00356, "epss_percentile": 0.57334}, "CVE-2020-23303": {"epss_score": 0.00356, "epss_percentile": 0.57334}, "CVE-2020-23306": {"epss_score": 0.00377, "epss_percentile": 0.58714}, "CVE-2020-23308": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2020-23309": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2020-23310": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2020-23311": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2020-23312": {"epss_score": 0.00303, "epss_percentile": 0.53181}, "CVE-2020-23313": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2020-23314": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2020-23315": {"epss_score": 0.03171, "epss_percentile": 0.86548}, "CVE-2020-23319": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2020-23320": {"epss_score": 0.00303, "epss_percentile": 0.53181}, "CVE-2020-23321": {"epss_score": 0.00356, "epss_percentile": 0.57334}, "CVE-2020-23322": {"epss_score": 0.00303, "epss_percentile": 0.53181}, "CVE-2020-23323": {"epss_score": 0.00356, "epss_percentile": 0.57334}, "CVE-2020-23327": {"epss_score": 0.00097, "epss_percentile": 0.27571}, "CVE-2020-23330": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2020-23331": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2020-23332": {"epss_score": 0.00327, "epss_percentile": 0.55133}, "CVE-2020-23333": {"epss_score": 0.00391, "epss_percentile": 0.59575}, "CVE-2020-23334": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-23341": {"epss_score": 0.00207, "epss_percentile": 0.43167}, "CVE-2020-23342": {"epss_score": 0.09213, "epss_percentile": 0.92451}, "CVE-2020-23349": {"epss_score": 0.00198, "epss_percentile": 0.42035}, "CVE-2020-23352": {"epss_score": 0.00242, "epss_percentile": 0.47392}, "CVE-2020-23355": {"epss_score": 0.00234, "epss_percentile": 0.46077}, "CVE-2020-23356": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-23359": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2020-23360": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2020-23361": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2020-23362": {"epss_score": 0.0038, "epss_percentile": 0.58955}, "CVE-2020-23363": {"epss_score": 0.00061, "epss_percentile": 0.19485}, "CVE-2020-23369": {"epss_score": 0.00207, "epss_percentile": 0.43167}, "CVE-2020-23370": {"epss_score": 0.00176, "epss_percentile": 0.39395}, "CVE-2020-23371": {"epss_score": 0.00253, "epss_percentile": 0.4848}, "CVE-2020-23373": {"epss_score": 0.00176, "epss_percentile": 0.39395}, "CVE-2020-23374": {"epss_score": 0.00176, "epss_percentile": 0.39395}, "CVE-2020-23376": {"epss_score": 0.00093, "epss_percentile": 0.2675}, "CVE-2020-23426": {"epss_score": 0.0012, "epss_percentile": 0.31696}, "CVE-2020-23438": {"epss_score": 0.00036, "epss_percentile": 0.10242}, "CVE-2020-23446": {"epss_score": 0.00455, "epss_percentile": 0.63283}, "CVE-2020-23447": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-23448": {"epss_score": 0.00398, "epss_percentile": 0.60071}, "CVE-2020-23449": {"epss_score": 0.00206, "epss_percentile": 0.42918}, "CVE-2020-23450": {"epss_score": 0.0043, "epss_percentile": 0.62022}, "CVE-2020-23451": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2020-23452": {"epss_score": 0.00071, "epss_percentile": 0.22082}, "CVE-2020-23466": {"epss_score": 0.00187, "epss_percentile": 0.40765}, "CVE-2020-23469": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-23478": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-23481": {"epss_score": 0.00281, "epss_percentile": 0.51183}, "CVE-2020-23489": {"epss_score": 0.07078, "epss_percentile": 0.91235}, "CVE-2020-23490": {"epss_score": 0.16676, "epss_percentile": 0.94712}, "CVE-2020-23512": {"epss_score": 0.00266, "epss_percentile": 0.49943}, "CVE-2020-23517": {"epss_score": 0.13375, "epss_percentile": 0.93945}, "CVE-2020-23518": {"epss_score": 0.00172, "epss_percentile": 0.38945}, "CVE-2020-23520": {"epss_score": 0.02453, "epss_percentile": 0.84792}, "CVE-2020-23522": {"epss_score": 0.00191, "epss_percentile": 0.41194}, "CVE-2020-23533": {"epss_score": 0.00154, "epss_percentile": 0.36694}, "CVE-2020-23534": {"epss_score": 0.00316, "epss_percentile": 0.54221}, "CVE-2020-23539": {"epss_score": 0.0072, "epss_percentile": 0.71965}, "CVE-2020-23545": {"epss_score": 0.00306, "epss_percentile": 0.53414}, "CVE-2020-23546": {"epss_score": 0.00243, "epss_percentile": 0.47482}, "CVE-2020-23549": {"epss_score": 0.00203, "epss_percentile": 0.4255}, "CVE-2020-23550": {"epss_score": 0.00135, "epss_percentile": 0.34024}, "CVE-2020-23551": {"epss_score": 0.00135, "epss_percentile": 0.34024}, "CVE-2020-23552": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2020-23553": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2020-23554": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2020-23555": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2020-23556": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2020-23557": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2020-23558": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2020-23559": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2020-23560": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2020-23561": {"epss_score": 0.00134, "epss_percentile": 0.33923}, "CVE-2020-23562": {"epss_score": 0.00134, "epss_percentile": 0.33923}, "CVE-2020-23563": {"epss_score": 0.00134, "epss_percentile": 0.33923}, "CVE-2020-23564": {"epss_score": 0.00236, "epss_percentile": 0.46418}, "CVE-2020-23565": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2020-23566": {"epss_score": 0.00189, "epss_percentile": 0.4096}, "CVE-2020-23567": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-23572": {"epss_score": 0.00591, "epss_percentile": 0.68595}, "CVE-2020-23574": {"epss_score": 0.00853, "epss_percentile": 0.74425}, "CVE-2020-23575": {"epss_score": 0.85091, "epss_percentile": 0.99317}, "CVE-2020-23576": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-23580": {"epss_score": 0.02228, "epss_percentile": 0.84076}, "CVE-2020-23582": {"epss_score": 0.00153, "epss_percentile": 0.36582}, "CVE-2020-23583": {"epss_score": 0.07771, "epss_percentile": 0.91674}, "CVE-2020-23584": {"epss_score": 0.1899, "epss_percentile": 0.95108}, "CVE-2020-23585": {"epss_score": 0.00214, "epss_percentile": 0.43985}, "CVE-2020-23586": {"epss_score": 0.00122, "epss_percentile": 0.32059}, "CVE-2020-23587": {"epss_score": 0.0009, "epss_percentile": 0.26002}, "CVE-2020-23588": {"epss_score": 0.00157, "epss_percentile": 0.37117}, "CVE-2020-23589": {"epss_score": 0.00163, "epss_percentile": 0.37785}, "CVE-2020-23590": {"epss_score": 0.00165, "epss_percentile": 0.38132}, "CVE-2020-23591": {"epss_score": 0.00817, "epss_percentile": 0.73843}, "CVE-2020-23592": {"epss_score": 0.00315, "epss_percentile": 0.54188}, "CVE-2020-23593": {"epss_score": 0.00159, "epss_percentile": 0.373}, "CVE-2020-23595": {"epss_score": 0.0029, "epss_percentile": 0.52111}, "CVE-2020-23617": {"epss_score": 0.00207, "epss_percentile": 0.43192}, "CVE-2020-23618": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-23620": {"epss_score": 0.04485, "epss_percentile": 0.88748}, "CVE-2020-23621": {"epss_score": 0.04485, "epss_percentile": 0.88748}, "CVE-2020-23622": {"epss_score": 0.00559, "epss_percentile": 0.67602}, "CVE-2020-23630": {"epss_score": 0.00308, "epss_percentile": 0.5362}, "CVE-2020-23631": {"epss_score": 0.00129, "epss_percentile": 0.33219}, "CVE-2020-23639": {"epss_score": 0.06091, "epss_percentile": 0.90473}, "CVE-2020-23643": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-23644": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-23647": {"epss_score": 0.00042, "epss_percentile": 0.12593}, "CVE-2020-23648": {"epss_score": 0.00362, "epss_percentile": 0.57788}, "CVE-2020-23653": {"epss_score": 0.11558, "epss_percentile": 0.93404}, "CVE-2020-23654": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-23655": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-23656": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-23657": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-23658": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-23659": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-23660": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-23679": {"epss_score": 0.01183, "epss_percentile": 0.78327}, "CVE-2020-23680": {"epss_score": 0.00189, "epss_percentile": 0.40928}, "CVE-2020-23685": {"epss_score": 0.00578, "epss_percentile": 0.68199}, "CVE-2020-23686": {"epss_score": 0.0022, "epss_percentile": 0.44573}, "CVE-2020-23689": {"epss_score": 0.00212, "epss_percentile": 0.43759}, "CVE-2020-23691": {"epss_score": 0.06472, "epss_percentile": 0.90779}, "CVE-2020-23697": {"epss_score": 0.092, "epss_percentile": 0.92445}, "CVE-2020-23700": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-23702": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-23705": {"epss_score": 0.00244, "epss_percentile": 0.47581}, "CVE-2020-23706": {"epss_score": 0.00328, "epss_percentile": 0.55156}, "CVE-2020-23707": {"epss_score": 0.00487, "epss_percentile": 0.64784}, "CVE-2020-23710": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-23711": {"epss_score": 0.00508, "epss_percentile": 0.65682}, "CVE-2020-23715": {"epss_score": 0.00618, "epss_percentile": 0.69384}, "CVE-2020-23718": {"epss_score": 0.00734, "epss_percentile": 0.72242}, "CVE-2020-23719": {"epss_score": 0.00734, "epss_percentile": 0.72242}, "CVE-2020-23721": {"epss_score": 0.00153, "epss_percentile": 0.36606}, "CVE-2020-23722": {"epss_score": 0.0026, "epss_percentile": 0.49166}, "CVE-2020-23726": {"epss_score": 0.00055, "epss_percentile": 0.17573}, "CVE-2020-23727": {"epss_score": 0.00049, "epss_percentile": 0.1562}, "CVE-2020-23735": {"epss_score": 0.00042, "epss_percentile": 0.12809}, "CVE-2020-23736": {"epss_score": 0.00049, "epss_percentile": 0.1562}, "CVE-2020-23738": {"epss_score": 0.00049, "epss_percentile": 0.1562}, "CVE-2020-23740": {"epss_score": 0.0006, "epss_percentile": 0.19052}, "CVE-2020-23741": {"epss_score": 0.00049, "epss_percentile": 0.1562}, "CVE-2020-23754": {"epss_score": 0.0081, "epss_percentile": 0.73717}, "CVE-2020-23761": {"epss_score": 0.00402, "epss_percentile": 0.60275}, "CVE-2020-23762": {"epss_score": 0.00119, "epss_percentile": 0.31645}, "CVE-2020-23763": {"epss_score": 0.00913, "epss_percentile": 0.75379}, "CVE-2020-23765": {"epss_score": 0.00378, "epss_percentile": 0.58785}, "CVE-2020-23766": {"epss_score": 0.01518, "epss_percentile": 0.80812}, "CVE-2020-23768": {"epss_score": 0.00238, "epss_percentile": 0.46835}, "CVE-2020-23774": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2020-23776": {"epss_score": 0.00278, "epss_percentile": 0.50895}, "CVE-2020-23790": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-23793": {"epss_score": 0.0009, "epss_percentile": 0.25996}, "CVE-2020-23804": {"epss_score": 0.00264, "epss_percentile": 0.49726}, "CVE-2020-23811": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-23814": {"epss_score": 0.01905, "epss_percentile": 0.82792}, "CVE-2020-23824": {"epss_score": 0.00287, "epss_percentile": 0.51846}, "CVE-2020-23826": {"epss_score": 0.11379, "epss_percentile": 0.93326}, "CVE-2020-23828": {"epss_score": 0.02309, "epss_percentile": 0.84332}, "CVE-2020-23829": {"epss_score": 0.0247, "epss_percentile": 0.84847}, "CVE-2020-23830": {"epss_score": 0.00218, "epss_percentile": 0.44396}, "CVE-2020-23831": {"epss_score": 0.00486, "epss_percentile": 0.64751}, "CVE-2020-23832": {"epss_score": 0.01345, "epss_percentile": 0.79628}, "CVE-2020-23833": {"epss_score": 0.06106, "epss_percentile": 0.90485}, "CVE-2020-23834": {"epss_score": 0.00032, "epss_percentile": 0.08733}, "CVE-2020-23835": {"epss_score": 0.01842, "epss_percentile": 0.82499}, "CVE-2020-23836": {"epss_score": 0.00214, "epss_percentile": 0.44007}, "CVE-2020-23837": {"epss_score": 0.0026, "epss_percentile": 0.49165}, "CVE-2020-23839": {"epss_score": 0.07053, "epss_percentile": 0.91215}, "CVE-2020-23849": {"epss_score": 0.00262, "epss_percentile": 0.49391}, "CVE-2020-23851": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2020-23852": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2020-23856": {"epss_score": 0.00113, "epss_percentile": 0.30719}, "CVE-2020-23861": {"epss_score": 0.00177, "epss_percentile": 0.39498}, "CVE-2020-23864": {"epss_score": 0.00043, "epss_percentile": 0.13278}, "CVE-2020-23868": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-23872": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2020-23873": {"epss_score": 0.00743, "epss_percentile": 0.72502}, "CVE-2020-23874": {"epss_score": 0.00743, "epss_percentile": 0.72502}, "CVE-2020-23876": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-23877": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2020-23878": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2020-23879": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2020-23884": {"epss_score": 0.00255, "epss_percentile": 0.48686}, "CVE-2020-23886": {"epss_score": 0.00255, "epss_percentile": 0.48686}, "CVE-2020-23887": {"epss_score": 0.00195, "epss_percentile": 0.41684}, "CVE-2020-23888": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-23889": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-23890": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2020-23891": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-23893": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-23894": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-23895": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-23896": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-23897": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-23898": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-23899": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-23900": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2020-23901": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-23902": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2020-23903": {"epss_score": 0.00129, "epss_percentile": 0.33134}, "CVE-2020-23904": {"epss_score": 0.00268, "epss_percentile": 0.50023}, "CVE-2020-23906": {"epss_score": 0.00078, "epss_percentile": 0.23665}, "CVE-2020-23907": {"epss_score": 0.02148, "epss_percentile": 0.83774}, "CVE-2020-23909": {"epss_score": 0.00027, "epss_percentile": 0.06956}, "CVE-2020-23910": {"epss_score": 0.00047, "epss_percentile": 0.14479}, "CVE-2020-23911": {"epss_score": 0.00052, "epss_percentile": 0.1645}, "CVE-2020-23912": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2020-23914": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2020-23915": {"epss_score": 0.00198, "epss_percentile": 0.42006}, "CVE-2020-23921": {"epss_score": 0.0025, "epss_percentile": 0.48139}, "CVE-2020-23922": {"epss_score": 0.03785, "epss_percentile": 0.87725}, "CVE-2020-23928": {"epss_score": 0.00293, "epss_percentile": 0.52298}, "CVE-2020-23930": {"epss_score": 0.0018, "epss_percentile": 0.39991}, "CVE-2020-23931": {"epss_score": 0.00293, "epss_percentile": 0.52298}, "CVE-2020-23932": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2020-23934": {"epss_score": 0.25912, "epss_percentile": 0.96093}, "CVE-2020-23935": {"epss_score": 0.31459, "epss_percentile": 0.96622}, "CVE-2020-23936": {"epss_score": 0.00525, "epss_percentile": 0.66379}, "CVE-2020-23945": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2020-23957": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-23960": {"epss_score": 0.00205, "epss_percentile": 0.4274}, "CVE-2020-23962": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-23966": {"epss_score": 0.00069, "epss_percentile": 0.21524}, "CVE-2020-23967": {"epss_score": 0.00035, "epss_percentile": 0.09909}, "CVE-2020-23968": {"epss_score": 0.02501, "epss_percentile": 0.84922}, "CVE-2020-23971": {"epss_score": 0.00168, "epss_percentile": 0.38416}, "CVE-2020-23972": {"epss_score": 0.77029, "epss_percentile": 0.98917}, "CVE-2020-23973": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2020-23974": {"epss_score": 0.00181, "epss_percentile": 0.40082}, "CVE-2020-23975": {"epss_score": 0.0018, "epss_percentile": 0.39872}, "CVE-2020-23976": {"epss_score": 0.01137, "epss_percentile": 0.77922}, "CVE-2020-23977": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2020-23978": {"epss_score": 0.01137, "epss_percentile": 0.77922}, "CVE-2020-23979": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2020-23980": {"epss_score": 0.00622, "epss_percentile": 0.6953}, "CVE-2020-23981": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2020-23982": {"epss_score": 0.00136, "epss_percentile": 0.3415}, "CVE-2020-23983": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2020-23984": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2020-23986": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-23989": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-23992": {"epss_score": 0.0086, "epss_percentile": 0.74537}, "CVE-2020-23995": {"epss_score": 0.00686, "epss_percentile": 0.71154}, "CVE-2020-23996": {"epss_score": 0.03341, "epss_percentile": 0.86942}, "CVE-2020-24000": {"epss_score": 0.0234, "epss_percentile": 0.84432}, "CVE-2020-24003": {"epss_score": 0.00805, "epss_percentile": 0.73642}, "CVE-2020-24007": {"epss_score": 0.01847, "epss_percentile": 0.82523}, "CVE-2020-24008": {"epss_score": 0.00198, "epss_percentile": 0.42085}, "CVE-2020-24020": {"epss_score": 0.00831, "epss_percentile": 0.74056}, "CVE-2020-24025": {"epss_score": 0.00482, "epss_percentile": 0.64548}, "CVE-2020-24026": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2020-24027": {"epss_score": 0.00549, "epss_percentile": 0.67311}, "CVE-2020-24028": {"epss_score": 0.00717, "epss_percentile": 0.71874}, "CVE-2020-24029": {"epss_score": 0.00828, "epss_percentile": 0.73994}, "CVE-2020-24030": {"epss_score": 0.01418, "epss_percentile": 0.80159}, "CVE-2020-24032": {"epss_score": 0.16755, "epss_percentile": 0.94728}, "CVE-2020-24033": {"epss_score": 0.01205, "epss_percentile": 0.7851}, "CVE-2020-24034": {"epss_score": 0.01639, "epss_percentile": 0.81498}, "CVE-2020-24036": {"epss_score": 0.01279, "epss_percentile": 0.79131}, "CVE-2020-24038": {"epss_score": 0.00295, "epss_percentile": 0.52451}, "CVE-2020-24045": {"epss_score": 0.01167, "epss_percentile": 0.78186}, "CVE-2020-24046": {"epss_score": 0.03565, "epss_percentile": 0.87361}, "CVE-2020-24051": {"epss_score": 0.00461, "epss_percentile": 0.63538}, "CVE-2020-24052": {"epss_score": 0.01419, "epss_percentile": 0.80164}, "CVE-2020-24053": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2020-24054": {"epss_score": 0.00629, "epss_percentile": 0.69669}, "CVE-2020-24055": {"epss_score": 0.00495, "epss_percentile": 0.65132}, "CVE-2020-24056": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2020-24057": {"epss_score": 0.21189, "epss_percentile": 0.95474}, "CVE-2020-24061": {"epss_score": 0.00104, "epss_percentile": 0.29242}, "CVE-2020-24063": {"epss_score": 0.00335, "epss_percentile": 0.55796}, "CVE-2020-24074": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2020-24075": {"epss_score": 0.00299, "epss_percentile": 0.52861}, "CVE-2020-24085": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-24088": {"epss_score": 0.00086, "epss_percentile": 0.25351}, "CVE-2020-24089": {"epss_score": 0.00071, "epss_percentile": 0.22035}, "CVE-2020-24102": {"epss_score": 0.03592, "epss_percentile": 0.87401}, "CVE-2020-24104": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-24113": {"epss_score": 0.00306, "epss_percentile": 0.53433}, "CVE-2020-24115": {"epss_score": 0.00631, "epss_percentile": 0.69719}, "CVE-2020-24119": {"epss_score": 0.00382, "epss_percentile": 0.59052}, "CVE-2020-24130": {"epss_score": 0.00093, "epss_percentile": 0.26721}, "CVE-2020-24133": {"epss_score": 0.02346, "epss_percentile": 0.84452}, "CVE-2020-24135": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2020-24136": {"epss_score": 0.01276, "epss_percentile": 0.79109}, "CVE-2020-24137": {"epss_score": 0.00147, "epss_percentile": 0.35672}, "CVE-2020-24138": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2020-24139": {"epss_score": 0.00304, "epss_percentile": 0.53297}, "CVE-2020-24140": {"epss_score": 0.00245, "epss_percentile": 0.47676}, "CVE-2020-24141": {"epss_score": 0.0019, "epss_percentile": 0.41074}, "CVE-2020-24142": {"epss_score": 0.00706, "epss_percentile": 0.71605}, "CVE-2020-24143": {"epss_score": 0.00913, "epss_percentile": 0.7537}, "CVE-2020-24144": {"epss_score": 0.01093, "epss_percentile": 0.77479}, "CVE-2020-24145": {"epss_score": 0.00511, "epss_percentile": 0.65814}, "CVE-2020-24146": {"epss_score": 0.00765, "epss_percentile": 0.72918}, "CVE-2020-24147": {"epss_score": 0.01007, "epss_percentile": 0.76559}, "CVE-2020-24148": {"epss_score": 0.92759, "epss_percentile": 0.99744}, "CVE-2020-24149": {"epss_score": 0.00587, "epss_percentile": 0.68481}, "CVE-2020-24158": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2020-24159": {"epss_score": 0.00044, "epss_percentile": 0.1354}, "CVE-2020-24160": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2020-24161": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2020-24162": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2020-24164": {"epss_score": 0.00141, "epss_percentile": 0.34868}, "CVE-2020-24165": {"epss_score": 0.00429, "epss_percentile": 0.62}, "CVE-2020-24175": {"epss_score": 0.01725, "epss_percentile": 0.81957}, "CVE-2020-24186": {"epss_score": 0.94213, "epss_percentile": 0.99917}, "CVE-2020-24187": {"epss_score": 0.00031, "epss_percentile": 0.08708}, "CVE-2020-24188": {"epss_score": 0.00301, "epss_percentile": 0.53018}, "CVE-2020-24193": {"epss_score": 0.02166, "epss_percentile": 0.83849}, "CVE-2020-24194": {"epss_score": 0.00285, "epss_percentile": 0.51542}, "CVE-2020-24195": {"epss_score": 0.02232, "epss_percentile": 0.8409}, "CVE-2020-24196": {"epss_score": 0.02569, "epss_percentile": 0.85124}, "CVE-2020-24197": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2020-24198": {"epss_score": 0.00402, "epss_percentile": 0.60275}, "CVE-2020-24199": {"epss_score": 0.03387, "epss_percentile": 0.87043}, "CVE-2020-24202": {"epss_score": 0.0307, "epss_percentile": 0.86346}, "CVE-2020-24203": {"epss_score": 0.05688, "epss_percentile": 0.90121}, "CVE-2020-24208": {"epss_score": 0.0349, "epss_percentile": 0.8723}, "CVE-2020-24213": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2020-24214": {"epss_score": 0.48008, "epss_percentile": 0.97614}, "CVE-2020-24215": {"epss_score": 0.41171, "epss_percentile": 0.97257}, "CVE-2020-24216": {"epss_score": 0.00712, "epss_percentile": 0.71775}, "CVE-2020-24217": {"epss_score": 0.31939, "epss_percentile": 0.96661}, "CVE-2020-24218": {"epss_score": 0.0034, "epss_percentile": 0.56256}, "CVE-2020-24219": {"epss_score": 0.21375, "epss_percentile": 0.95511}, "CVE-2020-24220": {"epss_score": 0.00811, "epss_percentile": 0.73725}, "CVE-2020-24221": {"epss_score": 0.00036, "epss_percentile": 0.10325}, "CVE-2020-24222": {"epss_score": 0.00037, "epss_percentile": 0.11006}, "CVE-2020-24223": {"epss_score": 0.15272, "epss_percentile": 0.94396}, "CVE-2020-24227": {"epss_score": 0.00617, "epss_percentile": 0.69355}, "CVE-2020-24231": {"epss_score": 0.01025, "epss_percentile": 0.76794}, "CVE-2020-24240": {"epss_score": 0.00403, "epss_percentile": 0.60341}, "CVE-2020-24241": {"epss_score": 0.00131, "epss_percentile": 0.33374}, "CVE-2020-24242": {"epss_score": 0.00137, "epss_percentile": 0.3431}, "CVE-2020-24246": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2020-24263": {"epss_score": 0.01917, "epss_percentile": 0.82863}, "CVE-2020-24264": {"epss_score": 0.05237, "epss_percentile": 0.89649}, "CVE-2020-24265": {"epss_score": 0.00546, "epss_percentile": 0.67209}, "CVE-2020-24266": {"epss_score": 0.00549, "epss_percentile": 0.67312}, "CVE-2020-24271": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2020-24275": {"epss_score": 0.00596, "epss_percentile": 0.68735}, "CVE-2020-24285": {"epss_score": 0.13052, "epss_percentile": 0.93859}, "CVE-2020-24292": {"epss_score": 0.01509, "epss_percentile": 0.80765}, "CVE-2020-24293": {"epss_score": 0.01509, "epss_percentile": 0.80765}, "CVE-2020-24294": {"epss_score": 0.00877, "epss_percentile": 0.74804}, "CVE-2020-24295": {"epss_score": 0.015, "epss_percentile": 0.80708}, "CVE-2020-24297": {"epss_score": 0.01528, "epss_percentile": 0.8087}, "CVE-2020-24301": {"epss_score": 0.0024, "epss_percentile": 0.46957}, "CVE-2020-24303": {"epss_score": 0.00362, "epss_percentile": 0.5782}, "CVE-2020-24307": {"epss_score": 0.00031, "epss_percentile": 0.08556}, "CVE-2020-24312": {"epss_score": 0.51624, "epss_percentile": 0.97789}, "CVE-2020-24313": {"epss_score": 0.00264, "epss_percentile": 0.49695}, "CVE-2020-24314": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2020-24315": {"epss_score": 0.00775, "epss_percentile": 0.73092}, "CVE-2020-24316": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2020-24327": {"epss_score": 0.00188, "epss_percentile": 0.40911}, "CVE-2020-24330": {"epss_score": 0.0019, "epss_percentile": 0.41099}, "CVE-2020-24331": {"epss_score": 0.0019, "epss_percentile": 0.41099}, "CVE-2020-24332": {"epss_score": 0.00244, "epss_percentile": 0.47578}, "CVE-2020-24333": {"epss_score": 0.00212, "epss_percentile": 0.438}, "CVE-2020-24334": {"epss_score": 0.00639, "epss_percentile": 0.69949}, "CVE-2020-24335": {"epss_score": 0.01547, "epss_percentile": 0.80972}, "CVE-2020-24336": {"epss_score": 0.0183, "epss_percentile": 0.82447}, "CVE-2020-24337": {"epss_score": 0.00447, "epss_percentile": 0.62961}, "CVE-2020-24338": {"epss_score": 0.16481, "epss_percentile": 0.94677}, "CVE-2020-24339": {"epss_score": 0.00495, "epss_percentile": 0.65127}, "CVE-2020-24340": {"epss_score": 0.00495, "epss_percentile": 0.65127}, "CVE-2020-24341": {"epss_score": 0.00739, "epss_percentile": 0.72352}, "CVE-2020-24342": {"epss_score": 0.00307, "epss_percentile": 0.53526}, "CVE-2020-24343": {"epss_score": 0.00182, "epss_percentile": 0.40235}, "CVE-2020-24344": {"epss_score": 0.00181, "epss_percentile": 0.40122}, "CVE-2020-24345": {"epss_score": 0.00254, "epss_percentile": 0.48551}, "CVE-2020-24346": {"epss_score": 0.00171, "epss_percentile": 0.38774}, "CVE-2020-24347": {"epss_score": 0.00046, "epss_percentile": 0.14106}, "CVE-2020-24348": {"epss_score": 0.00046, "epss_percentile": 0.14106}, "CVE-2020-24349": {"epss_score": 0.00057, "epss_percentile": 0.18071}, "CVE-2020-24352": {"epss_score": 0.00137, "epss_percentile": 0.34282}, "CVE-2020-24353": {"epss_score": 0.00312, "epss_percentile": 0.53995}, "CVE-2020-24354": {"epss_score": 0.0079, "epss_percentile": 0.73369}, "CVE-2020-24355": {"epss_score": 0.00367, "epss_percentile": 0.58134}, "CVE-2020-24356": {"epss_score": 0.00033, "epss_percentile": 0.0931}, "CVE-2020-24359": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-24360": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-24361": {"epss_score": 0.00567, "epss_percentile": 0.67841}, "CVE-2020-24363": {"epss_score": 0.16201, "epss_percentile": 0.94593}, "CVE-2020-24364": {"epss_score": 0.01091, "epss_percentile": 0.77462}, "CVE-2020-24365": {"epss_score": 0.12514, "epss_percentile": 0.93703}, "CVE-2020-24366": {"epss_score": 1e-05, "epss_percentile": 5e-05}, "CVE-2020-24367": {"epss_score": 0.00033, "epss_percentile": 0.09344}, "CVE-2020-24368": {"epss_score": 0.02228, "epss_percentile": 0.84076}, "CVE-2020-24369": {"epss_score": 0.00573, "epss_percentile": 0.68046}, "CVE-2020-24370": {"epss_score": 0.01862, "epss_percentile": 0.82594}, "CVE-2020-24371": {"epss_score": 0.00522, "epss_percentile": 0.66265}, "CVE-2020-24372": {"epss_score": 0.0032, "epss_percentile": 0.54628}, "CVE-2020-24373": {"epss_score": 0.00167, "epss_percentile": 0.38369}, "CVE-2020-24374": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2020-24375": {"epss_score": 0.00303, "epss_percentile": 0.53174}, "CVE-2020-24376": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2020-24377": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2020-24379": {"epss_score": 0.01106, "epss_percentile": 0.77615}, "CVE-2020-24381": {"epss_score": 0.00363, "epss_percentile": 0.57865}, "CVE-2020-24383": {"epss_score": 0.00739, "epss_percentile": 0.72352}, "CVE-2020-24384": {"epss_score": 0.05638, "epss_percentile": 0.90073}, "CVE-2020-24385": {"epss_score": 0.00036, "epss_percentile": 0.10311}, "CVE-2020-24386": {"epss_score": 0.00626, "epss_percentile": 0.69606}, "CVE-2020-24387": {"epss_score": 0.00788, "epss_percentile": 0.73334}, "CVE-2020-24388": {"epss_score": 0.00788, "epss_percentile": 0.73334}, "CVE-2020-24390": {"epss_score": 0.00391, "epss_percentile": 0.59561}, "CVE-2020-24391": {"epss_score": 0.92863, "epss_percentile": 0.99756}, "CVE-2020-24392": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-24393": {"epss_score": 0.00185, "epss_percentile": 0.40565}, "CVE-2020-24394": {"epss_score": 0.00052, "epss_percentile": 0.16615}, "CVE-2020-24395": {"epss_score": 0.00024, "epss_percentile": 0.05737}, "CVE-2020-24396": {"epss_score": 0.00472, "epss_percentile": 0.64057}, "CVE-2020-24397": {"epss_score": 0.11259, "epss_percentile": 0.93281}, "CVE-2020-24400": {"epss_score": 0.00257, "epss_percentile": 0.48887}, "CVE-2020-24401": {"epss_score": 0.00386, "epss_percentile": 0.59259}, "CVE-2020-24402": {"epss_score": 0.00259, "epss_percentile": 0.49073}, "CVE-2020-24403": {"epss_score": 0.00259, "epss_percentile": 0.49073}, "CVE-2020-24404": {"epss_score": 0.00371, "epss_percentile": 0.5841}, "CVE-2020-24405": {"epss_score": 0.00117, "epss_percentile": 0.31349}, "CVE-2020-24406": {"epss_score": 0.00295, "epss_percentile": 0.52451}, "CVE-2020-24407": {"epss_score": 0.03721, "epss_percentile": 0.87622}, "CVE-2020-24408": {"epss_score": 0.01321, "epss_percentile": 0.79444}, "CVE-2020-24409": {"epss_score": 0.03834, "epss_percentile": 0.87813}, "CVE-2020-24410": {"epss_score": 0.03834, "epss_percentile": 0.87813}, "CVE-2020-24411": {"epss_score": 0.03057, "epss_percentile": 0.86302}, "CVE-2020-24412": {"epss_score": 0.0665, "epss_percentile": 0.90915}, "CVE-2020-24413": {"epss_score": 0.0665, "epss_percentile": 0.90915}, "CVE-2020-24414": {"epss_score": 0.0665, "epss_percentile": 0.90915}, "CVE-2020-24415": {"epss_score": 0.0665, "epss_percentile": 0.90915}, "CVE-2020-24416": {"epss_score": 0.01783, "epss_percentile": 0.82247}, "CVE-2020-24418": {"epss_score": 0.024, "epss_percentile": 0.84637}, "CVE-2020-24419": {"epss_score": 0.00645, "epss_percentile": 0.70118}, "CVE-2020-24420": {"epss_score": 0.00435, "epss_percentile": 0.62354}, "CVE-2020-24421": {"epss_score": 0.00642, "epss_percentile": 0.70022}, "CVE-2020-24422": {"epss_score": 0.12468, "epss_percentile": 0.93681}, "CVE-2020-24423": {"epss_score": 0.00841, "epss_percentile": 0.74216}, "CVE-2020-24424": {"epss_score": 0.00841, "epss_percentile": 0.74216}, "CVE-2020-24425": {"epss_score": 0.00232, "epss_percentile": 0.45963}, "CVE-2020-24426": {"epss_score": 0.01604, "epss_percentile": 0.81285}, "CVE-2020-24427": {"epss_score": 0.0193, "epss_percentile": 0.82938}, "CVE-2020-24428": {"epss_score": 0.01687, "epss_percentile": 0.81756}, "CVE-2020-24429": {"epss_score": 0.00224, "epss_percentile": 0.45003}, "CVE-2020-24430": {"epss_score": 0.19531, "epss_percentile": 0.95201}, "CVE-2020-24431": {"epss_score": 0.00334, "epss_percentile": 0.55724}, "CVE-2020-24432": {"epss_score": 0.07148, "epss_percentile": 0.91283}, "CVE-2020-24433": {"epss_score": 0.01664, "epss_percentile": 0.81641}, "CVE-2020-24434": {"epss_score": 0.01604, "epss_percentile": 0.81285}, "CVE-2020-24435": {"epss_score": 0.21322, "epss_percentile": 0.955}, "CVE-2020-24436": {"epss_score": 0.06479, "epss_percentile": 0.90784}, "CVE-2020-24437": {"epss_score": 0.1303, "epss_percentile": 0.93849}, "CVE-2020-24438": {"epss_score": 0.0102, "epss_percentile": 0.7674}, "CVE-2020-24439": {"epss_score": 0.00068, "epss_percentile": 0.2123}, "CVE-2020-24440": {"epss_score": 0.00113, "epss_percentile": 0.3061}, "CVE-2020-24441": {"epss_score": 0.00788, "epss_percentile": 0.73323}, "CVE-2020-24442": {"epss_score": 0.01191, "epss_percentile": 0.78396}, "CVE-2020-24443": {"epss_score": 0.01188, "epss_percentile": 0.78368}, "CVE-2020-24444": {"epss_score": 0.0048, "epss_percentile": 0.64468}, "CVE-2020-24445": {"epss_score": 0.00602, "epss_percentile": 0.68875}, "CVE-2020-24447": {"epss_score": 0.00113, "epss_percentile": 0.3061}, "CVE-2020-24448": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-24450": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-24451": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2020-24452": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-24453": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-24454": {"epss_score": 0.00393, "epss_percentile": 0.59723}, "CVE-2020-24455": {"epss_score": 0.00101, "epss_percentile": 0.28706}, "CVE-2020-24456": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-24457": {"epss_score": 0.00071, "epss_percentile": 0.22049}, "CVE-2020-24458": {"epss_score": 0.00094, "epss_percentile": 0.26986}, "CVE-2020-24460": {"epss_score": 0.00033, "epss_percentile": 0.09158}, "CVE-2020-24462": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-24473": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-24474": {"epss_score": 0.00139, "epss_percentile": 0.34538}, "CVE-2020-24475": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-24480": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-24481": {"epss_score": 0.00044, "epss_percentile": 0.13366}, "CVE-2020-24482": {"epss_score": 0.00441, "epss_percentile": 0.62664}, "CVE-2020-24485": {"epss_score": 0.00173, "epss_percentile": 0.39093}, "CVE-2020-24486": {"epss_score": 0.00059, "epss_percentile": 0.18915}, "CVE-2020-24489": {"epss_score": 0.00068, "epss_percentile": 0.21417}, "CVE-2020-24490": {"epss_score": 0.05603, "epss_percentile": 0.90041}, "CVE-2020-24491": {"epss_score": 0.00065, "epss_percentile": 0.20653}, "CVE-2020-24492": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-24493": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-24494": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-24495": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-24496": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-24497": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-24498": {"epss_score": 0.00064, "epss_percentile": 0.20366}, "CVE-2020-24500": {"epss_score": 0.00064, "epss_percentile": 0.20366}, "CVE-2020-24501": {"epss_score": 0.00292, "epss_percentile": 0.52256}, "CVE-2020-24502": {"epss_score": 0.00194, "epss_percentile": 0.41516}, "CVE-2020-24503": {"epss_score": 0.00256, "epss_percentile": 0.4881}, "CVE-2020-24504": {"epss_score": 0.00094, "epss_percentile": 0.26961}, "CVE-2020-24505": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-24506": {"epss_score": 0.00169, "epss_percentile": 0.38553}, "CVE-2020-24507": {"epss_score": 0.00134, "epss_percentile": 0.33865}, "CVE-2020-24509": {"epss_score": 0.0015, "epss_percentile": 0.36147}, "CVE-2020-24511": {"epss_score": 0.00073, "epss_percentile": 0.22606}, "CVE-2020-24512": {"epss_score": 0.00061, "epss_percentile": 0.19483}, "CVE-2020-24513": {"epss_score": 0.00019, "epss_percentile": 0.04072}, "CVE-2020-24514": {"epss_score": 0.00115, "epss_percentile": 0.30972}, "CVE-2020-24515": {"epss_score": 0.00147, "epss_percentile": 0.3578}, "CVE-2020-24516": {"epss_score": 0.00076, "epss_percentile": 0.23084}, "CVE-2020-24525": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-24548": {"epss_score": 0.00215, "epss_percentile": 0.4406}, "CVE-2020-24549": {"epss_score": 0.00967, "epss_percentile": 0.76069}, "CVE-2020-24550": {"epss_score": 0.64544, "epss_percentile": 0.98382}, "CVE-2020-24551": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2020-24552": {"epss_score": 0.01281, "epss_percentile": 0.79146}, "CVE-2020-24553": {"epss_score": 0.00184, "epss_percentile": 0.40445}, "CVE-2020-24554": {"epss_score": 0.00643, "epss_percentile": 0.70067}, "CVE-2020-24556": {"epss_score": 0.0017, "epss_percentile": 0.38755}, "CVE-2020-24557": {"epss_score": 0.01876, "epss_percentile": 0.8266}, "CVE-2020-24558": {"epss_score": 0.00143, "epss_percentile": 0.35144}, "CVE-2020-24559": {"epss_score": 0.00173, "epss_percentile": 0.39115}, "CVE-2020-24560": {"epss_score": 0.00221, "epss_percentile": 0.44673}, "CVE-2020-24561": {"epss_score": 0.02364, "epss_percentile": 0.8451}, "CVE-2020-24562": {"epss_score": 0.00213, "epss_percentile": 0.43825}, "CVE-2020-24563": {"epss_score": 0.00107, "epss_percentile": 0.29747}, "CVE-2020-24564": {"epss_score": 0.00111, "epss_percentile": 0.30297}, "CVE-2020-24565": {"epss_score": 0.00111, "epss_percentile": 0.30297}, "CVE-2020-24566": {"epss_score": 0.01457, "epss_percentile": 0.80403}, "CVE-2020-24567": {"epss_score": 0.00134, "epss_percentile": 0.33775}, "CVE-2020-24568": {"epss_score": 0.00401, "epss_percentile": 0.60231}, "CVE-2020-24569": {"epss_score": 0.00278, "epss_percentile": 0.50854}, "CVE-2020-24570": {"epss_score": 0.00133, "epss_percentile": 0.33723}, "CVE-2020-24571": {"epss_score": 0.91237, "epss_percentile": 0.99629}, "CVE-2020-24572": {"epss_score": 0.42143, "epss_percentile": 0.97315}, "CVE-2020-24573": {"epss_score": 0.00398, "epss_percentile": 0.60081}, "CVE-2020-24574": {"epss_score": 0.00161, "epss_percentile": 0.3754}, "CVE-2020-24576": {"epss_score": 0.00467, "epss_percentile": 0.63849}, "CVE-2020-24577": {"epss_score": 0.16762, "epss_percentile": 0.94729}, "CVE-2020-24578": {"epss_score": 0.1984, "epss_percentile": 0.95248}, "CVE-2020-24579": {"epss_score": 0.87787, "epss_percentile": 0.99443}, "CVE-2020-24580": {"epss_score": 0.00097, "epss_percentile": 0.27626}, "CVE-2020-24581": {"epss_score": 0.89067, "epss_percentile": 0.99507}, "CVE-2020-24582": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-24583": {"epss_score": 0.03426, "epss_percentile": 0.87114}, "CVE-2020-24584": {"epss_score": 0.0329, "epss_percentile": 0.86835}, "CVE-2020-24585": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-24586": {"epss_score": 0.00539, "epss_percentile": 0.66959}, "CVE-2020-24587": {"epss_score": 0.00416, "epss_percentile": 0.61184}, "CVE-2020-24588": {"epss_score": 0.00507, "epss_percentile": 0.65655}, "CVE-2020-24589": {"epss_score": 0.8912, "epss_percentile": 0.99509}, "CVE-2020-24590": {"epss_score": 0.00562, "epss_percentile": 0.67699}, "CVE-2020-24591": {"epss_score": 0.00403, "epss_percentile": 0.6034}, "CVE-2020-24592": {"epss_score": 0.00206, "epss_percentile": 0.43053}, "CVE-2020-24593": {"epss_score": 0.00422, "epss_percentile": 0.61565}, "CVE-2020-24594": {"epss_score": 0.00651, "epss_percentile": 0.70295}, "CVE-2020-24595": {"epss_score": 0.00206, "epss_percentile": 0.43053}, "CVE-2020-24598": {"epss_score": 0.00049, "epss_percentile": 0.15505}, "CVE-2020-24599": {"epss_score": 0.00855, "epss_percentile": 0.74462}, "CVE-2020-24600": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2020-24601": {"epss_score": 0.00615, "epss_percentile": 0.69313}, "CVE-2020-24602": {"epss_score": 0.01138, "epss_percentile": 0.77935}, "CVE-2020-24604": {"epss_score": 0.00979, "epss_percentile": 0.76256}, "CVE-2020-24606": {"epss_score": 0.06342, "epss_percentile": 0.90682}, "CVE-2020-24609": {"epss_score": 0.16232, "epss_percentile": 0.94597}, "CVE-2020-24612": {"epss_score": 0.00051, "epss_percentile": 0.16189}, "CVE-2020-24613": {"epss_score": 0.00258, "epss_percentile": 0.48979}, "CVE-2020-24614": {"epss_score": 0.06403, "epss_percentile": 0.90729}, "CVE-2020-24615": {"epss_score": 0.00328, "epss_percentile": 0.55297}, "CVE-2020-24616": {"epss_score": 0.02676, "epss_percentile": 0.85403}, "CVE-2020-24617": {"epss_score": 0.00337, "epss_percentile": 0.56063}, "CVE-2020-24618": {"epss_score": 4e-05, "epss_percentile": 0.00154}, "CVE-2020-24619": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2020-24620": {"epss_score": 0.00041, "epss_percentile": 0.12343}, "CVE-2020-24621": {"epss_score": 0.05872, "epss_percentile": 0.9028}, "CVE-2020-24622": {"epss_score": 0.00224, "epss_percentile": 0.45054}, "CVE-2020-24623": {"epss_score": 0.00148, "epss_percentile": 0.35847}, "CVE-2020-24624": {"epss_score": 0.00423, "epss_percentile": 0.61581}, "CVE-2020-24625": {"epss_score": 0.00423, "epss_percentile": 0.61581}, "CVE-2020-24626": {"epss_score": 0.02421, "epss_percentile": 0.84705}, "CVE-2020-24627": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-24628": {"epss_score": 0.00923, "epss_percentile": 0.75495}, "CVE-2020-24629": {"epss_score": 0.00611, "epss_percentile": 0.69181}, "CVE-2020-24630": {"epss_score": 0.00406, "epss_percentile": 0.60543}, "CVE-2020-24631": {"epss_score": 0.03796, "epss_percentile": 0.87735}, "CVE-2020-24632": {"epss_score": 0.04723, "epss_percentile": 0.89057}, "CVE-2020-24633": {"epss_score": 0.01656, "epss_percentile": 0.816}, "CVE-2020-24634": {"epss_score": 0.003, "epss_percentile": 0.52934}, "CVE-2020-24635": {"epss_score": 0.05117, "epss_percentile": 0.89514}, "CVE-2020-24636": {"epss_score": 0.04513, "epss_percentile": 0.88783}, "CVE-2020-24637": {"epss_score": 0.00524, "epss_percentile": 0.66331}, "CVE-2020-24638": {"epss_score": 0.0272, "epss_percentile": 0.85515}, "CVE-2020-24639": {"epss_score": 0.00735, "epss_percentile": 0.72293}, "CVE-2020-24640": {"epss_score": 0.01195, "epss_percentile": 0.78429}, "CVE-2020-24641": {"epss_score": 0.00276, "epss_percentile": 0.50758}, "CVE-2020-24646": {"epss_score": 0.09172, "epss_percentile": 0.92431}, "CVE-2020-24647": {"epss_score": 0.02669, "epss_percentile": 0.85384}, "CVE-2020-24648": {"epss_score": 0.22097, "epss_percentile": 0.95595}, "CVE-2020-24649": {"epss_score": 0.02669, "epss_percentile": 0.85384}, "CVE-2020-24650": {"epss_score": 0.07205, "epss_percentile": 0.91321}, "CVE-2020-24651": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-24652": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-24653": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-24654": {"epss_score": 0.00835, "epss_percentile": 0.74124}, "CVE-2020-24655": {"epss_score": 0.00053, "epss_percentile": 0.16986}, "CVE-2020-24656": {"epss_score": 0.00588, "epss_percentile": 0.68503}, "CVE-2020-24658": {"epss_score": 0.00214, "epss_percentile": 0.4396}, "CVE-2020-24659": {"epss_score": 0.03396, "epss_percentile": 0.87059}, "CVE-2020-24660": {"epss_score": 0.00678, "epss_percentile": 0.70987}, "CVE-2020-24661": {"epss_score": 0.00251, "epss_percentile": 0.48259}, "CVE-2020-24662": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-24663": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-24664": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2020-24665": {"epss_score": 0.00671, "epss_percentile": 0.708}, "CVE-2020-24666": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2020-24667": {"epss_score": 0.00409, "epss_percentile": 0.60785}, "CVE-2020-24668": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-24669": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2020-24670": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2020-24671": {"epss_score": 0.00409, "epss_percentile": 0.60785}, "CVE-2020-24672": {"epss_score": 0.0015, "epss_percentile": 0.36088}, "CVE-2020-24673": {"epss_score": 0.00405, "epss_percentile": 0.60502}, "CVE-2020-24674": {"epss_score": 0.0418, "epss_percentile": 0.88356}, "CVE-2020-24675": {"epss_score": 0.00426, "epss_percentile": 0.61744}, "CVE-2020-24676": {"epss_score": 0.00042, "epss_percentile": 0.12598}, "CVE-2020-24677": {"epss_score": 0.01137, "epss_percentile": 0.77923}, "CVE-2020-24678": {"epss_score": 0.00618, "epss_percentile": 0.6937}, "CVE-2020-24679": {"epss_score": 0.00764, "epss_percentile": 0.72896}, "CVE-2020-24680": {"epss_score": 0.00037, "epss_percentile": 0.10968}, "CVE-2020-24681": {"epss_score": 0.00077, "epss_percentile": 0.2354}, "CVE-2020-24682": {"epss_score": 0.00048, "epss_percentile": 0.15273}, "CVE-2020-24683": {"epss_score": 0.00454, "epss_percentile": 0.63272}, "CVE-2020-24685": {"epss_score": 0.00804, "epss_percentile": 0.73625}, "CVE-2020-24686": {"epss_score": 0.00555, "epss_percentile": 0.67458}, "CVE-2020-24692": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2020-24693": {"epss_score": 0.00048, "epss_percentile": 0.1512}, "CVE-2020-24696": {"epss_score": 0.00075, "epss_percentile": 0.23033}, "CVE-2020-24697": {"epss_score": 0.00129, "epss_percentile": 0.33204}, "CVE-2020-24698": {"epss_score": 0.00033, "epss_percentile": 0.09405}, "CVE-2020-24699": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2020-24700": {"epss_score": 0.00295, "epss_percentile": 0.52444}, "CVE-2020-24701": {"epss_score": 0.35513, "epss_percentile": 0.96917}, "CVE-2020-24703": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2020-24704": {"epss_score": 0.00187, "epss_percentile": 0.40733}, "CVE-2020-24705": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2020-24706": {"epss_score": 0.00603, "epss_percentile": 0.68905}, "CVE-2020-24707": {"epss_score": 0.00168, "epss_percentile": 0.3841}, "CVE-2020-24708": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-24709": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-24710": {"epss_score": 0.00457, "epss_percentile": 0.63394}, "CVE-2020-24711": {"epss_score": 0.00486, "epss_percentile": 0.64741}, "CVE-2020-24712": {"epss_score": 0.0036, "epss_percentile": 0.57627}, "CVE-2020-24713": {"epss_score": 0.0036, "epss_percentile": 0.57649}, "CVE-2020-24714": {"epss_score": 0.00222, "epss_percentile": 0.4473}, "CVE-2020-24715": {"epss_score": 0.00203, "epss_percentile": 0.42513}, "CVE-2020-24716": {"epss_score": 0.00139, "epss_percentile": 0.34662}, "CVE-2020-24717": {"epss_score": 0.00154, "epss_percentile": 0.36696}, "CVE-2020-24718": {"epss_score": 0.00101, "epss_percentile": 0.28675}, "CVE-2020-24719": {"epss_score": 0.63523, "epss_percentile": 0.98336}, "CVE-2020-24721": {"epss_score": 0.00074, "epss_percentile": 0.22714}, "CVE-2020-24722": {"epss_score": 0.00318, "epss_percentile": 0.54403}, "CVE-2020-24723": {"epss_score": 0.00389, "epss_percentile": 0.59489}, "CVE-2020-24736": {"epss_score": 0.00026, "epss_percentile": 0.06521}, "CVE-2020-24739": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2020-24740": {"epss_score": 0.00117, "epss_percentile": 0.31307}, "CVE-2020-24742": {"epss_score": 0.00569, "epss_percentile": 0.67916}, "CVE-2020-24743": {"epss_score": 0.21242, "epss_percentile": 0.95484}, "CVE-2020-24750": {"epss_score": 0.01605, "epss_percentile": 0.81287}, "CVE-2020-24753": {"epss_score": 0.01295, "epss_percentile": 0.7925}, "CVE-2020-24755": {"epss_score": 0.00064, "epss_percentile": 0.2021}, "CVE-2020-24765": {"epss_score": 0.53277, "epss_percentile": 0.97869}, "CVE-2020-24769": {"epss_score": 0.01089, "epss_percentile": 0.77444}, "CVE-2020-24770": {"epss_score": 0.03887, "epss_percentile": 0.87906}, "CVE-2020-24771": {"epss_score": 0.01087, "epss_percentile": 0.77427}, "CVE-2020-24772": {"epss_score": 0.00121, "epss_percentile": 0.31823}, "CVE-2020-24786": {"epss_score": 0.0678, "epss_percentile": 0.91021}, "CVE-2020-24791": {"epss_score": 0.03558, "epss_percentile": 0.8735}, "CVE-2020-24794": {"epss_score": 0.0037, "epss_percentile": 0.58331}, "CVE-2020-24804": {"epss_score": 0.00169, "epss_percentile": 0.38634}, "CVE-2020-24807": {"epss_score": 0.00654, "epss_percentile": 0.7034}, "CVE-2020-24815": {"epss_score": 0.07537, "epss_percentile": 0.91523}, "CVE-2020-24821": {"epss_score": 0.00155, "epss_percentile": 0.36765}, "CVE-2020-24822": {"epss_score": 0.00169, "epss_percentile": 0.38609}, "CVE-2020-24823": {"epss_score": 0.00155, "epss_percentile": 0.36776}, "CVE-2020-24824": {"epss_score": 0.00161, "epss_percentile": 0.37612}, "CVE-2020-24825": {"epss_score": 0.00155, "epss_percentile": 0.36776}, "CVE-2020-24826": {"epss_score": 0.00155, "epss_percentile": 0.36776}, "CVE-2020-24827": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-24829": {"epss_score": 0.00133, "epss_percentile": 0.337}, "CVE-2020-24837": {"epss_score": 0.00484, "epss_percentile": 0.64631}, "CVE-2020-24838": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-24841": {"epss_score": 0.00419, "epss_percentile": 0.6138}, "CVE-2020-24842": {"epss_score": 0.00255, "epss_percentile": 0.48648}, "CVE-2020-24847": {"epss_score": 0.00138, "epss_percentile": 0.34519}, "CVE-2020-24848": {"epss_score": 0.0003, "epss_percentile": 0.07984}, "CVE-2020-24849": {"epss_score": 0.04767, "epss_percentile": 0.89123}, "CVE-2020-24855": {"epss_score": 0.00404, "epss_percentile": 0.60453}, "CVE-2020-24857": {"epss_score": 0.00524, "epss_percentile": 0.66314}, "CVE-2020-24860": {"epss_score": 0.00634, "epss_percentile": 0.69794}, "CVE-2020-24861": {"epss_score": 0.00353, "epss_percentile": 0.5716}, "CVE-2020-24862": {"epss_score": 0.00397, "epss_percentile": 0.59971}, "CVE-2020-24863": {"epss_score": 0.00098, "epss_percentile": 0.27804}, "CVE-2020-24870": {"epss_score": 0.00584, "epss_percentile": 0.68379}, "CVE-2020-24872": {"epss_score": 0.00299, "epss_percentile": 0.52861}, "CVE-2020-24876": {"epss_score": 0.00537, "epss_percentile": 0.66904}, "CVE-2020-24877": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2020-24881": {"epss_score": 0.90484, "epss_percentile": 0.99586}, "CVE-2020-24889": {"epss_score": 0.00931, "epss_percentile": 0.75621}, "CVE-2020-24890": {"epss_score": 0.00449, "epss_percentile": 0.63039}, "CVE-2020-24897": {"epss_score": 0.00294, "epss_percentile": 0.52393}, "CVE-2020-24898": {"epss_score": 0.00218, "epss_percentile": 0.44391}, "CVE-2020-24899": {"epss_score": 0.05677, "epss_percentile": 0.90113}, "CVE-2020-24900": {"epss_score": 0.00211, "epss_percentile": 0.43616}, "CVE-2020-24901": {"epss_score": 0.00085, "epss_percentile": 0.2522}, "CVE-2020-24902": {"epss_score": 0.01375, "epss_percentile": 0.79833}, "CVE-2020-24903": {"epss_score": 0.01341, "epss_percentile": 0.79586}, "CVE-2020-24904": {"epss_score": 0.00217, "epss_percentile": 0.44313}, "CVE-2020-24908": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2020-24912": {"epss_score": 0.21045, "epss_percentile": 0.95456}, "CVE-2020-24913": {"epss_score": 0.48144, "epss_percentile": 0.97623}, "CVE-2020-24914": {"epss_score": 0.37721, "epss_percentile": 0.97065}, "CVE-2020-24916": {"epss_score": 0.44255, "epss_percentile": 0.97426}, "CVE-2020-24917": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2020-24918": {"epss_score": 0.13031, "epss_percentile": 0.9385}, "CVE-2020-24922": {"epss_score": 0.01345, "epss_percentile": 0.79627}, "CVE-2020-24924": {"epss_score": 0.00258, "epss_percentile": 0.49004}, "CVE-2020-24925": {"epss_score": 0.00317, "epss_percentile": 0.54348}, "CVE-2020-24928": {"epss_score": 0.00206, "epss_percentile": 0.42787}, "CVE-2020-24930": {"epss_score": 0.00196, "epss_percentile": 0.41789}, "CVE-2020-24932": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2020-24939": {"epss_score": 0.00337, "epss_percentile": 0.56059}, "CVE-2020-24940": {"epss_score": 0.00261, "epss_percentile": 0.49271}, "CVE-2020-24941": {"epss_score": 0.00214, "epss_percentile": 0.43957}, "CVE-2020-24944": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-24948": {"epss_score": 0.28847, "epss_percentile": 0.96394}, "CVE-2020-24949": {"epss_score": 0.8889, "epss_percentile": 0.99498}, "CVE-2020-24950": {"epss_score": 0.03442, "epss_percentile": 0.87142}, "CVE-2020-24955": {"epss_score": 0.00035, "epss_percentile": 0.10159}, "CVE-2020-24963": {"epss_score": 0.00407, "epss_percentile": 0.6058}, "CVE-2020-24972": {"epss_score": 0.21343, "epss_percentile": 0.95503}, "CVE-2020-24977": {"epss_score": 0.00502, "epss_percentile": 0.65376}, "CVE-2020-24978": {"epss_score": 0.00413, "epss_percentile": 0.6101}, "CVE-2020-24981": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2020-24982": {"epss_score": 0.00239, "epss_percentile": 0.46914}, "CVE-2020-24983": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2020-24984": {"epss_score": 0.00339, "epss_percentile": 0.56208}, "CVE-2020-24985": {"epss_score": 0.00669, "epss_percentile": 0.70749}, "CVE-2020-24986": {"epss_score": 0.00733, "epss_percentile": 0.72206}, "CVE-2020-24987": {"epss_score": 0.0265, "epss_percentile": 0.85344}, "CVE-2020-24990": {"epss_score": 0.0304, "epss_percentile": 0.86273}, "CVE-2020-24992": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2020-24993": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2020-24994": {"epss_score": 0.01578, "epss_percentile": 0.81125}, "CVE-2020-24995": {"epss_score": 0.00223, "epss_percentile": 0.44966}, "CVE-2020-24996": {"epss_score": 0.00239, "epss_percentile": 0.46866}, "CVE-2020-24999": {"epss_score": 0.00258, "epss_percentile": 0.49005}, "CVE-2020-25004": {"epss_score": 0.01489, "epss_percentile": 0.80623}, "CVE-2020-25005": {"epss_score": 0.01489, "epss_percentile": 0.80623}, "CVE-2020-25006": {"epss_score": 0.01489, "epss_percentile": 0.80623}, "CVE-2020-25010": {"epss_score": 0.02481, "epss_percentile": 0.84874}, "CVE-2020-25011": {"epss_score": 0.00616, "epss_percentile": 0.69331}, "CVE-2020-25013": {"epss_score": 6e-05, "epss_percentile": 0.00238}, "CVE-2020-25014": {"epss_score": 0.01998, "epss_percentile": 0.83211}, "CVE-2020-25015": {"epss_score": 0.00289, "epss_percentile": 0.52072}, "CVE-2020-25016": {"epss_score": 0.00282, "epss_percentile": 0.51229}, "CVE-2020-25017": {"epss_score": 0.00053, "epss_percentile": 0.16985}, "CVE-2020-25018": {"epss_score": 0.02911, "epss_percentile": 0.85971}, "CVE-2020-25019": {"epss_score": 0.00145, "epss_percentile": 0.35488}, "CVE-2020-25020": {"epss_score": 0.01519, "epss_percentile": 0.80818}, "CVE-2020-25021": {"epss_score": 0.00633, "epss_percentile": 0.69772}, "CVE-2020-25022": {"epss_score": 0.00633, "epss_percentile": 0.69772}, "CVE-2020-25023": {"epss_score": 0.00633, "epss_percentile": 0.69772}, "CVE-2020-25025": {"epss_score": 0.00129, "epss_percentile": 0.33197}, "CVE-2020-25026": {"epss_score": 0.00197, "epss_percentile": 0.41875}, "CVE-2020-25031": {"epss_score": 0.00051, "epss_percentile": 0.16023}, "CVE-2020-25032": {"epss_score": 0.01251, "epss_percentile": 0.78895}, "CVE-2020-25033": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2020-25034": {"epss_score": 0.00175, "epss_percentile": 0.3937}, "CVE-2020-25035": {"epss_score": 0.00066, "epss_percentile": 0.20896}, "CVE-2020-25036": {"epss_score": 0.02089, "epss_percentile": 0.83561}, "CVE-2020-25037": {"epss_score": 0.00085, "epss_percentile": 0.25191}, "CVE-2020-25039": {"epss_score": 0.00815, "epss_percentile": 0.73786}, "CVE-2020-25040": {"epss_score": 0.00744, "epss_percentile": 0.72504}, "CVE-2020-25042": {"epss_score": 0.77043, "epss_percentile": 0.98918}, "CVE-2020-25043": {"epss_score": 0.00056, "epss_percentile": 0.17812}, "CVE-2020-25044": {"epss_score": 0.00052, "epss_percentile": 0.16613}, "CVE-2020-25045": {"epss_score": 0.00049, "epss_percentile": 0.15457}, "CVE-2020-25046": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2020-25047": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2020-25048": {"epss_score": 0.00021, "epss_percentile": 0.04785}, "CVE-2020-25049": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-25050": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2020-25051": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2020-25052": {"epss_score": 0.00175, "epss_percentile": 0.39344}, "CVE-2020-25053": {"epss_score": 0.00169, "epss_percentile": 0.38562}, "CVE-2020-25054": {"epss_score": 0.00562, "epss_percentile": 0.67699}, "CVE-2020-25055": {"epss_score": 0.00048, "epss_percentile": 0.14969}, "CVE-2020-25056": {"epss_score": 0.00134, "epss_percentile": 0.33847}, "CVE-2020-25057": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-25058": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-25059": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2020-25060": {"epss_score": 0.00015, "epss_percentile": 0.02186}, "CVE-2020-25061": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-25062": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-25063": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2020-25064": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2020-25065": {"epss_score": 0.00118, "epss_percentile": 0.31384}, "CVE-2020-25066": {"epss_score": 0.03745, "epss_percentile": 0.8766}, "CVE-2020-25067": {"epss_score": 0.01229, "epss_percentile": 0.78716}, "CVE-2020-25068": {"epss_score": 0.15194, "epss_percentile": 0.94382}, "CVE-2020-25069": {"epss_score": 0.00578, "epss_percentile": 0.68186}, "CVE-2020-25070": {"epss_score": 0.00214, "epss_percentile": 0.44004}, "CVE-2020-25071": {"epss_score": 0.00415, "epss_percentile": 0.61155}, "CVE-2020-25073": {"epss_score": 0.00622, "epss_percentile": 0.69501}, "CVE-2020-25074": {"epss_score": 0.12807, "epss_percentile": 0.9378}, "CVE-2020-25078": {"epss_score": 0.94229, "epss_percentile": 0.99921}, "CVE-2020-25079": {"epss_score": 0.4499, "epss_percentile": 0.97465}, "CVE-2020-25082": {"epss_score": 0.00059, "epss_percentile": 0.18757}, "CVE-2020-25084": {"epss_score": 0.00037, "epss_percentile": 0.10783}, "CVE-2020-25085": {"epss_score": 0.00039, "epss_percentile": 0.11669}, "CVE-2020-25086": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25087": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25088": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25089": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25090": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25091": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25092": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25093": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25094": {"epss_score": 0.12431, "epss_percentile": 0.93667}, "CVE-2020-25095": {"epss_score": 0.00374, "epss_percentile": 0.5854}, "CVE-2020-25096": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2020-25097": {"epss_score": 0.00583, "epss_percentile": 0.68342}, "CVE-2020-25102": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25104": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-25105": {"epss_score": 0.0034, "epss_percentile": 0.56277}, "CVE-2020-25106": {"epss_score": 0.00491, "epss_percentile": 0.64945}, "CVE-2020-25107": {"epss_score": 0.16481, "epss_percentile": 0.94677}, "CVE-2020-25108": {"epss_score": 0.1157, "epss_percentile": 0.93408}, "CVE-2020-25109": {"epss_score": 0.16481, "epss_percentile": 0.94677}, "CVE-2020-25110": {"epss_score": 0.16481, "epss_percentile": 0.94677}, "CVE-2020-25111": {"epss_score": 0.1157, "epss_percentile": 0.93408}, "CVE-2020-25112": {"epss_score": 0.16481, "epss_percentile": 0.94677}, "CVE-2020-25115": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-25116": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-25117": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-25118": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-25119": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-25120": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-25121": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-25122": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-25123": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-25124": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-25125": {"epss_score": 0.00334, "epss_percentile": 0.55686}, "CVE-2020-25130": {"epss_score": 0.00297, "epss_percentile": 0.52755}, "CVE-2020-25131": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25132": {"epss_score": 0.00351, "epss_percentile": 0.57009}, "CVE-2020-25133": {"epss_score": 0.01006, "epss_percentile": 0.76551}, "CVE-2020-25134": {"epss_score": 0.0352, "epss_percentile": 0.87283}, "CVE-2020-25135": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25136": {"epss_score": 0.01251, "epss_percentile": 0.78898}, "CVE-2020-25137": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25138": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25139": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25140": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-25141": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25142": {"epss_score": 0.00117, "epss_percentile": 0.31326}, "CVE-2020-25143": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2020-25144": {"epss_score": 0.01006, "epss_percentile": 0.76551}, "CVE-2020-25145": {"epss_score": 0.01006, "epss_percentile": 0.76551}, "CVE-2020-25146": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2020-25147": {"epss_score": 0.00366, "epss_percentile": 0.58079}, "CVE-2020-25148": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-25149": {"epss_score": 0.01006, "epss_percentile": 0.76551}, "CVE-2020-25150": {"epss_score": 0.0043, "epss_percentile": 0.62008}, "CVE-2020-25151": {"epss_score": 0.0035, "epss_percentile": 0.56968}, "CVE-2020-25152": {"epss_score": 0.00372, "epss_percentile": 0.58425}, "CVE-2020-25153": {"epss_score": 0.00177, "epss_percentile": 0.39507}, "CVE-2020-25154": {"epss_score": 0.00138, "epss_percentile": 0.34504}, "CVE-2020-25155": {"epss_score": 0.00114, "epss_percentile": 0.30778}, "CVE-2020-25156": {"epss_score": 0.0029, "epss_percentile": 0.52126}, "CVE-2020-25157": {"epss_score": 0.00191, "epss_percentile": 0.41178}, "CVE-2020-25158": {"epss_score": 0.00166, "epss_percentile": 0.38226}, "CVE-2020-25159": {"epss_score": 0.00504, "epss_percentile": 0.65518}, "CVE-2020-25160": {"epss_score": 0.00041, "epss_percentile": 0.12218}, "CVE-2020-25161": {"epss_score": 0.00625, "epss_percentile": 0.69591}, "CVE-2020-25162": {"epss_score": 0.00723, "epss_percentile": 0.72017}, "CVE-2020-25163": {"epss_score": 0.0024, "epss_percentile": 0.47196}, "CVE-2020-25164": {"epss_score": 0.00096, "epss_percentile": 0.27274}, "CVE-2020-25165": {"epss_score": 0.00207, "epss_percentile": 0.43202}, "CVE-2020-25166": {"epss_score": 0.00088, "epss_percentile": 0.25647}, "CVE-2020-25167": {"epss_score": 0.00134, "epss_percentile": 0.33904}, "CVE-2020-25168": {"epss_score": 0.00049, "epss_percentile": 0.15321}, "CVE-2020-25169": {"epss_score": 0.00114, "epss_percentile": 0.30778}, "CVE-2020-25170": {"epss_score": 0.00156, "epss_percentile": 0.37001}, "CVE-2020-25171": {"epss_score": 0.00265, "epss_percentile": 0.49801}, "CVE-2020-25172": {"epss_score": 0.00824, "epss_percentile": 0.7394}, "CVE-2020-25173": {"epss_score": 0.00039, "epss_percentile": 0.11673}, "CVE-2020-25174": {"epss_score": 0.00046, "epss_percentile": 0.14305}, "CVE-2020-25175": {"epss_score": 0.00235, "epss_percentile": 0.46341}, "CVE-2020-25176": {"epss_score": 0.02615, "epss_percentile": 0.85241}, "CVE-2020-25177": {"epss_score": 0.00848, "epss_percentile": 0.7436}, "CVE-2020-25178": {"epss_score": 0.00229, "epss_percentile": 0.45645}, "CVE-2020-25179": {"epss_score": 0.00221, "epss_percentile": 0.44714}, "CVE-2020-25180": {"epss_score": 0.00103, "epss_percentile": 0.2893}, "CVE-2020-25181": {"epss_score": 0.00848, "epss_percentile": 0.7436}, "CVE-2020-25182": {"epss_score": 0.00015, "epss_percentile": 0.02272}, "CVE-2020-25183": {"epss_score": 0.00103, "epss_percentile": 0.29042}, "CVE-2020-25184": {"epss_score": 0.00029, "epss_percentile": 0.07756}, "CVE-2020-25185": {"epss_score": 0.01036, "epss_percentile": 0.76915}, "CVE-2020-25186": {"epss_score": 0.00216, "epss_percentile": 0.44149}, "CVE-2020-25187": {"epss_score": 0.01274, "epss_percentile": 0.791}, "CVE-2020-25188": {"epss_score": 0.00193, "epss_percentile": 0.41385}, "CVE-2020-25189": {"epss_score": 0.0143, "epss_percentile": 0.8023}, "CVE-2020-25190": {"epss_score": 0.00093, "epss_percentile": 0.26709}, "CVE-2020-25191": {"epss_score": 0.00244, "epss_percentile": 0.47578}, "CVE-2020-25192": {"epss_score": 0.00166, "epss_percentile": 0.38225}, "CVE-2020-25193": {"epss_score": 0.0017, "epss_percentile": 0.38746}, "CVE-2020-25194": {"epss_score": 0.00155, "epss_percentile": 0.36853}, "CVE-2020-25195": {"epss_score": 0.00229, "epss_percentile": 0.45555}, "CVE-2020-25196": {"epss_score": 0.0011, "epss_percentile": 0.30226}, "CVE-2020-25197": {"epss_score": 0.03556, "epss_percentile": 0.87347}, "CVE-2020-25198": {"epss_score": 0.00189, "epss_percentile": 0.40957}, "CVE-2020-25199": {"epss_score": 0.00443, "epss_percentile": 0.6276}, "CVE-2020-25200": {"epss_score": 0.6809, "epss_percentile": 0.98531}, "CVE-2020-25201": {"epss_score": 0.01543, "epss_percentile": 0.80954}, "CVE-2020-25203": {"epss_score": 0.00071, "epss_percentile": 0.22211}, "CVE-2020-25204": {"epss_score": 0.00061, "epss_percentile": 0.19521}, "CVE-2020-25205": {"epss_score": 0.01028, "epss_percentile": 0.76823}, "CVE-2020-25206": {"epss_score": 0.17587, "epss_percentile": 0.94871}, "CVE-2020-25207": {"epss_score": 0.00035, "epss_percentile": 0.09806}, "CVE-2020-25208": {"epss_score": 2e-05, "epss_percentile": 0.00059}, "CVE-2020-25209": {"epss_score": 3e-05, "epss_percentile": 0.00092}, "CVE-2020-25210": {"epss_score": 3e-05, "epss_percentile": 0.00081}, "CVE-2020-25211": {"epss_score": 0.00146, "epss_percentile": 0.35593}, "CVE-2020-25212": {"epss_score": 0.00081, "epss_percentile": 0.24239}, "CVE-2020-25213": {"epss_score": 0.9442, "epss_percentile": 0.99978}, "CVE-2020-25214": {"epss_score": 0.00447, "epss_percentile": 0.62963}, "CVE-2020-25215": {"epss_score": 0.00492, "epss_percentile": 0.64985}, "CVE-2020-25216": {"epss_score": 0.0147, "epss_percentile": 0.80497}, "CVE-2020-25217": {"epss_score": 0.0309, "epss_percentile": 0.86393}, "CVE-2020-25218": {"epss_score": 0.00296, "epss_percentile": 0.52557}, "CVE-2020-25219": {"epss_score": 0.00587, "epss_percentile": 0.68465}, "CVE-2020-25220": {"epss_score": 0.00115, "epss_percentile": 0.30932}, "CVE-2020-25221": {"epss_score": 0.00193, "epss_percentile": 0.41446}, "CVE-2020-25223": {"epss_score": 0.94415, "epss_percentile": 0.99976}, "CVE-2020-25226": {"epss_score": 0.00825, "epss_percentile": 0.73955}, "CVE-2020-25228": {"epss_score": 0.00445, "epss_percentile": 0.62868}, "CVE-2020-25229": {"epss_score": 0.00153, "epss_percentile": 0.36552}, "CVE-2020-25230": {"epss_score": 0.001, "epss_percentile": 0.28534}, "CVE-2020-25231": {"epss_score": 0.00063, "epss_percentile": 0.20102}, "CVE-2020-25232": {"epss_score": 0.00187, "epss_percentile": 0.40713}, "CVE-2020-25233": {"epss_score": 0.00063, "epss_percentile": 0.20102}, "CVE-2020-25234": {"epss_score": 0.00121, "epss_percentile": 0.32001}, "CVE-2020-25235": {"epss_score": 0.00311, "epss_percentile": 0.53813}, "CVE-2020-25236": {"epss_score": 0.00103, "epss_percentile": 0.29035}, "CVE-2020-25237": {"epss_score": 0.01422, "epss_percentile": 0.80176}, "CVE-2020-25238": {"epss_score": 0.00085, "epss_percentile": 0.25176}, "CVE-2020-25239": {"epss_score": 0.00336, "epss_percentile": 0.55939}, "CVE-2020-25240": {"epss_score": 0.00336, "epss_percentile": 0.55939}, "CVE-2020-25241": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-25242": {"epss_score": 0.00147, "epss_percentile": 0.35779}, "CVE-2020-25243": {"epss_score": 0.00051, "epss_percentile": 0.16023}, "CVE-2020-25244": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2020-25245": {"epss_score": 0.00039, "epss_percentile": 0.11446}, "CVE-2020-25247": {"epss_score": 0.00604, "epss_percentile": 0.68959}, "CVE-2020-25248": {"epss_score": 0.00374, "epss_percentile": 0.5858}, "CVE-2020-25249": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-25250": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-25251": {"epss_score": 0.00247, "epss_percentile": 0.47829}, "CVE-2020-25252": {"epss_score": 0.00157, "epss_percentile": 0.37089}, "CVE-2020-25253": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-25254": {"epss_score": 0.00322, "epss_percentile": 0.54781}, "CVE-2020-25255": {"epss_score": 0.00563, "epss_percentile": 0.67718}, "CVE-2020-25256": {"epss_score": 0.00138, "epss_percentile": 0.34462}, "CVE-2020-25257": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2020-25258": {"epss_score": 0.0041, "epss_percentile": 0.60805}, "CVE-2020-25259": {"epss_score": 0.00329, "epss_percentile": 0.55321}, "CVE-2020-25260": {"epss_score": 0.02118, "epss_percentile": 0.83669}, "CVE-2020-25262": {"epss_score": 0.0014, "epss_percentile": 0.34766}, "CVE-2020-25263": {"epss_score": 0.00127, "epss_percentile": 0.32898}, "CVE-2020-25265": {"epss_score": 0.09185, "epss_percentile": 0.92436}, "CVE-2020-25266": {"epss_score": 0.00089, "epss_percentile": 0.25893}, "CVE-2020-25267": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-25268": {"epss_score": 0.02713, "epss_percentile": 0.85503}, "CVE-2020-25269": {"epss_score": 0.00669, "epss_percentile": 0.70768}, "CVE-2020-25270": {"epss_score": 0.00283, "epss_percentile": 0.51356}, "CVE-2020-25271": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2020-25272": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2020-25273": {"epss_score": 0.01068, "epss_percentile": 0.77236}, "CVE-2020-25275": {"epss_score": 0.06847, "epss_percentile": 0.91069}, "CVE-2020-25276": {"epss_score": 0.00152, "epss_percentile": 0.36436}, "CVE-2020-25278": {"epss_score": 0.00187, "epss_percentile": 0.40754}, "CVE-2020-25279": {"epss_score": 0.00245, "epss_percentile": 0.47643}, "CVE-2020-25280": {"epss_score": 0.00042, "epss_percentile": 0.12492}, "CVE-2020-25281": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2020-25282": {"epss_score": 0.00129, "epss_percentile": 0.33211}, "CVE-2020-25283": {"epss_score": 0.00129, "epss_percentile": 0.33211}, "CVE-2020-25284": {"epss_score": 0.00077, "epss_percentile": 0.23306}, "CVE-2020-25285": {"epss_score": 0.00084, "epss_percentile": 0.24994}, "CVE-2020-25286": {"epss_score": 0.0058, "epss_percentile": 0.68256}, "CVE-2020-25287": {"epss_score": 0.06351, "epss_percentile": 0.90691}, "CVE-2020-25288": {"epss_score": 0.00745, "epss_percentile": 0.72529}, "CVE-2020-25289": {"epss_score": 0.0004, "epss_percentile": 0.1188}, "CVE-2020-25291": {"epss_score": 0.0115, "epss_percentile": 0.78029}, "CVE-2020-25340": {"epss_score": 0.00048, "epss_percentile": 0.1519}, "CVE-2020-25343": {"epss_score": 0.00132, "epss_percentile": 0.33549}, "CVE-2020-25351": {"epss_score": 0.00059, "epss_percentile": 0.18871}, "CVE-2020-25352": {"epss_score": 0.02348, "epss_percentile": 0.84459}, "CVE-2020-25353": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2020-25359": {"epss_score": 0.01419, "epss_percentile": 0.80164}, "CVE-2020-25362": {"epss_score": 0.01298, "epss_percentile": 0.79271}, "CVE-2020-25366": {"epss_score": 0.00549, "epss_percentile": 0.67322}, "CVE-2020-25367": {"epss_score": 0.23952, "epss_percentile": 0.95837}, "CVE-2020-25368": {"epss_score": 0.34398, "epss_percentile": 0.96846}, "CVE-2020-25374": {"epss_score": 0.00157, "epss_percentile": 0.37095}, "CVE-2020-25375": {"epss_score": 0.00178, "epss_percentile": 0.39652}, "CVE-2020-25378": {"epss_score": 0.00207, "epss_percentile": 0.43167}, "CVE-2020-25379": {"epss_score": 0.02433, "epss_percentile": 0.84731}, "CVE-2020-25380": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2020-25385": {"epss_score": 0.40411, "epss_percentile": 0.97217}, "CVE-2020-25391": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-25392": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-25394": {"epss_score": 0.00352, "epss_percentile": 0.57101}, "CVE-2020-25398": {"epss_score": 0.09532, "epss_percentile": 0.92588}, "CVE-2020-25399": {"epss_score": 0.00318, "epss_percentile": 0.54425}, "CVE-2020-25400": {"epss_score": 0.0033, "epss_percentile": 0.55493}, "CVE-2020-25406": {"epss_score": 0.00282, "epss_percentile": 0.51227}, "CVE-2020-25408": {"epss_score": 0.00178, "epss_percentile": 0.397}, "CVE-2020-25409": {"epss_score": 0.00683, "epss_percentile": 0.71093}, "CVE-2020-25411": {"epss_score": 0.00209, "epss_percentile": 0.43426}, "CVE-2020-25412": {"epss_score": 0.00614, "epss_percentile": 0.69275}, "CVE-2020-25414": {"epss_score": 0.01569, "epss_percentile": 0.8108}, "CVE-2020-25422": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-25427": {"epss_score": 0.00122, "epss_percentile": 0.32069}, "CVE-2020-25444": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2020-25445": {"epss_score": 0.00203, "epss_percentile": 0.42522}, "CVE-2020-25449": {"epss_score": 0.00522, "epss_percentile": 0.66265}, "CVE-2020-25453": {"epss_score": 0.00263, "epss_percentile": 0.49504}, "CVE-2020-25454": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2020-25459": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-25461": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-25462": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2020-25463": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-25464": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2020-25465": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2020-25466": {"epss_score": 0.01305, "epss_percentile": 0.79323}, "CVE-2020-25467": {"epss_score": 0.00087, "epss_percentile": 0.25579}, "CVE-2020-25470": {"epss_score": 0.00497, "epss_percentile": 0.65199}, "CVE-2020-25472": {"epss_score": 0.00193, "epss_percentile": 0.4145}, "CVE-2020-25473": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2020-25474": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2020-25475": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2020-25476": {"epss_score": 0.0045, "epss_percentile": 0.631}, "CVE-2020-25483": {"epss_score": 0.49111, "epss_percentile": 0.97667}, "CVE-2020-25487": {"epss_score": 0.00247, "epss_percentile": 0.4785}, "CVE-2020-25489": {"epss_score": 0.01073, "epss_percentile": 0.7729}, "CVE-2020-25490": {"epss_score": 0.00775, "epss_percentile": 0.73092}, "CVE-2020-25491": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2020-25493": {"epss_score": 0.00158, "epss_percentile": 0.37255}, "CVE-2020-25494": {"epss_score": 0.60567, "epss_percentile": 0.98211}, "CVE-2020-25495": {"epss_score": 0.01421, "epss_percentile": 0.80173}, "CVE-2020-25498": {"epss_score": 0.00295, "epss_percentile": 0.52519}, "CVE-2020-25499": {"epss_score": 0.10752, "epss_percentile": 0.93093}, "CVE-2020-25502": {"epss_score": 0.00057, "epss_percentile": 0.18202}, "CVE-2020-25506": {"epss_score": 0.9384, "epss_percentile": 0.99854}, "CVE-2020-25507": {"epss_score": 0.001, "epss_percentile": 0.28521}, "CVE-2020-25514": {"epss_score": 0.00289, "epss_percentile": 0.52037}, "CVE-2020-25515": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2020-25516": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-25533": {"epss_score": 0.00037, "epss_percentile": 0.10673}, "CVE-2020-25537": {"epss_score": 0.00398, "epss_percentile": 0.60072}, "CVE-2020-25538": {"epss_score": 0.04517, "epss_percentile": 0.88792}, "CVE-2020-25540": {"epss_score": 0.94093, "epss_percentile": 0.999}, "CVE-2020-25557": {"epss_score": 0.06009, "epss_percentile": 0.90402}, "CVE-2020-25559": {"epss_score": 0.00395, "epss_percentile": 0.59843}, "CVE-2020-25560": {"epss_score": 0.00874, "epss_percentile": 0.74757}, "CVE-2020-25561": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2020-25562": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2020-25563": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2020-25564": {"epss_score": 0.0031, "epss_percentile": 0.53799}, "CVE-2020-25565": {"epss_score": 0.00874, "epss_percentile": 0.74757}, "CVE-2020-25566": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2020-25573": {"epss_score": 0.00595, "epss_percentile": 0.68678}, "CVE-2020-25574": {"epss_score": 0.01814, "epss_percentile": 0.82382}, "CVE-2020-25575": {"epss_score": 0.00619, "epss_percentile": 0.69426}, "CVE-2020-25576": {"epss_score": 0.00544, "epss_percentile": 0.67148}, "CVE-2020-25577": {"epss_score": 0.0058, "epss_percentile": 0.68259}, "CVE-2020-25578": {"epss_score": 0.06549, "epss_percentile": 0.90842}, "CVE-2020-25579": {"epss_score": 0.00339, "epss_percentile": 0.56198}, "CVE-2020-25580": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-25581": {"epss_score": 0.00519, "epss_percentile": 0.6618}, "CVE-2020-25582": {"epss_score": 0.0039, "epss_percentile": 0.59544}, "CVE-2020-25583": {"epss_score": 0.00477, "epss_percentile": 0.64345}, "CVE-2020-25584": {"epss_score": 0.00038, "epss_percentile": 0.11074}, "CVE-2020-25592": {"epss_score": 0.44938, "epss_percentile": 0.97461}, "CVE-2020-25593": {"epss_score": 0.00022, "epss_percentile": 0.05065}, "CVE-2020-25594": {"epss_score": 0.00481, "epss_percentile": 0.64489}, "CVE-2020-25595": {"epss_score": 0.00088, "epss_percentile": 0.25693}, "CVE-2020-25596": {"epss_score": 0.00086, "epss_percentile": 0.25349}, "CVE-2020-25597": {"epss_score": 0.00109, "epss_percentile": 0.29933}, "CVE-2020-25598": {"epss_score": 0.00073, "epss_percentile": 0.22596}, "CVE-2020-25599": {"epss_score": 0.00074, "epss_percentile": 0.2274}, "CVE-2020-25600": {"epss_score": 0.001, "epss_percentile": 0.28533}, "CVE-2020-25601": {"epss_score": 0.00076, "epss_percentile": 0.23131}, "CVE-2020-25602": {"epss_score": 0.00081, "epss_percentile": 0.24305}, "CVE-2020-25603": {"epss_score": 0.00072, "epss_percentile": 0.22387}, "CVE-2020-25604": {"epss_score": 0.00071, "epss_percentile": 0.2223}, "CVE-2020-25605": {"epss_score": 0.01019, "epss_percentile": 0.76729}, "CVE-2020-25606": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-25608": {"epss_score": 0.00381, "epss_percentile": 0.59005}, "CVE-2020-25609": {"epss_score": 0.00497, "epss_percentile": 0.65206}, "CVE-2020-25610": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2020-25611": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-25612": {"epss_score": 0.00296, "epss_percentile": 0.52579}, "CVE-2020-25613": {"epss_score": 0.00271, "epss_percentile": 0.50319}, "CVE-2020-25614": {"epss_score": 0.00444, "epss_percentile": 0.62815}, "CVE-2020-25617": {"epss_score": 0.10972, "epss_percentile": 0.9318}, "CVE-2020-25618": {"epss_score": 0.02628, "epss_percentile": 0.85273}, "CVE-2020-25619": {"epss_score": 0.00799, "epss_percentile": 0.73521}, "CVE-2020-25620": {"epss_score": 0.00344, "epss_percentile": 0.56496}, "CVE-2020-25621": {"epss_score": 0.00212, "epss_percentile": 0.43761}, "CVE-2020-25622": {"epss_score": 0.02629, "epss_percentile": 0.85275}, "CVE-2020-25623": {"epss_score": 0.00934, "epss_percentile": 0.75654}, "CVE-2020-25624": {"epss_score": 0.00034, "epss_percentile": 0.09633}, "CVE-2020-25625": {"epss_score": 0.00147, "epss_percentile": 0.35673}, "CVE-2020-25626": {"epss_score": 0.00715, "epss_percentile": 0.71838}, "CVE-2020-25627": {"epss_score": 0.05353, "epss_percentile": 0.89776}, "CVE-2020-25628": {"epss_score": 0.00249, "epss_percentile": 0.48074}, "CVE-2020-25629": {"epss_score": 0.00554, "epss_percentile": 0.67453}, "CVE-2020-25630": {"epss_score": 0.00497, "epss_percentile": 0.65182}, "CVE-2020-25631": {"epss_score": 0.0034, "epss_percentile": 0.56229}, "CVE-2020-25632": {"epss_score": 0.00014, "epss_percentile": 0.01742}, "CVE-2020-25633": {"epss_score": 0.00276, "epss_percentile": 0.50771}, "CVE-2020-25634": {"epss_score": 0.00109, "epss_percentile": 0.29953}, "CVE-2020-25635": {"epss_score": 0.00136, "epss_percentile": 0.34059}, "CVE-2020-25636": {"epss_score": 0.00129, "epss_percentile": 0.33094}, "CVE-2020-25637": {"epss_score": 0.00097, "epss_percentile": 0.27482}, "CVE-2020-25638": {"epss_score": 0.00519, "epss_percentile": 0.66178}, "CVE-2020-25639": {"epss_score": 0.0013, "epss_percentile": 0.33271}, "CVE-2020-25640": {"epss_score": 0.00354, "epss_percentile": 0.57227}, "CVE-2020-25641": {"epss_score": 0.0006, "epss_percentile": 0.18979}, "CVE-2020-25643": {"epss_score": 0.00423, "epss_percentile": 0.61594}, "CVE-2020-25644": {"epss_score": 0.00465, "epss_percentile": 0.63746}, "CVE-2020-25645": {"epss_score": 0.00359, "epss_percentile": 0.57604}, "CVE-2020-25646": {"epss_score": 0.00496, "epss_percentile": 0.65135}, "CVE-2020-25647": {"epss_score": 9e-05, "epss_percentile": 0.00661}, "CVE-2020-25648": {"epss_score": 0.00091, "epss_percentile": 0.26211}, "CVE-2020-25649": {"epss_score": 0.00018, "epss_percentile": 0.03717}, "CVE-2020-25650": {"epss_score": 0.00153, "epss_percentile": 0.36582}, "CVE-2020-25651": {"epss_score": 0.00115, "epss_percentile": 0.30925}, "CVE-2020-25652": {"epss_score": 0.0021, "epss_percentile": 0.43589}, "CVE-2020-25653": {"epss_score": 0.00113, "epss_percentile": 0.30659}, "CVE-2020-25654": {"epss_score": 0.00086, "epss_percentile": 0.25385}, "CVE-2020-25655": {"epss_score": 0.00212, "epss_percentile": 0.43814}, "CVE-2020-25656": {"epss_score": 0.0001, "epss_percentile": 0.00881}, "CVE-2020-25657": {"epss_score": 0.00407, "epss_percentile": 0.60588}, "CVE-2020-25658": {"epss_score": 0.00233, "epss_percentile": 0.46002}, "CVE-2020-25659": {"epss_score": 0.00252, "epss_percentile": 0.48414}, "CVE-2020-25660": {"epss_score": 0.00274, "epss_percentile": 0.50535}, "CVE-2020-25661": {"epss_score": 0.02091, "epss_percentile": 0.83572}, "CVE-2020-25662": {"epss_score": 0.00756, "epss_percentile": 0.72729}, "CVE-2020-25663": {"epss_score": 0.0017, "epss_percentile": 0.38678}, "CVE-2020-25664": {"epss_score": 0.00087, "epss_percentile": 0.25532}, "CVE-2020-25665": {"epss_score": 0.00313, "epss_percentile": 0.54066}, "CVE-2020-25666": {"epss_score": 0.00127, "epss_percentile": 0.32831}, "CVE-2020-25667": {"epss_score": 0.00108, "epss_percentile": 0.29818}, "CVE-2020-25668": {"epss_score": 0.00132, "epss_percentile": 0.33614}, "CVE-2020-25669": {"epss_score": 0.00138, "epss_percentile": 0.34501}, "CVE-2020-25670": {"epss_score": 0.00216, "epss_percentile": 0.44126}, "CVE-2020-25671": {"epss_score": 0.00131, "epss_percentile": 0.33405}, "CVE-2020-25672": {"epss_score": 0.02294, "epss_percentile": 0.84291}, "CVE-2020-25673": {"epss_score": 0.00126, "epss_percentile": 0.32773}, "CVE-2020-25674": {"epss_score": 0.00313, "epss_percentile": 0.54066}, "CVE-2020-25675": {"epss_score": 0.00127, "epss_percentile": 0.32831}, "CVE-2020-25676": {"epss_score": 0.00231, "epss_percentile": 0.45774}, "CVE-2020-25677": {"epss_score": 0.0002, "epss_percentile": 0.04614}, "CVE-2020-25678": {"epss_score": 0.00015, "epss_percentile": 0.02252}, "CVE-2020-25680": {"epss_score": 0.00079, "epss_percentile": 0.23857}, "CVE-2020-25681": {"epss_score": 0.20274, "epss_percentile": 0.95312}, "CVE-2020-25682": {"epss_score": 0.34287, "epss_percentile": 0.96839}, "CVE-2020-25683": {"epss_score": 0.31317, "epss_percentile": 0.96608}, "CVE-2020-25684": {"epss_score": 0.00271, "epss_percentile": 0.5032}, "CVE-2020-25685": {"epss_score": 0.00329, "epss_percentile": 0.5531}, "CVE-2020-25686": {"epss_score": 0.0046, "epss_percentile": 0.63529}, "CVE-2020-25687": {"epss_score": 0.2325, "epss_percentile": 0.95757}, "CVE-2020-25688": {"epss_score": 0.0003, "epss_percentile": 0.08292}, "CVE-2020-25689": {"epss_score": 0.00238, "epss_percentile": 0.46761}, "CVE-2020-25690": {"epss_score": 0.00838, "epss_percentile": 0.74179}, "CVE-2020-25691": {"epss_score": 0.00471, "epss_percentile": 0.64025}, "CVE-2020-25692": {"epss_score": 0.01215, "epss_percentile": 0.78586}, "CVE-2020-25693": {"epss_score": 0.00465, "epss_percentile": 0.63752}, "CVE-2020-25694": {"epss_score": 0.00359, "epss_percentile": 0.57596}, "CVE-2020-25695": {"epss_score": 0.22672, "epss_percentile": 0.95669}, "CVE-2020-25696": {"epss_score": 0.00199, "epss_percentile": 0.42138}, "CVE-2020-25697": {"epss_score": 0.00063, "epss_percentile": 0.20088}, "CVE-2020-25698": {"epss_score": 0.00701, "epss_percentile": 0.71498}, "CVE-2020-25699": {"epss_score": 0.00344, "epss_percentile": 0.56531}, "CVE-2020-25700": {"epss_score": 0.00452, "epss_percentile": 0.63161}, "CVE-2020-25701": {"epss_score": 0.00344, "epss_percentile": 0.56531}, "CVE-2020-25702": {"epss_score": 0.00367, "epss_percentile": 0.5811}, "CVE-2020-25703": {"epss_score": 0.00313, "epss_percentile": 0.54036}, "CVE-2020-25704": {"epss_score": 0.0006, "epss_percentile": 0.19235}, "CVE-2020-25705": {"epss_score": 0.01063, "epss_percentile": 0.77187}, "CVE-2020-25706": {"epss_score": 0.01582, "epss_percentile": 0.81142}, "CVE-2020-25708": {"epss_score": 0.00784, "epss_percentile": 0.73236}, "CVE-2020-25709": {"epss_score": 0.15603, "epss_percentile": 0.94468}, "CVE-2020-25710": {"epss_score": 0.08394, "epss_percentile": 0.92029}, "CVE-2020-25711": {"epss_score": 0.00183, "epss_percentile": 0.40297}, "CVE-2020-25712": {"epss_score": 0.00134, "epss_percentile": 0.33858}, "CVE-2020-25713": {"epss_score": 0.00512, "epss_percentile": 0.65852}, "CVE-2020-25715": {"epss_score": 0.00356, "epss_percentile": 0.57369}, "CVE-2020-25716": {"epss_score": 0.00157, "epss_percentile": 0.37117}, "CVE-2020-25717": {"epss_score": 0.00186, "epss_percentile": 0.40649}, "CVE-2020-25718": {"epss_score": 0.00132, "epss_percentile": 0.33539}, "CVE-2020-25719": {"epss_score": 0.00238, "epss_percentile": 0.46764}, "CVE-2020-25720": {"epss_score": 0.00281, "epss_percentile": 0.51107}, "CVE-2020-25721": {"epss_score": 0.00187, "epss_percentile": 0.40747}, "CVE-2020-25722": {"epss_score": 0.00382, "epss_percentile": 0.59058}, "CVE-2020-25723": {"epss_score": 0.00036, "epss_percentile": 0.10283}, "CVE-2020-25724": {"epss_score": 0.00132, "epss_percentile": 0.33568}, "CVE-2020-25725": {"epss_score": 0.00181, "epss_percentile": 0.40079}, "CVE-2020-25727": {"epss_score": 0.00296, "epss_percentile": 0.52581}, "CVE-2020-25728": {"epss_score": 0.00349, "epss_percentile": 0.56857}, "CVE-2020-25729": {"epss_score": 0.00528, "epss_percentile": 0.66542}, "CVE-2020-25730": {"epss_score": 0.0021, "epss_percentile": 0.43449}, "CVE-2020-25733": {"epss_score": 0.00337, "epss_percentile": 0.5605}, "CVE-2020-25734": {"epss_score": 0.00394, "epss_percentile": 0.59777}, "CVE-2020-25735": {"epss_score": 0.00264, "epss_percentile": 0.4971}, "CVE-2020-25736": {"epss_score": 0.20185, "epss_percentile": 0.95301}, "CVE-2020-25737": {"epss_score": 0.0005, "epss_percentile": 0.15965}, "CVE-2020-25738": {"epss_score": 0.0006, "epss_percentile": 0.1911}, "CVE-2020-25739": {"epss_score": 0.00564, "epss_percentile": 0.67748}, "CVE-2020-25741": {"epss_score": 0.00182, "epss_percentile": 0.40184}, "CVE-2020-25742": {"epss_score": 0.00044, "epss_percentile": 0.1342}, "CVE-2020-25743": {"epss_score": 0.00044, "epss_percentile": 0.1342}, "CVE-2020-25744": {"epss_score": 0.00384, "epss_percentile": 0.59158}, "CVE-2020-25746": {"epss_score": 0.00041, "epss_percentile": 0.12305}, "CVE-2020-25747": {"epss_score": 0.02151, "epss_percentile": 0.83788}, "CVE-2020-25748": {"epss_score": 0.00222, "epss_percentile": 0.44741}, "CVE-2020-25749": {"epss_score": 0.03944, "epss_percentile": 0.87992}, "CVE-2020-25750": {"epss_score": 0.0036, "epss_percentile": 0.57649}, "CVE-2020-25751": {"epss_score": 0.00316, "epss_percentile": 0.54236}, "CVE-2020-25752": {"epss_score": 0.00792, "epss_percentile": 0.73412}, "CVE-2020-25753": {"epss_score": 0.01676, "epss_percentile": 0.81706}, "CVE-2020-25754": {"epss_score": 0.00354, "epss_percentile": 0.57247}, "CVE-2020-25755": {"epss_score": 0.03118, "epss_percentile": 0.8644}, "CVE-2020-25756": {"epss_score": 0.00913, "epss_percentile": 0.75375}, "CVE-2020-25757": {"epss_score": 0.00518, "epss_percentile": 0.66125}, "CVE-2020-25758": {"epss_score": 0.00268, "epss_percentile": 0.50042}, "CVE-2020-25759": {"epss_score": 0.01453, "epss_percentile": 0.80376}, "CVE-2020-25760": {"epss_score": 0.00366, "epss_percentile": 0.58061}, "CVE-2020-25761": {"epss_score": 0.00434, "epss_percentile": 0.62318}, "CVE-2020-25762": {"epss_score": 0.17864, "epss_percentile": 0.94919}, "CVE-2020-25763": {"epss_score": 0.12138, "epss_percentile": 0.93582}, "CVE-2020-25765": {"epss_score": 0.08311, "epss_percentile": 0.91985}, "CVE-2020-25766": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-25767": {"epss_score": 0.00391, "epss_percentile": 0.59588}, "CVE-2020-25768": {"epss_score": 0.0031, "epss_percentile": 0.53772}, "CVE-2020-25770": {"epss_score": 0.00111, "epss_percentile": 0.30297}, "CVE-2020-25771": {"epss_score": 0.00111, "epss_percentile": 0.30297}, "CVE-2020-25772": {"epss_score": 0.00111, "epss_percentile": 0.30297}, "CVE-2020-25773": {"epss_score": 0.00528, "epss_percentile": 0.66566}, "CVE-2020-25774": {"epss_score": 0.00295, "epss_percentile": 0.5245}, "CVE-2020-25775": {"epss_score": 0.00062, "epss_percentile": 0.19572}, "CVE-2020-25776": {"epss_score": 0.00138, "epss_percentile": 0.34444}, "CVE-2020-25777": {"epss_score": 0.00258, "epss_percentile": 0.48968}, "CVE-2020-25778": {"epss_score": 0.00113, "epss_percentile": 0.30647}, "CVE-2020-25779": {"epss_score": 0.00075, "epss_percentile": 0.22957}, "CVE-2020-25780": {"epss_score": 0.63364, "epss_percentile": 0.9833}, "CVE-2020-25781": {"epss_score": 0.00258, "epss_percentile": 0.48966}, "CVE-2020-25782": {"epss_score": 0.20473, "epss_percentile": 0.95352}, "CVE-2020-25783": {"epss_score": 0.02053, "epss_percentile": 0.83415}, "CVE-2020-25784": {"epss_score": 0.02053, "epss_percentile": 0.83415}, "CVE-2020-25785": {"epss_score": 0.01903, "epss_percentile": 0.82785}, "CVE-2020-25786": {"epss_score": 0.00678, "epss_percentile": 0.70983}, "CVE-2020-25787": {"epss_score": 0.13768, "epss_percentile": 0.94055}, "CVE-2020-25788": {"epss_score": 0.00619, "epss_percentile": 0.69436}, "CVE-2020-25789": {"epss_score": 0.00528, "epss_percentile": 0.66542}, "CVE-2020-25790": {"epss_score": 0.41166, "epss_percentile": 0.97256}, "CVE-2020-25791": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2020-25792": {"epss_score": 0.00406, "epss_percentile": 0.60552}, "CVE-2020-25793": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2020-25794": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2020-25795": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2020-25796": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2020-25797": {"epss_score": 0.00263, "epss_percentile": 0.49517}, "CVE-2020-25798": {"epss_score": 0.00261, "epss_percentile": 0.49303}, "CVE-2020-25799": {"epss_score": 0.00263, "epss_percentile": 0.49517}, "CVE-2020-25802": {"epss_score": 0.00434, "epss_percentile": 0.62318}, "CVE-2020-25803": {"epss_score": 0.00655, "epss_percentile": 0.70419}, "CVE-2020-25812": {"epss_score": 0.00371, "epss_percentile": 0.58385}, "CVE-2020-25813": {"epss_score": 0.00366, "epss_percentile": 0.58075}, "CVE-2020-25814": {"epss_score": 0.00336, "epss_percentile": 0.55934}, "CVE-2020-25815": {"epss_score": 0.00387, "epss_percentile": 0.59293}, "CVE-2020-25816": {"epss_score": 0.00435, "epss_percentile": 0.62373}, "CVE-2020-25817": {"epss_score": 0.00348, "epss_percentile": 0.56841}, "CVE-2020-25820": {"epss_score": 0.0395, "epss_percentile": 0.87999}, "CVE-2020-25821": {"epss_score": 0.00435, "epss_percentile": 0.62332}, "CVE-2020-25824": {"epss_score": 0.00083, "epss_percentile": 0.24754}, "CVE-2020-25825": {"epss_score": 0.00378, "epss_percentile": 0.58794}, "CVE-2020-25826": {"epss_score": 0.00031, "epss_percentile": 0.08393}, "CVE-2020-25827": {"epss_score": 0.00239, "epss_percentile": 0.46886}, "CVE-2020-25828": {"epss_score": 0.00387, "epss_percentile": 0.59293}, "CVE-2020-25829": {"epss_score": 0.00348, "epss_percentile": 0.56847}, "CVE-2020-25830": {"epss_score": 0.00596, "epss_percentile": 0.68716}, "CVE-2020-25832": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-25833": {"epss_score": 0.00207, "epss_percentile": 0.43195}, "CVE-2020-25834": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-25835": {"epss_score": 0.00053, "epss_percentile": 0.16822}, "CVE-2020-25836": {"epss_score": 0.00162, "epss_percentile": 0.37732}, "CVE-2020-25837": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-25838": {"epss_score": 0.00288, "epss_percentile": 0.51882}, "CVE-2020-25839": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-25840": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-25842": {"epss_score": 0.00083, "epss_percentile": 0.24723}, "CVE-2020-25843": {"epss_score": 0.0251, "epss_percentile": 0.84948}, "CVE-2020-25844": {"epss_score": 0.0251, "epss_percentile": 0.84948}, "CVE-2020-25845": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2020-25846": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2020-25847": {"epss_score": 0.01501, "epss_percentile": 0.80716}, "CVE-2020-25848": {"epss_score": 0.00263, "epss_percentile": 0.49546}, "CVE-2020-25849": {"epss_score": 0.02985, "epss_percentile": 0.86129}, "CVE-2020-25850": {"epss_score": 0.0036, "epss_percentile": 0.57687}, "CVE-2020-25853": {"epss_score": 0.0013, "epss_percentile": 0.33237}, "CVE-2020-25854": {"epss_score": 0.01096, "epss_percentile": 0.77524}, "CVE-2020-25855": {"epss_score": 0.01864, "epss_percentile": 0.82601}, "CVE-2020-25856": {"epss_score": 0.01096, "epss_percentile": 0.77524}, "CVE-2020-25857": {"epss_score": 0.00151, "epss_percentile": 0.36367}, "CVE-2020-25858": {"epss_score": 0.02718, "epss_percentile": 0.85513}, "CVE-2020-25859": {"epss_score": 0.0008, "epss_percentile": 0.24115}, "CVE-2020-25860": {"epss_score": 0.00493, "epss_percentile": 0.65034}, "CVE-2020-25862": {"epss_score": 0.00297, "epss_percentile": 0.52702}, "CVE-2020-25863": {"epss_score": 0.00246, "epss_percentile": 0.47741}, "CVE-2020-25864": {"epss_score": 0.85106, "epss_percentile": 0.99318}, "CVE-2020-25866": {"epss_score": 0.00972, "epss_percentile": 0.76137}, "CVE-2020-25867": {"epss_score": 0.31321, "epss_percentile": 0.96609}, "CVE-2020-25868": {"epss_score": 0.00488, "epss_percentile": 0.64859}, "CVE-2020-25869": {"epss_score": 0.00274, "epss_percentile": 0.50544}, "CVE-2020-25872": {"epss_score": 0.0045, "epss_percentile": 0.63059}, "CVE-2020-25873": {"epss_score": 0.00392, "epss_percentile": 0.59679}, "CVE-2020-25875": {"epss_score": 0.00287, "epss_percentile": 0.51854}, "CVE-2020-25876": {"epss_score": 0.00287, "epss_percentile": 0.51854}, "CVE-2020-25877": {"epss_score": 0.00287, "epss_percentile": 0.51854}, "CVE-2020-25878": {"epss_score": 0.00328, "epss_percentile": 0.55294}, "CVE-2020-25879": {"epss_score": 0.00287, "epss_percentile": 0.51854}, "CVE-2020-25881": {"epss_score": 0.01459, "epss_percentile": 0.80411}, "CVE-2020-25887": {"epss_score": 0.00226, "epss_percentile": 0.45284}, "CVE-2020-25889": {"epss_score": 0.0138, "epss_percentile": 0.79864}, "CVE-2020-25890": {"epss_score": 0.00187, "epss_percentile": 0.40708}, "CVE-2020-25901": {"epss_score": 0.02296, "epss_percentile": 0.84297}, "CVE-2020-25902": {"epss_score": 0.00373, "epss_percentile": 0.58521}, "CVE-2020-25905": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2020-25911": {"epss_score": 0.00961, "epss_percentile": 0.7598}, "CVE-2020-25912": {"epss_score": 0.00269, "epss_percentile": 0.50106}, "CVE-2020-25915": {"epss_score": 0.00428, "epss_percentile": 0.61922}, "CVE-2020-25917": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2020-25925": {"epss_score": 0.00195, "epss_percentile": 0.41601}, "CVE-2020-25926": {"epss_score": 0.00289, "epss_percentile": 0.52006}, "CVE-2020-25927": {"epss_score": 0.00488, "epss_percentile": 0.64863}, "CVE-2020-25928": {"epss_score": 0.05961, "epss_percentile": 0.90366}, "CVE-2020-25950": {"epss_score": 0.00113, "epss_percentile": 0.30631}, "CVE-2020-25952": {"epss_score": 0.02276, "epss_percentile": 0.84228}, "CVE-2020-25955": {"epss_score": 0.00492, "epss_percentile": 0.65011}, "CVE-2020-25966": {"epss_score": 0.00378, "epss_percentile": 0.58837}, "CVE-2020-25967": {"epss_score": 0.005, "epss_percentile": 0.65322}, "CVE-2020-25969": {"epss_score": 0.00111, "epss_percentile": 0.30279}, "CVE-2020-25985": {"epss_score": 0.03568, "epss_percentile": 0.87367}, "CVE-2020-25986": {"epss_score": 0.00117, "epss_percentile": 0.31224}, "CVE-2020-25987": {"epss_score": 0.00306, "epss_percentile": 0.53459}, "CVE-2020-25988": {"epss_score": 0.03345, "epss_percentile": 0.86951}, "CVE-2020-25989": {"epss_score": 0.00251, "epss_percentile": 0.48305}, "CVE-2020-25990": {"epss_score": 0.00394, "epss_percentile": 0.59789}, "CVE-2020-26006": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-26007": {"epss_score": 0.00312, "epss_percentile": 0.5395}, "CVE-2020-26008": {"epss_score": 0.00312, "epss_percentile": 0.5395}, "CVE-2020-26028": {"epss_score": 0.00258, "epss_percentile": 0.48959}, "CVE-2020-26029": {"epss_score": 0.00215, "epss_percentile": 0.44054}, "CVE-2020-26030": {"epss_score": 0.00494, "epss_percentile": 0.65092}, "CVE-2020-26031": {"epss_score": 0.00129, "epss_percentile": 0.33135}, "CVE-2020-26032": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2020-26033": {"epss_score": 0.00125, "epss_percentile": 0.32469}, "CVE-2020-26034": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2020-26035": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-26037": {"epss_score": 0.03336, "epss_percentile": 0.86937}, "CVE-2020-26041": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2020-26042": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-26043": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-26045": {"epss_score": 0.0074, "epss_percentile": 0.72408}, "CVE-2020-26046": {"epss_score": 0.00327, "epss_percentile": 0.5514}, "CVE-2020-26048": {"epss_score": 0.01859, "epss_percentile": 0.82583}, "CVE-2020-26049": {"epss_score": 0.00497, "epss_percentile": 0.65199}, "CVE-2020-26050": {"epss_score": 0.00054, "epss_percentile": 0.17193}, "CVE-2020-26051": {"epss_score": 0.00494, "epss_percentile": 0.65094}, "CVE-2020-26052": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2020-26061": {"epss_score": 0.06784, "epss_percentile": 0.91025}, "CVE-2020-26062": {"epss_score": 0.00141, "epss_percentile": 0.34926}, "CVE-2020-26063": {"epss_score": 0.00107, "epss_percentile": 0.2974}, "CVE-2020-26064": {"epss_score": 0.00094, "epss_percentile": 0.26972}, "CVE-2020-26065": {"epss_score": 0.00278, "epss_percentile": 0.50922}, "CVE-2020-26066": {"epss_score": 0.00116, "epss_percentile": 0.31172}, "CVE-2020-26067": {"epss_score": 0.16661, "epss_percentile": 0.94709}, "CVE-2020-26068": {"epss_score": 0.00177, "epss_percentile": 0.39586}, "CVE-2020-26070": {"epss_score": 0.01033, "epss_percentile": 0.7687}, "CVE-2020-26071": {"epss_score": 0.00104, "epss_percentile": 0.29132}, "CVE-2020-26072": {"epss_score": 0.00228, "epss_percentile": 0.45541}, "CVE-2020-26073": {"epss_score": 0.90637, "epss_percentile": 0.99593}, "CVE-2020-26074": {"epss_score": 0.00061, "epss_percentile": 0.19506}, "CVE-2020-26075": {"epss_score": 0.01973, "epss_percentile": 0.83111}, "CVE-2020-26076": {"epss_score": 0.0058, "epss_percentile": 0.68253}, "CVE-2020-26077": {"epss_score": 0.00136, "epss_percentile": 0.34107}, "CVE-2020-26078": {"epss_score": 0.00215, "epss_percentile": 0.4403}, "CVE-2020-26079": {"epss_score": 0.00168, "epss_percentile": 0.38462}, "CVE-2020-26080": {"epss_score": 0.00136, "epss_percentile": 0.34092}, "CVE-2020-26081": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2020-26082": {"epss_score": 0.00074, "epss_percentile": 0.22873}, "CVE-2020-26083": {"epss_score": 0.0017, "epss_percentile": 0.38656}, "CVE-2020-26084": {"epss_score": 0.00151, "epss_percentile": 0.36348}, "CVE-2020-26085": {"epss_score": 0.00733, "epss_percentile": 0.72214}, "CVE-2020-26086": {"epss_score": 0.00172, "epss_percentile": 0.39038}, "CVE-2020-26088": {"epss_score": 0.00013, "epss_percentile": 0.01691}, "CVE-2020-26097": {"epss_score": 0.00389, "epss_percentile": 0.59454}, "CVE-2020-26098": {"epss_score": 0.09842, "epss_percentile": 0.92731}, "CVE-2020-26099": {"epss_score": 0.00602, "epss_percentile": 0.68889}, "CVE-2020-26100": {"epss_score": 0.01304, "epss_percentile": 0.79315}, "CVE-2020-26101": {"epss_score": 0.00887, "epss_percentile": 0.74971}, "CVE-2020-26102": {"epss_score": 0.01035, "epss_percentile": 0.769}, "CVE-2020-26103": {"epss_score": 0.00887, "epss_percentile": 0.74971}, "CVE-2020-26104": {"epss_score": 0.01035, "epss_percentile": 0.769}, "CVE-2020-26105": {"epss_score": 0.00887, "epss_percentile": 0.74971}, "CVE-2020-26106": {"epss_score": 0.00672, "epss_percentile": 0.70813}, "CVE-2020-26107": {"epss_score": 0.00415, "epss_percentile": 0.61131}, "CVE-2020-26108": {"epss_score": 0.01851, "epss_percentile": 0.82542}, "CVE-2020-26109": {"epss_score": 0.00602, "epss_percentile": 0.68889}, "CVE-2020-26110": {"epss_score": 0.00749, "epss_percentile": 0.726}, "CVE-2020-26111": {"epss_score": 0.00472, "epss_percentile": 0.64038}, "CVE-2020-26112": {"epss_score": 0.0047, "epss_percentile": 0.63977}, "CVE-2020-26113": {"epss_score": 0.00472, "epss_percentile": 0.64038}, "CVE-2020-26114": {"epss_score": 0.00472, "epss_percentile": 0.64038}, "CVE-2020-26115": {"epss_score": 0.00472, "epss_percentile": 0.64038}, "CVE-2020-26116": {"epss_score": 0.00832, "epss_percentile": 0.74062}, "CVE-2020-26117": {"epss_score": 0.00935, "epss_percentile": 0.75674}, "CVE-2020-26118": {"epss_score": 0.01958, "epss_percentile": 0.83049}, "CVE-2020-26120": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2020-26121": {"epss_score": 0.00158, "epss_percentile": 0.37163}, "CVE-2020-26122": {"epss_score": 0.00638, "epss_percentile": 0.69909}, "CVE-2020-26124": {"epss_score": 0.80279, "epss_percentile": 0.99079}, "CVE-2020-26129": {"epss_score": 2e-05, "epss_percentile": 0.00059}, "CVE-2020-26130": {"epss_score": 0.0013, "epss_percentile": 0.33241}, "CVE-2020-26131": {"epss_score": 0.00045, "epss_percentile": 0.13987}, "CVE-2020-26132": {"epss_score": 0.00045, "epss_percentile": 0.13987}, "CVE-2020-26133": {"epss_score": 0.00045, "epss_percentile": 0.13987}, "CVE-2020-26134": {"epss_score": 0.00396, "epss_percentile": 0.59903}, "CVE-2020-26135": {"epss_score": 0.00441, "epss_percentile": 0.62685}, "CVE-2020-26136": {"epss_score": 0.00216, "epss_percentile": 0.44192}, "CVE-2020-26137": {"epss_score": 0.00239, "epss_percentile": 0.46887}, "CVE-2020-26138": {"epss_score": 0.00292, "epss_percentile": 0.52269}, "CVE-2020-26139": {"epss_score": 0.00411, "epss_percentile": 0.60887}, "CVE-2020-26140": {"epss_score": 0.00177, "epss_percentile": 0.39579}, "CVE-2020-26141": {"epss_score": 0.00283, "epss_percentile": 0.51352}, "CVE-2020-26142": {"epss_score": 0.01557, "epss_percentile": 0.8102}, "CVE-2020-26143": {"epss_score": 0.00601, "epss_percentile": 0.68849}, "CVE-2020-26144": {"epss_score": 0.01015, "epss_percentile": 0.76657}, "CVE-2020-26145": {"epss_score": 0.00692, "epss_percentile": 0.71295}, "CVE-2020-26146": {"epss_score": 0.01512, "epss_percentile": 0.80782}, "CVE-2020-26147": {"epss_score": 0.00265, "epss_percentile": 0.49778}, "CVE-2020-26148": {"epss_score": 0.00362, "epss_percentile": 0.5775}, "CVE-2020-26149": {"epss_score": 0.00341, "epss_percentile": 0.56329}, "CVE-2020-26150": {"epss_score": 0.00339, "epss_percentile": 0.56177}, "CVE-2020-26153": {"epss_score": 0.29778, "epss_percentile": 0.96475}, "CVE-2020-26154": {"epss_score": 0.00717, "epss_percentile": 0.71874}, "CVE-2020-26155": {"epss_score": 0.00041, "epss_percentile": 0.12325}, "CVE-2020-26157": {"epss_score": 0.01275, "epss_percentile": 0.79105}, "CVE-2020-26158": {"epss_score": 0.01275, "epss_percentile": 0.79105}, "CVE-2020-26160": {"epss_score": 0.0005, "epss_percentile": 0.15953}, "CVE-2020-26161": {"epss_score": 0.0023, "epss_percentile": 0.45679}, "CVE-2020-26162": {"epss_score": 0.00312, "epss_percentile": 0.53995}, "CVE-2020-26163": {"epss_score": 0.00484, "epss_percentile": 0.64638}, "CVE-2020-26164": {"epss_score": 0.00099, "epss_percentile": 0.27863}, "CVE-2020-26165": {"epss_score": 0.01089, "epss_percentile": 0.77442}, "CVE-2020-26166": {"epss_score": 0.00261, "epss_percentile": 0.49291}, "CVE-2020-26167": {"epss_score": 0.02953, "epss_percentile": 0.86057}, "CVE-2020-26168": {"epss_score": 0.00866, "epss_percentile": 0.74641}, "CVE-2020-26171": {"epss_score": 0.0016, "epss_percentile": 0.37448}, "CVE-2020-26172": {"epss_score": 0.00196, "epss_percentile": 0.41771}, "CVE-2020-26173": {"epss_score": 0.00147, "epss_percentile": 0.35659}, "CVE-2020-26174": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2020-26175": {"epss_score": 0.0016, "epss_percentile": 0.37448}, "CVE-2020-26176": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2020-26177": {"epss_score": 0.00203, "epss_percentile": 0.42564}, "CVE-2020-26178": {"epss_score": 0.00258, "epss_percentile": 0.48951}, "CVE-2020-26180": {"epss_score": 0.00319, "epss_percentile": 0.54566}, "CVE-2020-26181": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2020-26182": {"epss_score": 0.00128, "epss_percentile": 0.3304}, "CVE-2020-26183": {"epss_score": 0.00125, "epss_percentile": 0.32573}, "CVE-2020-26184": {"epss_score": 0.0031, "epss_percentile": 0.53785}, "CVE-2020-26185": {"epss_score": 0.00463, "epss_percentile": 0.63688}, "CVE-2020-26186": {"epss_score": 0.00041, "epss_percentile": 0.12279}, "CVE-2020-26191": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2020-26192": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2020-26193": {"epss_score": 0.00132, "epss_percentile": 0.33545}, "CVE-2020-26194": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2020-26195": {"epss_score": 0.01163, "epss_percentile": 0.78161}, "CVE-2020-26196": {"epss_score": 0.00047, "epss_percentile": 0.14806}, "CVE-2020-26197": {"epss_score": 0.00129, "epss_percentile": 0.33208}, "CVE-2020-26198": {"epss_score": 0.00301, "epss_percentile": 0.53018}, "CVE-2020-26199": {"epss_score": 0.00047, "epss_percentile": 0.14807}, "CVE-2020-26200": {"epss_score": 0.00034, "epss_percentile": 0.09778}, "CVE-2020-26201": {"epss_score": 0.00659, "epss_percentile": 0.70505}, "CVE-2020-26205": {"epss_score": 0.00162, "epss_percentile": 0.37682}, "CVE-2020-26207": {"epss_score": 0.00691, "epss_percentile": 0.71273}, "CVE-2020-26208": {"epss_score": 0.00082, "epss_percentile": 0.24486}, "CVE-2020-26210": {"epss_score": 0.00432, "epss_percentile": 0.62129}, "CVE-2020-26211": {"epss_score": 0.00432, "epss_percentile": 0.62129}, "CVE-2020-26212": {"epss_score": 0.00285, "epss_percentile": 0.51676}, "CVE-2020-26213": {"epss_score": 0.0039, "epss_percentile": 0.59514}, "CVE-2020-26214": {"epss_score": 0.88241, "epss_percentile": 0.99462}, "CVE-2020-26215": {"epss_score": 0.00571, "epss_percentile": 0.67975}, "CVE-2020-26216": {"epss_score": 0.00583, "epss_percentile": 0.68353}, "CVE-2020-26217": {"epss_score": 0.93171, "epss_percentile": 0.9978}, "CVE-2020-26218": {"epss_score": 0.0309, "epss_percentile": 0.86394}, "CVE-2020-26219": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2020-26220": {"epss_score": 0.00203, "epss_percentile": 0.42555}, "CVE-2020-26221": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2020-26222": {"epss_score": 0.00477, "epss_percentile": 0.64333}, "CVE-2020-26223": {"epss_score": 0.00267, "epss_percentile": 0.49971}, "CVE-2020-26224": {"epss_score": 0.00922, "epss_percentile": 0.75493}, "CVE-2020-26225": {"epss_score": 0.00305, "epss_percentile": 0.53386}, "CVE-2020-26226": {"epss_score": 0.0035, "epss_percentile": 0.56959}, "CVE-2020-26227": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-26228": {"epss_score": 0.00177, "epss_percentile": 0.39622}, "CVE-2020-26229": {"epss_score": 0.0027, "epss_percentile": 0.50262}, "CVE-2020-26230": {"epss_score": 0.00746, "epss_percentile": 0.72542}, "CVE-2020-26231": {"epss_score": 0.00034, "epss_percentile": 0.09568}, "CVE-2020-26232": {"epss_score": 0.00232, "epss_percentile": 0.4597}, "CVE-2020-26233": {"epss_score": 0.15577, "epss_percentile": 0.94462}, "CVE-2020-26234": {"epss_score": 0.00079, "epss_percentile": 0.23891}, "CVE-2020-26235": {"epss_score": 0.00735, "epss_percentile": 0.72293}, "CVE-2020-26236": {"epss_score": 0.00332, "epss_percentile": 0.55609}, "CVE-2020-26237": {"epss_score": 0.00602, "epss_percentile": 0.68877}, "CVE-2020-26238": {"epss_score": 0.06488, "epss_percentile": 0.90794}, "CVE-2020-26239": {"epss_score": 0.0028, "epss_percentile": 0.51064}, "CVE-2020-26240": {"epss_score": 0.00386, "epss_percentile": 0.5925}, "CVE-2020-26241": {"epss_score": 0.00303, "epss_percentile": 0.53207}, "CVE-2020-26242": {"epss_score": 0.00526, "epss_percentile": 0.66433}, "CVE-2020-26243": {"epss_score": 0.00107, "epss_percentile": 0.29614}, "CVE-2020-26244": {"epss_score": 0.00155, "epss_percentile": 0.368}, "CVE-2020-26245": {"epss_score": 0.0113, "epss_percentile": 0.77851}, "CVE-2020-26246": {"epss_score": 7e-05, "epss_percentile": 0.00387}, "CVE-2020-26247": {"epss_score": 0.00678, "epss_percentile": 0.70973}, "CVE-2020-26248": {"epss_score": 0.8099, "epss_percentile": 0.99115}, "CVE-2020-26249": {"epss_score": 0.00414, "epss_percentile": 0.61103}, "CVE-2020-26250": {"epss_score": 0.0041, "epss_percentile": 0.6079}, "CVE-2020-26251": {"epss_score": 0.00231, "epss_percentile": 0.45843}, "CVE-2020-26252": {"epss_score": 0.01707, "epss_percentile": 0.81862}, "CVE-2020-26253": {"epss_score": 0.00161, "epss_percentile": 0.37588}, "CVE-2020-26254": {"epss_score": 0.00262, "epss_percentile": 0.4939}, "CVE-2020-26255": {"epss_score": 0.01108, "epss_percentile": 0.77641}, "CVE-2020-26256": {"epss_score": 0.01073, "epss_percentile": 0.77291}, "CVE-2020-26257": {"epss_score": 0.00453, "epss_percentile": 0.63222}, "CVE-2020-26258": {"epss_score": 0.9368, "epss_percentile": 0.99833}, "CVE-2020-26259": {"epss_score": 0.8887, "epss_percentile": 0.99496}, "CVE-2020-26260": {"epss_score": 0.00308, "epss_percentile": 0.53592}, "CVE-2020-26261": {"epss_score": 0.00162, "epss_percentile": 0.37702}, "CVE-2020-26262": {"epss_score": 0.00336, "epss_percentile": 0.56003}, "CVE-2020-26263": {"epss_score": 0.00244, "epss_percentile": 0.47613}, "CVE-2020-26264": {"epss_score": 0.00487, "epss_percentile": 0.64802}, "CVE-2020-26265": {"epss_score": 0.00267, "epss_percentile": 0.49953}, "CVE-2020-26266": {"epss_score": 0.00051, "epss_percentile": 0.16265}, "CVE-2020-26267": {"epss_score": 0.00018, "epss_percentile": 0.03649}, "CVE-2020-26268": {"epss_score": 0.00018, "epss_percentile": 0.03924}, "CVE-2020-26269": {"epss_score": 0.0014, "epss_percentile": 0.347}, "CVE-2020-26270": {"epss_score": 0.00019, "epss_percentile": 0.04162}, "CVE-2020-26271": {"epss_score": 0.00017, "epss_percentile": 0.03295}, "CVE-2020-26272": {"epss_score": 0.00965, "epss_percentile": 0.7604}, "CVE-2020-26273": {"epss_score": 0.00108, "epss_percentile": 0.29759}, "CVE-2020-26274": {"epss_score": 0.01389, "epss_percentile": 0.79925}, "CVE-2020-26275": {"epss_score": 0.00344, "epss_percentile": 0.56542}, "CVE-2020-26276": {"epss_score": 0.00978, "epss_percentile": 0.76243}, "CVE-2020-26277": {"epss_score": 0.00304, "epss_percentile": 0.53302}, "CVE-2020-26278": {"epss_score": 0.00158, "epss_percentile": 0.37172}, "CVE-2020-26279": {"epss_score": 0.01624, "epss_percentile": 0.8141}, "CVE-2020-26280": {"epss_score": 0.0047, "epss_percentile": 0.63991}, "CVE-2020-26281": {"epss_score": 0.0019, "epss_percentile": 0.41086}, "CVE-2020-26282": {"epss_score": 0.02411, "epss_percentile": 0.84667}, "CVE-2020-26283": {"epss_score": 0.00858, "epss_percentile": 0.74502}, "CVE-2020-26284": {"epss_score": 0.0041, "epss_percentile": 0.6082}, "CVE-2020-26285": {"epss_score": 0.01923, "epss_percentile": 0.82909}, "CVE-2020-26286": {"epss_score": 0.01307, "epss_percentile": 0.7934}, "CVE-2020-26287": {"epss_score": 0.00545, "epss_percentile": 0.67171}, "CVE-2020-26288": {"epss_score": 0.00163, "epss_percentile": 0.37824}, "CVE-2020-26289": {"epss_score": 0.00526, "epss_percentile": 0.66437}, "CVE-2020-26290": {"epss_score": 0.005, "epss_percentile": 0.65301}, "CVE-2020-26291": {"epss_score": 0.00581, "epss_percentile": 0.68265}, "CVE-2020-26292": {"epss_score": 0.00362, "epss_percentile": 0.57789}, "CVE-2020-26293": {"epss_score": 0.00344, "epss_percentile": 0.56505}, "CVE-2020-26294": {"epss_score": 0.0035, "epss_percentile": 0.56943}, "CVE-2020-26295": {"epss_score": 0.00751, "epss_percentile": 0.72639}, "CVE-2020-26296": {"epss_score": 0.00407, "epss_percentile": 0.60574}, "CVE-2020-26297": {"epss_score": 0.0033, "epss_percentile": 0.55433}, "CVE-2020-26298": {"epss_score": 0.00334, "epss_percentile": 0.55696}, "CVE-2020-26299": {"epss_score": 0.01004, "epss_percentile": 0.7653}, "CVE-2020-26300": {"epss_score": 0.01121, "epss_percentile": 0.77773}, "CVE-2020-26301": {"epss_score": 0.05066, "epss_percentile": 0.89457}, "CVE-2020-26302": {"epss_score": 0.00272, "epss_percentile": 0.50387}, "CVE-2020-26303": {"epss_score": 0.00122, "epss_percentile": 0.32142}, "CVE-2020-26304": {"epss_score": 0.00118, "epss_percentile": 0.31409}, "CVE-2020-26305": {"epss_score": 0.00118, "epss_percentile": 0.31409}, "CVE-2020-26306": {"epss_score": 0.00154, "epss_percentile": 0.36736}, "CVE-2020-26307": {"epss_score": 0.00142, "epss_percentile": 0.34998}, "CVE-2020-26308": {"epss_score": 0.00118, "epss_percentile": 0.31409}, "CVE-2020-26309": {"epss_score": 0.00154, "epss_percentile": 0.36736}, "CVE-2020-26310": {"epss_score": 0.00185, "epss_percentile": 0.40578}, "CVE-2020-26311": {"epss_score": 0.00122, "epss_percentile": 0.32142}, "CVE-2020-26312": {"epss_score": 0.00279, "epss_percentile": 0.5093}, "CVE-2020-26405": {"epss_score": 0.00544, "epss_percentile": 0.67146}, "CVE-2020-26406": {"epss_score": 0.00269, "epss_percentile": 0.50175}, "CVE-2020-26407": {"epss_score": 0.0015, "epss_percentile": 0.36103}, "CVE-2020-26408": {"epss_score": 0.00119, "epss_percentile": 0.3161}, "CVE-2020-26409": {"epss_score": 0.00169, "epss_percentile": 0.38563}, "CVE-2020-26411": {"epss_score": 0.00097, "epss_percentile": 0.27531}, "CVE-2020-26412": {"epss_score": 0.00131, "epss_percentile": 0.33356}, "CVE-2020-26413": {"epss_score": 0.92644, "epss_percentile": 0.99732}, "CVE-2020-26414": {"epss_score": 0.00268, "epss_percentile": 0.50098}, "CVE-2020-26415": {"epss_score": 0.00161, "epss_percentile": 0.37565}, "CVE-2020-26416": {"epss_score": 0.00042, "epss_percentile": 0.12882}, "CVE-2020-26417": {"epss_score": 0.00196, "epss_percentile": 0.41822}, "CVE-2020-26418": {"epss_score": 0.00405, "epss_percentile": 0.60476}, "CVE-2020-26419": {"epss_score": 0.00427, "epss_percentile": 0.61883}, "CVE-2020-26420": {"epss_score": 0.00427, "epss_percentile": 0.61883}, "CVE-2020-26421": {"epss_score": 0.001, "epss_percentile": 0.28472}, "CVE-2020-26422": {"epss_score": 0.00306, "epss_percentile": 0.53456}, "CVE-2020-26505": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-26506": {"epss_score": 0.00156, "epss_percentile": 0.37017}, "CVE-2020-26507": {"epss_score": 0.00375, "epss_percentile": 0.58638}, "CVE-2020-26508": {"epss_score": 0.00305, "epss_percentile": 0.53383}, "CVE-2020-26509": {"epss_score": 0.00345, "epss_percentile": 0.56591}, "CVE-2020-26510": {"epss_score": 0.01135, "epss_percentile": 0.77913}, "CVE-2020-26511": {"epss_score": 0.00536, "epss_percentile": 0.6686}, "CVE-2020-26513": {"epss_score": 0.00239, "epss_percentile": 0.46897}, "CVE-2020-26515": {"epss_score": 0.00072, "epss_percentile": 0.2236}, "CVE-2020-26516": {"epss_score": 0.0022, "epss_percentile": 0.44593}, "CVE-2020-26517": {"epss_score": 0.0031, "epss_percentile": 0.53775}, "CVE-2020-26518": {"epss_score": 0.03381, "epss_percentile": 0.87031}, "CVE-2020-26519": {"epss_score": 0.00769, "epss_percentile": 0.72992}, "CVE-2020-26521": {"epss_score": 0.00682, "epss_percentile": 0.71085}, "CVE-2020-26522": {"epss_score": 0.00133, "epss_percentile": 0.33687}, "CVE-2020-26523": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-26524": {"epss_score": 0.00298, "epss_percentile": 0.5278}, "CVE-2020-26525": {"epss_score": 0.26819, "epss_percentile": 0.96183}, "CVE-2020-26526": {"epss_score": 0.00472, "epss_percentile": 0.64065}, "CVE-2020-26527": {"epss_score": 0.00445, "epss_percentile": 0.62858}, "CVE-2020-26534": {"epss_score": 0.00032, "epss_percentile": 0.09086}, "CVE-2020-26535": {"epss_score": 0.00023, "epss_percentile": 0.05592}, "CVE-2020-26536": {"epss_score": 0.00035, "epss_percentile": 0.09807}, "CVE-2020-26537": {"epss_score": 0.00027, "epss_percentile": 0.0675}, "CVE-2020-26538": {"epss_score": 0.00012, "epss_percentile": 0.01417}, "CVE-2020-26539": {"epss_score": 0.02831, "epss_percentile": 0.85776}, "CVE-2020-26540": {"epss_score": 7e-05, "epss_percentile": 0.0039}, "CVE-2020-26541": {"epss_score": 0.00118, "epss_percentile": 0.31442}, "CVE-2020-26542": {"epss_score": 0.00703, "epss_percentile": 0.71547}, "CVE-2020-26546": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2020-26547": {"epss_score": 0.00207, "epss_percentile": 0.4313}, "CVE-2020-26548": {"epss_score": 0.00427, "epss_percentile": 0.61876}, "CVE-2020-26549": {"epss_score": 0.00614, "epss_percentile": 0.69284}, "CVE-2020-26550": {"epss_score": 0.00245, "epss_percentile": 0.47708}, "CVE-2020-26551": {"epss_score": 0.00156, "epss_percentile": 0.36902}, "CVE-2020-26552": {"epss_score": 0.00282, "epss_percentile": 0.51221}, "CVE-2020-26553": {"epss_score": 0.00841, "epss_percentile": 0.74226}, "CVE-2020-26554": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2020-26555": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2020-26556": {"epss_score": 0.01175, "epss_percentile": 0.78257}, "CVE-2020-26557": {"epss_score": 0.01233, "epss_percentile": 0.78749}, "CVE-2020-26558": {"epss_score": 0.00021, "epss_percentile": 0.049}, "CVE-2020-26559": {"epss_score": 0.01652, "epss_percentile": 0.81575}, "CVE-2020-26560": {"epss_score": 0.01216, "epss_percentile": 0.78594}, "CVE-2020-26561": {"epss_score": 0.01483, "epss_percentile": 0.80588}, "CVE-2020-26563": {"epss_score": 0.00278, "epss_percentile": 0.50902}, "CVE-2020-26564": {"epss_score": 0.00191, "epss_percentile": 0.41189}, "CVE-2020-26565": {"epss_score": 0.00399, "epss_percentile": 0.60111}, "CVE-2020-26566": {"epss_score": 0.12015, "epss_percentile": 0.93548}, "CVE-2020-26567": {"epss_score": 0.29384, "epss_percentile": 0.96438}, "CVE-2020-26569": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-26570": {"epss_score": 0.00051, "epss_percentile": 0.1607}, "CVE-2020-26571": {"epss_score": 0.00043, "epss_percentile": 0.13071}, "CVE-2020-26572": {"epss_score": 0.00051, "epss_percentile": 0.1607}, "CVE-2020-26574": {"epss_score": 0.03087, "epss_percentile": 0.86389}, "CVE-2020-26575": {"epss_score": 0.02233, "epss_percentile": 0.84093}, "CVE-2020-26582": {"epss_score": 0.02956, "epss_percentile": 0.86063}, "CVE-2020-26583": {"epss_score": 0.00779, "epss_percentile": 0.73153}, "CVE-2020-26584": {"epss_score": 0.0045, "epss_percentile": 0.631}, "CVE-2020-26596": {"epss_score": 0.17466, "epss_percentile": 0.94853}, "CVE-2020-26597": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2020-26598": {"epss_score": 0.00081, "epss_percentile": 0.24322}, "CVE-2020-26599": {"epss_score": 0.00089, "epss_percentile": 0.25816}, "CVE-2020-26600": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2020-26601": {"epss_score": 0.00092, "epss_percentile": 0.26544}, "CVE-2020-26602": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2020-26603": {"epss_score": 0.00055, "epss_percentile": 0.17517}, "CVE-2020-26604": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2020-26605": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2020-26606": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2020-26607": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-26609": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2020-26623": {"epss_score": 0.00276, "epss_percentile": 0.50704}, "CVE-2020-26624": {"epss_score": 0.0026, "epss_percentile": 0.49216}, "CVE-2020-26625": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2020-26627": {"epss_score": 0.00123, "epss_percentile": 0.32266}, "CVE-2020-26628": {"epss_score": 0.00235, "epss_percentile": 0.46328}, "CVE-2020-26629": {"epss_score": 0.00718, "epss_percentile": 0.71924}, "CVE-2020-26630": {"epss_score": 0.00087, "epss_percentile": 0.25575}, "CVE-2020-26641": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2020-26642": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-26649": {"epss_score": 0.00189, "epss_percentile": 0.4098}, "CVE-2020-26650": {"epss_score": 0.00245, "epss_percentile": 0.47687}, "CVE-2020-26652": {"epss_score": 0.00172, "epss_percentile": 0.38976}, "CVE-2020-26664": {"epss_score": 0.00292, "epss_percentile": 0.52232}, "CVE-2020-26668": {"epss_score": 0.0042, "epss_percentile": 0.61454}, "CVE-2020-26669": {"epss_score": 0.00369, "epss_percentile": 0.58251}, "CVE-2020-26670": {"epss_score": 0.01944, "epss_percentile": 0.82997}, "CVE-2020-26672": {"epss_score": 0.00178, "epss_percentile": 0.39652}, "CVE-2020-26677": {"epss_score": 0.00535, "epss_percentile": 0.66834}, "CVE-2020-26678": {"epss_score": 0.02951, "epss_percentile": 0.86053}, "CVE-2020-26679": {"epss_score": 0.00139, "epss_percentile": 0.34595}, "CVE-2020-26680": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2020-26682": {"epss_score": 0.00446, "epss_percentile": 0.62925}, "CVE-2020-26683": {"epss_score": 0.00027, "epss_percentile": 0.06808}, "CVE-2020-26693": {"epss_score": 0.00465, "epss_percentile": 0.63743}, "CVE-2020-26701": {"epss_score": 0.00132, "epss_percentile": 0.33549}, "CVE-2020-26705": {"epss_score": 0.00309, "epss_percentile": 0.5368}, "CVE-2020-26707": {"epss_score": 0.01119, "epss_percentile": 0.77752}, "CVE-2020-26708": {"epss_score": 0.00083, "epss_percentile": 0.24626}, "CVE-2020-26709": {"epss_score": 0.00043, "epss_percentile": 0.13094}, "CVE-2020-26710": {"epss_score": 0.00043, "epss_percentile": 0.13094}, "CVE-2020-26712": {"epss_score": 0.00697, "epss_percentile": 0.71404}, "CVE-2020-26713": {"epss_score": 0.00397, "epss_percentile": 0.60045}, "CVE-2020-26728": {"epss_score": 0.03387, "epss_percentile": 0.87043}, "CVE-2020-26732": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2020-26733": {"epss_score": 0.00602, "epss_percentile": 0.68885}, "CVE-2020-26759": {"epss_score": 0.03109, "epss_percentile": 0.86422}, "CVE-2020-26762": {"epss_score": 0.04353, "epss_percentile": 0.88588}, "CVE-2020-26763": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-26766": {"epss_score": 0.00138, "epss_percentile": 0.34426}, "CVE-2020-26768": {"epss_score": 0.0057, "epss_percentile": 0.67966}, "CVE-2020-26772": {"epss_score": 0.02729, "epss_percentile": 0.85536}, "CVE-2020-26773": {"epss_score": 0.004, "epss_percentile": 0.60192}, "CVE-2020-26797": {"epss_score": 0.00659, "epss_percentile": 0.70499}, "CVE-2020-26799": {"epss_score": 0.00187, "epss_percentile": 0.40777}, "CVE-2020-26800": {"epss_score": 0.00255, "epss_percentile": 0.48686}, "CVE-2020-26801": {"epss_score": 0.00388, "epss_percentile": 0.59355}, "CVE-2020-26802": {"epss_score": 0.00138, "epss_percentile": 0.34426}, "CVE-2020-26803": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2020-26804": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2020-26805": {"epss_score": 0.00533, "epss_percentile": 0.6677}, "CVE-2020-26806": {"epss_score": 0.05031, "epss_percentile": 0.89415}, "CVE-2020-26807": {"epss_score": 0.00031, "epss_percentile": 0.08378}, "CVE-2020-26808": {"epss_score": 0.0374, "epss_percentile": 0.87656}, "CVE-2020-26809": {"epss_score": 0.00262, "epss_percentile": 0.49389}, "CVE-2020-26810": {"epss_score": 0.01178, "epss_percentile": 0.78284}, "CVE-2020-26811": {"epss_score": 0.00805, "epss_percentile": 0.73637}, "CVE-2020-26814": {"epss_score": 0.00238, "epss_percentile": 0.46834}, "CVE-2020-26815": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2020-26816": {"epss_score": 0.0002, "epss_percentile": 0.04535}, "CVE-2020-26817": {"epss_score": 0.00226, "epss_percentile": 0.45351}, "CVE-2020-26818": {"epss_score": 0.00265, "epss_percentile": 0.49779}, "CVE-2020-26819": {"epss_score": 0.00383, "epss_percentile": 0.59094}, "CVE-2020-26820": {"epss_score": 0.03156, "epss_percentile": 0.86516}, "CVE-2020-26821": {"epss_score": 0.00812, "epss_percentile": 0.73746}, "CVE-2020-26822": {"epss_score": 0.00812, "epss_percentile": 0.73746}, "CVE-2020-26823": {"epss_score": 0.00365, "epss_percentile": 0.57972}, "CVE-2020-26824": {"epss_score": 0.00812, "epss_percentile": 0.73746}, "CVE-2020-26825": {"epss_score": 0.00273, "epss_percentile": 0.50483}, "CVE-2020-26826": {"epss_score": 0.00448, "epss_percentile": 0.6303}, "CVE-2020-26828": {"epss_score": 0.00318, "epss_percentile": 0.54453}, "CVE-2020-26829": {"epss_score": 0.03949, "epss_percentile": 0.87999}, "CVE-2020-26830": {"epss_score": 0.00254, "epss_percentile": 0.48574}, "CVE-2020-26831": {"epss_score": 0.00615, "epss_percentile": 0.69308}, "CVE-2020-26832": {"epss_score": 0.00495, "epss_percentile": 0.65129}, "CVE-2020-26834": {"epss_score": 0.0016, "epss_percentile": 0.37456}, "CVE-2020-26835": {"epss_score": 0.003, "epss_percentile": 0.52913}, "CVE-2020-26836": {"epss_score": 0.05012, "epss_percentile": 0.89391}, "CVE-2020-26837": {"epss_score": 0.00556, "epss_percentile": 0.67522}, "CVE-2020-26838": {"epss_score": 0.02003, "epss_percentile": 0.83225}, "CVE-2020-26867": {"epss_score": 0.03235, "epss_percentile": 0.86702}, "CVE-2020-26868": {"epss_score": 0.01114, "epss_percentile": 0.77696}, "CVE-2020-26869": {"epss_score": 0.00547, "epss_percentile": 0.6725}, "CVE-2020-26870": {"epss_score": 0.00366, "epss_percentile": 0.58083}, "CVE-2020-26876": {"epss_score": 0.80007, "epss_percentile": 0.99067}, "CVE-2020-26877": {"epss_score": 0.00247, "epss_percentile": 0.47861}, "CVE-2020-26878": {"epss_score": 0.41549, "epss_percentile": 0.97283}, "CVE-2020-26879": {"epss_score": 0.88286, "epss_percentile": 0.99466}, "CVE-2020-26880": {"epss_score": 0.00043, "epss_percentile": 0.13023}, "CVE-2020-26882": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2020-26883": {"epss_score": 0.00526, "epss_percentile": 0.66427}, "CVE-2020-26884": {"epss_score": 0.00469, "epss_percentile": 0.63957}, "CVE-2020-26885": {"epss_score": 0.00557, "epss_percentile": 0.6754}, "CVE-2020-26886": {"epss_score": 0.0007, "epss_percentile": 0.21799}, "CVE-2020-26887": {"epss_score": 0.004, "epss_percentile": 0.60182}, "CVE-2020-26890": {"epss_score": 0.00955, "epss_percentile": 0.75918}, "CVE-2020-26891": {"epss_score": 0.00616, "epss_percentile": 0.69328}, "CVE-2020-26892": {"epss_score": 0.00465, "epss_percentile": 0.63757}, "CVE-2020-26893": {"epss_score": 0.00027, "epss_percentile": 0.06759}, "CVE-2020-26894": {"epss_score": 0.00059, "epss_percentile": 0.18621}, "CVE-2020-26895": {"epss_score": 0.00148, "epss_percentile": 0.3586}, "CVE-2020-26896": {"epss_score": 0.00197, "epss_percentile": 0.41862}, "CVE-2020-26897": {"epss_score": 0.0013, "epss_percentile": 0.33256}, "CVE-2020-26898": {"epss_score": 0.0013, "epss_percentile": 0.33256}, "CVE-2020-26899": {"epss_score": 0.0019, "epss_percentile": 0.4107}, "CVE-2020-26900": {"epss_score": 0.00097, "epss_percentile": 0.2757}, "CVE-2020-26901": {"epss_score": 0.00095, "epss_percentile": 0.27148}, "CVE-2020-26902": {"epss_score": 0.01771, "epss_percentile": 0.82193}, "CVE-2020-26903": {"epss_score": 0.00097, "epss_percentile": 0.2757}, "CVE-2020-26904": {"epss_score": 0.00097, "epss_percentile": 0.2757}, "CVE-2020-26905": {"epss_score": 0.00196, "epss_percentile": 0.41797}, "CVE-2020-26906": {"epss_score": 0.0013, "epss_percentile": 0.33256}, "CVE-2020-26907": {"epss_score": 0.00432, "epss_percentile": 0.62136}, "CVE-2020-26908": {"epss_score": 0.00626, "epss_percentile": 0.69609}, "CVE-2020-26909": {"epss_score": 0.0038, "epss_percentile": 0.58933}, "CVE-2020-26910": {"epss_score": 0.00312, "epss_percentile": 0.53985}, "CVE-2020-26911": {"epss_score": 0.00129, "epss_percentile": 0.33129}, "CVE-2020-26912": {"epss_score": 0.0143, "epss_percentile": 0.80232}, "CVE-2020-26913": {"epss_score": 0.00311, "epss_percentile": 0.53928}, "CVE-2020-26914": {"epss_score": 0.00382, "epss_percentile": 0.59032}, "CVE-2020-26915": {"epss_score": 0.00204, "epss_percentile": 0.42633}, "CVE-2020-26916": {"epss_score": 0.00052, "epss_percentile": 0.16621}, "CVE-2020-26917": {"epss_score": 0.00213, "epss_percentile": 0.43847}, "CVE-2020-26918": {"epss_score": 0.00213, "epss_percentile": 0.43847}, "CVE-2020-26919": {"epss_score": 0.9411, "epss_percentile": 0.99905}, "CVE-2020-26920": {"epss_score": 0.01536, "epss_percentile": 0.80916}, "CVE-2020-26921": {"epss_score": 0.00133, "epss_percentile": 0.33686}, "CVE-2020-26922": {"epss_score": 0.00211, "epss_percentile": 0.43674}, "CVE-2020-26923": {"epss_score": 0.00311, "epss_percentile": 0.53844}, "CVE-2020-26924": {"epss_score": 0.0009, "epss_percentile": 0.26171}, "CVE-2020-26925": {"epss_score": 0.00059, "epss_percentile": 0.18929}, "CVE-2020-26926": {"epss_score": 0.00152, "epss_percentile": 0.3638}, "CVE-2020-26927": {"epss_score": 0.00592, "epss_percentile": 0.68613}, "CVE-2020-26928": {"epss_score": 0.00152, "epss_percentile": 0.3638}, "CVE-2020-26929": {"epss_score": 0.00477, "epss_percentile": 0.64335}, "CVE-2020-26930": {"epss_score": 0.00225, "epss_percentile": 0.45223}, "CVE-2020-26931": {"epss_score": 0.00095, "epss_percentile": 0.27148}, "CVE-2020-26932": {"epss_score": 0.00155, "epss_percentile": 0.36822}, "CVE-2020-26933": {"epss_score": 0.0005, "epss_percentile": 0.1574}, "CVE-2020-26934": {"epss_score": 0.02788, "epss_percentile": 0.8566}, "CVE-2020-26935": {"epss_score": 0.80066, "epss_percentile": 0.9907}, "CVE-2020-26936": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2020-26938": {"epss_score": 0.00386, "epss_percentile": 0.59268}, "CVE-2020-26939": {"epss_score": 0.02577, "epss_percentile": 0.85145}, "CVE-2020-26941": {"epss_score": 0.00032, "epss_percentile": 0.09029}, "CVE-2020-26942": {"epss_score": 0.00287, "epss_percentile": 0.51819}, "CVE-2020-26943": {"epss_score": 0.01296, "epss_percentile": 0.79257}, "CVE-2020-26944": {"epss_score": 0.005, "epss_percentile": 0.653}, "CVE-2020-26945": {"epss_score": 0.00595, "epss_percentile": 0.68686}, "CVE-2020-26947": {"epss_score": 0.0005, "epss_percentile": 0.15965}, "CVE-2020-26948": {"epss_score": 0.91735, "epss_percentile": 0.99664}, "CVE-2020-26950": {"epss_score": 0.46895, "epss_percentile": 0.9756}, "CVE-2020-26951": {"epss_score": 0.00433, "epss_percentile": 0.62179}, "CVE-2020-26952": {"epss_score": 0.00423, "epss_percentile": 0.61591}, "CVE-2020-26953": {"epss_score": 0.00233, "epss_percentile": 0.4598}, "CVE-2020-26954": {"epss_score": 0.00286, "epss_percentile": 0.51712}, "CVE-2020-26955": {"epss_score": 0.00284, "epss_percentile": 0.51463}, "CVE-2020-26956": {"epss_score": 0.00433, "epss_percentile": 0.62179}, "CVE-2020-26957": {"epss_score": 0.00178, "epss_percentile": 0.39662}, "CVE-2020-26958": {"epss_score": 0.00345, "epss_percentile": 0.56566}, "CVE-2020-26959": {"epss_score": 0.00495, "epss_percentile": 0.65124}, "CVE-2020-26960": {"epss_score": 0.00665, "epss_percentile": 0.70664}, "CVE-2020-26961": {"epss_score": 0.00275, "epss_percentile": 0.5067}, "CVE-2020-26962": {"epss_score": 0.00219, "epss_percentile": 0.44497}, "CVE-2020-26963": {"epss_score": 0.00405, "epss_percentile": 0.60482}, "CVE-2020-26964": {"epss_score": 0.00298, "epss_percentile": 0.52793}, "CVE-2020-26965": {"epss_score": 0.00444, "epss_percentile": 0.62841}, "CVE-2020-26966": {"epss_score": 0.00444, "epss_percentile": 0.62841}, "CVE-2020-26967": {"epss_score": 0.00284, "epss_percentile": 0.51463}, "CVE-2020-26968": {"epss_score": 0.00635, "epss_percentile": 0.69815}, "CVE-2020-26969": {"epss_score": 0.00774, "epss_percentile": 0.73065}, "CVE-2020-26970": {"epss_score": 0.00378, "epss_percentile": 0.58792}, "CVE-2020-26971": {"epss_score": 0.00813, "epss_percentile": 0.73757}, "CVE-2020-26972": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2020-26973": {"epss_score": 0.00326, "epss_percentile": 0.55054}, "CVE-2020-26974": {"epss_score": 0.00761, "epss_percentile": 0.72828}, "CVE-2020-26975": {"epss_score": 0.00379, "epss_percentile": 0.58897}, "CVE-2020-26976": {"epss_score": 0.01973, "epss_percentile": 0.83109}, "CVE-2020-26977": {"epss_score": 0.00384, "epss_percentile": 0.5913}, "CVE-2020-26978": {"epss_score": 0.00422, "epss_percentile": 0.61564}, "CVE-2020-26979": {"epss_score": 0.0025, "epss_percentile": 0.48242}, "CVE-2020-26980": {"epss_score": 0.01071, "epss_percentile": 0.77271}, "CVE-2020-26981": {"epss_score": 0.00403, "epss_percentile": 0.60352}, "CVE-2020-26982": {"epss_score": 0.01071, "epss_percentile": 0.77271}, "CVE-2020-26983": {"epss_score": 0.01071, "epss_percentile": 0.77271}, "CVE-2020-26984": {"epss_score": 0.01071, "epss_percentile": 0.77271}, "CVE-2020-26985": {"epss_score": 0.04097, "epss_percentile": 0.88254}, "CVE-2020-26986": {"epss_score": 0.0206, "epss_percentile": 0.83438}, "CVE-2020-26987": {"epss_score": 0.04097, "epss_percentile": 0.88254}, "CVE-2020-26988": {"epss_score": 0.01071, "epss_percentile": 0.77271}, "CVE-2020-26989": {"epss_score": 0.01807, "epss_percentile": 0.82353}, "CVE-2020-26990": {"epss_score": 0.01414, "epss_percentile": 0.80126}, "CVE-2020-26991": {"epss_score": 0.0101, "epss_percentile": 0.766}, "CVE-2020-26992": {"epss_score": 0.00853, "epss_percentile": 0.74433}, "CVE-2020-26993": {"epss_score": 0.00853, "epss_percentile": 0.74433}, "CVE-2020-26994": {"epss_score": 0.01595, "epss_percentile": 0.81233}, "CVE-2020-26995": {"epss_score": 0.02532, "epss_percentile": 0.85029}, "CVE-2020-26996": {"epss_score": 0.01071, "epss_percentile": 0.77271}, "CVE-2020-26997": {"epss_score": 0.00452, "epss_percentile": 0.63197}, "CVE-2020-26998": {"epss_score": 0.00097, "epss_percentile": 0.27573}, "CVE-2020-26999": {"epss_score": 0.00114, "epss_percentile": 0.30875}, "CVE-2020-27000": {"epss_score": 0.00116, "epss_percentile": 0.31152}, "CVE-2020-27001": {"epss_score": 0.00178, "epss_percentile": 0.39672}, "CVE-2020-27002": {"epss_score": 0.00076, "epss_percentile": 0.23239}, "CVE-2020-27003": {"epss_score": 0.00116, "epss_percentile": 0.31152}, "CVE-2020-27004": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2020-27005": {"epss_score": 0.00116, "epss_percentile": 0.31152}, "CVE-2020-27006": {"epss_score": 0.00116, "epss_percentile": 0.31152}, "CVE-2020-27007": {"epss_score": 0.00303, "epss_percentile": 0.53208}, "CVE-2020-27008": {"epss_score": 0.00069, "epss_percentile": 0.21475}, "CVE-2020-27009": {"epss_score": 0.0069, "epss_percentile": 0.71242}, "CVE-2020-27010": {"epss_score": 0.00415, "epss_percentile": 0.61137}, "CVE-2020-27013": {"epss_score": 0.00102, "epss_percentile": 0.28802}, "CVE-2020-27014": {"epss_score": 0.0006, "epss_percentile": 0.19024}, "CVE-2020-27015": {"epss_score": 0.00113, "epss_percentile": 0.30647}, "CVE-2020-27016": {"epss_score": 0.00286, "epss_percentile": 0.5174}, "CVE-2020-27017": {"epss_score": 0.00998, "epss_percentile": 0.76475}, "CVE-2020-27018": {"epss_score": 0.00137, "epss_percentile": 0.34304}, "CVE-2020-27019": {"epss_score": 0.00137, "epss_percentile": 0.34304}, "CVE-2020-27020": {"epss_score": 0.00265, "epss_percentile": 0.49785}, "CVE-2020-27021": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2020-27023": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-27024": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2020-27025": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-27026": {"epss_score": 0.00062, "epss_percentile": 0.19632}, "CVE-2020-27027": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-27028": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2020-27029": {"epss_score": 0.00294, "epss_percentile": 0.52364}, "CVE-2020-27030": {"epss_score": 0.00014, "epss_percentile": 0.01981}, "CVE-2020-27031": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2020-27032": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2020-27033": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-27034": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-27035": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2020-27036": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2020-27037": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-27038": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2020-27039": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-27040": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-27041": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2020-27043": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2020-27044": {"epss_score": 0.00018, "epss_percentile": 0.03602}, "CVE-2020-27045": {"epss_score": 0.00096, "epss_percentile": 0.27335}, "CVE-2020-27046": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2020-27047": {"epss_score": 0.00062, "epss_percentile": 0.19632}, "CVE-2020-27048": {"epss_score": 0.00056, "epss_percentile": 0.17816}, "CVE-2020-27049": {"epss_score": 0.00056, "epss_percentile": 0.17816}, "CVE-2020-27050": {"epss_score": 0.00096, "epss_percentile": 0.27335}, "CVE-2020-27051": {"epss_score": 0.00056, "epss_percentile": 0.17816}, "CVE-2020-27052": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2020-27053": {"epss_score": 0.00015, "epss_percentile": 0.02227}, "CVE-2020-27054": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2020-27055": {"epss_score": 0.00229, "epss_percentile": 0.45649}, "CVE-2020-27056": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2020-27057": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2020-27059": {"epss_score": 0.00081, "epss_percentile": 0.24396}, "CVE-2020-27066": {"epss_score": 0.00028, "epss_percentile": 0.07494}, "CVE-2020-27067": {"epss_score": 0.00019, "epss_percentile": 0.04379}, "CVE-2020-27068": {"epss_score": 0.00337, "epss_percentile": 0.5602}, "CVE-2020-27097": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2020-27098": {"epss_score": 0.00023, "epss_percentile": 0.05648}, "CVE-2020-27121": {"epss_score": 0.00633, "epss_percentile": 0.69763}, "CVE-2020-27122": {"epss_score": 0.00046, "epss_percentile": 0.14474}, "CVE-2020-27123": {"epss_score": 0.00061, "epss_percentile": 0.19258}, "CVE-2020-27124": {"epss_score": 0.01771, "epss_percentile": 0.82196}, "CVE-2020-27125": {"epss_score": 0.01109, "epss_percentile": 0.77645}, "CVE-2020-27126": {"epss_score": 0.00208, "epss_percentile": 0.43279}, "CVE-2020-27127": {"epss_score": 0.00341, "epss_percentile": 0.56316}, "CVE-2020-27128": {"epss_score": 0.02357, "epss_percentile": 0.84487}, "CVE-2020-27129": {"epss_score": 0.00166, "epss_percentile": 0.38237}, "CVE-2020-27130": {"epss_score": 0.14129, "epss_percentile": 0.94142}, "CVE-2020-27131": {"epss_score": 0.88492, "epss_percentile": 0.99475}, "CVE-2020-27132": {"epss_score": 0.00353, "epss_percentile": 0.57145}, "CVE-2020-27133": {"epss_score": 0.00441, "epss_percentile": 0.62675}, "CVE-2020-27134": {"epss_score": 0.0067, "epss_percentile": 0.70781}, "CVE-2020-27146": {"epss_score": 0.00136, "epss_percentile": 0.34089}, "CVE-2020-27147": {"epss_score": 0.0027, "epss_percentile": 0.50192}, "CVE-2020-27148": {"epss_score": 0.00574, "epss_percentile": 0.68075}, "CVE-2020-27149": {"epss_score": 0.00336, "epss_percentile": 0.55949}, "CVE-2020-27150": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2020-27151": {"epss_score": 0.00845, "epss_percentile": 0.74291}, "CVE-2020-27152": {"epss_score": 0.00068, "epss_percentile": 0.21262}, "CVE-2020-27153": {"epss_score": 0.01899, "epss_percentile": 0.82765}, "CVE-2020-27154": {"epss_score": 0.00511, "epss_percentile": 0.65827}, "CVE-2020-27155": {"epss_score": 0.00383, "epss_percentile": 0.59086}, "CVE-2020-27156": {"epss_score": 0.04698, "epss_percentile": 0.89022}, "CVE-2020-27157": {"epss_score": 0.00928, "epss_percentile": 0.75581}, "CVE-2020-27158": {"epss_score": 0.1071, "epss_percentile": 0.93079}, "CVE-2020-27159": {"epss_score": 0.08311, "epss_percentile": 0.91985}, "CVE-2020-27160": {"epss_score": 0.04927, "epss_percentile": 0.89294}, "CVE-2020-27163": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-27170": {"epss_score": 0.00151, "epss_percentile": 0.36311}, "CVE-2020-27171": {"epss_score": 0.00179, "epss_percentile": 0.39794}, "CVE-2020-27172": {"epss_score": 0.00631, "epss_percentile": 0.69716}, "CVE-2020-27173": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-27174": {"epss_score": 0.00563, "epss_percentile": 0.67714}, "CVE-2020-27176": {"epss_score": 0.0129, "epss_percentile": 0.79217}, "CVE-2020-27178": {"epss_score": 0.00225, "epss_percentile": 0.45118}, "CVE-2020-27179": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2020-27180": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-27181": {"epss_score": 0.0017, "epss_percentile": 0.38732}, "CVE-2020-27182": {"epss_score": 0.00317, "epss_percentile": 0.5439}, "CVE-2020-27183": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-27184": {"epss_score": 0.00085, "epss_percentile": 0.25182}, "CVE-2020-27185": {"epss_score": 0.00201, "epss_percentile": 0.42371}, "CVE-2020-27187": {"epss_score": 0.00123, "epss_percentile": 0.3233}, "CVE-2020-27191": {"epss_score": 0.73422, "epss_percentile": 0.98753}, "CVE-2020-27192": {"epss_score": 0.00035, "epss_percentile": 0.10054}, "CVE-2020-27193": {"epss_score": 0.00438, "epss_percentile": 0.62552}, "CVE-2020-27194": {"epss_score": 0.04246, "epss_percentile": 0.88441}, "CVE-2020-27195": {"epss_score": 0.0036, "epss_percentile": 0.57683}, "CVE-2020-27196": {"epss_score": 0.00526, "epss_percentile": 0.66427}, "CVE-2020-27197": {"epss_score": 0.0046, "epss_percentile": 0.63513}, "CVE-2020-27199": {"epss_score": 0.06505, "epss_percentile": 0.90805}, "CVE-2020-27207": {"epss_score": 0.00599, "epss_percentile": 0.68801}, "CVE-2020-27208": {"epss_score": 0.00036, "epss_percentile": 0.1044}, "CVE-2020-27209": {"epss_score": 0.00463, "epss_percentile": 0.63688}, "CVE-2020-27211": {"epss_score": 0.00078, "epss_percentile": 0.23572}, "CVE-2020-27212": {"epss_score": 0.00095, "epss_percentile": 0.27166}, "CVE-2020-27213": {"epss_score": 0.00097, "epss_percentile": 0.27574}, "CVE-2020-27216": {"epss_score": 0.00072, "epss_percentile": 0.2244}, "CVE-2020-27217": {"epss_score": 0.00325, "epss_percentile": 0.55034}, "CVE-2020-27218": {"epss_score": 0.00599, "epss_percentile": 0.68786}, "CVE-2020-27219": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2020-27220": {"epss_score": 0.00389, "epss_percentile": 0.59472}, "CVE-2020-27221": {"epss_score": 0.00732, "epss_percentile": 0.72186}, "CVE-2020-27222": {"epss_score": 0.00226, "epss_percentile": 0.45295}, "CVE-2020-27223": {"epss_score": 0.33816, "epss_percentile": 0.96806}, "CVE-2020-27224": {"epss_score": 0.009, "epss_percentile": 0.75163}, "CVE-2020-27225": {"epss_score": 0.00184, "epss_percentile": 0.40447}, "CVE-2020-27226": {"epss_score": 0.01434, "epss_percentile": 0.80262}, "CVE-2020-27227": {"epss_score": 0.05131, "epss_percentile": 0.8953}, "CVE-2020-27228": {"epss_score": 0.00142, "epss_percentile": 0.35033}, "CVE-2020-27229": {"epss_score": 0.00325, "epss_percentile": 0.54994}, "CVE-2020-27230": {"epss_score": 0.00325, "epss_percentile": 0.54994}, "CVE-2020-27231": {"epss_score": 0.0036, "epss_percentile": 0.57678}, "CVE-2020-27232": {"epss_score": 0.01541, "epss_percentile": 0.80947}, "CVE-2020-27233": {"epss_score": 0.0036, "epss_percentile": 0.57678}, "CVE-2020-27234": {"epss_score": 0.0036, "epss_percentile": 0.57678}, "CVE-2020-27235": {"epss_score": 0.0036, "epss_percentile": 0.57678}, "CVE-2020-27236": {"epss_score": 0.0036, "epss_percentile": 0.57678}, "CVE-2020-27237": {"epss_score": 0.0036, "epss_percentile": 0.57678}, "CVE-2020-27238": {"epss_score": 0.0036, "epss_percentile": 0.57678}, "CVE-2020-27239": {"epss_score": 0.00325, "epss_percentile": 0.54994}, "CVE-2020-27240": {"epss_score": 0.00325, "epss_percentile": 0.54994}, "CVE-2020-27241": {"epss_score": 0.00325, "epss_percentile": 0.54994}, "CVE-2020-27242": {"epss_score": 0.00325, "epss_percentile": 0.54994}, "CVE-2020-27243": {"epss_score": 0.00325, "epss_percentile": 0.54994}, "CVE-2020-27244": {"epss_score": 0.0036, "epss_percentile": 0.57678}, "CVE-2020-27245": {"epss_score": 0.00325, "epss_percentile": 0.54994}, "CVE-2020-27246": {"epss_score": 0.0036, "epss_percentile": 0.57678}, "CVE-2020-27247": {"epss_score": 0.00258, "epss_percentile": 0.48975}, "CVE-2020-27248": {"epss_score": 0.00258, "epss_percentile": 0.48975}, "CVE-2020-27249": {"epss_score": 0.00258, "epss_percentile": 0.48975}, "CVE-2020-27250": {"epss_score": 0.00258, "epss_percentile": 0.48975}, "CVE-2020-27251": {"epss_score": 0.19748, "epss_percentile": 0.95236}, "CVE-2020-27252": {"epss_score": 0.00598, "epss_percentile": 0.68763}, "CVE-2020-27253": {"epss_score": 0.00033, "epss_percentile": 0.09242}, "CVE-2020-27254": {"epss_score": 0.00196, "epss_percentile": 0.41767}, "CVE-2020-27255": {"epss_score": 0.01516, "epss_percentile": 0.80797}, "CVE-2020-27256": {"epss_score": 0.00053, "epss_percentile": 0.16818}, "CVE-2020-27257": {"epss_score": 0.00525, "epss_percentile": 0.66387}, "CVE-2020-27258": {"epss_score": 0.00141, "epss_percentile": 0.34953}, "CVE-2020-27259": {"epss_score": 0.00476, "epss_percentile": 0.64274}, "CVE-2020-27260": {"epss_score": 0.00109, "epss_percentile": 0.29909}, "CVE-2020-27261": {"epss_score": 0.01247, "epss_percentile": 0.78859}, "CVE-2020-27262": {"epss_score": 0.00159, "epss_percentile": 0.37308}, "CVE-2020-27263": {"epss_score": 0.00128, "epss_percentile": 0.33058}, "CVE-2020-27264": {"epss_score": 0.00097, "epss_percentile": 0.27563}, "CVE-2020-27265": {"epss_score": 0.00077, "epss_percentile": 0.23464}, "CVE-2020-27266": {"epss_score": 0.00068, "epss_percentile": 0.21211}, "CVE-2020-27267": {"epss_score": 0.00128, "epss_percentile": 0.33058}, "CVE-2020-27268": {"epss_score": 0.00072, "epss_percentile": 0.22304}, "CVE-2020-27269": {"epss_score": 0.00089, "epss_percentile": 0.25853}, "CVE-2020-27270": {"epss_score": 0.00048, "epss_percentile": 0.15023}, "CVE-2020-27272": {"epss_score": 0.00094, "epss_percentile": 0.26994}, "CVE-2020-27274": {"epss_score": 0.00403, "epss_percentile": 0.60378}, "CVE-2020-27275": {"epss_score": 0.00488, "epss_percentile": 0.64842}, "CVE-2020-27276": {"epss_score": 0.00078, "epss_percentile": 0.23603}, "CVE-2020-27277": {"epss_score": 0.00134, "epss_percentile": 0.33767}, "CVE-2020-27278": {"epss_score": 0.00051, "epss_percentile": 0.16104}, "CVE-2020-27279": {"epss_score": 0.00137, "epss_percentile": 0.34233}, "CVE-2020-27280": {"epss_score": 0.00311, "epss_percentile": 0.53866}, "CVE-2020-27281": {"epss_score": 0.00365, "epss_percentile": 0.58006}, "CVE-2020-27282": {"epss_score": 0.00074, "epss_percentile": 0.22801}, "CVE-2020-27283": {"epss_score": 0.00179, "epss_percentile": 0.39818}, "CVE-2020-27284": {"epss_score": 0.00265, "epss_percentile": 0.49801}, "CVE-2020-27285": {"epss_score": 0.0019, "epss_percentile": 0.41105}, "CVE-2020-27287": {"epss_score": 0.00368, "epss_percentile": 0.58169}, "CVE-2020-27288": {"epss_score": 0.00265, "epss_percentile": 0.49801}, "CVE-2020-27289": {"epss_score": 0.00205, "epss_percentile": 0.42721}, "CVE-2020-27290": {"epss_score": 0.00053, "epss_percentile": 0.16941}, "CVE-2020-27291": {"epss_score": 0.00205, "epss_percentile": 0.42721}, "CVE-2020-27293": {"epss_score": 0.00191, "epss_percentile": 0.4121}, "CVE-2020-27295": {"epss_score": 0.00258, "epss_percentile": 0.48981}, "CVE-2020-27297": {"epss_score": 0.00418, "epss_percentile": 0.61294}, "CVE-2020-27298": {"epss_score": 0.00225, "epss_percentile": 0.4509}, "CVE-2020-27299": {"epss_score": 0.00223, "epss_percentile": 0.44902}, "CVE-2020-27301": {"epss_score": 0.01049, "epss_percentile": 0.77058}, "CVE-2020-27302": {"epss_score": 0.00365, "epss_percentile": 0.58014}, "CVE-2020-27304": {"epss_score": 0.00995, "epss_percentile": 0.76431}, "CVE-2020-27336": {"epss_score": 0.00271, "epss_percentile": 0.50292}, "CVE-2020-27337": {"epss_score": 0.00379, "epss_percentile": 0.58886}, "CVE-2020-27338": {"epss_score": 0.00152, "epss_percentile": 0.36447}, "CVE-2020-27339": {"epss_score": 0.00056, "epss_percentile": 0.17957}, "CVE-2020-27340": {"epss_score": 0.00293, "epss_percentile": 0.52303}, "CVE-2020-27344": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2020-27347": {"epss_score": 0.00262, "epss_percentile": 0.49333}, "CVE-2020-27348": {"epss_score": 0.00065, "epss_percentile": 0.20669}, "CVE-2020-27349": {"epss_score": 0.00038, "epss_percentile": 0.11143}, "CVE-2020-27350": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2020-27351": {"epss_score": 0.00063, "epss_percentile": 0.19889}, "CVE-2020-27352": {"epss_score": 0.00187, "epss_percentile": 0.40768}, "CVE-2020-27356": {"epss_score": 0.00378, "epss_percentile": 0.58806}, "CVE-2020-27358": {"epss_score": 0.03426, "epss_percentile": 0.87115}, "CVE-2020-27359": {"epss_score": 0.00497, "epss_percentile": 0.65208}, "CVE-2020-27361": {"epss_score": 0.89331, "epss_percentile": 0.99519}, "CVE-2020-27362": {"epss_score": 0.00284, "epss_percentile": 0.51436}, "CVE-2020-27366": {"epss_score": 0.00078, "epss_percentile": 0.23755}, "CVE-2020-27368": {"epss_score": 0.00134, "epss_percentile": 0.33857}, "CVE-2020-27372": {"epss_score": 0.00502, "epss_percentile": 0.65402}, "CVE-2020-27373": {"epss_score": 0.00322, "epss_percentile": 0.54858}, "CVE-2020-27374": {"epss_score": 0.0012, "epss_percentile": 0.31725}, "CVE-2020-27375": {"epss_score": 0.00079, "epss_percentile": 0.23957}, "CVE-2020-27376": {"epss_score": 0.00109, "epss_percentile": 0.30023}, "CVE-2020-27377": {"epss_score": 0.0031, "epss_percentile": 0.53775}, "CVE-2020-27379": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2020-27383": {"epss_score": 0.00045, "epss_percentile": 0.13688}, "CVE-2020-27384": {"epss_score": 0.00045, "epss_percentile": 0.13688}, "CVE-2020-27385": {"epss_score": 0.00425, "epss_percentile": 0.61723}, "CVE-2020-27386": {"epss_score": 0.77946, "epss_percentile": 0.98961}, "CVE-2020-27387": {"epss_score": 0.70322, "epss_percentile": 0.98629}, "CVE-2020-27388": {"epss_score": 0.00561, "epss_percentile": 0.67661}, "CVE-2020-27397": {"epss_score": 0.02228, "epss_percentile": 0.84076}, "CVE-2020-27402": {"epss_score": 0.0008, "epss_percentile": 0.24168}, "CVE-2020-27403": {"epss_score": 0.0232, "epss_percentile": 0.84364}, "CVE-2020-27406": {"epss_score": 0.00213, "epss_percentile": 0.43917}, "CVE-2020-27408": {"epss_score": 0.01184, "epss_percentile": 0.78334}, "CVE-2020-27409": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2020-27413": {"epss_score": 0.00059, "epss_percentile": 0.18847}, "CVE-2020-27414": {"epss_score": 0.00269, "epss_percentile": 0.50114}, "CVE-2020-27416": {"epss_score": 0.00726, "epss_percentile": 0.72071}, "CVE-2020-27418": {"epss_score": 0.00081, "epss_percentile": 0.24395}, "CVE-2020-27422": {"epss_score": 0.10185, "epss_percentile": 0.92884}, "CVE-2020-27423": {"epss_score": 0.15393, "epss_percentile": 0.94422}, "CVE-2020-27428": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-27449": {"epss_score": 0.0181, "epss_percentile": 0.82364}, "CVE-2020-27459": {"epss_score": 0.00315, "epss_percentile": 0.54168}, "CVE-2020-27461": {"epss_score": 0.05674, "epss_percentile": 0.90107}, "CVE-2020-27464": {"epss_score": 0.0103, "epss_percentile": 0.76847}, "CVE-2020-27466": {"epss_score": 0.03723, "epss_percentile": 0.87629}, "CVE-2020-27467": {"epss_score": 0.79832, "epss_percentile": 0.99057}, "CVE-2020-27478": {"epss_score": 0.01414, "epss_percentile": 0.80128}, "CVE-2020-27481": {"epss_score": 0.51483, "epss_percentile": 0.97781}, "CVE-2020-27483": {"epss_score": 0.02305, "epss_percentile": 0.84322}, "CVE-2020-27484": {"epss_score": 0.00932, "epss_percentile": 0.75631}, "CVE-2020-27485": {"epss_score": 0.01093, "epss_percentile": 0.77477}, "CVE-2020-27486": {"epss_score": 0.00559, "epss_percentile": 0.67614}, "CVE-2020-27488": {"epss_score": 0.00985, "epss_percentile": 0.76318}, "CVE-2020-27507": {"epss_score": 0.00091, "epss_percentile": 0.26193}, "CVE-2020-27508": {"epss_score": 0.00341, "epss_percentile": 0.56306}, "CVE-2020-27509": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-27511": {"epss_score": 0.01274, "epss_percentile": 0.79091}, "CVE-2020-27514": {"epss_score": 0.01139, "epss_percentile": 0.77939}, "CVE-2020-27515": {"epss_score": 0.00538, "epss_percentile": 0.66936}, "CVE-2020-27518": {"epss_score": 0.00044, "epss_percentile": 0.13632}, "CVE-2020-27519": {"epss_score": 0.00044, "epss_percentile": 0.13637}, "CVE-2020-27523": {"epss_score": 0.01338, "epss_percentile": 0.79569}, "CVE-2020-27524": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2020-27533": {"epss_score": 0.00629, "epss_percentile": 0.69682}, "CVE-2020-27534": {"epss_score": 0.0077, "epss_percentile": 0.73002}, "CVE-2020-27539": {"epss_score": 0.00593, "epss_percentile": 0.68633}, "CVE-2020-27540": {"epss_score": 0.00203, "epss_percentile": 0.42502}, "CVE-2020-27541": {"epss_score": 0.00432, "epss_percentile": 0.62112}, "CVE-2020-27542": {"epss_score": 0.00758, "epss_percentile": 0.72771}, "CVE-2020-27543": {"epss_score": 0.01508, "epss_percentile": 0.80762}, "CVE-2020-27544": {"epss_score": 0.02328, "epss_percentile": 0.84395}, "CVE-2020-27545": {"epss_score": 0.00091, "epss_percentile": 0.26407}, "CVE-2020-27553": {"epss_score": 0.00365, "epss_percentile": 0.5801}, "CVE-2020-27554": {"epss_score": 0.00136, "epss_percentile": 0.3409}, "CVE-2020-27555": {"epss_score": 0.0267, "epss_percentile": 0.85387}, "CVE-2020-27556": {"epss_score": 0.00386, "epss_percentile": 0.59272}, "CVE-2020-27557": {"epss_score": 0.00046, "epss_percentile": 0.14397}, "CVE-2020-27558": {"epss_score": 0.00405, "epss_percentile": 0.60492}, "CVE-2020-27560": {"epss_score": 0.00128, "epss_percentile": 0.32975}, "CVE-2020-27568": {"epss_score": 0.00309, "epss_percentile": 0.53663}, "CVE-2020-27569": {"epss_score": 0.00246, "epss_percentile": 0.478}, "CVE-2020-27574": {"epss_score": 0.00219, "epss_percentile": 0.44527}, "CVE-2020-27575": {"epss_score": 0.06725, "epss_percentile": 0.9097}, "CVE-2020-27576": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-27583": {"epss_score": 0.04233, "epss_percentile": 0.88425}, "CVE-2020-27585": {"epss_score": 0.00042, "epss_percentile": 0.1279}, "CVE-2020-27586": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2020-27587": {"epss_score": 0.00054, "epss_percentile": 0.17112}, "CVE-2020-27589": {"epss_score": 0.00198, "epss_percentile": 0.41984}, "CVE-2020-27600": {"epss_score": 0.76357, "epss_percentile": 0.98888}, "CVE-2020-27601": {"epss_score": 0.00223, "epss_percentile": 0.44876}, "CVE-2020-27602": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-27603": {"epss_score": 0.26349, "epss_percentile": 0.96139}, "CVE-2020-27604": {"epss_score": 0.00237, "epss_percentile": 0.46726}, "CVE-2020-27605": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-27606": {"epss_score": 0.00243, "epss_percentile": 0.47458}, "CVE-2020-27607": {"epss_score": 0.00225, "epss_percentile": 0.45233}, "CVE-2020-27608": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-27609": {"epss_score": 0.00206, "epss_percentile": 0.42918}, "CVE-2020-27610": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-27611": {"epss_score": 0.00132, "epss_percentile": 0.33519}, "CVE-2020-27612": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2020-27613": {"epss_score": 0.00024, "epss_percentile": 0.05995}, "CVE-2020-27614": {"epss_score": 0.00031, "epss_percentile": 0.08574}, "CVE-2020-27615": {"epss_score": 0.80754, "epss_percentile": 0.99103}, "CVE-2020-27616": {"epss_score": 0.00438, "epss_percentile": 0.62558}, "CVE-2020-27617": {"epss_score": 0.00229, "epss_percentile": 0.45642}, "CVE-2020-27618": {"epss_score": 0.00072, "epss_percentile": 0.22241}, "CVE-2020-27619": {"epss_score": 0.01086, "epss_percentile": 0.77418}, "CVE-2020-27620": {"epss_score": 0.00528, "epss_percentile": 0.66542}, "CVE-2020-27621": {"epss_score": 0.00264, "epss_percentile": 0.49579}, "CVE-2020-27622": {"epss_score": 3e-05, "epss_percentile": 0.00081}, "CVE-2020-27623": {"epss_score": 3e-05, "epss_percentile": 0.00092}, "CVE-2020-27624": {"epss_score": 2e-05, "epss_percentile": 0.00056}, "CVE-2020-27625": {"epss_score": 3e-05, "epss_percentile": 0.00107}, "CVE-2020-27626": {"epss_score": 2e-05, "epss_percentile": 0.00056}, "CVE-2020-27627": {"epss_score": 3e-05, "epss_percentile": 0.00114}, "CVE-2020-27628": {"epss_score": 3e-05, "epss_percentile": 0.00069}, "CVE-2020-27629": {"epss_score": 3e-05, "epss_percentile": 0.00093}, "CVE-2020-27630": {"epss_score": 0.00184, "epss_percentile": 0.404}, "CVE-2020-27631": {"epss_score": 0.00184, "epss_percentile": 0.404}, "CVE-2020-27632": {"epss_score": 0.00379, "epss_percentile": 0.58846}, "CVE-2020-27633": {"epss_score": 0.00185, "epss_percentile": 0.40549}, "CVE-2020-27634": {"epss_score": 0.00185, "epss_percentile": 0.40549}, "CVE-2020-27635": {"epss_score": 0.00185, "epss_percentile": 0.40549}, "CVE-2020-27636": {"epss_score": 0.00185, "epss_percentile": 0.40549}, "CVE-2020-27637": {"epss_score": 0.00778, "epss_percentile": 0.73123}, "CVE-2020-27638": {"epss_score": 0.01106, "epss_percentile": 0.77621}, "CVE-2020-27639": {"epss_score": 0.00285, "epss_percentile": 0.51503}, "CVE-2020-27640": {"epss_score": 0.00285, "epss_percentile": 0.51503}, "CVE-2020-27642": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-27643": {"epss_score": 0.00119, "epss_percentile": 0.31679}, "CVE-2020-27644": {"epss_score": 0.00662, "epss_percentile": 0.70605}, "CVE-2020-27645": {"epss_score": 0.00662, "epss_percentile": 0.70605}, "CVE-2020-27646": {"epss_score": 0.00341, "epss_percentile": 0.56293}, "CVE-2020-27648": {"epss_score": 0.00192, "epss_percentile": 0.41374}, "CVE-2020-27649": {"epss_score": 0.00177, "epss_percentile": 0.39623}, "CVE-2020-27650": {"epss_score": 0.00168, "epss_percentile": 0.38479}, "CVE-2020-27651": {"epss_score": 0.00325, "epss_percentile": 0.54983}, "CVE-2020-27652": {"epss_score": 0.00408, "epss_percentile": 0.60655}, "CVE-2020-27653": {"epss_score": 0.00502, "epss_percentile": 0.65397}, "CVE-2020-27654": {"epss_score": 0.03047, "epss_percentile": 0.86285}, "CVE-2020-27655": {"epss_score": 0.01223, "epss_percentile": 0.78668}, "CVE-2020-27656": {"epss_score": 0.00099, "epss_percentile": 0.28404}, "CVE-2020-27657": {"epss_score": 0.00093, "epss_percentile": 0.26712}, "CVE-2020-27658": {"epss_score": 0.00264, "epss_percentile": 0.49691}, "CVE-2020-27659": {"epss_score": 0.00314, "epss_percentile": 0.54124}, "CVE-2020-27660": {"epss_score": 0.02197, "epss_percentile": 0.83961}, "CVE-2020-27661": {"epss_score": 0.0013, "epss_percentile": 0.33277}, "CVE-2020-27662": {"epss_score": 0.00231, "epss_percentile": 0.45803}, "CVE-2020-27663": {"epss_score": 0.00231, "epss_percentile": 0.45803}, "CVE-2020-27664": {"epss_score": 0.01344, "epss_percentile": 0.79612}, "CVE-2020-27665": {"epss_score": 0.00292, "epss_percentile": 0.52265}, "CVE-2020-27666": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-27670": {"epss_score": 0.00044, "epss_percentile": 0.13555}, "CVE-2020-27671": {"epss_score": 0.00071, "epss_percentile": 0.22235}, "CVE-2020-27672": {"epss_score": 0.00039, "epss_percentile": 0.11585}, "CVE-2020-27673": {"epss_score": 0.00055, "epss_percentile": 0.17547}, "CVE-2020-27674": {"epss_score": 0.00073, "epss_percentile": 0.22622}, "CVE-2020-27675": {"epss_score": 0.00088, "epss_percentile": 0.25666}, "CVE-2020-27678": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2020-27687": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2020-27688": {"epss_score": 0.08027, "epss_percentile": 0.91839}, "CVE-2020-27689": {"epss_score": 0.01564, "epss_percentile": 0.8106}, "CVE-2020-27690": {"epss_score": 0.00051, "epss_percentile": 0.16317}, "CVE-2020-27691": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-27692": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2020-27693": {"epss_score": 0.0008, "epss_percentile": 0.24019}, "CVE-2020-27694": {"epss_score": 0.01113, "epss_percentile": 0.7769}, "CVE-2020-27695": {"epss_score": 0.00065, "epss_percentile": 0.20509}, "CVE-2020-27696": {"epss_score": 0.00065, "epss_percentile": 0.20509}, "CVE-2020-27697": {"epss_score": 0.00051, "epss_percentile": 0.16108}, "CVE-2020-27708": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2020-27713": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-27714": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-27715": {"epss_score": 0.00611, "epss_percentile": 0.69187}, "CVE-2020-27716": {"epss_score": 0.00611, "epss_percentile": 0.69187}, "CVE-2020-27717": {"epss_score": 0.00916, "epss_percentile": 0.75421}, "CVE-2020-27718": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-27719": {"epss_score": 0.00466, "epss_percentile": 0.63802}, "CVE-2020-27720": {"epss_score": 0.00896, "epss_percentile": 0.75117}, "CVE-2020-27721": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-27722": {"epss_score": 0.00304, "epss_percentile": 0.53254}, "CVE-2020-27723": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-27724": {"epss_score": 0.00305, "epss_percentile": 0.5331}, "CVE-2020-27725": {"epss_score": 0.00295, "epss_percentile": 0.52478}, "CVE-2020-27726": {"epss_score": 0.00467, "epss_percentile": 0.63851}, "CVE-2020-27727": {"epss_score": 0.00274, "epss_percentile": 0.50576}, "CVE-2020-27728": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-27729": {"epss_score": 0.00218, "epss_percentile": 0.4441}, "CVE-2020-27730": {"epss_score": 0.0146, "epss_percentile": 0.80415}, "CVE-2020-27733": {"epss_score": 0.033, "epss_percentile": 0.86865}, "CVE-2020-27735": {"epss_score": 0.37, "epss_percentile": 0.97012}, "CVE-2020-27736": {"epss_score": 0.00827, "epss_percentile": 0.73985}, "CVE-2020-27737": {"epss_score": 0.00626, "epss_percentile": 0.69599}, "CVE-2020-27738": {"epss_score": 0.00867, "epss_percentile": 0.74648}, "CVE-2020-27739": {"epss_score": 0.02227, "epss_percentile": 0.84073}, "CVE-2020-27740": {"epss_score": 0.00409, "epss_percentile": 0.60728}, "CVE-2020-27741": {"epss_score": 0.00336, "epss_percentile": 0.55951}, "CVE-2020-27742": {"epss_score": 0.00157, "epss_percentile": 0.37114}, "CVE-2020-27743": {"epss_score": 0.00567, "epss_percentile": 0.6786}, "CVE-2020-27744": {"epss_score": 0.10407, "epss_percentile": 0.92976}, "CVE-2020-27745": {"epss_score": 0.00789, "epss_percentile": 0.73357}, "CVE-2020-27746": {"epss_score": 0.00269, "epss_percentile": 0.50191}, "CVE-2020-27747": {"epss_score": 0.00664, "epss_percentile": 0.70642}, "CVE-2020-27748": {"epss_score": 0.00324, "epss_percentile": 0.54933}, "CVE-2020-27749": {"epss_score": 0.00034, "epss_percentile": 0.09677}, "CVE-2020-27750": {"epss_score": 0.00119, "epss_percentile": 0.31658}, "CVE-2020-27751": {"epss_score": 0.00086, "epss_percentile": 0.25318}, "CVE-2020-27752": {"epss_score": 0.0032, "epss_percentile": 0.54635}, "CVE-2020-27753": {"epss_score": 0.00079, "epss_percentile": 0.23818}, "CVE-2020-27754": {"epss_score": 0.00086, "epss_percentile": 0.25318}, "CVE-2020-27755": {"epss_score": 0.00057, "epss_percentile": 0.1798}, "CVE-2020-27756": {"epss_score": 0.00134, "epss_percentile": 0.33921}, "CVE-2020-27757": {"epss_score": 0.00127, "epss_percentile": 0.32831}, "CVE-2020-27758": {"epss_score": 0.00086, "epss_percentile": 0.25318}, "CVE-2020-27759": {"epss_score": 0.00086, "epss_percentile": 0.25318}, "CVE-2020-27760": {"epss_score": 0.00156, "epss_percentile": 0.3696}, "CVE-2020-27761": {"epss_score": 0.00127, "epss_percentile": 0.32831}, "CVE-2020-27762": {"epss_score": 0.00119, "epss_percentile": 0.31658}, "CVE-2020-27763": {"epss_score": 0.00127, "epss_percentile": 0.32831}, "CVE-2020-27764": {"epss_score": 0.00094, "epss_percentile": 0.26986}, "CVE-2020-27765": {"epss_score": 0.00086, "epss_percentile": 0.25318}, "CVE-2020-27766": {"epss_score": 0.00135, "epss_percentile": 0.33989}, "CVE-2020-27767": {"epss_score": 0.00086, "epss_percentile": 0.25318}, "CVE-2020-27768": {"epss_score": 0.00078, "epss_percentile": 0.23603}, "CVE-2020-27769": {"epss_score": 0.00082, "epss_percentile": 0.24453}, "CVE-2020-27770": {"epss_score": 0.00119, "epss_percentile": 0.31658}, "CVE-2020-27771": {"epss_score": 0.00105, "epss_percentile": 0.29248}, "CVE-2020-27772": {"epss_score": 0.00086, "epss_percentile": 0.25318}, "CVE-2020-27773": {"epss_score": 0.00086, "epss_percentile": 0.25318}, "CVE-2020-27774": {"epss_score": 0.00086, "epss_percentile": 0.25318}, "CVE-2020-27775": {"epss_score": 0.00086, "epss_percentile": 0.25318}, "CVE-2020-27776": {"epss_score": 0.00065, "epss_percentile": 0.20651}, "CVE-2020-27777": {"epss_score": 0.00027, "epss_percentile": 0.0693}, "CVE-2020-27778": {"epss_score": 0.00283, "epss_percentile": 0.51384}, "CVE-2020-27779": {"epss_score": 0.00011, "epss_percentile": 0.01001}, "CVE-2020-27780": {"epss_score": 0.00436, "epss_percentile": 0.62385}, "CVE-2020-27781": {"epss_score": 0.00071, "epss_percentile": 0.22175}, "CVE-2020-27782": {"epss_score": 0.00182, "epss_percentile": 0.40156}, "CVE-2020-27783": {"epss_score": 0.01141, "epss_percentile": 0.77957}, "CVE-2020-27784": {"epss_score": 0.00024, "epss_percentile": 0.05744}, "CVE-2020-27786": {"epss_score": 0.08642, "epss_percentile": 0.92169}, "CVE-2020-27787": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2020-27788": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2020-27790": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2020-27792": {"epss_score": 0.00045, "epss_percentile": 0.13809}, "CVE-2020-27793": {"epss_score": 0.00382, "epss_percentile": 0.59054}, "CVE-2020-27794": {"epss_score": 0.00382, "epss_percentile": 0.59054}, "CVE-2020-27795": {"epss_score": 0.00501, "epss_percentile": 0.65337}, "CVE-2020-27796": {"epss_score": 0.00097, "epss_percentile": 0.27498}, "CVE-2020-27797": {"epss_score": 0.00132, "epss_percentile": 0.33509}, "CVE-2020-27798": {"epss_score": 0.00132, "epss_percentile": 0.33509}, "CVE-2020-27799": {"epss_score": 0.00136, "epss_percentile": 0.34164}, "CVE-2020-27800": {"epss_score": 0.00136, "epss_percentile": 0.34164}, "CVE-2020-27801": {"epss_score": 0.00146, "epss_percentile": 0.35644}, "CVE-2020-27802": {"epss_score": 0.00132, "epss_percentile": 0.33509}, "CVE-2020-27813": {"epss_score": 0.00177, "epss_percentile": 0.39567}, "CVE-2020-27814": {"epss_score": 0.00195, "epss_percentile": 0.41651}, "CVE-2020-27815": {"epss_score": 0.00182, "epss_percentile": 0.40219}, "CVE-2020-27816": {"epss_score": 0.00167, "epss_percentile": 0.38342}, "CVE-2020-27818": {"epss_score": 0.00163, "epss_percentile": 0.37793}, "CVE-2020-27819": {"epss_score": 0.00269, "epss_percentile": 0.50166}, "CVE-2020-27820": {"epss_score": 0.00021, "epss_percentile": 0.04915}, "CVE-2020-27821": {"epss_score": 0.00036, "epss_percentile": 0.10492}, "CVE-2020-27822": {"epss_score": 0.00339, "epss_percentile": 0.56199}, "CVE-2020-27823": {"epss_score": 0.00037, "epss_percentile": 0.10768}, "CVE-2020-27824": {"epss_score": 0.00253, "epss_percentile": 0.48438}, "CVE-2020-27825": {"epss_score": 0.00138, "epss_percentile": 0.34354}, "CVE-2020-27826": {"epss_score": 0.00166, "epss_percentile": 0.38161}, "CVE-2020-27827": {"epss_score": 0.00415, "epss_percentile": 0.61156}, "CVE-2020-27828": {"epss_score": 0.00181, "epss_percentile": 0.40029}, "CVE-2020-27829": {"epss_score": 0.00153, "epss_percentile": 0.3654}, "CVE-2020-27830": {"epss_score": 0.00146, "epss_percentile": 0.35559}, "CVE-2020-27831": {"epss_score": 0.00127, "epss_percentile": 0.32873}, "CVE-2020-27832": {"epss_score": 0.00447, "epss_percentile": 0.62938}, "CVE-2020-27833": {"epss_score": 0.0013, "epss_percentile": 0.33273}, "CVE-2020-27835": {"epss_score": 0.00068, "epss_percentile": 0.21394}, "CVE-2020-27836": {"epss_score": 0.00716, "epss_percentile": 0.71861}, "CVE-2020-27837": {"epss_score": 0.00056, "epss_percentile": 0.17799}, "CVE-2020-27838": {"epss_score": 0.78293, "epss_percentile": 0.98978}, "CVE-2020-27839": {"epss_score": 0.00335, "epss_percentile": 0.5584}, "CVE-2020-27840": {"epss_score": 0.17985, "epss_percentile": 0.94937}, "CVE-2020-27841": {"epss_score": 0.00098, "epss_percentile": 0.27827}, "CVE-2020-27842": {"epss_score": 0.00088, "epss_percentile": 0.257}, "CVE-2020-27843": {"epss_score": 0.00104, "epss_percentile": 0.29223}, "CVE-2020-27844": {"epss_score": 0.01655, "epss_percentile": 0.81592}, "CVE-2020-27845": {"epss_score": 0.00088, "epss_percentile": 0.257}, "CVE-2020-27846": {"epss_score": 0.0773, "epss_percentile": 0.91648}, "CVE-2020-27847": {"epss_score": 0.00357, "epss_percentile": 0.57467}, "CVE-2020-27848": {"epss_score": 0.00443, "epss_percentile": 0.62755}, "CVE-2020-27850": {"epss_score": 0.00248, "epss_percentile": 0.47978}, "CVE-2020-27851": {"epss_score": 0.00227, "epss_percentile": 0.45383}, "CVE-2020-27852": {"epss_score": 0.00217, "epss_percentile": 0.44311}, "CVE-2020-27853": {"epss_score": 0.03224, "epss_percentile": 0.8668}, "CVE-2020-27855": {"epss_score": 0.00352, "epss_percentile": 0.57107}, "CVE-2020-27856": {"epss_score": 0.00352, "epss_percentile": 0.57107}, "CVE-2020-27857": {"epss_score": 0.00675, "epss_percentile": 0.70904}, "CVE-2020-27858": {"epss_score": 0.20151, "epss_percentile": 0.95295}, "CVE-2020-27859": {"epss_score": 0.04378, "epss_percentile": 0.88621}, "CVE-2020-27860": {"epss_score": 0.13936, "epss_percentile": 0.94096}, "CVE-2020-27861": {"epss_score": 0.00122, "epss_percentile": 0.32127}, "CVE-2020-27862": {"epss_score": 0.03368, "epss_percentile": 0.87007}, "CVE-2020-27863": {"epss_score": 0.0222, "epss_percentile": 0.84048}, "CVE-2020-27864": {"epss_score": 0.15591, "epss_percentile": 0.94466}, "CVE-2020-27865": {"epss_score": 0.23503, "epss_percentile": 0.95786}, "CVE-2020-27866": {"epss_score": 0.9036, "epss_percentile": 0.99579}, "CVE-2020-27867": {"epss_score": 0.00133, "epss_percentile": 0.33662}, "CVE-2020-27868": {"epss_score": 0.68707, "epss_percentile": 0.98559}, "CVE-2020-27869": {"epss_score": 0.64952, "epss_percentile": 0.98399}, "CVE-2020-27870": {"epss_score": 0.09524, "epss_percentile": 0.92585}, "CVE-2020-27871": {"epss_score": 0.8811, "epss_percentile": 0.99457}, "CVE-2020-27872": {"epss_score": 0.01112, "epss_percentile": 0.77672}, "CVE-2020-27873": {"epss_score": 0.00327, "epss_percentile": 0.55134}, "CVE-2020-27874": {"epss_score": 0.01203, "epss_percentile": 0.78494}, "CVE-2020-27885": {"epss_score": 0.01056, "epss_percentile": 0.77124}, "CVE-2020-27886": {"epss_score": 0.0209, "epss_percentile": 0.83563}, "CVE-2020-27887": {"epss_score": 0.00964, "epss_percentile": 0.76035}, "CVE-2020-27888": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2020-27890": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2020-27891": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2020-27892": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2020-27893": {"epss_score": 0.00405, "epss_percentile": 0.6049}, "CVE-2020-27894": {"epss_score": 0.00328, "epss_percentile": 0.55272}, "CVE-2020-27895": {"epss_score": 0.00169, "epss_percentile": 0.38606}, "CVE-2020-27896": {"epss_score": 0.00978, "epss_percentile": 0.76235}, "CVE-2020-27897": {"epss_score": 0.00105, "epss_percentile": 0.29393}, "CVE-2020-27898": {"epss_score": 0.00159, "epss_percentile": 0.37422}, "CVE-2020-27899": {"epss_score": 0.00149, "epss_percentile": 0.35941}, "CVE-2020-27900": {"epss_score": 0.00227, "epss_percentile": 0.4538}, "CVE-2020-27901": {"epss_score": 0.00188, "epss_percentile": 0.40854}, "CVE-2020-27902": {"epss_score": 0.00054, "epss_percentile": 0.17249}, "CVE-2020-27903": {"epss_score": 0.0033, "epss_percentile": 0.55449}, "CVE-2020-27904": {"epss_score": 0.05023, "epss_percentile": 0.89406}, "CVE-2020-27905": {"epss_score": 0.00533, "epss_percentile": 0.66756}, "CVE-2020-27906": {"epss_score": 0.02319, "epss_percentile": 0.84363}, "CVE-2020-27907": {"epss_score": 0.00235, "epss_percentile": 0.46244}, "CVE-2020-27908": {"epss_score": 0.00482, "epss_percentile": 0.64545}, "CVE-2020-27909": {"epss_score": 0.00522, "epss_percentile": 0.66256}, "CVE-2020-27910": {"epss_score": 0.00813, "epss_percentile": 0.73761}, "CVE-2020-27911": {"epss_score": 0.02512, "epss_percentile": 0.84976}, "CVE-2020-27912": {"epss_score": 0.00989, "epss_percentile": 0.76365}, "CVE-2020-27914": {"epss_score": 0.00235, "epss_percentile": 0.46244}, "CVE-2020-27915": {"epss_score": 0.00235, "epss_percentile": 0.46244}, "CVE-2020-27916": {"epss_score": 0.00622, "epss_percentile": 0.69531}, "CVE-2020-27917": {"epss_score": 0.00712, "epss_percentile": 0.71781}, "CVE-2020-27918": {"epss_score": 0.00234, "epss_percentile": 0.46114}, "CVE-2020-27919": {"epss_score": 0.00616, "epss_percentile": 0.69335}, "CVE-2020-27920": {"epss_score": 0.00547, "epss_percentile": 0.67244}, "CVE-2020-27921": {"epss_score": 0.00184, "epss_percentile": 0.40426}, "CVE-2020-27922": {"epss_score": 0.00482, "epss_percentile": 0.64545}, "CVE-2020-27923": {"epss_score": 0.00482, "epss_percentile": 0.64545}, "CVE-2020-27924": {"epss_score": 0.00413, "epss_percentile": 0.60958}, "CVE-2020-27925": {"epss_score": 0.00061, "epss_percentile": 0.19495}, "CVE-2020-27926": {"epss_score": 0.00477, "epss_percentile": 0.64322}, "CVE-2020-27927": {"epss_score": 0.00592, "epss_percentile": 0.68621}, "CVE-2020-27929": {"epss_score": 0.00194, "epss_percentile": 0.41528}, "CVE-2020-27930": {"epss_score": 0.47173, "epss_percentile": 0.97572}, "CVE-2020-27931": {"epss_score": 0.00433, "epss_percentile": 0.62225}, "CVE-2020-27932": {"epss_score": 0.113, "epss_percentile": 0.93298}, "CVE-2020-27933": {"epss_score": 0.00483, "epss_percentile": 0.6456}, "CVE-2020-27935": {"epss_score": 0.05665, "epss_percentile": 0.90101}, "CVE-2020-27936": {"epss_score": 0.00039, "epss_percentile": 0.11794}, "CVE-2020-27937": {"epss_score": 0.00583, "epss_percentile": 0.68354}, "CVE-2020-27938": {"epss_score": 0.00153, "epss_percentile": 0.3655}, "CVE-2020-27939": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2020-27940": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2020-27941": {"epss_score": 0.00232, "epss_percentile": 0.45899}, "CVE-2020-27942": {"epss_score": 0.00348, "epss_percentile": 0.56837}, "CVE-2020-27943": {"epss_score": 0.00433, "epss_percentile": 0.62225}, "CVE-2020-27944": {"epss_score": 0.00461, "epss_percentile": 0.63568}, "CVE-2020-27945": {"epss_score": 0.00266, "epss_percentile": 0.49907}, "CVE-2020-27946": {"epss_score": 0.00324, "epss_percentile": 0.5493}, "CVE-2020-27947": {"epss_score": 0.00245, "epss_percentile": 0.47647}, "CVE-2020-27948": {"epss_score": 0.00461, "epss_percentile": 0.63568}, "CVE-2020-27949": {"epss_score": 0.00215, "epss_percentile": 0.44109}, "CVE-2020-27950": {"epss_score": 0.46919, "epss_percentile": 0.97562}, "CVE-2020-27951": {"epss_score": 0.00442, "epss_percentile": 0.62702}, "CVE-2020-27952": {"epss_score": 0.00491, "epss_percentile": 0.64957}, "CVE-2020-27955": {"epss_score": 0.92617, "epss_percentile": 0.99731}, "CVE-2020-27956": {"epss_score": 0.07715, "epss_percentile": 0.91639}, "CVE-2020-27957": {"epss_score": 0.00315, "epss_percentile": 0.54197}, "CVE-2020-27958": {"epss_score": 0.00216, "epss_percentile": 0.44229}, "CVE-2020-27969": {"epss_score": 0.00092, "epss_percentile": 0.26584}, "CVE-2020-27970": {"epss_score": 0.00208, "epss_percentile": 0.43301}, "CVE-2020-27974": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-27975": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2020-27976": {"epss_score": 0.20023, "epss_percentile": 0.95276}, "CVE-2020-27977": {"epss_score": 0.00068, "epss_percentile": 0.21234}, "CVE-2020-27978": {"epss_score": 0.00677, "epss_percentile": 0.70949}, "CVE-2020-27980": {"epss_score": 0.00402, "epss_percentile": 0.6028}, "CVE-2020-27982": {"epss_score": 0.07869, "epss_percentile": 0.91734}, "CVE-2020-27985": {"epss_score": 0.00057, "epss_percentile": 0.18042}, "CVE-2020-27986": {"epss_score": 0.92573, "epss_percentile": 0.99728}, "CVE-2020-27988": {"epss_score": 0.3019, "epss_percentile": 0.96517}, "CVE-2020-27989": {"epss_score": 0.05953, "epss_percentile": 0.90358}, "CVE-2020-27990": {"epss_score": 0.05953, "epss_percentile": 0.90358}, "CVE-2020-27991": {"epss_score": 0.05953, "epss_percentile": 0.90358}, "CVE-2020-27992": {"epss_score": 0.00039, "epss_percentile": 0.11571}, "CVE-2020-27993": {"epss_score": 0.00738, "epss_percentile": 0.72342}, "CVE-2020-27994": {"epss_score": 0.01886, "epss_percentile": 0.8271}, "CVE-2020-27995": {"epss_score": 0.3594, "epss_percentile": 0.96942}, "CVE-2020-27996": {"epss_score": 0.00516, "epss_percentile": 0.66036}, "CVE-2020-27997": {"epss_score": 0.00186, "epss_percentile": 0.40654}, "CVE-2020-27998": {"epss_score": 0.00551, "epss_percentile": 0.6736}, "CVE-2020-28001": {"epss_score": 0.0163, "epss_percentile": 0.81442}, "CVE-2020-28002": {"epss_score": 0.00208, "epss_percentile": 0.43268}, "CVE-2020-28005": {"epss_score": 0.00921, "epss_percentile": 0.75483}, "CVE-2020-28007": {"epss_score": 0.00226, "epss_percentile": 0.45347}, "CVE-2020-28008": {"epss_score": 0.00146, "epss_percentile": 0.35574}, "CVE-2020-28009": {"epss_score": 0.00236, "epss_percentile": 0.46358}, "CVE-2020-28010": {"epss_score": 0.00163, "epss_percentile": 0.37761}, "CVE-2020-28011": {"epss_score": 0.00196, "epss_percentile": 0.41784}, "CVE-2020-28012": {"epss_score": 0.0019, "epss_percentile": 0.41008}, "CVE-2020-28013": {"epss_score": 0.00196, "epss_percentile": 0.41784}, "CVE-2020-28014": {"epss_score": 0.00215, "epss_percentile": 0.44042}, "CVE-2020-28015": {"epss_score": 0.0019, "epss_percentile": 0.41008}, "CVE-2020-28016": {"epss_score": 0.00194, "epss_percentile": 0.41571}, "CVE-2020-28017": {"epss_score": 0.03939, "epss_percentile": 0.87988}, "CVE-2020-28018": {"epss_score": 0.76126, "epss_percentile": 0.98879}, "CVE-2020-28019": {"epss_score": 0.01692, "epss_percentile": 0.8179}, "CVE-2020-28020": {"epss_score": 0.19885, "epss_percentile": 0.95255}, "CVE-2020-28021": {"epss_score": 0.07881, "epss_percentile": 0.9174}, "CVE-2020-28022": {"epss_score": 0.02021, "epss_percentile": 0.83299}, "CVE-2020-28023": {"epss_score": 0.03519, "epss_percentile": 0.87283}, "CVE-2020-28024": {"epss_score": 0.04055, "epss_percentile": 0.88184}, "CVE-2020-28025": {"epss_score": 0.01669, "epss_percentile": 0.81664}, "CVE-2020-28026": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2020-28030": {"epss_score": 0.01065, "epss_percentile": 0.77206}, "CVE-2020-28031": {"epss_score": 0.00341, "epss_percentile": 0.563}, "CVE-2020-28032": {"epss_score": 0.20723, "epss_percentile": 0.95406}, "CVE-2020-28033": {"epss_score": 0.01258, "epss_percentile": 0.78959}, "CVE-2020-28034": {"epss_score": 0.02678, "epss_percentile": 0.85409}, "CVE-2020-28035": {"epss_score": 0.04877, "epss_percentile": 0.89242}, "CVE-2020-28036": {"epss_score": 0.04185, "epss_percentile": 0.8836}, "CVE-2020-28037": {"epss_score": 0.1273, "epss_percentile": 0.9376}, "CVE-2020-28038": {"epss_score": 0.16023, "epss_percentile": 0.94561}, "CVE-2020-28039": {"epss_score": 0.05996, "epss_percentile": 0.90391}, "CVE-2020-28040": {"epss_score": 0.00306, "epss_percentile": 0.53456}, "CVE-2020-28041": {"epss_score": 0.0106, "epss_percentile": 0.77169}, "CVE-2020-28042": {"epss_score": 0.35995, "epss_percentile": 0.96945}, "CVE-2020-28043": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2020-28044": {"epss_score": 0.00094, "epss_percentile": 0.26985}, "CVE-2020-28045": {"epss_score": 0.00064, "epss_percentile": 0.20254}, "CVE-2020-28046": {"epss_score": 0.00104, "epss_percentile": 0.29229}, "CVE-2020-28047": {"epss_score": 0.00219, "epss_percentile": 0.44485}, "CVE-2020-28049": {"epss_score": 0.00037, "epss_percentile": 0.10907}, "CVE-2020-28050": {"epss_score": 0.01601, "epss_percentile": 0.81261}, "CVE-2020-28052": {"epss_score": 0.0306, "epss_percentile": 0.86308}, "CVE-2020-28053": {"epss_score": 0.00257, "epss_percentile": 0.48874}, "CVE-2020-28054": {"epss_score": 0.01163, "epss_percentile": 0.78158}, "CVE-2020-28055": {"epss_score": 0.00062, "epss_percentile": 0.19705}, "CVE-2020-28062": {"epss_score": 0.00833, "epss_percentile": 0.74083}, "CVE-2020-28063": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-28070": {"epss_score": 0.04216, "epss_percentile": 0.88406}, "CVE-2020-28071": {"epss_score": 0.00288, "epss_percentile": 0.51975}, "CVE-2020-28072": {"epss_score": 0.02569, "epss_percentile": 0.85124}, "CVE-2020-28073": {"epss_score": 0.00842, "epss_percentile": 0.74245}, "CVE-2020-28074": {"epss_score": 0.00842, "epss_percentile": 0.74245}, "CVE-2020-28086": {"epss_score": 0.00113, "epss_percentile": 0.3062}, "CVE-2020-28087": {"epss_score": 0.00707, "epss_percentile": 0.71661}, "CVE-2020-28088": {"epss_score": 0.05875, "epss_percentile": 0.90284}, "CVE-2020-28091": {"epss_score": 0.04097, "epss_percentile": 0.88253}, "CVE-2020-28092": {"epss_score": 0.00919, "epss_percentile": 0.75458}, "CVE-2020-28093": {"epss_score": 0.00451, "epss_percentile": 0.63132}, "CVE-2020-28094": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-28095": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2020-28096": {"epss_score": 0.00049, "epss_percentile": 0.15329}, "CVE-2020-28097": {"epss_score": 0.00091, "epss_percentile": 0.26213}, "CVE-2020-28102": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-28103": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-28115": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2020-28119": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-28124": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2020-28129": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-28130": {"epss_score": 0.08464, "epss_percentile": 0.92066}, "CVE-2020-28133": {"epss_score": 0.00914, "epss_percentile": 0.75395}, "CVE-2020-28136": {"epss_score": 0.02415, "epss_percentile": 0.84686}, "CVE-2020-28137": {"epss_score": 0.00103, "epss_percentile": 0.28902}, "CVE-2020-28138": {"epss_score": 0.00419, "epss_percentile": 0.6138}, "CVE-2020-28139": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2020-28140": {"epss_score": 0.00576, "epss_percentile": 0.68144}, "CVE-2020-28141": {"epss_score": 0.00517, "epss_percentile": 0.66062}, "CVE-2020-28144": {"epss_score": 0.0278, "epss_percentile": 0.85649}, "CVE-2020-28145": {"epss_score": 0.00297, "epss_percentile": 0.52692}, "CVE-2020-28146": {"epss_score": 0.00728, "epss_percentile": 0.72115}, "CVE-2020-28149": {"epss_score": 0.00339, "epss_percentile": 0.56205}, "CVE-2020-28150": {"epss_score": 0.00207, "epss_percentile": 0.43155}, "CVE-2020-28163": {"epss_score": 0.00111, "epss_percentile": 0.30407}, "CVE-2020-28165": {"epss_score": 0.00596, "epss_percentile": 0.68718}, "CVE-2020-28168": {"epss_score": 0.00446, "epss_percentile": 0.6289}, "CVE-2020-28169": {"epss_score": 0.01616, "epss_percentile": 0.81361}, "CVE-2020-28172": {"epss_score": 0.04247, "epss_percentile": 0.88442}, "CVE-2020-28173": {"epss_score": 0.03804, "epss_percentile": 0.87749}, "CVE-2020-28175": {"epss_score": 0.00058, "epss_percentile": 0.18362}, "CVE-2020-28183": {"epss_score": 0.01128, "epss_percentile": 0.77833}, "CVE-2020-28184": {"epss_score": 0.00236, "epss_percentile": 0.46379}, "CVE-2020-28185": {"epss_score": 0.90659, "epss_percentile": 0.99595}, "CVE-2020-28186": {"epss_score": 0.30022, "epss_percentile": 0.96497}, "CVE-2020-28187": {"epss_score": 0.64157, "epss_percentile": 0.98367}, "CVE-2020-28188": {"epss_score": 0.9344, "epss_percentile": 0.99807}, "CVE-2020-28190": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-28191": {"epss_score": 0.00224, "epss_percentile": 0.44976}, "CVE-2020-28194": {"epss_score": 0.00633, "epss_percentile": 0.69774}, "CVE-2020-28196": {"epss_score": 0.00377, "epss_percentile": 0.58708}, "CVE-2020-28198": {"epss_score": 0.00095, "epss_percentile": 0.27223}, "CVE-2020-28199": {"epss_score": 0.00361, "epss_percentile": 0.57696}, "CVE-2020-28200": {"epss_score": 0.01023, "epss_percentile": 0.76773}, "CVE-2020-28203": {"epss_score": 0.00022, "epss_percentile": 0.05133}, "CVE-2020-28206": {"epss_score": 0.00206, "epss_percentile": 0.42767}, "CVE-2020-28208": {"epss_score": 0.52667, "epss_percentile": 0.97835}, "CVE-2020-28209": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2020-28210": {"epss_score": 0.00373, "epss_percentile": 0.58521}, "CVE-2020-28211": {"epss_score": 0.00055, "epss_percentile": 0.17473}, "CVE-2020-28212": {"epss_score": 0.00346, "epss_percentile": 0.56629}, "CVE-2020-28213": {"epss_score": 0.00349, "epss_percentile": 0.56868}, "CVE-2020-28214": {"epss_score": 0.00088, "epss_percentile": 0.25744}, "CVE-2020-28215": {"epss_score": 0.00988, "epss_percentile": 0.76357}, "CVE-2020-28216": {"epss_score": 0.00081, "epss_percentile": 0.24302}, "CVE-2020-28217": {"epss_score": 0.00062, "epss_percentile": 0.1978}, "CVE-2020-28218": {"epss_score": 0.00159, "epss_percentile": 0.37391}, "CVE-2020-28219": {"epss_score": 0.00047, "epss_percentile": 0.14787}, "CVE-2020-28220": {"epss_score": 0.00276, "epss_percentile": 0.50768}, "CVE-2020-28221": {"epss_score": 0.00924, "epss_percentile": 0.75523}, "CVE-2020-28241": {"epss_score": 0.00209, "epss_percentile": 0.43412}, "CVE-2020-28242": {"epss_score": 0.00591, "epss_percentile": 0.68597}, "CVE-2020-28243": {"epss_score": 0.01528, "epss_percentile": 0.80871}, "CVE-2020-28246": {"epss_score": 0.03455, "epss_percentile": 0.87172}, "CVE-2020-28247": {"epss_score": 0.0026, "epss_percentile": 0.49189}, "CVE-2020-28248": {"epss_score": 0.01001, "epss_percentile": 0.76495}, "CVE-2020-28249": {"epss_score": 0.0044, "epss_percentile": 0.62648}, "CVE-2020-28250": {"epss_score": 0.02597, "epss_percentile": 0.85201}, "CVE-2020-28251": {"epss_score": 0.00442, "epss_percentile": 0.62751}, "CVE-2020-28267": {"epss_score": 0.01927, "epss_percentile": 0.82928}, "CVE-2020-28268": {"epss_score": 0.02284, "epss_percentile": 0.84261}, "CVE-2020-28269": {"epss_score": 0.02626, "epss_percentile": 0.85266}, "CVE-2020-28270": {"epss_score": 0.02947, "epss_percentile": 0.86047}, "CVE-2020-28271": {"epss_score": 0.02626, "epss_percentile": 0.85266}, "CVE-2020-28272": {"epss_score": 0.02883, "epss_percentile": 0.85905}, "CVE-2020-28273": {"epss_score": 0.03864, "epss_percentile": 0.8787}, "CVE-2020-28274": {"epss_score": 0.0178, "epss_percentile": 0.82236}, "CVE-2020-28276": {"epss_score": 0.02883, "epss_percentile": 0.85905}, "CVE-2020-28277": {"epss_score": 0.02354, "epss_percentile": 0.84478}, "CVE-2020-28278": {"epss_score": 0.02883, "epss_percentile": 0.85905}, "CVE-2020-28279": {"epss_score": 0.02883, "epss_percentile": 0.85905}, "CVE-2020-28280": {"epss_score": 0.02354, "epss_percentile": 0.84478}, "CVE-2020-28281": {"epss_score": 0.04322, "epss_percentile": 0.88549}, "CVE-2020-28282": {"epss_score": 0.01979, "epss_percentile": 0.83131}, "CVE-2020-28283": {"epss_score": 0.02811, "epss_percentile": 0.85721}, "CVE-2020-28327": {"epss_score": 0.02764, "epss_percentile": 0.85608}, "CVE-2020-28328": {"epss_score": 0.49533, "epss_percentile": 0.97693}, "CVE-2020-28329": {"epss_score": 0.00706, "epss_percentile": 0.71613}, "CVE-2020-28330": {"epss_score": 0.00371, "epss_percentile": 0.58353}, "CVE-2020-28331": {"epss_score": 0.00523, "epss_percentile": 0.6629}, "CVE-2020-28332": {"epss_score": 0.00213, "epss_percentile": 0.43846}, "CVE-2020-28333": {"epss_score": 0.01449, "epss_percentile": 0.80342}, "CVE-2020-28334": {"epss_score": 0.13024, "epss_percentile": 0.93848}, "CVE-2020-28337": {"epss_score": 0.1411, "epss_percentile": 0.94134}, "CVE-2020-28339": {"epss_score": 0.00848, "epss_percentile": 0.74363}, "CVE-2020-28340": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-28341": {"epss_score": 0.00018, "epss_percentile": 0.03721}, "CVE-2020-28342": {"epss_score": 0.00069, "epss_percentile": 0.21446}, "CVE-2020-28343": {"epss_score": 0.00083, "epss_percentile": 0.24621}, "CVE-2020-28344": {"epss_score": 0.00145, "epss_percentile": 0.35486}, "CVE-2020-28345": {"epss_score": 0.00132, "epss_percentile": 0.33595}, "CVE-2020-28346": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2020-28347": {"epss_score": 0.82625, "epss_percentile": 0.99202}, "CVE-2020-28348": {"epss_score": 0.00493, "epss_percentile": 0.65051}, "CVE-2020-28349": {"epss_score": 0.00501, "epss_percentile": 0.65343}, "CVE-2020-28350": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-28351": {"epss_score": 0.09311, "epss_percentile": 0.92495}, "CVE-2020-28360": {"epss_score": 0.02409, "epss_percentile": 0.8466}, "CVE-2020-28361": {"epss_score": 0.00135, "epss_percentile": 0.3394}, "CVE-2020-28362": {"epss_score": 0.00213, "epss_percentile": 0.43839}, "CVE-2020-28364": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-28365": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-28366": {"epss_score": 0.00167, "epss_percentile": 0.38316}, "CVE-2020-28367": {"epss_score": 0.00272, "epss_percentile": 0.50414}, "CVE-2020-28368": {"epss_score": 0.00067, "epss_percentile": 0.20966}, "CVE-2020-28369": {"epss_score": 0.00115, "epss_percentile": 0.30954}, "CVE-2020-28371": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-28373": {"epss_score": 0.0011, "epss_percentile": 0.30175}, "CVE-2020-28374": {"epss_score": 0.00345, "epss_percentile": 0.56583}, "CVE-2020-28381": {"epss_score": 0.00358, "epss_percentile": 0.57491}, "CVE-2020-28382": {"epss_score": 0.00344, "epss_percentile": 0.5654}, "CVE-2020-28383": {"epss_score": 0.00396, "epss_percentile": 0.5989}, "CVE-2020-28384": {"epss_score": 0.0096, "epss_percentile": 0.75972}, "CVE-2020-28385": {"epss_score": 0.00357, "epss_percentile": 0.57474}, "CVE-2020-28386": {"epss_score": 0.00344, "epss_percentile": 0.5654}, "CVE-2020-28387": {"epss_score": 0.0022, "epss_percentile": 0.4462}, "CVE-2020-28388": {"epss_score": 0.00422, "epss_percentile": 0.61577}, "CVE-2020-28390": {"epss_score": 0.00047, "epss_percentile": 0.14889}, "CVE-2020-28391": {"epss_score": 0.00151, "epss_percentile": 0.36257}, "CVE-2020-28392": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-28393": {"epss_score": 0.00528, "epss_percentile": 0.66536}, "CVE-2020-28394": {"epss_score": 0.00069, "epss_percentile": 0.21475}, "CVE-2020-28395": {"epss_score": 0.0017, "epss_percentile": 0.38741}, "CVE-2020-28396": {"epss_score": 0.00174, "epss_percentile": 0.39216}, "CVE-2020-28397": {"epss_score": 0.00183, "epss_percentile": 0.40297}, "CVE-2020-28398": {"epss_score": 0.00071, "epss_percentile": 0.22221}, "CVE-2020-28400": {"epss_score": 0.0108, "epss_percentile": 0.77367}, "CVE-2020-28401": {"epss_score": 0.00344, "epss_percentile": 0.56537}, "CVE-2020-28402": {"epss_score": 0.00351, "epss_percentile": 0.57006}, "CVE-2020-28403": {"epss_score": 0.00164, "epss_percentile": 0.37986}, "CVE-2020-28404": {"epss_score": 0.00344, "epss_percentile": 0.56537}, "CVE-2020-28405": {"epss_score": 0.00506, "epss_percentile": 0.65631}, "CVE-2020-28406": {"epss_score": 0.00344, "epss_percentile": 0.56537}, "CVE-2020-28407": {"epss_score": 0.00015, "epss_percentile": 0.02411}, "CVE-2020-28408": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-28409": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-28413": {"epss_score": 0.02421, "epss_percentile": 0.84704}, "CVE-2020-28414": {"epss_score": 0.01018, "epss_percentile": 0.76718}, "CVE-2020-28415": {"epss_score": 0.01018, "epss_percentile": 0.76718}, "CVE-2020-28416": {"epss_score": 0.00059, "epss_percentile": 0.18914}, "CVE-2020-28419": {"epss_score": 0.00776, "epss_percentile": 0.73105}, "CVE-2020-28421": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2020-28422": {"epss_score": 0.00314, "epss_percentile": 0.54093}, "CVE-2020-28423": {"epss_score": 0.00486, "epss_percentile": 0.64766}, "CVE-2020-28424": {"epss_score": 0.00357, "epss_percentile": 0.57466}, "CVE-2020-28425": {"epss_score": 0.00463, "epss_percentile": 0.637}, "CVE-2020-28426": {"epss_score": 0.0691, "epss_percentile": 0.91112}, "CVE-2020-28429": {"epss_score": 0.8418, "epss_percentile": 0.99277}, "CVE-2020-28433": {"epss_score": 0.00463, "epss_percentile": 0.637}, "CVE-2020-28434": {"epss_score": 0.00486, "epss_percentile": 0.64766}, "CVE-2020-28435": {"epss_score": 0.00486, "epss_percentile": 0.64766}, "CVE-2020-28436": {"epss_score": 0.00463, "epss_percentile": 0.637}, "CVE-2020-28437": {"epss_score": 0.00486, "epss_percentile": 0.64766}, "CVE-2020-28438": {"epss_score": 0.00486, "epss_percentile": 0.64766}, "CVE-2020-28439": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-28440": {"epss_score": 0.04064, "epss_percentile": 0.88193}, "CVE-2020-28441": {"epss_score": 0.00699, "epss_percentile": 0.71452}, "CVE-2020-28442": {"epss_score": 0.00633, "epss_percentile": 0.69772}, "CVE-2020-28443": {"epss_score": 0.00486, "epss_percentile": 0.64766}, "CVE-2020-28445": {"epss_score": 0.00486, "epss_percentile": 0.64766}, "CVE-2020-28446": {"epss_score": 0.13722, "epss_percentile": 0.94043}, "CVE-2020-28447": {"epss_score": 0.00486, "epss_percentile": 0.64766}, "CVE-2020-28448": {"epss_score": 0.00368, "epss_percentile": 0.5821}, "CVE-2020-28449": {"epss_score": 0.004, "epss_percentile": 0.60174}, "CVE-2020-28450": {"epss_score": 0.004, "epss_percentile": 0.60174}, "CVE-2020-28451": {"epss_score": 0.00531, "epss_percentile": 0.66668}, "CVE-2020-28452": {"epss_score": 0.00217, "epss_percentile": 0.44307}, "CVE-2020-28453": {"epss_score": 0.00486, "epss_percentile": 0.64766}, "CVE-2020-28455": {"epss_score": 0.00222, "epss_percentile": 0.44767}, "CVE-2020-28456": {"epss_score": 0.00326, "epss_percentile": 0.55038}, "CVE-2020-28457": {"epss_score": 0.00319, "epss_percentile": 0.54535}, "CVE-2020-28458": {"epss_score": 0.01228, "epss_percentile": 0.78708}, "CVE-2020-28459": {"epss_score": 0.00222, "epss_percentile": 0.44767}, "CVE-2020-28460": {"epss_score": 0.0053, "epss_percentile": 0.66625}, "CVE-2020-28461": {"epss_score": 0.00699, "epss_percentile": 0.71452}, "CVE-2020-28462": {"epss_score": 0.0037, "epss_percentile": 0.58334}, "CVE-2020-28463": {"epss_score": 0.00671, "epss_percentile": 0.70802}, "CVE-2020-28464": {"epss_score": 0.00473, "epss_percentile": 0.6408}, "CVE-2020-28466": {"epss_score": 0.08427, "epss_percentile": 0.92046}, "CVE-2020-28468": {"epss_score": 0.04817, "epss_percentile": 0.89172}, "CVE-2020-28469": {"epss_score": 0.00888, "epss_percentile": 0.74999}, "CVE-2020-28470": {"epss_score": 0.003, "epss_percentile": 0.52913}, "CVE-2020-28471": {"epss_score": 0.00659, "epss_percentile": 0.70501}, "CVE-2020-28472": {"epss_score": 0.01661, "epss_percentile": 0.81627}, "CVE-2020-28473": {"epss_score": 0.00244, "epss_percentile": 0.47576}, "CVE-2020-28477": {"epss_score": 0.00321, "epss_percentile": 0.54648}, "CVE-2020-28478": {"epss_score": 0.00627, "epss_percentile": 0.69633}, "CVE-2020-28479": {"epss_score": 0.00563, "epss_percentile": 0.67714}, "CVE-2020-28480": {"epss_score": 0.00557, "epss_percentile": 0.67551}, "CVE-2020-28481": {"epss_score": 0.00189, "epss_percentile": 0.40997}, "CVE-2020-28482": {"epss_score": 0.00307, "epss_percentile": 0.53518}, "CVE-2020-28483": {"epss_score": 0.0036, "epss_percentile": 0.57683}, "CVE-2020-28487": {"epss_score": 0.00517, "epss_percentile": 0.66075}, "CVE-2020-28490": {"epss_score": 0.069, "epss_percentile": 0.91103}, "CVE-2020-28491": {"epss_score": 0.0039, "epss_percentile": 0.59534}, "CVE-2020-28493": {"epss_score": 0.00207, "epss_percentile": 0.43094}, "CVE-2020-28494": {"epss_score": 0.01199, "epss_percentile": 0.78457}, "CVE-2020-28495": {"epss_score": 0.06091, "epss_percentile": 0.90475}, "CVE-2020-28496": {"epss_score": 0.01422, "epss_percentile": 0.80186}, "CVE-2020-28498": {"epss_score": 0.00473, "epss_percentile": 0.64082}, "CVE-2020-28499": {"epss_score": 0.00541, "epss_percentile": 0.67032}, "CVE-2020-28500": {"epss_score": 0.00245, "epss_percentile": 0.47647}, "CVE-2020-28501": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-28502": {"epss_score": 0.17396, "epss_percentile": 0.94844}, "CVE-2020-28503": {"epss_score": 0.00577, "epss_percentile": 0.68173}, "CVE-2020-28572": {"epss_score": 0.00087, "epss_percentile": 0.25503}, "CVE-2020-28573": {"epss_score": 0.0038, "epss_percentile": 0.58972}, "CVE-2020-28574": {"epss_score": 0.04038, "epss_percentile": 0.8816}, "CVE-2020-28575": {"epss_score": 0.00173, "epss_percentile": 0.39055}, "CVE-2020-28576": {"epss_score": 0.00846, "epss_percentile": 0.74338}, "CVE-2020-28577": {"epss_score": 0.0038, "epss_percentile": 0.58972}, "CVE-2020-28578": {"epss_score": 0.58536, "epss_percentile": 0.98122}, "CVE-2020-28579": {"epss_score": 0.38535, "epss_percentile": 0.97103}, "CVE-2020-28580": {"epss_score": 0.73422, "epss_percentile": 0.98753}, "CVE-2020-28581": {"epss_score": 0.73422, "epss_percentile": 0.98753}, "CVE-2020-28582": {"epss_score": 0.0038, "epss_percentile": 0.58972}, "CVE-2020-28583": {"epss_score": 0.0038, "epss_percentile": 0.58972}, "CVE-2020-28587": {"epss_score": 0.00258, "epss_percentile": 0.48975}, "CVE-2020-28588": {"epss_score": 0.00059, "epss_percentile": 0.18727}, "CVE-2020-28589": {"epss_score": 0.00836, "epss_percentile": 0.74147}, "CVE-2020-28590": {"epss_score": 0.00285, "epss_percentile": 0.51522}, "CVE-2020-28591": {"epss_score": 0.00324, "epss_percentile": 0.54944}, "CVE-2020-28592": {"epss_score": 0.04084, "epss_percentile": 0.88224}, "CVE-2020-28593": {"epss_score": 0.02015, "epss_percentile": 0.8327}, "CVE-2020-28594": {"epss_score": 0.01074, "epss_percentile": 0.773}, "CVE-2020-28595": {"epss_score": 0.00626, "epss_percentile": 0.69602}, "CVE-2020-28596": {"epss_score": 0.01049, "epss_percentile": 0.7706}, "CVE-2020-28597": {"epss_score": 0.00372, "epss_percentile": 0.58463}, "CVE-2020-28598": {"epss_score": 0.0066, "epss_percentile": 0.70533}, "CVE-2020-28599": {"epss_score": 0.01358, "epss_percentile": 0.79727}, "CVE-2020-28600": {"epss_score": 0.00696, "epss_percentile": 0.7139}, "CVE-2020-28601": {"epss_score": 0.00693, "epss_percentile": 0.71332}, "CVE-2020-28602": {"epss_score": 0.00499, "epss_percentile": 0.65281}, "CVE-2020-28603": {"epss_score": 0.00509, "epss_percentile": 0.65724}, "CVE-2020-28604": {"epss_score": 0.00499, "epss_percentile": 0.65281}, "CVE-2020-28605": {"epss_score": 0.00416, "epss_percentile": 0.61187}, "CVE-2020-28606": {"epss_score": 0.00499, "epss_percentile": 0.65281}, "CVE-2020-28607": {"epss_score": 0.0039, "epss_percentile": 0.59512}, "CVE-2020-28608": {"epss_score": 0.00499, "epss_percentile": 0.65281}, "CVE-2020-28609": {"epss_score": 0.00616, "epss_percentile": 0.69318}, "CVE-2020-28610": {"epss_score": 0.00499, "epss_percentile": 0.65281}, "CVE-2020-28611": {"epss_score": 0.00499, "epss_percentile": 0.65281}, "CVE-2020-28612": {"epss_score": 0.0039, "epss_percentile": 0.59512}, "CVE-2020-28613": {"epss_score": 0.00325, "epss_percentile": 0.54985}, "CVE-2020-28614": {"epss_score": 0.00325, "epss_percentile": 0.54985}, "CVE-2020-28615": {"epss_score": 0.00418, "epss_percentile": 0.61264}, "CVE-2020-28616": {"epss_score": 0.00418, "epss_percentile": 0.61264}, "CVE-2020-28617": {"epss_score": 0.00355, "epss_percentile": 0.5726}, "CVE-2020-28618": {"epss_score": 0.00418, "epss_percentile": 0.61264}, "CVE-2020-28619": {"epss_score": 0.00418, "epss_percentile": 0.61264}, "CVE-2020-28620": {"epss_score": 0.00418, "epss_percentile": 0.61264}, "CVE-2020-28621": {"epss_score": 0.00418, "epss_percentile": 0.61264}, "CVE-2020-28622": {"epss_score": 0.00348, "epss_percentile": 0.56823}, "CVE-2020-28623": {"epss_score": 0.00378, "epss_percentile": 0.58808}, "CVE-2020-28624": {"epss_score": 0.00325, "epss_percentile": 0.54985}, "CVE-2020-28625": {"epss_score": 0.0039, "epss_percentile": 0.59512}, "CVE-2020-28626": {"epss_score": 0.00418, "epss_percentile": 0.61264}, "CVE-2020-28627": {"epss_score": 0.00397, "epss_percentile": 0.60032}, "CVE-2020-28628": {"epss_score": 0.00325, "epss_percentile": 0.54985}, "CVE-2020-28629": {"epss_score": 0.0039, "epss_percentile": 0.59512}, "CVE-2020-28630": {"epss_score": 0.00499, "epss_percentile": 0.65281}, "CVE-2020-28631": {"epss_score": 0.0039, "epss_percentile": 0.59512}, "CVE-2020-28632": {"epss_score": 0.0039, "epss_percentile": 0.59512}, "CVE-2020-28633": {"epss_score": 0.00499, "epss_percentile": 0.65281}, "CVE-2020-28634": {"epss_score": 0.00652, "epss_percentile": 0.70308}, "CVE-2020-28635": {"epss_score": 0.00519, "epss_percentile": 0.66165}, "CVE-2020-28636": {"epss_score": 0.00905, "epss_percentile": 0.75234}, "CVE-2020-28638": {"epss_score": 0.00197, "epss_percentile": 0.41969}, "CVE-2020-28641": {"epss_score": 0.00058, "epss_percentile": 0.18511}, "CVE-2020-28642": {"epss_score": 0.00703, "epss_percentile": 0.71533}, "CVE-2020-28644": {"epss_score": 0.00146, "epss_percentile": 0.35578}, "CVE-2020-28645": {"epss_score": 0.00255, "epss_percentile": 0.48629}, "CVE-2020-28646": {"epss_score": 0.00126, "epss_percentile": 0.32708}, "CVE-2020-28647": {"epss_score": 0.001, "epss_percentile": 0.28472}, "CVE-2020-28648": {"epss_score": 0.34044, "epss_percentile": 0.96823}, "CVE-2020-28649": {"epss_score": 0.003, "epss_percentile": 0.52964}, "CVE-2020-28650": {"epss_score": 0.00154, "epss_percentile": 0.36673}, "CVE-2020-28653": {"epss_score": 0.88711, "epss_percentile": 0.99485}, "CVE-2020-28656": {"epss_score": 0.00024, "epss_percentile": 0.06007}, "CVE-2020-28657": {"epss_score": 0.00685, "epss_percentile": 0.71152}, "CVE-2020-28672": {"epss_score": 0.06731, "epss_percentile": 0.90987}, "CVE-2020-28679": {"epss_score": 0.04719, "epss_percentile": 0.89047}, "CVE-2020-28687": {"epss_score": 0.10378, "epss_percentile": 0.92966}, "CVE-2020-28688": {"epss_score": 0.10378, "epss_percentile": 0.92966}, "CVE-2020-28692": {"epss_score": 0.00451, "epss_percentile": 0.63132}, "CVE-2020-28693": {"epss_score": 0.02255, "epss_percentile": 0.84166}, "CVE-2020-28695": {"epss_score": 0.00913, "epss_percentile": 0.75371}, "CVE-2020-28702": {"epss_score": 0.00246, "epss_percentile": 0.47765}, "CVE-2020-28705": {"epss_score": 0.00141, "epss_percentile": 0.34841}, "CVE-2020-28707": {"epss_score": 0.00602, "epss_percentile": 0.68875}, "CVE-2020-28713": {"epss_score": 0.00653, "epss_percentile": 0.70325}, "CVE-2020-28715": {"epss_score": 0.00108, "epss_percentile": 0.29766}, "CVE-2020-28717": {"epss_score": 0.0017, "epss_percentile": 0.38709}, "CVE-2020-28722": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2020-28723": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-28724": {"epss_score": 0.00923, "epss_percentile": 0.75495}, "CVE-2020-28726": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2020-28727": {"epss_score": 0.0045, "epss_percentile": 0.631}, "CVE-2020-28734": {"epss_score": 0.00484, "epss_percentile": 0.64664}, "CVE-2020-28735": {"epss_score": 0.00484, "epss_percentile": 0.64664}, "CVE-2020-28736": {"epss_score": 0.00484, "epss_percentile": 0.64664}, "CVE-2020-28759": {"epss_score": 0.00323, "epss_percentile": 0.54914}, "CVE-2020-28838": {"epss_score": 0.00096, "epss_percentile": 0.27358}, "CVE-2020-28840": {"epss_score": 0.00028, "epss_percentile": 0.07242}, "CVE-2020-28841": {"epss_score": 0.00149, "epss_percentile": 0.35982}, "CVE-2020-28845": {"epss_score": 0.01073, "epss_percentile": 0.77285}, "CVE-2020-28846": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2020-28847": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-28848": {"epss_score": 0.02456, "epss_percentile": 0.84799}, "CVE-2020-28849": {"epss_score": 0.00068, "epss_percentile": 0.21314}, "CVE-2020-28851": {"epss_score": 0.00138, "epss_percentile": 0.34382}, "CVE-2020-28852": {"epss_score": 0.00107, "epss_percentile": 0.29745}, "CVE-2020-28856": {"epss_score": 0.00843, "epss_percentile": 0.74263}, "CVE-2020-28857": {"epss_score": 0.00482, "epss_percentile": 0.64552}, "CVE-2020-28858": {"epss_score": 0.00366, "epss_percentile": 0.58093}, "CVE-2020-28859": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-28860": {"epss_score": 0.02416, "epss_percentile": 0.84688}, "CVE-2020-28861": {"epss_score": 0.00945, "epss_percentile": 0.75796}, "CVE-2020-28864": {"epss_score": 0.00697, "epss_percentile": 0.714}, "CVE-2020-28865": {"epss_score": 0.00166, "epss_percentile": 0.38178}, "CVE-2020-28870": {"epss_score": 0.01467, "epss_percentile": 0.80469}, "CVE-2020-28871": {"epss_score": 0.94046, "epss_percentile": 0.99892}, "CVE-2020-28872": {"epss_score": 0.00553, "epss_percentile": 0.67431}, "CVE-2020-28873": {"epss_score": 0.00138, "epss_percentile": 0.34521}, "CVE-2020-28874": {"epss_score": 0.0136, "epss_percentile": 0.79748}, "CVE-2020-28877": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2020-28884": {"epss_score": 0.04838, "epss_percentile": 0.89195}, "CVE-2020-28885": {"epss_score": 0.00902, "epss_percentile": 0.7519}, "CVE-2020-28895": {"epss_score": 0.00424, "epss_percentile": 0.61667}, "CVE-2020-28896": {"epss_score": 0.00332, "epss_percentile": 0.55595}, "CVE-2020-28898": {"epss_score": 0.00823, "epss_percentile": 0.73922}, "CVE-2020-28899": {"epss_score": 0.00501, "epss_percentile": 0.65332}, "CVE-2020-28900": {"epss_score": 0.00794, "epss_percentile": 0.7345}, "CVE-2020-28901": {"epss_score": 0.05534, "epss_percentile": 0.89969}, "CVE-2020-28902": {"epss_score": 0.10355, "epss_percentile": 0.92957}, "CVE-2020-28903": {"epss_score": 0.20705, "epss_percentile": 0.95403}, "CVE-2020-28904": {"epss_score": 0.00904, "epss_percentile": 0.75221}, "CVE-2020-28905": {"epss_score": 0.59165, "epss_percentile": 0.98152}, "CVE-2020-28906": {"epss_score": 0.00908, "epss_percentile": 0.75281}, "CVE-2020-28907": {"epss_score": 0.0065, "epss_percentile": 0.7025}, "CVE-2020-28908": {"epss_score": 0.33287, "epss_percentile": 0.9676}, "CVE-2020-28909": {"epss_score": 0.00997, "epss_percentile": 0.7646}, "CVE-2020-28910": {"epss_score": 0.00518, "epss_percentile": 0.66133}, "CVE-2020-28911": {"epss_score": 0.2144, "epss_percentile": 0.95519}, "CVE-2020-28912": {"epss_score": 0.00114, "epss_percentile": 0.3085}, "CVE-2020-28914": {"epss_score": 0.00053, "epss_percentile": 0.16696}, "CVE-2020-28915": {"epss_score": 0.00122, "epss_percentile": 0.32145}, "CVE-2020-28916": {"epss_score": 0.00047, "epss_percentile": 0.14597}, "CVE-2020-28917": {"epss_score": 0.00153, "epss_percentile": 0.36544}, "CVE-2020-28918": {"epss_score": 0.00298, "epss_percentile": 0.5278}, "CVE-2020-28919": {"epss_score": 0.00229, "epss_percentile": 0.45645}, "CVE-2020-28921": {"epss_score": 0.00068, "epss_percentile": 0.21202}, "CVE-2020-28922": {"epss_score": 0.00068, "epss_percentile": 0.21202}, "CVE-2020-28923": {"epss_score": 0.00182, "epss_percentile": 0.40224}, "CVE-2020-28924": {"epss_score": 0.00352, "epss_percentile": 0.5712}, "CVE-2020-28925": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2020-28926": {"epss_score": 0.65261, "epss_percentile": 0.9841}, "CVE-2020-28927": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-28928": {"epss_score": 0.00045, "epss_percentile": 0.1391}, "CVE-2020-28929": {"epss_score": 0.01983, "epss_percentile": 0.83142}, "CVE-2020-28930": {"epss_score": 0.0042, "epss_percentile": 0.61413}, "CVE-2020-28931": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2020-28935": {"epss_score": 0.00081, "epss_percentile": 0.24387}, "CVE-2020-28937": {"epss_score": 0.00634, "epss_percentile": 0.69796}, "CVE-2020-28938": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-28939": {"epss_score": 0.02284, "epss_percentile": 0.84264}, "CVE-2020-28940": {"epss_score": 0.03621, "epss_percentile": 0.87443}, "CVE-2020-28941": {"epss_score": 0.00062, "epss_percentile": 0.19711}, "CVE-2020-28942": {"epss_score": 0.00096, "epss_percentile": 0.27395}, "CVE-2020-28943": {"epss_score": 0.00212, "epss_percentile": 0.43761}, "CVE-2020-28944": {"epss_score": 0.00451, "epss_percentile": 0.63118}, "CVE-2020-28945": {"epss_score": 0.00403, "epss_percentile": 0.60364}, "CVE-2020-28946": {"epss_score": 0.0031, "epss_percentile": 0.53802}, "CVE-2020-28947": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-28948": {"epss_score": 0.73725, "epss_percentile": 0.9877}, "CVE-2020-28949": {"epss_score": 0.92961, "epss_percentile": 0.99764}, "CVE-2020-28950": {"epss_score": 0.00047, "epss_percentile": 0.14876}, "CVE-2020-28951": {"epss_score": 0.00518, "epss_percentile": 0.66117}, "CVE-2020-28952": {"epss_score": 0.00389, "epss_percentile": 0.59486}, "CVE-2020-28953": {"epss_score": 0.00203, "epss_percentile": 0.42564}, "CVE-2020-28954": {"epss_score": 0.00383, "epss_percentile": 0.59086}, "CVE-2020-28955": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-28956": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-28957": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-28960": {"epss_score": 0.00272, "epss_percentile": 0.5035}, "CVE-2020-28961": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-28963": {"epss_score": 0.0005, "epss_percentile": 0.1586}, "CVE-2020-28964": {"epss_score": 0.00053, "epss_percentile": 0.17028}, "CVE-2020-28967": {"epss_score": 0.00581, "epss_percentile": 0.68269}, "CVE-2020-28968": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-28969": {"epss_score": 0.00268, "epss_percentile": 0.50094}, "CVE-2020-28970": {"epss_score": 0.03621, "epss_percentile": 0.87443}, "CVE-2020-28971": {"epss_score": 0.03145, "epss_percentile": 0.86493}, "CVE-2020-28972": {"epss_score": 0.00802, "epss_percentile": 0.73587}, "CVE-2020-28973": {"epss_score": 0.00347, "epss_percentile": 0.56792}, "CVE-2020-28974": {"epss_score": 0.00059, "epss_percentile": 0.1883}, "CVE-2020-28975": {"epss_score": 0.00278, "epss_percentile": 0.5086}, "CVE-2020-28976": {"epss_score": 0.2575, "epss_percentile": 0.96062}, "CVE-2020-28977": {"epss_score": 0.10409, "epss_percentile": 0.92977}, "CVE-2020-28978": {"epss_score": 0.10409, "epss_percentile": 0.92977}, "CVE-2020-28984": {"epss_score": 0.00713, "epss_percentile": 0.71802}, "CVE-2020-28991": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2020-28993": {"epss_score": 0.13233, "epss_percentile": 0.93907}, "CVE-2020-28994": {"epss_score": 0.00954, "epss_percentile": 0.75896}, "CVE-2020-28998": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-28999": {"epss_score": 0.0065, "epss_percentile": 0.70271}, "CVE-2020-29000": {"epss_score": 0.0268, "epss_percentile": 0.85413}, "CVE-2020-29001": {"epss_score": 0.00511, "epss_percentile": 0.65847}, "CVE-2020-29002": {"epss_score": 0.00218, "epss_percentile": 0.44359}, "CVE-2020-29003": {"epss_score": 0.00289, "epss_percentile": 0.52046}, "CVE-2020-29004": {"epss_score": 0.00156, "epss_percentile": 0.36955}, "CVE-2020-29005": {"epss_score": 0.0009, "epss_percentile": 0.26092}, "CVE-2020-29006": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2020-29007": {"epss_score": 0.07456, "epss_percentile": 0.91482}, "CVE-2020-29010": {"epss_score": 0.00165, "epss_percentile": 0.38049}, "CVE-2020-29011": {"epss_score": 0.00361, "epss_percentile": 0.57725}, "CVE-2020-29012": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2020-29013": {"epss_score": 0.00402, "epss_percentile": 0.60317}, "CVE-2020-29014": {"epss_score": 0.00497, "epss_percentile": 0.652}, "CVE-2020-29015": {"epss_score": 0.01005, "epss_percentile": 0.76542}, "CVE-2020-29016": {"epss_score": 0.02177, "epss_percentile": 0.83889}, "CVE-2020-29017": {"epss_score": 0.06365, "epss_percentile": 0.90703}, "CVE-2020-29018": {"epss_score": 0.00772, "epss_percentile": 0.73047}, "CVE-2020-29019": {"epss_score": 0.00986, "epss_percentile": 0.76334}, "CVE-2020-29020": {"epss_score": 0.00665, "epss_percentile": 0.70664}, "CVE-2020-29021": {"epss_score": 0.00356, "epss_percentile": 0.57351}, "CVE-2020-29022": {"epss_score": 0.00214, "epss_percentile": 0.43957}, "CVE-2020-29023": {"epss_score": 0.00214, "epss_percentile": 0.44011}, "CVE-2020-29024": {"epss_score": 0.00111, "epss_percentile": 0.30267}, "CVE-2020-29025": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2020-29026": {"epss_score": 0.00341, "epss_percentile": 0.56308}, "CVE-2020-29027": {"epss_score": 0.00272, "epss_percentile": 0.50417}, "CVE-2020-29028": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2020-29029": {"epss_score": 0.0027, "epss_percentile": 0.50239}, "CVE-2020-29030": {"epss_score": 0.00142, "epss_percentile": 0.34977}, "CVE-2020-29031": {"epss_score": 0.00216, "epss_percentile": 0.44147}, "CVE-2020-29032": {"epss_score": 0.00209, "epss_percentile": 0.43347}, "CVE-2020-29040": {"epss_score": 0.00065, "epss_percentile": 0.20505}, "CVE-2020-29041": {"epss_score": 0.00704, "epss_percentile": 0.71561}, "CVE-2020-29042": {"epss_score": 0.00273, "epss_percentile": 0.50459}, "CVE-2020-29043": {"epss_score": 0.00289, "epss_percentile": 0.51984}, "CVE-2020-29045": {"epss_score": 0.35195, "epss_percentile": 0.96893}, "CVE-2020-29047": {"epss_score": 0.8462, "epss_percentile": 0.99298}, "CVE-2020-29050": {"epss_score": 0.00709, "epss_percentile": 0.71689}, "CVE-2020-29053": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-29054": {"epss_score": 0.00405, "epss_percentile": 0.60482}, "CVE-2020-29055": {"epss_score": 0.00125, "epss_percentile": 0.32622}, "CVE-2020-29056": {"epss_score": 0.00453, "epss_percentile": 0.63226}, "CVE-2020-29057": {"epss_score": 0.00619, "epss_percentile": 0.69396}, "CVE-2020-29058": {"epss_score": 0.00405, "epss_percentile": 0.60482}, "CVE-2020-29059": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2020-29060": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2020-29061": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2020-29062": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2020-29063": {"epss_score": 0.00079, "epss_percentile": 0.23981}, "CVE-2020-29069": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2020-29070": {"epss_score": 0.0049, "epss_percentile": 0.64919}, "CVE-2020-29071": {"epss_score": 0.00645, "epss_percentile": 0.70106}, "CVE-2020-29072": {"epss_score": 0.00243, "epss_percentile": 0.47472}, "CVE-2020-29074": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2020-29075": {"epss_score": 0.00919, "epss_percentile": 0.75456}, "CVE-2020-29127": {"epss_score": 0.00536, "epss_percentile": 0.66856}, "CVE-2020-29128": {"epss_score": 0.01877, "epss_percentile": 0.82664}, "CVE-2020-29129": {"epss_score": 0.00343, "epss_percentile": 0.56464}, "CVE-2020-29130": {"epss_score": 0.00582, "epss_percentile": 0.6829}, "CVE-2020-29133": {"epss_score": 0.00768, "epss_percentile": 0.72966}, "CVE-2020-29134": {"epss_score": 0.2033, "epss_percentile": 0.95327}, "CVE-2020-29135": {"epss_score": 0.00224, "epss_percentile": 0.45057}, "CVE-2020-29136": {"epss_score": 0.00241, "epss_percentile": 0.47242}, "CVE-2020-29137": {"epss_score": 0.00404, "epss_percentile": 0.60396}, "CVE-2020-29138": {"epss_score": 0.00635, "epss_percentile": 0.69816}, "CVE-2020-29139": {"epss_score": 0.00057, "epss_percentile": 0.18137}, "CVE-2020-29140": {"epss_score": 0.00057, "epss_percentile": 0.18176}, "CVE-2020-29142": {"epss_score": 0.00057, "epss_percentile": 0.18176}, "CVE-2020-29143": {"epss_score": 0.00057, "epss_percentile": 0.18137}, "CVE-2020-29144": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-29145": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-29146": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-29147": {"epss_score": 0.00238, "epss_percentile": 0.46824}, "CVE-2020-29156": {"epss_score": 0.13078, "epss_percentile": 0.93866}, "CVE-2020-29157": {"epss_score": 0.00049, "epss_percentile": 0.15329}, "CVE-2020-29158": {"epss_score": 0.00112, "epss_percentile": 0.30556}, "CVE-2020-29159": {"epss_score": 0.00335, "epss_percentile": 0.55895}, "CVE-2020-29160": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2020-29163": {"epss_score": 0.00507, "epss_percentile": 0.65661}, "CVE-2020-29164": {"epss_score": 0.10218, "epss_percentile": 0.92899}, "CVE-2020-29165": {"epss_score": 0.0108, "epss_percentile": 0.77365}, "CVE-2020-29166": {"epss_score": 0.01011, "epss_percentile": 0.7661}, "CVE-2020-29168": {"epss_score": 0.00078, "epss_percentile": 0.2367}, "CVE-2020-29171": {"epss_score": 0.00397, "epss_percentile": 0.60042}, "CVE-2020-29172": {"epss_score": 0.00334, "epss_percentile": 0.557}, "CVE-2020-29176": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2020-29177": {"epss_score": 0.00346, "epss_percentile": 0.56608}, "CVE-2020-29189": {"epss_score": 0.00159, "epss_percentile": 0.37321}, "CVE-2020-29193": {"epss_score": 0.00126, "epss_percentile": 0.32759}, "CVE-2020-29194": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2020-29203": {"epss_score": 0.00512, "epss_percentile": 0.65871}, "CVE-2020-29204": {"epss_score": 0.0028, "epss_percentile": 0.511}, "CVE-2020-29205": {"epss_score": 0.00648, "epss_percentile": 0.70212}, "CVE-2020-29214": {"epss_score": 0.47269, "epss_percentile": 0.97579}, "CVE-2020-29215": {"epss_score": 0.00163, "epss_percentile": 0.37805}, "CVE-2020-29227": {"epss_score": 0.93408, "epss_percentile": 0.99804}, "CVE-2020-29228": {"epss_score": 0.0047, "epss_percentile": 0.63988}, "CVE-2020-29230": {"epss_score": 0.0042, "epss_percentile": 0.61415}, "CVE-2020-29231": {"epss_score": 0.00527, "epss_percentile": 0.66452}, "CVE-2020-29233": {"epss_score": 0.00136, "epss_percentile": 0.34117}, "CVE-2020-29238": {"epss_score": 0.46595, "epss_percentile": 0.97553}, "CVE-2020-29239": {"epss_score": 0.00113, "epss_percentile": 0.30715}, "CVE-2020-29240": {"epss_score": 0.00206, "epss_percentile": 0.42938}, "CVE-2020-29241": {"epss_score": 0.00169, "epss_percentile": 0.38621}, "CVE-2020-29242": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2020-29243": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2020-29244": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2020-29245": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2020-29247": {"epss_score": 0.0044, "epss_percentile": 0.62631}, "CVE-2020-29249": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-29250": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-29254": {"epss_score": 0.03296, "epss_percentile": 0.86858}, "CVE-2020-29257": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-29258": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-29259": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-29260": {"epss_score": 0.0021, "epss_percentile": 0.43492}, "CVE-2020-29279": {"epss_score": 0.49028, "epss_percentile": 0.97663}, "CVE-2020-29280": {"epss_score": 0.01466, "epss_percentile": 0.80462}, "CVE-2020-29282": {"epss_score": 0.01004, "epss_percentile": 0.76532}, "CVE-2020-29283": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-29284": {"epss_score": 0.21285, "epss_percentile": 0.95494}, "CVE-2020-29285": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-29287": {"epss_score": 0.02406, "epss_percentile": 0.84652}, "CVE-2020-29288": {"epss_score": 0.01466, "epss_percentile": 0.80462}, "CVE-2020-29292": {"epss_score": 0.0012, "epss_percentile": 0.317}, "CVE-2020-29297": {"epss_score": 0.00086, "epss_percentile": 0.25322}, "CVE-2020-29299": {"epss_score": 0.0361, "epss_percentile": 0.87423}, "CVE-2020-29303": {"epss_score": 0.01119, "epss_percentile": 0.77754}, "CVE-2020-29304": {"epss_score": 0.01235, "epss_percentile": 0.78764}, "CVE-2020-29311": {"epss_score": 0.0853, "epss_percentile": 0.92105}, "CVE-2020-29312": {"epss_score": 0.02476, "epss_percentile": 0.84861}, "CVE-2020-29315": {"epss_score": 0.00201, "epss_percentile": 0.42389}, "CVE-2020-29321": {"epss_score": 0.00832, "epss_percentile": 0.74059}, "CVE-2020-29322": {"epss_score": 0.00592, "epss_percentile": 0.68624}, "CVE-2020-29323": {"epss_score": 0.00832, "epss_percentile": 0.74059}, "CVE-2020-29324": {"epss_score": 0.00507, "epss_percentile": 0.65663}, "CVE-2020-29361": {"epss_score": 0.00262, "epss_percentile": 0.4934}, "CVE-2020-29362": {"epss_score": 0.00084, "epss_percentile": 0.24983}, "CVE-2020-29363": {"epss_score": 0.00575, "epss_percentile": 0.68103}, "CVE-2020-29364": {"epss_score": 0.0032, "epss_percentile": 0.54636}, "CVE-2020-29367": {"epss_score": 0.00129, "epss_percentile": 0.33163}, "CVE-2020-29368": {"epss_score": 0.00102, "epss_percentile": 0.28857}, "CVE-2020-29369": {"epss_score": 0.00079, "epss_percentile": 0.2392}, "CVE-2020-29370": {"epss_score": 0.00359, "epss_percentile": 0.57593}, "CVE-2020-29371": {"epss_score": 0.00086, "epss_percentile": 0.25371}, "CVE-2020-29372": {"epss_score": 0.00052, "epss_percentile": 0.16514}, "CVE-2020-29373": {"epss_score": 0.00047, "epss_percentile": 0.14649}, "CVE-2020-29374": {"epss_score": 0.00019, "epss_percentile": 0.04257}, "CVE-2020-29375": {"epss_score": 0.00238, "epss_percentile": 0.46751}, "CVE-2020-29376": {"epss_score": 0.00405, "epss_percentile": 0.60482}, "CVE-2020-29377": {"epss_score": 0.00472, "epss_percentile": 0.64064}, "CVE-2020-29378": {"epss_score": 0.00281, "epss_percentile": 0.51106}, "CVE-2020-29379": {"epss_score": 0.00048, "epss_percentile": 0.15286}, "CVE-2020-29380": {"epss_score": 0.00111, "epss_percentile": 0.30342}, "CVE-2020-29381": {"epss_score": 0.02696, "epss_percentile": 0.85443}, "CVE-2020-29382": {"epss_score": 0.00061, "epss_percentile": 0.19447}, "CVE-2020-29383": {"epss_score": 0.00048, "epss_percentile": 0.15039}, "CVE-2020-29384": {"epss_score": 0.00201, "epss_percentile": 0.42384}, "CVE-2020-29385": {"epss_score": 0.00662, "epss_percentile": 0.7061}, "CVE-2020-29389": {"epss_score": 0.00393, "epss_percentile": 0.59724}, "CVE-2020-29390": {"epss_score": 0.90592, "epss_percentile": 0.9959}, "CVE-2020-29392": {"epss_score": 0.0006, "epss_percentile": 0.19229}, "CVE-2020-29394": {"epss_score": 0.01549, "epss_percentile": 0.80981}, "CVE-2020-29395": {"epss_score": 0.03284, "epss_percentile": 0.86821}, "CVE-2020-29396": {"epss_score": 0.01814, "epss_percentile": 0.82378}, "CVE-2020-29436": {"epss_score": 0.00512, "epss_percentile": 0.6587}, "CVE-2020-29437": {"epss_score": 0.01236, "epss_percentile": 0.7877}, "CVE-2020-29438": {"epss_score": 0.00086, "epss_percentile": 0.25328}, "CVE-2020-29439": {"epss_score": 0.00129, "epss_percentile": 0.33082}, "CVE-2020-29440": {"epss_score": 0.00066, "epss_percentile": 0.20956}, "CVE-2020-29441": {"epss_score": 0.01294, "epss_percentile": 0.79244}, "CVE-2020-29443": {"epss_score": 0.00076, "epss_percentile": 0.23104}, "CVE-2020-29444": {"epss_score": 0.00273, "epss_percentile": 0.50478}, "CVE-2020-29445": {"epss_score": 0.00217, "epss_percentile": 0.44333}, "CVE-2020-29446": {"epss_score": 0.0039, "epss_percentile": 0.59527}, "CVE-2020-29447": {"epss_score": 0.00439, "epss_percentile": 0.62584}, "CVE-2020-29448": {"epss_score": 0.00626, "epss_percentile": 0.69615}, "CVE-2020-29450": {"epss_score": 0.00755, "epss_percentile": 0.72715}, "CVE-2020-29451": {"epss_score": 0.0016, "epss_percentile": 0.37464}, "CVE-2020-29453": {"epss_score": 0.80006, "epss_percentile": 0.99067}, "CVE-2020-29454": {"epss_score": 0.00187, "epss_percentile": 0.40777}, "CVE-2020-29455": {"epss_score": 0.00472, "epss_percentile": 0.64042}, "CVE-2020-29456": {"epss_score": 0.00467, "epss_percentile": 0.63812}, "CVE-2020-29457": {"epss_score": 0.00132, "epss_percentile": 0.33577}, "CVE-2020-29458": {"epss_score": 0.00177, "epss_percentile": 0.39535}, "CVE-2020-29469": {"epss_score": 0.00311, "epss_percentile": 0.53826}, "CVE-2020-29470": {"epss_score": 0.00155, "epss_percentile": 0.36843}, "CVE-2020-29471": {"epss_score": 0.00155, "epss_percentile": 0.36843}, "CVE-2020-29472": {"epss_score": 0.01983, "epss_percentile": 0.83142}, "CVE-2020-29474": {"epss_score": 0.01983, "epss_percentile": 0.83142}, "CVE-2020-29475": {"epss_score": 0.0016, "epss_percentile": 0.37483}, "CVE-2020-29477": {"epss_score": 0.00429, "epss_percentile": 0.61974}, "CVE-2020-29478": {"epss_score": 0.00614, "epss_percentile": 0.69268}, "CVE-2020-29479": {"epss_score": 0.00046, "epss_percentile": 0.14433}, "CVE-2020-29480": {"epss_score": 0.00062, "epss_percentile": 0.19554}, "CVE-2020-29481": {"epss_score": 0.00066, "epss_percentile": 0.20859}, "CVE-2020-29482": {"epss_score": 0.00064, "epss_percentile": 0.20328}, "CVE-2020-29483": {"epss_score": 0.00056, "epss_percentile": 0.17769}, "CVE-2020-29484": {"epss_score": 0.00064, "epss_percentile": 0.2013}, "CVE-2020-29485": {"epss_score": 0.00063, "epss_percentile": 0.19847}, "CVE-2020-29486": {"epss_score": 0.00061, "epss_percentile": 0.19263}, "CVE-2020-29487": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2020-29489": {"epss_score": 0.0002, "epss_percentile": 0.04492}, "CVE-2020-29490": {"epss_score": 0.00543, "epss_percentile": 0.67102}, "CVE-2020-29491": {"epss_score": 0.00905, "epss_percentile": 0.75242}, "CVE-2020-29492": {"epss_score": 0.00857, "epss_percentile": 0.74492}, "CVE-2020-29493": {"epss_score": 0.05795, "epss_percentile": 0.90215}, "CVE-2020-29494": {"epss_score": 0.00963, "epss_percentile": 0.76017}, "CVE-2020-29495": {"epss_score": 0.1549, "epss_percentile": 0.94437}, "CVE-2020-29496": {"epss_score": 0.0017, "epss_percentile": 0.38656}, "CVE-2020-29497": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2020-29498": {"epss_score": 0.00203, "epss_percentile": 0.42548}, "CVE-2020-29499": {"epss_score": 0.00161, "epss_percentile": 0.37614}, "CVE-2020-29500": {"epss_score": 0.0004, "epss_percentile": 0.1202}, "CVE-2020-29501": {"epss_score": 0.0004, "epss_percentile": 0.1202}, "CVE-2020-29502": {"epss_score": 0.0004, "epss_percentile": 0.1202}, "CVE-2020-29503": {"epss_score": 0.0005, "epss_percentile": 0.1583}, "CVE-2020-29504": {"epss_score": 0.00175, "epss_percentile": 0.39266}, "CVE-2020-29505": {"epss_score": 0.00484, "epss_percentile": 0.64634}, "CVE-2020-29506": {"epss_score": 0.01329, "epss_percentile": 0.79509}, "CVE-2020-29507": {"epss_score": 0.0085, "epss_percentile": 0.74383}, "CVE-2020-29508": {"epss_score": 0.00734, "epss_percentile": 0.72219}, "CVE-2020-29509": {"epss_score": 0.00187, "epss_percentile": 0.4074}, "CVE-2020-29510": {"epss_score": 0.00122, "epss_percentile": 0.32172}, "CVE-2020-29511": {"epss_score": 0.00187, "epss_percentile": 0.4074}, "CVE-2020-29529": {"epss_score": 0.0045, "epss_percentile": 0.63079}, "CVE-2020-29534": {"epss_score": 0.0004, "epss_percentile": 0.12075}, "CVE-2020-29535": {"epss_score": 0.00222, "epss_percentile": 0.44782}, "CVE-2020-29536": {"epss_score": 0.00098, "epss_percentile": 0.27693}, "CVE-2020-29537": {"epss_score": 0.00112, "epss_percentile": 0.30522}, "CVE-2020-29538": {"epss_score": 0.00228, "epss_percentile": 0.45537}, "CVE-2020-29539": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2020-29540": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-29547": {"epss_score": 0.00318, "epss_percentile": 0.54409}, "CVE-2020-29548": {"epss_score": 0.0062, "epss_percentile": 0.69442}, "CVE-2020-29550": {"epss_score": 0.00524, "epss_percentile": 0.66325}, "CVE-2020-29551": {"epss_score": 0.03412, "epss_percentile": 0.87087}, "CVE-2020-29552": {"epss_score": 0.08777, "epss_percentile": 0.9225}, "CVE-2020-29553": {"epss_score": 0.00152, "epss_percentile": 0.36497}, "CVE-2020-29555": {"epss_score": 0.04155, "epss_percentile": 0.88327}, "CVE-2020-29556": {"epss_score": 0.00105, "epss_percentile": 0.29299}, "CVE-2020-29557": {"epss_score": 0.89773, "epss_percentile": 0.99541}, "CVE-2020-29561": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2020-29562": {"epss_score": 0.00052, "epss_percentile": 0.16404}, "CVE-2020-29563": {"epss_score": 0.05623, "epss_percentile": 0.90063}, "CVE-2020-29564": {"epss_score": 0.49552, "epss_percentile": 0.97694}, "CVE-2020-29565": {"epss_score": 0.0071, "epss_percentile": 0.71702}, "CVE-2020-29566": {"epss_score": 0.00071, "epss_percentile": 0.2201}, "CVE-2020-29567": {"epss_score": 0.00055, "epss_percentile": 0.17453}, "CVE-2020-29568": {"epss_score": 0.00064, "epss_percentile": 0.2027}, "CVE-2020-29569": {"epss_score": 0.0007, "epss_percentile": 0.2165}, "CVE-2020-29570": {"epss_score": 0.0006, "epss_percentile": 0.19014}, "CVE-2020-29571": {"epss_score": 0.00058, "epss_percentile": 0.18575}, "CVE-2020-29572": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-29573": {"epss_score": 0.00136, "epss_percentile": 0.34174}, "CVE-2020-29574": {"epss_score": 0.08409, "epss_percentile": 0.92035}, "CVE-2020-29575": {"epss_score": 0.02074, "epss_percentile": 0.83498}, "CVE-2020-29576": {"epss_score": 0.02074, "epss_percentile": 0.83498}, "CVE-2020-29577": {"epss_score": 0.02074, "epss_percentile": 0.83498}, "CVE-2020-29578": {"epss_score": 0.02074, "epss_percentile": 0.83498}, "CVE-2020-29579": {"epss_score": 0.02074, "epss_percentile": 0.83498}, "CVE-2020-29580": {"epss_score": 0.02074, "epss_percentile": 0.83498}, "CVE-2020-29581": {"epss_score": 0.02074, "epss_percentile": 0.83498}, "CVE-2020-29582": {"epss_score": 3e-05, "epss_percentile": 0.00122}, "CVE-2020-29583": {"epss_score": 0.94367, "epss_percentile": 0.99961}, "CVE-2020-29587": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-29591": {"epss_score": 0.02656, "epss_percentile": 0.85358}, "CVE-2020-29592": {"epss_score": 0.01344, "epss_percentile": 0.79612}, "CVE-2020-29593": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-29594": {"epss_score": 0.00488, "epss_percentile": 0.6485}, "CVE-2020-29595": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-29596": {"epss_score": 0.06997, "epss_percentile": 0.91171}, "CVE-2020-29597": {"epss_score": 0.85276, "epss_percentile": 0.99327}, "CVE-2020-29599": {"epss_score": 0.6875, "epss_percentile": 0.98562}, "CVE-2020-29600": {"epss_score": 0.02265, "epss_percentile": 0.84197}, "CVE-2020-29601": {"epss_score": 0.02074, "epss_percentile": 0.83498}, "CVE-2020-29602": {"epss_score": 0.02074, "epss_percentile": 0.83498}, "CVE-2020-29603": {"epss_score": 0.00197, "epss_percentile": 0.41875}, "CVE-2020-29604": {"epss_score": 0.00212, "epss_percentile": 0.43797}, "CVE-2020-29605": {"epss_score": 0.00147, "epss_percentile": 0.35684}, "CVE-2020-29607": {"epss_score": 0.61038, "epss_percentile": 0.98232}, "CVE-2020-29608": {"epss_score": 0.00698, "epss_percentile": 0.71423}, "CVE-2020-29610": {"epss_score": 0.00359, "epss_percentile": 0.57597}, "CVE-2020-29611": {"epss_score": 0.00461, "epss_percentile": 0.63568}, "CVE-2020-29612": {"epss_score": 0.00264, "epss_percentile": 0.49683}, "CVE-2020-29613": {"epss_score": 0.00194, "epss_percentile": 0.41528}, "CVE-2020-29614": {"epss_score": 0.00352, "epss_percentile": 0.57132}, "CVE-2020-29615": {"epss_score": 0.00341, "epss_percentile": 0.56307}, "CVE-2020-29616": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2020-29617": {"epss_score": 0.00352, "epss_percentile": 0.57132}, "CVE-2020-29618": {"epss_score": 0.00849, "epss_percentile": 0.74373}, "CVE-2020-29619": {"epss_score": 0.00352, "epss_percentile": 0.57132}, "CVE-2020-29620": {"epss_score": 0.00176, "epss_percentile": 0.39381}, "CVE-2020-29621": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2020-29622": {"epss_score": 0.00366, "epss_percentile": 0.58074}, "CVE-2020-29623": {"epss_score": 0.00033, "epss_percentile": 0.09135}, "CVE-2020-29624": {"epss_score": 0.00395, "epss_percentile": 0.59815}, "CVE-2020-29625": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2020-29629": {"epss_score": 0.003, "epss_percentile": 0.52951}, "CVE-2020-29633": {"epss_score": 0.00635, "epss_percentile": 0.69818}, "CVE-2020-29639": {"epss_score": 0.003, "epss_percentile": 0.52951}, "CVE-2020-29651": {"epss_score": 0.00848, "epss_percentile": 0.74356}, "CVE-2020-29652": {"epss_score": 0.00069, "epss_percentile": 0.21498}, "CVE-2020-29653": {"epss_score": 0.00331, "epss_percentile": 0.55545}, "CVE-2020-29654": {"epss_score": 0.00047, "epss_percentile": 0.14583}, "CVE-2020-29655": {"epss_score": 0.00238, "epss_percentile": 0.46811}, "CVE-2020-29656": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2020-29657": {"epss_score": 0.00468, "epss_percentile": 0.63913}, "CVE-2020-29658": {"epss_score": 0.14952, "epss_percentile": 0.94332}, "CVE-2020-29659": {"epss_score": 0.03403, "epss_percentile": 0.87071}, "CVE-2020-29660": {"epss_score": 0.00069, "epss_percentile": 0.21626}, "CVE-2020-29661": {"epss_score": 0.0026, "epss_percentile": 0.49178}, "CVE-2020-29662": {"epss_score": 0.00235, "epss_percentile": 0.46204}, "CVE-2020-29663": {"epss_score": 0.00482, "epss_percentile": 0.6455}, "CVE-2020-29664": {"epss_score": 0.00464, "epss_percentile": 0.6372}, "CVE-2020-29666": {"epss_score": 0.00447, "epss_percentile": 0.62964}, "CVE-2020-29667": {"epss_score": 0.04441, "epss_percentile": 0.88694}, "CVE-2020-29668": {"epss_score": 0.01039, "epss_percentile": 0.76941}, "CVE-2020-29669": {"epss_score": 0.10597, "epss_percentile": 0.93041}, "CVE-2020-2000": {"epss_score": 0.01715, "epss_percentile": 0.81898}, "CVE-2020-2001": {"epss_score": 0.01525, "epss_percentile": 0.80854}, "CVE-2020-2002": {"epss_score": 0.00584, "epss_percentile": 0.68384}, "CVE-2020-2003": {"epss_score": 0.00332, "epss_percentile": 0.55563}, "CVE-2020-2004": {"epss_score": 0.00058, "epss_percentile": 0.18305}, "CVE-2020-2005": {"epss_score": 0.00504, "epss_percentile": 0.65547}, "CVE-2020-2006": {"epss_score": 0.01526, "epss_percentile": 0.80864}, "CVE-2020-2007": {"epss_score": 0.03601, "epss_percentile": 0.87411}, "CVE-2020-2008": {"epss_score": 0.02993, "epss_percentile": 0.86149}, "CVE-2020-2009": {"epss_score": 0.01523, "epss_percentile": 0.80841}, "CVE-2020-2010": {"epss_score": 0.03173, "epss_percentile": 0.86554}, "CVE-2020-2011": {"epss_score": 0.0058, "epss_percentile": 0.68247}, "CVE-2020-2012": {"epss_score": 0.03507, "epss_percentile": 0.8726}, "CVE-2020-2013": {"epss_score": 0.0034, "epss_percentile": 0.56226}, "CVE-2020-2014": {"epss_score": 0.04821, "epss_percentile": 0.89177}, "CVE-2020-2015": {"epss_score": 0.01737, "epss_percentile": 0.82019}, "CVE-2020-2016": {"epss_score": 0.00207, "epss_percentile": 0.43156}, "CVE-2020-2017": {"epss_score": 0.00491, "epss_percentile": 0.64949}, "CVE-2020-2018": {"epss_score": 0.00319, "epss_percentile": 0.54556}, "CVE-2020-2020": {"epss_score": 0.00058, "epss_percentile": 0.18474}, "CVE-2020-2021": {"epss_score": 0.16868, "epss_percentile": 0.94739}, "CVE-2020-2022": {"epss_score": 0.00915, "epss_percentile": 0.75396}, "CVE-2020-2023": {"epss_score": 0.02375, "epss_percentile": 0.84539}, "CVE-2020-2024": {"epss_score": 0.00123, "epss_percentile": 0.32181}, "CVE-2020-2025": {"epss_score": 0.00113, "epss_percentile": 0.30698}, "CVE-2020-2026": {"epss_score": 0.00211, "epss_percentile": 0.43644}, "CVE-2020-2027": {"epss_score": 0.02401, "epss_percentile": 0.84639}, "CVE-2020-2028": {"epss_score": 0.00521, "epss_percentile": 0.66237}, "CVE-2020-2029": {"epss_score": 0.01112, "epss_percentile": 0.77675}, "CVE-2020-2030": {"epss_score": 0.02684, "epss_percentile": 0.85422}, "CVE-2020-2031": {"epss_score": 0.00319, "epss_percentile": 0.54549}, "CVE-2020-2032": {"epss_score": 0.00034, "epss_percentile": 0.0975}, "CVE-2020-2033": {"epss_score": 0.00032, "epss_percentile": 0.09042}, "CVE-2020-2034": {"epss_score": 0.6142, "epss_percentile": 0.98247}, "CVE-2020-2035": {"epss_score": 0.00263, "epss_percentile": 0.49505}, "CVE-2020-2036": {"epss_score": 0.8195, "epss_percentile": 0.99166}, "CVE-2020-2037": {"epss_score": 0.00993, "epss_percentile": 0.76402}, "CVE-2020-2038": {"epss_score": 0.88016, "epss_percentile": 0.99455}, "CVE-2020-2039": {"epss_score": 0.11151, "epss_percentile": 0.93244}, "CVE-2020-2040": {"epss_score": 0.03993, "epss_percentile": 0.88074}, "CVE-2020-2041": {"epss_score": 0.01335, "epss_percentile": 0.79551}, "CVE-2020-2042": {"epss_score": 0.01781, "epss_percentile": 0.82242}, "CVE-2020-2043": {"epss_score": 0.00228, "epss_percentile": 0.45548}, "CVE-2020-2044": {"epss_score": 0.00228, "epss_percentile": 0.45548}, "CVE-2020-2048": {"epss_score": 0.00057, "epss_percentile": 0.18184}, "CVE-2020-2049": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2020-2050": {"epss_score": 0.0016, "epss_percentile": 0.37435}, "CVE-2020-2075": {"epss_score": 0.00219, "epss_percentile": 0.44473}, "CVE-2020-2076": {"epss_score": 0.00431, "epss_percentile": 0.62051}, "CVE-2020-2077": {"epss_score": 0.00209, "epss_percentile": 0.43312}, "CVE-2020-2078": {"epss_score": 0.00215, "epss_percentile": 0.44054}, "CVE-2020-2090": {"epss_score": 0.0011, "epss_percentile": 0.30124}, "CVE-2020-2091": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2020-2092": {"epss_score": 0.00147, "epss_percentile": 0.35706}, "CVE-2020-2093": {"epss_score": 0.00089, "epss_percentile": 0.25962}, "CVE-2020-2094": {"epss_score": 0.00061, "epss_percentile": 0.1945}, "CVE-2020-2095": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2096": {"epss_score": 0.93762, "epss_percentile": 0.99841}, "CVE-2020-2097": {"epss_score": 0.00103, "epss_percentile": 0.28918}, "CVE-2020-2098": {"epss_score": 0.00167, "epss_percentile": 0.38387}, "CVE-2020-2099": {"epss_score": 0.00643, "epss_percentile": 0.70066}, "CVE-2020-2100": {"epss_score": 0.0137, "epss_percentile": 0.79801}, "CVE-2020-2101": {"epss_score": 0.01645, "epss_percentile": 0.81528}, "CVE-2020-2102": {"epss_score": 0.01523, "epss_percentile": 0.8084}, "CVE-2020-2103": {"epss_score": 0.45215, "epss_percentile": 0.97477}, "CVE-2020-2104": {"epss_score": 0.00473, "epss_percentile": 0.64079}, "CVE-2020-2105": {"epss_score": 0.00345, "epss_percentile": 0.5655}, "CVE-2020-2106": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2107": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2108": {"epss_score": 0.0006, "epss_percentile": 0.18952}, "CVE-2020-2109": {"epss_score": 0.00475, "epss_percentile": 0.64181}, "CVE-2020-2110": {"epss_score": 0.01291, "epss_percentile": 0.79227}, "CVE-2020-2111": {"epss_score": 0.00083, "epss_percentile": 0.24805}, "CVE-2020-2112": {"epss_score": 0.00121, "epss_percentile": 0.31999}, "CVE-2020-2113": {"epss_score": 0.00121, "epss_percentile": 0.31999}, "CVE-2020-2114": {"epss_score": 0.00053, "epss_percentile": 0.16702}, "CVE-2020-2115": {"epss_score": 0.00132, "epss_percentile": 0.33622}, "CVE-2020-2116": {"epss_score": 0.00074, "epss_percentile": 0.2274}, "CVE-2020-2117": {"epss_score": 0.00031, "epss_percentile": 0.08662}, "CVE-2020-2118": {"epss_score": 0.00031, "epss_percentile": 0.08662}, "CVE-2020-2119": {"epss_score": 0.00038, "epss_percentile": 0.11298}, "CVE-2020-2120": {"epss_score": 0.00132, "epss_percentile": 0.33622}, "CVE-2020-2121": {"epss_score": 0.01598, "epss_percentile": 0.81249}, "CVE-2020-2122": {"epss_score": 0.00103, "epss_percentile": 0.28972}, "CVE-2020-2123": {"epss_score": 0.00807, "epss_percentile": 0.73672}, "CVE-2020-2124": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2125": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2126": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2127": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2128": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2129": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2020-2130": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2020-2131": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2020-2132": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2020-2133": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2020-2134": {"epss_score": 0.00183, "epss_percentile": 0.40295}, "CVE-2020-2135": {"epss_score": 0.00183, "epss_percentile": 0.40295}, "CVE-2020-2136": {"epss_score": 0.00127, "epss_percentile": 0.32884}, "CVE-2020-2137": {"epss_score": 0.00242, "epss_percentile": 0.4734}, "CVE-2020-2138": {"epss_score": 0.00216, "epss_percentile": 0.44174}, "CVE-2020-2139": {"epss_score": 0.05232, "epss_percentile": 0.89643}, "CVE-2020-2140": {"epss_score": 0.44807, "epss_percentile": 0.97454}, "CVE-2020-2141": {"epss_score": 0.00427, "epss_percentile": 0.61877}, "CVE-2020-2142": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2143": {"epss_score": 0.00027, "epss_percentile": 0.0681}, "CVE-2020-2144": {"epss_score": 0.00089, "epss_percentile": 0.25915}, "CVE-2020-2145": {"epss_score": 0.00011, "epss_percentile": 0.01071}, "CVE-2020-2146": {"epss_score": 0.00034, "epss_percentile": 0.09659}, "CVE-2020-2147": {"epss_score": 0.00305, "epss_percentile": 0.53342}, "CVE-2020-2148": {"epss_score": 0.00052, "epss_percentile": 0.16342}, "CVE-2020-2149": {"epss_score": 0.00027, "epss_percentile": 0.0681}, "CVE-2020-2150": {"epss_score": 0.00027, "epss_percentile": 0.0681}, "CVE-2020-2151": {"epss_score": 0.00048, "epss_percentile": 0.15229}, "CVE-2020-2152": {"epss_score": 0.00141, "epss_percentile": 0.34907}, "CVE-2020-2153": {"epss_score": 0.00024, "epss_percentile": 0.05863}, "CVE-2020-2154": {"epss_score": 0.00032, "epss_percentile": 0.09028}, "CVE-2020-2155": {"epss_score": 0.00027, "epss_percentile": 0.0681}, "CVE-2020-2156": {"epss_score": 0.00044, "epss_percentile": 0.13378}, "CVE-2020-2157": {"epss_score": 0.00024, "epss_percentile": 0.05863}, "CVE-2020-2158": {"epss_score": 0.01027, "epss_percentile": 0.76803}, "CVE-2020-2159": {"epss_score": 0.02767, "epss_percentile": 0.85614}, "CVE-2020-2160": {"epss_score": 0.00197, "epss_percentile": 0.41833}, "CVE-2020-2161": {"epss_score": 0.00303, "epss_percentile": 0.53176}, "CVE-2020-2162": {"epss_score": 0.00427, "epss_percentile": 0.6178}, "CVE-2020-2163": {"epss_score": 0.00427, "epss_percentile": 0.6178}, "CVE-2020-2164": {"epss_score": 0.00258, "epss_percentile": 0.48983}, "CVE-2020-2165": {"epss_score": 0.00331, "epss_percentile": 0.5554}, "CVE-2020-2166": {"epss_score": 0.00654, "epss_percentile": 0.70348}, "CVE-2020-2167": {"epss_score": 0.03888, "epss_percentile": 0.87907}, "CVE-2020-2168": {"epss_score": 0.00654, "epss_percentile": 0.70348}, "CVE-2020-2169": {"epss_score": 0.00168, "epss_percentile": 0.38432}, "CVE-2020-2170": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2171": {"epss_score": 0.00132, "epss_percentile": 0.33622}, "CVE-2020-2172": {"epss_score": 0.00155, "epss_percentile": 0.36802}, "CVE-2020-2173": {"epss_score": 0.00156, "epss_percentile": 0.36893}, "CVE-2020-2174": {"epss_score": 0.00118, "epss_percentile": 0.31432}, "CVE-2020-2175": {"epss_score": 0.00156, "epss_percentile": 0.36893}, "CVE-2020-2176": {"epss_score": 0.00207, "epss_percentile": 0.43199}, "CVE-2020-2177": {"epss_score": 0.00024, "epss_percentile": 0.05863}, "CVE-2020-2178": {"epss_score": 0.00121, "epss_percentile": 0.3184}, "CVE-2020-2179": {"epss_score": 0.00807, "epss_percentile": 0.73672}, "CVE-2020-2180": {"epss_score": 0.00807, "epss_percentile": 0.73672}, "CVE-2020-2181": {"epss_score": 0.001, "epss_percentile": 0.28453}, "CVE-2020-2182": {"epss_score": 0.00045, "epss_percentile": 0.13907}, "CVE-2020-2183": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2020-2184": {"epss_score": 0.02004, "epss_percentile": 0.83228}, "CVE-2020-2185": {"epss_score": 0.001, "epss_percentile": 0.28529}, "CVE-2020-2186": {"epss_score": 0.00528, "epss_percentile": 0.66561}, "CVE-2020-2187": {"epss_score": 0.00037, "epss_percentile": 0.10981}, "CVE-2020-2188": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2189": {"epss_score": 0.00807, "epss_percentile": 0.73672}, "CVE-2020-2190": {"epss_score": 0.0012, "epss_percentile": 0.31696}, "CVE-2020-2191": {"epss_score": 0.00021, "epss_percentile": 0.04723}, "CVE-2020-2192": {"epss_score": 0.00412, "epss_percentile": 0.60905}, "CVE-2020-2193": {"epss_score": 0.00121, "epss_percentile": 0.31999}, "CVE-2020-2194": {"epss_score": 0.00121, "epss_percentile": 0.31999}, "CVE-2020-2195": {"epss_score": 0.00121, "epss_percentile": 0.31999}, "CVE-2020-2196": {"epss_score": 0.00105, "epss_percentile": 0.2929}, "CVE-2020-2197": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2198": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2020-2199": {"epss_score": 0.21759, "epss_percentile": 0.95555}, "CVE-2020-2200": {"epss_score": 0.03019, "epss_percentile": 0.8622}, "CVE-2020-2201": {"epss_score": 0.00089, "epss_percentile": 0.25957}, "CVE-2020-2202": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2203": {"epss_score": 0.00528, "epss_percentile": 0.66561}, "CVE-2020-2204": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2205": {"epss_score": 0.00178, "epss_percentile": 0.39671}, "CVE-2020-2206": {"epss_score": 0.00295, "epss_percentile": 0.52521}, "CVE-2020-2207": {"epss_score": 0.00295, "epss_percentile": 0.52521}, "CVE-2020-2208": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2209": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2210": {"epss_score": 0.00034, "epss_percentile": 0.09572}, "CVE-2020-2211": {"epss_score": 0.00807, "epss_percentile": 0.73672}, "CVE-2020-2212": {"epss_score": 0.00021, "epss_percentile": 0.04723}, "CVE-2020-2213": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2214": {"epss_score": 0.00121, "epss_percentile": 0.31999}, "CVE-2020-2215": {"epss_score": 0.00427, "epss_percentile": 0.61875}, "CVE-2020-2216": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2217": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-2218": {"epss_score": 0.00046, "epss_percentile": 0.14419}, "CVE-2020-2219": {"epss_score": 0.00121, "epss_percentile": 0.31999}, "CVE-2020-2220": {"epss_score": 0.00429, "epss_percentile": 0.61965}, "CVE-2020-2221": {"epss_score": 0.00536, "epss_percentile": 0.66868}, "CVE-2020-2222": {"epss_score": 0.00532, "epss_percentile": 0.66676}, "CVE-2020-2223": {"epss_score": 0.00525, "epss_percentile": 0.66369}, "CVE-2020-2224": {"epss_score": 0.00296, "epss_percentile": 0.5259}, "CVE-2020-2225": {"epss_score": 0.00312, "epss_percentile": 0.53939}, "CVE-2020-2226": {"epss_score": 0.00108, "epss_percentile": 0.29826}, "CVE-2020-2227": {"epss_score": 0.00121, "epss_percentile": 0.31999}, "CVE-2020-2228": {"epss_score": 0.00145, "epss_percentile": 0.35412}, "CVE-2020-2229": {"epss_score": 0.02228, "epss_percentile": 0.84077}, "CVE-2020-2230": {"epss_score": 0.00328, "epss_percentile": 0.55164}, "CVE-2020-2231": {"epss_score": 0.00472, "epss_percentile": 0.64058}, "CVE-2020-2232": {"epss_score": 0.00047, "epss_percentile": 0.14773}, "CVE-2020-2233": {"epss_score": 0.00048, "epss_percentile": 0.15045}, "CVE-2020-2234": {"epss_score": 0.00048, "epss_percentile": 0.15045}, "CVE-2020-2235": {"epss_score": 0.0041, "epss_percentile": 0.60827}, "CVE-2020-2236": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2237": {"epss_score": 0.00475, "epss_percentile": 0.6418}, "CVE-2020-2238": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2239": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2020-2240": {"epss_score": 0.00199, "epss_percentile": 0.42135}, "CVE-2020-2241": {"epss_score": 0.00433, "epss_percentile": 0.62225}, "CVE-2020-2242": {"epss_score": 0.00061, "epss_percentile": 0.1945}, "CVE-2020-2243": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2244": {"epss_score": 0.00171, "epss_percentile": 0.38886}, "CVE-2020-2245": {"epss_score": 0.00168, "epss_percentile": 0.38423}, "CVE-2020-2246": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2247": {"epss_score": 0.00145, "epss_percentile": 0.35399}, "CVE-2020-2248": {"epss_score": 0.00258, "epss_percentile": 0.49023}, "CVE-2020-2249": {"epss_score": 7e-05, "epss_percentile": 0.00415}, "CVE-2020-2250": {"epss_score": 0.00226, "epss_percentile": 0.45328}, "CVE-2020-2251": {"epss_score": 0.00042, "epss_percentile": 0.12749}, "CVE-2020-2252": {"epss_score": 0.00036, "epss_percentile": 0.10204}, "CVE-2020-2253": {"epss_score": 0.00036, "epss_percentile": 0.10395}, "CVE-2020-2254": {"epss_score": 0.02419, "epss_percentile": 0.84698}, "CVE-2020-2255": {"epss_score": 0.00061, "epss_percentile": 0.1945}, "CVE-2020-2256": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2257": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2258": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2259": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2260": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2261": {"epss_score": 0.00246, "epss_percentile": 0.47784}, "CVE-2020-2262": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2263": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2264": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2265": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2266": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2267": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2268": {"epss_score": 0.00088, "epss_percentile": 0.25639}, "CVE-2020-2269": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2270": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2271": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2272": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2273": {"epss_score": 0.00475, "epss_percentile": 0.6418}, "CVE-2020-2274": {"epss_score": 0.0001, "epss_percentile": 0.00869}, "CVE-2020-2275": {"epss_score": 0.01511, "epss_percentile": 0.80777}, "CVE-2020-2276": {"epss_score": 0.00671, "epss_percentile": 0.70805}, "CVE-2020-2277": {"epss_score": 0.01482, "epss_percentile": 0.80572}, "CVE-2020-2278": {"epss_score": 0.0101, "epss_percentile": 0.76593}, "CVE-2020-2279": {"epss_score": 0.00285, "epss_percentile": 0.51642}, "CVE-2020-2280": {"epss_score": 0.00145, "epss_percentile": 0.3537}, "CVE-2020-2281": {"epss_score": 0.00122, "epss_percentile": 0.32122}, "CVE-2020-2282": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2283": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2284": {"epss_score": 0.00066, "epss_percentile": 0.20696}, "CVE-2020-2285": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2286": {"epss_score": 0.001, "epss_percentile": 0.28547}, "CVE-2020-2287": {"epss_score": 0.00066, "epss_percentile": 0.20906}, "CVE-2020-2288": {"epss_score": 0.00066, "epss_percentile": 0.20906}, "CVE-2020-2289": {"epss_score": 0.00205, "epss_percentile": 0.42754}, "CVE-2020-2290": {"epss_score": 0.00235, "epss_percentile": 0.46221}, "CVE-2020-2291": {"epss_score": 0.0001, "epss_percentile": 0.00868}, "CVE-2020-2292": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2020-2293": {"epss_score": 0.00338, "epss_percentile": 0.5615}, "CVE-2020-2294": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2020-2295": {"epss_score": 0.0012, "epss_percentile": 0.31697}, "CVE-2020-2296": {"epss_score": 0.00528, "epss_percentile": 0.66561}, "CVE-2020-2297": {"epss_score": 0.0001, "epss_percentile": 0.00868}, "CVE-2020-2298": {"epss_score": 0.00686, "epss_percentile": 0.71155}, "CVE-2020-2299": {"epss_score": 0.00191, "epss_percentile": 0.41276}, "CVE-2020-2300": {"epss_score": 0.00191, "epss_percentile": 0.41276}, "CVE-2020-2301": {"epss_score": 0.00181, "epss_percentile": 0.40035}, "CVE-2020-2302": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2020-2303": {"epss_score": 0.00475, "epss_percentile": 0.6418}, "CVE-2020-2304": {"epss_score": 0.01606, "epss_percentile": 0.81303}, "CVE-2020-2305": {"epss_score": 0.00503, "epss_percentile": 0.65481}, "CVE-2020-2306": {"epss_score": 0.00064, "epss_percentile": 0.20172}, "CVE-2020-2307": {"epss_score": 0.00082, "epss_percentile": 0.24496}, "CVE-2020-2308": {"epss_score": 0.00089, "epss_percentile": 0.25838}, "CVE-2020-2309": {"epss_score": 0.00089, "epss_percentile": 0.25838}, "CVE-2020-2310": {"epss_score": 0.00065, "epss_percentile": 0.20483}, "CVE-2020-2311": {"epss_score": 0.00067, "epss_percentile": 0.21015}, "CVE-2020-2312": {"epss_score": 0.00183, "epss_percentile": 0.40341}, "CVE-2020-2313": {"epss_score": 0.00065, "epss_percentile": 0.20483}, "CVE-2020-2314": {"epss_score": 0.00011, "epss_percentile": 0.01071}, "CVE-2020-2315": {"epss_score": 0.00274, "epss_percentile": 0.50537}, "CVE-2020-2316": {"epss_score": 0.00246, "epss_percentile": 0.47756}, "CVE-2020-2317": {"epss_score": 0.00217, "epss_percentile": 0.44277}, "CVE-2020-2318": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2020-2319": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2020-2320": {"epss_score": 0.00438, "epss_percentile": 0.62574}, "CVE-2020-2321": {"epss_score": 0.0008, "epss_percentile": 0.24115}, "CVE-2020-2322": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2020-2323": {"epss_score": 0.00206, "epss_percentile": 0.42787}, "CVE-2020-2324": {"epss_score": 0.00147, "epss_percentile": 0.35713}, "CVE-2020-2490": {"epss_score": 0.01018, "epss_percentile": 0.76704}, "CVE-2020-2491": {"epss_score": 0.0027, "epss_percentile": 0.50233}, "CVE-2020-2492": {"epss_score": 0.02557, "epss_percentile": 0.85096}, "CVE-2020-2493": {"epss_score": 0.0027, "epss_percentile": 0.50233}, "CVE-2020-2494": {"epss_score": 0.0027, "epss_percentile": 0.50233}, "CVE-2020-2495": {"epss_score": 0.0027, "epss_percentile": 0.50233}, "CVE-2020-2496": {"epss_score": 0.00327, "epss_percentile": 0.551}, "CVE-2020-2497": {"epss_score": 0.00327, "epss_percentile": 0.551}, "CVE-2020-2498": {"epss_score": 0.00145, "epss_percentile": 0.35442}, "CVE-2020-2499": {"epss_score": 0.00198, "epss_percentile": 0.42046}, "CVE-2020-2500": {"epss_score": 0.00255, "epss_percentile": 0.48639}, "CVE-2020-2501": {"epss_score": 0.03755, "epss_percentile": 0.87681}, "CVE-2020-2502": {"epss_score": 0.00239, "epss_percentile": 0.46842}, "CVE-2020-2503": {"epss_score": 0.00296, "epss_percentile": 0.52618}, "CVE-2020-2504": {"epss_score": 0.00349, "epss_percentile": 0.56868}, "CVE-2020-2505": {"epss_score": 0.00059, "epss_percentile": 0.18818}, "CVE-2020-2506": {"epss_score": 0.17988, "epss_percentile": 0.94938}, "CVE-2020-2507": {"epss_score": 0.04621, "epss_percentile": 0.88932}, "CVE-2020-2508": {"epss_score": 0.0246, "epss_percentile": 0.84821}, "CVE-2020-2509": {"epss_score": 0.85958, "epss_percentile": 0.99358}, "CVE-2020-2510": {"epss_score": 0.02116, "epss_percentile": 0.8366}, "CVE-2020-2511": {"epss_score": 0.00407, "epss_percentile": 0.60618}, "CVE-2020-2512": {"epss_score": 0.01622, "epss_percentile": 0.81398}, "CVE-2020-2513": {"epss_score": 0.00283, "epss_percentile": 0.5138}, "CVE-2020-2514": {"epss_score": 0.00424, "epss_percentile": 0.61638}, "CVE-2020-2515": {"epss_score": 0.0035, "epss_percentile": 0.56945}, "CVE-2020-2516": {"epss_score": 0.00281, "epss_percentile": 0.51115}, "CVE-2020-2517": {"epss_score": 0.00317, "epss_percentile": 0.54362}, "CVE-2020-2518": {"epss_score": 0.00817, "epss_percentile": 0.73842}, "CVE-2020-2519": {"epss_score": 0.01914, "epss_percentile": 0.82849}, "CVE-2020-2522": {"epss_score": 0.00981, "epss_percentile": 0.76277}, "CVE-2020-2524": {"epss_score": 0.01401, "epss_percentile": 0.80008}, "CVE-2020-2527": {"epss_score": 0.0029, "epss_percentile": 0.52119}, "CVE-2020-2530": {"epss_score": 0.01121, "epss_percentile": 0.77769}, "CVE-2020-2531": {"epss_score": 0.00992, "epss_percentile": 0.76396}, "CVE-2020-2533": {"epss_score": 0.00898, "epss_percentile": 0.75142}, "CVE-2020-2534": {"epss_score": 0.00898, "epss_percentile": 0.75142}, "CVE-2020-2535": {"epss_score": 0.0175, "epss_percentile": 0.82097}, "CVE-2020-2536": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2537": {"epss_score": 0.01539, "epss_percentile": 0.80938}, "CVE-2020-2538": {"epss_score": 0.01499, "epss_percentile": 0.80707}, "CVE-2020-2539": {"epss_score": 0.01163, "epss_percentile": 0.7816}, "CVE-2020-2540": {"epss_score": 0.0121, "epss_percentile": 0.78548}, "CVE-2020-2541": {"epss_score": 0.0121, "epss_percentile": 0.78548}, "CVE-2020-2542": {"epss_score": 0.0121, "epss_percentile": 0.78548}, "CVE-2020-2543": {"epss_score": 0.00926, "epss_percentile": 0.7555}, "CVE-2020-2544": {"epss_score": 0.0122, "epss_percentile": 0.78619}, "CVE-2020-2545": {"epss_score": 0.03921, "epss_percentile": 0.87953}, "CVE-2020-2546": {"epss_score": 0.29688, "epss_percentile": 0.96466}, "CVE-2020-2547": {"epss_score": 0.00306, "epss_percentile": 0.53443}, "CVE-2020-2548": {"epss_score": 0.00306, "epss_percentile": 0.53443}, "CVE-2020-2549": {"epss_score": 0.01329, "epss_percentile": 0.79508}, "CVE-2020-2550": {"epss_score": 0.00371, "epss_percentile": 0.58364}, "CVE-2020-2551": {"epss_score": 0.94412, "epss_percentile": 0.99976}, "CVE-2020-2552": {"epss_score": 0.0041, "epss_percentile": 0.60843}, "CVE-2020-2553": {"epss_score": 0.00788, "epss_percentile": 0.73341}, "CVE-2020-2555": {"epss_score": 0.93141, "epss_percentile": 0.99779}, "CVE-2020-2556": {"epss_score": 0.00106, "epss_percentile": 0.2946}, "CVE-2020-2557": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2558": {"epss_score": 0.0152, "epss_percentile": 0.80822}, "CVE-2020-2559": {"epss_score": 0.01102, "epss_percentile": 0.7758}, "CVE-2020-2560": {"epss_score": 0.00868, "epss_percentile": 0.74681}, "CVE-2020-2561": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2020-2562": {"epss_score": 0.00852, "epss_percentile": 0.74414}, "CVE-2020-2563": {"epss_score": 0.00364, "epss_percentile": 0.57928}, "CVE-2020-2564": {"epss_score": 0.01176, "epss_percentile": 0.78272}, "CVE-2020-2565": {"epss_score": 0.00115, "epss_percentile": 0.30991}, "CVE-2020-2566": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2567": {"epss_score": 0.00262, "epss_percentile": 0.49333}, "CVE-2020-2568": {"epss_score": 0.00267, "epss_percentile": 0.49956}, "CVE-2020-2569": {"epss_score": 0.00132, "epss_percentile": 0.33591}, "CVE-2020-2570": {"epss_score": 0.00453, "epss_percentile": 0.63221}, "CVE-2020-2571": {"epss_score": 0.00339, "epss_percentile": 0.56206}, "CVE-2020-2572": {"epss_score": 0.00321, "epss_percentile": 0.54687}, "CVE-2020-2573": {"epss_score": 0.00702, "epss_percentile": 0.71516}, "CVE-2020-2574": {"epss_score": 0.0016, "epss_percentile": 0.37516}, "CVE-2020-2575": {"epss_score": 0.00166, "epss_percentile": 0.38189}, "CVE-2020-2576": {"epss_score": 0.0121, "epss_percentile": 0.78548}, "CVE-2020-2577": {"epss_score": 0.00362, "epss_percentile": 0.57762}, "CVE-2020-2578": {"epss_score": 0.0152, "epss_percentile": 0.80822}, "CVE-2020-2579": {"epss_score": 0.00487, "epss_percentile": 0.6481}, "CVE-2020-2580": {"epss_score": 0.00365, "epss_percentile": 0.58001}, "CVE-2020-2581": {"epss_score": 0.00714, "epss_percentile": 0.7181}, "CVE-2020-2582": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2583": {"epss_score": 0.00474, "epss_percentile": 0.64137}, "CVE-2020-2584": {"epss_score": 0.00437, "epss_percentile": 0.62526}, "CVE-2020-2585": {"epss_score": 0.01206, "epss_percentile": 0.78521}, "CVE-2020-2586": {"epss_score": 0.01981, "epss_percentile": 0.83138}, "CVE-2020-2587": {"epss_score": 0.01981, "epss_percentile": 0.83138}, "CVE-2020-2588": {"epss_score": 0.00362, "epss_percentile": 0.57762}, "CVE-2020-2589": {"epss_score": 0.0023, "epss_percentile": 0.45721}, "CVE-2020-2590": {"epss_score": 0.00442, "epss_percentile": 0.62738}, "CVE-2020-2591": {"epss_score": 0.01456, "epss_percentile": 0.80396}, "CVE-2020-2592": {"epss_score": 0.01176, "epss_percentile": 0.78272}, "CVE-2020-2593": {"epss_score": 0.00594, "epss_percentile": 0.68665}, "CVE-2020-2594": {"epss_score": 0.00403, "epss_percentile": 0.60329}, "CVE-2020-2595": {"epss_score": 0.00868, "epss_percentile": 0.74681}, "CVE-2020-2596": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2597": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2598": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2599": {"epss_score": 0.00246, "epss_percentile": 0.47744}, "CVE-2020-2600": {"epss_score": 0.00935, "epss_percentile": 0.75667}, "CVE-2020-2601": {"epss_score": 0.00652, "epss_percentile": 0.70307}, "CVE-2020-2602": {"epss_score": 0.00935, "epss_percentile": 0.75667}, "CVE-2020-2603": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2604": {"epss_score": 0.01449, "epss_percentile": 0.80338}, "CVE-2020-2605": {"epss_score": 0.0011, "epss_percentile": 0.30077}, "CVE-2020-2606": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2607": {"epss_score": 0.00935, "epss_percentile": 0.75667}, "CVE-2020-2608": {"epss_score": 0.00504, "epss_percentile": 0.65489}, "CVE-2020-2609": {"epss_score": 0.00421, "epss_percentile": 0.6149}, "CVE-2020-2610": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2611": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2612": {"epss_score": 0.00504, "epss_percentile": 0.65489}, "CVE-2020-2613": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2614": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2615": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2616": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2617": {"epss_score": 0.00488, "epss_percentile": 0.64843}, "CVE-2020-2618": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2619": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2620": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2621": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2622": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2623": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2624": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2625": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2626": {"epss_score": 0.00504, "epss_percentile": 0.65489}, "CVE-2020-2627": {"epss_score": 0.00239, "epss_percentile": 0.46939}, "CVE-2020-2628": {"epss_score": 0.00504, "epss_percentile": 0.65489}, "CVE-2020-2629": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2630": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2631": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2632": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2633": {"epss_score": 0.00521, "epss_percentile": 0.66236}, "CVE-2020-2634": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2635": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2636": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2637": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2638": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2639": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2640": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2641": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2642": {"epss_score": 0.00488, "epss_percentile": 0.64843}, "CVE-2020-2643": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2644": {"epss_score": 0.00469, "epss_percentile": 0.63931}, "CVE-2020-2645": {"epss_score": 0.00521, "epss_percentile": 0.66236}, "CVE-2020-2646": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2020-2647": {"epss_score": 0.00192, "epss_percentile": 0.41319}, "CVE-2020-2648": {"epss_score": 0.00135, "epss_percentile": 0.33931}, "CVE-2020-2649": {"epss_score": 0.00121, "epss_percentile": 0.32008}, "CVE-2020-2650": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2651": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2652": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2653": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2654": {"epss_score": 0.00274, "epss_percentile": 0.50509}, "CVE-2020-2655": {"epss_score": 0.02411, "epss_percentile": 0.84665}, "CVE-2020-2656": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2020-2657": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2658": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2659": {"epss_score": 0.00279, "epss_percentile": 0.50937}, "CVE-2020-2660": {"epss_score": 0.00362, "epss_percentile": 0.57762}, "CVE-2020-2661": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2662": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2663": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2664": {"epss_score": 0.00099, "epss_percentile": 0.28378}, "CVE-2020-2665": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2666": {"epss_score": 0.01405, "epss_percentile": 0.80041}, "CVE-2020-2667": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2668": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2669": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2670": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2671": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2672": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2673": {"epss_score": 0.02331, "epss_percentile": 0.84402}, "CVE-2020-2674": {"epss_score": 0.00167, "epss_percentile": 0.38358}, "CVE-2020-2675": {"epss_score": 0.00475, "epss_percentile": 0.64249}, "CVE-2020-2676": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2677": {"epss_score": 0.00601, "epss_percentile": 0.68838}, "CVE-2020-2678": {"epss_score": 0.00144, "epss_percentile": 0.35269}, "CVE-2020-2679": {"epss_score": 0.00362, "epss_percentile": 0.57762}, "CVE-2020-2680": {"epss_score": 0.00201, "epss_percentile": 0.42388}, "CVE-2020-2681": {"epss_score": 0.00123, "epss_percentile": 0.32305}, "CVE-2020-2682": {"epss_score": 0.00167, "epss_percentile": 0.38358}, "CVE-2020-2683": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2020-2684": {"epss_score": 0.00601, "epss_percentile": 0.68838}, "CVE-2020-2685": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2686": {"epss_score": 0.00637, "epss_percentile": 0.69898}, "CVE-2020-2687": {"epss_score": 0.01102, "epss_percentile": 0.7758}, "CVE-2020-2688": {"epss_score": 0.00475, "epss_percentile": 0.64249}, "CVE-2020-2689": {"epss_score": 0.00123, "epss_percentile": 0.32305}, "CVE-2020-2690": {"epss_score": 0.00234, "epss_percentile": 0.46177}, "CVE-2020-2691": {"epss_score": 0.00416, "epss_percentile": 0.61192}, "CVE-2020-2692": {"epss_score": 0.00123, "epss_percentile": 0.32305}, "CVE-2020-2693": {"epss_score": 0.00135, "epss_percentile": 0.33983}, "CVE-2020-2694": {"epss_score": 0.0032, "epss_percentile": 0.54634}, "CVE-2020-2695": {"epss_score": 0.01176, "epss_percentile": 0.78272}, "CVE-2020-2696": {"epss_score": 0.0008, "epss_percentile": 0.24123}, "CVE-2020-2697": {"epss_score": 0.00171, "epss_percentile": 0.38856}, "CVE-2020-2698": {"epss_score": 0.00167, "epss_percentile": 0.38358}, "CVE-2020-2699": {"epss_score": 0.00475, "epss_percentile": 0.64249}, "CVE-2020-2700": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2020-2701": {"epss_score": 0.00167, "epss_percentile": 0.38358}, "CVE-2020-2702": {"epss_score": 0.00167, "epss_percentile": 0.38358}, "CVE-2020-2703": {"epss_score": 0.00151, "epss_percentile": 0.36253}, "CVE-2020-2704": {"epss_score": 0.00123, "epss_percentile": 0.32305}, "CVE-2020-2705": {"epss_score": 0.00123, "epss_percentile": 0.32305}, "CVE-2020-2706": {"epss_score": 0.00305, "epss_percentile": 0.53338}, "CVE-2020-2707": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2020-2709": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2710": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2020-2711": {"epss_score": 0.00601, "epss_percentile": 0.68838}, "CVE-2020-2712": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2713": {"epss_score": 0.00475, "epss_percentile": 0.64249}, "CVE-2020-2714": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2020-2715": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2020-2716": {"epss_score": 0.00601, "epss_percentile": 0.68838}, "CVE-2020-2717": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2718": {"epss_score": 0.00475, "epss_percentile": 0.64249}, "CVE-2020-2719": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2020-2720": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2020-2721": {"epss_score": 0.00601, "epss_percentile": 0.68838}, "CVE-2020-2722": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2723": {"epss_score": 0.00475, "epss_percentile": 0.64249}, "CVE-2020-2724": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2020-2725": {"epss_score": 0.00151, "epss_percentile": 0.36253}, "CVE-2020-2726": {"epss_score": 0.00167, "epss_percentile": 0.38358}, "CVE-2020-2727": {"epss_score": 0.00135, "epss_percentile": 0.33983}, "CVE-2020-2728": {"epss_score": 0.05655, "epss_percentile": 0.90089}, "CVE-2020-2729": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2020-2730": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2020-2731": {"epss_score": 0.00132, "epss_percentile": 0.33591}, "CVE-2020-2732": {"epss_score": 0.00438, "epss_percentile": 0.62544}, "CVE-2020-2733": {"epss_score": 0.88882, "epss_percentile": 0.99497}, "CVE-2020-2734": {"epss_score": 0.0041, "epss_percentile": 0.60794}, "CVE-2020-2735": {"epss_score": 0.01229, "epss_percentile": 0.78718}, "CVE-2020-2737": {"epss_score": 0.01309, "epss_percentile": 0.79352}, "CVE-2020-2738": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2020-2739": {"epss_score": 0.03151, "epss_percentile": 0.86506}, "CVE-2020-2740": {"epss_score": 0.00257, "epss_percentile": 0.48913}, "CVE-2020-2741": {"epss_score": 0.0015, "epss_percentile": 0.36175}, "CVE-2020-2742": {"epss_score": 0.00156, "epss_percentile": 0.3701}, "CVE-2020-2743": {"epss_score": 0.0015, "epss_percentile": 0.36175}, "CVE-2020-2744": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2020-2745": {"epss_score": 0.0376, "epss_percentile": 0.87687}, "CVE-2020-2746": {"epss_score": 0.01261, "epss_percentile": 0.78976}, "CVE-2020-2747": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2020-2748": {"epss_score": 0.00128, "epss_percentile": 0.32975}, "CVE-2020-2749": {"epss_score": 0.00265, "epss_percentile": 0.49775}, "CVE-2020-2750": {"epss_score": 0.02186, "epss_percentile": 0.83921}, "CVE-2020-2751": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2752": {"epss_score": 0.00195, "epss_percentile": 0.41633}, "CVE-2020-2753": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2754": {"epss_score": 0.00217, "epss_percentile": 0.44258}, "CVE-2020-2755": {"epss_score": 0.00208, "epss_percentile": 0.43296}, "CVE-2020-2756": {"epss_score": 0.0026, "epss_percentile": 0.49241}, "CVE-2020-2757": {"epss_score": 0.0026, "epss_percentile": 0.49241}, "CVE-2020-2758": {"epss_score": 0.00156, "epss_percentile": 0.3701}, "CVE-2020-2759": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2020-2760": {"epss_score": 0.00096, "epss_percentile": 0.27303}, "CVE-2020-2761": {"epss_score": 0.00512, "epss_percentile": 0.65856}, "CVE-2020-2762": {"epss_score": 0.0008, "epss_percentile": 0.24177}, "CVE-2020-2763": {"epss_score": 0.00447, "epss_percentile": 0.62988}, "CVE-2020-2764": {"epss_score": 0.00917, "epss_percentile": 0.75429}, "CVE-2020-2765": {"epss_score": 0.0008, "epss_percentile": 0.24177}, "CVE-2020-2766": {"epss_score": 0.01434, "epss_percentile": 0.80262}, "CVE-2020-2767": {"epss_score": 0.00291, "epss_percentile": 0.52211}, "CVE-2020-2768": {"epss_score": 0.0041, "epss_percentile": 0.60817}, "CVE-2020-2769": {"epss_score": 0.00404, "epss_percentile": 0.60445}, "CVE-2020-2770": {"epss_score": 0.00512, "epss_percentile": 0.65856}, "CVE-2020-2771": {"epss_score": 0.00141, "epss_percentile": 0.34824}, "CVE-2020-2772": {"epss_score": 0.0031, "epss_percentile": 0.53784}, "CVE-2020-2773": {"epss_score": 0.00771, "epss_percentile": 0.73023}, "CVE-2020-2774": {"epss_score": 0.00512, "epss_percentile": 0.65856}, "CVE-2020-2775": {"epss_score": 0.01176, "epss_percentile": 0.78272}, "CVE-2020-2776": {"epss_score": 0.01422, "epss_percentile": 0.80179}, "CVE-2020-2777": {"epss_score": 0.00446, "epss_percentile": 0.62906}, "CVE-2020-2778": {"epss_score": 0.00356, "epss_percentile": 0.57397}, "CVE-2020-2779": {"epss_score": 0.00393, "epss_percentile": 0.5973}, "CVE-2020-2780": {"epss_score": 0.00163, "epss_percentile": 0.37804}, "CVE-2020-2781": {"epss_score": 0.00255, "epss_percentile": 0.48712}, "CVE-2020-2782": {"epss_score": 0.00886, "epss_percentile": 0.74954}, "CVE-2020-2783": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2784": {"epss_score": 0.00926, "epss_percentile": 0.7555}, "CVE-2020-2785": {"epss_score": 0.00926, "epss_percentile": 0.7555}, "CVE-2020-2786": {"epss_score": 0.00926, "epss_percentile": 0.7555}, "CVE-2020-2787": {"epss_score": 0.00926, "epss_percentile": 0.7555}, "CVE-2020-2789": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2790": {"epss_score": 0.00471, "epss_percentile": 0.63995}, "CVE-2020-2791": {"epss_score": 0.01818, "epss_percentile": 0.82399}, "CVE-2020-2793": {"epss_score": 0.0038, "epss_percentile": 0.5893}, "CVE-2020-2794": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2795": {"epss_score": 0.00463, "epss_percentile": 0.63686}, "CVE-2020-2796": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2797": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2798": {"epss_score": 0.03356, "epss_percentile": 0.86975}, "CVE-2020-2799": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2020-2800": {"epss_score": 0.00576, "epss_percentile": 0.68148}, "CVE-2020-2801": {"epss_score": 0.05411, "epss_percentile": 0.89844}, "CVE-2020-2802": {"epss_score": 0.00389, "epss_percentile": 0.59411}, "CVE-2020-2803": {"epss_score": 0.03262, "epss_percentile": 0.86775}, "CVE-2020-2804": {"epss_score": 0.00744, "epss_percentile": 0.72508}, "CVE-2020-2805": {"epss_score": 0.01833, "epss_percentile": 0.82457}, "CVE-2020-2806": {"epss_score": 0.00493, "epss_percentile": 0.65035}, "CVE-2020-2807": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2808": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2809": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2810": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2811": {"epss_score": 0.01121, "epss_percentile": 0.77769}, "CVE-2020-2812": {"epss_score": 0.00104, "epss_percentile": 0.29169}, "CVE-2020-2813": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2814": {"epss_score": 0.00111, "epss_percentile": 0.30392}, "CVE-2020-2815": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2816": {"epss_score": 0.00535, "epss_percentile": 0.6683}, "CVE-2020-2817": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2818": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2819": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2820": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2821": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2822": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2823": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2824": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2825": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2826": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2827": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2828": {"epss_score": 0.02374, "epss_percentile": 0.84537}, "CVE-2020-2829": {"epss_score": 0.00767, "epss_percentile": 0.72951}, "CVE-2020-2830": {"epss_score": 0.00222, "epss_percentile": 0.44796}, "CVE-2020-2831": {"epss_score": 0.02595, "epss_percentile": 0.85193}, "CVE-2020-2832": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2833": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2834": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2835": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2836": {"epss_score": 0.02627, "epss_percentile": 0.8527}, "CVE-2020-2837": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2838": {"epss_score": 0.01621, "epss_percentile": 0.8139}, "CVE-2020-2839": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2840": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2841": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2842": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2843": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2844": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2845": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2846": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2847": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2848": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2849": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2850": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2851": {"epss_score": 0.00135, "epss_percentile": 0.3404}, "CVE-2020-2852": {"epss_score": 0.09693, "epss_percentile": 0.92665}, "CVE-2020-2853": {"epss_score": 0.00512, "epss_percentile": 0.65856}, "CVE-2020-2854": {"epss_score": 0.09693, "epss_percentile": 0.92665}, "CVE-2020-2855": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2856": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2857": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2858": {"epss_score": 0.02595, "epss_percentile": 0.85193}, "CVE-2020-2859": {"epss_score": 0.018, "epss_percentile": 0.82322}, "CVE-2020-2860": {"epss_score": 0.02595, "epss_percentile": 0.85193}, "CVE-2020-2861": {"epss_score": 0.02595, "epss_percentile": 0.85193}, "CVE-2020-2862": {"epss_score": 0.00868, "epss_percentile": 0.74681}, "CVE-2020-2863": {"epss_score": 0.00475, "epss_percentile": 0.64249}, "CVE-2020-2864": {"epss_score": 0.01176, "epss_percentile": 0.78272}, "CVE-2020-2865": {"epss_score": 0.01176, "epss_percentile": 0.78272}, "CVE-2020-2866": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2867": {"epss_score": 0.01305, "epss_percentile": 0.79325}, "CVE-2020-2868": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2869": {"epss_score": 0.0122, "epss_percentile": 0.78619}, "CVE-2020-2870": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2871": {"epss_score": 0.09693, "epss_percentile": 0.92665}, "CVE-2020-2872": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2873": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2874": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2875": {"epss_score": 0.0089, "epss_percentile": 0.75026}, "CVE-2020-2876": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2877": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2878": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2879": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2880": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2881": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2882": {"epss_score": 0.07439, "epss_percentile": 0.91474}, "CVE-2020-2883": {"epss_score": 0.94357, "epss_percentile": 0.99958}, "CVE-2020-2884": {"epss_score": 0.0449, "epss_percentile": 0.88756}, "CVE-2020-2885": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2020-2886": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2887": {"epss_score": 0.00978, "epss_percentile": 0.7625}, "CVE-2020-2888": {"epss_score": 0.01176, "epss_percentile": 0.78272}, "CVE-2020-2889": {"epss_score": 0.01176, "epss_percentile": 0.78272}, "CVE-2020-2890": {"epss_score": 0.02221, "epss_percentile": 0.84051}, "CVE-2020-2891": {"epss_score": 0.00316, "epss_percentile": 0.54228}, "CVE-2020-2892": {"epss_score": 0.00237, "epss_percentile": 0.46736}, "CVE-2020-2893": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2020-2894": {"epss_score": 0.00118, "epss_percentile": 0.31386}, "CVE-2020-2895": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2020-2896": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2020-2897": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2020-2898": {"epss_score": 0.0008, "epss_percentile": 0.24177}, "CVE-2020-2899": {"epss_score": 0.00262, "epss_percentile": 0.49333}, "CVE-2020-2900": {"epss_score": 0.00301, "epss_percentile": 0.53042}, "CVE-2020-2901": {"epss_score": 0.00447, "epss_percentile": 0.62988}, "CVE-2020-2902": {"epss_score": 0.00143, "epss_percentile": 0.35181}, "CVE-2020-2903": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2020-2904": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2020-2905": {"epss_score": 0.00158, "epss_percentile": 0.372}, "CVE-2020-2906": {"epss_score": 0.00601, "epss_percentile": 0.68838}, "CVE-2020-2907": {"epss_score": 0.00154, "epss_percentile": 0.36728}, "CVE-2020-2908": {"epss_score": 0.00154, "epss_percentile": 0.36728}, "CVE-2020-2909": {"epss_score": 0.00224, "epss_percentile": 0.44976}, "CVE-2020-2910": {"epss_score": 0.00136, "epss_percentile": 0.3419}, "CVE-2020-2911": {"epss_score": 0.00156, "epss_percentile": 0.3701}, "CVE-2020-2912": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2020-2913": {"epss_score": 0.00257, "epss_percentile": 0.48913}, "CVE-2020-2914": {"epss_score": 0.00257, "epss_percentile": 0.48913}, "CVE-2020-2915": {"epss_score": 0.04481, "epss_percentile": 0.88743}, "CVE-2020-2920": {"epss_score": 0.01065, "epss_percentile": 0.77207}, "CVE-2020-2921": {"epss_score": 0.00132, "epss_percentile": 0.3361}, "CVE-2020-2922": {"epss_score": 0.00186, "epss_percentile": 0.40693}, "CVE-2020-2923": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2020-2924": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2020-2925": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2020-2926": {"epss_score": 0.00094, "epss_percentile": 0.27046}, "CVE-2020-2927": {"epss_score": 0.00115, "epss_percentile": 0.30991}, "CVE-2020-2928": {"epss_score": 0.00507, "epss_percentile": 0.65649}, "CVE-2020-2929": {"epss_score": 0.00255, "epss_percentile": 0.48642}, "CVE-2020-2930": {"epss_score": 0.0008, "epss_percentile": 0.24177}, "CVE-2020-2931": {"epss_score": 0.01898, "epss_percentile": 0.82763}, "CVE-2020-2932": {"epss_score": 0.01622, "epss_percentile": 0.81398}, "CVE-2020-2933": {"epss_score": 0.00128, "epss_percentile": 0.32968}, "CVE-2020-2934": {"epss_score": 0.00133, "epss_percentile": 0.33742}, "CVE-2020-2935": {"epss_score": 0.00337, "epss_percentile": 0.56047}, "CVE-2020-2936": {"epss_score": 0.00316, "epss_percentile": 0.54228}, "CVE-2020-2937": {"epss_score": 0.00316, "epss_percentile": 0.54228}, "CVE-2020-2938": {"epss_score": 0.00316, "epss_percentile": 0.54228}, "CVE-2020-2939": {"epss_score": 0.00316, "epss_percentile": 0.54228}, "CVE-2020-2940": {"epss_score": 0.00316, "epss_percentile": 0.54228}, "CVE-2020-2941": {"epss_score": 0.00316, "epss_percentile": 0.54228}, "CVE-2020-2942": {"epss_score": 0.00316, "epss_percentile": 0.54228}, "CVE-2020-2943": {"epss_score": 0.00337, "epss_percentile": 0.56047}, "CVE-2020-2944": {"epss_score": 0.0059, "epss_percentile": 0.68554}, "CVE-2020-2945": {"epss_score": 0.00405, "epss_percentile": 0.60511}, "CVE-2020-2946": {"epss_score": 0.00504, "epss_percentile": 0.65489}, "CVE-2020-2947": {"epss_score": 0.00323, "epss_percentile": 0.54871}, "CVE-2020-2949": {"epss_score": 0.01373, "epss_percentile": 0.79817}, "CVE-2020-2950": {"epss_score": 0.87568, "epss_percentile": 0.99433}, "CVE-2020-2951": {"epss_score": 0.00134, "epss_percentile": 0.33923}, "CVE-2020-2952": {"epss_score": 0.01403, "epss_percentile": 0.8003}, "CVE-2020-2953": {"epss_score": 0.01559, "epss_percentile": 0.81031}, "CVE-2020-2954": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2020-2955": {"epss_score": 0.0035, "epss_percentile": 0.56945}, "CVE-2020-2956": {"epss_score": 0.01118, "epss_percentile": 0.77748}, "CVE-2020-2958": {"epss_score": 0.00178, "epss_percentile": 0.3972}, "CVE-2020-2959": {"epss_score": 0.01501, "epss_percentile": 0.80714}, "CVE-2020-2961": {"epss_score": 0.01818, "epss_percentile": 0.82399}, "CVE-2020-2963": {"epss_score": 0.01329, "epss_percentile": 0.79508}, "CVE-2020-2964": {"epss_score": 0.0038, "epss_percentile": 0.5893}, "CVE-2020-2966": {"epss_score": 0.00601, "epss_percentile": 0.68859}, "CVE-2020-2967": {"epss_score": 0.0467, "epss_percentile": 0.88986}, "CVE-2020-2968": {"epss_score": 0.01706, "epss_percentile": 0.81855}, "CVE-2020-2969": {"epss_score": 0.02081, "epss_percentile": 0.83531}, "CVE-2020-2971": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-2972": {"epss_score": 0.00241, "epss_percentile": 0.473}, "CVE-2020-2973": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-2974": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-2975": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-2976": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-2977": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2020-2978": {"epss_score": 0.00208, "epss_percentile": 0.43214}, "CVE-2020-2981": {"epss_score": 0.00481, "epss_percentile": 0.64504}, "CVE-2020-2982": {"epss_score": 0.00478, "epss_percentile": 0.64383}, "CVE-2020-2983": {"epss_score": 0.00478, "epss_percentile": 0.64383}, "CVE-2020-2984": {"epss_score": 0.00478, "epss_percentile": 0.64383}, "CVE-2020-35012": {"epss_score": 0.00789, "epss_percentile": 0.73348}, "CVE-2020-35037": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2020-35111": {"epss_score": 0.00318, "epss_percentile": 0.54433}, "CVE-2020-35112": {"epss_score": 0.00532, "epss_percentile": 0.66696}, "CVE-2020-35113": {"epss_score": 0.00535, "epss_percentile": 0.66841}, "CVE-2020-35114": {"epss_score": 0.00434, "epss_percentile": 0.62292}, "CVE-2020-35121": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2020-35122": {"epss_score": 0.00226, "epss_percentile": 0.45243}, "CVE-2020-35123": {"epss_score": 0.00838, "epss_percentile": 0.74183}, "CVE-2020-35124": {"epss_score": 0.01142, "epss_percentile": 0.77976}, "CVE-2020-35125": {"epss_score": 0.01246, "epss_percentile": 0.78847}, "CVE-2020-35126": {"epss_score": 0.00207, "epss_percentile": 0.4309}, "CVE-2020-35127": {"epss_score": 0.00319, "epss_percentile": 0.54569}, "CVE-2020-35128": {"epss_score": 0.00651, "epss_percentile": 0.70288}, "CVE-2020-35129": {"epss_score": 0.00617, "epss_percentile": 0.69342}, "CVE-2020-35131": {"epss_score": 0.91149, "epss_percentile": 0.99623}, "CVE-2020-35132": {"epss_score": 0.00523, "epss_percentile": 0.6631}, "CVE-2020-35133": {"epss_score": 0.00562, "epss_percentile": 0.67704}, "CVE-2020-35135": {"epss_score": 0.00287, "epss_percentile": 0.51806}, "CVE-2020-35136": {"epss_score": 0.06993, "epss_percentile": 0.91169}, "CVE-2020-35137": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2020-35138": {"epss_score": 0.00217, "epss_percentile": 0.44309}, "CVE-2020-35139": {"epss_score": 0.00193, "epss_percentile": 0.4146}, "CVE-2020-35141": {"epss_score": 0.00193, "epss_percentile": 0.4146}, "CVE-2020-35145": {"epss_score": 0.00053, "epss_percentile": 0.16694}, "CVE-2020-35149": {"epss_score": 0.00259, "epss_percentile": 0.49032}, "CVE-2020-35151": {"epss_score": 0.0018, "epss_percentile": 0.39893}, "CVE-2020-35152": {"epss_score": 0.00054, "epss_percentile": 0.1723}, "CVE-2020-35163": {"epss_score": 0.0072, "epss_percentile": 0.71955}, "CVE-2020-35164": {"epss_score": 0.00655, "epss_percentile": 0.70422}, "CVE-2020-35165": {"epss_score": 0.00184, "epss_percentile": 0.40444}, "CVE-2020-35166": {"epss_score": 0.00483, "epss_percentile": 0.64576}, "CVE-2020-35167": {"epss_score": 0.00736, "epss_percentile": 0.72311}, "CVE-2020-35168": {"epss_score": 0.00145, "epss_percentile": 0.35498}, "CVE-2020-35169": {"epss_score": 0.00209, "epss_percentile": 0.43404}, "CVE-2020-35170": {"epss_score": 0.00287, "epss_percentile": 0.51812}, "CVE-2020-35173": {"epss_score": 0.00528, "epss_percentile": 0.66577}, "CVE-2020-35175": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-35176": {"epss_score": 0.01565, "epss_percentile": 0.81065}, "CVE-2020-35177": {"epss_score": 0.00395, "epss_percentile": 0.59833}, "CVE-2020-35184": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35185": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35186": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35187": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35189": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35190": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35191": {"epss_score": 0.20358, "epss_percentile": 0.95332}, "CVE-2020-35192": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35193": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35195": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35196": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35197": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35198": {"epss_score": 0.02426, "epss_percentile": 0.84717}, "CVE-2020-35199": {"epss_score": 0.00169, "epss_percentile": 0.38532}, "CVE-2020-35200": {"epss_score": 0.0084, "epss_percentile": 0.74213}, "CVE-2020-35201": {"epss_score": 0.00169, "epss_percentile": 0.38532}, "CVE-2020-35202": {"epss_score": 0.00169, "epss_percentile": 0.38532}, "CVE-2020-35203": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-35204": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-35205": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2020-35206": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-35207": {"epss_score": 0.00046, "epss_percentile": 0.14078}, "CVE-2020-35208": {"epss_score": 0.00046, "epss_percentile": 0.14078}, "CVE-2020-35209": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-35210": {"epss_score": 0.00308, "epss_percentile": 0.53623}, "CVE-2020-35211": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2020-35213": {"epss_score": 0.00365, "epss_percentile": 0.57961}, "CVE-2020-35214": {"epss_score": 0.00229, "epss_percentile": 0.45559}, "CVE-2020-35215": {"epss_score": 0.00288, "epss_percentile": 0.51882}, "CVE-2020-35216": {"epss_score": 0.00416, "epss_percentile": 0.61162}, "CVE-2020-35217": {"epss_score": 0.00154, "epss_percentile": 0.36713}, "CVE-2020-35219": {"epss_score": 0.00365, "epss_percentile": 0.57999}, "CVE-2020-35221": {"epss_score": 0.00044, "epss_percentile": 0.13462}, "CVE-2020-35223": {"epss_score": 0.00142, "epss_percentile": 0.34977}, "CVE-2020-35224": {"epss_score": 0.00674, "epss_percentile": 0.70849}, "CVE-2020-35225": {"epss_score": 0.00126, "epss_percentile": 0.32631}, "CVE-2020-35226": {"epss_score": 0.00487, "epss_percentile": 0.64806}, "CVE-2020-35227": {"epss_score": 0.00565, "epss_percentile": 0.678}, "CVE-2020-35228": {"epss_score": 0.00174, "epss_percentile": 0.39204}, "CVE-2020-35229": {"epss_score": 0.00127, "epss_percentile": 0.32841}, "CVE-2020-35230": {"epss_score": 0.00134, "epss_percentile": 0.33899}, "CVE-2020-35231": {"epss_score": 0.00129, "epss_percentile": 0.33133}, "CVE-2020-35233": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-35234": {"epss_score": 0.77656, "epss_percentile": 0.98945}, "CVE-2020-35235": {"epss_score": 0.08993, "epss_percentile": 0.92356}, "CVE-2020-35236": {"epss_score": 0.00383, "epss_percentile": 0.59086}, "CVE-2020-35239": {"epss_score": 0.00084, "epss_percentile": 0.24855}, "CVE-2020-35240": {"epss_score": 0.00441, "epss_percentile": 0.6267}, "CVE-2020-35241": {"epss_score": 0.00154, "epss_percentile": 0.36738}, "CVE-2020-35242": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-35243": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-35244": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-35245": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-35249": {"epss_score": 0.00562, "epss_percentile": 0.67702}, "CVE-2020-35252": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2020-35261": {"epss_score": 0.00361, "epss_percentile": 0.5774}, "CVE-2020-35262": {"epss_score": 0.00692, "epss_percentile": 0.71287}, "CVE-2020-35263": {"epss_score": 0.0076, "epss_percentile": 0.72813}, "CVE-2020-35269": {"epss_score": 0.02936, "epss_percentile": 0.86025}, "CVE-2020-35270": {"epss_score": 0.00244, "epss_percentile": 0.47559}, "CVE-2020-35271": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2020-35272": {"epss_score": 0.00207, "epss_percentile": 0.4309}, "CVE-2020-35273": {"epss_score": 0.00163, "epss_percentile": 0.37844}, "CVE-2020-35274": {"epss_score": 0.00207, "epss_percentile": 0.4309}, "CVE-2020-35275": {"epss_score": 0.00432, "epss_percentile": 0.62115}, "CVE-2020-35276": {"epss_score": 0.00316, "epss_percentile": 0.54231}, "CVE-2020-35284": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2020-35296": {"epss_score": 0.01102, "epss_percentile": 0.77578}, "CVE-2020-35305": {"epss_score": 0.00312, "epss_percentile": 0.53953}, "CVE-2020-35308": {"epss_score": 0.00944, "epss_percentile": 0.75788}, "CVE-2020-35309": {"epss_score": 0.00155, "epss_percentile": 0.36779}, "CVE-2020-35313": {"epss_score": 0.13088, "epss_percentile": 0.9387}, "CVE-2020-35314": {"epss_score": 0.39573, "epss_percentile": 0.97168}, "CVE-2020-35326": {"epss_score": 0.02196, "epss_percentile": 0.83956}, "CVE-2020-35327": {"epss_score": 0.00267, "epss_percentile": 0.49986}, "CVE-2020-35328": {"epss_score": 0.00163, "epss_percentile": 0.37805}, "CVE-2020-35329": {"epss_score": 0.00296, "epss_percentile": 0.5259}, "CVE-2020-35337": {"epss_score": 0.00527, "epss_percentile": 0.66468}, "CVE-2020-35338": {"epss_score": 0.79871, "epss_percentile": 0.99058}, "CVE-2020-35339": {"epss_score": 0.13017, "epss_percentile": 0.93846}, "CVE-2020-35340": {"epss_score": 0.00342, "epss_percentile": 0.56377}, "CVE-2020-35342": {"epss_score": 0.00109, "epss_percentile": 0.29907}, "CVE-2020-35346": {"epss_score": 0.00171, "epss_percentile": 0.38899}, "CVE-2020-35347": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2020-35349": {"epss_score": 0.00207, "epss_percentile": 0.4309}, "CVE-2020-35357": {"epss_score": 0.00201, "epss_percentile": 0.42324}, "CVE-2020-35358": {"epss_score": 0.01477, "epss_percentile": 0.80544}, "CVE-2020-35359": {"epss_score": 0.08638, "epss_percentile": 0.92167}, "CVE-2020-35362": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2020-35364": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35370": {"epss_score": 0.05529, "epss_percentile": 0.89964}, "CVE-2020-35373": {"epss_score": 0.00489, "epss_percentile": 0.64907}, "CVE-2020-35376": {"epss_score": 0.00454, "epss_percentile": 0.63256}, "CVE-2020-35378": {"epss_score": 0.00537, "epss_percentile": 0.66901}, "CVE-2020-35380": {"epss_score": 0.00471, "epss_percentile": 0.64009}, "CVE-2020-35381": {"epss_score": 0.00426, "epss_percentile": 0.61766}, "CVE-2020-35382": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2020-35388": {"epss_score": 0.00528, "epss_percentile": 0.66571}, "CVE-2020-35391": {"epss_score": 0.4627, "epss_percentile": 0.97539}, "CVE-2020-35395": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2020-35396": {"epss_score": 0.00509, "epss_percentile": 0.65739}, "CVE-2020-35398": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2020-35416": {"epss_score": 0.02201, "epss_percentile": 0.83981}, "CVE-2020-35418": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2020-35419": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2020-35427": {"epss_score": 0.01118, "epss_percentile": 0.77745}, "CVE-2020-35430": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2020-35437": {"epss_score": 0.00311, "epss_percentile": 0.53852}, "CVE-2020-35438": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-35441": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-35442": {"epss_score": 0.00806, "epss_percentile": 0.73665}, "CVE-2020-35448": {"epss_score": 0.00132, "epss_percentile": 0.336}, "CVE-2020-35450": {"epss_score": 0.00367, "epss_percentile": 0.58112}, "CVE-2020-35451": {"epss_score": 0.00096, "epss_percentile": 0.27285}, "CVE-2020-35452": {"epss_score": 0.13393, "epss_percentile": 0.93951}, "CVE-2020-35453": {"epss_score": 0.00328, "epss_percentile": 0.55293}, "CVE-2020-35454": {"epss_score": 0.00028, "epss_percentile": 0.07253}, "CVE-2020-35455": {"epss_score": 0.00025, "epss_percentile": 0.0626}, "CVE-2020-35456": {"epss_score": 0.00104, "epss_percentile": 0.29104}, "CVE-2020-35457": {"epss_score": 0.0019, "epss_percentile": 0.41051}, "CVE-2020-35458": {"epss_score": 0.12988, "epss_percentile": 0.93836}, "CVE-2020-35459": {"epss_score": 0.00045, "epss_percentile": 0.14055}, "CVE-2020-35460": {"epss_score": 0.00646, "epss_percentile": 0.70137}, "CVE-2020-35462": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35463": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35464": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35466": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35467": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35468": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35469": {"epss_score": 0.02014, "epss_percentile": 0.83268}, "CVE-2020-35470": {"epss_score": 0.00781, "epss_percentile": 0.73192}, "CVE-2020-35471": {"epss_score": 0.00069, "epss_percentile": 0.21546}, "CVE-2020-35473": {"epss_score": 0.00144, "epss_percentile": 0.35311}, "CVE-2020-35474": {"epss_score": 0.00468, "epss_percentile": 0.63871}, "CVE-2020-35475": {"epss_score": 0.00592, "epss_percentile": 0.68618}, "CVE-2020-35476": {"epss_score": 0.9425, "epss_percentile": 0.99926}, "CVE-2020-35477": {"epss_score": 0.00474, "epss_percentile": 0.64141}, "CVE-2020-35478": {"epss_score": 0.00446, "epss_percentile": 0.62893}, "CVE-2020-35479": {"epss_score": 0.0086, "epss_percentile": 0.74524}, "CVE-2020-35480": {"epss_score": 0.00344, "epss_percentile": 0.56534}, "CVE-2020-35481": {"epss_score": 0.04459, "epss_percentile": 0.88718}, "CVE-2020-35482": {"epss_score": 0.04259, "epss_percentile": 0.88461}, "CVE-2020-35483": {"epss_score": 0.00054, "epss_percentile": 0.17175}, "CVE-2020-35488": {"epss_score": 0.19392, "epss_percentile": 0.95176}, "CVE-2020-35489": {"epss_score": 0.90113, "epss_percentile": 0.99561}, "CVE-2020-35490": {"epss_score": 0.03916, "epss_percentile": 0.87948}, "CVE-2020-35491": {"epss_score": 0.05713, "epss_percentile": 0.90144}, "CVE-2020-35492": {"epss_score": 0.00093, "epss_percentile": 0.26651}, "CVE-2020-35493": {"epss_score": 0.00227, "epss_percentile": 0.45452}, "CVE-2020-35494": {"epss_score": 0.00113, "epss_percentile": 0.30594}, "CVE-2020-35495": {"epss_score": 0.00119, "epss_percentile": 0.31648}, "CVE-2020-35496": {"epss_score": 0.00205, "epss_percentile": 0.4275}, "CVE-2020-35497": {"epss_score": 0.00317, "epss_percentile": 0.54327}, "CVE-2020-35498": {"epss_score": 0.05765, "epss_percentile": 0.90188}, "CVE-2020-35499": {"epss_score": 0.00121, "epss_percentile": 0.31823}, "CVE-2020-35501": {"epss_score": 0.00088, "epss_percentile": 0.25752}, "CVE-2020-35502": {"epss_score": 0.00638, "epss_percentile": 0.69919}, "CVE-2020-35503": {"epss_score": 0.00024, "epss_percentile": 0.05858}, "CVE-2020-35504": {"epss_score": 0.00015, "epss_percentile": 0.02336}, "CVE-2020-35505": {"epss_score": 0.00017, "epss_percentile": 0.03434}, "CVE-2020-35506": {"epss_score": 0.0003, "epss_percentile": 0.08181}, "CVE-2020-35507": {"epss_score": 0.00205, "epss_percentile": 0.4275}, "CVE-2020-35508": {"epss_score": 0.00053, "epss_percentile": 0.16731}, "CVE-2020-35509": {"epss_score": 0.00087, "epss_percentile": 0.2554}, "CVE-2020-35510": {"epss_score": 0.00195, "epss_percentile": 0.41646}, "CVE-2020-35511": {"epss_score": 0.00048, "epss_percentile": 0.14947}, "CVE-2020-35512": {"epss_score": 0.00034, "epss_percentile": 0.09469}, "CVE-2020-35513": {"epss_score": 0.00317, "epss_percentile": 0.54348}, "CVE-2020-35514": {"epss_score": 0.00041, "epss_percentile": 0.12413}, "CVE-2020-35517": {"epss_score": 0.00084, "epss_percentile": 0.24856}, "CVE-2020-35518": {"epss_score": 0.00801, "epss_percentile": 0.73562}, "CVE-2020-35519": {"epss_score": 0.00169, "epss_percentile": 0.38558}, "CVE-2020-35521": {"epss_score": 0.00098, "epss_percentile": 0.27728}, "CVE-2020-35522": {"epss_score": 0.00036, "epss_percentile": 0.10539}, "CVE-2020-35523": {"epss_score": 0.00255, "epss_percentile": 0.48663}, "CVE-2020-35524": {"epss_score": 0.00413, "epss_percentile": 0.61011}, "CVE-2020-35525": {"epss_score": 0.00248, "epss_percentile": 0.47953}, "CVE-2020-35527": {"epss_score": 0.00293, "epss_percentile": 0.52288}, "CVE-2020-35530": {"epss_score": 0.00091, "epss_percentile": 0.26378}, "CVE-2020-35531": {"epss_score": 0.00091, "epss_percentile": 0.26378}, "CVE-2020-35532": {"epss_score": 0.00091, "epss_percentile": 0.26378}, "CVE-2020-35533": {"epss_score": 0.00091, "epss_percentile": 0.26378}, "CVE-2020-35534": {"epss_score": 0.00155, "epss_percentile": 0.36797}, "CVE-2020-35535": {"epss_score": 0.00047, "epss_percentile": 0.14887}, "CVE-2020-35538": {"epss_score": 0.00024, "epss_percentile": 0.05664}, "CVE-2020-35542": {"epss_score": 0.00272, "epss_percentile": 0.50417}, "CVE-2020-35545": {"epss_score": 0.0841, "epss_percentile": 0.92036}, "CVE-2020-35546": {"epss_score": 0.0011, "epss_percentile": 0.3011}, "CVE-2020-35547": {"epss_score": 0.00367, "epss_percentile": 0.58101}, "CVE-2020-35548": {"epss_score": 0.00016, "epss_percentile": 0.02625}, "CVE-2020-35549": {"epss_score": 0.00018, "epss_percentile": 0.03704}, "CVE-2020-35550": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2020-35551": {"epss_score": 0.00129, "epss_percentile": 0.33211}, "CVE-2020-35552": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2020-35553": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2020-35554": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2020-35555": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2020-35556": {"epss_score": 0.00291, "epss_percentile": 0.52156}, "CVE-2020-35557": {"epss_score": 0.00257, "epss_percentile": 0.4891}, "CVE-2020-35558": {"epss_score": 0.00298, "epss_percentile": 0.52785}, "CVE-2020-35559": {"epss_score": 0.00362, "epss_percentile": 0.578}, "CVE-2020-35560": {"epss_score": 0.00197, "epss_percentile": 0.41931}, "CVE-2020-35561": {"epss_score": 0.00796, "epss_percentile": 0.73479}, "CVE-2020-35563": {"epss_score": 0.00272, "epss_percentile": 0.50417}, "CVE-2020-35564": {"epss_score": 0.00283, "epss_percentile": 0.51407}, "CVE-2020-35565": {"epss_score": 0.00307, "epss_percentile": 0.53494}, "CVE-2020-35566": {"epss_score": 0.00238, "epss_percentile": 0.46836}, "CVE-2020-35567": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2020-35568": {"epss_score": 0.00294, "epss_percentile": 0.52398}, "CVE-2020-35569": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2020-35570": {"epss_score": 0.00796, "epss_percentile": 0.73479}, "CVE-2020-35571": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2020-35572": {"epss_score": 0.05146, "epss_percentile": 0.89543}, "CVE-2020-35573": {"epss_score": 0.01711, "epss_percentile": 0.81881}, "CVE-2020-35575": {"epss_score": 0.18786, "epss_percentile": 0.95069}, "CVE-2020-35576": {"epss_score": 0.71232, "epss_percentile": 0.9866}, "CVE-2020-35577": {"epss_score": 0.00887, "epss_percentile": 0.74973}, "CVE-2020-35578": {"epss_score": 0.90441, "epss_percentile": 0.99583}, "CVE-2020-35579": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2020-35580": {"epss_score": 0.80044, "epss_percentile": 0.99068}, "CVE-2020-35581": {"epss_score": 0.00483, "epss_percentile": 0.64612}, "CVE-2020-35582": {"epss_score": 0.00483, "epss_percentile": 0.64612}, "CVE-2020-35584": {"epss_score": 0.00176, "epss_percentile": 0.39396}, "CVE-2020-35585": {"epss_score": 0.00343, "epss_percentile": 0.5643}, "CVE-2020-35586": {"epss_score": 0.00343, "epss_percentile": 0.5643}, "CVE-2020-35587": {"epss_score": 0.00715, "epss_percentile": 0.71833}, "CVE-2020-35589": {"epss_score": 0.00178, "epss_percentile": 0.39652}, "CVE-2020-35590": {"epss_score": 0.4285, "epss_percentile": 0.97358}, "CVE-2020-35591": {"epss_score": 0.00184, "epss_percentile": 0.40416}, "CVE-2020-35592": {"epss_score": 0.00177, "epss_percentile": 0.39512}, "CVE-2020-35593": {"epss_score": 0.00032, "epss_percentile": 0.0874}, "CVE-2020-35594": {"epss_score": 0.0387, "epss_percentile": 0.8788}, "CVE-2020-35597": {"epss_score": 0.00946, "epss_percentile": 0.75808}, "CVE-2020-35598": {"epss_score": 0.74425, "epss_percentile": 0.98799}, "CVE-2020-35604": {"epss_score": 0.00455, "epss_percentile": 0.63311}, "CVE-2020-35605": {"epss_score": 0.05524, "epss_percentile": 0.89961}, "CVE-2020-35606": {"epss_score": 0.78779, "epss_percentile": 0.99002}, "CVE-2020-35608": {"epss_score": 0.00242, "epss_percentile": 0.47336}, "CVE-2020-35609": {"epss_score": 0.00166, "epss_percentile": 0.38185}, "CVE-2020-35610": {"epss_score": 8e-05, "epss_percentile": 0.00518}, "CVE-2020-35611": {"epss_score": 0.00012, "epss_percentile": 0.01243}, "CVE-2020-35612": {"epss_score": 0.00013, "epss_percentile": 0.01453}, "CVE-2020-35613": {"epss_score": 0.01016, "epss_percentile": 0.76671}, "CVE-2020-35614": {"epss_score": 6e-05, "epss_percentile": 0.00318}, "CVE-2020-35615": {"epss_score": 4e-05, "epss_percentile": 0.00143}, "CVE-2020-35616": {"epss_score": 0.0001, "epss_percentile": 0.00814}, "CVE-2020-35622": {"epss_score": 0.00174, "epss_percentile": 0.39152}, "CVE-2020-35623": {"epss_score": 0.00182, "epss_percentile": 0.40267}, "CVE-2020-35624": {"epss_score": 0.00172, "epss_percentile": 0.39035}, "CVE-2020-35625": {"epss_score": 0.00229, "epss_percentile": 0.45605}, "CVE-2020-35626": {"epss_score": 0.0011, "epss_percentile": 0.30128}, "CVE-2020-35627": {"epss_score": 0.00706, "epss_percentile": 0.71609}, "CVE-2020-35628": {"epss_score": 0.00693, "epss_percentile": 0.71332}, "CVE-2020-35629": {"epss_score": 0.00416, "epss_percentile": 0.61187}, "CVE-2020-35630": {"epss_score": 0.00499, "epss_percentile": 0.65281}, "CVE-2020-35631": {"epss_score": 0.00325, "epss_percentile": 0.54985}, "CVE-2020-35632": {"epss_score": 0.00287, "epss_percentile": 0.51818}, "CVE-2020-35633": {"epss_score": 0.00213, "epss_percentile": 0.43879}, "CVE-2020-35634": {"epss_score": 0.00213, "epss_percentile": 0.43879}, "CVE-2020-35635": {"epss_score": 0.00331, "epss_percentile": 0.55524}, "CVE-2020-35636": {"epss_score": 0.00156, "epss_percentile": 0.36892}, "CVE-2020-35650": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2020-35652": {"epss_score": 0.00114, "epss_percentile": 0.30786}, "CVE-2020-35653": {"epss_score": 0.00293, "epss_percentile": 0.52315}, "CVE-2020-35654": {"epss_score": 0.00199, "epss_percentile": 0.42184}, "CVE-2020-35655": {"epss_score": 0.00269, "epss_percentile": 0.50154}, "CVE-2020-35656": {"epss_score": 0.02628, "epss_percentile": 0.85273}, "CVE-2020-35657": {"epss_score": 0.02847, "epss_percentile": 0.85823}, "CVE-2020-35658": {"epss_score": 0.00113, "epss_percentile": 0.3062}, "CVE-2020-35659": {"epss_score": 0.0045, "epss_percentile": 0.631}, "CVE-2020-35660": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2020-35662": {"epss_score": 0.0075, "epss_percentile": 0.72618}, "CVE-2020-35664": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2020-35665": {"epss_score": 0.89253, "epss_percentile": 0.99517}, "CVE-2020-35666": {"epss_score": 0.00421, "epss_percentile": 0.61493}, "CVE-2020-35667": {"epss_score": 4e-05, "epss_percentile": 0.00125}, "CVE-2020-35668": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2020-35669": {"epss_score": 0.25314, "epss_percentile": 0.96011}, "CVE-2020-35674": {"epss_score": 0.0127, "epss_percentile": 0.79049}, "CVE-2020-35675": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2020-35676": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-35677": {"epss_score": 0.0011, "epss_percentile": 0.30196}, "CVE-2020-35678": {"epss_score": 0.00294, "epss_percentile": 0.52384}, "CVE-2020-35679": {"epss_score": 0.01705, "epss_percentile": 0.81852}, "CVE-2020-35680": {"epss_score": 0.04225, "epss_percentile": 0.88415}, "CVE-2020-35681": {"epss_score": 0.008, "epss_percentile": 0.73543}, "CVE-2020-35682": {"epss_score": 0.01719, "epss_percentile": 0.81927}, "CVE-2020-35683": {"epss_score": 0.00534, "epss_percentile": 0.66798}, "CVE-2020-35684": {"epss_score": 0.00698, "epss_percentile": 0.71419}, "CVE-2020-35685": {"epss_score": 0.00408, "epss_percentile": 0.60667}, "CVE-2020-35686": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2020-35687": {"epss_score": 0.00124, "epss_percentile": 0.3234}, "CVE-2020-35693": {"epss_score": 0.00044, "epss_percentile": 0.13496}, "CVE-2020-35698": {"epss_score": 0.00078, "epss_percentile": 0.23755}, "CVE-2020-35700": {"epss_score": 0.00091, "epss_percentile": 0.26287}, "CVE-2020-35701": {"epss_score": 0.02452, "epss_percentile": 0.8479}, "CVE-2020-35702": {"epss_score": 0.00438, "epss_percentile": 0.62567}, "CVE-2020-35704": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-35705": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-35706": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-35707": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-35708": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2020-35709": {"epss_score": 0.00753, "epss_percentile": 0.72676}, "CVE-2020-35710": {"epss_score": 0.00542, "epss_percentile": 0.67068}, "CVE-2020-35711": {"epss_score": 0.00328, "epss_percentile": 0.55183}, "CVE-2020-35712": {"epss_score": 0.00312, "epss_percentile": 0.53957}, "CVE-2020-35713": {"epss_score": 0.9275, "epss_percentile": 0.99742}, "CVE-2020-35714": {"epss_score": 0.03725, "epss_percentile": 0.87631}, "CVE-2020-35715": {"epss_score": 0.04045, "epss_percentile": 0.88171}, "CVE-2020-35716": {"epss_score": 0.01405, "epss_percentile": 0.8004}, "CVE-2020-35717": {"epss_score": 0.06143, "epss_percentile": 0.90515}, "CVE-2020-35719": {"epss_score": 0.00375, "epss_percentile": 0.58615}, "CVE-2020-35720": {"epss_score": 0.00242, "epss_percentile": 0.47374}, "CVE-2020-35721": {"epss_score": 0.00149, "epss_percentile": 0.36008}, "CVE-2020-35722": {"epss_score": 0.00183, "epss_percentile": 0.4034}, "CVE-2020-35723": {"epss_score": 0.00149, "epss_percentile": 0.36008}, "CVE-2020-35724": {"epss_score": 0.00149, "epss_percentile": 0.36008}, "CVE-2020-35725": {"epss_score": 0.00375, "epss_percentile": 0.58615}, "CVE-2020-35726": {"epss_score": 0.00375, "epss_percentile": 0.58615}, "CVE-2020-35727": {"epss_score": 0.00149, "epss_percentile": 0.36008}, "CVE-2020-35728": {"epss_score": 0.42315, "epss_percentile": 0.97325}, "CVE-2020-35729": {"epss_score": 0.90634, "epss_percentile": 0.99593}, "CVE-2020-35730": {"epss_score": 0.69032, "epss_percentile": 0.98574}, "CVE-2020-35733": {"epss_score": 0.0022, "epss_percentile": 0.44575}, "CVE-2020-35734": {"epss_score": 0.05156, "epss_percentile": 0.89553}, "CVE-2020-35735": {"epss_score": 0.00214, "epss_percentile": 0.4401}, "CVE-2020-35736": {"epss_score": 0.82358, "epss_percentile": 0.9919}, "CVE-2020-35737": {"epss_score": 0.18006, "epss_percentile": 0.94943}, "CVE-2020-35738": {"epss_score": 0.00408, "epss_percentile": 0.60626}, "CVE-2020-35740": {"epss_score": 0.00294, "epss_percentile": 0.52438}, "CVE-2020-35741": {"epss_score": 0.00294, "epss_percentile": 0.52438}, "CVE-2020-35742": {"epss_score": 0.00255, "epss_percentile": 0.48699}, "CVE-2020-35743": {"epss_score": 0.00255, "epss_percentile": 0.48699}, "CVE-2020-35745": {"epss_score": 0.00379, "epss_percentile": 0.58841}, "CVE-2020-35748": {"epss_score": 0.00122, "epss_percentile": 0.32151}, "CVE-2020-35749": {"epss_score": 0.76788, "epss_percentile": 0.98905}, "CVE-2020-35752": {"epss_score": 0.00227, "epss_percentile": 0.45417}, "CVE-2020-35753": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-35754": {"epss_score": 0.1883, "epss_percentile": 0.95079}, "CVE-2020-35755": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2020-35756": {"epss_score": 0.00432, "epss_percentile": 0.62134}, "CVE-2020-35757": {"epss_score": 0.02196, "epss_percentile": 0.83955}, "CVE-2020-35758": {"epss_score": 0.02035, "epss_percentile": 0.83348}, "CVE-2020-35759": {"epss_score": 0.00229, "epss_percentile": 0.45586}, "CVE-2020-35760": {"epss_score": 0.01344, "epss_percentile": 0.79612}, "CVE-2020-35761": {"epss_score": 0.00135, "epss_percentile": 0.34001}, "CVE-2020-35762": {"epss_score": 0.00258, "epss_percentile": 0.49001}, "CVE-2020-35765": {"epss_score": 0.01258, "epss_percentile": 0.78955}, "CVE-2020-35766": {"epss_score": 0.00144, "epss_percentile": 0.35227}, "CVE-2020-35769": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35773": {"epss_score": 0.00135, "epss_percentile": 0.34054}, "CVE-2020-35774": {"epss_score": 0.81158, "epss_percentile": 0.99125}, "CVE-2020-35775": {"epss_score": 0.26159, "epss_percentile": 0.96118}, "CVE-2020-35776": {"epss_score": 0.00081, "epss_percentile": 0.24258}, "CVE-2020-35777": {"epss_score": 0.00597, "epss_percentile": 0.68735}, "CVE-2020-35778": {"epss_score": 0.00177, "epss_percentile": 0.39595}, "CVE-2020-35779": {"epss_score": 0.0035, "epss_percentile": 0.56945}, "CVE-2020-35780": {"epss_score": 0.00372, "epss_percentile": 0.58452}, "CVE-2020-35781": {"epss_score": 0.00478, "epss_percentile": 0.64408}, "CVE-2020-35782": {"epss_score": 0.00518, "epss_percentile": 0.66107}, "CVE-2020-35783": {"epss_score": 0.00857, "epss_percentile": 0.74487}, "CVE-2020-35784": {"epss_score": 0.00309, "epss_percentile": 0.53671}, "CVE-2020-35785": {"epss_score": 0.00127, "epss_percentile": 0.32841}, "CVE-2020-35786": {"epss_score": 0.00344, "epss_percentile": 0.56493}, "CVE-2020-35787": {"epss_score": 0.00139, "epss_percentile": 0.34538}, "CVE-2020-35788": {"epss_score": 0.00142, "epss_percentile": 0.35033}, "CVE-2020-35789": {"epss_score": 0.00843, "epss_percentile": 0.74269}, "CVE-2020-35790": {"epss_score": 0.00164, "epss_percentile": 0.37947}, "CVE-2020-35791": {"epss_score": 0.00103, "epss_percentile": 0.29066}, "CVE-2020-35792": {"epss_score": 0.0052, "epss_percentile": 0.66211}, "CVE-2020-35793": {"epss_score": 0.00075, "epss_percentile": 0.23054}, "CVE-2020-35794": {"epss_score": 0.0052, "epss_percentile": 0.66211}, "CVE-2020-35795": {"epss_score": 0.00556, "epss_percentile": 0.67529}, "CVE-2020-35796": {"epss_score": 0.014, "epss_percentile": 0.80004}, "CVE-2020-35797": {"epss_score": 0.02562, "epss_percentile": 0.85106}, "CVE-2020-35798": {"epss_score": 0.00376, "epss_percentile": 0.58643}, "CVE-2020-35799": {"epss_score": 0.01543, "epss_percentile": 0.80956}, "CVE-2020-35800": {"epss_score": 0.01496, "epss_percentile": 0.80683}, "CVE-2020-35801": {"epss_score": 0.01697, "epss_percentile": 0.81819}, "CVE-2020-35802": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-35803": {"epss_score": 0.00058, "epss_percentile": 0.18373}, "CVE-2020-35804": {"epss_score": 0.00058, "epss_percentile": 0.18421}, "CVE-2020-35805": {"epss_score": 0.00457, "epss_percentile": 0.63365}, "CVE-2020-35806": {"epss_score": 0.00268, "epss_percentile": 0.50057}, "CVE-2020-35807": {"epss_score": 0.00204, "epss_percentile": 0.42633}, "CVE-2020-35808": {"epss_score": 0.00205, "epss_percentile": 0.42742}, "CVE-2020-35809": {"epss_score": 0.00262, "epss_percentile": 0.49338}, "CVE-2020-35810": {"epss_score": 0.00262, "epss_percentile": 0.49338}, "CVE-2020-35811": {"epss_score": 0.00404, "epss_percentile": 0.6044}, "CVE-2020-35812": {"epss_score": 0.00404, "epss_percentile": 0.6044}, "CVE-2020-35813": {"epss_score": 0.00264, "epss_percentile": 0.49575}, "CVE-2020-35814": {"epss_score": 0.00457, "epss_percentile": 0.63392}, "CVE-2020-35815": {"epss_score": 0.00457, "epss_percentile": 0.63365}, "CVE-2020-35816": {"epss_score": 0.00403, "epss_percentile": 0.60372}, "CVE-2020-35817": {"epss_score": 0.00384, "epss_percentile": 0.5915}, "CVE-2020-35818": {"epss_score": 0.00457, "epss_percentile": 0.63392}, "CVE-2020-35819": {"epss_score": 0.00507, "epss_percentile": 0.65656}, "CVE-2020-35820": {"epss_score": 0.00403, "epss_percentile": 0.60372}, "CVE-2020-35821": {"epss_score": 0.00404, "epss_percentile": 0.6044}, "CVE-2020-35822": {"epss_score": 0.00404, "epss_percentile": 0.6044}, "CVE-2020-35823": {"epss_score": 0.00403, "epss_percentile": 0.60372}, "CVE-2020-35824": {"epss_score": 0.00404, "epss_percentile": 0.6044}, "CVE-2020-35825": {"epss_score": 0.00262, "epss_percentile": 0.49338}, "CVE-2020-35826": {"epss_score": 0.00262, "epss_percentile": 0.49338}, "CVE-2020-35827": {"epss_score": 0.00404, "epss_percentile": 0.6044}, "CVE-2020-35828": {"epss_score": 0.00404, "epss_percentile": 0.6044}, "CVE-2020-35829": {"epss_score": 0.00403, "epss_percentile": 0.60372}, "CVE-2020-35830": {"epss_score": 0.0026, "epss_percentile": 0.49176}, "CVE-2020-35831": {"epss_score": 0.00275, "epss_percentile": 0.50683}, "CVE-2020-35832": {"epss_score": 0.00404, "epss_percentile": 0.6044}, "CVE-2020-35833": {"epss_score": 0.00403, "epss_percentile": 0.60372}, "CVE-2020-35834": {"epss_score": 0.00403, "epss_percentile": 0.60372}, "CVE-2020-35835": {"epss_score": 0.00403, "epss_percentile": 0.60372}, "CVE-2020-35836": {"epss_score": 0.00403, "epss_percentile": 0.60372}, "CVE-2020-35837": {"epss_score": 0.00142, "epss_percentile": 0.34986}, "CVE-2020-35838": {"epss_score": 0.00457, "epss_percentile": 0.63365}, "CVE-2020-35839": {"epss_score": 0.00424, "epss_percentile": 0.6167}, "CVE-2020-35840": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-35841": {"epss_score": 0.00344, "epss_percentile": 0.56474}, "CVE-2020-35842": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-35843": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2020-35844": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2020-35845": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2020-35846": {"epss_score": 0.93533, "epss_percentile": 0.99816}, "CVE-2020-35847": {"epss_score": 0.9391, "epss_percentile": 0.99867}, "CVE-2020-35848": {"epss_score": 0.92681, "epss_percentile": 0.99734}, "CVE-2020-35849": {"epss_score": 0.00762, "epss_percentile": 0.72849}, "CVE-2020-35850": {"epss_score": 0.00447, "epss_percentile": 0.62963}, "CVE-2020-35851": {"epss_score": 0.00767, "epss_percentile": 0.7296}, "CVE-2020-35852": {"epss_score": 0.00255, "epss_percentile": 0.48713}, "CVE-2020-35853": {"epss_score": 0.00207, "epss_percentile": 0.4309}, "CVE-2020-35854": {"epss_score": 0.00295, "epss_percentile": 0.52494}, "CVE-2020-35856": {"epss_score": 0.01023, "epss_percentile": 0.76775}, "CVE-2020-35857": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-35858": {"epss_score": 0.02484, "epss_percentile": 0.84883}, "CVE-2020-35859": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35860": {"epss_score": 0.00372, "epss_percentile": 0.58439}, "CVE-2020-35861": {"epss_score": 0.00285, "epss_percentile": 0.51522}, "CVE-2020-35862": {"epss_score": 0.00509, "epss_percentile": 0.65724}, "CVE-2020-35863": {"epss_score": 0.02006, "epss_percentile": 0.83234}, "CVE-2020-35864": {"epss_score": 0.00167, "epss_percentile": 0.38291}, "CVE-2020-35865": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-35866": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35867": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35868": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35869": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35870": {"epss_score": 0.00509, "epss_percentile": 0.65724}, "CVE-2020-35871": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-35872": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35873": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2020-35874": {"epss_score": 0.00394, "epss_percentile": 0.59775}, "CVE-2020-35875": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-35876": {"epss_score": 0.00509, "epss_percentile": 0.65724}, "CVE-2020-35877": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35878": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35879": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35880": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35881": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35882": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-35883": {"epss_score": 0.00417, "epss_percentile": 0.61234}, "CVE-2020-35884": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2020-35885": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35886": {"epss_score": 0.00042, "epss_percentile": 0.12589}, "CVE-2020-35887": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2020-35888": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35889": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-35890": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-35891": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-35892": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35893": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-35894": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2020-35895": {"epss_score": 0.00632, "epss_percentile": 0.69741}, "CVE-2020-35896": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-35897": {"epss_score": 0.00042, "epss_percentile": 0.12589}, "CVE-2020-35898": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-35899": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2020-35900": {"epss_score": 0.00062, "epss_percentile": 0.19559}, "CVE-2020-35901": {"epss_score": 0.00393, "epss_percentile": 0.59709}, "CVE-2020-35902": {"epss_score": 0.00509, "epss_percentile": 0.65724}, "CVE-2020-35903": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2020-35904": {"epss_score": 0.00057, "epss_percentile": 0.17971}, "CVE-2020-35905": {"epss_score": 0.0005, "epss_percentile": 0.15708}, "CVE-2020-35906": {"epss_score": 0.00055, "epss_percentile": 0.17438}, "CVE-2020-35907": {"epss_score": 0.00054, "epss_percentile": 0.17283}, "CVE-2020-35908": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2020-35909": {"epss_score": 0.00383, "epss_percentile": 0.59087}, "CVE-2020-35910": {"epss_score": 0.00057, "epss_percentile": 0.17971}, "CVE-2020-35911": {"epss_score": 0.00044, "epss_percentile": 0.1345}, "CVE-2020-35912": {"epss_score": 0.00044, "epss_percentile": 0.1345}, "CVE-2020-35913": {"epss_score": 0.00042, "epss_percentile": 0.12748}, "CVE-2020-35914": {"epss_score": 0.00044, "epss_percentile": 0.1345}, "CVE-2020-35915": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2020-35916": {"epss_score": 0.00054, "epss_percentile": 0.17283}, "CVE-2020-35917": {"epss_score": 0.00063, "epss_percentile": 0.19958}, "CVE-2020-35918": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2020-35919": {"epss_score": 0.00054, "epss_percentile": 0.17283}, "CVE-2020-35920": {"epss_score": 0.00057, "epss_percentile": 0.17971}, "CVE-2020-35921": {"epss_score": 0.00057, "epss_percentile": 0.17971}, "CVE-2020-35922": {"epss_score": 0.00075, "epss_percentile": 0.22928}, "CVE-2020-35923": {"epss_score": 0.00135, "epss_percentile": 0.33947}, "CVE-2020-35924": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2020-35925": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2020-35926": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-35927": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2020-35928": {"epss_score": 0.00042, "epss_percentile": 0.12589}, "CVE-2020-35929": {"epss_score": 0.00364, "epss_percentile": 0.57942}, "CVE-2020-35930": {"epss_score": 0.0039, "epss_percentile": 0.59549}, "CVE-2020-35931": {"epss_score": 0.00087, "epss_percentile": 0.25453}, "CVE-2020-35932": {"epss_score": 0.0098, "epss_percentile": 0.76266}, "CVE-2020-35933": {"epss_score": 0.00121, "epss_percentile": 0.31957}, "CVE-2020-35934": {"epss_score": 0.00328, "epss_percentile": 0.55269}, "CVE-2020-35935": {"epss_score": 0.00373, "epss_percentile": 0.58469}, "CVE-2020-35936": {"epss_score": 0.01319, "epss_percentile": 0.79433}, "CVE-2020-35937": {"epss_score": 0.01377, "epss_percentile": 0.79841}, "CVE-2020-35938": {"epss_score": 0.01341, "epss_percentile": 0.79582}, "CVE-2020-35939": {"epss_score": 0.01399, "epss_percentile": 0.79997}, "CVE-2020-35942": {"epss_score": 0.00311, "epss_percentile": 0.53919}, "CVE-2020-35943": {"epss_score": 0.0011, "epss_percentile": 0.30204}, "CVE-2020-35944": {"epss_score": 0.00209, "epss_percentile": 0.43325}, "CVE-2020-35945": {"epss_score": 0.02232, "epss_percentile": 0.84089}, "CVE-2020-35946": {"epss_score": 0.00133, "epss_percentile": 0.33703}, "CVE-2020-35947": {"epss_score": 0.00539, "epss_percentile": 0.66974}, "CVE-2020-35948": {"epss_score": 0.51632, "epss_percentile": 0.9779}, "CVE-2020-35949": {"epss_score": 0.13311, "epss_percentile": 0.93928}, "CVE-2020-35950": {"epss_score": 0.00244, "epss_percentile": 0.47551}, "CVE-2020-35951": {"epss_score": 0.58661, "epss_percentile": 0.9813}, "CVE-2020-35952": {"epss_score": 0.00288, "epss_percentile": 0.51882}, "CVE-2020-35962": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2020-35963": {"epss_score": 0.00376, "epss_percentile": 0.58659}, "CVE-2020-35964": {"epss_score": 0.00528, "epss_percentile": 0.66546}, "CVE-2020-35965": {"epss_score": 0.01621, "epss_percentile": 0.81392}, "CVE-2020-35970": {"epss_score": 0.00773, "epss_percentile": 0.73058}, "CVE-2020-35971": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2020-35972": {"epss_score": 0.00141, "epss_percentile": 0.34841}, "CVE-2020-35973": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-35979": {"epss_score": 0.00275, "epss_percentile": 0.50653}, "CVE-2020-35980": {"epss_score": 0.00133, "epss_percentile": 0.33723}, "CVE-2020-35981": {"epss_score": 0.0028, "epss_percentile": 0.51095}, "CVE-2020-35982": {"epss_score": 0.0028, "epss_percentile": 0.51095}, "CVE-2020-35984": {"epss_score": 0.01648, "epss_percentile": 0.81545}, "CVE-2020-35985": {"epss_score": 0.05134, "epss_percentile": 0.89534}, "CVE-2020-35986": {"epss_score": 0.01614, "epss_percentile": 0.81346}, "CVE-2020-35987": {"epss_score": 0.03657, "epss_percentile": 0.87519}, "CVE-2020-35990": {"epss_score": 0.00028, "epss_percentile": 0.07254}, "CVE-2020-35992": {"epss_score": 0.00214, "epss_percentile": 0.4401}, "CVE-2020-36002": {"epss_score": 0.00317, "epss_percentile": 0.54315}, "CVE-2020-36003": {"epss_score": 0.00323, "epss_percentile": 0.54867}, "CVE-2020-36004": {"epss_score": 0.00217, "epss_percentile": 0.44285}, "CVE-2020-36005": {"epss_score": 0.00339, "epss_percentile": 0.56207}, "CVE-2020-36006": {"epss_score": 0.00339, "epss_percentile": 0.56207}, "CVE-2020-36007": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2020-36008": {"epss_score": 0.00308, "epss_percentile": 0.53623}, "CVE-2020-36009": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-36011": {"epss_score": 0.00162, "epss_percentile": 0.37618}, "CVE-2020-36012": {"epss_score": 0.00295, "epss_percentile": 0.52494}, "CVE-2020-36023": {"epss_score": 0.00068, "epss_percentile": 0.21333}, "CVE-2020-36024": {"epss_score": 0.00095, "epss_percentile": 0.27118}, "CVE-2020-36033": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-36034": {"epss_score": 0.011, "epss_percentile": 0.77569}, "CVE-2020-36037": {"epss_score": 0.00315, "epss_percentile": 0.54198}, "CVE-2020-36048": {"epss_score": 0.00797, "epss_percentile": 0.7349}, "CVE-2020-36049": {"epss_score": 0.00528, "epss_percentile": 0.66546}, "CVE-2020-36051": {"epss_score": 0.00426, "epss_percentile": 0.61752}, "CVE-2020-36052": {"epss_score": 0.01695, "epss_percentile": 0.81807}, "CVE-2020-36056": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-36062": {"epss_score": 0.00892, "epss_percentile": 0.75061}, "CVE-2020-36064": {"epss_score": 0.00446, "epss_percentile": 0.62918}, "CVE-2020-36065": {"epss_score": 0.0007, "epss_percentile": 0.2198}, "CVE-2020-36066": {"epss_score": 0.00095, "epss_percentile": 0.27091}, "CVE-2020-36067": {"epss_score": 0.00471, "epss_percentile": 0.64009}, "CVE-2020-36070": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2020-36071": {"epss_score": 0.02245, "epss_percentile": 0.84129}, "CVE-2020-36072": {"epss_score": 0.02245, "epss_percentile": 0.84129}, "CVE-2020-36073": {"epss_score": 0.02245, "epss_percentile": 0.84129}, "CVE-2020-36074": {"epss_score": 0.02245, "epss_percentile": 0.84129}, "CVE-2020-36077": {"epss_score": 0.01529, "epss_percentile": 0.80875}, "CVE-2020-36079": {"epss_score": 0.24422, "epss_percentile": 0.95919}, "CVE-2020-36082": {"epss_score": 0.01641, "epss_percentile": 0.81503}, "CVE-2020-36084": {"epss_score": 0.00343, "epss_percentile": 0.56404}, "CVE-2020-36085": {"epss_score": 0.00142, "epss_percentile": 0.34988}, "CVE-2020-36109": {"epss_score": 0.28295, "epss_percentile": 0.9634}, "CVE-2020-36112": {"epss_score": 0.8758, "epss_percentile": 0.99434}, "CVE-2020-36115": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2020-36120": {"epss_score": 0.00422, "epss_percentile": 0.61571}, "CVE-2020-36124": {"epss_score": 0.0056, "epss_percentile": 0.67638}, "CVE-2020-36125": {"epss_score": 0.00317, "epss_percentile": 0.54352}, "CVE-2020-36126": {"epss_score": 0.00283, "epss_percentile": 0.51401}, "CVE-2020-36127": {"epss_score": 0.00135, "epss_percentile": 0.33984}, "CVE-2020-36128": {"epss_score": 0.00222, "epss_percentile": 0.44746}, "CVE-2020-36129": {"epss_score": 0.00176, "epss_percentile": 0.39426}, "CVE-2020-36130": {"epss_score": 0.00112, "epss_percentile": 0.30459}, "CVE-2020-36131": {"epss_score": 0.00168, "epss_percentile": 0.38451}, "CVE-2020-36133": {"epss_score": 0.00168, "epss_percentile": 0.38451}, "CVE-2020-36134": {"epss_score": 0.00172, "epss_percentile": 0.39008}, "CVE-2020-36135": {"epss_score": 0.00112, "epss_percentile": 0.30459}, "CVE-2020-36136": {"epss_score": 0.00049, "epss_percentile": 0.15447}, "CVE-2020-36138": {"epss_score": 0.00281, "epss_percentile": 0.51193}, "CVE-2020-36139": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2020-36140": {"epss_score": 0.00194, "epss_percentile": 0.41586}, "CVE-2020-36141": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2020-36142": {"epss_score": 0.00392, "epss_percentile": 0.59674}, "CVE-2020-36144": {"epss_score": 0.00331, "epss_percentile": 0.55533}, "CVE-2020-36148": {"epss_score": 0.00285, "epss_percentile": 0.51653}, "CVE-2020-36149": {"epss_score": 0.00285, "epss_percentile": 0.51653}, "CVE-2020-36150": {"epss_score": 0.00326, "epss_percentile": 0.55056}, "CVE-2020-36151": {"epss_score": 0.00326, "epss_percentile": 0.55056}, "CVE-2020-36152": {"epss_score": 0.01446, "epss_percentile": 0.80324}, "CVE-2020-36154": {"epss_score": 0.00042, "epss_percentile": 0.12582}, "CVE-2020-36155": {"epss_score": 0.61437, "epss_percentile": 0.98248}, "CVE-2020-36156": {"epss_score": 0.00933, "epss_percentile": 0.75643}, "CVE-2020-36157": {"epss_score": 0.01524, "epss_percentile": 0.80848}, "CVE-2020-36158": {"epss_score": 0.00579, "epss_percentile": 0.6821}, "CVE-2020-36159": {"epss_score": 0.00221, "epss_percentile": 0.44653}, "CVE-2020-36160": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2020-36161": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2020-36162": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2020-36163": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2020-36164": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2020-36165": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2020-36166": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2020-36167": {"epss_score": 0.0005, "epss_percentile": 0.15873}, "CVE-2020-36168": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2020-36169": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2020-36170": {"epss_score": 0.00204, "epss_percentile": 0.42657}, "CVE-2020-36171": {"epss_score": 0.00127, "epss_percentile": 0.32899}, "CVE-2020-36172": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2020-36173": {"epss_score": 0.00187, "epss_percentile": 0.40739}, "CVE-2020-36174": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2020-36175": {"epss_score": 0.00187, "epss_percentile": 0.40739}, "CVE-2020-36176": {"epss_score": 0.00213, "epss_percentile": 0.43843}, "CVE-2020-36177": {"epss_score": 0.0131, "epss_percentile": 0.79364}, "CVE-2020-36178": {"epss_score": 0.13608, "epss_percentile": 0.94011}, "CVE-2020-36179": {"epss_score": 0.60256, "epss_percentile": 0.98201}, "CVE-2020-36180": {"epss_score": 0.02234, "epss_percentile": 0.84094}, "CVE-2020-36181": {"epss_score": 0.05412, "epss_percentile": 0.89847}, "CVE-2020-36182": {"epss_score": 0.02715, "epss_percentile": 0.85507}, "CVE-2020-36183": {"epss_score": 0.02061, "epss_percentile": 0.83443}, "CVE-2020-36184": {"epss_score": 0.05743, "epss_percentile": 0.90173}, "CVE-2020-36185": {"epss_score": 0.02234, "epss_percentile": 0.84094}, "CVE-2020-36186": {"epss_score": 0.03062, "epss_percentile": 0.86318}, "CVE-2020-36187": {"epss_score": 0.02147, "epss_percentile": 0.83767}, "CVE-2020-36188": {"epss_score": 0.07892, "epss_percentile": 0.91749}, "CVE-2020-36189": {"epss_score": 0.03642, "epss_percentile": 0.87494}, "CVE-2020-36190": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2020-36191": {"epss_score": 0.00124, "epss_percentile": 0.32372}, "CVE-2020-36192": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2020-36193": {"epss_score": 0.72179, "epss_percentile": 0.98698}, "CVE-2020-36194": {"epss_score": 0.00317, "epss_percentile": 0.54387}, "CVE-2020-36195": {"epss_score": 0.00624, "epss_percentile": 0.6956}, "CVE-2020-36196": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2020-36197": {"epss_score": 0.0259, "epss_percentile": 0.85181}, "CVE-2020-36198": {"epss_score": 0.00936, "epss_percentile": 0.75687}, "CVE-2020-36199": {"epss_score": 0.06022, "epss_percentile": 0.90416}, "CVE-2020-36200": {"epss_score": 0.00267, "epss_percentile": 0.50003}, "CVE-2020-36201": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2020-36202": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2020-36203": {"epss_score": 0.00046, "epss_percentile": 0.14179}, "CVE-2020-36204": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-36205": {"epss_score": 0.00059, "epss_percentile": 0.18819}, "CVE-2020-36206": {"epss_score": 0.00068, "epss_percentile": 0.21223}, "CVE-2020-36207": {"epss_score": 0.00068, "epss_percentile": 0.21223}, "CVE-2020-36208": {"epss_score": 0.00068, "epss_percentile": 0.21223}, "CVE-2020-36209": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-36210": {"epss_score": 0.00065, "epss_percentile": 0.20549}, "CVE-2020-36211": {"epss_score": 0.00068, "epss_percentile": 0.21223}, "CVE-2020-36212": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-36213": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-36214": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-36215": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-36216": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-36217": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-36218": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-36219": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-36220": {"epss_score": 0.00301, "epss_percentile": 0.53043}, "CVE-2020-36221": {"epss_score": 0.56144, "epss_percentile": 0.98009}, "CVE-2020-36222": {"epss_score": 0.46118, "epss_percentile": 0.9753}, "CVE-2020-36223": {"epss_score": 0.10415, "epss_percentile": 0.9298}, "CVE-2020-36224": {"epss_score": 0.01428, "epss_percentile": 0.8022}, "CVE-2020-36225": {"epss_score": 0.01428, "epss_percentile": 0.8022}, "CVE-2020-36226": {"epss_score": 0.01056, "epss_percentile": 0.77122}, "CVE-2020-36227": {"epss_score": 0.73367, "epss_percentile": 0.98749}, "CVE-2020-36228": {"epss_score": 0.71144, "epss_percentile": 0.98656}, "CVE-2020-36229": {"epss_score": 0.03589, "epss_percentile": 0.87398}, "CVE-2020-36230": {"epss_score": 0.03451, "epss_percentile": 0.87165}, "CVE-2020-36231": {"epss_score": 0.00143, "epss_percentile": 0.35101}, "CVE-2020-36232": {"epss_score": 0.00103, "epss_percentile": 0.29059}, "CVE-2020-36233": {"epss_score": 0.00038, "epss_percentile": 0.11312}, "CVE-2020-36234": {"epss_score": 0.0019, "epss_percentile": 0.41065}, "CVE-2020-36235": {"epss_score": 0.00503, "epss_percentile": 0.6546}, "CVE-2020-36236": {"epss_score": 0.00389, "epss_percentile": 0.59458}, "CVE-2020-36237": {"epss_score": 0.00805, "epss_percentile": 0.7364}, "CVE-2020-36238": {"epss_score": 0.00203, "epss_percentile": 0.42504}, "CVE-2020-36239": {"epss_score": 0.16173, "epss_percentile": 0.94588}, "CVE-2020-36240": {"epss_score": 0.00349, "epss_percentile": 0.56911}, "CVE-2020-36241": {"epss_score": 0.00175, "epss_percentile": 0.39354}, "CVE-2020-36242": {"epss_score": 0.01272, "epss_percentile": 0.79076}, "CVE-2020-36243": {"epss_score": 0.88534, "epss_percentile": 0.99476}, "CVE-2020-36244": {"epss_score": 0.02319, "epss_percentile": 0.84364}, "CVE-2020-36245": {"epss_score": 0.0036, "epss_percentile": 0.57681}, "CVE-2020-36246": {"epss_score": 0.0014, "epss_percentile": 0.34713}, "CVE-2020-36247": {"epss_score": 0.00157, "epss_percentile": 0.37089}, "CVE-2020-36248": {"epss_score": 0.00028, "epss_percentile": 0.07447}, "CVE-2020-36249": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-36250": {"epss_score": 0.00057, "epss_percentile": 0.18073}, "CVE-2020-36251": {"epss_score": 0.00208, "epss_percentile": 0.4329}, "CVE-2020-36252": {"epss_score": 0.00087, "epss_percentile": 0.25497}, "CVE-2020-36254": {"epss_score": 0.00342, "epss_percentile": 0.56401}, "CVE-2020-36255": {"epss_score": 0.00437, "epss_percentile": 0.62509}, "CVE-2020-36277": {"epss_score": 0.06648, "epss_percentile": 0.90914}, "CVE-2020-36278": {"epss_score": 0.00431, "epss_percentile": 0.62056}, "CVE-2020-36279": {"epss_score": 0.04251, "epss_percentile": 0.88452}, "CVE-2020-36280": {"epss_score": 0.0175, "epss_percentile": 0.82097}, "CVE-2020-36281": {"epss_score": 0.00506, "epss_percentile": 0.6563}, "CVE-2020-36282": {"epss_score": 0.01699, "epss_percentile": 0.81823}, "CVE-2020-36283": {"epss_score": 0.00214, "epss_percentile": 0.43973}, "CVE-2020-36284": {"epss_score": 0.00122, "epss_percentile": 0.32173}, "CVE-2020-36285": {"epss_score": 0.00122, "epss_percentile": 0.32173}, "CVE-2020-36286": {"epss_score": 0.00214, "epss_percentile": 0.43957}, "CVE-2020-36287": {"epss_score": 0.60461, "epss_percentile": 0.98208}, "CVE-2020-36288": {"epss_score": 0.00656, "epss_percentile": 0.70445}, "CVE-2020-36289": {"epss_score": 0.90008, "epss_percentile": 0.99556}, "CVE-2020-36290": {"epss_score": 0.00459, "epss_percentile": 0.63466}, "CVE-2020-36306": {"epss_score": 0.00339, "epss_percentile": 0.56169}, "CVE-2020-36307": {"epss_score": 0.00415, "epss_percentile": 0.61114}, "CVE-2020-36308": {"epss_score": 0.0045, "epss_percentile": 0.63093}, "CVE-2020-36309": {"epss_score": 0.00423, "epss_percentile": 0.61579}, "CVE-2020-36310": {"epss_score": 0.00103, "epss_percentile": 0.2908}, "CVE-2020-36311": {"epss_score": 0.00112, "epss_percentile": 0.30545}, "CVE-2020-36312": {"epss_score": 0.00028, "epss_percentile": 0.0734}, "CVE-2020-36313": {"epss_score": 0.00073, "epss_percentile": 0.22675}, "CVE-2020-36314": {"epss_score": 0.00198, "epss_percentile": 0.42068}, "CVE-2020-36315": {"epss_score": 0.00133, "epss_percentile": 0.33681}, "CVE-2020-36316": {"epss_score": 0.00259, "epss_percentile": 0.49036}, "CVE-2020-36317": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2020-36318": {"epss_score": 0.00356, "epss_percentile": 0.57334}, "CVE-2020-36319": {"epss_score": 0.0039, "epss_percentile": 0.59537}, "CVE-2020-36320": {"epss_score": 0.00724, "epss_percentile": 0.72037}, "CVE-2020-36321": {"epss_score": 0.00551, "epss_percentile": 0.67353}, "CVE-2020-36322": {"epss_score": 0.00028, "epss_percentile": 0.07219}, "CVE-2020-36323": {"epss_score": 0.00705, "epss_percentile": 0.71586}, "CVE-2020-36324": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-36325": {"epss_score": 0.00323, "epss_percentile": 0.54877}, "CVE-2020-36326": {"epss_score": 0.01029, "epss_percentile": 0.76826}, "CVE-2020-36327": {"epss_score": 0.15566, "epss_percentile": 0.9446}, "CVE-2020-36328": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2020-36329": {"epss_score": 0.00503, "epss_percentile": 0.65463}, "CVE-2020-36330": {"epss_score": 0.00164, "epss_percentile": 0.38}, "CVE-2020-36331": {"epss_score": 0.00189, "epss_percentile": 0.40959}, "CVE-2020-36332": {"epss_score": 0.00818, "epss_percentile": 0.73851}, "CVE-2020-36333": {"epss_score": 0.50218, "epss_percentile": 0.97727}, "CVE-2020-36334": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2020-36363": {"epss_score": 0.00284, "epss_percentile": 0.51449}, "CVE-2020-36364": {"epss_score": 0.00597, "epss_percentile": 0.68742}, "CVE-2020-36365": {"epss_score": 0.09448, "epss_percentile": 0.92553}, "CVE-2020-36366": {"epss_score": 0.00265, "epss_percentile": 0.49836}, "CVE-2020-36367": {"epss_score": 0.00265, "epss_percentile": 0.49836}, "CVE-2020-36368": {"epss_score": 0.00265, "epss_percentile": 0.49836}, "CVE-2020-36369": {"epss_score": 0.00265, "epss_percentile": 0.49836}, "CVE-2020-36370": {"epss_score": 0.00265, "epss_percentile": 0.49836}, "CVE-2020-36371": {"epss_score": 0.00265, "epss_percentile": 0.49836}, "CVE-2020-36372": {"epss_score": 0.00265, "epss_percentile": 0.49836}, "CVE-2020-36373": {"epss_score": 0.00265, "epss_percentile": 0.49836}, "CVE-2020-36374": {"epss_score": 0.00265, "epss_percentile": 0.49836}, "CVE-2020-36375": {"epss_score": 0.00265, "epss_percentile": 0.49836}, "CVE-2020-36376": {"epss_score": 0.01119, "epss_percentile": 0.77752}, "CVE-2020-36377": {"epss_score": 0.01119, "epss_percentile": 0.77752}, "CVE-2020-36378": {"epss_score": 0.01119, "epss_percentile": 0.77752}, "CVE-2020-36379": {"epss_score": 0.01119, "epss_percentile": 0.77752}, "CVE-2020-36380": {"epss_score": 0.01201, "epss_percentile": 0.78484}, "CVE-2020-36381": {"epss_score": 0.01119, "epss_percentile": 0.77752}, "CVE-2020-36382": {"epss_score": 0.0129, "epss_percentile": 0.79216}, "CVE-2020-36383": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2020-36384": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2020-36385": {"epss_score": 0.00069, "epss_percentile": 0.21509}, "CVE-2020-36386": {"epss_score": 0.00227, "epss_percentile": 0.45401}, "CVE-2020-36387": {"epss_score": 0.00057, "epss_percentile": 0.18162}, "CVE-2020-36388": {"epss_score": 0.00665, "epss_percentile": 0.70654}, "CVE-2020-36389": {"epss_score": 0.00409, "epss_percentile": 0.60787}, "CVE-2020-36394": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2020-36395": {"epss_score": 0.00352, "epss_percentile": 0.57101}, "CVE-2020-36396": {"epss_score": 0.00352, "epss_percentile": 0.57101}, "CVE-2020-36397": {"epss_score": 0.00352, "epss_percentile": 0.57101}, "CVE-2020-36398": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2020-36399": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2020-36400": {"epss_score": 0.00539, "epss_percentile": 0.66975}, "CVE-2020-36401": {"epss_score": 0.00242, "epss_percentile": 0.47345}, "CVE-2020-36402": {"epss_score": 0.00221, "epss_percentile": 0.44679}, "CVE-2020-36403": {"epss_score": 0.0051, "epss_percentile": 0.6576}, "CVE-2020-36404": {"epss_score": 0.00354, "epss_percentile": 0.57209}, "CVE-2020-36405": {"epss_score": 0.00401, "epss_percentile": 0.60216}, "CVE-2020-36406": {"epss_score": 0.00646, "epss_percentile": 0.70145}, "CVE-2020-36407": {"epss_score": 0.00476, "epss_percentile": 0.64273}, "CVE-2020-36408": {"epss_score": 0.00305, "epss_percentile": 0.53336}, "CVE-2020-36409": {"epss_score": 0.00275, "epss_percentile": 0.50637}, "CVE-2020-36410": {"epss_score": 0.00275, "epss_percentile": 0.50637}, "CVE-2020-36411": {"epss_score": 0.00275, "epss_percentile": 0.50637}, "CVE-2020-36412": {"epss_score": 0.00275, "epss_percentile": 0.50637}, "CVE-2020-36413": {"epss_score": 0.00275, "epss_percentile": 0.50637}, "CVE-2020-36414": {"epss_score": 0.00322, "epss_percentile": 0.54799}, "CVE-2020-36415": {"epss_score": 0.00275, "epss_percentile": 0.50637}, "CVE-2020-36416": {"epss_score": 0.00275, "epss_percentile": 0.50637}, "CVE-2020-36420": {"epss_score": 0.00711, "epss_percentile": 0.71741}, "CVE-2020-36421": {"epss_score": 0.002, "epss_percentile": 0.42205}, "CVE-2020-36422": {"epss_score": 0.00183, "epss_percentile": 0.40284}, "CVE-2020-36423": {"epss_score": 0.00202, "epss_percentile": 0.42401}, "CVE-2020-36424": {"epss_score": 0.00059, "epss_percentile": 0.18756}, "CVE-2020-36425": {"epss_score": 0.00332, "epss_percentile": 0.55596}, "CVE-2020-36426": {"epss_score": 0.00225, "epss_percentile": 0.45139}, "CVE-2020-36427": {"epss_score": 0.00224, "epss_percentile": 0.45062}, "CVE-2020-36428": {"epss_score": 0.0016, "epss_percentile": 0.3743}, "CVE-2020-36429": {"epss_score": 0.00078, "epss_percentile": 0.23603}, "CVE-2020-36430": {"epss_score": 0.00311, "epss_percentile": 0.53864}, "CVE-2020-36431": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2020-36432": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-36433": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2020-36434": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-36435": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-36436": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-36437": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-36438": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-36439": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-36440": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-36441": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-36442": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-36443": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-36444": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-36445": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-36446": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-36447": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2020-36448": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2020-36449": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-36450": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-36451": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-36452": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2020-36453": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2020-36454": {"epss_score": 0.00281, "epss_percentile": 0.51144}, "CVE-2020-36455": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-36456": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2020-36457": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2020-36458": {"epss_score": 0.00301, "epss_percentile": 0.53066}, "CVE-2020-36459": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2020-36460": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2020-36461": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2020-36462": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2020-36463": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2020-36464": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-36465": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-36466": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-36467": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-36468": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-36469": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-36470": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-36471": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-36472": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2020-36473": {"epss_score": 0.00108, "epss_percentile": 0.29902}, "CVE-2020-36474": {"epss_score": 0.00841, "epss_percentile": 0.74226}, "CVE-2020-36475": {"epss_score": 0.00251, "epss_percentile": 0.48327}, "CVE-2020-36476": {"epss_score": 0.0027, "epss_percentile": 0.50247}, "CVE-2020-36477": {"epss_score": 0.00217, "epss_percentile": 0.44284}, "CVE-2020-36478": {"epss_score": 0.00305, "epss_percentile": 0.53372}, "CVE-2020-36485": {"epss_score": 0.00075, "epss_percentile": 0.22888}, "CVE-2020-36486": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-36488": {"epss_score": 0.00392, "epss_percentile": 0.59674}, "CVE-2020-36489": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-36490": {"epss_score": 0.00176, "epss_percentile": 0.39494}, "CVE-2020-36491": {"epss_score": 0.00176, "epss_percentile": 0.39494}, "CVE-2020-36492": {"epss_score": 0.00176, "epss_percentile": 0.39494}, "CVE-2020-36493": {"epss_score": 0.00176, "epss_percentile": 0.39494}, "CVE-2020-36494": {"epss_score": 0.0018, "epss_percentile": 0.39987}, "CVE-2020-36495": {"epss_score": 0.0018, "epss_percentile": 0.39987}, "CVE-2020-36496": {"epss_score": 0.0018, "epss_percentile": 0.39987}, "CVE-2020-36497": {"epss_score": 0.0018, "epss_percentile": 0.39987}, "CVE-2020-36498": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-36499": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-36501": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-36502": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-36503": {"epss_score": 0.01275, "epss_percentile": 0.79102}, "CVE-2020-36504": {"epss_score": 0.0013, "epss_percentile": 0.33334}, "CVE-2020-36505": {"epss_score": 0.00214, "epss_percentile": 0.43995}, "CVE-2020-36510": {"epss_score": 0.02579, "epss_percentile": 0.85149}, "CVE-2020-36511": {"epss_score": 0.00285, "epss_percentile": 0.51538}, "CVE-2020-36512": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-36513": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-36514": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-36516": {"epss_score": 0.0004, "epss_percentile": 0.11867}, "CVE-2020-36517": {"epss_score": 0.01845, "epss_percentile": 0.82508}, "CVE-2020-36518": {"epss_score": 0.00514, "epss_percentile": 0.65964}, "CVE-2020-36519": {"epss_score": 0.00232, "epss_percentile": 0.45959}, "CVE-2020-36521": {"epss_score": 0.00057, "epss_percentile": 0.18216}, "CVE-2020-36523": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-36524": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-36525": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-36526": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-36527": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-36528": {"epss_score": 0.00524, "epss_percentile": 0.66327}, "CVE-2020-36529": {"epss_score": 0.08244, "epss_percentile": 0.91947}, "CVE-2020-36530": {"epss_score": 0.00229, "epss_percentile": 0.45573}, "CVE-2020-36531": {"epss_score": 0.00444, "epss_percentile": 0.62849}, "CVE-2020-36532": {"epss_score": 0.00256, "epss_percentile": 0.48742}, "CVE-2020-36533": {"epss_score": 0.00674, "epss_percentile": 0.70884}, "CVE-2020-36534": {"epss_score": 0.00114, "epss_percentile": 0.30862}, "CVE-2020-36535": {"epss_score": 0.00175, "epss_percentile": 0.39325}, "CVE-2020-36536": {"epss_score": 0.00212, "epss_percentile": 0.43816}, "CVE-2020-36537": {"epss_score": 0.00175, "epss_percentile": 0.39325}, "CVE-2020-36538": {"epss_score": 0.00189, "epss_percentile": 0.4093}, "CVE-2020-36539": {"epss_score": 0.00189, "epss_percentile": 0.4093}, "CVE-2020-36540": {"epss_score": 0.00245, "epss_percentile": 0.47643}, "CVE-2020-36541": {"epss_score": 0.00322, "epss_percentile": 0.54757}, "CVE-2020-36542": {"epss_score": 0.0046, "epss_percentile": 0.63502}, "CVE-2020-36543": {"epss_score": 0.00706, "epss_percentile": 0.7162}, "CVE-2020-36544": {"epss_score": 0.00502, "epss_percentile": 0.65419}, "CVE-2020-36547": {"epss_score": 0.00114, "epss_percentile": 0.30768}, "CVE-2020-36548": {"epss_score": 0.00104, "epss_percentile": 0.29103}, "CVE-2020-36549": {"epss_score": 0.00119, "epss_percentile": 0.3167}, "CVE-2020-36550": {"epss_score": 0.00361, "epss_percentile": 0.5774}, "CVE-2020-36551": {"epss_score": 0.00361, "epss_percentile": 0.5774}, "CVE-2020-36552": {"epss_score": 0.00361, "epss_percentile": 0.5774}, "CVE-2020-36553": {"epss_score": 0.00361, "epss_percentile": 0.5774}, "CVE-2020-36557": {"epss_score": 0.00015, "epss_percentile": 0.02468}, "CVE-2020-36558": {"epss_score": 0.00016, "epss_percentile": 0.02824}, "CVE-2020-36559": {"epss_score": 0.0201, "epss_percentile": 0.83245}, "CVE-2020-36560": {"epss_score": 0.00706, "epss_percentile": 0.7162}, "CVE-2020-36561": {"epss_score": 0.00612, "epss_percentile": 0.6923}, "CVE-2020-36562": {"epss_score": 0.00429, "epss_percentile": 0.6197}, "CVE-2020-36563": {"epss_score": 0.00116, "epss_percentile": 0.31145}, "CVE-2020-36564": {"epss_score": 0.00308, "epss_percentile": 0.53627}, "CVE-2020-36565": {"epss_score": 0.00399, "epss_percentile": 0.60118}, "CVE-2020-36566": {"epss_score": 0.00622, "epss_percentile": 0.69532}, "CVE-2020-36567": {"epss_score": 0.00158, "epss_percentile": 0.372}, "CVE-2020-36568": {"epss_score": 0.01092, "epss_percentile": 0.77464}, "CVE-2020-36569": {"epss_score": 0.00361, "epss_percentile": 0.57747}, "CVE-2020-36599": {"epss_score": 0.00585, "epss_percentile": 0.68416}, "CVE-2020-36600": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2020-36601": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2020-36602": {"epss_score": 0.00075, "epss_percentile": 0.23042}, "CVE-2020-36603": {"epss_score": 0.00603, "epss_percentile": 0.68906}, "CVE-2020-36604": {"epss_score": 0.01001, "epss_percentile": 0.76493}, "CVE-2020-36605": {"epss_score": 0.0003, "epss_percentile": 0.08222}, "CVE-2020-36607": {"epss_score": 0.00183, "epss_percentile": 0.40298}, "CVE-2020-36608": {"epss_score": 0.00233, "epss_percentile": 0.45995}, "CVE-2020-36609": {"epss_score": 0.00278, "epss_percentile": 0.50896}, "CVE-2020-36610": {"epss_score": 0.00233, "epss_percentile": 0.46002}, "CVE-2020-36611": {"epss_score": 0.00043, "epss_percentile": 0.13182}, "CVE-2020-36615": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2020-36617": {"epss_score": 0.004, "epss_percentile": 0.60149}, "CVE-2020-36618": {"epss_score": 0.00541, "epss_percentile": 0.67054}, "CVE-2020-36619": {"epss_score": 0.00511, "epss_percentile": 0.65832}, "CVE-2020-36620": {"epss_score": 0.00154, "epss_percentile": 0.36685}, "CVE-2020-36621": {"epss_score": 0.00201, "epss_percentile": 0.42387}, "CVE-2020-36622": {"epss_score": 0.00162, "epss_percentile": 0.3769}, "CVE-2020-36623": {"epss_score": 0.00164, "epss_percentile": 0.37989}, "CVE-2020-36624": {"epss_score": 0.00324, "epss_percentile": 0.54966}, "CVE-2020-36625": {"epss_score": 0.00301, "epss_percentile": 0.53001}, "CVE-2020-36626": {"epss_score": 0.00326, "epss_percentile": 0.55054}, "CVE-2020-36627": {"epss_score": 0.00313, "epss_percentile": 0.54035}, "CVE-2020-36628": {"epss_score": 0.00739, "epss_percentile": 0.72352}, "CVE-2020-36629": {"epss_score": 0.00458, "epss_percentile": 0.6343}, "CVE-2020-36630": {"epss_score": 0.00353, "epss_percentile": 0.57193}, "CVE-2020-36631": {"epss_score": 0.00353, "epss_percentile": 0.57193}, "CVE-2020-36632": {"epss_score": 0.00517, "epss_percentile": 0.66084}, "CVE-2020-36633": {"epss_score": 0.00197, "epss_percentile": 0.41861}, "CVE-2020-36634": {"epss_score": 0.00299, "epss_percentile": 0.52878}, "CVE-2020-36635": {"epss_score": 0.00285, "epss_percentile": 0.51646}, "CVE-2020-36636": {"epss_score": 0.00285, "epss_percentile": 0.51646}, "CVE-2020-36637": {"epss_score": 0.00346, "epss_percentile": 0.5665}, "CVE-2020-36638": {"epss_score": 0.00346, "epss_percentile": 0.5665}, "CVE-2020-36639": {"epss_score": 0.00582, "epss_percentile": 0.68292}, "CVE-2020-36640": {"epss_score": 0.00049, "epss_percentile": 0.15342}, "CVE-2020-36641": {"epss_score": 0.00042, "epss_percentile": 0.12789}, "CVE-2020-36642": {"epss_score": 0.00481, "epss_percentile": 0.64502}, "CVE-2020-36644": {"epss_score": 0.00347, "epss_percentile": 0.56787}, "CVE-2020-36645": {"epss_score": 0.00076, "epss_percentile": 0.23145}, "CVE-2020-36646": {"epss_score": 0.00096, "epss_percentile": 0.2728}, "CVE-2020-36647": {"epss_score": 0.00098, "epss_percentile": 0.27648}, "CVE-2020-36648": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2020-36649": {"epss_score": 0.00053, "epss_percentile": 0.16843}, "CVE-2020-36650": {"epss_score": 0.00176, "epss_percentile": 0.39377}, "CVE-2020-36651": {"epss_score": 0.00108, "epss_percentile": 0.29874}, "CVE-2020-36652": {"epss_score": 0.00036, "epss_percentile": 0.10615}, "CVE-2020-36653": {"epss_score": 0.00083, "epss_percentile": 0.24808}, "CVE-2020-36654": {"epss_score": 0.00083, "epss_percentile": 0.24808}, "CVE-2020-36655": {"epss_score": 0.0165, "epss_percentile": 0.8156}, "CVE-2020-36656": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2020-36657": {"epss_score": 0.00039, "epss_percentile": 0.11549}, "CVE-2020-36658": {"epss_score": 0.00153, "epss_percentile": 0.36518}, "CVE-2020-36659": {"epss_score": 0.00153, "epss_percentile": 0.36518}, "CVE-2020-36660": {"epss_score": 0.00097, "epss_percentile": 0.27598}, "CVE-2020-36661": {"epss_score": 0.0006, "epss_percentile": 0.19237}, "CVE-2020-36663": {"epss_score": 0.00071, "epss_percentile": 0.22143}, "CVE-2020-36664": {"epss_score": 0.00071, "epss_percentile": 0.22143}, "CVE-2020-36665": {"epss_score": 0.00065, "epss_percentile": 0.2064}, "CVE-2020-36666": {"epss_score": 0.00266, "epss_percentile": 0.49908}, "CVE-2020-36667": {"epss_score": 0.00072, "epss_percentile": 0.22458}, "CVE-2020-36668": {"epss_score": 0.00156, "epss_percentile": 0.36998}, "CVE-2020-36669": {"epss_score": 0.00157, "epss_percentile": 0.37078}, "CVE-2020-36670": {"epss_score": 0.00052, "epss_percentile": 0.16603}, "CVE-2020-36691": {"epss_score": 0.00013, "epss_percentile": 0.01602}, "CVE-2020-36692": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2020-36694": {"epss_score": 0.00011, "epss_percentile": 0.01113}, "CVE-2020-36695": {"epss_score": 0.00042, "epss_percentile": 0.12477}, "CVE-2020-36696": {"epss_score": 0.00353, "epss_percentile": 0.57185}, "CVE-2020-36697": {"epss_score": 0.00086, "epss_percentile": 0.25367}, "CVE-2020-36698": {"epss_score": 0.00261, "epss_percentile": 0.49286}, "CVE-2020-36699": {"epss_score": 0.00066, "epss_percentile": 0.20958}, "CVE-2020-36700": {"epss_score": 0.00223, "epss_percentile": 0.44881}, "CVE-2020-36701": {"epss_score": 0.01226, "epss_percentile": 0.78693}, "CVE-2020-36702": {"epss_score": 0.00037, "epss_percentile": 0.10877}, "CVE-2020-36703": {"epss_score": 0.00114, "epss_percentile": 0.30745}, "CVE-2020-36704": {"epss_score": 0.00066, "epss_percentile": 0.20704}, "CVE-2020-36705": {"epss_score": 0.8533, "epss_percentile": 0.99329}, "CVE-2020-36706": {"epss_score": 0.07069, "epss_percentile": 0.91225}, "CVE-2020-36707": {"epss_score": 0.0012, "epss_percentile": 0.31728}, "CVE-2020-36708": {"epss_score": 0.90488, "epss_percentile": 0.99586}, "CVE-2020-36709": {"epss_score": 0.00136, "epss_percentile": 0.3406}, "CVE-2020-36710": {"epss_score": 0.00467, "epss_percentile": 0.63842}, "CVE-2020-36711": {"epss_score": 0.00107, "epss_percentile": 0.29738}, "CVE-2020-36712": {"epss_score": 0.00218, "epss_percentile": 0.44408}, "CVE-2020-36713": {"epss_score": 0.00903, "epss_percentile": 0.75202}, "CVE-2020-36714": {"epss_score": 0.00143, "epss_percentile": 0.35191}, "CVE-2020-36715": {"epss_score": 0.00065, "epss_percentile": 0.20581}, "CVE-2020-36716": {"epss_score": 0.00093, "epss_percentile": 0.26678}, "CVE-2020-36717": {"epss_score": 0.00247, "epss_percentile": 0.47815}, "CVE-2020-36718": {"epss_score": 0.01329, "epss_percentile": 0.79503}, "CVE-2020-36719": {"epss_score": 0.62965, "epss_percentile": 0.98314}, "CVE-2020-36720": {"epss_score": 0.00192, "epss_percentile": 0.41282}, "CVE-2020-36721": {"epss_score": 0.0012, "epss_percentile": 0.31752}, "CVE-2020-36722": {"epss_score": 0.00088, "epss_percentile": 0.25688}, "CVE-2020-36723": {"epss_score": 0.14607, "epss_percentile": 0.9425}, "CVE-2020-36724": {"epss_score": 0.00162, "epss_percentile": 0.37652}, "CVE-2020-36725": {"epss_score": 0.00454, "epss_percentile": 0.63268}, "CVE-2020-36726": {"epss_score": 0.00765, "epss_percentile": 0.72927}, "CVE-2020-36727": {"epss_score": 0.00765, "epss_percentile": 0.72927}, "CVE-2020-36728": {"epss_score": 0.77717, "epss_percentile": 0.98949}, "CVE-2020-36729": {"epss_score": 0.00022, "epss_percentile": 0.05318}, "CVE-2020-36730": {"epss_score": 0.42777, "epss_percentile": 0.97349}, "CVE-2020-36731": {"epss_score": 0.1844, "epss_percentile": 0.95017}, "CVE-2020-36732": {"epss_score": 0.00577, "epss_percentile": 0.68172}, "CVE-2020-36735": {"epss_score": 0.00104, "epss_percentile": 0.29221}, "CVE-2020-36736": {"epss_score": 0.00095, "epss_percentile": 0.27234}, "CVE-2020-36737": {"epss_score": 0.00095, "epss_percentile": 0.27234}, "CVE-2020-36738": {"epss_score": 0.00099, "epss_percentile": 0.28379}, "CVE-2020-36739": {"epss_score": 0.00099, "epss_percentile": 0.28379}, "CVE-2020-36740": {"epss_score": 0.00112, "epss_percentile": 0.30434}, "CVE-2020-36741": {"epss_score": 0.00106, "epss_percentile": 0.29414}, "CVE-2020-36742": {"epss_score": 0.00106, "epss_percentile": 0.29414}, "CVE-2020-36743": {"epss_score": 0.00106, "epss_percentile": 0.29414}, "CVE-2020-36744": {"epss_score": 0.00106, "epss_percentile": 0.29414}, "CVE-2020-36745": {"epss_score": 0.00112, "epss_percentile": 0.30434}, "CVE-2020-36746": {"epss_score": 0.00093, "epss_percentile": 0.26697}, "CVE-2020-36747": {"epss_score": 0.00093, "epss_percentile": 0.26697}, "CVE-2020-36748": {"epss_score": 0.00093, "epss_percentile": 0.26697}, "CVE-2020-36749": {"epss_score": 0.00093, "epss_percentile": 0.26697}, "CVE-2020-36750": {"epss_score": 0.00106, "epss_percentile": 0.29414}, "CVE-2020-36751": {"epss_score": 0.00144, "epss_percentile": 0.35239}, "CVE-2020-36752": {"epss_score": 0.00093, "epss_percentile": 0.26697}, "CVE-2020-36753": {"epss_score": 0.00144, "epss_percentile": 0.35239}, "CVE-2020-36754": {"epss_score": 0.00137, "epss_percentile": 0.3423}, "CVE-2020-36755": {"epss_score": 0.00137, "epss_percentile": 0.3423}, "CVE-2020-36756": {"epss_score": 0.00148, "epss_percentile": 0.359}, "CVE-2020-36757": {"epss_score": 0.00106, "epss_percentile": 0.29414}, "CVE-2020-36758": {"epss_score": 0.00137, "epss_percentile": 0.3423}, "CVE-2020-36759": {"epss_score": 0.00137, "epss_percentile": 0.3423}, "CVE-2020-36760": {"epss_score": 0.00111, "epss_percentile": 0.30379}, "CVE-2020-36761": {"epss_score": 0.00122, "epss_percentile": 0.32055}, "CVE-2020-36762": {"epss_score": 0.00415, "epss_percentile": 0.61159}, "CVE-2020-36763": {"epss_score": 0.00046, "epss_percentile": 0.14272}, "CVE-2020-36765": {"epss_score": 0.00101, "epss_percentile": 0.28681}, "CVE-2020-36766": {"epss_score": 0.00012, "epss_percentile": 0.0114}, "CVE-2020-36767": {"epss_score": 0.00065, "epss_percentile": 0.20614}, "CVE-2020-36768": {"epss_score": 0.00056, "epss_percentile": 0.17768}, "CVE-2020-36769": {"epss_score": 0.00112, "epss_percentile": 0.30489}, "CVE-2020-36770": {"epss_score": 0.00053, "epss_percentile": 0.16826}, "CVE-2020-36771": {"epss_score": 0.00073, "epss_percentile": 0.22523}, "CVE-2020-36772": {"epss_score": 0.00024, "epss_percentile": 0.05962}, "CVE-2020-36773": {"epss_score": 0.00106, "epss_percentile": 0.29442}, "CVE-2020-36774": {"epss_score": 0.00026, "epss_percentile": 0.06489}, "CVE-2020-36775": {"epss_score": 0.00027, "epss_percentile": 0.06937}, "CVE-2020-36776": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2020-36777": {"epss_score": 7e-05, "epss_percentile": 0.00366}, "CVE-2020-36778": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2020-36779": {"epss_score": 0.00035, "epss_percentile": 0.09941}, "CVE-2020-36780": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2020-36781": {"epss_score": 0.0003, "epss_percentile": 0.08022}, "CVE-2020-36782": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2020-36783": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2020-36784": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2020-36785": {"epss_score": 0.00036, "epss_percentile": 0.10514}, "CVE-2020-36786": {"epss_score": 0.00035, "epss_percentile": 0.09827}, "CVE-2020-36787": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2020-36788": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2020-36789": {"epss_score": 0.00021, "epss_percentile": 0.04866}, "CVE-2020-36790": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2020-36791": {"epss_score": 0.00016, "epss_percentile": 0.02962}, "CVE-2020-36825": {"epss_score": 0.00068, "epss_percentile": 0.21209}, "CVE-2020-36826": {"epss_score": 0.00069, "epss_percentile": 0.21492}, "CVE-2020-36827": {"epss_score": 0.00083, "epss_percentile": 0.24732}, "CVE-2020-36828": {"epss_score": 0.00072, "epss_percentile": 0.22426}, "CVE-2020-36829": {"epss_score": 0.00165, "epss_percentile": 0.38133}, "CVE-2020-36830": {"epss_score": 0.00065, "epss_percentile": 0.20454}, "CVE-2020-36831": {"epss_score": 0.00261, "epss_percentile": 0.49279}, "CVE-2020-36832": {"epss_score": 0.00468, "epss_percentile": 0.63872}, "CVE-2020-36833": {"epss_score": 0.00043, "epss_percentile": 0.12951}, "CVE-2020-36834": {"epss_score": 0.00101, "epss_percentile": 0.28644}, "CVE-2020-36835": {"epss_score": 0.00209, "epss_percentile": 0.4341}, "CVE-2020-36836": {"epss_score": 0.19778, "epss_percentile": 0.95239}, "CVE-2020-36837": {"epss_score": 0.00356, "epss_percentile": 0.57385}, "CVE-2020-36838": {"epss_score": 0.00023, "epss_percentile": 0.05511}, "CVE-2020-36839": {"epss_score": 0.00178, "epss_percentile": 0.39671}, "CVE-2020-36840": {"epss_score": 0.00266, "epss_percentile": 0.49945}, "CVE-2020-36841": {"epss_score": 0.00083, "epss_percentile": 0.24724}, "CVE-2020-36842": {"epss_score": 0.38685, "epss_percentile": 0.97115}, "CVE-2020-36843": {"epss_score": 0.00025, "epss_percentile": 0.06364}, "CVE-2020-36844": {"epss_score": 0.00053, "epss_percentile": 0.16872}, "CVE-2020-36845": {"epss_score": 0.00058, "epss_percentile": 0.18547}, "CVE-2020-36846": {"epss_score": 0.00086, "epss_percentile": 0.25304}, "CVE-2020-36847": {"epss_score": 0.86143, "epss_percentile": 0.9937}, "CVE-2020-36848": {"epss_score": 0.562, "epss_percentile": 0.98011}, "CVE-2020-36849": {"epss_score": 0.6349, "epss_percentile": 0.98335}, "CVE-2020-36850": {"epss_score": 0.00057, "epss_percentile": 0.18111}, "CVE-2020-36851": {"epss_score": 0.00702, "epss_percentile": 0.71508}, "CVE-2020-36852": {"epss_score": 0.00075, "epss_percentile": 0.22997}, "CVE-2020-36853": {"epss_score": 0.00163, "epss_percentile": 0.37835}, "CVE-2020-36854": {"epss_score": 0.00035, "epss_percentile": 0.10045}, "CVE-2020-36855": {"epss_score": 0.00034, "epss_percentile": 0.0952}, "CVE-2020-36856": {"epss_score": 0.00248, "epss_percentile": 0.47934}, "CVE-2020-36857": {"epss_score": 0.00348, "epss_percentile": 0.56831}, "CVE-2020-36858": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2020-36859": {"epss_score": 0.01157, "epss_percentile": 0.7811}, "CVE-2020-36860": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2020-36861": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2020-36862": {"epss_score": 0.0008, "epss_percentile": 0.24169}, "CVE-2020-36863": {"epss_score": 0.00691, "epss_percentile": 0.71273}, "CVE-2020-36864": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2020-36865": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2020-36866": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2020-36867": {"epss_score": 0.0155, "epss_percentile": 0.80983}, "CVE-2020-36868": {"epss_score": 0.00036, "epss_percentile": 0.10324}, "CVE-2020-36869": {"epss_score": 0.00549, "epss_percentile": 0.67308}, "CVE-2020-36870": {"epss_score": 0.00169, "epss_percentile": 0.38559}, "CVE-2020-36871": {"epss_score": 0.00387, "epss_percentile": 0.59326}, "CVE-2020-36872": {"epss_score": 0.00223, "epss_percentile": 0.44899}, "CVE-2020-36873": {"epss_score": 0.00288, "epss_percentile": 0.51918}, "CVE-2020-36874": {"epss_score": 0.00412, "epss_percentile": 0.60913}, "CVE-2020-36876": {"epss_score": 0.00099, "epss_percentile": 0.2843}, "CVE-2020-36877": {"epss_score": 0.00585, "epss_percentile": 0.68418}, "CVE-2020-36878": {"epss_score": 0.00057, "epss_percentile": 0.18137}, "CVE-2020-36879": {"epss_score": 0.00057, "epss_percentile": 0.18136}, "CVE-2020-36880": {"epss_score": 0.00014, "epss_percentile": 0.01746}, "CVE-2020-36881": {"epss_score": 0.00033, "epss_percentile": 0.0933}, "CVE-2020-36882": {"epss_score": 0.00157, "epss_percentile": 0.37095}, "CVE-2020-36883": {"epss_score": 0.00163, "epss_percentile": 0.37761}, "CVE-2020-36884": {"epss_score": 0.00058, "epss_percentile": 0.18385}, "CVE-2020-36885": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2020-36886": {"epss_score": 0.00062, "epss_percentile": 0.19789}, "CVE-2020-36887": {"epss_score": 0.00041, "epss_percentile": 0.12283}, "CVE-2020-36888": {"epss_score": 0.00032, "epss_percentile": 0.0877}, "CVE-2020-36889": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2020-36890": {"epss_score": 0.00047, "epss_percentile": 0.14879}, "CVE-2020-36891": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2020-36892": {"epss_score": 0.00331, "epss_percentile": 0.55543}, "CVE-2020-36893": {"epss_score": 0.08023, "epss_percentile": 0.91836}, "CVE-2020-36894": {"epss_score": 0.00373, "epss_percentile": 0.58479}, "CVE-2020-36895": {"epss_score": 0.00204, "epss_percentile": 0.42668}, "CVE-2020-36896": {"epss_score": 0.00914, "epss_percentile": 0.75394}, "CVE-2020-36897": {"epss_score": 0.01212, "epss_percentile": 0.78558}, "CVE-2020-36898": {"epss_score": 0.05594, "epss_percentile": 0.90033}, "CVE-2020-36899": {"epss_score": 0.00434, "epss_percentile": 0.62317}, "CVE-2020-36900": {"epss_score": 0.00025, "epss_percentile": 0.06246}, "CVE-2020-36901": {"epss_score": 0.00046, "epss_percentile": 0.14465}, "CVE-2020-36902": {"epss_score": 0.00364, "epss_percentile": 0.57952}, "CVE-2020-36903": {"epss_score": 0.00014, "epss_percentile": 0.01786}, "CVE-2020-36904": {"epss_score": 0.00111, "epss_percentile": 0.3034}, "CVE-2020-36905": {"epss_score": 0.00049, "epss_percentile": 0.15509}, "CVE-2020-36906": {"epss_score": 0.00017, "epss_percentile": 0.03324}, "CVE-2020-36907": {"epss_score": 0.00383, "epss_percentile": 0.59087}, "CVE-2020-36908": {"epss_score": 0.00016, "epss_percentile": 0.02622}, "CVE-2020-36909": {"epss_score": 0.00034, "epss_percentile": 0.0979}, "CVE-2020-36910": {"epss_score": 0.00325, "epss_percentile": 0.54982}, "CVE-2020-36912": {"epss_score": 0.00045, "epss_percentile": 0.13731}, "CVE-2020-36913": {"epss_score": 0.00087, "epss_percentile": 0.25581}, "CVE-2020-36914": {"epss_score": 0.00036, "epss_percentile": 0.10504}, "CVE-2020-36915": {"epss_score": 0.00036, "epss_percentile": 0.10543}, "CVE-2020-36916": {"epss_score": 0.00023, "epss_percentile": 0.05326}, "CVE-2020-36917": {"epss_score": 0.00063, "epss_percentile": 0.20062}, "CVE-2020-36918": {"epss_score": 0.00017, "epss_percentile": 0.03324}, "CVE-2020-36920": {"epss_score": 0.00051, "epss_percentile": 0.16189}, "CVE-2020-36921": {"epss_score": 0.00191, "epss_percentile": 0.41212}, "CVE-2020-36922": {"epss_score": 0.00082, "epss_percentile": 0.24488}, "CVE-2020-36923": {"epss_score": 0.00069, "epss_percentile": 0.21503}, "CVE-2020-36924": {"epss_score": 0.00062, "epss_percentile": 0.19707}, "CVE-2020-36925": {"epss_score": 0.00523, "epss_percentile": 0.66297}, "CVE-2020-3110": {"epss_score": 0.01462, "epss_percentile": 0.8044}, "CVE-2020-3111": {"epss_score": 0.00234, "epss_percentile": 0.46122}, "CVE-2020-3112": {"epss_score": 0.0059, "epss_percentile": 0.68572}, "CVE-2020-3113": {"epss_score": 0.00294, "epss_percentile": 0.52405}, "CVE-2020-3114": {"epss_score": 0.00368, "epss_percentile": 0.58166}, "CVE-2020-3115": {"epss_score": 0.00139, "epss_percentile": 0.34655}, "CVE-2020-3116": {"epss_score": 0.00321, "epss_percentile": 0.54737}, "CVE-2020-3117": {"epss_score": 0.00069, "epss_percentile": 0.21538}, "CVE-2020-3118": {"epss_score": 0.00294, "epss_percentile": 0.52368}, "CVE-2020-3119": {"epss_score": 0.07914, "epss_percentile": 0.91761}, "CVE-2020-3120": {"epss_score": 0.00319, "epss_percentile": 0.54484}, "CVE-2020-3121": {"epss_score": 0.00319, "epss_percentile": 0.54468}, "CVE-2020-3122": {"epss_score": 0.00056, "epss_percentile": 0.17876}, "CVE-2020-3123": {"epss_score": 0.03107, "epss_percentile": 0.86421}, "CVE-2020-3124": {"epss_score": 0.00184, "epss_percentile": 0.40387}, "CVE-2020-3125": {"epss_score": 0.01172, "epss_percentile": 0.78231}, "CVE-2020-3126": {"epss_score": 0.00103, "epss_percentile": 0.29081}, "CVE-2020-3127": {"epss_score": 0.00598, "epss_percentile": 0.68769}, "CVE-2020-3128": {"epss_score": 0.00493, "epss_percentile": 0.65031}, "CVE-2020-3129": {"epss_score": 0.0026, "epss_percentile": 0.49106}, "CVE-2020-3130": {"epss_score": 0.00104, "epss_percentile": 0.29192}, "CVE-2020-3131": {"epss_score": 0.00744, "epss_percentile": 0.72513}, "CVE-2020-3132": {"epss_score": 0.0092, "epss_percentile": 0.75466}, "CVE-2020-3133": {"epss_score": 0.0022, "epss_percentile": 0.44569}, "CVE-2020-3134": {"epss_score": 0.00584, "epss_percentile": 0.68375}, "CVE-2020-3135": {"epss_score": 0.00159, "epss_percentile": 0.37334}, "CVE-2020-3136": {"epss_score": 0.00717, "epss_percentile": 0.71885}, "CVE-2020-3137": {"epss_score": 0.00469, "epss_percentile": 0.63957}, "CVE-2020-3138": {"epss_score": 0.00029, "epss_percentile": 0.07862}, "CVE-2020-3139": {"epss_score": 0.00219, "epss_percentile": 0.44517}, "CVE-2020-3140": {"epss_score": 0.01659, "epss_percentile": 0.81613}, "CVE-2020-3141": {"epss_score": 0.00982, "epss_percentile": 0.76286}, "CVE-2020-3142": {"epss_score": 0.00496, "epss_percentile": 0.65154}, "CVE-2020-3143": {"epss_score": 0.02275, "epss_percentile": 0.84226}, "CVE-2020-3144": {"epss_score": 0.00215, "epss_percentile": 0.44057}, "CVE-2020-3145": {"epss_score": 0.01371, "epss_percentile": 0.79806}, "CVE-2020-3146": {"epss_score": 0.02324, "epss_percentile": 0.84381}, "CVE-2020-3147": {"epss_score": 0.02561, "epss_percentile": 0.85106}, "CVE-2020-3148": {"epss_score": 0.00306, "epss_percentile": 0.53407}, "CVE-2020-3149": {"epss_score": 0.0026, "epss_percentile": 0.49106}, "CVE-2020-3150": {"epss_score": 0.00336, "epss_percentile": 0.55985}, "CVE-2020-3151": {"epss_score": 0.00051, "epss_percentile": 0.15993}, "CVE-2020-3152": {"epss_score": 0.00018, "epss_percentile": 0.03525}, "CVE-2020-3153": {"epss_score": 0.25087, "epss_percentile": 0.95984}, "CVE-2020-3154": {"epss_score": 0.00258, "epss_percentile": 0.48977}, "CVE-2020-3155": {"epss_score": 0.0025, "epss_percentile": 0.48137}, "CVE-2020-3156": {"epss_score": 0.00208, "epss_percentile": 0.43279}, "CVE-2020-3157": {"epss_score": 0.00217, "epss_percentile": 0.44308}, "CVE-2020-3158": {"epss_score": 0.02515, "epss_percentile": 0.84981}, "CVE-2020-3159": {"epss_score": 0.00319, "epss_percentile": 0.54468}, "CVE-2020-3160": {"epss_score": 0.00727, "epss_percentile": 0.72102}, "CVE-2020-3161": {"epss_score": 0.83148, "epss_percentile": 0.99233}, "CVE-2020-3162": {"epss_score": 0.01416, "epss_percentile": 0.80141}, "CVE-2020-3163": {"epss_score": 0.00348, "epss_percentile": 0.56808}, "CVE-2020-3164": {"epss_score": 0.00813, "epss_percentile": 0.73766}, "CVE-2020-3165": {"epss_score": 0.00618, "epss_percentile": 0.69382}, "CVE-2020-3166": {"epss_score": 0.00171, "epss_percentile": 0.3877}, "CVE-2020-3167": {"epss_score": 0.00251, "epss_percentile": 0.4828}, "CVE-2020-3168": {"epss_score": 0.02426, "epss_percentile": 0.84715}, "CVE-2020-3169": {"epss_score": 0.00146, "epss_percentile": 0.35545}, "CVE-2020-3170": {"epss_score": 0.004, "epss_percentile": 0.60155}, "CVE-2020-3171": {"epss_score": 0.00174, "epss_percentile": 0.39217}, "CVE-2020-3172": {"epss_score": 0.01078, "epss_percentile": 0.7735}, "CVE-2020-3173": {"epss_score": 0.0024, "epss_percentile": 0.46958}, "CVE-2020-3174": {"epss_score": 0.00103, "epss_percentile": 0.29043}, "CVE-2020-3175": {"epss_score": 0.02588, "epss_percentile": 0.85173}, "CVE-2020-3176": {"epss_score": 0.00107, "epss_percentile": 0.29717}, "CVE-2020-3177": {"epss_score": 0.00948, "epss_percentile": 0.75826}, "CVE-2020-3178": {"epss_score": 0.00249, "epss_percentile": 0.4804}, "CVE-2020-3179": {"epss_score": 0.01156, "epss_percentile": 0.78087}, "CVE-2020-3180": {"epss_score": 0.00096, "epss_percentile": 0.27301}, "CVE-2020-3181": {"epss_score": 0.00525, "epss_percentile": 0.6639}, "CVE-2020-3182": {"epss_score": 0.00208, "epss_percentile": 0.43293}, "CVE-2020-3184": {"epss_score": 0.0038, "epss_percentile": 0.58973}, "CVE-2020-3185": {"epss_score": 0.00294, "epss_percentile": 0.52405}, "CVE-2020-3186": {"epss_score": 0.00184, "epss_percentile": 0.40437}, "CVE-2020-3187": {"epss_score": 0.94341, "epss_percentile": 0.99952}, "CVE-2020-3188": {"epss_score": 0.00555, "epss_percentile": 0.67475}, "CVE-2020-3189": {"epss_score": 0.01311, "epss_percentile": 0.79368}, "CVE-2020-3190": {"epss_score": 0.00961, "epss_percentile": 0.75973}, "CVE-2020-3191": {"epss_score": 0.0104, "epss_percentile": 0.76961}, "CVE-2020-3192": {"epss_score": 0.00234, "epss_percentile": 0.46198}, "CVE-2020-3193": {"epss_score": 0.00881, "epss_percentile": 0.74881}, "CVE-2020-3194": {"epss_score": 0.00789, "epss_percentile": 0.7335}, "CVE-2020-3195": {"epss_score": 0.01311, "epss_percentile": 0.79368}, "CVE-2020-3196": {"epss_score": 0.01858, "epss_percentile": 0.82579}, "CVE-2020-3197": {"epss_score": 0.00374, "epss_percentile": 0.58584}, "CVE-2020-3198": {"epss_score": 0.16401, "epss_percentile": 0.94646}, "CVE-2020-3199": {"epss_score": 0.00116, "epss_percentile": 0.31175}, "CVE-2020-3200": {"epss_score": 0.00308, "epss_percentile": 0.53623}, "CVE-2020-3201": {"epss_score": 0.00033, "epss_percentile": 0.09174}, "CVE-2020-3203": {"epss_score": 0.00756, "epss_percentile": 0.72747}, "CVE-2020-3204": {"epss_score": 0.00063, "epss_percentile": 0.19974}, "CVE-2020-3205": {"epss_score": 0.00282, "epss_percentile": 0.51217}, "CVE-2020-3206": {"epss_score": 0.00133, "epss_percentile": 0.33691}, "CVE-2020-3207": {"epss_score": 0.00208, "epss_percentile": 0.43223}, "CVE-2020-3208": {"epss_score": 0.00055, "epss_percentile": 0.17505}, "CVE-2020-3209": {"epss_score": 0.00045, "epss_percentile": 0.13815}, "CVE-2020-3210": {"epss_score": 0.00047, "epss_percentile": 0.14484}, "CVE-2020-3211": {"epss_score": 0.01588, "epss_percentile": 0.81187}, "CVE-2020-3212": {"epss_score": 0.01809, "epss_percentile": 0.82361}, "CVE-2020-3213": {"epss_score": 0.00042, "epss_percentile": 0.12701}, "CVE-2020-3214": {"epss_score": 0.00049, "epss_percentile": 0.15468}, "CVE-2020-3215": {"epss_score": 0.00059, "epss_percentile": 0.18676}, "CVE-2020-3216": {"epss_score": 0.0009, "epss_percentile": 0.26145}, "CVE-2020-3217": {"epss_score": 0.00244, "epss_percentile": 0.47614}, "CVE-2020-3218": {"epss_score": 0.01703, "epss_percentile": 0.81843}, "CVE-2020-3219": {"epss_score": 0.00637, "epss_percentile": 0.69896}, "CVE-2020-3220": {"epss_score": 0.00419, "epss_percentile": 0.61373}, "CVE-2020-3221": {"epss_score": 0.00504, "epss_percentile": 0.65518}, "CVE-2020-3222": {"epss_score": 0.00068, "epss_percentile": 0.21339}, "CVE-2020-3223": {"epss_score": 0.00253, "epss_percentile": 0.48457}, "CVE-2020-3224": {"epss_score": 0.00346, "epss_percentile": 0.56611}, "CVE-2020-3225": {"epss_score": 0.01033, "epss_percentile": 0.7687}, "CVE-2020-3226": {"epss_score": 0.01033, "epss_percentile": 0.7687}, "CVE-2020-3227": {"epss_score": 0.13371, "epss_percentile": 0.93944}, "CVE-2020-3228": {"epss_score": 0.01644, "epss_percentile": 0.81521}, "CVE-2020-3229": {"epss_score": 0.01016, "epss_percentile": 0.76677}, "CVE-2020-3230": {"epss_score": 0.01961, "epss_percentile": 0.83063}, "CVE-2020-3231": {"epss_score": 0.0007, "epss_percentile": 0.2166}, "CVE-2020-3232": {"epss_score": 0.00328, "epss_percentile": 0.55276}, "CVE-2020-3233": {"epss_score": 0.00167, "epss_percentile": 0.3839}, "CVE-2020-3234": {"epss_score": 0.00046, "epss_percentile": 0.14323}, "CVE-2020-3235": {"epss_score": 0.00287, "epss_percentile": 0.51852}, "CVE-2020-3236": {"epss_score": 0.00046, "epss_percentile": 0.14297}, "CVE-2020-3237": {"epss_score": 0.00046, "epss_percentile": 0.14362}, "CVE-2020-3238": {"epss_score": 0.00407, "epss_percentile": 0.60605}, "CVE-2020-3239": {"epss_score": 0.38705, "epss_percentile": 0.97116}, "CVE-2020-3240": {"epss_score": 0.38933, "epss_percentile": 0.97127}, "CVE-2020-3241": {"epss_score": 0.00497, "epss_percentile": 0.65202}, "CVE-2020-3242": {"epss_score": 0.00256, "epss_percentile": 0.48774}, "CVE-2020-3243": {"epss_score": 0.82533, "epss_percentile": 0.99199}, "CVE-2020-3244": {"epss_score": 0.00418, "epss_percentile": 0.61268}, "CVE-2020-3245": {"epss_score": 0.0021, "epss_percentile": 0.4349}, "CVE-2020-3246": {"epss_score": 0.00161, "epss_percentile": 0.3753}, "CVE-2020-3247": {"epss_score": 0.46067, "epss_percentile": 0.9752}, "CVE-2020-3248": {"epss_score": 0.46067, "epss_percentile": 0.9752}, "CVE-2020-3249": {"epss_score": 0.26235, "epss_percentile": 0.96127}, "CVE-2020-3250": {"epss_score": 0.89688, "epss_percentile": 0.99538}, "CVE-2020-3251": {"epss_score": 0.30726, "epss_percentile": 0.96563}, "CVE-2020-3252": {"epss_score": 0.09025, "epss_percentile": 0.92373}, "CVE-2020-3253": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2020-3254": {"epss_score": 0.01156, "epss_percentile": 0.78087}, "CVE-2020-3255": {"epss_score": 0.01311, "epss_percentile": 0.79368}, "CVE-2020-3256": {"epss_score": 0.00341, "epss_percentile": 0.56319}, "CVE-2020-3257": {"epss_score": 0.0012, "epss_percentile": 0.31755}, "CVE-2020-3258": {"epss_score": 0.16401, "epss_percentile": 0.94646}, "CVE-2020-3259": {"epss_score": 0.69725, "epss_percentile": 0.986}, "CVE-2020-3260": {"epss_score": 0.00308, "epss_percentile": 0.53603}, "CVE-2020-3261": {"epss_score": 0.00293, "epss_percentile": 0.52345}, "CVE-2020-3262": {"epss_score": 0.01407, "epss_percentile": 0.8006}, "CVE-2020-3263": {"epss_score": 0.01758, "epss_percentile": 0.82138}, "CVE-2020-3264": {"epss_score": 0.00144, "epss_percentile": 0.35261}, "CVE-2020-3265": {"epss_score": 0.00147, "epss_percentile": 0.35655}, "CVE-2020-3266": {"epss_score": 0.00176, "epss_percentile": 0.39484}, "CVE-2020-3267": {"epss_score": 0.00329, "epss_percentile": 0.55395}, "CVE-2020-3268": {"epss_score": 0.01464, "epss_percentile": 0.80447}, "CVE-2020-3269": {"epss_score": 0.01464, "epss_percentile": 0.80447}, "CVE-2020-3272": {"epss_score": 0.00358, "epss_percentile": 0.57531}, "CVE-2020-3273": {"epss_score": 0.00641, "epss_percentile": 0.69988}, "CVE-2020-3274": {"epss_score": 0.01809, "epss_percentile": 0.82361}, "CVE-2020-3275": {"epss_score": 0.01809, "epss_percentile": 0.82361}, "CVE-2020-3276": {"epss_score": 0.01809, "epss_percentile": 0.82361}, "CVE-2020-3277": {"epss_score": 0.01809, "epss_percentile": 0.82361}, "CVE-2020-3278": {"epss_score": 0.01809, "epss_percentile": 0.82361}, "CVE-2020-3279": {"epss_score": 0.01809, "epss_percentile": 0.82361}, "CVE-2020-3280": {"epss_score": 0.06345, "epss_percentile": 0.90687}, "CVE-2020-3281": {"epss_score": 0.00343, "epss_percentile": 0.56408}, "CVE-2020-3282": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2020-3283": {"epss_score": 0.01311, "epss_percentile": 0.79368}, "CVE-2020-3284": {"epss_score": 0.04583, "epss_percentile": 0.8888}, "CVE-2020-3285": {"epss_score": 0.00205, "epss_percentile": 0.42754}, "CVE-2020-3286": {"epss_score": 0.03349, "epss_percentile": 0.86961}, "CVE-2020-3287": {"epss_score": 0.03349, "epss_percentile": 0.86961}, "CVE-2020-3288": {"epss_score": 0.03349, "epss_percentile": 0.86961}, "CVE-2020-3289": {"epss_score": 0.03349, "epss_percentile": 0.86961}, "CVE-2020-3290": {"epss_score": 0.03349, "epss_percentile": 0.86961}, "CVE-2020-3291": {"epss_score": 0.03349, "epss_percentile": 0.86961}, "CVE-2020-3292": {"epss_score": 0.03349, "epss_percentile": 0.86961}, "CVE-2020-3293": {"epss_score": 0.03349, "epss_percentile": 0.86961}, "CVE-2020-3294": {"epss_score": 0.03349, "epss_percentile": 0.86961}, "CVE-2020-3295": {"epss_score": 0.03349, "epss_percentile": 0.86961}, "CVE-2020-3296": {"epss_score": 0.03349, "epss_percentile": 0.86961}, "CVE-2020-3297": {"epss_score": 0.0541, "epss_percentile": 0.89844}, "CVE-2020-3298": {"epss_score": 0.01156, "epss_percentile": 0.78087}, "CVE-2020-3299": {"epss_score": 0.00571, "epss_percentile": 0.6799}, "CVE-2020-3301": {"epss_score": 0.00199, "epss_percentile": 0.42119}, "CVE-2020-3302": {"epss_score": 0.00527, "epss_percentile": 0.66525}, "CVE-2020-3303": {"epss_score": 0.00459, "epss_percentile": 0.63456}, "CVE-2020-3304": {"epss_score": 0.00498, "epss_percentile": 0.65212}, "CVE-2020-3305": {"epss_score": 0.00596, "epss_percentile": 0.68716}, "CVE-2020-3306": {"epss_score": 0.00233, "epss_percentile": 0.46011}, "CVE-2020-3307": {"epss_score": 0.00164, "epss_percentile": 0.37956}, "CVE-2020-3308": {"epss_score": 0.0008, "epss_percentile": 0.24039}, "CVE-2020-3309": {"epss_score": 0.00878, "epss_percentile": 0.74816}, "CVE-2020-3310": {"epss_score": 0.00423, "epss_percentile": 0.61588}, "CVE-2020-3311": {"epss_score": 0.00263, "epss_percentile": 0.49514}, "CVE-2020-3312": {"epss_score": 0.0055, "epss_percentile": 0.67344}, "CVE-2020-3313": {"epss_score": 0.00133, "epss_percentile": 0.33729}, "CVE-2020-3314": {"epss_score": 0.00237, "epss_percentile": 0.46465}, "CVE-2020-3315": {"epss_score": 0.00215, "epss_percentile": 0.44105}, "CVE-2020-3317": {"epss_score": 0.00435, "epss_percentile": 0.62351}, "CVE-2020-3318": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2020-3319": {"epss_score": 0.00348, "epss_percentile": 0.56801}, "CVE-2020-3320": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2020-3321": {"epss_score": 0.00348, "epss_percentile": 0.56801}, "CVE-2020-3322": {"epss_score": 0.00348, "epss_percentile": 0.56801}, "CVE-2020-3323": {"epss_score": 0.02842, "epss_percentile": 0.8581}, "CVE-2020-3327": {"epss_score": 0.08026, "epss_percentile": 0.91838}, "CVE-2020-3329": {"epss_score": 0.00139, "epss_percentile": 0.34552}, "CVE-2020-3330": {"epss_score": 0.05356, "epss_percentile": 0.89779}, "CVE-2020-3331": {"epss_score": 0.26257, "epss_percentile": 0.9613}, "CVE-2020-3332": {"epss_score": 0.01977, "epss_percentile": 0.83126}, "CVE-2020-3333": {"epss_score": 0.00552, "epss_percentile": 0.67401}, "CVE-2020-3334": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3335": {"epss_score": 0.00044, "epss_percentile": 0.13666}, "CVE-2020-3336": {"epss_score": 0.01388, "epss_percentile": 0.79923}, "CVE-2020-3337": {"epss_score": 0.00063, "epss_percentile": 0.19819}, "CVE-2020-3338": {"epss_score": 0.01858, "epss_percentile": 0.82579}, "CVE-2020-3339": {"epss_score": 0.00171, "epss_percentile": 0.38789}, "CVE-2020-3340": {"epss_score": 0.0017, "epss_percentile": 0.38656}, "CVE-2020-3341": {"epss_score": 0.04112, "epss_percentile": 0.88274}, "CVE-2020-3342": {"epss_score": 0.00996, "epss_percentile": 0.76444}, "CVE-2020-3343": {"epss_score": 0.00034, "epss_percentile": 0.09655}, "CVE-2020-3344": {"epss_score": 0.00034, "epss_percentile": 0.09655}, "CVE-2020-3345": {"epss_score": 0.00535, "epss_percentile": 0.66829}, "CVE-2020-3346": {"epss_score": 0.00346, "epss_percentile": 0.56627}, "CVE-2020-3347": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2020-3348": {"epss_score": 0.00192, "epss_percentile": 0.41349}, "CVE-2020-3349": {"epss_score": 0.00192, "epss_percentile": 0.41349}, "CVE-2020-3350": {"epss_score": 0.0014, "epss_percentile": 0.34785}, "CVE-2020-3351": {"epss_score": 0.00564, "epss_percentile": 0.67777}, "CVE-2020-3352": {"epss_score": 0.00056, "epss_percentile": 0.1775}, "CVE-2020-3353": {"epss_score": 0.00377, "epss_percentile": 0.58774}, "CVE-2020-3354": {"epss_score": 0.00192, "epss_percentile": 0.41349}, "CVE-2020-3355": {"epss_score": 0.00192, "epss_percentile": 0.41349}, "CVE-2020-3356": {"epss_score": 0.00208, "epss_percentile": 0.43279}, "CVE-2020-3357": {"epss_score": 0.04116, "epss_percentile": 0.88278}, "CVE-2020-3358": {"epss_score": 0.00201, "epss_percentile": 0.4232}, "CVE-2020-3359": {"epss_score": 0.00564, "epss_percentile": 0.67777}, "CVE-2020-3360": {"epss_score": 0.00358, "epss_percentile": 0.57537}, "CVE-2020-3361": {"epss_score": 0.01788, "epss_percentile": 0.82267}, "CVE-2020-3362": {"epss_score": 0.00061, "epss_percentile": 0.19258}, "CVE-2020-3363": {"epss_score": 0.00641, "epss_percentile": 0.69988}, "CVE-2020-3364": {"epss_score": 0.00528, "epss_percentile": 0.66534}, "CVE-2020-3365": {"epss_score": 0.00321, "epss_percentile": 0.54678}, "CVE-2020-3367": {"epss_score": 0.00309, "epss_percentile": 0.53663}, "CVE-2020-3368": {"epss_score": 0.00214, "epss_percentile": 0.44005}, "CVE-2020-3369": {"epss_score": 0.01156, "epss_percentile": 0.78087}, "CVE-2020-3370": {"epss_score": 0.00214, "epss_percentile": 0.44005}, "CVE-2020-3371": {"epss_score": 0.01911, "epss_percentile": 0.8283}, "CVE-2020-3372": {"epss_score": 0.00169, "epss_percentile": 0.38561}, "CVE-2020-3373": {"epss_score": 0.0191, "epss_percentile": 0.82827}, "CVE-2020-3374": {"epss_score": 0.00105, "epss_percentile": 0.29357}, "CVE-2020-3375": {"epss_score": 0.01992, "epss_percentile": 0.8318}, "CVE-2020-3376": {"epss_score": 0.00892, "epss_percentile": 0.75064}, "CVE-2020-3377": {"epss_score": 0.00659, "epss_percentile": 0.70501}, "CVE-2020-3378": {"epss_score": 0.00163, "epss_percentile": 0.37819}, "CVE-2020-3379": {"epss_score": 0.00057, "epss_percentile": 0.18135}, "CVE-2020-3380": {"epss_score": 0.00196, "epss_percentile": 0.41793}, "CVE-2020-3381": {"epss_score": 0.00641, "epss_percentile": 0.69988}, "CVE-2020-3382": {"epss_score": 0.13058, "epss_percentile": 0.93861}, "CVE-2020-3383": {"epss_score": 0.0199, "epss_percentile": 0.83173}, "CVE-2020-3384": {"epss_score": 0.0049, "epss_percentile": 0.64928}, "CVE-2020-3385": {"epss_score": 0.00052, "epss_percentile": 0.16618}, "CVE-2020-3386": {"epss_score": 0.01038, "epss_percentile": 0.76932}, "CVE-2020-3387": {"epss_score": 0.45692, "epss_percentile": 0.97498}, "CVE-2020-3388": {"epss_score": 0.00049, "epss_percentile": 0.15436}, "CVE-2020-3389": {"epss_score": 0.00037, "epss_percentile": 0.10893}, "CVE-2020-3390": {"epss_score": 0.00133, "epss_percentile": 0.33673}, "CVE-2020-3391": {"epss_score": 0.00196, "epss_percentile": 0.41794}, "CVE-2020-3392": {"epss_score": 0.01638, "epss_percentile": 0.81484}, "CVE-2020-3393": {"epss_score": 0.00031, "epss_percentile": 0.08709}, "CVE-2020-3394": {"epss_score": 0.00108, "epss_percentile": 0.29816}, "CVE-2020-3396": {"epss_score": 0.00052, "epss_percentile": 0.16602}, "CVE-2020-3397": {"epss_score": 0.01002, "epss_percentile": 0.76504}, "CVE-2020-3398": {"epss_score": 0.01387, "epss_percentile": 0.79917}, "CVE-2020-3399": {"epss_score": 0.00564, "epss_percentile": 0.67777}, "CVE-2020-3400": {"epss_score": 0.00196, "epss_percentile": 0.41821}, "CVE-2020-3401": {"epss_score": 0.00064, "epss_percentile": 0.20128}, "CVE-2020-3402": {"epss_score": 0.00514, "epss_percentile": 0.65952}, "CVE-2020-3403": {"epss_score": 0.00098, "epss_percentile": 0.27672}, "CVE-2020-3404": {"epss_score": 0.00023, "epss_percentile": 0.05396}, "CVE-2020-3405": {"epss_score": 0.00313, "epss_percentile": 0.5403}, "CVE-2020-3406": {"epss_score": 0.00181, "epss_percentile": 0.40081}, "CVE-2020-3407": {"epss_score": 0.01258, "epss_percentile": 0.78956}, "CVE-2020-3408": {"epss_score": 0.01156, "epss_percentile": 0.78087}, "CVE-2020-3409": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3410": {"epss_score": 0.00637, "epss_percentile": 0.69882}, "CVE-2020-3411": {"epss_score": 0.00287, "epss_percentile": 0.51805}, "CVE-2020-3412": {"epss_score": 0.00128, "epss_percentile": 0.32965}, "CVE-2020-3413": {"epss_score": 0.00128, "epss_percentile": 0.32965}, "CVE-2020-3414": {"epss_score": 0.01033, "epss_percentile": 0.7687}, "CVE-2020-3415": {"epss_score": 0.00214, "epss_percentile": 0.43959}, "CVE-2020-3416": {"epss_score": 0.00195, "epss_percentile": 0.41707}, "CVE-2020-3417": {"epss_score": 0.00084, "epss_percentile": 0.24971}, "CVE-2020-3418": {"epss_score": 0.00062, "epss_percentile": 0.19788}, "CVE-2020-3419": {"epss_score": 0.00472, "epss_percentile": 0.64067}, "CVE-2020-3420": {"epss_score": 0.00072, "epss_percentile": 0.22391}, "CVE-2020-3421": {"epss_score": 0.00966, "epss_percentile": 0.76063}, "CVE-2020-3422": {"epss_score": 0.01023, "epss_percentile": 0.76768}, "CVE-2020-3423": {"epss_score": 0.00058, "epss_percentile": 0.18573}, "CVE-2020-3425": {"epss_score": 0.00982, "epss_percentile": 0.76286}, "CVE-2020-3426": {"epss_score": 0.00525, "epss_percentile": 0.66379}, "CVE-2020-3427": {"epss_score": 0.00028, "epss_percentile": 0.07579}, "CVE-2020-3428": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2020-3429": {"epss_score": 0.00133, "epss_percentile": 0.33673}, "CVE-2020-3430": {"epss_score": 0.05306, "epss_percentile": 0.89712}, "CVE-2020-3431": {"epss_score": 0.00066, "epss_percentile": 0.20929}, "CVE-2020-3432": {"epss_score": 0.00035, "epss_percentile": 0.09981}, "CVE-2020-3433": {"epss_score": 0.04462, "epss_percentile": 0.88725}, "CVE-2020-3434": {"epss_score": 0.00161, "epss_percentile": 0.37538}, "CVE-2020-3435": {"epss_score": 0.0017, "epss_percentile": 0.38677}, "CVE-2020-3436": {"epss_score": 0.02146, "epss_percentile": 0.83766}, "CVE-2020-3437": {"epss_score": 0.01232, "epss_percentile": 0.7874}, "CVE-2020-3439": {"epss_score": 0.0017, "epss_percentile": 0.38656}, "CVE-2020-3440": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2020-3441": {"epss_score": 0.00864, "epss_percentile": 0.74607}, "CVE-2020-3442": {"epss_score": 0.00022, "epss_percentile": 0.05175}, "CVE-2020-3443": {"epss_score": 0.00773, "epss_percentile": 0.73051}, "CVE-2020-3444": {"epss_score": 0.00778, "epss_percentile": 0.73131}, "CVE-2020-3446": {"epss_score": 0.01642, "epss_percentile": 0.81512}, "CVE-2020-3447": {"epss_score": 0.00219, "epss_percentile": 0.44495}, "CVE-2020-3448": {"epss_score": 0.00571, "epss_percentile": 0.67992}, "CVE-2020-3449": {"epss_score": 0.00473, "epss_percentile": 0.64078}, "CVE-2020-3450": {"epss_score": 0.00183, "epss_percentile": 0.40288}, "CVE-2020-3451": {"epss_score": 0.00524, "epss_percentile": 0.66361}, "CVE-2020-3452": {"epss_score": 0.94452, "epss_percentile": 0.99991}, "CVE-2020-3453": {"epss_score": 0.01398, "epss_percentile": 0.79988}, "CVE-2020-3454": {"epss_score": 0.01756, "epss_percentile": 0.82124}, "CVE-2020-3455": {"epss_score": 0.00062, "epss_percentile": 0.19745}, "CVE-2020-3456": {"epss_score": 0.0025, "epss_percentile": 0.48243}, "CVE-2020-3457": {"epss_score": 0.00151, "epss_percentile": 0.36226}, "CVE-2020-3458": {"epss_score": 0.00053, "epss_percentile": 0.16711}, "CVE-2020-3459": {"epss_score": 0.00176, "epss_percentile": 0.39382}, "CVE-2020-3460": {"epss_score": 0.00469, "epss_percentile": 0.63957}, "CVE-2020-3461": {"epss_score": 0.00553, "epss_percentile": 0.6741}, "CVE-2020-3462": {"epss_score": 0.00267, "epss_percentile": 0.49997}, "CVE-2020-3463": {"epss_score": 0.00406, "epss_percentile": 0.60525}, "CVE-2020-3464": {"epss_score": 0.0017, "epss_percentile": 0.38656}, "CVE-2020-3465": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3466": {"epss_score": 0.00346, "epss_percentile": 0.56627}, "CVE-2020-3467": {"epss_score": 0.00127, "epss_percentile": 0.32913}, "CVE-2020-3468": {"epss_score": 0.0015, "epss_percentile": 0.3615}, "CVE-2020-3470": {"epss_score": 0.03203, "epss_percentile": 0.86626}, "CVE-2020-3471": {"epss_score": 0.00625, "epss_percentile": 0.69589}, "CVE-2020-3472": {"epss_score": 0.00125, "epss_percentile": 0.32556}, "CVE-2020-3473": {"epss_score": 0.00043, "epss_percentile": 0.13263}, "CVE-2020-3474": {"epss_score": 0.0017, "epss_percentile": 0.3874}, "CVE-2020-3475": {"epss_score": 0.00216, "epss_percentile": 0.4422}, "CVE-2020-3476": {"epss_score": 0.00064, "epss_percentile": 0.20331}, "CVE-2020-3477": {"epss_score": 0.0005, "epss_percentile": 0.15709}, "CVE-2020-3478": {"epss_score": 0.00543, "epss_percentile": 0.67102}, "CVE-2020-3479": {"epss_score": 0.0039, "epss_percentile": 0.59552}, "CVE-2020-3480": {"epss_score": 0.01156, "epss_percentile": 0.78087}, "CVE-2020-3481": {"epss_score": 0.0298, "epss_percentile": 0.86116}, "CVE-2020-3482": {"epss_score": 0.00197, "epss_percentile": 0.41862}, "CVE-2020-3483": {"epss_score": 0.00033, "epss_percentile": 0.09153}, "CVE-2020-3484": {"epss_score": 0.00108, "epss_percentile": 0.29757}, "CVE-2020-3485": {"epss_score": 0.00065, "epss_percentile": 0.2044}, "CVE-2020-3486": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3487": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3488": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3489": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3490": {"epss_score": 0.00241, "epss_percentile": 0.47277}, "CVE-2020-3491": {"epss_score": 0.0021, "epss_percentile": 0.43497}, "CVE-2020-3492": {"epss_score": 0.00564, "epss_percentile": 0.67777}, "CVE-2020-3493": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3494": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3495": {"epss_score": 0.09144, "epss_percentile": 0.92421}, "CVE-2020-3496": {"epss_score": 0.00351, "epss_percentile": 0.57036}, "CVE-2020-3497": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3498": {"epss_score": 0.00307, "epss_percentile": 0.53518}, "CVE-2020-3499": {"epss_score": 0.01311, "epss_percentile": 0.79368}, "CVE-2020-3500": {"epss_score": 0.0029, "epss_percentile": 0.52106}, "CVE-2020-3501": {"epss_score": 0.00164, "epss_percentile": 0.37988}, "CVE-2020-3502": {"epss_score": 0.00164, "epss_percentile": 0.37988}, "CVE-2020-3503": {"epss_score": 0.00036, "epss_percentile": 0.10355}, "CVE-2020-3504": {"epss_score": 0.00168, "epss_percentile": 0.3842}, "CVE-2020-3505": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3506": {"epss_score": 0.00116, "epss_percentile": 0.31175}, "CVE-2020-3507": {"epss_score": 0.00116, "epss_percentile": 0.31175}, "CVE-2020-3508": {"epss_score": 0.00076, "epss_percentile": 0.23158}, "CVE-2020-3509": {"epss_score": 0.01156, "epss_percentile": 0.78087}, "CVE-2020-3510": {"epss_score": 0.00754, "epss_percentile": 0.72709}, "CVE-2020-3511": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3512": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3513": {"epss_score": 0.00195, "epss_percentile": 0.41707}, "CVE-2020-3514": {"epss_score": 0.00031, "epss_percentile": 0.08435}, "CVE-2020-3515": {"epss_score": 0.00159, "epss_percentile": 0.37361}, "CVE-2020-3516": {"epss_score": 0.00628, "epss_percentile": 0.69667}, "CVE-2020-3517": {"epss_score": 0.0151, "epss_percentile": 0.80771}, "CVE-2020-3518": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2020-3519": {"epss_score": 0.00407, "epss_percentile": 0.60605}, "CVE-2020-3520": {"epss_score": 0.00061, "epss_percentile": 0.19258}, "CVE-2020-3521": {"epss_score": 0.00202, "epss_percentile": 0.42467}, "CVE-2020-3522": {"epss_score": 0.00156, "epss_percentile": 0.36891}, "CVE-2020-3523": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2020-3524": {"epss_score": 0.00072, "epss_percentile": 0.22467}, "CVE-2020-3525": {"epss_score": 0.0015, "epss_percentile": 0.36105}, "CVE-2020-3526": {"epss_score": 0.00564, "epss_percentile": 0.67777}, "CVE-2020-3527": {"epss_score": 0.00683, "epss_percentile": 0.71107}, "CVE-2020-3528": {"epss_score": 0.00912, "epss_percentile": 0.75361}, "CVE-2020-3529": {"epss_score": 0.01311, "epss_percentile": 0.79368}, "CVE-2020-3530": {"epss_score": 0.0003, "epss_percentile": 0.08148}, "CVE-2020-3531": {"epss_score": 0.04838, "epss_percentile": 0.89197}, "CVE-2020-3532": {"epss_score": 0.00123, "epss_percentile": 0.32302}, "CVE-2020-3533": {"epss_score": 0.01311, "epss_percentile": 0.79368}, "CVE-2020-3535": {"epss_score": 0.00054, "epss_percentile": 0.17242}, "CVE-2020-3536": {"epss_score": 0.00154, "epss_percentile": 0.36675}, "CVE-2020-3537": {"epss_score": 0.00364, "epss_percentile": 0.57919}, "CVE-2020-3538": {"epss_score": 0.00111, "epss_percentile": 0.3025}, "CVE-2020-3539": {"epss_score": 0.0032, "epss_percentile": 0.54573}, "CVE-2020-3541": {"epss_score": 0.00062, "epss_percentile": 0.19606}, "CVE-2020-3542": {"epss_score": 0.00266, "epss_percentile": 0.49864}, "CVE-2020-3543": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3544": {"epss_score": 0.00116, "epss_percentile": 0.31175}, "CVE-2020-3545": {"epss_score": 0.0006, "epss_percentile": 0.19198}, "CVE-2020-3546": {"epss_score": 0.00563, "epss_percentile": 0.67733}, "CVE-2020-3547": {"epss_score": 0.00172, "epss_percentile": 0.38946}, "CVE-2020-3548": {"epss_score": 0.0043, "epss_percentile": 0.6203}, "CVE-2020-3549": {"epss_score": 0.00529, "epss_percentile": 0.66602}, "CVE-2020-3550": {"epss_score": 0.00332, "epss_percentile": 0.55574}, "CVE-2020-3551": {"epss_score": 0.00346, "epss_percentile": 0.56627}, "CVE-2020-3552": {"epss_score": 0.00101, "epss_percentile": 0.28664}, "CVE-2020-3553": {"epss_score": 0.0014, "epss_percentile": 0.34767}, "CVE-2020-3554": {"epss_score": 0.03181, "epss_percentile": 0.8658}, "CVE-2020-3555": {"epss_score": 0.00596, "epss_percentile": 0.68716}, "CVE-2020-3556": {"epss_score": 0.00236, "epss_percentile": 0.4642}, "CVE-2020-3557": {"epss_score": 0.00194, "epss_percentile": 0.4152}, "CVE-2020-3558": {"epss_score": 0.00249, "epss_percentile": 0.4804}, "CVE-2020-3559": {"epss_score": 0.01276, "epss_percentile": 0.79111}, "CVE-2020-3560": {"epss_score": 0.01156, "epss_percentile": 0.78087}, "CVE-2020-3561": {"epss_score": 0.00363, "epss_percentile": 0.5783}, "CVE-2020-3562": {"epss_score": 0.00528, "epss_percentile": 0.66552}, "CVE-2020-3563": {"epss_score": 0.01156, "epss_percentile": 0.78087}, "CVE-2020-3564": {"epss_score": 0.00253, "epss_percentile": 0.48475}, "CVE-2020-3565": {"epss_score": 0.00199, "epss_percentile": 0.42174}, "CVE-2020-3566": {"epss_score": 0.07174, "epss_percentile": 0.91299}, "CVE-2020-3567": {"epss_score": 0.00368, "epss_percentile": 0.58178}, "CVE-2020-3568": {"epss_score": 0.00214, "epss_percentile": 0.44005}, "CVE-2020-3569": {"epss_score": 0.16091, "epss_percentile": 0.94571}, "CVE-2020-3571": {"epss_score": 0.00564, "epss_percentile": 0.67777}, "CVE-2020-3572": {"epss_score": 0.01858, "epss_percentile": 0.82579}, "CVE-2020-3573": {"epss_score": 0.00422, "epss_percentile": 0.61543}, "CVE-2020-3574": {"epss_score": 0.03181, "epss_percentile": 0.8658}, "CVE-2020-3577": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2020-3578": {"epss_score": 0.00183, "epss_percentile": 0.40291}, "CVE-2020-3579": {"epss_score": 0.00346, "epss_percentile": 0.56627}, "CVE-2020-3580": {"epss_score": 0.92448, "epss_percentile": 0.99715}, "CVE-2020-3581": {"epss_score": 0.00238, "epss_percentile": 0.4679}, "CVE-2020-3582": {"epss_score": 0.00238, "epss_percentile": 0.4679}, "CVE-2020-3583": {"epss_score": 0.00299, "epss_percentile": 0.52849}, "CVE-2020-3585": {"epss_score": 0.00365, "epss_percentile": 0.57993}, "CVE-2020-3586": {"epss_score": 0.02231, "epss_percentile": 0.84086}, "CVE-2020-3587": {"epss_score": 0.00181, "epss_percentile": 0.40081}, "CVE-2020-3588": {"epss_score": 0.00047, "epss_percentile": 0.14828}, "CVE-2020-3589": {"epss_score": 0.00192, "epss_percentile": 0.41349}, "CVE-2020-3590": {"epss_score": 0.00181, "epss_percentile": 0.40081}, "CVE-2020-3591": {"epss_score": 0.0019, "epss_percentile": 0.41135}, "CVE-2020-3592": {"epss_score": 0.00033, "epss_percentile": 0.09132}, "CVE-2020-3593": {"epss_score": 0.00036, "epss_percentile": 0.10378}, "CVE-2020-3594": {"epss_score": 0.00036, "epss_percentile": 0.10378}, "CVE-2020-3595": {"epss_score": 0.00027, "epss_percentile": 0.07088}, "CVE-2020-3596": {"epss_score": 0.00596, "epss_percentile": 0.68716}, "CVE-2020-3597": {"epss_score": 0.00642, "epss_percentile": 0.7004}, "CVE-2020-3598": {"epss_score": 0.00256, "epss_percentile": 0.48775}, "CVE-2020-3599": {"epss_score": 0.00346, "epss_percentile": 0.56627}, "CVE-2020-3600": {"epss_score": 0.00036, "epss_percentile": 0.10378}, "CVE-2020-3601": {"epss_score": 0.00114, "epss_percentile": 0.30739}, "CVE-2020-3602": {"epss_score": 0.00125, "epss_percentile": 0.32481}, "CVE-2020-3603": {"epss_score": 0.00422, "epss_percentile": 0.61543}, "CVE-2020-3604": {"epss_score": 0.00422, "epss_percentile": 0.61543}, "CVE-2020-3610": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-3611": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-3613": {"epss_score": 0.00101, "epss_percentile": 0.2868}, "CVE-2020-3614": {"epss_score": 0.00309, "epss_percentile": 0.53673}, "CVE-2020-3615": {"epss_score": 0.00336, "epss_percentile": 0.56001}, "CVE-2020-3616": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2020-3617": {"epss_score": 0.00033, "epss_percentile": 0.09283}, "CVE-2020-3618": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-3619": {"epss_score": 0.00029, "epss_percentile": 0.07605}, "CVE-2020-3620": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2020-3621": {"epss_score": 0.00113, "epss_percentile": 0.3064}, "CVE-2020-3622": {"epss_score": 0.0005, "epss_percentile": 0.15934}, "CVE-2020-3623": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-3624": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2020-3625": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-3626": {"epss_score": 0.00037, "epss_percentile": 0.10678}, "CVE-2020-3628": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-3629": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-3630": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-3632": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-3633": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-3634": {"epss_score": 0.00305, "epss_percentile": 0.53365}, "CVE-2020-3635": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-3636": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-3638": {"epss_score": 0.00032, "epss_percentile": 0.09093}, "CVE-2020-3639": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-3640": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-3641": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-3642": {"epss_score": 0.00044, "epss_percentile": 0.13562}, "CVE-2020-3643": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2020-3644": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2020-3645": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2020-3646": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2020-3647": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2020-3648": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2020-3651": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2020-3652": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2020-3653": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2020-3654": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2020-3656": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-3657": {"epss_score": 0.15553, "epss_percentile": 0.94457}, "CVE-2020-3658": {"epss_score": 0.00317, "epss_percentile": 0.54366}, "CVE-2020-3660": {"epss_score": 0.00317, "epss_percentile": 0.54366}, "CVE-2020-3661": {"epss_score": 0.00285, "epss_percentile": 0.51514}, "CVE-2020-3662": {"epss_score": 0.00196, "epss_percentile": 0.41727}, "CVE-2020-3663": {"epss_score": 0.0014, "epss_percentile": 0.34773}, "CVE-2020-3664": {"epss_score": 0.00036, "epss_percentile": 0.10296}, "CVE-2020-3665": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2020-3666": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-3667": {"epss_score": 0.00214, "epss_percentile": 0.44022}, "CVE-2020-3668": {"epss_score": 0.00454, "epss_percentile": 0.63253}, "CVE-2020-3669": {"epss_score": 0.00379, "epss_percentile": 0.58857}, "CVE-2020-3670": {"epss_score": 0.0032, "epss_percentile": 0.54589}, "CVE-2020-3671": {"epss_score": 0.0031, "epss_percentile": 0.53792}, "CVE-2020-3673": {"epss_score": 0.00268, "epss_percentile": 0.50021}, "CVE-2020-3674": {"epss_score": 0.00096, "epss_percentile": 0.27304}, "CVE-2020-3675": {"epss_score": 0.00374, "epss_percentile": 0.58566}, "CVE-2020-3676": {"epss_score": 0.00129, "epss_percentile": 0.33183}, "CVE-2020-3678": {"epss_score": 0.00128, "epss_percentile": 0.32959}, "CVE-2020-3679": {"epss_score": 0.0025, "epss_percentile": 0.48245}, "CVE-2020-3680": {"epss_score": 0.0015, "epss_percentile": 0.36135}, "CVE-2020-3681": {"epss_score": 0.00353, "epss_percentile": 0.5717}, "CVE-2020-3684": {"epss_score": 0.00077, "epss_percentile": 0.23464}, "CVE-2020-3685": {"epss_score": 0.0021, "epss_percentile": 0.43496}, "CVE-2020-3686": {"epss_score": 0.0022, "epss_percentile": 0.44623}, "CVE-2020-3687": {"epss_score": 0.00036, "epss_percentile": 0.10261}, "CVE-2020-3688": {"epss_score": 0.00371, "epss_percentile": 0.58365}, "CVE-2020-3690": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2020-3691": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2020-3692": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2020-3693": {"epss_score": 0.00048, "epss_percentile": 0.15011}, "CVE-2020-3694": {"epss_score": 0.00048, "epss_percentile": 0.15011}, "CVE-2020-3696": {"epss_score": 0.00044, "epss_percentile": 0.13562}, "CVE-2020-3698": {"epss_score": 0.00296, "epss_percentile": 0.52596}, "CVE-2020-3699": {"epss_score": 0.00296, "epss_percentile": 0.52596}, "CVE-2020-3700": {"epss_score": 0.00436, "epss_percentile": 0.62462}, "CVE-2020-3701": {"epss_score": 0.00096, "epss_percentile": 0.27446}, "CVE-2020-3702": {"epss_score": 0.00261, "epss_percentile": 0.49247}, "CVE-2020-3703": {"epss_score": 0.00294, "epss_percentile": 0.52436}, "CVE-2020-3704": {"epss_score": 0.0019, "epss_percentile": 0.41072}, "CVE-2020-3710": {"epss_score": 0.01413, "epss_percentile": 0.80119}, "CVE-2020-3711": {"epss_score": 0.0284, "epss_percentile": 0.85803}, "CVE-2020-3712": {"epss_score": 0.0284, "epss_percentile": 0.85803}, "CVE-2020-3713": {"epss_score": 0.01413, "epss_percentile": 0.80119}, "CVE-2020-3714": {"epss_score": 0.02642, "epss_percentile": 0.85307}, "CVE-2020-3715": {"epss_score": 0.0027, "epss_percentile": 0.50217}, "CVE-2020-3716": {"epss_score": 0.17339, "epss_percentile": 0.94829}, "CVE-2020-3717": {"epss_score": 0.00276, "epss_percentile": 0.50717}, "CVE-2020-3718": {"epss_score": 0.08697, "epss_percentile": 0.92208}, "CVE-2020-3719": {"epss_score": 0.01514, "epss_percentile": 0.80794}, "CVE-2020-3720": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3721": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3722": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3723": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3724": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3725": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3726": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3727": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3728": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3729": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3730": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3731": {"epss_score": 0.37074, "epss_percentile": 0.97018}, "CVE-2020-3732": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3733": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3734": {"epss_score": 0.2575, "epss_percentile": 0.96063}, "CVE-2020-3735": {"epss_score": 0.37074, "epss_percentile": 0.97018}, "CVE-2020-3736": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3737": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3738": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-3739": {"epss_score": 0.13725, "epss_percentile": 0.94044}, "CVE-2020-3740": {"epss_score": 0.08032, "epss_percentile": 0.91843}, "CVE-2020-3741": {"epss_score": 0.02184, "epss_percentile": 0.83916}, "CVE-2020-3742": {"epss_score": 0.04793, "epss_percentile": 0.89153}, "CVE-2020-3743": {"epss_score": 0.04792, "epss_percentile": 0.89152}, "CVE-2020-3744": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2020-3745": {"epss_score": 0.04792, "epss_percentile": 0.89152}, "CVE-2020-3746": {"epss_score": 0.04792, "epss_percentile": 0.89152}, "CVE-2020-3747": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2020-3748": {"epss_score": 0.03988, "epss_percentile": 0.88067}, "CVE-2020-3749": {"epss_score": 0.04792, "epss_percentile": 0.89152}, "CVE-2020-3750": {"epss_score": 0.04792, "epss_percentile": 0.89152}, "CVE-2020-3751": {"epss_score": 0.04792, "epss_percentile": 0.89152}, "CVE-2020-3752": {"epss_score": 0.03119, "epss_percentile": 0.86442}, "CVE-2020-3753": {"epss_score": 0.01734, "epss_percentile": 0.82005}, "CVE-2020-3754": {"epss_score": 0.02599, "epss_percentile": 0.85204}, "CVE-2020-3755": {"epss_score": 0.01906, "epss_percentile": 0.82808}, "CVE-2020-3756": {"epss_score": 0.01734, "epss_percentile": 0.82005}, "CVE-2020-3757": {"epss_score": 0.05414, "epss_percentile": 0.89849}, "CVE-2020-3758": {"epss_score": 0.00282, "epss_percentile": 0.51213}, "CVE-2020-3759": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2020-3760": {"epss_score": 0.14833, "epss_percentile": 0.94295}, "CVE-2020-3761": {"epss_score": 0.04003, "epss_percentile": 0.88096}, "CVE-2020-3762": {"epss_score": 0.01325, "epss_percentile": 0.79472}, "CVE-2020-3763": {"epss_score": 0.01325, "epss_percentile": 0.79472}, "CVE-2020-3764": {"epss_score": 0.01503, "epss_percentile": 0.80732}, "CVE-2020-3765": {"epss_score": 0.02574, "epss_percentile": 0.85138}, "CVE-2020-3766": {"epss_score": 0.00092, "epss_percentile": 0.26457}, "CVE-2020-3767": {"epss_score": 0.02053, "epss_percentile": 0.83414}, "CVE-2020-3768": {"epss_score": 0.0014, "epss_percentile": 0.34701}, "CVE-2020-3769": {"epss_score": 0.01088, "epss_percentile": 0.77435}, "CVE-2020-3770": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2020-3771": {"epss_score": 0.02393, "epss_percentile": 0.84611}, "CVE-2020-3772": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2020-3773": {"epss_score": 0.13607, "epss_percentile": 0.94011}, "CVE-2020-3774": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2020-3775": {"epss_score": 0.24977, "epss_percentile": 0.95974}, "CVE-2020-3776": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2020-3777": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2020-3778": {"epss_score": 0.02393, "epss_percentile": 0.84611}, "CVE-2020-3779": {"epss_score": 0.13607, "epss_percentile": 0.94011}, "CVE-2020-3780": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2020-3781": {"epss_score": 0.02393, "epss_percentile": 0.84611}, "CVE-2020-3782": {"epss_score": 0.02393, "epss_percentile": 0.84611}, "CVE-2020-3783": {"epss_score": 0.24977, "epss_percentile": 0.95974}, "CVE-2020-3784": {"epss_score": 0.10057, "epss_percentile": 0.92834}, "CVE-2020-3785": {"epss_score": 0.10057, "epss_percentile": 0.92834}, "CVE-2020-3786": {"epss_score": 0.10057, "epss_percentile": 0.92834}, "CVE-2020-3787": {"epss_score": 0.10057, "epss_percentile": 0.92834}, "CVE-2020-3788": {"epss_score": 0.10057, "epss_percentile": 0.92834}, "CVE-2020-3789": {"epss_score": 0.10057, "epss_percentile": 0.92834}, "CVE-2020-3790": {"epss_score": 0.10494, "epss_percentile": 0.93009}, "CVE-2020-3791": {"epss_score": 0.02393, "epss_percentile": 0.84611}, "CVE-2020-3792": {"epss_score": 0.27078, "epss_percentile": 0.96205}, "CVE-2020-3793": {"epss_score": 0.27078, "epss_percentile": 0.96205}, "CVE-2020-3794": {"epss_score": 0.21113, "epss_percentile": 0.95463}, "CVE-2020-3795": {"epss_score": 0.14185, "epss_percentile": 0.94158}, "CVE-2020-3796": {"epss_score": 0.03746, "epss_percentile": 0.87663}, "CVE-2020-3797": {"epss_score": 0.10057, "epss_percentile": 0.92834}, "CVE-2020-3798": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2020-3799": {"epss_score": 0.288, "epss_percentile": 0.96385}, "CVE-2020-3800": {"epss_score": 0.0446, "epss_percentile": 0.88721}, "CVE-2020-3801": {"epss_score": 0.17814, "epss_percentile": 0.94911}, "CVE-2020-3802": {"epss_score": 0.21821, "epss_percentile": 0.95563}, "CVE-2020-3803": {"epss_score": 0.0014, "epss_percentile": 0.34701}, "CVE-2020-3804": {"epss_score": 0.04302, "epss_percentile": 0.88517}, "CVE-2020-3805": {"epss_score": 0.33735, "epss_percentile": 0.968}, "CVE-2020-3806": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2020-3807": {"epss_score": 0.30072, "epss_percentile": 0.96503}, "CVE-2020-3808": {"epss_score": 0.01666, "epss_percentile": 0.8165}, "CVE-2020-3809": {"epss_score": 0.01913, "epss_percentile": 0.82841}, "CVE-2020-3810": {"epss_score": 0.00565, "epss_percentile": 0.67794}, "CVE-2020-3811": {"epss_score": 0.00424, "epss_percentile": 0.61641}, "CVE-2020-3812": {"epss_score": 0.00045, "epss_percentile": 0.13702}, "CVE-2020-3825": {"epss_score": 0.00588, "epss_percentile": 0.68504}, "CVE-2020-3826": {"epss_score": 0.00504, "epss_percentile": 0.6551}, "CVE-2020-3827": {"epss_score": 0.00374, "epss_percentile": 0.58554}, "CVE-2020-3828": {"epss_score": 0.00154, "epss_percentile": 0.36688}, "CVE-2020-3829": {"epss_score": 0.00299, "epss_percentile": 0.52851}, "CVE-2020-3830": {"epss_score": 0.00181, "epss_percentile": 0.40082}, "CVE-2020-3831": {"epss_score": 0.00293, "epss_percentile": 0.52334}, "CVE-2020-3833": {"epss_score": 0.00351, "epss_percentile": 0.57031}, "CVE-2020-3834": {"epss_score": 0.00374, "epss_percentile": 0.58554}, "CVE-2020-3835": {"epss_score": 0.00137, "epss_percentile": 0.34244}, "CVE-2020-3836": {"epss_score": 0.00134, "epss_percentile": 0.33782}, "CVE-2020-3837": {"epss_score": 0.06189, "epss_percentile": 0.90547}, "CVE-2020-3838": {"epss_score": 0.00399, "epss_percentile": 0.60136}, "CVE-2020-3839": {"epss_score": 0.00159, "epss_percentile": 0.37337}, "CVE-2020-3840": {"epss_score": 0.00469, "epss_percentile": 0.63942}, "CVE-2020-3841": {"epss_score": 0.00139, "epss_percentile": 0.34597}, "CVE-2020-3842": {"epss_score": 0.00414, "epss_percentile": 0.61102}, "CVE-2020-3843": {"epss_score": 0.01654, "epss_percentile": 0.81587}, "CVE-2020-3844": {"epss_score": 0.00153, "epss_percentile": 0.36595}, "CVE-2020-3845": {"epss_score": 0.00374, "epss_percentile": 0.58554}, "CVE-2020-3846": {"epss_score": 0.00773, "epss_percentile": 0.73055}, "CVE-2020-3847": {"epss_score": 0.01337, "epss_percentile": 0.7956}, "CVE-2020-3848": {"epss_score": 0.00857, "epss_percentile": 0.74496}, "CVE-2020-3849": {"epss_score": 0.00857, "epss_percentile": 0.74496}, "CVE-2020-3850": {"epss_score": 0.0118, "epss_percentile": 0.78303}, "CVE-2020-3851": {"epss_score": 0.00195, "epss_percentile": 0.41633}, "CVE-2020-3852": {"epss_score": 0.00284, "epss_percentile": 0.51474}, "CVE-2020-3853": {"epss_score": 0.00414, "epss_percentile": 0.61102}, "CVE-2020-3854": {"epss_score": 0.00374, "epss_percentile": 0.58554}, "CVE-2020-3855": {"epss_score": 0.00323, "epss_percentile": 0.54874}, "CVE-2020-3856": {"epss_score": 0.00352, "epss_percentile": 0.57092}, "CVE-2020-3857": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2020-3858": {"epss_score": 0.00374, "epss_percentile": 0.58554}, "CVE-2020-3859": {"epss_score": 0.00154, "epss_percentile": 0.36688}, "CVE-2020-3860": {"epss_score": 0.00131, "epss_percentile": 0.33359}, "CVE-2020-3861": {"epss_score": 0.00129, "epss_percentile": 0.33125}, "CVE-2020-3862": {"epss_score": 0.00216, "epss_percentile": 0.44189}, "CVE-2020-3863": {"epss_score": 0.00326, "epss_percentile": 0.5504}, "CVE-2020-3864": {"epss_score": 0.00055, "epss_percentile": 0.17606}, "CVE-2020-3865": {"epss_score": 0.00472, "epss_percentile": 0.6403}, "CVE-2020-3866": {"epss_score": 0.00217, "epss_percentile": 0.44242}, "CVE-2020-3867": {"epss_score": 0.00362, "epss_percentile": 0.57793}, "CVE-2020-3868": {"epss_score": 0.00275, "epss_percentile": 0.5063}, "CVE-2020-3869": {"epss_score": 0.00351, "epss_percentile": 0.57031}, "CVE-2020-3870": {"epss_score": 0.00613, "epss_percentile": 0.69254}, "CVE-2020-3871": {"epss_score": 0.00374, "epss_percentile": 0.58554}, "CVE-2020-3872": {"epss_score": 0.00325, "epss_percentile": 0.55025}, "CVE-2020-3873": {"epss_score": 0.00153, "epss_percentile": 0.36595}, "CVE-2020-3874": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2020-3875": {"epss_score": 0.00325, "epss_percentile": 0.55025}, "CVE-2020-3877": {"epss_score": 0.01152, "epss_percentile": 0.78047}, "CVE-2020-3878": {"epss_score": 0.00616, "epss_percentile": 0.69336}, "CVE-2020-3880": {"epss_score": 0.00235, "epss_percentile": 0.46227}, "CVE-2020-3881": {"epss_score": 0.00048, "epss_percentile": 0.1518}, "CVE-2020-3882": {"epss_score": 0.0028, "epss_percentile": 0.51016}, "CVE-2020-3883": {"epss_score": 0.00475, "epss_percentile": 0.64198}, "CVE-2020-3884": {"epss_score": 0.00502, "epss_percentile": 0.65416}, "CVE-2020-3885": {"epss_score": 0.00774, "epss_percentile": 0.73076}, "CVE-2020-3886": {"epss_score": 0.00352, "epss_percentile": 0.57119}, "CVE-2020-3887": {"epss_score": 0.00492, "epss_percentile": 0.64992}, "CVE-2020-3888": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2020-3889": {"epss_score": 0.00048, "epss_percentile": 0.1518}, "CVE-2020-3890": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2020-3891": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2020-3892": {"epss_score": 0.00302, "epss_percentile": 0.53122}, "CVE-2020-3893": {"epss_score": 0.00302, "epss_percentile": 0.53122}, "CVE-2020-3894": {"epss_score": 0.00644, "epss_percentile": 0.70086}, "CVE-2020-3895": {"epss_score": 0.01284, "epss_percentile": 0.79167}, "CVE-2020-3896": {"epss_score": 0.00244, "epss_percentile": 0.47598}, "CVE-2020-3897": {"epss_score": 0.0249, "epss_percentile": 0.84896}, "CVE-2020-3898": {"epss_score": 0.00087, "epss_percentile": 0.2556}, "CVE-2020-3899": {"epss_score": 0.02676, "epss_percentile": 0.85404}, "CVE-2020-3900": {"epss_score": 0.00888, "epss_percentile": 0.75}, "CVE-2020-3901": {"epss_score": 0.00953, "epss_percentile": 0.75889}, "CVE-2020-3902": {"epss_score": 0.00844, "epss_percentile": 0.74271}, "CVE-2020-3903": {"epss_score": 0.00302, "epss_percentile": 0.53122}, "CVE-2020-3904": {"epss_score": 0.00326, "epss_percentile": 0.5504}, "CVE-2020-3905": {"epss_score": 0.00302, "epss_percentile": 0.53122}, "CVE-2020-3906": {"epss_score": 0.00256, "epss_percentile": 0.48739}, "CVE-2020-3907": {"epss_score": 0.00036, "epss_percentile": 0.10269}, "CVE-2020-3908": {"epss_score": 0.00039, "epss_percentile": 0.11794}, "CVE-2020-3909": {"epss_score": 0.03186, "epss_percentile": 0.86589}, "CVE-2020-3910": {"epss_score": 0.01174, "epss_percentile": 0.78248}, "CVE-2020-3911": {"epss_score": 0.01563, "epss_percentile": 0.81048}, "CVE-2020-3912": {"epss_score": 0.00039, "epss_percentile": 0.11794}, "CVE-2020-3913": {"epss_score": 0.00196, "epss_percentile": 0.4179}, "CVE-2020-3914": {"epss_score": 0.003, "epss_percentile": 0.52957}, "CVE-2020-3915": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-3916": {"epss_score": 0.00206, "epss_percentile": 0.43053}, "CVE-2020-3917": {"epss_score": 0.00063, "epss_percentile": 0.19931}, "CVE-2020-3918": {"epss_score": 0.00067, "epss_percentile": 0.21181}, "CVE-2020-3919": {"epss_score": 0.00266, "epss_percentile": 0.49882}, "CVE-2020-3920": {"epss_score": 0.00252, "epss_percentile": 0.48342}, "CVE-2020-3921": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2020-3922": {"epss_score": 0.00607, "epss_percentile": 0.69051}, "CVE-2020-3923": {"epss_score": 0.0033, "epss_percentile": 0.55489}, "CVE-2020-3924": {"epss_score": 0.00406, "epss_percentile": 0.60543}, "CVE-2020-3925": {"epss_score": 0.04511, "epss_percentile": 0.8878}, "CVE-2020-3926": {"epss_score": 0.00374, "epss_percentile": 0.58532}, "CVE-2020-3927": {"epss_score": 0.00411, "epss_percentile": 0.60901}, "CVE-2020-3928": {"epss_score": 0.00098, "epss_percentile": 0.27813}, "CVE-2020-3929": {"epss_score": 0.00125, "epss_percentile": 0.32622}, "CVE-2020-3930": {"epss_score": 0.00053, "epss_percentile": 0.16685}, "CVE-2020-3931": {"epss_score": 0.01727, "epss_percentile": 0.81968}, "CVE-2020-3932": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2020-3933": {"epss_score": 0.00455, "epss_percentile": 0.63308}, "CVE-2020-3934": {"epss_score": 0.00375, "epss_percentile": 0.58611}, "CVE-2020-3935": {"epss_score": 0.00218, "epss_percentile": 0.44347}, "CVE-2020-3936": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2020-3937": {"epss_score": 0.00334, "epss_percentile": 0.5572}, "CVE-2020-3938": {"epss_score": 0.00356, "epss_percentile": 0.57355}, "CVE-2020-3939": {"epss_score": 0.00296, "epss_percentile": 0.52586}, "CVE-2020-3940": {"epss_score": 0.00221, "epss_percentile": 0.44636}, "CVE-2020-3941": {"epss_score": 0.00072, "epss_percentile": 0.22352}, "CVE-2020-3943": {"epss_score": 0.01728, "epss_percentile": 0.81972}, "CVE-2020-3944": {"epss_score": 0.00429, "epss_percentile": 0.61995}, "CVE-2020-3945": {"epss_score": 0.0044, "epss_percentile": 0.62637}, "CVE-2020-3946": {"epss_score": 0.00319, "epss_percentile": 0.54485}, "CVE-2020-3947": {"epss_score": 0.00172, "epss_percentile": 0.38926}, "CVE-2020-3948": {"epss_score": 0.00028, "epss_percentile": 0.07356}, "CVE-2020-3950": {"epss_score": 0.19652, "epss_percentile": 0.95221}, "CVE-2020-3951": {"epss_score": 0.00118, "epss_percentile": 0.31411}, "CVE-2020-3952": {"epss_score": 0.94355, "epss_percentile": 0.99957}, "CVE-2020-3953": {"epss_score": 0.0034, "epss_percentile": 0.56242}, "CVE-2020-3954": {"epss_score": 0.005, "epss_percentile": 0.65288}, "CVE-2020-3955": {"epss_score": 0.02527, "epss_percentile": 0.85016}, "CVE-2020-3956": {"epss_score": 0.65189, "epss_percentile": 0.98407}, "CVE-2020-3957": {"epss_score": 0.00064, "epss_percentile": 0.2013}, "CVE-2020-3958": {"epss_score": 0.00095, "epss_percentile": 0.27136}, "CVE-2020-3959": {"epss_score": 0.00096, "epss_percentile": 0.27406}, "CVE-2020-3960": {"epss_score": 0.00054, "epss_percentile": 0.17356}, "CVE-2020-3961": {"epss_score": 0.00135, "epss_percentile": 0.33975}, "CVE-2020-3962": {"epss_score": 0.00122, "epss_percentile": 0.32155}, "CVE-2020-3963": {"epss_score": 0.00123, "epss_percentile": 0.32252}, "CVE-2020-3964": {"epss_score": 0.00114, "epss_percentile": 0.30872}, "CVE-2020-3965": {"epss_score": 0.00056, "epss_percentile": 0.17803}, "CVE-2020-3966": {"epss_score": 0.00037, "epss_percentile": 0.10743}, "CVE-2020-3967": {"epss_score": 0.00065, "epss_percentile": 0.20433}, "CVE-2020-3968": {"epss_score": 0.00032, "epss_percentile": 0.0903}, "CVE-2020-3969": {"epss_score": 0.00109, "epss_percentile": 0.30022}, "CVE-2020-3970": {"epss_score": 0.00046, "epss_percentile": 0.14167}, "CVE-2020-3971": {"epss_score": 0.00043, "epss_percentile": 0.13099}, "CVE-2020-3972": {"epss_score": 0.00042, "epss_percentile": 0.12828}, "CVE-2020-3973": {"epss_score": 0.00538, "epss_percentile": 0.66947}, "CVE-2020-3974": {"epss_score": 0.00034, "epss_percentile": 0.09771}, "CVE-2020-3975": {"epss_score": 0.00304, "epss_percentile": 0.53269}, "CVE-2020-3976": {"epss_score": 0.02497, "epss_percentile": 0.84909}, "CVE-2020-3977": {"epss_score": 0.00119, "epss_percentile": 0.31635}, "CVE-2020-3979": {"epss_score": 0.00064, "epss_percentile": 0.20141}, "CVE-2020-3980": {"epss_score": 0.00107, "epss_percentile": 0.29581}, "CVE-2020-3981": {"epss_score": 0.00203, "epss_percentile": 0.42535}, "CVE-2020-3982": {"epss_score": 0.00237, "epss_percentile": 0.46711}, "CVE-2020-3984": {"epss_score": 0.16628, "epss_percentile": 0.94705}, "CVE-2020-3985": {"epss_score": 0.00494, "epss_percentile": 0.65096}, "CVE-2020-3986": {"epss_score": 0.00048, "epss_percentile": 0.15194}, "CVE-2020-3987": {"epss_score": 0.00048, "epss_percentile": 0.15194}, "CVE-2020-3988": {"epss_score": 0.00048, "epss_percentile": 0.15194}, "CVE-2020-3989": {"epss_score": 0.00037, "epss_percentile": 0.10743}, "CVE-2020-3990": {"epss_score": 0.00041, "epss_percentile": 0.12198}, "CVE-2020-3991": {"epss_score": 0.00039, "epss_percentile": 0.11634}, "CVE-2020-3992": {"epss_score": 0.82694, "epss_percentile": 0.99208}, "CVE-2020-3993": {"epss_score": 0.00318, "epss_percentile": 0.54431}, "CVE-2020-3994": {"epss_score": 0.00127, "epss_percentile": 0.32821}, "CVE-2020-3995": {"epss_score": 0.00367, "epss_percentile": 0.58157}, "CVE-2020-3996": {"epss_score": 0.00098, "epss_percentile": 0.27727}, "CVE-2020-3997": {"epss_score": 0.00229, "epss_percentile": 0.45605}, "CVE-2020-3998": {"epss_score": 0.00239, "epss_percentile": 0.46878}, "CVE-2020-3999": {"epss_score": 0.00103, "epss_percentile": 0.29079}, "CVE-2020-4000": {"epss_score": 0.29866, "epss_percentile": 0.96482}, "CVE-2020-4001": {"epss_score": 0.09872, "epss_percentile": 0.92746}, "CVE-2020-4002": {"epss_score": 0.00566, "epss_percentile": 0.67813}, "CVE-2020-4003": {"epss_score": 0.00401, "epss_percentile": 0.60207}, "CVE-2020-4004": {"epss_score": 0.00365, "epss_percentile": 0.57975}, "CVE-2020-4005": {"epss_score": 0.0021, "epss_percentile": 0.43589}, "CVE-2020-4006": {"epss_score": 0.12338, "epss_percentile": 0.93644}, "CVE-2020-4008": {"epss_score": 0.00036, "epss_percentile": 0.10283}, "CVE-2020-4013": {"epss_score": 0.00215, "epss_percentile": 0.44104}, "CVE-2020-4014": {"epss_score": 0.00253, "epss_percentile": 0.4849}, "CVE-2020-4015": {"epss_score": 0.00369, "epss_percentile": 0.5823}, "CVE-2020-4016": {"epss_score": 0.00411, "epss_percentile": 0.60882}, "CVE-2020-4017": {"epss_score": 0.00411, "epss_percentile": 0.60882}, "CVE-2020-4018": {"epss_score": 0.00156, "epss_percentile": 0.36893}, "CVE-2020-4019": {"epss_score": 0.00063, "epss_percentile": 0.19907}, "CVE-2020-4020": {"epss_score": 0.00674, "epss_percentile": 0.70881}, "CVE-2020-4021": {"epss_score": 0.00257, "epss_percentile": 0.48869}, "CVE-2020-4022": {"epss_score": 0.00334, "epss_percentile": 0.55795}, "CVE-2020-4023": {"epss_score": 0.00342, "epss_percentile": 0.56394}, "CVE-2020-4024": {"epss_score": 0.0027, "epss_percentile": 0.50238}, "CVE-2020-4025": {"epss_score": 0.00277, "epss_percentile": 0.50812}, "CVE-2020-4026": {"epss_score": 0.00157, "epss_percentile": 0.37081}, "CVE-2020-4027": {"epss_score": 0.00148, "epss_percentile": 0.35863}, "CVE-2020-4028": {"epss_score": 0.00455, "epss_percentile": 0.63293}, "CVE-2020-4029": {"epss_score": 0.00229, "epss_percentile": 0.45623}, "CVE-2020-4030": {"epss_score": 0.0004, "epss_percentile": 0.11926}, "CVE-2020-4031": {"epss_score": 0.00348, "epss_percentile": 0.5684}, "CVE-2020-4032": {"epss_score": 0.00531, "epss_percentile": 0.6666}, "CVE-2020-4033": {"epss_score": 0.00156, "epss_percentile": 0.36899}, "CVE-2020-4035": {"epss_score": 0.00187, "epss_percentile": 0.40801}, "CVE-2020-4037": {"epss_score": 0.00382, "epss_percentile": 0.59078}, "CVE-2020-4038": {"epss_score": 0.33487, "epss_percentile": 0.96778}, "CVE-2020-4039": {"epss_score": 0.0063, "epss_percentile": 0.69701}, "CVE-2020-4040": {"epss_score": 0.00495, "epss_percentile": 0.65131}, "CVE-2020-4041": {"epss_score": 0.00441, "epss_percentile": 0.62677}, "CVE-2020-4042": {"epss_score": 0.00267, "epss_percentile": 0.5}, "CVE-2020-4043": {"epss_score": 0.01568, "epss_percentile": 0.81076}, "CVE-2020-4044": {"epss_score": 0.00802, "epss_percentile": 0.73593}, "CVE-2020-4045": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-4046": {"epss_score": 0.06854, "epss_percentile": 0.91076}, "CVE-2020-4047": {"epss_score": 0.05566, "epss_percentile": 0.9}, "CVE-2020-4048": {"epss_score": 0.03502, "epss_percentile": 0.8725}, "CVE-2020-4049": {"epss_score": 0.05886, "epss_percentile": 0.90293}, "CVE-2020-4050": {"epss_score": 0.02416, "epss_percentile": 0.84688}, "CVE-2020-4051": {"epss_score": 0.00175, "epss_percentile": 0.39364}, "CVE-2020-4052": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-4053": {"epss_score": 0.00408, "epss_percentile": 0.60648}, "CVE-2020-4054": {"epss_score": 0.00484, "epss_percentile": 0.64668}, "CVE-2020-4059": {"epss_score": 0.02075, "epss_percentile": 0.83502}, "CVE-2020-4060": {"epss_score": 0.00591, "epss_percentile": 0.68591}, "CVE-2020-4061": {"epss_score": 0.00309, "epss_percentile": 0.53703}, "CVE-2020-4062": {"epss_score": 0.00418, "epss_percentile": 0.61273}, "CVE-2020-4066": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2020-4067": {"epss_score": 0.01104, "epss_percentile": 0.77596}, "CVE-2020-4068": {"epss_score": 0.00902, "epss_percentile": 0.75188}, "CVE-2020-4070": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-4071": {"epss_score": 0.00109, "epss_percentile": 0.30073}, "CVE-2020-4072": {"epss_score": 0.00304, "epss_percentile": 0.53293}, "CVE-2020-4074": {"epss_score": 0.00432, "epss_percentile": 0.62124}, "CVE-2020-4075": {"epss_score": 0.00264, "epss_percentile": 0.4955}, "CVE-2020-4076": {"epss_score": 0.00075, "epss_percentile": 0.2304}, "CVE-2020-4077": {"epss_score": 0.00436, "epss_percentile": 0.62456}, "CVE-2020-4079": {"epss_score": 0.00288, "epss_percentile": 0.51882}, "CVE-2020-4080": {"epss_score": 0.00766, "epss_percentile": 0.72942}, "CVE-2020-4081": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-4082": {"epss_score": 0.00166, "epss_percentile": 0.38251}, "CVE-2020-4083": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2020-4084": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-4085": {"epss_score": 0.00291, "epss_percentile": 0.5216}, "CVE-2020-4089": {"epss_score": 0.00357, "epss_percentile": 0.57433}, "CVE-2020-4092": {"epss_score": 0.0006, "epss_percentile": 0.18953}, "CVE-2020-4095": {"epss_score": 0.00026, "epss_percentile": 0.06561}, "CVE-2020-4097": {"epss_score": 0.00077, "epss_percentile": 0.23346}, "CVE-2020-4099": {"epss_score": 0.00178, "epss_percentile": 0.39695}, "CVE-2020-4100": {"epss_score": 0.00053, "epss_percentile": 0.16929}, "CVE-2020-4101": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2020-4102": {"epss_score": 0.00051, "epss_percentile": 0.16274}, "CVE-2020-4104": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-4107": {"epss_score": 0.00041, "epss_percentile": 0.12356}, "CVE-2020-4125": {"epss_score": 0.00134, "epss_percentile": 0.33783}, "CVE-2020-4126": {"epss_score": 0.00185, "epss_percentile": 0.40477}, "CVE-2020-4127": {"epss_score": 0.0016, "epss_percentile": 0.37446}, "CVE-2020-4128": {"epss_score": 0.00319, "epss_percentile": 0.54552}, "CVE-2020-4129": {"epss_score": 0.00319, "epss_percentile": 0.54552}, "CVE-2020-4135": {"epss_score": 0.00908, "epss_percentile": 0.75274}, "CVE-2020-4138": {"epss_score": 0.00044, "epss_percentile": 0.13557}, "CVE-2020-4140": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2020-4146": {"epss_score": 0.00138, "epss_percentile": 0.34354}, "CVE-2020-4150": {"epss_score": 0.00058, "epss_percentile": 0.18293}, "CVE-2020-4151": {"epss_score": 0.00133, "epss_percentile": 0.33732}, "CVE-2020-4152": {"epss_score": 0.00095, "epss_percentile": 0.27175}, "CVE-2020-4153": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2020-4157": {"epss_score": 0.00072, "epss_percentile": 0.22438}, "CVE-2020-4159": {"epss_score": 0.00209, "epss_percentile": 0.43316}, "CVE-2020-4160": {"epss_score": 0.00168, "epss_percentile": 0.38421}, "CVE-2020-4161": {"epss_score": 0.00448, "epss_percentile": 0.63017}, "CVE-2020-4162": {"epss_score": 0.00314, "epss_percentile": 0.54134}, "CVE-2020-4163": {"epss_score": 0.00415, "epss_percentile": 0.61133}, "CVE-2020-4164": {"epss_score": 0.00141, "epss_percentile": 0.34836}, "CVE-2020-4165": {"epss_score": 0.00086, "epss_percentile": 0.25407}, "CVE-2020-4166": {"epss_score": 0.00186, "epss_percentile": 0.40643}, "CVE-2020-4167": {"epss_score": 0.00127, "epss_percentile": 0.32799}, "CVE-2020-4169": {"epss_score": 0.00129, "epss_percentile": 0.33077}, "CVE-2020-4170": {"epss_score": 0.0009, "epss_percentile": 0.26068}, "CVE-2020-4171": {"epss_score": 0.00137, "epss_percentile": 0.3425}, "CVE-2020-4172": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2020-4173": {"epss_score": 0.00172, "epss_percentile": 0.38984}, "CVE-2020-4174": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4175": {"epss_score": 0.00298, "epss_percentile": 0.52782}, "CVE-2020-4177": {"epss_score": 0.0008, "epss_percentile": 0.24127}, "CVE-2020-4180": {"epss_score": 0.12303, "epss_percentile": 0.93628}, "CVE-2020-4182": {"epss_score": 0.00247, "epss_percentile": 0.47828}, "CVE-2020-4183": {"epss_score": 0.00188, "epss_percentile": 0.40866}, "CVE-2020-4184": {"epss_score": 0.00249, "epss_percentile": 0.48077}, "CVE-2020-4185": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4186": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2020-4187": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2020-4188": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2020-4189": {"epss_score": 0.00056, "epss_percentile": 0.17709}, "CVE-2020-4190": {"epss_score": 0.00018, "epss_percentile": 0.0373}, "CVE-2020-4191": {"epss_score": 0.00024, "epss_percentile": 0.06006}, "CVE-2020-4193": {"epss_score": 0.00414, "epss_percentile": 0.61022}, "CVE-2020-4195": {"epss_score": 0.00086, "epss_percentile": 0.25407}, "CVE-2020-4196": {"epss_score": 0.00314, "epss_percentile": 0.54134}, "CVE-2020-4197": {"epss_score": 0.00098, "epss_percentile": 0.27693}, "CVE-2020-4198": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4199": {"epss_score": 0.00118, "epss_percentile": 0.31449}, "CVE-2020-4200": {"epss_score": 0.00311, "epss_percentile": 0.53932}, "CVE-2020-4202": {"epss_score": 0.00234, "epss_percentile": 0.46076}, "CVE-2020-4203": {"epss_score": 0.00266, "epss_percentile": 0.49902}, "CVE-2020-4204": {"epss_score": 0.00111, "epss_percentile": 0.3029}, "CVE-2020-4205": {"epss_score": 0.00084, "epss_percentile": 0.24904}, "CVE-2020-4206": {"epss_score": 0.04583, "epss_percentile": 0.8888}, "CVE-2020-4207": {"epss_score": 0.01975, "epss_percentile": 0.83117}, "CVE-2020-4208": {"epss_score": 0.00026, "epss_percentile": 0.06427}, "CVE-2020-4209": {"epss_score": 0.00429, "epss_percentile": 0.6199}, "CVE-2020-4210": {"epss_score": 0.28945, "epss_percentile": 0.96402}, "CVE-2020-4211": {"epss_score": 0.48538, "epss_percentile": 0.97642}, "CVE-2020-4212": {"epss_score": 0.19739, "epss_percentile": 0.95234}, "CVE-2020-4213": {"epss_score": 0.28945, "epss_percentile": 0.96402}, "CVE-2020-4214": {"epss_score": 0.00104, "epss_percentile": 0.29105}, "CVE-2020-4216": {"epss_score": 0.00129, "epss_percentile": 0.33172}, "CVE-2020-4217": {"epss_score": 0.00467, "epss_percentile": 0.63836}, "CVE-2020-4222": {"epss_score": 0.28945, "epss_percentile": 0.96402}, "CVE-2020-4223": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4224": {"epss_score": 0.00045, "epss_percentile": 0.13824}, "CVE-2020-4226": {"epss_score": 0.00206, "epss_percentile": 0.43047}, "CVE-2020-4229": {"epss_score": 0.00183, "epss_percentile": 0.40315}, "CVE-2020-4230": {"epss_score": 0.00087, "epss_percentile": 0.25588}, "CVE-2020-4231": {"epss_score": 0.00025, "epss_percentile": 0.06124}, "CVE-2020-4232": {"epss_score": 0.00154, "epss_percentile": 0.36661}, "CVE-2020-4233": {"epss_score": 0.00128, "epss_percentile": 0.33047}, "CVE-2020-4235": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2020-4236": {"epss_score": 0.00256, "epss_percentile": 0.48813}, "CVE-2020-4237": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2020-4238": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2020-4239": {"epss_score": 0.00124, "epss_percentile": 0.32345}, "CVE-2020-4240": {"epss_score": 0.0042, "epss_percentile": 0.61455}, "CVE-2020-4241": {"epss_score": 0.07567, "epss_percentile": 0.91545}, "CVE-2020-4242": {"epss_score": 0.03227, "epss_percentile": 0.86688}, "CVE-2020-4243": {"epss_score": 0.00207, "epss_percentile": 0.43164}, "CVE-2020-4244": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2020-4245": {"epss_score": 0.00176, "epss_percentile": 0.39487}, "CVE-2020-4246": {"epss_score": 0.00397, "epss_percentile": 0.60033}, "CVE-2020-4248": {"epss_score": 0.00099, "epss_percentile": 0.28313}, "CVE-2020-4249": {"epss_score": 0.00143, "epss_percentile": 0.35195}, "CVE-2020-4251": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4252": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2020-4253": {"epss_score": 0.00225, "epss_percentile": 0.45119}, "CVE-2020-4254": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4257": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4258": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4259": {"epss_score": 0.00102, "epss_percentile": 0.2888}, "CVE-2020-4260": {"epss_score": 0.00118, "epss_percentile": 0.31385}, "CVE-2020-4261": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4262": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4263": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4264": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4265": {"epss_score": 0.00066, "epss_percentile": 0.20945}, "CVE-2020-4266": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4267": {"epss_score": 0.00198, "epss_percentile": 0.42081}, "CVE-2020-4268": {"epss_score": 0.00239, "epss_percentile": 0.46928}, "CVE-2020-4269": {"epss_score": 0.00216, "epss_percentile": 0.44145}, "CVE-2020-4270": {"epss_score": 0.00146, "epss_percentile": 0.3558}, "CVE-2020-4271": {"epss_score": 0.00589, "epss_percentile": 0.68516}, "CVE-2020-4272": {"epss_score": 0.05106, "epss_percentile": 0.89506}, "CVE-2020-4273": {"epss_score": 0.00041, "epss_percentile": 0.1223}, "CVE-2020-4274": {"epss_score": 0.00266, "epss_percentile": 0.49925}, "CVE-2020-4276": {"epss_score": 0.00445, "epss_percentile": 0.62883}, "CVE-2020-4277": {"epss_score": 0.0018, "epss_percentile": 0.39871}, "CVE-2020-4278": {"epss_score": 0.00082, "epss_percentile": 0.24421}, "CVE-2020-4280": {"epss_score": 0.45463, "epss_percentile": 0.97488}, "CVE-2020-4281": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4282": {"epss_score": 0.00174, "epss_percentile": 0.39201}, "CVE-2020-4283": {"epss_score": 0.00064, "epss_percentile": 0.20171}, "CVE-2020-4284": {"epss_score": 0.00139, "epss_percentile": 0.34651}, "CVE-2020-4285": {"epss_score": 0.01324, "epss_percentile": 0.79468}, "CVE-2020-4286": {"epss_score": 0.0009, "epss_percentile": 0.26068}, "CVE-2020-4287": {"epss_score": 0.01324, "epss_percentile": 0.79468}, "CVE-2020-4288": {"epss_score": 0.01324, "epss_percentile": 0.79468}, "CVE-2020-4289": {"epss_score": 0.00138, "epss_percentile": 0.34354}, "CVE-2020-4290": {"epss_score": 0.00106, "epss_percentile": 0.29493}, "CVE-2020-4291": {"epss_score": 0.00147, "epss_percentile": 0.35748}, "CVE-2020-4292": {"epss_score": 0.00284, "epss_percentile": 0.51458}, "CVE-2020-4294": {"epss_score": 0.00156, "epss_percentile": 0.36956}, "CVE-2020-4295": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4297": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4298": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4299": {"epss_score": 0.00077, "epss_percentile": 0.23364}, "CVE-2020-4300": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2020-4301": {"epss_score": 0.00134, "epss_percentile": 0.33902}, "CVE-2020-4302": {"epss_score": 0.01367, "epss_percentile": 0.79785}, "CVE-2020-4303": {"epss_score": 0.00292, "epss_percentile": 0.52251}, "CVE-2020-4304": {"epss_score": 0.00223, "epss_percentile": 0.44845}, "CVE-2020-4305": {"epss_score": 0.01393, "epss_percentile": 0.79964}, "CVE-2020-4306": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4307": {"epss_score": 0.00161, "epss_percentile": 0.3761}, "CVE-2020-4309": {"epss_score": 0.00208, "epss_percentile": 0.43267}, "CVE-2020-4310": {"epss_score": 0.00615, "epss_percentile": 0.69312}, "CVE-2020-4311": {"epss_score": 0.00068, "epss_percentile": 0.21415}, "CVE-2020-4312": {"epss_score": 0.00156, "epss_percentile": 0.3694}, "CVE-2020-4315": {"epss_score": 0.00036, "epss_percentile": 0.10237}, "CVE-2020-4316": {"epss_score": 0.00172, "epss_percentile": 0.38984}, "CVE-2020-4317": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4318": {"epss_score": 0.00314, "epss_percentile": 0.54134}, "CVE-2020-4319": {"epss_score": 0.00156, "epss_percentile": 0.3694}, "CVE-2020-4320": {"epss_score": 0.00175, "epss_percentile": 0.39301}, "CVE-2020-4322": {"epss_score": 0.00208, "epss_percentile": 0.43284}, "CVE-2020-4323": {"epss_score": 0.00188, "epss_percentile": 0.40866}, "CVE-2020-4324": {"epss_score": 0.00034, "epss_percentile": 0.09526}, "CVE-2020-4325": {"epss_score": 0.00376, "epss_percentile": 0.58645}, "CVE-2020-4327": {"epss_score": 0.00187, "epss_percentile": 0.40799}, "CVE-2020-4328": {"epss_score": 0.00209, "epss_percentile": 0.43347}, "CVE-2020-4329": {"epss_score": 0.00208, "epss_percentile": 0.43302}, "CVE-2020-4336": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2020-4337": {"epss_score": 0.00192, "epss_percentile": 0.41305}, "CVE-2020-4338": {"epss_score": 0.001, "epss_percentile": 0.28466}, "CVE-2020-4340": {"epss_score": 0.00025, "epss_percentile": 0.06139}, "CVE-2020-4341": {"epss_score": 0.00044, "epss_percentile": 0.13616}, "CVE-2020-4342": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2020-4343": {"epss_score": 0.01953, "epss_percentile": 0.83028}, "CVE-2020-4344": {"epss_score": 0.00048, "epss_percentile": 0.15231}, "CVE-2020-4345": {"epss_score": 0.00054, "epss_percentile": 0.17069}, "CVE-2020-4346": {"epss_score": 0.00174, "epss_percentile": 0.39166}, "CVE-2020-4347": {"epss_score": 0.00163, "epss_percentile": 0.37858}, "CVE-2020-4348": {"epss_score": 0.00102, "epss_percentile": 0.2888}, "CVE-2020-4349": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4350": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4352": {"epss_score": 0.00055, "epss_percentile": 0.17367}, "CVE-2020-4353": {"epss_score": 0.00053, "epss_percentile": 0.16857}, "CVE-2020-4354": {"epss_score": 0.00184, "epss_percentile": 0.4043}, "CVE-2020-4355": {"epss_score": 0.00466, "epss_percentile": 0.63806}, "CVE-2020-4357": {"epss_score": 0.00104, "epss_percentile": 0.29187}, "CVE-2020-4358": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4360": {"epss_score": 0.00036, "epss_percentile": 0.10248}, "CVE-2020-4361": {"epss_score": 0.00113, "epss_percentile": 0.30665}, "CVE-2020-4362": {"epss_score": 0.00525, "epss_percentile": 0.66383}, "CVE-2020-4363": {"epss_score": 0.0007, "epss_percentile": 0.21952}, "CVE-2020-4364": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4365": {"epss_score": 0.00091, "epss_percentile": 0.2638}, "CVE-2020-4366": {"epss_score": 0.00247, "epss_percentile": 0.47828}, "CVE-2020-4367": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4369": {"epss_score": 0.00025, "epss_percentile": 0.06299}, "CVE-2020-4371": {"epss_score": 0.00041, "epss_percentile": 0.1241}, "CVE-2020-4372": {"epss_score": 0.0004, "epss_percentile": 0.12132}, "CVE-2020-4375": {"epss_score": 0.00355, "epss_percentile": 0.57278}, "CVE-2020-4376": {"epss_score": 0.00376, "epss_percentile": 0.58645}, "CVE-2020-4377": {"epss_score": 0.00606, "epss_percentile": 0.69004}, "CVE-2020-4378": {"epss_score": 0.00136, "epss_percentile": 0.34108}, "CVE-2020-4379": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4380": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4381": {"epss_score": 0.00198, "epss_percentile": 0.42081}, "CVE-2020-4382": {"epss_score": 0.00045, "epss_percentile": 0.13734}, "CVE-2020-4383": {"epss_score": 0.00377, "epss_percentile": 0.58689}, "CVE-2020-4384": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4385": {"epss_score": 0.0008, "epss_percentile": 0.24127}, "CVE-2020-4386": {"epss_score": 0.00032, "epss_percentile": 0.08987}, "CVE-2020-4387": {"epss_score": 0.00032, "epss_percentile": 0.08987}, "CVE-2020-4388": {"epss_score": 0.00202, "epss_percentile": 0.42467}, "CVE-2020-4395": {"epss_score": 0.00099, "epss_percentile": 0.28406}, "CVE-2020-4396": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4397": {"epss_score": 0.00082, "epss_percentile": 0.24463}, "CVE-2020-4399": {"epss_score": 0.00377, "epss_percentile": 0.58689}, "CVE-2020-4400": {"epss_score": 0.00305, "epss_percentile": 0.53316}, "CVE-2020-4405": {"epss_score": 0.00281, "epss_percentile": 0.51184}, "CVE-2020-4406": {"epss_score": 0.00074, "epss_percentile": 0.22874}, "CVE-2020-4408": {"epss_score": 0.00053, "epss_percentile": 0.17031}, "CVE-2020-4409": {"epss_score": 0.00162, "epss_percentile": 0.37685}, "CVE-2020-4410": {"epss_score": 0.00095, "epss_percentile": 0.27126}, "CVE-2020-4411": {"epss_score": 0.00043, "epss_percentile": 0.13364}, "CVE-2020-4412": {"epss_score": 0.00316, "epss_percentile": 0.54276}, "CVE-2020-4413": {"epss_score": 0.00247, "epss_percentile": 0.47855}, "CVE-2020-4414": {"epss_score": 0.00048, "epss_percentile": 0.14993}, "CVE-2020-4415": {"epss_score": 0.2457, "epss_percentile": 0.95934}, "CVE-2020-4419": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4420": {"epss_score": 0.02039, "epss_percentile": 0.83363}, "CVE-2020-4421": {"epss_score": 0.0017, "epss_percentile": 0.38723}, "CVE-2020-4422": {"epss_score": 0.00965, "epss_percentile": 0.76042}, "CVE-2020-4427": {"epss_score": 0.90345, "epss_percentile": 0.99578}, "CVE-2020-4428": {"epss_score": 0.92289, "epss_percentile": 0.99705}, "CVE-2020-4429": {"epss_score": 0.89253, "epss_percentile": 0.99517}, "CVE-2020-4430": {"epss_score": 0.84293, "epss_percentile": 0.99283}, "CVE-2020-4431": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4432": {"epss_score": 0.01435, "epss_percentile": 0.80272}, "CVE-2020-4433": {"epss_score": 0.09244, "epss_percentile": 0.92465}, "CVE-2020-4434": {"epss_score": 0.01346, "epss_percentile": 0.79647}, "CVE-2020-4435": {"epss_score": 0.00954, "epss_percentile": 0.75903}, "CVE-2020-4436": {"epss_score": 0.0019, "epss_percentile": 0.41096}, "CVE-2020-4445": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4446": {"epss_score": 0.00077, "epss_percentile": 0.23431}, "CVE-2020-4447": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4448": {"epss_score": 0.1624, "epss_percentile": 0.946}, "CVE-2020-4449": {"epss_score": 0.00573, "epss_percentile": 0.68047}, "CVE-2020-4450": {"epss_score": 0.71859, "epss_percentile": 0.98684}, "CVE-2020-4452": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4459": {"epss_score": 0.00097, "epss_percentile": 0.27584}, "CVE-2020-4461": {"epss_score": 0.00174, "epss_percentile": 0.39201}, "CVE-2020-4462": {"epss_score": 0.00977, "epss_percentile": 0.76229}, "CVE-2020-4463": {"epss_score": 0.90034, "epss_percentile": 0.99557}, "CVE-2020-4464": {"epss_score": 0.45414, "epss_percentile": 0.97486}, "CVE-2020-4465": {"epss_score": 0.01017, "epss_percentile": 0.76689}, "CVE-2020-4466": {"epss_score": 0.00271, "epss_percentile": 0.50301}, "CVE-2020-4467": {"epss_score": 0.01324, "epss_percentile": 0.79468}, "CVE-2020-4468": {"epss_score": 0.01324, "epss_percentile": 0.79468}, "CVE-2020-4469": {"epss_score": 0.47757, "epss_percentile": 0.97599}, "CVE-2020-4470": {"epss_score": 0.0023, "epss_percentile": 0.45676}, "CVE-2020-4471": {"epss_score": 0.0015, "epss_percentile": 0.36114}, "CVE-2020-4475": {"epss_score": 0.00148, "epss_percentile": 0.35882}, "CVE-2020-4476": {"epss_score": 0.00227, "epss_percentile": 0.45431}, "CVE-2020-4477": {"epss_score": 0.00243, "epss_percentile": 0.47455}, "CVE-2020-4481": {"epss_score": 0.00427, "epss_percentile": 0.61905}, "CVE-2020-4482": {"epss_score": 0.00133, "epss_percentile": 0.33732}, "CVE-2020-4483": {"epss_score": 0.00104, "epss_percentile": 0.29187}, "CVE-2020-4484": {"epss_score": 0.00119, "epss_percentile": 0.31669}, "CVE-2020-4485": {"epss_score": 0.00198, "epss_percentile": 0.42081}, "CVE-2020-4486": {"epss_score": 0.00328, "epss_percentile": 0.55256}, "CVE-2020-4487": {"epss_score": 0.00112, "epss_percentile": 0.3051}, "CVE-2020-4490": {"epss_score": 0.00117, "epss_percentile": 0.31233}, "CVE-2020-4491": {"epss_score": 0.00043, "epss_percentile": 0.13127}, "CVE-2020-4492": {"epss_score": 0.00058, "epss_percentile": 0.18388}, "CVE-2020-4493": {"epss_score": 0.00623, "epss_percentile": 0.69542}, "CVE-2020-4494": {"epss_score": 0.00207, "epss_percentile": 0.43161}, "CVE-2020-4495": {"epss_score": 0.0151, "epss_percentile": 0.80768}, "CVE-2020-4496": {"epss_score": 0.00094, "epss_percentile": 0.26784}, "CVE-2020-4497": {"epss_score": 0.00146, "epss_percentile": 0.35574}, "CVE-2020-4498": {"epss_score": 0.0004, "epss_percentile": 0.12187}, "CVE-2020-4499": {"epss_score": 0.00383, "epss_percentile": 0.59087}, "CVE-2020-4503": {"epss_score": 0.00049, "epss_percentile": 0.15579}, "CVE-2020-4509": {"epss_score": 0.00476, "epss_percentile": 0.64277}, "CVE-2020-4510": {"epss_score": 0.00075, "epss_percentile": 0.22952}, "CVE-2020-4511": {"epss_score": 0.00377, "epss_percentile": 0.58689}, "CVE-2020-4512": {"epss_score": 0.00751, "epss_percentile": 0.72642}, "CVE-2020-4513": {"epss_score": 0.00247, "epss_percentile": 0.47828}, "CVE-2020-4516": {"epss_score": 0.0007, "epss_percentile": 0.21684}, "CVE-2020-4520": {"epss_score": 0.0103, "epss_percentile": 0.7685}, "CVE-2020-4521": {"epss_score": 0.13075, "epss_percentile": 0.93866}, "CVE-2020-4522": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4524": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2020-4525": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4526": {"epss_score": 0.0009, "epss_percentile": 0.26068}, "CVE-2020-4527": {"epss_score": 0.0029, "epss_percentile": 0.52144}, "CVE-2020-4528": {"epss_score": 0.00046, "epss_percentile": 0.14193}, "CVE-2020-4529": {"epss_score": 0.00073, "epss_percentile": 0.22481}, "CVE-2020-4530": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4531": {"epss_score": 0.00124, "epss_percentile": 0.32345}, "CVE-2020-4532": {"epss_score": 0.00177, "epss_percentile": 0.39627}, "CVE-2020-4533": {"epss_score": 0.00188, "epss_percentile": 0.40866}, "CVE-2020-4534": {"epss_score": 0.00141, "epss_percentile": 0.34869}, "CVE-2020-4535": {"epss_score": 0.00187, "epss_percentile": 0.40779}, "CVE-2020-4536": {"epss_score": 0.00183, "epss_percentile": 0.40284}, "CVE-2020-4539": {"epss_score": 0.00188, "epss_percentile": 0.40866}, "CVE-2020-4541": {"epss_score": 0.00188, "epss_percentile": 0.40866}, "CVE-2020-4542": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4544": {"epss_score": 0.00112, "epss_percentile": 0.3051}, "CVE-2020-4545": {"epss_score": 0.00965, "epss_percentile": 0.76042}, "CVE-2020-4546": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4547": {"epss_score": 0.00089, "epss_percentile": 0.25809}, "CVE-2020-4548": {"epss_score": 0.00178, "epss_percentile": 0.39713}, "CVE-2020-4549": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4550": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4551": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4552": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4553": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4554": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4555": {"epss_score": 0.0026, "epss_percentile": 0.49179}, "CVE-2020-4556": {"epss_score": 0.0003, "epss_percentile": 0.08295}, "CVE-2020-4557": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4559": {"epss_score": 0.00467, "epss_percentile": 0.63836}, "CVE-2020-4560": {"epss_score": 0.00131, "epss_percentile": 0.33423}, "CVE-2020-4561": {"epss_score": 0.00874, "epss_percentile": 0.74764}, "CVE-2020-4562": {"epss_score": 0.00193, "epss_percentile": 0.41393}, "CVE-2020-4564": {"epss_score": 0.00259, "epss_percentile": 0.49065}, "CVE-2020-4565": {"epss_score": 0.00239, "epss_percentile": 0.46936}, "CVE-2020-4566": {"epss_score": 0.00243, "epss_percentile": 0.4751}, "CVE-2020-4567": {"epss_score": 0.00308, "epss_percentile": 0.53579}, "CVE-2020-4568": {"epss_score": 0.00083, "epss_percentile": 0.24697}, "CVE-2020-4569": {"epss_score": 0.00187, "epss_percentile": 0.4077}, "CVE-2020-4572": {"epss_score": 0.00245, "epss_percentile": 0.47637}, "CVE-2020-4573": {"epss_score": 0.00254, "epss_percentile": 0.48539}, "CVE-2020-4574": {"epss_score": 0.0015, "epss_percentile": 0.36127}, "CVE-2020-4575": {"epss_score": 0.00131, "epss_percentile": 0.33423}, "CVE-2020-4576": {"epss_score": 0.00439, "epss_percentile": 0.62604}, "CVE-2020-4578": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2020-4579": {"epss_score": 0.01612, "epss_percentile": 0.81335}, "CVE-2020-4580": {"epss_score": 0.00729, "epss_percentile": 0.7212}, "CVE-2020-4581": {"epss_score": 0.00729, "epss_percentile": 0.7212}, "CVE-2020-4584": {"epss_score": 0.00193, "epss_percentile": 0.41451}, "CVE-2020-4587": {"epss_score": 0.00038, "epss_percentile": 0.11169}, "CVE-2020-4588": {"epss_score": 0.00366, "epss_percentile": 0.58015}, "CVE-2020-4589": {"epss_score": 0.0677, "epss_percentile": 0.91014}, "CVE-2020-4590": {"epss_score": 0.00448, "epss_percentile": 0.63017}, "CVE-2020-4591": {"epss_score": 0.00023, "epss_percentile": 0.05388}, "CVE-2020-4592": {"epss_score": 0.00133, "epss_percentile": 0.33732}, "CVE-2020-4593": {"epss_score": 0.00034, "epss_percentile": 0.09748}, "CVE-2020-4594": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4595": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4596": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4597": {"epss_score": 0.0008, "epss_percentile": 0.24185}, "CVE-2020-4598": {"epss_score": 0.00176, "epss_percentile": 0.39428}, "CVE-2020-4599": {"epss_score": 0.00186, "epss_percentile": 0.40643}, "CVE-2020-4600": {"epss_score": 0.00186, "epss_percentile": 0.40643}, "CVE-2020-4602": {"epss_score": 0.00038, "epss_percentile": 0.11098}, "CVE-2020-4603": {"epss_score": 0.00205, "epss_percentile": 0.42718}, "CVE-2020-4604": {"epss_score": 0.00021, "epss_percentile": 0.04779}, "CVE-2020-4606": {"epss_score": 0.00041, "epss_percentile": 0.12392}, "CVE-2020-4607": {"epss_score": 0.00044, "epss_percentile": 0.13629}, "CVE-2020-4609": {"epss_score": 0.00126, "epss_percentile": 0.3263}, "CVE-2020-4610": {"epss_score": 0.00043, "epss_percentile": 0.13182}, "CVE-2020-4611": {"epss_score": 0.0051, "epss_percentile": 0.65796}, "CVE-2020-4612": {"epss_score": 0.00124, "epss_percentile": 0.32442}, "CVE-2020-4613": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4614": {"epss_score": 0.00097, "epss_percentile": 0.27621}, "CVE-2020-4615": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2020-4616": {"epss_score": 0.00195, "epss_percentile": 0.41696}, "CVE-2020-4617": {"epss_score": 0.00115, "epss_percentile": 0.30991}, "CVE-2020-4618": {"epss_score": 0.00262, "epss_percentile": 0.49393}, "CVE-2020-4619": {"epss_score": 0.00114, "epss_percentile": 0.30759}, "CVE-2020-4620": {"epss_score": 0.03595, "epss_percentile": 0.87403}, "CVE-2020-4621": {"epss_score": 0.00384, "epss_percentile": 0.59164}, "CVE-2020-4622": {"epss_score": 0.00062, "epss_percentile": 0.19757}, "CVE-2020-4623": {"epss_score": 0.00094, "epss_percentile": 0.27071}, "CVE-2020-4624": {"epss_score": 0.00076, "epss_percentile": 0.23178}, "CVE-2020-4625": {"epss_score": 0.00138, "epss_percentile": 0.34354}, "CVE-2020-4626": {"epss_score": 0.00095, "epss_percentile": 0.27126}, "CVE-2020-4627": {"epss_score": 0.00894, "epss_percentile": 0.75087}, "CVE-2020-4628": {"epss_score": 0.00177, "epss_percentile": 0.39627}, "CVE-2020-4629": {"epss_score": 0.00041, "epss_percentile": 0.1241}, "CVE-2020-4631": {"epss_score": 0.00026, "epss_percentile": 0.06583}, "CVE-2020-4632": {"epss_score": 0.0012, "epss_percentile": 0.3178}, "CVE-2020-4633": {"epss_score": 0.02275, "epss_percentile": 0.84227}, "CVE-2020-4635": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2020-4636": {"epss_score": 0.00671, "epss_percentile": 0.70789}, "CVE-2020-4638": {"epss_score": 0.00522, "epss_percentile": 0.66265}, "CVE-2020-4640": {"epss_score": 0.00076, "epss_percentile": 0.23087}, "CVE-2020-4642": {"epss_score": 0.00056, "epss_percentile": 0.17954}, "CVE-2020-4643": {"epss_score": 0.00344, "epss_percentile": 0.56528}, "CVE-2020-4644": {"epss_score": 0.00339, "epss_percentile": 0.56173}, "CVE-2020-4645": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4646": {"epss_score": 0.00119, "epss_percentile": 0.31669}, "CVE-2020-4647": {"epss_score": 0.00362, "epss_percentile": 0.57785}, "CVE-2020-4648": {"epss_score": 0.00133, "epss_percentile": 0.33692}, "CVE-2020-4649": {"epss_score": 0.00156, "epss_percentile": 0.36883}, "CVE-2020-4650": {"epss_score": 0.00042, "epss_percentile": 0.12651}, "CVE-2020-4651": {"epss_score": 0.00043, "epss_percentile": 0.13016}, "CVE-2020-4653": {"epss_score": 0.00152, "epss_percentile": 0.36471}, "CVE-2020-4654": {"epss_score": 0.00312, "epss_percentile": 0.53987}, "CVE-2020-4655": {"epss_score": 0.00362, "epss_percentile": 0.57785}, "CVE-2020-4657": {"epss_score": 0.00247, "epss_percentile": 0.47828}, "CVE-2020-4658": {"epss_score": 0.00188, "epss_percentile": 0.40866}, "CVE-2020-4660": {"epss_score": 0.00123, "epss_percentile": 0.32253}, "CVE-2020-4661": {"epss_score": 0.00107, "epss_percentile": 0.29676}, "CVE-2020-4662": {"epss_score": 0.00136, "epss_percentile": 0.34146}, "CVE-2020-4663": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4664": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4665": {"epss_score": 0.00172, "epss_percentile": 0.38984}, "CVE-2020-4666": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4667": {"epss_score": 0.00156, "epss_percentile": 0.3694}, "CVE-2020-4668": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2020-4669": {"epss_score": 0.00781, "epss_percentile": 0.73194}, "CVE-2020-4670": {"epss_score": 0.00817, "epss_percentile": 0.73847}, "CVE-2020-4671": {"epss_score": 0.00243, "epss_percentile": 0.4751}, "CVE-2020-4672": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4673": {"epss_score": 0.00156, "epss_percentile": 0.36883}, "CVE-2020-4674": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2020-4675": {"epss_score": 0.0009, "epss_percentile": 0.26068}, "CVE-2020-4678": {"epss_score": 0.0022, "epss_percentile": 0.44617}, "CVE-2020-4679": {"epss_score": 0.00245, "epss_percentile": 0.47677}, "CVE-2020-4680": {"epss_score": 0.00206, "epss_percentile": 0.43056}, "CVE-2020-4681": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4682": {"epss_score": 0.02993, "epss_percentile": 0.86149}, "CVE-2020-4685": {"epss_score": 0.00522, "epss_percentile": 0.66265}, "CVE-2020-4686": {"epss_score": 0.00195, "epss_percentile": 0.41617}, "CVE-2020-4687": {"epss_score": 0.00119, "epss_percentile": 0.31669}, "CVE-2020-4688": {"epss_score": 0.00138, "epss_percentile": 0.34467}, "CVE-2020-4689": {"epss_score": 0.00677, "epss_percentile": 0.70945}, "CVE-2020-4690": {"epss_score": 0.00097, "epss_percentile": 0.27584}, "CVE-2020-4691": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4692": {"epss_score": 0.00211, "epss_percentile": 0.4371}, "CVE-2020-4693": {"epss_score": 0.00616, "epss_percentile": 0.69332}, "CVE-2020-4695": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2020-4696": {"epss_score": 0.00114, "epss_percentile": 0.30828}, "CVE-2020-4697": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4698": {"epss_score": 0.00223, "epss_percentile": 0.44887}, "CVE-2020-4699": {"epss_score": 0.00107, "epss_percentile": 0.29676}, "CVE-2020-4700": {"epss_score": 0.00584, "epss_percentile": 0.68373}, "CVE-2020-4701": {"epss_score": 0.0007, "epss_percentile": 0.21952}, "CVE-2020-4702": {"epss_score": 0.00223, "epss_percentile": 0.44887}, "CVE-2020-4703": {"epss_score": 0.00842, "epss_percentile": 0.74241}, "CVE-2020-4704": {"epss_score": 0.00112, "epss_percentile": 0.30415}, "CVE-2020-4705": {"epss_score": 0.00162, "epss_percentile": 0.37754}, "CVE-2020-4706": {"epss_score": 0.0004, "epss_percentile": 0.11894}, "CVE-2020-4707": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2020-4708": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2020-4711": {"epss_score": 0.0061, "epss_percentile": 0.69159}, "CVE-2020-4717": {"epss_score": 0.00112, "epss_percentile": 0.30413}, "CVE-2020-4718": {"epss_score": 0.0017, "epss_percentile": 0.38707}, "CVE-2020-4719": {"epss_score": 0.00219, "epss_percentile": 0.44466}, "CVE-2020-4721": {"epss_score": 0.00219, "epss_percentile": 0.44484}, "CVE-2020-4722": {"epss_score": 0.00219, "epss_percentile": 0.44484}, "CVE-2020-4723": {"epss_score": 0.0019, "epss_percentile": 0.41137}, "CVE-2020-4724": {"epss_score": 0.0019, "epss_percentile": 0.41137}, "CVE-2020-4725": {"epss_score": 0.002, "epss_percentile": 0.42246}, "CVE-2020-4726": {"epss_score": 0.00085, "epss_percentile": 0.25234}, "CVE-2020-4727": {"epss_score": 0.00181, "epss_percentile": 0.40116}, "CVE-2020-4729": {"epss_score": 0.00084, "epss_percentile": 0.24895}, "CVE-2020-4731": {"epss_score": 0.00131, "epss_percentile": 0.33423}, "CVE-2020-4732": {"epss_score": 0.00211, "epss_percentile": 0.4371}, "CVE-2020-4733": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4739": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2020-4740": {"epss_score": 0.00103, "epss_percentile": 0.29084}, "CVE-2020-4741": {"epss_score": 0.0017, "epss_percentile": 0.38707}, "CVE-2020-4747": {"epss_score": 0.01998, "epss_percentile": 0.8321}, "CVE-2020-4748": {"epss_score": 0.00216, "epss_percentile": 0.44192}, "CVE-2020-4749": {"epss_score": 0.00148, "epss_percentile": 0.35893}, "CVE-2020-4755": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2020-4756": {"epss_score": 0.00048, "epss_percentile": 0.15171}, "CVE-2020-4757": {"epss_score": 0.00413, "epss_percentile": 0.61012}, "CVE-2020-4759": {"epss_score": 0.00421, "epss_percentile": 0.61514}, "CVE-2020-4760": {"epss_score": 0.00157, "epss_percentile": 0.37119}, "CVE-2020-4761": {"epss_score": 0.00177, "epss_percentile": 0.39627}, "CVE-2020-4762": {"epss_score": 0.00584, "epss_percentile": 0.68373}, "CVE-2020-4763": {"epss_score": 0.00172, "epss_percentile": 0.38984}, "CVE-2020-4764": {"epss_score": 0.00077, "epss_percentile": 0.23548}, "CVE-2020-4765": {"epss_score": 0.00042, "epss_percentile": 0.12651}, "CVE-2020-4766": {"epss_score": 0.00961, "epss_percentile": 0.75975}, "CVE-2020-4767": {"epss_score": 0.00729, "epss_percentile": 0.7212}, "CVE-2020-4768": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2020-4771": {"epss_score": 0.00142, "epss_percentile": 0.3503}, "CVE-2020-4772": {"epss_score": 0.00528, "epss_percentile": 0.66536}, "CVE-2020-4773": {"epss_score": 0.00078, "epss_percentile": 0.23582}, "CVE-2020-4774": {"epss_score": 0.00109, "epss_percentile": 0.30032}, "CVE-2020-4775": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2020-4776": {"epss_score": 0.00566, "epss_percentile": 0.67818}, "CVE-2020-4778": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2020-4779": {"epss_score": 0.00126, "epss_percentile": 0.32775}, "CVE-2020-4780": {"epss_score": 0.0012, "epss_percentile": 0.31747}, "CVE-2020-4781": {"epss_score": 0.00198, "epss_percentile": 0.42014}, "CVE-2020-4782": {"epss_score": 0.00392, "epss_percentile": 0.5967}, "CVE-2020-4783": {"epss_score": 0.00172, "epss_percentile": 0.38974}, "CVE-2020-4785": {"epss_score": 0.00084, "epss_percentile": 0.24972}, "CVE-2020-4786": {"epss_score": 0.00117, "epss_percentile": 0.31342}, "CVE-2020-4787": {"epss_score": 0.0004, "epss_percentile": 0.1188}, "CVE-2020-4788": {"epss_score": 0.00198, "epss_percentile": 0.42002}, "CVE-2020-4789": {"epss_score": 0.00367, "epss_percentile": 0.58139}, "CVE-2020-4790": {"epss_score": 0.00101, "epss_percentile": 0.28682}, "CVE-2020-4791": {"epss_score": 0.0005, "epss_percentile": 0.15689}, "CVE-2020-4792": {"epss_score": 0.00143, "epss_percentile": 0.35117}, "CVE-2020-4794": {"epss_score": 0.00128, "epss_percentile": 0.32949}, "CVE-2020-4795": {"epss_score": 0.00124, "epss_percentile": 0.32463}, "CVE-2020-4799": {"epss_score": 0.00041, "epss_percentile": 0.12211}, "CVE-2020-4803": {"epss_score": 0.00048, "epss_percentile": 0.15231}, "CVE-2020-4805": {"epss_score": 0.00048, "epss_percentile": 0.15231}, "CVE-2020-4809": {"epss_score": 0.00048, "epss_percentile": 0.15231}, "CVE-2020-4811": {"epss_score": 0.00077, "epss_percentile": 0.23444}, "CVE-2020-4815": {"epss_score": 0.00134, "epss_percentile": 0.33854}, "CVE-2020-4816": {"epss_score": 0.00259, "epss_percentile": 0.4906}, "CVE-2020-4820": {"epss_score": 0.00188, "epss_percentile": 0.40866}, "CVE-2020-4821": {"epss_score": 0.00238, "epss_percentile": 0.46744}, "CVE-2020-4825": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2020-4826": {"epss_score": 0.0009, "epss_percentile": 0.26068}, "CVE-2020-4827": {"epss_score": 0.0009, "epss_percentile": 0.26068}, "CVE-2020-4828": {"epss_score": 0.00158, "epss_percentile": 0.37214}, "CVE-2020-4829": {"epss_score": 0.00038, "epss_percentile": 0.11169}, "CVE-2020-4831": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4832": {"epss_score": 0.00046, "epss_percentile": 0.14193}, "CVE-2020-4838": {"epss_score": 0.00092, "epss_percentile": 0.26586}, "CVE-2020-4839": {"epss_score": 0.00706, "epss_percentile": 0.71623}, "CVE-2020-4840": {"epss_score": 0.00238, "epss_percentile": 0.46791}, "CVE-2020-4841": {"epss_score": 0.00259, "epss_percentile": 0.4906}, "CVE-2020-4842": {"epss_score": 0.00152, "epss_percentile": 0.36421}, "CVE-2020-4843": {"epss_score": 0.00099, "epss_percentile": 0.28305}, "CVE-2020-4845": {"epss_score": 0.00314, "epss_percentile": 0.54134}, "CVE-2020-4846": {"epss_score": 0.00217, "epss_percentile": 0.44258}, "CVE-2020-4848": {"epss_score": 0.00151, "epss_percentile": 0.36333}, "CVE-2020-4849": {"epss_score": 0.00113, "epss_percentile": 0.307}, "CVE-2020-4850": {"epss_score": 0.00122, "epss_percentile": 0.32156}, "CVE-2020-4851": {"epss_score": 0.00046, "epss_percentile": 0.14202}, "CVE-2020-4854": {"epss_score": 0.00234, "epss_percentile": 0.46178}, "CVE-2020-4855": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2020-4856": {"epss_score": 0.0025, "epss_percentile": 0.4811}, "CVE-2020-4857": {"epss_score": 0.00236, "epss_percentile": 0.46409}, "CVE-2020-4863": {"epss_score": 0.00177, "epss_percentile": 0.39598}, "CVE-2020-4864": {"epss_score": 0.00077, "epss_percentile": 0.23372}, "CVE-2020-4865": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2020-4866": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2020-4868": {"epss_score": 0.00051, "epss_percentile": 0.16214}, "CVE-2020-4869": {"epss_score": 0.00545, "epss_percentile": 0.6716}, "CVE-2020-4870": {"epss_score": 0.00644, "epss_percentile": 0.7009}, "CVE-2020-4871": {"epss_score": 0.00051, "epss_percentile": 0.1615}, "CVE-2020-4873": {"epss_score": 0.00139, "epss_percentile": 0.34651}, "CVE-2020-4874": {"epss_score": 0.00052, "epss_percentile": 0.16557}, "CVE-2020-4875": {"epss_score": 0.0037, "epss_percentile": 0.58308}, "CVE-2020-4876": {"epss_score": 0.0037, "epss_percentile": 0.58308}, "CVE-2020-4877": {"epss_score": 0.00354, "epss_percentile": 0.5723}, "CVE-2020-4879": {"epss_score": 0.00907, "epss_percentile": 0.75269}, "CVE-2020-4881": {"epss_score": 0.00224, "epss_percentile": 0.44995}, "CVE-2020-4882": {"epss_score": 0.00122, "epss_percentile": 0.32074}, "CVE-2020-4883": {"epss_score": 0.00161, "epss_percentile": 0.37615}, "CVE-2020-4884": {"epss_score": 0.00019, "epss_percentile": 0.04135}, "CVE-2020-4885": {"epss_score": 0.00087, "epss_percentile": 0.25509}, "CVE-2020-4886": {"epss_score": 0.00048, "epss_percentile": 0.15231}, "CVE-2020-4887": {"epss_score": 0.00042, "epss_percentile": 0.12831}, "CVE-2020-4888": {"epss_score": 0.43722, "epss_percentile": 0.974}, "CVE-2020-4889": {"epss_score": 0.00038, "epss_percentile": 0.11411}, "CVE-2020-4890": {"epss_score": 0.00041, "epss_percentile": 0.12458}, "CVE-2020-4891": {"epss_score": 0.00038, "epss_percentile": 0.11077}, "CVE-2020-4892": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2020-4893": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2020-4895": {"epss_score": 0.00105, "epss_percentile": 0.29375}, "CVE-2020-4896": {"epss_score": 0.00158, "epss_percentile": 0.37214}, "CVE-2020-4897": {"epss_score": 0.00256, "epss_percentile": 0.48804}, "CVE-2020-4898": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4899": {"epss_score": 0.00109, "epss_percentile": 0.29909}, "CVE-2020-4900": {"epss_score": 0.00046, "epss_percentile": 0.14193}, "CVE-2020-4901": {"epss_score": 0.00327, "epss_percentile": 0.55151}, "CVE-2020-4902": {"epss_score": 0.00372, "epss_percentile": 0.58422}, "CVE-2020-4903": {"epss_score": 0.00136, "epss_percentile": 0.34145}, "CVE-2020-4904": {"epss_score": 0.0009, "epss_percentile": 0.26068}, "CVE-2020-4905": {"epss_score": 0.00241, "epss_percentile": 0.47257}, "CVE-2020-4906": {"epss_score": 0.00048, "epss_percentile": 0.15231}, "CVE-2020-4907": {"epss_score": 0.00177, "epss_percentile": 0.39627}, "CVE-2020-4908": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2020-4909": {"epss_score": 0.00162, "epss_percentile": 0.37754}, "CVE-2020-4910": {"epss_score": 0.00213, "epss_percentile": 0.4392}, "CVE-2020-4912": {"epss_score": 0.00309, "epss_percentile": 0.53669}, "CVE-2020-4913": {"epss_score": 0.00043, "epss_percentile": 0.13229}, "CVE-2020-4914": {"epss_score": 0.00013, "epss_percentile": 0.0148}, "CVE-2020-4916": {"epss_score": 0.00178, "epss_percentile": 0.39695}, "CVE-2020-4917": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2020-4918": {"epss_score": 0.0004, "epss_percentile": 0.12169}, "CVE-2020-4919": {"epss_score": 0.00137, "epss_percentile": 0.34265}, "CVE-2020-4920": {"epss_score": 0.00128, "epss_percentile": 0.33043}, "CVE-2020-4921": {"epss_score": 0.00539, "epss_percentile": 0.66979}, "CVE-2020-4925": {"epss_score": 0.00045, "epss_percentile": 0.13734}, "CVE-2020-4926": {"epss_score": 0.00158, "epss_percentile": 0.37172}, "CVE-2020-4927": {"epss_score": 0.00072, "epss_percentile": 0.22245}, "CVE-2020-4928": {"epss_score": 0.00068, "epss_percentile": 0.21222}, "CVE-2020-4929": {"epss_score": 0.00187, "epss_percentile": 0.40779}, "CVE-2020-4931": {"epss_score": 0.00377, "epss_percentile": 0.58689}, "CVE-2020-4932": {"epss_score": 0.00028, "epss_percentile": 0.07574}, "CVE-2020-4933": {"epss_score": 0.00187, "epss_percentile": 0.40779}, "CVE-2020-4934": {"epss_score": 0.00162, "epss_percentile": 0.3774}, "CVE-2020-4935": {"epss_score": 0.00143, "epss_percentile": 0.35117}, "CVE-2020-4937": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2020-4938": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2020-4941": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2020-4942": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2020-4944": {"epss_score": 0.00022, "epss_percentile": 0.04984}, "CVE-2020-4945": {"epss_score": 0.00122, "epss_percentile": 0.32075}, "CVE-2020-4949": {"epss_score": 0.00298, "epss_percentile": 0.52825}, "CVE-2020-4951": {"epss_score": 0.00068, "epss_percentile": 0.2137}, "CVE-2020-4952": {"epss_score": 0.00699, "epss_percentile": 0.71456}, "CVE-2020-4953": {"epss_score": 0.00097, "epss_percentile": 0.27523}, "CVE-2020-4954": {"epss_score": 0.00088, "epss_percentile": 0.25642}, "CVE-2020-4955": {"epss_score": 0.01276, "epss_percentile": 0.7911}, "CVE-2020-4956": {"epss_score": 0.00225, "epss_percentile": 0.45092}, "CVE-2020-4957": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2020-4958": {"epss_score": 0.00469, "epss_percentile": 0.6395}, "CVE-2020-4964": {"epss_score": 0.00153, "epss_percentile": 0.36616}, "CVE-2020-4965": {"epss_score": 0.00111, "epss_percentile": 0.3026}, "CVE-2020-4966": {"epss_score": 0.00356, "epss_percentile": 0.57345}, "CVE-2020-4967": {"epss_score": 0.00156, "epss_percentile": 0.36883}, "CVE-2020-4968": {"epss_score": 0.0005, "epss_percentile": 0.15839}, "CVE-2020-4969": {"epss_score": 0.00161, "epss_percentile": 0.37549}, "CVE-2020-4970": {"epss_score": 0.00104, "epss_percentile": 0.29186}, "CVE-2020-4974": {"epss_score": 0.00168, "epss_percentile": 0.3845}, "CVE-2020-4975": {"epss_score": 0.0025, "epss_percentile": 0.4811}, "CVE-2020-4976": {"epss_score": 0.00037, "epss_percentile": 0.10685}, "CVE-2020-4977": {"epss_score": 0.00187, "epss_percentile": 0.40779}, "CVE-2020-4979": {"epss_score": 0.00575, "epss_percentile": 0.68104}, "CVE-2020-4980": {"epss_score": 0.0005, "epss_percentile": 0.15839}, "CVE-2020-4981": {"epss_score": 0.00035, "epss_percentile": 0.10073}, "CVE-2020-4983": {"epss_score": 0.00056, "epss_percentile": 0.1779}, "CVE-2020-4985": {"epss_score": 0.00209, "epss_percentile": 0.43316}, "CVE-2020-4987": {"epss_score": 0.00105, "epss_percentile": 0.29375}, "CVE-2020-4988": {"epss_score": 0.00615, "epss_percentile": 0.69293}, "CVE-2020-4989": {"epss_score": 0.00156, "epss_percentile": 0.3694}, "CVE-2020-4990": {"epss_score": 0.00539, "epss_percentile": 0.66979}, "CVE-2020-4992": {"epss_score": 0.00103, "epss_percentile": 0.29082}, "CVE-2020-4993": {"epss_score": 0.00284, "epss_percentile": 0.51458}, "CVE-2020-4994": {"epss_score": 0.00578, "epss_percentile": 0.68207}, "CVE-2020-4995": {"epss_score": 0.0012, "epss_percentile": 0.31747}, "CVE-2020-4996": {"epss_score": 0.00047, "epss_percentile": 0.14881}, "CVE-2020-4997": {"epss_score": 0.00143, "epss_percentile": 0.35117}, "CVE-2020-5000": {"epss_score": 0.00259, "epss_percentile": 0.49065}, "CVE-2020-5001": {"epss_score": 0.00083, "epss_percentile": 0.24726}, "CVE-2020-5002": {"epss_score": 0.00066, "epss_percentile": 0.20817}, "CVE-2020-5003": {"epss_score": 0.00327, "epss_percentile": 0.5515}, "CVE-2020-5004": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2020-5008": {"epss_score": 0.00147, "epss_percentile": 0.35681}, "CVE-2020-5013": {"epss_score": 0.00578, "epss_percentile": 0.68195}, "CVE-2020-5014": {"epss_score": 0.00925, "epss_percentile": 0.7554}, "CVE-2020-5015": {"epss_score": 0.01193, "epss_percentile": 0.78406}, "CVE-2020-5016": {"epss_score": 0.00206, "epss_percentile": 0.43001}, "CVE-2020-5017": {"epss_score": 0.00033, "epss_percentile": 0.0928}, "CVE-2020-5018": {"epss_score": 0.00097, "epss_percentile": 0.27621}, "CVE-2020-5019": {"epss_score": 0.00047, "epss_percentile": 0.14595}, "CVE-2020-5020": {"epss_score": 0.00181, "epss_percentile": 0.40116}, "CVE-2020-5021": {"epss_score": 0.00033, "epss_percentile": 0.09141}, "CVE-2020-5022": {"epss_score": 0.00167, "epss_percentile": 0.38306}, "CVE-2020-5023": {"epss_score": 0.00729, "epss_percentile": 0.7212}, "CVE-2020-5024": {"epss_score": 0.01614, "epss_percentile": 0.81345}, "CVE-2020-5025": {"epss_score": 0.00287, "epss_percentile": 0.51814}, "CVE-2020-5026": {"epss_score": 0.00059, "epss_percentile": 0.18824}, "CVE-2020-5030": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2020-5031": {"epss_score": 0.00164, "epss_percentile": 0.37916}, "CVE-2020-5032": {"epss_score": 0.0013, "epss_percentile": 0.3328}, "CVE-2020-5129": {"epss_score": 0.00513, "epss_percentile": 0.65891}, "CVE-2020-5130": {"epss_score": 0.00553, "epss_percentile": 0.67421}, "CVE-2020-5131": {"epss_score": 0.00043, "epss_percentile": 0.1324}, "CVE-2020-5132": {"epss_score": 0.00174, "epss_percentile": 0.39194}, "CVE-2020-5133": {"epss_score": 0.00531, "epss_percentile": 0.66654}, "CVE-2020-5134": {"epss_score": 0.00378, "epss_percentile": 0.58807}, "CVE-2020-5135": {"epss_score": 0.22585, "epss_percentile": 0.95654}, "CVE-2020-5136": {"epss_score": 0.00314, "epss_percentile": 0.54096}, "CVE-2020-5137": {"epss_score": 0.00498, "epss_percentile": 0.65239}, "CVE-2020-5138": {"epss_score": 0.00498, "epss_percentile": 0.65239}, "CVE-2020-5139": {"epss_score": 0.00505, "epss_percentile": 0.65607}, "CVE-2020-5140": {"epss_score": 0.00505, "epss_percentile": 0.65607}, "CVE-2020-5141": {"epss_score": 0.00477, "epss_percentile": 0.643}, "CVE-2020-5142": {"epss_score": 0.00135, "epss_percentile": 0.33971}, "CVE-2020-5143": {"epss_score": 0.00501, "epss_percentile": 0.65352}, "CVE-2020-5144": {"epss_score": 0.00061, "epss_percentile": 0.19399}, "CVE-2020-5145": {"epss_score": 0.00166, "epss_percentile": 0.38228}, "CVE-2020-5146": {"epss_score": 0.02255, "epss_percentile": 0.84167}, "CVE-2020-5147": {"epss_score": 0.00094, "epss_percentile": 0.27067}, "CVE-2020-5148": {"epss_score": 0.00118, "epss_percentile": 0.31445}, "CVE-2020-5179": {"epss_score": 0.02426, "epss_percentile": 0.84716}, "CVE-2020-5180": {"epss_score": 0.00067, "epss_percentile": 0.21174}, "CVE-2020-5182": {"epss_score": 0.00292, "epss_percentile": 0.52214}, "CVE-2020-5183": {"epss_score": 0.00965, "epss_percentile": 0.76043}, "CVE-2020-5186": {"epss_score": 0.00353, "epss_percentile": 0.5716}, "CVE-2020-5187": {"epss_score": 0.00747, "epss_percentile": 0.72575}, "CVE-2020-5188": {"epss_score": 0.00268, "epss_percentile": 0.50022}, "CVE-2020-5191": {"epss_score": 0.04817, "epss_percentile": 0.89172}, "CVE-2020-5192": {"epss_score": 0.31998, "epss_percentile": 0.96665}, "CVE-2020-5193": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2020-5194": {"epss_score": 0.00232, "epss_percentile": 0.45887}, "CVE-2020-5195": {"epss_score": 0.00579, "epss_percentile": 0.68223}, "CVE-2020-5196": {"epss_score": 0.00216, "epss_percentile": 0.44187}, "CVE-2020-5197": {"epss_score": 0.00069, "epss_percentile": 0.21506}, "CVE-2020-5200": {"epss_score": 0.00076, "epss_percentile": 0.23218}, "CVE-2020-5202": {"epss_score": 0.00071, "epss_percentile": 0.22067}, "CVE-2020-5203": {"epss_score": 0.00646, "epss_percentile": 0.7013}, "CVE-2020-5204": {"epss_score": 0.00686, "epss_percentile": 0.71175}, "CVE-2020-5205": {"epss_score": 0.00302, "epss_percentile": 0.53165}, "CVE-2020-5206": {"epss_score": 0.00296, "epss_percentile": 0.52532}, "CVE-2020-5207": {"epss_score": 4e-05, "epss_percentile": 0.00143}, "CVE-2020-5208": {"epss_score": 0.00571, "epss_percentile": 0.67982}, "CVE-2020-5209": {"epss_score": 0.01694, "epss_percentile": 0.81802}, "CVE-2020-5210": {"epss_score": 0.01554, "epss_percentile": 0.81003}, "CVE-2020-5211": {"epss_score": 0.01836, "epss_percentile": 0.82472}, "CVE-2020-5212": {"epss_score": 0.01836, "epss_percentile": 0.82472}, "CVE-2020-5213": {"epss_score": 0.01836, "epss_percentile": 0.82472}, "CVE-2020-5214": {"epss_score": 0.01836, "epss_percentile": 0.82472}, "CVE-2020-5215": {"epss_score": 0.00232, "epss_percentile": 0.45957}, "CVE-2020-5216": {"epss_score": 0.00347, "epss_percentile": 0.5675}, "CVE-2020-5217": {"epss_score": 0.00521, "epss_percentile": 0.66225}, "CVE-2020-5218": {"epss_score": 0.00305, "epss_percentile": 0.53379}, "CVE-2020-5219": {"epss_score": 0.00633, "epss_percentile": 0.69772}, "CVE-2020-5220": {"epss_score": 0.00323, "epss_percentile": 0.5491}, "CVE-2020-5221": {"epss_score": 0.01487, "epss_percentile": 0.80611}, "CVE-2020-5222": {"epss_score": 0.0026, "epss_percentile": 0.49149}, "CVE-2020-5223": {"epss_score": 0.00453, "epss_percentile": 0.63224}, "CVE-2020-5224": {"epss_score": 0.00129, "epss_percentile": 0.33218}, "CVE-2020-5225": {"epss_score": 0.00173, "epss_percentile": 0.3911}, "CVE-2020-5226": {"epss_score": 0.00402, "epss_percentile": 0.6028}, "CVE-2020-5227": {"epss_score": 0.00666, "epss_percentile": 0.70674}, "CVE-2020-5228": {"epss_score": 0.00337, "epss_percentile": 0.56029}, "CVE-2020-5229": {"epss_score": 0.00153, "epss_percentile": 0.36624}, "CVE-2020-5230": {"epss_score": 0.00327, "epss_percentile": 0.55151}, "CVE-2020-5231": {"epss_score": 0.00229, "epss_percentile": 0.45648}, "CVE-2020-5232": {"epss_score": 0.00269, "epss_percentile": 0.50117}, "CVE-2020-5233": {"epss_score": 0.00287, "epss_percentile": 0.51832}, "CVE-2020-5234": {"epss_score": 0.00578, "epss_percentile": 0.68202}, "CVE-2020-5235": {"epss_score": 0.00557, "epss_percentile": 0.67551}, "CVE-2020-5236": {"epss_score": 0.13924, "epss_percentile": 0.94094}, "CVE-2020-5237": {"epss_score": 0.05506, "epss_percentile": 0.89943}, "CVE-2020-5238": {"epss_score": 0.00509, "epss_percentile": 0.65729}, "CVE-2020-5239": {"epss_score": 0.0045, "epss_percentile": 0.63105}, "CVE-2020-5240": {"epss_score": 0.00161, "epss_percentile": 0.37539}, "CVE-2020-5241": {"epss_score": 0.00337, "epss_percentile": 0.56062}, "CVE-2020-5242": {"epss_score": 0.00723, "epss_percentile": 0.72027}, "CVE-2020-5243": {"epss_score": 0.00805, "epss_percentile": 0.73629}, "CVE-2020-5244": {"epss_score": 0.01132, "epss_percentile": 0.77873}, "CVE-2020-5245": {"epss_score": 0.06297, "epss_percentile": 0.90653}, "CVE-2020-5246": {"epss_score": 0.00205, "epss_percentile": 0.42702}, "CVE-2020-5247": {"epss_score": 0.02094, "epss_percentile": 0.83578}, "CVE-2020-5248": {"epss_score": 0.02836, "epss_percentile": 0.8579}, "CVE-2020-5249": {"epss_score": 0.00498, "epss_percentile": 0.65212}, "CVE-2020-5250": {"epss_score": 0.00627, "epss_percentile": 0.6963}, "CVE-2020-5251": {"epss_score": 0.00313, "epss_percentile": 0.54013}, "CVE-2020-5252": {"epss_score": 0.00069, "epss_percentile": 0.21514}, "CVE-2020-5253": {"epss_score": 0.001, "epss_percentile": 0.2847}, "CVE-2020-5254": {"epss_score": 0.09282, "epss_percentile": 0.92482}, "CVE-2020-5255": {"epss_score": 0.00374, "epss_percentile": 0.58583}, "CVE-2020-5256": {"epss_score": 0.00675, "epss_percentile": 0.70911}, "CVE-2020-5257": {"epss_score": 0.00186, "epss_percentile": 0.40642}, "CVE-2020-5258": {"epss_score": 0.01992, "epss_percentile": 0.83181}, "CVE-2020-5259": {"epss_score": 0.00278, "epss_percentile": 0.50855}, "CVE-2020-5260": {"epss_score": 0.38086, "epss_percentile": 0.97085}, "CVE-2020-5261": {"epss_score": 0.00285, "epss_percentile": 0.51671}, "CVE-2020-5262": {"epss_score": 0.00068, "epss_percentile": 0.21272}, "CVE-2020-5263": {"epss_score": 0.00231, "epss_percentile": 0.45805}, "CVE-2020-5264": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2020-5265": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2020-5266": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-5267": {"epss_score": 0.00887, "epss_percentile": 0.74973}, "CVE-2020-5268": {"epss_score": 0.00295, "epss_percentile": 0.52497}, "CVE-2020-5269": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2020-5270": {"epss_score": 0.00182, "epss_percentile": 0.40267}, "CVE-2020-5271": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2020-5272": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2020-5273": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-5274": {"epss_score": 0.00267, "epss_percentile": 0.50011}, "CVE-2020-5275": {"epss_score": 0.00274, "epss_percentile": 0.50486}, "CVE-2020-5276": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2020-5277": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-5278": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2020-5279": {"epss_score": 0.00173, "epss_percentile": 0.39057}, "CVE-2020-5280": {"epss_score": 0.00848, "epss_percentile": 0.7436}, "CVE-2020-5281": {"epss_score": 0.00357, "epss_percentile": 0.57406}, "CVE-2020-5282": {"epss_score": 0.00316, "epss_percentile": 0.54272}, "CVE-2020-5283": {"epss_score": 0.00413, "epss_percentile": 0.61007}, "CVE-2020-5284": {"epss_score": 0.79765, "epss_percentile": 0.99054}, "CVE-2020-5285": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2020-5286": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2020-5287": {"epss_score": 0.00173, "epss_percentile": 0.39057}, "CVE-2020-5288": {"epss_score": 0.00173, "epss_percentile": 0.39057}, "CVE-2020-5289": {"epss_score": 0.00323, "epss_percentile": 0.54898}, "CVE-2020-5290": {"epss_score": 0.00179, "epss_percentile": 0.39823}, "CVE-2020-5291": {"epss_score": 0.0019, "epss_percentile": 0.41136}, "CVE-2020-5292": {"epss_score": 0.00286, "epss_percentile": 0.51701}, "CVE-2020-5293": {"epss_score": 0.00212, "epss_percentile": 0.43761}, "CVE-2020-5294": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-5295": {"epss_score": 0.10667, "epss_percentile": 0.93063}, "CVE-2020-5296": {"epss_score": 0.01376, "epss_percentile": 0.79836}, "CVE-2020-5297": {"epss_score": 0.01759, "epss_percentile": 0.82143}, "CVE-2020-5298": {"epss_score": 0.00759, "epss_percentile": 0.72792}, "CVE-2020-5299": {"epss_score": 0.00673, "epss_percentile": 0.7084}, "CVE-2020-5300": {"epss_score": 0.00192, "epss_percentile": 0.4131}, "CVE-2020-5301": {"epss_score": 0.00142, "epss_percentile": 0.35034}, "CVE-2020-5302": {"epss_score": 0.00245, "epss_percentile": 0.47659}, "CVE-2020-5303": {"epss_score": 0.00316, "epss_percentile": 0.54282}, "CVE-2020-5304": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-5305": {"epss_score": 0.00412, "epss_percentile": 0.60936}, "CVE-2020-5306": {"epss_score": 0.0052, "epss_percentile": 0.66202}, "CVE-2020-5307": {"epss_score": 0.80522, "epss_percentile": 0.99093}, "CVE-2020-5308": {"epss_score": 0.00361, "epss_percentile": 0.57738}, "CVE-2020-5310": {"epss_score": 0.00611, "epss_percentile": 0.69205}, "CVE-2020-5311": {"epss_score": 0.01304, "epss_percentile": 0.79316}, "CVE-2020-5312": {"epss_score": 0.0173, "epss_percentile": 0.81988}, "CVE-2020-5313": {"epss_score": 0.00551, "epss_percentile": 0.67354}, "CVE-2020-5315": {"epss_score": 0.00042, "epss_percentile": 0.12714}, "CVE-2020-5316": {"epss_score": 0.00131, "epss_percentile": 0.33466}, "CVE-2020-5317": {"epss_score": 0.00205, "epss_percentile": 0.42727}, "CVE-2020-5318": {"epss_score": 0.00311, "epss_percentile": 0.53813}, "CVE-2020-5319": {"epss_score": 0.01063, "epss_percentile": 0.77189}, "CVE-2020-5320": {"epss_score": 0.00624, "epss_percentile": 0.69565}, "CVE-2020-5321": {"epss_score": 0.00429, "epss_percentile": 0.61973}, "CVE-2020-5322": {"epss_score": 0.02651, "epss_percentile": 0.85345}, "CVE-2020-5323": {"epss_score": 0.00428, "epss_percentile": 0.61955}, "CVE-2020-5324": {"epss_score": 0.001, "epss_percentile": 0.28493}, "CVE-2020-5326": {"epss_score": 0.00055, "epss_percentile": 0.1747}, "CVE-2020-5327": {"epss_score": 0.05044, "epss_percentile": 0.8943}, "CVE-2020-5328": {"epss_score": 0.00391, "epss_percentile": 0.59578}, "CVE-2020-5329": {"epss_score": 0.00203, "epss_percentile": 0.42548}, "CVE-2020-5330": {"epss_score": 0.20574, "epss_percentile": 0.95379}, "CVE-2020-5331": {"epss_score": 0.00166, "epss_percentile": 0.38234}, "CVE-2020-5332": {"epss_score": 0.02018, "epss_percentile": 0.83288}, "CVE-2020-5333": {"epss_score": 0.00111, "epss_percentile": 0.30387}, "CVE-2020-5334": {"epss_score": 0.00707, "epss_percentile": 0.71643}, "CVE-2020-5335": {"epss_score": 0.00078, "epss_percentile": 0.23611}, "CVE-2020-5336": {"epss_score": 0.0062, "epss_percentile": 0.69458}, "CVE-2020-5337": {"epss_score": 0.00163, "epss_percentile": 0.37795}, "CVE-2020-5339": {"epss_score": 0.00234, "epss_percentile": 0.46165}, "CVE-2020-5340": {"epss_score": 0.00237, "epss_percentile": 0.46693}, "CVE-2020-5341": {"epss_score": 0.1271, "epss_percentile": 0.93754}, "CVE-2020-5342": {"epss_score": 0.00203, "epss_percentile": 0.42503}, "CVE-2020-5343": {"epss_score": 0.0002, "epss_percentile": 0.04462}, "CVE-2020-5344": {"epss_score": 0.04115, "epss_percentile": 0.88276}, "CVE-2020-5345": {"epss_score": 0.00458, "epss_percentile": 0.63443}, "CVE-2020-5346": {"epss_score": 0.00289, "epss_percentile": 0.52015}, "CVE-2020-5347": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2020-5348": {"epss_score": 0.00115, "epss_percentile": 0.31007}, "CVE-2020-5349": {"epss_score": 0.00359, "epss_percentile": 0.57604}, "CVE-2020-5350": {"epss_score": 0.03682, "epss_percentile": 0.8756}, "CVE-2020-5351": {"epss_score": 0.00285, "epss_percentile": 0.51677}, "CVE-2020-5352": {"epss_score": 0.05549, "epss_percentile": 0.89984}, "CVE-2020-5353": {"epss_score": 0.00336, "epss_percentile": 0.55944}, "CVE-2020-5355": {"epss_score": 0.00157, "epss_percentile": 0.37138}, "CVE-2020-5356": {"epss_score": 0.00173, "epss_percentile": 0.39121}, "CVE-2020-5357": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-5358": {"epss_score": 0.00017, "epss_percentile": 0.03111}, "CVE-2020-5359": {"epss_score": 0.0042, "epss_percentile": 0.61427}, "CVE-2020-5360": {"epss_score": 0.01804, "epss_percentile": 0.82344}, "CVE-2020-5361": {"epss_score": 0.00052, "epss_percentile": 0.16353}, "CVE-2020-5362": {"epss_score": 0.00051, "epss_percentile": 0.16258}, "CVE-2020-5363": {"epss_score": 0.00048, "epss_percentile": 0.15266}, "CVE-2020-5364": {"epss_score": 0.0026, "epss_percentile": 0.49152}, "CVE-2020-5365": {"epss_score": 0.0026, "epss_percentile": 0.49152}, "CVE-2020-5366": {"epss_score": 0.00426, "epss_percentile": 0.61768}, "CVE-2020-5367": {"epss_score": 0.0029, "epss_percentile": 0.52081}, "CVE-2020-5368": {"epss_score": 0.00626, "epss_percentile": 0.69601}, "CVE-2020-5369": {"epss_score": 0.0046, "epss_percentile": 0.63512}, "CVE-2020-5370": {"epss_score": 0.01143, "epss_percentile": 0.7798}, "CVE-2020-5371": {"epss_score": 0.00277, "epss_percentile": 0.50818}, "CVE-2020-5372": {"epss_score": 0.00661, "epss_percentile": 0.70588}, "CVE-2020-5373": {"epss_score": 0.00276, "epss_percentile": 0.50708}, "CVE-2020-5374": {"epss_score": 0.00405, "epss_percentile": 0.60505}, "CVE-2020-5376": {"epss_score": 0.00046, "epss_percentile": 0.14421}, "CVE-2020-5377": {"epss_score": 0.78587, "epss_percentile": 0.98992}, "CVE-2020-5378": {"epss_score": 0.00046, "epss_percentile": 0.14421}, "CVE-2020-5379": {"epss_score": 0.00126, "epss_percentile": 0.32659}, "CVE-2020-5383": {"epss_score": 0.0029, "epss_percentile": 0.52083}, "CVE-2020-5384": {"epss_score": 0.00051, "epss_percentile": 0.16287}, "CVE-2020-5385": {"epss_score": 0.00019, "epss_percentile": 0.04353}, "CVE-2020-5386": {"epss_score": 0.00879, "epss_percentile": 0.74836}, "CVE-2020-5387": {"epss_score": 0.00138, "epss_percentile": 0.34384}, "CVE-2020-5388": {"epss_score": 0.00045, "epss_percentile": 0.13777}, "CVE-2020-5389": {"epss_score": 0.00335, "epss_percentile": 0.55896}, "CVE-2020-5390": {"epss_score": 0.00763, "epss_percentile": 0.72885}, "CVE-2020-5391": {"epss_score": 0.00247, "epss_percentile": 0.4781}, "CVE-2020-5392": {"epss_score": 0.00243, "epss_percentile": 0.47415}, "CVE-2020-5393": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-5395": {"epss_score": 0.00279, "epss_percentile": 0.50925}, "CVE-2020-5396": {"epss_score": 0.01602, "epss_percentile": 0.81268}, "CVE-2020-5397": {"epss_score": 0.00889, "epss_percentile": 0.75016}, "CVE-2020-5398": {"epss_score": 0.90205, "epss_percentile": 0.99568}, "CVE-2020-5399": {"epss_score": 0.002, "epss_percentile": 0.42215}, "CVE-2020-5400": {"epss_score": 0.00326, "epss_percentile": 0.55066}, "CVE-2020-5401": {"epss_score": 0.00448, "epss_percentile": 0.6302}, "CVE-2020-5402": {"epss_score": 0.0021, "epss_percentile": 0.43452}, "CVE-2020-5403": {"epss_score": 0.00331, "epss_percentile": 0.55508}, "CVE-2020-5404": {"epss_score": 0.00228, "epss_percentile": 0.45501}, "CVE-2020-5405": {"epss_score": 0.87989, "epss_percentile": 0.99454}, "CVE-2020-5406": {"epss_score": 0.00228, "epss_percentile": 0.4553}, "CVE-2020-5407": {"epss_score": 0.00665, "epss_percentile": 0.70652}, "CVE-2020-5408": {"epss_score": 0.00468, "epss_percentile": 0.63895}, "CVE-2020-5409": {"epss_score": 0.00666, "epss_percentile": 0.70682}, "CVE-2020-5410": {"epss_score": 0.94323, "epss_percentile": 0.99948}, "CVE-2020-5411": {"epss_score": 0.00805, "epss_percentile": 0.73636}, "CVE-2020-5412": {"epss_score": 0.92376, "epss_percentile": 0.99711}, "CVE-2020-5413": {"epss_score": 0.02178, "epss_percentile": 0.83892}, "CVE-2020-5414": {"epss_score": 0.00564, "epss_percentile": 0.67765}, "CVE-2020-5415": {"epss_score": 0.00257, "epss_percentile": 0.48877}, "CVE-2020-5416": {"epss_score": 0.00501, "epss_percentile": 0.65338}, "CVE-2020-5417": {"epss_score": 0.00336, "epss_percentile": 0.55939}, "CVE-2020-5418": {"epss_score": 0.00171, "epss_percentile": 0.3879}, "CVE-2020-5419": {"epss_score": 0.0007, "epss_percentile": 0.21862}, "CVE-2020-5420": {"epss_score": 0.00175, "epss_percentile": 0.39307}, "CVE-2020-5421": {"epss_score": 0.56167, "epss_percentile": 0.9801}, "CVE-2020-5422": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2020-5423": {"epss_score": 0.00421, "epss_percentile": 0.61514}, "CVE-2020-5425": {"epss_score": 0.0013, "epss_percentile": 0.33224}, "CVE-2020-5426": {"epss_score": 0.00179, "epss_percentile": 0.39849}, "CVE-2020-5427": {"epss_score": 0.01047, "epss_percentile": 0.77044}, "CVE-2020-5428": {"epss_score": 0.00277, "epss_percentile": 0.50795}, "CVE-2020-5496": {"epss_score": 0.00204, "epss_percentile": 0.42641}, "CVE-2020-5497": {"epss_score": 0.00364, "epss_percentile": 0.57908}, "CVE-2020-5499": {"epss_score": 0.0138, "epss_percentile": 0.79857}, "CVE-2020-5501": {"epss_score": 0.00104, "epss_percentile": 0.29178}, "CVE-2020-5502": {"epss_score": 0.00104, "epss_percentile": 0.29178}, "CVE-2020-5504": {"epss_score": 0.23142, "epss_percentile": 0.9574}, "CVE-2020-5505": {"epss_score": 0.23035, "epss_percentile": 0.95722}, "CVE-2020-5509": {"epss_score": 0.05558, "epss_percentile": 0.89992}, "CVE-2020-5510": {"epss_score": 0.0032, "epss_percentile": 0.54579}, "CVE-2020-5511": {"epss_score": 0.00524, "epss_percentile": 0.66331}, "CVE-2020-5512": {"epss_score": 0.00842, "epss_percentile": 0.7424}, "CVE-2020-5513": {"epss_score": 0.02575, "epss_percentile": 0.8514}, "CVE-2020-5514": {"epss_score": 0.00835, "epss_percentile": 0.74119}, "CVE-2020-5515": {"epss_score": 0.63344, "epss_percentile": 0.98329}, "CVE-2020-5517": {"epss_score": 0.00191, "epss_percentile": 0.41208}, "CVE-2020-5519": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2020-5520": {"epss_score": 0.00138, "epss_percentile": 0.34458}, "CVE-2020-5521": {"epss_score": 0.00138, "epss_percentile": 0.34458}, "CVE-2020-5522": {"epss_score": 0.00138, "epss_percentile": 0.34458}, "CVE-2020-5523": {"epss_score": 0.00384, "epss_percentile": 0.59122}, "CVE-2020-5524": {"epss_score": 0.00224, "epss_percentile": 0.45063}, "CVE-2020-5525": {"epss_score": 0.00229, "epss_percentile": 0.45616}, "CVE-2020-5526": {"epss_score": 0.00156, "epss_percentile": 0.36992}, "CVE-2020-5527": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2020-5528": {"epss_score": 0.00429, "epss_percentile": 0.61969}, "CVE-2020-5529": {"epss_score": 0.02085, "epss_percentile": 0.83546}, "CVE-2020-5530": {"epss_score": 0.00137, "epss_percentile": 0.34291}, "CVE-2020-5531": {"epss_score": 0.0077, "epss_percentile": 0.73001}, "CVE-2020-5532": {"epss_score": 0.00324, "epss_percentile": 0.54936}, "CVE-2020-5533": {"epss_score": 0.00429, "epss_percentile": 0.61969}, "CVE-2020-5534": {"epss_score": 0.00229, "epss_percentile": 0.45616}, "CVE-2020-5535": {"epss_score": 0.00499, "epss_percentile": 0.65277}, "CVE-2020-5536": {"epss_score": 0.001, "epss_percentile": 0.28441}, "CVE-2020-5537": {"epss_score": 0.03262, "epss_percentile": 0.86775}, "CVE-2020-5538": {"epss_score": 0.00046, "epss_percentile": 0.14468}, "CVE-2020-5539": {"epss_score": 0.00415, "epss_percentile": 0.61148}, "CVE-2020-5540": {"epss_score": 0.00421, "epss_percentile": 0.61501}, "CVE-2020-5541": {"epss_score": 0.00555, "epss_percentile": 0.67459}, "CVE-2020-5542": {"epss_score": 0.00976, "epss_percentile": 0.7621}, "CVE-2020-5543": {"epss_score": 0.00947, "epss_percentile": 0.75822}, "CVE-2020-5544": {"epss_score": 0.00838, "epss_percentile": 0.74181}, "CVE-2020-5545": {"epss_score": 0.00117, "epss_percentile": 0.31217}, "CVE-2020-5546": {"epss_score": 0.00162, "epss_percentile": 0.37645}, "CVE-2020-5547": {"epss_score": 0.00976, "epss_percentile": 0.7621}, "CVE-2020-5548": {"epss_score": 0.01325, "epss_percentile": 0.79477}, "CVE-2020-5549": {"epss_score": 0.00196, "epss_percentile": 0.41737}, "CVE-2020-5550": {"epss_score": 0.00473, "epss_percentile": 0.64086}, "CVE-2020-5551": {"epss_score": 0.00585, "epss_percentile": 0.68401}, "CVE-2020-5552": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2020-5553": {"epss_score": 0.02142, "epss_percentile": 0.83753}, "CVE-2020-5554": {"epss_score": 0.00333, "epss_percentile": 0.55677}, "CVE-2020-5555": {"epss_score": 0.00389, "epss_percentile": 0.59466}, "CVE-2020-5556": {"epss_score": 0.02142, "epss_percentile": 0.83753}, "CVE-2020-5557": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2020-5558": {"epss_score": 0.01472, "epss_percentile": 0.8051}, "CVE-2020-5559": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2020-5560": {"epss_score": 0.02142, "epss_percentile": 0.83753}, "CVE-2020-5561": {"epss_score": 0.02142, "epss_percentile": 0.83753}, "CVE-2020-5562": {"epss_score": 0.00239, "epss_percentile": 0.46906}, "CVE-2020-5563": {"epss_score": 0.00636, "epss_percentile": 0.69866}, "CVE-2020-5564": {"epss_score": 0.00402, "epss_percentile": 0.60275}, "CVE-2020-5565": {"epss_score": 0.00238, "epss_percentile": 0.46804}, "CVE-2020-5566": {"epss_score": 0.00264, "epss_percentile": 0.4973}, "CVE-2020-5567": {"epss_score": 0.00813, "epss_percentile": 0.73761}, "CVE-2020-5568": {"epss_score": 0.00402, "epss_percentile": 0.60275}, "CVE-2020-5569": {"epss_score": 0.00162, "epss_percentile": 0.37661}, "CVE-2020-5570": {"epss_score": 0.00261, "epss_percentile": 0.49291}, "CVE-2020-5571": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2020-5572": {"epss_score": 0.00063, "epss_percentile": 0.19948}, "CVE-2020-5573": {"epss_score": 0.00063, "epss_percentile": 0.19948}, "CVE-2020-5574": {"epss_score": 0.00338, "epss_percentile": 0.56142}, "CVE-2020-5575": {"epss_score": 0.00305, "epss_percentile": 0.53335}, "CVE-2020-5576": {"epss_score": 0.00149, "epss_percentile": 0.36011}, "CVE-2020-5577": {"epss_score": 0.00851, "epss_percentile": 0.7441}, "CVE-2020-5579": {"epss_score": 0.01829, "epss_percentile": 0.82442}, "CVE-2020-5580": {"epss_score": 0.00215, "epss_percentile": 0.4403}, "CVE-2020-5581": {"epss_score": 0.00276, "epss_percentile": 0.50761}, "CVE-2020-5582": {"epss_score": 0.00188, "epss_percentile": 0.40909}, "CVE-2020-5583": {"epss_score": 0.00226, "epss_percentile": 0.45315}, "CVE-2020-5584": {"epss_score": 0.004, "epss_percentile": 0.60158}, "CVE-2020-5585": {"epss_score": 0.00403, "epss_percentile": 0.60384}, "CVE-2020-5586": {"epss_score": 0.00352, "epss_percentile": 0.57127}, "CVE-2020-5587": {"epss_score": 0.00249, "epss_percentile": 0.4807}, "CVE-2020-5588": {"epss_score": 0.00417, "epss_percentile": 0.61254}, "CVE-2020-5589": {"epss_score": 0.00116, "epss_percentile": 0.31105}, "CVE-2020-5590": {"epss_score": 0.02208, "epss_percentile": 0.84009}, "CVE-2020-5591": {"epss_score": 0.00979, "epss_percentile": 0.76255}, "CVE-2020-5592": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2020-5593": {"epss_score": 0.0079, "epss_percentile": 0.73369}, "CVE-2020-5594": {"epss_score": 0.00331, "epss_percentile": 0.55539}, "CVE-2020-5595": {"epss_score": 0.00387, "epss_percentile": 0.59303}, "CVE-2020-5596": {"epss_score": 0.00145, "epss_percentile": 0.35413}, "CVE-2020-5597": {"epss_score": 0.00265, "epss_percentile": 0.49753}, "CVE-2020-5598": {"epss_score": 0.00141, "epss_percentile": 0.3484}, "CVE-2020-5599": {"epss_score": 0.01256, "epss_percentile": 0.78933}, "CVE-2020-5600": {"epss_score": 0.00264, "epss_percentile": 0.49574}, "CVE-2020-5601": {"epss_score": 0.00689, "epss_percentile": 0.71225}, "CVE-2020-5602": {"epss_score": 0.00408, "epss_percentile": 0.60677}, "CVE-2020-5603": {"epss_score": 0.00494, "epss_percentile": 0.6509}, "CVE-2020-5604": {"epss_score": 0.01475, "epss_percentile": 0.80527}, "CVE-2020-5605": {"epss_score": 0.00143, "epss_percentile": 0.35174}, "CVE-2020-5606": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2020-5607": {"epss_score": 0.00591, "epss_percentile": 0.68594}, "CVE-2020-5608": {"epss_score": 0.01674, "epss_percentile": 0.81699}, "CVE-2020-5609": {"epss_score": 0.04514, "epss_percentile": 0.88787}, "CVE-2020-5610": {"epss_score": 0.00246, "epss_percentile": 0.47781}, "CVE-2020-5611": {"epss_score": 0.02182, "epss_percentile": 0.8391}, "CVE-2020-5612": {"epss_score": 0.00422, "epss_percentile": 0.61544}, "CVE-2020-5613": {"epss_score": 0.00422, "epss_percentile": 0.61544}, "CVE-2020-5614": {"epss_score": 0.00258, "epss_percentile": 0.48948}, "CVE-2020-5615": {"epss_score": 0.00142, "epss_percentile": 0.34988}, "CVE-2020-5616": {"epss_score": 0.03863, "epss_percentile": 0.87868}, "CVE-2020-5617": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2020-5619": {"epss_score": 0.00203, "epss_percentile": 0.42571}, "CVE-2020-5620": {"epss_score": 0.00203, "epss_percentile": 0.42571}, "CVE-2020-5621": {"epss_score": 0.00157, "epss_percentile": 0.3705}, "CVE-2020-5622": {"epss_score": 0.00721, "epss_percentile": 0.7197}, "CVE-2020-5623": {"epss_score": 0.00214, "epss_percentile": 0.43967}, "CVE-2020-5624": {"epss_score": 0.00888, "epss_percentile": 0.74996}, "CVE-2020-5625": {"epss_score": 0.00435, "epss_percentile": 0.62353}, "CVE-2020-5626": {"epss_score": 0.02109, "epss_percentile": 0.83641}, "CVE-2020-5627": {"epss_score": 0.00214, "epss_percentile": 0.43967}, "CVE-2020-5628": {"epss_score": 0.00231, "epss_percentile": 0.45823}, "CVE-2020-5629": {"epss_score": 0.00231, "epss_percentile": 0.45823}, "CVE-2020-5631": {"epss_score": 0.00435, "epss_percentile": 0.62353}, "CVE-2020-5632": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2020-5633": {"epss_score": 0.00979, "epss_percentile": 0.76255}, "CVE-2020-5634": {"epss_score": 0.0013, "epss_percentile": 0.33256}, "CVE-2020-5635": {"epss_score": 0.00414, "epss_percentile": 0.61021}, "CVE-2020-5636": {"epss_score": 0.00244, "epss_percentile": 0.4752}, "CVE-2020-5637": {"epss_score": 0.00129, "epss_percentile": 0.33075}, "CVE-2020-5638": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2020-5639": {"epss_score": 0.09206, "epss_percentile": 0.92448}, "CVE-2020-5640": {"epss_score": 0.03091, "epss_percentile": 0.86396}, "CVE-2020-5641": {"epss_score": 0.00092, "epss_percentile": 0.26574}, "CVE-2020-5642": {"epss_score": 0.00102, "epss_percentile": 0.28744}, "CVE-2020-5643": {"epss_score": 0.00136, "epss_percentile": 0.3419}, "CVE-2020-5644": {"epss_score": 0.01174, "epss_percentile": 0.78255}, "CVE-2020-5645": {"epss_score": 0.00962, "epss_percentile": 0.75988}, "CVE-2020-5646": {"epss_score": 0.00485, "epss_percentile": 0.64703}, "CVE-2020-5647": {"epss_score": 0.00525, "epss_percentile": 0.66374}, "CVE-2020-5648": {"epss_score": 0.00967, "epss_percentile": 0.76069}, "CVE-2020-5649": {"epss_score": 0.00938, "epss_percentile": 0.7571}, "CVE-2020-5650": {"epss_score": 0.00278, "epss_percentile": 0.50895}, "CVE-2020-5651": {"epss_score": 0.00747, "epss_percentile": 0.72554}, "CVE-2020-5652": {"epss_score": 0.02972, "epss_percentile": 0.86099}, "CVE-2020-5653": {"epss_score": 0.00864, "epss_percentile": 0.74613}, "CVE-2020-5654": {"epss_score": 0.00615, "epss_percentile": 0.69294}, "CVE-2020-5655": {"epss_score": 0.00601, "epss_percentile": 0.6886}, "CVE-2020-5656": {"epss_score": 0.00749, "epss_percentile": 0.7261}, "CVE-2020-5657": {"epss_score": 0.00171, "epss_percentile": 0.38793}, "CVE-2020-5658": {"epss_score": 0.006, "epss_percentile": 0.68809}, "CVE-2020-5659": {"epss_score": 0.00714, "epss_percentile": 0.71807}, "CVE-2020-5662": {"epss_score": 0.00203, "epss_percentile": 0.42571}, "CVE-2020-5663": {"epss_score": 0.00197, "epss_percentile": 0.41829}, "CVE-2020-5664": {"epss_score": 0.06208, "epss_percentile": 0.90568}, "CVE-2020-5665": {"epss_score": 0.00178, "epss_percentile": 0.39708}, "CVE-2020-5666": {"epss_score": 0.18403, "epss_percentile": 0.95012}, "CVE-2020-5667": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2020-5668": {"epss_score": 0.03119, "epss_percentile": 0.86442}, "CVE-2020-5669": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2020-5674": {"epss_score": 0.00082, "epss_percentile": 0.24398}, "CVE-2020-5675": {"epss_score": 0.00316, "epss_percentile": 0.54217}, "CVE-2020-5676": {"epss_score": 0.00569, "epss_percentile": 0.67937}, "CVE-2020-5677": {"epss_score": 0.00419, "epss_percentile": 0.61379}, "CVE-2020-5678": {"epss_score": 0.0059, "epss_percentile": 0.68576}, "CVE-2020-5679": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2020-5680": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2020-5681": {"epss_score": 0.00171, "epss_percentile": 0.38824}, "CVE-2020-5682": {"epss_score": 0.00846, "epss_percentile": 0.74321}, "CVE-2020-5683": {"epss_score": 0.00957, "epss_percentile": 0.75931}, "CVE-2020-5684": {"epss_score": 0.001, "epss_percentile": 0.28507}, "CVE-2020-5685": {"epss_score": 0.00614, "epss_percentile": 0.69269}, "CVE-2020-5686": {"epss_score": 0.0029, "epss_percentile": 0.52128}, "CVE-2020-5720": {"epss_score": 0.00281, "epss_percentile": 0.51115}, "CVE-2020-5721": {"epss_score": 0.00101, "epss_percentile": 0.28655}, "CVE-2020-5722": {"epss_score": 0.90907, "epss_percentile": 0.99609}, "CVE-2020-5723": {"epss_score": 0.51792, "epss_percentile": 0.97798}, "CVE-2020-5724": {"epss_score": 0.6003, "epss_percentile": 0.9819}, "CVE-2020-5725": {"epss_score": 0.00389, "epss_percentile": 0.59468}, "CVE-2020-5726": {"epss_score": 0.06357, "epss_percentile": 0.90696}, "CVE-2020-5727": {"epss_score": 0.00066, "epss_percentile": 0.20893}, "CVE-2020-5728": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-5729": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-5730": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-5731": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-5732": {"epss_score": 0.00993, "epss_percentile": 0.7641}, "CVE-2020-5733": {"epss_score": 0.00993, "epss_percentile": 0.7641}, "CVE-2020-5734": {"epss_score": 0.13115, "epss_percentile": 0.93878}, "CVE-2020-5735": {"epss_score": 0.61634, "epss_percentile": 0.98255}, "CVE-2020-5736": {"epss_score": 0.00728, "epss_percentile": 0.72111}, "CVE-2020-5737": {"epss_score": 0.00227, "epss_percentile": 0.45377}, "CVE-2020-5738": {"epss_score": 0.05144, "epss_percentile": 0.8954}, "CVE-2020-5739": {"epss_score": 0.02439, "epss_percentile": 0.84748}, "CVE-2020-5740": {"epss_score": 0.00254, "epss_percentile": 0.48554}, "CVE-2020-5741": {"epss_score": 0.46122, "epss_percentile": 0.97531}, "CVE-2020-5742": {"epss_score": 0.00816, "epss_percentile": 0.73804}, "CVE-2020-5743": {"epss_score": 0.00144, "epss_percentile": 0.35286}, "CVE-2020-5744": {"epss_score": 0.00301, "epss_percentile": 0.53}, "CVE-2020-5745": {"epss_score": 0.00151, "epss_percentile": 0.36316}, "CVE-2020-5746": {"epss_score": 0.00157, "epss_percentile": 0.37034}, "CVE-2020-5747": {"epss_score": 0.00157, "epss_percentile": 0.37034}, "CVE-2020-5748": {"epss_score": 0.01138, "epss_percentile": 0.7793}, "CVE-2020-5749": {"epss_score": 0.00157, "epss_percentile": 0.37034}, "CVE-2020-5750": {"epss_score": 0.01283, "epss_percentile": 0.79161}, "CVE-2020-5751": {"epss_score": 0.00157, "epss_percentile": 0.37034}, "CVE-2020-5752": {"epss_score": 0.10024, "epss_percentile": 0.92819}, "CVE-2020-5753": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2020-5754": {"epss_score": 0.00806, "epss_percentile": 0.73665}, "CVE-2020-5755": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2020-5756": {"epss_score": 0.01756, "epss_percentile": 0.82123}, "CVE-2020-5757": {"epss_score": 0.18523, "epss_percentile": 0.95028}, "CVE-2020-5758": {"epss_score": 0.05192, "epss_percentile": 0.89597}, "CVE-2020-5759": {"epss_score": 0.08108, "epss_percentile": 0.91883}, "CVE-2020-5760": {"epss_score": 0.03942, "epss_percentile": 0.8799}, "CVE-2020-5761": {"epss_score": 0.02154, "epss_percentile": 0.838}, "CVE-2020-5762": {"epss_score": 0.0137, "epss_percentile": 0.79799}, "CVE-2020-5763": {"epss_score": 0.01312, "epss_percentile": 0.79377}, "CVE-2020-5764": {"epss_score": 0.00645, "epss_percentile": 0.70117}, "CVE-2020-5765": {"epss_score": 0.0038, "epss_percentile": 0.58932}, "CVE-2020-5766": {"epss_score": 0.39068, "epss_percentile": 0.97136}, "CVE-2020-5767": {"epss_score": 0.00127, "epss_percentile": 0.3293}, "CVE-2020-5768": {"epss_score": 0.0105, "epss_percentile": 0.77074}, "CVE-2020-5769": {"epss_score": 0.00157, "epss_percentile": 0.37034}, "CVE-2020-5770": {"epss_score": 0.0015, "epss_percentile": 0.36074}, "CVE-2020-5771": {"epss_score": 0.01918, "epss_percentile": 0.82877}, "CVE-2020-5772": {"epss_score": 0.00407, "epss_percentile": 0.60588}, "CVE-2020-5773": {"epss_score": 0.0031, "epss_percentile": 0.53799}, "CVE-2020-5774": {"epss_score": 0.00044, "epss_percentile": 0.13614}, "CVE-2020-5775": {"epss_score": 0.70759, "epss_percentile": 0.98641}, "CVE-2020-5776": {"epss_score": 0.79726, "epss_percentile": 0.99053}, "CVE-2020-5777": {"epss_score": 0.91472, "epss_percentile": 0.99647}, "CVE-2020-5778": {"epss_score": 0.00803, "epss_percentile": 0.73597}, "CVE-2020-5779": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-5780": {"epss_score": 0.0043, "epss_percentile": 0.62033}, "CVE-2020-5781": {"epss_score": 0.00299, "epss_percentile": 0.52866}, "CVE-2020-5782": {"epss_score": 0.00273, "epss_percentile": 0.50446}, "CVE-2020-5783": {"epss_score": 0.00115, "epss_percentile": 0.30976}, "CVE-2020-5784": {"epss_score": 0.0016, "epss_percentile": 0.37448}, "CVE-2020-5785": {"epss_score": 0.01056, "epss_percentile": 0.77123}, "CVE-2020-5786": {"epss_score": 0.00287, "epss_percentile": 0.51814}, "CVE-2020-5787": {"epss_score": 0.01588, "epss_percentile": 0.81191}, "CVE-2020-5788": {"epss_score": 0.00861, "epss_percentile": 0.74567}, "CVE-2020-5789": {"epss_score": 0.00263, "epss_percentile": 0.49519}, "CVE-2020-5790": {"epss_score": 0.02669, "epss_percentile": 0.85383}, "CVE-2020-5791": {"epss_score": 0.87753, "epss_percentile": 0.99441}, "CVE-2020-5792": {"epss_score": 0.81197, "epss_percentile": 0.99127}, "CVE-2020-5793": {"epss_score": 0.0011, "epss_percentile": 0.30213}, "CVE-2020-5794": {"epss_score": 0.00052, "epss_percentile": 0.16344}, "CVE-2020-5795": {"epss_score": 0.00127, "epss_percentile": 0.32875}, "CVE-2020-5796": {"epss_score": 0.00075, "epss_percentile": 0.23028}, "CVE-2020-5797": {"epss_score": 0.00199, "epss_percentile": 0.42157}, "CVE-2020-5798": {"epss_score": 0.00016, "epss_percentile": 0.02743}, "CVE-2020-5799": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-5800": {"epss_score": 0.00444, "epss_percentile": 0.62827}, "CVE-2020-5801": {"epss_score": 0.00221, "epss_percentile": 0.44649}, "CVE-2020-5802": {"epss_score": 0.00168, "epss_percentile": 0.38456}, "CVE-2020-5803": {"epss_score": 0.00814, "epss_percentile": 0.73778}, "CVE-2020-5804": {"epss_score": 0.00893, "epss_percentile": 0.75075}, "CVE-2020-5805": {"epss_score": 0.002, "epss_percentile": 0.422}, "CVE-2020-5806": {"epss_score": 5e-05, "epss_percentile": 0.00216}, "CVE-2020-5807": {"epss_score": 0.00593, "epss_percentile": 0.68649}, "CVE-2020-5808": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-5809": {"epss_score": 0.0042, "epss_percentile": 0.61413}, "CVE-2020-5810": {"epss_score": 0.03495, "epss_percentile": 0.87236}, "CVE-2020-5811": {"epss_score": 0.02606, "epss_percentile": 0.85225}, "CVE-2020-5812": {"epss_score": 0.00107, "epss_percentile": 0.29578}, "CVE-2020-5820": {"epss_score": 0.00072, "epss_percentile": 0.22272}, "CVE-2020-5821": {"epss_score": 0.00072, "epss_percentile": 0.22272}, "CVE-2020-5822": {"epss_score": 0.00072, "epss_percentile": 0.22272}, "CVE-2020-5823": {"epss_score": 0.00072, "epss_percentile": 0.22272}, "CVE-2020-5824": {"epss_score": 0.00063, "epss_percentile": 0.19835}, "CVE-2020-5825": {"epss_score": 0.00091, "epss_percentile": 0.26277}, "CVE-2020-5826": {"epss_score": 0.00063, "epss_percentile": 0.19835}, "CVE-2020-5827": {"epss_score": 0.00067, "epss_percentile": 0.21152}, "CVE-2020-5828": {"epss_score": 0.00067, "epss_percentile": 0.21152}, "CVE-2020-5829": {"epss_score": 0.00067, "epss_percentile": 0.21152}, "CVE-2020-5830": {"epss_score": 0.00067, "epss_percentile": 0.21152}, "CVE-2020-5831": {"epss_score": 0.00067, "epss_percentile": 0.21152}, "CVE-2020-5832": {"epss_score": 0.00208, "epss_percentile": 0.43255}, "CVE-2020-5833": {"epss_score": 0.00065, "epss_percentile": 0.20651}, "CVE-2020-5834": {"epss_score": 0.00153, "epss_percentile": 0.36552}, "CVE-2020-5835": {"epss_score": 0.00055, "epss_percentile": 0.17653}, "CVE-2020-5836": {"epss_score": 0.00072, "epss_percentile": 0.22272}, "CVE-2020-5837": {"epss_score": 0.0177, "epss_percentile": 0.82191}, "CVE-2020-5838": {"epss_score": 0.00497, "epss_percentile": 0.652}, "CVE-2020-5839": {"epss_score": 0.01513, "epss_percentile": 0.80788}, "CVE-2020-5840": {"epss_score": 0.00469, "epss_percentile": 0.63919}, "CVE-2020-5841": {"epss_score": 0.00328, "epss_percentile": 0.55268}, "CVE-2020-5842": {"epss_score": 0.01819, "epss_percentile": 0.82403}, "CVE-2020-5843": {"epss_score": 0.00412, "epss_percentile": 0.60936}, "CVE-2020-5844": {"epss_score": 0.77105, "epss_percentile": 0.98922}, "CVE-2020-5846": {"epss_score": 0.00799, "epss_percentile": 0.73524}, "CVE-2020-5847": {"epss_score": 0.93678, "epss_percentile": 0.99833}, "CVE-2020-5849": {"epss_score": 0.93763, "epss_percentile": 0.99841}, "CVE-2020-5851": {"epss_score": 0.00206, "epss_percentile": 0.42949}, "CVE-2020-5852": {"epss_score": 0.00896, "epss_percentile": 0.75117}, "CVE-2020-5853": {"epss_score": 0.00328, "epss_percentile": 0.55193}, "CVE-2020-5854": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2020-5855": {"epss_score": 0.0015, "epss_percentile": 0.36115}, "CVE-2020-5856": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2020-5857": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2020-5858": {"epss_score": 0.0022, "epss_percentile": 0.44572}, "CVE-2020-5859": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2020-5860": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2020-5861": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2020-5862": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2020-5863": {"epss_score": 0.01111, "epss_percentile": 0.77667}, "CVE-2020-5864": {"epss_score": 0.00422, "epss_percentile": 0.61559}, "CVE-2020-5865": {"epss_score": 0.00119, "epss_percentile": 0.31629}, "CVE-2020-5866": {"epss_score": 0.001, "epss_percentile": 0.28452}, "CVE-2020-5867": {"epss_score": 0.00149, "epss_percentile": 0.35945}, "CVE-2020-5868": {"epss_score": 0.03878, "epss_percentile": 0.87893}, "CVE-2020-5869": {"epss_score": 0.00288, "epss_percentile": 0.51872}, "CVE-2020-5870": {"epss_score": 0.0022, "epss_percentile": 0.44602}, "CVE-2020-5871": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5872": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5873": {"epss_score": 0.00286, "epss_percentile": 0.51777}, "CVE-2020-5874": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5875": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5876": {"epss_score": 0.00304, "epss_percentile": 0.53255}, "CVE-2020-5877": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5878": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5879": {"epss_score": 0.00251, "epss_percentile": 0.48297}, "CVE-2020-5880": {"epss_score": 0.00414, "epss_percentile": 0.61039}, "CVE-2020-5881": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5882": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5883": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5884": {"epss_score": 0.00616, "epss_percentile": 0.69321}, "CVE-2020-5885": {"epss_score": 0.00244, "epss_percentile": 0.47524}, "CVE-2020-5886": {"epss_score": 0.00244, "epss_percentile": 0.47524}, "CVE-2020-5887": {"epss_score": 0.00372, "epss_percentile": 0.58447}, "CVE-2020-5888": {"epss_score": 0.00158, "epss_percentile": 0.37244}, "CVE-2020-5889": {"epss_score": 0.00157, "epss_percentile": 0.37051}, "CVE-2020-5890": {"epss_score": 0.00133, "epss_percentile": 0.33634}, "CVE-2020-5891": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5892": {"epss_score": 0.00092, "epss_percentile": 0.26588}, "CVE-2020-5893": {"epss_score": 0.00127, "epss_percentile": 0.3293}, "CVE-2020-5894": {"epss_score": 0.00419, "epss_percentile": 0.61385}, "CVE-2020-5895": {"epss_score": 0.00062, "epss_percentile": 0.19694}, "CVE-2020-5896": {"epss_score": 0.00062, "epss_percentile": 0.19694}, "CVE-2020-5897": {"epss_score": 0.0086, "epss_percentile": 0.74535}, "CVE-2020-5898": {"epss_score": 0.00067, "epss_percentile": 0.21118}, "CVE-2020-5899": {"epss_score": 0.00038, "epss_percentile": 0.11411}, "CVE-2020-5900": {"epss_score": 0.00279, "epss_percentile": 0.50941}, "CVE-2020-5901": {"epss_score": 0.00883, "epss_percentile": 0.74913}, "CVE-2020-5902": {"epss_score": 0.94426, "epss_percentile": 0.99981}, "CVE-2020-5903": {"epss_score": 0.09081, "epss_percentile": 0.92391}, "CVE-2020-5904": {"epss_score": 0.00279, "epss_percentile": 0.50941}, "CVE-2020-5905": {"epss_score": 0.00255, "epss_percentile": 0.48644}, "CVE-2020-5906": {"epss_score": 0.00131, "epss_percentile": 0.3346}, "CVE-2020-5907": {"epss_score": 0.00358, "epss_percentile": 0.57526}, "CVE-2020-5908": {"epss_score": 0.0009, "epss_percentile": 0.26052}, "CVE-2020-5909": {"epss_score": 0.00117, "epss_percentile": 0.3134}, "CVE-2020-5910": {"epss_score": 0.00355, "epss_percentile": 0.57313}, "CVE-2020-5911": {"epss_score": 0.00387, "epss_percentile": 0.59308}, "CVE-2020-5912": {"epss_score": 0.00084, "epss_percentile": 0.24873}, "CVE-2020-5913": {"epss_score": 0.00193, "epss_percentile": 0.41423}, "CVE-2020-5914": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5915": {"epss_score": 0.00398, "epss_percentile": 0.60063}, "CVE-2020-5916": {"epss_score": 0.001, "epss_percentile": 0.28459}, "CVE-2020-5917": {"epss_score": 0.00251, "epss_percentile": 0.48297}, "CVE-2020-5918": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5919": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5920": {"epss_score": 0.00229, "epss_percentile": 0.45658}, "CVE-2020-5921": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5922": {"epss_score": 0.00156, "epss_percentile": 0.36911}, "CVE-2020-5923": {"epss_score": 0.00073, "epss_percentile": 0.22512}, "CVE-2020-5924": {"epss_score": 0.00526, "epss_percentile": 0.664}, "CVE-2020-5925": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5926": {"epss_score": 0.00834, "epss_percentile": 0.74097}, "CVE-2020-5927": {"epss_score": 0.00351, "epss_percentile": 0.57028}, "CVE-2020-5928": {"epss_score": 0.0004, "epss_percentile": 0.1191}, "CVE-2020-5929": {"epss_score": 0.00668, "epss_percentile": 0.70738}, "CVE-2020-5930": {"epss_score": 0.0086, "epss_percentile": 0.74534}, "CVE-2020-5931": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2020-5932": {"epss_score": 0.00254, "epss_percentile": 0.48516}, "CVE-2020-5933": {"epss_score": 0.00611, "epss_percentile": 0.69187}, "CVE-2020-5934": {"epss_score": 0.00178, "epss_percentile": 0.39685}, "CVE-2020-5935": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5936": {"epss_score": 0.00495, "epss_percentile": 0.65102}, "CVE-2020-5937": {"epss_score": 0.00611, "epss_percentile": 0.69187}, "CVE-2020-5938": {"epss_score": 0.00125, "epss_percentile": 0.3254}, "CVE-2020-5939": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5940": {"epss_score": 0.0028, "epss_percentile": 0.51009}, "CVE-2020-5941": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5942": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5943": {"epss_score": 0.00154, "epss_percentile": 0.3675}, "CVE-2020-5944": {"epss_score": 0.00295, "epss_percentile": 0.52478}, "CVE-2020-5945": {"epss_score": 0.00454, "epss_percentile": 0.63252}, "CVE-2020-5946": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5947": {"epss_score": 0.00185, "epss_percentile": 0.40474}, "CVE-2020-5948": {"epss_score": 0.00822, "epss_percentile": 0.73913}, "CVE-2020-5949": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2020-5950": {"epss_score": 0.00806, "epss_percentile": 0.73652}, "CVE-2020-5953": {"epss_score": 0.00293, "epss_percentile": 0.52295}, "CVE-2020-5955": {"epss_score": 0.00725, "epss_percentile": 0.72062}, "CVE-2020-5956": {"epss_score": 0.00409, "epss_percentile": 0.60728}, "CVE-2020-5957": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2020-5958": {"epss_score": 0.00143, "epss_percentile": 0.35169}, "CVE-2020-5959": {"epss_score": 0.00122, "epss_percentile": 0.3215}, "CVE-2020-5960": {"epss_score": 0.00122, "epss_percentile": 0.3215}, "CVE-2020-5961": {"epss_score": 0.00122, "epss_percentile": 0.3215}, "CVE-2020-5962": {"epss_score": 0.00048, "epss_percentile": 0.15052}, "CVE-2020-5963": {"epss_score": 0.00053, "epss_percentile": 0.16954}, "CVE-2020-5964": {"epss_score": 0.00023, "epss_percentile": 0.05418}, "CVE-2020-5965": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-5966": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-5967": {"epss_score": 0.00038, "epss_percentile": 0.11288}, "CVE-2020-5968": {"epss_score": 0.0006, "epss_percentile": 0.19144}, "CVE-2020-5969": {"epss_score": 0.00042, "epss_percentile": 0.1261}, "CVE-2020-5970": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-5971": {"epss_score": 0.0006, "epss_percentile": 0.19144}, "CVE-2020-5972": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-5973": {"epss_score": 0.00053, "epss_percentile": 0.16822}, "CVE-2020-5974": {"epss_score": 0.00032, "epss_percentile": 0.0911}, "CVE-2020-5975": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-5976": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-5977": {"epss_score": 0.00075, "epss_percentile": 0.22884}, "CVE-2020-5978": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-5979": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-5980": {"epss_score": 0.00057, "epss_percentile": 0.17968}, "CVE-2020-5981": {"epss_score": 0.00057, "epss_percentile": 0.17968}, "CVE-2020-5982": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-5983": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-5984": {"epss_score": 0.00098, "epss_percentile": 0.27682}, "CVE-2020-5985": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-5986": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-5987": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-5988": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2020-5989": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-5990": {"epss_score": 0.00054, "epss_percentile": 0.17042}, "CVE-2020-5991": {"epss_score": 0.0006, "epss_percentile": 0.19144}, "CVE-2020-5992": {"epss_score": 0.0006, "epss_percentile": 0.19152}, "CVE-2020-6007": {"epss_score": 0.03357, "epss_percentile": 0.86978}, "CVE-2020-6008": {"epss_score": 0.0755, "epss_percentile": 0.91533}, "CVE-2020-6009": {"epss_score": 0.00885, "epss_percentile": 0.74945}, "CVE-2020-6010": {"epss_score": 0.51506, "epss_percentile": 0.97782}, "CVE-2020-6012": {"epss_score": 0.00069, "epss_percentile": 0.2149}, "CVE-2020-6013": {"epss_score": 0.00935, "epss_percentile": 0.75668}, "CVE-2020-6014": {"epss_score": 0.00113, "epss_percentile": 0.30631}, "CVE-2020-6015": {"epss_score": 0.00055, "epss_percentile": 0.1744}, "CVE-2020-6016": {"epss_score": 0.06632, "epss_percentile": 0.90904}, "CVE-2020-6017": {"epss_score": 0.05655, "epss_percentile": 0.90088}, "CVE-2020-6018": {"epss_score": 0.05655, "epss_percentile": 0.90088}, "CVE-2020-6019": {"epss_score": 0.06723, "epss_percentile": 0.90969}, "CVE-2020-6020": {"epss_score": 0.00108, "epss_percentile": 0.29778}, "CVE-2020-6021": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-6022": {"epss_score": 0.00053, "epss_percentile": 0.16976}, "CVE-2020-6023": {"epss_score": 0.00068, "epss_percentile": 0.21234}, "CVE-2020-6024": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2020-6058": {"epss_score": 0.0016, "epss_percentile": 0.37486}, "CVE-2020-6059": {"epss_score": 0.00158, "epss_percentile": 0.37283}, "CVE-2020-6060": {"epss_score": 0.00435, "epss_percentile": 0.62369}, "CVE-2020-6061": {"epss_score": 0.01772, "epss_percentile": 0.822}, "CVE-2020-6062": {"epss_score": 0.08329, "epss_percentile": 0.91993}, "CVE-2020-6063": {"epss_score": 0.02248, "epss_percentile": 0.84139}, "CVE-2020-6064": {"epss_score": 0.02248, "epss_percentile": 0.84139}, "CVE-2020-6065": {"epss_score": 0.0288, "epss_percentile": 0.85895}, "CVE-2020-6066": {"epss_score": 0.02248, "epss_percentile": 0.84139}, "CVE-2020-6067": {"epss_score": 0.02248, "epss_percentile": 0.84139}, "CVE-2020-6068": {"epss_score": 0.02248, "epss_percentile": 0.84139}, "CVE-2020-6069": {"epss_score": 0.02248, "epss_percentile": 0.84139}, "CVE-2020-6070": {"epss_score": 0.00649, "epss_percentile": 0.70235}, "CVE-2020-6071": {"epss_score": 0.00613, "epss_percentile": 0.69241}, "CVE-2020-6072": {"epss_score": 0.022, "epss_percentile": 0.83974}, "CVE-2020-6073": {"epss_score": 0.01405, "epss_percentile": 0.80046}, "CVE-2020-6074": {"epss_score": 0.00387, "epss_percentile": 0.59292}, "CVE-2020-6075": {"epss_score": 0.01431, "epss_percentile": 0.80243}, "CVE-2020-6076": {"epss_score": 0.01431, "epss_percentile": 0.80243}, "CVE-2020-6077": {"epss_score": 0.00767, "epss_percentile": 0.7295}, "CVE-2020-6078": {"epss_score": 0.01405, "epss_percentile": 0.80046}, "CVE-2020-6079": {"epss_score": 0.01197, "epss_percentile": 0.78446}, "CVE-2020-6080": {"epss_score": 0.01082, "epss_percentile": 0.77385}, "CVE-2020-6081": {"epss_score": 0.00859, "epss_percentile": 0.74518}, "CVE-2020-6082": {"epss_score": 0.01431, "epss_percentile": 0.80243}, "CVE-2020-6083": {"epss_score": 0.00157, "epss_percentile": 0.37096}, "CVE-2020-6084": {"epss_score": 0.00042, "epss_percentile": 0.12673}, "CVE-2020-6085": {"epss_score": 0.00042, "epss_percentile": 0.12673}, "CVE-2020-6086": {"epss_score": 0.00042, "epss_percentile": 0.12673}, "CVE-2020-6087": {"epss_score": 0.00042, "epss_percentile": 0.12673}, "CVE-2020-6088": {"epss_score": 0.00157, "epss_percentile": 0.37096}, "CVE-2020-6089": {"epss_score": 0.01622, "epss_percentile": 0.814}, "CVE-2020-6090": {"epss_score": 0.01219, "epss_percentile": 0.78615}, "CVE-2020-6091": {"epss_score": 0.00351, "epss_percentile": 0.57075}, "CVE-2020-6092": {"epss_score": 0.00181, "epss_percentile": 0.4011}, "CVE-2020-6093": {"epss_score": 0.00011, "epss_percentile": 0.01109}, "CVE-2020-6094": {"epss_score": 0.01431, "epss_percentile": 0.80243}, "CVE-2020-6095": {"epss_score": 0.0053, "epss_percentile": 0.66615}, "CVE-2020-6096": {"epss_score": 0.0449, "epss_percentile": 0.88756}, "CVE-2020-6097": {"epss_score": 0.00288, "epss_percentile": 0.51923}, "CVE-2020-6098": {"epss_score": 0.00626, "epss_percentile": 0.69604}, "CVE-2020-6099": {"epss_score": 0.00827, "epss_percentile": 0.73978}, "CVE-2020-6100": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2020-6101": {"epss_score": 0.00932, "epss_percentile": 0.75631}, "CVE-2020-6102": {"epss_score": 0.00932, "epss_percentile": 0.75631}, "CVE-2020-6103": {"epss_score": 0.00932, "epss_percentile": 0.75631}, "CVE-2020-6104": {"epss_score": 0.0026, "epss_percentile": 0.49228}, "CVE-2020-6105": {"epss_score": 0.0061, "epss_percentile": 0.69157}, "CVE-2020-6106": {"epss_score": 0.00292, "epss_percentile": 0.52273}, "CVE-2020-6107": {"epss_score": 0.0026, "epss_percentile": 0.49228}, "CVE-2020-6108": {"epss_score": 0.0116, "epss_percentile": 0.78132}, "CVE-2020-6109": {"epss_score": 0.00675, "epss_percentile": 0.70907}, "CVE-2020-6110": {"epss_score": 0.01098, "epss_percentile": 0.77532}, "CVE-2020-6111": {"epss_score": 0.00089, "epss_percentile": 0.25935}, "CVE-2020-6112": {"epss_score": 0.00051, "epss_percentile": 0.16118}, "CVE-2020-6113": {"epss_score": 0.00495, "epss_percentile": 0.6513}, "CVE-2020-6114": {"epss_score": 0.02208, "epss_percentile": 0.84008}, "CVE-2020-6115": {"epss_score": 0.00011, "epss_percentile": 0.01109}, "CVE-2020-6116": {"epss_score": 0.00288, "epss_percentile": 0.5193}, "CVE-2020-6117": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6118": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6119": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6120": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6121": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6122": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6123": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6124": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6125": {"epss_score": 0.01726, "epss_percentile": 0.81963}, "CVE-2020-6126": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6127": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6128": {"epss_score": 0.01726, "epss_percentile": 0.81963}, "CVE-2020-6129": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6130": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6131": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6132": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6133": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6134": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2020-6135": {"epss_score": 0.01726, "epss_percentile": 0.81963}, "CVE-2020-6136": {"epss_score": 0.01726, "epss_percentile": 0.81963}, "CVE-2020-6137": {"epss_score": 0.00717, "epss_percentile": 0.71889}, "CVE-2020-6138": {"epss_score": 0.00717, "epss_percentile": 0.71889}, "CVE-2020-6139": {"epss_score": 0.00717, "epss_percentile": 0.71889}, "CVE-2020-6140": {"epss_score": 0.00717, "epss_percentile": 0.71889}, "CVE-2020-6141": {"epss_score": 0.10825, "epss_percentile": 0.93125}, "CVE-2020-6142": {"epss_score": 0.32266, "epss_percentile": 0.96684}, "CVE-2020-6143": {"epss_score": 0.10783, "epss_percentile": 0.93102}, "CVE-2020-6144": {"epss_score": 0.10783, "epss_percentile": 0.93102}, "CVE-2020-6145": {"epss_score": 0.01726, "epss_percentile": 0.81963}, "CVE-2020-6146": {"epss_score": 0.00503, "epss_percentile": 0.65461}, "CVE-2020-6147": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2020-6148": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2020-6149": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2020-6150": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2020-6151": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2020-6152": {"epss_score": 0.00492, "epss_percentile": 0.65016}, "CVE-2020-6155": {"epss_score": 0.01498, "epss_percentile": 0.80705}, "CVE-2020-6156": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2020-6157": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2020-6158": {"epss_score": 0.00077, "epss_percentile": 0.23305}, "CVE-2020-6159": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-6162": {"epss_score": 0.00562, "epss_percentile": 0.67699}, "CVE-2020-6163": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-6164": {"epss_score": 0.00703, "epss_percentile": 0.7155}, "CVE-2020-6165": {"epss_score": 0.00159, "epss_percentile": 0.37303}, "CVE-2020-6166": {"epss_score": 0.00412, "epss_percentile": 0.6092}, "CVE-2020-6167": {"epss_score": 0.0073, "epss_percentile": 0.72152}, "CVE-2020-6168": {"epss_score": 0.01239, "epss_percentile": 0.78797}, "CVE-2020-6170": {"epss_score": 0.09768, "epss_percentile": 0.92695}, "CVE-2020-6171": {"epss_score": 0.18832, "epss_percentile": 0.95079}, "CVE-2020-6173": {"epss_score": 0.00173, "epss_percentile": 0.3912}, "CVE-2020-6174": {"epss_score": 0.00195, "epss_percentile": 0.4171}, "CVE-2020-6175": {"epss_score": 0.00144, "epss_percentile": 0.35297}, "CVE-2020-6177": {"epss_score": 0.00293, "epss_percentile": 0.5229}, "CVE-2020-6178": {"epss_score": 0.00092, "epss_percentile": 0.26461}, "CVE-2020-6181": {"epss_score": 0.00305, "epss_percentile": 0.53391}, "CVE-2020-6183": {"epss_score": 0.00249, "epss_percentile": 0.48061}, "CVE-2020-6184": {"epss_score": 0.00544, "epss_percentile": 0.67126}, "CVE-2020-6185": {"epss_score": 0.00267, "epss_percentile": 0.49993}, "CVE-2020-6186": {"epss_score": 0.00513, "epss_percentile": 0.65904}, "CVE-2020-6187": {"epss_score": 0.00311, "epss_percentile": 0.53863}, "CVE-2020-6188": {"epss_score": 0.00199, "epss_percentile": 0.42134}, "CVE-2020-6189": {"epss_score": 0.0029, "epss_percentile": 0.52108}, "CVE-2020-6190": {"epss_score": 0.00261, "epss_percentile": 0.49297}, "CVE-2020-6191": {"epss_score": 0.0044, "epss_percentile": 0.62644}, "CVE-2020-6192": {"epss_score": 0.00231, "epss_percentile": 0.45774}, "CVE-2020-6193": {"epss_score": 0.00423, "epss_percentile": 0.61584}, "CVE-2020-6195": {"epss_score": 0.00194, "epss_percentile": 0.41555}, "CVE-2020-6196": {"epss_score": 0.00284, "epss_percentile": 0.51489}, "CVE-2020-6197": {"epss_score": 0.00167, "epss_percentile": 0.38377}, "CVE-2020-6198": {"epss_score": 0.00265, "epss_percentile": 0.49803}, "CVE-2020-6199": {"epss_score": 0.00116, "epss_percentile": 0.31124}, "CVE-2020-6200": {"epss_score": 0.00402, "epss_percentile": 0.6028}, "CVE-2020-6201": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2020-6202": {"epss_score": 0.00476, "epss_percentile": 0.6426}, "CVE-2020-6203": {"epss_score": 0.00978, "epss_percentile": 0.76238}, "CVE-2020-6204": {"epss_score": 0.00228, "epss_percentile": 0.45498}, "CVE-2020-6205": {"epss_score": 0.00509, "epss_percentile": 0.65725}, "CVE-2020-6206": {"epss_score": 0.00165, "epss_percentile": 0.3804}, "CVE-2020-6207": {"epss_score": 0.94274, "epss_percentile": 0.99931}, "CVE-2020-6208": {"epss_score": 0.02599, "epss_percentile": 0.85204}, "CVE-2020-6209": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2020-6210": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2020-6211": {"epss_score": 0.00216, "epss_percentile": 0.44202}, "CVE-2020-6212": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2020-6213": {"epss_score": 0.00191, "epss_percentile": 0.41168}, "CVE-2020-6214": {"epss_score": 0.00201, "epss_percentile": 0.42304}, "CVE-2020-6215": {"epss_score": 0.00402, "epss_percentile": 0.60262}, "CVE-2020-6216": {"epss_score": 0.00243, "epss_percentile": 0.47488}, "CVE-2020-6217": {"epss_score": 0.00366, "epss_percentile": 0.58076}, "CVE-2020-6218": {"epss_score": 0.00246, "epss_percentile": 0.47777}, "CVE-2020-6219": {"epss_score": 0.01258, "epss_percentile": 0.78957}, "CVE-2020-6220": {"epss_score": 0.00149, "epss_percentile": 0.36009}, "CVE-2020-6221": {"epss_score": 0.00248, "epss_percentile": 0.47995}, "CVE-2020-6222": {"epss_score": 0.0037, "epss_percentile": 0.58282}, "CVE-2020-6223": {"epss_score": 0.00216, "epss_percentile": 0.44202}, "CVE-2020-6224": {"epss_score": 0.00285, "epss_percentile": 0.51543}, "CVE-2020-6225": {"epss_score": 0.00537, "epss_percentile": 0.6692}, "CVE-2020-6226": {"epss_score": 0.0032, "epss_percentile": 0.5464}, "CVE-2020-6227": {"epss_score": 0.0028, "epss_percentile": 0.51068}, "CVE-2020-6228": {"epss_score": 0.00131, "epss_percentile": 0.33488}, "CVE-2020-6229": {"epss_score": 0.00243, "epss_percentile": 0.47488}, "CVE-2020-6230": {"epss_score": 0.00356, "epss_percentile": 0.57327}, "CVE-2020-6231": {"epss_score": 0.0032, "epss_percentile": 0.5464}, "CVE-2020-6232": {"epss_score": 0.00248, "epss_percentile": 0.47954}, "CVE-2020-6233": {"epss_score": 0.00225, "epss_percentile": 0.45161}, "CVE-2020-6234": {"epss_score": 0.00709, "epss_percentile": 0.71693}, "CVE-2020-6235": {"epss_score": 0.00382, "epss_percentile": 0.59046}, "CVE-2020-6236": {"epss_score": 0.00211, "epss_percentile": 0.43624}, "CVE-2020-6237": {"epss_score": 0.00348, "epss_percentile": 0.56805}, "CVE-2020-6238": {"epss_score": 0.00408, "epss_percentile": 0.60671}, "CVE-2020-6239": {"epss_score": 0.00034, "epss_percentile": 0.09572}, "CVE-2020-6240": {"epss_score": 0.01437, "epss_percentile": 0.80279}, "CVE-2020-6241": {"epss_score": 0.00508, "epss_percentile": 0.65707}, "CVE-2020-6242": {"epss_score": 0.00229, "epss_percentile": 0.45619}, "CVE-2020-6243": {"epss_score": 0.00686, "epss_percentile": 0.71158}, "CVE-2020-6244": {"epss_score": 0.00071, "epss_percentile": 0.22157}, "CVE-2020-6245": {"epss_score": 0.00054, "epss_percentile": 0.17313}, "CVE-2020-6246": {"epss_score": 0.00273, "epss_percentile": 0.50483}, "CVE-2020-6247": {"epss_score": 0.0029, "epss_percentile": 0.521}, "CVE-2020-6248": {"epss_score": 0.01439, "epss_percentile": 0.80291}, "CVE-2020-6249": {"epss_score": 0.004, "epss_percentile": 0.60181}, "CVE-2020-6250": {"epss_score": 0.00078, "epss_percentile": 0.23612}, "CVE-2020-6251": {"epss_score": 0.00223, "epss_percentile": 0.44851}, "CVE-2020-6252": {"epss_score": 0.00158, "epss_percentile": 0.37149}, "CVE-2020-6253": {"epss_score": 0.00574, "epss_percentile": 0.68093}, "CVE-2020-6254": {"epss_score": 0.00191, "epss_percentile": 0.41168}, "CVE-2020-6256": {"epss_score": 0.00133, "epss_percentile": 0.33695}, "CVE-2020-6257": {"epss_score": 0.00162, "epss_percentile": 0.37663}, "CVE-2020-6258": {"epss_score": 0.00171, "epss_percentile": 0.3889}, "CVE-2020-6259": {"epss_score": 0.00254, "epss_percentile": 0.48519}, "CVE-2020-6260": {"epss_score": 0.00189, "epss_percentile": 0.40996}, "CVE-2020-6261": {"epss_score": 0.00181, "epss_percentile": 0.40053}, "CVE-2020-6262": {"epss_score": 0.0079, "epss_percentile": 0.73369}, "CVE-2020-6263": {"epss_score": 0.00224, "epss_percentile": 0.45052}, "CVE-2020-6264": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-6265": {"epss_score": 0.00598, "epss_percentile": 0.68764}, "CVE-2020-6266": {"epss_score": 0.00171, "epss_percentile": 0.38887}, "CVE-2020-6267": {"epss_score": 0.00171, "epss_percentile": 0.38866}, "CVE-2020-6268": {"epss_score": 0.00166, "epss_percentile": 0.38239}, "CVE-2020-6269": {"epss_score": 0.00223, "epss_percentile": 0.44851}, "CVE-2020-6270": {"epss_score": 0.00174, "epss_percentile": 0.39204}, "CVE-2020-6271": {"epss_score": 0.00531, "epss_percentile": 0.66652}, "CVE-2020-6272": {"epss_score": 0.00162, "epss_percentile": 0.37724}, "CVE-2020-6273": {"epss_score": 0.00136, "epss_percentile": 0.34155}, "CVE-2020-6275": {"epss_score": 0.0046, "epss_percentile": 0.635}, "CVE-2020-6276": {"epss_score": 0.00166, "epss_percentile": 0.38185}, "CVE-2020-6278": {"epss_score": 0.00141, "epss_percentile": 0.34843}, "CVE-2020-6280": {"epss_score": 0.00232, "epss_percentile": 0.45906}, "CVE-2020-6281": {"epss_score": 0.00166, "epss_percentile": 0.38185}, "CVE-2020-6282": {"epss_score": 0.00137, "epss_percentile": 0.34263}, "CVE-2020-6283": {"epss_score": 0.00361, "epss_percentile": 0.57708}, "CVE-2020-6284": {"epss_score": 0.00892, "epss_percentile": 0.75059}, "CVE-2020-6285": {"epss_score": 0.00256, "epss_percentile": 0.48837}, "CVE-2020-6286": {"epss_score": 0.85681, "epss_percentile": 0.99343}, "CVE-2020-6287": {"epss_score": 0.94395, "epss_percentile": 0.99971}, "CVE-2020-6288": {"epss_score": 0.00218, "epss_percentile": 0.44416}, "CVE-2020-6289": {"epss_score": 0.00101, "epss_percentile": 0.2862}, "CVE-2020-6290": {"epss_score": 0.00147, "epss_percentile": 0.35782}, "CVE-2020-6291": {"epss_score": 0.00153, "epss_percentile": 0.36611}, "CVE-2020-6292": {"epss_score": 0.00198, "epss_percentile": 0.42095}, "CVE-2020-6293": {"epss_score": 0.0031, "epss_percentile": 0.53747}, "CVE-2020-6294": {"epss_score": 0.00308, "epss_percentile": 0.53633}, "CVE-2020-6295": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2020-6296": {"epss_score": 0.00585, "epss_percentile": 0.68407}, "CVE-2020-6297": {"epss_score": 0.00053, "epss_percentile": 0.16741}, "CVE-2020-6298": {"epss_score": 0.00209, "epss_percentile": 0.43311}, "CVE-2020-6299": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2020-6300": {"epss_score": 0.00237, "epss_percentile": 0.46667}, "CVE-2020-6301": {"epss_score": 0.00179, "epss_percentile": 0.3981}, "CVE-2020-6302": {"epss_score": 0.00397, "epss_percentile": 0.60033}, "CVE-2020-6303": {"epss_score": 0.00306, "epss_percentile": 0.53453}, "CVE-2020-6304": {"epss_score": 0.00697, "epss_percentile": 0.71403}, "CVE-2020-6305": {"epss_score": 0.0028, "epss_percentile": 0.51001}, "CVE-2020-6306": {"epss_score": 0.00234, "epss_percentile": 0.46091}, "CVE-2020-6307": {"epss_score": 0.00236, "epss_percentile": 0.4638}, "CVE-2020-6308": {"epss_score": 0.82056, "epss_percentile": 0.9917}, "CVE-2020-6309": {"epss_score": 0.0054, "epss_percentile": 0.67011}, "CVE-2020-6310": {"epss_score": 0.0026, "epss_percentile": 0.49163}, "CVE-2020-6311": {"epss_score": 0.00169, "epss_percentile": 0.38559}, "CVE-2020-6312": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-6313": {"epss_score": 0.00296, "epss_percentile": 0.52577}, "CVE-2020-6314": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6315": {"epss_score": 0.00159, "epss_percentile": 0.37301}, "CVE-2020-6316": {"epss_score": 0.00149, "epss_percentile": 0.3599}, "CVE-2020-6317": {"epss_score": 0.00072, "epss_percentile": 0.22251}, "CVE-2020-6318": {"epss_score": 0.06134, "epss_percentile": 0.90506}, "CVE-2020-6319": {"epss_score": 0.00322, "epss_percentile": 0.54819}, "CVE-2020-6320": {"epss_score": 0.00364, "epss_percentile": 0.57947}, "CVE-2020-6321": {"epss_score": 0.00473, "epss_percentile": 0.64086}, "CVE-2020-6322": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6323": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-6324": {"epss_score": 0.00903, "epss_percentile": 0.75209}, "CVE-2020-6326": {"epss_score": 0.00313, "epss_percentile": 0.5402}, "CVE-2020-6327": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6328": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6329": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6330": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6331": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6332": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6333": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6334": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6335": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6336": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6337": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6338": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6339": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6340": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6341": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6342": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6343": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6344": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6345": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6346": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6347": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6348": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6349": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6350": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6351": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6352": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6353": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6354": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6355": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6356": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6357": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6358": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6359": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6360": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6361": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2020-6362": {"epss_score": 0.00148, "epss_percentile": 0.35892}, "CVE-2020-6363": {"epss_score": 0.0021, "epss_percentile": 0.4359}, "CVE-2020-6364": {"epss_score": 0.20638, "epss_percentile": 0.95392}, "CVE-2020-6365": {"epss_score": 0.00212, "epss_percentile": 0.43805}, "CVE-2020-6366": {"epss_score": 0.00425, "epss_percentile": 0.61713}, "CVE-2020-6367": {"epss_score": 0.01254, "epss_percentile": 0.7892}, "CVE-2020-6368": {"epss_score": 0.00384, "epss_percentile": 0.59172}, "CVE-2020-6369": {"epss_score": 0.01243, "epss_percentile": 0.78826}, "CVE-2020-6370": {"epss_score": 0.00206, "epss_percentile": 0.42926}, "CVE-2020-6371": {"epss_score": 0.00197, "epss_percentile": 0.41875}, "CVE-2020-6372": {"epss_score": 0.00226, "epss_percentile": 0.45351}, "CVE-2020-6373": {"epss_score": 0.00226, "epss_percentile": 0.45351}, "CVE-2020-6374": {"epss_score": 0.00226, "epss_percentile": 0.45351}, "CVE-2020-6375": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2020-6376": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2020-6377": {"epss_score": 0.02899, "epss_percentile": 0.85949}, "CVE-2020-6378": {"epss_score": 0.00654, "epss_percentile": 0.70352}, "CVE-2020-6379": {"epss_score": 0.00654, "epss_percentile": 0.70352}, "CVE-2020-6380": {"epss_score": 0.00286, "epss_percentile": 0.51756}, "CVE-2020-6381": {"epss_score": 0.02916, "epss_percentile": 0.85981}, "CVE-2020-6382": {"epss_score": 0.02916, "epss_percentile": 0.85981}, "CVE-2020-6383": {"epss_score": 0.24916, "epss_percentile": 0.95964}, "CVE-2020-6384": {"epss_score": 0.02429, "epss_percentile": 0.84722}, "CVE-2020-6385": {"epss_score": 0.01421, "epss_percentile": 0.80172}, "CVE-2020-6386": {"epss_score": 0.02532, "epss_percentile": 0.85028}, "CVE-2020-6387": {"epss_score": 0.01445, "epss_percentile": 0.80323}, "CVE-2020-6388": {"epss_score": 0.05504, "epss_percentile": 0.89942}, "CVE-2020-6389": {"epss_score": 0.01445, "epss_percentile": 0.80323}, "CVE-2020-6390": {"epss_score": 0.07149, "epss_percentile": 0.91285}, "CVE-2020-6391": {"epss_score": 0.01288, "epss_percentile": 0.792}, "CVE-2020-6392": {"epss_score": 0.01288, "epss_percentile": 0.792}, "CVE-2020-6393": {"epss_score": 0.01456, "epss_percentile": 0.80393}, "CVE-2020-6394": {"epss_score": 0.01071, "epss_percentile": 0.77271}, "CVE-2020-6395": {"epss_score": 0.01479, "epss_percentile": 0.80561}, "CVE-2020-6396": {"epss_score": 0.01379, "epss_percentile": 0.79852}, "CVE-2020-6397": {"epss_score": 0.01379, "epss_percentile": 0.79852}, "CVE-2020-6398": {"epss_score": 0.02199, "epss_percentile": 0.83969}, "CVE-2020-6399": {"epss_score": 0.01094, "epss_percentile": 0.77488}, "CVE-2020-6400": {"epss_score": 0.01918, "epss_percentile": 0.82874}, "CVE-2020-6401": {"epss_score": 0.00784, "epss_percentile": 0.73232}, "CVE-2020-6402": {"epss_score": 0.03167, "epss_percentile": 0.86541}, "CVE-2020-6403": {"epss_score": 0.01379, "epss_percentile": 0.79852}, "CVE-2020-6404": {"epss_score": 0.01754, "epss_percentile": 0.8212}, "CVE-2020-6405": {"epss_score": 0.00738, "epss_percentile": 0.72344}, "CVE-2020-6406": {"epss_score": 0.02916, "epss_percentile": 0.85981}, "CVE-2020-6407": {"epss_score": 0.01341, "epss_percentile": 0.79588}, "CVE-2020-6408": {"epss_score": 0.01238, "epss_percentile": 0.78792}, "CVE-2020-6409": {"epss_score": 0.00638, "epss_percentile": 0.69908}, "CVE-2020-6410": {"epss_score": 0.01567, "epss_percentile": 0.81073}, "CVE-2020-6411": {"epss_score": 0.00783, "epss_percentile": 0.73227}, "CVE-2020-6412": {"epss_score": 0.00578, "epss_percentile": 0.68184}, "CVE-2020-6413": {"epss_score": 0.00862, "epss_percentile": 0.74581}, "CVE-2020-6414": {"epss_score": 0.00862, "epss_percentile": 0.74581}, "CVE-2020-6415": {"epss_score": 0.02916, "epss_percentile": 0.85981}, "CVE-2020-6416": {"epss_score": 0.03893, "epss_percentile": 0.87912}, "CVE-2020-6417": {"epss_score": 0.00075, "epss_percentile": 0.23038}, "CVE-2020-6418": {"epss_score": 0.86279, "epss_percentile": 0.99376}, "CVE-2020-6419": {"epss_score": 0.00331, "epss_percentile": 0.55523}, "CVE-2020-6420": {"epss_score": 0.00485, "epss_percentile": 0.64734}, "CVE-2020-6422": {"epss_score": 0.04693, "epss_percentile": 0.89013}, "CVE-2020-6423": {"epss_score": 0.01907, "epss_percentile": 0.82814}, "CVE-2020-6424": {"epss_score": 0.04149, "epss_percentile": 0.88319}, "CVE-2020-6425": {"epss_score": 0.00458, "epss_percentile": 0.63441}, "CVE-2020-6426": {"epss_score": 0.01451, "epss_percentile": 0.80356}, "CVE-2020-6427": {"epss_score": 0.04754, "epss_percentile": 0.89109}, "CVE-2020-6428": {"epss_score": 0.04754, "epss_percentile": 0.89109}, "CVE-2020-6429": {"epss_score": 0.04754, "epss_percentile": 0.89109}, "CVE-2020-6430": {"epss_score": 0.01907, "epss_percentile": 0.82814}, "CVE-2020-6431": {"epss_score": 0.00798, "epss_percentile": 0.73509}, "CVE-2020-6432": {"epss_score": 0.00736, "epss_percentile": 0.72314}, "CVE-2020-6433": {"epss_score": 0.00736, "epss_percentile": 0.72314}, "CVE-2020-6434": {"epss_score": 0.01494, "epss_percentile": 0.80646}, "CVE-2020-6435": {"epss_score": 0.00736, "epss_percentile": 0.72314}, "CVE-2020-6436": {"epss_score": 0.01494, "epss_percentile": 0.80646}, "CVE-2020-6437": {"epss_score": 0.00924, "epss_percentile": 0.75526}, "CVE-2020-6438": {"epss_score": 0.00695, "epss_percentile": 0.71378}, "CVE-2020-6439": {"epss_score": 0.00878, "epss_percentile": 0.74824}, "CVE-2020-6440": {"epss_score": 0.00695, "epss_percentile": 0.71378}, "CVE-2020-6441": {"epss_score": 0.00527, "epss_percentile": 0.66451}, "CVE-2020-6442": {"epss_score": 0.01095, "epss_percentile": 0.77511}, "CVE-2020-6443": {"epss_score": 0.01339, "epss_percentile": 0.79569}, "CVE-2020-6444": {"epss_score": 0.01394, "epss_percentile": 0.79971}, "CVE-2020-6445": {"epss_score": 0.00527, "epss_percentile": 0.66451}, "CVE-2020-6446": {"epss_score": 0.00527, "epss_percentile": 0.66451}, "CVE-2020-6447": {"epss_score": 0.01494, "epss_percentile": 0.80646}, "CVE-2020-6448": {"epss_score": 0.01494, "epss_percentile": 0.80646}, "CVE-2020-6449": {"epss_score": 0.0145, "epss_percentile": 0.80355}, "CVE-2020-6450": {"epss_score": 0.00781, "epss_percentile": 0.73192}, "CVE-2020-6451": {"epss_score": 0.00781, "epss_percentile": 0.73192}, "CVE-2020-6452": {"epss_score": 0.01048, "epss_percentile": 0.77054}, "CVE-2020-6453": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2020-6454": {"epss_score": 0.00787, "epss_percentile": 0.73322}, "CVE-2020-6455": {"epss_score": 0.01242, "epss_percentile": 0.78819}, "CVE-2020-6456": {"epss_score": 0.00612, "epss_percentile": 0.69231}, "CVE-2020-6457": {"epss_score": 0.01062, "epss_percentile": 0.7718}, "CVE-2020-6458": {"epss_score": 0.00805, "epss_percentile": 0.73628}, "CVE-2020-6459": {"epss_score": 0.00989, "epss_percentile": 0.76358}, "CVE-2020-6460": {"epss_score": 0.00705, "epss_percentile": 0.71601}, "CVE-2020-6461": {"epss_score": 0.0109, "epss_percentile": 0.77449}, "CVE-2020-6462": {"epss_score": 0.0109, "epss_percentile": 0.77449}, "CVE-2020-6463": {"epss_score": 0.03747, "epss_percentile": 0.87665}, "CVE-2020-6464": {"epss_score": 0.01364, "epss_percentile": 0.79774}, "CVE-2020-6465": {"epss_score": 0.01747, "epss_percentile": 0.82078}, "CVE-2020-6466": {"epss_score": 0.01467, "epss_percentile": 0.80474}, "CVE-2020-6467": {"epss_score": 0.02045, "epss_percentile": 0.83385}, "CVE-2020-6468": {"epss_score": 0.42466, "epss_percentile": 0.97333}, "CVE-2020-6469": {"epss_score": 0.00702, "epss_percentile": 0.71525}, "CVE-2020-6470": {"epss_score": 0.01159, "epss_percentile": 0.78129}, "CVE-2020-6471": {"epss_score": 0.00856, "epss_percentile": 0.74481}, "CVE-2020-6472": {"epss_score": 0.00889, "epss_percentile": 0.75014}, "CVE-2020-6473": {"epss_score": 0.01451, "epss_percentile": 0.80357}, "CVE-2020-6474": {"epss_score": 0.02073, "epss_percentile": 0.83494}, "CVE-2020-6475": {"epss_score": 0.01409, "epss_percentile": 0.80073}, "CVE-2020-6476": {"epss_score": 0.00582, "epss_percentile": 0.68284}, "CVE-2020-6477": {"epss_score": 0.00031, "epss_percentile": 0.08439}, "CVE-2020-6478": {"epss_score": 0.00913, "epss_percentile": 0.75381}, "CVE-2020-6479": {"epss_score": 0.00913, "epss_percentile": 0.75381}, "CVE-2020-6480": {"epss_score": 0.00495, "epss_percentile": 0.65116}, "CVE-2020-6481": {"epss_score": 0.01409, "epss_percentile": 0.80073}, "CVE-2020-6482": {"epss_score": 0.00582, "epss_percentile": 0.68284}, "CVE-2020-6483": {"epss_score": 0.00694, "epss_percentile": 0.71339}, "CVE-2020-6484": {"epss_score": 0.00608, "epss_percentile": 0.69068}, "CVE-2020-6485": {"epss_score": 0.00626, "epss_percentile": 0.69619}, "CVE-2020-6486": {"epss_score": 0.00968, "epss_percentile": 0.76089}, "CVE-2020-6487": {"epss_score": 0.00694, "epss_percentile": 0.71339}, "CVE-2020-6488": {"epss_score": 0.00608, "epss_percentile": 0.69068}, "CVE-2020-6489": {"epss_score": 0.01041, "epss_percentile": 0.76968}, "CVE-2020-6490": {"epss_score": 0.01041, "epss_percentile": 0.76968}, "CVE-2020-6491": {"epss_score": 0.00913, "epss_percentile": 0.75381}, "CVE-2020-6492": {"epss_score": 0.00398, "epss_percentile": 0.60091}, "CVE-2020-6493": {"epss_score": 0.01637, "epss_percentile": 0.81481}, "CVE-2020-6494": {"epss_score": 0.00498, "epss_percentile": 0.65213}, "CVE-2020-6495": {"epss_score": 0.00515, "epss_percentile": 0.6597}, "CVE-2020-6496": {"epss_score": 0.01318, "epss_percentile": 0.79424}, "CVE-2020-6497": {"epss_score": 0.00483, "epss_percentile": 0.64561}, "CVE-2020-6498": {"epss_score": 0.00483, "epss_percentile": 0.64561}, "CVE-2020-6499": {"epss_score": 0.00139, "epss_percentile": 0.34643}, "CVE-2020-6500": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2020-6501": {"epss_score": 0.00092, "epss_percentile": 0.26503}, "CVE-2020-6502": {"epss_score": 0.00173, "epss_percentile": 0.39095}, "CVE-2020-6503": {"epss_score": 0.00185, "epss_percentile": 0.40565}, "CVE-2020-6504": {"epss_score": 0.00068, "epss_percentile": 0.21243}, "CVE-2020-6505": {"epss_score": 0.00625, "epss_percentile": 0.69586}, "CVE-2020-6506": {"epss_score": 0.01414, "epss_percentile": 0.80125}, "CVE-2020-6507": {"epss_score": 0.26284, "epss_percentile": 0.96135}, "CVE-2020-6509": {"epss_score": 0.00258, "epss_percentile": 0.48962}, "CVE-2020-6510": {"epss_score": 0.00446, "epss_percentile": 0.62891}, "CVE-2020-6511": {"epss_score": 0.0241, "epss_percentile": 0.84661}, "CVE-2020-6512": {"epss_score": 0.04484, "epss_percentile": 0.88746}, "CVE-2020-6513": {"epss_score": 0.01703, "epss_percentile": 0.81843}, "CVE-2020-6514": {"epss_score": 0.14455, "epss_percentile": 0.94215}, "CVE-2020-6515": {"epss_score": 0.03205, "epss_percentile": 0.86633}, "CVE-2020-6516": {"epss_score": 0.03665, "epss_percentile": 0.87532}, "CVE-2020-6517": {"epss_score": 0.01729, "epss_percentile": 0.81983}, "CVE-2020-6518": {"epss_score": 0.03205, "epss_percentile": 0.86633}, "CVE-2020-6519": {"epss_score": 0.23706, "epss_percentile": 0.95806}, "CVE-2020-6520": {"epss_score": 0.01729, "epss_percentile": 0.81983}, "CVE-2020-6521": {"epss_score": 0.0241, "epss_percentile": 0.84661}, "CVE-2020-6522": {"epss_score": 0.02277, "epss_percentile": 0.84233}, "CVE-2020-6523": {"epss_score": 0.03205, "epss_percentile": 0.86633}, "CVE-2020-6524": {"epss_score": 0.02094, "epss_percentile": 0.83578}, "CVE-2020-6525": {"epss_score": 0.01651, "epss_percentile": 0.81568}, "CVE-2020-6526": {"epss_score": 0.01673, "epss_percentile": 0.81686}, "CVE-2020-6527": {"epss_score": 0.00887, "epss_percentile": 0.74974}, "CVE-2020-6528": {"epss_score": 0.01736, "epss_percentile": 0.82013}, "CVE-2020-6529": {"epss_score": 0.00623, "epss_percentile": 0.69552}, "CVE-2020-6530": {"epss_score": 0.01352, "epss_percentile": 0.79689}, "CVE-2020-6531": {"epss_score": 0.01496, "epss_percentile": 0.80684}, "CVE-2020-6532": {"epss_score": 0.0109, "epss_percentile": 0.77449}, "CVE-2020-6533": {"epss_score": 0.02277, "epss_percentile": 0.84233}, "CVE-2020-6534": {"epss_score": 0.01629, "epss_percentile": 0.81439}, "CVE-2020-6535": {"epss_score": 0.01139, "epss_percentile": 0.77936}, "CVE-2020-6536": {"epss_score": 0.01736, "epss_percentile": 0.82013}, "CVE-2020-6537": {"epss_score": 0.02892, "epss_percentile": 0.85921}, "CVE-2020-6538": {"epss_score": 0.00961, "epss_percentile": 0.75973}, "CVE-2020-6539": {"epss_score": 0.01062, "epss_percentile": 0.7718}, "CVE-2020-6540": {"epss_score": 0.01416, "epss_percentile": 0.80143}, "CVE-2020-6541": {"epss_score": 0.04976, "epss_percentile": 0.89355}, "CVE-2020-6542": {"epss_score": 0.01653, "epss_percentile": 0.81581}, "CVE-2020-6543": {"epss_score": 0.01036, "epss_percentile": 0.76914}, "CVE-2020-6544": {"epss_score": 0.01036, "epss_percentile": 0.76914}, "CVE-2020-6545": {"epss_score": 0.01036, "epss_percentile": 0.76914}, "CVE-2020-6546": {"epss_score": 0.00022, "epss_percentile": 0.05231}, "CVE-2020-6547": {"epss_score": 0.01027, "epss_percentile": 0.76811}, "CVE-2020-6548": {"epss_score": 0.02725, "epss_percentile": 0.85525}, "CVE-2020-6549": {"epss_score": 0.17688, "epss_percentile": 0.94889}, "CVE-2020-6550": {"epss_score": 0.17688, "epss_percentile": 0.94889}, "CVE-2020-6551": {"epss_score": 0.22641, "epss_percentile": 0.95663}, "CVE-2020-6552": {"epss_score": 0.01578, "epss_percentile": 0.81122}, "CVE-2020-6553": {"epss_score": 0.01578, "epss_percentile": 0.81122}, "CVE-2020-6554": {"epss_score": 0.00316, "epss_percentile": 0.54232}, "CVE-2020-6555": {"epss_score": 0.01218, "epss_percentile": 0.78608}, "CVE-2020-6556": {"epss_score": 0.0188, "epss_percentile": 0.82686}, "CVE-2020-6557": {"epss_score": 0.00817, "epss_percentile": 0.73846}, "CVE-2020-6558": {"epss_score": 0.00523, "epss_percentile": 0.6629}, "CVE-2020-6559": {"epss_score": 0.05648, "epss_percentile": 0.90082}, "CVE-2020-6560": {"epss_score": 0.00818, "epss_percentile": 0.73859}, "CVE-2020-6561": {"epss_score": 0.00987, "epss_percentile": 0.76345}, "CVE-2020-6562": {"epss_score": 0.00707, "epss_percentile": 0.7166}, "CVE-2020-6563": {"epss_score": 0.00818, "epss_percentile": 0.73859}, "CVE-2020-6564": {"epss_score": 0.00662, "epss_percentile": 0.70594}, "CVE-2020-6565": {"epss_score": 0.00864, "epss_percentile": 0.74597}, "CVE-2020-6566": {"epss_score": 0.00889, "epss_percentile": 0.75024}, "CVE-2020-6567": {"epss_score": 0.0053, "epss_percentile": 0.66616}, "CVE-2020-6568": {"epss_score": 0.0053, "epss_percentile": 0.66616}, "CVE-2020-6569": {"epss_score": 0.01169, "epss_percentile": 0.78196}, "CVE-2020-6570": {"epss_score": 0.00912, "epss_percentile": 0.75365}, "CVE-2020-6571": {"epss_score": 0.00959, "epss_percentile": 0.7595}, "CVE-2020-6572": {"epss_score": 0.14975, "epss_percentile": 0.94336}, "CVE-2020-6573": {"epss_score": 0.02277, "epss_percentile": 0.84233}, "CVE-2020-6574": {"epss_score": 0.00128, "epss_percentile": 0.33024}, "CVE-2020-6575": {"epss_score": 0.02552, "epss_percentile": 0.85081}, "CVE-2020-6576": {"epss_score": 0.02277, "epss_percentile": 0.84233}, "CVE-2020-6577": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-6578": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-6579": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2020-6581": {"epss_score": 0.00229, "epss_percentile": 0.45635}, "CVE-2020-6582": {"epss_score": 0.01645, "epss_percentile": 0.81531}, "CVE-2020-6583": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-6584": {"epss_score": 0.00483, "epss_percentile": 0.64564}, "CVE-2020-6585": {"epss_score": 0.00867, "epss_percentile": 0.74658}, "CVE-2020-6586": {"epss_score": 0.07329, "epss_percentile": 0.91412}, "CVE-2020-6590": {"epss_score": 0.00249, "epss_percentile": 0.48022}, "CVE-2020-6609": {"epss_score": 0.00557, "epss_percentile": 0.67556}, "CVE-2020-6610": {"epss_score": 0.00528, "epss_percentile": 0.66557}, "CVE-2020-6611": {"epss_score": 0.00579, "epss_percentile": 0.68224}, "CVE-2020-6612": {"epss_score": 0.00605, "epss_percentile": 0.68981}, "CVE-2020-6613": {"epss_score": 0.00605, "epss_percentile": 0.68981}, "CVE-2020-6614": {"epss_score": 0.00605, "epss_percentile": 0.68981}, "CVE-2020-6615": {"epss_score": 0.00672, "epss_percentile": 0.70819}, "CVE-2020-6616": {"epss_score": 0.00122, "epss_percentile": 0.32032}, "CVE-2020-6617": {"epss_score": 0.00452, "epss_percentile": 0.63183}, "CVE-2020-6618": {"epss_score": 0.00452, "epss_percentile": 0.63183}, "CVE-2020-6619": {"epss_score": 0.00452, "epss_percentile": 0.63183}, "CVE-2020-6620": {"epss_score": 0.00452, "epss_percentile": 0.63183}, "CVE-2020-6621": {"epss_score": 0.00457, "epss_percentile": 0.63379}, "CVE-2020-6622": {"epss_score": 0.00296, "epss_percentile": 0.52585}, "CVE-2020-6623": {"epss_score": 0.0032, "epss_percentile": 0.54634}, "CVE-2020-6624": {"epss_score": 0.0101, "epss_percentile": 0.76592}, "CVE-2020-6625": {"epss_score": 0.00851, "epss_percentile": 0.74406}, "CVE-2020-6627": {"epss_score": 0.14059, "epss_percentile": 0.94126}, "CVE-2020-6628": {"epss_score": 0.00318, "epss_percentile": 0.54458}, "CVE-2020-6629": {"epss_score": 0.00153, "epss_percentile": 0.36593}, "CVE-2020-6630": {"epss_score": 0.00266, "epss_percentile": 0.49917}, "CVE-2020-6631": {"epss_score": 0.00288, "epss_percentile": 0.5192}, "CVE-2020-6632": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-6637": {"epss_score": 0.78071, "epss_percentile": 0.98968}, "CVE-2020-6638": {"epss_score": 0.00415, "epss_percentile": 0.61145}, "CVE-2020-6640": {"epss_score": 0.00203, "epss_percentile": 0.42571}, "CVE-2020-6641": {"epss_score": 0.00134, "epss_percentile": 0.33835}, "CVE-2020-6643": {"epss_score": 0.00203, "epss_percentile": 0.42571}, "CVE-2020-6644": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2020-6646": {"epss_score": 0.00227, "epss_percentile": 0.45377}, "CVE-2020-6647": {"epss_score": 0.00355, "epss_percentile": 0.57296}, "CVE-2020-6648": {"epss_score": 0.00221, "epss_percentile": 0.44635}, "CVE-2020-6649": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2020-6650": {"epss_score": 0.04848, "epss_percentile": 0.89211}, "CVE-2020-6651": {"epss_score": 0.0107, "epss_percentile": 0.77257}, "CVE-2020-6652": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2020-6653": {"epss_score": 0.00065, "epss_percentile": 0.20653}, "CVE-2020-6654": {"epss_score": 0.00068, "epss_percentile": 0.21237}, "CVE-2020-6655": {"epss_score": 0.00605, "epss_percentile": 0.68988}, "CVE-2020-6656": {"epss_score": 0.00589, "epss_percentile": 0.68522}, "CVE-2020-6750": {"epss_score": 0.00587, "epss_percentile": 0.68476}, "CVE-2020-6752": {"epss_score": 0.00153, "epss_percentile": 0.36539}, "CVE-2020-6753": {"epss_score": 0.00265, "epss_percentile": 0.49813}, "CVE-2020-6754": {"epss_score": 0.75495, "epss_percentile": 0.98849}, "CVE-2020-6756": {"epss_score": 0.11831, "epss_percentile": 0.93489}, "CVE-2020-6757": {"epss_score": 0.00918, "epss_percentile": 0.75451}, "CVE-2020-6758": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2020-6760": {"epss_score": 0.00447, "epss_percentile": 0.62963}, "CVE-2020-6765": {"epss_score": 0.00788, "epss_percentile": 0.73341}, "CVE-2020-6767": {"epss_score": 0.00371, "epss_percentile": 0.5838}, "CVE-2020-6768": {"epss_score": 0.01605, "epss_percentile": 0.81288}, "CVE-2020-6769": {"epss_score": 0.01082, "epss_percentile": 0.77382}, "CVE-2020-6770": {"epss_score": 0.11298, "epss_percentile": 0.93296}, "CVE-2020-6771": {"epss_score": 0.00061, "epss_percentile": 0.1948}, "CVE-2020-6774": {"epss_score": 0.00043, "epss_percentile": 0.13272}, "CVE-2020-6776": {"epss_score": 0.00224, "epss_percentile": 0.45074}, "CVE-2020-6777": {"epss_score": 0.00139, "epss_percentile": 0.34632}, "CVE-2020-6779": {"epss_score": 0.09936, "epss_percentile": 0.92781}, "CVE-2020-6780": {"epss_score": 0.001, "epss_percentile": 0.28489}, "CVE-2020-6781": {"epss_score": 0.00116, "epss_percentile": 0.31083}, "CVE-2020-6785": {"epss_score": 0.00061, "epss_percentile": 0.1948}, "CVE-2020-6786": {"epss_score": 0.00061, "epss_percentile": 0.1948}, "CVE-2020-6787": {"epss_score": 0.00061, "epss_percentile": 0.1948}, "CVE-2020-6788": {"epss_score": 0.00061, "epss_percentile": 0.1948}, "CVE-2020-6789": {"epss_score": 0.00128, "epss_percentile": 0.32959}, "CVE-2020-6790": {"epss_score": 0.00061, "epss_percentile": 0.1948}, "CVE-2020-6792": {"epss_score": 0.00953, "epss_percentile": 0.75892}, "CVE-2020-6793": {"epss_score": 0.00803, "epss_percentile": 0.73599}, "CVE-2020-6794": {"epss_score": 0.00399, "epss_percentile": 0.60131}, "CVE-2020-6795": {"epss_score": 0.00688, "epss_percentile": 0.71193}, "CVE-2020-6796": {"epss_score": 0.00866, "epss_percentile": 0.74632}, "CVE-2020-6797": {"epss_score": 0.0102, "epss_percentile": 0.76731}, "CVE-2020-6798": {"epss_score": 0.01646, "epss_percentile": 0.81532}, "CVE-2020-6799": {"epss_score": 0.00474, "epss_percentile": 0.64147}, "CVE-2020-6800": {"epss_score": 0.0125, "epss_percentile": 0.7889}, "CVE-2020-6801": {"epss_score": 0.00576, "epss_percentile": 0.68143}, "CVE-2020-6802": {"epss_score": 0.00285, "epss_percentile": 0.51673}, "CVE-2020-6803": {"epss_score": 0.00275, "epss_percentile": 0.50638}, "CVE-2020-6804": {"epss_score": 0.00317, "epss_percentile": 0.54349}, "CVE-2020-6805": {"epss_score": 0.01521, "epss_percentile": 0.8083}, "CVE-2020-6806": {"epss_score": 0.04548, "epss_percentile": 0.88837}, "CVE-2020-6807": {"epss_score": 0.0139, "epss_percentile": 0.79939}, "CVE-2020-6808": {"epss_score": 0.00272, "epss_percentile": 0.5042}, "CVE-2020-6809": {"epss_score": 0.00458, "epss_percentile": 0.63436}, "CVE-2020-6810": {"epss_score": 0.00262, "epss_percentile": 0.49401}, "CVE-2020-6811": {"epss_score": 0.01364, "epss_percentile": 0.79774}, "CVE-2020-6812": {"epss_score": 0.00577, "epss_percentile": 0.68174}, "CVE-2020-6813": {"epss_score": 0.00134, "epss_percentile": 0.338}, "CVE-2020-6814": {"epss_score": 0.00837, "epss_percentile": 0.74165}, "CVE-2020-6815": {"epss_score": 0.00453, "epss_percentile": 0.63229}, "CVE-2020-6816": {"epss_score": 0.00419, "epss_percentile": 0.61377}, "CVE-2020-6817": {"epss_score": 0.00178, "epss_percentile": 0.3969}, "CVE-2020-6819": {"epss_score": 0.00329, "epss_percentile": 0.55321}, "CVE-2020-6820": {"epss_score": 0.04997, "epss_percentile": 0.89374}, "CVE-2020-6821": {"epss_score": 0.00541, "epss_percentile": 0.6703}, "CVE-2020-6822": {"epss_score": 0.00817, "epss_percentile": 0.73843}, "CVE-2020-6823": {"epss_score": 0.00919, "epss_percentile": 0.7546}, "CVE-2020-6824": {"epss_score": 0.00132, "epss_percentile": 0.33539}, "CVE-2020-6825": {"epss_score": 0.00701, "epss_percentile": 0.71486}, "CVE-2020-6826": {"epss_score": 0.00484, "epss_percentile": 0.64667}, "CVE-2020-6827": {"epss_score": 0.00321, "epss_percentile": 0.54695}, "CVE-2020-6828": {"epss_score": 0.00355, "epss_percentile": 0.57293}, "CVE-2020-6829": {"epss_score": 0.00236, "epss_percentile": 0.46445}, "CVE-2020-6830": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-6831": {"epss_score": 0.06267, "epss_percentile": 0.90625}, "CVE-2020-6832": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2020-6833": {"epss_score": 0.00077, "epss_percentile": 0.23384}, "CVE-2020-6835": {"epss_score": 0.00421, "epss_percentile": 0.61488}, "CVE-2020-6836": {"epss_score": 0.00957, "epss_percentile": 0.75927}, "CVE-2020-6838": {"epss_score": 0.00418, "epss_percentile": 0.61288}, "CVE-2020-6839": {"epss_score": 0.00512, "epss_percentile": 0.6586}, "CVE-2020-6840": {"epss_score": 0.00418, "epss_percentile": 0.61288}, "CVE-2020-6841": {"epss_score": 0.10174, "epss_percentile": 0.9288}, "CVE-2020-6842": {"epss_score": 0.01552, "epss_percentile": 0.80992}, "CVE-2020-6843": {"epss_score": 0.0188, "epss_percentile": 0.82674}, "CVE-2020-6844": {"epss_score": 0.00224, "epss_percentile": 0.44975}, "CVE-2020-6845": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2020-6847": {"epss_score": 0.00399, "epss_percentile": 0.6013}, "CVE-2020-6848": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-6849": {"epss_score": 0.01327, "epss_percentile": 0.79488}, "CVE-2020-6850": {"epss_score": 0.00363, "epss_percentile": 0.57845}, "CVE-2020-6851": {"epss_score": 0.0122, "epss_percentile": 0.78626}, "CVE-2020-6852": {"epss_score": 0.00738, "epss_percentile": 0.72336}, "CVE-2020-6854": {"epss_score": 0.00374, "epss_percentile": 0.58536}, "CVE-2020-6855": {"epss_score": 0.00492, "epss_percentile": 0.64988}, "CVE-2020-6856": {"epss_score": 0.00448, "epss_percentile": 0.63013}, "CVE-2020-6857": {"epss_score": 0.00126, "epss_percentile": 0.32775}, "CVE-2020-6858": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2020-6859": {"epss_score": 0.01142, "epss_percentile": 0.77976}, "CVE-2020-6860": {"epss_score": 0.0054, "epss_percentile": 0.67004}, "CVE-2020-6861": {"epss_score": 0.00591, "epss_percentile": 0.68601}, "CVE-2020-6862": {"epss_score": 0.13274, "epss_percentile": 0.93919}, "CVE-2020-6863": {"epss_score": 0.00104, "epss_percentile": 0.29225}, "CVE-2020-6864": {"epss_score": 0.00093, "epss_percentile": 0.26653}, "CVE-2020-6865": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2020-6866": {"epss_score": 0.00382, "epss_percentile": 0.59049}, "CVE-2020-6867": {"epss_score": 0.00049, "epss_percentile": 0.15544}, "CVE-2020-6868": {"epss_score": 0.0006, "epss_percentile": 0.19207}, "CVE-2020-6869": {"epss_score": 0.00317, "epss_percentile": 0.54384}, "CVE-2020-6870": {"epss_score": 0.00143, "epss_percentile": 0.35213}, "CVE-2020-6871": {"epss_score": 0.00403, "epss_percentile": 0.60348}, "CVE-2020-6872": {"epss_score": 0.00421, "epss_percentile": 0.61474}, "CVE-2020-6873": {"epss_score": 0.00445, "epss_percentile": 0.62888}, "CVE-2020-6874": {"epss_score": 0.00054, "epss_percentile": 0.17101}, "CVE-2020-6875": {"epss_score": 0.00257, "epss_percentile": 0.48845}, "CVE-2020-6876": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2020-6877": {"epss_score": 0.00312, "epss_percentile": 0.5395}, "CVE-2020-6879": {"epss_score": 0.00042, "epss_percentile": 0.12741}, "CVE-2020-6880": {"epss_score": 0.00617, "epss_percentile": 0.6935}, "CVE-2020-6881": {"epss_score": 0.00227, "epss_percentile": 0.45425}, "CVE-2020-6882": {"epss_score": 0.00319, "epss_percentile": 0.5457}, "CVE-2020-6917": {"epss_score": 0.00705, "epss_percentile": 0.71579}, "CVE-2020-6918": {"epss_score": 0.0052, "epss_percentile": 0.66188}, "CVE-2020-6919": {"epss_score": 0.0052, "epss_percentile": 0.66188}, "CVE-2020-6920": {"epss_score": 0.00558, "epss_percentile": 0.67594}, "CVE-2020-6921": {"epss_score": 0.0064, "epss_percentile": 0.69975}, "CVE-2020-6922": {"epss_score": 0.0064, "epss_percentile": 0.69975}, "CVE-2020-6923": {"epss_score": 0.00068, "epss_percentile": 0.21424}, "CVE-2020-6931": {"epss_score": 0.00064, "epss_percentile": 0.2016}, "CVE-2020-6932": {"epss_score": 0.03626, "epss_percentile": 0.8746}, "CVE-2020-6933": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-6937": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2020-6938": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-6939": {"epss_score": 0.01355, "epss_percentile": 0.79711}, "CVE-2020-6948": {"epss_score": 0.03282, "epss_percentile": 0.8682}, "CVE-2020-6949": {"epss_score": 0.00299, "epss_percentile": 0.52901}, "CVE-2020-6950": {"epss_score": 0.57917, "epss_percentile": 0.98091}, "CVE-2020-6954": {"epss_score": 0.00356, "epss_percentile": 0.57397}, "CVE-2020-6955": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-6956": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-6958": {"epss_score": 0.00509, "epss_percentile": 0.65733}, "CVE-2020-6959": {"epss_score": 0.00931, "epss_percentile": 0.75615}, "CVE-2020-6960": {"epss_score": 0.00226, "epss_percentile": 0.4524}, "CVE-2020-6961": {"epss_score": 0.00186, "epss_percentile": 0.40584}, "CVE-2020-6962": {"epss_score": 0.00192, "epss_percentile": 0.41286}, "CVE-2020-6963": {"epss_score": 0.00207, "epss_percentile": 0.43082}, "CVE-2020-6964": {"epss_score": 0.00272, "epss_percentile": 0.50399}, "CVE-2020-6965": {"epss_score": 0.003, "epss_percentile": 0.52911}, "CVE-2020-6966": {"epss_score": 0.00163, "epss_percentile": 0.37826}, "CVE-2020-6967": {"epss_score": 0.01584, "epss_percentile": 0.81157}, "CVE-2020-6968": {"epss_score": 0.00076, "epss_percentile": 0.23255}, "CVE-2020-6969": {"epss_score": 0.00454, "epss_percentile": 0.63245}, "CVE-2020-6970": {"epss_score": 0.0115, "epss_percentile": 0.78025}, "CVE-2020-6971": {"epss_score": 0.00076, "epss_percentile": 0.23255}, "CVE-2020-6972": {"epss_score": 0.00144, "epss_percentile": 0.35237}, "CVE-2020-6973": {"epss_score": 0.00397, "epss_percentile": 0.6002}, "CVE-2020-6974": {"epss_score": 0.00138, "epss_percentile": 0.34363}, "CVE-2020-6975": {"epss_score": 0.00333, "epss_percentile": 0.55624}, "CVE-2020-6976": {"epss_score": 0.00265, "epss_percentile": 0.49809}, "CVE-2020-6977": {"epss_score": 0.00255, "epss_percentile": 0.48723}, "CVE-2020-6978": {"epss_score": 0.00149, "epss_percentile": 0.35964}, "CVE-2020-6979": {"epss_score": 0.00281, "epss_percentile": 0.51179}, "CVE-2020-6980": {"epss_score": 6e-05, "epss_percentile": 0.00306}, "CVE-2020-6981": {"epss_score": 0.00289, "epss_percentile": 0.52053}, "CVE-2020-6982": {"epss_score": 0.00197, "epss_percentile": 0.41958}, "CVE-2020-6983": {"epss_score": 0.00281, "epss_percentile": 0.51179}, "CVE-2020-6984": {"epss_score": 0.00204, "epss_percentile": 0.4264}, "CVE-2020-6985": {"epss_score": 0.00301, "epss_percentile": 0.53069}, "CVE-2020-6986": {"epss_score": 0.00665, "epss_percentile": 0.70669}, "CVE-2020-6987": {"epss_score": 0.00148, "epss_percentile": 0.35906}, "CVE-2020-6988": {"epss_score": 0.00132, "epss_percentile": 0.33597}, "CVE-2020-6989": {"epss_score": 0.01416, "epss_percentile": 0.80143}, "CVE-2020-6990": {"epss_score": 0.00109, "epss_percentile": 0.30003}, "CVE-2020-6991": {"epss_score": 0.00289, "epss_percentile": 0.51996}, "CVE-2020-6992": {"epss_score": 0.0008, "epss_percentile": 0.24182}, "CVE-2020-6993": {"epss_score": 0.00317, "epss_percentile": 0.54394}, "CVE-2020-6994": {"epss_score": 0.00059, "epss_percentile": 0.18663}, "CVE-2020-6995": {"epss_score": 0.00368, "epss_percentile": 0.58189}, "CVE-2020-6996": {"epss_score": 0.00354, "epss_percentile": 0.57246}, "CVE-2020-6997": {"epss_score": 0.00148, "epss_percentile": 0.35906}, "CVE-2020-6998": {"epss_score": 0.0049, "epss_percentile": 0.64922}, "CVE-2020-6999": {"epss_score": 0.0029, "epss_percentile": 0.5211}, "CVE-2020-7000": {"epss_score": 0.00085, "epss_percentile": 0.25098}, "CVE-2020-7001": {"epss_score": 0.00148, "epss_percentile": 0.35906}, "CVE-2020-7002": {"epss_score": 0.0031, "epss_percentile": 0.53805}, "CVE-2020-7003": {"epss_score": 0.00148, "epss_percentile": 0.35906}, "CVE-2020-7004": {"epss_score": 0.0005, "epss_percentile": 0.15866}, "CVE-2020-7005": {"epss_score": 0.00141, "epss_percentile": 0.34842}, "CVE-2020-7006": {"epss_score": 0.00527, "epss_percentile": 0.66452}, "CVE-2020-7007": {"epss_score": 0.00413, "epss_percentile": 0.60994}, "CVE-2020-7008": {"epss_score": 0.00283, "epss_percentile": 0.51394}, "CVE-2020-7009": {"epss_score": 0.02073, "epss_percentile": 0.83493}, "CVE-2020-7010": {"epss_score": 0.00352, "epss_percentile": 0.57133}, "CVE-2020-7011": {"epss_score": 0.00316, "epss_percentile": 0.54291}, "CVE-2020-7012": {"epss_score": 0.73437, "epss_percentile": 0.98755}, "CVE-2020-7013": {"epss_score": 0.01139, "epss_percentile": 0.77942}, "CVE-2020-7014": {"epss_score": 0.00572, "epss_percentile": 0.68006}, "CVE-2020-7015": {"epss_score": 0.00401, "epss_percentile": 0.60253}, "CVE-2020-7016": {"epss_score": 0.00377, "epss_percentile": 0.58702}, "CVE-2020-7017": {"epss_score": 0.00919, "epss_percentile": 0.75463}, "CVE-2020-7018": {"epss_score": 0.00166, "epss_percentile": 0.38228}, "CVE-2020-7019": {"epss_score": 0.00136, "epss_percentile": 0.34084}, "CVE-2020-7020": {"epss_score": 0.00124, "epss_percentile": 0.32383}, "CVE-2020-7021": {"epss_score": 0.00411, "epss_percentile": 0.60851}, "CVE-2020-7029": {"epss_score": 0.00231, "epss_percentile": 0.4582}, "CVE-2020-7030": {"epss_score": 0.00221, "epss_percentile": 0.44702}, "CVE-2020-7032": {"epss_score": 0.00659, "epss_percentile": 0.70505}, "CVE-2020-7033": {"epss_score": 0.00473, "epss_percentile": 0.64076}, "CVE-2020-7034": {"epss_score": 0.0305, "epss_percentile": 0.86289}, "CVE-2020-7035": {"epss_score": 0.00324, "epss_percentile": 0.54952}, "CVE-2020-7036": {"epss_score": 0.00248, "epss_percentile": 0.4794}, "CVE-2020-7037": {"epss_score": 0.00564, "epss_percentile": 0.67774}, "CVE-2020-7038": {"epss_score": 0.01808, "epss_percentile": 0.82356}, "CVE-2020-7039": {"epss_score": 0.00831, "epss_percentile": 0.74055}, "CVE-2020-7040": {"epss_score": 0.05192, "epss_percentile": 0.89596}, "CVE-2020-7041": {"epss_score": 0.00843, "epss_percentile": 0.74247}, "CVE-2020-7042": {"epss_score": 0.00616, "epss_percentile": 0.69327}, "CVE-2020-7043": {"epss_score": 0.00468, "epss_percentile": 0.63866}, "CVE-2020-7044": {"epss_score": 0.00725, "epss_percentile": 0.72048}, "CVE-2020-7045": {"epss_score": 0.00137, "epss_percentile": 0.34274}, "CVE-2020-7046": {"epss_score": 0.00428, "epss_percentile": 0.61959}, "CVE-2020-7047": {"epss_score": 0.01691, "epss_percentile": 0.81776}, "CVE-2020-7048": {"epss_score": 0.41378, "epss_percentile": 0.9727}, "CVE-2020-7049": {"epss_score": 0.0014, "epss_percentile": 0.34753}, "CVE-2020-7050": {"epss_score": 0.00182, "epss_percentile": 0.4027}, "CVE-2020-7051": {"epss_score": 0.00282, "epss_percentile": 0.51286}, "CVE-2020-7052": {"epss_score": 0.00755, "epss_percentile": 0.72722}, "CVE-2020-7053": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2020-7054": {"epss_score": 0.00661, "epss_percentile": 0.70574}, "CVE-2020-7055": {"epss_score": 0.02065, "epss_percentile": 0.83454}, "CVE-2020-7057": {"epss_score": 0.00329, "epss_percentile": 0.55401}, "CVE-2020-7058": {"epss_score": 0.00916, "epss_percentile": 0.75419}, "CVE-2020-7059": {"epss_score": 0.02124, "epss_percentile": 0.83689}, "CVE-2020-7060": {"epss_score": 0.06404, "epss_percentile": 0.9073}, "CVE-2020-7061": {"epss_score": 0.02056, "epss_percentile": 0.83423}, "CVE-2020-7062": {"epss_score": 0.012, "epss_percentile": 0.78469}, "CVE-2020-7063": {"epss_score": 0.00314, "epss_percentile": 0.54152}, "CVE-2020-7064": {"epss_score": 0.0233, "epss_percentile": 0.84401}, "CVE-2020-7065": {"epss_score": 0.05019, "epss_percentile": 0.894}, "CVE-2020-7066": {"epss_score": 0.01533, "epss_percentile": 0.80897}, "CVE-2020-7067": {"epss_score": 0.09983, "epss_percentile": 0.92803}, "CVE-2020-7068": {"epss_score": 0.01021, "epss_percentile": 0.76751}, "CVE-2020-7069": {"epss_score": 0.09212, "epss_percentile": 0.9245}, "CVE-2020-7070": {"epss_score": 0.26088, "epss_percentile": 0.96109}, "CVE-2020-7071": {"epss_score": 0.07549, "epss_percentile": 0.91531}, "CVE-2020-7079": {"epss_score": 0.0013, "epss_percentile": 0.3334}, "CVE-2020-7080": {"epss_score": 0.00495, "epss_percentile": 0.65118}, "CVE-2020-7081": {"epss_score": 0.00525, "epss_percentile": 0.66394}, "CVE-2020-7082": {"epss_score": 0.00506, "epss_percentile": 0.65641}, "CVE-2020-7083": {"epss_score": 0.00513, "epss_percentile": 0.65928}, "CVE-2020-7084": {"epss_score": 0.00285, "epss_percentile": 0.51531}, "CVE-2020-7085": {"epss_score": 0.00495, "epss_percentile": 0.65118}, "CVE-2020-7104": {"epss_score": 0.02606, "epss_percentile": 0.85222}, "CVE-2020-7105": {"epss_score": 0.00569, "epss_percentile": 0.67915}, "CVE-2020-7106": {"epss_score": 0.04094, "epss_percentile": 0.88245}, "CVE-2020-7107": {"epss_score": 0.05245, "epss_percentile": 0.89657}, "CVE-2020-7108": {"epss_score": 0.01454, "epss_percentile": 0.80382}, "CVE-2020-7109": {"epss_score": 0.00873, "epss_percentile": 0.7474}, "CVE-2020-7110": {"epss_score": 0.00328, "epss_percentile": 0.55173}, "CVE-2020-7111": {"epss_score": 0.02793, "epss_percentile": 0.85673}, "CVE-2020-7113": {"epss_score": 0.00367, "epss_percentile": 0.5811}, "CVE-2020-7114": {"epss_score": 0.0042, "epss_percentile": 0.6141}, "CVE-2020-7115": {"epss_score": 0.61646, "epss_percentile": 0.98256}, "CVE-2020-7116": {"epss_score": 0.01944, "epss_percentile": 0.82996}, "CVE-2020-7117": {"epss_score": 0.01944, "epss_percentile": 0.82996}, "CVE-2020-7119": {"epss_score": 0.00343, "epss_percentile": 0.56447}, "CVE-2020-7120": {"epss_score": 0.00072, "epss_percentile": 0.22372}, "CVE-2020-7121": {"epss_score": 0.00346, "epss_percentile": 0.56612}, "CVE-2020-7122": {"epss_score": 0.00346, "epss_percentile": 0.56612}, "CVE-2020-7123": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2020-7124": {"epss_score": 0.00868, "epss_percentile": 0.74675}, "CVE-2020-7125": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2020-7126": {"epss_score": 0.00206, "epss_percentile": 0.42787}, "CVE-2020-7127": {"epss_score": 0.01765, "epss_percentile": 0.82162}, "CVE-2020-7128": {"epss_score": 0.00929, "epss_percentile": 0.75591}, "CVE-2020-7129": {"epss_score": 0.04723, "epss_percentile": 0.89057}, "CVE-2020-7130": {"epss_score": 0.02362, "epss_percentile": 0.845}, "CVE-2020-7131": {"epss_score": 0.00357, "epss_percentile": 0.57471}, "CVE-2020-7132": {"epss_score": 0.00165, "epss_percentile": 0.38035}, "CVE-2020-7133": {"epss_score": 0.01634, "epss_percentile": 0.81466}, "CVE-2020-7134": {"epss_score": 0.00306, "epss_percentile": 0.53399}, "CVE-2020-7135": {"epss_score": 0.00083, "epss_percentile": 0.24608}, "CVE-2020-7136": {"epss_score": 0.6363, "epss_percentile": 0.98342}, "CVE-2020-7137": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2020-7138": {"epss_score": 0.01921, "epss_percentile": 0.82897}, "CVE-2020-7139": {"epss_score": 0.00317, "epss_percentile": 0.54384}, "CVE-2020-7140": {"epss_score": 0.00398, "epss_percentile": 0.60068}, "CVE-2020-7141": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7142": {"epss_score": 0.07205, "epss_percentile": 0.91321}, "CVE-2020-7143": {"epss_score": 0.07205, "epss_percentile": 0.91321}, "CVE-2020-7144": {"epss_score": 0.0678, "epss_percentile": 0.91023}, "CVE-2020-7145": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7146": {"epss_score": 0.07205, "epss_percentile": 0.91321}, "CVE-2020-7147": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7148": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7149": {"epss_score": 0.07205, "epss_percentile": 0.91321}, "CVE-2020-7150": {"epss_score": 0.0678, "epss_percentile": 0.91023}, "CVE-2020-7151": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7152": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7153": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7154": {"epss_score": 0.07205, "epss_percentile": 0.91321}, "CVE-2020-7155": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7156": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7157": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7158": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7159": {"epss_score": 0.07205, "epss_percentile": 0.91321}, "CVE-2020-7160": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7161": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7162": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7163": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7164": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7165": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7166": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7167": {"epss_score": 0.07205, "epss_percentile": 0.91321}, "CVE-2020-7168": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7169": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7170": {"epss_score": 0.06729, "epss_percentile": 0.90986}, "CVE-2020-7171": {"epss_score": 0.07205, "epss_percentile": 0.91321}, "CVE-2020-7172": {"epss_score": 0.07205, "epss_percentile": 0.91321}, "CVE-2020-7173": {"epss_score": 0.0125, "epss_percentile": 0.78877}, "CVE-2020-7174": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7175": {"epss_score": 0.01675, "epss_percentile": 0.81703}, "CVE-2020-7176": {"epss_score": 0.01675, "epss_percentile": 0.81703}, "CVE-2020-7177": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7178": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7179": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7180": {"epss_score": 0.01675, "epss_percentile": 0.81703}, "CVE-2020-7181": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7182": {"epss_score": 0.01675, "epss_percentile": 0.81703}, "CVE-2020-7183": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7184": {"epss_score": 0.01675, "epss_percentile": 0.81703}, "CVE-2020-7185": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7186": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7187": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7188": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7189": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7190": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7191": {"epss_score": 0.01675, "epss_percentile": 0.81703}, "CVE-2020-7192": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7193": {"epss_score": 0.01675, "epss_percentile": 0.81703}, "CVE-2020-7194": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2020-7195": {"epss_score": 0.01675, "epss_percentile": 0.81703}, "CVE-2020-7196": {"epss_score": 0.00158, "epss_percentile": 0.37288}, "CVE-2020-7197": {"epss_score": 0.0205, "epss_percentile": 0.83398}, "CVE-2020-7198": {"epss_score": 0.00446, "epss_percentile": 0.62895}, "CVE-2020-7199": {"epss_score": 0.10907, "epss_percentile": 0.93152}, "CVE-2020-7200": {"epss_score": 0.8554, "epss_percentile": 0.99339}, "CVE-2020-7201": {"epss_score": 0.00217, "epss_percentile": 0.44281}, "CVE-2020-7202": {"epss_score": 0.00349, "epss_percentile": 0.56868}, "CVE-2020-7203": {"epss_score": 0.02794, "epss_percentile": 0.85676}, "CVE-2020-7205": {"epss_score": 0.00108, "epss_percentile": 0.29841}, "CVE-2020-7206": {"epss_score": 0.01043, "epss_percentile": 0.76989}, "CVE-2020-7207": {"epss_score": 0.00077, "epss_percentile": 0.23448}, "CVE-2020-7208": {"epss_score": 0.00567, "epss_percentile": 0.67858}, "CVE-2020-7209": {"epss_score": 0.93631, "epss_percentile": 0.99826}, "CVE-2020-7210": {"epss_score": 0.00232, "epss_percentile": 0.45961}, "CVE-2020-7211": {"epss_score": 0.00305, "epss_percentile": 0.53383}, "CVE-2020-7212": {"epss_score": 0.00603, "epss_percentile": 0.68929}, "CVE-2020-7213": {"epss_score": 0.00248, "epss_percentile": 0.48}, "CVE-2020-7215": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2020-7216": {"epss_score": 0.00341, "epss_percentile": 0.56341}, "CVE-2020-7217": {"epss_score": 0.00597, "epss_percentile": 0.68743}, "CVE-2020-7218": {"epss_score": 0.00772, "epss_percentile": 0.73035}, "CVE-2020-7219": {"epss_score": 0.00873, "epss_percentile": 0.74743}, "CVE-2020-7220": {"epss_score": 0.00305, "epss_percentile": 0.5338}, "CVE-2020-7221": {"epss_score": 0.00269, "epss_percentile": 0.50191}, "CVE-2020-7222": {"epss_score": 0.00257, "epss_percentile": 0.48914}, "CVE-2020-7224": {"epss_score": 0.00623, "epss_percentile": 0.69549}, "CVE-2020-7226": {"epss_score": 0.03282, "epss_percentile": 0.86818}, "CVE-2020-7227": {"epss_score": 0.00376, "epss_percentile": 0.58682}, "CVE-2020-7228": {"epss_score": 0.00614, "epss_percentile": 0.6928}, "CVE-2020-7229": {"epss_score": 0.00399, "epss_percentile": 0.6013}, "CVE-2020-7231": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2020-7232": {"epss_score": 0.00506, "epss_percentile": 0.65636}, "CVE-2020-7233": {"epss_score": 0.00389, "epss_percentile": 0.59454}, "CVE-2020-7234": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-7235": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-7236": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-7237": {"epss_score": 0.46813, "epss_percentile": 0.97558}, "CVE-2020-7238": {"epss_score": 0.01687, "epss_percentile": 0.81757}, "CVE-2020-7239": {"epss_score": 0.00326, "epss_percentile": 0.55062}, "CVE-2020-7240": {"epss_score": 0.01198, "epss_percentile": 0.78456}, "CVE-2020-7241": {"epss_score": 0.005, "epss_percentile": 0.65317}, "CVE-2020-7242": {"epss_score": 0.06123, "epss_percentile": 0.90496}, "CVE-2020-7243": {"epss_score": 0.06123, "epss_percentile": 0.90496}, "CVE-2020-7244": {"epss_score": 0.06123, "epss_percentile": 0.90496}, "CVE-2020-7245": {"epss_score": 0.00383, "epss_percentile": 0.59104}, "CVE-2020-7246": {"epss_score": 0.90588, "epss_percentile": 0.9959}, "CVE-2020-7247": {"epss_score": 0.94076, "epss_percentile": 0.99898}, "CVE-2020-7248": {"epss_score": 0.01111, "epss_percentile": 0.77667}, "CVE-2020-7249": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-7250": {"epss_score": 0.00093, "epss_percentile": 0.267}, "CVE-2020-7251": {"epss_score": 0.00112, "epss_percentile": 0.30529}, "CVE-2020-7252": {"epss_score": 0.00034, "epss_percentile": 0.09458}, "CVE-2020-7253": {"epss_score": 0.00105, "epss_percentile": 0.2939}, "CVE-2020-7254": {"epss_score": 0.001, "epss_percentile": 0.28453}, "CVE-2020-7255": {"epss_score": 0.00084, "epss_percentile": 0.24897}, "CVE-2020-7256": {"epss_score": 0.00283, "epss_percentile": 0.51413}, "CVE-2020-7257": {"epss_score": 0.00136, "epss_percentile": 0.34146}, "CVE-2020-7258": {"epss_score": 0.00283, "epss_percentile": 0.51413}, "CVE-2020-7259": {"epss_score": 0.00039, "epss_percentile": 0.11481}, "CVE-2020-7260": {"epss_score": 0.00054, "epss_percentile": 0.17103}, "CVE-2020-7261": {"epss_score": 0.0013, "epss_percentile": 0.33242}, "CVE-2020-7262": {"epss_score": 0.00296, "epss_percentile": 0.52539}, "CVE-2020-7263": {"epss_score": 0.00039, "epss_percentile": 0.1157}, "CVE-2020-7264": {"epss_score": 0.00035, "epss_percentile": 0.0992}, "CVE-2020-7265": {"epss_score": 0.00035, "epss_percentile": 0.0992}, "CVE-2020-7266": {"epss_score": 0.00035, "epss_percentile": 0.0992}, "CVE-2020-7267": {"epss_score": 0.00035, "epss_percentile": 0.0992}, "CVE-2020-7268": {"epss_score": 0.00147, "epss_percentile": 0.35773}, "CVE-2020-7269": {"epss_score": 0.00088, "epss_percentile": 0.2573}, "CVE-2020-7270": {"epss_score": 0.00176, "epss_percentile": 0.39412}, "CVE-2020-7273": {"epss_score": 0.00091, "epss_percentile": 0.26408}, "CVE-2020-7274": {"epss_score": 0.00113, "epss_percentile": 0.30698}, "CVE-2020-7275": {"epss_score": 0.00121, "epss_percentile": 0.32008}, "CVE-2020-7276": {"epss_score": 0.00046, "epss_percentile": 0.14471}, "CVE-2020-7277": {"epss_score": 0.00127, "epss_percentile": 0.32803}, "CVE-2020-7278": {"epss_score": 0.00155, "epss_percentile": 0.36809}, "CVE-2020-7279": {"epss_score": 0.00034, "epss_percentile": 0.09666}, "CVE-2020-7280": {"epss_score": 0.00042, "epss_percentile": 0.12809}, "CVE-2020-7281": {"epss_score": 0.00029, "epss_percentile": 0.07656}, "CVE-2020-7282": {"epss_score": 0.00048, "epss_percentile": 0.15226}, "CVE-2020-7283": {"epss_score": 0.0034, "epss_percentile": 0.56211}, "CVE-2020-7284": {"epss_score": 0.00047, "epss_percentile": 0.14711}, "CVE-2020-7285": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2020-7286": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2020-7287": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2020-7288": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2020-7289": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2020-7290": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2020-7291": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2020-7292": {"epss_score": 0.00222, "epss_percentile": 0.44793}, "CVE-2020-7293": {"epss_score": 0.00096, "epss_percentile": 0.27362}, "CVE-2020-7294": {"epss_score": 0.00063, "epss_percentile": 0.20099}, "CVE-2020-7295": {"epss_score": 0.00063, "epss_percentile": 0.20099}, "CVE-2020-7296": {"epss_score": 0.00088, "epss_percentile": 0.25706}, "CVE-2020-7297": {"epss_score": 0.00088, "epss_percentile": 0.25706}, "CVE-2020-7298": {"epss_score": 0.00048, "epss_percentile": 0.15028}, "CVE-2020-7299": {"epss_score": 0.0003, "epss_percentile": 0.07981}, "CVE-2020-7300": {"epss_score": 0.00124, "epss_percentile": 0.32368}, "CVE-2020-7301": {"epss_score": 0.00444, "epss_percentile": 0.62843}, "CVE-2020-7302": {"epss_score": 0.00588, "epss_percentile": 0.68497}, "CVE-2020-7303": {"epss_score": 0.00131, "epss_percentile": 0.33446}, "CVE-2020-7304": {"epss_score": 0.00089, "epss_percentile": 0.25832}, "CVE-2020-7305": {"epss_score": 0.00158, "epss_percentile": 0.37203}, "CVE-2020-7306": {"epss_score": 0.00044, "epss_percentile": 0.13509}, "CVE-2020-7307": {"epss_score": 0.00044, "epss_percentile": 0.13509}, "CVE-2020-7308": {"epss_score": 0.00091, "epss_percentile": 0.26256}, "CVE-2020-7309": {"epss_score": 0.00179, "epss_percentile": 0.39808}, "CVE-2020-7310": {"epss_score": 0.00038, "epss_percentile": 0.1131}, "CVE-2020-7311": {"epss_score": 0.00028, "epss_percentile": 0.07249}, "CVE-2020-7312": {"epss_score": 0.00051, "epss_percentile": 0.16328}, "CVE-2020-7314": {"epss_score": 0.00028, "epss_percentile": 0.07317}, "CVE-2020-7315": {"epss_score": 0.00198, "epss_percentile": 0.42011}, "CVE-2020-7316": {"epss_score": 0.00056, "epss_percentile": 0.17955}, "CVE-2020-7317": {"epss_score": 0.00139, "epss_percentile": 0.34589}, "CVE-2020-7318": {"epss_score": 0.12523, "epss_percentile": 0.93707}, "CVE-2020-7319": {"epss_score": 0.00054, "epss_percentile": 0.17288}, "CVE-2020-7320": {"epss_score": 0.00058, "epss_percentile": 0.18526}, "CVE-2020-7322": {"epss_score": 0.00059, "epss_percentile": 0.18847}, "CVE-2020-7323": {"epss_score": 0.00053, "epss_percentile": 0.16816}, "CVE-2020-7324": {"epss_score": 0.00032, "epss_percentile": 0.08811}, "CVE-2020-7325": {"epss_score": 0.00047, "epss_percentile": 0.14573}, "CVE-2020-7326": {"epss_score": 0.00051, "epss_percentile": 0.16267}, "CVE-2020-7327": {"epss_score": 0.00051, "epss_percentile": 0.16267}, "CVE-2020-7328": {"epss_score": 0.01461, "epss_percentile": 0.80432}, "CVE-2020-7329": {"epss_score": 0.00703, "epss_percentile": 0.71545}, "CVE-2020-7330": {"epss_score": 0.00042, "epss_percentile": 0.12809}, "CVE-2020-7331": {"epss_score": 0.00048, "epss_percentile": 0.15177}, "CVE-2020-7332": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2020-7333": {"epss_score": 0.00351, "epss_percentile": 0.57077}, "CVE-2020-7334": {"epss_score": 0.00051, "epss_percentile": 0.16267}, "CVE-2020-7335": {"epss_score": 0.00042, "epss_percentile": 0.12809}, "CVE-2020-7336": {"epss_score": 0.00127, "epss_percentile": 0.32848}, "CVE-2020-7337": {"epss_score": 0.00032, "epss_percentile": 0.0882}, "CVE-2020-7339": {"epss_score": 0.00024, "epss_percentile": 0.05967}, "CVE-2020-7343": {"epss_score": 0.0004, "epss_percentile": 0.11985}, "CVE-2020-7346": {"epss_score": 0.00063, "epss_percentile": 0.19932}, "CVE-2020-7350": {"epss_score": 0.58671, "epss_percentile": 0.98131}, "CVE-2020-7351": {"epss_score": 0.69959, "epss_percentile": 0.9861}, "CVE-2020-7352": {"epss_score": 0.1073, "epss_percentile": 0.93085}, "CVE-2020-7354": {"epss_score": 0.00426, "epss_percentile": 0.61743}, "CVE-2020-7355": {"epss_score": 0.00426, "epss_percentile": 0.61743}, "CVE-2020-7356": {"epss_score": 0.6151, "epss_percentile": 0.98251}, "CVE-2020-7357": {"epss_score": 0.78706, "epss_percentile": 0.99}, "CVE-2020-7358": {"epss_score": 0.0008, "epss_percentile": 0.24154}, "CVE-2020-7360": {"epss_score": 0.00069, "epss_percentile": 0.21532}, "CVE-2020-7361": {"epss_score": 0.35969, "epss_percentile": 0.96944}, "CVE-2020-7363": {"epss_score": 0.00204, "epss_percentile": 0.42654}, "CVE-2020-7364": {"epss_score": 0.00204, "epss_percentile": 0.42654}, "CVE-2020-7369": {"epss_score": 0.00193, "epss_percentile": 0.4149}, "CVE-2020-7370": {"epss_score": 0.00193, "epss_percentile": 0.4149}, "CVE-2020-7371": {"epss_score": 0.00193, "epss_percentile": 0.4149}, "CVE-2020-7373": {"epss_score": 0.9023, "epss_percentile": 0.9957}, "CVE-2020-7374": {"epss_score": 0.44086, "epss_percentile": 0.97418}, "CVE-2020-7376": {"epss_score": 0.00326, "epss_percentile": 0.5508}, "CVE-2020-7377": {"epss_score": 0.0041, "epss_percentile": 0.60799}, "CVE-2020-7378": {"epss_score": 0.08686, "epss_percentile": 0.92202}, "CVE-2020-7381": {"epss_score": 0.00371, "epss_percentile": 0.58358}, "CVE-2020-7382": {"epss_score": 0.00096, "epss_percentile": 0.27404}, "CVE-2020-7383": {"epss_score": 0.00356, "epss_percentile": 0.57353}, "CVE-2020-7384": {"epss_score": 0.64836, "epss_percentile": 0.98394}, "CVE-2020-7385": {"epss_score": 0.00582, "epss_percentile": 0.68283}, "CVE-2020-7387": {"epss_score": 0.48814, "epss_percentile": 0.97656}, "CVE-2020-7388": {"epss_score": 0.7672, "epss_percentile": 0.98901}, "CVE-2020-7389": {"epss_score": 0.06371, "epss_percentile": 0.90705}, "CVE-2020-7390": {"epss_score": 0.00328, "epss_percentile": 0.55158}, "CVE-2020-7450": {"epss_score": 0.01017, "epss_percentile": 0.76692}, "CVE-2020-7451": {"epss_score": 0.00214, "epss_percentile": 0.43957}, "CVE-2020-7452": {"epss_score": 0.00978, "epss_percentile": 0.76253}, "CVE-2020-7453": {"epss_score": 0.00064, "epss_percentile": 0.20107}, "CVE-2020-7454": {"epss_score": 0.00631, "epss_percentile": 0.69727}, "CVE-2020-7455": {"epss_score": 0.00098, "epss_percentile": 0.27704}, "CVE-2020-7456": {"epss_score": 0.00153, "epss_percentile": 0.36541}, "CVE-2020-7457": {"epss_score": 0.3684, "epss_percentile": 0.97004}, "CVE-2020-7458": {"epss_score": 0.01568, "epss_percentile": 0.81077}, "CVE-2020-7459": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2020-7460": {"epss_score": 0.01508, "epss_percentile": 0.80759}, "CVE-2020-7461": {"epss_score": 0.13439, "epss_percentile": 0.93963}, "CVE-2020-7462": {"epss_score": 0.00051, "epss_percentile": 0.16067}, "CVE-2020-7463": {"epss_score": 0.00049, "epss_percentile": 0.15608}, "CVE-2020-7464": {"epss_score": 0.00283, "epss_percentile": 0.51407}, "CVE-2020-7465": {"epss_score": 0.0303, "epss_percentile": 0.86247}, "CVE-2020-7466": {"epss_score": 0.01749, "epss_percentile": 0.82092}, "CVE-2020-7467": {"epss_score": 0.00042, "epss_percentile": 0.12605}, "CVE-2020-7468": {"epss_score": 0.0066, "epss_percentile": 0.7054}, "CVE-2020-7469": {"epss_score": 0.0055, "epss_percentile": 0.67323}, "CVE-2020-7470": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-7471": {"epss_score": 0.07771, "epss_percentile": 0.91673}, "CVE-2020-7472": {"epss_score": 0.01199, "epss_percentile": 0.78463}, "CVE-2020-7473": {"epss_score": 0.67099, "epss_percentile": 0.98495}, "CVE-2020-7474": {"epss_score": 0.00155, "epss_percentile": 0.36837}, "CVE-2020-7475": {"epss_score": 0.00571, "epss_percentile": 0.67986}, "CVE-2020-7476": {"epss_score": 0.00146, "epss_percentile": 0.35558}, "CVE-2020-7477": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2020-7478": {"epss_score": 0.01836, "epss_percentile": 0.82469}, "CVE-2020-7479": {"epss_score": 0.00138, "epss_percentile": 0.34442}, "CVE-2020-7480": {"epss_score": 0.00571, "epss_percentile": 0.67986}, "CVE-2020-7481": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2020-7482": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2020-7483": {"epss_score": 0.00097, "epss_percentile": 0.27556}, "CVE-2020-7484": {"epss_score": 0.00307, "epss_percentile": 0.53567}, "CVE-2020-7485": {"epss_score": 0.00285, "epss_percentile": 0.51662}, "CVE-2020-7486": {"epss_score": 0.003, "epss_percentile": 0.52947}, "CVE-2020-7487": {"epss_score": 0.00221, "epss_percentile": 0.44637}, "CVE-2020-7488": {"epss_score": 0.00188, "epss_percentile": 0.40845}, "CVE-2020-7489": {"epss_score": 0.00473, "epss_percentile": 0.64105}, "CVE-2020-7490": {"epss_score": 0.00135, "epss_percentile": 0.33932}, "CVE-2020-7491": {"epss_score": 0.00249, "epss_percentile": 0.48012}, "CVE-2020-7492": {"epss_score": 0.00292, "epss_percentile": 0.52214}, "CVE-2020-7493": {"epss_score": 0.00341, "epss_percentile": 0.5632}, "CVE-2020-7494": {"epss_score": 0.00433, "epss_percentile": 0.622}, "CVE-2020-7495": {"epss_score": 0.00221, "epss_percentile": 0.44672}, "CVE-2020-7496": {"epss_score": 0.00268, "epss_percentile": 0.50038}, "CVE-2020-7497": {"epss_score": 0.01486, "epss_percentile": 0.80609}, "CVE-2020-7498": {"epss_score": 0.00487, "epss_percentile": 0.64781}, "CVE-2020-7499": {"epss_score": 0.00181, "epss_percentile": 0.40096}, "CVE-2020-7500": {"epss_score": 0.00798, "epss_percentile": 0.73518}, "CVE-2020-7501": {"epss_score": 0.00336, "epss_percentile": 0.55939}, "CVE-2020-7502": {"epss_score": 0.00349, "epss_percentile": 0.56859}, "CVE-2020-7503": {"epss_score": 0.00167, "epss_percentile": 0.38375}, "CVE-2020-7504": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2020-7505": {"epss_score": 0.00353, "epss_percentile": 0.57185}, "CVE-2020-7506": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2020-7507": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-7508": {"epss_score": 0.00257, "epss_percentile": 0.48845}, "CVE-2020-7509": {"epss_score": 0.00399, "epss_percentile": 0.601}, "CVE-2020-7510": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-7511": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2020-7512": {"epss_score": 0.00432, "epss_percentile": 0.62132}, "CVE-2020-7513": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2020-7514": {"epss_score": 0.00027, "epss_percentile": 0.06912}, "CVE-2020-7515": {"epss_score": 0.00047, "epss_percentile": 0.14787}, "CVE-2020-7516": {"epss_score": 0.00026, "epss_percentile": 0.06468}, "CVE-2020-7517": {"epss_score": 0.00028, "epss_percentile": 0.07447}, "CVE-2020-7518": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-7519": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2020-7520": {"epss_score": 0.00325, "epss_percentile": 0.55013}, "CVE-2020-7521": {"epss_score": 0.00733, "epss_percentile": 0.72205}, "CVE-2020-7522": {"epss_score": 0.00733, "epss_percentile": 0.72205}, "CVE-2020-7523": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2020-7524": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2020-7525": {"epss_score": 0.00992, "epss_percentile": 0.76398}, "CVE-2020-7526": {"epss_score": 0.01546, "epss_percentile": 0.80966}, "CVE-2020-7527": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2020-7528": {"epss_score": 0.00407, "epss_percentile": 0.60569}, "CVE-2020-7529": {"epss_score": 0.00221, "epss_percentile": 0.44672}, "CVE-2020-7530": {"epss_score": 0.00345, "epss_percentile": 0.56597}, "CVE-2020-7531": {"epss_score": 0.00176, "epss_percentile": 0.39381}, "CVE-2020-7532": {"epss_score": 0.00427, "epss_percentile": 0.61878}, "CVE-2020-7533": {"epss_score": 0.00233, "epss_percentile": 0.46052}, "CVE-2020-7534": {"epss_score": 0.00178, "epss_percentile": 0.39655}, "CVE-2020-7535": {"epss_score": 0.00426, "epss_percentile": 0.61741}, "CVE-2020-7536": {"epss_score": 0.0048, "epss_percentile": 0.6448}, "CVE-2020-7537": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-7538": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2020-7539": {"epss_score": 0.00393, "epss_percentile": 0.59725}, "CVE-2020-7540": {"epss_score": 0.00309, "epss_percentile": 0.53675}, "CVE-2020-7541": {"epss_score": 0.00311, "epss_percentile": 0.5383}, "CVE-2020-7542": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-7543": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-7544": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2020-7545": {"epss_score": 0.00462, "epss_percentile": 0.63617}, "CVE-2020-7546": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2020-7547": {"epss_score": 0.00336, "epss_percentile": 0.55939}, "CVE-2020-7548": {"epss_score": 0.00591, "epss_percentile": 0.68601}, "CVE-2020-7549": {"epss_score": 0.00522, "epss_percentile": 0.66284}, "CVE-2020-7550": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2020-7551": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2020-7552": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2020-7553": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2020-7554": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2020-7555": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2020-7556": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2020-7557": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2020-7558": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2020-7559": {"epss_score": 0.00505, "epss_percentile": 0.65609}, "CVE-2020-7560": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2020-7561": {"epss_score": 0.00602, "epss_percentile": 0.68873}, "CVE-2020-7562": {"epss_score": 0.00516, "epss_percentile": 0.66014}, "CVE-2020-7563": {"epss_score": 0.01043, "epss_percentile": 0.76988}, "CVE-2020-7564": {"epss_score": 0.01234, "epss_percentile": 0.78759}, "CVE-2020-7565": {"epss_score": 0.00024, "epss_percentile": 0.05977}, "CVE-2020-7566": {"epss_score": 0.00052, "epss_percentile": 0.1639}, "CVE-2020-7567": {"epss_score": 0.00023, "epss_percentile": 0.05472}, "CVE-2020-7568": {"epss_score": 0.00083, "epss_percentile": 0.24696}, "CVE-2020-7569": {"epss_score": 0.0145, "epss_percentile": 0.80356}, "CVE-2020-7570": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2020-7571": {"epss_score": 0.00187, "epss_percentile": 0.40791}, "CVE-2020-7572": {"epss_score": 0.00466, "epss_percentile": 0.63787}, "CVE-2020-7573": {"epss_score": 0.00199, "epss_percentile": 0.42102}, "CVE-2020-7574": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2020-7575": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2020-7576": {"epss_score": 0.00469, "epss_percentile": 0.63944}, "CVE-2020-7577": {"epss_score": 0.00798, "epss_percentile": 0.73511}, "CVE-2020-7578": {"epss_score": 0.00401, "epss_percentile": 0.6023}, "CVE-2020-7579": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2020-7580": {"epss_score": 0.00049, "epss_percentile": 0.15416}, "CVE-2020-7581": {"epss_score": 0.00048, "epss_percentile": 0.1513}, "CVE-2020-7583": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-7584": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-7585": {"epss_score": 0.00087, "epss_percentile": 0.2558}, "CVE-2020-7586": {"epss_score": 0.00151, "epss_percentile": 0.36363}, "CVE-2020-7587": {"epss_score": 0.00498, "epss_percentile": 0.65232}, "CVE-2020-7588": {"epss_score": 0.00398, "epss_percentile": 0.60077}, "CVE-2020-7589": {"epss_score": 0.00354, "epss_percentile": 0.57214}, "CVE-2020-7590": {"epss_score": 0.00129, "epss_percentile": 0.33206}, "CVE-2020-7591": {"epss_score": 0.00268, "epss_percentile": 0.50089}, "CVE-2020-7592": {"epss_score": 0.00033, "epss_percentile": 0.09323}, "CVE-2020-7593": {"epss_score": 0.17292, "epss_percentile": 0.94817}, "CVE-2020-7594": {"epss_score": 0.02391, "epss_percentile": 0.84601}, "CVE-2020-7595": {"epss_score": 0.00466, "epss_percentile": 0.63787}, "CVE-2020-7596": {"epss_score": 0.0129, "epss_percentile": 0.79222}, "CVE-2020-7597": {"epss_score": 0.00687, "epss_percentile": 0.7118}, "CVE-2020-7598": {"epss_score": 0.00253, "epss_percentile": 0.48444}, "CVE-2020-7599": {"epss_score": 0.00181, "epss_percentile": 0.40088}, "CVE-2020-7600": {"epss_score": 0.00319, "epss_percentile": 0.54565}, "CVE-2020-7601": {"epss_score": 0.00712, "epss_percentile": 0.71772}, "CVE-2020-7602": {"epss_score": 0.00426, "epss_percentile": 0.61733}, "CVE-2020-7603": {"epss_score": 0.00426, "epss_percentile": 0.61733}, "CVE-2020-7604": {"epss_score": 0.00426, "epss_percentile": 0.61733}, "CVE-2020-7605": {"epss_score": 0.00426, "epss_percentile": 0.61733}, "CVE-2020-7606": {"epss_score": 0.00426, "epss_percentile": 0.61733}, "CVE-2020-7607": {"epss_score": 0.00426, "epss_percentile": 0.61733}, "CVE-2020-7608": {"epss_score": 0.0011, "epss_percentile": 0.30214}, "CVE-2020-7609": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2020-7610": {"epss_score": 0.00699, "epss_percentile": 0.71455}, "CVE-2020-7611": {"epss_score": 0.005, "epss_percentile": 0.65328}, "CVE-2020-7613": {"epss_score": 0.01803, "epss_percentile": 0.82335}, "CVE-2020-7614": {"epss_score": 0.01346, "epss_percentile": 0.79631}, "CVE-2020-7615": {"epss_score": 0.00477, "epss_percentile": 0.64331}, "CVE-2020-7616": {"epss_score": 0.00318, "epss_percentile": 0.54426}, "CVE-2020-7617": {"epss_score": 0.00234, "epss_percentile": 0.4616}, "CVE-2020-7618": {"epss_score": 0.00318, "epss_percentile": 0.54426}, "CVE-2020-7619": {"epss_score": 0.02062, "epss_percentile": 0.83446}, "CVE-2020-7620": {"epss_score": 0.02062, "epss_percentile": 0.83446}, "CVE-2020-7621": {"epss_score": 0.01743, "epss_percentile": 0.82056}, "CVE-2020-7622": {"epss_score": 0.00451, "epss_percentile": 0.63151}, "CVE-2020-7623": {"epss_score": 0.01562, "epss_percentile": 0.81046}, "CVE-2020-7624": {"epss_score": 0.01227, "epss_percentile": 0.78697}, "CVE-2020-7625": {"epss_score": 0.01227, "epss_percentile": 0.78697}, "CVE-2020-7626": {"epss_score": 0.01227, "epss_percentile": 0.78697}, "CVE-2020-7627": {"epss_score": 0.01227, "epss_percentile": 0.78697}, "CVE-2020-7628": {"epss_score": 0.01334, "epss_percentile": 0.79538}, "CVE-2020-7629": {"epss_score": 0.01227, "epss_percentile": 0.78697}, "CVE-2020-7630": {"epss_score": 0.01227, "epss_percentile": 0.78697}, "CVE-2020-7631": {"epss_score": 0.01227, "epss_percentile": 0.78697}, "CVE-2020-7632": {"epss_score": 0.01227, "epss_percentile": 0.78697}, "CVE-2020-7633": {"epss_score": 0.01227, "epss_percentile": 0.78697}, "CVE-2020-7634": {"epss_score": 0.03263, "epss_percentile": 0.86778}, "CVE-2020-7635": {"epss_score": 0.01227, "epss_percentile": 0.78697}, "CVE-2020-7636": {"epss_score": 0.00906, "epss_percentile": 0.75253}, "CVE-2020-7637": {"epss_score": 0.00318, "epss_percentile": 0.54426}, "CVE-2020-7638": {"epss_score": 0.00347, "epss_percentile": 0.56787}, "CVE-2020-7639": {"epss_score": 0.00326, "epss_percentile": 0.55041}, "CVE-2020-7640": {"epss_score": 0.00646, "epss_percentile": 0.7013}, "CVE-2020-7641": {"epss_score": 0.0005, "epss_percentile": 0.15707}, "CVE-2020-7642": {"epss_score": 0.00341, "epss_percentile": 0.56311}, "CVE-2020-7643": {"epss_score": 0.00318, "epss_percentile": 0.54426}, "CVE-2020-7644": {"epss_score": 0.00506, "epss_percentile": 0.65615}, "CVE-2020-7645": {"epss_score": 0.00584, "epss_percentile": 0.68394}, "CVE-2020-7646": {"epss_score": 0.00184, "epss_percentile": 0.40415}, "CVE-2020-7647": {"epss_score": 0.00264, "epss_percentile": 0.49707}, "CVE-2020-7648": {"epss_score": 0.00393, "epss_percentile": 0.59722}, "CVE-2020-7649": {"epss_score": 0.00566, "epss_percentile": 0.67821}, "CVE-2020-7650": {"epss_score": 0.00393, "epss_percentile": 0.59722}, "CVE-2020-7651": {"epss_score": 0.00233, "epss_percentile": 0.45984}, "CVE-2020-7652": {"epss_score": 0.00406, "epss_percentile": 0.60565}, "CVE-2020-7653": {"epss_score": 0.00393, "epss_percentile": 0.59722}, "CVE-2020-7654": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2020-7655": {"epss_score": 0.00238, "epss_percentile": 0.46802}, "CVE-2020-7656": {"epss_score": 0.01105, "epss_percentile": 0.7761}, "CVE-2020-7658": {"epss_score": 0.00238, "epss_percentile": 0.46802}, "CVE-2020-7659": {"epss_score": 0.00095, "epss_percentile": 0.27172}, "CVE-2020-7660": {"epss_score": 0.02351, "epss_percentile": 0.8447}, "CVE-2020-7661": {"epss_score": 0.00603, "epss_percentile": 0.68899}, "CVE-2020-7662": {"epss_score": 0.00445, "epss_percentile": 0.62859}, "CVE-2020-7663": {"epss_score": 0.00511, "epss_percentile": 0.65828}, "CVE-2020-7664": {"epss_score": 0.00346, "epss_percentile": 0.56708}, "CVE-2020-7665": {"epss_score": 0.00149, "epss_percentile": 0.36011}, "CVE-2020-7666": {"epss_score": 0.00513, "epss_percentile": 0.65895}, "CVE-2020-7667": {"epss_score": 0.00414, "epss_percentile": 0.61101}, "CVE-2020-7668": {"epss_score": 0.00346, "epss_percentile": 0.56708}, "CVE-2020-7669": {"epss_score": 0.00346, "epss_percentile": 0.56632}, "CVE-2020-7670": {"epss_score": 0.00289, "epss_percentile": 0.52073}, "CVE-2020-7671": {"epss_score": 0.00242, "epss_percentile": 0.47354}, "CVE-2020-7672": {"epss_score": 0.00959, "epss_percentile": 0.75952}, "CVE-2020-7673": {"epss_score": 0.01201, "epss_percentile": 0.78484}, "CVE-2020-7674": {"epss_score": 0.01201, "epss_percentile": 0.78484}, "CVE-2020-7675": {"epss_score": 0.01201, "epss_percentile": 0.78484}, "CVE-2020-7676": {"epss_score": 0.00563, "epss_percentile": 0.67738}, "CVE-2020-7677": {"epss_score": 0.00227, "epss_percentile": 0.45397}, "CVE-2020-7678": {"epss_score": 0.00411, "epss_percentile": 0.60885}, "CVE-2020-7679": {"epss_score": 0.00774, "epss_percentile": 0.73072}, "CVE-2020-7680": {"epss_score": 0.05639, "epss_percentile": 0.90075}, "CVE-2020-7681": {"epss_score": 0.00471, "epss_percentile": 0.64027}, "CVE-2020-7682": {"epss_score": 0.00471, "epss_percentile": 0.64027}, "CVE-2020-7683": {"epss_score": 0.00471, "epss_percentile": 0.64027}, "CVE-2020-7684": {"epss_score": 0.00569, "epss_percentile": 0.67921}, "CVE-2020-7685": {"epss_score": 0.00449, "epss_percentile": 0.63054}, "CVE-2020-7686": {"epss_score": 0.00471, "epss_percentile": 0.64027}, "CVE-2020-7687": {"epss_score": 0.00574, "epss_percentile": 0.68085}, "CVE-2020-7688": {"epss_score": 0.00191, "epss_percentile": 0.41176}, "CVE-2020-7689": {"epss_score": 0.00148, "epss_percentile": 0.3591}, "CVE-2020-7690": {"epss_score": 0.00234, "epss_percentile": 0.46096}, "CVE-2020-7691": {"epss_score": 0.00228, "epss_percentile": 0.45483}, "CVE-2020-7692": {"epss_score": 0.00099, "epss_percentile": 0.28313}, "CVE-2020-7693": {"epss_score": 0.15951, "epss_percentile": 0.94542}, "CVE-2020-7694": {"epss_score": 0.00227, "epss_percentile": 0.45396}, "CVE-2020-7695": {"epss_score": 0.003, "epss_percentile": 0.52957}, "CVE-2020-7696": {"epss_score": 0.00455, "epss_percentile": 0.63308}, "CVE-2020-7697": {"epss_score": 0.00421, "epss_percentile": 0.61488}, "CVE-2020-7698": {"epss_score": 0.00421, "epss_percentile": 0.61488}, "CVE-2020-7699": {"epss_score": 0.04089, "epss_percentile": 0.88235}, "CVE-2020-7700": {"epss_score": 0.0041, "epss_percentile": 0.60805}, "CVE-2020-7701": {"epss_score": 0.01104, "epss_percentile": 0.77598}, "CVE-2020-7702": {"epss_score": 0.0041, "epss_percentile": 0.60805}, "CVE-2020-7703": {"epss_score": 0.0041, "epss_percentile": 0.60805}, "CVE-2020-7704": {"epss_score": 0.01718, "epss_percentile": 0.8192}, "CVE-2020-7705": {"epss_score": 0.00331, "epss_percentile": 0.55527}, "CVE-2020-7706": {"epss_score": 0.01718, "epss_percentile": 0.8192}, "CVE-2020-7707": {"epss_score": 0.02086, "epss_percentile": 0.83549}, "CVE-2020-7708": {"epss_score": 0.01085, "epss_percentile": 0.77401}, "CVE-2020-7709": {"epss_score": 0.01043, "epss_percentile": 0.76995}, "CVE-2020-7710": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-7711": {"epss_score": 0.00438, "epss_percentile": 0.62554}, "CVE-2020-7712": {"epss_score": 0.0039, "epss_percentile": 0.59517}, "CVE-2020-7713": {"epss_score": 0.0041, "epss_percentile": 0.60805}, "CVE-2020-7714": {"epss_score": 0.0041, "epss_percentile": 0.60805}, "CVE-2020-7715": {"epss_score": 0.00795, "epss_percentile": 0.73474}, "CVE-2020-7716": {"epss_score": 0.00448, "epss_percentile": 0.63}, "CVE-2020-7717": {"epss_score": 0.0041, "epss_percentile": 0.60805}, "CVE-2020-7718": {"epss_score": 0.0041, "epss_percentile": 0.60805}, "CVE-2020-7719": {"epss_score": 0.01718, "epss_percentile": 0.8192}, "CVE-2020-7720": {"epss_score": 0.02085, "epss_percentile": 0.83546}, "CVE-2020-7721": {"epss_score": 0.0041, "epss_percentile": 0.60805}, "CVE-2020-7722": {"epss_score": 0.0041, "epss_percentile": 0.60805}, "CVE-2020-7723": {"epss_score": 0.0041, "epss_percentile": 0.60805}, "CVE-2020-7724": {"epss_score": 0.00386, "epss_percentile": 0.59278}, "CVE-2020-7725": {"epss_score": 0.00386, "epss_percentile": 0.59278}, "CVE-2020-7726": {"epss_score": 0.00386, "epss_percentile": 0.59278}, "CVE-2020-7727": {"epss_score": 0.00386, "epss_percentile": 0.59278}, "CVE-2020-7729": {"epss_score": 0.03584, "epss_percentile": 0.87389}, "CVE-2020-7730": {"epss_score": 0.08, "epss_percentile": 0.91821}, "CVE-2020-7731": {"epss_score": 0.00604, "epss_percentile": 0.6894}, "CVE-2020-7733": {"epss_score": 0.01196, "epss_percentile": 0.78442}, "CVE-2020-7734": {"epss_score": 0.01413, "epss_percentile": 0.80117}, "CVE-2020-7735": {"epss_score": 0.0271, "epss_percentile": 0.85491}, "CVE-2020-7736": {"epss_score": 0.00849, "epss_percentile": 0.74382}, "CVE-2020-7737": {"epss_score": 0.00391, "epss_percentile": 0.59562}, "CVE-2020-7738": {"epss_score": 0.00765, "epss_percentile": 0.72921}, "CVE-2020-7739": {"epss_score": 0.00267, "epss_percentile": 0.49951}, "CVE-2020-7740": {"epss_score": 0.0548, "epss_percentile": 0.89919}, "CVE-2020-7741": {"epss_score": 0.00517, "epss_percentile": 0.66084}, "CVE-2020-7742": {"epss_score": 0.00366, "epss_percentile": 0.58025}, "CVE-2020-7743": {"epss_score": 0.01682, "epss_percentile": 0.81736}, "CVE-2020-7744": {"epss_score": 0.00154, "epss_percentile": 0.36656}, "CVE-2020-7745": {"epss_score": 0.00448, "epss_percentile": 0.62995}, "CVE-2020-7746": {"epss_score": 0.00155, "epss_percentile": 0.36844}, "CVE-2020-7747": {"epss_score": 0.00437, "epss_percentile": 0.62489}, "CVE-2020-7748": {"epss_score": 0.00555, "epss_percentile": 0.67492}, "CVE-2020-7749": {"epss_score": 0.00477, "epss_percentile": 0.64298}, "CVE-2020-7750": {"epss_score": 0.0695, "epss_percentile": 0.91137}, "CVE-2020-7751": {"epss_score": 0.0065, "epss_percentile": 0.70253}, "CVE-2020-7752": {"epss_score": 0.03143, "epss_percentile": 0.86492}, "CVE-2020-7753": {"epss_score": 0.06853, "epss_percentile": 0.91074}, "CVE-2020-7754": {"epss_score": 0.0163, "epss_percentile": 0.81441}, "CVE-2020-7755": {"epss_score": 0.00554, "epss_percentile": 0.67445}, "CVE-2020-7757": {"epss_score": 0.00382, "epss_percentile": 0.59038}, "CVE-2020-7758": {"epss_score": 0.00411, "epss_percentile": 0.60896}, "CVE-2020-7759": {"epss_score": 0.00037, "epss_percentile": 0.10885}, "CVE-2020-7760": {"epss_score": 0.0034, "epss_percentile": 0.56229}, "CVE-2020-7761": {"epss_score": 0.00363, "epss_percentile": 0.57834}, "CVE-2020-7762": {"epss_score": 0.00344, "epss_percentile": 0.56516}, "CVE-2020-7763": {"epss_score": 0.00405, "epss_percentile": 0.60458}, "CVE-2020-7764": {"epss_score": 0.00974, "epss_percentile": 0.76172}, "CVE-2020-7765": {"epss_score": 0.00169, "epss_percentile": 0.38538}, "CVE-2020-7766": {"epss_score": 0.01064, "epss_percentile": 0.77198}, "CVE-2020-7767": {"epss_score": 0.00363, "epss_percentile": 0.57834}, "CVE-2020-7768": {"epss_score": 0.01142, "epss_percentile": 0.77974}, "CVE-2020-7769": {"epss_score": 0.00509, "epss_percentile": 0.65754}, "CVE-2020-7770": {"epss_score": 0.00334, "epss_percentile": 0.55713}, "CVE-2020-7771": {"epss_score": 0.00448, "epss_percentile": 0.63}, "CVE-2020-7772": {"epss_score": 0.00781, "epss_percentile": 0.73178}, "CVE-2020-7773": {"epss_score": 0.00367, "epss_percentile": 0.58135}, "CVE-2020-7774": {"epss_score": 0.00637, "epss_percentile": 0.69879}, "CVE-2020-7775": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-7776": {"epss_score": 0.00335, "epss_percentile": 0.55892}, "CVE-2020-7777": {"epss_score": 0.0098, "epss_percentile": 0.76264}, "CVE-2020-7778": {"epss_score": 0.01103, "epss_percentile": 0.77594}, "CVE-2020-7779": {"epss_score": 0.00398, "epss_percentile": 0.60081}, "CVE-2020-7780": {"epss_score": 0.00365, "epss_percentile": 0.58012}, "CVE-2020-7781": {"epss_score": 0.0056, "epss_percentile": 0.67648}, "CVE-2020-7782": {"epss_score": 0.00613, "epss_percentile": 0.69255}, "CVE-2020-7784": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-7785": {"epss_score": 0.00613, "epss_percentile": 0.69255}, "CVE-2020-7786": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2020-7787": {"epss_score": 0.00267, "epss_percentile": 0.49964}, "CVE-2020-7788": {"epss_score": 0.00291, "epss_percentile": 0.52179}, "CVE-2020-7789": {"epss_score": 0.00197, "epss_percentile": 0.41872}, "CVE-2020-7790": {"epss_score": 0.00264, "epss_percentile": 0.49569}, "CVE-2020-7791": {"epss_score": 0.01483, "epss_percentile": 0.80587}, "CVE-2020-7792": {"epss_score": 0.00982, "epss_percentile": 0.76298}, "CVE-2020-7793": {"epss_score": 0.02644, "epss_percentile": 0.85319}, "CVE-2020-7794": {"epss_score": 0.00571, "epss_percentile": 0.67986}, "CVE-2020-7795": {"epss_score": 0.07563, "epss_percentile": 0.91543}, "CVE-2020-7796": {"epss_score": 0.90602, "epss_percentile": 0.99591}, "CVE-2020-7799": {"epss_score": 0.72738, "epss_percentile": 0.98724}, "CVE-2020-7800": {"epss_score": 0.03351, "epss_percentile": 0.86964}, "CVE-2020-7801": {"epss_score": 0.00174, "epss_percentile": 0.39141}, "CVE-2020-7802": {"epss_score": 0.00116, "epss_percentile": 0.31136}, "CVE-2020-7803": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2020-7804": {"epss_score": 0.00674, "epss_percentile": 0.70883}, "CVE-2020-7805": {"epss_score": 0.05268, "epss_percentile": 0.89675}, "CVE-2020-7806": {"epss_score": 0.00464, "epss_percentile": 0.63716}, "CVE-2020-7807": {"epss_score": 0.00025, "epss_percentile": 0.06298}, "CVE-2020-7808": {"epss_score": 0.00236, "epss_percentile": 0.46373}, "CVE-2020-7809": {"epss_score": 0.00264, "epss_percentile": 0.49738}, "CVE-2020-7810": {"epss_score": 0.00197, "epss_percentile": 0.41834}, "CVE-2020-7811": {"epss_score": 0.00043, "epss_percentile": 0.13217}, "CVE-2020-7812": {"epss_score": 0.00464, "epss_percentile": 0.63716}, "CVE-2020-7813": {"epss_score": 0.00409, "epss_percentile": 0.60762}, "CVE-2020-7814": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2020-7815": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2020-7816": {"epss_score": 0.01339, "epss_percentile": 0.79571}, "CVE-2020-7817": {"epss_score": 0.00064, "epss_percentile": 0.20199}, "CVE-2020-7818": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2020-7819": {"epss_score": 0.01249, "epss_percentile": 0.78873}, "CVE-2020-7820": {"epss_score": 0.00965, "epss_percentile": 0.76047}, "CVE-2020-7821": {"epss_score": 0.00965, "epss_percentile": 0.76047}, "CVE-2020-7822": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2020-7823": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2020-7824": {"epss_score": 0.00174, "epss_percentile": 0.39162}, "CVE-2020-7825": {"epss_score": 0.00511, "epss_percentile": 0.65836}, "CVE-2020-7826": {"epss_score": 0.00233, "epss_percentile": 0.4604}, "CVE-2020-7827": {"epss_score": 0.00681, "epss_percentile": 0.71042}, "CVE-2020-7828": {"epss_score": 0.0055, "epss_percentile": 0.67336}, "CVE-2020-7829": {"epss_score": 0.0055, "epss_percentile": 0.67336}, "CVE-2020-7830": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2020-7831": {"epss_score": 0.0037, "epss_percentile": 0.58278}, "CVE-2020-7832": {"epss_score": 0.0099, "epss_percentile": 0.76381}, "CVE-2020-7836": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2020-7837": {"epss_score": 0.0042, "epss_percentile": 0.61459}, "CVE-2020-7838": {"epss_score": 0.0041, "epss_percentile": 0.60793}, "CVE-2020-7839": {"epss_score": 0.02773, "epss_percentile": 0.85629}, "CVE-2020-7841": {"epss_score": 0.00654, "epss_percentile": 0.70354}, "CVE-2020-7842": {"epss_score": 0.00891, "epss_percentile": 0.75036}, "CVE-2020-7845": {"epss_score": 0.02684, "epss_percentile": 0.85423}, "CVE-2020-7846": {"epss_score": 0.00475, "epss_percentile": 0.64185}, "CVE-2020-7847": {"epss_score": 0.00274, "epss_percentile": 0.50526}, "CVE-2020-7848": {"epss_score": 0.02892, "epss_percentile": 0.85918}, "CVE-2020-7849": {"epss_score": 0.00776, "epss_percentile": 0.73104}, "CVE-2020-7850": {"epss_score": 0.00331, "epss_percentile": 0.55515}, "CVE-2020-7851": {"epss_score": 0.00331, "epss_percentile": 0.55515}, "CVE-2020-7852": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2020-7853": {"epss_score": 0.00341, "epss_percentile": 0.56322}, "CVE-2020-7856": {"epss_score": 0.00813, "epss_percentile": 0.73754}, "CVE-2020-7857": {"epss_score": 0.00521, "epss_percentile": 0.66239}, "CVE-2020-7858": {"epss_score": 0.00424, "epss_percentile": 0.61637}, "CVE-2020-7860": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2020-7861": {"epss_score": 0.01101, "epss_percentile": 0.77572}, "CVE-2020-7862": {"epss_score": 0.00626, "epss_percentile": 0.69606}, "CVE-2020-7863": {"epss_score": 0.00436, "epss_percentile": 0.62433}, "CVE-2020-7864": {"epss_score": 0.00363, "epss_percentile": 0.57825}, "CVE-2020-7865": {"epss_score": 0.0099, "epss_percentile": 0.76381}, "CVE-2020-7866": {"epss_score": 0.00555, "epss_percentile": 0.67495}, "CVE-2020-7867": {"epss_score": 0.00409, "epss_percentile": 0.60738}, "CVE-2020-7868": {"epss_score": 0.02328, "epss_percentile": 0.84397}, "CVE-2020-7869": {"epss_score": 0.01269, "epss_percentile": 0.7904}, "CVE-2020-7870": {"epss_score": 0.00273, "epss_percentile": 0.50443}, "CVE-2020-7871": {"epss_score": 0.00906, "epss_percentile": 0.75258}, "CVE-2020-7872": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2020-7873": {"epss_score": 0.00233, "epss_percentile": 0.4604}, "CVE-2020-7874": {"epss_score": 0.00233, "epss_percentile": 0.4604}, "CVE-2020-7875": {"epss_score": 0.00409, "epss_percentile": 0.60703}, "CVE-2020-7877": {"epss_score": 0.0053, "epss_percentile": 0.66609}, "CVE-2020-7878": {"epss_score": 0.00337, "epss_percentile": 0.56049}, "CVE-2020-7879": {"epss_score": 0.00806, "epss_percentile": 0.73647}, "CVE-2020-7880": {"epss_score": 0.00734, "epss_percentile": 0.72252}, "CVE-2020-7881": {"epss_score": 0.01247, "epss_percentile": 0.78858}, "CVE-2020-7882": {"epss_score": 0.00407, "epss_percentile": 0.60578}, "CVE-2020-7883": {"epss_score": 0.00772, "epss_percentile": 0.73038}, "CVE-2020-7904": {"epss_score": 3e-05, "epss_percentile": 0.00062}, "CVE-2020-7905": {"epss_score": 3e-05, "epss_percentile": 0.00092}, "CVE-2020-7906": {"epss_score": 2e-05, "epss_percentile": 0.00046}, "CVE-2020-7907": {"epss_score": 2e-05, "epss_percentile": 0.00047}, "CVE-2020-7908": {"epss_score": 2e-05, "epss_percentile": 0.00044}, "CVE-2020-7909": {"epss_score": 3e-05, "epss_percentile": 0.0007}, "CVE-2020-7910": {"epss_score": 7e-05, "epss_percentile": 0.00429}, "CVE-2020-7911": {"epss_score": 7e-05, "epss_percentile": 0.00342}, "CVE-2020-7912": {"epss_score": 3e-05, "epss_percentile": 0.00081}, "CVE-2020-7913": {"epss_score": 5e-05, "epss_percentile": 0.00213}, "CVE-2020-7914": {"epss_score": 4e-05, "epss_percentile": 0.0013}, "CVE-2020-7915": {"epss_score": 0.00323, "epss_percentile": 0.54896}, "CVE-2020-7916": {"epss_score": 0.00382, "epss_percentile": 0.59065}, "CVE-2020-7918": {"epss_score": 0.0019, "epss_percentile": 0.41007}, "CVE-2020-7919": {"epss_score": 0.0085, "epss_percentile": 0.7439}, "CVE-2020-7920": {"epss_score": 0.00757, "epss_percentile": 0.72752}, "CVE-2020-7921": {"epss_score": 0.00179, "epss_percentile": 0.39839}, "CVE-2020-7922": {"epss_score": 0.002, "epss_percentile": 0.4224}, "CVE-2020-7923": {"epss_score": 0.00441, "epss_percentile": 0.62659}, "CVE-2020-7924": {"epss_score": 0.00283, "epss_percentile": 0.51356}, "CVE-2020-7925": {"epss_score": 0.01665, "epss_percentile": 0.81649}, "CVE-2020-7926": {"epss_score": 0.00441, "epss_percentile": 0.62659}, "CVE-2020-7927": {"epss_score": 0.00554, "epss_percentile": 0.6744}, "CVE-2020-7928": {"epss_score": 0.00484, "epss_percentile": 0.64666}, "CVE-2020-7929": {"epss_score": 0.00441, "epss_percentile": 0.62659}, "CVE-2020-7931": {"epss_score": 0.33484, "epss_percentile": 0.96777}, "CVE-2020-7932": {"epss_score": 0.00345, "epss_percentile": 0.56596}, "CVE-2020-7934": {"epss_score": 0.03286, "epss_percentile": 0.86825}, "CVE-2020-7935": {"epss_score": 0.00598, "epss_percentile": 0.68757}, "CVE-2020-7936": {"epss_score": 0.0034, "epss_percentile": 0.56246}, "CVE-2020-7937": {"epss_score": 0.00504, "epss_percentile": 0.65528}, "CVE-2020-7938": {"epss_score": 0.00628, "epss_percentile": 0.69659}, "CVE-2020-7939": {"epss_score": 0.00509, "epss_percentile": 0.6572}, "CVE-2020-7940": {"epss_score": 0.0034, "epss_percentile": 0.56259}, "CVE-2020-7941": {"epss_score": 0.00619, "epss_percentile": 0.69436}, "CVE-2020-7942": {"epss_score": 0.00119, "epss_percentile": 0.31556}, "CVE-2020-7943": {"epss_score": 0.65366, "epss_percentile": 0.98415}, "CVE-2020-7944": {"epss_score": 0.00405, "epss_percentile": 0.6049}, "CVE-2020-7945": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2020-7947": {"epss_score": 0.01807, "epss_percentile": 0.82355}, "CVE-2020-7948": {"epss_score": 0.01853, "epss_percentile": 0.82546}, "CVE-2020-7949": {"epss_score": 0.09972, "epss_percentile": 0.92798}, "CVE-2020-7950": {"epss_score": 0.02603, "epss_percentile": 0.85213}, "CVE-2020-7951": {"epss_score": 0.02603, "epss_percentile": 0.85213}, "CVE-2020-7952": {"epss_score": 0.02603, "epss_percentile": 0.85213}, "CVE-2020-7953": {"epss_score": 0.00365, "epss_percentile": 0.57967}, "CVE-2020-7954": {"epss_score": 0.00148, "epss_percentile": 0.35804}, "CVE-2020-7955": {"epss_score": 0.00332, "epss_percentile": 0.55552}, "CVE-2020-7956": {"epss_score": 0.00244, "epss_percentile": 0.47576}, "CVE-2020-7957": {"epss_score": 0.00366, "epss_percentile": 0.58055}, "CVE-2020-7958": {"epss_score": 0.00177, "epss_percentile": 0.39603}, "CVE-2020-7959": {"epss_score": 0.00209, "epss_percentile": 0.43325}, "CVE-2020-7961": {"epss_score": 0.94352, "epss_percentile": 0.99956}, "CVE-2020-7962": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2020-7964": {"epss_score": 0.00315, "epss_percentile": 0.54193}, "CVE-2020-7965": {"epss_score": 0.00167, "epss_percentile": 0.38369}, "CVE-2020-7966": {"epss_score": 0.00055, "epss_percentile": 0.17421}, "CVE-2020-7967": {"epss_score": 0.00047, "epss_percentile": 0.14478}, "CVE-2020-7968": {"epss_score": 0.00077, "epss_percentile": 0.23285}, "CVE-2020-7969": {"epss_score": 0.00077, "epss_percentile": 0.23384}, "CVE-2020-7971": {"epss_score": 0.001, "epss_percentile": 0.28555}, "CVE-2020-7972": {"epss_score": 0.00052, "epss_percentile": 0.16439}, "CVE-2020-7973": {"epss_score": 0.0021, "epss_percentile": 0.43439}, "CVE-2020-7974": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2020-7976": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2020-7977": {"epss_score": 0.00052, "epss_percentile": 0.16439}, "CVE-2020-7978": {"epss_score": 0.00141, "epss_percentile": 0.34932}, "CVE-2020-7979": {"epss_score": 0.00075, "epss_percentile": 0.22898}, "CVE-2020-7980": {"epss_score": 0.93932, "epss_percentile": 0.9987}, "CVE-2020-7981": {"epss_score": 0.00626, "epss_percentile": 0.69616}, "CVE-2020-7982": {"epss_score": 0.04368, "epss_percentile": 0.88605}, "CVE-2020-7983": {"epss_score": 0.00147, "epss_percentile": 0.35673}, "CVE-2020-7984": {"epss_score": 0.008, "epss_percentile": 0.73547}, "CVE-2020-7988": {"epss_score": 0.00718, "epss_percentile": 0.71919}, "CVE-2020-7989": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-7990": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-7991": {"epss_score": 0.00401, "epss_percentile": 0.60203}, "CVE-2020-7993": {"epss_score": 0.00221, "epss_percentile": 0.44652}, "CVE-2020-7994": {"epss_score": 0.00542, "epss_percentile": 0.67061}, "CVE-2020-7995": {"epss_score": 0.00636, "epss_percentile": 0.69865}, "CVE-2020-7996": {"epss_score": 0.00365, "epss_percentile": 0.57974}, "CVE-2020-7997": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-7998": {"epss_score": 0.00433, "epss_percentile": 0.62186}, "CVE-2020-7999": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2020-8000": {"epss_score": 0.00811, "epss_percentile": 0.73739}, "CVE-2020-8001": {"epss_score": 0.00389, "epss_percentile": 0.59454}, "CVE-2020-8002": {"epss_score": 0.0015, "epss_percentile": 0.36176}, "CVE-2020-8003": {"epss_score": 0.00165, "epss_percentile": 0.38011}, "CVE-2020-8004": {"epss_score": 0.06145, "epss_percentile": 0.90517}, "CVE-2020-8006": {"epss_score": 0.00225, "epss_percentile": 0.45095}, "CVE-2020-8007": {"epss_score": 0.00735, "epss_percentile": 0.72292}, "CVE-2020-8009": {"epss_score": 0.00482, "epss_percentile": 0.64525}, "CVE-2020-8010": {"epss_score": 0.80938, "epss_percentile": 0.99113}, "CVE-2020-8011": {"epss_score": 0.01248, "epss_percentile": 0.78864}, "CVE-2020-8012": {"epss_score": 0.80953, "epss_percentile": 0.99114}, "CVE-2020-8013": {"epss_score": 0.00053, "epss_percentile": 0.16711}, "CVE-2020-8014": {"epss_score": 0.00034, "epss_percentile": 0.09584}, "CVE-2020-8015": {"epss_score": 0.00143, "epss_percentile": 0.3511}, "CVE-2020-8016": {"epss_score": 0.00094, "epss_percentile": 0.27036}, "CVE-2020-8017": {"epss_score": 0.00023, "epss_percentile": 0.05441}, "CVE-2020-8018": {"epss_score": 0.00027, "epss_percentile": 0.06811}, "CVE-2020-8019": {"epss_score": 0.00147, "epss_percentile": 0.35724}, "CVE-2020-8020": {"epss_score": 0.0022, "epss_percentile": 0.44556}, "CVE-2020-8021": {"epss_score": 0.00186, "epss_percentile": 0.40602}, "CVE-2020-8022": {"epss_score": 0.00187, "epss_percentile": 0.40766}, "CVE-2020-8023": {"epss_score": 0.00061, "epss_percentile": 0.19259}, "CVE-2020-8024": {"epss_score": 0.00155, "epss_percentile": 0.36762}, "CVE-2020-8025": {"epss_score": 0.001, "epss_percentile": 0.28501}, "CVE-2020-8026": {"epss_score": 0.00051, "epss_percentile": 0.16287}, "CVE-2020-8027": {"epss_score": 0.00041, "epss_percentile": 0.12245}, "CVE-2020-8028": {"epss_score": 0.00031, "epss_percentile": 0.08573}, "CVE-2020-8029": {"epss_score": 0.0011, "epss_percentile": 0.30119}, "CVE-2020-8030": {"epss_score": 0.00041, "epss_percentile": 0.12355}, "CVE-2020-8031": {"epss_score": 0.00217, "epss_percentile": 0.44284}, "CVE-2020-8032": {"epss_score": 0.00126, "epss_percentile": 0.32681}, "CVE-2020-8033": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-8034": {"epss_score": 0.00499, "epss_percentile": 0.65283}, "CVE-2020-8035": {"epss_score": 0.0045, "epss_percentile": 0.631}, "CVE-2020-8036": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2020-8037": {"epss_score": 0.00219, "epss_percentile": 0.44441}, "CVE-2020-8086": {"epss_score": 0.0067, "epss_percentile": 0.70778}, "CVE-2020-8087": {"epss_score": 0.03551, "epss_percentile": 0.87341}, "CVE-2020-8088": {"epss_score": 0.0015, "epss_percentile": 0.36053}, "CVE-2020-8089": {"epss_score": 0.00408, "epss_percentile": 0.60683}, "CVE-2020-8090": {"epss_score": 0.00323, "epss_percentile": 0.54896}, "CVE-2020-8091": {"epss_score": 0.20517, "epss_percentile": 0.95362}, "CVE-2020-8092": {"epss_score": 0.00101, "epss_percentile": 0.28672}, "CVE-2020-8093": {"epss_score": 0.00101, "epss_percentile": 0.28642}, "CVE-2020-8094": {"epss_score": 0.00031, "epss_percentile": 0.08576}, "CVE-2020-8095": {"epss_score": 0.00148, "epss_percentile": 0.35801}, "CVE-2020-8096": {"epss_score": 0.00221, "epss_percentile": 0.4465}, "CVE-2020-8097": {"epss_score": 0.00023, "epss_percentile": 0.05371}, "CVE-2020-8099": {"epss_score": 0.00037, "epss_percentile": 0.10677}, "CVE-2020-8100": {"epss_score": 0.00472, "epss_percentile": 0.64045}, "CVE-2020-8101": {"epss_score": 0.00547, "epss_percentile": 0.67229}, "CVE-2020-8102": {"epss_score": 0.00499, "epss_percentile": 0.65253}, "CVE-2020-8103": {"epss_score": 0.01033, "epss_percentile": 0.76878}, "CVE-2020-8105": {"epss_score": 0.00353, "epss_percentile": 0.57145}, "CVE-2020-8107": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-8108": {"epss_score": 0.0005, "epss_percentile": 0.15763}, "CVE-2020-8109": {"epss_score": 0.00277, "epss_percentile": 0.50844}, "CVE-2020-8110": {"epss_score": 0.00277, "epss_percentile": 0.50844}, "CVE-2020-8112": {"epss_score": 0.01428, "epss_percentile": 0.8022}, "CVE-2020-8113": {"epss_score": 0.00183, "epss_percentile": 0.4035}, "CVE-2020-8114": {"epss_score": 0.00183, "epss_percentile": 0.4035}, "CVE-2020-8115": {"epss_score": 0.55788, "epss_percentile": 0.97996}, "CVE-2020-8116": {"epss_score": 0.0033, "epss_percentile": 0.55491}, "CVE-2020-8117": {"epss_score": 0.00304, "epss_percentile": 0.53237}, "CVE-2020-8118": {"epss_score": 0.01317, "epss_percentile": 0.79419}, "CVE-2020-8119": {"epss_score": 0.00517, "epss_percentile": 0.66068}, "CVE-2020-8120": {"epss_score": 0.00331, "epss_percentile": 0.55516}, "CVE-2020-8121": {"epss_score": 0.00437, "epss_percentile": 0.62514}, "CVE-2020-8122": {"epss_score": 0.0029, "epss_percentile": 0.52107}, "CVE-2020-8123": {"epss_score": 0.00633, "epss_percentile": 0.69769}, "CVE-2020-8124": {"epss_score": 0.00055, "epss_percentile": 0.17578}, "CVE-2020-8125": {"epss_score": 0.01074, "epss_percentile": 0.77303}, "CVE-2020-8126": {"epss_score": 0.00155, "epss_percentile": 0.36757}, "CVE-2020-8127": {"epss_score": 0.00534, "epss_percentile": 0.6678}, "CVE-2020-8128": {"epss_score": 0.00429, "epss_percentile": 0.61991}, "CVE-2020-8129": {"epss_score": 0.00488, "epss_percentile": 0.64835}, "CVE-2020-8130": {"epss_score": 0.00079, "epss_percentile": 0.23875}, "CVE-2020-8131": {"epss_score": 0.00897, "epss_percentile": 0.75129}, "CVE-2020-8132": {"epss_score": 0.00459, "epss_percentile": 0.63462}, "CVE-2020-8133": {"epss_score": 0.00169, "epss_percentile": 0.38554}, "CVE-2020-8134": {"epss_score": 0.00299, "epss_percentile": 0.52839}, "CVE-2020-8135": {"epss_score": 0.0051, "epss_percentile": 0.65788}, "CVE-2020-8136": {"epss_score": 0.00751, "epss_percentile": 0.72643}, "CVE-2020-8137": {"epss_score": 0.04715, "epss_percentile": 0.89043}, "CVE-2020-8138": {"epss_score": 0.00222, "epss_percentile": 0.44741}, "CVE-2020-8139": {"epss_score": 0.00317, "epss_percentile": 0.54313}, "CVE-2020-8140": {"epss_score": 0.00175, "epss_percentile": 0.39338}, "CVE-2020-8141": {"epss_score": 0.01037, "epss_percentile": 0.7693}, "CVE-2020-8142": {"epss_score": 0.00085, "epss_percentile": 0.25156}, "CVE-2020-8143": {"epss_score": 0.06369, "epss_percentile": 0.90704}, "CVE-2020-8144": {"epss_score": 0.00262, "epss_percentile": 0.49332}, "CVE-2020-8145": {"epss_score": 0.00231, "epss_percentile": 0.45789}, "CVE-2020-8146": {"epss_score": 0.00051, "epss_percentile": 0.16173}, "CVE-2020-8147": {"epss_score": 0.01115, "epss_percentile": 0.77717}, "CVE-2020-8148": {"epss_score": 0.0035, "epss_percentile": 0.56926}, "CVE-2020-8149": {"epss_score": 0.02036, "epss_percentile": 0.83354}, "CVE-2020-8150": {"epss_score": 0.00036, "epss_percentile": 0.10227}, "CVE-2020-8151": {"epss_score": 0.00286, "epss_percentile": 0.51771}, "CVE-2020-8152": {"epss_score": 0.00038, "epss_percentile": 0.11335}, "CVE-2020-8153": {"epss_score": 0.00367, "epss_percentile": 0.58105}, "CVE-2020-8154": {"epss_score": 0.00964, "epss_percentile": 0.76025}, "CVE-2020-8155": {"epss_score": 0.00569, "epss_percentile": 0.67933}, "CVE-2020-8156": {"epss_score": 0.00543, "epss_percentile": 0.67104}, "CVE-2020-8157": {"epss_score": 0.00036, "epss_percentile": 0.10512}, "CVE-2020-8158": {"epss_score": 0.00284, "epss_percentile": 0.51427}, "CVE-2020-8159": {"epss_score": 0.0542, "epss_percentile": 0.89856}, "CVE-2020-8160": {"epss_score": 0.00263, "epss_percentile": 0.49508}, "CVE-2020-8161": {"epss_score": 0.00475, "epss_percentile": 0.64195}, "CVE-2020-8162": {"epss_score": 0.01549, "epss_percentile": 0.80983}, "CVE-2020-8163": {"epss_score": 0.90927, "epss_percentile": 0.9961}, "CVE-2020-8164": {"epss_score": 0.08889, "epss_percentile": 0.92302}, "CVE-2020-8165": {"epss_score": 0.90128, "epss_percentile": 0.99563}, "CVE-2020-8166": {"epss_score": 0.00443, "epss_percentile": 0.62765}, "CVE-2020-8167": {"epss_score": 0.00592, "epss_percentile": 0.68622}, "CVE-2020-8168": {"epss_score": 0.00315, "epss_percentile": 0.54174}, "CVE-2020-8169": {"epss_score": 0.00053, "epss_percentile": 0.16863}, "CVE-2020-8170": {"epss_score": 0.0037, "epss_percentile": 0.58335}, "CVE-2020-8171": {"epss_score": 0.06929, "epss_percentile": 0.91121}, "CVE-2020-8172": {"epss_score": 0.01031, "epss_percentile": 0.76852}, "CVE-2020-8173": {"epss_score": 0.00093, "epss_percentile": 0.26668}, "CVE-2020-8174": {"epss_score": 0.01546, "epss_percentile": 0.80967}, "CVE-2020-8175": {"epss_score": 0.00679, "epss_percentile": 0.71024}, "CVE-2020-8176": {"epss_score": 0.00187, "epss_percentile": 0.40733}, "CVE-2020-8177": {"epss_score": 0.00021, "epss_percentile": 0.04698}, "CVE-2020-8178": {"epss_score": 0.05601, "epss_percentile": 0.9004}, "CVE-2020-8179": {"epss_score": 0.00135, "epss_percentile": 0.34011}, "CVE-2020-8180": {"epss_score": 0.00716, "epss_percentile": 0.71863}, "CVE-2020-8181": {"epss_score": 0.00219, "epss_percentile": 0.44447}, "CVE-2020-8182": {"epss_score": 0.0021, "epss_percentile": 0.43615}, "CVE-2020-8183": {"epss_score": 0.00399, "epss_percentile": 0.60104}, "CVE-2020-8184": {"epss_score": 0.01067, "epss_percentile": 0.7723}, "CVE-2020-8185": {"epss_score": 0.00679, "epss_percentile": 0.7101}, "CVE-2020-8186": {"epss_score": 0.01493, "epss_percentile": 0.80641}, "CVE-2020-8187": {"epss_score": 0.00623, "epss_percentile": 0.6955}, "CVE-2020-8188": {"epss_score": 0.00944, "epss_percentile": 0.75785}, "CVE-2020-8189": {"epss_score": 0.01008, "epss_percentile": 0.7657}, "CVE-2020-8190": {"epss_score": 0.00268, "epss_percentile": 0.50069}, "CVE-2020-8191": {"epss_score": 0.91575, "epss_percentile": 0.99653}, "CVE-2020-8192": {"epss_score": 0.00383, "epss_percentile": 0.5909}, "CVE-2020-8193": {"epss_score": 0.94177, "epss_percentile": 0.99913}, "CVE-2020-8194": {"epss_score": 0.81139, "epss_percentile": 0.99123}, "CVE-2020-8195": {"epss_score": 0.70871, "epss_percentile": 0.98645}, "CVE-2020-8196": {"epss_score": 0.70664, "epss_percentile": 0.98639}, "CVE-2020-8197": {"epss_score": 0.0071, "epss_percentile": 0.71712}, "CVE-2020-8198": {"epss_score": 0.0039, "epss_percentile": 0.59555}, "CVE-2020-8199": {"epss_score": 0.0013, "epss_percentile": 0.33269}, "CVE-2020-8200": {"epss_score": 0.00279, "epss_percentile": 0.50937}, "CVE-2020-8201": {"epss_score": 0.00501, "epss_percentile": 0.65335}, "CVE-2020-8202": {"epss_score": 0.00387, "epss_percentile": 0.59291}, "CVE-2020-8203": {"epss_score": 0.03419, "epss_percentile": 0.87096}, "CVE-2020-8204": {"epss_score": 0.00169, "epss_percentile": 0.38597}, "CVE-2020-8205": {"epss_score": 0.00267, "epss_percentile": 0.49958}, "CVE-2020-8206": {"epss_score": 0.0152, "epss_percentile": 0.80824}, "CVE-2020-8207": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2020-8208": {"epss_score": 0.0039, "epss_percentile": 0.59555}, "CVE-2020-8209": {"epss_score": 0.93007, "epss_percentile": 0.99767}, "CVE-2020-8210": {"epss_score": 0.00308, "epss_percentile": 0.53615}, "CVE-2020-8211": {"epss_score": 0.00525, "epss_percentile": 0.66373}, "CVE-2020-8212": {"epss_score": 0.00506, "epss_percentile": 0.65622}, "CVE-2020-8213": {"epss_score": 0.0039, "epss_percentile": 0.59543}, "CVE-2020-8214": {"epss_score": 0.00402, "epss_percentile": 0.60293}, "CVE-2020-8215": {"epss_score": 0.01867, "epss_percentile": 0.82619}, "CVE-2020-8216": {"epss_score": 0.02167, "epss_percentile": 0.83855}, "CVE-2020-8217": {"epss_score": 0.00136, "epss_percentile": 0.34138}, "CVE-2020-8218": {"epss_score": 0.92345, "epss_percentile": 0.9971}, "CVE-2020-8219": {"epss_score": 0.01732, "epss_percentile": 0.81997}, "CVE-2020-8220": {"epss_score": 0.06668, "epss_percentile": 0.9093}, "CVE-2020-8221": {"epss_score": 0.02858, "epss_percentile": 0.85845}, "CVE-2020-8222": {"epss_score": 0.0086, "epss_percentile": 0.74534}, "CVE-2020-8223": {"epss_score": 0.0027, "epss_percentile": 0.50246}, "CVE-2020-8224": {"epss_score": 0.00188, "epss_percentile": 0.40866}, "CVE-2020-8225": {"epss_score": 0.01301, "epss_percentile": 0.79291}, "CVE-2020-8226": {"epss_score": 0.00177, "epss_percentile": 0.39555}, "CVE-2020-8227": {"epss_score": 0.04677, "epss_percentile": 0.88997}, "CVE-2020-8228": {"epss_score": 0.00451, "epss_percentile": 0.63149}, "CVE-2020-8229": {"epss_score": 0.00077, "epss_percentile": 0.23523}, "CVE-2020-8230": {"epss_score": 0.00072, "epss_percentile": 0.22469}, "CVE-2020-8231": {"epss_score": 0.0012, "epss_percentile": 0.31784}, "CVE-2020-8232": {"epss_score": 0.00518, "epss_percentile": 0.66128}, "CVE-2020-8233": {"epss_score": 0.14944, "epss_percentile": 0.94331}, "CVE-2020-8234": {"epss_score": 0.018, "epss_percentile": 0.82318}, "CVE-2020-8235": {"epss_score": 0.00135, "epss_percentile": 0.34035}, "CVE-2020-8236": {"epss_score": 0.00081, "epss_percentile": 0.24394}, "CVE-2020-8237": {"epss_score": 0.00474, "epss_percentile": 0.64151}, "CVE-2020-8238": {"epss_score": 0.00131, "epss_percentile": 0.33343}, "CVE-2020-8239": {"epss_score": 0.00433, "epss_percentile": 0.62176}, "CVE-2020-8240": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2020-8241": {"epss_score": 0.035, "epss_percentile": 0.87245}, "CVE-2020-8242": {"epss_score": 0.00323, "epss_percentile": 0.54885}, "CVE-2020-8243": {"epss_score": 0.21988, "epss_percentile": 0.95582}, "CVE-2020-8244": {"epss_score": 0.00368, "epss_percentile": 0.58221}, "CVE-2020-8245": {"epss_score": 0.0039, "epss_percentile": 0.59555}, "CVE-2020-8246": {"epss_score": 0.00506, "epss_percentile": 0.65645}, "CVE-2020-8247": {"epss_score": 0.00355, "epss_percentile": 0.57263}, "CVE-2020-8248": {"epss_score": 0.00406, "epss_percentile": 0.60547}, "CVE-2020-8249": {"epss_score": 0.00651, "epss_percentile": 0.70285}, "CVE-2020-8250": {"epss_score": 0.0035, "epss_percentile": 0.5694}, "CVE-2020-8251": {"epss_score": 0.03055, "epss_percentile": 0.86299}, "CVE-2020-8252": {"epss_score": 0.00198, "epss_percentile": 0.42012}, "CVE-2020-8253": {"epss_score": 0.0028, "epss_percentile": 0.51034}, "CVE-2020-8254": {"epss_score": 0.02435, "epss_percentile": 0.84737}, "CVE-2020-8255": {"epss_score": 0.13488, "epss_percentile": 0.93979}, "CVE-2020-8256": {"epss_score": 0.03911, "epss_percentile": 0.87934}, "CVE-2020-8257": {"epss_score": 0.00431, "epss_percentile": 0.6205}, "CVE-2020-8258": {"epss_score": 0.00218, "epss_percentile": 0.44411}, "CVE-2020-8259": {"epss_score": 0.00081, "epss_percentile": 0.24267}, "CVE-2020-8260": {"epss_score": 0.75303, "epss_percentile": 0.98836}, "CVE-2020-8261": {"epss_score": 0.00613, "epss_percentile": 0.69253}, "CVE-2020-8262": {"epss_score": 0.00144, "epss_percentile": 0.35323}, "CVE-2020-8263": {"epss_score": 0.00347, "epss_percentile": 0.56764}, "CVE-2020-8264": {"epss_score": 0.00346, "epss_percentile": 0.56651}, "CVE-2020-8265": {"epss_score": 0.01024, "epss_percentile": 0.76775}, "CVE-2020-8267": {"epss_score": 0.00278, "epss_percentile": 0.50887}, "CVE-2020-8268": {"epss_score": 0.00175, "epss_percentile": 0.39326}, "CVE-2020-8269": {"epss_score": 0.00369, "epss_percentile": 0.58225}, "CVE-2020-8270": {"epss_score": 0.00849, "epss_percentile": 0.7438}, "CVE-2020-8271": {"epss_score": 0.39296, "epss_percentile": 0.97152}, "CVE-2020-8272": {"epss_score": 0.0023, "epss_percentile": 0.45735}, "CVE-2020-8273": {"epss_score": 0.01609, "epss_percentile": 0.81318}, "CVE-2020-8274": {"epss_score": 0.01036, "epss_percentile": 0.76918}, "CVE-2020-8275": {"epss_score": 0.0037, "epss_percentile": 0.58335}, "CVE-2020-8276": {"epss_score": 0.0003, "epss_percentile": 0.08079}, "CVE-2020-8277": {"epss_score": 0.59168, "epss_percentile": 0.98152}, "CVE-2020-8278": {"epss_score": 0.00206, "epss_percentile": 0.43054}, "CVE-2020-8279": {"epss_score": 0.00109, "epss_percentile": 0.29987}, "CVE-2020-8280": {"epss_score": 0.00217, "epss_percentile": 0.44259}, "CVE-2020-8281": {"epss_score": 0.00217, "epss_percentile": 0.44259}, "CVE-2020-8282": {"epss_score": 0.00382, "epss_percentile": 0.59046}, "CVE-2020-8283": {"epss_score": 0.00369, "epss_percentile": 0.58225}, "CVE-2020-8284": {"epss_score": 0.00104, "epss_percentile": 0.29133}, "CVE-2020-8285": {"epss_score": 0.00742, "epss_percentile": 0.72458}, "CVE-2020-8286": {"epss_score": 0.00384, "epss_percentile": 0.59162}, "CVE-2020-8287": {"epss_score": 0.11865, "epss_percentile": 0.93499}, "CVE-2020-8288": {"epss_score": 0.00498, "epss_percentile": 0.65214}, "CVE-2020-8289": {"epss_score": 0.20543, "epss_percentile": 0.95375}, "CVE-2020-8290": {"epss_score": 0.00108, "epss_percentile": 0.29859}, "CVE-2020-8291": {"epss_score": 0.0023, "epss_percentile": 0.45672}, "CVE-2020-8292": {"epss_score": 0.00322, "epss_percentile": 0.54799}, "CVE-2020-8293": {"epss_score": 0.00625, "epss_percentile": 0.6958}, "CVE-2020-8294": {"epss_score": 0.00391, "epss_percentile": 0.59566}, "CVE-2020-8295": {"epss_score": 0.00508, "epss_percentile": 0.65702}, "CVE-2020-8296": {"epss_score": 0.00626, "epss_percentile": 0.69603}, "CVE-2020-8297": {"epss_score": 0.00233, "epss_percentile": 0.46035}, "CVE-2020-8298": {"epss_score": 0.04178, "epss_percentile": 0.88354}, "CVE-2020-8299": {"epss_score": 0.00246, "epss_percentile": 0.47743}, "CVE-2020-8300": {"epss_score": 0.13884, "epss_percentile": 0.94085}, "CVE-2020-8315": {"epss_score": 0.00322, "epss_percentile": 0.54828}, "CVE-2020-8316": {"epss_score": 0.00094, "epss_percentile": 0.26797}, "CVE-2020-8317": {"epss_score": 0.00143, "epss_percentile": 0.35199}, "CVE-2020-8318": {"epss_score": 0.00122, "epss_percentile": 0.3203}, "CVE-2020-8319": {"epss_score": 0.00122, "epss_percentile": 0.3203}, "CVE-2020-8320": {"epss_score": 0.00047, "epss_percentile": 0.1464}, "CVE-2020-8321": {"epss_score": 0.00137, "epss_percentile": 0.34246}, "CVE-2020-8322": {"epss_score": 0.0005, "epss_percentile": 0.15945}, "CVE-2020-8323": {"epss_score": 0.0005, "epss_percentile": 0.15945}, "CVE-2020-8324": {"epss_score": 0.00062, "epss_percentile": 0.19637}, "CVE-2020-8326": {"epss_score": 0.00128, "epss_percentile": 0.33036}, "CVE-2020-8327": {"epss_score": 0.00104, "epss_percentile": 0.29205}, "CVE-2020-8329": {"epss_score": 0.00241, "epss_percentile": 0.47259}, "CVE-2020-8330": {"epss_score": 0.00241, "epss_percentile": 0.47259}, "CVE-2020-8332": {"epss_score": 0.00035, "epss_percentile": 0.09899}, "CVE-2020-8333": {"epss_score": 0.00038, "epss_percentile": 0.11179}, "CVE-2020-8334": {"epss_score": 0.00062, "epss_percentile": 0.1979}, "CVE-2020-8335": {"epss_score": 0.00072, "epss_percentile": 0.22422}, "CVE-2020-8336": {"epss_score": 0.00052, "epss_percentile": 0.16625}, "CVE-2020-8337": {"epss_score": 0.00046, "epss_percentile": 0.1418}, "CVE-2020-8338": {"epss_score": 0.00051, "epss_percentile": 0.16282}, "CVE-2020-8339": {"epss_score": 0.00289, "epss_percentile": 0.52053}, "CVE-2020-8340": {"epss_score": 0.00245, "epss_percentile": 0.47659}, "CVE-2020-8341": {"epss_score": 0.00058, "epss_percentile": 0.18434}, "CVE-2020-8342": {"epss_score": 0.00034, "epss_percentile": 0.0975}, "CVE-2020-8345": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2020-8346": {"epss_score": 0.00038, "epss_percentile": 0.11204}, "CVE-2020-8347": {"epss_score": 0.00698, "epss_percentile": 0.71424}, "CVE-2020-8348": {"epss_score": 0.00474, "epss_percentile": 0.64157}, "CVE-2020-8349": {"epss_score": 0.02622, "epss_percentile": 0.85256}, "CVE-2020-8350": {"epss_score": 0.00122, "epss_percentile": 0.32019}, "CVE-2020-8351": {"epss_score": 0.00055, "epss_percentile": 0.17532}, "CVE-2020-8352": {"epss_score": 0.00058, "epss_percentile": 0.18434}, "CVE-2020-8353": {"epss_score": 0.00049, "epss_percentile": 0.15614}, "CVE-2020-8354": {"epss_score": 0.00033, "epss_percentile": 0.09139}, "CVE-2020-8355": {"epss_score": 0.00111, "epss_percentile": 0.30381}, "CVE-2020-8356": {"epss_score": 0.00171, "epss_percentile": 0.38888}, "CVE-2020-8357": {"epss_score": 0.00043, "epss_percentile": 0.13225}, "CVE-2020-8416": {"epss_score": 0.16366, "epss_percentile": 0.94636}, "CVE-2020-8417": {"epss_score": 0.50314, "epss_percentile": 0.97731}, "CVE-2020-8419": {"epss_score": 6e-05, "epss_percentile": 0.00288}, "CVE-2020-8420": {"epss_score": 0.00037, "epss_percentile": 0.10682}, "CVE-2020-8421": {"epss_score": 0.01258, "epss_percentile": 0.78956}, "CVE-2020-8422": {"epss_score": 0.00266, "epss_percentile": 0.49872}, "CVE-2020-8423": {"epss_score": 0.30167, "epss_percentile": 0.96515}, "CVE-2020-8424": {"epss_score": 0.003, "epss_percentile": 0.52989}, "CVE-2020-8425": {"epss_score": 0.00306, "epss_percentile": 0.53453}, "CVE-2020-8426": {"epss_score": 0.0045, "epss_percentile": 0.63065}, "CVE-2020-8427": {"epss_score": 0.00351, "epss_percentile": 0.57009}, "CVE-2020-8428": {"epss_score": 0.00102, "epss_percentile": 0.28878}, "CVE-2020-8429": {"epss_score": 0.00451, "epss_percentile": 0.63141}, "CVE-2020-8430": {"epss_score": 0.0025, "epss_percentile": 0.48125}, "CVE-2020-8432": {"epss_score": 0.01959, "epss_percentile": 0.83052}, "CVE-2020-8434": {"epss_score": 0.00277, "epss_percentile": 0.50826}, "CVE-2020-8435": {"epss_score": 0.00864, "epss_percentile": 0.74613}, "CVE-2020-8436": {"epss_score": 0.00326, "epss_percentile": 0.55046}, "CVE-2020-8437": {"epss_score": 0.20726, "epss_percentile": 0.95406}, "CVE-2020-8438": {"epss_score": 0.0108, "epss_percentile": 0.77367}, "CVE-2020-8439": {"epss_score": 0.00649, "epss_percentile": 0.70236}, "CVE-2020-8440": {"epss_score": 0.03282, "epss_percentile": 0.8682}, "CVE-2020-8441": {"epss_score": 0.0758, "epss_percentile": 0.91553}, "CVE-2020-8442": {"epss_score": 0.00767, "epss_percentile": 0.72952}, "CVE-2020-8443": {"epss_score": 0.00756, "epss_percentile": 0.7274}, "CVE-2020-8444": {"epss_score": 0.00854, "epss_percentile": 0.74455}, "CVE-2020-8445": {"epss_score": 0.00988, "epss_percentile": 0.76356}, "CVE-2020-8446": {"epss_score": 0.00185, "epss_percentile": 0.40508}, "CVE-2020-8447": {"epss_score": 0.00854, "epss_percentile": 0.74455}, "CVE-2020-8448": {"epss_score": 0.00143, "epss_percentile": 0.35166}, "CVE-2020-8449": {"epss_score": 0.03294, "epss_percentile": 0.86845}, "CVE-2020-8450": {"epss_score": 0.46287, "epss_percentile": 0.9754}, "CVE-2020-8461": {"epss_score": 0.00231, "epss_percentile": 0.45769}, "CVE-2020-8462": {"epss_score": 0.0047, "epss_percentile": 0.63987}, "CVE-2020-8463": {"epss_score": 0.00561, "epss_percentile": 0.67674}, "CVE-2020-8464": {"epss_score": 0.00644, "epss_percentile": 0.70087}, "CVE-2020-8465": {"epss_score": 0.00178, "epss_percentile": 0.39709}, "CVE-2020-8466": {"epss_score": 0.27274, "epss_percentile": 0.9623}, "CVE-2020-8467": {"epss_score": 0.30162, "epss_percentile": 0.96515}, "CVE-2020-8468": {"epss_score": 0.18378, "epss_percentile": 0.95008}, "CVE-2020-8469": {"epss_score": 0.00178, "epss_percentile": 0.39692}, "CVE-2020-8470": {"epss_score": 0.01122, "epss_percentile": 0.77779}, "CVE-2020-8471": {"epss_score": 0.00145, "epss_percentile": 0.35458}, "CVE-2020-8472": {"epss_score": 0.00025, "epss_percentile": 0.06321}, "CVE-2020-8473": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2020-8474": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2020-8475": {"epss_score": 0.00341, "epss_percentile": 0.56307}, "CVE-2020-8476": {"epss_score": 0.00379, "epss_percentile": 0.58846}, "CVE-2020-8477": {"epss_score": 0.00465, "epss_percentile": 0.63772}, "CVE-2020-8478": {"epss_score": 0.00051, "epss_percentile": 0.16128}, "CVE-2020-8479": {"epss_score": 0.00487, "epss_percentile": 0.64811}, "CVE-2020-8481": {"epss_score": 0.00478, "epss_percentile": 0.64391}, "CVE-2020-8482": {"epss_score": 0.00069, "epss_percentile": 0.21525}, "CVE-2020-8484": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2020-8485": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2020-8486": {"epss_score": 0.00131, "epss_percentile": 0.33411}, "CVE-2020-8487": {"epss_score": 0.00131, "epss_percentile": 0.33411}, "CVE-2020-8488": {"epss_score": 0.00132, "epss_percentile": 0.33538}, "CVE-2020-8489": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2020-8492": {"epss_score": 0.03512, "epss_percentile": 0.87269}, "CVE-2020-8493": {"epss_score": 0.01249, "epss_percentile": 0.78875}, "CVE-2020-8494": {"epss_score": 0.00525, "epss_percentile": 0.66386}, "CVE-2020-8495": {"epss_score": 0.04966, "epss_percentile": 0.89343}, "CVE-2020-8496": {"epss_score": 0.003, "epss_percentile": 0.52989}, "CVE-2020-8497": {"epss_score": 0.34655, "epss_percentile": 0.96863}, "CVE-2020-8498": {"epss_score": 0.00473, "epss_percentile": 0.64085}, "CVE-2020-8500": {"epss_score": 0.0114, "epss_percentile": 0.77948}, "CVE-2020-8503": {"epss_score": 0.00267, "epss_percentile": 0.4998}, "CVE-2020-8504": {"epss_score": 0.00386, "epss_percentile": 0.59246}, "CVE-2020-8505": {"epss_score": 0.00386, "epss_percentile": 0.59246}, "CVE-2020-8506": {"epss_score": 0.00207, "epss_percentile": 0.43206}, "CVE-2020-8507": {"epss_score": 0.00218, "epss_percentile": 0.44347}, "CVE-2020-8508": {"epss_score": 0.00873, "epss_percentile": 0.7474}, "CVE-2020-8509": {"epss_score": 0.11968, "epss_percentile": 0.93528}, "CVE-2020-8510": {"epss_score": 0.0035, "epss_percentile": 0.56975}, "CVE-2020-8511": {"epss_score": 0.00598, "epss_percentile": 0.68757}, "CVE-2020-8512": {"epss_score": 0.36838, "epss_percentile": 0.97003}, "CVE-2020-8514": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2020-8515": {"epss_score": 0.94357, "epss_percentile": 0.99958}, "CVE-2020-8516": {"epss_score": 0.0078, "epss_percentile": 0.7317}, "CVE-2020-8517": {"epss_score": 0.00828, "epss_percentile": 0.73999}, "CVE-2020-8518": {"epss_score": 0.84857, "epss_percentile": 0.99308}, "CVE-2020-8519": {"epss_score": 0.00598, "epss_percentile": 0.68765}, "CVE-2020-8520": {"epss_score": 0.00598, "epss_percentile": 0.68765}, "CVE-2020-8521": {"epss_score": 0.00598, "epss_percentile": 0.68765}, "CVE-2020-8539": {"epss_score": 0.05758, "epss_percentile": 0.90182}, "CVE-2020-8540": {"epss_score": 0.24116, "epss_percentile": 0.95877}, "CVE-2020-8541": {"epss_score": 0.00207, "epss_percentile": 0.43135}, "CVE-2020-8542": {"epss_score": 0.00686, "epss_percentile": 0.71165}, "CVE-2020-8543": {"epss_score": 0.00361, "epss_percentile": 0.57701}, "CVE-2020-8544": {"epss_score": 0.00207, "epss_percentile": 0.43135}, "CVE-2020-8545": {"epss_score": 0.00469, "epss_percentile": 0.63919}, "CVE-2020-8547": {"epss_score": 0.03293, "epss_percentile": 0.86842}, "CVE-2020-8548": {"epss_score": 0.00819, "epss_percentile": 0.73864}, "CVE-2020-8549": {"epss_score": 0.00564, "epss_percentile": 0.67743}, "CVE-2020-8551": {"epss_score": 0.00627, "epss_percentile": 0.69628}, "CVE-2020-8552": {"epss_score": 0.001, "epss_percentile": 0.28445}, "CVE-2020-8553": {"epss_score": 0.00523, "epss_percentile": 0.66293}, "CVE-2020-8554": {"epss_score": 0.24784, "epss_percentile": 0.95954}, "CVE-2020-8555": {"epss_score": 0.0861, "epss_percentile": 0.9215}, "CVE-2020-8557": {"epss_score": 0.00114, "epss_percentile": 0.30785}, "CVE-2020-8558": {"epss_score": 0.25153, "epss_percentile": 0.95991}, "CVE-2020-8559": {"epss_score": 0.60105, "epss_percentile": 0.98192}, "CVE-2020-8561": {"epss_score": 0.00237, "epss_percentile": 0.46667}, "CVE-2020-8562": {"epss_score": 0.00048, "epss_percentile": 0.15238}, "CVE-2020-8563": {"epss_score": 0.00075, "epss_percentile": 0.23023}, "CVE-2020-8564": {"epss_score": 0.00054, "epss_percentile": 0.17348}, "CVE-2020-8565": {"epss_score": 0.0006, "epss_percentile": 0.19242}, "CVE-2020-8566": {"epss_score": 0.00091, "epss_percentile": 0.26272}, "CVE-2020-8567": {"epss_score": 0.00155, "epss_percentile": 0.36792}, "CVE-2020-8568": {"epss_score": 0.00449, "epss_percentile": 0.63048}, "CVE-2020-8569": {"epss_score": 0.00349, "epss_percentile": 0.56855}, "CVE-2020-8570": {"epss_score": 0.01085, "epss_percentile": 0.77406}, "CVE-2020-8571": {"epss_score": 0.0095, "epss_percentile": 0.75857}, "CVE-2020-8572": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-8573": {"epss_score": 0.00428, "epss_percentile": 0.61931}, "CVE-2020-8574": {"epss_score": 0.00159, "epss_percentile": 0.37335}, "CVE-2020-8575": {"epss_score": 0.00057, "epss_percentile": 0.18023}, "CVE-2020-8576": {"epss_score": 0.0022, "epss_percentile": 0.44554}, "CVE-2020-8577": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-8578": {"epss_score": 0.00065, "epss_percentile": 0.20507}, "CVE-2020-8579": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-8580": {"epss_score": 0.0055, "epss_percentile": 0.67347}, "CVE-2020-8581": {"epss_score": 0.00232, "epss_percentile": 0.45879}, "CVE-2020-8582": {"epss_score": 0.00328, "epss_percentile": 0.55177}, "CVE-2020-8583": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2020-8584": {"epss_score": 0.06405, "epss_percentile": 0.90732}, "CVE-2020-8585": {"epss_score": 0.00139, "epss_percentile": 0.34619}, "CVE-2020-8587": {"epss_score": 0.0018, "epss_percentile": 0.3991}, "CVE-2020-8588": {"epss_score": 0.00086, "epss_percentile": 0.25329}, "CVE-2020-8589": {"epss_score": 0.00086, "epss_percentile": 0.25329}, "CVE-2020-8590": {"epss_score": 0.00065, "epss_percentile": 0.20507}, "CVE-2020-8591": {"epss_score": 0.00137, "epss_percentile": 0.3431}, "CVE-2020-8592": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2020-8594": {"epss_score": 0.00857, "epss_percentile": 0.74498}, "CVE-2020-8595": {"epss_score": 0.0106, "epss_percentile": 0.77163}, "CVE-2020-8596": {"epss_score": 0.01311, "epss_percentile": 0.79365}, "CVE-2020-8597": {"epss_score": 0.63737, "epss_percentile": 0.98346}, "CVE-2020-8598": {"epss_score": 0.08463, "epss_percentile": 0.92065}, "CVE-2020-8599": {"epss_score": 0.5786, "epss_percentile": 0.98087}, "CVE-2020-8600": {"epss_score": 0.01113, "epss_percentile": 0.77688}, "CVE-2020-8601": {"epss_score": 0.00208, "epss_percentile": 0.43218}, "CVE-2020-8602": {"epss_score": 0.01683, "epss_percentile": 0.81737}, "CVE-2020-8603": {"epss_score": 0.00391, "epss_percentile": 0.5957}, "CVE-2020-8604": {"epss_score": 0.8286, "epss_percentile": 0.9922}, "CVE-2020-8605": {"epss_score": 0.88697, "epss_percentile": 0.99484}, "CVE-2020-8606": {"epss_score": 0.88833, "epss_percentile": 0.99493}, "CVE-2020-8607": {"epss_score": 0.00082, "epss_percentile": 0.24509}, "CVE-2020-8608": {"epss_score": 0.01501, "epss_percentile": 0.80721}, "CVE-2020-8611": {"epss_score": 0.00101, "epss_percentile": 0.28706}, "CVE-2020-8612": {"epss_score": 0.00028, "epss_percentile": 0.07265}, "CVE-2020-8614": {"epss_score": 0.01064, "epss_percentile": 0.77196}, "CVE-2020-8615": {"epss_score": 0.06895, "epss_percentile": 0.91099}, "CVE-2020-8616": {"epss_score": 0.19877, "epss_percentile": 0.95254}, "CVE-2020-8617": {"epss_score": 0.89736, "epss_percentile": 0.9954}, "CVE-2020-8618": {"epss_score": 0.01297, "epss_percentile": 0.79262}, "CVE-2020-8619": {"epss_score": 0.06931, "epss_percentile": 0.91123}, "CVE-2020-8620": {"epss_score": 0.07292, "epss_percentile": 0.91387}, "CVE-2020-8621": {"epss_score": 0.04224, "epss_percentile": 0.88414}, "CVE-2020-8622": {"epss_score": 0.00673, "epss_percentile": 0.70831}, "CVE-2020-8623": {"epss_score": 0.18125, "epss_percentile": 0.9496}, "CVE-2020-8624": {"epss_score": 0.01687, "epss_percentile": 0.81757}, "CVE-2020-8625": {"epss_score": 0.01645, "epss_percentile": 0.81531}, "CVE-2020-8631": {"epss_score": 0.00156, "epss_percentile": 0.36904}, "CVE-2020-8632": {"epss_score": 0.00139, "epss_percentile": 0.34546}, "CVE-2020-8633": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2020-8634": {"epss_score": 0.00086, "epss_percentile": 0.25279}, "CVE-2020-8635": {"epss_score": 0.03646, "epss_percentile": 0.875}, "CVE-2020-8636": {"epss_score": 0.04749, "epss_percentile": 0.89102}, "CVE-2020-8637": {"epss_score": 0.11163, "epss_percentile": 0.9325}, "CVE-2020-8638": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2020-8639": {"epss_score": 0.10077, "epss_percentile": 0.9284}, "CVE-2020-8641": {"epss_score": 0.72611, "epss_percentile": 0.98719}, "CVE-2020-8644": {"epss_score": 0.92716, "epss_percentile": 0.99738}, "CVE-2020-8645": {"epss_score": 0.00448, "epss_percentile": 0.63014}, "CVE-2020-8647": {"epss_score": 0.00076, "epss_percentile": 0.23258}, "CVE-2020-8648": {"epss_score": 0.00036, "epss_percentile": 0.10514}, "CVE-2020-8649": {"epss_score": 0.00094, "epss_percentile": 0.26975}, "CVE-2020-8654": {"epss_score": 0.91205, "epss_percentile": 0.99627}, "CVE-2020-8655": {"epss_score": 0.81328, "epss_percentile": 0.99132}, "CVE-2020-8656": {"epss_score": 0.77688, "epss_percentile": 0.98948}, "CVE-2020-8657": {"epss_score": 0.86393, "epss_percentile": 0.9938}, "CVE-2020-8658": {"epss_score": 0.02152, "epss_percentile": 0.83792}, "CVE-2020-8659": {"epss_score": 0.01019, "epss_percentile": 0.7673}, "CVE-2020-8660": {"epss_score": 0.00025, "epss_percentile": 0.0634}, "CVE-2020-8661": {"epss_score": 0.00571, "epss_percentile": 0.67978}, "CVE-2020-8663": {"epss_score": 0.00105, "epss_percentile": 0.29296}, "CVE-2020-8664": {"epss_score": 0.00403, "epss_percentile": 0.60352}, "CVE-2020-8669": {"epss_score": 0.00328, "epss_percentile": 0.55177}, "CVE-2020-8670": {"epss_score": 0.00053, "epss_percentile": 0.16792}, "CVE-2020-8671": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-8672": {"epss_score": 0.00067, "epss_percentile": 0.21106}, "CVE-2020-8674": {"epss_score": 0.01249, "epss_percentile": 0.7887}, "CVE-2020-8675": {"epss_score": 0.00098, "epss_percentile": 0.27794}, "CVE-2020-8676": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2020-8677": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2020-8678": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-8679": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-8680": {"epss_score": 0.00045, "epss_percentile": 0.13706}, "CVE-2020-8681": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-8682": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-8683": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-8684": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2020-8685": {"epss_score": 0.0006, "epss_percentile": 0.19062}, "CVE-2020-8687": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2020-8688": {"epss_score": 0.00381, "epss_percentile": 0.59023}, "CVE-2020-8689": {"epss_score": 0.00277, "epss_percentile": 0.508}, "CVE-2020-8690": {"epss_score": 0.00059, "epss_percentile": 0.18729}, "CVE-2020-8691": {"epss_score": 0.00059, "epss_percentile": 0.18729}, "CVE-2020-8692": {"epss_score": 0.00052, "epss_percentile": 0.16512}, "CVE-2020-8693": {"epss_score": 0.00059, "epss_percentile": 0.18729}, "CVE-2020-8694": {"epss_score": 0.00875, "epss_percentile": 0.74774}, "CVE-2020-8695": {"epss_score": 0.00144, "epss_percentile": 0.3528}, "CVE-2020-8696": {"epss_score": 0.00261, "epss_percentile": 0.49291}, "CVE-2020-8698": {"epss_score": 0.00266, "epss_percentile": 0.49903}, "CVE-2020-8700": {"epss_score": 0.00235, "epss_percentile": 0.4631}, "CVE-2020-8701": {"epss_score": 0.0004, "epss_percentile": 0.1191}, "CVE-2020-8702": {"epss_score": 0.00097, "epss_percentile": 0.27595}, "CVE-2020-8703": {"epss_score": 0.00259, "epss_percentile": 0.49058}, "CVE-2020-8704": {"epss_score": 0.00116, "epss_percentile": 0.31178}, "CVE-2020-8705": {"epss_score": 0.00724, "epss_percentile": 0.72033}, "CVE-2020-8706": {"epss_score": 0.00168, "epss_percentile": 0.38471}, "CVE-2020-8707": {"epss_score": 0.00168, "epss_percentile": 0.38471}, "CVE-2020-8708": {"epss_score": 0.00211, "epss_percentile": 0.43634}, "CVE-2020-8709": {"epss_score": 0.00211, "epss_percentile": 0.43634}, "CVE-2020-8710": {"epss_score": 0.0008, "epss_percentile": 0.24021}, "CVE-2020-8711": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2020-8712": {"epss_score": 0.00073, "epss_percentile": 0.22527}, "CVE-2020-8713": {"epss_score": 0.00211, "epss_percentile": 0.43634}, "CVE-2020-8714": {"epss_score": 0.00058, "epss_percentile": 0.18368}, "CVE-2020-8715": {"epss_score": 0.00063, "epss_percentile": 0.19849}, "CVE-2020-8716": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-8717": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-8718": {"epss_score": 0.00073, "epss_percentile": 0.22527}, "CVE-2020-8719": {"epss_score": 0.0008, "epss_percentile": 0.24021}, "CVE-2020-8720": {"epss_score": 0.00059, "epss_percentile": 0.18688}, "CVE-2020-8721": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2020-8722": {"epss_score": 0.0008, "epss_percentile": 0.24021}, "CVE-2020-8723": {"epss_score": 0.0028, "epss_percentile": 0.51018}, "CVE-2020-8729": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-8730": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-8731": {"epss_score": 0.0004, "epss_percentile": 0.12072}, "CVE-2020-8732": {"epss_score": 0.00168, "epss_percentile": 0.38471}, "CVE-2020-8733": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2020-8734": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2020-8736": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2020-8737": {"epss_score": 0.00246, "epss_percentile": 0.47736}, "CVE-2020-8738": {"epss_score": 0.00216, "epss_percentile": 0.44232}, "CVE-2020-8739": {"epss_score": 0.00224, "epss_percentile": 0.45052}, "CVE-2020-8740": {"epss_score": 0.00216, "epss_percentile": 0.44232}, "CVE-2020-8741": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-8742": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2020-8743": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-8744": {"epss_score": 0.0016, "epss_percentile": 0.37505}, "CVE-2020-8745": {"epss_score": 0.00645, "epss_percentile": 0.70117}, "CVE-2020-8746": {"epss_score": 0.00213, "epss_percentile": 0.43831}, "CVE-2020-8747": {"epss_score": 0.00804, "epss_percentile": 0.73612}, "CVE-2020-8749": {"epss_score": 0.00536, "epss_percentile": 0.66857}, "CVE-2020-8750": {"epss_score": 0.00059, "epss_percentile": 0.18875}, "CVE-2020-8751": {"epss_score": 0.00078, "epss_percentile": 0.23748}, "CVE-2020-8752": {"epss_score": 0.00858, "epss_percentile": 0.745}, "CVE-2020-8753": {"epss_score": 0.00964, "epss_percentile": 0.76038}, "CVE-2020-8754": {"epss_score": 0.00964, "epss_percentile": 0.76038}, "CVE-2020-8755": {"epss_score": 0.00067, "epss_percentile": 0.21078}, "CVE-2020-8756": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2020-8757": {"epss_score": 0.00136, "epss_percentile": 0.34062}, "CVE-2020-8758": {"epss_score": 0.01309, "epss_percentile": 0.79355}, "CVE-2020-8759": {"epss_score": 0.00061, "epss_percentile": 0.19474}, "CVE-2020-8760": {"epss_score": 0.00124, "epss_percentile": 0.32389}, "CVE-2020-8761": {"epss_score": 0.00102, "epss_percentile": 0.28855}, "CVE-2020-8763": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2020-8764": {"epss_score": 0.00136, "epss_percentile": 0.34062}, "CVE-2020-8765": {"epss_score": 0.00036, "epss_percentile": 0.10235}, "CVE-2020-8766": {"epss_score": 0.00236, "epss_percentile": 0.46373}, "CVE-2020-8767": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2020-8768": {"epss_score": 0.00308, "epss_percentile": 0.53576}, "CVE-2020-8771": {"epss_score": 0.81044, "epss_percentile": 0.99117}, "CVE-2020-8772": {"epss_score": 0.93091, "epss_percentile": 0.99775}, "CVE-2020-8773": {"epss_score": 0.00535, "epss_percentile": 0.66843}, "CVE-2020-8774": {"epss_score": 0.00528, "epss_percentile": 0.66553}, "CVE-2020-8775": {"epss_score": 0.00535, "epss_percentile": 0.66843}, "CVE-2020-8776": {"epss_score": 0.00981, "epss_percentile": 0.76285}, "CVE-2020-8777": {"epss_score": 0.01588, "epss_percentile": 0.81186}, "CVE-2020-8778": {"epss_score": 0.0202, "epss_percentile": 0.83293}, "CVE-2020-8781": {"epss_score": 4e-05, "epss_percentile": 0.00132}, "CVE-2020-8782": {"epss_score": 0.08427, "epss_percentile": 0.92045}, "CVE-2020-8783": {"epss_score": 0.00435, "epss_percentile": 0.62371}, "CVE-2020-8784": {"epss_score": 0.00435, "epss_percentile": 0.62371}, "CVE-2020-8785": {"epss_score": 0.00435, "epss_percentile": 0.62371}, "CVE-2020-8786": {"epss_score": 0.00435, "epss_percentile": 0.62371}, "CVE-2020-8787": {"epss_score": 0.0021, "epss_percentile": 0.43478}, "CVE-2020-8788": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2020-8789": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-8790": {"epss_score": 0.01043, "epss_percentile": 0.76996}, "CVE-2020-8791": {"epss_score": 0.00333, "epss_percentile": 0.55654}, "CVE-2020-8792": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2020-8793": {"epss_score": 0.00786, "epss_percentile": 0.73291}, "CVE-2020-8794": {"epss_score": 0.88136, "epss_percentile": 0.99459}, "CVE-2020-8795": {"epss_score": 0.00077, "epss_percentile": 0.23384}, "CVE-2020-8796": {"epss_score": 0.03293, "epss_percentile": 0.8684}, "CVE-2020-8797": {"epss_score": 0.00668, "epss_percentile": 0.70723}, "CVE-2020-8798": {"epss_score": 0.0018, "epss_percentile": 0.39931}, "CVE-2020-8799": {"epss_score": 0.00186, "epss_percentile": 0.406}, "CVE-2020-8800": {"epss_score": 0.00488, "epss_percentile": 0.64862}, "CVE-2020-8801": {"epss_score": 0.00476, "epss_percentile": 0.64275}, "CVE-2020-8802": {"epss_score": 0.005, "epss_percentile": 0.65328}, "CVE-2020-8803": {"epss_score": 0.0096, "epss_percentile": 0.75962}, "CVE-2020-8804": {"epss_score": 0.00354, "epss_percentile": 0.57257}, "CVE-2020-8806": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2020-8807": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2020-8808": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2020-8809": {"epss_score": 0.00222, "epss_percentile": 0.44807}, "CVE-2020-8810": {"epss_score": 0.00678, "epss_percentile": 0.71}, "CVE-2020-8811": {"epss_score": 0.00354, "epss_percentile": 0.57247}, "CVE-2020-8812": {"epss_score": 0.0027, "epss_percentile": 0.5027}, "CVE-2020-8813": {"epss_score": 0.94119, "epss_percentile": 0.99905}, "CVE-2020-8815": {"epss_score": 0.01692, "epss_percentile": 0.81791}, "CVE-2020-8816": {"epss_score": 0.90775, "epss_percentile": 0.99599}, "CVE-2020-8817": {"epss_score": 0.00317, "epss_percentile": 0.54384}, "CVE-2020-8818": {"epss_score": 0.00178, "epss_percentile": 0.39706}, "CVE-2020-8819": {"epss_score": 0.00274, "epss_percentile": 0.50529}, "CVE-2020-8820": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-8821": {"epss_score": 0.02482, "epss_percentile": 0.84876}, "CVE-2020-8822": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2020-8823": {"epss_score": 0.00757, "epss_percentile": 0.72761}, "CVE-2020-8824": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-8825": {"epss_score": 0.00642, "epss_percentile": 0.70024}, "CVE-2020-8826": {"epss_score": 0.00468, "epss_percentile": 0.63911}, "CVE-2020-8827": {"epss_score": 0.00714, "epss_percentile": 0.71814}, "CVE-2020-8828": {"epss_score": 0.00429, "epss_percentile": 0.61988}, "CVE-2020-8829": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2020-8830": {"epss_score": 0.00126, "epss_percentile": 0.32769}, "CVE-2020-8831": {"epss_score": 0.00117, "epss_percentile": 0.31222}, "CVE-2020-8832": {"epss_score": 0.00312, "epss_percentile": 0.54005}, "CVE-2020-8833": {"epss_score": 0.00034, "epss_percentile": 0.09673}, "CVE-2020-8834": {"epss_score": 0.0009, "epss_percentile": 0.26152}, "CVE-2020-8835": {"epss_score": 0.25092, "epss_percentile": 0.95984}, "CVE-2020-8838": {"epss_score": 0.00328, "epss_percentile": 0.55156}, "CVE-2020-8839": {"epss_score": 0.00851, "epss_percentile": 0.74411}, "CVE-2020-8840": {"epss_score": 0.08164, "epss_percentile": 0.91911}, "CVE-2020-8841": {"epss_score": 0.00567, "epss_percentile": 0.67836}, "CVE-2020-8843": {"epss_score": 0.00214, "epss_percentile": 0.43985}, "CVE-2020-8844": {"epss_score": 0.24154, "epss_percentile": 0.9588}, "CVE-2020-8845": {"epss_score": 0.1639, "epss_percentile": 0.94644}, "CVE-2020-8846": {"epss_score": 0.1639, "epss_percentile": 0.94644}, "CVE-2020-8847": {"epss_score": 0.02412, "epss_percentile": 0.84671}, "CVE-2020-8848": {"epss_score": 0.02412, "epss_percentile": 0.84671}, "CVE-2020-8849": {"epss_score": 0.02412, "epss_percentile": 0.84671}, "CVE-2020-8850": {"epss_score": 0.02412, "epss_percentile": 0.84671}, "CVE-2020-8851": {"epss_score": 0.02412, "epss_percentile": 0.84671}, "CVE-2020-8852": {"epss_score": 0.20378, "epss_percentile": 0.95336}, "CVE-2020-8853": {"epss_score": 0.02412, "epss_percentile": 0.84671}, "CVE-2020-8854": {"epss_score": 0.02412, "epss_percentile": 0.84671}, "CVE-2020-8855": {"epss_score": 0.01933, "epss_percentile": 0.82953}, "CVE-2020-8856": {"epss_score": 0.1639, "epss_percentile": 0.94644}, "CVE-2020-8857": {"epss_score": 0.01231, "epss_percentile": 0.7873}, "CVE-2020-8858": {"epss_score": 0.1853, "epss_percentile": 0.95029}, "CVE-2020-8859": {"epss_score": 0.01843, "epss_percentile": 0.82502}, "CVE-2020-8860": {"epss_score": 0.00892, "epss_percentile": 0.75069}, "CVE-2020-8861": {"epss_score": 0.0328, "epss_percentile": 0.8681}, "CVE-2020-8862": {"epss_score": 0.04711, "epss_percentile": 0.89038}, "CVE-2020-8863": {"epss_score": 0.01769, "epss_percentile": 0.82183}, "CVE-2020-8864": {"epss_score": 0.11332, "epss_percentile": 0.93312}, "CVE-2020-8865": {"epss_score": 0.03897, "epss_percentile": 0.87916}, "CVE-2020-8866": {"epss_score": 0.03533, "epss_percentile": 0.87305}, "CVE-2020-8867": {"epss_score": 0.01718, "epss_percentile": 0.81921}, "CVE-2020-8868": {"epss_score": 0.25682, "epss_percentile": 0.96056}, "CVE-2020-8869": {"epss_score": 0.0284, "epss_percentile": 0.85802}, "CVE-2020-8870": {"epss_score": 0.0284, "epss_percentile": 0.85802}, "CVE-2020-8871": {"epss_score": 0.0013, "epss_percentile": 0.33225}, "CVE-2020-8872": {"epss_score": 0.00095, "epss_percentile": 0.27086}, "CVE-2020-8873": {"epss_score": 0.00089, "epss_percentile": 0.25817}, "CVE-2020-8874": {"epss_score": 0.00124, "epss_percentile": 0.32391}, "CVE-2020-8875": {"epss_score": 0.00116, "epss_percentile": 0.31161}, "CVE-2020-8876": {"epss_score": 0.00094, "epss_percentile": 0.26801}, "CVE-2020-8877": {"epss_score": 0.20378, "epss_percentile": 0.95336}, "CVE-2020-8878": {"epss_score": 0.02412, "epss_percentile": 0.84671}, "CVE-2020-8879": {"epss_score": 0.20378, "epss_percentile": 0.95336}, "CVE-2020-8880": {"epss_score": 0.02412, "epss_percentile": 0.84671}, "CVE-2020-8881": {"epss_score": 0.01933, "epss_percentile": 0.82953}, "CVE-2020-8882": {"epss_score": 0.01933, "epss_percentile": 0.82953}, "CVE-2020-8883": {"epss_score": 0.20378, "epss_percentile": 0.95336}, "CVE-2020-8884": {"epss_score": 0.11082, "epss_percentile": 0.93214}, "CVE-2020-8887": {"epss_score": 0.00574, "epss_percentile": 0.68071}, "CVE-2020-8889": {"epss_score": 0.00086, "epss_percentile": 0.25345}, "CVE-2020-8890": {"epss_score": 0.00382, "epss_percentile": 0.59039}, "CVE-2020-8891": {"epss_score": 0.0042, "epss_percentile": 0.61404}, "CVE-2020-8892": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2020-8893": {"epss_score": 0.00414, "epss_percentile": 0.61094}, "CVE-2020-8894": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2020-8895": {"epss_score": 0.0002, "epss_percentile": 0.04608}, "CVE-2020-8896": {"epss_score": 0.00087, "epss_percentile": 0.25488}, "CVE-2020-8897": {"epss_score": 0.00078, "epss_percentile": 0.23638}, "CVE-2020-8899": {"epss_score": 0.0954, "epss_percentile": 0.9259}, "CVE-2020-8902": {"epss_score": 0.00057, "epss_percentile": 0.18231}, "CVE-2020-8903": {"epss_score": 0.00092, "epss_percentile": 0.26589}, "CVE-2020-8904": {"epss_score": 0.00061, "epss_percentile": 0.19291}, "CVE-2020-8905": {"epss_score": 0.00058, "epss_percentile": 0.18484}, "CVE-2020-8907": {"epss_score": 0.00086, "epss_percentile": 0.25352}, "CVE-2020-8908": {"epss_score": 0.00072, "epss_percentile": 0.2241}, "CVE-2020-8910": {"epss_score": 0.00072, "epss_percentile": 0.22346}, "CVE-2020-8911": {"epss_score": 0.00203, "epss_percentile": 0.42553}, "CVE-2020-8912": {"epss_score": 0.00141, "epss_percentile": 0.34824}, "CVE-2020-8913": {"epss_score": 0.01486, "epss_percentile": 0.80604}, "CVE-2020-8916": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2020-8918": {"epss_score": 0.00017, "epss_percentile": 0.03055}, "CVE-2020-8919": {"epss_score": 0.00076, "epss_percentile": 0.2311}, "CVE-2020-8920": {"epss_score": 0.00076, "epss_percentile": 0.2311}, "CVE-2020-8923": {"epss_score": 0.00087, "epss_percentile": 0.25589}, "CVE-2020-8927": {"epss_score": 0.0031, "epss_percentile": 0.53741}, "CVE-2020-8929": {"epss_score": 0.00081, "epss_percentile": 0.24377}, "CVE-2020-8933": {"epss_score": 0.00078, "epss_percentile": 0.23776}, "CVE-2020-8934": {"epss_score": 0.00042, "epss_percentile": 0.12595}, "CVE-2020-8935": {"epss_score": 0.00017, "epss_percentile": 0.03408}, "CVE-2020-8936": {"epss_score": 0.00019, "epss_percentile": 0.04165}, "CVE-2020-8937": {"epss_score": 0.00018, "epss_percentile": 0.03926}, "CVE-2020-8938": {"epss_score": 0.0004, "epss_percentile": 0.12083}, "CVE-2020-8939": {"epss_score": 0.00019, "epss_percentile": 0.04165}, "CVE-2020-8940": {"epss_score": 0.00019, "epss_percentile": 0.04165}, "CVE-2020-8941": {"epss_score": 0.00019, "epss_percentile": 0.04323}, "CVE-2020-8942": {"epss_score": 0.00019, "epss_percentile": 0.04165}, "CVE-2020-8943": {"epss_score": 0.00019, "epss_percentile": 0.04165}, "CVE-2020-8944": {"epss_score": 0.00018, "epss_percentile": 0.03926}, "CVE-2020-8945": {"epss_score": 0.02443, "epss_percentile": 0.8476}, "CVE-2020-8946": {"epss_score": 0.01048, "epss_percentile": 0.77057}, "CVE-2020-8947": {"epss_score": 0.14272, "epss_percentile": 0.94177}, "CVE-2020-8948": {"epss_score": 6e-05, "epss_percentile": 0.00279}, "CVE-2020-8949": {"epss_score": 0.03778, "epss_percentile": 0.87712}, "CVE-2020-8950": {"epss_score": 0.03001, "epss_percentile": 0.86168}, "CVE-2020-8951": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-8952": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-8953": {"epss_score": 0.00431, "epss_percentile": 0.62051}, "CVE-2020-8954": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2020-8955": {"epss_score": 0.14209, "epss_percentile": 0.94164}, "CVE-2020-8956": {"epss_score": 0.09237, "epss_percentile": 0.92461}, "CVE-2020-8958": {"epss_score": 0.8591, "epss_percentile": 0.99355}, "CVE-2020-8959": {"epss_score": 0.00126, "epss_percentile": 0.32708}, "CVE-2020-8960": {"epss_score": 0.00528, "epss_percentile": 0.66542}, "CVE-2020-8961": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2020-8962": {"epss_score": 0.02267, "epss_percentile": 0.84201}, "CVE-2020-8963": {"epss_score": 0.03253, "epss_percentile": 0.86755}, "CVE-2020-8964": {"epss_score": 0.0293, "epss_percentile": 0.86015}, "CVE-2020-8966": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2020-8967": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2020-8968": {"epss_score": 0.00052, "epss_percentile": 0.16385}, "CVE-2020-8973": {"epss_score": 0.00086, "epss_percentile": 0.25365}, "CVE-2020-8974": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2020-8975": {"epss_score": 0.00232, "epss_percentile": 0.45897}, "CVE-2020-8976": {"epss_score": 0.00158, "epss_percentile": 0.3719}, "CVE-2020-8981": {"epss_score": 0.00445, "epss_percentile": 0.62853}, "CVE-2020-8982": {"epss_score": 0.7588, "epss_percentile": 0.98869}, "CVE-2020-8983": {"epss_score": 0.0224, "epss_percentile": 0.84114}, "CVE-2020-8984": {"epss_score": 0.00201, "epss_percentile": 0.42277}, "CVE-2020-8985": {"epss_score": 0.00272, "epss_percentile": 0.50371}, "CVE-2020-8986": {"epss_score": 0.00919, "epss_percentile": 0.75455}, "CVE-2020-8987": {"epss_score": 0.00116, "epss_percentile": 0.31083}, "CVE-2020-8988": {"epss_score": 0.00342, "epss_percentile": 0.56366}, "CVE-2020-8989": {"epss_score": 0.005, "epss_percentile": 0.65292}, "CVE-2020-8990": {"epss_score": 0.00259, "epss_percentile": 0.49084}, "CVE-2020-8991": {"epss_score": 0.00156, "epss_percentile": 0.36904}, "CVE-2020-8992": {"epss_score": 0.00062, "epss_percentile": 0.19774}, "CVE-2020-8994": {"epss_score": 0.0018, "epss_percentile": 0.39972}, "CVE-2020-8995": {"epss_score": 0.01109, "epss_percentile": 0.77648}, "CVE-2020-8996": {"epss_score": 0.00578, "epss_percentile": 0.682}, "CVE-2020-8997": {"epss_score": 0.00555, "epss_percentile": 0.67472}, "CVE-2020-9000": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-9002": {"epss_score": 0.00314, "epss_percentile": 0.54113}, "CVE-2020-9003": {"epss_score": 0.00977, "epss_percentile": 0.76229}, "CVE-2020-9004": {"epss_score": 0.00538, "epss_percentile": 0.66957}, "CVE-2020-9005": {"epss_score": 0.02603, "epss_percentile": 0.85213}, "CVE-2020-9006": {"epss_score": 0.41252, "epss_percentile": 0.97262}, "CVE-2020-9007": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-9008": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2020-9009": {"epss_score": 0.00186, "epss_percentile": 0.40654}, "CVE-2020-9012": {"epss_score": 0.00301, "epss_percentile": 0.53018}, "CVE-2020-9013": {"epss_score": 0.00238, "epss_percentile": 0.46789}, "CVE-2020-9014": {"epss_score": 0.00063, "epss_percentile": 0.20097}, "CVE-2020-9015": {"epss_score": 0.78409, "epss_percentile": 0.98985}, "CVE-2020-9016": {"epss_score": 0.00179, "epss_percentile": 0.39836}, "CVE-2020-9017": {"epss_score": 0.00408, "epss_percentile": 0.60674}, "CVE-2020-9018": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2020-9019": {"epss_score": 0.00276, "epss_percentile": 0.50759}, "CVE-2020-9020": {"epss_score": 0.00726, "epss_percentile": 0.7207}, "CVE-2020-9021": {"epss_score": 0.00371, "epss_percentile": 0.58359}, "CVE-2020-9022": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-9023": {"epss_score": 0.00405, "epss_percentile": 0.60458}, "CVE-2020-9024": {"epss_score": 0.00331, "epss_percentile": 0.55532}, "CVE-2020-9025": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-9026": {"epss_score": 0.02139, "epss_percentile": 0.83743}, "CVE-2020-9027": {"epss_score": 0.03194, "epss_percentile": 0.86607}, "CVE-2020-9028": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2020-9029": {"epss_score": 0.0022, "epss_percentile": 0.44575}, "CVE-2020-9030": {"epss_score": 0.00219, "epss_percentile": 0.44449}, "CVE-2020-9031": {"epss_score": 0.00219, "epss_percentile": 0.44449}, "CVE-2020-9032": {"epss_score": 0.00219, "epss_percentile": 0.44449}, "CVE-2020-9033": {"epss_score": 0.00219, "epss_percentile": 0.44449}, "CVE-2020-9034": {"epss_score": 0.007, "epss_percentile": 0.71484}, "CVE-2020-9036": {"epss_score": 0.2618, "epss_percentile": 0.9612}, "CVE-2020-9038": {"epss_score": 0.01362, "epss_percentile": 0.79762}, "CVE-2020-9039": {"epss_score": 0.00385, "epss_percentile": 0.59217}, "CVE-2020-9040": {"epss_score": 0.00138, "epss_percentile": 0.34376}, "CVE-2020-9041": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2020-9042": {"epss_score": 0.0021, "epss_percentile": 0.43452}, "CVE-2020-9043": {"epss_score": 0.29554, "epss_percentile": 0.96456}, "CVE-2020-9044": {"epss_score": 0.00269, "epss_percentile": 0.50166}, "CVE-2020-9045": {"epss_score": 0.00131, "epss_percentile": 0.33406}, "CVE-2020-9046": {"epss_score": 0.00041, "epss_percentile": 0.12349}, "CVE-2020-9047": {"epss_score": 0.17828, "epss_percentile": 0.94914}, "CVE-2020-9048": {"epss_score": 0.00977, "epss_percentile": 0.76221}, "CVE-2020-9049": {"epss_score": 0.00061, "epss_percentile": 0.19466}, "CVE-2020-9050": {"epss_score": 0.00722, "epss_percentile": 0.72}, "CVE-2020-9054": {"epss_score": 0.94312, "epss_percentile": 0.99944}, "CVE-2020-9055": {"epss_score": 0.00309, "epss_percentile": 0.53652}, "CVE-2020-9056": {"epss_score": 0.00397, "epss_percentile": 0.60022}, "CVE-2020-9057": {"epss_score": 0.00039, "epss_percentile": 0.11472}, "CVE-2020-9058": {"epss_score": 0.00025, "epss_percentile": 0.06351}, "CVE-2020-9059": {"epss_score": 0.00148, "epss_percentile": 0.35864}, "CVE-2020-9060": {"epss_score": 0.00052, "epss_percentile": 0.16554}, "CVE-2020-9061": {"epss_score": 0.00142, "epss_percentile": 0.34997}, "CVE-2020-9062": {"epss_score": 0.00012, "epss_percentile": 0.01353}, "CVE-2020-9063": {"epss_score": 0.00221, "epss_percentile": 0.44674}, "CVE-2020-9064": {"epss_score": 0.00052, "epss_percentile": 0.16607}, "CVE-2020-9065": {"epss_score": 0.00055, "epss_percentile": 0.17373}, "CVE-2020-9066": {"epss_score": 0.00041, "epss_percentile": 0.12231}, "CVE-2020-9067": {"epss_score": 0.00178, "epss_percentile": 0.39672}, "CVE-2020-9068": {"epss_score": 0.00161, "epss_percentile": 0.37604}, "CVE-2020-9069": {"epss_score": 0.00044, "epss_percentile": 0.13665}, "CVE-2020-9070": {"epss_score": 0.00069, "epss_percentile": 0.21517}, "CVE-2020-9071": {"epss_score": 0.00166, "epss_percentile": 0.3817}, "CVE-2020-9072": {"epss_score": 0.00023, "epss_percentile": 0.05519}, "CVE-2020-9073": {"epss_score": 0.00026, "epss_percentile": 0.06437}, "CVE-2020-9074": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2020-9075": {"epss_score": 0.00153, "epss_percentile": 0.36549}, "CVE-2020-9076": {"epss_score": 0.00102, "epss_percentile": 0.28808}, "CVE-2020-9077": {"epss_score": 0.0026, "epss_percentile": 0.49099}, "CVE-2020-9078": {"epss_score": 0.00024, "epss_percentile": 0.05854}, "CVE-2020-9079": {"epss_score": 0.0006, "epss_percentile": 0.19169}, "CVE-2020-9080": {"epss_score": 0.00016, "epss_percentile": 0.02637}, "CVE-2020-9081": {"epss_score": 0.00028, "epss_percentile": 0.07533}, "CVE-2020-9082": {"epss_score": 0.00078, "epss_percentile": 0.23754}, "CVE-2020-9083": {"epss_score": 0.00027, "epss_percentile": 0.06882}, "CVE-2020-9084": {"epss_score": 0.00024, "epss_percentile": 0.05821}, "CVE-2020-9085": {"epss_score": 0.00128, "epss_percentile": 0.32958}, "CVE-2020-9086": {"epss_score": 0.00033, "epss_percentile": 0.09167}, "CVE-2020-9087": {"epss_score": 0.00025, "epss_percentile": 0.06237}, "CVE-2020-9089": {"epss_score": 0.00021, "epss_percentile": 0.04882}, "CVE-2020-9090": {"epss_score": 0.00027, "epss_percentile": 0.06914}, "CVE-2020-9091": {"epss_score": 0.00024, "epss_percentile": 0.05726}, "CVE-2020-9092": {"epss_score": 0.0006, "epss_percentile": 0.1921}, "CVE-2020-9093": {"epss_score": 0.00086, "epss_percentile": 0.25304}, "CVE-2020-9094": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2020-9095": {"epss_score": 0.00024, "epss_percentile": 0.05726}, "CVE-2020-9096": {"epss_score": 0.00024, "epss_percentile": 0.05726}, "CVE-2020-9098": {"epss_score": 0.00149, "epss_percentile": 0.36022}, "CVE-2020-9099": {"epss_score": 0.00161, "epss_percentile": 0.37604}, "CVE-2020-9100": {"epss_score": 0.00018, "epss_percentile": 0.03858}, "CVE-2020-9101": {"epss_score": 0.00037, "epss_percentile": 0.10664}, "CVE-2020-9102": {"epss_score": 0.00023, "epss_percentile": 0.05351}, "CVE-2020-9103": {"epss_score": 0.00025, "epss_percentile": 0.06213}, "CVE-2020-9104": {"epss_score": 0.00048, "epss_percentile": 0.15282}, "CVE-2020-9105": {"epss_score": 0.00026, "epss_percentile": 0.06569}, "CVE-2020-9106": {"epss_score": 0.00029, "epss_percentile": 0.07756}, "CVE-2020-9107": {"epss_score": 0.0017, "epss_percentile": 0.3872}, "CVE-2020-9108": {"epss_score": 0.00076, "epss_percentile": 0.23213}, "CVE-2020-9109": {"epss_score": 0.00028, "epss_percentile": 0.07343}, "CVE-2020-9110": {"epss_score": 0.0003, "epss_percentile": 0.08028}, "CVE-2020-9111": {"epss_score": 0.00049, "epss_percentile": 0.15484}, "CVE-2020-9112": {"epss_score": 0.00023, "epss_percentile": 0.05509}, "CVE-2020-9113": {"epss_score": 0.00046, "epss_percentile": 0.14434}, "CVE-2020-9114": {"epss_score": 0.00018, "epss_percentile": 0.03747}, "CVE-2020-9115": {"epss_score": 0.00822, "epss_percentile": 0.7391}, "CVE-2020-9116": {"epss_score": 0.01468, "epss_percentile": 0.80479}, "CVE-2020-9117": {"epss_score": 0.0003, "epss_percentile": 0.08186}, "CVE-2020-9118": {"epss_score": 0.00013, "epss_percentile": 0.01712}, "CVE-2020-9119": {"epss_score": 0.0003, "epss_percentile": 0.07982}, "CVE-2020-9120": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2020-9122": {"epss_score": 0.0005, "epss_percentile": 0.15778}, "CVE-2020-9123": {"epss_score": 0.004, "epss_percentile": 0.60176}, "CVE-2020-9124": {"epss_score": 0.00313, "epss_percentile": 0.54071}, "CVE-2020-9125": {"epss_score": 0.00014, "epss_percentile": 0.01896}, "CVE-2020-9127": {"epss_score": 0.00113, "epss_percentile": 0.30701}, "CVE-2020-9128": {"epss_score": 7e-05, "epss_percentile": 0.00444}, "CVE-2020-9129": {"epss_score": 0.00033, "epss_percentile": 0.09335}, "CVE-2020-9137": {"epss_score": 0.00026, "epss_percentile": 0.06624}, "CVE-2020-9138": {"epss_score": 0.0019, "epss_percentile": 0.41131}, "CVE-2020-9139": {"epss_score": 0.00221, "epss_percentile": 0.44643}, "CVE-2020-9140": {"epss_score": 0.0061, "epss_percentile": 0.69162}, "CVE-2020-9141": {"epss_score": 0.00057, "epss_percentile": 0.18179}, "CVE-2020-9142": {"epss_score": 0.00196, "epss_percentile": 0.4178}, "CVE-2020-9143": {"epss_score": 0.00086, "epss_percentile": 0.25361}, "CVE-2020-9144": {"epss_score": 0.00254, "epss_percentile": 0.48568}, "CVE-2020-9145": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2020-9146": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2020-9147": {"epss_score": 0.00024, "epss_percentile": 0.05854}, "CVE-2020-9148": {"epss_score": 0.00023, "epss_percentile": 0.05464}, "CVE-2020-9149": {"epss_score": 0.00023, "epss_percentile": 0.05464}, "CVE-2020-9158": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2020-9199": {"epss_score": 0.00241, "epss_percentile": 0.47273}, "CVE-2020-9200": {"epss_score": 0.00063, "epss_percentile": 0.19807}, "CVE-2020-9201": {"epss_score": 0.00047, "epss_percentile": 0.14927}, "CVE-2020-9202": {"epss_score": 0.00031, "epss_percentile": 0.08418}, "CVE-2020-9203": {"epss_score": 0.00023, "epss_percentile": 0.05402}, "CVE-2020-9205": {"epss_score": 0.00127, "epss_percentile": 0.32917}, "CVE-2020-9206": {"epss_score": 0.0003, "epss_percentile": 0.07982}, "CVE-2020-9207": {"epss_score": 0.00083, "epss_percentile": 0.24821}, "CVE-2020-9208": {"epss_score": 0.00102, "epss_percentile": 0.28727}, "CVE-2020-9209": {"epss_score": 0.00022, "epss_percentile": 0.05199}, "CVE-2020-9210": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2020-9211": {"epss_score": 0.00048, "epss_percentile": 0.14954}, "CVE-2020-9212": {"epss_score": 0.00153, "epss_percentile": 0.36549}, "CVE-2020-9213": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2020-9222": {"epss_score": 0.00012, "epss_percentile": 0.01233}, "CVE-2020-9223": {"epss_score": 0.00277, "epss_percentile": 0.50809}, "CVE-2020-9225": {"epss_score": 0.0002, "epss_percentile": 0.0468}, "CVE-2020-9226": {"epss_score": 0.00042, "epss_percentile": 0.12906}, "CVE-2020-9227": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2020-9228": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2020-9229": {"epss_score": 0.00031, "epss_percentile": 0.08418}, "CVE-2020-9230": {"epss_score": 0.00019, "epss_percentile": 0.04257}, "CVE-2020-9233": {"epss_score": 0.00141, "epss_percentile": 0.3492}, "CVE-2020-9235": {"epss_score": 0.00033, "epss_percentile": 0.09305}, "CVE-2020-9236": {"epss_score": 0.00137, "epss_percentile": 0.34237}, "CVE-2020-9237": {"epss_score": 0.0003, "epss_percentile": 0.07982}, "CVE-2020-9238": {"epss_score": 0.00053, "epss_percentile": 0.16842}, "CVE-2020-9239": {"epss_score": 0.00033, "epss_percentile": 0.09305}, "CVE-2020-9240": {"epss_score": 0.00025, "epss_percentile": 0.06247}, "CVE-2020-9241": {"epss_score": 0.00173, "epss_percentile": 0.39108}, "CVE-2020-9242": {"epss_score": 0.02018, "epss_percentile": 0.83286}, "CVE-2020-9243": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2020-9244": {"epss_score": 0.00027, "epss_percentile": 0.06742}, "CVE-2020-9245": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2020-9246": {"epss_score": 0.00153, "epss_percentile": 0.36549}, "CVE-2020-9247": {"epss_score": 0.00352, "epss_percentile": 0.57082}, "CVE-2020-9248": {"epss_score": 0.00026, "epss_percentile": 0.06569}, "CVE-2020-9249": {"epss_score": 0.0005, "epss_percentile": 0.15778}, "CVE-2020-9250": {"epss_score": 0.00014, "epss_percentile": 0.01846}, "CVE-2020-9251": {"epss_score": 0.00027, "epss_percentile": 0.07001}, "CVE-2020-9252": {"epss_score": 0.00031, "epss_percentile": 0.0855}, "CVE-2020-9253": {"epss_score": 0.00078, "epss_percentile": 0.23553}, "CVE-2020-9254": {"epss_score": 0.00172, "epss_percentile": 0.38939}, "CVE-2020-9255": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2020-9256": {"epss_score": 0.00148, "epss_percentile": 0.35858}, "CVE-2020-9257": {"epss_score": 0.00294, "epss_percentile": 0.52394}, "CVE-2020-9258": {"epss_score": 0.00028, "epss_percentile": 0.07308}, "CVE-2020-9259": {"epss_score": 0.00119, "epss_percentile": 0.31645}, "CVE-2020-9260": {"epss_score": 0.00044, "epss_percentile": 0.13665}, "CVE-2020-9261": {"epss_score": 0.00196, "epss_percentile": 0.41714}, "CVE-2020-9262": {"epss_score": 0.00318, "epss_percentile": 0.54402}, "CVE-2020-9263": {"epss_score": 0.00318, "epss_percentile": 0.54402}, "CVE-2020-9264": {"epss_score": 0.00252, "epss_percentile": 0.48377}, "CVE-2020-9265": {"epss_score": 0.01002, "epss_percentile": 0.76508}, "CVE-2020-9266": {"epss_score": 0.0021, "epss_percentile": 0.43587}, "CVE-2020-9267": {"epss_score": 0.00192, "epss_percentile": 0.41368}, "CVE-2020-9268": {"epss_score": 0.00789, "epss_percentile": 0.7336}, "CVE-2020-9269": {"epss_score": 0.00452, "epss_percentile": 0.63164}, "CVE-2020-9270": {"epss_score": 0.00177, "epss_percentile": 0.39535}, "CVE-2020-9271": {"epss_score": 0.00161, "epss_percentile": 0.37584}, "CVE-2020-9272": {"epss_score": 0.00518, "epss_percentile": 0.66136}, "CVE-2020-9273": {"epss_score": 0.66833, "epss_percentile": 0.98482}, "CVE-2020-9274": {"epss_score": 0.15323, "epss_percentile": 0.94409}, "CVE-2020-9275": {"epss_score": 0.00756, "epss_percentile": 0.72733}, "CVE-2020-9276": {"epss_score": 0.00838, "epss_percentile": 0.74167}, "CVE-2020-9277": {"epss_score": 0.00661, "epss_percentile": 0.70566}, "CVE-2020-9278": {"epss_score": 0.00638, "epss_percentile": 0.69924}, "CVE-2020-9279": {"epss_score": 0.02222, "epss_percentile": 0.84054}, "CVE-2020-9280": {"epss_score": 0.00386, "epss_percentile": 0.59253}, "CVE-2020-9281": {"epss_score": 0.01194, "epss_percentile": 0.78412}, "CVE-2020-9282": {"epss_score": 0.00274, "epss_percentile": 0.50511}, "CVE-2020-9283": {"epss_score": 0.18682, "epss_percentile": 0.95052}, "CVE-2020-9285": {"epss_score": 0.00103, "epss_percentile": 0.28921}, "CVE-2020-9286": {"epss_score": 0.00854, "epss_percentile": 0.74451}, "CVE-2020-9287": {"epss_score": 0.00049, "epss_percentile": 0.15623}, "CVE-2020-9288": {"epss_score": 0.00203, "epss_percentile": 0.42571}, "CVE-2020-9289": {"epss_score": 0.01022, "epss_percentile": 0.7676}, "CVE-2020-9290": {"epss_score": 0.00049, "epss_percentile": 0.15623}, "CVE-2020-9291": {"epss_score": 0.00115, "epss_percentile": 0.30932}, "CVE-2020-9292": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2020-9294": {"epss_score": 0.80131, "epss_percentile": 0.99072}, "CVE-2020-9295": {"epss_score": 0.00237, "epss_percentile": 0.46656}, "CVE-2020-9296": {"epss_score": 0.00563, "epss_percentile": 0.67715}, "CVE-2020-9297": {"epss_score": 0.00322, "epss_percentile": 0.54818}, "CVE-2020-9298": {"epss_score": 0.00347, "epss_percentile": 0.56752}, "CVE-2020-9299": {"epss_score": 0.00444, "epss_percentile": 0.62843}, "CVE-2020-9300": {"epss_score": 0.00621, "epss_percentile": 0.69477}, "CVE-2020-9301": {"epss_score": 0.00812, "epss_percentile": 0.73751}, "CVE-2020-9306": {"epss_score": 0.00222, "epss_percentile": 0.44801}, "CVE-2020-9307": {"epss_score": 0.00036, "epss_percentile": 0.10321}, "CVE-2020-9308": {"epss_score": 0.00733, "epss_percentile": 0.72206}, "CVE-2020-9309": {"epss_score": 0.00727, "epss_percentile": 0.721}, "CVE-2020-9311": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2020-9314": {"epss_score": 0.41294, "epss_percentile": 0.97264}, "CVE-2020-9315": {"epss_score": 0.8793, "epss_percentile": 0.9945}, "CVE-2020-9318": {"epss_score": 0.00362, "epss_percentile": 0.57788}, "CVE-2020-9320": {"epss_score": 0.00625, "epss_percentile": 0.69579}, "CVE-2020-9321": {"epss_score": 0.00155, "epss_percentile": 0.36804}, "CVE-2020-9322": {"epss_score": 0.0002, "epss_percentile": 0.04501}, "CVE-2020-9323": {"epss_score": 0.01563, "epss_percentile": 0.81049}, "CVE-2020-9324": {"epss_score": 0.0046, "epss_percentile": 0.63527}, "CVE-2020-9325": {"epss_score": 0.00554, "epss_percentile": 0.67443}, "CVE-2020-9326": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2020-9327": {"epss_score": 0.00701, "epss_percentile": 0.71505}, "CVE-2020-9329": {"epss_score": 0.00266, "epss_percentile": 0.49918}, "CVE-2020-9330": {"epss_score": 0.00333, "epss_percentile": 0.55621}, "CVE-2020-9331": {"epss_score": 0.0005, "epss_percentile": 0.15965}, "CVE-2020-9332": {"epss_score": 0.00057, "epss_percentile": 0.18228}, "CVE-2020-9334": {"epss_score": 0.0048, "epss_percentile": 0.64477}, "CVE-2020-9335": {"epss_score": 0.00549, "epss_percentile": 0.67302}, "CVE-2020-9336": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-9337": {"epss_score": 0.00189, "epss_percentile": 0.40989}, "CVE-2020-9338": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-9339": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2020-9340": {"epss_score": 0.0032, "epss_percentile": 0.54591}, "CVE-2020-9341": {"epss_score": 0.00405, "epss_percentile": 0.60475}, "CVE-2020-9342": {"epss_score": 0.0025, "epss_percentile": 0.48087}, "CVE-2020-9343": {"epss_score": 0.00559, "epss_percentile": 0.67615}, "CVE-2020-9344": {"epss_score": 0.36969, "epss_percentile": 0.97012}, "CVE-2020-9345": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2020-9346": {"epss_score": 0.00484, "epss_percentile": 0.64633}, "CVE-2020-9347": {"epss_score": 0.02498, "epss_percentile": 0.84913}, "CVE-2020-9349": {"epss_score": 0.00561, "epss_percentile": 0.6767}, "CVE-2020-9350": {"epss_score": 0.00402, "epss_percentile": 0.6028}, "CVE-2020-9351": {"epss_score": 0.00868, "epss_percentile": 0.74666}, "CVE-2020-9352": {"epss_score": 0.01055, "epss_percentile": 0.77114}, "CVE-2020-9353": {"epss_score": 0.00822, "epss_percentile": 0.7392}, "CVE-2020-9354": {"epss_score": 0.00794, "epss_percentile": 0.73436}, "CVE-2020-9355": {"epss_score": 0.00527, "epss_percentile": 0.6645}, "CVE-2020-9359": {"epss_score": 0.02641, "epss_percentile": 0.85305}, "CVE-2020-9361": {"epss_score": 0.00048, "epss_percentile": 0.15028}, "CVE-2020-9362": {"epss_score": 0.00213, "epss_percentile": 0.43897}, "CVE-2020-9363": {"epss_score": 0.00063, "epss_percentile": 0.20089}, "CVE-2020-9364": {"epss_score": 0.00536, "epss_percentile": 0.66883}, "CVE-2020-9365": {"epss_score": 0.41809, "epss_percentile": 0.97295}, "CVE-2020-9366": {"epss_score": 0.00733, "epss_percentile": 0.72214}, "CVE-2020-9367": {"epss_score": 0.00057, "epss_percentile": 0.18011}, "CVE-2020-9368": {"epss_score": 0.03878, "epss_percentile": 0.87893}, "CVE-2020-9369": {"epss_score": 0.02124, "epss_percentile": 0.8369}, "CVE-2020-9370": {"epss_score": 0.00298, "epss_percentile": 0.52798}, "CVE-2020-9371": {"epss_score": 0.00738, "epss_percentile": 0.72341}, "CVE-2020-9372": {"epss_score": 0.1934, "epss_percentile": 0.95166}, "CVE-2020-9374": {"epss_score": 0.88703, "epss_percentile": 0.99484}, "CVE-2020-9375": {"epss_score": 0.28044, "epss_percentile": 0.96303}, "CVE-2020-9376": {"epss_score": 0.92258, "epss_percentile": 0.99703}, "CVE-2020-9377": {"epss_score": 0.76636, "epss_percentile": 0.98899}, "CVE-2020-9379": {"epss_score": 0.0034, "epss_percentile": 0.56266}, "CVE-2020-9380": {"epss_score": 0.20743, "epss_percentile": 0.95407}, "CVE-2020-9381": {"epss_score": 0.02545, "epss_percentile": 0.8506}, "CVE-2020-9382": {"epss_score": 0.00388, "epss_percentile": 0.59399}, "CVE-2020-9383": {"epss_score": 0.00095, "epss_percentile": 0.27172}, "CVE-2020-9384": {"epss_score": 0.00591, "epss_percentile": 0.68592}, "CVE-2020-9385": {"epss_score": 0.00153, "epss_percentile": 0.36614}, "CVE-2020-9386": {"epss_score": 0.00205, "epss_percentile": 0.427}, "CVE-2020-9387": {"epss_score": 0.00189, "epss_percentile": 0.40999}, "CVE-2020-9388": {"epss_score": 0.00155, "epss_percentile": 0.36821}, "CVE-2020-9389": {"epss_score": 0.00316, "epss_percentile": 0.54278}, "CVE-2020-9390": {"epss_score": 0.00445, "epss_percentile": 0.62864}, "CVE-2020-9391": {"epss_score": 0.00161, "epss_percentile": 0.3757}, "CVE-2020-9392": {"epss_score": 0.0082, "epss_percentile": 0.73891}, "CVE-2020-9393": {"epss_score": 0.00259, "epss_percentile": 0.49095}, "CVE-2020-9394": {"epss_score": 0.00273, "epss_percentile": 0.50427}, "CVE-2020-9395": {"epss_score": 0.00442, "epss_percentile": 0.62709}, "CVE-2020-9398": {"epss_score": 0.00512, "epss_percentile": 0.65854}, "CVE-2020-9399": {"epss_score": 0.00109, "epss_percentile": 0.30022}, "CVE-2020-9402": {"epss_score": 0.81181, "epss_percentile": 0.99127}, "CVE-2020-9403": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2020-9404": {"epss_score": 0.0005, "epss_percentile": 0.15729}, "CVE-2020-9405": {"epss_score": 0.00707, "epss_percentile": 0.7165}, "CVE-2020-9406": {"epss_score": 0.009, "epss_percentile": 0.75166}, "CVE-2020-9407": {"epss_score": 0.00292, "epss_percentile": 0.52224}, "CVE-2020-9408": {"epss_score": 0.00241, "epss_percentile": 0.47263}, "CVE-2020-9409": {"epss_score": 0.05012, "epss_percentile": 0.89392}, "CVE-2020-9410": {"epss_score": 0.011, "epss_percentile": 0.7757}, "CVE-2020-9411": {"epss_score": 0.00385, "epss_percentile": 0.5921}, "CVE-2020-9412": {"epss_score": 0.00779, "epss_percentile": 0.73139}, "CVE-2020-9413": {"epss_score": 0.00856, "epss_percentile": 0.74473}, "CVE-2020-9414": {"epss_score": 0.00546, "epss_percentile": 0.67224}, "CVE-2020-9415": {"epss_score": 0.00285, "epss_percentile": 0.51651}, "CVE-2020-9416": {"epss_score": 0.0041, "epss_percentile": 0.60839}, "CVE-2020-9417": {"epss_score": 0.00419, "epss_percentile": 0.61359}, "CVE-2020-9418": {"epss_score": 0.0008, "epss_percentile": 0.24018}, "CVE-2020-9419": {"epss_score": 0.0016, "epss_percentile": 0.37465}, "CVE-2020-9420": {"epss_score": 0.00127, "epss_percentile": 0.32881}, "CVE-2020-9423": {"epss_score": 0.01478, "epss_percentile": 0.80554}, "CVE-2020-9425": {"epss_score": 0.49449, "epss_percentile": 0.97688}, "CVE-2020-9426": {"epss_score": 0.00509, "epss_percentile": 0.65739}, "CVE-2020-9427": {"epss_score": 0.00205, "epss_percentile": 0.42703}, "CVE-2020-9428": {"epss_score": 0.08184, "epss_percentile": 0.91917}, "CVE-2020-9429": {"epss_score": 0.00586, "epss_percentile": 0.68452}, "CVE-2020-9430": {"epss_score": 0.03608, "epss_percentile": 0.8742}, "CVE-2020-9431": {"epss_score": 0.04397, "epss_percentile": 0.8864}, "CVE-2020-9432": {"epss_score": 0.00146, "epss_percentile": 0.35631}, "CVE-2020-9433": {"epss_score": 0.00146, "epss_percentile": 0.35631}, "CVE-2020-9434": {"epss_score": 0.00146, "epss_percentile": 0.35631}, "CVE-2020-9435": {"epss_score": 0.00376, "epss_percentile": 0.58667}, "CVE-2020-9436": {"epss_score": 0.01221, "epss_percentile": 0.78647}, "CVE-2020-9437": {"epss_score": 0.00632, "epss_percentile": 0.69739}, "CVE-2020-9438": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2020-9439": {"epss_score": 0.00332, "epss_percentile": 0.55583}, "CVE-2020-9440": {"epss_score": 0.00485, "epss_percentile": 0.64705}, "CVE-2020-9442": {"epss_score": 0.02049, "epss_percentile": 0.83395}, "CVE-2020-9443": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-9444": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2020-9445": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2020-9447": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2020-9449": {"epss_score": 0.00525, "epss_percentile": 0.66386}, "CVE-2020-9450": {"epss_score": 0.00056, "epss_percentile": 0.1795}, "CVE-2020-9451": {"epss_score": 0.00037, "epss_percentile": 0.10973}, "CVE-2020-9452": {"epss_score": 0.00044, "epss_percentile": 0.13461}, "CVE-2020-9453": {"epss_score": 0.00052, "epss_percentile": 0.16377}, "CVE-2020-9454": {"epss_score": 0.00569, "epss_percentile": 0.67928}, "CVE-2020-9455": {"epss_score": 0.00208, "epss_percentile": 0.43228}, "CVE-2020-9456": {"epss_score": 0.01959, "epss_percentile": 0.83052}, "CVE-2020-9457": {"epss_score": 0.00792, "epss_percentile": 0.73409}, "CVE-2020-9458": {"epss_score": 0.01959, "epss_percentile": 0.83052}, "CVE-2020-9459": {"epss_score": 0.00185, "epss_percentile": 0.40513}, "CVE-2020-9460": {"epss_score": 0.02298, "epss_percentile": 0.84302}, "CVE-2020-9461": {"epss_score": 0.02298, "epss_percentile": 0.84302}, "CVE-2020-9462": {"epss_score": 0.00035, "epss_percentile": 0.10014}, "CVE-2020-9463": {"epss_score": 0.03829, "epss_percentile": 0.87797}, "CVE-2020-9464": {"epss_score": 0.00446, "epss_percentile": 0.629}, "CVE-2020-9465": {"epss_score": 0.78909, "epss_percentile": 0.9901}, "CVE-2020-9466": {"epss_score": 0.00265, "epss_percentile": 0.49813}, "CVE-2020-9467": {"epss_score": 0.00198, "epss_percentile": 0.41975}, "CVE-2020-9468": {"epss_score": 0.00224, "epss_percentile": 0.4502}, "CVE-2020-9470": {"epss_score": 0.0191, "epss_percentile": 0.82826}, "CVE-2020-9471": {"epss_score": 0.02935, "epss_percentile": 0.86024}, "CVE-2020-9472": {"epss_score": 0.0216, "epss_percentile": 0.83824}, "CVE-2020-9473": {"epss_score": 0.00462, "epss_percentile": 0.63616}, "CVE-2020-9474": {"epss_score": 0.01382, "epss_percentile": 0.79888}, "CVE-2020-9475": {"epss_score": 0.00033, "epss_percentile": 0.09152}, "CVE-2020-9476": {"epss_score": 0.00299, "epss_percentile": 0.52874}, "CVE-2020-9477": {"epss_score": 0.00932, "epss_percentile": 0.75624}, "CVE-2020-9478": {"epss_score": 0.03732, "epss_percentile": 0.87646}, "CVE-2020-9479": {"epss_score": 0.01892, "epss_percentile": 0.82737}, "CVE-2020-9480": {"epss_score": 0.933, "epss_percentile": 0.99794}, "CVE-2020-9481": {"epss_score": 0.03921, "epss_percentile": 0.87953}, "CVE-2020-9482": {"epss_score": 0.00923, "epss_percentile": 0.75496}, "CVE-2020-9483": {"epss_score": 0.93816, "epss_percentile": 0.99851}, "CVE-2020-9484": {"epss_score": 0.93325, "epss_percentile": 0.99796}, "CVE-2020-9485": {"epss_score": 0.02134, "epss_percentile": 0.83725}, "CVE-2020-9486": {"epss_score": 0.0058, "epss_percentile": 0.68248}, "CVE-2020-9487": {"epss_score": 0.00638, "epss_percentile": 0.69915}, "CVE-2020-9488": {"epss_score": 0.00021, "epss_percentile": 0.0469}, "CVE-2020-9489": {"epss_score": 0.00388, "epss_percentile": 0.59379}, "CVE-2020-9490": {"epss_score": 0.75824, "epss_percentile": 0.98865}, "CVE-2020-9491": {"epss_score": 0.02825, "epss_percentile": 0.85756}, "CVE-2020-9492": {"epss_score": 0.00115, "epss_percentile": 0.31014}, "CVE-2020-9493": {"epss_score": 0.00348, "epss_percentile": 0.5681}, "CVE-2020-9494": {"epss_score": 0.01169, "epss_percentile": 0.78197}, "CVE-2020-9495": {"epss_score": 0.27485, "epss_percentile": 0.9625}, "CVE-2020-9496": {"epss_score": 0.93772, "epss_percentile": 0.99842}, "CVE-2020-9497": {"epss_score": 0.00082, "epss_percentile": 0.24577}, "CVE-2020-9498": {"epss_score": 0.00107, "epss_percentile": 0.296}, "CVE-2020-9499": {"epss_score": 0.00534, "epss_percentile": 0.66801}, "CVE-2020-9500": {"epss_score": 0.0053, "epss_percentile": 0.66618}, "CVE-2020-9501": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2020-9502": {"epss_score": 0.00604, "epss_percentile": 0.68966}, "CVE-2020-9514": {"epss_score": 0.0025, "epss_percentile": 0.48114}, "CVE-2020-9517": {"epss_score": 0.00155, "epss_percentile": 0.36766}, "CVE-2020-9518": {"epss_score": 0.00425, "epss_percentile": 0.61691}, "CVE-2020-9519": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2020-9520": {"epss_score": 0.00203, "epss_percentile": 0.42579}, "CVE-2020-9521": {"epss_score": 0.003, "epss_percentile": 0.52943}, "CVE-2020-9522": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2020-9523": {"epss_score": 0.00288, "epss_percentile": 0.51979}, "CVE-2020-9524": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2020-9525": {"epss_score": 0.00716, "epss_percentile": 0.71854}, "CVE-2020-9526": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2020-9527": {"epss_score": 0.07578, "epss_percentile": 0.9155}, "CVE-2020-9528": {"epss_score": 0.00175, "epss_percentile": 0.39374}, "CVE-2020-9529": {"epss_score": 0.02335, "epss_percentile": 0.84415}, "CVE-2020-9530": {"epss_score": 0.00502, "epss_percentile": 0.65404}, "CVE-2020-9531": {"epss_score": 0.00207, "epss_percentile": 0.43187}, "CVE-2020-9534": {"epss_score": 0.00535, "epss_percentile": 0.66824}, "CVE-2020-9535": {"epss_score": 0.00547, "epss_percentile": 0.67263}, "CVE-2020-9540": {"epss_score": 0.00099, "epss_percentile": 0.28373}, "CVE-2020-9543": {"epss_score": 0.00323, "epss_percentile": 0.54867}, "CVE-2020-9544": {"epss_score": 0.00715, "epss_percentile": 0.71851}, "CVE-2020-9545": {"epss_score": 0.00544, "epss_percentile": 0.67131}, "CVE-2020-9546": {"epss_score": 0.02327, "epss_percentile": 0.84393}, "CVE-2020-9547": {"epss_score": 0.43143, "epss_percentile": 0.97371}, "CVE-2020-9548": {"epss_score": 0.62015, "epss_percentile": 0.98272}, "CVE-2020-9549": {"epss_score": 0.01247, "epss_percentile": 0.78858}, "CVE-2020-9550": {"epss_score": 0.00242, "epss_percentile": 0.47389}, "CVE-2020-9551": {"epss_score": 0.08423, "epss_percentile": 0.92044}, "CVE-2020-9552": {"epss_score": 0.26491, "epss_percentile": 0.96151}, "CVE-2020-9553": {"epss_score": 0.0193, "epss_percentile": 0.82938}, "CVE-2020-9554": {"epss_score": 0.03924, "epss_percentile": 0.87959}, "CVE-2020-9555": {"epss_score": 0.08729, "epss_percentile": 0.92231}, "CVE-2020-9556": {"epss_score": 0.04213, "epss_percentile": 0.88403}, "CVE-2020-9557": {"epss_score": 0.03272, "epss_percentile": 0.86797}, "CVE-2020-9558": {"epss_score": 0.01763, "epss_percentile": 0.82156}, "CVE-2020-9559": {"epss_score": 0.03924, "epss_percentile": 0.87959}, "CVE-2020-9560": {"epss_score": 0.03924, "epss_percentile": 0.87959}, "CVE-2020-9561": {"epss_score": 0.04213, "epss_percentile": 0.88403}, "CVE-2020-9562": {"epss_score": 0.09158, "epss_percentile": 0.92426}, "CVE-2020-9563": {"epss_score": 0.09784, "epss_percentile": 0.92701}, "CVE-2020-9564": {"epss_score": 0.03924, "epss_percentile": 0.87959}, "CVE-2020-9565": {"epss_score": 0.03924, "epss_percentile": 0.87959}, "CVE-2020-9566": {"epss_score": 0.10244, "epss_percentile": 0.92909}, "CVE-2020-9567": {"epss_score": 0.09593, "epss_percentile": 0.92614}, "CVE-2020-9568": {"epss_score": 0.0284, "epss_percentile": 0.85803}, "CVE-2020-9569": {"epss_score": 0.03924, "epss_percentile": 0.87959}, "CVE-2020-9570": {"epss_score": 0.02642, "epss_percentile": 0.85307}, "CVE-2020-9571": {"epss_score": 0.02642, "epss_percentile": 0.85307}, "CVE-2020-9572": {"epss_score": 0.0284, "epss_percentile": 0.85803}, "CVE-2020-9573": {"epss_score": 0.02642, "epss_percentile": 0.85307}, "CVE-2020-9574": {"epss_score": 0.02642, "epss_percentile": 0.85307}, "CVE-2020-9575": {"epss_score": 0.01413, "epss_percentile": 0.80119}, "CVE-2020-9576": {"epss_score": 0.031, "epss_percentile": 0.86407}, "CVE-2020-9577": {"epss_score": 0.00319, "epss_percentile": 0.5456}, "CVE-2020-9578": {"epss_score": 0.0323, "epss_percentile": 0.86695}, "CVE-2020-9579": {"epss_score": 0.0622, "epss_percentile": 0.90578}, "CVE-2020-9580": {"epss_score": 0.0622, "epss_percentile": 0.90578}, "CVE-2020-9581": {"epss_score": 0.00319, "epss_percentile": 0.5456}, "CVE-2020-9582": {"epss_score": 0.0323, "epss_percentile": 0.86695}, "CVE-2020-9583": {"epss_score": 0.031, "epss_percentile": 0.86407}, "CVE-2020-9584": {"epss_score": 0.00171, "epss_percentile": 0.3884}, "CVE-2020-9585": {"epss_score": 0.0622, "epss_percentile": 0.90578}, "CVE-2020-9586": {"epss_score": 0.0562, "epss_percentile": 0.90059}, "CVE-2020-9587": {"epss_score": 0.00551, "epss_percentile": 0.67374}, "CVE-2020-9588": {"epss_score": 0.01185, "epss_percentile": 0.7834}, "CVE-2020-9589": {"epss_score": 0.05718, "epss_percentile": 0.90148}, "CVE-2020-9590": {"epss_score": 0.04846, "epss_percentile": 0.8921}, "CVE-2020-9591": {"epss_score": 0.01311, "epss_percentile": 0.79373}, "CVE-2020-9592": {"epss_score": 0.00321, "epss_percentile": 0.54672}, "CVE-2020-9593": {"epss_score": 0.01913, "epss_percentile": 0.82841}, "CVE-2020-9594": {"epss_score": 0.03002, "epss_percentile": 0.86175}, "CVE-2020-9595": {"epss_score": 0.01913, "epss_percentile": 0.82841}, "CVE-2020-9596": {"epss_score": 0.00321, "epss_percentile": 0.54672}, "CVE-2020-9597": {"epss_score": 0.38571, "epss_percentile": 0.97107}, "CVE-2020-9598": {"epss_score": 0.01913, "epss_percentile": 0.82841}, "CVE-2020-9599": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2020-9600": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2020-9601": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2020-9602": {"epss_score": 0.01913, "epss_percentile": 0.82841}, "CVE-2020-9603": {"epss_score": 0.01913, "epss_percentile": 0.82841}, "CVE-2020-9604": {"epss_score": 0.03757, "epss_percentile": 0.87682}, "CVE-2020-9605": {"epss_score": 0.03757, "epss_percentile": 0.87682}, "CVE-2020-9606": {"epss_score": 0.00545, "epss_percentile": 0.67157}, "CVE-2020-9607": {"epss_score": 0.04561, "epss_percentile": 0.88852}, "CVE-2020-9608": {"epss_score": 0.01913, "epss_percentile": 0.82841}, "CVE-2020-9609": {"epss_score": 0.01913, "epss_percentile": 0.82841}, "CVE-2020-9610": {"epss_score": 0.00952, "epss_percentile": 0.75883}, "CVE-2020-9611": {"epss_score": 0.01289, "epss_percentile": 0.79211}, "CVE-2020-9612": {"epss_score": 0.08178, "epss_percentile": 0.91915}, "CVE-2020-9613": {"epss_score": 0.00465, "epss_percentile": 0.63766}, "CVE-2020-9614": {"epss_score": 0.00465, "epss_percentile": 0.63766}, "CVE-2020-9615": {"epss_score": 0.0036, "epss_percentile": 0.57678}, "CVE-2020-9616": {"epss_score": 0.02606, "epss_percentile": 0.85226}, "CVE-2020-9617": {"epss_score": 0.03272, "epss_percentile": 0.86797}, "CVE-2020-9618": {"epss_score": 0.01517, "epss_percentile": 0.80809}, "CVE-2020-9620": {"epss_score": 0.04593, "epss_percentile": 0.88894}, "CVE-2020-9621": {"epss_score": 0.05718, "epss_percentile": 0.90148}, "CVE-2020-9622": {"epss_score": 0.01913, "epss_percentile": 0.82841}, "CVE-2020-9623": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2020-9624": {"epss_score": 0.01913, "epss_percentile": 0.82841}, "CVE-2020-9625": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2020-9626": {"epss_score": 0.01763, "epss_percentile": 0.82156}, "CVE-2020-9627": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2020-9628": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2020-9629": {"epss_score": 0.01913, "epss_percentile": 0.82841}, "CVE-2020-9630": {"epss_score": 0.00844, "epss_percentile": 0.74274}, "CVE-2020-9631": {"epss_score": 0.07683, "epss_percentile": 0.91624}, "CVE-2020-9632": {"epss_score": 0.07985, "epss_percentile": 0.91804}, "CVE-2020-9633": {"epss_score": 0.08341, "epss_percentile": 0.91999}, "CVE-2020-9634": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-9635": {"epss_score": 0.15524, "epss_percentile": 0.94451}, "CVE-2020-9636": {"epss_score": 0.13725, "epss_percentile": 0.94044}, "CVE-2020-9637": {"epss_score": 0.05956, "epss_percentile": 0.90362}, "CVE-2020-9638": {"epss_score": 0.04787, "epss_percentile": 0.89144}, "CVE-2020-9639": {"epss_score": 0.01413, "epss_percentile": 0.80119}, "CVE-2020-9640": {"epss_score": 0.01413, "epss_percentile": 0.80119}, "CVE-2020-9641": {"epss_score": 0.01413, "epss_percentile": 0.80119}, "CVE-2020-9642": {"epss_score": 0.02702, "epss_percentile": 0.85457}, "CVE-2020-9643": {"epss_score": 0.01088, "epss_percentile": 0.77435}, "CVE-2020-9644": {"epss_score": 0.05965, "epss_percentile": 0.90369}, "CVE-2020-9645": {"epss_score": 0.01088, "epss_percentile": 0.77435}, "CVE-2020-9646": {"epss_score": 0.07653, "epss_percentile": 0.91606}, "CVE-2020-9647": {"epss_score": 0.14026, "epss_percentile": 0.94117}, "CVE-2020-9648": {"epss_score": 0.14026, "epss_percentile": 0.94117}, "CVE-2020-9649": {"epss_score": 0.02606, "epss_percentile": 0.85226}, "CVE-2020-9650": {"epss_score": 0.07653, "epss_percentile": 0.91606}, "CVE-2020-9651": {"epss_score": 0.14026, "epss_percentile": 0.94117}, "CVE-2020-9652": {"epss_score": 0.02299, "epss_percentile": 0.84306}, "CVE-2020-9653": {"epss_score": 0.02327, "epss_percentile": 0.84394}, "CVE-2020-9654": {"epss_score": 0.02327, "epss_percentile": 0.84394}, "CVE-2020-9655": {"epss_score": 0.06512, "epss_percentile": 0.90813}, "CVE-2020-9656": {"epss_score": 0.04903, "epss_percentile": 0.89275}, "CVE-2020-9657": {"epss_score": 0.02871, "epss_percentile": 0.85873}, "CVE-2020-9658": {"epss_score": 0.02871, "epss_percentile": 0.85873}, "CVE-2020-9659": {"epss_score": 0.02871, "epss_percentile": 0.85873}, "CVE-2020-9660": {"epss_score": 0.02995, "epss_percentile": 0.86155}, "CVE-2020-9661": {"epss_score": 0.03872, "epss_percentile": 0.87882}, "CVE-2020-9662": {"epss_score": 0.02995, "epss_percentile": 0.86155}, "CVE-2020-9663": {"epss_score": 0.00627, "epss_percentile": 0.69634}, "CVE-2020-9664": {"epss_score": 0.16149, "epss_percentile": 0.94579}, "CVE-2020-9665": {"epss_score": 0.00575, "epss_percentile": 0.68121}, "CVE-2020-9666": {"epss_score": 0.03272, "epss_percentile": 0.86797}, "CVE-2020-9667": {"epss_score": 0.00076, "epss_percentile": 0.23084}, "CVE-2020-9668": {"epss_score": 0.0086, "epss_percentile": 0.74526}, "CVE-2020-9669": {"epss_score": 0.00919, "epss_percentile": 0.75461}, "CVE-2020-9670": {"epss_score": 0.02866, "epss_percentile": 0.85862}, "CVE-2020-9671": {"epss_score": 0.00639, "epss_percentile": 0.69948}, "CVE-2020-9672": {"epss_score": 0.0015, "epss_percentile": 0.36081}, "CVE-2020-9673": {"epss_score": 0.0015, "epss_percentile": 0.36081}, "CVE-2020-9674": {"epss_score": 0.05207, "epss_percentile": 0.89612}, "CVE-2020-9675": {"epss_score": 0.0776, "epss_percentile": 0.91663}, "CVE-2020-9676": {"epss_score": 0.05207, "epss_percentile": 0.89612}, "CVE-2020-9677": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2020-9678": {"epss_score": 0.13607, "epss_percentile": 0.94011}, "CVE-2020-9679": {"epss_score": 0.23037, "epss_percentile": 0.95723}, "CVE-2020-9680": {"epss_score": 0.13607, "epss_percentile": 0.94011}, "CVE-2020-9681": {"epss_score": 0.00098, "epss_percentile": 0.27729}, "CVE-2020-9682": {"epss_score": 0.02944, "epss_percentile": 0.86037}, "CVE-2020-9683": {"epss_score": 0.2411, "epss_percentile": 0.95874}, "CVE-2020-9684": {"epss_score": 0.13607, "epss_percentile": 0.94011}, "CVE-2020-9685": {"epss_score": 0.13607, "epss_percentile": 0.94011}, "CVE-2020-9686": {"epss_score": 0.23037, "epss_percentile": 0.95723}, "CVE-2020-9687": {"epss_score": 0.13607, "epss_percentile": 0.94011}, "CVE-2020-9688": {"epss_score": 0.04506, "epss_percentile": 0.88771}, "CVE-2020-9689": {"epss_score": 0.00574, "epss_percentile": 0.68079}, "CVE-2020-9690": {"epss_score": 0.0047, "epss_percentile": 0.63962}, "CVE-2020-9691": {"epss_score": 0.00649, "epss_percentile": 0.70231}, "CVE-2020-9692": {"epss_score": 0.00234, "epss_percentile": 0.46172}, "CVE-2020-9693": {"epss_score": 0.04153, "epss_percentile": 0.88324}, "CVE-2020-9694": {"epss_score": 0.06479, "epss_percentile": 0.90784}, "CVE-2020-9696": {"epss_score": 0.00968, "epss_percentile": 0.76076}, "CVE-2020-9697": {"epss_score": 0.03272, "epss_percentile": 0.86797}, "CVE-2020-9698": {"epss_score": 0.06975, "epss_percentile": 0.91156}, "CVE-2020-9699": {"epss_score": 0.06512, "epss_percentile": 0.90813}, "CVE-2020-9700": {"epss_score": 0.06512, "epss_percentile": 0.90813}, "CVE-2020-9701": {"epss_score": 0.06512, "epss_percentile": 0.90813}, "CVE-2020-9702": {"epss_score": 0.00645, "epss_percentile": 0.70114}, "CVE-2020-9703": {"epss_score": 0.00645, "epss_percentile": 0.70114}, "CVE-2020-9704": {"epss_score": 0.06512, "epss_percentile": 0.90813}, "CVE-2020-9705": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2020-9706": {"epss_score": 0.01604, "epss_percentile": 0.81285}, "CVE-2020-9707": {"epss_score": 0.01604, "epss_percentile": 0.81285}, "CVE-2020-9708": {"epss_score": 0.03823, "epss_percentile": 0.87788}, "CVE-2020-9710": {"epss_score": 0.01604, "epss_percentile": 0.81285}, "CVE-2020-9712": {"epss_score": 0.00361, "epss_percentile": 0.57717}, "CVE-2020-9714": {"epss_score": 0.01801, "epss_percentile": 0.82329}, "CVE-2020-9715": {"epss_score": 0.56205, "epss_percentile": 0.98012}, "CVE-2020-9716": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2020-9717": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2020-9718": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2020-9719": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2020-9720": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2020-9721": {"epss_score": 0.03835, "epss_percentile": 0.87822}, "CVE-2020-9722": {"epss_score": 0.09593, "epss_percentile": 0.92614}, "CVE-2020-9723": {"epss_score": 0.02399, "epss_percentile": 0.84633}, "CVE-2020-9724": {"epss_score": 0.01334, "epss_percentile": 0.79533}, "CVE-2020-9725": {"epss_score": 0.11041, "epss_percentile": 0.93198}, "CVE-2020-9726": {"epss_score": 0.02882, "epss_percentile": 0.85902}, "CVE-2020-9727": {"epss_score": 0.03883, "epss_percentile": 0.879}, "CVE-2020-9728": {"epss_score": 0.03883, "epss_percentile": 0.879}, "CVE-2020-9729": {"epss_score": 0.03883, "epss_percentile": 0.879}, "CVE-2020-9730": {"epss_score": 0.03883, "epss_percentile": 0.879}, "CVE-2020-9731": {"epss_score": 0.02168, "epss_percentile": 0.83861}, "CVE-2020-9732": {"epss_score": 0.00702, "epss_percentile": 0.71526}, "CVE-2020-9733": {"epss_score": 0.00487, "epss_percentile": 0.64805}, "CVE-2020-9734": {"epss_score": 0.00485, "epss_percentile": 0.64707}, "CVE-2020-9735": {"epss_score": 0.0209, "epss_percentile": 0.83567}, "CVE-2020-9736": {"epss_score": 0.0209, "epss_percentile": 0.83567}, "CVE-2020-9737": {"epss_score": 0.0209, "epss_percentile": 0.83567}, "CVE-2020-9738": {"epss_score": 0.0209, "epss_percentile": 0.83567}, "CVE-2020-9739": {"epss_score": 0.01616, "epss_percentile": 0.81358}, "CVE-2020-9740": {"epss_score": 0.00485, "epss_percentile": 0.64707}, "CVE-2020-9741": {"epss_score": 0.00485, "epss_percentile": 0.64707}, "CVE-2020-9742": {"epss_score": 0.00872, "epss_percentile": 0.74728}, "CVE-2020-9743": {"epss_score": 0.03316, "epss_percentile": 0.869}, "CVE-2020-9744": {"epss_score": 0.01616, "epss_percentile": 0.81358}, "CVE-2020-9745": {"epss_score": 0.01616, "epss_percentile": 0.81358}, "CVE-2020-9746": {"epss_score": 0.01717, "epss_percentile": 0.81918}, "CVE-2020-9747": {"epss_score": 0.03919, "epss_percentile": 0.8795}, "CVE-2020-9748": {"epss_score": 0.09158, "epss_percentile": 0.92426}, "CVE-2020-9749": {"epss_score": 0.04018, "epss_percentile": 0.88126}, "CVE-2020-9750": {"epss_score": 0.04018, "epss_percentile": 0.88126}, "CVE-2020-9751": {"epss_score": 0.00147, "epss_percentile": 0.3568}, "CVE-2020-9752": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2020-9753": {"epss_score": 0.00172, "epss_percentile": 0.3896}, "CVE-2020-9754": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2020-9756": {"epss_score": 0.00081, "epss_percentile": 0.24387}, "CVE-2020-9757": {"epss_score": 0.94276, "epss_percentile": 0.99932}, "CVE-2020-9758": {"epss_score": 0.02418, "epss_percentile": 0.84697}, "CVE-2020-9759": {"epss_score": 0.00157, "epss_percentile": 0.37129}, "CVE-2020-9760": {"epss_score": 0.01053, "epss_percentile": 0.77101}, "CVE-2020-9761": {"epss_score": 0.00646, "epss_percentile": 0.7013}, "CVE-2020-9767": {"epss_score": 0.00193, "epss_percentile": 0.41458}, "CVE-2020-9768": {"epss_score": 0.00477, "epss_percentile": 0.64322}, "CVE-2020-9769": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2020-9770": {"epss_score": 0.00405, "epss_percentile": 0.60473}, "CVE-2020-9771": {"epss_score": 0.00118, "epss_percentile": 0.31518}, "CVE-2020-9772": {"epss_score": 0.00071, "epss_percentile": 0.2213}, "CVE-2020-9773": {"epss_score": 0.0019, "epss_percentile": 0.41108}, "CVE-2020-9774": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2020-9775": {"epss_score": 0.00206, "epss_percentile": 0.43053}, "CVE-2020-9776": {"epss_score": 0.0019, "epss_percentile": 0.41108}, "CVE-2020-9777": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2020-9779": {"epss_score": 0.00039, "epss_percentile": 0.11794}, "CVE-2020-9780": {"epss_score": 0.00048, "epss_percentile": 0.1512}, "CVE-2020-9781": {"epss_score": 0.00148, "epss_percentile": 0.3582}, "CVE-2020-9782": {"epss_score": 0.00487, "epss_percentile": 0.64783}, "CVE-2020-9783": {"epss_score": 0.00547, "epss_percentile": 0.67247}, "CVE-2020-9784": {"epss_score": 0.00255, "epss_percentile": 0.48671}, "CVE-2020-9785": {"epss_score": 0.00276, "epss_percentile": 0.50769}, "CVE-2020-9786": {"epss_score": 0.00238, "epss_percentile": 0.46825}, "CVE-2020-9787": {"epss_score": 0.00292, "epss_percentile": 0.52269}, "CVE-2020-9788": {"epss_score": 0.00179, "epss_percentile": 0.39807}, "CVE-2020-9789": {"epss_score": 0.0135, "epss_percentile": 0.79675}, "CVE-2020-9790": {"epss_score": 0.0135, "epss_percentile": 0.79675}, "CVE-2020-9791": {"epss_score": 0.00633, "epss_percentile": 0.69762}, "CVE-2020-9792": {"epss_score": 0.00046, "epss_percentile": 0.14333}, "CVE-2020-9793": {"epss_score": 0.01193, "epss_percentile": 0.7841}, "CVE-2020-9794": {"epss_score": 0.00959, "epss_percentile": 0.75956}, "CVE-2020-9795": {"epss_score": 0.00626, "epss_percentile": 0.69607}, "CVE-2020-9796": {"epss_score": 0.00036, "epss_percentile": 0.1038}, "CVE-2020-9797": {"epss_score": 0.00325, "epss_percentile": 0.55025}, "CVE-2020-9799": {"epss_score": 0.00245, "epss_percentile": 0.47647}, "CVE-2020-9800": {"epss_score": 0.00765, "epss_percentile": 0.72913}, "CVE-2020-9801": {"epss_score": 0.25648, "epss_percentile": 0.96053}, "CVE-2020-9802": {"epss_score": 0.41488, "epss_percentile": 0.97277}, "CVE-2020-9803": {"epss_score": 0.00256, "epss_percentile": 0.48818}, "CVE-2020-9804": {"epss_score": 0.00059, "epss_percentile": 0.18719}, "CVE-2020-9805": {"epss_score": 0.00866, "epss_percentile": 0.74635}, "CVE-2020-9806": {"epss_score": 0.00674, "epss_percentile": 0.7086}, "CVE-2020-9807": {"epss_score": 0.00229, "epss_percentile": 0.45614}, "CVE-2020-9808": {"epss_score": 0.00335, "epss_percentile": 0.5581}, "CVE-2020-9809": {"epss_score": 0.00297, "epss_percentile": 0.52703}, "CVE-2020-9810": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2020-9811": {"epss_score": 0.00325, "epss_percentile": 0.55025}, "CVE-2020-9812": {"epss_score": 0.00297, "epss_percentile": 0.52703}, "CVE-2020-9813": {"epss_score": 0.00484, "epss_percentile": 0.64656}, "CVE-2020-9814": {"epss_score": 0.00484, "epss_percentile": 0.64656}, "CVE-2020-9815": {"epss_score": 0.00633, "epss_percentile": 0.69762}, "CVE-2020-9816": {"epss_score": 0.00484, "epss_percentile": 0.64656}, "CVE-2020-9817": {"epss_score": 0.00106, "epss_percentile": 0.29444}, "CVE-2020-9818": {"epss_score": 0.00252, "epss_percentile": 0.48384}, "CVE-2020-9819": {"epss_score": 0.00196, "epss_percentile": 0.4181}, "CVE-2020-9820": {"epss_score": 0.00233, "epss_percentile": 0.46048}, "CVE-2020-9821": {"epss_score": 0.00533, "epss_percentile": 0.66756}, "CVE-2020-9822": {"epss_score": 0.00245, "epss_percentile": 0.47647}, "CVE-2020-9823": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-9824": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-9825": {"epss_score": 0.00189, "epss_percentile": 0.40946}, "CVE-2020-9826": {"epss_score": 0.00471, "epss_percentile": 0.64003}, "CVE-2020-9827": {"epss_score": 0.00821, "epss_percentile": 0.73905}, "CVE-2020-9828": {"epss_score": 0.00281, "epss_percentile": 0.51122}, "CVE-2020-9829": {"epss_score": 0.00614, "epss_percentile": 0.69277}, "CVE-2020-9830": {"epss_score": 0.00264, "epss_percentile": 0.49683}, "CVE-2020-9831": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2020-9832": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2020-9833": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2020-9834": {"epss_score": 0.00245, "epss_percentile": 0.47647}, "CVE-2020-9835": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2020-9837": {"epss_score": 0.00764, "epss_percentile": 0.72898}, "CVE-2020-9838": {"epss_score": 0.02126, "epss_percentile": 0.83694}, "CVE-2020-9839": {"epss_score": 0.35894, "epss_percentile": 0.9694}, "CVE-2020-9840": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2020-9841": {"epss_score": 0.00264, "epss_percentile": 0.49683}, "CVE-2020-9842": {"epss_score": 0.00331, "epss_percentile": 0.55505}, "CVE-2020-9843": {"epss_score": 0.00708, "epss_percentile": 0.71682}, "CVE-2020-9844": {"epss_score": 0.00528, "epss_percentile": 0.66569}, "CVE-2020-9846": {"epss_score": 0.00158, "epss_percentile": 0.37203}, "CVE-2020-9847": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2020-9848": {"epss_score": 0.00057, "epss_percentile": 0.18106}, "CVE-2020-9849": {"epss_score": 0.01069, "epss_percentile": 0.77249}, "CVE-2020-9850": {"epss_score": 0.82826, "epss_percentile": 0.99217}, "CVE-2020-9851": {"epss_score": 0.00194, "epss_percentile": 0.41528}, "CVE-2020-9852": {"epss_score": 0.00533, "epss_percentile": 0.66756}, "CVE-2020-9853": {"epss_score": 0.00255, "epss_percentile": 0.48722}, "CVE-2020-9854": {"epss_score": 0.00147, "epss_percentile": 0.35741}, "CVE-2020-9855": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2020-9856": {"epss_score": 0.18924, "epss_percentile": 0.95098}, "CVE-2020-9857": {"epss_score": 0.0025, "epss_percentile": 0.48248}, "CVE-2020-9858": {"epss_score": 0.00064, "epss_percentile": 0.20141}, "CVE-2020-9859": {"epss_score": 0.00168, "epss_percentile": 0.38518}, "CVE-2020-9860": {"epss_score": 0.00401, "epss_percentile": 0.6025}, "CVE-2020-9861": {"epss_score": 0.00248, "epss_percentile": 0.4791}, "CVE-2020-9862": {"epss_score": 0.00353, "epss_percentile": 0.57186}, "CVE-2020-9863": {"epss_score": 0.00287, "epss_percentile": 0.518}, "CVE-2020-9864": {"epss_score": 0.01139, "epss_percentile": 0.77942}, "CVE-2020-9865": {"epss_score": 0.00305, "epss_percentile": 0.53341}, "CVE-2020-9866": {"epss_score": 0.01214, "epss_percentile": 0.78575}, "CVE-2020-9868": {"epss_score": 0.00143, "epss_percentile": 0.35206}, "CVE-2020-9869": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2020-9870": {"epss_score": 0.00834, "epss_percentile": 0.741}, "CVE-2020-9871": {"epss_score": 0.00424, "epss_percentile": 0.61662}, "CVE-2020-9872": {"epss_score": 0.00312, "epss_percentile": 0.53983}, "CVE-2020-9873": {"epss_score": 0.00312, "epss_percentile": 0.53983}, "CVE-2020-9874": {"epss_score": 0.00424, "epss_percentile": 0.61662}, "CVE-2020-9875": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2020-9876": {"epss_score": 0.00418, "epss_percentile": 0.61343}, "CVE-2020-9877": {"epss_score": 0.00312, "epss_percentile": 0.53983}, "CVE-2020-9878": {"epss_score": 0.014, "epss_percentile": 0.80004}, "CVE-2020-9879": {"epss_score": 0.00424, "epss_percentile": 0.61662}, "CVE-2020-9880": {"epss_score": 0.00999, "epss_percentile": 0.76483}, "CVE-2020-9881": {"epss_score": 0.00999, "epss_percentile": 0.76483}, "CVE-2020-9882": {"epss_score": 0.00999, "epss_percentile": 0.76483}, "CVE-2020-9883": {"epss_score": 0.0106, "epss_percentile": 0.77163}, "CVE-2020-9884": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2020-9885": {"epss_score": 0.0011, "epss_percentile": 0.3017}, "CVE-2020-9887": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2020-9888": {"epss_score": 0.00462, "epss_percentile": 0.63586}, "CVE-2020-9889": {"epss_score": 0.00447, "epss_percentile": 0.62964}, "CVE-2020-9890": {"epss_score": 0.00462, "epss_percentile": 0.63586}, "CVE-2020-9891": {"epss_score": 0.00462, "epss_percentile": 0.63586}, "CVE-2020-9892": {"epss_score": 0.00243, "epss_percentile": 0.47454}, "CVE-2020-9893": {"epss_score": 0.00749, "epss_percentile": 0.72609}, "CVE-2020-9894": {"epss_score": 0.0066, "epss_percentile": 0.70536}, "CVE-2020-9895": {"epss_score": 0.02865, "epss_percentile": 0.8586}, "CVE-2020-9897": {"epss_score": 0.00299, "epss_percentile": 0.52848}, "CVE-2020-9898": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2020-9899": {"epss_score": 0.00245, "epss_percentile": 0.47647}, "CVE-2020-9900": {"epss_score": 0.00051, "epss_percentile": 0.16211}, "CVE-2020-9901": {"epss_score": 0.00049, "epss_percentile": 0.15587}, "CVE-2020-9902": {"epss_score": 0.00246, "epss_percentile": 0.47731}, "CVE-2020-9903": {"epss_score": 0.00098, "epss_percentile": 0.2783}, "CVE-2020-9904": {"epss_score": 0.00256, "epss_percentile": 0.48833}, "CVE-2020-9905": {"epss_score": 0.0121, "epss_percentile": 0.78552}, "CVE-2020-9906": {"epss_score": 0.01036, "epss_percentile": 0.76915}, "CVE-2020-9907": {"epss_score": 0.00607, "epss_percentile": 0.69061}, "CVE-2020-9908": {"epss_score": 0.00039, "epss_percentile": 0.11794}, "CVE-2020-9909": {"epss_score": 0.00771, "epss_percentile": 0.73026}, "CVE-2020-9910": {"epss_score": 0.0027, "epss_percentile": 0.50198}, "CVE-2020-9911": {"epss_score": 0.00334, "epss_percentile": 0.55694}, "CVE-2020-9912": {"epss_score": 0.00068, "epss_percentile": 0.21233}, "CVE-2020-9913": {"epss_score": 0.00048, "epss_percentile": 0.1518}, "CVE-2020-9914": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2020-9915": {"epss_score": 0.00775, "epss_percentile": 0.73088}, "CVE-2020-9916": {"epss_score": 0.00526, "epss_percentile": 0.66411}, "CVE-2020-9917": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2020-9918": {"epss_score": 0.01424, "epss_percentile": 0.80193}, "CVE-2020-9919": {"epss_score": 0.00794, "epss_percentile": 0.73441}, "CVE-2020-9920": {"epss_score": 0.00698, "epss_percentile": 0.71415}, "CVE-2020-9921": {"epss_score": 0.00038, "epss_percentile": 0.11385}, "CVE-2020-9922": {"epss_score": 0.00405, "epss_percentile": 0.60476}, "CVE-2020-9923": {"epss_score": 0.00209, "epss_percentile": 0.4332}, "CVE-2020-9924": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2020-9925": {"epss_score": 0.0076, "epss_percentile": 0.72804}, "CVE-2020-9926": {"epss_score": 0.00667, "epss_percentile": 0.70702}, "CVE-2020-9927": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2020-9928": {"epss_score": 0.00245, "epss_percentile": 0.47647}, "CVE-2020-9929": {"epss_score": 0.00046, "epss_percentile": 0.1442}, "CVE-2020-9930": {"epss_score": 0.00039, "epss_percentile": 0.11794}, "CVE-2020-9931": {"epss_score": 0.00441, "epss_percentile": 0.62672}, "CVE-2020-9932": {"epss_score": 0.00874, "epss_percentile": 0.74754}, "CVE-2020-9933": {"epss_score": 0.00216, "epss_percentile": 0.44224}, "CVE-2020-9934": {"epss_score": 0.02101, "epss_percentile": 0.83604}, "CVE-2020-9935": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2020-9936": {"epss_score": 0.00318, "epss_percentile": 0.54453}, "CVE-2020-9937": {"epss_score": 0.00424, "epss_percentile": 0.61662}, "CVE-2020-9938": {"epss_score": 0.00424, "epss_percentile": 0.61662}, "CVE-2020-9939": {"epss_score": 0.00043, "epss_percentile": 0.13309}, "CVE-2020-9940": {"epss_score": 0.00952, "epss_percentile": 0.75875}, "CVE-2020-9941": {"epss_score": 0.01467, "epss_percentile": 0.80473}, "CVE-2020-9942": {"epss_score": 0.00247, "epss_percentile": 0.4787}, "CVE-2020-9943": {"epss_score": 0.00302, "epss_percentile": 0.53139}, "CVE-2020-9944": {"epss_score": 0.00302, "epss_percentile": 0.53139}, "CVE-2020-9945": {"epss_score": 0.0034, "epss_percentile": 0.56259}, "CVE-2020-9946": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2020-9947": {"epss_score": 0.00809, "epss_percentile": 0.73705}, "CVE-2020-9948": {"epss_score": 0.00294, "epss_percentile": 0.52422}, "CVE-2020-9949": {"epss_score": 0.007, "epss_percentile": 0.71463}, "CVE-2020-9950": {"epss_score": 0.0078, "epss_percentile": 0.73171}, "CVE-2020-9951": {"epss_score": 0.01995, "epss_percentile": 0.83192}, "CVE-2020-9952": {"epss_score": 0.00475, "epss_percentile": 0.64172}, "CVE-2020-9954": {"epss_score": 0.0086, "epss_percentile": 0.74525}, "CVE-2020-9955": {"epss_score": 0.00371, "epss_percentile": 0.5836}, "CVE-2020-9956": {"epss_score": 0.00395, "epss_percentile": 0.59815}, "CVE-2020-9958": {"epss_score": 0.00179, "epss_percentile": 0.39807}, "CVE-2020-9959": {"epss_score": 0.00054, "epss_percentile": 0.17296}, "CVE-2020-9960": {"epss_score": 0.00395, "epss_percentile": 0.59815}, "CVE-2020-9961": {"epss_score": 0.00275, "epss_percentile": 0.50642}, "CVE-2020-9962": {"epss_score": 0.00766, "epss_percentile": 0.72931}, "CVE-2020-9963": {"epss_score": 0.00325, "epss_percentile": 0.55025}, "CVE-2020-9964": {"epss_score": 0.00048, "epss_percentile": 0.1518}, "CVE-2020-9965": {"epss_score": 0.00633, "epss_percentile": 0.69762}, "CVE-2020-9966": {"epss_score": 0.00788, "epss_percentile": 0.73336}, "CVE-2020-9967": {"epss_score": 0.01262, "epss_percentile": 0.78983}, "CVE-2020-9968": {"epss_score": 0.00303, "epss_percentile": 0.53186}, "CVE-2020-9969": {"epss_score": 0.00156, "epss_percentile": 0.36895}, "CVE-2020-9971": {"epss_score": 0.00428, "epss_percentile": 0.6192}, "CVE-2020-9972": {"epss_score": 0.02321, "epss_percentile": 0.84369}, "CVE-2020-9973": {"epss_score": 0.00248, "epss_percentile": 0.47955}, "CVE-2020-9974": {"epss_score": 0.00349, "epss_percentile": 0.56862}, "CVE-2020-9975": {"epss_score": 0.00522, "epss_percentile": 0.66273}, "CVE-2020-9976": {"epss_score": 0.00288, "epss_percentile": 0.51869}, "CVE-2020-9977": {"epss_score": 0.00359, "epss_percentile": 0.57597}, "CVE-2020-9978": {"epss_score": 0.00157, "epss_percentile": 0.37112}, "CVE-2020-9979": {"epss_score": 0.0012, "epss_percentile": 0.31748}, "CVE-2020-9980": {"epss_score": 0.00462, "epss_percentile": 0.63586}, "CVE-2020-9981": {"epss_score": 0.00395, "epss_percentile": 0.598}, "CVE-2020-9982": {"epss_score": 0.00278, "epss_percentile": 0.50905}, "CVE-2020-9983": {"epss_score": 0.02195, "epss_percentile": 0.83952}, "CVE-2020-9984": {"epss_score": 0.00424, "epss_percentile": 0.61662}, "CVE-2020-9985": {"epss_score": 0.00865, "epss_percentile": 0.74628}, "CVE-2020-9986": {"epss_score": 0.00182, "epss_percentile": 0.40265}, "CVE-2020-9987": {"epss_score": 0.00284, "epss_percentile": 0.51474}, "CVE-2020-9988": {"epss_score": 0.00148, "epss_percentile": 0.35824}, "CVE-2020-9989": {"epss_score": 0.00148, "epss_percentile": 0.35824}, "CVE-2020-9990": {"epss_score": 0.00047, "epss_percentile": 0.14844}, "CVE-2020-9991": {"epss_score": 0.02136, "epss_percentile": 0.83728}, "CVE-2020-9992": {"epss_score": 0.04184, "epss_percentile": 0.88359}, "CVE-2020-9993": {"epss_score": 0.00247, "epss_percentile": 0.4787}, "CVE-2020-9994": {"epss_score": 0.00284, "epss_percentile": 0.51487}, "CVE-2020-9995": {"epss_score": 0.00192, "epss_percentile": 0.41321}, "CVE-2020-9996": {"epss_score": 0.0031, "epss_percentile": 0.53752}, "CVE-2020-9997": {"epss_score": 0.00178, "epss_percentile": 0.39715}, "CVE-2020-9999": {"epss_score": 0.00688, "epss_percentile": 0.71191}, "CVE-2021-0001": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2021-0002": {"epss_score": 0.00069, "epss_percentile": 0.21515}, "CVE-2021-0003": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2021-0004": {"epss_score": 0.00056, "epss_percentile": 0.17679}, "CVE-2021-0005": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2021-0006": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2021-0007": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2021-0008": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2021-0009": {"epss_score": 0.00238, "epss_percentile": 0.46747}, "CVE-2021-0012": {"epss_score": 0.0017, "epss_percentile": 0.38736}, "CVE-2021-0013": {"epss_score": 0.00286, "epss_percentile": 0.51696}, "CVE-2021-0051": {"epss_score": 0.00049, "epss_percentile": 0.15309}, "CVE-2021-0052": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2021-0053": {"epss_score": 0.00096, "epss_percentile": 0.27388}, "CVE-2021-0054": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2021-0055": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-0056": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-0057": {"epss_score": 0.00071, "epss_percentile": 0.22157}, "CVE-2021-0058": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-0060": {"epss_score": 0.00231, "epss_percentile": 0.45854}, "CVE-2021-0061": {"epss_score": 0.00148, "epss_percentile": 0.35828}, "CVE-2021-0062": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-0063": {"epss_score": 0.00067, "epss_percentile": 0.21084}, "CVE-2021-0064": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-0065": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-0066": {"epss_score": 0.00114, "epss_percentile": 0.30866}, "CVE-2021-0067": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2021-0069": {"epss_score": 0.00078, "epss_percentile": 0.23747}, "CVE-2021-0070": {"epss_score": 0.00113, "epss_percentile": 0.3069}, "CVE-2021-0071": {"epss_score": 0.00221, "epss_percentile": 0.44659}, "CVE-2021-0072": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2021-0073": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-0074": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-0075": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-0076": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-0077": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-0078": {"epss_score": 0.00084, "epss_percentile": 0.24904}, "CVE-2021-0079": {"epss_score": 0.00067, "epss_percentile": 0.21084}, "CVE-2021-0082": {"epss_score": 0.00071, "epss_percentile": 0.22157}, "CVE-2021-0083": {"epss_score": 0.00049, "epss_percentile": 0.15309}, "CVE-2021-0084": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-0086": {"epss_score": 0.001, "epss_percentile": 0.2846}, "CVE-2021-0089": {"epss_score": 0.00044, "epss_percentile": 0.1339}, "CVE-2021-0090": {"epss_score": 0.00154, "epss_percentile": 0.36653}, "CVE-2021-0091": {"epss_score": 0.00356, "epss_percentile": 0.57328}, "CVE-2021-0092": {"epss_score": 0.00148, "epss_percentile": 0.359}, "CVE-2021-0093": {"epss_score": 0.00091, "epss_percentile": 0.26226}, "CVE-2021-0094": {"epss_score": 0.00062, "epss_percentile": 0.19562}, "CVE-2021-0095": {"epss_score": 0.00123, "epss_percentile": 0.32337}, "CVE-2021-0096": {"epss_score": 0.0005, "epss_percentile": 0.15763}, "CVE-2021-0097": {"epss_score": 0.00261, "epss_percentile": 0.49279}, "CVE-2021-0098": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-0099": {"epss_score": 0.00241, "epss_percentile": 0.47262}, "CVE-2021-0100": {"epss_score": 0.00039, "epss_percentile": 0.11612}, "CVE-2021-0101": {"epss_score": 0.0014, "epss_percentile": 0.34673}, "CVE-2021-0102": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-0103": {"epss_score": 0.00249, "epss_percentile": 0.48009}, "CVE-2021-0104": {"epss_score": 0.00103, "epss_percentile": 0.28922}, "CVE-2021-0105": {"epss_score": 0.00074, "epss_percentile": 0.22855}, "CVE-2021-0106": {"epss_score": 0.00039, "epss_percentile": 0.11612}, "CVE-2021-0107": {"epss_score": 0.00249, "epss_percentile": 0.48009}, "CVE-2021-0108": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2021-0109": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-0110": {"epss_score": 0.00063, "epss_percentile": 0.19849}, "CVE-2021-0111": {"epss_score": 0.00249, "epss_percentile": 0.48009}, "CVE-2021-0112": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-0113": {"epss_score": 0.00121, "epss_percentile": 0.31876}, "CVE-2021-0114": {"epss_score": 0.0012, "epss_percentile": 0.31716}, "CVE-2021-0115": {"epss_score": 0.00271, "epss_percentile": 0.50318}, "CVE-2021-0116": {"epss_score": 0.00301, "epss_percentile": 0.53073}, "CVE-2021-0117": {"epss_score": 0.00301, "epss_percentile": 0.53073}, "CVE-2021-0118": {"epss_score": 0.00236, "epss_percentile": 0.46415}, "CVE-2021-0119": {"epss_score": 0.00256, "epss_percentile": 0.48826}, "CVE-2021-0120": {"epss_score": 0.00179, "epss_percentile": 0.39783}, "CVE-2021-0121": {"epss_score": 0.00148, "epss_percentile": 0.35828}, "CVE-2021-0124": {"epss_score": 0.00301, "epss_percentile": 0.53073}, "CVE-2021-0125": {"epss_score": 0.00301, "epss_percentile": 0.53073}, "CVE-2021-0126": {"epss_score": 0.00131, "epss_percentile": 0.33371}, "CVE-2021-0127": {"epss_score": 0.00073, "epss_percentile": 0.22663}, "CVE-2021-0129": {"epss_score": 0.00177, "epss_percentile": 0.39592}, "CVE-2021-0131": {"epss_score": 0.00328, "epss_percentile": 0.55177}, "CVE-2021-0132": {"epss_score": 0.0026, "epss_percentile": 0.49177}, "CVE-2021-0133": {"epss_score": 0.00267, "epss_percentile": 0.49992}, "CVE-2021-0134": {"epss_score": 0.0026, "epss_percentile": 0.49177}, "CVE-2021-0135": {"epss_score": 0.00133, "epss_percentile": 0.33642}, "CVE-2021-0143": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-0144": {"epss_score": 0.00121, "epss_percentile": 0.31891}, "CVE-2021-0145": {"epss_score": 0.00178, "epss_percentile": 0.39707}, "CVE-2021-0146": {"epss_score": 0.00269, "epss_percentile": 0.50149}, "CVE-2021-0147": {"epss_score": 0.00038, "epss_percentile": 0.11114}, "CVE-2021-0148": {"epss_score": 0.00058, "epss_percentile": 0.18373}, "CVE-2021-0151": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-0152": {"epss_score": 0.00024, "epss_percentile": 0.05691}, "CVE-2021-0153": {"epss_score": 0.00157, "epss_percentile": 0.37026}, "CVE-2021-0154": {"epss_score": 0.00115, "epss_percentile": 0.31005}, "CVE-2021-0155": {"epss_score": 0.00137, "epss_percentile": 0.34303}, "CVE-2021-0156": {"epss_score": 0.00241, "epss_percentile": 0.47262}, "CVE-2021-0157": {"epss_score": 0.01754, "epss_percentile": 0.82116}, "CVE-2021-0158": {"epss_score": 0.00084, "epss_percentile": 0.2494}, "CVE-2021-0159": {"epss_score": 0.00115, "epss_percentile": 0.31005}, "CVE-2021-0160": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2021-0161": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2021-0162": {"epss_score": 0.00221, "epss_percentile": 0.44659}, "CVE-2021-0163": {"epss_score": 0.00221, "epss_percentile": 0.44659}, "CVE-2021-0164": {"epss_score": 0.0014, "epss_percentile": 0.34712}, "CVE-2021-0165": {"epss_score": 0.00153, "epss_percentile": 0.36531}, "CVE-2021-0166": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2021-0167": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2021-0168": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2021-0169": {"epss_score": 0.00074, "epss_percentile": 0.22748}, "CVE-2021-0170": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2021-0171": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2021-0172": {"epss_score": 0.00153, "epss_percentile": 0.36531}, "CVE-2021-0173": {"epss_score": 0.00153, "epss_percentile": 0.36531}, "CVE-2021-0174": {"epss_score": 0.00153, "epss_percentile": 0.36531}, "CVE-2021-0175": {"epss_score": 0.00153, "epss_percentile": 0.36531}, "CVE-2021-0176": {"epss_score": 0.00134, "epss_percentile": 0.33831}, "CVE-2021-0177": {"epss_score": 0.00153, "epss_percentile": 0.36531}, "CVE-2021-0178": {"epss_score": 0.00153, "epss_percentile": 0.36531}, "CVE-2021-0179": {"epss_score": 0.00348, "epss_percentile": 0.56825}, "CVE-2021-0180": {"epss_score": 0.00147, "epss_percentile": 0.3578}, "CVE-2021-0182": {"epss_score": 0.00165, "epss_percentile": 0.38117}, "CVE-2021-0183": {"epss_score": 0.00179, "epss_percentile": 0.39848}, "CVE-2021-0185": {"epss_score": 0.00058, "epss_percentile": 0.18451}, "CVE-2021-0186": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2021-0187": {"epss_score": 0.00041, "epss_percentile": 0.12442}, "CVE-2021-0188": {"epss_score": 0.00177, "epss_percentile": 0.39599}, "CVE-2021-0189": {"epss_score": 0.00142, "epss_percentile": 0.35081}, "CVE-2021-0190": {"epss_score": 0.00177, "epss_percentile": 0.39599}, "CVE-2021-0193": {"epss_score": 0.00314, "epss_percentile": 0.54155}, "CVE-2021-0194": {"epss_score": 0.00404, "epss_percentile": 0.60449}, "CVE-2021-0196": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-0197": {"epss_score": 0.00059, "epss_percentile": 0.18643}, "CVE-2021-0198": {"epss_score": 0.00059, "epss_percentile": 0.18643}, "CVE-2021-0199": {"epss_score": 0.00043, "epss_percentile": 0.1323}, "CVE-2021-0200": {"epss_score": 0.00091, "epss_percentile": 0.262}, "CVE-2021-0202": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-0203": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-0204": {"epss_score": 0.00026, "epss_percentile": 0.06417}, "CVE-2021-0205": {"epss_score": 0.00229, "epss_percentile": 0.45622}, "CVE-2021-0206": {"epss_score": 0.0039, "epss_percentile": 0.59533}, "CVE-2021-0207": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-0208": {"epss_score": 0.00167, "epss_percentile": 0.38293}, "CVE-2021-0209": {"epss_score": 0.00076, "epss_percentile": 0.23113}, "CVE-2021-0210": {"epss_score": 0.00416, "epss_percentile": 0.61178}, "CVE-2021-0211": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-0212": {"epss_score": 0.00037, "epss_percentile": 0.10861}, "CVE-2021-0214": {"epss_score": 0.00031, "epss_percentile": 0.08693}, "CVE-2021-0215": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-0216": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-0217": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-0218": {"epss_score": 0.00349, "epss_percentile": 0.56876}, "CVE-2021-0219": {"epss_score": 0.00037, "epss_percentile": 0.1067}, "CVE-2021-0220": {"epss_score": 0.00275, "epss_percentile": 0.50691}, "CVE-2021-0221": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-0222": {"epss_score": 0.00042, "epss_percentile": 0.12791}, "CVE-2021-0223": {"epss_score": 0.00035, "epss_percentile": 0.09885}, "CVE-2021-0224": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-0225": {"epss_score": 0.00187, "epss_percentile": 0.40781}, "CVE-2021-0226": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2021-0227": {"epss_score": 0.01187, "epss_percentile": 0.78357}, "CVE-2021-0228": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-0229": {"epss_score": 0.00526, "epss_percentile": 0.66399}, "CVE-2021-0230": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-0231": {"epss_score": 0.00267, "epss_percentile": 0.49979}, "CVE-2021-0232": {"epss_score": 0.00451, "epss_percentile": 0.63118}, "CVE-2021-0233": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2021-0234": {"epss_score": 0.00268, "epss_percentile": 0.50041}, "CVE-2021-0235": {"epss_score": 0.00051, "epss_percentile": 0.15994}, "CVE-2021-0236": {"epss_score": 0.00222, "epss_percentile": 0.4473}, "CVE-2021-0237": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-0238": {"epss_score": 0.00045, "epss_percentile": 0.1375}, "CVE-2021-0239": {"epss_score": 0.002, "epss_percentile": 0.4227}, "CVE-2021-0240": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-0241": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-0242": {"epss_score": 0.00076, "epss_percentile": 0.23113}, "CVE-2021-0243": {"epss_score": 0.00078, "epss_percentile": 0.23627}, "CVE-2021-0244": {"epss_score": 0.00207, "epss_percentile": 0.43204}, "CVE-2021-0245": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2021-0246": {"epss_score": 0.00038, "epss_percentile": 0.11338}, "CVE-2021-0247": {"epss_score": 0.00231, "epss_percentile": 0.45775}, "CVE-2021-0248": {"epss_score": 0.0042, "epss_percentile": 0.6141}, "CVE-2021-0249": {"epss_score": 0.00423, "epss_percentile": 0.61619}, "CVE-2021-0250": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-0251": {"epss_score": 0.0039, "epss_percentile": 0.59533}, "CVE-2021-0252": {"epss_score": 0.00165, "epss_percentile": 0.38127}, "CVE-2021-0253": {"epss_score": 0.00438, "epss_percentile": 0.6257}, "CVE-2021-0254": {"epss_score": 0.0064, "epss_percentile": 0.69966}, "CVE-2021-0255": {"epss_score": 0.00021, "epss_percentile": 0.04696}, "CVE-2021-0256": {"epss_score": 0.00035, "epss_percentile": 0.09818}, "CVE-2021-0257": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-0258": {"epss_score": 0.00202, "epss_percentile": 0.42397}, "CVE-2021-0259": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-0260": {"epss_score": 0.00668, "epss_percentile": 0.70737}, "CVE-2021-0261": {"epss_score": 0.00438, "epss_percentile": 0.62567}, "CVE-2021-0262": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-0263": {"epss_score": 0.00312, "epss_percentile": 0.53957}, "CVE-2021-0264": {"epss_score": 0.00241, "epss_percentile": 0.47329}, "CVE-2021-0265": {"epss_score": 0.05431, "epss_percentile": 0.89876}, "CVE-2021-0266": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2021-0267": {"epss_score": 0.00056, "epss_percentile": 0.17726}, "CVE-2021-0268": {"epss_score": 0.00268, "epss_percentile": 0.50078}, "CVE-2021-0269": {"epss_score": 0.00375, "epss_percentile": 0.58602}, "CVE-2021-0270": {"epss_score": 0.00334, "epss_percentile": 0.55707}, "CVE-2021-0271": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-0272": {"epss_score": 0.00066, "epss_percentile": 0.20808}, "CVE-2021-0273": {"epss_score": 0.00268, "epss_percentile": 0.50041}, "CVE-2021-0275": {"epss_score": 0.00531, "epss_percentile": 0.6667}, "CVE-2021-0276": {"epss_score": 0.02629, "epss_percentile": 0.85275}, "CVE-2021-0277": {"epss_score": 0.00231, "epss_percentile": 0.45809}, "CVE-2021-0278": {"epss_score": 0.00167, "epss_percentile": 0.38379}, "CVE-2021-0279": {"epss_score": 0.00311, "epss_percentile": 0.53818}, "CVE-2021-0280": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-0281": {"epss_score": 0.00277, "epss_percentile": 0.50844}, "CVE-2021-0282": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2021-0283": {"epss_score": 0.00437, "epss_percentile": 0.62498}, "CVE-2021-0284": {"epss_score": 0.00437, "epss_percentile": 0.62498}, "CVE-2021-0285": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-0286": {"epss_score": 0.00153, "epss_percentile": 0.36593}, "CVE-2021-0287": {"epss_score": 0.00076, "epss_percentile": 0.23113}, "CVE-2021-0288": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-0289": {"epss_score": 0.00063, "epss_percentile": 0.19806}, "CVE-2021-0290": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-0291": {"epss_score": 0.00285, "epss_percentile": 0.5164}, "CVE-2021-0292": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-0293": {"epss_score": 0.00047, "epss_percentile": 0.14662}, "CVE-2021-0294": {"epss_score": 0.0023, "epss_percentile": 0.45666}, "CVE-2021-0295": {"epss_score": 0.00106, "epss_percentile": 0.29439}, "CVE-2021-0296": {"epss_score": 0.00124, "epss_percentile": 0.32434}, "CVE-2021-0297": {"epss_score": 0.00184, "epss_percentile": 0.40458}, "CVE-2021-0298": {"epss_score": 0.00033, "epss_percentile": 0.09197}, "CVE-2021-0299": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2021-0301": {"epss_score": 0.00015, "epss_percentile": 0.02557}, "CVE-2021-0302": {"epss_score": 0.00064, "epss_percentile": 0.20305}, "CVE-2021-0303": {"epss_score": 0.00012, "epss_percentile": 0.01119}, "CVE-2021-0304": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-0305": {"epss_score": 0.00057, "epss_percentile": 0.18129}, "CVE-2021-0306": {"epss_score": 0.0001, "epss_percentile": 0.00853}, "CVE-2021-0307": {"epss_score": 0.00031, "epss_percentile": 0.08497}, "CVE-2021-0308": {"epss_score": 0.00067, "epss_percentile": 0.21075}, "CVE-2021-0309": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-0310": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2021-0311": {"epss_score": 0.00198, "epss_percentile": 0.42024}, "CVE-2021-0312": {"epss_score": 0.00198, "epss_percentile": 0.42024}, "CVE-2021-0313": {"epss_score": 0.03739, "epss_percentile": 0.87654}, "CVE-2021-0314": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-0315": {"epss_score": 0.00026, "epss_percentile": 0.06405}, "CVE-2021-0316": {"epss_score": 0.0505, "epss_percentile": 0.8944}, "CVE-2021-0317": {"epss_score": 0.00047, "epss_percentile": 0.14575}, "CVE-2021-0318": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2021-0319": {"epss_score": 0.00012, "epss_percentile": 0.01276}, "CVE-2021-0320": {"epss_score": 0.00013, "epss_percentile": 0.01546}, "CVE-2021-0321": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-0322": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2021-0324": {"epss_score": 0.0017, "epss_percentile": 0.38684}, "CVE-2021-0325": {"epss_score": 0.041, "epss_percentile": 0.88257}, "CVE-2021-0326": {"epss_score": 0.11512, "epss_percentile": 0.93389}, "CVE-2021-0327": {"epss_score": 8e-05, "epss_percentile": 0.00586}, "CVE-2021-0328": {"epss_score": 0.00022, "epss_percentile": 0.05013}, "CVE-2021-0329": {"epss_score": 0.00027, "epss_percentile": 0.06979}, "CVE-2021-0330": {"epss_score": 0.00029, "epss_percentile": 0.07778}, "CVE-2021-0331": {"epss_score": 0.00032, "epss_percentile": 0.09007}, "CVE-2021-0332": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2021-0333": {"epss_score": 0.00012, "epss_percentile": 0.01141}, "CVE-2021-0334": {"epss_score": 8e-05, "epss_percentile": 0.00555}, "CVE-2021-0335": {"epss_score": 0.00286, "epss_percentile": 0.5174}, "CVE-2021-0336": {"epss_score": 0.00012, "epss_percentile": 0.01141}, "CVE-2021-0337": {"epss_score": 0.00019, "epss_percentile": 0.04168}, "CVE-2021-0338": {"epss_score": 0.00012, "epss_percentile": 0.01306}, "CVE-2021-0339": {"epss_score": 0.00086, "epss_percentile": 0.25313}, "CVE-2021-0340": {"epss_score": 0.02617, "epss_percentile": 0.85249}, "CVE-2021-0341": {"epss_score": 0.01174, "epss_percentile": 0.7825}, "CVE-2021-0342": {"epss_score": 0.00026, "epss_percentile": 0.06412}, "CVE-2021-0343": {"epss_score": 0.00012, "epss_percentile": 0.01426}, "CVE-2021-0344": {"epss_score": 0.00014, "epss_percentile": 0.02095}, "CVE-2021-0345": {"epss_score": 0.00014, "epss_percentile": 0.02095}, "CVE-2021-0346": {"epss_score": 0.00014, "epss_percentile": 0.02095}, "CVE-2021-0347": {"epss_score": 0.00017, "epss_percentile": 0.03267}, "CVE-2021-0348": {"epss_score": 0.00014, "epss_percentile": 0.02095}, "CVE-2021-0349": {"epss_score": 0.00019, "epss_percentile": 0.0424}, "CVE-2021-0350": {"epss_score": 0.00017, "epss_percentile": 0.03326}, "CVE-2021-0351": {"epss_score": 0.00704, "epss_percentile": 0.71566}, "CVE-2021-0352": {"epss_score": 0.00015, "epss_percentile": 0.0239}, "CVE-2021-0353": {"epss_score": 0.0001, "epss_percentile": 0.00831}, "CVE-2021-0354": {"epss_score": 0.0002, "epss_percentile": 0.04545}, "CVE-2021-0355": {"epss_score": 0.0002, "epss_percentile": 0.04422}, "CVE-2021-0356": {"epss_score": 0.00117, "epss_percentile": 0.31285}, "CVE-2021-0357": {"epss_score": 0.00019, "epss_percentile": 0.0441}, "CVE-2021-0358": {"epss_score": 0.00117, "epss_percentile": 0.31285}, "CVE-2021-0359": {"epss_score": 0.00019, "epss_percentile": 0.0441}, "CVE-2021-0360": {"epss_score": 0.00019, "epss_percentile": 0.0441}, "CVE-2021-0361": {"epss_score": 0.00017, "epss_percentile": 0.03193}, "CVE-2021-0362": {"epss_score": 9e-05, "epss_percentile": 0.00644}, "CVE-2021-0363": {"epss_score": 0.00087, "epss_percentile": 0.256}, "CVE-2021-0364": {"epss_score": 0.00117, "epss_percentile": 0.31285}, "CVE-2021-0365": {"epss_score": 0.00023, "epss_percentile": 0.05406}, "CVE-2021-0366": {"epss_score": 0.00029, "epss_percentile": 0.07896}, "CVE-2021-0367": {"epss_score": 0.00029, "epss_percentile": 0.07896}, "CVE-2021-0368": {"epss_score": 0.00215, "epss_percentile": 0.441}, "CVE-2021-0369": {"epss_score": 0.00016, "epss_percentile": 0.02757}, "CVE-2021-0370": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-0371": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-0372": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0374": {"epss_score": 0.00014, "epss_percentile": 0.02094}, "CVE-2021-0375": {"epss_score": 0.00014, "epss_percentile": 0.01847}, "CVE-2021-0376": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2021-0377": {"epss_score": 0.00015, "epss_percentile": 0.02467}, "CVE-2021-0378": {"epss_score": 0.0041, "epss_percentile": 0.60825}, "CVE-2021-0379": {"epss_score": 0.00362, "epss_percentile": 0.57811}, "CVE-2021-0380": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0381": {"epss_score": 0.00014, "epss_percentile": 0.01894}, "CVE-2021-0382": {"epss_score": 0.00014, "epss_percentile": 0.01894}, "CVE-2021-0383": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-0385": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0386": {"epss_score": 0.00049, "epss_percentile": 0.15602}, "CVE-2021-0387": {"epss_score": 0.00011, "epss_percentile": 0.01044}, "CVE-2021-0388": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0389": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0390": {"epss_score": 0.00067, "epss_percentile": 0.21184}, "CVE-2021-0391": {"epss_score": 0.00052, "epss_percentile": 0.16613}, "CVE-2021-0392": {"epss_score": 0.00029, "epss_percentile": 0.07941}, "CVE-2021-0393": {"epss_score": 0.0191, "epss_percentile": 0.82826}, "CVE-2021-0394": {"epss_score": 0.00079, "epss_percentile": 0.23956}, "CVE-2021-0395": {"epss_score": 0.00018, "epss_percentile": 0.03602}, "CVE-2021-0396": {"epss_score": 0.06242, "epss_percentile": 0.90597}, "CVE-2021-0397": {"epss_score": 0.1356, "epss_percentile": 0.93997}, "CVE-2021-0398": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-0399": {"epss_score": 0.00756, "epss_percentile": 0.7273}, "CVE-2021-0400": {"epss_score": 0.00027, "epss_percentile": 0.06985}, "CVE-2021-0401": {"epss_score": 0.00026, "epss_percentile": 0.06487}, "CVE-2021-0402": {"epss_score": 0.0005, "epss_percentile": 0.15706}, "CVE-2021-0403": {"epss_score": 0.00014, "epss_percentile": 0.01997}, "CVE-2021-0404": {"epss_score": 0.00019, "epss_percentile": 0.04295}, "CVE-2021-0405": {"epss_score": 0.0005, "epss_percentile": 0.15706}, "CVE-2021-0406": {"epss_score": 0.00045, "epss_percentile": 0.13763}, "CVE-2021-0407": {"epss_score": 0.00019, "epss_percentile": 0.0441}, "CVE-2021-0408": {"epss_score": 0.00017, "epss_percentile": 0.03211}, "CVE-2021-0409": {"epss_score": 0.00015, "epss_percentile": 0.02157}, "CVE-2021-0410": {"epss_score": 0.00015, "epss_percentile": 0.02157}, "CVE-2021-0411": {"epss_score": 0.00017, "epss_percentile": 0.03225}, "CVE-2021-0412": {"epss_score": 0.00015, "epss_percentile": 0.02157}, "CVE-2021-0413": {"epss_score": 0.00015, "epss_percentile": 0.02157}, "CVE-2021-0414": {"epss_score": 0.00012, "epss_percentile": 0.01274}, "CVE-2021-0415": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2021-0416": {"epss_score": 0.00018, "epss_percentile": 0.03887}, "CVE-2021-0417": {"epss_score": 0.00018, "epss_percentile": 0.03887}, "CVE-2021-0418": {"epss_score": 0.00018, "epss_percentile": 0.03887}, "CVE-2021-0419": {"epss_score": 0.00018, "epss_percentile": 0.03887}, "CVE-2021-0420": {"epss_score": 0.00018, "epss_percentile": 0.03887}, "CVE-2021-0421": {"epss_score": 0.00015, "epss_percentile": 0.02334}, "CVE-2021-0422": {"epss_score": 0.00013, "epss_percentile": 0.01691}, "CVE-2021-0423": {"epss_score": 0.00015, "epss_percentile": 0.02334}, "CVE-2021-0424": {"epss_score": 0.00013, "epss_percentile": 0.01691}, "CVE-2021-0425": {"epss_score": 0.00015, "epss_percentile": 0.02334}, "CVE-2021-0426": {"epss_score": 0.00016, "epss_percentile": 0.02804}, "CVE-2021-0427": {"epss_score": 0.00016, "epss_percentile": 0.02804}, "CVE-2021-0428": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-0429": {"epss_score": 0.00034, "epss_percentile": 0.09517}, "CVE-2021-0430": {"epss_score": 0.01493, "epss_percentile": 0.80638}, "CVE-2021-0431": {"epss_score": 0.01559, "epss_percentile": 0.81032}, "CVE-2021-0432": {"epss_score": 0.00014, "epss_percentile": 0.01827}, "CVE-2021-0433": {"epss_score": 8e-05, "epss_percentile": 0.00586}, "CVE-2021-0434": {"epss_score": 0.0003, "epss_percentile": 0.08113}, "CVE-2021-0435": {"epss_score": 0.01559, "epss_percentile": 0.81032}, "CVE-2021-0436": {"epss_score": 0.00029, "epss_percentile": 0.0791}, "CVE-2021-0437": {"epss_score": 0.00026, "epss_percentile": 0.06598}, "CVE-2021-0438": {"epss_score": 0.00029, "epss_percentile": 0.07946}, "CVE-2021-0439": {"epss_score": 0.00031, "epss_percentile": 0.08335}, "CVE-2021-0441": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0442": {"epss_score": 0.00018, "epss_percentile": 0.03602}, "CVE-2021-0443": {"epss_score": 0.00025, "epss_percentile": 0.06285}, "CVE-2021-0444": {"epss_score": 0.00035, "epss_percentile": 0.1013}, "CVE-2021-0445": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-0446": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0449": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2021-0450": {"epss_score": 0.00016, "epss_percentile": 0.02929}, "CVE-2021-0451": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2021-0452": {"epss_score": 0.00016, "epss_percentile": 0.02929}, "CVE-2021-0453": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2021-0454": {"epss_score": 0.00014, "epss_percentile": 0.01848}, "CVE-2021-0455": {"epss_score": 0.00014, "epss_percentile": 0.01848}, "CVE-2021-0456": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2021-0457": {"epss_score": 0.00015, "epss_percentile": 0.02549}, "CVE-2021-0458": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2021-0459": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2021-0460": {"epss_score": 0.00016, "epss_percentile": 0.02929}, "CVE-2021-0461": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-0462": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-0463": {"epss_score": 0.00017, "epss_percentile": 0.03104}, "CVE-2021-0464": {"epss_score": 0.00016, "epss_percentile": 0.02804}, "CVE-2021-0465": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-0466": {"epss_score": 0.00576, "epss_percentile": 0.6814}, "CVE-2021-0467": {"epss_score": 0.00032, "epss_percentile": 0.09025}, "CVE-2021-0468": {"epss_score": 0.00033, "epss_percentile": 0.09199}, "CVE-2021-0471": {"epss_score": 0.00026, "epss_percentile": 0.0672}, "CVE-2021-0472": {"epss_score": 0.00012, "epss_percentile": 0.01276}, "CVE-2021-0473": {"epss_score": 0.0055, "epss_percentile": 0.67343}, "CVE-2021-0474": {"epss_score": 0.03883, "epss_percentile": 0.87898}, "CVE-2021-0475": {"epss_score": 0.00574, "epss_percentile": 0.68079}, "CVE-2021-0476": {"epss_score": 0.00028, "epss_percentile": 0.07534}, "CVE-2021-0477": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-0478": {"epss_score": 0.00015, "epss_percentile": 0.02277}, "CVE-2021-0480": {"epss_score": 0.00069, "epss_percentile": 0.21631}, "CVE-2021-0481": {"epss_score": 0.00059, "epss_percentile": 0.18663}, "CVE-2021-0482": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2021-0483": {"epss_score": 0.00014, "epss_percentile": 0.01827}, "CVE-2021-0484": {"epss_score": 0.00026, "epss_percentile": 0.0672}, "CVE-2021-0485": {"epss_score": 7e-05, "epss_percentile": 0.00339}, "CVE-2021-0486": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2021-0487": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-0488": {"epss_score": 0.00012, "epss_percentile": 0.01308}, "CVE-2021-0489": {"epss_score": 0.00014, "epss_percentile": 0.01814}, "CVE-2021-0490": {"epss_score": 0.0001, "epss_percentile": 0.00864}, "CVE-2021-0491": {"epss_score": 0.00013, "epss_percentile": 0.0151}, "CVE-2021-0492": {"epss_score": 0.00014, "epss_percentile": 0.01814}, "CVE-2021-0493": {"epss_score": 0.00014, "epss_percentile": 0.01814}, "CVE-2021-0494": {"epss_score": 0.00016, "epss_percentile": 0.02771}, "CVE-2021-0495": {"epss_score": 0.00014, "epss_percentile": 0.0201}, "CVE-2021-0496": {"epss_score": 0.00016, "epss_percentile": 0.0283}, "CVE-2021-0497": {"epss_score": 0.00016, "epss_percentile": 0.0283}, "CVE-2021-0498": {"epss_score": 0.00014, "epss_percentile": 0.01814}, "CVE-2021-0504": {"epss_score": 0.00091, "epss_percentile": 0.26282}, "CVE-2021-0505": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-0506": {"epss_score": 0.00011, "epss_percentile": 0.01015}, "CVE-2021-0507": {"epss_score": 0.01092, "epss_percentile": 0.77467}, "CVE-2021-0508": {"epss_score": 0.00029, "epss_percentile": 0.07644}, "CVE-2021-0509": {"epss_score": 0.00029, "epss_percentile": 0.07644}, "CVE-2021-0510": {"epss_score": 0.00027, "epss_percentile": 0.06979}, "CVE-2021-0511": {"epss_score": 0.00035, "epss_percentile": 0.09817}, "CVE-2021-0512": {"epss_score": 0.00036, "epss_percentile": 0.10449}, "CVE-2021-0513": {"epss_score": 0.00014, "epss_percentile": 0.01872}, "CVE-2021-0514": {"epss_score": 0.01406, "epss_percentile": 0.80047}, "CVE-2021-0515": {"epss_score": 0.02181, "epss_percentile": 0.83904}, "CVE-2021-0516": {"epss_score": 0.01546, "epss_percentile": 0.80967}, "CVE-2021-0517": {"epss_score": 0.00276, "epss_percentile": 0.50717}, "CVE-2021-0518": {"epss_score": 0.00014, "epss_percentile": 0.01894}, "CVE-2021-0519": {"epss_score": 0.00049, "epss_percentile": 0.15317}, "CVE-2021-0520": {"epss_score": 0.00029, "epss_percentile": 0.07644}, "CVE-2021-0521": {"epss_score": 0.00024, "epss_percentile": 0.05955}, "CVE-2021-0522": {"epss_score": 0.02159, "epss_percentile": 0.83821}, "CVE-2021-0523": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0524": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-0525": {"epss_score": 0.00019, "epss_percentile": 0.04257}, "CVE-2021-0526": {"epss_score": 0.00016, "epss_percentile": 0.02946}, "CVE-2021-0527": {"epss_score": 0.00019, "epss_percentile": 0.04257}, "CVE-2021-0528": {"epss_score": 0.00016, "epss_percentile": 0.02946}, "CVE-2021-0529": {"epss_score": 0.00013, "epss_percentile": 0.01496}, "CVE-2021-0530": {"epss_score": 0.00016, "epss_percentile": 0.02946}, "CVE-2021-0531": {"epss_score": 0.00019, "epss_percentile": 0.04257}, "CVE-2021-0532": {"epss_score": 0.0001, "epss_percentile": 0.0077}, "CVE-2021-0533": {"epss_score": 0.0001, "epss_percentile": 0.0077}, "CVE-2021-0534": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-0535": {"epss_score": 0.00017, "epss_percentile": 0.03274}, "CVE-2021-0536": {"epss_score": 0.00012, "epss_percentile": 0.01429}, "CVE-2021-0537": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0538": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0539": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0540": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-0541": {"epss_score": 0.00014, "epss_percentile": 0.02094}, "CVE-2021-0542": {"epss_score": 0.00015, "epss_percentile": 0.02294}, "CVE-2021-0543": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-0544": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2021-0545": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2021-0546": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2021-0547": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0548": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-0549": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2021-0550": {"epss_score": 0.00013, "epss_percentile": 0.01556}, "CVE-2021-0551": {"epss_score": 0.00345, "epss_percentile": 0.5656}, "CVE-2021-0552": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-0553": {"epss_score": 0.00042, "epss_percentile": 0.12495}, "CVE-2021-0554": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-0555": {"epss_score": 0.00581, "epss_percentile": 0.68274}, "CVE-2021-0556": {"epss_score": 0.00017, "epss_percentile": 0.03515}, "CVE-2021-0557": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2021-0558": {"epss_score": 0.0041, "epss_percentile": 0.60825}, "CVE-2021-0559": {"epss_score": 0.00215, "epss_percentile": 0.441}, "CVE-2021-0561": {"epss_score": 0.00022, "epss_percentile": 0.05184}, "CVE-2021-0562": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-0563": {"epss_score": 0.00017, "epss_percentile": 0.03515}, "CVE-2021-0564": {"epss_score": 0.00013, "epss_percentile": 0.01646}, "CVE-2021-0565": {"epss_score": 0.00014, "epss_percentile": 0.01827}, "CVE-2021-0566": {"epss_score": 0.00014, "epss_percentile": 0.02094}, "CVE-2021-0567": {"epss_score": 0.00036, "epss_percentile": 0.10197}, "CVE-2021-0568": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0569": {"epss_score": 0.00015, "epss_percentile": 0.02216}, "CVE-2021-0570": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0571": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2021-0572": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-0573": {"epss_score": 0.00016, "epss_percentile": 0.02946}, "CVE-2021-0574": {"epss_score": 0.00016, "epss_percentile": 0.02946}, "CVE-2021-0576": {"epss_score": 0.00016, "epss_percentile": 0.02946}, "CVE-2021-0577": {"epss_score": 0.00013, "epss_percentile": 0.01498}, "CVE-2021-0578": {"epss_score": 0.00082, "epss_percentile": 0.24402}, "CVE-2021-0579": {"epss_score": 0.00082, "epss_percentile": 0.24402}, "CVE-2021-0580": {"epss_score": 0.00082, "epss_percentile": 0.24402}, "CVE-2021-0581": {"epss_score": 0.00082, "epss_percentile": 0.24402}, "CVE-2021-0582": {"epss_score": 0.00082, "epss_percentile": 0.24402}, "CVE-2021-0583": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0584": {"epss_score": 0.0003, "epss_percentile": 0.0827}, "CVE-2021-0585": {"epss_score": 0.0003, "epss_percentile": 0.0809}, "CVE-2021-0586": {"epss_score": 0.00028, "epss_percentile": 0.07342}, "CVE-2021-0587": {"epss_score": 0.00062, "epss_percentile": 0.1977}, "CVE-2021-0588": {"epss_score": 0.00028, "epss_percentile": 0.07545}, "CVE-2021-0589": {"epss_score": 0.00028, "epss_percentile": 0.07475}, "CVE-2021-0590": {"epss_score": 0.00014, "epss_percentile": 0.01816}, "CVE-2021-0591": {"epss_score": 0.00075, "epss_percentile": 0.23025}, "CVE-2021-0592": {"epss_score": 0.00502, "epss_percentile": 0.6538}, "CVE-2021-0593": {"epss_score": 0.00031, "epss_percentile": 0.08335}, "CVE-2021-0594": {"epss_score": 0.00069, "epss_percentile": 0.21484}, "CVE-2021-0595": {"epss_score": 0.00025, "epss_percentile": 0.06336}, "CVE-2021-0596": {"epss_score": 0.00884, "epss_percentile": 0.74925}, "CVE-2021-0597": {"epss_score": 0.00054, "epss_percentile": 0.17171}, "CVE-2021-0598": {"epss_score": 0.00026, "epss_percentile": 0.06429}, "CVE-2021-0599": {"epss_score": 0.00031, "epss_percentile": 0.08707}, "CVE-2021-0600": {"epss_score": 0.00053, "epss_percentile": 0.1683}, "CVE-2021-0601": {"epss_score": 0.00042, "epss_percentile": 0.12924}, "CVE-2021-0602": {"epss_score": 0.00011, "epss_percentile": 0.00994}, "CVE-2021-0603": {"epss_score": 0.00015, "epss_percentile": 0.02548}, "CVE-2021-0604": {"epss_score": 0.00039, "epss_percentile": 0.11706}, "CVE-2021-0605": {"epss_score": 0.00042, "epss_percentile": 0.12716}, "CVE-2021-0606": {"epss_score": 0.00026, "epss_percentile": 0.06412}, "CVE-2021-0607": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-0608": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-0610": {"epss_score": 0.00016, "epss_percentile": 0.02958}, "CVE-2021-0611": {"epss_score": 0.00017, "epss_percentile": 0.03055}, "CVE-2021-0612": {"epss_score": 0.00017, "epss_percentile": 0.03055}, "CVE-2021-0613": {"epss_score": 0.00015, "epss_percentile": 0.02157}, "CVE-2021-0614": {"epss_score": 0.00015, "epss_percentile": 0.02157}, "CVE-2021-0615": {"epss_score": 0.00017, "epss_percentile": 0.03225}, "CVE-2021-0616": {"epss_score": 0.00012, "epss_percentile": 0.01274}, "CVE-2021-0617": {"epss_score": 0.00012, "epss_percentile": 0.01274}, "CVE-2021-0618": {"epss_score": 0.00012, "epss_percentile": 0.01274}, "CVE-2021-0619": {"epss_score": 0.00015, "epss_percentile": 0.02334}, "CVE-2021-0620": {"epss_score": 0.00012, "epss_percentile": 0.01388}, "CVE-2021-0621": {"epss_score": 0.00017, "epss_percentile": 0.03442}, "CVE-2021-0622": {"epss_score": 0.00012, "epss_percentile": 0.01388}, "CVE-2021-0623": {"epss_score": 0.00051, "epss_percentile": 0.16255}, "CVE-2021-0624": {"epss_score": 0.00012, "epss_percentile": 0.01388}, "CVE-2021-0625": {"epss_score": 0.0001, "epss_percentile": 0.00791}, "CVE-2021-0626": {"epss_score": 0.00019, "epss_percentile": 0.0441}, "CVE-2021-0627": {"epss_score": 0.0002, "epss_percentile": 0.04545}, "CVE-2021-0628": {"epss_score": 0.00017, "epss_percentile": 0.03356}, "CVE-2021-0629": {"epss_score": 0.00013, "epss_percentile": 0.01677}, "CVE-2021-0630": {"epss_score": 0.00771, "epss_percentile": 0.7303}, "CVE-2021-0631": {"epss_score": 0.00663, "epss_percentile": 0.70624}, "CVE-2021-0632": {"epss_score": 0.00095, "epss_percentile": 0.27195}, "CVE-2021-0633": {"epss_score": 0.00014, "epss_percentile": 0.01965}, "CVE-2021-0634": {"epss_score": 0.00013, "epss_percentile": 0.01559}, "CVE-2021-0635": {"epss_score": 0.00055, "epss_percentile": 0.17613}, "CVE-2021-0636": {"epss_score": 0.00055, "epss_percentile": 0.17613}, "CVE-2021-0639": {"epss_score": 0.00015, "epss_percentile": 0.02294}, "CVE-2021-0640": {"epss_score": 0.00025, "epss_percentile": 0.06123}, "CVE-2021-0641": {"epss_score": 0.00026, "epss_percentile": 0.06381}, "CVE-2021-0642": {"epss_score": 0.00068, "epss_percentile": 0.21271}, "CVE-2021-0643": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2021-0644": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-0645": {"epss_score": 0.00042, "epss_percentile": 0.12798}, "CVE-2021-0646": {"epss_score": 0.00031, "epss_percentile": 0.08335}, "CVE-2021-0649": {"epss_score": 0.0001, "epss_percentile": 0.00853}, "CVE-2021-0650": {"epss_score": 0.00467, "epss_percentile": 0.6385}, "CVE-2021-0651": {"epss_score": 0.00033, "epss_percentile": 0.09137}, "CVE-2021-0652": {"epss_score": 0.0002, "epss_percentile": 0.04639}, "CVE-2021-0653": {"epss_score": 0.00032, "epss_percentile": 0.09028}, "CVE-2021-0654": {"epss_score": 0.00057, "epss_percentile": 0.18218}, "CVE-2021-0655": {"epss_score": 0.00015, "epss_percentile": 0.02557}, "CVE-2021-0656": {"epss_score": 0.00016, "epss_percentile": 0.02807}, "CVE-2021-0657": {"epss_score": 0.00011, "epss_percentile": 0.01009}, "CVE-2021-0658": {"epss_score": 0.00015, "epss_percentile": 0.02557}, "CVE-2021-0659": {"epss_score": 0.00016, "epss_percentile": 0.02953}, "CVE-2021-0660": {"epss_score": 0.00171, "epss_percentile": 0.38893}, "CVE-2021-0661": {"epss_score": 0.00021, "epss_percentile": 0.04689}, "CVE-2021-0662": {"epss_score": 0.00021, "epss_percentile": 0.04689}, "CVE-2021-0663": {"epss_score": 0.00021, "epss_percentile": 0.04689}, "CVE-2021-0664": {"epss_score": 0.00016, "epss_percentile": 0.02807}, "CVE-2021-0665": {"epss_score": 0.00016, "epss_percentile": 0.02953}, "CVE-2021-0666": {"epss_score": 0.00016, "epss_percentile": 0.02953}, "CVE-2021-0667": {"epss_score": 0.00018, "epss_percentile": 0.03805}, "CVE-2021-0668": {"epss_score": 0.00011, "epss_percentile": 0.01105}, "CVE-2021-0669": {"epss_score": 0.00015, "epss_percentile": 0.02409}, "CVE-2021-0670": {"epss_score": 0.00015, "epss_percentile": 0.02409}, "CVE-2021-0671": {"epss_score": 0.00013, "epss_percentile": 0.01553}, "CVE-2021-0672": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-0673": {"epss_score": 0.00019, "epss_percentile": 0.04279}, "CVE-2021-0674": {"epss_score": 0.00023, "epss_percentile": 0.05343}, "CVE-2021-0675": {"epss_score": 0.00018, "epss_percentile": 0.03608}, "CVE-2021-0676": {"epss_score": 0.00014, "epss_percentile": 0.02117}, "CVE-2021-0677": {"epss_score": 0.00017, "epss_percentile": 0.03182}, "CVE-2021-0678": {"epss_score": 0.00015, "epss_percentile": 0.02557}, "CVE-2021-0679": {"epss_score": 0.00015, "epss_percentile": 0.02557}, "CVE-2021-0680": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-0681": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-0682": {"epss_score": 0.00033, "epss_percentile": 0.09246}, "CVE-2021-0683": {"epss_score": 0.00024, "epss_percentile": 0.06019}, "CVE-2021-0684": {"epss_score": 0.00029, "epss_percentile": 0.07953}, "CVE-2021-0685": {"epss_score": 0.0003, "epss_percentile": 0.08197}, "CVE-2021-0686": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-0687": {"epss_score": 0.00027, "epss_percentile": 0.06763}, "CVE-2021-0688": {"epss_score": 5e-05, "epss_percentile": 0.00193}, "CVE-2021-0689": {"epss_score": 0.00047, "epss_percentile": 0.14633}, "CVE-2021-0690": {"epss_score": 0.01129, "epss_percentile": 0.77839}, "CVE-2021-0691": {"epss_score": 0.00034, "epss_percentile": 0.09574}, "CVE-2021-0692": {"epss_score": 0.00034, "epss_percentile": 0.09477}, "CVE-2021-0693": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-0694": {"epss_score": 0.0001, "epss_percentile": 0.00853}, "CVE-2021-0695": {"epss_score": 0.00086, "epss_percentile": 0.25397}, "CVE-2021-0696": {"epss_score": 0.00015, "epss_percentile": 0.02165}, "CVE-2021-0697": {"epss_score": 0.00012, "epss_percentile": 0.01428}, "CVE-2021-0698": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2021-0699": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2021-0701": {"epss_score": 0.00048, "epss_percentile": 0.15017}, "CVE-2021-0702": {"epss_score": 0.00018, "epss_percentile": 0.03961}, "CVE-2021-0703": {"epss_score": 0.00016, "epss_percentile": 0.02611}, "CVE-2021-0704": {"epss_score": 9e-05, "epss_percentile": 0.00664}, "CVE-2021-0705": {"epss_score": 0.00011, "epss_percentile": 0.00994}, "CVE-2021-0706": {"epss_score": 0.00046, "epss_percentile": 0.14365}, "CVE-2021-0707": {"epss_score": 0.0002, "epss_percentile": 0.04442}, "CVE-2021-0708": {"epss_score": 0.00034, "epss_percentile": 0.09473}, "CVE-2021-0734": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2021-0735": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-0769": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-0799": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-0869": {"epss_score": 0.00646, "epss_percentile": 0.70144}, "CVE-2021-0870": {"epss_score": 0.00946, "epss_percentile": 0.75809}, "CVE-2021-0871": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2021-0872": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0873": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0874": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0875": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0876": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0877": {"epss_score": 0.00054, "epss_percentile": 0.17356}, "CVE-2021-0878": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0879": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0880": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0881": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0882": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0883": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0884": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0885": {"epss_score": 0.00014, "epss_percentile": 0.01753}, "CVE-2021-0887": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2021-0889": {"epss_score": 0.03655, "epss_percentile": 0.87513}, "CVE-2021-0891": {"epss_score": 0.00114, "epss_percentile": 0.30879}, "CVE-2021-0893": {"epss_score": 0.00018, "epss_percentile": 0.03805}, "CVE-2021-0894": {"epss_score": 0.00015, "epss_percentile": 0.02557}, "CVE-2021-0895": {"epss_score": 0.00015, "epss_percentile": 0.02557}, "CVE-2021-0896": {"epss_score": 0.00015, "epss_percentile": 0.02557}, "CVE-2021-0897": {"epss_score": 0.00012, "epss_percentile": 0.01268}, "CVE-2021-0898": {"epss_score": 0.00018, "epss_percentile": 0.03805}, "CVE-2021-0899": {"epss_score": 0.00018, "epss_percentile": 0.03805}, "CVE-2021-0900": {"epss_score": 0.00016, "epss_percentile": 0.02953}, "CVE-2021-0901": {"epss_score": 0.00018, "epss_percentile": 0.0372}, "CVE-2021-0902": {"epss_score": 0.00016, "epss_percentile": 0.02953}, "CVE-2021-0903": {"epss_score": 0.00015, "epss_percentile": 0.02557}, "CVE-2021-0904": {"epss_score": 0.00012, "epss_percentile": 0.01334}, "CVE-2021-0918": {"epss_score": 0.00161, "epss_percentile": 0.37581}, "CVE-2021-0919": {"epss_score": 0.00042, "epss_percentile": 0.12483}, "CVE-2021-0920": {"epss_score": 0.00942, "epss_percentile": 0.75763}, "CVE-2021-0921": {"epss_score": 0.00012, "epss_percentile": 0.01429}, "CVE-2021-0922": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0923": {"epss_score": 0.0001, "epss_percentile": 0.00853}, "CVE-2021-0924": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-0925": {"epss_score": 0.00393, "epss_percentile": 0.59743}, "CVE-2021-0926": {"epss_score": 0.00034, "epss_percentile": 0.09477}, "CVE-2021-0927": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-0928": {"epss_score": 0.00241, "epss_percentile": 0.47299}, "CVE-2021-0929": {"epss_score": 0.00047, "epss_percentile": 0.14498}, "CVE-2021-0930": {"epss_score": 0.00667, "epss_percentile": 0.70707}, "CVE-2021-0931": {"epss_score": 0.00037, "epss_percentile": 0.10683}, "CVE-2021-0932": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-0933": {"epss_score": 0.00431, "epss_percentile": 0.62093}, "CVE-2021-0934": {"epss_score": 0.00041, "epss_percentile": 0.12382}, "CVE-2021-0935": {"epss_score": 0.00021, "epss_percentile": 0.04776}, "CVE-2021-0936": {"epss_score": 0.00023, "epss_percentile": 0.05636}, "CVE-2021-0938": {"epss_score": 0.00043, "epss_percentile": 0.12955}, "CVE-2021-0939": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2021-0940": {"epss_score": 0.00012, "epss_percentile": 0.01308}, "CVE-2021-0941": {"epss_score": 0.00061, "epss_percentile": 0.19333}, "CVE-2021-0942": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2021-0943": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2021-0945": {"epss_score": 0.00048, "epss_percentile": 0.15017}, "CVE-2021-0946": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2021-0947": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2021-0948": {"epss_score": 0.00026, "epss_percentile": 0.06572}, "CVE-2021-0951": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2021-0952": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2021-0953": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-0954": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-0955": {"epss_score": 0.0001, "epss_percentile": 0.00812}, "CVE-2021-0956": {"epss_score": 0.01098, "epss_percentile": 0.77535}, "CVE-2021-0957": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-0958": {"epss_score": 0.00014, "epss_percentile": 0.01858}, "CVE-2021-0959": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-0961": {"epss_score": 0.00047, "epss_percentile": 0.14477}, "CVE-2021-0963": {"epss_score": 0.0001, "epss_percentile": 0.00809}, "CVE-2021-0964": {"epss_score": 0.00366, "epss_percentile": 0.58074}, "CVE-2021-0965": {"epss_score": 0.00037, "epss_percentile": 0.10642}, "CVE-2021-0966": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-0967": {"epss_score": 0.00502, "epss_percentile": 0.6538}, "CVE-2021-0968": {"epss_score": 0.00481, "epss_percentile": 0.64492}, "CVE-2021-0969": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2021-0970": {"epss_score": 0.00021, "epss_percentile": 0.04896}, "CVE-2021-0971": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2021-0973": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2021-0975": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2021-0976": {"epss_score": 0.00244, "epss_percentile": 0.47549}, "CVE-2021-0977": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-0978": {"epss_score": 0.00012, "epss_percentile": 0.01262}, "CVE-2021-0979": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2021-0981": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-0982": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2021-0983": {"epss_score": 0.00015, "epss_percentile": 0.02311}, "CVE-2021-0984": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-0985": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-0986": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-0987": {"epss_score": 0.00013, "epss_percentile": 0.01531}, "CVE-2021-0988": {"epss_score": 0.00013, "epss_percentile": 0.01531}, "CVE-2021-0989": {"epss_score": 0.00013, "epss_percentile": 0.01531}, "CVE-2021-0990": {"epss_score": 0.00013, "epss_percentile": 0.01531}, "CVE-2021-0991": {"epss_score": 0.00021, "epss_percentile": 0.04894}, "CVE-2021-0992": {"epss_score": 0.00017, "epss_percentile": 0.03374}, "CVE-2021-0993": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2021-0994": {"epss_score": 0.00012, "epss_percentile": 0.01262}, "CVE-2021-0995": {"epss_score": 0.00013, "epss_percentile": 0.01531}, "CVE-2021-0996": {"epss_score": 0.00028, "epss_percentile": 0.07577}, "CVE-2021-0997": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-0998": {"epss_score": 0.00017, "epss_percentile": 0.03515}, "CVE-2021-0999": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-1000": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-1001": {"epss_score": 0.00017, "epss_percentile": 0.03515}, "CVE-2021-1002": {"epss_score": 0.00289, "epss_percentile": 0.52017}, "CVE-2021-1003": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-1004": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2021-1005": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-1006": {"epss_score": 0.00015, "epss_percentile": 0.02227}, "CVE-2021-1007": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2021-1008": {"epss_score": 0.00014, "epss_percentile": 0.01858}, "CVE-2021-1009": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-1010": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-1011": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-1012": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-1013": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-1014": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-1015": {"epss_score": 0.00013, "epss_percentile": 0.01531}, "CVE-2021-1016": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-1017": {"epss_score": 0.00015, "epss_percentile": 0.02548}, "CVE-2021-1018": {"epss_score": 0.00013, "epss_percentile": 0.01531}, "CVE-2021-1019": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-1020": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-1021": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-1022": {"epss_score": 0.00581, "epss_percentile": 0.68274}, "CVE-2021-1023": {"epss_score": 0.00015, "epss_percentile": 0.02299}, "CVE-2021-1024": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-1025": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2021-1026": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-1027": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-1028": {"epss_score": 0.00018, "epss_percentile": 0.03602}, "CVE-2021-1029": {"epss_score": 0.00018, "epss_percentile": 0.03602}, "CVE-2021-1030": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-1031": {"epss_score": 0.00013, "epss_percentile": 0.01531}, "CVE-2021-1032": {"epss_score": 0.00013, "epss_percentile": 0.01531}, "CVE-2021-1033": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-1034": {"epss_score": 0.00013, "epss_percentile": 0.01701}, "CVE-2021-1035": {"epss_score": 0.00013, "epss_percentile": 0.01592}, "CVE-2021-1036": {"epss_score": 0.00049, "epss_percentile": 0.15602}, "CVE-2021-1037": {"epss_score": 0.00064, "epss_percentile": 0.20145}, "CVE-2021-1038": {"epss_score": 0.00016, "epss_percentile": 0.02888}, "CVE-2021-1039": {"epss_score": 0.00013, "epss_percentile": 0.01549}, "CVE-2021-1040": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-1041": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-1042": {"epss_score": 0.00019, "epss_percentile": 0.041}, "CVE-2021-1043": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-1044": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-1045": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2021-1046": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2021-1047": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2021-1048": {"epss_score": 0.02226, "epss_percentile": 0.8407}, "CVE-2021-1049": {"epss_score": 0.00113, "epss_percentile": 0.30701}, "CVE-2021-1050": {"epss_score": 0.00033, "epss_percentile": 0.09168}, "CVE-2021-1051": {"epss_score": 0.00034, "epss_percentile": 0.09618}, "CVE-2021-1052": {"epss_score": 0.00201, "epss_percentile": 0.42391}, "CVE-2021-1053": {"epss_score": 0.00087, "epss_percentile": 0.25504}, "CVE-2021-1054": {"epss_score": 0.00043, "epss_percentile": 0.13225}, "CVE-2021-1055": {"epss_score": 0.00055, "epss_percentile": 0.17375}, "CVE-2021-1056": {"epss_score": 0.06555, "epss_percentile": 0.90846}, "CVE-2021-1057": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2021-1058": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-1059": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2021-1060": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-1061": {"epss_score": 0.00042, "epss_percentile": 0.1261}, "CVE-2021-1062": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-1063": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2021-1064": {"epss_score": 0.00138, "epss_percentile": 0.34509}, "CVE-2021-1065": {"epss_score": 0.00122, "epss_percentile": 0.3215}, "CVE-2021-1066": {"epss_score": 0.00062, "epss_percentile": 0.19561}, "CVE-2021-1067": {"epss_score": 0.001, "epss_percentile": 0.2847}, "CVE-2021-1068": {"epss_score": 0.00097, "epss_percentile": 0.27599}, "CVE-2021-1069": {"epss_score": 0.00044, "epss_percentile": 0.13645}, "CVE-2021-1070": {"epss_score": 0.00045, "epss_percentile": 0.1375}, "CVE-2021-1071": {"epss_score": 0.00052, "epss_percentile": 0.16442}, "CVE-2021-1072": {"epss_score": 0.00035, "epss_percentile": 0.10056}, "CVE-2021-1073": {"epss_score": 0.00308, "epss_percentile": 0.53605}, "CVE-2021-1074": {"epss_score": 0.00107, "epss_percentile": 0.29748}, "CVE-2021-1075": {"epss_score": 0.00048, "epss_percentile": 0.14974}, "CVE-2021-1076": {"epss_score": 0.00064, "epss_percentile": 0.20144}, "CVE-2021-1077": {"epss_score": 0.00048, "epss_percentile": 0.15071}, "CVE-2021-1078": {"epss_score": 0.0004, "epss_percentile": 0.12157}, "CVE-2021-1079": {"epss_score": 0.00037, "epss_percentile": 0.11005}, "CVE-2021-1080": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2021-1081": {"epss_score": 0.00044, "epss_percentile": 0.13574}, "CVE-2021-1082": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2021-1083": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2021-1084": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2021-1085": {"epss_score": 0.00043, "epss_percentile": 0.1297}, "CVE-2021-1086": {"epss_score": 0.00043, "epss_percentile": 0.12975}, "CVE-2021-1087": {"epss_score": 0.00052, "epss_percentile": 0.16442}, "CVE-2021-1088": {"epss_score": 0.00053, "epss_percentile": 0.16741}, "CVE-2021-1089": {"epss_score": 0.00123, "epss_percentile": 0.32272}, "CVE-2021-1090": {"epss_score": 0.00147, "epss_percentile": 0.35651}, "CVE-2021-1091": {"epss_score": 0.00115, "epss_percentile": 0.30903}, "CVE-2021-1092": {"epss_score": 0.00115, "epss_percentile": 0.30903}, "CVE-2021-1093": {"epss_score": 0.00076, "epss_percentile": 0.23122}, "CVE-2021-1094": {"epss_score": 0.00082, "epss_percentile": 0.24502}, "CVE-2021-1095": {"epss_score": 0.00295, "epss_percentile": 0.52446}, "CVE-2021-1096": {"epss_score": 0.00059, "epss_percentile": 0.18726}, "CVE-2021-1097": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2021-1098": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2021-1099": {"epss_score": 0.00175, "epss_percentile": 0.39369}, "CVE-2021-1100": {"epss_score": 0.00045, "epss_percentile": 0.13799}, "CVE-2021-1101": {"epss_score": 0.00043, "epss_percentile": 0.13333}, "CVE-2021-1102": {"epss_score": 0.00097, "epss_percentile": 0.27578}, "CVE-2021-1103": {"epss_score": 0.00045, "epss_percentile": 0.13893}, "CVE-2021-1104": {"epss_score": 0.00566, "epss_percentile": 0.6783}, "CVE-2021-1105": {"epss_score": 0.00053, "epss_percentile": 0.16741}, "CVE-2021-1106": {"epss_score": 0.00112, "epss_percentile": 0.30502}, "CVE-2021-1107": {"epss_score": 0.00107, "epss_percentile": 0.29694}, "CVE-2021-1108": {"epss_score": 0.00112, "epss_percentile": 0.30502}, "CVE-2021-1109": {"epss_score": 0.00101, "epss_percentile": 0.28626}, "CVE-2021-1110": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2021-1111": {"epss_score": 0.00476, "epss_percentile": 0.64284}, "CVE-2021-1112": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2021-1113": {"epss_score": 0.00103, "epss_percentile": 0.29012}, "CVE-2021-1114": {"epss_score": 0.00116, "epss_percentile": 0.31081}, "CVE-2021-1115": {"epss_score": 0.0004, "epss_percentile": 0.11953}, "CVE-2021-1116": {"epss_score": 0.00045, "epss_percentile": 0.1375}, "CVE-2021-1117": {"epss_score": 0.00045, "epss_percentile": 0.1375}, "CVE-2021-1118": {"epss_score": 0.0011, "epss_percentile": 0.30205}, "CVE-2021-1119": {"epss_score": 0.00047, "epss_percentile": 0.14662}, "CVE-2021-1120": {"epss_score": 0.00046, "epss_percentile": 0.14417}, "CVE-2021-1121": {"epss_score": 0.00045, "epss_percentile": 0.1375}, "CVE-2021-1122": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-1123": {"epss_score": 0.00035, "epss_percentile": 0.09858}, "CVE-2021-1125": {"epss_score": 0.00049, "epss_percentile": 0.15456}, "CVE-2021-1126": {"epss_score": 0.00039, "epss_percentile": 0.11722}, "CVE-2021-1127": {"epss_score": 0.00192, "epss_percentile": 0.41359}, "CVE-2021-1128": {"epss_score": 0.00071, "epss_percentile": 0.22207}, "CVE-2021-1129": {"epss_score": 0.00358, "epss_percentile": 0.5751}, "CVE-2021-1130": {"epss_score": 0.00174, "epss_percentile": 0.39187}, "CVE-2021-1131": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-1132": {"epss_score": 0.00378, "epss_percentile": 0.5878}, "CVE-2021-1133": {"epss_score": 0.00354, "epss_percentile": 0.57251}, "CVE-2021-1134": {"epss_score": 0.00202, "epss_percentile": 0.42476}, "CVE-2021-1135": {"epss_score": 0.00172, "epss_percentile": 0.38952}, "CVE-2021-1136": {"epss_score": 0.00023, "epss_percentile": 0.05463}, "CVE-2021-1137": {"epss_score": 0.00639, "epss_percentile": 0.6993}, "CVE-2021-1138": {"epss_score": 0.11689, "epss_percentile": 0.9345}, "CVE-2021-1139": {"epss_score": 0.08202, "epss_percentile": 0.91928}, "CVE-2021-1140": {"epss_score": 0.11689, "epss_percentile": 0.9345}, "CVE-2021-1141": {"epss_score": 0.08202, "epss_percentile": 0.91928}, "CVE-2021-1142": {"epss_score": 0.06672, "epss_percentile": 0.90934}, "CVE-2021-1143": {"epss_score": 0.00129, "epss_percentile": 0.33126}, "CVE-2021-1144": {"epss_score": 0.00464, "epss_percentile": 0.63706}, "CVE-2021-1145": {"epss_score": 0.00262, "epss_percentile": 0.49389}, "CVE-2021-1146": {"epss_score": 0.00668, "epss_percentile": 0.70736}, "CVE-2021-1147": {"epss_score": 0.00668, "epss_percentile": 0.70736}, "CVE-2021-1148": {"epss_score": 0.00668, "epss_percentile": 0.70736}, "CVE-2021-1149": {"epss_score": 0.00668, "epss_percentile": 0.70736}, "CVE-2021-1150": {"epss_score": 0.00668, "epss_percentile": 0.70736}, "CVE-2021-1151": {"epss_score": 0.00035, "epss_percentile": 0.10039}, "CVE-2021-1152": {"epss_score": 0.00035, "epss_percentile": 0.10039}, "CVE-2021-1153": {"epss_score": 0.00035, "epss_percentile": 0.10039}, "CVE-2021-1154": {"epss_score": 0.00035, "epss_percentile": 0.10039}, "CVE-2021-1155": {"epss_score": 0.00035, "epss_percentile": 0.10039}, "CVE-2021-1156": {"epss_score": 0.00035, "epss_percentile": 0.10039}, "CVE-2021-1157": {"epss_score": 0.00035, "epss_percentile": 0.10039}, "CVE-2021-1158": {"epss_score": 0.00035, "epss_percentile": 0.10039}, "CVE-2021-1159": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1160": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1161": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1162": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1163": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1164": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1165": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1166": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1167": {"epss_score": 0.05729, "epss_percentile": 0.90159}, "CVE-2021-1168": {"epss_score": 0.00309, "epss_percentile": 0.53646}, "CVE-2021-1169": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1170": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1171": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1172": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1173": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1174": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1175": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1176": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1177": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1178": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1179": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1180": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1181": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1182": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1183": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1184": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1185": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1186": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1187": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1188": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1189": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1190": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1191": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1192": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1193": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1194": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1195": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1196": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1197": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1198": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1199": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1200": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1201": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1202": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1203": {"epss_score": 0.00309, "epss_percentile": 0.53646}, "CVE-2021-1204": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1205": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1206": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1207": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1208": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1209": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1210": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1211": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1212": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1213": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1214": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1215": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1216": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1217": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1218": {"epss_score": 0.00031, "epss_percentile": 0.08444}, "CVE-2021-1219": {"epss_score": 0.00047, "epss_percentile": 0.14615}, "CVE-2021-1220": {"epss_score": 0.00205, "epss_percentile": 0.42717}, "CVE-2021-1221": {"epss_score": 0.00385, "epss_percentile": 0.59228}, "CVE-2021-1222": {"epss_score": 0.00223, "epss_percentile": 0.44898}, "CVE-2021-1223": {"epss_score": 0.00424, "epss_percentile": 0.61638}, "CVE-2021-1224": {"epss_score": 0.00366, "epss_percentile": 0.58093}, "CVE-2021-1225": {"epss_score": 0.00567, "epss_percentile": 0.67862}, "CVE-2021-1226": {"epss_score": 0.00225, "epss_percentile": 0.45126}, "CVE-2021-1227": {"epss_score": 0.00376, "epss_percentile": 0.58646}, "CVE-2021-1228": {"epss_score": 0.00083, "epss_percentile": 0.24621}, "CVE-2021-1229": {"epss_score": 0.00981, "epss_percentile": 0.76276}, "CVE-2021-1230": {"epss_score": 0.00701, "epss_percentile": 0.71493}, "CVE-2021-1231": {"epss_score": 0.00117, "epss_percentile": 0.31229}, "CVE-2021-1232": {"epss_score": 0.00124, "epss_percentile": 0.32436}, "CVE-2021-1233": {"epss_score": 0.00058, "epss_percentile": 0.18599}, "CVE-2021-1234": {"epss_score": 0.00105, "epss_percentile": 0.29367}, "CVE-2021-1235": {"epss_score": 0.00061, "epss_percentile": 0.19258}, "CVE-2021-1236": {"epss_score": 0.00291, "epss_percentile": 0.52147}, "CVE-2021-1237": {"epss_score": 0.00054, "epss_percentile": 0.17242}, "CVE-2021-1238": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2021-1239": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2021-1240": {"epss_score": 0.00242, "epss_percentile": 0.47339}, "CVE-2021-1241": {"epss_score": 0.00596, "epss_percentile": 0.68716}, "CVE-2021-1242": {"epss_score": 0.00373, "epss_percentile": 0.58496}, "CVE-2021-1243": {"epss_score": 0.00608, "epss_percentile": 0.69066}, "CVE-2021-1244": {"epss_score": 0.00023, "epss_percentile": 0.05463}, "CVE-2021-1245": {"epss_score": 0.0047, "epss_percentile": 0.6396}, "CVE-2021-1246": {"epss_score": 0.00517, "epss_percentile": 0.66069}, "CVE-2021-1247": {"epss_score": 0.00947, "epss_percentile": 0.75816}, "CVE-2021-1248": {"epss_score": 0.00733, "epss_percentile": 0.72218}, "CVE-2021-1249": {"epss_score": 0.00192, "epss_percentile": 0.41359}, "CVE-2021-1250": {"epss_score": 0.00192, "epss_percentile": 0.41359}, "CVE-2021-1251": {"epss_score": 0.00096, "epss_percentile": 0.2745}, "CVE-2021-1252": {"epss_score": 0.00513, "epss_percentile": 0.65916}, "CVE-2021-1253": {"epss_score": 0.00192, "epss_percentile": 0.41359}, "CVE-2021-1254": {"epss_score": 0.00201, "epss_percentile": 0.42345}, "CVE-2021-1255": {"epss_score": 0.00172, "epss_percentile": 0.38952}, "CVE-2021-1256": {"epss_score": 0.0003, "epss_percentile": 0.0814}, "CVE-2021-1257": {"epss_score": 0.00124, "epss_percentile": 0.32352}, "CVE-2021-1258": {"epss_score": 0.00045, "epss_percentile": 0.1372}, "CVE-2021-1259": {"epss_score": 0.00251, "epss_percentile": 0.483}, "CVE-2021-1260": {"epss_score": 0.01283, "epss_percentile": 0.79163}, "CVE-2021-1261": {"epss_score": 0.01283, "epss_percentile": 0.79163}, "CVE-2021-1262": {"epss_score": 0.00574, "epss_percentile": 0.68086}, "CVE-2021-1263": {"epss_score": 0.01283, "epss_percentile": 0.79163}, "CVE-2021-1264": {"epss_score": 0.00907, "epss_percentile": 0.75264}, "CVE-2021-1265": {"epss_score": 0.0011, "epss_percentile": 0.3023}, "CVE-2021-1266": {"epss_score": 0.00378, "epss_percentile": 0.5878}, "CVE-2021-1267": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2021-1268": {"epss_score": 0.00086, "epss_percentile": 0.25332}, "CVE-2021-1269": {"epss_score": 0.00301, "epss_percentile": 0.53071}, "CVE-2021-1270": {"epss_score": 0.00125, "epss_percentile": 0.32474}, "CVE-2021-1271": {"epss_score": 0.00174, "epss_percentile": 0.39187}, "CVE-2021-1272": {"epss_score": 0.00198, "epss_percentile": 0.41975}, "CVE-2021-1273": {"epss_score": 0.00991, "epss_percentile": 0.76382}, "CVE-2021-1274": {"epss_score": 0.00694, "epss_percentile": 0.71351}, "CVE-2021-1275": {"epss_score": 0.01749, "epss_percentile": 0.82084}, "CVE-2021-1276": {"epss_score": 0.00116, "epss_percentile": 0.31083}, "CVE-2021-1277": {"epss_score": 0.00116, "epss_percentile": 0.31083}, "CVE-2021-1278": {"epss_score": 0.01062, "epss_percentile": 0.77185}, "CVE-2021-1279": {"epss_score": 0.00596, "epss_percentile": 0.68716}, "CVE-2021-1280": {"epss_score": 0.00063, "epss_percentile": 0.19965}, "CVE-2021-1281": {"epss_score": 0.00041, "epss_percentile": 0.12366}, "CVE-2021-1282": {"epss_score": 0.00309, "epss_percentile": 0.53688}, "CVE-2021-1283": {"epss_score": 0.00061, "epss_percentile": 0.19258}, "CVE-2021-1284": {"epss_score": 0.00074, "epss_percentile": 0.22871}, "CVE-2021-1285": {"epss_score": 0.01665, "epss_percentile": 0.81647}, "CVE-2021-1286": {"epss_score": 0.00201, "epss_percentile": 0.42325}, "CVE-2021-1287": {"epss_score": 0.00379, "epss_percentile": 0.58881}, "CVE-2021-1288": {"epss_score": 0.00596, "epss_percentile": 0.68716}, "CVE-2021-1289": {"epss_score": 0.01866, "epss_percentile": 0.82616}, "CVE-2021-1290": {"epss_score": 0.01866, "epss_percentile": 0.82616}, "CVE-2021-1291": {"epss_score": 0.01866, "epss_percentile": 0.82616}, "CVE-2021-1292": {"epss_score": 0.01866, "epss_percentile": 0.82616}, "CVE-2021-1293": {"epss_score": 0.06344, "epss_percentile": 0.90685}, "CVE-2021-1294": {"epss_score": 0.01866, "epss_percentile": 0.82616}, "CVE-2021-1295": {"epss_score": 0.01866, "epss_percentile": 0.82616}, "CVE-2021-1296": {"epss_score": 0.00445, "epss_percentile": 0.62867}, "CVE-2021-1297": {"epss_score": 0.00445, "epss_percentile": 0.62867}, "CVE-2021-1298": {"epss_score": 0.01094, "epss_percentile": 0.77489}, "CVE-2021-1299": {"epss_score": 0.01094, "epss_percentile": 0.77489}, "CVE-2021-1300": {"epss_score": 0.00876, "epss_percentile": 0.74786}, "CVE-2021-1301": {"epss_score": 0.00876, "epss_percentile": 0.74786}, "CVE-2021-1302": {"epss_score": 0.00091, "epss_percentile": 0.26402}, "CVE-2021-1303": {"epss_score": 0.00177, "epss_percentile": 0.39513}, "CVE-2021-1304": {"epss_score": 0.00278, "epss_percentile": 0.5085}, "CVE-2021-1305": {"epss_score": 0.00208, "epss_percentile": 0.43224}, "CVE-2021-1306": {"epss_score": 0.00039, "epss_percentile": 0.11436}, "CVE-2021-1307": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1308": {"epss_score": 0.00096, "epss_percentile": 0.2745}, "CVE-2021-1309": {"epss_score": 0.00108, "epss_percentile": 0.29845}, "CVE-2021-1310": {"epss_score": 0.0019, "epss_percentile": 0.4112}, "CVE-2021-1311": {"epss_score": 0.0037, "epss_percentile": 0.58331}, "CVE-2021-1312": {"epss_score": 0.00114, "epss_percentile": 0.30744}, "CVE-2021-1313": {"epss_score": 0.00596, "epss_percentile": 0.68716}, "CVE-2021-1314": {"epss_score": 0.00668, "epss_percentile": 0.70736}, "CVE-2021-1315": {"epss_score": 0.00668, "epss_percentile": 0.70736}, "CVE-2021-1316": {"epss_score": 0.00668, "epss_percentile": 0.70736}, "CVE-2021-1317": {"epss_score": 0.00668, "epss_percentile": 0.70736}, "CVE-2021-1318": {"epss_score": 0.00668, "epss_percentile": 0.70736}, "CVE-2021-1319": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1320": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1321": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1322": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1323": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1324": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1325": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1326": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1327": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1328": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1329": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1330": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1331": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1332": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1333": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1334": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1335": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1336": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1337": {"epss_score": 0.00567, "epss_percentile": 0.67845}, "CVE-2021-1338": {"epss_score": 0.00567, "epss_percentile": 0.67845}, "CVE-2021-1339": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1340": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1341": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1342": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1343": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1344": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1345": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1346": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1347": {"epss_score": 0.00567, "epss_percentile": 0.67845}, "CVE-2021-1348": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1349": {"epss_score": 0.00056, "epss_percentile": 0.1792}, "CVE-2021-1350": {"epss_score": 0.00351, "epss_percentile": 0.57008}, "CVE-2021-1351": {"epss_score": 0.0015, "epss_percentile": 0.36126}, "CVE-2021-1352": {"epss_score": 0.00074, "epss_percentile": 0.22724}, "CVE-2021-1353": {"epss_score": 0.00521, "epss_percentile": 0.66229}, "CVE-2021-1354": {"epss_score": 0.00024, "epss_percentile": 0.05843}, "CVE-2021-1355": {"epss_score": 0.004, "epss_percentile": 0.60156}, "CVE-2021-1356": {"epss_score": 0.00112, "epss_percentile": 0.3042}, "CVE-2021-1357": {"epss_score": 0.0036, "epss_percentile": 0.57683}, "CVE-2021-1358": {"epss_score": 0.00171, "epss_percentile": 0.3879}, "CVE-2021-1359": {"epss_score": 0.01255, "epss_percentile": 0.78929}, "CVE-2021-1360": {"epss_score": 0.00505, "epss_percentile": 0.65582}, "CVE-2021-1361": {"epss_score": 0.00292, "epss_percentile": 0.52276}, "CVE-2021-1362": {"epss_score": 0.0233, "epss_percentile": 0.84401}, "CVE-2021-1363": {"epss_score": 0.00169, "epss_percentile": 0.3855}, "CVE-2021-1364": {"epss_score": 0.00309, "epss_percentile": 0.53688}, "CVE-2021-1365": {"epss_score": 0.00169, "epss_percentile": 0.3855}, "CVE-2021-1366": {"epss_score": 0.008, "epss_percentile": 0.73534}, "CVE-2021-1367": {"epss_score": 0.00221, "epss_percentile": 0.44649}, "CVE-2021-1368": {"epss_score": 0.00266, "epss_percentile": 0.4989}, "CVE-2021-1369": {"epss_score": 0.00526, "epss_percentile": 0.66432}, "CVE-2021-1370": {"epss_score": 0.00077, "epss_percentile": 0.2341}, "CVE-2021-1371": {"epss_score": 0.00028, "epss_percentile": 0.07251}, "CVE-2021-1372": {"epss_score": 0.00083, "epss_percentile": 0.24747}, "CVE-2021-1373": {"epss_score": 0.00192, "epss_percentile": 0.4128}, "CVE-2021-1374": {"epss_score": 0.00164, "epss_percentile": 0.37934}, "CVE-2021-1375": {"epss_score": 0.00025, "epss_percentile": 0.06064}, "CVE-2021-1376": {"epss_score": 0.00025, "epss_percentile": 0.06064}, "CVE-2021-1377": {"epss_score": 0.00544, "epss_percentile": 0.67133}, "CVE-2021-1378": {"epss_score": 0.00155, "epss_percentile": 0.36858}, "CVE-2021-1379": {"epss_score": 0.00091, "epss_percentile": 0.26265}, "CVE-2021-1380": {"epss_score": 0.00346, "epss_percentile": 0.56627}, "CVE-2021-1381": {"epss_score": 0.00121, "epss_percentile": 0.31823}, "CVE-2021-1382": {"epss_score": 0.00074, "epss_percentile": 0.22686}, "CVE-2021-1383": {"epss_score": 0.00149, "epss_percentile": 0.36013}, "CVE-2021-1384": {"epss_score": 0.16124, "epss_percentile": 0.94576}, "CVE-2021-1385": {"epss_score": 0.00236, "epss_percentile": 0.46394}, "CVE-2021-1386": {"epss_score": 0.00059, "epss_percentile": 0.18863}, "CVE-2021-1387": {"epss_score": 0.00941, "epss_percentile": 0.75756}, "CVE-2021-1388": {"epss_score": 0.01958, "epss_percentile": 0.83049}, "CVE-2021-1389": {"epss_score": 0.00383, "epss_percentile": 0.59084}, "CVE-2021-1390": {"epss_score": 0.0004, "epss_percentile": 0.12096}, "CVE-2021-1391": {"epss_score": 0.00041, "epss_percentile": 0.12366}, "CVE-2021-1392": {"epss_score": 0.0003, "epss_percentile": 0.0827}, "CVE-2021-1393": {"epss_score": 0.01056, "epss_percentile": 0.77121}, "CVE-2021-1394": {"epss_score": 0.00074, "epss_percentile": 0.22742}, "CVE-2021-1395": {"epss_score": 0.00322, "epss_percentile": 0.54817}, "CVE-2021-1396": {"epss_score": 0.00555, "epss_percentile": 0.67497}, "CVE-2021-1397": {"epss_score": 0.0018, "epss_percentile": 0.39865}, "CVE-2021-1398": {"epss_score": 0.00065, "epss_percentile": 0.206}, "CVE-2021-1399": {"epss_score": 0.00072, "epss_percentile": 0.22243}, "CVE-2021-1400": {"epss_score": 0.00503, "epss_percentile": 0.65438}, "CVE-2021-1401": {"epss_score": 0.01141, "epss_percentile": 0.77961}, "CVE-2021-1402": {"epss_score": 0.00215, "epss_percentile": 0.4404}, "CVE-2021-1403": {"epss_score": 0.00109, "epss_percentile": 0.30027}, "CVE-2021-1404": {"epss_score": 0.00427, "epss_percentile": 0.61782}, "CVE-2021-1405": {"epss_score": 0.01422, "epss_percentile": 0.80186}, "CVE-2021-1406": {"epss_score": 0.00189, "epss_percentile": 0.40985}, "CVE-2021-1407": {"epss_score": 0.00339, "epss_percentile": 0.56181}, "CVE-2021-1408": {"epss_score": 0.00339, "epss_percentile": 0.56181}, "CVE-2021-1409": {"epss_score": 0.00346, "epss_percentile": 0.56627}, "CVE-2021-1410": {"epss_score": 0.00226, "epss_percentile": 0.45357}, "CVE-2021-1411": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2021-1412": {"epss_score": 0.00177, "epss_percentile": 0.39516}, "CVE-2021-1413": {"epss_score": 0.01241, "epss_percentile": 0.78816}, "CVE-2021-1414": {"epss_score": 0.00954, "epss_percentile": 0.75894}, "CVE-2021-1415": {"epss_score": 0.01241, "epss_percentile": 0.78816}, "CVE-2021-1416": {"epss_score": 0.00285, "epss_percentile": 0.51673}, "CVE-2021-1417": {"epss_score": 0.00338, "epss_percentile": 0.56144}, "CVE-2021-1418": {"epss_score": 0.00514, "epss_percentile": 0.65965}, "CVE-2021-1419": {"epss_score": 0.00036, "epss_percentile": 0.10378}, "CVE-2021-1420": {"epss_score": 0.00356, "epss_percentile": 0.57329}, "CVE-2021-1421": {"epss_score": 0.001, "epss_percentile": 0.28477}, "CVE-2021-1422": {"epss_score": 0.00427, "epss_percentile": 0.61891}, "CVE-2021-1423": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2021-1424": {"epss_score": 0.00642, "epss_percentile": 0.70041}, "CVE-2021-1425": {"epss_score": 0.00246, "epss_percentile": 0.47793}, "CVE-2021-1426": {"epss_score": 0.00051, "epss_percentile": 0.16112}, "CVE-2021-1427": {"epss_score": 0.00054, "epss_percentile": 0.17242}, "CVE-2021-1428": {"epss_score": 0.00054, "epss_percentile": 0.17242}, "CVE-2021-1429": {"epss_score": 0.00054, "epss_percentile": 0.17242}, "CVE-2021-1430": {"epss_score": 0.00054, "epss_percentile": 0.17242}, "CVE-2021-1431": {"epss_score": 0.00384, "epss_percentile": 0.5918}, "CVE-2021-1432": {"epss_score": 0.00061, "epss_percentile": 0.19409}, "CVE-2021-1433": {"epss_score": 0.00668, "epss_percentile": 0.70738}, "CVE-2021-1434": {"epss_score": 0.00055, "epss_percentile": 0.17379}, "CVE-2021-1435": {"epss_score": 0.00384, "epss_percentile": 0.59167}, "CVE-2021-1436": {"epss_score": 0.00073, "epss_percentile": 0.22511}, "CVE-2021-1437": {"epss_score": 0.00483, "epss_percentile": 0.64613}, "CVE-2021-1438": {"epss_score": 0.00046, "epss_percentile": 0.14168}, "CVE-2021-1439": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-1440": {"epss_score": 0.00572, "epss_percentile": 0.68026}, "CVE-2021-1441": {"epss_score": 0.00074, "epss_percentile": 0.22851}, "CVE-2021-1442": {"epss_score": 0.00049, "epss_percentile": 0.15434}, "CVE-2021-1443": {"epss_score": 0.00795, "epss_percentile": 0.73462}, "CVE-2021-1444": {"epss_score": 0.00121, "epss_percentile": 0.31989}, "CVE-2021-1445": {"epss_score": 0.00312, "epss_percentile": 0.5394}, "CVE-2021-1446": {"epss_score": 0.00276, "epss_percentile": 0.50774}, "CVE-2021-1447": {"epss_score": 0.00023, "epss_percentile": 0.05473}, "CVE-2021-1448": {"epss_score": 0.00045, "epss_percentile": 0.13812}, "CVE-2021-1449": {"epss_score": 0.00045, "epss_percentile": 0.13725}, "CVE-2021-1450": {"epss_score": 0.00058, "epss_percentile": 0.18582}, "CVE-2021-1451": {"epss_score": 0.00656, "epss_percentile": 0.70446}, "CVE-2021-1452": {"epss_score": 0.00073, "epss_percentile": 0.22532}, "CVE-2021-1453": {"epss_score": 0.00052, "epss_percentile": 0.1647}, "CVE-2021-1454": {"epss_score": 0.00108, "epss_percentile": 0.29787}, "CVE-2021-1455": {"epss_score": 0.00314, "epss_percentile": 0.54146}, "CVE-2021-1456": {"epss_score": 0.00192, "epss_percentile": 0.41315}, "CVE-2021-1457": {"epss_score": 0.00142, "epss_percentile": 0.35039}, "CVE-2021-1458": {"epss_score": 0.00112, "epss_percentile": 0.30546}, "CVE-2021-1459": {"epss_score": 0.0145, "epss_percentile": 0.80346}, "CVE-2021-1460": {"epss_score": 0.00095, "epss_percentile": 0.27152}, "CVE-2021-1461": {"epss_score": 0.00035, "epss_percentile": 0.09987}, "CVE-2021-1462": {"epss_score": 0.0006, "epss_percentile": 0.19178}, "CVE-2021-1463": {"epss_score": 0.00339, "epss_percentile": 0.56181}, "CVE-2021-1464": {"epss_score": 0.00143, "epss_percentile": 0.35217}, "CVE-2021-1465": {"epss_score": 0.00654, "epss_percentile": 0.70349}, "CVE-2021-1466": {"epss_score": 0.00263, "epss_percentile": 0.49543}, "CVE-2021-1467": {"epss_score": 0.00107, "epss_percentile": 0.29682}, "CVE-2021-1468": {"epss_score": 0.01455, "epss_percentile": 0.80389}, "CVE-2021-1469": {"epss_score": 0.0037, "epss_percentile": 0.58322}, "CVE-2021-1470": {"epss_score": 0.00044, "epss_percentile": 0.13487}, "CVE-2021-1471": {"epss_score": 0.00315, "epss_percentile": 0.54194}, "CVE-2021-1472": {"epss_score": 0.87334, "epss_percentile": 0.99424}, "CVE-2021-1473": {"epss_score": 0.90786, "epss_percentile": 0.99599}, "CVE-2021-1474": {"epss_score": 0.00333, "epss_percentile": 0.55637}, "CVE-2021-1475": {"epss_score": 0.00184, "epss_percentile": 0.40448}, "CVE-2021-1476": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2021-1477": {"epss_score": 0.00149, "epss_percentile": 0.36}, "CVE-2021-1478": {"epss_score": 0.00239, "epss_percentile": 0.46909}, "CVE-2021-1479": {"epss_score": 0.02569, "epss_percentile": 0.85122}, "CVE-2021-1480": {"epss_score": 0.09586, "epss_percentile": 0.9261}, "CVE-2021-1481": {"epss_score": 0.00071, "epss_percentile": 0.22233}, "CVE-2021-1482": {"epss_score": 0.00049, "epss_percentile": 0.15349}, "CVE-2021-1483": {"epss_score": 0.00113, "epss_percentile": 0.30616}, "CVE-2021-1484": {"epss_score": 0.00304, "epss_percentile": 0.53259}, "CVE-2021-1485": {"epss_score": 0.0007, "epss_percentile": 0.21759}, "CVE-2021-1486": {"epss_score": 0.00365, "epss_percentile": 0.57993}, "CVE-2021-1487": {"epss_score": 0.00684, "epss_percentile": 0.71114}, "CVE-2021-1488": {"epss_score": 0.0007, "epss_percentile": 0.21665}, "CVE-2021-1489": {"epss_score": 0.00258, "epss_percentile": 0.48951}, "CVE-2021-1490": {"epss_score": 0.00204, "epss_percentile": 0.42628}, "CVE-2021-1491": {"epss_score": 0.002, "epss_percentile": 0.42202}, "CVE-2021-1492": {"epss_score": 0.00051, "epss_percentile": 0.16314}, "CVE-2021-1493": {"epss_score": 0.00623, "epss_percentile": 0.69533}, "CVE-2021-1494": {"epss_score": 0.001, "epss_percentile": 0.28501}, "CVE-2021-1495": {"epss_score": 0.00185, "epss_percentile": 0.4046}, "CVE-2021-1496": {"epss_score": 0.00147, "epss_percentile": 0.35688}, "CVE-2021-1497": {"epss_score": 0.94396, "epss_percentile": 0.99971}, "CVE-2021-1498": {"epss_score": 0.94012, "epss_percentile": 0.99886}, "CVE-2021-1499": {"epss_score": 0.9197, "epss_percentile": 0.99682}, "CVE-2021-1500": {"epss_score": 0.00183, "epss_percentile": 0.40331}, "CVE-2021-1501": {"epss_score": 0.00768, "epss_percentile": 0.72969}, "CVE-2021-1502": {"epss_score": 0.00452, "epss_percentile": 0.63181}, "CVE-2021-1503": {"epss_score": 0.00452, "epss_percentile": 0.63181}, "CVE-2021-1504": {"epss_score": 0.00312, "epss_percentile": 0.5394}, "CVE-2021-1505": {"epss_score": 0.01272, "epss_percentile": 0.79081}, "CVE-2021-1506": {"epss_score": 0.01119, "epss_percentile": 0.77755}, "CVE-2021-1507": {"epss_score": 0.00152, "epss_percentile": 0.36409}, "CVE-2021-1508": {"epss_score": 0.01094, "epss_percentile": 0.77494}, "CVE-2021-1509": {"epss_score": 0.00861, "epss_percentile": 0.74554}, "CVE-2021-1510": {"epss_score": 0.00912, "epss_percentile": 0.75361}, "CVE-2021-1511": {"epss_score": 0.008, "epss_percentile": 0.73532}, "CVE-2021-1512": {"epss_score": 0.00064, "epss_percentile": 0.20331}, "CVE-2021-1513": {"epss_score": 0.00818, "epss_percentile": 0.7386}, "CVE-2021-1514": {"epss_score": 0.00071, "epss_percentile": 0.2223}, "CVE-2021-1515": {"epss_score": 0.00064, "epss_percentile": 0.20187}, "CVE-2021-1516": {"epss_score": 0.00319, "epss_percentile": 0.54563}, "CVE-2021-1517": {"epss_score": 0.00179, "epss_percentile": 0.39789}, "CVE-2021-1518": {"epss_score": 0.00689, "epss_percentile": 0.71222}, "CVE-2021-1519": {"epss_score": 0.0005, "epss_percentile": 0.15876}, "CVE-2021-1520": {"epss_score": 0.00027, "epss_percentile": 0.06949}, "CVE-2021-1521": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2021-1522": {"epss_score": 0.00115, "epss_percentile": 0.30943}, "CVE-2021-1523": {"epss_score": 0.00537, "epss_percentile": 0.66894}, "CVE-2021-1524": {"epss_score": 0.00429, "epss_percentile": 0.61979}, "CVE-2021-1525": {"epss_score": 0.00183, "epss_percentile": 0.40331}, "CVE-2021-1526": {"epss_score": 0.00452, "epss_percentile": 0.63181}, "CVE-2021-1527": {"epss_score": 0.00332, "epss_percentile": 0.5557}, "CVE-2021-1528": {"epss_score": 0.00057, "epss_percentile": 0.181}, "CVE-2021-1529": {"epss_score": 0.00047, "epss_percentile": 0.14757}, "CVE-2021-1530": {"epss_score": 0.0045, "epss_percentile": 0.63102}, "CVE-2021-1531": {"epss_score": 0.14129, "epss_percentile": 0.94141}, "CVE-2021-1532": {"epss_score": 0.00211, "epss_percentile": 0.43672}, "CVE-2021-1534": {"epss_score": 0.00279, "epss_percentile": 0.50973}, "CVE-2021-1535": {"epss_score": 0.00307, "epss_percentile": 0.53528}, "CVE-2021-1536": {"epss_score": 0.00065, "epss_percentile": 0.20612}, "CVE-2021-1537": {"epss_score": 0.00076, "epss_percentile": 0.23096}, "CVE-2021-1538": {"epss_score": 0.01977, "epss_percentile": 0.83126}, "CVE-2021-1539": {"epss_score": 0.00285, "epss_percentile": 0.51501}, "CVE-2021-1540": {"epss_score": 0.00261, "epss_percentile": 0.49245}, "CVE-2021-1541": {"epss_score": 0.00384, "epss_percentile": 0.59159}, "CVE-2021-1542": {"epss_score": 0.00382, "epss_percentile": 0.59039}, "CVE-2021-1543": {"epss_score": 0.00276, "epss_percentile": 0.50751}, "CVE-2021-1544": {"epss_score": 0.00055, "epss_percentile": 0.17404}, "CVE-2021-1546": {"epss_score": 0.00154, "epss_percentile": 0.36646}, "CVE-2021-1547": {"epss_score": 0.00694, "epss_percentile": 0.71357}, "CVE-2021-1548": {"epss_score": 0.00694, "epss_percentile": 0.71357}, "CVE-2021-1549": {"epss_score": 0.00694, "epss_percentile": 0.71357}, "CVE-2021-1550": {"epss_score": 0.00694, "epss_percentile": 0.71357}, "CVE-2021-1551": {"epss_score": 0.00694, "epss_percentile": 0.71357}, "CVE-2021-1552": {"epss_score": 0.00694, "epss_percentile": 0.71357}, "CVE-2021-1553": {"epss_score": 0.00694, "epss_percentile": 0.71357}, "CVE-2021-1554": {"epss_score": 0.00694, "epss_percentile": 0.71357}, "CVE-2021-1555": {"epss_score": 0.00694, "epss_percentile": 0.71357}, "CVE-2021-1557": {"epss_score": 0.00069, "epss_percentile": 0.21442}, "CVE-2021-1558": {"epss_score": 0.00069, "epss_percentile": 0.21442}, "CVE-2021-1559": {"epss_score": 0.02551, "epss_percentile": 0.85077}, "CVE-2021-1560": {"epss_score": 0.02551, "epss_percentile": 0.85077}, "CVE-2021-1561": {"epss_score": 0.00137, "epss_percentile": 0.34332}, "CVE-2021-1562": {"epss_score": 0.00112, "epss_percentile": 0.30457}, "CVE-2021-1563": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2021-1564": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2021-1565": {"epss_score": 0.00296, "epss_percentile": 0.52569}, "CVE-2021-1566": {"epss_score": 0.00095, "epss_percentile": 0.27129}, "CVE-2021-1567": {"epss_score": 0.00039, "epss_percentile": 0.11779}, "CVE-2021-1568": {"epss_score": 0.00065, "epss_percentile": 0.20482}, "CVE-2021-1569": {"epss_score": 0.00306, "epss_percentile": 0.53454}, "CVE-2021-1570": {"epss_score": 0.00313, "epss_percentile": 0.54072}, "CVE-2021-1571": {"epss_score": 0.00258, "epss_percentile": 0.48987}, "CVE-2021-1572": {"epss_score": 0.00109, "epss_percentile": 0.30006}, "CVE-2021-1573": {"epss_score": 0.00183, "epss_percentile": 0.40358}, "CVE-2021-1574": {"epss_score": 0.01529, "epss_percentile": 0.8088}, "CVE-2021-1575": {"epss_score": 0.00322, "epss_percentile": 0.54817}, "CVE-2021-1576": {"epss_score": 0.00136, "epss_percentile": 0.34157}, "CVE-2021-1577": {"epss_score": 0.00727, "epss_percentile": 0.72083}, "CVE-2021-1578": {"epss_score": 0.00674, "epss_percentile": 0.70874}, "CVE-2021-1579": {"epss_score": 0.00856, "epss_percentile": 0.74487}, "CVE-2021-1580": {"epss_score": 0.01859, "epss_percentile": 0.82584}, "CVE-2021-1581": {"epss_score": 0.03001, "epss_percentile": 0.86167}, "CVE-2021-1582": {"epss_score": 0.0017, "epss_percentile": 0.38702}, "CVE-2021-1583": {"epss_score": 0.00157, "epss_percentile": 0.37084}, "CVE-2021-1584": {"epss_score": 0.00111, "epss_percentile": 0.30257}, "CVE-2021-1585": {"epss_score": 0.53069, "epss_percentile": 0.97856}, "CVE-2021-1586": {"epss_score": 0.0008, "epss_percentile": 0.24205}, "CVE-2021-1587": {"epss_score": 0.00575, "epss_percentile": 0.68112}, "CVE-2021-1588": {"epss_score": 0.0138, "epss_percentile": 0.79862}, "CVE-2021-1589": {"epss_score": 0.0024, "epss_percentile": 0.4722}, "CVE-2021-1590": {"epss_score": 0.00822, "epss_percentile": 0.73917}, "CVE-2021-1591": {"epss_score": 0.00293, "epss_percentile": 0.52288}, "CVE-2021-1592": {"epss_score": 0.00415, "epss_percentile": 0.61116}, "CVE-2021-1593": {"epss_score": 0.00051, "epss_percentile": 0.16112}, "CVE-2021-1594": {"epss_score": 0.00156, "epss_percentile": 0.36899}, "CVE-2021-1595": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-1596": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-1597": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-1598": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-1599": {"epss_score": 0.00323, "epss_percentile": 0.54875}, "CVE-2021-1600": {"epss_score": 0.00107, "epss_percentile": 0.2963}, "CVE-2021-1601": {"epss_score": 0.00107, "epss_percentile": 0.2963}, "CVE-2021-1602": {"epss_score": 0.01615, "epss_percentile": 0.81351}, "CVE-2021-1603": {"epss_score": 0.00161, "epss_percentile": 0.37563}, "CVE-2021-1604": {"epss_score": 0.00161, "epss_percentile": 0.37563}, "CVE-2021-1605": {"epss_score": 0.00161, "epss_percentile": 0.37563}, "CVE-2021-1606": {"epss_score": 0.00146, "epss_percentile": 0.35599}, "CVE-2021-1607": {"epss_score": 0.00161, "epss_percentile": 0.37563}, "CVE-2021-1609": {"epss_score": 0.0081, "epss_percentile": 0.73721}, "CVE-2021-1610": {"epss_score": 0.00664, "epss_percentile": 0.70632}, "CVE-2021-1611": {"epss_score": 0.00491, "epss_percentile": 0.64953}, "CVE-2021-1612": {"epss_score": 0.00048, "epss_percentile": 0.15254}, "CVE-2021-1614": {"epss_score": 0.00536, "epss_percentile": 0.66885}, "CVE-2021-1615": {"epss_score": 0.00442, "epss_percentile": 0.62739}, "CVE-2021-1616": {"epss_score": 0.00429, "epss_percentile": 0.61997}, "CVE-2021-1617": {"epss_score": 0.0068, "epss_percentile": 0.71029}, "CVE-2021-1618": {"epss_score": 0.02162, "epss_percentile": 0.83831}, "CVE-2021-1619": {"epss_score": 0.00869, "epss_percentile": 0.74693}, "CVE-2021-1620": {"epss_score": 0.0033, "epss_percentile": 0.55436}, "CVE-2021-1621": {"epss_score": 0.00087, "epss_percentile": 0.25454}, "CVE-2021-1622": {"epss_score": 0.00266, "epss_percentile": 0.49924}, "CVE-2021-1623": {"epss_score": 0.00344, "epss_percentile": 0.56498}, "CVE-2021-1624": {"epss_score": 0.00418, "epss_percentile": 0.61283}, "CVE-2021-1625": {"epss_score": 0.00387, "epss_percentile": 0.59335}, "CVE-2021-1626": {"epss_score": 0.02269, "epss_percentile": 0.84203}, "CVE-2021-1627": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2021-1628": {"epss_score": 0.00351, "epss_percentile": 0.57013}, "CVE-2021-1629": {"epss_score": 0.0029, "epss_percentile": 0.52114}, "CVE-2021-1630": {"epss_score": 0.00417, "epss_percentile": 0.61236}, "CVE-2021-1636": {"epss_score": 0.05167, "epss_percentile": 0.89566}, "CVE-2021-1637": {"epss_score": 0.00281, "epss_percentile": 0.5112}, "CVE-2021-1638": {"epss_score": 0.00612, "epss_percentile": 0.69224}, "CVE-2021-1639": {"epss_score": 0.03044, "epss_percentile": 0.8628}, "CVE-2021-1640": {"epss_score": 0.01237, "epss_percentile": 0.78781}, "CVE-2021-1641": {"epss_score": 0.01251, "epss_percentile": 0.78892}, "CVE-2021-1642": {"epss_score": 0.0034, "epss_percentile": 0.56255}, "CVE-2021-1643": {"epss_score": 0.08236, "epss_percentile": 0.91943}, "CVE-2021-1644": {"epss_score": 0.08236, "epss_percentile": 0.91943}, "CVE-2021-1645": {"epss_score": 0.28181, "epss_percentile": 0.9633}, "CVE-2021-1646": {"epss_score": 0.00307, "epss_percentile": 0.53496}, "CVE-2021-1647": {"epss_score": 0.73986, "epss_percentile": 0.98779}, "CVE-2021-1648": {"epss_score": 0.00736, "epss_percentile": 0.72315}, "CVE-2021-1649": {"epss_score": 0.00271, "epss_percentile": 0.50325}, "CVE-2021-1650": {"epss_score": 0.00205, "epss_percentile": 0.42751}, "CVE-2021-1651": {"epss_score": 0.00313, "epss_percentile": 0.54022}, "CVE-2021-1652": {"epss_score": 0.00271, "epss_percentile": 0.50325}, "CVE-2021-1653": {"epss_score": 0.00271, "epss_percentile": 0.50325}, "CVE-2021-1654": {"epss_score": 0.00271, "epss_percentile": 0.50325}, "CVE-2021-1655": {"epss_score": 0.00271, "epss_percentile": 0.50325}, "CVE-2021-1656": {"epss_score": 0.01602, "epss_percentile": 0.81271}, "CVE-2021-1657": {"epss_score": 0.00484, "epss_percentile": 0.64646}, "CVE-2021-1658": {"epss_score": 0.04375, "epss_percentile": 0.88616}, "CVE-2021-1659": {"epss_score": 0.00206, "epss_percentile": 0.43074}, "CVE-2021-1660": {"epss_score": 0.04375, "epss_percentile": 0.88616}, "CVE-2021-1661": {"epss_score": 0.00407, "epss_percentile": 0.60588}, "CVE-2021-1662": {"epss_score": 0.00256, "epss_percentile": 0.48812}, "CVE-2021-1663": {"epss_score": 0.00541, "epss_percentile": 0.67026}, "CVE-2021-1664": {"epss_score": 0.04375, "epss_percentile": 0.88616}, "CVE-2021-1665": {"epss_score": 0.14724, "epss_percentile": 0.9427}, "CVE-2021-1666": {"epss_score": 0.04375, "epss_percentile": 0.88616}, "CVE-2021-1667": {"epss_score": 0.08485, "epss_percentile": 0.92077}, "CVE-2021-1668": {"epss_score": 0.05344, "epss_percentile": 0.89766}, "CVE-2021-1669": {"epss_score": 0.05451, "epss_percentile": 0.89891}, "CVE-2021-1670": {"epss_score": 0.00541, "epss_percentile": 0.67026}, "CVE-2021-1671": {"epss_score": 0.04375, "epss_percentile": 0.88616}, "CVE-2021-1672": {"epss_score": 0.00541, "epss_percentile": 0.67026}, "CVE-2021-1673": {"epss_score": 0.04375, "epss_percentile": 0.88616}, "CVE-2021-1674": {"epss_score": 0.03306, "epss_percentile": 0.86877}, "CVE-2021-1675": {"epss_score": 0.94314, "epss_percentile": 0.99945}, "CVE-2021-1676": {"epss_score": 0.00695, "epss_percentile": 0.71365}, "CVE-2021-1677": {"epss_score": 0.00484, "epss_percentile": 0.64657}, "CVE-2021-1678": {"epss_score": 0.63432, "epss_percentile": 0.98333}, "CVE-2021-1679": {"epss_score": 0.06672, "epss_percentile": 0.90934}, "CVE-2021-1680": {"epss_score": 0.00256, "epss_percentile": 0.48812}, "CVE-2021-1681": {"epss_score": 0.00187, "epss_percentile": 0.40778}, "CVE-2021-1682": {"epss_score": 0.00155, "epss_percentile": 0.36781}, "CVE-2021-1683": {"epss_score": 0.03628, "epss_percentile": 0.87466}, "CVE-2021-1684": {"epss_score": 0.03628, "epss_percentile": 0.87466}, "CVE-2021-1685": {"epss_score": 0.00662, "epss_percentile": 0.70599}, "CVE-2021-1686": {"epss_score": 0.00256, "epss_percentile": 0.48812}, "CVE-2021-1687": {"epss_score": 0.00256, "epss_percentile": 0.48812}, "CVE-2021-1688": {"epss_score": 0.00206, "epss_percentile": 0.43074}, "CVE-2021-1689": {"epss_score": 0.00206, "epss_percentile": 0.4292}, "CVE-2021-1690": {"epss_score": 0.00256, "epss_percentile": 0.48812}, "CVE-2021-1691": {"epss_score": 0.00997, "epss_percentile": 0.76457}, "CVE-2021-1692": {"epss_score": 0.00804, "epss_percentile": 0.73614}, "CVE-2021-1693": {"epss_score": 0.00271, "epss_percentile": 0.50325}, "CVE-2021-1694": {"epss_score": 0.02206, "epss_percentile": 0.84003}, "CVE-2021-1695": {"epss_score": 0.00475, "epss_percentile": 0.64192}, "CVE-2021-1696": {"epss_score": 0.14305, "epss_percentile": 0.94184}, "CVE-2021-1697": {"epss_score": 0.00313, "epss_percentile": 0.54022}, "CVE-2021-1698": {"epss_score": 0.00595, "epss_percentile": 0.68694}, "CVE-2021-1699": {"epss_score": 0.01081, "epss_percentile": 0.77375}, "CVE-2021-1700": {"epss_score": 0.08485, "epss_percentile": 0.92077}, "CVE-2021-1701": {"epss_score": 0.08485, "epss_percentile": 0.92077}, "CVE-2021-1702": {"epss_score": 0.0025, "epss_percentile": 0.48097}, "CVE-2021-1703": {"epss_score": 0.00288, "epss_percentile": 0.51901}, "CVE-2021-1704": {"epss_score": 0.0056, "epss_percentile": 0.67654}, "CVE-2021-1705": {"epss_score": 0.01249, "epss_percentile": 0.78871}, "CVE-2021-1706": {"epss_score": 0.01737, "epss_percentile": 0.82019}, "CVE-2021-1707": {"epss_score": 0.06525, "epss_percentile": 0.90821}, "CVE-2021-1708": {"epss_score": 0.13476, "epss_percentile": 0.93975}, "CVE-2021-1709": {"epss_score": 0.00238, "epss_percentile": 0.46815}, "CVE-2021-1710": {"epss_score": 0.02197, "epss_percentile": 0.83961}, "CVE-2021-1711": {"epss_score": 0.05381, "epss_percentile": 0.89811}, "CVE-2021-1712": {"epss_score": 0.02045, "epss_percentile": 0.83384}, "CVE-2021-1713": {"epss_score": 0.05319, "epss_percentile": 0.89726}, "CVE-2021-1714": {"epss_score": 0.03316, "epss_percentile": 0.86901}, "CVE-2021-1715": {"epss_score": 0.03398, "epss_percentile": 0.87063}, "CVE-2021-1716": {"epss_score": 0.05513, "epss_percentile": 0.89948}, "CVE-2021-1717": {"epss_score": 0.01251, "epss_percentile": 0.78892}, "CVE-2021-1718": {"epss_score": 0.02863, "epss_percentile": 0.85856}, "CVE-2021-1719": {"epss_score": 0.02045, "epss_percentile": 0.83384}, "CVE-2021-1721": {"epss_score": 0.07099, "epss_percentile": 0.91249}, "CVE-2021-1722": {"epss_score": 0.06416, "epss_percentile": 0.90745}, "CVE-2021-1723": {"epss_score": 0.04579, "epss_percentile": 0.88872}, "CVE-2021-1724": {"epss_score": 0.00945, "epss_percentile": 0.75797}, "CVE-2021-1725": {"epss_score": 0.0052, "epss_percentile": 0.66215}, "CVE-2021-1726": {"epss_score": 0.05312, "epss_percentile": 0.89719}, "CVE-2021-1727": {"epss_score": 0.00137, "epss_percentile": 0.34288}, "CVE-2021-1728": {"epss_score": 0.01058, "epss_percentile": 0.77146}, "CVE-2021-1729": {"epss_score": 0.00184, "epss_percentile": 0.40372}, "CVE-2021-1730": {"epss_score": 0.02229, "epss_percentile": 0.84079}, "CVE-2021-1731": {"epss_score": 0.00533, "epss_percentile": 0.66751}, "CVE-2021-1732": {"epss_score": 0.90988, "epss_percentile": 0.99613}, "CVE-2021-1733": {"epss_score": 0.00322, "epss_percentile": 0.54787}, "CVE-2021-1734": {"epss_score": 0.20315, "epss_percentile": 0.95321}, "CVE-2021-1736": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-1737": {"epss_score": 0.00266, "epss_percentile": 0.49907}, "CVE-2021-1738": {"epss_score": 0.00266, "epss_percentile": 0.49907}, "CVE-2021-1739": {"epss_score": 0.00066, "epss_percentile": 0.20853}, "CVE-2021-1740": {"epss_score": 0.00069, "epss_percentile": 0.21612}, "CVE-2021-1741": {"epss_score": 0.00395, "epss_percentile": 0.59815}, "CVE-2021-1742": {"epss_score": 0.00395, "epss_percentile": 0.59815}, "CVE-2021-1743": {"epss_score": 0.00568, "epss_percentile": 0.67885}, "CVE-2021-1744": {"epss_score": 0.00693, "epss_percentile": 0.71336}, "CVE-2021-1745": {"epss_score": 0.00338, "epss_percentile": 0.56144}, "CVE-2021-1746": {"epss_score": 0.00881, "epss_percentile": 0.7488}, "CVE-2021-1747": {"epss_score": 0.00785, "epss_percentile": 0.73252}, "CVE-2021-1748": {"epss_score": 0.01209, "epss_percentile": 0.78544}, "CVE-2021-1750": {"epss_score": 0.00553, "epss_percentile": 0.67411}, "CVE-2021-1751": {"epss_score": 0.00197, "epss_percentile": 0.41887}, "CVE-2021-1753": {"epss_score": 0.00362, "epss_percentile": 0.57758}, "CVE-2021-1754": {"epss_score": 0.00772, "epss_percentile": 0.73034}, "CVE-2021-1755": {"epss_score": 0.00131, "epss_percentile": 0.33404}, "CVE-2021-1756": {"epss_score": 0.00139, "epss_percentile": 0.34562}, "CVE-2021-1757": {"epss_score": 0.00232, "epss_percentile": 0.45908}, "CVE-2021-1758": {"epss_score": 0.01347, "epss_percentile": 0.79658}, "CVE-2021-1759": {"epss_score": 0.00637, "epss_percentile": 0.69897}, "CVE-2021-1760": {"epss_score": 0.00338, "epss_percentile": 0.56067}, "CVE-2021-1761": {"epss_score": 0.01093, "epss_percentile": 0.77473}, "CVE-2021-1762": {"epss_score": 0.00275, "epss_percentile": 0.50677}, "CVE-2021-1763": {"epss_score": 0.00404, "epss_percentile": 0.60415}, "CVE-2021-1764": {"epss_score": 0.01093, "epss_percentile": 0.77473}, "CVE-2021-1765": {"epss_score": 0.00083, "epss_percentile": 0.24616}, "CVE-2021-1766": {"epss_score": 0.00309, "epss_percentile": 0.53661}, "CVE-2021-1767": {"epss_score": 0.00227, "epss_percentile": 0.45424}, "CVE-2021-1768": {"epss_score": 0.00276, "epss_percentile": 0.50772}, "CVE-2021-1769": {"epss_score": 0.00054, "epss_percentile": 0.17332}, "CVE-2021-1770": {"epss_score": 0.02359, "epss_percentile": 0.84491}, "CVE-2021-1771": {"epss_score": 0.00238, "epss_percentile": 0.46825}, "CVE-2021-1772": {"epss_score": 0.00683, "epss_percentile": 0.71108}, "CVE-2021-1773": {"epss_score": 0.00309, "epss_percentile": 0.53661}, "CVE-2021-1774": {"epss_score": 0.00419, "epss_percentile": 0.61386}, "CVE-2021-1775": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2021-1776": {"epss_score": 0.00359, "epss_percentile": 0.57551}, "CVE-2021-1777": {"epss_score": 0.00402, "epss_percentile": 0.60286}, "CVE-2021-1778": {"epss_score": 0.00309, "epss_percentile": 0.53661}, "CVE-2021-1779": {"epss_score": 0.00302, "epss_percentile": 0.53122}, "CVE-2021-1780": {"epss_score": 0.00184, "epss_percentile": 0.40398}, "CVE-2021-1781": {"epss_score": 0.00236, "epss_percentile": 0.46457}, "CVE-2021-1782": {"epss_score": 0.07901, "epss_percentile": 0.91754}, "CVE-2021-1783": {"epss_score": 0.00419, "epss_percentile": 0.61386}, "CVE-2021-1784": {"epss_score": 0.00382, "epss_percentile": 0.59049}, "CVE-2021-1785": {"epss_score": 0.00419, "epss_percentile": 0.61386}, "CVE-2021-1786": {"epss_score": 0.00158, "epss_percentile": 0.37213}, "CVE-2021-1787": {"epss_score": 0.00122, "epss_percentile": 0.32111}, "CVE-2021-1788": {"epss_score": 0.00408, "epss_percentile": 0.60622}, "CVE-2021-1789": {"epss_score": 0.00243, "epss_percentile": 0.47512}, "CVE-2021-1790": {"epss_score": 0.00306, "epss_percentile": 0.53423}, "CVE-2021-1791": {"epss_score": 0.00442, "epss_percentile": 0.62751}, "CVE-2021-1792": {"epss_score": 0.01041, "epss_percentile": 0.76962}, "CVE-2021-1793": {"epss_score": 0.00548, "epss_percentile": 0.67289}, "CVE-2021-1794": {"epss_score": 0.01558, "epss_percentile": 0.81025}, "CVE-2021-1795": {"epss_score": 0.01558, "epss_percentile": 0.81025}, "CVE-2021-1796": {"epss_score": 0.01558, "epss_percentile": 0.81025}, "CVE-2021-1797": {"epss_score": 0.00104, "epss_percentile": 0.29223}, "CVE-2021-1799": {"epss_score": 0.00127, "epss_percentile": 0.32821}, "CVE-2021-1800": {"epss_score": 0.00204, "epss_percentile": 0.42621}, "CVE-2021-1801": {"epss_score": 0.00247, "epss_percentile": 0.47849}, "CVE-2021-1802": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2021-1803": {"epss_score": 0.00188, "epss_percentile": 0.40863}, "CVE-2021-1805": {"epss_score": 0.00257, "epss_percentile": 0.48868}, "CVE-2021-1806": {"epss_score": 0.00199, "epss_percentile": 0.42117}, "CVE-2021-1807": {"epss_score": 0.00054, "epss_percentile": 0.17261}, "CVE-2021-1808": {"epss_score": 0.00542, "epss_percentile": 0.67068}, "CVE-2021-1809": {"epss_score": 0.00542, "epss_percentile": 0.67068}, "CVE-2021-1810": {"epss_score": 0.00213, "epss_percentile": 0.43835}, "CVE-2021-1811": {"epss_score": 0.00605, "epss_percentile": 0.6899}, "CVE-2021-1812": {"epss_score": 0.0039, "epss_percentile": 0.59521}, "CVE-2021-1813": {"epss_score": 0.00235, "epss_percentile": 0.46345}, "CVE-2021-1814": {"epss_score": 0.00317, "epss_percentile": 0.54314}, "CVE-2021-1815": {"epss_score": 0.0009, "epss_percentile": 0.26041}, "CVE-2021-1816": {"epss_score": 0.00404, "epss_percentile": 0.60416}, "CVE-2021-1817": {"epss_score": 0.0097, "epss_percentile": 0.76116}, "CVE-2021-1818": {"epss_score": 0.01746, "epss_percentile": 0.82071}, "CVE-2021-1820": {"epss_score": 0.0077, "epss_percentile": 0.73002}, "CVE-2021-1821": {"epss_score": 0.0039, "epss_percentile": 0.59501}, "CVE-2021-1822": {"epss_score": 0.00056, "epss_percentile": 0.17808}, "CVE-2021-1824": {"epss_score": 0.0005, "epss_percentile": 0.15899}, "CVE-2021-1825": {"epss_score": 0.00437, "epss_percentile": 0.62501}, "CVE-2021-1826": {"epss_score": 0.00741, "epss_percentile": 0.72413}, "CVE-2021-1828": {"epss_score": 0.00181, "epss_percentile": 0.40052}, "CVE-2021-1829": {"epss_score": 0.00841, "epss_percentile": 0.74227}, "CVE-2021-1830": {"epss_score": 0.00048, "epss_percentile": 0.1518}, "CVE-2021-1831": {"epss_score": 0.0018, "epss_percentile": 0.39908}, "CVE-2021-1832": {"epss_score": 0.00166, "epss_percentile": 0.38157}, "CVE-2021-1833": {"epss_score": 0.00256, "epss_percentile": 0.48739}, "CVE-2021-1834": {"epss_score": 0.01437, "epss_percentile": 0.80283}, "CVE-2021-1835": {"epss_score": 0.00128, "epss_percentile": 0.33057}, "CVE-2021-1836": {"epss_score": 0.00037, "epss_percentile": 0.10638}, "CVE-2021-1837": {"epss_score": 0.00089, "epss_percentile": 0.25813}, "CVE-2021-1838": {"epss_score": 0.00337, "epss_percentile": 0.56013}, "CVE-2021-1839": {"epss_score": 0.00038, "epss_percentile": 0.1122}, "CVE-2021-1840": {"epss_score": 0.00069, "epss_percentile": 0.21511}, "CVE-2021-1841": {"epss_score": 0.00202, "epss_percentile": 0.42411}, "CVE-2021-1843": {"epss_score": 0.00344, "epss_percentile": 0.56494}, "CVE-2021-1844": {"epss_score": 0.0117, "epss_percentile": 0.78207}, "CVE-2021-1846": {"epss_score": 0.00296, "epss_percentile": 0.52573}, "CVE-2021-1847": {"epss_score": 0.00407, "epss_percentile": 0.60593}, "CVE-2021-1848": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2021-1849": {"epss_score": 0.00154, "epss_percentile": 0.36745}, "CVE-2021-1851": {"epss_score": 0.00913, "epss_percentile": 0.75375}, "CVE-2021-1852": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2021-1853": {"epss_score": 0.00038, "epss_percentile": 0.11271}, "CVE-2021-1854": {"epss_score": 0.00206, "epss_percentile": 0.43072}, "CVE-2021-1855": {"epss_score": 0.0023, "epss_percentile": 0.45715}, "CVE-2021-1857": {"epss_score": 0.00605, "epss_percentile": 0.6899}, "CVE-2021-1858": {"epss_score": 0.00483, "epss_percentile": 0.6456}, "CVE-2021-1859": {"epss_score": 0.00308, "epss_percentile": 0.53584}, "CVE-2021-1860": {"epss_score": 0.00522, "epss_percentile": 0.66281}, "CVE-2021-1861": {"epss_score": 0.0025, "epss_percentile": 0.48248}, "CVE-2021-1862": {"epss_score": 0.00057, "epss_percentile": 0.18106}, "CVE-2021-1863": {"epss_score": 0.0005, "epss_percentile": 0.15724}, "CVE-2021-1864": {"epss_score": 0.01689, "epss_percentile": 0.81768}, "CVE-2021-1865": {"epss_score": 0.001, "epss_percentile": 0.28522}, "CVE-2021-1867": {"epss_score": 0.00415, "epss_percentile": 0.61128}, "CVE-2021-1868": {"epss_score": 0.00056, "epss_percentile": 0.17789}, "CVE-2021-1870": {"epss_score": 0.01151, "epss_percentile": 0.78036}, "CVE-2021-1871": {"epss_score": 0.00855, "epss_percentile": 0.74462}, "CVE-2021-1872": {"epss_score": 0.00305, "epss_percentile": 0.53375}, "CVE-2021-1873": {"epss_score": 0.00308, "epss_percentile": 0.5362}, "CVE-2021-1874": {"epss_score": 0.00509, "epss_percentile": 0.65753}, "CVE-2021-1875": {"epss_score": 0.00249, "epss_percentile": 0.48062}, "CVE-2021-1876": {"epss_score": 0.00813, "epss_percentile": 0.73762}, "CVE-2021-1877": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2021-1878": {"epss_score": 0.00501, "epss_percentile": 0.65357}, "CVE-2021-1879": {"epss_score": 0.01942, "epss_percentile": 0.82984}, "CVE-2021-1880": {"epss_score": 0.00364, "epss_percentile": 0.57939}, "CVE-2021-1881": {"epss_score": 0.00502, "epss_percentile": 0.65408}, "CVE-2021-1882": {"epss_score": 0.00871, "epss_percentile": 0.74712}, "CVE-2021-1883": {"epss_score": 0.00994, "epss_percentile": 0.76429}, "CVE-2021-1884": {"epss_score": 0.01006, "epss_percentile": 0.76552}, "CVE-2021-1885": {"epss_score": 0.00462, "epss_percentile": 0.63586}, "CVE-2021-1886": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2021-1887": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2021-1888": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2021-1889": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-1890": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2021-1891": {"epss_score": 0.00044, "epss_percentile": 0.13562}, "CVE-2021-1892": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2021-1894": {"epss_score": 0.00034, "epss_percentile": 0.09689}, "CVE-2021-1895": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2021-1896": {"epss_score": 0.00031, "epss_percentile": 0.08436}, "CVE-2021-1897": {"epss_score": 0.00113, "epss_percentile": 0.30634}, "CVE-2021-1898": {"epss_score": 0.00046, "epss_percentile": 0.14422}, "CVE-2021-1899": {"epss_score": 0.00046, "epss_percentile": 0.14422}, "CVE-2021-1900": {"epss_score": 0.00034, "epss_percentile": 0.09712}, "CVE-2021-1901": {"epss_score": 0.00046, "epss_percentile": 0.14422}, "CVE-2021-1903": {"epss_score": 0.00216, "epss_percentile": 0.44157}, "CVE-2021-1904": {"epss_score": 0.00132, "epss_percentile": 0.33513}, "CVE-2021-1905": {"epss_score": 0.00889, "epss_percentile": 0.75022}, "CVE-2021-1906": {"epss_score": 0.00149, "epss_percentile": 0.35991}, "CVE-2021-1907": {"epss_score": 0.00329, "epss_percentile": 0.55405}, "CVE-2021-1909": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-1910": {"epss_score": 0.00232, "epss_percentile": 0.45875}, "CVE-2021-1912": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2021-1913": {"epss_score": 0.00035, "epss_percentile": 0.09892}, "CVE-2021-1914": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2021-1915": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-1916": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2021-1917": {"epss_score": 0.00035, "epss_percentile": 0.09892}, "CVE-2021-1918": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2021-1919": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2021-1920": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2021-1921": {"epss_score": 0.0003, "epss_percentile": 0.08207}, "CVE-2021-1923": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2021-1924": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2021-1925": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2021-1927": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2021-1928": {"epss_score": 0.00045, "epss_percentile": 0.13919}, "CVE-2021-1929": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2021-1930": {"epss_score": 0.00041, "epss_percentile": 0.1231}, "CVE-2021-1931": {"epss_score": 0.00017, "epss_percentile": 0.03496}, "CVE-2021-1932": {"epss_score": 0.00031, "epss_percentile": 0.08328}, "CVE-2021-1933": {"epss_score": 0.00251, "epss_percentile": 0.48323}, "CVE-2021-1934": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2021-1935": {"epss_score": 0.0004, "epss_percentile": 0.1193}, "CVE-2021-1936": {"epss_score": 0.00246, "epss_percentile": 0.47772}, "CVE-2021-1937": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2021-1938": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2021-1939": {"epss_score": 0.00033, "epss_percentile": 0.09283}, "CVE-2021-1940": {"epss_score": 0.00024, "epss_percentile": 0.05954}, "CVE-2021-1941": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2021-1942": {"epss_score": 0.00029, "epss_percentile": 0.07933}, "CVE-2021-1943": {"epss_score": 0.00394, "epss_percentile": 0.59774}, "CVE-2021-1945": {"epss_score": 0.00305, "epss_percentile": 0.5337}, "CVE-2021-1946": {"epss_score": 0.00216, "epss_percentile": 0.44138}, "CVE-2021-1947": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2021-1948": {"epss_score": 0.00317, "epss_percentile": 0.54338}, "CVE-2021-1949": {"epss_score": 0.00099, "epss_percentile": 0.28401}, "CVE-2021-1950": {"epss_score": 0.00031, "epss_percentile": 0.08709}, "CVE-2021-1952": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2021-1953": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2021-1954": {"epss_score": 0.00394, "epss_percentile": 0.59774}, "CVE-2021-1955": {"epss_score": 0.00305, "epss_percentile": 0.5337}, "CVE-2021-1956": {"epss_score": 0.00071, "epss_percentile": 0.22183}, "CVE-2021-1957": {"epss_score": 0.00061, "epss_percentile": 0.19387}, "CVE-2021-1958": {"epss_score": 0.00037, "epss_percentile": 0.1099}, "CVE-2021-1959": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2021-1960": {"epss_score": 0.00071, "epss_percentile": 0.22183}, "CVE-2021-1961": {"epss_score": 0.01928, "epss_percentile": 0.8293}, "CVE-2021-1962": {"epss_score": 0.00059, "epss_percentile": 0.18827}, "CVE-2021-1963": {"epss_score": 0.00048, "epss_percentile": 0.15198}, "CVE-2021-1964": {"epss_score": 0.00394, "epss_percentile": 0.59774}, "CVE-2021-1965": {"epss_score": 0.2745, "epss_percentile": 0.96246}, "CVE-2021-1966": {"epss_score": 0.00059, "epss_percentile": 0.18827}, "CVE-2021-1967": {"epss_score": 0.0006, "epss_percentile": 0.19182}, "CVE-2021-1968": {"epss_score": 0.00018, "epss_percentile": 0.03927}, "CVE-2021-1969": {"epss_score": 0.00035, "epss_percentile": 0.10077}, "CVE-2021-1970": {"epss_score": 0.00216, "epss_percentile": 0.44185}, "CVE-2021-1971": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2021-1972": {"epss_score": 0.00356, "epss_percentile": 0.57383}, "CVE-2021-1973": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2021-1974": {"epss_score": 0.00305, "epss_percentile": 0.5337}, "CVE-2021-1975": {"epss_score": 0.00325, "epss_percentile": 0.55019}, "CVE-2021-1976": {"epss_score": 0.00388, "epss_percentile": 0.5934}, "CVE-2021-1977": {"epss_score": 0.00336, "epss_percentile": 0.56001}, "CVE-2021-1979": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-1980": {"epss_score": 0.00434, "epss_percentile": 0.6231}, "CVE-2021-1981": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2021-1982": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2021-1983": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-1984": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2021-1985": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2021-1993": {"epss_score": 0.00232, "epss_percentile": 0.45939}, "CVE-2021-1994": {"epss_score": 0.26765, "epss_percentile": 0.96177}, "CVE-2021-1995": {"epss_score": 0.00355, "epss_percentile": 0.57267}, "CVE-2021-1996": {"epss_score": 0.00386, "epss_percentile": 0.59258}, "CVE-2021-1997": {"epss_score": 0.01352, "epss_percentile": 0.79691}, "CVE-2021-1998": {"epss_score": 0.00349, "epss_percentile": 0.56883}, "CVE-2021-1999": {"epss_score": 0.00081, "epss_percentile": 0.24325}, "CVE-2021-20001": {"epss_score": 0.00765, "epss_percentile": 0.72917}, "CVE-2021-20016": {"epss_score": 0.79818, "epss_percentile": 0.99056}, "CVE-2021-20017": {"epss_score": 0.02622, "epss_percentile": 0.85257}, "CVE-2021-20018": {"epss_score": 0.00092, "epss_percentile": 0.26501}, "CVE-2021-20019": {"epss_score": 0.01045, "epss_percentile": 0.77014}, "CVE-2021-20020": {"epss_score": 0.02384, "epss_percentile": 0.84575}, "CVE-2021-20021": {"epss_score": 0.90152, "epss_percentile": 0.99565}, "CVE-2021-20022": {"epss_score": 0.32596, "epss_percentile": 0.9671}, "CVE-2021-20023": {"epss_score": 0.47755, "epss_percentile": 0.97599}, "CVE-2021-20024": {"epss_score": 0.00076, "epss_percentile": 0.23082}, "CVE-2021-20025": {"epss_score": 0.00024, "epss_percentile": 0.05951}, "CVE-2021-20026": {"epss_score": 0.0278, "epss_percentile": 0.85649}, "CVE-2021-20027": {"epss_score": 0.00432, "epss_percentile": 0.62117}, "CVE-2021-20028": {"epss_score": 0.85685, "epss_percentile": 0.99343}, "CVE-2021-20030": {"epss_score": 0.01141, "epss_percentile": 0.77962}, "CVE-2021-20031": {"epss_score": 0.36219, "epss_percentile": 0.96961}, "CVE-2021-20032": {"epss_score": 0.01045, "epss_percentile": 0.77012}, "CVE-2021-20034": {"epss_score": 0.04701, "epss_percentile": 0.89025}, "CVE-2021-20035": {"epss_score": 0.04544, "epss_percentile": 0.88832}, "CVE-2021-20037": {"epss_score": 0.00025, "epss_percentile": 0.06141}, "CVE-2021-20038": {"epss_score": 0.94292, "epss_percentile": 0.99936}, "CVE-2021-20039": {"epss_score": 0.82461, "epss_percentile": 0.99196}, "CVE-2021-20040": {"epss_score": 0.08808, "epss_percentile": 0.92263}, "CVE-2021-20041": {"epss_score": 0.00601, "epss_percentile": 0.68854}, "CVE-2021-20042": {"epss_score": 0.00883, "epss_percentile": 0.74919}, "CVE-2021-20043": {"epss_score": 0.0493, "epss_percentile": 0.89297}, "CVE-2021-20044": {"epss_score": 0.05675, "epss_percentile": 0.90109}, "CVE-2021-20045": {"epss_score": 0.03739, "epss_percentile": 0.87655}, "CVE-2021-20046": {"epss_score": 0.01131, "epss_percentile": 0.77863}, "CVE-2021-20047": {"epss_score": 0.00082, "epss_percentile": 0.24495}, "CVE-2021-20048": {"epss_score": 0.01131, "epss_percentile": 0.77863}, "CVE-2021-20049": {"epss_score": 0.00334, "epss_percentile": 0.55709}, "CVE-2021-20050": {"epss_score": 0.00175, "epss_percentile": 0.39296}, "CVE-2021-20051": {"epss_score": 0.00019, "epss_percentile": 0.04085}, "CVE-2021-20066": {"epss_score": 0.00378, "epss_percentile": 0.58813}, "CVE-2021-20067": {"epss_score": 0.00187, "epss_percentile": 0.40731}, "CVE-2021-20068": {"epss_score": 0.00212, "epss_percentile": 0.43759}, "CVE-2021-20069": {"epss_score": 0.00212, "epss_percentile": 0.43759}, "CVE-2021-20070": {"epss_score": 0.00212, "epss_percentile": 0.43759}, "CVE-2021-20071": {"epss_score": 0.00212, "epss_percentile": 0.43759}, "CVE-2021-20072": {"epss_score": 0.01894, "epss_percentile": 0.82745}, "CVE-2021-20073": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2021-20074": {"epss_score": 0.00555, "epss_percentile": 0.67472}, "CVE-2021-20075": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2021-20076": {"epss_score": 0.03466, "epss_percentile": 0.8719}, "CVE-2021-20077": {"epss_score": 0.00042, "epss_percentile": 0.12804}, "CVE-2021-20078": {"epss_score": 0.48645, "epss_percentile": 0.97646}, "CVE-2021-20079": {"epss_score": 0.00145, "epss_percentile": 0.35353}, "CVE-2021-20080": {"epss_score": 0.23388, "epss_percentile": 0.95773}, "CVE-2021-20081": {"epss_score": 0.64528, "epss_percentile": 0.98381}, "CVE-2021-20083": {"epss_score": 0.07286, "epss_percentile": 0.91384}, "CVE-2021-20084": {"epss_score": 0.004, "epss_percentile": 0.60159}, "CVE-2021-20085": {"epss_score": 0.00546, "epss_percentile": 0.67223}, "CVE-2021-20086": {"epss_score": 0.30086, "epss_percentile": 0.96506}, "CVE-2021-20087": {"epss_score": 0.00634, "epss_percentile": 0.69805}, "CVE-2021-20088": {"epss_score": 0.00349, "epss_percentile": 0.56855}, "CVE-2021-20089": {"epss_score": 0.00852, "epss_percentile": 0.74423}, "CVE-2021-20090": {"epss_score": 0.94401, "epss_percentile": 0.99973}, "CVE-2021-20091": {"epss_score": 0.8599, "epss_percentile": 0.9936}, "CVE-2021-20092": {"epss_score": 0.68874, "epss_percentile": 0.98566}, "CVE-2021-20093": {"epss_score": 0.08202, "epss_percentile": 0.91928}, "CVE-2021-20094": {"epss_score": 0.02543, "epss_percentile": 0.85058}, "CVE-2021-20096": {"epss_score": 0.00149, "epss_percentile": 0.36043}, "CVE-2021-20099": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2021-20100": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2021-20101": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-20102": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2021-20103": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-20104": {"epss_score": 0.01291, "epss_percentile": 0.79227}, "CVE-2021-20105": {"epss_score": 0.00215, "epss_percentile": 0.44086}, "CVE-2021-20106": {"epss_score": 0.003, "epss_percentile": 0.52924}, "CVE-2021-20107": {"epss_score": 0.00074, "epss_percentile": 0.22741}, "CVE-2021-20108": {"epss_score": 0.02752, "epss_percentile": 0.85584}, "CVE-2021-20109": {"epss_score": 0.0279, "epss_percentile": 0.85666}, "CVE-2021-20110": {"epss_score": 0.01866, "epss_percentile": 0.82614}, "CVE-2021-20111": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-20112": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-20113": {"epss_score": 0.00302, "epss_percentile": 0.53167}, "CVE-2021-20114": {"epss_score": 0.53868, "epss_percentile": 0.97901}, "CVE-2021-20115": {"epss_score": 0.00264, "epss_percentile": 0.49695}, "CVE-2021-20116": {"epss_score": 0.00264, "epss_percentile": 0.49695}, "CVE-2021-20117": {"epss_score": 0.00043, "epss_percentile": 0.13185}, "CVE-2021-20118": {"epss_score": 0.00043, "epss_percentile": 0.13185}, "CVE-2021-20119": {"epss_score": 0.00094, "epss_percentile": 0.26777}, "CVE-2021-20120": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2021-20121": {"epss_score": 0.00072, "epss_percentile": 0.224}, "CVE-2021-20122": {"epss_score": 0.08536, "epss_percentile": 0.92108}, "CVE-2021-20123": {"epss_score": 0.93989, "epss_percentile": 0.99881}, "CVE-2021-20124": {"epss_score": 0.94059, "epss_percentile": 0.99895}, "CVE-2021-20125": {"epss_score": 0.02971, "epss_percentile": 0.86093}, "CVE-2021-20126": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-20127": {"epss_score": 0.00346, "epss_percentile": 0.56707}, "CVE-2021-20128": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-20129": {"epss_score": 0.01029, "epss_percentile": 0.76835}, "CVE-2021-20130": {"epss_score": 0.48417, "epss_percentile": 0.97636}, "CVE-2021-20131": {"epss_score": 0.48417, "epss_percentile": 0.97636}, "CVE-2021-20132": {"epss_score": 0.0047, "epss_percentile": 0.63981}, "CVE-2021-20133": {"epss_score": 0.00485, "epss_percentile": 0.64737}, "CVE-2021-20134": {"epss_score": 0.01093, "epss_percentile": 0.77483}, "CVE-2021-20135": {"epss_score": 0.00049, "epss_percentile": 0.15614}, "CVE-2021-20136": {"epss_score": 0.31399, "epss_percentile": 0.96617}, "CVE-2021-20137": {"epss_score": 0.11461, "epss_percentile": 0.93373}, "CVE-2021-20138": {"epss_score": 0.08179, "epss_percentile": 0.91917}, "CVE-2021-20139": {"epss_score": 0.07766, "epss_percentile": 0.9167}, "CVE-2021-20140": {"epss_score": 0.07766, "epss_percentile": 0.9167}, "CVE-2021-20141": {"epss_score": 0.07766, "epss_percentile": 0.9167}, "CVE-2021-20142": {"epss_score": 0.07766, "epss_percentile": 0.9167}, "CVE-2021-20143": {"epss_score": 0.07766, "epss_percentile": 0.9167}, "CVE-2021-20144": {"epss_score": 0.07766, "epss_percentile": 0.9167}, "CVE-2021-20145": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2021-20146": {"epss_score": 0.01493, "epss_percentile": 0.80638}, "CVE-2021-20147": {"epss_score": 0.18027, "epss_percentile": 0.94945}, "CVE-2021-20148": {"epss_score": 0.00284, "epss_percentile": 0.51466}, "CVE-2021-20149": {"epss_score": 0.00706, "epss_percentile": 0.71605}, "CVE-2021-20150": {"epss_score": 0.38799, "epss_percentile": 0.9712}, "CVE-2021-20151": {"epss_score": 0.00706, "epss_percentile": 0.71605}, "CVE-2021-20152": {"epss_score": 0.00153, "epss_percentile": 0.36592}, "CVE-2021-20153": {"epss_score": 0.00385, "epss_percentile": 0.59205}, "CVE-2021-20154": {"epss_score": 0.00156, "epss_percentile": 0.36902}, "CVE-2021-20155": {"epss_score": 0.00732, "epss_percentile": 0.72192}, "CVE-2021-20156": {"epss_score": 0.00095, "epss_percentile": 0.27148}, "CVE-2021-20157": {"epss_score": 0.00503, "epss_percentile": 0.65463}, "CVE-2021-20158": {"epss_score": 0.8034, "epss_percentile": 0.99082}, "CVE-2021-20159": {"epss_score": 0.09123, "epss_percentile": 0.92409}, "CVE-2021-20160": {"epss_score": 0.09123, "epss_percentile": 0.92409}, "CVE-2021-20161": {"epss_score": 0.00043, "epss_percentile": 0.1335}, "CVE-2021-20162": {"epss_score": 0.00154, "epss_percentile": 0.36654}, "CVE-2021-20163": {"epss_score": 0.00261, "epss_percentile": 0.49303}, "CVE-2021-20164": {"epss_score": 0.00261, "epss_percentile": 0.49303}, "CVE-2021-20165": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-20166": {"epss_score": 0.64228, "epss_percentile": 0.98371}, "CVE-2021-20167": {"epss_score": 0.79422, "epss_percentile": 0.99037}, "CVE-2021-20168": {"epss_score": 0.00051, "epss_percentile": 0.16249}, "CVE-2021-20169": {"epss_score": 0.00023, "epss_percentile": 0.05422}, "CVE-2021-20170": {"epss_score": 0.00159, "epss_percentile": 0.37418}, "CVE-2021-20171": {"epss_score": 0.00059, "epss_percentile": 0.18635}, "CVE-2021-20172": {"epss_score": 0.00035, "epss_percentile": 0.10054}, "CVE-2021-20173": {"epss_score": 0.11544, "epss_percentile": 0.93401}, "CVE-2021-20174": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2021-20175": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2021-20176": {"epss_score": 0.00067, "epss_percentile": 0.21014}, "CVE-2021-20177": {"epss_score": 0.00054, "epss_percentile": 0.1717}, "CVE-2021-20178": {"epss_score": 0.0004, "epss_percentile": 0.12151}, "CVE-2021-20179": {"epss_score": 0.00399, "epss_percentile": 0.60105}, "CVE-2021-20180": {"epss_score": 0.00038, "epss_percentile": 0.11102}, "CVE-2021-20181": {"epss_score": 0.00019, "epss_percentile": 0.04378}, "CVE-2021-20182": {"epss_score": 0.0053, "epss_percentile": 0.66618}, "CVE-2021-20183": {"epss_score": 0.00617, "epss_percentile": 0.69358}, "CVE-2021-20184": {"epss_score": 0.00202, "epss_percentile": 0.42463}, "CVE-2021-20185": {"epss_score": 0.00478, "epss_percentile": 0.64401}, "CVE-2021-20186": {"epss_score": 0.00585, "epss_percentile": 0.68414}, "CVE-2021-20187": {"epss_score": 0.00683, "epss_percentile": 0.71102}, "CVE-2021-20188": {"epss_score": 0.00085, "epss_percentile": 0.25226}, "CVE-2021-20190": {"epss_score": 0.00404, "epss_percentile": 0.60445}, "CVE-2021-20191": {"epss_score": 0.00035, "epss_percentile": 0.09809}, "CVE-2021-20193": {"epss_score": 0.00069, "epss_percentile": 0.21516}, "CVE-2021-20194": {"epss_score": 0.0005, "epss_percentile": 0.15834}, "CVE-2021-20195": {"epss_score": 0.00305, "epss_percentile": 0.5333}, "CVE-2021-20196": {"epss_score": 0.00036, "epss_percentile": 0.10338}, "CVE-2021-20197": {"epss_score": 0.00115, "epss_percentile": 0.31034}, "CVE-2021-20198": {"epss_score": 0.00558, "epss_percentile": 0.67576}, "CVE-2021-20199": {"epss_score": 0.00604, "epss_percentile": 0.68966}, "CVE-2021-20201": {"epss_score": 0.0073, "epss_percentile": 0.7215}, "CVE-2021-20202": {"epss_score": 0.00046, "epss_percentile": 0.14111}, "CVE-2021-20203": {"epss_score": 0.00031, "epss_percentile": 0.08391}, "CVE-2021-20204": {"epss_score": 0.01955, "epss_percentile": 0.83033}, "CVE-2021-20205": {"epss_score": 0.00439, "epss_percentile": 0.62584}, "CVE-2021-20206": {"epss_score": 0.00121, "epss_percentile": 0.3182}, "CVE-2021-20208": {"epss_score": 0.00183, "epss_percentile": 0.40336}, "CVE-2021-20209": {"epss_score": 0.01071, "epss_percentile": 0.77267}, "CVE-2021-20210": {"epss_score": 0.01117, "epss_percentile": 0.77737}, "CVE-2021-20211": {"epss_score": 0.00825, "epss_percentile": 0.7395}, "CVE-2021-20212": {"epss_score": 0.01117, "epss_percentile": 0.77737}, "CVE-2021-20213": {"epss_score": 0.01263, "epss_percentile": 0.78988}, "CVE-2021-20214": {"epss_score": 0.01117, "epss_percentile": 0.77737}, "CVE-2021-20215": {"epss_score": 0.01117, "epss_percentile": 0.77737}, "CVE-2021-20216": {"epss_score": 0.01652, "epss_percentile": 0.81576}, "CVE-2021-20217": {"epss_score": 0.00453, "epss_percentile": 0.63217}, "CVE-2021-20218": {"epss_score": 0.00594, "epss_percentile": 0.68657}, "CVE-2021-20219": {"epss_score": 0.00052, "epss_percentile": 0.16348}, "CVE-2021-20220": {"epss_score": 0.0031, "epss_percentile": 0.5377}, "CVE-2021-20221": {"epss_score": 0.00023, "epss_percentile": 0.05632}, "CVE-2021-20222": {"epss_score": 0.0044, "epss_percentile": 0.6263}, "CVE-2021-20224": {"epss_score": 0.00031, "epss_percentile": 0.08663}, "CVE-2021-20225": {"epss_score": 0.00052, "epss_percentile": 0.16591}, "CVE-2021-20226": {"epss_score": 0.00146, "epss_percentile": 0.35607}, "CVE-2021-20227": {"epss_score": 0.0021, "epss_percentile": 0.43612}, "CVE-2021-20228": {"epss_score": 0.00137, "epss_percentile": 0.34262}, "CVE-2021-20229": {"epss_score": 0.00086, "epss_percentile": 0.25323}, "CVE-2021-20230": {"epss_score": 0.00209, "epss_percentile": 0.43373}, "CVE-2021-20231": {"epss_score": 0.00917, "epss_percentile": 0.75432}, "CVE-2021-20232": {"epss_score": 0.00844, "epss_percentile": 0.74277}, "CVE-2021-20233": {"epss_score": 0.0013, "epss_percentile": 0.33225}, "CVE-2021-20234": {"epss_score": 0.00452, "epss_percentile": 0.63173}, "CVE-2021-20235": {"epss_score": 0.09493, "epss_percentile": 0.92572}, "CVE-2021-20236": {"epss_score": 0.00377, "epss_percentile": 0.58714}, "CVE-2021-20237": {"epss_score": 0.0115, "epss_percentile": 0.78027}, "CVE-2021-20238": {"epss_score": 0.00142, "epss_percentile": 0.35073}, "CVE-2021-20239": {"epss_score": 0.00087, "epss_percentile": 0.25567}, "CVE-2021-20240": {"epss_score": 0.00794, "epss_percentile": 0.73436}, "CVE-2021-20241": {"epss_score": 0.00228, "epss_percentile": 0.45545}, "CVE-2021-20243": {"epss_score": 0.00228, "epss_percentile": 0.45545}, "CVE-2021-20244": {"epss_score": 0.0013, "epss_percentile": 0.33288}, "CVE-2021-20245": {"epss_score": 0.00166, "epss_percentile": 0.38227}, "CVE-2021-20246": {"epss_score": 0.00173, "epss_percentile": 0.39121}, "CVE-2021-20247": {"epss_score": 0.01449, "epss_percentile": 0.80345}, "CVE-2021-20250": {"epss_score": 0.00171, "epss_percentile": 0.38796}, "CVE-2021-20251": {"epss_score": 0.0023, "epss_percentile": 0.45688}, "CVE-2021-20252": {"epss_score": 0.00338, "epss_percentile": 0.56116}, "CVE-2021-20253": {"epss_score": 0.00278, "epss_percentile": 0.50845}, "CVE-2021-20254": {"epss_score": 0.0035, "epss_percentile": 0.56948}, "CVE-2021-20255": {"epss_score": 0.00167, "epss_percentile": 0.38329}, "CVE-2021-20256": {"epss_score": 0.00119, "epss_percentile": 0.31675}, "CVE-2021-20257": {"epss_score": 0.00076, "epss_percentile": 0.23169}, "CVE-2021-20259": {"epss_score": 0.00114, "epss_percentile": 0.30741}, "CVE-2021-20260": {"epss_score": 0.00033, "epss_percentile": 0.09397}, "CVE-2021-20261": {"epss_score": 0.00033, "epss_percentile": 0.09351}, "CVE-2021-20262": {"epss_score": 0.00044, "epss_percentile": 0.13497}, "CVE-2021-20263": {"epss_score": 0.00133, "epss_percentile": 0.3367}, "CVE-2021-20264": {"epss_score": 0.00119, "epss_percentile": 0.31641}, "CVE-2021-20265": {"epss_score": 0.0004, "epss_percentile": 0.12192}, "CVE-2021-20266": {"epss_score": 0.00063, "epss_percentile": 0.19965}, "CVE-2021-20267": {"epss_score": 0.00123, "epss_percentile": 0.32337}, "CVE-2021-20268": {"epss_score": 0.00108, "epss_percentile": 0.29815}, "CVE-2021-20269": {"epss_score": 0.00024, "epss_percentile": 0.05744}, "CVE-2021-20270": {"epss_score": 0.00115, "epss_percentile": 0.30933}, "CVE-2021-20271": {"epss_score": 0.00155, "epss_percentile": 0.36855}, "CVE-2021-20272": {"epss_score": 0.02553, "epss_percentile": 0.85085}, "CVE-2021-20273": {"epss_score": 0.02822, "epss_percentile": 0.85748}, "CVE-2021-20274": {"epss_score": 0.00695, "epss_percentile": 0.71364}, "CVE-2021-20275": {"epss_score": 0.0057, "epss_percentile": 0.6794}, "CVE-2021-20276": {"epss_score": 0.02806, "epss_percentile": 0.85707}, "CVE-2021-20277": {"epss_score": 0.14905, "epss_percentile": 0.94319}, "CVE-2021-20278": {"epss_score": 0.00162, "epss_percentile": 0.37621}, "CVE-2021-20279": {"epss_score": 0.00733, "epss_percentile": 0.72202}, "CVE-2021-20280": {"epss_score": 0.01161, "epss_percentile": 0.7814}, "CVE-2021-20281": {"epss_score": 0.00387, "epss_percentile": 0.59315}, "CVE-2021-20282": {"epss_score": 0.00304, "epss_percentile": 0.5329}, "CVE-2021-20283": {"epss_score": 0.00284, "epss_percentile": 0.51452}, "CVE-2021-20284": {"epss_score": 0.00087, "epss_percentile": 0.25601}, "CVE-2021-20285": {"epss_score": 0.00237, "epss_percentile": 0.46685}, "CVE-2021-20286": {"epss_score": 0.00388, "epss_percentile": 0.59345}, "CVE-2021-20288": {"epss_score": 0.00179, "epss_percentile": 0.39826}, "CVE-2021-20289": {"epss_score": 0.00088, "epss_percentile": 0.25776}, "CVE-2021-20290": {"epss_score": 0.00084, "epss_percentile": 0.24963}, "CVE-2021-20291": {"epss_score": 0.00879, "epss_percentile": 0.74835}, "CVE-2021-20292": {"epss_score": 0.00085, "epss_percentile": 0.25044}, "CVE-2021-20293": {"epss_score": 0.00402, "epss_percentile": 0.60276}, "CVE-2021-20294": {"epss_score": 0.15051, "epss_percentile": 0.94351}, "CVE-2021-20295": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2021-20296": {"epss_score": 0.01014, "epss_percentile": 0.76643}, "CVE-2021-20297": {"epss_score": 0.00104, "epss_percentile": 0.29227}, "CVE-2021-20298": {"epss_score": 0.00221, "epss_percentile": 0.44633}, "CVE-2021-20299": {"epss_score": 0.01029, "epss_percentile": 0.7683}, "CVE-2021-20300": {"epss_score": 0.00395, "epss_percentile": 0.59811}, "CVE-2021-20302": {"epss_score": 0.00536, "epss_percentile": 0.66856}, "CVE-2021-20303": {"epss_score": 0.00132, "epss_percentile": 0.33606}, "CVE-2021-20304": {"epss_score": 0.00148, "epss_percentile": 0.35841}, "CVE-2021-20305": {"epss_score": 0.00176, "epss_percentile": 0.39434}, "CVE-2021-20306": {"epss_score": 0.00129, "epss_percentile": 0.33111}, "CVE-2021-20307": {"epss_score": 0.00222, "epss_percentile": 0.44826}, "CVE-2021-20308": {"epss_score": 0.00547, "epss_percentile": 0.67248}, "CVE-2021-20309": {"epss_score": 0.0024, "epss_percentile": 0.46963}, "CVE-2021-20310": {"epss_score": 0.00396, "epss_percentile": 0.59925}, "CVE-2021-20311": {"epss_score": 0.00125, "epss_percentile": 0.32543}, "CVE-2021-20312": {"epss_score": 0.00108, "epss_percentile": 0.2985}, "CVE-2021-20313": {"epss_score": 0.00154, "epss_percentile": 0.36697}, "CVE-2021-20314": {"epss_score": 0.00169, "epss_percentile": 0.3862}, "CVE-2021-20315": {"epss_score": 0.00038, "epss_percentile": 0.11131}, "CVE-2021-20316": {"epss_score": 0.0049, "epss_percentile": 0.64922}, "CVE-2021-20317": {"epss_score": 0.00016, "epss_percentile": 0.02792}, "CVE-2021-20318": {"epss_score": 0.02131, "epss_percentile": 0.83711}, "CVE-2021-20319": {"epss_score": 0.00099, "epss_percentile": 0.28346}, "CVE-2021-20320": {"epss_score": 0.00095, "epss_percentile": 0.27122}, "CVE-2021-20321": {"epss_score": 0.00018, "epss_percentile": 0.03517}, "CVE-2021-20322": {"epss_score": 0.00131, "epss_percentile": 0.33502}, "CVE-2021-20323": {"epss_score": 0.66054, "epss_percentile": 0.98449}, "CVE-2021-20325": {"epss_score": 0.00688, "epss_percentile": 0.71208}, "CVE-2021-20326": {"epss_score": 0.0029, "epss_percentile": 0.52105}, "CVE-2021-20327": {"epss_score": 0.00125, "epss_percentile": 0.32596}, "CVE-2021-20328": {"epss_score": 0.00129, "epss_percentile": 0.33076}, "CVE-2021-20329": {"epss_score": 0.0014, "epss_percentile": 0.34708}, "CVE-2021-20330": {"epss_score": 0.00378, "epss_percentile": 0.58811}, "CVE-2021-20331": {"epss_score": 0.00287, "epss_percentile": 0.51828}, "CVE-2021-20332": {"epss_score": 0.00133, "epss_percentile": 0.33668}, "CVE-2021-20333": {"epss_score": 0.00439, "epss_percentile": 0.62593}, "CVE-2021-20334": {"epss_score": 0.00097, "epss_percentile": 0.27514}, "CVE-2021-20335": {"epss_score": 0.00056, "epss_percentile": 0.17722}, "CVE-2021-20336": {"epss_score": 0.00095, "epss_percentile": 0.27139}, "CVE-2021-20337": {"epss_score": 0.00087, "epss_percentile": 0.255}, "CVE-2021-20338": {"epss_score": 0.00187, "epss_percentile": 0.40779}, "CVE-2021-20340": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2021-20341": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2021-20343": {"epss_score": 0.0009, "epss_percentile": 0.26}, "CVE-2021-20345": {"epss_score": 0.00099, "epss_percentile": 0.28406}, "CVE-2021-20346": {"epss_score": 0.00148, "epss_percentile": 0.35897}, "CVE-2021-20347": {"epss_score": 0.00099, "epss_percentile": 0.28406}, "CVE-2021-20348": {"epss_score": 0.0009, "epss_percentile": 0.26}, "CVE-2021-20349": {"epss_score": 0.00042, "epss_percentile": 0.12898}, "CVE-2021-20350": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2021-20351": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2021-20352": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-20353": {"epss_score": 0.0108, "epss_percentile": 0.7736}, "CVE-2021-20354": {"epss_score": 0.00458, "epss_percentile": 0.63422}, "CVE-2021-20355": {"epss_score": 0.00192, "epss_percentile": 0.41304}, "CVE-2021-20357": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-20358": {"epss_score": 0.00066, "epss_percentile": 0.20699}, "CVE-2021-20359": {"epss_score": 0.00236, "epss_percentile": 0.46435}, "CVE-2021-20360": {"epss_score": 0.00116, "epss_percentile": 0.31088}, "CVE-2021-20361": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2021-20362": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2021-20363": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2021-20364": {"epss_score": 0.00164, "epss_percentile": 0.37916}, "CVE-2021-20365": {"epss_score": 0.00215, "epss_percentile": 0.44096}, "CVE-2021-20366": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2021-20368": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2021-20369": {"epss_score": 0.00129, "epss_percentile": 0.33077}, "CVE-2021-20371": {"epss_score": 0.00141, "epss_percentile": 0.34817}, "CVE-2021-20372": {"epss_score": 0.00268, "epss_percentile": 0.50087}, "CVE-2021-20373": {"epss_score": 0.00299, "epss_percentile": 0.52867}, "CVE-2021-20374": {"epss_score": 0.00211, "epss_percentile": 0.43684}, "CVE-2021-20375": {"epss_score": 0.00133, "epss_percentile": 0.33732}, "CVE-2021-20376": {"epss_score": 0.00119, "epss_percentile": 0.31669}, "CVE-2021-20377": {"epss_score": 0.00115, "epss_percentile": 0.30961}, "CVE-2021-20378": {"epss_score": 0.00099, "epss_percentile": 0.28372}, "CVE-2021-20379": {"epss_score": 0.00047, "epss_percentile": 0.14611}, "CVE-2021-20380": {"epss_score": 0.00159, "epss_percentile": 0.37364}, "CVE-2021-20385": {"epss_score": 0.0067, "epss_percentile": 0.70787}, "CVE-2021-20386": {"epss_score": 0.00166, "epss_percentile": 0.38177}, "CVE-2021-20389": {"epss_score": 0.00031, "epss_percentile": 0.08583}, "CVE-2021-20391": {"epss_score": 0.00042, "epss_percentile": 0.12651}, "CVE-2021-20392": {"epss_score": 0.00131, "epss_percentile": 0.33423}, "CVE-2021-20393": {"epss_score": 0.0027, "epss_percentile": 0.50257}, "CVE-2021-20396": {"epss_score": 0.00042, "epss_percentile": 0.12651}, "CVE-2021-20397": {"epss_score": 0.00149, "epss_percentile": 0.36039}, "CVE-2021-20399": {"epss_score": 0.00545, "epss_percentile": 0.67153}, "CVE-2021-20400": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2021-20401": {"epss_score": 0.00017, "epss_percentile": 0.03445}, "CVE-2021-20402": {"epss_score": 0.00101, "epss_percentile": 0.2871}, "CVE-2021-20403": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2021-20404": {"epss_score": 0.0031, "epss_percentile": 0.53763}, "CVE-2021-20405": {"epss_score": 0.00164, "epss_percentile": 0.37872}, "CVE-2021-20406": {"epss_score": 0.00089, "epss_percentile": 0.25926}, "CVE-2021-20407": {"epss_score": 0.00076, "epss_percentile": 0.23088}, "CVE-2021-20408": {"epss_score": 0.00019, "epss_percentile": 0.04135}, "CVE-2021-20409": {"epss_score": 0.00094, "epss_percentile": 0.26984}, "CVE-2021-20410": {"epss_score": 0.00122, "epss_percentile": 0.32053}, "CVE-2021-20411": {"epss_score": 0.00085, "epss_percentile": 0.25232}, "CVE-2021-20412": {"epss_score": 0.00065, "epss_percentile": 0.20593}, "CVE-2021-20413": {"epss_score": 0.0009, "epss_percentile": 0.26045}, "CVE-2021-20414": {"epss_score": 0.00102, "epss_percentile": 0.28758}, "CVE-2021-20415": {"epss_score": 0.00091, "epss_percentile": 0.26381}, "CVE-2021-20416": {"epss_score": 0.00094, "epss_percentile": 0.2677}, "CVE-2021-20417": {"epss_score": 0.0005, "epss_percentile": 0.15698}, "CVE-2021-20418": {"epss_score": 0.00143, "epss_percentile": 0.35111}, "CVE-2021-20419": {"epss_score": 0.00101, "epss_percentile": 0.28601}, "CVE-2021-20420": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2021-20421": {"epss_score": 0.00092, "epss_percentile": 0.26447}, "CVE-2021-20422": {"epss_score": 0.00214, "epss_percentile": 0.43954}, "CVE-2021-20423": {"epss_score": 0.00179, "epss_percentile": 0.39842}, "CVE-2021-20424": {"epss_score": 0.00095, "epss_percentile": 0.27138}, "CVE-2021-20426": {"epss_score": 0.00072, "epss_percentile": 0.22399}, "CVE-2021-20427": {"epss_score": 0.00223, "epss_percentile": 0.44967}, "CVE-2021-20428": {"epss_score": 0.00177, "epss_percentile": 0.39627}, "CVE-2021-20429": {"epss_score": 0.00139, "epss_percentile": 0.34651}, "CVE-2021-20430": {"epss_score": 0.00157, "epss_percentile": 0.37059}, "CVE-2021-20431": {"epss_score": 0.00162, "epss_percentile": 0.37729}, "CVE-2021-20432": {"epss_score": 0.00158, "epss_percentile": 0.37214}, "CVE-2021-20433": {"epss_score": 0.00186, "epss_percentile": 0.40683}, "CVE-2021-20434": {"epss_score": 0.00034, "epss_percentile": 0.09748}, "CVE-2021-20435": {"epss_score": 0.00022, "epss_percentile": 0.04982}, "CVE-2021-20439": {"epss_score": 0.00205, "epss_percentile": 0.42711}, "CVE-2021-20440": {"epss_score": 0.0018, "epss_percentile": 0.39983}, "CVE-2021-20441": {"epss_score": 0.00134, "epss_percentile": 0.33803}, "CVE-2021-20442": {"epss_score": 0.00131, "epss_percentile": 0.33462}, "CVE-2021-20443": {"epss_score": 0.00233, "epss_percentile": 0.46031}, "CVE-2021-20444": {"epss_score": 0.00166, "epss_percentile": 0.38177}, "CVE-2021-20445": {"epss_score": 0.00147, "epss_percentile": 0.35699}, "CVE-2021-20446": {"epss_score": 0.00143, "epss_percentile": 0.35117}, "CVE-2021-20447": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-20448": {"epss_score": 0.00143, "epss_percentile": 0.35117}, "CVE-2021-20450": {"epss_score": 0.00086, "epss_percentile": 0.25355}, "CVE-2021-20451": {"epss_score": 0.00072, "epss_percentile": 0.22395}, "CVE-2021-20453": {"epss_score": 0.00083, "epss_percentile": 0.24641}, "CVE-2021-20454": {"epss_score": 0.00102, "epss_percentile": 0.28726}, "CVE-2021-20455": {"epss_score": 0.00057, "epss_percentile": 0.18054}, "CVE-2021-20461": {"epss_score": 0.00193, "epss_percentile": 0.41423}, "CVE-2021-20464": {"epss_score": 0.00326, "epss_percentile": 0.5507}, "CVE-2021-20468": {"epss_score": 0.00134, "epss_percentile": 0.33902}, "CVE-2021-20470": {"epss_score": 0.00256, "epss_percentile": 0.48786}, "CVE-2021-20473": {"epss_score": 0.00089, "epss_percentile": 0.25892}, "CVE-2021-20474": {"epss_score": 0.00044, "epss_percentile": 0.13638}, "CVE-2021-20477": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2021-20478": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2021-20479": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2021-20480": {"epss_score": 0.00374, "epss_percentile": 0.58544}, "CVE-2021-20481": {"epss_score": 0.00157, "epss_percentile": 0.37119}, "CVE-2021-20482": {"epss_score": 0.0038, "epss_percentile": 0.58911}, "CVE-2021-20483": {"epss_score": 0.00144, "epss_percentile": 0.35234}, "CVE-2021-20484": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-20485": {"epss_score": 0.00107, "epss_percentile": 0.29642}, "CVE-2021-20486": {"epss_score": 0.00186, "epss_percentile": 0.40683}, "CVE-2021-20487": {"epss_score": 0.00128, "epss_percentile": 0.32944}, "CVE-2021-20488": {"epss_score": 0.00192, "epss_percentile": 0.41326}, "CVE-2021-20489": {"epss_score": 0.00094, "epss_percentile": 0.27031}, "CVE-2021-20490": {"epss_score": 0.00041, "epss_percentile": 0.12332}, "CVE-2021-20491": {"epss_score": 0.00048, "epss_percentile": 0.1515}, "CVE-2021-20492": {"epss_score": 0.00304, "epss_percentile": 0.53263}, "CVE-2021-20493": {"epss_score": 0.00239, "epss_percentile": 0.46914}, "CVE-2021-20494": {"epss_score": 0.00275, "epss_percentile": 0.50678}, "CVE-2021-20496": {"epss_score": 0.00179, "epss_percentile": 0.3978}, "CVE-2021-20497": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2021-20498": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2021-20499": {"epss_score": 0.00106, "epss_percentile": 0.29554}, "CVE-2021-20500": {"epss_score": 0.00044, "epss_percentile": 0.13624}, "CVE-2021-20501": {"epss_score": 0.00454, "epss_percentile": 0.63258}, "CVE-2021-20502": {"epss_score": 0.00274, "epss_percentile": 0.50545}, "CVE-2021-20503": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-20504": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-20505": {"epss_score": 0.00102, "epss_percentile": 0.28758}, "CVE-2021-20506": {"epss_score": 0.00211, "epss_percentile": 0.43684}, "CVE-2021-20507": {"epss_score": 0.00182, "epss_percentile": 0.40215}, "CVE-2021-20508": {"epss_score": 0.0013, "epss_percentile": 0.33307}, "CVE-2021-20509": {"epss_score": 0.00758, "epss_percentile": 0.72779}, "CVE-2021-20510": {"epss_score": 0.00053, "epss_percentile": 0.16985}, "CVE-2021-20511": {"epss_score": 0.0043, "epss_percentile": 0.62002}, "CVE-2021-20515": {"epss_score": 0.00074, "epss_percentile": 0.22792}, "CVE-2021-20517": {"epss_score": 0.01097, "epss_percentile": 0.77524}, "CVE-2021-20518": {"epss_score": 0.00143, "epss_percentile": 0.35117}, "CVE-2021-20519": {"epss_score": 0.00157, "epss_percentile": 0.37119}, "CVE-2021-20520": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-20523": {"epss_score": 0.00106, "epss_percentile": 0.29554}, "CVE-2021-20524": {"epss_score": 0.0017, "epss_percentile": 0.3865}, "CVE-2021-20526": {"epss_score": 0.00207, "epss_percentile": 0.43164}, "CVE-2021-20527": {"epss_score": 0.00229, "epss_percentile": 0.4556}, "CVE-2021-20528": {"epss_score": 0.00143, "epss_percentile": 0.35117}, "CVE-2021-20529": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2021-20532": {"epss_score": 0.00023, "epss_percentile": 0.05405}, "CVE-2021-20533": {"epss_score": 0.00371, "epss_percentile": 0.58404}, "CVE-2021-20534": {"epss_score": 0.00076, "epss_percentile": 0.23273}, "CVE-2021-20535": {"epss_score": 0.00094, "epss_percentile": 0.27067}, "CVE-2021-20536": {"epss_score": 0.00044, "epss_percentile": 0.13574}, "CVE-2021-20537": {"epss_score": 0.00071, "epss_percentile": 0.22023}, "CVE-2021-20538": {"epss_score": 0.00127, "epss_percentile": 0.32885}, "CVE-2021-20539": {"epss_score": 0.00169, "epss_percentile": 0.38545}, "CVE-2021-20540": {"epss_score": 0.00194, "epss_percentile": 0.4158}, "CVE-2021-20541": {"epss_score": 0.00169, "epss_percentile": 0.38545}, "CVE-2021-20543": {"epss_score": 0.00087, "epss_percentile": 0.25539}, "CVE-2021-20544": {"epss_score": 0.00102, "epss_percentile": 0.28875}, "CVE-2021-20546": {"epss_score": 0.0004, "epss_percentile": 0.12175}, "CVE-2021-20549": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-20550": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-20551": {"epss_score": 0.00042, "epss_percentile": 0.12651}, "CVE-2021-20552": {"epss_score": 0.00107, "epss_percentile": 0.29642}, "CVE-2021-20553": {"epss_score": 0.00055, "epss_percentile": 0.17447}, "CVE-2021-20554": {"epss_score": 0.00151, "epss_percentile": 0.36192}, "CVE-2021-20556": {"epss_score": 0.00068, "epss_percentile": 0.2138}, "CVE-2021-20557": {"epss_score": 0.01696, "epss_percentile": 0.81809}, "CVE-2021-20559": {"epss_score": 0.001, "epss_percentile": 0.28528}, "CVE-2021-20560": {"epss_score": 0.00076, "epss_percentile": 0.23266}, "CVE-2021-20561": {"epss_score": 0.00157, "epss_percentile": 0.37119}, "CVE-2021-20562": {"epss_score": 0.00715, "epss_percentile": 0.71837}, "CVE-2021-20563": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2021-20564": {"epss_score": 0.00134, "epss_percentile": 0.33824}, "CVE-2021-20565": {"epss_score": 0.00162, "epss_percentile": 0.37737}, "CVE-2021-20566": {"epss_score": 0.00087, "epss_percentile": 0.255}, "CVE-2021-20567": {"epss_score": 0.00011, "epss_percentile": 0.00993}, "CVE-2021-20569": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2021-20571": {"epss_score": 0.0015, "epss_percentile": 0.3609}, "CVE-2021-20572": {"epss_score": 0.00657, "epss_percentile": 0.7047}, "CVE-2021-20573": {"epss_score": 0.00657, "epss_percentile": 0.7047}, "CVE-2021-20574": {"epss_score": 0.01304, "epss_percentile": 0.79315}, "CVE-2021-20575": {"epss_score": 0.00042, "epss_percentile": 0.12651}, "CVE-2021-20576": {"epss_score": 0.0101, "epss_percentile": 0.76591}, "CVE-2021-20577": {"epss_score": 0.00172, "epss_percentile": 0.3901}, "CVE-2021-20578": {"epss_score": 0.00111, "epss_percentile": 0.30353}, "CVE-2021-20579": {"epss_score": 0.0027, "epss_percentile": 0.50208}, "CVE-2021-20580": {"epss_score": 0.0009, "epss_percentile": 0.26068}, "CVE-2021-20581": {"epss_score": 0.00048, "epss_percentile": 0.14988}, "CVE-2021-20582": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2021-20583": {"epss_score": 0.00218, "epss_percentile": 0.44346}, "CVE-2021-20584": {"epss_score": 0.00134, "epss_percentile": 0.33922}, "CVE-2021-20585": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2021-20586": {"epss_score": 0.02014, "epss_percentile": 0.83269}, "CVE-2021-20587": {"epss_score": 0.09006, "epss_percentile": 0.9236}, "CVE-2021-20588": {"epss_score": 0.01389, "epss_percentile": 0.79931}, "CVE-2021-20589": {"epss_score": 0.00326, "epss_percentile": 0.55059}, "CVE-2021-20590": {"epss_score": 0.00258, "epss_percentile": 0.48985}, "CVE-2021-20591": {"epss_score": 0.00496, "epss_percentile": 0.6516}, "CVE-2021-20592": {"epss_score": 0.00388, "epss_percentile": 0.59349}, "CVE-2021-20593": {"epss_score": 0.00143, "epss_percentile": 0.35201}, "CVE-2021-20594": {"epss_score": 0.0086, "epss_percentile": 0.74531}, "CVE-2021-20595": {"epss_score": 0.00154, "epss_percentile": 0.36712}, "CVE-2021-20596": {"epss_score": 0.00573, "epss_percentile": 0.68067}, "CVE-2021-20597": {"epss_score": 0.00888, "epss_percentile": 0.74996}, "CVE-2021-20598": {"epss_score": 0.00473, "epss_percentile": 0.64083}, "CVE-2021-20599": {"epss_score": 0.00332, "epss_percentile": 0.55598}, "CVE-2021-20600": {"epss_score": 0.00616, "epss_percentile": 0.69318}, "CVE-2021-20601": {"epss_score": 0.00366, "epss_percentile": 0.58088}, "CVE-2021-20606": {"epss_score": 0.00151, "epss_percentile": 0.36363}, "CVE-2021-20607": {"epss_score": 0.00151, "epss_percentile": 0.36363}, "CVE-2021-20608": {"epss_score": 0.00258, "epss_percentile": 0.48958}, "CVE-2021-20609": {"epss_score": 0.0048, "epss_percentile": 0.64453}, "CVE-2021-20610": {"epss_score": 0.00932, "epss_percentile": 0.75623}, "CVE-2021-20611": {"epss_score": 0.00605, "epss_percentile": 0.68997}, "CVE-2021-20612": {"epss_score": 0.00353, "epss_percentile": 0.57181}, "CVE-2021-20613": {"epss_score": 0.00353, "epss_percentile": 0.57181}, "CVE-2021-20616": {"epss_score": 0.00071, "epss_percentile": 0.22157}, "CVE-2021-20617": {"epss_score": 0.40785, "epss_percentile": 0.97238}, "CVE-2021-20618": {"epss_score": 0.02512, "epss_percentile": 0.84954}, "CVE-2021-20619": {"epss_score": 0.00464, "epss_percentile": 0.63727}, "CVE-2021-20620": {"epss_score": 0.00464, "epss_percentile": 0.63727}, "CVE-2021-20621": {"epss_score": 0.00155, "epss_percentile": 0.36789}, "CVE-2021-20622": {"epss_score": 0.00464, "epss_percentile": 0.63727}, "CVE-2021-20623": {"epss_score": 0.02078, "epss_percentile": 0.83517}, "CVE-2021-20624": {"epss_score": 0.00232, "epss_percentile": 0.45879}, "CVE-2021-20625": {"epss_score": 0.00232, "epss_percentile": 0.45879}, "CVE-2021-20626": {"epss_score": 0.00232, "epss_percentile": 0.45879}, "CVE-2021-20627": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20628": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20629": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20630": {"epss_score": 0.00227, "epss_percentile": 0.4539}, "CVE-2021-20631": {"epss_score": 0.00232, "epss_percentile": 0.45879}, "CVE-2021-20632": {"epss_score": 0.00227, "epss_percentile": 0.4539}, "CVE-2021-20633": {"epss_score": 0.00227, "epss_percentile": 0.4539}, "CVE-2021-20634": {"epss_score": 0.00227, "epss_percentile": 0.4539}, "CVE-2021-20635": {"epss_score": 0.00094, "epss_percentile": 0.27034}, "CVE-2021-20636": {"epss_score": 0.00092, "epss_percentile": 0.26574}, "CVE-2021-20637": {"epss_score": 0.00421, "epss_percentile": 0.61526}, "CVE-2021-20638": {"epss_score": 0.00335, "epss_percentile": 0.55836}, "CVE-2021-20639": {"epss_score": 0.00335, "epss_percentile": 0.55836}, "CVE-2021-20640": {"epss_score": 0.00131, "epss_percentile": 0.33495}, "CVE-2021-20641": {"epss_score": 0.00092, "epss_percentile": 0.26574}, "CVE-2021-20642": {"epss_score": 0.00421, "epss_percentile": 0.61526}, "CVE-2021-20643": {"epss_score": 0.00299, "epss_percentile": 0.52893}, "CVE-2021-20644": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-20645": {"epss_score": 0.00329, "epss_percentile": 0.55318}, "CVE-2021-20646": {"epss_score": 0.00092, "epss_percentile": 0.26574}, "CVE-2021-20647": {"epss_score": 0.00092, "epss_percentile": 0.26574}, "CVE-2021-20648": {"epss_score": 0.00296, "epss_percentile": 0.52539}, "CVE-2021-20649": {"epss_score": 0.001, "epss_percentile": 0.28507}, "CVE-2021-20650": {"epss_score": 0.00092, "epss_percentile": 0.26574}, "CVE-2021-20651": {"epss_score": 0.01227, "epss_percentile": 0.78703}, "CVE-2021-20652": {"epss_score": 0.00094, "epss_percentile": 0.26775}, "CVE-2021-20653": {"epss_score": 0.00196, "epss_percentile": 0.41816}, "CVE-2021-20654": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-20655": {"epss_score": 0.03946, "epss_percentile": 0.87997}, "CVE-2021-20656": {"epss_score": 0.00326, "epss_percentile": 0.55065}, "CVE-2021-20657": {"epss_score": 0.00317, "epss_percentile": 0.5431}, "CVE-2021-20658": {"epss_score": 0.0214, "epss_percentile": 0.83745}, "CVE-2021-20659": {"epss_score": 0.01566, "epss_percentile": 0.81068}, "CVE-2021-20660": {"epss_score": 0.00611, "epss_percentile": 0.69182}, "CVE-2021-20661": {"epss_score": 0.01218, "epss_percentile": 0.78608}, "CVE-2021-20662": {"epss_score": 0.00399, "epss_percentile": 0.60104}, "CVE-2021-20663": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20664": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20665": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20667": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20668": {"epss_score": 0.00283, "epss_percentile": 0.51379}, "CVE-2021-20669": {"epss_score": 0.0026, "epss_percentile": 0.49178}, "CVE-2021-20670": {"epss_score": 0.01041, "epss_percentile": 0.7697}, "CVE-2021-20671": {"epss_score": 0.02211, "epss_percentile": 0.84014}, "CVE-2021-20672": {"epss_score": 0.00419, "epss_percentile": 0.61386}, "CVE-2021-20673": {"epss_score": 0.00259, "epss_percentile": 0.49076}, "CVE-2021-20674": {"epss_score": 0.00432, "epss_percentile": 0.62105}, "CVE-2021-20675": {"epss_score": 0.00565, "epss_percentile": 0.67794}, "CVE-2021-20676": {"epss_score": 0.00152, "epss_percentile": 0.3647}, "CVE-2021-20677": {"epss_score": 0.00304, "epss_percentile": 0.53285}, "CVE-2021-20678": {"epss_score": 0.02557, "epss_percentile": 0.85096}, "CVE-2021-20679": {"epss_score": 0.0051, "epss_percentile": 0.65792}, "CVE-2021-20680": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20681": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20682": {"epss_score": 0.02722, "epss_percentile": 0.8552}, "CVE-2021-20683": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20684": {"epss_score": 0.00232, "epss_percentile": 0.45884}, "CVE-2021-20685": {"epss_score": 0.00205, "epss_percentile": 0.42676}, "CVE-2021-20686": {"epss_score": 0.00232, "epss_percentile": 0.45884}, "CVE-2021-20687": {"epss_score": 0.00094, "epss_percentile": 0.27005}, "CVE-2021-20688": {"epss_score": 0.00232, "epss_percentile": 0.45884}, "CVE-2021-20689": {"epss_score": 0.00205, "epss_percentile": 0.42676}, "CVE-2021-20690": {"epss_score": 0.00232, "epss_percentile": 0.45884}, "CVE-2021-20691": {"epss_score": 0.00232, "epss_percentile": 0.45884}, "CVE-2021-20692": {"epss_score": 0.00277, "epss_percentile": 0.50803}, "CVE-2021-20693": {"epss_score": 0.0023, "epss_percentile": 0.45694}, "CVE-2021-20694": {"epss_score": 0.00203, "epss_percentile": 0.42561}, "CVE-2021-20695": {"epss_score": 0.00365, "epss_percentile": 0.58009}, "CVE-2021-20696": {"epss_score": 0.00974, "epss_percentile": 0.76176}, "CVE-2021-20697": {"epss_score": 0.00576, "epss_percentile": 0.68135}, "CVE-2021-20698": {"epss_score": 0.00469, "epss_percentile": 0.63934}, "CVE-2021-20699": {"epss_score": 0.00529, "epss_percentile": 0.66596}, "CVE-2021-20700": {"epss_score": 0.01346, "epss_percentile": 0.79645}, "CVE-2021-20701": {"epss_score": 0.01346, "epss_percentile": 0.79645}, "CVE-2021-20702": {"epss_score": 0.01346, "epss_percentile": 0.79645}, "CVE-2021-20703": {"epss_score": 0.01346, "epss_percentile": 0.79645}, "CVE-2021-20704": {"epss_score": 0.01346, "epss_percentile": 0.79645}, "CVE-2021-20705": {"epss_score": 0.00202, "epss_percentile": 0.42413}, "CVE-2021-20706": {"epss_score": 0.00202, "epss_percentile": 0.42413}, "CVE-2021-20707": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-20708": {"epss_score": 0.0069, "epss_percentile": 0.71244}, "CVE-2021-20709": {"epss_score": 0.00256, "epss_percentile": 0.48794}, "CVE-2021-20710": {"epss_score": 0.00317, "epss_percentile": 0.5439}, "CVE-2021-20711": {"epss_score": 0.00647, "epss_percentile": 0.70209}, "CVE-2021-20712": {"epss_score": 0.0025, "epss_percentile": 0.48146}, "CVE-2021-20713": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2021-20714": {"epss_score": 0.02219, "epss_percentile": 0.84045}, "CVE-2021-20715": {"epss_score": 0.00256, "epss_percentile": 0.4879}, "CVE-2021-20716": {"epss_score": 0.03027, "epss_percentile": 0.86242}, "CVE-2021-20717": {"epss_score": 0.03337, "epss_percentile": 0.86938}, "CVE-2021-20718": {"epss_score": 0.01849, "epss_percentile": 0.82532}, "CVE-2021-20719": {"epss_score": 0.00291, "epss_percentile": 0.52162}, "CVE-2021-20720": {"epss_score": 0.00537, "epss_percentile": 0.66918}, "CVE-2021-20721": {"epss_score": 0.00675, "epss_percentile": 0.70895}, "CVE-2021-20722": {"epss_score": 0.00075, "epss_percentile": 0.22921}, "CVE-2021-20723": {"epss_score": 0.00317, "epss_percentile": 0.5439}, "CVE-2021-20724": {"epss_score": 0.00317, "epss_percentile": 0.5439}, "CVE-2021-20725": {"epss_score": 0.00317, "epss_percentile": 0.5439}, "CVE-2021-20726": {"epss_score": 0.00075, "epss_percentile": 0.22921}, "CVE-2021-20727": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2021-20728": {"epss_score": 0.00265, "epss_percentile": 0.49831}, "CVE-2021-20729": {"epss_score": 0.00306, "epss_percentile": 0.53432}, "CVE-2021-20730": {"epss_score": 0.00075, "epss_percentile": 0.22972}, "CVE-2021-20731": {"epss_score": 0.00328, "epss_percentile": 0.55172}, "CVE-2021-20732": {"epss_score": 0.00126, "epss_percentile": 0.32728}, "CVE-2021-20733": {"epss_score": 0.00254, "epss_percentile": 0.48537}, "CVE-2021-20734": {"epss_score": 0.00493, "epss_percentile": 0.65055}, "CVE-2021-20735": {"epss_score": 0.00347, "epss_percentile": 0.56771}, "CVE-2021-20736": {"epss_score": 0.0035, "epss_percentile": 0.56966}, "CVE-2021-20737": {"epss_score": 0.00255, "epss_percentile": 0.48727}, "CVE-2021-20738": {"epss_score": 0.00095, "epss_percentile": 0.27148}, "CVE-2021-20739": {"epss_score": 0.00333, "epss_percentile": 0.55624}, "CVE-2021-20740": {"epss_score": 0.02367, "epss_percentile": 0.84517}, "CVE-2021-20741": {"epss_score": 0.00321, "epss_percentile": 0.54675}, "CVE-2021-20742": {"epss_score": 0.0025, "epss_percentile": 0.48106}, "CVE-2021-20743": {"epss_score": 0.00388, "epss_percentile": 0.59365}, "CVE-2021-20744": {"epss_score": 0.00321, "epss_percentile": 0.54675}, "CVE-2021-20745": {"epss_score": 0.00247, "epss_percentile": 0.47856}, "CVE-2021-20746": {"epss_score": 0.00832, "epss_percentile": 0.74057}, "CVE-2021-20747": {"epss_score": 0.00303, "epss_percentile": 0.53226}, "CVE-2021-20748": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2021-20749": {"epss_score": 0.00183, "epss_percentile": 0.4032}, "CVE-2021-20750": {"epss_score": 0.00403, "epss_percentile": 0.60325}, "CVE-2021-20751": {"epss_score": 0.00321, "epss_percentile": 0.54675}, "CVE-2021-20752": {"epss_score": 0.00214, "epss_percentile": 0.44015}, "CVE-2021-20753": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20754": {"epss_score": 0.00163, "epss_percentile": 0.37794}, "CVE-2021-20755": {"epss_score": 0.00157, "epss_percentile": 0.37094}, "CVE-2021-20756": {"epss_score": 0.00157, "epss_percentile": 0.37094}, "CVE-2021-20757": {"epss_score": 0.00193, "epss_percentile": 0.41486}, "CVE-2021-20758": {"epss_score": 0.00093, "epss_percentile": 0.26657}, "CVE-2021-20759": {"epss_score": 0.00193, "epss_percentile": 0.41486}, "CVE-2021-20760": {"epss_score": 0.00163, "epss_percentile": 0.37794}, "CVE-2021-20761": {"epss_score": 0.00147, "epss_percentile": 0.3579}, "CVE-2021-20762": {"epss_score": 0.00163, "epss_percentile": 0.37794}, "CVE-2021-20763": {"epss_score": 0.00157, "epss_percentile": 0.37094}, "CVE-2021-20764": {"epss_score": 0.0027, "epss_percentile": 0.50211}, "CVE-2021-20765": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20766": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20767": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20768": {"epss_score": 0.00193, "epss_percentile": 0.41486}, "CVE-2021-20769": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20770": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20771": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20772": {"epss_score": 0.00177, "epss_percentile": 0.39568}, "CVE-2021-20773": {"epss_score": 0.00181, "epss_percentile": 0.40034}, "CVE-2021-20774": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20775": {"epss_score": 0.0016, "epss_percentile": 0.37426}, "CVE-2021-20776": {"epss_score": 0.00383, "epss_percentile": 0.59117}, "CVE-2021-20777": {"epss_score": 0.00188, "epss_percentile": 0.40902}, "CVE-2021-20778": {"epss_score": 0.00294, "epss_percentile": 0.52408}, "CVE-2021-20779": {"epss_score": 0.00151, "epss_percentile": 0.36226}, "CVE-2021-20780": {"epss_score": 0.00151, "epss_percentile": 0.36226}, "CVE-2021-20781": {"epss_score": 0.00147, "epss_percentile": 0.35687}, "CVE-2021-20782": {"epss_score": 0.00151, "epss_percentile": 0.36226}, "CVE-2021-20783": {"epss_score": 0.00094, "epss_percentile": 0.27005}, "CVE-2021-20784": {"epss_score": 0.00452, "epss_percentile": 0.6316}, "CVE-2021-20785": {"epss_score": 0.00214, "epss_percentile": 0.44}, "CVE-2021-20786": {"epss_score": 0.00092, "epss_percentile": 0.26574}, "CVE-2021-20787": {"epss_score": 0.00214, "epss_percentile": 0.44}, "CVE-2021-20788": {"epss_score": 0.00134, "epss_percentile": 0.33747}, "CVE-2021-20789": {"epss_score": 0.00274, "epss_percentile": 0.50574}, "CVE-2021-20790": {"epss_score": 0.00626, "epss_percentile": 0.6961}, "CVE-2021-20791": {"epss_score": 0.00313, "epss_percentile": 0.54034}, "CVE-2021-20792": {"epss_score": 0.09715, "epss_percentile": 0.92674}, "CVE-2021-20793": {"epss_score": 0.00205, "epss_percentile": 0.42707}, "CVE-2021-20795": {"epss_score": 0.00094, "epss_percentile": 0.27005}, "CVE-2021-20796": {"epss_score": 0.00434, "epss_percentile": 0.62321}, "CVE-2021-20797": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20798": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20799": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20800": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20801": {"epss_score": 0.00488, "epss_percentile": 0.64831}, "CVE-2021-20802": {"epss_score": 0.00351, "epss_percentile": 0.57073}, "CVE-2021-20803": {"epss_score": 0.00152, "epss_percentile": 0.3647}, "CVE-2021-20804": {"epss_score": 0.00485, "epss_percentile": 0.64725}, "CVE-2021-20805": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20806": {"epss_score": 0.00274, "epss_percentile": 0.50574}, "CVE-2021-20807": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20808": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20809": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20810": {"epss_score": 0.00332, "epss_percentile": 0.55583}, "CVE-2021-20811": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20812": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20813": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20814": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20815": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2021-20825": {"epss_score": 0.00297, "epss_percentile": 0.52757}, "CVE-2021-20826": {"epss_score": 0.0009, "epss_percentile": 0.26008}, "CVE-2021-20827": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2021-20828": {"epss_score": 0.00317, "epss_percentile": 0.5439}, "CVE-2021-20829": {"epss_score": 0.00332, "epss_percentile": 0.55583}, "CVE-2021-20831": {"epss_score": 0.00128, "epss_percentile": 0.33028}, "CVE-2021-20832": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2021-20833": {"epss_score": 0.00109, "epss_percentile": 0.29964}, "CVE-2021-20834": {"epss_score": 0.00344, "epss_percentile": 0.56541}, "CVE-2021-20835": {"epss_score": 0.00325, "epss_percentile": 0.5498}, "CVE-2021-20836": {"epss_score": 0.00901, "epss_percentile": 0.7517}, "CVE-2021-20837": {"epss_score": 0.94187, "epss_percentile": 0.99915}, "CVE-2021-20838": {"epss_score": 0.00719, "epss_percentile": 0.71945}, "CVE-2021-20839": {"epss_score": 0.0042, "epss_percentile": 0.6145}, "CVE-2021-20840": {"epss_score": 0.00668, "epss_percentile": 0.70739}, "CVE-2021-20841": {"epss_score": 0.00203, "epss_percentile": 0.42551}, "CVE-2021-20842": {"epss_score": 0.00108, "epss_percentile": 0.29782}, "CVE-2021-20843": {"epss_score": 0.00283, "epss_percentile": 0.51379}, "CVE-2021-20844": {"epss_score": 0.00338, "epss_percentile": 0.5616}, "CVE-2021-20845": {"epss_score": 0.0012, "epss_percentile": 0.31739}, "CVE-2021-20846": {"epss_score": 0.00163, "epss_percentile": 0.37816}, "CVE-2021-20847": {"epss_score": 0.00447, "epss_percentile": 0.62978}, "CVE-2021-20848": {"epss_score": 0.00317, "epss_percentile": 0.5439}, "CVE-2021-20850": {"epss_score": 0.01155, "epss_percentile": 0.78072}, "CVE-2021-20851": {"epss_score": 0.00158, "epss_percentile": 0.37212}, "CVE-2021-20852": {"epss_score": 0.00151, "epss_percentile": 0.3632}, "CVE-2021-20853": {"epss_score": 0.00346, "epss_percentile": 0.5664}, "CVE-2021-20854": {"epss_score": 0.00346, "epss_percentile": 0.5664}, "CVE-2021-20855": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20856": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20857": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20858": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-20859": {"epss_score": 0.00327, "epss_percentile": 0.55092}, "CVE-2021-20860": {"epss_score": 0.00094, "epss_percentile": 0.27005}, "CVE-2021-20861": {"epss_score": 0.00155, "epss_percentile": 0.36849}, "CVE-2021-20862": {"epss_score": 0.00103, "epss_percentile": 0.289}, "CVE-2021-20863": {"epss_score": 0.0124, "epss_percentile": 0.78805}, "CVE-2021-20864": {"epss_score": 0.00243, "epss_percentile": 0.47477}, "CVE-2021-20865": {"epss_score": 0.01947, "epss_percentile": 0.83007}, "CVE-2021-20866": {"epss_score": 0.01159, "epss_percentile": 0.78124}, "CVE-2021-20867": {"epss_score": 0.00746, "epss_percentile": 0.72551}, "CVE-2021-20868": {"epss_score": 0.00202, "epss_percentile": 0.42402}, "CVE-2021-20869": {"epss_score": 0.00239, "epss_percentile": 0.46853}, "CVE-2021-20870": {"epss_score": 0.00106, "epss_percentile": 0.29416}, "CVE-2021-20871": {"epss_score": 0.00325, "epss_percentile": 0.54983}, "CVE-2021-20872": {"epss_score": 0.00139, "epss_percentile": 0.34659}, "CVE-2021-20873": {"epss_score": 0.00268, "epss_percentile": 0.5004}, "CVE-2021-20874": {"epss_score": 0.00638, "epss_percentile": 0.69916}, "CVE-2021-20875": {"epss_score": 0.00244, "epss_percentile": 0.47619}, "CVE-2021-20876": {"epss_score": 0.00234, "epss_percentile": 0.46195}, "CVE-2021-20877": {"epss_score": 0.00285, "epss_percentile": 0.51675}, "CVE-2021-20986": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2021-20987": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2021-20988": {"epss_score": 0.00277, "epss_percentile": 0.50844}, "CVE-2021-20989": {"epss_score": 0.01843, "epss_percentile": 0.82503}, "CVE-2021-20990": {"epss_score": 0.01763, "epss_percentile": 0.82158}, "CVE-2021-20991": {"epss_score": 0.34187, "epss_percentile": 0.9683}, "CVE-2021-20992": {"epss_score": 0.01202, "epss_percentile": 0.78487}, "CVE-2021-20993": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2021-20994": {"epss_score": 0.00391, "epss_percentile": 0.59577}, "CVE-2021-20995": {"epss_score": 0.00127, "epss_percentile": 0.32819}, "CVE-2021-20996": {"epss_score": 0.00206, "epss_percentile": 0.42787}, "CVE-2021-20997": {"epss_score": 0.00252, "epss_percentile": 0.48384}, "CVE-2021-20998": {"epss_score": 0.00136, "epss_percentile": 0.34123}, "CVE-2021-20999": {"epss_score": 0.00413, "epss_percentile": 0.61003}, "CVE-2021-21000": {"epss_score": 0.0013, "epss_percentile": 0.33237}, "CVE-2021-21001": {"epss_score": 0.00238, "epss_percentile": 0.46773}, "CVE-2021-21002": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-21003": {"epss_score": 0.00305, "epss_percentile": 0.53327}, "CVE-2021-21004": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-21005": {"epss_score": 0.00043, "epss_percentile": 0.13168}, "CVE-2021-21006": {"epss_score": 0.08144, "epss_percentile": 0.91901}, "CVE-2021-21007": {"epss_score": 0.00708, "epss_percentile": 0.71674}, "CVE-2021-21008": {"epss_score": 0.00721, "epss_percentile": 0.71968}, "CVE-2021-21009": {"epss_score": 0.00717, "epss_percentile": 0.71913}, "CVE-2021-21010": {"epss_score": 0.01644, "epss_percentile": 0.81524}, "CVE-2021-21011": {"epss_score": 0.00831, "epss_percentile": 0.74044}, "CVE-2021-21012": {"epss_score": 0.00447, "epss_percentile": 0.62967}, "CVE-2021-21013": {"epss_score": 0.00875, "epss_percentile": 0.74779}, "CVE-2021-21014": {"epss_score": 0.00694, "epss_percentile": 0.71354}, "CVE-2021-21015": {"epss_score": 0.05601, "epss_percentile": 0.90039}, "CVE-2021-21016": {"epss_score": 0.04238, "epss_percentile": 0.88431}, "CVE-2021-21017": {"epss_score": 0.90641, "epss_percentile": 0.99594}, "CVE-2021-21018": {"epss_score": 0.09493, "epss_percentile": 0.92572}, "CVE-2021-21019": {"epss_score": 0.03012, "epss_percentile": 0.86198}, "CVE-2021-21020": {"epss_score": 0.00134, "epss_percentile": 0.33833}, "CVE-2021-21021": {"epss_score": 0.1344, "epss_percentile": 0.93965}, "CVE-2021-21022": {"epss_score": 0.00154, "epss_percentile": 0.36646}, "CVE-2021-21023": {"epss_score": 0.02821, "epss_percentile": 0.85744}, "CVE-2021-21024": {"epss_score": 0.02071, "epss_percentile": 0.83483}, "CVE-2021-21025": {"epss_score": 0.04724, "epss_percentile": 0.89059}, "CVE-2021-21026": {"epss_score": 0.00679, "epss_percentile": 0.71018}, "CVE-2021-21027": {"epss_score": 0.00146, "epss_percentile": 0.35597}, "CVE-2021-21028": {"epss_score": 0.20298, "epss_percentile": 0.95316}, "CVE-2021-21029": {"epss_score": 0.43501, "epss_percentile": 0.97389}, "CVE-2021-21030": {"epss_score": 0.06281, "epss_percentile": 0.90639}, "CVE-2021-21031": {"epss_score": 0.00159, "epss_percentile": 0.37396}, "CVE-2021-21032": {"epss_score": 0.00159, "epss_percentile": 0.37396}, "CVE-2021-21033": {"epss_score": 0.1344, "epss_percentile": 0.93965}, "CVE-2021-21034": {"epss_score": 0.01012, "epss_percentile": 0.76618}, "CVE-2021-21035": {"epss_score": 0.1344, "epss_percentile": 0.93965}, "CVE-2021-21036": {"epss_score": 0.07081, "epss_percentile": 0.91239}, "CVE-2021-21037": {"epss_score": 0.12384, "epss_percentile": 0.93656}, "CVE-2021-21038": {"epss_score": 0.04146, "epss_percentile": 0.88315}, "CVE-2021-21039": {"epss_score": 0.11184, "epss_percentile": 0.93258}, "CVE-2021-21040": {"epss_score": 0.11184, "epss_percentile": 0.93258}, "CVE-2021-21041": {"epss_score": 0.11184, "epss_percentile": 0.93258}, "CVE-2021-21042": {"epss_score": 0.44966, "epss_percentile": 0.97463}, "CVE-2021-21043": {"epss_score": 0.00985, "epss_percentile": 0.76326}, "CVE-2021-21044": {"epss_score": 0.04885, "epss_percentile": 0.89253}, "CVE-2021-21045": {"epss_score": 0.00786, "epss_percentile": 0.73269}, "CVE-2021-21046": {"epss_score": 0.011, "epss_percentile": 0.7757}, "CVE-2021-21047": {"epss_score": 0.04739, "epss_percentile": 0.89077}, "CVE-2021-21048": {"epss_score": 0.04255, "epss_percentile": 0.88458}, "CVE-2021-21049": {"epss_score": 0.03119, "epss_percentile": 0.86445}, "CVE-2021-21050": {"epss_score": 0.03119, "epss_percentile": 0.86445}, "CVE-2021-21051": {"epss_score": 0.02895, "epss_percentile": 0.85925}, "CVE-2021-21052": {"epss_score": 0.04536, "epss_percentile": 0.88818}, "CVE-2021-21053": {"epss_score": 0.02333, "epss_percentile": 0.84409}, "CVE-2021-21054": {"epss_score": 0.0392, "epss_percentile": 0.87951}, "CVE-2021-21055": {"epss_score": 0.00351, "epss_percentile": 0.56981}, "CVE-2021-21056": {"epss_score": 0.03941, "epss_percentile": 0.87989}, "CVE-2021-21057": {"epss_score": 0.00648, "epss_percentile": 0.70223}, "CVE-2021-21058": {"epss_score": 0.05562, "epss_percentile": 0.89998}, "CVE-2021-21059": {"epss_score": 0.05562, "epss_percentile": 0.89998}, "CVE-2021-21060": {"epss_score": 0.00232, "epss_percentile": 0.45928}, "CVE-2021-21061": {"epss_score": 0.01261, "epss_percentile": 0.78977}, "CVE-2021-21062": {"epss_score": 0.05562, "epss_percentile": 0.89998}, "CVE-2021-21063": {"epss_score": 0.05562, "epss_percentile": 0.89998}, "CVE-2021-21064": {"epss_score": 0.00512, "epss_percentile": 0.65859}, "CVE-2021-21065": {"epss_score": 0.04451, "epss_percentile": 0.88706}, "CVE-2021-21066": {"epss_score": 0.04451, "epss_percentile": 0.88706}, "CVE-2021-21067": {"epss_score": 0.02834, "epss_percentile": 0.85781}, "CVE-2021-21068": {"epss_score": 0.001, "epss_percentile": 0.28476}, "CVE-2021-21069": {"epss_score": 0.00742, "epss_percentile": 0.72457}, "CVE-2021-21070": {"epss_score": 0.00462, "epss_percentile": 0.63581}, "CVE-2021-21071": {"epss_score": 0.0299, "epss_percentile": 0.86141}, "CVE-2021-21072": {"epss_score": 0.01043, "epss_percentile": 0.76991}, "CVE-2021-21073": {"epss_score": 0.01043, "epss_percentile": 0.76991}, "CVE-2021-21074": {"epss_score": 0.01043, "epss_percentile": 0.76991}, "CVE-2021-21075": {"epss_score": 0.01043, "epss_percentile": 0.76991}, "CVE-2021-21076": {"epss_score": 0.01043, "epss_percentile": 0.76991}, "CVE-2021-21077": {"epss_score": 0.0247, "epss_percentile": 0.84846}, "CVE-2021-21078": {"epss_score": 0.00087, "epss_percentile": 0.25631}, "CVE-2021-21079": {"epss_score": 0.00668, "epss_percentile": 0.70728}, "CVE-2021-21080": {"epss_score": 0.00856, "epss_percentile": 0.74485}, "CVE-2021-21082": {"epss_score": 0.03231, "epss_percentile": 0.86697}, "CVE-2021-21083": {"epss_score": 0.00354, "epss_percentile": 0.57214}, "CVE-2021-21084": {"epss_score": 0.02255, "epss_percentile": 0.84168}, "CVE-2021-21085": {"epss_score": 0.02553, "epss_percentile": 0.85084}, "CVE-2021-21086": {"epss_score": 0.11755, "epss_percentile": 0.93466}, "CVE-2021-21087": {"epss_score": 0.81792, "epss_percentile": 0.99156}, "CVE-2021-21088": {"epss_score": 0.00131, "epss_percentile": 0.33498}, "CVE-2021-21089": {"epss_score": 0.00707, "epss_percentile": 0.71661}, "CVE-2021-21090": {"epss_score": 0.02801, "epss_percentile": 0.85697}, "CVE-2021-21091": {"epss_score": 0.00417, "epss_percentile": 0.61235}, "CVE-2021-21092": {"epss_score": 0.01622, "epss_percentile": 0.81396}, "CVE-2021-21093": {"epss_score": 0.0131, "epss_percentile": 0.79358}, "CVE-2021-21094": {"epss_score": 0.02509, "epss_percentile": 0.84945}, "CVE-2021-21095": {"epss_score": 0.02111, "epss_percentile": 0.83646}, "CVE-2021-21096": {"epss_score": 0.00065, "epss_percentile": 0.2055}, "CVE-2021-21098": {"epss_score": 0.03546, "epss_percentile": 0.87327}, "CVE-2021-21099": {"epss_score": 0.03546, "epss_percentile": 0.87327}, "CVE-2021-21100": {"epss_score": 0.01022, "epss_percentile": 0.76763}, "CVE-2021-21101": {"epss_score": 0.05293, "epss_percentile": 0.89698}, "CVE-2021-21102": {"epss_score": 0.04287, "epss_percentile": 0.88496}, "CVE-2021-21103": {"epss_score": 0.00489, "epss_percentile": 0.64897}, "CVE-2021-21104": {"epss_score": 0.0382, "epss_percentile": 0.87775}, "CVE-2021-21105": {"epss_score": 0.04415, "epss_percentile": 0.88665}, "CVE-2021-21106": {"epss_score": 0.02806, "epss_percentile": 0.85708}, "CVE-2021-21107": {"epss_score": 0.01308, "epss_percentile": 0.79346}, "CVE-2021-21108": {"epss_score": 0.01308, "epss_percentile": 0.79346}, "CVE-2021-21109": {"epss_score": 0.01308, "epss_percentile": 0.79346}, "CVE-2021-21110": {"epss_score": 0.23074, "epss_percentile": 0.9573}, "CVE-2021-21111": {"epss_score": 0.00454, "epss_percentile": 0.63262}, "CVE-2021-21112": {"epss_score": 0.01729, "epss_percentile": 0.81981}, "CVE-2021-21113": {"epss_score": 0.01523, "epss_percentile": 0.80842}, "CVE-2021-21114": {"epss_score": 0.01308, "epss_percentile": 0.79346}, "CVE-2021-21115": {"epss_score": 0.01308, "epss_percentile": 0.79346}, "CVE-2021-21116": {"epss_score": 0.01523, "epss_percentile": 0.80842}, "CVE-2021-21117": {"epss_score": 0.00012, "epss_percentile": 0.01136}, "CVE-2021-21118": {"epss_score": 0.27839, "epss_percentile": 0.96286}, "CVE-2021-21119": {"epss_score": 0.036, "epss_percentile": 0.8741}, "CVE-2021-21120": {"epss_score": 0.05264, "epss_percentile": 0.89671}, "CVE-2021-21121": {"epss_score": 0.03401, "epss_percentile": 0.87068}, "CVE-2021-21122": {"epss_score": 0.036, "epss_percentile": 0.8741}, "CVE-2021-21123": {"epss_score": 0.02029, "epss_percentile": 0.8333}, "CVE-2021-21124": {"epss_score": 0.11182, "epss_percentile": 0.93257}, "CVE-2021-21125": {"epss_score": 0.06937, "epss_percentile": 0.91129}, "CVE-2021-21126": {"epss_score": 0.07628, "epss_percentile": 0.91583}, "CVE-2021-21127": {"epss_score": 0.02863, "epss_percentile": 0.85858}, "CVE-2021-21128": {"epss_score": 0.0625, "epss_percentile": 0.90614}, "CVE-2021-21129": {"epss_score": 0.04797, "epss_percentile": 0.89155}, "CVE-2021-21130": {"epss_score": 0.04797, "epss_percentile": 0.89155}, "CVE-2021-21131": {"epss_score": 0.00883, "epss_percentile": 0.74922}, "CVE-2021-21132": {"epss_score": 0.18445, "epss_percentile": 0.95017}, "CVE-2021-21133": {"epss_score": 0.09285, "epss_percentile": 0.92483}, "CVE-2021-21134": {"epss_score": 0.15325, "epss_percentile": 0.94411}, "CVE-2021-21135": {"epss_score": 0.24927, "epss_percentile": 0.95967}, "CVE-2021-21136": {"epss_score": 0.20144, "epss_percentile": 0.95293}, "CVE-2021-21137": {"epss_score": 0.03341, "epss_percentile": 0.86943}, "CVE-2021-21138": {"epss_score": 0.00145, "epss_percentile": 0.35498}, "CVE-2021-21139": {"epss_score": 0.03724, "epss_percentile": 0.87629}, "CVE-2021-21140": {"epss_score": 0.00171, "epss_percentile": 0.3877}, "CVE-2021-21141": {"epss_score": 0.04042, "epss_percentile": 0.88167}, "CVE-2021-21142": {"epss_score": 0.00606, "epss_percentile": 0.69023}, "CVE-2021-21143": {"epss_score": 0.00346, "epss_percentile": 0.56638}, "CVE-2021-21144": {"epss_score": 0.0032, "epss_percentile": 0.546}, "CVE-2021-21145": {"epss_score": 0.00638, "epss_percentile": 0.69914}, "CVE-2021-21146": {"epss_score": 0.00638, "epss_percentile": 0.69914}, "CVE-2021-21147": {"epss_score": 0.00244, "epss_percentile": 0.47519}, "CVE-2021-21148": {"epss_score": 0.19904, "epss_percentile": 0.95256}, "CVE-2021-21149": {"epss_score": 0.00865, "epss_percentile": 0.74629}, "CVE-2021-21150": {"epss_score": 0.00856, "epss_percentile": 0.74479}, "CVE-2021-21151": {"epss_score": 0.00728, "epss_percentile": 0.72116}, "CVE-2021-21152": {"epss_score": 0.00968, "epss_percentile": 0.76079}, "CVE-2021-21153": {"epss_score": 0.00968, "epss_percentile": 0.76079}, "CVE-2021-21154": {"epss_score": 0.01083, "epss_percentile": 0.7739}, "CVE-2021-21155": {"epss_score": 0.00853, "epss_percentile": 0.74427}, "CVE-2021-21156": {"epss_score": 0.01604, "epss_percentile": 0.81285}, "CVE-2021-21157": {"epss_score": 0.03549, "epss_percentile": 0.87337}, "CVE-2021-21159": {"epss_score": 0.01249, "epss_percentile": 0.78874}, "CVE-2021-21160": {"epss_score": 0.0171, "epss_percentile": 0.81875}, "CVE-2021-21161": {"epss_score": 0.01096, "epss_percentile": 0.77517}, "CVE-2021-21162": {"epss_score": 0.01441, "epss_percentile": 0.80303}, "CVE-2021-21163": {"epss_score": 0.00575, "epss_percentile": 0.68108}, "CVE-2021-21164": {"epss_score": 0.00408, "epss_percentile": 0.60671}, "CVE-2021-21165": {"epss_score": 0.01348, "epss_percentile": 0.7966}, "CVE-2021-21166": {"epss_score": 0.42174, "epss_percentile": 0.97316}, "CVE-2021-21167": {"epss_score": 0.01282, "epss_percentile": 0.79156}, "CVE-2021-21168": {"epss_score": 0.01357, "epss_percentile": 0.79721}, "CVE-2021-21169": {"epss_score": 0.01282, "epss_percentile": 0.79156}, "CVE-2021-21170": {"epss_score": 0.00973, "epss_percentile": 0.76167}, "CVE-2021-21171": {"epss_score": 0.00973, "epss_percentile": 0.76167}, "CVE-2021-21172": {"epss_score": 0.00419, "epss_percentile": 0.61359}, "CVE-2021-21173": {"epss_score": 0.01156, "epss_percentile": 0.78098}, "CVE-2021-21174": {"epss_score": 0.00589, "epss_percentile": 0.68522}, "CVE-2021-21175": {"epss_score": 0.00711, "epss_percentile": 0.71736}, "CVE-2021-21176": {"epss_score": 0.00973, "epss_percentile": 0.76167}, "CVE-2021-21177": {"epss_score": 0.01391, "epss_percentile": 0.79953}, "CVE-2021-21178": {"epss_score": 0.00973, "epss_percentile": 0.76167}, "CVE-2021-21179": {"epss_score": 0.01282, "epss_percentile": 0.79156}, "CVE-2021-21180": {"epss_score": 0.01282, "epss_percentile": 0.79156}, "CVE-2021-21181": {"epss_score": 0.01357, "epss_percentile": 0.79721}, "CVE-2021-21182": {"epss_score": 0.0034, "epss_percentile": 0.56241}, "CVE-2021-21183": {"epss_score": 0.00593, "epss_percentile": 0.68651}, "CVE-2021-21184": {"epss_score": 0.00593, "epss_percentile": 0.68651}, "CVE-2021-21185": {"epss_score": 0.00607, "epss_percentile": 0.6906}, "CVE-2021-21186": {"epss_score": 0.00433, "epss_percentile": 0.62184}, "CVE-2021-21187": {"epss_score": 0.00926, "epss_percentile": 0.75546}, "CVE-2021-21188": {"epss_score": 0.01282, "epss_percentile": 0.79156}, "CVE-2021-21189": {"epss_score": 0.00616, "epss_percentile": 0.6933}, "CVE-2021-21190": {"epss_score": 0.01249, "epss_percentile": 0.78875}, "CVE-2021-21191": {"epss_score": 0.00987, "epss_percentile": 0.76344}, "CVE-2021-21192": {"epss_score": 0.01464, "epss_percentile": 0.80446}, "CVE-2021-21193": {"epss_score": 0.148, "epss_percentile": 0.94287}, "CVE-2021-21194": {"epss_score": 0.00835, "epss_percentile": 0.74122}, "CVE-2021-21195": {"epss_score": 0.0012, "epss_percentile": 0.31733}, "CVE-2021-21196": {"epss_score": 0.01044, "epss_percentile": 0.77001}, "CVE-2021-21197": {"epss_score": 0.0074, "epss_percentile": 0.72398}, "CVE-2021-21198": {"epss_score": 0.00827, "epss_percentile": 0.73979}, "CVE-2021-21199": {"epss_score": 0.00668, "epss_percentile": 0.70727}, "CVE-2021-21200": {"epss_score": 0.004, "epss_percentile": 0.60191}, "CVE-2021-21201": {"epss_score": 0.00913, "epss_percentile": 0.75371}, "CVE-2021-21202": {"epss_score": 0.00201, "epss_percentile": 0.42355}, "CVE-2021-21203": {"epss_score": 0.0139, "epss_percentile": 0.79939}, "CVE-2021-21204": {"epss_score": 0.01401, "epss_percentile": 0.80007}, "CVE-2021-21205": {"epss_score": 0.00441, "epss_percentile": 0.62684}, "CVE-2021-21206": {"epss_score": 0.21907, "epss_percentile": 0.95571}, "CVE-2021-21207": {"epss_score": 0.00217, "epss_percentile": 0.44252}, "CVE-2021-21208": {"epss_score": 0.00487, "epss_percentile": 0.64826}, "CVE-2021-21209": {"epss_score": 0.00743, "epss_percentile": 0.72464}, "CVE-2021-21210": {"epss_score": 0.01017, "epss_percentile": 0.76686}, "CVE-2021-21211": {"epss_score": 0.00743, "epss_percentile": 0.72464}, "CVE-2021-21212": {"epss_score": 0.00865, "epss_percentile": 0.74627}, "CVE-2021-21213": {"epss_score": 0.01504, "epss_percentile": 0.80739}, "CVE-2021-21214": {"epss_score": 0.01094, "epss_percentile": 0.77493}, "CVE-2021-21215": {"epss_score": 0.00858, "epss_percentile": 0.745}, "CVE-2021-21216": {"epss_score": 0.00938, "epss_percentile": 0.7571}, "CVE-2021-21217": {"epss_score": 0.00572, "epss_percentile": 0.68031}, "CVE-2021-21218": {"epss_score": 0.00602, "epss_percentile": 0.68886}, "CVE-2021-21219": {"epss_score": 0.00602, "epss_percentile": 0.68886}, "CVE-2021-21220": {"epss_score": 0.92595, "epss_percentile": 0.99729}, "CVE-2021-21221": {"epss_score": 0.01207, "epss_percentile": 0.78526}, "CVE-2021-21222": {"epss_score": 0.00603, "epss_percentile": 0.68929}, "CVE-2021-21223": {"epss_score": 0.01158, "epss_percentile": 0.78116}, "CVE-2021-21224": {"epss_score": 0.54319, "epss_percentile": 0.97919}, "CVE-2021-21225": {"epss_score": 0.01013, "epss_percentile": 0.76636}, "CVE-2021-21226": {"epss_score": 0.01339, "epss_percentile": 0.7957}, "CVE-2021-21227": {"epss_score": 0.03176, "epss_percentile": 0.86568}, "CVE-2021-21228": {"epss_score": 0.00654, "epss_percentile": 0.70353}, "CVE-2021-21229": {"epss_score": 0.0086, "epss_percentile": 0.74532}, "CVE-2021-21230": {"epss_score": 0.03608, "epss_percentile": 0.8742}, "CVE-2021-21231": {"epss_score": 0.01953, "epss_percentile": 0.83025}, "CVE-2021-21232": {"epss_score": 0.01708, "epss_percentile": 0.81865}, "CVE-2021-21233": {"epss_score": 0.02329, "epss_percentile": 0.84398}, "CVE-2021-21234": {"epss_score": 0.93852, "epss_percentile": 0.99858}, "CVE-2021-21235": {"epss_score": 0.00436, "epss_percentile": 0.62448}, "CVE-2021-21236": {"epss_score": 0.00094, "epss_percentile": 0.27039}, "CVE-2021-21237": {"epss_score": 0.00197, "epss_percentile": 0.4195}, "CVE-2021-21238": {"epss_score": 0.0014, "epss_percentile": 0.34782}, "CVE-2021-21239": {"epss_score": 0.02672, "epss_percentile": 0.85395}, "CVE-2021-21240": {"epss_score": 0.01924, "epss_percentile": 0.82916}, "CVE-2021-21241": {"epss_score": 0.00421, "epss_percentile": 0.61483}, "CVE-2021-21242": {"epss_score": 0.43409, "epss_percentile": 0.97386}, "CVE-2021-21243": {"epss_score": 0.02877, "epss_percentile": 0.85883}, "CVE-2021-21244": {"epss_score": 0.00386, "epss_percentile": 0.59241}, "CVE-2021-21245": {"epss_score": 0.00345, "epss_percentile": 0.56564}, "CVE-2021-21246": {"epss_score": 0.00291, "epss_percentile": 0.52156}, "CVE-2021-21247": {"epss_score": 0.00307, "epss_percentile": 0.53502}, "CVE-2021-21248": {"epss_score": 0.00351, "epss_percentile": 0.57041}, "CVE-2021-21249": {"epss_score": 0.01328, "epss_percentile": 0.79501}, "CVE-2021-21250": {"epss_score": 0.00288, "epss_percentile": 0.51882}, "CVE-2021-21251": {"epss_score": 0.00711, "epss_percentile": 0.71741}, "CVE-2021-21252": {"epss_score": 0.00504, "epss_percentile": 0.65547}, "CVE-2021-21253": {"epss_score": 0.00108, "epss_percentile": 0.29902}, "CVE-2021-21254": {"epss_score": 0.00405, "epss_percentile": 0.605}, "CVE-2021-21255": {"epss_score": 0.0027, "epss_percentile": 0.50216}, "CVE-2021-21257": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-21258": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2021-21259": {"epss_score": 0.0027, "epss_percentile": 0.50247}, "CVE-2021-21260": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-21261": {"epss_score": 0.00225, "epss_percentile": 0.45235}, "CVE-2021-21263": {"epss_score": 0.01139, "epss_percentile": 0.77945}, "CVE-2021-21264": {"epss_score": 0.00034, "epss_percentile": 0.0948}, "CVE-2021-21265": {"epss_score": 0.0051, "epss_percentile": 0.65762}, "CVE-2021-21266": {"epss_score": 0.00361, "epss_percentile": 0.57717}, "CVE-2021-21267": {"epss_score": 0.00866, "epss_percentile": 0.74635}, "CVE-2021-21269": {"epss_score": 0.00358, "epss_percentile": 0.57517}, "CVE-2021-21270": {"epss_score": 0.00042, "epss_percentile": 0.12815}, "CVE-2021-21271": {"epss_score": 0.00487, "epss_percentile": 0.64802}, "CVE-2021-21272": {"epss_score": 0.00404, "epss_percentile": 0.60435}, "CVE-2021-21273": {"epss_score": 0.00387, "epss_percentile": 0.59289}, "CVE-2021-21274": {"epss_score": 0.00581, "epss_percentile": 0.68266}, "CVE-2021-21275": {"epss_score": 0.00178, "epss_percentile": 0.3971}, "CVE-2021-21276": {"epss_score": 0.20615, "epss_percentile": 0.95385}, "CVE-2021-21277": {"epss_score": 0.00328, "epss_percentile": 0.55193}, "CVE-2021-21278": {"epss_score": 0.00451, "epss_percentile": 0.63158}, "CVE-2021-21279": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2021-21280": {"epss_score": 0.00413, "epss_percentile": 0.61003}, "CVE-2021-21281": {"epss_score": 0.00438, "epss_percentile": 0.62549}, "CVE-2021-21282": {"epss_score": 0.00438, "epss_percentile": 0.62549}, "CVE-2021-21283": {"epss_score": 0.00347, "epss_percentile": 0.56734}, "CVE-2021-21284": {"epss_score": 0.0002, "epss_percentile": 0.04591}, "CVE-2021-21285": {"epss_score": 0.01168, "epss_percentile": 0.78192}, "CVE-2021-21286": {"epss_score": 0.00265, "epss_percentile": 0.49803}, "CVE-2021-21287": {"epss_score": 0.91999, "epss_percentile": 0.99684}, "CVE-2021-21288": {"epss_score": 0.002, "epss_percentile": 0.42246}, "CVE-2021-21289": {"epss_score": 0.02503, "epss_percentile": 0.84928}, "CVE-2021-21290": {"epss_score": 0.00026, "epss_percentile": 0.06618}, "CVE-2021-21291": {"epss_score": 0.0024, "epss_percentile": 0.46949}, "CVE-2021-21292": {"epss_score": 0.00064, "epss_percentile": 0.2035}, "CVE-2021-21293": {"epss_score": 0.00408, "epss_percentile": 0.60647}, "CVE-2021-21294": {"epss_score": 0.00408, "epss_percentile": 0.60647}, "CVE-2021-21295": {"epss_score": 0.0036, "epss_percentile": 0.57663}, "CVE-2021-21296": {"epss_score": 0.00682, "epss_percentile": 0.71067}, "CVE-2021-21297": {"epss_score": 0.00327, "epss_percentile": 0.55113}, "CVE-2021-21298": {"epss_score": 0.00365, "epss_percentile": 0.58002}, "CVE-2021-21299": {"epss_score": 0.00481, "epss_percentile": 0.64493}, "CVE-2021-21300": {"epss_score": 0.62075, "epss_percentile": 0.98275}, "CVE-2021-21301": {"epss_score": 0.00373, "epss_percentile": 0.58476}, "CVE-2021-21302": {"epss_score": 0.0047, "epss_percentile": 0.63964}, "CVE-2021-21303": {"epss_score": 0.00384, "epss_percentile": 0.59123}, "CVE-2021-21304": {"epss_score": 0.00637, "epss_percentile": 0.69885}, "CVE-2021-21305": {"epss_score": 0.0282, "epss_percentile": 0.85742}, "CVE-2021-21306": {"epss_score": 0.00603, "epss_percentile": 0.68898}, "CVE-2021-21307": {"epss_score": 0.92213, "epss_percentile": 0.99701}, "CVE-2021-21308": {"epss_score": 0.00368, "epss_percentile": 0.58217}, "CVE-2021-21309": {"epss_score": 0.00464, "epss_percentile": 0.63702}, "CVE-2021-21310": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2021-21311": {"epss_score": 0.93872, "epss_percentile": 0.9986}, "CVE-2021-21312": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2021-21313": {"epss_score": 0.00385, "epss_percentile": 0.59229}, "CVE-2021-21314": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2021-21315": {"epss_score": 0.93764, "epss_percentile": 0.99841}, "CVE-2021-21316": {"epss_score": 0.00301, "epss_percentile": 0.52994}, "CVE-2021-21317": {"epss_score": 0.01481, "epss_percentile": 0.8057}, "CVE-2021-21318": {"epss_score": 0.00192, "epss_percentile": 0.41373}, "CVE-2021-21319": {"epss_score": 0.00718, "epss_percentile": 0.71922}, "CVE-2021-21320": {"epss_score": 0.00185, "epss_percentile": 0.40484}, "CVE-2021-21321": {"epss_score": 0.00451, "epss_percentile": 0.63158}, "CVE-2021-21322": {"epss_score": 0.00446, "epss_percentile": 0.62905}, "CVE-2021-21323": {"epss_score": 0.00237, "epss_percentile": 0.4665}, "CVE-2021-21324": {"epss_score": 0.00312, "epss_percentile": 0.53961}, "CVE-2021-21325": {"epss_score": 0.00508, "epss_percentile": 0.65682}, "CVE-2021-21326": {"epss_score": 0.00211, "epss_percentile": 0.43687}, "CVE-2021-21327": {"epss_score": 0.003, "epss_percentile": 0.52946}, "CVE-2021-21328": {"epss_score": 0.00442, "epss_percentile": 0.62711}, "CVE-2021-21329": {"epss_score": 0.00315, "epss_percentile": 0.54176}, "CVE-2021-21330": {"epss_score": 0.00486, "epss_percentile": 0.6477}, "CVE-2021-21331": {"epss_score": 0.00204, "epss_percentile": 0.4261}, "CVE-2021-21332": {"epss_score": 0.00505, "epss_percentile": 0.65596}, "CVE-2021-21333": {"epss_score": 0.00385, "epss_percentile": 0.59187}, "CVE-2021-21334": {"epss_score": 0.00361, "epss_percentile": 0.57721}, "CVE-2021-21335": {"epss_score": 0.00416, "epss_percentile": 0.61165}, "CVE-2021-21336": {"epss_score": 0.00324, "epss_percentile": 0.54926}, "CVE-2021-21337": {"epss_score": 0.01798, "epss_percentile": 0.82312}, "CVE-2021-21338": {"epss_score": 0.00253, "epss_percentile": 0.48425}, "CVE-2021-21339": {"epss_score": 0.00132, "epss_percentile": 0.33514}, "CVE-2021-21340": {"epss_score": 0.00379, "epss_percentile": 0.58905}, "CVE-2021-21341": {"epss_score": 0.23434, "epss_percentile": 0.95777}, "CVE-2021-21342": {"epss_score": 0.01022, "epss_percentile": 0.76759}, "CVE-2021-21343": {"epss_score": 0.00687, "epss_percentile": 0.71185}, "CVE-2021-21344": {"epss_score": 0.28061, "epss_percentile": 0.96304}, "CVE-2021-21345": {"epss_score": 0.87079, "epss_percentile": 0.99413}, "CVE-2021-21346": {"epss_score": 0.03973, "epss_percentile": 0.88045}, "CVE-2021-21347": {"epss_score": 0.02891, "epss_percentile": 0.85918}, "CVE-2021-21348": {"epss_score": 0.00199, "epss_percentile": 0.42104}, "CVE-2021-21349": {"epss_score": 0.05914, "epss_percentile": 0.90317}, "CVE-2021-21350": {"epss_score": 0.08244, "epss_percentile": 0.91946}, "CVE-2021-21351": {"epss_score": 0.91268, "epss_percentile": 0.9963}, "CVE-2021-21352": {"epss_score": 0.00419, "epss_percentile": 0.61361}, "CVE-2021-21353": {"epss_score": 0.04259, "epss_percentile": 0.88461}, "CVE-2021-21354": {"epss_score": 0.00845, "epss_percentile": 0.74317}, "CVE-2021-21355": {"epss_score": 0.00416, "epss_percentile": 0.61218}, "CVE-2021-21357": {"epss_score": 0.01121, "epss_percentile": 0.77773}, "CVE-2021-21358": {"epss_score": 0.00379, "epss_percentile": 0.58905}, "CVE-2021-21359": {"epss_score": 0.00751, "epss_percentile": 0.72638}, "CVE-2021-21360": {"epss_score": 0.00337, "epss_percentile": 0.56024}, "CVE-2021-21361": {"epss_score": 0.00119, "epss_percentile": 0.31541}, "CVE-2021-21362": {"epss_score": 0.00103, "epss_percentile": 0.29035}, "CVE-2021-21363": {"epss_score": 0.00044, "epss_percentile": 0.13484}, "CVE-2021-21364": {"epss_score": 0.00067, "epss_percentile": 0.21084}, "CVE-2021-21365": {"epss_score": 0.00342, "epss_percentile": 0.56374}, "CVE-2021-21366": {"epss_score": 0.00574, "epss_percentile": 0.68087}, "CVE-2021-21367": {"epss_score": 0.00144, "epss_percentile": 0.3527}, "CVE-2021-21368": {"epss_score": 0.0133, "epss_percentile": 0.79511}, "CVE-2021-21369": {"epss_score": 0.00579, "epss_percentile": 0.68216}, "CVE-2021-21370": {"epss_score": 0.00342, "epss_percentile": 0.56374}, "CVE-2021-21371": {"epss_score": 0.00079, "epss_percentile": 0.23813}, "CVE-2021-21372": {"epss_score": 0.01789, "epss_percentile": 0.82276}, "CVE-2021-21373": {"epss_score": 0.0019, "epss_percentile": 0.41064}, "CVE-2021-21374": {"epss_score": 0.00313, "epss_percentile": 0.54076}, "CVE-2021-21375": {"epss_score": 0.01311, "epss_percentile": 0.79371}, "CVE-2021-21376": {"epss_score": 0.00424, "epss_percentile": 0.61652}, "CVE-2021-21377": {"epss_score": 0.00314, "epss_percentile": 0.54091}, "CVE-2021-21378": {"epss_score": 0.00421, "epss_percentile": 0.61496}, "CVE-2021-21379": {"epss_score": 0.00442, "epss_percentile": 0.62724}, "CVE-2021-21380": {"epss_score": 0.03318, "epss_percentile": 0.86905}, "CVE-2021-21381": {"epss_score": 0.00118, "epss_percentile": 0.31483}, "CVE-2021-21382": {"epss_score": 0.00455, "epss_percentile": 0.6328}, "CVE-2021-21383": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2021-21384": {"epss_score": 0.00165, "epss_percentile": 0.38107}, "CVE-2021-21385": {"epss_score": 0.00187, "epss_percentile": 0.40797}, "CVE-2021-21386": {"epss_score": 0.01049, "epss_percentile": 0.77061}, "CVE-2021-21387": {"epss_score": 0.00061, "epss_percentile": 0.19516}, "CVE-2021-21388": {"epss_score": 0.00617, "epss_percentile": 0.69349}, "CVE-2021-21389": {"epss_score": 0.93307, "epss_percentile": 0.99795}, "CVE-2021-21390": {"epss_score": 0.00385, "epss_percentile": 0.59182}, "CVE-2021-21391": {"epss_score": 0.08303, "epss_percentile": 0.91978}, "CVE-2021-21392": {"epss_score": 0.002, "epss_percentile": 0.42239}, "CVE-2021-21393": {"epss_score": 0.00548, "epss_percentile": 0.67269}, "CVE-2021-21394": {"epss_score": 0.00519, "epss_percentile": 0.66142}, "CVE-2021-21395": {"epss_score": 0.00404, "epss_percentile": 0.60396}, "CVE-2021-21396": {"epss_score": 0.00316, "epss_percentile": 0.54292}, "CVE-2021-21398": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2021-21399": {"epss_score": 0.0037, "epss_percentile": 0.58301}, "CVE-2021-21400": {"epss_score": 0.0042, "epss_percentile": 0.61452}, "CVE-2021-21401": {"epss_score": 0.00199, "epss_percentile": 0.42181}, "CVE-2021-21402": {"epss_score": 0.9275, "epss_percentile": 0.99742}, "CVE-2021-21403": {"epss_score": 0.00353, "epss_percentile": 0.57168}, "CVE-2021-21404": {"epss_score": 0.00918, "epss_percentile": 0.75444}, "CVE-2021-21405": {"epss_score": 0.00172, "epss_percentile": 0.39006}, "CVE-2021-21406": {"epss_score": 0.00575, "epss_percentile": 0.6812}, "CVE-2021-21407": {"epss_score": 0.00152, "epss_percentile": 0.36432}, "CVE-2021-21408": {"epss_score": 0.0028, "epss_percentile": 0.51098}, "CVE-2021-21409": {"epss_score": 0.02547, "epss_percentile": 0.85065}, "CVE-2021-21410": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-21411": {"epss_score": 0.00313, "epss_percentile": 0.54026}, "CVE-2021-21412": {"epss_score": 0.01082, "epss_percentile": 0.77381}, "CVE-2021-21413": {"epss_score": 0.00137, "epss_percentile": 0.34323}, "CVE-2021-21414": {"epss_score": 0.02563, "epss_percentile": 0.85109}, "CVE-2021-21415": {"epss_score": 0.00773, "epss_percentile": 0.73058}, "CVE-2021-21416": {"epss_score": 0.00188, "epss_percentile": 0.40916}, "CVE-2021-21417": {"epss_score": 0.00528, "epss_percentile": 0.66553}, "CVE-2021-21418": {"epss_score": 0.00264, "epss_percentile": 0.49737}, "CVE-2021-21419": {"epss_score": 0.00097, "epss_percentile": 0.27549}, "CVE-2021-21420": {"epss_score": 0.00203, "epss_percentile": 0.42522}, "CVE-2021-21421": {"epss_score": 0.00314, "epss_percentile": 0.54113}, "CVE-2021-21422": {"epss_score": 0.01294, "epss_percentile": 0.79243}, "CVE-2021-21423": {"epss_score": 0.00672, "epss_percentile": 0.70809}, "CVE-2021-21424": {"epss_score": 0.00266, "epss_percentile": 0.49877}, "CVE-2021-21425": {"epss_score": 0.91913, "epss_percentile": 0.99678}, "CVE-2021-21426": {"epss_score": 0.00405, "epss_percentile": 0.60494}, "CVE-2021-21427": {"epss_score": 0.00636, "epss_percentile": 0.69832}, "CVE-2021-21428": {"epss_score": 0.0005, "epss_percentile": 0.1582}, "CVE-2021-21429": {"epss_score": 0.00053, "epss_percentile": 0.16685}, "CVE-2021-21430": {"epss_score": 0.00068, "epss_percentile": 0.2122}, "CVE-2021-21431": {"epss_score": 0.00271, "epss_percentile": 0.50306}, "CVE-2021-21432": {"epss_score": 0.00301, "epss_percentile": 0.53045}, "CVE-2021-21433": {"epss_score": 0.03696, "epss_percentile": 0.87585}, "CVE-2021-21434": {"epss_score": 0.00364, "epss_percentile": 0.5791}, "CVE-2021-21435": {"epss_score": 0.00287, "epss_percentile": 0.51786}, "CVE-2021-21436": {"epss_score": 0.00112, "epss_percentile": 0.30556}, "CVE-2021-21437": {"epss_score": 0.00112, "epss_percentile": 0.30556}, "CVE-2021-21438": {"epss_score": 0.00172, "epss_percentile": 0.39004}, "CVE-2021-21439": {"epss_score": 0.00509, "epss_percentile": 0.6573}, "CVE-2021-21440": {"epss_score": 0.00181, "epss_percentile": 0.40108}, "CVE-2021-21441": {"epss_score": 0.00406, "epss_percentile": 0.60556}, "CVE-2021-21442": {"epss_score": 0.00345, "epss_percentile": 0.56566}, "CVE-2021-21443": {"epss_score": 0.00302, "epss_percentile": 0.53118}, "CVE-2021-21444": {"epss_score": 0.00169, "epss_percentile": 0.38636}, "CVE-2021-21445": {"epss_score": 0.00178, "epss_percentile": 0.397}, "CVE-2021-21446": {"epss_score": 0.00531, "epss_percentile": 0.66655}, "CVE-2021-21447": {"epss_score": 0.00262, "epss_percentile": 0.49347}, "CVE-2021-21448": {"epss_score": 0.00052, "epss_percentile": 0.16442}, "CVE-2021-21449": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21450": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21451": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21452": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21453": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21454": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21455": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21456": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21457": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21458": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21459": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21460": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21461": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21462": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21463": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2021-21464": {"epss_score": 0.00307, "epss_percentile": 0.53528}, "CVE-2021-21465": {"epss_score": 0.01427, "epss_percentile": 0.80213}, "CVE-2021-21466": {"epss_score": 0.02521, "epss_percentile": 0.85004}, "CVE-2021-21467": {"epss_score": 0.00105, "epss_percentile": 0.29265}, "CVE-2021-21468": {"epss_score": 0.00417, "epss_percentile": 0.61252}, "CVE-2021-21469": {"epss_score": 0.00204, "epss_percentile": 0.42605}, "CVE-2021-21470": {"epss_score": 0.00045, "epss_percentile": 0.13987}, "CVE-2021-21471": {"epss_score": 0.00439, "epss_percentile": 0.62606}, "CVE-2021-21472": {"epss_score": 0.00192, "epss_percentile": 0.41284}, "CVE-2021-21473": {"epss_score": 0.00475, "epss_percentile": 0.64196}, "CVE-2021-21474": {"epss_score": 0.00152, "epss_percentile": 0.3645}, "CVE-2021-21475": {"epss_score": 0.00534, "epss_percentile": 0.66779}, "CVE-2021-21476": {"epss_score": 0.00324, "epss_percentile": 0.54925}, "CVE-2021-21477": {"epss_score": 0.01147, "epss_percentile": 0.78006}, "CVE-2021-21478": {"epss_score": 0.00169, "epss_percentile": 0.38636}, "CVE-2021-21479": {"epss_score": 0.85973, "epss_percentile": 0.9936}, "CVE-2021-21480": {"epss_score": 0.24611, "epss_percentile": 0.95939}, "CVE-2021-21481": {"epss_score": 0.00156, "epss_percentile": 0.36959}, "CVE-2021-21482": {"epss_score": 0.00092, "epss_percentile": 0.26535}, "CVE-2021-21483": {"epss_score": 0.00238, "epss_percentile": 0.46834}, "CVE-2021-21484": {"epss_score": 0.00222, "epss_percentile": 0.44725}, "CVE-2021-21485": {"epss_score": 0.00274, "epss_percentile": 0.50563}, "CVE-2021-21486": {"epss_score": 0.00146, "epss_percentile": 0.35542}, "CVE-2021-21487": {"epss_score": 0.00146, "epss_percentile": 0.35542}, "CVE-2021-21488": {"epss_score": 0.00669, "epss_percentile": 0.70752}, "CVE-2021-21489": {"epss_score": 0.00237, "epss_percentile": 0.46713}, "CVE-2021-21490": {"epss_score": 0.00248, "epss_percentile": 0.4798}, "CVE-2021-21491": {"epss_score": 0.00133, "epss_percentile": 0.33666}, "CVE-2021-21492": {"epss_score": 0.00161, "epss_percentile": 0.37597}, "CVE-2021-21493": {"epss_score": 0.00196, "epss_percentile": 0.41782}, "CVE-2021-21494": {"epss_score": 0.0019, "epss_percentile": 0.41067}, "CVE-2021-21495": {"epss_score": 0.0021, "epss_percentile": 0.4345}, "CVE-2021-21501": {"epss_score": 0.0101, "epss_percentile": 0.76596}, "CVE-2021-21502": {"epss_score": 0.00272, "epss_percentile": 0.50415}, "CVE-2021-21503": {"epss_score": 0.00118, "epss_percentile": 0.31401}, "CVE-2021-21505": {"epss_score": 0.05406, "epss_percentile": 0.89838}, "CVE-2021-21506": {"epss_score": 0.00525, "epss_percentile": 0.66386}, "CVE-2021-21507": {"epss_score": 0.00086, "epss_percentile": 0.25323}, "CVE-2021-21510": {"epss_score": 0.00813, "epss_percentile": 0.73763}, "CVE-2021-21511": {"epss_score": 0.00152, "epss_percentile": 0.36437}, "CVE-2021-21512": {"epss_score": 0.00051, "epss_percentile": 0.16246}, "CVE-2021-21513": {"epss_score": 0.00505, "epss_percentile": 0.65584}, "CVE-2021-21514": {"epss_score": 0.07321, "epss_percentile": 0.91407}, "CVE-2021-21515": {"epss_score": 0.00256, "epss_percentile": 0.48803}, "CVE-2021-21517": {"epss_score": 0.00441, "epss_percentile": 0.62673}, "CVE-2021-21518": {"epss_score": 0.00037, "epss_percentile": 0.10684}, "CVE-2021-21522": {"epss_score": 0.00043, "epss_percentile": 0.1321}, "CVE-2021-21524": {"epss_score": 0.04597, "epss_percentile": 0.889}, "CVE-2021-21526": {"epss_score": 0.00027, "epss_percentile": 0.07205}, "CVE-2021-21527": {"epss_score": 0.00054, "epss_percentile": 0.1725}, "CVE-2021-21528": {"epss_score": 0.00274, "epss_percentile": 0.50539}, "CVE-2021-21529": {"epss_score": 0.0004, "epss_percentile": 0.12169}, "CVE-2021-21530": {"epss_score": 0.00385, "epss_percentile": 0.59233}, "CVE-2021-21531": {"epss_score": 0.00145, "epss_percentile": 0.35405}, "CVE-2021-21532": {"epss_score": 0.00052, "epss_percentile": 0.16359}, "CVE-2021-21533": {"epss_score": 0.00228, "epss_percentile": 0.45544}, "CVE-2021-21534": {"epss_score": 0.00051, "epss_percentile": 0.16317}, "CVE-2021-21535": {"epss_score": 0.00034, "epss_percentile": 0.09668}, "CVE-2021-21536": {"epss_score": 0.00057, "epss_percentile": 0.18087}, "CVE-2021-21537": {"epss_score": 0.00057, "epss_percentile": 0.18087}, "CVE-2021-21538": {"epss_score": 0.01553, "epss_percentile": 0.80997}, "CVE-2021-21539": {"epss_score": 0.00415, "epss_percentile": 0.61158}, "CVE-2021-21540": {"epss_score": 0.00528, "epss_percentile": 0.66559}, "CVE-2021-21541": {"epss_score": 0.01027, "epss_percentile": 0.76808}, "CVE-2021-21542": {"epss_score": 0.00219, "epss_percentile": 0.44519}, "CVE-2021-21543": {"epss_score": 0.00408, "epss_percentile": 0.60627}, "CVE-2021-21544": {"epss_score": 0.00289, "epss_percentile": 0.52016}, "CVE-2021-21545": {"epss_score": 0.00037, "epss_percentile": 0.10684}, "CVE-2021-21546": {"epss_score": 0.00042, "epss_percentile": 0.12902}, "CVE-2021-21547": {"epss_score": 0.00021, "epss_percentile": 0.04707}, "CVE-2021-21548": {"epss_score": 0.00066, "epss_percentile": 0.2071}, "CVE-2021-21549": {"epss_score": 0.00116, "epss_percentile": 0.31097}, "CVE-2021-21550": {"epss_score": 0.00054, "epss_percentile": 0.1725}, "CVE-2021-21551": {"epss_score": 0.72191, "epss_percentile": 0.98698}, "CVE-2021-21552": {"epss_score": 0.00139, "epss_percentile": 0.34648}, "CVE-2021-21553": {"epss_score": 0.00033, "epss_percentile": 0.09396}, "CVE-2021-21554": {"epss_score": 0.00049, "epss_percentile": 0.15488}, "CVE-2021-21555": {"epss_score": 0.00151, "epss_percentile": 0.36291}, "CVE-2021-21556": {"epss_score": 0.00049, "epss_percentile": 0.15488}, "CVE-2021-21557": {"epss_score": 0.00024, "epss_percentile": 0.06018}, "CVE-2021-21558": {"epss_score": 0.0006, "epss_percentile": 0.19133}, "CVE-2021-21559": {"epss_score": 0.00036, "epss_percentile": 0.10439}, "CVE-2021-21561": {"epss_score": 0.00048, "epss_percentile": 0.14953}, "CVE-2021-21562": {"epss_score": 0.00056, "epss_percentile": 0.17921}, "CVE-2021-21563": {"epss_score": 0.00237, "epss_percentile": 0.46654}, "CVE-2021-21564": {"epss_score": 0.00883, "epss_percentile": 0.7492}, "CVE-2021-21565": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2021-21567": {"epss_score": 0.0004, "epss_percentile": 0.12024}, "CVE-2021-21568": {"epss_score": 0.00209, "epss_percentile": 0.43347}, "CVE-2021-21569": {"epss_score": 0.00514, "epss_percentile": 0.65942}, "CVE-2021-21570": {"epss_score": 0.00437, "epss_percentile": 0.62501}, "CVE-2021-21571": {"epss_score": 0.00199, "epss_percentile": 0.42108}, "CVE-2021-21572": {"epss_score": 0.00046, "epss_percentile": 0.14121}, "CVE-2021-21573": {"epss_score": 0.00046, "epss_percentile": 0.14121}, "CVE-2021-21574": {"epss_score": 0.00089, "epss_percentile": 0.25851}, "CVE-2021-21575": {"epss_score": 0.00093, "epss_percentile": 0.26701}, "CVE-2021-21576": {"epss_score": 0.00331, "epss_percentile": 0.55506}, "CVE-2021-21577": {"epss_score": 0.00331, "epss_percentile": 0.55506}, "CVE-2021-21578": {"epss_score": 0.00692, "epss_percentile": 0.71299}, "CVE-2021-21579": {"epss_score": 0.00706, "epss_percentile": 0.71619}, "CVE-2021-21580": {"epss_score": 0.00484, "epss_percentile": 0.64652}, "CVE-2021-21581": {"epss_score": 0.00303, "epss_percentile": 0.53187}, "CVE-2021-21584": {"epss_score": 0.00235, "epss_percentile": 0.46217}, "CVE-2021-21585": {"epss_score": 0.01371, "epss_percentile": 0.79809}, "CVE-2021-21586": {"epss_score": 0.4607, "epss_percentile": 0.97521}, "CVE-2021-21587": {"epss_score": 0.05402, "epss_percentile": 0.89834}, "CVE-2021-21588": {"epss_score": 0.00138, "epss_percentile": 0.34465}, "CVE-2021-21589": {"epss_score": 0.00043, "epss_percentile": 0.1301}, "CVE-2021-21590": {"epss_score": 0.00047, "epss_percentile": 0.1477}, "CVE-2021-21591": {"epss_score": 0.00047, "epss_percentile": 0.1477}, "CVE-2021-21592": {"epss_score": 0.00215, "epss_percentile": 0.4405}, "CVE-2021-21594": {"epss_score": 0.00257, "epss_percentile": 0.48871}, "CVE-2021-21595": {"epss_score": 0.00137, "epss_percentile": 0.3422}, "CVE-2021-21596": {"epss_score": 0.00248, "epss_percentile": 0.47984}, "CVE-2021-21597": {"epss_score": 0.00044, "epss_percentile": 0.13421}, "CVE-2021-21598": {"epss_score": 0.00052, "epss_percentile": 0.16539}, "CVE-2021-21599": {"epss_score": 0.00219, "epss_percentile": 0.44467}, "CVE-2021-21600": {"epss_score": 0.00236, "epss_percentile": 0.46437}, "CVE-2021-21601": {"epss_score": 0.00038, "epss_percentile": 0.11316}, "CVE-2021-21602": {"epss_score": 0.01393, "epss_percentile": 0.79965}, "CVE-2021-21603": {"epss_score": 0.00319, "epss_percentile": 0.54472}, "CVE-2021-21604": {"epss_score": 0.00835, "epss_percentile": 0.74124}, "CVE-2021-21605": {"epss_score": 0.00441, "epss_percentile": 0.62666}, "CVE-2021-21606": {"epss_score": 0.00235, "epss_percentile": 0.46216}, "CVE-2021-21607": {"epss_score": 0.00332, "epss_percentile": 0.55553}, "CVE-2021-21608": {"epss_score": 0.0054, "epss_percentile": 0.66994}, "CVE-2021-21609": {"epss_score": 0.00149, "epss_percentile": 0.36008}, "CVE-2021-21610": {"epss_score": 0.00327, "epss_percentile": 0.55123}, "CVE-2021-21611": {"epss_score": 0.00319, "epss_percentile": 0.54472}, "CVE-2021-21612": {"epss_score": 0.00026, "epss_percentile": 0.06729}, "CVE-2021-21613": {"epss_score": 0.00241, "epss_percentile": 0.47249}, "CVE-2021-21614": {"epss_score": 0.00011, "epss_percentile": 0.01071}, "CVE-2021-21615": {"epss_score": 0.00436, "epss_percentile": 0.62467}, "CVE-2021-21616": {"epss_score": 0.02294, "epss_percentile": 0.8429}, "CVE-2021-21617": {"epss_score": 0.00074, "epss_percentile": 0.22817}, "CVE-2021-21618": {"epss_score": 0.00982, "epss_percentile": 0.76288}, "CVE-2021-21619": {"epss_score": 0.00151, "epss_percentile": 0.36318}, "CVE-2021-21620": {"epss_score": 0.00253, "epss_percentile": 0.48453}, "CVE-2021-21621": {"epss_score": 0.00049, "epss_percentile": 0.15588}, "CVE-2021-21622": {"epss_score": 0.00217, "epss_percentile": 0.44277}, "CVE-2021-21623": {"epss_score": 0.001, "epss_percentile": 0.28453}, "CVE-2021-21624": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2021-21625": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2021-21626": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2021-21627": {"epss_score": 0.00074, "epss_percentile": 0.22817}, "CVE-2021-21628": {"epss_score": 0.01259, "epss_percentile": 0.78967}, "CVE-2021-21629": {"epss_score": 0.00074, "epss_percentile": 0.22817}, "CVE-2021-21630": {"epss_score": 0.01259, "epss_percentile": 0.78967}, "CVE-2021-21631": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2021-21632": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2021-21633": {"epss_score": 0.00074, "epss_percentile": 0.22817}, "CVE-2021-21634": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2021-21635": {"epss_score": 0.00205, "epss_percentile": 0.42754}, "CVE-2021-21636": {"epss_score": 0.00031, "epss_percentile": 0.08662}, "CVE-2021-21637": {"epss_score": 0.00048, "epss_percentile": 0.15045}, "CVE-2021-21638": {"epss_score": 0.00074, "epss_percentile": 0.22817}, "CVE-2021-21639": {"epss_score": 0.00942, "epss_percentile": 0.75766}, "CVE-2021-21640": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2021-21641": {"epss_score": 0.02526, "epss_percentile": 0.85014}, "CVE-2021-21642": {"epss_score": 0.00298, "epss_percentile": 0.52796}, "CVE-2021-21643": {"epss_score": 0.00832, "epss_percentile": 0.74076}, "CVE-2021-21644": {"epss_score": 0.00203, "epss_percentile": 0.42536}, "CVE-2021-21645": {"epss_score": 0.00118, "epss_percentile": 0.31399}, "CVE-2021-21646": {"epss_score": 0.00387, "epss_percentile": 0.59328}, "CVE-2021-21647": {"epss_score": 0.00162, "epss_percentile": 0.3773}, "CVE-2021-21648": {"epss_score": 0.0031, "epss_percentile": 0.53762}, "CVE-2021-21649": {"epss_score": 0.00188, "epss_percentile": 0.4081}, "CVE-2021-21650": {"epss_score": 0.00048, "epss_percentile": 0.14983}, "CVE-2021-21651": {"epss_score": 0.00065, "epss_percentile": 0.20483}, "CVE-2021-21652": {"epss_score": 0.00283, "epss_percentile": 0.51362}, "CVE-2021-21653": {"epss_score": 0.00063, "epss_percentile": 0.20093}, "CVE-2021-21654": {"epss_score": 0.00088, "epss_percentile": 0.25699}, "CVE-2021-21655": {"epss_score": 0.0019, "epss_percentile": 0.41131}, "CVE-2021-21656": {"epss_score": 0.00202, "epss_percentile": 0.42406}, "CVE-2021-21657": {"epss_score": 0.00163, "epss_percentile": 0.37789}, "CVE-2021-21658": {"epss_score": 0.00686, "epss_percentile": 0.71155}, "CVE-2021-21659": {"epss_score": 0.00289, "epss_percentile": 0.52045}, "CVE-2021-21660": {"epss_score": 0.00246, "epss_percentile": 0.47757}, "CVE-2021-21661": {"epss_score": 0.00296, "epss_percentile": 0.52569}, "CVE-2021-21662": {"epss_score": 0.00119, "epss_percentile": 0.31681}, "CVE-2021-21663": {"epss_score": 0.00117, "epss_percentile": 0.31298}, "CVE-2021-21664": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2021-21665": {"epss_score": 0.00074, "epss_percentile": 0.22817}, "CVE-2021-21666": {"epss_score": 0.00168, "epss_percentile": 0.38432}, "CVE-2021-21667": {"epss_score": 0.00241, "epss_percentile": 0.473}, "CVE-2021-21668": {"epss_score": 0.01259, "epss_percentile": 0.78967}, "CVE-2021-21669": {"epss_score": 0.00213, "epss_percentile": 0.43854}, "CVE-2021-21670": {"epss_score": 0.01173, "epss_percentile": 0.78242}, "CVE-2021-21671": {"epss_score": 0.00273, "epss_percentile": 0.50432}, "CVE-2021-21672": {"epss_score": 0.00384, "epss_percentile": 0.59176}, "CVE-2021-21673": {"epss_score": 0.00077, "epss_percentile": 0.23388}, "CVE-2021-21674": {"epss_score": 0.00125, "epss_percentile": 0.32541}, "CVE-2021-21675": {"epss_score": 0.00603, "epss_percentile": 0.68903}, "CVE-2021-21676": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2021-21677": {"epss_score": 0.01198, "epss_percentile": 0.78454}, "CVE-2021-21678": {"epss_score": 0.00065, "epss_percentile": 0.20483}, "CVE-2021-21679": {"epss_score": 0.00055, "epss_percentile": 0.17406}, "CVE-2021-21680": {"epss_score": 0.00168, "epss_percentile": 0.38423}, "CVE-2021-21681": {"epss_score": 0.00011, "epss_percentile": 0.01071}, "CVE-2021-21682": {"epss_score": 0.00176, "epss_percentile": 0.39387}, "CVE-2021-21683": {"epss_score": 0.01205, "epss_percentile": 0.78516}, "CVE-2021-21684": {"epss_score": 0.00193, "epss_percentile": 0.41406}, "CVE-2021-21685": {"epss_score": 0.00197, "epss_percentile": 0.41955}, "CVE-2021-21686": {"epss_score": 0.00278, "epss_percentile": 0.50882}, "CVE-2021-21687": {"epss_score": 0.00271, "epss_percentile": 0.50341}, "CVE-2021-21688": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2021-21689": {"epss_score": 0.00805, "epss_percentile": 0.73633}, "CVE-2021-21690": {"epss_score": 0.00504, "epss_percentile": 0.65522}, "CVE-2021-21691": {"epss_score": 0.00637, "epss_percentile": 0.69891}, "CVE-2021-21692": {"epss_score": 0.00647, "epss_percentile": 0.70183}, "CVE-2021-21693": {"epss_score": 0.00508, "epss_percentile": 0.65707}, "CVE-2021-21694": {"epss_score": 0.00291, "epss_percentile": 0.52204}, "CVE-2021-21695": {"epss_score": 0.00528, "epss_percentile": 0.66558}, "CVE-2021-21696": {"epss_score": 0.00954, "epss_percentile": 0.75905}, "CVE-2021-21697": {"epss_score": 0.00808, "epss_percentile": 0.73689}, "CVE-2021-21698": {"epss_score": 0.02078, "epss_percentile": 0.83521}, "CVE-2021-21699": {"epss_score": 0.00241, "epss_percentile": 0.473}, "CVE-2021-21700": {"epss_score": 0.00205, "epss_percentile": 0.42754}, "CVE-2021-21701": {"epss_score": 0.00386, "epss_percentile": 0.59283}, "CVE-2021-21702": {"epss_score": 0.0025, "epss_percentile": 0.48243}, "CVE-2021-21703": {"epss_score": 0.00133, "epss_percentile": 0.33658}, "CVE-2021-21704": {"epss_score": 0.00138, "epss_percentile": 0.34368}, "CVE-2021-21705": {"epss_score": 0.00294, "epss_percentile": 0.52402}, "CVE-2021-21706": {"epss_score": 0.00529, "epss_percentile": 0.66596}, "CVE-2021-21707": {"epss_score": 0.00563, "epss_percentile": 0.67739}, "CVE-2021-21708": {"epss_score": 0.0026, "epss_percentile": 0.49166}, "CVE-2021-21722": {"epss_score": 0.00056, "epss_percentile": 0.17962}, "CVE-2021-21723": {"epss_score": 0.0056, "epss_percentile": 0.67639}, "CVE-2021-21724": {"epss_score": 0.00032, "epss_percentile": 0.08856}, "CVE-2021-21725": {"epss_score": 0.00076, "epss_percentile": 0.23101}, "CVE-2021-21726": {"epss_score": 0.00051, "epss_percentile": 0.16287}, "CVE-2021-21727": {"epss_score": 0.00607, "epss_percentile": 0.69045}, "CVE-2021-21728": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2021-21729": {"epss_score": 0.0012, "epss_percentile": 0.317}, "CVE-2021-21730": {"epss_score": 0.0033, "epss_percentile": 0.55457}, "CVE-2021-21731": {"epss_score": 0.00102, "epss_percentile": 0.28717}, "CVE-2021-21732": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-21733": {"epss_score": 0.00296, "epss_percentile": 0.52579}, "CVE-2021-21734": {"epss_score": 0.00138, "epss_percentile": 0.34366}, "CVE-2021-21735": {"epss_score": 0.00148, "epss_percentile": 0.35886}, "CVE-2021-21736": {"epss_score": 0.00326, "epss_percentile": 0.55048}, "CVE-2021-21737": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2021-21738": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-21739": {"epss_score": 0.00022, "epss_percentile": 0.05273}, "CVE-2021-21740": {"epss_score": 0.00049, "epss_percentile": 0.15647}, "CVE-2021-21741": {"epss_score": 0.01348, "epss_percentile": 0.79663}, "CVE-2021-21742": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2021-21743": {"epss_score": 0.00218, "epss_percentile": 0.4434}, "CVE-2021-21744": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2021-21745": {"epss_score": 0.40585, "epss_percentile": 0.97224}, "CVE-2021-21746": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-21747": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-21748": {"epss_score": 0.01297, "epss_percentile": 0.79264}, "CVE-2021-21749": {"epss_score": 0.01297, "epss_percentile": 0.79264}, "CVE-2021-21750": {"epss_score": 0.00043, "epss_percentile": 0.1336}, "CVE-2021-21751": {"epss_score": 0.00372, "epss_percentile": 0.58452}, "CVE-2021-21772": {"epss_score": 0.03749, "epss_percentile": 0.8767}, "CVE-2021-21773": {"epss_score": 0.00237, "epss_percentile": 0.46692}, "CVE-2021-21775": {"epss_score": 0.00631, "epss_percentile": 0.69723}, "CVE-2021-21776": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2021-21777": {"epss_score": 0.00342, "epss_percentile": 0.56353}, "CVE-2021-21778": {"epss_score": 0.00533, "epss_percentile": 0.66761}, "CVE-2021-21779": {"epss_score": 0.00508, "epss_percentile": 0.6571}, "CVE-2021-21781": {"epss_score": 0.00015, "epss_percentile": 0.02125}, "CVE-2021-21782": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2021-21783": {"epss_score": 0.03515, "epss_percentile": 0.87273}, "CVE-2021-21784": {"epss_score": 0.00294, "epss_percentile": 0.52435}, "CVE-2021-21785": {"epss_score": 0.00052, "epss_percentile": 0.16634}, "CVE-2021-21786": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2021-21787": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2021-21788": {"epss_score": 0.0005, "epss_percentile": 0.15965}, "CVE-2021-21789": {"epss_score": 0.0005, "epss_percentile": 0.15965}, "CVE-2021-21790": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2021-21791": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2021-21792": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2021-21793": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2021-21794": {"epss_score": 0.00237, "epss_percentile": 0.46692}, "CVE-2021-21795": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2021-21796": {"epss_score": 0.75472, "epss_percentile": 0.98847}, "CVE-2021-21797": {"epss_score": 0.73369, "epss_percentile": 0.98749}, "CVE-2021-21798": {"epss_score": 0.68653, "epss_percentile": 0.98558}, "CVE-2021-21799": {"epss_score": 0.75907, "epss_percentile": 0.9887}, "CVE-2021-21800": {"epss_score": 0.68444, "epss_percentile": 0.98549}, "CVE-2021-21801": {"epss_score": 0.84598, "epss_percentile": 0.99296}, "CVE-2021-21802": {"epss_score": 0.66834, "epss_percentile": 0.98483}, "CVE-2021-21803": {"epss_score": 0.73892, "epss_percentile": 0.98775}, "CVE-2021-21804": {"epss_score": 0.27808, "epss_percentile": 0.96284}, "CVE-2021-21805": {"epss_score": 0.91616, "epss_percentile": 0.99658}, "CVE-2021-21806": {"epss_score": 0.02072, "epss_percentile": 0.83492}, "CVE-2021-21807": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2021-21808": {"epss_score": 0.0042, "epss_percentile": 0.61459}, "CVE-2021-21809": {"epss_score": 0.72129, "epss_percentile": 0.98696}, "CVE-2021-21810": {"epss_score": 0.00593, "epss_percentile": 0.68633}, "CVE-2021-21811": {"epss_score": 0.00593, "epss_percentile": 0.68633}, "CVE-2021-21812": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2021-21813": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2021-21814": {"epss_score": 0.00136, "epss_percentile": 0.34166}, "CVE-2021-21815": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2021-21816": {"epss_score": 0.77268, "epss_percentile": 0.98929}, "CVE-2021-21817": {"epss_score": 0.01918, "epss_percentile": 0.82873}, "CVE-2021-21818": {"epss_score": 0.00638, "epss_percentile": 0.69928}, "CVE-2021-21819": {"epss_score": 0.01254, "epss_percentile": 0.78919}, "CVE-2021-21820": {"epss_score": 0.02001, "epss_percentile": 0.83221}, "CVE-2021-21821": {"epss_score": 0.01183, "epss_percentile": 0.78327}, "CVE-2021-21822": {"epss_score": 0.198, "epss_percentile": 0.95244}, "CVE-2021-21823": {"epss_score": 0.00271, "epss_percentile": 0.50343}, "CVE-2021-21824": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-21825": {"epss_score": 0.02268, "epss_percentile": 0.84202}, "CVE-2021-21826": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2021-21827": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2021-21828": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2021-21829": {"epss_score": 0.02268, "epss_percentile": 0.84202}, "CVE-2021-21830": {"epss_score": 0.02268, "epss_percentile": 0.84202}, "CVE-2021-21831": {"epss_score": 0.00998, "epss_percentile": 0.76472}, "CVE-2021-21832": {"epss_score": 0.00559, "epss_percentile": 0.67626}, "CVE-2021-21833": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-21834": {"epss_score": 0.00209, "epss_percentile": 0.43405}, "CVE-2021-21835": {"epss_score": 0.00438, "epss_percentile": 0.6255}, "CVE-2021-21836": {"epss_score": 0.0025, "epss_percentile": 0.48211}, "CVE-2021-21837": {"epss_score": 0.00509, "epss_percentile": 0.65736}, "CVE-2021-21838": {"epss_score": 0.00198, "epss_percentile": 0.41989}, "CVE-2021-21839": {"epss_score": 0.00509, "epss_percentile": 0.65736}, "CVE-2021-21840": {"epss_score": 0.0025, "epss_percentile": 0.48211}, "CVE-2021-21841": {"epss_score": 0.0025, "epss_percentile": 0.48211}, "CVE-2021-21842": {"epss_score": 0.00418, "epss_percentile": 0.61349}, "CVE-2021-21843": {"epss_score": 0.00232, "epss_percentile": 0.4586}, "CVE-2021-21844": {"epss_score": 0.00198, "epss_percentile": 0.41989}, "CVE-2021-21845": {"epss_score": 0.00509, "epss_percentile": 0.65736}, "CVE-2021-21846": {"epss_score": 0.00509, "epss_percentile": 0.65736}, "CVE-2021-21847": {"epss_score": 0.00198, "epss_percentile": 0.41989}, "CVE-2021-21848": {"epss_score": 0.00245, "epss_percentile": 0.47728}, "CVE-2021-21849": {"epss_score": 0.00418, "epss_percentile": 0.61349}, "CVE-2021-21850": {"epss_score": 0.00418, "epss_percentile": 0.61349}, "CVE-2021-21851": {"epss_score": 0.004, "epss_percentile": 0.60186}, "CVE-2021-21852": {"epss_score": 0.00168, "epss_percentile": 0.38464}, "CVE-2021-21853": {"epss_score": 0.00519, "epss_percentile": 0.66184}, "CVE-2021-21854": {"epss_score": 0.00519, "epss_percentile": 0.66184}, "CVE-2021-21855": {"epss_score": 0.00519, "epss_percentile": 0.66184}, "CVE-2021-21856": {"epss_score": 0.00543, "epss_percentile": 0.67119}, "CVE-2021-21857": {"epss_score": 0.00238, "epss_percentile": 0.46753}, "CVE-2021-21858": {"epss_score": 0.00238, "epss_percentile": 0.46753}, "CVE-2021-21859": {"epss_score": 0.00467, "epss_percentile": 0.63818}, "CVE-2021-21860": {"epss_score": 0.00457, "epss_percentile": 0.63393}, "CVE-2021-21861": {"epss_score": 0.00418, "epss_percentile": 0.61349}, "CVE-2021-21862": {"epss_score": 0.00443, "epss_percentile": 0.62766}, "CVE-2021-21863": {"epss_score": 0.00083, "epss_percentile": 0.24717}, "CVE-2021-21864": {"epss_score": 0.00158, "epss_percentile": 0.37229}, "CVE-2021-21865": {"epss_score": 0.00116, "epss_percentile": 0.31159}, "CVE-2021-21866": {"epss_score": 0.00158, "epss_percentile": 0.37229}, "CVE-2021-21867": {"epss_score": 0.00158, "epss_percentile": 0.37229}, "CVE-2021-21868": {"epss_score": 0.00158, "epss_percentile": 0.37229}, "CVE-2021-21869": {"epss_score": 0.00144, "epss_percentile": 0.35251}, "CVE-2021-21870": {"epss_score": 0.00864, "epss_percentile": 0.74603}, "CVE-2021-21871": {"epss_score": 0.00237, "epss_percentile": 0.46692}, "CVE-2021-21872": {"epss_score": 0.03545, "epss_percentile": 0.87325}, "CVE-2021-21873": {"epss_score": 0.01024, "epss_percentile": 0.76784}, "CVE-2021-21874": {"epss_score": 0.01024, "epss_percentile": 0.76784}, "CVE-2021-21875": {"epss_score": 0.01024, "epss_percentile": 0.76784}, "CVE-2021-21876": {"epss_score": 0.02807, "epss_percentile": 0.8571}, "CVE-2021-21877": {"epss_score": 0.02807, "epss_percentile": 0.8571}, "CVE-2021-21878": {"epss_score": 0.00288, "epss_percentile": 0.51952}, "CVE-2021-21879": {"epss_score": 0.00745, "epss_percentile": 0.7252}, "CVE-2021-21880": {"epss_score": 0.00267, "epss_percentile": 0.49975}, "CVE-2021-21881": {"epss_score": 0.92333, "epss_percentile": 0.99709}, "CVE-2021-21882": {"epss_score": 0.03544, "epss_percentile": 0.87322}, "CVE-2021-21883": {"epss_score": 0.03544, "epss_percentile": 0.87322}, "CVE-2021-21884": {"epss_score": 0.02857, "epss_percentile": 0.85844}, "CVE-2021-21885": {"epss_score": 0.00267, "epss_percentile": 0.49975}, "CVE-2021-21886": {"epss_score": 0.0034, "epss_percentile": 0.56285}, "CVE-2021-21887": {"epss_score": 0.02972, "epss_percentile": 0.86098}, "CVE-2021-21888": {"epss_score": 0.01478, "epss_percentile": 0.80552}, "CVE-2021-21889": {"epss_score": 0.03748, "epss_percentile": 0.87667}, "CVE-2021-21890": {"epss_score": 0.02972, "epss_percentile": 0.86098}, "CVE-2021-21891": {"epss_score": 0.02972, "epss_percentile": 0.86098}, "CVE-2021-21892": {"epss_score": 0.07147, "epss_percentile": 0.91283}, "CVE-2021-21893": {"epss_score": 0.01006, "epss_percentile": 0.76547}, "CVE-2021-21894": {"epss_score": 0.01278, "epss_percentile": 0.79124}, "CVE-2021-21895": {"epss_score": 0.02829, "epss_percentile": 0.85772}, "CVE-2021-21896": {"epss_score": 0.01398, "epss_percentile": 0.7999}, "CVE-2021-21897": {"epss_score": 0.02758, "epss_percentile": 0.85595}, "CVE-2021-21898": {"epss_score": 0.00249, "epss_percentile": 0.4804}, "CVE-2021-21899": {"epss_score": 0.00337, "epss_percentile": 0.56017}, "CVE-2021-21900": {"epss_score": 0.00338, "epss_percentile": 0.56137}, "CVE-2021-21901": {"epss_score": 0.00196, "epss_percentile": 0.41761}, "CVE-2021-21902": {"epss_score": 0.00437, "epss_percentile": 0.62511}, "CVE-2021-21903": {"epss_score": 0.00201, "epss_percentile": 0.42325}, "CVE-2021-21904": {"epss_score": 0.02063, "epss_percentile": 0.8345}, "CVE-2021-21905": {"epss_score": 0.00283, "epss_percentile": 0.51378}, "CVE-2021-21906": {"epss_score": 0.00283, "epss_percentile": 0.51378}, "CVE-2021-21907": {"epss_score": 0.00263, "epss_percentile": 0.49507}, "CVE-2021-21908": {"epss_score": 0.0102, "epss_percentile": 0.76733}, "CVE-2021-21909": {"epss_score": 0.00511, "epss_percentile": 0.65839}, "CVE-2021-21910": {"epss_score": 0.00038, "epss_percentile": 0.11117}, "CVE-2021-21911": {"epss_score": 0.00038, "epss_percentile": 0.11117}, "CVE-2021-21912": {"epss_score": 0.00038, "epss_percentile": 0.11117}, "CVE-2021-21913": {"epss_score": 0.00691, "epss_percentile": 0.71261}, "CVE-2021-21914": {"epss_score": 0.01182, "epss_percentile": 0.78315}, "CVE-2021-21915": {"epss_score": 0.0125, "epss_percentile": 0.78884}, "CVE-2021-21916": {"epss_score": 0.0125, "epss_percentile": 0.78884}, "CVE-2021-21917": {"epss_score": 0.0125, "epss_percentile": 0.78884}, "CVE-2021-21918": {"epss_score": 0.01337, "epss_percentile": 0.79563}, "CVE-2021-21919": {"epss_score": 0.01337, "epss_percentile": 0.79563}, "CVE-2021-21920": {"epss_score": 0.01337, "epss_percentile": 0.79563}, "CVE-2021-21921": {"epss_score": 0.01337, "epss_percentile": 0.79563}, "CVE-2021-21922": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21923": {"epss_score": 0.01337, "epss_percentile": 0.79563}, "CVE-2021-21924": {"epss_score": 0.01399, "epss_percentile": 0.79997}, "CVE-2021-21925": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21926": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21927": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21928": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21929": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21930": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21931": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21932": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21933": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21934": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21935": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21936": {"epss_score": 0.0125, "epss_percentile": 0.78884}, "CVE-2021-21937": {"epss_score": 0.01194, "epss_percentile": 0.78419}, "CVE-2021-21938": {"epss_score": 0.00791, "epss_percentile": 0.73394}, "CVE-2021-21939": {"epss_score": 0.01182, "epss_percentile": 0.78315}, "CVE-2021-21940": {"epss_score": 0.00523, "epss_percentile": 0.66298}, "CVE-2021-21941": {"epss_score": 0.01802, "epss_percentile": 0.82331}, "CVE-2021-21942": {"epss_score": 0.01038, "epss_percentile": 0.76934}, "CVE-2021-21943": {"epss_score": 0.01182, "epss_percentile": 0.78315}, "CVE-2021-21944": {"epss_score": 0.0042, "epss_percentile": 0.61459}, "CVE-2021-21945": {"epss_score": 0.0042, "epss_percentile": 0.61459}, "CVE-2021-21946": {"epss_score": 0.0042, "epss_percentile": 0.61459}, "CVE-2021-21947": {"epss_score": 0.0042, "epss_percentile": 0.61459}, "CVE-2021-21948": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2021-21949": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2021-21950": {"epss_score": 0.00882, "epss_percentile": 0.74883}, "CVE-2021-21951": {"epss_score": 0.00882, "epss_percentile": 0.74883}, "CVE-2021-21952": {"epss_score": 0.00459, "epss_percentile": 0.63454}, "CVE-2021-21953": {"epss_score": 0.00305, "epss_percentile": 0.53313}, "CVE-2021-21954": {"epss_score": 0.0166, "epss_percentile": 0.81621}, "CVE-2021-21955": {"epss_score": 0.00519, "epss_percentile": 0.66182}, "CVE-2021-21956": {"epss_score": 0.00433, "epss_percentile": 0.62182}, "CVE-2021-21957": {"epss_score": 0.00613, "epss_percentile": 0.69252}, "CVE-2021-21958": {"epss_score": 0.00827, "epss_percentile": 0.73978}, "CVE-2021-21959": {"epss_score": 0.00306, "epss_percentile": 0.53399}, "CVE-2021-21960": {"epss_score": 0.01884, "epss_percentile": 0.82703}, "CVE-2021-21961": {"epss_score": 0.01884, "epss_percentile": 0.82703}, "CVE-2021-21962": {"epss_score": 0.01899, "epss_percentile": 0.82765}, "CVE-2021-21963": {"epss_score": 0.00125, "epss_percentile": 0.32622}, "CVE-2021-21964": {"epss_score": 0.00221, "epss_percentile": 0.44654}, "CVE-2021-21965": {"epss_score": 0.00435, "epss_percentile": 0.62345}, "CVE-2021-21966": {"epss_score": 0.02024, "epss_percentile": 0.83309}, "CVE-2021-21967": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2021-21968": {"epss_score": 0.00419, "epss_percentile": 0.61368}, "CVE-2021-21969": {"epss_score": 0.00439, "epss_percentile": 0.62578}, "CVE-2021-21970": {"epss_score": 0.00439, "epss_percentile": 0.62578}, "CVE-2021-21971": {"epss_score": 0.00427, "epss_percentile": 0.61885}, "CVE-2021-21972": {"epss_score": 0.93821, "epss_percentile": 0.99853}, "CVE-2021-21973": {"epss_score": 0.90336, "epss_percentile": 0.99578}, "CVE-2021-21974": {"epss_score": 0.46867, "epss_percentile": 0.97559}, "CVE-2021-21975": {"epss_score": 0.94419, "epss_percentile": 0.99977}, "CVE-2021-21976": {"epss_score": 0.01597, "epss_percentile": 0.81244}, "CVE-2021-21978": {"epss_score": 0.90903, "epss_percentile": 0.99608}, "CVE-2021-21979": {"epss_score": 0.00173, "epss_percentile": 0.39111}, "CVE-2021-21980": {"epss_score": 0.10573, "epss_percentile": 0.93031}, "CVE-2021-21981": {"epss_score": 0.00046, "epss_percentile": 0.14163}, "CVE-2021-21982": {"epss_score": 0.00265, "epss_percentile": 0.49805}, "CVE-2021-21983": {"epss_score": 0.83177, "epss_percentile": 0.99237}, "CVE-2021-21984": {"epss_score": 0.01808, "epss_percentile": 0.82356}, "CVE-2021-21985": {"epss_score": 0.94412, "epss_percentile": 0.99975}, "CVE-2021-21986": {"epss_score": 0.01494, "epss_percentile": 0.80651}, "CVE-2021-21987": {"epss_score": 0.00178, "epss_percentile": 0.39662}, "CVE-2021-21988": {"epss_score": 0.00053, "epss_percentile": 0.16969}, "CVE-2021-21989": {"epss_score": 0.00053, "epss_percentile": 0.16969}, "CVE-2021-21990": {"epss_score": 0.00616, "epss_percentile": 0.69317}, "CVE-2021-21991": {"epss_score": 0.00181, "epss_percentile": 0.40113}, "CVE-2021-21992": {"epss_score": 0.00896, "epss_percentile": 0.75114}, "CVE-2021-21993": {"epss_score": 0.00237, "epss_percentile": 0.46706}, "CVE-2021-21994": {"epss_score": 0.00378, "epss_percentile": 0.58831}, "CVE-2021-21995": {"epss_score": 0.00403, "epss_percentile": 0.60331}, "CVE-2021-21996": {"epss_score": 0.02739, "epss_percentile": 0.85557}, "CVE-2021-21997": {"epss_score": 0.00091, "epss_percentile": 0.26406}, "CVE-2021-21998": {"epss_score": 0.00491, "epss_percentile": 0.64945}, "CVE-2021-21999": {"epss_score": 0.00064, "epss_percentile": 0.20314}, "CVE-2021-22000": {"epss_score": 0.00148, "epss_percentile": 0.35919}, "CVE-2021-22001": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-22002": {"epss_score": 0.00462, "epss_percentile": 0.63581}, "CVE-2021-22003": {"epss_score": 0.00419, "epss_percentile": 0.61372}, "CVE-2021-22004": {"epss_score": 0.00051, "epss_percentile": 0.16323}, "CVE-2021-22005": {"epss_score": 0.94457, "epss_percentile": 0.99993}, "CVE-2021-22006": {"epss_score": 0.58604, "epss_percentile": 0.98126}, "CVE-2021-22007": {"epss_score": 0.00101, "epss_percentile": 0.28659}, "CVE-2021-22008": {"epss_score": 0.00684, "epss_percentile": 0.71125}, "CVE-2021-22009": {"epss_score": 0.01465, "epss_percentile": 0.80455}, "CVE-2021-22010": {"epss_score": 0.01465, "epss_percentile": 0.80455}, "CVE-2021-22011": {"epss_score": 0.00815, "epss_percentile": 0.73782}, "CVE-2021-22012": {"epss_score": 0.00656, "epss_percentile": 0.70434}, "CVE-2021-22013": {"epss_score": 0.00729, "epss_percentile": 0.72129}, "CVE-2021-22014": {"epss_score": 0.01153, "epss_percentile": 0.78061}, "CVE-2021-22015": {"epss_score": 0.01789, "epss_percentile": 0.82268}, "CVE-2021-22016": {"epss_score": 0.01226, "epss_percentile": 0.78693}, "CVE-2021-22017": {"epss_score": 0.75711, "epss_percentile": 0.98861}, "CVE-2021-22018": {"epss_score": 0.00375, "epss_percentile": 0.58626}, "CVE-2021-22019": {"epss_score": 0.01465, "epss_percentile": 0.80455}, "CVE-2021-22020": {"epss_score": 0.00116, "epss_percentile": 0.31106}, "CVE-2021-22021": {"epss_score": 0.00242, "epss_percentile": 0.47352}, "CVE-2021-22022": {"epss_score": 0.00214, "epss_percentile": 0.43957}, "CVE-2021-22023": {"epss_score": 0.00324, "epss_percentile": 0.54969}, "CVE-2021-22024": {"epss_score": 0.00273, "epss_percentile": 0.50477}, "CVE-2021-22025": {"epss_score": 0.00189, "epss_percentile": 0.40949}, "CVE-2021-22026": {"epss_score": 0.00253, "epss_percentile": 0.48476}, "CVE-2021-22027": {"epss_score": 0.00228, "epss_percentile": 0.45522}, "CVE-2021-22028": {"epss_score": 0.00467, "epss_percentile": 0.63811}, "CVE-2021-22029": {"epss_score": 0.00278, "epss_percentile": 0.50871}, "CVE-2021-22030": {"epss_score": 0.00589, "epss_percentile": 0.68536}, "CVE-2021-22033": {"epss_score": 0.00159, "epss_percentile": 0.37344}, "CVE-2021-22034": {"epss_score": 0.0023, "epss_percentile": 0.45744}, "CVE-2021-22035": {"epss_score": 0.00267, "epss_percentile": 0.49995}, "CVE-2021-22036": {"epss_score": 0.00582, "epss_percentile": 0.68295}, "CVE-2021-22037": {"epss_score": 0.00133, "epss_percentile": 0.33625}, "CVE-2021-22038": {"epss_score": 0.00672, "epss_percentile": 0.70814}, "CVE-2021-22040": {"epss_score": 0.00739, "epss_percentile": 0.72395}, "CVE-2021-22041": {"epss_score": 0.00577, "epss_percentile": 0.68158}, "CVE-2021-22042": {"epss_score": 0.00249, "epss_percentile": 0.4808}, "CVE-2021-22043": {"epss_score": 0.00312, "epss_percentile": 0.53941}, "CVE-2021-22044": {"epss_score": 0.00328, "epss_percentile": 0.55153}, "CVE-2021-22045": {"epss_score": 0.02138, "epss_percentile": 0.83734}, "CVE-2021-22047": {"epss_score": 0.00315, "epss_percentile": 0.54181}, "CVE-2021-22048": {"epss_score": 0.00932, "epss_percentile": 0.75632}, "CVE-2021-22049": {"epss_score": 0.00655, "epss_percentile": 0.70424}, "CVE-2021-22050": {"epss_score": 0.01005, "epss_percentile": 0.76544}, "CVE-2021-22051": {"epss_score": 0.00135, "epss_percentile": 0.34022}, "CVE-2021-22053": {"epss_score": 0.85682, "epss_percentile": 0.99343}, "CVE-2021-22054": {"epss_score": 0.84417, "epss_percentile": 0.99289}, "CVE-2021-22055": {"epss_score": 0.00169, "epss_percentile": 0.38615}, "CVE-2021-22056": {"epss_score": 0.00657, "epss_percentile": 0.70476}, "CVE-2021-22057": {"epss_score": 0.00152, "epss_percentile": 0.36401}, "CVE-2021-22060": {"epss_score": 0.00193, "epss_percentile": 0.41393}, "CVE-2021-22095": {"epss_score": 0.00571, "epss_percentile": 0.67983}, "CVE-2021-22096": {"epss_score": 0.00221, "epss_percentile": 0.44642}, "CVE-2021-22097": {"epss_score": 0.00434, "epss_percentile": 0.62282}, "CVE-2021-22098": {"epss_score": 0.00272, "epss_percentile": 0.50364}, "CVE-2021-22100": {"epss_score": 0.00522, "epss_percentile": 0.66284}, "CVE-2021-22101": {"epss_score": 0.0098, "epss_percentile": 0.76265}, "CVE-2021-22112": {"epss_score": 0.00979, "epss_percentile": 0.76255}, "CVE-2021-22113": {"epss_score": 0.00165, "epss_percentile": 0.38084}, "CVE-2021-22114": {"epss_score": 0.00387, "epss_percentile": 0.59317}, "CVE-2021-22115": {"epss_score": 0.00215, "epss_percentile": 0.44054}, "CVE-2021-22116": {"epss_score": 0.01026, "epss_percentile": 0.76799}, "CVE-2021-22117": {"epss_score": 0.00102, "epss_percentile": 0.28805}, "CVE-2021-22118": {"epss_score": 0.0019, "epss_percentile": 0.41088}, "CVE-2021-22119": {"epss_score": 0.04895, "epss_percentile": 0.89268}, "CVE-2021-22122": {"epss_score": 0.52697, "epss_percentile": 0.97835}, "CVE-2021-22123": {"epss_score": 0.80497, "epss_percentile": 0.99092}, "CVE-2021-22124": {"epss_score": 0.01138, "epss_percentile": 0.77928}, "CVE-2021-22125": {"epss_score": 0.00306, "epss_percentile": 0.5341}, "CVE-2021-22126": {"epss_score": 0.00024, "epss_percentile": 0.05848}, "CVE-2021-22127": {"epss_score": 0.00311, "epss_percentile": 0.53865}, "CVE-2021-22128": {"epss_score": 0.00385, "epss_percentile": 0.59186}, "CVE-2021-22129": {"epss_score": 0.00452, "epss_percentile": 0.63164}, "CVE-2021-22130": {"epss_score": 0.00618, "epss_percentile": 0.69385}, "CVE-2021-22131": {"epss_score": 0.00052, "epss_percentile": 0.16636}, "CVE-2021-22132": {"epss_score": 0.00411, "epss_percentile": 0.60849}, "CVE-2021-22133": {"epss_score": 0.00073, "epss_percentile": 0.22664}, "CVE-2021-22134": {"epss_score": 0.00165, "epss_percentile": 0.38023}, "CVE-2021-22135": {"epss_score": 0.00212, "epss_percentile": 0.43752}, "CVE-2021-22136": {"epss_score": 0.00112, "epss_percentile": 0.3043}, "CVE-2021-22137": {"epss_score": 0.00128, "epss_percentile": 0.33053}, "CVE-2021-22138": {"epss_score": 0.00109, "epss_percentile": 0.29988}, "CVE-2021-22139": {"epss_score": 0.00388, "epss_percentile": 0.59399}, "CVE-2021-22140": {"epss_score": 0.00367, "epss_percentile": 0.581}, "CVE-2021-22141": {"epss_score": 0.00347, "epss_percentile": 0.56734}, "CVE-2021-22142": {"epss_score": 0.0047, "epss_percentile": 0.63984}, "CVE-2021-22143": {"epss_score": 0.00202, "epss_percentile": 0.42466}, "CVE-2021-22144": {"epss_score": 0.00501, "epss_percentile": 0.65353}, "CVE-2021-22145": {"epss_score": 0.65695, "epss_percentile": 0.98433}, "CVE-2021-22146": {"epss_score": 0.29897, "epss_percentile": 0.96485}, "CVE-2021-22147": {"epss_score": 0.00314, "epss_percentile": 0.54112}, "CVE-2021-22148": {"epss_score": 0.00232, "epss_percentile": 0.459}, "CVE-2021-22149": {"epss_score": 0.00266, "epss_percentile": 0.49898}, "CVE-2021-22150": {"epss_score": 0.00162, "epss_percentile": 0.37693}, "CVE-2021-22151": {"epss_score": 0.00592, "epss_percentile": 0.68624}, "CVE-2021-22152": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-22153": {"epss_score": 0.00651, "epss_percentile": 0.70291}, "CVE-2021-22154": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2021-22155": {"epss_score": 0.00374, "epss_percentile": 0.58543}, "CVE-2021-22156": {"epss_score": 0.01277, "epss_percentile": 0.79114}, "CVE-2021-22157": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2021-22158": {"epss_score": 0.00207, "epss_percentile": 0.43152}, "CVE-2021-22159": {"epss_score": 0.00034, "epss_percentile": 0.09798}, "CVE-2021-22160": {"epss_score": 0.18529, "epss_percentile": 0.95029}, "CVE-2021-22161": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-22166": {"epss_score": 0.0015, "epss_percentile": 0.36135}, "CVE-2021-22167": {"epss_score": 0.00248, "epss_percentile": 0.47929}, "CVE-2021-22168": {"epss_score": 0.00171, "epss_percentile": 0.38817}, "CVE-2021-22169": {"epss_score": 0.002, "epss_percentile": 0.42253}, "CVE-2021-22170": {"epss_score": 0.00066, "epss_percentile": 0.20768}, "CVE-2021-22171": {"epss_score": 0.00127, "epss_percentile": 0.32837}, "CVE-2021-22172": {"epss_score": 0.00255, "epss_percentile": 0.48695}, "CVE-2021-22173": {"epss_score": 0.00499, "epss_percentile": 0.65259}, "CVE-2021-22174": {"epss_score": 0.0019, "epss_percentile": 0.41135}, "CVE-2021-22175": {"epss_score": 0.60386, "epss_percentile": 0.98205}, "CVE-2021-22176": {"epss_score": 0.00241, "epss_percentile": 0.4732}, "CVE-2021-22177": {"epss_score": 0.00165, "epss_percentile": 0.38028}, "CVE-2021-22178": {"epss_score": 0.00275, "epss_percentile": 0.50652}, "CVE-2021-22179": {"epss_score": 0.0031, "epss_percentile": 0.53731}, "CVE-2021-22180": {"epss_score": 0.00139, "epss_percentile": 0.34572}, "CVE-2021-22181": {"epss_score": 0.00171, "epss_percentile": 0.38805}, "CVE-2021-22182": {"epss_score": 0.0014, "epss_percentile": 0.3475}, "CVE-2021-22183": {"epss_score": 0.00176, "epss_percentile": 0.39384}, "CVE-2021-22184": {"epss_score": 0.00071, "epss_percentile": 0.22125}, "CVE-2021-22185": {"epss_score": 0.0017, "epss_percentile": 0.38699}, "CVE-2021-22186": {"epss_score": 0.0017, "epss_percentile": 0.38765}, "CVE-2021-22187": {"epss_score": 0.00172, "epss_percentile": 0.38993}, "CVE-2021-22188": {"epss_score": 0.00329, "epss_percentile": 0.55298}, "CVE-2021-22189": {"epss_score": 0.00085, "epss_percentile": 0.25157}, "CVE-2021-22190": {"epss_score": 0.00335, "epss_percentile": 0.5586}, "CVE-2021-22191": {"epss_score": 0.00502, "epss_percentile": 0.65375}, "CVE-2021-22192": {"epss_score": 0.81162, "epss_percentile": 0.99125}, "CVE-2021-22193": {"epss_score": 0.00279, "epss_percentile": 0.5096}, "CVE-2021-22194": {"epss_score": 0.00036, "epss_percentile": 0.10165}, "CVE-2021-22195": {"epss_score": 0.00206, "epss_percentile": 0.42783}, "CVE-2021-22196": {"epss_score": 0.00191, "epss_percentile": 0.41205}, "CVE-2021-22197": {"epss_score": 0.00353, "epss_percentile": 0.57135}, "CVE-2021-22198": {"epss_score": 0.003, "epss_percentile": 0.52938}, "CVE-2021-22199": {"epss_score": 0.0017, "epss_percentile": 0.38699}, "CVE-2021-22200": {"epss_score": 0.00174, "epss_percentile": 0.39164}, "CVE-2021-22201": {"epss_score": 0.0899, "epss_percentile": 0.92355}, "CVE-2021-22202": {"epss_score": 0.00156, "epss_percentile": 0.36887}, "CVE-2021-22203": {"epss_score": 0.00241, "epss_percentile": 0.47238}, "CVE-2021-22204": {"epss_score": 0.92761, "epss_percentile": 0.99745}, "CVE-2021-22205": {"epss_score": 0.94467, "epss_percentile": 0.99996}, "CVE-2021-22206": {"epss_score": 0.00116, "epss_percentile": 0.3111}, "CVE-2021-22207": {"epss_score": 0.0047, "epss_percentile": 0.63992}, "CVE-2021-22208": {"epss_score": 0.00184, "epss_percentile": 0.40446}, "CVE-2021-22209": {"epss_score": 0.00186, "epss_percentile": 0.40653}, "CVE-2021-22210": {"epss_score": 0.00198, "epss_percentile": 0.42062}, "CVE-2021-22211": {"epss_score": 0.00165, "epss_percentile": 0.38033}, "CVE-2021-22212": {"epss_score": 0.00139, "epss_percentile": 0.34558}, "CVE-2021-22213": {"epss_score": 0.0096, "epss_percentile": 0.75962}, "CVE-2021-22214": {"epss_score": 0.9352, "epss_percentile": 0.99814}, "CVE-2021-22215": {"epss_score": 0.00203, "epss_percentile": 0.42555}, "CVE-2021-22216": {"epss_score": 0.00171, "epss_percentile": 0.38817}, "CVE-2021-22217": {"epss_score": 0.0068, "epss_percentile": 0.71029}, "CVE-2021-22218": {"epss_score": 0.00125, "epss_percentile": 0.32486}, "CVE-2021-22219": {"epss_score": 0.00207, "epss_percentile": 0.43186}, "CVE-2021-22220": {"epss_score": 0.0015, "epss_percentile": 0.36103}, "CVE-2021-22221": {"epss_score": 0.00189, "epss_percentile": 0.40964}, "CVE-2021-22222": {"epss_score": 0.00188, "epss_percentile": 0.40849}, "CVE-2021-22223": {"epss_score": 0.00185, "epss_percentile": 0.40506}, "CVE-2021-22224": {"epss_score": 0.00374, "epss_percentile": 0.58543}, "CVE-2021-22225": {"epss_score": 0.00135, "epss_percentile": 0.34053}, "CVE-2021-22226": {"epss_score": 0.00191, "epss_percentile": 0.41186}, "CVE-2021-22227": {"epss_score": 0.00106, "epss_percentile": 0.29431}, "CVE-2021-22228": {"epss_score": 0.00231, "epss_percentile": 0.45796}, "CVE-2021-22229": {"epss_score": 0.002, "epss_percentile": 0.42217}, "CVE-2021-22230": {"epss_score": 0.00196, "epss_percentile": 0.41775}, "CVE-2021-22231": {"epss_score": 0.00376, "epss_percentile": 0.58678}, "CVE-2021-22232": {"epss_score": 0.00128, "epss_percentile": 0.33032}, "CVE-2021-22233": {"epss_score": 0.00186, "epss_percentile": 0.40586}, "CVE-2021-22234": {"epss_score": 0.00172, "epss_percentile": 0.38938}, "CVE-2021-22235": {"epss_score": 0.00828, "epss_percentile": 0.73991}, "CVE-2021-22236": {"epss_score": 0.00225, "epss_percentile": 0.45147}, "CVE-2021-22237": {"epss_score": 0.00175, "epss_percentile": 0.39334}, "CVE-2021-22238": {"epss_score": 0.01011, "epss_percentile": 0.76613}, "CVE-2021-22239": {"epss_score": 0.00165, "epss_percentile": 0.38033}, "CVE-2021-22240": {"epss_score": 0.00226, "epss_percentile": 0.45245}, "CVE-2021-22241": {"epss_score": 0.00185, "epss_percentile": 0.40471}, "CVE-2021-22242": {"epss_score": 0.02281, "epss_percentile": 0.8425}, "CVE-2021-22243": {"epss_score": 0.00179, "epss_percentile": 0.39783}, "CVE-2021-22244": {"epss_score": 0.00266, "epss_percentile": 0.49914}, "CVE-2021-22245": {"epss_score": 0.00401, "epss_percentile": 0.60245}, "CVE-2021-22246": {"epss_score": 0.00223, "epss_percentile": 0.44963}, "CVE-2021-22247": {"epss_score": 0.00245, "epss_percentile": 0.47665}, "CVE-2021-22248": {"epss_score": 0.00218, "epss_percentile": 0.44401}, "CVE-2021-22249": {"epss_score": 0.00274, "epss_percentile": 0.50562}, "CVE-2021-22250": {"epss_score": 0.00253, "epss_percentile": 0.48435}, "CVE-2021-22251": {"epss_score": 0.00218, "epss_percentile": 0.44371}, "CVE-2021-22252": {"epss_score": 0.00266, "epss_percentile": 0.49914}, "CVE-2021-22253": {"epss_score": 0.0031, "epss_percentile": 0.53731}, "CVE-2021-22254": {"epss_score": 0.00274, "epss_percentile": 0.50562}, "CVE-2021-22255": {"epss_score": 0.00215, "epss_percentile": 0.44111}, "CVE-2021-22256": {"epss_score": 0.00226, "epss_percentile": 0.45245}, "CVE-2021-22257": {"epss_score": 0.00218, "epss_percentile": 0.44401}, "CVE-2021-22258": {"epss_score": 0.00274, "epss_percentile": 0.50562}, "CVE-2021-22259": {"epss_score": 0.00282, "epss_percentile": 0.51265}, "CVE-2021-22260": {"epss_score": 0.0016, "epss_percentile": 0.37498}, "CVE-2021-22261": {"epss_score": 0.00197, "epss_percentile": 0.41888}, "CVE-2021-22262": {"epss_score": 0.00155, "epss_percentile": 0.3682}, "CVE-2021-22263": {"epss_score": 0.00205, "epss_percentile": 0.42747}, "CVE-2021-22264": {"epss_score": 0.00142, "epss_percentile": 0.35003}, "CVE-2021-22267": {"epss_score": 0.0033, "epss_percentile": 0.55484}, "CVE-2021-22272": {"epss_score": 0.00192, "epss_percentile": 0.41318}, "CVE-2021-22275": {"epss_score": 0.00438, "epss_percentile": 0.62546}, "CVE-2021-22276": {"epss_score": 0.00075, "epss_percentile": 0.22886}, "CVE-2021-22277": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2021-22278": {"epss_score": 0.00018, "epss_percentile": 0.04046}, "CVE-2021-22279": {"epss_score": 0.0031, "epss_percentile": 0.53744}, "CVE-2021-22280": {"epss_score": 0.00076, "epss_percentile": 0.23182}, "CVE-2021-22281": {"epss_score": 0.00122, "epss_percentile": 0.32034}, "CVE-2021-22282": {"epss_score": 0.00168, "epss_percentile": 0.38476}, "CVE-2021-22283": {"epss_score": 0.00078, "epss_percentile": 0.23757}, "CVE-2021-22284": {"epss_score": 0.00345, "epss_percentile": 0.56577}, "CVE-2021-22285": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2021-22286": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2021-22288": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2021-22289": {"epss_score": 0.00715, "epss_percentile": 0.71833}, "CVE-2021-22291": {"epss_score": 0.00056, "epss_percentile": 0.1774}, "CVE-2021-22292": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-22293": {"epss_score": 0.00131, "epss_percentile": 0.3337}, "CVE-2021-22294": {"epss_score": 0.00022, "epss_percentile": 0.05282}, "CVE-2021-22295": {"epss_score": 0.00018, "epss_percentile": 0.03853}, "CVE-2021-22296": {"epss_score": 0.00067, "epss_percentile": 0.21163}, "CVE-2021-22298": {"epss_score": 0.00185, "epss_percentile": 0.40485}, "CVE-2021-22299": {"epss_score": 0.00024, "epss_percentile": 0.05854}, "CVE-2021-22300": {"epss_score": 0.00013, "epss_percentile": 0.01544}, "CVE-2021-22301": {"epss_score": 0.00033, "epss_percentile": 0.09232}, "CVE-2021-22302": {"epss_score": 0.00027, "epss_percentile": 0.06914}, "CVE-2021-22303": {"epss_score": 0.00083, "epss_percentile": 0.24719}, "CVE-2021-22304": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2021-22305": {"epss_score": 0.00027, "epss_percentile": 0.0693}, "CVE-2021-22306": {"epss_score": 0.00025, "epss_percentile": 0.06213}, "CVE-2021-22307": {"epss_score": 0.00023, "epss_percentile": 0.05464}, "CVE-2021-22308": {"epss_score": 0.00025, "epss_percentile": 0.06352}, "CVE-2021-22309": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-22310": {"epss_score": 0.00027, "epss_percentile": 0.06945}, "CVE-2021-22311": {"epss_score": 0.00146, "epss_percentile": 0.35633}, "CVE-2021-22312": {"epss_score": 0.00186, "epss_percentile": 0.4065}, "CVE-2021-22313": {"epss_score": 0.00136, "epss_percentile": 0.34107}, "CVE-2021-22314": {"epss_score": 0.00024, "epss_percentile": 0.05854}, "CVE-2021-22316": {"epss_score": 0.00024, "epss_percentile": 0.06022}, "CVE-2021-22317": {"epss_score": 0.00136, "epss_percentile": 0.34107}, "CVE-2021-22318": {"epss_score": 0.0002, "epss_percentile": 0.04636}, "CVE-2021-22319": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2021-22320": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22321": {"epss_score": 0.00207, "epss_percentile": 0.43158}, "CVE-2021-22322": {"epss_score": 0.00106, "epss_percentile": 0.29401}, "CVE-2021-22323": {"epss_score": 0.00207, "epss_percentile": 0.43126}, "CVE-2021-22324": {"epss_score": 0.00136, "epss_percentile": 0.34107}, "CVE-2021-22325": {"epss_score": 0.00071, "epss_percentile": 0.22228}, "CVE-2021-22326": {"epss_score": 0.00026, "epss_percentile": 0.06614}, "CVE-2021-22327": {"epss_score": 0.00162, "epss_percentile": 0.37647}, "CVE-2021-22328": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22329": {"epss_score": 0.00088, "epss_percentile": 0.25723}, "CVE-2021-22330": {"epss_score": 0.00037, "epss_percentile": 0.10664}, "CVE-2021-22331": {"epss_score": 0.00206, "epss_percentile": 0.4304}, "CVE-2021-22332": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22333": {"epss_score": 0.00182, "epss_percentile": 0.40253}, "CVE-2021-22334": {"epss_score": 0.00032, "epss_percentile": 0.09036}, "CVE-2021-22335": {"epss_score": 0.00027, "epss_percentile": 0.06914}, "CVE-2021-22336": {"epss_score": 0.00206, "epss_percentile": 0.4304}, "CVE-2021-22337": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2021-22338": {"epss_score": 0.00151, "epss_percentile": 0.36261}, "CVE-2021-22339": {"epss_score": 0.00066, "epss_percentile": 0.20803}, "CVE-2021-22340": {"epss_score": 0.00016, "epss_percentile": 0.02857}, "CVE-2021-22341": {"epss_score": 0.00157, "epss_percentile": 0.37141}, "CVE-2021-22342": {"epss_score": 0.00138, "epss_percentile": 0.3451}, "CVE-2021-22343": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22344": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2021-22345": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-22346": {"epss_score": 0.00085, "epss_percentile": 0.25226}, "CVE-2021-22347": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2021-22348": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-22349": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-22350": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-22351": {"epss_score": 0.00153, "epss_percentile": 0.36617}, "CVE-2021-22352": {"epss_score": 0.00101, "epss_percentile": 0.28695}, "CVE-2021-22353": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-22354": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-22356": {"epss_score": 0.0007, "epss_percentile": 0.2194}, "CVE-2021-22357": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22358": {"epss_score": 0.00169, "epss_percentile": 0.3856}, "CVE-2021-22359": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-22360": {"epss_score": 0.00147, "epss_percentile": 0.35669}, "CVE-2021-22361": {"epss_score": 0.00027, "epss_percentile": 0.06914}, "CVE-2021-22362": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2021-22363": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22364": {"epss_score": 0.00024, "epss_percentile": 0.05726}, "CVE-2021-22365": {"epss_score": 0.00023, "epss_percentile": 0.05402}, "CVE-2021-22366": {"epss_score": 0.00021, "epss_percentile": 0.04924}, "CVE-2021-22367": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2021-22368": {"epss_score": 0.00155, "epss_percentile": 0.36862}, "CVE-2021-22369": {"epss_score": 0.0016, "epss_percentile": 0.37473}, "CVE-2021-22370": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-22371": {"epss_score": 0.00116, "epss_percentile": 0.31153}, "CVE-2021-22372": {"epss_score": 0.00136, "epss_percentile": 0.34107}, "CVE-2021-22373": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22374": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22375": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-22376": {"epss_score": 0.00018, "epss_percentile": 0.03527}, "CVE-2021-22377": {"epss_score": 0.00709, "epss_percentile": 0.71699}, "CVE-2021-22378": {"epss_score": 0.00135, "epss_percentile": 0.33945}, "CVE-2021-22379": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22380": {"epss_score": 0.0011, "epss_percentile": 0.30171}, "CVE-2021-22381": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22382": {"epss_score": 0.00022, "epss_percentile": 0.05199}, "CVE-2021-22383": {"epss_score": 0.00149, "epss_percentile": 0.35953}, "CVE-2021-22384": {"epss_score": 0.00199, "epss_percentile": 0.42162}, "CVE-2021-22385": {"epss_score": 0.00019, "epss_percentile": 0.04415}, "CVE-2021-22386": {"epss_score": 0.00019, "epss_percentile": 0.04075}, "CVE-2021-22387": {"epss_score": 0.003, "epss_percentile": 0.52908}, "CVE-2021-22388": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-22389": {"epss_score": 0.00191, "epss_percentile": 0.41174}, "CVE-2021-22390": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-22391": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22392": {"epss_score": 0.00102, "epss_percentile": 0.28736}, "CVE-2021-22393": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22394": {"epss_score": 0.00267, "epss_percentile": 0.49967}, "CVE-2021-22395": {"epss_score": 0.00284, "epss_percentile": 0.51472}, "CVE-2021-22396": {"epss_score": 0.00021, "epss_percentile": 0.04723}, "CVE-2021-22397": {"epss_score": 0.00026, "epss_percentile": 0.06569}, "CVE-2021-22398": {"epss_score": 0.00024, "epss_percentile": 0.06005}, "CVE-2021-22399": {"epss_score": 0.00024, "epss_percentile": 0.05726}, "CVE-2021-22400": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2021-22401": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22402": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22403": {"epss_score": 0.00207, "epss_percentile": 0.43126}, "CVE-2021-22404": {"epss_score": 0.00067, "epss_percentile": 0.21138}, "CVE-2021-22405": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22406": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22407": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2021-22409": {"epss_score": 0.00174, "epss_percentile": 0.39177}, "CVE-2021-22410": {"epss_score": 0.00141, "epss_percentile": 0.34922}, "CVE-2021-22411": {"epss_score": 0.00174, "epss_percentile": 0.39177}, "CVE-2021-22412": {"epss_score": 0.00136, "epss_percentile": 0.34107}, "CVE-2021-22413": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22414": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22415": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22416": {"epss_score": 0.00018, "epss_percentile": 0.0372}, "CVE-2021-22417": {"epss_score": 0.00019, "epss_percentile": 0.04233}, "CVE-2021-22418": {"epss_score": 0.00019, "epss_percentile": 0.04075}, "CVE-2021-22419": {"epss_score": 9e-05, "epss_percentile": 0.0069}, "CVE-2021-22420": {"epss_score": 0.00019, "epss_percentile": 0.04075}, "CVE-2021-22421": {"epss_score": 0.00016, "epss_percentile": 0.02826}, "CVE-2021-22422": {"epss_score": 0.00019, "epss_percentile": 0.04075}, "CVE-2021-22423": {"epss_score": 0.00019, "epss_percentile": 0.04075}, "CVE-2021-22424": {"epss_score": 0.00019, "epss_percentile": 0.04233}, "CVE-2021-22425": {"epss_score": 0.00019, "epss_percentile": 0.04075}, "CVE-2021-22426": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2021-22427": {"epss_score": 0.00207, "epss_percentile": 0.43077}, "CVE-2021-22428": {"epss_score": 0.00199, "epss_percentile": 0.42162}, "CVE-2021-22429": {"epss_score": 0.0018, "epss_percentile": 0.39907}, "CVE-2021-22430": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2021-22431": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2021-22432": {"epss_score": 0.0018, "epss_percentile": 0.39907}, "CVE-2021-22433": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2021-22434": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2021-22435": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22436": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22437": {"epss_score": 0.00021, "epss_percentile": 0.04777}, "CVE-2021-22438": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-22439": {"epss_score": 0.00167, "epss_percentile": 0.38307}, "CVE-2021-22440": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2021-22441": {"epss_score": 0.00021, "epss_percentile": 0.04924}, "CVE-2021-22442": {"epss_score": 0.00069, "epss_percentile": 0.215}, "CVE-2021-22443": {"epss_score": 0.00136, "epss_percentile": 0.34107}, "CVE-2021-22444": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-22445": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-22446": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-22447": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-22448": {"epss_score": 0.00146, "epss_percentile": 0.35607}, "CVE-2021-22449": {"epss_score": 0.00179, "epss_percentile": 0.39808}, "CVE-2021-22450": {"epss_score": 0.00019, "epss_percentile": 0.04233}, "CVE-2021-22451": {"epss_score": 0.00024, "epss_percentile": 0.05854}, "CVE-2021-22452": {"epss_score": 0.00025, "epss_percentile": 0.06237}, "CVE-2021-22453": {"epss_score": 0.00023, "epss_percentile": 0.05402}, "CVE-2021-22454": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2021-22455": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2021-22456": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2021-22457": {"epss_score": 0.00023, "epss_percentile": 0.05402}, "CVE-2021-22458": {"epss_score": 0.00025, "epss_percentile": 0.06296}, "CVE-2021-22459": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2021-22460": {"epss_score": 0.00011, "epss_percentile": 0.01022}, "CVE-2021-22461": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2021-22462": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2021-22463": {"epss_score": 0.00029, "epss_percentile": 0.07906}, "CVE-2021-22464": {"epss_score": 0.00024, "epss_percentile": 0.05814}, "CVE-2021-22465": {"epss_score": 0.00022, "epss_percentile": 0.05264}, "CVE-2021-22466": {"epss_score": 0.00024, "epss_percentile": 0.0566}, "CVE-2021-22467": {"epss_score": 0.00025, "epss_percentile": 0.06237}, "CVE-2021-22468": {"epss_score": 0.00023, "epss_percentile": 0.05351}, "CVE-2021-22469": {"epss_score": 0.00024, "epss_percentile": 0.05854}, "CVE-2021-22470": {"epss_score": 0.00024, "epss_percentile": 0.05854}, "CVE-2021-22471": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2021-22472": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-22473": {"epss_score": 0.00117, "epss_percentile": 0.31301}, "CVE-2021-22474": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-22475": {"epss_score": 0.00095, "epss_percentile": 0.27114}, "CVE-2021-22478": {"epss_score": 0.00028, "epss_percentile": 0.07471}, "CVE-2021-22479": {"epss_score": 0.00021, "epss_percentile": 0.04924}, "CVE-2021-22480": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-22481": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-22482": {"epss_score": 0.00113, "epss_percentile": 0.30629}, "CVE-2021-22483": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22484": {"epss_score": 0.00142, "epss_percentile": 0.3504}, "CVE-2021-22485": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-22486": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-22487": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22488": {"epss_score": 0.00158, "epss_percentile": 0.37291}, "CVE-2021-22489": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2021-22490": {"epss_score": 0.00151, "epss_percentile": 0.36261}, "CVE-2021-22491": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-22492": {"epss_score": 0.0004, "epss_percentile": 0.12013}, "CVE-2021-22494": {"epss_score": 0.0005, "epss_percentile": 0.15847}, "CVE-2021-22495": {"epss_score": 0.00053, "epss_percentile": 0.1669}, "CVE-2021-22496": {"epss_score": 0.00279, "epss_percentile": 0.50996}, "CVE-2021-22497": {"epss_score": 0.00229, "epss_percentile": 0.45661}, "CVE-2021-22498": {"epss_score": 0.00324, "epss_percentile": 0.54945}, "CVE-2021-22499": {"epss_score": 0.00207, "epss_percentile": 0.43195}, "CVE-2021-22500": {"epss_score": 0.00117, "epss_percentile": 0.31326}, "CVE-2021-22501": {"epss_score": 0.00155, "epss_percentile": 0.36847}, "CVE-2021-22502": {"epss_score": 0.93981, "epss_percentile": 0.99879}, "CVE-2021-22503": {"epss_score": 0.00151, "epss_percentile": 0.36341}, "CVE-2021-22504": {"epss_score": 0.03018, "epss_percentile": 0.86219}, "CVE-2021-22505": {"epss_score": 0.00884, "epss_percentile": 0.74923}, "CVE-2021-22506": {"epss_score": 0.10545, "epss_percentile": 0.93023}, "CVE-2021-22507": {"epss_score": 0.00849, "epss_percentile": 0.74378}, "CVE-2021-22508": {"epss_score": 0.00204, "epss_percentile": 0.42662}, "CVE-2021-22509": {"epss_score": 0.00071, "epss_percentile": 0.22087}, "CVE-2021-22510": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-22511": {"epss_score": 0.00091, "epss_percentile": 0.26409}, "CVE-2021-22512": {"epss_score": 0.00117, "epss_percentile": 0.31326}, "CVE-2021-22513": {"epss_score": 0.00139, "epss_percentile": 0.34564}, "CVE-2021-22514": {"epss_score": 0.01778, "epss_percentile": 0.82227}, "CVE-2021-22515": {"epss_score": 0.00194, "epss_percentile": 0.41561}, "CVE-2021-22516": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-22517": {"epss_score": 0.00504, "epss_percentile": 0.6555}, "CVE-2021-22518": {"epss_score": 0.00034, "epss_percentile": 0.09469}, "CVE-2021-22519": {"epss_score": 0.01778, "epss_percentile": 0.82227}, "CVE-2021-22521": {"epss_score": 0.00038, "epss_percentile": 0.11157}, "CVE-2021-22522": {"epss_score": 0.00241, "epss_percentile": 0.4733}, "CVE-2021-22523": {"epss_score": 0.00343, "epss_percentile": 0.56457}, "CVE-2021-22524": {"epss_score": 0.00198, "epss_percentile": 0.41976}, "CVE-2021-22525": {"epss_score": 0.00052, "epss_percentile": 0.16634}, "CVE-2021-22526": {"epss_score": 0.00144, "epss_percentile": 0.3529}, "CVE-2021-22527": {"epss_score": 0.00225, "epss_percentile": 0.45228}, "CVE-2021-22528": {"epss_score": 0.00355, "epss_percentile": 0.57275}, "CVE-2021-22529": {"epss_score": 0.00039, "epss_percentile": 0.11801}, "CVE-2021-22530": {"epss_score": 0.00068, "epss_percentile": 0.21425}, "CVE-2021-22531": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-22532": {"epss_score": 0.00398, "epss_percentile": 0.60089}, "CVE-2021-22533": {"epss_score": 0.00098, "epss_percentile": 0.27817}, "CVE-2021-22535": {"epss_score": 0.00231, "epss_percentile": 0.45767}, "CVE-2021-22538": {"epss_score": 0.00237, "epss_percentile": 0.46736}, "CVE-2021-22539": {"epss_score": 0.00063, "epss_percentile": 0.19854}, "CVE-2021-22540": {"epss_score": 0.00356, "epss_percentile": 0.5737}, "CVE-2021-22543": {"epss_score": 5e-05, "epss_percentile": 0.00185}, "CVE-2021-22545": {"epss_score": 0.00059, "epss_percentile": 0.18661}, "CVE-2021-22547": {"epss_score": 0.00026, "epss_percentile": 0.0668}, "CVE-2021-22548": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2021-22549": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2021-22550": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2021-22552": {"epss_score": 0.00019, "epss_percentile": 0.04165}, "CVE-2021-22553": {"epss_score": 0.00091, "epss_percentile": 0.26242}, "CVE-2021-22555": {"epss_score": 0.85339, "epss_percentile": 0.9933}, "CVE-2021-22556": {"epss_score": 0.00016, "epss_percentile": 0.02622}, "CVE-2021-22557": {"epss_score": 0.00537, "epss_percentile": 0.66922}, "CVE-2021-22563": {"epss_score": 0.00045, "epss_percentile": 0.13909}, "CVE-2021-22564": {"epss_score": 0.00043, "epss_percentile": 0.13103}, "CVE-2021-22565": {"epss_score": 0.00121, "epss_percentile": 0.31997}, "CVE-2021-22566": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2021-22567": {"epss_score": 0.00141, "epss_percentile": 0.34929}, "CVE-2021-22568": {"epss_score": 0.0044, "epss_percentile": 0.6261}, "CVE-2021-22569": {"epss_score": 0.00291, "epss_percentile": 0.52171}, "CVE-2021-22570": {"epss_score": 0.0015, "epss_percentile": 0.36084}, "CVE-2021-22571": {"epss_score": 0.00029, "epss_percentile": 0.07728}, "CVE-2021-22572": {"epss_score": 0.00013, "epss_percentile": 0.01511}, "CVE-2021-22573": {"epss_score": 0.00055, "epss_percentile": 0.17586}, "CVE-2021-22600": {"epss_score": 0.00153, "epss_percentile": 0.36643}, "CVE-2021-22636": {"epss_score": 0.00042, "epss_percentile": 0.12633}, "CVE-2021-22637": {"epss_score": 0.00365, "epss_percentile": 0.58006}, "CVE-2021-22638": {"epss_score": 0.00167, "epss_percentile": 0.38292}, "CVE-2021-22639": {"epss_score": 0.00193, "epss_percentile": 0.41385}, "CVE-2021-22640": {"epss_score": 0.00227, "epss_percentile": 0.45434}, "CVE-2021-22641": {"epss_score": 0.00483, "epss_percentile": 0.6457}, "CVE-2021-22642": {"epss_score": 0.00249, "epss_percentile": 0.48049}, "CVE-2021-22643": {"epss_score": 0.00352, "epss_percentile": 0.57098}, "CVE-2021-22644": {"epss_score": 0.00227, "epss_percentile": 0.45434}, "CVE-2021-22645": {"epss_score": 0.00252, "epss_percentile": 0.48353}, "CVE-2021-22646": {"epss_score": 0.00943, "epss_percentile": 0.75769}, "CVE-2021-22647": {"epss_score": 0.00368, "epss_percentile": 0.58169}, "CVE-2021-22648": {"epss_score": 0.00234, "epss_percentile": 0.4612}, "CVE-2021-22649": {"epss_score": 0.0033, "epss_percentile": 0.55498}, "CVE-2021-22650": {"epss_score": 0.00701, "epss_percentile": 0.71502}, "CVE-2021-22651": {"epss_score": 0.01711, "epss_percentile": 0.81882}, "CVE-2021-22652": {"epss_score": 0.4086, "epss_percentile": 0.97241}, "CVE-2021-22653": {"epss_score": 0.00302, "epss_percentile": 0.53099}, "CVE-2021-22654": {"epss_score": 0.00422, "epss_percentile": 0.6157}, "CVE-2021-22655": {"epss_score": 0.00302, "epss_percentile": 0.53099}, "CVE-2021-22656": {"epss_score": 0.01855, "epss_percentile": 0.82558}, "CVE-2021-22657": {"epss_score": 0.00403, "epss_percentile": 0.60327}, "CVE-2021-22658": {"epss_score": 0.00325, "epss_percentile": 0.55007}, "CVE-2021-22659": {"epss_score": 0.00574, "epss_percentile": 0.68086}, "CVE-2021-22660": {"epss_score": 0.00352, "epss_percentile": 0.57098}, "CVE-2021-22661": {"epss_score": 0.00159, "epss_percentile": 0.37418}, "CVE-2021-22662": {"epss_score": 0.00235, "epss_percentile": 0.462}, "CVE-2021-22663": {"epss_score": 0.00407, "epss_percentile": 0.60583}, "CVE-2021-22664": {"epss_score": 0.00205, "epss_percentile": 0.42721}, "CVE-2021-22665": {"epss_score": 4e-05, "epss_percentile": 0.00152}, "CVE-2021-22666": {"epss_score": 0.00268, "epss_percentile": 0.50077}, "CVE-2021-22667": {"epss_score": 0.00596, "epss_percentile": 0.68733}, "CVE-2021-22668": {"epss_score": 0.007, "epss_percentile": 0.71471}, "CVE-2021-22669": {"epss_score": 0.00169, "epss_percentile": 0.38637}, "CVE-2021-22670": {"epss_score": 0.00167, "epss_percentile": 0.38292}, "CVE-2021-22671": {"epss_score": 0.00695, "epss_percentile": 0.71368}, "CVE-2021-22672": {"epss_score": 0.003, "epss_percentile": 0.52973}, "CVE-2021-22673": {"epss_score": 0.0074, "epss_percentile": 0.72402}, "CVE-2021-22674": {"epss_score": 0.00312, "epss_percentile": 0.53958}, "CVE-2021-22675": {"epss_score": 0.00772, "epss_percentile": 0.73046}, "CVE-2021-22676": {"epss_score": 0.00188, "epss_percentile": 0.40898}, "CVE-2021-22677": {"epss_score": 0.00061, "epss_percentile": 0.19545}, "CVE-2021-22678": {"epss_score": 0.00407, "epss_percentile": 0.60583}, "CVE-2021-22679": {"epss_score": 0.00695, "epss_percentile": 0.71368}, "CVE-2021-22680": {"epss_score": 0.01845, "epss_percentile": 0.82507}, "CVE-2021-22681": {"epss_score": 0.00182, "epss_percentile": 0.40239}, "CVE-2021-22682": {"epss_score": 0.00033, "epss_percentile": 0.09251}, "CVE-2021-22683": {"epss_score": 0.00177, "epss_percentile": 0.39614}, "CVE-2021-22684": {"epss_score": 0.00335, "epss_percentile": 0.55805}, "CVE-2021-22685": {"epss_score": 0.00149, "epss_percentile": 0.36006}, "CVE-2021-22696": {"epss_score": 0.01971, "epss_percentile": 0.83097}, "CVE-2021-22697": {"epss_score": 0.0071, "epss_percentile": 0.7171}, "CVE-2021-22698": {"epss_score": 0.01384, "epss_percentile": 0.79901}, "CVE-2021-22699": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2021-22701": {"epss_score": 0.00152, "epss_percentile": 0.36448}, "CVE-2021-22702": {"epss_score": 0.00195, "epss_percentile": 0.41625}, "CVE-2021-22703": {"epss_score": 0.00216, "epss_percentile": 0.44187}, "CVE-2021-22704": {"epss_score": 0.00601, "epss_percentile": 0.68844}, "CVE-2021-22705": {"epss_score": 0.00058, "epss_percentile": 0.18549}, "CVE-2021-22706": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2021-22707": {"epss_score": 0.91573, "epss_percentile": 0.99652}, "CVE-2021-22708": {"epss_score": 0.00245, "epss_percentile": 0.47678}, "CVE-2021-22709": {"epss_score": 0.007, "epss_percentile": 0.71467}, "CVE-2021-22710": {"epss_score": 0.007, "epss_percentile": 0.71467}, "CVE-2021-22711": {"epss_score": 0.00127, "epss_percentile": 0.32785}, "CVE-2021-22712": {"epss_score": 0.00127, "epss_percentile": 0.32785}, "CVE-2021-22713": {"epss_score": 0.00922, "epss_percentile": 0.7549}, "CVE-2021-22714": {"epss_score": 0.02269, "epss_percentile": 0.84203}, "CVE-2021-22716": {"epss_score": 0.00192, "epss_percentile": 0.41281}, "CVE-2021-22717": {"epss_score": 0.11594, "epss_percentile": 0.93414}, "CVE-2021-22718": {"epss_score": 0.03764, "epss_percentile": 0.87691}, "CVE-2021-22719": {"epss_score": 0.13604, "epss_percentile": 0.94008}, "CVE-2021-22720": {"epss_score": 0.07827, "epss_percentile": 0.91702}, "CVE-2021-22721": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2021-22722": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-22723": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-22724": {"epss_score": 0.00142, "epss_percentile": 0.34977}, "CVE-2021-22725": {"epss_score": 0.00142, "epss_percentile": 0.34977}, "CVE-2021-22726": {"epss_score": 0.00188, "epss_percentile": 0.40858}, "CVE-2021-22727": {"epss_score": 0.006, "epss_percentile": 0.68832}, "CVE-2021-22728": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2021-22729": {"epss_score": 0.00346, "epss_percentile": 0.56706}, "CVE-2021-22730": {"epss_score": 0.00346, "epss_percentile": 0.56706}, "CVE-2021-22731": {"epss_score": 0.02006, "epss_percentile": 0.83235}, "CVE-2021-22732": {"epss_score": 0.00047, "epss_percentile": 0.14697}, "CVE-2021-22733": {"epss_score": 0.00118, "epss_percentile": 0.31421}, "CVE-2021-22734": {"epss_score": 0.00845, "epss_percentile": 0.74283}, "CVE-2021-22735": {"epss_score": 0.00845, "epss_percentile": 0.74283}, "CVE-2021-22736": {"epss_score": 0.00391, "epss_percentile": 0.59625}, "CVE-2021-22737": {"epss_score": 0.00304, "epss_percentile": 0.53248}, "CVE-2021-22738": {"epss_score": 0.00184, "epss_percentile": 0.40408}, "CVE-2021-22739": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-22740": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2021-22741": {"epss_score": 0.00026, "epss_percentile": 0.06567}, "CVE-2021-22742": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2021-22743": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2021-22744": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2021-22745": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2021-22746": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2021-22747": {"epss_score": 0.00055, "epss_percentile": 0.17513}, "CVE-2021-22748": {"epss_score": 0.038, "epss_percentile": 0.87743}, "CVE-2021-22749": {"epss_score": 0.00356, "epss_percentile": 0.57364}, "CVE-2021-22750": {"epss_score": 0.00434, "epss_percentile": 0.62285}, "CVE-2021-22751": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2021-22752": {"epss_score": 0.00434, "epss_percentile": 0.62285}, "CVE-2021-22753": {"epss_score": 0.00434, "epss_percentile": 0.62285}, "CVE-2021-22754": {"epss_score": 0.00434, "epss_percentile": 0.62285}, "CVE-2021-22755": {"epss_score": 0.00493, "epss_percentile": 0.6506}, "CVE-2021-22756": {"epss_score": 0.00434, "epss_percentile": 0.62285}, "CVE-2021-22757": {"epss_score": 0.00493, "epss_percentile": 0.6506}, "CVE-2021-22758": {"epss_score": 0.00434, "epss_percentile": 0.62285}, "CVE-2021-22759": {"epss_score": 0.00509, "epss_percentile": 0.6573}, "CVE-2021-22760": {"epss_score": 0.00434, "epss_percentile": 0.62285}, "CVE-2021-22761": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2021-22762": {"epss_score": 0.00611, "epss_percentile": 0.69191}, "CVE-2021-22763": {"epss_score": 0.00342, "epss_percentile": 0.56364}, "CVE-2021-22764": {"epss_score": 0.00123, "epss_percentile": 0.32235}, "CVE-2021-22765": {"epss_score": 0.0061, "epss_percentile": 0.69158}, "CVE-2021-22766": {"epss_score": 0.01077, "epss_percentile": 0.7733}, "CVE-2021-22767": {"epss_score": 0.00589, "epss_percentile": 0.68515}, "CVE-2021-22768": {"epss_score": 0.00589, "epss_percentile": 0.68515}, "CVE-2021-22769": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2021-22770": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2021-22771": {"epss_score": 0.00259, "epss_percentile": 0.49078}, "CVE-2021-22772": {"epss_score": 0.00208, "epss_percentile": 0.43237}, "CVE-2021-22773": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2021-22774": {"epss_score": 0.00136, "epss_percentile": 0.34097}, "CVE-2021-22775": {"epss_score": 0.00066, "epss_percentile": 0.20849}, "CVE-2021-22777": {"epss_score": 0.00357, "epss_percentile": 0.57466}, "CVE-2021-22778": {"epss_score": 0.00045, "epss_percentile": 0.13813}, "CVE-2021-22779": {"epss_score": 0.00192, "epss_percentile": 0.41308}, "CVE-2021-22780": {"epss_score": 0.00054, "epss_percentile": 0.17049}, "CVE-2021-22781": {"epss_score": 0.00052, "epss_percentile": 0.1647}, "CVE-2021-22782": {"epss_score": 0.00016, "epss_percentile": 0.02924}, "CVE-2021-22783": {"epss_score": 0.00093, "epss_percentile": 0.2663}, "CVE-2021-22784": {"epss_score": 0.01426, "epss_percentile": 0.80202}, "CVE-2021-22785": {"epss_score": 0.00402, "epss_percentile": 0.60289}, "CVE-2021-22786": {"epss_score": 0.00234, "epss_percentile": 0.46106}, "CVE-2021-22787": {"epss_score": 0.00431, "epss_percentile": 0.62054}, "CVE-2021-22788": {"epss_score": 0.01449, "epss_percentile": 0.80344}, "CVE-2021-22789": {"epss_score": 0.00437, "epss_percentile": 0.62525}, "CVE-2021-22790": {"epss_score": 0.00437, "epss_percentile": 0.62525}, "CVE-2021-22791": {"epss_score": 0.00437, "epss_percentile": 0.62525}, "CVE-2021-22792": {"epss_score": 0.00458, "epss_percentile": 0.63427}, "CVE-2021-22793": {"epss_score": 0.00544, "epss_percentile": 0.67152}, "CVE-2021-22794": {"epss_score": 0.03731, "epss_percentile": 0.87644}, "CVE-2021-22795": {"epss_score": 0.03191, "epss_percentile": 0.86601}, "CVE-2021-22796": {"epss_score": 0.00632, "epss_percentile": 0.69744}, "CVE-2021-22797": {"epss_score": 0.00813, "epss_percentile": 0.7376}, "CVE-2021-22798": {"epss_score": 0.00291, "epss_percentile": 0.52197}, "CVE-2021-22799": {"epss_score": 0.00054, "epss_percentile": 0.17226}, "CVE-2021-22800": {"epss_score": 0.00444, "epss_percentile": 0.62829}, "CVE-2021-22801": {"epss_score": 0.00845, "epss_percentile": 0.74287}, "CVE-2021-22802": {"epss_score": 0.02468, "epss_percentile": 0.84838}, "CVE-2021-22803": {"epss_score": 0.02027, "epss_percentile": 0.83321}, "CVE-2021-22804": {"epss_score": 0.0049, "epss_percentile": 0.64939}, "CVE-2021-22805": {"epss_score": 0.00232, "epss_percentile": 0.45969}, "CVE-2021-22806": {"epss_score": 0.00385, "epss_percentile": 0.59184}, "CVE-2021-22807": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2021-22808": {"epss_score": 0.00515, "epss_percentile": 0.65975}, "CVE-2021-22809": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2021-22810": {"epss_score": 0.00815, "epss_percentile": 0.7379}, "CVE-2021-22811": {"epss_score": 0.00815, "epss_percentile": 0.7379}, "CVE-2021-22812": {"epss_score": 0.00815, "epss_percentile": 0.7379}, "CVE-2021-22813": {"epss_score": 0.00815, "epss_percentile": 0.7379}, "CVE-2021-22814": {"epss_score": 0.00815, "epss_percentile": 0.7379}, "CVE-2021-22815": {"epss_score": 0.0025, "epss_percentile": 0.48146}, "CVE-2021-22816": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2021-22817": {"epss_score": 0.0004, "epss_percentile": 0.1188}, "CVE-2021-22818": {"epss_score": 0.00251, "epss_percentile": 0.48273}, "CVE-2021-22819": {"epss_score": 0.00206, "epss_percentile": 0.43072}, "CVE-2021-22820": {"epss_score": 0.00571, "epss_percentile": 0.67997}, "CVE-2021-22821": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2021-22822": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2021-22823": {"epss_score": 0.0032, "epss_percentile": 0.54573}, "CVE-2021-22824": {"epss_score": 0.03281, "epss_percentile": 0.86816}, "CVE-2021-22825": {"epss_score": 0.00379, "epss_percentile": 0.58886}, "CVE-2021-22826": {"epss_score": 0.00724, "epss_percentile": 0.72032}, "CVE-2021-22827": {"epss_score": 0.00724, "epss_percentile": 0.72032}, "CVE-2021-22847": {"epss_score": 0.01172, "epss_percentile": 0.78228}, "CVE-2021-22848": {"epss_score": 0.00444, "epss_percentile": 0.62837}, "CVE-2021-22849": {"epss_score": 0.00172, "epss_percentile": 0.38906}, "CVE-2021-22850": {"epss_score": 0.00291, "epss_percentile": 0.52181}, "CVE-2021-22851": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-22852": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2021-22853": {"epss_score": 0.00265, "epss_percentile": 0.49799}, "CVE-2021-22854": {"epss_score": 0.00387, "epss_percentile": 0.59334}, "CVE-2021-22855": {"epss_score": 0.0078, "epss_percentile": 0.7317}, "CVE-2021-22856": {"epss_score": 0.00313, "epss_percentile": 0.54052}, "CVE-2021-22857": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2021-22858": {"epss_score": 0.00266, "epss_percentile": 0.49865}, "CVE-2021-22859": {"epss_score": 0.01696, "epss_percentile": 0.81814}, "CVE-2021-22860": {"epss_score": 0.00914, "epss_percentile": 0.75388}, "CVE-2021-22861": {"epss_score": 0.00465, "epss_percentile": 0.63761}, "CVE-2021-22862": {"epss_score": 0.0015, "epss_percentile": 0.36152}, "CVE-2021-22863": {"epss_score": 0.00465, "epss_percentile": 0.63779}, "CVE-2021-22864": {"epss_score": 0.02496, "epss_percentile": 0.84908}, "CVE-2021-22865": {"epss_score": 0.00226, "epss_percentile": 0.45297}, "CVE-2021-22866": {"epss_score": 0.00203, "epss_percentile": 0.42547}, "CVE-2021-22867": {"epss_score": 0.00457, "epss_percentile": 0.63361}, "CVE-2021-22868": {"epss_score": 0.00284, "epss_percentile": 0.51431}, "CVE-2021-22869": {"epss_score": 0.00404, "epss_percentile": 0.60414}, "CVE-2021-22870": {"epss_score": 0.00457, "epss_percentile": 0.63361}, "CVE-2021-22871": {"epss_score": 0.0094, "epss_percentile": 0.75743}, "CVE-2021-22872": {"epss_score": 0.02138, "epss_percentile": 0.83735}, "CVE-2021-22873": {"epss_score": 0.71647, "epss_percentile": 0.98676}, "CVE-2021-22874": {"epss_score": 0.00775, "epss_percentile": 0.7308}, "CVE-2021-22875": {"epss_score": 0.00775, "epss_percentile": 0.7308}, "CVE-2021-22876": {"epss_score": 0.00068, "epss_percentile": 0.21288}, "CVE-2021-22877": {"epss_score": 0.00279, "epss_percentile": 0.50984}, "CVE-2021-22878": {"epss_score": 0.00368, "epss_percentile": 0.58191}, "CVE-2021-22879": {"epss_score": 0.01853, "epss_percentile": 0.82549}, "CVE-2021-22880": {"epss_score": 0.05881, "epss_percentile": 0.90291}, "CVE-2021-22881": {"epss_score": 0.09022, "epss_percentile": 0.9237}, "CVE-2021-22882": {"epss_score": 0.00589, "epss_percentile": 0.68538}, "CVE-2021-22883": {"epss_score": 0.91125, "epss_percentile": 0.99621}, "CVE-2021-22884": {"epss_score": 0.00503, "epss_percentile": 0.65469}, "CVE-2021-22885": {"epss_score": 0.02303, "epss_percentile": 0.84316}, "CVE-2021-22886": {"epss_score": 0.00752, "epss_percentile": 0.7265}, "CVE-2021-22887": {"epss_score": 0.0006, "epss_percentile": 0.19151}, "CVE-2021-22888": {"epss_score": 0.009, "epss_percentile": 0.75161}, "CVE-2021-22889": {"epss_score": 0.009, "epss_percentile": 0.75161}, "CVE-2021-22890": {"epss_score": 0.00125, "epss_percentile": 0.32503}, "CVE-2021-22891": {"epss_score": 0.00507, "epss_percentile": 0.65662}, "CVE-2021-22892": {"epss_score": 0.01357, "epss_percentile": 0.79719}, "CVE-2021-22893": {"epss_score": 0.93378, "epss_percentile": 0.99801}, "CVE-2021-22894": {"epss_score": 0.5062, "epss_percentile": 0.97742}, "CVE-2021-22895": {"epss_score": 0.00364, "epss_percentile": 0.57904}, "CVE-2021-22896": {"epss_score": 0.00409, "epss_percentile": 0.60723}, "CVE-2021-22897": {"epss_score": 0.01124, "epss_percentile": 0.77793}, "CVE-2021-22898": {"epss_score": 0.00126, "epss_percentile": 0.32628}, "CVE-2021-22899": {"epss_score": 0.37999, "epss_percentile": 0.97081}, "CVE-2021-22900": {"epss_score": 0.01642, "epss_percentile": 0.8151}, "CVE-2021-22901": {"epss_score": 0.00344, "epss_percentile": 0.56517}, "CVE-2021-22902": {"epss_score": 0.01063, "epss_percentile": 0.77188}, "CVE-2021-22903": {"epss_score": 0.00151, "epss_percentile": 0.3634}, "CVE-2021-22904": {"epss_score": 0.08198, "epss_percentile": 0.91926}, "CVE-2021-22905": {"epss_score": 0.00352, "epss_percentile": 0.57096}, "CVE-2021-22906": {"epss_score": 0.00189, "epss_percentile": 0.40925}, "CVE-2021-22907": {"epss_score": 0.00127, "epss_percentile": 0.32846}, "CVE-2021-22908": {"epss_score": 0.31772, "epss_percentile": 0.96647}, "CVE-2021-22909": {"epss_score": 0.00551, "epss_percentile": 0.67352}, "CVE-2021-22910": {"epss_score": 0.0099, "epss_percentile": 0.76377}, "CVE-2021-22911": {"epss_score": 0.92086, "epss_percentile": 0.99691}, "CVE-2021-22912": {"epss_score": 0.00652, "epss_percentile": 0.70311}, "CVE-2021-22913": {"epss_score": 0.00652, "epss_percentile": 0.70311}, "CVE-2021-22914": {"epss_score": 0.00324, "epss_percentile": 0.54971}, "CVE-2021-22915": {"epss_score": 0.00491, "epss_percentile": 0.64951}, "CVE-2021-22916": {"epss_score": 0.00128, "epss_percentile": 0.33049}, "CVE-2021-22917": {"epss_score": 0.00327, "epss_percentile": 0.55096}, "CVE-2021-22918": {"epss_score": 0.00718, "epss_percentile": 0.71933}, "CVE-2021-22919": {"epss_score": 0.00506, "epss_percentile": 0.65645}, "CVE-2021-22920": {"epss_score": 0.00262, "epss_percentile": 0.4933}, "CVE-2021-22921": {"epss_score": 0.00065, "epss_percentile": 0.20562}, "CVE-2021-22922": {"epss_score": 0.0018, "epss_percentile": 0.3988}, "CVE-2021-22923": {"epss_score": 0.00122, "epss_percentile": 0.32077}, "CVE-2021-22924": {"epss_score": 0.00746, "epss_percentile": 0.7255}, "CVE-2021-22925": {"epss_score": 0.00424, "epss_percentile": 0.61657}, "CVE-2021-22926": {"epss_score": 0.00657, "epss_percentile": 0.70459}, "CVE-2021-22927": {"epss_score": 0.00269, "epss_percentile": 0.50183}, "CVE-2021-22928": {"epss_score": 0.00052, "epss_percentile": 0.16379}, "CVE-2021-22929": {"epss_score": 0.00024, "epss_percentile": 0.05838}, "CVE-2021-22930": {"epss_score": 0.00347, "epss_percentile": 0.56735}, "CVE-2021-22931": {"epss_score": 0.00713, "epss_percentile": 0.7179}, "CVE-2021-22932": {"epss_score": 0.00081, "epss_percentile": 0.24394}, "CVE-2021-22933": {"epss_score": 0.06377, "epss_percentile": 0.90709}, "CVE-2021-22934": {"epss_score": 0.04682, "epss_percentile": 0.89}, "CVE-2021-22935": {"epss_score": 0.04289, "epss_percentile": 0.88499}, "CVE-2021-22936": {"epss_score": 0.00117, "epss_percentile": 0.31303}, "CVE-2021-22937": {"epss_score": 0.10252, "epss_percentile": 0.92913}, "CVE-2021-22938": {"epss_score": 0.04289, "epss_percentile": 0.88499}, "CVE-2021-22939": {"epss_score": 0.00133, "epss_percentile": 0.33729}, "CVE-2021-22940": {"epss_score": 0.00408, "epss_percentile": 0.60648}, "CVE-2021-22941": {"epss_score": 0.88492, "epss_percentile": 0.99475}, "CVE-2021-22942": {"epss_score": 0.0061, "epss_percentile": 0.69164}, "CVE-2021-22943": {"epss_score": 0.00116, "epss_percentile": 0.31105}, "CVE-2021-22944": {"epss_score": 0.0015, "epss_percentile": 0.36104}, "CVE-2021-22945": {"epss_score": 0.00353, "epss_percentile": 0.5719}, "CVE-2021-22946": {"epss_score": 0.00071, "epss_percentile": 0.22133}, "CVE-2021-22947": {"epss_score": 0.00188, "epss_percentile": 0.40863}, "CVE-2021-22948": {"epss_score": 0.00372, "epss_percentile": 0.58441}, "CVE-2021-22949": {"epss_score": 0.00094, "epss_percentile": 0.26984}, "CVE-2021-22950": {"epss_score": 0.00104, "epss_percentile": 0.29113}, "CVE-2021-22951": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2021-22952": {"epss_score": 0.005, "epss_percentile": 0.65322}, "CVE-2021-22953": {"epss_score": 0.00094, "epss_percentile": 0.26984}, "CVE-2021-22954": {"epss_score": 0.00149, "epss_percentile": 0.35937}, "CVE-2021-22955": {"epss_score": 0.00508, "epss_percentile": 0.65684}, "CVE-2021-22956": {"epss_score": 0.00506, "epss_percentile": 0.65645}, "CVE-2021-22957": {"epss_score": 0.00439, "epss_percentile": 0.626}, "CVE-2021-22958": {"epss_score": 0.00396, "epss_percentile": 0.59866}, "CVE-2021-22959": {"epss_score": 0.00212, "epss_percentile": 0.43788}, "CVE-2021-22960": {"epss_score": 0.00183, "epss_percentile": 0.40295}, "CVE-2021-22961": {"epss_score": 0.00956, "epss_percentile": 0.75923}, "CVE-2021-22962": {"epss_score": 0.27817, "epss_percentile": 0.96285}, "CVE-2021-22963": {"epss_score": 0.00172, "epss_percentile": 0.38905}, "CVE-2021-22964": {"epss_score": 0.00362, "epss_percentile": 0.57784}, "CVE-2021-22965": {"epss_score": 0.1362, "epss_percentile": 0.94016}, "CVE-2021-22966": {"epss_score": 0.00267, "epss_percentile": 0.49981}, "CVE-2021-22967": {"epss_score": 0.00747, "epss_percentile": 0.72568}, "CVE-2021-22968": {"epss_score": 0.0266, "epss_percentile": 0.85364}, "CVE-2021-22969": {"epss_score": 0.00268, "epss_percentile": 0.5008}, "CVE-2021-22970": {"epss_score": 0.00386, "epss_percentile": 0.59239}, "CVE-2021-22973": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-22974": {"epss_score": 0.00326, "epss_percentile": 0.55072}, "CVE-2021-22975": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-22976": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-22977": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-22978": {"epss_score": 0.00822, "epss_percentile": 0.73913}, "CVE-2021-22979": {"epss_score": 0.00316, "epss_percentile": 0.54292}, "CVE-2021-22980": {"epss_score": 0.00078, "epss_percentile": 0.23587}, "CVE-2021-22981": {"epss_score": 0.0023, "epss_percentile": 0.45687}, "CVE-2021-22982": {"epss_score": 0.00434, "epss_percentile": 0.62292}, "CVE-2021-22983": {"epss_score": 0.00223, "epss_percentile": 0.44879}, "CVE-2021-22984": {"epss_score": 0.00197, "epss_percentile": 0.41903}, "CVE-2021-22985": {"epss_score": 0.00612, "epss_percentile": 0.69234}, "CVE-2021-22986": {"epss_score": 0.94485, "epss_percentile": 0.99998}, "CVE-2021-22987": {"epss_score": 0.01769, "epss_percentile": 0.82185}, "CVE-2021-22988": {"epss_score": 0.02384, "epss_percentile": 0.84575}, "CVE-2021-22989": {"epss_score": 0.01365, "epss_percentile": 0.79775}, "CVE-2021-22990": {"epss_score": 0.01843, "epss_percentile": 0.82503}, "CVE-2021-22991": {"epss_score": 0.6626, "epss_percentile": 0.98457}, "CVE-2021-22992": {"epss_score": 0.07778, "epss_percentile": 0.91677}, "CVE-2021-22993": {"epss_score": 0.00822, "epss_percentile": 0.73913}, "CVE-2021-22994": {"epss_score": 0.00316, "epss_percentile": 0.54292}, "CVE-2021-22995": {"epss_score": 0.0024, "epss_percentile": 0.46959}, "CVE-2021-22996": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-22997": {"epss_score": 0.0032, "epss_percentile": 0.54633}, "CVE-2021-22998": {"epss_score": 0.00628, "epss_percentile": 0.69654}, "CVE-2021-22999": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-23000": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-23001": {"epss_score": 0.00246, "epss_percentile": 0.4776}, "CVE-2021-23002": {"epss_score": 0.00073, "epss_percentile": 0.22506}, "CVE-2021-23003": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-23004": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-23005": {"epss_score": 0.0047, "epss_percentile": 0.63962}, "CVE-2021-23006": {"epss_score": 0.00351, "epss_percentile": 0.57028}, "CVE-2021-23007": {"epss_score": 0.00733, "epss_percentile": 0.72215}, "CVE-2021-23008": {"epss_score": 0.0061, "epss_percentile": 0.69151}, "CVE-2021-23009": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-23010": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-23011": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-23012": {"epss_score": 0.0019, "epss_percentile": 0.4107}, "CVE-2021-23013": {"epss_score": 0.00798, "epss_percentile": 0.73518}, "CVE-2021-23014": {"epss_score": 0.00275, "epss_percentile": 0.5065}, "CVE-2021-23015": {"epss_score": 0.00081, "epss_percentile": 0.2434}, "CVE-2021-23016": {"epss_score": 0.00263, "epss_percentile": 0.49494}, "CVE-2021-23017": {"epss_score": 0.73166, "epss_percentile": 0.98739}, "CVE-2021-23018": {"epss_score": 0.0022, "epss_percentile": 0.44546}, "CVE-2021-23019": {"epss_score": 0.00063, "epss_percentile": 0.19981}, "CVE-2021-23020": {"epss_score": 0.0009, "epss_percentile": 0.26052}, "CVE-2021-23021": {"epss_score": 0.00085, "epss_percentile": 0.25228}, "CVE-2021-23022": {"epss_score": 0.00137, "epss_percentile": 0.3425}, "CVE-2021-23023": {"epss_score": 0.00088, "epss_percentile": 0.25687}, "CVE-2021-23024": {"epss_score": 0.0489, "epss_percentile": 0.8926}, "CVE-2021-23025": {"epss_score": 0.01119, "epss_percentile": 0.77757}, "CVE-2021-23026": {"epss_score": 0.00302, "epss_percentile": 0.53124}, "CVE-2021-23027": {"epss_score": 0.00387, "epss_percentile": 0.59304}, "CVE-2021-23028": {"epss_score": 0.00608, "epss_percentile": 0.69077}, "CVE-2021-23029": {"epss_score": 0.00279, "epss_percentile": 0.50997}, "CVE-2021-23030": {"epss_score": 0.00682, "epss_percentile": 0.71072}, "CVE-2021-23031": {"epss_score": 0.005, "epss_percentile": 0.65319}, "CVE-2021-23032": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2021-23033": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-23034": {"epss_score": 0.00916, "epss_percentile": 0.75421}, "CVE-2021-23035": {"epss_score": 0.00862, "epss_percentile": 0.74577}, "CVE-2021-23036": {"epss_score": 0.00608, "epss_percentile": 0.69077}, "CVE-2021-23037": {"epss_score": 0.00714, "epss_percentile": 0.71821}, "CVE-2021-23038": {"epss_score": 0.00326, "epss_percentile": 0.55071}, "CVE-2021-23039": {"epss_score": 0.00574, "epss_percentile": 0.68096}, "CVE-2021-23040": {"epss_score": 0.00303, "epss_percentile": 0.53216}, "CVE-2021-23041": {"epss_score": 0.00411, "epss_percentile": 0.60902}, "CVE-2021-23042": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-23043": {"epss_score": 0.0035, "epss_percentile": 0.56938}, "CVE-2021-23044": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2021-23045": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-23046": {"epss_score": 0.00242, "epss_percentile": 0.47339}, "CVE-2021-23047": {"epss_score": 0.00338, "epss_percentile": 0.56145}, "CVE-2021-23048": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2021-23049": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2021-23050": {"epss_score": 0.00245, "epss_percentile": 0.47729}, "CVE-2021-23051": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2021-23052": {"epss_score": 0.00219, "epss_percentile": 0.44469}, "CVE-2021-23053": {"epss_score": 0.00628, "epss_percentile": 0.69654}, "CVE-2021-23054": {"epss_score": 0.00444, "epss_percentile": 0.62827}, "CVE-2021-23055": {"epss_score": 0.00178, "epss_percentile": 0.39718}, "CVE-2021-23123": {"epss_score": 0.00011, "epss_percentile": 0.01029}, "CVE-2021-23124": {"epss_score": 0.01599, "epss_percentile": 0.81254}, "CVE-2021-23125": {"epss_score": 0.03589, "epss_percentile": 0.87397}, "CVE-2021-23126": {"epss_score": 0.00011, "epss_percentile": 0.01002}, "CVE-2021-23127": {"epss_score": 9e-05, "epss_percentile": 0.00745}, "CVE-2021-23128": {"epss_score": 9e-05, "epss_percentile": 0.00745}, "CVE-2021-23129": {"epss_score": 0.01635, "epss_percentile": 0.81471}, "CVE-2021-23130": {"epss_score": 0.01635, "epss_percentile": 0.81471}, "CVE-2021-23131": {"epss_score": 0.00029, "epss_percentile": 0.07901}, "CVE-2021-23132": {"epss_score": 0.65284, "epss_percentile": 0.98411}, "CVE-2021-23133": {"epss_score": 0.00083, "epss_percentile": 0.24805}, "CVE-2021-23134": {"epss_score": 0.00029, "epss_percentile": 0.07634}, "CVE-2021-23135": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2021-23136": {"epss_score": 0.00122, "epss_percentile": 0.32158}, "CVE-2021-23138": {"epss_score": 0.00639, "epss_percentile": 0.69938}, "CVE-2021-23139": {"epss_score": 0.00742, "epss_percentile": 0.72456}, "CVE-2021-23140": {"epss_score": 0.00233, "epss_percentile": 0.46042}, "CVE-2021-23146": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2021-23147": {"epss_score": 0.00044, "epss_percentile": 0.13587}, "CVE-2021-23150": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-23152": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-23154": {"epss_score": 0.00153, "epss_percentile": 0.36565}, "CVE-2021-23155": {"epss_score": 0.00129, "epss_percentile": 0.33159}, "CVE-2021-23157": {"epss_score": 0.00572, "epss_percentile": 0.68017}, "CVE-2021-23158": {"epss_score": 0.00465, "epss_percentile": 0.63784}, "CVE-2021-23159": {"epss_score": 0.00035, "epss_percentile": 0.09881}, "CVE-2021-23162": {"epss_score": 0.00187, "epss_percentile": 0.40711}, "CVE-2021-23163": {"epss_score": 0.00116, "epss_percentile": 0.31156}, "CVE-2021-23165": {"epss_score": 0.00406, "epss_percentile": 0.60521}, "CVE-2021-23166": {"epss_score": 0.00337, "epss_percentile": 0.56066}, "CVE-2021-23167": {"epss_score": 0.00102, "epss_percentile": 0.28723}, "CVE-2021-23168": {"epss_score": 0.00232, "epss_percentile": 0.45937}, "CVE-2021-23169": {"epss_score": 0.00186, "epss_percentile": 0.40684}, "CVE-2021-23172": {"epss_score": 0.00035, "epss_percentile": 0.09881}, "CVE-2021-23173": {"epss_score": 0.00158, "epss_percentile": 0.37286}, "CVE-2021-23174": {"epss_score": 0.00418, "epss_percentile": 0.61275}, "CVE-2021-23175": {"epss_score": 0.00037, "epss_percentile": 0.11001}, "CVE-2021-23176": {"epss_score": 0.0037, "epss_percentile": 0.58282}, "CVE-2021-23177": {"epss_score": 0.00039, "epss_percentile": 0.11718}, "CVE-2021-23178": {"epss_score": 0.00214, "epss_percentile": 0.44013}, "CVE-2021-23179": {"epss_score": 0.00057, "epss_percentile": 0.17992}, "CVE-2021-23180": {"epss_score": 0.00279, "epss_percentile": 0.50965}, "CVE-2021-23182": {"epss_score": 0.00027, "epss_percentile": 0.06942}, "CVE-2021-23186": {"epss_score": 0.00281, "epss_percentile": 0.5118}, "CVE-2021-23188": {"epss_score": 0.00128, "epss_percentile": 0.33009}, "CVE-2021-23191": {"epss_score": 0.00245, "epss_percentile": 0.47626}, "CVE-2021-23192": {"epss_score": 0.00054, "epss_percentile": 0.17192}, "CVE-2021-23193": {"epss_score": 0.0018, "epss_percentile": 0.39966}, "CVE-2021-23195": {"epss_score": 0.00182, "epss_percentile": 0.40257}, "CVE-2021-23196": {"epss_score": 0.00261, "epss_percentile": 0.49278}, "CVE-2021-23197": {"epss_score": 0.00044, "epss_percentile": 0.136}, "CVE-2021-23198": {"epss_score": 0.00403, "epss_percentile": 0.60327}, "CVE-2021-23201": {"epss_score": 0.00038, "epss_percentile": 0.11075}, "CVE-2021-23203": {"epss_score": 0.00326, "epss_percentile": 0.55087}, "CVE-2021-23204": {"epss_score": 0.0018, "epss_percentile": 0.39892}, "CVE-2021-23205": {"epss_score": 0.00254, "epss_percentile": 0.48557}, "CVE-2021-23206": {"epss_score": 0.00514, "epss_percentile": 0.65956}, "CVE-2021-23207": {"epss_score": 0.00054, "epss_percentile": 0.17136}, "CVE-2021-23209": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-23210": {"epss_score": 0.00038, "epss_percentile": 0.11128}, "CVE-2021-23211": {"epss_score": 0.00014, "epss_percentile": 0.01866}, "CVE-2021-23214": {"epss_score": 0.00356, "epss_percentile": 0.57397}, "CVE-2021-23215": {"epss_score": 0.00106, "epss_percentile": 0.29446}, "CVE-2021-23217": {"epss_score": 0.00042, "epss_percentile": 0.12747}, "CVE-2021-23218": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-23219": {"epss_score": 0.00053, "epss_percentile": 0.16741}, "CVE-2021-23222": {"epss_score": 0.00282, "epss_percentile": 0.51241}, "CVE-2021-23223": {"epss_score": 0.00116, "epss_percentile": 0.31161}, "CVE-2021-23225": {"epss_score": 0.0081, "epss_percentile": 0.73714}, "CVE-2021-23227": {"epss_score": 0.00139, "epss_percentile": 0.34596}, "CVE-2021-23228": {"epss_score": 0.00156, "epss_percentile": 0.36982}, "CVE-2021-23230": {"epss_score": 0.00248, "epss_percentile": 0.47931}, "CVE-2021-23233": {"epss_score": 0.00319, "epss_percentile": 0.5447}, "CVE-2021-23236": {"epss_score": 0.00205, "epss_percentile": 0.42757}, "CVE-2021-23239": {"epss_score": 0.00062, "epss_percentile": 0.19737}, "CVE-2021-23240": {"epss_score": 0.00225, "epss_percentile": 0.45114}, "CVE-2021-23241": {"epss_score": 0.62713, "epss_percentile": 0.98304}, "CVE-2021-23242": {"epss_score": 0.0038, "epss_percentile": 0.58961}, "CVE-2021-23243": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2021-23244": {"epss_score": 0.00164, "epss_percentile": 0.37906}, "CVE-2021-23246": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-23247": {"epss_score": 0.03358, "epss_percentile": 0.8698}, "CVE-2021-23253": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2021-23258": {"epss_score": 0.00292, "epss_percentile": 0.52254}, "CVE-2021-23259": {"epss_score": 0.00391, "epss_percentile": 0.59564}, "CVE-2021-23260": {"epss_score": 0.00476, "epss_percentile": 0.64278}, "CVE-2021-23261": {"epss_score": 0.00373, "epss_percentile": 0.58478}, "CVE-2021-23262": {"epss_score": 0.0055, "epss_percentile": 0.67346}, "CVE-2021-23263": {"epss_score": 0.00467, "epss_percentile": 0.6382}, "CVE-2021-23264": {"epss_score": 0.01086, "epss_percentile": 0.77412}, "CVE-2021-23265": {"epss_score": 0.00232, "epss_percentile": 0.45903}, "CVE-2021-23266": {"epss_score": 0.00243, "epss_percentile": 0.47472}, "CVE-2021-23267": {"epss_score": 0.00462, "epss_percentile": 0.63619}, "CVE-2021-23270": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-23271": {"epss_score": 0.00333, "epss_percentile": 0.55638}, "CVE-2021-23272": {"epss_score": 0.00213, "epss_percentile": 0.43895}, "CVE-2021-23273": {"epss_score": 0.00254, "epss_percentile": 0.48572}, "CVE-2021-23274": {"epss_score": 0.00241, "epss_percentile": 0.47282}, "CVE-2021-23275": {"epss_score": 0.00026, "epss_percentile": 0.06515}, "CVE-2021-23276": {"epss_score": 0.00103, "epss_percentile": 0.29014}, "CVE-2021-23277": {"epss_score": 0.00427, "epss_percentile": 0.61908}, "CVE-2021-23278": {"epss_score": 0.00099, "epss_percentile": 0.28389}, "CVE-2021-23279": {"epss_score": 0.00914, "epss_percentile": 0.7539}, "CVE-2021-23280": {"epss_score": 0.00123, "epss_percentile": 0.3226}, "CVE-2021-23281": {"epss_score": 0.00578, "epss_percentile": 0.68199}, "CVE-2021-23282": {"epss_score": 0.00969, "epss_percentile": 0.76101}, "CVE-2021-23283": {"epss_score": 0.00196, "epss_percentile": 0.41764}, "CVE-2021-23284": {"epss_score": 0.00245, "epss_percentile": 0.47684}, "CVE-2021-23285": {"epss_score": 0.00222, "epss_percentile": 0.44843}, "CVE-2021-23286": {"epss_score": 0.00096, "epss_percentile": 0.2742}, "CVE-2021-23287": {"epss_score": 0.00357, "epss_percentile": 0.57408}, "CVE-2021-23288": {"epss_score": 0.00065, "epss_percentile": 0.20604}, "CVE-2021-23326": {"epss_score": 0.01502, "epss_percentile": 0.80723}, "CVE-2021-23327": {"epss_score": 0.00732, "epss_percentile": 0.72188}, "CVE-2021-23328": {"epss_score": 0.00282, "epss_percentile": 0.51227}, "CVE-2021-23329": {"epss_score": 0.00332, "epss_percentile": 0.556}, "CVE-2021-23330": {"epss_score": 0.16547, "epss_percentile": 0.94688}, "CVE-2021-23331": {"epss_score": 0.00036, "epss_percentile": 0.10316}, "CVE-2021-23335": {"epss_score": 0.0025, "epss_percentile": 0.48102}, "CVE-2021-23336": {"epss_score": 0.003, "epss_percentile": 0.52957}, "CVE-2021-23337": {"epss_score": 0.00741, "epss_percentile": 0.72433}, "CVE-2021-23338": {"epss_score": 0.02852, "epss_percentile": 0.85832}, "CVE-2021-23339": {"epss_score": 0.00211, "epss_percentile": 0.43638}, "CVE-2021-23340": {"epss_score": 0.00022, "epss_percentile": 0.05132}, "CVE-2021-23341": {"epss_score": 0.01762, "epss_percentile": 0.82155}, "CVE-2021-23342": {"epss_score": 0.00463, "epss_percentile": 0.63684}, "CVE-2021-23343": {"epss_score": 0.00506, "epss_percentile": 0.65622}, "CVE-2021-23344": {"epss_score": 0.06653, "epss_percentile": 0.90917}, "CVE-2021-23345": {"epss_score": 0.00213, "epss_percentile": 0.43947}, "CVE-2021-23346": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2021-23347": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2021-23348": {"epss_score": 0.01082, "epss_percentile": 0.77379}, "CVE-2021-23351": {"epss_score": 0.01345, "epss_percentile": 0.79627}, "CVE-2021-23352": {"epss_score": 0.00625, "epss_percentile": 0.69584}, "CVE-2021-23353": {"epss_score": 0.01346, "epss_percentile": 0.79629}, "CVE-2021-23354": {"epss_score": 0.00399, "epss_percentile": 0.60118}, "CVE-2021-23355": {"epss_score": 0.01432, "epss_percentile": 0.80254}, "CVE-2021-23356": {"epss_score": 0.01432, "epss_percentile": 0.80254}, "CVE-2021-23357": {"epss_score": 0.00047, "epss_percentile": 0.14861}, "CVE-2021-23358": {"epss_score": 0.01433, "epss_percentile": 0.80258}, "CVE-2021-23359": {"epss_score": 0.0038, "epss_percentile": 0.58942}, "CVE-2021-23360": {"epss_score": 0.00759, "epss_percentile": 0.72795}, "CVE-2021-23362": {"epss_score": 0.00554, "epss_percentile": 0.67446}, "CVE-2021-23363": {"epss_score": 0.00998, "epss_percentile": 0.76466}, "CVE-2021-23364": {"epss_score": 0.00385, "epss_percentile": 0.59214}, "CVE-2021-23365": {"epss_score": 0.00366, "epss_percentile": 0.58088}, "CVE-2021-23368": {"epss_score": 0.003, "epss_percentile": 0.52954}, "CVE-2021-23369": {"epss_score": 0.02248, "epss_percentile": 0.84135}, "CVE-2021-23370": {"epss_score": 0.0154, "epss_percentile": 0.8094}, "CVE-2021-23371": {"epss_score": 0.00408, "epss_percentile": 0.60647}, "CVE-2021-23372": {"epss_score": 0.00306, "epss_percentile": 0.53458}, "CVE-2021-23373": {"epss_score": 0.00389, "epss_percentile": 0.59404}, "CVE-2021-23374": {"epss_score": 0.00806, "epss_percentile": 0.7366}, "CVE-2021-23375": {"epss_score": 0.00806, "epss_percentile": 0.7366}, "CVE-2021-23376": {"epss_score": 0.00612, "epss_percentile": 0.69216}, "CVE-2021-23377": {"epss_score": 0.00612, "epss_percentile": 0.69216}, "CVE-2021-23378": {"epss_score": 0.00612, "epss_percentile": 0.69216}, "CVE-2021-23379": {"epss_score": 0.00806, "epss_percentile": 0.7366}, "CVE-2021-23380": {"epss_score": 0.00496, "epss_percentile": 0.65168}, "CVE-2021-23381": {"epss_score": 0.00806, "epss_percentile": 0.7366}, "CVE-2021-23382": {"epss_score": 0.00071, "epss_percentile": 0.22056}, "CVE-2021-23383": {"epss_score": 0.04396, "epss_percentile": 0.88639}, "CVE-2021-23384": {"epss_score": 0.00207, "epss_percentile": 0.43155}, "CVE-2021-23385": {"epss_score": 0.00214, "epss_percentile": 0.43949}, "CVE-2021-23386": {"epss_score": 0.01115, "epss_percentile": 0.77712}, "CVE-2021-23387": {"epss_score": 0.0026, "epss_percentile": 0.49187}, "CVE-2021-23388": {"epss_score": 0.00372, "epss_percentile": 0.58422}, "CVE-2021-23389": {"epss_score": 0.0534, "epss_percentile": 0.89761}, "CVE-2021-23390": {"epss_score": 0.01311, "epss_percentile": 0.79366}, "CVE-2021-23391": {"epss_score": 0.00088, "epss_percentile": 0.25729}, "CVE-2021-23392": {"epss_score": 0.00408, "epss_percentile": 0.60647}, "CVE-2021-23393": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2021-23394": {"epss_score": 0.77529, "epss_percentile": 0.98939}, "CVE-2021-23395": {"epss_score": 0.00224, "epss_percentile": 0.45023}, "CVE-2021-23396": {"epss_score": 0.00391, "epss_percentile": 0.59562}, "CVE-2021-23397": {"epss_score": 0.0037, "epss_percentile": 0.58334}, "CVE-2021-23398": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2021-23399": {"epss_score": 0.00806, "epss_percentile": 0.7366}, "CVE-2021-23400": {"epss_score": 0.00536, "epss_percentile": 0.66856}, "CVE-2021-23401": {"epss_score": 0.00265, "epss_percentile": 0.49796}, "CVE-2021-23402": {"epss_score": 0.0053, "epss_percentile": 0.66625}, "CVE-2021-23403": {"epss_score": 0.0053, "epss_percentile": 0.66625}, "CVE-2021-23404": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2021-23405": {"epss_score": 0.00027, "epss_percentile": 0.07086}, "CVE-2021-23406": {"epss_score": 0.00999, "epss_percentile": 0.76477}, "CVE-2021-23407": {"epss_score": 0.00532, "epss_percentile": 0.66679}, "CVE-2021-23408": {"epss_score": 0.00254, "epss_percentile": 0.48535}, "CVE-2021-23409": {"epss_score": 0.00911, "epss_percentile": 0.75322}, "CVE-2021-23411": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2021-23412": {"epss_score": 0.03916, "epss_percentile": 0.87947}, "CVE-2021-23413": {"epss_score": 0.0014, "epss_percentile": 0.34716}, "CVE-2021-23414": {"epss_score": 0.00437, "epss_percentile": 0.62509}, "CVE-2021-23415": {"epss_score": 0.00436, "epss_percentile": 0.62471}, "CVE-2021-23416": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-23417": {"epss_score": 0.0053, "epss_percentile": 0.66625}, "CVE-2021-23418": {"epss_score": 0.00381, "epss_percentile": 0.59004}, "CVE-2021-23419": {"epss_score": 0.00432, "epss_percentile": 0.6213}, "CVE-2021-23420": {"epss_score": 0.00579, "epss_percentile": 0.68229}, "CVE-2021-23421": {"epss_score": 0.0053, "epss_percentile": 0.66625}, "CVE-2021-23422": {"epss_score": 0.00203, "epss_percentile": 0.42522}, "CVE-2021-23423": {"epss_score": 0.00353, "epss_percentile": 0.57163}, "CVE-2021-23424": {"epss_score": 0.00204, "epss_percentile": 0.42635}, "CVE-2021-23425": {"epss_score": 0.00364, "epss_percentile": 0.57945}, "CVE-2021-23426": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2021-23427": {"epss_score": 0.00631, "epss_percentile": 0.69716}, "CVE-2021-23428": {"epss_score": 0.00754, "epss_percentile": 0.72702}, "CVE-2021-23429": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2021-23430": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2021-23431": {"epss_score": 0.00138, "epss_percentile": 0.34375}, "CVE-2021-23432": {"epss_score": 0.00303, "epss_percentile": 0.53236}, "CVE-2021-23433": {"epss_score": 0.00367, "epss_percentile": 0.5814}, "CVE-2021-23434": {"epss_score": 0.00062, "epss_percentile": 0.19611}, "CVE-2021-23435": {"epss_score": 0.00282, "epss_percentile": 0.51262}, "CVE-2021-23436": {"epss_score": 0.00176, "epss_percentile": 0.39467}, "CVE-2021-23437": {"epss_score": 0.00208, "epss_percentile": 0.43293}, "CVE-2021-23438": {"epss_score": 0.00518, "epss_percentile": 0.66107}, "CVE-2021-23439": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2021-23440": {"epss_score": 0.00066, "epss_percentile": 0.20746}, "CVE-2021-23442": {"epss_score": 0.005, "epss_percentile": 0.6529}, "CVE-2021-23443": {"epss_score": 0.00238, "epss_percentile": 0.46802}, "CVE-2021-23444": {"epss_score": 0.01539, "epss_percentile": 0.80938}, "CVE-2021-23445": {"epss_score": 0.00327, "epss_percentile": 0.5515}, "CVE-2021-23446": {"epss_score": 0.00287, "epss_percentile": 0.5179}, "CVE-2021-23447": {"epss_score": 0.00305, "epss_percentile": 0.5334}, "CVE-2021-23448": {"epss_score": 0.00444, "epss_percentile": 0.6283}, "CVE-2021-23449": {"epss_score": 0.02202, "epss_percentile": 0.83984}, "CVE-2021-23450": {"epss_score": 0.02411, "epss_percentile": 0.84665}, "CVE-2021-23451": {"epss_score": 0.00359, "epss_percentile": 0.5759}, "CVE-2021-23452": {"epss_score": 0.00556, "epss_percentile": 0.67523}, "CVE-2021-23460": {"epss_score": 0.00542, "epss_percentile": 0.67072}, "CVE-2021-23463": {"epss_score": 0.00376, "epss_percentile": 0.58641}, "CVE-2021-23470": {"epss_score": 0.01455, "epss_percentile": 0.80388}, "CVE-2021-23472": {"epss_score": 0.00577, "epss_percentile": 0.68151}, "CVE-2021-23484": {"epss_score": 0.0059, "epss_percentile": 0.68557}, "CVE-2021-23490": {"epss_score": 0.00408, "epss_percentile": 0.60647}, "CVE-2021-23495": {"epss_score": 0.00255, "epss_percentile": 0.48718}, "CVE-2021-23497": {"epss_score": 0.03252, "epss_percentile": 0.86753}, "CVE-2021-23507": {"epss_score": 0.00502, "epss_percentile": 0.65407}, "CVE-2021-23509": {"epss_score": 0.01748, "epss_percentile": 0.8208}, "CVE-2021-23514": {"epss_score": 0.00778, "epss_percentile": 0.73126}, "CVE-2021-23518": {"epss_score": 0.0051, "epss_percentile": 0.65797}, "CVE-2021-23520": {"epss_score": 0.00738, "epss_percentile": 0.72337}, "CVE-2021-23521": {"epss_score": 0.00076, "epss_percentile": 0.2311}, "CVE-2021-23543": {"epss_score": 0.00556, "epss_percentile": 0.67523}, "CVE-2021-23555": {"epss_score": 0.01093, "epss_percentile": 0.77471}, "CVE-2021-23556": {"epss_score": 0.00823, "epss_percentile": 0.73929}, "CVE-2021-23558": {"epss_score": 0.00678, "epss_percentile": 0.70971}, "CVE-2021-23561": {"epss_score": 0.00477, "epss_percentile": 0.64341}, "CVE-2021-23562": {"epss_score": 0.00945, "epss_percentile": 0.75798}, "CVE-2021-23566": {"epss_score": 0.00025, "epss_percentile": 0.06379}, "CVE-2021-23567": {"epss_score": 0.00586, "epss_percentile": 0.68457}, "CVE-2021-23568": {"epss_score": 0.00502, "epss_percentile": 0.654}, "CVE-2021-23574": {"epss_score": 0.01272, "epss_percentile": 0.79076}, "CVE-2021-23592": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2021-23594": {"epss_score": 0.00556, "epss_percentile": 0.67523}, "CVE-2021-23597": {"epss_score": 0.00405, "epss_percentile": 0.60503}, "CVE-2021-23624": {"epss_score": 0.00427, "epss_percentile": 0.61874}, "CVE-2021-23631": {"epss_score": 0.00386, "epss_percentile": 0.59285}, "CVE-2021-23632": {"epss_score": 0.03224, "epss_percentile": 0.86682}, "CVE-2021-23639": {"epss_score": 0.24757, "epss_percentile": 0.95952}, "CVE-2021-23648": {"epss_score": 0.00122, "epss_percentile": 0.32091}, "CVE-2021-23654": {"epss_score": 0.01432, "epss_percentile": 0.80254}, "CVE-2021-23663": {"epss_score": 0.00477, "epss_percentile": 0.64341}, "CVE-2021-23664": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2021-23673": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-23682": {"epss_score": 0.05384, "epss_percentile": 0.89817}, "CVE-2021-23700": {"epss_score": 0.00477, "epss_percentile": 0.64341}, "CVE-2021-23702": {"epss_score": 0.0038, "epss_percentile": 0.58948}, "CVE-2021-23718": {"epss_score": 0.00354, "epss_percentile": 0.57241}, "CVE-2021-23727": {"epss_score": 0.01148, "epss_percentile": 0.78015}, "CVE-2021-23732": {"epss_score": 0.00845, "epss_percentile": 0.74282}, "CVE-2021-23758": {"epss_score": 0.87776, "epss_percentile": 0.99442}, "CVE-2021-23760": {"epss_score": 0.02425, "epss_percentile": 0.84714}, "CVE-2021-23771": {"epss_score": 0.00304, "epss_percentile": 0.53296}, "CVE-2021-23772": {"epss_score": 0.00662, "epss_percentile": 0.70596}, "CVE-2021-23784": {"epss_score": 0.00326, "epss_percentile": 0.55086}, "CVE-2021-23792": {"epss_score": 0.00298, "epss_percentile": 0.52783}, "CVE-2021-23797": {"epss_score": 0.00641, "epss_percentile": 0.70015}, "CVE-2021-23803": {"epss_score": 0.00406, "epss_percentile": 0.60513}, "CVE-2021-23807": {"epss_score": 0.00166, "epss_percentile": 0.38141}, "CVE-2021-23814": {"epss_score": 0.02089, "epss_percentile": 0.83562}, "CVE-2021-23820": {"epss_score": 0.002, "epss_percentile": 0.42269}, "CVE-2021-23824": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2021-23827": {"epss_score": 0.00079, "epss_percentile": 0.23977}, "CVE-2021-23835": {"epss_score": 0.0164, "epss_percentile": 0.81499}, "CVE-2021-23836": {"epss_score": 0.004, "epss_percentile": 0.60147}, "CVE-2021-23837": {"epss_score": 0.00781, "epss_percentile": 0.73188}, "CVE-2021-23838": {"epss_score": 0.0034, "epss_percentile": 0.56243}, "CVE-2021-23839": {"epss_score": 0.00289, "epss_percentile": 0.52005}, "CVE-2021-23840": {"epss_score": 0.0057, "epss_percentile": 0.67966}, "CVE-2021-23841": {"epss_score": 0.00613, "epss_percentile": 0.69247}, "CVE-2021-23842": {"epss_score": 0.00027, "epss_percentile": 0.07121}, "CVE-2021-23843": {"epss_score": 0.00042, "epss_percentile": 0.12792}, "CVE-2021-23845": {"epss_score": 0.00285, "epss_percentile": 0.51636}, "CVE-2021-23846": {"epss_score": 0.00135, "epss_percentile": 0.34049}, "CVE-2021-23847": {"epss_score": 0.00336, "epss_percentile": 0.55935}, "CVE-2021-23848": {"epss_score": 0.00393, "epss_percentile": 0.59702}, "CVE-2021-23849": {"epss_score": 0.00181, "epss_percentile": 0.4012}, "CVE-2021-23850": {"epss_score": 0.00267, "epss_percentile": 0.49996}, "CVE-2021-23851": {"epss_score": 0.00236, "epss_percentile": 0.46456}, "CVE-2021-23852": {"epss_score": 0.00261, "epss_percentile": 0.49246}, "CVE-2021-23853": {"epss_score": 0.00308, "epss_percentile": 0.53605}, "CVE-2021-23854": {"epss_score": 0.00293, "epss_percentile": 0.52307}, "CVE-2021-23855": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2021-23856": {"epss_score": 0.00306, "epss_percentile": 0.53402}, "CVE-2021-23857": {"epss_score": 0.00358, "epss_percentile": 0.57529}, "CVE-2021-23858": {"epss_score": 0.00239, "epss_percentile": 0.46907}, "CVE-2021-23859": {"epss_score": 0.0029, "epss_percentile": 0.521}, "CVE-2021-23860": {"epss_score": 0.00251, "epss_percentile": 0.48285}, "CVE-2021-23861": {"epss_score": 0.00304, "epss_percentile": 0.53243}, "CVE-2021-23862": {"epss_score": 0.00528, "epss_percentile": 0.66566}, "CVE-2021-23863": {"epss_score": 0.00251, "epss_percentile": 0.48285}, "CVE-2021-23872": {"epss_score": 0.00042, "epss_percentile": 0.12934}, "CVE-2021-23873": {"epss_score": 0.00097, "epss_percentile": 0.27632}, "CVE-2021-23874": {"epss_score": 0.0076, "epss_percentile": 0.72812}, "CVE-2021-23876": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2021-23877": {"epss_score": 0.00027, "epss_percentile": 0.06983}, "CVE-2021-23878": {"epss_score": 0.00165, "epss_percentile": 0.38128}, "CVE-2021-23879": {"epss_score": 0.00056, "epss_percentile": 0.17916}, "CVE-2021-23880": {"epss_score": 0.00051, "epss_percentile": 0.16149}, "CVE-2021-23881": {"epss_score": 0.0031, "epss_percentile": 0.53775}, "CVE-2021-23882": {"epss_score": 0.00048, "epss_percentile": 0.15281}, "CVE-2021-23883": {"epss_score": 0.00063, "epss_percentile": 0.19912}, "CVE-2021-23884": {"epss_score": 0.0005, "epss_percentile": 0.15665}, "CVE-2021-23885": {"epss_score": 0.00934, "epss_percentile": 0.7565}, "CVE-2021-23886": {"epss_score": 0.00043, "epss_percentile": 0.13231}, "CVE-2021-23887": {"epss_score": 0.00035, "epss_percentile": 0.10054}, "CVE-2021-23888": {"epss_score": 0.005, "epss_percentile": 0.65329}, "CVE-2021-23889": {"epss_score": 0.00212, "epss_percentile": 0.43759}, "CVE-2021-23890": {"epss_score": 0.00718, "epss_percentile": 0.71937}, "CVE-2021-23891": {"epss_score": 0.00042, "epss_percentile": 0.128}, "CVE-2021-23892": {"epss_score": 0.00022, "epss_percentile": 0.05216}, "CVE-2021-23893": {"epss_score": 0.00026, "epss_percentile": 0.06616}, "CVE-2021-23894": {"epss_score": 0.04277, "epss_percentile": 0.88483}, "CVE-2021-23895": {"epss_score": 0.01406, "epss_percentile": 0.80048}, "CVE-2021-23896": {"epss_score": 0.00045, "epss_percentile": 0.13722}, "CVE-2021-23899": {"epss_score": 0.00443, "epss_percentile": 0.62773}, "CVE-2021-23900": {"epss_score": 0.00408, "epss_percentile": 0.60647}, "CVE-2021-23901": {"epss_score": 0.01068, "epss_percentile": 0.77235}, "CVE-2021-23906": {"epss_score": 0.00251, "epss_percentile": 0.48293}, "CVE-2021-23907": {"epss_score": 0.02019, "epss_percentile": 0.83289}, "CVE-2021-23908": {"epss_score": 0.02019, "epss_percentile": 0.83289}, "CVE-2021-23909": {"epss_score": 0.02648, "epss_percentile": 0.85338}, "CVE-2021-23910": {"epss_score": 0.00253, "epss_percentile": 0.48447}, "CVE-2021-23921": {"epss_score": 0.00282, "epss_percentile": 0.51263}, "CVE-2021-23922": {"epss_score": 0.00163, "epss_percentile": 0.3782}, "CVE-2021-23923": {"epss_score": 0.00183, "epss_percentile": 0.40349}, "CVE-2021-23924": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-23925": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2021-23926": {"epss_score": 0.00322, "epss_percentile": 0.548}, "CVE-2021-23927": {"epss_score": 0.00129, "epss_percentile": 0.33089}, "CVE-2021-23928": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2021-23929": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2021-23930": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2021-23931": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2021-23932": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2021-23933": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2021-23934": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2021-23935": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2021-23936": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2021-23937": {"epss_score": 0.05235, "epss_percentile": 0.89646}, "CVE-2021-23953": {"epss_score": 0.00382, "epss_percentile": 0.59036}, "CVE-2021-23954": {"epss_score": 0.00387, "epss_percentile": 0.59329}, "CVE-2021-23955": {"epss_score": 0.00238, "epss_percentile": 0.46836}, "CVE-2021-23956": {"epss_score": 0.00284, "epss_percentile": 0.51452}, "CVE-2021-23957": {"epss_score": 0.00286, "epss_percentile": 0.51712}, "CVE-2021-23958": {"epss_score": 0.00325, "epss_percentile": 0.55031}, "CVE-2021-23959": {"epss_score": 0.00302, "epss_percentile": 0.53137}, "CVE-2021-23960": {"epss_score": 0.00529, "epss_percentile": 0.66592}, "CVE-2021-23961": {"epss_score": 0.00793, "epss_percentile": 0.73418}, "CVE-2021-23962": {"epss_score": 0.00342, "epss_percentile": 0.56375}, "CVE-2021-23963": {"epss_score": 0.0023, "epss_percentile": 0.45715}, "CVE-2021-23964": {"epss_score": 0.00653, "epss_percentile": 0.70335}, "CVE-2021-23965": {"epss_score": 0.00372, "epss_percentile": 0.58426}, "CVE-2021-23968": {"epss_score": 0.00851, "epss_percentile": 0.74404}, "CVE-2021-23969": {"epss_score": 0.0102, "epss_percentile": 0.76733}, "CVE-2021-23970": {"epss_score": 0.00484, "epss_percentile": 0.64652}, "CVE-2021-23971": {"epss_score": 0.00481, "epss_percentile": 0.64481}, "CVE-2021-23972": {"epss_score": 0.00467, "epss_percentile": 0.63864}, "CVE-2021-23973": {"epss_score": 0.00716, "epss_percentile": 0.71859}, "CVE-2021-23974": {"epss_score": 0.00142, "epss_percentile": 0.35086}, "CVE-2021-23975": {"epss_score": 0.00287, "epss_percentile": 0.5182}, "CVE-2021-23976": {"epss_score": 0.00334, "epss_percentile": 0.55693}, "CVE-2021-23977": {"epss_score": 0.00372, "epss_percentile": 0.58447}, "CVE-2021-23978": {"epss_score": 0.00661, "epss_percentile": 0.70579}, "CVE-2021-23979": {"epss_score": 0.0034, "epss_percentile": 0.56276}, "CVE-2021-23980": {"epss_score": 0.0034, "epss_percentile": 0.56214}, "CVE-2021-23981": {"epss_score": 0.00461, "epss_percentile": 0.63547}, "CVE-2021-23982": {"epss_score": 0.00196, "epss_percentile": 0.4176}, "CVE-2021-23983": {"epss_score": 0.00366, "epss_percentile": 0.58075}, "CVE-2021-23984": {"epss_score": 0.00267, "epss_percentile": 0.49991}, "CVE-2021-23985": {"epss_score": 0.0051, "epss_percentile": 0.6579}, "CVE-2021-23986": {"epss_score": 0.00053, "epss_percentile": 0.16909}, "CVE-2021-23987": {"epss_score": 0.00313, "epss_percentile": 0.54012}, "CVE-2021-23988": {"epss_score": 0.00323, "epss_percentile": 0.54912}, "CVE-2021-23991": {"epss_score": 0.00204, "epss_percentile": 0.42638}, "CVE-2021-23992": {"epss_score": 0.00087, "epss_percentile": 0.25469}, "CVE-2021-23993": {"epss_score": 0.00051, "epss_percentile": 0.16181}, "CVE-2021-23994": {"epss_score": 0.00348, "epss_percentile": 0.56801}, "CVE-2021-23995": {"epss_score": 0.01035, "epss_percentile": 0.76904}, "CVE-2021-23996": {"epss_score": 0.0027, "epss_percentile": 0.50244}, "CVE-2021-23997": {"epss_score": 0.00349, "epss_percentile": 0.56912}, "CVE-2021-23998": {"epss_score": 0.00163, "epss_percentile": 0.3782}, "CVE-2021-23999": {"epss_score": 0.00152, "epss_percentile": 0.36466}, "CVE-2021-24000": {"epss_score": 0.00234, "epss_percentile": 0.46114}, "CVE-2021-24001": {"epss_score": 0.0027, "epss_percentile": 0.50244}, "CVE-2021-24002": {"epss_score": 0.00457, "epss_percentile": 0.6336}, "CVE-2021-24005": {"epss_score": 0.00127, "epss_percentile": 0.32813}, "CVE-2021-24006": {"epss_score": 0.00487, "epss_percentile": 0.64801}, "CVE-2021-24007": {"epss_score": 0.00707, "epss_percentile": 0.71642}, "CVE-2021-24008": {"epss_score": 0.00095, "epss_percentile": 0.27158}, "CVE-2021-24009": {"epss_score": 0.00325, "epss_percentile": 0.55025}, "CVE-2021-24010": {"epss_score": 0.00437, "epss_percentile": 0.6253}, "CVE-2021-24011": {"epss_score": 0.00373, "epss_percentile": 0.5852}, "CVE-2021-24012": {"epss_score": 0.00207, "epss_percentile": 0.43122}, "CVE-2021-24013": {"epss_score": 0.00614, "epss_percentile": 0.69268}, "CVE-2021-24014": {"epss_score": 0.00444, "epss_percentile": 0.62826}, "CVE-2021-24015": {"epss_score": 0.00313, "epss_percentile": 0.54076}, "CVE-2021-24016": {"epss_score": 0.00143, "epss_percentile": 0.35204}, "CVE-2021-24017": {"epss_score": 0.00154, "epss_percentile": 0.36659}, "CVE-2021-24018": {"epss_score": 0.0012, "epss_percentile": 0.31749}, "CVE-2021-24019": {"epss_score": 0.1519, "epss_percentile": 0.94381}, "CVE-2021-24020": {"epss_score": 0.00171, "epss_percentile": 0.38804}, "CVE-2021-24021": {"epss_score": 0.00187, "epss_percentile": 0.407}, "CVE-2021-24022": {"epss_score": 0.0005, "epss_percentile": 0.15739}, "CVE-2021-24023": {"epss_score": 0.00229, "epss_percentile": 0.45623}, "CVE-2021-24024": {"epss_score": 0.00177, "epss_percentile": 0.395}, "CVE-2021-24025": {"epss_score": 0.00468, "epss_percentile": 0.63883}, "CVE-2021-24026": {"epss_score": 0.00442, "epss_percentile": 0.62751}, "CVE-2021-24027": {"epss_score": 0.15232, "epss_percentile": 0.9439}, "CVE-2021-24028": {"epss_score": 0.01674, "epss_percentile": 0.81695}, "CVE-2021-24029": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2021-24030": {"epss_score": 0.01161, "epss_percentile": 0.78147}, "CVE-2021-24031": {"epss_score": 0.00074, "epss_percentile": 0.22689}, "CVE-2021-24032": {"epss_score": 0.0002, "epss_percentile": 0.04494}, "CVE-2021-24033": {"epss_score": 0.01439, "epss_percentile": 0.80293}, "CVE-2021-24035": {"epss_score": 0.00484, "epss_percentile": 0.64663}, "CVE-2021-24036": {"epss_score": 0.06185, "epss_percentile": 0.90542}, "CVE-2021-24037": {"epss_score": 0.00535, "epss_percentile": 0.66842}, "CVE-2021-24038": {"epss_score": 0.00042, "epss_percentile": 0.12809}, "CVE-2021-24040": {"epss_score": 0.36239, "epss_percentile": 0.96963}, "CVE-2021-24041": {"epss_score": 0.00689, "epss_percentile": 0.71235}, "CVE-2021-24042": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-24043": {"epss_score": 0.00566, "epss_percentile": 0.6782}, "CVE-2021-24044": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-24045": {"epss_score": 0.00547, "epss_percentile": 0.67234}, "CVE-2021-24046": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2021-24066": {"epss_score": 0.03664, "epss_percentile": 0.87531}, "CVE-2021-24067": {"epss_score": 0.06847, "epss_percentile": 0.9107}, "CVE-2021-24068": {"epss_score": 0.03079, "epss_percentile": 0.86368}, "CVE-2021-24069": {"epss_score": 0.03079, "epss_percentile": 0.86368}, "CVE-2021-24070": {"epss_score": 0.06847, "epss_percentile": 0.9107}, "CVE-2021-24071": {"epss_score": 0.08862, "epss_percentile": 0.92291}, "CVE-2021-24072": {"epss_score": 0.03396, "epss_percentile": 0.87059}, "CVE-2021-24073": {"epss_score": 0.00533, "epss_percentile": 0.66752}, "CVE-2021-24074": {"epss_score": 0.169, "epss_percentile": 0.94745}, "CVE-2021-24075": {"epss_score": 0.01069, "epss_percentile": 0.77245}, "CVE-2021-24076": {"epss_score": 0.00248, "epss_percentile": 0.47912}, "CVE-2021-24077": {"epss_score": 0.03854, "epss_percentile": 0.87855}, "CVE-2021-24078": {"epss_score": 0.12438, "epss_percentile": 0.93672}, "CVE-2021-24079": {"epss_score": 0.00316, "epss_percentile": 0.54219}, "CVE-2021-24080": {"epss_score": 0.20715, "epss_percentile": 0.95405}, "CVE-2021-24081": {"epss_score": 0.04788, "epss_percentile": 0.89146}, "CVE-2021-24082": {"epss_score": 0.04989, "epss_percentile": 0.89366}, "CVE-2021-24083": {"epss_score": 0.13065, "epss_percentile": 0.93863}, "CVE-2021-24084": {"epss_score": 0.05558, "epss_percentile": 0.89991}, "CVE-2021-24085": {"epss_score": 0.18028, "epss_percentile": 0.94945}, "CVE-2021-24086": {"epss_score": 0.40622, "epss_percentile": 0.97227}, "CVE-2021-24087": {"epss_score": 0.00138, "epss_percentile": 0.34394}, "CVE-2021-24088": {"epss_score": 0.03851, "epss_percentile": 0.8785}, "CVE-2021-24089": {"epss_score": 0.02133, "epss_percentile": 0.8372}, "CVE-2021-24090": {"epss_score": 0.01171, "epss_percentile": 0.78215}, "CVE-2021-24091": {"epss_score": 0.12029, "epss_percentile": 0.93551}, "CVE-2021-24092": {"epss_score": 0.00414, "epss_percentile": 0.61034}, "CVE-2021-24093": {"epss_score": 0.25671, "epss_percentile": 0.96055}, "CVE-2021-24094": {"epss_score": 0.16518, "epss_percentile": 0.94683}, "CVE-2021-24095": {"epss_score": 0.0015, "epss_percentile": 0.36092}, "CVE-2021-24096": {"epss_score": 0.05814, "epss_percentile": 0.90229}, "CVE-2021-24098": {"epss_score": 0.02685, "epss_percentile": 0.85426}, "CVE-2021-24099": {"epss_score": 0.04764, "epss_percentile": 0.89121}, "CVE-2021-24100": {"epss_score": 0.07946, "epss_percentile": 0.91782}, "CVE-2021-24101": {"epss_score": 0.12326, "epss_percentile": 0.93641}, "CVE-2021-24102": {"epss_score": 0.00355, "epss_percentile": 0.57315}, "CVE-2021-24103": {"epss_score": 0.00399, "epss_percentile": 0.60099}, "CVE-2021-24104": {"epss_score": 0.01145, "epss_percentile": 0.77994}, "CVE-2021-24105": {"epss_score": 0.01446, "epss_percentile": 0.80325}, "CVE-2021-24106": {"epss_score": 0.00284, "epss_percentile": 0.51459}, "CVE-2021-24107": {"epss_score": 0.0038, "epss_percentile": 0.58927}, "CVE-2021-24108": {"epss_score": 0.02602, "epss_percentile": 0.85209}, "CVE-2021-24109": {"epss_score": 0.03718, "epss_percentile": 0.87616}, "CVE-2021-24110": {"epss_score": 0.02133, "epss_percentile": 0.8372}, "CVE-2021-24111": {"epss_score": 0.24574, "epss_percentile": 0.95935}, "CVE-2021-24112": {"epss_score": 0.00817, "epss_percentile": 0.73848}, "CVE-2021-24113": {"epss_score": 0.02042, "epss_percentile": 0.83374}, "CVE-2021-24114": {"epss_score": 0.25909, "epss_percentile": 0.96093}, "CVE-2021-24115": {"epss_score": 0.00711, "epss_percentile": 0.71735}, "CVE-2021-24116": {"epss_score": 0.00378, "epss_percentile": 0.58789}, "CVE-2021-24117": {"epss_score": 0.00694, "epss_percentile": 0.71358}, "CVE-2021-24119": {"epss_score": 0.00918, "epss_percentile": 0.75446}, "CVE-2021-24122": {"epss_score": 0.53943, "epss_percentile": 0.97903}, "CVE-2021-24123": {"epss_score": 0.00875, "epss_percentile": 0.74777}, "CVE-2021-24124": {"epss_score": 0.01037, "epss_percentile": 0.76921}, "CVE-2021-24125": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24126": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24127": {"epss_score": 0.00332, "epss_percentile": 0.55559}, "CVE-2021-24128": {"epss_score": 0.00332, "epss_percentile": 0.55559}, "CVE-2021-24129": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24130": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24131": {"epss_score": 0.00972, "epss_percentile": 0.76139}, "CVE-2021-24132": {"epss_score": 0.00501, "epss_percentile": 0.65342}, "CVE-2021-24133": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24134": {"epss_score": 0.00186, "epss_percentile": 0.406}, "CVE-2021-24135": {"epss_score": 0.00179, "epss_percentile": 0.39846}, "CVE-2021-24136": {"epss_score": 0.00124, "epss_percentile": 0.32462}, "CVE-2021-24137": {"epss_score": 0.00912, "epss_percentile": 0.75365}, "CVE-2021-24138": {"epss_score": 0.00868, "epss_percentile": 0.74679}, "CVE-2021-24139": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2021-24140": {"epss_score": 0.00534, "epss_percentile": 0.66784}, "CVE-2021-24141": {"epss_score": 0.00534, "epss_percentile": 0.66784}, "CVE-2021-24142": {"epss_score": 0.00534, "epss_percentile": 0.66784}, "CVE-2021-24143": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24144": {"epss_score": 0.00414, "epss_percentile": 0.611}, "CVE-2021-24145": {"epss_score": 0.92547, "epss_percentile": 0.99726}, "CVE-2021-24146": {"epss_score": 0.6415, "epss_percentile": 0.98367}, "CVE-2021-24147": {"epss_score": 0.00266, "epss_percentile": 0.49914}, "CVE-2021-24148": {"epss_score": 0.05628, "epss_percentile": 0.90065}, "CVE-2021-24149": {"epss_score": 0.00912, "epss_percentile": 0.75365}, "CVE-2021-24150": {"epss_score": 0.41724, "epss_percentile": 0.97291}, "CVE-2021-24151": {"epss_score": 0.00526, "epss_percentile": 0.6641}, "CVE-2021-24152": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24153": {"epss_score": 0.00334, "epss_percentile": 0.55706}, "CVE-2021-24154": {"epss_score": 0.00576, "epss_percentile": 0.68137}, "CVE-2021-24155": {"epss_score": 0.93251, "epss_percentile": 0.99788}, "CVE-2021-24156": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24157": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24158": {"epss_score": 0.0019, "epss_percentile": 0.41122}, "CVE-2021-24159": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-24160": {"epss_score": 0.63797, "epss_percentile": 0.98349}, "CVE-2021-24161": {"epss_score": 0.00747, "epss_percentile": 0.72565}, "CVE-2021-24162": {"epss_score": 0.00123, "epss_percentile": 0.32256}, "CVE-2021-24163": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2021-24164": {"epss_score": 0.00168, "epss_percentile": 0.38451}, "CVE-2021-24165": {"epss_score": 0.01173, "epss_percentile": 0.78242}, "CVE-2021-24166": {"epss_score": 0.00093, "epss_percentile": 0.26707}, "CVE-2021-24167": {"epss_score": 0.00614, "epss_percentile": 0.69284}, "CVE-2021-24168": {"epss_score": 0.00332, "epss_percentile": 0.55559}, "CVE-2021-24169": {"epss_score": 0.05053, "epss_percentile": 0.89442}, "CVE-2021-24170": {"epss_score": 0.28674, "epss_percentile": 0.96377}, "CVE-2021-24171": {"epss_score": 0.00919, "epss_percentile": 0.75455}, "CVE-2021-24172": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24173": {"epss_score": 0.00098, "epss_percentile": 0.27714}, "CVE-2021-24174": {"epss_score": 0.00375, "epss_percentile": 0.58626}, "CVE-2021-24175": {"epss_score": 0.80698, "epss_percentile": 0.99101}, "CVE-2021-24176": {"epss_score": 0.21335, "epss_percentile": 0.95502}, "CVE-2021-24177": {"epss_score": 0.00244, "epss_percentile": 0.47611}, "CVE-2021-24178": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2021-24179": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2021-24180": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24181": {"epss_score": 0.00449, "epss_percentile": 0.63048}, "CVE-2021-24182": {"epss_score": 0.07632, "epss_percentile": 0.91585}, "CVE-2021-24183": {"epss_score": 0.07632, "epss_percentile": 0.91585}, "CVE-2021-24184": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2021-24185": {"epss_score": 0.00449, "epss_percentile": 0.63048}, "CVE-2021-24186": {"epss_score": 0.00625, "epss_percentile": 0.69576}, "CVE-2021-24187": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24188": {"epss_score": 0.00659, "epss_percentile": 0.70511}, "CVE-2021-24189": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2021-24190": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2021-24191": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2021-24192": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2021-24193": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2021-24194": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2021-24195": {"epss_score": 0.00603, "epss_percentile": 0.68933}, "CVE-2021-24196": {"epss_score": 0.00363, "epss_percentile": 0.57823}, "CVE-2021-24197": {"epss_score": 0.0038, "epss_percentile": 0.58934}, "CVE-2021-24198": {"epss_score": 0.00642, "epss_percentile": 0.70032}, "CVE-2021-24199": {"epss_score": 0.00903, "epss_percentile": 0.75206}, "CVE-2021-24200": {"epss_score": 0.00903, "epss_percentile": 0.75206}, "CVE-2021-24201": {"epss_score": 0.00108, "epss_percentile": 0.29804}, "CVE-2021-24202": {"epss_score": 0.00099, "epss_percentile": 0.27846}, "CVE-2021-24203": {"epss_score": 0.00099, "epss_percentile": 0.27846}, "CVE-2021-24204": {"epss_score": 0.00099, "epss_percentile": 0.27846}, "CVE-2021-24205": {"epss_score": 0.00099, "epss_percentile": 0.27846}, "CVE-2021-24206": {"epss_score": 0.00099, "epss_percentile": 0.27846}, "CVE-2021-24207": {"epss_score": 0.00166, "epss_percentile": 0.38197}, "CVE-2021-24208": {"epss_score": 0.00419, "epss_percentile": 0.61381}, "CVE-2021-24209": {"epss_score": 0.02352, "epss_percentile": 0.84471}, "CVE-2021-24210": {"epss_score": 0.11853, "epss_percentile": 0.93496}, "CVE-2021-24211": {"epss_score": 0.00332, "epss_percentile": 0.55559}, "CVE-2021-24212": {"epss_score": 0.68228, "epss_percentile": 0.98536}, "CVE-2021-24213": {"epss_score": 0.03165, "epss_percentile": 0.86538}, "CVE-2021-24214": {"epss_score": 0.04044, "epss_percentile": 0.8817}, "CVE-2021-24215": {"epss_score": 0.37383, "epss_percentile": 0.97041}, "CVE-2021-24216": {"epss_score": 0.00875, "epss_percentile": 0.74777}, "CVE-2021-24217": {"epss_score": 0.06505, "epss_percentile": 0.90805}, "CVE-2021-24218": {"epss_score": 0.00149, "epss_percentile": 0.35951}, "CVE-2021-24219": {"epss_score": 0.10122, "epss_percentile": 0.92858}, "CVE-2021-24220": {"epss_score": 0.53243, "epss_percentile": 0.97867}, "CVE-2021-24221": {"epss_score": 0.02566, "epss_percentile": 0.85117}, "CVE-2021-24222": {"epss_score": 0.05664, "epss_percentile": 0.90098}, "CVE-2021-24223": {"epss_score": 0.00919, "epss_percentile": 0.75455}, "CVE-2021-24224": {"epss_score": 0.02066, "epss_percentile": 0.83458}, "CVE-2021-24225": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24226": {"epss_score": 0.25403, "epss_percentile": 0.96025}, "CVE-2021-24227": {"epss_score": 0.33001, "epss_percentile": 0.9674}, "CVE-2021-24228": {"epss_score": 0.00861, "epss_percentile": 0.7456}, "CVE-2021-24229": {"epss_score": 0.00635, "epss_percentile": 0.69825}, "CVE-2021-24230": {"epss_score": 0.0012, "epss_percentile": 0.31793}, "CVE-2021-24231": {"epss_score": 0.00089, "epss_percentile": 0.25807}, "CVE-2021-24232": {"epss_score": 0.00332, "epss_percentile": 0.55559}, "CVE-2021-24233": {"epss_score": 0.07769, "epss_percentile": 0.91672}, "CVE-2021-24234": {"epss_score": 0.00265, "epss_percentile": 0.49813}, "CVE-2021-24235": {"epss_score": 0.26734, "epss_percentile": 0.96171}, "CVE-2021-24236": {"epss_score": 0.7493, "epss_percentile": 0.98824}, "CVE-2021-24237": {"epss_score": 0.63261, "epss_percentile": 0.98325}, "CVE-2021-24238": {"epss_score": 0.00296, "epss_percentile": 0.52587}, "CVE-2021-24239": {"epss_score": 0.04595, "epss_percentile": 0.88897}, "CVE-2021-24240": {"epss_score": 0.08068, "epss_percentile": 0.91865}, "CVE-2021-24241": {"epss_score": 0.00628, "epss_percentile": 0.69646}, "CVE-2021-24242": {"epss_score": 0.00224, "epss_percentile": 0.45071}, "CVE-2021-24243": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24244": {"epss_score": 0.00188, "epss_percentile": 0.4081}, "CVE-2021-24245": {"epss_score": 0.17943, "epss_percentile": 0.94931}, "CVE-2021-24246": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24247": {"epss_score": 0.00341, "epss_percentile": 0.56295}, "CVE-2021-24248": {"epss_score": 0.00875, "epss_percentile": 0.74777}, "CVE-2021-24249": {"epss_score": 0.00121, "epss_percentile": 0.32014}, "CVE-2021-24250": {"epss_score": 0.00332, "epss_percentile": 0.55559}, "CVE-2021-24251": {"epss_score": 0.00142, "epss_percentile": 0.34966}, "CVE-2021-24252": {"epss_score": 0.00991, "epss_percentile": 0.76388}, "CVE-2021-24253": {"epss_score": 0.01964, "epss_percentile": 0.83074}, "CVE-2021-24254": {"epss_score": 0.00907, "epss_percentile": 0.75271}, "CVE-2021-24255": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24256": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24257": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24258": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24259": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24260": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24261": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24262": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24263": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24264": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24265": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24266": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24267": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24268": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24269": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24270": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24271": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24272": {"epss_score": 0.00245, "epss_percentile": 0.47639}, "CVE-2021-24273": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24274": {"epss_score": 0.05512, "epss_percentile": 0.89947}, "CVE-2021-24275": {"epss_score": 0.05897, "epss_percentile": 0.90305}, "CVE-2021-24276": {"epss_score": 0.08366, "epss_percentile": 0.9201}, "CVE-2021-24277": {"epss_score": 0.00332, "epss_percentile": 0.55559}, "CVE-2021-24278": {"epss_score": 0.35223, "epss_percentile": 0.96894}, "CVE-2021-24279": {"epss_score": 0.00256, "epss_percentile": 0.48783}, "CVE-2021-24280": {"epss_score": 0.03375, "epss_percentile": 0.87017}, "CVE-2021-24281": {"epss_score": 0.00155, "epss_percentile": 0.36807}, "CVE-2021-24282": {"epss_score": 0.00248, "epss_percentile": 0.47966}, "CVE-2021-24283": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24284": {"epss_score": 0.73011, "epss_percentile": 0.98732}, "CVE-2021-24285": {"epss_score": 0.90112, "epss_percentile": 0.99561}, "CVE-2021-24286": {"epss_score": 0.52303, "epss_percentile": 0.97818}, "CVE-2021-24287": {"epss_score": 0.33301, "epss_percentile": 0.96761}, "CVE-2021-24288": {"epss_score": 0.04398, "epss_percentile": 0.88643}, "CVE-2021-24289": {"epss_score": 0.01005, "epss_percentile": 0.76538}, "CVE-2021-24290": {"epss_score": 0.03211, "epss_percentile": 0.86654}, "CVE-2021-24291": {"epss_score": 0.14622, "epss_percentile": 0.94252}, "CVE-2021-24292": {"epss_score": 0.00222, "epss_percentile": 0.44823}, "CVE-2021-24293": {"epss_score": 0.00392, "epss_percentile": 0.59658}, "CVE-2021-24294": {"epss_score": 0.0775, "epss_percentile": 0.91658}, "CVE-2021-24295": {"epss_score": 0.26068, "epss_percentile": 0.96107}, "CVE-2021-24296": {"epss_score": 0.00186, "epss_percentile": 0.406}, "CVE-2021-24297": {"epss_score": 0.00387, "epss_percentile": 0.59302}, "CVE-2021-24298": {"epss_score": 0.13939, "epss_percentile": 0.94097}, "CVE-2021-24299": {"epss_score": 0.00344, "epss_percentile": 0.56525}, "CVE-2021-24300": {"epss_score": 0.03405, "epss_percentile": 0.87074}, "CVE-2021-24301": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24302": {"epss_score": 0.00332, "epss_percentile": 0.55559}, "CVE-2021-24303": {"epss_score": 0.00582, "epss_percentile": 0.68293}, "CVE-2021-24304": {"epss_score": 0.02446, "epss_percentile": 0.8477}, "CVE-2021-24305": {"epss_score": 0.02316, "epss_percentile": 0.84357}, "CVE-2021-24306": {"epss_score": 0.00363, "epss_percentile": 0.57823}, "CVE-2021-24307": {"epss_score": 0.41776, "epss_percentile": 0.97295}, "CVE-2021-24308": {"epss_score": 0.0027, "epss_percentile": 0.50252}, "CVE-2021-24309": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24310": {"epss_score": 0.00186, "epss_percentile": 0.406}, "CVE-2021-24311": {"epss_score": 0.01894, "epss_percentile": 0.82741}, "CVE-2021-24312": {"epss_score": 0.01432, "epss_percentile": 0.80251}, "CVE-2021-24313": {"epss_score": 0.00332, "epss_percentile": 0.55559}, "CVE-2021-24314": {"epss_score": 0.01021, "epss_percentile": 0.7675}, "CVE-2021-24315": {"epss_score": 0.00414, "epss_percentile": 0.61098}, "CVE-2021-24316": {"epss_score": 0.57424, "epss_percentile": 0.98061}, "CVE-2021-24317": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2021-24318": {"epss_score": 0.00392, "epss_percentile": 0.59642}, "CVE-2021-24319": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24320": {"epss_score": 0.50348, "epss_percentile": 0.97733}, "CVE-2021-24321": {"epss_score": 0.00758, "epss_percentile": 0.72778}, "CVE-2021-24322": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24323": {"epss_score": 0.00377, "epss_percentile": 0.58692}, "CVE-2021-24324": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24325": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2021-24326": {"epss_score": 0.00332, "epss_percentile": 0.55559}, "CVE-2021-24327": {"epss_score": 0.00186, "epss_percentile": 0.406}, "CVE-2021-24328": {"epss_score": 0.0018, "epss_percentile": 0.39891}, "CVE-2021-24329": {"epss_score": 0.00266, "epss_percentile": 0.49914}, "CVE-2021-24330": {"epss_score": 0.00186, "epss_percentile": 0.406}, "CVE-2021-24331": {"epss_score": 0.00186, "epss_percentile": 0.406}, "CVE-2021-24332": {"epss_score": 0.00186, "epss_percentile": 0.406}, "CVE-2021-24333": {"epss_score": 0.00223, "epss_percentile": 0.44854}, "CVE-2021-24334": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24335": {"epss_score": 0.45587, "epss_percentile": 0.97492}, "CVE-2021-24336": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24337": {"epss_score": 0.00582, "epss_percentile": 0.68293}, "CVE-2021-24338": {"epss_score": 0.01115, "epss_percentile": 0.77708}, "CVE-2021-24339": {"epss_score": 0.00602, "epss_percentile": 0.68885}, "CVE-2021-24340": {"epss_score": 0.8326, "epss_percentile": 0.9924}, "CVE-2021-24341": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24342": {"epss_score": 0.02816, "epss_percentile": 0.85732}, "CVE-2021-24343": {"epss_score": 0.0042, "epss_percentile": 0.61451}, "CVE-2021-24344": {"epss_score": 0.00445, "epss_percentile": 0.62876}, "CVE-2021-24345": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24346": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24347": {"epss_score": 0.81417, "epss_percentile": 0.99137}, "CVE-2021-24348": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24349": {"epss_score": 0.00108, "epss_percentile": 0.29796}, "CVE-2021-24350": {"epss_score": 0.0265, "epss_percentile": 0.85341}, "CVE-2021-24351": {"epss_score": 0.54267, "epss_percentile": 0.97917}, "CVE-2021-24352": {"epss_score": 0.00898, "epss_percentile": 0.7514}, "CVE-2021-24353": {"epss_score": 0.00898, "epss_percentile": 0.7514}, "CVE-2021-24354": {"epss_score": 0.01126, "epss_percentile": 0.77816}, "CVE-2021-24355": {"epss_score": 0.0023, "epss_percentile": 0.45671}, "CVE-2021-24356": {"epss_score": 0.44007, "epss_percentile": 0.97414}, "CVE-2021-24357": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24358": {"epss_score": 0.02906, "epss_percentile": 0.85962}, "CVE-2021-24359": {"epss_score": 0.00435, "epss_percentile": 0.62324}, "CVE-2021-24360": {"epss_score": 0.00498, "epss_percentile": 0.65232}, "CVE-2021-24361": {"epss_score": 0.01126, "epss_percentile": 0.77815}, "CVE-2021-24362": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24363": {"epss_score": 0.0035, "epss_percentile": 0.56967}, "CVE-2021-24364": {"epss_score": 0.02314, "epss_percentile": 0.84354}, "CVE-2021-24365": {"epss_score": 0.00295, "epss_percentile": 0.52517}, "CVE-2021-24366": {"epss_score": 0.00371, "epss_percentile": 0.58361}, "CVE-2021-24367": {"epss_score": 0.00368, "epss_percentile": 0.58181}, "CVE-2021-24368": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2021-24369": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24370": {"epss_score": 0.80681, "epss_percentile": 0.99101}, "CVE-2021-24371": {"epss_score": 0.00224, "epss_percentile": 0.44981}, "CVE-2021-24372": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24373": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24374": {"epss_score": 0.00789, "epss_percentile": 0.7336}, "CVE-2021-24375": {"epss_score": 0.03013, "epss_percentile": 0.86202}, "CVE-2021-24376": {"epss_score": 0.10014, "epss_percentile": 0.92817}, "CVE-2021-24377": {"epss_score": 0.00485, "epss_percentile": 0.6474}, "CVE-2021-24378": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2021-24379": {"epss_score": 0.00296, "epss_percentile": 0.52534}, "CVE-2021-24380": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24381": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24382": {"epss_score": 0.00419, "epss_percentile": 0.61381}, "CVE-2021-24383": {"epss_score": 0.00868, "epss_percentile": 0.74671}, "CVE-2021-24384": {"epss_score": 0.04455, "epss_percentile": 0.88712}, "CVE-2021-24385": {"epss_score": 0.09019, "epss_percentile": 0.92369}, "CVE-2021-24386": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24387": {"epss_score": 0.42184, "epss_percentile": 0.97317}, "CVE-2021-24388": {"epss_score": 0.00085, "epss_percentile": 0.25028}, "CVE-2021-24389": {"epss_score": 0.13968, "epss_percentile": 0.94102}, "CVE-2021-24390": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24391": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24392": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24393": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24394": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24395": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24396": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24397": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24398": {"epss_score": 0.0062, "epss_percentile": 0.6945}, "CVE-2021-24399": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24400": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24401": {"epss_score": 0.0062, "epss_percentile": 0.6945}, "CVE-2021-24402": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24403": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24404": {"epss_score": 0.00582, "epss_percentile": 0.68293}, "CVE-2021-24405": {"epss_score": 0.0383, "epss_percentile": 0.87805}, "CVE-2021-24406": {"epss_score": 0.08523, "epss_percentile": 0.92101}, "CVE-2021-24407": {"epss_score": 0.20956, "epss_percentile": 0.95446}, "CVE-2021-24408": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24409": {"epss_score": 0.13254, "epss_percentile": 0.93916}, "CVE-2021-24410": {"epss_score": 0.00099, "epss_percentile": 0.27841}, "CVE-2021-24411": {"epss_score": 0.00099, "epss_percentile": 0.27841}, "CVE-2021-24412": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24413": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24414": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24415": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24416": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24418": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24419": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24420": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24421": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24423": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24424": {"epss_score": 0.00368, "epss_percentile": 0.58181}, "CVE-2021-24425": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24426": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24427": {"epss_score": 0.0042, "epss_percentile": 0.61451}, "CVE-2021-24428": {"epss_score": 0.0041, "epss_percentile": 0.60814}, "CVE-2021-24429": {"epss_score": 0.01192, "epss_percentile": 0.78402}, "CVE-2021-24430": {"epss_score": 0.01033, "epss_percentile": 0.76879}, "CVE-2021-24431": {"epss_score": 0.00144, "epss_percentile": 0.35292}, "CVE-2021-24432": {"epss_score": 0.00372, "epss_percentile": 0.58434}, "CVE-2021-24433": {"epss_score": 0.00266, "epss_percentile": 0.49844}, "CVE-2021-24434": {"epss_score": 0.00099, "epss_percentile": 0.27841}, "CVE-2021-24435": {"epss_score": 0.13254, "epss_percentile": 0.93916}, "CVE-2021-24436": {"epss_score": 0.05838, "epss_percentile": 0.9025}, "CVE-2021-24437": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24438": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2021-24439": {"epss_score": 0.00368, "epss_percentile": 0.58181}, "CVE-2021-24440": {"epss_score": 0.00186, "epss_percentile": 0.406}, "CVE-2021-24441": {"epss_score": 0.0084, "epss_percentile": 0.74215}, "CVE-2021-24442": {"epss_score": 0.72516, "epss_percentile": 0.98714}, "CVE-2021-24443": {"epss_score": 0.00281, "epss_percentile": 0.51119}, "CVE-2021-24444": {"epss_score": 0.01572, "epss_percentile": 0.81096}, "CVE-2021-24445": {"epss_score": 0.0033, "epss_percentile": 0.55486}, "CVE-2021-24446": {"epss_score": 0.00084, "epss_percentile": 0.24901}, "CVE-2021-24447": {"epss_score": 0.0034, "epss_percentile": 0.56232}, "CVE-2021-24448": {"epss_score": 0.00381, "epss_percentile": 0.59022}, "CVE-2021-24450": {"epss_score": 0.00296, "epss_percentile": 0.52627}, "CVE-2021-24451": {"epss_score": 0.00974, "epss_percentile": 0.76168}, "CVE-2021-24452": {"epss_score": 0.09627, "epss_percentile": 0.9263}, "CVE-2021-24453": {"epss_score": 0.07222, "epss_percentile": 0.91334}, "CVE-2021-24454": {"epss_score": 0.01651, "epss_percentile": 0.81569}, "CVE-2021-24455": {"epss_score": 0.00226, "epss_percentile": 0.45334}, "CVE-2021-24456": {"epss_score": 0.00628, "epss_percentile": 0.69649}, "CVE-2021-24457": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24458": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24459": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24460": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24461": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24462": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24463": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24464": {"epss_score": 0.00281, "epss_percentile": 0.51119}, "CVE-2021-24465": {"epss_score": 0.00558, "epss_percentile": 0.67572}, "CVE-2021-24466": {"epss_score": 0.00099, "epss_percentile": 0.27841}, "CVE-2021-24467": {"epss_score": 0.00103, "epss_percentile": 0.2909}, "CVE-2021-24468": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24470": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24471": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24472": {"epss_score": 0.8982, "epss_percentile": 0.99543}, "CVE-2021-24473": {"epss_score": 0.00175, "epss_percentile": 0.39342}, "CVE-2021-24474": {"epss_score": 0.00418, "epss_percentile": 0.61346}, "CVE-2021-24476": {"epss_score": 0.00281, "epss_percentile": 0.51119}, "CVE-2021-24477": {"epss_score": 0.00099, "epss_percentile": 0.27841}, "CVE-2021-24478": {"epss_score": 0.00281, "epss_percentile": 0.51119}, "CVE-2021-24479": {"epss_score": 0.00387, "epss_percentile": 0.5931}, "CVE-2021-24480": {"epss_score": 0.00387, "epss_percentile": 0.5931}, "CVE-2021-24481": {"epss_score": 0.00387, "epss_percentile": 0.5931}, "CVE-2021-24482": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24483": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24484": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24485": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24486": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24487": {"epss_score": 0.00302, "epss_percentile": 0.53158}, "CVE-2021-24488": {"epss_score": 0.11533, "epss_percentile": 0.93397}, "CVE-2021-24489": {"epss_score": 0.00287, "epss_percentile": 0.51837}, "CVE-2021-24490": {"epss_score": 0.00124, "epss_percentile": 0.3246}, "CVE-2021-24491": {"epss_score": 0.00227, "epss_percentile": 0.4537}, "CVE-2021-24492": {"epss_score": 0.00945, "epss_percentile": 0.75799}, "CVE-2021-24493": {"epss_score": 0.01578, "epss_percentile": 0.81125}, "CVE-2021-24494": {"epss_score": 0.00465, "epss_percentile": 0.63759}, "CVE-2021-24495": {"epss_score": 0.32206, "epss_percentile": 0.9668}, "CVE-2021-24496": {"epss_score": 0.0019, "epss_percentile": 0.41049}, "CVE-2021-24497": {"epss_score": 0.00534, "epss_percentile": 0.66784}, "CVE-2021-24498": {"epss_score": 0.25481, "epss_percentile": 0.96033}, "CVE-2021-24499": {"epss_score": 0.93938, "epss_percentile": 0.99872}, "CVE-2021-24500": {"epss_score": 0.00177, "epss_percentile": 0.39526}, "CVE-2021-24501": {"epss_score": 0.00294, "epss_percentile": 0.5242}, "CVE-2021-24502": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24503": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24504": {"epss_score": 0.01368, "epss_percentile": 0.79791}, "CVE-2021-24505": {"epss_score": 0.00281, "epss_percentile": 0.51119}, "CVE-2021-24506": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24507": {"epss_score": 0.44195, "epss_percentile": 0.97423}, "CVE-2021-24508": {"epss_score": 0.14825, "epss_percentile": 0.94295}, "CVE-2021-24509": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24510": {"epss_score": 0.21147, "epss_percentile": 0.9547}, "CVE-2021-24511": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24512": {"epss_score": 0.00281, "epss_percentile": 0.51119}, "CVE-2021-24513": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24514": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24515": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24516": {"epss_score": 0.00287, "epss_percentile": 0.51837}, "CVE-2021-24517": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24518": {"epss_score": 0.00578, "epss_percentile": 0.68206}, "CVE-2021-24519": {"epss_score": 0.00349, "epss_percentile": 0.56873}, "CVE-2021-24520": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24521": {"epss_score": 0.00776, "epss_percentile": 0.73099}, "CVE-2021-24522": {"epss_score": 0.00247, "epss_percentile": 0.47889}, "CVE-2021-24523": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24524": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2021-24525": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24526": {"epss_score": 0.00281, "epss_percentile": 0.51119}, "CVE-2021-24527": {"epss_score": 0.69958, "epss_percentile": 0.9861}, "CVE-2021-24528": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24529": {"epss_score": 0.00188, "epss_percentile": 0.4083}, "CVE-2021-24530": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24531": {"epss_score": 0.00533, "epss_percentile": 0.66773}, "CVE-2021-24533": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24534": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24535": {"epss_score": 0.00099, "epss_percentile": 0.27841}, "CVE-2021-24536": {"epss_score": 0.00099, "epss_percentile": 0.27841}, "CVE-2021-24537": {"epss_score": 0.01033, "epss_percentile": 0.76879}, "CVE-2021-24538": {"epss_score": 0.00346, "epss_percentile": 0.56647}, "CVE-2021-24539": {"epss_score": 0.00287, "epss_percentile": 0.51837}, "CVE-2021-24540": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24541": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24543": {"epss_score": 0.00108, "epss_percentile": 0.29796}, "CVE-2021-24544": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24545": {"epss_score": 0.13323, "epss_percentile": 0.93933}, "CVE-2021-24546": {"epss_score": 0.00852, "epss_percentile": 0.74412}, "CVE-2021-24547": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24548": {"epss_score": 0.00281, "epss_percentile": 0.51119}, "CVE-2021-24549": {"epss_score": 0.01016, "epss_percentile": 0.76672}, "CVE-2021-24550": {"epss_score": 0.00903, "epss_percentile": 0.75197}, "CVE-2021-24551": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2021-24552": {"epss_score": 0.00986, "epss_percentile": 0.76331}, "CVE-2021-24553": {"epss_score": 0.00986, "epss_percentile": 0.76331}, "CVE-2021-24554": {"epss_score": 0.40697, "epss_percentile": 0.97233}, "CVE-2021-24555": {"epss_score": 0.00284, "epss_percentile": 0.51464}, "CVE-2021-24556": {"epss_score": 0.01321, "epss_percentile": 0.79442}, "CVE-2021-24557": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24558": {"epss_score": 0.00247, "epss_percentile": 0.47836}, "CVE-2021-24559": {"epss_score": 0.00155, "epss_percentile": 0.36847}, "CVE-2021-24560": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24561": {"epss_score": 0.00202, "epss_percentile": 0.42443}, "CVE-2021-24562": {"epss_score": 0.00609, "epss_percentile": 0.69088}, "CVE-2021-24563": {"epss_score": 0.22184, "epss_percentile": 0.95605}, "CVE-2021-24564": {"epss_score": 0.00188, "epss_percentile": 0.4083}, "CVE-2021-24565": {"epss_score": 0.00204, "epss_percentile": 0.42592}, "CVE-2021-24566": {"epss_score": 0.01802, "epss_percentile": 0.8233}, "CVE-2021-24567": {"epss_score": 0.0024, "epss_percentile": 0.4696}, "CVE-2021-24568": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24569": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2021-24570": {"epss_score": 0.00158, "epss_percentile": 0.37154}, "CVE-2021-24571": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24572": {"epss_score": 0.00142, "epss_percentile": 0.34966}, "CVE-2021-24574": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24575": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2021-24576": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24577": {"epss_score": 0.00285, "epss_percentile": 0.51541}, "CVE-2021-24578": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24579": {"epss_score": 0.00776, "epss_percentile": 0.73103}, "CVE-2021-24580": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24581": {"epss_score": 0.03701, "epss_percentile": 0.87592}, "CVE-2021-24582": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24583": {"epss_score": 0.00092, "epss_percentile": 0.26512}, "CVE-2021-24584": {"epss_score": 0.00118, "epss_percentile": 0.31405}, "CVE-2021-24585": {"epss_score": 0.00559, "epss_percentile": 0.67627}, "CVE-2021-24586": {"epss_score": 0.00144, "epss_percentile": 0.35292}, "CVE-2021-24587": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24588": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2021-24590": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24591": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24592": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24593": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24594": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24595": {"epss_score": 0.00154, "epss_percentile": 0.36661}, "CVE-2021-24596": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2021-24597": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24598": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24599": {"epss_score": 0.00189, "epss_percentile": 0.40956}, "CVE-2021-24600": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2021-24601": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-24602": {"epss_score": 0.00659, "epss_percentile": 0.70511}, "CVE-2021-24603": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24604": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2021-24605": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24606": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24607": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24608": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24609": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24610": {"epss_score": 0.01572, "epss_percentile": 0.81096}, "CVE-2021-24611": {"epss_score": 0.00085, "epss_percentile": 0.25028}, "CVE-2021-24612": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24613": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24614": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24615": {"epss_score": 0.00099, "epss_percentile": 0.27841}, "CVE-2021-24616": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24617": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24618": {"epss_score": 0.00198, "epss_percentile": 0.41991}, "CVE-2021-24619": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24620": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2021-24621": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2021-24622": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2021-24623": {"epss_score": 0.00308, "epss_percentile": 0.53628}, "CVE-2021-24624": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2021-24625": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24626": {"epss_score": 0.00194, "epss_percentile": 0.41549}, "CVE-2021-24627": {"epss_score": 0.25395, "epss_percentile": 0.96023}, "CVE-2021-24628": {"epss_score": 0.00903, "epss_percentile": 0.75197}, "CVE-2021-24629": {"epss_score": 0.00903, "epss_percentile": 0.75197}, "CVE-2021-24630": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2021-24631": {"epss_score": 0.00768, "epss_percentile": 0.72965}, "CVE-2021-24632": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24633": {"epss_score": 0.0017, "epss_percentile": 0.38742}, "CVE-2021-24634": {"epss_score": 0.00197, "epss_percentile": 0.41908}, "CVE-2021-24635": {"epss_score": 0.00162, "epss_percentile": 0.37658}, "CVE-2021-24636": {"epss_score": 0.0012, "epss_percentile": 0.31793}, "CVE-2021-24637": {"epss_score": 0.00197, "epss_percentile": 0.41908}, "CVE-2021-24638": {"epss_score": 0.0399, "epss_percentile": 0.8807}, "CVE-2021-24639": {"epss_score": 0.003, "epss_percentile": 0.52939}, "CVE-2021-24640": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24641": {"epss_score": 0.00089, "epss_percentile": 0.25807}, "CVE-2021-24642": {"epss_score": 0.00154, "epss_percentile": 0.36661}, "CVE-2021-24643": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24644": {"epss_score": 0.20545, "epss_percentile": 0.95376}, "CVE-2021-24645": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24646": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24647": {"epss_score": 0.85031, "epss_percentile": 0.99313}, "CVE-2021-24648": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24649": {"epss_score": 0.00409, "epss_percentile": 0.60755}, "CVE-2021-24651": {"epss_score": 0.0177, "epss_percentile": 0.82191}, "CVE-2021-24652": {"epss_score": 0.00183, "epss_percentile": 0.40356}, "CVE-2021-24653": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24654": {"epss_score": 0.00285, "epss_percentile": 0.51541}, "CVE-2021-24655": {"epss_score": 0.00695, "epss_percentile": 0.71373}, "CVE-2021-24656": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2021-24657": {"epss_score": 0.01315, "epss_percentile": 0.79403}, "CVE-2021-24658": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24659": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24660": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24661": {"epss_score": 0.00237, "epss_percentile": 0.46712}, "CVE-2021-24662": {"epss_score": 0.00903, "epss_percentile": 0.75197}, "CVE-2021-24663": {"epss_score": 0.00875, "epss_percentile": 0.74777}, "CVE-2021-24664": {"epss_score": 0.01366, "epss_percentile": 0.7978}, "CVE-2021-24665": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24666": {"epss_score": 0.80649, "epss_percentile": 0.99099}, "CVE-2021-24667": {"epss_score": 0.00247, "epss_percentile": 0.47836}, "CVE-2021-24668": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24669": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24670": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24671": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24672": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24673": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24674": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2021-24675": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24676": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24677": {"epss_score": 0.00642, "epss_percentile": 0.7002}, "CVE-2021-24678": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24679": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24680": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24681": {"epss_score": 0.00681, "epss_percentile": 0.71041}, "CVE-2021-24682": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24683": {"epss_score": 0.00108, "epss_percentile": 0.29796}, "CVE-2021-24684": {"epss_score": 0.11883, "epss_percentile": 0.93504}, "CVE-2021-24685": {"epss_score": 0.00137, "epss_percentile": 0.34315}, "CVE-2021-24686": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24687": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24688": {"epss_score": 0.00085, "epss_percentile": 0.25135}, "CVE-2021-24689": {"epss_score": 0.00846, "epss_percentile": 0.74328}, "CVE-2021-24690": {"epss_score": 0.00247, "epss_percentile": 0.47836}, "CVE-2021-24691": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2021-24692": {"epss_score": 0.00741, "epss_percentile": 0.72439}, "CVE-2021-24693": {"epss_score": 0.0062, "epss_percentile": 0.69444}, "CVE-2021-24694": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24695": {"epss_score": 0.01339, "epss_percentile": 0.79571}, "CVE-2021-24696": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-24697": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24698": {"epss_score": 0.0014, "epss_percentile": 0.34745}, "CVE-2021-24699": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24700": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24701": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24702": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24703": {"epss_score": 0.00124, "epss_percentile": 0.32465}, "CVE-2021-24704": {"epss_score": 0.0011, "epss_percentile": 0.30196}, "CVE-2021-24705": {"epss_score": 0.00097, "epss_percentile": 0.2746}, "CVE-2021-24706": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24707": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24708": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24709": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2021-24710": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24711": {"epss_score": 0.00148, "epss_percentile": 0.35822}, "CVE-2021-24712": {"epss_score": 0.00255, "epss_percentile": 0.487}, "CVE-2021-24713": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24714": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24715": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2021-24716": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24717": {"epss_score": 0.00241, "epss_percentile": 0.47264}, "CVE-2021-24718": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24719": {"epss_score": 0.00717, "epss_percentile": 0.7188}, "CVE-2021-24720": {"epss_score": 0.00398, "epss_percentile": 0.60086}, "CVE-2021-24721": {"epss_score": 0.00282, "epss_percentile": 0.51212}, "CVE-2021-24722": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24723": {"epss_score": 0.00197, "epss_percentile": 0.41908}, "CVE-2021-24724": {"epss_score": 0.00252, "epss_percentile": 0.48387}, "CVE-2021-24725": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24726": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2021-24727": {"epss_score": 0.00856, "epss_percentile": 0.74478}, "CVE-2021-24728": {"epss_score": 0.01483, "epss_percentile": 0.80584}, "CVE-2021-24729": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24730": {"epss_score": 0.00072, "epss_percentile": 0.22389}, "CVE-2021-24731": {"epss_score": 0.53132, "epss_percentile": 0.97857}, "CVE-2021-24732": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24733": {"epss_score": 0.00186, "epss_percentile": 0.40687}, "CVE-2021-24734": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24735": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2021-24736": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24737": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2021-24738": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24739": {"epss_score": 0.00427, "epss_percentile": 0.61898}, "CVE-2021-24740": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2021-24741": {"epss_score": 0.58256, "epss_percentile": 0.98104}, "CVE-2021-24742": {"epss_score": 0.0019, "epss_percentile": 0.41122}, "CVE-2021-24743": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24744": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24745": {"epss_score": 0.00197, "epss_percentile": 0.41908}, "CVE-2021-24746": {"epss_score": 0.02255, "epss_percentile": 0.84166}, "CVE-2021-24747": {"epss_score": 0.00849, "epss_percentile": 0.74377}, "CVE-2021-24748": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2021-24749": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24750": {"epss_score": 0.69584, "epss_percentile": 0.98593}, "CVE-2021-24751": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24752": {"epss_score": 0.00128, "epss_percentile": 0.32956}, "CVE-2021-24753": {"epss_score": 0.00666, "epss_percentile": 0.70683}, "CVE-2021-24754": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24755": {"epss_score": 0.00661, "epss_percentile": 0.70577}, "CVE-2021-24756": {"epss_score": 0.14825, "epss_percentile": 0.94295}, "CVE-2021-24757": {"epss_score": 0.00456, "epss_percentile": 0.63317}, "CVE-2021-24758": {"epss_score": 0.00501, "epss_percentile": 0.65342}, "CVE-2021-24759": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24760": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24761": {"epss_score": 0.00226, "epss_percentile": 0.4528}, "CVE-2021-24762": {"epss_score": 0.84686, "epss_percentile": 0.993}, "CVE-2021-24763": {"epss_score": 0.00535, "epss_percentile": 0.66826}, "CVE-2021-24764": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24765": {"epss_score": 0.0323, "epss_percentile": 0.86696}, "CVE-2021-24766": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2021-24767": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24768": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24769": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24770": {"epss_score": 0.00231, "epss_percentile": 0.45851}, "CVE-2021-24771": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24772": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24773": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24774": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24775": {"epss_score": 0.00619, "epss_percentile": 0.69437}, "CVE-2021-24776": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24777": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24778": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24779": {"epss_score": 0.00236, "epss_percentile": 0.46452}, "CVE-2021-24780": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24781": {"epss_score": 0.0014, "epss_percentile": 0.34745}, "CVE-2021-24782": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24783": {"epss_score": 0.0019, "epss_percentile": 0.41122}, "CVE-2021-24784": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2021-24785": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24786": {"epss_score": 0.04568, "epss_percentile": 0.88859}, "CVE-2021-24787": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24788": {"epss_score": 0.00234, "epss_percentile": 0.46161}, "CVE-2021-24789": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24790": {"epss_score": 0.00121, "epss_percentile": 0.31875}, "CVE-2021-24791": {"epss_score": 0.06309, "epss_percentile": 0.90661}, "CVE-2021-24792": {"epss_score": 0.12126, "epss_percentile": 0.93575}, "CVE-2021-24793": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24794": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2021-24795": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24796": {"epss_score": 0.12126, "epss_percentile": 0.93575}, "CVE-2021-24797": {"epss_score": 0.12126, "epss_percentile": 0.93575}, "CVE-2021-24798": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24799": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24800": {"epss_score": 0.00153, "epss_percentile": 0.36583}, "CVE-2021-24801": {"epss_score": 0.00119, "epss_percentile": 0.31538}, "CVE-2021-24802": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24803": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-24804": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-24805": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24806": {"epss_score": 0.00143, "epss_percentile": 0.35181}, "CVE-2021-24807": {"epss_score": 0.04148, "epss_percentile": 0.88316}, "CVE-2021-24808": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24809": {"epss_score": 0.003, "epss_percentile": 0.52964}, "CVE-2021-24810": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24811": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24812": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24813": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24814": {"epss_score": 0.17231, "epss_percentile": 0.94803}, "CVE-2021-24815": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24816": {"epss_score": 0.0014, "epss_percentile": 0.34745}, "CVE-2021-24817": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24818": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24819": {"epss_score": 0.00186, "epss_percentile": 0.40687}, "CVE-2021-24820": {"epss_score": 0.00625, "epss_percentile": 0.6958}, "CVE-2021-24821": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24822": {"epss_score": 0.00107, "epss_percentile": 0.29602}, "CVE-2021-24823": {"epss_score": 0.00165, "epss_percentile": 0.38135}, "CVE-2021-24824": {"epss_score": 0.00172, "epss_percentile": 0.39016}, "CVE-2021-24825": {"epss_score": 0.00089, "epss_percentile": 0.25808}, "CVE-2021-24826": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24827": {"epss_score": 0.72386, "epss_percentile": 0.98706}, "CVE-2021-24828": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24829": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2021-24830": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2021-24831": {"epss_score": 0.00898, "epss_percentile": 0.75146}, "CVE-2021-24832": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24833": {"epss_score": 0.00231, "epss_percentile": 0.4578}, "CVE-2021-24834": {"epss_score": 0.00244, "epss_percentile": 0.47612}, "CVE-2021-24835": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24836": {"epss_score": 0.00071, "epss_percentile": 0.22191}, "CVE-2021-24837": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2021-24838": {"epss_score": 0.02345, "epss_percentile": 0.84448}, "CVE-2021-24839": {"epss_score": 0.01009, "epss_percentile": 0.76584}, "CVE-2021-24840": {"epss_score": 0.00367, "epss_percentile": 0.58136}, "CVE-2021-24841": {"epss_score": 0.00338, "epss_percentile": 0.5607}, "CVE-2021-24842": {"epss_score": 0.00146, "epss_percentile": 0.35533}, "CVE-2021-24843": {"epss_score": 0.00153, "epss_percentile": 0.36512}, "CVE-2021-24844": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24845": {"epss_score": 0.0044, "epss_percentile": 0.62631}, "CVE-2021-24846": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2021-24847": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2021-24848": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2021-24849": {"epss_score": 0.6198, "epss_percentile": 0.9827}, "CVE-2021-24850": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24851": {"epss_score": 0.00186, "epss_percentile": 0.40687}, "CVE-2021-24852": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2021-24853": {"epss_score": 0.00112, "epss_percentile": 0.30476}, "CVE-2021-24854": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24855": {"epss_score": 0.00197, "epss_percentile": 0.41908}, "CVE-2021-24856": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24857": {"epss_score": 0.00795, "epss_percentile": 0.73474}, "CVE-2021-24858": {"epss_score": 0.00903, "epss_percentile": 0.75197}, "CVE-2021-24859": {"epss_score": 0.00186, "epss_percentile": 0.40687}, "CVE-2021-24860": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24861": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24862": {"epss_score": 0.42876, "epss_percentile": 0.9736}, "CVE-2021-24863": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2021-24864": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2021-24865": {"epss_score": 0.00534, "epss_percentile": 0.66784}, "CVE-2021-24866": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2021-24867": {"epss_score": 0.06685, "epss_percentile": 0.90944}, "CVE-2021-24868": {"epss_score": 0.00274, "epss_percentile": 0.5052}, "CVE-2021-24869": {"epss_score": 0.00595, "epss_percentile": 0.68684}, "CVE-2021-24870": {"epss_score": 0.0013, "epss_percentile": 0.33297}, "CVE-2021-24871": {"epss_score": 0.00295, "epss_percentile": 0.52517}, "CVE-2021-24872": {"epss_score": 0.00545, "epss_percentile": 0.67155}, "CVE-2021-24873": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2021-24874": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2021-24875": {"epss_score": 0.16493, "epss_percentile": 0.94679}, "CVE-2021-24876": {"epss_score": 0.00578, "epss_percentile": 0.68192}, "CVE-2021-24877": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24878": {"epss_score": 0.00864, "epss_percentile": 0.74611}, "CVE-2021-24879": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2021-24880": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24881": {"epss_score": 0.00606, "epss_percentile": 0.69013}, "CVE-2021-24882": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24883": {"epss_score": 0.00231, "epss_percentile": 0.4578}, "CVE-2021-24884": {"epss_score": 0.19162, "epss_percentile": 0.95141}, "CVE-2021-24885": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24888": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2021-24889": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-24890": {"epss_score": 0.00221, "epss_percentile": 0.44641}, "CVE-2021-24891": {"epss_score": 0.09482, "epss_percentile": 0.92566}, "CVE-2021-24892": {"epss_score": 0.01678, "epss_percentile": 0.81718}, "CVE-2021-24893": {"epss_score": 0.00634, "epss_percentile": 0.69806}, "CVE-2021-24894": {"epss_score": 0.00485, "epss_percentile": 0.64709}, "CVE-2021-24895": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24896": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24897": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24898": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24899": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24900": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2021-24901": {"epss_score": 0.03035, "epss_percentile": 0.8626}, "CVE-2021-24902": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24903": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24904": {"epss_score": 0.03035, "epss_percentile": 0.8626}, "CVE-2021-24905": {"epss_score": 0.00121, "epss_percentile": 0.31883}, "CVE-2021-24906": {"epss_score": 0.01891, "epss_percentile": 0.82728}, "CVE-2021-24907": {"epss_score": 0.00471, "epss_percentile": 0.64022}, "CVE-2021-24908": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24909": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2021-24910": {"epss_score": 0.10373, "epss_percentile": 0.92964}, "CVE-2021-24911": {"epss_score": 0.0046, "epss_percentile": 0.63534}, "CVE-2021-24912": {"epss_score": 0.00198, "epss_percentile": 0.41984}, "CVE-2021-24913": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24914": {"epss_score": 0.00129, "epss_percentile": 0.33212}, "CVE-2021-24915": {"epss_score": 0.70278, "epss_percentile": 0.98626}, "CVE-2021-24916": {"epss_score": 0.03284, "epss_percentile": 0.86821}, "CVE-2021-24917": {"epss_score": 0.74492, "epss_percentile": 0.98802}, "CVE-2021-24918": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24919": {"epss_score": 0.00879, "epss_percentile": 0.74839}, "CVE-2021-24920": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24921": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24922": {"epss_score": 0.00107, "epss_percentile": 0.29686}, "CVE-2021-24923": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24924": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24925": {"epss_score": 0.00293, "epss_percentile": 0.52337}, "CVE-2021-24926": {"epss_score": 0.09793, "epss_percentile": 0.92704}, "CVE-2021-24927": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24928": {"epss_score": 0.00369, "epss_percentile": 0.58229}, "CVE-2021-24930": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-24931": {"epss_score": 0.71971, "epss_percentile": 0.9869}, "CVE-2021-24932": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24933": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24934": {"epss_score": 0.03752, "epss_percentile": 0.87675}, "CVE-2021-24935": {"epss_score": 0.00293, "epss_percentile": 0.52337}, "CVE-2021-24936": {"epss_score": 0.00107, "epss_percentile": 0.29631}, "CVE-2021-24937": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24938": {"epss_score": 0.00293, "epss_percentile": 0.52337}, "CVE-2021-24939": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24940": {"epss_score": 0.01887, "epss_percentile": 0.82715}, "CVE-2021-24941": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24942": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2021-24943": {"epss_score": 0.55452, "epss_percentile": 0.97978}, "CVE-2021-24944": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24945": {"epss_score": 0.00141, "epss_percentile": 0.34907}, "CVE-2021-24946": {"epss_score": 0.60622, "epss_percentile": 0.98213}, "CVE-2021-24947": {"epss_score": 0.10223, "epss_percentile": 0.929}, "CVE-2021-24948": {"epss_score": 0.02727, "epss_percentile": 0.85529}, "CVE-2021-24949": {"epss_score": 0.01503, "epss_percentile": 0.80727}, "CVE-2021-24950": {"epss_score": 0.0013, "epss_percentile": 0.33281}, "CVE-2021-24951": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2021-24952": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2021-24953": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24954": {"epss_score": 0.00216, "epss_percentile": 0.44184}, "CVE-2021-24955": {"epss_score": 0.00216, "epss_percentile": 0.44184}, "CVE-2021-24956": {"epss_score": 0.01515, "epss_percentile": 0.80794}, "CVE-2021-24957": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2021-24958": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24959": {"epss_score": 0.39424, "epss_percentile": 0.9716}, "CVE-2021-24960": {"epss_score": 0.00253, "epss_percentile": 0.48471}, "CVE-2021-24961": {"epss_score": 0.00277, "epss_percentile": 0.50791}, "CVE-2021-24962": {"epss_score": 0.01715, "epss_percentile": 0.81897}, "CVE-2021-24963": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24964": {"epss_score": 0.14825, "epss_percentile": 0.94295}, "CVE-2021-24965": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24966": {"epss_score": 0.04253, "epss_percentile": 0.88454}, "CVE-2021-24967": {"epss_score": 0.12126, "epss_percentile": 0.93575}, "CVE-2021-24968": {"epss_score": 0.00092, "epss_percentile": 0.26438}, "CVE-2021-24969": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24970": {"epss_score": 0.19736, "epss_percentile": 0.95234}, "CVE-2021-24971": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24972": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24973": {"epss_score": 0.04428, "epss_percentile": 0.88677}, "CVE-2021-24974": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-24975": {"epss_score": 0.0352, "epss_percentile": 0.87286}, "CVE-2021-24976": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24977": {"epss_score": 0.03429, "epss_percentile": 0.8712}, "CVE-2021-24978": {"epss_score": 0.00109, "epss_percentile": 0.30031}, "CVE-2021-24979": {"epss_score": 0.0269, "epss_percentile": 0.85436}, "CVE-2021-24980": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24981": {"epss_score": 0.00223, "epss_percentile": 0.44945}, "CVE-2021-24982": {"epss_score": 0.00171, "epss_percentile": 0.38787}, "CVE-2021-24983": {"epss_score": 0.00282, "epss_percentile": 0.51269}, "CVE-2021-24984": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24985": {"epss_score": 0.00354, "epss_percentile": 0.57212}, "CVE-2021-24986": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2021-24987": {"epss_score": 0.06052, "epss_percentile": 0.90435}, "CVE-2021-24988": {"epss_score": 0.00123, "epss_percentile": 0.32202}, "CVE-2021-24989": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-24991": {"epss_score": 0.03364, "epss_percentile": 0.86998}, "CVE-2021-24992": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24993": {"epss_score": 0.00175, "epss_percentile": 0.39338}, "CVE-2021-24994": {"epss_score": 0.0352, "epss_percentile": 0.87286}, "CVE-2021-24995": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-24996": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-24997": {"epss_score": 0.04579, "epss_percentile": 0.88873}, "CVE-2021-24998": {"epss_score": 0.00207, "epss_percentile": 0.43189}, "CVE-2021-24999": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25000": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25001": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25002": {"epss_score": 0.01202, "epss_percentile": 0.78489}, "CVE-2021-25003": {"epss_score": 0.92018, "epss_percentile": 0.99686}, "CVE-2021-25004": {"epss_score": 0.00639, "epss_percentile": 0.69939}, "CVE-2021-25005": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-25006": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25007": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2021-25008": {"epss_score": 0.03359, "epss_percentile": 0.86988}, "CVE-2021-25009": {"epss_score": 0.00277, "epss_percentile": 0.50789}, "CVE-2021-25010": {"epss_score": 0.00149, "epss_percentile": 0.35999}, "CVE-2021-25011": {"epss_score": 0.0007, "epss_percentile": 0.21676}, "CVE-2021-25012": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25013": {"epss_score": 0.00118, "epss_percentile": 0.31433}, "CVE-2021-25014": {"epss_score": 0.0018, "epss_percentile": 0.399}, "CVE-2021-25015": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25016": {"epss_score": 0.15671, "epss_percentile": 0.9448}, "CVE-2021-25017": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2021-25018": {"epss_score": 0.00171, "epss_percentile": 0.38837}, "CVE-2021-25019": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2021-25020": {"epss_score": 0.00482, "epss_percentile": 0.6455}, "CVE-2021-25021": {"epss_score": 0.00425, "epss_percentile": 0.61703}, "CVE-2021-25022": {"epss_score": 0.00269, "epss_percentile": 0.50168}, "CVE-2021-25023": {"epss_score": 0.00528, "epss_percentile": 0.6655}, "CVE-2021-25024": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25025": {"epss_score": 0.00071, "epss_percentile": 0.22191}, "CVE-2021-25026": {"epss_score": 0.00195, "epss_percentile": 0.4166}, "CVE-2021-25027": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25028": {"epss_score": 0.04398, "epss_percentile": 0.88643}, "CVE-2021-25029": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-25030": {"epss_score": 0.0071, "epss_percentile": 0.71719}, "CVE-2021-25031": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25032": {"epss_score": 0.81889, "epss_percentile": 0.99163}, "CVE-2021-25033": {"epss_score": 0.01059, "epss_percentile": 0.77152}, "CVE-2021-25034": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25035": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25036": {"epss_score": 0.03985, "epss_percentile": 0.88064}, "CVE-2021-25037": {"epss_score": 0.0131, "epss_percentile": 0.79362}, "CVE-2021-25038": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25039": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25040": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25041": {"epss_score": 0.00149, "epss_percentile": 0.36013}, "CVE-2021-25042": {"epss_score": 0.0013, "epss_percentile": 0.33281}, "CVE-2021-25043": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25044": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2021-25045": {"epss_score": 0.01151, "epss_percentile": 0.78042}, "CVE-2021-25046": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-25047": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25048": {"epss_score": 0.00322, "epss_percentile": 0.54821}, "CVE-2021-25049": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2021-25050": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-25051": {"epss_score": 0.001, "epss_percentile": 0.28512}, "CVE-2021-25052": {"epss_score": 0.42408, "epss_percentile": 0.97331}, "CVE-2021-25053": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-25054": {"epss_score": 0.00661, "epss_percentile": 0.70577}, "CVE-2021-25055": {"epss_score": 0.01696, "epss_percentile": 0.81814}, "CVE-2021-25056": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-25057": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-25058": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-25059": {"epss_score": 0.0024, "epss_percentile": 0.46966}, "CVE-2021-25060": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-25061": {"epss_score": 0.01256, "epss_percentile": 0.78937}, "CVE-2021-25062": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25063": {"epss_score": 0.01155, "epss_percentile": 0.7807}, "CVE-2021-25064": {"epss_score": 0.00753, "epss_percentile": 0.72668}, "CVE-2021-25065": {"epss_score": 0.03142, "epss_percentile": 0.8649}, "CVE-2021-25066": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2021-25067": {"epss_score": 0.0646, "epss_percentile": 0.9077}, "CVE-2021-25068": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-25069": {"epss_score": 0.00666, "epss_percentile": 0.70695}, "CVE-2021-25070": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2021-25071": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25072": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-25073": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-25074": {"epss_score": 0.01001, "epss_percentile": 0.76494}, "CVE-2021-25075": {"epss_score": 0.12492, "epss_percentile": 0.93691}, "CVE-2021-25076": {"epss_score": 0.49762, "epss_percentile": 0.97705}, "CVE-2021-25077": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25078": {"epss_score": 0.05997, "epss_percentile": 0.90391}, "CVE-2021-25079": {"epss_score": 0.03135, "epss_percentile": 0.86479}, "CVE-2021-25080": {"epss_score": 0.51607, "epss_percentile": 0.97789}, "CVE-2021-25081": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-25082": {"epss_score": 0.31753, "epss_percentile": 0.96646}, "CVE-2021-25083": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25084": {"epss_score": 0.0017, "epss_percentile": 0.38742}, "CVE-2021-25085": {"epss_score": 0.03204, "epss_percentile": 0.86628}, "CVE-2021-25086": {"epss_score": 0.16891, "epss_percentile": 0.94743}, "CVE-2021-25087": {"epss_score": 0.01202, "epss_percentile": 0.78489}, "CVE-2021-25088": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-25089": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25090": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-25091": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25092": {"epss_score": 0.00103, "epss_percentile": 0.28963}, "CVE-2021-25093": {"epss_score": 0.00618, "epss_percentile": 0.69384}, "CVE-2021-25094": {"epss_score": 0.90199, "epss_percentile": 0.99568}, "CVE-2021-25095": {"epss_score": 0.00148, "epss_percentile": 0.35892}, "CVE-2021-25096": {"epss_score": 0.00172, "epss_percentile": 0.38954}, "CVE-2021-25097": {"epss_score": 0.0012, "epss_percentile": 0.3178}, "CVE-2021-25098": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2021-25099": {"epss_score": 0.02406, "epss_percentile": 0.84651}, "CVE-2021-25100": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25101": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-25102": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25103": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-25104": {"epss_score": 0.03381, "epss_percentile": 0.87032}, "CVE-2021-25105": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2021-25106": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2021-25107": {"epss_score": 0.12126, "epss_percentile": 0.93575}, "CVE-2021-25108": {"epss_score": 0.00089, "epss_percentile": 0.25807}, "CVE-2021-25109": {"epss_score": 0.00177, "epss_percentile": 0.39629}, "CVE-2021-25110": {"epss_score": 0.00237, "epss_percentile": 0.46712}, "CVE-2021-25111": {"epss_score": 0.01767, "epss_percentile": 0.82177}, "CVE-2021-25112": {"epss_score": 0.05226, "epss_percentile": 0.89633}, "CVE-2021-25113": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-25114": {"epss_score": 0.80944, "epss_percentile": 0.99113}, "CVE-2021-25115": {"epss_score": 0.00197, "epss_percentile": 0.41894}, "CVE-2021-25116": {"epss_score": 0.00097, "epss_percentile": 0.2753}, "CVE-2021-25117": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2021-25118": {"epss_score": 0.27358, "epss_percentile": 0.9624}, "CVE-2021-25119": {"epss_score": 0.00907, "epss_percentile": 0.75271}, "CVE-2021-25120": {"epss_score": 0.54081, "epss_percentile": 0.9791}, "CVE-2021-25121": {"epss_score": 0.00476, "epss_percentile": 0.6427}, "CVE-2021-25122": {"epss_score": 0.02775, "epss_percentile": 0.85635}, "CVE-2021-25123": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2021-25124": {"epss_score": 0.00119, "epss_percentile": 0.31571}, "CVE-2021-25125": {"epss_score": 0.00119, "epss_percentile": 0.31571}, "CVE-2021-25126": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2021-25127": {"epss_score": 0.00099, "epss_percentile": 0.28346}, "CVE-2021-25128": {"epss_score": 0.00119, "epss_percentile": 0.31571}, "CVE-2021-25129": {"epss_score": 0.00119, "epss_percentile": 0.31571}, "CVE-2021-25130": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2021-25131": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2021-25132": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2021-25133": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2021-25134": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2021-25135": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2021-25136": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2021-25137": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2021-25138": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2021-25139": {"epss_score": 0.05332, "epss_percentile": 0.89739}, "CVE-2021-25140": {"epss_score": 0.0741, "epss_percentile": 0.91458}, "CVE-2021-25141": {"epss_score": 0.00127, "epss_percentile": 0.32809}, "CVE-2021-25142": {"epss_score": 0.00141, "epss_percentile": 0.34869}, "CVE-2021-25143": {"epss_score": 0.00666, "epss_percentile": 0.70684}, "CVE-2021-25144": {"epss_score": 0.01444, "epss_percentile": 0.80319}, "CVE-2021-25145": {"epss_score": 0.00164, "epss_percentile": 0.37956}, "CVE-2021-25146": {"epss_score": 0.05053, "epss_percentile": 0.89444}, "CVE-2021-25147": {"epss_score": 0.00125, "epss_percentile": 0.32541}, "CVE-2021-25148": {"epss_score": 0.00559, "epss_percentile": 0.67624}, "CVE-2021-25149": {"epss_score": 0.00714, "epss_percentile": 0.71826}, "CVE-2021-25150": {"epss_score": 0.05063, "epss_percentile": 0.89456}, "CVE-2021-25151": {"epss_score": 0.05679, "epss_percentile": 0.90116}, "CVE-2021-25152": {"epss_score": 0.00981, "epss_percentile": 0.76278}, "CVE-2021-25153": {"epss_score": 0.00286, "epss_percentile": 0.51691}, "CVE-2021-25154": {"epss_score": 0.00758, "epss_percentile": 0.72778}, "CVE-2021-25155": {"epss_score": 0.09926, "epss_percentile": 0.92775}, "CVE-2021-25156": {"epss_score": 0.14768, "epss_percentile": 0.9428}, "CVE-2021-25157": {"epss_score": 0.07362, "epss_percentile": 0.91432}, "CVE-2021-25158": {"epss_score": 0.06721, "epss_percentile": 0.90967}, "CVE-2021-25159": {"epss_score": 0.10935, "epss_percentile": 0.93164}, "CVE-2021-25160": {"epss_score": 0.10132, "epss_percentile": 0.92862}, "CVE-2021-25161": {"epss_score": 0.02593, "epss_percentile": 0.85188}, "CVE-2021-25162": {"epss_score": 0.40269, "epss_percentile": 0.97209}, "CVE-2021-25163": {"epss_score": 0.00938, "epss_percentile": 0.75711}, "CVE-2021-25164": {"epss_score": 0.01123, "epss_percentile": 0.77789}, "CVE-2021-25165": {"epss_score": 0.00938, "epss_percentile": 0.75711}, "CVE-2021-25166": {"epss_score": 0.00965, "epss_percentile": 0.76046}, "CVE-2021-25167": {"epss_score": 0.00965, "epss_percentile": 0.76046}, "CVE-2021-25168": {"epss_score": 0.00131, "epss_percentile": 0.33476}, "CVE-2021-25169": {"epss_score": 0.00131, "epss_percentile": 0.33476}, "CVE-2021-25170": {"epss_score": 0.00131, "epss_percentile": 0.33476}, "CVE-2021-25171": {"epss_score": 0.00131, "epss_percentile": 0.33476}, "CVE-2021-25172": {"epss_score": 0.00223, "epss_percentile": 0.4488}, "CVE-2021-25173": {"epss_score": 0.00336, "epss_percentile": 0.56002}, "CVE-2021-25174": {"epss_score": 0.00396, "epss_percentile": 0.59895}, "CVE-2021-25175": {"epss_score": 0.00263, "epss_percentile": 0.495}, "CVE-2021-25176": {"epss_score": 0.00336, "epss_percentile": 0.56002}, "CVE-2021-25177": {"epss_score": 0.00336, "epss_percentile": 0.56002}, "CVE-2021-25178": {"epss_score": 0.00668, "epss_percentile": 0.70725}, "CVE-2021-25179": {"epss_score": 0.01839, "epss_percentile": 0.82488}, "CVE-2021-25195": {"epss_score": 0.00193, "epss_percentile": 0.41455}, "CVE-2021-25197": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2021-25200": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2021-25201": {"epss_score": 0.00232, "epss_percentile": 0.4594}, "CVE-2021-25202": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2021-25203": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2021-25204": {"epss_score": 0.00129, "epss_percentile": 0.33194}, "CVE-2021-25205": {"epss_score": 0.00492, "epss_percentile": 0.64994}, "CVE-2021-25206": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2021-25207": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2021-25208": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2021-25209": {"epss_score": 0.00444, "epss_percentile": 0.62837}, "CVE-2021-25210": {"epss_score": 0.00944, "epss_percentile": 0.75788}, "CVE-2021-25211": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2021-25212": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2021-25213": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2021-25214": {"epss_score": 0.0132, "epss_percentile": 0.7944}, "CVE-2021-25215": {"epss_score": 0.01015, "epss_percentile": 0.76665}, "CVE-2021-25216": {"epss_score": 0.16004, "epss_percentile": 0.94553}, "CVE-2021-25217": {"epss_score": 0.00488, "epss_percentile": 0.64856}, "CVE-2021-25218": {"epss_score": 0.00396, "epss_percentile": 0.59866}, "CVE-2021-25219": {"epss_score": 0.00706, "epss_percentile": 0.71616}, "CVE-2021-25220": {"epss_score": 0.00091, "epss_percentile": 0.26197}, "CVE-2021-25224": {"epss_score": 0.00069, "epss_percentile": 0.21432}, "CVE-2021-25225": {"epss_score": 0.00069, "epss_percentile": 0.21432}, "CVE-2021-25226": {"epss_score": 0.00069, "epss_percentile": 0.21432}, "CVE-2021-25227": {"epss_score": 0.00091, "epss_percentile": 0.26409}, "CVE-2021-25228": {"epss_score": 0.0034, "epss_percentile": 0.5622}, "CVE-2021-25229": {"epss_score": 0.0038, "epss_percentile": 0.58972}, "CVE-2021-25230": {"epss_score": 0.0038, "epss_percentile": 0.58972}, "CVE-2021-25231": {"epss_score": 0.0034, "epss_percentile": 0.5622}, "CVE-2021-25232": {"epss_score": 0.0038, "epss_percentile": 0.58972}, "CVE-2021-25233": {"epss_score": 0.00343, "epss_percentile": 0.56458}, "CVE-2021-25234": {"epss_score": 0.00343, "epss_percentile": 0.56458}, "CVE-2021-25235": {"epss_score": 0.0038, "epss_percentile": 0.58972}, "CVE-2021-25236": {"epss_score": 0.00421, "epss_percentile": 0.61467}, "CVE-2021-25237": {"epss_score": 0.00375, "epss_percentile": 0.58639}, "CVE-2021-25238": {"epss_score": 0.0038, "epss_percentile": 0.58972}, "CVE-2021-25239": {"epss_score": 0.0034, "epss_percentile": 0.5622}, "CVE-2021-25240": {"epss_score": 0.0034, "epss_percentile": 0.5622}, "CVE-2021-25241": {"epss_score": 0.00421, "epss_percentile": 0.61467}, "CVE-2021-25242": {"epss_score": 0.0034, "epss_percentile": 0.5622}, "CVE-2021-25243": {"epss_score": 0.0034, "epss_percentile": 0.5622}, "CVE-2021-25244": {"epss_score": 0.00375, "epss_percentile": 0.58639}, "CVE-2021-25245": {"epss_score": 0.00375, "epss_percentile": 0.58639}, "CVE-2021-25246": {"epss_score": 0.00356, "epss_percentile": 0.57372}, "CVE-2021-25247": {"epss_score": 0.00088, "epss_percentile": 0.25783}, "CVE-2021-25248": {"epss_score": 0.00148, "epss_percentile": 0.35805}, "CVE-2021-25249": {"epss_score": 0.0008, "epss_percentile": 0.24053}, "CVE-2021-25250": {"epss_score": 0.0007, "epss_percentile": 0.21708}, "CVE-2021-25251": {"epss_score": 0.00862, "epss_percentile": 0.74568}, "CVE-2021-25252": {"epss_score": 0.00063, "epss_percentile": 0.19956}, "CVE-2021-25253": {"epss_score": 0.01093, "epss_percentile": 0.7747}, "CVE-2021-25254": {"epss_score": 0.0005, "epss_percentile": 0.15842}, "CVE-2021-25255": {"epss_score": 0.00174, "epss_percentile": 0.39151}, "CVE-2021-25261": {"epss_score": 0.00033, "epss_percentile": 0.09349}, "CVE-2021-25262": {"epss_score": 0.00036, "epss_percentile": 0.10301}, "CVE-2021-25263": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2021-25264": {"epss_score": 0.00019, "epss_percentile": 0.0429}, "CVE-2021-25265": {"epss_score": 0.00248, "epss_percentile": 0.47973}, "CVE-2021-25266": {"epss_score": 0.00054, "epss_percentile": 0.17331}, "CVE-2021-25267": {"epss_score": 0.00246, "epss_percentile": 0.47749}, "CVE-2021-25268": {"epss_score": 0.00184, "epss_percentile": 0.40444}, "CVE-2021-25269": {"epss_score": 0.00054, "epss_percentile": 0.17048}, "CVE-2021-25270": {"epss_score": 0.0005, "epss_percentile": 0.1585}, "CVE-2021-25271": {"epss_score": 0.0005, "epss_percentile": 0.15979}, "CVE-2021-25273": {"epss_score": 0.00135, "epss_percentile": 0.34045}, "CVE-2021-25274": {"epss_score": 0.5023, "epss_percentile": 0.97728}, "CVE-2021-25275": {"epss_score": 0.00106, "epss_percentile": 0.29412}, "CVE-2021-25276": {"epss_score": 0.00405, "epss_percentile": 0.60477}, "CVE-2021-25277": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2021-25278": {"epss_score": 0.0028, "epss_percentile": 0.51001}, "CVE-2021-25281": {"epss_score": 0.93846, "epss_percentile": 0.99857}, "CVE-2021-25282": {"epss_score": 0.90946, "epss_percentile": 0.99611}, "CVE-2021-25283": {"epss_score": 0.10038, "epss_percentile": 0.92824}, "CVE-2021-25284": {"epss_score": 0.00019, "epss_percentile": 0.04391}, "CVE-2021-25287": {"epss_score": 0.00343, "epss_percentile": 0.56463}, "CVE-2021-25288": {"epss_score": 0.00267, "epss_percentile": 0.49982}, "CVE-2021-25289": {"epss_score": 0.00206, "epss_percentile": 0.43063}, "CVE-2021-25290": {"epss_score": 0.00143, "epss_percentile": 0.35154}, "CVE-2021-25291": {"epss_score": 0.00539, "epss_percentile": 0.66983}, "CVE-2021-25292": {"epss_score": 0.00147, "epss_percentile": 0.35745}, "CVE-2021-25293": {"epss_score": 0.001, "epss_percentile": 0.28539}, "CVE-2021-25294": {"epss_score": 0.27726, "epss_percentile": 0.96276}, "CVE-2021-25295": {"epss_score": 0.00849, "epss_percentile": 0.74368}, "CVE-2021-25296": {"epss_score": 0.93708, "epss_percentile": 0.99836}, "CVE-2021-25297": {"epss_score": 0.60589, "epss_percentile": 0.98211}, "CVE-2021-25298": {"epss_score": 0.8035, "epss_percentile": 0.99083}, "CVE-2021-25299": {"epss_score": 0.7993, "epss_percentile": 0.99063}, "CVE-2021-25306": {"epss_score": 0.0085, "epss_percentile": 0.74392}, "CVE-2021-25309": {"epss_score": 0.00556, "epss_percentile": 0.67528}, "CVE-2021-25310": {"epss_score": 0.06345, "epss_percentile": 0.90686}, "CVE-2021-25311": {"epss_score": 0.02768, "epss_percentile": 0.85615}, "CVE-2021-25312": {"epss_score": 0.00463, "epss_percentile": 0.63635}, "CVE-2021-25313": {"epss_score": 0.00645, "epss_percentile": 0.70109}, "CVE-2021-25314": {"epss_score": 0.00028, "epss_percentile": 0.07539}, "CVE-2021-25315": {"epss_score": 0.00209, "epss_percentile": 0.43317}, "CVE-2021-25316": {"epss_score": 0.00041, "epss_percentile": 0.12213}, "CVE-2021-25317": {"epss_score": 0.00076, "epss_percentile": 0.23248}, "CVE-2021-25318": {"epss_score": 0.0012, "epss_percentile": 0.31731}, "CVE-2021-25319": {"epss_score": 0.00024, "epss_percentile": 0.05993}, "CVE-2021-25320": {"epss_score": 0.00199, "epss_percentile": 0.42133}, "CVE-2021-25321": {"epss_score": 0.0003, "epss_percentile": 0.08299}, "CVE-2021-25322": {"epss_score": 0.00035, "epss_percentile": 0.10116}, "CVE-2021-25323": {"epss_score": 0.00257, "epss_percentile": 0.48877}, "CVE-2021-25324": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-25325": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2021-25326": {"epss_score": 0.00164, "epss_percentile": 0.37986}, "CVE-2021-25327": {"epss_score": 0.00304, "epss_percentile": 0.53263}, "CVE-2021-25328": {"epss_score": 0.0493, "epss_percentile": 0.89296}, "CVE-2021-25329": {"epss_score": 0.00802, "epss_percentile": 0.73585}, "CVE-2021-25330": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2021-25331": {"epss_score": 0.00071, "epss_percentile": 0.22047}, "CVE-2021-25332": {"epss_score": 0.00071, "epss_percentile": 0.22047}, "CVE-2021-25333": {"epss_score": 0.00064, "epss_percentile": 0.20187}, "CVE-2021-25334": {"epss_score": 0.00017, "epss_percentile": 0.03339}, "CVE-2021-25335": {"epss_score": 0.00046, "epss_percentile": 0.14139}, "CVE-2021-25336": {"epss_score": 0.00049, "epss_percentile": 0.15472}, "CVE-2021-25337": {"epss_score": 0.00296, "epss_percentile": 0.52572}, "CVE-2021-25338": {"epss_score": 0.00018, "epss_percentile": 0.03685}, "CVE-2021-25339": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2021-25340": {"epss_score": 0.00017, "epss_percentile": 0.03447}, "CVE-2021-25341": {"epss_score": 0.00054, "epss_percentile": 0.17244}, "CVE-2021-25342": {"epss_score": 0.00054, "epss_percentile": 0.17244}, "CVE-2021-25343": {"epss_score": 0.00054, "epss_percentile": 0.17244}, "CVE-2021-25344": {"epss_score": 0.0002, "epss_percentile": 0.04564}, "CVE-2021-25345": {"epss_score": 0.00016, "epss_percentile": 0.02939}, "CVE-2021-25346": {"epss_score": 0.00573, "epss_percentile": 0.68042}, "CVE-2021-25347": {"epss_score": 0.00015, "epss_percentile": 0.02129}, "CVE-2021-25348": {"epss_score": 0.00059, "epss_percentile": 0.18876}, "CVE-2021-25349": {"epss_score": 0.00033, "epss_percentile": 0.09245}, "CVE-2021-25350": {"epss_score": 0.00049, "epss_percentile": 0.1546}, "CVE-2021-25351": {"epss_score": 0.00049, "epss_percentile": 0.15348}, "CVE-2021-25352": {"epss_score": 0.00037, "epss_percentile": 0.10818}, "CVE-2021-25353": {"epss_score": 0.00035, "epss_percentile": 0.09905}, "CVE-2021-25354": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2021-25355": {"epss_score": 0.00033, "epss_percentile": 0.09245}, "CVE-2021-25356": {"epss_score": 0.00032, "epss_percentile": 0.09073}, "CVE-2021-25357": {"epss_score": 0.00018, "epss_percentile": 0.04044}, "CVE-2021-25358": {"epss_score": 0.00016, "epss_percentile": 0.02894}, "CVE-2021-25359": {"epss_score": 0.00012, "epss_percentile": 0.0135}, "CVE-2021-25360": {"epss_score": 0.00288, "epss_percentile": 0.51885}, "CVE-2021-25361": {"epss_score": 0.00013, "epss_percentile": 0.01489}, "CVE-2021-25362": {"epss_score": 0.00015, "epss_percentile": 0.02503}, "CVE-2021-25363": {"epss_score": 0.00015, "epss_percentile": 0.02503}, "CVE-2021-25364": {"epss_score": 0.0002, "epss_percentile": 0.04433}, "CVE-2021-25365": {"epss_score": 0.00013, "epss_percentile": 0.01546}, "CVE-2021-25366": {"epss_score": 0.00069, "epss_percentile": 0.21614}, "CVE-2021-25367": {"epss_score": 0.00209, "epss_percentile": 0.43334}, "CVE-2021-25368": {"epss_score": 0.00137, "epss_percentile": 0.34262}, "CVE-2021-25369": {"epss_score": 0.00112, "epss_percentile": 0.30496}, "CVE-2021-25370": {"epss_score": 0.00337, "epss_percentile": 0.56037}, "CVE-2021-25371": {"epss_score": 0.00948, "epss_percentile": 0.75833}, "CVE-2021-25372": {"epss_score": 0.01275, "epss_percentile": 0.791}, "CVE-2021-25373": {"epss_score": 0.00037, "epss_percentile": 0.10625}, "CVE-2021-25374": {"epss_score": 0.07641, "epss_percentile": 0.91595}, "CVE-2021-25375": {"epss_score": 0.0036, "epss_percentile": 0.57663}, "CVE-2021-25376": {"epss_score": 0.00247, "epss_percentile": 0.47842}, "CVE-2021-25377": {"epss_score": 0.00044, "epss_percentile": 0.13387}, "CVE-2021-25378": {"epss_score": 0.00393, "epss_percentile": 0.59728}, "CVE-2021-25379": {"epss_score": 0.00054, "epss_percentile": 0.17115}, "CVE-2021-25380": {"epss_score": 0.00309, "epss_percentile": 0.5372}, "CVE-2021-25381": {"epss_score": 0.00037, "epss_percentile": 0.10625}, "CVE-2021-25382": {"epss_score": 0.00018, "epss_percentile": 0.03746}, "CVE-2021-25383": {"epss_score": 0.00187, "epss_percentile": 0.40754}, "CVE-2021-25384": {"epss_score": 0.00187, "epss_percentile": 0.40754}, "CVE-2021-25385": {"epss_score": 0.00187, "epss_percentile": 0.40754}, "CVE-2021-25386": {"epss_score": 0.00187, "epss_percentile": 0.40754}, "CVE-2021-25387": {"epss_score": 0.00187, "epss_percentile": 0.40754}, "CVE-2021-25388": {"epss_score": 9e-05, "epss_percentile": 0.00614}, "CVE-2021-25389": {"epss_score": 0.0002, "epss_percentile": 0.0455}, "CVE-2021-25390": {"epss_score": 0.00019, "epss_percentile": 0.04194}, "CVE-2021-25391": {"epss_score": 0.00019, "epss_percentile": 0.04194}, "CVE-2021-25392": {"epss_score": 9e-05, "epss_percentile": 0.00688}, "CVE-2021-25393": {"epss_score": 0.00028, "epss_percentile": 0.07274}, "CVE-2021-25394": {"epss_score": 0.0062, "epss_percentile": 0.69443}, "CVE-2021-25395": {"epss_score": 0.00172, "epss_percentile": 0.38959}, "CVE-2021-25396": {"epss_score": 0.00018, "epss_percentile": 0.0402}, "CVE-2021-25397": {"epss_score": 0.0002, "epss_percentile": 0.04433}, "CVE-2021-25398": {"epss_score": 0.00065, "epss_percentile": 0.20469}, "CVE-2021-25399": {"epss_score": 0.0005, "epss_percentile": 0.15729}, "CVE-2021-25400": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2021-25401": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-25402": {"epss_score": 0.00065, "epss_percentile": 0.20469}, "CVE-2021-25403": {"epss_score": 0.00065, "epss_percentile": 0.20469}, "CVE-2021-25404": {"epss_score": 0.00065, "epss_percentile": 0.20469}, "CVE-2021-25405": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2021-25406": {"epss_score": 0.00081, "epss_percentile": 0.24259}, "CVE-2021-25407": {"epss_score": 0.00019, "epss_percentile": 0.04153}, "CVE-2021-25408": {"epss_score": 0.00018, "epss_percentile": 0.03721}, "CVE-2021-25409": {"epss_score": 0.00018, "epss_percentile": 0.03899}, "CVE-2021-25410": {"epss_score": 0.00014, "epss_percentile": 0.01982}, "CVE-2021-25411": {"epss_score": 0.00034, "epss_percentile": 0.09545}, "CVE-2021-25412": {"epss_score": 0.00011, "epss_percentile": 0.01107}, "CVE-2021-25413": {"epss_score": 0.00012, "epss_percentile": 0.01244}, "CVE-2021-25414": {"epss_score": 0.00015, "epss_percentile": 0.02186}, "CVE-2021-25415": {"epss_score": 0.00041, "epss_percentile": 0.12305}, "CVE-2021-25416": {"epss_score": 0.00031, "epss_percentile": 0.08498}, "CVE-2021-25417": {"epss_score": 0.00103, "epss_percentile": 0.29056}, "CVE-2021-25418": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2021-25419": {"epss_score": 0.00275, "epss_percentile": 0.50668}, "CVE-2021-25420": {"epss_score": 0.00045, "epss_percentile": 0.1398}, "CVE-2021-25421": {"epss_score": 0.00045, "epss_percentile": 0.1398}, "CVE-2021-25422": {"epss_score": 0.00045, "epss_percentile": 0.1398}, "CVE-2021-25423": {"epss_score": 0.00045, "epss_percentile": 0.1398}, "CVE-2021-25424": {"epss_score": 0.00111, "epss_percentile": 0.30242}, "CVE-2021-25425": {"epss_score": 0.00284, "epss_percentile": 0.51425}, "CVE-2021-25426": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2021-25427": {"epss_score": 0.00059, "epss_percentile": 0.18849}, "CVE-2021-25428": {"epss_score": 0.00015, "epss_percentile": 0.02508}, "CVE-2021-25429": {"epss_score": 0.0003, "epss_percentile": 0.07979}, "CVE-2021-25430": {"epss_score": 0.0003, "epss_percentile": 0.07979}, "CVE-2021-25431": {"epss_score": 0.00051, "epss_percentile": 0.16133}, "CVE-2021-25432": {"epss_score": 0.00065, "epss_percentile": 0.20469}, "CVE-2021-25433": {"epss_score": 0.00039, "epss_percentile": 0.11612}, "CVE-2021-25434": {"epss_score": 0.01096, "epss_percentile": 0.77514}, "CVE-2021-25435": {"epss_score": 0.01096, "epss_percentile": 0.77514}, "CVE-2021-25436": {"epss_score": 0.01096, "epss_percentile": 0.77514}, "CVE-2021-25437": {"epss_score": 0.01139, "epss_percentile": 0.77942}, "CVE-2021-25438": {"epss_score": 0.00047, "epss_percentile": 0.14829}, "CVE-2021-25439": {"epss_score": 0.00055, "epss_percentile": 0.17641}, "CVE-2021-25440": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2021-25441": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-25442": {"epss_score": 0.00247, "epss_percentile": 0.47845}, "CVE-2021-25443": {"epss_score": 0.00018, "epss_percentile": 0.03895}, "CVE-2021-25444": {"epss_score": 0.00026, "epss_percentile": 0.06724}, "CVE-2021-25445": {"epss_score": 0.00243, "epss_percentile": 0.47429}, "CVE-2021-25446": {"epss_score": 0.00211, "epss_percentile": 0.43638}, "CVE-2021-25447": {"epss_score": 0.00281, "epss_percentile": 0.51116}, "CVE-2021-25448": {"epss_score": 0.00234, "epss_percentile": 0.46109}, "CVE-2021-25449": {"epss_score": 0.00178, "epss_percentile": 0.39712}, "CVE-2021-25450": {"epss_score": 0.0005, "epss_percentile": 0.15773}, "CVE-2021-25451": {"epss_score": 0.00057, "epss_percentile": 0.18005}, "CVE-2021-25452": {"epss_score": 0.0002, "epss_percentile": 0.04495}, "CVE-2021-25453": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2021-25454": {"epss_score": 0.00087, "epss_percentile": 0.25503}, "CVE-2021-25455": {"epss_score": 0.00061, "epss_percentile": 0.19357}, "CVE-2021-25456": {"epss_score": 0.00062, "epss_percentile": 0.19684}, "CVE-2021-25457": {"epss_score": 0.00038, "epss_percentile": 0.11275}, "CVE-2021-25458": {"epss_score": 0.00017, "epss_percentile": 0.03227}, "CVE-2021-25459": {"epss_score": 0.00018, "epss_percentile": 0.04047}, "CVE-2021-25460": {"epss_score": 0.00016, "epss_percentile": 0.02874}, "CVE-2021-25461": {"epss_score": 0.00032, "epss_percentile": 0.08786}, "CVE-2021-25462": {"epss_score": 0.00017, "epss_percentile": 0.03227}, "CVE-2021-25463": {"epss_score": 0.0006, "epss_percentile": 0.18931}, "CVE-2021-25464": {"epss_score": 0.00057, "epss_percentile": 0.18131}, "CVE-2021-25465": {"epss_score": 0.00047, "epss_percentile": 0.14625}, "CVE-2021-25466": {"epss_score": 0.00235, "epss_percentile": 0.46204}, "CVE-2021-25467": {"epss_score": 0.00017, "epss_percentile": 0.03372}, "CVE-2021-25468": {"epss_score": 0.00021, "epss_percentile": 0.04867}, "CVE-2021-25469": {"epss_score": 0.0002, "epss_percentile": 0.04491}, "CVE-2021-25470": {"epss_score": 0.0004, "epss_percentile": 0.12043}, "CVE-2021-25471": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2021-25472": {"epss_score": 0.00018, "epss_percentile": 0.03704}, "CVE-2021-25473": {"epss_score": 0.00049, "epss_percentile": 0.15445}, "CVE-2021-25474": {"epss_score": 0.00049, "epss_percentile": 0.15445}, "CVE-2021-25475": {"epss_score": 0.00016, "epss_percentile": 0.02635}, "CVE-2021-25476": {"epss_score": 0.00019, "epss_percentile": 0.04405}, "CVE-2021-25477": {"epss_score": 0.00199, "epss_percentile": 0.42117}, "CVE-2021-25478": {"epss_score": 0.00231, "epss_percentile": 0.45795}, "CVE-2021-25479": {"epss_score": 0.00231, "epss_percentile": 0.45795}, "CVE-2021-25480": {"epss_score": 0.00307, "epss_percentile": 0.53496}, "CVE-2021-25481": {"epss_score": 0.00016, "epss_percentile": 0.02812}, "CVE-2021-25482": {"epss_score": 0.00035, "epss_percentile": 0.09927}, "CVE-2021-25483": {"epss_score": 0.00062, "epss_percentile": 0.19678}, "CVE-2021-25484": {"epss_score": 0.00019, "epss_percentile": 0.04149}, "CVE-2021-25485": {"epss_score": 0.0006, "epss_percentile": 0.18936}, "CVE-2021-25486": {"epss_score": 0.00018, "epss_percentile": 0.03527}, "CVE-2021-25487": {"epss_score": 0.02365, "epss_percentile": 0.84514}, "CVE-2021-25488": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2021-25489": {"epss_score": 0.00363, "epss_percentile": 0.57865}, "CVE-2021-25490": {"epss_score": 0.00026, "epss_percentile": 0.06488}, "CVE-2021-25491": {"epss_score": 0.00017, "epss_percentile": 0.03258}, "CVE-2021-25492": {"epss_score": 0.00055, "epss_percentile": 0.17466}, "CVE-2021-25493": {"epss_score": 0.00052, "epss_percentile": 0.1663}, "CVE-2021-25494": {"epss_score": 0.00058, "epss_percentile": 0.18303}, "CVE-2021-25495": {"epss_score": 0.00077, "epss_percentile": 0.2355}, "CVE-2021-25496": {"epss_score": 0.00077, "epss_percentile": 0.2355}, "CVE-2021-25497": {"epss_score": 0.00077, "epss_percentile": 0.2355}, "CVE-2021-25498": {"epss_score": 0.00077, "epss_percentile": 0.2355}, "CVE-2021-25499": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2021-25500": {"epss_score": 0.00021, "epss_percentile": 0.04694}, "CVE-2021-25501": {"epss_score": 0.00018, "epss_percentile": 0.03608}, "CVE-2021-25502": {"epss_score": 0.0001, "epss_percentile": 0.00823}, "CVE-2021-25503": {"epss_score": 0.00018, "epss_percentile": 0.03563}, "CVE-2021-25504": {"epss_score": 0.00068, "epss_percentile": 0.21353}, "CVE-2021-25505": {"epss_score": 0.00149, "epss_percentile": 0.36022}, "CVE-2021-25506": {"epss_score": 0.00057, "epss_percentile": 0.18226}, "CVE-2021-25507": {"epss_score": 0.00077, "epss_percentile": 0.23538}, "CVE-2021-25508": {"epss_score": 0.00269, "epss_percentile": 0.50171}, "CVE-2021-25509": {"epss_score": 0.00057, "epss_percentile": 0.18198}, "CVE-2021-25510": {"epss_score": 0.00015, "epss_percentile": 0.02401}, "CVE-2021-25511": {"epss_score": 0.00015, "epss_percentile": 0.02322}, "CVE-2021-25512": {"epss_score": 0.00016, "epss_percentile": 0.02656}, "CVE-2021-25513": {"epss_score": 0.00019, "epss_percentile": 0.04194}, "CVE-2021-25514": {"epss_score": 0.00069, "epss_percentile": 0.21534}, "CVE-2021-25515": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2021-25516": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2021-25517": {"epss_score": 0.00017, "epss_percentile": 0.0322}, "CVE-2021-25518": {"epss_score": 0.00018, "epss_percentile": 0.0402}, "CVE-2021-25519": {"epss_score": 0.00016, "epss_percentile": 0.02894}, "CVE-2021-25520": {"epss_score": 0.00272, "epss_percentile": 0.50419}, "CVE-2021-25521": {"epss_score": 0.00062, "epss_percentile": 0.19622}, "CVE-2021-25522": {"epss_score": 0.00065, "epss_percentile": 0.20469}, "CVE-2021-25523": {"epss_score": 0.00065, "epss_percentile": 0.20469}, "CVE-2021-25524": {"epss_score": 0.00065, "epss_percentile": 0.20469}, "CVE-2021-25525": {"epss_score": 0.00095, "epss_percentile": 0.27121}, "CVE-2021-25526": {"epss_score": 0.00054, "epss_percentile": 0.17352}, "CVE-2021-25527": {"epss_score": 0.00056, "epss_percentile": 0.17847}, "CVE-2021-25630": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2021-25631": {"epss_score": 0.0428, "epss_percentile": 0.88487}, "CVE-2021-25633": {"epss_score": 0.00608, "epss_percentile": 0.69066}, "CVE-2021-25634": {"epss_score": 0.00468, "epss_percentile": 0.63875}, "CVE-2021-25635": {"epss_score": 0.00039, "epss_percentile": 0.11579}, "CVE-2021-25636": {"epss_score": 0.0024, "epss_percentile": 0.47217}, "CVE-2021-25640": {"epss_score": 0.00115, "epss_percentile": 0.3101}, "CVE-2021-25641": {"epss_score": 0.7462, "epss_percentile": 0.9881}, "CVE-2021-25642": {"epss_score": 0.02074, "epss_percentile": 0.835}, "CVE-2021-25643": {"epss_score": 0.00193, "epss_percentile": 0.41392}, "CVE-2021-25644": {"epss_score": 0.00187, "epss_percentile": 0.40756}, "CVE-2021-25645": {"epss_score": 0.00046, "epss_percentile": 0.14133}, "CVE-2021-25646": {"epss_score": 0.94055, "epss_percentile": 0.99893}, "CVE-2021-25647": {"epss_score": 0.00298, "epss_percentile": 0.52808}, "CVE-2021-25648": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-25649": {"epss_score": 0.00211, "epss_percentile": 0.43708}, "CVE-2021-25650": {"epss_score": 0.00225, "epss_percentile": 0.45099}, "CVE-2021-25651": {"epss_score": 0.00102, "epss_percentile": 0.28738}, "CVE-2021-25652": {"epss_score": 0.00153, "epss_percentile": 0.36576}, "CVE-2021-25653": {"epss_score": 0.00095, "epss_percentile": 0.2724}, "CVE-2021-25654": {"epss_score": 0.00214, "epss_percentile": 0.44015}, "CVE-2021-25655": {"epss_score": 0.00116, "epss_percentile": 0.31078}, "CVE-2021-25656": {"epss_score": 0.00147, "epss_percentile": 0.3565}, "CVE-2021-25657": {"epss_score": 0.00109, "epss_percentile": 0.29924}, "CVE-2021-25659": {"epss_score": 0.00444, "epss_percentile": 0.62829}, "CVE-2021-25660": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2021-25661": {"epss_score": 0.00371, "epss_percentile": 0.58342}, "CVE-2021-25662": {"epss_score": 0.0074, "epss_percentile": 0.72407}, "CVE-2021-25663": {"epss_score": 0.00523, "epss_percentile": 0.66294}, "CVE-2021-25664": {"epss_score": 0.00523, "epss_percentile": 0.66294}, "CVE-2021-25665": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-25666": {"epss_score": 0.00091, "epss_percentile": 0.26254}, "CVE-2021-25667": {"epss_score": 0.00447, "epss_percentile": 0.62939}, "CVE-2021-25668": {"epss_score": 0.00535, "epss_percentile": 0.66842}, "CVE-2021-25669": {"epss_score": 0.01004, "epss_percentile": 0.76524}, "CVE-2021-25670": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2021-25671": {"epss_score": 0.00104, "epss_percentile": 0.29123}, "CVE-2021-25672": {"epss_score": 0.00336, "epss_percentile": 0.55939}, "CVE-2021-25673": {"epss_score": 0.0004, "epss_percentile": 0.12169}, "CVE-2021-25674": {"epss_score": 0.00045, "epss_percentile": 0.13765}, "CVE-2021-25675": {"epss_score": 0.00045, "epss_percentile": 0.13765}, "CVE-2021-25676": {"epss_score": 0.00242, "epss_percentile": 0.47374}, "CVE-2021-25677": {"epss_score": 0.00385, "epss_percentile": 0.59213}, "CVE-2021-25678": {"epss_score": 0.0038, "epss_percentile": 0.58953}, "CVE-2021-25679": {"epss_score": 0.00832, "epss_percentile": 0.7406}, "CVE-2021-25680": {"epss_score": 0.01742, "epss_percentile": 0.82055}, "CVE-2021-25681": {"epss_score": 0.11194, "epss_percentile": 0.93261}, "CVE-2021-25682": {"epss_score": 0.00075, "epss_percentile": 0.22913}, "CVE-2021-25683": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2021-25684": {"epss_score": 0.00045, "epss_percentile": 0.13687}, "CVE-2021-25688": {"epss_score": 0.00054, "epss_percentile": 0.17191}, "CVE-2021-25689": {"epss_score": 0.01025, "epss_percentile": 0.76794}, "CVE-2021-25690": {"epss_score": 0.0039, "epss_percentile": 0.59533}, "CVE-2021-25692": {"epss_score": 0.0003, "epss_percentile": 0.08025}, "CVE-2021-25693": {"epss_score": 0.0039, "epss_percentile": 0.59533}, "CVE-2021-25694": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2021-25695": {"epss_score": 0.0006, "epss_percentile": 0.19196}, "CVE-2021-25698": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2021-25699": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2021-25701": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-25735": {"epss_score": 0.15581, "epss_percentile": 0.94464}, "CVE-2021-25736": {"epss_score": 0.0008, "epss_percentile": 0.24188}, "CVE-2021-25737": {"epss_score": 0.00379, "epss_percentile": 0.5886}, "CVE-2021-25738": {"epss_score": 0.00116, "epss_percentile": 0.31153}, "CVE-2021-25740": {"epss_score": 0.00535, "epss_percentile": 0.66831}, "CVE-2021-25741": {"epss_score": 0.33042, "epss_percentile": 0.96742}, "CVE-2021-25742": {"epss_score": 0.0054, "epss_percentile": 0.66992}, "CVE-2021-25743": {"epss_score": 0.0028, "epss_percentile": 0.51045}, "CVE-2021-25745": {"epss_score": 0.00357, "epss_percentile": 0.57435}, "CVE-2021-25746": {"epss_score": 0.00791, "epss_percentile": 0.73385}, "CVE-2021-25748": {"epss_score": 0.00041, "epss_percentile": 0.12335}, "CVE-2021-25749": {"epss_score": 0.00036, "epss_percentile": 0.10355}, "CVE-2021-25755": {"epss_score": 1e-05, "epss_percentile": 0.0001}, "CVE-2021-25756": {"epss_score": 3e-05, "epss_percentile": 0.00107}, "CVE-2021-25757": {"epss_score": 3e-05, "epss_percentile": 0.00078}, "CVE-2021-25758": {"epss_score": 1e-05, "epss_percentile": 0.00015}, "CVE-2021-25759": {"epss_score": 3e-05, "epss_percentile": 0.00076}, "CVE-2021-25760": {"epss_score": 3e-05, "epss_percentile": 0.00107}, "CVE-2021-25761": {"epss_score": 2e-05, "epss_percentile": 0.00034}, "CVE-2021-25762": {"epss_score": 3e-05, "epss_percentile": 0.00077}, "CVE-2021-25763": {"epss_score": 2e-05, "epss_percentile": 0.00034}, "CVE-2021-25764": {"epss_score": 3e-05, "epss_percentile": 0.00101}, "CVE-2021-25765": {"epss_score": 2e-05, "epss_percentile": 0.00048}, "CVE-2021-25766": {"epss_score": 3e-05, "epss_percentile": 0.00107}, "CVE-2021-25767": {"epss_score": 5e-05, "epss_percentile": 0.00179}, "CVE-2021-25768": {"epss_score": 3e-05, "epss_percentile": 0.00078}, "CVE-2021-25769": {"epss_score": 6e-05, "epss_percentile": 0.00239}, "CVE-2021-25770": {"epss_score": 0.00016, "epss_percentile": 0.02873}, "CVE-2021-25771": {"epss_score": 5e-05, "epss_percentile": 0.00179}, "CVE-2021-25772": {"epss_score": 5e-05, "epss_percentile": 0.00201}, "CVE-2021-25773": {"epss_score": 8e-05, "epss_percentile": 0.00492}, "CVE-2021-25774": {"epss_score": 2e-05, "epss_percentile": 0.0005}, "CVE-2021-25775": {"epss_score": 3e-05, "epss_percentile": 0.00083}, "CVE-2021-25776": {"epss_score": 4e-05, "epss_percentile": 0.00124}, "CVE-2021-25777": {"epss_score": 3e-05, "epss_percentile": 0.00065}, "CVE-2021-25778": {"epss_score": 3e-05, "epss_percentile": 0.00091}, "CVE-2021-25779": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-25780": {"epss_score": 0.04043, "epss_percentile": 0.88169}, "CVE-2021-25783": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2021-25784": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2021-25785": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2021-25786": {"epss_score": 0.00302, "epss_percentile": 0.53102}, "CVE-2021-25790": {"epss_score": 0.00281, "epss_percentile": 0.51195}, "CVE-2021-25791": {"epss_score": 0.00141, "epss_percentile": 0.34944}, "CVE-2021-25801": {"epss_score": 0.0314, "epss_percentile": 0.86484}, "CVE-2021-25802": {"epss_score": 0.00282, "epss_percentile": 0.51255}, "CVE-2021-25803": {"epss_score": 0.00282, "epss_percentile": 0.51255}, "CVE-2021-25804": {"epss_score": 0.01001, "epss_percentile": 0.76501}, "CVE-2021-25808": {"epss_score": 0.00496, "epss_percentile": 0.65155}, "CVE-2021-25809": {"epss_score": 0.00209, "epss_percentile": 0.43415}, "CVE-2021-25810": {"epss_score": 0.00611, "epss_percentile": 0.69182}, "CVE-2021-25811": {"epss_score": 0.0051, "epss_percentile": 0.65792}, "CVE-2021-25812": {"epss_score": 0.05096, "epss_percentile": 0.89494}, "CVE-2021-25827": {"epss_score": 0.00298, "epss_percentile": 0.5281}, "CVE-2021-25828": {"epss_score": 0.00194, "epss_percentile": 0.41549}, "CVE-2021-25829": {"epss_score": 0.02181, "epss_percentile": 0.83902}, "CVE-2021-25830": {"epss_score": 0.05324, "epss_percentile": 0.89732}, "CVE-2021-25831": {"epss_score": 0.03615, "epss_percentile": 0.87436}, "CVE-2021-25832": {"epss_score": 0.08288, "epss_percentile": 0.91971}, "CVE-2021-25833": {"epss_score": 0.07618, "epss_percentile": 0.91573}, "CVE-2021-25834": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2021-25835": {"epss_score": 0.00179, "epss_percentile": 0.3975}, "CVE-2021-25836": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2021-25837": {"epss_score": 0.00392, "epss_percentile": 0.59677}, "CVE-2021-25838": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-25839": {"epss_score": 0.00405, "epss_percentile": 0.60482}, "CVE-2021-25845": {"epss_score": 0.00409, "epss_percentile": 0.60735}, "CVE-2021-25846": {"epss_score": 0.0032, "epss_percentile": 0.54576}, "CVE-2021-25847": {"epss_score": 0.00383, "epss_percentile": 0.59099}, "CVE-2021-25848": {"epss_score": 0.00383, "epss_percentile": 0.59099}, "CVE-2021-25849": {"epss_score": 0.0032, "epss_percentile": 0.54576}, "CVE-2021-25856": {"epss_score": 0.00036, "epss_percentile": 0.1062}, "CVE-2021-25857": {"epss_score": 0.00085, "epss_percentile": 0.25047}, "CVE-2021-25863": {"epss_score": 0.00107, "epss_percentile": 0.29741}, "CVE-2021-25864": {"epss_score": 0.85508, "epss_percentile": 0.99337}, "CVE-2021-25874": {"epss_score": 0.0083, "epss_percentile": 0.74039}, "CVE-2021-25875": {"epss_score": 0.00435, "epss_percentile": 0.62353}, "CVE-2021-25876": {"epss_score": 0.00435, "epss_percentile": 0.62353}, "CVE-2021-25877": {"epss_score": 0.01204, "epss_percentile": 0.78508}, "CVE-2021-25878": {"epss_score": 0.00435, "epss_percentile": 0.62353}, "CVE-2021-25893": {"epss_score": 0.00379, "epss_percentile": 0.58905}, "CVE-2021-25894": {"epss_score": 0.00397, "epss_percentile": 0.60045}, "CVE-2021-25898": {"epss_score": 0.00136, "epss_percentile": 0.3409}, "CVE-2021-25899": {"epss_score": 0.88861, "epss_percentile": 0.99495}, "CVE-2021-25900": {"epss_score": 0.00547, "epss_percentile": 0.67257}, "CVE-2021-25901": {"epss_score": 0.00305, "epss_percentile": 0.53327}, "CVE-2021-25902": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-25903": {"epss_score": 0.0039, "epss_percentile": 0.59514}, "CVE-2021-25904": {"epss_score": 0.0039, "epss_percentile": 0.59514}, "CVE-2021-25905": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-25906": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-25907": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-25908": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-25909": {"epss_score": 0.0042, "epss_percentile": 0.61416}, "CVE-2021-25910": {"epss_score": 0.00068, "epss_percentile": 0.21333}, "CVE-2021-25912": {"epss_score": 0.02947, "epss_percentile": 0.86047}, "CVE-2021-25913": {"epss_score": 0.02947, "epss_percentile": 0.86047}, "CVE-2021-25914": {"epss_score": 0.0323, "epss_percentile": 0.86694}, "CVE-2021-25915": {"epss_score": 0.02947, "epss_percentile": 0.86047}, "CVE-2021-25916": {"epss_score": 0.02947, "epss_percentile": 0.86047}, "CVE-2021-25917": {"epss_score": 0.02795, "epss_percentile": 0.85678}, "CVE-2021-25918": {"epss_score": 0.02795, "epss_percentile": 0.85678}, "CVE-2021-25919": {"epss_score": 0.5897, "epss_percentile": 0.98142}, "CVE-2021-25920": {"epss_score": 0.00224, "epss_percentile": 0.44971}, "CVE-2021-25921": {"epss_score": 0.57066, "epss_percentile": 0.98047}, "CVE-2021-25922": {"epss_score": 0.01722, "epss_percentile": 0.81939}, "CVE-2021-25923": {"epss_score": 0.00065, "epss_percentile": 0.20481}, "CVE-2021-25924": {"epss_score": 0.00928, "epss_percentile": 0.75573}, "CVE-2021-25925": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-25926": {"epss_score": 0.0033, "epss_percentile": 0.55447}, "CVE-2021-25927": {"epss_score": 0.0323, "epss_percentile": 0.86694}, "CVE-2021-25928": {"epss_score": 0.03349, "epss_percentile": 0.86957}, "CVE-2021-25929": {"epss_score": 0.00488, "epss_percentile": 0.64845}, "CVE-2021-25930": {"epss_score": 0.00154, "epss_percentile": 0.36756}, "CVE-2021-25931": {"epss_score": 0.00219, "epss_percentile": 0.44441}, "CVE-2021-25932": {"epss_score": 0.00264, "epss_percentile": 0.49737}, "CVE-2021-25933": {"epss_score": 0.0049, "epss_percentile": 0.64934}, "CVE-2021-25934": {"epss_score": 0.00284, "epss_percentile": 0.51501}, "CVE-2021-25935": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2021-25938": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-25939": {"epss_score": 0.00234, "epss_percentile": 0.46086}, "CVE-2021-25940": {"epss_score": 0.00274, "epss_percentile": 0.50489}, "CVE-2021-25941": {"epss_score": 0.02947, "epss_percentile": 0.86047}, "CVE-2021-25943": {"epss_score": 0.02947, "epss_percentile": 0.86047}, "CVE-2021-25944": {"epss_score": 0.0254, "epss_percentile": 0.85047}, "CVE-2021-25945": {"epss_score": 0.0254, "epss_percentile": 0.85047}, "CVE-2021-25946": {"epss_score": 0.02947, "epss_percentile": 0.86047}, "CVE-2021-25947": {"epss_score": 0.0254, "epss_percentile": 0.85047}, "CVE-2021-25948": {"epss_score": 0.02947, "epss_percentile": 0.86047}, "CVE-2021-25949": {"epss_score": 0.02286, "epss_percentile": 0.84268}, "CVE-2021-25951": {"epss_score": 0.00307, "epss_percentile": 0.53563}, "CVE-2021-25952": {"epss_score": 0.02947, "epss_percentile": 0.86047}, "CVE-2021-25953": {"epss_score": 0.0254, "epss_percentile": 0.85047}, "CVE-2021-25954": {"epss_score": 0.00171, "epss_percentile": 0.38883}, "CVE-2021-25955": {"epss_score": 0.00415, "epss_percentile": 0.61149}, "CVE-2021-25956": {"epss_score": 0.00372, "epss_percentile": 0.58437}, "CVE-2021-25957": {"epss_score": 0.00326, "epss_percentile": 0.55074}, "CVE-2021-25958": {"epss_score": 0.02028, "epss_percentile": 0.83323}, "CVE-2021-25959": {"epss_score": 0.00396, "epss_percentile": 0.59908}, "CVE-2021-25960": {"epss_score": 0.00528, "epss_percentile": 0.66554}, "CVE-2021-25961": {"epss_score": 0.00334, "epss_percentile": 0.55701}, "CVE-2021-25962": {"epss_score": 0.00432, "epss_percentile": 0.62123}, "CVE-2021-25963": {"epss_score": 0.00396, "epss_percentile": 0.59908}, "CVE-2021-25964": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-25965": {"epss_score": 0.00208, "epss_percentile": 0.43289}, "CVE-2021-25966": {"epss_score": 0.00299, "epss_percentile": 0.52898}, "CVE-2021-25967": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-25968": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-25969": {"epss_score": 0.01844, "epss_percentile": 0.82505}, "CVE-2021-25970": {"epss_score": 0.00702, "epss_percentile": 0.71506}, "CVE-2021-25971": {"epss_score": 0.00389, "epss_percentile": 0.59452}, "CVE-2021-25972": {"epss_score": 0.00324, "epss_percentile": 0.54938}, "CVE-2021-25973": {"epss_score": 0.00157, "epss_percentile": 0.37093}, "CVE-2021-25974": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-25975": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-25976": {"epss_score": 0.00101, "epss_percentile": 0.28652}, "CVE-2021-25977": {"epss_score": 0.00319, "epss_percentile": 0.54474}, "CVE-2021-25978": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-25979": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2021-25980": {"epss_score": 0.02198, "epss_percentile": 0.83963}, "CVE-2021-25981": {"epss_score": 0.02105, "epss_percentile": 0.83621}, "CVE-2021-25982": {"epss_score": 0.01393, "epss_percentile": 0.79966}, "CVE-2021-25983": {"epss_score": 0.01393, "epss_percentile": 0.79966}, "CVE-2021-25984": {"epss_score": 0.01393, "epss_percentile": 0.79966}, "CVE-2021-25985": {"epss_score": 0.00169, "epss_percentile": 0.38539}, "CVE-2021-25986": {"epss_score": 0.00195, "epss_percentile": 0.41621}, "CVE-2021-25987": {"epss_score": 0.00091, "epss_percentile": 0.26271}, "CVE-2021-25988": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-25989": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-25990": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-25991": {"epss_score": 0.00192, "epss_percentile": 0.41354}, "CVE-2021-25992": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2021-25993": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-25994": {"epss_score": 0.01758, "epss_percentile": 0.82139}, "CVE-2021-26023": {"epss_score": 0.6479, "epss_percentile": 0.98391}, "CVE-2021-26024": {"epss_score": 0.011, "epss_percentile": 0.77565}, "CVE-2021-26025": {"epss_score": 0.00169, "epss_percentile": 0.38539}, "CVE-2021-26026": {"epss_score": 0.00169, "epss_percentile": 0.38539}, "CVE-2021-26027": {"epss_score": 0.00014, "epss_percentile": 0.01963}, "CVE-2021-26028": {"epss_score": 0.00014, "epss_percentile": 0.01778}, "CVE-2021-26029": {"epss_score": 0.00017, "epss_percentile": 0.03185}, "CVE-2021-26030": {"epss_score": 0.47876, "epss_percentile": 0.97606}, "CVE-2021-26031": {"epss_score": 0.00011, "epss_percentile": 0.00998}, "CVE-2021-26032": {"epss_score": 0.0161, "epss_percentile": 0.81322}, "CVE-2021-26033": {"epss_score": 9e-05, "epss_percentile": 0.00713}, "CVE-2021-26034": {"epss_score": 9e-05, "epss_percentile": 0.00713}, "CVE-2021-26035": {"epss_score": 0.02166, "epss_percentile": 0.83846}, "CVE-2021-26036": {"epss_score": 9e-05, "epss_percentile": 0.00716}, "CVE-2021-26037": {"epss_score": 9e-05, "epss_percentile": 0.0061}, "CVE-2021-26038": {"epss_score": 0.0001, "epss_percentile": 0.00871}, "CVE-2021-26039": {"epss_score": 0.02166, "epss_percentile": 0.83846}, "CVE-2021-26040": {"epss_score": 6e-05, "epss_percentile": 0.00309}, "CVE-2021-26067": {"epss_score": 0.01534, "epss_percentile": 0.80902}, "CVE-2021-26068": {"epss_score": 0.04995, "epss_percentile": 0.89371}, "CVE-2021-26069": {"epss_score": 0.01154, "epss_percentile": 0.78068}, "CVE-2021-26070": {"epss_score": 0.00381, "epss_percentile": 0.58989}, "CVE-2021-26071": {"epss_score": 0.00114, "epss_percentile": 0.30877}, "CVE-2021-26072": {"epss_score": 0.1813, "epss_percentile": 0.94961}, "CVE-2021-26073": {"epss_score": 0.00343, "epss_percentile": 0.56462}, "CVE-2021-26074": {"epss_score": 0.00258, "epss_percentile": 0.49024}, "CVE-2021-26075": {"epss_score": 0.00268, "epss_percentile": 0.50094}, "CVE-2021-26076": {"epss_score": 0.00214, "epss_percentile": 0.43957}, "CVE-2021-26077": {"epss_score": 0.00388, "epss_percentile": 0.59379}, "CVE-2021-26078": {"epss_score": 0.00558, "epss_percentile": 0.67575}, "CVE-2021-26079": {"epss_score": 0.0036, "epss_percentile": 0.57656}, "CVE-2021-26080": {"epss_score": 0.0031, "epss_percentile": 0.53742}, "CVE-2021-26081": {"epss_score": 0.00379, "epss_percentile": 0.58853}, "CVE-2021-26082": {"epss_score": 0.00257, "epss_percentile": 0.48846}, "CVE-2021-26083": {"epss_score": 0.00257, "epss_percentile": 0.48846}, "CVE-2021-26084": {"epss_score": 0.9444, "epss_percentile": 0.99988}, "CVE-2021-26085": {"epss_score": 0.94012, "epss_percentile": 0.99886}, "CVE-2021-26086": {"epss_score": 0.94189, "epss_percentile": 0.99915}, "CVE-2021-26087": {"epss_score": 0.0005, "epss_percentile": 0.15679}, "CVE-2021-26088": {"epss_score": 0.05478, "epss_percentile": 0.89918}, "CVE-2021-26089": {"epss_score": 0.00093, "epss_percentile": 0.2674}, "CVE-2021-26090": {"epss_score": 0.00424, "epss_percentile": 0.61666}, "CVE-2021-26091": {"epss_score": 0.00078, "epss_percentile": 0.23773}, "CVE-2021-26092": {"epss_score": 0.00529, "epss_percentile": 0.66598}, "CVE-2021-26093": {"epss_score": 0.00037, "epss_percentile": 0.10997}, "CVE-2021-26095": {"epss_score": 0.00306, "epss_percentile": 0.53424}, "CVE-2021-26096": {"epss_score": 0.00525, "epss_percentile": 0.66384}, "CVE-2021-26097": {"epss_score": 0.00434, "epss_percentile": 0.62303}, "CVE-2021-26098": {"epss_score": 0.00306, "epss_percentile": 0.53415}, "CVE-2021-26099": {"epss_score": 0.00159, "epss_percentile": 0.37391}, "CVE-2021-26100": {"epss_score": 0.00109, "epss_percentile": 0.29989}, "CVE-2021-26102": {"epss_score": 0.28081, "epss_percentile": 0.96307}, "CVE-2021-26103": {"epss_score": 0.00292, "epss_percentile": 0.52241}, "CVE-2021-26104": {"epss_score": 0.01346, "epss_percentile": 0.79645}, "CVE-2021-26105": {"epss_score": 0.00102, "epss_percentile": 0.28815}, "CVE-2021-26106": {"epss_score": 0.00142, "epss_percentile": 0.34955}, "CVE-2021-26107": {"epss_score": 0.0022, "epss_percentile": 0.44599}, "CVE-2021-26108": {"epss_score": 0.00344, "epss_percentile": 0.56504}, "CVE-2021-26109": {"epss_score": 0.01255, "epss_percentile": 0.78926}, "CVE-2021-26110": {"epss_score": 0.00148, "epss_percentile": 0.35828}, "CVE-2021-26111": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2021-26112": {"epss_score": 0.02873, "epss_percentile": 0.85877}, "CVE-2021-26113": {"epss_score": 0.001, "epss_percentile": 0.28488}, "CVE-2021-26114": {"epss_score": 0.01922, "epss_percentile": 0.82907}, "CVE-2021-26115": {"epss_score": 0.00355, "epss_percentile": 0.57275}, "CVE-2021-26116": {"epss_score": 0.00331, "epss_percentile": 0.55528}, "CVE-2021-26117": {"epss_score": 0.163, "epss_percentile": 0.94613}, "CVE-2021-26118": {"epss_score": 0.00745, "epss_percentile": 0.72527}, "CVE-2021-26119": {"epss_score": 0.62613, "epss_percentile": 0.98299}, "CVE-2021-26120": {"epss_score": 0.7558, "epss_percentile": 0.98855}, "CVE-2021-26122": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-26123": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-26194": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2021-26195": {"epss_score": 0.00359, "epss_percentile": 0.57599}, "CVE-2021-26197": {"epss_score": 0.00257, "epss_percentile": 0.48943}, "CVE-2021-26198": {"epss_score": 0.00257, "epss_percentile": 0.48943}, "CVE-2021-26199": {"epss_score": 0.00257, "epss_percentile": 0.48943}, "CVE-2021-26200": {"epss_score": 0.00159, "epss_percentile": 0.37409}, "CVE-2021-26201": {"epss_score": 0.00154, "epss_percentile": 0.36725}, "CVE-2021-26215": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2021-26216": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2021-26220": {"epss_score": 0.00436, "epss_percentile": 0.62467}, "CVE-2021-26221": {"epss_score": 0.00436, "epss_percentile": 0.62467}, "CVE-2021-26222": {"epss_score": 0.00436, "epss_percentile": 0.62467}, "CVE-2021-26223": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2021-26224": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2021-26226": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2021-26227": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2021-26228": {"epss_score": 0.00617, "epss_percentile": 0.69345}, "CVE-2021-26229": {"epss_score": 0.00513, "epss_percentile": 0.65936}, "CVE-2021-26230": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2021-26231": {"epss_score": 0.00617, "epss_percentile": 0.69345}, "CVE-2021-26232": {"epss_score": 0.00492, "epss_percentile": 0.64994}, "CVE-2021-26233": {"epss_score": 0.00317, "epss_percentile": 0.54358}, "CVE-2021-26234": {"epss_score": 0.00317, "epss_percentile": 0.54358}, "CVE-2021-26235": {"epss_score": 0.00317, "epss_percentile": 0.54358}, "CVE-2021-26236": {"epss_score": 0.0074, "epss_percentile": 0.72412}, "CVE-2021-26237": {"epss_score": 0.00233, "epss_percentile": 0.46059}, "CVE-2021-26247": {"epss_score": 0.43776, "epss_percentile": 0.97403}, "CVE-2021-26248": {"epss_score": 0.0005, "epss_percentile": 0.15687}, "CVE-2021-26251": {"epss_score": 0.00463, "epss_percentile": 0.63669}, "CVE-2021-26252": {"epss_score": 0.00391, "epss_percentile": 0.59592}, "CVE-2021-26253": {"epss_score": 0.00204, "epss_percentile": 0.42622}, "CVE-2021-26254": {"epss_score": 0.00131, "epss_percentile": 0.33346}, "CVE-2021-26256": {"epss_score": 0.01293, "epss_percentile": 0.79239}, "CVE-2021-26257": {"epss_score": 0.00054, "epss_percentile": 0.1708}, "CVE-2021-26258": {"epss_score": 0.00927, "epss_percentile": 0.75572}, "CVE-2021-26259": {"epss_score": 0.00263, "epss_percentile": 0.49406}, "CVE-2021-26260": {"epss_score": 0.00541, "epss_percentile": 0.67055}, "CVE-2021-26262": {"epss_score": 0.00108, "epss_percentile": 0.29886}, "CVE-2021-26263": {"epss_score": 0.00114, "epss_percentile": 0.30826}, "CVE-2021-26264": {"epss_score": 0.00028, "epss_percentile": 0.07563}, "CVE-2021-26266": {"epss_score": 0.00346, "epss_percentile": 0.56645}, "CVE-2021-26267": {"epss_score": 0.00346, "epss_percentile": 0.56645}, "CVE-2021-26271": {"epss_score": 0.00428, "epss_percentile": 0.61953}, "CVE-2021-26272": {"epss_score": 0.00203, "epss_percentile": 0.42558}, "CVE-2021-26273": {"epss_score": 0.00135, "epss_percentile": 0.33984}, "CVE-2021-26274": {"epss_score": 0.00037, "epss_percentile": 0.10973}, "CVE-2021-26275": {"epss_score": 0.0627, "epss_percentile": 0.90629}, "CVE-2021-26276": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2021-26277": {"epss_score": 0.00367, "epss_percentile": 0.58109}, "CVE-2021-26278": {"epss_score": 0.00027, "epss_percentile": 0.07136}, "CVE-2021-26279": {"epss_score": 0.00026, "epss_percentile": 0.06577}, "CVE-2021-26280": {"epss_score": 0.00025, "epss_percentile": 0.06203}, "CVE-2021-26281": {"epss_score": 0.00029, "epss_percentile": 0.07761}, "CVE-2021-26291": {"epss_score": 0.3955, "epss_percentile": 0.97168}, "CVE-2021-26293": {"epss_score": 0.507, "epss_percentile": 0.97746}, "CVE-2021-26294": {"epss_score": 0.92486, "epss_percentile": 0.99718}, "CVE-2021-26295": {"epss_score": 0.94237, "epss_percentile": 0.99923}, "CVE-2021-26296": {"epss_score": 0.00461, "epss_percentile": 0.6354}, "CVE-2021-26303": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2021-26304": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2021-26305": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-26306": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-26307": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-26308": {"epss_score": 0.00291, "epss_percentile": 0.52156}, "CVE-2021-26309": {"epss_score": 1e-05, "epss_percentile": 3e-05}, "CVE-2021-26310": {"epss_score": 5e-05, "epss_percentile": 0.00191}, "CVE-2021-26311": {"epss_score": 0.01283, "epss_percentile": 0.7916}, "CVE-2021-26312": {"epss_score": 0.00135, "epss_percentile": 0.33947}, "CVE-2021-26313": {"epss_score": 0.00078, "epss_percentile": 0.23602}, "CVE-2021-26314": {"epss_score": 0.00096, "epss_percentile": 0.27384}, "CVE-2021-26315": {"epss_score": 0.00027, "epss_percentile": 0.06884}, "CVE-2021-26316": {"epss_score": 0.00095, "epss_percentile": 0.27128}, "CVE-2021-26317": {"epss_score": 0.00192, "epss_percentile": 0.41288}, "CVE-2021-26318": {"epss_score": 0.00111, "epss_percentile": 0.30363}, "CVE-2021-26320": {"epss_score": 0.00038, "epss_percentile": 0.11396}, "CVE-2021-26321": {"epss_score": 0.00108, "epss_percentile": 0.29767}, "CVE-2021-26322": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-26323": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-26324": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2021-26325": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-26326": {"epss_score": 0.00046, "epss_percentile": 0.14199}, "CVE-2021-26327": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2021-26328": {"epss_score": 0.00063, "epss_percentile": 0.2}, "CVE-2021-26329": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-26330": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-26331": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2021-26332": {"epss_score": 0.00044, "epss_percentile": 0.13673}, "CVE-2021-26333": {"epss_score": 0.00116, "epss_percentile": 0.31074}, "CVE-2021-26334": {"epss_score": 0.00508, "epss_percentile": 0.65703}, "CVE-2021-26335": {"epss_score": 0.0013, "epss_percentile": 0.33277}, "CVE-2021-26336": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2021-26337": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2021-26338": {"epss_score": 0.00314, "epss_percentile": 0.54143}, "CVE-2021-26339": {"epss_score": 0.0009, "epss_percentile": 0.26141}, "CVE-2021-26340": {"epss_score": 0.00058, "epss_percentile": 0.18464}, "CVE-2021-26341": {"epss_score": 0.0005, "epss_percentile": 0.15781}, "CVE-2021-26342": {"epss_score": 0.00119, "epss_percentile": 0.31551}, "CVE-2021-26343": {"epss_score": 0.00047, "epss_percentile": 0.14645}, "CVE-2021-26344": {"epss_score": 0.00079, "epss_percentile": 0.23993}, "CVE-2021-26345": {"epss_score": 0.00027, "epss_percentile": 0.06957}, "CVE-2021-26346": {"epss_score": 0.00061, "epss_percentile": 0.19261}, "CVE-2021-26347": {"epss_score": 0.00145, "epss_percentile": 0.35376}, "CVE-2021-26348": {"epss_score": 0.00114, "epss_percentile": 0.30861}, "CVE-2021-26349": {"epss_score": 0.00134, "epss_percentile": 0.33793}, "CVE-2021-26350": {"epss_score": 0.00102, "epss_percentile": 0.28763}, "CVE-2021-26351": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2021-26352": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2021-26353": {"epss_score": 0.00147, "epss_percentile": 0.35654}, "CVE-2021-26354": {"epss_score": 0.00044, "epss_percentile": 0.13484}, "CVE-2021-26355": {"epss_score": 0.00061, "epss_percentile": 0.19261}, "CVE-2021-26356": {"epss_score": 0.00135, "epss_percentile": 0.34056}, "CVE-2021-26360": {"epss_score": 0.00104, "epss_percentile": 0.29205}, "CVE-2021-26361": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2021-26362": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2021-26363": {"epss_score": 0.00119, "epss_percentile": 0.31551}, "CVE-2021-26364": {"epss_score": 0.00068, "epss_percentile": 0.21306}, "CVE-2021-26365": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2021-26366": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2021-26367": {"epss_score": 0.00038, "epss_percentile": 0.11279}, "CVE-2021-26368": {"epss_score": 0.00057, "epss_percentile": 0.18028}, "CVE-2021-26369": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2021-26370": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2021-26371": {"epss_score": 0.00061, "epss_percentile": 0.1934}, "CVE-2021-26372": {"epss_score": 0.00118, "epss_percentile": 0.31419}, "CVE-2021-26373": {"epss_score": 0.00118, "epss_percentile": 0.31419}, "CVE-2021-26375": {"epss_score": 0.0008, "epss_percentile": 0.24141}, "CVE-2021-26376": {"epss_score": 0.00118, "epss_percentile": 0.31419}, "CVE-2021-26377": {"epss_score": 0.00027, "epss_percentile": 0.06777}, "CVE-2021-26378": {"epss_score": 0.00118, "epss_percentile": 0.31419}, "CVE-2021-26379": {"epss_score": 0.00169, "epss_percentile": 0.38614}, "CVE-2021-26382": {"epss_score": 0.00118, "epss_percentile": 0.31472}, "CVE-2021-26383": {"epss_score": 0.00023, "epss_percentile": 0.0547}, "CVE-2021-26384": {"epss_score": 0.00135, "epss_percentile": 0.34024}, "CVE-2021-26386": {"epss_score": 0.00192, "epss_percentile": 0.41288}, "CVE-2021-26387": {"epss_score": 0.00022, "epss_percentile": 0.05288}, "CVE-2021-26388": {"epss_score": 0.00118, "epss_percentile": 0.31419}, "CVE-2021-26390": {"epss_score": 0.00131, "epss_percentile": 0.33468}, "CVE-2021-26391": {"epss_score": 0.00045, "epss_percentile": 0.13752}, "CVE-2021-26392": {"epss_score": 0.00154, "epss_percentile": 0.36663}, "CVE-2021-26393": {"epss_score": 0.00155, "epss_percentile": 0.36812}, "CVE-2021-26396": {"epss_score": 0.00025, "epss_percentile": 0.06305}, "CVE-2021-26397": {"epss_score": 0.00032, "epss_percentile": 0.09099}, "CVE-2021-26398": {"epss_score": 0.00062, "epss_percentile": 0.19593}, "CVE-2021-26400": {"epss_score": 0.00057, "epss_percentile": 0.18106}, "CVE-2021-26401": {"epss_score": 0.00132, "epss_percentile": 0.33525}, "CVE-2021-26402": {"epss_score": 0.00061, "epss_percentile": 0.19348}, "CVE-2021-26403": {"epss_score": 0.00067, "epss_percentile": 0.21023}, "CVE-2021-26404": {"epss_score": 0.00064, "epss_percentile": 0.20138}, "CVE-2021-26406": {"epss_score": 0.00146, "epss_percentile": 0.35531}, "CVE-2021-26407": {"epss_score": 0.00086, "epss_percentile": 0.2542}, "CVE-2021-26408": {"epss_score": 0.0006, "epss_percentile": 0.1903}, "CVE-2021-26409": {"epss_score": 0.00086, "epss_percentile": 0.25292}, "CVE-2021-26411": {"epss_score": 0.92473, "epss_percentile": 0.99717}, "CVE-2021-26412": {"epss_score": 0.24204, "epss_percentile": 0.95885}, "CVE-2021-26413": {"epss_score": 0.0084, "epss_percentile": 0.74202}, "CVE-2021-26414": {"epss_score": 0.23319, "epss_percentile": 0.95764}, "CVE-2021-26415": {"epss_score": 0.11468, "epss_percentile": 0.93376}, "CVE-2021-26416": {"epss_score": 0.03245, "epss_percentile": 0.86741}, "CVE-2021-26417": {"epss_score": 0.00488, "epss_percentile": 0.64844}, "CVE-2021-26418": {"epss_score": 0.00545, "epss_percentile": 0.67169}, "CVE-2021-26419": {"epss_score": 0.34148, "epss_percentile": 0.96827}, "CVE-2021-26420": {"epss_score": 0.07182, "epss_percentile": 0.91304}, "CVE-2021-26421": {"epss_score": 0.00782, "epss_percentile": 0.73205}, "CVE-2021-26422": {"epss_score": 0.07688, "epss_percentile": 0.91627}, "CVE-2021-26423": {"epss_score": 0.03657, "epss_percentile": 0.87518}, "CVE-2021-26424": {"epss_score": 0.1053, "epss_percentile": 0.93019}, "CVE-2021-26425": {"epss_score": 0.00204, "epss_percentile": 0.42654}, "CVE-2021-26426": {"epss_score": 0.00572, "epss_percentile": 0.68009}, "CVE-2021-26427": {"epss_score": 0.00522, "epss_percentile": 0.6625}, "CVE-2021-26428": {"epss_score": 0.00384, "epss_percentile": 0.59181}, "CVE-2021-26429": {"epss_score": 0.00601, "epss_percentile": 0.68848}, "CVE-2021-26430": {"epss_score": 0.00182, "epss_percentile": 0.40242}, "CVE-2021-26431": {"epss_score": 0.00385, "epss_percentile": 0.5919}, "CVE-2021-26432": {"epss_score": 0.10285, "epss_percentile": 0.92926}, "CVE-2021-26433": {"epss_score": 0.17064, "epss_percentile": 0.94768}, "CVE-2021-26434": {"epss_score": 0.00436, "epss_percentile": 0.62463}, "CVE-2021-26435": {"epss_score": 0.05872, "epss_percentile": 0.90281}, "CVE-2021-26436": {"epss_score": 0.01112, "epss_percentile": 0.77673}, "CVE-2021-26437": {"epss_score": 0.03422, "epss_percentile": 0.87106}, "CVE-2021-26439": {"epss_score": 0.08687, "epss_percentile": 0.92202}, "CVE-2021-26441": {"epss_score": 0.00231, "epss_percentile": 0.45809}, "CVE-2021-26442": {"epss_score": 0.00253, "epss_percentile": 0.48415}, "CVE-2021-26443": {"epss_score": 0.0055, "epss_percentile": 0.67327}, "CVE-2021-26444": {"epss_score": 0.00838, "epss_percentile": 0.74167}, "CVE-2021-26461": {"epss_score": 0.02052, "epss_percentile": 0.8341}, "CVE-2021-26471": {"epss_score": 0.07871, "epss_percentile": 0.91736}, "CVE-2021-26472": {"epss_score": 0.10709, "epss_percentile": 0.93079}, "CVE-2021-26473": {"epss_score": 0.00743, "epss_percentile": 0.725}, "CVE-2021-26474": {"epss_score": 0.00234, "epss_percentile": 0.46096}, "CVE-2021-26475": {"epss_score": 0.66362, "epss_percentile": 0.98461}, "CVE-2021-26476": {"epss_score": 0.02869, "epss_percentile": 0.85871}, "CVE-2021-26504": {"epss_score": 0.00508, "epss_percentile": 0.65716}, "CVE-2021-26505": {"epss_score": 0.01257, "epss_percentile": 0.7895}, "CVE-2021-26528": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-26529": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-26530": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-26539": {"epss_score": 0.00288, "epss_percentile": 0.5195}, "CVE-2021-26540": {"epss_score": 0.00288, "epss_percentile": 0.5195}, "CVE-2021-26541": {"epss_score": 0.12886, "epss_percentile": 0.93812}, "CVE-2021-26543": {"epss_score": 0.03711, "epss_percentile": 0.87608}, "CVE-2021-26544": {"epss_score": 0.02403, "epss_percentile": 0.84644}, "CVE-2021-26549": {"epss_score": 0.01432, "epss_percentile": 0.80251}, "CVE-2021-26550": {"epss_score": 0.00091, "epss_percentile": 0.2619}, "CVE-2021-26551": {"epss_score": 0.00175, "epss_percentile": 0.39283}, "CVE-2021-26556": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2021-26557": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2021-26558": {"epss_score": 0.02032, "epss_percentile": 0.83337}, "CVE-2021-26559": {"epss_score": 0.00557, "epss_percentile": 0.67541}, "CVE-2021-26560": {"epss_score": 0.00164, "epss_percentile": 0.37912}, "CVE-2021-26561": {"epss_score": 0.02341, "epss_percentile": 0.84437}, "CVE-2021-26562": {"epss_score": 0.01388, "epss_percentile": 0.79922}, "CVE-2021-26563": {"epss_score": 0.00117, "epss_percentile": 0.31228}, "CVE-2021-26564": {"epss_score": 0.00135, "epss_percentile": 0.34025}, "CVE-2021-26565": {"epss_score": 0.00315, "epss_percentile": 0.54168}, "CVE-2021-26566": {"epss_score": 0.00535, "epss_percentile": 0.66827}, "CVE-2021-26567": {"epss_score": 0.01128, "epss_percentile": 0.77831}, "CVE-2021-26569": {"epss_score": 0.01754, "epss_percentile": 0.82117}, "CVE-2021-26570": {"epss_score": 0.00124, "epss_percentile": 0.32439}, "CVE-2021-26571": {"epss_score": 0.00131, "epss_percentile": 0.33476}, "CVE-2021-26572": {"epss_score": 0.00131, "epss_percentile": 0.33476}, "CVE-2021-26573": {"epss_score": 0.00131, "epss_percentile": 0.33476}, "CVE-2021-26574": {"epss_score": 0.00119, "epss_percentile": 0.31571}, "CVE-2021-26575": {"epss_score": 0.00119, "epss_percentile": 0.31571}, "CVE-2021-26576": {"epss_score": 0.00116, "epss_percentile": 0.31172}, "CVE-2021-26577": {"epss_score": 0.00073, "epss_percentile": 0.22543}, "CVE-2021-26578": {"epss_score": 0.00349, "epss_percentile": 0.56872}, "CVE-2021-26579": {"epss_score": 0.00046, "epss_percentile": 0.14122}, "CVE-2021-26580": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-26581": {"epss_score": 0.00372, "epss_percentile": 0.58452}, "CVE-2021-26582": {"epss_score": 0.003, "epss_percentile": 0.52944}, "CVE-2021-26583": {"epss_score": 0.02578, "epss_percentile": 0.85148}, "CVE-2021-26584": {"epss_score": 0.00209, "epss_percentile": 0.43406}, "CVE-2021-26585": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2021-26586": {"epss_score": 0.00305, "epss_percentile": 0.53393}, "CVE-2021-26587": {"epss_score": 0.00304, "epss_percentile": 0.53292}, "CVE-2021-26588": {"epss_score": 0.01708, "epss_percentile": 0.81866}, "CVE-2021-26589": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2021-26593": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-26594": {"epss_score": 0.0031, "epss_percentile": 0.53799}, "CVE-2021-26595": {"epss_score": 0.00108, "epss_percentile": 0.29902}, "CVE-2021-26596": {"epss_score": 0.00506, "epss_percentile": 0.6564}, "CVE-2021-26597": {"epss_score": 0.00477, "epss_percentile": 0.64305}, "CVE-2021-26598": {"epss_score": 0.76068, "epss_percentile": 0.98876}, "CVE-2021-26599": {"epss_score": 0.04018, "epss_percentile": 0.88125}, "CVE-2021-26600": {"epss_score": 0.01206, "epss_percentile": 0.78518}, "CVE-2021-26601": {"epss_score": 0.11918, "epss_percentile": 0.93517}, "CVE-2021-26603": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2021-26605": {"epss_score": 0.00428, "epss_percentile": 0.61939}, "CVE-2021-26606": {"epss_score": 0.00485, "epss_percentile": 0.6474}, "CVE-2021-26607": {"epss_score": 0.00967, "epss_percentile": 0.76066}, "CVE-2021-26608": {"epss_score": 0.00233, "epss_percentile": 0.4604}, "CVE-2021-26609": {"epss_score": 0.00647, "epss_percentile": 0.70182}, "CVE-2021-26610": {"epss_score": 0.00137, "epss_percentile": 0.34259}, "CVE-2021-26611": {"epss_score": 0.00707, "epss_percentile": 0.71656}, "CVE-2021-26612": {"epss_score": 0.00917, "epss_percentile": 0.75431}, "CVE-2021-26613": {"epss_score": 0.00307, "epss_percentile": 0.53488}, "CVE-2021-26614": {"epss_score": 0.03462, "epss_percentile": 0.87185}, "CVE-2021-26615": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2021-26616": {"epss_score": 0.0066, "epss_percentile": 0.70537}, "CVE-2021-26617": {"epss_score": 0.00729, "epss_percentile": 0.72119}, "CVE-2021-26618": {"epss_score": 0.00425, "epss_percentile": 0.61729}, "CVE-2021-26619": {"epss_score": 0.01241, "epss_percentile": 0.78818}, "CVE-2021-26620": {"epss_score": 0.0061, "epss_percentile": 0.69147}, "CVE-2021-26621": {"epss_score": 0.03309, "epss_percentile": 0.86883}, "CVE-2021-26622": {"epss_score": 0.02273, "epss_percentile": 0.84222}, "CVE-2021-26623": {"epss_score": 0.00694, "epss_percentile": 0.7135}, "CVE-2021-26624": {"epss_score": 0.01876, "epss_percentile": 0.82659}, "CVE-2021-26625": {"epss_score": 0.00205, "epss_percentile": 0.42741}, "CVE-2021-26626": {"epss_score": 0.00701, "epss_percentile": 0.71502}, "CVE-2021-26627": {"epss_score": 0.00382, "epss_percentile": 0.59035}, "CVE-2021-26628": {"epss_score": 0.003, "epss_percentile": 0.52981}, "CVE-2021-26629": {"epss_score": 0.01855, "epss_percentile": 0.82558}, "CVE-2021-26630": {"epss_score": 0.00388, "epss_percentile": 0.59385}, "CVE-2021-26631": {"epss_score": 0.00334, "epss_percentile": 0.55687}, "CVE-2021-26633": {"epss_score": 0.00279, "epss_percentile": 0.50928}, "CVE-2021-26634": {"epss_score": 0.00498, "epss_percentile": 0.65219}, "CVE-2021-26635": {"epss_score": 0.05086, "epss_percentile": 0.89479}, "CVE-2021-26636": {"epss_score": 0.00756, "epss_percentile": 0.72744}, "CVE-2021-26637": {"epss_score": 0.00981, "epss_percentile": 0.76285}, "CVE-2021-26638": {"epss_score": 0.08749, "epss_percentile": 0.9224}, "CVE-2021-26639": {"epss_score": 0.00117, "epss_percentile": 0.31312}, "CVE-2021-26642": {"epss_score": 0.04054, "epss_percentile": 0.88183}, "CVE-2021-26644": {"epss_score": 0.01548, "epss_percentile": 0.80977}, "CVE-2021-26675": {"epss_score": 0.00186, "epss_percentile": 0.40636}, "CVE-2021-26676": {"epss_score": 0.00096, "epss_percentile": 0.27272}, "CVE-2021-26677": {"epss_score": 0.00041, "epss_percentile": 0.1242}, "CVE-2021-26678": {"epss_score": 0.00469, "epss_percentile": 0.63957}, "CVE-2021-26679": {"epss_score": 0.04139, "epss_percentile": 0.8831}, "CVE-2021-26680": {"epss_score": 0.01841, "epss_percentile": 0.82496}, "CVE-2021-26681": {"epss_score": 0.04473, "epss_percentile": 0.88735}, "CVE-2021-26682": {"epss_score": 0.00249, "epss_percentile": 0.48017}, "CVE-2021-26683": {"epss_score": 0.04139, "epss_percentile": 0.8831}, "CVE-2021-26684": {"epss_score": 0.04139, "epss_percentile": 0.8831}, "CVE-2021-26685": {"epss_score": 0.00202, "epss_percentile": 0.42458}, "CVE-2021-26686": {"epss_score": 0.00202, "epss_percentile": 0.42458}, "CVE-2021-26687": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2021-26688": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2021-26689": {"epss_score": 0.00173, "epss_percentile": 0.39069}, "CVE-2021-26690": {"epss_score": 0.68609, "epss_percentile": 0.98557}, "CVE-2021-26691": {"epss_score": 0.35729, "epss_percentile": 0.96929}, "CVE-2021-26697": {"epss_score": 0.02459, "epss_percentile": 0.84816}, "CVE-2021-26698": {"epss_score": 0.0065, "epss_percentile": 0.70249}, "CVE-2021-26699": {"epss_score": 0.00473, "epss_percentile": 0.64085}, "CVE-2021-26700": {"epss_score": 0.12921, "epss_percentile": 0.93818}, "CVE-2021-26701": {"epss_score": 0.08242, "epss_percentile": 0.91946}, "CVE-2021-26702": {"epss_score": 0.04853, "epss_percentile": 0.89217}, "CVE-2021-26703": {"epss_score": 0.06458, "epss_percentile": 0.90769}, "CVE-2021-26704": {"epss_score": 0.02307, "epss_percentile": 0.84327}, "CVE-2021-26705": {"epss_score": 0.0048, "epss_percentile": 0.64469}, "CVE-2021-26706": {"epss_score": 0.0076, "epss_percentile": 0.72802}, "CVE-2021-26707": {"epss_score": 0.0109, "epss_percentile": 0.77451}, "CVE-2021-26708": {"epss_score": 0.01244, "epss_percentile": 0.78836}, "CVE-2021-26709": {"epss_score": 0.39843, "epss_percentile": 0.97182}, "CVE-2021-26710": {"epss_score": 0.21051, "epss_percentile": 0.95458}, "CVE-2021-26711": {"epss_score": 0.00257, "epss_percentile": 0.48917}, "CVE-2021-26712": {"epss_score": 0.01654, "epss_percentile": 0.81585}, "CVE-2021-26713": {"epss_score": 0.00164, "epss_percentile": 0.37905}, "CVE-2021-26714": {"epss_score": 0.00915, "epss_percentile": 0.7541}, "CVE-2021-26715": {"epss_score": 0.00552, "epss_percentile": 0.67399}, "CVE-2021-26716": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-26717": {"epss_score": 0.0044, "epss_percentile": 0.62643}, "CVE-2021-26718": {"epss_score": 0.00051, "epss_percentile": 0.16068}, "CVE-2021-26719": {"epss_score": 0.00591, "epss_percentile": 0.68596}, "CVE-2021-26720": {"epss_score": 0.00069, "epss_percentile": 0.21495}, "CVE-2021-26722": {"epss_score": 0.29912, "epss_percentile": 0.96486}, "CVE-2021-26723": {"epss_score": 0.64083, "epss_percentile": 0.98363}, "CVE-2021-26724": {"epss_score": 0.02713, "epss_percentile": 0.85503}, "CVE-2021-26725": {"epss_score": 0.00528, "epss_percentile": 0.66557}, "CVE-2021-26726": {"epss_score": 0.0108, "epss_percentile": 0.77368}, "CVE-2021-26727": {"epss_score": 0.08393, "epss_percentile": 0.92027}, "CVE-2021-26728": {"epss_score": 0.08393, "epss_percentile": 0.92027}, "CVE-2021-26729": {"epss_score": 0.08393, "epss_percentile": 0.92027}, "CVE-2021-26730": {"epss_score": 0.01303, "epss_percentile": 0.79309}, "CVE-2021-26731": {"epss_score": 0.10583, "epss_percentile": 0.93035}, "CVE-2021-26732": {"epss_score": 0.00164, "epss_percentile": 0.37966}, "CVE-2021-26733": {"epss_score": 0.00225, "epss_percentile": 0.45131}, "CVE-2021-26734": {"epss_score": 0.00023, "epss_percentile": 0.05453}, "CVE-2021-26735": {"epss_score": 0.00039, "epss_percentile": 0.11767}, "CVE-2021-26736": {"epss_score": 0.00033, "epss_percentile": 0.09421}, "CVE-2021-26737": {"epss_score": 0.00019, "epss_percentile": 0.04297}, "CVE-2021-26738": {"epss_score": 0.00038, "epss_percentile": 0.11093}, "CVE-2021-26739": {"epss_score": 0.00621, "epss_percentile": 0.69492}, "CVE-2021-26740": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2021-26746": {"epss_score": 0.00469, "epss_percentile": 0.63916}, "CVE-2021-26747": {"epss_score": 0.24398, "epss_percentile": 0.95917}, "CVE-2021-26750": {"epss_score": 0.00051, "epss_percentile": 0.16293}, "CVE-2021-26751": {"epss_score": 0.00372, "epss_percentile": 0.58443}, "CVE-2021-26752": {"epss_score": 0.01161, "epss_percentile": 0.78145}, "CVE-2021-26753": {"epss_score": 0.00582, "epss_percentile": 0.68284}, "CVE-2021-26754": {"epss_score": 0.09116, "epss_percentile": 0.92407}, "CVE-2021-26758": {"epss_score": 0.03356, "epss_percentile": 0.86974}, "CVE-2021-26762": {"epss_score": 0.01147, "epss_percentile": 0.78004}, "CVE-2021-26764": {"epss_score": 0.03091, "epss_percentile": 0.86395}, "CVE-2021-26765": {"epss_score": 0.03694, "epss_percentile": 0.87582}, "CVE-2021-26776": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2021-26777": {"epss_score": 0.00982, "epss_percentile": 0.76297}, "CVE-2021-26786": {"epss_score": 0.01228, "epss_percentile": 0.78707}, "CVE-2021-26787": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-26788": {"epss_score": 0.00157, "epss_percentile": 0.37087}, "CVE-2021-26794": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2021-26795": {"epss_score": 0.0032, "epss_percentile": 0.5459}, "CVE-2021-26797": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2021-26799": {"epss_score": 0.00356, "epss_percentile": 0.57395}, "CVE-2021-26800": {"epss_score": 0.00117, "epss_percentile": 0.31326}, "CVE-2021-26804": {"epss_score": 0.00269, "epss_percentile": 0.50176}, "CVE-2021-26805": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2021-26807": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2021-26809": {"epss_score": 0.00782, "epss_percentile": 0.73203}, "CVE-2021-26810": {"epss_score": 0.34278, "epss_percentile": 0.96839}, "CVE-2021-26812": {"epss_score": 0.19091, "epss_percentile": 0.95127}, "CVE-2021-26813": {"epss_score": 0.00478, "epss_percentile": 0.64393}, "CVE-2021-26814": {"epss_score": 0.64023, "epss_percentile": 0.9836}, "CVE-2021-26822": {"epss_score": 0.09893, "epss_percentile": 0.92756}, "CVE-2021-26824": {"epss_score": 0.00058, "epss_percentile": 0.18404}, "CVE-2021-26825": {"epss_score": 0.00648, "epss_percentile": 0.70213}, "CVE-2021-26826": {"epss_score": 0.00648, "epss_percentile": 0.70213}, "CVE-2021-26827": {"epss_score": 0.00929, "epss_percentile": 0.75588}, "CVE-2021-26828": {"epss_score": 0.8012, "epss_percentile": 0.99072}, "CVE-2021-26829": {"epss_score": 0.17378, "epss_percentile": 0.94841}, "CVE-2021-26830": {"epss_score": 0.01093, "epss_percentile": 0.77472}, "CVE-2021-26832": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-26833": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-26834": {"epss_score": 0.0032, "epss_percentile": 0.54595}, "CVE-2021-26835": {"epss_score": 0.00602, "epss_percentile": 0.68886}, "CVE-2021-26837": {"epss_score": 0.00089, "epss_percentile": 0.25815}, "CVE-2021-26843": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-26844": {"epss_score": 0.002, "epss_percentile": 0.42231}, "CVE-2021-26845": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2021-26854": {"epss_score": 0.05151, "epss_percentile": 0.89549}, "CVE-2021-26855": {"epss_score": 0.94351, "epss_percentile": 0.99955}, "CVE-2021-26857": {"epss_score": 0.34542, "epss_percentile": 0.96855}, "CVE-2021-26858": {"epss_score": 0.55064, "epss_percentile": 0.97959}, "CVE-2021-26859": {"epss_score": 0.05001, "epss_percentile": 0.89379}, "CVE-2021-26860": {"epss_score": 0.003, "epss_percentile": 0.52985}, "CVE-2021-26861": {"epss_score": 0.09589, "epss_percentile": 0.92612}, "CVE-2021-26862": {"epss_score": 0.00456, "epss_percentile": 0.63338}, "CVE-2021-26863": {"epss_score": 0.00236, "epss_percentile": 0.46375}, "CVE-2021-26864": {"epss_score": 0.00598, "epss_percentile": 0.68767}, "CVE-2021-26865": {"epss_score": 0.02206, "epss_percentile": 0.84002}, "CVE-2021-26866": {"epss_score": 0.00639, "epss_percentile": 0.69951}, "CVE-2021-26867": {"epss_score": 0.01305, "epss_percentile": 0.7933}, "CVE-2021-26868": {"epss_score": 0.05299, "epss_percentile": 0.89705}, "CVE-2021-26869": {"epss_score": 0.00426, "epss_percentile": 0.61734}, "CVE-2021-26870": {"epss_score": 0.00513, "epss_percentile": 0.65932}, "CVE-2021-26871": {"epss_score": 0.01927, "epss_percentile": 0.82927}, "CVE-2021-26872": {"epss_score": 0.00483, "epss_percentile": 0.64562}, "CVE-2021-26873": {"epss_score": 0.00267, "epss_percentile": 0.49994}, "CVE-2021-26874": {"epss_score": 0.00387, "epss_percentile": 0.59335}, "CVE-2021-26875": {"epss_score": 0.00355, "epss_percentile": 0.57325}, "CVE-2021-26876": {"epss_score": 0.14566, "epss_percentile": 0.94242}, "CVE-2021-26877": {"epss_score": 0.10581, "epss_percentile": 0.93034}, "CVE-2021-26878": {"epss_score": 0.00355, "epss_percentile": 0.57325}, "CVE-2021-26879": {"epss_score": 0.23956, "epss_percentile": 0.95837}, "CVE-2021-26880": {"epss_score": 0.00513, "epss_percentile": 0.65932}, "CVE-2021-26881": {"epss_score": 0.08498, "epss_percentile": 0.92084}, "CVE-2021-26882": {"epss_score": 0.06066, "epss_percentile": 0.90447}, "CVE-2021-26884": {"epss_score": 0.00446, "epss_percentile": 0.62929}, "CVE-2021-26885": {"epss_score": 0.3174, "epss_percentile": 0.96644}, "CVE-2021-26886": {"epss_score": 0.00206, "epss_percentile": 0.43073}, "CVE-2021-26887": {"epss_score": 0.00459, "epss_percentile": 0.63497}, "CVE-2021-26889": {"epss_score": 0.00679, "epss_percentile": 0.71005}, "CVE-2021-26890": {"epss_score": 0.00738, "epss_percentile": 0.72345}, "CVE-2021-26891": {"epss_score": 0.00378, "epss_percentile": 0.58821}, "CVE-2021-26892": {"epss_score": 0.00748, "epss_percentile": 0.72581}, "CVE-2021-26893": {"epss_score": 0.0831, "epss_percentile": 0.91984}, "CVE-2021-26894": {"epss_score": 0.09935, "epss_percentile": 0.9278}, "CVE-2021-26895": {"epss_score": 0.09935, "epss_percentile": 0.9278}, "CVE-2021-26896": {"epss_score": 0.20423, "epss_percentile": 0.95343}, "CVE-2021-26897": {"epss_score": 0.10984, "epss_percentile": 0.93183}, "CVE-2021-26898": {"epss_score": 0.0051, "epss_percentile": 0.65795}, "CVE-2021-26899": {"epss_score": 0.00441, "epss_percentile": 0.6266}, "CVE-2021-26900": {"epss_score": 0.05334, "epss_percentile": 0.89741}, "CVE-2021-26901": {"epss_score": 0.0051, "epss_percentile": 0.65795}, "CVE-2021-26902": {"epss_score": 0.07761, "epss_percentile": 0.91664}, "CVE-2021-26903": {"epss_score": 0.00435, "epss_percentile": 0.62333}, "CVE-2021-26904": {"epss_score": 0.00727, "epss_percentile": 0.72084}, "CVE-2021-26905": {"epss_score": 0.00219, "epss_percentile": 0.44493}, "CVE-2021-26906": {"epss_score": 0.00506, "epss_percentile": 0.65627}, "CVE-2021-26908": {"epss_score": 0.00054, "epss_percentile": 0.17226}, "CVE-2021-26909": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2021-26910": {"epss_score": 0.0005, "epss_percentile": 0.1598}, "CVE-2021-26911": {"epss_score": 0.00284, "epss_percentile": 0.51429}, "CVE-2021-26912": {"epss_score": 0.35429, "epss_percentile": 0.96908}, "CVE-2021-26913": {"epss_score": 0.35429, "epss_percentile": 0.96908}, "CVE-2021-26914": {"epss_score": 0.64438, "epss_percentile": 0.98378}, "CVE-2021-26915": {"epss_score": 0.34158, "epss_percentile": 0.96828}, "CVE-2021-26916": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2021-26917": {"epss_score": 0.00083, "epss_percentile": 0.24714}, "CVE-2021-26918": {"epss_score": 0.00782, "epss_percentile": 0.73203}, "CVE-2021-26919": {"epss_score": 0.79309, "epss_percentile": 0.99031}, "CVE-2021-26920": {"epss_score": 0.03207, "epss_percentile": 0.86639}, "CVE-2021-26921": {"epss_score": 0.00242, "epss_percentile": 0.47346}, "CVE-2021-26923": {"epss_score": 0.00544, "epss_percentile": 0.67137}, "CVE-2021-26924": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-26925": {"epss_score": 0.00259, "epss_percentile": 0.49092}, "CVE-2021-26926": {"epss_score": 0.00114, "epss_percentile": 0.3081}, "CVE-2021-26927": {"epss_score": 0.00082, "epss_percentile": 0.24451}, "CVE-2021-26928": {"epss_score": 0.00332, "epss_percentile": 0.55588}, "CVE-2021-26929": {"epss_score": 0.03502, "epss_percentile": 0.87251}, "CVE-2021-26930": {"epss_score": 0.00107, "epss_percentile": 0.29662}, "CVE-2021-26931": {"epss_score": 0.00069, "epss_percentile": 0.21515}, "CVE-2021-26932": {"epss_score": 0.00186, "epss_percentile": 0.40637}, "CVE-2021-26933": {"epss_score": 0.00081, "epss_percentile": 0.24219}, "CVE-2021-26934": {"epss_score": 0.00133, "epss_percentile": 0.33714}, "CVE-2021-26935": {"epss_score": 0.00581, "epss_percentile": 0.68282}, "CVE-2021-26936": {"epss_score": 0.00032, "epss_percentile": 0.08833}, "CVE-2021-26937": {"epss_score": 0.12654, "epss_percentile": 0.93741}, "CVE-2021-26938": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-26939": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-26943": {"epss_score": 0.05598, "epss_percentile": 0.90035}, "CVE-2021-26945": {"epss_score": 0.00256, "epss_percentile": 0.48817}, "CVE-2021-26947": {"epss_score": 0.00588, "epss_percentile": 0.685}, "CVE-2021-26948": {"epss_score": 0.00151, "epss_percentile": 0.36319}, "CVE-2021-26950": {"epss_score": 0.00054, "epss_percentile": 0.1708}, "CVE-2021-26951": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-26952": {"epss_score": 0.00291, "epss_percentile": 0.52156}, "CVE-2021-26953": {"epss_score": 0.00291, "epss_percentile": 0.52156}, "CVE-2021-26954": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2021-26955": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-26956": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-26957": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-26958": {"epss_score": 0.00568, "epss_percentile": 0.67878}, "CVE-2021-26960": {"epss_score": 0.00314, "epss_percentile": 0.54113}, "CVE-2021-26961": {"epss_score": 0.00314, "epss_percentile": 0.54113}, "CVE-2021-26962": {"epss_score": 0.03628, "epss_percentile": 0.87466}, "CVE-2021-26963": {"epss_score": 0.03628, "epss_percentile": 0.87466}, "CVE-2021-26964": {"epss_score": 0.0009, "epss_percentile": 0.26056}, "CVE-2021-26965": {"epss_score": 0.00227, "epss_percentile": 0.45387}, "CVE-2021-26966": {"epss_score": 0.00257, "epss_percentile": 0.48863}, "CVE-2021-26967": {"epss_score": 0.00301, "epss_percentile": 0.53018}, "CVE-2021-26968": {"epss_score": 0.00211, "epss_percentile": 0.43625}, "CVE-2021-26969": {"epss_score": 0.00857, "epss_percentile": 0.74495}, "CVE-2021-26970": {"epss_score": 0.01105, "epss_percentile": 0.77611}, "CVE-2021-26971": {"epss_score": 0.01105, "epss_percentile": 0.77611}, "CVE-2021-26987": {"epss_score": 0.0187, "epss_percentile": 0.82627}, "CVE-2021-26988": {"epss_score": 0.00137, "epss_percentile": 0.34231}, "CVE-2021-26989": {"epss_score": 0.00797, "epss_percentile": 0.73499}, "CVE-2021-26990": {"epss_score": 0.00598, "epss_percentile": 0.68764}, "CVE-2021-26991": {"epss_score": 0.00206, "epss_percentile": 0.42948}, "CVE-2021-26992": {"epss_score": 0.00703, "epss_percentile": 0.71527}, "CVE-2021-26993": {"epss_score": 0.00445, "epss_percentile": 0.62888}, "CVE-2021-26994": {"epss_score": 0.00372, "epss_percentile": 0.58452}, "CVE-2021-26995": {"epss_score": 0.00976, "epss_percentile": 0.76211}, "CVE-2021-26996": {"epss_score": 0.0026, "epss_percentile": 0.49172}, "CVE-2021-26997": {"epss_score": 0.00237, "epss_percentile": 0.4665}, "CVE-2021-26998": {"epss_score": 0.00227, "epss_percentile": 0.4539}, "CVE-2021-26999": {"epss_score": 0.00227, "epss_percentile": 0.4539}, "CVE-2021-27001": {"epss_score": 0.00059, "epss_percentile": 0.18675}, "CVE-2021-27002": {"epss_score": 0.00754, "epss_percentile": 0.72697}, "CVE-2021-27003": {"epss_score": 0.00206, "epss_percentile": 0.43072}, "CVE-2021-27004": {"epss_score": 0.00127, "epss_percentile": 0.32886}, "CVE-2021-27005": {"epss_score": 0.00703, "epss_percentile": 0.71527}, "CVE-2021-27006": {"epss_score": 0.00064, "epss_percentile": 0.20169}, "CVE-2021-27007": {"epss_score": 0.00713, "epss_percentile": 0.71783}, "CVE-2021-27017": {"epss_score": 0.00236, "epss_percentile": 0.46456}, "CVE-2021-27018": {"epss_score": 0.00095, "epss_percentile": 0.27099}, "CVE-2021-27019": {"epss_score": 0.00204, "epss_percentile": 0.42626}, "CVE-2021-27020": {"epss_score": 0.00495, "epss_percentile": 0.651}, "CVE-2021-27021": {"epss_score": 0.00626, "epss_percentile": 0.69605}, "CVE-2021-27022": {"epss_score": 0.00335, "epss_percentile": 0.55895}, "CVE-2021-27023": {"epss_score": 0.00397, "epss_percentile": 0.60046}, "CVE-2021-27024": {"epss_score": 0.00317, "epss_percentile": 0.54384}, "CVE-2021-27025": {"epss_score": 0.0048, "epss_percentile": 0.64478}, "CVE-2021-27026": {"epss_score": 0.00058, "epss_percentile": 0.18373}, "CVE-2021-27027": {"epss_score": 0.00319, "epss_percentile": 0.54571}, "CVE-2021-27028": {"epss_score": 0.00728, "epss_percentile": 0.7211}, "CVE-2021-27029": {"epss_score": 0.00138, "epss_percentile": 0.34409}, "CVE-2021-27030": {"epss_score": 0.49329, "epss_percentile": 0.9768}, "CVE-2021-27031": {"epss_score": 0.00258, "epss_percentile": 0.4895}, "CVE-2021-27032": {"epss_score": 0.00033, "epss_percentile": 0.09213}, "CVE-2021-27033": {"epss_score": 0.00891, "epss_percentile": 0.7505}, "CVE-2021-27034": {"epss_score": 0.00666, "epss_percentile": 0.70689}, "CVE-2021-27035": {"epss_score": 0.00274, "epss_percentile": 0.50516}, "CVE-2021-27036": {"epss_score": 0.00274, "epss_percentile": 0.50516}, "CVE-2021-27037": {"epss_score": 0.00483, "epss_percentile": 0.64611}, "CVE-2021-27038": {"epss_score": 0.00306, "epss_percentile": 0.53423}, "CVE-2021-27039": {"epss_score": 0.00262, "epss_percentile": 0.4936}, "CVE-2021-27040": {"epss_score": 0.00332, "epss_percentile": 0.55585}, "CVE-2021-27041": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2021-27042": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2021-27043": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2021-27044": {"epss_score": 0.00971, "epss_percentile": 0.7613}, "CVE-2021-27045": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-27046": {"epss_score": 0.00068, "epss_percentile": 0.21237}, "CVE-2021-27047": {"epss_score": 0.07761, "epss_percentile": 0.91664}, "CVE-2021-27048": {"epss_score": 0.02133, "epss_percentile": 0.8372}, "CVE-2021-27049": {"epss_score": 0.02133, "epss_percentile": 0.8372}, "CVE-2021-27050": {"epss_score": 0.08369, "epss_percentile": 0.92014}, "CVE-2021-27051": {"epss_score": 0.02133, "epss_percentile": 0.8372}, "CVE-2021-27052": {"epss_score": 0.08862, "epss_percentile": 0.92291}, "CVE-2021-27053": {"epss_score": 0.0356, "epss_percentile": 0.87353}, "CVE-2021-27054": {"epss_score": 0.0356, "epss_percentile": 0.87353}, "CVE-2021-27055": {"epss_score": 0.01253, "epss_percentile": 0.78917}, "CVE-2021-27056": {"epss_score": 0.12755, "epss_percentile": 0.93764}, "CVE-2021-27057": {"epss_score": 0.04203, "epss_percentile": 0.88391}, "CVE-2021-27058": {"epss_score": 0.08307, "epss_percentile": 0.91982}, "CVE-2021-27059": {"epss_score": 0.02255, "epss_percentile": 0.84166}, "CVE-2021-27060": {"epss_score": 0.03079, "epss_percentile": 0.86368}, "CVE-2021-27061": {"epss_score": 0.08369, "epss_percentile": 0.92014}, "CVE-2021-27062": {"epss_score": 0.02133, "epss_percentile": 0.8372}, "CVE-2021-27063": {"epss_score": 0.12525, "epss_percentile": 0.93709}, "CVE-2021-27064": {"epss_score": 0.00242, "epss_percentile": 0.47383}, "CVE-2021-27065": {"epss_score": 0.94282, "epss_percentile": 0.99934}, "CVE-2021-27066": {"epss_score": 0.03502, "epss_percentile": 0.87251}, "CVE-2021-27067": {"epss_score": 0.12326, "epss_percentile": 0.93641}, "CVE-2021-27068": {"epss_score": 0.10094, "epss_percentile": 0.92847}, "CVE-2021-27070": {"epss_score": 0.03809, "epss_percentile": 0.87755}, "CVE-2021-27072": {"epss_score": 0.0054, "epss_percentile": 0.66991}, "CVE-2021-27074": {"epss_score": 0.00443, "epss_percentile": 0.62789}, "CVE-2021-27075": {"epss_score": 0.00478, "epss_percentile": 0.64381}, "CVE-2021-27076": {"epss_score": 0.10556, "epss_percentile": 0.93027}, "CVE-2021-27077": {"epss_score": 0.02947, "epss_percentile": 0.86042}, "CVE-2021-27078": {"epss_score": 0.32551, "epss_percentile": 0.96708}, "CVE-2021-27079": {"epss_score": 0.08228, "epss_percentile": 0.9194}, "CVE-2021-27080": {"epss_score": 0.0018, "epss_percentile": 0.39937}, "CVE-2021-27081": {"epss_score": 0.10474, "epss_percentile": 0.92998}, "CVE-2021-27082": {"epss_score": 0.05778, "epss_percentile": 0.90198}, "CVE-2021-27083": {"epss_score": 0.12017, "epss_percentile": 0.93548}, "CVE-2021-27084": {"epss_score": 0.12019, "epss_percentile": 0.93549}, "CVE-2021-27085": {"epss_score": 0.02184, "epss_percentile": 0.83912}, "CVE-2021-27086": {"epss_score": 0.00279, "epss_percentile": 0.50974}, "CVE-2021-27088": {"epss_score": 0.00216, "epss_percentile": 0.44203}, "CVE-2021-27089": {"epss_score": 0.01106, "epss_percentile": 0.77619}, "CVE-2021-27090": {"epss_score": 0.01999, "epss_percentile": 0.83212}, "CVE-2021-27091": {"epss_score": 0.00431, "epss_percentile": 0.62086}, "CVE-2021-27092": {"epss_score": 0.1067, "epss_percentile": 0.93064}, "CVE-2021-27093": {"epss_score": 0.00598, "epss_percentile": 0.68762}, "CVE-2021-27094": {"epss_score": 0.00407, "epss_percentile": 0.60615}, "CVE-2021-27095": {"epss_score": 0.01983, "epss_percentile": 0.83149}, "CVE-2021-27096": {"epss_score": 0.00262, "epss_percentile": 0.49397}, "CVE-2021-27097": {"epss_score": 0.00056, "epss_percentile": 0.17686}, "CVE-2021-27098": {"epss_score": 0.00117, "epss_percentile": 0.31262}, "CVE-2021-27099": {"epss_score": 0.00211, "epss_percentile": 0.43711}, "CVE-2021-27101": {"epss_score": 0.01047, "epss_percentile": 0.77034}, "CVE-2021-27102": {"epss_score": 0.00337, "epss_percentile": 0.56052}, "CVE-2021-27103": {"epss_score": 0.0213, "epss_percentile": 0.83711}, "CVE-2021-27104": {"epss_score": 0.02442, "epss_percentile": 0.84757}, "CVE-2021-27112": {"epss_score": 0.02228, "epss_percentile": 0.84076}, "CVE-2021-27113": {"epss_score": 0.30981, "epss_percentile": 0.96579}, "CVE-2021-27114": {"epss_score": 0.01856, "epss_percentile": 0.82572}, "CVE-2021-27116": {"epss_score": 0.0016, "epss_percentile": 0.37513}, "CVE-2021-27117": {"epss_score": 0.0016, "epss_percentile": 0.37513}, "CVE-2021-27124": {"epss_score": 0.22289, "epss_percentile": 0.95619}, "CVE-2021-27129": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2021-27130": {"epss_score": 0.00537, "epss_percentile": 0.66901}, "CVE-2021-27131": {"epss_score": 0.00125, "epss_percentile": 0.32605}, "CVE-2021-27132": {"epss_score": 0.7855, "epss_percentile": 0.98992}, "CVE-2021-27135": {"epss_score": 0.04467, "epss_percentile": 0.8873}, "CVE-2021-27138": {"epss_score": 0.0006, "epss_percentile": 0.19234}, "CVE-2021-27139": {"epss_score": 0.00051, "epss_percentile": 0.16261}, "CVE-2021-27140": {"epss_score": 0.00046, "epss_percentile": 0.14191}, "CVE-2021-27141": {"epss_score": 0.00681, "epss_percentile": 0.71058}, "CVE-2021-27142": {"epss_score": 0.00146, "epss_percentile": 0.35528}, "CVE-2021-27143": {"epss_score": 0.00681, "epss_percentile": 0.71058}, "CVE-2021-27144": {"epss_score": 0.00681, "epss_percentile": 0.71058}, "CVE-2021-27145": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27146": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27147": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27148": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27149": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27150": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27151": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27152": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27153": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27154": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27155": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27156": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27157": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27158": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27159": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27160": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27161": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27162": {"epss_score": 0.00188, "epss_percentile": 0.40862}, "CVE-2021-27163": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27164": {"epss_score": 0.00699, "epss_percentile": 0.7144}, "CVE-2021-27165": {"epss_score": 0.00639, "epss_percentile": 0.69947}, "CVE-2021-27166": {"epss_score": 0.00215, "epss_percentile": 0.44093}, "CVE-2021-27167": {"epss_score": 0.00639, "epss_percentile": 0.69947}, "CVE-2021-27168": {"epss_score": 0.00639, "epss_percentile": 0.69947}, "CVE-2021-27169": {"epss_score": 0.00639, "epss_percentile": 0.69947}, "CVE-2021-27170": {"epss_score": 0.00085, "epss_percentile": 0.2509}, "CVE-2021-27171": {"epss_score": 0.00077, "epss_percentile": 0.23363}, "CVE-2021-27172": {"epss_score": 0.00639, "epss_percentile": 0.69947}, "CVE-2021-27173": {"epss_score": 0.00075, "epss_percentile": 0.2301}, "CVE-2021-27174": {"epss_score": 0.00041, "epss_percentile": 0.12389}, "CVE-2021-27175": {"epss_score": 0.00041, "epss_percentile": 0.12389}, "CVE-2021-27176": {"epss_score": 0.00066, "epss_percentile": 0.20894}, "CVE-2021-27177": {"epss_score": 0.00095, "epss_percentile": 0.27132}, "CVE-2021-27178": {"epss_score": 0.00043, "epss_percentile": 0.13222}, "CVE-2021-27179": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2021-27180": {"epss_score": 0.00308, "epss_percentile": 0.53577}, "CVE-2021-27181": {"epss_score": 0.00131, "epss_percentile": 0.33352}, "CVE-2021-27182": {"epss_score": 0.00857, "epss_percentile": 0.74493}, "CVE-2021-27183": {"epss_score": 0.04398, "epss_percentile": 0.88644}, "CVE-2021-27184": {"epss_score": 0.00319, "epss_percentile": 0.54469}, "CVE-2021-27185": {"epss_score": 0.14458, "epss_percentile": 0.94216}, "CVE-2021-27186": {"epss_score": 0.00409, "epss_percentile": 0.6076}, "CVE-2021-27187": {"epss_score": 0.00572, "epss_percentile": 0.68024}, "CVE-2021-27188": {"epss_score": 0.00353, "epss_percentile": 0.57142}, "CVE-2021-27189": {"epss_score": 0.00265, "epss_percentile": 0.49815}, "CVE-2021-27190": {"epss_score": 0.03857, "epss_percentile": 0.87859}, "CVE-2021-27191": {"epss_score": 0.00563, "epss_percentile": 0.67714}, "CVE-2021-27192": {"epss_score": 0.00052, "epss_percentile": 0.1661}, "CVE-2021-27193": {"epss_score": 0.01176, "epss_percentile": 0.78273}, "CVE-2021-27194": {"epss_score": 0.00237, "epss_percentile": 0.46708}, "CVE-2021-27195": {"epss_score": 0.00246, "epss_percentile": 0.47774}, "CVE-2021-27196": {"epss_score": 0.01045, "epss_percentile": 0.77018}, "CVE-2021-27197": {"epss_score": 0.00295, "epss_percentile": 0.52498}, "CVE-2021-27198": {"epss_score": 0.12315, "epss_percentile": 0.93639}, "CVE-2021-27200": {"epss_score": 0.03045, "epss_percentile": 0.86281}, "CVE-2021-27201": {"epss_score": 0.01609, "epss_percentile": 0.81316}, "CVE-2021-27203": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2021-27204": {"epss_score": 0.00037, "epss_percentile": 0.10816}, "CVE-2021-27205": {"epss_score": 0.00037, "epss_percentile": 0.10816}, "CVE-2021-27208": {"epss_score": 0.0019, "epss_percentile": 0.41053}, "CVE-2021-27209": {"epss_score": 0.00024, "epss_percentile": 0.05814}, "CVE-2021-27210": {"epss_score": 0.001, "epss_percentile": 0.28562}, "CVE-2021-27211": {"epss_score": 0.0064, "epss_percentile": 0.69966}, "CVE-2021-27212": {"epss_score": 0.35807, "epss_percentile": 0.96935}, "CVE-2021-27213": {"epss_score": 0.00393, "epss_percentile": 0.59729}, "CVE-2021-27214": {"epss_score": 0.0959, "epss_percentile": 0.92613}, "CVE-2021-27215": {"epss_score": 0.00783, "epss_percentile": 0.73224}, "CVE-2021-27216": {"epss_score": 0.0013, "epss_percentile": 0.33288}, "CVE-2021-27217": {"epss_score": 0.00615, "epss_percentile": 0.69294}, "CVE-2021-27218": {"epss_score": 0.05212, "epss_percentile": 0.89617}, "CVE-2021-27219": {"epss_score": 0.01483, "epss_percentile": 0.80586}, "CVE-2021-27220": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2021-27221": {"epss_score": 0.41887, "epss_percentile": 0.97299}, "CVE-2021-27222": {"epss_score": 0.00262, "epss_percentile": 0.49378}, "CVE-2021-27223": {"epss_score": 0.00048, "epss_percentile": 0.15028}, "CVE-2021-27224": {"epss_score": 0.05642, "epss_percentile": 0.90078}, "CVE-2021-27225": {"epss_score": 0.00132, "epss_percentile": 0.33511}, "CVE-2021-27228": {"epss_score": 0.00435, "epss_percentile": 0.62332}, "CVE-2021-27229": {"epss_score": 0.02596, "epss_percentile": 0.85198}, "CVE-2021-27230": {"epss_score": 0.03009, "epss_percentile": 0.86194}, "CVE-2021-27231": {"epss_score": 0.00317, "epss_percentile": 0.54329}, "CVE-2021-27232": {"epss_score": 0.0067, "epss_percentile": 0.70783}, "CVE-2021-27233": {"epss_score": 0.00125, "epss_percentile": 0.32478}, "CVE-2021-27234": {"epss_score": 0.00366, "epss_percentile": 0.58079}, "CVE-2021-27235": {"epss_score": 0.00267, "epss_percentile": 0.49975}, "CVE-2021-27236": {"epss_score": 0.01896, "epss_percentile": 0.8275}, "CVE-2021-27237": {"epss_score": 0.0034, "epss_percentile": 0.56243}, "CVE-2021-27239": {"epss_score": 0.02592, "epss_percentile": 0.85184}, "CVE-2021-27240": {"epss_score": 0.01539, "epss_percentile": 0.80937}, "CVE-2021-27241": {"epss_score": 0.00039, "epss_percentile": 0.11592}, "CVE-2021-27242": {"epss_score": 0.00093, "epss_percentile": 0.2671}, "CVE-2021-27243": {"epss_score": 0.00093, "epss_percentile": 0.2671}, "CVE-2021-27244": {"epss_score": 0.0009, "epss_percentile": 0.2612}, "CVE-2021-27245": {"epss_score": 0.04207, "epss_percentile": 0.88396}, "CVE-2021-27246": {"epss_score": 0.07877, "epss_percentile": 0.91738}, "CVE-2021-27247": {"epss_score": 0.00604, "epss_percentile": 0.68954}, "CVE-2021-27248": {"epss_score": 0.00658, "epss_percentile": 0.70484}, "CVE-2021-27249": {"epss_score": 0.01441, "epss_percentile": 0.80305}, "CVE-2021-27250": {"epss_score": 0.70313, "epss_percentile": 0.98628}, "CVE-2021-27251": {"epss_score": 0.00295, "epss_percentile": 0.52456}, "CVE-2021-27252": {"epss_score": 0.00557, "epss_percentile": 0.67537}, "CVE-2021-27253": {"epss_score": 0.0074, "epss_percentile": 0.72404}, "CVE-2021-27254": {"epss_score": 0.00084, "epss_percentile": 0.24995}, "CVE-2021-27255": {"epss_score": 0.01665, "epss_percentile": 0.81645}, "CVE-2021-27256": {"epss_score": 0.00557, "epss_percentile": 0.67537}, "CVE-2021-27257": {"epss_score": 0.00057, "epss_percentile": 0.18062}, "CVE-2021-27258": {"epss_score": 0.11234, "epss_percentile": 0.93273}, "CVE-2021-27259": {"epss_score": 0.00117, "epss_percentile": 0.31332}, "CVE-2021-27260": {"epss_score": 0.00099, "epss_percentile": 0.28354}, "CVE-2021-27261": {"epss_score": 0.06075, "epss_percentile": 0.90457}, "CVE-2021-27262": {"epss_score": 0.14423, "epss_percentile": 0.94209}, "CVE-2021-27263": {"epss_score": 0.2433, "epss_percentile": 0.95906}, "CVE-2021-27264": {"epss_score": 0.14423, "epss_percentile": 0.94209}, "CVE-2021-27265": {"epss_score": 0.14423, "epss_percentile": 0.94209}, "CVE-2021-27266": {"epss_score": 0.14423, "epss_percentile": 0.94209}, "CVE-2021-27267": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-27268": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-27269": {"epss_score": 0.06075, "epss_percentile": 0.90457}, "CVE-2021-27270": {"epss_score": 0.03965, "epss_percentile": 0.88028}, "CVE-2021-27271": {"epss_score": 0.03849, "epss_percentile": 0.87844}, "CVE-2021-27272": {"epss_score": 0.14527, "epss_percentile": 0.94231}, "CVE-2021-27273": {"epss_score": 0.79159, "epss_percentile": 0.99021}, "CVE-2021-27274": {"epss_score": 0.51302, "epss_percentile": 0.97775}, "CVE-2021-27275": {"epss_score": 0.59585, "epss_percentile": 0.98171}, "CVE-2021-27276": {"epss_score": 0.10965, "epss_percentile": 0.93179}, "CVE-2021-27277": {"epss_score": 0.02208, "epss_percentile": 0.8401}, "CVE-2021-27278": {"epss_score": 0.00052, "epss_percentile": 0.16556}, "CVE-2021-27279": {"epss_score": 0.00379, "epss_percentile": 0.58905}, "CVE-2021-27280": {"epss_score": 0.00027, "epss_percentile": 0.06958}, "CVE-2021-27285": {"epss_score": 0.00091, "epss_percentile": 0.26288}, "CVE-2021-27288": {"epss_score": 0.00379, "epss_percentile": 0.58881}, "CVE-2021-27289": {"epss_score": 0.00165, "epss_percentile": 0.38129}, "CVE-2021-27290": {"epss_score": 0.02628, "epss_percentile": 0.85272}, "CVE-2021-27291": {"epss_score": 0.02751, "epss_percentile": 0.85582}, "CVE-2021-27292": {"epss_score": 0.00266, "epss_percentile": 0.49927}, "CVE-2021-27293": {"epss_score": 0.00502, "epss_percentile": 0.65368}, "CVE-2021-27306": {"epss_score": 0.01471, "epss_percentile": 0.80506}, "CVE-2021-27308": {"epss_score": 0.00485, "epss_percentile": 0.64729}, "CVE-2021-27309": {"epss_score": 0.00874, "epss_percentile": 0.74768}, "CVE-2021-27310": {"epss_score": 0.04092, "epss_percentile": 0.88238}, "CVE-2021-27312": {"epss_score": 0.01935, "epss_percentile": 0.82957}, "CVE-2021-27314": {"epss_score": 0.78706, "epss_percentile": 0.99}, "CVE-2021-27315": {"epss_score": 0.71381, "epss_percentile": 0.98665}, "CVE-2021-27316": {"epss_score": 0.71381, "epss_percentile": 0.98665}, "CVE-2021-27317": {"epss_score": 0.00342, "epss_percentile": 0.56357}, "CVE-2021-27318": {"epss_score": 0.00441, "epss_percentile": 0.62686}, "CVE-2021-27319": {"epss_score": 0.72221, "epss_percentile": 0.987}, "CVE-2021-27320": {"epss_score": 0.76248, "epss_percentile": 0.98884}, "CVE-2021-27328": {"epss_score": 0.57084, "epss_percentile": 0.98048}, "CVE-2021-27329": {"epss_score": 0.0029, "epss_percentile": 0.52105}, "CVE-2021-27330": {"epss_score": 0.22381, "epss_percentile": 0.95628}, "CVE-2021-27332": {"epss_score": 0.00285, "epss_percentile": 0.51542}, "CVE-2021-27335": {"epss_score": 0.01988, "epss_percentile": 0.83166}, "CVE-2021-27338": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-27340": {"epss_score": 0.00375, "epss_percentile": 0.58603}, "CVE-2021-27341": {"epss_score": 0.00836, "epss_percentile": 0.74132}, "CVE-2021-27342": {"epss_score": 0.0743, "epss_percentile": 0.91471}, "CVE-2021-27343": {"epss_score": 0.00446, "epss_percentile": 0.62893}, "CVE-2021-27345": {"epss_score": 0.00086, "epss_percentile": 0.25385}, "CVE-2021-27347": {"epss_score": 0.00072, "epss_percentile": 0.22329}, "CVE-2021-27349": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-27351": {"epss_score": 0.00179, "epss_percentile": 0.3975}, "CVE-2021-27352": {"epss_score": 0.00201, "epss_percentile": 0.42391}, "CVE-2021-27357": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2021-27358": {"epss_score": 0.87049, "epss_percentile": 0.99411}, "CVE-2021-27362": {"epss_score": 0.04239, "epss_percentile": 0.88432}, "CVE-2021-27363": {"epss_score": 0.00146, "epss_percentile": 0.35617}, "CVE-2021-27364": {"epss_score": 0.00033, "epss_percentile": 0.09286}, "CVE-2021-27365": {"epss_score": 0.00455, "epss_percentile": 0.63292}, "CVE-2021-27367": {"epss_score": 0.00274, "epss_percentile": 0.50489}, "CVE-2021-27368": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-27369": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-27370": {"epss_score": 0.00297, "epss_percentile": 0.52691}, "CVE-2021-27371": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2021-27372": {"epss_score": 0.0032, "epss_percentile": 0.54635}, "CVE-2021-27374": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2021-27375": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2021-27376": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-27377": {"epss_score": 0.00509, "epss_percentile": 0.65724}, "CVE-2021-27378": {"epss_score": 0.00468, "epss_percentile": 0.63913}, "CVE-2021-27379": {"epss_score": 0.0007, "epss_percentile": 0.21879}, "CVE-2021-27380": {"epss_score": 0.00357, "epss_percentile": 0.57474}, "CVE-2021-27381": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-27382": {"epss_score": 0.00669, "epss_percentile": 0.70765}, "CVE-2021-27383": {"epss_score": 0.00436, "epss_percentile": 0.6248}, "CVE-2021-27384": {"epss_score": 0.01434, "epss_percentile": 0.80266}, "CVE-2021-27385": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2021-27386": {"epss_score": 0.00436, "epss_percentile": 0.6248}, "CVE-2021-27387": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-27388": {"epss_score": 0.01865, "epss_percentile": 0.82603}, "CVE-2021-27389": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2021-27390": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2021-27391": {"epss_score": 0.0286, "epss_percentile": 0.8585}, "CVE-2021-27392": {"epss_score": 0.00245, "epss_percentile": 0.4767}, "CVE-2021-27393": {"epss_score": 0.00218, "epss_percentile": 0.44339}, "CVE-2021-27394": {"epss_score": 0.00337, "epss_percentile": 0.56022}, "CVE-2021-27395": {"epss_score": 0.00248, "epss_percentile": 0.47913}, "CVE-2021-27396": {"epss_score": 0.00936, "epss_percentile": 0.7569}, "CVE-2021-27397": {"epss_score": 0.0038, "epss_percentile": 0.58953}, "CVE-2021-27398": {"epss_score": 0.00936, "epss_percentile": 0.7569}, "CVE-2021-27399": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-27400": {"epss_score": 0.00235, "epss_percentile": 0.46234}, "CVE-2021-27401": {"epss_score": 0.00275, "epss_percentile": 0.507}, "CVE-2021-27402": {"epss_score": 0.00304, "epss_percentile": 0.53256}, "CVE-2021-27403": {"epss_score": 0.00938, "epss_percentile": 0.75715}, "CVE-2021-27404": {"epss_score": 0.00164, "epss_percentile": 0.37872}, "CVE-2021-27405": {"epss_score": 0.00563, "epss_percentile": 0.67714}, "CVE-2021-27406": {"epss_score": 0.00602, "epss_percentile": 0.68884}, "CVE-2021-27408": {"epss_score": 0.00221, "epss_percentile": 0.44693}, "CVE-2021-27410": {"epss_score": 0.00552, "epss_percentile": 0.67397}, "CVE-2021-27411": {"epss_score": 0.00212, "epss_percentile": 0.43809}, "CVE-2021-27412": {"epss_score": 0.0027, "epss_percentile": 0.50217}, "CVE-2021-27413": {"epss_score": 0.00794, "epss_percentile": 0.73452}, "CVE-2021-27414": {"epss_score": 0.00102, "epss_percentile": 0.28817}, "CVE-2021-27416": {"epss_score": 0.00523, "epss_percentile": 0.66294}, "CVE-2021-27417": {"epss_score": 0.00182, "epss_percentile": 0.40137}, "CVE-2021-27418": {"epss_score": 0.00218, "epss_percentile": 0.44354}, "CVE-2021-27419": {"epss_score": 0.03141, "epss_percentile": 0.86487}, "CVE-2021-27420": {"epss_score": 0.00292, "epss_percentile": 0.52279}, "CVE-2021-27421": {"epss_score": 0.00454, "epss_percentile": 0.63267}, "CVE-2021-27422": {"epss_score": 0.00097, "epss_percentile": 0.27518}, "CVE-2021-27424": {"epss_score": 0.0026, "epss_percentile": 0.4923}, "CVE-2021-27425": {"epss_score": 0.01981, "epss_percentile": 0.83137}, "CVE-2021-27426": {"epss_score": 0.00245, "epss_percentile": 0.47627}, "CVE-2021-27427": {"epss_score": 0.02114, "epss_percentile": 0.83655}, "CVE-2021-27428": {"epss_score": 0.00245, "epss_percentile": 0.47627}, "CVE-2021-27429": {"epss_score": 0.00042, "epss_percentile": 0.12742}, "CVE-2021-27430": {"epss_score": 0.00085, "epss_percentile": 0.25071}, "CVE-2021-27431": {"epss_score": 0.00517, "epss_percentile": 0.66083}, "CVE-2021-27432": {"epss_score": 0.00222, "epss_percentile": 0.4477}, "CVE-2021-27433": {"epss_score": 0.03779, "epss_percentile": 0.87713}, "CVE-2021-27434": {"epss_score": 0.00216, "epss_percentile": 0.44159}, "CVE-2021-27435": {"epss_score": 0.03522, "epss_percentile": 0.87289}, "CVE-2021-27436": {"epss_score": 0.00185, "epss_percentile": 0.4051}, "CVE-2021-27437": {"epss_score": 0.00174, "epss_percentile": 0.39261}, "CVE-2021-27438": {"epss_score": 0.00276, "epss_percentile": 0.50747}, "CVE-2021-27439": {"epss_score": 0.0107, "epss_percentile": 0.7726}, "CVE-2021-27440": {"epss_score": 0.00269, "epss_percentile": 0.50156}, "CVE-2021-27442": {"epss_score": 0.00145, "epss_percentile": 0.3545}, "CVE-2021-27444": {"epss_score": 0.00298, "epss_percentile": 0.52786}, "CVE-2021-27445": {"epss_score": 0.00031, "epss_percentile": 0.08435}, "CVE-2021-27446": {"epss_score": 0.00282, "epss_percentile": 0.51275}, "CVE-2021-27447": {"epss_score": 0.01457, "epss_percentile": 0.804}, "CVE-2021-27448": {"epss_score": 0.00048, "epss_percentile": 0.15132}, "CVE-2021-27449": {"epss_score": 0.01084, "epss_percentile": 0.77399}, "CVE-2021-27450": {"epss_score": 0.00027, "epss_percentile": 0.06921}, "CVE-2021-27451": {"epss_score": 0.00212, "epss_percentile": 0.43781}, "CVE-2021-27452": {"epss_score": 0.0004, "epss_percentile": 0.12076}, "CVE-2021-27453": {"epss_score": 0.00224, "epss_percentile": 0.45008}, "CVE-2021-27454": {"epss_score": 0.00048, "epss_percentile": 0.15132}, "CVE-2021-27455": {"epss_score": 0.00158, "epss_percentile": 0.372}, "CVE-2021-27456": {"epss_score": 0.00082, "epss_percentile": 0.24547}, "CVE-2021-27457": {"epss_score": 0.00056, "epss_percentile": 0.17868}, "CVE-2021-27458": {"epss_score": 0.00263, "epss_percentile": 0.49408}, "CVE-2021-27459": {"epss_score": 0.00695, "epss_percentile": 0.71368}, "CVE-2021-27460": {"epss_score": 0.00286, "epss_percentile": 0.51741}, "CVE-2021-27461": {"epss_score": 0.00329, "epss_percentile": 0.55394}, "CVE-2021-27462": {"epss_score": 0.00111, "epss_percentile": 0.30336}, "CVE-2021-27463": {"epss_score": 0.00164, "epss_percentile": 0.3798}, "CVE-2021-27464": {"epss_score": 0.00029, "epss_percentile": 0.07746}, "CVE-2021-27465": {"epss_score": 0.0017, "epss_percentile": 0.38682}, "CVE-2021-27466": {"epss_score": 0.00105, "epss_percentile": 0.29364}, "CVE-2021-27467": {"epss_score": 0.00168, "epss_percentile": 0.38501}, "CVE-2021-27468": {"epss_score": 0.00058, "epss_percentile": 0.18405}, "CVE-2021-27470": {"epss_score": 0.00381, "epss_percentile": 0.5903}, "CVE-2021-27471": {"epss_score": 0.00051, "epss_percentile": 0.16049}, "CVE-2021-27472": {"epss_score": 0.00092, "epss_percentile": 0.26448}, "CVE-2021-27473": {"epss_score": 3e-05, "epss_percentile": 0.00069}, "CVE-2021-27474": {"epss_score": 0.00094, "epss_percentile": 0.26784}, "CVE-2021-27475": {"epss_score": 0.00205, "epss_percentile": 0.42708}, "CVE-2021-27476": {"epss_score": 0.00033, "epss_percentile": 0.09303}, "CVE-2021-27477": {"epss_score": 0.00234, "epss_percentile": 0.46171}, "CVE-2021-27478": {"epss_score": 0.00126, "epss_percentile": 0.32779}, "CVE-2021-27479": {"epss_score": 0.00138, "epss_percentile": 0.34373}, "CVE-2021-27480": {"epss_score": 0.0049, "epss_percentile": 0.64923}, "CVE-2021-27481": {"epss_score": 0.00031, "epss_percentile": 0.0854}, "CVE-2021-27482": {"epss_score": 0.00194, "epss_percentile": 0.4155}, "CVE-2021-27483": {"epss_score": 0.00037, "epss_percentile": 0.10841}, "CVE-2021-27485": {"epss_score": 0.00198, "epss_percentile": 0.42028}, "CVE-2021-27486": {"epss_score": 0.00263, "epss_percentile": 0.4952}, "CVE-2021-27487": {"epss_score": 0.00028, "epss_percentile": 0.07496}, "CVE-2021-27488": {"epss_score": 0.00297, "epss_percentile": 0.52754}, "CVE-2021-27489": {"epss_score": 0.00543, "epss_percentile": 0.67104}, "CVE-2021-27490": {"epss_score": 0.00297, "epss_percentile": 0.52754}, "CVE-2021-27491": {"epss_score": 0.0022, "epss_percentile": 0.44552}, "CVE-2021-27492": {"epss_score": 0.007, "epss_percentile": 0.71473}, "CVE-2021-27493": {"epss_score": 0.00162, "epss_percentile": 0.37654}, "CVE-2021-27494": {"epss_score": 0.00619, "epss_percentile": 0.69401}, "CVE-2021-27495": {"epss_score": 0.00192, "epss_percentile": 0.41324}, "CVE-2021-27496": {"epss_score": 0.00297, "epss_percentile": 0.52754}, "CVE-2021-27497": {"epss_score": 0.00255, "epss_percentile": 0.48644}, "CVE-2021-27498": {"epss_score": 0.00136, "epss_percentile": 0.34111}, "CVE-2021-27499": {"epss_score": 0.001, "epss_percentile": 0.28467}, "CVE-2021-27500": {"epss_score": 0.00136, "epss_percentile": 0.34111}, "CVE-2021-27501": {"epss_score": 0.00216, "epss_percentile": 0.44162}, "CVE-2021-27502": {"epss_score": 0.00057, "epss_percentile": 0.18048}, "CVE-2021-27503": {"epss_score": 0.00148, "epss_percentile": 0.35895}, "CVE-2021-27504": {"epss_score": 0.00086, "epss_percentile": 0.2534}, "CVE-2021-27505": {"epss_score": 0.00212, "epss_percentile": 0.438}, "CVE-2021-27506": {"epss_score": 0.00191, "epss_percentile": 0.41275}, "CVE-2021-27509": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2021-27513": {"epss_score": 0.4497, "epss_percentile": 0.97464}, "CVE-2021-27514": {"epss_score": 0.13672, "epss_percentile": 0.94031}, "CVE-2021-27515": {"epss_score": 0.00188, "epss_percentile": 0.40838}, "CVE-2021-27516": {"epss_score": 0.00552, "epss_percentile": 0.67386}, "CVE-2021-27517": {"epss_score": 0.00471, "epss_percentile": 0.64011}, "CVE-2021-27519": {"epss_score": 0.0383, "epss_percentile": 0.87806}, "CVE-2021-27520": {"epss_score": 0.01118, "epss_percentile": 0.77747}, "CVE-2021-27522": {"epss_score": 0.00548, "epss_percentile": 0.6729}, "CVE-2021-27523": {"epss_score": 0.01257, "epss_percentile": 0.78944}, "CVE-2021-27524": {"epss_score": 0.00105, "epss_percentile": 0.29313}, "CVE-2021-27526": {"epss_score": 0.00184, "epss_percentile": 0.4039}, "CVE-2021-27527": {"epss_score": 0.00162, "epss_percentile": 0.37726}, "CVE-2021-27528": {"epss_score": 0.00184, "epss_percentile": 0.4039}, "CVE-2021-27529": {"epss_score": 0.00162, "epss_percentile": 0.37726}, "CVE-2021-27530": {"epss_score": 0.00184, "epss_percentile": 0.4039}, "CVE-2021-27531": {"epss_score": 0.00184, "epss_percentile": 0.4039}, "CVE-2021-27544": {"epss_score": 0.00347, "epss_percentile": 0.56745}, "CVE-2021-27545": {"epss_score": 0.01155, "epss_percentile": 0.78075}, "CVE-2021-27548": {"epss_score": 0.00196, "epss_percentile": 0.41737}, "CVE-2021-27549": {"epss_score": 0.00216, "epss_percentile": 0.44207}, "CVE-2021-27550": {"epss_score": 0.00179, "epss_percentile": 0.39781}, "CVE-2021-27556": {"epss_score": 0.0713, "epss_percentile": 0.91269}, "CVE-2021-27557": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2021-27558": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2021-27559": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-27561": {"epss_score": 0.94106, "epss_percentile": 0.99904}, "CVE-2021-27562": {"epss_score": 0.59458, "epss_percentile": 0.98166}, "CVE-2021-27564": {"epss_score": 0.0042, "epss_percentile": 0.61413}, "CVE-2021-27565": {"epss_score": 0.02416, "epss_percentile": 0.84689}, "CVE-2021-27568": {"epss_score": 0.00647, "epss_percentile": 0.70207}, "CVE-2021-27569": {"epss_score": 0.00064, "epss_percentile": 0.20391}, "CVE-2021-27570": {"epss_score": 0.00114, "epss_percentile": 0.30832}, "CVE-2021-27571": {"epss_score": 0.00225, "epss_percentile": 0.45085}, "CVE-2021-27572": {"epss_score": 0.02807, "epss_percentile": 0.85709}, "CVE-2021-27573": {"epss_score": 0.55269, "epss_percentile": 0.97969}, "CVE-2021-27574": {"epss_score": 0.00203, "epss_percentile": 0.42502}, "CVE-2021-27576": {"epss_score": 0.04499, "epss_percentile": 0.88764}, "CVE-2021-27577": {"epss_score": 0.00419, "epss_percentile": 0.61365}, "CVE-2021-27578": {"epss_score": 0.02311, "epss_percentile": 0.84338}, "CVE-2021-27579": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-27581": {"epss_score": 0.00416, "epss_percentile": 0.61201}, "CVE-2021-27582": {"epss_score": 0.00616, "epss_percentile": 0.6933}, "CVE-2021-27583": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2021-27584": {"epss_score": 0.00137, "epss_percentile": 0.34206}, "CVE-2021-27585": {"epss_score": 0.0029, "epss_percentile": 0.52084}, "CVE-2021-27586": {"epss_score": 0.00226, "epss_percentile": 0.45351}, "CVE-2021-27587": {"epss_score": 0.00251, "epss_percentile": 0.48334}, "CVE-2021-27588": {"epss_score": 0.00226, "epss_percentile": 0.45351}, "CVE-2021-27589": {"epss_score": 0.00185, "epss_percentile": 0.40469}, "CVE-2021-27590": {"epss_score": 0.00226, "epss_percentile": 0.45351}, "CVE-2021-27591": {"epss_score": 0.00226, "epss_percentile": 0.45351}, "CVE-2021-27592": {"epss_score": 0.00244, "epss_percentile": 0.47566}, "CVE-2021-27593": {"epss_score": 0.00154, "epss_percentile": 0.36755}, "CVE-2021-27594": {"epss_score": 0.00154, "epss_percentile": 0.36755}, "CVE-2021-27595": {"epss_score": 0.00137, "epss_percentile": 0.34206}, "CVE-2021-27596": {"epss_score": 0.00137, "epss_percentile": 0.34206}, "CVE-2021-27597": {"epss_score": 0.00278, "epss_percentile": 0.50899}, "CVE-2021-27598": {"epss_score": 0.0028, "epss_percentile": 0.51082}, "CVE-2021-27599": {"epss_score": 0.00234, "epss_percentile": 0.4616}, "CVE-2021-27600": {"epss_score": 0.00222, "epss_percentile": 0.44787}, "CVE-2021-27601": {"epss_score": 0.00162, "epss_percentile": 0.37663}, "CVE-2021-27602": {"epss_score": 0.01896, "epss_percentile": 0.82753}, "CVE-2021-27603": {"epss_score": 0.00448, "epss_percentile": 0.6303}, "CVE-2021-27604": {"epss_score": 0.00343, "epss_percentile": 0.56406}, "CVE-2021-27605": {"epss_score": 0.0012, "epss_percentile": 0.31781}, "CVE-2021-27606": {"epss_score": 0.00278, "epss_percentile": 0.50899}, "CVE-2021-27607": {"epss_score": 0.00324, "epss_percentile": 0.54966}, "CVE-2021-27608": {"epss_score": 0.00122, "epss_percentile": 0.32106}, "CVE-2021-27609": {"epss_score": 0.00136, "epss_percentile": 0.34155}, "CVE-2021-27610": {"epss_score": 0.0055, "epss_percentile": 0.67333}, "CVE-2021-27611": {"epss_score": 0.00111, "epss_percentile": 0.30377}, "CVE-2021-27612": {"epss_score": 0.00181, "epss_percentile": 0.4007}, "CVE-2021-27613": {"epss_score": 0.00041, "epss_percentile": 0.12344}, "CVE-2021-27614": {"epss_score": 0.00042, "epss_percentile": 0.12738}, "CVE-2021-27615": {"epss_score": 0.00361, "epss_percentile": 0.57705}, "CVE-2021-27616": {"epss_score": 0.00034, "epss_percentile": 0.09732}, "CVE-2021-27617": {"epss_score": 0.00209, "epss_percentile": 0.4341}, "CVE-2021-27618": {"epss_score": 0.00209, "epss_percentile": 0.4341}, "CVE-2021-27619": {"epss_score": 0.00184, "epss_percentile": 0.40382}, "CVE-2021-27620": {"epss_score": 0.00507, "epss_percentile": 0.6566}, "CVE-2021-27621": {"epss_score": 0.00221, "epss_percentile": 0.44645}, "CVE-2021-27622": {"epss_score": 0.00507, "epss_percentile": 0.6566}, "CVE-2021-27623": {"epss_score": 0.0027, "epss_percentile": 0.50229}, "CVE-2021-27624": {"epss_score": 0.00507, "epss_percentile": 0.6566}, "CVE-2021-27625": {"epss_score": 0.00507, "epss_percentile": 0.6566}, "CVE-2021-27626": {"epss_score": 0.00507, "epss_percentile": 0.6566}, "CVE-2021-27627": {"epss_score": 0.00507, "epss_percentile": 0.6566}, "CVE-2021-27628": {"epss_score": 0.00278, "epss_percentile": 0.50899}, "CVE-2021-27629": {"epss_score": 0.00278, "epss_percentile": 0.50899}, "CVE-2021-27630": {"epss_score": 0.00324, "epss_percentile": 0.54966}, "CVE-2021-27631": {"epss_score": 0.00324, "epss_percentile": 0.54966}, "CVE-2021-27632": {"epss_score": 0.00324, "epss_percentile": 0.54966}, "CVE-2021-27633": {"epss_score": 0.00278, "epss_percentile": 0.50899}, "CVE-2021-27634": {"epss_score": 0.00211, "epss_percentile": 0.43666}, "CVE-2021-27635": {"epss_score": 0.02079, "epss_percentile": 0.83528}, "CVE-2021-27637": {"epss_score": 0.00055, "epss_percentile": 0.17489}, "CVE-2021-27638": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2021-27639": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2021-27640": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2021-27641": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2021-27642": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2021-27643": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2021-27644": {"epss_score": 0.02092, "epss_percentile": 0.83574}, "CVE-2021-27645": {"epss_score": 0.00037, "epss_percentile": 0.10967}, "CVE-2021-27646": {"epss_score": 0.02203, "epss_percentile": 0.83996}, "CVE-2021-27647": {"epss_score": 0.01674, "epss_percentile": 0.81697}, "CVE-2021-27648": {"epss_score": 0.10117, "epss_percentile": 0.92855}, "CVE-2021-27649": {"epss_score": 0.01457, "epss_percentile": 0.80404}, "CVE-2021-27651": {"epss_score": 0.92069, "epss_percentile": 0.99689}, "CVE-2021-27653": {"epss_score": 0.00309, "epss_percentile": 0.53696}, "CVE-2021-27654": {"epss_score": 0.0013, "epss_percentile": 0.33316}, "CVE-2021-27656": {"epss_score": 0.00246, "epss_percentile": 0.47759}, "CVE-2021-27657": {"epss_score": 0.00286, "epss_percentile": 0.51693}, "CVE-2021-27658": {"epss_score": 0.00225, "epss_percentile": 0.45125}, "CVE-2021-27659": {"epss_score": 0.00265, "epss_percentile": 0.49783}, "CVE-2021-27660": {"epss_score": 0.01164, "epss_percentile": 0.78168}, "CVE-2021-27661": {"epss_score": 0.0019, "epss_percentile": 0.41138}, "CVE-2021-27662": {"epss_score": 0.0018, "epss_percentile": 0.39977}, "CVE-2021-27663": {"epss_score": 0.00727, "epss_percentile": 0.7209}, "CVE-2021-27664": {"epss_score": 0.00269, "epss_percentile": 0.50188}, "CVE-2021-27665": {"epss_score": 0.00322, "epss_percentile": 0.5486}, "CVE-2021-27668": {"epss_score": 0.00349, "epss_percentile": 0.56878}, "CVE-2021-27670": {"epss_score": 0.92837, "epss_percentile": 0.99754}, "CVE-2021-27671": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-27672": {"epss_score": 0.00398, "epss_percentile": 0.60067}, "CVE-2021-27673": {"epss_score": 0.00228, "epss_percentile": 0.45512}, "CVE-2021-27676": {"epss_score": 0.00045, "epss_percentile": 0.14054}, "CVE-2021-27677": {"epss_score": 0.00143, "epss_percentile": 0.35202}, "CVE-2021-27678": {"epss_score": 0.00143, "epss_percentile": 0.35202}, "CVE-2021-27679": {"epss_score": 0.00127, "epss_percentile": 0.32782}, "CVE-2021-27691": {"epss_score": 0.04398, "epss_percentile": 0.88643}, "CVE-2021-27692": {"epss_score": 0.03251, "epss_percentile": 0.86751}, "CVE-2021-27693": {"epss_score": 0.00299, "epss_percentile": 0.52896}, "CVE-2021-27695": {"epss_score": 0.00596, "epss_percentile": 0.68709}, "CVE-2021-27697": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2021-27698": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2021-27700": {"epss_score": 0.00129, "epss_percentile": 0.3312}, "CVE-2021-27701": {"epss_score": 0.00152, "epss_percentile": 0.36428}, "CVE-2021-27702": {"epss_score": 0.00187, "epss_percentile": 0.40725}, "CVE-2021-27703": {"epss_score": 0.0027, "epss_percentile": 0.5025}, "CVE-2021-27704": {"epss_score": 0.00159, "epss_percentile": 0.37407}, "CVE-2021-27705": {"epss_score": 0.03106, "epss_percentile": 0.86419}, "CVE-2021-27706": {"epss_score": 0.03106, "epss_percentile": 0.86419}, "CVE-2021-27707": {"epss_score": 0.03106, "epss_percentile": 0.86419}, "CVE-2021-27708": {"epss_score": 0.2015, "epss_percentile": 0.95295}, "CVE-2021-27710": {"epss_score": 0.2015, "epss_percentile": 0.95295}, "CVE-2021-27715": {"epss_score": 0.00057, "epss_percentile": 0.18143}, "CVE-2021-27722": {"epss_score": 0.00738, "epss_percentile": 0.72339}, "CVE-2021-27730": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-27731": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2021-27733": {"epss_score": 6e-05, "epss_percentile": 0.00241}, "CVE-2021-27734": {"epss_score": 0.00118, "epss_percentile": 0.31436}, "CVE-2021-27736": {"epss_score": 0.00276, "epss_percentile": 0.50724}, "CVE-2021-27737": {"epss_score": 0.072, "epss_percentile": 0.91317}, "CVE-2021-27738": {"epss_score": 0.02184, "epss_percentile": 0.83914}, "CVE-2021-27741": {"epss_score": 0.00371, "epss_percentile": 0.58359}, "CVE-2021-27746": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-27751": {"epss_score": 0.00044, "epss_percentile": 0.13579}, "CVE-2021-27753": {"epss_score": 0.00082, "epss_percentile": 0.24514}, "CVE-2021-27755": {"epss_score": 0.00082, "epss_percentile": 0.24514}, "CVE-2021-27756": {"epss_score": 0.00142, "epss_percentile": 0.34972}, "CVE-2021-27757": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2021-27758": {"epss_score": 0.00084, "epss_percentile": 0.24828}, "CVE-2021-27759": {"epss_score": 0.00102, "epss_percentile": 0.28741}, "CVE-2021-27760": {"epss_score": 0.00472, "epss_percentile": 0.64058}, "CVE-2021-27761": {"epss_score": 0.00116, "epss_percentile": 0.31047}, "CVE-2021-27762": {"epss_score": 0.00268, "epss_percentile": 0.50021}, "CVE-2021-27764": {"epss_score": 0.0011, "epss_percentile": 0.301}, "CVE-2021-27765": {"epss_score": 0.00045, "epss_percentile": 0.13951}, "CVE-2021-27766": {"epss_score": 0.00044, "epss_percentile": 0.13534}, "CVE-2021-27767": {"epss_score": 0.00044, "epss_percentile": 0.13534}, "CVE-2021-27768": {"epss_score": 0.00094, "epss_percentile": 0.26969}, "CVE-2021-27769": {"epss_score": 0.00204, "epss_percentile": 0.42635}, "CVE-2021-27770": {"epss_score": 0.00352, "epss_percentile": 0.57108}, "CVE-2021-27771": {"epss_score": 0.00304, "epss_percentile": 0.53275}, "CVE-2021-27772": {"epss_score": 0.0018, "epss_percentile": 0.39892}, "CVE-2021-27773": {"epss_score": 0.00145, "epss_percentile": 0.35485}, "CVE-2021-27774": {"epss_score": 0.0025, "epss_percentile": 0.48248}, "CVE-2021-27777": {"epss_score": 0.003, "epss_percentile": 0.52944}, "CVE-2021-27778": {"epss_score": 0.00149, "epss_percentile": 0.35944}, "CVE-2021-27779": {"epss_score": 0.00118, "epss_percentile": 0.31406}, "CVE-2021-27780": {"epss_score": 0.00205, "epss_percentile": 0.42673}, "CVE-2021-27781": {"epss_score": 0.00205, "epss_percentile": 0.42742}, "CVE-2021-27782": {"epss_score": 0.00223, "epss_percentile": 0.44961}, "CVE-2021-27783": {"epss_score": 0.00109, "epss_percentile": 0.30041}, "CVE-2021-27784": {"epss_score": 0.00081, "epss_percentile": 0.24302}, "CVE-2021-27785": {"epss_score": 0.00062, "epss_percentile": 0.19675}, "CVE-2021-27786": {"epss_score": 0.00186, "epss_percentile": 0.40596}, "CVE-2021-27788": {"epss_score": 0.00129, "epss_percentile": 0.33171}, "CVE-2021-27789": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2021-27790": {"epss_score": 0.00049, "epss_percentile": 0.15565}, "CVE-2021-27791": {"epss_score": 0.00366, "epss_percentile": 0.58018}, "CVE-2021-27792": {"epss_score": 0.00051, "epss_percentile": 0.16039}, "CVE-2021-27793": {"epss_score": 0.00323, "epss_percentile": 0.5489}, "CVE-2021-27794": {"epss_score": 0.00058, "epss_percentile": 0.18368}, "CVE-2021-27795": {"epss_score": 0.00039, "epss_percentile": 0.11689}, "CVE-2021-27796": {"epss_score": 0.00313, "epss_percentile": 0.5402}, "CVE-2021-27797": {"epss_score": 0.00296, "epss_percentile": 0.52528}, "CVE-2021-27798": {"epss_score": 0.0005, "epss_percentile": 0.15951}, "CVE-2021-27799": {"epss_score": 0.01012, "epss_percentile": 0.76623}, "CVE-2021-27803": {"epss_score": 0.00283, "epss_percentile": 0.51392}, "CVE-2021-27804": {"epss_score": 0.00821, "epss_percentile": 0.73908}, "CVE-2021-27807": {"epss_score": 0.00544, "epss_percentile": 0.67147}, "CVE-2021-27811": {"epss_score": 0.00496, "epss_percentile": 0.65162}, "CVE-2021-27815": {"epss_score": 0.00215, "epss_percentile": 0.44078}, "CVE-2021-27817": {"epss_score": 0.01304, "epss_percentile": 0.79316}, "CVE-2021-27821": {"epss_score": 0.00489, "epss_percentile": 0.64874}, "CVE-2021-27822": {"epss_score": 0.00207, "epss_percentile": 0.4309}, "CVE-2021-27823": {"epss_score": 0.00434, "epss_percentile": 0.62297}, "CVE-2021-27825": {"epss_score": 0.02108, "epss_percentile": 0.83638}, "CVE-2021-27828": {"epss_score": 0.00768, "epss_percentile": 0.72965}, "CVE-2021-27836": {"epss_score": 0.00421, "epss_percentile": 0.61526}, "CVE-2021-27839": {"epss_score": 0.00224, "epss_percentile": 0.45062}, "CVE-2021-27845": {"epss_score": 0.00329, "epss_percentile": 0.55399}, "CVE-2021-27847": {"epss_score": 0.00097, "epss_percentile": 0.27514}, "CVE-2021-27850": {"epss_score": 0.94219, "epss_percentile": 0.99918}, "CVE-2021-27851": {"epss_score": 0.00041, "epss_percentile": 0.12305}, "CVE-2021-27852": {"epss_score": 0.28821, "epss_percentile": 0.9639}, "CVE-2021-27853": {"epss_score": 0.00146, "epss_percentile": 0.35597}, "CVE-2021-27854": {"epss_score": 0.00128, "epss_percentile": 0.32986}, "CVE-2021-27855": {"epss_score": 0.00811, "epss_percentile": 0.73729}, "CVE-2021-27856": {"epss_score": 0.60793, "epss_percentile": 0.98221}, "CVE-2021-27857": {"epss_score": 0.00503, "epss_percentile": 0.65468}, "CVE-2021-27858": {"epss_score": 0.37835, "epss_percentile": 0.97072}, "CVE-2021-27859": {"epss_score": 0.00752, "epss_percentile": 0.72651}, "CVE-2021-27860": {"epss_score": 0.42561, "epss_percentile": 0.97339}, "CVE-2021-27861": {"epss_score": 0.00132, "epss_percentile": 0.33594}, "CVE-2021-27862": {"epss_score": 0.00087, "epss_percentile": 0.25459}, "CVE-2021-27876": {"epss_score": 0.01972, "epss_percentile": 0.83106}, "CVE-2021-27877": {"epss_score": 0.29375, "epss_percentile": 0.96436}, "CVE-2021-27878": {"epss_score": 0.06921, "epss_percentile": 0.91118}, "CVE-2021-27884": {"epss_score": 0.00056, "epss_percentile": 0.17854}, "CVE-2021-27885": {"epss_score": 0.00344, "epss_percentile": 0.56529}, "CVE-2021-27886": {"epss_score": 0.04114, "epss_percentile": 0.88275}, "CVE-2021-27887": {"epss_score": 0.00274, "epss_percentile": 0.50557}, "CVE-2021-27888": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-27889": {"epss_score": 0.02244, "epss_percentile": 0.84123}, "CVE-2021-27890": {"epss_score": 0.05707, "epss_percentile": 0.90138}, "CVE-2021-27891": {"epss_score": 0.00511, "epss_percentile": 0.65827}, "CVE-2021-27892": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2021-27893": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2021-27899": {"epss_score": 0.00107, "epss_percentile": 0.29614}, "CVE-2021-27900": {"epss_score": 0.00245, "epss_percentile": 0.47636}, "CVE-2021-27901": {"epss_score": 0.00041, "epss_percentile": 0.12285}, "CVE-2021-27902": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2021-27903": {"epss_score": 0.03824, "epss_percentile": 0.87791}, "CVE-2021-27904": {"epss_score": 0.00052, "epss_percentile": 0.16634}, "CVE-2021-27905": {"epss_score": 0.93901, "epss_percentile": 0.99865}, "CVE-2021-27906": {"epss_score": 0.00543, "epss_percentile": 0.67119}, "CVE-2021-27907": {"epss_score": 0.02198, "epss_percentile": 0.83963}, "CVE-2021-27908": {"epss_score": 0.00109, "epss_percentile": 0.29943}, "CVE-2021-27909": {"epss_score": 0.18658, "epss_percentile": 0.95048}, "CVE-2021-27910": {"epss_score": 0.00297, "epss_percentile": 0.52713}, "CVE-2021-27911": {"epss_score": 0.00352, "epss_percentile": 0.57123}, "CVE-2021-27912": {"epss_score": 0.00391, "epss_percentile": 0.59587}, "CVE-2021-27913": {"epss_score": 0.00089, "epss_percentile": 0.25802}, "CVE-2021-27914": {"epss_score": 0.00405, "epss_percentile": 0.6051}, "CVE-2021-27915": {"epss_score": 0.00142, "epss_percentile": 0.34995}, "CVE-2021-27916": {"epss_score": 0.00152, "epss_percentile": 0.36429}, "CVE-2021-27917": {"epss_score": 0.00332, "epss_percentile": 0.55555}, "CVE-2021-27918": {"epss_score": 0.00025, "epss_percentile": 0.06342}, "CVE-2021-27919": {"epss_score": 0.00132, "epss_percentile": 0.33578}, "CVE-2021-27921": {"epss_score": 0.00419, "epss_percentile": 0.61378}, "CVE-2021-27922": {"epss_score": 0.00145, "epss_percentile": 0.3542}, "CVE-2021-27923": {"epss_score": 0.00419, "epss_percentile": 0.61378}, "CVE-2021-27924": {"epss_score": 0.00173, "epss_percentile": 0.39126}, "CVE-2021-27925": {"epss_score": 0.00238, "epss_percentile": 0.46816}, "CVE-2021-27927": {"epss_score": 0.00125, "epss_percentile": 0.32506}, "CVE-2021-27928": {"epss_score": 0.47179, "epss_percentile": 0.97573}, "CVE-2021-27930": {"epss_score": 0.00181, "epss_percentile": 0.40085}, "CVE-2021-27931": {"epss_score": 0.91224, "epss_percentile": 0.99628}, "CVE-2021-27932": {"epss_score": 0.0005, "epss_percentile": 0.1569}, "CVE-2021-27933": {"epss_score": 0.01446, "epss_percentile": 0.80325}, "CVE-2021-27935": {"epss_score": 0.00146, "epss_percentile": 0.35623}, "CVE-2021-27938": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-27940": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2021-27941": {"epss_score": 0.00054, "epss_percentile": 0.17173}, "CVE-2021-27942": {"epss_score": 0.00064, "epss_percentile": 0.2021}, "CVE-2021-27943": {"epss_score": 0.00203, "epss_percentile": 0.42523}, "CVE-2021-27944": {"epss_score": 0.01072, "epss_percentile": 0.77282}, "CVE-2021-27945": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2021-27946": {"epss_score": 0.00182, "epss_percentile": 0.40262}, "CVE-2021-27947": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2021-27948": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2021-27949": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-27950": {"epss_score": 0.00473, "epss_percentile": 0.64106}, "CVE-2021-27952": {"epss_score": 0.00365, "epss_percentile": 0.57986}, "CVE-2021-27953": {"epss_score": 0.01258, "epss_percentile": 0.78961}, "CVE-2021-27954": {"epss_score": 0.00391, "epss_percentile": 0.59575}, "CVE-2021-27956": {"epss_score": 0.01483, "epss_percentile": 0.80585}, "CVE-2021-27961": {"epss_score": 0.00032, "epss_percentile": 0.08831}, "CVE-2021-27962": {"epss_score": 0.00366, "epss_percentile": 0.58026}, "CVE-2021-27963": {"epss_score": 0.03115, "epss_percentile": 0.86434}, "CVE-2021-27964": {"epss_score": 0.8087, "epss_percentile": 0.99111}, "CVE-2021-27965": {"epss_score": 0.22627, "epss_percentile": 0.9566}, "CVE-2021-27969": {"epss_score": 0.00207, "epss_percentile": 0.4309}, "CVE-2021-27971": {"epss_score": 0.0005, "epss_percentile": 0.15693}, "CVE-2021-27973": {"epss_score": 0.00267, "epss_percentile": 0.49984}, "CVE-2021-27983": {"epss_score": 0.10612, "epss_percentile": 0.93047}, "CVE-2021-27984": {"epss_score": 0.04249, "epss_percentile": 0.8845}, "CVE-2021-27989": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-27990": {"epss_score": 0.00564, "epss_percentile": 0.67774}, "CVE-2021-27999": {"epss_score": 0.00194, "epss_percentile": 0.41591}, "CVE-2021-28000": {"epss_score": 0.0037, "epss_percentile": 0.58325}, "CVE-2021-28001": {"epss_score": 0.00343, "epss_percentile": 0.56453}, "CVE-2021-28002": {"epss_score": 0.00228, "epss_percentile": 0.45483}, "CVE-2021-28006": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2021-28007": {"epss_score": 0.0019, "epss_percentile": 0.41097}, "CVE-2021-28021": {"epss_score": 0.00149, "epss_percentile": 0.36014}, "CVE-2021-28022": {"epss_score": 0.00325, "epss_percentile": 0.55029}, "CVE-2021-28023": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-28024": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-28025": {"epss_score": 0.00029, "epss_percentile": 0.07971}, "CVE-2021-28026": {"epss_score": 0.00507, "epss_percentile": 0.65672}, "CVE-2021-28027": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-28028": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-28029": {"epss_score": 0.00285, "epss_percentile": 0.51538}, "CVE-2021-28030": {"epss_score": 0.00285, "epss_percentile": 0.51538}, "CVE-2021-28031": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-28032": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-28033": {"epss_score": 0.0046, "epss_percentile": 0.63528}, "CVE-2021-28034": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-28035": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-28036": {"epss_score": 0.00353, "epss_percentile": 0.57162}, "CVE-2021-28037": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-28038": {"epss_score": 0.00211, "epss_percentile": 0.4368}, "CVE-2021-28039": {"epss_score": 0.0014, "epss_percentile": 0.3471}, "CVE-2021-28040": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-28041": {"epss_score": 0.00298, "epss_percentile": 0.52827}, "CVE-2021-28042": {"epss_score": 0.05164, "epss_percentile": 0.89562}, "CVE-2021-28047": {"epss_score": 0.00115, "epss_percentile": 0.30982}, "CVE-2021-28048": {"epss_score": 0.00148, "epss_percentile": 0.35894}, "CVE-2021-28052": {"epss_score": 0.00285, "epss_percentile": 0.51529}, "CVE-2021-28053": {"epss_score": 0.00293, "epss_percentile": 0.52296}, "CVE-2021-28054": {"epss_score": 0.00049, "epss_percentile": 0.15482}, "CVE-2021-28055": {"epss_score": 0.00085, "epss_percentile": 0.25222}, "CVE-2021-28060": {"epss_score": 0.00375, "epss_percentile": 0.58592}, "CVE-2021-28070": {"epss_score": 0.00098, "epss_percentile": 0.27733}, "CVE-2021-28075": {"epss_score": 0.00392, "epss_percentile": 0.59692}, "CVE-2021-28079": {"epss_score": 0.02158, "epss_percentile": 0.83815}, "CVE-2021-28088": {"epss_score": 0.00164, "epss_percentile": 0.37991}, "CVE-2021-28089": {"epss_score": 0.0125, "epss_percentile": 0.78879}, "CVE-2021-28090": {"epss_score": 0.02687, "epss_percentile": 0.85431}, "CVE-2021-28091": {"epss_score": 0.00512, "epss_percentile": 0.65869}, "CVE-2021-28092": {"epss_score": 0.00741, "epss_percentile": 0.72447}, "CVE-2021-28093": {"epss_score": 0.00134, "epss_percentile": 0.33855}, "CVE-2021-28094": {"epss_score": 0.00134, "epss_percentile": 0.33855}, "CVE-2021-28095": {"epss_score": 0.00146, "epss_percentile": 0.3555}, "CVE-2021-28096": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2021-28098": {"epss_score": 0.00046, "epss_percentile": 0.14187}, "CVE-2021-28099": {"epss_score": 0.00035, "epss_percentile": 0.09907}, "CVE-2021-28100": {"epss_score": 0.00044, "epss_percentile": 0.13511}, "CVE-2021-28109": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-28110": {"epss_score": 0.00296, "epss_percentile": 0.52585}, "CVE-2021-28111": {"epss_score": 0.02959, "epss_percentile": 0.86068}, "CVE-2021-28112": {"epss_score": 0.02337, "epss_percentile": 0.84421}, "CVE-2021-28113": {"epss_score": 0.03007, "epss_percentile": 0.86188}, "CVE-2021-28114": {"epss_score": 0.0057, "epss_percentile": 0.67937}, "CVE-2021-28115": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-28116": {"epss_score": 0.07036, "epss_percentile": 0.91205}, "CVE-2021-28117": {"epss_score": 0.00706, "epss_percentile": 0.71609}, "CVE-2021-28119": {"epss_score": 0.06472, "epss_percentile": 0.90779}, "CVE-2021-28121": {"epss_score": 0.00976, "epss_percentile": 0.76215}, "CVE-2021-28122": {"epss_score": 0.01097, "epss_percentile": 0.77531}, "CVE-2021-28123": {"epss_score": 0.00841, "epss_percentile": 0.74226}, "CVE-2021-28124": {"epss_score": 0.00298, "epss_percentile": 0.52837}, "CVE-2021-28125": {"epss_score": 0.04916, "epss_percentile": 0.89285}, "CVE-2021-28126": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-28127": {"epss_score": 0.00216, "epss_percentile": 0.44231}, "CVE-2021-28128": {"epss_score": 0.00259, "epss_percentile": 0.49072}, "CVE-2021-28129": {"epss_score": 0.00192, "epss_percentile": 0.41294}, "CVE-2021-28130": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2021-28131": {"epss_score": 0.00437, "epss_percentile": 0.62528}, "CVE-2021-28132": {"epss_score": 0.03112, "epss_percentile": 0.86428}, "CVE-2021-28133": {"epss_score": 0.02292, "epss_percentile": 0.84285}, "CVE-2021-28134": {"epss_score": 0.08178, "epss_percentile": 0.91916}, "CVE-2021-28135": {"epss_score": 0.00234, "epss_percentile": 0.46174}, "CVE-2021-28136": {"epss_score": 0.00286, "epss_percentile": 0.517}, "CVE-2021-28139": {"epss_score": 0.00464, "epss_percentile": 0.63704}, "CVE-2021-28141": {"epss_score": 0.01039, "epss_percentile": 0.7695}, "CVE-2021-28142": {"epss_score": 0.04018, "epss_percentile": 0.88125}, "CVE-2021-28143": {"epss_score": 0.23127, "epss_percentile": 0.95737}, "CVE-2021-28144": {"epss_score": 0.20331, "epss_percentile": 0.95327}, "CVE-2021-28145": {"epss_score": 0.00197, "epss_percentile": 0.41833}, "CVE-2021-28146": {"epss_score": 0.00257, "epss_percentile": 0.48854}, "CVE-2021-28147": {"epss_score": 0.00492, "epss_percentile": 0.64993}, "CVE-2021-28148": {"epss_score": 0.05674, "epss_percentile": 0.90106}, "CVE-2021-28149": {"epss_score": 0.90658, "epss_percentile": 0.99594}, "CVE-2021-28150": {"epss_score": 0.78839, "epss_percentile": 0.99006}, "CVE-2021-28151": {"epss_score": 0.92677, "epss_percentile": 0.99734}, "CVE-2021-28152": {"epss_score": 0.37467, "epss_percentile": 0.97049}, "CVE-2021-28153": {"epss_score": 0.00574, "epss_percentile": 0.68072}, "CVE-2021-28154": {"epss_score": 0.00351, "epss_percentile": 0.5704}, "CVE-2021-28155": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2021-28156": {"epss_score": 0.01279, "epss_percentile": 0.79134}, "CVE-2021-28157": {"epss_score": 0.00242, "epss_percentile": 0.47387}, "CVE-2021-28160": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-28161": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2021-28162": {"epss_score": 0.00172, "epss_percentile": 0.38999}, "CVE-2021-28163": {"epss_score": 0.00154, "epss_percentile": 0.36702}, "CVE-2021-28164": {"epss_score": 0.93485, "epss_percentile": 0.99811}, "CVE-2021-28165": {"epss_score": 0.11986, "epss_percentile": 0.93537}, "CVE-2021-28166": {"epss_score": 0.00624, "epss_percentile": 0.69559}, "CVE-2021-28167": {"epss_score": 0.00216, "epss_percentile": 0.44193}, "CVE-2021-28168": {"epss_score": 0.00158, "epss_percentile": 0.37297}, "CVE-2021-28169": {"epss_score": 0.90399, "epss_percentile": 0.99581}, "CVE-2021-28170": {"epss_score": 0.00113, "epss_percentile": 0.30643}, "CVE-2021-28171": {"epss_score": 0.00275, "epss_percentile": 0.5063}, "CVE-2021-28172": {"epss_score": 0.00536, "epss_percentile": 0.66852}, "CVE-2021-28173": {"epss_score": 0.00748, "epss_percentile": 0.72582}, "CVE-2021-28174": {"epss_score": 0.00135, "epss_percentile": 0.33996}, "CVE-2021-28175": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28176": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28177": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28178": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28179": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28180": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28181": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28182": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28183": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28184": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28185": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28186": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28187": {"epss_score": 0.00655, "epss_percentile": 0.70418}, "CVE-2021-28188": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28189": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28190": {"epss_score": 0.00655, "epss_percentile": 0.70418}, "CVE-2021-28191": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28192": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28193": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28194": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28195": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28196": {"epss_score": 0.00655, "epss_percentile": 0.70418}, "CVE-2021-28197": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28198": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28199": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28200": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28201": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28202": {"epss_score": 0.00895, "epss_percentile": 0.75101}, "CVE-2021-28203": {"epss_score": 0.01749, "epss_percentile": 0.82085}, "CVE-2021-28204": {"epss_score": 0.01749, "epss_percentile": 0.82085}, "CVE-2021-28205": {"epss_score": 0.00501, "epss_percentile": 0.65364}, "CVE-2021-28206": {"epss_score": 0.00501, "epss_percentile": 0.65364}, "CVE-2021-28207": {"epss_score": 0.00501, "epss_percentile": 0.65364}, "CVE-2021-28208": {"epss_score": 0.00501, "epss_percentile": 0.65364}, "CVE-2021-28209": {"epss_score": 0.00501, "epss_percentile": 0.65364}, "CVE-2021-28210": {"epss_score": 0.00118, "epss_percentile": 0.31458}, "CVE-2021-28211": {"epss_score": 0.0006, "epss_percentile": 0.19222}, "CVE-2021-28213": {"epss_score": 0.0027, "epss_percentile": 0.5021}, "CVE-2021-28216": {"epss_score": 0.00107, "epss_percentile": 0.2963}, "CVE-2021-28233": {"epss_score": 0.00352, "epss_percentile": 0.57112}, "CVE-2021-28235": {"epss_score": 0.0044, "epss_percentile": 0.6261}, "CVE-2021-28236": {"epss_score": 0.00435, "epss_percentile": 0.62332}, "CVE-2021-28237": {"epss_score": 0.00414, "epss_percentile": 0.61033}, "CVE-2021-28242": {"epss_score": 0.00479, "epss_percentile": 0.64432}, "CVE-2021-28245": {"epss_score": 0.00238, "epss_percentile": 0.46824}, "CVE-2021-28246": {"epss_score": 0.00101, "epss_percentile": 0.28702}, "CVE-2021-28247": {"epss_score": 0.00154, "epss_percentile": 0.36698}, "CVE-2021-28248": {"epss_score": 0.00238, "epss_percentile": 0.46763}, "CVE-2021-28249": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2021-28250": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2021-28254": {"epss_score": 0.00226, "epss_percentile": 0.45244}, "CVE-2021-28269": {"epss_score": 0.02421, "epss_percentile": 0.84704}, "CVE-2021-28271": {"epss_score": 0.02421, "epss_percentile": 0.84704}, "CVE-2021-28275": {"epss_score": 0.00071, "epss_percentile": 0.22055}, "CVE-2021-28276": {"epss_score": 0.00099, "epss_percentile": 0.27867}, "CVE-2021-28277": {"epss_score": 0.00105, "epss_percentile": 0.29396}, "CVE-2021-28278": {"epss_score": 0.00138, "epss_percentile": 0.34403}, "CVE-2021-28280": {"epss_score": 0.00412, "epss_percentile": 0.60942}, "CVE-2021-28290": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-28293": {"epss_score": 0.0178, "epss_percentile": 0.82234}, "CVE-2021-28294": {"epss_score": 0.02606, "epss_percentile": 0.85223}, "CVE-2021-28295": {"epss_score": 0.00658, "epss_percentile": 0.70478}, "CVE-2021-28300": {"epss_score": 0.00944, "epss_percentile": 0.75791}, "CVE-2021-28302": {"epss_score": 0.00374, "epss_percentile": 0.58529}, "CVE-2021-28305": {"epss_score": 0.00509, "epss_percentile": 0.65724}, "CVE-2021-28306": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-28307": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-28308": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-28309": {"epss_score": 0.00427, "epss_percentile": 0.61782}, "CVE-2021-28310": {"epss_score": 0.60293, "epss_percentile": 0.98203}, "CVE-2021-28311": {"epss_score": 0.02572, "epss_percentile": 0.85134}, "CVE-2021-28312": {"epss_score": 0.08276, "epss_percentile": 0.91965}, "CVE-2021-28313": {"epss_score": 0.00508, "epss_percentile": 0.657}, "CVE-2021-28314": {"epss_score": 0.00513, "epss_percentile": 0.65932}, "CVE-2021-28315": {"epss_score": 0.01109, "epss_percentile": 0.77652}, "CVE-2021-28316": {"epss_score": 0.00279, "epss_percentile": 0.50925}, "CVE-2021-28317": {"epss_score": 0.00605, "epss_percentile": 0.68973}, "CVE-2021-28318": {"epss_score": 0.0054, "epss_percentile": 0.66994}, "CVE-2021-28319": {"epss_score": 0.20423, "epss_percentile": 0.95343}, "CVE-2021-28320": {"epss_score": 0.00681, "epss_percentile": 0.71048}, "CVE-2021-28321": {"epss_score": 0.01085, "epss_percentile": 0.77409}, "CVE-2021-28322": {"epss_score": 0.00674, "epss_percentile": 0.70845}, "CVE-2021-28323": {"epss_score": 0.16564, "epss_percentile": 0.94692}, "CVE-2021-28324": {"epss_score": 0.18987, "epss_percentile": 0.95106}, "CVE-2021-28325": {"epss_score": 0.21136, "epss_percentile": 0.95468}, "CVE-2021-28326": {"epss_score": 0.0106, "epss_percentile": 0.77166}, "CVE-2021-28327": {"epss_score": 0.11182, "epss_percentile": 0.93257}, "CVE-2021-28328": {"epss_score": 0.13034, "epss_percentile": 0.93852}, "CVE-2021-28329": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28330": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28331": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28332": {"epss_score": 0.17338, "epss_percentile": 0.94829}, "CVE-2021-28333": {"epss_score": 0.11182, "epss_percentile": 0.93257}, "CVE-2021-28334": {"epss_score": 0.17338, "epss_percentile": 0.94829}, "CVE-2021-28335": {"epss_score": 0.17338, "epss_percentile": 0.94829}, "CVE-2021-28336": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28337": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28338": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28339": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28340": {"epss_score": 0.11182, "epss_percentile": 0.93257}, "CVE-2021-28341": {"epss_score": 0.17338, "epss_percentile": 0.94829}, "CVE-2021-28342": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28343": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28344": {"epss_score": 0.11182, "epss_percentile": 0.93257}, "CVE-2021-28345": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28346": {"epss_score": 0.17338, "epss_percentile": 0.94829}, "CVE-2021-28347": {"epss_score": 0.00681, "epss_percentile": 0.71048}, "CVE-2021-28348": {"epss_score": 0.00541, "epss_percentile": 0.67049}, "CVE-2021-28349": {"epss_score": 0.00355, "epss_percentile": 0.57325}, "CVE-2021-28350": {"epss_score": 0.00518, "epss_percentile": 0.66098}, "CVE-2021-28351": {"epss_score": 0.00681, "epss_percentile": 0.71048}, "CVE-2021-28352": {"epss_score": 0.17338, "epss_percentile": 0.94829}, "CVE-2021-28353": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28354": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28355": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28356": {"epss_score": 0.11182, "epss_percentile": 0.93257}, "CVE-2021-28357": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28358": {"epss_score": 0.17338, "epss_percentile": 0.94829}, "CVE-2021-28359": {"epss_score": 0.0416, "epss_percentile": 0.88334}, "CVE-2021-28361": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-28362": {"epss_score": 0.0035, "epss_percentile": 0.56968}, "CVE-2021-28363": {"epss_score": 0.00107, "epss_percentile": 0.29583}, "CVE-2021-28372": {"epss_score": 0.00906, "epss_percentile": 0.75251}, "CVE-2021-28373": {"epss_score": 0.00147, "epss_percentile": 0.35778}, "CVE-2021-28374": {"epss_score": 0.00286, "epss_percentile": 0.51777}, "CVE-2021-28375": {"epss_score": 0.00059, "epss_percentile": 0.188}, "CVE-2021-28376": {"epss_score": 0.00144, "epss_percentile": 0.35248}, "CVE-2021-28377": {"epss_score": 0.4612, "epss_percentile": 0.97531}, "CVE-2021-28378": {"epss_score": 0.12924, "epss_percentile": 0.93819}, "CVE-2021-28379": {"epss_score": 0.0329, "epss_percentile": 0.86836}, "CVE-2021-28380": {"epss_score": 0.00272, "epss_percentile": 0.50417}, "CVE-2021-28381": {"epss_score": 0.00366, "epss_percentile": 0.58079}, "CVE-2021-28382": {"epss_score": 0.19524, "epss_percentile": 0.952}, "CVE-2021-28398": {"epss_score": 0.01122, "epss_percentile": 0.77781}, "CVE-2021-28399": {"epss_score": 0.00711, "epss_percentile": 0.71732}, "CVE-2021-28411": {"epss_score": 0.00306, "epss_percentile": 0.53411}, "CVE-2021-28417": {"epss_score": 0.00213, "epss_percentile": 0.43945}, "CVE-2021-28418": {"epss_score": 0.00213, "epss_percentile": 0.43945}, "CVE-2021-28419": {"epss_score": 0.0923, "epss_percentile": 0.92458}, "CVE-2021-28420": {"epss_score": 0.00208, "epss_percentile": 0.43267}, "CVE-2021-28423": {"epss_score": 0.01718, "epss_percentile": 0.81922}, "CVE-2021-28424": {"epss_score": 0.0041, "epss_percentile": 0.60821}, "CVE-2021-28427": {"epss_score": 0.00047, "epss_percentile": 0.14768}, "CVE-2021-28428": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-28429": {"epss_score": 0.00021, "epss_percentile": 0.04746}, "CVE-2021-28434": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2021-28435": {"epss_score": 0.00542, "epss_percentile": 0.6708}, "CVE-2021-28436": {"epss_score": 0.00513, "epss_percentile": 0.65932}, "CVE-2021-28437": {"epss_score": 0.00427, "epss_percentile": 0.61782}, "CVE-2021-28438": {"epss_score": 0.0084, "epss_percentile": 0.7421}, "CVE-2021-28439": {"epss_score": 0.20904, "epss_percentile": 0.95436}, "CVE-2021-28440": {"epss_score": 0.00467, "epss_percentile": 0.63834}, "CVE-2021-28441": {"epss_score": 0.00448, "epss_percentile": 0.62991}, "CVE-2021-28442": {"epss_score": 0.13694, "epss_percentile": 0.94036}, "CVE-2021-28443": {"epss_score": 0.00256, "epss_percentile": 0.48835}, "CVE-2021-28444": {"epss_score": 0.09651, "epss_percentile": 0.9264}, "CVE-2021-28445": {"epss_score": 0.20109, "epss_percentile": 0.95289}, "CVE-2021-28446": {"epss_score": 0.00982, "epss_percentile": 0.76291}, "CVE-2021-28447": {"epss_score": 0.00348, "epss_percentile": 0.56824}, "CVE-2021-28448": {"epss_score": 0.0534, "epss_percentile": 0.89761}, "CVE-2021-28449": {"epss_score": 0.04766, "epss_percentile": 0.89123}, "CVE-2021-28450": {"epss_score": 0.01478, "epss_percentile": 0.80554}, "CVE-2021-28451": {"epss_score": 0.0534, "epss_percentile": 0.89761}, "CVE-2021-28452": {"epss_score": 0.00732, "epss_percentile": 0.72194}, "CVE-2021-28453": {"epss_score": 0.03656, "epss_percentile": 0.87518}, "CVE-2021-28454": {"epss_score": 0.07026, "epss_percentile": 0.91195}, "CVE-2021-28455": {"epss_score": 0.11351, "epss_percentile": 0.93321}, "CVE-2021-28456": {"epss_score": 0.07347, "epss_percentile": 0.91422}, "CVE-2021-28457": {"epss_score": 0.04005, "epss_percentile": 0.88102}, "CVE-2021-28458": {"epss_score": 0.03898, "epss_percentile": 0.87919}, "CVE-2021-28459": {"epss_score": 0.00708, "epss_percentile": 0.71678}, "CVE-2021-28460": {"epss_score": 0.00524, "epss_percentile": 0.66363}, "CVE-2021-28461": {"epss_score": 0.01271, "epss_percentile": 0.79057}, "CVE-2021-28464": {"epss_score": 0.0534, "epss_percentile": 0.89761}, "CVE-2021-28465": {"epss_score": 0.06365, "epss_percentile": 0.90702}, "CVE-2021-28466": {"epss_score": 0.0534, "epss_percentile": 0.89761}, "CVE-2021-28468": {"epss_score": 0.04703, "epss_percentile": 0.89028}, "CVE-2021-28469": {"epss_score": 0.04005, "epss_percentile": 0.88102}, "CVE-2021-28470": {"epss_score": 0.0534, "epss_percentile": 0.89761}, "CVE-2021-28471": {"epss_score": 0.04642, "epss_percentile": 0.88955}, "CVE-2021-28472": {"epss_score": 0.12255, "epss_percentile": 0.93612}, "CVE-2021-28473": {"epss_score": 0.04005, "epss_percentile": 0.88102}, "CVE-2021-28474": {"epss_score": 0.17998, "epss_percentile": 0.9494}, "CVE-2021-28475": {"epss_score": 0.04005, "epss_percentile": 0.88102}, "CVE-2021-28476": {"epss_score": 0.63905, "epss_percentile": 0.98355}, "CVE-2021-28477": {"epss_score": 0.01924, "epss_percentile": 0.82917}, "CVE-2021-28478": {"epss_score": 0.0229, "epss_percentile": 0.84279}, "CVE-2021-28479": {"epss_score": 0.00248, "epss_percentile": 0.47973}, "CVE-2021-28480": {"epss_score": 0.62469, "epss_percentile": 0.98293}, "CVE-2021-28481": {"epss_score": 0.04893, "epss_percentile": 0.89267}, "CVE-2021-28482": {"epss_score": 0.54674, "epss_percentile": 0.97938}, "CVE-2021-28483": {"epss_score": 0.00583, "epss_percentile": 0.68339}, "CVE-2021-28484": {"epss_score": 0.0056, "epss_percentile": 0.67652}, "CVE-2021-28485": {"epss_score": 0.00474, "epss_percentile": 0.64164}, "CVE-2021-28488": {"epss_score": 0.0063, "epss_percentile": 0.69691}, "CVE-2021-28490": {"epss_score": 0.00177, "epss_percentile": 0.39535}, "CVE-2021-28492": {"epss_score": 0.00258, "epss_percentile": 0.48953}, "CVE-2021-28493": {"epss_score": 0.00037, "epss_percentile": 0.10668}, "CVE-2021-28494": {"epss_score": 0.00293, "epss_percentile": 0.52344}, "CVE-2021-28495": {"epss_score": 0.0039, "epss_percentile": 0.59557}, "CVE-2021-28496": {"epss_score": 0.00122, "epss_percentile": 0.32094}, "CVE-2021-28497": {"epss_score": 0.00047, "epss_percentile": 0.14789}, "CVE-2021-28498": {"epss_score": 0.0009, "epss_percentile": 0.26081}, "CVE-2021-28499": {"epss_score": 0.00042, "epss_percentile": 0.12671}, "CVE-2021-28500": {"epss_score": 0.00312, "epss_percentile": 0.53991}, "CVE-2021-28501": {"epss_score": 0.00291, "epss_percentile": 0.52148}, "CVE-2021-28503": {"epss_score": 0.00402, "epss_percentile": 0.60286}, "CVE-2021-28504": {"epss_score": 0.00184, "epss_percentile": 0.40391}, "CVE-2021-28505": {"epss_score": 0.00203, "epss_percentile": 0.42523}, "CVE-2021-28506": {"epss_score": 0.00481, "epss_percentile": 0.64513}, "CVE-2021-28507": {"epss_score": 0.00102, "epss_percentile": 0.28847}, "CVE-2021-28508": {"epss_score": 0.0015, "epss_percentile": 0.36179}, "CVE-2021-28509": {"epss_score": 0.00142, "epss_percentile": 0.34993}, "CVE-2021-28510": {"epss_score": 0.003, "epss_percentile": 0.52913}, "CVE-2021-28511": {"epss_score": 0.00232, "epss_percentile": 0.45929}, "CVE-2021-28543": {"epss_score": 0.00918, "epss_percentile": 0.75437}, "CVE-2021-28544": {"epss_score": 0.00375, "epss_percentile": 0.58621}, "CVE-2021-28545": {"epss_score": 0.0121, "epss_percentile": 0.78552}, "CVE-2021-28546": {"epss_score": 0.00401, "epss_percentile": 0.60206}, "CVE-2021-28547": {"epss_score": 0.00074, "epss_percentile": 0.22715}, "CVE-2021-28548": {"epss_score": 0.04343, "epss_percentile": 0.88572}, "CVE-2021-28549": {"epss_score": 0.04343, "epss_percentile": 0.88572}, "CVE-2021-28550": {"epss_score": 0.14246, "epss_percentile": 0.9417}, "CVE-2021-28551": {"epss_score": 0.19754, "epss_percentile": 0.95237}, "CVE-2021-28552": {"epss_score": 0.06742, "epss_percentile": 0.90996}, "CVE-2021-28553": {"epss_score": 0.42437, "epss_percentile": 0.97332}, "CVE-2021-28554": {"epss_score": 0.27353, "epss_percentile": 0.96239}, "CVE-2021-28555": {"epss_score": 0.02078, "epss_percentile": 0.83518}, "CVE-2021-28556": {"epss_score": 0.23863, "epss_percentile": 0.95826}, "CVE-2021-28557": {"epss_score": 0.01316, "epss_percentile": 0.79409}, "CVE-2021-28558": {"epss_score": 0.41537, "epss_percentile": 0.97282}, "CVE-2021-28559": {"epss_score": 0.00861, "epss_percentile": 0.74559}, "CVE-2021-28560": {"epss_score": 0.37349, "epss_percentile": 0.97034}, "CVE-2021-28561": {"epss_score": 0.18211, "epss_percentile": 0.94975}, "CVE-2021-28562": {"epss_score": 0.22853, "epss_percentile": 0.95699}, "CVE-2021-28563": {"epss_score": 0.00189, "epss_percentile": 0.40976}, "CVE-2021-28564": {"epss_score": 0.31079, "epss_percentile": 0.96586}, "CVE-2021-28565": {"epss_score": 0.11804, "epss_percentile": 0.93482}, "CVE-2021-28566": {"epss_score": 0.00731, "epss_percentile": 0.72168}, "CVE-2021-28567": {"epss_score": 0.00076, "epss_percentile": 0.23145}, "CVE-2021-28568": {"epss_score": 0.00137, "epss_percentile": 0.34305}, "CVE-2021-28569": {"epss_score": 0.0078, "epss_percentile": 0.73174}, "CVE-2021-28570": {"epss_score": 0.0077, "epss_percentile": 0.73002}, "CVE-2021-28571": {"epss_score": 0.02767, "epss_percentile": 0.85612}, "CVE-2021-28573": {"epss_score": 0.00818, "epss_percentile": 0.73852}, "CVE-2021-28574": {"epss_score": 0.0078, "epss_percentile": 0.73174}, "CVE-2021-28575": {"epss_score": 0.0078, "epss_percentile": 0.73174}, "CVE-2021-28576": {"epss_score": 0.0078, "epss_percentile": 0.73174}, "CVE-2021-28579": {"epss_score": 0.00168, "epss_percentile": 0.38435}, "CVE-2021-28580": {"epss_score": 0.03985, "epss_percentile": 0.88063}, "CVE-2021-28581": {"epss_score": 0.00115, "epss_percentile": 0.30894}, "CVE-2021-28583": {"epss_score": 0.00391, "epss_percentile": 0.59622}, "CVE-2021-28584": {"epss_score": 0.00574, "epss_percentile": 0.68094}, "CVE-2021-28585": {"epss_score": 0.0026, "epss_percentile": 0.491}, "CVE-2021-28586": {"epss_score": 0.00837, "epss_percentile": 0.74155}, "CVE-2021-28587": {"epss_score": 0.00864, "epss_percentile": 0.74598}, "CVE-2021-28588": {"epss_score": 0.13981, "epss_percentile": 0.94107}, "CVE-2021-28589": {"epss_score": 0.02246, "epss_percentile": 0.84134}, "CVE-2021-28590": {"epss_score": 0.02246, "epss_percentile": 0.84134}, "CVE-2021-28591": {"epss_score": 0.01994, "epss_percentile": 0.83189}, "CVE-2021-28592": {"epss_score": 0.01994, "epss_percentile": 0.83189}, "CVE-2021-28593": {"epss_score": 0.00786, "epss_percentile": 0.73287}, "CVE-2021-28594": {"epss_score": 0.05686, "epss_percentile": 0.9012}, "CVE-2021-28595": {"epss_score": 0.05686, "epss_percentile": 0.9012}, "CVE-2021-28596": {"epss_score": 0.0125, "epss_percentile": 0.78891}, "CVE-2021-28597": {"epss_score": 0.00089, "epss_percentile": 0.25875}, "CVE-2021-28600": {"epss_score": 0.00677, "epss_percentile": 0.70947}, "CVE-2021-28601": {"epss_score": 0.00951, "epss_percentile": 0.75866}, "CVE-2021-28602": {"epss_score": 0.02552, "epss_percentile": 0.85083}, "CVE-2021-28603": {"epss_score": 0.00989, "epss_percentile": 0.76362}, "CVE-2021-28604": {"epss_score": 0.01087, "epss_percentile": 0.77431}, "CVE-2021-28605": {"epss_score": 0.01275, "epss_percentile": 0.791}, "CVE-2021-28606": {"epss_score": 0.01671, "epss_percentile": 0.81676}, "CVE-2021-28607": {"epss_score": 0.01307, "epss_percentile": 0.79338}, "CVE-2021-28608": {"epss_score": 0.03029, "epss_percentile": 0.86245}, "CVE-2021-28609": {"epss_score": 0.00677, "epss_percentile": 0.70947}, "CVE-2021-28610": {"epss_score": 0.01066, "epss_percentile": 0.77214}, "CVE-2021-28611": {"epss_score": 0.00637, "epss_percentile": 0.6989}, "CVE-2021-28612": {"epss_score": 0.00637, "epss_percentile": 0.6989}, "CVE-2021-28613": {"epss_score": 0.00102, "epss_percentile": 0.28842}, "CVE-2021-28614": {"epss_score": 0.00637, "epss_percentile": 0.6989}, "CVE-2021-28615": {"epss_score": 0.00677, "epss_percentile": 0.70947}, "CVE-2021-28616": {"epss_score": 0.00637, "epss_percentile": 0.6989}, "CVE-2021-28617": {"epss_score": 0.00707, "epss_percentile": 0.71651}, "CVE-2021-28618": {"epss_score": 0.00707, "epss_percentile": 0.71651}, "CVE-2021-28619": {"epss_score": 0.00707, "epss_percentile": 0.71651}, "CVE-2021-28620": {"epss_score": 0.0543, "epss_percentile": 0.89876}, "CVE-2021-28621": {"epss_score": 0.0422, "epss_percentile": 0.8841}, "CVE-2021-28622": {"epss_score": 0.06008, "epss_percentile": 0.904}, "CVE-2021-28623": {"epss_score": 0.00104, "epss_percentile": 0.29206}, "CVE-2021-28624": {"epss_score": 0.11194, "epss_percentile": 0.93261}, "CVE-2021-28625": {"epss_score": 0.00877, "epss_percentile": 0.74803}, "CVE-2021-28626": {"epss_score": 0.00395, "epss_percentile": 0.598}, "CVE-2021-28627": {"epss_score": 0.00427, "epss_percentile": 0.61915}, "CVE-2021-28628": {"epss_score": 0.00877, "epss_percentile": 0.74803}, "CVE-2021-28629": {"epss_score": 0.0946, "epss_percentile": 0.92558}, "CVE-2021-28630": {"epss_score": 0.01288, "epss_percentile": 0.79199}, "CVE-2021-28631": {"epss_score": 0.30798, "epss_percentile": 0.96569}, "CVE-2021-28632": {"epss_score": 0.30798, "epss_percentile": 0.96569}, "CVE-2021-28633": {"epss_score": 0.001, "epss_percentile": 0.28476}, "CVE-2021-28634": {"epss_score": 0.03583, "epss_percentile": 0.87388}, "CVE-2021-28635": {"epss_score": 0.21374, "epss_percentile": 0.9551}, "CVE-2021-28636": {"epss_score": 0.01291, "epss_percentile": 0.79224}, "CVE-2021-28637": {"epss_score": 0.01834, "epss_percentile": 0.82461}, "CVE-2021-28638": {"epss_score": 0.42197, "epss_percentile": 0.97318}, "CVE-2021-28639": {"epss_score": 0.174, "epss_percentile": 0.94845}, "CVE-2021-28640": {"epss_score": 0.11491, "epss_percentile": 0.93383}, "CVE-2021-28641": {"epss_score": 0.51568, "epss_percentile": 0.97786}, "CVE-2021-28642": {"epss_score": 0.37328, "epss_percentile": 0.97033}, "CVE-2021-28643": {"epss_score": 0.00521, "epss_percentile": 0.66248}, "CVE-2021-28644": {"epss_score": 0.02172, "epss_percentile": 0.83875}, "CVE-2021-28645": {"epss_score": 0.0007, "epss_percentile": 0.21708}, "CVE-2021-28646": {"epss_score": 0.00062, "epss_percentile": 0.19553}, "CVE-2021-28647": {"epss_score": 0.00084, "epss_percentile": 0.2497}, "CVE-2021-28648": {"epss_score": 0.00078, "epss_percentile": 0.23766}, "CVE-2021-28649": {"epss_score": 0.00093, "epss_percentile": 0.26655}, "CVE-2021-28650": {"epss_score": 0.00175, "epss_percentile": 0.39283}, "CVE-2021-28651": {"epss_score": 0.05153, "epss_percentile": 0.8955}, "CVE-2021-28652": {"epss_score": 0.00532, "epss_percentile": 0.66701}, "CVE-2021-28653": {"epss_score": 0.00305, "epss_percentile": 0.53316}, "CVE-2021-28655": {"epss_score": 0.00432, "epss_percentile": 0.62135}, "CVE-2021-28656": {"epss_score": 0.01322, "epss_percentile": 0.79453}, "CVE-2021-28657": {"epss_score": 0.00177, "epss_percentile": 0.3961}, "CVE-2021-28658": {"epss_score": 0.01292, "epss_percentile": 0.79232}, "CVE-2021-28660": {"epss_score": 0.00319, "epss_percentile": 0.54462}, "CVE-2021-28661": {"epss_score": 0.00169, "epss_percentile": 0.38546}, "CVE-2021-28662": {"epss_score": 0.1363, "epss_percentile": 0.94017}, "CVE-2021-28663": {"epss_score": 0.02417, "epss_percentile": 0.84692}, "CVE-2021-28664": {"epss_score": 0.00153, "epss_percentile": 0.36606}, "CVE-2021-28665": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2021-28667": {"epss_score": 0.00668, "epss_percentile": 0.70737}, "CVE-2021-28668": {"epss_score": 0.00348, "epss_percentile": 0.56822}, "CVE-2021-28669": {"epss_score": 0.00256, "epss_percentile": 0.48816}, "CVE-2021-28670": {"epss_score": 0.00554, "epss_percentile": 0.67443}, "CVE-2021-28671": {"epss_score": 0.01575, "epss_percentile": 0.81109}, "CVE-2021-28672": {"epss_score": 0.02219, "epss_percentile": 0.84043}, "CVE-2021-28673": {"epss_score": 0.01031, "epss_percentile": 0.76855}, "CVE-2021-28674": {"epss_score": 0.00498, "epss_percentile": 0.6524}, "CVE-2021-28675": {"epss_score": 0.00115, "epss_percentile": 0.30939}, "CVE-2021-28676": {"epss_score": 0.00366, "epss_percentile": 0.58095}, "CVE-2021-28677": {"epss_score": 0.00263, "epss_percentile": 0.49541}, "CVE-2021-28678": {"epss_score": 0.0011, "epss_percentile": 0.3021}, "CVE-2021-28680": {"epss_score": 0.00255, "epss_percentile": 0.48648}, "CVE-2021-28681": {"epss_score": 0.001, "epss_percentile": 0.2845}, "CVE-2021-28682": {"epss_score": 0.00095, "epss_percentile": 0.27197}, "CVE-2021-28683": {"epss_score": 0.00116, "epss_percentile": 0.31037}, "CVE-2021-28684": {"epss_score": 0.00226, "epss_percentile": 0.45241}, "CVE-2021-28685": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2021-28686": {"epss_score": 0.00059, "epss_percentile": 0.18688}, "CVE-2021-28687": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2021-28688": {"epss_score": 0.00133, "epss_percentile": 0.33736}, "CVE-2021-28689": {"epss_score": 0.00076, "epss_percentile": 0.23085}, "CVE-2021-28690": {"epss_score": 0.00357, "epss_percentile": 0.57476}, "CVE-2021-28691": {"epss_score": 0.00031, "epss_percentile": 0.08396}, "CVE-2021-28692": {"epss_score": 0.00036, "epss_percentile": 0.103}, "CVE-2021-28693": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2021-28694": {"epss_score": 0.00136, "epss_percentile": 0.34202}, "CVE-2021-28695": {"epss_score": 0.00137, "epss_percentile": 0.34234}, "CVE-2021-28696": {"epss_score": 0.00092, "epss_percentile": 0.26566}, "CVE-2021-28697": {"epss_score": 0.00059, "epss_percentile": 0.18683}, "CVE-2021-28698": {"epss_score": 0.00056, "epss_percentile": 0.17744}, "CVE-2021-28699": {"epss_score": 0.00074, "epss_percentile": 0.22845}, "CVE-2021-28700": {"epss_score": 0.02126, "epss_percentile": 0.83695}, "CVE-2021-28701": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2021-28702": {"epss_score": 0.00074, "epss_percentile": 0.22821}, "CVE-2021-28703": {"epss_score": 0.0011, "epss_percentile": 0.30181}, "CVE-2021-28704": {"epss_score": 0.00086, "epss_percentile": 0.25336}, "CVE-2021-28705": {"epss_score": 0.00115, "epss_percentile": 0.30963}, "CVE-2021-28706": {"epss_score": 0.00155, "epss_percentile": 0.36856}, "CVE-2021-28707": {"epss_score": 0.00086, "epss_percentile": 0.25336}, "CVE-2021-28708": {"epss_score": 0.00087, "epss_percentile": 0.2547}, "CVE-2021-28709": {"epss_score": 0.00086, "epss_percentile": 0.25336}, "CVE-2021-28710": {"epss_score": 0.00043, "epss_percentile": 0.13352}, "CVE-2021-28711": {"epss_score": 0.00042, "epss_percentile": 0.1262}, "CVE-2021-28712": {"epss_score": 0.00042, "epss_percentile": 0.1262}, "CVE-2021-28713": {"epss_score": 0.00042, "epss_percentile": 0.1262}, "CVE-2021-28714": {"epss_score": 0.00021, "epss_percentile": 0.04872}, "CVE-2021-28715": {"epss_score": 0.00012, "epss_percentile": 0.0129}, "CVE-2021-28789": {"epss_score": 0.0143, "epss_percentile": 0.80229}, "CVE-2021-28790": {"epss_score": 0.0143, "epss_percentile": 0.80229}, "CVE-2021-28791": {"epss_score": 0.01388, "epss_percentile": 0.7992}, "CVE-2021-28792": {"epss_score": 0.0143, "epss_percentile": 0.80229}, "CVE-2021-28793": {"epss_score": 0.00531, "epss_percentile": 0.66647}, "CVE-2021-28794": {"epss_score": 0.00513, "epss_percentile": 0.65917}, "CVE-2021-28796": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-28797": {"epss_score": 0.01297, "epss_percentile": 0.79264}, "CVE-2021-28798": {"epss_score": 0.00399, "epss_percentile": 0.60145}, "CVE-2021-28799": {"epss_score": 0.80202, "epss_percentile": 0.99076}, "CVE-2021-28800": {"epss_score": 0.00907, "epss_percentile": 0.75262}, "CVE-2021-28801": {"epss_score": 0.00277, "epss_percentile": 0.50806}, "CVE-2021-28802": {"epss_score": 0.01062, "epss_percentile": 0.77177}, "CVE-2021-28803": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-28804": {"epss_score": 0.02174, "epss_percentile": 0.83878}, "CVE-2021-28805": {"epss_score": 0.0005, "epss_percentile": 0.1567}, "CVE-2021-28806": {"epss_score": 0.00247, "epss_percentile": 0.47819}, "CVE-2021-28807": {"epss_score": 0.0066, "epss_percentile": 0.70532}, "CVE-2021-28809": {"epss_score": 0.00578, "epss_percentile": 0.68178}, "CVE-2021-28810": {"epss_score": 0.00251, "epss_percentile": 0.48273}, "CVE-2021-28811": {"epss_score": 0.0288, "epss_percentile": 0.85896}, "CVE-2021-28812": {"epss_score": 0.01868, "epss_percentile": 0.82624}, "CVE-2021-28813": {"epss_score": 0.00375, "epss_percentile": 0.58603}, "CVE-2021-28814": {"epss_score": 0.00602, "epss_percentile": 0.68894}, "CVE-2021-28815": {"epss_score": 0.00109, "epss_percentile": 0.30075}, "CVE-2021-28816": {"epss_score": 0.01174, "epss_percentile": 0.7825}, "CVE-2021-28817": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2021-28818": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2021-28819": {"epss_score": 0.00034, "epss_percentile": 0.09558}, "CVE-2021-28820": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2021-28821": {"epss_score": 0.00118, "epss_percentile": 0.31421}, "CVE-2021-28822": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2021-28823": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2021-28824": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2021-28825": {"epss_score": 0.00029, "epss_percentile": 0.07953}, "CVE-2021-28826": {"epss_score": 0.00029, "epss_percentile": 0.07953}, "CVE-2021-28827": {"epss_score": 0.00609, "epss_percentile": 0.691}, "CVE-2021-28828": {"epss_score": 0.00387, "epss_percentile": 0.5929}, "CVE-2021-28829": {"epss_score": 0.00275, "epss_percentile": 0.50688}, "CVE-2021-28830": {"epss_score": 0.00034, "epss_percentile": 0.09743}, "CVE-2021-28831": {"epss_score": 0.01019, "epss_percentile": 0.76727}, "CVE-2021-28832": {"epss_score": 0.00438, "epss_percentile": 0.6257}, "CVE-2021-28833": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-28834": {"epss_score": 0.0259, "epss_percentile": 0.8518}, "CVE-2021-28835": {"epss_score": 0.00025, "epss_percentile": 0.06167}, "CVE-2021-28838": {"epss_score": 0.01044, "epss_percentile": 0.77009}, "CVE-2021-28839": {"epss_score": 0.00564, "epss_percentile": 0.67772}, "CVE-2021-28840": {"epss_score": 0.01044, "epss_percentile": 0.77009}, "CVE-2021-28841": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-28842": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-28843": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-28844": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-28845": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-28846": {"epss_score": 0.00308, "epss_percentile": 0.53623}, "CVE-2021-28847": {"epss_score": 0.00467, "epss_percentile": 0.63836}, "CVE-2021-28848": {"epss_score": 0.0056, "epss_percentile": 0.67652}, "CVE-2021-28855": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2021-28856": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2021-28857": {"epss_score": 0.00262, "epss_percentile": 0.49346}, "CVE-2021-28858": {"epss_score": 0.00025, "epss_percentile": 0.06098}, "CVE-2021-28860": {"epss_score": 0.01156, "epss_percentile": 0.78105}, "CVE-2021-28861": {"epss_score": 0.01395, "epss_percentile": 0.79972}, "CVE-2021-28874": {"epss_score": 0.00284, "epss_percentile": 0.5146}, "CVE-2021-28875": {"epss_score": 0.00416, "epss_percentile": 0.61183}, "CVE-2021-28876": {"epss_score": 0.00419, "epss_percentile": 0.61371}, "CVE-2021-28877": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2021-28878": {"epss_score": 0.01012, "epss_percentile": 0.76629}, "CVE-2021-28879": {"epss_score": 0.011, "epss_percentile": 0.77564}, "CVE-2021-28890": {"epss_score": 0.00478, "epss_percentile": 0.64372}, "CVE-2021-28899": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-28901": {"epss_score": 0.00214, "epss_percentile": 0.44016}, "CVE-2021-28902": {"epss_score": 0.00367, "epss_percentile": 0.581}, "CVE-2021-28903": {"epss_score": 0.00724, "epss_percentile": 0.72039}, "CVE-2021-28904": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2021-28905": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2021-28906": {"epss_score": 0.00367, "epss_percentile": 0.581}, "CVE-2021-28909": {"epss_score": 0.01761, "epss_percentile": 0.8215}, "CVE-2021-28910": {"epss_score": 0.01219, "epss_percentile": 0.78613}, "CVE-2021-28911": {"epss_score": 0.02328, "epss_percentile": 0.84395}, "CVE-2021-28912": {"epss_score": 0.00766, "epss_percentile": 0.72938}, "CVE-2021-28913": {"epss_score": 0.02828, "epss_percentile": 0.8577}, "CVE-2021-28914": {"epss_score": 0.00575, "epss_percentile": 0.68102}, "CVE-2021-28918": {"epss_score": 0.85896, "epss_percentile": 0.99354}, "CVE-2021-28924": {"epss_score": 0.66182, "epss_percentile": 0.98454}, "CVE-2021-28925": {"epss_score": 0.74242, "epss_percentile": 0.98793}, "CVE-2021-28927": {"epss_score": 0.00497, "epss_percentile": 0.65212}, "CVE-2021-28931": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2021-28935": {"epss_score": 0.0023, "epss_percentile": 0.45681}, "CVE-2021-28936": {"epss_score": 0.00283, "epss_percentile": 0.51357}, "CVE-2021-28937": {"epss_score": 0.33834, "epss_percentile": 0.96808}, "CVE-2021-28938": {"epss_score": 0.00391, "epss_percentile": 0.59624}, "CVE-2021-28940": {"epss_score": 0.04578, "epss_percentile": 0.88871}, "CVE-2021-28941": {"epss_score": 0.00192, "epss_percentile": 0.4137}, "CVE-2021-28950": {"epss_score": 0.00029, "epss_percentile": 0.07754}, "CVE-2021-28951": {"epss_score": 0.00054, "epss_percentile": 0.17315}, "CVE-2021-28952": {"epss_score": 0.00177, "epss_percentile": 0.39566}, "CVE-2021-28953": {"epss_score": 0.00246, "epss_percentile": 0.4774}, "CVE-2021-28954": {"epss_score": 0.00237, "epss_percentile": 0.46713}, "CVE-2021-28955": {"epss_score": 0.00467, "epss_percentile": 0.63847}, "CVE-2021-28956": {"epss_score": 0.00512, "epss_percentile": 0.65865}, "CVE-2021-28957": {"epss_score": 0.00496, "epss_percentile": 0.65151}, "CVE-2021-28958": {"epss_score": 0.57464, "epss_percentile": 0.98064}, "CVE-2021-28959": {"epss_score": 0.24132, "epss_percentile": 0.95879}, "CVE-2021-28960": {"epss_score": 0.05341, "epss_percentile": 0.89762}, "CVE-2021-28961": {"epss_score": 0.01139, "epss_percentile": 0.77939}, "CVE-2021-28962": {"epss_score": 0.00755, "epss_percentile": 0.72709}, "CVE-2021-28963": {"epss_score": 0.00488, "epss_percentile": 0.64848}, "CVE-2021-28964": {"epss_score": 0.00086, "epss_percentile": 0.25313}, "CVE-2021-28965": {"epss_score": 0.00362, "epss_percentile": 0.57781}, "CVE-2021-28966": {"epss_score": 0.00347, "epss_percentile": 0.56744}, "CVE-2021-28967": {"epss_score": 0.01232, "epss_percentile": 0.78741}, "CVE-2021-28968": {"epss_score": 0.00271, "epss_percentile": 0.50341}, "CVE-2021-28969": {"epss_score": 0.0018, "epss_percentile": 0.39915}, "CVE-2021-28970": {"epss_score": 0.00204, "epss_percentile": 0.42618}, "CVE-2021-28971": {"epss_score": 0.00035, "epss_percentile": 0.09971}, "CVE-2021-28972": {"epss_score": 0.00055, "epss_percentile": 0.17466}, "CVE-2021-28973": {"epss_score": 0.00244, "epss_percentile": 0.47621}, "CVE-2021-28975": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-28976": {"epss_score": 0.05539, "epss_percentile": 0.89976}, "CVE-2021-28977": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2021-28979": {"epss_score": 0.00538, "epss_percentile": 0.66927}, "CVE-2021-28993": {"epss_score": 0.00304, "epss_percentile": 0.53246}, "CVE-2021-28994": {"epss_score": 0.00408, "epss_percentile": 0.60647}, "CVE-2021-28998": {"epss_score": 0.00337, "epss_percentile": 0.56035}, "CVE-2021-28999": {"epss_score": 0.00188, "epss_percentile": 0.40917}, "CVE-2021-29002": {"epss_score": 0.0031, "epss_percentile": 0.53742}, "CVE-2021-29003": {"epss_score": 0.33527, "epss_percentile": 0.96782}, "CVE-2021-29004": {"epss_score": 0.01785, "epss_percentile": 0.82253}, "CVE-2021-29005": {"epss_score": 0.00054, "epss_percentile": 0.17218}, "CVE-2021-29006": {"epss_score": 0.30402, "epss_percentile": 0.96537}, "CVE-2021-29008": {"epss_score": 0.00176, "epss_percentile": 0.39429}, "CVE-2021-29009": {"epss_score": 0.00184, "epss_percentile": 0.4039}, "CVE-2021-29010": {"epss_score": 0.00184, "epss_percentile": 0.4039}, "CVE-2021-29011": {"epss_score": 0.00258, "epss_percentile": 0.48994}, "CVE-2021-29012": {"epss_score": 0.032, "epss_percentile": 0.86621}, "CVE-2021-29022": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2021-29023": {"epss_score": 0.00155, "epss_percentile": 0.3683}, "CVE-2021-29024": {"epss_score": 0.01173, "epss_percentile": 0.78242}, "CVE-2021-29025": {"epss_score": 0.00184, "epss_percentile": 0.4039}, "CVE-2021-29026": {"epss_score": 0.00146, "epss_percentile": 0.35566}, "CVE-2021-29027": {"epss_score": 0.00184, "epss_percentile": 0.4039}, "CVE-2021-29028": {"epss_score": 0.00162, "epss_percentile": 0.37726}, "CVE-2021-29029": {"epss_score": 0.00184, "epss_percentile": 0.4039}, "CVE-2021-29030": {"epss_score": 0.00162, "epss_percentile": 0.37726}, "CVE-2021-29031": {"epss_score": 0.00162, "epss_percentile": 0.37726}, "CVE-2021-29032": {"epss_score": 0.00162, "epss_percentile": 0.37726}, "CVE-2021-29033": {"epss_score": 0.00184, "epss_percentile": 0.4039}, "CVE-2021-29038": {"epss_score": 0.00094, "epss_percentile": 0.27065}, "CVE-2021-29039": {"epss_score": 0.00474, "epss_percentile": 0.64161}, "CVE-2021-29040": {"epss_score": 0.00402, "epss_percentile": 0.60315}, "CVE-2021-29041": {"epss_score": 0.00521, "epss_percentile": 0.66225}, "CVE-2021-29043": {"epss_score": 0.00204, "epss_percentile": 0.4264}, "CVE-2021-29044": {"epss_score": 0.00474, "epss_percentile": 0.64161}, "CVE-2021-29045": {"epss_score": 0.00278, "epss_percentile": 0.50862}, "CVE-2021-29046": {"epss_score": 0.00474, "epss_percentile": 0.64161}, "CVE-2021-29047": {"epss_score": 0.00288, "epss_percentile": 0.51975}, "CVE-2021-29048": {"epss_score": 0.00474, "epss_percentile": 0.64161}, "CVE-2021-29049": {"epss_score": 0.00278, "epss_percentile": 0.50862}, "CVE-2021-29050": {"epss_score": 0.00592, "epss_percentile": 0.68611}, "CVE-2021-29051": {"epss_score": 0.00317, "epss_percentile": 0.54357}, "CVE-2021-29052": {"epss_score": 0.00105, "epss_percentile": 0.29295}, "CVE-2021-29053": {"epss_score": 0.00461, "epss_percentile": 0.63557}, "CVE-2021-29054": {"epss_score": 0.0025, "epss_percentile": 0.48109}, "CVE-2021-29055": {"epss_score": 0.00234, "epss_percentile": 0.46148}, "CVE-2021-29056": {"epss_score": 0.00197, "epss_percentile": 0.419}, "CVE-2021-29057": {"epss_score": 0.00054, "epss_percentile": 0.17203}, "CVE-2021-29059": {"epss_score": 0.02802, "epss_percentile": 0.857}, "CVE-2021-29060": {"epss_score": 0.00336, "epss_percentile": 0.55984}, "CVE-2021-29061": {"epss_score": 0.01521, "epss_percentile": 0.80827}, "CVE-2021-29063": {"epss_score": 0.02352, "epss_percentile": 0.84473}, "CVE-2021-29065": {"epss_score": 0.00105, "epss_percentile": 0.29363}, "CVE-2021-29066": {"epss_score": 0.00105, "epss_percentile": 0.29363}, "CVE-2021-29067": {"epss_score": 0.0014, "epss_percentile": 0.34745}, "CVE-2021-29068": {"epss_score": 0.00552, "epss_percentile": 0.67402}, "CVE-2021-29069": {"epss_score": 0.00081, "epss_percentile": 0.24279}, "CVE-2021-29070": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2021-29071": {"epss_score": 0.00183, "epss_percentile": 0.4028}, "CVE-2021-29072": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2021-29073": {"epss_score": 0.00095, "epss_percentile": 0.27128}, "CVE-2021-29074": {"epss_score": 0.00142, "epss_percentile": 0.35033}, "CVE-2021-29075": {"epss_score": 0.00142, "epss_percentile": 0.35033}, "CVE-2021-29076": {"epss_score": 0.00701, "epss_percentile": 0.71501}, "CVE-2021-29077": {"epss_score": 0.0021, "epss_percentile": 0.43489}, "CVE-2021-29078": {"epss_score": 0.00244, "epss_percentile": 0.47522}, "CVE-2021-29079": {"epss_score": 0.00244, "epss_percentile": 0.47522}, "CVE-2021-29080": {"epss_score": 0.0009, "epss_percentile": 0.26169}, "CVE-2021-29081": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-29082": {"epss_score": 0.00087, "epss_percentile": 0.25466}, "CVE-2021-29083": {"epss_score": 0.01037, "epss_percentile": 0.76924}, "CVE-2021-29084": {"epss_score": 0.00419, "epss_percentile": 0.61358}, "CVE-2021-29085": {"epss_score": 0.00284, "epss_percentile": 0.51461}, "CVE-2021-29086": {"epss_score": 0.00196, "epss_percentile": 0.41738}, "CVE-2021-29087": {"epss_score": 0.00295, "epss_percentile": 0.52481}, "CVE-2021-29088": {"epss_score": 0.00038, "epss_percentile": 0.11276}, "CVE-2021-29089": {"epss_score": 0.00818, "epss_percentile": 0.73853}, "CVE-2021-29090": {"epss_score": 0.01397, "epss_percentile": 0.79984}, "CVE-2021-29091": {"epss_score": 0.00147, "epss_percentile": 0.35646}, "CVE-2021-29092": {"epss_score": 0.01202, "epss_percentile": 0.78489}, "CVE-2021-29093": {"epss_score": 0.00385, "epss_percentile": 0.59232}, "CVE-2021-29094": {"epss_score": 0.00639, "epss_percentile": 0.69933}, "CVE-2021-29095": {"epss_score": 0.0036, "epss_percentile": 0.57688}, "CVE-2021-29096": {"epss_score": 0.00278, "epss_percentile": 0.5092}, "CVE-2021-29097": {"epss_score": 0.00441, "epss_percentile": 0.62657}, "CVE-2021-29098": {"epss_score": 0.00456, "epss_percentile": 0.63326}, "CVE-2021-29099": {"epss_score": 0.00231, "epss_percentile": 0.45833}, "CVE-2021-29100": {"epss_score": 0.00511, "epss_percentile": 0.65842}, "CVE-2021-29101": {"epss_score": 0.01645, "epss_percentile": 0.81524}, "CVE-2021-29102": {"epss_score": 0.00359, "epss_percentile": 0.57602}, "CVE-2021-29103": {"epss_score": 0.0023, "epss_percentile": 0.45724}, "CVE-2021-29104": {"epss_score": 0.00484, "epss_percentile": 0.64671}, "CVE-2021-29105": {"epss_score": 0.00148, "epss_percentile": 0.35924}, "CVE-2021-29106": {"epss_score": 0.0023, "epss_percentile": 0.45724}, "CVE-2021-29107": {"epss_score": 0.00484, "epss_percentile": 0.64671}, "CVE-2021-29108": {"epss_score": 0.00292, "epss_percentile": 0.52262}, "CVE-2021-29109": {"epss_score": 0.00189, "epss_percentile": 0.40993}, "CVE-2021-29110": {"epss_score": 0.00257, "epss_percentile": 0.48882}, "CVE-2021-29112": {"epss_score": 0.00072, "epss_percentile": 0.22253}, "CVE-2021-29113": {"epss_score": 0.00333, "epss_percentile": 0.55632}, "CVE-2021-29114": {"epss_score": 0.00427, "epss_percentile": 0.61904}, "CVE-2021-29115": {"epss_score": 0.01294, "epss_percentile": 0.79244}, "CVE-2021-29116": {"epss_score": 0.0032, "epss_percentile": 0.54616}, "CVE-2021-29117": {"epss_score": 0.00049, "epss_percentile": 0.15575}, "CVE-2021-29118": {"epss_score": 0.00072, "epss_percentile": 0.22253}, "CVE-2021-29133": {"epss_score": 0.02116, "epss_percentile": 0.83664}, "CVE-2021-29134": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2021-29136": {"epss_score": 0.00146, "epss_percentile": 0.3563}, "CVE-2021-29137": {"epss_score": 0.00381, "epss_percentile": 0.59005}, "CVE-2021-29138": {"epss_score": 0.00292, "epss_percentile": 0.52247}, "CVE-2021-29139": {"epss_score": 0.0028, "epss_percentile": 0.51001}, "CVE-2021-29140": {"epss_score": 0.00749, "epss_percentile": 0.72608}, "CVE-2021-29141": {"epss_score": 0.00437, "epss_percentile": 0.62502}, "CVE-2021-29142": {"epss_score": 0.0031, "epss_percentile": 0.53775}, "CVE-2021-29143": {"epss_score": 0.05032, "epss_percentile": 0.89415}, "CVE-2021-29144": {"epss_score": 0.00437, "epss_percentile": 0.62502}, "CVE-2021-29145": {"epss_score": 0.02064, "epss_percentile": 0.83453}, "CVE-2021-29146": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-29147": {"epss_score": 0.04237, "epss_percentile": 0.8843}, "CVE-2021-29148": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-29149": {"epss_score": 0.00056, "epss_percentile": 0.17781}, "CVE-2021-29150": {"epss_score": 0.01426, "epss_percentile": 0.80201}, "CVE-2021-29151": {"epss_score": 0.00137, "epss_percentile": 0.3429}, "CVE-2021-29152": {"epss_score": 0.00565, "epss_percentile": 0.67794}, "CVE-2021-29154": {"epss_score": 0.00037, "epss_percentile": 0.1067}, "CVE-2021-29155": {"epss_score": 0.00212, "epss_percentile": 0.43799}, "CVE-2021-29156": {"epss_score": 0.88035, "epss_percentile": 0.99455}, "CVE-2021-29157": {"epss_score": 0.00105, "epss_percentile": 0.29339}, "CVE-2021-29158": {"epss_score": 0.00224, "epss_percentile": 0.45054}, "CVE-2021-29159": {"epss_score": 0.00275, "epss_percentile": 0.507}, "CVE-2021-29200": {"epss_score": 0.92497, "epss_percentile": 0.9972}, "CVE-2021-29201": {"epss_score": 0.00185, "epss_percentile": 0.40481}, "CVE-2021-29202": {"epss_score": 0.00106, "epss_percentile": 0.29404}, "CVE-2021-29203": {"epss_score": 0.86779, "epss_percentile": 0.99395}, "CVE-2021-29204": {"epss_score": 0.00171, "epss_percentile": 0.3883}, "CVE-2021-29205": {"epss_score": 0.00171, "epss_percentile": 0.3883}, "CVE-2021-29206": {"epss_score": 0.00185, "epss_percentile": 0.40481}, "CVE-2021-29207": {"epss_score": 0.00171, "epss_percentile": 0.3883}, "CVE-2021-29208": {"epss_score": 0.00268, "epss_percentile": 0.50035}, "CVE-2021-29209": {"epss_score": 0.00268, "epss_percentile": 0.50035}, "CVE-2021-29210": {"epss_score": 0.00268, "epss_percentile": 0.50035}, "CVE-2021-29211": {"epss_score": 0.00171, "epss_percentile": 0.3883}, "CVE-2021-29212": {"epss_score": 0.16991, "epss_percentile": 0.94757}, "CVE-2021-29213": {"epss_score": 0.00036, "epss_percentile": 0.10238}, "CVE-2021-29214": {"epss_score": 0.0031, "epss_percentile": 0.53772}, "CVE-2021-29215": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-29216": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2021-29217": {"epss_score": 0.00223, "epss_percentile": 0.449}, "CVE-2021-29218": {"epss_score": 0.00065, "epss_percentile": 0.20584}, "CVE-2021-29219": {"epss_score": 0.00065, "epss_percentile": 0.2047}, "CVE-2021-29220": {"epss_score": 0.0045, "epss_percentile": 0.63078}, "CVE-2021-29221": {"epss_score": 0.00038, "epss_percentile": 0.11209}, "CVE-2021-29238": {"epss_score": 0.0017, "epss_percentile": 0.38652}, "CVE-2021-29239": {"epss_score": 0.00031, "epss_percentile": 0.08455}, "CVE-2021-29240": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2021-29241": {"epss_score": 0.00562, "epss_percentile": 0.67694}, "CVE-2021-29242": {"epss_score": 0.00438, "epss_percentile": 0.62564}, "CVE-2021-29243": {"epss_score": 0.00275, "epss_percentile": 0.507}, "CVE-2021-29245": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2021-29246": {"epss_score": 0.00465, "epss_percentile": 0.63745}, "CVE-2021-29247": {"epss_score": 0.00515, "epss_percentile": 0.65968}, "CVE-2021-29248": {"epss_score": 0.00235, "epss_percentile": 0.46209}, "CVE-2021-29249": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-29250": {"epss_score": 0.00272, "epss_percentile": 0.50417}, "CVE-2021-29251": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2021-29252": {"epss_score": 0.0025, "epss_percentile": 0.48137}, "CVE-2021-29253": {"epss_score": 0.0005, "epss_percentile": 0.15717}, "CVE-2021-29255": {"epss_score": 0.00115, "epss_percentile": 0.3093}, "CVE-2021-29256": {"epss_score": 0.00638, "epss_percentile": 0.69926}, "CVE-2021-29258": {"epss_score": 0.00116, "epss_percentile": 0.31037}, "CVE-2021-29261": {"epss_score": 0.00681, "epss_percentile": 0.71051}, "CVE-2021-29262": {"epss_score": 0.26231, "epss_percentile": 0.96126}, "CVE-2021-29263": {"epss_score": 1e-05, "epss_percentile": 5e-05}, "CVE-2021-29264": {"epss_score": 0.00111, "epss_percentile": 0.30391}, "CVE-2021-29265": {"epss_score": 0.00105, "epss_percentile": 0.29271}, "CVE-2021-29266": {"epss_score": 0.0007, "epss_percentile": 0.21687}, "CVE-2021-29267": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-29271": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-29272": {"epss_score": 0.00328, "epss_percentile": 0.55161}, "CVE-2021-29274": {"epss_score": 0.00323, "epss_percentile": 0.54888}, "CVE-2021-29279": {"epss_score": 0.0022, "epss_percentile": 0.44595}, "CVE-2021-29280": {"epss_score": 0.00098, "epss_percentile": 0.27757}, "CVE-2021-29281": {"epss_score": 0.03561, "epss_percentile": 0.87354}, "CVE-2021-29294": {"epss_score": 0.00263, "epss_percentile": 0.49543}, "CVE-2021-29295": {"epss_score": 0.00443, "epss_percentile": 0.62763}, "CVE-2021-29296": {"epss_score": 0.00263, "epss_percentile": 0.49543}, "CVE-2021-29297": {"epss_score": 0.00332, "epss_percentile": 0.55607}, "CVE-2021-29298": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2021-29300": {"epss_score": 0.44705, "epss_percentile": 0.9745}, "CVE-2021-29302": {"epss_score": 0.10093, "epss_percentile": 0.92846}, "CVE-2021-29313": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2021-29323": {"epss_score": 0.00146, "epss_percentile": 0.35639}, "CVE-2021-29324": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-29325": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-29326": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-29327": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-29328": {"epss_score": 0.00169, "epss_percentile": 0.38527}, "CVE-2021-29329": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-29334": {"epss_score": 0.00134, "epss_percentile": 0.33798}, "CVE-2021-29337": {"epss_score": 0.00092, "epss_percentile": 0.26528}, "CVE-2021-29338": {"epss_score": 0.00113, "epss_percentile": 0.30608}, "CVE-2021-29343": {"epss_score": 0.00188, "epss_percentile": 0.40904}, "CVE-2021-29349": {"epss_score": 0.00568, "epss_percentile": 0.67897}, "CVE-2021-29350": {"epss_score": 0.00519, "epss_percentile": 0.66178}, "CVE-2021-29357": {"epss_score": 0.00249, "epss_percentile": 0.48022}, "CVE-2021-29358": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2021-29360": {"epss_score": 0.00652, "epss_percentile": 0.70318}, "CVE-2021-29361": {"epss_score": 0.00652, "epss_percentile": 0.70318}, "CVE-2021-29362": {"epss_score": 0.00652, "epss_percentile": 0.70318}, "CVE-2021-29363": {"epss_score": 0.00652, "epss_percentile": 0.70318}, "CVE-2021-29364": {"epss_score": 0.00652, "epss_percentile": 0.70318}, "CVE-2021-29365": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2021-29366": {"epss_score": 0.00652, "epss_percentile": 0.70318}, "CVE-2021-29367": {"epss_score": 0.00652, "epss_percentile": 0.70318}, "CVE-2021-29368": {"epss_score": 0.00302, "epss_percentile": 0.53133}, "CVE-2021-29369": {"epss_score": 0.01099, "epss_percentile": 0.77557}, "CVE-2021-29370": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-29376": {"epss_score": 0.03609, "epss_percentile": 0.87422}, "CVE-2021-29377": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2021-29378": {"epss_score": 0.00061, "epss_percentile": 0.19313}, "CVE-2021-29379": {"epss_score": 0.30375, "epss_percentile": 0.96535}, "CVE-2021-29387": {"epss_score": 0.00242, "epss_percentile": 0.47333}, "CVE-2021-29388": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2021-29390": {"epss_score": 0.00066, "epss_percentile": 0.20705}, "CVE-2021-29393": {"epss_score": 0.14164, "epss_percentile": 0.94148}, "CVE-2021-29394": {"epss_score": 0.00153, "epss_percentile": 0.36593}, "CVE-2021-29395": {"epss_score": 0.0117, "epss_percentile": 0.78206}, "CVE-2021-29396": {"epss_score": 0.01395, "epss_percentile": 0.79978}, "CVE-2021-29397": {"epss_score": 0.00179, "epss_percentile": 0.39785}, "CVE-2021-29398": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2021-29399": {"epss_score": 0.00598, "epss_percentile": 0.68763}, "CVE-2021-29400": {"epss_score": 0.00108, "epss_percentile": 0.29881}, "CVE-2021-29414": {"epss_score": 0.0015, "epss_percentile": 0.36101}, "CVE-2021-29415": {"epss_score": 0.00081, "epss_percentile": 0.24395}, "CVE-2021-29416": {"epss_score": 0.00313, "epss_percentile": 0.54021}, "CVE-2021-29417": {"epss_score": 0.05337, "epss_percentile": 0.89744}, "CVE-2021-29418": {"epss_score": 0.00023, "epss_percentile": 0.05358}, "CVE-2021-29421": {"epss_score": 0.00374, "epss_percentile": 0.58539}, "CVE-2021-29424": {"epss_score": 0.00085, "epss_percentile": 0.25231}, "CVE-2021-29425": {"epss_score": 0.00485, "epss_percentile": 0.64734}, "CVE-2021-29427": {"epss_score": 0.00557, "epss_percentile": 0.67557}, "CVE-2021-29428": {"epss_score": 0.00055, "epss_percentile": 0.1753}, "CVE-2021-29429": {"epss_score": 0.00041, "epss_percentile": 0.12439}, "CVE-2021-29430": {"epss_score": 0.01367, "epss_percentile": 0.79784}, "CVE-2021-29431": {"epss_score": 0.00303, "epss_percentile": 0.53173}, "CVE-2021-29432": {"epss_score": 0.0025, "epss_percentile": 0.48213}, "CVE-2021-29433": {"epss_score": 0.00281, "epss_percentile": 0.51121}, "CVE-2021-29434": {"epss_score": 0.00274, "epss_percentile": 0.50486}, "CVE-2021-29435": {"epss_score": 0.00144, "epss_percentile": 0.35263}, "CVE-2021-29436": {"epss_score": 0.00218, "epss_percentile": 0.44389}, "CVE-2021-29437": {"epss_score": 0.00271, "epss_percentile": 0.50341}, "CVE-2021-29438": {"epss_score": 0.00224, "epss_percentile": 0.44998}, "CVE-2021-29439": {"epss_score": 0.00723, "epss_percentile": 0.72025}, "CVE-2021-29440": {"epss_score": 0.18422, "epss_percentile": 0.95014}, "CVE-2021-29441": {"epss_score": 0.9419, "epss_percentile": 0.99916}, "CVE-2021-29442": {"epss_score": 0.94002, "epss_percentile": 0.99883}, "CVE-2021-29443": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-29444": {"epss_score": 0.00394, "epss_percentile": 0.59764}, "CVE-2021-29445": {"epss_score": 0.00394, "epss_percentile": 0.59764}, "CVE-2021-29446": {"epss_score": 0.00394, "epss_percentile": 0.59764}, "CVE-2021-29447": {"epss_score": 0.90358, "epss_percentile": 0.99579}, "CVE-2021-29448": {"epss_score": 0.00303, "epss_percentile": 0.53231}, "CVE-2021-29449": {"epss_score": 0.1136, "epss_percentile": 0.93323}, "CVE-2021-29450": {"epss_score": 0.0208, "epss_percentile": 0.83529}, "CVE-2021-29451": {"epss_score": 0.002, "epss_percentile": 0.42258}, "CVE-2021-29452": {"epss_score": 0.00248, "epss_percentile": 0.47932}, "CVE-2021-29453": {"epss_score": 0.0032, "epss_percentile": 0.54596}, "CVE-2021-29454": {"epss_score": 0.00438, "epss_percentile": 0.62547}, "CVE-2021-29455": {"epss_score": 0.002, "epss_percentile": 0.42258}, "CVE-2021-29456": {"epss_score": 0.00151, "epss_percentile": 0.3623}, "CVE-2021-29457": {"epss_score": 0.01509, "epss_percentile": 0.80764}, "CVE-2021-29458": {"epss_score": 0.00095, "epss_percentile": 0.27153}, "CVE-2021-29459": {"epss_score": 0.00423, "epss_percentile": 0.61636}, "CVE-2021-29460": {"epss_score": 0.0112, "epss_percentile": 0.77763}, "CVE-2021-29461": {"epss_score": 0.01563, "epss_percentile": 0.81057}, "CVE-2021-29462": {"epss_score": 0.00137, "epss_percentile": 0.34302}, "CVE-2021-29463": {"epss_score": 0.00099, "epss_percentile": 0.28375}, "CVE-2021-29464": {"epss_score": 0.00155, "epss_percentile": 0.36769}, "CVE-2021-29465": {"epss_score": 0.03684, "epss_percentile": 0.87567}, "CVE-2021-29466": {"epss_score": 0.00703, "epss_percentile": 0.71548}, "CVE-2021-29467": {"epss_score": 0.00178, "epss_percentile": 0.39635}, "CVE-2021-29468": {"epss_score": 0.00545, "epss_percentile": 0.67165}, "CVE-2021-29469": {"epss_score": 0.00381, "epss_percentile": 0.58997}, "CVE-2021-29470": {"epss_score": 0.0019, "epss_percentile": 0.4106}, "CVE-2021-29471": {"epss_score": 0.00611, "epss_percentile": 0.69181}, "CVE-2021-29472": {"epss_score": 0.03585, "epss_percentile": 0.87392}, "CVE-2021-29473": {"epss_score": 0.00144, "epss_percentile": 0.35226}, "CVE-2021-29474": {"epss_score": 0.00277, "epss_percentile": 0.50787}, "CVE-2021-29475": {"epss_score": 0.00259, "epss_percentile": 0.49044}, "CVE-2021-29476": {"epss_score": 0.02219, "epss_percentile": 0.84047}, "CVE-2021-29477": {"epss_score": 0.03523, "epss_percentile": 0.87291}, "CVE-2021-29478": {"epss_score": 0.02489, "epss_percentile": 0.84894}, "CVE-2021-29479": {"epss_score": 0.00225, "epss_percentile": 0.45233}, "CVE-2021-29480": {"epss_score": 0.00089, "epss_percentile": 0.25946}, "CVE-2021-29481": {"epss_score": 0.00072, "epss_percentile": 0.22245}, "CVE-2021-29482": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2021-29483": {"epss_score": 0.00441, "epss_percentile": 0.62668}, "CVE-2021-29484": {"epss_score": 0.82004, "epss_percentile": 0.99169}, "CVE-2021-29485": {"epss_score": 0.02483, "epss_percentile": 0.8488}, "CVE-2021-29486": {"epss_score": 0.00661, "epss_percentile": 0.70565}, "CVE-2021-29487": {"epss_score": 0.00503, "epss_percentile": 0.65465}, "CVE-2021-29488": {"epss_score": 0.00267, "epss_percentile": 0.4996}, "CVE-2021-29489": {"epss_score": 0.00227, "epss_percentile": 0.45424}, "CVE-2021-29490": {"epss_score": 0.91997, "epss_percentile": 0.99684}, "CVE-2021-29492": {"epss_score": 0.07418, "epss_percentile": 0.91462}, "CVE-2021-29493": {"epss_score": 0.00317, "epss_percentile": 0.54311}, "CVE-2021-29495": {"epss_score": 0.00107, "epss_percentile": 0.29578}, "CVE-2021-29499": {"epss_score": 0.00317, "epss_percentile": 0.54348}, "CVE-2021-29500": {"epss_score": 0.0011, "epss_percentile": 0.30228}, "CVE-2021-29501": {"epss_score": 0.0029, "epss_percentile": 0.52107}, "CVE-2021-29502": {"epss_score": 0.00306, "epss_percentile": 0.53415}, "CVE-2021-29503": {"epss_score": 0.02049, "epss_percentile": 0.83395}, "CVE-2021-29504": {"epss_score": 0.00849, "epss_percentile": 0.74371}, "CVE-2021-29505": {"epss_score": 0.90349, "epss_percentile": 0.99579}, "CVE-2021-29506": {"epss_score": 0.00376, "epss_percentile": 0.58658}, "CVE-2021-29507": {"epss_score": 0.00262, "epss_percentile": 0.49385}, "CVE-2021-29508": {"epss_score": 0.00451, "epss_percentile": 0.63147}, "CVE-2021-29509": {"epss_score": 0.01358, "epss_percentile": 0.7973}, "CVE-2021-29510": {"epss_score": 0.00066, "epss_percentile": 0.20695}, "CVE-2021-29511": {"epss_score": 0.00376, "epss_percentile": 0.58658}, "CVE-2021-29512": {"epss_score": 0.00018, "epss_percentile": 0.03803}, "CVE-2021-29513": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29514": {"epss_score": 0.00018, "epss_percentile": 0.03803}, "CVE-2021-29515": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29516": {"epss_score": 0.00015, "epss_percentile": 0.02536}, "CVE-2021-29517": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29518": {"epss_score": 9e-05, "epss_percentile": 0.00627}, "CVE-2021-29519": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29520": {"epss_score": 0.00019, "epss_percentile": 0.04197}, "CVE-2021-29521": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29522": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29523": {"epss_score": 0.00015, "epss_percentile": 0.02236}, "CVE-2021-29524": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29525": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29526": {"epss_score": 0.00015, "epss_percentile": 0.02536}, "CVE-2021-29527": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29528": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29529": {"epss_score": 0.00047, "epss_percentile": 0.14671}, "CVE-2021-29530": {"epss_score": 0.00021, "epss_percentile": 0.04697}, "CVE-2021-29531": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29532": {"epss_score": 0.00017, "epss_percentile": 0.03336}, "CVE-2021-29533": {"epss_score": 0.00018, "epss_percentile": 0.03607}, "CVE-2021-29534": {"epss_score": 0.00015, "epss_percentile": 0.02236}, "CVE-2021-29535": {"epss_score": 0.00018, "epss_percentile": 0.03884}, "CVE-2021-29536": {"epss_score": 0.00018, "epss_percentile": 0.03884}, "CVE-2021-29537": {"epss_score": 0.00018, "epss_percentile": 0.03884}, "CVE-2021-29538": {"epss_score": 0.00015, "epss_percentile": 0.02236}, "CVE-2021-29539": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29540": {"epss_score": 0.00019, "epss_percentile": 0.04197}, "CVE-2021-29541": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29542": {"epss_score": 0.00016, "epss_percentile": 0.0264}, "CVE-2021-29543": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29544": {"epss_score": 0.00067, "epss_percentile": 0.2114}, "CVE-2021-29545": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29546": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29547": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29548": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29549": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29550": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29551": {"epss_score": 0.00018, "epss_percentile": 0.03607}, "CVE-2021-29552": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29553": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29554": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29555": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29556": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29557": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29558": {"epss_score": 0.00018, "epss_percentile": 0.03803}, "CVE-2021-29559": {"epss_score": 0.00017, "epss_percentile": 0.03336}, "CVE-2021-29560": {"epss_score": 0.00018, "epss_percentile": 0.03884}, "CVE-2021-29561": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29562": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29563": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29564": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29565": {"epss_score": 0.00059, "epss_percentile": 0.1886}, "CVE-2021-29566": {"epss_score": 0.00017, "epss_percentile": 0.03336}, "CVE-2021-29567": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29568": {"epss_score": 0.00011, "epss_percentile": 0.01079}, "CVE-2021-29569": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29570": {"epss_score": 0.00014, "epss_percentile": 0.01744}, "CVE-2021-29571": {"epss_score": 0.00026, "epss_percentile": 0.06576}, "CVE-2021-29572": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29573": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29574": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29575": {"epss_score": 0.00017, "epss_percentile": 0.03334}, "CVE-2021-29576": {"epss_score": 0.00018, "epss_percentile": 0.03803}, "CVE-2021-29577": {"epss_score": 0.00018, "epss_percentile": 0.03803}, "CVE-2021-29578": {"epss_score": 0.00018, "epss_percentile": 0.03803}, "CVE-2021-29579": {"epss_score": 0.00018, "epss_percentile": 0.03803}, "CVE-2021-29580": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29581": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29582": {"epss_score": 0.00017, "epss_percentile": 0.03336}, "CVE-2021-29583": {"epss_score": 0.00018, "epss_percentile": 0.03803}, "CVE-2021-29584": {"epss_score": 0.00011, "epss_percentile": 0.01015}, "CVE-2021-29585": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29586": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29587": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29588": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29589": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29590": {"epss_score": 0.00017, "epss_percentile": 0.03336}, "CVE-2021-29591": {"epss_score": 0.00056, "epss_percentile": 0.17717}, "CVE-2021-29592": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29593": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29594": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29595": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29596": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29597": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29598": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29599": {"epss_score": 0.00065, "epss_percentile": 0.20547}, "CVE-2021-29600": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29601": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29602": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29603": {"epss_score": 0.00017, "epss_percentile": 0.03336}, "CVE-2021-29604": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29605": {"epss_score": 0.0002, "epss_percentile": 0.04559}, "CVE-2021-29606": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29607": {"epss_score": 0.00048, "epss_percentile": 0.14998}, "CVE-2021-29608": {"epss_score": 0.00057, "epss_percentile": 0.18212}, "CVE-2021-29609": {"epss_score": 0.00048, "epss_percentile": 0.14998}, "CVE-2021-29610": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29611": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29612": {"epss_score": 0.00065, "epss_percentile": 0.20601}, "CVE-2021-29613": {"epss_score": 0.00048, "epss_percentile": 0.14998}, "CVE-2021-29614": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29615": {"epss_score": 0.00015, "epss_percentile": 0.02599}, "CVE-2021-29616": {"epss_score": 0.00017, "epss_percentile": 0.03292}, "CVE-2021-29617": {"epss_score": 0.0005, "epss_percentile": 0.15713}, "CVE-2021-29618": {"epss_score": 0.0005, "epss_percentile": 0.15713}, "CVE-2021-29619": {"epss_score": 0.00015, "epss_percentile": 0.02184}, "CVE-2021-29620": {"epss_score": 0.00417, "epss_percentile": 0.61247}, "CVE-2021-29621": {"epss_score": 0.00429, "epss_percentile": 0.61997}, "CVE-2021-29622": {"epss_score": 0.8663, "epss_percentile": 0.99391}, "CVE-2021-29623": {"epss_score": 0.00554, "epss_percentile": 0.67444}, "CVE-2021-29624": {"epss_score": 0.00254, "epss_percentile": 0.48532}, "CVE-2021-29625": {"epss_score": 0.70255, "epss_percentile": 0.98625}, "CVE-2021-29626": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2021-29627": {"epss_score": 0.0105, "epss_percentile": 0.77069}, "CVE-2021-29628": {"epss_score": 0.0019, "epss_percentile": 0.41076}, "CVE-2021-29629": {"epss_score": 0.00494, "epss_percentile": 0.6509}, "CVE-2021-29630": {"epss_score": 0.0108, "epss_percentile": 0.77366}, "CVE-2021-29631": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2021-29632": {"epss_score": 0.00255, "epss_percentile": 0.48642}, "CVE-2021-29641": {"epss_score": 0.0565, "epss_percentile": 0.90083}, "CVE-2021-29642": {"epss_score": 0.00206, "epss_percentile": 0.42787}, "CVE-2021-29643": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-29644": {"epss_score": 0.02624, "epss_percentile": 0.85261}, "CVE-2021-29645": {"epss_score": 0.00044, "epss_percentile": 0.13516}, "CVE-2021-29646": {"epss_score": 0.00105, "epss_percentile": 0.29343}, "CVE-2021-29647": {"epss_score": 0.00094, "epss_percentile": 0.27066}, "CVE-2021-29648": {"epss_score": 0.00074, "epss_percentile": 0.22685}, "CVE-2021-29649": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2021-29650": {"epss_score": 0.00022, "epss_percentile": 0.05153}, "CVE-2021-29651": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2021-29652": {"epss_score": 0.0018, "epss_percentile": 0.39887}, "CVE-2021-29653": {"epss_score": 0.00098, "epss_percentile": 0.27715}, "CVE-2021-29654": {"epss_score": 0.01889, "epss_percentile": 0.82723}, "CVE-2021-29655": {"epss_score": 0.00191, "epss_percentile": 0.41194}, "CVE-2021-29656": {"epss_score": 0.0022, "epss_percentile": 0.44537}, "CVE-2021-29657": {"epss_score": 0.00043, "epss_percentile": 0.13181}, "CVE-2021-29658": {"epss_score": 0.00484, "epss_percentile": 0.64638}, "CVE-2021-29659": {"epss_score": 0.00299, "epss_percentile": 0.52892}, "CVE-2021-29660": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2021-29661": {"epss_score": 0.0042, "epss_percentile": 0.61413}, "CVE-2021-29662": {"epss_score": 0.00597, "epss_percentile": 0.68748}, "CVE-2021-29663": {"epss_score": 0.00201, "epss_percentile": 0.42336}, "CVE-2021-29665": {"epss_score": 0.00679, "epss_percentile": 0.71022}, "CVE-2021-29666": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-29667": {"epss_score": 0.00313, "epss_percentile": 0.54045}, "CVE-2021-29668": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2021-29669": {"epss_score": 0.00155, "epss_percentile": 0.36832}, "CVE-2021-29670": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2021-29671": {"epss_score": 0.00038, "epss_percentile": 0.11411}, "CVE-2021-29672": {"epss_score": 0.00092, "epss_percentile": 0.26486}, "CVE-2021-29673": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-29676": {"epss_score": 0.00123, "epss_percentile": 0.32194}, "CVE-2021-29677": {"epss_score": 0.00239, "epss_percentile": 0.46872}, "CVE-2021-29678": {"epss_score": 0.00205, "epss_percentile": 0.4268}, "CVE-2021-29679": {"epss_score": 0.00721, "epss_percentile": 0.71974}, "CVE-2021-29681": {"epss_score": 0.00188, "epss_percentile": 0.40845}, "CVE-2021-29682": {"epss_score": 0.00318, "epss_percentile": 0.54431}, "CVE-2021-29683": {"epss_score": 0.00087, "epss_percentile": 0.25556}, "CVE-2021-29686": {"epss_score": 0.00167, "epss_percentile": 0.38313}, "CVE-2021-29687": {"epss_score": 0.00187, "epss_percentile": 0.40749}, "CVE-2021-29688": {"epss_score": 0.00303, "epss_percentile": 0.53231}, "CVE-2021-29691": {"epss_score": 0.00065, "epss_percentile": 0.20593}, "CVE-2021-29692": {"epss_score": 0.00185, "epss_percentile": 0.40477}, "CVE-2021-29693": {"epss_score": 0.00102, "epss_percentile": 0.28894}, "CVE-2021-29694": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2021-29695": {"epss_score": 0.00653, "epss_percentile": 0.70337}, "CVE-2021-29696": {"epss_score": 0.00492, "epss_percentile": 0.64992}, "CVE-2021-29697": {"epss_score": 0.00154, "epss_percentile": 0.367}, "CVE-2021-29699": {"epss_score": 0.00355, "epss_percentile": 0.57288}, "CVE-2021-29700": {"epss_score": 0.00025, "epss_percentile": 0.06299}, "CVE-2021-29701": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2021-29702": {"epss_score": 0.00755, "epss_percentile": 0.72715}, "CVE-2021-29703": {"epss_score": 0.00644, "epss_percentile": 0.7009}, "CVE-2021-29704": {"epss_score": 0.00087, "epss_percentile": 0.255}, "CVE-2021-29706": {"epss_score": 0.00036, "epss_percentile": 0.10299}, "CVE-2021-29707": {"epss_score": 0.00036, "epss_percentile": 0.10339}, "CVE-2021-29708": {"epss_score": 0.00048, "epss_percentile": 0.15071}, "CVE-2021-29711": {"epss_score": 0.00083, "epss_percentile": 0.24753}, "CVE-2021-29712": {"epss_score": 0.00149, "epss_percentile": 0.36039}, "CVE-2021-29713": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2021-29714": {"epss_score": 0.00198, "epss_percentile": 0.42014}, "CVE-2021-29715": {"epss_score": 0.00506, "epss_percentile": 0.65626}, "CVE-2021-29716": {"epss_score": 0.00361, "epss_percentile": 0.57722}, "CVE-2021-29719": {"epss_score": 0.00202, "epss_percentile": 0.42483}, "CVE-2021-29722": {"epss_score": 0.00142, "epss_percentile": 0.3509}, "CVE-2021-29723": {"epss_score": 0.00142, "epss_percentile": 0.3509}, "CVE-2021-29725": {"epss_score": 0.02028, "epss_percentile": 0.83322}, "CVE-2021-29726": {"epss_score": 0.00069, "epss_percentile": 0.21499}, "CVE-2021-29727": {"epss_score": 0.00037, "epss_percentile": 0.10671}, "CVE-2021-29728": {"epss_score": 0.00088, "epss_percentile": 0.25749}, "CVE-2021-29730": {"epss_score": 0.00268, "epss_percentile": 0.50093}, "CVE-2021-29735": {"epss_score": 0.00102, "epss_percentile": 0.28773}, "CVE-2021-29736": {"epss_score": 0.00523, "epss_percentile": 0.66291}, "CVE-2021-29737": {"epss_score": 0.00121, "epss_percentile": 0.31812}, "CVE-2021-29738": {"epss_score": 0.00157, "epss_percentile": 0.37059}, "CVE-2021-29739": {"epss_score": 0.00138, "epss_percentile": 0.34351}, "CVE-2021-29740": {"epss_score": 0.00073, "epss_percentile": 0.22589}, "CVE-2021-29741": {"epss_score": 0.00039, "epss_percentile": 0.11456}, "CVE-2021-29742": {"epss_score": 0.00198, "epss_percentile": 0.42003}, "CVE-2021-29743": {"epss_score": 0.0015, "epss_percentile": 0.3609}, "CVE-2021-29744": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-29745": {"epss_score": 0.0024, "epss_percentile": 0.472}, "CVE-2021-29747": {"epss_score": 0.00492, "epss_percentile": 0.65002}, "CVE-2021-29749": {"epss_score": 0.00242, "epss_percentile": 0.47373}, "CVE-2021-29750": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2021-29751": {"epss_score": 0.00225, "epss_percentile": 0.45136}, "CVE-2021-29752": {"epss_score": 0.00361, "epss_percentile": 0.57727}, "CVE-2021-29753": {"epss_score": 0.0007, "epss_percentile": 0.21722}, "CVE-2021-29754": {"epss_score": 0.0015, "epss_percentile": 0.36098}, "CVE-2021-29755": {"epss_score": 0.00095, "epss_percentile": 0.2713}, "CVE-2021-29756": {"epss_score": 0.00155, "epss_percentile": 0.36826}, "CVE-2021-29757": {"epss_score": 0.00108, "epss_percentile": 0.29875}, "CVE-2021-29758": {"epss_score": 0.00133, "epss_percentile": 0.33732}, "CVE-2021-29759": {"epss_score": 0.00045, "epss_percentile": 0.13819}, "CVE-2021-29760": {"epss_score": 0.00119, "epss_percentile": 0.31669}, "CVE-2021-29761": {"epss_score": 0.00119, "epss_percentile": 0.31669}, "CVE-2021-29763": {"epss_score": 0.00056, "epss_percentile": 0.17731}, "CVE-2021-29764": {"epss_score": 0.0015, "epss_percentile": 0.3609}, "CVE-2021-29765": {"epss_score": 0.00206, "epss_percentile": 0.43047}, "CVE-2021-29766": {"epss_score": 0.00177, "epss_percentile": 0.39627}, "CVE-2021-29767": {"epss_score": 0.00177, "epss_percentile": 0.39627}, "CVE-2021-29768": {"epss_score": 0.00304, "epss_percentile": 0.53297}, "CVE-2021-29769": {"epss_score": 0.0008, "epss_percentile": 0.24185}, "CVE-2021-29770": {"epss_score": 0.00133, "epss_percentile": 0.33732}, "CVE-2021-29771": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-29772": {"epss_score": 0.0025, "epss_percentile": 0.48095}, "CVE-2021-29773": {"epss_score": 0.00087, "epss_percentile": 0.25447}, "CVE-2021-29774": {"epss_score": 0.00269, "epss_percentile": 0.50126}, "CVE-2021-29775": {"epss_score": 0.00161, "epss_percentile": 0.37557}, "CVE-2021-29776": {"epss_score": 0.00179, "epss_percentile": 0.39747}, "CVE-2021-29777": {"epss_score": 0.00326, "epss_percentile": 0.5507}, "CVE-2021-29779": {"epss_score": 0.00127, "epss_percentile": 0.32895}, "CVE-2021-29780": {"epss_score": 0.00189, "epss_percentile": 0.40934}, "CVE-2021-29781": {"epss_score": 0.04051, "epss_percentile": 0.88176}, "CVE-2021-29784": {"epss_score": 0.00089, "epss_percentile": 0.25936}, "CVE-2021-29785": {"epss_score": 0.00223, "epss_percentile": 0.44883}, "CVE-2021-29786": {"epss_score": 0.00087, "epss_percentile": 0.25556}, "CVE-2021-29788": {"epss_score": 0.00235, "epss_percentile": 0.46224}, "CVE-2021-29790": {"epss_score": 0.00235, "epss_percentile": 0.46224}, "CVE-2021-29792": {"epss_score": 0.00098, "epss_percentile": 0.27716}, "CVE-2021-29794": {"epss_score": 0.00087, "epss_percentile": 0.255}, "CVE-2021-29795": {"epss_score": 0.0004, "epss_percentile": 0.11924}, "CVE-2021-29798": {"epss_score": 0.00358, "epss_percentile": 0.57539}, "CVE-2021-29799": {"epss_score": 0.00186, "epss_percentile": 0.40618}, "CVE-2021-29800": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29801": {"epss_score": 0.00034, "epss_percentile": 0.09467}, "CVE-2021-29802": {"epss_score": 0.00099, "epss_percentile": 0.28396}, "CVE-2021-29803": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29804": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29805": {"epss_score": 0.00177, "epss_percentile": 0.39598}, "CVE-2021-29806": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29807": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29808": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29809": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29810": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29811": {"epss_score": 0.00192, "epss_percentile": 0.41309}, "CVE-2021-29812": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29813": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29814": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29815": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29816": {"epss_score": 0.0009, "epss_percentile": 0.26068}, "CVE-2021-29817": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2021-29818": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2021-29819": {"epss_score": 0.00239, "epss_percentile": 0.46872}, "CVE-2021-29820": {"epss_score": 0.00239, "epss_percentile": 0.46872}, "CVE-2021-29821": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2021-29822": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2021-29823": {"epss_score": 0.00062, "epss_percentile": 0.19659}, "CVE-2021-29824": {"epss_score": 0.00224, "epss_percentile": 0.45072}, "CVE-2021-29825": {"epss_score": 0.00299, "epss_percentile": 0.52867}, "CVE-2021-29827": {"epss_score": 0.00031, "epss_percentile": 0.08549}, "CVE-2021-29831": {"epss_score": 0.00664, "epss_percentile": 0.70632}, "CVE-2021-29832": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29833": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-29834": {"epss_score": 0.00105, "epss_percentile": 0.29375}, "CVE-2021-29835": {"epss_score": 0.00157, "epss_percentile": 0.37119}, "CVE-2021-29836": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-29837": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2021-29838": {"epss_score": 0.00168, "epss_percentile": 0.38421}, "CVE-2021-29841": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2021-29842": {"epss_score": 0.00369, "epss_percentile": 0.58264}, "CVE-2021-29843": {"epss_score": 0.00198, "epss_percentile": 0.42014}, "CVE-2021-29844": {"epss_score": 0.00128, "epss_percentile": 0.33023}, "CVE-2021-29845": {"epss_score": 0.00192, "epss_percentile": 0.41326}, "CVE-2021-29846": {"epss_score": 0.00108, "epss_percentile": 0.29883}, "CVE-2021-29847": {"epss_score": 0.00176, "epss_percentile": 0.39393}, "CVE-2021-29849": {"epss_score": 0.00157, "epss_percentile": 0.37119}, "CVE-2021-29851": {"epss_score": 0.00089, "epss_percentile": 0.25936}, "CVE-2021-29852": {"epss_score": 0.00143, "epss_percentile": 0.35117}, "CVE-2021-29853": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2021-29854": {"epss_score": 0.00057, "epss_percentile": 0.18129}, "CVE-2021-29855": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-29856": {"epss_score": 0.00377, "epss_percentile": 0.58689}, "CVE-2021-29859": {"epss_score": 0.00049, "epss_percentile": 0.15615}, "CVE-2021-29860": {"epss_score": 0.00108, "epss_percentile": 0.2982}, "CVE-2021-29861": {"epss_score": 0.00108, "epss_percentile": 0.2982}, "CVE-2021-29862": {"epss_score": 0.00041, "epss_percentile": 0.12404}, "CVE-2021-29863": {"epss_score": 0.00092, "epss_percentile": 0.26447}, "CVE-2021-29864": {"epss_score": 0.00094, "epss_percentile": 0.27005}, "CVE-2021-29865": {"epss_score": 0.0008, "epss_percentile": 0.2412}, "CVE-2021-29867": {"epss_score": 0.00167, "epss_percentile": 0.38364}, "CVE-2021-29868": {"epss_score": 0.00036, "epss_percentile": 0.10236}, "CVE-2021-29872": {"epss_score": 0.00054, "epss_percentile": 0.17106}, "CVE-2021-29873": {"epss_score": 0.00431, "epss_percentile": 0.62037}, "CVE-2021-29875": {"epss_score": 0.00206, "epss_percentile": 0.43047}, "CVE-2021-29878": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-29880": {"epss_score": 0.00258, "epss_percentile": 0.4901}, "CVE-2021-29883": {"epss_score": 0.00122, "epss_percentile": 0.32031}, "CVE-2021-29888": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2021-29891": {"epss_score": 0.00127, "epss_percentile": 0.32811}, "CVE-2021-29892": {"epss_score": 0.00032, "epss_percentile": 0.08787}, "CVE-2021-29894": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2021-29899": {"epss_score": 0.00198, "epss_percentile": 0.42081}, "CVE-2021-29903": {"epss_score": 0.00358, "epss_percentile": 0.57539}, "CVE-2021-29904": {"epss_score": 0.00022, "epss_percentile": 0.04984}, "CVE-2021-29905": {"epss_score": 0.00208, "epss_percentile": 0.43236}, "CVE-2021-29906": {"epss_score": 0.00101, "epss_percentile": 0.28603}, "CVE-2021-29907": {"epss_score": 0.00561, "epss_percentile": 0.67669}, "CVE-2021-29908": {"epss_score": 0.00606, "epss_percentile": 0.69021}, "CVE-2021-29912": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2021-29913": {"epss_score": 0.00053, "epss_percentile": 0.16982}, "CVE-2021-29921": {"epss_score": 0.01822, "epss_percentile": 0.82415}, "CVE-2021-29922": {"epss_score": 0.00325, "epss_percentile": 0.55035}, "CVE-2021-29923": {"epss_score": 0.00115, "epss_percentile": 0.30885}, "CVE-2021-29929": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-29930": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-29931": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-29932": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-29933": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-29934": {"epss_score": 0.00349, "epss_percentile": 0.56889}, "CVE-2021-29935": {"epss_score": 0.0041, "epss_percentile": 0.60812}, "CVE-2021-29936": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-29937": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2021-29938": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-29939": {"epss_score": 0.00765, "epss_percentile": 0.72926}, "CVE-2021-29940": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-29941": {"epss_score": 0.00349, "epss_percentile": 0.56889}, "CVE-2021-29942": {"epss_score": 0.00349, "epss_percentile": 0.56889}, "CVE-2021-29943": {"epss_score": 0.07673, "epss_percentile": 0.91617}, "CVE-2021-29944": {"epss_score": 0.00377, "epss_percentile": 0.58772}, "CVE-2021-29945": {"epss_score": 0.00409, "epss_percentile": 0.60724}, "CVE-2021-29946": {"epss_score": 0.00163, "epss_percentile": 0.37831}, "CVE-2021-29947": {"epss_score": 0.00348, "epss_percentile": 0.56799}, "CVE-2021-29948": {"epss_score": 0.00071, "epss_percentile": 0.22224}, "CVE-2021-29949": {"epss_score": 0.00063, "epss_percentile": 0.19818}, "CVE-2021-29950": {"epss_score": 0.00131, "epss_percentile": 0.33407}, "CVE-2021-29951": {"epss_score": 0.00391, "epss_percentile": 0.59626}, "CVE-2021-29952": {"epss_score": 0.00253, "epss_percentile": 0.48464}, "CVE-2021-29953": {"epss_score": 0.00392, "epss_percentile": 0.59691}, "CVE-2021-29954": {"epss_score": 0.00173, "epss_percentile": 0.39092}, "CVE-2021-29955": {"epss_score": 0.00884, "epss_percentile": 0.74928}, "CVE-2021-29956": {"epss_score": 0.00133, "epss_percentile": 0.33684}, "CVE-2021-29957": {"epss_score": 0.00305, "epss_percentile": 0.5338}, "CVE-2021-29958": {"epss_score": 0.00186, "epss_percentile": 0.40691}, "CVE-2021-29959": {"epss_score": 0.00316, "epss_percentile": 0.54296}, "CVE-2021-29960": {"epss_score": 0.00424, "epss_percentile": 0.6167}, "CVE-2021-29961": {"epss_score": 0.00316, "epss_percentile": 0.54296}, "CVE-2021-29962": {"epss_score": 0.00399, "epss_percentile": 0.60095}, "CVE-2021-29963": {"epss_score": 0.00143, "epss_percentile": 0.35198}, "CVE-2021-29964": {"epss_score": 0.00324, "epss_percentile": 0.5495}, "CVE-2021-29965": {"epss_score": 0.00304, "epss_percentile": 0.53252}, "CVE-2021-29966": {"epss_score": 0.00467, "epss_percentile": 0.63864}, "CVE-2021-29967": {"epss_score": 0.00244, "epss_percentile": 0.47563}, "CVE-2021-29968": {"epss_score": 0.00296, "epss_percentile": 0.52547}, "CVE-2021-29969": {"epss_score": 0.00396, "epss_percentile": 0.59885}, "CVE-2021-29970": {"epss_score": 0.00746, "epss_percentile": 0.72545}, "CVE-2021-29971": {"epss_score": 0.00412, "epss_percentile": 0.6092}, "CVE-2021-29972": {"epss_score": 0.00467, "epss_percentile": 0.63864}, "CVE-2021-29973": {"epss_score": 0.0034, "epss_percentile": 0.56227}, "CVE-2021-29974": {"epss_score": 0.00391, "epss_percentile": 0.59573}, "CVE-2021-29975": {"epss_score": 0.00391, "epss_percentile": 0.59573}, "CVE-2021-29976": {"epss_score": 0.00594, "epss_percentile": 0.68654}, "CVE-2021-29977": {"epss_score": 0.00467, "epss_percentile": 0.63864}, "CVE-2021-29978": {"epss_score": 0.01032, "epss_percentile": 0.7686}, "CVE-2021-29979": {"epss_score": 0.00489, "epss_percentile": 0.64874}, "CVE-2021-29980": {"epss_score": 0.00449, "epss_percentile": 0.63034}, "CVE-2021-29981": {"epss_score": 0.00445, "epss_percentile": 0.62851}, "CVE-2021-29982": {"epss_score": 0.00383, "epss_percentile": 0.59098}, "CVE-2021-29983": {"epss_score": 0.00294, "epss_percentile": 0.52387}, "CVE-2021-29984": {"epss_score": 0.00446, "epss_percentile": 0.6291}, "CVE-2021-29985": {"epss_score": 0.00413, "epss_percentile": 0.60995}, "CVE-2021-29986": {"epss_score": 0.00587, "epss_percentile": 0.68474}, "CVE-2021-29987": {"epss_score": 0.0031, "epss_percentile": 0.538}, "CVE-2021-29988": {"epss_score": 0.00411, "epss_percentile": 0.6085}, "CVE-2021-29989": {"epss_score": 0.00345, "epss_percentile": 0.56556}, "CVE-2021-29990": {"epss_score": 0.00445, "epss_percentile": 0.62851}, "CVE-2021-29991": {"epss_score": 0.00341, "epss_percentile": 0.56324}, "CVE-2021-29993": {"epss_score": 0.00401, "epss_percentile": 0.60204}, "CVE-2021-29994": {"epss_score": 0.00466, "epss_percentile": 0.63792}, "CVE-2021-29995": {"epss_score": 0.01725, "epss_percentile": 0.81957}, "CVE-2021-29996": {"epss_score": 0.0322, "epss_percentile": 0.86673}, "CVE-2021-29997": {"epss_score": 0.00127, "epss_percentile": 0.32917}, "CVE-2021-29998": {"epss_score": 0.0072, "epss_percentile": 0.71964}, "CVE-2021-29999": {"epss_score": 0.00394, "epss_percentile": 0.5976}, "CVE-2021-2000": {"epss_score": 0.00218, "epss_percentile": 0.44359}, "CVE-2021-2001": {"epss_score": 0.00362, "epss_percentile": 0.57753}, "CVE-2021-2002": {"epss_score": 0.00145, "epss_percentile": 0.35426}, "CVE-2021-2003": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2021-2004": {"epss_score": 0.00197, "epss_percentile": 0.41896}, "CVE-2021-2005": {"epss_score": 0.00863, "epss_percentile": 0.74585}, "CVE-2021-2006": {"epss_score": 0.01115, "epss_percentile": 0.7771}, "CVE-2021-2007": {"epss_score": 0.00629, "epss_percentile": 0.6967}, "CVE-2021-2008": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2021-2009": {"epss_score": 0.00199, "epss_percentile": 0.42173}, "CVE-2021-2010": {"epss_score": 0.00364, "epss_percentile": 0.57942}, "CVE-2021-2011": {"epss_score": 0.02144, "epss_percentile": 0.83761}, "CVE-2021-2012": {"epss_score": 0.0034, "epss_percentile": 0.56282}, "CVE-2021-2013": {"epss_score": 0.00658, "epss_percentile": 0.70487}, "CVE-2021-2014": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2015": {"epss_score": 0.00961, "epss_percentile": 0.75976}, "CVE-2021-2016": {"epss_score": 0.00354, "epss_percentile": 0.57225}, "CVE-2021-2017": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2021-2018": {"epss_score": 0.01344, "epss_percentile": 0.79615}, "CVE-2021-2019": {"epss_score": 0.00281, "epss_percentile": 0.51114}, "CVE-2021-2020": {"epss_score": 0.01766, "epss_percentile": 0.82169}, "CVE-2021-2021": {"epss_score": 0.51799, "epss_percentile": 0.97798}, "CVE-2021-2022": {"epss_score": 0.004, "epss_percentile": 0.60188}, "CVE-2021-2023": {"epss_score": 0.00656, "epss_percentile": 0.70453}, "CVE-2021-2024": {"epss_score": 0.00637, "epss_percentile": 0.69892}, "CVE-2021-2025": {"epss_score": 0.01089, "epss_percentile": 0.77446}, "CVE-2021-2026": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2027": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2028": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2029": {"epss_score": 0.01905, "epss_percentile": 0.82792}, "CVE-2021-2030": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2031": {"epss_score": 0.00109, "epss_percentile": 0.29915}, "CVE-2021-2032": {"epss_score": 0.00255, "epss_percentile": 0.48664}, "CVE-2021-2033": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2021-2034": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2035": {"epss_score": 0.01769, "epss_percentile": 0.82189}, "CVE-2021-2036": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2038": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2039": {"epss_score": 0.00539, "epss_percentile": 0.66976}, "CVE-2021-2040": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2021-2041": {"epss_score": 0.01231, "epss_percentile": 0.78729}, "CVE-2021-2042": {"epss_score": 0.00101, "epss_percentile": 0.28675}, "CVE-2021-2043": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2021-2044": {"epss_score": 0.00573, "epss_percentile": 0.68055}, "CVE-2021-2045": {"epss_score": 0.00314, "epss_percentile": 0.54136}, "CVE-2021-2046": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2047": {"epss_score": 0.26765, "epss_percentile": 0.96177}, "CVE-2021-2048": {"epss_score": 0.00124, "epss_percentile": 0.32412}, "CVE-2021-2049": {"epss_score": 0.00658, "epss_percentile": 0.70487}, "CVE-2021-2050": {"epss_score": 0.00658, "epss_percentile": 0.70487}, "CVE-2021-2051": {"epss_score": 0.00658, "epss_percentile": 0.70487}, "CVE-2021-2052": {"epss_score": 0.00568, "epss_percentile": 0.67891}, "CVE-2021-2053": {"epss_score": 0.00298, "epss_percentile": 0.52826}, "CVE-2021-2054": {"epss_score": 0.01689, "epss_percentile": 0.81768}, "CVE-2021-2055": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2056": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2057": {"epss_score": 0.00266, "epss_percentile": 0.49908}, "CVE-2021-2058": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2059": {"epss_score": 0.00941, "epss_percentile": 0.75754}, "CVE-2021-2060": {"epss_score": 0.00206, "epss_percentile": 0.42779}, "CVE-2021-2061": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2062": {"epss_score": 0.00539, "epss_percentile": 0.66976}, "CVE-2021-2063": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2021-2064": {"epss_score": 0.29688, "epss_percentile": 0.96466}, "CVE-2021-2065": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2066": {"epss_score": 0.01075, "epss_percentile": 0.77316}, "CVE-2021-2067": {"epss_score": 0.01075, "epss_percentile": 0.77316}, "CVE-2021-2068": {"epss_score": 0.01075, "epss_percentile": 0.77316}, "CVE-2021-2069": {"epss_score": 0.01075, "epss_percentile": 0.77316}, "CVE-2021-2070": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2071": {"epss_score": 0.01231, "epss_percentile": 0.78729}, "CVE-2021-2072": {"epss_score": 0.0034, "epss_percentile": 0.56282}, "CVE-2021-2073": {"epss_score": 0.00196, "epss_percentile": 0.4173}, "CVE-2021-2074": {"epss_score": 0.00166, "epss_percentile": 0.38143}, "CVE-2021-2075": {"epss_score": 0.29688, "epss_percentile": 0.96466}, "CVE-2021-2076": {"epss_score": 0.0034, "epss_percentile": 0.56282}, "CVE-2021-2077": {"epss_score": 0.01595, "epss_percentile": 0.81236}, "CVE-2021-2078": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2079": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2080": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2081": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2082": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2083": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2084": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2085": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2086": {"epss_score": 0.00187, "epss_percentile": 0.40802}, "CVE-2021-2087": {"epss_score": 0.00091, "epss_percentile": 0.26267}, "CVE-2021-2088": {"epss_score": 0.00091, "epss_percentile": 0.26267}, "CVE-2021-2089": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2090": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2091": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2092": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2093": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2094": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2096": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2097": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2098": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2099": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2100": {"epss_score": 0.01723, "epss_percentile": 0.81944}, "CVE-2021-2101": {"epss_score": 0.01723, "epss_percentile": 0.81944}, "CVE-2021-2102": {"epss_score": 0.01595, "epss_percentile": 0.81236}, "CVE-2021-2103": {"epss_score": 0.01595, "epss_percentile": 0.81236}, "CVE-2021-2104": {"epss_score": 0.01595, "epss_percentile": 0.81236}, "CVE-2021-2105": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2106": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2107": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2108": {"epss_score": 0.26765, "epss_percentile": 0.96177}, "CVE-2021-2109": {"epss_score": 0.93246, "epss_percentile": 0.99788}, "CVE-2021-2110": {"epss_score": 0.00197, "epss_percentile": 0.41896}, "CVE-2021-2111": {"epss_score": 0.00162, "epss_percentile": 0.37641}, "CVE-2021-2112": {"epss_score": 0.00162, "epss_percentile": 0.37641}, "CVE-2021-2113": {"epss_score": 0.00201, "epss_percentile": 0.42321}, "CVE-2021-2114": {"epss_score": 0.09088, "epss_percentile": 0.92396}, "CVE-2021-2115": {"epss_score": 0.00539, "epss_percentile": 0.66976}, "CVE-2021-2116": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2021-2117": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2021-2118": {"epss_score": 0.01691, "epss_percentile": 0.81788}, "CVE-2021-2119": {"epss_score": 0.03803, "epss_percentile": 0.87747}, "CVE-2021-2120": {"epss_score": 0.00158, "epss_percentile": 0.37182}, "CVE-2021-2121": {"epss_score": 0.00166, "epss_percentile": 0.38246}, "CVE-2021-2122": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2021-2123": {"epss_score": 0.00048, "epss_percentile": 0.15113}, "CVE-2021-2124": {"epss_score": 0.00187, "epss_percentile": 0.40802}, "CVE-2021-2125": {"epss_score": 0.0012, "epss_percentile": 0.31788}, "CVE-2021-2126": {"epss_score": 0.00154, "epss_percentile": 0.36645}, "CVE-2021-2127": {"epss_score": 0.00196, "epss_percentile": 0.4173}, "CVE-2021-2128": {"epss_score": 0.00167, "epss_percentile": 0.38355}, "CVE-2021-2129": {"epss_score": 0.00135, "epss_percentile": 0.33996}, "CVE-2021-2130": {"epss_score": 0.00174, "epss_percentile": 0.39146}, "CVE-2021-2131": {"epss_score": 0.00305, "epss_percentile": 0.53374}, "CVE-2021-2134": {"epss_score": 0.0037, "epss_percentile": 0.58326}, "CVE-2021-2135": {"epss_score": 0.71821, "epss_percentile": 0.98682}, "CVE-2021-2136": {"epss_score": 0.04797, "epss_percentile": 0.89155}, "CVE-2021-2137": {"epss_score": 0.01769, "epss_percentile": 0.82189}, "CVE-2021-2138": {"epss_score": 0.00062, "epss_percentile": 0.19766}, "CVE-2021-2140": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2021-2141": {"epss_score": 0.00196, "epss_percentile": 0.41789}, "CVE-2021-2142": {"epss_score": 0.00601, "epss_percentile": 0.68859}, "CVE-2021-2144": {"epss_score": 0.02342, "epss_percentile": 0.8444}, "CVE-2021-2145": {"epss_score": 0.003, "epss_percentile": 0.52922}, "CVE-2021-2146": {"epss_score": 0.01728, "epss_percentile": 0.81974}, "CVE-2021-2147": {"epss_score": 0.00076, "epss_percentile": 0.23142}, "CVE-2021-2149": {"epss_score": 0.00121, "epss_percentile": 0.32007}, "CVE-2021-2150": {"epss_score": 0.02151, "epss_percentile": 0.83787}, "CVE-2021-2151": {"epss_score": 0.00366, "epss_percentile": 0.58072}, "CVE-2021-2152": {"epss_score": 0.00236, "epss_percentile": 0.46384}, "CVE-2021-2153": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2021-2154": {"epss_score": 0.0017, "epss_percentile": 0.38712}, "CVE-2021-2155": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2021-2156": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2157": {"epss_score": 0.04792, "epss_percentile": 0.89152}, "CVE-2021-2158": {"epss_score": 0.00188, "epss_percentile": 0.4089}, "CVE-2021-2159": {"epss_score": 0.00188, "epss_percentile": 0.4083}, "CVE-2021-2160": {"epss_score": 0.00244, "epss_percentile": 0.47574}, "CVE-2021-2161": {"epss_score": 0.00342, "epss_percentile": 0.56382}, "CVE-2021-2162": {"epss_score": 0.00627, "epss_percentile": 0.69643}, "CVE-2021-2163": {"epss_score": 0.00097, "epss_percentile": 0.27599}, "CVE-2021-2164": {"epss_score": 0.01233, "epss_percentile": 0.78748}, "CVE-2021-2166": {"epss_score": 0.01063, "epss_percentile": 0.77191}, "CVE-2021-2167": {"epss_score": 0.00051, "epss_percentile": 0.16314}, "CVE-2021-2169": {"epss_score": 0.01728, "epss_percentile": 0.81974}, "CVE-2021-2170": {"epss_score": 0.01233, "epss_percentile": 0.78748}, "CVE-2021-2171": {"epss_score": 0.00962, "epss_percentile": 0.75985}, "CVE-2021-2172": {"epss_score": 0.01342, "epss_percentile": 0.79593}, "CVE-2021-2173": {"epss_score": 0.00459, "epss_percentile": 0.63453}, "CVE-2021-2174": {"epss_score": 0.00962, "epss_percentile": 0.75985}, "CVE-2021-2175": {"epss_score": 0.00429, "epss_percentile": 0.61983}, "CVE-2021-2177": {"epss_score": 0.03968, "epss_percentile": 0.88033}, "CVE-2021-2178": {"epss_score": 0.01365, "epss_percentile": 0.79776}, "CVE-2021-2179": {"epss_score": 0.01728, "epss_percentile": 0.81974}, "CVE-2021-2180": {"epss_score": 0.00764, "epss_percentile": 0.72905}, "CVE-2021-2181": {"epss_score": 0.00472, "epss_percentile": 0.64054}, "CVE-2021-2182": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2183": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2184": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2185": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2186": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2187": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2188": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2189": {"epss_score": 0.01639, "epss_percentile": 0.81491}, "CVE-2021-2190": {"epss_score": 0.02235, "epss_percentile": 0.841}, "CVE-2021-2191": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2021-2192": {"epss_score": 0.00053, "epss_percentile": 0.169}, "CVE-2021-2193": {"epss_score": 0.01233, "epss_percentile": 0.78748}, "CVE-2021-2194": {"epss_score": 0.00173, "epss_percentile": 0.3904}, "CVE-2021-2195": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2196": {"epss_score": 0.01233, "epss_percentile": 0.78748}, "CVE-2021-2197": {"epss_score": 0.02105, "epss_percentile": 0.83623}, "CVE-2021-2198": {"epss_score": 0.031, "epss_percentile": 0.86408}, "CVE-2021-2199": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2200": {"epss_score": 0.01723, "epss_percentile": 0.81944}, "CVE-2021-2201": {"epss_score": 0.00989, "epss_percentile": 0.76372}, "CVE-2021-2202": {"epss_score": 0.00722, "epss_percentile": 0.71991}, "CVE-2021-2203": {"epss_score": 0.00989, "epss_percentile": 0.76372}, "CVE-2021-2204": {"epss_score": 0.0135, "epss_percentile": 0.79673}, "CVE-2021-2205": {"epss_score": 0.02147, "epss_percentile": 0.83767}, "CVE-2021-2206": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2207": {"epss_score": 0.00116, "epss_percentile": 0.31189}, "CVE-2021-2208": {"epss_score": 0.00989, "epss_percentile": 0.76372}, "CVE-2021-2209": {"epss_score": 0.0046, "epss_percentile": 0.63523}, "CVE-2021-2210": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2211": {"epss_score": 0.02594, "epss_percentile": 0.8519}, "CVE-2021-2212": {"epss_score": 0.00989, "epss_percentile": 0.76372}, "CVE-2021-2213": {"epss_score": 0.00649, "epss_percentile": 0.70234}, "CVE-2021-2214": {"epss_score": 0.00539, "epss_percentile": 0.66983}, "CVE-2021-2215": {"epss_score": 0.00989, "epss_percentile": 0.76372}, "CVE-2021-2216": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2021-2217": {"epss_score": 0.00989, "epss_percentile": 0.76372}, "CVE-2021-2218": {"epss_score": 0.00605, "epss_percentile": 0.68971}, "CVE-2021-2219": {"epss_score": 0.00207, "epss_percentile": 0.43156}, "CVE-2021-2220": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2021-2221": {"epss_score": 0.02292, "epss_percentile": 0.84286}, "CVE-2021-2222": {"epss_score": 0.01489, "epss_percentile": 0.80622}, "CVE-2021-2223": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2224": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2225": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2226": {"epss_score": 0.01687, "epss_percentile": 0.81755}, "CVE-2021-2227": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2228": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2229": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2230": {"epss_score": 0.00989, "epss_percentile": 0.76372}, "CVE-2021-2231": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2232": {"epss_score": 0.00115, "epss_percentile": 0.30909}, "CVE-2021-2233": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2234": {"epss_score": 0.0022, "epss_percentile": 0.44568}, "CVE-2021-2235": {"epss_score": 0.02465, "epss_percentile": 0.84834}, "CVE-2021-2236": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2237": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2238": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2239": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2240": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2021-2241": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2242": {"epss_score": 0.00788, "epss_percentile": 0.73337}, "CVE-2021-2244": {"epss_score": 0.02067, "epss_percentile": 0.83461}, "CVE-2021-2245": {"epss_score": 0.00206, "epss_percentile": 0.42999}, "CVE-2021-2246": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2247": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2248": {"epss_score": 0.03968, "epss_percentile": 0.88033}, "CVE-2021-2249": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2250": {"epss_score": 0.0015, "epss_percentile": 0.36047}, "CVE-2021-2251": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2252": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2253": {"epss_score": 0.01723, "epss_percentile": 0.81944}, "CVE-2021-2254": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2255": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2256": {"epss_score": 0.02228, "epss_percentile": 0.84078}, "CVE-2021-2257": {"epss_score": 0.00202, "epss_percentile": 0.42455}, "CVE-2021-2258": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2259": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2260": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2261": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2262": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2263": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2264": {"epss_score": 0.00113, "epss_percentile": 0.30619}, "CVE-2021-2266": {"epss_score": 0.00072, "epss_percentile": 0.22417}, "CVE-2021-2267": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2268": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2269": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2270": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2271": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2272": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2273": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2274": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2275": {"epss_score": 0.01252, "epss_percentile": 0.78905}, "CVE-2021-2276": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2277": {"epss_score": 0.02226, "epss_percentile": 0.84071}, "CVE-2021-2278": {"epss_score": 0.00989, "epss_percentile": 0.76372}, "CVE-2021-2279": {"epss_score": 0.07624, "epss_percentile": 0.91579}, "CVE-2021-2280": {"epss_score": 0.00154, "epss_percentile": 0.36709}, "CVE-2021-2281": {"epss_score": 0.00171, "epss_percentile": 0.38899}, "CVE-2021-2282": {"epss_score": 0.00154, "epss_percentile": 0.36709}, "CVE-2021-2283": {"epss_score": 0.00182, "epss_percentile": 0.40271}, "CVE-2021-2284": {"epss_score": 0.00169, "epss_percentile": 0.38609}, "CVE-2021-2285": {"epss_score": 0.00182, "epss_percentile": 0.40271}, "CVE-2021-2286": {"epss_score": 0.00169, "epss_percentile": 0.38609}, "CVE-2021-2287": {"epss_score": 0.00182, "epss_percentile": 0.40271}, "CVE-2021-2288": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2289": {"epss_score": 0.01669, "epss_percentile": 0.81663}, "CVE-2021-2290": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2291": {"epss_score": 0.00112, "epss_percentile": 0.30539}, "CVE-2021-2292": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2293": {"epss_score": 0.00989, "epss_percentile": 0.76372}, "CVE-2021-2294": {"epss_score": 0.01384, "epss_percentile": 0.79898}, "CVE-2021-2295": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2296": {"epss_score": 0.00092, "epss_percentile": 0.2653}, "CVE-2021-2297": {"epss_score": 0.00092, "epss_percentile": 0.2653}, "CVE-2021-2298": {"epss_score": 0.01077, "epss_percentile": 0.77332}, "CVE-2021-2299": {"epss_score": 0.00311, "epss_percentile": 0.53869}, "CVE-2021-2300": {"epss_score": 0.00311, "epss_percentile": 0.53869}, "CVE-2021-2301": {"epss_score": 0.00318, "epss_percentile": 0.54456}, "CVE-2021-2302": {"epss_score": 0.52528, "epss_percentile": 0.9783}, "CVE-2021-2303": {"epss_score": 0.00838, "epss_percentile": 0.74176}, "CVE-2021-2304": {"epss_score": 0.00287, "epss_percentile": 0.51789}, "CVE-2021-2305": {"epss_score": 0.00311, "epss_percentile": 0.53869}, "CVE-2021-2306": {"epss_score": 0.00065, "epss_percentile": 0.20569}, "CVE-2021-2307": {"epss_score": 0.00448, "epss_percentile": 0.62999}, "CVE-2021-2308": {"epss_score": 0.0015, "epss_percentile": 0.36125}, "CVE-2021-2309": {"epss_score": 0.00093, "epss_percentile": 0.26735}, "CVE-2021-2310": {"epss_score": 0.00231, "epss_percentile": 0.45797}, "CVE-2021-2311": {"epss_score": 0.00517, "epss_percentile": 0.66065}, "CVE-2021-2312": {"epss_score": 0.00059, "epss_percentile": 0.18872}, "CVE-2021-2314": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2315": {"epss_score": 0.00601, "epss_percentile": 0.68859}, "CVE-2021-2316": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2317": {"epss_score": 0.0209, "epss_percentile": 0.83568}, "CVE-2021-2318": {"epss_score": 0.01647, "epss_percentile": 0.81541}, "CVE-2021-2319": {"epss_score": 0.01226, "epss_percentile": 0.78691}, "CVE-2021-2320": {"epss_score": 0.01226, "epss_percentile": 0.78691}, "CVE-2021-2321": {"epss_score": 0.00158, "epss_percentile": 0.37196}, "CVE-2021-2322": {"epss_score": 0.00926, "epss_percentile": 0.75547}, "CVE-2021-2323": {"epss_score": 0.0146, "epss_percentile": 0.8042}, "CVE-2021-2324": {"epss_score": 0.0023, "epss_percentile": 0.45688}, "CVE-2021-2326": {"epss_score": 0.00182, "epss_percentile": 0.40233}, "CVE-2021-2328": {"epss_score": 0.01406, "epss_percentile": 0.8005}, "CVE-2021-2329": {"epss_score": 0.01406, "epss_percentile": 0.8005}, "CVE-2021-2330": {"epss_score": 0.00314, "epss_percentile": 0.54136}, "CVE-2021-2332": {"epss_score": 0.00288, "epss_percentile": 0.51887}, "CVE-2021-2333": {"epss_score": 0.00588, "epss_percentile": 0.68493}, "CVE-2021-2334": {"epss_score": 0.00212, "epss_percentile": 0.43798}, "CVE-2021-2335": {"epss_score": 0.00212, "epss_percentile": 0.43798}, "CVE-2021-2336": {"epss_score": 0.00292, "epss_percentile": 0.5226}, "CVE-2021-2337": {"epss_score": 0.01647, "epss_percentile": 0.81541}, "CVE-2021-2338": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2021-2339": {"epss_score": 0.00195, "epss_percentile": 0.41603}, "CVE-2021-2340": {"epss_score": 0.00152, "epss_percentile": 0.3644}, "CVE-2021-2341": {"epss_score": 0.00321, "epss_percentile": 0.54688}, "CVE-2021-2342": {"epss_score": 0.0044, "epss_percentile": 0.62625}, "CVE-2021-2343": {"epss_score": 0.00178, "epss_percentile": 0.39638}, "CVE-2021-2344": {"epss_score": 0.01639, "epss_percentile": 0.81491}, "CVE-2021-2345": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2021-2346": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2021-2347": {"epss_score": 0.00553, "epss_percentile": 0.67416}, "CVE-2021-2348": {"epss_score": 0.00197, "epss_percentile": 0.41896}, "CVE-2021-2349": {"epss_score": 0.01651, "epss_percentile": 0.81566}, "CVE-2021-2350": {"epss_score": 0.02226, "epss_percentile": 0.84071}, "CVE-2021-2351": {"epss_score": 0.02948, "epss_percentile": 0.86048}, "CVE-2021-2352": {"epss_score": 0.00195, "epss_percentile": 0.41603}, "CVE-2021-2353": {"epss_score": 0.00187, "epss_percentile": 0.40767}, "CVE-2021-2354": {"epss_score": 0.00361, "epss_percentile": 0.57695}, "CVE-2021-2355": {"epss_score": 0.01723, "epss_percentile": 0.81944}, "CVE-2021-2356": {"epss_score": 0.00243, "epss_percentile": 0.475}, "CVE-2021-2357": {"epss_score": 0.00385, "epss_percentile": 0.59233}, "CVE-2021-2358": {"epss_score": 0.00588, "epss_percentile": 0.68493}, "CVE-2021-2359": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2360": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2361": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2362": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2363": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2364": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2365": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2366": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2021-2367": {"epss_score": 0.0044, "epss_percentile": 0.62625}, "CVE-2021-2368": {"epss_score": 0.01087, "epss_percentile": 0.77428}, "CVE-2021-2369": {"epss_score": 0.00324, "epss_percentile": 0.54949}, "CVE-2021-2370": {"epss_score": 0.0044, "epss_percentile": 0.62625}, "CVE-2021-2371": {"epss_score": 0.01399, "epss_percentile": 0.79996}, "CVE-2021-2372": {"epss_score": 0.00243, "epss_percentile": 0.47479}, "CVE-2021-2373": {"epss_score": 0.00167, "epss_percentile": 0.38338}, "CVE-2021-2374": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2021-2375": {"epss_score": 0.00601, "epss_percentile": 0.68859}, "CVE-2021-2376": {"epss_score": 0.02434, "epss_percentile": 0.84734}, "CVE-2021-2377": {"epss_score": 0.00178, "epss_percentile": 0.39638}, "CVE-2021-2378": {"epss_score": 0.01874, "epss_percentile": 0.82652}, "CVE-2021-2380": {"epss_score": 0.00486, "epss_percentile": 0.64754}, "CVE-2021-2381": {"epss_score": 0.00081, "epss_percentile": 0.24281}, "CVE-2021-2382": {"epss_score": 0.02317, "epss_percentile": 0.8436}, "CVE-2021-2383": {"epss_score": 0.0044, "epss_percentile": 0.62625}, "CVE-2021-2384": {"epss_score": 0.0044, "epss_percentile": 0.62625}, "CVE-2021-2385": {"epss_score": 0.00396, "epss_percentile": 0.59925}, "CVE-2021-2386": {"epss_score": 0.00163, "epss_percentile": 0.37784}, "CVE-2021-2387": {"epss_score": 0.00266, "epss_percentile": 0.49923}, "CVE-2021-2388": {"epss_score": 0.00694, "epss_percentile": 0.71345}, "CVE-2021-2389": {"epss_score": 0.00508, "epss_percentile": 0.65712}, "CVE-2021-2390": {"epss_score": 0.02184, "epss_percentile": 0.83913}, "CVE-2021-2391": {"epss_score": 0.04753, "epss_percentile": 0.89107}, "CVE-2021-2392": {"epss_score": 0.03518, "epss_percentile": 0.87281}, "CVE-2021-2393": {"epss_score": 0.01426, "epss_percentile": 0.80203}, "CVE-2021-2394": {"epss_score": 0.90228, "epss_percentile": 0.9957}, "CVE-2021-2395": {"epss_score": 0.01426, "epss_percentile": 0.80203}, "CVE-2021-2396": {"epss_score": 0.03666, "epss_percentile": 0.87533}, "CVE-2021-2397": {"epss_score": 0.02317, "epss_percentile": 0.8436}, "CVE-2021-2398": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2399": {"epss_score": 0.00266, "epss_percentile": 0.49923}, "CVE-2021-2400": {"epss_score": 0.07274, "epss_percentile": 0.91377}, "CVE-2021-2401": {"epss_score": 0.02962, "epss_percentile": 0.86073}, "CVE-2021-2402": {"epss_score": 0.00266, "epss_percentile": 0.49923}, "CVE-2021-2403": {"epss_score": 0.01823, "epss_percentile": 0.82417}, "CVE-2021-2404": {"epss_score": 0.00551, "epss_percentile": 0.67377}, "CVE-2021-2405": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2406": {"epss_score": 0.00902, "epss_percentile": 0.75185}, "CVE-2021-2407": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2021-2408": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2021-2409": {"epss_score": 0.00103, "epss_percentile": 0.29059}, "CVE-2021-2410": {"epss_score": 0.00266, "epss_percentile": 0.49923}, "CVE-2021-2411": {"epss_score": 0.00905, "epss_percentile": 0.75232}, "CVE-2021-2412": {"epss_score": 0.00266, "epss_percentile": 0.49923}, "CVE-2021-2414": {"epss_score": 0.00411, "epss_percentile": 0.60848}, "CVE-2021-2415": {"epss_score": 0.01426, "epss_percentile": 0.80203}, "CVE-2021-2416": {"epss_score": 0.00213, "epss_percentile": 0.43943}, "CVE-2021-2417": {"epss_score": 0.00091, "epss_percentile": 0.26244}, "CVE-2021-2418": {"epss_score": 0.00266, "epss_percentile": 0.49923}, "CVE-2021-2419": {"epss_score": 0.01034, "epss_percentile": 0.7689}, "CVE-2021-2420": {"epss_score": 0.01034, "epss_percentile": 0.7689}, "CVE-2021-2421": {"epss_score": 0.00361, "epss_percentile": 0.57702}, "CVE-2021-2422": {"epss_score": 0.00193, "epss_percentile": 0.41401}, "CVE-2021-2423": {"epss_score": 0.01399, "epss_percentile": 0.79996}, "CVE-2021-2424": {"epss_score": 0.00266, "epss_percentile": 0.49923}, "CVE-2021-2425": {"epss_score": 0.00266, "epss_percentile": 0.49923}, "CVE-2021-2426": {"epss_score": 0.00311, "epss_percentile": 0.53869}, "CVE-2021-2427": {"epss_score": 0.00311, "epss_percentile": 0.53869}, "CVE-2021-2428": {"epss_score": 0.01091, "epss_percentile": 0.77461}, "CVE-2021-2429": {"epss_score": 0.05389, "epss_percentile": 0.89823}, "CVE-2021-2430": {"epss_score": 0.01399, "epss_percentile": 0.79996}, "CVE-2021-2431": {"epss_score": 0.01399, "epss_percentile": 0.79996}, "CVE-2021-2432": {"epss_score": 0.00233, "epss_percentile": 0.4605}, "CVE-2021-2433": {"epss_score": 0.01705, "epss_percentile": 0.8185}, "CVE-2021-2434": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2021-2435": {"epss_score": 0.01818, "epss_percentile": 0.82402}, "CVE-2021-2436": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-2437": {"epss_score": 0.00266, "epss_percentile": 0.49923}, "CVE-2021-2438": {"epss_score": 0.00314, "epss_percentile": 0.54136}, "CVE-2021-2439": {"epss_score": 0.00814, "epss_percentile": 0.73768}, "CVE-2021-2440": {"epss_score": 0.00145, "epss_percentile": 0.35397}, "CVE-2021-2441": {"epss_score": 0.00266, "epss_percentile": 0.49923}, "CVE-2021-2442": {"epss_score": 0.00105, "epss_percentile": 0.29317}, "CVE-2021-2443": {"epss_score": 0.00053, "epss_percentile": 0.16714}, "CVE-2021-2444": {"epss_score": 0.00145, "epss_percentile": 0.35397}, "CVE-2021-2445": {"epss_score": 0.01321, "epss_percentile": 0.79447}, "CVE-2021-2446": {"epss_score": 0.01086, "epss_percentile": 0.77423}, "CVE-2021-2447": {"epss_score": 0.01769, "epss_percentile": 0.82189}, "CVE-2021-2448": {"epss_score": 0.00066, "epss_percentile": 0.2087}, "CVE-2021-2449": {"epss_score": 0.01034, "epss_percentile": 0.7689}, "CVE-2021-2450": {"epss_score": 0.01034, "epss_percentile": 0.7689}, "CVE-2021-2451": {"epss_score": 0.01034, "epss_percentile": 0.7689}, "CVE-2021-2452": {"epss_score": 0.01422, "epss_percentile": 0.80179}, "CVE-2021-2453": {"epss_score": 0.01422, "epss_percentile": 0.80179}, "CVE-2021-2454": {"epss_score": 0.00239, "epss_percentile": 0.46872}, "CVE-2021-2455": {"epss_score": 0.0138, "epss_percentile": 0.79859}, "CVE-2021-2456": {"epss_score": 0.73092, "epss_percentile": 0.98735}, "CVE-2021-2457": {"epss_score": 0.01686, "epss_percentile": 0.81754}, "CVE-2021-2458": {"epss_score": 0.00508, "epss_percentile": 0.65684}, "CVE-2021-2460": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2021-2461": {"epss_score": 0.00753, "epss_percentile": 0.72689}, "CVE-2021-2462": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2021-2463": {"epss_score": 0.01905, "epss_percentile": 0.82792}, "CVE-2021-2464": {"epss_score": 0.00064, "epss_percentile": 0.20106}, "CVE-2021-2471": {"epss_score": 0.65138, "epss_percentile": 0.98404}, "CVE-2021-2474": {"epss_score": 0.00863, "epss_percentile": 0.74585}, "CVE-2021-2475": {"epss_score": 0.00051, "epss_percentile": 0.16144}, "CVE-2021-2476": {"epss_score": 0.00462, "epss_percentile": 0.63618}, "CVE-2021-2477": {"epss_score": 0.0158, "epss_percentile": 0.81132}, "CVE-2021-2478": {"epss_score": 0.00534, "epss_percentile": 0.6679}, "CVE-2021-2479": {"epss_score": 0.00534, "epss_percentile": 0.6679}, "CVE-2021-2480": {"epss_score": 0.00553, "epss_percentile": 0.6743}, "CVE-2021-2481": {"epss_score": 0.00674, "epss_percentile": 0.70876}, "CVE-2021-2482": {"epss_score": 0.01168, "epss_percentile": 0.78194}, "CVE-2021-2483": {"epss_score": 0.01352, "epss_percentile": 0.79691}, "CVE-2021-2484": {"epss_score": 0.01352, "epss_percentile": 0.79691}, "CVE-2021-2485": {"epss_score": 0.01352, "epss_percentile": 0.79691}, "CVE-2021-30000": {"epss_score": 0.00613, "epss_percentile": 0.69246}, "CVE-2021-30002": {"epss_score": 0.0003, "epss_percentile": 0.08183}, "CVE-2021-30003": {"epss_score": 0.00212, "epss_percentile": 0.43759}, "CVE-2021-30004": {"epss_score": 0.00296, "epss_percentile": 0.52586}, "CVE-2021-30005": {"epss_score": 3e-05, "epss_percentile": 0.0009}, "CVE-2021-30006": {"epss_score": 3e-05, "epss_percentile": 0.00067}, "CVE-2021-30014": {"epss_score": 0.00097, "epss_percentile": 0.27613}, "CVE-2021-30015": {"epss_score": 0.00094, "epss_percentile": 0.27048}, "CVE-2021-30019": {"epss_score": 0.00108, "epss_percentile": 0.29771}, "CVE-2021-30020": {"epss_score": 0.00265, "epss_percentile": 0.49842}, "CVE-2021-30022": {"epss_score": 0.0009, "epss_percentile": 0.26079}, "CVE-2021-30027": {"epss_score": 0.00266, "epss_percentile": 0.4995}, "CVE-2021-30028": {"epss_score": 0.0034, "epss_percentile": 0.56268}, "CVE-2021-30030": {"epss_score": 0.00185, "epss_percentile": 0.40546}, "CVE-2021-30034": {"epss_score": 0.00148, "epss_percentile": 0.35818}, "CVE-2021-30039": {"epss_score": 0.00148, "epss_percentile": 0.35818}, "CVE-2021-30042": {"epss_score": 0.00148, "epss_percentile": 0.35818}, "CVE-2021-30044": {"epss_score": 0.00109, "epss_percentile": 0.29919}, "CVE-2021-30045": {"epss_score": 0.00611, "epss_percentile": 0.69188}, "CVE-2021-30046": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2021-30047": {"epss_score": 0.3126, "epss_percentile": 0.96604}, "CVE-2021-30048": {"epss_score": 0.01082, "epss_percentile": 0.77383}, "CVE-2021-30049": {"epss_score": 0.05184, "epss_percentile": 0.89586}, "CVE-2021-30055": {"epss_score": 0.00569, "epss_percentile": 0.67921}, "CVE-2021-30056": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-30057": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2021-30058": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2021-30061": {"epss_score": 8e-05, "epss_percentile": 0.0049}, "CVE-2021-30062": {"epss_score": 0.00035, "epss_percentile": 0.09827}, "CVE-2021-30063": {"epss_score": 0.00067, "epss_percentile": 0.21077}, "CVE-2021-30064": {"epss_score": 0.00057, "epss_percentile": 0.18232}, "CVE-2021-30065": {"epss_score": 0.0003, "epss_percentile": 0.08113}, "CVE-2021-30066": {"epss_score": 4e-05, "epss_percentile": 0.00131}, "CVE-2021-30070": {"epss_score": 0.00231, "epss_percentile": 0.4583}, "CVE-2021-30071": {"epss_score": 0.00228, "epss_percentile": 0.45462}, "CVE-2021-30072": {"epss_score": 0.00547, "epss_percentile": 0.6726}, "CVE-2021-30074": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-30080": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-30081": {"epss_score": 0.00239, "epss_percentile": 0.46936}, "CVE-2021-30082": {"epss_score": 0.00182, "epss_percentile": 0.40257}, "CVE-2021-30083": {"epss_score": 0.00164, "epss_percentile": 0.3789}, "CVE-2021-30086": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-30108": {"epss_score": 0.00223, "epss_percentile": 0.44942}, "CVE-2021-30109": {"epss_score": 0.00135, "epss_percentile": 0.34016}, "CVE-2021-30110": {"epss_score": 0.01523, "epss_percentile": 0.8084}, "CVE-2021-30111": {"epss_score": 0.0024, "epss_percentile": 0.47209}, "CVE-2021-30112": {"epss_score": 0.00139, "epss_percentile": 0.34657}, "CVE-2021-30113": {"epss_score": 0.00253, "epss_percentile": 0.48425}, "CVE-2021-30114": {"epss_score": 0.00137, "epss_percentile": 0.34228}, "CVE-2021-30116": {"epss_score": 0.4984, "epss_percentile": 0.97707}, "CVE-2021-30117": {"epss_score": 0.00622, "epss_percentile": 0.69506}, "CVE-2021-30118": {"epss_score": 0.56392, "epss_percentile": 0.9802}, "CVE-2021-30119": {"epss_score": 0.00191, "epss_percentile": 0.41216}, "CVE-2021-30120": {"epss_score": 0.00224, "epss_percentile": 0.4506}, "CVE-2021-30121": {"epss_score": 0.00373, "epss_percentile": 0.58504}, "CVE-2021-30123": {"epss_score": 0.03431, "epss_percentile": 0.87125}, "CVE-2021-30124": {"epss_score": 0.02739, "epss_percentile": 0.85557}, "CVE-2021-30125": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2021-30126": {"epss_score": 0.00207, "epss_percentile": 0.43185}, "CVE-2021-30127": {"epss_score": 0.00236, "epss_percentile": 0.46392}, "CVE-2021-30128": {"epss_score": 0.93353, "epss_percentile": 0.99799}, "CVE-2021-30129": {"epss_score": 0.00228, "epss_percentile": 0.45513}, "CVE-2021-30130": {"epss_score": 0.00229, "epss_percentile": 0.45649}, "CVE-2021-30132": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2021-30133": {"epss_score": 0.00233, "epss_percentile": 0.46057}, "CVE-2021-30134": {"epss_score": 0.03001, "epss_percentile": 0.86168}, "CVE-2021-30137": {"epss_score": 0.00161, "epss_percentile": 0.37534}, "CVE-2021-30139": {"epss_score": 0.00192, "epss_percentile": 0.41333}, "CVE-2021-30140": {"epss_score": 0.0125, "epss_percentile": 0.78876}, "CVE-2021-30141": {"epss_score": 0.00467, "epss_percentile": 0.63848}, "CVE-2021-30144": {"epss_score": 0.00124, "epss_percentile": 0.32354}, "CVE-2021-30145": {"epss_score": 0.03391, "epss_percentile": 0.8705}, "CVE-2021-30146": {"epss_score": 0.00482, "epss_percentile": 0.64536}, "CVE-2021-30147": {"epss_score": 0.00404, "epss_percentile": 0.6043}, "CVE-2021-30149": {"epss_score": 0.15517, "epss_percentile": 0.94444}, "CVE-2021-30150": {"epss_score": 0.00321, "epss_percentile": 0.5474}, "CVE-2021-30151": {"epss_score": 0.12475, "epss_percentile": 0.93684}, "CVE-2021-30152": {"epss_score": 0.00526, "epss_percentile": 0.66406}, "CVE-2021-30153": {"epss_score": 0.00184, "epss_percentile": 0.40424}, "CVE-2021-30154": {"epss_score": 0.01115, "epss_percentile": 0.77715}, "CVE-2021-30155": {"epss_score": 0.00447, "epss_percentile": 0.62968}, "CVE-2021-30156": {"epss_score": 0.00191, "epss_percentile": 0.41145}, "CVE-2021-30157": {"epss_score": 0.01006, "epss_percentile": 0.76557}, "CVE-2021-30158": {"epss_score": 0.00614, "epss_percentile": 0.69266}, "CVE-2021-30159": {"epss_score": 0.00866, "epss_percentile": 0.74634}, "CVE-2021-30161": {"epss_score": 0.00018, "epss_percentile": 0.03704}, "CVE-2021-30162": {"epss_score": 0.00017, "epss_percentile": 0.03252}, "CVE-2021-30163": {"epss_score": 0.00495, "epss_percentile": 0.65116}, "CVE-2021-30164": {"epss_score": 0.00209, "epss_percentile": 0.43397}, "CVE-2021-30165": {"epss_score": 0.0029, "epss_percentile": 0.52135}, "CVE-2021-30166": {"epss_score": 0.07536, "epss_percentile": 0.91522}, "CVE-2021-30167": {"epss_score": 0.03556, "epss_percentile": 0.87348}, "CVE-2021-30168": {"epss_score": 0.0182, "epss_percentile": 0.82408}, "CVE-2021-30169": {"epss_score": 0.00952, "epss_percentile": 0.75879}, "CVE-2021-30170": {"epss_score": 0.00275, "epss_percentile": 0.5064}, "CVE-2021-30171": {"epss_score": 0.00275, "epss_percentile": 0.5064}, "CVE-2021-30172": {"epss_score": 0.00254, "epss_percentile": 0.4851}, "CVE-2021-30173": {"epss_score": 0.00331, "epss_percentile": 0.55536}, "CVE-2021-30174": {"epss_score": 0.00169, "epss_percentile": 0.38638}, "CVE-2021-30175": {"epss_score": 0.7447, "epss_percentile": 0.98801}, "CVE-2021-30176": {"epss_score": 0.01913, "epss_percentile": 0.82837}, "CVE-2021-30177": {"epss_score": 0.01184, "epss_percentile": 0.78334}, "CVE-2021-30178": {"epss_score": 0.00114, "epss_percentile": 0.30808}, "CVE-2021-30179": {"epss_score": 0.03582, "epss_percentile": 0.87387}, "CVE-2021-30180": {"epss_score": 0.0369, "epss_percentile": 0.87575}, "CVE-2021-30181": {"epss_score": 0.03871, "epss_percentile": 0.87881}, "CVE-2021-30183": {"epss_score": 0.00156, "epss_percentile": 0.36902}, "CVE-2021-30184": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2021-30185": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2021-30186": {"epss_score": 0.00453, "epss_percentile": 0.63202}, "CVE-2021-30187": {"epss_score": 0.00117, "epss_percentile": 0.31235}, "CVE-2021-30188": {"epss_score": 0.0057, "epss_percentile": 0.67948}, "CVE-2021-30189": {"epss_score": 0.0057, "epss_percentile": 0.67948}, "CVE-2021-30190": {"epss_score": 0.00428, "epss_percentile": 0.61936}, "CVE-2021-30191": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2021-30192": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2021-30193": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2021-30194": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2021-30195": {"epss_score": 0.00419, "epss_percentile": 0.61391}, "CVE-2021-30199": {"epss_score": 0.00094, "epss_percentile": 0.27048}, "CVE-2021-30201": {"epss_score": 0.00329, "epss_percentile": 0.55306}, "CVE-2021-30203": {"epss_score": 0.01296, "epss_percentile": 0.79255}, "CVE-2021-30205": {"epss_score": 0.00133, "epss_percentile": 0.33742}, "CVE-2021-30209": {"epss_score": 0.00146, "epss_percentile": 0.3557}, "CVE-2021-30211": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-30212": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-30213": {"epss_score": 0.02977, "epss_percentile": 0.86107}, "CVE-2021-30214": {"epss_score": 0.01583, "epss_percentile": 0.81151}, "CVE-2021-30218": {"epss_score": 0.00266, "epss_percentile": 0.49917}, "CVE-2021-30219": {"epss_score": 0.00266, "epss_percentile": 0.49917}, "CVE-2021-30224": {"epss_score": 0.00113, "epss_percentile": 0.30596}, "CVE-2021-30227": {"epss_score": 0.00214, "epss_percentile": 0.43978}, "CVE-2021-30228": {"epss_score": 0.03192, "epss_percentile": 0.86604}, "CVE-2021-30229": {"epss_score": 0.03117, "epss_percentile": 0.86437}, "CVE-2021-30230": {"epss_score": 0.03192, "epss_percentile": 0.86604}, "CVE-2021-30231": {"epss_score": 0.03192, "epss_percentile": 0.86604}, "CVE-2021-30232": {"epss_score": 0.03192, "epss_percentile": 0.86604}, "CVE-2021-30233": {"epss_score": 0.03192, "epss_percentile": 0.86604}, "CVE-2021-30234": {"epss_score": 0.03192, "epss_percentile": 0.86604}, "CVE-2021-30245": {"epss_score": 0.00402, "epss_percentile": 0.60295}, "CVE-2021-30246": {"epss_score": 0.002, "epss_percentile": 0.42266}, "CVE-2021-30254": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-30255": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-30256": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-30257": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2021-30258": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-30259": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2021-30260": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2021-30261": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-30262": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2021-30263": {"epss_score": 0.0004, "epss_percentile": 0.12016}, "CVE-2021-30264": {"epss_score": 0.00048, "epss_percentile": 0.15198}, "CVE-2021-30265": {"epss_score": 0.00055, "epss_percentile": 0.17522}, "CVE-2021-30266": {"epss_score": 0.00048, "epss_percentile": 0.15198}, "CVE-2021-30267": {"epss_score": 0.00054, "epss_percentile": 0.1724}, "CVE-2021-30268": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2021-30269": {"epss_score": 0.00031, "epss_percentile": 0.08698}, "CVE-2021-30270": {"epss_score": 0.00031, "epss_percentile": 0.08698}, "CVE-2021-30271": {"epss_score": 0.00031, "epss_percentile": 0.08698}, "CVE-2021-30272": {"epss_score": 0.00031, "epss_percentile": 0.08698}, "CVE-2021-30273": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2021-30274": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2021-30275": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2021-30276": {"epss_score": 0.00029, "epss_percentile": 0.07759}, "CVE-2021-30278": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2021-30279": {"epss_score": 0.00028, "epss_percentile": 0.07525}, "CVE-2021-30281": {"epss_score": 0.00026, "epss_percentile": 0.06458}, "CVE-2021-30282": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2021-30283": {"epss_score": 0.00044, "epss_percentile": 0.13513}, "CVE-2021-30284": {"epss_score": 0.0027, "epss_percentile": 0.50245}, "CVE-2021-30285": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2021-30287": {"epss_score": 0.00359, "epss_percentile": 0.5755}, "CVE-2021-30288": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-30289": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-30290": {"epss_score": 0.00033, "epss_percentile": 0.09339}, "CVE-2021-30291": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2021-30292": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2021-30293": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2021-30294": {"epss_score": 0.00033, "epss_percentile": 0.09283}, "CVE-2021-30295": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-30297": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2021-30298": {"epss_score": 0.0004, "epss_percentile": 0.12016}, "CVE-2021-30299": {"epss_score": 0.00018, "epss_percentile": 0.04014}, "CVE-2021-30300": {"epss_score": 0.00359, "epss_percentile": 0.5755}, "CVE-2021-30301": {"epss_score": 0.00359, "epss_percentile": 0.5755}, "CVE-2021-30302": {"epss_score": 0.00228, "epss_percentile": 0.45526}, "CVE-2021-30303": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-30304": {"epss_score": 0.0037, "epss_percentile": 0.58306}, "CVE-2021-30305": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2021-30306": {"epss_score": 0.00043, "epss_percentile": 0.13054}, "CVE-2021-30307": {"epss_score": 0.00359, "epss_percentile": 0.5755}, "CVE-2021-30308": {"epss_score": 0.00105, "epss_percentile": 0.29293}, "CVE-2021-30309": {"epss_score": 0.0005, "epss_percentile": 0.15934}, "CVE-2021-30310": {"epss_score": 0.0028, "epss_percentile": 0.51089}, "CVE-2021-30311": {"epss_score": 0.00105, "epss_percentile": 0.29293}, "CVE-2021-30312": {"epss_score": 0.00186, "epss_percentile": 0.40663}, "CVE-2021-30313": {"epss_score": 0.00076, "epss_percentile": 0.23162}, "CVE-2021-30314": {"epss_score": 0.00096, "epss_percentile": 0.27304}, "CVE-2021-30315": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2021-30316": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2021-30317": {"epss_score": 0.00041, "epss_percentile": 0.12295}, "CVE-2021-30318": {"epss_score": 0.0012, "epss_percentile": 0.31783}, "CVE-2021-30319": {"epss_score": 0.00101, "epss_percentile": 0.2868}, "CVE-2021-30321": {"epss_score": 0.00271, "epss_percentile": 0.50331}, "CVE-2021-30322": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2021-30323": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2021-30324": {"epss_score": 0.00047, "epss_percentile": 0.14627}, "CVE-2021-30325": {"epss_score": 0.00047, "epss_percentile": 0.14627}, "CVE-2021-30326": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2021-30327": {"epss_score": 0.00034, "epss_percentile": 0.09805}, "CVE-2021-30328": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2021-30329": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2021-30330": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2021-30331": {"epss_score": 0.00047, "epss_percentile": 0.14796}, "CVE-2021-30332": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2021-30333": {"epss_score": 0.0012, "epss_percentile": 0.31783}, "CVE-2021-30334": {"epss_score": 0.00089, "epss_percentile": 0.25915}, "CVE-2021-30335": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2021-30336": {"epss_score": 0.00033, "epss_percentile": 0.09278}, "CVE-2021-30337": {"epss_score": 0.00037, "epss_percentile": 0.10761}, "CVE-2021-30338": {"epss_score": 0.00039, "epss_percentile": 0.11442}, "CVE-2021-30339": {"epss_score": 0.00039, "epss_percentile": 0.11442}, "CVE-2021-30340": {"epss_score": 0.00228, "epss_percentile": 0.45469}, "CVE-2021-30341": {"epss_score": 0.00218, "epss_percentile": 0.44414}, "CVE-2021-30342": {"epss_score": 0.00143, "epss_percentile": 0.35092}, "CVE-2021-30343": {"epss_score": 0.00177, "epss_percentile": 0.39556}, "CVE-2021-30344": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2021-30345": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2021-30346": {"epss_score": 0.00045, "epss_percentile": 0.13697}, "CVE-2021-30347": {"epss_score": 0.0023, "epss_percentile": 0.45764}, "CVE-2021-30348": {"epss_score": 0.00071, "epss_percentile": 0.22183}, "CVE-2021-30349": {"epss_score": 0.00035, "epss_percentile": 0.1}, "CVE-2021-30350": {"epss_score": 0.00105, "epss_percentile": 0.2931}, "CVE-2021-30351": {"epss_score": 0.00393, "epss_percentile": 0.59743}, "CVE-2021-30353": {"epss_score": 0.00361, "epss_percentile": 0.57703}, "CVE-2021-30354": {"epss_score": 0.00884, "epss_percentile": 0.74925}, "CVE-2021-30355": {"epss_score": 0.00232, "epss_percentile": 0.45874}, "CVE-2021-30356": {"epss_score": 0.00464, "epss_percentile": 0.63708}, "CVE-2021-30357": {"epss_score": 0.29976, "epss_percentile": 0.96491}, "CVE-2021-30358": {"epss_score": 0.0051, "epss_percentile": 0.65768}, "CVE-2021-30359": {"epss_score": 0.00061, "epss_percentile": 0.19331}, "CVE-2021-30360": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2021-30361": {"epss_score": 0.00213, "epss_percentile": 0.43846}, "CVE-2021-30454": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-30455": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-30456": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-30457": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-30458": {"epss_score": 0.00214, "epss_percentile": 0.44014}, "CVE-2021-30459": {"epss_score": 0.00434, "epss_percentile": 0.62291}, "CVE-2021-30461": {"epss_score": 0.92773, "epss_percentile": 0.99746}, "CVE-2021-30462": {"epss_score": 0.00801, "epss_percentile": 0.73567}, "CVE-2021-30463": {"epss_score": 0.00056, "epss_percentile": 0.17676}, "CVE-2021-30464": {"epss_score": 0.00137, "epss_percentile": 0.34238}, "CVE-2021-30465": {"epss_score": 0.02358, "epss_percentile": 0.84488}, "CVE-2021-30468": {"epss_score": 0.01898, "epss_percentile": 0.82764}, "CVE-2021-30469": {"epss_score": 0.00168, "epss_percentile": 0.3847}, "CVE-2021-30470": {"epss_score": 0.00044, "epss_percentile": 0.13656}, "CVE-2021-30471": {"epss_score": 0.00044, "epss_percentile": 0.13656}, "CVE-2021-30472": {"epss_score": 0.00193, "epss_percentile": 0.41433}, "CVE-2021-30473": {"epss_score": 0.00247, "epss_percentile": 0.47891}, "CVE-2021-30474": {"epss_score": 0.00172, "epss_percentile": 0.38999}, "CVE-2021-30475": {"epss_score": 0.00212, "epss_percentile": 0.43806}, "CVE-2021-30476": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2021-30477": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2021-30478": {"epss_score": 0.00137, "epss_percentile": 0.34243}, "CVE-2021-30479": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2021-30480": {"epss_score": 0.1036, "epss_percentile": 0.92959}, "CVE-2021-30481": {"epss_score": 0.10977, "epss_percentile": 0.93182}, "CVE-2021-30482": {"epss_score": 3e-05, "epss_percentile": 0.00067}, "CVE-2021-30483": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2021-30485": {"epss_score": 0.01459, "epss_percentile": 0.8041}, "CVE-2021-30486": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2021-30487": {"epss_score": 0.00214, "epss_percentile": 0.43963}, "CVE-2021-30490": {"epss_score": 0.00034, "epss_percentile": 0.09795}, "CVE-2021-30493": {"epss_score": 0.00047, "epss_percentile": 0.14857}, "CVE-2021-30494": {"epss_score": 0.00047, "epss_percentile": 0.14857}, "CVE-2021-30496": {"epss_score": 0.00661, "epss_percentile": 0.70572}, "CVE-2021-30497": {"epss_score": 0.93774, "epss_percentile": 0.99843}, "CVE-2021-30498": {"epss_score": 0.00068, "epss_percentile": 0.21296}, "CVE-2021-30499": {"epss_score": 0.00064, "epss_percentile": 0.2038}, "CVE-2021-30500": {"epss_score": 0.0016, "epss_percentile": 0.37422}, "CVE-2021-30501": {"epss_score": 0.00125, "epss_percentile": 0.32616}, "CVE-2021-30502": {"epss_score": 0.0396, "epss_percentile": 0.88012}, "CVE-2021-30503": {"epss_score": 0.03332, "epss_percentile": 0.86929}, "CVE-2021-30504": {"epss_score": 4e-05, "epss_percentile": 0.00131}, "CVE-2021-30506": {"epss_score": 0.00306, "epss_percentile": 0.53429}, "CVE-2021-30507": {"epss_score": 0.00392, "epss_percentile": 0.59657}, "CVE-2021-30508": {"epss_score": 0.00309, "epss_percentile": 0.53703}, "CVE-2021-30509": {"epss_score": 0.00273, "epss_percentile": 0.5047}, "CVE-2021-30510": {"epss_score": 0.00901, "epss_percentile": 0.75179}, "CVE-2021-30511": {"epss_score": 0.00322, "epss_percentile": 0.54748}, "CVE-2021-30512": {"epss_score": 0.00665, "epss_percentile": 0.7066}, "CVE-2021-30513": {"epss_score": 0.01087, "epss_percentile": 0.77433}, "CVE-2021-30514": {"epss_score": 0.00736, "epss_percentile": 0.7231}, "CVE-2021-30515": {"epss_score": 0.0049, "epss_percentile": 0.64931}, "CVE-2021-30516": {"epss_score": 0.0082, "epss_percentile": 0.73887}, "CVE-2021-30517": {"epss_score": 0.14196, "epss_percentile": 0.9416}, "CVE-2021-30518": {"epss_score": 0.0082, "epss_percentile": 0.73887}, "CVE-2021-30519": {"epss_score": 0.00322, "epss_percentile": 0.54748}, "CVE-2021-30520": {"epss_score": 0.00322, "epss_percentile": 0.54748}, "CVE-2021-30521": {"epss_score": 0.0082, "epss_percentile": 0.73887}, "CVE-2021-30522": {"epss_score": 0.00917, "epss_percentile": 0.75427}, "CVE-2021-30523": {"epss_score": 0.00579, "epss_percentile": 0.68236}, "CVE-2021-30524": {"epss_score": 0.00256, "epss_percentile": 0.48777}, "CVE-2021-30525": {"epss_score": 0.00277, "epss_percentile": 0.5081}, "CVE-2021-30526": {"epss_score": 0.00258, "epss_percentile": 0.48962}, "CVE-2021-30527": {"epss_score": 0.00328, "epss_percentile": 0.55258}, "CVE-2021-30528": {"epss_score": 0.00838, "epss_percentile": 0.74176}, "CVE-2021-30529": {"epss_score": 0.00241, "epss_percentile": 0.47324}, "CVE-2021-30530": {"epss_score": 0.00584, "epss_percentile": 0.68374}, "CVE-2021-30531": {"epss_score": 0.00374, "epss_percentile": 0.58561}, "CVE-2021-30532": {"epss_score": 0.00558, "epss_percentile": 0.67577}, "CVE-2021-30533": {"epss_score": 0.10532, "epss_percentile": 0.9302}, "CVE-2021-30534": {"epss_score": 0.00117, "epss_percentile": 0.31291}, "CVE-2021-30535": {"epss_score": 0.00559, "epss_percentile": 0.67611}, "CVE-2021-30536": {"epss_score": 0.00805, "epss_percentile": 0.73642}, "CVE-2021-30537": {"epss_score": 0.00088, "epss_percentile": 0.25696}, "CVE-2021-30538": {"epss_score": 0.00205, "epss_percentile": 0.4268}, "CVE-2021-30539": {"epss_score": 0.00139, "epss_percentile": 0.34651}, "CVE-2021-30540": {"epss_score": 0.00533, "epss_percentile": 0.66757}, "CVE-2021-30541": {"epss_score": 0.01627, "epss_percentile": 0.8143}, "CVE-2021-30542": {"epss_score": 0.00276, "epss_percentile": 0.5077}, "CVE-2021-30543": {"epss_score": 0.00276, "epss_percentile": 0.5077}, "CVE-2021-30544": {"epss_score": 0.0032, "epss_percentile": 0.54619}, "CVE-2021-30545": {"epss_score": 0.00605, "epss_percentile": 0.68976}, "CVE-2021-30546": {"epss_score": 0.00605, "epss_percentile": 0.68976}, "CVE-2021-30547": {"epss_score": 0.0319, "epss_percentile": 0.866}, "CVE-2021-30548": {"epss_score": 0.00774, "epss_percentile": 0.73074}, "CVE-2021-30549": {"epss_score": 0.00258, "epss_percentile": 0.48962}, "CVE-2021-30550": {"epss_score": 0.00328, "epss_percentile": 0.55258}, "CVE-2021-30551": {"epss_score": 0.77963, "epss_percentile": 0.98962}, "CVE-2021-30552": {"epss_score": 0.00258, "epss_percentile": 0.48962}, "CVE-2021-30553": {"epss_score": 0.00609, "epss_percentile": 0.69133}, "CVE-2021-30554": {"epss_score": 0.04583, "epss_percentile": 0.88882}, "CVE-2021-30555": {"epss_score": 0.00287, "epss_percentile": 0.51841}, "CVE-2021-30556": {"epss_score": 0.00777, "epss_percentile": 0.73113}, "CVE-2021-30557": {"epss_score": 0.01169, "epss_percentile": 0.78205}, "CVE-2021-30558": {"epss_score": 0.00249, "epss_percentile": 0.4803}, "CVE-2021-30559": {"epss_score": 0.00412, "epss_percentile": 0.60939}, "CVE-2021-30560": {"epss_score": 0.00092, "epss_percentile": 0.2646}, "CVE-2021-30561": {"epss_score": 0.00416, "epss_percentile": 0.6116}, "CVE-2021-30562": {"epss_score": 0.00655, "epss_percentile": 0.70423}, "CVE-2021-30563": {"epss_score": 0.03591, "epss_percentile": 0.87399}, "CVE-2021-30564": {"epss_score": 0.00454, "epss_percentile": 0.63246}, "CVE-2021-30565": {"epss_score": 0.00208, "epss_percentile": 0.43257}, "CVE-2021-30566": {"epss_score": 0.00803, "epss_percentile": 0.73598}, "CVE-2021-30567": {"epss_score": 0.00258, "epss_percentile": 0.48962}, "CVE-2021-30568": {"epss_score": 0.01004, "epss_percentile": 0.76528}, "CVE-2021-30569": {"epss_score": 0.00805, "epss_percentile": 0.73635}, "CVE-2021-30571": {"epss_score": 0.00235, "epss_percentile": 0.46334}, "CVE-2021-30572": {"epss_score": 0.00805, "epss_percentile": 0.73635}, "CVE-2021-30573": {"epss_score": 0.6456, "epss_percentile": 0.98383}, "CVE-2021-30574": {"epss_score": 0.00805, "epss_percentile": 0.73635}, "CVE-2021-30575": {"epss_score": 0.00805, "epss_percentile": 0.73635}, "CVE-2021-30576": {"epss_score": 0.00258, "epss_percentile": 0.48962}, "CVE-2021-30577": {"epss_score": 0.00392, "epss_percentile": 0.59685}, "CVE-2021-30578": {"epss_score": 0.00805, "epss_percentile": 0.73635}, "CVE-2021-30579": {"epss_score": 0.00805, "epss_percentile": 0.73635}, "CVE-2021-30580": {"epss_score": 0.00276, "epss_percentile": 0.50702}, "CVE-2021-30581": {"epss_score": 0.00258, "epss_percentile": 0.48962}, "CVE-2021-30582": {"epss_score": 0.00574, "epss_percentile": 0.68093}, "CVE-2021-30583": {"epss_score": 0.00662, "epss_percentile": 0.7059}, "CVE-2021-30584": {"epss_score": 0.00408, "epss_percentile": 0.6067}, "CVE-2021-30585": {"epss_score": 0.00642, "epss_percentile": 0.70027}, "CVE-2021-30586": {"epss_score": 0.00303, "epss_percentile": 0.53216}, "CVE-2021-30587": {"epss_score": 0.00408, "epss_percentile": 0.6067}, "CVE-2021-30588": {"epss_score": 0.00597, "epss_percentile": 0.68748}, "CVE-2021-30589": {"epss_score": 0.00248, "epss_percentile": 0.47931}, "CVE-2021-30590": {"epss_score": 0.00629, "epss_percentile": 0.69675}, "CVE-2021-30591": {"epss_score": 0.0048, "epss_percentile": 0.64451}, "CVE-2021-30592": {"epss_score": 0.00232, "epss_percentile": 0.45967}, "CVE-2021-30593": {"epss_score": 0.00268, "epss_percentile": 0.50081}, "CVE-2021-30594": {"epss_score": 0.00305, "epss_percentile": 0.53338}, "CVE-2021-30596": {"epss_score": 0.00204, "epss_percentile": 0.42625}, "CVE-2021-30597": {"epss_score": 0.00281, "epss_percentile": 0.51121}, "CVE-2021-30598": {"epss_score": 0.01879, "epss_percentile": 0.82672}, "CVE-2021-30599": {"epss_score": 0.01912, "epss_percentile": 0.82835}, "CVE-2021-30600": {"epss_score": 0.00805, "epss_percentile": 0.73635}, "CVE-2021-30601": {"epss_score": 0.00247, "epss_percentile": 0.47855}, "CVE-2021-30602": {"epss_score": 0.00325, "epss_percentile": 0.55}, "CVE-2021-30603": {"epss_score": 0.01136, "epss_percentile": 0.77919}, "CVE-2021-30604": {"epss_score": 0.00805, "epss_percentile": 0.73635}, "CVE-2021-30605": {"epss_score": 0.00013, "epss_percentile": 0.01695}, "CVE-2021-30606": {"epss_score": 0.00435, "epss_percentile": 0.62328}, "CVE-2021-30607": {"epss_score": 0.00242, "epss_percentile": 0.47359}, "CVE-2021-30608": {"epss_score": 0.00435, "epss_percentile": 0.62328}, "CVE-2021-30609": {"epss_score": 0.00506, "epss_percentile": 0.65644}, "CVE-2021-30610": {"epss_score": 0.00504, "epss_percentile": 0.65548}, "CVE-2021-30611": {"epss_score": 0.00392, "epss_percentile": 0.59655}, "CVE-2021-30612": {"epss_score": 0.00393, "epss_percentile": 0.59742}, "CVE-2021-30613": {"epss_score": 0.00506, "epss_percentile": 0.65644}, "CVE-2021-30614": {"epss_score": 0.01871, "epss_percentile": 0.82633}, "CVE-2021-30615": {"epss_score": 0.04784, "epss_percentile": 0.89139}, "CVE-2021-30616": {"epss_score": 0.00506, "epss_percentile": 0.65644}, "CVE-2021-30617": {"epss_score": 0.00977, "epss_percentile": 0.76231}, "CVE-2021-30618": {"epss_score": 0.02341, "epss_percentile": 0.84435}, "CVE-2021-30619": {"epss_score": 0.01693, "epss_percentile": 0.81795}, "CVE-2021-30620": {"epss_score": 0.02341, "epss_percentile": 0.84435}, "CVE-2021-30621": {"epss_score": 0.01693, "epss_percentile": 0.81795}, "CVE-2021-30622": {"epss_score": 0.00506, "epss_percentile": 0.65644}, "CVE-2021-30623": {"epss_score": 0.00241, "epss_percentile": 0.4726}, "CVE-2021-30624": {"epss_score": 0.00506, "epss_percentile": 0.65644}, "CVE-2021-30625": {"epss_score": 0.03445, "epss_percentile": 0.87147}, "CVE-2021-30626": {"epss_score": 0.00819, "epss_percentile": 0.73872}, "CVE-2021-30627": {"epss_score": 0.00814, "epss_percentile": 0.73778}, "CVE-2021-30628": {"epss_score": 0.01223, "epss_percentile": 0.78667}, "CVE-2021-30629": {"epss_score": 0.0062, "epss_percentile": 0.69454}, "CVE-2021-30630": {"epss_score": 0.00283, "epss_percentile": 0.51391}, "CVE-2021-30632": {"epss_score": 0.83228, "epss_percentile": 0.99239}, "CVE-2021-30633": {"epss_score": 0.38157, "epss_percentile": 0.97088}, "CVE-2021-30635": {"epss_score": 0.00144, "epss_percentile": 0.35329}, "CVE-2021-30636": {"epss_score": 0.00335, "epss_percentile": 0.55856}, "CVE-2021-30637": {"epss_score": 0.00148, "epss_percentile": 0.35818}, "CVE-2021-30638": {"epss_score": 0.05311, "epss_percentile": 0.89717}, "CVE-2021-30639": {"epss_score": 0.00422, "epss_percentile": 0.61553}, "CVE-2021-30640": {"epss_score": 0.00184, "epss_percentile": 0.40396}, "CVE-2021-30641": {"epss_score": 0.22051, "epss_percentile": 0.95588}, "CVE-2021-30642": {"epss_score": 0.016, "epss_percentile": 0.81259}, "CVE-2021-30648": {"epss_score": 0.00491, "epss_percentile": 0.64957}, "CVE-2021-30650": {"epss_score": 0.00249, "epss_percentile": 0.48017}, "CVE-2021-30651": {"epss_score": 0.00297, "epss_percentile": 0.52697}, "CVE-2021-30652": {"epss_score": 0.00225, "epss_percentile": 0.45146}, "CVE-2021-30653": {"epss_score": 0.00462, "epss_percentile": 0.63586}, "CVE-2021-30654": {"epss_score": 0.00129, "epss_percentile": 0.33139}, "CVE-2021-30655": {"epss_score": 0.00838, "epss_percentile": 0.74165}, "CVE-2021-30656": {"epss_score": 0.00216, "epss_percentile": 0.44164}, "CVE-2021-30657": {"epss_score": 0.74324, "epss_percentile": 0.98796}, "CVE-2021-30658": {"epss_score": 0.00063, "epss_percentile": 0.19805}, "CVE-2021-30659": {"epss_score": 0.00408, "epss_percentile": 0.60625}, "CVE-2021-30660": {"epss_score": 0.00602, "epss_percentile": 0.68865}, "CVE-2021-30661": {"epss_score": 0.00157, "epss_percentile": 0.37134}, "CVE-2021-30662": {"epss_score": 0.00397, "epss_percentile": 0.5997}, "CVE-2021-30663": {"epss_score": 0.01108, "epss_percentile": 0.7763}, "CVE-2021-30664": {"epss_score": 0.00462, "epss_percentile": 0.63586}, "CVE-2021-30665": {"epss_score": 0.00654, "epss_percentile": 0.70353}, "CVE-2021-30666": {"epss_score": 0.01497, "epss_percentile": 0.80691}, "CVE-2021-30667": {"epss_score": 0.00062, "epss_percentile": 0.19773}, "CVE-2021-30668": {"epss_score": 0.00064, "epss_percentile": 0.20174}, "CVE-2021-30669": {"epss_score": 0.00068, "epss_percentile": 0.21255}, "CVE-2021-30671": {"epss_score": 0.00138, "epss_percentile": 0.34351}, "CVE-2021-30672": {"epss_score": 0.00352, "epss_percentile": 0.57092}, "CVE-2021-30673": {"epss_score": 0.00178, "epss_percentile": 0.39715}, "CVE-2021-30674": {"epss_score": 0.0031, "epss_percentile": 0.53757}, "CVE-2021-30675": {"epss_score": 0.00409, "epss_percentile": 0.60702}, "CVE-2021-30676": {"epss_score": 0.00041, "epss_percentile": 0.12279}, "CVE-2021-30677": {"epss_score": 0.0011, "epss_percentile": 0.30187}, "CVE-2021-30678": {"epss_score": 0.02479, "epss_percentile": 0.84868}, "CVE-2021-30679": {"epss_score": 0.00225, "epss_percentile": 0.45143}, "CVE-2021-30680": {"epss_score": 0.00044, "epss_percentile": 0.13636}, "CVE-2021-30681": {"epss_score": 0.00157, "epss_percentile": 0.37061}, "CVE-2021-30682": {"epss_score": 0.00369, "epss_percentile": 0.58273}, "CVE-2021-30683": {"epss_score": 0.00528, "epss_percentile": 0.66551}, "CVE-2021-30684": {"epss_score": 0.00429, "epss_percentile": 0.62001}, "CVE-2021-30685": {"epss_score": 0.00296, "epss_percentile": 0.52573}, "CVE-2021-30686": {"epss_score": 0.00296, "epss_percentile": 0.52573}, "CVE-2021-30687": {"epss_score": 0.00394, "epss_percentile": 0.59784}, "CVE-2021-30688": {"epss_score": 0.00043, "epss_percentile": 0.13341}, "CVE-2021-30689": {"epss_score": 0.01123, "epss_percentile": 0.77786}, "CVE-2021-30690": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-30691": {"epss_score": 0.00269, "epss_percentile": 0.50161}, "CVE-2021-30692": {"epss_score": 0.00269, "epss_percentile": 0.50161}, "CVE-2021-30693": {"epss_score": 0.00402, "epss_percentile": 0.60286}, "CVE-2021-30694": {"epss_score": 0.00269, "epss_percentile": 0.50161}, "CVE-2021-30695": {"epss_score": 0.00269, "epss_percentile": 0.50161}, "CVE-2021-30696": {"epss_score": 0.00289, "epss_percentile": 0.52015}, "CVE-2021-30697": {"epss_score": 0.00061, "epss_percentile": 0.19329}, "CVE-2021-30698": {"epss_score": 0.00469, "epss_percentile": 0.63942}, "CVE-2021-30699": {"epss_score": 0.00063, "epss_percentile": 0.19948}, "CVE-2021-30700": {"epss_score": 0.00444, "epss_percentile": 0.62817}, "CVE-2021-30701": {"epss_score": 0.00727, "epss_percentile": 0.72093}, "CVE-2021-30702": {"epss_score": 0.00054, "epss_percentile": 0.17112}, "CVE-2021-30703": {"epss_score": 0.0032, "epss_percentile": 0.54636}, "CVE-2021-30704": {"epss_score": 0.00361, "epss_percentile": 0.57698}, "CVE-2021-30705": {"epss_score": 0.00259, "epss_percentile": 0.49073}, "CVE-2021-30706": {"epss_score": 0.00269, "epss_percentile": 0.50161}, "CVE-2021-30707": {"epss_score": 0.01204, "epss_percentile": 0.78507}, "CVE-2021-30708": {"epss_score": 0.00376, "epss_percentile": 0.58653}, "CVE-2021-30709": {"epss_score": 0.00244, "epss_percentile": 0.47528}, "CVE-2021-30710": {"epss_score": 0.00238, "epss_percentile": 0.46749}, "CVE-2021-30712": {"epss_score": 0.01108, "epss_percentile": 0.77638}, "CVE-2021-30713": {"epss_score": 0.00142, "epss_percentile": 0.35013}, "CVE-2021-30714": {"epss_score": 0.0015, "epss_percentile": 0.36067}, "CVE-2021-30715": {"epss_score": 0.00653, "epss_percentile": 0.70325}, "CVE-2021-30716": {"epss_score": 0.00645, "epss_percentile": 0.70123}, "CVE-2021-30717": {"epss_score": 0.00885, "epss_percentile": 0.74946}, "CVE-2021-30718": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2021-30719": {"epss_score": 0.00031, "epss_percentile": 0.08577}, "CVE-2021-30720": {"epss_score": 0.00383, "epss_percentile": 0.591}, "CVE-2021-30721": {"epss_score": 0.00501, "epss_percentile": 0.65357}, "CVE-2021-30722": {"epss_score": 0.00481, "epss_percentile": 0.6449}, "CVE-2021-30723": {"epss_score": 0.00269, "epss_percentile": 0.50161}, "CVE-2021-30724": {"epss_score": 0.0025, "epss_percentile": 0.48136}, "CVE-2021-30725": {"epss_score": 0.00406, "epss_percentile": 0.60532}, "CVE-2021-30726": {"epss_score": 0.00292, "epss_percentile": 0.52273}, "CVE-2021-30727": {"epss_score": 0.00235, "epss_percentile": 0.46206}, "CVE-2021-30728": {"epss_score": 0.00292, "epss_percentile": 0.52273}, "CVE-2021-30729": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2021-30731": {"epss_score": 0.00259, "epss_percentile": 0.49047}, "CVE-2021-30733": {"epss_score": 0.00334, "epss_percentile": 0.55695}, "CVE-2021-30734": {"epss_score": 0.00381, "epss_percentile": 0.58977}, "CVE-2021-30735": {"epss_score": 0.00271, "epss_percentile": 0.50322}, "CVE-2021-30736": {"epss_score": 0.00382, "epss_percentile": 0.59049}, "CVE-2021-30737": {"epss_score": 0.00622, "epss_percentile": 0.69516}, "CVE-2021-30738": {"epss_score": 0.0006, "epss_percentile": 0.19207}, "CVE-2021-30739": {"epss_score": 0.00069, "epss_percentile": 0.21511}, "CVE-2021-30740": {"epss_score": 0.01025, "epss_percentile": 0.76792}, "CVE-2021-30741": {"epss_score": 0.00184, "epss_percentile": 0.4037}, "CVE-2021-30742": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2021-30743": {"epss_score": 0.00424, "epss_percentile": 0.61673}, "CVE-2021-30744": {"epss_score": 0.0061, "epss_percentile": 0.69153}, "CVE-2021-30746": {"epss_score": 0.00269, "epss_percentile": 0.50161}, "CVE-2021-30748": {"epss_score": 0.00858, "epss_percentile": 0.74498}, "CVE-2021-30749": {"epss_score": 0.00535, "epss_percentile": 0.66835}, "CVE-2021-30750": {"epss_score": 0.00146, "epss_percentile": 0.35616}, "CVE-2021-30751": {"epss_score": 0.00194, "epss_percentile": 0.41528}, "CVE-2021-30752": {"epss_score": 0.00406, "epss_percentile": 0.60532}, "CVE-2021-30753": {"epss_score": 0.00269, "epss_percentile": 0.50161}, "CVE-2021-30755": {"epss_score": 0.00408, "epss_percentile": 0.60625}, "CVE-2021-30756": {"epss_score": 0.00035, "epss_percentile": 0.09997}, "CVE-2021-30757": {"epss_score": 0.00248, "epss_percentile": 0.47952}, "CVE-2021-30758": {"epss_score": 0.00346, "epss_percentile": 0.56605}, "CVE-2021-30759": {"epss_score": 0.01048, "epss_percentile": 0.77051}, "CVE-2021-30760": {"epss_score": 0.00447, "epss_percentile": 0.62967}, "CVE-2021-30761": {"epss_score": 0.0037, "epss_percentile": 0.58281}, "CVE-2021-30762": {"epss_score": 0.00049, "epss_percentile": 0.15348}, "CVE-2021-30763": {"epss_score": 0.00149, "epss_percentile": 0.36037}, "CVE-2021-30764": {"epss_score": 0.00407, "epss_percentile": 0.60593}, "CVE-2021-30765": {"epss_score": 0.00546, "epss_percentile": 0.67211}, "CVE-2021-30766": {"epss_score": 0.00546, "epss_percentile": 0.67211}, "CVE-2021-30767": {"epss_score": 0.00059, "epss_percentile": 0.18923}, "CVE-2021-30768": {"epss_score": 0.00504, "epss_percentile": 0.65485}, "CVE-2021-30769": {"epss_score": 0.00104, "epss_percentile": 0.29129}, "CVE-2021-30770": {"epss_score": 0.00036, "epss_percentile": 0.10261}, "CVE-2021-30771": {"epss_score": 0.00406, "epss_percentile": 0.60532}, "CVE-2021-30772": {"epss_score": 0.00345, "epss_percentile": 0.56565}, "CVE-2021-30773": {"epss_score": 0.00147, "epss_percentile": 0.35774}, "CVE-2021-30774": {"epss_score": 0.00299, "epss_percentile": 0.52891}, "CVE-2021-30775": {"epss_score": 0.00798, "epss_percentile": 0.73506}, "CVE-2021-30776": {"epss_score": 0.00314, "epss_percentile": 0.54142}, "CVE-2021-30777": {"epss_score": 0.00435, "epss_percentile": 0.62372}, "CVE-2021-30778": {"epss_score": 0.00164, "epss_percentile": 0.37912}, "CVE-2021-30779": {"epss_score": 0.00898, "epss_percentile": 0.75148}, "CVE-2021-30780": {"epss_score": 0.00393, "epss_percentile": 0.59715}, "CVE-2021-30781": {"epss_score": 0.00248, "epss_percentile": 0.47958}, "CVE-2021-30782": {"epss_score": 0.00552, "epss_percentile": 0.67399}, "CVE-2021-30783": {"epss_score": 0.00141, "epss_percentile": 0.34908}, "CVE-2021-30784": {"epss_score": 0.00372, "epss_percentile": 0.58455}, "CVE-2021-30785": {"epss_score": 0.00799, "epss_percentile": 0.7352}, "CVE-2021-30786": {"epss_score": 0.00209, "epss_percentile": 0.43309}, "CVE-2021-30787": {"epss_score": 0.00334, "epss_percentile": 0.55689}, "CVE-2021-30788": {"epss_score": 0.00337, "epss_percentile": 0.56018}, "CVE-2021-30789": {"epss_score": 0.00623, "epss_percentile": 0.69553}, "CVE-2021-30790": {"epss_score": 0.0097, "epss_percentile": 0.76111}, "CVE-2021-30791": {"epss_score": 0.0034, "epss_percentile": 0.56235}, "CVE-2021-30792": {"epss_score": 0.00497, "epss_percentile": 0.6519}, "CVE-2021-30793": {"epss_score": 0.01622, "epss_percentile": 0.81399}, "CVE-2021-30795": {"epss_score": 0.00666, "epss_percentile": 0.70689}, "CVE-2021-30796": {"epss_score": 0.00555, "epss_percentile": 0.67474}, "CVE-2021-30797": {"epss_score": 0.00672, "epss_percentile": 0.7082}, "CVE-2021-30798": {"epss_score": 0.00387, "epss_percentile": 0.59313}, "CVE-2021-30799": {"epss_score": 0.01008, "epss_percentile": 0.7657}, "CVE-2021-30800": {"epss_score": 0.00234, "epss_percentile": 0.46169}, "CVE-2021-30802": {"epss_score": 0.00492, "epss_percentile": 0.6501}, "CVE-2021-30803": {"epss_score": 0.00257, "epss_percentile": 0.48856}, "CVE-2021-30804": {"epss_score": 0.00248, "epss_percentile": 0.47952}, "CVE-2021-30805": {"epss_score": 0.01622, "epss_percentile": 0.81399}, "CVE-2021-30807": {"epss_score": 0.17401, "epss_percentile": 0.94846}, "CVE-2021-30808": {"epss_score": 0.00289, "epss_percentile": 0.52037}, "CVE-2021-30809": {"epss_score": 0.00777, "epss_percentile": 0.73121}, "CVE-2021-30810": {"epss_score": 0.00147, "epss_percentile": 0.35746}, "CVE-2021-30811": {"epss_score": 0.00096, "epss_percentile": 0.27362}, "CVE-2021-30813": {"epss_score": 0.00055, "epss_percentile": 0.17525}, "CVE-2021-30814": {"epss_score": 0.00634, "epss_percentile": 0.69801}, "CVE-2021-30815": {"epss_score": 0.00046, "epss_percentile": 0.14194}, "CVE-2021-30816": {"epss_score": 0.00053, "epss_percentile": 0.16864}, "CVE-2021-30817": {"epss_score": 0.00227, "epss_percentile": 0.4538}, "CVE-2021-30818": {"epss_score": 0.00492, "epss_percentile": 0.65013}, "CVE-2021-30819": {"epss_score": 0.00245, "epss_percentile": 0.47693}, "CVE-2021-30820": {"epss_score": 0.02126, "epss_percentile": 0.83694}, "CVE-2021-30821": {"epss_score": 0.00292, "epss_percentile": 0.52273}, "CVE-2021-30823": {"epss_score": 0.00502, "epss_percentile": 0.65372}, "CVE-2021-30824": {"epss_score": 0.00292, "epss_percentile": 0.52273}, "CVE-2021-30825": {"epss_score": 0.00073, "epss_percentile": 0.22559}, "CVE-2021-30826": {"epss_score": 0.00289, "epss_percentile": 0.52015}, "CVE-2021-30827": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2021-30828": {"epss_score": 0.00042, "epss_percentile": 0.12731}, "CVE-2021-30829": {"epss_score": 0.00039, "epss_percentile": 0.11466}, "CVE-2021-30830": {"epss_score": 0.00195, "epss_percentile": 0.41665}, "CVE-2021-30831": {"epss_score": 0.00244, "epss_percentile": 0.47528}, "CVE-2021-30832": {"epss_score": 0.00067, "epss_percentile": 0.20981}, "CVE-2021-30833": {"epss_score": 0.0305, "epss_percentile": 0.86289}, "CVE-2021-30834": {"epss_score": 0.00344, "epss_percentile": 0.56494}, "CVE-2021-30835": {"epss_score": 0.00402, "epss_percentile": 0.60296}, "CVE-2021-30836": {"epss_score": 0.00238, "epss_percentile": 0.46832}, "CVE-2021-30837": {"epss_score": 0.00383, "epss_percentile": 0.59103}, "CVE-2021-30838": {"epss_score": 0.00235, "epss_percentile": 0.46227}, "CVE-2021-30840": {"epss_score": 0.00376, "epss_percentile": 0.58653}, "CVE-2021-30841": {"epss_score": 0.0027, "epss_percentile": 0.50241}, "CVE-2021-30842": {"epss_score": 0.0027, "epss_percentile": 0.50241}, "CVE-2021-30843": {"epss_score": 0.0027, "epss_percentile": 0.50241}, "CVE-2021-30844": {"epss_score": 0.00571, "epss_percentile": 0.67977}, "CVE-2021-30845": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2021-30846": {"epss_score": 0.00628, "epss_percentile": 0.69647}, "CVE-2021-30847": {"epss_score": 0.00402, "epss_percentile": 0.60296}, "CVE-2021-30848": {"epss_score": 0.00662, "epss_percentile": 0.70606}, "CVE-2021-30849": {"epss_score": 0.0048, "epss_percentile": 0.64464}, "CVE-2021-30850": {"epss_score": 0.00222, "epss_percentile": 0.44805}, "CVE-2021-30851": {"epss_score": 0.00708, "epss_percentile": 0.71676}, "CVE-2021-30852": {"epss_score": 0.00714, "epss_percentile": 0.71829}, "CVE-2021-30853": {"epss_score": 0.0021, "epss_percentile": 0.43494}, "CVE-2021-30854": {"epss_score": 0.00283, "epss_percentile": 0.51393}, "CVE-2021-30855": {"epss_score": 0.00214, "epss_percentile": 0.44021}, "CVE-2021-30856": {"epss_score": 0.00257, "epss_percentile": 0.48877}, "CVE-2021-30857": {"epss_score": 0.00237, "epss_percentile": 0.46737}, "CVE-2021-30858": {"epss_score": 0.00794, "epss_percentile": 0.73459}, "CVE-2021-30859": {"epss_score": 0.00268, "epss_percentile": 0.50066}, "CVE-2021-30860": {"epss_score": 0.69529, "epss_percentile": 0.98592}, "CVE-2021-30861": {"epss_score": 0.00236, "epss_percentile": 0.46383}, "CVE-2021-30862": {"epss_score": 0.01637, "epss_percentile": 0.8148}, "CVE-2021-30863": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2021-30864": {"epss_score": 0.00437, "epss_percentile": 0.62508}, "CVE-2021-30865": {"epss_score": 0.00233, "epss_percentile": 0.46049}, "CVE-2021-30866": {"epss_score": 0.00097, "epss_percentile": 0.27536}, "CVE-2021-30867": {"epss_score": 0.00172, "epss_percentile": 0.38956}, "CVE-2021-30868": {"epss_score": 0.00191, "epss_percentile": 0.41147}, "CVE-2021-30869": {"epss_score": 0.01997, "epss_percentile": 0.83207}, "CVE-2021-30870": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2021-30871": {"epss_score": 0.00154, "epss_percentile": 0.36716}, "CVE-2021-30873": {"epss_score": 0.00273, "epss_percentile": 0.50472}, "CVE-2021-30874": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2021-30875": {"epss_score": 0.00047, "epss_percentile": 0.146}, "CVE-2021-30876": {"epss_score": 0.00364, "epss_percentile": 0.57959}, "CVE-2021-30877": {"epss_score": 0.00241, "epss_percentile": 0.47271}, "CVE-2021-30879": {"epss_score": 0.00364, "epss_percentile": 0.57959}, "CVE-2021-30880": {"epss_score": 0.00241, "epss_percentile": 0.47271}, "CVE-2021-30881": {"epss_score": 0.00574, "epss_percentile": 0.68081}, "CVE-2021-30882": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2021-30883": {"epss_score": 0.00577, "epss_percentile": 0.6815}, "CVE-2021-30884": {"epss_score": 0.0028, "epss_percentile": 0.5104}, "CVE-2021-30886": {"epss_score": 0.00587, "epss_percentile": 0.68461}, "CVE-2021-30887": {"epss_score": 0.00304, "epss_percentile": 0.53254}, "CVE-2021-30888": {"epss_score": 0.00242, "epss_percentile": 0.47357}, "CVE-2021-30889": {"epss_score": 0.00696, "epss_percentile": 0.71389}, "CVE-2021-30890": {"epss_score": 0.00191, "epss_percentile": 0.41256}, "CVE-2021-30892": {"epss_score": 0.01938, "epss_percentile": 0.82966}, "CVE-2021-30894": {"epss_score": 0.00473, "epss_percentile": 0.64102}, "CVE-2021-30895": {"epss_score": 0.00342, "epss_percentile": 0.56362}, "CVE-2021-30896": {"epss_score": 0.00368, "epss_percentile": 0.58175}, "CVE-2021-30897": {"epss_score": 0.00254, "epss_percentile": 0.4851}, "CVE-2021-30898": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2021-30899": {"epss_score": 0.002, "epss_percentile": 0.42234}, "CVE-2021-30900": {"epss_score": 0.01194, "epss_percentile": 0.78422}, "CVE-2021-30901": {"epss_score": 0.00258, "epss_percentile": 0.49015}, "CVE-2021-30902": {"epss_score": 0.00077, "epss_percentile": 0.23316}, "CVE-2021-30903": {"epss_score": 0.00189, "epss_percentile": 0.40993}, "CVE-2021-30904": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2021-30905": {"epss_score": 0.00321, "epss_percentile": 0.54738}, "CVE-2021-30906": {"epss_score": 0.00112, "epss_percentile": 0.30423}, "CVE-2021-30907": {"epss_score": 0.00491, "epss_percentile": 0.64951}, "CVE-2021-30908": {"epss_score": 0.00049, "epss_percentile": 0.15376}, "CVE-2021-30909": {"epss_score": 0.00576, "epss_percentile": 0.68131}, "CVE-2021-30910": {"epss_score": 0.00327, "epss_percentile": 0.55129}, "CVE-2021-30911": {"epss_score": 0.00264, "epss_percentile": 0.49576}, "CVE-2021-30912": {"epss_score": 0.00178, "epss_percentile": 0.39639}, "CVE-2021-30913": {"epss_score": 0.00172, "epss_percentile": 0.38935}, "CVE-2021-30914": {"epss_score": 0.00265, "epss_percentile": 0.4984}, "CVE-2021-30915": {"epss_score": 0.00112, "epss_percentile": 0.30419}, "CVE-2021-30916": {"epss_score": 0.00387, "epss_percentile": 0.59292}, "CVE-2021-30917": {"epss_score": 0.00493, "epss_percentile": 0.65034}, "CVE-2021-30918": {"epss_score": 0.0007, "epss_percentile": 0.21867}, "CVE-2021-30919": {"epss_score": 0.00601, "epss_percentile": 0.68843}, "CVE-2021-30920": {"epss_score": 0.00035, "epss_percentile": 0.09996}, "CVE-2021-30921": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2021-30922": {"epss_score": 0.00059, "epss_percentile": 0.18634}, "CVE-2021-30923": {"epss_score": 0.0018, "epss_percentile": 0.39989}, "CVE-2021-30924": {"epss_score": 0.0088, "epss_percentile": 0.74857}, "CVE-2021-30925": {"epss_score": 0.00232, "epss_percentile": 0.45962}, "CVE-2021-30926": {"epss_score": 0.00339, "epss_percentile": 0.56189}, "CVE-2021-30927": {"epss_score": 0.00098, "epss_percentile": 0.27727}, "CVE-2021-30928": {"epss_score": 0.00414, "epss_percentile": 0.61109}, "CVE-2021-30929": {"epss_score": 0.00077, "epss_percentile": 0.23387}, "CVE-2021-30930": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2021-30931": {"epss_score": 0.00242, "epss_percentile": 0.47385}, "CVE-2021-30932": {"epss_score": 0.00048, "epss_percentile": 0.15267}, "CVE-2021-30933": {"epss_score": 0.0018, "epss_percentile": 0.39989}, "CVE-2021-30934": {"epss_score": 0.0169, "epss_percentile": 0.81773}, "CVE-2021-30935": {"epss_score": 0.00124, "epss_percentile": 0.3243}, "CVE-2021-30936": {"epss_score": 0.00887, "epss_percentile": 0.74969}, "CVE-2021-30937": {"epss_score": 0.24404, "epss_percentile": 0.95918}, "CVE-2021-30938": {"epss_score": 0.0005, "epss_percentile": 0.15652}, "CVE-2021-30939": {"epss_score": 0.00411, "epss_percentile": 0.60872}, "CVE-2021-30940": {"epss_score": 0.00305, "epss_percentile": 0.53348}, "CVE-2021-30941": {"epss_score": 0.00305, "epss_percentile": 0.53348}, "CVE-2021-30942": {"epss_score": 0.00325, "epss_percentile": 0.55008}, "CVE-2021-30943": {"epss_score": 0.00189, "epss_percentile": 0.40992}, "CVE-2021-30944": {"epss_score": 0.00264, "epss_percentile": 0.49576}, "CVE-2021-30945": {"epss_score": 0.00064, "epss_percentile": 0.20398}, "CVE-2021-30946": {"epss_score": 0.00336, "epss_percentile": 0.55998}, "CVE-2021-30947": {"epss_score": 0.0029, "epss_percentile": 0.52119}, "CVE-2021-30948": {"epss_score": 0.00055, "epss_percentile": 0.17492}, "CVE-2021-30949": {"epss_score": 0.00415, "epss_percentile": 0.61146}, "CVE-2021-30950": {"epss_score": 0.00282, "epss_percentile": 0.51274}, "CVE-2021-30951": {"epss_score": 0.00887, "epss_percentile": 0.74969}, "CVE-2021-30952": {"epss_score": 0.00329, "epss_percentile": 0.55318}, "CVE-2021-30953": {"epss_score": 0.00805, "epss_percentile": 0.7364}, "CVE-2021-30954": {"epss_score": 0.00266, "epss_percentile": 0.49901}, "CVE-2021-30955": {"epss_score": 0.28245, "epss_percentile": 0.96337}, "CVE-2021-30956": {"epss_score": 0.00064, "epss_percentile": 0.20333}, "CVE-2021-30957": {"epss_score": 0.00691, "epss_percentile": 0.71266}, "CVE-2021-30958": {"epss_score": 0.0034, "epss_percentile": 0.5623}, "CVE-2021-30959": {"epss_score": 0.00235, "epss_percentile": 0.46239}, "CVE-2021-30960": {"epss_score": 0.00307, "epss_percentile": 0.53484}, "CVE-2021-30961": {"epss_score": 0.00235, "epss_percentile": 0.46239}, "CVE-2021-30962": {"epss_score": 0.00222, "epss_percentile": 0.44734}, "CVE-2021-30963": {"epss_score": 0.00235, "epss_percentile": 0.46239}, "CVE-2021-30964": {"epss_score": 0.00178, "epss_percentile": 0.39639}, "CVE-2021-30965": {"epss_score": 0.0035, "epss_percentile": 0.56976}, "CVE-2021-30966": {"epss_score": 0.00468, "epss_percentile": 0.6391}, "CVE-2021-30967": {"epss_score": 0.00039, "epss_percentile": 0.11672}, "CVE-2021-30968": {"epss_score": 0.0023, "epss_percentile": 0.45728}, "CVE-2021-30969": {"epss_score": 0.00233, "epss_percentile": 0.46049}, "CVE-2021-30970": {"epss_score": 0.00039, "epss_percentile": 0.11704}, "CVE-2021-30971": {"epss_score": 0.00244, "epss_percentile": 0.47608}, "CVE-2021-30972": {"epss_score": 0.00055, "epss_percentile": 0.17471}, "CVE-2021-30973": {"epss_score": 0.00264, "epss_percentile": 0.49576}, "CVE-2021-30975": {"epss_score": 0.00344, "epss_percentile": 0.56519}, "CVE-2021-30976": {"epss_score": 0.00227, "epss_percentile": 0.45437}, "CVE-2021-30977": {"epss_score": 0.00398, "epss_percentile": 0.60082}, "CVE-2021-30979": {"epss_score": 0.00607, "epss_percentile": 0.69058}, "CVE-2021-30980": {"epss_score": 0.00591, "epss_percentile": 0.68593}, "CVE-2021-30981": {"epss_score": 0.00747, "epss_percentile": 0.72555}, "CVE-2021-30982": {"epss_score": 0.00312, "epss_percentile": 0.53989}, "CVE-2021-30983": {"epss_score": 0.00678, "epss_percentile": 0.70971}, "CVE-2021-30984": {"epss_score": 0.00688, "epss_percentile": 0.71202}, "CVE-2021-30985": {"epss_score": 0.00265, "epss_percentile": 0.4984}, "CVE-2021-30986": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2021-30987": {"epss_score": 0.00065, "epss_percentile": 0.20462}, "CVE-2021-30988": {"epss_score": 0.00168, "epss_percentile": 0.38405}, "CVE-2021-30990": {"epss_score": 0.00212, "epss_percentile": 0.43819}, "CVE-2021-30991": {"epss_score": 0.00265, "epss_percentile": 0.4984}, "CVE-2021-30992": {"epss_score": 0.00068, "epss_percentile": 0.21216}, "CVE-2021-30993": {"epss_score": 0.01668, "epss_percentile": 0.81661}, "CVE-2021-30994": {"epss_score": 0.00202, "epss_percentile": 0.42421}, "CVE-2021-30995": {"epss_score": 0.00179, "epss_percentile": 0.39809}, "CVE-2021-30996": {"epss_score": 0.00191, "epss_percentile": 0.41147}, "CVE-2021-30997": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2021-30998": {"epss_score": 0.00125, "epss_percentile": 0.32532}, "CVE-2021-30999": {"epss_score": 0.00169, "epss_percentile": 0.3862}, "CVE-2021-31000": {"epss_score": 0.00227, "epss_percentile": 0.45436}, "CVE-2021-31001": {"epss_score": 0.00356, "epss_percentile": 0.57397}, "CVE-2021-31002": {"epss_score": 0.00341, "epss_percentile": 0.56322}, "CVE-2021-31004": {"epss_score": 0.00212, "epss_percentile": 0.43729}, "CVE-2021-31005": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2021-31006": {"epss_score": 0.001, "epss_percentile": 0.28526}, "CVE-2021-31007": {"epss_score": 0.00133, "epss_percentile": 0.33683}, "CVE-2021-31008": {"epss_score": 0.01231, "epss_percentile": 0.78728}, "CVE-2021-31009": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-31010": {"epss_score": 0.01272, "epss_percentile": 0.79083}, "CVE-2021-31013": {"epss_score": 0.0032, "epss_percentile": 0.54577}, "CVE-2021-31152": {"epss_score": 0.01732, "epss_percentile": 0.81996}, "CVE-2021-31153": {"epss_score": 0.00053, "epss_percentile": 0.16865}, "CVE-2021-31154": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2021-31155": {"epss_score": 0.00035, "epss_percentile": 0.10054}, "CVE-2021-31156": {"epss_score": 0.00384, "epss_percentile": 0.59156}, "CVE-2021-31158": {"epss_score": 0.00168, "epss_percentile": 0.38518}, "CVE-2021-31159": {"epss_score": 0.23702, "epss_percentile": 0.95805}, "CVE-2021-31160": {"epss_score": 0.10019, "epss_percentile": 0.92819}, "CVE-2021-31162": {"epss_score": 0.01824, "epss_percentile": 0.82425}, "CVE-2021-31164": {"epss_score": 0.02937, "epss_percentile": 0.86028}, "CVE-2021-31165": {"epss_score": 0.0033, "epss_percentile": 0.55429}, "CVE-2021-31166": {"epss_score": 0.93069, "epss_percentile": 0.99773}, "CVE-2021-31167": {"epss_score": 0.0033, "epss_percentile": 0.55429}, "CVE-2021-31168": {"epss_score": 0.0033, "epss_percentile": 0.55429}, "CVE-2021-31169": {"epss_score": 0.0033, "epss_percentile": 0.55429}, "CVE-2021-31170": {"epss_score": 0.00387, "epss_percentile": 0.59298}, "CVE-2021-31171": {"epss_score": 0.00287, "epss_percentile": 0.51784}, "CVE-2021-31172": {"epss_score": 0.02278, "epss_percentile": 0.84236}, "CVE-2021-31173": {"epss_score": 0.02924, "epss_percentile": 0.86003}, "CVE-2021-31174": {"epss_score": 0.00503, "epss_percentile": 0.65445}, "CVE-2021-31175": {"epss_score": 0.07026, "epss_percentile": 0.91195}, "CVE-2021-31176": {"epss_score": 0.06044, "epss_percentile": 0.90431}, "CVE-2021-31177": {"epss_score": 0.06268, "epss_percentile": 0.90627}, "CVE-2021-31178": {"epss_score": 0.25551, "epss_percentile": 0.9604}, "CVE-2021-31179": {"epss_score": 0.05291, "epss_percentile": 0.89697}, "CVE-2021-31180": {"epss_score": 0.05936, "epss_percentile": 0.90343}, "CVE-2021-31181": {"epss_score": 0.28274, "epss_percentile": 0.96339}, "CVE-2021-31182": {"epss_score": 0.00341, "epss_percentile": 0.5632}, "CVE-2021-31183": {"epss_score": 0.22628, "epss_percentile": 0.95661}, "CVE-2021-31184": {"epss_score": 0.02392, "epss_percentile": 0.84603}, "CVE-2021-31185": {"epss_score": 0.00135, "epss_percentile": 0.33995}, "CVE-2021-31186": {"epss_score": 0.11696, "epss_percentile": 0.93453}, "CVE-2021-31187": {"epss_score": 0.01494, "epss_percentile": 0.80644}, "CVE-2021-31188": {"epss_score": 0.01143, "epss_percentile": 0.7798}, "CVE-2021-31190": {"epss_score": 0.00513, "epss_percentile": 0.65932}, "CVE-2021-31191": {"epss_score": 0.00403, "epss_percentile": 0.60347}, "CVE-2021-31192": {"epss_score": 0.05936, "epss_percentile": 0.90343}, "CVE-2021-31193": {"epss_score": 0.00283, "epss_percentile": 0.51388}, "CVE-2021-31194": {"epss_score": 0.11235, "epss_percentile": 0.93274}, "CVE-2021-31195": {"epss_score": 0.84363, "epss_percentile": 0.99286}, "CVE-2021-31196": {"epss_score": 0.08139, "epss_percentile": 0.91898}, "CVE-2021-31198": {"epss_score": 0.01628, "epss_percentile": 0.81434}, "CVE-2021-31199": {"epss_score": 0.01021, "epss_percentile": 0.76746}, "CVE-2021-31200": {"epss_score": 0.0461, "epss_percentile": 0.88913}, "CVE-2021-31201": {"epss_score": 0.016, "epss_percentile": 0.81254}, "CVE-2021-31204": {"epss_score": 0.08688, "epss_percentile": 0.92203}, "CVE-2021-31205": {"epss_score": 0.06449, "epss_percentile": 0.90763}, "CVE-2021-31206": {"epss_score": 0.07114, "epss_percentile": 0.9126}, "CVE-2021-31207": {"epss_score": 0.93908, "epss_percentile": 0.99866}, "CVE-2021-31208": {"epss_score": 0.00513, "epss_percentile": 0.65932}, "CVE-2021-31209": {"epss_score": 0.00408, "epss_percentile": 0.60627}, "CVE-2021-31211": {"epss_score": 0.04005, "epss_percentile": 0.88102}, "CVE-2021-31213": {"epss_score": 0.04715, "epss_percentile": 0.89042}, "CVE-2021-31214": {"epss_score": 0.04485, "epss_percentile": 0.88747}, "CVE-2021-31215": {"epss_score": 0.00697, "epss_percentile": 0.7141}, "CVE-2021-31216": {"epss_score": 0.00181, "epss_percentile": 0.40123}, "CVE-2021-31217": {"epss_score": 0.00305, "epss_percentile": 0.53385}, "CVE-2021-31220": {"epss_score": 0.00067, "epss_percentile": 0.21123}, "CVE-2021-31221": {"epss_score": 0.0007, "epss_percentile": 0.21822}, "CVE-2021-31222": {"epss_score": 0.00063, "epss_percentile": 0.20048}, "CVE-2021-31223": {"epss_score": 0.00087, "epss_percentile": 0.25596}, "CVE-2021-31224": {"epss_score": 0.0007, "epss_percentile": 0.21822}, "CVE-2021-31225": {"epss_score": 0.00082, "epss_percentile": 0.24434}, "CVE-2021-31226": {"epss_score": 0.01697, "epss_percentile": 0.81818}, "CVE-2021-31227": {"epss_score": 0.00217, "epss_percentile": 0.44331}, "CVE-2021-31228": {"epss_score": 0.0028, "epss_percentile": 0.51081}, "CVE-2021-31229": {"epss_score": 0.01848, "epss_percentile": 0.82527}, "CVE-2021-31231": {"epss_score": 0.0007, "epss_percentile": 0.21984}, "CVE-2021-31232": {"epss_score": 0.00091, "epss_percentile": 0.26277}, "CVE-2021-31233": {"epss_score": 0.00206, "epss_percentile": 0.42951}, "CVE-2021-31239": {"epss_score": 0.04859, "epss_percentile": 0.8922}, "CVE-2021-31240": {"epss_score": 0.00026, "epss_percentile": 0.06673}, "CVE-2021-31245": {"epss_score": 0.01342, "epss_percentile": 0.79598}, "CVE-2021-31249": {"epss_score": 0.9258, "epss_percentile": 0.99728}, "CVE-2021-31250": {"epss_score": 0.89372, "epss_percentile": 0.99522}, "CVE-2021-31251": {"epss_score": 0.09587, "epss_percentile": 0.9261}, "CVE-2021-31252": {"epss_score": 0.02868, "epss_percentile": 0.85867}, "CVE-2021-31254": {"epss_score": 0.00196, "epss_percentile": 0.41727}, "CVE-2021-31255": {"epss_score": 0.00196, "epss_percentile": 0.41727}, "CVE-2021-31256": {"epss_score": 0.00124, "epss_percentile": 0.32439}, "CVE-2021-31257": {"epss_score": 0.00089, "epss_percentile": 0.25969}, "CVE-2021-31258": {"epss_score": 0.00086, "epss_percentile": 0.25355}, "CVE-2021-31259": {"epss_score": 0.00271, "epss_percentile": 0.50287}, "CVE-2021-31260": {"epss_score": 0.00089, "epss_percentile": 0.25969}, "CVE-2021-31261": {"epss_score": 0.00278, "epss_percentile": 0.50864}, "CVE-2021-31262": {"epss_score": 0.00271, "epss_percentile": 0.50287}, "CVE-2021-31272": {"epss_score": 0.0107, "epss_percentile": 0.77257}, "CVE-2021-31274": {"epss_score": 0.0001, "epss_percentile": 0.00813}, "CVE-2021-31280": {"epss_score": 0.00071, "epss_percentile": 0.22082}, "CVE-2021-31292": {"epss_score": 0.00551, "epss_percentile": 0.67371}, "CVE-2021-31294": {"epss_score": 0.00214, "epss_percentile": 0.44016}, "CVE-2021-31314": {"epss_score": 0.00153, "epss_percentile": 0.36533}, "CVE-2021-31315": {"epss_score": 0.00205, "epss_percentile": 0.42705}, "CVE-2021-31316": {"epss_score": 0.65425, "epss_percentile": 0.98417}, "CVE-2021-31317": {"epss_score": 0.00265, "epss_percentile": 0.49772}, "CVE-2021-31318": {"epss_score": 0.00265, "epss_percentile": 0.49772}, "CVE-2021-31319": {"epss_score": 0.00205, "epss_percentile": 0.42705}, "CVE-2021-31320": {"epss_score": 0.00259, "epss_percentile": 0.49091}, "CVE-2021-31321": {"epss_score": 0.00204, "epss_percentile": 0.42626}, "CVE-2021-31322": {"epss_score": 0.0028, "epss_percentile": 0.51099}, "CVE-2021-31323": {"epss_score": 0.00477, "epss_percentile": 0.64339}, "CVE-2021-31324": {"epss_score": 0.82331, "epss_percentile": 0.99188}, "CVE-2021-31326": {"epss_score": 0.0166, "epss_percentile": 0.81618}, "CVE-2021-31327": {"epss_score": 0.0037, "epss_percentile": 0.583}, "CVE-2021-31329": {"epss_score": 0.0037, "epss_percentile": 0.583}, "CVE-2021-31330": {"epss_score": 0.00589, "epss_percentile": 0.68523}, "CVE-2021-31337": {"epss_score": 0.00622, "epss_percentile": 0.69496}, "CVE-2021-31338": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2021-31339": {"epss_score": 0.00178, "epss_percentile": 0.3965}, "CVE-2021-31340": {"epss_score": 0.00482, "epss_percentile": 0.64532}, "CVE-2021-31341": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2021-31342": {"epss_score": 0.00578, "epss_percentile": 0.68184}, "CVE-2021-31343": {"epss_score": 0.00783, "epss_percentile": 0.73227}, "CVE-2021-31344": {"epss_score": 0.00911, "epss_percentile": 0.75326}, "CVE-2021-31345": {"epss_score": 0.01246, "epss_percentile": 0.78847}, "CVE-2021-31346": {"epss_score": 0.02496, "epss_percentile": 0.84907}, "CVE-2021-31347": {"epss_score": 0.01168, "epss_percentile": 0.78195}, "CVE-2021-31348": {"epss_score": 0.00858, "epss_percentile": 0.74502}, "CVE-2021-31349": {"epss_score": 0.00752, "epss_percentile": 0.72653}, "CVE-2021-31350": {"epss_score": 0.00342, "epss_percentile": 0.564}, "CVE-2021-31351": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-31352": {"epss_score": 0.00122, "epss_percentile": 0.32066}, "CVE-2021-31353": {"epss_score": 0.0041, "epss_percentile": 0.60831}, "CVE-2021-31354": {"epss_score": 0.00279, "epss_percentile": 0.5097}, "CVE-2021-31355": {"epss_score": 0.00329, "epss_percentile": 0.55404}, "CVE-2021-31356": {"epss_score": 0.001, "epss_percentile": 0.28451}, "CVE-2021-31357": {"epss_score": 0.00217, "epss_percentile": 0.44256}, "CVE-2021-31358": {"epss_score": 0.00217, "epss_percentile": 0.44256}, "CVE-2021-31359": {"epss_score": 0.00027, "epss_percentile": 0.06832}, "CVE-2021-31360": {"epss_score": 0.00038, "epss_percentile": 0.11303}, "CVE-2021-31361": {"epss_score": 0.00458, "epss_percentile": 0.63422}, "CVE-2021-31362": {"epss_score": 0.00084, "epss_percentile": 0.24933}, "CVE-2021-31363": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-31364": {"epss_score": 0.00224, "epss_percentile": 0.45058}, "CVE-2021-31365": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-31366": {"epss_score": 0.0023, "epss_percentile": 0.45734}, "CVE-2021-31367": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2021-31368": {"epss_score": 0.00513, "epss_percentile": 0.65876}, "CVE-2021-31369": {"epss_score": 0.00268, "epss_percentile": 0.50092}, "CVE-2021-31370": {"epss_score": 0.00084, "epss_percentile": 0.24933}, "CVE-2021-31371": {"epss_score": 0.00215, "epss_percentile": 0.44107}, "CVE-2021-31372": {"epss_score": 0.00521, "epss_percentile": 0.66222}, "CVE-2021-31373": {"epss_score": 0.0028, "epss_percentile": 0.51087}, "CVE-2021-31374": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-31375": {"epss_score": 0.00207, "epss_percentile": 0.43137}, "CVE-2021-31376": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-31377": {"epss_score": 0.00034, "epss_percentile": 0.09531}, "CVE-2021-31378": {"epss_score": 0.00275, "epss_percentile": 0.50678}, "CVE-2021-31379": {"epss_score": 0.00345, "epss_percentile": 0.56593}, "CVE-2021-31380": {"epss_score": 0.00174, "epss_percentile": 0.39218}, "CVE-2021-31381": {"epss_score": 0.00731, "epss_percentile": 0.72166}, "CVE-2021-31382": {"epss_score": 0.00216, "epss_percentile": 0.44193}, "CVE-2021-31383": {"epss_score": 0.00463, "epss_percentile": 0.63698}, "CVE-2021-31384": {"epss_score": 0.00365, "epss_percentile": 0.57976}, "CVE-2021-31385": {"epss_score": 0.00709, "epss_percentile": 0.71691}, "CVE-2021-31386": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2021-31399": {"epss_score": 0.00213, "epss_percentile": 0.4385}, "CVE-2021-31400": {"epss_score": 0.00408, "epss_percentile": 0.60675}, "CVE-2021-31401": {"epss_score": 0.00498, "epss_percentile": 0.65217}, "CVE-2021-31402": {"epss_score": 0.00353, "epss_percentile": 0.5717}, "CVE-2021-31403": {"epss_score": 0.00116, "epss_percentile": 0.31178}, "CVE-2021-31404": {"epss_score": 0.00045, "epss_percentile": 0.14065}, "CVE-2021-31405": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2021-31406": {"epss_score": 0.00054, "epss_percentile": 0.17226}, "CVE-2021-31407": {"epss_score": 0.01802, "epss_percentile": 0.82332}, "CVE-2021-31408": {"epss_score": 0.00048, "epss_percentile": 0.14947}, "CVE-2021-31409": {"epss_score": 0.00724, "epss_percentile": 0.72037}, "CVE-2021-31410": {"epss_score": 0.0028, "epss_percentile": 0.51037}, "CVE-2021-31411": {"epss_score": 0.00049, "epss_percentile": 0.15436}, "CVE-2021-31412": {"epss_score": 0.00686, "epss_percentile": 0.71162}, "CVE-2021-31414": {"epss_score": 0.02481, "epss_percentile": 0.84874}, "CVE-2021-31417": {"epss_score": 0.00081, "epss_percentile": 0.24343}, "CVE-2021-31418": {"epss_score": 0.0009, "epss_percentile": 0.2612}, "CVE-2021-31419": {"epss_score": 0.0009, "epss_percentile": 0.2612}, "CVE-2021-31420": {"epss_score": 0.00099, "epss_percentile": 0.28384}, "CVE-2021-31421": {"epss_score": 0.00134, "epss_percentile": 0.33838}, "CVE-2021-31422": {"epss_score": 0.00084, "epss_percentile": 0.24918}, "CVE-2021-31423": {"epss_score": 0.00078, "epss_percentile": 0.23779}, "CVE-2021-31424": {"epss_score": 0.00099, "epss_percentile": 0.28384}, "CVE-2021-31425": {"epss_score": 0.00076, "epss_percentile": 0.2325}, "CVE-2021-31426": {"epss_score": 0.00076, "epss_percentile": 0.2325}, "CVE-2021-31427": {"epss_score": 0.00074, "epss_percentile": 0.22839}, "CVE-2021-31428": {"epss_score": 0.00109, "epss_percentile": 0.29909}, "CVE-2021-31429": {"epss_score": 0.00109, "epss_percentile": 0.29909}, "CVE-2021-31430": {"epss_score": 0.00078, "epss_percentile": 0.23779}, "CVE-2021-31431": {"epss_score": 0.00078, "epss_percentile": 0.23779}, "CVE-2021-31432": {"epss_score": 0.00087, "epss_percentile": 0.25541}, "CVE-2021-31433": {"epss_score": 0.03868, "epss_percentile": 0.87876}, "CVE-2021-31434": {"epss_score": 0.03868, "epss_percentile": 0.87876}, "CVE-2021-31435": {"epss_score": 0.00351, "epss_percentile": 0.57047}, "CVE-2021-31436": {"epss_score": 0.06075, "epss_percentile": 0.90457}, "CVE-2021-31437": {"epss_score": 0.03868, "epss_percentile": 0.87876}, "CVE-2021-31438": {"epss_score": 0.06075, "epss_percentile": 0.90457}, "CVE-2021-31439": {"epss_score": 0.01035, "epss_percentile": 0.76905}, "CVE-2021-31440": {"epss_score": 0.00667, "epss_percentile": 0.70716}, "CVE-2021-31441": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-31442": {"epss_score": 0.06075, "epss_percentile": 0.90457}, "CVE-2021-31443": {"epss_score": 0.06229, "epss_percentile": 0.90586}, "CVE-2021-31444": {"epss_score": 0.03774, "epss_percentile": 0.87706}, "CVE-2021-31445": {"epss_score": 0.03353, "epss_percentile": 0.86967}, "CVE-2021-31446": {"epss_score": 0.04967, "epss_percentile": 0.89344}, "CVE-2021-31447": {"epss_score": 0.03353, "epss_percentile": 0.86967}, "CVE-2021-31448": {"epss_score": 0.03774, "epss_percentile": 0.87706}, "CVE-2021-31449": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-31450": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-31451": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-31452": {"epss_score": 0.06075, "epss_percentile": 0.90457}, "CVE-2021-31453": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-31454": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-31455": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-31456": {"epss_score": 0.00518, "epss_percentile": 0.66135}, "CVE-2021-31457": {"epss_score": 0.00518, "epss_percentile": 0.66135}, "CVE-2021-31458": {"epss_score": 0.00518, "epss_percentile": 0.66135}, "CVE-2021-31459": {"epss_score": 0.00518, "epss_percentile": 0.66135}, "CVE-2021-31460": {"epss_score": 0.00518, "epss_percentile": 0.66135}, "CVE-2021-31461": {"epss_score": 0.00353, "epss_percentile": 0.57174}, "CVE-2021-31462": {"epss_score": 0.0037, "epss_percentile": 0.58325}, "CVE-2021-31463": {"epss_score": 0.0037, "epss_percentile": 0.58325}, "CVE-2021-31464": {"epss_score": 0.00247, "epss_percentile": 0.47893}, "CVE-2021-31465": {"epss_score": 0.00503, "epss_percentile": 0.65439}, "CVE-2021-31466": {"epss_score": 0.00862, "epss_percentile": 0.7457}, "CVE-2021-31467": {"epss_score": 0.00247, "epss_percentile": 0.47893}, "CVE-2021-31468": {"epss_score": 0.00862, "epss_percentile": 0.7457}, "CVE-2021-31469": {"epss_score": 0.04276, "epss_percentile": 0.88482}, "CVE-2021-31470": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-31471": {"epss_score": 0.06222, "epss_percentile": 0.90581}, "CVE-2021-31472": {"epss_score": 0.06075, "epss_percentile": 0.90457}, "CVE-2021-31473": {"epss_score": 0.06075, "epss_percentile": 0.90457}, "CVE-2021-31474": {"epss_score": 0.53629, "epss_percentile": 0.97887}, "CVE-2021-31475": {"epss_score": 0.12284, "epss_percentile": 0.93622}, "CVE-2021-31476": {"epss_score": 0.00508, "epss_percentile": 0.65708}, "CVE-2021-31477": {"epss_score": 0.04419, "epss_percentile": 0.88667}, "CVE-2021-31478": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31479": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31480": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-31481": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31482": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31483": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31484": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31485": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31486": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31487": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31488": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31489": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31490": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31491": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31492": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31493": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31494": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31495": {"epss_score": 0.00973, "epss_percentile": 0.76162}, "CVE-2021-31496": {"epss_score": 0.00345, "epss_percentile": 0.56549}, "CVE-2021-31497": {"epss_score": 0.00345, "epss_percentile": 0.56549}, "CVE-2021-31498": {"epss_score": 0.00227, "epss_percentile": 0.45421}, "CVE-2021-31499": {"epss_score": 0.00345, "epss_percentile": 0.56549}, "CVE-2021-31500": {"epss_score": 0.00345, "epss_percentile": 0.56549}, "CVE-2021-31501": {"epss_score": 0.00227, "epss_percentile": 0.45421}, "CVE-2021-31502": {"epss_score": 0.00345, "epss_percentile": 0.56549}, "CVE-2021-31503": {"epss_score": 0.00345, "epss_percentile": 0.56549}, "CVE-2021-31504": {"epss_score": 0.00345, "epss_percentile": 0.56549}, "CVE-2021-31505": {"epss_score": 0.00314, "epss_percentile": 0.54153}, "CVE-2021-31506": {"epss_score": 0.00227, "epss_percentile": 0.45421}, "CVE-2021-31507": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31508": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31509": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31510": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31511": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31512": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31513": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31514": {"epss_score": 0.00477, "epss_percentile": 0.64315}, "CVE-2021-31515": {"epss_score": 0.01324, "epss_percentile": 0.7946}, "CVE-2021-31516": {"epss_score": 0.01324, "epss_percentile": 0.7946}, "CVE-2021-31517": {"epss_score": 0.00688, "epss_percentile": 0.71202}, "CVE-2021-31518": {"epss_score": 0.00688, "epss_percentile": 0.71202}, "CVE-2021-31519": {"epss_score": 0.00093, "epss_percentile": 0.26655}, "CVE-2021-31520": {"epss_score": 0.01498, "epss_percentile": 0.80697}, "CVE-2021-31521": {"epss_score": 0.00405, "epss_percentile": 0.60455}, "CVE-2021-31522": {"epss_score": 0.03405, "epss_percentile": 0.87074}, "CVE-2021-31523": {"epss_score": 0.00042, "epss_percentile": 0.12585}, "CVE-2021-31525": {"epss_score": 0.00013, "epss_percentile": 0.01548}, "CVE-2021-31530": {"epss_score": 0.0494, "epss_percentile": 0.89306}, "CVE-2021-31531": {"epss_score": 0.05639, "epss_percentile": 0.90074}, "CVE-2021-31532": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2021-31535": {"epss_score": 0.0206, "epss_percentile": 0.83442}, "CVE-2021-31537": {"epss_score": 0.72054, "epss_percentile": 0.98694}, "CVE-2021-31538": {"epss_score": 0.00419, "epss_percentile": 0.61376}, "CVE-2021-31539": {"epss_score": 0.00025, "epss_percentile": 0.06307}, "CVE-2021-31540": {"epss_score": 0.00035, "epss_percentile": 0.09896}, "CVE-2021-31542": {"epss_score": 0.05192, "epss_percentile": 0.89596}, "CVE-2021-31545": {"epss_score": 0.002, "epss_percentile": 0.42244}, "CVE-2021-31546": {"epss_score": 0.00111, "epss_percentile": 0.30406}, "CVE-2021-31547": {"epss_score": 0.0017, "epss_percentile": 0.38733}, "CVE-2021-31548": {"epss_score": 0.0011, "epss_percentile": 0.30206}, "CVE-2021-31549": {"epss_score": 0.00177, "epss_percentile": 0.395}, "CVE-2021-31550": {"epss_score": 0.00219, "epss_percentile": 0.44482}, "CVE-2021-31551": {"epss_score": 0.00225, "epss_percentile": 0.45115}, "CVE-2021-31552": {"epss_score": 0.00083, "epss_percentile": 0.24769}, "CVE-2021-31553": {"epss_score": 0.00672, "epss_percentile": 0.70824}, "CVE-2021-31554": {"epss_score": 0.00092, "epss_percentile": 0.2658}, "CVE-2021-31555": {"epss_score": 0.0021, "epss_percentile": 0.43471}, "CVE-2021-31556": {"epss_score": 0.00657, "epss_percentile": 0.70476}, "CVE-2021-31558": {"epss_score": 0.00883, "epss_percentile": 0.74902}, "CVE-2021-31559": {"epss_score": 0.00198, "epss_percentile": 0.42032}, "CVE-2021-31562": {"epss_score": 0.00088, "epss_percentile": 0.25792}, "CVE-2021-31566": {"epss_score": 0.00036, "epss_percentile": 0.10408}, "CVE-2021-31567": {"epss_score": 0.01019, "epss_percentile": 0.76727}, "CVE-2021-31571": {"epss_score": 0.01008, "epss_percentile": 0.76571}, "CVE-2021-31572": {"epss_score": 0.01008, "epss_percentile": 0.76571}, "CVE-2021-31573": {"epss_score": 0.02568, "epss_percentile": 0.8512}, "CVE-2021-31574": {"epss_score": 0.02568, "epss_percentile": 0.8512}, "CVE-2021-31575": {"epss_score": 0.02568, "epss_percentile": 0.8512}, "CVE-2021-31576": {"epss_score": 0.00755, "epss_percentile": 0.72719}, "CVE-2021-31577": {"epss_score": 0.03563, "epss_percentile": 0.87356}, "CVE-2021-31578": {"epss_score": 0.03678, "epss_percentile": 0.87555}, "CVE-2021-31579": {"epss_score": 0.00465, "epss_percentile": 0.6376}, "CVE-2021-31580": {"epss_score": 0.00867, "epss_percentile": 0.74654}, "CVE-2021-31581": {"epss_score": 0.15575, "epss_percentile": 0.94461}, "CVE-2021-31583": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2021-31584": {"epss_score": 0.00368, "epss_percentile": 0.58182}, "CVE-2021-31585": {"epss_score": 0.0018, "epss_percentile": 0.3987}, "CVE-2021-31586": {"epss_score": 0.00477, "epss_percentile": 0.64302}, "CVE-2021-31589": {"epss_score": 0.27167, "epss_percentile": 0.96215}, "CVE-2021-31590": {"epss_score": 0.01493, "epss_percentile": 0.80643}, "CVE-2021-31597": {"epss_score": 0.0033, "epss_percentile": 0.55431}, "CVE-2021-31598": {"epss_score": 0.0083, "epss_percentile": 0.74027}, "CVE-2021-31599": {"epss_score": 0.00886, "epss_percentile": 0.7495}, "CVE-2021-31600": {"epss_score": 0.00216, "epss_percentile": 0.44142}, "CVE-2021-31601": {"epss_score": 0.02063, "epss_percentile": 0.83447}, "CVE-2021-31602": {"epss_score": 0.92774, "epss_percentile": 0.99746}, "CVE-2021-31604": {"epss_score": 0.00111, "epss_percentile": 0.30373}, "CVE-2021-31605": {"epss_score": 0.02194, "epss_percentile": 0.83949}, "CVE-2021-31606": {"epss_score": 0.0108, "epss_percentile": 0.77365}, "CVE-2021-31607": {"epss_score": 0.04548, "epss_percentile": 0.88836}, "CVE-2021-31608": {"epss_score": 0.00263, "epss_percentile": 0.49483}, "CVE-2021-31609": {"epss_score": 0.00129, "epss_percentile": 0.33099}, "CVE-2021-31610": {"epss_score": 0.00204, "epss_percentile": 0.42622}, "CVE-2021-31611": {"epss_score": 0.00098, "epss_percentile": 0.2779}, "CVE-2021-31612": {"epss_score": 0.00134, "epss_percentile": 0.33848}, "CVE-2021-31613": {"epss_score": 0.00207, "epss_percentile": 0.4319}, "CVE-2021-31615": {"epss_score": 0.00186, "epss_percentile": 0.40655}, "CVE-2021-31616": {"epss_score": 0.02202, "epss_percentile": 0.83985}, "CVE-2021-31617": {"epss_score": 0.03008, "epss_percentile": 0.8619}, "CVE-2021-31618": {"epss_score": 0.18517, "epss_percentile": 0.95027}, "CVE-2021-31624": {"epss_score": 0.00116, "epss_percentile": 0.31196}, "CVE-2021-31627": {"epss_score": 0.00116, "epss_percentile": 0.31196}, "CVE-2021-31630": {"epss_score": 0.8678, "epss_percentile": 0.99396}, "CVE-2021-31631": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2021-31632": {"epss_score": 0.00621, "epss_percentile": 0.69492}, "CVE-2021-31635": {"epss_score": 0.01256, "epss_percentile": 0.78938}, "CVE-2021-31637": {"epss_score": 0.00321, "epss_percentile": 0.5468}, "CVE-2021-31641": {"epss_score": 0.01159, "epss_percentile": 0.78128}, "CVE-2021-31642": {"epss_score": 0.30213, "epss_percentile": 0.96519}, "CVE-2021-31643": {"epss_score": 0.0381, "epss_percentile": 0.87759}, "CVE-2021-31645": {"epss_score": 0.00801, "epss_percentile": 0.73568}, "CVE-2021-31646": {"epss_score": 0.00588, "epss_percentile": 0.68499}, "CVE-2021-31649": {"epss_score": 0.00405, "epss_percentile": 0.60494}, "CVE-2021-31650": {"epss_score": 0.00488, "epss_percentile": 0.64835}, "CVE-2021-31651": {"epss_score": 0.00063, "epss_percentile": 0.1988}, "CVE-2021-31655": {"epss_score": 0.00397, "epss_percentile": 0.60045}, "CVE-2021-31658": {"epss_score": 0.00291, "epss_percentile": 0.52185}, "CVE-2021-31659": {"epss_score": 0.00105, "epss_percentile": 0.29393}, "CVE-2021-31660": {"epss_score": 0.00335, "epss_percentile": 0.55831}, "CVE-2021-31661": {"epss_score": 0.00335, "epss_percentile": 0.55831}, "CVE-2021-31662": {"epss_score": 0.00335, "epss_percentile": 0.55831}, "CVE-2021-31663": {"epss_score": 0.00446, "epss_percentile": 0.62893}, "CVE-2021-31664": {"epss_score": 0.00335, "epss_percentile": 0.55831}, "CVE-2021-31671": {"epss_score": 0.00182, "epss_percentile": 0.40268}, "CVE-2021-31673": {"epss_score": 0.02705, "epss_percentile": 0.85465}, "CVE-2021-31674": {"epss_score": 0.02158, "epss_percentile": 0.83818}, "CVE-2021-31676": {"epss_score": 0.0028, "epss_percentile": 0.51084}, "CVE-2021-31677": {"epss_score": 0.0014, "epss_percentile": 0.34766}, "CVE-2021-31678": {"epss_score": 0.00124, "epss_percentile": 0.3244}, "CVE-2021-31679": {"epss_score": 0.00117, "epss_percentile": 0.31352}, "CVE-2021-31680": {"epss_score": 0.00031, "epss_percentile": 0.08541}, "CVE-2021-31681": {"epss_score": 0.00031, "epss_percentile": 0.08541}, "CVE-2021-31682": {"epss_score": 0.41198, "epss_percentile": 0.97258}, "CVE-2021-31684": {"epss_score": 0.00117, "epss_percentile": 0.31337}, "CVE-2021-31693": {"epss_score": 0.00172, "epss_percentile": 0.38937}, "CVE-2021-31698": {"epss_score": 0.00424, "epss_percentile": 0.61659}, "CVE-2021-31701": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2021-31702": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-31703": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-31707": {"epss_score": 0.01699, "epss_percentile": 0.81823}, "CVE-2021-31711": {"epss_score": 0.00217, "epss_percentile": 0.4424}, "CVE-2021-31712": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2021-31718": {"epss_score": 0.00479, "epss_percentile": 0.64434}, "CVE-2021-31721": {"epss_score": 0.00405, "epss_percentile": 0.60485}, "CVE-2021-31726": {"epss_score": 0.05536, "epss_percentile": 0.89971}, "CVE-2021-31727": {"epss_score": 0.00221, "epss_percentile": 0.44631}, "CVE-2021-31728": {"epss_score": 0.17696, "epss_percentile": 0.94891}, "CVE-2021-31731": {"epss_score": 0.00593, "epss_percentile": 0.68631}, "CVE-2021-31737": {"epss_score": 0.22778, "epss_percentile": 0.95686}, "CVE-2021-31738": {"epss_score": 0.00345, "epss_percentile": 0.56555}, "CVE-2021-31739": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2021-31740": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2021-31745": {"epss_score": 0.00346, "epss_percentile": 0.56711}, "CVE-2021-31746": {"epss_score": 0.01381, "epss_percentile": 0.79866}, "CVE-2021-31747": {"epss_score": 0.00102, "epss_percentile": 0.28717}, "CVE-2021-31755": {"epss_score": 0.94261, "epss_percentile": 0.99929}, "CVE-2021-31756": {"epss_score": 0.01511, "epss_percentile": 0.80774}, "CVE-2021-31757": {"epss_score": 0.01962, "epss_percentile": 0.83064}, "CVE-2021-31758": {"epss_score": 0.40111, "epss_percentile": 0.97196}, "CVE-2021-31760": {"epss_score": 0.39871, "epss_percentile": 0.97185}, "CVE-2021-31761": {"epss_score": 0.81918, "epss_percentile": 0.99164}, "CVE-2021-31762": {"epss_score": 0.22718, "epss_percentile": 0.95673}, "CVE-2021-31769": {"epss_score": 0.05068, "epss_percentile": 0.8946}, "CVE-2021-31776": {"epss_score": 0.00048, "epss_percentile": 0.14972}, "CVE-2021-31777": {"epss_score": 0.00287, "epss_percentile": 0.51845}, "CVE-2021-31778": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-31779": {"epss_score": 0.00146, "epss_percentile": 0.35621}, "CVE-2021-31780": {"epss_score": 0.00354, "epss_percentile": 0.57208}, "CVE-2021-31783": {"epss_score": 0.00176, "epss_percentile": 0.39458}, "CVE-2021-31784": {"epss_score": 0.00321, "epss_percentile": 0.54676}, "CVE-2021-31785": {"epss_score": 0.00104, "epss_percentile": 0.29142}, "CVE-2021-31786": {"epss_score": 0.00104, "epss_percentile": 0.29142}, "CVE-2021-31787": {"epss_score": 0.00134, "epss_percentile": 0.33848}, "CVE-2021-31791": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2021-31792": {"epss_score": 0.00379, "epss_percentile": 0.58905}, "CVE-2021-31793": {"epss_score": 0.017, "epss_percentile": 0.81833}, "CVE-2021-31794": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2021-31795": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2021-31796": {"epss_score": 0.00609, "epss_percentile": 0.69126}, "CVE-2021-31797": {"epss_score": 0.00085, "epss_percentile": 0.25051}, "CVE-2021-31798": {"epss_score": 0.00113, "epss_percentile": 0.30717}, "CVE-2021-31799": {"epss_score": 0.00351, "epss_percentile": 0.57047}, "CVE-2021-31800": {"epss_score": 0.39208, "epss_percentile": 0.97146}, "CVE-2021-31802": {"epss_score": 0.18407, "epss_percentile": 0.95013}, "CVE-2021-31803": {"epss_score": 0.00375, "epss_percentile": 0.58627}, "CVE-2021-31804": {"epss_score": 0.00194, "epss_percentile": 0.4155}, "CVE-2021-31805": {"epss_score": 0.93956, "epss_percentile": 0.99873}, "CVE-2021-31806": {"epss_score": 0.82652, "epss_percentile": 0.99204}, "CVE-2021-31807": {"epss_score": 0.33801, "epss_percentile": 0.96804}, "CVE-2021-31808": {"epss_score": 0.0033, "epss_percentile": 0.5549}, "CVE-2021-31810": {"epss_score": 0.00582, "epss_percentile": 0.68298}, "CVE-2021-31811": {"epss_score": 0.00545, "epss_percentile": 0.67168}, "CVE-2021-31812": {"epss_score": 0.0004, "epss_percentile": 0.11877}, "CVE-2021-31813": {"epss_score": 0.2463, "epss_percentile": 0.95942}, "CVE-2021-31814": {"epss_score": 0.00039, "epss_percentile": 0.11571}, "CVE-2021-31815": {"epss_score": 0.0001, "epss_percentile": 0.00854}, "CVE-2021-31816": {"epss_score": 0.00156, "epss_percentile": 0.36902}, "CVE-2021-31817": {"epss_score": 0.00156, "epss_percentile": 0.36902}, "CVE-2021-31818": {"epss_score": 0.00232, "epss_percentile": 0.45874}, "CVE-2021-31819": {"epss_score": 0.01864, "epss_percentile": 0.826}, "CVE-2021-31820": {"epss_score": 0.00137, "epss_percentile": 0.34342}, "CVE-2021-31821": {"epss_score": 0.00028, "epss_percentile": 0.07447}, "CVE-2021-31822": {"epss_score": 0.00086, "epss_percentile": 0.25279}, "CVE-2021-31826": {"epss_score": 0.01478, "epss_percentile": 0.80557}, "CVE-2021-31827": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-31828": {"epss_score": 0.00187, "epss_percentile": 0.40776}, "CVE-2021-31829": {"epss_score": 0.00081, "epss_percentile": 0.24339}, "CVE-2021-31830": {"epss_score": 0.00426, "epss_percentile": 0.61743}, "CVE-2021-31831": {"epss_score": 0.00319, "epss_percentile": 0.54571}, "CVE-2021-31832": {"epss_score": 0.00403, "epss_percentile": 0.60362}, "CVE-2021-31833": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2021-31834": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-31835": {"epss_score": 0.00249, "epss_percentile": 0.48047}, "CVE-2021-31836": {"epss_score": 0.00047, "epss_percentile": 0.14832}, "CVE-2021-31837": {"epss_score": 0.00066, "epss_percentile": 0.2074}, "CVE-2021-31838": {"epss_score": 0.02289, "epss_percentile": 0.84276}, "CVE-2021-31839": {"epss_score": 0.00039, "epss_percentile": 0.11429}, "CVE-2021-31840": {"epss_score": 0.00044, "epss_percentile": 0.13524}, "CVE-2021-31841": {"epss_score": 0.00019, "epss_percentile": 0.04204}, "CVE-2021-31842": {"epss_score": 0.00048, "epss_percentile": 0.15028}, "CVE-2021-31843": {"epss_score": 0.00034, "epss_percentile": 0.09688}, "CVE-2021-31844": {"epss_score": 0.0006, "epss_percentile": 0.1899}, "CVE-2021-31845": {"epss_score": 0.00962, "epss_percentile": 0.75987}, "CVE-2021-31847": {"epss_score": 0.00034, "epss_percentile": 0.09511}, "CVE-2021-31848": {"epss_score": 0.00312, "epss_percentile": 0.5397}, "CVE-2021-31849": {"epss_score": 0.00395, "epss_percentile": 0.59837}, "CVE-2021-31850": {"epss_score": 0.00285, "epss_percentile": 0.51674}, "CVE-2021-31851": {"epss_score": 0.00783, "epss_percentile": 0.73229}, "CVE-2021-31852": {"epss_score": 0.00912, "epss_percentile": 0.75358}, "CVE-2021-31853": {"epss_score": 0.00032, "epss_percentile": 0.09113}, "CVE-2021-31854": {"epss_score": 0.00325, "epss_percentile": 0.54997}, "CVE-2021-31855": {"epss_score": 0.00138, "epss_percentile": 0.34366}, "CVE-2021-31856": {"epss_score": 0.79924, "epss_percentile": 0.99063}, "CVE-2021-31857": {"epss_score": 0.00512, "epss_percentile": 0.65872}, "CVE-2021-31858": {"epss_score": 0.00234, "epss_percentile": 0.4617}, "CVE-2021-31859": {"epss_score": 0.00084, "epss_percentile": 0.24916}, "CVE-2021-31862": {"epss_score": 0.41302, "epss_percentile": 0.97265}, "CVE-2021-31863": {"epss_score": 0.0079, "epss_percentile": 0.73365}, "CVE-2021-31864": {"epss_score": 0.00217, "epss_percentile": 0.44278}, "CVE-2021-31865": {"epss_score": 0.00391, "epss_percentile": 0.59593}, "CVE-2021-31866": {"epss_score": 0.00442, "epss_percentile": 0.62738}, "CVE-2021-31867": {"epss_score": 0.00038, "epss_percentile": 0.1118}, "CVE-2021-31868": {"epss_score": 0.00117, "epss_percentile": 0.31222}, "CVE-2021-31869": {"epss_score": 7e-05, "epss_percentile": 0.00425}, "CVE-2021-31870": {"epss_score": 0.01279, "epss_percentile": 0.79132}, "CVE-2021-31871": {"epss_score": 0.01589, "epss_percentile": 0.81197}, "CVE-2021-31872": {"epss_score": 0.01173, "epss_percentile": 0.78241}, "CVE-2021-31873": {"epss_score": 0.00889, "epss_percentile": 0.75015}, "CVE-2021-31874": {"epss_score": 0.01217, "epss_percentile": 0.786}, "CVE-2021-31875": {"epss_score": 0.0055, "epss_percentile": 0.67348}, "CVE-2021-31876": {"epss_score": 0.00487, "epss_percentile": 0.64784}, "CVE-2021-31878": {"epss_score": 0.00731, "epss_percentile": 0.72183}, "CVE-2021-31879": {"epss_score": 0.00154, "epss_percentile": 0.36704}, "CVE-2021-31881": {"epss_score": 0.01414, "epss_percentile": 0.80123}, "CVE-2021-31882": {"epss_score": 0.01414, "epss_percentile": 0.80126}, "CVE-2021-31883": {"epss_score": 0.01414, "epss_percentile": 0.80123}, "CVE-2021-31884": {"epss_score": 0.00725, "epss_percentile": 0.72062}, "CVE-2021-31885": {"epss_score": 0.00386, "epss_percentile": 0.59253}, "CVE-2021-31886": {"epss_score": 0.0653, "epss_percentile": 0.90824}, "CVE-2021-31887": {"epss_score": 0.01721, "epss_percentile": 0.81933}, "CVE-2021-31888": {"epss_score": 0.02827, "epss_percentile": 0.85767}, "CVE-2021-31889": {"epss_score": 0.01577, "epss_percentile": 0.81117}, "CVE-2021-31890": {"epss_score": 0.02496, "epss_percentile": 0.84909}, "CVE-2021-31891": {"epss_score": 0.04575, "epss_percentile": 0.88868}, "CVE-2021-31892": {"epss_score": 0.00104, "epss_percentile": 0.29226}, "CVE-2021-31893": {"epss_score": 0.00162, "epss_percentile": 0.37646}, "CVE-2021-31894": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2021-31895": {"epss_score": 0.01162, "epss_percentile": 0.78154}, "CVE-2021-31897": {"epss_score": 0.00011, "epss_percentile": 0.00974}, "CVE-2021-31898": {"epss_score": 2e-05, "epss_percentile": 0.0003}, "CVE-2021-31899": {"epss_score": 0.00011, "epss_percentile": 0.00953}, "CVE-2021-31900": {"epss_score": 3e-05, "epss_percentile": 0.00063}, "CVE-2021-31901": {"epss_score": 3e-05, "epss_percentile": 0.00072}, "CVE-2021-31902": {"epss_score": 2e-05, "epss_percentile": 0.00056}, "CVE-2021-31903": {"epss_score": 5e-05, "epss_percentile": 0.00181}, "CVE-2021-31904": {"epss_score": 0.00012, "epss_percentile": 0.0131}, "CVE-2021-31905": {"epss_score": 3e-05, "epss_percentile": 0.00077}, "CVE-2021-31906": {"epss_score": 2e-05, "epss_percentile": 0.00055}, "CVE-2021-31907": {"epss_score": 3e-05, "epss_percentile": 0.00068}, "CVE-2021-31908": {"epss_score": 8e-05, "epss_percentile": 0.00529}, "CVE-2021-31909": {"epss_score": 0.00149, "epss_percentile": 0.36026}, "CVE-2021-31910": {"epss_score": 6e-05, "epss_percentile": 0.00247}, "CVE-2021-31911": {"epss_score": 0.00015, "epss_percentile": 0.02244}, "CVE-2021-31912": {"epss_score": 6e-05, "epss_percentile": 0.00242}, "CVE-2021-31913": {"epss_score": 2e-05, "epss_percentile": 0.00052}, "CVE-2021-31914": {"epss_score": 0.0004, "epss_percentile": 0.12045}, "CVE-2021-31915": {"epss_score": 0.00158, "epss_percentile": 0.37213}, "CVE-2021-31916": {"epss_score": 0.00025, "epss_percentile": 0.06305}, "CVE-2021-31917": {"epss_score": 0.00431, "epss_percentile": 0.62051}, "CVE-2021-31918": {"epss_score": 0.00208, "epss_percentile": 0.43281}, "CVE-2021-31919": {"epss_score": 0.00353, "epss_percentile": 0.57162}, "CVE-2021-31920": {"epss_score": 0.00191, "epss_percentile": 0.41203}, "CVE-2021-31921": {"epss_score": 0.00424, "epss_percentile": 0.61638}, "CVE-2021-31922": {"epss_score": 0.00189, "epss_percentile": 0.40944}, "CVE-2021-31923": {"epss_score": 0.00221, "epss_percentile": 0.44689}, "CVE-2021-31924": {"epss_score": 0.00083, "epss_percentile": 0.24709}, "CVE-2021-31925": {"epss_score": 0.00361, "epss_percentile": 0.57746}, "CVE-2021-31926": {"epss_score": 0.00151, "epss_percentile": 0.36259}, "CVE-2021-31927": {"epss_score": 0.00172, "epss_percentile": 0.38942}, "CVE-2021-31928": {"epss_score": 0.00521, "epss_percentile": 0.66222}, "CVE-2021-31929": {"epss_score": 0.00152, "epss_percentile": 0.36457}, "CVE-2021-31930": {"epss_score": 0.01056, "epss_percentile": 0.77125}, "CVE-2021-31932": {"epss_score": 0.07281, "epss_percentile": 0.91382}, "CVE-2021-31933": {"epss_score": 0.14784, "epss_percentile": 0.94284}, "CVE-2021-31934": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2021-31935": {"epss_score": 0.00174, "epss_percentile": 0.39184}, "CVE-2021-31936": {"epss_score": 0.09678, "epss_percentile": 0.92656}, "CVE-2021-31937": {"epss_score": 0.01146, "epss_percentile": 0.78002}, "CVE-2021-31938": {"epss_score": 0.05084, "epss_percentile": 0.89477}, "CVE-2021-31939": {"epss_score": 0.07402, "epss_percentile": 0.91453}, "CVE-2021-31940": {"epss_score": 0.0534, "epss_percentile": 0.89761}, "CVE-2021-31941": {"epss_score": 0.05642, "epss_percentile": 0.90077}, "CVE-2021-31942": {"epss_score": 0.0534, "epss_percentile": 0.89761}, "CVE-2021-31943": {"epss_score": 0.04098, "epss_percentile": 0.88255}, "CVE-2021-31944": {"epss_score": 0.04333, "epss_percentile": 0.88562}, "CVE-2021-31945": {"epss_score": 0.01674, "epss_percentile": 0.81698}, "CVE-2021-31946": {"epss_score": 0.00698, "epss_percentile": 0.71415}, "CVE-2021-31947": {"epss_score": 0.0534, "epss_percentile": 0.89761}, "CVE-2021-31948": {"epss_score": 0.03701, "epss_percentile": 0.87591}, "CVE-2021-31949": {"epss_score": 0.01437, "epss_percentile": 0.80282}, "CVE-2021-31950": {"epss_score": 0.02264, "epss_percentile": 0.84194}, "CVE-2021-31951": {"epss_score": 0.007, "epss_percentile": 0.71475}, "CVE-2021-31952": {"epss_score": 0.007, "epss_percentile": 0.71475}, "CVE-2021-31953": {"epss_score": 0.00483, "epss_percentile": 0.64562}, "CVE-2021-31954": {"epss_score": 0.01255, "epss_percentile": 0.78927}, "CVE-2021-31955": {"epss_score": 0.06179, "epss_percentile": 0.90537}, "CVE-2021-31956": {"epss_score": 0.90724, "epss_percentile": 0.99597}, "CVE-2021-31957": {"epss_score": 0.05126, "epss_percentile": 0.89524}, "CVE-2021-31958": {"epss_score": 0.02123, "epss_percentile": 0.83686}, "CVE-2021-31959": {"epss_score": 0.03289, "epss_percentile": 0.86832}, "CVE-2021-31960": {"epss_score": 0.00403, "epss_percentile": 0.60347}, "CVE-2021-31961": {"epss_score": 0.00323, "epss_percentile": 0.54884}, "CVE-2021-31962": {"epss_score": 0.17791, "epss_percentile": 0.94906}, "CVE-2021-31963": {"epss_score": 0.06699, "epss_percentile": 0.90955}, "CVE-2021-31964": {"epss_score": 0.03892, "epss_percentile": 0.87911}, "CVE-2021-31965": {"epss_score": 0.08257, "epss_percentile": 0.91954}, "CVE-2021-31966": {"epss_score": 0.1107, "epss_percentile": 0.93209}, "CVE-2021-31967": {"epss_score": 0.04564, "epss_percentile": 0.88855}, "CVE-2021-31968": {"epss_score": 0.27537, "epss_percentile": 0.96255}, "CVE-2021-31969": {"epss_score": 0.00627, "epss_percentile": 0.69644}, "CVE-2021-31970": {"epss_score": 0.00801, "epss_percentile": 0.7357}, "CVE-2021-31971": {"epss_score": 0.0276, "epss_percentile": 0.85599}, "CVE-2021-31972": {"epss_score": 0.00425, "epss_percentile": 0.61728}, "CVE-2021-31973": {"epss_score": 0.00483, "epss_percentile": 0.64562}, "CVE-2021-31974": {"epss_score": 0.14302, "epss_percentile": 0.94183}, "CVE-2021-31975": {"epss_score": 0.14121, "epss_percentile": 0.94138}, "CVE-2021-31976": {"epss_score": 0.17342, "epss_percentile": 0.94831}, "CVE-2021-31977": {"epss_score": 0.05047, "epss_percentile": 0.89436}, "CVE-2021-31978": {"epss_score": 0.00622, "epss_percentile": 0.69494}, "CVE-2021-31979": {"epss_score": 0.14365, "epss_percentile": 0.94194}, "CVE-2021-31980": {"epss_score": 0.0507, "epss_percentile": 0.89463}, "CVE-2021-31982": {"epss_score": 0.03313, "epss_percentile": 0.86897}, "CVE-2021-31983": {"epss_score": 0.02205, "epss_percentile": 0.84}, "CVE-2021-31984": {"epss_score": 0.03458, "epss_percentile": 0.87176}, "CVE-2021-31985": {"epss_score": 0.04004, "epss_percentile": 0.88097}, "CVE-2021-31986": {"epss_score": 0.00584, "epss_percentile": 0.68373}, "CVE-2021-31987": {"epss_score": 0.00106, "epss_percentile": 0.29411}, "CVE-2021-31988": {"epss_score": 0.00615, "epss_percentile": 0.69301}, "CVE-2021-31989": {"epss_score": 0.00138, "epss_percentile": 0.34366}, "CVE-2021-31996": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-31997": {"epss_score": 0.00035, "epss_percentile": 0.10116}, "CVE-2021-31998": {"epss_score": 0.00029, "epss_percentile": 0.0761}, "CVE-2021-31999": {"epss_score": 0.0038, "epss_percentile": 0.58929}, "CVE-2021-32000": {"epss_score": 0.00017, "epss_percentile": 0.03358}, "CVE-2021-32001": {"epss_score": 0.00113, "epss_percentile": 0.30692}, "CVE-2021-32002": {"epss_score": 0.00041, "epss_percentile": 0.12442}, "CVE-2021-32003": {"epss_score": 0.00042, "epss_percentile": 0.12775}, "CVE-2021-32004": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2021-32005": {"epss_score": 0.00777, "epss_percentile": 0.7311}, "CVE-2021-32006": {"epss_score": 0.00149, "epss_percentile": 0.35948}, "CVE-2021-32007": {"epss_score": 0.00089, "epss_percentile": 0.25891}, "CVE-2021-32008": {"epss_score": 0.00683, "epss_percentile": 0.7109}, "CVE-2021-32009": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2021-32010": {"epss_score": 0.00103, "epss_percentile": 0.28925}, "CVE-2021-32012": {"epss_score": 0.00212, "epss_percentile": 0.43743}, "CVE-2021-32013": {"epss_score": 0.00212, "epss_percentile": 0.43743}, "CVE-2021-32014": {"epss_score": 0.00212, "epss_percentile": 0.43743}, "CVE-2021-32015": {"epss_score": 0.00045, "epss_percentile": 0.14059}, "CVE-2021-32016": {"epss_score": 0.00809, "epss_percentile": 0.73703}, "CVE-2021-32017": {"epss_score": 0.00233, "epss_percentile": 0.46026}, "CVE-2021-32018": {"epss_score": 0.00422, "epss_percentile": 0.61545}, "CVE-2021-32019": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-32020": {"epss_score": 0.0036, "epss_percentile": 0.57652}, "CVE-2021-32021": {"epss_score": 0.00046, "epss_percentile": 0.14413}, "CVE-2021-32022": {"epss_score": 0.00057, "epss_percentile": 0.18158}, "CVE-2021-32023": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2021-32024": {"epss_score": 0.02652, "epss_percentile": 0.85348}, "CVE-2021-32025": {"epss_score": 0.00034, "epss_percentile": 0.0975}, "CVE-2021-32027": {"epss_score": 0.00491, "epss_percentile": 0.64948}, "CVE-2021-32028": {"epss_score": 0.00467, "epss_percentile": 0.63851}, "CVE-2021-32029": {"epss_score": 0.00185, "epss_percentile": 0.40572}, "CVE-2021-32030": {"epss_score": 0.94215, "epss_percentile": 0.99918}, "CVE-2021-32032": {"epss_score": 0.0056, "epss_percentile": 0.67652}, "CVE-2021-32033": {"epss_score": 0.00161, "epss_percentile": 0.37609}, "CVE-2021-32036": {"epss_score": 0.00142, "epss_percentile": 0.35015}, "CVE-2021-32037": {"epss_score": 0.00474, "epss_percentile": 0.6414}, "CVE-2021-32039": {"epss_score": 0.00136, "epss_percentile": 0.34125}, "CVE-2021-32040": {"epss_score": 0.01129, "epss_percentile": 0.77835}, "CVE-2021-32050": {"epss_score": 0.00039, "epss_percentile": 0.11572}, "CVE-2021-32051": {"epss_score": 0.01107, "epss_percentile": 0.77627}, "CVE-2021-32052": {"epss_score": 0.01909, "epss_percentile": 0.82819}, "CVE-2021-32053": {"epss_score": 0.00452, "epss_percentile": 0.63162}, "CVE-2021-32054": {"epss_score": 0.00358, "epss_percentile": 0.57517}, "CVE-2021-32055": {"epss_score": 0.00534, "epss_percentile": 0.66796}, "CVE-2021-32056": {"epss_score": 0.00208, "epss_percentile": 0.43237}, "CVE-2021-32061": {"epss_score": 0.00387, "epss_percentile": 0.59307}, "CVE-2021-32062": {"epss_score": 0.00657, "epss_percentile": 0.7046}, "CVE-2021-32066": {"epss_score": 0.00102, "epss_percentile": 0.28768}, "CVE-2021-32067": {"epss_score": 0.002, "epss_percentile": 0.42249}, "CVE-2021-32068": {"epss_score": 0.00189, "epss_percentile": 0.40987}, "CVE-2021-32069": {"epss_score": 0.00162, "epss_percentile": 0.37686}, "CVE-2021-32070": {"epss_score": 0.00171, "epss_percentile": 0.38866}, "CVE-2021-32071": {"epss_score": 0.00561, "epss_percentile": 0.67666}, "CVE-2021-32072": {"epss_score": 0.00256, "epss_percentile": 0.48837}, "CVE-2021-32073": {"epss_score": 0.0037, "epss_percentile": 0.58327}, "CVE-2021-32074": {"epss_score": 0.00346, "epss_percentile": 0.56611}, "CVE-2021-32075": {"epss_score": 0.0057, "epss_percentile": 0.67972}, "CVE-2021-32076": {"epss_score": 0.00485, "epss_percentile": 0.64737}, "CVE-2021-32077": {"epss_score": 0.0036, "epss_percentile": 0.57665}, "CVE-2021-32078": {"epss_score": 0.00096, "epss_percentile": 0.27403}, "CVE-2021-32089": {"epss_score": 0.01639, "epss_percentile": 0.81491}, "CVE-2021-32090": {"epss_score": 0.00447, "epss_percentile": 0.62963}, "CVE-2021-32091": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-32092": {"epss_score": 0.00484, "epss_percentile": 0.64645}, "CVE-2021-32093": {"epss_score": 0.00371, "epss_percentile": 0.58353}, "CVE-2021-32094": {"epss_score": 0.00911, "epss_percentile": 0.75323}, "CVE-2021-32095": {"epss_score": 0.00287, "epss_percentile": 0.5186}, "CVE-2021-32096": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2021-32098": {"epss_score": 0.0279, "epss_percentile": 0.85665}, "CVE-2021-32099": {"epss_score": 0.58823, "epss_percentile": 0.98139}, "CVE-2021-32100": {"epss_score": 0.00697, "epss_percentile": 0.71411}, "CVE-2021-32101": {"epss_score": 0.00217, "epss_percentile": 0.44298}, "CVE-2021-32102": {"epss_score": 0.00024, "epss_percentile": 0.06015}, "CVE-2021-32103": {"epss_score": 0.00505, "epss_percentile": 0.65553}, "CVE-2021-32104": {"epss_score": 0.00024, "epss_percentile": 0.06015}, "CVE-2021-32106": {"epss_score": 0.00237, "epss_percentile": 0.46714}, "CVE-2021-32122": {"epss_score": 0.00175, "epss_percentile": 0.39294}, "CVE-2021-32132": {"epss_score": 0.0026, "epss_percentile": 0.49243}, "CVE-2021-32134": {"epss_score": 0.00271, "epss_percentile": 0.50287}, "CVE-2021-32135": {"epss_score": 0.0026, "epss_percentile": 0.49243}, "CVE-2021-32136": {"epss_score": 0.0054, "epss_percentile": 0.67006}, "CVE-2021-32137": {"epss_score": 0.00535, "epss_percentile": 0.66835}, "CVE-2021-32138": {"epss_score": 0.00242, "epss_percentile": 0.47391}, "CVE-2021-32139": {"epss_score": 0.00109, "epss_percentile": 0.2994}, "CVE-2021-32142": {"epss_score": 0.00023, "epss_percentile": 0.05419}, "CVE-2021-32156": {"epss_score": 0.08015, "epss_percentile": 0.9183}, "CVE-2021-32157": {"epss_score": 0.25282, "epss_percentile": 0.96008}, "CVE-2021-32158": {"epss_score": 0.08093, "epss_percentile": 0.91876}, "CVE-2021-32159": {"epss_score": 0.08015, "epss_percentile": 0.9183}, "CVE-2021-32160": {"epss_score": 0.08093, "epss_percentile": 0.91876}, "CVE-2021-32161": {"epss_score": 0.08093, "epss_percentile": 0.91876}, "CVE-2021-32162": {"epss_score": 0.08015, "epss_percentile": 0.9183}, "CVE-2021-32163": {"epss_score": 0.00324, "epss_percentile": 0.54955}, "CVE-2021-32172": {"epss_score": 0.70441, "epss_percentile": 0.98632}, "CVE-2021-32198": {"epss_score": 0.00568, "epss_percentile": 0.67899}, "CVE-2021-32202": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-32233": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2021-32234": {"epss_score": 0.03074, "epss_percentile": 0.86355}, "CVE-2021-32238": {"epss_score": 0.00631, "epss_percentile": 0.69724}, "CVE-2021-32243": {"epss_score": 0.00825, "epss_percentile": 0.73948}, "CVE-2021-32244": {"epss_score": 0.00126, "epss_percentile": 0.32723}, "CVE-2021-32245": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-32256": {"epss_score": 0.00115, "epss_percentile": 0.31007}, "CVE-2021-32263": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2021-32265": {"epss_score": 0.00639, "epss_percentile": 0.69935}, "CVE-2021-32268": {"epss_score": 0.00736, "epss_percentile": 0.72308}, "CVE-2021-32269": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-32270": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-32271": {"epss_score": 0.00446, "epss_percentile": 0.62896}, "CVE-2021-32272": {"epss_score": 0.0021, "epss_percentile": 0.43491}, "CVE-2021-32273": {"epss_score": 0.00147, "epss_percentile": 0.35785}, "CVE-2021-32274": {"epss_score": 0.00166, "epss_percentile": 0.38165}, "CVE-2021-32275": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-32276": {"epss_score": 0.00106, "epss_percentile": 0.29566}, "CVE-2021-32277": {"epss_score": 0.00166, "epss_percentile": 0.38165}, "CVE-2021-32278": {"epss_score": 0.00166, "epss_percentile": 0.38165}, "CVE-2021-32280": {"epss_score": 0.00091, "epss_percentile": 0.2641}, "CVE-2021-32281": {"epss_score": 0.00312, "epss_percentile": 0.5395}, "CVE-2021-32282": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-32283": {"epss_score": 0.00266, "epss_percentile": 0.4995}, "CVE-2021-32284": {"epss_score": 0.00158, "epss_percentile": 0.37181}, "CVE-2021-32285": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-32286": {"epss_score": 0.00446, "epss_percentile": 0.62896}, "CVE-2021-32287": {"epss_score": 0.00412, "epss_percentile": 0.60951}, "CVE-2021-32288": {"epss_score": 0.00412, "epss_percentile": 0.60951}, "CVE-2021-32289": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-32292": {"epss_score": 0.00133, "epss_percentile": 0.3364}, "CVE-2021-32294": {"epss_score": 0.00554, "epss_percentile": 0.67435}, "CVE-2021-32297": {"epss_score": 0.00554, "epss_percentile": 0.67435}, "CVE-2021-32298": {"epss_score": 0.00591, "epss_percentile": 0.68595}, "CVE-2021-32299": {"epss_score": 0.00412, "epss_percentile": 0.60951}, "CVE-2021-32302": {"epss_score": 0.00112, "epss_percentile": 0.30506}, "CVE-2021-32305": {"epss_score": 0.93186, "epss_percentile": 0.99782}, "CVE-2021-32399": {"epss_score": 0.0008, "epss_percentile": 0.24082}, "CVE-2021-32402": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2021-32403": {"epss_score": 0.00532, "epss_percentile": 0.6671}, "CVE-2021-32415": {"epss_score": 0.00058, "epss_percentile": 0.18362}, "CVE-2021-32419": {"epss_score": 0.0038, "epss_percentile": 0.58961}, "CVE-2021-32420": {"epss_score": 0.00129, "epss_percentile": 0.331}, "CVE-2021-32421": {"epss_score": 0.00127, "epss_percentile": 0.32791}, "CVE-2021-32422": {"epss_score": 0.00176, "epss_percentile": 0.39457}, "CVE-2021-32424": {"epss_score": 0.00305, "epss_percentile": 0.53355}, "CVE-2021-32426": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-32428": {"epss_score": 0.0045, "epss_percentile": 0.63079}, "CVE-2021-32434": {"epss_score": 0.00093, "epss_percentile": 0.26676}, "CVE-2021-32435": {"epss_score": 0.00129, "epss_percentile": 0.33142}, "CVE-2021-32436": {"epss_score": 0.00235, "epss_percentile": 0.46232}, "CVE-2021-32437": {"epss_score": 0.00252, "epss_percentile": 0.48359}, "CVE-2021-32438": {"epss_score": 0.00252, "epss_percentile": 0.48359}, "CVE-2021-32439": {"epss_score": 0.00302, "epss_percentile": 0.53104}, "CVE-2021-32440": {"epss_score": 0.00252, "epss_percentile": 0.48359}, "CVE-2021-32441": {"epss_score": 0.00073, "epss_percentile": 0.22575}, "CVE-2021-32453": {"epss_score": 0.0005, "epss_percentile": 0.1588}, "CVE-2021-32454": {"epss_score": 0.00087, "epss_percentile": 0.25554}, "CVE-2021-32455": {"epss_score": 0.00065, "epss_percentile": 0.20536}, "CVE-2021-32456": {"epss_score": 0.00042, "epss_percentile": 0.12743}, "CVE-2021-32457": {"epss_score": 0.00137, "epss_percentile": 0.34333}, "CVE-2021-32458": {"epss_score": 0.00073, "epss_percentile": 0.22545}, "CVE-2021-32459": {"epss_score": 0.00532, "epss_percentile": 0.6671}, "CVE-2021-32460": {"epss_score": 0.00061, "epss_percentile": 0.19415}, "CVE-2021-32461": {"epss_score": 0.00066, "epss_percentile": 0.20905}, "CVE-2021-32462": {"epss_score": 0.17414, "epss_percentile": 0.94847}, "CVE-2021-32463": {"epss_score": 0.00058, "epss_percentile": 0.1831}, "CVE-2021-32464": {"epss_score": 0.00094, "epss_percentile": 0.27069}, "CVE-2021-32465": {"epss_score": 0.0344, "epss_percentile": 0.87139}, "CVE-2021-32466": {"epss_score": 0.00095, "epss_percentile": 0.27153}, "CVE-2021-32467": {"epss_score": 0.00562, "epss_percentile": 0.67699}, "CVE-2021-32468": {"epss_score": 0.01108, "epss_percentile": 0.77641}, "CVE-2021-32469": {"epss_score": 0.00562, "epss_percentile": 0.67699}, "CVE-2021-32470": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2021-32471": {"epss_score": 0.05434, "epss_percentile": 0.89879}, "CVE-2021-32472": {"epss_score": 0.00386, "epss_percentile": 0.59285}, "CVE-2021-32473": {"epss_score": 0.00451, "epss_percentile": 0.63156}, "CVE-2021-32474": {"epss_score": 0.00773, "epss_percentile": 0.73057}, "CVE-2021-32475": {"epss_score": 0.00731, "epss_percentile": 0.72181}, "CVE-2021-32476": {"epss_score": 0.00649, "epss_percentile": 0.70234}, "CVE-2021-32477": {"epss_score": 0.00283, "epss_percentile": 0.51411}, "CVE-2021-32478": {"epss_score": 0.03754, "epss_percentile": 0.8768}, "CVE-2021-32481": {"epss_score": 0.00323, "epss_percentile": 0.54888}, "CVE-2021-32482": {"epss_score": 0.00275, "epss_percentile": 0.507}, "CVE-2021-32483": {"epss_score": 0.00206, "epss_percentile": 0.43053}, "CVE-2021-32484": {"epss_score": 0.02078, "epss_percentile": 0.8352}, "CVE-2021-32485": {"epss_score": 0.02078, "epss_percentile": 0.8352}, "CVE-2021-32486": {"epss_score": 0.02078, "epss_percentile": 0.8352}, "CVE-2021-32487": {"epss_score": 0.02078, "epss_percentile": 0.8352}, "CVE-2021-32489": {"epss_score": 0.00989, "epss_percentile": 0.76369}, "CVE-2021-32490": {"epss_score": 0.00128, "epss_percentile": 0.32986}, "CVE-2021-32491": {"epss_score": 0.00364, "epss_percentile": 0.57948}, "CVE-2021-32492": {"epss_score": 0.00364, "epss_percentile": 0.57948}, "CVE-2021-32493": {"epss_score": 0.00377, "epss_percentile": 0.58711}, "CVE-2021-32494": {"epss_score": 0.00191, "epss_percentile": 0.41195}, "CVE-2021-32495": {"epss_score": 0.0026, "epss_percentile": 0.49104}, "CVE-2021-32496": {"epss_score": 0.00072, "epss_percentile": 0.22327}, "CVE-2021-32497": {"epss_score": 0.00145, "epss_percentile": 0.35517}, "CVE-2021-32498": {"epss_score": 0.00133, "epss_percentile": 0.33647}, "CVE-2021-32499": {"epss_score": 0.00389, "epss_percentile": 0.59494}, "CVE-2021-32503": {"epss_score": 0.00882, "epss_percentile": 0.74886}, "CVE-2021-32504": {"epss_score": 0.00325, "epss_percentile": 0.55033}, "CVE-2021-32506": {"epss_score": 0.00235, "epss_percentile": 0.46343}, "CVE-2021-32507": {"epss_score": 0.00235, "epss_percentile": 0.46343}, "CVE-2021-32508": {"epss_score": 0.00208, "epss_percentile": 0.43256}, "CVE-2021-32509": {"epss_score": 0.00235, "epss_percentile": 0.46343}, "CVE-2021-32510": {"epss_score": 0.00121, "epss_percentile": 0.31874}, "CVE-2021-32511": {"epss_score": 0.00121, "epss_percentile": 0.31874}, "CVE-2021-32512": {"epss_score": 0.01174, "epss_percentile": 0.78245}, "CVE-2021-32513": {"epss_score": 0.01174, "epss_percentile": 0.78245}, "CVE-2021-32514": {"epss_score": 0.00447, "epss_percentile": 0.62935}, "CVE-2021-32515": {"epss_score": 0.00178, "epss_percentile": 0.39643}, "CVE-2021-32516": {"epss_score": 0.00304, "epss_percentile": 0.53257}, "CVE-2021-32517": {"epss_score": 0.00218, "epss_percentile": 0.44418}, "CVE-2021-32518": {"epss_score": 0.00304, "epss_percentile": 0.53257}, "CVE-2021-32519": {"epss_score": 0.00102, "epss_percentile": 0.28859}, "CVE-2021-32520": {"epss_score": 0.00206, "epss_percentile": 0.42783}, "CVE-2021-32521": {"epss_score": 0.00296, "epss_percentile": 0.52566}, "CVE-2021-32522": {"epss_score": 0.00241, "epss_percentile": 0.47293}, "CVE-2021-32523": {"epss_score": 0.00231, "epss_percentile": 0.45795}, "CVE-2021-32524": {"epss_score": 0.00851, "epss_percentile": 0.744}, "CVE-2021-32525": {"epss_score": 0.0096, "epss_percentile": 0.75967}, "CVE-2021-32526": {"epss_score": 0.0017, "epss_percentile": 0.38718}, "CVE-2021-32527": {"epss_score": 0.00718, "epss_percentile": 0.71937}, "CVE-2021-32528": {"epss_score": 0.00143, "epss_percentile": 0.35216}, "CVE-2021-32529": {"epss_score": 0.0101, "epss_percentile": 0.76598}, "CVE-2021-32530": {"epss_score": 0.0101, "epss_percentile": 0.76598}, "CVE-2021-32531": {"epss_score": 0.01134, "epss_percentile": 0.77891}, "CVE-2021-32532": {"epss_score": 0.00213, "epss_percentile": 0.43894}, "CVE-2021-32533": {"epss_score": 0.00537, "epss_percentile": 0.66923}, "CVE-2021-32534": {"epss_score": 0.00537, "epss_percentile": 0.66923}, "CVE-2021-32535": {"epss_score": 0.00494, "epss_percentile": 0.65066}, "CVE-2021-32536": {"epss_score": 0.00173, "epss_percentile": 0.39056}, "CVE-2021-32537": {"epss_score": 0.00247, "epss_percentile": 0.4783}, "CVE-2021-32538": {"epss_score": 0.01057, "epss_percentile": 0.77137}, "CVE-2021-32539": {"epss_score": 0.00125, "epss_percentile": 0.32494}, "CVE-2021-32540": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2021-32541": {"epss_score": 0.00348, "epss_percentile": 0.56844}, "CVE-2021-32542": {"epss_score": 0.00496, "epss_percentile": 0.65139}, "CVE-2021-32543": {"epss_score": 0.00107, "epss_percentile": 0.29612}, "CVE-2021-32544": {"epss_score": 0.00169, "epss_percentile": 0.38638}, "CVE-2021-32545": {"epss_score": 0.00449, "epss_percentile": 0.63043}, "CVE-2021-32546": {"epss_score": 0.0144, "epss_percentile": 0.80296}, "CVE-2021-32547": {"epss_score": 0.00061, "epss_percentile": 0.19342}, "CVE-2021-32548": {"epss_score": 0.00061, "epss_percentile": 0.19342}, "CVE-2021-32549": {"epss_score": 0.00061, "epss_percentile": 0.19342}, "CVE-2021-32550": {"epss_score": 0.00055, "epss_percentile": 0.17477}, "CVE-2021-32551": {"epss_score": 0.00055, "epss_percentile": 0.17477}, "CVE-2021-32552": {"epss_score": 0.00055, "epss_percentile": 0.17477}, "CVE-2021-32553": {"epss_score": 0.00048, "epss_percentile": 0.15226}, "CVE-2021-32554": {"epss_score": 0.00061, "epss_percentile": 0.19342}, "CVE-2021-32555": {"epss_score": 0.00055, "epss_percentile": 0.17477}, "CVE-2021-32556": {"epss_score": 0.00093, "epss_percentile": 0.26658}, "CVE-2021-32557": {"epss_score": 0.00058, "epss_percentile": 0.18266}, "CVE-2021-32558": {"epss_score": 0.04975, "epss_percentile": 0.89354}, "CVE-2021-32559": {"epss_score": 0.00191, "epss_percentile": 0.41201}, "CVE-2021-32560": {"epss_score": 0.00351, "epss_percentile": 0.57028}, "CVE-2021-32561": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2021-32563": {"epss_score": 0.00672, "epss_percentile": 0.70811}, "CVE-2021-32565": {"epss_score": 0.05675, "epss_percentile": 0.9011}, "CVE-2021-32566": {"epss_score": 0.05062, "epss_percentile": 0.89455}, "CVE-2021-32567": {"epss_score": 0.07927, "epss_percentile": 0.91766}, "CVE-2021-32568": {"epss_score": 0.00252, "epss_percentile": 0.48335}, "CVE-2021-32569": {"epss_score": 0.00529, "epss_percentile": 0.66595}, "CVE-2021-32570": {"epss_score": 0.00236, "epss_percentile": 0.4643}, "CVE-2021-32571": {"epss_score": 0.00657, "epss_percentile": 0.70458}, "CVE-2021-32572": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2021-32573": {"epss_score": 0.00212, "epss_percentile": 0.43759}, "CVE-2021-32574": {"epss_score": 0.00802, "epss_percentile": 0.73584}, "CVE-2021-32575": {"epss_score": 0.00182, "epss_percentile": 0.40154}, "CVE-2021-32576": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2021-32577": {"epss_score": 0.00033, "epss_percentile": 0.09344}, "CVE-2021-32578": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2021-32579": {"epss_score": 0.00041, "epss_percentile": 0.12348}, "CVE-2021-32580": {"epss_score": 0.00054, "epss_percentile": 0.17175}, "CVE-2021-32581": {"epss_score": 0.00155, "epss_percentile": 0.36837}, "CVE-2021-32582": {"epss_score": 0.00418, "epss_percentile": 0.61265}, "CVE-2021-32584": {"epss_score": 0.00088, "epss_percentile": 0.25691}, "CVE-2021-32585": {"epss_score": 0.00669, "epss_percentile": 0.70754}, "CVE-2021-32586": {"epss_score": 0.00436, "epss_percentile": 0.62487}, "CVE-2021-32587": {"epss_score": 0.00204, "epss_percentile": 0.42667}, "CVE-2021-32588": {"epss_score": 0.31045, "epss_percentile": 0.96585}, "CVE-2021-32589": {"epss_score": 0.0387, "epss_percentile": 0.87878}, "CVE-2021-32590": {"epss_score": 0.00198, "epss_percentile": 0.4202}, "CVE-2021-32591": {"epss_score": 0.00392, "epss_percentile": 0.59661}, "CVE-2021-32592": {"epss_score": 0.00052, "epss_percentile": 0.16513}, "CVE-2021-32593": {"epss_score": 0.00166, "epss_percentile": 0.38145}, "CVE-2021-32594": {"epss_score": 0.00372, "epss_percentile": 0.58452}, "CVE-2021-32595": {"epss_score": 0.00372, "epss_percentile": 0.58452}, "CVE-2021-32596": {"epss_score": 0.00083, "epss_percentile": 0.24595}, "CVE-2021-32597": {"epss_score": 0.0017, "epss_percentile": 0.38702}, "CVE-2021-32598": {"epss_score": 0.00138, "epss_percentile": 0.34443}, "CVE-2021-32600": {"epss_score": 0.00282, "epss_percentile": 0.51252}, "CVE-2021-32602": {"epss_score": 0.00443, "epss_percentile": 0.62772}, "CVE-2021-32603": {"epss_score": 0.0022, "epss_percentile": 0.44622}, "CVE-2021-32604": {"epss_score": 0.01758, "epss_percentile": 0.82137}, "CVE-2021-32605": {"epss_score": 0.21913, "epss_percentile": 0.95572}, "CVE-2021-32606": {"epss_score": 0.00123, "epss_percentile": 0.32189}, "CVE-2021-32607": {"epss_score": 0.01916, "epss_percentile": 0.8286}, "CVE-2021-32608": {"epss_score": 0.01916, "epss_percentile": 0.8286}, "CVE-2021-32609": {"epss_score": 0.09085, "epss_percentile": 0.92395}, "CVE-2021-32610": {"epss_score": 0.02975, "epss_percentile": 0.86103}, "CVE-2021-32611": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-32612": {"epss_score": 0.00235, "epss_percentile": 0.46337}, "CVE-2021-32613": {"epss_score": 0.00336, "epss_percentile": 0.55919}, "CVE-2021-32614": {"epss_score": 0.00325, "epss_percentile": 0.55015}, "CVE-2021-32615": {"epss_score": 0.01114, "epss_percentile": 0.77695}, "CVE-2021-32616": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2021-32617": {"epss_score": 0.00075, "epss_percentile": 0.23061}, "CVE-2021-32618": {"epss_score": 0.17163, "epss_percentile": 0.9479}, "CVE-2021-32619": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2021-32620": {"epss_score": 0.00311, "epss_percentile": 0.53864}, "CVE-2021-32621": {"epss_score": 0.00691, "epss_percentile": 0.71274}, "CVE-2021-32622": {"epss_score": 0.00174, "epss_percentile": 0.39198}, "CVE-2021-32623": {"epss_score": 0.00308, "epss_percentile": 0.53623}, "CVE-2021-32624": {"epss_score": 0.00314, "epss_percentile": 0.54113}, "CVE-2021-32625": {"epss_score": 0.02747, "epss_percentile": 0.85575}, "CVE-2021-32626": {"epss_score": 0.01172, "epss_percentile": 0.78228}, "CVE-2021-32627": {"epss_score": 0.00795, "epss_percentile": 0.73463}, "CVE-2021-32628": {"epss_score": 0.00586, "epss_percentile": 0.68443}, "CVE-2021-32629": {"epss_score": 0.0007, "epss_percentile": 0.21797}, "CVE-2021-32630": {"epss_score": 0.00845, "epss_percentile": 0.74287}, "CVE-2021-32631": {"epss_score": 0.00254, "epss_percentile": 0.48497}, "CVE-2021-32632": {"epss_score": 0.00148, "epss_percentile": 0.35915}, "CVE-2021-32633": {"epss_score": 0.00943, "epss_percentile": 0.7578}, "CVE-2021-32634": {"epss_score": 0.03051, "epss_percentile": 0.86291}, "CVE-2021-32635": {"epss_score": 0.00632, "epss_percentile": 0.69751}, "CVE-2021-32637": {"epss_score": 0.00528, "epss_percentile": 0.66549}, "CVE-2021-32638": {"epss_score": 0.00073, "epss_percentile": 0.22492}, "CVE-2021-32639": {"epss_score": 0.00781, "epss_percentile": 0.73179}, "CVE-2021-32640": {"epss_score": 0.00522, "epss_percentile": 0.66263}, "CVE-2021-32641": {"epss_score": 0.00793, "epss_percentile": 0.73418}, "CVE-2021-32642": {"epss_score": 0.01516, "epss_percentile": 0.80801}, "CVE-2021-32643": {"epss_score": 0.00316, "epss_percentile": 0.54299}, "CVE-2021-32644": {"epss_score": 0.00441, "epss_percentile": 0.62665}, "CVE-2021-32645": {"epss_score": 0.00285, "epss_percentile": 0.51683}, "CVE-2021-32646": {"epss_score": 0.00151, "epss_percentile": 0.36231}, "CVE-2021-32647": {"epss_score": 0.03428, "epss_percentile": 0.87117}, "CVE-2021-32648": {"epss_score": 0.92015, "epss_percentile": 0.99685}, "CVE-2021-32649": {"epss_score": 0.005, "epss_percentile": 0.65322}, "CVE-2021-32650": {"epss_score": 0.01086, "epss_percentile": 0.77418}, "CVE-2021-32651": {"epss_score": 0.00247, "epss_percentile": 0.47822}, "CVE-2021-32652": {"epss_score": 0.0046, "epss_percentile": 0.63519}, "CVE-2021-32653": {"epss_score": 0.0038, "epss_percentile": 0.58962}, "CVE-2021-32654": {"epss_score": 0.00275, "epss_percentile": 0.50656}, "CVE-2021-32655": {"epss_score": 0.00352, "epss_percentile": 0.57085}, "CVE-2021-32656": {"epss_score": 0.00463, "epss_percentile": 0.63636}, "CVE-2021-32657": {"epss_score": 0.00489, "epss_percentile": 0.64905}, "CVE-2021-32658": {"epss_score": 0.00143, "epss_percentile": 0.35212}, "CVE-2021-32659": {"epss_score": 0.00268, "epss_percentile": 0.50097}, "CVE-2021-32660": {"epss_score": 0.00468, "epss_percentile": 0.63867}, "CVE-2021-32661": {"epss_score": 0.00444, "epss_percentile": 0.62839}, "CVE-2021-32662": {"epss_score": 0.00484, "epss_percentile": 0.64667}, "CVE-2021-32663": {"epss_score": 0.00316, "epss_percentile": 0.5428}, "CVE-2021-32664": {"epss_score": 0.00423, "epss_percentile": 0.61619}, "CVE-2021-32665": {"epss_score": 0.00123, "epss_percentile": 0.32317}, "CVE-2021-32666": {"epss_score": 0.00308, "epss_percentile": 0.53623}, "CVE-2021-32667": {"epss_score": 0.00415, "epss_percentile": 0.61132}, "CVE-2021-32668": {"epss_score": 0.00364, "epss_percentile": 0.57913}, "CVE-2021-32669": {"epss_score": 0.00374, "epss_percentile": 0.58561}, "CVE-2021-32670": {"epss_score": 0.00594, "epss_percentile": 0.68654}, "CVE-2021-32671": {"epss_score": 0.00758, "epss_percentile": 0.7277}, "CVE-2021-32672": {"epss_score": 0.00287, "epss_percentile": 0.5186}, "CVE-2021-32673": {"epss_score": 0.01795, "epss_percentile": 0.82301}, "CVE-2021-32674": {"epss_score": 0.00801, "epss_percentile": 0.73571}, "CVE-2021-32675": {"epss_score": 0.02528, "epss_percentile": 0.8502}, "CVE-2021-32676": {"epss_score": 0.00325, "epss_percentile": 0.55033}, "CVE-2021-32677": {"epss_score": 0.00119, "epss_percentile": 0.3163}, "CVE-2021-32678": {"epss_score": 0.00302, "epss_percentile": 0.53093}, "CVE-2021-32679": {"epss_score": 0.00812, "epss_percentile": 0.73752}, "CVE-2021-32680": {"epss_score": 0.002, "epss_percentile": 0.42217}, "CVE-2021-32681": {"epss_score": 0.00294, "epss_percentile": 0.52424}, "CVE-2021-32682": {"epss_score": 0.93466, "epss_percentile": 0.9981}, "CVE-2021-32683": {"epss_score": 0.00352, "epss_percentile": 0.57123}, "CVE-2021-32684": {"epss_score": 0.00189, "epss_percentile": 0.4096}, "CVE-2021-32685": {"epss_score": 0.00177, "epss_percentile": 0.39584}, "CVE-2021-32686": {"epss_score": 0.01712, "epss_percentile": 0.81884}, "CVE-2021-32687": {"epss_score": 0.00908, "epss_percentile": 0.75282}, "CVE-2021-32688": {"epss_score": 0.03114, "epss_percentile": 0.8643}, "CVE-2021-32689": {"epss_score": 0.00257, "epss_percentile": 0.48879}, "CVE-2021-32690": {"epss_score": 0.00394, "epss_percentile": 0.59751}, "CVE-2021-32691": {"epss_score": 0.00641, "epss_percentile": 0.70013}, "CVE-2021-32692": {"epss_score": 0.00477, "epss_percentile": 0.64296}, "CVE-2021-32693": {"epss_score": 0.00545, "epss_percentile": 0.67162}, "CVE-2021-32694": {"epss_score": 0.00236, "epss_percentile": 0.46394}, "CVE-2021-32695": {"epss_score": 0.0028, "epss_percentile": 0.51032}, "CVE-2021-32696": {"epss_score": 0.00292, "epss_percentile": 0.52246}, "CVE-2021-32697": {"epss_score": 0.00396, "epss_percentile": 0.59863}, "CVE-2021-32698": {"epss_score": 0.00261, "epss_percentile": 0.49303}, "CVE-2021-32699": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2021-32700": {"epss_score": 0.00117, "epss_percentile": 0.31371}, "CVE-2021-32701": {"epss_score": 0.00308, "epss_percentile": 0.53583}, "CVE-2021-32702": {"epss_score": 0.00581, "epss_percentile": 0.68263}, "CVE-2021-32703": {"epss_score": 0.00555, "epss_percentile": 0.67488}, "CVE-2021-32704": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2021-32705": {"epss_score": 0.00572, "epss_percentile": 0.6802}, "CVE-2021-32706": {"epss_score": 0.59444, "epss_percentile": 0.98165}, "CVE-2021-32707": {"epss_score": 0.00323, "epss_percentile": 0.54893}, "CVE-2021-32708": {"epss_score": 0.07327, "epss_percentile": 0.91411}, "CVE-2021-32709": {"epss_score": 0.00185, "epss_percentile": 0.4047}, "CVE-2021-32710": {"epss_score": 0.00272, "epss_percentile": 0.50348}, "CVE-2021-32711": {"epss_score": 0.00386, "epss_percentile": 0.59253}, "CVE-2021-32712": {"epss_score": 0.00298, "epss_percentile": 0.5278}, "CVE-2021-32713": {"epss_score": 0.0039, "epss_percentile": 0.59541}, "CVE-2021-32714": {"epss_score": 0.00399, "epss_percentile": 0.60107}, "CVE-2021-32715": {"epss_score": 0.00295, "epss_percentile": 0.52506}, "CVE-2021-32716": {"epss_score": 0.00308, "epss_percentile": 0.53639}, "CVE-2021-32717": {"epss_score": 0.0033, "epss_percentile": 0.55484}, "CVE-2021-32718": {"epss_score": 0.00076, "epss_percentile": 0.23094}, "CVE-2021-32719": {"epss_score": 0.00086, "epss_percentile": 0.25372}, "CVE-2021-32720": {"epss_score": 0.00221, "epss_percentile": 0.44668}, "CVE-2021-32721": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2021-32722": {"epss_score": 0.00754, "epss_percentile": 0.72691}, "CVE-2021-32723": {"epss_score": 0.00373, "epss_percentile": 0.58465}, "CVE-2021-32724": {"epss_score": 0.00324, "epss_percentile": 0.5497}, "CVE-2021-32725": {"epss_score": 0.0027, "epss_percentile": 0.50219}, "CVE-2021-32726": {"epss_score": 0.0055, "epss_percentile": 0.67339}, "CVE-2021-32727": {"epss_score": 0.00167, "epss_percentile": 0.38335}, "CVE-2021-32728": {"epss_score": 0.00209, "epss_percentile": 0.43321}, "CVE-2021-32729": {"epss_score": 0.00046, "epss_percentile": 0.14391}, "CVE-2021-32730": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2021-32731": {"epss_score": 0.00087, "epss_percentile": 0.25494}, "CVE-2021-32732": {"epss_score": 0.00071, "epss_percentile": 0.22129}, "CVE-2021-32733": {"epss_score": 0.00168, "epss_percentile": 0.38423}, "CVE-2021-32734": {"epss_score": 0.00326, "epss_percentile": 0.55049}, "CVE-2021-32735": {"epss_score": 0.00383, "epss_percentile": 0.59109}, "CVE-2021-32736": {"epss_score": 0.00212, "epss_percentile": 0.43754}, "CVE-2021-32737": {"epss_score": 0.0036, "epss_percentile": 0.57624}, "CVE-2021-32738": {"epss_score": 0.00069, "epss_percentile": 0.21598}, "CVE-2021-32739": {"epss_score": 0.00692, "epss_percentile": 0.713}, "CVE-2021-32740": {"epss_score": 0.00503, "epss_percentile": 0.65481}, "CVE-2021-32741": {"epss_score": 0.0034, "epss_percentile": 0.5621}, "CVE-2021-32742": {"epss_score": 0.00374, "epss_percentile": 0.5853}, "CVE-2021-32743": {"epss_score": 0.00806, "epss_percentile": 0.73646}, "CVE-2021-32744": {"epss_score": 0.00748, "epss_percentile": 0.72586}, "CVE-2021-32745": {"epss_score": 0.00208, "epss_percentile": 0.43219}, "CVE-2021-32746": {"epss_score": 0.00611, "epss_percentile": 0.69193}, "CVE-2021-32747": {"epss_score": 0.00511, "epss_percentile": 0.65821}, "CVE-2021-32748": {"epss_score": 0.00226, "epss_percentile": 0.45313}, "CVE-2021-32749": {"epss_score": 0.00301, "epss_percentile": 0.53068}, "CVE-2021-32750": {"epss_score": 0.00276, "epss_percentile": 0.50738}, "CVE-2021-32751": {"epss_score": 0.00257, "epss_percentile": 0.48882}, "CVE-2021-32752": {"epss_score": 0.00773, "epss_percentile": 0.73055}, "CVE-2021-32753": {"epss_score": 0.00309, "epss_percentile": 0.53675}, "CVE-2021-32754": {"epss_score": 0.00305, "epss_percentile": 0.53389}, "CVE-2021-32755": {"epss_score": 0.00071, "epss_percentile": 0.22178}, "CVE-2021-32756": {"epss_score": 0.01023, "epss_percentile": 0.76764}, "CVE-2021-32758": {"epss_score": 0.0036, "epss_percentile": 0.57666}, "CVE-2021-32759": {"epss_score": 0.0055, "epss_percentile": 0.67328}, "CVE-2021-32760": {"epss_score": 0.00071, "epss_percentile": 0.22163}, "CVE-2021-32761": {"epss_score": 0.00633, "epss_percentile": 0.69786}, "CVE-2021-32762": {"epss_score": 0.00869, "epss_percentile": 0.74687}, "CVE-2021-32763": {"epss_score": 0.00308, "epss_percentile": 0.53623}, "CVE-2021-32764": {"epss_score": 0.00237, "epss_percentile": 0.46696}, "CVE-2021-32765": {"epss_score": 0.00499, "epss_percentile": 0.65257}, "CVE-2021-32766": {"epss_score": 0.00384, "epss_percentile": 0.59148}, "CVE-2021-32767": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2021-32768": {"epss_score": 0.00284, "epss_percentile": 0.51475}, "CVE-2021-32769": {"epss_score": 0.00436, "epss_percentile": 0.62471}, "CVE-2021-32770": {"epss_score": 0.00238, "epss_percentile": 0.46763}, "CVE-2021-32771": {"epss_score": 0.00694, "epss_percentile": 0.71349}, "CVE-2021-32772": {"epss_score": 0.00873, "epss_percentile": 0.74754}, "CVE-2021-32773": {"epss_score": 0.00288, "epss_percentile": 0.5193}, "CVE-2021-32774": {"epss_score": 0.00185, "epss_percentile": 0.40576}, "CVE-2021-32775": {"epss_score": 0.00288, "epss_percentile": 0.51882}, "CVE-2021-32776": {"epss_score": 0.00144, "epss_percentile": 0.35347}, "CVE-2021-32777": {"epss_score": 0.0002, "epss_percentile": 0.04658}, "CVE-2021-32778": {"epss_score": 0.0006, "epss_percentile": 0.19116}, "CVE-2021-32779": {"epss_score": 0.00035, "epss_percentile": 0.10068}, "CVE-2021-32780": {"epss_score": 0.00067, "epss_percentile": 0.21086}, "CVE-2021-32781": {"epss_score": 0.00073, "epss_percentile": 0.22566}, "CVE-2021-32782": {"epss_score": 0.00358, "epss_percentile": 0.57532}, "CVE-2021-32783": {"epss_score": 0.00265, "epss_percentile": 0.49784}, "CVE-2021-32785": {"epss_score": 0.0031, "epss_percentile": 0.53771}, "CVE-2021-32786": {"epss_score": 0.00147, "epss_percentile": 0.35679}, "CVE-2021-32787": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2021-32788": {"epss_score": 0.0039, "epss_percentile": 0.59556}, "CVE-2021-32789": {"epss_score": 0.92211, "epss_percentile": 0.997}, "CVE-2021-32790": {"epss_score": 0.02007, "epss_percentile": 0.83237}, "CVE-2021-32791": {"epss_score": 0.00358, "epss_percentile": 0.57509}, "CVE-2021-32792": {"epss_score": 0.00177, "epss_percentile": 0.39532}, "CVE-2021-32793": {"epss_score": 0.00221, "epss_percentile": 0.44674}, "CVE-2021-32794": {"epss_score": 0.00346, "epss_percentile": 0.56732}, "CVE-2021-32795": {"epss_score": 0.00552, "epss_percentile": 0.67383}, "CVE-2021-32796": {"epss_score": 0.00493, "epss_percentile": 0.65061}, "CVE-2021-32797": {"epss_score": 0.01136, "epss_percentile": 0.77921}, "CVE-2021-32798": {"epss_score": 0.00226, "epss_percentile": 0.4526}, "CVE-2021-32800": {"epss_score": 0.00327, "epss_percentile": 0.55145}, "CVE-2021-32801": {"epss_score": 0.00062, "epss_percentile": 0.19752}, "CVE-2021-32802": {"epss_score": 0.02254, "epss_percentile": 0.84165}, "CVE-2021-32803": {"epss_score": 0.00176, "epss_percentile": 0.39474}, "CVE-2021-32804": {"epss_score": 0.85517, "epss_percentile": 0.99337}, "CVE-2021-32805": {"epss_score": 0.00189, "epss_percentile": 0.40957}, "CVE-2021-32806": {"epss_score": 0.003, "epss_percentile": 0.52952}, "CVE-2021-32807": {"epss_score": 0.01883, "epss_percentile": 0.82698}, "CVE-2021-32808": {"epss_score": 0.01444, "epss_percentile": 0.8032}, "CVE-2021-32809": {"epss_score": 0.00206, "epss_percentile": 0.43033}, "CVE-2021-32810": {"epss_score": 0.01079, "epss_percentile": 0.77358}, "CVE-2021-32811": {"epss_score": 0.03934, "epss_percentile": 0.8798}, "CVE-2021-32812": {"epss_score": 0.00279, "epss_percentile": 0.50947}, "CVE-2021-32813": {"epss_score": 0.00379, "epss_percentile": 0.58862}, "CVE-2021-32814": {"epss_score": 0.00735, "epss_percentile": 0.72295}, "CVE-2021-32815": {"epss_score": 0.00153, "epss_percentile": 0.36521}, "CVE-2021-32816": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2021-32817": {"epss_score": 0.00342, "epss_percentile": 0.56384}, "CVE-2021-32818": {"epss_score": 0.00255, "epss_percentile": 0.48631}, "CVE-2021-32819": {"epss_score": 0.88448, "epss_percentile": 0.99473}, "CVE-2021-32820": {"epss_score": 0.90956, "epss_percentile": 0.99612}, "CVE-2021-32821": {"epss_score": 0.00231, "epss_percentile": 0.45788}, "CVE-2021-32822": {"epss_score": 0.00299, "epss_percentile": 0.52873}, "CVE-2021-32823": {"epss_score": 0.00437, "epss_percentile": 0.62514}, "CVE-2021-32824": {"epss_score": 0.05896, "epss_percentile": 0.90304}, "CVE-2021-32825": {"epss_score": 0.00501, "epss_percentile": 0.65353}, "CVE-2021-32826": {"epss_score": 0.00286, "epss_percentile": 0.51709}, "CVE-2021-32827": {"epss_score": 0.00757, "epss_percentile": 0.7275}, "CVE-2021-32828": {"epss_score": 0.01197, "epss_percentile": 0.78448}, "CVE-2021-32829": {"epss_score": 0.01574, "epss_percentile": 0.81104}, "CVE-2021-32830": {"epss_score": 0.002, "epss_percentile": 0.42207}, "CVE-2021-32831": {"epss_score": 0.00871, "epss_percentile": 0.74709}, "CVE-2021-32832": {"epss_score": 0.01045, "epss_percentile": 0.77016}, "CVE-2021-32833": {"epss_score": 0.00374, "epss_percentile": 0.58546}, "CVE-2021-32834": {"epss_score": 0.0033, "epss_percentile": 0.55493}, "CVE-2021-32835": {"epss_score": 0.02508, "epss_percentile": 0.84941}, "CVE-2021-32836": {"epss_score": 0.01404, "epss_percentile": 0.80038}, "CVE-2021-32837": {"epss_score": 0.03975, "epss_percentile": 0.88047}, "CVE-2021-32838": {"epss_score": 0.01367, "epss_percentile": 0.79784}, "CVE-2021-32839": {"epss_score": 0.0012, "epss_percentile": 0.31789}, "CVE-2021-32840": {"epss_score": 0.01545, "epss_percentile": 0.80962}, "CVE-2021-32841": {"epss_score": 0.00378, "epss_percentile": 0.58806}, "CVE-2021-32842": {"epss_score": 0.00298, "epss_percentile": 0.52785}, "CVE-2021-32843": {"epss_score": 0.00028, "epss_percentile": 0.07209}, "CVE-2021-32844": {"epss_score": 0.00028, "epss_percentile": 0.07209}, "CVE-2021-32845": {"epss_score": 0.00029, "epss_percentile": 0.07894}, "CVE-2021-32846": {"epss_score": 0.00034, "epss_percentile": 0.09669}, "CVE-2021-32847": {"epss_score": 0.00128, "epss_percentile": 0.32994}, "CVE-2021-32848": {"epss_score": 0.00101, "epss_percentile": 0.28709}, "CVE-2021-32849": {"epss_score": 0.78306, "epss_percentile": 0.98979}, "CVE-2021-32850": {"epss_score": 0.0064, "epss_percentile": 0.6997}, "CVE-2021-32851": {"epss_score": 0.00445, "epss_percentile": 0.62882}, "CVE-2021-32852": {"epss_score": 0.00173, "epss_percentile": 0.39127}, "CVE-2021-32853": {"epss_score": 0.85495, "epss_percentile": 0.99336}, "CVE-2021-32854": {"epss_score": 0.00245, "epss_percentile": 0.47692}, "CVE-2021-32855": {"epss_score": 0.00507, "epss_percentile": 0.65674}, "CVE-2021-32856": {"epss_score": 0.01416, "epss_percentile": 0.80144}, "CVE-2021-32857": {"epss_score": 0.00602, "epss_percentile": 0.68893}, "CVE-2021-32858": {"epss_score": 0.00121, "epss_percentile": 0.31825}, "CVE-2021-32859": {"epss_score": 0.00373, "epss_percentile": 0.58496}, "CVE-2021-32860": {"epss_score": 0.00442, "epss_percentile": 0.62723}, "CVE-2021-32862": {"epss_score": 0.00623, "epss_percentile": 0.69536}, "CVE-2021-32917": {"epss_score": 0.0281, "epss_percentile": 0.85715}, "CVE-2021-32918": {"epss_score": 0.0287, "epss_percentile": 0.85872}, "CVE-2021-32919": {"epss_score": 0.00337, "epss_percentile": 0.56049}, "CVE-2021-32920": {"epss_score": 0.0329, "epss_percentile": 0.86836}, "CVE-2021-32921": {"epss_score": 0.03802, "epss_percentile": 0.87747}, "CVE-2021-32923": {"epss_score": 0.00654, "epss_percentile": 0.70339}, "CVE-2021-32924": {"epss_score": 0.0399, "epss_percentile": 0.88069}, "CVE-2021-32925": {"epss_score": 0.00505, "epss_percentile": 0.65554}, "CVE-2021-32926": {"epss_score": 0.00129, "epss_percentile": 0.33074}, "CVE-2021-32927": {"epss_score": 0.00181, "epss_percentile": 0.40099}, "CVE-2021-32928": {"epss_score": 0.0034, "epss_percentile": 0.56278}, "CVE-2021-32929": {"epss_score": 0.00088, "epss_percentile": 0.25792}, "CVE-2021-32930": {"epss_score": 0.00449, "epss_percentile": 0.63039}, "CVE-2021-32931": {"epss_score": 0.00297, "epss_percentile": 0.52692}, "CVE-2021-32932": {"epss_score": 0.00187, "epss_percentile": 0.40761}, "CVE-2021-32933": {"epss_score": 0.00296, "epss_percentile": 0.526}, "CVE-2021-32934": {"epss_score": 0.0011, "epss_percentile": 0.30201}, "CVE-2021-32935": {"epss_score": 0.0055, "epss_percentile": 0.67323}, "CVE-2021-32936": {"epss_score": 0.00167, "epss_percentile": 0.38329}, "CVE-2021-32937": {"epss_score": 0.00205, "epss_percentile": 0.42706}, "CVE-2021-32938": {"epss_score": 0.0021, "epss_percentile": 0.43442}, "CVE-2021-32939": {"epss_score": 0.00205, "epss_percentile": 0.42721}, "CVE-2021-32940": {"epss_score": 0.00323, "epss_percentile": 0.5487}, "CVE-2021-32941": {"epss_score": 0.01551, "epss_percentile": 0.8099}, "CVE-2021-32942": {"epss_score": 0.00029, "epss_percentile": 0.0776}, "CVE-2021-32943": {"epss_score": 0.0086, "epss_percentile": 0.7453}, "CVE-2021-32944": {"epss_score": 0.00224, "epss_percentile": 0.45025}, "CVE-2021-32945": {"epss_score": 0.00054, "epss_percentile": 0.17309}, "CVE-2021-32946": {"epss_score": 0.00301, "epss_percentile": 0.53047}, "CVE-2021-32947": {"epss_score": 0.00365, "epss_percentile": 0.58006}, "CVE-2021-32948": {"epss_score": 0.00161, "epss_percentile": 0.37586}, "CVE-2021-32949": {"epss_score": 0.00298, "epss_percentile": 0.52827}, "CVE-2021-32950": {"epss_score": 0.00323, "epss_percentile": 0.5487}, "CVE-2021-32951": {"epss_score": 0.00129, "epss_percentile": 0.33214}, "CVE-2021-32952": {"epss_score": 0.00252, "epss_percentile": 0.48353}, "CVE-2021-32953": {"epss_score": 0.00224, "epss_percentile": 0.45017}, "CVE-2021-32954": {"epss_score": 0.00209, "epss_percentile": 0.43372}, "CVE-2021-32955": {"epss_score": 0.00412, "epss_percentile": 0.60932}, "CVE-2021-32956": {"epss_score": 0.00157, "epss_percentile": 0.37027}, "CVE-2021-32957": {"epss_score": 0.00173, "epss_percentile": 0.39091}, "CVE-2021-32958": {"epss_score": 0.0004, "epss_percentile": 0.11909}, "CVE-2021-32959": {"epss_score": 0.00638, "epss_percentile": 0.69917}, "CVE-2021-32960": {"epss_score": 0.00036, "epss_percentile": 0.10303}, "CVE-2021-32961": {"epss_score": 0.00354, "epss_percentile": 0.57222}, "CVE-2021-32962": {"epss_score": 0.00241, "epss_percentile": 0.47328}, "CVE-2021-32963": {"epss_score": 0.00458, "epss_percentile": 0.63427}, "CVE-2021-32964": {"epss_score": 0.00195, "epss_percentile": 0.41603}, "CVE-2021-32965": {"epss_score": 0.00221, "epss_percentile": 0.44691}, "CVE-2021-32966": {"epss_score": 0.00104, "epss_percentile": 0.29148}, "CVE-2021-32967": {"epss_score": 0.00352, "epss_percentile": 0.57126}, "CVE-2021-32968": {"epss_score": 0.00947, "epss_percentile": 0.75817}, "CVE-2021-32969": {"epss_score": 0.00223, "epss_percentile": 0.44875}, "CVE-2021-32970": {"epss_score": 0.00759, "epss_percentile": 0.72794}, "CVE-2021-32971": {"epss_score": 0.00458, "epss_percentile": 0.63427}, "CVE-2021-32972": {"epss_score": 0.00154, "epss_percentile": 0.36702}, "CVE-2021-32974": {"epss_score": 0.00842, "epss_percentile": 0.7424}, "CVE-2021-32975": {"epss_score": 0.00407, "epss_percentile": 0.60583}, "CVE-2021-32976": {"epss_score": 0.01385, "epss_percentile": 0.79905}, "CVE-2021-32977": {"epss_score": 0.00094, "epss_percentile": 0.27001}, "CVE-2021-32978": {"epss_score": 0.0022, "epss_percentile": 0.44552}, "CVE-2021-32979": {"epss_score": 0.00458, "epss_percentile": 0.63427}, "CVE-2021-32980": {"epss_score": 0.00285, "epss_percentile": 0.51645}, "CVE-2021-32981": {"epss_score": 0.00237, "epss_percentile": 0.46666}, "CVE-2021-32982": {"epss_score": 0.00116, "epss_percentile": 0.3109}, "CVE-2021-32983": {"epss_score": 0.02323, "epss_percentile": 0.84377}, "CVE-2021-32984": {"epss_score": 0.00285, "epss_percentile": 0.51645}, "CVE-2021-32985": {"epss_score": 0.00085, "epss_percentile": 0.25165}, "CVE-2021-32986": {"epss_score": 0.00285, "epss_percentile": 0.51645}, "CVE-2021-32987": {"epss_score": 0.00458, "epss_percentile": 0.63427}, "CVE-2021-32988": {"epss_score": 0.00748, "epss_percentile": 0.72584}, "CVE-2021-32989": {"epss_score": 0.00212, "epss_percentile": 0.43811}, "CVE-2021-32990": {"epss_score": 0.00748, "epss_percentile": 0.72584}, "CVE-2021-32991": {"epss_score": 0.00092, "epss_percentile": 0.26507}, "CVE-2021-32992": {"epss_score": 0.007, "epss_percentile": 0.71471}, "CVE-2021-32993": {"epss_score": 0.00032, "epss_percentile": 0.09099}, "CVE-2021-32994": {"epss_score": 0.00122, "epss_percentile": 0.32091}, "CVE-2021-32995": {"epss_score": 0.00407, "epss_percentile": 0.60583}, "CVE-2021-32996": {"epss_score": 0.00397, "epss_percentile": 0.59983}, "CVE-2021-32997": {"epss_score": 0.00051, "epss_percentile": 0.16335}, "CVE-2021-32998": {"epss_score": 0.00385, "epss_percentile": 0.59214}, "CVE-2021-32999": {"epss_score": 0.00277, "epss_percentile": 0.50844}, "CVE-2021-33000": {"epss_score": 0.00479, "epss_percentile": 0.64431}, "CVE-2021-33001": {"epss_score": 0.00291, "epss_percentile": 0.52183}, "CVE-2021-33002": {"epss_score": 0.0027, "epss_percentile": 0.50217}, "CVE-2021-33003": {"epss_score": 0.00028, "epss_percentile": 0.07496}, "CVE-2021-33004": {"epss_score": 0.00362, "epss_percentile": 0.5779}, "CVE-2021-33005": {"epss_score": 0.00342, "epss_percentile": 0.5635}, "CVE-2021-33007": {"epss_score": 0.00513, "epss_percentile": 0.65898}, "CVE-2021-33008": {"epss_score": 0.00178, "epss_percentile": 0.39666}, "CVE-2021-33009": {"epss_score": 0.00224, "epss_percentile": 0.45061}, "CVE-2021-33010": {"epss_score": 0.00211, "epss_percentile": 0.43703}, "CVE-2021-33011": {"epss_score": 0.00066, "epss_percentile": 0.20693}, "CVE-2021-33012": {"epss_score": 0.02742, "epss_percentile": 0.85562}, "CVE-2021-33013": {"epss_score": 0.00217, "epss_percentile": 0.44245}, "CVE-2021-33014": {"epss_score": 0.00151, "epss_percentile": 0.36248}, "CVE-2021-33015": {"epss_score": 0.00407, "epss_percentile": 0.60583}, "CVE-2021-33016": {"epss_score": 0.00187, "epss_percentile": 0.40732}, "CVE-2021-33017": {"epss_score": 0.00062, "epss_percentile": 0.19728}, "CVE-2021-33018": {"epss_score": 0.00108, "epss_percentile": 0.29791}, "CVE-2021-33019": {"epss_score": 0.00389, "epss_percentile": 0.59462}, "CVE-2021-33020": {"epss_score": 0.00219, "epss_percentile": 0.44508}, "CVE-2021-33021": {"epss_score": 0.00291, "epss_percentile": 0.52183}, "CVE-2021-33022": {"epss_score": 0.00108, "epss_percentile": 0.29791}, "CVE-2021-33023": {"epss_score": 0.00907, "epss_percentile": 0.75266}, "CVE-2021-33024": {"epss_score": 0.00183, "epss_percentile": 0.40336}, "CVE-2021-33025": {"epss_score": 0.00052, "epss_percentile": 0.16353}, "CVE-2021-33026": {"epss_score": 0.1628, "epss_percentile": 0.9461}, "CVE-2021-33027": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2021-33031": {"epss_score": 0.00139, "epss_percentile": 0.34582}, "CVE-2021-33032": {"epss_score": 0.50215, "epss_percentile": 0.97727}, "CVE-2021-33033": {"epss_score": 0.00037, "epss_percentile": 0.10887}, "CVE-2021-33034": {"epss_score": 0.0009, "epss_percentile": 0.26045}, "CVE-2021-33035": {"epss_score": 0.14675, "epss_percentile": 0.94261}, "CVE-2021-33036": {"epss_score": 0.02095, "epss_percentile": 0.83582}, "CVE-2021-33037": {"epss_score": 0.02513, "epss_percentile": 0.84977}, "CVE-2021-33038": {"epss_score": 0.00406, "epss_percentile": 0.60551}, "CVE-2021-33040": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2021-33041": {"epss_score": 0.00487, "epss_percentile": 0.64784}, "CVE-2021-33044": {"epss_score": 0.94269, "epss_percentile": 0.99931}, "CVE-2021-33045": {"epss_score": 0.94171, "epss_percentile": 0.99911}, "CVE-2021-33046": {"epss_score": 0.00502, "epss_percentile": 0.65402}, "CVE-2021-33054": {"epss_score": 0.00301, "epss_percentile": 0.53009}, "CVE-2021-33055": {"epss_score": 0.21777, "epss_percentile": 0.95559}, "CVE-2021-33056": {"epss_score": 0.00415, "epss_percentile": 0.61145}, "CVE-2021-33057": {"epss_score": 0.00343, "epss_percentile": 0.5643}, "CVE-2021-33058": {"epss_score": 0.00072, "epss_percentile": 0.22297}, "CVE-2021-33059": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2021-33060": {"epss_score": 0.00201, "epss_percentile": 0.42338}, "CVE-2021-33061": {"epss_score": 0.00045, "epss_percentile": 0.14016}, "CVE-2021-33062": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-33063": {"epss_score": 0.00071, "epss_percentile": 0.22157}, "CVE-2021-33064": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2021-33068": {"epss_score": 0.00451, "epss_percentile": 0.63142}, "CVE-2021-33069": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2021-33071": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-33073": {"epss_score": 0.00063, "epss_percentile": 0.19849}, "CVE-2021-33074": {"epss_score": 0.00165, "epss_percentile": 0.38117}, "CVE-2021-33075": {"epss_score": 0.00035, "epss_percentile": 0.10055}, "CVE-2021-33076": {"epss_score": 0.001, "epss_percentile": 0.28551}, "CVE-2021-33077": {"epss_score": 0.00076, "epss_percentile": 0.23084}, "CVE-2021-33078": {"epss_score": 0.00035, "epss_percentile": 0.10055}, "CVE-2021-33079": {"epss_score": 0.00058, "epss_percentile": 0.18373}, "CVE-2021-33080": {"epss_score": 0.00147, "epss_percentile": 0.3578}, "CVE-2021-33081": {"epss_score": 0.00053, "epss_percentile": 0.1689}, "CVE-2021-33082": {"epss_score": 0.00165, "epss_percentile": 0.38117}, "CVE-2021-33083": {"epss_score": 0.00065, "epss_percentile": 0.20542}, "CVE-2021-33086": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2021-33087": {"epss_score": 0.0005, "epss_percentile": 0.15822}, "CVE-2021-33088": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2021-33089": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-33090": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2021-33091": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2021-33092": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2021-33093": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2021-33094": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2021-33095": {"epss_score": 0.00052, "epss_percentile": 0.16513}, "CVE-2021-33096": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-33097": {"epss_score": 0.00284, "epss_percentile": 0.51467}, "CVE-2021-33098": {"epss_score": 0.00066, "epss_percentile": 0.20706}, "CVE-2021-33101": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2021-33103": {"epss_score": 0.00122, "epss_percentile": 0.32158}, "CVE-2021-33104": {"epss_score": 0.00044, "epss_percentile": 0.13555}, "CVE-2021-33105": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2021-33106": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-33107": {"epss_score": 0.00144, "epss_percentile": 0.35326}, "CVE-2021-33108": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2021-33110": {"epss_score": 0.00405, "epss_percentile": 0.60507}, "CVE-2021-33113": {"epss_score": 0.0048, "epss_percentile": 0.6445}, "CVE-2021-33114": {"epss_score": 0.00281, "epss_percentile": 0.51139}, "CVE-2021-33115": {"epss_score": 0.00512, "epss_percentile": 0.6586}, "CVE-2021-33117": {"epss_score": 0.00136, "epss_percentile": 0.34093}, "CVE-2021-33118": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-33119": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2021-33120": {"epss_score": 0.0044, "epss_percentile": 0.62633}, "CVE-2021-33122": {"epss_score": 0.00193, "epss_percentile": 0.41402}, "CVE-2021-33123": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2021-33124": {"epss_score": 0.00133, "epss_percentile": 0.33678}, "CVE-2021-33126": {"epss_score": 0.00059, "epss_percentile": 0.18899}, "CVE-2021-33128": {"epss_score": 0.00061, "epss_percentile": 0.19349}, "CVE-2021-33129": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2021-33130": {"epss_score": 0.00085, "epss_percentile": 0.25068}, "CVE-2021-33135": {"epss_score": 0.00071, "epss_percentile": 0.2209}, "CVE-2021-33137": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-33139": {"epss_score": 0.00074, "epss_percentile": 0.2278}, "CVE-2021-33141": {"epss_score": 0.00131, "epss_percentile": 0.33469}, "CVE-2021-33142": {"epss_score": 0.00037, "epss_percentile": 0.10817}, "CVE-2021-33145": {"epss_score": 0.00041, "epss_percentile": 0.1244}, "CVE-2021-33146": {"epss_score": 0.00169, "epss_percentile": 0.38613}, "CVE-2021-33147": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2021-33149": {"epss_score": 0.0011, "epss_percentile": 0.30197}, "CVE-2021-33150": {"epss_score": 0.0033, "epss_percentile": 0.55486}, "CVE-2021-33155": {"epss_score": 0.00102, "epss_percentile": 0.28828}, "CVE-2021-33157": {"epss_score": 0.00039, "epss_percentile": 0.11792}, "CVE-2021-33158": {"epss_score": 0.00042, "epss_percentile": 0.12495}, "CVE-2021-33159": {"epss_score": 0.00041, "epss_percentile": 0.12276}, "CVE-2021-33161": {"epss_score": 0.00038, "epss_percentile": 0.11332}, "CVE-2021-33162": {"epss_score": 0.00033, "epss_percentile": 0.09213}, "CVE-2021-33164": {"epss_score": 0.00061, "epss_percentile": 0.19388}, "CVE-2021-33166": {"epss_score": 0.00039, "epss_percentile": 0.11578}, "CVE-2021-33175": {"epss_score": 0.00413, "epss_percentile": 0.60958}, "CVE-2021-33176": {"epss_score": 0.00413, "epss_percentile": 0.60958}, "CVE-2021-33177": {"epss_score": 0.35967, "epss_percentile": 0.96944}, "CVE-2021-33178": {"epss_score": 0.00776, "epss_percentile": 0.73097}, "CVE-2021-33179": {"epss_score": 0.58082, "epss_percentile": 0.98099}, "CVE-2021-33180": {"epss_score": 0.00341, "epss_percentile": 0.56312}, "CVE-2021-33181": {"epss_score": 0.0038, "epss_percentile": 0.58942}, "CVE-2021-33182": {"epss_score": 0.00116, "epss_percentile": 0.312}, "CVE-2021-33183": {"epss_score": 0.00052, "epss_percentile": 0.16479}, "CVE-2021-33184": {"epss_score": 0.0015, "epss_percentile": 0.36139}, "CVE-2021-33185": {"epss_score": 0.00302, "epss_percentile": 0.53107}, "CVE-2021-33186": {"epss_score": 0.00335, "epss_percentile": 0.55831}, "CVE-2021-33190": {"epss_score": 0.01155, "epss_percentile": 0.78073}, "CVE-2021-33191": {"epss_score": 0.05886, "epss_percentile": 0.90293}, "CVE-2021-33192": {"epss_score": 0.03378, "epss_percentile": 0.87026}, "CVE-2021-33193": {"epss_score": 0.00935, "epss_percentile": 0.75665}, "CVE-2021-33194": {"epss_score": 0.00039, "epss_percentile": 0.11441}, "CVE-2021-33195": {"epss_score": 0.00032, "epss_percentile": 0.08788}, "CVE-2021-33196": {"epss_score": 0.00024, "epss_percentile": 0.05663}, "CVE-2021-33197": {"epss_score": 0.00033, "epss_percentile": 0.09131}, "CVE-2021-33198": {"epss_score": 0.00028, "epss_percentile": 0.07528}, "CVE-2021-33199": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-33200": {"epss_score": 0.00033, "epss_percentile": 0.09207}, "CVE-2021-33203": {"epss_score": 0.00327, "epss_percentile": 0.55093}, "CVE-2021-33204": {"epss_score": 0.0105, "epss_percentile": 0.77068}, "CVE-2021-33205": {"epss_score": 0.00511, "epss_percentile": 0.65827}, "CVE-2021-33207": {"epss_score": 0.02785, "epss_percentile": 0.85656}, "CVE-2021-33208": {"epss_score": 0.00941, "epss_percentile": 0.75754}, "CVE-2021-33209": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2021-33210": {"epss_score": 0.00188, "epss_percentile": 0.40832}, "CVE-2021-33211": {"epss_score": 0.00425, "epss_percentile": 0.61696}, "CVE-2021-33212": {"epss_score": 0.00133, "epss_percentile": 0.33656}, "CVE-2021-33213": {"epss_score": 0.00184, "epss_percentile": 0.4043}, "CVE-2021-33214": {"epss_score": 0.00126, "epss_percentile": 0.32703}, "CVE-2021-33215": {"epss_score": 0.00126, "epss_percentile": 0.32663}, "CVE-2021-33216": {"epss_score": 0.17599, "epss_percentile": 0.94872}, "CVE-2021-33217": {"epss_score": 0.00841, "epss_percentile": 0.74216}, "CVE-2021-33218": {"epss_score": 0.0125, "epss_percentile": 0.78878}, "CVE-2021-33219": {"epss_score": 0.00706, "epss_percentile": 0.71605}, "CVE-2021-33220": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2021-33221": {"epss_score": 0.93335, "epss_percentile": 0.99797}, "CVE-2021-33223": {"epss_score": 0.00061, "epss_percentile": 0.1938}, "CVE-2021-33224": {"epss_score": 0.00584, "epss_percentile": 0.68375}, "CVE-2021-33226": {"epss_score": 0.02325, "epss_percentile": 0.84388}, "CVE-2021-33231": {"epss_score": 0.00217, "epss_percentile": 0.4427}, "CVE-2021-33254": {"epss_score": 0.00464, "epss_percentile": 0.63713}, "CVE-2021-33256": {"epss_score": 0.16305, "epss_percentile": 0.94614}, "CVE-2021-33259": {"epss_score": 0.0048, "epss_percentile": 0.64472}, "CVE-2021-33265": {"epss_score": 0.05977, "epss_percentile": 0.90376}, "CVE-2021-33266": {"epss_score": 0.02632, "epss_percentile": 0.85284}, "CVE-2021-33267": {"epss_score": 0.01932, "epss_percentile": 0.82947}, "CVE-2021-33268": {"epss_score": 0.01932, "epss_percentile": 0.82947}, "CVE-2021-33269": {"epss_score": 0.01932, "epss_percentile": 0.82947}, "CVE-2021-33270": {"epss_score": 0.01932, "epss_percentile": 0.82947}, "CVE-2021-33271": {"epss_score": 0.01932, "epss_percentile": 0.82947}, "CVE-2021-33274": {"epss_score": 0.01932, "epss_percentile": 0.82947}, "CVE-2021-33285": {"epss_score": 0.00034, "epss_percentile": 0.09627}, "CVE-2021-33286": {"epss_score": 0.00144, "epss_percentile": 0.35244}, "CVE-2021-33287": {"epss_score": 0.00019, "epss_percentile": 0.04325}, "CVE-2021-33289": {"epss_score": 0.00145, "epss_percentile": 0.35484}, "CVE-2021-33293": {"epss_score": 0.00274, "epss_percentile": 0.50507}, "CVE-2021-33294": {"epss_score": 0.0002, "epss_percentile": 0.04522}, "CVE-2021-33295": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2021-33304": {"epss_score": 0.0035, "epss_percentile": 0.56939}, "CVE-2021-33315": {"epss_score": 0.00638, "epss_percentile": 0.69917}, "CVE-2021-33316": {"epss_score": 0.00638, "epss_percentile": 0.69917}, "CVE-2021-33317": {"epss_score": 0.00458, "epss_percentile": 0.63427}, "CVE-2021-33318": {"epss_score": 0.00743, "epss_percentile": 0.725}, "CVE-2021-33320": {"epss_score": 0.00392, "epss_percentile": 0.59658}, "CVE-2021-33321": {"epss_score": 0.00313, "epss_percentile": 0.54048}, "CVE-2021-33322": {"epss_score": 0.00223, "epss_percentile": 0.44944}, "CVE-2021-33323": {"epss_score": 0.00417, "epss_percentile": 0.61256}, "CVE-2021-33324": {"epss_score": 0.00121, "epss_percentile": 0.31958}, "CVE-2021-33325": {"epss_score": 0.00123, "epss_percentile": 0.32234}, "CVE-2021-33326": {"epss_score": 0.00418, "epss_percentile": 0.61291}, "CVE-2021-33327": {"epss_score": 0.00106, "epss_percentile": 0.29555}, "CVE-2021-33328": {"epss_score": 0.00148, "epss_percentile": 0.35845}, "CVE-2021-33330": {"epss_score": 0.00207, "epss_percentile": 0.43157}, "CVE-2021-33331": {"epss_score": 0.00356, "epss_percentile": 0.5737}, "CVE-2021-33332": {"epss_score": 0.00244, "epss_percentile": 0.47554}, "CVE-2021-33333": {"epss_score": 0.00285, "epss_percentile": 0.51526}, "CVE-2021-33334": {"epss_score": 0.00081, "epss_percentile": 0.24334}, "CVE-2021-33335": {"epss_score": 0.00634, "epss_percentile": 0.69803}, "CVE-2021-33336": {"epss_score": 0.00167, "epss_percentile": 0.3838}, "CVE-2021-33337": {"epss_score": 0.00258, "epss_percentile": 0.49017}, "CVE-2021-33338": {"epss_score": 0.0011, "epss_percentile": 0.30209}, "CVE-2021-33339": {"epss_score": 0.00172, "epss_percentile": 0.38927}, "CVE-2021-33346": {"epss_score": 0.00578, "epss_percentile": 0.68181}, "CVE-2021-33347": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2021-33348": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2021-33351": {"epss_score": 0.00111, "epss_percentile": 0.30315}, "CVE-2021-33352": {"epss_score": 0.00188, "epss_percentile": 0.40874}, "CVE-2021-33353": {"epss_score": 0.00539, "epss_percentile": 0.66964}, "CVE-2021-33354": {"epss_score": 0.01033, "epss_percentile": 0.76874}, "CVE-2021-33356": {"epss_score": 0.11122, "epss_percentile": 0.93229}, "CVE-2021-33357": {"epss_score": 0.94007, "epss_percentile": 0.99885}, "CVE-2021-33358": {"epss_score": 0.00806, "epss_percentile": 0.7366}, "CVE-2021-33359": {"epss_score": 0.01517, "epss_percentile": 0.80801}, "CVE-2021-33360": {"epss_score": 0.00151, "epss_percentile": 0.36189}, "CVE-2021-33361": {"epss_score": 0.00117, "epss_percentile": 0.31339}, "CVE-2021-33362": {"epss_score": 0.00206, "epss_percentile": 0.43073}, "CVE-2021-33363": {"epss_score": 0.00117, "epss_percentile": 0.31339}, "CVE-2021-33364": {"epss_score": 0.00117, "epss_percentile": 0.31339}, "CVE-2021-33365": {"epss_score": 0.00127, "epss_percentile": 0.3283}, "CVE-2021-33366": {"epss_score": 0.00117, "epss_percentile": 0.31339}, "CVE-2021-33367": {"epss_score": 0.00051, "epss_percentile": 0.15992}, "CVE-2021-33371": {"epss_score": 0.00187, "epss_percentile": 0.40765}, "CVE-2021-33387": {"epss_score": 0.00133, "epss_percentile": 0.33744}, "CVE-2021-33388": {"epss_score": 0.00158, "epss_percentile": 0.37194}, "CVE-2021-33390": {"epss_score": 0.00206, "epss_percentile": 0.42781}, "CVE-2021-33391": {"epss_score": 0.00283, "epss_percentile": 0.51406}, "CVE-2021-33393": {"epss_score": 0.7148, "epss_percentile": 0.98671}, "CVE-2021-33394": {"epss_score": 0.00137, "epss_percentile": 0.34251}, "CVE-2021-33396": {"epss_score": 0.00138, "epss_percentile": 0.34443}, "CVE-2021-33403": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2021-33408": {"epss_score": 0.00089, "epss_percentile": 0.25928}, "CVE-2021-33420": {"epss_score": 0.02202, "epss_percentile": 0.83983}, "CVE-2021-33425": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-33430": {"epss_score": 0.00591, "epss_percentile": 0.68585}, "CVE-2021-33436": {"epss_score": 0.00042, "epss_percentile": 0.12671}, "CVE-2021-33437": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2021-33438": {"epss_score": 0.00049, "epss_percentile": 0.15477}, "CVE-2021-33439": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2021-33440": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2021-33441": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2021-33442": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2021-33443": {"epss_score": 0.00049, "epss_percentile": 0.15477}, "CVE-2021-33444": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2021-33445": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2021-33446": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2021-33447": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2021-33448": {"epss_score": 0.00049, "epss_percentile": 0.15477}, "CVE-2021-33449": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2021-33450": {"epss_score": 0.00047, "epss_percentile": 0.14887}, "CVE-2021-33451": {"epss_score": 0.00074, "epss_percentile": 0.2278}, "CVE-2021-33452": {"epss_score": 0.00047, "epss_percentile": 0.14887}, "CVE-2021-33453": {"epss_score": 0.00078, "epss_percentile": 0.2367}, "CVE-2021-33454": {"epss_score": 0.00033, "epss_percentile": 0.09351}, "CVE-2021-33455": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2021-33456": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2021-33457": {"epss_score": 0.00125, "epss_percentile": 0.32547}, "CVE-2021-33458": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2021-33459": {"epss_score": 0.00038, "epss_percentile": 0.11111}, "CVE-2021-33460": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2021-33461": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2021-33462": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2021-33463": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2021-33464": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2021-33465": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2021-33466": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2021-33467": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2021-33468": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2021-33469": {"epss_score": 0.00207, "epss_percentile": 0.4309}, "CVE-2021-33470": {"epss_score": 0.00484, "epss_percentile": 0.64644}, "CVE-2021-33473": {"epss_score": 0.00344, "epss_percentile": 0.56525}, "CVE-2021-33477": {"epss_score": 0.01113, "epss_percentile": 0.77691}, "CVE-2021-33478": {"epss_score": 0.00133, "epss_percentile": 0.33711}, "CVE-2021-33479": {"epss_score": 0.00239, "epss_percentile": 0.46918}, "CVE-2021-33480": {"epss_score": 0.00164, "epss_percentile": 0.37865}, "CVE-2021-33481": {"epss_score": 0.00268, "epss_percentile": 0.50062}, "CVE-2021-33483": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-33484": {"epss_score": 0.00156, "epss_percentile": 0.36972}, "CVE-2021-33485": {"epss_score": 0.00543, "epss_percentile": 0.67119}, "CVE-2021-33486": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-33488": {"epss_score": 0.00299, "epss_percentile": 0.52871}, "CVE-2021-33489": {"epss_score": 0.00341, "epss_percentile": 0.56292}, "CVE-2021-33490": {"epss_score": 0.00341, "epss_percentile": 0.56292}, "CVE-2021-33491": {"epss_score": 0.04366, "epss_percentile": 0.88603}, "CVE-2021-33492": {"epss_score": 0.00397, "epss_percentile": 0.60045}, "CVE-2021-33493": {"epss_score": 0.00202, "epss_percentile": 0.42395}, "CVE-2021-33494": {"epss_score": 0.00397, "epss_percentile": 0.60045}, "CVE-2021-33495": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2021-33496": {"epss_score": 0.00308, "epss_percentile": 0.53636}, "CVE-2021-33497": {"epss_score": 0.01606, "epss_percentile": 0.813}, "CVE-2021-33498": {"epss_score": 0.00449, "epss_percentile": 0.63043}, "CVE-2021-33499": {"epss_score": 0.00449, "epss_percentile": 0.63043}, "CVE-2021-33500": {"epss_score": 0.004, "epss_percentile": 0.60153}, "CVE-2021-33501": {"epss_score": 0.12544, "epss_percentile": 0.93711}, "CVE-2021-33502": {"epss_score": 0.00322, "epss_percentile": 0.54826}, "CVE-2021-33503": {"epss_score": 0.00863, "epss_percentile": 0.74587}, "CVE-2021-33504": {"epss_score": 0.00418, "epss_percentile": 0.61345}, "CVE-2021-33505": {"epss_score": 0.00056, "epss_percentile": 0.17758}, "CVE-2021-33506": {"epss_score": 0.00242, "epss_percentile": 0.47351}, "CVE-2021-33507": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2021-33508": {"epss_score": 0.00272, "epss_percentile": 0.50417}, "CVE-2021-33509": {"epss_score": 0.0098, "epss_percentile": 0.76274}, "CVE-2021-33510": {"epss_score": 0.00123, "epss_percentile": 0.3227}, "CVE-2021-33511": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2021-33512": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-33513": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-33514": {"epss_score": 0.24207, "epss_percentile": 0.95886}, "CVE-2021-33515": {"epss_score": 0.03627, "epss_percentile": 0.8746}, "CVE-2021-33516": {"epss_score": 0.00368, "epss_percentile": 0.58184}, "CVE-2021-33523": {"epss_score": 0.01275, "epss_percentile": 0.79104}, "CVE-2021-33525": {"epss_score": 0.07706, "epss_percentile": 0.91638}, "CVE-2021-33526": {"epss_score": 0.00028, "epss_percentile": 0.0753}, "CVE-2021-33527": {"epss_score": 0.06378, "epss_percentile": 0.9071}, "CVE-2021-33528": {"epss_score": 0.00699, "epss_percentile": 0.71456}, "CVE-2021-33529": {"epss_score": 0.00347, "epss_percentile": 0.56752}, "CVE-2021-33530": {"epss_score": 0.04095, "epss_percentile": 0.88249}, "CVE-2021-33531": {"epss_score": 0.00239, "epss_percentile": 0.46903}, "CVE-2021-33532": {"epss_score": 0.04507, "epss_percentile": 0.88774}, "CVE-2021-33533": {"epss_score": 0.04507, "epss_percentile": 0.88774}, "CVE-2021-33534": {"epss_score": 0.03677, "epss_percentile": 0.87553}, "CVE-2021-33535": {"epss_score": 0.01907, "epss_percentile": 0.82811}, "CVE-2021-33536": {"epss_score": 0.00245, "epss_percentile": 0.47656}, "CVE-2021-33537": {"epss_score": 0.02257, "epss_percentile": 0.84173}, "CVE-2021-33538": {"epss_score": 0.00478, "epss_percentile": 0.64403}, "CVE-2021-33539": {"epss_score": 0.00445, "epss_percentile": 0.62875}, "CVE-2021-33540": {"epss_score": 0.00236, "epss_percentile": 0.46425}, "CVE-2021-33541": {"epss_score": 0.01309, "epss_percentile": 0.79353}, "CVE-2021-33542": {"epss_score": 0.00529, "epss_percentile": 0.66588}, "CVE-2021-33543": {"epss_score": 0.89477, "epss_percentile": 0.99528}, "CVE-2021-33544": {"epss_score": 0.94247, "epss_percentile": 0.99925}, "CVE-2021-33545": {"epss_score": 0.20626, "epss_percentile": 0.95389}, "CVE-2021-33546": {"epss_score": 0.20626, "epss_percentile": 0.95389}, "CVE-2021-33547": {"epss_score": 0.20626, "epss_percentile": 0.95389}, "CVE-2021-33548": {"epss_score": 0.89001, "epss_percentile": 0.99504}, "CVE-2021-33549": {"epss_score": 0.90277, "epss_percentile": 0.99574}, "CVE-2021-33550": {"epss_score": 0.88361, "epss_percentile": 0.99468}, "CVE-2021-33551": {"epss_score": 0.86342, "epss_percentile": 0.99378}, "CVE-2021-33552": {"epss_score": 0.86342, "epss_percentile": 0.99378}, "CVE-2021-33553": {"epss_score": 0.86342, "epss_percentile": 0.99378}, "CVE-2021-33554": {"epss_score": 0.89001, "epss_percentile": 0.99504}, "CVE-2021-33555": {"epss_score": 0.00618, "epss_percentile": 0.69383}, "CVE-2021-33557": {"epss_score": 0.0093, "epss_percentile": 0.75599}, "CVE-2021-33558": {"epss_score": 0.93409, "epss_percentile": 0.99805}, "CVE-2021-33560": {"epss_score": 0.00425, "epss_percentile": 0.61686}, "CVE-2021-33561": {"epss_score": 0.00734, "epss_percentile": 0.72237}, "CVE-2021-33562": {"epss_score": 0.00325, "epss_percentile": 0.54998}, "CVE-2021-33563": {"epss_score": 0.00171, "epss_percentile": 0.38864}, "CVE-2021-33564": {"epss_score": 0.93359, "epss_percentile": 0.998}, "CVE-2021-33570": {"epss_score": 0.01707, "epss_percentile": 0.81863}, "CVE-2021-33571": {"epss_score": 0.00018, "epss_percentile": 0.0402}, "CVE-2021-33572": {"epss_score": 0.00436, "epss_percentile": 0.62484}, "CVE-2021-33574": {"epss_score": 0.0014, "epss_percentile": 0.34748}, "CVE-2021-33575": {"epss_score": 0.0274, "epss_percentile": 0.85558}, "CVE-2021-33576": {"epss_score": 0.00631, "epss_percentile": 0.69716}, "CVE-2021-33577": {"epss_score": 0.00115, "epss_percentile": 0.30895}, "CVE-2021-33578": {"epss_score": 0.0038, "epss_percentile": 0.58925}, "CVE-2021-33580": {"epss_score": 0.02435, "epss_percentile": 0.84736}, "CVE-2021-33581": {"epss_score": 0.00864, "epss_percentile": 0.74605}, "CVE-2021-33582": {"epss_score": 0.04396, "epss_percentile": 0.8864}, "CVE-2021-33583": {"epss_score": 0.00299, "epss_percentile": 0.52886}, "CVE-2021-33586": {"epss_score": 0.00187, "epss_percentile": 0.4072}, "CVE-2021-33587": {"epss_score": 0.00211, "epss_percentile": 0.43627}, "CVE-2021-33589": {"epss_score": 0.00134, "epss_percentile": 0.33776}, "CVE-2021-33590": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-33591": {"epss_score": 0.00862, "epss_percentile": 0.74572}, "CVE-2021-33592": {"epss_score": 0.01044, "epss_percentile": 0.77001}, "CVE-2021-33593": {"epss_score": 0.00203, "epss_percentile": 0.42526}, "CVE-2021-33594": {"epss_score": 0.00303, "epss_percentile": 0.53213}, "CVE-2021-33595": {"epss_score": 0.00303, "epss_percentile": 0.53213}, "CVE-2021-33596": {"epss_score": 0.00273, "epss_percentile": 0.50475}, "CVE-2021-33597": {"epss_score": 0.00145, "epss_percentile": 0.3544}, "CVE-2021-33598": {"epss_score": 0.00351, "epss_percentile": 0.56981}, "CVE-2021-33599": {"epss_score": 0.00145, "epss_percentile": 0.3544}, "CVE-2021-33600": {"epss_score": 0.00371, "epss_percentile": 0.58404}, "CVE-2021-33601": {"epss_score": 0.00723, "epss_percentile": 0.72009}, "CVE-2021-33602": {"epss_score": 0.0029, "epss_percentile": 0.52132}, "CVE-2021-33603": {"epss_score": 0.00342, "epss_percentile": 0.56395}, "CVE-2021-33604": {"epss_score": 0.00054, "epss_percentile": 0.17047}, "CVE-2021-33605": {"epss_score": 0.00336, "epss_percentile": 0.55949}, "CVE-2021-33609": {"epss_score": 0.00205, "epss_percentile": 0.42725}, "CVE-2021-33611": {"epss_score": 0.00304, "epss_percentile": 0.53273}, "CVE-2021-33615": {"epss_score": 0.00536, "epss_percentile": 0.6685}, "CVE-2021-33616": {"epss_score": 0.00511, "epss_percentile": 0.65841}, "CVE-2021-33617": {"epss_score": 0.00483, "epss_percentile": 0.6459}, "CVE-2021-33618": {"epss_score": 0.00409, "epss_percentile": 0.60734}, "CVE-2021-33620": {"epss_score": 0.05906, "epss_percentile": 0.90313}, "CVE-2021-33621": {"epss_score": 0.01521, "epss_percentile": 0.80827}, "CVE-2021-33622": {"epss_score": 0.00547, "epss_percentile": 0.67234}, "CVE-2021-33623": {"epss_score": 0.01255, "epss_percentile": 0.78927}, "CVE-2021-33624": {"epss_score": 0.00473, "epss_percentile": 0.64107}, "CVE-2021-33625": {"epss_score": 0.00063, "epss_percentile": 0.19894}, "CVE-2021-33626": {"epss_score": 0.00078, "epss_percentile": 0.23566}, "CVE-2021-33627": {"epss_score": 0.00155, "epss_percentile": 0.36857}, "CVE-2021-33629": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-33630": {"epss_score": 0.00064, "epss_percentile": 0.20395}, "CVE-2021-33631": {"epss_score": 0.00159, "epss_percentile": 0.37321}, "CVE-2021-33632": {"epss_score": 0.00021, "epss_percentile": 0.04886}, "CVE-2021-33633": {"epss_score": 0.00038, "epss_percentile": 0.11427}, "CVE-2021-33634": {"epss_score": 0.00033, "epss_percentile": 0.0931}, "CVE-2021-33635": {"epss_score": 0.00149, "epss_percentile": 0.36005}, "CVE-2021-33636": {"epss_score": 0.00057, "epss_percentile": 0.17982}, "CVE-2021-33637": {"epss_score": 0.00031, "epss_percentile": 0.08651}, "CVE-2021-33638": {"epss_score": 0.00031, "epss_percentile": 0.08651}, "CVE-2021-33639": {"epss_score": 0.00075, "epss_percentile": 0.23005}, "CVE-2021-33640": {"epss_score": 0.00183, "epss_percentile": 0.40301}, "CVE-2021-33641": {"epss_score": 0.00041, "epss_percentile": 0.12423}, "CVE-2021-33642": {"epss_score": 0.00038, "epss_percentile": 0.1133}, "CVE-2021-33643": {"epss_score": 0.00194, "epss_percentile": 0.41566}, "CVE-2021-33644": {"epss_score": 0.00194, "epss_percentile": 0.41566}, "CVE-2021-33645": {"epss_score": 0.00188, "epss_percentile": 0.40884}, "CVE-2021-33646": {"epss_score": 0.00188, "epss_percentile": 0.40884}, "CVE-2021-33647": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-33648": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-33649": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2021-33650": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-33651": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-33652": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2021-33653": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2021-33654": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-33655": {"epss_score": 0.00024, "epss_percentile": 0.05672}, "CVE-2021-33656": {"epss_score": 0.0003, "epss_percentile": 0.08237}, "CVE-2021-33657": {"epss_score": 0.00082, "epss_percentile": 0.24505}, "CVE-2021-33658": {"epss_score": 0.00021, "epss_percentile": 0.04786}, "CVE-2021-33659": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2021-33660": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2021-33661": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2021-33662": {"epss_score": 0.00042, "epss_percentile": 0.12815}, "CVE-2021-33663": {"epss_score": 0.00189, "epss_percentile": 0.40987}, "CVE-2021-33664": {"epss_score": 0.00237, "epss_percentile": 0.46696}, "CVE-2021-33665": {"epss_score": 0.00237, "epss_percentile": 0.46696}, "CVE-2021-33666": {"epss_score": 0.0015, "epss_percentile": 0.36049}, "CVE-2021-33667": {"epss_score": 0.00255, "epss_percentile": 0.48662}, "CVE-2021-33668": {"epss_score": 0.01902, "epss_percentile": 0.82781}, "CVE-2021-33669": {"epss_score": 0.00027, "epss_percentile": 0.07086}, "CVE-2021-33670": {"epss_score": 0.05562, "epss_percentile": 0.89996}, "CVE-2021-33671": {"epss_score": 0.00222, "epss_percentile": 0.44785}, "CVE-2021-33672": {"epss_score": 0.00269, "epss_percentile": 0.5011}, "CVE-2021-33673": {"epss_score": 0.00327, "epss_percentile": 0.55134}, "CVE-2021-33674": {"epss_score": 0.00265, "epss_percentile": 0.49796}, "CVE-2021-33675": {"epss_score": 0.00295, "epss_percentile": 0.52449}, "CVE-2021-33676": {"epss_score": 0.00237, "epss_percentile": 0.46726}, "CVE-2021-33677": {"epss_score": 0.00197, "epss_percentile": 0.41887}, "CVE-2021-33678": {"epss_score": 0.00707, "epss_percentile": 0.7166}, "CVE-2021-33679": {"epss_score": 0.00162, "epss_percentile": 0.37663}, "CVE-2021-33680": {"epss_score": 0.00314, "epss_percentile": 0.54123}, "CVE-2021-33681": {"epss_score": 0.00291, "epss_percentile": 0.52185}, "CVE-2021-33682": {"epss_score": 0.00235, "epss_percentile": 0.46213}, "CVE-2021-33683": {"epss_score": 0.00086, "epss_percentile": 0.25398}, "CVE-2021-33684": {"epss_score": 0.00182, "epss_percentile": 0.4026}, "CVE-2021-33685": {"epss_score": 0.00331, "epss_percentile": 0.55512}, "CVE-2021-33686": {"epss_score": 0.00204, "epss_percentile": 0.42635}, "CVE-2021-33687": {"epss_score": 0.00448, "epss_percentile": 0.63016}, "CVE-2021-33688": {"epss_score": 0.00295, "epss_percentile": 0.52468}, "CVE-2021-33689": {"epss_score": 0.00336, "epss_percentile": 0.55949}, "CVE-2021-33690": {"epss_score": 0.93259, "epss_percentile": 0.99789}, "CVE-2021-33691": {"epss_score": 0.00231, "epss_percentile": 0.45838}, "CVE-2021-33692": {"epss_score": 0.0035, "epss_percentile": 0.56923}, "CVE-2021-33693": {"epss_score": 0.00127, "epss_percentile": 0.32779}, "CVE-2021-33694": {"epss_score": 0.00156, "epss_percentile": 0.37003}, "CVE-2021-33695": {"epss_score": 0.0011, "epss_percentile": 0.30106}, "CVE-2021-33696": {"epss_score": 0.00162, "epss_percentile": 0.37663}, "CVE-2021-33697": {"epss_score": 0.00238, "epss_percentile": 0.46791}, "CVE-2021-33698": {"epss_score": 0.00303, "epss_percentile": 0.53234}, "CVE-2021-33699": {"epss_score": 0.03868, "epss_percentile": 0.87874}, "CVE-2021-33700": {"epss_score": 0.00036, "epss_percentile": 0.10212}, "CVE-2021-33701": {"epss_score": 0.01249, "epss_percentile": 0.78872}, "CVE-2021-33702": {"epss_score": 0.00738, "epss_percentile": 0.72346}, "CVE-2021-33703": {"epss_score": 0.00666, "epss_percentile": 0.70683}, "CVE-2021-33704": {"epss_score": 0.00222, "epss_percentile": 0.44785}, "CVE-2021-33705": {"epss_score": 0.00691, "epss_percentile": 0.71267}, "CVE-2021-33706": {"epss_score": 0.00335, "epss_percentile": 0.55848}, "CVE-2021-33707": {"epss_score": 0.00606, "epss_percentile": 0.69027}, "CVE-2021-33708": {"epss_score": 0.00662, "epss_percentile": 0.70593}, "CVE-2021-33709": {"epss_score": 0.00279, "epss_percentile": 0.50946}, "CVE-2021-33710": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2021-33711": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2021-33712": {"epss_score": 0.00246, "epss_percentile": 0.47802}, "CVE-2021-33713": {"epss_score": 0.00053, "epss_percentile": 0.1687}, "CVE-2021-33714": {"epss_score": 0.00053, "epss_percentile": 0.1687}, "CVE-2021-33715": {"epss_score": 0.00053, "epss_percentile": 0.1687}, "CVE-2021-33716": {"epss_score": 0.00085, "epss_percentile": 0.25043}, "CVE-2021-33717": {"epss_score": 0.00164, "epss_percentile": 0.3795}, "CVE-2021-33718": {"epss_score": 0.00103, "epss_percentile": 0.29083}, "CVE-2021-33719": {"epss_score": 0.00556, "epss_percentile": 0.67511}, "CVE-2021-33720": {"epss_score": 0.00444, "epss_percentile": 0.62829}, "CVE-2021-33721": {"epss_score": 0.05085, "epss_percentile": 0.89477}, "CVE-2021-33722": {"epss_score": 0.00203, "epss_percentile": 0.42527}, "CVE-2021-33723": {"epss_score": 0.00152, "epss_percentile": 0.36457}, "CVE-2021-33724": {"epss_score": 0.00844, "epss_percentile": 0.74276}, "CVE-2021-33725": {"epss_score": 0.00844, "epss_percentile": 0.74276}, "CVE-2021-33726": {"epss_score": 0.00445, "epss_percentile": 0.62876}, "CVE-2021-33727": {"epss_score": 0.00328, "epss_percentile": 0.55177}, "CVE-2021-33728": {"epss_score": 0.01993, "epss_percentile": 0.83183}, "CVE-2021-33729": {"epss_score": 0.008, "epss_percentile": 0.73546}, "CVE-2021-33730": {"epss_score": 0.00755, "epss_percentile": 0.72712}, "CVE-2021-33731": {"epss_score": 0.00755, "epss_percentile": 0.72712}, "CVE-2021-33732": {"epss_score": 0.00755, "epss_percentile": 0.72712}, "CVE-2021-33733": {"epss_score": 0.0131, "epss_percentile": 0.79358}, "CVE-2021-33734": {"epss_score": 0.00755, "epss_percentile": 0.72712}, "CVE-2021-33735": {"epss_score": 0.00643, "epss_percentile": 0.70054}, "CVE-2021-33736": {"epss_score": 0.00643, "epss_percentile": 0.70054}, "CVE-2021-33737": {"epss_score": 0.00229, "epss_percentile": 0.45552}, "CVE-2021-33738": {"epss_score": 0.00276, "epss_percentile": 0.50739}, "CVE-2021-33739": {"epss_score": 0.20095, "epss_percentile": 0.95287}, "CVE-2021-33740": {"epss_score": 0.02076, "epss_percentile": 0.83506}, "CVE-2021-33741": {"epss_score": 0.02246, "epss_percentile": 0.84133}, "CVE-2021-33742": {"epss_score": 0.72116, "epss_percentile": 0.98695}, "CVE-2021-33743": {"epss_score": 0.00214, "epss_percentile": 0.43961}, "CVE-2021-33744": {"epss_score": 0.00191, "epss_percentile": 0.4119}, "CVE-2021-33745": {"epss_score": 0.04362, "epss_percentile": 0.88597}, "CVE-2021-33746": {"epss_score": 0.07579, "epss_percentile": 0.9155}, "CVE-2021-33749": {"epss_score": 0.08567, "epss_percentile": 0.92128}, "CVE-2021-33750": {"epss_score": 0.02701, "epss_percentile": 0.85453}, "CVE-2021-33751": {"epss_score": 0.00625, "epss_percentile": 0.69588}, "CVE-2021-33752": {"epss_score": 0.02701, "epss_percentile": 0.85453}, "CVE-2021-33753": {"epss_score": 0.0098, "epss_percentile": 0.76272}, "CVE-2021-33754": {"epss_score": 0.01789, "epss_percentile": 0.82276}, "CVE-2021-33755": {"epss_score": 0.01516, "epss_percentile": 0.80798}, "CVE-2021-33756": {"epss_score": 0.02281, "epss_percentile": 0.84248}, "CVE-2021-33757": {"epss_score": 0.02507, "epss_percentile": 0.84938}, "CVE-2021-33758": {"epss_score": 0.0175, "epss_percentile": 0.82097}, "CVE-2021-33759": {"epss_score": 0.00275, "epss_percentile": 0.50676}, "CVE-2021-33760": {"epss_score": 0.0053, "epss_percentile": 0.66605}, "CVE-2021-33761": {"epss_score": 0.00275, "epss_percentile": 0.50676}, "CVE-2021-33762": {"epss_score": 0.00221, "epss_percentile": 0.44663}, "CVE-2021-33763": {"epss_score": 0.00351, "epss_percentile": 0.57046}, "CVE-2021-33764": {"epss_score": 0.02072, "epss_percentile": 0.83491}, "CVE-2021-33765": {"epss_score": 0.006, "epss_percentile": 0.68824}, "CVE-2021-33766": {"epss_score": 0.93483, "epss_percentile": 0.9981}, "CVE-2021-33767": {"epss_score": 0.00482, "epss_percentile": 0.64538}, "CVE-2021-33768": {"epss_score": 0.00207, "epss_percentile": 0.43204}, "CVE-2021-33771": {"epss_score": 0.10647, "epss_percentile": 0.93057}, "CVE-2021-33772": {"epss_score": 0.057, "epss_percentile": 0.90131}, "CVE-2021-33773": {"epss_score": 0.00243, "epss_percentile": 0.47491}, "CVE-2021-33774": {"epss_score": 0.00232, "epss_percentile": 0.45964}, "CVE-2021-33775": {"epss_score": 0.01129, "epss_percentile": 0.77838}, "CVE-2021-33776": {"epss_score": 0.01129, "epss_percentile": 0.77838}, "CVE-2021-33777": {"epss_score": 0.01129, "epss_percentile": 0.77838}, "CVE-2021-33778": {"epss_score": 0.05015, "epss_percentile": 0.89395}, "CVE-2021-33779": {"epss_score": 0.00816, "epss_percentile": 0.73803}, "CVE-2021-33780": {"epss_score": 0.01756, "epss_percentile": 0.82124}, "CVE-2021-33781": {"epss_score": 0.01055, "epss_percentile": 0.7712}, "CVE-2021-33782": {"epss_score": 0.02885, "epss_percentile": 0.85909}, "CVE-2021-33783": {"epss_score": 0.19885, "epss_percentile": 0.95255}, "CVE-2021-33784": {"epss_score": 0.00275, "epss_percentile": 0.50676}, "CVE-2021-33785": {"epss_score": 0.0486, "epss_percentile": 0.89221}, "CVE-2021-33786": {"epss_score": 0.01531, "epss_percentile": 0.80888}, "CVE-2021-33788": {"epss_score": 0.07758, "epss_percentile": 0.91663}, "CVE-2021-33790": {"epss_score": 0.05433, "epss_percentile": 0.89878}, "CVE-2021-33792": {"epss_score": 0.00035, "epss_percentile": 0.09977}, "CVE-2021-33793": {"epss_score": 0.00027, "epss_percentile": 0.0675}, "CVE-2021-33794": {"epss_score": 0.00027, "epss_percentile": 0.0675}, "CVE-2021-33795": {"epss_score": 0.00023, "epss_percentile": 0.05616}, "CVE-2021-33796": {"epss_score": 0.0008, "epss_percentile": 0.2405}, "CVE-2021-33797": {"epss_score": 0.00097, "epss_percentile": 0.27624}, "CVE-2021-33798": {"epss_score": 0.00061, "epss_percentile": 0.19453}, "CVE-2021-33800": {"epss_score": 0.00423, "epss_percentile": 0.61581}, "CVE-2021-33806": {"epss_score": 0.06862, "epss_percentile": 0.9108}, "CVE-2021-33807": {"epss_score": 0.7766, "epss_percentile": 0.98946}, "CVE-2021-33813": {"epss_score": 0.0103, "epss_percentile": 0.76838}, "CVE-2021-33815": {"epss_score": 0.00119, "epss_percentile": 0.31564}, "CVE-2021-33816": {"epss_score": 0.02572, "epss_percentile": 0.85133}, "CVE-2021-33818": {"epss_score": 0.0056, "epss_percentile": 0.67652}, "CVE-2021-33820": {"epss_score": 0.0056, "epss_percentile": 0.67652}, "CVE-2021-33822": {"epss_score": 0.0056, "epss_percentile": 0.67652}, "CVE-2021-33823": {"epss_score": 0.0054, "epss_percentile": 0.66997}, "CVE-2021-33824": {"epss_score": 0.00645, "epss_percentile": 0.70123}, "CVE-2021-33827": {"epss_score": 0.01328, "epss_percentile": 0.79499}, "CVE-2021-33828": {"epss_score": 0.00536, "epss_percentile": 0.66849}, "CVE-2021-33829": {"epss_score": 0.47617, "epss_percentile": 0.97593}, "CVE-2021-33831": {"epss_score": 0.0803, "epss_percentile": 0.91841}, "CVE-2021-33833": {"epss_score": 0.00155, "epss_percentile": 0.36772}, "CVE-2021-33834": {"epss_score": 0.00071, "epss_percentile": 0.22122}, "CVE-2021-33838": {"epss_score": 0.02132, "epss_percentile": 0.83715}, "CVE-2021-33839": {"epss_score": 0.02088, "epss_percentile": 0.83556}, "CVE-2021-33840": {"epss_score": 0.00482, "epss_percentile": 0.64549}, "CVE-2021-33841": {"epss_score": 0.01478, "epss_percentile": 0.80549}, "CVE-2021-33842": {"epss_score": 0.00115, "epss_percentile": 0.31028}, "CVE-2021-33843": {"epss_score": 0.00197, "epss_percentile": 0.41861}, "CVE-2021-33844": {"epss_score": 0.00038, "epss_percentile": 0.11128}, "CVE-2021-33845": {"epss_score": 0.00292, "epss_percentile": 0.52222}, "CVE-2021-33846": {"epss_score": 0.00045, "epss_percentile": 0.14051}, "CVE-2021-33847": {"epss_score": 0.00057, "epss_percentile": 0.17992}, "CVE-2021-33848": {"epss_score": 0.00171, "epss_percentile": 0.38821}, "CVE-2021-33849": {"epss_score": 0.02191, "epss_percentile": 0.83939}, "CVE-2021-33850": {"epss_score": 0.00681, "epss_percentile": 0.71042}, "CVE-2021-33851": {"epss_score": 0.07455, "epss_percentile": 0.91481}, "CVE-2021-33852": {"epss_score": 0.00197, "epss_percentile": 0.41908}, "CVE-2021-33853": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-33879": {"epss_score": 0.00848, "epss_percentile": 0.74367}, "CVE-2021-33880": {"epss_score": 0.00192, "epss_percentile": 0.41351}, "CVE-2021-33881": {"epss_score": 0.0006, "epss_percentile": 0.19101}, "CVE-2021-33882": {"epss_score": 0.00314, "epss_percentile": 0.54115}, "CVE-2021-33883": {"epss_score": 0.00251, "epss_percentile": 0.48277}, "CVE-2021-33884": {"epss_score": 0.00479, "epss_percentile": 0.6444}, "CVE-2021-33885": {"epss_score": 0.07945, "epss_percentile": 0.91781}, "CVE-2021-33886": {"epss_score": 0.02581, "epss_percentile": 0.85152}, "CVE-2021-33887": {"epss_score": 0.00027, "epss_percentile": 0.07115}, "CVE-2021-33889": {"epss_score": 0.00079, "epss_percentile": 0.23822}, "CVE-2021-33894": {"epss_score": 0.01622, "epss_percentile": 0.81397}, "CVE-2021-33895": {"epss_score": 0.00386, "epss_percentile": 0.59236}, "CVE-2021-33896": {"epss_score": 0.00524, "epss_percentile": 0.6633}, "CVE-2021-33897": {"epss_score": 0.00065, "epss_percentile": 0.20508}, "CVE-2021-33898": {"epss_score": 0.01856, "epss_percentile": 0.82569}, "CVE-2021-33900": {"epss_score": 0.00141, "epss_percentile": 0.34899}, "CVE-2021-33903": {"epss_score": 0.00397, "epss_percentile": 0.60021}, "CVE-2021-33904": {"epss_score": 0.12306, "epss_percentile": 0.9363}, "CVE-2021-33907": {"epss_score": 0.03254, "epss_percentile": 0.86758}, "CVE-2021-33909": {"epss_score": 0.0242, "epss_percentile": 0.84702}, "CVE-2021-33910": {"epss_score": 0.00079, "epss_percentile": 0.23986}, "CVE-2021-33911": {"epss_score": 0.06834, "epss_percentile": 0.91056}, "CVE-2021-33912": {"epss_score": 0.0135, "epss_percentile": 0.79674}, "CVE-2021-33913": {"epss_score": 0.0135, "epss_percentile": 0.79674}, "CVE-2021-33923": {"epss_score": 0.00046, "epss_percentile": 0.14167}, "CVE-2021-33924": {"epss_score": 0.00798, "epss_percentile": 0.73504}, "CVE-2021-33925": {"epss_score": 0.00642, "epss_percentile": 0.70023}, "CVE-2021-33926": {"epss_score": 0.0028, "epss_percentile": 0.51043}, "CVE-2021-33928": {"epss_score": 0.0006, "epss_percentile": 0.19218}, "CVE-2021-33929": {"epss_score": 0.0006, "epss_percentile": 0.19218}, "CVE-2021-33930": {"epss_score": 0.0006, "epss_percentile": 0.19218}, "CVE-2021-33938": {"epss_score": 0.0006, "epss_percentile": 0.19218}, "CVE-2021-33945": {"epss_score": 0.00539, "epss_percentile": 0.66964}, "CVE-2021-33948": {"epss_score": 0.00097, "epss_percentile": 0.2748}, "CVE-2021-33949": {"epss_score": 0.00627, "epss_percentile": 0.6964}, "CVE-2021-33950": {"epss_score": 0.00108, "epss_percentile": 0.29888}, "CVE-2021-33959": {"epss_score": 0.17986, "epss_percentile": 0.94937}, "CVE-2021-33961": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2021-33962": {"epss_score": 0.03834, "epss_percentile": 0.87812}, "CVE-2021-33963": {"epss_score": 0.01827, "epss_percentile": 0.82438}, "CVE-2021-33964": {"epss_score": 0.03901, "epss_percentile": 0.87921}, "CVE-2021-33965": {"epss_score": 0.03901, "epss_percentile": 0.87921}, "CVE-2021-33966": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2021-33970": {"epss_score": 0.00365, "epss_percentile": 0.58015}, "CVE-2021-33971": {"epss_score": 0.00049, "epss_percentile": 0.15647}, "CVE-2021-33972": {"epss_score": 0.00119, "epss_percentile": 0.31539}, "CVE-2021-33973": {"epss_score": 0.0004, "epss_percentile": 0.12163}, "CVE-2021-33974": {"epss_score": 0.00146, "epss_percentile": 0.3556}, "CVE-2021-33975": {"epss_score": 0.00299, "epss_percentile": 0.52869}, "CVE-2021-33981": {"epss_score": 0.00148, "epss_percentile": 0.35855}, "CVE-2021-33982": {"epss_score": 0.0024, "epss_percentile": 0.4719}, "CVE-2021-33983": {"epss_score": 0.00138, "epss_percentile": 0.34348}, "CVE-2021-33988": {"epss_score": 0.00826, "epss_percentile": 0.73961}, "CVE-2021-33990": {"epss_score": 0.55745, "epss_percentile": 0.97993}, "CVE-2021-34055": {"epss_score": 0.00064, "epss_percentile": 0.20172}, "CVE-2021-34066": {"epss_score": 0.00231, "epss_percentile": 0.45837}, "CVE-2021-34067": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2021-34068": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2021-34069": {"epss_score": 0.00286, "epss_percentile": 0.51783}, "CVE-2021-34070": {"epss_score": 0.00286, "epss_percentile": 0.51783}, "CVE-2021-34071": {"epss_score": 0.00288, "epss_percentile": 0.51887}, "CVE-2021-34073": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2021-34074": {"epss_score": 0.04813, "epss_percentile": 0.89169}, "CVE-2021-34075": {"epss_score": 0.00362, "epss_percentile": 0.57784}, "CVE-2021-34076": {"epss_score": 0.00232, "epss_percentile": 0.45928}, "CVE-2021-34078": {"epss_score": 0.03214, "epss_percentile": 0.86659}, "CVE-2021-34079": {"epss_score": 0.10238, "epss_percentile": 0.92906}, "CVE-2021-34080": {"epss_score": 0.14688, "epss_percentile": 0.94265}, "CVE-2021-34081": {"epss_score": 0.06326, "epss_percentile": 0.90672}, "CVE-2021-34082": {"epss_score": 0.13289, "epss_percentile": 0.93923}, "CVE-2021-34083": {"epss_score": 0.00649, "epss_percentile": 0.70224}, "CVE-2021-34084": {"epss_score": 0.14688, "epss_percentile": 0.94265}, "CVE-2021-34085": {"epss_score": 0.00593, "epss_percentile": 0.68641}, "CVE-2021-34086": {"epss_score": 0.00213, "epss_percentile": 0.43843}, "CVE-2021-34087": {"epss_score": 0.00378, "epss_percentile": 0.58813}, "CVE-2021-34110": {"epss_score": 0.01969, "epss_percentile": 0.83089}, "CVE-2021-34111": {"epss_score": 0.04013, "epss_percentile": 0.88116}, "CVE-2021-34117": {"epss_score": 0.00912, "epss_percentile": 0.75358}, "CVE-2021-34119": {"epss_score": 0.00019, "epss_percentile": 0.04065}, "CVE-2021-34121": {"epss_score": 0.00027, "epss_percentile": 0.06824}, "CVE-2021-34122": {"epss_score": 0.00286, "epss_percentile": 0.51783}, "CVE-2021-34123": {"epss_score": 0.0009, "epss_percentile": 0.26159}, "CVE-2021-34125": {"epss_score": 0.00168, "epss_percentile": 0.38465}, "CVE-2021-34128": {"epss_score": 0.0074, "epss_percentile": 0.72409}, "CVE-2021-34129": {"epss_score": 0.0087, "epss_percentile": 0.74698}, "CVE-2021-34141": {"epss_score": 0.00065, "epss_percentile": 0.20462}, "CVE-2021-34143": {"epss_score": 0.00241, "epss_percentile": 0.47281}, "CVE-2021-34144": {"epss_score": 0.00138, "epss_percentile": 0.344}, "CVE-2021-34145": {"epss_score": 0.00116, "epss_percentile": 0.311}, "CVE-2021-34146": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2021-34147": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2021-34148": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2021-34149": {"epss_score": 0.00147, "epss_percentile": 0.35774}, "CVE-2021-34150": {"epss_score": 0.00129, "epss_percentile": 0.33099}, "CVE-2021-34164": {"epss_score": 0.00101, "epss_percentile": 0.28655}, "CVE-2021-34165": {"epss_score": 0.00656, "epss_percentile": 0.70452}, "CVE-2021-34166": {"epss_score": 0.00656, "epss_percentile": 0.70452}, "CVE-2021-34167": {"epss_score": 0.00533, "epss_percentile": 0.66771}, "CVE-2021-34170": {"epss_score": 0.03417, "epss_percentile": 0.87093}, "CVE-2021-34173": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2021-34174": {"epss_score": 0.00147, "epss_percentile": 0.35694}, "CVE-2021-34181": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2021-34182": {"epss_score": 0.00137, "epss_percentile": 0.34242}, "CVE-2021-34184": {"epss_score": 0.00385, "epss_percentile": 0.59189}, "CVE-2021-34185": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-34187": {"epss_score": 0.89805, "epss_percentile": 0.99542}, "CVE-2021-34190": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2021-34193": {"epss_score": 0.00477, "epss_percentile": 0.64299}, "CVE-2021-34201": {"epss_score": 0.00057, "epss_percentile": 0.18107}, "CVE-2021-34202": {"epss_score": 0.00334, "epss_percentile": 0.55684}, "CVE-2021-34203": {"epss_score": 0.00069, "epss_percentile": 0.21466}, "CVE-2021-34204": {"epss_score": 0.00061, "epss_percentile": 0.19532}, "CVE-2021-34207": {"epss_score": 0.00212, "epss_percentile": 0.43787}, "CVE-2021-34215": {"epss_score": 0.00191, "epss_percentile": 0.41202}, "CVE-2021-34218": {"epss_score": 0.00209, "epss_percentile": 0.43384}, "CVE-2021-34220": {"epss_score": 0.00191, "epss_percentile": 0.41202}, "CVE-2021-34223": {"epss_score": 0.00191, "epss_percentile": 0.41202}, "CVE-2021-34228": {"epss_score": 0.01806, "epss_percentile": 0.8235}, "CVE-2021-34235": {"epss_score": 0.0032, "epss_percentile": 0.54579}, "CVE-2021-34236": {"epss_score": 0.0196, "epss_percentile": 0.83056}, "CVE-2021-34243": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-34244": {"epss_score": 0.00141, "epss_percentile": 0.34861}, "CVE-2021-34249": {"epss_score": 0.00077, "epss_percentile": 0.23368}, "CVE-2021-34254": {"epss_score": 0.00354, "epss_percentile": 0.57211}, "CVE-2021-34257": {"epss_score": 0.00919, "epss_percentile": 0.7546}, "CVE-2021-34259": {"epss_score": 0.00081, "epss_percentile": 0.24331}, "CVE-2021-34260": {"epss_score": 0.00081, "epss_percentile": 0.24331}, "CVE-2021-34261": {"epss_score": 0.00134, "epss_percentile": 0.33923}, "CVE-2021-34262": {"epss_score": 0.00081, "epss_percentile": 0.24331}, "CVE-2021-34267": {"epss_score": 0.00055, "epss_percentile": 0.17571}, "CVE-2021-34268": {"epss_score": 0.00055, "epss_percentile": 0.17571}, "CVE-2021-34270": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2021-34272": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2021-34273": {"epss_score": 0.0031, "epss_percentile": 0.5377}, "CVE-2021-34280": {"epss_score": 0.00682, "epss_percentile": 0.71082}, "CVE-2021-34291": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34292": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34293": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34294": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34295": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34296": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34297": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34298": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34299": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2021-34300": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34301": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34302": {"epss_score": 0.00178, "epss_percentile": 0.39665}, "CVE-2021-34303": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2021-34304": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2021-34305": {"epss_score": 0.00463, "epss_percentile": 0.63687}, "CVE-2021-34306": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-34307": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2021-34308": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2021-34309": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34310": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34311": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34312": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-34313": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-34314": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34315": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34316": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34317": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-34318": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-34319": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34320": {"epss_score": 0.00178, "epss_percentile": 0.39665}, "CVE-2021-34321": {"epss_score": 0.00178, "epss_percentile": 0.39665}, "CVE-2021-34322": {"epss_score": 0.00204, "epss_percentile": 0.42621}, "CVE-2021-34323": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34324": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34325": {"epss_score": 0.00178, "epss_percentile": 0.39665}, "CVE-2021-34326": {"epss_score": 0.00448, "epss_percentile": 0.63022}, "CVE-2021-34327": {"epss_score": 0.00448, "epss_percentile": 0.63022}, "CVE-2021-34328": {"epss_score": 0.00448, "epss_percentile": 0.63022}, "CVE-2021-34329": {"epss_score": 0.00448, "epss_percentile": 0.63022}, "CVE-2021-34330": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-34331": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-34332": {"epss_score": 0.00164, "epss_percentile": 0.3795}, "CVE-2021-34333": {"epss_score": 0.00285, "epss_percentile": 0.51531}, "CVE-2021-34334": {"epss_score": 0.00112, "epss_percentile": 0.30547}, "CVE-2021-34335": {"epss_score": 0.00075, "epss_percentile": 0.22954}, "CVE-2021-34337": {"epss_score": 0.00511, "epss_percentile": 0.65817}, "CVE-2021-34338": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2021-34339": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2021-34340": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2021-34341": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2021-34342": {"epss_score": 0.00279, "epss_percentile": 0.50982}, "CVE-2021-34343": {"epss_score": 0.00477, "epss_percentile": 0.64335}, "CVE-2021-34344": {"epss_score": 0.00546, "epss_percentile": 0.67225}, "CVE-2021-34345": {"epss_score": 0.01214, "epss_percentile": 0.78575}, "CVE-2021-34346": {"epss_score": 0.00723, "epss_percentile": 0.7201}, "CVE-2021-34348": {"epss_score": 0.00896, "epss_percentile": 0.75113}, "CVE-2021-34349": {"epss_score": 0.01086, "epss_percentile": 0.77419}, "CVE-2021-34351": {"epss_score": 0.01215, "epss_percentile": 0.78582}, "CVE-2021-34352": {"epss_score": 0.04181, "epss_percentile": 0.88357}, "CVE-2021-34354": {"epss_score": 0.00255, "epss_percentile": 0.48632}, "CVE-2021-34355": {"epss_score": 0.00169, "epss_percentile": 0.3863}, "CVE-2021-34356": {"epss_score": 0.00255, "epss_percentile": 0.48632}, "CVE-2021-34357": {"epss_score": 0.0035, "epss_percentile": 0.56948}, "CVE-2021-34358": {"epss_score": 0.00119, "epss_percentile": 0.31564}, "CVE-2021-34359": {"epss_score": 0.00222, "epss_percentile": 0.44724}, "CVE-2021-34360": {"epss_score": 0.00087, "epss_percentile": 0.25621}, "CVE-2021-34361": {"epss_score": 0.0035, "epss_percentile": 0.56948}, "CVE-2021-34362": {"epss_score": 0.00867, "epss_percentile": 0.74659}, "CVE-2021-34363": {"epss_score": 0.01125, "epss_percentile": 0.77804}, "CVE-2021-34364": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-34369": {"epss_score": 0.06771, "epss_percentile": 0.91015}, "CVE-2021-34370": {"epss_score": 0.11651, "epss_percentile": 0.93434}, "CVE-2021-34371": {"epss_score": 0.64924, "epss_percentile": 0.98398}, "CVE-2021-34372": {"epss_score": 0.00075, "epss_percentile": 0.23004}, "CVE-2021-34373": {"epss_score": 0.00073, "epss_percentile": 0.22476}, "CVE-2021-34374": {"epss_score": 0.00061, "epss_percentile": 0.19461}, "CVE-2021-34375": {"epss_score": 0.00073, "epss_percentile": 0.22476}, "CVE-2021-34376": {"epss_score": 0.00052, "epss_percentile": 0.16512}, "CVE-2021-34377": {"epss_score": 0.00052, "epss_percentile": 0.16512}, "CVE-2021-34378": {"epss_score": 0.00052, "epss_percentile": 0.16512}, "CVE-2021-34379": {"epss_score": 0.00065, "epss_percentile": 0.20611}, "CVE-2021-34380": {"epss_score": 0.00079, "epss_percentile": 0.23869}, "CVE-2021-34381": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2021-34382": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-34383": {"epss_score": 0.00073, "epss_percentile": 0.22476}, "CVE-2021-34384": {"epss_score": 0.00079, "epss_percentile": 0.23869}, "CVE-2021-34385": {"epss_score": 0.0007, "epss_percentile": 0.21832}, "CVE-2021-34386": {"epss_score": 0.0007, "epss_percentile": 0.21832}, "CVE-2021-34387": {"epss_score": 0.00027, "epss_percentile": 0.07172}, "CVE-2021-34388": {"epss_score": 0.00079, "epss_percentile": 0.23869}, "CVE-2021-34389": {"epss_score": 0.00051, "epss_percentile": 0.1604}, "CVE-2021-34390": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-34391": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2021-34392": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-34393": {"epss_score": 0.00172, "epss_percentile": 0.3893}, "CVE-2021-34394": {"epss_score": 0.0009, "epss_percentile": 0.26124}, "CVE-2021-34395": {"epss_score": 0.00047, "epss_percentile": 0.14831}, "CVE-2021-34396": {"epss_score": 0.00059, "epss_percentile": 0.18929}, "CVE-2021-34397": {"epss_score": 0.00059, "epss_percentile": 0.18929}, "CVE-2021-34398": {"epss_score": 0.00038, "epss_percentile": 0.11331}, "CVE-2021-34399": {"epss_score": 0.00058, "epss_percentile": 0.18373}, "CVE-2021-34400": {"epss_score": 0.00058, "epss_percentile": 0.18373}, "CVE-2021-34401": {"epss_score": 0.00052, "epss_percentile": 0.16358}, "CVE-2021-34402": {"epss_score": 0.0005, "epss_percentile": 0.15774}, "CVE-2021-34403": {"epss_score": 0.00056, "epss_percentile": 0.1768}, "CVE-2021-34404": {"epss_score": 0.00049, "epss_percentile": 0.15492}, "CVE-2021-34405": {"epss_score": 0.0004, "epss_percentile": 0.12157}, "CVE-2021-34406": {"epss_score": 0.00035, "epss_percentile": 0.10055}, "CVE-2021-34408": {"epss_score": 0.00129, "epss_percentile": 0.33099}, "CVE-2021-34409": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2021-34410": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2021-34411": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2021-34412": {"epss_score": 0.00118, "epss_percentile": 0.31421}, "CVE-2021-34413": {"epss_score": 0.00396, "epss_percentile": 0.59863}, "CVE-2021-34414": {"epss_score": 0.01593, "epss_percentile": 0.81229}, "CVE-2021-34415": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2021-34416": {"epss_score": 0.01576, "epss_percentile": 0.81112}, "CVE-2021-34417": {"epss_score": 0.00363, "epss_percentile": 0.57895}, "CVE-2021-34418": {"epss_score": 0.00184, "epss_percentile": 0.40456}, "CVE-2021-34419": {"epss_score": 0.00314, "epss_percentile": 0.54153}, "CVE-2021-34420": {"epss_score": 0.00119, "epss_percentile": 0.31612}, "CVE-2021-34421": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2021-34422": {"epss_score": 0.00329, "epss_percentile": 0.55399}, "CVE-2021-34423": {"epss_score": 0.00982, "epss_percentile": 0.76296}, "CVE-2021-34424": {"epss_score": 0.00267, "epss_percentile": 0.49968}, "CVE-2021-34425": {"epss_score": 0.0025, "epss_percentile": 0.48113}, "CVE-2021-34426": {"epss_score": 0.00045, "epss_percentile": 0.13941}, "CVE-2021-34427": {"epss_score": 0.62233, "epss_percentile": 0.98286}, "CVE-2021-34428": {"epss_score": 0.00669, "epss_percentile": 0.70755}, "CVE-2021-34429": {"epss_score": 0.93778, "epss_percentile": 0.99844}, "CVE-2021-34430": {"epss_score": 0.00102, "epss_percentile": 0.28836}, "CVE-2021-34431": {"epss_score": 0.0037, "epss_percentile": 0.58323}, "CVE-2021-34432": {"epss_score": 0.00343, "epss_percentile": 0.56458}, "CVE-2021-34433": {"epss_score": 0.00048, "epss_percentile": 0.15033}, "CVE-2021-34434": {"epss_score": 0.00363, "epss_percentile": 0.57892}, "CVE-2021-34435": {"epss_score": 0.00123, "epss_percentile": 0.32192}, "CVE-2021-34436": {"epss_score": 0.035, "epss_percentile": 0.87243}, "CVE-2021-34438": {"epss_score": 0.01063, "epss_percentile": 0.7719}, "CVE-2021-34439": {"epss_score": 0.02817, "epss_percentile": 0.85738}, "CVE-2021-34440": {"epss_score": 0.0041, "epss_percentile": 0.60826}, "CVE-2021-34441": {"epss_score": 0.01469, "epss_percentile": 0.80491}, "CVE-2021-34442": {"epss_score": 0.06937, "epss_percentile": 0.91128}, "CVE-2021-34444": {"epss_score": 0.03709, "epss_percentile": 0.87601}, "CVE-2021-34445": {"epss_score": 0.00275, "epss_percentile": 0.50676}, "CVE-2021-34446": {"epss_score": 0.01855, "epss_percentile": 0.82558}, "CVE-2021-34447": {"epss_score": 0.0276, "epss_percentile": 0.85599}, "CVE-2021-34448": {"epss_score": 0.02015, "epss_percentile": 0.83272}, "CVE-2021-34449": {"epss_score": 0.00296, "epss_percentile": 0.52567}, "CVE-2021-34450": {"epss_score": 0.01693, "epss_percentile": 0.81799}, "CVE-2021-34451": {"epss_score": 0.0069, "epss_percentile": 0.71236}, "CVE-2021-34452": {"epss_score": 0.01263, "epss_percentile": 0.78989}, "CVE-2021-34453": {"epss_score": 0.07525, "epss_percentile": 0.91516}, "CVE-2021-34454": {"epss_score": 0.00429, "epss_percentile": 0.61987}, "CVE-2021-34455": {"epss_score": 0.00164, "epss_percentile": 0.37872}, "CVE-2021-34456": {"epss_score": 0.00342, "epss_percentile": 0.56348}, "CVE-2021-34457": {"epss_score": 0.00517, "epss_percentile": 0.66086}, "CVE-2021-34458": {"epss_score": 0.01704, "epss_percentile": 0.81846}, "CVE-2021-34459": {"epss_score": 0.00305, "epss_percentile": 0.53311}, "CVE-2021-34460": {"epss_score": 0.00317, "epss_percentile": 0.54333}, "CVE-2021-34461": {"epss_score": 0.00317, "epss_percentile": 0.54333}, "CVE-2021-34462": {"epss_score": 0.00301, "epss_percentile": 0.53043}, "CVE-2021-34464": {"epss_score": 0.02202, "epss_percentile": 0.83983}, "CVE-2021-34466": {"epss_score": 0.00443, "epss_percentile": 0.62764}, "CVE-2021-34467": {"epss_score": 0.02733, "epss_percentile": 0.85544}, "CVE-2021-34468": {"epss_score": 0.01183, "epss_percentile": 0.78325}, "CVE-2021-34469": {"epss_score": 0.00834, "epss_percentile": 0.74099}, "CVE-2021-34470": {"epss_score": 0.04721, "epss_percentile": 0.89048}, "CVE-2021-34471": {"epss_score": 0.00249, "epss_percentile": 0.48029}, "CVE-2021-34473": {"epss_score": 0.9423, "epss_percentile": 0.99921}, "CVE-2021-34474": {"epss_score": 0.00889, "epss_percentile": 0.75012}, "CVE-2021-34475": {"epss_score": 0.00231, "epss_percentile": 0.45771}, "CVE-2021-34476": {"epss_score": 0.09089, "epss_percentile": 0.92397}, "CVE-2021-34477": {"epss_score": 0.00258, "epss_percentile": 0.4899}, "CVE-2021-34478": {"epss_score": 0.09479, "epss_percentile": 0.92566}, "CVE-2021-34479": {"epss_score": 0.07841, "epss_percentile": 0.91712}, "CVE-2021-34480": {"epss_score": 0.03053, "epss_percentile": 0.86293}, "CVE-2021-34481": {"epss_score": 0.30553, "epss_percentile": 0.96551}, "CVE-2021-34483": {"epss_score": 0.00305, "epss_percentile": 0.53331}, "CVE-2021-34484": {"epss_score": 0.02257, "epss_percentile": 0.84174}, "CVE-2021-34485": {"epss_score": 0.00966, "epss_percentile": 0.76049}, "CVE-2021-34486": {"epss_score": 0.34654, "epss_percentile": 0.96863}, "CVE-2021-34487": {"epss_score": 0.0019, "epss_percentile": 0.41118}, "CVE-2021-34488": {"epss_score": 0.00128, "epss_percentile": 0.33073}, "CVE-2021-34489": {"epss_score": 0.0079, "epss_percentile": 0.73373}, "CVE-2021-34490": {"epss_score": 0.057, "epss_percentile": 0.90131}, "CVE-2021-34491": {"epss_score": 0.00476, "epss_percentile": 0.64257}, "CVE-2021-34492": {"epss_score": 0.018, "epss_percentile": 0.82322}, "CVE-2021-34493": {"epss_score": 0.00175, "epss_percentile": 0.39284}, "CVE-2021-34494": {"epss_score": 0.01672, "epss_percentile": 0.81678}, "CVE-2021-34496": {"epss_score": 0.02392, "epss_percentile": 0.84603}, "CVE-2021-34497": {"epss_score": 0.02895, "epss_percentile": 0.85925}, "CVE-2021-34498": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2021-34499": {"epss_score": 0.04362, "epss_percentile": 0.88597}, "CVE-2021-34500": {"epss_score": 0.02586, "epss_percentile": 0.85166}, "CVE-2021-34501": {"epss_score": 0.09094, "epss_percentile": 0.92399}, "CVE-2021-34503": {"epss_score": 0.01129, "epss_percentile": 0.77838}, "CVE-2021-34504": {"epss_score": 0.01966, "epss_percentile": 0.83083}, "CVE-2021-34506": {"epss_score": 0.00898, "epss_percentile": 0.75141}, "CVE-2021-34507": {"epss_score": 0.09882, "epss_percentile": 0.92752}, "CVE-2021-34508": {"epss_score": 0.04863, "epss_percentile": 0.89223}, "CVE-2021-34509": {"epss_score": 0.00403, "epss_percentile": 0.60347}, "CVE-2021-34510": {"epss_score": 0.00405, "epss_percentile": 0.6046}, "CVE-2021-34511": {"epss_score": 0.00318, "epss_percentile": 0.54409}, "CVE-2021-34512": {"epss_score": 0.00996, "epss_percentile": 0.76449}, "CVE-2021-34513": {"epss_score": 0.01642, "epss_percentile": 0.81506}, "CVE-2021-34514": {"epss_score": 0.00407, "epss_percentile": 0.60594}, "CVE-2021-34516": {"epss_score": 0.01669, "epss_percentile": 0.81666}, "CVE-2021-34517": {"epss_score": 0.01518, "epss_percentile": 0.80814}, "CVE-2021-34518": {"epss_score": 0.01129, "epss_percentile": 0.77838}, "CVE-2021-34519": {"epss_score": 0.01181, "epss_percentile": 0.78304}, "CVE-2021-34520": {"epss_score": 0.04942, "epss_percentile": 0.89309}, "CVE-2021-34521": {"epss_score": 0.01129, "epss_percentile": 0.77838}, "CVE-2021-34522": {"epss_score": 0.02202, "epss_percentile": 0.83983}, "CVE-2021-34523": {"epss_score": 0.94055, "epss_percentile": 0.99893}, "CVE-2021-34524": {"epss_score": 0.01556, "epss_percentile": 0.81017}, "CVE-2021-34525": {"epss_score": 0.04863, "epss_percentile": 0.89223}, "CVE-2021-34527": {"epss_score": 0.94274, "epss_percentile": 0.99932}, "CVE-2021-34528": {"epss_score": 0.0534, "epss_percentile": 0.89761}, "CVE-2021-34529": {"epss_score": 0.05642, "epss_percentile": 0.90077}, "CVE-2021-34530": {"epss_score": 0.05577, "epss_percentile": 0.90014}, "CVE-2021-34532": {"epss_score": 0.0029, "epss_percentile": 0.52111}, "CVE-2021-34533": {"epss_score": 0.01106, "epss_percentile": 0.77619}, "CVE-2021-34534": {"epss_score": 0.023, "epss_percentile": 0.8431}, "CVE-2021-34535": {"epss_score": 0.04763, "epss_percentile": 0.8912}, "CVE-2021-34536": {"epss_score": 0.00422, "epss_percentile": 0.61575}, "CVE-2021-34537": {"epss_score": 0.00243, "epss_percentile": 0.4749}, "CVE-2021-34538": {"epss_score": 0.00451, "epss_percentile": 0.63152}, "CVE-2021-34539": {"epss_score": 0.00921, "epss_percentile": 0.75485}, "CVE-2021-34540": {"epss_score": 0.00334, "epss_percentile": 0.557}, "CVE-2021-34543": {"epss_score": 0.0119, "epss_percentile": 0.78379}, "CVE-2021-34544": {"epss_score": 0.00396, "epss_percentile": 0.59883}, "CVE-2021-34546": {"epss_score": 0.00733, "epss_percentile": 0.72216}, "CVE-2021-34547": {"epss_score": 0.00142, "epss_percentile": 0.34966}, "CVE-2021-34548": {"epss_score": 0.00086, "epss_percentile": 0.25344}, "CVE-2021-34549": {"epss_score": 0.00645, "epss_percentile": 0.70123}, "CVE-2021-34550": {"epss_score": 0.00832, "epss_percentile": 0.7407}, "CVE-2021-34551": {"epss_score": 0.02108, "epss_percentile": 0.83638}, "CVE-2021-34552": {"epss_score": 0.00337, "epss_percentile": 0.56008}, "CVE-2021-34553": {"epss_score": 0.00611, "epss_percentile": 0.69206}, "CVE-2021-34555": {"epss_score": 0.00379, "epss_percentile": 0.58844}, "CVE-2021-34556": {"epss_score": 0.00043, "epss_percentile": 0.13291}, "CVE-2021-34557": {"epss_score": 0.00066, "epss_percentile": 0.20879}, "CVE-2021-34558": {"epss_score": 0.01475, "epss_percentile": 0.80524}, "CVE-2021-34559": {"epss_score": 0.00313, "epss_percentile": 0.54014}, "CVE-2021-34560": {"epss_score": 0.00052, "epss_percentile": 0.16606}, "CVE-2021-34561": {"epss_score": 0.00332, "epss_percentile": 0.55609}, "CVE-2021-34562": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-34563": {"epss_score": 0.00047, "epss_percentile": 0.14836}, "CVE-2021-34564": {"epss_score": 0.00025, "epss_percentile": 0.06098}, "CVE-2021-34565": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2021-34566": {"epss_score": 0.01089, "epss_percentile": 0.7744}, "CVE-2021-34567": {"epss_score": 0.00908, "epss_percentile": 0.75279}, "CVE-2021-34568": {"epss_score": 0.00947, "epss_percentile": 0.75814}, "CVE-2021-34569": {"epss_score": 0.00276, "epss_percentile": 0.50759}, "CVE-2021-34570": {"epss_score": 0.00446, "epss_percentile": 0.629}, "CVE-2021-34571": {"epss_score": 0.00044, "epss_percentile": 0.1353}, "CVE-2021-34572": {"epss_score": 0.00033, "epss_percentile": 0.09191}, "CVE-2021-34573": {"epss_score": 0.00115, "epss_percentile": 0.30907}, "CVE-2021-34574": {"epss_score": 0.00198, "epss_percentile": 0.42045}, "CVE-2021-34575": {"epss_score": 0.00274, "epss_percentile": 0.50515}, "CVE-2021-34576": {"epss_score": 0.00167, "epss_percentile": 0.38356}, "CVE-2021-34577": {"epss_score": 0.00091, "epss_percentile": 0.26246}, "CVE-2021-34578": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2021-34579": {"epss_score": 0.00265, "epss_percentile": 0.49825}, "CVE-2021-34580": {"epss_score": 0.00274, "epss_percentile": 0.50515}, "CVE-2021-34581": {"epss_score": 0.01583, "epss_percentile": 0.81152}, "CVE-2021-34582": {"epss_score": 0.00094, "epss_percentile": 0.26962}, "CVE-2021-34583": {"epss_score": 0.00693, "epss_percentile": 0.71337}, "CVE-2021-34584": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2021-34585": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2021-34586": {"epss_score": 0.00645, "epss_percentile": 0.7011}, "CVE-2021-34587": {"epss_score": 0.00305, "epss_percentile": 0.53327}, "CVE-2021-34588": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2021-34589": {"epss_score": 0.003, "epss_percentile": 0.52984}, "CVE-2021-34590": {"epss_score": 0.00576, "epss_percentile": 0.68143}, "CVE-2021-34591": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2021-34592": {"epss_score": 0.0419, "epss_percentile": 0.88375}, "CVE-2021-34593": {"epss_score": 0.01595, "epss_percentile": 0.81235}, "CVE-2021-34594": {"epss_score": 0.00568, "epss_percentile": 0.6791}, "CVE-2021-34595": {"epss_score": 0.00372, "epss_percentile": 0.58452}, "CVE-2021-34596": {"epss_score": 0.00236, "epss_percentile": 0.46437}, "CVE-2021-34597": {"epss_score": 0.0016, "epss_percentile": 0.37438}, "CVE-2021-34598": {"epss_score": 0.00268, "epss_percentile": 0.50062}, "CVE-2021-34599": {"epss_score": 0.00093, "epss_percentile": 0.26722}, "CVE-2021-34600": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2021-34601": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2021-34602": {"epss_score": 0.04746, "epss_percentile": 0.89096}, "CVE-2021-34605": {"epss_score": 0.00354, "epss_percentile": 0.57224}, "CVE-2021-34606": {"epss_score": 0.00065, "epss_percentile": 0.20487}, "CVE-2021-34609": {"epss_score": 0.00608, "epss_percentile": 0.6908}, "CVE-2021-34610": {"epss_score": 0.03295, "epss_percentile": 0.86847}, "CVE-2021-34611": {"epss_score": 0.02453, "epss_percentile": 0.84791}, "CVE-2021-34612": {"epss_score": 0.01743, "epss_percentile": 0.8206}, "CVE-2021-34613": {"epss_score": 0.01743, "epss_percentile": 0.8206}, "CVE-2021-34614": {"epss_score": 0.01743, "epss_percentile": 0.8206}, "CVE-2021-34615": {"epss_score": 0.01743, "epss_percentile": 0.8206}, "CVE-2021-34616": {"epss_score": 0.01743, "epss_percentile": 0.8206}, "CVE-2021-34617": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2021-34618": {"epss_score": 0.00256, "epss_percentile": 0.48739}, "CVE-2021-34619": {"epss_score": 0.00109, "epss_percentile": 0.30071}, "CVE-2021-34620": {"epss_score": 0.00248, "epss_percentile": 0.47983}, "CVE-2021-34621": {"epss_score": 0.92771, "epss_percentile": 0.99746}, "CVE-2021-34622": {"epss_score": 0.51775, "epss_percentile": 0.97797}, "CVE-2021-34623": {"epss_score": 0.00894, "epss_percentile": 0.7508}, "CVE-2021-34624": {"epss_score": 0.64957, "epss_percentile": 0.98399}, "CVE-2021-34625": {"epss_score": 0.00314, "epss_percentile": 0.54118}, "CVE-2021-34626": {"epss_score": 0.00207, "epss_percentile": 0.43136}, "CVE-2021-34627": {"epss_score": 0.00312, "epss_percentile": 0.53951}, "CVE-2021-34628": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-34629": {"epss_score": 0.00229, "epss_percentile": 0.45662}, "CVE-2021-34630": {"epss_score": 0.00651, "epss_percentile": 0.70283}, "CVE-2021-34631": {"epss_score": 0.00109, "epss_percentile": 0.30071}, "CVE-2021-34632": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-34633": {"epss_score": 0.00109, "epss_percentile": 0.30071}, "CVE-2021-34634": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-34635": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34636": {"epss_score": 0.00109, "epss_percentile": 0.30071}, "CVE-2021-34637": {"epss_score": 0.00109, "epss_percentile": 0.30071}, "CVE-2021-34638": {"epss_score": 0.01041, "epss_percentile": 0.76969}, "CVE-2021-34639": {"epss_score": 0.00193, "epss_percentile": 0.41376}, "CVE-2021-34640": {"epss_score": 0.12179, "epss_percentile": 0.93593}, "CVE-2021-34641": {"epss_score": 0.00266, "epss_percentile": 0.49867}, "CVE-2021-34642": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34643": {"epss_score": 0.23353, "epss_percentile": 0.95769}, "CVE-2021-34644": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34645": {"epss_score": 0.00109, "epss_percentile": 0.30071}, "CVE-2021-34646": {"epss_score": 0.22823, "epss_percentile": 0.95696}, "CVE-2021-34647": {"epss_score": 0.00535, "epss_percentile": 0.66823}, "CVE-2021-34648": {"epss_score": 0.00162, "epss_percentile": 0.37658}, "CVE-2021-34649": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34650": {"epss_score": 0.00191, "epss_percentile": 0.4119}, "CVE-2021-34651": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34652": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34653": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34654": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34655": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34656": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34657": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34658": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34659": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34660": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34661": {"epss_score": 0.00103, "epss_percentile": 0.28963}, "CVE-2021-34663": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34664": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34665": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34666": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34667": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-34668": {"epss_score": 0.00171, "epss_percentile": 0.38787}, "CVE-2021-34675": {"epss_score": 0.00894, "epss_percentile": 0.75089}, "CVE-2021-34676": {"epss_score": 0.00894, "epss_percentile": 0.75089}, "CVE-2021-34679": {"epss_score": 0.00241, "epss_percentile": 0.47278}, "CVE-2021-34682": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2021-34683": {"epss_score": 0.00247, "epss_percentile": 0.47849}, "CVE-2021-34684": {"epss_score": 0.26333, "epss_percentile": 0.96138}, "CVE-2021-34685": {"epss_score": 0.0197, "epss_percentile": 0.83094}, "CVE-2021-34687": {"epss_score": 0.00034, "epss_percentile": 0.0967}, "CVE-2021-34688": {"epss_score": 0.00065, "epss_percentile": 0.205}, "CVE-2021-34689": {"epss_score": 0.00066, "epss_percentile": 0.20931}, "CVE-2021-34690": {"epss_score": 0.00948, "epss_percentile": 0.75827}, "CVE-2021-34691": {"epss_score": 0.00531, "epss_percentile": 0.66655}, "CVE-2021-34692": {"epss_score": 0.00056, "epss_percentile": 0.1796}, "CVE-2021-34693": {"epss_score": 0.00051, "epss_percentile": 0.16266}, "CVE-2021-34696": {"epss_score": 0.00264, "epss_percentile": 0.4973}, "CVE-2021-34697": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2021-34698": {"epss_score": 0.00517, "epss_percentile": 0.66065}, "CVE-2021-34699": {"epss_score": 0.00702, "epss_percentile": 0.71506}, "CVE-2021-34700": {"epss_score": 0.00053, "epss_percentile": 0.16688}, "CVE-2021-34701": {"epss_score": 0.0009, "epss_percentile": 0.26063}, "CVE-2021-34702": {"epss_score": 0.00163, "epss_percentile": 0.37814}, "CVE-2021-34703": {"epss_score": 0.00243, "epss_percentile": 0.47487}, "CVE-2021-34704": {"epss_score": 0.00254, "epss_percentile": 0.48545}, "CVE-2021-34705": {"epss_score": 0.00552, "epss_percentile": 0.67381}, "CVE-2021-34706": {"epss_score": 0.00206, "epss_percentile": 0.42766}, "CVE-2021-34707": {"epss_score": 0.00237, "epss_percentile": 0.4664}, "CVE-2021-34708": {"epss_score": 0.00024, "epss_percentile": 0.0574}, "CVE-2021-34709": {"epss_score": 0.00024, "epss_percentile": 0.0574}, "CVE-2021-34710": {"epss_score": 0.04491, "epss_percentile": 0.88757}, "CVE-2021-34711": {"epss_score": 0.00067, "epss_percentile": 0.21148}, "CVE-2021-34712": {"epss_score": 0.00073, "epss_percentile": 0.22532}, "CVE-2021-34713": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2021-34714": {"epss_score": 0.00185, "epss_percentile": 0.40485}, "CVE-2021-34715": {"epss_score": 0.00669, "epss_percentile": 0.70747}, "CVE-2021-34716": {"epss_score": 0.01103, "epss_percentile": 0.7759}, "CVE-2021-34718": {"epss_score": 0.01179, "epss_percentile": 0.78292}, "CVE-2021-34719": {"epss_score": 0.00077, "epss_percentile": 0.2341}, "CVE-2021-34720": {"epss_score": 0.00381, "epss_percentile": 0.58987}, "CVE-2021-34721": {"epss_score": 0.00082, "epss_percentile": 0.24508}, "CVE-2021-34722": {"epss_score": 0.00065, "epss_percentile": 0.20579}, "CVE-2021-34723": {"epss_score": 0.00055, "epss_percentile": 0.17505}, "CVE-2021-34724": {"epss_score": 0.00125, "epss_percentile": 0.32498}, "CVE-2021-34725": {"epss_score": 0.001, "epss_percentile": 0.28532}, "CVE-2021-34726": {"epss_score": 0.00089, "epss_percentile": 0.25801}, "CVE-2021-34727": {"epss_score": 0.01, "epss_percentile": 0.76487}, "CVE-2021-34728": {"epss_score": 0.00162, "epss_percentile": 0.37713}, "CVE-2021-34729": {"epss_score": 0.00053, "epss_percentile": 0.16872}, "CVE-2021-34730": {"epss_score": 0.37268, "epss_percentile": 0.97032}, "CVE-2021-34731": {"epss_score": 0.00174, "epss_percentile": 0.39187}, "CVE-2021-34732": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2021-34733": {"epss_score": 0.00047, "epss_percentile": 0.1489}, "CVE-2021-34734": {"epss_score": 0.00317, "epss_percentile": 0.54345}, "CVE-2021-34735": {"epss_score": 0.01508, "epss_percentile": 0.80761}, "CVE-2021-34736": {"epss_score": 0.00157, "epss_percentile": 0.37086}, "CVE-2021-34737": {"epss_score": 0.00419, "epss_percentile": 0.61388}, "CVE-2021-34738": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-34739": {"epss_score": 0.005, "epss_percentile": 0.65325}, "CVE-2021-34740": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2021-34741": {"epss_score": 0.00238, "epss_percentile": 0.46753}, "CVE-2021-34742": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2021-34743": {"epss_score": 0.00229, "epss_percentile": 0.45636}, "CVE-2021-34744": {"epss_score": 0.00296, "epss_percentile": 0.52558}, "CVE-2021-34745": {"epss_score": 0.00044, "epss_percentile": 0.13394}, "CVE-2021-34746": {"epss_score": 0.03623, "epss_percentile": 0.87446}, "CVE-2021-34748": {"epss_score": 0.01269, "epss_percentile": 0.79036}, "CVE-2021-34749": {"epss_score": 0.00232, "epss_percentile": 0.45966}, "CVE-2021-34750": {"epss_score": 0.00141, "epss_percentile": 0.34812}, "CVE-2021-34751": {"epss_score": 0.00141, "epss_percentile": 0.34812}, "CVE-2021-34752": {"epss_score": 0.00199, "epss_percentile": 0.42161}, "CVE-2021-34753": {"epss_score": 0.00046, "epss_percentile": 0.14116}, "CVE-2021-34754": {"epss_score": 0.00119, "epss_percentile": 0.31536}, "CVE-2021-34755": {"epss_score": 0.00065, "epss_percentile": 0.20511}, "CVE-2021-34756": {"epss_score": 0.00065, "epss_percentile": 0.20511}, "CVE-2021-34757": {"epss_score": 0.00167, "epss_percentile": 0.38314}, "CVE-2021-34758": {"epss_score": 0.00106, "epss_percentile": 0.2943}, "CVE-2021-34759": {"epss_score": 0.00196, "epss_percentile": 0.41804}, "CVE-2021-34760": {"epss_score": 0.00196, "epss_percentile": 0.41779}, "CVE-2021-34761": {"epss_score": 0.0016, "epss_percentile": 0.37447}, "CVE-2021-34762": {"epss_score": 0.00195, "epss_percentile": 0.41672}, "CVE-2021-34763": {"epss_score": 0.00175, "epss_percentile": 0.39276}, "CVE-2021-34764": {"epss_score": 0.00195, "epss_percentile": 0.41657}, "CVE-2021-34765": {"epss_score": 0.00133, "epss_percentile": 0.33705}, "CVE-2021-34766": {"epss_score": 0.0012, "epss_percentile": 0.31694}, "CVE-2021-34767": {"epss_score": 0.001, "epss_percentile": 0.28501}, "CVE-2021-34768": {"epss_score": 0.00474, "epss_percentile": 0.6415}, "CVE-2021-34769": {"epss_score": 0.00474, "epss_percentile": 0.6415}, "CVE-2021-34770": {"epss_score": 0.01029, "epss_percentile": 0.76833}, "CVE-2021-34771": {"epss_score": 0.00137, "epss_percentile": 0.34266}, "CVE-2021-34772": {"epss_score": 0.00329, "epss_percentile": 0.55398}, "CVE-2021-34773": {"epss_score": 0.00243, "epss_percentile": 0.47473}, "CVE-2021-34774": {"epss_score": 0.00051, "epss_percentile": 0.16299}, "CVE-2021-34775": {"epss_score": 0.0013, "epss_percentile": 0.33221}, "CVE-2021-34776": {"epss_score": 0.0013, "epss_percentile": 0.33221}, "CVE-2021-34777": {"epss_score": 0.00179, "epss_percentile": 0.39856}, "CVE-2021-34778": {"epss_score": 0.00179, "epss_percentile": 0.39856}, "CVE-2021-34779": {"epss_score": 0.00094, "epss_percentile": 0.26789}, "CVE-2021-34780": {"epss_score": 0.00139, "epss_percentile": 0.34654}, "CVE-2021-34781": {"epss_score": 0.00429, "epss_percentile": 0.61988}, "CVE-2021-34782": {"epss_score": 0.00277, "epss_percentile": 0.50836}, "CVE-2021-34783": {"epss_score": 0.00767, "epss_percentile": 0.72961}, "CVE-2021-34784": {"epss_score": 0.0026, "epss_percentile": 0.49183}, "CVE-2021-34785": {"epss_score": 0.00522, "epss_percentile": 0.6626}, "CVE-2021-34786": {"epss_score": 0.00217, "epss_percentile": 0.44239}, "CVE-2021-34787": {"epss_score": 0.01152, "epss_percentile": 0.78043}, "CVE-2021-34788": {"epss_score": 0.00039, "epss_percentile": 0.11779}, "CVE-2021-34789": {"epss_score": 0.00196, "epss_percentile": 0.41779}, "CVE-2021-34790": {"epss_score": 0.00467, "epss_percentile": 0.63811}, "CVE-2021-34791": {"epss_score": 0.00728, "epss_percentile": 0.72112}, "CVE-2021-34792": {"epss_score": 0.00431, "epss_percentile": 0.62054}, "CVE-2021-34793": {"epss_score": 0.00079, "epss_percentile": 0.23858}, "CVE-2021-34794": {"epss_score": 0.00683, "epss_percentile": 0.71102}, "CVE-2021-34795": {"epss_score": 0.01256, "epss_percentile": 0.78942}, "CVE-2021-34797": {"epss_score": 0.00282, "epss_percentile": 0.51229}, "CVE-2021-34798": {"epss_score": 0.11686, "epss_percentile": 0.93447}, "CVE-2021-34800": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-34801": {"epss_score": 0.01046, "epss_percentile": 0.77024}, "CVE-2021-34802": {"epss_score": 0.00546, "epss_percentile": 0.67205}, "CVE-2021-34803": {"epss_score": 0.00108, "epss_percentile": 0.29834}, "CVE-2021-34805": {"epss_score": 0.90222, "epss_percentile": 0.99569}, "CVE-2021-34807": {"epss_score": 0.00841, "epss_percentile": 0.74222}, "CVE-2021-34808": {"epss_score": 0.0018, "epss_percentile": 0.39877}, "CVE-2021-34809": {"epss_score": 0.01637, "epss_percentile": 0.81482}, "CVE-2021-34810": {"epss_score": 0.01108, "epss_percentile": 0.77637}, "CVE-2021-34811": {"epss_score": 0.00116, "epss_percentile": 0.31191}, "CVE-2021-34812": {"epss_score": 0.00218, "epss_percentile": 0.44391}, "CVE-2021-34813": {"epss_score": 0.04458, "epss_percentile": 0.88714}, "CVE-2021-34814": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2021-34815": {"epss_score": 0.00295, "epss_percentile": 0.52494}, "CVE-2021-34816": {"epss_score": 0.00444, "epss_percentile": 0.62807}, "CVE-2021-34817": {"epss_score": 0.00854, "epss_percentile": 0.74448}, "CVE-2021-34820": {"epss_score": 0.03016, "epss_percentile": 0.86217}, "CVE-2021-34821": {"epss_score": 0.00391, "epss_percentile": 0.59564}, "CVE-2021-34823": {"epss_score": 0.01898, "epss_percentile": 0.82761}, "CVE-2021-34824": {"epss_score": 0.01837, "epss_percentile": 0.82482}, "CVE-2021-34825": {"epss_score": 0.00124, "epss_percentile": 0.32411}, "CVE-2021-34827": {"epss_score": 0.01731, "epss_percentile": 0.81991}, "CVE-2021-34828": {"epss_score": 0.01731, "epss_percentile": 0.81991}, "CVE-2021-34829": {"epss_score": 0.01731, "epss_percentile": 0.81991}, "CVE-2021-34830": {"epss_score": 0.01731, "epss_percentile": 0.81991}, "CVE-2021-34831": {"epss_score": 0.0138, "epss_percentile": 0.79858}, "CVE-2021-34832": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34833": {"epss_score": 0.04957, "epss_percentile": 0.89331}, "CVE-2021-34834": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34835": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34836": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34837": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34838": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34839": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34840": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34841": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34842": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34843": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34844": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34845": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34846": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34847": {"epss_score": 0.04957, "epss_percentile": 0.89331}, "CVE-2021-34848": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34849": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34850": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34851": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34852": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34853": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2021-34854": {"epss_score": 0.00074, "epss_percentile": 0.22856}, "CVE-2021-34855": {"epss_score": 0.0009, "epss_percentile": 0.2612}, "CVE-2021-34856": {"epss_score": 0.00146, "epss_percentile": 0.35592}, "CVE-2021-34857": {"epss_score": 0.00075, "epss_percentile": 0.22985}, "CVE-2021-34858": {"epss_score": 0.01465, "epss_percentile": 0.80455}, "CVE-2021-34859": {"epss_score": 0.01283, "epss_percentile": 0.79159}, "CVE-2021-34860": {"epss_score": 0.1322, "epss_percentile": 0.93905}, "CVE-2021-34861": {"epss_score": 0.00409, "epss_percentile": 0.60691}, "CVE-2021-34862": {"epss_score": 0.00409, "epss_percentile": 0.60691}, "CVE-2021-34863": {"epss_score": 0.00409, "epss_percentile": 0.60691}, "CVE-2021-34864": {"epss_score": 0.0007, "epss_percentile": 0.21682}, "CVE-2021-34865": {"epss_score": 0.01148, "epss_percentile": 0.78013}, "CVE-2021-34866": {"epss_score": 0.00109, "epss_percentile": 0.30027}, "CVE-2021-34867": {"epss_score": 0.00069, "epss_percentile": 0.2158}, "CVE-2021-34868": {"epss_score": 0.00072, "epss_percentile": 0.22306}, "CVE-2021-34869": {"epss_score": 0.00072, "epss_percentile": 0.22306}, "CVE-2021-34870": {"epss_score": 0.00292, "epss_percentile": 0.5228}, "CVE-2021-34871": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34872": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34873": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-34874": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-34875": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-34876": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34877": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34878": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34879": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34880": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-34881": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-34882": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-34883": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-34884": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-34885": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34886": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-34887": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-34888": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-34889": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-34890": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-34891": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34892": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34893": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34894": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-34895": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-34896": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34897": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34898": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34899": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34900": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34901": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-34902": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-34903": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34904": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34905": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34906": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34907": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34908": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34909": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34910": {"epss_score": 0.00452, "epss_percentile": 0.63201}, "CVE-2021-34911": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-34912": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34913": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34914": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34915": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34916": {"epss_score": 0.00452, "epss_percentile": 0.63201}, "CVE-2021-34917": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34918": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34919": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-34920": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34921": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34922": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34923": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34924": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34925": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34926": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34927": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34928": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34929": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34930": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34931": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34932": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34933": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34934": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34935": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34936": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34937": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34938": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34939": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34940": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34941": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34942": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34943": {"epss_score": 0.00452, "epss_percentile": 0.63201}, "CVE-2021-34944": {"epss_score": 0.00452, "epss_percentile": 0.63201}, "CVE-2021-34945": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34946": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2021-34947": {"epss_score": 0.00388, "epss_percentile": 0.59376}, "CVE-2021-34948": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34949": {"epss_score": 0.00373, "epss_percentile": 0.58468}, "CVE-2021-34950": {"epss_score": 0.0127, "epss_percentile": 0.79051}, "CVE-2021-34951": {"epss_score": 0.00559, "epss_percentile": 0.67607}, "CVE-2021-34952": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34953": {"epss_score": 0.01999, "epss_percentile": 0.83213}, "CVE-2021-34954": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34955": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34956": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34957": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34958": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34959": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34960": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34961": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34962": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34963": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34964": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34965": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34966": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34967": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34968": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34969": {"epss_score": 0.00586, "epss_percentile": 0.68434}, "CVE-2021-34970": {"epss_score": 0.00373, "epss_percentile": 0.58468}, "CVE-2021-34971": {"epss_score": 0.01776, "epss_percentile": 0.8222}, "CVE-2021-34972": {"epss_score": 0.00586, "epss_percentile": 0.68434}, "CVE-2021-34973": {"epss_score": 0.00667, "epss_percentile": 0.7072}, "CVE-2021-34974": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34975": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-34976": {"epss_score": 0.00667, "epss_percentile": 0.7072}, "CVE-2021-34977": {"epss_score": 0.00497, "epss_percentile": 0.65183}, "CVE-2021-34978": {"epss_score": 0.00187, "epss_percentile": 0.40748}, "CVE-2021-34979": {"epss_score": 0.00225, "epss_percentile": 0.45237}, "CVE-2021-34980": {"epss_score": 0.00224, "epss_percentile": 0.45039}, "CVE-2021-34981": {"epss_score": 0.00012, "epss_percentile": 0.01355}, "CVE-2021-34982": {"epss_score": 0.05568, "epss_percentile": 0.90004}, "CVE-2021-34983": {"epss_score": 0.00184, "epss_percentile": 0.404}, "CVE-2021-34984": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-34985": {"epss_score": 0.00506, "epss_percentile": 0.65632}, "CVE-2021-34986": {"epss_score": 0.00071, "epss_percentile": 0.22102}, "CVE-2021-34987": {"epss_score": 0.00083, "epss_percentile": 0.24731}, "CVE-2021-34991": {"epss_score": 0.00565, "epss_percentile": 0.67795}, "CVE-2021-34992": {"epss_score": 0.21136, "epss_percentile": 0.95468}, "CVE-2021-34993": {"epss_score": 0.00631, "epss_percentile": 0.69723}, "CVE-2021-34994": {"epss_score": 0.00504, "epss_percentile": 0.6552}, "CVE-2021-34995": {"epss_score": 0.03059, "epss_percentile": 0.86306}, "CVE-2021-34996": {"epss_score": 0.20456, "epss_percentile": 0.95348}, "CVE-2021-34997": {"epss_score": 0.02106, "epss_percentile": 0.83626}, "CVE-2021-34998": {"epss_score": 0.00049, "epss_percentile": 0.15479}, "CVE-2021-34999": {"epss_score": 0.00048, "epss_percentile": 0.14977}, "CVE-2021-35000": {"epss_score": 0.00046, "epss_percentile": 0.14289}, "CVE-2021-35001": {"epss_score": 0.00484, "epss_percentile": 0.64652}, "CVE-2021-35002": {"epss_score": 0.07183, "epss_percentile": 0.91304}, "CVE-2021-35003": {"epss_score": 0.10631, "epss_percentile": 0.93054}, "CVE-2021-35004": {"epss_score": 0.16462, "epss_percentile": 0.94666}, "CVE-2021-35005": {"epss_score": 0.00095, "epss_percentile": 0.27225}, "CVE-2021-35027": {"epss_score": 0.00315, "epss_percentile": 0.54177}, "CVE-2021-35028": {"epss_score": 0.0007, "epss_percentile": 0.21701}, "CVE-2021-35029": {"epss_score": 0.00713, "epss_percentile": 0.71798}, "CVE-2021-35030": {"epss_score": 0.00115, "epss_percentile": 0.31035}, "CVE-2021-35031": {"epss_score": 0.00085, "epss_percentile": 0.25126}, "CVE-2021-35032": {"epss_score": 0.00036, "epss_percentile": 0.1051}, "CVE-2021-35033": {"epss_score": 0.00036, "epss_percentile": 0.10229}, "CVE-2021-35034": {"epss_score": 0.00271, "epss_percentile": 0.50345}, "CVE-2021-35035": {"epss_score": 0.00073, "epss_percentile": 0.22601}, "CVE-2021-35036": {"epss_score": 0.00153, "epss_percentile": 0.3658}, "CVE-2021-35037": {"epss_score": 0.00154, "epss_percentile": 0.36726}, "CVE-2021-35039": {"epss_score": 0.00085, "epss_percentile": 0.25228}, "CVE-2021-35041": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-35042": {"epss_score": 0.35237, "epss_percentile": 0.96895}, "CVE-2021-35043": {"epss_score": 0.00356, "epss_percentile": 0.57394}, "CVE-2021-35045": {"epss_score": 0.00396, "epss_percentile": 0.59908}, "CVE-2021-35046": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2021-35047": {"epss_score": 0.00894, "epss_percentile": 0.75082}, "CVE-2021-35048": {"epss_score": 0.00785, "epss_percentile": 0.73255}, "CVE-2021-35049": {"epss_score": 0.03366, "epss_percentile": 0.87004}, "CVE-2021-35050": {"epss_score": 0.00307, "epss_percentile": 0.53519}, "CVE-2021-35052": {"epss_score": 0.00153, "epss_percentile": 0.36603}, "CVE-2021-35053": {"epss_score": 0.01281, "epss_percentile": 0.79144}, "CVE-2021-35054": {"epss_score": 0.00484, "epss_percentile": 0.64634}, "CVE-2021-35055": {"epss_score": 0.00364, "epss_percentile": 0.57932}, "CVE-2021-35056": {"epss_score": 0.00057, "epss_percentile": 0.18048}, "CVE-2021-35059": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2021-35060": {"epss_score": 0.00319, "epss_percentile": 0.54552}, "CVE-2021-35061": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2021-35062": {"epss_score": 0.0031, "epss_percentile": 0.53806}, "CVE-2021-35063": {"epss_score": 0.01077, "epss_percentile": 0.77335}, "CVE-2021-35064": {"epss_score": 0.82326, "epss_percentile": 0.99187}, "CVE-2021-35065": {"epss_score": 0.00371, "epss_percentile": 0.5838}, "CVE-2021-35066": {"epss_score": 0.00428, "epss_percentile": 0.61936}, "CVE-2021-35067": {"epss_score": 0.00219, "epss_percentile": 0.44534}, "CVE-2021-35068": {"epss_score": 0.00219, "epss_percentile": 0.4448}, "CVE-2021-35069": {"epss_score": 0.00111, "epss_percentile": 0.30321}, "CVE-2021-35070": {"epss_score": 0.00039, "epss_percentile": 0.11442}, "CVE-2021-35071": {"epss_score": 0.00039, "epss_percentile": 0.11657}, "CVE-2021-35072": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-35073": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2021-35074": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2021-35075": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2021-35076": {"epss_score": 0.00246, "epss_percentile": 0.47772}, "CVE-2021-35077": {"epss_score": 0.00096, "epss_percentile": 0.27446}, "CVE-2021-35078": {"epss_score": 0.00551, "epss_percentile": 0.67376}, "CVE-2021-35079": {"epss_score": 0.00025, "epss_percentile": 0.06342}, "CVE-2021-35080": {"epss_score": 0.00039, "epss_percentile": 0.11442}, "CVE-2021-35081": {"epss_score": 0.00271, "epss_percentile": 0.50331}, "CVE-2021-35082": {"epss_score": 0.00167, "epss_percentile": 0.38299}, "CVE-2021-35083": {"epss_score": 0.00174, "epss_percentile": 0.392}, "CVE-2021-35084": {"epss_score": 0.00035, "epss_percentile": 0.10008}, "CVE-2021-35085": {"epss_score": 0.00037, "epss_percentile": 0.10895}, "CVE-2021-35086": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2021-35087": {"epss_score": 0.00246, "epss_percentile": 0.47772}, "CVE-2021-35088": {"epss_score": 0.0032, "epss_percentile": 0.54589}, "CVE-2021-35089": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2021-35090": {"epss_score": 0.0003, "epss_percentile": 0.08207}, "CVE-2021-35091": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2021-35092": {"epss_score": 0.00036, "epss_percentile": 0.10272}, "CVE-2021-35093": {"epss_score": 0.00163, "epss_percentile": 0.37762}, "CVE-2021-35094": {"epss_score": 0.00029, "epss_percentile": 0.07635}, "CVE-2021-35095": {"epss_score": 0.00033, "epss_percentile": 0.09248}, "CVE-2021-35096": {"epss_score": 0.00245, "epss_percentile": 0.47703}, "CVE-2021-35097": {"epss_score": 0.00024, "epss_percentile": 0.05746}, "CVE-2021-35098": {"epss_score": 0.00042, "epss_percentile": 0.12745}, "CVE-2021-35100": {"epss_score": 0.00317, "epss_percentile": 0.54338}, "CVE-2021-35101": {"epss_score": 0.0004, "epss_percentile": 0.1193}, "CVE-2021-35102": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2021-35103": {"epss_score": 0.00101, "epss_percentile": 0.2868}, "CVE-2021-35104": {"epss_score": 0.00325, "epss_percentile": 0.55019}, "CVE-2021-35105": {"epss_score": 0.00101, "epss_percentile": 0.2868}, "CVE-2021-35106": {"epss_score": 0.00094, "epss_percentile": 0.27026}, "CVE-2021-35108": {"epss_score": 0.00055, "epss_percentile": 0.17454}, "CVE-2021-35109": {"epss_score": 0.00072, "epss_percentile": 0.22466}, "CVE-2021-35110": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2021-35111": {"epss_score": 0.0019, "epss_percentile": 0.41072}, "CVE-2021-35112": {"epss_score": 0.00085, "epss_percentile": 0.25148}, "CVE-2021-35113": {"epss_score": 0.00024, "epss_percentile": 0.05746}, "CVE-2021-35114": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2021-35115": {"epss_score": 0.00044, "epss_percentile": 0.13562}, "CVE-2021-35116": {"epss_score": 0.00044, "epss_percentile": 0.1368}, "CVE-2021-35117": {"epss_score": 0.00239, "epss_percentile": 0.46848}, "CVE-2021-35118": {"epss_score": 0.00036, "epss_percentile": 0.10272}, "CVE-2021-35119": {"epss_score": 0.00039, "epss_percentile": 0.11657}, "CVE-2021-35120": {"epss_score": 0.00036, "epss_percentile": 0.10272}, "CVE-2021-35121": {"epss_score": 0.00036, "epss_percentile": 0.10272}, "CVE-2021-35122": {"epss_score": 0.00032, "epss_percentile": 0.08827}, "CVE-2021-35123": {"epss_score": 0.00145, "epss_percentile": 0.35409}, "CVE-2021-35126": {"epss_score": 0.00111, "epss_percentile": 0.30321}, "CVE-2021-35129": {"epss_score": 0.00111, "epss_percentile": 0.30321}, "CVE-2021-35130": {"epss_score": 0.00043, "epss_percentile": 0.13313}, "CVE-2021-35132": {"epss_score": 0.00042, "epss_percentile": 0.12769}, "CVE-2021-35133": {"epss_score": 0.00043, "epss_percentile": 0.12972}, "CVE-2021-35134": {"epss_score": 0.00128, "epss_percentile": 0.33064}, "CVE-2021-35135": {"epss_score": 0.00039, "epss_percentile": 0.11657}, "CVE-2021-35193": {"epss_score": 0.00165, "epss_percentile": 0.38122}, "CVE-2021-35196": {"epss_score": 0.0075, "epss_percentile": 0.72632}, "CVE-2021-35197": {"epss_score": 0.0073, "epss_percentile": 0.7216}, "CVE-2021-35198": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-35199": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-35200": {"epss_score": 0.0031, "epss_percentile": 0.53775}, "CVE-2021-35201": {"epss_score": 0.00347, "epss_percentile": 0.56756}, "CVE-2021-35202": {"epss_score": 0.00206, "epss_percentile": 0.43072}, "CVE-2021-35203": {"epss_score": 0.00345, "epss_percentile": 0.56596}, "CVE-2021-35204": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-35205": {"epss_score": 0.00152, "epss_percentile": 0.36499}, "CVE-2021-35206": {"epss_score": 0.00505, "epss_percentile": 0.65552}, "CVE-2021-35207": {"epss_score": 0.01059, "epss_percentile": 0.77161}, "CVE-2021-35208": {"epss_score": 0.01281, "epss_percentile": 0.79147}, "CVE-2021-35209": {"epss_score": 0.0245, "epss_percentile": 0.8478}, "CVE-2021-35210": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-35211": {"epss_score": 0.94321, "epss_percentile": 0.99947}, "CVE-2021-35212": {"epss_score": 0.01774, "epss_percentile": 0.8221}, "CVE-2021-35213": {"epss_score": 0.00867, "epss_percentile": 0.74649}, "CVE-2021-35214": {"epss_score": 0.00248, "epss_percentile": 0.47975}, "CVE-2021-35215": {"epss_score": 0.82759, "epss_percentile": 0.99212}, "CVE-2021-35216": {"epss_score": 0.51655, "epss_percentile": 0.97791}, "CVE-2021-35217": {"epss_score": 0.60058, "epss_percentile": 0.98191}, "CVE-2021-35218": {"epss_score": 0.16852, "epss_percentile": 0.94738}, "CVE-2021-35219": {"epss_score": 0.00104, "epss_percentile": 0.29216}, "CVE-2021-35220": {"epss_score": 0.01629, "epss_percentile": 0.81438}, "CVE-2021-35221": {"epss_score": 0.00392, "epss_percentile": 0.59643}, "CVE-2021-35222": {"epss_score": 0.01033, "epss_percentile": 0.7688}, "CVE-2021-35223": {"epss_score": 0.05282, "epss_percentile": 0.8969}, "CVE-2021-35225": {"epss_score": 0.01106, "epss_percentile": 0.77621}, "CVE-2021-35226": {"epss_score": 0.00312, "epss_percentile": 0.53962}, "CVE-2021-35227": {"epss_score": 0.00714, "epss_percentile": 0.7182}, "CVE-2021-35228": {"epss_score": 0.01249, "epss_percentile": 0.78872}, "CVE-2021-35229": {"epss_score": 0.00772, "epss_percentile": 0.73048}, "CVE-2021-35230": {"epss_score": 0.00405, "epss_percentile": 0.60509}, "CVE-2021-35231": {"epss_score": 0.0037, "epss_percentile": 0.58315}, "CVE-2021-35232": {"epss_score": 0.00216, "epss_percentile": 0.44205}, "CVE-2021-35233": {"epss_score": 0.00989, "epss_percentile": 0.76374}, "CVE-2021-35234": {"epss_score": 0.00763, "epss_percentile": 0.7285}, "CVE-2021-35235": {"epss_score": 0.02393, "epss_percentile": 0.84612}, "CVE-2021-35236": {"epss_score": 0.00497, "epss_percentile": 0.65204}, "CVE-2021-35237": {"epss_score": 0.00244, "epss_percentile": 0.47577}, "CVE-2021-35238": {"epss_score": 0.00524, "epss_percentile": 0.66321}, "CVE-2021-35239": {"epss_score": 0.00435, "epss_percentile": 0.62353}, "CVE-2021-35240": {"epss_score": 0.00459, "epss_percentile": 0.63477}, "CVE-2021-35242": {"epss_score": 0.00372, "epss_percentile": 0.58442}, "CVE-2021-35243": {"epss_score": 0.00462, "epss_percentile": 0.63614}, "CVE-2021-35244": {"epss_score": 0.19111, "epss_percentile": 0.95131}, "CVE-2021-35245": {"epss_score": 0.00245, "epss_percentile": 0.47709}, "CVE-2021-35246": {"epss_score": 0.00212, "epss_percentile": 0.4379}, "CVE-2021-35247": {"epss_score": 0.02918, "epss_percentile": 0.85986}, "CVE-2021-35248": {"epss_score": 0.00268, "epss_percentile": 0.50095}, "CVE-2021-35249": {"epss_score": 0.0015, "epss_percentile": 0.3618}, "CVE-2021-35250": {"epss_score": 0.89975, "epss_percentile": 0.99555}, "CVE-2021-35251": {"epss_score": 0.00722, "epss_percentile": 0.71998}, "CVE-2021-35252": {"epss_score": 0.00389, "epss_percentile": 0.59406}, "CVE-2021-35254": {"epss_score": 0.00175, "epss_percentile": 0.39312}, "CVE-2021-35261": {"epss_score": 0.00122, "epss_percentile": 0.32075}, "CVE-2021-35265": {"epss_score": 0.05313, "epss_percentile": 0.89719}, "CVE-2021-35266": {"epss_score": 0.00086, "epss_percentile": 0.25412}, "CVE-2021-35267": {"epss_score": 0.00107, "epss_percentile": 0.2965}, "CVE-2021-35268": {"epss_score": 0.00084, "epss_percentile": 0.25027}, "CVE-2021-35269": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2021-35283": {"epss_score": 0.0071, "epss_percentile": 0.71725}, "CVE-2021-35284": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2021-35290": {"epss_score": 0.00304, "epss_percentile": 0.53305}, "CVE-2021-35296": {"epss_score": 0.004, "epss_percentile": 0.60184}, "CVE-2021-35297": {"epss_score": 0.01112, "epss_percentile": 0.77674}, "CVE-2021-35298": {"epss_score": 0.00209, "epss_percentile": 0.43369}, "CVE-2021-35299": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-35300": {"epss_score": 0.00217, "epss_percentile": 0.44249}, "CVE-2021-35301": {"epss_score": 0.00212, "epss_percentile": 0.43778}, "CVE-2021-35302": {"epss_score": 0.00212, "epss_percentile": 0.43778}, "CVE-2021-35303": {"epss_score": 0.00209, "epss_percentile": 0.43369}, "CVE-2021-35306": {"epss_score": 0.00309, "epss_percentile": 0.53648}, "CVE-2021-35307": {"epss_score": 0.00309, "epss_percentile": 0.53648}, "CVE-2021-35309": {"epss_score": 0.00138, "epss_percentile": 0.3453}, "CVE-2021-35312": {"epss_score": 0.00195, "epss_percentile": 0.41679}, "CVE-2021-35323": {"epss_score": 0.03031, "epss_percentile": 0.86248}, "CVE-2021-35324": {"epss_score": 0.00756, "epss_percentile": 0.7274}, "CVE-2021-35325": {"epss_score": 0.03131, "epss_percentile": 0.86474}, "CVE-2021-35326": {"epss_score": 0.04092, "epss_percentile": 0.88242}, "CVE-2021-35327": {"epss_score": 0.00443, "epss_percentile": 0.62759}, "CVE-2021-35331": {"epss_score": 0.00516, "epss_percentile": 0.66013}, "CVE-2021-35336": {"epss_score": 0.88398, "epss_percentile": 0.99471}, "CVE-2021-35337": {"epss_score": 0.00124, "epss_percentile": 0.32395}, "CVE-2021-35342": {"epss_score": 0.00208, "epss_percentile": 0.43301}, "CVE-2021-35343": {"epss_score": 0.00104, "epss_percentile": 0.29201}, "CVE-2021-35344": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2021-35346": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2021-35358": {"epss_score": 0.00402, "epss_percentile": 0.60298}, "CVE-2021-35360": {"epss_score": 0.00355, "epss_percentile": 0.57285}, "CVE-2021-35361": {"epss_score": 0.00394, "epss_percentile": 0.5977}, "CVE-2021-35368": {"epss_score": 0.00503, "epss_percentile": 0.65447}, "CVE-2021-35369": {"epss_score": 0.00107, "epss_percentile": 0.29715}, "CVE-2021-35370": {"epss_score": 0.00957, "epss_percentile": 0.75931}, "CVE-2021-35377": {"epss_score": 0.00509, "epss_percentile": 0.65748}, "CVE-2021-35380": {"epss_score": 0.73487, "epss_percentile": 0.98758}, "CVE-2021-35387": {"epss_score": 0.00741, "epss_percentile": 0.72432}, "CVE-2021-35388": {"epss_score": 0.00548, "epss_percentile": 0.67283}, "CVE-2021-35391": {"epss_score": 0.00056, "epss_percentile": 0.17769}, "CVE-2021-35392": {"epss_score": 0.71785, "epss_percentile": 0.9868}, "CVE-2021-35393": {"epss_score": 0.11737, "epss_percentile": 0.93462}, "CVE-2021-35394": {"epss_score": 0.9422, "epss_percentile": 0.99919}, "CVE-2021-35395": {"epss_score": 0.93663, "epss_percentile": 0.99831}, "CVE-2021-35397": {"epss_score": 0.02944, "epss_percentile": 0.86037}, "CVE-2021-35413": {"epss_score": 0.03237, "epss_percentile": 0.86725}, "CVE-2021-35414": {"epss_score": 0.01343, "epss_percentile": 0.79606}, "CVE-2021-35415": {"epss_score": 0.00917, "epss_percentile": 0.75428}, "CVE-2021-35437": {"epss_score": 0.00081, "epss_percentile": 0.24311}, "CVE-2021-35438": {"epss_score": 0.00447, "epss_percentile": 0.62959}, "CVE-2021-35440": {"epss_score": 0.00723, "epss_percentile": 0.72019}, "CVE-2021-35448": {"epss_score": 0.00373, "epss_percentile": 0.58477}, "CVE-2021-35449": {"epss_score": 0.13287, "epss_percentile": 0.93922}, "CVE-2021-35450": {"epss_score": 0.00767, "epss_percentile": 0.72961}, "CVE-2021-35451": {"epss_score": 0.00533, "epss_percentile": 0.66755}, "CVE-2021-35452": {"epss_score": 0.00136, "epss_percentile": 0.34131}, "CVE-2021-35456": {"epss_score": 0.00822, "epss_percentile": 0.73919}, "CVE-2021-35458": {"epss_score": 0.00558, "epss_percentile": 0.67597}, "CVE-2021-35463": {"epss_score": 0.00149, "epss_percentile": 0.35965}, "CVE-2021-35464": {"epss_score": 0.94386, "epss_percentile": 0.99967}, "CVE-2021-35465": {"epss_score": 0.00052, "epss_percentile": 0.16372}, "CVE-2021-35469": {"epss_score": 0.00034, "epss_percentile": 0.09743}, "CVE-2021-35472": {"epss_score": 0.00648, "epss_percentile": 0.70216}, "CVE-2021-35473": {"epss_score": 0.0014, "epss_percentile": 0.34694}, "CVE-2021-35474": {"epss_score": 0.09211, "epss_percentile": 0.9245}, "CVE-2021-35475": {"epss_score": 0.00617, "epss_percentile": 0.69356}, "CVE-2021-35477": {"epss_score": 0.00043, "epss_percentile": 0.13291}, "CVE-2021-35478": {"epss_score": 0.476, "epss_percentile": 0.97593}, "CVE-2021-35479": {"epss_score": 0.48001, "epss_percentile": 0.97613}, "CVE-2021-35482": {"epss_score": 0.00163, "epss_percentile": 0.37821}, "CVE-2021-35487": {"epss_score": 0.00637, "epss_percentile": 0.69883}, "CVE-2021-35488": {"epss_score": 0.12795, "epss_percentile": 0.93775}, "CVE-2021-35489": {"epss_score": 0.00401, "epss_percentile": 0.60248}, "CVE-2021-35490": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-35491": {"epss_score": 0.00199, "epss_percentile": 0.42102}, "CVE-2021-35492": {"epss_score": 0.12981, "epss_percentile": 0.93835}, "CVE-2021-35493": {"epss_score": 0.00416, "epss_percentile": 0.61191}, "CVE-2021-35494": {"epss_score": 0.00158, "epss_percentile": 0.37216}, "CVE-2021-35495": {"epss_score": 0.00352, "epss_percentile": 0.57096}, "CVE-2021-35496": {"epss_score": 0.00345, "epss_percentile": 0.56597}, "CVE-2021-35497": {"epss_score": 0.00171, "epss_percentile": 0.38869}, "CVE-2021-35498": {"epss_score": 0.00312, "epss_percentile": 0.53957}, "CVE-2021-35499": {"epss_score": 0.00416, "epss_percentile": 0.61191}, "CVE-2021-35500": {"epss_score": 0.00091, "epss_percentile": 0.26232}, "CVE-2021-35501": {"epss_score": 0.00375, "epss_percentile": 0.5864}, "CVE-2021-35502": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-35503": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-35504": {"epss_score": 0.09455, "epss_percentile": 0.92555}, "CVE-2021-35505": {"epss_score": 0.032, "epss_percentile": 0.86622}, "CVE-2021-35506": {"epss_score": 0.00281, "epss_percentile": 0.51188}, "CVE-2021-35508": {"epss_score": 0.00293, "epss_percentile": 0.52315}, "CVE-2021-35512": {"epss_score": 0.01433, "epss_percentile": 0.80257}, "CVE-2021-35513": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2021-35514": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2021-35515": {"epss_score": 0.00811, "epss_percentile": 0.73731}, "CVE-2021-35516": {"epss_score": 0.01893, "epss_percentile": 0.82738}, "CVE-2021-35517": {"epss_score": 0.01437, "epss_percentile": 0.80279}, "CVE-2021-35520": {"epss_score": 0.00092, "epss_percentile": 0.26508}, "CVE-2021-35521": {"epss_score": 0.00286, "epss_percentile": 0.51716}, "CVE-2021-35522": {"epss_score": 0.04097, "epss_percentile": 0.88253}, "CVE-2021-35523": {"epss_score": 0.00067, "epss_percentile": 0.21136}, "CVE-2021-35525": {"epss_score": 0.00614, "epss_percentile": 0.6928}, "CVE-2021-35526": {"epss_score": 9e-05, "epss_percentile": 0.00661}, "CVE-2021-35527": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2021-35528": {"epss_score": 0.00042, "epss_percentile": 0.12804}, "CVE-2021-35529": {"epss_score": 0.00295, "epss_percentile": 0.52447}, "CVE-2021-35530": {"epss_score": 0.00037, "epss_percentile": 0.10678}, "CVE-2021-35531": {"epss_score": 0.00155, "epss_percentile": 0.36785}, "CVE-2021-35532": {"epss_score": 0.00021, "epss_percentile": 0.0477}, "CVE-2021-35533": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2021-35534": {"epss_score": 0.00203, "epss_percentile": 0.42574}, "CVE-2021-35535": {"epss_score": 0.00263, "epss_percentile": 0.49524}, "CVE-2021-35536": {"epss_score": 0.01267, "epss_percentile": 0.79024}, "CVE-2021-35537": {"epss_score": 0.00148, "epss_percentile": 0.35856}, "CVE-2021-35538": {"epss_score": 0.00105, "epss_percentile": 0.29382}, "CVE-2021-35539": {"epss_score": 0.00076, "epss_percentile": 0.23269}, "CVE-2021-35540": {"epss_score": 0.0011, "epss_percentile": 0.30109}, "CVE-2021-35541": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2021-35542": {"epss_score": 0.00044, "epss_percentile": 0.13613}, "CVE-2021-35543": {"epss_score": 0.01352, "epss_percentile": 0.79691}, "CVE-2021-35545": {"epss_score": 0.00048, "epss_percentile": 0.14935}, "CVE-2021-35546": {"epss_score": 0.00534, "epss_percentile": 0.6679}, "CVE-2021-35549": {"epss_score": 0.00081, "epss_percentile": 0.24281}, "CVE-2021-35550": {"epss_score": 0.00078, "epss_percentile": 0.23583}, "CVE-2021-35551": {"epss_score": 0.00293, "epss_percentile": 0.52318}, "CVE-2021-35552": {"epss_score": 0.01183, "epss_percentile": 0.78323}, "CVE-2021-35553": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2021-35554": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2021-35556": {"epss_score": 0.00137, "epss_percentile": 0.34206}, "CVE-2021-35557": {"epss_score": 0.00314, "epss_percentile": 0.54136}, "CVE-2021-35558": {"epss_score": 0.00314, "epss_percentile": 0.54136}, "CVE-2021-35559": {"epss_score": 0.00117, "epss_percentile": 0.31375}, "CVE-2021-35560": {"epss_score": 0.00643, "epss_percentile": 0.70048}, "CVE-2021-35561": {"epss_score": 0.00176, "epss_percentile": 0.39456}, "CVE-2021-35562": {"epss_score": 0.01095, "epss_percentile": 0.77502}, "CVE-2021-35563": {"epss_score": 0.02136, "epss_percentile": 0.8373}, "CVE-2021-35564": {"epss_score": 0.00106, "epss_percentile": 0.29554}, "CVE-2021-35565": {"epss_score": 0.00153, "epss_percentile": 0.36575}, "CVE-2021-35566": {"epss_score": 0.01095, "epss_percentile": 0.77502}, "CVE-2021-35567": {"epss_score": 0.0017, "epss_percentile": 0.38687}, "CVE-2021-35568": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2021-35569": {"epss_score": 0.00411, "epss_percentile": 0.60848}, "CVE-2021-35570": {"epss_score": 0.01168, "epss_percentile": 0.78194}, "CVE-2021-35571": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2021-35572": {"epss_score": 0.018, "epss_percentile": 0.82322}, "CVE-2021-35573": {"epss_score": 0.018, "epss_percentile": 0.82322}, "CVE-2021-35574": {"epss_score": 0.01571, "epss_percentile": 0.81094}, "CVE-2021-35575": {"epss_score": 0.00393, "epss_percentile": 0.59741}, "CVE-2021-35576": {"epss_score": 0.00439, "epss_percentile": 0.62605}, "CVE-2021-35577": {"epss_score": 0.00309, "epss_percentile": 0.53681}, "CVE-2021-35578": {"epss_score": 0.00144, "epss_percentile": 0.35229}, "CVE-2021-35580": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2021-35581": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2021-35582": {"epss_score": 0.00183, "epss_percentile": 0.40365}, "CVE-2021-35583": {"epss_score": 0.01522, "epss_percentile": 0.80835}, "CVE-2021-35584": {"epss_score": 0.00281, "epss_percentile": 0.51116}, "CVE-2021-35585": {"epss_score": 0.01267, "epss_percentile": 0.79024}, "CVE-2021-35586": {"epss_score": 0.00167, "epss_percentile": 0.38325}, "CVE-2021-35587": {"epss_score": 0.94234, "epss_percentile": 0.99923}, "CVE-2021-35588": {"epss_score": 0.00084, "epss_percentile": 0.24994}, "CVE-2021-35589": {"epss_score": 0.00074, "epss_percentile": 0.22874}, "CVE-2021-35590": {"epss_score": 0.28894, "epss_percentile": 0.96398}, "CVE-2021-35591": {"epss_score": 0.00389, "epss_percentile": 0.59497}, "CVE-2021-35592": {"epss_score": 0.39342, "epss_percentile": 0.97156}, "CVE-2021-35593": {"epss_score": 0.39342, "epss_percentile": 0.97156}, "CVE-2021-35594": {"epss_score": 0.39342, "epss_percentile": 0.97156}, "CVE-2021-35595": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2021-35596": {"epss_score": 0.00309, "epss_percentile": 0.53681}, "CVE-2021-35597": {"epss_score": 0.00674, "epss_percentile": 0.70874}, "CVE-2021-35598": {"epss_score": 0.39342, "epss_percentile": 0.97156}, "CVE-2021-35599": {"epss_score": 0.00056, "epss_percentile": 0.17879}, "CVE-2021-35601": {"epss_score": 0.0017, "epss_percentile": 0.38735}, "CVE-2021-35602": {"epss_score": 0.00224, "epss_percentile": 0.45071}, "CVE-2021-35603": {"epss_score": 0.00123, "epss_percentile": 0.32252}, "CVE-2021-35604": {"epss_score": 0.0019, "epss_percentile": 0.4111}, "CVE-2021-35606": {"epss_score": 0.0017, "epss_percentile": 0.38735}, "CVE-2021-35607": {"epss_score": 0.00182, "epss_percentile": 0.40266}, "CVE-2021-35608": {"epss_score": 0.00088, "epss_percentile": 0.25772}, "CVE-2021-35609": {"epss_score": 0.00573, "epss_percentile": 0.68055}, "CVE-2021-35610": {"epss_score": 0.00567, "epss_percentile": 0.67849}, "CVE-2021-35611": {"epss_score": 0.00454, "epss_percentile": 0.63269}, "CVE-2021-35612": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2021-35613": {"epss_score": 0.0073, "epss_percentile": 0.72153}, "CVE-2021-35616": {"epss_score": 0.02805, "epss_percentile": 0.85706}, "CVE-2021-35617": {"epss_score": 0.05214, "epss_percentile": 0.89619}, "CVE-2021-35618": {"epss_score": 0.00323, "epss_percentile": 0.54876}, "CVE-2021-35619": {"epss_score": 0.01237, "epss_percentile": 0.78778}, "CVE-2021-35620": {"epss_score": 0.02525, "epss_percentile": 0.85011}, "CVE-2021-35621": {"epss_score": 0.06237, "epss_percentile": 0.9059}, "CVE-2021-35622": {"epss_score": 0.00231, "epss_percentile": 0.45831}, "CVE-2021-35623": {"epss_score": 0.00111, "epss_percentile": 0.30319}, "CVE-2021-35624": {"epss_score": 0.00301, "epss_percentile": 0.53056}, "CVE-2021-35625": {"epss_score": 0.00153, "epss_percentile": 0.36615}, "CVE-2021-35626": {"epss_score": 0.00318, "epss_percentile": 0.54408}, "CVE-2021-35627": {"epss_score": 0.00439, "epss_percentile": 0.62583}, "CVE-2021-35628": {"epss_score": 0.00439, "epss_percentile": 0.62583}, "CVE-2021-35629": {"epss_score": 0.00249, "epss_percentile": 0.48065}, "CVE-2021-35630": {"epss_score": 0.00416, "epss_percentile": 0.61181}, "CVE-2021-35631": {"epss_score": 0.00439, "epss_percentile": 0.62583}, "CVE-2021-35632": {"epss_score": 0.00119, "epss_percentile": 0.31672}, "CVE-2021-35633": {"epss_score": 0.00185, "epss_percentile": 0.40525}, "CVE-2021-35634": {"epss_score": 0.00439, "epss_percentile": 0.62583}, "CVE-2021-35635": {"epss_score": 0.00439, "epss_percentile": 0.62583}, "CVE-2021-35636": {"epss_score": 0.00439, "epss_percentile": 0.62583}, "CVE-2021-35637": {"epss_score": 0.00216, "epss_percentile": 0.44226}, "CVE-2021-35638": {"epss_score": 0.00401, "epss_percentile": 0.60228}, "CVE-2021-35639": {"epss_score": 0.00145, "epss_percentile": 0.35397}, "CVE-2021-35640": {"epss_score": 0.00117, "epss_percentile": 0.31231}, "CVE-2021-35641": {"epss_score": 0.00439, "epss_percentile": 0.62583}, "CVE-2021-35642": {"epss_score": 0.00318, "epss_percentile": 0.54408}, "CVE-2021-35643": {"epss_score": 0.00318, "epss_percentile": 0.54408}, "CVE-2021-35644": {"epss_score": 0.00439, "epss_percentile": 0.62583}, "CVE-2021-35645": {"epss_score": 0.00439, "epss_percentile": 0.62583}, "CVE-2021-35646": {"epss_score": 0.00318, "epss_percentile": 0.54408}, "CVE-2021-35647": {"epss_score": 0.00318, "epss_percentile": 0.54408}, "CVE-2021-35648": {"epss_score": 0.00439, "epss_percentile": 0.62583}, "CVE-2021-35649": {"epss_score": 0.00299, "epss_percentile": 0.52873}, "CVE-2021-35650": {"epss_score": 0.00206, "epss_percentile": 0.43042}, "CVE-2021-35651": {"epss_score": 0.00356, "epss_percentile": 0.57372}, "CVE-2021-35652": {"epss_score": 0.02228, "epss_percentile": 0.84078}, "CVE-2021-35653": {"epss_score": 0.004, "epss_percentile": 0.60179}, "CVE-2021-35654": {"epss_score": 0.01639, "epss_percentile": 0.81491}, "CVE-2021-35655": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2021-35656": {"epss_score": 0.018, "epss_percentile": 0.82322}, "CVE-2021-35657": {"epss_score": 0.018, "epss_percentile": 0.82322}, "CVE-2021-35658": {"epss_score": 0.018, "epss_percentile": 0.82322}, "CVE-2021-35659": {"epss_score": 0.018, "epss_percentile": 0.82322}, "CVE-2021-35660": {"epss_score": 0.018, "epss_percentile": 0.82322}, "CVE-2021-35661": {"epss_score": 0.018, "epss_percentile": 0.82322}, "CVE-2021-35662": {"epss_score": 0.018, "epss_percentile": 0.82322}, "CVE-2021-35665": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2021-35666": {"epss_score": 0.01322, "epss_percentile": 0.7945}, "CVE-2021-35683": {"epss_score": 0.01544, "epss_percentile": 0.80959}, "CVE-2021-35686": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2021-35687": {"epss_score": 0.01176, "epss_percentile": 0.78272}, "CVE-2021-35689": {"epss_score": 0.02521, "epss_percentile": 0.85003}, "CVE-2021-35936": {"epss_score": 0.01403, "epss_percentile": 0.80033}, "CVE-2021-35937": {"epss_score": 0.00012, "epss_percentile": 0.01355}, "CVE-2021-35938": {"epss_score": 0.00117, "epss_percentile": 0.31353}, "CVE-2021-35939": {"epss_score": 0.00159, "epss_percentile": 0.37383}, "CVE-2021-35940": {"epss_score": 0.00057, "epss_percentile": 0.181}, "CVE-2021-35941": {"epss_score": 0.03795, "epss_percentile": 0.87734}, "CVE-2021-35942": {"epss_score": 0.01109, "epss_percentile": 0.77654}, "CVE-2021-35943": {"epss_score": 0.0038, "epss_percentile": 0.58928}, "CVE-2021-35944": {"epss_score": 0.00508, "epss_percentile": 0.65704}, "CVE-2021-35945": {"epss_score": 0.00508, "epss_percentile": 0.65704}, "CVE-2021-35946": {"epss_score": 0.00311, "epss_percentile": 0.53839}, "CVE-2021-35947": {"epss_score": 0.00256, "epss_percentile": 0.48782}, "CVE-2021-35948": {"epss_score": 0.00171, "epss_percentile": 0.38866}, "CVE-2021-35949": {"epss_score": 0.00176, "epss_percentile": 0.39491}, "CVE-2021-35951": {"epss_score": 0.00636, "epss_percentile": 0.69873}, "CVE-2021-35952": {"epss_score": 0.00196, "epss_percentile": 0.41814}, "CVE-2021-35953": {"epss_score": 0.00563, "epss_percentile": 0.67718}, "CVE-2021-35954": {"epss_score": 0.00203, "epss_percentile": 0.42581}, "CVE-2021-35955": {"epss_score": 0.0031, "epss_percentile": 0.53775}, "CVE-2021-35956": {"epss_score": 0.00984, "epss_percentile": 0.76314}, "CVE-2021-35957": {"epss_score": 0.00055, "epss_percentile": 0.17441}, "CVE-2021-35958": {"epss_score": 0.01093, "epss_percentile": 0.77478}, "CVE-2021-35959": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-35961": {"epss_score": 0.01583, "epss_percentile": 0.81145}, "CVE-2021-35962": {"epss_score": 0.00509, "epss_percentile": 0.65756}, "CVE-2021-35963": {"epss_score": 0.02108, "epss_percentile": 0.83636}, "CVE-2021-35964": {"epss_score": 0.00692, "epss_percentile": 0.71294}, "CVE-2021-35965": {"epss_score": 0.01802, "epss_percentile": 0.82333}, "CVE-2021-35966": {"epss_score": 0.00177, "epss_percentile": 0.3953}, "CVE-2021-35967": {"epss_score": 0.00189, "epss_percentile": 0.40966}, "CVE-2021-35968": {"epss_score": 0.00136, "epss_percentile": 0.34202}, "CVE-2021-35969": {"epss_score": 0.00449, "epss_percentile": 0.63043}, "CVE-2021-35970": {"epss_score": 0.00609, "epss_percentile": 0.69128}, "CVE-2021-35971": {"epss_score": 0.00775, "epss_percentile": 0.73089}, "CVE-2021-35973": {"epss_score": 0.01454, "epss_percentile": 0.80381}, "CVE-2021-35975": {"epss_score": 0.0024, "epss_percentile": 0.46969}, "CVE-2021-35976": {"epss_score": 0.0053, "epss_percentile": 0.66612}, "CVE-2021-35977": {"epss_score": 0.00677, "epss_percentile": 0.70945}, "CVE-2021-35978": {"epss_score": 0.08068, "epss_percentile": 0.91865}, "CVE-2021-35979": {"epss_score": 0.00276, "epss_percentile": 0.50718}, "CVE-2021-35980": {"epss_score": 0.00833, "epss_percentile": 0.74086}, "CVE-2021-35981": {"epss_score": 0.14581, "epss_percentile": 0.94245}, "CVE-2021-35982": {"epss_score": 0.00308, "epss_percentile": 0.53626}, "CVE-2021-35983": {"epss_score": 0.50594, "epss_percentile": 0.97742}, "CVE-2021-35984": {"epss_score": 0.00793, "epss_percentile": 0.7343}, "CVE-2021-35985": {"epss_score": 0.00804, "epss_percentile": 0.73627}, "CVE-2021-35986": {"epss_score": 0.00432, "epss_percentile": 0.62108}, "CVE-2021-35987": {"epss_score": 0.00918, "epss_percentile": 0.75438}, "CVE-2021-35988": {"epss_score": 0.00918, "epss_percentile": 0.75438}, "CVE-2021-35989": {"epss_score": 0.02988, "epss_percentile": 0.86139}, "CVE-2021-35990": {"epss_score": 0.02988, "epss_percentile": 0.86139}, "CVE-2021-35991": {"epss_score": 0.00503, "epss_percentile": 0.65482}, "CVE-2021-35992": {"epss_score": 0.0079, "epss_percentile": 0.73379}, "CVE-2021-35993": {"epss_score": 0.02122, "epss_percentile": 0.83681}, "CVE-2021-35994": {"epss_score": 0.01482, "epss_percentile": 0.80581}, "CVE-2021-35995": {"epss_score": 0.00643, "epss_percentile": 0.70064}, "CVE-2021-35996": {"epss_score": 0.01482, "epss_percentile": 0.80581}, "CVE-2021-35997": {"epss_score": 0.0125, "epss_percentile": 0.78891}, "CVE-2021-35999": {"epss_score": 0.02397, "epss_percentile": 0.84621}, "CVE-2021-36000": {"epss_score": 0.00875, "epss_percentile": 0.74774}, "CVE-2021-36001": {"epss_score": 0.0102, "epss_percentile": 0.76743}, "CVE-2021-36002": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2021-36003": {"epss_score": 0.00707, "epss_percentile": 0.71651}, "CVE-2021-36004": {"epss_score": 0.05361, "epss_percentile": 0.89783}, "CVE-2021-36005": {"epss_score": 0.08338, "epss_percentile": 0.91997}, "CVE-2021-36006": {"epss_score": 0.00279, "epss_percentile": 0.50977}, "CVE-2021-36007": {"epss_score": 0.0036, "epss_percentile": 0.57651}, "CVE-2021-36008": {"epss_score": 0.00786, "epss_percentile": 0.73287}, "CVE-2021-36009": {"epss_score": 0.00782, "epss_percentile": 0.732}, "CVE-2021-36010": {"epss_score": 0.0095, "epss_percentile": 0.75857}, "CVE-2021-36011": {"epss_score": 0.01461, "epss_percentile": 0.8043}, "CVE-2021-36012": {"epss_score": 0.00584, "epss_percentile": 0.68382}, "CVE-2021-36013": {"epss_score": 0.02246, "epss_percentile": 0.84134}, "CVE-2021-36014": {"epss_score": 0.00651, "epss_percentile": 0.7028}, "CVE-2021-36015": {"epss_score": 0.00875, "epss_percentile": 0.74774}, "CVE-2021-36016": {"epss_score": 0.0102, "epss_percentile": 0.76743}, "CVE-2021-36017": {"epss_score": 0.01038, "epss_percentile": 0.76934}, "CVE-2021-36018": {"epss_score": 0.01112, "epss_percentile": 0.77678}, "CVE-2021-36019": {"epss_score": 0.00853, "epss_percentile": 0.74434}, "CVE-2021-36020": {"epss_score": 0.31066, "epss_percentile": 0.96585}, "CVE-2021-36021": {"epss_score": 0.00898, "epss_percentile": 0.75144}, "CVE-2021-36022": {"epss_score": 0.11326, "epss_percentile": 0.9331}, "CVE-2021-36023": {"epss_score": 0.09651, "epss_percentile": 0.9264}, "CVE-2021-36024": {"epss_score": 0.08668, "epss_percentile": 0.92181}, "CVE-2021-36025": {"epss_score": 0.05476, "epss_percentile": 0.89912}, "CVE-2021-36026": {"epss_score": 0.01528, "epss_percentile": 0.80872}, "CVE-2021-36027": {"epss_score": 0.01528, "epss_percentile": 0.80872}, "CVE-2021-36028": {"epss_score": 0.11326, "epss_percentile": 0.9331}, "CVE-2021-36029": {"epss_score": 0.04985, "epss_percentile": 0.89364}, "CVE-2021-36030": {"epss_score": 0.01056, "epss_percentile": 0.77123}, "CVE-2021-36031": {"epss_score": 0.1031, "epss_percentile": 0.92938}, "CVE-2021-36032": {"epss_score": 0.00646, "epss_percentile": 0.70147}, "CVE-2021-36033": {"epss_score": 0.11326, "epss_percentile": 0.9331}, "CVE-2021-36034": {"epss_score": 0.05476, "epss_percentile": 0.89912}, "CVE-2021-36035": {"epss_score": 0.07254, "epss_percentile": 0.91352}, "CVE-2021-36036": {"epss_score": 0.01182, "epss_percentile": 0.78317}, "CVE-2021-36037": {"epss_score": 0.00662, "epss_percentile": 0.70604}, "CVE-2021-36038": {"epss_score": 0.01081, "epss_percentile": 0.7737}, "CVE-2021-36039": {"epss_score": 0.00591, "epss_percentile": 0.68591}, "CVE-2021-36040": {"epss_score": 0.03446, "epss_percentile": 0.87148}, "CVE-2021-36041": {"epss_score": 0.05476, "epss_percentile": 0.89912}, "CVE-2021-36042": {"epss_score": 0.04108, "epss_percentile": 0.88268}, "CVE-2021-36043": {"epss_score": 0.0261, "epss_percentile": 0.85234}, "CVE-2021-36044": {"epss_score": 0.01739, "epss_percentile": 0.82041}, "CVE-2021-36045": {"epss_score": 0.00247, "epss_percentile": 0.47838}, "CVE-2021-36046": {"epss_score": 0.00293, "epss_percentile": 0.52328}, "CVE-2021-36047": {"epss_score": 0.00454, "epss_percentile": 0.63271}, "CVE-2021-36048": {"epss_score": 0.00454, "epss_percentile": 0.63271}, "CVE-2021-36049": {"epss_score": 0.01751, "epss_percentile": 0.82104}, "CVE-2021-36050": {"epss_score": 0.00654, "epss_percentile": 0.70353}, "CVE-2021-36051": {"epss_score": 0.02723, "epss_percentile": 0.85522}, "CVE-2021-36052": {"epss_score": 0.02453, "epss_percentile": 0.84792}, "CVE-2021-36053": {"epss_score": 0.00247, "epss_percentile": 0.47838}, "CVE-2021-36054": {"epss_score": 0.00111, "epss_percentile": 0.30382}, "CVE-2021-36055": {"epss_score": 0.00698, "epss_percentile": 0.71421}, "CVE-2021-36056": {"epss_score": 0.00279, "epss_percentile": 0.50942}, "CVE-2021-36057": {"epss_score": 0.00044, "epss_percentile": 0.13546}, "CVE-2021-36058": {"epss_score": 0.00256, "epss_percentile": 0.48794}, "CVE-2021-36059": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-36060": {"epss_score": 0.00026, "epss_percentile": 0.06575}, "CVE-2021-36061": {"epss_score": 0.00965, "epss_percentile": 0.76048}, "CVE-2021-36062": {"epss_score": 0.00688, "epss_percentile": 0.71206}, "CVE-2021-36063": {"epss_score": 0.00877, "epss_percentile": 0.74803}, "CVE-2021-36064": {"epss_score": 0.00597, "epss_percentile": 0.68751}, "CVE-2021-36065": {"epss_score": 0.06706, "epss_percentile": 0.9096}, "CVE-2021-36066": {"epss_score": 0.0167, "epss_percentile": 0.81671}, "CVE-2021-36067": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-36068": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-36069": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-36070": {"epss_score": 0.01119, "epss_percentile": 0.77755}, "CVE-2021-36071": {"epss_score": 0.0143, "epss_percentile": 0.80233}, "CVE-2021-36072": {"epss_score": 0.0167, "epss_percentile": 0.81671}, "CVE-2021-36073": {"epss_score": 0.08338, "epss_percentile": 0.91997}, "CVE-2021-36074": {"epss_score": 0.01117, "epss_percentile": 0.77738}, "CVE-2021-36075": {"epss_score": 0.08338, "epss_percentile": 0.91997}, "CVE-2021-36076": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-36077": {"epss_score": 0.0031, "epss_percentile": 0.53748}, "CVE-2021-36078": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-36079": {"epss_score": 0.02468, "epss_percentile": 0.84839}, "CVE-2021-36080": {"epss_score": 0.00436, "epss_percentile": 0.62382}, "CVE-2021-36081": {"epss_score": 0.00242, "epss_percentile": 0.47345}, "CVE-2021-36082": {"epss_score": 0.00503, "epss_percentile": 0.65463}, "CVE-2021-36083": {"epss_score": 0.0038, "epss_percentile": 0.58932}, "CVE-2021-36084": {"epss_score": 0.00017, "epss_percentile": 0.03131}, "CVE-2021-36085": {"epss_score": 0.00017, "epss_percentile": 0.03134}, "CVE-2021-36086": {"epss_score": 0.00017, "epss_percentile": 0.03134}, "CVE-2021-36087": {"epss_score": 0.00017, "epss_percentile": 0.03134}, "CVE-2021-36088": {"epss_score": 0.00513, "epss_percentile": 0.65917}, "CVE-2021-36089": {"epss_score": 0.00409, "epss_percentile": 0.60733}, "CVE-2021-36090": {"epss_score": 0.00802, "epss_percentile": 0.73593}, "CVE-2021-36091": {"epss_score": 0.00182, "epss_percentile": 0.40138}, "CVE-2021-36092": {"epss_score": 0.00364, "epss_percentile": 0.57934}, "CVE-2021-36093": {"epss_score": 0.0047, "epss_percentile": 0.63961}, "CVE-2021-36094": {"epss_score": 0.00282, "epss_percentile": 0.51228}, "CVE-2021-36095": {"epss_score": 0.00252, "epss_percentile": 0.48412}, "CVE-2021-36096": {"epss_score": 0.00167, "epss_percentile": 0.3837}, "CVE-2021-36097": {"epss_score": 0.00115, "epss_percentile": 0.30922}, "CVE-2021-36100": {"epss_score": 0.00814, "epss_percentile": 0.73767}, "CVE-2021-36121": {"epss_score": 0.01665, "epss_percentile": 0.81645}, "CVE-2021-36122": {"epss_score": 0.00941, "epss_percentile": 0.75749}, "CVE-2021-36123": {"epss_score": 0.0032, "epss_percentile": 0.54632}, "CVE-2021-36124": {"epss_score": 0.00541, "epss_percentile": 0.67058}, "CVE-2021-36125": {"epss_score": 0.00275, "epss_percentile": 0.50641}, "CVE-2021-36126": {"epss_score": 0.00339, "epss_percentile": 0.56174}, "CVE-2021-36127": {"epss_score": 0.00111, "epss_percentile": 0.30351}, "CVE-2021-36128": {"epss_score": 0.00566, "epss_percentile": 0.67828}, "CVE-2021-36129": {"epss_score": 0.00105, "epss_percentile": 0.293}, "CVE-2021-36130": {"epss_score": 0.00206, "epss_percentile": 0.43073}, "CVE-2021-36131": {"epss_score": 0.00192, "epss_percentile": 0.41327}, "CVE-2021-36132": {"epss_score": 0.00252, "epss_percentile": 0.48383}, "CVE-2021-36133": {"epss_score": 0.00055, "epss_percentile": 0.17373}, "CVE-2021-36134": {"epss_score": 0.00133, "epss_percentile": 0.33725}, "CVE-2021-36143": {"epss_score": 0.00437, "epss_percentile": 0.62527}, "CVE-2021-36144": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2021-36145": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2021-36146": {"epss_score": 0.00235, "epss_percentile": 0.46232}, "CVE-2021-36147": {"epss_score": 0.00435, "epss_percentile": 0.62332}, "CVE-2021-36148": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2021-36150": {"epss_score": 0.00372, "epss_percentile": 0.58436}, "CVE-2021-36151": {"epss_score": 0.00074, "epss_percentile": 0.22685}, "CVE-2021-36152": {"epss_score": 0.01283, "epss_percentile": 0.79159}, "CVE-2021-36153": {"epss_score": 0.01361, "epss_percentile": 0.79754}, "CVE-2021-36154": {"epss_score": 0.00846, "epss_percentile": 0.74321}, "CVE-2021-36155": {"epss_score": 0.00846, "epss_percentile": 0.74321}, "CVE-2021-36156": {"epss_score": 0.00395, "epss_percentile": 0.59846}, "CVE-2021-36157": {"epss_score": 0.00242, "epss_percentile": 0.47389}, "CVE-2021-36158": {"epss_score": 0.00085, "epss_percentile": 0.25182}, "CVE-2021-36159": {"epss_score": 0.00573, "epss_percentile": 0.68051}, "CVE-2021-36160": {"epss_score": 0.04962, "epss_percentile": 0.89335}, "CVE-2021-36161": {"epss_score": 0.02734, "epss_percentile": 0.85549}, "CVE-2021-36162": {"epss_score": 0.01354, "epss_percentile": 0.79702}, "CVE-2021-36163": {"epss_score": 0.01617, "epss_percentile": 0.81364}, "CVE-2021-36165": {"epss_score": 0.00108, "epss_percentile": 0.29902}, "CVE-2021-36166": {"epss_score": 0.00503, "epss_percentile": 0.65484}, "CVE-2021-36167": {"epss_score": 0.0014, "epss_percentile": 0.34711}, "CVE-2021-36168": {"epss_score": 0.00267, "epss_percentile": 0.49962}, "CVE-2021-36169": {"epss_score": 0.00124, "epss_percentile": 0.32395}, "CVE-2021-36170": {"epss_score": 0.0011, "epss_percentile": 0.30153}, "CVE-2021-36171": {"epss_score": 0.00484, "epss_percentile": 0.6465}, "CVE-2021-36172": {"epss_score": 0.00257, "epss_percentile": 0.48884}, "CVE-2021-36173": {"epss_score": 0.00672, "epss_percentile": 0.70809}, "CVE-2021-36174": {"epss_score": 0.00331, "epss_percentile": 0.55508}, "CVE-2021-36175": {"epss_score": 0.00192, "epss_percentile": 0.41359}, "CVE-2021-36176": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2021-36177": {"epss_score": 0.00165, "epss_percentile": 0.38036}, "CVE-2021-36178": {"epss_score": 0.00253, "epss_percentile": 0.48465}, "CVE-2021-36179": {"epss_score": 0.00583, "epss_percentile": 0.68352}, "CVE-2021-36180": {"epss_score": 0.0049, "epss_percentile": 0.64931}, "CVE-2021-36181": {"epss_score": 0.00295, "epss_percentile": 0.52446}, "CVE-2021-36182": {"epss_score": 0.00748, "epss_percentile": 0.72576}, "CVE-2021-36183": {"epss_score": 0.00136, "epss_percentile": 0.34168}, "CVE-2021-36184": {"epss_score": 0.00308, "epss_percentile": 0.53569}, "CVE-2021-36185": {"epss_score": 0.01781, "epss_percentile": 0.82238}, "CVE-2021-36186": {"epss_score": 0.00535, "epss_percentile": 0.66833}, "CVE-2021-36187": {"epss_score": 0.01116, "epss_percentile": 0.77719}, "CVE-2021-36188": {"epss_score": 0.00374, "epss_percentile": 0.58578}, "CVE-2021-36189": {"epss_score": 0.00092, "epss_percentile": 0.2653}, "CVE-2021-36190": {"epss_score": 0.00491, "epss_percentile": 0.64965}, "CVE-2021-36191": {"epss_score": 0.00217, "epss_percentile": 0.44299}, "CVE-2021-36192": {"epss_score": 0.00054, "epss_percentile": 0.17226}, "CVE-2021-36193": {"epss_score": 0.00496, "epss_percentile": 0.65139}, "CVE-2021-36194": {"epss_score": 0.0076, "epss_percentile": 0.72798}, "CVE-2021-36195": {"epss_score": 0.00218, "epss_percentile": 0.44376}, "CVE-2021-36198": {"epss_score": 0.00196, "epss_percentile": 0.41747}, "CVE-2021-36199": {"epss_score": 0.00219, "epss_percentile": 0.44474}, "CVE-2021-36200": {"epss_score": 0.00277, "epss_percentile": 0.50814}, "CVE-2021-36201": {"epss_score": 0.00122, "epss_percentile": 0.32123}, "CVE-2021-36202": {"epss_score": 0.0019, "epss_percentile": 0.41138}, "CVE-2021-36203": {"epss_score": 0.00168, "epss_percentile": 0.38427}, "CVE-2021-36204": {"epss_score": 0.00228, "epss_percentile": 0.45527}, "CVE-2021-36205": {"epss_score": 0.00275, "epss_percentile": 0.50665}, "CVE-2021-36206": {"epss_score": 0.00619, "epss_percentile": 0.69424}, "CVE-2021-36207": {"epss_score": 0.00158, "epss_percentile": 0.37153}, "CVE-2021-36209": {"epss_score": 4e-05, "epss_percentile": 0.00159}, "CVE-2021-36212": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-36213": {"epss_score": 0.00765, "epss_percentile": 0.72912}, "CVE-2021-36214": {"epss_score": 0.00212, "epss_percentile": 0.43815}, "CVE-2021-36215": {"epss_score": 0.00209, "epss_percentile": 0.43395}, "CVE-2021-36216": {"epss_score": 0.0006, "epss_percentile": 0.18936}, "CVE-2021-36218": {"epss_score": 0.00408, "epss_percentile": 0.60657}, "CVE-2021-36219": {"epss_score": 0.00413, "epss_percentile": 0.61007}, "CVE-2021-36221": {"epss_score": 0.00198, "epss_percentile": 0.42009}, "CVE-2021-36222": {"epss_score": 0.08014, "epss_percentile": 0.91828}, "CVE-2021-36224": {"epss_score": 0.00105, "epss_percentile": 0.29289}, "CVE-2021-36225": {"epss_score": 0.00088, "epss_percentile": 0.25782}, "CVE-2021-36226": {"epss_score": 0.00055, "epss_percentile": 0.17489}, "CVE-2021-36230": {"epss_score": 0.00553, "epss_percentile": 0.67426}, "CVE-2021-36231": {"epss_score": 0.01137, "epss_percentile": 0.77923}, "CVE-2021-36232": {"epss_score": 0.00432, "epss_percentile": 0.62108}, "CVE-2021-36233": {"epss_score": 0.00422, "epss_percentile": 0.61549}, "CVE-2021-36234": {"epss_score": 0.00046, "epss_percentile": 0.14397}, "CVE-2021-36235": {"epss_score": 0.00303, "epss_percentile": 0.53234}, "CVE-2021-36260": {"epss_score": 0.94436, "epss_percentile": 0.99984}, "CVE-2021-36276": {"epss_score": 0.0003, "epss_percentile": 0.08112}, "CVE-2021-36277": {"epss_score": 0.00019, "epss_percentile": 0.0407}, "CVE-2021-36278": {"epss_score": 0.00187, "epss_percentile": 0.40707}, "CVE-2021-36279": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2021-36280": {"epss_score": 0.00047, "epss_percentile": 0.14787}, "CVE-2021-36281": {"epss_score": 0.00396, "epss_percentile": 0.59853}, "CVE-2021-36282": {"epss_score": 0.00054, "epss_percentile": 0.17226}, "CVE-2021-36283": {"epss_score": 0.0004, "epss_percentile": 0.12}, "CVE-2021-36284": {"epss_score": 0.00049, "epss_percentile": 0.15296}, "CVE-2021-36285": {"epss_score": 0.00049, "epss_percentile": 0.15296}, "CVE-2021-36286": {"epss_score": 0.00065, "epss_percentile": 0.2045}, "CVE-2021-36287": {"epss_score": 0.02113, "epss_percentile": 0.83649}, "CVE-2021-36288": {"epss_score": 0.00932, "epss_percentile": 0.75626}, "CVE-2021-36289": {"epss_score": 0.00047, "epss_percentile": 0.14789}, "CVE-2021-36290": {"epss_score": 0.00047, "epss_percentile": 0.1477}, "CVE-2021-36293": {"epss_score": 0.00075, "epss_percentile": 0.22912}, "CVE-2021-36294": {"epss_score": 0.00575, "epss_percentile": 0.68109}, "CVE-2021-36295": {"epss_score": 0.00942, "epss_percentile": 0.75761}, "CVE-2021-36296": {"epss_score": 0.00942, "epss_percentile": 0.75761}, "CVE-2021-36297": {"epss_score": 0.00053, "epss_percentile": 0.16833}, "CVE-2021-36298": {"epss_score": 0.00198, "epss_percentile": 0.42045}, "CVE-2021-36299": {"epss_score": 0.01918, "epss_percentile": 0.82873}, "CVE-2021-36300": {"epss_score": 0.05939, "epss_percentile": 0.90348}, "CVE-2021-36301": {"epss_score": 0.14489, "epss_percentile": 0.94222}, "CVE-2021-36302": {"epss_score": 0.00244, "epss_percentile": 0.4762}, "CVE-2021-36305": {"epss_score": 0.00237, "epss_percentile": 0.46654}, "CVE-2021-36306": {"epss_score": 0.01724, "epss_percentile": 0.81951}, "CVE-2021-36307": {"epss_score": 0.00232, "epss_percentile": 0.45884}, "CVE-2021-36308": {"epss_score": 0.01724, "epss_percentile": 0.81951}, "CVE-2021-36309": {"epss_score": 0.00259, "epss_percentile": 0.49062}, "CVE-2021-36310": {"epss_score": 0.00318, "epss_percentile": 0.54451}, "CVE-2021-36311": {"epss_score": 0.00037, "epss_percentile": 0.10792}, "CVE-2021-36312": {"epss_score": 0.00207, "epss_percentile": 0.43149}, "CVE-2021-36313": {"epss_score": 0.01038, "epss_percentile": 0.7694}, "CVE-2021-36314": {"epss_score": 0.00768, "epss_percentile": 0.72964}, "CVE-2021-36315": {"epss_score": 0.00045, "epss_percentile": 0.13728}, "CVE-2021-36316": {"epss_score": 0.00226, "epss_percentile": 0.45245}, "CVE-2021-36317": {"epss_score": 0.00037, "epss_percentile": 0.10636}, "CVE-2021-36318": {"epss_score": 0.00041, "epss_percentile": 0.12252}, "CVE-2021-36319": {"epss_score": 0.0005, "epss_percentile": 0.15946}, "CVE-2021-36320": {"epss_score": 0.00817, "epss_percentile": 0.73846}, "CVE-2021-36321": {"epss_score": 0.00387, "epss_percentile": 0.59299}, "CVE-2021-36322": {"epss_score": 0.00673, "epss_percentile": 0.70832}, "CVE-2021-36323": {"epss_score": 0.0004, "epss_percentile": 0.12}, "CVE-2021-36324": {"epss_score": 0.0004, "epss_percentile": 0.12}, "CVE-2021-36325": {"epss_score": 0.0004, "epss_percentile": 0.12}, "CVE-2021-36326": {"epss_score": 0.00401, "epss_percentile": 0.60215}, "CVE-2021-36327": {"epss_score": 0.00298, "epss_percentile": 0.52807}, "CVE-2021-36328": {"epss_score": 0.00371, "epss_percentile": 0.58403}, "CVE-2021-36329": {"epss_score": 0.00215, "epss_percentile": 0.44054}, "CVE-2021-36330": {"epss_score": 0.0085, "epss_percentile": 0.74388}, "CVE-2021-36332": {"epss_score": 0.00112, "epss_percentile": 0.30577}, "CVE-2021-36333": {"epss_score": 0.00042, "epss_percentile": 0.12787}, "CVE-2021-36334": {"epss_score": 0.00467, "epss_percentile": 0.63817}, "CVE-2021-36335": {"epss_score": 0.00428, "epss_percentile": 0.61937}, "CVE-2021-36336": {"epss_score": 0.03055, "epss_percentile": 0.86298}, "CVE-2021-36337": {"epss_score": 0.001, "epss_percentile": 0.28498}, "CVE-2021-36338": {"epss_score": 0.00077, "epss_percentile": 0.23289}, "CVE-2021-36339": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-36340": {"epss_score": 0.00048, "epss_percentile": 0.14953}, "CVE-2021-36341": {"epss_score": 0.00046, "epss_percentile": 0.14305}, "CVE-2021-36342": {"epss_score": 0.0004, "epss_percentile": 0.12}, "CVE-2021-36343": {"epss_score": 0.0004, "epss_percentile": 0.12}, "CVE-2021-36346": {"epss_score": 0.00949, "epss_percentile": 0.75837}, "CVE-2021-36347": {"epss_score": 0.03741, "epss_percentile": 0.87657}, "CVE-2021-36348": {"epss_score": 0.00549, "epss_percentile": 0.67322}, "CVE-2021-36349": {"epss_score": 0.00133, "epss_percentile": 0.33695}, "CVE-2021-36350": {"epss_score": 0.00392, "epss_percentile": 0.59642}, "CVE-2021-36351": {"epss_score": 0.00477, "epss_percentile": 0.64304}, "CVE-2021-36352": {"epss_score": 0.00175, "epss_percentile": 0.39368}, "CVE-2021-36356": {"epss_score": 0.91156, "epss_percentile": 0.99624}, "CVE-2021-36357": {"epss_score": 0.00203, "epss_percentile": 0.42558}, "CVE-2021-36359": {"epss_score": 0.04884, "epss_percentile": 0.89253}, "CVE-2021-36363": {"epss_score": 0.01017, "epss_percentile": 0.76695}, "CVE-2021-36364": {"epss_score": 0.11091, "epss_percentile": 0.93216}, "CVE-2021-36365": {"epss_score": 0.01017, "epss_percentile": 0.76695}, "CVE-2021-36366": {"epss_score": 0.11091, "epss_percentile": 0.93216}, "CVE-2021-36367": {"epss_score": 0.00135, "epss_percentile": 0.33996}, "CVE-2021-36368": {"epss_score": 0.00395, "epss_percentile": 0.59844}, "CVE-2021-36369": {"epss_score": 0.00129, "epss_percentile": 0.33195}, "CVE-2021-36370": {"epss_score": 0.01137, "epss_percentile": 0.77926}, "CVE-2021-36371": {"epss_score": 0.001, "epss_percentile": 0.28465}, "CVE-2021-36372": {"epss_score": 0.00628, "epss_percentile": 0.69662}, "CVE-2021-36373": {"epss_score": 0.00113, "epss_percentile": 0.30619}, "CVE-2021-36374": {"epss_score": 0.00153, "epss_percentile": 0.36585}, "CVE-2021-36376": {"epss_score": 0.0008, "epss_percentile": 0.24124}, "CVE-2021-36377": {"epss_score": 0.00105, "epss_percentile": 0.29335}, "CVE-2021-36380": {"epss_score": 0.93643, "epss_percentile": 0.99829}, "CVE-2021-36381": {"epss_score": 0.00664, "epss_percentile": 0.70642}, "CVE-2021-36382": {"epss_score": 0.00131, "epss_percentile": 0.33393}, "CVE-2021-36383": {"epss_score": 0.0015, "epss_percentile": 0.36136}, "CVE-2021-36385": {"epss_score": 0.03461, "epss_percentile": 0.87181}, "CVE-2021-36386": {"epss_score": 0.0026, "epss_percentile": 0.49179}, "CVE-2021-36387": {"epss_score": 0.03085, "epss_percentile": 0.86383}, "CVE-2021-36388": {"epss_score": 0.01606, "epss_percentile": 0.81303}, "CVE-2021-36389": {"epss_score": 0.03015, "epss_percentile": 0.86211}, "CVE-2021-36392": {"epss_score": 0.00525, "epss_percentile": 0.66376}, "CVE-2021-36393": {"epss_score": 0.26765, "epss_percentile": 0.96176}, "CVE-2021-36394": {"epss_score": 0.20861, "epss_percentile": 0.95429}, "CVE-2021-36395": {"epss_score": 0.00237, "epss_percentile": 0.46711}, "CVE-2021-36396": {"epss_score": 0.00815, "epss_percentile": 0.73793}, "CVE-2021-36397": {"epss_score": 0.00573, "epss_percentile": 0.68065}, "CVE-2021-36398": {"epss_score": 0.00908, "epss_percentile": 0.75288}, "CVE-2021-36399": {"epss_score": 0.00836, "epss_percentile": 0.74128}, "CVE-2021-36400": {"epss_score": 0.00237, "epss_percentile": 0.46722}, "CVE-2021-36401": {"epss_score": 0.00149, "epss_percentile": 0.36018}, "CVE-2021-36402": {"epss_score": 0.00293, "epss_percentile": 0.52328}, "CVE-2021-36403": {"epss_score": 0.00251, "epss_percentile": 0.4832}, "CVE-2021-36408": {"epss_score": 0.00103, "epss_percentile": 0.29004}, "CVE-2021-36409": {"epss_score": 0.00161, "epss_percentile": 0.37569}, "CVE-2021-36410": {"epss_score": 0.00088, "epss_percentile": 0.25719}, "CVE-2021-36411": {"epss_score": 0.00156, "epss_percentile": 0.36972}, "CVE-2021-36412": {"epss_score": 0.00155, "epss_percentile": 0.36814}, "CVE-2021-36414": {"epss_score": 0.00214, "epss_percentile": 0.43989}, "CVE-2021-36417": {"epss_score": 0.00214, "epss_percentile": 0.43989}, "CVE-2021-36424": {"epss_score": 0.00373, "epss_percentile": 0.58514}, "CVE-2021-36425": {"epss_score": 0.00394, "epss_percentile": 0.59784}, "CVE-2021-36426": {"epss_score": 0.00373, "epss_percentile": 0.58527}, "CVE-2021-36431": {"epss_score": 0.00058, "epss_percentile": 0.18377}, "CVE-2021-36432": {"epss_score": 0.00066, "epss_percentile": 0.20683}, "CVE-2021-36433": {"epss_score": 0.00058, "epss_percentile": 0.18377}, "CVE-2021-36434": {"epss_score": 0.00058, "epss_percentile": 0.18377}, "CVE-2021-36436": {"epss_score": 0.00065, "epss_percentile": 0.20627}, "CVE-2021-36440": {"epss_score": 0.36807, "epss_percentile": 0.97002}, "CVE-2021-36443": {"epss_score": 0.00316, "epss_percentile": 0.54272}, "CVE-2021-36444": {"epss_score": 0.00316, "epss_percentile": 0.54272}, "CVE-2021-36450": {"epss_score": 0.20063, "epss_percentile": 0.95283}, "CVE-2021-36454": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-36455": {"epss_score": 0.00447, "epss_percentile": 0.62986}, "CVE-2021-36460": {"epss_score": 0.00125, "epss_percentile": 0.32494}, "CVE-2021-36461": {"epss_score": 0.00354, "epss_percentile": 0.57234}, "CVE-2021-36471": {"epss_score": 0.01401, "epss_percentile": 0.80007}, "CVE-2021-36483": {"epss_score": 0.0195, "epss_percentile": 0.83014}, "CVE-2021-36484": {"epss_score": 0.00063, "epss_percentile": 0.19812}, "CVE-2021-36489": {"epss_score": 0.00065, "epss_percentile": 0.20669}, "CVE-2021-36493": {"epss_score": 0.00228, "epss_percentile": 0.45519}, "CVE-2021-36503": {"epss_score": 0.00258, "epss_percentile": 0.49023}, "CVE-2021-36512": {"epss_score": 0.00364, "epss_percentile": 0.57948}, "CVE-2021-36513": {"epss_score": 0.00477, "epss_percentile": 0.6435}, "CVE-2021-36520": {"epss_score": 0.00105, "epss_percentile": 0.29386}, "CVE-2021-36530": {"epss_score": 0.00352, "epss_percentile": 0.57112}, "CVE-2021-36531": {"epss_score": 0.00352, "epss_percentile": 0.57112}, "CVE-2021-36532": {"epss_score": 0.00338, "epss_percentile": 0.56157}, "CVE-2021-36535": {"epss_score": 0.00125, "epss_percentile": 0.32613}, "CVE-2021-36538": {"epss_score": 0.00053, "epss_percentile": 0.16794}, "CVE-2021-36539": {"epss_score": 0.00274, "epss_percentile": 0.50546}, "CVE-2021-36542": {"epss_score": 0.00102, "epss_percentile": 0.28813}, "CVE-2021-36543": {"epss_score": 0.00108, "epss_percentile": 0.29881}, "CVE-2021-36544": {"epss_score": 0.00111, "epss_percentile": 0.30312}, "CVE-2021-36545": {"epss_score": 0.00053, "epss_percentile": 0.16794}, "CVE-2021-36546": {"epss_score": 0.00103, "epss_percentile": 0.29051}, "CVE-2021-36547": {"epss_score": 0.22363, "epss_percentile": 0.95625}, "CVE-2021-36548": {"epss_score": 0.17751, "epss_percentile": 0.94898}, "CVE-2021-36550": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-36551": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-36560": {"epss_score": 0.00117, "epss_percentile": 0.31218}, "CVE-2021-36563": {"epss_score": 0.07986, "epss_percentile": 0.91805}, "CVE-2021-36564": {"epss_score": 0.01097, "epss_percentile": 0.77526}, "CVE-2021-36567": {"epss_score": 0.03362, "epss_percentile": 0.86994}, "CVE-2021-36568": {"epss_score": 0.00407, "epss_percentile": 0.60619}, "CVE-2021-36569": {"epss_score": 0.00288, "epss_percentile": 0.51934}, "CVE-2021-36570": {"epss_score": 0.00285, "epss_percentile": 0.51526}, "CVE-2021-36572": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2021-36573": {"epss_score": 0.00214, "epss_percentile": 0.43993}, "CVE-2021-36580": {"epss_score": 0.096, "epss_percentile": 0.92616}, "CVE-2021-36581": {"epss_score": 0.00537, "epss_percentile": 0.66903}, "CVE-2021-36582": {"epss_score": 0.0058, "epss_percentile": 0.68259}, "CVE-2021-36584": {"epss_score": 0.00111, "epss_percentile": 0.30356}, "CVE-2021-36601": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2021-36603": {"epss_score": 0.00092, "epss_percentile": 0.26498}, "CVE-2021-36605": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2021-36608": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-36609": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-36613": {"epss_score": 0.00906, "epss_percentile": 0.75259}, "CVE-2021-36614": {"epss_score": 0.00906, "epss_percentile": 0.75259}, "CVE-2021-36621": {"epss_score": 0.0131, "epss_percentile": 0.79363}, "CVE-2021-36622": {"epss_score": 0.00412, "epss_percentile": 0.60924}, "CVE-2021-36623": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-36624": {"epss_score": 0.00154, "epss_percentile": 0.3666}, "CVE-2021-36625": {"epss_score": 0.00279, "epss_percentile": 0.50983}, "CVE-2021-36630": {"epss_score": 0.16132, "epss_percentile": 0.94577}, "CVE-2021-36631": {"epss_score": 0.00071, "epss_percentile": 0.22121}, "CVE-2021-36646": {"epss_score": 0.01158, "epss_percentile": 0.78119}, "CVE-2021-36647": {"epss_score": 0.00036, "epss_percentile": 0.10255}, "CVE-2021-36654": {"epss_score": 0.02602, "epss_percentile": 0.8521}, "CVE-2021-36665": {"epss_score": 0.00173, "epss_percentile": 0.39064}, "CVE-2021-36666": {"epss_score": 0.00051, "epss_percentile": 0.16039}, "CVE-2021-36667": {"epss_score": 0.01071, "epss_percentile": 0.77261}, "CVE-2021-36668": {"epss_score": 0.0022, "epss_percentile": 0.44601}, "CVE-2021-36686": {"epss_score": 0.00369, "epss_percentile": 0.58272}, "CVE-2021-36689": {"epss_score": 0.00036, "epss_percentile": 0.10269}, "CVE-2021-36690": {"epss_score": 0.00974, "epss_percentile": 0.76175}, "CVE-2021-36691": {"epss_score": 0.00303, "epss_percentile": 0.53181}, "CVE-2021-36692": {"epss_score": 0.00312, "epss_percentile": 0.54003}, "CVE-2021-36695": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-36696": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-36697": {"epss_score": 0.00177, "epss_percentile": 0.39597}, "CVE-2021-36698": {"epss_score": 0.00379, "epss_percentile": 0.58905}, "CVE-2021-36701": {"epss_score": 0.00872, "epss_percentile": 0.74734}, "CVE-2021-36702": {"epss_score": 0.00196, "epss_percentile": 0.41772}, "CVE-2021-36703": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2021-36705": {"epss_score": 0.11787, "epss_percentile": 0.93476}, "CVE-2021-36706": {"epss_score": 0.11787, "epss_percentile": 0.93476}, "CVE-2021-36707": {"epss_score": 0.11787, "epss_percentile": 0.93476}, "CVE-2021-36708": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2021-36710": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2021-36711": {"epss_score": 0.49539, "epss_percentile": 0.97693}, "CVE-2021-36712": {"epss_score": 0.0009, "epss_percentile": 0.26074}, "CVE-2021-36713": {"epss_score": 0.00153, "epss_percentile": 0.36605}, "CVE-2021-36716": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2021-36717": {"epss_score": 0.0025, "epss_percentile": 0.48123}, "CVE-2021-36718": {"epss_score": 0.00182, "epss_percentile": 0.40141}, "CVE-2021-36719": {"epss_score": 0.00397, "epss_percentile": 0.60021}, "CVE-2021-36720": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-36721": {"epss_score": 0.0015, "epss_percentile": 0.36068}, "CVE-2021-36722": {"epss_score": 0.00192, "epss_percentile": 0.41284}, "CVE-2021-36723": {"epss_score": 0.0021, "epss_percentile": 0.43464}, "CVE-2021-36724": {"epss_score": 0.00036, "epss_percentile": 0.10382}, "CVE-2021-36737": {"epss_score": 0.15929, "epss_percentile": 0.94538}, "CVE-2021-36738": {"epss_score": 0.15929, "epss_percentile": 0.94538}, "CVE-2021-36739": {"epss_score": 0.15929, "epss_percentile": 0.94538}, "CVE-2021-36740": {"epss_score": 0.00708, "epss_percentile": 0.71678}, "CVE-2021-36741": {"epss_score": 0.00582, "epss_percentile": 0.68323}, "CVE-2021-36742": {"epss_score": 0.01869, "epss_percentile": 0.82624}, "CVE-2021-36744": {"epss_score": 0.00228, "epss_percentile": 0.45535}, "CVE-2021-36745": {"epss_score": 0.18719, "epss_percentile": 0.95058}, "CVE-2021-36746": {"epss_score": 0.00378, "epss_percentile": 0.58829}, "CVE-2021-36747": {"epss_score": 0.00368, "epss_percentile": 0.58181}, "CVE-2021-36748": {"epss_score": 0.83038, "epss_percentile": 0.99228}, "CVE-2021-36749": {"epss_score": 0.93841, "epss_percentile": 0.99855}, "CVE-2021-36750": {"epss_score": 0.19701, "epss_percentile": 0.95228}, "CVE-2021-36751": {"epss_score": 0.00172, "epss_percentile": 0.39012}, "CVE-2021-36753": {"epss_score": 0.00195, "epss_percentile": 0.4163}, "CVE-2021-36754": {"epss_score": 0.20558, "epss_percentile": 0.95377}, "CVE-2021-36755": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-36756": {"epss_score": 0.00087, "epss_percentile": 0.25565}, "CVE-2021-36758": {"epss_score": 0.00189, "epss_percentile": 0.40982}, "CVE-2021-36760": {"epss_score": 0.00668, "epss_percentile": 0.70731}, "CVE-2021-36761": {"epss_score": 0.00365, "epss_percentile": 0.5799}, "CVE-2021-36762": {"epss_score": 0.00353, "epss_percentile": 0.5714}, "CVE-2021-36763": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-36764": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-36765": {"epss_score": 0.00309, "epss_percentile": 0.53668}, "CVE-2021-36766": {"epss_score": 0.01543, "epss_percentile": 0.80955}, "CVE-2021-36767": {"epss_score": 0.00243, "epss_percentile": 0.47498}, "CVE-2021-36769": {"epss_score": 0.00294, "epss_percentile": 0.52389}, "CVE-2021-36770": {"epss_score": 0.00149, "epss_percentile": 0.35964}, "CVE-2021-36771": {"epss_score": 0.0387, "epss_percentile": 0.8788}, "CVE-2021-36772": {"epss_score": 0.0387, "epss_percentile": 0.8788}, "CVE-2021-36773": {"epss_score": 0.01511, "epss_percentile": 0.80775}, "CVE-2021-36774": {"epss_score": 0.00805, "epss_percentile": 0.73639}, "CVE-2021-36775": {"epss_score": 0.00278, "epss_percentile": 0.50848}, "CVE-2021-36776": {"epss_score": 0.00525, "epss_percentile": 0.66372}, "CVE-2021-36777": {"epss_score": 0.00307, "epss_percentile": 0.53494}, "CVE-2021-36778": {"epss_score": 0.00396, "epss_percentile": 0.59887}, "CVE-2021-36779": {"epss_score": 0.00053, "epss_percentile": 0.17032}, "CVE-2021-36780": {"epss_score": 0.00055, "epss_percentile": 0.1765}, "CVE-2021-36781": {"epss_score": 0.00089, "epss_percentile": 0.25884}, "CVE-2021-36782": {"epss_score": 0.79605, "epss_percentile": 0.99047}, "CVE-2021-36783": {"epss_score": 0.00477, "epss_percentile": 0.6434}, "CVE-2021-36784": {"epss_score": 0.00484, "epss_percentile": 0.64633}, "CVE-2021-36785": {"epss_score": 0.00263, "epss_percentile": 0.49517}, "CVE-2021-36786": {"epss_score": 0.00253, "epss_percentile": 0.48458}, "CVE-2021-36787": {"epss_score": 0.00691, "epss_percentile": 0.71269}, "CVE-2021-36788": {"epss_score": 0.00308, "epss_percentile": 0.5364}, "CVE-2021-36789": {"epss_score": 0.00384, "epss_percentile": 0.5916}, "CVE-2021-36790": {"epss_score": 0.00323, "epss_percentile": 0.54888}, "CVE-2021-36791": {"epss_score": 0.00186, "epss_percentile": 0.40615}, "CVE-2021-36792": {"epss_score": 0.0018, "epss_percentile": 0.39976}, "CVE-2021-36793": {"epss_score": 0.00253, "epss_percentile": 0.48458}, "CVE-2021-36794": {"epss_score": 0.00654, "epss_percentile": 0.70345}, "CVE-2021-36795": {"epss_score": 0.00047, "epss_percentile": 0.14895}, "CVE-2021-36797": {"epss_score": 0.00049, "epss_percentile": 0.15329}, "CVE-2021-36798": {"epss_score": 0.27683, "epss_percentile": 0.96274}, "CVE-2021-36799": {"epss_score": 0.00128, "epss_percentile": 0.3303}, "CVE-2021-36800": {"epss_score": 0.00322, "epss_percentile": 0.5478}, "CVE-2021-36801": {"epss_score": 0.00285, "epss_percentile": 0.51517}, "CVE-2021-36802": {"epss_score": 0.00359, "epss_percentile": 0.57597}, "CVE-2021-36803": {"epss_score": 0.00329, "epss_percentile": 0.55397}, "CVE-2021-36804": {"epss_score": 0.00325, "epss_percentile": 0.54999}, "CVE-2021-36805": {"epss_score": 0.00297, "epss_percentile": 0.52749}, "CVE-2021-36806": {"epss_score": 0.00082, "epss_percentile": 0.24562}, "CVE-2021-36807": {"epss_score": 0.00205, "epss_percentile": 0.42746}, "CVE-2021-36808": {"epss_score": 0.0002, "epss_percentile": 0.04439}, "CVE-2021-36809": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2021-36821": {"epss_score": 0.00088, "epss_percentile": 0.25658}, "CVE-2021-36823": {"epss_score": 0.00208, "epss_percentile": 0.4325}, "CVE-2021-36826": {"epss_score": 0.0022, "epss_percentile": 0.44621}, "CVE-2021-36827": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-36828": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-36829": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2021-36830": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2021-36832": {"epss_score": 0.00176, "epss_percentile": 0.3942}, "CVE-2021-36833": {"epss_score": 0.00332, "epss_percentile": 0.55607}, "CVE-2021-36839": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2021-36841": {"epss_score": 0.00355, "epss_percentile": 0.57316}, "CVE-2021-36843": {"epss_score": 0.00224, "epss_percentile": 0.45014}, "CVE-2021-36844": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-36845": {"epss_score": 0.00419, "epss_percentile": 0.61388}, "CVE-2021-36846": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-36847": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2021-36848": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-36849": {"epss_score": 0.0073, "epss_percentile": 0.72154}, "CVE-2021-36850": {"epss_score": 0.00103, "epss_percentile": 0.28963}, "CVE-2021-36851": {"epss_score": 0.0015, "epss_percentile": 0.36082}, "CVE-2021-36852": {"epss_score": 0.00097, "epss_percentile": 0.27452}, "CVE-2021-36854": {"epss_score": 0.00104, "epss_percentile": 0.29139}, "CVE-2021-36855": {"epss_score": 0.00093, "epss_percentile": 0.2674}, "CVE-2021-36857": {"epss_score": 0.00176, "epss_percentile": 0.39407}, "CVE-2021-36858": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2021-36861": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2021-36863": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2021-36864": {"epss_score": 0.00177, "epss_percentile": 0.39496}, "CVE-2021-36865": {"epss_score": 0.0014, "epss_percentile": 0.3475}, "CVE-2021-36866": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-36867": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-36869": {"epss_score": 0.00218, "epss_percentile": 0.4442}, "CVE-2021-36870": {"epss_score": 0.00204, "epss_percentile": 0.42597}, "CVE-2021-36871": {"epss_score": 0.00443, "epss_percentile": 0.62757}, "CVE-2021-36872": {"epss_score": 0.00223, "epss_percentile": 0.44849}, "CVE-2021-36873": {"epss_score": 0.03985, "epss_percentile": 0.88064}, "CVE-2021-36874": {"epss_score": 0.00747, "epss_percentile": 0.72569}, "CVE-2021-36875": {"epss_score": 0.00259, "epss_percentile": 0.49039}, "CVE-2021-36876": {"epss_score": 0.00107, "epss_percentile": 0.29646}, "CVE-2021-36877": {"epss_score": 0.00103, "epss_percentile": 0.28963}, "CVE-2021-36878": {"epss_score": 0.00103, "epss_percentile": 0.28963}, "CVE-2021-36879": {"epss_score": 0.00395, "epss_percentile": 0.59845}, "CVE-2021-36880": {"epss_score": 0.03562, "epss_percentile": 0.87355}, "CVE-2021-36884": {"epss_score": 0.00215, "epss_percentile": 0.44082}, "CVE-2021-36885": {"epss_score": 0.0031, "epss_percentile": 0.53804}, "CVE-2021-36886": {"epss_score": 0.00112, "epss_percentile": 0.3052}, "CVE-2021-36887": {"epss_score": 0.0011, "epss_percentile": 0.30201}, "CVE-2021-36888": {"epss_score": 0.7332, "epss_percentile": 0.98747}, "CVE-2021-36889": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-36890": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-36891": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2021-36893": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-36895": {"epss_score": 0.0031, "epss_percentile": 0.53804}, "CVE-2021-36896": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-36898": {"epss_score": 0.00537, "epss_percentile": 0.66899}, "CVE-2021-36899": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2021-36901": {"epss_score": 0.00293, "epss_percentile": 0.52337}, "CVE-2021-36905": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2021-36906": {"epss_score": 0.00419, "epss_percentile": 0.61378}, "CVE-2021-36908": {"epss_score": 0.00148, "epss_percentile": 0.35833}, "CVE-2021-36909": {"epss_score": 0.01206, "epss_percentile": 0.78517}, "CVE-2021-36910": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-36911": {"epss_score": 0.00176, "epss_percentile": 0.3942}, "CVE-2021-36912": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2021-36913": {"epss_score": 0.00516, "epss_percentile": 0.6605}, "CVE-2021-36914": {"epss_score": 0.00162, "epss_percentile": 0.37625}, "CVE-2021-36915": {"epss_score": 0.00329, "epss_percentile": 0.55415}, "CVE-2021-36916": {"epss_score": 0.00614, "epss_percentile": 0.69266}, "CVE-2021-36917": {"epss_score": 0.01236, "epss_percentile": 0.78771}, "CVE-2021-36919": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2021-36920": {"epss_score": 0.00215, "epss_percentile": 0.44082}, "CVE-2021-36921": {"epss_score": 0.005, "epss_percentile": 0.65301}, "CVE-2021-36922": {"epss_score": 0.00028, "epss_percentile": 0.07532}, "CVE-2021-36923": {"epss_score": 0.00028, "epss_percentile": 0.07532}, "CVE-2021-36924": {"epss_score": 0.00028, "epss_percentile": 0.07215}, "CVE-2021-36925": {"epss_score": 0.00035, "epss_percentile": 0.10156}, "CVE-2021-36926": {"epss_score": 0.14576, "epss_percentile": 0.94244}, "CVE-2021-36927": {"epss_score": 0.00225, "epss_percentile": 0.45125}, "CVE-2021-36928": {"epss_score": 0.01312, "epss_percentile": 0.79378}, "CVE-2021-36929": {"epss_score": 0.02325, "epss_percentile": 0.84388}, "CVE-2021-36930": {"epss_score": 0.00541, "epss_percentile": 0.67043}, "CVE-2021-36931": {"epss_score": 0.00453, "epss_percentile": 0.63209}, "CVE-2021-36932": {"epss_score": 0.19424, "epss_percentile": 0.9518}, "CVE-2021-36933": {"epss_score": 0.14576, "epss_percentile": 0.94244}, "CVE-2021-36934": {"epss_score": 0.90897, "epss_percentile": 0.99608}, "CVE-2021-36936": {"epss_score": 0.07797, "epss_percentile": 0.91687}, "CVE-2021-36937": {"epss_score": 0.01106, "epss_percentile": 0.77619}, "CVE-2021-36938": {"epss_score": 0.00285, "epss_percentile": 0.51532}, "CVE-2021-36940": {"epss_score": 0.01312, "epss_percentile": 0.79377}, "CVE-2021-36941": {"epss_score": 0.05015, "epss_percentile": 0.89395}, "CVE-2021-36942": {"epss_score": 0.93551, "epss_percentile": 0.99817}, "CVE-2021-36943": {"epss_score": 0.00289, "epss_percentile": 0.51981}, "CVE-2021-36945": {"epss_score": 0.01878, "epss_percentile": 0.82669}, "CVE-2021-36946": {"epss_score": 0.01017, "epss_percentile": 0.76697}, "CVE-2021-36947": {"epss_score": 0.09232, "epss_percentile": 0.92458}, "CVE-2021-36948": {"epss_score": 0.00971, "epss_percentile": 0.76121}, "CVE-2021-36949": {"epss_score": 0.0079, "epss_percentile": 0.7337}, "CVE-2021-36950": {"epss_score": 0.00999, "epss_percentile": 0.76481}, "CVE-2021-36952": {"epss_score": 0.20115, "epss_percentile": 0.95289}, "CVE-2021-36953": {"epss_score": 0.10915, "epss_percentile": 0.93156}, "CVE-2021-36954": {"epss_score": 0.00183, "epss_percentile": 0.40327}, "CVE-2021-36955": {"epss_score": 0.26462, "epss_percentile": 0.96149}, "CVE-2021-36956": {"epss_score": 0.00384, "epss_percentile": 0.59181}, "CVE-2021-36957": {"epss_score": 0.00318, "epss_percentile": 0.5441}, "CVE-2021-36958": {"epss_score": 0.04919, "epss_percentile": 0.8929}, "CVE-2021-36959": {"epss_score": 0.01877, "epss_percentile": 0.82665}, "CVE-2021-36960": {"epss_score": 0.15405, "epss_percentile": 0.94425}, "CVE-2021-36961": {"epss_score": 0.00227, "epss_percentile": 0.45454}, "CVE-2021-36962": {"epss_score": 0.00391, "epss_percentile": 0.59623}, "CVE-2021-36963": {"epss_score": 0.0043, "epss_percentile": 0.62035}, "CVE-2021-36964": {"epss_score": 0.00234, "epss_percentile": 0.46105}, "CVE-2021-36965": {"epss_score": 0.02204, "epss_percentile": 0.83997}, "CVE-2021-36966": {"epss_score": 0.00183, "epss_percentile": 0.40327}, "CVE-2021-36967": {"epss_score": 0.01467, "epss_percentile": 0.80474}, "CVE-2021-36968": {"epss_score": 0.00318, "epss_percentile": 0.54409}, "CVE-2021-36969": {"epss_score": 0.00427, "epss_percentile": 0.61782}, "CVE-2021-36970": {"epss_score": 0.14902, "epss_percentile": 0.94318}, "CVE-2021-36972": {"epss_score": 0.00347, "epss_percentile": 0.5678}, "CVE-2021-36973": {"epss_score": 0.00249, "epss_percentile": 0.48029}, "CVE-2021-36974": {"epss_score": 0.0016, "epss_percentile": 0.37429}, "CVE-2021-36975": {"epss_score": 0.00397, "epss_percentile": 0.60028}, "CVE-2021-36976": {"epss_score": 0.00192, "epss_percentile": 0.41353}, "CVE-2021-36977": {"epss_score": 0.00116, "epss_percentile": 0.31069}, "CVE-2021-36978": {"epss_score": 0.00079, "epss_percentile": 0.23893}, "CVE-2021-36979": {"epss_score": 0.00205, "epss_percentile": 0.42674}, "CVE-2021-36980": {"epss_score": 0.00104, "epss_percentile": 0.29175}, "CVE-2021-36981": {"epss_score": 0.09579, "epss_percentile": 0.92607}, "CVE-2021-36982": {"epss_score": 0.00985, "epss_percentile": 0.76321}, "CVE-2021-36983": {"epss_score": 0.00032, "epss_percentile": 0.09002}, "CVE-2021-36985": {"epss_score": 0.00195, "epss_percentile": 0.41626}, "CVE-2021-36986": {"epss_score": 0.00208, "epss_percentile": 0.43219}, "CVE-2021-36987": {"epss_score": 0.00133, "epss_percentile": 0.33662}, "CVE-2021-36988": {"epss_score": 0.00113, "epss_percentile": 0.30629}, "CVE-2021-36989": {"epss_score": 0.00168, "epss_percentile": 0.3846}, "CVE-2021-36990": {"epss_score": 0.00168, "epss_percentile": 0.3846}, "CVE-2021-36991": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-36992": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-36993": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-36994": {"epss_score": 0.00087, "epss_percentile": 0.25594}, "CVE-2021-36995": {"epss_score": 0.00113, "epss_percentile": 0.30629}, "CVE-2021-36996": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2021-36997": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2021-36998": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2021-36999": {"epss_score": 0.00517, "epss_percentile": 0.66063}, "CVE-2021-37000": {"epss_score": 0.00021, "epss_percentile": 0.04818}, "CVE-2021-37001": {"epss_score": 0.00113, "epss_percentile": 0.30629}, "CVE-2021-37002": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-37003": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37004": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37005": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37006": {"epss_score": 0.00114, "epss_percentile": 0.30748}, "CVE-2021-37007": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37008": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37009": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-37010": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-37011": {"epss_score": 0.00258, "epss_percentile": 0.49012}, "CVE-2021-37012": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37013": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2021-37014": {"epss_score": 0.00196, "epss_percentile": 0.4178}, "CVE-2021-37015": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37016": {"epss_score": 0.00193, "epss_percentile": 0.41388}, "CVE-2021-37017": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37018": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37019": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37020": {"epss_score": 0.00254, "epss_percentile": 0.48568}, "CVE-2021-37021": {"epss_score": 0.00254, "epss_percentile": 0.48568}, "CVE-2021-37022": {"epss_score": 0.00223, "epss_percentile": 0.44943}, "CVE-2021-37023": {"epss_score": 0.00151, "epss_percentile": 0.36289}, "CVE-2021-37024": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37025": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37026": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37027": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2021-37028": {"epss_score": 0.00108, "epss_percentile": 0.29833}, "CVE-2021-37029": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2021-37030": {"epss_score": 0.00155, "epss_percentile": 0.36862}, "CVE-2021-37031": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37032": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2021-37033": {"epss_score": 0.00206, "epss_percentile": 0.4304}, "CVE-2021-37034": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-37035": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37036": {"epss_score": 0.00028, "epss_percentile": 0.07471}, "CVE-2021-37037": {"epss_score": 0.00149, "epss_percentile": 0.36022}, "CVE-2021-37038": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-37039": {"epss_score": 0.00052, "epss_percentile": 0.16618}, "CVE-2021-37040": {"epss_score": 0.00253, "epss_percentile": 0.48416}, "CVE-2021-37041": {"epss_score": 0.00205, "epss_percentile": 0.42716}, "CVE-2021-37042": {"epss_score": 0.00205, "epss_percentile": 0.42716}, "CVE-2021-37043": {"epss_score": 0.00168, "epss_percentile": 0.38434}, "CVE-2021-37044": {"epss_score": 0.00163, "epss_percentile": 0.37817}, "CVE-2021-37045": {"epss_score": 0.0018, "epss_percentile": 0.39907}, "CVE-2021-37046": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37047": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37048": {"epss_score": 0.00113, "epss_percentile": 0.30629}, "CVE-2021-37049": {"epss_score": 0.00267, "epss_percentile": 0.49967}, "CVE-2021-37050": {"epss_score": 0.00033, "epss_percentile": 0.09296}, "CVE-2021-37051": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2021-37052": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-37053": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2021-37054": {"epss_score": 0.0013, "epss_percentile": 0.3325}, "CVE-2021-37055": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2021-37056": {"epss_score": 0.00082, "epss_percentile": 0.24581}, "CVE-2021-37057": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37058": {"epss_score": 0.00099, "epss_percentile": 0.28401}, "CVE-2021-37059": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-37060": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-37061": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37062": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-37063": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-37064": {"epss_score": 0.0024, "epss_percentile": 0.47212}, "CVE-2021-37065": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-37066": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37067": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-37068": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37069": {"epss_score": 0.00172, "epss_percentile": 0.3901}, "CVE-2021-37070": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37071": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37072": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37073": {"epss_score": 0.00087, "epss_percentile": 0.25594}, "CVE-2021-37074": {"epss_score": 0.00139, "epss_percentile": 0.34641}, "CVE-2021-37075": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-37076": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37077": {"epss_score": 0.00172, "epss_percentile": 0.38995}, "CVE-2021-37078": {"epss_score": 0.00277, "epss_percentile": 0.50809}, "CVE-2021-37079": {"epss_score": 0.00206, "epss_percentile": 0.4304}, "CVE-2021-37080": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37081": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37082": {"epss_score": 0.00141, "epss_percentile": 0.34816}, "CVE-2021-37083": {"epss_score": 0.00182, "epss_percentile": 0.40254}, "CVE-2021-37084": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-37085": {"epss_score": 0.00133, "epss_percentile": 0.33662}, "CVE-2021-37086": {"epss_score": 0.00114, "epss_percentile": 0.30748}, "CVE-2021-37087": {"epss_score": 0.0024, "epss_percentile": 0.47212}, "CVE-2021-37088": {"epss_score": 0.0024, "epss_percentile": 0.47212}, "CVE-2021-37089": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-37090": {"epss_score": 0.00156, "epss_percentile": 0.36991}, "CVE-2021-37091": {"epss_score": 0.00133, "epss_percentile": 0.33656}, "CVE-2021-37092": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2021-37093": {"epss_score": 0.00096, "epss_percentile": 0.27403}, "CVE-2021-37094": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37095": {"epss_score": 0.00934, "epss_percentile": 0.75645}, "CVE-2021-37096": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-37097": {"epss_score": 0.00169, "epss_percentile": 0.38633}, "CVE-2021-37098": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37099": {"epss_score": 0.00227, "epss_percentile": 0.45362}, "CVE-2021-37100": {"epss_score": 0.00129, "epss_percentile": 0.33117}, "CVE-2021-37101": {"epss_score": 0.00023, "epss_percentile": 0.05466}, "CVE-2021-37102": {"epss_score": 0.00643, "epss_percentile": 0.7005}, "CVE-2021-37103": {"epss_score": 0.00024, "epss_percentile": 0.05889}, "CVE-2021-37104": {"epss_score": 0.00129, "epss_percentile": 0.33131}, "CVE-2021-37105": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37106": {"epss_score": 0.00417, "epss_percentile": 0.61252}, "CVE-2021-37107": {"epss_score": 0.00028, "epss_percentile": 0.07471}, "CVE-2021-37109": {"epss_score": 0.00027, "epss_percentile": 0.06914}, "CVE-2021-37110": {"epss_score": 0.00155, "epss_percentile": 0.36763}, "CVE-2021-37111": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2021-37112": {"epss_score": 0.00113, "epss_percentile": 0.30629}, "CVE-2021-37113": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-37114": {"epss_score": 0.00096, "epss_percentile": 0.27403}, "CVE-2021-37115": {"epss_score": 0.00028, "epss_percentile": 0.07471}, "CVE-2021-37116": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-37117": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2021-37118": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2021-37119": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2021-37120": {"epss_score": 0.00207, "epss_percentile": 0.43126}, "CVE-2021-37121": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-37122": {"epss_score": 0.00059, "epss_percentile": 0.18647}, "CVE-2021-37123": {"epss_score": 0.00183, "epss_percentile": 0.40331}, "CVE-2021-37124": {"epss_score": 0.00045, "epss_percentile": 0.13782}, "CVE-2021-37125": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-37126": {"epss_score": 0.002, "epss_percentile": 0.42227}, "CVE-2021-37127": {"epss_score": 0.00101, "epss_percentile": 0.28646}, "CVE-2021-37128": {"epss_score": 0.00343, "epss_percentile": 0.56464}, "CVE-2021-37129": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-37130": {"epss_score": 0.00208, "epss_percentile": 0.4327}, "CVE-2021-37131": {"epss_score": 0.0025, "epss_percentile": 0.48091}, "CVE-2021-37132": {"epss_score": 0.00084, "epss_percentile": 0.24826}, "CVE-2021-37133": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-37134": {"epss_score": 0.00161, "epss_percentile": 0.37531}, "CVE-2021-37136": {"epss_score": 0.01021, "epss_percentile": 0.76744}, "CVE-2021-37137": {"epss_score": 0.02383, "epss_percentile": 0.8457}, "CVE-2021-37144": {"epss_score": 0.00289, "epss_percentile": 0.5205}, "CVE-2021-37145": {"epss_score": 0.03148, "epss_percentile": 0.86499}, "CVE-2021-37146": {"epss_score": 0.01283, "epss_percentile": 0.79157}, "CVE-2021-37147": {"epss_score": 0.00656, "epss_percentile": 0.70454}, "CVE-2021-37148": {"epss_score": 0.0062, "epss_percentile": 0.69444}, "CVE-2021-37149": {"epss_score": 0.0062, "epss_percentile": 0.69444}, "CVE-2021-37150": {"epss_score": 0.00257, "epss_percentile": 0.48921}, "CVE-2021-37151": {"epss_score": 0.00226, "epss_percentile": 0.45275}, "CVE-2021-37152": {"epss_score": 0.03215, "epss_percentile": 0.86661}, "CVE-2021-37153": {"epss_score": 0.00626, "epss_percentile": 0.6961}, "CVE-2021-37154": {"epss_score": 0.00534, "epss_percentile": 0.668}, "CVE-2021-37155": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2021-37156": {"epss_score": 0.00248, "epss_percentile": 0.47932}, "CVE-2021-37157": {"epss_score": 0.00263, "epss_percentile": 0.49548}, "CVE-2021-37158": {"epss_score": 0.00576, "epss_percentile": 0.68134}, "CVE-2021-37159": {"epss_score": 0.00033, "epss_percentile": 0.09307}, "CVE-2021-37160": {"epss_score": 0.02029, "epss_percentile": 0.8333}, "CVE-2021-37161": {"epss_score": 0.07565, "epss_percentile": 0.91544}, "CVE-2021-37162": {"epss_score": 0.07565, "epss_percentile": 0.91544}, "CVE-2021-37163": {"epss_score": 0.00575, "epss_percentile": 0.68119}, "CVE-2021-37164": {"epss_score": 0.00802, "epss_percentile": 0.73583}, "CVE-2021-37165": {"epss_score": 0.04996, "epss_percentile": 0.89373}, "CVE-2021-37166": {"epss_score": 0.00867, "epss_percentile": 0.74654}, "CVE-2021-37167": {"epss_score": 0.00584, "epss_percentile": 0.68359}, "CVE-2021-37172": {"epss_score": 0.00186, "epss_percentile": 0.40626}, "CVE-2021-37173": {"epss_score": 0.0155, "epss_percentile": 0.80987}, "CVE-2021-37174": {"epss_score": 0.00557, "epss_percentile": 0.67541}, "CVE-2021-37175": {"epss_score": 0.00235, "epss_percentile": 0.46233}, "CVE-2021-37176": {"epss_score": 0.00167, "epss_percentile": 0.38367}, "CVE-2021-37177": {"epss_score": 0.00103, "epss_percentile": 0.289}, "CVE-2021-37178": {"epss_score": 0.00218, "epss_percentile": 0.44421}, "CVE-2021-37179": {"epss_score": 0.00533, "epss_percentile": 0.66713}, "CVE-2021-37180": {"epss_score": 0.0038, "epss_percentile": 0.58953}, "CVE-2021-37181": {"epss_score": 0.01102, "epss_percentile": 0.77581}, "CVE-2021-37182": {"epss_score": 0.00346, "epss_percentile": 0.56621}, "CVE-2021-37183": {"epss_score": 0.00127, "epss_percentile": 0.32931}, "CVE-2021-37184": {"epss_score": 0.00517, "epss_percentile": 0.66068}, "CVE-2021-37185": {"epss_score": 0.00702, "epss_percentile": 0.71521}, "CVE-2021-37186": {"epss_score": 0.00165, "epss_percentile": 0.38036}, "CVE-2021-37187": {"epss_score": 0.00306, "epss_percentile": 0.53398}, "CVE-2021-37188": {"epss_score": 0.00255, "epss_percentile": 0.48702}, "CVE-2021-37189": {"epss_score": 0.00187, "epss_percentile": 0.40713}, "CVE-2021-37190": {"epss_score": 0.00075, "epss_percentile": 0.22972}, "CVE-2021-37191": {"epss_score": 0.00101, "epss_percentile": 0.28588}, "CVE-2021-37192": {"epss_score": 0.00075, "epss_percentile": 0.22972}, "CVE-2021-37193": {"epss_score": 0.00103, "epss_percentile": 0.289}, "CVE-2021-37194": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2021-37195": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2021-37196": {"epss_score": 0.00338, "epss_percentile": 0.56127}, "CVE-2021-37197": {"epss_score": 0.00724, "epss_percentile": 0.72036}, "CVE-2021-37198": {"epss_score": 0.00142, "epss_percentile": 0.34977}, "CVE-2021-37199": {"epss_score": 0.00145, "epss_percentile": 0.35412}, "CVE-2021-37200": {"epss_score": 0.02255, "epss_percentile": 0.84167}, "CVE-2021-37201": {"epss_score": 0.00142, "epss_percentile": 0.35008}, "CVE-2021-37202": {"epss_score": 0.00448, "epss_percentile": 0.63014}, "CVE-2021-37203": {"epss_score": 0.00189, "epss_percentile": 0.40946}, "CVE-2021-37204": {"epss_score": 0.00702, "epss_percentile": 0.71521}, "CVE-2021-37205": {"epss_score": 0.01138, "epss_percentile": 0.77928}, "CVE-2021-37206": {"epss_score": 0.00576, "epss_percentile": 0.68126}, "CVE-2021-37207": {"epss_score": 0.00034, "epss_percentile": 0.09558}, "CVE-2021-37208": {"epss_score": 0.00579, "epss_percentile": 0.68209}, "CVE-2021-37209": {"epss_score": 0.00091, "epss_percentile": 0.26254}, "CVE-2021-37211": {"epss_score": 0.00155, "epss_percentile": 0.36768}, "CVE-2021-37212": {"epss_score": 0.00108, "epss_percentile": 0.29815}, "CVE-2021-37213": {"epss_score": 0.00111, "epss_percentile": 0.30349}, "CVE-2021-37214": {"epss_score": 0.00566, "epss_percentile": 0.67833}, "CVE-2021-37215": {"epss_score": 0.00113, "epss_percentile": 0.30733}, "CVE-2021-37216": {"epss_score": 0.04668, "epss_percentile": 0.88982}, "CVE-2021-37218": {"epss_score": 0.00166, "epss_percentile": 0.38199}, "CVE-2021-37219": {"epss_score": 0.00655, "epss_percentile": 0.70411}, "CVE-2021-37220": {"epss_score": 0.00246, "epss_percentile": 0.4778}, "CVE-2021-37221": {"epss_score": 0.00402, "epss_percentile": 0.60294}, "CVE-2021-37222": {"epss_score": 0.0088, "epss_percentile": 0.74852}, "CVE-2021-37223": {"epss_score": 0.00667, "epss_percentile": 0.70703}, "CVE-2021-37231": {"epss_score": 0.00343, "epss_percentile": 0.56437}, "CVE-2021-37232": {"epss_score": 0.0059, "epss_percentile": 0.68565}, "CVE-2021-37234": {"epss_score": 0.00066, "epss_percentile": 0.20946}, "CVE-2021-37253": {"epss_score": 0.03122, "epss_percentile": 0.86451}, "CVE-2021-37254": {"epss_score": 0.00321, "epss_percentile": 0.54644}, "CVE-2021-37262": {"epss_score": 0.00368, "epss_percentile": 0.58188}, "CVE-2021-37267": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-37270": {"epss_score": 0.00263, "epss_percentile": 0.49487}, "CVE-2021-37271": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-37273": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2021-37274": {"epss_score": 0.00332, "epss_percentile": 0.55605}, "CVE-2021-37289": {"epss_score": 0.00455, "epss_percentile": 0.63273}, "CVE-2021-37291": {"epss_score": 0.60436, "epss_percentile": 0.98207}, "CVE-2021-37292": {"epss_score": 0.05562, "epss_percentile": 0.89996}, "CVE-2021-37293": {"epss_score": 0.00446, "epss_percentile": 0.62892}, "CVE-2021-37304": {"epss_score": 0.54819, "epss_percentile": 0.97946}, "CVE-2021-37305": {"epss_score": 0.5231, "epss_percentile": 0.97818}, "CVE-2021-37306": {"epss_score": 0.00086, "epss_percentile": 0.2538}, "CVE-2021-37311": {"epss_score": 0.00098, "epss_percentile": 0.27801}, "CVE-2021-37315": {"epss_score": 0.00453, "epss_percentile": 0.63235}, "CVE-2021-37316": {"epss_score": 0.0007, "epss_percentile": 0.21983}, "CVE-2021-37317": {"epss_score": 0.01324, "epss_percentile": 0.79468}, "CVE-2021-37322": {"epss_score": 0.00241, "epss_percentile": 0.47235}, "CVE-2021-37326": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2021-37330": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-37331": {"epss_score": 0.00213, "epss_percentile": 0.43947}, "CVE-2021-37333": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2021-37334": {"epss_score": 0.012, "epss_percentile": 0.78477}, "CVE-2021-37343": {"epss_score": 0.82596, "epss_percentile": 0.99201}, "CVE-2021-37344": {"epss_score": 0.53599, "epss_percentile": 0.97884}, "CVE-2021-37345": {"epss_score": 0.00023, "epss_percentile": 0.05337}, "CVE-2021-37346": {"epss_score": 0.51148, "epss_percentile": 0.97766}, "CVE-2021-37347": {"epss_score": 0.00085, "epss_percentile": 0.25118}, "CVE-2021-37348": {"epss_score": 0.11694, "epss_percentile": 0.93451}, "CVE-2021-37349": {"epss_score": 0.00161, "epss_percentile": 0.37552}, "CVE-2021-37350": {"epss_score": 0.40955, "epss_percentile": 0.97247}, "CVE-2021-37351": {"epss_score": 0.00583, "epss_percentile": 0.68351}, "CVE-2021-37352": {"epss_score": 0.03248, "epss_percentile": 0.86746}, "CVE-2021-37353": {"epss_score": 0.02365, "epss_percentile": 0.84512}, "CVE-2021-37354": {"epss_score": 0.00474, "epss_percentile": 0.64161}, "CVE-2021-37358": {"epss_score": 0.01632, "epss_percentile": 0.81456}, "CVE-2021-37363": {"epss_score": 0.00197, "epss_percentile": 0.41967}, "CVE-2021-37364": {"epss_score": 0.00227, "epss_percentile": 0.45362}, "CVE-2021-37365": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-37366": {"epss_score": 0.00141, "epss_percentile": 0.34896}, "CVE-2021-37367": {"epss_score": 0.00123, "epss_percentile": 0.32295}, "CVE-2021-37371": {"epss_score": 0.01033, "epss_percentile": 0.76868}, "CVE-2021-37372": {"epss_score": 0.0787, "epss_percentile": 0.91735}, "CVE-2021-37373": {"epss_score": 0.00062, "epss_percentile": 0.19769}, "CVE-2021-37374": {"epss_score": 0.00062, "epss_percentile": 0.19769}, "CVE-2021-37375": {"epss_score": 0.00062, "epss_percentile": 0.19769}, "CVE-2021-37376": {"epss_score": 0.0017, "epss_percentile": 0.38664}, "CVE-2021-37377": {"epss_score": 0.00062, "epss_percentile": 0.19769}, "CVE-2021-37378": {"epss_score": 0.00062, "epss_percentile": 0.19769}, "CVE-2021-37379": {"epss_score": 0.00062, "epss_percentile": 0.19769}, "CVE-2021-37381": {"epss_score": 0.00211, "epss_percentile": 0.43674}, "CVE-2021-37384": {"epss_score": 0.01161, "epss_percentile": 0.78146}, "CVE-2021-37386": {"epss_score": 0.00065, "epss_percentile": 0.20453}, "CVE-2021-37388": {"epss_score": 0.03432, "epss_percentile": 0.87126}, "CVE-2021-37389": {"epss_score": 0.00361, "epss_percentile": 0.57728}, "CVE-2021-37390": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2021-37391": {"epss_score": 0.00556, "epss_percentile": 0.67527}, "CVE-2021-37392": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-37393": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-37394": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2021-37400": {"epss_score": 0.00704, "epss_percentile": 0.71571}, "CVE-2021-37401": {"epss_score": 0.00704, "epss_percentile": 0.71571}, "CVE-2021-37402": {"epss_score": 0.00435, "epss_percentile": 0.62333}, "CVE-2021-37403": {"epss_score": 0.00487, "epss_percentile": 0.64807}, "CVE-2021-37404": {"epss_score": 0.01194, "epss_percentile": 0.78424}, "CVE-2021-37409": {"epss_score": 0.00067, "epss_percentile": 0.20984}, "CVE-2021-37412": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-37413": {"epss_score": 0.01705, "epss_percentile": 0.81849}, "CVE-2021-37414": {"epss_score": 0.02223, "epss_percentile": 0.84054}, "CVE-2021-37415": {"epss_score": 0.92323, "epss_percentile": 0.99707}, "CVE-2021-37416": {"epss_score": 0.07004, "epss_percentile": 0.91178}, "CVE-2021-37417": {"epss_score": 0.18575, "epss_percentile": 0.95035}, "CVE-2021-37419": {"epss_score": 0.07708, "epss_percentile": 0.91638}, "CVE-2021-37420": {"epss_score": 0.01124, "epss_percentile": 0.77796}, "CVE-2021-37421": {"epss_score": 0.08906, "epss_percentile": 0.9231}, "CVE-2021-37422": {"epss_score": 0.26431, "epss_percentile": 0.96146}, "CVE-2021-37423": {"epss_score": 0.21242, "epss_percentile": 0.95484}, "CVE-2021-37424": {"epss_score": 0.13636, "epss_percentile": 0.94017}, "CVE-2021-37425": {"epss_score": 0.08684, "epss_percentile": 0.92199}, "CVE-2021-37436": {"epss_score": 0.00092, "epss_percentile": 0.26537}, "CVE-2021-37439": {"epss_score": 0.00382, "epss_percentile": 0.59038}, "CVE-2021-37440": {"epss_score": 0.00228, "epss_percentile": 0.45495}, "CVE-2021-37441": {"epss_score": 0.00496, "epss_percentile": 0.65168}, "CVE-2021-37442": {"epss_score": 0.00344, "epss_percentile": 0.56516}, "CVE-2021-37443": {"epss_score": 0.00445, "epss_percentile": 0.62886}, "CVE-2021-37444": {"epss_score": 0.01158, "epss_percentile": 0.78117}, "CVE-2021-37445": {"epss_score": 0.0122, "epss_percentile": 0.78623}, "CVE-2021-37446": {"epss_score": 0.00394, "epss_percentile": 0.5979}, "CVE-2021-37447": {"epss_score": 0.01466, "epss_percentile": 0.80463}, "CVE-2021-37448": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-37449": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-37450": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-37451": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-37452": {"epss_score": 0.00022, "epss_percentile": 0.05146}, "CVE-2021-37453": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-37454": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-37455": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-37456": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-37457": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-37458": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-37459": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-37460": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-37461": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-37462": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-37463": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-37464": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-37465": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-37466": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-37467": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-37468": {"epss_score": 0.00022, "epss_percentile": 0.05162}, "CVE-2021-37469": {"epss_score": 0.00483, "epss_percentile": 0.64618}, "CVE-2021-37470": {"epss_score": 0.00278, "epss_percentile": 0.50923}, "CVE-2021-37471": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2021-37473": {"epss_score": 0.00679, "epss_percentile": 0.71004}, "CVE-2021-37475": {"epss_score": 0.00679, "epss_percentile": 0.71004}, "CVE-2021-37476": {"epss_score": 0.00679, "epss_percentile": 0.71004}, "CVE-2021-37477": {"epss_score": 0.00679, "epss_percentile": 0.71004}, "CVE-2021-37478": {"epss_score": 0.00679, "epss_percentile": 0.71004}, "CVE-2021-37491": {"epss_score": 0.00156, "epss_percentile": 0.36969}, "CVE-2021-37492": {"epss_score": 0.00108, "epss_percentile": 0.29785}, "CVE-2021-37497": {"epss_score": 0.00577, "epss_percentile": 0.68158}, "CVE-2021-37498": {"epss_score": 0.00173, "epss_percentile": 0.39092}, "CVE-2021-37499": {"epss_score": 0.0018, "epss_percentile": 0.39912}, "CVE-2021-37500": {"epss_score": 0.00217, "epss_percentile": 0.44305}, "CVE-2021-37501": {"epss_score": 0.00071, "epss_percentile": 0.21989}, "CVE-2021-37502": {"epss_score": 0.00053, "epss_percentile": 0.17037}, "CVE-2021-37504": {"epss_score": 0.00717, "epss_percentile": 0.71872}, "CVE-2021-37517": {"epss_score": 0.00356, "epss_percentile": 0.57394}, "CVE-2021-37518": {"epss_score": 0.00071, "epss_percentile": 0.22137}, "CVE-2021-37519": {"epss_score": 0.00022, "epss_percentile": 0.05181}, "CVE-2021-37522": {"epss_score": 0.00227, "epss_percentile": 0.45459}, "CVE-2021-37524": {"epss_score": 0.00948, "epss_percentile": 0.75832}, "CVE-2021-37529": {"epss_score": 0.00248, "epss_percentile": 0.47927}, "CVE-2021-37530": {"epss_score": 0.00248, "epss_percentile": 0.47927}, "CVE-2021-37531": {"epss_score": 0.04234, "epss_percentile": 0.88426}, "CVE-2021-37532": {"epss_score": 0.00243, "epss_percentile": 0.47482}, "CVE-2021-37533": {"epss_score": 0.00214, "epss_percentile": 0.43963}, "CVE-2021-37534": {"epss_score": 0.0023, "epss_percentile": 0.45729}, "CVE-2021-37535": {"epss_score": 0.00337, "epss_percentile": 0.56057}, "CVE-2021-37538": {"epss_score": 0.89404, "epss_percentile": 0.99524}, "CVE-2021-37539": {"epss_score": 0.38217, "epss_percentile": 0.9709}, "CVE-2021-37540": {"epss_score": 3e-05, "epss_percentile": 0.00081}, "CVE-2021-37541": {"epss_score": 3e-05, "epss_percentile": 0.00088}, "CVE-2021-37542": {"epss_score": 7e-05, "epss_percentile": 0.00443}, "CVE-2021-37543": {"epss_score": 0.0001, "epss_percentile": 0.00769}, "CVE-2021-37544": {"epss_score": 0.00015, "epss_percentile": 0.02476}, "CVE-2021-37545": {"epss_score": 4e-05, "epss_percentile": 0.00133}, "CVE-2021-37546": {"epss_score": 3e-05, "epss_percentile": 0.00074}, "CVE-2021-37547": {"epss_score": 4e-05, "epss_percentile": 0.00162}, "CVE-2021-37548": {"epss_score": 3e-05, "epss_percentile": 0.00064}, "CVE-2021-37549": {"epss_score": 3e-05, "epss_percentile": 0.00113}, "CVE-2021-37550": {"epss_score": 3e-05, "epss_percentile": 0.00083}, "CVE-2021-37551": {"epss_score": 2e-05, "epss_percentile": 0.00026}, "CVE-2021-37552": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2021-37553": {"epss_score": 4e-05, "epss_percentile": 0.00155}, "CVE-2021-37554": {"epss_score": 2e-05, "epss_percentile": 0.00051}, "CVE-2021-37555": {"epss_score": 0.00374, "epss_percentile": 0.58547}, "CVE-2021-37556": {"epss_score": 0.34327, "epss_percentile": 0.96842}, "CVE-2021-37557": {"epss_score": 0.34327, "epss_percentile": 0.96842}, "CVE-2021-37558": {"epss_score": 0.02059, "epss_percentile": 0.83436}, "CVE-2021-37560": {"epss_score": 0.00364, "epss_percentile": 0.57932}, "CVE-2021-37561": {"epss_score": 0.00364, "epss_percentile": 0.57932}, "CVE-2021-37562": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2021-37563": {"epss_score": 0.00364, "epss_percentile": 0.57932}, "CVE-2021-37564": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2021-37565": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2021-37566": {"epss_score": 0.00364, "epss_percentile": 0.57932}, "CVE-2021-37567": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2021-37568": {"epss_score": 0.00364, "epss_percentile": 0.57932}, "CVE-2021-37569": {"epss_score": 0.00364, "epss_percentile": 0.57932}, "CVE-2021-37570": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2021-37571": {"epss_score": 0.00364, "epss_percentile": 0.57932}, "CVE-2021-37572": {"epss_score": 0.00519, "epss_percentile": 0.66184}, "CVE-2021-37573": {"epss_score": 0.18516, "epss_percentile": 0.95026}, "CVE-2021-37576": {"epss_score": 0.00014, "epss_percentile": 0.01966}, "CVE-2021-37577": {"epss_score": 0.0004, "epss_percentile": 0.12194}, "CVE-2021-37578": {"epss_score": 0.01581, "epss_percentile": 0.81139}, "CVE-2021-37579": {"epss_score": 0.03832, "epss_percentile": 0.87808}, "CVE-2021-37580": {"epss_score": 0.93993, "epss_percentile": 0.99882}, "CVE-2021-37583": {"epss_score": 0.00549, "epss_percentile": 0.67311}, "CVE-2021-37584": {"epss_score": 0.00549, "epss_percentile": 0.67311}, "CVE-2021-37586": {"epss_score": 0.00258, "epss_percentile": 0.48953}, "CVE-2021-37587": {"epss_score": 0.00181, "epss_percentile": 0.40083}, "CVE-2021-37588": {"epss_score": 0.0027, "epss_percentile": 0.5025}, "CVE-2021-37589": {"epss_score": 0.57122, "epss_percentile": 0.98049}, "CVE-2021-37592": {"epss_score": 0.00135, "epss_percentile": 0.34019}, "CVE-2021-37593": {"epss_score": 0.00699, "epss_percentile": 0.71455}, "CVE-2021-37594": {"epss_score": 0.00418, "epss_percentile": 0.61288}, "CVE-2021-37595": {"epss_score": 0.00418, "epss_percentile": 0.61288}, "CVE-2021-37596": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-37597": {"epss_score": 0.008, "epss_percentile": 0.73541}, "CVE-2021-37598": {"epss_score": 0.00254, "epss_percentile": 0.48566}, "CVE-2021-37599": {"epss_score": 0.08148, "epss_percentile": 0.91903}, "CVE-2021-37600": {"epss_score": 0.00054, "epss_percentile": 0.17328}, "CVE-2021-37601": {"epss_score": 0.00671, "epss_percentile": 0.70797}, "CVE-2021-37604": {"epss_score": 0.00482, "epss_percentile": 0.64542}, "CVE-2021-37605": {"epss_score": 0.00466, "epss_percentile": 0.63786}, "CVE-2021-37606": {"epss_score": 0.00166, "epss_percentile": 0.38241}, "CVE-2021-37608": {"epss_score": 0.04523, "epss_percentile": 0.88803}, "CVE-2021-37613": {"epss_score": 0.00213, "epss_percentile": 0.43901}, "CVE-2021-37614": {"epss_score": 0.00174, "epss_percentile": 0.39169}, "CVE-2021-37615": {"epss_score": 0.00081, "epss_percentile": 0.24365}, "CVE-2021-37616": {"epss_score": 0.00075, "epss_percentile": 0.22954}, "CVE-2021-37617": {"epss_score": 0.00299, "epss_percentile": 0.52874}, "CVE-2021-37618": {"epss_score": 0.00074, "epss_percentile": 0.22853}, "CVE-2021-37619": {"epss_score": 0.00074, "epss_percentile": 0.22853}, "CVE-2021-37620": {"epss_score": 0.00085, "epss_percentile": 0.25169}, "CVE-2021-37621": {"epss_score": 0.00086, "epss_percentile": 0.25329}, "CVE-2021-37622": {"epss_score": 0.00093, "epss_percentile": 0.26726}, "CVE-2021-37623": {"epss_score": 0.00092, "epss_percentile": 0.26588}, "CVE-2021-37624": {"epss_score": 0.01698, "epss_percentile": 0.81821}, "CVE-2021-37625": {"epss_score": 0.00068, "epss_percentile": 0.21335}, "CVE-2021-37626": {"epss_score": 0.00715, "epss_percentile": 0.71851}, "CVE-2021-37627": {"epss_score": 0.00485, "epss_percentile": 0.64728}, "CVE-2021-37628": {"epss_score": 0.00401, "epss_percentile": 0.6026}, "CVE-2021-37629": {"epss_score": 0.00384, "epss_percentile": 0.59148}, "CVE-2021-37630": {"epss_score": 0.00327, "epss_percentile": 0.5513}, "CVE-2021-37631": {"epss_score": 0.00289, "epss_percentile": 0.52074}, "CVE-2021-37632": {"epss_score": 0.01856, "epss_percentile": 0.82569}, "CVE-2021-37633": {"epss_score": 0.00276, "epss_percentile": 0.50721}, "CVE-2021-37634": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2021-37635": {"epss_score": 0.00014, "epss_percentile": 0.01744}, "CVE-2021-37636": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37637": {"epss_score": 0.00012, "epss_percentile": 0.01129}, "CVE-2021-37638": {"epss_score": 0.00013, "epss_percentile": 0.0169}, "CVE-2021-37639": {"epss_score": 0.00014, "epss_percentile": 0.01746}, "CVE-2021-37640": {"epss_score": 0.00033, "epss_percentile": 0.0917}, "CVE-2021-37641": {"epss_score": 0.00013, "epss_percentile": 0.01686}, "CVE-2021-37642": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37643": {"epss_score": 0.00012, "epss_percentile": 0.01129}, "CVE-2021-37644": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37645": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37646": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37647": {"epss_score": 0.00044, "epss_percentile": 0.13637}, "CVE-2021-37648": {"epss_score": 0.00014, "epss_percentile": 0.01852}, "CVE-2021-37649": {"epss_score": 0.00012, "epss_percentile": 0.01129}, "CVE-2021-37650": {"epss_score": 0.00014, "epss_percentile": 0.02049}, "CVE-2021-37651": {"epss_score": 0.00012, "epss_percentile": 0.01131}, "CVE-2021-37652": {"epss_score": 0.00016, "epss_percentile": 0.03023}, "CVE-2021-37653": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37654": {"epss_score": 0.00038, "epss_percentile": 0.11178}, "CVE-2021-37655": {"epss_score": 0.00014, "epss_percentile": 0.01744}, "CVE-2021-37656": {"epss_score": 0.00013, "epss_percentile": 0.01686}, "CVE-2021-37657": {"epss_score": 0.00038, "epss_percentile": 0.11178}, "CVE-2021-37658": {"epss_score": 0.00014, "epss_percentile": 0.01744}, "CVE-2021-37659": {"epss_score": 0.00051, "epss_percentile": 0.16121}, "CVE-2021-37660": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37661": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37662": {"epss_score": 0.00037, "epss_percentile": 0.10979}, "CVE-2021-37663": {"epss_score": 0.00013, "epss_percentile": 0.01686}, "CVE-2021-37664": {"epss_score": 0.00014, "epss_percentile": 0.01744}, "CVE-2021-37665": {"epss_score": 0.00037, "epss_percentile": 0.10979}, "CVE-2021-37666": {"epss_score": 0.00013, "epss_percentile": 0.01686}, "CVE-2021-37667": {"epss_score": 0.00013, "epss_percentile": 0.01686}, "CVE-2021-37668": {"epss_score": 0.00044, "epss_percentile": 0.13631}, "CVE-2021-37669": {"epss_score": 0.00032, "epss_percentile": 0.08865}, "CVE-2021-37670": {"epss_score": 0.0004, "epss_percentile": 0.11988}, "CVE-2021-37671": {"epss_score": 0.00013, "epss_percentile": 0.01686}, "CVE-2021-37672": {"epss_score": 0.00016, "epss_percentile": 0.02723}, "CVE-2021-37673": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37674": {"epss_score": 0.00032, "epss_percentile": 0.08865}, "CVE-2021-37675": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37676": {"epss_score": 0.00013, "epss_percentile": 0.01686}, "CVE-2021-37677": {"epss_score": 9e-05, "epss_percentile": 0.00637}, "CVE-2021-37678": {"epss_score": 0.01023, "epss_percentile": 0.76766}, "CVE-2021-37679": {"epss_score": 0.00042, "epss_percentile": 0.12615}, "CVE-2021-37680": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37681": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2021-37682": {"epss_score": 0.00039, "epss_percentile": 0.11548}, "CVE-2021-37683": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37684": {"epss_score": 8e-05, "epss_percentile": 0.00563}, "CVE-2021-37685": {"epss_score": 0.0004, "epss_percentile": 0.11988}, "CVE-2021-37686": {"epss_score": 0.00012, "epss_percentile": 0.01238}, "CVE-2021-37687": {"epss_score": 0.00044, "epss_percentile": 0.13535}, "CVE-2021-37688": {"epss_score": 0.00013, "epss_percentile": 0.01448}, "CVE-2021-37689": {"epss_score": 0.00048, "epss_percentile": 0.1497}, "CVE-2021-37690": {"epss_score": 0.00024, "epss_percentile": 0.06011}, "CVE-2021-37691": {"epss_score": 0.00012, "epss_percentile": 0.01127}, "CVE-2021-37692": {"epss_score": 0.00032, "epss_percentile": 0.08865}, "CVE-2021-37693": {"epss_score": 0.00322, "epss_percentile": 0.54744}, "CVE-2021-37694": {"epss_score": 0.00206, "epss_percentile": 0.43075}, "CVE-2021-37695": {"epss_score": 0.00476, "epss_percentile": 0.64253}, "CVE-2021-37696": {"epss_score": 0.00218, "epss_percentile": 0.44391}, "CVE-2021-37697": {"epss_score": 0.00218, "epss_percentile": 0.44391}, "CVE-2021-37698": {"epss_score": 0.00138, "epss_percentile": 0.34352}, "CVE-2021-37699": {"epss_score": 0.0043, "epss_percentile": 0.62018}, "CVE-2021-37700": {"epss_score": 0.00672, "epss_percentile": 0.7081}, "CVE-2021-37701": {"epss_score": 0.00025, "epss_percentile": 0.06155}, "CVE-2021-37702": {"epss_score": 0.00036, "epss_percentile": 0.10293}, "CVE-2021-37703": {"epss_score": 0.00229, "epss_percentile": 0.45595}, "CVE-2021-37704": {"epss_score": 0.47802, "epss_percentile": 0.97602}, "CVE-2021-37705": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2021-37706": {"epss_score": 0.00506, "epss_percentile": 0.65639}, "CVE-2021-37707": {"epss_score": 0.00215, "epss_percentile": 0.44043}, "CVE-2021-37708": {"epss_score": 0.05905, "epss_percentile": 0.90312}, "CVE-2021-37709": {"epss_score": 0.00218, "epss_percentile": 0.44391}, "CVE-2021-37710": {"epss_score": 0.00355, "epss_percentile": 0.57275}, "CVE-2021-37711": {"epss_score": 0.00519, "epss_percentile": 0.66141}, "CVE-2021-37712": {"epss_score": 0.00016, "epss_percentile": 0.02961}, "CVE-2021-37713": {"epss_score": 0.00606, "epss_percentile": 0.69}, "CVE-2021-37714": {"epss_score": 0.02969, "epss_percentile": 0.86091}, "CVE-2021-37715": {"epss_score": 0.00247, "epss_percentile": 0.47829}, "CVE-2021-37716": {"epss_score": 0.01583, "epss_percentile": 0.81147}, "CVE-2021-37717": {"epss_score": 0.0355, "epss_percentile": 0.8734}, "CVE-2021-37718": {"epss_score": 0.0355, "epss_percentile": 0.8734}, "CVE-2021-37719": {"epss_score": 0.03628, "epss_percentile": 0.87466}, "CVE-2021-37720": {"epss_score": 0.0355, "epss_percentile": 0.8734}, "CVE-2021-37721": {"epss_score": 0.0355, "epss_percentile": 0.8734}, "CVE-2021-37722": {"epss_score": 0.0355, "epss_percentile": 0.8734}, "CVE-2021-37723": {"epss_score": 0.02066, "epss_percentile": 0.83459}, "CVE-2021-37724": {"epss_score": 0.02066, "epss_percentile": 0.83459}, "CVE-2021-37725": {"epss_score": 0.00169, "epss_percentile": 0.38541}, "CVE-2021-37726": {"epss_score": 0.01318, "epss_percentile": 0.7942}, "CVE-2021-37727": {"epss_score": 0.02704, "epss_percentile": 0.85464}, "CVE-2021-37728": {"epss_score": 0.0069, "epss_percentile": 0.71241}, "CVE-2021-37729": {"epss_score": 0.0057, "epss_percentile": 0.67962}, "CVE-2021-37730": {"epss_score": 0.02704, "epss_percentile": 0.85464}, "CVE-2021-37731": {"epss_score": 0.00177, "epss_percentile": 0.39497}, "CVE-2021-37732": {"epss_score": 0.02704, "epss_percentile": 0.85464}, "CVE-2021-37733": {"epss_score": 0.00448, "epss_percentile": 0.63028}, "CVE-2021-37734": {"epss_score": 0.00485, "epss_percentile": 0.64715}, "CVE-2021-37735": {"epss_score": 0.00537, "epss_percentile": 0.66889}, "CVE-2021-37736": {"epss_score": 0.0051, "epss_percentile": 0.65757}, "CVE-2021-37737": {"epss_score": 0.00608, "epss_percentile": 0.6908}, "CVE-2021-37738": {"epss_score": 0.00319, "epss_percentile": 0.5457}, "CVE-2021-37739": {"epss_score": 0.03295, "epss_percentile": 0.86847}, "CVE-2021-37740": {"epss_score": 0.1997, "epss_percentile": 0.95268}, "CVE-2021-37741": {"epss_score": 0.0541, "epss_percentile": 0.89843}, "CVE-2021-37742": {"epss_score": 0.00255, "epss_percentile": 0.48725}, "CVE-2021-37743": {"epss_score": 0.00255, "epss_percentile": 0.48725}, "CVE-2021-37746": {"epss_score": 0.00483, "epss_percentile": 0.64623}, "CVE-2021-37748": {"epss_score": 0.11924, "epss_percentile": 0.93517}, "CVE-2021-37749": {"epss_score": 0.00675, "epss_percentile": 0.70913}, "CVE-2021-37750": {"epss_score": 0.00716, "epss_percentile": 0.71865}, "CVE-2021-37759": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-37760": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-37761": {"epss_score": 0.3738, "epss_percentile": 0.97041}, "CVE-2021-37762": {"epss_score": 0.3738, "epss_percentile": 0.97041}, "CVE-2021-37764": {"epss_score": 0.00139, "epss_percentile": 0.34541}, "CVE-2021-37770": {"epss_score": 0.01073, "epss_percentile": 0.77292}, "CVE-2021-37774": {"epss_score": 0.00066, "epss_percentile": 0.20757}, "CVE-2021-37777": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2021-37778": {"epss_score": 0.01278, "epss_percentile": 0.79124}, "CVE-2021-37781": {"epss_score": 0.00548, "epss_percentile": 0.67283}, "CVE-2021-37782": {"epss_score": 0.00631, "epss_percentile": 0.69722}, "CVE-2021-37786": {"epss_score": 0.0003, "epss_percentile": 0.08222}, "CVE-2021-37787": {"epss_score": 0.00077, "epss_percentile": 0.23539}, "CVE-2021-37788": {"epss_score": 0.00142, "epss_percentile": 0.34956}, "CVE-2021-37789": {"epss_score": 0.00165, "epss_percentile": 0.38009}, "CVE-2021-37791": {"epss_score": 0.00275, "epss_percentile": 0.5068}, "CVE-2021-37794": {"epss_score": 0.00278, "epss_percentile": 0.50897}, "CVE-2021-37803": {"epss_score": 0.00329, "epss_percentile": 0.55301}, "CVE-2021-37805": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2021-37806": {"epss_score": 0.00397, "epss_percentile": 0.59971}, "CVE-2021-37807": {"epss_score": 0.00251, "epss_percentile": 0.48312}, "CVE-2021-37808": {"epss_score": 0.00397, "epss_percentile": 0.59971}, "CVE-2021-37819": {"epss_score": 0.00343, "epss_percentile": 0.56433}, "CVE-2021-37823": {"epss_score": 0.0032, "epss_percentile": 0.54624}, "CVE-2021-37832": {"epss_score": 0.1308, "epss_percentile": 0.93867}, "CVE-2021-37833": {"epss_score": 0.05431, "epss_percentile": 0.89877}, "CVE-2021-37839": {"epss_score": 0.00236, "epss_percentile": 0.46423}, "CVE-2021-37840": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2021-37841": {"epss_score": 0.00172, "epss_percentile": 0.38989}, "CVE-2021-37842": {"epss_score": 0.00162, "epss_percentile": 0.37736}, "CVE-2021-37843": {"epss_score": 0.00908, "epss_percentile": 0.75275}, "CVE-2021-37845": {"epss_score": 0.0009, "epss_percentile": 0.26147}, "CVE-2021-37847": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-37848": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-37850": {"epss_score": 0.00123, "epss_percentile": 0.32184}, "CVE-2021-37851": {"epss_score": 0.00034, "epss_percentile": 0.09558}, "CVE-2021-37852": {"epss_score": 0.0003, "epss_percentile": 0.08051}, "CVE-2021-37859": {"epss_score": 0.45086, "epss_percentile": 0.97472}, "CVE-2021-37860": {"epss_score": 0.00214, "epss_percentile": 0.43949}, "CVE-2021-37861": {"epss_score": 0.00335, "epss_percentile": 0.55798}, "CVE-2021-37862": {"epss_score": 0.00168, "epss_percentile": 0.385}, "CVE-2021-37863": {"epss_score": 0.00572, "epss_percentile": 0.68031}, "CVE-2021-37864": {"epss_score": 0.00177, "epss_percentile": 0.39582}, "CVE-2021-37865": {"epss_score": 0.00603, "epss_percentile": 0.68905}, "CVE-2021-37866": {"epss_score": 0.0019, "epss_percentile": 0.41105}, "CVE-2021-37867": {"epss_score": 0.00227, "epss_percentile": 0.4539}, "CVE-2021-37909": {"epss_score": 0.01836, "epss_percentile": 0.8247}, "CVE-2021-37910": {"epss_score": 0.03298, "epss_percentile": 0.8686}, "CVE-2021-37911": {"epss_score": 0.00114, "epss_percentile": 0.30849}, "CVE-2021-37912": {"epss_score": 0.06621, "epss_percentile": 0.90894}, "CVE-2021-37913": {"epss_score": 0.06621, "epss_percentile": 0.90894}, "CVE-2021-37914": {"epss_score": 0.00271, "epss_percentile": 0.50278}, "CVE-2021-37915": {"epss_score": 0.00794, "epss_percentile": 0.7345}, "CVE-2021-37916": {"epss_score": 0.00358, "epss_percentile": 0.57534}, "CVE-2021-37918": {"epss_score": 0.44137, "epss_percentile": 0.9742}, "CVE-2021-37919": {"epss_score": 0.3738, "epss_percentile": 0.97041}, "CVE-2021-37920": {"epss_score": 0.3738, "epss_percentile": 0.97041}, "CVE-2021-37921": {"epss_score": 0.3738, "epss_percentile": 0.97041}, "CVE-2021-37922": {"epss_score": 0.25953, "epss_percentile": 0.96096}, "CVE-2021-37923": {"epss_score": 0.3738, "epss_percentile": 0.97041}, "CVE-2021-37924": {"epss_score": 0.3738, "epss_percentile": 0.97041}, "CVE-2021-37925": {"epss_score": 0.16824, "epss_percentile": 0.94735}, "CVE-2021-37926": {"epss_score": 0.36013, "epss_percentile": 0.96949}, "CVE-2021-37927": {"epss_score": 0.02144, "epss_percentile": 0.83761}, "CVE-2021-37928": {"epss_score": 0.3738, "epss_percentile": 0.97041}, "CVE-2021-37929": {"epss_score": 0.3738, "epss_percentile": 0.97041}, "CVE-2021-37930": {"epss_score": 0.3738, "epss_percentile": 0.97041}, "CVE-2021-37931": {"epss_score": 0.3738, "epss_percentile": 0.97041}, "CVE-2021-37933": {"epss_score": 0.00221, "epss_percentile": 0.44685}, "CVE-2021-37934": {"epss_score": 0.01361, "epss_percentile": 0.79752}, "CVE-2021-37935": {"epss_score": 0.00452, "epss_percentile": 0.63172}, "CVE-2021-37936": {"epss_score": 0.00686, "epss_percentile": 0.71156}, "CVE-2021-37937": {"epss_score": 0.00242, "epss_percentile": 0.47379}, "CVE-2021-37938": {"epss_score": 0.00273, "epss_percentile": 0.50443}, "CVE-2021-37939": {"epss_score": 0.00166, "epss_percentile": 0.38234}, "CVE-2021-37940": {"epss_score": 0.00282, "epss_percentile": 0.51224}, "CVE-2021-37941": {"epss_score": 0.00033, "epss_percentile": 0.09344}, "CVE-2021-37942": {"epss_score": 0.00094, "epss_percentile": 0.26795}, "CVE-2021-37956": {"epss_score": 0.0048, "epss_percentile": 0.64479}, "CVE-2021-37957": {"epss_score": 0.0039, "epss_percentile": 0.59517}, "CVE-2021-37958": {"epss_score": 0.00208, "epss_percentile": 0.4329}, "CVE-2021-37959": {"epss_score": 0.00102, "epss_percentile": 0.28778}, "CVE-2021-37961": {"epss_score": 0.00635, "epss_percentile": 0.69824}, "CVE-2021-37962": {"epss_score": 0.00585, "epss_percentile": 0.6843}, "CVE-2021-37963": {"epss_score": 0.00024, "epss_percentile": 0.05972}, "CVE-2021-37964": {"epss_score": 0.0035, "epss_percentile": 0.56963}, "CVE-2021-37965": {"epss_score": 0.00343, "epss_percentile": 0.56408}, "CVE-2021-37966": {"epss_score": 0.00274, "epss_percentile": 0.50509}, "CVE-2021-37967": {"epss_score": 0.00818, "epss_percentile": 0.73859}, "CVE-2021-37968": {"epss_score": 0.00518, "epss_percentile": 0.66125}, "CVE-2021-37969": {"epss_score": 0.00718, "epss_percentile": 0.7193}, "CVE-2021-37970": {"epss_score": 0.02501, "epss_percentile": 0.84921}, "CVE-2021-37971": {"epss_score": 0.00219, "epss_percentile": 0.44449}, "CVE-2021-37972": {"epss_score": 0.00723, "epss_percentile": 0.72017}, "CVE-2021-37973": {"epss_score": 0.0425, "epss_percentile": 0.8845}, "CVE-2021-37974": {"epss_score": 0.01154, "epss_percentile": 0.78067}, "CVE-2021-37975": {"epss_score": 0.62947, "epss_percentile": 0.98314}, "CVE-2021-37976": {"epss_score": 0.06605, "epss_percentile": 0.90883}, "CVE-2021-37977": {"epss_score": 0.00767, "epss_percentile": 0.72961}, "CVE-2021-37978": {"epss_score": 0.02288, "epss_percentile": 0.84273}, "CVE-2021-37979": {"epss_score": 0.01706, "epss_percentile": 0.81857}, "CVE-2021-37980": {"epss_score": 0.00314, "epss_percentile": 0.54111}, "CVE-2021-37981": {"epss_score": 0.012, "epss_percentile": 0.78466}, "CVE-2021-37982": {"epss_score": 0.01133, "epss_percentile": 0.77882}, "CVE-2021-37983": {"epss_score": 0.01308, "epss_percentile": 0.7935}, "CVE-2021-37984": {"epss_score": 0.02362, "epss_percentile": 0.84504}, "CVE-2021-37985": {"epss_score": 0.01094, "epss_percentile": 0.77497}, "CVE-2021-37986": {"epss_score": 0.00987, "epss_percentile": 0.7634}, "CVE-2021-37987": {"epss_score": 0.01409, "epss_percentile": 0.80077}, "CVE-2021-37988": {"epss_score": 0.01094, "epss_percentile": 0.77497}, "CVE-2021-37989": {"epss_score": 0.00679, "epss_percentile": 0.71011}, "CVE-2021-37990": {"epss_score": 0.00342, "epss_percentile": 0.564}, "CVE-2021-37991": {"epss_score": 0.01582, "epss_percentile": 0.81141}, "CVE-2021-37992": {"epss_score": 0.00999, "epss_percentile": 0.76476}, "CVE-2021-37993": {"epss_score": 0.01409, "epss_percentile": 0.80077}, "CVE-2021-37994": {"epss_score": 0.00342, "epss_percentile": 0.56401}, "CVE-2021-37995": {"epss_score": 0.00355, "epss_percentile": 0.57287}, "CVE-2021-37996": {"epss_score": 0.00164, "epss_percentile": 0.38002}, "CVE-2021-37997": {"epss_score": 0.00856, "epss_percentile": 0.74481}, "CVE-2021-37998": {"epss_score": 0.00893, "epss_percentile": 0.75076}, "CVE-2021-37999": {"epss_score": 0.0054, "epss_percentile": 0.67017}, "CVE-2021-38000": {"epss_score": 0.0251, "epss_percentile": 0.84947}, "CVE-2021-38001": {"epss_score": 0.33062, "epss_percentile": 0.96743}, "CVE-2021-38002": {"epss_score": 0.00827, "epss_percentile": 0.73979}, "CVE-2021-38003": {"epss_score": 0.74804, "epss_percentile": 0.98818}, "CVE-2021-38004": {"epss_score": 0.00382, "epss_percentile": 0.59045}, "CVE-2021-38005": {"epss_score": 0.01409, "epss_percentile": 0.80077}, "CVE-2021-38006": {"epss_score": 0.01201, "epss_percentile": 0.7848}, "CVE-2021-38007": {"epss_score": 0.01418, "epss_percentile": 0.80157}, "CVE-2021-38008": {"epss_score": 0.01455, "epss_percentile": 0.80386}, "CVE-2021-38009": {"epss_score": 0.01139, "epss_percentile": 0.77946}, "CVE-2021-38010": {"epss_score": 0.00357, "epss_percentile": 0.57472}, "CVE-2021-38011": {"epss_score": 0.00887, "epss_percentile": 0.74968}, "CVE-2021-38012": {"epss_score": 0.01418, "epss_percentile": 0.80157}, "CVE-2021-38013": {"epss_score": 0.0132, "epss_percentile": 0.7944}, "CVE-2021-38014": {"epss_score": 0.01201, "epss_percentile": 0.7848}, "CVE-2021-38015": {"epss_score": 0.00192, "epss_percentile": 0.41279}, "CVE-2021-38016": {"epss_score": 0.00171, "epss_percentile": 0.3882}, "CVE-2021-38017": {"epss_score": 0.00234, "epss_percentile": 0.46157}, "CVE-2021-38018": {"epss_score": 0.00803, "epss_percentile": 0.73594}, "CVE-2021-38019": {"epss_score": 0.01139, "epss_percentile": 0.77946}, "CVE-2021-38020": {"epss_score": 0.00526, "epss_percentile": 0.66423}, "CVE-2021-38021": {"epss_score": 0.00348, "epss_percentile": 0.56822}, "CVE-2021-38022": {"epss_score": 0.00948, "epss_percentile": 0.75834}, "CVE-2021-38023": {"epss_score": 0.00539, "epss_percentile": 0.66987}, "CVE-2021-38084": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2021-38085": {"epss_score": 0.03671, "epss_percentile": 0.87539}, "CVE-2021-38086": {"epss_score": 0.00054, "epss_percentile": 0.17175}, "CVE-2021-38087": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2021-38088": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2021-38090": {"epss_score": 0.00503, "epss_percentile": 0.65442}, "CVE-2021-38091": {"epss_score": 0.00503, "epss_percentile": 0.65442}, "CVE-2021-38092": {"epss_score": 0.00503, "epss_percentile": 0.65442}, "CVE-2021-38093": {"epss_score": 0.00503, "epss_percentile": 0.65442}, "CVE-2021-38094": {"epss_score": 0.00503, "epss_percentile": 0.65442}, "CVE-2021-38095": {"epss_score": 0.00567, "epss_percentile": 0.67843}, "CVE-2021-38096": {"epss_score": 0.01415, "epss_percentile": 0.80138}, "CVE-2021-38097": {"epss_score": 0.01388, "epss_percentile": 0.79924}, "CVE-2021-38098": {"epss_score": 0.00694, "epss_percentile": 0.7134}, "CVE-2021-38099": {"epss_score": 0.00332, "epss_percentile": 0.55604}, "CVE-2021-38100": {"epss_score": 0.00372, "epss_percentile": 0.58422}, "CVE-2021-38101": {"epss_score": 0.00423, "epss_percentile": 0.61599}, "CVE-2021-38102": {"epss_score": 0.0024, "epss_percentile": 0.47193}, "CVE-2021-38103": {"epss_score": 0.00292, "epss_percentile": 0.52254}, "CVE-2021-38104": {"epss_score": 0.0024, "epss_percentile": 0.47193}, "CVE-2021-38105": {"epss_score": 0.0024, "epss_percentile": 0.47193}, "CVE-2021-38106": {"epss_score": 0.0024, "epss_percentile": 0.47193}, "CVE-2021-38107": {"epss_score": 0.0024, "epss_percentile": 0.47193}, "CVE-2021-38108": {"epss_score": 0.0024, "epss_percentile": 0.47193}, "CVE-2021-38109": {"epss_score": 0.0024, "epss_percentile": 0.47193}, "CVE-2021-38110": {"epss_score": 0.00372, "epss_percentile": 0.58422}, "CVE-2021-38111": {"epss_score": 0.00393, "epss_percentile": 0.59728}, "CVE-2021-38112": {"epss_score": 0.17728, "epss_percentile": 0.94896}, "CVE-2021-38113": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2021-38114": {"epss_score": 0.00114, "epss_percentile": 0.30832}, "CVE-2021-38115": {"epss_score": 0.00212, "epss_percentile": 0.43752}, "CVE-2021-38116": {"epss_score": 0.0013, "epss_percentile": 0.33333}, "CVE-2021-38117": {"epss_score": 0.00602, "epss_percentile": 0.68888}, "CVE-2021-38118": {"epss_score": 0.00048, "epss_percentile": 0.15274}, "CVE-2021-38119": {"epss_score": 0.00118, "epss_percentile": 0.31411}, "CVE-2021-38120": {"epss_score": 0.00108, "epss_percentile": 0.29776}, "CVE-2021-38121": {"epss_score": 0.0003, "epss_percentile": 0.08311}, "CVE-2021-38122": {"epss_score": 0.00143, "epss_percentile": 0.35151}, "CVE-2021-38123": {"epss_score": 0.00234, "epss_percentile": 0.46172}, "CVE-2021-38124": {"epss_score": 0.02095, "epss_percentile": 0.83582}, "CVE-2021-38125": {"epss_score": 0.01665, "epss_percentile": 0.81647}, "CVE-2021-38126": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-38127": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-38129": {"epss_score": 0.00047, "epss_percentile": 0.146}, "CVE-2021-38130": {"epss_score": 0.00263, "epss_percentile": 0.49512}, "CVE-2021-38131": {"epss_score": 0.00151, "epss_percentile": 0.36341}, "CVE-2021-38132": {"epss_score": 0.00121, "epss_percentile": 0.32002}, "CVE-2021-38133": {"epss_score": 0.00221, "epss_percentile": 0.44643}, "CVE-2021-38134": {"epss_score": 0.00114, "epss_percentile": 0.3084}, "CVE-2021-38135": {"epss_score": 0.00095, "epss_percentile": 0.27239}, "CVE-2021-38136": {"epss_score": 0.00382, "epss_percentile": 0.59038}, "CVE-2021-38137": {"epss_score": 0.00211, "epss_percentile": 0.43711}, "CVE-2021-38138": {"epss_score": 0.00346, "epss_percentile": 0.5671}, "CVE-2021-38140": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2021-38142": {"epss_score": 0.00093, "epss_percentile": 0.26758}, "CVE-2021-38143": {"epss_score": 0.01187, "epss_percentile": 0.78356}, "CVE-2021-38144": {"epss_score": 0.00453, "epss_percentile": 0.63207}, "CVE-2021-38145": {"epss_score": 0.02283, "epss_percentile": 0.8426}, "CVE-2021-38146": {"epss_score": 0.45088, "epss_percentile": 0.97472}, "CVE-2021-38147": {"epss_score": 0.63253, "epss_percentile": 0.98325}, "CVE-2021-38148": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-38149": {"epss_score": 0.00162, "epss_percentile": 0.37752}, "CVE-2021-38150": {"epss_score": 0.00128, "epss_percentile": 0.33031}, "CVE-2021-38151": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-38152": {"epss_score": 0.00445, "epss_percentile": 0.62864}, "CVE-2021-38153": {"epss_score": 0.00914, "epss_percentile": 0.75388}, "CVE-2021-38154": {"epss_score": 0.11868, "epss_percentile": 0.93501}, "CVE-2021-38155": {"epss_score": 0.01158, "epss_percentile": 0.78122}, "CVE-2021-38156": {"epss_score": 0.84015, "epss_percentile": 0.99271}, "CVE-2021-38157": {"epss_score": 0.00504, "epss_percentile": 0.65525}, "CVE-2021-38159": {"epss_score": 0.0342, "epss_percentile": 0.87101}, "CVE-2021-38160": {"epss_score": 0.00073, "epss_percentile": 0.22657}, "CVE-2021-38161": {"epss_score": 0.01167, "epss_percentile": 0.78184}, "CVE-2021-38162": {"epss_score": 0.01797, "epss_percentile": 0.82311}, "CVE-2021-38163": {"epss_score": 0.78698, "epss_percentile": 0.98999}, "CVE-2021-38164": {"epss_score": 0.00129, "epss_percentile": 0.33165}, "CVE-2021-38165": {"epss_score": 0.04281, "epss_percentile": 0.88489}, "CVE-2021-38166": {"epss_score": 0.00095, "epss_percentile": 0.27097}, "CVE-2021-38167": {"epss_score": 0.01054, "epss_percentile": 0.77108}, "CVE-2021-38168": {"epss_score": 0.00424, "epss_percentile": 0.61675}, "CVE-2021-38169": {"epss_score": 0.03154, "epss_percentile": 0.86512}, "CVE-2021-38171": {"epss_score": 0.0021, "epss_percentile": 0.43466}, "CVE-2021-38172": {"epss_score": 0.01173, "epss_percentile": 0.78241}, "CVE-2021-38173": {"epss_score": 0.00199, "epss_percentile": 0.4214}, "CVE-2021-38174": {"epss_score": 0.00291, "epss_percentile": 0.52185}, "CVE-2021-38175": {"epss_score": 0.00231, "epss_percentile": 0.45848}, "CVE-2021-38176": {"epss_score": 0.00722, "epss_percentile": 0.71994}, "CVE-2021-38177": {"epss_score": 0.03078, "epss_percentile": 0.86364}, "CVE-2021-38178": {"epss_score": 0.00446, "epss_percentile": 0.62906}, "CVE-2021-38179": {"epss_score": 0.00335, "epss_percentile": 0.55895}, "CVE-2021-38180": {"epss_score": 0.01824, "epss_percentile": 0.82428}, "CVE-2021-38181": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2021-38182": {"epss_score": 0.00517, "epss_percentile": 0.66072}, "CVE-2021-38183": {"epss_score": 0.00487, "epss_percentile": 0.64807}, "CVE-2021-38185": {"epss_score": 0.26706, "epss_percentile": 0.96168}, "CVE-2021-38186": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2021-38187": {"epss_score": 0.00389, "epss_percentile": 0.59471}, "CVE-2021-38188": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2021-38189": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2021-38190": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2021-38191": {"epss_score": 0.00237, "epss_percentile": 0.46661}, "CVE-2021-38192": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-38193": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2021-38194": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2021-38195": {"epss_score": 0.0017, "epss_percentile": 0.38663}, "CVE-2021-38196": {"epss_score": 0.03365, "epss_percentile": 0.87002}, "CVE-2021-38197": {"epss_score": 0.00872, "epss_percentile": 0.74739}, "CVE-2021-38198": {"epss_score": 0.00079, "epss_percentile": 0.23972}, "CVE-2021-38199": {"epss_score": 0.00309, "epss_percentile": 0.53653}, "CVE-2021-38200": {"epss_score": 0.00042, "epss_percentile": 0.1292}, "CVE-2021-38201": {"epss_score": 0.01735, "epss_percentile": 0.82005}, "CVE-2021-38202": {"epss_score": 0.01452, "epss_percentile": 0.80371}, "CVE-2021-38203": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2021-38204": {"epss_score": 0.0007, "epss_percentile": 0.21934}, "CVE-2021-38205": {"epss_score": 0.00069, "epss_percentile": 0.21583}, "CVE-2021-38206": {"epss_score": 0.00065, "epss_percentile": 0.20494}, "CVE-2021-38207": {"epss_score": 0.02483, "epss_percentile": 0.84879}, "CVE-2021-38208": {"epss_score": 0.00082, "epss_percentile": 0.24572}, "CVE-2021-38209": {"epss_score": 0.00087, "epss_percentile": 0.25535}, "CVE-2021-38217": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2021-38221": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-38239": {"epss_score": 0.00302, "epss_percentile": 0.53085}, "CVE-2021-38241": {"epss_score": 0.00889, "epss_percentile": 0.75015}, "CVE-2021-38243": {"epss_score": 0.04212, "epss_percentile": 0.88402}, "CVE-2021-38244": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-38258": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2021-38260": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2021-38263": {"epss_score": 0.0053, "epss_percentile": 0.66641}, "CVE-2021-38264": {"epss_score": 0.00295, "epss_percentile": 0.5252}, "CVE-2021-38265": {"epss_score": 0.00178, "epss_percentile": 0.39684}, "CVE-2021-38266": {"epss_score": 0.01851, "epss_percentile": 0.82537}, "CVE-2021-38267": {"epss_score": 0.00178, "epss_percentile": 0.39684}, "CVE-2021-38268": {"epss_score": 0.00119, "epss_percentile": 0.31674}, "CVE-2021-38269": {"epss_score": 0.00178, "epss_percentile": 0.39684}, "CVE-2021-38278": {"epss_score": 0.00522, "epss_percentile": 0.66255}, "CVE-2021-38283": {"epss_score": 0.00699, "epss_percentile": 0.71444}, "CVE-2021-38289": {"epss_score": 0.0031, "epss_percentile": 0.53799}, "CVE-2021-38290": {"epss_score": 0.00436, "epss_percentile": 0.62464}, "CVE-2021-38291": {"epss_score": 0.00334, "epss_percentile": 0.55744}, "CVE-2021-38294": {"epss_score": 0.84614, "epss_percentile": 0.99297}, "CVE-2021-38295": {"epss_score": 0.04093, "epss_percentile": 0.88243}, "CVE-2021-38296": {"epss_score": 0.0088, "epss_percentile": 0.74854}, "CVE-2021-38297": {"epss_score": 0.05854, "epss_percentile": 0.90265}, "CVE-2021-38298": {"epss_score": 0.05595, "epss_percentile": 0.90033}, "CVE-2021-38299": {"epss_score": 0.00349, "epss_percentile": 0.56887}, "CVE-2021-38300": {"epss_score": 0.00152, "epss_percentile": 0.3646}, "CVE-2021-38302": {"epss_score": 0.00384, "epss_percentile": 0.5916}, "CVE-2021-38303": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-38304": {"epss_score": 0.00148, "epss_percentile": 0.35828}, "CVE-2021-38305": {"epss_score": 0.0086, "epss_percentile": 0.74545}, "CVE-2021-38306": {"epss_score": 0.34966, "epss_percentile": 0.96879}, "CVE-2021-38311": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-38312": {"epss_score": 0.00136, "epss_percentile": 0.34061}, "CVE-2021-38314": {"epss_score": 0.8852, "epss_percentile": 0.99475}, "CVE-2021-38315": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38316": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38317": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38318": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38319": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38320": {"epss_score": 0.00258, "epss_percentile": 0.49023}, "CVE-2021-38321": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38322": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38323": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38324": {"epss_score": 0.00514, "epss_percentile": 0.65964}, "CVE-2021-38325": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38326": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38327": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38328": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38329": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38330": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38331": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38332": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38333": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38334": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38335": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38336": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38337": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38338": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38339": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38340": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38341": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38342": {"epss_score": 0.00098, "epss_percentile": 0.27668}, "CVE-2021-38343": {"epss_score": 0.00192, "epss_percentile": 0.41314}, "CVE-2021-38344": {"epss_score": 0.00171, "epss_percentile": 0.38787}, "CVE-2021-38345": {"epss_score": 0.00253, "epss_percentile": 0.4846}, "CVE-2021-38346": {"epss_score": 0.02275, "epss_percentile": 0.84227}, "CVE-2021-38347": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38348": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38349": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38350": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38351": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38352": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38353": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38354": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38355": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38356": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38357": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38358": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38359": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38360": {"epss_score": 0.04628, "epss_percentile": 0.8894}, "CVE-2021-38361": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-38362": {"epss_score": 0.0026, "epss_percentile": 0.4922}, "CVE-2021-38363": {"epss_score": 0.0007, "epss_percentile": 0.21718}, "CVE-2021-38364": {"epss_score": 0.00133, "epss_percentile": 0.33652}, "CVE-2021-38365": {"epss_score": 0.00442, "epss_percentile": 0.62697}, "CVE-2021-38366": {"epss_score": 0.0279, "epss_percentile": 0.85666}, "CVE-2021-38370": {"epss_score": 0.00187, "epss_percentile": 0.4073}, "CVE-2021-38371": {"epss_score": 0.02209, "epss_percentile": 0.8401}, "CVE-2021-38372": {"epss_score": 0.00314, "epss_percentile": 0.54153}, "CVE-2021-38373": {"epss_score": 0.00161, "epss_percentile": 0.37549}, "CVE-2021-38374": {"epss_score": 0.00431, "epss_percentile": 0.62093}, "CVE-2021-38375": {"epss_score": 0.00341, "epss_percentile": 0.56292}, "CVE-2021-38376": {"epss_score": 0.00268, "epss_percentile": 0.5007}, "CVE-2021-38377": {"epss_score": 0.00299, "epss_percentile": 0.52871}, "CVE-2021-38378": {"epss_score": 0.0025, "epss_percentile": 0.48136}, "CVE-2021-38379": {"epss_score": 0.0003, "epss_percentile": 0.08209}, "CVE-2021-38380": {"epss_score": 0.00277, "epss_percentile": 0.50813}, "CVE-2021-38381": {"epss_score": 0.00225, "epss_percentile": 0.45082}, "CVE-2021-38382": {"epss_score": 0.00225, "epss_percentile": 0.45082}, "CVE-2021-38383": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-38384": {"epss_score": 0.00328, "epss_percentile": 0.55171}, "CVE-2021-38385": {"epss_score": 0.00522, "epss_percentile": 0.66262}, "CVE-2021-38386": {"epss_score": 0.00727, "epss_percentile": 0.72082}, "CVE-2021-38387": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-38388": {"epss_score": 0.00299, "epss_percentile": 0.52865}, "CVE-2021-38389": {"epss_score": 0.00467, "epss_percentile": 0.63848}, "CVE-2021-38390": {"epss_score": 0.01647, "epss_percentile": 0.81538}, "CVE-2021-38391": {"epss_score": 0.01066, "epss_percentile": 0.77218}, "CVE-2021-38392": {"epss_score": 0.00038, "epss_percentile": 0.11178}, "CVE-2021-38393": {"epss_score": 0.01647, "epss_percentile": 0.81538}, "CVE-2021-38394": {"epss_score": 0.00042, "epss_percentile": 0.12898}, "CVE-2021-38395": {"epss_score": 0.00394, "epss_percentile": 0.59761}, "CVE-2021-38396": {"epss_score": 0.00024, "epss_percentile": 0.05771}, "CVE-2021-38397": {"epss_score": 0.00361, "epss_percentile": 0.57701}, "CVE-2021-38398": {"epss_score": 0.00042, "epss_percentile": 0.12832}, "CVE-2021-38399": {"epss_score": 0.00316, "epss_percentile": 0.54295}, "CVE-2021-38400": {"epss_score": 0.00025, "epss_percentile": 0.06231}, "CVE-2021-38401": {"epss_score": 0.00223, "epss_percentile": 0.44875}, "CVE-2021-38402": {"epss_score": 0.00842, "epss_percentile": 0.74246}, "CVE-2021-38403": {"epss_score": 0.00287, "epss_percentile": 0.5184}, "CVE-2021-38404": {"epss_score": 0.00926, "epss_percentile": 0.75556}, "CVE-2021-38405": {"epss_score": 0.0008, "epss_percentile": 0.24036}, "CVE-2021-38406": {"epss_score": 0.77604, "epss_percentile": 0.98943}, "CVE-2021-38407": {"epss_score": 0.00287, "epss_percentile": 0.5184}, "CVE-2021-38408": {"epss_score": 0.01473, "epss_percentile": 0.80514}, "CVE-2021-38409": {"epss_score": 0.00131, "epss_percentile": 0.33501}, "CVE-2021-38410": {"epss_score": 0.00109, "epss_percentile": 0.29993}, "CVE-2021-38411": {"epss_score": 0.00203, "epss_percentile": 0.4251}, "CVE-2021-38412": {"epss_score": 0.00156, "epss_percentile": 0.37015}, "CVE-2021-38413": {"epss_score": 0.00372, "epss_percentile": 0.58456}, "CVE-2021-38415": {"epss_score": 0.00372, "epss_percentile": 0.58456}, "CVE-2021-38416": {"epss_score": 0.00048, "epss_percentile": 0.15033}, "CVE-2021-38417": {"epss_score": 0.00348, "epss_percentile": 0.56848}, "CVE-2021-38418": {"epss_score": 0.00072, "epss_percentile": 0.22415}, "CVE-2021-38419": {"epss_score": 0.00223, "epss_percentile": 0.44875}, "CVE-2021-38420": {"epss_score": 0.00031, "epss_percentile": 0.08435}, "CVE-2021-38421": {"epss_score": 0.00131, "epss_percentile": 0.33501}, "CVE-2021-38422": {"epss_score": 0.00023, "epss_percentile": 0.05325}, "CVE-2021-38423": {"epss_score": 0.00176, "epss_percentile": 0.39433}, "CVE-2021-38424": {"epss_score": 0.00114, "epss_percentile": 0.30789}, "CVE-2021-38425": {"epss_score": 0.00066, "epss_percentile": 0.20942}, "CVE-2021-38426": {"epss_score": 0.00302, "epss_percentile": 0.53135}, "CVE-2021-38427": {"epss_score": 0.00102, "epss_percentile": 0.28727}, "CVE-2021-38428": {"epss_score": 0.00336, "epss_percentile": 0.55945}, "CVE-2021-38429": {"epss_score": 0.0006, "epss_percentile": 0.19076}, "CVE-2021-38430": {"epss_score": 0.00374, "epss_percentile": 0.58585}, "CVE-2021-38431": {"epss_score": 0.00101, "epss_percentile": 0.28674}, "CVE-2021-38432": {"epss_score": 0.00861, "epss_percentile": 0.74563}, "CVE-2021-38433": {"epss_score": 0.00095, "epss_percentile": 0.2723}, "CVE-2021-38434": {"epss_score": 0.00302, "epss_percentile": 0.53135}, "CVE-2021-38435": {"epss_score": 0.00186, "epss_percentile": 0.40596}, "CVE-2021-38436": {"epss_score": 0.00555, "epss_percentile": 0.67491}, "CVE-2021-38438": {"epss_score": 0.00223, "epss_percentile": 0.44875}, "CVE-2021-38439": {"epss_score": 0.00816, "epss_percentile": 0.73836}, "CVE-2021-38440": {"epss_score": 0.00147, "epss_percentile": 0.3578}, "CVE-2021-38441": {"epss_score": 0.00161, "epss_percentile": 0.37588}, "CVE-2021-38442": {"epss_score": 0.00555, "epss_percentile": 0.67491}, "CVE-2021-38443": {"epss_score": 0.0016, "epss_percentile": 0.37479}, "CVE-2021-38445": {"epss_score": 0.00698, "epss_percentile": 0.71422}, "CVE-2021-38447": {"epss_score": 0.00097, "epss_percentile": 0.27536}, "CVE-2021-38448": {"epss_score": 0.00127, "epss_percentile": 0.32912}, "CVE-2021-38449": {"epss_score": 0.00267, "epss_percentile": 0.50018}, "CVE-2021-38450": {"epss_score": 0.00284, "epss_percentile": 0.51468}, "CVE-2021-38451": {"epss_score": 0.00166, "epss_percentile": 0.38192}, "CVE-2021-38452": {"epss_score": 0.00603, "epss_percentile": 0.68902}, "CVE-2021-38453": {"epss_score": 0.00248, "epss_percentile": 0.47924}, "CVE-2021-38454": {"epss_score": 0.00564, "epss_percentile": 0.67754}, "CVE-2021-38455": {"epss_score": 0.00201, "epss_percentile": 0.42348}, "CVE-2021-38456": {"epss_score": 0.00222, "epss_percentile": 0.44809}, "CVE-2021-38457": {"epss_score": 0.00274, "epss_percentile": 0.50518}, "CVE-2021-38458": {"epss_score": 0.00821, "epss_percentile": 0.73903}, "CVE-2021-38459": {"epss_score": 0.00222, "epss_percentile": 0.44809}, "CVE-2021-38460": {"epss_score": 0.00636, "epss_percentile": 0.69867}, "CVE-2021-38461": {"epss_score": 0.0008, "epss_percentile": 0.24046}, "CVE-2021-38462": {"epss_score": 0.00222, "epss_percentile": 0.44809}, "CVE-2021-38463": {"epss_score": 0.00206, "epss_percentile": 0.42927}, "CVE-2021-38464": {"epss_score": 0.00037, "epss_percentile": 0.10677}, "CVE-2021-38465": {"epss_score": 0.00304, "epss_percentile": 0.5327}, "CVE-2021-38466": {"epss_score": 0.002, "epss_percentile": 0.42251}, "CVE-2021-38467": {"epss_score": 0.0016, "epss_percentile": 0.37437}, "CVE-2021-38468": {"epss_score": 0.00143, "epss_percentile": 0.35216}, "CVE-2021-38469": {"epss_score": 0.00128, "epss_percentile": 0.33066}, "CVE-2021-38470": {"epss_score": 0.0037, "epss_percentile": 0.58302}, "CVE-2021-38471": {"epss_score": 0.00219, "epss_percentile": 0.44486}, "CVE-2021-38472": {"epss_score": 0.00145, "epss_percentile": 0.35436}, "CVE-2021-38473": {"epss_score": 0.00315, "epss_percentile": 0.54214}, "CVE-2021-38474": {"epss_score": 0.0016, "epss_percentile": 0.37477}, "CVE-2021-38475": {"epss_score": 0.00135, "epss_percentile": 0.33948}, "CVE-2021-38476": {"epss_score": 0.0015, "epss_percentile": 0.36099}, "CVE-2021-38477": {"epss_score": 0.00211, "epss_percentile": 0.4367}, "CVE-2021-38478": {"epss_score": 0.0037, "epss_percentile": 0.58302}, "CVE-2021-38479": {"epss_score": 0.00165, "epss_percentile": 0.38104}, "CVE-2021-38480": {"epss_score": 0.00091, "epss_percentile": 0.26283}, "CVE-2021-38481": {"epss_score": 0.00243, "epss_percentile": 0.47468}, "CVE-2021-38482": {"epss_score": 0.00143, "epss_percentile": 0.35216}, "CVE-2021-38483": {"epss_score": 0.00043, "epss_percentile": 0.12951}, "CVE-2021-38484": {"epss_score": 0.0065, "epss_percentile": 0.7026}, "CVE-2021-38485": {"epss_score": 0.0022, "epss_percentile": 0.44607}, "CVE-2021-38486": {"epss_score": 0.00252, "epss_percentile": 0.48403}, "CVE-2021-38487": {"epss_score": 0.00105, "epss_percentile": 0.29379}, "CVE-2021-38488": {"epss_score": 0.00433, "epss_percentile": 0.62196}, "CVE-2021-38490": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-38491": {"epss_score": 0.00391, "epss_percentile": 0.59573}, "CVE-2021-38492": {"epss_score": 0.00406, "epss_percentile": 0.60524}, "CVE-2021-38493": {"epss_score": 0.00392, "epss_percentile": 0.59659}, "CVE-2021-38494": {"epss_score": 0.0042, "epss_percentile": 0.61435}, "CVE-2021-38495": {"epss_score": 0.00541, "epss_percentile": 0.6705}, "CVE-2021-38496": {"epss_score": 0.0149, "epss_percentile": 0.80631}, "CVE-2021-38497": {"epss_score": 0.00344, "epss_percentile": 0.56498}, "CVE-2021-38498": {"epss_score": 0.00272, "epss_percentile": 0.50363}, "CVE-2021-38499": {"epss_score": 0.0042, "epss_percentile": 0.61435}, "CVE-2021-38500": {"epss_score": 0.00689, "epss_percentile": 0.71221}, "CVE-2021-38501": {"epss_score": 0.00402, "epss_percentile": 0.60302}, "CVE-2021-38502": {"epss_score": 0.00461, "epss_percentile": 0.6355}, "CVE-2021-38503": {"epss_score": 0.01484, "epss_percentile": 0.80589}, "CVE-2021-38504": {"epss_score": 0.00707, "epss_percentile": 0.71648}, "CVE-2021-38505": {"epss_score": 0.00444, "epss_percentile": 0.62841}, "CVE-2021-38506": {"epss_score": 0.00297, "epss_percentile": 0.52758}, "CVE-2021-38507": {"epss_score": 0.00461, "epss_percentile": 0.63544}, "CVE-2021-38508": {"epss_score": 0.00446, "epss_percentile": 0.62927}, "CVE-2021-38509": {"epss_score": 0.00535, "epss_percentile": 0.66838}, "CVE-2021-38510": {"epss_score": 0.0047, "epss_percentile": 0.63975}, "CVE-2021-38511": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2021-38512": {"epss_score": 0.00422, "epss_percentile": 0.61572}, "CVE-2021-38513": {"epss_score": 0.00317, "epss_percentile": 0.54332}, "CVE-2021-38514": {"epss_score": 0.00246, "epss_percentile": 0.47775}, "CVE-2021-38515": {"epss_score": 0.00229, "epss_percentile": 0.45608}, "CVE-2021-38516": {"epss_score": 0.00442, "epss_percentile": 0.62751}, "CVE-2021-38517": {"epss_score": 0.00309, "epss_percentile": 0.53671}, "CVE-2021-38518": {"epss_score": 0.01144, "epss_percentile": 0.77985}, "CVE-2021-38519": {"epss_score": 0.00261, "epss_percentile": 0.49266}, "CVE-2021-38520": {"epss_score": 0.0039, "epss_percentile": 0.59523}, "CVE-2021-38521": {"epss_score": 0.00299, "epss_percentile": 0.52889}, "CVE-2021-38522": {"epss_score": 0.00533, "epss_percentile": 0.66765}, "CVE-2021-38523": {"epss_score": 0.00657, "epss_percentile": 0.70471}, "CVE-2021-38524": {"epss_score": 0.00292, "epss_percentile": 0.5224}, "CVE-2021-38525": {"epss_score": 0.005, "epss_percentile": 0.65321}, "CVE-2021-38526": {"epss_score": 0.00282, "epss_percentile": 0.51272}, "CVE-2021-38527": {"epss_score": 0.02457, "epss_percentile": 0.84802}, "CVE-2021-38528": {"epss_score": 0.02928, "epss_percentile": 0.86011}, "CVE-2021-38529": {"epss_score": 0.01473, "epss_percentile": 0.80513}, "CVE-2021-38530": {"epss_score": 0.01658, "epss_percentile": 0.81607}, "CVE-2021-38531": {"epss_score": 0.0025, "epss_percentile": 0.48111}, "CVE-2021-38532": {"epss_score": 0.00539, "epss_percentile": 0.66966}, "CVE-2021-38533": {"epss_score": 0.00287, "epss_percentile": 0.51817}, "CVE-2021-38534": {"epss_score": 0.00247, "epss_percentile": 0.47829}, "CVE-2021-38535": {"epss_score": 0.00364, "epss_percentile": 0.5791}, "CVE-2021-38536": {"epss_score": 0.00328, "epss_percentile": 0.55173}, "CVE-2021-38537": {"epss_score": 0.00199, "epss_percentile": 0.42137}, "CVE-2021-38538": {"epss_score": 0.00246, "epss_percentile": 0.47796}, "CVE-2021-38539": {"epss_score": 0.00213, "epss_percentile": 0.43831}, "CVE-2021-38540": {"epss_score": 0.90036, "epss_percentile": 0.99558}, "CVE-2021-38542": {"epss_score": 0.00614, "epss_percentile": 0.69264}, "CVE-2021-38543": {"epss_score": 0.00292, "epss_percentile": 0.52246}, "CVE-2021-38544": {"epss_score": 0.00292, "epss_percentile": 0.52246}, "CVE-2021-38545": {"epss_score": 0.00292, "epss_percentile": 0.52246}, "CVE-2021-38546": {"epss_score": 0.00292, "epss_percentile": 0.52246}, "CVE-2021-38547": {"epss_score": 0.00292, "epss_percentile": 0.52246}, "CVE-2021-38548": {"epss_score": 0.00292, "epss_percentile": 0.52246}, "CVE-2021-38549": {"epss_score": 0.00292, "epss_percentile": 0.52246}, "CVE-2021-38553": {"epss_score": 0.00032, "epss_percentile": 0.09076}, "CVE-2021-38554": {"epss_score": 0.0031, "epss_percentile": 0.5379}, "CVE-2021-38555": {"epss_score": 0.01272, "epss_percentile": 0.79077}, "CVE-2021-38556": {"epss_score": 0.18635, "epss_percentile": 0.95046}, "CVE-2021-38557": {"epss_score": 0.00728, "epss_percentile": 0.72105}, "CVE-2021-38559": {"epss_score": 0.00254, "epss_percentile": 0.48507}, "CVE-2021-38560": {"epss_score": 0.01549, "epss_percentile": 0.80982}, "CVE-2021-38561": {"epss_score": 0.00095, "epss_percentile": 0.27209}, "CVE-2021-38562": {"epss_score": 0.00101, "epss_percentile": 0.28699}, "CVE-2021-38563": {"epss_score": 0.00023, "epss_percentile": 0.05415}, "CVE-2021-38564": {"epss_score": 0.00023, "epss_percentile": 0.05415}, "CVE-2021-38565": {"epss_score": 0.0001, "epss_percentile": 0.00846}, "CVE-2021-38566": {"epss_score": 0.00018, "epss_percentile": 0.03636}, "CVE-2021-38567": {"epss_score": 0.00018, "epss_percentile": 0.03636}, "CVE-2021-38568": {"epss_score": 0.00027, "epss_percentile": 0.0675}, "CVE-2021-38569": {"epss_score": 0.00018, "epss_percentile": 0.03636}, "CVE-2021-38570": {"epss_score": 0.0004, "epss_percentile": 0.11985}, "CVE-2021-38571": {"epss_score": 0.00032, "epss_percentile": 0.08821}, "CVE-2021-38572": {"epss_score": 0.00023, "epss_percentile": 0.05415}, "CVE-2021-38573": {"epss_score": 0.00023, "epss_percentile": 0.05415}, "CVE-2021-38574": {"epss_score": 0.00017, "epss_percentile": 0.03135}, "CVE-2021-38575": {"epss_score": 0.0064, "epss_percentile": 0.6996}, "CVE-2021-38576": {"epss_score": 0.00179, "epss_percentile": 0.39835}, "CVE-2021-38578": {"epss_score": 0.00064, "epss_percentile": 0.20204}, "CVE-2021-38583": {"epss_score": 0.01089, "epss_percentile": 0.77442}, "CVE-2021-38584": {"epss_score": 0.00577, "epss_percentile": 0.68172}, "CVE-2021-38585": {"epss_score": 0.01521, "epss_percentile": 0.80832}, "CVE-2021-38586": {"epss_score": 0.00067, "epss_percentile": 0.21031}, "CVE-2021-38587": {"epss_score": 0.00328, "epss_percentile": 0.5527}, "CVE-2021-38588": {"epss_score": 0.00205, "epss_percentile": 0.42745}, "CVE-2021-38589": {"epss_score": 0.00561, "epss_percentile": 0.67664}, "CVE-2021-38590": {"epss_score": 0.00048, "epss_percentile": 0.15135}, "CVE-2021-38591": {"epss_score": 0.00018, "epss_percentile": 0.03704}, "CVE-2021-38592": {"epss_score": 0.00297, "epss_percentile": 0.52695}, "CVE-2021-38593": {"epss_score": 0.00834, "epss_percentile": 0.74101}, "CVE-2021-38597": {"epss_score": 0.00152, "epss_percentile": 0.36443}, "CVE-2021-38598": {"epss_score": 0.00036, "epss_percentile": 0.10456}, "CVE-2021-38599": {"epss_score": 0.0017, "epss_percentile": 0.38709}, "CVE-2021-38602": {"epss_score": 0.00518, "epss_percentile": 0.66133}, "CVE-2021-38603": {"epss_score": 0.00763, "epss_percentile": 0.72851}, "CVE-2021-38604": {"epss_score": 0.00102, "epss_percentile": 0.28761}, "CVE-2021-38606": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-38607": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2021-38608": {"epss_score": 0.00039, "epss_percentile": 0.11448}, "CVE-2021-38611": {"epss_score": 0.03684, "epss_percentile": 0.87566}, "CVE-2021-38612": {"epss_score": 0.00439, "epss_percentile": 0.62608}, "CVE-2021-38613": {"epss_score": 0.08945, "epss_percentile": 0.92331}, "CVE-2021-38614": {"epss_score": 0.00448, "epss_percentile": 0.63028}, "CVE-2021-38615": {"epss_score": 0.00336, "epss_percentile": 0.55996}, "CVE-2021-38616": {"epss_score": 0.00901, "epss_percentile": 0.7518}, "CVE-2021-38617": {"epss_score": 0.00881, "epss_percentile": 0.74862}, "CVE-2021-38618": {"epss_score": 0.00255, "epss_percentile": 0.48672}, "CVE-2021-38619": {"epss_score": 0.05364, "epss_percentile": 0.89785}, "CVE-2021-38621": {"epss_score": 0.00276, "epss_percentile": 0.50771}, "CVE-2021-38623": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-38624": {"epss_score": 0.00392, "epss_percentile": 0.59659}, "CVE-2021-38625": {"epss_score": 0.00249, "epss_percentile": 0.48029}, "CVE-2021-38626": {"epss_score": 0.00249, "epss_percentile": 0.48029}, "CVE-2021-38628": {"epss_score": 0.00318, "epss_percentile": 0.54409}, "CVE-2021-38629": {"epss_score": 0.22203, "epss_percentile": 0.95609}, "CVE-2021-38630": {"epss_score": 0.00234, "epss_percentile": 0.46105}, "CVE-2021-38631": {"epss_score": 0.00579, "epss_percentile": 0.68213}, "CVE-2021-38632": {"epss_score": 0.00428, "epss_percentile": 0.61933}, "CVE-2021-38633": {"epss_score": 0.00459, "epss_percentile": 0.63481}, "CVE-2021-38634": {"epss_score": 0.00241, "epss_percentile": 0.47321}, "CVE-2021-38635": {"epss_score": 0.00605, "epss_percentile": 0.68973}, "CVE-2021-38636": {"epss_score": 0.00605, "epss_percentile": 0.68973}, "CVE-2021-38637": {"epss_score": 0.00313, "epss_percentile": 0.54028}, "CVE-2021-38638": {"epss_score": 0.00356, "epss_percentile": 0.57387}, "CVE-2021-38639": {"epss_score": 0.00774, "epss_percentile": 0.73064}, "CVE-2021-38641": {"epss_score": 0.00717, "epss_percentile": 0.71885}, "CVE-2021-38642": {"epss_score": 0.00717, "epss_percentile": 0.71885}, "CVE-2021-38644": {"epss_score": 0.00418, "epss_percentile": 0.61272}, "CVE-2021-38645": {"epss_score": 0.14607, "epss_percentile": 0.9425}, "CVE-2021-38646": {"epss_score": 0.36255, "epss_percentile": 0.96964}, "CVE-2021-38647": {"epss_score": 0.94392, "epss_percentile": 0.9997}, "CVE-2021-38648": {"epss_score": 0.31792, "epss_percentile": 0.96648}, "CVE-2021-38649": {"epss_score": 0.06512, "epss_percentile": 0.90814}, "CVE-2021-38650": {"epss_score": 0.00823, "epss_percentile": 0.73922}, "CVE-2021-38651": {"epss_score": 0.01082, "epss_percentile": 0.77387}, "CVE-2021-38652": {"epss_score": 0.01286, "epss_percentile": 0.79183}, "CVE-2021-38653": {"epss_score": 0.08194, "epss_percentile": 0.91924}, "CVE-2021-38654": {"epss_score": 0.08194, "epss_percentile": 0.91924}, "CVE-2021-38655": {"epss_score": 0.06999, "epss_percentile": 0.91173}, "CVE-2021-38656": {"epss_score": 0.08194, "epss_percentile": 0.91924}, "CVE-2021-38657": {"epss_score": 0.00285, "epss_percentile": 0.51532}, "CVE-2021-38658": {"epss_score": 0.04203, "epss_percentile": 0.88391}, "CVE-2021-38659": {"epss_score": 0.04203, "epss_percentile": 0.88391}, "CVE-2021-38660": {"epss_score": 0.03146, "epss_percentile": 0.86495}, "CVE-2021-38661": {"epss_score": 0.00681, "epss_percentile": 0.71041}, "CVE-2021-38662": {"epss_score": 0.00578, "epss_percentile": 0.68182}, "CVE-2021-38663": {"epss_score": 0.00422, "epss_percentile": 0.61549}, "CVE-2021-38665": {"epss_score": 0.06446, "epss_percentile": 0.90762}, "CVE-2021-38666": {"epss_score": 0.21581, "epss_percentile": 0.95536}, "CVE-2021-38667": {"epss_score": 0.00305, "epss_percentile": 0.53331}, "CVE-2021-38669": {"epss_score": 0.00463, "epss_percentile": 0.63691}, "CVE-2021-38671": {"epss_score": 0.00305, "epss_percentile": 0.53331}, "CVE-2021-38672": {"epss_score": 0.00479, "epss_percentile": 0.64423}, "CVE-2021-38674": {"epss_score": 0.00288, "epss_percentile": 0.51886}, "CVE-2021-38675": {"epss_score": 0.00132, "epss_percentile": 0.33541}, "CVE-2021-38677": {"epss_score": 0.00324, "epss_percentile": 0.5495}, "CVE-2021-38678": {"epss_score": 0.00169, "epss_percentile": 0.38636}, "CVE-2021-38679": {"epss_score": 0.00198, "epss_percentile": 0.42063}, "CVE-2021-38680": {"epss_score": 0.00231, "epss_percentile": 0.4578}, "CVE-2021-38681": {"epss_score": 0.00249, "epss_percentile": 0.48074}, "CVE-2021-38682": {"epss_score": 0.01214, "epss_percentile": 0.78575}, "CVE-2021-38684": {"epss_score": 0.00814, "epss_percentile": 0.7377}, "CVE-2021-38685": {"epss_score": 0.01134, "epss_percentile": 0.77891}, "CVE-2021-38686": {"epss_score": 0.0028, "epss_percentile": 0.5108}, "CVE-2021-38687": {"epss_score": 0.00814, "epss_percentile": 0.7377}, "CVE-2021-38688": {"epss_score": 0.00208, "epss_percentile": 0.43253}, "CVE-2021-38689": {"epss_score": 0.01214, "epss_percentile": 0.78575}, "CVE-2021-38690": {"epss_score": 0.01214, "epss_percentile": 0.78575}, "CVE-2021-38691": {"epss_score": 0.01214, "epss_percentile": 0.78575}, "CVE-2021-38692": {"epss_score": 0.01214, "epss_percentile": 0.78575}, "CVE-2021-38693": {"epss_score": 0.00269, "epss_percentile": 0.50151}, "CVE-2021-38694": {"epss_score": 0.00276, "epss_percentile": 0.5075}, "CVE-2021-38695": {"epss_score": 0.00259, "epss_percentile": 0.49092}, "CVE-2021-38696": {"epss_score": 0.00351, "epss_percentile": 0.57032}, "CVE-2021-38697": {"epss_score": 0.01555, "epss_percentile": 0.81012}, "CVE-2021-38698": {"epss_score": 0.00689, "epss_percentile": 0.71214}, "CVE-2021-38699": {"epss_score": 0.08885, "epss_percentile": 0.923}, "CVE-2021-38701": {"epss_score": 0.00238, "epss_percentile": 0.46794}, "CVE-2021-38702": {"epss_score": 0.469, "epss_percentile": 0.97561}, "CVE-2021-38703": {"epss_score": 0.08251, "epss_percentile": 0.91951}, "CVE-2021-38704": {"epss_score": 0.09961, "epss_percentile": 0.92795}, "CVE-2021-38705": {"epss_score": 0.00716, "epss_percentile": 0.71859}, "CVE-2021-38706": {"epss_score": 0.00447, "epss_percentile": 0.62986}, "CVE-2021-38707": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-38708": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-38709": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-38710": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-38711": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2021-38712": {"epss_score": 0.00238, "epss_percentile": 0.46835}, "CVE-2021-38713": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2021-38714": {"epss_score": 0.00108, "epss_percentile": 0.29826}, "CVE-2021-38721": {"epss_score": 0.00191, "epss_percentile": 0.41264}, "CVE-2021-38723": {"epss_score": 0.00239, "epss_percentile": 0.46936}, "CVE-2021-38725": {"epss_score": 0.00172, "epss_percentile": 0.38991}, "CVE-2021-38727": {"epss_score": 0.01238, "epss_percentile": 0.78792}, "CVE-2021-38728": {"epss_score": 0.00542, "epss_percentile": 0.67078}, "CVE-2021-38729": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2021-38730": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2021-38731": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2021-38732": {"epss_score": 0.01139, "epss_percentile": 0.77937}, "CVE-2021-38733": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2021-38734": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2021-38736": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2021-38737": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2021-38745": {"epss_score": 0.01541, "epss_percentile": 0.80948}, "CVE-2021-38751": {"epss_score": 0.12877, "epss_percentile": 0.9381}, "CVE-2021-38752": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-38753": {"epss_score": 0.00517, "epss_percentile": 0.66071}, "CVE-2021-38754": {"epss_score": 0.00333, "epss_percentile": 0.55637}, "CVE-2021-38755": {"epss_score": 0.00266, "epss_percentile": 0.49926}, "CVE-2021-38756": {"epss_score": 0.00196, "epss_percentile": 0.41731}, "CVE-2021-38757": {"epss_score": 0.00268, "epss_percentile": 0.50045}, "CVE-2021-38758": {"epss_score": 0.00568, "epss_percentile": 0.67892}, "CVE-2021-38759": {"epss_score": 0.45028, "epss_percentile": 0.97467}, "CVE-2021-38772": {"epss_score": 0.00515, "epss_percentile": 0.66001}, "CVE-2021-38783": {"epss_score": 0.00774, "epss_percentile": 0.73066}, "CVE-2021-38784": {"epss_score": 0.00639, "epss_percentile": 0.69949}, "CVE-2021-38785": {"epss_score": 0.00776, "epss_percentile": 0.73102}, "CVE-2021-38786": {"epss_score": 0.00789, "epss_percentile": 0.73362}, "CVE-2021-38787": {"epss_score": 0.00788, "epss_percentile": 0.73344}, "CVE-2021-38788": {"epss_score": 0.00787, "epss_percentile": 0.73307}, "CVE-2021-38789": {"epss_score": 0.0034, "epss_percentile": 0.56259}, "CVE-2021-38819": {"epss_score": 0.007, "epss_percentile": 0.71481}, "CVE-2021-38822": {"epss_score": 0.00344, "epss_percentile": 0.56491}, "CVE-2021-38823": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2021-38827": {"epss_score": 0.00103, "epss_percentile": 0.28921}, "CVE-2021-38828": {"epss_score": 0.00045, "epss_percentile": 0.13931}, "CVE-2021-38833": {"epss_score": 0.00426, "epss_percentile": 0.61753}, "CVE-2021-38834": {"epss_score": 0.00434, "epss_percentile": 0.62292}, "CVE-2021-38840": {"epss_score": 0.00682, "epss_percentile": 0.71065}, "CVE-2021-38841": {"epss_score": 0.12063, "epss_percentile": 0.93558}, "CVE-2021-38847": {"epss_score": 0.00865, "epss_percentile": 0.74618}, "CVE-2021-38859": {"epss_score": 0.00083, "epss_percentile": 0.24761}, "CVE-2021-38862": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2021-38863": {"epss_score": 0.00039, "epss_percentile": 0.11805}, "CVE-2021-38864": {"epss_score": 0.00109, "epss_percentile": 0.30038}, "CVE-2021-38868": {"epss_score": 0.0008, "epss_percentile": 0.24069}, "CVE-2021-38869": {"epss_score": 0.00354, "epss_percentile": 0.5723}, "CVE-2021-38870": {"epss_score": 0.0015, "epss_percentile": 0.3609}, "CVE-2021-38871": {"epss_score": 0.00215, "epss_percentile": 0.44092}, "CVE-2021-38872": {"epss_score": 0.00454, "epss_percentile": 0.63258}, "CVE-2021-38873": {"epss_score": 0.00304, "epss_percentile": 0.53289}, "CVE-2021-38874": {"epss_score": 0.00156, "epss_percentile": 0.36883}, "CVE-2021-38875": {"epss_score": 0.00198, "epss_percentile": 0.42014}, "CVE-2021-38876": {"epss_score": 0.00225, "epss_percentile": 0.45223}, "CVE-2021-38877": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-38878": {"epss_score": 0.00205, "epss_percentile": 0.42763}, "CVE-2021-38879": {"epss_score": 0.00192, "epss_percentile": 0.41304}, "CVE-2021-38882": {"epss_score": 0.0005, "epss_percentile": 0.15833}, "CVE-2021-38883": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-38886": {"epss_score": 0.0018, "epss_percentile": 0.39921}, "CVE-2021-38887": {"epss_score": 0.00162, "epss_percentile": 0.3766}, "CVE-2021-38890": {"epss_score": 0.00186, "epss_percentile": 0.40665}, "CVE-2021-38891": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2021-38893": {"epss_score": 0.00216, "epss_percentile": 0.44219}, "CVE-2021-38894": {"epss_score": 0.00094, "epss_percentile": 0.26966}, "CVE-2021-38895": {"epss_score": 0.00346, "epss_percentile": 0.56621}, "CVE-2021-38896": {"epss_score": 0.00166, "epss_percentile": 0.38177}, "CVE-2021-38899": {"epss_score": 0.00046, "epss_percentile": 0.14468}, "CVE-2021-38900": {"epss_score": 0.00247, "epss_percentile": 0.47849}, "CVE-2021-38901": {"epss_score": 0.0004, "epss_percentile": 0.11952}, "CVE-2021-38903": {"epss_score": 0.00145, "epss_percentile": 0.3535}, "CVE-2021-38904": {"epss_score": 0.00274, "epss_percentile": 0.50537}, "CVE-2021-38905": {"epss_score": 0.00172, "epss_percentile": 0.39008}, "CVE-2021-38909": {"epss_score": 0.00229, "epss_percentile": 0.45551}, "CVE-2021-38910": {"epss_score": 0.00249, "epss_percentile": 0.48011}, "CVE-2021-38911": {"epss_score": 0.0008, "epss_percentile": 0.24089}, "CVE-2021-38915": {"epss_score": 0.00114, "epss_percentile": 0.30759}, "CVE-2021-38917": {"epss_score": 0.00174, "epss_percentile": 0.3922}, "CVE-2021-38918": {"epss_score": 0.00206, "epss_percentile": 0.43047}, "CVE-2021-38919": {"epss_score": 0.00275, "epss_percentile": 0.50678}, "CVE-2021-38921": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2021-38923": {"epss_score": 0.00273, "epss_percentile": 0.50449}, "CVE-2021-38924": {"epss_score": 0.00264, "epss_percentile": 0.4968}, "CVE-2021-38925": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2021-38926": {"epss_score": 0.0009, "epss_percentile": 0.25996}, "CVE-2021-38927": {"epss_score": 0.00072, "epss_percentile": 0.22472}, "CVE-2021-38928": {"epss_score": 0.00287, "epss_percentile": 0.51842}, "CVE-2021-38929": {"epss_score": 0.00228, "epss_percentile": 0.4553}, "CVE-2021-38930": {"epss_score": 0.00247, "epss_percentile": 0.4783}, "CVE-2021-38931": {"epss_score": 0.0027, "epss_percentile": 0.50208}, "CVE-2021-38933": {"epss_score": 0.00029, "epss_percentile": 0.07763}, "CVE-2021-38934": {"epss_score": 0.00377, "epss_percentile": 0.58746}, "CVE-2021-38935": {"epss_score": 0.00176, "epss_percentile": 0.39487}, "CVE-2021-38936": {"epss_score": 0.00189, "epss_percentile": 0.40952}, "CVE-2021-38937": {"epss_score": 0.00198, "epss_percentile": 0.42051}, "CVE-2021-38938": {"epss_score": 0.00024, "epss_percentile": 0.05858}, "CVE-2021-38939": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2021-38941": {"epss_score": 0.00133, "epss_percentile": 0.33695}, "CVE-2021-38944": {"epss_score": 0.00213, "epss_percentile": 0.43922}, "CVE-2021-38945": {"epss_score": 0.00228, "epss_percentile": 0.45484}, "CVE-2021-38946": {"epss_score": 0.00498, "epss_percentile": 0.65242}, "CVE-2021-38947": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2021-38948": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2021-38949": {"epss_score": 0.00054, "epss_percentile": 0.17078}, "CVE-2021-38950": {"epss_score": 0.00047, "epss_percentile": 0.14778}, "CVE-2021-38951": {"epss_score": 0.00426, "epss_percentile": 0.61746}, "CVE-2021-38952": {"epss_score": 0.00215, "epss_percentile": 0.44092}, "CVE-2021-38954": {"epss_score": 0.00119, "epss_percentile": 0.31619}, "CVE-2021-38955": {"epss_score": 0.00039, "epss_percentile": 0.11581}, "CVE-2021-38956": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2021-38957": {"epss_score": 0.00209, "epss_percentile": 0.43316}, "CVE-2021-38958": {"epss_score": 0.00045, "epss_percentile": 0.13734}, "CVE-2021-38959": {"epss_score": 0.00038, "epss_percentile": 0.11312}, "CVE-2021-38960": {"epss_score": 0.00223, "epss_percentile": 0.44852}, "CVE-2021-38961": {"epss_score": 0.00131, "epss_percentile": 0.33423}, "CVE-2021-38963": {"epss_score": 0.00288, "epss_percentile": 0.51926}, "CVE-2021-38965": {"epss_score": 0.02314, "epss_percentile": 0.84351}, "CVE-2021-38966": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-38967": {"epss_score": 0.00044, "epss_percentile": 0.13386}, "CVE-2021-38969": {"epss_score": 0.00189, "epss_percentile": 0.40957}, "CVE-2021-38971": {"epss_score": 0.00189, "epss_percentile": 0.40992}, "CVE-2021-38972": {"epss_score": 0.00174, "epss_percentile": 0.3916}, "CVE-2021-38973": {"epss_score": 0.00178, "epss_percentile": 0.3972}, "CVE-2021-38974": {"epss_score": 0.00236, "epss_percentile": 0.46417}, "CVE-2021-38975": {"epss_score": 0.00099, "epss_percentile": 0.28389}, "CVE-2021-38976": {"epss_score": 0.00038, "epss_percentile": 0.11077}, "CVE-2021-38977": {"epss_score": 0.00133, "epss_percentile": 0.33639}, "CVE-2021-38978": {"epss_score": 0.00078, "epss_percentile": 0.23761}, "CVE-2021-38979": {"epss_score": 0.00088, "epss_percentile": 0.25742}, "CVE-2021-38980": {"epss_score": 0.0017, "epss_percentile": 0.38751}, "CVE-2021-38981": {"epss_score": 0.00124, "epss_percentile": 0.32345}, "CVE-2021-38982": {"epss_score": 0.00158, "epss_percentile": 0.37281}, "CVE-2021-38983": {"epss_score": 0.00102, "epss_percentile": 0.28873}, "CVE-2021-38984": {"epss_score": 0.00097, "epss_percentile": 0.27621}, "CVE-2021-38985": {"epss_score": 0.00174, "epss_percentile": 0.3916}, "CVE-2021-38986": {"epss_score": 0.00094, "epss_percentile": 0.26803}, "CVE-2021-38988": {"epss_score": 0.00041, "epss_percentile": 0.12404}, "CVE-2021-38989": {"epss_score": 0.00041, "epss_percentile": 0.12404}, "CVE-2021-38990": {"epss_score": 0.00103, "epss_percentile": 0.29067}, "CVE-2021-38991": {"epss_score": 0.00081, "epss_percentile": 0.24325}, "CVE-2021-38993": {"epss_score": 0.00038, "epss_percentile": 0.11312}, "CVE-2021-38994": {"epss_score": 0.00043, "epss_percentile": 0.13127}, "CVE-2021-38995": {"epss_score": 0.00043, "epss_percentile": 0.13127}, "CVE-2021-38996": {"epss_score": 0.00043, "epss_percentile": 0.13127}, "CVE-2021-38997": {"epss_score": 0.00297, "epss_percentile": 0.52743}, "CVE-2021-38999": {"epss_score": 0.0004, "epss_percentile": 0.11952}, "CVE-2021-39000": {"epss_score": 0.00097, "epss_percentile": 0.27454}, "CVE-2021-39002": {"epss_score": 0.00179, "epss_percentile": 0.39851}, "CVE-2021-39006": {"epss_score": 0.0014, "epss_percentile": 0.34772}, "CVE-2021-39008": {"epss_score": 0.00058, "epss_percentile": 0.18388}, "CVE-2021-39009": {"epss_score": 0.00059, "epss_percentile": 0.18876}, "CVE-2021-39011": {"epss_score": 0.00069, "epss_percentile": 0.21592}, "CVE-2021-39013": {"epss_score": 0.00162, "epss_percentile": 0.3766}, "CVE-2021-39014": {"epss_score": 0.00135, "epss_percentile": 0.34016}, "CVE-2021-39015": {"epss_score": 0.00121, "epss_percentile": 0.32005}, "CVE-2021-39016": {"epss_score": 0.00145, "epss_percentile": 0.35406}, "CVE-2021-39017": {"epss_score": 0.00112, "epss_percentile": 0.30529}, "CVE-2021-39018": {"epss_score": 0.00126, "epss_percentile": 0.32732}, "CVE-2021-39019": {"epss_score": 0.00186, "epss_percentile": 0.40618}, "CVE-2021-39020": {"epss_score": 0.0008, "epss_percentile": 0.24142}, "CVE-2021-39021": {"epss_score": 0.00088, "epss_percentile": 0.25643}, "CVE-2021-39022": {"epss_score": 0.00101, "epss_percentile": 0.28682}, "CVE-2021-39023": {"epss_score": 0.00133, "epss_percentile": 0.33672}, "CVE-2021-39024": {"epss_score": 0.00065, "epss_percentile": 0.20443}, "CVE-2021-39025": {"epss_score": 0.00075, "epss_percentile": 0.23057}, "CVE-2021-39026": {"epss_score": 0.00056, "epss_percentile": 0.17703}, "CVE-2021-39027": {"epss_score": 0.00096, "epss_percentile": 0.27343}, "CVE-2021-39028": {"epss_score": 0.00221, "epss_percentile": 0.44652}, "CVE-2021-39031": {"epss_score": 0.00184, "epss_percentile": 0.40407}, "CVE-2021-39032": {"epss_score": 0.00038, "epss_percentile": 0.11137}, "CVE-2021-39033": {"epss_score": 0.00145, "epss_percentile": 0.35413}, "CVE-2021-39034": {"epss_score": 0.00094, "epss_percentile": 0.26789}, "CVE-2021-39035": {"epss_score": 0.00121, "epss_percentile": 0.32005}, "CVE-2021-39036": {"epss_score": 0.00153, "epss_percentile": 0.36621}, "CVE-2021-39038": {"epss_score": 0.00037, "epss_percentile": 0.10772}, "CVE-2021-39040": {"epss_score": 0.00177, "epss_percentile": 0.3954}, "CVE-2021-39041": {"epss_score": 0.00363, "epss_percentile": 0.5787}, "CVE-2021-39043": {"epss_score": 0.0027, "epss_percentile": 0.50224}, "CVE-2021-39044": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2021-39045": {"epss_score": 0.00129, "epss_percentile": 0.33124}, "CVE-2021-39046": {"epss_score": 0.00145, "epss_percentile": 0.35507}, "CVE-2021-39047": {"epss_score": 0.00215, "epss_percentile": 0.4404}, "CVE-2021-39048": {"epss_score": 0.00064, "epss_percentile": 0.20253}, "CVE-2021-39049": {"epss_score": 0.00062, "epss_percentile": 0.19662}, "CVE-2021-39050": {"epss_score": 0.00062, "epss_percentile": 0.19662}, "CVE-2021-39051": {"epss_score": 0.00117, "epss_percentile": 0.31266}, "CVE-2021-39052": {"epss_score": 0.00506, "epss_percentile": 0.65626}, "CVE-2021-39053": {"epss_score": 0.00183, "epss_percentile": 0.4028}, "CVE-2021-39054": {"epss_score": 0.0008, "epss_percentile": 0.2412}, "CVE-2021-39055": {"epss_score": 0.00215, "epss_percentile": 0.44092}, "CVE-2021-39056": {"epss_score": 0.00278, "epss_percentile": 0.50885}, "CVE-2021-39057": {"epss_score": 0.00121, "epss_percentile": 0.31828}, "CVE-2021-39058": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2021-39059": {"epss_score": 0.00215, "epss_percentile": 0.44092}, "CVE-2021-39063": {"epss_score": 0.00082, "epss_percentile": 0.24435}, "CVE-2021-39064": {"epss_score": 0.00163, "epss_percentile": 0.37808}, "CVE-2021-39065": {"epss_score": 0.04189, "epss_percentile": 0.88369}, "CVE-2021-39066": {"epss_score": 0.00179, "epss_percentile": 0.39845}, "CVE-2021-39068": {"epss_score": 0.00215, "epss_percentile": 0.44092}, "CVE-2021-39070": {"epss_score": 0.00671, "epss_percentile": 0.70802}, "CVE-2021-39072": {"epss_score": 0.00223, "epss_percentile": 0.44883}, "CVE-2021-39074": {"epss_score": 0.00131, "epss_percentile": 0.33423}, "CVE-2021-39076": {"epss_score": 0.00097, "epss_percentile": 0.27621}, "CVE-2021-39077": {"epss_score": 0.00021, "epss_percentile": 0.04779}, "CVE-2021-39078": {"epss_score": 0.00024, "epss_percentile": 0.05676}, "CVE-2021-39079": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2021-39080": {"epss_score": 0.00136, "epss_percentile": 0.34145}, "CVE-2021-39081": {"epss_score": 0.00046, "epss_percentile": 0.14186}, "CVE-2021-39082": {"epss_score": 0.00135, "epss_percentile": 0.34043}, "CVE-2021-39085": {"epss_score": 0.00227, "epss_percentile": 0.45419}, "CVE-2021-39086": {"epss_score": 0.00097, "epss_percentile": 0.27579}, "CVE-2021-39087": {"epss_score": 0.00124, "epss_percentile": 0.3244}, "CVE-2021-39088": {"epss_score": 0.00048, "epss_percentile": 0.1522}, "CVE-2021-39089": {"epss_score": 0.00125, "epss_percentile": 0.32476}, "CVE-2021-39090": {"epss_score": 0.00014, "epss_percentile": 0.0198}, "CVE-2021-39109": {"epss_score": 0.00476, "epss_percentile": 0.64262}, "CVE-2021-39111": {"epss_score": 0.00344, "epss_percentile": 0.56484}, "CVE-2021-39112": {"epss_score": 0.00197, "epss_percentile": 0.41887}, "CVE-2021-39113": {"epss_score": 0.00314, "epss_percentile": 0.54109}, "CVE-2021-39114": {"epss_score": 0.00361, "epss_percentile": 0.57747}, "CVE-2021-39115": {"epss_score": 0.25738, "epss_percentile": 0.96061}, "CVE-2021-39116": {"epss_score": 0.00252, "epss_percentile": 0.48409}, "CVE-2021-39117": {"epss_score": 0.00215, "epss_percentile": 0.44079}, "CVE-2021-39118": {"epss_score": 0.00592, "epss_percentile": 0.68626}, "CVE-2021-39119": {"epss_score": 0.00185, "epss_percentile": 0.40554}, "CVE-2021-39121": {"epss_score": 0.00235, "epss_percentile": 0.46321}, "CVE-2021-39122": {"epss_score": 0.00284, "epss_percentile": 0.51434}, "CVE-2021-39123": {"epss_score": 0.00803, "epss_percentile": 0.73603}, "CVE-2021-39124": {"epss_score": 0.0017, "epss_percentile": 0.38681}, "CVE-2021-39125": {"epss_score": 0.00284, "epss_percentile": 0.51434}, "CVE-2021-39126": {"epss_score": 0.00196, "epss_percentile": 0.41778}, "CVE-2021-39127": {"epss_score": 0.00292, "epss_percentile": 0.52234}, "CVE-2021-39128": {"epss_score": 0.00832, "epss_percentile": 0.74074}, "CVE-2021-39131": {"epss_score": 0.00446, "epss_percentile": 0.62905}, "CVE-2021-39132": {"epss_score": 0.00481, "epss_percentile": 0.64494}, "CVE-2021-39133": {"epss_score": 0.00147, "epss_percentile": 0.35679}, "CVE-2021-39134": {"epss_score": 0.01288, "epss_percentile": 0.792}, "CVE-2021-39135": {"epss_score": 0.00211, "epss_percentile": 0.43625}, "CVE-2021-39136": {"epss_score": 0.0054, "epss_percentile": 0.66991}, "CVE-2021-39137": {"epss_score": 0.00289, "epss_percentile": 0.5204}, "CVE-2021-39138": {"epss_score": 0.00218, "epss_percentile": 0.44376}, "CVE-2021-39139": {"epss_score": 0.00842, "epss_percentile": 0.7424}, "CVE-2021-39140": {"epss_score": 0.00038, "epss_percentile": 0.11217}, "CVE-2021-39141": {"epss_score": 0.84542, "epss_percentile": 0.99294}, "CVE-2021-39143": {"epss_score": 0.00088, "epss_percentile": 0.25662}, "CVE-2021-39144": {"epss_score": 0.9438, "epss_percentile": 0.99965}, "CVE-2021-39145": {"epss_score": 0.005, "epss_percentile": 0.65288}, "CVE-2021-39146": {"epss_score": 0.54176, "epss_percentile": 0.97914}, "CVE-2021-39147": {"epss_score": 0.00573, "epss_percentile": 0.6804}, "CVE-2021-39148": {"epss_score": 0.00573, "epss_percentile": 0.6804}, "CVE-2021-39149": {"epss_score": 0.00712, "epss_percentile": 0.71752}, "CVE-2021-39150": {"epss_score": 0.01965, "epss_percentile": 0.83079}, "CVE-2021-39151": {"epss_score": 0.00573, "epss_percentile": 0.6804}, "CVE-2021-39152": {"epss_score": 0.67834, "epss_percentile": 0.98522}, "CVE-2021-39153": {"epss_score": 0.00573, "epss_percentile": 0.6804}, "CVE-2021-39154": {"epss_score": 0.00712, "epss_percentile": 0.71752}, "CVE-2021-39155": {"epss_score": 0.00171, "epss_percentile": 0.38891}, "CVE-2021-39156": {"epss_score": 0.00236, "epss_percentile": 0.4636}, "CVE-2021-39157": {"epss_score": 0.00528, "epss_percentile": 0.66557}, "CVE-2021-39158": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2021-39159": {"epss_score": 0.01322, "epss_percentile": 0.79453}, "CVE-2021-39160": {"epss_score": 0.00825, "epss_percentile": 0.73955}, "CVE-2021-39161": {"epss_score": 0.00256, "epss_percentile": 0.48798}, "CVE-2021-39162": {"epss_score": 0.00668, "epss_percentile": 0.70729}, "CVE-2021-39163": {"epss_score": 0.00272, "epss_percentile": 0.50362}, "CVE-2021-39164": {"epss_score": 0.00485, "epss_percentile": 0.64734}, "CVE-2021-39165": {"epss_score": 0.8938, "epss_percentile": 0.99523}, "CVE-2021-39166": {"epss_score": 0.00011, "epss_percentile": 0.01006}, "CVE-2021-39167": {"epss_score": 0.00443, "epss_percentile": 0.62773}, "CVE-2021-39168": {"epss_score": 0.00443, "epss_percentile": 0.62773}, "CVE-2021-39169": {"epss_score": 0.0032, "epss_percentile": 0.54638}, "CVE-2021-39170": {"epss_score": 0.00015, "epss_percentile": 0.02433}, "CVE-2021-39171": {"epss_score": 0.00467, "epss_percentile": 0.63848}, "CVE-2021-39172": {"epss_score": 0.57084, "epss_percentile": 0.98048}, "CVE-2021-39173": {"epss_score": 0.0171, "epss_percentile": 0.81875}, "CVE-2021-39174": {"epss_score": 0.45357, "epss_percentile": 0.97483}, "CVE-2021-39175": {"epss_score": 0.00288, "epss_percentile": 0.51952}, "CVE-2021-39176": {"epss_score": 0.00615, "epss_percentile": 0.69297}, "CVE-2021-39177": {"epss_score": 0.00352, "epss_percentile": 0.57125}, "CVE-2021-39178": {"epss_score": 0.007, "epss_percentile": 0.71485}, "CVE-2021-39179": {"epss_score": 0.00727, "epss_percentile": 0.72083}, "CVE-2021-39180": {"epss_score": 0.01222, "epss_percentile": 0.78655}, "CVE-2021-39181": {"epss_score": 0.00546, "epss_percentile": 0.6722}, "CVE-2021-39182": {"epss_score": 0.00079, "epss_percentile": 0.23981}, "CVE-2021-39183": {"epss_score": 0.00326, "epss_percentile": 0.55048}, "CVE-2021-39184": {"epss_score": 0.00366, "epss_percentile": 0.58062}, "CVE-2021-39185": {"epss_score": 0.00169, "epss_percentile": 0.38616}, "CVE-2021-39186": {"epss_score": 0.00305, "epss_percentile": 0.5334}, "CVE-2021-39187": {"epss_score": 0.0066, "epss_percentile": 0.70535}, "CVE-2021-39189": {"epss_score": 0.00013, "epss_percentile": 0.01681}, "CVE-2021-39190": {"epss_score": 0.00195, "epss_percentile": 0.41662}, "CVE-2021-39191": {"epss_score": 0.00342, "epss_percentile": 0.56356}, "CVE-2021-39192": {"epss_score": 0.00394, "epss_percentile": 0.59779}, "CVE-2021-39193": {"epss_score": 0.00292, "epss_percentile": 0.52253}, "CVE-2021-39194": {"epss_score": 0.00485, "epss_percentile": 0.64725}, "CVE-2021-39195": {"epss_score": 0.00239, "epss_percentile": 0.4691}, "CVE-2021-39196": {"epss_score": 0.00208, "epss_percentile": 0.43302}, "CVE-2021-39197": {"epss_score": 0.00212, "epss_percentile": 0.43795}, "CVE-2021-39198": {"epss_score": 0.00106, "epss_percentile": 0.29534}, "CVE-2021-39199": {"epss_score": 0.00329, "epss_percentile": 0.55309}, "CVE-2021-39200": {"epss_score": 0.01767, "epss_percentile": 0.82173}, "CVE-2021-39201": {"epss_score": 0.00378, "epss_percentile": 0.588}, "CVE-2021-39202": {"epss_score": 0.00817, "epss_percentile": 0.7385}, "CVE-2021-39203": {"epss_score": 0.00701, "epss_percentile": 0.71494}, "CVE-2021-39204": {"epss_score": 0.00407, "epss_percentile": 0.60592}, "CVE-2021-39205": {"epss_score": 0.00285, "epss_percentile": 0.51514}, "CVE-2021-39206": {"epss_score": 0.00162, "epss_percentile": 0.37734}, "CVE-2021-39207": {"epss_score": 0.01351, "epss_percentile": 0.79683}, "CVE-2021-39208": {"epss_score": 0.00432, "epss_percentile": 0.6211}, "CVE-2021-39209": {"epss_score": 0.00137, "epss_percentile": 0.34283}, "CVE-2021-39210": {"epss_score": 0.00266, "epss_percentile": 0.49876}, "CVE-2021-39211": {"epss_score": 0.54404, "epss_percentile": 0.97924}, "CVE-2021-39212": {"epss_score": 0.00018, "epss_percentile": 0.03924}, "CVE-2021-39213": {"epss_score": 0.00351, "epss_percentile": 0.57041}, "CVE-2021-39214": {"epss_score": 0.00193, "epss_percentile": 0.41385}, "CVE-2021-39215": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2021-39216": {"epss_score": 0.00152, "epss_percentile": 0.36504}, "CVE-2021-39217": {"epss_score": 0.00272, "epss_percentile": 0.50371}, "CVE-2021-39218": {"epss_score": 0.00183, "epss_percentile": 0.40288}, "CVE-2021-39219": {"epss_score": 0.00074, "epss_percentile": 0.22781}, "CVE-2021-39220": {"epss_score": 0.00264, "epss_percentile": 0.49714}, "CVE-2021-39221": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2021-39222": {"epss_score": 0.00425, "epss_percentile": 0.6169}, "CVE-2021-39223": {"epss_score": 0.0035, "epss_percentile": 0.56945}, "CVE-2021-39224": {"epss_score": 0.00211, "epss_percentile": 0.43648}, "CVE-2021-39225": {"epss_score": 0.00269, "epss_percentile": 0.50171}, "CVE-2021-39226": {"epss_score": 0.9435, "epss_percentile": 0.99955}, "CVE-2021-39227": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2021-39228": {"epss_score": 0.00552, "epss_percentile": 0.67395}, "CVE-2021-39229": {"epss_score": 0.00446, "epss_percentile": 0.62905}, "CVE-2021-39230": {"epss_score": 0.00214, "epss_percentile": 0.43998}, "CVE-2021-39231": {"epss_score": 0.01238, "epss_percentile": 0.78793}, "CVE-2021-39232": {"epss_score": 0.00713, "epss_percentile": 0.71797}, "CVE-2021-39233": {"epss_score": 0.01174, "epss_percentile": 0.78251}, "CVE-2021-39234": {"epss_score": 0.00199, "epss_percentile": 0.42184}, "CVE-2021-39235": {"epss_score": 0.00367, "epss_percentile": 0.58122}, "CVE-2021-39236": {"epss_score": 0.00638, "epss_percentile": 0.69909}, "CVE-2021-39237": {"epss_score": 0.01094, "epss_percentile": 0.7749}, "CVE-2021-39238": {"epss_score": 0.05355, "epss_percentile": 0.89778}, "CVE-2021-39239": {"epss_score": 0.0032, "epss_percentile": 0.54576}, "CVE-2021-39240": {"epss_score": 0.00066, "epss_percentile": 0.20678}, "CVE-2021-39241": {"epss_score": 0.00444, "epss_percentile": 0.62835}, "CVE-2021-39242": {"epss_score": 0.00467, "epss_percentile": 0.63857}, "CVE-2021-39243": {"epss_score": 0.0012, "epss_percentile": 0.31697}, "CVE-2021-39244": {"epss_score": 0.1324, "epss_percentile": 0.93909}, "CVE-2021-39245": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2021-39246": {"epss_score": 0.00108, "epss_percentile": 0.29798}, "CVE-2021-39247": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2021-39248": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-39249": {"epss_score": 0.00335, "epss_percentile": 0.55796}, "CVE-2021-39250": {"epss_score": 0.00455, "epss_percentile": 0.63303}, "CVE-2021-39251": {"epss_score": 0.00022, "epss_percentile": 0.04981}, "CVE-2021-39252": {"epss_score": 0.00019, "epss_percentile": 0.04408}, "CVE-2021-39253": {"epss_score": 0.00021, "epss_percentile": 0.04857}, "CVE-2021-39254": {"epss_score": 0.00021, "epss_percentile": 0.04712}, "CVE-2021-39255": {"epss_score": 0.00025, "epss_percentile": 0.06359}, "CVE-2021-39256": {"epss_score": 0.00027, "epss_percentile": 0.06816}, "CVE-2021-39257": {"epss_score": 0.00044, "epss_percentile": 0.1343}, "CVE-2021-39258": {"epss_score": 0.00025, "epss_percentile": 0.06359}, "CVE-2021-39259": {"epss_score": 0.00025, "epss_percentile": 0.06359}, "CVE-2021-39260": {"epss_score": 0.00028, "epss_percentile": 0.07243}, "CVE-2021-39261": {"epss_score": 0.00027, "epss_percentile": 0.06816}, "CVE-2021-39262": {"epss_score": 0.00028, "epss_percentile": 0.07243}, "CVE-2021-39263": {"epss_score": 0.00027, "epss_percentile": 0.06816}, "CVE-2021-39267": {"epss_score": 0.00723, "epss_percentile": 0.72023}, "CVE-2021-39268": {"epss_score": 0.00411, "epss_percentile": 0.60905}, "CVE-2021-39270": {"epss_score": 0.00111, "epss_percentile": 0.30313}, "CVE-2021-39271": {"epss_score": 0.03984, "epss_percentile": 0.88063}, "CVE-2021-39272": {"epss_score": 0.00182, "epss_percentile": 0.40276}, "CVE-2021-39273": {"epss_score": 0.0166, "epss_percentile": 0.81619}, "CVE-2021-39274": {"epss_score": 0.00684, "epss_percentile": 0.71117}, "CVE-2021-39275": {"epss_score": 0.46965, "epss_percentile": 0.97564}, "CVE-2021-39278": {"epss_score": 0.00262, "epss_percentile": 0.49361}, "CVE-2021-39279": {"epss_score": 0.05887, "epss_percentile": 0.90295}, "CVE-2021-39280": {"epss_score": 0.01309, "epss_percentile": 0.79357}, "CVE-2021-39282": {"epss_score": 0.00296, "epss_percentile": 0.52533}, "CVE-2021-39283": {"epss_score": 0.00212, "epss_percentile": 0.4375}, "CVE-2021-39285": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-39286": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-39289": {"epss_score": 0.00172, "epss_percentile": 0.38976}, "CVE-2021-39290": {"epss_score": 0.0051, "epss_percentile": 0.658}, "CVE-2021-39291": {"epss_score": 0.00615, "epss_percentile": 0.69308}, "CVE-2021-39293": {"epss_score": 0.00039, "epss_percentile": 0.11608}, "CVE-2021-39295": {"epss_score": 0.00162, "epss_percentile": 0.37646}, "CVE-2021-39296": {"epss_score": 0.00087, "epss_percentile": 0.25498}, "CVE-2021-39297": {"epss_score": 0.00567, "epss_percentile": 0.67843}, "CVE-2021-39298": {"epss_score": 0.00044, "epss_percentile": 0.13656}, "CVE-2021-39299": {"epss_score": 0.0006, "epss_percentile": 0.19157}, "CVE-2021-39300": {"epss_score": 0.0006, "epss_percentile": 0.19157}, "CVE-2021-39301": {"epss_score": 0.00254, "epss_percentile": 0.48568}, "CVE-2021-39302": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-39303": {"epss_score": 0.00731, "epss_percentile": 0.7217}, "CVE-2021-39304": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2021-39306": {"epss_score": 0.00615, "epss_percentile": 0.6929}, "CVE-2021-39307": {"epss_score": 0.00563, "epss_percentile": 0.6774}, "CVE-2021-39308": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-39309": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-39310": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-39311": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-39312": {"epss_score": 0.91056, "epss_percentile": 0.99617}, "CVE-2021-39313": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-39314": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-39315": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-39316": {"epss_score": 0.93526, "epss_percentile": 0.99815}, "CVE-2021-39317": {"epss_score": 0.01285, "epss_percentile": 0.79176}, "CVE-2021-39318": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-39319": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-39320": {"epss_score": 0.19664, "epss_percentile": 0.95222}, "CVE-2021-39321": {"epss_score": 0.01146, "epss_percentile": 0.77996}, "CVE-2021-39322": {"epss_score": 0.13873, "epss_percentile": 0.94082}, "CVE-2021-39325": {"epss_score": 0.00186, "epss_percentile": 0.40652}, "CVE-2021-39327": {"epss_score": 0.91276, "epss_percentile": 0.99631}, "CVE-2021-39328": {"epss_score": 0.00447, "epss_percentile": 0.62938}, "CVE-2021-39329": {"epss_score": 0.00668, "epss_percentile": 0.70738}, "CVE-2021-39332": {"epss_score": 0.00288, "epss_percentile": 0.51901}, "CVE-2021-39333": {"epss_score": 0.00294, "epss_percentile": 0.5242}, "CVE-2021-39334": {"epss_score": 0.00447, "epss_percentile": 0.62938}, "CVE-2021-39335": {"epss_score": 0.00409, "epss_percentile": 0.60702}, "CVE-2021-39336": {"epss_score": 0.00447, "epss_percentile": 0.62938}, "CVE-2021-39337": {"epss_score": 0.00409, "epss_percentile": 0.60702}, "CVE-2021-39338": {"epss_score": 0.00409, "epss_percentile": 0.60702}, "CVE-2021-39339": {"epss_score": 0.00216, "epss_percentile": 0.44238}, "CVE-2021-39340": {"epss_score": 0.00472, "epss_percentile": 0.64039}, "CVE-2021-39341": {"epss_score": 0.44317, "epss_percentile": 0.9743}, "CVE-2021-39342": {"epss_score": 0.00131, "epss_percentile": 0.33491}, "CVE-2021-39343": {"epss_score": 0.00568, "epss_percentile": 0.67903}, "CVE-2021-39344": {"epss_score": 0.00568, "epss_percentile": 0.67903}, "CVE-2021-39345": {"epss_score": 0.00409, "epss_percentile": 0.60702}, "CVE-2021-39346": {"epss_score": 0.00432, "epss_percentile": 0.62101}, "CVE-2021-39347": {"epss_score": 0.00135, "epss_percentile": 0.33993}, "CVE-2021-39348": {"epss_score": 0.00447, "epss_percentile": 0.62938}, "CVE-2021-39349": {"epss_score": 0.00906, "epss_percentile": 0.7525}, "CVE-2021-39350": {"epss_score": 0.16614, "epss_percentile": 0.94703}, "CVE-2021-39351": {"epss_score": 0.00608, "epss_percentile": 0.69083}, "CVE-2021-39352": {"epss_score": 0.75591, "epss_percentile": 0.98857}, "CVE-2021-39353": {"epss_score": 0.00086, "epss_percentile": 0.25412}, "CVE-2021-39354": {"epss_score": 0.0031, "epss_percentile": 0.53754}, "CVE-2021-39355": {"epss_score": 0.00568, "epss_percentile": 0.67903}, "CVE-2021-39356": {"epss_score": 0.00568, "epss_percentile": 0.67903}, "CVE-2021-39357": {"epss_score": 0.00447, "epss_percentile": 0.62938}, "CVE-2021-39358": {"epss_score": 0.00219, "epss_percentile": 0.44485}, "CVE-2021-39359": {"epss_score": 0.00158, "epss_percentile": 0.37183}, "CVE-2021-39360": {"epss_score": 0.00522, "epss_percentile": 0.6628}, "CVE-2021-39361": {"epss_score": 0.00107, "epss_percentile": 0.29645}, "CVE-2021-39362": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-39363": {"epss_score": 0.01359, "epss_percentile": 0.79738}, "CVE-2021-39364": {"epss_score": 0.00234, "epss_percentile": 0.46113}, "CVE-2021-39365": {"epss_score": 0.00248, "epss_percentile": 0.47954}, "CVE-2021-39367": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2021-39368": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-39369": {"epss_score": 0.00419, "epss_percentile": 0.61363}, "CVE-2021-39371": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2021-39373": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2021-39375": {"epss_score": 0.0032, "epss_percentile": 0.5459}, "CVE-2021-39376": {"epss_score": 0.00484, "epss_percentile": 0.64646}, "CVE-2021-39377": {"epss_score": 0.06999, "epss_percentile": 0.91173}, "CVE-2021-39378": {"epss_score": 0.25373, "epss_percentile": 0.96021}, "CVE-2021-39379": {"epss_score": 0.06999, "epss_percentile": 0.91173}, "CVE-2021-39383": {"epss_score": 0.06224, "epss_percentile": 0.90583}, "CVE-2021-39384": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2021-39390": {"epss_score": 0.0024, "epss_percentile": 0.47209}, "CVE-2021-39391": {"epss_score": 0.00241, "epss_percentile": 0.47291}, "CVE-2021-39392": {"epss_score": 0.03675, "epss_percentile": 0.87552}, "CVE-2021-39393": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2021-39394": {"epss_score": 0.00096, "epss_percentile": 0.27308}, "CVE-2021-39402": {"epss_score": 0.00886, "epss_percentile": 0.74949}, "CVE-2021-39404": {"epss_score": 0.00328, "epss_percentile": 0.55155}, "CVE-2021-39408": {"epss_score": 0.01321, "epss_percentile": 0.79442}, "CVE-2021-39409": {"epss_score": 0.13552, "epss_percentile": 0.93994}, "CVE-2021-39411": {"epss_score": 0.01665, "epss_percentile": 0.81649}, "CVE-2021-39412": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-39413": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2021-39416": {"epss_score": 0.00486, "epss_percentile": 0.64755}, "CVE-2021-39420": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-39421": {"epss_score": 0.00076, "epss_percentile": 0.23229}, "CVE-2021-39425": {"epss_score": 0.00086, "epss_percentile": 0.25349}, "CVE-2021-39426": {"epss_score": 0.00572, "epss_percentile": 0.68001}, "CVE-2021-39427": {"epss_score": 0.00331, "epss_percentile": 0.55525}, "CVE-2021-39428": {"epss_score": 0.0009, "epss_percentile": 0.26041}, "CVE-2021-39432": {"epss_score": 0.00153, "epss_percentile": 0.36585}, "CVE-2021-39433": {"epss_score": 0.81123, "epss_percentile": 0.99122}, "CVE-2021-39434": {"epss_score": 0.00265, "epss_percentile": 0.49825}, "CVE-2021-39458": {"epss_score": 0.00332, "epss_percentile": 0.55587}, "CVE-2021-39459": {"epss_score": 0.10059, "epss_percentile": 0.92835}, "CVE-2021-39473": {"epss_score": 0.00346, "epss_percentile": 0.56648}, "CVE-2021-39474": {"epss_score": 0.02453, "epss_percentile": 0.84793}, "CVE-2021-39480": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-39486": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-39491": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-39496": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-39497": {"epss_score": 0.01214, "epss_percentile": 0.78577}, "CVE-2021-39499": {"epss_score": 0.00405, "epss_percentile": 0.60486}, "CVE-2021-39500": {"epss_score": 0.0111, "epss_percentile": 0.77656}, "CVE-2021-39501": {"epss_score": 0.62491, "epss_percentile": 0.98295}, "CVE-2021-39503": {"epss_score": 0.03282, "epss_percentile": 0.86818}, "CVE-2021-39509": {"epss_score": 0.16338, "epss_percentile": 0.94632}, "CVE-2021-39510": {"epss_score": 0.06502, "epss_percentile": 0.90804}, "CVE-2021-39514": {"epss_score": 0.00257, "epss_percentile": 0.48943}, "CVE-2021-39515": {"epss_score": 0.00258, "epss_percentile": 0.49009}, "CVE-2021-39516": {"epss_score": 0.00258, "epss_percentile": 0.49009}, "CVE-2021-39517": {"epss_score": 0.00258, "epss_percentile": 0.49009}, "CVE-2021-39518": {"epss_score": 0.00273, "epss_percentile": 0.50437}, "CVE-2021-39519": {"epss_score": 0.00239, "epss_percentile": 0.46868}, "CVE-2021-39520": {"epss_score": 0.00239, "epss_percentile": 0.46868}, "CVE-2021-39521": {"epss_score": 0.00239, "epss_percentile": 0.46886}, "CVE-2021-39522": {"epss_score": 0.00385, "epss_percentile": 0.592}, "CVE-2021-39523": {"epss_score": 0.00239, "epss_percentile": 0.46886}, "CVE-2021-39525": {"epss_score": 0.00352, "epss_percentile": 0.57112}, "CVE-2021-39527": {"epss_score": 0.00352, "epss_percentile": 0.57112}, "CVE-2021-39528": {"epss_score": 0.00332, "epss_percentile": 0.55592}, "CVE-2021-39530": {"epss_score": 0.00385, "epss_percentile": 0.592}, "CVE-2021-39531": {"epss_score": 0.00412, "epss_percentile": 0.60931}, "CVE-2021-39532": {"epss_score": 0.00239, "epss_percentile": 0.46886}, "CVE-2021-39533": {"epss_score": 0.00412, "epss_percentile": 0.60931}, "CVE-2021-39534": {"epss_score": 0.00377, "epss_percentile": 0.58712}, "CVE-2021-39535": {"epss_score": 0.00258, "epss_percentile": 0.49009}, "CVE-2021-39536": {"epss_score": 0.00381, "epss_percentile": 0.58975}, "CVE-2021-39537": {"epss_score": 0.00397, "epss_percentile": 0.60016}, "CVE-2021-39538": {"epss_score": 0.00266, "epss_percentile": 0.4995}, "CVE-2021-39539": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-39540": {"epss_score": 0.00412, "epss_percentile": 0.60951}, "CVE-2021-39541": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-39542": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-39543": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-39544": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-39545": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-39546": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-39547": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-39548": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-39549": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-39550": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-39551": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-39552": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-39553": {"epss_score": 0.00186, "epss_percentile": 0.40585}, "CVE-2021-39554": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2021-39555": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39556": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39557": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2021-39558": {"epss_score": 0.00451, "epss_percentile": 0.63121}, "CVE-2021-39559": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2021-39561": {"epss_score": 0.00451, "epss_percentile": 0.63121}, "CVE-2021-39562": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2021-39563": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2021-39564": {"epss_score": 0.00446, "epss_percentile": 0.62896}, "CVE-2021-39569": {"epss_score": 0.00446, "epss_percentile": 0.62896}, "CVE-2021-39574": {"epss_score": 0.00451, "epss_percentile": 0.63121}, "CVE-2021-39575": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39577": {"epss_score": 0.00451, "epss_percentile": 0.63121}, "CVE-2021-39579": {"epss_score": 0.00451, "epss_percentile": 0.63121}, "CVE-2021-39582": {"epss_score": 0.00451, "epss_percentile": 0.63121}, "CVE-2021-39583": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39584": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2021-39585": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39587": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39588": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39589": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39590": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39591": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2021-39592": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39593": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2021-39594": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2021-39595": {"epss_score": 0.00451, "epss_percentile": 0.63121}, "CVE-2021-39596": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39597": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39598": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-39599": {"epss_score": 0.00201, "epss_percentile": 0.42343}, "CVE-2021-39602": {"epss_score": 0.00338, "epss_percentile": 0.56136}, "CVE-2021-39608": {"epss_score": 0.16897, "epss_percentile": 0.94744}, "CVE-2021-39609": {"epss_score": 0.00571, "epss_percentile": 0.67981}, "CVE-2021-39613": {"epss_score": 0.01301, "epss_percentile": 0.79291}, "CVE-2021-39614": {"epss_score": 0.01025, "epss_percentile": 0.7679}, "CVE-2021-39615": {"epss_score": 0.02272, "epss_percentile": 0.84219}, "CVE-2021-39616": {"epss_score": 0.00322, "epss_percentile": 0.54824}, "CVE-2021-39618": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-39619": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-39620": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2021-39621": {"epss_score": 9e-05, "epss_percentile": 0.00615}, "CVE-2021-39622": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-39623": {"epss_score": 0.02519, "epss_percentile": 0.84995}, "CVE-2021-39624": {"epss_score": 0.00015, "epss_percentile": 0.0233}, "CVE-2021-39625": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-39626": {"epss_score": 0.0002, "epss_percentile": 0.04438}, "CVE-2021-39627": {"epss_score": 9e-05, "epss_percentile": 0.00615}, "CVE-2021-39628": {"epss_score": 0.00015, "epss_percentile": 0.02311}, "CVE-2021-39629": {"epss_score": 0.0003, "epss_percentile": 0.08265}, "CVE-2021-39630": {"epss_score": 0.0001, "epss_percentile": 0.00853}, "CVE-2021-39631": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-39632": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-39633": {"epss_score": 0.00062, "epss_percentile": 0.19639}, "CVE-2021-39634": {"epss_score": 0.0002, "epss_percentile": 0.04584}, "CVE-2021-39635": {"epss_score": 0.00083, "epss_percentile": 0.24735}, "CVE-2021-39636": {"epss_score": 0.00047, "epss_percentile": 0.14477}, "CVE-2021-39637": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2021-39638": {"epss_score": 0.00017, "epss_percentile": 0.03274}, "CVE-2021-39639": {"epss_score": 0.00013, "epss_percentile": 0.01549}, "CVE-2021-39640": {"epss_score": 0.0001, "epss_percentile": 0.00812}, "CVE-2021-39641": {"epss_score": 0.00173, "epss_percentile": 0.39082}, "CVE-2021-39642": {"epss_score": 0.00011, "epss_percentile": 0.01089}, "CVE-2021-39643": {"epss_score": 0.00017, "epss_percentile": 0.03404}, "CVE-2021-39644": {"epss_score": 0.00173, "epss_percentile": 0.39082}, "CVE-2021-39645": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2021-39646": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2021-39647": {"epss_score": 0.00012, "epss_percentile": 0.0142}, "CVE-2021-39648": {"epss_score": 0.00048, "epss_percentile": 0.15247}, "CVE-2021-39649": {"epss_score": 0.00013, "epss_percentile": 0.01646}, "CVE-2021-39650": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2021-39651": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-39652": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-39653": {"epss_score": 0.00034, "epss_percentile": 0.09739}, "CVE-2021-39655": {"epss_score": 0.00173, "epss_percentile": 0.39082}, "CVE-2021-39656": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2021-39657": {"epss_score": 0.00025, "epss_percentile": 0.0631}, "CVE-2021-39658": {"epss_score": 0.00096, "epss_percentile": 0.27446}, "CVE-2021-39659": {"epss_score": 0.00015, "epss_percentile": 0.0233}, "CVE-2021-39660": {"epss_score": 0.00012, "epss_percentile": 0.01428}, "CVE-2021-39661": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2021-39662": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-39663": {"epss_score": 0.00011, "epss_percentile": 0.01062}, "CVE-2021-39664": {"epss_score": 0.00018, "epss_percentile": 0.03961}, "CVE-2021-39665": {"epss_score": 0.0038, "epss_percentile": 0.5891}, "CVE-2021-39666": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-39667": {"epss_score": 0.0038, "epss_percentile": 0.5891}, "CVE-2021-39668": {"epss_score": 0.00014, "epss_percentile": 0.01847}, "CVE-2021-39669": {"epss_score": 9e-05, "epss_percentile": 0.00632}, "CVE-2021-39670": {"epss_score": 0.00024, "epss_percentile": 0.06016}, "CVE-2021-39671": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2021-39672": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-39674": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2021-39675": {"epss_score": 0.05789, "epss_percentile": 0.90212}, "CVE-2021-39676": {"epss_score": 0.00012, "epss_percentile": 0.01429}, "CVE-2021-39677": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2021-39678": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-39679": {"epss_score": 0.00012, "epss_percentile": 0.01119}, "CVE-2021-39680": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2021-39681": {"epss_score": 0.00018, "epss_percentile": 0.03602}, "CVE-2021-39682": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-39683": {"epss_score": 0.00012, "epss_percentile": 0.01308}, "CVE-2021-39684": {"epss_score": 0.00046, "epss_percentile": 0.14111}, "CVE-2021-39685": {"epss_score": 0.0101, "epss_percentile": 0.76593}, "CVE-2021-39686": {"epss_score": 0.00017, "epss_percentile": 0.03441}, "CVE-2021-39687": {"epss_score": 0.00017, "epss_percentile": 0.03515}, "CVE-2021-39688": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-39689": {"epss_score": 6e-05, "epss_percentile": 0.00239}, "CVE-2021-39690": {"epss_score": 0.00012, "epss_percentile": 0.01306}, "CVE-2021-39691": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-39692": {"epss_score": 0.00052, "epss_percentile": 0.16357}, "CVE-2021-39693": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-39694": {"epss_score": 0.0001, "epss_percentile": 0.00853}, "CVE-2021-39695": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-39696": {"epss_score": 0.00016, "epss_percentile": 0.02751}, "CVE-2021-39697": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-39698": {"epss_score": 0.00033, "epss_percentile": 0.0931}, "CVE-2021-39700": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-39701": {"epss_score": 0.00038, "epss_percentile": 0.11392}, "CVE-2021-39702": {"epss_score": 0.00019, "epss_percentile": 0.04221}, "CVE-2021-39703": {"epss_score": 0.00013, "epss_percentile": 0.01592}, "CVE-2021-39704": {"epss_score": 0.00014, "epss_percentile": 0.02019}, "CVE-2021-39706": {"epss_score": 0.00052, "epss_percentile": 0.16357}, "CVE-2021-39707": {"epss_score": 0.00011, "epss_percentile": 0.01062}, "CVE-2021-39708": {"epss_score": 0.00632, "epss_percentile": 0.69739}, "CVE-2021-39709": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-39710": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2021-39711": {"epss_score": 0.00112, "epss_percentile": 0.30506}, "CVE-2021-39712": {"epss_score": 0.00011, "epss_percentile": 0.01089}, "CVE-2021-39713": {"epss_score": 0.00015, "epss_percentile": 0.02417}, "CVE-2021-39714": {"epss_score": 0.00031, "epss_percentile": 0.08657}, "CVE-2021-39715": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2021-39716": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2021-39717": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2021-39718": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2021-39719": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-39720": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2021-39721": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2021-39722": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2021-39723": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2021-39724": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2021-39725": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2021-39726": {"epss_score": 0.00289, "epss_percentile": 0.52017}, "CVE-2021-39727": {"epss_score": 0.00012, "epss_percentile": 0.0142}, "CVE-2021-39729": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2021-39730": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2021-39731": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2021-39732": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-39733": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-39734": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2021-39735": {"epss_score": 0.00013, "epss_percentile": 0.01522}, "CVE-2021-39736": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-39737": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2021-39738": {"epss_score": 0.00028, "epss_percentile": 0.07294}, "CVE-2021-39739": {"epss_score": 0.00015, "epss_percentile": 0.02311}, "CVE-2021-39740": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-39741": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-39742": {"epss_score": 0.00057, "epss_percentile": 0.18218}, "CVE-2021-39743": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-39744": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-39745": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-39746": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-39747": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2021-39748": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-39749": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-39750": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-39751": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2021-39752": {"epss_score": 0.00013, "epss_percentile": 0.01556}, "CVE-2021-39753": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-39754": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-39755": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-39756": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-39757": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-39758": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-39759": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-39760": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-39761": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-39762": {"epss_score": 0.00312, "epss_percentile": 0.53982}, "CVE-2021-39763": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-39764": {"epss_score": 0.00056, "epss_percentile": 0.17816}, "CVE-2021-39765": {"epss_score": 0.00035, "epss_percentile": 0.0994}, "CVE-2021-39766": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-39767": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-39768": {"epss_score": 0.00015, "epss_percentile": 0.02548}, "CVE-2021-39769": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2021-39770": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-39771": {"epss_score": 0.00056, "epss_percentile": 0.17816}, "CVE-2021-39772": {"epss_score": 0.00031, "epss_percentile": 0.08619}, "CVE-2021-39773": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-39774": {"epss_score": 0.00014, "epss_percentile": 0.02044}, "CVE-2021-39775": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-39776": {"epss_score": 0.00018, "epss_percentile": 0.03602}, "CVE-2021-39777": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-39778": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-39779": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2021-39780": {"epss_score": 0.00049, "epss_percentile": 0.15602}, "CVE-2021-39781": {"epss_score": 0.00013, "epss_percentile": 0.01556}, "CVE-2021-39782": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-39783": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-39784": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-39786": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2021-39787": {"epss_score": 0.0004, "epss_percentile": 0.11961}, "CVE-2021-39788": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2021-39789": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2021-39790": {"epss_score": 0.00049, "epss_percentile": 0.15602}, "CVE-2021-39791": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2021-39792": {"epss_score": 0.00016, "epss_percentile": 0.03017}, "CVE-2021-39793": {"epss_score": 0.00092, "epss_percentile": 0.26509}, "CVE-2021-39794": {"epss_score": 0.00034, "epss_percentile": 0.09549}, "CVE-2021-39796": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-39797": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-39798": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2021-39799": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-39800": {"epss_score": 0.00037, "epss_percentile": 0.10971}, "CVE-2021-39801": {"epss_score": 0.00012, "epss_percentile": 0.01119}, "CVE-2021-39802": {"epss_score": 0.0001, "epss_percentile": 0.00853}, "CVE-2021-39803": {"epss_score": 0.00265, "epss_percentile": 0.49782}, "CVE-2021-39804": {"epss_score": 0.00127, "epss_percentile": 0.32828}, "CVE-2021-39805": {"epss_score": 0.00084, "epss_percentile": 0.25017}, "CVE-2021-39806": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2021-39807": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-39808": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2021-39809": {"epss_score": 0.00289, "epss_percentile": 0.52017}, "CVE-2021-39810": {"epss_score": 0.00016, "epss_percentile": 0.02935}, "CVE-2021-39812": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2021-39814": {"epss_score": 0.00033, "epss_percentile": 0.09321}, "CVE-2021-39815": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2021-39816": {"epss_score": 0.01627, "epss_percentile": 0.81431}, "CVE-2021-39817": {"epss_score": 0.01627, "epss_percentile": 0.81431}, "CVE-2021-39818": {"epss_score": 0.02855, "epss_percentile": 0.85837}, "CVE-2021-39819": {"epss_score": 0.02855, "epss_percentile": 0.85837}, "CVE-2021-39820": {"epss_score": 0.04653, "epss_percentile": 0.88965}, "CVE-2021-39821": {"epss_score": 0.02569, "epss_percentile": 0.85125}, "CVE-2021-39822": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2021-39823": {"epss_score": 0.23416, "epss_percentile": 0.95776}, "CVE-2021-39824": {"epss_score": 0.03829, "epss_percentile": 0.878}, "CVE-2021-39825": {"epss_score": 0.09446, "epss_percentile": 0.92551}, "CVE-2021-39826": {"epss_score": 0.02865, "epss_percentile": 0.85859}, "CVE-2021-39827": {"epss_score": 0.00838, "epss_percentile": 0.74175}, "CVE-2021-39828": {"epss_score": 0.01008, "epss_percentile": 0.76571}, "CVE-2021-39829": {"epss_score": 0.04154, "epss_percentile": 0.88325}, "CVE-2021-39830": {"epss_score": 0.05046, "epss_percentile": 0.89436}, "CVE-2021-39831": {"epss_score": 0.05535, "epss_percentile": 0.89971}, "CVE-2021-39832": {"epss_score": 0.05046, "epss_percentile": 0.89436}, "CVE-2021-39833": {"epss_score": 0.0143, "epss_percentile": 0.80233}, "CVE-2021-39834": {"epss_score": 0.0143, "epss_percentile": 0.80233}, "CVE-2021-39835": {"epss_score": 0.02077, "epss_percentile": 0.83513}, "CVE-2021-39836": {"epss_score": 0.56988, "epss_percentile": 0.98044}, "CVE-2021-39837": {"epss_score": 0.56988, "epss_percentile": 0.98044}, "CVE-2021-39838": {"epss_score": 0.56988, "epss_percentile": 0.98044}, "CVE-2021-39839": {"epss_score": 0.56988, "epss_percentile": 0.98044}, "CVE-2021-39840": {"epss_score": 0.56988, "epss_percentile": 0.98044}, "CVE-2021-39841": {"epss_score": 0.12188, "epss_percentile": 0.93598}, "CVE-2021-39842": {"epss_score": 0.56988, "epss_percentile": 0.98044}, "CVE-2021-39843": {"epss_score": 0.31328, "epss_percentile": 0.96611}, "CVE-2021-39844": {"epss_score": 0.0071, "epss_percentile": 0.71714}, "CVE-2021-39845": {"epss_score": 0.01021, "epss_percentile": 0.76745}, "CVE-2021-39846": {"epss_score": 0.01021, "epss_percentile": 0.76745}, "CVE-2021-39847": {"epss_score": 0.00261, "epss_percentile": 0.49312}, "CVE-2021-39849": {"epss_score": 0.01014, "epss_percentile": 0.76643}, "CVE-2021-39850": {"epss_score": 0.01014, "epss_percentile": 0.76643}, "CVE-2021-39851": {"epss_score": 0.01014, "epss_percentile": 0.76643}, "CVE-2021-39852": {"epss_score": 0.01014, "epss_percentile": 0.76643}, "CVE-2021-39853": {"epss_score": 0.01014, "epss_percentile": 0.76643}, "CVE-2021-39854": {"epss_score": 0.01014, "epss_percentile": 0.76643}, "CVE-2021-39855": {"epss_score": 0.02023, "epss_percentile": 0.83305}, "CVE-2021-39856": {"epss_score": 0.02023, "epss_percentile": 0.83305}, "CVE-2021-39857": {"epss_score": 0.01128, "epss_percentile": 0.77832}, "CVE-2021-39858": {"epss_score": 0.0071, "epss_percentile": 0.71714}, "CVE-2021-39859": {"epss_score": 0.00015, "epss_percentile": 0.02221}, "CVE-2021-39860": {"epss_score": 0.0175, "epss_percentile": 0.82095}, "CVE-2021-39861": {"epss_score": 0.01647, "epss_percentile": 0.81542}, "CVE-2021-39862": {"epss_score": 0.00933, "epss_percentile": 0.75633}, "CVE-2021-39863": {"epss_score": 0.22137, "epss_percentile": 0.95599}, "CVE-2021-39864": {"epss_score": 0.00863, "epss_percentile": 0.74592}, "CVE-2021-39865": {"epss_score": 0.00715, "epss_percentile": 0.71834}, "CVE-2021-39866": {"epss_score": 0.00261, "epss_percentile": 0.49302}, "CVE-2021-39867": {"epss_score": 0.00145, "epss_percentile": 0.35358}, "CVE-2021-39868": {"epss_score": 0.00293, "epss_percentile": 0.52298}, "CVE-2021-39869": {"epss_score": 0.00248, "epss_percentile": 0.47929}, "CVE-2021-39870": {"epss_score": 0.00123, "epss_percentile": 0.32199}, "CVE-2021-39871": {"epss_score": 0.00123, "epss_percentile": 0.32199}, "CVE-2021-39872": {"epss_score": 0.00215, "epss_percentile": 0.44089}, "CVE-2021-39873": {"epss_score": 0.00275, "epss_percentile": 0.50671}, "CVE-2021-39874": {"epss_score": 0.00253, "epss_percentile": 0.48435}, "CVE-2021-39875": {"epss_score": 0.00299, "epss_percentile": 0.52846}, "CVE-2021-39876": {"epss_score": 0.00236, "epss_percentile": 0.4646}, "CVE-2021-39877": {"epss_score": 0.00178, "epss_percentile": 0.39682}, "CVE-2021-39878": {"epss_score": 0.00185, "epss_percentile": 0.40483}, "CVE-2021-39879": {"epss_score": 0.00124, "epss_percentile": 0.32416}, "CVE-2021-39880": {"epss_score": 0.00399, "epss_percentile": 0.60133}, "CVE-2021-39881": {"epss_score": 0.00252, "epss_percentile": 0.48408}, "CVE-2021-39882": {"epss_score": 0.00102, "epss_percentile": 0.28765}, "CVE-2021-39883": {"epss_score": 0.002, "epss_percentile": 0.42253}, "CVE-2021-39884": {"epss_score": 0.00274, "epss_percentile": 0.50562}, "CVE-2021-39885": {"epss_score": 0.00217, "epss_percentile": 0.44243}, "CVE-2021-39886": {"epss_score": 0.00135, "epss_percentile": 0.34008}, "CVE-2021-39887": {"epss_score": 0.00202, "epss_percentile": 0.42439}, "CVE-2021-39888": {"epss_score": 0.00255, "epss_percentile": 0.48695}, "CVE-2021-39889": {"epss_score": 0.00245, "epss_percentile": 0.47665}, "CVE-2021-39890": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2021-39891": {"epss_score": 0.00114, "epss_percentile": 0.30752}, "CVE-2021-39892": {"epss_score": 0.00297, "epss_percentile": 0.52679}, "CVE-2021-39893": {"epss_score": 0.00395, "epss_percentile": 0.59804}, "CVE-2021-39894": {"epss_score": 0.00165, "epss_percentile": 0.38033}, "CVE-2021-39895": {"epss_score": 0.00281, "epss_percentile": 0.51146}, "CVE-2021-39896": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2021-39897": {"epss_score": 0.00289, "epss_percentile": 0.52026}, "CVE-2021-39898": {"epss_score": 0.00301, "epss_percentile": 0.52993}, "CVE-2021-39899": {"epss_score": 0.00073, "epss_percentile": 0.22486}, "CVE-2021-39900": {"epss_score": 0.00209, "epss_percentile": 0.43413}, "CVE-2021-39901": {"epss_score": 0.00293, "epss_percentile": 0.52294}, "CVE-2021-39902": {"epss_score": 0.00226, "epss_percentile": 0.45245}, "CVE-2021-39903": {"epss_score": 0.00254, "epss_percentile": 0.48624}, "CVE-2021-39904": {"epss_score": 0.00121, "epss_percentile": 0.32001}, "CVE-2021-39905": {"epss_score": 0.003, "epss_percentile": 0.52937}, "CVE-2021-39906": {"epss_score": 0.01183, "epss_percentile": 0.78325}, "CVE-2021-39907": {"epss_score": 0.00248, "epss_percentile": 0.47988}, "CVE-2021-39908": {"epss_score": 0.00299, "epss_percentile": 0.52888}, "CVE-2021-39909": {"epss_score": 0.00049, "epss_percentile": 0.15418}, "CVE-2021-39910": {"epss_score": 0.0018, "epss_percentile": 0.39891}, "CVE-2021-39911": {"epss_score": 0.00219, "epss_percentile": 0.44482}, "CVE-2021-39912": {"epss_score": 0.00248, "epss_percentile": 0.47988}, "CVE-2021-39913": {"epss_score": 0.0006, "epss_percentile": 0.19225}, "CVE-2021-39914": {"epss_score": 0.00176, "epss_percentile": 0.39457}, "CVE-2021-39915": {"epss_score": 0.00269, "epss_percentile": 0.50175}, "CVE-2021-39916": {"epss_score": 0.00281, "epss_percentile": 0.5118}, "CVE-2021-39917": {"epss_score": 0.00386, "epss_percentile": 0.59279}, "CVE-2021-39918": {"epss_score": 0.00226, "epss_percentile": 0.45245}, "CVE-2021-39919": {"epss_score": 0.00068, "epss_percentile": 0.21201}, "CVE-2021-39920": {"epss_score": 0.00525, "epss_percentile": 0.66394}, "CVE-2021-39921": {"epss_score": 0.01341, "epss_percentile": 0.79589}, "CVE-2021-39922": {"epss_score": 0.04999, "epss_percentile": 0.89376}, "CVE-2021-39923": {"epss_score": 0.0225, "epss_percentile": 0.84156}, "CVE-2021-39924": {"epss_score": 0.0145, "epss_percentile": 0.80356}, "CVE-2021-39925": {"epss_score": 0.04999, "epss_percentile": 0.89376}, "CVE-2021-39926": {"epss_score": 0.00942, "epss_percentile": 0.75766}, "CVE-2021-39927": {"epss_score": 0.00143, "epss_percentile": 0.35193}, "CVE-2021-39928": {"epss_score": 0.01455, "epss_percentile": 0.80387}, "CVE-2021-39929": {"epss_score": 0.00149, "epss_percentile": 0.36009}, "CVE-2021-39930": {"epss_score": 0.00245, "epss_percentile": 0.47665}, "CVE-2021-39931": {"epss_score": 0.00253, "epss_percentile": 0.48435}, "CVE-2021-39932": {"epss_score": 0.00222, "epss_percentile": 0.44735}, "CVE-2021-39933": {"epss_score": 0.00189, "epss_percentile": 0.40965}, "CVE-2021-39934": {"epss_score": 0.00248, "epss_percentile": 0.47987}, "CVE-2021-39935": {"epss_score": 0.2825, "epss_percentile": 0.96338}, "CVE-2021-39936": {"epss_score": 0.00342, "epss_percentile": 0.56397}, "CVE-2021-39937": {"epss_score": 0.00151, "epss_percentile": 0.36187}, "CVE-2021-39938": {"epss_score": 0.00138, "epss_percentile": 0.34405}, "CVE-2021-39939": {"epss_score": 0.00138, "epss_percentile": 0.34405}, "CVE-2021-39940": {"epss_score": 0.00189, "epss_percentile": 0.40965}, "CVE-2021-39941": {"epss_score": 0.00293, "epss_percentile": 0.52301}, "CVE-2021-39942": {"epss_score": 0.00204, "epss_percentile": 0.4266}, "CVE-2021-39943": {"epss_score": 0.00244, "epss_percentile": 0.47561}, "CVE-2021-39944": {"epss_score": 0.00176, "epss_percentile": 0.39426}, "CVE-2021-39945": {"epss_score": 0.00244, "epss_percentile": 0.47576}, "CVE-2021-39946": {"epss_score": 0.00307, "epss_percentile": 0.53526}, "CVE-2021-39947": {"epss_score": 0.00175, "epss_percentile": 0.39368}, "CVE-2021-39966": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-39967": {"epss_score": 0.00112, "epss_percentile": 0.30525}, "CVE-2021-39968": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-39969": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-39970": {"epss_score": 0.00158, "epss_percentile": 0.37291}, "CVE-2021-39971": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-39972": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-39973": {"epss_score": 0.0015, "epss_percentile": 0.36077}, "CVE-2021-39974": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-39975": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-39976": {"epss_score": 0.00019, "epss_percentile": 0.04075}, "CVE-2021-39977": {"epss_score": 0.00182, "epss_percentile": 0.40254}, "CVE-2021-39978": {"epss_score": 0.00271, "epss_percentile": 0.50332}, "CVE-2021-39979": {"epss_score": 0.00393, "epss_percentile": 0.59717}, "CVE-2021-39980": {"epss_score": 0.00111, "epss_percentile": 0.30275}, "CVE-2021-39981": {"epss_score": 0.00113, "epss_percentile": 0.30629}, "CVE-2021-39982": {"epss_score": 0.0011, "epss_percentile": 0.30128}, "CVE-2021-39983": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-39984": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-39985": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-39986": {"epss_score": 0.00028, "epss_percentile": 0.07471}, "CVE-2021-39987": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-39988": {"epss_score": 0.00182, "epss_percentile": 0.40254}, "CVE-2021-39989": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-39990": {"epss_score": 0.00254, "epss_percentile": 0.48568}, "CVE-2021-39991": {"epss_score": 0.00028, "epss_percentile": 0.07471}, "CVE-2021-39992": {"epss_score": 0.00023, "epss_percentile": 0.05509}, "CVE-2021-39993": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-39994": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-39995": {"epss_score": 0.00164, "epss_percentile": 0.37973}, "CVE-2021-39996": {"epss_score": 0.00236, "epss_percentile": 0.46359}, "CVE-2021-39997": {"epss_score": 0.00242, "epss_percentile": 0.47395}, "CVE-2021-39998": {"epss_score": 0.00149, "epss_percentile": 0.36022}, "CVE-2021-39999": {"epss_score": 0.00204, "epss_percentile": 0.42644}, "CVE-2021-3002": {"epss_score": 0.30353, "epss_percentile": 0.96534}, "CVE-2021-3003": {"epss_score": 0.00159, "epss_percentile": 0.37333}, "CVE-2021-3004": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2021-3005": {"epss_score": 0.00293, "epss_percentile": 0.52353}, "CVE-2021-3006": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2021-3007": {"epss_score": 0.91409, "epss_percentile": 0.99641}, "CVE-2021-3010": {"epss_score": 0.0012, "epss_percentile": 0.31702}, "CVE-2021-3011": {"epss_score": 0.00056, "epss_percentile": 0.17851}, "CVE-2021-3012": {"epss_score": 0.00142, "epss_percentile": 0.35013}, "CVE-2021-3013": {"epss_score": 0.0071, "epss_percentile": 0.71701}, "CVE-2021-3014": {"epss_score": 0.00576, "epss_percentile": 0.68146}, "CVE-2021-3017": {"epss_score": 0.68784, "epss_percentile": 0.98563}, "CVE-2021-3018": {"epss_score": 0.70481, "epss_percentile": 0.98634}, "CVE-2021-3019": {"epss_score": 0.92483, "epss_percentile": 0.99718}, "CVE-2021-3020": {"epss_score": 0.00401, "epss_percentile": 0.60214}, "CVE-2021-3021": {"epss_score": 0.00441, "epss_percentile": 0.62684}, "CVE-2021-3022": {"epss_score": 0.00018, "epss_percentile": 0.03704}, "CVE-2021-3024": {"epss_score": 0.00481, "epss_percentile": 0.64489}, "CVE-2021-3025": {"epss_score": 0.00482, "epss_percentile": 0.64527}, "CVE-2021-3026": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2021-3027": {"epss_score": 0.00319, "epss_percentile": 0.54472}, "CVE-2021-3028": {"epss_score": 0.0105, "epss_percentile": 0.77068}, "CVE-2021-3029": {"epss_score": 0.01, "epss_percentile": 0.7649}, "CVE-2021-3031": {"epss_score": 0.00088, "epss_percentile": 0.25736}, "CVE-2021-3032": {"epss_score": 0.00033, "epss_percentile": 0.09148}, "CVE-2021-3033": {"epss_score": 0.00111, "epss_percentile": 0.30381}, "CVE-2021-3034": {"epss_score": 0.00029, "epss_percentile": 0.07658}, "CVE-2021-3035": {"epss_score": 0.03376, "epss_percentile": 0.87019}, "CVE-2021-3036": {"epss_score": 0.00143, "epss_percentile": 0.35098}, "CVE-2021-3037": {"epss_score": 0.0007, "epss_percentile": 0.21637}, "CVE-2021-3038": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2021-3039": {"epss_score": 0.0018, "epss_percentile": 0.39874}, "CVE-2021-3040": {"epss_score": 0.03376, "epss_percentile": 0.87019}, "CVE-2021-3041": {"epss_score": 0.00035, "epss_percentile": 0.09983}, "CVE-2021-3042": {"epss_score": 0.00035, "epss_percentile": 0.09983}, "CVE-2021-3043": {"epss_score": 0.0016, "epss_percentile": 0.37508}, "CVE-2021-3044": {"epss_score": 0.00357, "epss_percentile": 0.57402}, "CVE-2021-3045": {"epss_score": 0.00598, "epss_percentile": 0.68759}, "CVE-2021-3046": {"epss_score": 0.0025, "epss_percentile": 0.48137}, "CVE-2021-3047": {"epss_score": 0.00284, "epss_percentile": 0.51416}, "CVE-2021-3048": {"epss_score": 0.00586, "epss_percentile": 0.68435}, "CVE-2021-3049": {"epss_score": 0.00113, "epss_percentile": 0.30603}, "CVE-2021-3050": {"epss_score": 0.03481, "epss_percentile": 0.87219}, "CVE-2021-3051": {"epss_score": 0.00141, "epss_percentile": 0.34948}, "CVE-2021-3052": {"epss_score": 0.00634, "epss_percentile": 0.69804}, "CVE-2021-3053": {"epss_score": 0.00328, "epss_percentile": 0.5528}, "CVE-2021-3054": {"epss_score": 0.00641, "epss_percentile": 0.69996}, "CVE-2021-3055": {"epss_score": 0.00282, "epss_percentile": 0.51206}, "CVE-2021-3056": {"epss_score": 0.00751, "epss_percentile": 0.72634}, "CVE-2021-3057": {"epss_score": 0.01082, "epss_percentile": 0.77384}, "CVE-2021-3058": {"epss_score": 0.00767, "epss_percentile": 0.72962}, "CVE-2021-3059": {"epss_score": 0.00762, "epss_percentile": 0.72846}, "CVE-2021-3060": {"epss_score": 0.40196, "epss_percentile": 0.97206}, "CVE-2021-3061": {"epss_score": 0.00443, "epss_percentile": 0.62799}, "CVE-2021-3062": {"epss_score": 0.00362, "epss_percentile": 0.57792}, "CVE-2021-3063": {"epss_score": 0.00578, "epss_percentile": 0.68194}, "CVE-2021-3064": {"epss_score": 0.49719, "epss_percentile": 0.97702}, "CVE-2021-3100": {"epss_score": 0.00033, "epss_percentile": 0.09213}, "CVE-2021-3101": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2021-3109": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2021-3110": {"epss_score": 0.79344, "epss_percentile": 0.99035}, "CVE-2021-3111": {"epss_score": 0.00606, "epss_percentile": 0.69025}, "CVE-2021-3113": {"epss_score": 0.00836, "epss_percentile": 0.74131}, "CVE-2021-3114": {"epss_score": 0.00035, "epss_percentile": 0.09912}, "CVE-2021-3115": {"epss_score": 0.0013, "epss_percentile": 0.33318}, "CVE-2021-3116": {"epss_score": 0.00412, "epss_percentile": 0.60916}, "CVE-2021-3118": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2021-3119": {"epss_score": 0.00603, "epss_percentile": 0.689}, "CVE-2021-3120": {"epss_score": 0.12245, "epss_percentile": 0.9361}, "CVE-2021-3121": {"epss_score": 0.00105, "epss_percentile": 0.29398}, "CVE-2021-3122": {"epss_score": 0.87096, "epss_percentile": 0.99415}, "CVE-2021-3124": {"epss_score": 0.00206, "epss_percentile": 0.42938}, "CVE-2021-3125": {"epss_score": 0.00942, "epss_percentile": 0.75768}, "CVE-2021-3127": {"epss_score": 0.0029, "epss_percentile": 0.52136}, "CVE-2021-3128": {"epss_score": 0.0248, "epss_percentile": 0.84872}, "CVE-2021-3129": {"epss_score": 0.94287, "epss_percentile": 0.99935}, "CVE-2021-3130": {"epss_score": 0.00627, "epss_percentile": 0.69625}, "CVE-2021-3131": {"epss_score": 0.00156, "epss_percentile": 0.36902}, "CVE-2021-3133": {"epss_score": 0.00125, "epss_percentile": 0.32588}, "CVE-2021-3134": {"epss_score": 0.0005, "epss_percentile": 0.15757}, "CVE-2021-3135": {"epss_score": 0.00439, "epss_percentile": 0.62595}, "CVE-2021-3137": {"epss_score": 0.00152, "epss_percentile": 0.36383}, "CVE-2021-3138": {"epss_score": 0.02655, "epss_percentile": 0.85356}, "CVE-2021-3139": {"epss_score": 0.00935, "epss_percentile": 0.75675}, "CVE-2021-3141": {"epss_score": 0.00042, "epss_percentile": 0.12714}, "CVE-2021-3144": {"epss_score": 0.05481, "epss_percentile": 0.89919}, "CVE-2021-3145": {"epss_score": 0.00216, "epss_percentile": 0.44159}, "CVE-2021-3146": {"epss_score": 0.00048, "epss_percentile": 0.1495}, "CVE-2021-3148": {"epss_score": 0.12138, "epss_percentile": 0.93583}, "CVE-2021-3149": {"epss_score": 0.02448, "epss_percentile": 0.84772}, "CVE-2021-3150": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2021-3151": {"epss_score": 0.002, "epss_percentile": 0.42268}, "CVE-2021-3152": {"epss_score": 0.00404, "epss_percentile": 0.60428}, "CVE-2021-3153": {"epss_score": 0.00138, "epss_percentile": 0.34526}, "CVE-2021-3154": {"epss_score": 0.02914, "epss_percentile": 0.85976}, "CVE-2021-3155": {"epss_score": 0.00028, "epss_percentile": 0.07505}, "CVE-2021-3156": {"epss_score": 0.9246, "epss_percentile": 0.99716}, "CVE-2021-3159": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-3160": {"epss_score": 0.14326, "epss_percentile": 0.94187}, "CVE-2021-3162": {"epss_score": 0.00022, "epss_percentile": 0.05189}, "CVE-2021-3163": {"epss_score": 0.00496, "epss_percentile": 0.65138}, "CVE-2021-3164": {"epss_score": 0.21186, "epss_percentile": 0.95473}, "CVE-2021-3165": {"epss_score": 0.00239, "epss_percentile": 0.46902}, "CVE-2021-3166": {"epss_score": 0.04706, "epss_percentile": 0.89031}, "CVE-2021-3167": {"epss_score": 0.00408, "epss_percentile": 0.60623}, "CVE-2021-3169": {"epss_score": 0.01077, "epss_percentile": 0.77336}, "CVE-2021-3172": {"epss_score": 0.00074, "epss_percentile": 0.22837}, "CVE-2021-3176": {"epss_score": 0.00423, "epss_percentile": 0.61593}, "CVE-2021-3177": {"epss_score": 0.00072, "epss_percentile": 0.22311}, "CVE-2021-3178": {"epss_score": 0.00156, "epss_percentile": 0.36897}, "CVE-2021-3179": {"epss_score": 0.00074, "epss_percentile": 0.22814}, "CVE-2021-3181": {"epss_score": 0.02997, "epss_percentile": 0.86156}, "CVE-2021-3182": {"epss_score": 0.00157, "epss_percentile": 0.37036}, "CVE-2021-3183": {"epss_score": 0.00279, "epss_percentile": 0.50996}, "CVE-2021-3184": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-3185": {"epss_score": 0.00668, "epss_percentile": 0.70742}, "CVE-2021-3186": {"epss_score": 0.00255, "epss_percentile": 0.48695}, "CVE-2021-3187": {"epss_score": 0.00197, "epss_percentile": 0.41898}, "CVE-2021-3188": {"epss_score": 0.00424, "epss_percentile": 0.61659}, "CVE-2021-3189": {"epss_score": 0.00289, "epss_percentile": 0.52045}, "CVE-2021-3190": {"epss_score": 0.20943, "epss_percentile": 0.95445}, "CVE-2021-3191": {"epss_score": 0.02434, "epss_percentile": 0.84734}, "CVE-2021-3193": {"epss_score": 0.22602, "epss_percentile": 0.95656}, "CVE-2021-3195": {"epss_score": 0.00315, "epss_percentile": 0.54197}, "CVE-2021-3196": {"epss_score": 0.00336, "epss_percentile": 0.5594}, "CVE-2021-3197": {"epss_score": 0.09933, "epss_percentile": 0.92778}, "CVE-2021-3198": {"epss_score": 0.02201, "epss_percentile": 0.83978}, "CVE-2021-3199": {"epss_score": 0.06758, "epss_percentile": 0.91007}, "CVE-2021-3200": {"epss_score": 0.00045, "epss_percentile": 0.14014}, "CVE-2021-3204": {"epss_score": 0.00226, "epss_percentile": 0.45313}, "CVE-2021-3210": {"epss_score": 0.01753, "epss_percentile": 0.82112}, "CVE-2021-3223": {"epss_score": 0.91547, "epss_percentile": 0.99651}, "CVE-2021-3224": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2021-3229": {"epss_score": 0.00623, "epss_percentile": 0.69541}, "CVE-2021-3236": {"epss_score": 0.00022, "epss_percentile": 0.05249}, "CVE-2021-3239": {"epss_score": 0.38354, "epss_percentile": 0.97097}, "CVE-2021-3242": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2021-3243": {"epss_score": 0.00216, "epss_percentile": 0.44215}, "CVE-2021-3246": {"epss_score": 0.00806, "epss_percentile": 0.73651}, "CVE-2021-3252": {"epss_score": 0.00437, "epss_percentile": 0.62526}, "CVE-2021-3254": {"epss_score": 0.00619, "epss_percentile": 0.69396}, "CVE-2021-3256": {"epss_score": 0.00243, "epss_percentile": 0.47468}, "CVE-2021-3258": {"epss_score": 0.00521, "epss_percentile": 0.66246}, "CVE-2021-3262": {"epss_score": 0.00097, "epss_percentile": 0.27579}, "CVE-2021-3264": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2021-3267": {"epss_score": 0.01114, "epss_percentile": 0.77701}, "CVE-2021-3271": {"epss_score": 0.00301, "epss_percentile": 0.53007}, "CVE-2021-3272": {"epss_score": 0.0008, "epss_percentile": 0.24126}, "CVE-2021-3273": {"epss_score": 0.24281, "epss_percentile": 0.959}, "CVE-2021-3275": {"epss_score": 0.01215, "epss_percentile": 0.78581}, "CVE-2021-3277": {"epss_score": 0.32138, "epss_percentile": 0.96673}, "CVE-2021-3278": {"epss_score": 0.01216, "epss_percentile": 0.78591}, "CVE-2021-3279": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2021-3281": {"epss_score": 0.30172, "epss_percentile": 0.96516}, "CVE-2021-3282": {"epss_score": 0.00318, "epss_percentile": 0.54405}, "CVE-2021-3283": {"epss_score": 0.00394, "epss_percentile": 0.5975}, "CVE-2021-3285": {"epss_score": 0.07997, "epss_percentile": 0.91813}, "CVE-2021-3286": {"epss_score": 0.00261, "epss_percentile": 0.49277}, "CVE-2021-3287": {"epss_score": 0.8849, "epss_percentile": 0.99474}, "CVE-2021-3291": {"epss_score": 0.43205, "epss_percentile": 0.97375}, "CVE-2021-3293": {"epss_score": 0.6791, "epss_percentile": 0.98525}, "CVE-2021-3294": {"epss_score": 0.0057, "epss_percentile": 0.67967}, "CVE-2021-3297": {"epss_score": 0.86299, "epss_percentile": 0.99377}, "CVE-2021-3298": {"epss_score": 0.00163, "epss_percentile": 0.37815}, "CVE-2021-3304": {"epss_score": 0.00512, "epss_percentile": 0.65871}, "CVE-2021-3305": {"epss_score": 0.00063, "epss_percentile": 0.19927}, "CVE-2021-3308": {"epss_score": 0.00058, "epss_percentile": 0.18476}, "CVE-2021-3309": {"epss_score": 0.00414, "epss_percentile": 0.61036}, "CVE-2021-3310": {"epss_score": 0.01136, "epss_percentile": 0.7792}, "CVE-2021-3311": {"epss_score": 0.01522, "epss_percentile": 0.80833}, "CVE-2021-3312": {"epss_score": 0.00476, "epss_percentile": 0.64291}, "CVE-2021-3313": {"epss_score": 0.00444, "epss_percentile": 0.62838}, "CVE-2021-3314": {"epss_score": 0.00134, "epss_percentile": 0.33794}, "CVE-2021-3315": {"epss_score": 9e-05, "epss_percentile": 0.00611}, "CVE-2021-3317": {"epss_score": 0.26364, "epss_percentile": 0.96141}, "CVE-2021-3318": {"epss_score": 0.00303, "epss_percentile": 0.53174}, "CVE-2021-3319": {"epss_score": 0.00435, "epss_percentile": 0.62349}, "CVE-2021-3320": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-3321": {"epss_score": 0.00116, "epss_percentile": 0.31123}, "CVE-2021-3322": {"epss_score": 0.00095, "epss_percentile": 0.27233}, "CVE-2021-3323": {"epss_score": 0.00413, "epss_percentile": 0.61003}, "CVE-2021-3325": {"epss_score": 0.01382, "epss_percentile": 0.79887}, "CVE-2021-3326": {"epss_score": 0.00225, "epss_percentile": 0.45129}, "CVE-2021-3327": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-3328": {"epss_score": 0.03888, "epss_percentile": 0.87907}, "CVE-2021-3329": {"epss_score": 0.00062, "epss_percentile": 0.19661}, "CVE-2021-3330": {"epss_score": 0.00109, "epss_percentile": 0.30062}, "CVE-2021-3331": {"epss_score": 0.06385, "epss_percentile": 0.90715}, "CVE-2021-3332": {"epss_score": 0.00219, "epss_percentile": 0.44508}, "CVE-2021-3333": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-3336": {"epss_score": 0.00352, "epss_percentile": 0.57092}, "CVE-2021-3337": {"epss_score": 0.17372, "epss_percentile": 0.9484}, "CVE-2021-3339": {"epss_score": 0.02174, "epss_percentile": 0.83879}, "CVE-2021-3340": {"epss_score": 0.00304, "epss_percentile": 0.53273}, "CVE-2021-3341": {"epss_score": 0.00643, "epss_percentile": 0.70054}, "CVE-2021-3342": {"epss_score": 0.03514, "epss_percentile": 0.87272}, "CVE-2021-3344": {"epss_score": 0.00676, "epss_percentile": 0.70942}, "CVE-2021-3345": {"epss_score": 0.05706, "epss_percentile": 0.90138}, "CVE-2021-3346": {"epss_score": 0.00519, "epss_percentile": 0.66143}, "CVE-2021-3347": {"epss_score": 0.00234, "epss_percentile": 0.46175}, "CVE-2021-3348": {"epss_score": 0.00095, "epss_percentile": 0.27222}, "CVE-2021-3349": {"epss_score": 0.00104, "epss_percentile": 0.29148}, "CVE-2021-3350": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-3351": {"epss_score": 0.00185, "epss_percentile": 0.40564}, "CVE-2021-3352": {"epss_score": 0.00367, "epss_percentile": 0.58101}, "CVE-2021-3355": {"epss_score": 0.00215, "epss_percentile": 0.44073}, "CVE-2021-3370": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-3374": {"epss_score": 0.83282, "epss_percentile": 0.99242}, "CVE-2021-3375": {"epss_score": 0.00954, "epss_percentile": 0.75896}, "CVE-2021-3376": {"epss_score": 0.00501, "epss_percentile": 0.65367}, "CVE-2021-3377": {"epss_score": 0.46141, "epss_percentile": 0.97532}, "CVE-2021-3378": {"epss_score": 0.92847, "epss_percentile": 0.99754}, "CVE-2021-3380": {"epss_score": 0.00235, "epss_percentile": 0.46229}, "CVE-2021-3382": {"epss_score": 0.00916, "epss_percentile": 0.75414}, "CVE-2021-3384": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2021-3391": {"epss_score": 0.00362, "epss_percentile": 0.57793}, "CVE-2021-3392": {"epss_score": 0.00027, "epss_percentile": 0.06827}, "CVE-2021-3393": {"epss_score": 0.00143, "epss_percentile": 0.35173}, "CVE-2021-3394": {"epss_score": 0.00669, "epss_percentile": 0.7076}, "CVE-2021-3395": {"epss_score": 0.00236, "epss_percentile": 0.46458}, "CVE-2021-3396": {"epss_score": 0.02493, "epss_percentile": 0.84903}, "CVE-2021-3398": {"epss_score": 0.00328, "epss_percentile": 0.55297}, "CVE-2021-3401": {"epss_score": 0.03001, "epss_percentile": 0.86166}, "CVE-2021-3402": {"epss_score": 0.01043, "epss_percentile": 0.76992}, "CVE-2021-3403": {"epss_score": 0.00889, "epss_percentile": 0.75012}, "CVE-2021-3404": {"epss_score": 0.02066, "epss_percentile": 0.83458}, "CVE-2021-3405": {"epss_score": 0.01475, "epss_percentile": 0.80525}, "CVE-2021-3406": {"epss_score": 0.00104, "epss_percentile": 0.29124}, "CVE-2021-3407": {"epss_score": 0.01186, "epss_percentile": 0.78349}, "CVE-2021-3409": {"epss_score": 0.00046, "epss_percentile": 0.14307}, "CVE-2021-3410": {"epss_score": 0.00213, "epss_percentile": 0.43902}, "CVE-2021-3411": {"epss_score": 0.00107, "epss_percentile": 0.29581}, "CVE-2021-3412": {"epss_score": 0.00153, "epss_percentile": 0.36569}, "CVE-2021-3413": {"epss_score": 0.00317, "epss_percentile": 0.5433}, "CVE-2021-3414": {"epss_score": 0.00134, "epss_percentile": 0.33806}, "CVE-2021-3416": {"epss_score": 6e-05, "epss_percentile": 0.00268}, "CVE-2021-3417": {"epss_score": 0.00142, "epss_percentile": 0.3497}, "CVE-2021-3418": {"epss_score": 0.00064, "epss_percentile": 0.20392}, "CVE-2021-3420": {"epss_score": 0.00228, "epss_percentile": 0.45479}, "CVE-2021-3421": {"epss_score": 0.00048, "epss_percentile": 0.1512}, "CVE-2021-3422": {"epss_score": 0.00396, "epss_percentile": 0.59866}, "CVE-2021-3423": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2021-3424": {"epss_score": 0.00164, "epss_percentile": 0.37865}, "CVE-2021-3425": {"epss_score": 0.00055, "epss_percentile": 0.17464}, "CVE-2021-3426": {"epss_score": 0.00081, "epss_percentile": 0.24318}, "CVE-2021-3427": {"epss_score": 0.00632, "epss_percentile": 0.69745}, "CVE-2021-3428": {"epss_score": 0.00022, "epss_percentile": 0.05004}, "CVE-2021-3429": {"epss_score": 0.0005, "epss_percentile": 0.15714}, "CVE-2021-3430": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-3431": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-3432": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-3433": {"epss_score": 0.00054, "epss_percentile": 0.17332}, "CVE-2021-3434": {"epss_score": 0.00121, "epss_percentile": 0.3199}, "CVE-2021-3435": {"epss_score": 0.00054, "epss_percentile": 0.17226}, "CVE-2021-3436": {"epss_score": 0.00315, "epss_percentile": 0.54182}, "CVE-2021-3437": {"epss_score": 0.00526, "epss_percentile": 0.66409}, "CVE-2021-3438": {"epss_score": 0.01676, "epss_percentile": 0.81707}, "CVE-2021-3439": {"epss_score": 0.00134, "epss_percentile": 0.33798}, "CVE-2021-3440": {"epss_score": 0.00064, "epss_percentile": 0.2016}, "CVE-2021-3441": {"epss_score": 0.00225, "epss_percentile": 0.4515}, "CVE-2021-3442": {"epss_score": 0.00212, "epss_percentile": 0.43744}, "CVE-2021-3443": {"epss_score": 0.00036, "epss_percentile": 0.10211}, "CVE-2021-3444": {"epss_score": 0.00085, "epss_percentile": 0.25129}, "CVE-2021-3445": {"epss_score": 0.00038, "epss_percentile": 0.11334}, "CVE-2021-3446": {"epss_score": 0.00035, "epss_percentile": 0.09829}, "CVE-2021-3447": {"epss_score": 0.00072, "epss_percentile": 0.22307}, "CVE-2021-3448": {"epss_score": 0.00031, "epss_percentile": 0.08665}, "CVE-2021-3449": {"epss_score": 0.11261, "epss_percentile": 0.93282}, "CVE-2021-3450": {"epss_score": 0.00504, "epss_percentile": 0.65545}, "CVE-2021-3451": {"epss_score": 0.00043, "epss_percentile": 0.13225}, "CVE-2021-3452": {"epss_score": 0.00062, "epss_percentile": 0.19781}, "CVE-2021-3453": {"epss_score": 0.00048, "epss_percentile": 0.14986}, "CVE-2021-3454": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-3455": {"epss_score": 0.00393, "epss_percentile": 0.59709}, "CVE-2021-3456": {"epss_score": 0.00031, "epss_percentile": 0.08623}, "CVE-2021-3457": {"epss_score": 0.00017, "epss_percentile": 0.03186}, "CVE-2021-3458": {"epss_score": 0.00043, "epss_percentile": 0.13172}, "CVE-2021-3459": {"epss_score": 0.0005, "epss_percentile": 0.15653}, "CVE-2021-3460": {"epss_score": 0.0022, "epss_percentile": 0.44537}, "CVE-2021-3461": {"epss_score": 0.00052, "epss_percentile": 0.16368}, "CVE-2021-3462": {"epss_score": 0.00121, "epss_percentile": 0.31952}, "CVE-2021-3463": {"epss_score": 0.00041, "epss_percentile": 0.12355}, "CVE-2021-3464": {"epss_score": 0.00052, "epss_percentile": 0.16513}, "CVE-2021-3466": {"epss_score": 0.00419, "epss_percentile": 0.61391}, "CVE-2021-3467": {"epss_score": 0.00073, "epss_percentile": 0.22654}, "CVE-2021-3468": {"epss_score": 0.0001, "epss_percentile": 0.00867}, "CVE-2021-3469": {"epss_score": 0.0013, "epss_percentile": 0.3332}, "CVE-2021-3470": {"epss_score": 0.00665, "epss_percentile": 0.70666}, "CVE-2021-3472": {"epss_score": 0.00093, "epss_percentile": 0.26611}, "CVE-2021-3473": {"epss_score": 0.001, "epss_percentile": 0.28538}, "CVE-2021-3474": {"epss_score": 0.0101, "epss_percentile": 0.76606}, "CVE-2021-3475": {"epss_score": 0.00654, "epss_percentile": 0.70343}, "CVE-2021-3476": {"epss_score": 0.0101, "epss_percentile": 0.76606}, "CVE-2021-3477": {"epss_score": 0.00507, "epss_percentile": 0.65666}, "CVE-2021-3478": {"epss_score": 0.00507, "epss_percentile": 0.65666}, "CVE-2021-3479": {"epss_score": 0.0048, "epss_percentile": 0.64452}, "CVE-2021-3480": {"epss_score": 0.0258, "epss_percentile": 0.85151}, "CVE-2021-3481": {"epss_score": 0.00054, "epss_percentile": 0.17197}, "CVE-2021-3482": {"epss_score": 0.00202, "epss_percentile": 0.42458}, "CVE-2021-3483": {"epss_score": 0.00179, "epss_percentile": 0.39852}, "CVE-2021-3485": {"epss_score": 0.00778, "epss_percentile": 0.73131}, "CVE-2021-3486": {"epss_score": 0.00705, "epss_percentile": 0.71578}, "CVE-2021-3489": {"epss_score": 0.00076, "epss_percentile": 0.23282}, "CVE-2021-3490": {"epss_score": 0.03383, "epss_percentile": 0.87035}, "CVE-2021-3491": {"epss_score": 0.00047, "epss_percentile": 0.14705}, "CVE-2021-3492": {"epss_score": 0.24443, "epss_percentile": 0.95922}, "CVE-2021-3493": {"epss_score": 0.76767, "epss_percentile": 0.98903}, "CVE-2021-3494": {"epss_score": 0.0027, "epss_percentile": 0.50193}, "CVE-2021-3495": {"epss_score": 0.00339, "epss_percentile": 0.56183}, "CVE-2021-3496": {"epss_score": 0.00184, "epss_percentile": 0.40369}, "CVE-2021-3497": {"epss_score": 0.00231, "epss_percentile": 0.45766}, "CVE-2021-3498": {"epss_score": 0.00287, "epss_percentile": 0.51783}, "CVE-2021-3499": {"epss_score": 0.00135, "epss_percentile": 0.34045}, "CVE-2021-3500": {"epss_score": 0.00288, "epss_percentile": 0.51945}, "CVE-2021-3501": {"epss_score": 0.00042, "epss_percentile": 0.12928}, "CVE-2021-3502": {"epss_score": 0.00032, "epss_percentile": 0.08813}, "CVE-2021-3503": {"epss_score": 0.00324, "epss_percentile": 0.54934}, "CVE-2021-3504": {"epss_score": 0.00134, "epss_percentile": 0.33759}, "CVE-2021-3505": {"epss_score": 0.00126, "epss_percentile": 0.32776}, "CVE-2021-3506": {"epss_score": 0.00137, "epss_percentile": 0.34243}, "CVE-2021-3507": {"epss_score": 0.00029, "epss_percentile": 0.07862}, "CVE-2021-3508": {"epss_score": 0.00339, "epss_percentile": 0.56183}, "CVE-2021-3509": {"epss_score": 0.00597, "epss_percentile": 0.68749}, "CVE-2021-3510": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-3511": {"epss_score": 0.00194, "epss_percentile": 0.41553}, "CVE-2021-3512": {"epss_score": 0.00245, "epss_percentile": 0.47668}, "CVE-2021-3513": {"epss_score": 0.00201, "epss_percentile": 0.42322}, "CVE-2021-3514": {"epss_score": 0.00219, "epss_percentile": 0.44533}, "CVE-2021-3515": {"epss_score": 0.00124, "epss_percentile": 0.3241}, "CVE-2021-3516": {"epss_score": 0.00362, "epss_percentile": 0.578}, "CVE-2021-3517": {"epss_score": 0.00084, "epss_percentile": 0.24883}, "CVE-2021-3518": {"epss_score": 0.0023, "epss_percentile": 0.45759}, "CVE-2021-3519": {"epss_score": 0.00034, "epss_percentile": 0.09755}, "CVE-2021-3520": {"epss_score": 0.00134, "epss_percentile": 0.33804}, "CVE-2021-3521": {"epss_score": 0.00034, "epss_percentile": 0.09627}, "CVE-2021-3522": {"epss_score": 0.0017, "epss_percentile": 0.38679}, "CVE-2021-3523": {"epss_score": 0.00164, "epss_percentile": 0.37865}, "CVE-2021-3524": {"epss_score": 0.00583, "epss_percentile": 0.68329}, "CVE-2021-3527": {"epss_score": 0.00027, "epss_percentile": 0.06828}, "CVE-2021-3528": {"epss_score": 0.0033, "epss_percentile": 0.5549}, "CVE-2021-3529": {"epss_score": 0.00225, "epss_percentile": 0.4509}, "CVE-2021-3530": {"epss_score": 0.00071, "epss_percentile": 0.21999}, "CVE-2021-3531": {"epss_score": 0.00257, "epss_percentile": 0.48893}, "CVE-2021-3535": {"epss_score": 0.00226, "epss_percentile": 0.45298}, "CVE-2021-3536": {"epss_score": 0.00284, "epss_percentile": 0.51475}, "CVE-2021-3537": {"epss_score": 0.00111, "epss_percentile": 0.30354}, "CVE-2021-3538": {"epss_score": 0.00457, "epss_percentile": 0.63369}, "CVE-2021-3539": {"epss_score": 0.00197, "epss_percentile": 0.41904}, "CVE-2021-3540": {"epss_score": 0.02201, "epss_percentile": 0.83978}, "CVE-2021-3541": {"epss_score": 0.00067, "epss_percentile": 0.21092}, "CVE-2021-3543": {"epss_score": 0.00098, "epss_percentile": 0.27699}, "CVE-2021-3544": {"epss_score": 0.00032, "epss_percentile": 0.09072}, "CVE-2021-3545": {"epss_score": 0.00116, "epss_percentile": 0.31149}, "CVE-2021-3546": {"epss_score": 0.00043, "epss_percentile": 0.13362}, "CVE-2021-3547": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2021-3548": {"epss_score": 0.00325, "epss_percentile": 0.55015}, "CVE-2021-3549": {"epss_score": 0.00361, "epss_percentile": 0.57726}, "CVE-2021-3550": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2021-3551": {"epss_score": 0.00018, "epss_percentile": 0.03614}, "CVE-2021-3552": {"epss_score": 0.00212, "epss_percentile": 0.43725}, "CVE-2021-3553": {"epss_score": 0.00222, "epss_percentile": 0.44795}, "CVE-2021-3554": {"epss_score": 0.00317, "epss_percentile": 0.54315}, "CVE-2021-3555": {"epss_score": 0.0031, "epss_percentile": 0.53805}, "CVE-2021-3557": {"epss_score": 0.00182, "epss_percentile": 0.40261}, "CVE-2021-3559": {"epss_score": 0.00368, "epss_percentile": 0.58186}, "CVE-2021-3560": {"epss_score": 0.11686, "epss_percentile": 0.93447}, "CVE-2021-3561": {"epss_score": 0.00148, "epss_percentile": 0.35854}, "CVE-2021-3563": {"epss_score": 0.00054, "epss_percentile": 0.17202}, "CVE-2021-3564": {"epss_score": 0.00022, "epss_percentile": 0.05226}, "CVE-2021-3565": {"epss_score": 0.00162, "epss_percentile": 0.37643}, "CVE-2021-3566": {"epss_score": 0.00103, "epss_percentile": 0.29002}, "CVE-2021-3567": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2021-3569": {"epss_score": 0.00047, "epss_percentile": 0.14877}, "CVE-2021-3570": {"epss_score": 0.01226, "epss_percentile": 0.78692}, "CVE-2021-3571": {"epss_score": 0.0072, "epss_percentile": 0.71966}, "CVE-2021-3572": {"epss_score": 0.0024, "epss_percentile": 0.46946}, "CVE-2021-3573": {"epss_score": 0.00026, "epss_percentile": 0.06658}, "CVE-2021-3574": {"epss_score": 0.00031, "epss_percentile": 0.08648}, "CVE-2021-3575": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-3576": {"epss_score": 0.00042, "epss_percentile": 0.12733}, "CVE-2021-3577": {"epss_score": 0.86428, "epss_percentile": 0.99382}, "CVE-2021-3578": {"epss_score": 0.02289, "epss_percentile": 0.84274}, "CVE-2021-3579": {"epss_score": 0.00068, "epss_percentile": 0.21384}, "CVE-2021-3580": {"epss_score": 0.00038, "epss_percentile": 0.1123}, "CVE-2021-3581": {"epss_score": 0.00151, "epss_percentile": 0.3636}, "CVE-2021-3582": {"epss_score": 0.00162, "epss_percentile": 0.37637}, "CVE-2021-3583": {"epss_score": 0.00293, "epss_percentile": 0.52344}, "CVE-2021-3584": {"epss_score": 0.00476, "epss_percentile": 0.64256}, "CVE-2021-3585": {"epss_score": 0.00034, "epss_percentile": 0.09574}, "CVE-2021-3586": {"epss_score": 0.00442, "epss_percentile": 0.62752}, "CVE-2021-3588": {"epss_score": 0.00121, "epss_percentile": 0.31951}, "CVE-2021-3589": {"epss_score": 0.00218, "epss_percentile": 0.44356}, "CVE-2021-3590": {"epss_score": 0.00157, "epss_percentile": 0.37018}, "CVE-2021-3592": {"epss_score": 0.00025, "epss_percentile": 0.06332}, "CVE-2021-3593": {"epss_score": 0.00022, "epss_percentile": 0.04964}, "CVE-2021-3594": {"epss_score": 0.00028, "epss_percentile": 0.07378}, "CVE-2021-3595": {"epss_score": 0.00022, "epss_percentile": 0.04964}, "CVE-2021-3596": {"epss_score": 0.00174, "epss_percentile": 0.39159}, "CVE-2021-3597": {"epss_score": 0.00169, "epss_percentile": 0.38641}, "CVE-2021-3598": {"epss_score": 0.00162, "epss_percentile": 0.37637}, "CVE-2021-3599": {"epss_score": 0.00037, "epss_percentile": 0.10985}, "CVE-2021-3600": {"epss_score": 0.00122, "epss_percentile": 0.3214}, "CVE-2021-3602": {"epss_score": 0.00035, "epss_percentile": 0.09944}, "CVE-2021-3603": {"epss_score": 0.00401, "epss_percentile": 0.60254}, "CVE-2021-3604": {"epss_score": 0.00566, "epss_percentile": 0.67813}, "CVE-2021-3605": {"epss_score": 0.00454, "epss_percentile": 0.63244}, "CVE-2021-3606": {"epss_score": 0.00126, "epss_percentile": 0.32708}, "CVE-2021-3607": {"epss_score": 0.00173, "epss_percentile": 0.39041}, "CVE-2021-3608": {"epss_score": 0.00037, "epss_percentile": 0.10985}, "CVE-2021-3609": {"epss_score": 0.00067, "epss_percentile": 0.21036}, "CVE-2021-3610": {"epss_score": 0.00147, "epss_percentile": 0.35791}, "CVE-2021-3611": {"epss_score": 0.00017, "epss_percentile": 0.03188}, "CVE-2021-3612": {"epss_score": 0.00081, "epss_percentile": 0.24259}, "CVE-2021-3613": {"epss_score": 0.00071, "epss_percentile": 0.22139}, "CVE-2021-3614": {"epss_score": 0.00047, "epss_percentile": 0.14789}, "CVE-2021-3615": {"epss_score": 0.00057, "epss_percentile": 0.18126}, "CVE-2021-3616": {"epss_score": 0.0026, "epss_percentile": 0.49151}, "CVE-2021-3617": {"epss_score": 0.01323, "epss_percentile": 0.79458}, "CVE-2021-3618": {"epss_score": 0.00492, "epss_percentile": 0.65017}, "CVE-2021-3619": {"epss_score": 0.0042, "epss_percentile": 0.61424}, "CVE-2021-3620": {"epss_score": 0.00195, "epss_percentile": 0.41606}, "CVE-2021-3621": {"epss_score": 0.00454, "epss_percentile": 0.63256}, "CVE-2021-3622": {"epss_score": 0.0045, "epss_percentile": 0.63091}, "CVE-2021-3623": {"epss_score": 0.00052, "epss_percentile": 0.16442}, "CVE-2021-3624": {"epss_score": 0.00292, "epss_percentile": 0.5222}, "CVE-2021-3625": {"epss_score": 0.05556, "epss_percentile": 0.8999}, "CVE-2021-3626": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2021-3628": {"epss_score": 0.0026, "epss_percentile": 0.49216}, "CVE-2021-3629": {"epss_score": 0.00358, "epss_percentile": 0.57506}, "CVE-2021-3630": {"epss_score": 0.00333, "epss_percentile": 0.55614}, "CVE-2021-3631": {"epss_score": 0.00073, "epss_percentile": 0.22534}, "CVE-2021-3632": {"epss_score": 0.00411, "epss_percentile": 0.6087}, "CVE-2021-3633": {"epss_score": 0.00021, "epss_percentile": 0.04775}, "CVE-2021-3634": {"epss_score": 0.00117, "epss_percentile": 0.3133}, "CVE-2021-3635": {"epss_score": 0.00097, "epss_percentile": 0.27541}, "CVE-2021-3636": {"epss_score": 0.00031, "epss_percentile": 0.08508}, "CVE-2021-3637": {"epss_score": 0.00468, "epss_percentile": 0.63876}, "CVE-2021-3638": {"epss_score": 0.0002, "epss_percentile": 0.0447}, "CVE-2021-3639": {"epss_score": 0.00139, "epss_percentile": 0.34561}, "CVE-2021-3640": {"epss_score": 4e-05, "epss_percentile": 0.00127}, "CVE-2021-3641": {"epss_score": 0.00041, "epss_percentile": 0.12365}, "CVE-2021-3642": {"epss_score": 0.00267, "epss_percentile": 0.49962}, "CVE-2021-3643": {"epss_score": 0.00079, "epss_percentile": 0.23815}, "CVE-2021-3644": {"epss_score": 0.0044, "epss_percentile": 0.62646}, "CVE-2021-3645": {"epss_score": 0.00453, "epss_percentile": 0.63237}, "CVE-2021-3646": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2021-3647": {"epss_score": 0.00175, "epss_percentile": 0.39281}, "CVE-2021-3649": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-3652": {"epss_score": 0.00193, "epss_percentile": 0.41395}, "CVE-2021-3653": {"epss_score": 0.00013, "epss_percentile": 0.01558}, "CVE-2021-3654": {"epss_score": 0.88336, "epss_percentile": 0.99466}, "CVE-2021-3655": {"epss_score": 0.00023, "epss_percentile": 0.05375}, "CVE-2021-3656": {"epss_score": 0.0006, "epss_percentile": 0.18978}, "CVE-2021-3657": {"epss_score": 0.06799, "epss_percentile": 0.91033}, "CVE-2021-3658": {"epss_score": 0.0007, "epss_percentile": 0.21645}, "CVE-2021-3659": {"epss_score": 0.00021, "epss_percentile": 0.04844}, "CVE-2021-3660": {"epss_score": 0.0027, "epss_percentile": 0.50227}, "CVE-2021-3661": {"epss_score": 0.00275, "epss_percentile": 0.50656}, "CVE-2021-3662": {"epss_score": 0.00171, "epss_percentile": 0.3881}, "CVE-2021-3663": {"epss_score": 0.0016, "epss_percentile": 0.37445}, "CVE-2021-3664": {"epss_score": 0.00314, "epss_percentile": 0.54146}, "CVE-2021-3666": {"epss_score": 0.00358, "epss_percentile": 0.57536}, "CVE-2021-3667": {"epss_score": 0.00436, "epss_percentile": 0.62469}, "CVE-2021-3669": {"epss_score": 0.00013, "epss_percentile": 0.01704}, "CVE-2021-3670": {"epss_score": 0.02977, "epss_percentile": 0.86109}, "CVE-2021-3671": {"epss_score": 0.0123, "epss_percentile": 0.78727}, "CVE-2021-3672": {"epss_score": 0.00092, "epss_percentile": 0.2651}, "CVE-2021-3673": {"epss_score": 0.00644, "epss_percentile": 0.70085}, "CVE-2021-3674": {"epss_score": 0.00094, "epss_percentile": 0.26974}, "CVE-2021-3675": {"epss_score": 0.00142, "epss_percentile": 0.35025}, "CVE-2021-3677": {"epss_score": 0.00192, "epss_percentile": 0.41318}, "CVE-2021-3678": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2021-3679": {"epss_score": 0.01295, "epss_percentile": 0.79251}, "CVE-2021-3680": {"epss_score": 0.00099, "epss_percentile": 0.28348}, "CVE-2021-3681": {"epss_score": 0.00043, "epss_percentile": 0.13135}, "CVE-2021-3682": {"epss_score": 0.00491, "epss_percentile": 0.64965}, "CVE-2021-3683": {"epss_score": 0.00112, "epss_percentile": 0.30422}, "CVE-2021-3684": {"epss_score": 0.00048, "epss_percentile": 0.15274}, "CVE-2021-3688": {"epss_score": 0.00269, "epss_percentile": 0.5019}, "CVE-2021-3689": {"epss_score": 0.00449, "epss_percentile": 0.63051}, "CVE-2021-3690": {"epss_score": 0.00278, "epss_percentile": 0.50854}, "CVE-2021-3692": {"epss_score": 0.00358, "epss_percentile": 0.57538}, "CVE-2021-3693": {"epss_score": 0.00792, "epss_percentile": 0.73415}, "CVE-2021-3694": {"epss_score": 0.00252, "epss_percentile": 0.4835}, "CVE-2021-3695": {"epss_score": 0.0006, "epss_percentile": 0.19002}, "CVE-2021-3696": {"epss_score": 0.00114, "epss_percentile": 0.30742}, "CVE-2021-3697": {"epss_score": 0.00067, "epss_percentile": 0.2115}, "CVE-2021-3698": {"epss_score": 0.00146, "epss_percentile": 0.3563}, "CVE-2021-3700": {"epss_score": 0.00037, "epss_percentile": 0.10988}, "CVE-2021-3701": {"epss_score": 0.00133, "epss_percentile": 0.33684}, "CVE-2021-3702": {"epss_score": 0.00128, "epss_percentile": 0.33022}, "CVE-2021-3703": {"epss_score": 0.00434, "epss_percentile": 0.6232}, "CVE-2021-3704": {"epss_score": 0.00544, "epss_percentile": 0.67151}, "CVE-2021-3705": {"epss_score": 0.00456, "epss_percentile": 0.63331}, "CVE-2021-3706": {"epss_score": 0.00152, "epss_percentile": 0.36429}, "CVE-2021-3707": {"epss_score": 0.03808, "epss_percentile": 0.87752}, "CVE-2021-3708": {"epss_score": 0.17115, "epss_percentile": 0.94777}, "CVE-2021-3709": {"epss_score": 0.00071, "epss_percentile": 0.22125}, "CVE-2021-3710": {"epss_score": 0.00049, "epss_percentile": 0.15617}, "CVE-2021-3711": {"epss_score": 0.02119, "epss_percentile": 0.83671}, "CVE-2021-3712": {"epss_score": 0.00486, "epss_percentile": 0.64747}, "CVE-2021-3713": {"epss_score": 0.00033, "epss_percentile": 0.09372}, "CVE-2021-3714": {"epss_score": 0.00052, "epss_percentile": 0.16575}, "CVE-2021-3715": {"epss_score": 0.00042, "epss_percentile": 0.12674}, "CVE-2021-3716": {"epss_score": 0.00073, "epss_percentile": 0.2267}, "CVE-2021-3717": {"epss_score": 0.00039, "epss_percentile": 0.11596}, "CVE-2021-3718": {"epss_score": 0.00035, "epss_percentile": 0.10086}, "CVE-2021-3719": {"epss_score": 0.00037, "epss_percentile": 0.10985}, "CVE-2021-3720": {"epss_score": 0.00044, "epss_percentile": 0.1349}, "CVE-2021-3721": {"epss_score": 0.00036, "epss_percentile": 0.10328}, "CVE-2021-3722": {"epss_score": 0.00034, "epss_percentile": 0.09713}, "CVE-2021-3723": {"epss_score": 0.01196, "epss_percentile": 0.78437}, "CVE-2021-3725": {"epss_score": 0.0136, "epss_percentile": 0.79748}, "CVE-2021-3726": {"epss_score": 0.00444, "epss_percentile": 0.62819}, "CVE-2021-3727": {"epss_score": 0.0136, "epss_percentile": 0.79748}, "CVE-2021-3728": {"epss_score": 0.00111, "epss_percentile": 0.30383}, "CVE-2021-3729": {"epss_score": 0.00117, "epss_percentile": 0.31307}, "CVE-2021-3730": {"epss_score": 0.00111, "epss_percentile": 0.30383}, "CVE-2021-3731": {"epss_score": 0.00154, "epss_percentile": 0.36688}, "CVE-2021-3732": {"epss_score": 0.00022, "epss_percentile": 0.05191}, "CVE-2021-3733": {"epss_score": 0.00702, "epss_percentile": 0.71514}, "CVE-2021-3734": {"epss_score": 0.00109, "epss_percentile": 0.29945}, "CVE-2021-3735": {"epss_score": 0.00124, "epss_percentile": 0.3242}, "CVE-2021-3736": {"epss_score": 0.00053, "epss_percentile": 0.16829}, "CVE-2021-3737": {"epss_score": 0.00162, "epss_percentile": 0.37651}, "CVE-2021-3738": {"epss_score": 0.00285, "epss_percentile": 0.51639}, "CVE-2021-3739": {"epss_score": 0.00029, "epss_percentile": 0.07588}, "CVE-2021-3740": {"epss_score": 0.00086, "epss_percentile": 0.25297}, "CVE-2021-3741": {"epss_score": 0.00158, "epss_percentile": 0.37253}, "CVE-2021-3742": {"epss_score": 0.0012, "epss_percentile": 0.31741}, "CVE-2021-3743": {"epss_score": 0.00012, "epss_percentile": 0.01161}, "CVE-2021-3744": {"epss_score": 0.00011, "epss_percentile": 0.01092}, "CVE-2021-3745": {"epss_score": 0.00378, "epss_percentile": 0.58785}, "CVE-2021-3746": {"epss_score": 0.00186, "epss_percentile": 0.40692}, "CVE-2021-3747": {"epss_score": 0.0004, "epss_percentile": 0.1193}, "CVE-2021-3748": {"epss_score": 0.00023, "epss_percentile": 0.05397}, "CVE-2021-3749": {"epss_score": 0.08894, "epss_percentile": 0.92304}, "CVE-2021-3750": {"epss_score": 0.00029, "epss_percentile": 0.0767}, "CVE-2021-3751": {"epss_score": 0.00332, "epss_percentile": 0.55577}, "CVE-2021-3752": {"epss_score": 0.00036, "epss_percentile": 0.10337}, "CVE-2021-3753": {"epss_score": 0.00012, "epss_percentile": 0.01225}, "CVE-2021-3754": {"epss_score": 0.11083, "epss_percentile": 0.93214}, "CVE-2021-3756": {"epss_score": 0.00328, "epss_percentile": 0.55277}, "CVE-2021-3757": {"epss_score": 0.00592, "epss_percentile": 0.68604}, "CVE-2021-3758": {"epss_score": 0.0024, "epss_percentile": 0.472}, "CVE-2021-3759": {"epss_score": 0.00016, "epss_percentile": 0.0293}, "CVE-2021-3760": {"epss_score": 0.00135, "epss_percentile": 0.33967}, "CVE-2021-3761": {"epss_score": 0.0045, "epss_percentile": 0.63094}, "CVE-2021-3762": {"epss_score": 0.03906, "epss_percentile": 0.87928}, "CVE-2021-3763": {"epss_score": 0.00166, "epss_percentile": 0.38143}, "CVE-2021-3764": {"epss_score": 0.00016, "epss_percentile": 0.02741}, "CVE-2021-3765": {"epss_score": 0.00044, "epss_percentile": 0.13392}, "CVE-2021-3766": {"epss_score": 0.00359, "epss_percentile": 0.57614}, "CVE-2021-3767": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2021-3768": {"epss_score": 0.00181, "epss_percentile": 0.40084}, "CVE-2021-3769": {"epss_score": 0.00329, "epss_percentile": 0.55406}, "CVE-2021-3770": {"epss_score": 0.00295, "epss_percentile": 0.52512}, "CVE-2021-3772": {"epss_score": 0.0016, "epss_percentile": 0.37449}, "CVE-2021-3773": {"epss_score": 0.00651, "epss_percentile": 0.70297}, "CVE-2021-3774": {"epss_score": 0.00151, "epss_percentile": 0.36188}, "CVE-2021-3775": {"epss_score": 0.00112, "epss_percentile": 0.30422}, "CVE-2021-3776": {"epss_score": 0.00112, "epss_percentile": 0.30422}, "CVE-2021-3777": {"epss_score": 0.00248, "epss_percentile": 0.47957}, "CVE-2021-3778": {"epss_score": 0.00361, "epss_percentile": 0.5773}, "CVE-2021-3779": {"epss_score": 0.0039, "epss_percentile": 0.59498}, "CVE-2021-3780": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2021-3781": {"epss_score": 0.09269, "epss_percentile": 0.92474}, "CVE-2021-3782": {"epss_score": 0.00023, "epss_percentile": 0.05374}, "CVE-2021-3783": {"epss_score": 0.00355, "epss_percentile": 0.57271}, "CVE-2021-3784": {"epss_score": 0.00027, "epss_percentile": 0.0709}, "CVE-2021-3785": {"epss_score": 0.00318, "epss_percentile": 0.54446}, "CVE-2021-3786": {"epss_score": 0.00044, "epss_percentile": 0.13391}, "CVE-2021-3787": {"epss_score": 0.00055, "epss_percentile": 0.17541}, "CVE-2021-3788": {"epss_score": 0.00065, "epss_percentile": 0.20449}, "CVE-2021-3789": {"epss_score": 0.00014, "epss_percentile": 0.02096}, "CVE-2021-3790": {"epss_score": 0.00098, "epss_percentile": 0.27816}, "CVE-2021-3791": {"epss_score": 0.00107, "epss_percentile": 0.29695}, "CVE-2021-3792": {"epss_score": 0.00095, "epss_percentile": 0.27217}, "CVE-2021-3793": {"epss_score": 0.00319, "epss_percentile": 0.54552}, "CVE-2021-3794": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-3795": {"epss_score": 0.00468, "epss_percentile": 0.63891}, "CVE-2021-3796": {"epss_score": 0.00108, "epss_percentile": 0.29775}, "CVE-2021-3797": {"epss_score": 0.00441, "epss_percentile": 0.62689}, "CVE-2021-3798": {"epss_score": 0.00154, "epss_percentile": 0.36672}, "CVE-2021-3799": {"epss_score": 0.00161, "epss_percentile": 0.37544}, "CVE-2021-3800": {"epss_score": 0.00059, "epss_percentile": 0.18832}, "CVE-2021-3801": {"epss_score": 0.0028, "epss_percentile": 0.51035}, "CVE-2021-3802": {"epss_score": 0.00035, "epss_percentile": 0.09845}, "CVE-2021-3803": {"epss_score": 0.00122, "epss_percentile": 0.32138}, "CVE-2021-3804": {"epss_score": 0.00248, "epss_percentile": 0.47957}, "CVE-2021-3805": {"epss_score": 0.00123, "epss_percentile": 0.32211}, "CVE-2021-3806": {"epss_score": 0.00449, "epss_percentile": 0.63055}, "CVE-2021-3807": {"epss_score": 0.00215, "epss_percentile": 0.44106}, "CVE-2021-3808": {"epss_score": 0.00179, "epss_percentile": 0.39841}, "CVE-2021-3809": {"epss_score": 0.00179, "epss_percentile": 0.39841}, "CVE-2021-3810": {"epss_score": 0.00248, "epss_percentile": 0.47957}, "CVE-2021-3811": {"epss_score": 0.00183, "epss_percentile": 0.40324}, "CVE-2021-3812": {"epss_score": 0.00183, "epss_percentile": 0.40324}, "CVE-2021-3813": {"epss_score": 0.00226, "epss_percentile": 0.45313}, "CVE-2021-3814": {"epss_score": 0.00263, "epss_percentile": 0.49506}, "CVE-2021-3815": {"epss_score": 0.00184, "epss_percentile": 0.4044}, "CVE-2021-3816": {"epss_score": 0.00436, "epss_percentile": 0.62462}, "CVE-2021-3817": {"epss_score": 0.49236, "epss_percentile": 0.97675}, "CVE-2021-3818": {"epss_score": 0.00294, "epss_percentile": 0.52403}, "CVE-2021-3819": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2021-3820": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-3821": {"epss_score": 0.00325, "epss_percentile": 0.54998}, "CVE-2021-3822": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-3823": {"epss_score": 0.00403, "epss_percentile": 0.60327}, "CVE-2021-3824": {"epss_score": 0.00301, "epss_percentile": 0.53018}, "CVE-2021-3825": {"epss_score": 0.00405, "epss_percentile": 0.60482}, "CVE-2021-3826": {"epss_score": 0.00348, "epss_percentile": 0.56826}, "CVE-2021-3827": {"epss_score": 0.00208, "epss_percentile": 0.43301}, "CVE-2021-3828": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2021-3829": {"epss_score": 0.00229, "epss_percentile": 0.45636}, "CVE-2021-3830": {"epss_score": 0.00234, "epss_percentile": 0.46176}, "CVE-2021-3831": {"epss_score": 0.26611, "epss_percentile": 0.96162}, "CVE-2021-3832": {"epss_score": 0.01593, "epss_percentile": 0.81229}, "CVE-2021-3833": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2021-3834": {"epss_score": 0.00251, "epss_percentile": 0.48285}, "CVE-2021-3835": {"epss_score": 0.00116, "epss_percentile": 0.31123}, "CVE-2021-3836": {"epss_score": 0.00166, "epss_percentile": 0.38193}, "CVE-2021-3837": {"epss_score": 0.00142, "epss_percentile": 0.35037}, "CVE-2021-3838": {"epss_score": 0.03462, "epss_percentile": 0.87184}, "CVE-2021-3839": {"epss_score": 0.00366, "epss_percentile": 0.58058}, "CVE-2021-3840": {"epss_score": 0.0118, "epss_percentile": 0.78298}, "CVE-2021-3841": {"epss_score": 0.00113, "epss_percentile": 0.30702}, "CVE-2021-3842": {"epss_score": 0.00411, "epss_percentile": 0.60879}, "CVE-2021-3843": {"epss_score": 0.00037, "epss_percentile": 0.10985}, "CVE-2021-3844": {"epss_score": 0.00063, "epss_percentile": 0.19983}, "CVE-2021-3845": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2021-3846": {"epss_score": 0.00237, "epss_percentile": 0.46725}, "CVE-2021-3847": {"epss_score": 0.0003, "epss_percentile": 0.08246}, "CVE-2021-3848": {"epss_score": 0.00067, "epss_percentile": 0.21186}, "CVE-2021-3849": {"epss_score": 0.00507, "epss_percentile": 0.65653}, "CVE-2021-3850": {"epss_score": 0.00359, "epss_percentile": 0.57598}, "CVE-2021-3851": {"epss_score": 0.00169, "epss_percentile": 0.38612}, "CVE-2021-3852": {"epss_score": 0.00196, "epss_percentile": 0.41771}, "CVE-2021-3853": {"epss_score": 0.00234, "epss_percentile": 0.4617}, "CVE-2021-3854": {"epss_score": 0.0007, "epss_percentile": 0.21974}, "CVE-2021-3855": {"epss_score": 0.01683, "epss_percentile": 0.81739}, "CVE-2021-3856": {"epss_score": 0.00364, "epss_percentile": 0.57913}, "CVE-2021-3857": {"epss_score": 0.00152, "epss_percentile": 0.36425}, "CVE-2021-3858": {"epss_score": 0.00154, "epss_percentile": 0.36713}, "CVE-2021-3859": {"epss_score": 0.0029, "epss_percentile": 0.52131}, "CVE-2021-3860": {"epss_score": 0.00247, "epss_percentile": 0.4785}, "CVE-2021-3861": {"epss_score": 0.00049, "epss_percentile": 0.155}, "CVE-2021-3862": {"epss_score": 0.00266, "epss_percentile": 0.49913}, "CVE-2021-3863": {"epss_score": 0.00238, "epss_percentile": 0.46793}, "CVE-2021-3864": {"epss_score": 0.00386, "epss_percentile": 0.59247}, "CVE-2021-3866": {"epss_score": 0.01002, "epss_percentile": 0.76509}, "CVE-2021-3869": {"epss_score": 0.00323, "epss_percentile": 0.54891}, "CVE-2021-3872": {"epss_score": 0.00134, "epss_percentile": 0.33796}, "CVE-2021-3874": {"epss_score": 0.00378, "epss_percentile": 0.58788}, "CVE-2021-3875": {"epss_score": 0.00131, "epss_percentile": 0.33402}, "CVE-2021-3878": {"epss_score": 0.00313, "epss_percentile": 0.54021}, "CVE-2021-3879": {"epss_score": 0.00453, "epss_percentile": 0.63229}, "CVE-2021-3881": {"epss_score": 0.00378, "epss_percentile": 0.58805}, "CVE-2021-3882": {"epss_score": 0.00116, "epss_percentile": 0.31075}, "CVE-2021-3888": {"epss_score": 0.00262, "epss_percentile": 0.49353}, "CVE-2021-3889": {"epss_score": 0.00262, "epss_percentile": 0.49353}, "CVE-2021-3897": {"epss_score": 0.00364, "epss_percentile": 0.57927}, "CVE-2021-3898": {"epss_score": 0.00126, "epss_percentile": 0.32703}, "CVE-2021-3899": {"epss_score": 0.03143, "epss_percentile": 0.86491}, "CVE-2021-3900": {"epss_score": 0.00214, "epss_percentile": 0.43955}, "CVE-2021-3901": {"epss_score": 0.00108, "epss_percentile": 0.29844}, "CVE-2021-3902": {"epss_score": 0.02844, "epss_percentile": 0.85815}, "CVE-2021-3903": {"epss_score": 0.00323, "epss_percentile": 0.54921}, "CVE-2021-3904": {"epss_score": 0.00181, "epss_percentile": 0.40084}, "CVE-2021-3905": {"epss_score": 0.00148, "epss_percentile": 0.3586}, "CVE-2021-3906": {"epss_score": 0.00229, "epss_percentile": 0.4561}, "CVE-2021-3907": {"epss_score": 0.0151, "epss_percentile": 0.80769}, "CVE-2021-3908": {"epss_score": 0.00286, "epss_percentile": 0.51751}, "CVE-2021-3909": {"epss_score": 0.00735, "epss_percentile": 0.72253}, "CVE-2021-3910": {"epss_score": 0.00502, "epss_percentile": 0.65408}, "CVE-2021-3911": {"epss_score": 0.00555, "epss_percentile": 0.67473}, "CVE-2021-3912": {"epss_score": 0.00552, "epss_percentile": 0.67382}, "CVE-2021-3914": {"epss_score": 0.0048, "epss_percentile": 0.64462}, "CVE-2021-3915": {"epss_score": 0.00334, "epss_percentile": 0.55693}, "CVE-2021-3916": {"epss_score": 0.00397, "epss_percentile": 0.60021}, "CVE-2021-3917": {"epss_score": 0.00106, "epss_percentile": 0.29489}, "CVE-2021-3918": {"epss_score": 0.0151, "epss_percentile": 0.8077}, "CVE-2021-3919": {"epss_score": 0.00448, "epss_percentile": 0.63002}, "CVE-2021-3920": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-3921": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2021-3922": {"epss_score": 0.00418, "epss_percentile": 0.61324}, "CVE-2021-3923": {"epss_score": 0.00013, "epss_percentile": 0.01705}, "CVE-2021-3924": {"epss_score": 0.00975, "epss_percentile": 0.76196}, "CVE-2021-3927": {"epss_score": 0.00274, "epss_percentile": 0.50559}, "CVE-2021-3928": {"epss_score": 0.00055, "epss_percentile": 0.17628}, "CVE-2021-3929": {"epss_score": 0.04882, "epss_percentile": 0.8925}, "CVE-2021-3930": {"epss_score": 0.00054, "epss_percentile": 0.17282}, "CVE-2021-3931": {"epss_score": 0.00128, "epss_percentile": 0.3302}, "CVE-2021-3932": {"epss_score": 0.00112, "epss_percentile": 0.30432}, "CVE-2021-3933": {"epss_score": 0.0053, "epss_percentile": 0.66617}, "CVE-2021-3934": {"epss_score": 0.00203, "epss_percentile": 0.42522}, "CVE-2021-3935": {"epss_score": 0.00141, "epss_percentile": 0.34853}, "CVE-2021-3938": {"epss_score": 0.00226, "epss_percentile": 0.45295}, "CVE-2021-3939": {"epss_score": 0.00172, "epss_percentile": 0.38993}, "CVE-2021-3941": {"epss_score": 0.00127, "epss_percentile": 0.32789}, "CVE-2021-3942": {"epss_score": 0.00729, "epss_percentile": 0.72122}, "CVE-2021-3943": {"epss_score": 0.01195, "epss_percentile": 0.78426}, "CVE-2021-3944": {"epss_score": 0.00092, "epss_percentile": 0.26537}, "CVE-2021-3945": {"epss_score": 0.00422, "epss_percentile": 0.61572}, "CVE-2021-3947": {"epss_score": 0.00061, "epss_percentile": 0.19422}, "CVE-2021-3948": {"epss_score": 0.00192, "epss_percentile": 0.41308}, "CVE-2021-3950": {"epss_score": 0.00357, "epss_percentile": 0.57409}, "CVE-2021-3956": {"epss_score": 0.00183, "epss_percentile": 0.40331}, "CVE-2021-3957": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2021-3958": {"epss_score": 0.02197, "epss_percentile": 0.83961}, "CVE-2021-3959": {"epss_score": 0.00222, "epss_percentile": 0.44795}, "CVE-2021-3960": {"epss_score": 0.00047, "epss_percentile": 0.14758}, "CVE-2021-3961": {"epss_score": 0.00326, "epss_percentile": 0.5505}, "CVE-2021-3962": {"epss_score": 0.00312, "epss_percentile": 0.53984}, "CVE-2021-3963": {"epss_score": 0.00098, "epss_percentile": 0.27733}, "CVE-2021-3964": {"epss_score": 0.00178, "epss_percentile": 0.39685}, "CVE-2021-3965": {"epss_score": 0.00255, "epss_percentile": 0.48729}, "CVE-2021-3966": {"epss_score": 0.00069, "epss_percentile": 0.21445}, "CVE-2021-3967": {"epss_score": 0.00306, "epss_percentile": 0.53443}, "CVE-2021-3968": {"epss_score": 0.00358, "epss_percentile": 0.57537}, "CVE-2021-3969": {"epss_score": 0.00418, "epss_percentile": 0.61324}, "CVE-2021-3970": {"epss_score": 0.00364, "epss_percentile": 0.57943}, "CVE-2021-3971": {"epss_score": 0.00801, "epss_percentile": 0.73565}, "CVE-2021-3972": {"epss_score": 0.03212, "epss_percentile": 0.86656}, "CVE-2021-3973": {"epss_score": 0.00138, "epss_percentile": 0.34427}, "CVE-2021-3974": {"epss_score": 0.00195, "epss_percentile": 0.41644}, "CVE-2021-3975": {"epss_score": 0.00427, "epss_percentile": 0.61917}, "CVE-2021-3976": {"epss_score": 0.00098, "epss_percentile": 0.27733}, "CVE-2021-3977": {"epss_score": 0.00249, "epss_percentile": 0.48021}, "CVE-2021-3978": {"epss_score": 0.00021, "epss_percentile": 0.04912}, "CVE-2021-3979": {"epss_score": 0.00244, "epss_percentile": 0.47516}, "CVE-2021-3980": {"epss_score": 0.0064, "epss_percentile": 0.69963}, "CVE-2021-3981": {"epss_score": 0.00024, "epss_percentile": 0.0601}, "CVE-2021-3982": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2021-3983": {"epss_score": 0.00206, "epss_percentile": 0.43044}, "CVE-2021-3984": {"epss_score": 0.00223, "epss_percentile": 0.44888}, "CVE-2021-3985": {"epss_score": 0.00433, "epss_percentile": 0.62207}, "CVE-2021-3986": {"epss_score": 0.00147, "epss_percentile": 0.35741}, "CVE-2021-3987": {"epss_score": 0.00109, "epss_percentile": 0.2995}, "CVE-2021-3988": {"epss_score": 0.00175, "epss_percentile": 0.39307}, "CVE-2021-3989": {"epss_score": 0.00207, "epss_percentile": 0.43155}, "CVE-2021-3990": {"epss_score": 0.00301, "epss_percentile": 0.53056}, "CVE-2021-3991": {"epss_score": 0.00051, "epss_percentile": 0.16285}, "CVE-2021-3992": {"epss_score": 0.00226, "epss_percentile": 0.45313}, "CVE-2021-3993": {"epss_score": 0.00117, "epss_percentile": 0.31307}, "CVE-2021-3994": {"epss_score": 0.0048, "epss_percentile": 0.64454}, "CVE-2021-3995": {"epss_score": 0.00271, "epss_percentile": 0.50296}, "CVE-2021-3996": {"epss_score": 0.00233, "epss_percentile": 0.46034}, "CVE-2021-3997": {"epss_score": 0.00022, "epss_percentile": 0.05006}, "CVE-2021-3998": {"epss_score": 0.00121, "epss_percentile": 0.32008}, "CVE-2021-3999": {"epss_score": 0.01019, "epss_percentile": 0.76719}, "CVE-2021-40000": {"epss_score": 0.00048, "epss_percentile": 0.15077}, "CVE-2021-40001": {"epss_score": 0.00178, "epss_percentile": 0.39649}, "CVE-2021-40002": {"epss_score": 0.00048, "epss_percentile": 0.15077}, "CVE-2021-40003": {"epss_score": 0.00126, "epss_percentile": 0.32639}, "CVE-2021-40004": {"epss_score": 0.00129, "epss_percentile": 0.33131}, "CVE-2021-40005": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2021-40006": {"epss_score": 0.00031, "epss_percentile": 0.0847}, "CVE-2021-40007": {"epss_score": 0.00153, "epss_percentile": 0.36549}, "CVE-2021-40008": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2021-40009": {"epss_score": 0.00153, "epss_percentile": 0.36643}, "CVE-2021-40010": {"epss_score": 0.00837, "epss_percentile": 0.74156}, "CVE-2021-40011": {"epss_score": 0.00135, "epss_percentile": 0.33998}, "CVE-2021-40012": {"epss_score": 0.0018, "epss_percentile": 0.39973}, "CVE-2021-40013": {"epss_score": 0.00036, "epss_percentile": 0.10291}, "CVE-2021-40014": {"epss_score": 0.00302, "epss_percentile": 0.53132}, "CVE-2021-40015": {"epss_score": 0.00016, "epss_percentile": 0.02851}, "CVE-2021-40016": {"epss_score": 0.00044, "epss_percentile": 0.13665}, "CVE-2021-40017": {"epss_score": 0.00229, "epss_percentile": 0.45613}, "CVE-2021-40018": {"epss_score": 0.0016, "epss_percentile": 0.37475}, "CVE-2021-40019": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-40020": {"epss_score": 0.00187, "epss_percentile": 0.40724}, "CVE-2021-40021": {"epss_score": 0.00187, "epss_percentile": 0.40724}, "CVE-2021-40022": {"epss_score": 0.00187, "epss_percentile": 0.40724}, "CVE-2021-40023": {"epss_score": 0.00187, "epss_percentile": 0.40724}, "CVE-2021-40024": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-40025": {"epss_score": 0.00187, "epss_percentile": 0.40724}, "CVE-2021-40026": {"epss_score": 0.00106, "epss_percentile": 0.29448}, "CVE-2021-40027": {"epss_score": 0.00192, "epss_percentile": 0.41294}, "CVE-2021-40028": {"epss_score": 0.00164, "epss_percentile": 0.37917}, "CVE-2021-40029": {"epss_score": 0.00206, "epss_percentile": 0.4292}, "CVE-2021-40030": {"epss_score": 0.00155, "epss_percentile": 0.36763}, "CVE-2021-40031": {"epss_score": 0.00113, "epss_percentile": 0.30681}, "CVE-2021-40032": {"epss_score": 0.00224, "epss_percentile": 0.4497}, "CVE-2021-40033": {"epss_score": 0.00028, "epss_percentile": 0.07471}, "CVE-2021-40034": {"epss_score": 0.00218, "epss_percentile": 0.44434}, "CVE-2021-40035": {"epss_score": 0.00206, "epss_percentile": 0.4292}, "CVE-2021-40036": {"epss_score": 0.00276, "epss_percentile": 0.50714}, "CVE-2021-40037": {"epss_score": 0.00019, "epss_percentile": 0.04095}, "CVE-2021-40038": {"epss_score": 0.00098, "epss_percentile": 0.27757}, "CVE-2021-40039": {"epss_score": 0.00098, "epss_percentile": 0.2782}, "CVE-2021-40040": {"epss_score": 0.00162, "epss_percentile": 0.37742}, "CVE-2021-40041": {"epss_score": 0.00062, "epss_percentile": 0.19767}, "CVE-2021-40042": {"epss_score": 0.00174, "epss_percentile": 0.39177}, "CVE-2021-40043": {"epss_score": 0.00191, "epss_percentile": 0.41207}, "CVE-2021-40044": {"epss_score": 0.0006, "epss_percentile": 0.19169}, "CVE-2021-40045": {"epss_score": 0.00123, "epss_percentile": 0.32253}, "CVE-2021-40046": {"epss_score": 0.00236, "epss_percentile": 0.46368}, "CVE-2021-40047": {"epss_score": 0.00095, "epss_percentile": 0.27087}, "CVE-2021-40048": {"epss_score": 0.00149, "epss_percentile": 0.36022}, "CVE-2021-40049": {"epss_score": 0.00112, "epss_percentile": 0.30525}, "CVE-2021-40050": {"epss_score": 0.0023, "epss_percentile": 0.45718}, "CVE-2021-40051": {"epss_score": 0.00156, "epss_percentile": 0.37007}, "CVE-2021-40052": {"epss_score": 0.00743, "epss_percentile": 0.72476}, "CVE-2021-40053": {"epss_score": 0.00154, "epss_percentile": 0.36729}, "CVE-2021-40054": {"epss_score": 0.00109, "epss_percentile": 0.29922}, "CVE-2021-40055": {"epss_score": 0.00095, "epss_percentile": 0.27087}, "CVE-2021-40056": {"epss_score": 0.00258, "epss_percentile": 0.49004}, "CVE-2021-40057": {"epss_score": 0.00266, "epss_percentile": 0.49873}, "CVE-2021-40058": {"epss_score": 0.00266, "epss_percentile": 0.49873}, "CVE-2021-40059": {"epss_score": 0.00042, "epss_percentile": 0.12727}, "CVE-2021-40060": {"epss_score": 0.00266, "epss_percentile": 0.49873}, "CVE-2021-40061": {"epss_score": 0.00098, "epss_percentile": 0.27757}, "CVE-2021-40062": {"epss_score": 0.00258, "epss_percentile": 0.49004}, "CVE-2021-40063": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-40064": {"epss_score": 0.00161, "epss_percentile": 0.3757}, "CVE-2021-40065": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-40066": {"epss_score": 0.00162, "epss_percentile": 0.37731}, "CVE-2021-40067": {"epss_score": 0.00158, "epss_percentile": 0.37145}, "CVE-2021-40083": {"epss_score": 0.0084, "epss_percentile": 0.74203}, "CVE-2021-40084": {"epss_score": 0.01275, "epss_percentile": 0.79106}, "CVE-2021-40085": {"epss_score": 0.00412, "epss_percentile": 0.60952}, "CVE-2021-40086": {"epss_score": 0.00205, "epss_percentile": 0.42707}, "CVE-2021-40087": {"epss_score": 0.00096, "epss_percentile": 0.27279}, "CVE-2021-40088": {"epss_score": 0.00127, "epss_percentile": 0.32925}, "CVE-2021-40089": {"epss_score": 0.00053, "epss_percentile": 0.16929}, "CVE-2021-40091": {"epss_score": 0.00365, "epss_percentile": 0.58}, "CVE-2021-40092": {"epss_score": 0.00202, "epss_percentile": 0.42485}, "CVE-2021-40093": {"epss_score": 0.00202, "epss_percentile": 0.42485}, "CVE-2021-40094": {"epss_score": 0.00308, "epss_percentile": 0.5364}, "CVE-2021-40095": {"epss_score": 0.00184, "epss_percentile": 0.40445}, "CVE-2021-40096": {"epss_score": 0.00232, "epss_percentile": 0.45911}, "CVE-2021-40097": {"epss_score": 0.04123, "epss_percentile": 0.88287}, "CVE-2021-40098": {"epss_score": 0.0051, "epss_percentile": 0.65759}, "CVE-2021-40099": {"epss_score": 0.03585, "epss_percentile": 0.87391}, "CVE-2021-40100": {"epss_score": 0.00252, "epss_percentile": 0.48383}, "CVE-2021-40101": {"epss_score": 0.09143, "epss_percentile": 0.9242}, "CVE-2021-40102": {"epss_score": 0.00681, "epss_percentile": 0.71047}, "CVE-2021-40103": {"epss_score": 0.00396, "epss_percentile": 0.59925}, "CVE-2021-40104": {"epss_score": 0.00419, "epss_percentile": 0.61354}, "CVE-2021-40105": {"epss_score": 0.00261, "epss_percentile": 0.49283}, "CVE-2021-40106": {"epss_score": 0.00405, "epss_percentile": 0.60463}, "CVE-2021-40108": {"epss_score": 0.00125, "epss_percentile": 0.32588}, "CVE-2021-40109": {"epss_score": 0.00099, "epss_percentile": 0.28352}, "CVE-2021-40110": {"epss_score": 0.00496, "epss_percentile": 0.6515}, "CVE-2021-40111": {"epss_score": 0.00585, "epss_percentile": 0.68399}, "CVE-2021-40112": {"epss_score": 0.02351, "epss_percentile": 0.8447}, "CVE-2021-40113": {"epss_score": 0.21921, "epss_percentile": 0.95572}, "CVE-2021-40114": {"epss_score": 0.01356, "epss_percentile": 0.79716}, "CVE-2021-40115": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2021-40116": {"epss_score": 0.00784, "epss_percentile": 0.73232}, "CVE-2021-40117": {"epss_score": 0.00837, "epss_percentile": 0.74164}, "CVE-2021-40118": {"epss_score": 0.00263, "epss_percentile": 0.49536}, "CVE-2021-40119": {"epss_score": 0.07643, "epss_percentile": 0.91597}, "CVE-2021-40120": {"epss_score": 0.00482, "epss_percentile": 0.64538}, "CVE-2021-40121": {"epss_score": 0.00274, "epss_percentile": 0.50508}, "CVE-2021-40122": {"epss_score": 0.00376, "epss_percentile": 0.58685}, "CVE-2021-40123": {"epss_score": 0.00048, "epss_percentile": 0.14948}, "CVE-2021-40124": {"epss_score": 0.00036, "epss_percentile": 0.10497}, "CVE-2021-40125": {"epss_score": 0.00332, "epss_percentile": 0.55553}, "CVE-2021-40126": {"epss_score": 0.00151, "epss_percentile": 0.36229}, "CVE-2021-40127": {"epss_score": 0.00152, "epss_percentile": 0.36497}, "CVE-2021-40128": {"epss_score": 0.00085, "epss_percentile": 0.25244}, "CVE-2021-40129": {"epss_score": 0.00251, "epss_percentile": 0.48331}, "CVE-2021-40130": {"epss_score": 0.00182, "epss_percentile": 0.40146}, "CVE-2021-40131": {"epss_score": 0.00208, "epss_percentile": 0.43215}, "CVE-2021-40142": {"epss_score": 0.00802, "epss_percentile": 0.73582}, "CVE-2021-40143": {"epss_score": 0.00929, "epss_percentile": 0.75594}, "CVE-2021-40145": {"epss_score": 0.00537, "epss_percentile": 0.66922}, "CVE-2021-40146": {"epss_score": 0.04295, "epss_percentile": 0.88507}, "CVE-2021-40147": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-40148": {"epss_score": 0.00202, "epss_percentile": 0.42443}, "CVE-2021-40149": {"epss_score": 0.59239, "epss_percentile": 0.98156}, "CVE-2021-40150": {"epss_score": 0.34226, "epss_percentile": 0.96834}, "CVE-2021-40153": {"epss_score": 0.00542, "epss_percentile": 0.67075}, "CVE-2021-40154": {"epss_score": 0.00993, "epss_percentile": 0.76411}, "CVE-2021-40155": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-40156": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-40157": {"epss_score": 0.00141, "epss_percentile": 0.34811}, "CVE-2021-40158": {"epss_score": 0.00443, "epss_percentile": 0.62802}, "CVE-2021-40159": {"epss_score": 0.00342, "epss_percentile": 0.56392}, "CVE-2021-40160": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-40161": {"epss_score": 0.00064, "epss_percentile": 0.20141}, "CVE-2021-40162": {"epss_score": 0.00116, "epss_percentile": 0.31198}, "CVE-2021-40163": {"epss_score": 0.00116, "epss_percentile": 0.31198}, "CVE-2021-40164": {"epss_score": 0.00121, "epss_percentile": 0.31818}, "CVE-2021-40165": {"epss_score": 0.00116, "epss_percentile": 0.31198}, "CVE-2021-40166": {"epss_score": 0.00116, "epss_percentile": 0.31198}, "CVE-2021-40167": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-40170": {"epss_score": 0.00245, "epss_percentile": 0.47631}, "CVE-2021-40171": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2021-40172": {"epss_score": 0.00575, "epss_percentile": 0.6811}, "CVE-2021-40173": {"epss_score": 0.00575, "epss_percentile": 0.6811}, "CVE-2021-40174": {"epss_score": 0.00575, "epss_percentile": 0.6811}, "CVE-2021-40175": {"epss_score": 0.09319, "epss_percentile": 0.92499}, "CVE-2021-40176": {"epss_score": 0.0387, "epss_percentile": 0.8788}, "CVE-2021-40177": {"epss_score": 0.06834, "epss_percentile": 0.91056}, "CVE-2021-40178": {"epss_score": 0.0387, "epss_percentile": 0.8788}, "CVE-2021-40180": {"epss_score": 0.00421, "epss_percentile": 0.61494}, "CVE-2021-40186": {"epss_score": 0.00311, "epss_percentile": 0.53927}, "CVE-2021-40188": {"epss_score": 0.00833, "epss_percentile": 0.74083}, "CVE-2021-40189": {"epss_score": 0.01953, "epss_percentile": 0.83025}, "CVE-2021-40191": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-40211": {"epss_score": 0.00092, "epss_percentile": 0.26504}, "CVE-2021-40212": {"epss_score": 0.01214, "epss_percentile": 0.78572}, "CVE-2021-40214": {"epss_score": 0.00353, "epss_percentile": 0.5716}, "CVE-2021-40219": {"epss_score": 0.05034, "epss_percentile": 0.89417}, "CVE-2021-40222": {"epss_score": 0.08052, "epss_percentile": 0.91855}, "CVE-2021-40223": {"epss_score": 0.00247, "epss_percentile": 0.47836}, "CVE-2021-40226": {"epss_score": 0.00526, "epss_percentile": 0.66396}, "CVE-2021-40238": {"epss_score": 0.00634, "epss_percentile": 0.69803}, "CVE-2021-40239": {"epss_score": 0.00414, "epss_percentile": 0.61033}, "CVE-2021-40241": {"epss_score": 0.00095, "epss_percentile": 0.27199}, "CVE-2021-40247": {"epss_score": 0.07821, "epss_percentile": 0.91698}, "CVE-2021-40260": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-40261": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2021-40262": {"epss_score": 0.00063, "epss_percentile": 0.19987}, "CVE-2021-40263": {"epss_score": 0.00108, "epss_percentile": 0.29818}, "CVE-2021-40264": {"epss_score": 0.00067, "epss_percentile": 0.21133}, "CVE-2021-40265": {"epss_score": 0.00226, "epss_percentile": 0.45284}, "CVE-2021-40266": {"epss_score": 0.00083, "epss_percentile": 0.24823}, "CVE-2021-40272": {"epss_score": 0.04872, "epss_percentile": 0.89233}, "CVE-2021-40279": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2021-40280": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2021-40281": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2021-40282": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2021-40284": {"epss_score": 0.00231, "epss_percentile": 0.45766}, "CVE-2021-40285": {"epss_score": 0.00389, "epss_percentile": 0.59402}, "CVE-2021-40288": {"epss_score": 0.01958, "epss_percentile": 0.8305}, "CVE-2021-40289": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2021-40292": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2021-40303": {"epss_score": 0.00164, "epss_percentile": 0.37873}, "CVE-2021-40309": {"epss_score": 0.0092, "epss_percentile": 0.75474}, "CVE-2021-40310": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2021-40313": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2021-40317": {"epss_score": 0.00279, "epss_percentile": 0.50967}, "CVE-2021-40323": {"epss_score": 0.93171, "epss_percentile": 0.9978}, "CVE-2021-40324": {"epss_score": 0.0239, "epss_percentile": 0.84598}, "CVE-2021-40325": {"epss_score": 0.00024, "epss_percentile": 0.06034}, "CVE-2021-40326": {"epss_score": 0.00064, "epss_percentile": 0.20108}, "CVE-2021-40327": {"epss_score": 0.0033, "epss_percentile": 0.55484}, "CVE-2021-40329": {"epss_score": 0.00404, "epss_percentile": 0.60427}, "CVE-2021-40330": {"epss_score": 0.00447, "epss_percentile": 0.62976}, "CVE-2021-40331": {"epss_score": 0.0009, "epss_percentile": 0.26102}, "CVE-2021-40333": {"epss_score": 0.00198, "epss_percentile": 0.4199}, "CVE-2021-40334": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2021-40335": {"epss_score": 0.0024, "epss_percentile": 0.4695}, "CVE-2021-40336": {"epss_score": 0.00485, "epss_percentile": 0.64726}, "CVE-2021-40337": {"epss_score": 0.00476, "epss_percentile": 0.64261}, "CVE-2021-40338": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2021-40339": {"epss_score": 0.00307, "epss_percentile": 0.53534}, "CVE-2021-40340": {"epss_score": 0.00307, "epss_percentile": 0.53534}, "CVE-2021-40341": {"epss_score": 0.00035, "epss_percentile": 0.10046}, "CVE-2021-40342": {"epss_score": 0.00153, "epss_percentile": 0.36614}, "CVE-2021-40343": {"epss_score": 0.00573, "epss_percentile": 0.68043}, "CVE-2021-40344": {"epss_score": 0.6721, "epss_percentile": 0.98499}, "CVE-2021-40345": {"epss_score": 0.7475, "epss_percentile": 0.98816}, "CVE-2021-40346": {"epss_score": 0.92714, "epss_percentile": 0.99737}, "CVE-2021-40347": {"epss_score": 0.00213, "epss_percentile": 0.43841}, "CVE-2021-40348": {"epss_score": 0.00447, "epss_percentile": 0.62963}, "CVE-2021-40349": {"epss_score": 0.00223, "epss_percentile": 0.44848}, "CVE-2021-40350": {"epss_score": 0.00398, "epss_percentile": 0.60071}, "CVE-2021-40352": {"epss_score": 0.04642, "epss_percentile": 0.88954}, "CVE-2021-40353": {"epss_score": 0.0903, "epss_percentile": 0.92374}, "CVE-2021-40354": {"epss_score": 0.00209, "epss_percentile": 0.43311}, "CVE-2021-40355": {"epss_score": 0.00395, "epss_percentile": 0.59807}, "CVE-2021-40356": {"epss_score": 0.00307, "epss_percentile": 0.53501}, "CVE-2021-40357": {"epss_score": 0.0058, "epss_percentile": 0.68243}, "CVE-2021-40358": {"epss_score": 0.00695, "epss_percentile": 0.71377}, "CVE-2021-40359": {"epss_score": 0.00469, "epss_percentile": 0.63943}, "CVE-2021-40360": {"epss_score": 0.00264, "epss_percentile": 0.49572}, "CVE-2021-40363": {"epss_score": 0.00026, "epss_percentile": 0.06468}, "CVE-2021-40364": {"epss_score": 0.00052, "epss_percentile": 0.16442}, "CVE-2021-40365": {"epss_score": 0.00216, "epss_percentile": 0.44204}, "CVE-2021-40366": {"epss_score": 0.00073, "epss_percentile": 0.22674}, "CVE-2021-40367": {"epss_score": 0.0005, "epss_percentile": 0.15899}, "CVE-2021-40368": {"epss_score": 0.00444, "epss_percentile": 0.62829}, "CVE-2021-40369": {"epss_score": 0.09621, "epss_percentile": 0.92627}, "CVE-2021-40371": {"epss_score": 0.0456, "epss_percentile": 0.8885}, "CVE-2021-40373": {"epss_score": 0.25494, "epss_percentile": 0.96034}, "CVE-2021-40374": {"epss_score": 0.01908, "epss_percentile": 0.82815}, "CVE-2021-40375": {"epss_score": 0.00642, "epss_percentile": 0.70032}, "CVE-2021-40376": {"epss_score": 0.00039, "epss_percentile": 0.11473}, "CVE-2021-40377": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-40378": {"epss_score": 0.40608, "epss_percentile": 0.97225}, "CVE-2021-40379": {"epss_score": 0.40065, "epss_percentile": 0.97193}, "CVE-2021-40380": {"epss_score": 0.39532, "epss_percentile": 0.97165}, "CVE-2021-40381": {"epss_score": 0.39532, "epss_percentile": 0.97165}, "CVE-2021-40382": {"epss_score": 0.39532, "epss_percentile": 0.97165}, "CVE-2021-40385": {"epss_score": 0.00433, "epss_percentile": 0.62186}, "CVE-2021-40386": {"epss_score": 0.02509, "epss_percentile": 0.84946}, "CVE-2021-40387": {"epss_score": 0.05703, "epss_percentile": 0.90133}, "CVE-2021-40388": {"epss_score": 0.00038, "epss_percentile": 0.11117}, "CVE-2021-40389": {"epss_score": 0.00038, "epss_percentile": 0.11117}, "CVE-2021-40390": {"epss_score": 0.00328, "epss_percentile": 0.55189}, "CVE-2021-40391": {"epss_score": 0.00473, "epss_percentile": 0.64106}, "CVE-2021-40392": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2021-40393": {"epss_score": 0.00277, "epss_percentile": 0.50778}, "CVE-2021-40394": {"epss_score": 0.00556, "epss_percentile": 0.67522}, "CVE-2021-40396": {"epss_score": 0.00038, "epss_percentile": 0.11117}, "CVE-2021-40397": {"epss_score": 0.00122, "epss_percentile": 0.3213}, "CVE-2021-40398": {"epss_score": 0.00237, "epss_percentile": 0.46692}, "CVE-2021-40399": {"epss_score": 0.00688, "epss_percentile": 0.71199}, "CVE-2021-40400": {"epss_score": 0.00213, "epss_percentile": 0.43826}, "CVE-2021-40401": {"epss_score": 0.00269, "epss_percentile": 0.50118}, "CVE-2021-40402": {"epss_score": 0.00364, "epss_percentile": 0.57933}, "CVE-2021-40403": {"epss_score": 0.0013, "epss_percentile": 0.33226}, "CVE-2021-40404": {"epss_score": 0.00252, "epss_percentile": 0.48365}, "CVE-2021-40405": {"epss_score": 0.00149, "epss_percentile": 0.35996}, "CVE-2021-40406": {"epss_score": 0.00616, "epss_percentile": 0.69324}, "CVE-2021-40407": {"epss_score": 0.34176, "epss_percentile": 0.96828}, "CVE-2021-40408": {"epss_score": 0.05354, "epss_percentile": 0.89777}, "CVE-2021-40409": {"epss_score": 0.05354, "epss_percentile": 0.89777}, "CVE-2021-40410": {"epss_score": 0.04806, "epss_percentile": 0.89162}, "CVE-2021-40411": {"epss_score": 0.03859, "epss_percentile": 0.87862}, "CVE-2021-40412": {"epss_score": 0.04806, "epss_percentile": 0.89162}, "CVE-2021-40413": {"epss_score": 0.00207, "epss_percentile": 0.43083}, "CVE-2021-40414": {"epss_score": 0.00207, "epss_percentile": 0.43083}, "CVE-2021-40415": {"epss_score": 0.00183, "epss_percentile": 0.40319}, "CVE-2021-40416": {"epss_score": 0.00284, "epss_percentile": 0.5143}, "CVE-2021-40417": {"epss_score": 0.0154, "epss_percentile": 0.8094}, "CVE-2021-40418": {"epss_score": 0.01325, "epss_percentile": 0.79473}, "CVE-2021-40419": {"epss_score": 0.00511, "epss_percentile": 0.65829}, "CVE-2021-40420": {"epss_score": 0.00603, "epss_percentile": 0.68936}, "CVE-2021-40422": {"epss_score": 0.10738, "epss_percentile": 0.93088}, "CVE-2021-40423": {"epss_score": 0.00271, "epss_percentile": 0.503}, "CVE-2021-40424": {"epss_score": 0.0006, "epss_percentile": 0.1916}, "CVE-2021-40425": {"epss_score": 0.00049, "epss_percentile": 0.153}, "CVE-2021-40426": {"epss_score": 0.00136, "epss_percentile": 0.34112}, "CVE-2021-40438": {"epss_score": 0.94432, "epss_percentile": 0.99983}, "CVE-2021-40439": {"epss_score": 0.00533, "epss_percentile": 0.6676}, "CVE-2021-40440": {"epss_score": 0.00707, "epss_percentile": 0.71659}, "CVE-2021-40441": {"epss_score": 0.00338, "epss_percentile": 0.56115}, "CVE-2021-40442": {"epss_score": 0.03472, "epss_percentile": 0.87202}, "CVE-2021-40443": {"epss_score": 0.00312, "epss_percentile": 0.53989}, "CVE-2021-40444": {"epss_score": 0.94332, "epss_percentile": 0.9995}, "CVE-2021-40447": {"epss_score": 0.00252, "epss_percentile": 0.48378}, "CVE-2021-40448": {"epss_score": 0.01236, "epss_percentile": 0.78768}, "CVE-2021-40449": {"epss_score": 0.91886, "epss_percentile": 0.99675}, "CVE-2021-40450": {"epss_score": 0.07526, "epss_percentile": 0.91517}, "CVE-2021-40452": {"epss_score": 0.02648, "epss_percentile": 0.85338}, "CVE-2021-40453": {"epss_score": 0.03472, "epss_percentile": 0.87202}, "CVE-2021-40454": {"epss_score": 0.00113, "epss_percentile": 0.30722}, "CVE-2021-40455": {"epss_score": 0.00593, "epss_percentile": 0.68644}, "CVE-2021-40456": {"epss_score": 0.01338, "epss_percentile": 0.79569}, "CVE-2021-40457": {"epss_score": 0.00697, "epss_percentile": 0.714}, "CVE-2021-40460": {"epss_score": 0.01299, "epss_percentile": 0.79285}, "CVE-2021-40461": {"epss_score": 0.00558, "epss_percentile": 0.67575}, "CVE-2021-40462": {"epss_score": 0.0306, "epss_percentile": 0.86306}, "CVE-2021-40463": {"epss_score": 0.15342, "epss_percentile": 0.94413}, "CVE-2021-40464": {"epss_score": 0.00578, "epss_percentile": 0.6819}, "CVE-2021-40465": {"epss_score": 0.02726, "epss_percentile": 0.85526}, "CVE-2021-40466": {"epss_score": 0.00312, "epss_percentile": 0.53989}, "CVE-2021-40467": {"epss_score": 0.00414, "epss_percentile": 0.61034}, "CVE-2021-40468": {"epss_score": 0.00488, "epss_percentile": 0.64844}, "CVE-2021-40469": {"epss_score": 0.16904, "epss_percentile": 0.94746}, "CVE-2021-40470": {"epss_score": 0.00332, "epss_percentile": 0.55588}, "CVE-2021-40471": {"epss_score": 0.04005, "epss_percentile": 0.881}, "CVE-2021-40472": {"epss_score": 0.00542, "epss_percentile": 0.6708}, "CVE-2021-40473": {"epss_score": 0.04005, "epss_percentile": 0.881}, "CVE-2021-40474": {"epss_score": 0.04005, "epss_percentile": 0.881}, "CVE-2021-40475": {"epss_score": 0.00403, "epss_percentile": 0.60347}, "CVE-2021-40476": {"epss_score": 0.00441, "epss_percentile": 0.62674}, "CVE-2021-40477": {"epss_score": 0.00289, "epss_percentile": 0.52077}, "CVE-2021-40478": {"epss_score": 0.00342, "epss_percentile": 0.56388}, "CVE-2021-40479": {"epss_score": 0.04005, "epss_percentile": 0.881}, "CVE-2021-40480": {"epss_score": 0.04235, "epss_percentile": 0.88427}, "CVE-2021-40481": {"epss_score": 0.04892, "epss_percentile": 0.89265}, "CVE-2021-40482": {"epss_score": 0.02815, "epss_percentile": 0.8573}, "CVE-2021-40483": {"epss_score": 0.06132, "epss_percentile": 0.90503}, "CVE-2021-40484": {"epss_score": 0.06132, "epss_percentile": 0.90503}, "CVE-2021-40485": {"epss_score": 0.00619, "epss_percentile": 0.69387}, "CVE-2021-40486": {"epss_score": 0.04235, "epss_percentile": 0.88427}, "CVE-2021-40487": {"epss_score": 0.00875, "epss_percentile": 0.74784}, "CVE-2021-40488": {"epss_score": 0.00342, "epss_percentile": 0.56388}, "CVE-2021-40489": {"epss_score": 0.00297, "epss_percentile": 0.527}, "CVE-2021-40490": {"epss_score": 0.00034, "epss_percentile": 0.09652}, "CVE-2021-40491": {"epss_score": 0.00271, "epss_percentile": 0.50286}, "CVE-2021-40492": {"epss_score": 0.09965, "epss_percentile": 0.92796}, "CVE-2021-40493": {"epss_score": 0.3877, "epss_percentile": 0.97119}, "CVE-2021-40494": {"epss_score": 0.0026, "epss_percentile": 0.49236}, "CVE-2021-40495": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2021-40496": {"epss_score": 0.00416, "epss_percentile": 0.61164}, "CVE-2021-40497": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2021-40498": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2021-40499": {"epss_score": 0.00688, "epss_percentile": 0.71194}, "CVE-2021-40500": {"epss_score": 0.01212, "epss_percentile": 0.7856}, "CVE-2021-40501": {"epss_score": 0.00182, "epss_percentile": 0.40197}, "CVE-2021-40502": {"epss_score": 0.00353, "epss_percentile": 0.57174}, "CVE-2021-40503": {"epss_score": 0.00041, "epss_percentile": 0.12343}, "CVE-2021-40504": {"epss_score": 0.00106, "epss_percentile": 0.29416}, "CVE-2021-40506": {"epss_score": 0.00111, "epss_percentile": 0.30251}, "CVE-2021-40507": {"epss_score": 0.00111, "epss_percentile": 0.30251}, "CVE-2021-40509": {"epss_score": 0.0058, "epss_percentile": 0.68253}, "CVE-2021-40510": {"epss_score": 0.00728, "epss_percentile": 0.72109}, "CVE-2021-40511": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2021-40516": {"epss_score": 0.00981, "epss_percentile": 0.76278}, "CVE-2021-40517": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-40518": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2021-40519": {"epss_score": 0.00314, "epss_percentile": 0.54086}, "CVE-2021-40520": {"epss_score": 0.00405, "epss_percentile": 0.60482}, "CVE-2021-40521": {"epss_score": 0.08856, "epss_percentile": 0.92287}, "CVE-2021-40523": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-40524": {"epss_score": 0.24037, "epss_percentile": 0.95848}, "CVE-2021-40525": {"epss_score": 0.02773, "epss_percentile": 0.8563}, "CVE-2021-40526": {"epss_score": 0.00813, "epss_percentile": 0.73758}, "CVE-2021-40527": {"epss_score": 0.00154, "epss_percentile": 0.36738}, "CVE-2021-40528": {"epss_score": 0.00097, "epss_percentile": 0.27552}, "CVE-2021-40529": {"epss_score": 0.003, "epss_percentile": 0.52935}, "CVE-2021-40530": {"epss_score": 0.00257, "epss_percentile": 0.48843}, "CVE-2021-40531": {"epss_score": 0.06708, "epss_percentile": 0.90961}, "CVE-2021-40532": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-40537": {"epss_score": 0.00273, "epss_percentile": 0.50472}, "CVE-2021-40539": {"epss_score": 0.94424, "epss_percentile": 0.9998}, "CVE-2021-40540": {"epss_score": 0.0275, "epss_percentile": 0.8558}, "CVE-2021-40541": {"epss_score": 0.00425, "epss_percentile": 0.61705}, "CVE-2021-40542": {"epss_score": 0.25259, "epss_percentile": 0.96004}, "CVE-2021-40543": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2021-40546": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2021-40553": {"epss_score": 0.03121, "epss_percentile": 0.86449}, "CVE-2021-40555": {"epss_score": 0.00108, "epss_percentile": 0.2987}, "CVE-2021-40556": {"epss_score": 0.01085, "epss_percentile": 0.77404}, "CVE-2021-40559": {"epss_score": 0.00112, "epss_percentile": 0.30477}, "CVE-2021-40562": {"epss_score": 0.00124, "epss_percentile": 0.32399}, "CVE-2021-40563": {"epss_score": 0.00124, "epss_percentile": 0.32399}, "CVE-2021-40564": {"epss_score": 0.00115, "epss_percentile": 0.30903}, "CVE-2021-40565": {"epss_score": 0.00124, "epss_percentile": 0.32399}, "CVE-2021-40566": {"epss_score": 0.00123, "epss_percentile": 0.32226}, "CVE-2021-40567": {"epss_score": 0.00107, "epss_percentile": 0.29593}, "CVE-2021-40568": {"epss_score": 0.0019, "epss_percentile": 0.41095}, "CVE-2021-40569": {"epss_score": 0.00114, "epss_percentile": 0.30847}, "CVE-2021-40570": {"epss_score": 0.00168, "epss_percentile": 0.38462}, "CVE-2021-40571": {"epss_score": 0.00146, "epss_percentile": 0.35537}, "CVE-2021-40572": {"epss_score": 0.00114, "epss_percentile": 0.30847}, "CVE-2021-40573": {"epss_score": 0.00252, "epss_percentile": 0.48359}, "CVE-2021-40574": {"epss_score": 0.00555, "epss_percentile": 0.67487}, "CVE-2021-40575": {"epss_score": 0.00107, "epss_percentile": 0.29593}, "CVE-2021-40576": {"epss_score": 0.00107, "epss_percentile": 0.29593}, "CVE-2021-40577": {"epss_score": 0.0019, "epss_percentile": 0.41055}, "CVE-2021-40578": {"epss_score": 0.00524, "epss_percentile": 0.66319}, "CVE-2021-40579": {"epss_score": 0.00218, "epss_percentile": 0.44391}, "CVE-2021-40589": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2021-40592": {"epss_score": 0.00083, "epss_percentile": 0.24698}, "CVE-2021-40595": {"epss_score": 0.00578, "epss_percentile": 0.68193}, "CVE-2021-40596": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-40597": {"epss_score": 0.00759, "epss_percentile": 0.72789}, "CVE-2021-40604": {"epss_score": 0.00547, "epss_percentile": 0.67257}, "CVE-2021-40606": {"epss_score": 0.00076, "epss_percentile": 0.23141}, "CVE-2021-40607": {"epss_score": 0.00272, "epss_percentile": 0.50398}, "CVE-2021-40608": {"epss_score": 0.00077, "epss_percentile": 0.23308}, "CVE-2021-40609": {"epss_score": 0.00077, "epss_percentile": 0.23308}, "CVE-2021-40610": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-40612": {"epss_score": 0.00995, "epss_percentile": 0.76432}, "CVE-2021-40616": {"epss_score": 0.00121, "epss_percentile": 0.31837}, "CVE-2021-40617": {"epss_score": 0.03077, "epss_percentile": 0.86361}, "CVE-2021-40618": {"epss_score": 0.00383, "epss_percentile": 0.59105}, "CVE-2021-40633": {"epss_score": 0.0081, "epss_percentile": 0.73722}, "CVE-2021-40635": {"epss_score": 0.00384, "epss_percentile": 0.59164}, "CVE-2021-40636": {"epss_score": 0.00384, "epss_percentile": 0.59164}, "CVE-2021-40637": {"epss_score": 0.00272, "epss_percentile": 0.50414}, "CVE-2021-40639": {"epss_score": 0.00291, "epss_percentile": 0.52187}, "CVE-2021-40642": {"epss_score": 0.00115, "epss_percentile": 0.309}, "CVE-2021-40643": {"epss_score": 0.03224, "epss_percentile": 0.86679}, "CVE-2021-40644": {"epss_score": 0.00241, "epss_percentile": 0.47252}, "CVE-2021-40645": {"epss_score": 0.00241, "epss_percentile": 0.47252}, "CVE-2021-40647": {"epss_score": 0.00034, "epss_percentile": 0.09699}, "CVE-2021-40648": {"epss_score": 0.00057, "epss_percentile": 0.18183}, "CVE-2021-40649": {"epss_score": 0.00196, "epss_percentile": 0.41771}, "CVE-2021-40650": {"epss_score": 0.00156, "epss_percentile": 0.36944}, "CVE-2021-40651": {"epss_score": 0.69873, "epss_percentile": 0.98607}, "CVE-2021-40654": {"epss_score": 0.00832, "epss_percentile": 0.74068}, "CVE-2021-40655": {"epss_score": 0.9287, "epss_percentile": 0.99757}, "CVE-2021-40656": {"epss_score": 0.00352, "epss_percentile": 0.57095}, "CVE-2021-40658": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2021-40660": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-40661": {"epss_score": 0.86991, "epss_percentile": 0.99406}, "CVE-2021-40662": {"epss_score": 0.00579, "epss_percentile": 0.68208}, "CVE-2021-40663": {"epss_score": 0.005, "epss_percentile": 0.6529}, "CVE-2021-40668": {"epss_score": 0.00393, "epss_percentile": 0.59729}, "CVE-2021-40669": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-40670": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-40674": {"epss_score": 0.00304, "epss_percentile": 0.53267}, "CVE-2021-40678": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-40680": {"epss_score": 0.00431, "epss_percentile": 0.62041}, "CVE-2021-40683": {"epss_score": 0.00069, "epss_percentile": 0.216}, "CVE-2021-40684": {"epss_score": 0.00616, "epss_percentile": 0.69329}, "CVE-2021-40690": {"epss_score": 0.00378, "epss_percentile": 0.58822}, "CVE-2021-40691": {"epss_score": 0.00402, "epss_percentile": 0.60311}, "CVE-2021-40692": {"epss_score": 0.00297, "epss_percentile": 0.52742}, "CVE-2021-40693": {"epss_score": 0.0045, "epss_percentile": 0.63079}, "CVE-2021-40694": {"epss_score": 0.0047, "epss_percentile": 0.63965}, "CVE-2021-40695": {"epss_score": 0.00374, "epss_percentile": 0.58549}, "CVE-2021-40697": {"epss_score": 0.01057, "epss_percentile": 0.77135}, "CVE-2021-40698": {"epss_score": 0.00122, "epss_percentile": 0.32075}, "CVE-2021-40699": {"epss_score": 0.00227, "epss_percentile": 0.45397}, "CVE-2021-40700": {"epss_score": 0.04112, "epss_percentile": 0.88274}, "CVE-2021-40701": {"epss_score": 0.03829, "epss_percentile": 0.878}, "CVE-2021-40702": {"epss_score": 0.03829, "epss_percentile": 0.878}, "CVE-2021-40703": {"epss_score": 0.03829, "epss_percentile": 0.878}, "CVE-2021-40708": {"epss_score": 0.06875, "epss_percentile": 0.91087}, "CVE-2021-40709": {"epss_score": 0.07147, "epss_percentile": 0.91282}, "CVE-2021-40710": {"epss_score": 0.03995, "epss_percentile": 0.88084}, "CVE-2021-40711": {"epss_score": 0.02148, "epss_percentile": 0.8377}, "CVE-2021-40712": {"epss_score": 0.00392, "epss_percentile": 0.59654}, "CVE-2021-40713": {"epss_score": 0.00242, "epss_percentile": 0.47375}, "CVE-2021-40714": {"epss_score": 0.00882, "epss_percentile": 0.74893}, "CVE-2021-40715": {"epss_score": 0.01627, "epss_percentile": 0.81431}, "CVE-2021-40716": {"epss_score": 0.00211, "epss_percentile": 0.43623}, "CVE-2021-40719": {"epss_score": 0.24933, "epss_percentile": 0.95969}, "CVE-2021-40720": {"epss_score": 0.15132, "epss_percentile": 0.9437}, "CVE-2021-40721": {"epss_score": 0.01084, "epss_percentile": 0.77398}, "CVE-2021-40722": {"epss_score": 0.01033, "epss_percentile": 0.76872}, "CVE-2021-40723": {"epss_score": 0.00014, "epss_percentile": 0.02105}, "CVE-2021-40724": {"epss_score": 0.03426, "epss_percentile": 0.87114}, "CVE-2021-40725": {"epss_score": 0.20846, "epss_percentile": 0.95427}, "CVE-2021-40726": {"epss_score": 0.20846, "epss_percentile": 0.95427}, "CVE-2021-40727": {"epss_score": 0.00529, "epss_percentile": 0.66579}, "CVE-2021-40728": {"epss_score": 0.12116, "epss_percentile": 0.93569}, "CVE-2021-40729": {"epss_score": 0.00546, "epss_percentile": 0.67222}, "CVE-2021-40730": {"epss_score": 0.01226, "epss_percentile": 0.78693}, "CVE-2021-40731": {"epss_score": 0.05762, "epss_percentile": 0.90184}, "CVE-2021-40732": {"epss_score": 0.00125, "epss_percentile": 0.32495}, "CVE-2021-40733": {"epss_score": 0.03995, "epss_percentile": 0.88084}, "CVE-2021-40734": {"epss_score": 0.02123, "epss_percentile": 0.83683}, "CVE-2021-40735": {"epss_score": 0.03829, "epss_percentile": 0.878}, "CVE-2021-40736": {"epss_score": 0.03829, "epss_percentile": 0.878}, "CVE-2021-40737": {"epss_score": 0.0041, "epss_percentile": 0.6081}, "CVE-2021-40738": {"epss_score": 0.00889, "epss_percentile": 0.75017}, "CVE-2021-40739": {"epss_score": 0.00889, "epss_percentile": 0.75017}, "CVE-2021-40740": {"epss_score": 0.00889, "epss_percentile": 0.75017}, "CVE-2021-40741": {"epss_score": 0.0041, "epss_percentile": 0.6081}, "CVE-2021-40742": {"epss_score": 0.0041, "epss_percentile": 0.6081}, "CVE-2021-40745": {"epss_score": 0.01819, "epss_percentile": 0.82406}, "CVE-2021-40750": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-40751": {"epss_score": 0.01801, "epss_percentile": 0.82328}, "CVE-2021-40752": {"epss_score": 0.01801, "epss_percentile": 0.82328}, "CVE-2021-40753": {"epss_score": 0.01801, "epss_percentile": 0.82328}, "CVE-2021-40754": {"epss_score": 0.01801, "epss_percentile": 0.82328}, "CVE-2021-40755": {"epss_score": 0.0092, "epss_percentile": 0.75473}, "CVE-2021-40756": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-40757": {"epss_score": 0.0092, "epss_percentile": 0.75473}, "CVE-2021-40758": {"epss_score": 0.00881, "epss_percentile": 0.74868}, "CVE-2021-40759": {"epss_score": 0.00881, "epss_percentile": 0.74868}, "CVE-2021-40760": {"epss_score": 0.00881, "epss_percentile": 0.74868}, "CVE-2021-40761": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-40762": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-40763": {"epss_score": 0.00881, "epss_percentile": 0.74868}, "CVE-2021-40764": {"epss_score": 0.00881, "epss_percentile": 0.74868}, "CVE-2021-40765": {"epss_score": 0.00881, "epss_percentile": 0.74868}, "CVE-2021-40766": {"epss_score": 0.02292, "epss_percentile": 0.84285}, "CVE-2021-40767": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-40768": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-40769": {"epss_score": 0.02292, "epss_percentile": 0.84285}, "CVE-2021-40770": {"epss_score": 0.06563, "epss_percentile": 0.9085}, "CVE-2021-40771": {"epss_score": 0.04942, "epss_percentile": 0.8931}, "CVE-2021-40772": {"epss_score": 0.04942, "epss_percentile": 0.8931}, "CVE-2021-40773": {"epss_score": 0.0041, "epss_percentile": 0.6081}, "CVE-2021-40774": {"epss_score": 0.0041, "epss_percentile": 0.6081}, "CVE-2021-40775": {"epss_score": 0.04942, "epss_percentile": 0.8931}, "CVE-2021-40776": {"epss_score": 0.00255, "epss_percentile": 0.48713}, "CVE-2021-40777": {"epss_score": 0.03829, "epss_percentile": 0.878}, "CVE-2021-40778": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-40779": {"epss_score": 0.00881, "epss_percentile": 0.74868}, "CVE-2021-40780": {"epss_score": 0.00881, "epss_percentile": 0.74868}, "CVE-2021-40781": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-40782": {"epss_score": 0.0041, "epss_percentile": 0.6081}, "CVE-2021-40783": {"epss_score": 0.06563, "epss_percentile": 0.9085}, "CVE-2021-40784": {"epss_score": 0.06563, "epss_percentile": 0.9085}, "CVE-2021-40785": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-40786": {"epss_score": 0.00881, "epss_percentile": 0.74868}, "CVE-2021-40787": {"epss_score": 0.00881, "epss_percentile": 0.74868}, "CVE-2021-40788": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-40789": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-40790": {"epss_score": 0.00028, "epss_percentile": 0.0731}, "CVE-2021-40791": {"epss_score": 0.00029, "epss_percentile": 0.07938}, "CVE-2021-40792": {"epss_score": 0.02122, "epss_percentile": 0.83682}, "CVE-2021-40793": {"epss_score": 0.02855, "epss_percentile": 0.85837}, "CVE-2021-40794": {"epss_score": 0.02855, "epss_percentile": 0.85837}, "CVE-2021-40795": {"epss_score": 0.00157, "epss_percentile": 0.37091}, "CVE-2021-40796": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-40797": {"epss_score": 0.00384, "epss_percentile": 0.59162}, "CVE-2021-40809": {"epss_score": 0.00576, "epss_percentile": 0.68147}, "CVE-2021-40812": {"epss_score": 0.0016, "epss_percentile": 0.37467}, "CVE-2021-40813": {"epss_score": 0.00125, "epss_percentile": 0.3259}, "CVE-2021-40814": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-40818": {"epss_score": 0.00455, "epss_percentile": 0.63312}, "CVE-2021-40822": {"epss_score": 0.93253, "epss_percentile": 0.99789}, "CVE-2021-40823": {"epss_score": 0.00261, "epss_percentile": 0.49312}, "CVE-2021-40824": {"epss_score": 0.00239, "epss_percentile": 0.46902}, "CVE-2021-40825": {"epss_score": 0.0026, "epss_percentile": 0.49244}, "CVE-2021-40826": {"epss_score": 0.00626, "epss_percentile": 0.69602}, "CVE-2021-40827": {"epss_score": 0.00626, "epss_percentile": 0.69602}, "CVE-2021-40828": {"epss_score": 0.00102, "epss_percentile": 0.2875}, "CVE-2021-40829": {"epss_score": 0.00102, "epss_percentile": 0.2875}, "CVE-2021-40830": {"epss_score": 0.00103, "epss_percentile": 0.28931}, "CVE-2021-40831": {"epss_score": 0.00278, "epss_percentile": 0.50853}, "CVE-2021-40832": {"epss_score": 0.00302, "epss_percentile": 0.53167}, "CVE-2021-40833": {"epss_score": 0.00129, "epss_percentile": 0.3316}, "CVE-2021-40834": {"epss_score": 0.00205, "epss_percentile": 0.42712}, "CVE-2021-40835": {"epss_score": 0.00295, "epss_percentile": 0.52494}, "CVE-2021-40836": {"epss_score": 0.00148, "epss_percentile": 0.35916}, "CVE-2021-40837": {"epss_score": 0.00253, "epss_percentile": 0.4844}, "CVE-2021-40839": {"epss_score": 0.13839, "epss_percentile": 0.94073}, "CVE-2021-40840": {"epss_score": 0.00502, "epss_percentile": 0.65419}, "CVE-2021-40841": {"epss_score": 0.00381, "epss_percentile": 0.59016}, "CVE-2021-40842": {"epss_score": 0.00385, "epss_percentile": 0.59205}, "CVE-2021-40843": {"epss_score": 0.00031, "epss_percentile": 0.08517}, "CVE-2021-40845": {"epss_score": 0.26958, "epss_percentile": 0.96195}, "CVE-2021-40846": {"epss_score": 0.00184, "epss_percentile": 0.40368}, "CVE-2021-40847": {"epss_score": 0.06129, "epss_percentile": 0.90499}, "CVE-2021-40848": {"epss_score": 0.00449, "epss_percentile": 0.63046}, "CVE-2021-40849": {"epss_score": 0.00428, "epss_percentile": 0.61936}, "CVE-2021-40850": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-40851": {"epss_score": 0.00325, "epss_percentile": 0.5498}, "CVE-2021-40852": {"epss_score": 0.00199, "epss_percentile": 0.42185}, "CVE-2021-40853": {"epss_score": 0.00203, "epss_percentile": 0.42494}, "CVE-2021-40854": {"epss_score": 0.00118, "epss_percentile": 0.31421}, "CVE-2021-40855": {"epss_score": 0.00265, "epss_percentile": 0.49764}, "CVE-2021-40856": {"epss_score": 0.8812, "epss_percentile": 0.99458}, "CVE-2021-40857": {"epss_score": 0.01393, "epss_percentile": 0.79967}, "CVE-2021-40858": {"epss_score": 0.01708, "epss_percentile": 0.81866}, "CVE-2021-40859": {"epss_score": 0.81279, "epss_percentile": 0.9913}, "CVE-2021-40860": {"epss_score": 0.02164, "epss_percentile": 0.83838}, "CVE-2021-40861": {"epss_score": 0.02164, "epss_percentile": 0.83838}, "CVE-2021-40862": {"epss_score": 0.00512, "epss_percentile": 0.65864}, "CVE-2021-40864": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-40865": {"epss_score": 0.4622, "epss_percentile": 0.97537}, "CVE-2021-40866": {"epss_score": 0.01428, "epss_percentile": 0.8022}, "CVE-2021-40867": {"epss_score": 0.00119, "epss_percentile": 0.3164}, "CVE-2021-40868": {"epss_score": 0.24386, "epss_percentile": 0.95916}, "CVE-2021-40870": {"epss_score": 0.94228, "epss_percentile": 0.99921}, "CVE-2021-40871": {"epss_score": 0.00628, "epss_percentile": 0.69647}, "CVE-2021-40872": {"epss_score": 0.00665, "epss_percentile": 0.70662}, "CVE-2021-40873": {"epss_score": 0.00628, "epss_percentile": 0.69647}, "CVE-2021-40874": {"epss_score": 0.00293, "epss_percentile": 0.52318}, "CVE-2021-40875": {"epss_score": 0.81108, "epss_percentile": 0.9912}, "CVE-2021-40881": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2021-40882": {"epss_score": 0.00321, "epss_percentile": 0.54644}, "CVE-2021-40883": {"epss_score": 0.09084, "epss_percentile": 0.92394}, "CVE-2021-40884": {"epss_score": 0.00258, "epss_percentile": 0.4899}, "CVE-2021-40886": {"epss_score": 0.00449, "epss_percentile": 0.63049}, "CVE-2021-40887": {"epss_score": 0.00845, "epss_percentile": 0.74287}, "CVE-2021-40888": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2021-40889": {"epss_score": 0.00396, "epss_percentile": 0.59887}, "CVE-2021-40892": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-40893": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-40894": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-40895": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-40896": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-40897": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-40898": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-40899": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-40900": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-40901": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-40902": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-40903": {"epss_score": 0.11622, "epss_percentile": 0.93422}, "CVE-2021-40904": {"epss_score": 0.19129, "epss_percentile": 0.95136}, "CVE-2021-40905": {"epss_score": 0.04878, "epss_percentile": 0.89242}, "CVE-2021-40906": {"epss_score": 0.00845, "epss_percentile": 0.74291}, "CVE-2021-40907": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-40908": {"epss_score": 0.11163, "epss_percentile": 0.9325}, "CVE-2021-40909": {"epss_score": 0.01397, "epss_percentile": 0.79983}, "CVE-2021-40910": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-40921": {"epss_score": 0.00206, "epss_percentile": 0.43065}, "CVE-2021-40922": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2021-40923": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2021-40924": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2021-40925": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2021-40926": {"epss_score": 0.00284, "epss_percentile": 0.51419}, "CVE-2021-40927": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2021-40928": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2021-40940": {"epss_score": 0.00979, "epss_percentile": 0.76259}, "CVE-2021-40941": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-40942": {"epss_score": 0.00279, "epss_percentile": 0.50926}, "CVE-2021-40943": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-40944": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-40954": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2021-40955": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2021-40956": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2021-40959": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2021-40960": {"epss_score": 0.81807, "epss_percentile": 0.99158}, "CVE-2021-40961": {"epss_score": 0.01318, "epss_percentile": 0.79424}, "CVE-2021-40964": {"epss_score": 0.08281, "epss_percentile": 0.91967}, "CVE-2021-40965": {"epss_score": 0.00134, "epss_percentile": 0.33768}, "CVE-2021-40966": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-40968": {"epss_score": 0.01286, "epss_percentile": 0.79189}, "CVE-2021-40969": {"epss_score": 0.01286, "epss_percentile": 0.79189}, "CVE-2021-40970": {"epss_score": 0.01286, "epss_percentile": 0.79189}, "CVE-2021-40971": {"epss_score": 0.01286, "epss_percentile": 0.79189}, "CVE-2021-40972": {"epss_score": 0.01286, "epss_percentile": 0.79189}, "CVE-2021-40973": {"epss_score": 0.01286, "epss_percentile": 0.79189}, "CVE-2021-40975": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2021-40978": {"epss_score": 0.84812, "epss_percentile": 0.99305}, "CVE-2021-40981": {"epss_score": 0.0005, "epss_percentile": 0.15965}, "CVE-2021-40985": {"epss_score": 0.00099, "epss_percentile": 0.28391}, "CVE-2021-40986": {"epss_score": 0.02519, "epss_percentile": 0.84997}, "CVE-2021-40987": {"epss_score": 0.02519, "epss_percentile": 0.84997}, "CVE-2021-40988": {"epss_score": 0.05476, "epss_percentile": 0.89914}, "CVE-2021-40989": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2021-40990": {"epss_score": 0.00256, "epss_percentile": 0.48783}, "CVE-2021-40991": {"epss_score": 0.00784, "epss_percentile": 0.73231}, "CVE-2021-40992": {"epss_score": 0.00624, "epss_percentile": 0.69565}, "CVE-2021-40993": {"epss_score": 0.00242, "epss_percentile": 0.47383}, "CVE-2021-40994": {"epss_score": 0.01518, "epss_percentile": 0.80815}, "CVE-2021-40995": {"epss_score": 0.01518, "epss_percentile": 0.80815}, "CVE-2021-40996": {"epss_score": 0.00709, "epss_percentile": 0.71689}, "CVE-2021-40997": {"epss_score": 0.00709, "epss_percentile": 0.71689}, "CVE-2021-40998": {"epss_score": 0.02519, "epss_percentile": 0.84997}, "CVE-2021-40999": {"epss_score": 0.01279, "epss_percentile": 0.79133}, "CVE-2021-41000": {"epss_score": 0.05606, "epss_percentile": 0.90044}, "CVE-2021-41001": {"epss_score": 0.05606, "epss_percentile": 0.90044}, "CVE-2021-41002": {"epss_score": 0.00479, "epss_percentile": 0.64419}, "CVE-2021-41003": {"epss_score": 0.00554, "epss_percentile": 0.67442}, "CVE-2021-41004": {"epss_score": 0.00387, "epss_percentile": 0.59334}, "CVE-2021-41005": {"epss_score": 0.00371, "epss_percentile": 0.58365}, "CVE-2021-41011": {"epss_score": 0.0039, "epss_percentile": 0.59546}, "CVE-2021-41013": {"epss_score": 0.00489, "epss_percentile": 0.64911}, "CVE-2021-41014": {"epss_score": 0.00747, "epss_percentile": 0.72573}, "CVE-2021-41015": {"epss_score": 0.00545, "epss_percentile": 0.67153}, "CVE-2021-41016": {"epss_score": 0.00807, "epss_percentile": 0.73676}, "CVE-2021-41017": {"epss_score": 0.00883, "epss_percentile": 0.74918}, "CVE-2021-41018": {"epss_score": 0.00638, "epss_percentile": 0.69923}, "CVE-2021-41019": {"epss_score": 0.0024, "epss_percentile": 0.47209}, "CVE-2021-41020": {"epss_score": 0.00296, "epss_percentile": 0.52535}, "CVE-2021-41021": {"epss_score": 0.00037, "epss_percentile": 0.10633}, "CVE-2021-41022": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2021-41023": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2021-41024": {"epss_score": 0.00996, "epss_percentile": 0.76443}, "CVE-2021-41025": {"epss_score": 0.00326, "epss_percentile": 0.55075}, "CVE-2021-41026": {"epss_score": 0.00503, "epss_percentile": 0.65439}, "CVE-2021-41027": {"epss_score": 0.00182, "epss_percentile": 0.40182}, "CVE-2021-41028": {"epss_score": 0.00136, "epss_percentile": 0.3414}, "CVE-2021-41029": {"epss_score": 0.00406, "epss_percentile": 0.60537}, "CVE-2021-41030": {"epss_score": 0.00237, "epss_percentile": 0.46643}, "CVE-2021-41031": {"epss_score": 0.00177, "epss_percentile": 0.39543}, "CVE-2021-41032": {"epss_score": 0.00208, "epss_percentile": 0.4322}, "CVE-2021-41033": {"epss_score": 0.00416, "epss_percentile": 0.61214}, "CVE-2021-41034": {"epss_score": 0.00204, "epss_percentile": 0.42657}, "CVE-2021-41035": {"epss_score": 0.00147, "epss_percentile": 0.35786}, "CVE-2021-41036": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2021-41037": {"epss_score": 0.00508, "epss_percentile": 0.65709}, "CVE-2021-41038": {"epss_score": 0.0026, "epss_percentile": 0.49197}, "CVE-2021-41039": {"epss_score": 0.00251, "epss_percentile": 0.48268}, "CVE-2021-41040": {"epss_score": 0.0119, "epss_percentile": 0.78375}, "CVE-2021-41041": {"epss_score": 0.00089, "epss_percentile": 0.25969}, "CVE-2021-41042": {"epss_score": 0.00309, "epss_percentile": 0.53656}, "CVE-2021-41043": {"epss_score": 0.00243, "epss_percentile": 0.47467}, "CVE-2021-41054": {"epss_score": 0.0058, "epss_percentile": 0.6826}, "CVE-2021-41055": {"epss_score": 0.00808, "epss_percentile": 0.73697}, "CVE-2021-41057": {"epss_score": 0.00078, "epss_percentile": 0.23634}, "CVE-2021-41061": {"epss_score": 0.00033, "epss_percentile": 0.09147}, "CVE-2021-41063": {"epss_score": 0.01529, "epss_percentile": 0.80882}, "CVE-2021-41065": {"epss_score": 0.0004, "epss_percentile": 0.12101}, "CVE-2021-41066": {"epss_score": 0.00242, "epss_percentile": 0.47358}, "CVE-2021-41067": {"epss_score": 0.00144, "epss_percentile": 0.35228}, "CVE-2021-41072": {"epss_score": 0.03585, "epss_percentile": 0.87391}, "CVE-2021-41073": {"epss_score": 0.00771, "epss_percentile": 0.73019}, "CVE-2021-41075": {"epss_score": 0.26431, "epss_percentile": 0.96146}, "CVE-2021-41077": {"epss_score": 0.00426, "epss_percentile": 0.61759}, "CVE-2021-41078": {"epss_score": 0.01473, "epss_percentile": 0.80514}, "CVE-2021-41079": {"epss_score": 0.00051, "epss_percentile": 0.16035}, "CVE-2021-41080": {"epss_score": 0.15456, "epss_percentile": 0.94432}, "CVE-2021-41081": {"epss_score": 0.2736, "epss_percentile": 0.9624}, "CVE-2021-41082": {"epss_score": 0.00702, "epss_percentile": 0.7152}, "CVE-2021-41083": {"epss_score": 0.00172, "epss_percentile": 0.39003}, "CVE-2021-41084": {"epss_score": 0.00451, "epss_percentile": 0.63152}, "CVE-2021-41086": {"epss_score": 0.00638, "epss_percentile": 0.69918}, "CVE-2021-41087": {"epss_score": 0.00168, "epss_percentile": 0.38522}, "CVE-2021-41088": {"epss_score": 0.00245, "epss_percentile": 0.47705}, "CVE-2021-41089": {"epss_score": 0.00033, "epss_percentile": 0.09326}, "CVE-2021-41090": {"epss_score": 0.00718, "epss_percentile": 0.71936}, "CVE-2021-41091": {"epss_score": 0.04746, "epss_percentile": 0.89097}, "CVE-2021-41092": {"epss_score": 0.00125, "epss_percentile": 0.32576}, "CVE-2021-41093": {"epss_score": 0.00363, "epss_percentile": 0.57903}, "CVE-2021-41094": {"epss_score": 0.00037, "epss_percentile": 0.10902}, "CVE-2021-41095": {"epss_score": 0.00224, "epss_percentile": 0.44997}, "CVE-2021-41096": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2021-41097": {"epss_score": 0.00337, "epss_percentile": 0.56032}, "CVE-2021-41098": {"epss_score": 0.0054, "epss_percentile": 0.67019}, "CVE-2021-41099": {"epss_score": 0.00371, "epss_percentile": 0.58357}, "CVE-2021-41100": {"epss_score": 0.003, "epss_percentile": 0.5296}, "CVE-2021-41101": {"epss_score": 0.00306, "epss_percentile": 0.53448}, "CVE-2021-41103": {"epss_score": 0.00066, "epss_percentile": 0.20909}, "CVE-2021-41104": {"epss_score": 0.00284, "epss_percentile": 0.5146}, "CVE-2021-41105": {"epss_score": 0.0442, "epss_percentile": 0.88668}, "CVE-2021-41106": {"epss_score": 0.00034, "epss_percentile": 0.09801}, "CVE-2021-41109": {"epss_score": 0.00362, "epss_percentile": 0.57818}, "CVE-2021-41110": {"epss_score": 0.00609, "epss_percentile": 0.69088}, "CVE-2021-41111": {"epss_score": 0.00143, "epss_percentile": 0.35208}, "CVE-2021-41112": {"epss_score": 0.00213, "epss_percentile": 0.43917}, "CVE-2021-41113": {"epss_score": 0.00244, "epss_percentile": 0.47574}, "CVE-2021-41114": {"epss_score": 0.00289, "epss_percentile": 0.52015}, "CVE-2021-41115": {"epss_score": 0.01039, "epss_percentile": 0.76943}, "CVE-2021-41116": {"epss_score": 0.0072, "epss_percentile": 0.71956}, "CVE-2021-41117": {"epss_score": 0.00435, "epss_percentile": 0.6238}, "CVE-2021-41118": {"epss_score": 0.00366, "epss_percentile": 0.58084}, "CVE-2021-41119": {"epss_score": 0.00486, "epss_percentile": 0.64752}, "CVE-2021-41120": {"epss_score": 0.00366, "epss_percentile": 0.58061}, "CVE-2021-41121": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2021-41122": {"epss_score": 0.00203, "epss_percentile": 0.42564}, "CVE-2021-41123": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2021-41124": {"epss_score": 0.00284, "epss_percentile": 0.51435}, "CVE-2021-41125": {"epss_score": 0.00251, "epss_percentile": 0.48331}, "CVE-2021-41126": {"epss_score": 0.00485, "epss_percentile": 0.64728}, "CVE-2021-41127": {"epss_score": 0.00396, "epss_percentile": 0.59856}, "CVE-2021-41128": {"epss_score": 0.00782, "epss_percentile": 0.73207}, "CVE-2021-41129": {"epss_score": 0.00193, "epss_percentile": 0.41465}, "CVE-2021-41130": {"epss_score": 0.00112, "epss_percentile": 0.30446}, "CVE-2021-41131": {"epss_score": 0.00644, "epss_percentile": 0.7007}, "CVE-2021-41132": {"epss_score": 0.00558, "epss_percentile": 0.67574}, "CVE-2021-41133": {"epss_score": 0.00056, "epss_percentile": 0.17752}, "CVE-2021-41134": {"epss_score": 0.00337, "epss_percentile": 0.56062}, "CVE-2021-41135": {"epss_score": 0.00537, "epss_percentile": 0.66886}, "CVE-2021-41136": {"epss_score": 0.00288, "epss_percentile": 0.51866}, "CVE-2021-41137": {"epss_score": 0.00126, "epss_percentile": 0.32664}, "CVE-2021-41138": {"epss_score": 0.00575, "epss_percentile": 0.68115}, "CVE-2021-41139": {"epss_score": 0.00516, "epss_percentile": 0.66057}, "CVE-2021-41140": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2021-41141": {"epss_score": 0.01625, "epss_percentile": 0.81421}, "CVE-2021-41142": {"epss_score": 0.00444, "epss_percentile": 0.62838}, "CVE-2021-41143": {"epss_score": 0.00442, "epss_percentile": 0.62735}, "CVE-2021-41144": {"epss_score": 0.00044, "epss_percentile": 0.13528}, "CVE-2021-41145": {"epss_score": 0.00954, "epss_percentile": 0.75896}, "CVE-2021-41146": {"epss_score": 0.01365, "epss_percentile": 0.79776}, "CVE-2021-41147": {"epss_score": 0.01085, "epss_percentile": 0.77403}, "CVE-2021-41148": {"epss_score": 0.00855, "epss_percentile": 0.74458}, "CVE-2021-41149": {"epss_score": 0.00851, "epss_percentile": 0.74402}, "CVE-2021-41150": {"epss_score": 0.00524, "epss_percentile": 0.66362}, "CVE-2021-41151": {"epss_score": 0.00454, "epss_percentile": 0.63253}, "CVE-2021-41152": {"epss_score": 0.0054, "epss_percentile": 0.67012}, "CVE-2021-41153": {"epss_score": 0.00334, "epss_percentile": 0.55695}, "CVE-2021-41154": {"epss_score": 0.00855, "epss_percentile": 0.74458}, "CVE-2021-41155": {"epss_score": 0.00855, "epss_percentile": 0.74458}, "CVE-2021-41156": {"epss_score": 0.00312, "epss_percentile": 0.53968}, "CVE-2021-41157": {"epss_score": 0.00345, "epss_percentile": 0.56576}, "CVE-2021-41158": {"epss_score": 0.00362, "epss_percentile": 0.57772}, "CVE-2021-41159": {"epss_score": 0.00066, "epss_percentile": 0.20887}, "CVE-2021-41160": {"epss_score": 0.00132, "epss_percentile": 0.33599}, "CVE-2021-41161": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2021-41162": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2021-41163": {"epss_score": 0.03651, "epss_percentile": 0.87508}, "CVE-2021-41164": {"epss_score": 0.00076, "epss_percentile": 0.23249}, "CVE-2021-41165": {"epss_score": 0.00117, "epss_percentile": 0.31243}, "CVE-2021-41166": {"epss_score": 0.0023, "epss_percentile": 0.45742}, "CVE-2021-41167": {"epss_score": 0.00367, "epss_percentile": 0.58125}, "CVE-2021-41168": {"epss_score": 0.00193, "epss_percentile": 0.41418}, "CVE-2021-41169": {"epss_score": 0.00286, "epss_percentile": 0.51752}, "CVE-2021-41170": {"epss_score": 0.00524, "epss_percentile": 0.66325}, "CVE-2021-41171": {"epss_score": 0.00227, "epss_percentile": 0.45404}, "CVE-2021-41172": {"epss_score": 0.0033, "epss_percentile": 0.55458}, "CVE-2021-41173": {"epss_score": 0.00175, "epss_percentile": 0.3928}, "CVE-2021-41174": {"epss_score": 0.79005, "epss_percentile": 0.99015}, "CVE-2021-41175": {"epss_score": 0.00425, "epss_percentile": 0.6169}, "CVE-2021-41176": {"epss_score": 0.00168, "epss_percentile": 0.38454}, "CVE-2021-41177": {"epss_score": 0.00618, "epss_percentile": 0.69374}, "CVE-2021-41178": {"epss_score": 0.00867, "epss_percentile": 0.7465}, "CVE-2021-41179": {"epss_score": 0.0038, "epss_percentile": 0.58939}, "CVE-2021-41180": {"epss_score": 0.00187, "epss_percentile": 0.40757}, "CVE-2021-41181": {"epss_score": 0.00072, "epss_percentile": 0.2237}, "CVE-2021-41182": {"epss_score": 0.1926, "epss_percentile": 0.95157}, "CVE-2021-41183": {"epss_score": 0.0286, "epss_percentile": 0.8585}, "CVE-2021-41184": {"epss_score": 0.22087, "epss_percentile": 0.95593}, "CVE-2021-41185": {"epss_score": 0.00464, "epss_percentile": 0.63739}, "CVE-2021-41186": {"epss_score": 0.00486, "epss_percentile": 0.64741}, "CVE-2021-41187": {"epss_score": 0.00234, "epss_percentile": 0.46164}, "CVE-2021-41188": {"epss_score": 0.00512, "epss_percentile": 0.65869}, "CVE-2021-41189": {"epss_score": 0.00627, "epss_percentile": 0.69634}, "CVE-2021-41190": {"epss_score": 0.00303, "epss_percentile": 0.53196}, "CVE-2021-41191": {"epss_score": 0.00453, "epss_percentile": 0.63208}, "CVE-2021-41192": {"epss_score": 0.87556, "epss_percentile": 0.99433}, "CVE-2021-41193": {"epss_score": 0.01144, "epss_percentile": 0.77988}, "CVE-2021-41194": {"epss_score": 0.00352, "epss_percentile": 0.57125}, "CVE-2021-41195": {"epss_score": 0.00038, "epss_percentile": 0.11314}, "CVE-2021-41196": {"epss_score": 0.00049, "epss_percentile": 0.15372}, "CVE-2021-41197": {"epss_score": 0.00022, "epss_percentile": 0.05278}, "CVE-2021-41198": {"epss_score": 0.00049, "epss_percentile": 0.15564}, "CVE-2021-41199": {"epss_score": 0.00049, "epss_percentile": 0.15564}, "CVE-2021-41200": {"epss_score": 0.00049, "epss_percentile": 0.15372}, "CVE-2021-41201": {"epss_score": 0.00022, "epss_percentile": 0.05218}, "CVE-2021-41202": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2021-41203": {"epss_score": 0.00019, "epss_percentile": 0.04088}, "CVE-2021-41204": {"epss_score": 0.00017, "epss_percentile": 0.0348}, "CVE-2021-41205": {"epss_score": 0.00019, "epss_percentile": 0.04057}, "CVE-2021-41206": {"epss_score": 0.0001, "epss_percentile": 0.00826}, "CVE-2021-41207": {"epss_score": 0.00017, "epss_percentile": 0.0348}, "CVE-2021-41208": {"epss_score": 0.00012, "epss_percentile": 0.01303}, "CVE-2021-41209": {"epss_score": 0.00017, "epss_percentile": 0.0348}, "CVE-2021-41210": {"epss_score": 0.00019, "epss_percentile": 0.04057}, "CVE-2021-41211": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2021-41212": {"epss_score": 0.00019, "epss_percentile": 0.04057}, "CVE-2021-41213": {"epss_score": 0.00043, "epss_percentile": 0.13211}, "CVE-2021-41214": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2021-41215": {"epss_score": 0.00017, "epss_percentile": 0.0348}, "CVE-2021-41216": {"epss_score": 0.0002, "epss_percentile": 0.04446}, "CVE-2021-41217": {"epss_score": 0.00017, "epss_percentile": 0.0348}, "CVE-2021-41218": {"epss_score": 0.00017, "epss_percentile": 0.0348}, "CVE-2021-41219": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2021-41220": {"epss_score": 0.00021, "epss_percentile": 0.04947}, "CVE-2021-41221": {"epss_score": 0.0002, "epss_percentile": 0.04656}, "CVE-2021-41222": {"epss_score": 0.00017, "epss_percentile": 0.0348}, "CVE-2021-41223": {"epss_score": 0.00019, "epss_percentile": 0.04057}, "CVE-2021-41224": {"epss_score": 0.00019, "epss_percentile": 0.04057}, "CVE-2021-41225": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2021-41226": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2021-41227": {"epss_score": 0.00082, "epss_percentile": 0.24497}, "CVE-2021-41228": {"epss_score": 0.0004, "epss_percentile": 0.11967}, "CVE-2021-41229": {"epss_score": 0.00028, "epss_percentile": 0.0749}, "CVE-2021-41230": {"epss_score": 0.00238, "epss_percentile": 0.46751}, "CVE-2021-41231": {"epss_score": 0.00293, "epss_percentile": 0.52354}, "CVE-2021-41232": {"epss_score": 0.00492, "epss_percentile": 0.65003}, "CVE-2021-41233": {"epss_score": 0.00272, "epss_percentile": 0.50367}, "CVE-2021-41236": {"epss_score": 0.005, "epss_percentile": 0.65294}, "CVE-2021-41238": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2021-41239": {"epss_score": 0.0037, "epss_percentile": 0.58308}, "CVE-2021-41241": {"epss_score": 0.00233, "epss_percentile": 0.45972}, "CVE-2021-41242": {"epss_score": 0.00788, "epss_percentile": 0.73346}, "CVE-2021-41243": {"epss_score": 0.02799, "epss_percentile": 0.85692}, "CVE-2021-41244": {"epss_score": 0.00486, "epss_percentile": 0.64746}, "CVE-2021-41245": {"epss_score": 0.00132, "epss_percentile": 0.33517}, "CVE-2021-41246": {"epss_score": 0.00381, "epss_percentile": 0.5898}, "CVE-2021-41247": {"epss_score": 0.00212, "epss_percentile": 0.43822}, "CVE-2021-41248": {"epss_score": 0.00398, "epss_percentile": 0.6007}, "CVE-2021-41249": {"epss_score": 0.00313, "epss_percentile": 0.54018}, "CVE-2021-41250": {"epss_score": 0.00144, "epss_percentile": 0.35235}, "CVE-2021-41251": {"epss_score": 0.00331, "epss_percentile": 0.55501}, "CVE-2021-41252": {"epss_score": 0.00445, "epss_percentile": 0.62875}, "CVE-2021-41253": {"epss_score": 0.00717, "epss_percentile": 0.71879}, "CVE-2021-41254": {"epss_score": 0.00976, "epss_percentile": 0.76213}, "CVE-2021-41256": {"epss_score": 0.00251, "epss_percentile": 0.4829}, "CVE-2021-41258": {"epss_score": 0.00519, "epss_percentile": 0.66145}, "CVE-2021-41260": {"epss_score": 0.00158, "epss_percentile": 0.37186}, "CVE-2021-41261": {"epss_score": 0.00353, "epss_percentile": 0.57152}, "CVE-2021-41262": {"epss_score": 0.00299, "epss_percentile": 0.5289}, "CVE-2021-41263": {"epss_score": 0.00198, "epss_percentile": 0.42004}, "CVE-2021-41264": {"epss_score": 0.00641, "epss_percentile": 0.69996}, "CVE-2021-41265": {"epss_score": 0.00328, "epss_percentile": 0.5527}, "CVE-2021-41266": {"epss_score": 0.79997, "epss_percentile": 0.99066}, "CVE-2021-41267": {"epss_score": 0.00462, "epss_percentile": 0.63571}, "CVE-2021-41268": {"epss_score": 0.00476, "epss_percentile": 0.64262}, "CVE-2021-41269": {"epss_score": 0.03799, "epss_percentile": 0.87741}, "CVE-2021-41270": {"epss_score": 0.00871, "epss_percentile": 0.74718}, "CVE-2021-41271": {"epss_score": 0.00289, "epss_percentile": 0.5204}, "CVE-2021-41272": {"epss_score": 0.00367, "epss_percentile": 0.58125}, "CVE-2021-41273": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2021-41274": {"epss_score": 0.00106, "epss_percentile": 0.29404}, "CVE-2021-41275": {"epss_score": 0.00075, "epss_percentile": 0.22942}, "CVE-2021-41276": {"epss_score": 0.00735, "epss_percentile": 0.72297}, "CVE-2021-41277": {"epss_score": 0.94408, "epss_percentile": 0.99974}, "CVE-2021-41278": {"epss_score": 0.00078, "epss_percentile": 0.23751}, "CVE-2021-41279": {"epss_score": 0.00438, "epss_percentile": 0.62573}, "CVE-2021-41280": {"epss_score": 0.07631, "epss_percentile": 0.91583}, "CVE-2021-41281": {"epss_score": 0.00549, "epss_percentile": 0.67296}, "CVE-2021-41282": {"epss_score": 0.9188, "epss_percentile": 0.99675}, "CVE-2021-41285": {"epss_score": 0.00135, "epss_percentile": 0.34042}, "CVE-2021-41286": {"epss_score": 0.00048, "epss_percentile": 0.15081}, "CVE-2021-41288": {"epss_score": 0.3247, "epss_percentile": 0.96703}, "CVE-2021-41289": {"epss_score": 0.0004, "epss_percentile": 0.11953}, "CVE-2021-41290": {"epss_score": 0.01816, "epss_percentile": 0.82391}, "CVE-2021-41291": {"epss_score": 0.9166, "epss_percentile": 0.99661}, "CVE-2021-41292": {"epss_score": 0.00307, "epss_percentile": 0.53531}, "CVE-2021-41293": {"epss_score": 0.89647, "epss_percentile": 0.99536}, "CVE-2021-41294": {"epss_score": 0.03889, "epss_percentile": 0.87908}, "CVE-2021-41295": {"epss_score": 0.00116, "epss_percentile": 0.31142}, "CVE-2021-41296": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2021-41297": {"epss_score": 0.00168, "epss_percentile": 0.38406}, "CVE-2021-41298": {"epss_score": 0.00233, "epss_percentile": 0.46012}, "CVE-2021-41299": {"epss_score": 0.01186, "epss_percentile": 0.7835}, "CVE-2021-41300": {"epss_score": 0.00417, "epss_percentile": 0.61222}, "CVE-2021-41301": {"epss_score": 0.0043, "epss_percentile": 0.62027}, "CVE-2021-41302": {"epss_score": 0.00163, "epss_percentile": 0.37785}, "CVE-2021-41303": {"epss_score": 0.53416, "epss_percentile": 0.97875}, "CVE-2021-41304": {"epss_score": 0.00389, "epss_percentile": 0.59458}, "CVE-2021-41305": {"epss_score": 0.00414, "epss_percentile": 0.61093}, "CVE-2021-41306": {"epss_score": 0.00414, "epss_percentile": 0.61093}, "CVE-2021-41307": {"epss_score": 0.00715, "epss_percentile": 0.71833}, "CVE-2021-41308": {"epss_score": 0.00146, "epss_percentile": 0.35536}, "CVE-2021-41309": {"epss_score": 0.00184, "epss_percentile": 0.40432}, "CVE-2021-41310": {"epss_score": 0.00389, "epss_percentile": 0.59458}, "CVE-2021-41311": {"epss_score": 0.00188, "epss_percentile": 0.40832}, "CVE-2021-41312": {"epss_score": 0.00318, "epss_percentile": 0.54438}, "CVE-2021-41313": {"epss_score": 0.00146, "epss_percentile": 0.35536}, "CVE-2021-41314": {"epss_score": 0.03647, "epss_percentile": 0.87501}, "CVE-2021-41315": {"epss_score": 0.00629, "epss_percentile": 0.69673}, "CVE-2021-41316": {"epss_score": 0.00653, "epss_percentile": 0.70335}, "CVE-2021-41317": {"epss_score": 0.00502, "epss_percentile": 0.65373}, "CVE-2021-41318": {"epss_score": 0.00453, "epss_percentile": 0.63228}, "CVE-2021-41320": {"epss_score": 0.00058, "epss_percentile": 0.18561}, "CVE-2021-41322": {"epss_score": 0.00525, "epss_percentile": 0.66386}, "CVE-2021-41323": {"epss_score": 0.0028, "epss_percentile": 0.51065}, "CVE-2021-41324": {"epss_score": 0.00374, "epss_percentile": 0.5857}, "CVE-2021-41325": {"epss_score": 0.00209, "epss_percentile": 0.43383}, "CVE-2021-41326": {"epss_score": 0.00252, "epss_percentile": 0.4836}, "CVE-2021-41329": {"epss_score": 0.00405, "epss_percentile": 0.6049}, "CVE-2021-41330": {"epss_score": 0.03146, "epss_percentile": 0.86495}, "CVE-2021-41331": {"epss_score": 0.03248, "epss_percentile": 0.86747}, "CVE-2021-41332": {"epss_score": 0.213, "epss_percentile": 0.95497}, "CVE-2021-41333": {"epss_score": 0.00653, "epss_percentile": 0.70333}, "CVE-2021-41334": {"epss_score": 0.00197, "epss_percentile": 0.41871}, "CVE-2021-41335": {"epss_score": 0.00322, "epss_percentile": 0.54803}, "CVE-2021-41336": {"epss_score": 0.00403, "epss_percentile": 0.60347}, "CVE-2021-41337": {"epss_score": 0.00496, "epss_percentile": 0.65154}, "CVE-2021-41338": {"epss_score": 0.01201, "epss_percentile": 0.78481}, "CVE-2021-41339": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2021-41340": {"epss_score": 0.03248, "epss_percentile": 0.86747}, "CVE-2021-41342": {"epss_score": 0.01815, "epss_percentile": 0.82383}, "CVE-2021-41343": {"epss_score": 0.00427, "epss_percentile": 0.61782}, "CVE-2021-41344": {"epss_score": 0.04739, "epss_percentile": 0.89077}, "CVE-2021-41345": {"epss_score": 0.00436, "epss_percentile": 0.62463}, "CVE-2021-41346": {"epss_score": 0.00259, "epss_percentile": 0.49035}, "CVE-2021-41347": {"epss_score": 0.00203, "epss_percentile": 0.42509}, "CVE-2021-41348": {"epss_score": 0.00406, "epss_percentile": 0.60537}, "CVE-2021-41349": {"epss_score": 0.91327, "epss_percentile": 0.99634}, "CVE-2021-41350": {"epss_score": 0.04474, "epss_percentile": 0.88736}, "CVE-2021-41351": {"epss_score": 0.09764, "epss_percentile": 0.92693}, "CVE-2021-41352": {"epss_score": 0.09515, "epss_percentile": 0.92582}, "CVE-2021-41353": {"epss_score": 0.00526, "epss_percentile": 0.66413}, "CVE-2021-41354": {"epss_score": 0.00664, "epss_percentile": 0.70648}, "CVE-2021-41355": {"epss_score": 0.03608, "epss_percentile": 0.87421}, "CVE-2021-41356": {"epss_score": 0.03827, "epss_percentile": 0.87795}, "CVE-2021-41357": {"epss_score": 0.07369, "epss_percentile": 0.91438}, "CVE-2021-41360": {"epss_score": 0.00681, "epss_percentile": 0.71041}, "CVE-2021-41361": {"epss_score": 0.00501, "epss_percentile": 0.65359}, "CVE-2021-41363": {"epss_score": 0.00193, "epss_percentile": 0.41383}, "CVE-2021-41365": {"epss_score": 0.01091, "epss_percentile": 0.7746}, "CVE-2021-41366": {"epss_score": 0.00171, "epss_percentile": 0.38795}, "CVE-2021-41367": {"epss_score": 0.00356, "epss_percentile": 0.57387}, "CVE-2021-41368": {"epss_score": 0.0112, "epss_percentile": 0.77763}, "CVE-2021-41370": {"epss_score": 0.00234, "epss_percentile": 0.46105}, "CVE-2021-41371": {"epss_score": 0.00584, "epss_percentile": 0.68372}, "CVE-2021-41372": {"epss_score": 0.00233, "epss_percentile": 0.46032}, "CVE-2021-41373": {"epss_score": 0.00282, "epss_percentile": 0.51203}, "CVE-2021-41374": {"epss_score": 0.00337, "epss_percentile": 0.5601}, "CVE-2021-41375": {"epss_score": 0.00384, "epss_percentile": 0.59181}, "CVE-2021-41376": {"epss_score": 0.00739, "epss_percentile": 0.72354}, "CVE-2021-41377": {"epss_score": 0.00318, "epss_percentile": 0.54409}, "CVE-2021-41378": {"epss_score": 0.00557, "epss_percentile": 0.67547}, "CVE-2021-41379": {"epss_score": 0.01716, "epss_percentile": 0.81906}, "CVE-2021-41380": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2021-41381": {"epss_score": 0.80779, "epss_percentile": 0.99105}, "CVE-2021-41382": {"epss_score": 0.15404, "epss_percentile": 0.94425}, "CVE-2021-41383": {"epss_score": 0.01156, "epss_percentile": 0.78101}, "CVE-2021-41385": {"epss_score": 0.00215, "epss_percentile": 0.44106}, "CVE-2021-41387": {"epss_score": 0.00433, "epss_percentile": 0.62186}, "CVE-2021-41388": {"epss_score": 0.00044, "epss_percentile": 0.13545}, "CVE-2021-41390": {"epss_score": 0.00433, "epss_percentile": 0.62207}, "CVE-2021-41391": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-41392": {"epss_score": 0.07063, "epss_percentile": 0.91222}, "CVE-2021-41393": {"epss_score": 0.00397, "epss_percentile": 0.59969}, "CVE-2021-41394": {"epss_score": 0.00292, "epss_percentile": 0.52253}, "CVE-2021-41395": {"epss_score": 0.00225, "epss_percentile": 0.45233}, "CVE-2021-41396": {"epss_score": 0.0044, "epss_percentile": 0.62623}, "CVE-2021-41402": {"epss_score": 0.01025, "epss_percentile": 0.76788}, "CVE-2021-41403": {"epss_score": 0.00518, "epss_percentile": 0.66113}, "CVE-2021-41408": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2021-41411": {"epss_score": 0.00066, "epss_percentile": 0.20769}, "CVE-2021-41413": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-41415": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-41418": {"epss_score": 0.00316, "epss_percentile": 0.54221}, "CVE-2021-41419": {"epss_score": 0.79351, "epss_percentile": 0.99035}, "CVE-2021-41420": {"epss_score": 0.01943, "epss_percentile": 0.82994}, "CVE-2021-41421": {"epss_score": 0.00328, "epss_percentile": 0.55155}, "CVE-2021-41426": {"epss_score": 0.00175, "epss_percentile": 0.3927}, "CVE-2021-41427": {"epss_score": 0.00397, "epss_percentile": 0.60045}, "CVE-2021-41432": {"epss_score": 0.05677, "epss_percentile": 0.90113}, "CVE-2021-41433": {"epss_score": 0.00568, "epss_percentile": 0.6788}, "CVE-2021-41434": {"epss_score": 0.00356, "epss_percentile": 0.57344}, "CVE-2021-41435": {"epss_score": 0.02497, "epss_percentile": 0.84911}, "CVE-2021-41436": {"epss_score": 0.04577, "epss_percentile": 0.88869}, "CVE-2021-41437": {"epss_score": 0.01205, "epss_percentile": 0.78509}, "CVE-2021-41441": {"epss_score": 0.00233, "epss_percentile": 0.46031}, "CVE-2021-41442": {"epss_score": 0.02319, "epss_percentile": 0.84364}, "CVE-2021-41445": {"epss_score": 0.00443, "epss_percentile": 0.62784}, "CVE-2021-41449": {"epss_score": 0.01438, "epss_percentile": 0.80285}, "CVE-2021-41450": {"epss_score": 0.05961, "epss_percentile": 0.90366}, "CVE-2021-41451": {"epss_score": 0.06833, "epss_percentile": 0.91056}, "CVE-2021-41456": {"epss_score": 0.00092, "epss_percentile": 0.26558}, "CVE-2021-41457": {"epss_score": 0.00112, "epss_percentile": 0.30408}, "CVE-2021-41458": {"epss_score": 0.00175, "epss_percentile": 0.39266}, "CVE-2021-41459": {"epss_score": 0.00092, "epss_percentile": 0.26558}, "CVE-2021-41460": {"epss_score": 0.2834, "epss_percentile": 0.96344}, "CVE-2021-41461": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2021-41462": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2021-41463": {"epss_score": 0.00255, "epss_percentile": 0.48649}, "CVE-2021-41464": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2021-41465": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2021-41467": {"epss_score": 0.0516, "epss_percentile": 0.89558}, "CVE-2021-41471": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-41472": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-41487": {"epss_score": 0.00477, "epss_percentile": 0.64304}, "CVE-2021-41490": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-41492": {"epss_score": 0.00375, "epss_percentile": 0.58611}, "CVE-2021-41495": {"epss_score": 0.00108, "epss_percentile": 0.29792}, "CVE-2021-41496": {"epss_score": 0.00042, "epss_percentile": 0.12609}, "CVE-2021-41497": {"epss_score": 0.00281, "epss_percentile": 0.51137}, "CVE-2021-41498": {"epss_score": 0.00321, "epss_percentile": 0.54646}, "CVE-2021-41499": {"epss_score": 0.00388, "epss_percentile": 0.59393}, "CVE-2021-41500": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2021-41502": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-41503": {"epss_score": 0.0043, "epss_percentile": 0.62029}, "CVE-2021-41504": {"epss_score": 0.00164, "epss_percentile": 0.38}, "CVE-2021-41506": {"epss_score": 0.00974, "epss_percentile": 0.76174}, "CVE-2021-41511": {"epss_score": 0.00691, "epss_percentile": 0.71272}, "CVE-2021-41524": {"epss_score": 0.07103, "epss_percentile": 0.91254}, "CVE-2021-41525": {"epss_score": 0.00055, "epss_percentile": 0.17525}, "CVE-2021-41526": {"epss_score": 0.00051, "epss_percentile": 0.1625}, "CVE-2021-41527": {"epss_score": 0.00124, "epss_percentile": 0.32362}, "CVE-2021-41528": {"epss_score": 0.00108, "epss_percentile": 0.29864}, "CVE-2021-41530": {"epss_score": 0.00366, "epss_percentile": 0.58016}, "CVE-2021-41531": {"epss_score": 0.00351, "epss_percentile": 0.57031}, "CVE-2021-41532": {"epss_score": 0.01277, "epss_percentile": 0.79116}, "CVE-2021-41533": {"epss_score": 0.0021, "epss_percentile": 0.43475}, "CVE-2021-41534": {"epss_score": 0.0021, "epss_percentile": 0.43475}, "CVE-2021-41535": {"epss_score": 0.0059, "epss_percentile": 0.68554}, "CVE-2021-41536": {"epss_score": 0.00678, "epss_percentile": 0.70981}, "CVE-2021-41537": {"epss_score": 0.00678, "epss_percentile": 0.70981}, "CVE-2021-41538": {"epss_score": 0.0021, "epss_percentile": 0.43475}, "CVE-2021-41539": {"epss_score": 0.00678, "epss_percentile": 0.70981}, "CVE-2021-41540": {"epss_score": 0.00678, "epss_percentile": 0.70981}, "CVE-2021-41541": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2021-41542": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2021-41543": {"epss_score": 0.00215, "epss_percentile": 0.44054}, "CVE-2021-41544": {"epss_score": 0.00033, "epss_percentile": 0.09137}, "CVE-2021-41545": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2021-41546": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2021-41547": {"epss_score": 0.00822, "epss_percentile": 0.73917}, "CVE-2021-41550": {"epss_score": 0.00469, "epss_percentile": 0.63941}, "CVE-2021-41551": {"epss_score": 0.00207, "epss_percentile": 0.43186}, "CVE-2021-41552": {"epss_score": 0.01263, "epss_percentile": 0.78989}, "CVE-2021-41553": {"epss_score": 0.00467, "epss_percentile": 0.63862}, "CVE-2021-41554": {"epss_score": 0.00291, "epss_percentile": 0.52181}, "CVE-2021-41555": {"epss_score": 0.00396, "epss_percentile": 0.59908}, "CVE-2021-41556": {"epss_score": 0.00836, "epss_percentile": 0.7413}, "CVE-2021-41557": {"epss_score": 0.00266, "epss_percentile": 0.49875}, "CVE-2021-41558": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-41559": {"epss_score": 0.00348, "epss_percentile": 0.56842}, "CVE-2021-41560": {"epss_score": 0.46152, "epss_percentile": 0.97534}, "CVE-2021-41561": {"epss_score": 0.00351, "epss_percentile": 0.57049}, "CVE-2021-41562": {"epss_score": 0.00054, "epss_percentile": 0.17331}, "CVE-2021-41563": {"epss_score": 0.00686, "epss_percentile": 0.71161}, "CVE-2021-41564": {"epss_score": 0.00332, "epss_percentile": 0.55569}, "CVE-2021-41565": {"epss_score": 0.00311, "epss_percentile": 0.53838}, "CVE-2021-41566": {"epss_score": 0.02197, "epss_percentile": 0.83957}, "CVE-2021-41567": {"epss_score": 0.00686, "epss_percentile": 0.71161}, "CVE-2021-41568": {"epss_score": 0.00163, "epss_percentile": 0.37833}, "CVE-2021-41569": {"epss_score": 0.5477, "epss_percentile": 0.97944}, "CVE-2021-41570": {"epss_score": 0.00437, "epss_percentile": 0.62535}, "CVE-2021-41571": {"epss_score": 0.00979, "epss_percentile": 0.76254}, "CVE-2021-41573": {"epss_score": 0.00204, "epss_percentile": 0.42653}, "CVE-2021-41578": {"epss_score": 0.00329, "epss_percentile": 0.55395}, "CVE-2021-41579": {"epss_score": 0.01076, "epss_percentile": 0.77322}, "CVE-2021-41580": {"epss_score": 0.00474, "epss_percentile": 0.64159}, "CVE-2021-41581": {"epss_score": 0.00304, "epss_percentile": 0.53308}, "CVE-2021-41583": {"epss_score": 0.00614, "epss_percentile": 0.69275}, "CVE-2021-41584": {"epss_score": 0.00511, "epss_percentile": 0.65824}, "CVE-2021-41585": {"epss_score": 0.01034, "epss_percentile": 0.76891}, "CVE-2021-41586": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2021-41587": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2021-41588": {"epss_score": 0.00194, "epss_percentile": 0.4154}, "CVE-2021-41589": {"epss_score": 0.02448, "epss_percentile": 0.84774}, "CVE-2021-41590": {"epss_score": 0.00206, "epss_percentile": 0.43053}, "CVE-2021-41591": {"epss_score": 0.00591, "epss_percentile": 0.68589}, "CVE-2021-41592": {"epss_score": 0.00831, "epss_percentile": 0.74042}, "CVE-2021-41593": {"epss_score": 0.00719, "epss_percentile": 0.71946}, "CVE-2021-41594": {"epss_score": 0.00247, "epss_percentile": 0.47871}, "CVE-2021-41595": {"epss_score": 0.00269, "epss_percentile": 0.50189}, "CVE-2021-41596": {"epss_score": 0.00302, "epss_percentile": 0.53099}, "CVE-2021-41597": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2021-41598": {"epss_score": 0.00272, "epss_percentile": 0.50368}, "CVE-2021-41599": {"epss_score": 0.02496, "epss_percentile": 0.84908}, "CVE-2021-41608": {"epss_score": 0.01134, "epss_percentile": 0.77892}, "CVE-2021-41609": {"epss_score": 0.03374, "epss_percentile": 0.87014}, "CVE-2021-41611": {"epss_score": 0.02164, "epss_percentile": 0.83837}, "CVE-2021-41612": {"epss_score": 0.00132, "epss_percentile": 0.33582}, "CVE-2021-41613": {"epss_score": 0.00131, "epss_percentile": 0.33401}, "CVE-2021-41614": {"epss_score": 0.0002, "epss_percentile": 0.0452}, "CVE-2021-41615": {"epss_score": 0.00275, "epss_percentile": 0.50663}, "CVE-2021-41616": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2021-41617": {"epss_score": 0.00372, "epss_percentile": 0.5844}, "CVE-2021-41619": {"epss_score": 0.03729, "epss_percentile": 0.87638}, "CVE-2021-41634": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2021-41635": {"epss_score": 0.01581, "epss_percentile": 0.81139}, "CVE-2021-41636": {"epss_score": 0.00408, "epss_percentile": 0.60637}, "CVE-2021-41637": {"epss_score": 0.00038, "epss_percentile": 0.1134}, "CVE-2021-41638": {"epss_score": 0.00382, "epss_percentile": 0.59035}, "CVE-2021-41639": {"epss_score": 0.00059, "epss_percentile": 0.18635}, "CVE-2021-41641": {"epss_score": 0.00128, "epss_percentile": 0.32974}, "CVE-2021-41643": {"epss_score": 0.1073, "epss_percentile": 0.93085}, "CVE-2021-41644": {"epss_score": 0.00762, "epss_percentile": 0.72845}, "CVE-2021-41645": {"epss_score": 0.10252, "epss_percentile": 0.92914}, "CVE-2021-41646": {"epss_score": 0.03679, "epss_percentile": 0.87557}, "CVE-2021-41647": {"epss_score": 0.00976, "epss_percentile": 0.76209}, "CVE-2021-41648": {"epss_score": 0.63228, "epss_percentile": 0.98324}, "CVE-2021-41649": {"epss_score": 0.9066, "epss_percentile": 0.99595}, "CVE-2021-41651": {"epss_score": 0.06322, "epss_percentile": 0.90671}, "CVE-2021-41652": {"epss_score": 0.00277, "epss_percentile": 0.50775}, "CVE-2021-41653": {"epss_score": 0.91914, "epss_percentile": 0.99678}, "CVE-2021-41654": {"epss_score": 0.00286, "epss_percentile": 0.51719}, "CVE-2021-41657": {"epss_score": 0.00256, "epss_percentile": 0.48835}, "CVE-2021-41658": {"epss_score": 0.00344, "epss_percentile": 0.56491}, "CVE-2021-41659": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-41660": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-41661": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2021-41662": {"epss_score": 0.01632, "epss_percentile": 0.81456}, "CVE-2021-41663": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2021-41672": {"epss_score": 0.00675, "epss_percentile": 0.70889}, "CVE-2021-41674": {"epss_score": 0.00375, "epss_percentile": 0.58611}, "CVE-2021-41675": {"epss_score": 0.03659, "epss_percentile": 0.87521}, "CVE-2021-41676": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2021-41677": {"epss_score": 0.00383, "epss_percentile": 0.59105}, "CVE-2021-41678": {"epss_score": 0.00561, "epss_percentile": 0.67665}, "CVE-2021-41679": {"epss_score": 0.00561, "epss_percentile": 0.67665}, "CVE-2021-41682": {"epss_score": 0.00278, "epss_percentile": 0.50877}, "CVE-2021-41683": {"epss_score": 0.00275, "epss_percentile": 0.50666}, "CVE-2021-41687": {"epss_score": 0.00149, "epss_percentile": 0.35994}, "CVE-2021-41688": {"epss_score": 0.00116, "epss_percentile": 0.31157}, "CVE-2021-41689": {"epss_score": 0.0012, "epss_percentile": 0.31689}, "CVE-2021-41690": {"epss_score": 0.00116, "epss_percentile": 0.31157}, "CVE-2021-41691": {"epss_score": 0.03321, "epss_percentile": 0.8691}, "CVE-2021-41694": {"epss_score": 0.00353, "epss_percentile": 0.57182}, "CVE-2021-41695": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2021-41696": {"epss_score": 0.00178, "epss_percentile": 0.39672}, "CVE-2021-41697": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-41714": {"epss_score": 0.00569, "epss_percentile": 0.67935}, "CVE-2021-41715": {"epss_score": 0.00389, "epss_percentile": 0.59453}, "CVE-2021-41716": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2021-41719": {"epss_score": 0.00131, "epss_percentile": 0.33416}, "CVE-2021-41728": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-41729": {"epss_score": 0.00252, "epss_percentile": 0.48338}, "CVE-2021-41731": {"epss_score": 0.00318, "epss_percentile": 0.54437}, "CVE-2021-41732": {"epss_score": 0.00191, "epss_percentile": 0.41171}, "CVE-2021-41733": {"epss_score": 0.00443, "epss_percentile": 0.628}, "CVE-2021-41736": {"epss_score": 0.00385, "epss_percentile": 0.59191}, "CVE-2021-41737": {"epss_score": 0.00165, "epss_percentile": 0.38139}, "CVE-2021-41738": {"epss_score": 0.03544, "epss_percentile": 0.87321}, "CVE-2021-41739": {"epss_score": 0.06738, "epss_percentile": 0.90994}, "CVE-2021-41744": {"epss_score": 0.02802, "epss_percentile": 0.85698}, "CVE-2021-41745": {"epss_score": 0.00316, "epss_percentile": 0.54285}, "CVE-2021-41746": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2021-41747": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-41749": {"epss_score": 0.85815, "epss_percentile": 0.9935}, "CVE-2021-41750": {"epss_score": 0.00472, "epss_percentile": 0.64042}, "CVE-2021-41751": {"epss_score": 0.00437, "epss_percentile": 0.62505}, "CVE-2021-41752": {"epss_score": 0.00385, "epss_percentile": 0.59189}, "CVE-2021-41753": {"epss_score": 0.01436, "epss_percentile": 0.80273}, "CVE-2021-41754": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-41755": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2021-41756": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2021-41764": {"epss_score": 0.00172, "epss_percentile": 0.38986}, "CVE-2021-41765": {"epss_score": 0.36064, "epss_percentile": 0.96952}, "CVE-2021-41766": {"epss_score": 0.00368, "epss_percentile": 0.58188}, "CVE-2021-41767": {"epss_score": 0.00457, "epss_percentile": 0.63381}, "CVE-2021-41769": {"epss_score": 0.00474, "epss_percentile": 0.64162}, "CVE-2021-41770": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2021-41771": {"epss_score": 0.0043, "epss_percentile": 0.62005}, "CVE-2021-41772": {"epss_score": 0.00062, "epss_percentile": 0.19736}, "CVE-2021-41773": {"epss_score": 0.94377, "epss_percentile": 0.99963}, "CVE-2021-41780": {"epss_score": 0.0011, "epss_percentile": 0.30158}, "CVE-2021-41781": {"epss_score": 0.0011, "epss_percentile": 0.30158}, "CVE-2021-41782": {"epss_score": 0.0011, "epss_percentile": 0.30158}, "CVE-2021-41783": {"epss_score": 0.0011, "epss_percentile": 0.30158}, "CVE-2021-41784": {"epss_score": 0.03221, "epss_percentile": 0.86674}, "CVE-2021-41785": {"epss_score": 0.0011, "epss_percentile": 0.30158}, "CVE-2021-41788": {"epss_score": 0.00549, "epss_percentile": 0.67294}, "CVE-2021-41789": {"epss_score": 0.00215, "epss_percentile": 0.44074}, "CVE-2021-41790": {"epss_score": 0.00853, "epss_percentile": 0.74427}, "CVE-2021-41791": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-41792": {"epss_score": 0.00198, "epss_percentile": 0.42058}, "CVE-2021-41794": {"epss_score": 0.00395, "epss_percentile": 0.59815}, "CVE-2021-41795": {"epss_score": 0.00341, "epss_percentile": 0.56293}, "CVE-2021-41798": {"epss_score": 0.00151, "epss_percentile": 0.36202}, "CVE-2021-41799": {"epss_score": 0.00268, "epss_percentile": 0.50069}, "CVE-2021-41800": {"epss_score": 0.00177, "epss_percentile": 0.39623}, "CVE-2021-41801": {"epss_score": 0.00395, "epss_percentile": 0.5981}, "CVE-2021-41802": {"epss_score": 0.00254, "epss_percentile": 0.4856}, "CVE-2021-41803": {"epss_score": 0.00273, "epss_percentile": 0.50423}, "CVE-2021-41805": {"epss_score": 0.02299, "epss_percentile": 0.84304}, "CVE-2021-41807": {"epss_score": 0.00229, "epss_percentile": 0.45609}, "CVE-2021-41808": {"epss_score": 0.00048, "epss_percentile": 0.14994}, "CVE-2021-41809": {"epss_score": 0.00149, "epss_percentile": 0.35948}, "CVE-2021-41810": {"epss_score": 0.00255, "epss_percentile": 0.48644}, "CVE-2021-41816": {"epss_score": 0.00905, "epss_percentile": 0.75241}, "CVE-2021-41817": {"epss_score": 0.00495, "epss_percentile": 0.65114}, "CVE-2021-41819": {"epss_score": 0.00881, "epss_percentile": 0.74876}, "CVE-2021-41821": {"epss_score": 0.00466, "epss_percentile": 0.63788}, "CVE-2021-41823": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2021-41824": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2021-41825": {"epss_score": 0.00456, "epss_percentile": 0.63333}, "CVE-2021-41826": {"epss_score": 0.23963, "epss_percentile": 0.95839}, "CVE-2021-41827": {"epss_score": 0.11396, "epss_percentile": 0.93333}, "CVE-2021-41828": {"epss_score": 0.11396, "epss_percentile": 0.93333}, "CVE-2021-41829": {"epss_score": 0.06058, "epss_percentile": 0.9044}, "CVE-2021-41830": {"epss_score": 0.00452, "epss_percentile": 0.63166}, "CVE-2021-41831": {"epss_score": 0.0082, "epss_percentile": 0.7388}, "CVE-2021-41832": {"epss_score": 0.00333, "epss_percentile": 0.55626}, "CVE-2021-41833": {"epss_score": 0.27313, "epss_percentile": 0.96236}, "CVE-2021-41834": {"epss_score": 0.0018, "epss_percentile": 0.39906}, "CVE-2021-41835": {"epss_score": 0.00049, "epss_percentile": 0.15491}, "CVE-2021-41836": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-41837": {"epss_score": 0.00063, "epss_percentile": 0.20067}, "CVE-2021-41838": {"epss_score": 0.00055, "epss_percentile": 0.17423}, "CVE-2021-41839": {"epss_score": 0.00087, "epss_percentile": 0.25496}, "CVE-2021-41840": {"epss_score": 0.00057, "epss_percentile": 0.18021}, "CVE-2021-41841": {"epss_score": 0.00057, "epss_percentile": 0.18021}, "CVE-2021-41842": {"epss_score": 0.01216, "epss_percentile": 0.78595}, "CVE-2021-41843": {"epss_score": 0.00179, "epss_percentile": 0.39813}, "CVE-2021-41844": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2021-41845": {"epss_score": 0.00218, "epss_percentile": 0.44356}, "CVE-2021-41847": {"epss_score": 0.00503, "epss_percentile": 0.65444}, "CVE-2021-41848": {"epss_score": 0.00078, "epss_percentile": 0.23788}, "CVE-2021-41849": {"epss_score": 0.00031, "epss_percentile": 0.08574}, "CVE-2021-41850": {"epss_score": 0.00149, "epss_percentile": 0.35995}, "CVE-2021-41861": {"epss_score": 0.00058, "epss_percentile": 0.18368}, "CVE-2021-41862": {"epss_score": 0.01119, "epss_percentile": 0.77752}, "CVE-2021-41864": {"epss_score": 0.0003, "epss_percentile": 0.08278}, "CVE-2021-41865": {"epss_score": 0.00462, "epss_percentile": 0.63571}, "CVE-2021-41866": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2021-41867": {"epss_score": 0.00477, "epss_percentile": 0.64352}, "CVE-2021-41868": {"epss_score": 0.00712, "epss_percentile": 0.71756}, "CVE-2021-41869": {"epss_score": 0.00883, "epss_percentile": 0.74917}, "CVE-2021-41870": {"epss_score": 0.00706, "epss_percentile": 0.71606}, "CVE-2021-41871": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-41872": {"epss_score": 0.00322, "epss_percentile": 0.54783}, "CVE-2021-41873": {"epss_score": 0.00399, "epss_percentile": 0.60112}, "CVE-2021-41878": {"epss_score": 0.0795, "epss_percentile": 0.91783}, "CVE-2021-41916": {"epss_score": 0.00193, "epss_percentile": 0.41497}, "CVE-2021-41917": {"epss_score": 0.00324, "epss_percentile": 0.54974}, "CVE-2021-41918": {"epss_score": 0.00324, "epss_percentile": 0.54974}, "CVE-2021-41919": {"epss_score": 0.0153, "epss_percentile": 0.80886}, "CVE-2021-41920": {"epss_score": 0.02592, "epss_percentile": 0.85184}, "CVE-2021-41921": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2021-41924": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-41928": {"epss_score": 0.00621, "epss_percentile": 0.69492}, "CVE-2021-41929": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2021-41930": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2021-41931": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-41932": {"epss_score": 0.00318, "epss_percentile": 0.54425}, "CVE-2021-41938": {"epss_score": 0.00378, "epss_percentile": 0.58785}, "CVE-2021-41942": {"epss_score": 0.00251, "epss_percentile": 0.48312}, "CVE-2021-41943": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2021-41945": {"epss_score": 0.00718, "epss_percentile": 0.7192}, "CVE-2021-41946": {"epss_score": 0.00665, "epss_percentile": 0.70665}, "CVE-2021-41947": {"epss_score": 0.00299, "epss_percentile": 0.52881}, "CVE-2021-41948": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-41950": {"epss_score": 0.32263, "epss_percentile": 0.96684}, "CVE-2021-41951": {"epss_score": 0.58407, "epss_percentile": 0.98115}, "CVE-2021-41952": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2021-41959": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-41962": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2021-41965": {"epss_score": 0.0025, "epss_percentile": 0.4825}, "CVE-2021-41971": {"epss_score": 0.00785, "epss_percentile": 0.73254}, "CVE-2021-41972": {"epss_score": 0.00314, "epss_percentile": 0.54115}, "CVE-2021-41973": {"epss_score": 0.00622, "epss_percentile": 0.6951}, "CVE-2021-41974": {"epss_score": 0.00313, "epss_percentile": 0.5406}, "CVE-2021-41975": {"epss_score": 0.0044, "epss_percentile": 0.62629}, "CVE-2021-41976": {"epss_score": 0.00314, "epss_percentile": 0.54122}, "CVE-2021-41987": {"epss_score": 0.49622, "epss_percentile": 0.97697}, "CVE-2021-41988": {"epss_score": 0.00043, "epss_percentile": 0.13099}, "CVE-2021-41989": {"epss_score": 0.00043, "epss_percentile": 0.13099}, "CVE-2021-41990": {"epss_score": 0.02501, "epss_percentile": 0.84924}, "CVE-2021-41991": {"epss_score": 0.01874, "epss_percentile": 0.82647}, "CVE-2021-41992": {"epss_score": 0.00148, "epss_percentile": 0.35819}, "CVE-2021-41993": {"epss_score": 0.00075, "epss_percentile": 0.22887}, "CVE-2021-41994": {"epss_score": 0.00075, "epss_percentile": 0.22887}, "CVE-2021-41995": {"epss_score": 0.00248, "epss_percentile": 0.47939}, "CVE-2021-42000": {"epss_score": 0.00117, "epss_percentile": 0.31377}, "CVE-2021-42001": {"epss_score": 0.00218, "epss_percentile": 0.44432}, "CVE-2021-42002": {"epss_score": 0.09273, "epss_percentile": 0.92479}, "CVE-2021-42006": {"epss_score": 0.00425, "epss_percentile": 0.61718}, "CVE-2021-42008": {"epss_score": 0.00929, "epss_percentile": 0.75593}, "CVE-2021-42009": {"epss_score": 0.00652, "epss_percentile": 0.70306}, "CVE-2021-42010": {"epss_score": 0.00495, "epss_percentile": 0.65112}, "CVE-2021-42011": {"epss_score": 0.00108, "epss_percentile": 0.2979}, "CVE-2021-42012": {"epss_score": 0.00418, "epss_percentile": 0.61267}, "CVE-2021-42013": {"epss_score": 0.9441, "epss_percentile": 0.99975}, "CVE-2021-42015": {"epss_score": 0.00125, "epss_percentile": 0.32595}, "CVE-2021-42016": {"epss_score": 0.0014, "epss_percentile": 0.3469}, "CVE-2021-42017": {"epss_score": 0.00087, "epss_percentile": 0.25564}, "CVE-2021-42018": {"epss_score": 0.006, "epss_percentile": 0.6881}, "CVE-2021-42019": {"epss_score": 0.00556, "epss_percentile": 0.67507}, "CVE-2021-42020": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2021-42021": {"epss_score": 0.00995, "epss_percentile": 0.7644}, "CVE-2021-42022": {"epss_score": 0.00434, "epss_percentile": 0.62286}, "CVE-2021-42023": {"epss_score": 0.00142, "epss_percentile": 0.35047}, "CVE-2021-42024": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-42025": {"epss_score": 0.00147, "epss_percentile": 0.35662}, "CVE-2021-42026": {"epss_score": 0.00149, "epss_percentile": 0.3599}, "CVE-2021-42027": {"epss_score": 0.00136, "epss_percentile": 0.34156}, "CVE-2021-42028": {"epss_score": 0.00041, "epss_percentile": 0.12237}, "CVE-2021-42029": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2021-42040": {"epss_score": 0.00328, "epss_percentile": 0.55272}, "CVE-2021-42041": {"epss_score": 0.0051, "epss_percentile": 0.65765}, "CVE-2021-42042": {"epss_score": 0.00404, "epss_percentile": 0.60437}, "CVE-2021-42043": {"epss_score": 0.0044, "epss_percentile": 0.62617}, "CVE-2021-42044": {"epss_score": 0.00375, "epss_percentile": 0.58631}, "CVE-2021-42045": {"epss_score": 0.00213, "epss_percentile": 0.43908}, "CVE-2021-42046": {"epss_score": 0.00304, "epss_percentile": 0.53274}, "CVE-2021-42047": {"epss_score": 0.00213, "epss_percentile": 0.43908}, "CVE-2021-42048": {"epss_score": 0.00219, "epss_percentile": 0.4447}, "CVE-2021-42049": {"epss_score": 0.00332, "epss_percentile": 0.55569}, "CVE-2021-42050": {"epss_score": 0.00298, "epss_percentile": 0.52804}, "CVE-2021-42051": {"epss_score": 0.00193, "epss_percentile": 0.41424}, "CVE-2021-42052": {"epss_score": 0.00397, "epss_percentile": 0.60051}, "CVE-2021-42053": {"epss_score": 0.00308, "epss_percentile": 0.53597}, "CVE-2021-42054": {"epss_score": 0.00261, "epss_percentile": 0.49269}, "CVE-2021-42055": {"epss_score": 0.00098, "epss_percentile": 0.27695}, "CVE-2021-42056": {"epss_score": 0.02336, "epss_percentile": 0.84417}, "CVE-2021-42057": {"epss_score": 0.00295, "epss_percentile": 0.52492}, "CVE-2021-42059": {"epss_score": 0.00063, "epss_percentile": 0.19989}, "CVE-2021-42060": {"epss_score": 0.00039, "epss_percentile": 0.11579}, "CVE-2021-42061": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-42062": {"epss_score": 0.00129, "epss_percentile": 0.33197}, "CVE-2021-42063": {"epss_score": 0.40784, "epss_percentile": 0.97237}, "CVE-2021-42064": {"epss_score": 0.0062, "epss_percentile": 0.69442}, "CVE-2021-42066": {"epss_score": 0.0012, "epss_percentile": 0.31788}, "CVE-2021-42067": {"epss_score": 0.0026, "epss_percentile": 0.49163}, "CVE-2021-42068": {"epss_score": 0.00178, "epss_percentile": 0.39637}, "CVE-2021-42069": {"epss_score": 0.00188, "epss_percentile": 0.40839}, "CVE-2021-42070": {"epss_score": 0.00178, "epss_percentile": 0.39637}, "CVE-2021-42071": {"epss_score": 0.91339, "epss_percentile": 0.99635}, "CVE-2021-42072": {"epss_score": 0.00537, "epss_percentile": 0.66904}, "CVE-2021-42073": {"epss_score": 0.0061, "epss_percentile": 0.69153}, "CVE-2021-42074": {"epss_score": 0.00885, "epss_percentile": 0.74938}, "CVE-2021-42075": {"epss_score": 0.00889, "epss_percentile": 0.75015}, "CVE-2021-42076": {"epss_score": 0.00235, "epss_percentile": 0.46329}, "CVE-2021-42077": {"epss_score": 0.00754, "epss_percentile": 0.7269}, "CVE-2021-42078": {"epss_score": 0.00298, "epss_percentile": 0.52804}, "CVE-2021-42079": {"epss_score": 0.0005, "epss_percentile": 0.15843}, "CVE-2021-42080": {"epss_score": 0.00142, "epss_percentile": 0.34968}, "CVE-2021-42081": {"epss_score": 0.00085, "epss_percentile": 0.25222}, "CVE-2021-42082": {"epss_score": 0.00043, "epss_percentile": 0.12939}, "CVE-2021-42083": {"epss_score": 0.00117, "epss_percentile": 0.31217}, "CVE-2021-42084": {"epss_score": 0.00427, "epss_percentile": 0.6189}, "CVE-2021-42085": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-42086": {"epss_score": 0.00511, "epss_percentile": 0.65827}, "CVE-2021-42087": {"epss_score": 0.00335, "epss_percentile": 0.55895}, "CVE-2021-42088": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-42089": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-42090": {"epss_score": 0.04934, "epss_percentile": 0.893}, "CVE-2021-42091": {"epss_score": 0.00253, "epss_percentile": 0.48491}, "CVE-2021-42092": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-42093": {"epss_score": 0.01069, "epss_percentile": 0.7725}, "CVE-2021-42094": {"epss_score": 0.02287, "epss_percentile": 0.8427}, "CVE-2021-42095": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-42096": {"epss_score": 0.00316, "epss_percentile": 0.54218}, "CVE-2021-42097": {"epss_score": 0.00614, "epss_percentile": 0.69288}, "CVE-2021-42098": {"epss_score": 0.00219, "epss_percentile": 0.44474}, "CVE-2021-42099": {"epss_score": 0.22415, "epss_percentile": 0.95633}, "CVE-2021-42101": {"epss_score": 0.00124, "epss_percentile": 0.32438}, "CVE-2021-42102": {"epss_score": 0.00124, "epss_percentile": 0.32438}, "CVE-2021-42103": {"epss_score": 0.00124, "epss_percentile": 0.32438}, "CVE-2021-42104": {"epss_score": 0.00123, "epss_percentile": 0.32311}, "CVE-2021-42105": {"epss_score": 0.00123, "epss_percentile": 0.32311}, "CVE-2021-42106": {"epss_score": 0.00123, "epss_percentile": 0.32311}, "CVE-2021-42107": {"epss_score": 0.00123, "epss_percentile": 0.32311}, "CVE-2021-42108": {"epss_score": 0.00123, "epss_percentile": 0.32311}, "CVE-2021-42109": {"epss_score": 0.00622, "epss_percentile": 0.69502}, "CVE-2021-42110": {"epss_score": 0.00055, "epss_percentile": 0.17599}, "CVE-2021-42111": {"epss_score": 0.00052, "epss_percentile": 0.16442}, "CVE-2021-42112": {"epss_score": 0.00576, "epss_percentile": 0.68132}, "CVE-2021-42113": {"epss_score": 0.00075, "epss_percentile": 0.22952}, "CVE-2021-42114": {"epss_score": 0.0084, "epss_percentile": 0.74201}, "CVE-2021-42115": {"epss_score": 0.00569, "epss_percentile": 0.67924}, "CVE-2021-42116": {"epss_score": 0.00128, "epss_percentile": 0.33062}, "CVE-2021-42117": {"epss_score": 0.00345, "epss_percentile": 0.5658}, "CVE-2021-42118": {"epss_score": 0.00255, "epss_percentile": 0.48699}, "CVE-2021-42119": {"epss_score": 0.00416, "epss_percentile": 0.61185}, "CVE-2021-42120": {"epss_score": 0.00378, "epss_percentile": 0.58823}, "CVE-2021-42121": {"epss_score": 0.00367, "epss_percentile": 0.58134}, "CVE-2021-42122": {"epss_score": 0.00147, "epss_percentile": 0.35775}, "CVE-2021-42123": {"epss_score": 0.00249, "epss_percentile": 0.48081}, "CVE-2021-42124": {"epss_score": 0.04319, "epss_percentile": 0.88541}, "CVE-2021-42125": {"epss_score": 0.65015, "epss_percentile": 0.98401}, "CVE-2021-42126": {"epss_score": 0.05743, "epss_percentile": 0.90173}, "CVE-2021-42127": {"epss_score": 0.53968, "epss_percentile": 0.97905}, "CVE-2021-42128": {"epss_score": 0.16888, "epss_percentile": 0.94742}, "CVE-2021-42129": {"epss_score": 0.69622, "epss_percentile": 0.98595}, "CVE-2021-42130": {"epss_score": 0.76657, "epss_percentile": 0.98899}, "CVE-2021-42131": {"epss_score": 0.27264, "epss_percentile": 0.9623}, "CVE-2021-42132": {"epss_score": 0.69622, "epss_percentile": 0.98595}, "CVE-2021-42133": {"epss_score": 0.14401, "epss_percentile": 0.94204}, "CVE-2021-42134": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-42135": {"epss_score": 0.00245, "epss_percentile": 0.47689}, "CVE-2021-42136": {"epss_score": 0.01758, "epss_percentile": 0.82138}, "CVE-2021-42137": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2021-42138": {"epss_score": 0.00186, "epss_percentile": 0.4065}, "CVE-2021-42139": {"epss_score": 0.0051, "epss_percentile": 0.65787}, "CVE-2021-42141": {"epss_score": 0.0012, "epss_percentile": 0.31809}, "CVE-2021-42142": {"epss_score": 0.0204, "epss_percentile": 0.83366}, "CVE-2021-42143": {"epss_score": 0.00354, "epss_percentile": 0.57202}, "CVE-2021-42144": {"epss_score": 0.00095, "epss_percentile": 0.27149}, "CVE-2021-42145": {"epss_score": 0.00059, "epss_percentile": 0.18742}, "CVE-2021-42146": {"epss_score": 0.00087, "epss_percentile": 0.25524}, "CVE-2021-42147": {"epss_score": 0.00354, "epss_percentile": 0.57202}, "CVE-2021-42165": {"epss_score": 0.39549, "epss_percentile": 0.97167}, "CVE-2021-42168": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-42169": {"epss_score": 0.00208, "epss_percentile": 0.43218}, "CVE-2021-42171": {"epss_score": 0.17813, "epss_percentile": 0.9491}, "CVE-2021-42183": {"epss_score": 0.51009, "epss_percentile": 0.97758}, "CVE-2021-42185": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2021-42192": {"epss_score": 0.24025, "epss_percentile": 0.95845}, "CVE-2021-42193": {"epss_score": 0.0005, "epss_percentile": 0.15872}, "CVE-2021-42194": {"epss_score": 0.00337, "epss_percentile": 0.56066}, "CVE-2021-42195": {"epss_score": 0.00451, "epss_percentile": 0.63121}, "CVE-2021-42196": {"epss_score": 0.0018, "epss_percentile": 0.39991}, "CVE-2021-42197": {"epss_score": 0.00538, "epss_percentile": 0.66945}, "CVE-2021-42198": {"epss_score": 0.0018, "epss_percentile": 0.39991}, "CVE-2021-42199": {"epss_score": 0.00903, "epss_percentile": 0.75203}, "CVE-2021-42200": {"epss_score": 0.0018, "epss_percentile": 0.39991}, "CVE-2021-42201": {"epss_score": 0.00532, "epss_percentile": 0.66694}, "CVE-2021-42202": {"epss_score": 0.0018, "epss_percentile": 0.39991}, "CVE-2021-42203": {"epss_score": 0.00759, "epss_percentile": 0.72791}, "CVE-2021-42204": {"epss_score": 0.00613, "epss_percentile": 0.6925}, "CVE-2021-42205": {"epss_score": 0.00118, "epss_percentile": 0.31388}, "CVE-2021-42216": {"epss_score": 0.00295, "epss_percentile": 0.52513}, "CVE-2021-42218": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-42219": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2021-42220": {"epss_score": 0.00271, "epss_percentile": 0.50304}, "CVE-2021-42223": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2021-42224": {"epss_score": 0.0035, "epss_percentile": 0.56938}, "CVE-2021-42227": {"epss_score": 0.00345, "epss_percentile": 0.56555}, "CVE-2021-42228": {"epss_score": 0.00186, "epss_percentile": 0.40654}, "CVE-2021-42230": {"epss_score": 0.20359, "epss_percentile": 0.95332}, "CVE-2021-42232": {"epss_score": 0.05568, "epss_percentile": 0.90004}, "CVE-2021-42233": {"epss_score": 0.00346, "epss_percentile": 0.56622}, "CVE-2021-42235": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-42237": {"epss_score": 0.94309, "epss_percentile": 0.99942}, "CVE-2021-42242": {"epss_score": 0.01057, "epss_percentile": 0.77137}, "CVE-2021-42244": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2021-42245": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2021-42250": {"epss_score": 0.0074, "epss_percentile": 0.72411}, "CVE-2021-42252": {"epss_score": 0.00131, "epss_percentile": 0.33476}, "CVE-2021-42254": {"epss_score": 0.00036, "epss_percentile": 0.10307}, "CVE-2021-42255": {"epss_score": 0.00032, "epss_percentile": 0.08828}, "CVE-2021-42257": {"epss_score": 0.00124, "epss_percentile": 0.32374}, "CVE-2021-42258": {"epss_score": 0.93664, "epss_percentile": 0.99832}, "CVE-2021-42260": {"epss_score": 0.00638, "epss_percentile": 0.69904}, "CVE-2021-42261": {"epss_score": 0.01329, "epss_percentile": 0.79507}, "CVE-2021-42262": {"epss_score": 0.0039, "epss_percentile": 0.5955}, "CVE-2021-42263": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-42264": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-42265": {"epss_score": 0.00029, "epss_percentile": 0.07938}, "CVE-2021-42266": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-42267": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-42268": {"epss_score": 0.00556, "epss_percentile": 0.67528}, "CVE-2021-42269": {"epss_score": 0.03953, "epss_percentile": 0.88002}, "CVE-2021-42270": {"epss_score": 0.03533, "epss_percentile": 0.87307}, "CVE-2021-42271": {"epss_score": 0.03533, "epss_percentile": 0.87307}, "CVE-2021-42272": {"epss_score": 0.03533, "epss_percentile": 0.87307}, "CVE-2021-42274": {"epss_score": 0.00135, "epss_percentile": 0.33995}, "CVE-2021-42275": {"epss_score": 0.02842, "epss_percentile": 0.8581}, "CVE-2021-42276": {"epss_score": 0.04919, "epss_percentile": 0.89291}, "CVE-2021-42277": {"epss_score": 0.00263, "epss_percentile": 0.49545}, "CVE-2021-42278": {"epss_score": 0.94066, "epss_percentile": 0.99896}, "CVE-2021-42279": {"epss_score": 0.03267, "epss_percentile": 0.86784}, "CVE-2021-42280": {"epss_score": 0.00157, "epss_percentile": 0.37052}, "CVE-2021-42282": {"epss_score": 0.01536, "epss_percentile": 0.8092}, "CVE-2021-42283": {"epss_score": 0.00234, "epss_percentile": 0.46105}, "CVE-2021-42284": {"epss_score": 0.06034, "epss_percentile": 0.90424}, "CVE-2021-42285": {"epss_score": 0.00256, "epss_percentile": 0.48778}, "CVE-2021-42286": {"epss_score": 0.00249, "epss_percentile": 0.48029}, "CVE-2021-42287": {"epss_score": 0.94006, "epss_percentile": 0.99884}, "CVE-2021-42288": {"epss_score": 0.00578, "epss_percentile": 0.68186}, "CVE-2021-42291": {"epss_score": 0.01291, "epss_percentile": 0.79224}, "CVE-2021-42292": {"epss_score": 0.19101, "epss_percentile": 0.95129}, "CVE-2021-42293": {"epss_score": 0.02692, "epss_percentile": 0.85439}, "CVE-2021-42294": {"epss_score": 0.00951, "epss_percentile": 0.7587}, "CVE-2021-42295": {"epss_score": 0.04162, "epss_percentile": 0.88338}, "CVE-2021-42296": {"epss_score": 0.00747, "epss_percentile": 0.72576}, "CVE-2021-42297": {"epss_score": 0.00827, "epss_percentile": 0.73989}, "CVE-2021-42298": {"epss_score": 0.02023, "epss_percentile": 0.83306}, "CVE-2021-42299": {"epss_score": 0.00414, "epss_percentile": 0.61095}, "CVE-2021-42300": {"epss_score": 0.00222, "epss_percentile": 0.44802}, "CVE-2021-42301": {"epss_score": 0.00596, "epss_percentile": 0.68711}, "CVE-2021-42302": {"epss_score": 0.00388, "epss_percentile": 0.59367}, "CVE-2021-42303": {"epss_score": 0.00388, "epss_percentile": 0.59367}, "CVE-2021-42304": {"epss_score": 0.00388, "epss_percentile": 0.59367}, "CVE-2021-42305": {"epss_score": 0.12241, "epss_percentile": 0.9361}, "CVE-2021-42306": {"epss_score": 0.06268, "epss_percentile": 0.90626}, "CVE-2021-42307": {"epss_score": 0.00221, "epss_percentile": 0.44697}, "CVE-2021-42308": {"epss_score": 0.01702, "epss_percentile": 0.81839}, "CVE-2021-42309": {"epss_score": 0.00553, "epss_percentile": 0.67428}, "CVE-2021-42310": {"epss_score": 0.01142, "epss_percentile": 0.77969}, "CVE-2021-42311": {"epss_score": 0.02009, "epss_percentile": 0.83243}, "CVE-2021-42312": {"epss_score": 0.00214, "epss_percentile": 0.43961}, "CVE-2021-42313": {"epss_score": 0.02402, "epss_percentile": 0.84641}, "CVE-2021-42314": {"epss_score": 0.03366, "epss_percentile": 0.87004}, "CVE-2021-42315": {"epss_score": 0.01141, "epss_percentile": 0.7796}, "CVE-2021-42316": {"epss_score": 0.01237, "epss_percentile": 0.7878}, "CVE-2021-42319": {"epss_score": 0.00224, "epss_percentile": 0.45036}, "CVE-2021-42320": {"epss_score": 0.00586, "epss_percentile": 0.68456}, "CVE-2021-42321": {"epss_score": 0.92801, "epss_percentile": 0.9975}, "CVE-2021-42322": {"epss_score": 0.00243, "epss_percentile": 0.47484}, "CVE-2021-42323": {"epss_score": 0.00814, "epss_percentile": 0.73774}, "CVE-2021-42324": {"epss_score": 0.00104, "epss_percentile": 0.29155}, "CVE-2021-42325": {"epss_score": 0.05516, "epss_percentile": 0.8995}, "CVE-2021-42326": {"epss_score": 0.00506, "epss_percentile": 0.65615}, "CVE-2021-42327": {"epss_score": 0.00249, "epss_percentile": 0.48077}, "CVE-2021-42329": {"epss_score": 0.00148, "epss_percentile": 0.35924}, "CVE-2021-42330": {"epss_score": 0.00175, "epss_percentile": 0.39348}, "CVE-2021-42331": {"epss_score": 0.00122, "epss_percentile": 0.32109}, "CVE-2021-42332": {"epss_score": 0.00126, "epss_percentile": 0.3267}, "CVE-2021-42333": {"epss_score": 0.00238, "epss_percentile": 0.46748}, "CVE-2021-42334": {"epss_score": 0.00238, "epss_percentile": 0.46748}, "CVE-2021-42335": {"epss_score": 0.00148, "epss_percentile": 0.35924}, "CVE-2021-42336": {"epss_score": 0.00112, "epss_percentile": 0.30421}, "CVE-2021-42337": {"epss_score": 0.00131, "epss_percentile": 0.33452}, "CVE-2021-42338": {"epss_score": 0.00811, "epss_percentile": 0.73733}, "CVE-2021-42340": {"epss_score": 0.05703, "epss_percentile": 0.90134}, "CVE-2021-42341": {"epss_score": 0.01546, "epss_percentile": 0.80965}, "CVE-2021-42342": {"epss_score": 0.77601, "epss_percentile": 0.98942}, "CVE-2021-42343": {"epss_score": 0.0311, "epss_percentile": 0.86424}, "CVE-2021-42357": {"epss_score": 0.15929, "epss_percentile": 0.94538}, "CVE-2021-42358": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-42359": {"epss_score": 0.20875, "epss_percentile": 0.95431}, "CVE-2021-42360": {"epss_score": 0.00172, "epss_percentile": 0.3891}, "CVE-2021-42361": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2021-42362": {"epss_score": 0.77546, "epss_percentile": 0.98941}, "CVE-2021-42363": {"epss_score": 0.00346, "epss_percentile": 0.56624}, "CVE-2021-42364": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2021-42365": {"epss_score": 0.00423, "epss_percentile": 0.61624}, "CVE-2021-42367": {"epss_score": 0.00241, "epss_percentile": 0.47236}, "CVE-2021-42369": {"epss_score": 0.00422, "epss_percentile": 0.61567}, "CVE-2021-42370": {"epss_score": 0.00176, "epss_percentile": 0.39396}, "CVE-2021-42371": {"epss_score": 0.00725, "epss_percentile": 0.72062}, "CVE-2021-42372": {"epss_score": 0.23026, "epss_percentile": 0.95722}, "CVE-2021-42373": {"epss_score": 0.00083, "epss_percentile": 0.2472}, "CVE-2021-42374": {"epss_score": 0.00054, "epss_percentile": 0.17192}, "CVE-2021-42375": {"epss_score": 0.00061, "epss_percentile": 0.19428}, "CVE-2021-42376": {"epss_score": 0.00045, "epss_percentile": 0.13891}, "CVE-2021-42377": {"epss_score": 0.01853, "epss_percentile": 0.82548}, "CVE-2021-42378": {"epss_score": 0.00236, "epss_percentile": 0.46407}, "CVE-2021-42379": {"epss_score": 0.00236, "epss_percentile": 0.46407}, "CVE-2021-42380": {"epss_score": 0.00452, "epss_percentile": 0.63166}, "CVE-2021-42381": {"epss_score": 0.00321, "epss_percentile": 0.54645}, "CVE-2021-42382": {"epss_score": 0.00321, "epss_percentile": 0.54645}, "CVE-2021-42383": {"epss_score": 0.00299, "epss_percentile": 0.52876}, "CVE-2021-42384": {"epss_score": 0.00236, "epss_percentile": 0.46407}, "CVE-2021-42385": {"epss_score": 0.00293, "epss_percentile": 0.52346}, "CVE-2021-42386": {"epss_score": 0.00293, "epss_percentile": 0.52346}, "CVE-2021-42387": {"epss_score": 0.00316, "epss_percentile": 0.54299}, "CVE-2021-42388": {"epss_score": 0.00365, "epss_percentile": 0.58009}, "CVE-2021-42389": {"epss_score": 0.00533, "epss_percentile": 0.66756}, "CVE-2021-42390": {"epss_score": 0.00533, "epss_percentile": 0.66756}, "CVE-2021-42391": {"epss_score": 0.00563, "epss_percentile": 0.67719}, "CVE-2021-42392": {"epss_score": 0.91037, "epss_percentile": 0.99615}, "CVE-2021-42521": {"epss_score": 0.00097, "epss_percentile": 0.27582}, "CVE-2021-42522": {"epss_score": 0.00345, "epss_percentile": 0.56594}, "CVE-2021-42523": {"epss_score": 0.00102, "epss_percentile": 0.2877}, "CVE-2021-42524": {"epss_score": 0.03533, "epss_percentile": 0.87307}, "CVE-2021-42525": {"epss_score": 0.0143, "epss_percentile": 0.80233}, "CVE-2021-42526": {"epss_score": 0.00969, "epss_percentile": 0.76104}, "CVE-2021-42527": {"epss_score": 0.00969, "epss_percentile": 0.76104}, "CVE-2021-42528": {"epss_score": 0.001, "epss_percentile": 0.28436}, "CVE-2021-42529": {"epss_score": 0.00364, "epss_percentile": 0.57913}, "CVE-2021-42530": {"epss_score": 0.00364, "epss_percentile": 0.57913}, "CVE-2021-42531": {"epss_score": 0.00826, "epss_percentile": 0.73962}, "CVE-2021-42532": {"epss_score": 0.00423, "epss_percentile": 0.61582}, "CVE-2021-42533": {"epss_score": 0.04722, "epss_percentile": 0.89056}, "CVE-2021-42534": {"epss_score": 0.00301, "epss_percentile": 0.53008}, "CVE-2021-42535": {"epss_score": 0.00196, "epss_percentile": 0.41732}, "CVE-2021-42536": {"epss_score": 0.0019, "epss_percentile": 0.4112}, "CVE-2021-42537": {"epss_score": 0.002, "epss_percentile": 0.42273}, "CVE-2021-42538": {"epss_score": 0.00219, "epss_percentile": 0.44498}, "CVE-2021-42539": {"epss_score": 0.00175, "epss_percentile": 0.39333}, "CVE-2021-42540": {"epss_score": 0.00221, "epss_percentile": 0.4465}, "CVE-2021-42542": {"epss_score": 0.0049, "epss_percentile": 0.64932}, "CVE-2021-42543": {"epss_score": 0.00174, "epss_percentile": 0.39139}, "CVE-2021-42544": {"epss_score": 0.00983, "epss_percentile": 0.76305}, "CVE-2021-42545": {"epss_score": 0.00293, "epss_percentile": 0.5235}, "CVE-2021-42546": {"epss_score": 0.00782, "epss_percentile": 0.732}, "CVE-2021-42547": {"epss_score": 0.00782, "epss_percentile": 0.732}, "CVE-2021-42548": {"epss_score": 0.00782, "epss_percentile": 0.732}, "CVE-2021-42549": {"epss_score": 0.00782, "epss_percentile": 0.732}, "CVE-2021-42550": {"epss_score": 0.02604, "epss_percentile": 0.85215}, "CVE-2021-42551": {"epss_score": 0.09561, "epss_percentile": 0.92599}, "CVE-2021-42552": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-42553": {"epss_score": 0.01415, "epss_percentile": 0.80136}, "CVE-2021-42554": {"epss_score": 0.00045, "epss_percentile": 0.1383}, "CVE-2021-42555": {"epss_score": 0.00449, "epss_percentile": 0.63043}, "CVE-2021-42556": {"epss_score": 0.01238, "epss_percentile": 0.78784}, "CVE-2021-42557": {"epss_score": 0.00507, "epss_percentile": 0.6566}, "CVE-2021-42558": {"epss_score": 0.02148, "epss_percentile": 0.83771}, "CVE-2021-42559": {"epss_score": 0.04005, "epss_percentile": 0.88102}, "CVE-2021-42560": {"epss_score": 0.10351, "epss_percentile": 0.92954}, "CVE-2021-42561": {"epss_score": 0.10288, "epss_percentile": 0.92928}, "CVE-2021-42562": {"epss_score": 0.00882, "epss_percentile": 0.74887}, "CVE-2021-42563": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2021-42564": {"epss_score": 0.0014, "epss_percentile": 0.34727}, "CVE-2021-42565": {"epss_score": 0.00675, "epss_percentile": 0.70888}, "CVE-2021-42566": {"epss_score": 0.00675, "epss_percentile": 0.70888}, "CVE-2021-42567": {"epss_score": 0.46272, "epss_percentile": 0.97539}, "CVE-2021-42568": {"epss_score": 0.00109, "epss_percentile": 0.29954}, "CVE-2021-42574": {"epss_score": 0.25542, "epss_percentile": 0.96038}, "CVE-2021-42575": {"epss_score": 0.00718, "epss_percentile": 0.71936}, "CVE-2021-42576": {"epss_score": 0.00321, "epss_percentile": 0.54691}, "CVE-2021-42577": {"epss_score": 0.00409, "epss_percentile": 0.60735}, "CVE-2021-42580": {"epss_score": 0.0188, "epss_percentile": 0.82684}, "CVE-2021-42581": {"epss_score": 0.00165, "epss_percentile": 0.38067}, "CVE-2021-42583": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2021-42584": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2021-42585": {"epss_score": 0.00421, "epss_percentile": 0.61489}, "CVE-2021-42586": {"epss_score": 0.00421, "epss_percentile": 0.61489}, "CVE-2021-42597": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2021-42612": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2021-42613": {"epss_score": 0.00204, "epss_percentile": 0.42617}, "CVE-2021-42614": {"epss_score": 0.00256, "epss_percentile": 0.48764}, "CVE-2021-42624": {"epss_score": 0.00053, "epss_percentile": 0.17023}, "CVE-2021-42627": {"epss_score": 0.61191, "epss_percentile": 0.98238}, "CVE-2021-42631": {"epss_score": 0.20569, "epss_percentile": 0.95378}, "CVE-2021-42633": {"epss_score": 0.00628, "epss_percentile": 0.69666}, "CVE-2021-42635": {"epss_score": 0.23531, "epss_percentile": 0.95789}, "CVE-2021-42637": {"epss_score": 0.01465, "epss_percentile": 0.80457}, "CVE-2021-42638": {"epss_score": 0.25003, "epss_percentile": 0.95977}, "CVE-2021-42639": {"epss_score": 0.00798, "epss_percentile": 0.73513}, "CVE-2021-42640": {"epss_score": 0.00796, "epss_percentile": 0.73487}, "CVE-2021-42641": {"epss_score": 0.00796, "epss_percentile": 0.73487}, "CVE-2021-42642": {"epss_score": 0.00676, "epss_percentile": 0.70925}, "CVE-2021-42643": {"epss_score": 0.00444, "epss_percentile": 0.62805}, "CVE-2021-42644": {"epss_score": 0.00356, "epss_percentile": 0.57397}, "CVE-2021-42645": {"epss_score": 0.06884, "epss_percentile": 0.91092}, "CVE-2021-42646": {"epss_score": 0.01343, "epss_percentile": 0.79601}, "CVE-2021-42648": {"epss_score": 0.00398, "epss_percentile": 0.60054}, "CVE-2021-42650": {"epss_score": 0.00221, "epss_percentile": 0.44681}, "CVE-2021-42651": {"epss_score": 0.02246, "epss_percentile": 0.84131}, "CVE-2021-42654": {"epss_score": 0.00946, "epss_percentile": 0.75807}, "CVE-2021-42655": {"epss_score": 0.00314, "epss_percentile": 0.54126}, "CVE-2021-42656": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2021-42659": {"epss_score": 0.00205, "epss_percentile": 0.42729}, "CVE-2021-42662": {"epss_score": 0.02229, "epss_percentile": 0.8408}, "CVE-2021-42663": {"epss_score": 0.37983, "epss_percentile": 0.9708}, "CVE-2021-42664": {"epss_score": 0.01891, "epss_percentile": 0.82728}, "CVE-2021-42665": {"epss_score": 0.05414, "epss_percentile": 0.89849}, "CVE-2021-42666": {"epss_score": 0.26817, "epss_percentile": 0.96182}, "CVE-2021-42667": {"epss_score": 0.72266, "epss_percentile": 0.98702}, "CVE-2021-42668": {"epss_score": 0.21401, "epss_percentile": 0.95513}, "CVE-2021-42669": {"epss_score": 0.44223, "epss_percentile": 0.97425}, "CVE-2021-42670": {"epss_score": 0.58031, "epss_percentile": 0.98096}, "CVE-2021-42671": {"epss_score": 0.06684, "epss_percentile": 0.90943}, "CVE-2021-42675": {"epss_score": 0.04185, "epss_percentile": 0.8836}, "CVE-2021-42681": {"epss_score": 0.00075, "epss_percentile": 0.23}, "CVE-2021-42682": {"epss_score": 0.00064, "epss_percentile": 0.20377}, "CVE-2021-42683": {"epss_score": 0.00075, "epss_percentile": 0.23}, "CVE-2021-42685": {"epss_score": 0.00064, "epss_percentile": 0.20377}, "CVE-2021-42686": {"epss_score": 0.00064, "epss_percentile": 0.20377}, "CVE-2021-42687": {"epss_score": 0.00075, "epss_percentile": 0.23}, "CVE-2021-42688": {"epss_score": 0.00064, "epss_percentile": 0.20377}, "CVE-2021-42692": {"epss_score": 0.00252, "epss_percentile": 0.48407}, "CVE-2021-42694": {"epss_score": 0.05247, "epss_percentile": 0.89662}, "CVE-2021-42697": {"epss_score": 0.75541, "epss_percentile": 0.98852}, "CVE-2021-42698": {"epss_score": 0.00126, "epss_percentile": 0.32671}, "CVE-2021-42699": {"epss_score": 0.00086, "epss_percentile": 0.25358}, "CVE-2021-42700": {"epss_score": 0.00651, "epss_percentile": 0.70296}, "CVE-2021-42701": {"epss_score": 0.0011, "epss_percentile": 0.30145}, "CVE-2021-42702": {"epss_score": 0.00651, "epss_percentile": 0.70296}, "CVE-2021-42703": {"epss_score": 0.00165, "epss_percentile": 0.38082}, "CVE-2021-42704": {"epss_score": 0.01326, "epss_percentile": 0.7948}, "CVE-2021-42705": {"epss_score": 0.00372, "epss_percentile": 0.58456}, "CVE-2021-42706": {"epss_score": 0.00051, "epss_percentile": 0.16008}, "CVE-2021-42707": {"epss_score": 0.00223, "epss_percentile": 0.44875}, "CVE-2021-42711": {"epss_score": 0.00086, "epss_percentile": 0.25279}, "CVE-2021-42712": {"epss_score": 0.00034, "epss_percentile": 0.09437}, "CVE-2021-42713": {"epss_score": 0.00034, "epss_percentile": 0.09437}, "CVE-2021-42714": {"epss_score": 0.00034, "epss_percentile": 0.09437}, "CVE-2021-42715": {"epss_score": 0.00138, "epss_percentile": 0.34518}, "CVE-2021-42716": {"epss_score": 0.00192, "epss_percentile": 0.41287}, "CVE-2021-42717": {"epss_score": 0.02045, "epss_percentile": 0.83385}, "CVE-2021-42718": {"epss_score": 0.0015, "epss_percentile": 0.36057}, "CVE-2021-42719": {"epss_score": 0.03693, "epss_percentile": 0.87579}, "CVE-2021-42720": {"epss_score": 0.08068, "epss_percentile": 0.91866}, "CVE-2021-42721": {"epss_score": 0.01819, "epss_percentile": 0.82403}, "CVE-2021-42722": {"epss_score": 0.0013, "epss_percentile": 0.33312}, "CVE-2021-42723": {"epss_score": 0.0428, "epss_percentile": 0.88489}, "CVE-2021-42724": {"epss_score": 0.05082, "epss_percentile": 0.89473}, "CVE-2021-42725": {"epss_score": 0.11306, "epss_percentile": 0.933}, "CVE-2021-42726": {"epss_score": 0.00951, "epss_percentile": 0.75867}, "CVE-2021-42727": {"epss_score": 0.07305, "epss_percentile": 0.91395}, "CVE-2021-42728": {"epss_score": 0.02603, "epss_percentile": 0.85214}, "CVE-2021-42729": {"epss_score": 0.05082, "epss_percentile": 0.89473}, "CVE-2021-42730": {"epss_score": 0.05082, "epss_percentile": 0.89473}, "CVE-2021-42731": {"epss_score": 0.00969, "epss_percentile": 0.76101}, "CVE-2021-42732": {"epss_score": 0.00916, "epss_percentile": 0.75412}, "CVE-2021-42733": {"epss_score": 0.0041, "epss_percentile": 0.6081}, "CVE-2021-42734": {"epss_score": 0.0002, "epss_percentile": 0.04441}, "CVE-2021-42735": {"epss_score": 0.01887, "epss_percentile": 0.82715}, "CVE-2021-42737": {"epss_score": 0.03807, "epss_percentile": 0.87752}, "CVE-2021-42738": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-42739": {"epss_score": 0.00038, "epss_percentile": 0.11203}, "CVE-2021-42740": {"epss_score": 0.05365, "epss_percentile": 0.89789}, "CVE-2021-42743": {"epss_score": 0.0012, "epss_percentile": 0.31739}, "CVE-2021-42744": {"epss_score": 0.00053, "epss_percentile": 0.16691}, "CVE-2021-42748": {"epss_score": 0.00157, "epss_percentile": 0.37054}, "CVE-2021-42749": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2021-42750": {"epss_score": 0.00745, "epss_percentile": 0.72516}, "CVE-2021-42751": {"epss_score": 0.00745, "epss_percentile": 0.72516}, "CVE-2021-42752": {"epss_score": 0.002, "epss_percentile": 0.42247}, "CVE-2021-42753": {"epss_score": 0.00596, "epss_percentile": 0.68712}, "CVE-2021-42754": {"epss_score": 0.00244, "epss_percentile": 0.47562}, "CVE-2021-42755": {"epss_score": 0.00101, "epss_percentile": 0.28673}, "CVE-2021-42756": {"epss_score": 0.83169, "epss_percentile": 0.99236}, "CVE-2021-42757": {"epss_score": 0.00073, "epss_percentile": 0.22605}, "CVE-2021-42758": {"epss_score": 0.00253, "epss_percentile": 0.48438}, "CVE-2021-42759": {"epss_score": 0.00114, "epss_percentile": 0.30744}, "CVE-2021-42760": {"epss_score": 0.00422, "epss_percentile": 0.61556}, "CVE-2021-42761": {"epss_score": 0.01914, "epss_percentile": 0.82846}, "CVE-2021-42762": {"epss_score": 8e-05, "epss_percentile": 0.00543}, "CVE-2021-42763": {"epss_score": 0.00173, "epss_percentile": 0.39126}, "CVE-2021-42764": {"epss_score": 0.00399, "epss_percentile": 0.60117}, "CVE-2021-42765": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-42766": {"epss_score": 0.00399, "epss_percentile": 0.60117}, "CVE-2021-42767": {"epss_score": 0.00716, "epss_percentile": 0.71857}, "CVE-2021-42770": {"epss_score": 0.01015, "epss_percentile": 0.76657}, "CVE-2021-42771": {"epss_score": 0.0013, "epss_percentile": 0.33285}, "CVE-2021-42772": {"epss_score": 0.00673, "epss_percentile": 0.70845}, "CVE-2021-42773": {"epss_score": 0.00323, "epss_percentile": 0.54899}, "CVE-2021-42774": {"epss_score": 0.00923, "epss_percentile": 0.75498}, "CVE-2021-42775": {"epss_score": 0.00469, "epss_percentile": 0.63956}, "CVE-2021-42776": {"epss_score": 0.00178, "epss_percentile": 0.39725}, "CVE-2021-42777": {"epss_score": 0.00431, "epss_percentile": 0.62044}, "CVE-2021-42778": {"epss_score": 0.00432, "epss_percentile": 0.62127}, "CVE-2021-42779": {"epss_score": 0.00063, "epss_percentile": 0.20065}, "CVE-2021-42780": {"epss_score": 0.00058, "epss_percentile": 0.18547}, "CVE-2021-42781": {"epss_score": 0.00093, "epss_percentile": 0.26625}, "CVE-2021-42782": {"epss_score": 0.00093, "epss_percentile": 0.26625}, "CVE-2021-42783": {"epss_score": 0.00664, "epss_percentile": 0.70647}, "CVE-2021-42784": {"epss_score": 0.03925, "epss_percentile": 0.87962}, "CVE-2021-42785": {"epss_score": 0.00751, "epss_percentile": 0.7264}, "CVE-2021-42786": {"epss_score": 0.01457, "epss_percentile": 0.80404}, "CVE-2021-42787": {"epss_score": 0.00302, "epss_percentile": 0.53163}, "CVE-2021-42791": {"epss_score": 0.00279, "epss_percentile": 0.50929}, "CVE-2021-42794": {"epss_score": 0.0033, "epss_percentile": 0.55432}, "CVE-2021-42796": {"epss_score": 0.00125, "epss_percentile": 0.32506}, "CVE-2021-42797": {"epss_score": 0.00216, "epss_percentile": 0.44144}, "CVE-2021-42808": {"epss_score": 0.0003, "epss_percentile": 0.08246}, "CVE-2021-42809": {"epss_score": 0.0004, "epss_percentile": 0.12001}, "CVE-2021-42810": {"epss_score": 0.00061, "epss_percentile": 0.19397}, "CVE-2021-42811": {"epss_score": 0.00234, "epss_percentile": 0.46091}, "CVE-2021-42833": {"epss_score": 0.00038, "epss_percentile": 0.11267}, "CVE-2021-42835": {"epss_score": 0.15059, "epss_percentile": 0.94352}, "CVE-2021-42836": {"epss_score": 0.00161, "epss_percentile": 0.37574}, "CVE-2021-42837": {"epss_score": 0.00476, "epss_percentile": 0.6426}, "CVE-2021-42838": {"epss_score": 0.00456, "epss_percentile": 0.6335}, "CVE-2021-42839": {"epss_score": 0.01628, "epss_percentile": 0.81436}, "CVE-2021-42840": {"epss_score": 0.47768, "epss_percentile": 0.976}, "CVE-2021-42841": {"epss_score": 0.00173, "epss_percentile": 0.39109}, "CVE-2021-42847": {"epss_score": 0.87102, "epss_percentile": 0.99415}, "CVE-2021-42848": {"epss_score": 0.00211, "epss_percentile": 0.43648}, "CVE-2021-42849": {"epss_score": 0.00119, "epss_percentile": 0.31615}, "CVE-2021-42850": {"epss_score": 0.00042, "epss_percentile": 0.12792}, "CVE-2021-42851": {"epss_score": 0.00358, "epss_percentile": 0.57482}, "CVE-2021-42852": {"epss_score": 0.00081, "epss_percentile": 0.24272}, "CVE-2021-42853": {"epss_score": 0.00633, "epss_percentile": 0.69785}, "CVE-2021-42854": {"epss_score": 0.00585, "epss_percentile": 0.68404}, "CVE-2021-42855": {"epss_score": 0.0004, "epss_percentile": 0.12024}, "CVE-2021-42856": {"epss_score": 0.00202, "epss_percentile": 0.42442}, "CVE-2021-42857": {"epss_score": 0.00456, "epss_percentile": 0.63343}, "CVE-2021-42859": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2021-42860": {"epss_score": 0.00291, "epss_percentile": 0.5217}, "CVE-2021-42863": {"epss_score": 0.00496, "epss_percentile": 0.65171}, "CVE-2021-42866": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2021-42867": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2021-42868": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2021-42869": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2021-42870": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-42872": {"epss_score": 0.11409, "epss_percentile": 0.93339}, "CVE-2021-42875": {"epss_score": 0.07583, "epss_percentile": 0.91554}, "CVE-2021-42877": {"epss_score": 0.01214, "epss_percentile": 0.78579}, "CVE-2021-42884": {"epss_score": 0.21785, "epss_percentile": 0.9556}, "CVE-2021-42885": {"epss_score": 0.09518, "epss_percentile": 0.92582}, "CVE-2021-42886": {"epss_score": 0.00964, "epss_percentile": 0.76031}, "CVE-2021-42887": {"epss_score": 0.61314, "epss_percentile": 0.98243}, "CVE-2021-42888": {"epss_score": 0.03343, "epss_percentile": 0.86948}, "CVE-2021-42889": {"epss_score": 0.00963, "epss_percentile": 0.76003}, "CVE-2021-42890": {"epss_score": 0.03343, "epss_percentile": 0.86948}, "CVE-2021-42891": {"epss_score": 0.00724, "epss_percentile": 0.72038}, "CVE-2021-42892": {"epss_score": 0.00149, "epss_percentile": 0.36004}, "CVE-2021-42893": {"epss_score": 0.00663, "epss_percentile": 0.70613}, "CVE-2021-42897": {"epss_score": 0.07063, "epss_percentile": 0.91222}, "CVE-2021-42911": {"epss_score": 0.13112, "epss_percentile": 0.93877}, "CVE-2021-42912": {"epss_score": 0.00097, "epss_percentile": 0.27508}, "CVE-2021-42913": {"epss_score": 0.00515, "epss_percentile": 0.65987}, "CVE-2021-42917": {"epss_score": 0.00222, "epss_percentile": 0.44733}, "CVE-2021-42923": {"epss_score": 0.00057, "epss_percentile": 0.17992}, "CVE-2021-42940": {"epss_score": 0.00593, "epss_percentile": 0.68641}, "CVE-2021-42943": {"epss_score": 0.00143, "epss_percentile": 0.35093}, "CVE-2021-42945": {"epss_score": 0.00441, "epss_percentile": 0.62684}, "CVE-2021-42946": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2021-42948": {"epss_score": 0.00185, "epss_percentile": 0.40524}, "CVE-2021-42949": {"epss_score": 0.36793, "epss_percentile": 0.97001}, "CVE-2021-42950": {"epss_score": 0.02852, "epss_percentile": 0.8583}, "CVE-2021-42951": {"epss_score": 0.02852, "epss_percentile": 0.8583}, "CVE-2021-42952": {"epss_score": 0.02852, "epss_percentile": 0.8583}, "CVE-2021-42954": {"epss_score": 0.0004, "epss_percentile": 0.12177}, "CVE-2021-42955": {"epss_score": 0.00075, "epss_percentile": 0.22993}, "CVE-2021-42956": {"epss_score": 0.00157, "epss_percentile": 0.37132}, "CVE-2021-42967": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2021-42969": {"epss_score": 0.05122, "epss_percentile": 0.89521}, "CVE-2021-42970": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-42972": {"epss_score": 0.00075, "epss_percentile": 0.23}, "CVE-2021-42973": {"epss_score": 0.00159, "epss_percentile": 0.37382}, "CVE-2021-42976": {"epss_score": 0.00172, "epss_percentile": 0.38963}, "CVE-2021-42977": {"epss_score": 0.00159, "epss_percentile": 0.37382}, "CVE-2021-42979": {"epss_score": 0.00159, "epss_percentile": 0.37382}, "CVE-2021-42980": {"epss_score": 0.00172, "epss_percentile": 0.38963}, "CVE-2021-42983": {"epss_score": 0.00172, "epss_percentile": 0.38963}, "CVE-2021-42986": {"epss_score": 0.00159, "epss_percentile": 0.37382}, "CVE-2021-42987": {"epss_score": 0.00064, "epss_percentile": 0.20377}, "CVE-2021-42988": {"epss_score": 0.00075, "epss_percentile": 0.23}, "CVE-2021-42990": {"epss_score": 0.00075, "epss_percentile": 0.23}, "CVE-2021-42993": {"epss_score": 0.00064, "epss_percentile": 0.20377}, "CVE-2021-42994": {"epss_score": 0.00075, "epss_percentile": 0.23}, "CVE-2021-42996": {"epss_score": 0.00064, "epss_percentile": 0.20377}, "CVE-2021-43000": {"epss_score": 0.00075, "epss_percentile": 0.23}, "CVE-2021-43002": {"epss_score": 0.00075, "epss_percentile": 0.23}, "CVE-2021-43003": {"epss_score": 0.00064, "epss_percentile": 0.20377}, "CVE-2021-43006": {"epss_score": 0.00064, "epss_percentile": 0.20377}, "CVE-2021-43008": {"epss_score": 0.8364, "epss_percentile": 0.99256}, "CVE-2021-43009": {"epss_score": 0.00224, "epss_percentile": 0.45053}, "CVE-2021-43010": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2021-43011": {"epss_score": 0.03055, "epss_percentile": 0.863}, "CVE-2021-43012": {"epss_score": 0.03055, "epss_percentile": 0.863}, "CVE-2021-43013": {"epss_score": 0.03055, "epss_percentile": 0.863}, "CVE-2021-43015": {"epss_score": 0.00687, "epss_percentile": 0.71181}, "CVE-2021-43016": {"epss_score": 0.00606, "epss_percentile": 0.69012}, "CVE-2021-43017": {"epss_score": 0.00323, "epss_percentile": 0.54888}, "CVE-2021-43018": {"epss_score": 0.00052, "epss_percentile": 0.16534}, "CVE-2021-43019": {"epss_score": 0.00542, "epss_percentile": 0.67074}, "CVE-2021-43021": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-43022": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-43023": {"epss_score": 0.02846, "epss_percentile": 0.85821}, "CVE-2021-43024": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-43025": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-43026": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-43027": {"epss_score": 0.00107, "epss_percentile": 0.29586}, "CVE-2021-43028": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-43029": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-43030": {"epss_score": 0.00447, "epss_percentile": 0.62977}, "CVE-2021-43032": {"epss_score": 0.01237, "epss_percentile": 0.78779}, "CVE-2021-43033": {"epss_score": 0.10955, "epss_percentile": 0.93175}, "CVE-2021-43034": {"epss_score": 0.00101, "epss_percentile": 0.2867}, "CVE-2021-43035": {"epss_score": 0.04026, "epss_percentile": 0.88141}, "CVE-2021-43036": {"epss_score": 0.0061, "epss_percentile": 0.6916}, "CVE-2021-43037": {"epss_score": 0.00053, "epss_percentile": 0.16999}, "CVE-2021-43038": {"epss_score": 0.02264, "epss_percentile": 0.84193}, "CVE-2021-43039": {"epss_score": 0.00289, "epss_percentile": 0.52007}, "CVE-2021-43040": {"epss_score": 0.00736, "epss_percentile": 0.72301}, "CVE-2021-43041": {"epss_score": 0.01416, "epss_percentile": 0.80143}, "CVE-2021-43042": {"epss_score": 0.02728, "epss_percentile": 0.85532}, "CVE-2021-43043": {"epss_score": 0.00391, "epss_percentile": 0.59622}, "CVE-2021-43044": {"epss_score": 0.0061, "epss_percentile": 0.6916}, "CVE-2021-43045": {"epss_score": 0.00591, "epss_percentile": 0.68602}, "CVE-2021-43046": {"epss_score": 0.00438, "epss_percentile": 0.62538}, "CVE-2021-43047": {"epss_score": 0.00288, "epss_percentile": 0.51903}, "CVE-2021-43048": {"epss_score": 0.00278, "epss_percentile": 0.50858}, "CVE-2021-43049": {"epss_score": 0.00478, "epss_percentile": 0.64386}, "CVE-2021-43050": {"epss_score": 0.00035, "epss_percentile": 0.09974}, "CVE-2021-43051": {"epss_score": 0.0022, "epss_percentile": 0.44574}, "CVE-2021-43052": {"epss_score": 0.00224, "epss_percentile": 0.44997}, "CVE-2021-43053": {"epss_score": 0.003, "epss_percentile": 0.52986}, "CVE-2021-43054": {"epss_score": 0.00159, "epss_percentile": 0.3732}, "CVE-2021-43055": {"epss_score": 0.00159, "epss_percentile": 0.3732}, "CVE-2021-43056": {"epss_score": 0.00023, "epss_percentile": 0.05653}, "CVE-2021-43057": {"epss_score": 0.00159, "epss_percentile": 0.37301}, "CVE-2021-43058": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2021-43062": {"epss_score": 0.50211, "epss_percentile": 0.97726}, "CVE-2021-43063": {"epss_score": 0.0077, "epss_percentile": 0.73001}, "CVE-2021-43064": {"epss_score": 0.00242, "epss_percentile": 0.47401}, "CVE-2021-43065": {"epss_score": 0.00148, "epss_percentile": 0.35891}, "CVE-2021-43066": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-43067": {"epss_score": 0.00395, "epss_percentile": 0.5985}, "CVE-2021-43068": {"epss_score": 0.00221, "epss_percentile": 0.44632}, "CVE-2021-43070": {"epss_score": 0.00387, "epss_percentile": 0.59297}, "CVE-2021-43071": {"epss_score": 0.00481, "epss_percentile": 0.64512}, "CVE-2021-43072": {"epss_score": 0.00049, "epss_percentile": 0.15453}, "CVE-2021-43073": {"epss_score": 0.00989, "epss_percentile": 0.76364}, "CVE-2021-43074": {"epss_score": 0.00121, "epss_percentile": 0.31833}, "CVE-2021-43075": {"epss_score": 0.016, "epss_percentile": 0.81256}, "CVE-2021-43076": {"epss_score": 0.0014, "epss_percentile": 0.34793}, "CVE-2021-43077": {"epss_score": 0.00695, "epss_percentile": 0.71375}, "CVE-2021-43080": {"epss_score": 0.0045, "epss_percentile": 0.63096}, "CVE-2021-43081": {"epss_score": 0.00917, "epss_percentile": 0.7543}, "CVE-2021-43082": {"epss_score": 0.01102, "epss_percentile": 0.77587}, "CVE-2021-43083": {"epss_score": 0.02071, "epss_percentile": 0.8348}, "CVE-2021-43084": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2021-43086": {"epss_score": 0.00385, "epss_percentile": 0.59189}, "CVE-2021-43090": {"epss_score": 0.00474, "epss_percentile": 0.64141}, "CVE-2021-43091": {"epss_score": 0.00154, "epss_percentile": 0.36654}, "CVE-2021-43094": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2021-43097": {"epss_score": 0.00276, "epss_percentile": 0.5072}, "CVE-2021-43098": {"epss_score": 0.00435, "epss_percentile": 0.62368}, "CVE-2021-43099": {"epss_score": 0.00753, "epss_percentile": 0.72676}, "CVE-2021-43100": {"epss_score": 0.00443, "epss_percentile": 0.62763}, "CVE-2021-43101": {"epss_score": 0.00443, "epss_percentile": 0.62763}, "CVE-2021-43102": {"epss_score": 0.00443, "epss_percentile": 0.62763}, "CVE-2021-43103": {"epss_score": 0.00443, "epss_percentile": 0.62763}, "CVE-2021-43105": {"epss_score": 0.00093, "epss_percentile": 0.26743}, "CVE-2021-43106": {"epss_score": 0.00238, "epss_percentile": 0.46802}, "CVE-2021-43109": {"epss_score": 0.00327, "epss_percentile": 0.55141}, "CVE-2021-43110": {"epss_score": 0.00411, "epss_percentile": 0.60881}, "CVE-2021-43113": {"epss_score": 0.02175, "epss_percentile": 0.83883}, "CVE-2021-43114": {"epss_score": 0.00566, "epss_percentile": 0.67813}, "CVE-2021-43116": {"epss_score": 0.12517, "epss_percentile": 0.93703}, "CVE-2021-43117": {"epss_score": 0.00708, "epss_percentile": 0.71671}, "CVE-2021-43118": {"epss_score": 0.46146, "epss_percentile": 0.97533}, "CVE-2021-43129": {"epss_score": 0.0485, "epss_percentile": 0.89215}, "CVE-2021-43130": {"epss_score": 0.00329, "epss_percentile": 0.55301}, "CVE-2021-43136": {"epss_score": 0.1324, "epss_percentile": 0.93909}, "CVE-2021-43137": {"epss_score": 0.00135, "epss_percentile": 0.33997}, "CVE-2021-43138": {"epss_score": 0.00706, "epss_percentile": 0.71607}, "CVE-2021-43140": {"epss_score": 0.00741, "epss_percentile": 0.72437}, "CVE-2021-43141": {"epss_score": 0.00569, "epss_percentile": 0.67931}, "CVE-2021-43142": {"epss_score": 0.00313, "epss_percentile": 0.54021}, "CVE-2021-43145": {"epss_score": 0.00379, "epss_percentile": 0.5884}, "CVE-2021-43154": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2021-43155": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2021-43156": {"epss_score": 0.00138, "epss_percentile": 0.34518}, "CVE-2021-43157": {"epss_score": 0.00286, "epss_percentile": 0.51719}, "CVE-2021-43158": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2021-43159": {"epss_score": 0.02542, "epss_percentile": 0.85055}, "CVE-2021-43160": {"epss_score": 0.02542, "epss_percentile": 0.85055}, "CVE-2021-43161": {"epss_score": 0.02542, "epss_percentile": 0.85055}, "CVE-2021-43162": {"epss_score": 0.02542, "epss_percentile": 0.85055}, "CVE-2021-43163": {"epss_score": 0.02845, "epss_percentile": 0.8582}, "CVE-2021-43164": {"epss_score": 0.26281, "epss_percentile": 0.96135}, "CVE-2021-43171": {"epss_score": 0.00051, "epss_percentile": 0.16321}, "CVE-2021-43172": {"epss_score": 0.0054, "epss_percentile": 0.66997}, "CVE-2021-43173": {"epss_score": 0.00436, "epss_percentile": 0.62484}, "CVE-2021-43174": {"epss_score": 0.00719, "epss_percentile": 0.71949}, "CVE-2021-43175": {"epss_score": 0.00361, "epss_percentile": 0.57697}, "CVE-2021-43176": {"epss_score": 0.00616, "epss_percentile": 0.69322}, "CVE-2021-43177": {"epss_score": 0.00295, "epss_percentile": 0.52507}, "CVE-2021-43180": {"epss_score": 4e-05, "epss_percentile": 0.00155}, "CVE-2021-43181": {"epss_score": 7e-05, "epss_percentile": 0.00347}, "CVE-2021-43182": {"epss_score": 5e-05, "epss_percentile": 0.00182}, "CVE-2021-43183": {"epss_score": 5e-05, "epss_percentile": 0.00208}, "CVE-2021-43184": {"epss_score": 7e-05, "epss_percentile": 0.00438}, "CVE-2021-43185": {"epss_score": 5e-05, "epss_percentile": 0.00185}, "CVE-2021-43186": {"epss_score": 6e-05, "epss_percentile": 0.00307}, "CVE-2021-43187": {"epss_score": 5e-05, "epss_percentile": 0.0018}, "CVE-2021-43188": {"epss_score": 6e-05, "epss_percentile": 0.00245}, "CVE-2021-43189": {"epss_score": 6e-05, "epss_percentile": 0.00245}, "CVE-2021-43190": {"epss_score": 4e-05, "epss_percentile": 0.00167}, "CVE-2021-43191": {"epss_score": 4e-05, "epss_percentile": 0.00167}, "CVE-2021-43192": {"epss_score": 4e-05, "epss_percentile": 0.00167}, "CVE-2021-43193": {"epss_score": 0.00019, "epss_percentile": 0.04195}, "CVE-2021-43194": {"epss_score": 5e-05, "epss_percentile": 0.00186}, "CVE-2021-43195": {"epss_score": 5e-05, "epss_percentile": 0.00186}, "CVE-2021-43196": {"epss_score": 4e-05, "epss_percentile": 0.00157}, "CVE-2021-43197": {"epss_score": 7e-05, "epss_percentile": 0.00443}, "CVE-2021-43198": {"epss_score": 0.00011, "epss_percentile": 0.00985}, "CVE-2021-43199": {"epss_score": 4e-05, "epss_percentile": 0.00149}, "CVE-2021-43200": {"epss_score": 5e-05, "epss_percentile": 0.00211}, "CVE-2021-43201": {"epss_score": 4e-05, "epss_percentile": 0.00171}, "CVE-2021-43202": {"epss_score": 5e-05, "epss_percentile": 0.00211}, "CVE-2021-43203": {"epss_score": 3e-05, "epss_percentile": 0.00061}, "CVE-2021-43204": {"epss_score": 0.00045, "epss_percentile": 0.13934}, "CVE-2021-43205": {"epss_score": 0.00597, "epss_percentile": 0.68752}, "CVE-2021-43206": {"epss_score": 0.00391, "epss_percentile": 0.59566}, "CVE-2021-43207": {"epss_score": 0.00433, "epss_percentile": 0.62185}, "CVE-2021-43208": {"epss_score": 0.01154, "epss_percentile": 0.78066}, "CVE-2021-43209": {"epss_score": 0.04097, "epss_percentile": 0.88251}, "CVE-2021-43211": {"epss_score": 0.00552, "epss_percentile": 0.67394}, "CVE-2021-43214": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2021-43215": {"epss_score": 0.03413, "epss_percentile": 0.87089}, "CVE-2021-43216": {"epss_score": 0.18233, "epss_percentile": 0.94978}, "CVE-2021-43217": {"epss_score": 0.23665, "epss_percentile": 0.958}, "CVE-2021-43219": {"epss_score": 0.01976, "epss_percentile": 0.8312}, "CVE-2021-43220": {"epss_score": 0.01717, "epss_percentile": 0.81917}, "CVE-2021-43221": {"epss_score": 0.00848, "epss_percentile": 0.74368}, "CVE-2021-43222": {"epss_score": 0.14127, "epss_percentile": 0.9414}, "CVE-2021-43223": {"epss_score": 0.00262, "epss_percentile": 0.49397}, "CVE-2021-43224": {"epss_score": 0.14869, "epss_percentile": 0.94305}, "CVE-2021-43225": {"epss_score": 0.01659, "epss_percentile": 0.81614}, "CVE-2021-43226": {"epss_score": 0.11526, "epss_percentile": 0.93393}, "CVE-2021-43227": {"epss_score": 0.00542, "epss_percentile": 0.6708}, "CVE-2021-43228": {"epss_score": 0.11792, "epss_percentile": 0.93477}, "CVE-2021-43229": {"epss_score": 0.11892, "epss_percentile": 0.93508}, "CVE-2021-43230": {"epss_score": 0.00734, "epss_percentile": 0.72241}, "CVE-2021-43231": {"epss_score": 0.00514, "epss_percentile": 0.65957}, "CVE-2021-43232": {"epss_score": 0.01655, "epss_percentile": 0.81589}, "CVE-2021-43233": {"epss_score": 0.01984, "epss_percentile": 0.83152}, "CVE-2021-43234": {"epss_score": 0.00817, "epss_percentile": 0.73837}, "CVE-2021-43235": {"epss_score": 0.00442, "epss_percentile": 0.62753}, "CVE-2021-43236": {"epss_score": 0.14127, "epss_percentile": 0.9414}, "CVE-2021-43237": {"epss_score": 0.00719, "epss_percentile": 0.71951}, "CVE-2021-43238": {"epss_score": 0.0042, "epss_percentile": 0.61405}, "CVE-2021-43239": {"epss_score": 0.00214, "epss_percentile": 0.43961}, "CVE-2021-43240": {"epss_score": 0.00502, "epss_percentile": 0.6539}, "CVE-2021-43242": {"epss_score": 0.01031, "epss_percentile": 0.76851}, "CVE-2021-43243": {"epss_score": 0.00398, "epss_percentile": 0.6008}, "CVE-2021-43244": {"epss_score": 0.00443, "epss_percentile": 0.62756}, "CVE-2021-43245": {"epss_score": 0.00192, "epss_percentile": 0.4128}, "CVE-2021-43246": {"epss_score": 0.00216, "epss_percentile": 0.44236}, "CVE-2021-43247": {"epss_score": 0.00702, "epss_percentile": 0.71516}, "CVE-2021-43248": {"epss_score": 0.00262, "epss_percentile": 0.49397}, "CVE-2021-43255": {"epss_score": 0.01096, "epss_percentile": 0.77519}, "CVE-2021-43256": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2021-43257": {"epss_score": 0.01198, "epss_percentile": 0.78453}, "CVE-2021-43258": {"epss_score": 0.78389, "epss_percentile": 0.98985}, "CVE-2021-43264": {"epss_score": 0.00093, "epss_percentile": 0.26706}, "CVE-2021-43265": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-43266": {"epss_score": 0.00501, "epss_percentile": 0.65367}, "CVE-2021-43267": {"epss_score": 0.72624, "epss_percentile": 0.98719}, "CVE-2021-43268": {"epss_score": 0.00142, "epss_percentile": 0.35014}, "CVE-2021-43269": {"epss_score": 0.00774, "epss_percentile": 0.73066}, "CVE-2021-43270": {"epss_score": 0.00079, "epss_percentile": 0.23981}, "CVE-2021-43271": {"epss_score": 0.00257, "epss_percentile": 0.48923}, "CVE-2021-43272": {"epss_score": 0.00729, "epss_percentile": 0.72118}, "CVE-2021-43273": {"epss_score": 0.00308, "epss_percentile": 0.53627}, "CVE-2021-43274": {"epss_score": 0.00404, "epss_percentile": 0.60413}, "CVE-2021-43275": {"epss_score": 0.00404, "epss_percentile": 0.60413}, "CVE-2021-43276": {"epss_score": 0.00414, "epss_percentile": 0.61019}, "CVE-2021-43277": {"epss_score": 0.0044, "epss_percentile": 0.62641}, "CVE-2021-43278": {"epss_score": 0.00414, "epss_percentile": 0.61019}, "CVE-2021-43279": {"epss_score": 0.00307, "epss_percentile": 0.53504}, "CVE-2021-43280": {"epss_score": 0.01398, "epss_percentile": 0.79987}, "CVE-2021-43281": {"epss_score": 0.00871, "epss_percentile": 0.74711}, "CVE-2021-43282": {"epss_score": 0.00175, "epss_percentile": 0.39267}, "CVE-2021-43283": {"epss_score": 0.03876, "epss_percentile": 0.87889}, "CVE-2021-43284": {"epss_score": 0.00122, "epss_percentile": 0.32051}, "CVE-2021-43286": {"epss_score": 0.02408, "epss_percentile": 0.84658}, "CVE-2021-43287": {"epss_score": 0.91307, "epss_percentile": 0.99633}, "CVE-2021-43288": {"epss_score": 0.01229, "epss_percentile": 0.78713}, "CVE-2021-43289": {"epss_score": 0.01559, "epss_percentile": 0.81035}, "CVE-2021-43290": {"epss_score": 0.04226, "epss_percentile": 0.88416}, "CVE-2021-43293": {"epss_score": 0.00237, "epss_percentile": 0.46708}, "CVE-2021-43294": {"epss_score": 0.05065, "epss_percentile": 0.89457}, "CVE-2021-43295": {"epss_score": 0.05065, "epss_percentile": 0.89457}, "CVE-2021-43296": {"epss_score": 0.0755, "epss_percentile": 0.91534}, "CVE-2021-43297": {"epss_score": 0.42301, "epss_percentile": 0.97324}, "CVE-2021-43298": {"epss_score": 0.00378, "epss_percentile": 0.58798}, "CVE-2021-43299": {"epss_score": 0.00289, "epss_percentile": 0.52076}, "CVE-2021-43300": {"epss_score": 0.00328, "epss_percentile": 0.55261}, "CVE-2021-43301": {"epss_score": 0.00328, "epss_percentile": 0.55261}, "CVE-2021-43302": {"epss_score": 0.00246, "epss_percentile": 0.47767}, "CVE-2021-43303": {"epss_score": 0.00328, "epss_percentile": 0.55261}, "CVE-2021-43304": {"epss_score": 0.0015, "epss_percentile": 0.36078}, "CVE-2021-43305": {"epss_score": 0.00281, "epss_percentile": 0.51187}, "CVE-2021-43306": {"epss_score": 0.00844, "epss_percentile": 0.74271}, "CVE-2021-43307": {"epss_score": 0.00465, "epss_percentile": 0.63759}, "CVE-2021-43308": {"epss_score": 0.00278, "epss_percentile": 0.50891}, "CVE-2021-43309": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2021-43310": {"epss_score": 0.02758, "epss_percentile": 0.85594}, "CVE-2021-43311": {"epss_score": 0.00125, "epss_percentile": 0.32581}, "CVE-2021-43312": {"epss_score": 0.00125, "epss_percentile": 0.32581}, "CVE-2021-43313": {"epss_score": 0.00125, "epss_percentile": 0.32581}, "CVE-2021-43314": {"epss_score": 0.00125, "epss_percentile": 0.32581}, "CVE-2021-43315": {"epss_score": 0.00125, "epss_percentile": 0.32581}, "CVE-2021-43316": {"epss_score": 0.00125, "epss_percentile": 0.32581}, "CVE-2021-43317": {"epss_score": 0.00125, "epss_percentile": 0.32581}, "CVE-2021-43319": {"epss_score": 0.73762, "epss_percentile": 0.98771}, "CVE-2021-43323": {"epss_score": 0.00048, "epss_percentile": 0.14992}, "CVE-2021-43324": {"epss_score": 3e-05, "epss_percentile": 0.001}, "CVE-2021-43325": {"epss_score": 0.00028, "epss_percentile": 0.07505}, "CVE-2021-43326": {"epss_score": 0.01538, "epss_percentile": 0.80932}, "CVE-2021-43327": {"epss_score": 0.00138, "epss_percentile": 0.3443}, "CVE-2021-43329": {"epss_score": 0.08165, "epss_percentile": 0.91912}, "CVE-2021-43331": {"epss_score": 0.00153, "epss_percentile": 0.36573}, "CVE-2021-43332": {"epss_score": 0.00122, "epss_percentile": 0.32133}, "CVE-2021-43333": {"epss_score": 0.00167, "epss_percentile": 0.38387}, "CVE-2021-43334": {"epss_score": 0.00473, "epss_percentile": 0.64074}, "CVE-2021-43336": {"epss_score": 0.00363, "epss_percentile": 0.57831}, "CVE-2021-43337": {"epss_score": 0.00531, "epss_percentile": 0.66671}, "CVE-2021-43339": {"epss_score": 0.12677, "epss_percentile": 0.93746}, "CVE-2021-43350": {"epss_score": 0.01299, "epss_percentile": 0.79282}, "CVE-2021-43353": {"epss_score": 0.00092, "epss_percentile": 0.2644}, "CVE-2021-43355": {"epss_score": 0.00224, "epss_percentile": 0.45008}, "CVE-2021-43358": {"epss_score": 0.00471, "epss_percentile": 0.64019}, "CVE-2021-43359": {"epss_score": 0.00638, "epss_percentile": 0.69906}, "CVE-2021-43360": {"epss_score": 0.00643, "epss_percentile": 0.70064}, "CVE-2021-43361": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2021-43362": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2021-43388": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2021-43389": {"epss_score": 0.00011, "epss_percentile": 0.01105}, "CVE-2021-43390": {"epss_score": 0.00313, "epss_percentile": 0.54031}, "CVE-2021-43391": {"epss_score": 0.00592, "epss_percentile": 0.68624}, "CVE-2021-43392": {"epss_score": 0.0003, "epss_percentile": 0.08025}, "CVE-2021-43393": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2021-43394": {"epss_score": 0.00392, "epss_percentile": 0.59657}, "CVE-2021-43395": {"epss_score": 0.00062, "epss_percentile": 0.19633}, "CVE-2021-43396": {"epss_score": 0.00504, "epss_percentile": 0.65494}, "CVE-2021-43397": {"epss_score": 0.18315, "epss_percentile": 0.94993}, "CVE-2021-43398": {"epss_score": 0.00502, "epss_percentile": 0.65375}, "CVE-2021-43399": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2021-43400": {"epss_score": 0.00172, "epss_percentile": 0.3901}, "CVE-2021-43403": {"epss_score": 0.00351, "epss_percentile": 0.5701}, "CVE-2021-43404": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2021-43405": {"epss_score": 0.05243, "epss_percentile": 0.89653}, "CVE-2021-43406": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2021-43408": {"epss_score": 0.31278, "epss_percentile": 0.96605}, "CVE-2021-43409": {"epss_score": 0.00587, "epss_percentile": 0.68478}, "CVE-2021-43410": {"epss_score": 0.03878, "epss_percentile": 0.87893}, "CVE-2021-43411": {"epss_score": 0.00454, "epss_percentile": 0.63244}, "CVE-2021-43412": {"epss_score": 0.00044, "epss_percentile": 0.13522}, "CVE-2021-43413": {"epss_score": 0.01063, "epss_percentile": 0.77189}, "CVE-2021-43414": {"epss_score": 0.00028, "epss_percentile": 0.07441}, "CVE-2021-43415": {"epss_score": 0.00305, "epss_percentile": 0.53366}, "CVE-2021-43419": {"epss_score": 0.00194, "epss_percentile": 0.41544}, "CVE-2021-43420": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-43421": {"epss_score": 0.7657, "epss_percentile": 0.98896}, "CVE-2021-43429": {"epss_score": 0.00217, "epss_percentile": 0.44255}, "CVE-2021-43430": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2021-43432": {"epss_score": 0.00308, "epss_percentile": 0.53636}, "CVE-2021-43436": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-43437": {"epss_score": 0.00444, "epss_percentile": 0.62819}, "CVE-2021-43438": {"epss_score": 0.00149, "epss_percentile": 0.35959}, "CVE-2021-43439": {"epss_score": 0.02989, "epss_percentile": 0.86141}, "CVE-2021-43440": {"epss_score": 0.00547, "epss_percentile": 0.67263}, "CVE-2021-43441": {"epss_score": 0.00296, "epss_percentile": 0.52576}, "CVE-2021-43442": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-43444": {"epss_score": 0.01693, "epss_percentile": 0.81796}, "CVE-2021-43445": {"epss_score": 0.01526, "epss_percentile": 0.80863}, "CVE-2021-43446": {"epss_score": 0.05836, "epss_percentile": 0.90248}, "CVE-2021-43447": {"epss_score": 0.00266, "epss_percentile": 0.499}, "CVE-2021-43448": {"epss_score": 0.00318, "epss_percentile": 0.54429}, "CVE-2021-43449": {"epss_score": 0.01281, "epss_percentile": 0.79146}, "CVE-2021-43451": {"epss_score": 0.01466, "epss_percentile": 0.80462}, "CVE-2021-43453": {"epss_score": 0.00385, "epss_percentile": 0.59191}, "CVE-2021-43454": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2021-43455": {"epss_score": 0.00132, "epss_percentile": 0.33615}, "CVE-2021-43456": {"epss_score": 0.00095, "epss_percentile": 0.27079}, "CVE-2021-43457": {"epss_score": 0.00079, "epss_percentile": 0.23865}, "CVE-2021-43458": {"epss_score": 0.00079, "epss_percentile": 0.23865}, "CVE-2021-43459": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2021-43460": {"epss_score": 0.00104, "epss_percentile": 0.29207}, "CVE-2021-43461": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2021-43462": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2021-43463": {"epss_score": 0.00104, "epss_percentile": 0.29207}, "CVE-2021-43464": {"epss_score": 0.00782, "epss_percentile": 0.73198}, "CVE-2021-43466": {"epss_score": 0.04592, "epss_percentile": 0.88893}, "CVE-2021-43469": {"epss_score": 0.09404, "epss_percentile": 0.92533}, "CVE-2021-43471": {"epss_score": 0.0029, "epss_percentile": 0.52119}, "CVE-2021-43474": {"epss_score": 0.03371, "epss_percentile": 0.87012}, "CVE-2021-43478": {"epss_score": 0.00272, "epss_percentile": 0.50413}, "CVE-2021-43479": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2021-43481": {"epss_score": 0.00567, "epss_percentile": 0.67836}, "CVE-2021-43483": {"epss_score": 0.00095, "epss_percentile": 0.27111}, "CVE-2021-43484": {"epss_score": 0.12708, "epss_percentile": 0.93754}, "CVE-2021-43492": {"epss_score": 0.01423, "epss_percentile": 0.80188}, "CVE-2021-43493": {"epss_score": 0.00753, "epss_percentile": 0.72674}, "CVE-2021-43494": {"epss_score": 0.00674, "epss_percentile": 0.70859}, "CVE-2021-43495": {"epss_score": 0.54584, "epss_percentile": 0.97934}, "CVE-2021-43496": {"epss_score": 0.40172, "epss_percentile": 0.97204}, "CVE-2021-43498": {"epss_score": 0.00833, "epss_percentile": 0.74078}, "CVE-2021-43505": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-43506": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2021-43509": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2021-43510": {"epss_score": 0.67767, "epss_percentile": 0.9852}, "CVE-2021-43512": {"epss_score": 0.00068, "epss_percentile": 0.21425}, "CVE-2021-43515": {"epss_score": 0.00502, "epss_percentile": 0.6541}, "CVE-2021-43517": {"epss_score": 0.00386, "epss_percentile": 0.59238}, "CVE-2021-43518": {"epss_score": 0.00378, "epss_percentile": 0.58824}, "CVE-2021-43519": {"epss_score": 0.00068, "epss_percentile": 0.21221}, "CVE-2021-43521": {"epss_score": 0.00297, "epss_percentile": 0.52695}, "CVE-2021-43522": {"epss_score": 0.00066, "epss_percentile": 0.20947}, "CVE-2021-43523": {"epss_score": 0.02885, "epss_percentile": 0.85911}, "CVE-2021-43527": {"epss_score": 0.05243, "epss_percentile": 0.89654}, "CVE-2021-43528": {"epss_score": 0.0086, "epss_percentile": 0.74544}, "CVE-2021-43529": {"epss_score": 0.00101, "epss_percentile": 0.28698}, "CVE-2021-43530": {"epss_score": 0.07071, "epss_percentile": 0.91229}, "CVE-2021-43531": {"epss_score": 0.00138, "epss_percentile": 0.34395}, "CVE-2021-43532": {"epss_score": 0.00226, "epss_percentile": 0.45281}, "CVE-2021-43533": {"epss_score": 0.00284, "epss_percentile": 0.51463}, "CVE-2021-43534": {"epss_score": 0.00756, "epss_percentile": 0.7274}, "CVE-2021-43535": {"epss_score": 0.0163, "epss_percentile": 0.81443}, "CVE-2021-43536": {"epss_score": 0.00479, "epss_percentile": 0.64439}, "CVE-2021-43537": {"epss_score": 0.00533, "epss_percentile": 0.66773}, "CVE-2021-43538": {"epss_score": 0.0025, "epss_percentile": 0.48123}, "CVE-2021-43539": {"epss_score": 0.00836, "epss_percentile": 0.74138}, "CVE-2021-43540": {"epss_score": 0.00316, "epss_percentile": 0.54283}, "CVE-2021-43541": {"epss_score": 0.00307, "epss_percentile": 0.53532}, "CVE-2021-43542": {"epss_score": 0.00626, "epss_percentile": 0.69608}, "CVE-2021-43543": {"epss_score": 0.00582, "epss_percentile": 0.68305}, "CVE-2021-43544": {"epss_score": 0.0038, "epss_percentile": 0.58926}, "CVE-2021-43545": {"epss_score": 0.00609, "epss_percentile": 0.69136}, "CVE-2021-43546": {"epss_score": 0.00354, "epss_percentile": 0.57215}, "CVE-2021-43547": {"epss_score": 0.00092, "epss_percentile": 0.26569}, "CVE-2021-43548": {"epss_score": 0.00112, "epss_percentile": 0.30571}, "CVE-2021-43549": {"epss_score": 0.00135, "epss_percentile": 0.34054}, "CVE-2021-43550": {"epss_score": 0.00041, "epss_percentile": 0.12251}, "CVE-2021-43551": {"epss_score": 0.00101, "epss_percentile": 0.28638}, "CVE-2021-43552": {"epss_score": 0.00068, "epss_percentile": 0.21292}, "CVE-2021-43553": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2021-43554": {"epss_score": 0.00316, "epss_percentile": 0.54289}, "CVE-2021-43555": {"epss_score": 0.01854, "epss_percentile": 0.82555}, "CVE-2021-43556": {"epss_score": 0.00609, "epss_percentile": 0.69127}, "CVE-2021-43557": {"epss_score": 0.58257, "epss_percentile": 0.98104}, "CVE-2021-43558": {"epss_score": 0.00451, "epss_percentile": 0.63119}, "CVE-2021-43559": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2021-43560": {"epss_score": 0.00308, "epss_percentile": 0.53639}, "CVE-2021-43561": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-43562": {"epss_score": 0.01468, "epss_percentile": 0.80476}, "CVE-2021-43563": {"epss_score": 0.0084, "epss_percentile": 0.74209}, "CVE-2021-43564": {"epss_score": 0.01398, "epss_percentile": 0.79992}, "CVE-2021-43565": {"epss_score": 0.00022, "epss_percentile": 0.05258}, "CVE-2021-43566": {"epss_score": 0.00158, "epss_percentile": 0.37159}, "CVE-2021-43568": {"epss_score": 0.00203, "epss_percentile": 0.42502}, "CVE-2021-43569": {"epss_score": 0.00222, "epss_percentile": 0.44715}, "CVE-2021-43570": {"epss_score": 0.00222, "epss_percentile": 0.44715}, "CVE-2021-43571": {"epss_score": 0.00222, "epss_percentile": 0.44715}, "CVE-2021-43572": {"epss_score": 0.00241, "epss_percentile": 0.47266}, "CVE-2021-43573": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2021-43574": {"epss_score": 0.2705, "epss_percentile": 0.96201}, "CVE-2021-43575": {"epss_score": 0.00046, "epss_percentile": 0.14397}, "CVE-2021-43576": {"epss_score": 0.00275, "epss_percentile": 0.50669}, "CVE-2021-43577": {"epss_score": 0.00121, "epss_percentile": 0.3184}, "CVE-2021-43578": {"epss_score": 0.00125, "epss_percentile": 0.32514}, "CVE-2021-43579": {"epss_score": 0.04961, "epss_percentile": 0.89334}, "CVE-2021-43581": {"epss_score": 0.00511, "epss_percentile": 0.65839}, "CVE-2021-43582": {"epss_score": 0.00344, "epss_percentile": 0.56528}, "CVE-2021-43584": {"epss_score": 0.00338, "epss_percentile": 0.56146}, "CVE-2021-43587": {"epss_score": 0.00034, "epss_percentile": 0.09633}, "CVE-2021-43588": {"epss_score": 0.00281, "epss_percentile": 0.51146}, "CVE-2021-43589": {"epss_score": 0.0006, "epss_percentile": 0.1899}, "CVE-2021-43590": {"epss_score": 0.0002, "epss_percentile": 0.04661}, "CVE-2021-43608": {"epss_score": 0.01352, "epss_percentile": 0.79692}, "CVE-2021-43609": {"epss_score": 0.03654, "epss_percentile": 0.87511}, "CVE-2021-43610": {"epss_score": 0.00363, "epss_percentile": 0.57893}, "CVE-2021-43611": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-43612": {"epss_score": 0.00124, "epss_percentile": 0.32429}, "CVE-2021-43615": {"epss_score": 0.00194, "epss_percentile": 0.41518}, "CVE-2021-43616": {"epss_score": 0.02417, "epss_percentile": 0.84694}, "CVE-2021-43617": {"epss_score": 0.52774, "epss_percentile": 0.9784}, "CVE-2021-43618": {"epss_score": 0.00499, "epss_percentile": 0.65287}, "CVE-2021-43619": {"epss_score": 0.00172, "epss_percentile": 0.38928}, "CVE-2021-43620": {"epss_score": 0.00307, "epss_percentile": 0.53565}, "CVE-2021-43628": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2021-43629": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2021-43630": {"epss_score": 0.01417, "epss_percentile": 0.80144}, "CVE-2021-43631": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2021-43633": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-43635": {"epss_score": 0.01302, "epss_percentile": 0.79303}, "CVE-2021-43636": {"epss_score": 0.00397, "epss_percentile": 0.60038}, "CVE-2021-43637": {"epss_score": 0.00075, "epss_percentile": 0.23}, "CVE-2021-43638": {"epss_score": 0.00136, "epss_percentile": 0.3416}, "CVE-2021-43650": {"epss_score": 0.01032, "epss_percentile": 0.76864}, "CVE-2021-43657": {"epss_score": 0.00254, "epss_percentile": 0.48538}, "CVE-2021-43659": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-43661": {"epss_score": 0.00212, "epss_percentile": 0.43787}, "CVE-2021-43662": {"epss_score": 0.00084, "epss_percentile": 0.24927}, "CVE-2021-43663": {"epss_score": 0.00814, "epss_percentile": 0.73772}, "CVE-2021-43664": {"epss_score": 0.04297, "epss_percentile": 0.8851}, "CVE-2021-43666": {"epss_score": 0.00182, "epss_percentile": 0.40243}, "CVE-2021-43667": {"epss_score": 0.00545, "epss_percentile": 0.67187}, "CVE-2021-43668": {"epss_score": 0.00057, "epss_percentile": 0.17971}, "CVE-2021-43669": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2021-43673": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-43674": {"epss_score": 0.00457, "epss_percentile": 0.63382}, "CVE-2021-43675": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2021-43676": {"epss_score": 0.00587, "epss_percentile": 0.68472}, "CVE-2021-43677": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2021-43678": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-43679": {"epss_score": 0.01107, "epss_percentile": 0.77628}, "CVE-2021-43681": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-43682": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-43683": {"epss_score": 0.00247, "epss_percentile": 0.47906}, "CVE-2021-43685": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-43686": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-43687": {"epss_score": 0.01067, "epss_percentile": 0.77224}, "CVE-2021-43689": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-43690": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-43691": {"epss_score": 0.00491, "epss_percentile": 0.6498}, "CVE-2021-43692": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-43693": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2021-43695": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-43696": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-43697": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-43698": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-43700": {"epss_score": 0.0028, "epss_percentile": 0.51084}, "CVE-2021-43701": {"epss_score": 0.00109, "epss_percentile": 0.30072}, "CVE-2021-43702": {"epss_score": 0.0052, "epss_percentile": 0.66199}, "CVE-2021-43703": {"epss_score": 0.00862, "epss_percentile": 0.74573}, "CVE-2021-43707": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-43708": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2021-43711": {"epss_score": 0.19992, "epss_percentile": 0.95272}, "CVE-2021-43712": {"epss_score": 0.00187, "epss_percentile": 0.40731}, "CVE-2021-43721": {"epss_score": 0.00428, "epss_percentile": 0.61947}, "CVE-2021-43722": {"epss_score": 0.01359, "epss_percentile": 0.79736}, "CVE-2021-43724": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2021-43725": {"epss_score": 0.01081, "epss_percentile": 0.77375}, "CVE-2021-43728": {"epss_score": 0.0037, "epss_percentile": 0.58321}, "CVE-2021-43729": {"epss_score": 0.0037, "epss_percentile": 0.58321}, "CVE-2021-43734": {"epss_score": 0.75482, "epss_percentile": 0.98848}, "CVE-2021-43735": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2021-43736": {"epss_score": 0.02903, "epss_percentile": 0.85957}, "CVE-2021-43737": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2021-43738": {"epss_score": 0.00118, "epss_percentile": 0.31461}, "CVE-2021-43741": {"epss_score": 0.11364, "epss_percentile": 0.93324}, "CVE-2021-43742": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-43745": {"epss_score": 0.00045, "epss_percentile": 0.13902}, "CVE-2021-43746": {"epss_score": 0.0077, "epss_percentile": 0.72999}, "CVE-2021-43747": {"epss_score": 0.01803, "epss_percentile": 0.82341}, "CVE-2021-43748": {"epss_score": 0.00662, "epss_percentile": 0.70603}, "CVE-2021-43749": {"epss_score": 0.00662, "epss_percentile": 0.70603}, "CVE-2021-43750": {"epss_score": 0.00662, "epss_percentile": 0.70603}, "CVE-2021-43751": {"epss_score": 0.00034, "epss_percentile": 0.09652}, "CVE-2021-43752": {"epss_score": 0.02372, "epss_percentile": 0.84529}, "CVE-2021-43753": {"epss_score": 0.00098, "epss_percentile": 0.27699}, "CVE-2021-43754": {"epss_score": 0.01147, "epss_percentile": 0.78004}, "CVE-2021-43755": {"epss_score": 0.01566, "epss_percentile": 0.81069}, "CVE-2021-43756": {"epss_score": 0.01397, "epss_percentile": 0.79985}, "CVE-2021-43757": {"epss_score": 0.00025, "epss_percentile": 0.06332}, "CVE-2021-43758": {"epss_score": 0.00031, "epss_percentile": 0.0862}, "CVE-2021-43759": {"epss_score": 0.00031, "epss_percentile": 0.0862}, "CVE-2021-43760": {"epss_score": 0.00031, "epss_percentile": 0.0862}, "CVE-2021-43761": {"epss_score": 0.03253, "epss_percentile": 0.86756}, "CVE-2021-43762": {"epss_score": 0.02343, "epss_percentile": 0.84441}, "CVE-2021-43763": {"epss_score": 0.02356, "epss_percentile": 0.84482}, "CVE-2021-43764": {"epss_score": 0.03253, "epss_percentile": 0.86756}, "CVE-2021-43765": {"epss_score": 0.07001, "epss_percentile": 0.91174}, "CVE-2021-43766": {"epss_score": 0.00142, "epss_percentile": 0.34983}, "CVE-2021-43767": {"epss_score": 0.00195, "epss_percentile": 0.4169}, "CVE-2021-43768": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2021-43771": {"epss_score": 0.00078, "epss_percentile": 0.23766}, "CVE-2021-43772": {"epss_score": 0.00083, "epss_percentile": 0.24742}, "CVE-2021-43774": {"epss_score": 0.00183, "epss_percentile": 0.40302}, "CVE-2021-43775": {"epss_score": 0.00447, "epss_percentile": 0.62972}, "CVE-2021-43776": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2021-43777": {"epss_score": 0.00102, "epss_percentile": 0.28871}, "CVE-2021-43778": {"epss_score": 0.87845, "epss_percentile": 0.99446}, "CVE-2021-43779": {"epss_score": 0.03413, "epss_percentile": 0.87088}, "CVE-2021-43780": {"epss_score": 0.00226, "epss_percentile": 0.4525}, "CVE-2021-43781": {"epss_score": 0.00144, "epss_percentile": 0.35252}, "CVE-2021-43782": {"epss_score": 0.00807, "epss_percentile": 0.73677}, "CVE-2021-43783": {"epss_score": 0.00353, "epss_percentile": 0.572}, "CVE-2021-43784": {"epss_score": 0.00131, "epss_percentile": 0.33353}, "CVE-2021-43785": {"epss_score": 0.00398, "epss_percentile": 0.6007}, "CVE-2021-43786": {"epss_score": 0.00475, "epss_percentile": 0.64171}, "CVE-2021-43787": {"epss_score": 0.0041, "epss_percentile": 0.60792}, "CVE-2021-43788": {"epss_score": 0.0252, "epss_percentile": 0.84998}, "CVE-2021-43789": {"epss_score": 0.13034, "epss_percentile": 0.93851}, "CVE-2021-43790": {"epss_score": 0.00502, "epss_percentile": 0.65398}, "CVE-2021-43791": {"epss_score": 0.00189, "epss_percentile": 0.40957}, "CVE-2021-43792": {"epss_score": 0.00265, "epss_percentile": 0.49791}, "CVE-2021-43793": {"epss_score": 0.00234, "epss_percentile": 0.46102}, "CVE-2021-43794": {"epss_score": 0.00379, "epss_percentile": 0.58888}, "CVE-2021-43795": {"epss_score": 0.00754, "epss_percentile": 0.72696}, "CVE-2021-43797": {"epss_score": 0.00325, "epss_percentile": 0.55005}, "CVE-2021-43798": {"epss_score": 0.94438, "epss_percentile": 0.99986}, "CVE-2021-43799": {"epss_score": 0.05271, "epss_percentile": 0.8968}, "CVE-2021-43800": {"epss_score": 0.00353, "epss_percentile": 0.57163}, "CVE-2021-43801": {"epss_score": 0.00367, "epss_percentile": 0.58125}, "CVE-2021-43802": {"epss_score": 0.00547, "epss_percentile": 0.67262}, "CVE-2021-43803": {"epss_score": 0.02726, "epss_percentile": 0.85528}, "CVE-2021-43804": {"epss_score": 0.00327, "epss_percentile": 0.55111}, "CVE-2021-43805": {"epss_score": 0.00118, "epss_percentile": 0.31489}, "CVE-2021-43806": {"epss_score": 0.00912, "epss_percentile": 0.75356}, "CVE-2021-43807": {"epss_score": 0.00389, "epss_percentile": 0.59413}, "CVE-2021-43808": {"epss_score": 0.00359, "epss_percentile": 0.57614}, "CVE-2021-43809": {"epss_score": 0.01557, "epss_percentile": 0.81022}, "CVE-2021-43810": {"epss_score": 0.62973, "epss_percentile": 0.98315}, "CVE-2021-43811": {"epss_score": 0.08717, "epss_percentile": 0.92225}, "CVE-2021-43812": {"epss_score": 0.00195, "epss_percentile": 0.41708}, "CVE-2021-43813": {"epss_score": 0.09342, "epss_percentile": 0.92509}, "CVE-2021-43814": {"epss_score": 0.00246, "epss_percentile": 0.4774}, "CVE-2021-43815": {"epss_score": 0.00505, "epss_percentile": 0.65609}, "CVE-2021-43816": {"epss_score": 0.00147, "epss_percentile": 0.35747}, "CVE-2021-43817": {"epss_score": 0.00219, "epss_percentile": 0.44529}, "CVE-2021-43818": {"epss_score": 0.02804, "epss_percentile": 0.85703}, "CVE-2021-43819": {"epss_score": 0.00147, "epss_percentile": 0.35741}, "CVE-2021-43820": {"epss_score": 0.00306, "epss_percentile": 0.53416}, "CVE-2021-43821": {"epss_score": 0.01036, "epss_percentile": 0.76908}, "CVE-2021-43822": {"epss_score": 0.00241, "epss_percentile": 0.47325}, "CVE-2021-43823": {"epss_score": 0.00307, "epss_percentile": 0.53525}, "CVE-2021-43824": {"epss_score": 0.00125, "epss_percentile": 0.3251}, "CVE-2021-43825": {"epss_score": 0.00096, "epss_percentile": 0.27374}, "CVE-2021-43826": {"epss_score": 0.00095, "epss_percentile": 0.27142}, "CVE-2021-43827": {"epss_score": 0.00281, "epss_percentile": 0.51121}, "CVE-2021-43828": {"epss_score": 0.0036, "epss_percentile": 0.57649}, "CVE-2021-43829": {"epss_score": 0.02277, "epss_percentile": 0.8423}, "CVE-2021-43830": {"epss_score": 0.00298, "epss_percentile": 0.52796}, "CVE-2021-43831": {"epss_score": 0.30342, "epss_percentile": 0.96533}, "CVE-2021-43832": {"epss_score": 0.01815, "epss_percentile": 0.82383}, "CVE-2021-43833": {"epss_score": 0.00306, "epss_percentile": 0.53429}, "CVE-2021-43834": {"epss_score": 0.00322, "epss_percentile": 0.54793}, "CVE-2021-43835": {"epss_score": 0.00321, "epss_percentile": 0.54682}, "CVE-2021-43836": {"epss_score": 0.04292, "epss_percentile": 0.88503}, "CVE-2021-43837": {"epss_score": 0.07478, "epss_percentile": 0.91493}, "CVE-2021-43838": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-43839": {"epss_score": 0.00289, "epss_percentile": 0.51984}, "CVE-2021-43840": {"epss_score": 0.00232, "epss_percentile": 0.4586}, "CVE-2021-43841": {"epss_score": 0.00568, "epss_percentile": 0.67884}, "CVE-2021-43842": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2021-43843": {"epss_score": 0.00563, "epss_percentile": 0.67714}, "CVE-2021-43844": {"epss_score": 0.02502, "epss_percentile": 0.84924}, "CVE-2021-43845": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2021-43846": {"epss_score": 0.00127, "epss_percentile": 0.32899}, "CVE-2021-43847": {"epss_score": 0.00332, "epss_percentile": 0.5556}, "CVE-2021-43848": {"epss_score": 0.133, "epss_percentile": 0.93926}, "CVE-2021-43849": {"epss_score": 0.00074, "epss_percentile": 0.22743}, "CVE-2021-43850": {"epss_score": 0.00297, "epss_percentile": 0.52715}, "CVE-2021-43851": {"epss_score": 0.00336, "epss_percentile": 0.55928}, "CVE-2021-43852": {"epss_score": 0.00626, "epss_percentile": 0.69618}, "CVE-2021-43853": {"epss_score": 0.00239, "epss_percentile": 0.46869}, "CVE-2021-43854": {"epss_score": 0.00836, "epss_percentile": 0.74138}, "CVE-2021-43855": {"epss_score": 0.00361, "epss_percentile": 0.57738}, "CVE-2021-43856": {"epss_score": 0.00425, "epss_percentile": 0.6169}, "CVE-2021-43857": {"epss_score": 0.4964, "epss_percentile": 0.97698}, "CVE-2021-43858": {"epss_score": 0.53117, "epss_percentile": 0.97857}, "CVE-2021-43859": {"epss_score": 0.01939, "epss_percentile": 0.82973}, "CVE-2021-43860": {"epss_score": 0.00191, "epss_percentile": 0.41178}, "CVE-2021-43861": {"epss_score": 0.00411, "epss_percentile": 0.60881}, "CVE-2021-43862": {"epss_score": 0.00297, "epss_percentile": 0.52749}, "CVE-2021-43863": {"epss_score": 0.00176, "epss_percentile": 0.39381}, "CVE-2021-43875": {"epss_score": 0.00693, "epss_percentile": 0.71324}, "CVE-2021-43876": {"epss_score": 0.01431, "epss_percentile": 0.8024}, "CVE-2021-43877": {"epss_score": 0.00681, "epss_percentile": 0.7105}, "CVE-2021-43880": {"epss_score": 0.00237, "epss_percentile": 0.46707}, "CVE-2021-43882": {"epss_score": 0.00412, "epss_percentile": 0.60933}, "CVE-2021-43883": {"epss_score": 0.09272, "epss_percentile": 0.92477}, "CVE-2021-43888": {"epss_score": 0.09835, "epss_percentile": 0.92726}, "CVE-2021-43889": {"epss_score": 0.00951, "epss_percentile": 0.7587}, "CVE-2021-43890": {"epss_score": 0.12908, "epss_percentile": 0.93815}, "CVE-2021-43891": {"epss_score": 0.11914, "epss_percentile": 0.93515}, "CVE-2021-43892": {"epss_score": 0.01932, "epss_percentile": 0.82943}, "CVE-2021-43893": {"epss_score": 0.06763, "epss_percentile": 0.91009}, "CVE-2021-43896": {"epss_score": 0.03216, "epss_percentile": 0.86664}, "CVE-2021-43899": {"epss_score": 0.0088, "epss_percentile": 0.74851}, "CVE-2021-43905": {"epss_score": 0.0066, "epss_percentile": 0.7053}, "CVE-2021-43907": {"epss_score": 0.10127, "epss_percentile": 0.92861}, "CVE-2021-43908": {"epss_score": 0.15227, "epss_percentile": 0.94389}, "CVE-2021-43925": {"epss_score": 0.00406, "epss_percentile": 0.60559}, "CVE-2021-43926": {"epss_score": 0.00406, "epss_percentile": 0.60559}, "CVE-2021-43927": {"epss_score": 0.00415, "epss_percentile": 0.6111}, "CVE-2021-43928": {"epss_score": 0.01059, "epss_percentile": 0.77161}, "CVE-2021-43929": {"epss_score": 0.00207, "epss_percentile": 0.4313}, "CVE-2021-43930": {"epss_score": 0.00266, "epss_percentile": 0.49871}, "CVE-2021-43931": {"epss_score": 0.00235, "epss_percentile": 0.46219}, "CVE-2021-43932": {"epss_score": 0.00192, "epss_percentile": 0.41363}, "CVE-2021-43933": {"epss_score": 0.00223, "epss_percentile": 0.44959}, "CVE-2021-43934": {"epss_score": 0.00265, "epss_percentile": 0.49841}, "CVE-2021-43935": {"epss_score": 0.00197, "epss_percentile": 0.41904}, "CVE-2021-43936": {"epss_score": 0.28667, "epss_percentile": 0.96376}, "CVE-2021-43937": {"epss_score": 0.00082, "epss_percentile": 0.24544}, "CVE-2021-43938": {"epss_score": 0.00246, "epss_percentile": 0.47769}, "CVE-2021-43939": {"epss_score": 0.00073, "epss_percentile": 0.22631}, "CVE-2021-43940": {"epss_score": 0.00155, "epss_percentile": 0.36878}, "CVE-2021-43941": {"epss_score": 0.00136, "epss_percentile": 0.34109}, "CVE-2021-43942": {"epss_score": 0.03078, "epss_percentile": 0.86366}, "CVE-2021-43943": {"epss_score": 0.00519, "epss_percentile": 0.66142}, "CVE-2021-43944": {"epss_score": 0.01969, "epss_percentile": 0.83092}, "CVE-2021-43945": {"epss_score": 0.00215, "epss_percentile": 0.4406}, "CVE-2021-43946": {"epss_score": 0.00285, "epss_percentile": 0.51682}, "CVE-2021-43947": {"epss_score": 0.01121, "epss_percentile": 0.77771}, "CVE-2021-43948": {"epss_score": 0.0037, "epss_percentile": 0.58322}, "CVE-2021-43949": {"epss_score": 0.00317, "epss_percentile": 0.54347}, "CVE-2021-43950": {"epss_score": 0.0037, "epss_percentile": 0.58322}, "CVE-2021-43951": {"epss_score": 0.00317, "epss_percentile": 0.54347}, "CVE-2021-43952": {"epss_score": 0.00389, "epss_percentile": 0.59488}, "CVE-2021-43953": {"epss_score": 0.00321, "epss_percentile": 0.54671}, "CVE-2021-43954": {"epss_score": 0.00143, "epss_percentile": 0.35176}, "CVE-2021-43955": {"epss_score": 0.00182, "epss_percentile": 0.40148}, "CVE-2021-43956": {"epss_score": 0.00368, "epss_percentile": 0.5822}, "CVE-2021-43957": {"epss_score": 0.00182, "epss_percentile": 0.40263}, "CVE-2021-43958": {"epss_score": 0.01276, "epss_percentile": 0.79111}, "CVE-2021-43959": {"epss_score": 0.00275, "epss_percentile": 0.50667}, "CVE-2021-43960": {"epss_score": 0.00445, "epss_percentile": 0.62875}, "CVE-2021-43961": {"epss_score": 0.0048, "epss_percentile": 0.6448}, "CVE-2021-43963": {"epss_score": 0.00325, "epss_percentile": 0.54977}, "CVE-2021-43969": {"epss_score": 0.00754, "epss_percentile": 0.72696}, "CVE-2021-43970": {"epss_score": 0.00677, "epss_percentile": 0.70946}, "CVE-2021-43971": {"epss_score": 0.00583, "epss_percentile": 0.68335}, "CVE-2021-43972": {"epss_score": 0.00227, "epss_percentile": 0.45384}, "CVE-2021-43973": {"epss_score": 0.00827, "epss_percentile": 0.7398}, "CVE-2021-43974": {"epss_score": 0.00261, "epss_percentile": 0.49253}, "CVE-2021-43975": {"epss_score": 0.00018, "epss_percentile": 0.03614}, "CVE-2021-43976": {"epss_score": 0.00048, "epss_percentile": 0.14982}, "CVE-2021-43977": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-43978": {"epss_score": 0.0022, "epss_percentile": 0.44606}, "CVE-2021-43979": {"epss_score": 0.00227, "epss_percentile": 0.45418}, "CVE-2021-43980": {"epss_score": 0.00179, "epss_percentile": 0.39747}, "CVE-2021-43981": {"epss_score": 0.00281, "epss_percentile": 0.51123}, "CVE-2021-43982": {"epss_score": 0.00626, "epss_percentile": 0.69611}, "CVE-2021-43983": {"epss_score": 0.00485, "epss_percentile": 0.64705}, "CVE-2021-43984": {"epss_score": 0.00281, "epss_percentile": 0.51123}, "CVE-2021-43985": {"epss_score": 0.002, "epss_percentile": 0.42275}, "CVE-2021-43986": {"epss_score": 0.00065, "epss_percentile": 0.20608}, "CVE-2021-43987": {"epss_score": 0.00228, "epss_percentile": 0.45477}, "CVE-2021-43988": {"epss_score": 0.0044, "epss_percentile": 0.62611}, "CVE-2021-43989": {"epss_score": 0.00096, "epss_percentile": 0.27274}, "CVE-2021-43990": {"epss_score": 0.00198, "epss_percentile": 0.42002}, "CVE-2021-43991": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2021-43996": {"epss_score": 0.00528, "epss_percentile": 0.66577}, "CVE-2021-43997": {"epss_score": 0.00126, "epss_percentile": 0.32638}, "CVE-2021-43998": {"epss_score": 0.00282, "epss_percentile": 0.51219}, "CVE-2021-43999": {"epss_score": 0.01358, "epss_percentile": 0.79732}, "CVE-2021-44000": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2021-44001": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-44002": {"epss_score": 0.00602, "epss_percentile": 0.68862}, "CVE-2021-44003": {"epss_score": 0.00158, "epss_percentile": 0.37167}, "CVE-2021-44004": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2021-44005": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-44006": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-44007": {"epss_score": 0.00164, "epss_percentile": 0.3795}, "CVE-2021-44008": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2021-44009": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2021-44010": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2021-44011": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2021-44012": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2021-44013": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-44014": {"epss_score": 0.00931, "epss_percentile": 0.75616}, "CVE-2021-44015": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2021-44016": {"epss_score": 0.00307, "epss_percentile": 0.53504}, "CVE-2021-44017": {"epss_score": 0.00197, "epss_percentile": 0.41945}, "CVE-2021-44018": {"epss_score": 0.00321, "epss_percentile": 0.54678}, "CVE-2021-44019": {"epss_score": 0.00061, "epss_percentile": 0.19415}, "CVE-2021-44020": {"epss_score": 0.00061, "epss_percentile": 0.19415}, "CVE-2021-44021": {"epss_score": 0.00061, "epss_percentile": 0.19415}, "CVE-2021-44022": {"epss_score": 0.00076, "epss_percentile": 0.23146}, "CVE-2021-44023": {"epss_score": 0.00213, "epss_percentile": 0.43919}, "CVE-2021-44024": {"epss_score": 0.00056, "epss_percentile": 0.17708}, "CVE-2021-44025": {"epss_score": 0.00629, "epss_percentile": 0.69671}, "CVE-2021-44026": {"epss_score": 0.64041, "epss_percentile": 0.98361}, "CVE-2021-44028": {"epss_score": 0.00194, "epss_percentile": 0.41519}, "CVE-2021-44029": {"epss_score": 0.00878, "epss_percentile": 0.74825}, "CVE-2021-44030": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2021-44031": {"epss_score": 0.02866, "epss_percentile": 0.85861}, "CVE-2021-44032": {"epss_score": 0.00395, "epss_percentile": 0.59833}, "CVE-2021-44033": {"epss_score": 0.00073, "epss_percentile": 0.22573}, "CVE-2021-44035": {"epss_score": 0.00175, "epss_percentile": 0.39325}, "CVE-2021-44036": {"epss_score": 0.00178, "epss_percentile": 0.39655}, "CVE-2021-44037": {"epss_score": 0.00284, "epss_percentile": 0.51474}, "CVE-2021-44038": {"epss_score": 0.00195, "epss_percentile": 0.4161}, "CVE-2021-44040": {"epss_score": 0.04473, "epss_percentile": 0.88735}, "CVE-2021-44041": {"epss_score": 0.00829, "epss_percentile": 0.74017}, "CVE-2021-44042": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2021-44043": {"epss_score": 0.00263, "epss_percentile": 0.49517}, "CVE-2021-44044": {"epss_score": 0.00316, "epss_percentile": 0.54285}, "CVE-2021-44045": {"epss_score": 0.0039, "epss_percentile": 0.5951}, "CVE-2021-44046": {"epss_score": 0.00307, "epss_percentile": 0.53494}, "CVE-2021-44047": {"epss_score": 0.00422, "epss_percentile": 0.61557}, "CVE-2021-44048": {"epss_score": 0.0033, "epss_percentile": 0.55495}, "CVE-2021-44049": {"epss_score": 0.00052, "epss_percentile": 0.16516}, "CVE-2021-44050": {"epss_score": 0.00355, "epss_percentile": 0.57265}, "CVE-2021-44051": {"epss_score": 0.01155, "epss_percentile": 0.78076}, "CVE-2021-44052": {"epss_score": 0.00433, "epss_percentile": 0.62204}, "CVE-2021-44053": {"epss_score": 0.00422, "epss_percentile": 0.61571}, "CVE-2021-44054": {"epss_score": 0.00208, "epss_percentile": 0.43252}, "CVE-2021-44055": {"epss_score": 0.00799, "epss_percentile": 0.73531}, "CVE-2021-44056": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-44057": {"epss_score": 0.0035, "epss_percentile": 0.56969}, "CVE-2021-44076": {"epss_score": 0.00562, "epss_percentile": 0.67701}, "CVE-2021-44077": {"epss_score": 0.943, "epss_percentile": 0.9994}, "CVE-2021-44078": {"epss_score": 0.00239, "epss_percentile": 0.4691}, "CVE-2021-44079": {"epss_score": 0.08313, "epss_percentile": 0.91987}, "CVE-2021-44080": {"epss_score": 0.16499, "epss_percentile": 0.9468}, "CVE-2021-44081": {"epss_score": 0.00327, "epss_percentile": 0.55133}, "CVE-2021-44082": {"epss_score": 0.03477, "epss_percentile": 0.87209}, "CVE-2021-44087": {"epss_score": 0.21479, "epss_percentile": 0.95523}, "CVE-2021-44088": {"epss_score": 0.01731, "epss_percentile": 0.8199}, "CVE-2021-44090": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2021-44091": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-44092": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2021-44093": {"epss_score": 0.04519, "epss_percentile": 0.88796}, "CVE-2021-44094": {"epss_score": 0.01203, "epss_percentile": 0.78491}, "CVE-2021-44095": {"epss_score": 0.00601, "epss_percentile": 0.68852}, "CVE-2021-44096": {"epss_score": 0.00478, "epss_percentile": 0.64372}, "CVE-2021-44097": {"epss_score": 0.00478, "epss_percentile": 0.64372}, "CVE-2021-44098": {"epss_score": 0.00478, "epss_percentile": 0.64372}, "CVE-2021-44108": {"epss_score": 0.00561, "epss_percentile": 0.67668}, "CVE-2021-44109": {"epss_score": 0.00952, "epss_percentile": 0.75873}, "CVE-2021-44111": {"epss_score": 0.00133, "epss_percentile": 0.33664}, "CVE-2021-44114": {"epss_score": 0.00318, "epss_percentile": 0.54404}, "CVE-2021-44116": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-44117": {"epss_score": 0.00643, "epss_percentile": 0.70049}, "CVE-2021-44118": {"epss_score": 0.00104, "epss_percentile": 0.29207}, "CVE-2021-44120": {"epss_score": 0.00465, "epss_percentile": 0.63756}, "CVE-2021-44122": {"epss_score": 0.00392, "epss_percentile": 0.59643}, "CVE-2021-44123": {"epss_score": 0.01728, "epss_percentile": 0.81972}, "CVE-2021-44124": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2021-44127": {"epss_score": 0.13515, "epss_percentile": 0.93986}, "CVE-2021-44132": {"epss_score": 0.02043, "epss_percentile": 0.83379}, "CVE-2021-44135": {"epss_score": 0.00303, "epss_percentile": 0.53184}, "CVE-2021-44138": {"epss_score": 0.81625, "epss_percentile": 0.99148}, "CVE-2021-44139": {"epss_score": 0.77664, "epss_percentile": 0.98947}, "CVE-2021-44140": {"epss_score": 0.05872, "epss_percentile": 0.90281}, "CVE-2021-44141": {"epss_score": 0.00309, "epss_percentile": 0.5368}, "CVE-2021-44142": {"epss_score": 0.28588, "epss_percentile": 0.96369}, "CVE-2021-44143": {"epss_score": 0.07783, "epss_percentile": 0.9168}, "CVE-2021-44144": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2021-44145": {"epss_score": 0.00166, "epss_percentile": 0.38238}, "CVE-2021-44147": {"epss_score": 0.00304, "epss_percentile": 0.53261}, "CVE-2021-44148": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-44149": {"epss_score": 0.00067, "epss_percentile": 0.21042}, "CVE-2021-44150": {"epss_score": 0.00211, "epss_percentile": 0.43678}, "CVE-2021-44151": {"epss_score": 0.00402, "epss_percentile": 0.60268}, "CVE-2021-44152": {"epss_score": 0.86671, "epss_percentile": 0.99392}, "CVE-2021-44153": {"epss_score": 0.0082, "epss_percentile": 0.73881}, "CVE-2021-44154": {"epss_score": 0.00672, "epss_percentile": 0.70811}, "CVE-2021-44155": {"epss_score": 0.0095, "epss_percentile": 0.7586}, "CVE-2021-44158": {"epss_score": 0.00155, "epss_percentile": 0.36762}, "CVE-2021-44159": {"epss_score": 0.04763, "epss_percentile": 0.89119}, "CVE-2021-44160": {"epss_score": 0.00592, "epss_percentile": 0.68603}, "CVE-2021-44161": {"epss_score": 0.00193, "epss_percentile": 0.41428}, "CVE-2021-44162": {"epss_score": 0.00423, "epss_percentile": 0.616}, "CVE-2021-44163": {"epss_score": 0.00192, "epss_percentile": 0.41328}, "CVE-2021-44164": {"epss_score": 0.03047, "epss_percentile": 0.86284}, "CVE-2021-44165": {"epss_score": 0.02256, "epss_percentile": 0.84171}, "CVE-2021-44166": {"epss_score": 0.00173, "epss_percentile": 0.39097}, "CVE-2021-44167": {"epss_score": 0.0024, "epss_percentile": 0.47225}, "CVE-2021-44168": {"epss_score": 0.01431, "epss_percentile": 0.80246}, "CVE-2021-44169": {"epss_score": 0.00149, "epss_percentile": 0.35939}, "CVE-2021-44170": {"epss_score": 0.00127, "epss_percentile": 0.32809}, "CVE-2021-44171": {"epss_score": 0.00821, "epss_percentile": 0.73909}, "CVE-2021-44172": {"epss_score": 0.00465, "epss_percentile": 0.63768}, "CVE-2021-44176": {"epss_score": 0.05654, "epss_percentile": 0.90087}, "CVE-2021-44177": {"epss_score": 0.05654, "epss_percentile": 0.90087}, "CVE-2021-44178": {"epss_score": 0.02816, "epss_percentile": 0.85734}, "CVE-2021-44179": {"epss_score": 0.01652, "epss_percentile": 0.81574}, "CVE-2021-44180": {"epss_score": 0.01717, "epss_percentile": 0.81918}, "CVE-2021-44181": {"epss_score": 0.01717, "epss_percentile": 0.81918}, "CVE-2021-44182": {"epss_score": 0.01748, "epss_percentile": 0.8208}, "CVE-2021-44183": {"epss_score": 0.02122, "epss_percentile": 0.83681}, "CVE-2021-44185": {"epss_score": 0.01339, "epss_percentile": 0.79574}, "CVE-2021-44186": {"epss_score": 0.00747, "epss_percentile": 0.72561}, "CVE-2021-44187": {"epss_score": 0.01339, "epss_percentile": 0.79574}, "CVE-2021-44188": {"epss_score": 0.00194, "epss_percentile": 0.41532}, "CVE-2021-44189": {"epss_score": 0.00032, "epss_percentile": 0.09011}, "CVE-2021-44190": {"epss_score": 0.00034, "epss_percentile": 0.09652}, "CVE-2021-44191": {"epss_score": 0.00034, "epss_percentile": 0.09652}, "CVE-2021-44192": {"epss_score": 0.00034, "epss_percentile": 0.09652}, "CVE-2021-44193": {"epss_score": 0.00034, "epss_percentile": 0.09652}, "CVE-2021-44194": {"epss_score": 0.00034, "epss_percentile": 0.09652}, "CVE-2021-44195": {"epss_score": 0.00034, "epss_percentile": 0.09652}, "CVE-2021-44196": {"epss_score": 0.00465, "epss_percentile": 0.63766}, "CVE-2021-44197": {"epss_score": 0.00096, "epss_percentile": 0.27405}, "CVE-2021-44198": {"epss_score": 0.00054, "epss_percentile": 0.17175}, "CVE-2021-44199": {"epss_score": 0.00053, "epss_percentile": 0.1687}, "CVE-2021-44200": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-44201": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2021-44202": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-44203": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2021-44204": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2021-44205": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2021-44206": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2021-44207": {"epss_score": 0.08924, "epss_percentile": 0.92321}, "CVE-2021-44208": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2021-44209": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2021-44210": {"epss_score": 0.00211, "epss_percentile": 0.43663}, "CVE-2021-44211": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2021-44212": {"epss_score": 0.00341, "epss_percentile": 0.56299}, "CVE-2021-44213": {"epss_score": 0.00341, "epss_percentile": 0.56299}, "CVE-2021-44215": {"epss_score": 0.00061, "epss_percentile": 0.19455}, "CVE-2021-44216": {"epss_score": 0.00061, "epss_percentile": 0.19455}, "CVE-2021-44217": {"epss_score": 0.00741, "epss_percentile": 0.72438}, "CVE-2021-44219": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2021-44221": {"epss_score": 0.00539, "epss_percentile": 0.66973}, "CVE-2021-44222": {"epss_score": 0.00414, "epss_percentile": 0.61042}, "CVE-2021-44223": {"epss_score": 0.27489, "epss_percentile": 0.96251}, "CVE-2021-44224": {"epss_score": 0.10696, "epss_percentile": 0.93073}, "CVE-2021-44225": {"epss_score": 0.0005, "epss_percentile": 0.15767}, "CVE-2021-44226": {"epss_score": 0.0007, "epss_percentile": 0.21958}, "CVE-2021-44227": {"epss_score": 0.00425, "epss_percentile": 0.61691}, "CVE-2021-44228": {"epss_score": 0.94358, "epss_percentile": 0.99959}, "CVE-2021-44230": {"epss_score": 0.00162, "epss_percentile": 0.37731}, "CVE-2021-44231": {"epss_score": 0.0073, "epss_percentile": 0.72144}, "CVE-2021-44232": {"epss_score": 0.00467, "epss_percentile": 0.63837}, "CVE-2021-44233": {"epss_score": 0.00406, "epss_percentile": 0.60523}, "CVE-2021-44234": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2021-44235": {"epss_score": 0.0012, "epss_percentile": 0.31692}, "CVE-2021-44238": {"epss_score": 0.0276, "epss_percentile": 0.85597}, "CVE-2021-44244": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2021-44245": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-44246": {"epss_score": 0.00407, "epss_percentile": 0.60572}, "CVE-2021-44247": {"epss_score": 0.2647, "epss_percentile": 0.9615}, "CVE-2021-44249": {"epss_score": 0.00477, "epss_percentile": 0.64304}, "CVE-2021-44255": {"epss_score": 0.13636, "epss_percentile": 0.94018}, "CVE-2021-44259": {"epss_score": 0.01043, "epss_percentile": 0.76996}, "CVE-2021-44260": {"epss_score": 0.26366, "epss_percentile": 0.96142}, "CVE-2021-44261": {"epss_score": 0.0161, "epss_percentile": 0.8132}, "CVE-2021-44262": {"epss_score": 0.00656, "epss_percentile": 0.70441}, "CVE-2021-44263": {"epss_score": 0.00354, "epss_percentile": 0.5725}, "CVE-2021-44266": {"epss_score": 0.0066, "epss_percentile": 0.70524}, "CVE-2021-44269": {"epss_score": 0.00117, "epss_percentile": 0.31349}, "CVE-2021-44273": {"epss_score": 0.00169, "epss_percentile": 0.386}, "CVE-2021-44277": {"epss_score": 3e-05, "epss_percentile": 0.00086}, "CVE-2021-44278": {"epss_score": 2e-05, "epss_percentile": 0.00057}, "CVE-2021-44279": {"epss_score": 3e-05, "epss_percentile": 0.00086}, "CVE-2021-44280": {"epss_score": 0.00228, "epss_percentile": 0.45518}, "CVE-2021-44283": {"epss_score": 0.00073, "epss_percentile": 0.22588}, "CVE-2021-44299": {"epss_score": 0.00221, "epss_percentile": 0.44657}, "CVE-2021-44302": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2021-44310": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2021-44312": {"epss_score": 0.00141, "epss_percentile": 0.3489}, "CVE-2021-44315": {"epss_score": 0.00291, "epss_percentile": 0.52179}, "CVE-2021-44317": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-44321": {"epss_score": 0.00086, "epss_percentile": 0.25381}, "CVE-2021-44331": {"epss_score": 0.00259, "epss_percentile": 0.49041}, "CVE-2021-44334": {"epss_score": 0.00252, "epss_percentile": 0.48337}, "CVE-2021-44335": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-44339": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-44340": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-44342": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-44343": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-44345": {"epss_score": 0.00251, "epss_percentile": 0.48312}, "CVE-2021-44347": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2021-44348": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-44349": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-44350": {"epss_score": 0.01037, "epss_percentile": 0.76923}, "CVE-2021-44351": {"epss_score": 0.00813, "epss_percentile": 0.73765}, "CVE-2021-44352": {"epss_score": 0.0122, "epss_percentile": 0.78624}, "CVE-2021-44354": {"epss_score": 0.00304, "epss_percentile": 0.53301}, "CVE-2021-44355": {"epss_score": 0.00304, "epss_percentile": 0.53301}, "CVE-2021-44356": {"epss_score": 0.00304, "epss_percentile": 0.53301}, "CVE-2021-44357": {"epss_score": 0.00304, "epss_percentile": 0.53301}, "CVE-2021-44358": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44359": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44360": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44361": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44362": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44363": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44364": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44365": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44366": {"epss_score": 0.00304, "epss_percentile": 0.53301}, "CVE-2021-44367": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44368": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44369": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44370": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44371": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44372": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44373": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44374": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44375": {"epss_score": 0.00304, "epss_percentile": 0.53301}, "CVE-2021-44376": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44377": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44378": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44379": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44380": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44381": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44382": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44383": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44384": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44385": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44386": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2021-44387": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44388": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44389": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44390": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44391": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44392": {"epss_score": 0.00163, "epss_percentile": 0.37774}, "CVE-2021-44393": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44394": {"epss_score": 0.00304, "epss_percentile": 0.53301}, "CVE-2021-44395": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44396": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44397": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44398": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44399": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44400": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44401": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44402": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44403": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44404": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44405": {"epss_score": 0.00163, "epss_percentile": 0.37774}, "CVE-2021-44406": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44407": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44408": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44409": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44410": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44411": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44412": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44413": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44414": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44415": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44416": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44417": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44418": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44419": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2021-44420": {"epss_score": 0.00138, "epss_percentile": 0.34355}, "CVE-2021-44421": {"epss_score": 0.00072, "epss_percentile": 0.22347}, "CVE-2021-44422": {"epss_score": 0.00804, "epss_percentile": 0.73618}, "CVE-2021-44423": {"epss_score": 0.00414, "epss_percentile": 0.61019}, "CVE-2021-44425": {"epss_score": 0.00113, "epss_percentile": 0.30702}, "CVE-2021-44426": {"epss_score": 0.0045, "epss_percentile": 0.63104}, "CVE-2021-44427": {"epss_score": 0.84943, "epss_percentile": 0.99312}, "CVE-2021-44428": {"epss_score": 0.01353, "epss_percentile": 0.79695}, "CVE-2021-44429": {"epss_score": 0.00801, "epss_percentile": 0.73564}, "CVE-2021-44430": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-44431": {"epss_score": 0.0019, "epss_percentile": 0.41108}, "CVE-2021-44432": {"epss_score": 0.00853, "epss_percentile": 0.74433}, "CVE-2021-44433": {"epss_score": 0.00678, "epss_percentile": 0.70981}, "CVE-2021-44434": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-44435": {"epss_score": 0.00853, "epss_percentile": 0.74433}, "CVE-2021-44436": {"epss_score": 0.0019, "epss_percentile": 0.41108}, "CVE-2021-44437": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-44438": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-44439": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2021-44440": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2021-44441": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-44442": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-44443": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-44444": {"epss_score": 0.00238, "epss_percentile": 0.46769}, "CVE-2021-44445": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-44446": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-44447": {"epss_score": 0.00678, "epss_percentile": 0.70981}, "CVE-2021-44448": {"epss_score": 0.0019, "epss_percentile": 0.41108}, "CVE-2021-44449": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2021-44450": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2021-44451": {"epss_score": 0.71271, "epss_percentile": 0.98661}, "CVE-2021-44453": {"epss_score": 0.00304, "epss_percentile": 0.53285}, "CVE-2021-44454": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2021-44458": {"epss_score": 0.00138, "epss_percentile": 0.34403}, "CVE-2021-44460": {"epss_score": 0.00353, "epss_percentile": 0.57177}, "CVE-2021-44461": {"epss_score": 0.00325, "epss_percentile": 0.55024}, "CVE-2021-44462": {"epss_score": 0.00145, "epss_percentile": 0.35378}, "CVE-2021-44463": {"epss_score": 0.00041, "epss_percentile": 0.12459}, "CVE-2021-44464": {"epss_score": 0.00181, "epss_percentile": 0.40053}, "CVE-2021-44465": {"epss_score": 0.00352, "epss_percentile": 0.57126}, "CVE-2021-44466": {"epss_score": 0.0015, "epss_percentile": 0.36139}, "CVE-2021-44467": {"epss_score": 0.00225, "epss_percentile": 0.45131}, "CVE-2021-44470": {"epss_score": 0.00039, "epss_percentile": 0.11578}, "CVE-2021-44471": {"epss_score": 0.0044, "epss_percentile": 0.62612}, "CVE-2021-44476": {"epss_score": 0.00404, "epss_percentile": 0.60418}, "CVE-2021-44477": {"epss_score": 0.00266, "epss_percentile": 0.49891}, "CVE-2021-44478": {"epss_score": 0.00813, "epss_percentile": 0.73757}, "CVE-2021-44479": {"epss_score": 0.00125, "epss_percentile": 0.32595}, "CVE-2021-44480": {"epss_score": 0.00304, "epss_percentile": 0.53286}, "CVE-2021-44481": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2021-44482": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-44483": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-44484": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-44485": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-44486": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2021-44487": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2021-44488": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-44489": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-44490": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-44491": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-44492": {"epss_score": 0.00265, "epss_percentile": 0.49806}, "CVE-2021-44493": {"epss_score": 0.00424, "epss_percentile": 0.61684}, "CVE-2021-44494": {"epss_score": 0.00368, "epss_percentile": 0.58215}, "CVE-2021-44495": {"epss_score": 0.00368, "epss_percentile": 0.58215}, "CVE-2021-44496": {"epss_score": 0.01221, "epss_percentile": 0.78644}, "CVE-2021-44497": {"epss_score": 0.00367, "epss_percentile": 0.58125}, "CVE-2021-44498": {"epss_score": 0.00265, "epss_percentile": 0.49806}, "CVE-2021-44499": {"epss_score": 0.00424, "epss_percentile": 0.61684}, "CVE-2021-44500": {"epss_score": 0.00264, "epss_percentile": 0.49722}, "CVE-2021-44501": {"epss_score": 0.00368, "epss_percentile": 0.58215}, "CVE-2021-44502": {"epss_score": 0.00264, "epss_percentile": 0.49722}, "CVE-2021-44503": {"epss_score": 0.00367, "epss_percentile": 0.58125}, "CVE-2021-44504": {"epss_score": 0.00367, "epss_percentile": 0.58125}, "CVE-2021-44505": {"epss_score": 0.00368, "epss_percentile": 0.58215}, "CVE-2021-44506": {"epss_score": 0.00265, "epss_percentile": 0.49806}, "CVE-2021-44507": {"epss_score": 0.00368, "epss_percentile": 0.58215}, "CVE-2021-44508": {"epss_score": 0.00367, "epss_percentile": 0.58102}, "CVE-2021-44509": {"epss_score": 0.00264, "epss_percentile": 0.49722}, "CVE-2021-44510": {"epss_score": 0.00264, "epss_percentile": 0.49722}, "CVE-2021-44512": {"epss_score": 0.00032, "epss_percentile": 0.08846}, "CVE-2021-44513": {"epss_score": 0.00039, "epss_percentile": 0.11659}, "CVE-2021-44514": {"epss_score": 0.06038, "epss_percentile": 0.90427}, "CVE-2021-44515": {"epss_score": 0.94311, "epss_percentile": 0.99944}, "CVE-2021-44518": {"epss_score": 0.00063, "epss_percentile": 0.19888}, "CVE-2021-44519": {"epss_score": 0.02111, "epss_percentile": 0.83646}, "CVE-2021-44520": {"epss_score": 0.15839, "epss_percentile": 0.94517}, "CVE-2021-44521": {"epss_score": 0.91526, "epss_percentile": 0.9965}, "CVE-2021-44522": {"epss_score": 0.00432, "epss_percentile": 0.62161}, "CVE-2021-44523": {"epss_score": 0.0042, "epss_percentile": 0.61423}, "CVE-2021-44524": {"epss_score": 0.00582, "epss_percentile": 0.68296}, "CVE-2021-44525": {"epss_score": 0.00777, "epss_percentile": 0.7311}, "CVE-2021-44526": {"epss_score": 0.05525, "epss_percentile": 0.89961}, "CVE-2021-44527": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2021-44528": {"epss_score": 0.31577, "epss_percentile": 0.96628}, "CVE-2021-44529": {"epss_score": 0.94461, "epss_percentile": 0.99994}, "CVE-2021-44530": {"epss_score": 0.0111, "epss_percentile": 0.77664}, "CVE-2021-44531": {"epss_score": 0.00104, "epss_percentile": 0.29129}, "CVE-2021-44532": {"epss_score": 0.00132, "epss_percentile": 0.3357}, "CVE-2021-44533": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2021-44534": {"epss_score": 0.0023, "epss_percentile": 0.45762}, "CVE-2021-44537": {"epss_score": 0.01086, "epss_percentile": 0.77424}, "CVE-2021-44538": {"epss_score": 0.01416, "epss_percentile": 0.80141}, "CVE-2021-44540": {"epss_score": 0.00089, "epss_percentile": 0.25959}, "CVE-2021-44541": {"epss_score": 0.00456, "epss_percentile": 0.63349}, "CVE-2021-44542": {"epss_score": 0.00145, "epss_percentile": 0.35383}, "CVE-2021-44543": {"epss_score": 0.00138, "epss_percentile": 0.34396}, "CVE-2021-44544": {"epss_score": 0.00209, "epss_percentile": 0.43314}, "CVE-2021-44545": {"epss_score": 0.00143, "epss_percentile": 0.35192}, "CVE-2021-44547": {"epss_score": 0.00253, "epss_percentile": 0.48457}, "CVE-2021-44548": {"epss_score": 0.0666, "epss_percentile": 0.90923}, "CVE-2021-44549": {"epss_score": 0.00178, "epss_percentile": 0.39739}, "CVE-2021-44550": {"epss_score": 0.00477, "epss_percentile": 0.6432}, "CVE-2021-44554": {"epss_score": 0.00395, "epss_percentile": 0.59831}, "CVE-2021-44556": {"epss_score": 0.00426, "epss_percentile": 0.61755}, "CVE-2021-44557": {"epss_score": 0.00426, "epss_percentile": 0.61755}, "CVE-2021-44564": {"epss_score": 0.00476, "epss_percentile": 0.64271}, "CVE-2021-44565": {"epss_score": 0.0036, "epss_percentile": 0.57627}, "CVE-2021-44566": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2021-44567": {"epss_score": 0.05378, "epss_percentile": 0.89805}, "CVE-2021-44568": {"epss_score": 0.00189, "epss_percentile": 0.40986}, "CVE-2021-44581": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2021-44582": {"epss_score": 0.0025, "epss_percentile": 0.48128}, "CVE-2021-44584": {"epss_score": 0.00248, "epss_percentile": 0.47939}, "CVE-2021-44585": {"epss_score": 0.00345, "epss_percentile": 0.56555}, "CVE-2021-44586": {"epss_score": 0.0039, "epss_percentile": 0.59525}, "CVE-2021-44590": {"epss_score": 0.00368, "epss_percentile": 0.58195}, "CVE-2021-44591": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2021-44593": {"epss_score": 0.0537, "epss_percentile": 0.89794}, "CVE-2021-44595": {"epss_score": 0.08168, "epss_percentile": 0.91913}, "CVE-2021-44596": {"epss_score": 0.42779, "epss_percentile": 0.9735}, "CVE-2021-44598": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2021-44599": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2021-44600": {"epss_score": 0.00295, "epss_percentile": 0.52507}, "CVE-2021-44607": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-44608": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-44610": {"epss_score": 0.00706, "epss_percentile": 0.71611}, "CVE-2021-44617": {"epss_score": 0.0054, "epss_percentile": 0.67015}, "CVE-2021-44618": {"epss_score": 0.00513, "epss_percentile": 0.6589}, "CVE-2021-44620": {"epss_score": 0.04056, "epss_percentile": 0.88186}, "CVE-2021-44622": {"epss_score": 0.00952, "epss_percentile": 0.75878}, "CVE-2021-44623": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2021-44625": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2021-44626": {"epss_score": 0.00952, "epss_percentile": 0.75878}, "CVE-2021-44627": {"epss_score": 0.00952, "epss_percentile": 0.75878}, "CVE-2021-44628": {"epss_score": 0.00952, "epss_percentile": 0.75878}, "CVE-2021-44629": {"epss_score": 0.00952, "epss_percentile": 0.75878}, "CVE-2021-44630": {"epss_score": 0.00952, "epss_percentile": 0.75878}, "CVE-2021-44631": {"epss_score": 0.00952, "epss_percentile": 0.75878}, "CVE-2021-44632": {"epss_score": 0.00952, "epss_percentile": 0.75878}, "CVE-2021-44647": {"epss_score": 0.00026, "epss_percentile": 0.06431}, "CVE-2021-44648": {"epss_score": 0.00154, "epss_percentile": 0.36644}, "CVE-2021-44649": {"epss_score": 0.00549, "epss_percentile": 0.67312}, "CVE-2021-44650": {"epss_score": 0.04615, "epss_percentile": 0.88921}, "CVE-2021-44651": {"epss_score": 0.07829, "epss_percentile": 0.91703}, "CVE-2021-44652": {"epss_score": 0.01114, "epss_percentile": 0.77699}, "CVE-2021-44653": {"epss_score": 0.00229, "epss_percentile": 0.45594}, "CVE-2021-44655": {"epss_score": 0.00229, "epss_percentile": 0.45594}, "CVE-2021-44657": {"epss_score": 0.02639, "epss_percentile": 0.85299}, "CVE-2021-44659": {"epss_score": 0.0199, "epss_percentile": 0.83173}, "CVE-2021-44662": {"epss_score": 0.0066, "epss_percentile": 0.70524}, "CVE-2021-44663": {"epss_score": 0.0429, "epss_percentile": 0.885}, "CVE-2021-44664": {"epss_score": 0.13471, "epss_percentile": 0.93975}, "CVE-2021-44665": {"epss_score": 0.05465, "epss_percentile": 0.89904}, "CVE-2021-44667": {"epss_score": 0.00427, "epss_percentile": 0.61888}, "CVE-2021-44673": {"epss_score": 0.0354, "epss_percentile": 0.87317}, "CVE-2021-44674": {"epss_score": 0.00421, "epss_percentile": 0.61518}, "CVE-2021-44675": {"epss_score": 0.01885, "epss_percentile": 0.82707}, "CVE-2021-44676": {"epss_score": 0.07742, "epss_percentile": 0.91654}, "CVE-2021-44677": {"epss_score": 0.00496, "epss_percentile": 0.65159}, "CVE-2021-44678": {"epss_score": 0.00496, "epss_percentile": 0.65159}, "CVE-2021-44679": {"epss_score": 0.00496, "epss_percentile": 0.65159}, "CVE-2021-44680": {"epss_score": 0.00496, "epss_percentile": 0.65159}, "CVE-2021-44681": {"epss_score": 0.00496, "epss_percentile": 0.65159}, "CVE-2021-44682": {"epss_score": 0.00496, "epss_percentile": 0.65159}, "CVE-2021-44683": {"epss_score": 0.00282, "epss_percentile": 0.51221}, "CVE-2021-44684": {"epss_score": 0.04434, "epss_percentile": 0.88683}, "CVE-2021-44685": {"epss_score": 0.01961, "epss_percentile": 0.8306}, "CVE-2021-44686": {"epss_score": 0.00362, "epss_percentile": 0.57784}, "CVE-2021-44692": {"epss_score": 0.00459, "epss_percentile": 0.63464}, "CVE-2021-44693": {"epss_score": 0.00224, "epss_percentile": 0.45059}, "CVE-2021-44694": {"epss_score": 0.00224, "epss_percentile": 0.45059}, "CVE-2021-44695": {"epss_score": 0.00198, "epss_percentile": 0.42025}, "CVE-2021-44696": {"epss_score": 0.00035, "epss_percentile": 0.09901}, "CVE-2021-44697": {"epss_score": 0.01604, "epss_percentile": 0.81285}, "CVE-2021-44698": {"epss_score": 0.01604, "epss_percentile": 0.81285}, "CVE-2021-44699": {"epss_score": 0.01604, "epss_percentile": 0.81285}, "CVE-2021-44700": {"epss_score": 0.0176, "epss_percentile": 0.82144}, "CVE-2021-44701": {"epss_score": 0.22642, "epss_percentile": 0.95663}, "CVE-2021-44702": {"epss_score": 0.01723, "epss_percentile": 0.81946}, "CVE-2021-44703": {"epss_score": 0.11776, "epss_percentile": 0.93471}, "CVE-2021-44704": {"epss_score": 0.07813, "epss_percentile": 0.91695}, "CVE-2021-44705": {"epss_score": 0.02265, "epss_percentile": 0.84196}, "CVE-2021-44706": {"epss_score": 0.07813, "epss_percentile": 0.91695}, "CVE-2021-44707": {"epss_score": 0.00555, "epss_percentile": 0.67463}, "CVE-2021-44708": {"epss_score": 0.02952, "epss_percentile": 0.86055}, "CVE-2021-44709": {"epss_score": 0.02952, "epss_percentile": 0.86055}, "CVE-2021-44710": {"epss_score": 0.07549, "epss_percentile": 0.91533}, "CVE-2021-44711": {"epss_score": 0.06411, "epss_percentile": 0.90741}, "CVE-2021-44712": {"epss_score": 0.00488, "epss_percentile": 0.64861}, "CVE-2021-44713": {"epss_score": 0.00498, "epss_percentile": 0.6523}, "CVE-2021-44714": {"epss_score": 0.00527, "epss_percentile": 0.66452}, "CVE-2021-44715": {"epss_score": 0.02146, "epss_percentile": 0.83767}, "CVE-2021-44716": {"epss_score": 0.00095, "epss_percentile": 0.27192}, "CVE-2021-44717": {"epss_score": 0.00441, "epss_percentile": 0.62676}, "CVE-2021-44718": {"epss_score": 0.0055, "epss_percentile": 0.67336}, "CVE-2021-44719": {"epss_score": 0.00062, "epss_percentile": 0.19688}, "CVE-2021-44720": {"epss_score": 0.026, "epss_percentile": 0.85204}, "CVE-2021-44725": {"epss_score": 0.00256, "epss_percentile": 0.48814}, "CVE-2021-44726": {"epss_score": 0.00389, "epss_percentile": 0.59465}, "CVE-2021-44730": {"epss_score": 0.00039, "epss_percentile": 0.11631}, "CVE-2021-44731": {"epss_score": 0.02304, "epss_percentile": 0.84318}, "CVE-2021-44732": {"epss_score": 0.00934, "epss_percentile": 0.75647}, "CVE-2021-44733": {"epss_score": 0.00255, "epss_percentile": 0.48698}, "CVE-2021-44734": {"epss_score": 0.083, "epss_percentile": 0.91978}, "CVE-2021-44735": {"epss_score": 0.12552, "epss_percentile": 0.93713}, "CVE-2021-44736": {"epss_score": 0.00594, "epss_percentile": 0.68665}, "CVE-2021-44737": {"epss_score": 0.00825, "epss_percentile": 0.73954}, "CVE-2021-44738": {"epss_score": 0.00838, "epss_percentile": 0.74181}, "CVE-2021-44739": {"epss_score": 0.01723, "epss_percentile": 0.81946}, "CVE-2021-44740": {"epss_score": 0.00753, "epss_percentile": 0.72669}, "CVE-2021-44741": {"epss_score": 0.00753, "epss_percentile": 0.72669}, "CVE-2021-44742": {"epss_score": 0.0862, "epss_percentile": 0.92156}, "CVE-2021-44743": {"epss_score": 0.01507, "epss_percentile": 0.80752}, "CVE-2021-44746": {"epss_score": 0.00212, "epss_percentile": 0.43778}, "CVE-2021-44747": {"epss_score": 0.00242, "epss_percentile": 0.47396}, "CVE-2021-44748": {"epss_score": 0.0045, "epss_percentile": 0.63087}, "CVE-2021-44749": {"epss_score": 0.01056, "epss_percentile": 0.77122}, "CVE-2021-44750": {"epss_score": 0.00239, "epss_percentile": 0.46919}, "CVE-2021-44751": {"epss_score": 0.00253, "epss_percentile": 0.48462}, "CVE-2021-44757": {"epss_score": 0.38574, "epss_percentile": 0.97107}, "CVE-2021-44758": {"epss_score": 0.00338, "epss_percentile": 0.56133}, "CVE-2021-44759": {"epss_score": 0.01437, "epss_percentile": 0.80281}, "CVE-2021-44760": {"epss_score": 0.00176, "epss_percentile": 0.3942}, "CVE-2021-44768": {"epss_score": 0.00145, "epss_percentile": 0.35381}, "CVE-2021-44769": {"epss_score": 0.00169, "epss_percentile": 0.38596}, "CVE-2021-44775": {"epss_score": 0.00366, "epss_percentile": 0.58025}, "CVE-2021-44776": {"epss_score": 0.00164, "epss_percentile": 0.37966}, "CVE-2021-44777": {"epss_score": 0.00098, "epss_percentile": 0.27707}, "CVE-2021-44779": {"epss_score": 0.00455, "epss_percentile": 0.63284}, "CVE-2021-44790": {"epss_score": 0.87092, "epss_percentile": 0.99414}, "CVE-2021-44791": {"epss_score": 0.05971, "epss_percentile": 0.90372}, "CVE-2021-44792": {"epss_score": 0.00392, "epss_percentile": 0.59667}, "CVE-2021-44793": {"epss_score": 0.00445, "epss_percentile": 0.62863}, "CVE-2021-44794": {"epss_score": 0.0018, "epss_percentile": 0.39877}, "CVE-2021-44795": {"epss_score": 0.00132, "epss_percentile": 0.3357}, "CVE-2021-44827": {"epss_score": 0.44631, "epss_percentile": 0.97447}, "CVE-2021-44828": {"epss_score": 0.00114, "epss_percentile": 0.3088}, "CVE-2021-44829": {"epss_score": 0.03428, "epss_percentile": 0.87119}, "CVE-2021-44832": {"epss_score": 0.53591, "epss_percentile": 0.97884}, "CVE-2021-44833": {"epss_score": 0.00285, "epss_percentile": 0.51549}, "CVE-2021-44835": {"epss_score": 0.00269, "epss_percentile": 0.50105}, "CVE-2021-44836": {"epss_score": 0.00158, "epss_percentile": 0.37149}, "CVE-2021-44837": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2021-44838": {"epss_score": 0.00225, "epss_percentile": 0.4512}, "CVE-2021-44839": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2021-44840": {"epss_score": 0.00189, "epss_percentile": 0.40967}, "CVE-2021-44847": {"epss_score": 0.02229, "epss_percentile": 0.84082}, "CVE-2021-44848": {"epss_score": 0.30193, "epss_percentile": 0.96517}, "CVE-2021-44850": {"epss_score": 0.00076, "epss_percentile": 0.23147}, "CVE-2021-44852": {"epss_score": 0.01855, "epss_percentile": 0.82557}, "CVE-2021-44854": {"epss_score": 0.00153, "epss_percentile": 0.36622}, "CVE-2021-44855": {"epss_score": 0.00375, "epss_percentile": 0.58623}, "CVE-2021-44856": {"epss_score": 0.00144, "epss_percentile": 0.35281}, "CVE-2021-44857": {"epss_score": 0.00181, "epss_percentile": 0.40109}, "CVE-2021-44858": {"epss_score": 0.00506, "epss_percentile": 0.65617}, "CVE-2021-44859": {"epss_score": 0.0044, "epss_percentile": 0.62641}, "CVE-2021-44860": {"epss_score": 0.0044, "epss_percentile": 0.62641}, "CVE-2021-44862": {"epss_score": 0.0005, "epss_percentile": 0.15928}, "CVE-2021-44864": {"epss_score": 0.03295, "epss_percentile": 0.86847}, "CVE-2021-44866": {"epss_score": 0.00296, "epss_percentile": 0.52582}, "CVE-2021-44868": {"epss_score": 0.00666, "epss_percentile": 0.70697}, "CVE-2021-44874": {"epss_score": 0.0058, "epss_percentile": 0.6826}, "CVE-2021-44875": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2021-44876": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2021-44877": {"epss_score": 0.00544, "epss_percentile": 0.67136}, "CVE-2021-44878": {"epss_score": 0.00139, "epss_percentile": 0.34571}, "CVE-2021-44879": {"epss_score": 0.00071, "epss_percentile": 0.22042}, "CVE-2021-44880": {"epss_score": 0.16649, "epss_percentile": 0.94707}, "CVE-2021-44881": {"epss_score": 0.08686, "epss_percentile": 0.92201}, "CVE-2021-44882": {"epss_score": 0.08686, "epss_percentile": 0.92201}, "CVE-2021-44886": {"epss_score": 0.00179, "epss_percentile": 0.39816}, "CVE-2021-44892": {"epss_score": 0.01989, "epss_percentile": 0.83169}, "CVE-2021-44896": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2021-44899": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2021-44900": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2021-44901": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2021-44903": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2021-44905": {"epss_score": 0.00568, "epss_percentile": 0.67906}, "CVE-2021-44906": {"epss_score": 0.00882, "epss_percentile": 0.74896}, "CVE-2021-44908": {"epss_score": 0.00456, "epss_percentile": 0.63336}, "CVE-2021-44911": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-44912": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-44915": {"epss_score": 0.00271, "epss_percentile": 0.50343}, "CVE-2021-44916": {"epss_score": 0.04458, "epss_percentile": 0.88717}, "CVE-2021-44917": {"epss_score": 0.00171, "epss_percentile": 0.38824}, "CVE-2021-44918": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-44919": {"epss_score": 0.00266, "epss_percentile": 0.4995}, "CVE-2021-44920": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-44921": {"epss_score": 0.00288, "epss_percentile": 0.5192}, "CVE-2021-44922": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-44923": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-44924": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-44925": {"epss_score": 0.00288, "epss_percentile": 0.5192}, "CVE-2021-44926": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-44927": {"epss_score": 0.00286, "epss_percentile": 0.51783}, "CVE-2021-44935": {"epss_score": 0.00124, "epss_percentile": 0.32397}, "CVE-2021-44937": {"epss_score": 0.00172, "epss_percentile": 0.38992}, "CVE-2021-44942": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2021-44949": {"epss_score": 0.00316, "epss_percentile": 0.54221}, "CVE-2021-44954": {"epss_score": 0.00057, "epss_percentile": 0.18039}, "CVE-2021-44956": {"epss_score": 0.00278, "epss_percentile": 0.50896}, "CVE-2021-44957": {"epss_score": 0.00278, "epss_percentile": 0.50896}, "CVE-2021-44960": {"epss_score": 0.00101, "epss_percentile": 0.28584}, "CVE-2021-44961": {"epss_score": 0.00198, "epss_percentile": 0.41992}, "CVE-2021-44962": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2021-44964": {"epss_score": 0.00185, "epss_percentile": 0.40499}, "CVE-2021-44965": {"epss_score": 0.00553, "epss_percentile": 0.67428}, "CVE-2021-44966": {"epss_score": 0.00125, "epss_percentile": 0.32598}, "CVE-2021-44967": {"epss_score": 0.68264, "epss_percentile": 0.98539}, "CVE-2021-44968": {"epss_score": 0.00079, "epss_percentile": 0.23941}, "CVE-2021-44969": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2021-44970": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-44971": {"epss_score": 0.02922, "epss_percentile": 0.85995}, "CVE-2021-44974": {"epss_score": 0.00349, "epss_percentile": 0.56895}, "CVE-2021-44975": {"epss_score": 0.00317, "epss_percentile": 0.5435}, "CVE-2021-44977": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2021-44978": {"epss_score": 0.02668, "epss_percentile": 0.85379}, "CVE-2021-44981": {"epss_score": 0.07064, "epss_percentile": 0.91223}, "CVE-2021-44983": {"epss_score": 0.00639, "epss_percentile": 0.69939}, "CVE-2021-44988": {"epss_score": 0.00279, "epss_percentile": 0.50926}, "CVE-2021-44992": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2021-44993": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2021-44994": {"epss_score": 0.00198, "epss_percentile": 0.41972}, "CVE-2021-45003": {"epss_score": 0.03368, "epss_percentile": 0.87006}, "CVE-2021-45005": {"epss_score": 0.00164, "epss_percentile": 0.37901}, "CVE-2021-45007": {"epss_score": 0.00406, "epss_percentile": 0.60533}, "CVE-2021-45008": {"epss_score": 0.0128, "epss_percentile": 0.7914}, "CVE-2021-45010": {"epss_score": 0.75454, "epss_percentile": 0.98846}, "CVE-2021-45014": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2021-45015": {"epss_score": 0.0061, "epss_percentile": 0.69161}, "CVE-2021-45017": {"epss_score": 0.00122, "epss_percentile": 0.32025}, "CVE-2021-45018": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-45024": {"epss_score": 0.00506, "epss_percentile": 0.6562}, "CVE-2021-45025": {"epss_score": 0.00176, "epss_percentile": 0.39396}, "CVE-2021-45026": {"epss_score": 0.03329, "epss_percentile": 0.86926}, "CVE-2021-45027": {"epss_score": 0.14201, "epss_percentile": 0.94162}, "CVE-2021-45029": {"epss_score": 0.04185, "epss_percentile": 0.88361}, "CVE-2021-45031": {"epss_score": 0.0035, "epss_percentile": 0.56975}, "CVE-2021-45033": {"epss_score": 0.00283, "epss_percentile": 0.51346}, "CVE-2021-45034": {"epss_score": 0.0063, "epss_percentile": 0.6969}, "CVE-2021-45035": {"epss_score": 0.00133, "epss_percentile": 0.33639}, "CVE-2021-45036": {"epss_score": 0.00439, "epss_percentile": 0.62596}, "CVE-2021-45038": {"epss_score": 0.00403, "epss_percentile": 0.60389}, "CVE-2021-45039": {"epss_score": 0.00976, "epss_percentile": 0.76208}, "CVE-2021-45040": {"epss_score": 0.04547, "epss_percentile": 0.88835}, "CVE-2021-45041": {"epss_score": 0.13282, "epss_percentile": 0.93922}, "CVE-2021-45042": {"epss_score": 0.00435, "epss_percentile": 0.62344}, "CVE-2021-45043": {"epss_score": 0.82486, "epss_percentile": 0.99196}, "CVE-2021-45046": {"epss_score": 0.9434, "epss_percentile": 0.99951}, "CVE-2021-45051": {"epss_score": 0.0237, "epss_percentile": 0.84524}, "CVE-2021-45052": {"epss_score": 0.03125, "epss_percentile": 0.86454}, "CVE-2021-45053": {"epss_score": 0.0123, "epss_percentile": 0.78725}, "CVE-2021-45054": {"epss_score": 0.01583, "epss_percentile": 0.81152}, "CVE-2021-45055": {"epss_score": 0.02015, "epss_percentile": 0.83273}, "CVE-2021-45056": {"epss_score": 0.01579, "epss_percentile": 0.81129}, "CVE-2021-45057": {"epss_score": 0.0123, "epss_percentile": 0.78725}, "CVE-2021-45058": {"epss_score": 0.0123, "epss_percentile": 0.78725}, "CVE-2021-45059": {"epss_score": 0.01919, "epss_percentile": 0.82884}, "CVE-2021-45060": {"epss_score": 0.01392, "epss_percentile": 0.79955}, "CVE-2021-45061": {"epss_score": 0.0167, "epss_percentile": 0.81671}, "CVE-2021-45062": {"epss_score": 0.09052, "epss_percentile": 0.9238}, "CVE-2021-45063": {"epss_score": 0.0237, "epss_percentile": 0.84524}, "CVE-2021-45064": {"epss_score": 0.16254, "epss_percentile": 0.94604}, "CVE-2021-45067": {"epss_score": 0.01836, "epss_percentile": 0.82469}, "CVE-2021-45068": {"epss_score": 0.04229, "epss_percentile": 0.88419}, "CVE-2021-45071": {"epss_score": 0.00478, "epss_percentile": 0.64376}, "CVE-2021-45074": {"epss_score": 0.0033, "epss_percentile": 0.55448}, "CVE-2021-45077": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2021-45078": {"epss_score": 0.00159, "epss_percentile": 0.37391}, "CVE-2021-45079": {"epss_score": 0.00136, "epss_percentile": 0.34114}, "CVE-2021-45081": {"epss_score": 0.00217, "epss_percentile": 0.44331}, "CVE-2021-45082": {"epss_score": 0.00043, "epss_percentile": 0.13124}, "CVE-2021-45083": {"epss_score": 0.0003, "epss_percentile": 0.08019}, "CVE-2021-45085": {"epss_score": 0.00289, "epss_percentile": 0.52011}, "CVE-2021-45086": {"epss_score": 0.00213, "epss_percentile": 0.43834}, "CVE-2021-45087": {"epss_score": 0.00289, "epss_percentile": 0.52011}, "CVE-2021-45088": {"epss_score": 0.00289, "epss_percentile": 0.52011}, "CVE-2021-45089": {"epss_score": 0.00083, "epss_percentile": 0.247}, "CVE-2021-45090": {"epss_score": 0.03822, "epss_percentile": 0.87786}, "CVE-2021-45091": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2021-45092": {"epss_score": 0.78911, "epss_percentile": 0.99011}, "CVE-2021-45094": {"epss_score": 0.00083, "epss_percentile": 0.2463}, "CVE-2021-45095": {"epss_score": 0.00033, "epss_percentile": 0.09138}, "CVE-2021-45096": {"epss_score": 0.00472, "epss_percentile": 0.6404}, "CVE-2021-45097": {"epss_score": 0.00119, "epss_percentile": 0.31631}, "CVE-2021-45098": {"epss_score": 0.00646, "epss_percentile": 0.70146}, "CVE-2021-45099": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2021-45100": {"epss_score": 0.00123, "epss_percentile": 0.32209}, "CVE-2021-45101": {"epss_score": 0.00303, "epss_percentile": 0.53208}, "CVE-2021-45102": {"epss_score": 0.00342, "epss_percentile": 0.56396}, "CVE-2021-45103": {"epss_score": 0.00282, "epss_percentile": 0.51274}, "CVE-2021-45104": {"epss_score": 0.00116, "epss_percentile": 0.31099}, "CVE-2021-45105": {"epss_score": 0.70431, "epss_percentile": 0.98632}, "CVE-2021-45106": {"epss_score": 0.00219, "epss_percentile": 0.44441}, "CVE-2021-45111": {"epss_score": 0.00955, "epss_percentile": 0.75919}, "CVE-2021-45115": {"epss_score": 0.00423, "epss_percentile": 0.61598}, "CVE-2021-45116": {"epss_score": 0.00358, "epss_percentile": 0.5749}, "CVE-2021-45117": {"epss_score": 0.00522, "epss_percentile": 0.66265}, "CVE-2021-45222": {"epss_score": 0.00429, "epss_percentile": 0.61988}, "CVE-2021-45223": {"epss_score": 0.00537, "epss_percentile": 0.66886}, "CVE-2021-45224": {"epss_score": 0.00486, "epss_percentile": 0.64769}, "CVE-2021-45225": {"epss_score": 0.00486, "epss_percentile": 0.64769}, "CVE-2021-45226": {"epss_score": 0.00305, "epss_percentile": 0.53375}, "CVE-2021-45227": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-45228": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-45229": {"epss_score": 0.01563, "epss_percentile": 0.81058}, "CVE-2021-45230": {"epss_score": 0.01322, "epss_percentile": 0.79449}, "CVE-2021-45231": {"epss_score": 0.00041, "epss_percentile": 0.12289}, "CVE-2021-45232": {"epss_score": 0.93877, "epss_percentile": 0.99862}, "CVE-2021-45252": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-45253": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-45255": {"epss_score": 0.00263, "epss_percentile": 0.49519}, "CVE-2021-45256": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-45257": {"epss_score": 0.00266, "epss_percentile": 0.49917}, "CVE-2021-45258": {"epss_score": 0.00158, "epss_percentile": 0.37257}, "CVE-2021-45259": {"epss_score": 0.00288, "epss_percentile": 0.5192}, "CVE-2021-45260": {"epss_score": 0.00288, "epss_percentile": 0.5192}, "CVE-2021-45261": {"epss_score": 0.00265, "epss_percentile": 0.49781}, "CVE-2021-45262": {"epss_score": 0.00103, "epss_percentile": 0.29043}, "CVE-2021-45263": {"epss_score": 0.00103, "epss_percentile": 0.29043}, "CVE-2021-45266": {"epss_score": 0.00281, "epss_percentile": 0.51137}, "CVE-2021-45267": {"epss_score": 0.00104, "epss_percentile": 0.29182}, "CVE-2021-45268": {"epss_score": 0.00449, "epss_percentile": 0.63035}, "CVE-2021-45281": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-45286": {"epss_score": 0.00129, "epss_percentile": 0.33087}, "CVE-2021-45288": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-45289": {"epss_score": 0.00266, "epss_percentile": 0.49917}, "CVE-2021-45290": {"epss_score": 0.00362, "epss_percentile": 0.57795}, "CVE-2021-45291": {"epss_score": 0.00103, "epss_percentile": 0.29043}, "CVE-2021-45292": {"epss_score": 0.00104, "epss_percentile": 0.29182}, "CVE-2021-45293": {"epss_score": 0.00179, "epss_percentile": 0.39791}, "CVE-2021-45297": {"epss_score": 0.00104, "epss_percentile": 0.29182}, "CVE-2021-45310": {"epss_score": 0.00324, "epss_percentile": 0.54937}, "CVE-2021-45325": {"epss_score": 0.00302, "epss_percentile": 0.53093}, "CVE-2021-45326": {"epss_score": 0.00214, "epss_percentile": 0.43968}, "CVE-2021-45327": {"epss_score": 0.00872, "epss_percentile": 0.74738}, "CVE-2021-45328": {"epss_score": 0.0018, "epss_percentile": 0.39909}, "CVE-2021-45329": {"epss_score": 0.00666, "epss_percentile": 0.70688}, "CVE-2021-45330": {"epss_score": 0.01128, "epss_percentile": 0.77825}, "CVE-2021-45331": {"epss_score": 0.00228, "epss_percentile": 0.4548}, "CVE-2021-45334": {"epss_score": 0.00242, "epss_percentile": 0.47394}, "CVE-2021-45335": {"epss_score": 0.00124, "epss_percentile": 0.32419}, "CVE-2021-45336": {"epss_score": 0.00074, "epss_percentile": 0.22847}, "CVE-2021-45337": {"epss_score": 0.00074, "epss_percentile": 0.22847}, "CVE-2021-45338": {"epss_score": 0.0007, "epss_percentile": 0.21783}, "CVE-2021-45339": {"epss_score": 0.00034, "epss_percentile": 0.09558}, "CVE-2021-45340": {"epss_score": 0.00163, "epss_percentile": 0.37813}, "CVE-2021-45341": {"epss_score": 0.01952, "epss_percentile": 0.83022}, "CVE-2021-45342": {"epss_score": 0.01744, "epss_percentile": 0.82061}, "CVE-2021-45343": {"epss_score": 0.00089, "epss_percentile": 0.25802}, "CVE-2021-45345": {"epss_score": 0.00283, "epss_percentile": 0.51371}, "CVE-2021-45346": {"epss_score": 0.00319, "epss_percentile": 0.54555}, "CVE-2021-45347": {"epss_score": 0.00222, "epss_percentile": 0.44754}, "CVE-2021-45348": {"epss_score": 0.00346, "epss_percentile": 0.56608}, "CVE-2021-45357": {"epss_score": 0.00321, "epss_percentile": 0.54644}, "CVE-2021-45364": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2021-45379": {"epss_score": 0.00299, "epss_percentile": 0.52865}, "CVE-2021-45380": {"epss_score": 0.01932, "epss_percentile": 0.82945}, "CVE-2021-45382": {"epss_score": 0.9423, "epss_percentile": 0.99922}, "CVE-2021-45385": {"epss_score": 0.00239, "epss_percentile": 0.46886}, "CVE-2021-45386": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-45387": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-45389": {"epss_score": 0.006, "epss_percentile": 0.68833}, "CVE-2021-45391": {"epss_score": 0.01, "epss_percentile": 0.7649}, "CVE-2021-45392": {"epss_score": 0.02707, "epss_percentile": 0.8547}, "CVE-2021-45394": {"epss_score": 0.00377, "epss_percentile": 0.58761}, "CVE-2021-45401": {"epss_score": 0.11787, "epss_percentile": 0.93476}, "CVE-2021-45402": {"epss_score": 0.00069, "epss_percentile": 0.21599}, "CVE-2021-45406": {"epss_score": 0.00946, "epss_percentile": 0.75808}, "CVE-2021-45408": {"epss_score": 0.00207, "epss_percentile": 0.43155}, "CVE-2021-45411": {"epss_score": 0.03206, "epss_percentile": 0.86635}, "CVE-2021-45414": {"epss_score": 0.02606, "epss_percentile": 0.85223}, "CVE-2021-45416": {"epss_score": 0.23057, "epss_percentile": 0.95726}, "CVE-2021-45417": {"epss_score": 0.00038, "epss_percentile": 0.11208}, "CVE-2021-45418": {"epss_score": 0.01298, "epss_percentile": 0.79275}, "CVE-2021-45419": {"epss_score": 0.00232, "epss_percentile": 0.45905}, "CVE-2021-45420": {"epss_score": 0.81099, "epss_percentile": 0.99119}, "CVE-2021-45421": {"epss_score": 0.00386, "epss_percentile": 0.59253}, "CVE-2021-45422": {"epss_score": 0.08607, "epss_percentile": 0.92148}, "CVE-2021-45423": {"epss_score": 0.00567, "epss_percentile": 0.67839}, "CVE-2021-45425": {"epss_score": 0.01667, "epss_percentile": 0.81658}, "CVE-2021-45427": {"epss_score": 0.0225, "epss_percentile": 0.84157}, "CVE-2021-45428": {"epss_score": 0.91545, "epss_percentile": 0.99651}, "CVE-2021-45429": {"epss_score": 0.00067, "epss_percentile": 0.21085}, "CVE-2021-45435": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2021-45440": {"epss_score": 0.00061, "epss_percentile": 0.19415}, "CVE-2021-45441": {"epss_score": 0.00029, "epss_percentile": 0.07784}, "CVE-2021-45442": {"epss_score": 0.00056, "epss_percentile": 0.17708}, "CVE-2021-45444": {"epss_score": 0.00114, "epss_percentile": 0.30761}, "CVE-2021-45445": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2021-45446": {"epss_score": 0.0019, "epss_percentile": 0.41138}, "CVE-2021-45447": {"epss_score": 0.00147, "epss_percentile": 0.35694}, "CVE-2021-45448": {"epss_score": 0.00432, "epss_percentile": 0.6216}, "CVE-2021-45449": {"epss_score": 0.00053, "epss_percentile": 0.16983}, "CVE-2021-45450": {"epss_score": 0.00057, "epss_percentile": 0.1812}, "CVE-2021-45451": {"epss_score": 0.00143, "epss_percentile": 0.35205}, "CVE-2021-45452": {"epss_score": 0.00293, "epss_percentile": 0.52329}, "CVE-2021-45454": {"epss_score": 0.00348, "epss_percentile": 0.56805}, "CVE-2021-45456": {"epss_score": 0.58277, "epss_percentile": 0.98106}, "CVE-2021-45457": {"epss_score": 0.01138, "epss_percentile": 0.77933}, "CVE-2021-45458": {"epss_score": 0.00631, "epss_percentile": 0.6971}, "CVE-2021-45459": {"epss_score": 0.03882, "epss_percentile": 0.87896}, "CVE-2021-45460": {"epss_score": 0.00473, "epss_percentile": 0.64099}, "CVE-2021-45461": {"epss_score": 0.03726, "epss_percentile": 0.87632}, "CVE-2021-45462": {"epss_score": 0.00356, "epss_percentile": 0.57335}, "CVE-2021-45463": {"epss_score": 0.0181, "epss_percentile": 0.82363}, "CVE-2021-45464": {"epss_score": 0.00058, "epss_percentile": 0.18569}, "CVE-2021-45465": {"epss_score": 0.0004, "epss_percentile": 0.11976}, "CVE-2021-45466": {"epss_score": 0.0421, "epss_percentile": 0.88399}, "CVE-2021-45467": {"epss_score": 0.85048, "epss_percentile": 0.99314}, "CVE-2021-45468": {"epss_score": 0.36095, "epss_percentile": 0.96955}, "CVE-2021-45469": {"epss_score": 0.00067, "epss_percentile": 0.21174}, "CVE-2021-45470": {"epss_score": 0.00408, "epss_percentile": 0.60647}, "CVE-2021-45471": {"epss_score": 0.00311, "epss_percentile": 0.53818}, "CVE-2021-45472": {"epss_score": 0.00256, "epss_percentile": 0.48828}, "CVE-2021-45473": {"epss_score": 0.00326, "epss_percentile": 0.55039}, "CVE-2021-45474": {"epss_score": 0.00256, "epss_percentile": 0.48828}, "CVE-2021-45475": {"epss_score": 0.0031, "epss_percentile": 0.5377}, "CVE-2021-45476": {"epss_score": 0.00335, "epss_percentile": 0.55799}, "CVE-2021-45477": {"epss_score": 0.00098, "epss_percentile": 0.27637}, "CVE-2021-45478": {"epss_score": 0.00098, "epss_percentile": 0.27637}, "CVE-2021-45479": {"epss_score": 0.00106, "epss_percentile": 0.29501}, "CVE-2021-45480": {"epss_score": 0.00043, "epss_percentile": 0.13071}, "CVE-2021-45481": {"epss_score": 0.00028, "epss_percentile": 0.07571}, "CVE-2021-45482": {"epss_score": 0.00028, "epss_percentile": 0.07571}, "CVE-2021-45483": {"epss_score": 0.00028, "epss_percentile": 0.07571}, "CVE-2021-45484": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-45485": {"epss_score": 0.00579, "epss_percentile": 0.68231}, "CVE-2021-45486": {"epss_score": 0.00017, "epss_percentile": 0.03175}, "CVE-2021-45487": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-45488": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-45489": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-45490": {"epss_score": 0.00129, "epss_percentile": 0.33204}, "CVE-2021-45491": {"epss_score": 0.00146, "epss_percentile": 0.35623}, "CVE-2021-45492": {"epss_score": 0.00031, "epss_percentile": 0.08631}, "CVE-2021-45493": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2021-45494": {"epss_score": 0.00171, "epss_percentile": 0.38796}, "CVE-2021-45495": {"epss_score": 0.00313, "epss_percentile": 0.54015}, "CVE-2021-45496": {"epss_score": 0.00178, "epss_percentile": 0.39702}, "CVE-2021-45497": {"epss_score": 0.00124, "epss_percentile": 0.3236}, "CVE-2021-45498": {"epss_score": 0.00252, "epss_percentile": 0.48356}, "CVE-2021-45499": {"epss_score": 0.00513, "epss_percentile": 0.65927}, "CVE-2021-45500": {"epss_score": 0.00084, "epss_percentile": 0.24993}, "CVE-2021-45501": {"epss_score": 0.00154, "epss_percentile": 0.36674}, "CVE-2021-45502": {"epss_score": 0.00346, "epss_percentile": 0.56606}, "CVE-2021-45503": {"epss_score": 0.00079, "epss_percentile": 0.23881}, "CVE-2021-45504": {"epss_score": 0.00396, "epss_percentile": 0.59861}, "CVE-2021-45505": {"epss_score": 0.00112, "epss_percentile": 0.30416}, "CVE-2021-45506": {"epss_score": 0.00112, "epss_percentile": 0.30416}, "CVE-2021-45507": {"epss_score": 0.01354, "epss_percentile": 0.79701}, "CVE-2021-45508": {"epss_score": 0.00396, "epss_percentile": 0.59861}, "CVE-2021-45509": {"epss_score": 0.00305, "epss_percentile": 0.53331}, "CVE-2021-45510": {"epss_score": 0.00064, "epss_percentile": 0.20106}, "CVE-2021-45511": {"epss_score": 0.49501, "epss_percentile": 0.97691}, "CVE-2021-45512": {"epss_score": 0.00157, "epss_percentile": 0.37108}, "CVE-2021-45513": {"epss_score": 0.00244, "epss_percentile": 0.47522}, "CVE-2021-45514": {"epss_score": 0.00244, "epss_percentile": 0.47522}, "CVE-2021-45515": {"epss_score": 0.00089, "epss_percentile": 0.2593}, "CVE-2021-45516": {"epss_score": 0.00047, "epss_percentile": 0.14621}, "CVE-2021-45517": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2021-45518": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2021-45519": {"epss_score": 0.00064, "epss_percentile": 0.20391}, "CVE-2021-45520": {"epss_score": 0.00135, "epss_percentile": 0.34028}, "CVE-2021-45521": {"epss_score": 0.0009, "epss_percentile": 0.26008}, "CVE-2021-45522": {"epss_score": 0.00165, "epss_percentile": 0.38009}, "CVE-2021-45523": {"epss_score": 0.00193, "epss_percentile": 0.41462}, "CVE-2021-45524": {"epss_score": 0.00279, "epss_percentile": 0.50998}, "CVE-2021-45525": {"epss_score": 0.00222, "epss_percentile": 0.44716}, "CVE-2021-45526": {"epss_score": 0.00259, "epss_percentile": 0.4903}, "CVE-2021-45527": {"epss_score": 0.01241, "epss_percentile": 0.78813}, "CVE-2021-45528": {"epss_score": 0.00171, "epss_percentile": 0.3879}, "CVE-2021-45529": {"epss_score": 0.00171, "epss_percentile": 0.3879}, "CVE-2021-45530": {"epss_score": 0.00502, "epss_percentile": 0.65393}, "CVE-2021-45531": {"epss_score": 0.0094, "epss_percentile": 0.75726}, "CVE-2021-45532": {"epss_score": 0.00107, "epss_percentile": 0.29644}, "CVE-2021-45533": {"epss_score": 0.00136, "epss_percentile": 0.34088}, "CVE-2021-45534": {"epss_score": 0.01266, "epss_percentile": 0.79013}, "CVE-2021-45535": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2021-45536": {"epss_score": 0.00164, "epss_percentile": 0.37911}, "CVE-2021-45537": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45538": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2021-45539": {"epss_score": 0.00136, "epss_percentile": 0.34088}, "CVE-2021-45540": {"epss_score": 0.00136, "epss_percentile": 0.34088}, "CVE-2021-45541": {"epss_score": 0.01885, "epss_percentile": 0.82707}, "CVE-2021-45542": {"epss_score": 0.00107, "epss_percentile": 0.29608}, "CVE-2021-45543": {"epss_score": 0.00107, "epss_percentile": 0.29608}, "CVE-2021-45544": {"epss_score": 0.0143, "epss_percentile": 0.80231}, "CVE-2021-45545": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45546": {"epss_score": 0.0143, "epss_percentile": 0.80231}, "CVE-2021-45547": {"epss_score": 0.0143, "epss_percentile": 0.80231}, "CVE-2021-45548": {"epss_score": 0.00818, "epss_percentile": 0.7386}, "CVE-2021-45549": {"epss_score": 0.00405, "epss_percentile": 0.60505}, "CVE-2021-45550": {"epss_score": 0.00081, "epss_percentile": 0.24279}, "CVE-2021-45551": {"epss_score": 0.02222, "epss_percentile": 0.84053}, "CVE-2021-45552": {"epss_score": 0.00176, "epss_percentile": 0.39406}, "CVE-2021-45553": {"epss_score": 0.0116, "epss_percentile": 0.78134}, "CVE-2021-45554": {"epss_score": 0.00136, "epss_percentile": 0.34088}, "CVE-2021-45555": {"epss_score": 0.00269, "epss_percentile": 0.50177}, "CVE-2021-45556": {"epss_score": 0.00791, "epss_percentile": 0.73387}, "CVE-2021-45557": {"epss_score": 0.0101, "epss_percentile": 0.76603}, "CVE-2021-45558": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45559": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45560": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2021-45561": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45562": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2021-45563": {"epss_score": 0.00089, "epss_percentile": 0.25851}, "CVE-2021-45564": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45565": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45566": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45567": {"epss_score": 0.00138, "epss_percentile": 0.3435}, "CVE-2021-45568": {"epss_score": 0.00138, "epss_percentile": 0.3435}, "CVE-2021-45569": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45570": {"epss_score": 0.00131, "epss_percentile": 0.33383}, "CVE-2021-45571": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45572": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45573": {"epss_score": 0.0014, "epss_percentile": 0.34673}, "CVE-2021-45574": {"epss_score": 0.00131, "epss_percentile": 0.33383}, "CVE-2021-45575": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45576": {"epss_score": 0.00178, "epss_percentile": 0.39667}, "CVE-2021-45577": {"epss_score": 0.00138, "epss_percentile": 0.34531}, "CVE-2021-45578": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2021-45579": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45580": {"epss_score": 0.00275, "epss_percentile": 0.50689}, "CVE-2021-45581": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2021-45582": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45583": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45584": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2021-45585": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45586": {"epss_score": 0.00275, "epss_percentile": 0.50689}, "CVE-2021-45587": {"epss_score": 0.00175, "epss_percentile": 0.39338}, "CVE-2021-45588": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45589": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2021-45590": {"epss_score": 0.00131, "epss_percentile": 0.33383}, "CVE-2021-45591": {"epss_score": 0.00126, "epss_percentile": 0.32681}, "CVE-2021-45592": {"epss_score": 0.00145, "epss_percentile": 0.35392}, "CVE-2021-45593": {"epss_score": 0.00103, "epss_percentile": 0.29041}, "CVE-2021-45594": {"epss_score": 0.00104, "epss_percentile": 0.29144}, "CVE-2021-45595": {"epss_score": 0.00238, "epss_percentile": 0.46785}, "CVE-2021-45596": {"epss_score": 0.0143, "epss_percentile": 0.80231}, "CVE-2021-45597": {"epss_score": 0.01462, "epss_percentile": 0.80436}, "CVE-2021-45598": {"epss_score": 0.00978, "epss_percentile": 0.76252}, "CVE-2021-45599": {"epss_score": 0.00978, "epss_percentile": 0.76252}, "CVE-2021-45600": {"epss_score": 0.02198, "epss_percentile": 0.83968}, "CVE-2021-45601": {"epss_score": 0.0143, "epss_percentile": 0.80231}, "CVE-2021-45602": {"epss_score": 0.00109, "epss_percentile": 0.30069}, "CVE-2021-45603": {"epss_score": 0.00037, "epss_percentile": 0.10655}, "CVE-2021-45604": {"epss_score": 0.00083, "epss_percentile": 0.24758}, "CVE-2021-45605": {"epss_score": 0.0015, "epss_percentile": 0.36069}, "CVE-2021-45606": {"epss_score": 0.00279, "epss_percentile": 0.50938}, "CVE-2021-45607": {"epss_score": 0.00288, "epss_percentile": 0.51865}, "CVE-2021-45608": {"epss_score": 0.05046, "epss_percentile": 0.89435}, "CVE-2021-45609": {"epss_score": 0.00342, "epss_percentile": 0.56384}, "CVE-2021-45610": {"epss_score": 0.00294, "epss_percentile": 0.52435}, "CVE-2021-45611": {"epss_score": 0.00342, "epss_percentile": 0.56384}, "CVE-2021-45612": {"epss_score": 0.00601, "epss_percentile": 0.68835}, "CVE-2021-45613": {"epss_score": 0.01527, "epss_percentile": 0.80868}, "CVE-2021-45614": {"epss_score": 0.00924, "epss_percentile": 0.75521}, "CVE-2021-45615": {"epss_score": 0.00135, "epss_percentile": 0.34042}, "CVE-2021-45616": {"epss_score": 0.01527, "epss_percentile": 0.80868}, "CVE-2021-45617": {"epss_score": 0.01527, "epss_percentile": 0.80868}, "CVE-2021-45618": {"epss_score": 0.01527, "epss_percentile": 0.80868}, "CVE-2021-45619": {"epss_score": 0.01022, "epss_percentile": 0.76757}, "CVE-2021-45620": {"epss_score": 0.01658, "epss_percentile": 0.81607}, "CVE-2021-45621": {"epss_score": 0.01527, "epss_percentile": 0.80868}, "CVE-2021-45622": {"epss_score": 0.02666, "epss_percentile": 0.85377}, "CVE-2021-45623": {"epss_score": 0.01614, "epss_percentile": 0.81346}, "CVE-2021-45624": {"epss_score": 0.01194, "epss_percentile": 0.78423}, "CVE-2021-45625": {"epss_score": 0.01194, "epss_percentile": 0.78423}, "CVE-2021-45626": {"epss_score": 0.0021, "epss_percentile": 0.43489}, "CVE-2021-45627": {"epss_score": 0.01618, "epss_percentile": 0.81373}, "CVE-2021-45628": {"epss_score": 0.00823, "epss_percentile": 0.73925}, "CVE-2021-45629": {"epss_score": 0.00286, "epss_percentile": 0.5175}, "CVE-2021-45630": {"epss_score": 0.01618, "epss_percentile": 0.81373}, "CVE-2021-45631": {"epss_score": 0.00895, "epss_percentile": 0.75104}, "CVE-2021-45632": {"epss_score": 0.00286, "epss_percentile": 0.5175}, "CVE-2021-45633": {"epss_score": 0.0021, "epss_percentile": 0.43489}, "CVE-2021-45634": {"epss_score": 0.00368, "epss_percentile": 0.58186}, "CVE-2021-45635": {"epss_score": 0.00823, "epss_percentile": 0.73925}, "CVE-2021-45636": {"epss_score": 0.00116, "epss_percentile": 0.31083}, "CVE-2021-45637": {"epss_score": 0.00653, "epss_percentile": 0.70331}, "CVE-2021-45638": {"epss_score": 0.00342, "epss_percentile": 0.56355}, "CVE-2021-45639": {"epss_score": 0.00251, "epss_percentile": 0.48285}, "CVE-2021-45640": {"epss_score": 0.00585, "epss_percentile": 0.68408}, "CVE-2021-45641": {"epss_score": 0.00374, "epss_percentile": 0.58539}, "CVE-2021-45642": {"epss_score": 0.00516, "epss_percentile": 0.66058}, "CVE-2021-45643": {"epss_score": 0.00067, "epss_percentile": 0.20979}, "CVE-2021-45644": {"epss_score": 0.00308, "epss_percentile": 0.53619}, "CVE-2021-45645": {"epss_score": 0.00268, "epss_percentile": 0.50021}, "CVE-2021-45646": {"epss_score": 0.00307, "epss_percentile": 0.53534}, "CVE-2021-45647": {"epss_score": 0.00265, "epss_percentile": 0.49774}, "CVE-2021-45648": {"epss_score": 0.00307, "epss_percentile": 0.53534}, "CVE-2021-45649": {"epss_score": 0.00049, "epss_percentile": 0.1561}, "CVE-2021-45650": {"epss_score": 0.00268, "epss_percentile": 0.50021}, "CVE-2021-45651": {"epss_score": 0.00158, "epss_percentile": 0.3729}, "CVE-2021-45652": {"epss_score": 0.00388, "epss_percentile": 0.59348}, "CVE-2021-45653": {"epss_score": 0.00675, "epss_percentile": 0.70915}, "CVE-2021-45654": {"epss_score": 0.00388, "epss_percentile": 0.59348}, "CVE-2021-45655": {"epss_score": 0.00101, "epss_percentile": 0.28702}, "CVE-2021-45656": {"epss_score": 0.00067, "epss_percentile": 0.211}, "CVE-2021-45657": {"epss_score": 0.00115, "epss_percentile": 0.30931}, "CVE-2021-45658": {"epss_score": 0.00244, "epss_percentile": 0.47623}, "CVE-2021-45659": {"epss_score": 0.00108, "epss_percentile": 0.29827}, "CVE-2021-45660": {"epss_score": 0.00115, "epss_percentile": 0.30931}, "CVE-2021-45661": {"epss_score": 0.00067, "epss_percentile": 0.211}, "CVE-2021-45662": {"epss_score": 0.00305, "epss_percentile": 0.53315}, "CVE-2021-45663": {"epss_score": 0.00305, "epss_percentile": 0.53315}, "CVE-2021-45664": {"epss_score": 0.00323, "epss_percentile": 0.54869}, "CVE-2021-45665": {"epss_score": 0.00274, "epss_percentile": 0.50575}, "CVE-2021-45666": {"epss_score": 0.00274, "epss_percentile": 0.50575}, "CVE-2021-45667": {"epss_score": 0.00364, "epss_percentile": 0.5791}, "CVE-2021-45668": {"epss_score": 0.00217, "epss_percentile": 0.44268}, "CVE-2021-45669": {"epss_score": 0.00274, "epss_percentile": 0.50508}, "CVE-2021-45670": {"epss_score": 0.00364, "epss_percentile": 0.5791}, "CVE-2021-45671": {"epss_score": 0.00217, "epss_percentile": 0.44268}, "CVE-2021-45672": {"epss_score": 0.00256, "epss_percentile": 0.48779}, "CVE-2021-45673": {"epss_score": 0.00197, "epss_percentile": 0.41967}, "CVE-2021-45674": {"epss_score": 0.00274, "epss_percentile": 0.50508}, "CVE-2021-45675": {"epss_score": 0.00185, "epss_percentile": 0.40509}, "CVE-2021-45676": {"epss_score": 0.00217, "epss_percentile": 0.44268}, "CVE-2021-45677": {"epss_score": 0.00371, "epss_percentile": 0.58379}, "CVE-2021-45678": {"epss_score": 0.00521, "epss_percentile": 0.66236}, "CVE-2021-45679": {"epss_score": 0.00476, "epss_percentile": 0.6426}, "CVE-2021-45680": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-45681": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-45682": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45683": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45684": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-45685": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45686": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45687": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45688": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45689": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-45690": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-45691": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45692": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-45693": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45694": {"epss_score": 0.00285, "epss_percentile": 0.51538}, "CVE-2021-45695": {"epss_score": 0.00931, "epss_percentile": 0.75615}, "CVE-2021-45696": {"epss_score": 0.00203, "epss_percentile": 0.42502}, "CVE-2021-45697": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45698": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45699": {"epss_score": 0.0055, "epss_percentile": 0.67325}, "CVE-2021-45700": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2021-45701": {"epss_score": 0.00441, "epss_percentile": 0.6269}, "CVE-2021-45702": {"epss_score": 0.00393, "epss_percentile": 0.59709}, "CVE-2021-45703": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45704": {"epss_score": 0.00336, "epss_percentile": 0.55925}, "CVE-2021-45705": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45706": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2021-45707": {"epss_score": 0.00466, "epss_percentile": 0.63805}, "CVE-2021-45708": {"epss_score": 0.00291, "epss_percentile": 0.52156}, "CVE-2021-45709": {"epss_score": 0.00233, "epss_percentile": 0.46048}, "CVE-2021-45710": {"epss_score": 0.00149, "epss_percentile": 0.35945}, "CVE-2021-45711": {"epss_score": 0.00578, "epss_percentile": 0.68183}, "CVE-2021-45712": {"epss_score": 0.00483, "epss_percentile": 0.64611}, "CVE-2021-45713": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2021-45714": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2021-45715": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2021-45716": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2021-45717": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2021-45718": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2021-45719": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2021-45720": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2021-45721": {"epss_score": 0.00226, "epss_percentile": 0.45238}, "CVE-2021-45729": {"epss_score": 0.00309, "epss_percentile": 0.53699}, "CVE-2021-45730": {"epss_score": 0.00164, "epss_percentile": 0.37892}, "CVE-2021-45732": {"epss_score": 0.00288, "epss_percentile": 0.51979}, "CVE-2021-45733": {"epss_score": 0.2581, "epss_percentile": 0.96075}, "CVE-2021-45734": {"epss_score": 0.00433, "epss_percentile": 0.62198}, "CVE-2021-45735": {"epss_score": 0.00248, "epss_percentile": 0.47924}, "CVE-2021-45736": {"epss_score": 0.00407, "epss_percentile": 0.60572}, "CVE-2021-45737": {"epss_score": 0.00407, "epss_percentile": 0.60572}, "CVE-2021-45738": {"epss_score": 0.2581, "epss_percentile": 0.96075}, "CVE-2021-45739": {"epss_score": 0.00407, "epss_percentile": 0.60572}, "CVE-2021-45740": {"epss_score": 0.00557, "epss_percentile": 0.67538}, "CVE-2021-45741": {"epss_score": 0.00407, "epss_percentile": 0.60572}, "CVE-2021-45742": {"epss_score": 0.20315, "epss_percentile": 0.95324}, "CVE-2021-45744": {"epss_score": 0.02999, "epss_percentile": 0.8616}, "CVE-2021-45745": {"epss_score": 0.02675, "epss_percentile": 0.85401}, "CVE-2021-45746": {"epss_score": 0.00477, "epss_percentile": 0.64297}, "CVE-2021-45756": {"epss_score": 0.00853, "epss_percentile": 0.74435}, "CVE-2021-45757": {"epss_score": 0.00661, "epss_percentile": 0.70586}, "CVE-2021-45760": {"epss_score": 0.0022, "epss_percentile": 0.44629}, "CVE-2021-45761": {"epss_score": 0.0024, "epss_percentile": 0.47216}, "CVE-2021-45762": {"epss_score": 0.00088, "epss_percentile": 0.25717}, "CVE-2021-45763": {"epss_score": 0.00129, "epss_percentile": 0.33098}, "CVE-2021-45764": {"epss_score": 0.00096, "epss_percentile": 0.27407}, "CVE-2021-45767": {"epss_score": 0.00096, "epss_percentile": 0.27407}, "CVE-2021-45769": {"epss_score": 0.00281, "epss_percentile": 0.51137}, "CVE-2021-45773": {"epss_score": 0.00281, "epss_percentile": 0.51137}, "CVE-2021-45783": {"epss_score": 0.03496, "epss_percentile": 0.87238}, "CVE-2021-45785": {"epss_score": 0.00069, "epss_percentile": 0.21569}, "CVE-2021-45786": {"epss_score": 0.00412, "epss_percentile": 0.60918}, "CVE-2021-45787": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-45788": {"epss_score": 0.1339, "epss_percentile": 0.9395}, "CVE-2021-45789": {"epss_score": 0.003, "epss_percentile": 0.52919}, "CVE-2021-45790": {"epss_score": 0.32365, "epss_percentile": 0.96692}, "CVE-2021-45791": {"epss_score": 0.00316, "epss_percentile": 0.54297}, "CVE-2021-45792": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2021-45793": {"epss_score": 0.11747, "epss_percentile": 0.93465}, "CVE-2021-45794": {"epss_score": 0.00246, "epss_percentile": 0.47765}, "CVE-2021-45802": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-45803": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2021-45806": {"epss_score": 0.01283, "epss_percentile": 0.79165}, "CVE-2021-45807": {"epss_score": 0.0219, "epss_percentile": 0.83932}, "CVE-2021-45808": {"epss_score": 0.00616, "epss_percentile": 0.69336}, "CVE-2021-45809": {"epss_score": 0.01048, "epss_percentile": 0.77051}, "CVE-2021-45810": {"epss_score": 0.00338, "epss_percentile": 0.5611}, "CVE-2021-45811": {"epss_score": 0.47409, "epss_percentile": 0.97586}, "CVE-2021-45812": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-45813": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-45814": {"epss_score": 0.00364, "epss_percentile": 0.57958}, "CVE-2021-45815": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-45818": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-45819": {"epss_score": 0.00036, "epss_percentile": 0.10389}, "CVE-2021-45821": {"epss_score": 0.01859, "epss_percentile": 0.82581}, "CVE-2021-45822": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2021-45829": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-45830": {"epss_score": 0.00253, "epss_percentile": 0.48415}, "CVE-2021-45831": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-45832": {"epss_score": 0.00161, "epss_percentile": 0.37591}, "CVE-2021-45833": {"epss_score": 0.00253, "epss_percentile": 0.48415}, "CVE-2021-45834": {"epss_score": 0.01353, "epss_percentile": 0.79696}, "CVE-2021-45835": {"epss_score": 0.18078, "epss_percentile": 0.94953}, "CVE-2021-45836": {"epss_score": 0.00716, "epss_percentile": 0.71854}, "CVE-2021-45837": {"epss_score": 0.81079, "epss_percentile": 0.99118}, "CVE-2021-45839": {"epss_score": 0.53996, "epss_percentile": 0.97906}, "CVE-2021-45840": {"epss_score": 0.01953, "epss_percentile": 0.83024}, "CVE-2021-45841": {"epss_score": 0.65511, "epss_percentile": 0.98423}, "CVE-2021-45842": {"epss_score": 0.00614, "epss_percentile": 0.69284}, "CVE-2021-45843": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2021-45844": {"epss_score": 0.00462, "epss_percentile": 0.63572}, "CVE-2021-45845": {"epss_score": 0.02154, "epss_percentile": 0.838}, "CVE-2021-45846": {"epss_score": 0.00266, "epss_percentile": 0.49917}, "CVE-2021-45847": {"epss_score": 0.00196, "epss_percentile": 0.41763}, "CVE-2021-45848": {"epss_score": 0.00482, "epss_percentile": 0.64547}, "CVE-2021-45851": {"epss_score": 0.00922, "epss_percentile": 0.75493}, "CVE-2021-45852": {"epss_score": 0.00198, "epss_percentile": 0.42035}, "CVE-2021-45856": {"epss_score": 0.00606, "epss_percentile": 0.69027}, "CVE-2021-45860": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-45861": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-45863": {"epss_score": 0.00146, "epss_percentile": 0.35639}, "CVE-2021-45864": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-45865": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-45866": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-45868": {"epss_score": 0.00144, "epss_percentile": 0.35281}, "CVE-2021-45876": {"epss_score": 0.04336, "epss_percentile": 0.88563}, "CVE-2021-45877": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2021-45878": {"epss_score": 0.00257, "epss_percentile": 0.48877}, "CVE-2021-45884": {"epss_score": 0.00264, "epss_percentile": 0.49692}, "CVE-2021-45885": {"epss_score": 0.0024, "epss_percentile": 0.47203}, "CVE-2021-45886": {"epss_score": 0.00146, "epss_percentile": 0.35567}, "CVE-2021-45887": {"epss_score": 0.05516, "epss_percentile": 0.8995}, "CVE-2021-45888": {"epss_score": 0.0038, "epss_percentile": 0.58927}, "CVE-2021-45889": {"epss_score": 0.0037, "epss_percentile": 0.58321}, "CVE-2021-45890": {"epss_score": 0.0057, "epss_percentile": 0.67941}, "CVE-2021-45891": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2021-45892": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2021-45893": {"epss_score": 0.00817, "epss_percentile": 0.73845}, "CVE-2021-45894": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2021-45895": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-45896": {"epss_score": 0.00557, "epss_percentile": 0.67559}, "CVE-2021-45897": {"epss_score": 0.24559, "epss_percentile": 0.95933}, "CVE-2021-45898": {"epss_score": 0.0047, "epss_percentile": 0.63967}, "CVE-2021-45899": {"epss_score": 0.03201, "epss_percentile": 0.86624}, "CVE-2021-45900": {"epss_score": 0.00201, "epss_percentile": 0.42282}, "CVE-2021-45901": {"epss_score": 0.19686, "epss_percentile": 0.95226}, "CVE-2021-45903": {"epss_score": 0.00386, "epss_percentile": 0.59246}, "CVE-2021-45904": {"epss_score": 0.00281, "epss_percentile": 0.51183}, "CVE-2021-45905": {"epss_score": 0.00281, "epss_percentile": 0.51183}, "CVE-2021-45906": {"epss_score": 0.00281, "epss_percentile": 0.51183}, "CVE-2021-45907": {"epss_score": 0.00193, "epss_percentile": 0.41433}, "CVE-2021-45908": {"epss_score": 0.00193, "epss_percentile": 0.41433}, "CVE-2021-45909": {"epss_score": 0.00161, "epss_percentile": 0.37603}, "CVE-2021-45910": {"epss_score": 0.00134, "epss_percentile": 0.33909}, "CVE-2021-45911": {"epss_score": 0.00161, "epss_percentile": 0.37603}, "CVE-2021-45912": {"epss_score": 0.00142, "epss_percentile": 0.34955}, "CVE-2021-45913": {"epss_score": 0.00309, "epss_percentile": 0.53722}, "CVE-2021-45914": {"epss_score": 0.012, "epss_percentile": 0.78478}, "CVE-2021-45915": {"epss_score": 0.012, "epss_percentile": 0.78478}, "CVE-2021-45916": {"epss_score": 0.00099, "epss_percentile": 0.28372}, "CVE-2021-45917": {"epss_score": 0.00062, "epss_percentile": 0.197}, "CVE-2021-45918": {"epss_score": 0.00679, "epss_percentile": 0.71012}, "CVE-2021-45919": {"epss_score": 0.00334, "epss_percentile": 0.55727}, "CVE-2021-45925": {"epss_score": 0.00187, "epss_percentile": 0.40735}, "CVE-2021-45926": {"epss_score": 0.00155, "epss_percentile": 0.36879}, "CVE-2021-45927": {"epss_score": 0.00155, "epss_percentile": 0.36879}, "CVE-2021-45928": {"epss_score": 0.00124, "epss_percentile": 0.32374}, "CVE-2021-45929": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-45930": {"epss_score": 0.00129, "epss_percentile": 0.33204}, "CVE-2021-45931": {"epss_score": 0.00769, "epss_percentile": 0.72984}, "CVE-2021-45932": {"epss_score": 0.0021, "epss_percentile": 0.43438}, "CVE-2021-45933": {"epss_score": 0.0021, "epss_percentile": 0.43438}, "CVE-2021-45934": {"epss_score": 0.0021, "epss_percentile": 0.43438}, "CVE-2021-45935": {"epss_score": 0.00229, "epss_percentile": 0.45638}, "CVE-2021-45936": {"epss_score": 0.0021, "epss_percentile": 0.43438}, "CVE-2021-45937": {"epss_score": 0.0021, "epss_percentile": 0.43438}, "CVE-2021-45938": {"epss_score": 0.0021, "epss_percentile": 0.43438}, "CVE-2021-45939": {"epss_score": 0.0021, "epss_percentile": 0.43438}, "CVE-2021-45940": {"epss_score": 0.00369, "epss_percentile": 0.58263}, "CVE-2021-45941": {"epss_score": 0.00369, "epss_percentile": 0.58263}, "CVE-2021-45942": {"epss_score": 0.00182, "epss_percentile": 0.4022}, "CVE-2021-45943": {"epss_score": 0.003, "epss_percentile": 0.52966}, "CVE-2021-45944": {"epss_score": 0.0031, "epss_percentile": 0.53752}, "CVE-2021-45946": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-45947": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-45948": {"epss_score": 0.00209, "epss_percentile": 0.43426}, "CVE-2021-45949": {"epss_score": 0.00056, "epss_percentile": 0.1767}, "CVE-2021-45950": {"epss_score": 0.00238, "epss_percentile": 0.46799}, "CVE-2021-45951": {"epss_score": 0.00046, "epss_percentile": 0.14301}, "CVE-2021-45952": {"epss_score": 0.00046, "epss_percentile": 0.14301}, "CVE-2021-45953": {"epss_score": 0.00046, "epss_percentile": 0.14301}, "CVE-2021-45954": {"epss_score": 0.00046, "epss_percentile": 0.14301}, "CVE-2021-45955": {"epss_score": 0.00046, "epss_percentile": 0.14301}, "CVE-2021-45956": {"epss_score": 0.00046, "epss_percentile": 0.14301}, "CVE-2021-45957": {"epss_score": 0.00046, "epss_percentile": 0.14301}, "CVE-2021-45958": {"epss_score": 0.00287, "epss_percentile": 0.51812}, "CVE-2021-45960": {"epss_score": 0.00309, "epss_percentile": 0.53723}, "CVE-2021-45966": {"epss_score": 0.13813, "epss_percentile": 0.94065}, "CVE-2021-45967": {"epss_score": 0.8933, "epss_percentile": 0.99519}, "CVE-2021-45968": {"epss_score": 0.70707, "epss_percentile": 0.9864}, "CVE-2021-45969": {"epss_score": 0.00056, "epss_percentile": 0.17957}, "CVE-2021-45970": {"epss_score": 0.00047, "epss_percentile": 0.14705}, "CVE-2021-45971": {"epss_score": 0.00056, "epss_percentile": 0.17957}, "CVE-2021-45972": {"epss_score": 0.00321, "epss_percentile": 0.54736}, "CVE-2021-45975": {"epss_score": 0.0007, "epss_percentile": 0.21973}, "CVE-2021-45977": {"epss_score": 5e-05, "epss_percentile": 0.00218}, "CVE-2021-45978": {"epss_score": 0.00909, "epss_percentile": 0.75311}, "CVE-2021-45979": {"epss_score": 0.00909, "epss_percentile": 0.75311}, "CVE-2021-45980": {"epss_score": 0.00775, "epss_percentile": 0.73093}, "CVE-2021-45981": {"epss_score": 0.00423, "epss_percentile": 0.61591}, "CVE-2021-45982": {"epss_score": 0.00475, "epss_percentile": 0.64186}, "CVE-2021-45983": {"epss_score": 0.01299, "epss_percentile": 0.7928}, "CVE-2021-45985": {"epss_score": 0.0021, "epss_percentile": 0.43468}, "CVE-2021-45986": {"epss_score": 0.02076, "epss_percentile": 0.83509}, "CVE-2021-45987": {"epss_score": 0.02076, "epss_percentile": 0.83509}, "CVE-2021-45988": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2021-45989": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2021-45990": {"epss_score": 0.02076, "epss_percentile": 0.83509}, "CVE-2021-45991": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2021-45992": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2021-45993": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2021-45994": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2021-45995": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2021-45996": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2021-45997": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2021-45998": {"epss_score": 0.07868, "epss_percentile": 0.91732}, "CVE-2021-46005": {"epss_score": 0.06131, "epss_percentile": 0.90501}, "CVE-2021-46006": {"epss_score": 0.00236, "epss_percentile": 0.46443}, "CVE-2021-46007": {"epss_score": 0.09409, "epss_percentile": 0.92535}, "CVE-2021-46008": {"epss_score": 0.00168, "epss_percentile": 0.38501}, "CVE-2021-46009": {"epss_score": 0.0102, "epss_percentile": 0.76735}, "CVE-2021-46010": {"epss_score": 0.00863, "epss_percentile": 0.74588}, "CVE-2021-46013": {"epss_score": 0.02405, "epss_percentile": 0.84649}, "CVE-2021-46019": {"epss_score": 0.002, "epss_percentile": 0.42239}, "CVE-2021-46020": {"epss_score": 0.00303, "epss_percentile": 0.53181}, "CVE-2021-46021": {"epss_score": 0.00129, "epss_percentile": 0.3313}, "CVE-2021-46022": {"epss_score": 0.00194, "epss_percentile": 0.41553}, "CVE-2021-46023": {"epss_score": 0.00092, "epss_percentile": 0.26484}, "CVE-2021-46024": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2021-46025": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-46026": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-46027": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2021-46028": {"epss_score": 0.00098, "epss_percentile": 0.27733}, "CVE-2021-46030": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-46033": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2021-46034": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2021-46036": {"epss_score": 0.10761, "epss_percentile": 0.93096}, "CVE-2021-46037": {"epss_score": 0.00234, "epss_percentile": 0.46174}, "CVE-2021-46038": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-46039": {"epss_score": 0.00104, "epss_percentile": 0.29182}, "CVE-2021-46040": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-46041": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-46042": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-46043": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-46044": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-46045": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-46046": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-46047": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-46048": {"epss_score": 0.00178, "epss_percentile": 0.39744}, "CVE-2021-46049": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-46050": {"epss_score": 0.00189, "epss_percentile": 0.40981}, "CVE-2021-46051": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2021-46052": {"epss_score": 0.00178, "epss_percentile": 0.39744}, "CVE-2021-46053": {"epss_score": 0.00178, "epss_percentile": 0.39744}, "CVE-2021-46054": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2021-46055": {"epss_score": 0.00165, "epss_percentile": 0.38075}, "CVE-2021-46061": {"epss_score": 0.00329, "epss_percentile": 0.55301}, "CVE-2021-46062": {"epss_score": 0.00171, "epss_percentile": 0.38781}, "CVE-2021-46063": {"epss_score": 0.10736, "epss_percentile": 0.93087}, "CVE-2021-46064": {"epss_score": 0.00583, "epss_percentile": 0.68357}, "CVE-2021-46065": {"epss_score": 0.20355, "epss_percentile": 0.95331}, "CVE-2021-46067": {"epss_score": 0.14113, "epss_percentile": 0.94135}, "CVE-2021-46068": {"epss_score": 0.05674, "epss_percentile": 0.90108}, "CVE-2021-46069": {"epss_score": 0.05674, "epss_percentile": 0.90108}, "CVE-2021-46070": {"epss_score": 0.00752, "epss_percentile": 0.7266}, "CVE-2021-46071": {"epss_score": 0.05674, "epss_percentile": 0.90108}, "CVE-2021-46072": {"epss_score": 0.05674, "epss_percentile": 0.90108}, "CVE-2021-46073": {"epss_score": 0.05674, "epss_percentile": 0.90108}, "CVE-2021-46074": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2021-46075": {"epss_score": 0.01579, "epss_percentile": 0.81127}, "CVE-2021-46076": {"epss_score": 0.07642, "epss_percentile": 0.91596}, "CVE-2021-46078": {"epss_score": 0.01765, "epss_percentile": 0.82164}, "CVE-2021-46079": {"epss_score": 0.08626, "epss_percentile": 0.9216}, "CVE-2021-46080": {"epss_score": 0.00281, "epss_percentile": 0.5115}, "CVE-2021-46082": {"epss_score": 0.00295, "epss_percentile": 0.5247}, "CVE-2021-46083": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-46084": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-46085": {"epss_score": 0.00115, "epss_percentile": 0.30908}, "CVE-2021-46086": {"epss_score": 0.00148, "epss_percentile": 0.35806}, "CVE-2021-46087": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2021-46088": {"epss_score": 0.02966, "epss_percentile": 0.86082}, "CVE-2021-46089": {"epss_score": 0.00816, "epss_percentile": 0.73804}, "CVE-2021-46093": {"epss_score": 0.00285, "epss_percentile": 0.51549}, "CVE-2021-46097": {"epss_score": 0.01077, "epss_percentile": 0.77339}, "CVE-2021-46101": {"epss_score": 0.00865, "epss_percentile": 0.74626}, "CVE-2021-46102": {"epss_score": 0.00528, "epss_percentile": 0.66557}, "CVE-2021-46104": {"epss_score": 0.14775, "epss_percentile": 0.94281}, "CVE-2021-46107": {"epss_score": 0.62758, "epss_percentile": 0.98307}, "CVE-2021-46108": {"epss_score": 0.01103, "epss_percentile": 0.77591}, "CVE-2021-46109": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-46110": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-46113": {"epss_score": 0.03029, "epss_percentile": 0.86244}, "CVE-2021-46114": {"epss_score": 0.01283, "epss_percentile": 0.79165}, "CVE-2021-46115": {"epss_score": 0.00452, "epss_percentile": 0.63171}, "CVE-2021-46116": {"epss_score": 0.02443, "epss_percentile": 0.8476}, "CVE-2021-46117": {"epss_score": 0.03689, "epss_percentile": 0.87573}, "CVE-2021-46118": {"epss_score": 0.03443, "epss_percentile": 0.87143}, "CVE-2021-46122": {"epss_score": 0.00437, "epss_percentile": 0.62513}, "CVE-2021-46141": {"epss_score": 0.00093, "epss_percentile": 0.26742}, "CVE-2021-46142": {"epss_score": 0.00093, "epss_percentile": 0.26742}, "CVE-2021-46143": {"epss_score": 0.04085, "epss_percentile": 0.88225}, "CVE-2021-46144": {"epss_score": 0.01288, "epss_percentile": 0.79203}, "CVE-2021-46145": {"epss_score": 0.01839, "epss_percentile": 0.82488}, "CVE-2021-46146": {"epss_score": 0.0016, "epss_percentile": 0.37472}, "CVE-2021-46147": {"epss_score": 0.0011, "epss_percentile": 0.30127}, "CVE-2021-46148": {"epss_score": 0.00248, "epss_percentile": 0.47937}, "CVE-2021-46149": {"epss_score": 0.00269, "epss_percentile": 0.50168}, "CVE-2021-46150": {"epss_score": 0.00183, "epss_percentile": 0.40309}, "CVE-2021-46151": {"epss_score": 0.00342, "epss_percentile": 0.56392}, "CVE-2021-46152": {"epss_score": 0.00454, "epss_percentile": 0.6327}, "CVE-2021-46153": {"epss_score": 0.00454, "epss_percentile": 0.6327}, "CVE-2021-46154": {"epss_score": 0.01364, "epss_percentile": 0.79772}, "CVE-2021-46155": {"epss_score": 0.01364, "epss_percentile": 0.79772}, "CVE-2021-46156": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-46157": {"epss_score": 0.0038, "epss_percentile": 0.58953}, "CVE-2021-46158": {"epss_score": 0.01242, "epss_percentile": 0.78819}, "CVE-2021-46159": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-46160": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-46161": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-46162": {"epss_score": 0.00405, "epss_percentile": 0.60471}, "CVE-2021-46163": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2021-46164": {"epss_score": 0.09823, "epss_percentile": 0.92719}, "CVE-2021-46165": {"epss_score": 0.00104, "epss_percentile": 0.2918}, "CVE-2021-46166": {"epss_score": 0.00308, "epss_percentile": 0.53595}, "CVE-2021-46167": {"epss_score": 0.001, "epss_percentile": 0.28459}, "CVE-2021-46168": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2021-46169": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46170": {"epss_score": 0.00274, "epss_percentile": 0.50571}, "CVE-2021-46171": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46174": {"epss_score": 0.00037, "epss_percentile": 0.10738}, "CVE-2021-46179": {"epss_score": 0.00105, "epss_percentile": 0.29256}, "CVE-2021-46195": {"epss_score": 0.00259, "epss_percentile": 0.49066}, "CVE-2021-46198": {"epss_score": 0.00329, "epss_percentile": 0.55301}, "CVE-2021-46200": {"epss_score": 0.00329, "epss_percentile": 0.55301}, "CVE-2021-46201": {"epss_score": 0.00329, "epss_percentile": 0.55301}, "CVE-2021-46203": {"epss_score": 0.00355, "epss_percentile": 0.57283}, "CVE-2021-46204": {"epss_score": 0.00261, "epss_percentile": 0.49277}, "CVE-2021-46225": {"epss_score": 0.00304, "epss_percentile": 0.5329}, "CVE-2021-46226": {"epss_score": 0.07868, "epss_percentile": 0.91732}, "CVE-2021-46227": {"epss_score": 0.13875, "epss_percentile": 0.94082}, "CVE-2021-46228": {"epss_score": 0.07868, "epss_percentile": 0.91732}, "CVE-2021-46229": {"epss_score": 0.05574, "epss_percentile": 0.9001}, "CVE-2021-46230": {"epss_score": 0.05864, "epss_percentile": 0.90276}, "CVE-2021-46231": {"epss_score": 0.05864, "epss_percentile": 0.90276}, "CVE-2021-46232": {"epss_score": 0.05864, "epss_percentile": 0.90276}, "CVE-2021-46233": {"epss_score": 0.05864, "epss_percentile": 0.90276}, "CVE-2021-46234": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2021-46236": {"epss_score": 0.00286, "epss_percentile": 0.51783}, "CVE-2021-46237": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46238": {"epss_score": 0.00161, "epss_percentile": 0.37612}, "CVE-2021-46239": {"epss_score": 0.00266, "epss_percentile": 0.4995}, "CVE-2021-46240": {"epss_score": 0.00291, "epss_percentile": 0.52205}, "CVE-2021-46242": {"epss_score": 0.00316, "epss_percentile": 0.54224}, "CVE-2021-46243": {"epss_score": 0.00277, "epss_percentile": 0.50833}, "CVE-2021-46244": {"epss_score": 0.0038, "epss_percentile": 0.58949}, "CVE-2021-46247": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2021-46249": {"epss_score": 0.00154, "epss_percentile": 0.3669}, "CVE-2021-46250": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2021-46251": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-46252": {"epss_score": 0.00117, "epss_percentile": 0.31326}, "CVE-2021-46253": {"epss_score": 0.00502, "epss_percentile": 0.65419}, "CVE-2021-46255": {"epss_score": 0.00234, "epss_percentile": 0.46174}, "CVE-2021-46262": {"epss_score": 0.01005, "epss_percentile": 0.76534}, "CVE-2021-46263": {"epss_score": 0.01005, "epss_percentile": 0.76534}, "CVE-2021-46264": {"epss_score": 0.01005, "epss_percentile": 0.76534}, "CVE-2021-46265": {"epss_score": 0.01005, "epss_percentile": 0.76534}, "CVE-2021-46270": {"epss_score": 0.00174, "epss_percentile": 0.39192}, "CVE-2021-46279": {"epss_score": 0.00225, "epss_percentile": 0.45144}, "CVE-2021-46283": {"epss_score": 0.0004, "epss_percentile": 0.11928}, "CVE-2021-46304": {"epss_score": 0.00327, "epss_percentile": 0.55096}, "CVE-2021-46307": {"epss_score": 0.00329, "epss_percentile": 0.55301}, "CVE-2021-46308": {"epss_score": 0.00329, "epss_percentile": 0.55301}, "CVE-2021-46309": {"epss_score": 0.00329, "epss_percentile": 0.55301}, "CVE-2021-46310": {"epss_score": 0.00258, "epss_percentile": 0.4898}, "CVE-2021-46311": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46312": {"epss_score": 0.00258, "epss_percentile": 0.4898}, "CVE-2021-46313": {"epss_score": 0.00266, "epss_percentile": 0.4995}, "CVE-2021-46314": {"epss_score": 0.23473, "epss_percentile": 0.95783}, "CVE-2021-46315": {"epss_score": 0.26252, "epss_percentile": 0.9613}, "CVE-2021-46319": {"epss_score": 0.16559, "epss_percentile": 0.94691}, "CVE-2021-46320": {"epss_score": 0.00517, "epss_percentile": 0.66071}, "CVE-2021-46321": {"epss_score": 0.01005, "epss_percentile": 0.76534}, "CVE-2021-46322": {"epss_score": 0.00079, "epss_percentile": 0.23982}, "CVE-2021-46323": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46324": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46325": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46326": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2021-46327": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2021-46328": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2021-46329": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2021-46330": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2021-46331": {"epss_score": 0.00286, "epss_percentile": 0.51783}, "CVE-2021-46332": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2021-46333": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2021-46334": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2021-46335": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2021-46336": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46337": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46338": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46339": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46340": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46342": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46343": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46344": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46345": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46346": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46347": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46348": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46349": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46350": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46351": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2021-46353": {"epss_score": 0.00452, "epss_percentile": 0.63169}, "CVE-2021-46354": {"epss_score": 0.34658, "epss_percentile": 0.96864}, "CVE-2021-46355": {"epss_score": 0.00319, "epss_percentile": 0.54474}, "CVE-2021-46359": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-46360": {"epss_score": 0.07841, "epss_percentile": 0.91711}, "CVE-2021-46361": {"epss_score": 0.01, "epss_percentile": 0.76489}, "CVE-2021-46362": {"epss_score": 0.02924, "epss_percentile": 0.86002}, "CVE-2021-46363": {"epss_score": 0.01661, "epss_percentile": 0.81631}, "CVE-2021-46364": {"epss_score": 0.01004, "epss_percentile": 0.76531}, "CVE-2021-46365": {"epss_score": 0.00513, "epss_percentile": 0.65919}, "CVE-2021-46366": {"epss_score": 0.00527, "epss_percentile": 0.66527}, "CVE-2021-46367": {"epss_score": 0.24712, "epss_percentile": 0.95947}, "CVE-2021-46368": {"epss_score": 0.00095, "epss_percentile": 0.27107}, "CVE-2021-46371": {"epss_score": 0.07644, "epss_percentile": 0.91598}, "CVE-2021-46372": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-46377": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2021-46378": {"epss_score": 0.33056, "epss_percentile": 0.96743}, "CVE-2021-46379": {"epss_score": 0.46879, "epss_percentile": 0.9756}, "CVE-2021-46381": {"epss_score": 0.90499, "epss_percentile": 0.99587}, "CVE-2021-46382": {"epss_score": 0.0057, "epss_percentile": 0.67951}, "CVE-2021-46383": {"epss_score": 0.0044, "epss_percentile": 0.62644}, "CVE-2021-46384": {"epss_score": 0.09689, "epss_percentile": 0.92663}, "CVE-2021-46385": {"epss_score": 0.0044, "epss_percentile": 0.62644}, "CVE-2021-46386": {"epss_score": 0.06397, "epss_percentile": 0.90724}, "CVE-2021-46387": {"epss_score": 0.28486, "epss_percentile": 0.96362}, "CVE-2021-46389": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2021-46390": {"epss_score": 0.00097, "epss_percentile": 0.2759}, "CVE-2021-46393": {"epss_score": 0.03509, "epss_percentile": 0.87262}, "CVE-2021-46394": {"epss_score": 0.02585, "epss_percentile": 0.85163}, "CVE-2021-46398": {"epss_score": 0.09247, "epss_percentile": 0.92465}, "CVE-2021-46408": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2021-46416": {"epss_score": 0.06286, "epss_percentile": 0.90642}, "CVE-2021-46417": {"epss_score": 0.92171, "epss_percentile": 0.99695}, "CVE-2021-46418": {"epss_score": 0.63051, "epss_percentile": 0.98318}, "CVE-2021-46419": {"epss_score": 0.88313, "epss_percentile": 0.99466}, "CVE-2021-46420": {"epss_score": 0.03253, "epss_percentile": 0.86756}, "CVE-2021-46421": {"epss_score": 0.03253, "epss_percentile": 0.86756}, "CVE-2021-46422": {"epss_score": 0.93876, "epss_percentile": 0.99861}, "CVE-2021-46423": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2021-46424": {"epss_score": 0.91469, "epss_percentile": 0.99646}, "CVE-2021-46426": {"epss_score": 0.00572, "epss_percentile": 0.68021}, "CVE-2021-46427": {"epss_score": 0.00375, "epss_percentile": 0.58611}, "CVE-2021-46428": {"epss_score": 0.02702, "epss_percentile": 0.85458}, "CVE-2021-46433": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2021-46434": {"epss_score": 0.00194, "epss_percentile": 0.41594}, "CVE-2021-46436": {"epss_score": 0.00255, "epss_percentile": 0.48634}, "CVE-2021-46437": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2021-46440": {"epss_score": 0.03089, "epss_percentile": 0.86392}, "CVE-2021-46441": {"epss_score": 0.22967, "epss_percentile": 0.95711}, "CVE-2021-46442": {"epss_score": 0.08692, "epss_percentile": 0.92206}, "CVE-2021-46444": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-46445": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-46446": {"epss_score": 0.00773, "epss_percentile": 0.73049}, "CVE-2021-46447": {"epss_score": 0.00502, "epss_percentile": 0.65419}, "CVE-2021-46448": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2021-46451": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2021-46452": {"epss_score": 0.05864, "epss_percentile": 0.90276}, "CVE-2021-46453": {"epss_score": 0.05864, "epss_percentile": 0.90276}, "CVE-2021-46454": {"epss_score": 0.35326, "epss_percentile": 0.969}, "CVE-2021-46455": {"epss_score": 0.07868, "epss_percentile": 0.91732}, "CVE-2021-46456": {"epss_score": 0.07868, "epss_percentile": 0.91732}, "CVE-2021-46457": {"epss_score": 0.07868, "epss_percentile": 0.91732}, "CVE-2021-46458": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2021-46459": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2021-46461": {"epss_score": 0.00619, "epss_percentile": 0.69436}, "CVE-2021-46462": {"epss_score": 0.00731, "epss_percentile": 0.7218}, "CVE-2021-46463": {"epss_score": 0.0046, "epss_percentile": 0.63536}, "CVE-2021-46474": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2021-46475": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2021-46477": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2021-46478": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2021-46480": {"epss_score": 0.00193, "epss_percentile": 0.41416}, "CVE-2021-46481": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2021-46482": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2021-46483": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2021-46484": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46485": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46486": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46487": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46488": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46489": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46490": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46491": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46492": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46494": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46495": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46496": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46497": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46498": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46499": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46500": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46501": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46502": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46503": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46504": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46505": {"epss_score": 0.00146, "epss_percentile": 0.35639}, "CVE-2021-46506": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46507": {"epss_score": 0.00146, "epss_percentile": 0.35639}, "CVE-2021-46508": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46509": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46510": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46511": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46512": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46513": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46514": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46515": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46516": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46517": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46518": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46519": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46520": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46521": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46522": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46523": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46524": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46525": {"epss_score": 0.00169, "epss_percentile": 0.38527}, "CVE-2021-46526": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46527": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2021-46528": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46529": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46530": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46531": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46532": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46534": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46535": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46537": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46538": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46539": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46540": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46541": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46542": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46543": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46544": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46545": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46546": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46547": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46548": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46549": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46550": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46553": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46554": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46556": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2021-46557": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-46558": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-46559": {"epss_score": 0.00113, "epss_percentile": 0.30687}, "CVE-2021-46560": {"epss_score": 0.02312, "epss_percentile": 0.84343}, "CVE-2021-46561": {"epss_score": 0.00359, "epss_percentile": 0.57541}, "CVE-2021-46562": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46563": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46564": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46565": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46566": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46567": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46568": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46569": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46570": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46571": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46572": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46573": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46574": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46575": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46576": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46577": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46578": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46579": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46580": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46581": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46582": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46583": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46584": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46585": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46586": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46587": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46588": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46589": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46590": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46591": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46592": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46593": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46594": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46595": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46596": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46597": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46598": {"epss_score": 0.0066, "epss_percentile": 0.70541}, "CVE-2021-46599": {"epss_score": 0.00489, "epss_percentile": 0.64877}, "CVE-2021-46600": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-46601": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46602": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-46603": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46604": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46605": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46606": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46607": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-46608": {"epss_score": 0.00489, "epss_percentile": 0.64882}, "CVE-2021-46609": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46610": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46611": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46612": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46613": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46614": {"epss_score": 0.00583, "epss_percentile": 0.68342}, "CVE-2021-46615": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46616": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46617": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46618": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46619": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46620": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46621": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46622": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46623": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46624": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46625": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46626": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46627": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46628": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46629": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46630": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46631": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46632": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46633": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46634": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46635": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46636": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46637": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46638": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46639": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46640": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46641": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46642": {"epss_score": 0.00506, "epss_percentile": 0.65632}, "CVE-2021-46643": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46644": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46645": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46646": {"epss_score": 0.0098, "epss_percentile": 0.76269}, "CVE-2021-46647": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46648": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46649": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46650": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46651": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46652": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46653": {"epss_score": 0.00621, "epss_percentile": 0.69473}, "CVE-2021-46654": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2021-46655": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46656": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2021-46657": {"epss_score": 0.0005, "epss_percentile": 0.15836}, "CVE-2021-46658": {"epss_score": 0.00083, "epss_percentile": 0.24708}, "CVE-2021-46659": {"epss_score": 0.00039, "epss_percentile": 0.11644}, "CVE-2021-46660": {"epss_score": 0.00368, "epss_percentile": 0.58183}, "CVE-2021-46661": {"epss_score": 0.00042, "epss_percentile": 0.12495}, "CVE-2021-46662": {"epss_score": 0.0005, "epss_percentile": 0.15742}, "CVE-2021-46663": {"epss_score": 0.00042, "epss_percentile": 0.12495}, "CVE-2021-46664": {"epss_score": 0.00042, "epss_percentile": 0.12495}, "CVE-2021-46665": {"epss_score": 0.00042, "epss_percentile": 0.12495}, "CVE-2021-46666": {"epss_score": 0.00063, "epss_percentile": 0.19915}, "CVE-2021-46667": {"epss_score": 0.00036, "epss_percentile": 0.10236}, "CVE-2021-46668": {"epss_score": 0.00034, "epss_percentile": 0.09793}, "CVE-2021-46669": {"epss_score": 0.00569, "epss_percentile": 0.67933}, "CVE-2021-46671": {"epss_score": 0.00121, "epss_percentile": 0.31822}, "CVE-2021-46676": {"epss_score": 0.00295, "epss_percentile": 0.52513}, "CVE-2021-46677": {"epss_score": 0.00406, "epss_percentile": 0.60539}, "CVE-2021-46678": {"epss_score": 0.00406, "epss_percentile": 0.60539}, "CVE-2021-46679": {"epss_score": 0.00295, "epss_percentile": 0.52513}, "CVE-2021-46680": {"epss_score": 0.00406, "epss_percentile": 0.60539}, "CVE-2021-46681": {"epss_score": 0.00295, "epss_percentile": 0.52513}, "CVE-2021-46686": {"epss_score": 0.00561, "epss_percentile": 0.67657}, "CVE-2021-46687": {"epss_score": 0.0025, "epss_percentile": 0.4821}, "CVE-2021-46699": {"epss_score": 0.0088, "epss_percentile": 0.74856}, "CVE-2021-46700": {"epss_score": 0.00257, "epss_percentile": 0.48943}, "CVE-2021-46701": {"epss_score": 0.00091, "epss_percentile": 0.26267}, "CVE-2021-46702": {"epss_score": 0.00125, "epss_percentile": 0.32546}, "CVE-2021-46703": {"epss_score": 0.01421, "epss_percentile": 0.80172}, "CVE-2021-46704": {"epss_score": 0.86931, "epss_percentile": 0.99404}, "CVE-2021-46705": {"epss_score": 0.00043, "epss_percentile": 0.13207}, "CVE-2021-46708": {"epss_score": 0.00286, "epss_percentile": 0.51735}, "CVE-2021-46709": {"epss_score": 0.00334, "epss_percentile": 0.55709}, "CVE-2021-46740": {"epss_score": 0.00139, "epss_percentile": 0.34622}, "CVE-2021-46741": {"epss_score": 0.00159, "epss_percentile": 0.37388}, "CVE-2021-46742": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2021-46743": {"epss_score": 0.00791, "epss_percentile": 0.73384}, "CVE-2021-46744": {"epss_score": 0.00087, "epss_percentile": 0.25578}, "CVE-2021-46746": {"epss_score": 0.00028, "epss_percentile": 0.07286}, "CVE-2021-46748": {"epss_score": 0.00103, "epss_percentile": 0.28932}, "CVE-2021-46749": {"epss_score": 0.00156, "epss_percentile": 0.36979}, "CVE-2021-46750": {"epss_score": 0.00019, "epss_percentile": 0.04369}, "CVE-2021-46753": {"epss_score": 0.00178, "epss_percentile": 0.39655}, "CVE-2021-46754": {"epss_score": 0.00171, "epss_percentile": 0.38832}, "CVE-2021-46755": {"epss_score": 0.00158, "epss_percentile": 0.37161}, "CVE-2021-46756": {"epss_score": 0.00115, "epss_percentile": 0.3095}, "CVE-2021-46757": {"epss_score": 0.00076, "epss_percentile": 0.23089}, "CVE-2021-46758": {"epss_score": 0.0013, "epss_percentile": 0.33334}, "CVE-2021-46759": {"epss_score": 0.00048, "epss_percentile": 0.15106}, "CVE-2021-46760": {"epss_score": 0.00227, "epss_percentile": 0.4544}, "CVE-2021-46762": {"epss_score": 0.00029, "epss_percentile": 0.07613}, "CVE-2021-46763": {"epss_score": 0.00092, "epss_percentile": 0.2647}, "CVE-2021-46764": {"epss_score": 0.00115, "epss_percentile": 0.30958}, "CVE-2021-46765": {"epss_score": 0.00115, "epss_percentile": 0.30958}, "CVE-2021-46766": {"epss_score": 0.00021, "epss_percentile": 0.04915}, "CVE-2021-46767": {"epss_score": 0.00072, "epss_percentile": 0.22253}, "CVE-2021-46768": {"epss_score": 0.00044, "epss_percentile": 0.13586}, "CVE-2021-46769": {"epss_score": 0.00156, "epss_percentile": 0.36936}, "CVE-2021-46771": {"epss_score": 0.00104, "epss_percentile": 0.29141}, "CVE-2021-46772": {"epss_score": 0.00031, "epss_percentile": 0.08532}, "CVE-2021-46773": {"epss_score": 0.00156, "epss_percentile": 0.36936}, "CVE-2021-46774": {"epss_score": 0.00022, "epss_percentile": 0.05164}, "CVE-2021-46775": {"epss_score": 0.00061, "epss_percentile": 0.19389}, "CVE-2021-46778": {"epss_score": 0.0012, "epss_percentile": 0.31738}, "CVE-2021-46779": {"epss_score": 0.00045, "epss_percentile": 0.1379}, "CVE-2021-46780": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-46781": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-46782": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2021-46784": {"epss_score": 0.12734, "epss_percentile": 0.93761}, "CVE-2021-46785": {"epss_score": 0.00096, "epss_percentile": 0.27403}, "CVE-2021-46786": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2021-46787": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2021-46788": {"epss_score": 0.00113, "epss_percentile": 0.30629}, "CVE-2021-46789": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2021-46790": {"epss_score": 0.00042, "epss_percentile": 0.12617}, "CVE-2021-46791": {"epss_score": 0.0005, "epss_percentile": 0.15951}, "CVE-2021-46792": {"epss_score": 0.00122, "epss_percentile": 0.32097}, "CVE-2021-46794": {"epss_score": 0.00156, "epss_percentile": 0.36979}, "CVE-2021-46795": {"epss_score": 0.00047, "epss_percentile": 0.14667}, "CVE-2021-46811": {"epss_score": 0.00082, "epss_percentile": 0.24581}, "CVE-2021-46812": {"epss_score": 0.00098, "epss_percentile": 0.27757}, "CVE-2021-46813": {"epss_score": 0.00251, "epss_percentile": 0.48296}, "CVE-2021-46814": {"epss_score": 0.00218, "epss_percentile": 0.44434}, "CVE-2021-46816": {"epss_score": 0.01736, "epss_percentile": 0.82012}, "CVE-2021-46817": {"epss_score": 0.03839, "epss_percentile": 0.87828}, "CVE-2021-46818": {"epss_score": 0.09775, "epss_percentile": 0.92698}, "CVE-2021-46820": {"epss_score": 0.00144, "epss_percentile": 0.35255}, "CVE-2021-46822": {"epss_score": 0.00111, "epss_percentile": 0.30375}, "CVE-2021-46823": {"epss_score": 0.00211, "epss_percentile": 0.43637}, "CVE-2021-46824": {"epss_score": 0.00283, "epss_percentile": 0.51403}, "CVE-2021-46825": {"epss_score": 0.00402, "epss_percentile": 0.60282}, "CVE-2021-46827": {"epss_score": 0.00719, "epss_percentile": 0.71951}, "CVE-2021-46828": {"epss_score": 0.0092, "epss_percentile": 0.75471}, "CVE-2021-46829": {"epss_score": 0.00425, "epss_percentile": 0.61694}, "CVE-2021-46830": {"epss_score": 0.00575, "epss_percentile": 0.68097}, "CVE-2021-46834": {"epss_score": 0.00024, "epss_percentile": 0.05889}, "CVE-2021-46835": {"epss_score": 0.00033, "epss_percentile": 0.09241}, "CVE-2021-46836": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-46837": {"epss_score": 0.00194, "epss_percentile": 0.41594}, "CVE-2021-46839": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-46840": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2021-46841": {"epss_score": 0.00172, "epss_percentile": 0.38982}, "CVE-2021-46846": {"epss_score": 0.00162, "epss_percentile": 0.377}, "CVE-2021-46848": {"epss_score": 0.00343, "epss_percentile": 0.56433}, "CVE-2021-46850": {"epss_score": 0.15924, "epss_percentile": 0.94536}, "CVE-2021-46851": {"epss_score": 0.002, "epss_percentile": 0.42243}, "CVE-2021-46852": {"epss_score": 0.00112, "epss_percentile": 0.30525}, "CVE-2021-46853": {"epss_score": 0.00277, "epss_percentile": 0.50812}, "CVE-2021-46854": {"epss_score": 0.01296, "epss_percentile": 0.79258}, "CVE-2021-46856": {"epss_score": 0.00215, "epss_percentile": 0.44088}, "CVE-2021-46867": {"epss_score": 0.00131, "epss_percentile": 0.33353}, "CVE-2021-46868": {"epss_score": 0.00131, "epss_percentile": 0.33353}, "CVE-2021-46871": {"epss_score": 0.00119, "epss_percentile": 0.31642}, "CVE-2021-46872": {"epss_score": 0.00637, "epss_percentile": 0.69886}, "CVE-2021-46873": {"epss_score": 0.00053, "epss_percentile": 0.16733}, "CVE-2021-46875": {"epss_score": 0.00487, "epss_percentile": 0.64808}, "CVE-2021-46876": {"epss_score": 0.00249, "epss_percentile": 0.48002}, "CVE-2021-46877": {"epss_score": 0.00261, "epss_percentile": 0.49283}, "CVE-2021-46878": {"epss_score": 0.00038, "epss_percentile": 0.11208}, "CVE-2021-46879": {"epss_score": 0.00026, "epss_percentile": 0.0657}, "CVE-2021-46880": {"epss_score": 0.00027, "epss_percentile": 0.06774}, "CVE-2021-46881": {"epss_score": 0.00085, "epss_percentile": 0.25033}, "CVE-2021-46882": {"epss_score": 0.00085, "epss_percentile": 0.25033}, "CVE-2021-46883": {"epss_score": 0.00085, "epss_percentile": 0.25033}, "CVE-2021-46884": {"epss_score": 0.00085, "epss_percentile": 0.25033}, "CVE-2021-46885": {"epss_score": 0.00085, "epss_percentile": 0.25033}, "CVE-2021-46886": {"epss_score": 0.00085, "epss_percentile": 0.25033}, "CVE-2021-46887": {"epss_score": 0.00125, "epss_percentile": 0.32481}, "CVE-2021-46888": {"epss_score": 0.01918, "epss_percentile": 0.82882}, "CVE-2021-46889": {"epss_score": 0.00438, "epss_percentile": 0.62557}, "CVE-2021-46890": {"epss_score": 0.00084, "epss_percentile": 0.24953}, "CVE-2021-46891": {"epss_score": 0.00084, "epss_percentile": 0.24953}, "CVE-2021-46892": {"epss_score": 0.00035, "epss_percentile": 0.1005}, "CVE-2021-46893": {"epss_score": 0.00057, "epss_percentile": 0.18226}, "CVE-2021-46894": {"epss_score": 0.00105, "epss_percentile": 0.2931}, "CVE-2021-46895": {"epss_score": 0.0002, "epss_percentile": 0.04602}, "CVE-2021-46896": {"epss_score": 0.00052, "epss_percentile": 0.16547}, "CVE-2021-46897": {"epss_score": 0.00101, "epss_percentile": 0.28679}, "CVE-2021-46898": {"epss_score": 0.00234, "epss_percentile": 0.46165}, "CVE-2021-46899": {"epss_score": 0.0003, "epss_percentile": 0.07983}, "CVE-2021-46900": {"epss_score": 0.00127, "epss_percentile": 0.32813}, "CVE-2021-46901": {"epss_score": 0.00215, "epss_percentile": 0.44093}, "CVE-2021-46902": {"epss_score": 0.00379, "epss_percentile": 0.58892}, "CVE-2021-46903": {"epss_score": 0.00098, "epss_percentile": 0.27703}, "CVE-2021-46904": {"epss_score": 0.00012, "epss_percentile": 0.01177}, "CVE-2021-46905": {"epss_score": 0.00011, "epss_percentile": 0.01047}, "CVE-2021-46906": {"epss_score": 0.0001, "epss_percentile": 0.00871}, "CVE-2021-46908": {"epss_score": 4e-05, "epss_percentile": 0.00137}, "CVE-2021-46909": {"epss_score": 7e-05, "epss_percentile": 0.00346}, "CVE-2021-46910": {"epss_score": 0.00035, "epss_percentile": 0.10057}, "CVE-2021-46911": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-46912": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-46913": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-46914": {"epss_score": 0.0003, "epss_percentile": 0.08022}, "CVE-2021-46915": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2021-46916": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2021-46917": {"epss_score": 0.00026, "epss_percentile": 0.06618}, "CVE-2021-46918": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2021-46919": {"epss_score": 0.0003, "epss_percentile": 0.08022}, "CVE-2021-46920": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2021-46921": {"epss_score": 0.00016, "epss_percentile": 0.02745}, "CVE-2021-46922": {"epss_score": 0.0003, "epss_percentile": 0.08022}, "CVE-2021-46923": {"epss_score": 0.00013, "epss_percentile": 0.01532}, "CVE-2021-46924": {"epss_score": 0.00012, "epss_percentile": 0.01288}, "CVE-2021-46925": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2021-46926": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2021-46927": {"epss_score": 0.00011, "epss_percentile": 0.01072}, "CVE-2021-46928": {"epss_score": 0.00014, "epss_percentile": 0.01815}, "CVE-2021-46929": {"epss_score": 0.00012, "epss_percentile": 0.01288}, "CVE-2021-46930": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2021-46931": {"epss_score": 0.00019, "epss_percentile": 0.04062}, "CVE-2021-46932": {"epss_score": 0.00012, "epss_percentile": 0.01177}, "CVE-2021-46933": {"epss_score": 0.00015, "epss_percentile": 0.02545}, "CVE-2021-46934": {"epss_score": 0.00015, "epss_percentile": 0.02416}, "CVE-2021-46935": {"epss_score": 0.00017, "epss_percentile": 0.03432}, "CVE-2021-46936": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2021-46937": {"epss_score": 0.00015, "epss_percentile": 0.02412}, "CVE-2021-46938": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2021-46939": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2021-46940": {"epss_score": 0.00018, "epss_percentile": 0.03893}, "CVE-2021-46941": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-46942": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2021-46943": {"epss_score": 0.00038, "epss_percentile": 0.11402}, "CVE-2021-46944": {"epss_score": 0.00016, "epss_percentile": 0.02847}, "CVE-2021-46945": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2021-46947": {"epss_score": 0.00035, "epss_percentile": 0.09977}, "CVE-2021-46948": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-46949": {"epss_score": 0.00035, "epss_percentile": 0.09941}, "CVE-2021-46950": {"epss_score": 0.00016, "epss_percentile": 0.02833}, "CVE-2021-46951": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2021-46952": {"epss_score": 0.00016, "epss_percentile": 0.02912}, "CVE-2021-46953": {"epss_score": 0.00014, "epss_percentile": 0.01973}, "CVE-2021-46954": {"epss_score": 0.00018, "epss_percentile": 0.03943}, "CVE-2021-46955": {"epss_score": 7e-05, "epss_percentile": 0.00463}, "CVE-2021-46956": {"epss_score": 0.00016, "epss_percentile": 0.02847}, "CVE-2021-46957": {"epss_score": 0.00038, "epss_percentile": 0.11338}, "CVE-2021-46958": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2021-46959": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2021-46960": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2021-46961": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2021-46962": {"epss_score": 0.00017, "epss_percentile": 0.03268}, "CVE-2021-46963": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2021-46964": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2021-46965": {"epss_score": 0.00038, "epss_percentile": 0.11108}, "CVE-2021-46966": {"epss_score": 0.00015, "epss_percentile": 0.02163}, "CVE-2021-46967": {"epss_score": 0.00011, "epss_percentile": 0.01037}, "CVE-2021-46968": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2021-46969": {"epss_score": 0.0002, "epss_percentile": 0.04635}, "CVE-2021-46970": {"epss_score": 0.00036, "epss_percentile": 0.10605}, "CVE-2021-46971": {"epss_score": 0.00019, "epss_percentile": 0.04181}, "CVE-2021-46972": {"epss_score": 8e-05, "epss_percentile": 0.00561}, "CVE-2021-46973": {"epss_score": 0.0002, "epss_percentile": 0.04463}, "CVE-2021-46974": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2021-46976": {"epss_score": 0.00038, "epss_percentile": 0.1131}, "CVE-2021-46977": {"epss_score": 0.00047, "epss_percentile": 0.14871}, "CVE-2021-46978": {"epss_score": 0.00047, "epss_percentile": 0.14665}, "CVE-2021-46979": {"epss_score": 0.00047, "epss_percentile": 0.145}, "CVE-2021-46980": {"epss_score": 0.00039, "epss_percentile": 0.11693}, "CVE-2021-46981": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2021-46982": {"epss_score": 0.00016, "epss_percentile": 0.03018}, "CVE-2021-46983": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-46984": {"epss_score": 0.00031, "epss_percentile": 0.08409}, "CVE-2021-46985": {"epss_score": 0.0003, "epss_percentile": 0.08182}, "CVE-2021-46986": {"epss_score": 0.00021, "epss_percentile": 0.04793}, "CVE-2021-46987": {"epss_score": 0.00014, "epss_percentile": 0.02112}, "CVE-2021-46988": {"epss_score": 0.00012, "epss_percentile": 0.01288}, "CVE-2021-46989": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2021-46990": {"epss_score": 0.00011, "epss_percentile": 0.01047}, "CVE-2021-46991": {"epss_score": 0.00016, "epss_percentile": 0.02833}, "CVE-2021-46992": {"epss_score": 7e-05, "epss_percentile": 0.00431}, "CVE-2021-46993": {"epss_score": 0.00121, "epss_percentile": 0.31813}, "CVE-2021-46994": {"epss_score": 0.00037, "epss_percentile": 0.10663}, "CVE-2021-46995": {"epss_score": 0.00037, "epss_percentile": 0.10721}, "CVE-2021-46996": {"epss_score": 0.00036, "epss_percentile": 0.10512}, "CVE-2021-46997": {"epss_score": 0.00019, "epss_percentile": 0.04185}, "CVE-2021-46998": {"epss_score": 0.00016, "epss_percentile": 0.02833}, "CVE-2021-46999": {"epss_score": 0.00019, "epss_percentile": 0.04172}, "CVE-2021-47000": {"epss_score": 0.00016, "epss_percentile": 0.02867}, "CVE-2021-47001": {"epss_score": 0.00012, "epss_percentile": 0.01321}, "CVE-2021-47002": {"epss_score": 0.00019, "epss_percentile": 0.04148}, "CVE-2021-47003": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47004": {"epss_score": 0.00041, "epss_percentile": 0.12347}, "CVE-2021-47005": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47006": {"epss_score": 0.00012, "epss_percentile": 0.01158}, "CVE-2021-47007": {"epss_score": 0.00019, "epss_percentile": 0.04185}, "CVE-2021-47008": {"epss_score": 0.00019, "epss_percentile": 0.04148}, "CVE-2021-47009": {"epss_score": 0.00029, "epss_percentile": 0.07906}, "CVE-2021-47010": {"epss_score": 0.0002, "epss_percentile": 0.04471}, "CVE-2021-47011": {"epss_score": 0.00019, "epss_percentile": 0.04185}, "CVE-2021-47012": {"epss_score": 0.00042, "epss_percentile": 0.12647}, "CVE-2021-47013": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2021-47014": {"epss_score": 0.00015, "epss_percentile": 0.02348}, "CVE-2021-47015": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2021-47016": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2021-47017": {"epss_score": 0.00031, "epss_percentile": 0.08454}, "CVE-2021-47018": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2021-47019": {"epss_score": 0.00026, "epss_percentile": 0.06478}, "CVE-2021-47020": {"epss_score": 0.00012, "epss_percentile": 0.01288}, "CVE-2021-47021": {"epss_score": 0.00041, "epss_percentile": 0.12248}, "CVE-2021-47022": {"epss_score": 0.00021, "epss_percentile": 0.04793}, "CVE-2021-47023": {"epss_score": 0.00077, "epss_percentile": 0.23307}, "CVE-2021-47024": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2021-47025": {"epss_score": 0.00016, "epss_percentile": 0.02925}, "CVE-2021-47026": {"epss_score": 0.00031, "epss_percentile": 0.08454}, "CVE-2021-47027": {"epss_score": 0.00107, "epss_percentile": 0.29649}, "CVE-2021-47028": {"epss_score": 0.00022, "epss_percentile": 0.05003}, "CVE-2021-47029": {"epss_score": 0.00083, "epss_percentile": 0.24614}, "CVE-2021-47030": {"epss_score": 0.00041, "epss_percentile": 0.12273}, "CVE-2021-47031": {"epss_score": 0.00116, "epss_percentile": 0.31179}, "CVE-2021-47032": {"epss_score": 0.00019, "epss_percentile": 0.04114}, "CVE-2021-47033": {"epss_score": 0.00019, "epss_percentile": 0.04114}, "CVE-2021-47034": {"epss_score": 0.00011, "epss_percentile": 0.00972}, "CVE-2021-47035": {"epss_score": 0.00017, "epss_percentile": 0.03312}, "CVE-2021-47036": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2021-47037": {"epss_score": 0.0003, "epss_percentile": 0.08268}, "CVE-2021-47038": {"epss_score": 0.00012, "epss_percentile": 0.01249}, "CVE-2021-47039": {"epss_score": 0.00022, "epss_percentile": 0.04963}, "CVE-2021-47040": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2021-47041": {"epss_score": 9e-05, "epss_percentile": 0.00606}, "CVE-2021-47042": {"epss_score": 0.00041, "epss_percentile": 0.12273}, "CVE-2021-47043": {"epss_score": 0.00029, "epss_percentile": 0.07745}, "CVE-2021-47044": {"epss_score": 0.00016, "epss_percentile": 0.02625}, "CVE-2021-47045": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2021-47046": {"epss_score": 0.00023, "epss_percentile": 0.05392}, "CVE-2021-47047": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47048": {"epss_score": 0.00038, "epss_percentile": 0.11313}, "CVE-2021-47049": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2021-47050": {"epss_score": 0.00027, "epss_percentile": 0.06928}, "CVE-2021-47051": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2021-47052": {"epss_score": 0.00019, "epss_percentile": 0.04114}, "CVE-2021-47053": {"epss_score": 0.00012, "epss_percentile": 0.01333}, "CVE-2021-47054": {"epss_score": 0.00012, "epss_percentile": 0.01177}, "CVE-2021-47055": {"epss_score": 7e-05, "epss_percentile": 0.00347}, "CVE-2021-47056": {"epss_score": 0.00012, "epss_percentile": 0.01177}, "CVE-2021-47057": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2021-47058": {"epss_score": 0.00016, "epss_percentile": 0.02833}, "CVE-2021-47059": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2021-47060": {"epss_score": 0.00016, "epss_percentile": 0.02825}, "CVE-2021-47061": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2021-47062": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2021-47063": {"epss_score": 0.00017, "epss_percentile": 0.03126}, "CVE-2021-47064": {"epss_score": 0.00051, "epss_percentile": 0.16274}, "CVE-2021-47065": {"epss_score": 0.00038, "epss_percentile": 0.11402}, "CVE-2021-47066": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47067": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2021-47068": {"epss_score": 0.00015, "epss_percentile": 0.02163}, "CVE-2021-47069": {"epss_score": 0.00018, "epss_percentile": 0.0391}, "CVE-2021-47070": {"epss_score": 0.00015, "epss_percentile": 0.02137}, "CVE-2021-47071": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2021-47072": {"epss_score": 0.00013, "epss_percentile": 0.01539}, "CVE-2021-47073": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2021-47074": {"epss_score": 0.0001, "epss_percentile": 0.00915}, "CVE-2021-47075": {"epss_score": 0.00051, "epss_percentile": 0.16274}, "CVE-2021-47076": {"epss_score": 0.00015, "epss_percentile": 0.02322}, "CVE-2021-47077": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47078": {"epss_score": 0.0001, "epss_percentile": 0.0086}, "CVE-2021-47079": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2021-47080": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47081": {"epss_score": 0.00034, "epss_percentile": 0.09669}, "CVE-2021-47082": {"epss_score": 0.00031, "epss_percentile": 0.08409}, "CVE-2021-47083": {"epss_score": 0.00016, "epss_percentile": 0.0267}, "CVE-2021-47086": {"epss_score": 8e-05, "epss_percentile": 0.00545}, "CVE-2021-47087": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2021-47088": {"epss_score": 0.00018, "epss_percentile": 0.03628}, "CVE-2021-47089": {"epss_score": 0.0001, "epss_percentile": 0.00832}, "CVE-2021-47090": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2021-47091": {"epss_score": 0.00012, "epss_percentile": 0.01249}, "CVE-2021-47092": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2021-47093": {"epss_score": 0.00012, "epss_percentile": 0.01285}, "CVE-2021-47094": {"epss_score": 0.00015, "epss_percentile": 0.02225}, "CVE-2021-47095": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47096": {"epss_score": 0.00014, "epss_percentile": 0.01748}, "CVE-2021-47097": {"epss_score": 0.0001, "epss_percentile": 0.00833}, "CVE-2021-47098": {"epss_score": 0.00015, "epss_percentile": 0.02348}, "CVE-2021-47099": {"epss_score": 0.00013, "epss_percentile": 0.01586}, "CVE-2021-47100": {"epss_score": 9e-05, "epss_percentile": 0.00742}, "CVE-2021-47101": {"epss_score": 9e-05, "epss_percentile": 0.00625}, "CVE-2021-47102": {"epss_score": 9e-05, "epss_percentile": 0.00625}, "CVE-2021-47103": {"epss_score": 0.0003, "epss_percentile": 0.08055}, "CVE-2021-47104": {"epss_score": 0.00012, "epss_percentile": 0.01144}, "CVE-2021-47105": {"epss_score": 0.00014, "epss_percentile": 0.02052}, "CVE-2021-47106": {"epss_score": 0.00015, "epss_percentile": 0.02348}, "CVE-2021-47107": {"epss_score": 0.00016, "epss_percentile": 0.02639}, "CVE-2021-47108": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2021-47109": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47110": {"epss_score": 0.00018, "epss_percentile": 0.03983}, "CVE-2021-47111": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2021-47112": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47113": {"epss_score": 0.0001, "epss_percentile": 0.00915}, "CVE-2021-47114": {"epss_score": 0.00012, "epss_percentile": 0.01177}, "CVE-2021-47116": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2021-47117": {"epss_score": 0.00012, "epss_percentile": 0.01177}, "CVE-2021-47118": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2021-47119": {"epss_score": 9e-05, "epss_percentile": 0.00657}, "CVE-2021-47120": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47121": {"epss_score": 0.00014, "epss_percentile": 0.01777}, "CVE-2021-47122": {"epss_score": 7e-05, "epss_percentile": 0.00366}, "CVE-2021-47123": {"epss_score": 0.00018, "epss_percentile": 0.03628}, "CVE-2021-47124": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2021-47125": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2021-47126": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2021-47127": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2021-47128": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2021-47129": {"epss_score": 0.00049, "epss_percentile": 0.15509}, "CVE-2021-47130": {"epss_score": 0.00013, "epss_percentile": 0.01718}, "CVE-2021-47131": {"epss_score": 0.00017, "epss_percentile": 0.03348}, "CVE-2021-47132": {"epss_score": 0.0002, "epss_percentile": 0.04673}, "CVE-2021-47133": {"epss_score": 0.00017, "epss_percentile": 0.03202}, "CVE-2021-47134": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47135": {"epss_score": 0.00018, "epss_percentile": 0.03628}, "CVE-2021-47136": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47137": {"epss_score": 0.00018, "epss_percentile": 0.03613}, "CVE-2021-47138": {"epss_score": 0.00016, "epss_percentile": 0.0267}, "CVE-2021-47139": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47140": {"epss_score": 0.00047, "epss_percentile": 0.1466}, "CVE-2021-47141": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47142": {"epss_score": 0.00012, "epss_percentile": 0.01144}, "CVE-2021-47143": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47145": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2021-47146": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2021-47147": {"epss_score": 0.00017, "epss_percentile": 0.03148}, "CVE-2021-47148": {"epss_score": 0.00022, "epss_percentile": 0.05001}, "CVE-2021-47149": {"epss_score": 0.00012, "epss_percentile": 0.01177}, "CVE-2021-47150": {"epss_score": 9e-05, "epss_percentile": 0.00742}, "CVE-2021-47151": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2021-47152": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2021-47153": {"epss_score": 6e-05, "epss_percentile": 0.00237}, "CVE-2021-47154": {"epss_score": 0.0004, "epss_percentile": 0.1215}, "CVE-2021-47155": {"epss_score": 0.00054, "epss_percentile": 0.17227}, "CVE-2021-47156": {"epss_score": 0.00125, "epss_percentile": 0.32577}, "CVE-2021-47157": {"epss_score": 0.00088, "epss_percentile": 0.25703}, "CVE-2021-47158": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2021-47159": {"epss_score": 0.00022, "epss_percentile": 0.05144}, "CVE-2021-47160": {"epss_score": 0.00022, "epss_percentile": 0.04949}, "CVE-2021-47161": {"epss_score": 0.00014, "epss_percentile": 0.02037}, "CVE-2021-47162": {"epss_score": 8e-05, "epss_percentile": 0.00533}, "CVE-2021-47163": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2021-47164": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47165": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2021-47166": {"epss_score": 0.00014, "epss_percentile": 0.01777}, "CVE-2021-47167": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47168": {"epss_score": 0.00016, "epss_percentile": 0.02804}, "CVE-2021-47169": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2021-47170": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2021-47171": {"epss_score": 7e-05, "epss_percentile": 0.00366}, "CVE-2021-47172": {"epss_score": 0.00018, "epss_percentile": 0.03652}, "CVE-2021-47173": {"epss_score": 0.00014, "epss_percentile": 0.01777}, "CVE-2021-47174": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2021-47175": {"epss_score": 0.00018, "epss_percentile": 0.03943}, "CVE-2021-47176": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2021-47177": {"epss_score": 0.00014, "epss_percentile": 0.02023}, "CVE-2021-47178": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47179": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2021-47180": {"epss_score": 0.00014, "epss_percentile": 0.01777}, "CVE-2021-47181": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2021-47182": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2021-47183": {"epss_score": 0.00026, "epss_percentile": 0.06415}, "CVE-2021-47184": {"epss_score": 8e-05, "epss_percentile": 0.0059}, "CVE-2021-47185": {"epss_score": 5e-05, "epss_percentile": 0.00199}, "CVE-2021-47186": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47187": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47188": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2021-47189": {"epss_score": 0.00178, "epss_percentile": 0.39669}, "CVE-2021-47190": {"epss_score": 0.0001, "epss_percentile": 0.00915}, "CVE-2021-47191": {"epss_score": 9e-05, "epss_percentile": 0.0071}, "CVE-2021-47192": {"epss_score": 0.00023, "epss_percentile": 0.05379}, "CVE-2021-47193": {"epss_score": 0.00019, "epss_percentile": 0.04203}, "CVE-2021-47194": {"epss_score": 0.00018, "epss_percentile": 0.03833}, "CVE-2021-47195": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2021-47196": {"epss_score": 0.00018, "epss_percentile": 0.03628}, "CVE-2021-47197": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47198": {"epss_score": 0.00018, "epss_percentile": 0.03628}, "CVE-2021-47199": {"epss_score": 0.00019, "epss_percentile": 0.04276}, "CVE-2021-47200": {"epss_score": 0.00012, "epss_percentile": 0.01282}, "CVE-2021-47201": {"epss_score": 0.00011, "epss_percentile": 0.00925}, "CVE-2021-47202": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2021-47203": {"epss_score": 9e-05, "epss_percentile": 0.00694}, "CVE-2021-47204": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2021-47205": {"epss_score": 0.00017, "epss_percentile": 0.03202}, "CVE-2021-47206": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2021-47207": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2021-47208": {"epss_score": 0.00044, "epss_percentile": 0.13537}, "CVE-2021-47209": {"epss_score": 0.00017, "epss_percentile": 0.03154}, "CVE-2021-47210": {"epss_score": 0.00019, "epss_percentile": 0.04149}, "CVE-2021-47211": {"epss_score": 9e-05, "epss_percentile": 0.006}, "CVE-2021-47212": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2021-47214": {"epss_score": 0.00017, "epss_percentile": 0.03154}, "CVE-2021-47215": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2021-47216": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2021-47217": {"epss_score": 0.00011, "epss_percentile": 0.01017}, "CVE-2021-47218": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47219": {"epss_score": 9e-05, "epss_percentile": 0.0071}, "CVE-2021-47221": {"epss_score": 0.00021, "epss_percentile": 0.04793}, "CVE-2021-47222": {"epss_score": 0.00016, "epss_percentile": 0.0273}, "CVE-2021-47223": {"epss_score": 9e-05, "epss_percentile": 0.00649}, "CVE-2021-47224": {"epss_score": 0.00052, "epss_percentile": 0.1657}, "CVE-2021-47225": {"epss_score": 0.00016, "epss_percentile": 0.02695}, "CVE-2021-47226": {"epss_score": 0.00053, "epss_percentile": 0.16727}, "CVE-2021-47227": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2021-47228": {"epss_score": 0.00018, "epss_percentile": 0.03719}, "CVE-2021-47229": {"epss_score": 8e-05, "epss_percentile": 0.00582}, "CVE-2021-47230": {"epss_score": 0.00018, "epss_percentile": 0.03862}, "CVE-2021-47231": {"epss_score": 8e-05, "epss_percentile": 0.00569}, "CVE-2021-47232": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2021-47233": {"epss_score": 0.00053, "epss_percentile": 0.16875}, "CVE-2021-47234": {"epss_score": 0.00021, "epss_percentile": 0.04758}, "CVE-2021-47235": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2021-47236": {"epss_score": 6e-05, "epss_percentile": 0.00313}, "CVE-2021-47237": {"epss_score": 0.00014, "epss_percentile": 0.01777}, "CVE-2021-47238": {"epss_score": 0.00014, "epss_percentile": 0.02037}, "CVE-2021-47239": {"epss_score": 0.00014, "epss_percentile": 0.02118}, "CVE-2021-47240": {"epss_score": 0.00037, "epss_percentile": 0.1074}, "CVE-2021-47241": {"epss_score": 0.00047, "epss_percentile": 0.14775}, "CVE-2021-47242": {"epss_score": 0.00016, "epss_percentile": 0.02745}, "CVE-2021-47243": {"epss_score": 0.00116, "epss_percentile": 0.31182}, "CVE-2021-47244": {"epss_score": 0.00072, "epss_percentile": 0.22273}, "CVE-2021-47245": {"epss_score": 9e-05, "epss_percentile": 0.00731}, "CVE-2021-47246": {"epss_score": 0.0001, "epss_percentile": 0.009}, "CVE-2021-47247": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2021-47248": {"epss_score": 7e-05, "epss_percentile": 0.00337}, "CVE-2021-47249": {"epss_score": 8e-05, "epss_percentile": 0.00533}, "CVE-2021-47250": {"epss_score": 0.00014, "epss_percentile": 0.01777}, "CVE-2021-47251": {"epss_score": 0.00022, "epss_percentile": 0.04963}, "CVE-2021-47252": {"epss_score": 8e-05, "epss_percentile": 0.00538}, "CVE-2021-47253": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2021-47254": {"epss_score": 0.00018, "epss_percentile": 0.03833}, "CVE-2021-47255": {"epss_score": 0.00011, "epss_percentile": 0.00984}, "CVE-2021-47256": {"epss_score": 0.0001, "epss_percentile": 0.00808}, "CVE-2021-47257": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2021-47258": {"epss_score": 0.00014, "epss_percentile": 0.01984}, "CVE-2021-47259": {"epss_score": 0.0008, "epss_percentile": 0.24148}, "CVE-2021-47260": {"epss_score": 7e-05, "epss_percentile": 0.00375}, "CVE-2021-47261": {"epss_score": 0.00017, "epss_percentile": 0.03503}, "CVE-2021-47262": {"epss_score": 0.00022, "epss_percentile": 0.04963}, "CVE-2021-47263": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2021-47264": {"epss_score": 0.00021, "epss_percentile": 0.04859}, "CVE-2021-47265": {"epss_score": 0.0001, "epss_percentile": 0.00823}, "CVE-2021-47266": {"epss_score": 0.00021, "epss_percentile": 0.04859}, "CVE-2021-47267": {"epss_score": 0.00088, "epss_percentile": 0.25773}, "CVE-2021-47268": {"epss_score": 0.00022, "epss_percentile": 0.05003}, "CVE-2021-47269": {"epss_score": 9e-05, "epss_percentile": 0.00746}, "CVE-2021-47270": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2021-47271": {"epss_score": 0.00016, "epss_percentile": 0.02695}, "CVE-2021-47272": {"epss_score": 0.00021, "epss_percentile": 0.04809}, "CVE-2021-47273": {"epss_score": 0.00021, "epss_percentile": 0.04859}, "CVE-2021-47274": {"epss_score": 0.00048, "epss_percentile": 0.15125}, "CVE-2021-47275": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2021-47276": {"epss_score": 0.00014, "epss_percentile": 0.018}, "CVE-2021-47277": {"epss_score": 0.00012, "epss_percentile": 0.013}, "CVE-2021-47278": {"epss_score": 0.00043, "epss_percentile": 0.12949}, "CVE-2021-47279": {"epss_score": 0.00041, "epss_percentile": 0.12375}, "CVE-2021-47280": {"epss_score": 0.00015, "epss_percentile": 0.022}, "CVE-2021-47281": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2021-47282": {"epss_score": 0.00054, "epss_percentile": 0.17233}, "CVE-2021-47283": {"epss_score": 0.00021, "epss_percentile": 0.04859}, "CVE-2021-47284": {"epss_score": 7e-05, "epss_percentile": 0.00375}, "CVE-2021-47286": {"epss_score": 0.00097, "epss_percentile": 0.27522}, "CVE-2021-47287": {"epss_score": 0.00014, "epss_percentile": 0.02052}, "CVE-2021-47288": {"epss_score": 8e-05, "epss_percentile": 0.00555}, "CVE-2021-47289": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2021-47290": {"epss_score": 0.00083, "epss_percentile": 0.24614}, "CVE-2021-47291": {"epss_score": 9e-05, "epss_percentile": 0.0071}, "CVE-2021-47292": {"epss_score": 0.00083, "epss_percentile": 0.24614}, "CVE-2021-47293": {"epss_score": 0.00026, "epss_percentile": 0.06443}, "CVE-2021-47294": {"epss_score": 0.00017, "epss_percentile": 0.033}, "CVE-2021-47295": {"epss_score": 0.00103, "epss_percentile": 0.29034}, "CVE-2021-47296": {"epss_score": 0.00011, "epss_percentile": 0.01025}, "CVE-2021-47297": {"epss_score": 0.00014, "epss_percentile": 0.018}, "CVE-2021-47298": {"epss_score": 0.00094, "epss_percentile": 0.26766}, "CVE-2021-47299": {"epss_score": 0.00094, "epss_percentile": 0.26766}, "CVE-2021-47300": {"epss_score": 0.00021, "epss_percentile": 0.04793}, "CVE-2021-47301": {"epss_score": 0.00019, "epss_percentile": 0.04172}, "CVE-2021-47302": {"epss_score": 5e-05, "epss_percentile": 0.00184}, "CVE-2021-47303": {"epss_score": 0.00097, "epss_percentile": 0.27522}, "CVE-2021-47304": {"epss_score": 9e-05, "epss_percentile": 0.00657}, "CVE-2021-47305": {"epss_score": 0.00014, "epss_percentile": 0.02037}, "CVE-2021-47306": {"epss_score": 0.00097, "epss_percentile": 0.27522}, "CVE-2021-47307": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47308": {"epss_score": 0.00058, "epss_percentile": 0.18461}, "CVE-2021-47309": {"epss_score": 0.00014, "epss_percentile": 0.01868}, "CVE-2021-47310": {"epss_score": 0.00011, "epss_percentile": 0.01095}, "CVE-2021-47311": {"epss_score": 0.00012, "epss_percentile": 0.01244}, "CVE-2021-47312": {"epss_score": 0.00052, "epss_percentile": 0.16384}, "CVE-2021-47313": {"epss_score": 0.00097, "epss_percentile": 0.27511}, "CVE-2021-47314": {"epss_score": 9e-05, "epss_percentile": 0.00606}, "CVE-2021-47315": {"epss_score": 4e-05, "epss_percentile": 0.00148}, "CVE-2021-47316": {"epss_score": 0.00094, "epss_percentile": 0.26766}, "CVE-2021-47317": {"epss_score": 0.00075, "epss_percentile": 0.22965}, "CVE-2021-47318": {"epss_score": 0.00086, "epss_percentile": 0.25284}, "CVE-2021-47319": {"epss_score": 0.00011, "epss_percentile": 0.01027}, "CVE-2021-47320": {"epss_score": 7e-05, "epss_percentile": 0.00436}, "CVE-2021-47321": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2021-47322": {"epss_score": 0.00022, "epss_percentile": 0.04963}, "CVE-2021-47323": {"epss_score": 0.00134, "epss_percentile": 0.33896}, "CVE-2021-47324": {"epss_score": 0.00134, "epss_percentile": 0.33896}, "CVE-2021-47325": {"epss_score": 0.00022, "epss_percentile": 0.05146}, "CVE-2021-47327": {"epss_score": 0.00047, "epss_percentile": 0.14898}, "CVE-2021-47328": {"epss_score": 0.00019, "epss_percentile": 0.04172}, "CVE-2021-47329": {"epss_score": 0.00019, "epss_percentile": 0.04065}, "CVE-2021-47330": {"epss_score": 0.00011, "epss_percentile": 0.01027}, "CVE-2021-47331": {"epss_score": 0.00041, "epss_percentile": 0.12347}, "CVE-2021-47332": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2021-47333": {"epss_score": 0.00019, "epss_percentile": 0.04069}, "CVE-2021-47334": {"epss_score": 0.00029, "epss_percentile": 0.0765}, "CVE-2021-47335": {"epss_score": 0.00019, "epss_percentile": 0.04079}, "CVE-2021-47336": {"epss_score": 0.00019, "epss_percentile": 0.0417}, "CVE-2021-47337": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2021-47338": {"epss_score": 0.00031, "epss_percentile": 0.08465}, "CVE-2021-47339": {"epss_score": 0.00019, "epss_percentile": 0.04185}, "CVE-2021-47340": {"epss_score": 0.00013, "epss_percentile": 0.01574}, "CVE-2021-47341": {"epss_score": 0.00026, "epss_percentile": 0.06388}, "CVE-2021-47342": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2021-47343": {"epss_score": 0.00013, "epss_percentile": 0.01574}, "CVE-2021-47344": {"epss_score": 9e-05, "epss_percentile": 0.00606}, "CVE-2021-47345": {"epss_score": 9e-05, "epss_percentile": 0.00606}, "CVE-2021-47346": {"epss_score": 0.00014, "epss_percentile": 0.02112}, "CVE-2021-47347": {"epss_score": 0.00144, "epss_percentile": 0.35299}, "CVE-2021-47348": {"epss_score": 0.00056, "epss_percentile": 0.17927}, "CVE-2021-47349": {"epss_score": 0.00021, "epss_percentile": 0.04785}, "CVE-2021-47350": {"epss_score": 0.00014, "epss_percentile": 0.02113}, "CVE-2021-47351": {"epss_score": 0.00023, "epss_percentile": 0.05493}, "CVE-2021-47352": {"epss_score": 0.00021, "epss_percentile": 0.04824}, "CVE-2021-47353": {"epss_score": 0.0001, "epss_percentile": 0.00855}, "CVE-2021-47354": {"epss_score": 0.00059, "epss_percentile": 0.18743}, "CVE-2021-47355": {"epss_score": 0.00017, "epss_percentile": 0.03338}, "CVE-2021-47356": {"epss_score": 0.00014, "epss_percentile": 0.02061}, "CVE-2021-47357": {"epss_score": 0.00017, "epss_percentile": 0.03338}, "CVE-2021-47358": {"epss_score": 0.00016, "epss_percentile": 0.02833}, "CVE-2021-47359": {"epss_score": 0.00011, "epss_percentile": 0.01072}, "CVE-2021-47360": {"epss_score": 9e-05, "epss_percentile": 0.00662}, "CVE-2021-47361": {"epss_score": 0.00016, "epss_percentile": 0.02833}, "CVE-2021-47362": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47363": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2021-47364": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2021-47365": {"epss_score": 8e-05, "epss_percentile": 0.00591}, "CVE-2021-47366": {"epss_score": 0.00014, "epss_percentile": 0.02025}, "CVE-2021-47367": {"epss_score": 0.00014, "epss_percentile": 0.01825}, "CVE-2021-47368": {"epss_score": 0.00028, "epss_percentile": 0.07292}, "CVE-2021-47369": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2021-47370": {"epss_score": 0.00019, "epss_percentile": 0.04377}, "CVE-2021-47371": {"epss_score": 0.00015, "epss_percentile": 0.0215}, "CVE-2021-47372": {"epss_score": 0.00016, "epss_percentile": 0.02833}, "CVE-2021-47373": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2021-47374": {"epss_score": 0.00014, "epss_percentile": 0.02076}, "CVE-2021-47375": {"epss_score": 7e-05, "epss_percentile": 0.00371}, "CVE-2021-47376": {"epss_score": 9e-05, "epss_percentile": 0.00662}, "CVE-2021-47378": {"epss_score": 0.0007, "epss_percentile": 0.2168}, "CVE-2021-47379": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2021-47380": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2021-47381": {"epss_score": 0.00014, "epss_percentile": 0.01825}, "CVE-2021-47382": {"epss_score": 0.00011, "epss_percentile": 0.01072}, "CVE-2021-47383": {"epss_score": 6e-05, "epss_percentile": 0.00322}, "CVE-2021-47384": {"epss_score": 0.00035, "epss_percentile": 0.09916}, "CVE-2021-47385": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47386": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2021-47387": {"epss_score": 7e-05, "epss_percentile": 0.00403}, "CVE-2021-47388": {"epss_score": 0.00015, "epss_percentile": 0.0253}, "CVE-2021-47389": {"epss_score": 0.00015, "epss_percentile": 0.02244}, "CVE-2021-47390": {"epss_score": 0.00016, "epss_percentile": 0.0267}, "CVE-2021-47391": {"epss_score": 0.00013, "epss_percentile": 0.01484}, "CVE-2021-47392": {"epss_score": 0.00015, "epss_percentile": 0.02369}, "CVE-2021-47393": {"epss_score": 0.00031, "epss_percentile": 0.08624}, "CVE-2021-47394": {"epss_score": 0.00015, "epss_percentile": 0.02348}, "CVE-2021-47395": {"epss_score": 0.00012, "epss_percentile": 0.01294}, "CVE-2021-47396": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2021-47397": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2021-47398": {"epss_score": 0.00014, "epss_percentile": 0.02025}, "CVE-2021-47399": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47400": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47401": {"epss_score": 0.0001, "epss_percentile": 0.00862}, "CVE-2021-47402": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2021-47403": {"epss_score": 0.00012, "epss_percentile": 0.01188}, "CVE-2021-47404": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2021-47405": {"epss_score": 7e-05, "epss_percentile": 0.00366}, "CVE-2021-47406": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2021-47407": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2021-47408": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2021-47409": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2021-47410": {"epss_score": 0.00014, "epss_percentile": 0.02076}, "CVE-2021-47412": {"epss_score": 0.00027, "epss_percentile": 0.07106}, "CVE-2021-47413": {"epss_score": 0.00028, "epss_percentile": 0.07332}, "CVE-2021-47414": {"epss_score": 0.00028, "epss_percentile": 0.07283}, "CVE-2021-47415": {"epss_score": 0.00026, "epss_percentile": 0.06657}, "CVE-2021-47416": {"epss_score": 0.00012, "epss_percentile": 0.01358}, "CVE-2021-47417": {"epss_score": 0.00026, "epss_percentile": 0.06573}, "CVE-2021-47418": {"epss_score": 0.00021, "epss_percentile": 0.04893}, "CVE-2021-47419": {"epss_score": 0.00028, "epss_percentile": 0.07283}, "CVE-2021-47420": {"epss_score": 0.00026, "epss_percentile": 0.06573}, "CVE-2021-47421": {"epss_score": 0.00059, "epss_percentile": 0.18834}, "CVE-2021-47422": {"epss_score": 0.00028, "epss_percentile": 0.07261}, "CVE-2021-47423": {"epss_score": 0.00022, "epss_percentile": 0.05162}, "CVE-2021-47424": {"epss_score": 0.00029, "epss_percentile": 0.07688}, "CVE-2021-47425": {"epss_score": 0.00022, "epss_percentile": 0.05055}, "CVE-2021-47426": {"epss_score": 0.00028, "epss_percentile": 0.07261}, "CVE-2021-47427": {"epss_score": 0.00027, "epss_percentile": 0.07139}, "CVE-2021-47428": {"epss_score": 0.00028, "epss_percentile": 0.07332}, "CVE-2021-47429": {"epss_score": 0.00026, "epss_percentile": 0.06657}, "CVE-2021-47430": {"epss_score": 0.00028, "epss_percentile": 0.07489}, "CVE-2021-47431": {"epss_score": 0.00016, "epss_percentile": 0.02897}, "CVE-2021-47432": {"epss_score": 8e-05, "epss_percentile": 0.00578}, "CVE-2021-47433": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2021-47434": {"epss_score": 8e-05, "epss_percentile": 0.00493}, "CVE-2021-47435": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2021-47436": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2021-47437": {"epss_score": 0.00011, "epss_percentile": 0.01072}, "CVE-2021-47438": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2021-47439": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2021-47440": {"epss_score": 4e-05, "epss_percentile": 0.00161}, "CVE-2021-47441": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2021-47442": {"epss_score": 0.00012, "epss_percentile": 0.01144}, "CVE-2021-47443": {"epss_score": 7e-05, "epss_percentile": 0.00356}, "CVE-2021-47444": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2021-47445": {"epss_score": 0.00012, "epss_percentile": 0.01177}, "CVE-2021-47446": {"epss_score": 0.00014, "epss_percentile": 0.02076}, "CVE-2021-47447": {"epss_score": 0.00014, "epss_percentile": 0.02076}, "CVE-2021-47448": {"epss_score": 0.00014, "epss_percentile": 0.02076}, "CVE-2021-47449": {"epss_score": 0.00014, "epss_percentile": 0.02091}, "CVE-2021-47450": {"epss_score": 0.00014, "epss_percentile": 0.02076}, "CVE-2021-47451": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2021-47452": {"epss_score": 0.00014, "epss_percentile": 0.02076}, "CVE-2021-47453": {"epss_score": 0.00017, "epss_percentile": 0.03154}, "CVE-2021-47454": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47455": {"epss_score": 0.0002, "epss_percentile": 0.046}, "CVE-2021-47456": {"epss_score": 0.00021, "epss_percentile": 0.04727}, "CVE-2021-47457": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2021-47458": {"epss_score": 0.00033, "epss_percentile": 0.09197}, "CVE-2021-47459": {"epss_score": 0.00023, "epss_percentile": 0.05516}, "CVE-2021-47460": {"epss_score": 0.00026, "epss_percentile": 0.06539}, "CVE-2021-47461": {"epss_score": 0.00013, "epss_percentile": 0.01488}, "CVE-2021-47462": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2021-47463": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2021-47464": {"epss_score": 0.00027, "epss_percentile": 0.06958}, "CVE-2021-47465": {"epss_score": 0.0004, "epss_percentile": 0.12081}, "CVE-2021-47466": {"epss_score": 0.00028, "epss_percentile": 0.07261}, "CVE-2021-47467": {"epss_score": 0.00086, "epss_percentile": 0.25382}, "CVE-2021-47468": {"epss_score": 0.0001, "epss_percentile": 0.00788}, "CVE-2021-47470": {"epss_score": 0.00032, "epss_percentile": 0.09071}, "CVE-2021-47471": {"epss_score": 0.00047, "epss_percentile": 0.14758}, "CVE-2021-47473": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2021-47474": {"epss_score": 0.00017, "epss_percentile": 0.03307}, "CVE-2021-47475": {"epss_score": 0.00017, "epss_percentile": 0.03307}, "CVE-2021-47476": {"epss_score": 0.00036, "epss_percentile": 0.10518}, "CVE-2021-47477": {"epss_score": 0.00062, "epss_percentile": 0.19746}, "CVE-2021-47478": {"epss_score": 0.00012, "epss_percentile": 0.0132}, "CVE-2021-47479": {"epss_score": 0.00019, "epss_percentile": 0.0408}, "CVE-2021-47480": {"epss_score": 0.00025, "epss_percentile": 0.06205}, "CVE-2021-47481": {"epss_score": 0.00031, "epss_percentile": 0.08477}, "CVE-2021-47482": {"epss_score": 0.00083, "epss_percentile": 0.24765}, "CVE-2021-47483": {"epss_score": 0.00022, "epss_percentile": 0.05286}, "CVE-2021-47484": {"epss_score": 0.00031, "epss_percentile": 0.08477}, "CVE-2021-47485": {"epss_score": 0.00026, "epss_percentile": 0.06678}, "CVE-2021-47486": {"epss_score": 0.00114, "epss_percentile": 0.30849}, "CVE-2021-47489": {"epss_score": 0.00023, "epss_percentile": 0.05516}, "CVE-2021-47490": {"epss_score": 0.00026, "epss_percentile": 0.06518}, "CVE-2021-47491": {"epss_score": 0.00016, "epss_percentile": 0.02927}, "CVE-2021-47492": {"epss_score": 0.00019, "epss_percentile": 0.04237}, "CVE-2021-47493": {"epss_score": 0.00025, "epss_percentile": 0.06348}, "CVE-2021-47494": {"epss_score": 0.00025, "epss_percentile": 0.06348}, "CVE-2021-47495": {"epss_score": 0.00012, "epss_percentile": 0.01131}, "CVE-2021-47496": {"epss_score": 0.00026, "epss_percentile": 0.06465}, "CVE-2021-47497": {"epss_score": 0.00022, "epss_percentile": 0.05286}, "CVE-2021-47498": {"epss_score": 0.00047, "epss_percentile": 0.14758}, "CVE-2021-47499": {"epss_score": 0.00014, "epss_percentile": 0.01777}, "CVE-2021-47500": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2021-47501": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2021-47502": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2021-47503": {"epss_score": 0.00018, "epss_percentile": 0.03719}, "CVE-2021-47504": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2021-47505": {"epss_score": 0.0002, "epss_percentile": 0.04657}, "CVE-2021-47506": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2021-47507": {"epss_score": 0.00014, "epss_percentile": 0.01892}, "CVE-2021-47508": {"epss_score": 0.00017, "epss_percentile": 0.03154}, "CVE-2021-47509": {"epss_score": 0.00014, "epss_percentile": 0.018}, "CVE-2021-47510": {"epss_score": 0.0002, "epss_percentile": 0.04512}, "CVE-2021-47511": {"epss_score": 8e-05, "epss_percentile": 0.00538}, "CVE-2021-47512": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47513": {"epss_score": 0.0002, "epss_percentile": 0.04499}, "CVE-2021-47514": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47515": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2021-47516": {"epss_score": 8e-05, "epss_percentile": 0.00576}, "CVE-2021-47517": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2021-47518": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2021-47519": {"epss_score": 0.00038, "epss_percentile": 0.11298}, "CVE-2021-47520": {"epss_score": 0.00018, "epss_percentile": 0.03833}, "CVE-2021-47521": {"epss_score": 0.00018, "epss_percentile": 0.03833}, "CVE-2021-47522": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47523": {"epss_score": 0.00018, "epss_percentile": 0.03652}, "CVE-2021-47524": {"epss_score": 0.00017, "epss_percentile": 0.03154}, "CVE-2021-47525": {"epss_score": 0.00018, "epss_percentile": 0.03628}, "CVE-2021-47526": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2021-47527": {"epss_score": 7e-05, "epss_percentile": 0.0041}, "CVE-2021-47528": {"epss_score": 0.00018, "epss_percentile": 0.03706}, "CVE-2021-47529": {"epss_score": 0.0002, "epss_percentile": 0.04499}, "CVE-2021-47530": {"epss_score": 0.0002, "epss_percentile": 0.04512}, "CVE-2021-47531": {"epss_score": 0.0002, "epss_percentile": 0.04512}, "CVE-2021-47532": {"epss_score": 0.00018, "epss_percentile": 0.03556}, "CVE-2021-47533": {"epss_score": 0.00018, "epss_percentile": 0.04022}, "CVE-2021-47534": {"epss_score": 7e-05, "epss_percentile": 0.00466}, "CVE-2021-47535": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2021-47536": {"epss_score": 0.00021, "epss_percentile": 0.04791}, "CVE-2021-47537": {"epss_score": 0.00017, "epss_percentile": 0.03202}, "CVE-2021-47538": {"epss_score": 0.00011, "epss_percentile": 0.01025}, "CVE-2021-47539": {"epss_score": 0.00018, "epss_percentile": 0.03652}, "CVE-2021-47540": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47541": {"epss_score": 0.00019, "epss_percentile": 0.0409}, "CVE-2021-47542": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2021-47544": {"epss_score": 0.00054, "epss_percentile": 0.17213}, "CVE-2021-47546": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2021-47547": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2021-47548": {"epss_score": 0.0006, "epss_percentile": 0.19103}, "CVE-2021-47549": {"epss_score": 0.00018, "epss_percentile": 0.03833}, "CVE-2021-47550": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2021-47551": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2021-47552": {"epss_score": 4e-05, "epss_percentile": 0.00161}, "CVE-2021-47553": {"epss_score": 0.00022, "epss_percentile": 0.05268}, "CVE-2021-47554": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2021-47555": {"epss_score": 0.00033, "epss_percentile": 0.09169}, "CVE-2021-47556": {"epss_score": 0.00018, "epss_percentile": 0.03857}, "CVE-2021-47557": {"epss_score": 0.00012, "epss_percentile": 0.01309}, "CVE-2021-47558": {"epss_score": 0.00031, "epss_percentile": 0.08477}, "CVE-2021-47559": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2021-47560": {"epss_score": 0.00028, "epss_percentile": 0.07332}, "CVE-2021-47561": {"epss_score": 0.00036, "epss_percentile": 0.10453}, "CVE-2021-47562": {"epss_score": 0.00021, "epss_percentile": 0.04756}, "CVE-2021-47563": {"epss_score": 0.00019, "epss_percentile": 0.04289}, "CVE-2021-47564": {"epss_score": 0.00034, "epss_percentile": 0.09728}, "CVE-2021-47565": {"epss_score": 0.00033, "epss_percentile": 0.09294}, "CVE-2021-47566": {"epss_score": 0.00034, "epss_percentile": 0.09598}, "CVE-2021-47567": {"epss_score": 0.0004, "epss_percentile": 0.12178}, "CVE-2021-47568": {"epss_score": 0.00031, "epss_percentile": 0.08452}, "CVE-2021-47569": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2021-47570": {"epss_score": 0.00031, "epss_percentile": 0.08452}, "CVE-2021-47571": {"epss_score": 0.00033, "epss_percentile": 0.09294}, "CVE-2021-47572": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2021-47576": {"epss_score": 0.00013, "epss_percentile": 0.01534}, "CVE-2021-47577": {"epss_score": 0.00013, "epss_percentile": 0.01612}, "CVE-2021-47578": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47579": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2021-47580": {"epss_score": 0.00015, "epss_percentile": 0.02467}, "CVE-2021-47582": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2021-47583": {"epss_score": 0.00011, "epss_percentile": 0.01017}, "CVE-2021-47584": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47585": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2021-47586": {"epss_score": 0.00017, "epss_percentile": 0.03154}, "CVE-2021-47587": {"epss_score": 5e-05, "epss_percentile": 0.00236}, "CVE-2021-47588": {"epss_score": 0.00014, "epss_percentile": 0.02037}, "CVE-2021-47589": {"epss_score": 0.00014, "epss_percentile": 0.01923}, "CVE-2021-47590": {"epss_score": 0.00013, "epss_percentile": 0.01633}, "CVE-2021-47591": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2021-47592": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2021-47593": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47594": {"epss_score": 0.0001, "epss_percentile": 0.00827}, "CVE-2021-47595": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2021-47596": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2021-47597": {"epss_score": 0.00017, "epss_percentile": 0.03349}, "CVE-2021-47598": {"epss_score": 0.00017, "epss_percentile": 0.03417}, "CVE-2021-47599": {"epss_score": 0.00013, "epss_percentile": 0.01633}, "CVE-2021-47600": {"epss_score": 0.00014, "epss_percentile": 0.02118}, "CVE-2021-47601": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2021-47602": {"epss_score": 0.00017, "epss_percentile": 0.03315}, "CVE-2021-47603": {"epss_score": 0.00018, "epss_percentile": 0.0373}, "CVE-2021-47604": {"epss_score": 0.00032, "epss_percentile": 0.08829}, "CVE-2021-47605": {"epss_score": 0.00076, "epss_percentile": 0.23092}, "CVE-2021-47606": {"epss_score": 0.00012, "epss_percentile": 0.01422}, "CVE-2021-47607": {"epss_score": 0.0002, "epss_percentile": 0.04431}, "CVE-2021-47608": {"epss_score": 0.00062, "epss_percentile": 0.19659}, "CVE-2021-47609": {"epss_score": 0.00039, "epss_percentile": 0.11653}, "CVE-2021-47610": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2021-47611": {"epss_score": 0.00034, "epss_percentile": 0.09706}, "CVE-2021-47612": {"epss_score": 0.00015, "epss_percentile": 0.02194}, "CVE-2021-47613": {"epss_score": 0.00076, "epss_percentile": 0.23092}, "CVE-2021-47614": {"epss_score": 0.00068, "epss_percentile": 0.21188}, "CVE-2021-47616": {"epss_score": 0.00032, "epss_percentile": 0.09071}, "CVE-2021-47617": {"epss_score": 0.00026, "epss_percentile": 0.06588}, "CVE-2021-47618": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2021-47619": {"epss_score": 0.00015, "epss_percentile": 0.02506}, "CVE-2021-47620": {"epss_score": 0.00029, "epss_percentile": 0.07663}, "CVE-2021-47621": {"epss_score": 0.00105, "epss_percentile": 0.29276}, "CVE-2021-47622": {"epss_score": 0.00013, "epss_percentile": 0.01541}, "CVE-2021-47623": {"epss_score": 0.00017, "epss_percentile": 0.03144}, "CVE-2021-47624": {"epss_score": 8e-05, "epss_percentile": 0.00593}, "CVE-2021-47631": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2021-47632": {"epss_score": 0.00023, "epss_percentile": 0.05352}, "CVE-2021-47633": {"epss_score": 0.00046, "epss_percentile": 0.14128}, "CVE-2021-47634": {"epss_score": 0.00097, "epss_percentile": 0.2759}, "CVE-2021-47635": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2021-47636": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2021-47637": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2021-47638": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2021-47639": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2021-47640": {"epss_score": 0.00043, "epss_percentile": 0.13133}, "CVE-2021-47641": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2021-47642": {"epss_score": 0.00027, "epss_percentile": 0.07168}, "CVE-2021-47643": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2021-47644": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2021-47645": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2021-47646": {"epss_score": 0.0005, "epss_percentile": 0.15652}, "CVE-2021-47647": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2021-47648": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2021-47649": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2021-47650": {"epss_score": 0.00052, "epss_percentile": 0.16496}, "CVE-2021-47651": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2021-47652": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2021-47653": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2021-47654": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2021-47655": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2021-47656": {"epss_score": 0.00027, "epss_percentile": 0.07168}, "CVE-2021-47657": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2021-47658": {"epss_score": 0.00047, "epss_percentile": 0.14614}, "CVE-2021-47659": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2021-47660": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2021-47662": {"epss_score": 0.00158, "epss_percentile": 0.37159}, "CVE-2021-47663": {"epss_score": 0.00125, "epss_percentile": 0.32572}, "CVE-2021-47664": {"epss_score": 0.00043, "epss_percentile": 0.1317}, "CVE-2021-47667": {"epss_score": 0.00428, "epss_percentile": 0.61944}, "CVE-2021-47668": {"epss_score": 0.00022, "epss_percentile": 0.04953}, "CVE-2021-47669": {"epss_score": 0.00021, "epss_percentile": 0.04933}, "CVE-2021-47670": {"epss_score": 0.00022, "epss_percentile": 0.05311}, "CVE-2021-47671": {"epss_score": 0.00018, "epss_percentile": 0.03705}, "CVE-2021-47688": {"epss_score": 7e-05, "epss_percentile": 0.00352}, "CVE-2021-47689": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2021-47690": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2021-47691": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2021-47693": {"epss_score": 0.01157, "epss_percentile": 0.7811}, "CVE-2021-47694": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2021-47695": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2021-47696": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2021-47697": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2021-47698": {"epss_score": 0.00434, "epss_percentile": 0.62289}, "CVE-2021-47699": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2021-47700": {"epss_score": 0.0009, "epss_percentile": 0.26056}, "CVE-2021-47701": {"epss_score": 0.0009, "epss_percentile": 0.26046}, "CVE-2021-47702": {"epss_score": 0.00031, "epss_percentile": 0.08654}, "CVE-2021-47703": {"epss_score": 0.00042, "epss_percentile": 0.12587}, "CVE-2021-47704": {"epss_score": 0.00059, "epss_percentile": 0.18727}, "CVE-2021-47705": {"epss_score": 0.00093, "epss_percentile": 0.26723}, "CVE-2021-47706": {"epss_score": 0.00481, "epss_percentile": 0.64487}, "CVE-2021-47707": {"epss_score": 0.00054, "epss_percentile": 0.17215}, "CVE-2021-47708": {"epss_score": 0.0032, "epss_percentile": 0.54577}, "CVE-2021-47709": {"epss_score": 0.00062, "epss_percentile": 0.19699}, "CVE-2021-47710": {"epss_score": 0.00062, "epss_percentile": 0.19699}, "CVE-2021-47711": {"epss_score": 0.00034, "epss_percentile": 0.09626}, "CVE-2021-47712": {"epss_score": 0.00017, "epss_percentile": 0.03321}, "CVE-2021-47713": {"epss_score": 0.00047, "epss_percentile": 0.14594}, "CVE-2021-47714": {"epss_score": 0.00018, "epss_percentile": 0.04007}, "CVE-2021-47715": {"epss_score": 0.00033, "epss_percentile": 0.09199}, "CVE-2021-47716": {"epss_score": 0.00029, "epss_percentile": 0.07783}, "CVE-2021-47717": {"epss_score": 0.00056, "epss_percentile": 0.17712}, "CVE-2021-47718": {"epss_score": 0.00223, "epss_percentile": 0.4494}, "CVE-2021-47719": {"epss_score": 0.00093, "epss_percentile": 0.26723}, "CVE-2021-47720": {"epss_score": 0.00027, "epss_percentile": 0.07089}, "CVE-2021-47721": {"epss_score": 0.00041, "epss_percentile": 0.12398}, "CVE-2021-47722": {"epss_score": 0.00015, "epss_percentile": 0.02221}, "CVE-2021-47723": {"epss_score": 0.00025, "epss_percentile": 0.06246}, "CVE-2021-47724": {"epss_score": 0.00163, "epss_percentile": 0.3777}, "CVE-2021-47725": {"epss_score": 0.00037, "epss_percentile": 0.1072}, "CVE-2021-47726": {"epss_score": 0.00078, "epss_percentile": 0.23733}, "CVE-2021-47727": {"epss_score": 0.00752, "epss_percentile": 0.72662}, "CVE-2021-47728": {"epss_score": 0.01196, "epss_percentile": 0.78436}, "CVE-2021-47729": {"epss_score": 0.00073, "epss_percentile": 0.22672}, "CVE-2021-47730": {"epss_score": 0.00199, "epss_percentile": 0.4216}, "CVE-2021-47731": {"epss_score": 0.00058, "epss_percentile": 0.18385}, "CVE-2021-47732": {"epss_score": 0.00029, "epss_percentile": 0.07653}, "CVE-2021-47733": {"epss_score": 0.00029, "epss_percentile": 0.07783}, "CVE-2021-47734": {"epss_score": 0.00224, "epss_percentile": 0.45024}, "CVE-2021-47735": {"epss_score": 0.00285, "epss_percentile": 0.51529}, "CVE-2021-47736": {"epss_score": 0.00561, "epss_percentile": 0.67673}, "CVE-2021-47737": {"epss_score": 0.00051, "epss_percentile": 0.15991}, "CVE-2021-47738": {"epss_score": 0.00051, "epss_percentile": 0.16265}, "CVE-2021-47739": {"epss_score": 0.00014, "epss_percentile": 0.01786}, "CVE-2021-47740": {"epss_score": 0.00073, "epss_percentile": 0.22594}, "CVE-2021-47741": {"epss_score": 0.00036, "epss_percentile": 0.10615}, "CVE-2021-47742": {"epss_score": 0.00031, "epss_percentile": 0.08409}, "CVE-2021-47743": {"epss_score": 0.00037, "epss_percentile": 0.10638}, "CVE-2021-47744": {"epss_score": 0.00041, "epss_percentile": 0.12345}, "CVE-2021-47745": {"epss_score": 0.00282, "epss_percentile": 0.51229}, "CVE-2021-47747": {"epss_score": 0.00247, "epss_percentile": 0.47894}, "CVE-2021-4000": {"epss_score": 0.00196, "epss_percentile": 0.41771}, "CVE-2021-4001": {"epss_score": 0.00016, "epss_percentile": 0.02612}, "CVE-2021-4002": {"epss_score": 0.00016, "epss_percentile": 0.02912}, "CVE-2021-4005": {"epss_score": 0.00161, "epss_percentile": 0.37584}, "CVE-2021-4007": {"epss_score": 0.00041, "epss_percentile": 0.12251}, "CVE-2021-4008": {"epss_score": 0.00075, "epss_percentile": 0.22891}, "CVE-2021-4009": {"epss_score": 0.00092, "epss_percentile": 0.26437}, "CVE-2021-4010": {"epss_score": 0.00079, "epss_percentile": 0.2389}, "CVE-2021-4011": {"epss_score": 0.00101, "epss_percentile": 0.28604}, "CVE-2021-4015": {"epss_score": 0.00161, "epss_percentile": 0.37584}, "CVE-2021-4016": {"epss_score": 0.00054, "epss_percentile": 0.1731}, "CVE-2021-4017": {"epss_score": 0.00142, "epss_percentile": 0.34987}, "CVE-2021-4018": {"epss_score": 0.00225, "epss_percentile": 0.45121}, "CVE-2021-4019": {"epss_score": 0.00206, "epss_percentile": 0.42771}, "CVE-2021-4020": {"epss_score": 0.00318, "epss_percentile": 0.54437}, "CVE-2021-4021": {"epss_score": 0.00436, "epss_percentile": 0.62386}, "CVE-2021-4022": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2021-4023": {"epss_score": 0.00029, "epss_percentile": 0.07955}, "CVE-2021-4024": {"epss_score": 0.00095, "epss_percentile": 0.27237}, "CVE-2021-4026": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2021-4028": {"epss_score": 0.00042, "epss_percentile": 0.12768}, "CVE-2021-4029": {"epss_score": 0.00603, "epss_percentile": 0.68935}, "CVE-2021-4030": {"epss_score": 0.00143, "epss_percentile": 0.351}, "CVE-2021-4031": {"epss_score": 0.00111, "epss_percentile": 0.30313}, "CVE-2021-4032": {"epss_score": 0.00047, "epss_percentile": 0.14777}, "CVE-2021-4033": {"epss_score": 0.00117, "epss_percentile": 0.31307}, "CVE-2021-4034": {"epss_score": 0.87119, "epss_percentile": 0.99417}, "CVE-2021-4035": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2021-4037": {"epss_score": 0.00031, "epss_percentile": 0.08619}, "CVE-2021-4038": {"epss_score": 0.0014, "epss_percentile": 0.34716}, "CVE-2021-4039": {"epss_score": 0.69768, "epss_percentile": 0.98602}, "CVE-2021-4040": {"epss_score": 0.04235, "epss_percentile": 0.88427}, "CVE-2021-4041": {"epss_score": 0.0006, "epss_percentile": 0.1896}, "CVE-2021-4043": {"epss_score": 0.01117, "epss_percentile": 0.77739}, "CVE-2021-4044": {"epss_score": 0.1758, "epss_percentile": 0.9487}, "CVE-2021-4045": {"epss_score": 0.89442, "epss_percentile": 0.99527}, "CVE-2021-4046": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-4047": {"epss_score": 0.00202, "epss_percentile": 0.42436}, "CVE-2021-4048": {"epss_score": 0.0024, "epss_percentile": 0.46946}, "CVE-2021-4049": {"epss_score": 0.00111, "epss_percentile": 0.30383}, "CVE-2021-4050": {"epss_score": 0.00323, "epss_percentile": 0.54877}, "CVE-2021-4052": {"epss_score": 0.00305, "epss_percentile": 0.53336}, "CVE-2021-4053": {"epss_score": 0.00965, "epss_percentile": 0.76045}, "CVE-2021-4054": {"epss_score": 0.00694, "epss_percentile": 0.71343}, "CVE-2021-4055": {"epss_score": 0.00527, "epss_percentile": 0.66469}, "CVE-2021-4056": {"epss_score": 0.0146, "epss_percentile": 0.8042}, "CVE-2021-4057": {"epss_score": 0.02973, "epss_percentile": 0.861}, "CVE-2021-4058": {"epss_score": 0.02423, "epss_percentile": 0.84709}, "CVE-2021-4059": {"epss_score": 0.01564, "epss_percentile": 0.81062}, "CVE-2021-4061": {"epss_score": 0.0146, "epss_percentile": 0.8042}, "CVE-2021-4062": {"epss_score": 0.02423, "epss_percentile": 0.84709}, "CVE-2021-4063": {"epss_score": 0.01375, "epss_percentile": 0.79833}, "CVE-2021-4064": {"epss_score": 0.00972, "epss_percentile": 0.76143}, "CVE-2021-4065": {"epss_score": 0.01172, "epss_percentile": 0.78227}, "CVE-2021-4066": {"epss_score": 0.01882, "epss_percentile": 0.82695}, "CVE-2021-4067": {"epss_score": 0.01375, "epss_percentile": 0.79833}, "CVE-2021-4068": {"epss_score": 0.01049, "epss_percentile": 0.77061}, "CVE-2021-4069": {"epss_score": 0.00202, "epss_percentile": 0.42424}, "CVE-2021-4070": {"epss_score": 0.00227, "epss_percentile": 0.45377}, "CVE-2021-4072": {"epss_score": 0.0033, "epss_percentile": 0.55464}, "CVE-2021-4073": {"epss_score": 0.57717, "epss_percentile": 0.9808}, "CVE-2021-4074": {"epss_score": 0.00155, "epss_percentile": 0.36779}, "CVE-2021-4075": {"epss_score": 0.00274, "epss_percentile": 0.50573}, "CVE-2021-4076": {"epss_score": 0.00477, "epss_percentile": 0.64331}, "CVE-2021-4078": {"epss_score": 0.01446, "epss_percentile": 0.80328}, "CVE-2021-4079": {"epss_score": 0.01387, "epss_percentile": 0.79915}, "CVE-2021-4080": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2021-4081": {"epss_score": 0.00011, "epss_percentile": 0.011}, "CVE-2021-4082": {"epss_score": 5e-05, "epss_percentile": 0.00203}, "CVE-2021-4083": {"epss_score": 0.00011, "epss_percentile": 0.01008}, "CVE-2021-4084": {"epss_score": 0.00021, "epss_percentile": 0.04794}, "CVE-2021-4088": {"epss_score": 0.01212, "epss_percentile": 0.78562}, "CVE-2021-4089": {"epss_score": 0.00223, "epss_percentile": 0.44903}, "CVE-2021-4090": {"epss_score": 0.00059, "epss_percentile": 0.18866}, "CVE-2021-4091": {"epss_score": 0.00236, "epss_percentile": 0.46382}, "CVE-2021-4092": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2021-4093": {"epss_score": 0.0009, "epss_percentile": 0.26097}, "CVE-2021-4095": {"epss_score": 0.00113, "epss_percentile": 0.30706}, "CVE-2021-4096": {"epss_score": 0.0011, "epss_percentile": 0.30132}, "CVE-2021-4097": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-4098": {"epss_score": 0.00276, "epss_percentile": 0.50767}, "CVE-2021-4099": {"epss_score": 0.00927, "epss_percentile": 0.75562}, "CVE-2021-4100": {"epss_score": 0.00785, "epss_percentile": 0.7326}, "CVE-2021-4101": {"epss_score": 0.00915, "epss_percentile": 0.75398}, "CVE-2021-4102": {"epss_score": 0.05459, "epss_percentile": 0.899}, "CVE-2021-4103": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2021-4104": {"epss_score": 0.72202, "epss_percentile": 0.987}, "CVE-2021-4105": {"epss_score": 0.00356, "epss_percentile": 0.57367}, "CVE-2021-4106": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2021-4107": {"epss_score": 0.00227, "epss_percentile": 0.45423}, "CVE-2021-4108": {"epss_score": 0.00225, "epss_percentile": 0.4523}, "CVE-2021-4110": {"epss_score": 0.00455, "epss_percentile": 0.63304}, "CVE-2021-4111": {"epss_score": 0.00177, "epss_percentile": 0.3953}, "CVE-2021-4112": {"epss_score": 0.0008, "epss_percentile": 0.24094}, "CVE-2021-4115": {"epss_score": 0.00021, "epss_percentile": 0.04768}, "CVE-2021-4116": {"epss_score": 0.00147, "epss_percentile": 0.35656}, "CVE-2021-4117": {"epss_score": 0.00186, "epss_percentile": 0.40637}, "CVE-2021-4118": {"epss_score": 0.0027, "epss_percentile": 0.50238}, "CVE-2021-4119": {"epss_score": 0.00425, "epss_percentile": 0.61717}, "CVE-2021-4120": {"epss_score": 0.00088, "epss_percentile": 0.25732}, "CVE-2021-4121": {"epss_score": 0.00206, "epss_percentile": 0.43044}, "CVE-2021-4122": {"epss_score": 0.00078, "epss_percentile": 0.23605}, "CVE-2021-4123": {"epss_score": 0.00097, "epss_percentile": 0.27629}, "CVE-2021-4124": {"epss_score": 0.0029, "epss_percentile": 0.52134}, "CVE-2021-4125": {"epss_score": 0.01137, "epss_percentile": 0.77924}, "CVE-2021-4126": {"epss_score": 0.00337, "epss_percentile": 0.56051}, "CVE-2021-4127": {"epss_score": 0.00503, "epss_percentile": 0.6546}, "CVE-2021-4128": {"epss_score": 0.00352, "epss_percentile": 0.5712}, "CVE-2021-4129": {"epss_score": 0.00244, "epss_percentile": 0.47515}, "CVE-2021-4130": {"epss_score": 0.00158, "epss_percentile": 0.37186}, "CVE-2021-4131": {"epss_score": 0.00144, "epss_percentile": 0.35331}, "CVE-2021-4132": {"epss_score": 0.00186, "epss_percentile": 0.40651}, "CVE-2021-4133": {"epss_score": 0.00352, "epss_percentile": 0.57081}, "CVE-2021-4134": {"epss_score": 0.02027, "epss_percentile": 0.83319}, "CVE-2021-4135": {"epss_score": 0.00115, "epss_percentile": 0.3094}, "CVE-2021-4136": {"epss_score": 0.00179, "epss_percentile": 0.39747}, "CVE-2021-4138": {"epss_score": 0.00198, "epss_percentile": 0.42017}, "CVE-2021-4139": {"epss_score": 0.00023, "epss_percentile": 0.0538}, "CVE-2021-4140": {"epss_score": 0.0005, "epss_percentile": 0.15715}, "CVE-2021-4142": {"epss_score": 0.00104, "epss_percentile": 0.29197}, "CVE-2021-4143": {"epss_score": 0.00311, "epss_percentile": 0.53857}, "CVE-2021-4144": {"epss_score": 0.01715, "epss_percentile": 0.81895}, "CVE-2021-4145": {"epss_score": 0.00065, "epss_percentile": 0.20488}, "CVE-2021-4146": {"epss_score": 7e-05, "epss_percentile": 0.00413}, "CVE-2021-4147": {"epss_score": 0.00065, "epss_percentile": 0.20529}, "CVE-2021-4148": {"epss_score": 0.00011, "epss_percentile": 0.0106}, "CVE-2021-4149": {"epss_score": 0.00023, "epss_percentile": 0.05377}, "CVE-2021-4150": {"epss_score": 0.00043, "epss_percentile": 0.13134}, "CVE-2021-4154": {"epss_score": 0.00838, "epss_percentile": 0.74184}, "CVE-2021-4155": {"epss_score": 0.00019, "epss_percentile": 0.04188}, "CVE-2021-4156": {"epss_score": 0.00103, "epss_percentile": 0.29063}, "CVE-2021-4157": {"epss_score": 0.00049, "epss_percentile": 0.15546}, "CVE-2021-4158": {"epss_score": 0.00015, "epss_percentile": 0.02169}, "CVE-2021-4159": {"epss_score": 0.00011, "epss_percentile": 0.0093}, "CVE-2021-4160": {"epss_score": 0.00299, "epss_percentile": 0.52857}, "CVE-2021-4161": {"epss_score": 0.00127, "epss_percentile": 0.32794}, "CVE-2021-4162": {"epss_score": 0.00098, "epss_percentile": 0.27733}, "CVE-2021-4164": {"epss_score": 0.00134, "epss_percentile": 0.33866}, "CVE-2021-4166": {"epss_score": 0.00224, "epss_percentile": 0.45059}, "CVE-2021-4168": {"epss_score": 0.00105, "epss_percentile": 0.29257}, "CVE-2021-4169": {"epss_score": 0.00576, "epss_percentile": 0.68124}, "CVE-2021-4170": {"epss_score": 0.00282, "epss_percentile": 0.51274}, "CVE-2021-4171": {"epss_score": 0.00441, "epss_percentile": 0.6266}, "CVE-2021-4172": {"epss_score": 0.00195, "epss_percentile": 0.41625}, "CVE-2021-4173": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2021-4175": {"epss_score": 0.00234, "epss_percentile": 0.46176}, "CVE-2021-4176": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2021-4177": {"epss_score": 0.00301, "epss_percentile": 0.53002}, "CVE-2021-4178": {"epss_score": 0.0009, "epss_percentile": 0.26025}, "CVE-2021-4179": {"epss_score": 0.00141, "epss_percentile": 0.3493}, "CVE-2021-4180": {"epss_score": 0.00284, "epss_percentile": 0.5143}, "CVE-2021-4181": {"epss_score": 0.00179, "epss_percentile": 0.39844}, "CVE-2021-4182": {"epss_score": 0.00042, "epss_percentile": 0.12709}, "CVE-2021-4183": {"epss_score": 0.00184, "epss_percentile": 0.40408}, "CVE-2021-4184": {"epss_score": 0.00309, "epss_percentile": 0.5367}, "CVE-2021-4185": {"epss_score": 0.0013, "epss_percentile": 0.33252}, "CVE-2021-4186": {"epss_score": 0.00128, "epss_percentile": 0.33048}, "CVE-2021-4187": {"epss_score": 0.00619, "epss_percentile": 0.69388}, "CVE-2021-4188": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2021-4189": {"epss_score": 0.00627, "epss_percentile": 0.69644}, "CVE-2021-4190": {"epss_score": 0.00121, "epss_percentile": 0.31833}, "CVE-2021-4191": {"epss_score": 0.92775, "epss_percentile": 0.99747}, "CVE-2021-4192": {"epss_score": 0.00329, "epss_percentile": 0.55398}, "CVE-2021-4193": {"epss_score": 0.00325, "epss_percentile": 0.55027}, "CVE-2021-4194": {"epss_score": 0.0016, "epss_percentile": 0.37448}, "CVE-2021-4195": {"epss_score": 0.00096, "epss_percentile": 0.27405}, "CVE-2021-4197": {"epss_score": 0.00014, "epss_percentile": 0.02017}, "CVE-2021-4198": {"epss_score": 0.00132, "epss_percentile": 0.3355}, "CVE-2021-4199": {"epss_score": 0.00576, "epss_percentile": 0.68137}, "CVE-2021-4200": {"epss_score": 0.00351, "epss_percentile": 0.57008}, "CVE-2021-4201": {"epss_score": 0.00913, "epss_percentile": 0.75378}, "CVE-2021-4202": {"epss_score": 0.00068, "epss_percentile": 0.21193}, "CVE-2021-4203": {"epss_score": 0.00064, "epss_percentile": 0.20177}, "CVE-2021-4204": {"epss_score": 0.00767, "epss_percentile": 0.7295}, "CVE-2021-4206": {"epss_score": 0.00161, "epss_percentile": 0.37605}, "CVE-2021-4207": {"epss_score": 0.00049, "epss_percentile": 0.15649}, "CVE-2021-4208": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2021-4209": {"epss_score": 0.00348, "epss_percentile": 0.56825}, "CVE-2021-4210": {"epss_score": 0.0004, "epss_percentile": 0.12}, "CVE-2021-4211": {"epss_score": 0.0004, "epss_percentile": 0.12}, "CVE-2021-4212": {"epss_score": 0.00037, "epss_percentile": 0.10985}, "CVE-2021-4213": {"epss_score": 0.00213, "epss_percentile": 0.43826}, "CVE-2021-4214": {"epss_score": 0.00223, "epss_percentile": 0.44878}, "CVE-2021-4216": {"epss_score": 0.00032, "epss_percentile": 0.08959}, "CVE-2021-4217": {"epss_score": 0.00183, "epss_percentile": 0.40351}, "CVE-2021-4218": {"epss_score": 0.00045, "epss_percentile": 0.13832}, "CVE-2021-4219": {"epss_score": 0.00061, "epss_percentile": 0.19343}, "CVE-2021-4221": {"epss_score": 0.00182, "epss_percentile": 0.40239}, "CVE-2021-4222": {"epss_score": 0.00323, "epss_percentile": 0.54879}, "CVE-2021-4225": {"epss_score": 0.01188, "epss_percentile": 0.78361}, "CVE-2021-4226": {"epss_score": 0.00138, "epss_percentile": 0.34456}, "CVE-2021-4227": {"epss_score": 0.00222, "epss_percentile": 0.44729}, "CVE-2021-4228": {"epss_score": 0.00772, "epss_percentile": 0.73047}, "CVE-2021-4229": {"epss_score": 0.00863, "epss_percentile": 0.74589}, "CVE-2021-4230": {"epss_score": 0.00273, "epss_percentile": 0.50464}, "CVE-2021-4231": {"epss_score": 0.01341, "epss_percentile": 0.79583}, "CVE-2021-4232": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2021-4234": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2021-4235": {"epss_score": 0.00042, "epss_percentile": 0.12621}, "CVE-2021-4236": {"epss_score": 0.00454, "epss_percentile": 0.63264}, "CVE-2021-4238": {"epss_score": 0.00299, "epss_percentile": 0.52893}, "CVE-2021-4239": {"epss_score": 0.00126, "epss_percentile": 0.32626}, "CVE-2021-4240": {"epss_score": 0.00239, "epss_percentile": 0.46855}, "CVE-2021-4241": {"epss_score": 0.0028, "epss_percentile": 0.51033}, "CVE-2021-4242": {"epss_score": 0.10482, "epss_percentile": 0.93001}, "CVE-2021-4244": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2021-4245": {"epss_score": 0.00654, "epss_percentile": 0.70351}, "CVE-2021-4246": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2021-4247": {"epss_score": 0.00377, "epss_percentile": 0.5869}, "CVE-2021-4248": {"epss_score": 0.006, "epss_percentile": 0.6883}, "CVE-2021-4249": {"epss_score": 0.00724, "epss_percentile": 0.72034}, "CVE-2021-4250": {"epss_score": 0.00882, "epss_percentile": 0.74901}, "CVE-2021-4251": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2021-4252": {"epss_score": 0.0027, "epss_percentile": 0.50267}, "CVE-2021-4253": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2021-4254": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2021-4255": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2021-4256": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2021-4257": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2021-4258": {"epss_score": 0.00118, "epss_percentile": 0.31488}, "CVE-2021-4259": {"epss_score": 0.00565, "epss_percentile": 0.67784}, "CVE-2021-4260": {"epss_score": 0.0016, "epss_percentile": 0.37431}, "CVE-2021-4261": {"epss_score": 0.00297, "epss_percentile": 0.52711}, "CVE-2021-4262": {"epss_score": 0.00297, "epss_percentile": 0.52711}, "CVE-2021-4263": {"epss_score": 0.00245, "epss_percentile": 0.47662}, "CVE-2021-4264": {"epss_score": 0.01357, "epss_percentile": 0.79725}, "CVE-2021-4265": {"epss_score": 0.00385, "epss_percentile": 0.59202}, "CVE-2021-4266": {"epss_score": 0.00639, "epss_percentile": 0.69951}, "CVE-2021-4267": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2021-4268": {"epss_score": 0.0029, "epss_percentile": 0.52133}, "CVE-2021-4269": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2021-4270": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2021-4271": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2021-4272": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2021-4273": {"epss_score": 0.003, "epss_percentile": 0.52951}, "CVE-2021-4274": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2021-4275": {"epss_score": 0.00118, "epss_percentile": 0.31488}, "CVE-2021-4276": {"epss_score": 0.00276, "epss_percentile": 0.50741}, "CVE-2021-4277": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2021-4278": {"epss_score": 0.00099, "epss_percentile": 0.28407}, "CVE-2021-4279": {"epss_score": 0.00411, "epss_percentile": 0.6085}, "CVE-2021-4280": {"epss_score": 0.00329, "epss_percentile": 0.554}, "CVE-2021-4281": {"epss_score": 0.02113, "epss_percentile": 0.83651}, "CVE-2021-4282": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2021-4283": {"epss_score": 0.00354, "epss_percentile": 0.57233}, "CVE-2021-4284": {"epss_score": 0.00868, "epss_percentile": 0.74672}, "CVE-2021-4285": {"epss_score": 0.0625, "epss_percentile": 0.90615}, "CVE-2021-4286": {"epss_score": 0.00444, "epss_percentile": 0.62842}, "CVE-2021-4287": {"epss_score": 0.01235, "epss_percentile": 0.78767}, "CVE-2021-4288": {"epss_score": 0.00335, "epss_percentile": 0.55844}, "CVE-2021-4289": {"epss_score": 0.00868, "epss_percentile": 0.74672}, "CVE-2021-4290": {"epss_score": 0.00297, "epss_percentile": 0.52711}, "CVE-2021-4291": {"epss_score": 0.00335, "epss_percentile": 0.55844}, "CVE-2021-4292": {"epss_score": 0.00335, "epss_percentile": 0.55844}, "CVE-2021-4293": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2021-4294": {"epss_score": 0.00165, "epss_percentile": 0.38132}, "CVE-2021-4295": {"epss_score": 0.00546, "epss_percentile": 0.67217}, "CVE-2021-4296": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2021-4297": {"epss_score": 0.00436, "epss_percentile": 0.62388}, "CVE-2021-4298": {"epss_score": 0.00351, "epss_percentile": 0.57037}, "CVE-2021-4299": {"epss_score": 0.00462, "epss_percentile": 0.63576}, "CVE-2021-4300": {"epss_score": 0.00344, "epss_percentile": 0.56522}, "CVE-2021-4301": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2021-4302": {"epss_score": 0.00246, "epss_percentile": 0.47766}, "CVE-2021-4303": {"epss_score": 0.00415, "epss_percentile": 0.61141}, "CVE-2021-4304": {"epss_score": 0.05866, "epss_percentile": 0.90276}, "CVE-2021-4305": {"epss_score": 0.0032, "epss_percentile": 0.54577}, "CVE-2021-4306": {"epss_score": 0.00462, "epss_percentile": 0.63576}, "CVE-2021-4307": {"epss_score": 0.00199, "epss_percentile": 0.42108}, "CVE-2021-4308": {"epss_score": 0.00071, "epss_percentile": 0.22136}, "CVE-2021-4309": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2021-4310": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2021-4311": {"epss_score": 0.0014, "epss_percentile": 0.34797}, "CVE-2021-4312": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2021-4313": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2021-4314": {"epss_score": 0.00081, "epss_percentile": 0.24224}, "CVE-2021-4315": {"epss_score": 0.00098, "epss_percentile": 0.27686}, "CVE-2021-4316": {"epss_score": 0.00121, "epss_percentile": 0.31953}, "CVE-2021-4317": {"epss_score": 0.00963, "epss_percentile": 0.76018}, "CVE-2021-4318": {"epss_score": 0.00963, "epss_percentile": 0.76018}, "CVE-2021-4319": {"epss_score": 0.00963, "epss_percentile": 0.76018}, "CVE-2021-4320": {"epss_score": 0.00963, "epss_percentile": 0.76018}, "CVE-2021-4321": {"epss_score": 0.00041, "epss_percentile": 0.12249}, "CVE-2021-4322": {"epss_score": 0.00061, "epss_percentile": 0.19338}, "CVE-2021-4323": {"epss_score": 0.00048, "epss_percentile": 0.15042}, "CVE-2021-4324": {"epss_score": 0.00141, "epss_percentile": 0.34905}, "CVE-2021-4325": {"epss_score": 0.00082, "epss_percentile": 0.24497}, "CVE-2021-4326": {"epss_score": 0.00024, "epss_percentile": 0.05841}, "CVE-2021-4327": {"epss_score": 0.00089, "epss_percentile": 0.25833}, "CVE-2021-4328": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2021-4329": {"epss_score": 0.00858, "epss_percentile": 0.74505}, "CVE-2021-4330": {"epss_score": 0.05539, "epss_percentile": 0.89975}, "CVE-2021-4331": {"epss_score": 0.001, "epss_percentile": 0.2846}, "CVE-2021-4332": {"epss_score": 0.00229, "epss_percentile": 0.45645}, "CVE-2021-4333": {"epss_score": 0.00078, "epss_percentile": 0.23735}, "CVE-2021-4334": {"epss_score": 0.00114, "epss_percentile": 0.30821}, "CVE-2021-4335": {"epss_score": 0.00046, "epss_percentile": 0.14393}, "CVE-2021-4336": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2021-4337": {"epss_score": 0.00187, "epss_percentile": 0.40756}, "CVE-2021-4338": {"epss_score": 0.00106, "epss_percentile": 0.29428}, "CVE-2021-4339": {"epss_score": 0.00694, "epss_percentile": 0.71357}, "CVE-2021-4340": {"epss_score": 0.00565, "epss_percentile": 0.67791}, "CVE-2021-4341": {"epss_score": 0.0021, "epss_percentile": 0.43492}, "CVE-2021-4343": {"epss_score": 0.0046, "epss_percentile": 0.635}, "CVE-2021-4344": {"epss_score": 0.00075, "epss_percentile": 0.23034}, "CVE-2021-4345": {"epss_score": 0.00118, "epss_percentile": 0.31487}, "CVE-2021-4346": {"epss_score": 0.00335, "epss_percentile": 0.55859}, "CVE-2021-4347": {"epss_score": 0.00091, "epss_percentile": 0.26285}, "CVE-2021-4348": {"epss_score": 0.00479, "epss_percentile": 0.64417}, "CVE-2021-4349": {"epss_score": 0.00225, "epss_percentile": 0.45229}, "CVE-2021-4350": {"epss_score": 0.00099, "epss_percentile": 0.28341}, "CVE-2021-4351": {"epss_score": 0.0014, "epss_percentile": 0.34698}, "CVE-2021-4352": {"epss_score": 0.00121, "epss_percentile": 0.31938}, "CVE-2021-4353": {"epss_score": 0.00285, "epss_percentile": 0.51682}, "CVE-2021-4354": {"epss_score": 0.05657, "epss_percentile": 0.90094}, "CVE-2021-4355": {"epss_score": 0.0083, "epss_percentile": 0.74039}, "CVE-2021-4356": {"epss_score": 0.00502, "epss_percentile": 0.65396}, "CVE-2021-4357": {"epss_score": 0.00097, "epss_percentile": 0.27518}, "CVE-2021-4358": {"epss_score": 0.00805, "epss_percentile": 0.73633}, "CVE-2021-4359": {"epss_score": 0.00081, "epss_percentile": 0.24234}, "CVE-2021-4360": {"epss_score": 0.00096, "epss_percentile": 0.27279}, "CVE-2021-4361": {"epss_score": 0.0026, "epss_percentile": 0.49244}, "CVE-2021-4362": {"epss_score": 0.00701, "epss_percentile": 0.71499}, "CVE-2021-4363": {"epss_score": 0.00774, "epss_percentile": 0.73071}, "CVE-2021-4364": {"epss_score": 0.00073, "epss_percentile": 0.22625}, "CVE-2021-4365": {"epss_score": 0.00751, "epss_percentile": 0.72637}, "CVE-2021-4366": {"epss_score": 0.00031, "epss_percentile": 0.08545}, "CVE-2021-4367": {"epss_score": 0.00101, "epss_percentile": 0.28641}, "CVE-2021-4368": {"epss_score": 0.05206, "epss_percentile": 0.8961}, "CVE-2021-4369": {"epss_score": 0.00126, "epss_percentile": 0.32687}, "CVE-2021-4370": {"epss_score": 0.00371, "epss_percentile": 0.58411}, "CVE-2021-4371": {"epss_score": 0.00064, "epss_percentile": 0.20251}, "CVE-2021-4372": {"epss_score": 0.00265, "epss_percentile": 0.49763}, "CVE-2021-4373": {"epss_score": 0.0009, "epss_percentile": 0.26061}, "CVE-2021-4374": {"epss_score": 0.70297, "epss_percentile": 0.98627}, "CVE-2021-4375": {"epss_score": 0.00065, "epss_percentile": 0.2051}, "CVE-2021-4376": {"epss_score": 0.00065, "epss_percentile": 0.20578}, "CVE-2021-4377": {"epss_score": 0.00264, "epss_percentile": 0.49714}, "CVE-2021-4378": {"epss_score": 0.00069, "epss_percentile": 0.21528}, "CVE-2021-4379": {"epss_score": 0.00044, "epss_percentile": 0.1352}, "CVE-2021-4380": {"epss_score": 0.8366, "epss_percentile": 0.99256}, "CVE-2021-4381": {"epss_score": 0.00371, "epss_percentile": 0.58411}, "CVE-2021-4382": {"epss_score": 0.07775, "epss_percentile": 0.91675}, "CVE-2021-4383": {"epss_score": 0.00107, "epss_percentile": 0.29693}, "CVE-2021-4384": {"epss_score": 0.00113, "epss_percentile": 0.30588}, "CVE-2021-4385": {"epss_score": 0.00119, "epss_percentile": 0.31601}, "CVE-2021-4386": {"epss_score": 0.00122, "epss_percentile": 0.3211}, "CVE-2021-4387": {"epss_score": 0.00115, "epss_percentile": 0.3095}, "CVE-2021-4388": {"epss_score": 0.00131, "epss_percentile": 0.33443}, "CVE-2021-4389": {"epss_score": 0.00093, "epss_percentile": 0.26697}, "CVE-2021-4390": {"epss_score": 0.00096, "epss_percentile": 0.27385}, "CVE-2021-4391": {"epss_score": 0.00093, "epss_percentile": 0.26697}, "CVE-2021-4392": {"epss_score": 0.00093, "epss_percentile": 0.26697}, "CVE-2021-4393": {"epss_score": 0.00093, "epss_percentile": 0.26697}, "CVE-2021-4394": {"epss_score": 0.00201, "epss_percentile": 0.42285}, "CVE-2021-4395": {"epss_score": 0.00107, "epss_percentile": 0.29722}, "CVE-2021-4396": {"epss_score": 0.00116, "epss_percentile": 0.31125}, "CVE-2021-4397": {"epss_score": 0.00116, "epss_percentile": 0.31125}, "CVE-2021-4398": {"epss_score": 0.00117, "epss_percentile": 0.31237}, "CVE-2021-4399": {"epss_score": 0.00117, "epss_percentile": 0.31237}, "CVE-2021-4400": {"epss_score": 0.0011, "epss_percentile": 0.30218}, "CVE-2021-4401": {"epss_score": 0.00238, "epss_percentile": 0.46774}, "CVE-2021-4402": {"epss_score": 0.0017, "epss_percentile": 0.3875}, "CVE-2021-4403": {"epss_score": 0.00116, "epss_percentile": 0.31125}, "CVE-2021-4404": {"epss_score": 0.00116, "epss_percentile": 0.31125}, "CVE-2021-4405": {"epss_score": 0.00128, "epss_percentile": 0.33037}, "CVE-2021-4406": {"epss_score": 0.00126, "epss_percentile": 0.3268}, "CVE-2021-4407": {"epss_score": 0.00113, "epss_percentile": 0.30588}, "CVE-2021-4408": {"epss_score": 0.00113, "epss_percentile": 0.30588}, "CVE-2021-4409": {"epss_score": 0.00113, "epss_percentile": 0.30588}, "CVE-2021-4410": {"epss_score": 0.00113, "epss_percentile": 0.30588}, "CVE-2021-4411": {"epss_score": 0.00113, "epss_percentile": 0.30588}, "CVE-2021-4412": {"epss_score": 0.00113, "epss_percentile": 0.30588}, "CVE-2021-4413": {"epss_score": 0.00113, "epss_percentile": 0.30588}, "CVE-2021-4414": {"epss_score": 0.00113, "epss_percentile": 0.30588}, "CVE-2021-4415": {"epss_score": 0.00113, "epss_percentile": 0.30588}, "CVE-2021-4416": {"epss_score": 0.00113, "epss_percentile": 0.30588}, "CVE-2021-4417": {"epss_score": 0.00132, "epss_percentile": 0.33514}, "CVE-2021-4418": {"epss_score": 0.00137, "epss_percentile": 0.3423}, "CVE-2021-4419": {"epss_score": 0.00131, "epss_percentile": 0.33363}, "CVE-2021-4420": {"epss_score": 0.00143, "epss_percentile": 0.35163}, "CVE-2021-4421": {"epss_score": 0.00131, "epss_percentile": 0.33363}, "CVE-2021-4422": {"epss_score": 0.00212, "epss_percentile": 0.43732}, "CVE-2021-4423": {"epss_score": 0.00131, "epss_percentile": 0.33363}, "CVE-2021-4424": {"epss_score": 0.00131, "epss_percentile": 0.33363}, "CVE-2021-4425": {"epss_score": 0.00125, "epss_percentile": 0.32481}, "CVE-2021-4426": {"epss_score": 0.00138, "epss_percentile": 0.34375}, "CVE-2021-4427": {"epss_score": 0.00125, "epss_percentile": 0.32481}, "CVE-2021-4428": {"epss_score": 0.64416, "epss_percentile": 0.98377}, "CVE-2021-4430": {"epss_score": 0.00096, "epss_percentile": 0.27272}, "CVE-2021-4431": {"epss_score": 0.00693, "epss_percentile": 0.71326}, "CVE-2021-4432": {"epss_score": 0.00102, "epss_percentile": 0.28828}, "CVE-2021-4433": {"epss_score": 0.00055, "epss_percentile": 0.17484}, "CVE-2021-4434": {"epss_score": 0.07986, "epss_percentile": 0.91806}, "CVE-2021-4435": {"epss_score": 0.00051, "epss_percentile": 0.16038}, "CVE-2021-4436": {"epss_score": 0.79586, "epss_percentile": 0.99045}, "CVE-2021-4437": {"epss_score": 0.00032, "epss_percentile": 0.08988}, "CVE-2021-4438": {"epss_score": 0.0004, "epss_percentile": 0.11954}, "CVE-2021-4439": {"epss_score": 0.00018, "epss_percentile": 0.03833}, "CVE-2021-4440": {"epss_score": 0.00026, "epss_percentile": 0.06525}, "CVE-2021-4441": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2021-4442": {"epss_score": 0.00023, "epss_percentile": 0.05377}, "CVE-2021-4443": {"epss_score": 0.01679, "epss_percentile": 0.81722}, "CVE-2021-4444": {"epss_score": 0.00121, "epss_percentile": 0.31827}, "CVE-2021-4445": {"epss_score": 0.00131, "epss_percentile": 0.33398}, "CVE-2021-4446": {"epss_score": 0.00046, "epss_percentile": 0.14141}, "CVE-2021-4447": {"epss_score": 0.00206, "epss_percentile": 0.42944}, "CVE-2021-4448": {"epss_score": 0.43626, "epss_percentile": 0.97396}, "CVE-2021-4449": {"epss_score": 0.78635, "epss_percentile": 0.98995}, "CVE-2021-4450": {"epss_score": 0.00386, "epss_percentile": 0.59258}, "CVE-2021-4451": {"epss_score": 0.00722, "epss_percentile": 0.71989}, "CVE-2021-4452": {"epss_score": 0.0021, "epss_percentile": 0.43449}, "CVE-2021-4453": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2021-4454": {"epss_score": 0.00023, "epss_percentile": 0.0563}, "CVE-2021-4455": {"epss_score": 0.01051, "epss_percentile": 0.77074}, "CVE-2021-4457": {"epss_score": 0.00102, "epss_percentile": 0.28798}, "CVE-2021-4458": {"epss_score": 0.0005, "epss_percentile": 0.15932}, "CVE-2021-4459": {"epss_score": 0.00202, "epss_percentile": 0.42459}, "CVE-2021-4460": {"epss_score": 0.00018, "epss_percentile": 0.03618}, "CVE-2021-4461": {"epss_score": 0.00118, "epss_percentile": 0.31485}, "CVE-2021-4462": {"epss_score": 0.22195, "epss_percentile": 0.95607}, "CVE-2021-4463": {"epss_score": 0.00137, "epss_percentile": 0.34213}, "CVE-2021-4464": {"epss_score": 0.00482, "epss_percentile": 0.64546}, "CVE-2021-4465": {"epss_score": 0.00308, "epss_percentile": 0.53607}, "CVE-2021-4466": {"epss_score": 0.0036, "epss_percentile": 0.57654}, "CVE-2021-4467": {"epss_score": 0.00141, "epss_percentile": 0.34916}, "CVE-2021-4468": {"epss_score": 0.00377, "epss_percentile": 0.5873}, "CVE-2021-4469": {"epss_score": 0.0034, "epss_percentile": 0.56212}, "CVE-2021-4470": {"epss_score": 0.00414, "epss_percentile": 0.61108}, "CVE-2021-4471": {"epss_score": 0.00355, "epss_percentile": 0.5727}, "CVE-2021-4472": {"epss_score": 0.00054, "epss_percentile": 0.1709}, "CVE-2022-0001": {"epss_score": 0.00391, "epss_percentile": 0.59634}, "CVE-2022-0002": {"epss_score": 0.0064, "epss_percentile": 0.6996}, "CVE-2022-0004": {"epss_score": 0.00223, "epss_percentile": 0.44855}, "CVE-2022-0005": {"epss_score": 0.00037, "epss_percentile": 0.1065}, "CVE-2022-0010": {"epss_score": 0.00061, "epss_percentile": 0.19331}, "CVE-2022-0011": {"epss_score": 0.00303, "epss_percentile": 0.53236}, "CVE-2022-0012": {"epss_score": 0.0004, "epss_percentile": 0.11902}, "CVE-2022-0013": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2022-0014": {"epss_score": 0.00046, "epss_percentile": 0.14272}, "CVE-2022-0015": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2022-0016": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2022-0017": {"epss_score": 0.00039, "epss_percentile": 0.11767}, "CVE-2022-0018": {"epss_score": 0.00253, "epss_percentile": 0.48471}, "CVE-2022-0019": {"epss_score": 0.00039, "epss_percentile": 0.11643}, "CVE-2022-0020": {"epss_score": 0.01147, "epss_percentile": 0.78006}, "CVE-2022-0021": {"epss_score": 0.00051, "epss_percentile": 0.16317}, "CVE-2022-0022": {"epss_score": 0.00027, "epss_percentile": 0.069}, "CVE-2022-0023": {"epss_score": 0.00782, "epss_percentile": 0.73204}, "CVE-2022-0024": {"epss_score": 0.01316, "epss_percentile": 0.79405}, "CVE-2022-0025": {"epss_score": 0.00043, "epss_percentile": 0.13185}, "CVE-2022-0026": {"epss_score": 0.00037, "epss_percentile": 0.10627}, "CVE-2022-0027": {"epss_score": 0.00149, "epss_percentile": 0.3599}, "CVE-2022-0028": {"epss_score": 0.04682, "epss_percentile": 0.89002}, "CVE-2022-0029": {"epss_score": 0.00044, "epss_percentile": 0.13383}, "CVE-2022-0030": {"epss_score": 0.00179, "epss_percentile": 0.39818}, "CVE-2022-0031": {"epss_score": 0.00024, "epss_percentile": 0.0596}, "CVE-2022-0070": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2022-0071": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2022-0072": {"epss_score": 0.00661, "epss_percentile": 0.7058}, "CVE-2022-0073": {"epss_score": 0.00734, "epss_percentile": 0.7224}, "CVE-2022-0074": {"epss_score": 0.00125, "epss_percentile": 0.32535}, "CVE-2022-0079": {"epss_score": 0.00194, "epss_percentile": 0.41594}, "CVE-2022-0080": {"epss_score": 0.00343, "epss_percentile": 0.56406}, "CVE-2022-0083": {"epss_score": 0.0021, "epss_percentile": 0.43494}, "CVE-2022-0084": {"epss_score": 0.00291, "epss_percentile": 0.52153}, "CVE-2022-0085": {"epss_score": 0.00706, "epss_percentile": 0.71619}, "CVE-2022-0086": {"epss_score": 0.00336, "epss_percentile": 0.5593}, "CVE-2022-0087": {"epss_score": 0.56131, "epss_percentile": 0.98009}, "CVE-2022-0088": {"epss_score": 0.00792, "epss_percentile": 0.73414}, "CVE-2022-0090": {"epss_score": 0.00271, "epss_percentile": 0.50299}, "CVE-2022-0093": {"epss_score": 0.00294, "epss_percentile": 0.52395}, "CVE-2022-0096": {"epss_score": 0.00531, "epss_percentile": 0.66659}, "CVE-2022-0097": {"epss_score": 0.00276, "epss_percentile": 0.5077}, "CVE-2022-0098": {"epss_score": 0.00273, "epss_percentile": 0.5047}, "CVE-2022-0099": {"epss_score": 0.00651, "epss_percentile": 0.70274}, "CVE-2022-0100": {"epss_score": 0.0069, "epss_percentile": 0.71241}, "CVE-2022-0101": {"epss_score": 0.00645, "epss_percentile": 0.70107}, "CVE-2022-0102": {"epss_score": 0.00604, "epss_percentile": 0.68958}, "CVE-2022-0103": {"epss_score": 0.00594, "epss_percentile": 0.68653}, "CVE-2022-0104": {"epss_score": 0.00596, "epss_percentile": 0.68732}, "CVE-2022-0105": {"epss_score": 0.00531, "epss_percentile": 0.66659}, "CVE-2022-0106": {"epss_score": 0.0061, "epss_percentile": 0.69152}, "CVE-2022-0107": {"epss_score": 0.00273, "epss_percentile": 0.5047}, "CVE-2022-0108": {"epss_score": 0.00334, "epss_percentile": 0.55696}, "CVE-2022-0109": {"epss_score": 0.00646, "epss_percentile": 0.70133}, "CVE-2022-0110": {"epss_score": 0.00463, "epss_percentile": 0.63636}, "CVE-2022-0111": {"epss_score": 0.00217, "epss_percentile": 0.44252}, "CVE-2022-0112": {"epss_score": 0.00505, "epss_percentile": 0.65583}, "CVE-2022-0113": {"epss_score": 0.00286, "epss_percentile": 0.51688}, "CVE-2022-0114": {"epss_score": 0.0061, "epss_percentile": 0.69152}, "CVE-2022-0115": {"epss_score": 0.00531, "epss_percentile": 0.66659}, "CVE-2022-0116": {"epss_score": 0.00435, "epss_percentile": 0.6234}, "CVE-2022-0117": {"epss_score": 0.00143, "epss_percentile": 0.35175}, "CVE-2022-0118": {"epss_score": 0.00505, "epss_percentile": 0.65583}, "CVE-2022-0120": {"epss_score": 0.00262, "epss_percentile": 0.49368}, "CVE-2022-0121": {"epss_score": 0.00393, "epss_percentile": 0.59715}, "CVE-2022-0122": {"epss_score": 0.00156, "epss_percentile": 0.36971}, "CVE-2022-0123": {"epss_score": 0.00083, "epss_percentile": 0.24718}, "CVE-2022-0124": {"epss_score": 0.00269, "epss_percentile": 0.50125}, "CVE-2022-0125": {"epss_score": 0.00281, "epss_percentile": 0.51129}, "CVE-2022-0128": {"epss_score": 0.00239, "epss_percentile": 0.46938}, "CVE-2022-0129": {"epss_score": 0.00059, "epss_percentile": 0.18849}, "CVE-2022-0130": {"epss_score": 0.01943, "epss_percentile": 0.82993}, "CVE-2022-0131": {"epss_score": 0.00047, "epss_percentile": 0.14769}, "CVE-2022-0132": {"epss_score": 0.00343, "epss_percentile": 0.56444}, "CVE-2022-0133": {"epss_score": 0.00343, "epss_percentile": 0.56444}, "CVE-2022-0134": {"epss_score": 0.00382, "epss_percentile": 0.59066}, "CVE-2022-0135": {"epss_score": 0.00205, "epss_percentile": 0.42704}, "CVE-2022-0136": {"epss_score": 0.00198, "epss_percentile": 0.42059}, "CVE-2022-0137": {"epss_score": 0.00082, "epss_percentile": 0.24504}, "CVE-2022-0138": {"epss_score": 0.00146, "epss_percentile": 0.35585}, "CVE-2022-0139": {"epss_score": 0.00398, "epss_percentile": 0.60087}, "CVE-2022-0140": {"epss_score": 0.09629, "epss_percentile": 0.92631}, "CVE-2022-0141": {"epss_score": 0.00089, "epss_percentile": 0.25807}, "CVE-2022-0142": {"epss_score": 0.03265, "epss_percentile": 0.86781}, "CVE-2022-0143": {"epss_score": 0.00322, "epss_percentile": 0.54755}, "CVE-2022-0144": {"epss_score": 0.00097, "epss_percentile": 0.27621}, "CVE-2022-0145": {"epss_score": 0.00346, "epss_percentile": 0.56641}, "CVE-2022-0147": {"epss_score": 0.01702, "epss_percentile": 0.81838}, "CVE-2022-0148": {"epss_score": 0.08753, "epss_percentile": 0.92241}, "CVE-2022-0149": {"epss_score": 0.01131, "epss_percentile": 0.77864}, "CVE-2022-0150": {"epss_score": 0.01307, "epss_percentile": 0.79338}, "CVE-2022-0151": {"epss_score": 0.00257, "epss_percentile": 0.48915}, "CVE-2022-0152": {"epss_score": 0.00152, "epss_percentile": 0.36444}, "CVE-2022-0153": {"epss_score": 0.00271, "epss_percentile": 0.50301}, "CVE-2022-0154": {"epss_score": 0.00134, "epss_percentile": 0.33839}, "CVE-2022-0155": {"epss_score": 0.00903, "epss_percentile": 0.75206}, "CVE-2022-0156": {"epss_score": 0.00123, "epss_percentile": 0.32269}, "CVE-2022-0157": {"epss_score": 0.004, "epss_percentile": 0.60169}, "CVE-2022-0158": {"epss_score": 0.00131, "epss_percentile": 0.33499}, "CVE-2022-0159": {"epss_score": 0.00213, "epss_percentile": 0.43849}, "CVE-2022-0161": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0162": {"epss_score": 0.00157, "epss_percentile": 0.37039}, "CVE-2022-0163": {"epss_score": 0.00407, "epss_percentile": 0.6059}, "CVE-2022-0164": {"epss_score": 0.00087, "epss_percentile": 0.25486}, "CVE-2022-0165": {"epss_score": 0.52255, "epss_percentile": 0.97815}, "CVE-2022-0166": {"epss_score": 0.00059, "epss_percentile": 0.18913}, "CVE-2022-0167": {"epss_score": 0.00288, "epss_percentile": 0.51883}, "CVE-2022-0168": {"epss_score": 0.00017, "epss_percentile": 0.03168}, "CVE-2022-0169": {"epss_score": 0.80785, "epss_percentile": 0.99105}, "CVE-2022-0170": {"epss_score": 0.00168, "epss_percentile": 0.38449}, "CVE-2022-0171": {"epss_score": 0.00036, "epss_percentile": 0.10519}, "CVE-2022-0172": {"epss_score": 0.00083, "epss_percentile": 0.24804}, "CVE-2022-0173": {"epss_score": 0.00355, "epss_percentile": 0.57282}, "CVE-2022-0174": {"epss_score": 0.00244, "epss_percentile": 0.4755}, "CVE-2022-0175": {"epss_score": 0.00129, "epss_percentile": 0.33088}, "CVE-2022-0176": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2022-0178": {"epss_score": 0.00213, "epss_percentile": 0.4383}, "CVE-2022-0179": {"epss_score": 0.00221, "epss_percentile": 0.44668}, "CVE-2022-0180": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2022-0181": {"epss_score": 0.00668, "epss_percentile": 0.70739}, "CVE-2022-0182": {"epss_score": 0.00453, "epss_percentile": 0.6324}, "CVE-2022-0183": {"epss_score": 0.00017, "epss_percentile": 0.03136}, "CVE-2022-0184": {"epss_score": 0.00071, "epss_percentile": 0.22048}, "CVE-2022-0185": {"epss_score": 0.00903, "epss_percentile": 0.75205}, "CVE-2022-0186": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2022-0188": {"epss_score": 0.00263, "epss_percentile": 0.49476}, "CVE-2022-0189": {"epss_score": 0.02778, "epss_percentile": 0.85645}, "CVE-2022-0190": {"epss_score": 0.00532, "epss_percentile": 0.66709}, "CVE-2022-0191": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-0192": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2022-0193": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0194": {"epss_score": 0.08786, "epss_percentile": 0.92255}, "CVE-2022-0196": {"epss_score": 0.00148, "epss_percentile": 0.35902}, "CVE-2022-0197": {"epss_score": 0.00148, "epss_percentile": 0.35911}, "CVE-2022-0198": {"epss_score": 0.00186, "epss_percentile": 0.40667}, "CVE-2022-0199": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-0200": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2022-0201": {"epss_score": 0.20086, "epss_percentile": 0.95286}, "CVE-2022-0203": {"epss_score": 0.00277, "epss_percentile": 0.50796}, "CVE-2022-0204": {"epss_score": 0.00051, "epss_percentile": 0.1625}, "CVE-2022-0205": {"epss_score": 0.00197, "epss_percentile": 0.41908}, "CVE-2022-0206": {"epss_score": 0.01998, "epss_percentile": 0.83209}, "CVE-2022-0207": {"epss_score": 0.0006, "epss_percentile": 0.19067}, "CVE-2022-0208": {"epss_score": 0.04312, "epss_percentile": 0.88532}, "CVE-2022-0209": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0210": {"epss_score": 0.0059, "epss_percentile": 0.6856}, "CVE-2022-0211": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2022-0212": {"epss_score": 0.01943, "epss_percentile": 0.82992}, "CVE-2022-0213": {"epss_score": 0.00187, "epss_percentile": 0.40781}, "CVE-2022-0214": {"epss_score": 0.01993, "epss_percentile": 0.83182}, "CVE-2022-0215": {"epss_score": 0.00318, "epss_percentile": 0.54458}, "CVE-2022-0216": {"epss_score": 0.00021, "epss_percentile": 0.04928}, "CVE-2022-0217": {"epss_score": 0.00456, "epss_percentile": 0.6333}, "CVE-2022-0218": {"epss_score": 0.69049, "epss_percentile": 0.98575}, "CVE-2022-0219": {"epss_score": 0.00502, "epss_percentile": 0.65419}, "CVE-2022-0220": {"epss_score": 0.03363, "epss_percentile": 0.86995}, "CVE-2022-0221": {"epss_score": 0.0023, "epss_percentile": 0.45736}, "CVE-2022-0222": {"epss_score": 0.00333, "epss_percentile": 0.5563}, "CVE-2022-0223": {"epss_score": 0.00253, "epss_percentile": 0.48484}, "CVE-2022-0224": {"epss_score": 0.00515, "epss_percentile": 0.65976}, "CVE-2022-0225": {"epss_score": 0.00457, "epss_percentile": 0.63372}, "CVE-2022-0226": {"epss_score": 0.00117, "epss_percentile": 0.31307}, "CVE-2022-0228": {"epss_score": 0.07048, "epss_percentile": 0.91211}, "CVE-2022-0229": {"epss_score": 0.00177, "epss_percentile": 0.39558}, "CVE-2022-0230": {"epss_score": 0.14825, "epss_percentile": 0.94295}, "CVE-2022-0231": {"epss_score": 0.00106, "epss_percentile": 0.29538}, "CVE-2022-0232": {"epss_score": 0.00432, "epss_percentile": 0.62101}, "CVE-2022-0233": {"epss_score": 0.00296, "epss_percentile": 0.52599}, "CVE-2022-0234": {"epss_score": 0.0259, "epss_percentile": 0.8518}, "CVE-2022-0235": {"epss_score": 0.00647, "epss_percentile": 0.70204}, "CVE-2022-0236": {"epss_score": 0.3739, "epss_percentile": 0.97042}, "CVE-2022-0237": {"epss_score": 0.00061, "epss_percentile": 0.1934}, "CVE-2022-0238": {"epss_score": 0.00166, "epss_percentile": 0.3816}, "CVE-2022-0239": {"epss_score": 0.00042, "epss_percentile": 0.12673}, "CVE-2022-0240": {"epss_score": 0.00299, "epss_percentile": 0.52881}, "CVE-2022-0242": {"epss_score": 0.00493, "epss_percentile": 0.65035}, "CVE-2022-0243": {"epss_score": 0.00195, "epss_percentile": 0.41625}, "CVE-2022-0244": {"epss_score": 0.00286, "epss_percentile": 0.51699}, "CVE-2022-0245": {"epss_score": 0.00106, "epss_percentile": 0.29538}, "CVE-2022-0246": {"epss_score": 0.00303, "epss_percentile": 0.53171}, "CVE-2022-0247": {"epss_score": 0.00016, "epss_percentile": 0.02647}, "CVE-2022-0248": {"epss_score": 0.14825, "epss_percentile": 0.94295}, "CVE-2022-0249": {"epss_score": 0.00233, "epss_percentile": 0.46034}, "CVE-2022-0250": {"epss_score": 0.00769, "epss_percentile": 0.72983}, "CVE-2022-0251": {"epss_score": 0.00012, "epss_percentile": 0.01185}, "CVE-2022-0252": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2022-0253": {"epss_score": 0.00289, "epss_percentile": 0.52026}, "CVE-2022-0254": {"epss_score": 0.00924, "epss_percentile": 0.75513}, "CVE-2022-0255": {"epss_score": 0.0062, "epss_percentile": 0.6945}, "CVE-2022-0256": {"epss_score": 0.0001, "epss_percentile": 0.00793}, "CVE-2022-0257": {"epss_score": 0.00017, "epss_percentile": 0.03126}, "CVE-2022-0258": {"epss_score": 0.00026, "epss_percentile": 0.06712}, "CVE-2022-0260": {"epss_score": 0.00023, "epss_percentile": 0.05417}, "CVE-2022-0261": {"epss_score": 0.00163, "epss_percentile": 0.37807}, "CVE-2022-0262": {"epss_score": 0.00036, "epss_percentile": 0.10493}, "CVE-2022-0263": {"epss_score": 3e-05, "epss_percentile": 0.00116}, "CVE-2022-0264": {"epss_score": 0.00081, "epss_percentile": 0.24358}, "CVE-2022-0265": {"epss_score": 0.09679, "epss_percentile": 0.92657}, "CVE-2022-0266": {"epss_score": 0.00303, "epss_percentile": 0.53226}, "CVE-2022-0267": {"epss_score": 0.0062, "epss_percentile": 0.6945}, "CVE-2022-0268": {"epss_score": 0.00266, "epss_percentile": 0.49913}, "CVE-2022-0269": {"epss_score": 0.00138, "epss_percentile": 0.34352}, "CVE-2022-0270": {"epss_score": 0.00299, "epss_percentile": 0.52865}, "CVE-2022-0271": {"epss_score": 0.05389, "epss_percentile": 0.89823}, "CVE-2022-0272": {"epss_score": 0.00303, "epss_percentile": 0.53192}, "CVE-2022-0273": {"epss_score": 0.00134, "epss_percentile": 0.33787}, "CVE-2022-0274": {"epss_score": 0.00158, "epss_percentile": 0.37155}, "CVE-2022-0277": {"epss_score": 0.0029, "epss_percentile": 0.52109}, "CVE-2022-0278": {"epss_score": 0.0021, "epss_percentile": 0.43601}, "CVE-2022-0279": {"epss_score": 0.00174, "epss_percentile": 0.39192}, "CVE-2022-0280": {"epss_score": 0.00186, "epss_percentile": 0.40632}, "CVE-2022-0281": {"epss_score": 0.34183, "epss_percentile": 0.96829}, "CVE-2022-0282": {"epss_score": 0.00675, "epss_percentile": 0.70895}, "CVE-2022-0283": {"epss_score": 0.00157, "epss_percentile": 0.37097}, "CVE-2022-0284": {"epss_score": 0.00036, "epss_percentile": 0.10237}, "CVE-2022-0285": {"epss_score": 0.00038, "epss_percentile": 0.11164}, "CVE-2022-0286": {"epss_score": 0.00065, "epss_percentile": 0.20442}, "CVE-2022-0287": {"epss_score": 0.00188, "epss_percentile": 0.40913}, "CVE-2022-0288": {"epss_score": 0.0304, "epss_percentile": 0.86272}, "CVE-2022-0289": {"epss_score": 0.11502, "epss_percentile": 0.93385}, "CVE-2022-0290": {"epss_score": 0.0101, "epss_percentile": 0.76605}, "CVE-2022-0291": {"epss_score": 0.00097, "epss_percentile": 0.27602}, "CVE-2022-0292": {"epss_score": 0.00122, "epss_percentile": 0.32107}, "CVE-2022-0293": {"epss_score": 0.00658, "epss_percentile": 0.70496}, "CVE-2022-0294": {"epss_score": 0.00193, "epss_percentile": 0.41389}, "CVE-2022-0295": {"epss_score": 0.00901, "epss_percentile": 0.75174}, "CVE-2022-0296": {"epss_score": 0.00901, "epss_percentile": 0.75174}, "CVE-2022-0297": {"epss_score": 0.00901, "epss_percentile": 0.75174}, "CVE-2022-0298": {"epss_score": 0.00714, "epss_percentile": 0.71826}, "CVE-2022-0300": {"epss_score": 0.013, "epss_percentile": 0.79286}, "CVE-2022-0301": {"epss_score": 0.0008, "epss_percentile": 0.24202}, "CVE-2022-0302": {"epss_score": 0.00227, "epss_percentile": 0.45398}, "CVE-2022-0304": {"epss_score": 0.00901, "epss_percentile": 0.75174}, "CVE-2022-0305": {"epss_score": 0.00178, "epss_percentile": 0.39678}, "CVE-2022-0306": {"epss_score": 0.06469, "epss_percentile": 0.90777}, "CVE-2022-0307": {"epss_score": 0.0096, "epss_percentile": 0.75972}, "CVE-2022-0308": {"epss_score": 0.00901, "epss_percentile": 0.75174}, "CVE-2022-0309": {"epss_score": 0.00105, "epss_percentile": 0.29256}, "CVE-2022-0310": {"epss_score": 0.00672, "epss_percentile": 0.70823}, "CVE-2022-0311": {"epss_score": 0.0046, "epss_percentile": 0.63516}, "CVE-2022-0313": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-0314": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2022-0315": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2022-0316": {"epss_score": 0.2777, "epss_percentile": 0.96281}, "CVE-2022-0317": {"epss_score": 0.00017, "epss_percentile": 0.03174}, "CVE-2022-0318": {"epss_score": 0.00203, "epss_percentile": 0.42498}, "CVE-2022-0319": {"epss_score": 0.00172, "epss_percentile": 0.38975}, "CVE-2022-0320": {"epss_score": 0.04513, "epss_percentile": 0.88784}, "CVE-2022-0321": {"epss_score": 0.0032, "epss_percentile": 0.54637}, "CVE-2022-0322": {"epss_score": 0.00084, "epss_percentile": 0.24839}, "CVE-2022-0323": {"epss_score": 0.00236, "epss_percentile": 0.46373}, "CVE-2022-0324": {"epss_score": 0.00888, "epss_percentile": 0.75002}, "CVE-2022-0326": {"epss_score": 0.00308, "epss_percentile": 0.53597}, "CVE-2022-0327": {"epss_score": 0.00293, "epss_percentile": 0.52337}, "CVE-2022-0328": {"epss_score": 0.00112, "epss_percentile": 0.30542}, "CVE-2022-0330": {"epss_score": 0.00039, "epss_percentile": 0.11463}, "CVE-2022-0331": {"epss_score": 0.00335, "epss_percentile": 0.55896}, "CVE-2022-0332": {"epss_score": 0.02572, "epss_percentile": 0.85132}, "CVE-2022-0333": {"epss_score": 0.0025, "epss_percentile": 0.4811}, "CVE-2022-0334": {"epss_score": 0.00226, "epss_percentile": 0.4531}, "CVE-2022-0335": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2022-0336": {"epss_score": 0.00271, "epss_percentile": 0.50305}, "CVE-2022-0337": {"epss_score": 0.11795, "epss_percentile": 0.93478}, "CVE-2022-0338": {"epss_score": 0.00248, "epss_percentile": 0.47966}, "CVE-2022-0339": {"epss_score": 0.00245, "epss_percentile": 0.47678}, "CVE-2022-0341": {"epss_score": 0.00141, "epss_percentile": 0.3493}, "CVE-2022-0342": {"epss_score": 0.91427, "epss_percentile": 0.99642}, "CVE-2022-0343": {"epss_score": 0.00015, "epss_percentile": 0.02596}, "CVE-2022-0344": {"epss_score": 0.00304, "epss_percentile": 0.5325}, "CVE-2022-0345": {"epss_score": 0.00071, "epss_percentile": 0.22018}, "CVE-2022-0346": {"epss_score": 0.06393, "epss_percentile": 0.90719}, "CVE-2022-0347": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0348": {"epss_score": 0.00023, "epss_percentile": 0.05381}, "CVE-2022-0349": {"epss_score": 0.58573, "epss_percentile": 0.98125}, "CVE-2022-0350": {"epss_score": 0.00158, "epss_percentile": 0.37155}, "CVE-2022-0351": {"epss_score": 0.00052, "epss_percentile": 0.16582}, "CVE-2022-0352": {"epss_score": 0.00318, "epss_percentile": 0.54437}, "CVE-2022-0353": {"epss_score": 0.00036, "epss_percentile": 0.10443}, "CVE-2022-0354": {"epss_score": 0.00052, "epss_percentile": 0.16385}, "CVE-2022-0355": {"epss_score": 0.0046, "epss_percentile": 0.63523}, "CVE-2022-0357": {"epss_score": 0.00039, "epss_percentile": 0.11624}, "CVE-2022-0358": {"epss_score": 0.00022, "epss_percentile": 0.05231}, "CVE-2022-0359": {"epss_score": 0.00122, "epss_percentile": 0.32072}, "CVE-2022-0360": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0361": {"epss_score": 0.00118, "epss_percentile": 0.31509}, "CVE-2022-0362": {"epss_score": 0.00274, "epss_percentile": 0.50513}, "CVE-2022-0363": {"epss_score": 0.00066, "epss_percentile": 0.20825}, "CVE-2022-0364": {"epss_score": 0.00271, "epss_percentile": 0.50301}, "CVE-2022-0365": {"epss_score": 0.02419, "epss_percentile": 0.847}, "CVE-2022-0366": {"epss_score": 0.00436, "epss_percentile": 0.62446}, "CVE-2022-0367": {"epss_score": 0.00101, "epss_percentile": 0.28712}, "CVE-2022-0368": {"epss_score": 0.00193, "epss_percentile": 0.41458}, "CVE-2022-0369": {"epss_score": 0.02201, "epss_percentile": 0.8398}, "CVE-2022-0370": {"epss_score": 0.00289, "epss_percentile": 0.52026}, "CVE-2022-0371": {"epss_score": 0.00282, "epss_percentile": 0.51264}, "CVE-2022-0372": {"epss_score": 0.00263, "epss_percentile": 0.49484}, "CVE-2022-0373": {"epss_score": 0.00274, "epss_percentile": 0.50536}, "CVE-2022-0374": {"epss_score": 0.00267, "epss_percentile": 0.50013}, "CVE-2022-0375": {"epss_score": 0.00357, "epss_percentile": 0.57402}, "CVE-2022-0376": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-0377": {"epss_score": 0.02681, "epss_percentile": 0.85415}, "CVE-2022-0378": {"epss_score": 0.07396, "epss_percentile": 0.91451}, "CVE-2022-0379": {"epss_score": 0.00342, "epss_percentile": 0.56359}, "CVE-2022-0380": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0381": {"epss_score": 0.07802, "epss_percentile": 0.91689}, "CVE-2022-0382": {"epss_score": 0.0005, "epss_percentile": 0.15943}, "CVE-2022-0383": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2022-0384": {"epss_score": 0.00228, "epss_percentile": 0.45475}, "CVE-2022-0385": {"epss_score": 0.05995, "epss_percentile": 0.9039}, "CVE-2022-0386": {"epss_score": 0.00331, "epss_percentile": 0.55502}, "CVE-2022-0387": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-0388": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-0389": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-0390": {"epss_score": 0.00263, "epss_percentile": 0.49485}, "CVE-2022-0391": {"epss_score": 0.01766, "epss_percentile": 0.82169}, "CVE-2022-0392": {"epss_score": 0.00107, "epss_percentile": 0.29694}, "CVE-2022-0393": {"epss_score": 0.00063, "epss_percentile": 0.19816}, "CVE-2022-0394": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2022-0395": {"epss_score": 0.00376, "epss_percentile": 0.58649}, "CVE-2022-0396": {"epss_score": 0.00073, "epss_percentile": 0.22638}, "CVE-2022-0397": {"epss_score": 0.00285, "epss_percentile": 0.51541}, "CVE-2022-0398": {"epss_score": 0.00066, "epss_percentile": 0.20894}, "CVE-2022-0399": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-0400": {"epss_score": 0.00041, "epss_percentile": 0.12456}, "CVE-2022-0401": {"epss_score": 0.00684, "epss_percentile": 0.71116}, "CVE-2022-0402": {"epss_score": 0.00306, "epss_percentile": 0.5341}, "CVE-2022-0403": {"epss_score": 0.0029, "epss_percentile": 0.52126}, "CVE-2022-0404": {"epss_score": 0.00269, "epss_percentile": 0.5017}, "CVE-2022-0405": {"epss_score": 0.00131, "epss_percentile": 0.3341}, "CVE-2022-0406": {"epss_score": 0.00134, "epss_percentile": 0.33787}, "CVE-2022-0407": {"epss_score": 0.00074, "epss_percentile": 0.22791}, "CVE-2022-0408": {"epss_score": 0.00191, "epss_percentile": 0.41172}, "CVE-2022-0409": {"epss_score": 0.00209, "epss_percentile": 0.43363}, "CVE-2022-0410": {"epss_score": 0.01219, "epss_percentile": 0.78614}, "CVE-2022-0411": {"epss_score": 0.01052, "epss_percentile": 0.77087}, "CVE-2022-0412": {"epss_score": 0.85862, "epss_percentile": 0.99352}, "CVE-2022-0413": {"epss_score": 0.0018, "epss_percentile": 0.39904}, "CVE-2022-0414": {"epss_score": 0.00326, "epss_percentile": 0.55075}, "CVE-2022-0415": {"epss_score": 0.85529, "epss_percentile": 0.99338}, "CVE-2022-0417": {"epss_score": 0.00309, "epss_percentile": 0.53667}, "CVE-2022-0418": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-0419": {"epss_score": 0.00248, "epss_percentile": 0.47923}, "CVE-2022-0420": {"epss_score": 0.00776, "epss_percentile": 0.73099}, "CVE-2022-0421": {"epss_score": 0.01037, "epss_percentile": 0.76925}, "CVE-2022-0422": {"epss_score": 0.08413, "epss_percentile": 0.92038}, "CVE-2022-0423": {"epss_score": 0.00285, "epss_percentile": 0.51541}, "CVE-2022-0424": {"epss_score": 0.25772, "epss_percentile": 0.96068}, "CVE-2022-0425": {"epss_score": 0.00159, "epss_percentile": 0.37416}, "CVE-2022-0426": {"epss_score": 0.00217, "epss_percentile": 0.44267}, "CVE-2022-0427": {"epss_score": 0.00119, "epss_percentile": 0.31664}, "CVE-2022-0428": {"epss_score": 0.0029, "epss_percentile": 0.52085}, "CVE-2022-0429": {"epss_score": 0.00888, "epss_percentile": 0.74993}, "CVE-2022-0430": {"epss_score": 0.00371, "epss_percentile": 0.584}, "CVE-2022-0431": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-0432": {"epss_score": 0.28093, "epss_percentile": 0.96308}, "CVE-2022-0433": {"epss_score": 0.00039, "epss_percentile": 0.11714}, "CVE-2022-0434": {"epss_score": 0.88588, "epss_percentile": 0.99479}, "CVE-2022-0435": {"epss_score": 0.54322, "epss_percentile": 0.97919}, "CVE-2022-0436": {"epss_score": 0.00119, "epss_percentile": 0.31573}, "CVE-2022-0437": {"epss_score": 0.12079, "epss_percentile": 0.93562}, "CVE-2022-0439": {"epss_score": 0.10004, "epss_percentile": 0.92812}, "CVE-2022-0440": {"epss_score": 0.00875, "epss_percentile": 0.74777}, "CVE-2022-0441": {"epss_score": 0.81347, "epss_percentile": 0.99133}, "CVE-2022-0442": {"epss_score": 0.00153, "epss_percentile": 0.36583}, "CVE-2022-0443": {"epss_score": 0.0018, "epss_percentile": 0.39904}, "CVE-2022-0444": {"epss_score": 0.00073, "epss_percentile": 0.22641}, "CVE-2022-0445": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2022-0446": {"epss_score": 0.00298, "epss_percentile": 0.52815}, "CVE-2022-0447": {"epss_score": 0.00285, "epss_percentile": 0.51541}, "CVE-2022-0448": {"epss_score": 0.06256, "epss_percentile": 0.90617}, "CVE-2022-0449": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-0450": {"epss_score": 0.00247, "epss_percentile": 0.47836}, "CVE-2022-0451": {"epss_score": 0.00164, "epss_percentile": 0.37905}, "CVE-2022-0452": {"epss_score": 0.00296, "epss_percentile": 0.52577}, "CVE-2022-0453": {"epss_score": 0.00296, "epss_percentile": 0.52577}, "CVE-2022-0454": {"epss_score": 0.00394, "epss_percentile": 0.59759}, "CVE-2022-0455": {"epss_score": 0.00288, "epss_percentile": 0.51951}, "CVE-2022-0456": {"epss_score": 0.00273, "epss_percentile": 0.50429}, "CVE-2022-0457": {"epss_score": 0.00292, "epss_percentile": 0.52282}, "CVE-2022-0458": {"epss_score": 0.00294, "epss_percentile": 0.52417}, "CVE-2022-0459": {"epss_score": 0.00539, "epss_percentile": 0.66969}, "CVE-2022-0460": {"epss_score": 0.00294, "epss_percentile": 0.52417}, "CVE-2022-0461": {"epss_score": 0.00066, "epss_percentile": 0.20948}, "CVE-2022-0462": {"epss_score": 0.00534, "epss_percentile": 0.66791}, "CVE-2022-0463": {"epss_score": 0.00294, "epss_percentile": 0.52417}, "CVE-2022-0464": {"epss_score": 0.00294, "epss_percentile": 0.52417}, "CVE-2022-0465": {"epss_score": 0.00294, "epss_percentile": 0.52417}, "CVE-2022-0466": {"epss_score": 0.00187, "epss_percentile": 0.40726}, "CVE-2022-0467": {"epss_score": 0.00216, "epss_percentile": 0.44202}, "CVE-2022-0468": {"epss_score": 0.00294, "epss_percentile": 0.52417}, "CVE-2022-0469": {"epss_score": 0.00191, "epss_percentile": 0.41163}, "CVE-2022-0470": {"epss_score": 0.00292, "epss_percentile": 0.52282}, "CVE-2022-0471": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-0472": {"epss_score": 0.00337, "epss_percentile": 0.56062}, "CVE-2022-0473": {"epss_score": 0.00604, "epss_percentile": 0.68953}, "CVE-2022-0474": {"epss_score": 0.00209, "epss_percentile": 0.43424}, "CVE-2022-0475": {"epss_score": 0.00516, "epss_percentile": 0.66051}, "CVE-2022-0476": {"epss_score": 0.00225, "epss_percentile": 0.45128}, "CVE-2022-0477": {"epss_score": 0.00187, "epss_percentile": 0.40799}, "CVE-2022-0478": {"epss_score": 0.00582, "epss_percentile": 0.68293}, "CVE-2022-0479": {"epss_score": 0.76374, "epss_percentile": 0.98889}, "CVE-2022-0480": {"epss_score": 0.00027, "epss_percentile": 0.06807}, "CVE-2022-0481": {"epss_score": 0.00281, "epss_percentile": 0.51192}, "CVE-2022-0482": {"epss_score": 0.93282, "epss_percentile": 0.99793}, "CVE-2022-0483": {"epss_score": 0.00033, "epss_percentile": 0.09344}, "CVE-2022-0484": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2022-0485": {"epss_score": 0.00116, "epss_percentile": 0.31188}, "CVE-2022-0486": {"epss_score": 0.0013, "epss_percentile": 0.33257}, "CVE-2022-0487": {"epss_score": 0.00071, "epss_percentile": 0.22008}, "CVE-2022-0488": {"epss_score": 0.00145, "epss_percentile": 0.35401}, "CVE-2022-0489": {"epss_score": 0.00199, "epss_percentile": 0.42146}, "CVE-2022-0492": {"epss_score": 0.05621, "epss_percentile": 0.9006}, "CVE-2022-0493": {"epss_score": 0.01036, "epss_percentile": 0.76914}, "CVE-2022-0494": {"epss_score": 0.00019, "epss_percentile": 0.04236}, "CVE-2022-0495": {"epss_score": 0.0043, "epss_percentile": 0.62031}, "CVE-2022-0496": {"epss_score": 0.00177, "epss_percentile": 0.39565}, "CVE-2022-0497": {"epss_score": 0.00179, "epss_percentile": 0.39773}, "CVE-2022-0499": {"epss_score": 0.0012, "epss_percentile": 0.31706}, "CVE-2022-0500": {"epss_score": 0.00022, "epss_percentile": 0.05231}, "CVE-2022-0501": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2022-0502": {"epss_score": 0.00376, "epss_percentile": 0.58649}, "CVE-2022-0503": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-0504": {"epss_score": 0.00288, "epss_percentile": 0.51882}, "CVE-2022-0505": {"epss_score": 0.00153, "epss_percentile": 0.36551}, "CVE-2022-0506": {"epss_score": 0.00241, "epss_percentile": 0.47253}, "CVE-2022-0507": {"epss_score": 0.00281, "epss_percentile": 0.5115}, "CVE-2022-0508": {"epss_score": 0.00213, "epss_percentile": 0.43947}, "CVE-2022-0509": {"epss_score": 0.00044, "epss_percentile": 0.13642}, "CVE-2022-0510": {"epss_score": 0.00034, "epss_percentile": 0.09546}, "CVE-2022-0511": {"epss_score": 0.00454, "epss_percentile": 0.6326}, "CVE-2022-0512": {"epss_score": 0.00028, "epss_percentile": 0.07439}, "CVE-2022-0513": {"epss_score": 0.30446, "epss_percentile": 0.9654}, "CVE-2022-0514": {"epss_score": 0.00203, "epss_percentile": 0.42564}, "CVE-2022-0515": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2022-0516": {"epss_score": 0.00092, "epss_percentile": 0.26547}, "CVE-2022-0517": {"epss_score": 0.00041, "epss_percentile": 0.124}, "CVE-2022-0518": {"epss_score": 0.00369, "epss_percentile": 0.58239}, "CVE-2022-0519": {"epss_score": 0.00355, "epss_percentile": 0.57277}, "CVE-2022-0520": {"epss_score": 0.00327, "epss_percentile": 0.55114}, "CVE-2022-0521": {"epss_score": 0.00355, "epss_percentile": 0.57277}, "CVE-2022-0522": {"epss_score": 0.00355, "epss_percentile": 0.57277}, "CVE-2022-0523": {"epss_score": 0.0024, "epss_percentile": 0.47205}, "CVE-2022-0524": {"epss_score": 0.00314, "epss_percentile": 0.54092}, "CVE-2022-0525": {"epss_score": 0.00297, "epss_percentile": 0.52683}, "CVE-2022-0526": {"epss_score": 0.00341, "epss_percentile": 0.56321}, "CVE-2022-0527": {"epss_score": 0.00357, "epss_percentile": 0.57402}, "CVE-2022-0528": {"epss_score": 0.00277, "epss_percentile": 0.50796}, "CVE-2022-0529": {"epss_score": 0.00242, "epss_percentile": 0.47403}, "CVE-2022-0530": {"epss_score": 0.00163, "epss_percentile": 0.37818}, "CVE-2022-0531": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-0532": {"epss_score": 0.00079, "epss_percentile": 0.23913}, "CVE-2022-0533": {"epss_score": 0.04689, "epss_percentile": 0.8901}, "CVE-2022-0534": {"epss_score": 0.0014, "epss_percentile": 0.34701}, "CVE-2022-0535": {"epss_score": 0.0224, "epss_percentile": 0.84113}, "CVE-2022-0536": {"epss_score": 0.00063, "epss_percentile": 0.2}, "CVE-2022-0537": {"epss_score": 0.00875, "epss_percentile": 0.74777}, "CVE-2022-0538": {"epss_score": 0.01656, "epss_percentile": 0.816}, "CVE-2022-0539": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-0540": {"epss_score": 0.92291, "epss_percentile": 0.99706}, "CVE-2022-0541": {"epss_score": 0.00732, "epss_percentile": 0.72192}, "CVE-2022-0542": {"epss_score": 0.00363, "epss_percentile": 0.57868}, "CVE-2022-0543": {"epss_score": 0.94398, "epss_percentile": 0.99972}, "CVE-2022-0544": {"epss_score": 0.00167, "epss_percentile": 0.38355}, "CVE-2022-0545": {"epss_score": 0.00287, "epss_percentile": 0.51851}, "CVE-2022-0546": {"epss_score": 0.00386, "epss_percentile": 0.59243}, "CVE-2022-0547": {"epss_score": 0.00593, "epss_percentile": 0.68643}, "CVE-2022-0549": {"epss_score": 0.00126, "epss_percentile": 0.32759}, "CVE-2022-0550": {"epss_score": 0.00477, "epss_percentile": 0.64333}, "CVE-2022-0551": {"epss_score": 0.00477, "epss_percentile": 0.64333}, "CVE-2022-0552": {"epss_score": 0.00285, "epss_percentile": 0.51637}, "CVE-2022-0553": {"epss_score": 0.00024, "epss_percentile": 0.06025}, "CVE-2022-0554": {"epss_score": 0.00399, "epss_percentile": 0.60146}, "CVE-2022-0555": {"epss_score": 0.00064, "epss_percentile": 0.20112}, "CVE-2022-0556": {"epss_score": 0.00038, "epss_percentile": 0.11141}, "CVE-2022-0557": {"epss_score": 0.14137, "epss_percentile": 0.94143}, "CVE-2022-0558": {"epss_score": 0.0032, "epss_percentile": 0.54627}, "CVE-2022-0559": {"epss_score": 0.00327, "epss_percentile": 0.55114}, "CVE-2022-0560": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2022-0561": {"epss_score": 0.00101, "epss_percentile": 0.2866}, "CVE-2022-0562": {"epss_score": 0.00057, "epss_percentile": 0.17989}, "CVE-2022-0563": {"epss_score": 0.0002, "epss_percentile": 0.04468}, "CVE-2022-0564": {"epss_score": 0.00485, "epss_percentile": 0.64721}, "CVE-2022-0565": {"epss_score": 0.00044, "epss_percentile": 0.13439}, "CVE-2022-0566": {"epss_score": 0.00209, "epss_percentile": 0.43385}, "CVE-2022-0567": {"epss_score": 0.00378, "epss_percentile": 0.58785}, "CVE-2022-0569": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2022-0570": {"epss_score": 0.0027, "epss_percentile": 0.50252}, "CVE-2022-0571": {"epss_score": 0.0039, "epss_percentile": 0.59542}, "CVE-2022-0572": {"epss_score": 0.01148, "epss_percentile": 0.78015}, "CVE-2022-0573": {"epss_score": 0.0592, "epss_percentile": 0.90321}, "CVE-2022-0574": {"epss_score": 0.00214, "epss_percentile": 0.44013}, "CVE-2022-0575": {"epss_score": 0.00026, "epss_percentile": 0.06721}, "CVE-2022-0576": {"epss_score": 6e-05, "epss_percentile": 0.00243}, "CVE-2022-0577": {"epss_score": 0.00174, "epss_percentile": 0.39224}, "CVE-2022-0578": {"epss_score": 0.00248, "epss_percentile": 0.47978}, "CVE-2022-0579": {"epss_score": 0.00303, "epss_percentile": 0.53211}, "CVE-2022-0580": {"epss_score": 2e-05, "epss_percentile": 0.00024}, "CVE-2022-0581": {"epss_score": 0.00075, "epss_percentile": 0.22889}, "CVE-2022-0582": {"epss_score": 0.00065, "epss_percentile": 0.2053}, "CVE-2022-0583": {"epss_score": 0.00078, "epss_percentile": 0.23761}, "CVE-2022-0585": {"epss_score": 0.0005, "epss_percentile": 0.15878}, "CVE-2022-0586": {"epss_score": 0.00024, "epss_percentile": 0.05815}, "CVE-2022-0587": {"epss_score": 2e-05, "epss_percentile": 0.00054}, "CVE-2022-0588": {"epss_score": 2e-05, "epss_percentile": 0.00038}, "CVE-2022-0589": {"epss_score": 0.00026, "epss_percentile": 0.06721}, "CVE-2022-0590": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-0591": {"epss_score": 0.87898, "epss_percentile": 0.99448}, "CVE-2022-0592": {"epss_score": 0.67367, "epss_percentile": 0.98504}, "CVE-2022-0593": {"epss_score": 0.0041, "epss_percentile": 0.60828}, "CVE-2022-0594": {"epss_score": 0.43978, "epss_percentile": 0.97412}, "CVE-2022-0595": {"epss_score": 0.05776, "epss_percentile": 0.90197}, "CVE-2022-0596": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2022-0597": {"epss_score": 0.00964, "epss_percentile": 0.76037}, "CVE-2022-0598": {"epss_score": 0.00415, "epss_percentile": 0.61135}, "CVE-2022-0599": {"epss_score": 0.01606, "epss_percentile": 0.81305}, "CVE-2022-0600": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0601": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-0602": {"epss_score": 0.0021, "epss_percentile": 0.43601}, "CVE-2022-0603": {"epss_score": 0.00681, "epss_percentile": 0.71046}, "CVE-2022-0604": {"epss_score": 0.00315, "epss_percentile": 0.54166}, "CVE-2022-0605": {"epss_score": 0.00285, "epss_percentile": 0.51528}, "CVE-2022-0606": {"epss_score": 0.00681, "epss_percentile": 0.71046}, "CVE-2022-0607": {"epss_score": 0.00681, "epss_percentile": 0.71046}, "CVE-2022-0608": {"epss_score": 0.00502, "epss_percentile": 0.65377}, "CVE-2022-0609": {"epss_score": 0.41478, "epss_percentile": 0.97276}, "CVE-2022-0610": {"epss_score": 0.00362, "epss_percentile": 0.57754}, "CVE-2022-0611": {"epss_score": 0.00294, "epss_percentile": 0.52411}, "CVE-2022-0612": {"epss_score": 0.00322, "epss_percentile": 0.54791}, "CVE-2022-0613": {"epss_score": 0.00084, "epss_percentile": 0.24859}, "CVE-2022-0614": {"epss_score": 0.0031, "epss_percentile": 0.53765}, "CVE-2022-0615": {"epss_score": 0.00431, "epss_percentile": 0.62058}, "CVE-2022-0616": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-0617": {"epss_score": 0.00023, "epss_percentile": 0.05487}, "CVE-2022-0618": {"epss_score": 0.01019, "epss_percentile": 0.76724}, "CVE-2022-0619": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2022-0620": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0621": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0622": {"epss_score": 0.00071, "epss_percentile": 0.22117}, "CVE-2022-0623": {"epss_score": 0.00433, "epss_percentile": 0.62172}, "CVE-2022-0624": {"epss_score": 0.00126, "epss_percentile": 0.32769}, "CVE-2022-0625": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2022-0626": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0627": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0628": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0629": {"epss_score": 0.01005, "epss_percentile": 0.76535}, "CVE-2022-0630": {"epss_score": 0.00297, "epss_percentile": 0.52683}, "CVE-2022-0631": {"epss_score": 0.00269, "epss_percentile": 0.50173}, "CVE-2022-0632": {"epss_score": 0.00227, "epss_percentile": 0.45364}, "CVE-2022-0633": {"epss_score": 0.01399, "epss_percentile": 0.79992}, "CVE-2022-0634": {"epss_score": 0.00071, "epss_percentile": 0.22191}, "CVE-2022-0635": {"epss_score": 0.00781, "epss_percentile": 0.73184}, "CVE-2022-0636": {"epss_score": 0.0004, "epss_percentile": 0.12157}, "CVE-2022-0637": {"epss_score": 0.00081, "epss_percentile": 0.2424}, "CVE-2022-0638": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2022-0639": {"epss_score": 0.00025, "epss_percentile": 0.06112}, "CVE-2022-0640": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0641": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0642": {"epss_score": 0.00084, "epss_percentile": 0.24901}, "CVE-2022-0643": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0645": {"epss_score": 0.00207, "epss_percentile": 0.43155}, "CVE-2022-0646": {"epss_score": 0.0011, "epss_percentile": 0.30151}, "CVE-2022-0647": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0648": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0649": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0650": {"epss_score": 0.00028, "epss_percentile": 0.07334}, "CVE-2022-0651": {"epss_score": 0.66896, "epss_percentile": 0.98486}, "CVE-2022-0652": {"epss_score": 0.00043, "epss_percentile": 0.12958}, "CVE-2022-0653": {"epss_score": 0.0565, "epss_percentile": 0.90084}, "CVE-2022-0654": {"epss_score": 0.00342, "epss_percentile": 0.56351}, "CVE-2022-0656": {"epss_score": 0.68162, "epss_percentile": 0.98534}, "CVE-2022-0657": {"epss_score": 0.02732, "epss_percentile": 0.85542}, "CVE-2022-0658": {"epss_score": 0.47173, "epss_percentile": 0.97572}, "CVE-2022-0659": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0660": {"epss_score": 0.07502, "epss_percentile": 0.91507}, "CVE-2022-0661": {"epss_score": 0.11833, "epss_percentile": 0.9349}, "CVE-2022-0662": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2022-0663": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0664": {"epss_score": 0.0029, "epss_percentile": 0.52118}, "CVE-2022-0665": {"epss_score": 0.00013, "epss_percentile": 0.01557}, "CVE-2022-0666": {"epss_score": 0.28901, "epss_percentile": 0.96399}, "CVE-2022-0667": {"epss_score": 0.00694, "epss_percentile": 0.71344}, "CVE-2022-0668": {"epss_score": 0.00084, "epss_percentile": 0.24858}, "CVE-2022-0669": {"epss_score": 0.00129, "epss_percentile": 0.33132}, "CVE-2022-0670": {"epss_score": 0.00196, "epss_percentile": 0.4181}, "CVE-2022-0671": {"epss_score": 0.00384, "epss_percentile": 0.59149}, "CVE-2022-0672": {"epss_score": 0.00085, "epss_percentile": 0.25219}, "CVE-2022-0673": {"epss_score": 0.00176, "epss_percentile": 0.39469}, "CVE-2022-0674": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0675": {"epss_score": 0.00534, "epss_percentile": 0.66777}, "CVE-2022-0676": {"epss_score": 0.00353, "epss_percentile": 0.57163}, "CVE-2022-0677": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2022-0678": {"epss_score": 0.01223, "epss_percentile": 0.78665}, "CVE-2022-0679": {"epss_score": 0.84482, "epss_percentile": 0.99292}, "CVE-2022-0680": {"epss_score": 0.01239, "epss_percentile": 0.78799}, "CVE-2022-0681": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2022-0683": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0684": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0685": {"epss_score": 0.00399, "epss_percentile": 0.60146}, "CVE-2022-0686": {"epss_score": 0.00108, "epss_percentile": 0.29781}, "CVE-2022-0687": {"epss_score": 0.00821, "epss_percentile": 0.73902}, "CVE-2022-0688": {"epss_score": 0.00333, "epss_percentile": 0.55622}, "CVE-2022-0689": {"epss_score": 0.00284, "epss_percentile": 0.51495}, "CVE-2022-0690": {"epss_score": 0.0085, "epss_percentile": 0.74393}, "CVE-2022-0691": {"epss_score": 0.00109, "epss_percentile": 0.29976}, "CVE-2022-0692": {"epss_score": 0.20834, "epss_percentile": 0.95421}, "CVE-2022-0693": {"epss_score": 0.62576, "epss_percentile": 0.98297}, "CVE-2022-0694": {"epss_score": 0.00865, "epss_percentile": 0.74615}, "CVE-2022-0695": {"epss_score": 0.00324, "epss_percentile": 0.54928}, "CVE-2022-0696": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2022-0697": {"epss_score": 0.00189, "epss_percentile": 0.41004}, "CVE-2022-0698": {"epss_score": 0.02106, "epss_percentile": 0.83625}, "CVE-2022-0699": {"epss_score": 0.00394, "epss_percentile": 0.59777}, "CVE-2022-0700": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0701": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2022-0702": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2022-0703": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0704": {"epss_score": 0.0003, "epss_percentile": 0.08185}, "CVE-2022-0705": {"epss_score": 9e-05, "epss_percentile": 0.00611}, "CVE-2022-0706": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2022-0707": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-0708": {"epss_score": 0.0039, "epss_percentile": 0.59525}, "CVE-2022-0709": {"epss_score": 0.00785, "epss_percentile": 0.73254}, "CVE-2022-0710": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0711": {"epss_score": 0.66484, "epss_percentile": 0.98464}, "CVE-2022-0712": {"epss_score": 0.00425, "epss_percentile": 0.61722}, "CVE-2022-0713": {"epss_score": 0.00343, "epss_percentile": 0.56467}, "CVE-2022-0714": {"epss_score": 0.00267, "epss_percentile": 0.50019}, "CVE-2022-0715": {"epss_score": 0.01246, "epss_percentile": 0.78855}, "CVE-2022-0717": {"epss_score": 0.00297, "epss_percentile": 0.52683}, "CVE-2022-0718": {"epss_score": 0.00402, "epss_percentile": 0.60316}, "CVE-2022-0719": {"epss_score": 0.00384, "epss_percentile": 0.59128}, "CVE-2022-0720": {"epss_score": 0.00133, "epss_percentile": 0.337}, "CVE-2022-0721": {"epss_score": 0.00352, "epss_percentile": 0.57081}, "CVE-2022-0722": {"epss_score": 0.00301, "epss_percentile": 0.53043}, "CVE-2022-0723": {"epss_score": 0.00384, "epss_percentile": 0.59128}, "CVE-2022-0724": {"epss_score": 0.00455, "epss_percentile": 0.63294}, "CVE-2022-0725": {"epss_score": 0.00841, "epss_percentile": 0.74217}, "CVE-2022-0726": {"epss_score": 0.00221, "epss_percentile": 0.44668}, "CVE-2022-0727": {"epss_score": 0.00152, "epss_percentile": 0.3642}, "CVE-2022-0728": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0729": {"epss_score": 0.00436, "epss_percentile": 0.62483}, "CVE-2022-0730": {"epss_score": 0.00377, "epss_percentile": 0.58746}, "CVE-2022-0731": {"epss_score": 0.00183, "epss_percentile": 0.40284}, "CVE-2022-0732": {"epss_score": 0.00881, "epss_percentile": 0.74874}, "CVE-2022-0734": {"epss_score": 0.00326, "epss_percentile": 0.55081}, "CVE-2022-0735": {"epss_score": 0.31084, "epss_percentile": 0.96586}, "CVE-2022-0736": {"epss_score": 0.00627, "epss_percentile": 0.69633}, "CVE-2022-0737": {"epss_score": 0.00281, "epss_percentile": 0.51196}, "CVE-2022-0738": {"epss_score": 0.00187, "epss_percentile": 0.40712}, "CVE-2022-0739": {"epss_score": 0.7311, "epss_percentile": 0.98736}, "CVE-2022-0740": {"epss_score": 0.0017, "epss_percentile": 0.38727}, "CVE-2022-0741": {"epss_score": 0.00274, "epss_percentile": 0.50527}, "CVE-2022-0742": {"epss_score": 0.02207, "epss_percentile": 0.84006}, "CVE-2022-0743": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-0745": {"epss_score": 0.00277, "epss_percentile": 0.50822}, "CVE-2022-0746": {"epss_score": 0.00215, "epss_percentile": 0.44079}, "CVE-2022-0747": {"epss_score": 0.89989, "epss_percentile": 0.99555}, "CVE-2022-0748": {"epss_score": 0.01201, "epss_percentile": 0.78484}, "CVE-2022-0749": {"epss_score": 0.005, "epss_percentile": 0.6529}, "CVE-2022-0750": {"epss_score": 0.00182, "epss_percentile": 0.4022}, "CVE-2022-0751": {"epss_score": 0.00258, "epss_percentile": 0.48956}, "CVE-2022-0752": {"epss_score": 0.00313, "epss_percentile": 0.54032}, "CVE-2022-0753": {"epss_score": 0.00291, "epss_percentile": 0.52189}, "CVE-2022-0754": {"epss_score": 0.00238, "epss_percentile": 0.46792}, "CVE-2022-0755": {"epss_score": 0.0024, "epss_percentile": 0.472}, "CVE-2022-0756": {"epss_score": 0.00248, "epss_percentile": 0.47931}, "CVE-2022-0757": {"epss_score": 0.00156, "epss_percentile": 0.36972}, "CVE-2022-0758": {"epss_score": 0.00442, "epss_percentile": 0.62729}, "CVE-2022-0759": {"epss_score": 0.00137, "epss_percentile": 0.34244}, "CVE-2022-0760": {"epss_score": 0.85913, "epss_percentile": 0.99356}, "CVE-2022-0762": {"epss_score": 0.00221, "epss_percentile": 0.44668}, "CVE-2022-0763": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-0764": {"epss_score": 0.00217, "epss_percentile": 0.44289}, "CVE-2022-0765": {"epss_score": 0.10813, "epss_percentile": 0.93119}, "CVE-2022-0766": {"epss_score": 0.00288, "epss_percentile": 0.51976}, "CVE-2022-0767": {"epss_score": 0.00197, "epss_percentile": 0.41845}, "CVE-2022-0768": {"epss_score": 0.00847, "epss_percentile": 0.74353}, "CVE-2022-0769": {"epss_score": 0.87617, "epss_percentile": 0.99435}, "CVE-2022-0770": {"epss_score": 0.003, "epss_percentile": 0.52964}, "CVE-2022-0771": {"epss_score": 0.00865, "epss_percentile": 0.74615}, "CVE-2022-0772": {"epss_score": 0.00016, "epss_percentile": 0.02898}, "CVE-2022-0773": {"epss_score": 0.75514, "epss_percentile": 0.9885}, "CVE-2022-0775": {"epss_score": 0.00339, "epss_percentile": 0.56186}, "CVE-2022-0776": {"epss_score": 0.20046, "epss_percentile": 0.9528}, "CVE-2022-0777": {"epss_score": 0.00509, "epss_percentile": 0.65755}, "CVE-2022-0778": {"epss_score": 0.0707, "epss_percentile": 0.91226}, "CVE-2022-0779": {"epss_score": 0.13663, "epss_percentile": 0.94029}, "CVE-2022-0780": {"epss_score": 0.01135, "epss_percentile": 0.77909}, "CVE-2022-0781": {"epss_score": 0.85118, "epss_percentile": 0.9932}, "CVE-2022-0782": {"epss_score": 0.02732, "epss_percentile": 0.85542}, "CVE-2022-0783": {"epss_score": 0.51271, "epss_percentile": 0.97772}, "CVE-2022-0784": {"epss_score": 0.72843, "epss_percentile": 0.98726}, "CVE-2022-0785": {"epss_score": 0.7029, "epss_percentile": 0.98626}, "CVE-2022-0786": {"epss_score": 0.64426, "epss_percentile": 0.98378}, "CVE-2022-0787": {"epss_score": 0.47173, "epss_percentile": 0.97572}, "CVE-2022-0788": {"epss_score": 0.45285, "epss_percentile": 0.97481}, "CVE-2022-0789": {"epss_score": 0.00891, "epss_percentile": 0.75051}, "CVE-2022-0790": {"epss_score": 0.00888, "epss_percentile": 0.75009}, "CVE-2022-0791": {"epss_score": 0.00722, "epss_percentile": 0.72002}, "CVE-2022-0792": {"epss_score": 0.00948, "epss_percentile": 0.75828}, "CVE-2022-0793": {"epss_score": 0.0021, "epss_percentile": 0.43467}, "CVE-2022-0794": {"epss_score": 0.00449, "epss_percentile": 0.63055}, "CVE-2022-0795": {"epss_score": 0.00469, "epss_percentile": 0.6394}, "CVE-2022-0796": {"epss_score": 0.00727, "epss_percentile": 0.72089}, "CVE-2022-0797": {"epss_score": 0.00722, "epss_percentile": 0.72002}, "CVE-2022-0798": {"epss_score": 0.00224, "epss_percentile": 0.45027}, "CVE-2022-0799": {"epss_score": 0.00483, "epss_percentile": 0.64616}, "CVE-2022-0800": {"epss_score": 0.00572, "epss_percentile": 0.68024}, "CVE-2022-0801": {"epss_score": 0.00111, "epss_percentile": 0.30355}, "CVE-2022-0802": {"epss_score": 0.00262, "epss_percentile": 0.49395}, "CVE-2022-0803": {"epss_score": 0.00241, "epss_percentile": 0.47242}, "CVE-2022-0804": {"epss_score": 0.00262, "epss_percentile": 0.49395}, "CVE-2022-0805": {"epss_score": 0.00449, "epss_percentile": 0.63055}, "CVE-2022-0806": {"epss_score": 0.00162, "epss_percentile": 0.37635}, "CVE-2022-0807": {"epss_score": 0.00141, "epss_percentile": 0.34848}, "CVE-2022-0808": {"epss_score": 0.00833, "epss_percentile": 0.74089}, "CVE-2022-0809": {"epss_score": 0.00519, "epss_percentile": 0.66144}, "CVE-2022-0811": {"epss_score": 0.21215, "epss_percentile": 0.95477}, "CVE-2022-0812": {"epss_score": 0.0015, "epss_percentile": 0.36113}, "CVE-2022-0813": {"epss_score": 0.00416, "epss_percentile": 0.61178}, "CVE-2022-0814": {"epss_score": 0.58129, "epss_percentile": 0.981}, "CVE-2022-0815": {"epss_score": 0.00381, "epss_percentile": 0.59008}, "CVE-2022-0817": {"epss_score": 0.64589, "epss_percentile": 0.98385}, "CVE-2022-0818": {"epss_score": 0.01135, "epss_percentile": 0.77909}, "CVE-2022-0819": {"epss_score": 0.02338, "epss_percentile": 0.84424}, "CVE-2022-0820": {"epss_score": 0.0034, "epss_percentile": 0.56263}, "CVE-2022-0821": {"epss_score": 0.00221, "epss_percentile": 0.44668}, "CVE-2022-0822": {"epss_score": 0.00195, "epss_percentile": 0.41625}, "CVE-2022-0823": {"epss_score": 0.00051, "epss_percentile": 0.16249}, "CVE-2022-0824": {"epss_score": 0.93877, "epss_percentile": 0.99862}, "CVE-2022-0825": {"epss_score": 0.00185, "epss_percentile": 0.40576}, "CVE-2022-0826": {"epss_score": 0.77316, "epss_percentile": 0.98931}, "CVE-2022-0827": {"epss_score": 0.71988, "epss_percentile": 0.98691}, "CVE-2022-0828": {"epss_score": 0.00357, "epss_percentile": 0.57473}, "CVE-2022-0829": {"epss_score": 0.00321, "epss_percentile": 0.54733}, "CVE-2022-0830": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-0831": {"epss_score": 0.00133, "epss_percentile": 0.33623}, "CVE-2022-0832": {"epss_score": 0.00182, "epss_percentile": 0.40235}, "CVE-2022-0833": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2022-0834": {"epss_score": 0.00171, "epss_percentile": 0.38787}, "CVE-2022-0835": {"epss_score": 0.00041, "epss_percentile": 0.12446}, "CVE-2022-0836": {"epss_score": 0.03246, "epss_percentile": 0.86744}, "CVE-2022-0837": {"epss_score": 0.00212, "epss_percentile": 0.43788}, "CVE-2022-0838": {"epss_score": 0.00914, "epss_percentile": 0.75386}, "CVE-2022-0839": {"epss_score": 0.00101, "epss_percentile": 0.28597}, "CVE-2022-0840": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0841": {"epss_score": 0.00461, "epss_percentile": 0.63557}, "CVE-2022-0842": {"epss_score": 0.00156, "epss_percentile": 0.36988}, "CVE-2022-0843": {"epss_score": 0.00369, "epss_percentile": 0.58262}, "CVE-2022-0845": {"epss_score": 0.00272, "epss_percentile": 0.50361}, "CVE-2022-0846": {"epss_score": 0.71133, "epss_percentile": 0.98655}, "CVE-2022-0847": {"epss_score": 0.84135, "epss_percentile": 0.99275}, "CVE-2022-0848": {"epss_score": 0.33882, "epss_percentile": 0.96812}, "CVE-2022-0849": {"epss_score": 0.00265, "epss_percentile": 0.49817}, "CVE-2022-0850": {"epss_score": 0.00015, "epss_percentile": 0.02418}, "CVE-2022-0851": {"epss_score": 0.00118, "epss_percentile": 0.31395}, "CVE-2022-0852": {"epss_score": 0.00154, "epss_percentile": 0.36672}, "CVE-2022-0853": {"epss_score": 0.017, "epss_percentile": 0.81833}, "CVE-2022-0854": {"epss_score": 9e-05, "epss_percentile": 0.007}, "CVE-2022-0855": {"epss_score": 0.00597, "epss_percentile": 0.68736}, "CVE-2022-0856": {"epss_score": 0.049, "epss_percentile": 0.89273}, "CVE-2022-0857": {"epss_score": 0.00206, "epss_percentile": 0.4277}, "CVE-2022-0858": {"epss_score": 0.00216, "epss_percentile": 0.44145}, "CVE-2022-0859": {"epss_score": 0.00036, "epss_percentile": 0.10455}, "CVE-2022-0860": {"epss_score": 0.00745, "epss_percentile": 0.72524}, "CVE-2022-0861": {"epss_score": 0.00155, "epss_percentile": 0.36795}, "CVE-2022-0862": {"epss_score": 0.00285, "epss_percentile": 0.51677}, "CVE-2022-0863": {"epss_score": 0.13293, "epss_percentile": 0.93924}, "CVE-2022-0864": {"epss_score": 0.04513, "epss_percentile": 0.88782}, "CVE-2022-0865": {"epss_score": 0.00091, "epss_percentile": 0.26288}, "CVE-2022-0866": {"epss_score": 0.00272, "epss_percentile": 0.50355}, "CVE-2022-0867": {"epss_score": 0.87685, "epss_percentile": 0.99438}, "CVE-2022-0868": {"epss_score": 0.00326, "epss_percentile": 0.55046}, "CVE-2022-0869": {"epss_score": 0.04224, "epss_percentile": 0.88413}, "CVE-2022-0870": {"epss_score": 0.07241, "epss_percentile": 0.91346}, "CVE-2022-0871": {"epss_score": 0.01001, "epss_percentile": 0.76502}, "CVE-2022-0873": {"epss_score": 0.00859, "epss_percentile": 0.74512}, "CVE-2022-0874": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-0875": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-0876": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0877": {"epss_score": 0.00308, "epss_percentile": 0.53629}, "CVE-2022-0878": {"epss_score": 0.00192, "epss_percentile": 0.41331}, "CVE-2022-0879": {"epss_score": 0.01062, "epss_percentile": 0.77178}, "CVE-2022-0880": {"epss_score": 0.00304, "epss_percentile": 0.5326}, "CVE-2022-0881": {"epss_score": 0.00518, "epss_percentile": 0.66095}, "CVE-2022-0882": {"epss_score": 0.00016, "epss_percentile": 0.02915}, "CVE-2022-0883": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2022-0884": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0885": {"epss_score": 0.87398, "epss_percentile": 0.99427}, "CVE-2022-0887": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2022-0888": {"epss_score": 0.09301, "epss_percentile": 0.9249}, "CVE-2022-0889": {"epss_score": 0.02022, "epss_percentile": 0.83301}, "CVE-2022-0890": {"epss_score": 0.00281, "epss_percentile": 0.51192}, "CVE-2022-0891": {"epss_score": 0.00029, "epss_percentile": 0.07614}, "CVE-2022-0892": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-0893": {"epss_score": 0.00015, "epss_percentile": 0.02172}, "CVE-2022-0894": {"epss_score": 0.0001, "epss_percentile": 0.0087}, "CVE-2022-0895": {"epss_score": 0.01204, "epss_percentile": 0.78504}, "CVE-2022-0896": {"epss_score": 0.01009, "epss_percentile": 0.76583}, "CVE-2022-0897": {"epss_score": 0.00049, "epss_percentile": 0.1561}, "CVE-2022-0898": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2022-0899": {"epss_score": 0.08267, "epss_percentile": 0.91959}, "CVE-2022-0900": {"epss_score": 0.00251, "epss_percentile": 0.48333}, "CVE-2022-0901": {"epss_score": 0.00211, "epss_percentile": 0.43673}, "CVE-2022-0902": {"epss_score": 0.06799, "epss_percentile": 0.91033}, "CVE-2022-0903": {"epss_score": 0.00262, "epss_percentile": 0.49349}, "CVE-2022-0904": {"epss_score": 0.0045, "epss_percentile": 0.63103}, "CVE-2022-0905": {"epss_score": 0.00294, "epss_percentile": 0.52405}, "CVE-2022-0906": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-0907": {"epss_score": 0.00341, "epss_percentile": 0.56323}, "CVE-2022-0908": {"epss_score": 0.00057, "epss_percentile": 0.17989}, "CVE-2022-0909": {"epss_score": 0.00085, "epss_percentile": 0.25061}, "CVE-2022-0910": {"epss_score": 0.00152, "epss_percentile": 0.36377}, "CVE-2022-0911": {"epss_score": 0.00015, "epss_percentile": 0.02172}, "CVE-2022-0912": {"epss_score": 0.00195, "epss_percentile": 0.41685}, "CVE-2022-0913": {"epss_score": 0.00811, "epss_percentile": 0.73724}, "CVE-2022-0914": {"epss_score": 0.00121, "epss_percentile": 0.32014}, "CVE-2022-0915": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2022-0916": {"epss_score": 0.00127, "epss_percentile": 0.32866}, "CVE-2022-0918": {"epss_score": 0.07127, "epss_percentile": 0.91267}, "CVE-2022-0919": {"epss_score": 0.00748, "epss_percentile": 0.72587}, "CVE-2022-0920": {"epss_score": 0.00821, "epss_percentile": 0.739}, "CVE-2022-0921": {"epss_score": 0.04555, "epss_percentile": 0.88844}, "CVE-2022-0922": {"epss_score": 0.00043, "epss_percentile": 0.13284}, "CVE-2022-0923": {"epss_score": 0.00219, "epss_percentile": 0.44442}, "CVE-2022-0924": {"epss_score": 0.00084, "epss_percentile": 0.24894}, "CVE-2022-0926": {"epss_score": 0.00187, "epss_percentile": 0.40776}, "CVE-2022-0928": {"epss_score": 0.04739, "epss_percentile": 0.89076}, "CVE-2022-0929": {"epss_score": 0.00579, "epss_percentile": 0.6823}, "CVE-2022-0930": {"epss_score": 0.00496, "epss_percentile": 0.65167}, "CVE-2022-0932": {"epss_score": 0.0028, "epss_percentile": 0.51088}, "CVE-2022-0934": {"epss_score": 0.00019, "epss_percentile": 0.04065}, "CVE-2022-0935": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2022-0936": {"epss_score": 0.00195, "epss_percentile": 0.41625}, "CVE-2022-0937": {"epss_score": 0.00181, "epss_percentile": 0.40084}, "CVE-2022-0938": {"epss_score": 0.00207, "epss_percentile": 0.43118}, "CVE-2022-0939": {"epss_score": 0.0026, "epss_percentile": 0.49218}, "CVE-2022-0940": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-0941": {"epss_score": 0.00196, "epss_percentile": 0.41742}, "CVE-2022-0942": {"epss_score": 0.00344, "epss_percentile": 0.56497}, "CVE-2022-0943": {"epss_score": 0.00056, "epss_percentile": 0.17695}, "CVE-2022-0944": {"epss_score": 0.73194, "epss_percentile": 0.98741}, "CVE-2022-0945": {"epss_score": 0.0035, "epss_percentile": 0.56962}, "CVE-2022-0946": {"epss_score": 0.00322, "epss_percentile": 0.54816}, "CVE-2022-0947": {"epss_score": 0.00411, "epss_percentile": 0.60901}, "CVE-2022-0948": {"epss_score": 0.6652, "epss_percentile": 0.98466}, "CVE-2022-0949": {"epss_score": 0.69083, "epss_percentile": 0.98576}, "CVE-2022-0950": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-0951": {"epss_score": 0.00343, "epss_percentile": 0.56437}, "CVE-2022-0952": {"epss_score": 0.89187, "epss_percentile": 0.99514}, "CVE-2022-0953": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-0954": {"epss_score": 0.05808, "epss_percentile": 0.90225}, "CVE-2022-0955": {"epss_score": 0.00021, "epss_percentile": 0.04833}, "CVE-2022-0956": {"epss_score": 0.00337, "epss_percentile": 0.56062}, "CVE-2022-0957": {"epss_score": 0.00305, "epss_percentile": 0.53386}, "CVE-2022-0958": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0959": {"epss_score": 0.00386, "epss_percentile": 0.59247}, "CVE-2022-0960": {"epss_score": 0.00388, "epss_percentile": 0.59357}, "CVE-2022-0961": {"epss_score": 0.01843, "epss_percentile": 0.82502}, "CVE-2022-0962": {"epss_score": 0.00384, "epss_percentile": 0.59128}, "CVE-2022-0963": {"epss_score": 0.0815, "epss_percentile": 0.91904}, "CVE-2022-0964": {"epss_score": 0.00384, "epss_percentile": 0.59128}, "CVE-2022-0965": {"epss_score": 0.00384, "epss_percentile": 0.59128}, "CVE-2022-0966": {"epss_score": 0.00223, "epss_percentile": 0.44888}, "CVE-2022-0967": {"epss_score": 0.00831, "epss_percentile": 0.74054}, "CVE-2022-0968": {"epss_score": 0.01425, "epss_percentile": 0.80195}, "CVE-2022-0969": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2022-0970": {"epss_score": 0.00384, "epss_percentile": 0.59128}, "CVE-2022-0971": {"epss_score": 0.00582, "epss_percentile": 0.68288}, "CVE-2022-0972": {"epss_score": 0.00196, "epss_percentile": 0.41757}, "CVE-2022-0973": {"epss_score": 0.00786, "epss_percentile": 0.73297}, "CVE-2022-0974": {"epss_score": 0.00839, "epss_percentile": 0.74188}, "CVE-2022-0975": {"epss_score": 0.00703, "epss_percentile": 0.71527}, "CVE-2022-0976": {"epss_score": 0.00509, "epss_percentile": 0.65735}, "CVE-2022-0977": {"epss_score": 0.00758, "epss_percentile": 0.72775}, "CVE-2022-0978": {"epss_score": 0.00786, "epss_percentile": 0.73297}, "CVE-2022-0979": {"epss_score": 0.00658, "epss_percentile": 0.70497}, "CVE-2022-0980": {"epss_score": 0.00295, "epss_percentile": 0.5248}, "CVE-2022-0981": {"epss_score": 0.00241, "epss_percentile": 0.47253}, "CVE-2022-0982": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2022-0983": {"epss_score": 0.00308, "epss_percentile": 0.53623}, "CVE-2022-0984": {"epss_score": 0.00259, "epss_percentile": 0.49065}, "CVE-2022-0985": {"epss_score": 0.00259, "epss_percentile": 0.49065}, "CVE-2022-0986": {"epss_score": 0.00333, "epss_percentile": 0.55622}, "CVE-2022-0987": {"epss_score": 0.00041, "epss_percentile": 0.12372}, "CVE-2022-0988": {"epss_score": 0.00135, "epss_percentile": 0.34003}, "CVE-2022-0989": {"epss_score": 0.00284, "epss_percentile": 0.51439}, "CVE-2022-0990": {"epss_score": 0.00288, "epss_percentile": 0.51938}, "CVE-2022-0991": {"epss_score": 0.00237, "epss_percentile": 0.46644}, "CVE-2022-0992": {"epss_score": 0.04367, "epss_percentile": 0.88604}, "CVE-2022-0993": {"epss_score": 0.03267, "epss_percentile": 0.86785}, "CVE-2022-0994": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-0995": {"epss_score": 0.20504, "epss_percentile": 0.95357}, "CVE-2022-0996": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2022-0997": {"epss_score": 0.00531, "epss_percentile": 0.66653}, "CVE-2022-0998": {"epss_score": 0.00167, "epss_percentile": 0.38323}, "CVE-2022-0999": {"epss_score": 0.00287, "epss_percentile": 0.518}, "CVE-2022-1000": {"epss_score": 0.00353, "epss_percentile": 0.57199}, "CVE-2022-1001": {"epss_score": 0.00462, "epss_percentile": 0.63579}, "CVE-2022-1002": {"epss_score": 0.00342, "epss_percentile": 0.56348}, "CVE-2022-1003": {"epss_score": 0.00131, "epss_percentile": 0.33378}, "CVE-2022-1004": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2022-1005": {"epss_score": 0.00335, "epss_percentile": 0.55796}, "CVE-2022-1006": {"epss_score": 0.0062, "epss_percentile": 0.6945}, "CVE-2022-1007": {"epss_score": 0.03683, "epss_percentile": 0.87562}, "CVE-2022-1008": {"epss_score": 0.01214, "epss_percentile": 0.78571}, "CVE-2022-1009": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2022-1010": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2022-1011": {"epss_score": 0.00201, "epss_percentile": 0.42385}, "CVE-2022-1012": {"epss_score": 0.0032, "epss_percentile": 0.54612}, "CVE-2022-1013": {"epss_score": 0.83084, "epss_percentile": 0.99231}, "CVE-2022-1014": {"epss_score": 0.00954, "epss_percentile": 0.75902}, "CVE-2022-1015": {"epss_score": 0.01481, "epss_percentile": 0.80572}, "CVE-2022-1016": {"epss_score": 0.00013, "epss_percentile": 0.01572}, "CVE-2022-1018": {"epss_score": 0.09136, "epss_percentile": 0.92416}, "CVE-2022-1019": {"epss_score": 0.00258, "epss_percentile": 0.49007}, "CVE-2022-1020": {"epss_score": 0.92138, "epss_percentile": 0.99693}, "CVE-2022-1021": {"epss_score": 0.0025, "epss_percentile": 0.48207}, "CVE-2022-1022": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2022-1023": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2022-1025": {"epss_score": 0.0032, "epss_percentile": 0.54618}, "CVE-2022-1026": {"epss_score": 0.86782, "epss_percentile": 0.99396}, "CVE-2022-1027": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1028": {"epss_score": 0.00287, "epss_percentile": 0.51837}, "CVE-2022-1029": {"epss_score": 0.00197, "epss_percentile": 0.41838}, "CVE-2022-1030": {"epss_score": 0.00415, "epss_percentile": 0.6114}, "CVE-2022-1031": {"epss_score": 0.00273, "epss_percentile": 0.50457}, "CVE-2022-1032": {"epss_score": 0.00468, "epss_percentile": 0.63908}, "CVE-2022-1033": {"epss_score": 0.00259, "epss_percentile": 0.49085}, "CVE-2022-1034": {"epss_score": 0.00487, "epss_percentile": 0.64825}, "CVE-2022-1035": {"epss_score": 0.00062, "epss_percentile": 0.1967}, "CVE-2022-1036": {"epss_score": 0.00739, "epss_percentile": 0.72391}, "CVE-2022-1037": {"epss_score": 0.00723, "epss_percentile": 0.72011}, "CVE-2022-1038": {"epss_score": 0.00029, "epss_percentile": 0.07815}, "CVE-2022-1039": {"epss_score": 0.00219, "epss_percentile": 0.44482}, "CVE-2022-1040": {"epss_score": 0.94439, "epss_percentile": 0.99987}, "CVE-2022-1041": {"epss_score": 0.00112, "epss_percentile": 0.30447}, "CVE-2022-1042": {"epss_score": 0.00112, "epss_percentile": 0.30447}, "CVE-2022-1043": {"epss_score": 0.10236, "epss_percentile": 0.92906}, "CVE-2022-1044": {"epss_score": 0.00317, "epss_percentile": 0.54369}, "CVE-2022-1045": {"epss_score": 0.00317, "epss_percentile": 0.54369}, "CVE-2022-1046": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1047": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1048": {"epss_score": 0.00013, "epss_percentile": 0.01659}, "CVE-2022-1049": {"epss_score": 0.00309, "epss_percentile": 0.53689}, "CVE-2022-1050": {"epss_score": 0.00029, "epss_percentile": 0.07739}, "CVE-2022-1051": {"epss_score": 0.10291, "epss_percentile": 0.92931}, "CVE-2022-1052": {"epss_score": 0.0015, "epss_percentile": 0.36134}, "CVE-2022-1053": {"epss_score": 0.0047, "epss_percentile": 0.6398}, "CVE-2022-1054": {"epss_score": 0.12369, "epss_percentile": 0.93652}, "CVE-2022-1055": {"epss_score": 0.00025, "epss_percentile": 0.0637}, "CVE-2022-1056": {"epss_score": 0.00047, "epss_percentile": 0.14658}, "CVE-2022-1057": {"epss_score": 0.58137, "epss_percentile": 0.981}, "CVE-2022-1058": {"epss_score": 0.23672, "epss_percentile": 0.95801}, "CVE-2022-1059": {"epss_score": 0.0088, "epss_percentile": 0.74857}, "CVE-2022-1061": {"epss_score": 0.0027, "epss_percentile": 0.50252}, "CVE-2022-1062": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1063": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2022-1064": {"epss_score": 0.00297, "epss_percentile": 0.52741}, "CVE-2022-1065": {"epss_score": 0.01634, "epss_percentile": 0.81467}, "CVE-2022-1066": {"epss_score": 0.0048, "epss_percentile": 0.64454}, "CVE-2022-1067": {"epss_score": 0.00149, "epss_percentile": 0.35935}, "CVE-2022-1068": {"epss_score": 0.00185, "epss_percentile": 0.4055}, "CVE-2022-1069": {"epss_score": 0.00994, "epss_percentile": 0.76423}, "CVE-2022-1070": {"epss_score": 0.00458, "epss_percentile": 0.63436}, "CVE-2022-1071": {"epss_score": 0.00321, "epss_percentile": 0.5469}, "CVE-2022-1073": {"epss_score": 0.00346, "epss_percentile": 0.56653}, "CVE-2022-1074": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-1075": {"epss_score": 0.00185, "epss_percentile": 0.40472}, "CVE-2022-1076": {"epss_score": 0.00202, "epss_percentile": 0.42442}, "CVE-2022-1077": {"epss_score": 0.03176, "epss_percentile": 0.8657}, "CVE-2022-1078": {"epss_score": 0.00334, "epss_percentile": 0.55738}, "CVE-2022-1079": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-1080": {"epss_score": 0.00251, "epss_percentile": 0.48331}, "CVE-2022-1081": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1082": {"epss_score": 0.00383, "epss_percentile": 0.59103}, "CVE-2022-1083": {"epss_score": 0.00383, "epss_percentile": 0.59103}, "CVE-2022-1084": {"epss_score": 0.00365, "epss_percentile": 0.58013}, "CVE-2022-1085": {"epss_score": 0.00192, "epss_percentile": 0.41278}, "CVE-2022-1086": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-1087": {"epss_score": 0.00316, "epss_percentile": 0.54284}, "CVE-2022-1088": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1089": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1090": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1091": {"epss_score": 0.00468, "epss_percentile": 0.6388}, "CVE-2022-1092": {"epss_score": 0.00099, "epss_percentile": 0.28376}, "CVE-2022-1093": {"epss_score": 0.002, "epss_percentile": 0.42223}, "CVE-2022-1094": {"epss_score": 0.00203, "epss_percentile": 0.42578}, "CVE-2022-1095": {"epss_score": 0.00308, "epss_percentile": 0.53628}, "CVE-2022-1096": {"epss_score": 0.40164, "epss_percentile": 0.97204}, "CVE-2022-1097": {"epss_score": 0.00212, "epss_percentile": 0.43726}, "CVE-2022-1098": {"epss_score": 0.00044, "epss_percentile": 0.13623}, "CVE-2022-1099": {"epss_score": 0.00166, "epss_percentile": 0.38254}, "CVE-2022-1100": {"epss_score": 0.00166, "epss_percentile": 0.38254}, "CVE-2022-1101": {"epss_score": 0.0023, "epss_percentile": 0.45679}, "CVE-2022-1102": {"epss_score": 0.00116, "epss_percentile": 0.31179}, "CVE-2022-1103": {"epss_score": 0.1664, "epss_percentile": 0.94705}, "CVE-2022-1104": {"epss_score": 0.135, "epss_percentile": 0.93981}, "CVE-2022-1105": {"epss_score": 0.002, "epss_percentile": 0.42253}, "CVE-2022-1106": {"epss_score": 0.00196, "epss_percentile": 0.41815}, "CVE-2022-1107": {"epss_score": 0.00032, "epss_percentile": 0.09093}, "CVE-2022-1108": {"epss_score": 0.00029, "epss_percentile": 0.07698}, "CVE-2022-1109": {"epss_score": 0.00087, "epss_percentile": 0.25525}, "CVE-2022-1110": {"epss_score": 0.00042, "epss_percentile": 0.12704}, "CVE-2022-1111": {"epss_score": 0.00249, "epss_percentile": 0.48026}, "CVE-2022-1112": {"epss_score": 0.00085, "epss_percentile": 0.25028}, "CVE-2022-1113": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1114": {"epss_score": 0.00076, "epss_percentile": 0.23182}, "CVE-2022-1115": {"epss_score": 0.00037, "epss_percentile": 0.10866}, "CVE-2022-1116": {"epss_score": 0.00139, "epss_percentile": 0.34553}, "CVE-2022-1117": {"epss_score": 0.0004, "epss_percentile": 0.11926}, "CVE-2022-1118": {"epss_score": 0.51482, "epss_percentile": 0.97781}, "CVE-2022-1119": {"epss_score": 0.90562, "epss_percentile": 0.99589}, "CVE-2022-1120": {"epss_score": 0.00241, "epss_percentile": 0.47267}, "CVE-2022-1121": {"epss_score": 0.00181, "epss_percentile": 0.40109}, "CVE-2022-1122": {"epss_score": 0.00052, "epss_percentile": 0.16619}, "CVE-2022-1123": {"epss_score": 0.00746, "epss_percentile": 0.72547}, "CVE-2022-1124": {"epss_score": 0.00245, "epss_percentile": 0.47665}, "CVE-2022-1125": {"epss_score": 0.00812, "epss_percentile": 0.73742}, "CVE-2022-1127": {"epss_score": 0.00556, "epss_percentile": 0.67532}, "CVE-2022-1128": {"epss_score": 0.00394, "epss_percentile": 0.59749}, "CVE-2022-1129": {"epss_score": 0.00182, "epss_percentile": 0.4015}, "CVE-2022-1130": {"epss_score": 0.00514, "epss_percentile": 0.65961}, "CVE-2022-1131": {"epss_score": 0.00594, "epss_percentile": 0.68656}, "CVE-2022-1132": {"epss_score": 0.00046, "epss_percentile": 0.14269}, "CVE-2022-1133": {"epss_score": 0.00533, "epss_percentile": 0.66767}, "CVE-2022-1134": {"epss_score": 0.01872, "epss_percentile": 0.82639}, "CVE-2022-1135": {"epss_score": 0.00642, "epss_percentile": 0.70031}, "CVE-2022-1136": {"epss_score": 0.00269, "epss_percentile": 0.50165}, "CVE-2022-1137": {"epss_score": 0.00187, "epss_percentile": 0.40729}, "CVE-2022-1138": {"epss_score": 0.00264, "epss_percentile": 0.49568}, "CVE-2022-1139": {"epss_score": 0.00227, "epss_percentile": 0.45453}, "CVE-2022-1141": {"epss_score": 0.00755, "epss_percentile": 0.7271}, "CVE-2022-1142": {"epss_score": 0.00785, "epss_percentile": 0.73247}, "CVE-2022-1143": {"epss_score": 0.00564, "epss_percentile": 0.67745}, "CVE-2022-1144": {"epss_score": 0.00856, "epss_percentile": 0.74482}, "CVE-2022-1145": {"epss_score": 0.00249, "epss_percentile": 0.48026}, "CVE-2022-1146": {"epss_score": 0.00227, "epss_percentile": 0.45453}, "CVE-2022-1148": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2022-1152": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2022-1153": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2022-1154": {"epss_score": 0.00597, "epss_percentile": 0.6874}, "CVE-2022-1155": {"epss_score": 0.00254, "epss_percentile": 0.48515}, "CVE-2022-1156": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1157": {"epss_score": 0.00214, "epss_percentile": 0.43954}, "CVE-2022-1158": {"epss_score": 0.00015, "epss_percentile": 0.02463}, "CVE-2022-1159": {"epss_score": 0.00031, "epss_percentile": 0.08394}, "CVE-2022-1160": {"epss_score": 0.00137, "epss_percentile": 0.34268}, "CVE-2022-1161": {"epss_score": 0.00119, "epss_percentile": 0.31564}, "CVE-2022-1162": {"epss_score": 0.88627, "epss_percentile": 0.99481}, "CVE-2022-1163": {"epss_score": 0.00626, "epss_percentile": 0.69601}, "CVE-2022-1164": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1165": {"epss_score": 0.00346, "epss_percentile": 0.56704}, "CVE-2022-1166": {"epss_score": 0.00343, "epss_percentile": 0.56456}, "CVE-2022-1167": {"epss_score": 0.00368, "epss_percentile": 0.58183}, "CVE-2022-1168": {"epss_score": 0.03356, "epss_percentile": 0.86973}, "CVE-2022-1169": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2022-1170": {"epss_score": 0.00931, "epss_percentile": 0.75607}, "CVE-2022-1171": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1172": {"epss_score": 0.00301, "epss_percentile": 0.53075}, "CVE-2022-1173": {"epss_score": 0.00352, "epss_percentile": 0.57134}, "CVE-2022-1174": {"epss_score": 0.00442, "epss_percentile": 0.62743}, "CVE-2022-1175": {"epss_score": 0.10323, "epss_percentile": 0.92944}, "CVE-2022-1176": {"epss_score": 0.00289, "epss_percentile": 0.52043}, "CVE-2022-1177": {"epss_score": 0.03305, "epss_percentile": 0.86871}, "CVE-2022-1178": {"epss_score": 0.13658, "epss_percentile": 0.94028}, "CVE-2022-1179": {"epss_score": 0.30561, "epss_percentile": 0.96552}, "CVE-2022-1180": {"epss_score": 0.18525, "epss_percentile": 0.95028}, "CVE-2022-1181": {"epss_score": 0.15808, "epss_percentile": 0.94512}, "CVE-2022-1182": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2022-1183": {"epss_score": 0.00314, "epss_percentile": 0.54078}, "CVE-2022-1184": {"epss_score": 0.00028, "epss_percentile": 0.07538}, "CVE-2022-1185": {"epss_score": 0.00365, "epss_percentile": 0.57961}, "CVE-2022-1186": {"epss_score": 0.00678, "epss_percentile": 0.70972}, "CVE-2022-1187": {"epss_score": 0.03226, "epss_percentile": 0.86686}, "CVE-2022-1188": {"epss_score": 0.00325, "epss_percentile": 0.55003}, "CVE-2022-1189": {"epss_score": 0.00219, "epss_percentile": 0.44482}, "CVE-2022-1190": {"epss_score": 0.01651, "epss_percentile": 0.81567}, "CVE-2022-1191": {"epss_score": 0.00191, "epss_percentile": 0.41164}, "CVE-2022-1192": {"epss_score": 0.00401, "epss_percentile": 0.60208}, "CVE-2022-1193": {"epss_score": 0.00139, "epss_percentile": 0.34562}, "CVE-2022-1194": {"epss_score": 0.01134, "epss_percentile": 0.77889}, "CVE-2022-1195": {"epss_score": 0.00016, "epss_percentile": 0.02644}, "CVE-2022-1196": {"epss_score": 0.00163, "epss_percentile": 0.37769}, "CVE-2022-1197": {"epss_score": 0.00239, "epss_percentile": 0.46917}, "CVE-2022-1198": {"epss_score": 0.00018, "epss_percentile": 0.03616}, "CVE-2022-1199": {"epss_score": 0.00083, "epss_percentile": 0.24748}, "CVE-2022-1201": {"epss_score": 0.00143, "epss_percentile": 0.35098}, "CVE-2022-1202": {"epss_score": 0.00307, "epss_percentile": 0.53491}, "CVE-2022-1203": {"epss_score": 0.04467, "epss_percentile": 0.88731}, "CVE-2022-1204": {"epss_score": 0.00082, "epss_percentile": 0.24567}, "CVE-2022-1205": {"epss_score": 0.00018, "epss_percentile": 0.03672}, "CVE-2022-1206": {"epss_score": 0.05748, "epss_percentile": 0.90176}, "CVE-2022-1207": {"epss_score": 0.0017, "epss_percentile": 0.38649}, "CVE-2022-1208": {"epss_score": 0.00282, "epss_percentile": 0.51228}, "CVE-2022-1209": {"epss_score": 0.00334, "epss_percentile": 0.55713}, "CVE-2022-1210": {"epss_score": 0.0005, "epss_percentile": 0.15727}, "CVE-2022-1211": {"epss_score": 0.00312, "epss_percentile": 0.53996}, "CVE-2022-1212": {"epss_score": 0.00332, "epss_percentile": 0.55559}, "CVE-2022-1213": {"epss_score": 0.00133, "epss_percentile": 0.33725}, "CVE-2022-1215": {"epss_score": 0.00043, "epss_percentile": 0.1306}, "CVE-2022-1216": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1217": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1218": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-1219": {"epss_score": 0.00184, "epss_percentile": 0.40457}, "CVE-2022-1220": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1221": {"epss_score": 0.25555, "epss_percentile": 0.96041}, "CVE-2022-1222": {"epss_score": 0.00064, "epss_percentile": 0.2033}, "CVE-2022-1223": {"epss_score": 0.0029, "epss_percentile": 0.52109}, "CVE-2022-1224": {"epss_score": 0.00226, "epss_percentile": 0.45313}, "CVE-2022-1225": {"epss_score": 0.00226, "epss_percentile": 0.45313}, "CVE-2022-1226": {"epss_score": 0.0013, "epss_percentile": 0.3323}, "CVE-2022-1227": {"epss_score": 0.32062, "epss_percentile": 0.9667}, "CVE-2022-1228": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1229": {"epss_score": 0.01878, "epss_percentile": 0.82667}, "CVE-2022-1230": {"epss_score": 0.0007, "epss_percentile": 0.2187}, "CVE-2022-1231": {"epss_score": 0.00199, "epss_percentile": 0.42097}, "CVE-2022-1232": {"epss_score": 0.04215, "epss_percentile": 0.88406}, "CVE-2022-1233": {"epss_score": 0.00183, "epss_percentile": 0.40345}, "CVE-2022-1234": {"epss_score": 0.00128, "epss_percentile": 0.33055}, "CVE-2022-1235": {"epss_score": 0.00096, "epss_percentile": 0.27401}, "CVE-2022-1236": {"epss_score": 0.00137, "epss_percentile": 0.34236}, "CVE-2022-1237": {"epss_score": 0.00258, "epss_percentile": 0.48951}, "CVE-2022-1238": {"epss_score": 0.00269, "epss_percentile": 0.50173}, "CVE-2022-1239": {"epss_score": 0.00554, "epss_percentile": 0.6745}, "CVE-2022-1240": {"epss_score": 0.0024, "epss_percentile": 0.46945}, "CVE-2022-1241": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1242": {"epss_score": 0.0005, "epss_percentile": 0.15888}, "CVE-2022-1243": {"epss_score": 0.00333, "epss_percentile": 0.55677}, "CVE-2022-1244": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2022-1245": {"epss_score": 0.00418, "epss_percentile": 0.61269}, "CVE-2022-1247": {"epss_score": 0.00018, "epss_percentile": 0.04018}, "CVE-2022-1248": {"epss_score": 0.0048, "epss_percentile": 0.6447}, "CVE-2022-1249": {"epss_score": 0.0014, "epss_percentile": 0.34699}, "CVE-2022-1250": {"epss_score": 0.01778, "epss_percentile": 0.82226}, "CVE-2022-1251": {"epss_score": 0.0012, "epss_percentile": 0.31809}, "CVE-2022-1252": {"epss_score": 0.00199, "epss_percentile": 0.42174}, "CVE-2022-1253": {"epss_score": 0.00499, "epss_percentile": 0.65261}, "CVE-2022-1254": {"epss_score": 0.0019, "epss_percentile": 0.41103}, "CVE-2022-1255": {"epss_score": 0.00203, "epss_percentile": 0.42578}, "CVE-2022-1256": {"epss_score": 0.00106, "epss_percentile": 0.2948}, "CVE-2022-1257": {"epss_score": 0.00179, "epss_percentile": 0.39847}, "CVE-2022-1258": {"epss_score": 0.00201, "epss_percentile": 0.42279}, "CVE-2022-1259": {"epss_score": 0.00255, "epss_percentile": 0.48651}, "CVE-2022-1261": {"epss_score": 0.00153, "epss_percentile": 0.36571}, "CVE-2022-1262": {"epss_score": 0.00616, "epss_percentile": 0.69324}, "CVE-2022-1263": {"epss_score": 0.00068, "epss_percentile": 0.21269}, "CVE-2022-1264": {"epss_score": 0.00376, "epss_percentile": 0.58652}, "CVE-2022-1265": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-1266": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-1267": {"epss_score": 0.00216, "epss_percentile": 0.44184}, "CVE-2022-1268": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-1269": {"epss_score": 0.00345, "epss_percentile": 0.56555}, "CVE-2022-1270": {"epss_score": 0.00045, "epss_percentile": 0.13949}, "CVE-2022-1271": {"epss_score": 0.00763, "epss_percentile": 0.72856}, "CVE-2022-1273": {"epss_score": 0.00875, "epss_percentile": 0.74777}, "CVE-2022-1274": {"epss_score": 0.00676, "epss_percentile": 0.70943}, "CVE-2022-1275": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1276": {"epss_score": 0.00839, "epss_percentile": 0.74191}, "CVE-2022-1277": {"epss_score": 0.00297, "epss_percentile": 0.52753}, "CVE-2022-1278": {"epss_score": 0.00883, "epss_percentile": 0.74916}, "CVE-2022-1279": {"epss_score": 0.00079, "epss_percentile": 0.23981}, "CVE-2022-1280": {"epss_score": 0.00021, "epss_percentile": 0.04896}, "CVE-2022-1281": {"epss_score": 0.06008, "epss_percentile": 0.90401}, "CVE-2022-1282": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1283": {"epss_score": 0.00273, "epss_percentile": 0.50438}, "CVE-2022-1284": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2022-1285": {"epss_score": 0.00628, "epss_percentile": 0.69651}, "CVE-2022-1286": {"epss_score": 0.00586, "epss_percentile": 0.68448}, "CVE-2022-1287": {"epss_score": 0.00342, "epss_percentile": 0.56401}, "CVE-2022-1288": {"epss_score": 0.00215, "epss_percentile": 0.4411}, "CVE-2022-1289": {"epss_score": 0.00312, "epss_percentile": 0.54003}, "CVE-2022-1290": {"epss_score": 0.00355, "epss_percentile": 0.57275}, "CVE-2022-1291": {"epss_score": 0.00204, "epss_percentile": 0.42611}, "CVE-2022-1292": {"epss_score": 0.41209, "epss_percentile": 0.97259}, "CVE-2022-1293": {"epss_score": 0.00282, "epss_percentile": 0.51236}, "CVE-2022-1294": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1295": {"epss_score": 0.00579, "epss_percentile": 0.68233}, "CVE-2022-1296": {"epss_score": 0.00283, "epss_percentile": 0.51356}, "CVE-2022-1297": {"epss_score": 0.00297, "epss_percentile": 0.52683}, "CVE-2022-1298": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1299": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1300": {"epss_score": 0.00571, "epss_percentile": 0.67993}, "CVE-2022-1301": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1302": {"epss_score": 0.0098, "epss_percentile": 0.76265}, "CVE-2022-1303": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1304": {"epss_score": 0.0049, "epss_percentile": 0.64935}, "CVE-2022-1305": {"epss_score": 0.00553, "epss_percentile": 0.67405}, "CVE-2022-1306": {"epss_score": 0.00159, "epss_percentile": 0.37304}, "CVE-2022-1307": {"epss_score": 0.00306, "epss_percentile": 0.53457}, "CVE-2022-1308": {"epss_score": 0.00583, "epss_percentile": 0.68332}, "CVE-2022-1309": {"epss_score": 0.0054, "epss_percentile": 0.67011}, "CVE-2022-1310": {"epss_score": 0.01428, "epss_percentile": 0.80217}, "CVE-2022-1311": {"epss_score": 0.00755, "epss_percentile": 0.7271}, "CVE-2022-1312": {"epss_score": 0.00233, "epss_percentile": 0.46036}, "CVE-2022-1313": {"epss_score": 0.00812, "epss_percentile": 0.73742}, "CVE-2022-1314": {"epss_score": 0.00807, "epss_percentile": 0.73668}, "CVE-2022-1316": {"epss_score": 0.00113, "epss_percentile": 0.30698}, "CVE-2022-1318": {"epss_score": 0.00014, "epss_percentile": 0.01991}, "CVE-2022-1319": {"epss_score": 0.00293, "epss_percentile": 0.5234}, "CVE-2022-1320": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-1321": {"epss_score": 0.00393, "epss_percentile": 0.59721}, "CVE-2022-1322": {"epss_score": 0.00298, "epss_percentile": 0.52815}, "CVE-2022-1323": {"epss_score": 0.00302, "epss_percentile": 0.53164}, "CVE-2022-1324": {"epss_score": 0.00298, "epss_percentile": 0.52815}, "CVE-2022-1325": {"epss_score": 0.00078, "epss_percentile": 0.23596}, "CVE-2022-1326": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-1327": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1328": {"epss_score": 0.00204, "epss_percentile": 0.42611}, "CVE-2022-1329": {"epss_score": 0.93475, "epss_percentile": 0.9981}, "CVE-2022-1330": {"epss_score": 0.00342, "epss_percentile": 0.56372}, "CVE-2022-1331": {"epss_score": 0.00127, "epss_percentile": 0.32896}, "CVE-2022-1332": {"epss_score": 0.00129, "epss_percentile": 0.33135}, "CVE-2022-1333": {"epss_score": 0.00363, "epss_percentile": 0.57898}, "CVE-2022-1334": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2022-1335": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1336": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1337": {"epss_score": 0.00427, "epss_percentile": 0.6189}, "CVE-2022-1338": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1339": {"epss_score": 0.00049, "epss_percentile": 0.15548}, "CVE-2022-1340": {"epss_score": 0.00158, "epss_percentile": 0.37142}, "CVE-2022-1341": {"epss_score": 0.00469, "epss_percentile": 0.63943}, "CVE-2022-1342": {"epss_score": 0.0006, "epss_percentile": 0.18955}, "CVE-2022-1343": {"epss_score": 0.00145, "epss_percentile": 0.35369}, "CVE-2022-1344": {"epss_score": 0.00373, "epss_percentile": 0.58518}, "CVE-2022-1345": {"epss_score": 0.00334, "epss_percentile": 0.55693}, "CVE-2022-1346": {"epss_score": 0.00373, "epss_percentile": 0.58518}, "CVE-2022-1347": {"epss_score": 0.00462, "epss_percentile": 0.63578}, "CVE-2022-1348": {"epss_score": 0.0011, "epss_percentile": 0.30169}, "CVE-2022-1349": {"epss_score": 0.00204, "epss_percentile": 0.42631}, "CVE-2022-1350": {"epss_score": 0.00305, "epss_percentile": 0.53393}, "CVE-2022-1351": {"epss_score": 0.00025, "epss_percentile": 0.06149}, "CVE-2022-1352": {"epss_score": 0.00209, "epss_percentile": 0.43407}, "CVE-2022-1353": {"epss_score": 0.00017, "epss_percentile": 0.03093}, "CVE-2022-1354": {"epss_score": 0.00036, "epss_percentile": 0.10555}, "CVE-2022-1355": {"epss_score": 0.00047, "epss_percentile": 0.14479}, "CVE-2022-1356": {"epss_score": 0.00104, "epss_percentile": 0.29226}, "CVE-2022-1357": {"epss_score": 0.01752, "epss_percentile": 0.82108}, "CVE-2022-1358": {"epss_score": 0.00188, "epss_percentile": 0.40831}, "CVE-2022-1359": {"epss_score": 0.00293, "epss_percentile": 0.52351}, "CVE-2022-1360": {"epss_score": 0.0124, "epss_percentile": 0.78813}, "CVE-2022-1361": {"epss_score": 0.00205, "epss_percentile": 0.42718}, "CVE-2022-1362": {"epss_score": 0.00096, "epss_percentile": 0.27291}, "CVE-2022-1364": {"epss_score": 0.11693, "epss_percentile": 0.93451}, "CVE-2022-1365": {"epss_score": 0.00311, "epss_percentile": 0.53852}, "CVE-2022-1366": {"epss_score": 0.00267, "epss_percentile": 0.50015}, "CVE-2022-1367": {"epss_score": 0.00448, "epss_percentile": 0.6303}, "CVE-2022-1368": {"epss_score": 0.00245, "epss_percentile": 0.47704}, "CVE-2022-1369": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-1370": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-1371": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-1372": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-1373": {"epss_score": 0.68585, "epss_percentile": 0.98555}, "CVE-2022-1374": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-1375": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-1376": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-1377": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-1378": {"epss_score": 0.00267, "epss_percentile": 0.50015}, "CVE-2022-1379": {"epss_score": 0.0028, "epss_percentile": 0.51086}, "CVE-2022-1380": {"epss_score": 0.00249, "epss_percentile": 0.48042}, "CVE-2022-1381": {"epss_score": 0.00062, "epss_percentile": 0.19754}, "CVE-2022-1382": {"epss_score": 0.00249, "epss_percentile": 0.48081}, "CVE-2022-1383": {"epss_score": 0.00242, "epss_percentile": 0.47367}, "CVE-2022-1384": {"epss_score": 0.00326, "epss_percentile": 0.55068}, "CVE-2022-1385": {"epss_score": 0.00168, "epss_percentile": 0.385}, "CVE-2022-1386": {"epss_score": 0.9361, "epss_percentile": 0.99823}, "CVE-2022-1387": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-1388": {"epss_score": 0.94456, "epss_percentile": 0.99992}, "CVE-2022-1389": {"epss_score": 0.00085, "epss_percentile": 0.25131}, "CVE-2022-1390": {"epss_score": 0.92036, "epss_percentile": 0.99687}, "CVE-2022-1391": {"epss_score": 0.66822, "epss_percentile": 0.9848}, "CVE-2022-1392": {"epss_score": 0.65164, "epss_percentile": 0.98405}, "CVE-2022-1393": {"epss_score": 0.00208, "epss_percentile": 0.43277}, "CVE-2022-1394": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1395": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1396": {"epss_score": 0.02402, "epss_percentile": 0.84642}, "CVE-2022-1397": {"epss_score": 0.00221, "epss_percentile": 0.44695}, "CVE-2022-1398": {"epss_score": 0.48896, "epss_percentile": 0.97658}, "CVE-2022-1399": {"epss_score": 0.00447, "epss_percentile": 0.62949}, "CVE-2022-1400": {"epss_score": 0.00361, "epss_percentile": 0.57709}, "CVE-2022-1401": {"epss_score": 0.0504, "epss_percentile": 0.89425}, "CVE-2022-1402": {"epss_score": 0.00159, "epss_percentile": 0.37394}, "CVE-2022-1403": {"epss_score": 0.00159, "epss_percentile": 0.37394}, "CVE-2022-1404": {"epss_score": 0.00062, "epss_percentile": 0.1969}, "CVE-2022-1405": {"epss_score": 0.00403, "epss_percentile": 0.60379}, "CVE-2022-1406": {"epss_score": 0.00215, "epss_percentile": 0.44056}, "CVE-2022-1407": {"epss_score": 0.00142, "epss_percentile": 0.34966}, "CVE-2022-1408": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-1409": {"epss_score": 0.00907, "epss_percentile": 0.75271}, "CVE-2022-1410": {"epss_score": 0.01345, "epss_percentile": 0.79621}, "CVE-2022-1411": {"epss_score": 0.00306, "epss_percentile": 0.53408}, "CVE-2022-1412": {"epss_score": 0.00571, "epss_percentile": 0.67981}, "CVE-2022-1413": {"epss_score": 0.00209, "epss_percentile": 0.43396}, "CVE-2022-1414": {"epss_score": 0.00513, "epss_percentile": 0.65928}, "CVE-2022-1415": {"epss_score": 0.00632, "epss_percentile": 0.69753}, "CVE-2022-1416": {"epss_score": 0.00153, "epss_percentile": 0.36545}, "CVE-2022-1417": {"epss_score": 0.00281, "epss_percentile": 0.51182}, "CVE-2022-1418": {"epss_score": 0.00099, "epss_percentile": 0.27841}, "CVE-2022-1419": {"epss_score": 0.00021, "epss_percentile": 0.04766}, "CVE-2022-1420": {"epss_score": 0.0005, "epss_percentile": 0.15837}, "CVE-2022-1421": {"epss_score": 0.07615, "epss_percentile": 0.91569}, "CVE-2022-1422": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1423": {"epss_score": 0.001, "epss_percentile": 0.2849}, "CVE-2022-1424": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2022-1425": {"epss_score": 0.00186, "epss_percentile": 0.40687}, "CVE-2022-1426": {"epss_score": 0.00201, "epss_percentile": 0.42347}, "CVE-2022-1427": {"epss_score": 0.0024, "epss_percentile": 0.46943}, "CVE-2022-1428": {"epss_score": 0.00139, "epss_percentile": 0.34631}, "CVE-2022-1429": {"epss_score": 0.00232, "epss_percentile": 0.45912}, "CVE-2022-1430": {"epss_score": 0.00444, "epss_percentile": 0.62805}, "CVE-2022-1431": {"epss_score": 0.00329, "epss_percentile": 0.55392}, "CVE-2022-1432": {"epss_score": 0.00435, "epss_percentile": 0.62347}, "CVE-2022-1433": {"epss_score": 0.00226, "epss_percentile": 0.45278}, "CVE-2022-1434": {"epss_score": 0.00067, "epss_percentile": 0.21058}, "CVE-2022-1435": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2022-1436": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1437": {"epss_score": 0.00251, "epss_percentile": 0.48275}, "CVE-2022-1438": {"epss_score": 0.00152, "epss_percentile": 0.36392}, "CVE-2022-1439": {"epss_score": 0.40599, "epss_percentile": 0.97224}, "CVE-2022-1440": {"epss_score": 0.09406, "epss_percentile": 0.92533}, "CVE-2022-1441": {"epss_score": 0.00142, "epss_percentile": 0.35014}, "CVE-2022-1442": {"epss_score": 0.84588, "epss_percentile": 0.99295}, "CVE-2022-1444": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2022-1445": {"epss_score": 0.0033, "epss_percentile": 0.55448}, "CVE-2022-1451": {"epss_score": 0.00276, "epss_percentile": 0.50722}, "CVE-2022-1452": {"epss_score": 0.00276, "epss_percentile": 0.50722}, "CVE-2022-1453": {"epss_score": 0.06415, "epss_percentile": 0.90744}, "CVE-2022-1455": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1456": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1457": {"epss_score": 0.00374, "epss_percentile": 0.5855}, "CVE-2022-1458": {"epss_score": 0.10429, "epss_percentile": 0.92985}, "CVE-2022-1459": {"epss_score": 0.00473, "epss_percentile": 0.64107}, "CVE-2022-1460": {"epss_score": 0.00261, "epss_percentile": 0.49265}, "CVE-2022-1461": {"epss_score": 0.01648, "epss_percentile": 0.81543}, "CVE-2022-1462": {"epss_score": 0.00041, "epss_percentile": 0.12415}, "CVE-2022-1463": {"epss_score": 0.01078, "epss_percentile": 0.77343}, "CVE-2022-1464": {"epss_score": 0.0021, "epss_percentile": 0.43601}, "CVE-2022-1465": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1466": {"epss_score": 0.00158, "epss_percentile": 0.37173}, "CVE-2022-1467": {"epss_score": 0.00278, "epss_percentile": 0.50847}, "CVE-2022-1468": {"epss_score": 0.00215, "epss_percentile": 0.44107}, "CVE-2022-1469": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2022-1470": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2022-1471": {"epss_score": 0.93849, "epss_percentile": 0.99858}, "CVE-2022-1472": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2022-1473": {"epss_score": 0.00282, "epss_percentile": 0.51205}, "CVE-2022-1474": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2022-1475": {"epss_score": 0.00095, "epss_percentile": 0.27122}, "CVE-2022-1476": {"epss_score": 0.35315, "epss_percentile": 0.96899}, "CVE-2022-1477": {"epss_score": 0.00807, "epss_percentile": 0.73675}, "CVE-2022-1478": {"epss_score": 0.01116, "epss_percentile": 0.7772}, "CVE-2022-1479": {"epss_score": 0.01116, "epss_percentile": 0.7772}, "CVE-2022-1481": {"epss_score": 0.01116, "epss_percentile": 0.7772}, "CVE-2022-1482": {"epss_score": 0.00417, "epss_percentile": 0.61245}, "CVE-2022-1483": {"epss_score": 0.00974, "epss_percentile": 0.76167}, "CVE-2022-1484": {"epss_score": 0.0075, "epss_percentile": 0.72624}, "CVE-2022-1485": {"epss_score": 0.00639, "epss_percentile": 0.69933}, "CVE-2022-1486": {"epss_score": 0.01059, "epss_percentile": 0.77159}, "CVE-2022-1487": {"epss_score": 0.00639, "epss_percentile": 0.69937}, "CVE-2022-1488": {"epss_score": 0.00248, "epss_percentile": 0.47936}, "CVE-2022-1489": {"epss_score": 0.01165, "epss_percentile": 0.78177}, "CVE-2022-1490": {"epss_score": 0.00825, "epss_percentile": 0.7395}, "CVE-2022-1491": {"epss_score": 0.00861, "epss_percentile": 0.74553}, "CVE-2022-1492": {"epss_score": 0.00337, "epss_percentile": 0.56027}, "CVE-2022-1493": {"epss_score": 0.00861, "epss_percentile": 0.74553}, "CVE-2022-1494": {"epss_score": 0.00419, "epss_percentile": 0.6135}, "CVE-2022-1495": {"epss_score": 0.00325, "epss_percentile": 0.55008}, "CVE-2022-1496": {"epss_score": 0.01165, "epss_percentile": 0.78177}, "CVE-2022-1497": {"epss_score": 0.00182, "epss_percentile": 0.40229}, "CVE-2022-1498": {"epss_score": 0.00335, "epss_percentile": 0.55813}, "CVE-2022-1499": {"epss_score": 0.00424, "epss_percentile": 0.61642}, "CVE-2022-1500": {"epss_score": 0.00182, "epss_percentile": 0.40228}, "CVE-2022-1501": {"epss_score": 0.00411, "epss_percentile": 0.60878}, "CVE-2022-1502": {"epss_score": 0.00175, "epss_percentile": 0.39268}, "CVE-2022-1503": {"epss_score": 0.00185, "epss_percentile": 0.40472}, "CVE-2022-1504": {"epss_score": 0.00345, "epss_percentile": 0.56555}, "CVE-2022-1505": {"epss_score": 0.0343, "epss_percentile": 0.87121}, "CVE-2022-1506": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2022-1507": {"epss_score": 0.00226, "epss_percentile": 0.45335}, "CVE-2022-1508": {"epss_score": 0.00124, "epss_percentile": 0.32426}, "CVE-2022-1509": {"epss_score": 0.01681, "epss_percentile": 0.81731}, "CVE-2022-1510": {"epss_score": 0.00215, "epss_percentile": 0.4408}, "CVE-2022-1511": {"epss_score": 0.0028, "epss_percentile": 0.51088}, "CVE-2022-1512": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-1513": {"epss_score": 0.00812, "epss_percentile": 0.73745}, "CVE-2022-1514": {"epss_score": 0.00395, "epss_percentile": 0.59843}, "CVE-2022-1515": {"epss_score": 0.00117, "epss_percentile": 0.31261}, "CVE-2022-1516": {"epss_score": 0.00023, "epss_percentile": 0.05492}, "CVE-2022-1517": {"epss_score": 0.0042, "epss_percentile": 0.61406}, "CVE-2022-1518": {"epss_score": 0.00314, "epss_percentile": 0.54145}, "CVE-2022-1519": {"epss_score": 0.00286, "epss_percentile": 0.51686}, "CVE-2022-1520": {"epss_score": 0.00096, "epss_percentile": 0.27357}, "CVE-2022-1521": {"epss_score": 0.00194, "epss_percentile": 0.41522}, "CVE-2022-1522": {"epss_score": 0.0016, "epss_percentile": 0.37482}, "CVE-2022-1523": {"epss_score": 0.00199, "epss_percentile": 0.42182}, "CVE-2022-1524": {"epss_score": 0.00053, "epss_percentile": 0.16865}, "CVE-2022-1525": {"epss_score": 0.00235, "epss_percentile": 0.46331}, "CVE-2022-1526": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-1527": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-1528": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-1529": {"epss_score": 0.03708, "epss_percentile": 0.87601}, "CVE-2022-1530": {"epss_score": 0.00219, "epss_percentile": 0.44506}, "CVE-2022-1531": {"epss_score": 0.03816, "epss_percentile": 0.87769}, "CVE-2022-1532": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2022-1533": {"epss_score": 0.00119, "epss_percentile": 0.31675}, "CVE-2022-1534": {"epss_score": 0.00126, "epss_percentile": 0.32761}, "CVE-2022-1536": {"epss_score": 0.00257, "epss_percentile": 0.48887}, "CVE-2022-1537": {"epss_score": 0.00198, "epss_percentile": 0.42067}, "CVE-2022-1538": {"epss_score": 0.0056, "epss_percentile": 0.67644}, "CVE-2022-1539": {"epss_score": 0.00918, "epss_percentile": 0.75441}, "CVE-2022-1540": {"epss_score": 0.00904, "epss_percentile": 0.75222}, "CVE-2022-1541": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1542": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1543": {"epss_score": 0.00408, "epss_percentile": 0.60674}, "CVE-2022-1544": {"epss_score": 0.00396, "epss_percentile": 0.59856}, "CVE-2022-1545": {"epss_score": 0.0026, "epss_percentile": 0.49232}, "CVE-2022-1546": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1547": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-1548": {"epss_score": 0.0024, "epss_percentile": 0.47227}, "CVE-2022-1549": {"epss_score": 0.00247, "epss_percentile": 0.47836}, "CVE-2022-1551": {"epss_score": 0.00416, "epss_percentile": 0.612}, "CVE-2022-1552": {"epss_score": 0.02642, "epss_percentile": 0.85309}, "CVE-2022-1553": {"epss_score": 0.00262, "epss_percentile": 0.49386}, "CVE-2022-1554": {"epss_score": 0.00613, "epss_percentile": 0.69241}, "CVE-2022-1555": {"epss_score": 0.00904, "epss_percentile": 0.75221}, "CVE-2022-1556": {"epss_score": 0.0883, "epss_percentile": 0.92272}, "CVE-2022-1557": {"epss_score": 0.02102, "epss_percentile": 0.83609}, "CVE-2022-1558": {"epss_score": 0.03429, "epss_percentile": 0.8712}, "CVE-2022-1559": {"epss_score": 0.01782, "epss_percentile": 0.82244}, "CVE-2022-1560": {"epss_score": 0.27775, "epss_percentile": 0.96281}, "CVE-2022-1561": {"epss_score": 0.00193, "epss_percentile": 0.41405}, "CVE-2022-1562": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2022-1563": {"epss_score": 0.00568, "epss_percentile": 0.679}, "CVE-2022-1564": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1565": {"epss_score": 0.5167, "epss_percentile": 0.97793}, "CVE-2022-1566": {"epss_score": 0.00287, "epss_percentile": 0.51825}, "CVE-2022-1567": {"epss_score": 0.00264, "epss_percentile": 0.4971}, "CVE-2022-1568": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1569": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1570": {"epss_score": 0.00177, "epss_percentile": 0.39615}, "CVE-2022-1571": {"epss_score": 0.00322, "epss_percentile": 0.54788}, "CVE-2022-1572": {"epss_score": 0.00212, "epss_percentile": 0.43821}, "CVE-2022-1573": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1574": {"epss_score": 0.73672, "epss_percentile": 0.98766}, "CVE-2022-1575": {"epss_score": 0.0183, "epss_percentile": 0.82443}, "CVE-2022-1576": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2022-1577": {"epss_score": 0.00098, "epss_percentile": 0.27707}, "CVE-2022-1578": {"epss_score": 0.00154, "epss_percentile": 0.36715}, "CVE-2022-1579": {"epss_score": 0.00254, "epss_percentile": 0.48511}, "CVE-2022-1580": {"epss_score": 0.07418, "epss_percentile": 0.91463}, "CVE-2022-1581": {"epss_score": 0.0028, "epss_percentile": 0.51036}, "CVE-2022-1582": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1583": {"epss_score": 0.00596, "epss_percentile": 0.68733}, "CVE-2022-1584": {"epss_score": 0.00321, "epss_percentile": 0.54644}, "CVE-2022-1585": {"epss_score": 0.00583, "epss_percentile": 0.68331}, "CVE-2022-1586": {"epss_score": 0.00454, "epss_percentile": 0.63271}, "CVE-2022-1587": {"epss_score": 0.00274, "epss_percentile": 0.50525}, "CVE-2022-1589": {"epss_score": 0.00224, "epss_percentile": 0.45073}, "CVE-2022-1590": {"epss_score": 0.00257, "epss_percentile": 0.48887}, "CVE-2022-1591": {"epss_score": 0.00141, "epss_percentile": 0.34933}, "CVE-2022-1592": {"epss_score": 0.00314, "epss_percentile": 0.54086}, "CVE-2022-1593": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1594": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1595": {"epss_score": 0.28971, "epss_percentile": 0.96406}, "CVE-2022-1596": {"epss_score": 0.00219, "epss_percentile": 0.44493}, "CVE-2022-1597": {"epss_score": 0.33441, "epss_percentile": 0.96774}, "CVE-2022-1598": {"epss_score": 0.25754, "epss_percentile": 0.96066}, "CVE-2022-1599": {"epss_score": 0.00229, "epss_percentile": 0.45586}, "CVE-2022-1600": {"epss_score": 0.00187, "epss_percentile": 0.40721}, "CVE-2022-1601": {"epss_score": 0.00115, "epss_percentile": 0.3101}, "CVE-2022-1602": {"epss_score": 0.00034, "epss_percentile": 0.09727}, "CVE-2022-1603": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1604": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1605": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1606": {"epss_score": 0.00163, "epss_percentile": 0.37846}, "CVE-2022-1607": {"epss_score": 0.00228, "epss_percentile": 0.45547}, "CVE-2022-1608": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2022-1609": {"epss_score": 0.93495, "epss_percentile": 0.99811}, "CVE-2022-1610": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1611": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2022-1612": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1613": {"epss_score": 0.00171, "epss_percentile": 0.38806}, "CVE-2022-1614": {"epss_score": 0.00245, "epss_percentile": 0.47672}, "CVE-2022-1615": {"epss_score": 0.00246, "epss_percentile": 0.47781}, "CVE-2022-1616": {"epss_score": 0.00088, "epss_percentile": 0.25688}, "CVE-2022-1617": {"epss_score": 0.0013, "epss_percentile": 0.33287}, "CVE-2022-1618": {"epss_score": 0.00211, "epss_percentile": 0.43639}, "CVE-2022-1619": {"epss_score": 0.00504, "epss_percentile": 0.65518}, "CVE-2022-1620": {"epss_score": 0.00081, "epss_percentile": 0.24338}, "CVE-2022-1621": {"epss_score": 0.00114, "epss_percentile": 0.30826}, "CVE-2022-1622": {"epss_score": 0.00104, "epss_percentile": 0.29191}, "CVE-2022-1623": {"epss_score": 0.00101, "epss_percentile": 0.28563}, "CVE-2022-1624": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1625": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1626": {"epss_score": 0.00084, "epss_percentile": 0.24901}, "CVE-2022-1627": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1628": {"epss_score": 0.00196, "epss_percentile": 0.41813}, "CVE-2022-1629": {"epss_score": 0.0096, "epss_percentile": 0.75972}, "CVE-2022-1630": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2022-1631": {"epss_score": 0.11741, "epss_percentile": 0.93463}, "CVE-2022-1632": {"epss_score": 0.00115, "epss_percentile": 0.31019}, "CVE-2022-1633": {"epss_score": 0.01181, "epss_percentile": 0.78308}, "CVE-2022-1634": {"epss_score": 0.00836, "epss_percentile": 0.74131}, "CVE-2022-1635": {"epss_score": 0.00872, "epss_percentile": 0.7473}, "CVE-2022-1636": {"epss_score": 0.00872, "epss_percentile": 0.7473}, "CVE-2022-1637": {"epss_score": 0.00323, "epss_percentile": 0.54892}, "CVE-2022-1638": {"epss_score": 0.00496, "epss_percentile": 0.65136}, "CVE-2022-1639": {"epss_score": 0.00867, "epss_percentile": 0.74651}, "CVE-2022-1640": {"epss_score": 0.00925, "epss_percentile": 0.75529}, "CVE-2022-1641": {"epss_score": 0.01047, "epss_percentile": 0.77043}, "CVE-2022-1642": {"epss_score": 0.00218, "epss_percentile": 0.44348}, "CVE-2022-1643": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1644": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1645": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1646": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1647": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1648": {"epss_score": 0.02802, "epss_percentile": 0.85698}, "CVE-2022-1649": {"epss_score": 0.00249, "epss_percentile": 0.48011}, "CVE-2022-1650": {"epss_score": 0.02081, "epss_percentile": 0.83535}, "CVE-2022-1651": {"epss_score": 0.00045, "epss_percentile": 0.1375}, "CVE-2022-1652": {"epss_score": 0.00135, "epss_percentile": 0.34019}, "CVE-2022-1653": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1654": {"epss_score": 0.00641, "epss_percentile": 0.69991}, "CVE-2022-1655": {"epss_score": 0.00192, "epss_percentile": 0.41316}, "CVE-2022-1656": {"epss_score": 0.00128, "epss_percentile": 0.33049}, "CVE-2022-1657": {"epss_score": 0.0104, "epss_percentile": 0.76956}, "CVE-2022-1658": {"epss_score": 0.00162, "epss_percentile": 0.37666}, "CVE-2022-1659": {"epss_score": 0.00186, "epss_percentile": 0.40613}, "CVE-2022-1660": {"epss_score": 0.01035, "epss_percentile": 0.76899}, "CVE-2022-1661": {"epss_score": 0.00281, "epss_percentile": 0.51139}, "CVE-2022-1662": {"epss_score": 0.00043, "epss_percentile": 0.13308}, "CVE-2022-1663": {"epss_score": 0.00205, "epss_percentile": 0.42681}, "CVE-2022-1664": {"epss_score": 0.0038, "epss_percentile": 0.5891}, "CVE-2022-1665": {"epss_score": 0.00012, "epss_percentile": 0.01271}, "CVE-2022-1666": {"epss_score": 0.00155, "epss_percentile": 0.36803}, "CVE-2022-1667": {"epss_score": 0.00245, "epss_percentile": 0.4773}, "CVE-2022-1668": {"epss_score": 0.00524, "epss_percentile": 0.66331}, "CVE-2022-1669": {"epss_score": 0.0019, "epss_percentile": 0.41104}, "CVE-2022-1670": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2022-1671": {"epss_score": 0.00158, "epss_percentile": 0.37238}, "CVE-2022-1672": {"epss_score": 0.00104, "epss_percentile": 0.29139}, "CVE-2022-1673": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1674": {"epss_score": 0.00125, "epss_percentile": 0.32479}, "CVE-2022-1677": {"epss_score": 0.00227, "epss_percentile": 0.45443}, "CVE-2022-1678": {"epss_score": 0.0152, "epss_percentile": 0.80825}, "CVE-2022-1679": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-1680": {"epss_score": 0.08939, "epss_percentile": 0.92328}, "CVE-2022-1681": {"epss_score": 0.00282, "epss_percentile": 0.51286}, "CVE-2022-1682": {"epss_score": 0.00299, "epss_percentile": 0.52899}, "CVE-2022-1683": {"epss_score": 0.00487, "epss_percentile": 0.64818}, "CVE-2022-1684": {"epss_score": 0.00181, "epss_percentile": 0.40107}, "CVE-2022-1685": {"epss_score": 0.00246, "epss_percentile": 0.47789}, "CVE-2022-1686": {"epss_score": 0.00198, "epss_percentile": 0.42059}, "CVE-2022-1687": {"epss_score": 0.00181, "epss_percentile": 0.40107}, "CVE-2022-1688": {"epss_score": 0.00181, "epss_percentile": 0.40107}, "CVE-2022-1689": {"epss_score": 0.00181, "epss_percentile": 0.40107}, "CVE-2022-1690": {"epss_score": 0.00181, "epss_percentile": 0.40107}, "CVE-2022-1691": {"epss_score": 0.00269, "epss_percentile": 0.50174}, "CVE-2022-1692": {"epss_score": 0.03246, "epss_percentile": 0.86744}, "CVE-2022-1694": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1695": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1697": {"epss_score": 0.00068, "epss_percentile": 0.21335}, "CVE-2022-1698": {"epss_score": 0.00319, "epss_percentile": 0.54486}, "CVE-2022-1699": {"epss_score": 0.00319, "epss_percentile": 0.54486}, "CVE-2022-1700": {"epss_score": 0.00334, "epss_percentile": 0.55687}, "CVE-2022-1701": {"epss_score": 0.00129, "epss_percentile": 0.33171}, "CVE-2022-1702": {"epss_score": 0.00171, "epss_percentile": 0.38885}, "CVE-2022-1703": {"epss_score": 0.03114, "epss_percentile": 0.86431}, "CVE-2022-1704": {"epss_score": 0.00263, "epss_percentile": 0.49518}, "CVE-2022-1705": {"epss_score": 0.00053, "epss_percentile": 0.16933}, "CVE-2022-1706": {"epss_score": 0.00592, "epss_percentile": 0.68617}, "CVE-2022-1707": {"epss_score": 0.1707, "epss_percentile": 0.94769}, "CVE-2022-1708": {"epss_score": 0.00592, "epss_percentile": 0.68617}, "CVE-2022-1709": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1710": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1711": {"epss_score": 0.30074, "epss_percentile": 0.96503}, "CVE-2022-1712": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1713": {"epss_score": 0.89884, "epss_percentile": 0.99547}, "CVE-2022-1714": {"epss_score": 0.00146, "epss_percentile": 0.35584}, "CVE-2022-1715": {"epss_score": 0.0034, "epss_percentile": 0.56275}, "CVE-2022-1716": {"epss_score": 0.00063, "epss_percentile": 0.19948}, "CVE-2022-1717": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1718": {"epss_score": 0.00585, "epss_percentile": 0.68404}, "CVE-2022-1719": {"epss_score": 0.00224, "epss_percentile": 0.45073}, "CVE-2022-1720": {"epss_score": 0.00519, "epss_percentile": 0.66181}, "CVE-2022-1721": {"epss_score": 0.01233, "epss_percentile": 0.78749}, "CVE-2022-1722": {"epss_score": 0.00159, "epss_percentile": 0.37371}, "CVE-2022-1723": {"epss_score": 0.00922, "epss_percentile": 0.75493}, "CVE-2022-1724": {"epss_score": 0.05224, "epss_percentile": 0.8963}, "CVE-2022-1725": {"epss_score": 0.00044, "epss_percentile": 0.13663}, "CVE-2022-1726": {"epss_score": 0.00305, "epss_percentile": 0.53386}, "CVE-2022-1727": {"epss_score": 0.01053, "epss_percentile": 0.77103}, "CVE-2022-1728": {"epss_score": 0.00438, "epss_percentile": 0.62551}, "CVE-2022-1729": {"epss_score": 0.00096, "epss_percentile": 0.273}, "CVE-2022-1730": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-1731": {"epss_score": 0.00344, "epss_percentile": 0.56532}, "CVE-2022-1732": {"epss_score": 0.00235, "epss_percentile": 0.46227}, "CVE-2022-1733": {"epss_score": 0.00028, "epss_percentile": 0.07438}, "CVE-2022-1734": {"epss_score": 0.00017, "epss_percentile": 0.03169}, "CVE-2022-1735": {"epss_score": 0.00131, "epss_percentile": 0.33412}, "CVE-2022-1736": {"epss_score": 0.00473, "epss_percentile": 0.64079}, "CVE-2022-1737": {"epss_score": 0.0004, "epss_percentile": 0.12186}, "CVE-2022-1738": {"epss_score": 0.00237, "epss_percentile": 0.46665}, "CVE-2022-1739": {"epss_score": 0.00013, "epss_percentile": 0.01678}, "CVE-2022-1740": {"epss_score": 0.00108, "epss_percentile": 0.29802}, "CVE-2022-1741": {"epss_score": 0.0005, "epss_percentile": 0.15879}, "CVE-2022-1742": {"epss_score": 0.0005, "epss_percentile": 0.15879}, "CVE-2022-1743": {"epss_score": 0.00091, "epss_percentile": 0.26249}, "CVE-2022-1744": {"epss_score": 0.00053, "epss_percentile": 0.16736}, "CVE-2022-1745": {"epss_score": 0.00043, "epss_percentile": 0.13215}, "CVE-2022-1746": {"epss_score": 0.00043, "epss_percentile": 0.13215}, "CVE-2022-1747": {"epss_score": 0.00022, "epss_percentile": 0.0504}, "CVE-2022-1748": {"epss_score": 0.00366, "epss_percentile": 0.58093}, "CVE-2022-1749": {"epss_score": 0.00212, "epss_percentile": 0.43743}, "CVE-2022-1750": {"epss_score": 0.00288, "epss_percentile": 0.51901}, "CVE-2022-1751": {"epss_score": 0.00852, "epss_percentile": 0.7442}, "CVE-2022-1752": {"epss_score": 0.00408, "epss_percentile": 0.60674}, "CVE-2022-1753": {"epss_score": 0.00224, "epss_percentile": 0.45}, "CVE-2022-1754": {"epss_score": 0.00535, "epss_percentile": 0.66827}, "CVE-2022-1755": {"epss_score": 0.00198, "epss_percentile": 0.42007}, "CVE-2022-1756": {"epss_score": 0.03183, "epss_percentile": 0.86585}, "CVE-2022-1757": {"epss_score": 0.00118, "epss_percentile": 0.31405}, "CVE-2022-1758": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2022-1759": {"epss_score": 0.00084, "epss_percentile": 0.24901}, "CVE-2022-1760": {"epss_score": 0.00129, "epss_percentile": 0.33181}, "CVE-2022-1761": {"epss_score": 0.00153, "epss_percentile": 0.36512}, "CVE-2022-1762": {"epss_score": 0.00245, "epss_percentile": 0.47672}, "CVE-2022-1763": {"epss_score": 0.00084, "epss_percentile": 0.24901}, "CVE-2022-1764": {"epss_score": 0.00092, "epss_percentile": 0.26457}, "CVE-2022-1765": {"epss_score": 0.00202, "epss_percentile": 0.4245}, "CVE-2022-1766": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2022-1767": {"epss_score": 0.00922, "epss_percentile": 0.75493}, "CVE-2022-1768": {"epss_score": 0.86112, "epss_percentile": 0.99368}, "CVE-2022-1769": {"epss_score": 0.00041, "epss_percentile": 0.1232}, "CVE-2022-1770": {"epss_score": 0.00299, "epss_percentile": 0.52901}, "CVE-2022-1771": {"epss_score": 0.00029, "epss_percentile": 0.07951}, "CVE-2022-1772": {"epss_score": 0.02509, "epss_percentile": 0.84943}, "CVE-2022-1773": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-1774": {"epss_score": 0.0102, "epss_percentile": 0.76732}, "CVE-2022-1775": {"epss_score": 0.003, "epss_percentile": 0.52923}, "CVE-2022-1776": {"epss_score": 0.00197, "epss_percentile": 0.41908}, "CVE-2022-1777": {"epss_score": 0.00638, "epss_percentile": 0.69927}, "CVE-2022-1778": {"epss_score": 0.00278, "epss_percentile": 0.50893}, "CVE-2022-1779": {"epss_score": 0.0012, "epss_percentile": 0.31793}, "CVE-2022-1780": {"epss_score": 0.00084, "epss_percentile": 0.24901}, "CVE-2022-1781": {"epss_score": 0.00084, "epss_percentile": 0.24901}, "CVE-2022-1782": {"epss_score": 0.00318, "epss_percentile": 0.5445}, "CVE-2022-1783": {"epss_score": 0.00503, "epss_percentile": 0.65466}, "CVE-2022-1784": {"epss_score": 0.01225, "epss_percentile": 0.78683}, "CVE-2022-1785": {"epss_score": 0.00048, "epss_percentile": 0.15203}, "CVE-2022-1786": {"epss_score": 0.01014, "epss_percentile": 0.76641}, "CVE-2022-1787": {"epss_score": 0.00084, "epss_percentile": 0.24901}, "CVE-2022-1788": {"epss_score": 0.00105, "epss_percentile": 0.29391}, "CVE-2022-1789": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2022-1790": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2022-1791": {"epss_score": 0.00089, "epss_percentile": 0.25807}, "CVE-2022-1792": {"epss_score": 0.00084, "epss_percentile": 0.24901}, "CVE-2022-1793": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1794": {"epss_score": 0.00111, "epss_percentile": 0.3024}, "CVE-2022-1795": {"epss_score": 0.00119, "epss_percentile": 0.31658}, "CVE-2022-1796": {"epss_score": 0.00095, "epss_percentile": 0.27104}, "CVE-2022-1797": {"epss_score": 0.0003, "epss_percentile": 0.08096}, "CVE-2022-1798": {"epss_score": 0.00034, "epss_percentile": 0.09454}, "CVE-2022-1799": {"epss_score": 0.00155, "epss_percentile": 0.3676}, "CVE-2022-1800": {"epss_score": 0.0062, "epss_percentile": 0.6945}, "CVE-2022-1801": {"epss_score": 0.00245, "epss_percentile": 0.47672}, "CVE-2022-1802": {"epss_score": 0.63835, "epss_percentile": 0.98351}, "CVE-2022-1803": {"epss_score": 0.00341, "epss_percentile": 0.56294}, "CVE-2022-1804": {"epss_score": 0.00019, "epss_percentile": 0.0421}, "CVE-2022-1805": {"epss_score": 0.00408, "epss_percentile": 0.60628}, "CVE-2022-1806": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2022-1807": {"epss_score": 0.00336, "epss_percentile": 0.56001}, "CVE-2022-1808": {"epss_score": 0.00919, "epss_percentile": 0.7546}, "CVE-2022-1809": {"epss_score": 0.00273, "epss_percentile": 0.50457}, "CVE-2022-1810": {"epss_score": 0.00061, "epss_percentile": 0.19481}, "CVE-2022-1811": {"epss_score": 0.00193, "epss_percentile": 0.41441}, "CVE-2022-1812": {"epss_score": 0.02099, "epss_percentile": 0.83594}, "CVE-2022-1813": {"epss_score": 0.0318, "epss_percentile": 0.86576}, "CVE-2022-1814": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1815": {"epss_score": 0.24873, "epss_percentile": 0.9596}, "CVE-2022-1816": {"epss_score": 0.00185, "epss_percentile": 0.40518}, "CVE-2022-1817": {"epss_score": 0.00185, "epss_percentile": 0.40518}, "CVE-2022-1818": {"epss_score": 0.00084, "epss_percentile": 0.24901}, "CVE-2022-1819": {"epss_score": 0.00347, "epss_percentile": 0.5676}, "CVE-2022-1820": {"epss_score": 0.02975, "epss_percentile": 0.86104}, "CVE-2022-1821": {"epss_score": 0.00203, "epss_percentile": 0.42537}, "CVE-2022-1822": {"epss_score": 0.02975, "epss_percentile": 0.86104}, "CVE-2022-1823": {"epss_score": 0.00174, "epss_percentile": 0.39169}, "CVE-2022-1824": {"epss_score": 0.00227, "epss_percentile": 0.45381}, "CVE-2022-1825": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-1826": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1827": {"epss_score": 0.00153, "epss_percentile": 0.36512}, "CVE-2022-1828": {"epss_score": 0.0014, "epss_percentile": 0.3468}, "CVE-2022-1829": {"epss_score": 0.00192, "epss_percentile": 0.41368}, "CVE-2022-1830": {"epss_score": 0.00199, "epss_percentile": 0.4215}, "CVE-2022-1831": {"epss_score": 0.00134, "epss_percentile": 0.33839}, "CVE-2022-1832": {"epss_score": 0.00142, "epss_percentile": 0.34966}, "CVE-2022-1833": {"epss_score": 0.00321, "epss_percentile": 0.54736}, "CVE-2022-1834": {"epss_score": 0.00173, "epss_percentile": 0.39089}, "CVE-2022-1837": {"epss_score": 0.00852, "epss_percentile": 0.74418}, "CVE-2022-1838": {"epss_score": 0.00321, "epss_percentile": 0.54686}, "CVE-2022-1839": {"epss_score": 0.00478, "epss_percentile": 0.64408}, "CVE-2022-1840": {"epss_score": 0.00294, "epss_percentile": 0.52387}, "CVE-2022-1841": {"epss_score": 0.00231, "epss_percentile": 0.4583}, "CVE-2022-1842": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1843": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1844": {"epss_score": 0.00112, "epss_percentile": 0.30542}, "CVE-2022-1845": {"epss_score": 0.00112, "epss_percentile": 0.30542}, "CVE-2022-1846": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1847": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1848": {"epss_score": 0.00363, "epss_percentile": 0.57898}, "CVE-2022-1849": {"epss_score": 0.00175, "epss_percentile": 0.39349}, "CVE-2022-1850": {"epss_score": 0.0032, "epss_percentile": 0.54588}, "CVE-2022-1851": {"epss_score": 0.00152, "epss_percentile": 0.36417}, "CVE-2022-1852": {"epss_score": 0.00017, "epss_percentile": 0.031}, "CVE-2022-1853": {"epss_score": 0.01131, "epss_percentile": 0.77857}, "CVE-2022-1854": {"epss_score": 0.00872, "epss_percentile": 0.7473}, "CVE-2022-1855": {"epss_score": 0.0093, "epss_percentile": 0.75602}, "CVE-2022-1856": {"epss_score": 0.00284, "epss_percentile": 0.51415}, "CVE-2022-1857": {"epss_score": 0.00478, "epss_percentile": 0.64369}, "CVE-2022-1858": {"epss_score": 0.00414, "epss_percentile": 0.61038}, "CVE-2022-1859": {"epss_score": 0.0093, "epss_percentile": 0.75602}, "CVE-2022-1860": {"epss_score": 0.01181, "epss_percentile": 0.78308}, "CVE-2022-1861": {"epss_score": 0.01181, "epss_percentile": 0.78308}, "CVE-2022-1862": {"epss_score": 0.00199, "epss_percentile": 0.42136}, "CVE-2022-1863": {"epss_score": 0.00284, "epss_percentile": 0.51415}, "CVE-2022-1864": {"epss_score": 0.00303, "epss_percentile": 0.53177}, "CVE-2022-1865": {"epss_score": 0.00303, "epss_percentile": 0.53177}, "CVE-2022-1866": {"epss_score": 0.01259, "epss_percentile": 0.78965}, "CVE-2022-1867": {"epss_score": 0.00377, "epss_percentile": 0.58691}, "CVE-2022-1868": {"epss_score": 0.00148, "epss_percentile": 0.35871}, "CVE-2022-1869": {"epss_score": 0.00414, "epss_percentile": 0.61038}, "CVE-2022-1870": {"epss_score": 0.00303, "epss_percentile": 0.53177}, "CVE-2022-1871": {"epss_score": 0.0019, "epss_percentile": 0.41063}, "CVE-2022-1872": {"epss_score": 0.00203, "epss_percentile": 0.42497}, "CVE-2022-1873": {"epss_score": 0.00088, "epss_percentile": 0.25725}, "CVE-2022-1874": {"epss_score": 0.00639, "epss_percentile": 0.69943}, "CVE-2022-1875": {"epss_score": 0.00339, "epss_percentile": 0.56198}, "CVE-2022-1876": {"epss_score": 0.00285, "epss_percentile": 0.51549}, "CVE-2022-1881": {"epss_score": 0.00153, "epss_percentile": 0.36608}, "CVE-2022-1882": {"epss_score": 0.00031, "epss_percentile": 0.08377}, "CVE-2022-1883": {"epss_score": 0.6204, "epss_percentile": 0.98274}, "CVE-2022-1884": {"epss_score": 0.09822, "epss_percentile": 0.92718}, "CVE-2022-1885": {"epss_score": 0.00142, "epss_percentile": 0.34966}, "CVE-2022-1886": {"epss_score": 0.00127, "epss_percentile": 0.32817}, "CVE-2022-1887": {"epss_score": 0.00593, "epss_percentile": 0.68652}, "CVE-2022-1888": {"epss_score": 0.00071, "epss_percentile": 0.22172}, "CVE-2022-1889": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2022-1890": {"epss_score": 0.00094, "epss_percentile": 0.26955}, "CVE-2022-1891": {"epss_score": 0.00094, "epss_percentile": 0.26955}, "CVE-2022-1892": {"epss_score": 0.00094, "epss_percentile": 0.26955}, "CVE-2022-1893": {"epss_score": 0.00323, "epss_percentile": 0.5491}, "CVE-2022-1894": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-1895": {"epss_score": 0.00112, "epss_percentile": 0.30542}, "CVE-2022-1896": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1897": {"epss_score": 0.00526, "epss_percentile": 0.66406}, "CVE-2022-1898": {"epss_score": 0.00152, "epss_percentile": 0.36492}, "CVE-2022-1899": {"epss_score": 0.00454, "epss_percentile": 0.63249}, "CVE-2022-1900": {"epss_score": 0.00142, "epss_percentile": 0.3505}, "CVE-2022-1901": {"epss_score": 0.00214, "epss_percentile": 0.43994}, "CVE-2022-1902": {"epss_score": 0.00847, "epss_percentile": 0.74349}, "CVE-2022-1903": {"epss_score": 0.82646, "epss_percentile": 0.99203}, "CVE-2022-1904": {"epss_score": 0.02188, "epss_percentile": 0.83926}, "CVE-2022-1905": {"epss_score": 0.23721, "epss_percentile": 0.95808}, "CVE-2022-1906": {"epss_score": 0.05846, "epss_percentile": 0.90256}, "CVE-2022-1907": {"epss_score": 0.0016, "epss_percentile": 0.37517}, "CVE-2022-1908": {"epss_score": 0.0016, "epss_percentile": 0.37517}, "CVE-2022-1909": {"epss_score": 0.0033, "epss_percentile": 0.55464}, "CVE-2022-1910": {"epss_score": 0.03381, "epss_percentile": 0.87032}, "CVE-2022-1911": {"epss_score": 0.00238, "epss_percentile": 0.46745}, "CVE-2022-1912": {"epss_score": 0.00192, "epss_percentile": 0.41326}, "CVE-2022-1913": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1914": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1915": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1916": {"epss_score": 0.04572, "epss_percentile": 0.88864}, "CVE-2022-1918": {"epss_score": 0.00203, "epss_percentile": 0.42511}, "CVE-2022-1919": {"epss_score": 0.00482, "epss_percentile": 0.64552}, "CVE-2022-1920": {"epss_score": 0.00095, "epss_percentile": 0.27084}, "CVE-2022-1921": {"epss_score": 0.00049, "epss_percentile": 0.15635}, "CVE-2022-1922": {"epss_score": 0.00049, "epss_percentile": 0.15447}, "CVE-2022-1923": {"epss_score": 0.00056, "epss_percentile": 0.17743}, "CVE-2022-1924": {"epss_score": 0.00049, "epss_percentile": 0.15447}, "CVE-2022-1925": {"epss_score": 0.00059, "epss_percentile": 0.18678}, "CVE-2022-1926": {"epss_score": 0.00413, "epss_percentile": 0.60989}, "CVE-2022-1927": {"epss_score": 0.00152, "epss_percentile": 0.36375}, "CVE-2022-1928": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2022-1929": {"epss_score": 0.00344, "epss_percentile": 0.56474}, "CVE-2022-1930": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-1931": {"epss_score": 0.00322, "epss_percentile": 0.54824}, "CVE-2022-1932": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-1933": {"epss_score": 0.14451, "epss_percentile": 0.94214}, "CVE-2022-1934": {"epss_score": 0.00143, "epss_percentile": 0.35102}, "CVE-2022-1935": {"epss_score": 0.00143, "epss_percentile": 0.35177}, "CVE-2022-1936": {"epss_score": 0.00168, "epss_percentile": 0.38463}, "CVE-2022-1937": {"epss_score": 0.05048, "epss_percentile": 0.89438}, "CVE-2022-1938": {"epss_score": 0.00723, "epss_percentile": 0.72025}, "CVE-2022-1939": {"epss_score": 0.00875, "epss_percentile": 0.74777}, "CVE-2022-1940": {"epss_score": 0.00187, "epss_percentile": 0.40795}, "CVE-2022-1941": {"epss_score": 0.00143, "epss_percentile": 0.35098}, "CVE-2022-1942": {"epss_score": 0.00826, "epss_percentile": 0.73975}, "CVE-2022-1943": {"epss_score": 0.00111, "epss_percentile": 0.30303}, "CVE-2022-1944": {"epss_score": 0.00162, "epss_percentile": 0.37685}, "CVE-2022-1945": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1946": {"epss_score": 0.00862, "epss_percentile": 0.74574}, "CVE-2022-1947": {"epss_score": 0.00511, "epss_percentile": 0.65822}, "CVE-2022-1948": {"epss_score": 0.2332, "epss_percentile": 0.95764}, "CVE-2022-1949": {"epss_score": 0.00676, "epss_percentile": 0.70931}, "CVE-2022-1950": {"epss_score": 0.57136, "epss_percentile": 0.98049}, "CVE-2022-1951": {"epss_score": 0.00293, "epss_percentile": 0.52337}, "CVE-2022-1952": {"epss_score": 0.85897, "epss_percentile": 0.99354}, "CVE-2022-1953": {"epss_score": 0.03888, "epss_percentile": 0.87906}, "CVE-2022-1954": {"epss_score": 0.00236, "epss_percentile": 0.46377}, "CVE-2022-1955": {"epss_score": 0.0008, "epss_percentile": 0.24119}, "CVE-2022-1956": {"epss_score": 0.0008, "epss_percentile": 0.24142}, "CVE-2022-1957": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1958": {"epss_score": 0.0023, "epss_percentile": 0.45671}, "CVE-2022-1959": {"epss_score": 0.0012, "epss_percentile": 0.31788}, "CVE-2022-1960": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1961": {"epss_score": 0.00623, "epss_percentile": 0.69542}, "CVE-2022-1962": {"epss_score": 5e-05, "epss_percentile": 0.00193}, "CVE-2022-1963": {"epss_score": 0.01459, "epss_percentile": 0.80409}, "CVE-2022-1964": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2022-1965": {"epss_score": 0.00787, "epss_percentile": 0.73312}, "CVE-2022-1967": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-1968": {"epss_score": 0.00178, "epss_percentile": 0.39657}, "CVE-2022-1969": {"epss_score": 0.0017, "epss_percentile": 0.38746}, "CVE-2022-1971": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1973": {"epss_score": 0.00126, "epss_percentile": 0.32729}, "CVE-2022-1974": {"epss_score": 0.00017, "epss_percentile": 0.03304}, "CVE-2022-1975": {"epss_score": 0.00024, "epss_percentile": 0.05669}, "CVE-2022-1976": {"epss_score": 0.00155, "epss_percentile": 0.36817}, "CVE-2022-1977": {"epss_score": 0.00723, "epss_percentile": 0.72011}, "CVE-2022-1979": {"epss_score": 0.00184, "epss_percentile": 0.40367}, "CVE-2022-1980": {"epss_score": 0.00215, "epss_percentile": 0.44061}, "CVE-2022-1981": {"epss_score": 0.00181, "epss_percentile": 0.40059}, "CVE-2022-1982": {"epss_score": 0.00427, "epss_percentile": 0.6189}, "CVE-2022-1983": {"epss_score": 0.00131, "epss_percentile": 0.33502}, "CVE-2022-1984": {"epss_score": 0.00145, "epss_percentile": 0.3536}, "CVE-2022-1985": {"epss_score": 0.00307, "epss_percentile": 0.53564}, "CVE-2022-1986": {"epss_score": 0.13864, "epss_percentile": 0.94078}, "CVE-2022-1987": {"epss_score": 0.00195, "epss_percentile": 0.41677}, "CVE-2022-1988": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2022-1989": {"epss_score": 0.00235, "epss_percentile": 0.46245}, "CVE-2022-1990": {"epss_score": 0.00338, "epss_percentile": 0.5607}, "CVE-2022-1991": {"epss_score": 0.00184, "epss_percentile": 0.40367}, "CVE-2022-1992": {"epss_score": 0.01689, "epss_percentile": 0.8177}, "CVE-2022-1993": {"epss_score": 0.00582, "epss_percentile": 0.68307}, "CVE-2022-1994": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-1995": {"epss_score": 0.00287, "epss_percentile": 0.51837}, "CVE-2022-1996": {"epss_score": 0.00963, "epss_percentile": 0.7602}, "CVE-2022-1997": {"epss_score": 0.00309, "epss_percentile": 0.53662}, "CVE-2022-1998": {"epss_score": 0.00125, "epss_percentile": 0.32537}, "CVE-2022-1999": {"epss_score": 0.00204, "epss_percentile": 0.42631}, "CVE-2022-20001": {"epss_score": 0.00413, "epss_percentile": 0.61012}, "CVE-2022-20002": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20004": {"epss_score": 0.00025, "epss_percentile": 0.06336}, "CVE-2022-20005": {"epss_score": 0.00027, "epss_percentile": 0.06979}, "CVE-2022-20006": {"epss_score": 0.00029, "epss_percentile": 0.07973}, "CVE-2022-20007": {"epss_score": 0.00023, "epss_percentile": 0.05522}, "CVE-2022-20008": {"epss_score": 0.00047, "epss_percentile": 0.14658}, "CVE-2022-20009": {"epss_score": 0.00302, "epss_percentile": 0.53163}, "CVE-2022-20010": {"epss_score": 0.00407, "epss_percentile": 0.60577}, "CVE-2022-20011": {"epss_score": 0.00053, "epss_percentile": 0.16861}, "CVE-2022-20012": {"epss_score": 0.00016, "epss_percentile": 0.02958}, "CVE-2022-20013": {"epss_score": 0.00012, "epss_percentile": 0.01268}, "CVE-2022-20014": {"epss_score": 0.00014, "epss_percentile": 0.01788}, "CVE-2022-20015": {"epss_score": 0.00014, "epss_percentile": 0.02117}, "CVE-2022-20016": {"epss_score": 0.00011, "epss_percentile": 0.00958}, "CVE-2022-20017": {"epss_score": 0.00015, "epss_percentile": 0.02334}, "CVE-2022-20018": {"epss_score": 0.00014, "epss_percentile": 0.02117}, "CVE-2022-20019": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2022-20020": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2022-20021": {"epss_score": 0.00785, "epss_percentile": 0.73253}, "CVE-2022-20022": {"epss_score": 0.00785, "epss_percentile": 0.73253}, "CVE-2022-20023": {"epss_score": 0.00136, "epss_percentile": 0.34142}, "CVE-2022-20024": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20025": {"epss_score": 0.00014, "epss_percentile": 0.01981}, "CVE-2022-20026": {"epss_score": 0.00014, "epss_percentile": 0.01981}, "CVE-2022-20027": {"epss_score": 0.00014, "epss_percentile": 0.01981}, "CVE-2022-20028": {"epss_score": 0.00014, "epss_percentile": 0.01981}, "CVE-2022-20029": {"epss_score": 0.00016, "epss_percentile": 0.02953}, "CVE-2022-20030": {"epss_score": 0.00015, "epss_percentile": 0.02212}, "CVE-2022-20031": {"epss_score": 0.00018, "epss_percentile": 0.03602}, "CVE-2022-20032": {"epss_score": 0.00011, "epss_percentile": 0.01079}, "CVE-2022-20033": {"epss_score": 0.00016, "epss_percentile": 0.02953}, "CVE-2022-20034": {"epss_score": 0.00023, "epss_percentile": 0.05481}, "CVE-2022-20035": {"epss_score": 0.00017, "epss_percentile": 0.03235}, "CVE-2022-20036": {"epss_score": 0.00015, "epss_percentile": 0.02334}, "CVE-2022-20037": {"epss_score": 0.00015, "epss_percentile": 0.02334}, "CVE-2022-20038": {"epss_score": 0.00016, "epss_percentile": 0.02736}, "CVE-2022-20039": {"epss_score": 0.00018, "epss_percentile": 0.03933}, "CVE-2022-20040": {"epss_score": 0.00016, "epss_percentile": 0.02804}, "CVE-2022-20041": {"epss_score": 0.00013, "epss_percentile": 0.01614}, "CVE-2022-20042": {"epss_score": 0.00015, "epss_percentile": 0.02334}, "CVE-2022-20043": {"epss_score": 0.00013, "epss_percentile": 0.01614}, "CVE-2022-20044": {"epss_score": 0.00017, "epss_percentile": 0.03055}, "CVE-2022-20045": {"epss_score": 0.00017, "epss_percentile": 0.03055}, "CVE-2022-20046": {"epss_score": 0.00013, "epss_percentile": 0.01691}, "CVE-2022-20047": {"epss_score": 0.00012, "epss_percentile": 0.01236}, "CVE-2022-20048": {"epss_score": 0.00012, "epss_percentile": 0.01236}, "CVE-2022-20049": {"epss_score": 0.00013, "epss_percentile": 0.01697}, "CVE-2022-20050": {"epss_score": 0.00017, "epss_percentile": 0.0325}, "CVE-2022-20051": {"epss_score": 0.00013, "epss_percentile": 0.0167}, "CVE-2022-20052": {"epss_score": 0.00015, "epss_percentile": 0.02409}, "CVE-2022-20053": {"epss_score": 0.00032, "epss_percentile": 0.08848}, "CVE-2022-20054": {"epss_score": 0.00041, "epss_percentile": 0.1225}, "CVE-2022-20055": {"epss_score": 0.00012, "epss_percentile": 0.01421}, "CVE-2022-20056": {"epss_score": 0.00015, "epss_percentile": 0.02277}, "CVE-2022-20057": {"epss_score": 0.00014, "epss_percentile": 0.01788}, "CVE-2022-20058": {"epss_score": 0.00015, "epss_percentile": 0.02277}, "CVE-2022-20059": {"epss_score": 0.00015, "epss_percentile": 0.02277}, "CVE-2022-20060": {"epss_score": 0.00017, "epss_percentile": 0.03127}, "CVE-2022-20062": {"epss_score": 0.00015, "epss_percentile": 0.02409}, "CVE-2022-20063": {"epss_score": 0.00011, "epss_percentile": 0.01105}, "CVE-2022-20064": {"epss_score": 0.00013, "epss_percentile": 0.0163}, "CVE-2022-20065": {"epss_score": 0.00015, "epss_percentile": 0.02557}, "CVE-2022-20066": {"epss_score": 0.0005, "epss_percentile": 0.15823}, "CVE-2022-20067": {"epss_score": 0.00014, "epss_percentile": 0.01788}, "CVE-2022-20068": {"epss_score": 0.00019, "epss_percentile": 0.04285}, "CVE-2022-20069": {"epss_score": 0.00017, "epss_percentile": 0.03373}, "CVE-2022-20070": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20071": {"epss_score": 7e-05, "epss_percentile": 0.00414}, "CVE-2022-20072": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2022-20073": {"epss_score": 0.00091, "epss_percentile": 0.26405}, "CVE-2022-20074": {"epss_score": 0.00015, "epss_percentile": 0.02277}, "CVE-2022-20075": {"epss_score": 0.00015, "epss_percentile": 0.02311}, "CVE-2022-20076": {"epss_score": 0.00014, "epss_percentile": 0.02117}, "CVE-2022-20077": {"epss_score": 0.0001, "epss_percentile": 0.00847}, "CVE-2022-20078": {"epss_score": 0.00011, "epss_percentile": 0.01019}, "CVE-2022-20079": {"epss_score": 0.00015, "epss_percentile": 0.02215}, "CVE-2022-20080": {"epss_score": 0.0001, "epss_percentile": 0.00791}, "CVE-2022-20081": {"epss_score": 0.00162, "epss_percentile": 0.37722}, "CVE-2022-20082": {"epss_score": 0.00011, "epss_percentile": 0.00988}, "CVE-2022-20083": {"epss_score": 0.0208, "epss_percentile": 0.83529}, "CVE-2022-20084": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20085": {"epss_score": 0.00022, "epss_percentile": 0.05238}, "CVE-2022-20087": {"epss_score": 0.00018, "epss_percentile": 0.037}, "CVE-2022-20088": {"epss_score": 0.00016, "epss_percentile": 0.02946}, "CVE-2022-20089": {"epss_score": 0.00016, "epss_percentile": 0.02736}, "CVE-2022-20090": {"epss_score": 0.00012, "epss_percentile": 0.01331}, "CVE-2022-20091": {"epss_score": 0.00012, "epss_percentile": 0.01331}, "CVE-2022-20092": {"epss_score": 0.00017, "epss_percentile": 0.03414}, "CVE-2022-20093": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20094": {"epss_score": 0.00016, "epss_percentile": 0.02736}, "CVE-2022-20095": {"epss_score": 0.00018, "epss_percentile": 0.037}, "CVE-2022-20096": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-20097": {"epss_score": 0.00012, "epss_percentile": 0.01173}, "CVE-2022-20098": {"epss_score": 0.00053, "epss_percentile": 0.17007}, "CVE-2022-20099": {"epss_score": 0.00016, "epss_percentile": 0.02946}, "CVE-2022-20100": {"epss_score": 0.00017, "epss_percentile": 0.03494}, "CVE-2022-20101": {"epss_score": 0.00014, "epss_percentile": 0.01916}, "CVE-2022-20102": {"epss_score": 0.00017, "epss_percentile": 0.03494}, "CVE-2022-20103": {"epss_score": 0.00018, "epss_percentile": 0.03895}, "CVE-2022-20104": {"epss_score": 0.00017, "epss_percentile": 0.03414}, "CVE-2022-20105": {"epss_score": 0.00017, "epss_percentile": 0.03446}, "CVE-2022-20106": {"epss_score": 0.00017, "epss_percentile": 0.03446}, "CVE-2022-20107": {"epss_score": 0.00051, "epss_percentile": 0.15992}, "CVE-2022-20108": {"epss_score": 0.00039, "epss_percentile": 0.11558}, "CVE-2022-20109": {"epss_score": 0.00019, "epss_percentile": 0.04257}, "CVE-2022-20110": {"epss_score": 0.00011, "epss_percentile": 0.01067}, "CVE-2022-20111": {"epss_score": 0.0002, "epss_percentile": 0.04587}, "CVE-2022-20112": {"epss_score": 0.00012, "epss_percentile": 0.01264}, "CVE-2022-20113": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2022-20114": {"epss_score": 0.0001, "epss_percentile": 0.00853}, "CVE-2022-20115": {"epss_score": 0.00053, "epss_percentile": 0.16861}, "CVE-2022-20116": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2022-20117": {"epss_score": 9e-05, "epss_percentile": 0.00694}, "CVE-2022-20118": {"epss_score": 0.00012, "epss_percentile": 0.01119}, "CVE-2022-20119": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2022-20120": {"epss_score": 0.01043, "epss_percentile": 0.76993}, "CVE-2022-20121": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20122": {"epss_score": 0.00164, "epss_percentile": 0.37987}, "CVE-2022-20123": {"epss_score": 0.00364, "epss_percentile": 0.57945}, "CVE-2022-20124": {"epss_score": 0.00029, "epss_percentile": 0.07608}, "CVE-2022-20125": {"epss_score": 0.00013, "epss_percentile": 0.01651}, "CVE-2022-20126": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2022-20127": {"epss_score": 0.05475, "epss_percentile": 0.89911}, "CVE-2022-20129": {"epss_score": 0.00015, "epss_percentile": 0.0233}, "CVE-2022-20130": {"epss_score": 0.16094, "epss_percentile": 0.94572}, "CVE-2022-20131": {"epss_score": 0.00364, "epss_percentile": 0.57945}, "CVE-2022-20132": {"epss_score": 0.00063, "epss_percentile": 0.20073}, "CVE-2022-20133": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2022-20134": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2022-20135": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2022-20137": {"epss_score": 0.00012, "epss_percentile": 0.01218}, "CVE-2022-20138": {"epss_score": 0.00025, "epss_percentile": 0.06336}, "CVE-2022-20140": {"epss_score": 0.04172, "epss_percentile": 0.88348}, "CVE-2022-20141": {"epss_score": 0.00029, "epss_percentile": 0.07864}, "CVE-2022-20142": {"epss_score": 0.00035, "epss_percentile": 0.09817}, "CVE-2022-20143": {"epss_score": 0.00015, "epss_percentile": 0.0233}, "CVE-2022-20144": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2022-20145": {"epss_score": 0.06369, "epss_percentile": 0.90704}, "CVE-2022-20146": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2022-20147": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2022-20148": {"epss_score": 0.00016, "epss_percentile": 0.02909}, "CVE-2022-20149": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20151": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20152": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20153": {"epss_score": 0.00016, "epss_percentile": 0.02741}, "CVE-2022-20154": {"epss_score": 0.0002, "epss_percentile": 0.04678}, "CVE-2022-20155": {"epss_score": 0.00012, "epss_percentile": 0.01119}, "CVE-2022-20156": {"epss_score": 0.00013, "epss_percentile": 0.01471}, "CVE-2022-20158": {"epss_score": 0.00029, "epss_percentile": 0.07751}, "CVE-2022-20159": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2022-20160": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2022-20162": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-20164": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2022-20165": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-20166": {"epss_score": 0.00017, "epss_percentile": 0.03253}, "CVE-2022-20167": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2022-20168": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2022-20169": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20170": {"epss_score": 0.00164, "epss_percentile": 0.37965}, "CVE-2022-20171": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2022-20172": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20173": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2022-20174": {"epss_score": 0.00055, "epss_percentile": 0.1749}, "CVE-2022-20175": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20176": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2022-20177": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20178": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-20179": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20180": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20181": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2022-20182": {"epss_score": 0.00015, "epss_percentile": 0.02227}, "CVE-2022-20183": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-20184": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20185": {"epss_score": 0.00017, "epss_percentile": 0.03274}, "CVE-2022-20186": {"epss_score": 0.02514, "epss_percentile": 0.84979}, "CVE-2022-20188": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20190": {"epss_score": 0.00118, "epss_percentile": 0.31384}, "CVE-2022-20191": {"epss_score": 0.00129, "epss_percentile": 0.33177}, "CVE-2022-20192": {"epss_score": 0.00013, "epss_percentile": 0.01556}, "CVE-2022-20193": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2022-20194": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2022-20195": {"epss_score": 0.00015, "epss_percentile": 0.02363}, "CVE-2022-20196": {"epss_score": 0.00017, "epss_percentile": 0.03491}, "CVE-2022-20197": {"epss_score": 0.00013, "epss_percentile": 0.01556}, "CVE-2022-20198": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2022-20199": {"epss_score": 0.00038, "epss_percentile": 0.11135}, "CVE-2022-20200": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20201": {"epss_score": 0.00012, "epss_percentile": 0.01265}, "CVE-2022-20202": {"epss_score": 0.0041, "epss_percentile": 0.60825}, "CVE-2022-20203": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2022-20204": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20205": {"epss_score": 0.00017, "epss_percentile": 0.03087}, "CVE-2022-20206": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20207": {"epss_score": 0.0003, "epss_percentile": 0.08095}, "CVE-2022-20208": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2022-20209": {"epss_score": 0.00333, "epss_percentile": 0.55647}, "CVE-2022-20210": {"epss_score": 0.00142, "epss_percentile": 0.3497}, "CVE-2022-20212": {"epss_score": 0.00015, "epss_percentile": 0.02548}, "CVE-2022-20213": {"epss_score": 0.00044, "epss_percentile": 0.13412}, "CVE-2022-20214": {"epss_score": 0.0009, "epss_percentile": 0.25992}, "CVE-2022-20215": {"epss_score": 0.00044, "epss_percentile": 0.13412}, "CVE-2022-20216": {"epss_score": 0.00127, "epss_percentile": 0.32808}, "CVE-2022-20217": {"epss_score": 0.00116, "epss_percentile": 0.3104}, "CVE-2022-20218": {"epss_score": 0.00013, "epss_percentile": 0.0162}, "CVE-2022-20219": {"epss_score": 9e-05, "epss_percentile": 0.00694}, "CVE-2022-20220": {"epss_score": 0.00013, "epss_percentile": 0.01709}, "CVE-2022-20221": {"epss_score": 0.00084, "epss_percentile": 0.25017}, "CVE-2022-20222": {"epss_score": 0.00873, "epss_percentile": 0.74748}, "CVE-2022-20223": {"epss_score": 0.00021, "epss_percentile": 0.04727}, "CVE-2022-20224": {"epss_score": 0.01499, "epss_percentile": 0.80706}, "CVE-2022-20225": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20226": {"epss_score": 0.00015, "epss_percentile": 0.02343}, "CVE-2022-20227": {"epss_score": 0.00063, "epss_percentile": 0.19999}, "CVE-2022-20228": {"epss_score": 0.00265, "epss_percentile": 0.49782}, "CVE-2022-20229": {"epss_score": 0.12488, "epss_percentile": 0.93688}, "CVE-2022-20230": {"epss_score": 0.0001, "epss_percentile": 0.00902}, "CVE-2022-20231": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20233": {"epss_score": 0.00026, "epss_percentile": 0.06401}, "CVE-2022-20234": {"epss_score": 0.00114, "epss_percentile": 0.30879}, "CVE-2022-20235": {"epss_score": 0.00066, "epss_percentile": 0.20698}, "CVE-2022-20236": {"epss_score": 0.00135, "epss_percentile": 0.34043}, "CVE-2022-20237": {"epss_score": 0.00646, "epss_percentile": 0.70144}, "CVE-2022-20238": {"epss_score": 0.00173, "epss_percentile": 0.39133}, "CVE-2022-20239": {"epss_score": 0.00073, "epss_percentile": 0.22637}, "CVE-2022-20240": {"epss_score": 0.00015, "epss_percentile": 0.02389}, "CVE-2022-20241": {"epss_score": 0.00016, "epss_percentile": 0.02801}, "CVE-2022-20242": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20243": {"epss_score": 9e-05, "epss_percentile": 0.00638}, "CVE-2022-20244": {"epss_score": 0.00032, "epss_percentile": 0.08995}, "CVE-2022-20245": {"epss_score": 0.00025, "epss_percentile": 0.06044}, "CVE-2022-20246": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20247": {"epss_score": 0.00257, "epss_percentile": 0.48863}, "CVE-2022-20248": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20249": {"epss_score": 0.00014, "epss_percentile": 0.01799}, "CVE-2022-20250": {"epss_score": 0.00016, "epss_percentile": 0.02757}, "CVE-2022-20251": {"epss_score": 0.00014, "epss_percentile": 0.01799}, "CVE-2022-20252": {"epss_score": 0.00014, "epss_percentile": 0.01799}, "CVE-2022-20253": {"epss_score": 0.00136, "epss_percentile": 0.34142}, "CVE-2022-20254": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-20255": {"epss_score": 0.00015, "epss_percentile": 0.02194}, "CVE-2022-20256": {"epss_score": 0.00011, "epss_percentile": 0.01089}, "CVE-2022-20257": {"epss_score": 0.00018, "epss_percentile": 0.03527}, "CVE-2022-20258": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20259": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20260": {"epss_score": 0.00017, "epss_percentile": 0.03305}, "CVE-2022-20261": {"epss_score": 0.00013, "epss_percentile": 0.01671}, "CVE-2022-20262": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2022-20263": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20264": {"epss_score": 0.00017, "epss_percentile": 0.03132}, "CVE-2022-20265": {"epss_score": 0.00022, "epss_percentile": 0.05168}, "CVE-2022-20266": {"epss_score": 0.00018, "epss_percentile": 0.03604}, "CVE-2022-20267": {"epss_score": 0.00015, "epss_percentile": 0.02535}, "CVE-2022-20268": {"epss_score": 0.00014, "epss_percentile": 0.01833}, "CVE-2022-20269": {"epss_score": 0.00033, "epss_percentile": 0.09378}, "CVE-2022-20270": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20271": {"epss_score": 0.00014, "epss_percentile": 0.01769}, "CVE-2022-20272": {"epss_score": 0.0002, "epss_percentile": 0.04467}, "CVE-2022-20273": {"epss_score": 0.00081, "epss_percentile": 0.24209}, "CVE-2022-20274": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20275": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20276": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20277": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20278": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20279": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20280": {"epss_score": 0.00047, "epss_percentile": 0.14871}, "CVE-2022-20281": {"epss_score": 0.00028, "epss_percentile": 0.07583}, "CVE-2022-20282": {"epss_score": 0.00015, "epss_percentile": 0.02548}, "CVE-2022-20283": {"epss_score": 0.00164, "epss_percentile": 0.37985}, "CVE-2022-20284": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20285": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20286": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20287": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20288": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20289": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20290": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20291": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20292": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20293": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20294": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20295": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20296": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20297": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20298": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20299": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20300": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20301": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20302": {"epss_score": 0.00032, "epss_percentile": 0.08995}, "CVE-2022-20303": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20304": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20305": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2022-20306": {"epss_score": 0.00017, "epss_percentile": 0.03274}, "CVE-2022-20307": {"epss_score": 0.00014, "epss_percentile": 0.01799}, "CVE-2022-20308": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2022-20309": {"epss_score": 0.00014, "epss_percentile": 0.01799}, "CVE-2022-20310": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2022-20311": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2022-20312": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20313": {"epss_score": 0.00033, "epss_percentile": 0.09378}, "CVE-2022-20314": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-20315": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2022-20316": {"epss_score": 0.00014, "epss_percentile": 0.01799}, "CVE-2022-20317": {"epss_score": 0.00018, "epss_percentile": 0.03961}, "CVE-2022-20318": {"epss_score": 0.00014, "epss_percentile": 0.01799}, "CVE-2022-20319": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20320": {"epss_score": 0.00014, "epss_percentile": 0.01799}, "CVE-2022-20321": {"epss_score": 0.00015, "epss_percentile": 0.02167}, "CVE-2022-20322": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20323": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20324": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20325": {"epss_score": 0.00019, "epss_percentile": 0.04137}, "CVE-2022-20326": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20327": {"epss_score": 0.00013, "epss_percentile": 0.01474}, "CVE-2022-20328": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2022-20329": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2022-20330": {"epss_score": 0.00024, "epss_percentile": 0.0581}, "CVE-2022-20331": {"epss_score": 0.00015, "epss_percentile": 0.02548}, "CVE-2022-20332": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20333": {"epss_score": 0.00159, "epss_percentile": 0.37321}, "CVE-2022-20334": {"epss_score": 0.00137, "epss_percentile": 0.34212}, "CVE-2022-20335": {"epss_score": 0.00015, "epss_percentile": 0.02535}, "CVE-2022-20336": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2022-20338": {"epss_score": 0.00085, "epss_percentile": 0.25127}, "CVE-2022-20339": {"epss_score": 0.00016, "epss_percentile": 0.02801}, "CVE-2022-20340": {"epss_score": 0.00014, "epss_percentile": 0.01905}, "CVE-2022-20341": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2022-20342": {"epss_score": 0.00016, "epss_percentile": 0.02801}, "CVE-2022-20344": {"epss_score": 0.00012, "epss_percentile": 0.01428}, "CVE-2022-20345": {"epss_score": 0.00772, "epss_percentile": 0.73031}, "CVE-2022-20346": {"epss_score": 0.00567, "epss_percentile": 0.6785}, "CVE-2022-20347": {"epss_score": 0.00667, "epss_percentile": 0.70703}, "CVE-2022-20348": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20349": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20350": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20351": {"epss_score": 0.00052, "epss_percentile": 0.16622}, "CVE-2022-20352": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20353": {"epss_score": 0.00036, "epss_percentile": 0.10491}, "CVE-2022-20354": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20355": {"epss_score": 0.00044, "epss_percentile": 0.136}, "CVE-2022-20356": {"epss_score": 0.0002, "epss_percentile": 0.04512}, "CVE-2022-20357": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20358": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2022-20360": {"epss_score": 0.00015, "epss_percentile": 0.0227}, "CVE-2022-20361": {"epss_score": 0.01481, "epss_percentile": 0.8057}, "CVE-2022-20362": {"epss_score": 0.00164, "epss_percentile": 0.37985}, "CVE-2022-20364": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20365": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2022-20366": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20367": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-20368": {"epss_score": 0.00072, "epss_percentile": 0.22351}, "CVE-2022-20369": {"epss_score": 0.00032, "epss_percentile": 0.09089}, "CVE-2022-20370": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20371": {"epss_score": 0.00015, "epss_percentile": 0.02315}, "CVE-2022-20372": {"epss_score": 0.00015, "epss_percentile": 0.0216}, "CVE-2022-20373": {"epss_score": 0.00013, "epss_percentile": 0.01646}, "CVE-2022-20375": {"epss_score": 0.00499, "epss_percentile": 0.65268}, "CVE-2022-20376": {"epss_score": 0.00013, "epss_percentile": 0.01646}, "CVE-2022-20377": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-20378": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2022-20379": {"epss_score": 0.00017, "epss_percentile": 0.03274}, "CVE-2022-20380": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20381": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2022-20382": {"epss_score": 0.00017, "epss_percentile": 0.03446}, "CVE-2022-20383": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20384": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2022-20385": {"epss_score": 0.00192, "epss_percentile": 0.41312}, "CVE-2022-20386": {"epss_score": 0.00192, "epss_percentile": 0.41312}, "CVE-2022-20387": {"epss_score": 0.00192, "epss_percentile": 0.41312}, "CVE-2022-20388": {"epss_score": 0.00192, "epss_percentile": 0.41312}, "CVE-2022-20389": {"epss_score": 0.00192, "epss_percentile": 0.41312}, "CVE-2022-20390": {"epss_score": 0.00192, "epss_percentile": 0.41312}, "CVE-2022-20391": {"epss_score": 0.00192, "epss_percentile": 0.41312}, "CVE-2022-20392": {"epss_score": 0.00061, "epss_percentile": 0.19448}, "CVE-2022-20393": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20394": {"epss_score": 0.00016, "epss_percentile": 0.02914}, "CVE-2022-20395": {"epss_score": 0.00012, "epss_percentile": 0.01164}, "CVE-2022-20396": {"epss_score": 7e-05, "epss_percentile": 0.00431}, "CVE-2022-20397": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20398": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2022-20399": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20400": {"epss_score": 0.00646, "epss_percentile": 0.70144}, "CVE-2022-20401": {"epss_score": 0.00345, "epss_percentile": 0.56587}, "CVE-2022-20402": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2022-20403": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2022-20404": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20405": {"epss_score": 0.0013, "epss_percentile": 0.33288}, "CVE-2022-20406": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20407": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2022-20408": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20409": {"epss_score": 0.05613, "epss_percentile": 0.90049}, "CVE-2022-20410": {"epss_score": 0.00241, "epss_percentile": 0.47239}, "CVE-2022-20411": {"epss_score": 0.05585, "epss_percentile": 0.90023}, "CVE-2022-20412": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20413": {"epss_score": 0.00034, "epss_percentile": 0.09618}, "CVE-2022-20414": {"epss_score": 0.00015, "epss_percentile": 0.0246}, "CVE-2022-20415": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20416": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20417": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20418": {"epss_score": 0.00784, "epss_percentile": 0.7323}, "CVE-2022-20419": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20420": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20421": {"epss_score": 0.06464, "epss_percentile": 0.90772}, "CVE-2022-20422": {"epss_score": 0.00033, "epss_percentile": 0.09331}, "CVE-2022-20423": {"epss_score": 0.00055, "epss_percentile": 0.17491}, "CVE-2022-20425": {"epss_score": 0.00044, "epss_percentile": 0.136}, "CVE-2022-20426": {"epss_score": 0.00041, "epss_percentile": 0.12382}, "CVE-2022-20427": {"epss_score": 0.0001, "epss_percentile": 0.00856}, "CVE-2022-20428": {"epss_score": 0.00014, "epss_percentile": 0.01849}, "CVE-2022-20429": {"epss_score": 0.00032, "epss_percentile": 0.08995}, "CVE-2022-20430": {"epss_score": 0.00013, "epss_percentile": 0.01659}, "CVE-2022-20431": {"epss_score": 0.00013, "epss_percentile": 0.01659}, "CVE-2022-20432": {"epss_score": 0.00013, "epss_percentile": 0.01659}, "CVE-2022-20433": {"epss_score": 0.00013, "epss_percentile": 0.01659}, "CVE-2022-20434": {"epss_score": 0.00013, "epss_percentile": 0.01659}, "CVE-2022-20435": {"epss_score": 0.00013, "epss_percentile": 0.01659}, "CVE-2022-20436": {"epss_score": 0.00013, "epss_percentile": 0.01659}, "CVE-2022-20437": {"epss_score": 0.00024, "epss_percentile": 0.05678}, "CVE-2022-20438": {"epss_score": 0.00024, "epss_percentile": 0.05678}, "CVE-2022-20439": {"epss_score": 0.00024, "epss_percentile": 0.05678}, "CVE-2022-20440": {"epss_score": 0.0002, "epss_percentile": 0.04627}, "CVE-2022-20441": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20442": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2022-20443": {"epss_score": 5e-05, "epss_percentile": 0.00204}, "CVE-2022-20445": {"epss_score": 0.00241, "epss_percentile": 0.47239}, "CVE-2022-20446": {"epss_score": 0.00015, "epss_percentile": 0.02535}, "CVE-2022-20447": {"epss_score": 0.00083, "epss_percentile": 0.24601}, "CVE-2022-20448": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2022-20449": {"epss_score": 0.00042, "epss_percentile": 0.12746}, "CVE-2022-20450": {"epss_score": 0.00012, "epss_percentile": 0.01281}, "CVE-2022-20451": {"epss_score": 0.00012, "epss_percentile": 0.01282}, "CVE-2022-20452": {"epss_score": 0.0033, "epss_percentile": 0.55453}, "CVE-2022-20453": {"epss_score": 0.0001, "epss_percentile": 0.00872}, "CVE-2022-20454": {"epss_score": 0.00015, "epss_percentile": 0.02285}, "CVE-2022-20455": {"epss_score": 0.00025, "epss_percentile": 0.06241}, "CVE-2022-20456": {"epss_score": 0.00025, "epss_percentile": 0.06359}, "CVE-2022-20457": {"epss_score": 0.00017, "epss_percentile": 0.03137}, "CVE-2022-20458": {"epss_score": 0.00089, "epss_percentile": 0.25876}, "CVE-2022-20459": {"epss_score": 0.00011, "epss_percentile": 0.00966}, "CVE-2022-20460": {"epss_score": 0.00012, "epss_percentile": 0.01427}, "CVE-2022-20461": {"epss_score": 0.00047, "epss_percentile": 0.14882}, "CVE-2022-20462": {"epss_score": 0.00039, "epss_percentile": 0.11713}, "CVE-2022-20464": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20465": {"epss_score": 0.00034, "epss_percentile": 0.09758}, "CVE-2022-20466": {"epss_score": 0.00029, "epss_percentile": 0.07862}, "CVE-2022-20467": {"epss_score": 0.00016, "epss_percentile": 0.02805}, "CVE-2022-20468": {"epss_score": 0.00058, "epss_percentile": 0.18537}, "CVE-2022-20469": {"epss_score": 0.0004, "epss_percentile": 0.12148}, "CVE-2022-20470": {"epss_score": 0.00016, "epss_percentile": 0.03034}, "CVE-2022-20471": {"epss_score": 0.00031, "epss_percentile": 0.08694}, "CVE-2022-20472": {"epss_score": 0.05452, "epss_percentile": 0.89893}, "CVE-2022-20473": {"epss_score": 0.51519, "epss_percentile": 0.97783}, "CVE-2022-20474": {"epss_score": 0.0025, "epss_percentile": 0.48128}, "CVE-2022-20475": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20476": {"epss_score": 0.0003, "epss_percentile": 0.08019}, "CVE-2022-20477": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20478": {"epss_score": 0.00031, "epss_percentile": 0.08643}, "CVE-2022-20479": {"epss_score": 0.00031, "epss_percentile": 0.08643}, "CVE-2022-20480": {"epss_score": 0.00031, "epss_percentile": 0.08643}, "CVE-2022-20481": {"epss_score": 0.00018, "epss_percentile": 0.03611}, "CVE-2022-20482": {"epss_score": 0.00015, "epss_percentile": 0.0246}, "CVE-2022-20483": {"epss_score": 0.00404, "epss_percentile": 0.60428}, "CVE-2022-20484": {"epss_score": 0.00031, "epss_percentile": 0.08643}, "CVE-2022-20485": {"epss_score": 0.00031, "epss_percentile": 0.08643}, "CVE-2022-20486": {"epss_score": 0.00031, "epss_percentile": 0.08643}, "CVE-2022-20487": {"epss_score": 0.00031, "epss_percentile": 0.08643}, "CVE-2022-20488": {"epss_score": 0.00014, "epss_percentile": 0.01833}, "CVE-2022-20489": {"epss_score": 0.00029, "epss_percentile": 0.07777}, "CVE-2022-20490": {"epss_score": 0.00029, "epss_percentile": 0.07777}, "CVE-2022-20491": {"epss_score": 0.00031, "epss_percentile": 0.08643}, "CVE-2022-20492": {"epss_score": 0.00029, "epss_percentile": 0.07777}, "CVE-2022-20493": {"epss_score": 0.00033, "epss_percentile": 0.09165}, "CVE-2022-20494": {"epss_score": 0.0107, "epss_percentile": 0.77259}, "CVE-2022-20495": {"epss_score": 0.00043, "epss_percentile": 0.13306}, "CVE-2022-20496": {"epss_score": 0.0003, "epss_percentile": 0.08195}, "CVE-2022-20497": {"epss_score": 0.00031, "epss_percentile": 0.08537}, "CVE-2022-20498": {"epss_score": 0.00213, "epss_percentile": 0.43906}, "CVE-2022-20499": {"epss_score": 0.00031, "epss_percentile": 0.08542}, "CVE-2022-20500": {"epss_score": 0.00039, "epss_percentile": 0.11454}, "CVE-2022-20501": {"epss_score": 0.00032, "epss_percentile": 0.08848}, "CVE-2022-20502": {"epss_score": 0.00039, "epss_percentile": 0.11539}, "CVE-2022-20503": {"epss_score": 0.00032, "epss_percentile": 0.08848}, "CVE-2022-20504": {"epss_score": 0.00025, "epss_percentile": 0.06353}, "CVE-2022-20505": {"epss_score": 0.00018, "epss_percentile": 0.03524}, "CVE-2022-20506": {"epss_score": 0.00025, "epss_percentile": 0.06251}, "CVE-2022-20507": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20508": {"epss_score": 0.00014, "epss_percentile": 0.02057}, "CVE-2022-20509": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20510": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2022-20511": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-20512": {"epss_score": 0.00037, "epss_percentile": 0.1063}, "CVE-2022-20513": {"epss_score": 0.00052, "epss_percentile": 0.16438}, "CVE-2022-20514": {"epss_score": 0.00019, "epss_percentile": 0.04322}, "CVE-2022-20515": {"epss_score": 0.0004, "epss_percentile": 0.11907}, "CVE-2022-20516": {"epss_score": 0.00975, "epss_percentile": 0.76204}, "CVE-2022-20517": {"epss_score": 0.00031, "epss_percentile": 0.08711}, "CVE-2022-20518": {"epss_score": 0.00031, "epss_percentile": 0.08711}, "CVE-2022-20519": {"epss_score": 0.00015, "epss_percentile": 0.02535}, "CVE-2022-20520": {"epss_score": 0.00045, "epss_percentile": 0.13787}, "CVE-2022-20521": {"epss_score": 0.00063, "epss_percentile": 0.19978}, "CVE-2022-20522": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20523": {"epss_score": 0.00018, "epss_percentile": 0.04045}, "CVE-2022-20524": {"epss_score": 0.00019, "epss_percentile": 0.04137}, "CVE-2022-20525": {"epss_score": 7e-05, "epss_percentile": 0.00366}, "CVE-2022-20526": {"epss_score": 0.00016, "epss_percentile": 0.0291}, "CVE-2022-20527": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20528": {"epss_score": 0.00062, "epss_percentile": 0.19741}, "CVE-2022-20529": {"epss_score": 0.00025, "epss_percentile": 0.06277}, "CVE-2022-20530": {"epss_score": 0.00272, "epss_percentile": 0.50352}, "CVE-2022-20531": {"epss_score": 0.00026, "epss_percentile": 0.06522}, "CVE-2022-20532": {"epss_score": 0.01103, "epss_percentile": 0.7759}, "CVE-2022-20533": {"epss_score": 0.00031, "epss_percentile": 0.08339}, "CVE-2022-20535": {"epss_score": 0.00014, "epss_percentile": 0.01799}, "CVE-2022-20536": {"epss_score": 0.00015, "epss_percentile": 0.02535}, "CVE-2022-20537": {"epss_score": 0.00046, "epss_percentile": 0.14285}, "CVE-2022-20538": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2022-20539": {"epss_score": 0.00028, "epss_percentile": 0.07242}, "CVE-2022-20540": {"epss_score": 0.00019, "epss_percentile": 0.04137}, "CVE-2022-20541": {"epss_score": 0.00038, "epss_percentile": 0.11282}, "CVE-2022-20542": {"epss_score": 0.00016, "epss_percentile": 0.02659}, "CVE-2022-20543": {"epss_score": 0.00017, "epss_percentile": 0.03197}, "CVE-2022-20544": {"epss_score": 7e-05, "epss_percentile": 0.00403}, "CVE-2022-20545": {"epss_score": 0.00586, "epss_percentile": 0.68439}, "CVE-2022-20546": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-20547": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-20548": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20549": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20550": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-20551": {"epss_score": 0.00019, "epss_percentile": 0.04064}, "CVE-2022-20552": {"epss_score": 0.00055, "epss_percentile": 0.17618}, "CVE-2022-20553": {"epss_score": 0.00015, "epss_percentile": 0.02428}, "CVE-2022-20554": {"epss_score": 0.00019, "epss_percentile": 0.04322}, "CVE-2022-20555": {"epss_score": 0.00043, "epss_percentile": 0.13001}, "CVE-2022-20556": {"epss_score": 0.00015, "epss_percentile": 0.02535}, "CVE-2022-20557": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20558": {"epss_score": 0.00013, "epss_percentile": 0.01613}, "CVE-2022-20559": {"epss_score": 0.00014, "epss_percentile": 0.01799}, "CVE-2022-20560": {"epss_score": 0.00153, "epss_percentile": 0.36528}, "CVE-2022-20561": {"epss_score": 0.00019, "epss_percentile": 0.04137}, "CVE-2022-20562": {"epss_score": 0.00016, "epss_percentile": 0.02801}, "CVE-2022-20563": {"epss_score": 0.00051, "epss_percentile": 0.16243}, "CVE-2022-20564": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20566": {"epss_score": 0.00019, "epss_percentile": 0.04276}, "CVE-2022-20567": {"epss_score": 0.00012, "epss_percentile": 0.01356}, "CVE-2022-20568": {"epss_score": 0.00019, "epss_percentile": 0.04114}, "CVE-2022-20569": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20570": {"epss_score": 0.00021, "epss_percentile": 0.04713}, "CVE-2022-20571": {"epss_score": 0.0004, "epss_percentile": 0.12054}, "CVE-2022-20572": {"epss_score": 0.00014, "epss_percentile": 0.01802}, "CVE-2022-20574": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20575": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20576": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20577": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20578": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20579": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20580": {"epss_score": 0.00039, "epss_percentile": 0.11691}, "CVE-2022-20581": {"epss_score": 0.00019, "epss_percentile": 0.04322}, "CVE-2022-20582": {"epss_score": 0.00039, "epss_percentile": 0.11713}, "CVE-2022-20583": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20584": {"epss_score": 0.00037, "epss_percentile": 0.1063}, "CVE-2022-20585": {"epss_score": 0.00037, "epss_percentile": 0.1063}, "CVE-2022-20586": {"epss_score": 0.00037, "epss_percentile": 0.1063}, "CVE-2022-20587": {"epss_score": 0.00037, "epss_percentile": 0.1063}, "CVE-2022-20588": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20589": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-20590": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20591": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20592": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20593": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-20594": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20595": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-20596": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20597": {"epss_score": 0.00037, "epss_percentile": 0.1063}, "CVE-2022-20598": {"epss_score": 0.00037, "epss_percentile": 0.1063}, "CVE-2022-20599": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-20600": {"epss_score": 0.00037, "epss_percentile": 0.1063}, "CVE-2022-20601": {"epss_score": 0.00123, "epss_percentile": 0.32286}, "CVE-2022-20602": {"epss_score": 0.00153, "epss_percentile": 0.36528}, "CVE-2022-20603": {"epss_score": 0.0067, "epss_percentile": 0.70788}, "CVE-2022-20604": {"epss_score": 0.00041, "epss_percentile": 0.12232}, "CVE-2022-20605": {"epss_score": 0.0026, "epss_percentile": 0.49181}, "CVE-2022-20606": {"epss_score": 0.0027, "epss_percentile": 0.50215}, "CVE-2022-20607": {"epss_score": 0.061, "epss_percentile": 0.9048}, "CVE-2022-20608": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20609": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-20610": {"epss_score": 0.02721, "epss_percentile": 0.85517}, "CVE-2022-20611": {"epss_score": 0.00014, "epss_percentile": 0.02057}, "CVE-2022-20612": {"epss_score": 0.00173, "epss_percentile": 0.39068}, "CVE-2022-20613": {"epss_score": 0.00156, "epss_percentile": 0.36977}, "CVE-2022-20614": {"epss_score": 0.00215, "epss_percentile": 0.44072}, "CVE-2022-20615": {"epss_score": 0.12783, "epss_percentile": 0.93772}, "CVE-2022-20616": {"epss_score": 0.00069, "epss_percentile": 0.2143}, "CVE-2022-20617": {"epss_score": 0.01238, "epss_percentile": 0.78792}, "CVE-2022-20618": {"epss_score": 0.00093, "epss_percentile": 0.26686}, "CVE-2022-20619": {"epss_score": 0.00391, "epss_percentile": 0.59567}, "CVE-2022-20620": {"epss_score": 0.00081, "epss_percentile": 0.24257}, "CVE-2022-20621": {"epss_score": 0.00032, "epss_percentile": 0.09041}, "CVE-2022-20622": {"epss_score": 0.01875, "epss_percentile": 0.82655}, "CVE-2022-20623": {"epss_score": 0.13087, "epss_percentile": 0.9387}, "CVE-2022-20624": {"epss_score": 0.04487, "epss_percentile": 0.88751}, "CVE-2022-20625": {"epss_score": 0.02776, "epss_percentile": 0.85637}, "CVE-2022-20626": {"epss_score": 0.00073, "epss_percentile": 0.22541}, "CVE-2022-20627": {"epss_score": 0.00192, "epss_percentile": 0.41359}, "CVE-2022-20628": {"epss_score": 0.00294, "epss_percentile": 0.52422}, "CVE-2022-20629": {"epss_score": 0.00192, "epss_percentile": 0.41359}, "CVE-2022-20630": {"epss_score": 0.00058, "epss_percentile": 0.18599}, "CVE-2022-20631": {"epss_score": 0.00279, "epss_percentile": 0.50995}, "CVE-2022-20632": {"epss_score": 0.00327, "epss_percentile": 0.55124}, "CVE-2022-20633": {"epss_score": 0.00198, "epss_percentile": 0.42017}, "CVE-2022-20634": {"epss_score": 0.00086, "epss_percentile": 0.25287}, "CVE-2022-20635": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2022-20636": {"epss_score": 0.00173, "epss_percentile": 0.39051}, "CVE-2022-20637": {"epss_score": 0.00173, "epss_percentile": 0.39051}, "CVE-2022-20638": {"epss_score": 0.00173, "epss_percentile": 0.39051}, "CVE-2022-20639": {"epss_score": 0.00173, "epss_percentile": 0.39051}, "CVE-2022-20640": {"epss_score": 0.00173, "epss_percentile": 0.39051}, "CVE-2022-20641": {"epss_score": 0.0016, "epss_percentile": 0.37437}, "CVE-2022-20642": {"epss_score": 0.00173, "epss_percentile": 0.39051}, "CVE-2022-20643": {"epss_score": 0.00173, "epss_percentile": 0.39051}, "CVE-2022-20644": {"epss_score": 0.00173, "epss_percentile": 0.39051}, "CVE-2022-20645": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2022-20646": {"epss_score": 0.00153, "epss_percentile": 0.36591}, "CVE-2022-20647": {"epss_score": 0.00234, "epss_percentile": 0.46198}, "CVE-2022-20648": {"epss_score": 0.00168, "epss_percentile": 0.38476}, "CVE-2022-20649": {"epss_score": 0.12511, "epss_percentile": 0.93702}, "CVE-2022-20650": {"epss_score": 0.08874, "epss_percentile": 0.92297}, "CVE-2022-20651": {"epss_score": 0.00023, "epss_percentile": 0.05439}, "CVE-2022-20652": {"epss_score": 0.00092, "epss_percentile": 0.26415}, "CVE-2022-20653": {"epss_score": 0.00983, "epss_percentile": 0.7631}, "CVE-2022-20654": {"epss_score": 0.00214, "epss_percentile": 0.44018}, "CVE-2022-20655": {"epss_score": 0.00295, "epss_percentile": 0.52442}, "CVE-2022-20656": {"epss_score": 0.00176, "epss_percentile": 0.39382}, "CVE-2022-20657": {"epss_score": 0.00178, "epss_percentile": 0.39726}, "CVE-2022-20658": {"epss_score": 0.00264, "epss_percentile": 0.49696}, "CVE-2022-20659": {"epss_score": 0.00898, "epss_percentile": 0.75149}, "CVE-2022-20660": {"epss_score": 0.00086, "epss_percentile": 0.25351}, "CVE-2022-20661": {"epss_score": 0.00329, "epss_percentile": 0.55386}, "CVE-2022-20662": {"epss_score": 0.0015, "epss_percentile": 0.36134}, "CVE-2022-20663": {"epss_score": 0.00105, "epss_percentile": 0.29269}, "CVE-2022-20664": {"epss_score": 0.00374, "epss_percentile": 0.5859}, "CVE-2022-20665": {"epss_score": 0.00152, "epss_percentile": 0.36442}, "CVE-2022-20666": {"epss_score": 0.00217, "epss_percentile": 0.44287}, "CVE-2022-20667": {"epss_score": 0.00217, "epss_percentile": 0.44287}, "CVE-2022-20668": {"epss_score": 0.00217, "epss_percentile": 0.44287}, "CVE-2022-20669": {"epss_score": 0.00217, "epss_percentile": 0.44287}, "CVE-2022-20670": {"epss_score": 0.00217, "epss_percentile": 0.44287}, "CVE-2022-20671": {"epss_score": 0.00142, "epss_percentile": 0.3499}, "CVE-2022-20672": {"epss_score": 0.00217, "epss_percentile": 0.44287}, "CVE-2022-20673": {"epss_score": 0.00142, "epss_percentile": 0.3499}, "CVE-2022-20674": {"epss_score": 0.00217, "epss_percentile": 0.44287}, "CVE-2022-20675": {"epss_score": 0.01273, "epss_percentile": 0.79088}, "CVE-2022-20676": {"epss_score": 0.0006, "epss_percentile": 0.19092}, "CVE-2022-20677": {"epss_score": 0.0016, "epss_percentile": 0.37503}, "CVE-2022-20678": {"epss_score": 0.0029, "epss_percentile": 0.52116}, "CVE-2022-20679": {"epss_score": 0.00735, "epss_percentile": 0.72288}, "CVE-2022-20680": {"epss_score": 0.0032, "epss_percentile": 0.54576}, "CVE-2022-20681": {"epss_score": 0.00116, "epss_percentile": 0.31078}, "CVE-2022-20682": {"epss_score": 0.00957, "epss_percentile": 0.75928}, "CVE-2022-20683": {"epss_score": 0.0057, "epss_percentile": 0.67939}, "CVE-2022-20684": {"epss_score": 0.00275, "epss_percentile": 0.50683}, "CVE-2022-20685": {"epss_score": 0.00503, "epss_percentile": 0.65444}, "CVE-2022-20686": {"epss_score": 0.00813, "epss_percentile": 0.73754}, "CVE-2022-20687": {"epss_score": 0.00813, "epss_percentile": 0.73754}, "CVE-2022-20688": {"epss_score": 0.0067, "epss_percentile": 0.70785}, "CVE-2022-20689": {"epss_score": 0.00398, "epss_percentile": 0.6007}, "CVE-2022-20690": {"epss_score": 0.00171, "epss_percentile": 0.38805}, "CVE-2022-20691": {"epss_score": 0.00542, "epss_percentile": 0.67084}, "CVE-2022-20692": {"epss_score": 0.00715, "epss_percentile": 0.71838}, "CVE-2022-20693": {"epss_score": 0.0241, "epss_percentile": 0.84663}, "CVE-2022-20694": {"epss_score": 0.0036, "epss_percentile": 0.57621}, "CVE-2022-20695": {"epss_score": 0.01464, "epss_percentile": 0.80449}, "CVE-2022-20696": {"epss_score": 0.00292, "epss_percentile": 0.52229}, "CVE-2022-20697": {"epss_score": 0.00447, "epss_percentile": 0.62965}, "CVE-2022-20698": {"epss_score": 0.00224, "epss_percentile": 0.45045}, "CVE-2022-20699": {"epss_score": 0.89409, "epss_percentile": 0.99525}, "CVE-2022-20700": {"epss_score": 0.2175, "epss_percentile": 0.95554}, "CVE-2022-20701": {"epss_score": 0.06078, "epss_percentile": 0.9046}, "CVE-2022-20702": {"epss_score": 0.02714, "epss_percentile": 0.85505}, "CVE-2022-20703": {"epss_score": 0.02001, "epss_percentile": 0.83221}, "CVE-2022-20704": {"epss_score": 0.00928, "epss_percentile": 0.75586}, "CVE-2022-20705": {"epss_score": 0.80463, "epss_percentile": 0.9909}, "CVE-2022-20706": {"epss_score": 0.02554, "epss_percentile": 0.85089}, "CVE-2022-20707": {"epss_score": 0.79949, "epss_percentile": 0.99065}, "CVE-2022-20708": {"epss_score": 0.13015, "epss_percentile": 0.93846}, "CVE-2022-20709": {"epss_score": 0.00529, "epss_percentile": 0.66587}, "CVE-2022-20710": {"epss_score": 0.01726, "epss_percentile": 0.81965}, "CVE-2022-20711": {"epss_score": 0.0236, "epss_percentile": 0.84493}, "CVE-2022-20712": {"epss_score": 0.02182, "epss_percentile": 0.83905}, "CVE-2022-20713": {"epss_score": 0.01521, "epss_percentile": 0.80829}, "CVE-2022-20714": {"epss_score": 0.01834, "epss_percentile": 0.82462}, "CVE-2022-20715": {"epss_score": 0.00564, "epss_percentile": 0.67777}, "CVE-2022-20716": {"epss_score": 0.00129, "epss_percentile": 0.33074}, "CVE-2022-20717": {"epss_score": 0.00058, "epss_percentile": 0.18582}, "CVE-2022-20718": {"epss_score": 0.01869, "epss_percentile": 0.82625}, "CVE-2022-20719": {"epss_score": 0.01577, "epss_percentile": 0.81117}, "CVE-2022-20720": {"epss_score": 0.00566, "epss_percentile": 0.67822}, "CVE-2022-20721": {"epss_score": 0.00553, "epss_percentile": 0.67421}, "CVE-2022-20722": {"epss_score": 0.00553, "epss_percentile": 0.67421}, "CVE-2022-20723": {"epss_score": 0.0102, "epss_percentile": 0.76737}, "CVE-2022-20724": {"epss_score": 0.00582, "epss_percentile": 0.68307}, "CVE-2022-20725": {"epss_score": 0.00764, "epss_percentile": 0.72896}, "CVE-2022-20726": {"epss_score": 0.00905, "epss_percentile": 0.75239}, "CVE-2022-20727": {"epss_score": 0.00534, "epss_percentile": 0.66801}, "CVE-2022-20728": {"epss_score": 0.0007, "epss_percentile": 0.2184}, "CVE-2022-20729": {"epss_score": 0.00149, "epss_percentile": 0.35957}, "CVE-2022-20730": {"epss_score": 0.00287, "epss_percentile": 0.5186}, "CVE-2022-20731": {"epss_score": 0.00089, "epss_percentile": 0.25815}, "CVE-2022-20732": {"epss_score": 0.00129, "epss_percentile": 0.33143}, "CVE-2022-20733": {"epss_score": 0.00518, "epss_percentile": 0.6614}, "CVE-2022-20734": {"epss_score": 0.00058, "epss_percentile": 0.18599}, "CVE-2022-20735": {"epss_score": 0.00184, "epss_percentile": 0.40387}, "CVE-2022-20736": {"epss_score": 0.00446, "epss_percentile": 0.62903}, "CVE-2022-20737": {"epss_score": 0.00739, "epss_percentile": 0.72388}, "CVE-2022-20738": {"epss_score": 0.0128, "epss_percentile": 0.79142}, "CVE-2022-20739": {"epss_score": 0.00116, "epss_percentile": 0.31129}, "CVE-2022-20740": {"epss_score": 0.00208, "epss_percentile": 0.43279}, "CVE-2022-20741": {"epss_score": 0.00178, "epss_percentile": 0.39684}, "CVE-2022-20742": {"epss_score": 0.00132, "epss_percentile": 0.33546}, "CVE-2022-20743": {"epss_score": 0.00699, "epss_percentile": 0.71449}, "CVE-2022-20744": {"epss_score": 0.00184, "epss_percentile": 0.40409}, "CVE-2022-20745": {"epss_score": 0.01085, "epss_percentile": 0.77408}, "CVE-2022-20746": {"epss_score": 0.00912, "epss_percentile": 0.75358}, "CVE-2022-20747": {"epss_score": 0.00201, "epss_percentile": 0.42382}, "CVE-2022-20748": {"epss_score": 0.00585, "epss_percentile": 0.68413}, "CVE-2022-20749": {"epss_score": 0.02399, "epss_percentile": 0.84625}, "CVE-2022-20750": {"epss_score": 0.00071, "epss_percentile": 0.22232}, "CVE-2022-20751": {"epss_score": 0.00784, "epss_percentile": 0.73232}, "CVE-2022-20752": {"epss_score": 0.00365, "epss_percentile": 0.58009}, "CVE-2022-20753": {"epss_score": 0.01672, "epss_percentile": 0.81681}, "CVE-2022-20754": {"epss_score": 0.00779, "epss_percentile": 0.73155}, "CVE-2022-20755": {"epss_score": 0.03268, "epss_percentile": 0.86787}, "CVE-2022-20756": {"epss_score": 0.01128, "epss_percentile": 0.77824}, "CVE-2022-20757": {"epss_score": 0.01227, "epss_percentile": 0.78701}, "CVE-2022-20758": {"epss_score": 0.0036, "epss_percentile": 0.57621}, "CVE-2022-20759": {"epss_score": 0.09281, "epss_percentile": 0.92481}, "CVE-2022-20760": {"epss_score": 0.02588, "epss_percentile": 0.85173}, "CVE-2022-20761": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2022-20762": {"epss_score": 0.00046, "epss_percentile": 0.1443}, "CVE-2022-20763": {"epss_score": 0.00479, "epss_percentile": 0.64446}, "CVE-2022-20764": {"epss_score": 0.00376, "epss_percentile": 0.58648}, "CVE-2022-20765": {"epss_score": 0.00161, "epss_percentile": 0.37563}, "CVE-2022-20766": {"epss_score": 0.00256, "epss_percentile": 0.48826}, "CVE-2022-20767": {"epss_score": 0.01349, "epss_percentile": 0.79669}, "CVE-2022-20768": {"epss_score": 0.00214, "epss_percentile": 0.44014}, "CVE-2022-20769": {"epss_score": 0.00054, "epss_percentile": 0.17275}, "CVE-2022-20770": {"epss_score": 0.00861, "epss_percentile": 0.74559}, "CVE-2022-20771": {"epss_score": 0.00983, "epss_percentile": 0.76303}, "CVE-2022-20772": {"epss_score": 0.00401, "epss_percentile": 0.60243}, "CVE-2022-20773": {"epss_score": 0.01234, "epss_percentile": 0.78752}, "CVE-2022-20774": {"epss_score": 0.00252, "epss_percentile": 0.48351}, "CVE-2022-20775": {"epss_score": 0.00136, "epss_percentile": 0.34134}, "CVE-2022-20776": {"epss_score": 0.00289, "epss_percentile": 0.52006}, "CVE-2022-20777": {"epss_score": 0.10677, "epss_percentile": 0.93067}, "CVE-2022-20778": {"epss_score": 0.00139, "epss_percentile": 0.34618}, "CVE-2022-20779": {"epss_score": 0.00516, "epss_percentile": 0.66034}, "CVE-2022-20780": {"epss_score": 0.00388, "epss_percentile": 0.5935}, "CVE-2022-20781": {"epss_score": 0.00178, "epss_percentile": 0.39684}, "CVE-2022-20782": {"epss_score": 0.00172, "epss_percentile": 0.38932}, "CVE-2022-20783": {"epss_score": 0.00408, "epss_percentile": 0.60649}, "CVE-2022-20784": {"epss_score": 0.00527, "epss_percentile": 0.66526}, "CVE-2022-20785": {"epss_score": 0.00938, "epss_percentile": 0.75701}, "CVE-2022-20786": {"epss_score": 0.00177, "epss_percentile": 0.39527}, "CVE-2022-20787": {"epss_score": 0.0008, "epss_percentile": 0.24097}, "CVE-2022-20788": {"epss_score": 0.0032, "epss_percentile": 0.54615}, "CVE-2022-20789": {"epss_score": 0.00854, "epss_percentile": 0.74453}, "CVE-2022-20790": {"epss_score": 0.00637, "epss_percentile": 0.69894}, "CVE-2022-20791": {"epss_score": 0.00512, "epss_percentile": 0.65867}, "CVE-2022-20792": {"epss_score": 0.00147, "epss_percentile": 0.35782}, "CVE-2022-20793": {"epss_score": 0.00101, "epss_percentile": 0.28677}, "CVE-2022-20794": {"epss_score": 0.00224, "epss_percentile": 0.44999}, "CVE-2022-20795": {"epss_score": 0.00433, "epss_percentile": 0.62174}, "CVE-2022-20796": {"epss_score": 0.00029, "epss_percentile": 0.07733}, "CVE-2022-20797": {"epss_score": 0.0061, "epss_percentile": 0.69159}, "CVE-2022-20798": {"epss_score": 0.01312, "epss_percentile": 0.79376}, "CVE-2022-20799": {"epss_score": 0.00865, "epss_percentile": 0.7462}, "CVE-2022-20800": {"epss_score": 0.0032, "epss_percentile": 0.54615}, "CVE-2022-20801": {"epss_score": 0.00865, "epss_percentile": 0.7462}, "CVE-2022-20802": {"epss_score": 0.00178, "epss_percentile": 0.39697}, "CVE-2022-20803": {"epss_score": 0.00232, "epss_percentile": 0.4589}, "CVE-2022-20804": {"epss_score": 0.00101, "epss_percentile": 0.28615}, "CVE-2022-20805": {"epss_score": 0.00034, "epss_percentile": 0.09726}, "CVE-2022-20806": {"epss_score": 0.0028, "epss_percentile": 0.5108}, "CVE-2022-20807": {"epss_score": 0.00326, "epss_percentile": 0.55074}, "CVE-2022-20808": {"epss_score": 0.00557, "epss_percentile": 0.67555}, "CVE-2022-20809": {"epss_score": 0.00634, "epss_percentile": 0.69806}, "CVE-2022-20810": {"epss_score": 0.00191, "epss_percentile": 0.41213}, "CVE-2022-20811": {"epss_score": 0.00525, "epss_percentile": 0.6637}, "CVE-2022-20812": {"epss_score": 0.00188, "epss_percentile": 0.40829}, "CVE-2022-20813": {"epss_score": 0.0015, "epss_percentile": 0.36114}, "CVE-2022-20814": {"epss_score": 0.00091, "epss_percentile": 0.26383}, "CVE-2022-20815": {"epss_score": 0.0032, "epss_percentile": 0.54615}, "CVE-2022-20816": {"epss_score": 0.00712, "epss_percentile": 0.71774}, "CVE-2022-20817": {"epss_score": 0.00891, "epss_percentile": 0.75051}, "CVE-2022-20818": {"epss_score": 0.00761, "epss_percentile": 0.72829}, "CVE-2022-20819": {"epss_score": 0.00172, "epss_percentile": 0.38932}, "CVE-2022-20820": {"epss_score": 0.0017, "epss_percentile": 0.38709}, "CVE-2022-20821": {"epss_score": 0.19129, "epss_percentile": 0.95136}, "CVE-2022-20822": {"epss_score": 0.00467, "epss_percentile": 0.63812}, "CVE-2022-20823": {"epss_score": 0.00641, "epss_percentile": 0.69988}, "CVE-2022-20824": {"epss_score": 0.00139, "epss_percentile": 0.34636}, "CVE-2022-20825": {"epss_score": 0.06382, "epss_percentile": 0.90713}, "CVE-2022-20826": {"epss_score": 0.00295, "epss_percentile": 0.52498}, "CVE-2022-20827": {"epss_score": 0.05842, "epss_percentile": 0.90252}, "CVE-2022-20828": {"epss_score": 0.53036, "epss_percentile": 0.97853}, "CVE-2022-20829": {"epss_score": 0.03438, "epss_percentile": 0.87137}, "CVE-2022-20830": {"epss_score": 0.00274, "epss_percentile": 0.50505}, "CVE-2022-20831": {"epss_score": 0.0019, "epss_percentile": 0.4108}, "CVE-2022-20832": {"epss_score": 0.00168, "epss_percentile": 0.38415}, "CVE-2022-20833": {"epss_score": 0.00168, "epss_percentile": 0.38415}, "CVE-2022-20834": {"epss_score": 0.00168, "epss_percentile": 0.38415}, "CVE-2022-20835": {"epss_score": 0.00168, "epss_percentile": 0.38415}, "CVE-2022-20836": {"epss_score": 0.00168, "epss_percentile": 0.38415}, "CVE-2022-20837": {"epss_score": 0.0095, "epss_percentile": 0.7586}, "CVE-2022-20838": {"epss_score": 0.00168, "epss_percentile": 0.38415}, "CVE-2022-20839": {"epss_score": 0.00168, "epss_percentile": 0.38415}, "CVE-2022-20840": {"epss_score": 0.00168, "epss_percentile": 0.38415}, "CVE-2022-20841": {"epss_score": 0.02893, "epss_percentile": 0.85922}, "CVE-2022-20842": {"epss_score": 0.01037, "epss_percentile": 0.76922}, "CVE-2022-20843": {"epss_score": 0.00168, "epss_percentile": 0.38415}, "CVE-2022-20844": {"epss_score": 0.00533, "epss_percentile": 0.66765}, "CVE-2022-20845": {"epss_score": 0.0005, "epss_percentile": 0.1596}, "CVE-2022-20846": {"epss_score": 0.01976, "epss_percentile": 0.83121}, "CVE-2022-20847": {"epss_score": 0.0095, "epss_percentile": 0.7586}, "CVE-2022-20848": {"epss_score": 0.01625, "epss_percentile": 0.81423}, "CVE-2022-20849": {"epss_score": 0.00051, "epss_percentile": 0.1633}, "CVE-2022-20850": {"epss_score": 0.00056, "epss_percentile": 0.1768}, "CVE-2022-20851": {"epss_score": 0.00197, "epss_percentile": 0.41952}, "CVE-2022-20852": {"epss_score": 0.00153, "epss_percentile": 0.36513}, "CVE-2022-20853": {"epss_score": 0.00616, "epss_percentile": 0.69321}, "CVE-2022-20854": {"epss_score": 0.00792, "epss_percentile": 0.73414}, "CVE-2022-20855": {"epss_score": 0.00198, "epss_percentile": 0.42017}, "CVE-2022-20856": {"epss_score": 0.0095, "epss_percentile": 0.7586}, "CVE-2022-20857": {"epss_score": 0.01169, "epss_percentile": 0.78204}, "CVE-2022-20858": {"epss_score": 0.01433, "epss_percentile": 0.80259}, "CVE-2022-20859": {"epss_score": 0.01644, "epss_percentile": 0.81521}, "CVE-2022-20860": {"epss_score": 0.00251, "epss_percentile": 0.48311}, "CVE-2022-20861": {"epss_score": 0.00306, "epss_percentile": 0.53405}, "CVE-2022-20862": {"epss_score": 0.00051, "epss_percentile": 0.16124}, "CVE-2022-20863": {"epss_score": 0.00672, "epss_percentile": 0.70823}, "CVE-2022-20864": {"epss_score": 0.00173, "epss_percentile": 0.39096}, "CVE-2022-20865": {"epss_score": 0.00216, "epss_percentile": 0.44174}, "CVE-2022-20866": {"epss_score": 0.09847, "epss_percentile": 0.92733}, "CVE-2022-20867": {"epss_score": 0.00246, "epss_percentile": 0.47734}, "CVE-2022-20868": {"epss_score": 0.00637, "epss_percentile": 0.69887}, "CVE-2022-20869": {"epss_score": 0.00361, "epss_percentile": 0.57734}, "CVE-2022-20870": {"epss_score": 0.00463, "epss_percentile": 0.63689}, "CVE-2022-20871": {"epss_score": 0.00204, "epss_percentile": 0.42607}, "CVE-2022-20872": {"epss_score": 0.00168, "epss_percentile": 0.38415}, "CVE-2022-20873": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20874": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20875": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20876": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20877": {"epss_score": 0.00584, "epss_percentile": 0.68377}, "CVE-2022-20878": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20879": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20880": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20881": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20882": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20883": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20884": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20885": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20886": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20887": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20888": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2022-20889": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20890": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20891": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20892": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20893": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20894": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20895": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20896": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20897": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20898": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20899": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20900": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20901": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20902": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20903": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20904": {"epss_score": 0.0058, "epss_percentile": 0.68249}, "CVE-2022-20905": {"epss_score": 0.00155, "epss_percentile": 0.36829}, "CVE-2022-20906": {"epss_score": 0.00022, "epss_percentile": 0.05025}, "CVE-2022-20907": {"epss_score": 0.00022, "epss_percentile": 0.05025}, "CVE-2022-20908": {"epss_score": 0.00026, "epss_percentile": 0.06484}, "CVE-2022-20909": {"epss_score": 0.00026, "epss_percentile": 0.06484}, "CVE-2022-20910": {"epss_score": 0.00489, "epss_percentile": 0.64874}, "CVE-2022-20911": {"epss_score": 0.00394, "epss_percentile": 0.59764}, "CVE-2022-20912": {"epss_score": 0.00384, "epss_percentile": 0.59147}, "CVE-2022-20913": {"epss_score": 0.00125, "epss_percentile": 0.32578}, "CVE-2022-20914": {"epss_score": 0.00155, "epss_percentile": 0.36854}, "CVE-2022-20915": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2022-20916": {"epss_score": 0.00361, "epss_percentile": 0.57734}, "CVE-2022-20917": {"epss_score": 0.00171, "epss_percentile": 0.38805}, "CVE-2022-20918": {"epss_score": 0.01511, "epss_percentile": 0.80775}, "CVE-2022-20919": {"epss_score": 0.00895, "epss_percentile": 0.75106}, "CVE-2022-20920": {"epss_score": 0.01023, "epss_percentile": 0.76766}, "CVE-2022-20921": {"epss_score": 0.00534, "epss_percentile": 0.66802}, "CVE-2022-20922": {"epss_score": 0.00779, "epss_percentile": 0.73137}, "CVE-2022-20923": {"epss_score": 0.00153, "epss_percentile": 0.36592}, "CVE-2022-20924": {"epss_score": 0.00751, "epss_percentile": 0.72647}, "CVE-2022-20925": {"epss_score": 0.0039, "epss_percentile": 0.59526}, "CVE-2022-20926": {"epss_score": 0.00849, "epss_percentile": 0.74374}, "CVE-2022-20927": {"epss_score": 0.00353, "epss_percentile": 0.57139}, "CVE-2022-20928": {"epss_score": 0.00332, "epss_percentile": 0.55562}, "CVE-2022-20929": {"epss_score": 0.00052, "epss_percentile": 0.16374}, "CVE-2022-20930": {"epss_score": 0.0029, "epss_percentile": 0.52097}, "CVE-2022-20931": {"epss_score": 0.00082, "epss_percentile": 0.24399}, "CVE-2022-20932": {"epss_score": 0.00155, "epss_percentile": 0.36829}, "CVE-2022-20933": {"epss_score": 0.00463, "epss_percentile": 0.63689}, "CVE-2022-20934": {"epss_score": 0.00111, "epss_percentile": 0.30338}, "CVE-2022-20935": {"epss_score": 0.00155, "epss_percentile": 0.36829}, "CVE-2022-20936": {"epss_score": 0.00155, "epss_percentile": 0.36829}, "CVE-2022-20937": {"epss_score": 0.00399, "epss_percentile": 0.60102}, "CVE-2022-20938": {"epss_score": 0.00132, "epss_percentile": 0.3356}, "CVE-2022-20939": {"epss_score": 0.00216, "epss_percentile": 0.4419}, "CVE-2022-20940": {"epss_score": 0.00273, "epss_percentile": 0.50452}, "CVE-2022-20941": {"epss_score": 0.00316, "epss_percentile": 0.54214}, "CVE-2022-20942": {"epss_score": 0.00271, "epss_percentile": 0.50292}, "CVE-2022-20943": {"epss_score": 0.00767, "epss_percentile": 0.72948}, "CVE-2022-20944": {"epss_score": 0.00104, "epss_percentile": 0.29193}, "CVE-2022-20945": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2022-20946": {"epss_score": 0.01431, "epss_percentile": 0.80244}, "CVE-2022-20947": {"epss_score": 0.00792, "epss_percentile": 0.73414}, "CVE-2022-20948": {"epss_score": 0.00077, "epss_percentile": 0.23327}, "CVE-2022-20949": {"epss_score": 0.0017, "epss_percentile": 0.38735}, "CVE-2022-20950": {"epss_score": 0.00472, "epss_percentile": 0.64033}, "CVE-2022-20951": {"epss_score": 0.00194, "epss_percentile": 0.41567}, "CVE-2022-20952": {"epss_score": 0.00165, "epss_percentile": 0.38028}, "CVE-2022-20953": {"epss_score": 0.00403, "epss_percentile": 0.60345}, "CVE-2022-20954": {"epss_score": 0.00335, "epss_percentile": 0.55838}, "CVE-2022-20955": {"epss_score": 0.00539, "epss_percentile": 0.66961}, "CVE-2022-20956": {"epss_score": 0.00076, "epss_percentile": 0.23258}, "CVE-2022-20958": {"epss_score": 0.00745, "epss_percentile": 0.72518}, "CVE-2022-20959": {"epss_score": 0.00229, "epss_percentile": 0.45616}, "CVE-2022-20960": {"epss_score": 0.01121, "epss_percentile": 0.77777}, "CVE-2022-20961": {"epss_score": 0.00642, "epss_percentile": 0.70016}, "CVE-2022-20962": {"epss_score": 0.00244, "epss_percentile": 0.47601}, "CVE-2022-20963": {"epss_score": 0.00154, "epss_percentile": 0.36678}, "CVE-2022-20964": {"epss_score": 0.04945, "epss_percentile": 0.89313}, "CVE-2022-20965": {"epss_score": 0.00023, "epss_percentile": 0.0544}, "CVE-2022-20966": {"epss_score": 0.03865, "epss_percentile": 0.87871}, "CVE-2022-20967": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2022-20968": {"epss_score": 0.04695, "epss_percentile": 0.89018}, "CVE-2022-20969": {"epss_score": 0.00132, "epss_percentile": 0.33617}, "CVE-2022-21122": {"epss_score": 0.01648, "epss_percentile": 0.81543}, "CVE-2022-21123": {"epss_score": 0.00168, "epss_percentile": 0.38419}, "CVE-2022-21124": {"epss_score": 0.00415, "epss_percentile": 0.61135}, "CVE-2022-21125": {"epss_score": 0.00199, "epss_percentile": 0.42137}, "CVE-2022-21126": {"epss_score": 0.00244, "epss_percentile": 0.47551}, "CVE-2022-21127": {"epss_score": 0.00229, "epss_percentile": 0.45554}, "CVE-2022-21128": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2022-21129": {"epss_score": 0.0157, "epss_percentile": 0.81084}, "CVE-2022-21131": {"epss_score": 0.00132, "epss_percentile": 0.33604}, "CVE-2022-21132": {"epss_score": 0.0082, "epss_percentile": 0.73875}, "CVE-2022-21133": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2022-21134": {"epss_score": 0.00393, "epss_percentile": 0.59742}, "CVE-2022-21136": {"epss_score": 0.00045, "epss_percentile": 0.13893}, "CVE-2022-21137": {"epss_score": 0.00707, "epss_percentile": 0.71654}, "CVE-2022-21139": {"epss_score": 0.00263, "epss_percentile": 0.49549}, "CVE-2022-21140": {"epss_score": 0.00137, "epss_percentile": 0.34341}, "CVE-2022-21141": {"epss_score": 0.00707, "epss_percentile": 0.71646}, "CVE-2022-21142": {"epss_score": 0.00883, "epss_percentile": 0.74914}, "CVE-2022-21143": {"epss_score": 0.00229, "epss_percentile": 0.45572}, "CVE-2022-21144": {"epss_score": 0.00182, "epss_percentile": 0.4022}, "CVE-2022-21145": {"epss_score": 0.06609, "epss_percentile": 0.90885}, "CVE-2022-21146": {"epss_score": 0.00129, "epss_percentile": 0.33161}, "CVE-2022-21147": {"epss_score": 0.00156, "epss_percentile": 0.36898}, "CVE-2022-21148": {"epss_score": 0.00057, "epss_percentile": 0.17992}, "CVE-2022-21149": {"epss_score": 0.00173, "epss_percentile": 0.39093}, "CVE-2022-21151": {"epss_score": 0.0005, "epss_percentile": 0.1574}, "CVE-2022-21152": {"epss_score": 0.00064, "epss_percentile": 0.20186}, "CVE-2022-21153": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2022-21154": {"epss_score": 0.00213, "epss_percentile": 0.43938}, "CVE-2022-21155": {"epss_score": 0.00107, "epss_percentile": 0.2974}, "CVE-2022-21156": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2022-21157": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2022-21158": {"epss_score": 0.00195, "epss_percentile": 0.41621}, "CVE-2022-21159": {"epss_score": 0.00446, "epss_percentile": 0.62905}, "CVE-2022-21160": {"epss_score": 0.01355, "epss_percentile": 0.79709}, "CVE-2022-21162": {"epss_score": 0.00095, "epss_percentile": 0.27214}, "CVE-2022-21163": {"epss_score": 0.00095, "epss_percentile": 0.2724}, "CVE-2022-21164": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2022-21165": {"epss_score": 0.02733, "epss_percentile": 0.85547}, "CVE-2022-21166": {"epss_score": 0.00152, "epss_percentile": 0.36494}, "CVE-2022-21167": {"epss_score": 0.00906, "epss_percentile": 0.75254}, "CVE-2022-21168": {"epss_score": 0.00167, "epss_percentile": 0.38351}, "CVE-2022-21169": {"epss_score": 0.00478, "epss_percentile": 0.64396}, "CVE-2022-21170": {"epss_score": 0.0041, "epss_percentile": 0.60833}, "CVE-2022-21172": {"epss_score": 0.00145, "epss_percentile": 0.35424}, "CVE-2022-21173": {"epss_score": 0.0013, "epss_percentile": 0.33256}, "CVE-2022-21174": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2022-21176": {"epss_score": 0.00208, "epss_percentile": 0.43213}, "CVE-2022-21177": {"epss_score": 0.00464, "epss_percentile": 0.63708}, "CVE-2022-21178": {"epss_score": 0.04937, "epss_percentile": 0.89304}, "CVE-2022-21179": {"epss_score": 0.00104, "epss_percentile": 0.29151}, "CVE-2022-21180": {"epss_score": 0.00068, "epss_percentile": 0.21346}, "CVE-2022-21181": {"epss_score": 0.0014, "epss_percentile": 0.34726}, "CVE-2022-21182": {"epss_score": 0.00311, "epss_percentile": 0.53851}, "CVE-2022-21184": {"epss_score": 0.00111, "epss_percentile": 0.30342}, "CVE-2022-21186": {"epss_score": 0.07948, "epss_percentile": 0.91783}, "CVE-2022-21187": {"epss_score": 0.0128, "epss_percentile": 0.79137}, "CVE-2022-21189": {"epss_score": 0.00204, "epss_percentile": 0.42588}, "CVE-2022-21190": {"epss_score": 0.00668, "epss_percentile": 0.70724}, "CVE-2022-21191": {"epss_score": 0.00339, "epss_percentile": 0.56197}, "CVE-2022-21192": {"epss_score": 0.01062, "epss_percentile": 0.77181}, "CVE-2022-21193": {"epss_score": 0.01197, "epss_percentile": 0.78445}, "CVE-2022-21194": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2022-21195": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2022-21196": {"epss_score": 0.00564, "epss_percentile": 0.67775}, "CVE-2022-21197": {"epss_score": 0.00883, "epss_percentile": 0.74912}, "CVE-2022-21198": {"epss_score": 0.00041, "epss_percentile": 0.12214}, "CVE-2022-21199": {"epss_score": 0.0026, "epss_percentile": 0.49101}, "CVE-2022-21201": {"epss_score": 0.00122, "epss_percentile": 0.32054}, "CVE-2022-21202": {"epss_score": 0.00167, "epss_percentile": 0.38351}, "CVE-2022-21203": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2022-21204": {"epss_score": 0.00037, "epss_percentile": 0.10956}, "CVE-2022-21205": {"epss_score": 0.00402, "epss_percentile": 0.60317}, "CVE-2022-21208": {"epss_score": 0.00784, "epss_percentile": 0.7323}, "CVE-2022-21209": {"epss_score": 0.00352, "epss_percentile": 0.57098}, "CVE-2022-21210": {"epss_score": 0.10519, "epss_percentile": 0.93017}, "CVE-2022-21211": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2022-21212": {"epss_score": 0.00475, "epss_percentile": 0.64242}, "CVE-2022-21213": {"epss_score": 0.01484, "epss_percentile": 0.80591}, "CVE-2022-21214": {"epss_score": 0.00513, "epss_percentile": 0.65898}, "CVE-2022-21215": {"epss_score": 0.00239, "epss_percentile": 0.46909}, "CVE-2022-21216": {"epss_score": 0.0004, "epss_percentile": 0.12173}, "CVE-2022-21217": {"epss_score": 0.00434, "epss_percentile": 0.62298}, "CVE-2022-21218": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2022-21219": {"epss_score": 0.00353, "epss_percentile": 0.57166}, "CVE-2022-21220": {"epss_score": 0.00053, "epss_percentile": 0.16998}, "CVE-2022-21221": {"epss_score": 0.00568, "epss_percentile": 0.67881}, "CVE-2022-21222": {"epss_score": 0.00246, "epss_percentile": 0.47762}, "CVE-2022-21223": {"epss_score": 0.00753, "epss_percentile": 0.72668}, "CVE-2022-21225": {"epss_score": 0.00334, "epss_percentile": 0.55743}, "CVE-2022-21226": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2022-21227": {"epss_score": 0.0038, "epss_percentile": 0.5894}, "CVE-2022-21228": {"epss_score": 0.00513, "epss_percentile": 0.65898}, "CVE-2022-21229": {"epss_score": 0.00099, "epss_percentile": 0.28306}, "CVE-2022-21230": {"epss_score": 0.0005, "epss_percentile": 0.15827}, "CVE-2022-21231": {"epss_score": 0.00247, "epss_percentile": 0.47871}, "CVE-2022-21233": {"epss_score": 0.00076, "epss_percentile": 0.23175}, "CVE-2022-21234": {"epss_score": 0.1099, "epss_percentile": 0.93184}, "CVE-2022-21235": {"epss_score": 0.00693, "epss_percentile": 0.71325}, "CVE-2022-21236": {"epss_score": 0.0176, "epss_percentile": 0.82145}, "CVE-2022-21237": {"epss_score": 0.00052, "epss_percentile": 0.16667}, "CVE-2022-21238": {"epss_score": 0.02031, "epss_percentile": 0.83334}, "CVE-2022-21239": {"epss_score": 0.00111, "epss_percentile": 0.30378}, "CVE-2022-21240": {"epss_score": 0.00147, "epss_percentile": 0.35787}, "CVE-2022-21241": {"epss_score": 0.29995, "epss_percentile": 0.96492}, "CVE-2022-21242": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2022-21243": {"epss_score": 0.00314, "epss_percentile": 0.54136}, "CVE-2022-21244": {"epss_score": 0.00694, "epss_percentile": 0.71343}, "CVE-2022-21245": {"epss_score": 0.00175, "epss_percentile": 0.39365}, "CVE-2022-21246": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2022-21247": {"epss_score": 0.00202, "epss_percentile": 0.42455}, "CVE-2022-21248": {"epss_score": 0.00083, "epss_percentile": 0.24719}, "CVE-2022-21249": {"epss_score": 0.00152, "epss_percentile": 0.3644}, "CVE-2022-21250": {"epss_score": 0.01267, "epss_percentile": 0.79024}, "CVE-2022-21251": {"epss_score": 0.01623, "epss_percentile": 0.81403}, "CVE-2022-21252": {"epss_score": 0.00968, "epss_percentile": 0.76085}, "CVE-2022-21253": {"epss_score": 0.00361, "epss_percentile": 0.57695}, "CVE-2022-21254": {"epss_score": 0.01135, "epss_percentile": 0.77911}, "CVE-2022-21255": {"epss_score": 0.01267, "epss_percentile": 0.79024}, "CVE-2022-21256": {"epss_score": 0.00361, "epss_percentile": 0.57695}, "CVE-2022-21257": {"epss_score": 0.00816, "epss_percentile": 0.73796}, "CVE-2022-21258": {"epss_score": 0.00601, "epss_percentile": 0.68859}, "CVE-2022-21259": {"epss_score": 0.00601, "epss_percentile": 0.68859}, "CVE-2022-21260": {"epss_score": 0.00601, "epss_percentile": 0.68859}, "CVE-2022-21261": {"epss_score": 0.00601, "epss_percentile": 0.68859}, "CVE-2022-21262": {"epss_score": 0.00601, "epss_percentile": 0.68859}, "CVE-2022-21263": {"epss_score": 0.00139, "epss_percentile": 0.34626}, "CVE-2022-21264": {"epss_score": 0.00385, "epss_percentile": 0.59233}, "CVE-2022-21265": {"epss_score": 0.0021, "epss_percentile": 0.43482}, "CVE-2022-21266": {"epss_score": 0.02226, "epss_percentile": 0.84071}, "CVE-2022-21267": {"epss_score": 0.00069, "epss_percentile": 0.21508}, "CVE-2022-21268": {"epss_score": 0.00069, "epss_percentile": 0.21508}, "CVE-2022-21269": {"epss_score": 0.00567, "epss_percentile": 0.67856}, "CVE-2022-21270": {"epss_score": 0.00279, "epss_percentile": 0.50977}, "CVE-2022-21271": {"epss_score": 0.00502, "epss_percentile": 0.65372}, "CVE-2022-21272": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2022-21273": {"epss_score": 0.01352, "epss_percentile": 0.79691}, "CVE-2022-21274": {"epss_score": 0.01267, "epss_percentile": 0.79024}, "CVE-2022-21275": {"epss_score": 0.01786, "epss_percentile": 0.82257}, "CVE-2022-21276": {"epss_score": 0.01659, "epss_percentile": 0.81614}, "CVE-2022-21277": {"epss_score": 0.00139, "epss_percentile": 0.34668}, "CVE-2022-21278": {"epss_score": 0.00428, "epss_percentile": 0.61923}, "CVE-2022-21279": {"epss_score": 0.1491, "epss_percentile": 0.9432}, "CVE-2022-21280": {"epss_score": 0.1491, "epss_percentile": 0.9432}, "CVE-2022-21281": {"epss_score": 0.0019, "epss_percentile": 0.41092}, "CVE-2022-21282": {"epss_score": 0.00134, "epss_percentile": 0.33749}, "CVE-2022-21283": {"epss_score": 0.00113, "epss_percentile": 0.30646}, "CVE-2022-21284": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21285": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21286": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21287": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21288": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21289": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21290": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21291": {"epss_score": 0.00126, "epss_percentile": 0.32776}, "CVE-2022-21292": {"epss_score": 0.0467, "epss_percentile": 0.88986}, "CVE-2022-21293": {"epss_score": 0.00096, "epss_percentile": 0.27328}, "CVE-2022-21294": {"epss_score": 0.00112, "epss_percentile": 0.30508}, "CVE-2022-21295": {"epss_score": 0.00047, "epss_percentile": 0.14928}, "CVE-2022-21296": {"epss_score": 0.00134, "epss_percentile": 0.33749}, "CVE-2022-21297": {"epss_score": 0.0018, "epss_percentile": 0.39974}, "CVE-2022-21298": {"epss_score": 0.00081, "epss_percentile": 0.24281}, "CVE-2022-21299": {"epss_score": 0.00097, "epss_percentile": 0.27601}, "CVE-2022-21300": {"epss_score": 0.02226, "epss_percentile": 0.84071}, "CVE-2022-21301": {"epss_score": 0.00279, "epss_percentile": 0.50977}, "CVE-2022-21302": {"epss_score": 0.00446, "epss_percentile": 0.62931}, "CVE-2022-21303": {"epss_score": 0.00279, "epss_percentile": 0.50977}, "CVE-2022-21304": {"epss_score": 0.00279, "epss_percentile": 0.50977}, "CVE-2022-21305": {"epss_score": 0.00231, "epss_percentile": 0.4582}, "CVE-2022-21306": {"epss_score": 0.36535, "epss_percentile": 0.96985}, "CVE-2022-21307": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21308": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21309": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21310": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21311": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21312": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21313": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21314": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21315": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21316": {"epss_score": 0.00509, "epss_percentile": 0.6574}, "CVE-2022-21317": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21318": {"epss_score": 0.00509, "epss_percentile": 0.6574}, "CVE-2022-21319": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21320": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21321": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21322": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21323": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21324": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21325": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21326": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21327": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21328": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21329": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21330": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21331": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21332": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21333": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21334": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21335": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21336": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21337": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21338": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2022-21339": {"epss_score": 0.00385, "epss_percentile": 0.59233}, "CVE-2022-21340": {"epss_score": 0.06462, "epss_percentile": 0.9077}, "CVE-2022-21341": {"epss_score": 0.00112, "epss_percentile": 0.30508}, "CVE-2022-21342": {"epss_score": 0.00249, "epss_percentile": 0.48065}, "CVE-2022-21344": {"epss_score": 0.0018, "epss_percentile": 0.39974}, "CVE-2022-21345": {"epss_score": 0.00573, "epss_percentile": 0.68055}, "CVE-2022-21346": {"epss_score": 0.03861, "epss_percentile": 0.87865}, "CVE-2022-21347": {"epss_score": 0.01384, "epss_percentile": 0.79898}, "CVE-2022-21348": {"epss_score": 0.00249, "epss_percentile": 0.48065}, "CVE-2022-21349": {"epss_score": 0.00117, "epss_percentile": 0.31206}, "CVE-2022-21350": {"epss_score": 0.46195, "epss_percentile": 0.97535}, "CVE-2022-21351": {"epss_score": 0.00428, "epss_percentile": 0.61923}, "CVE-2022-21352": {"epss_score": 0.00293, "epss_percentile": 0.52286}, "CVE-2022-21353": {"epss_score": 0.01384, "epss_percentile": 0.79898}, "CVE-2022-21354": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2022-21355": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21356": {"epss_score": 0.11434, "epss_percentile": 0.9336}, "CVE-2022-21357": {"epss_score": 0.00261, "epss_percentile": 0.4926}, "CVE-2022-21358": {"epss_score": 0.00277, "epss_percentile": 0.5078}, "CVE-2022-21359": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2022-21360": {"epss_score": 0.00112, "epss_percentile": 0.30508}, "CVE-2022-21361": {"epss_score": 0.00601, "epss_percentile": 0.68859}, "CVE-2022-21362": {"epss_score": 0.00249, "epss_percentile": 0.48065}, "CVE-2022-21363": {"epss_score": 0.01166, "epss_percentile": 0.78178}, "CVE-2022-21364": {"epss_score": 0.00941, "epss_percentile": 0.75754}, "CVE-2022-21365": {"epss_score": 0.00112, "epss_percentile": 0.30508}, "CVE-2022-21366": {"epss_score": 0.00139, "epss_percentile": 0.34668}, "CVE-2022-21367": {"epss_score": 0.0018, "epss_percentile": 0.39974}, "CVE-2022-21368": {"epss_score": 0.00176, "epss_percentile": 0.3943}, "CVE-2022-21369": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2022-21370": {"epss_score": 0.0018, "epss_percentile": 0.39974}, "CVE-2022-21371": {"epss_score": 0.94161, "epss_percentile": 0.9991}, "CVE-2022-21372": {"epss_score": 0.00128, "epss_percentile": 0.33044}, "CVE-2022-21373": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2022-21374": {"epss_score": 0.00249, "epss_percentile": 0.48065}, "CVE-2022-21375": {"epss_score": 0.00062, "epss_percentile": 0.19641}, "CVE-2022-21376": {"epss_score": 0.00567, "epss_percentile": 0.67856}, "CVE-2022-21377": {"epss_score": 0.00567, "epss_percentile": 0.67856}, "CVE-2022-21378": {"epss_score": 0.00249, "epss_percentile": 0.48065}, "CVE-2022-21379": {"epss_score": 0.00266, "epss_percentile": 0.49923}, "CVE-2022-21380": {"epss_score": 0.30557, "epss_percentile": 0.96551}, "CVE-2022-21381": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2022-21382": {"epss_score": 0.00355, "epss_percentile": 0.57267}, "CVE-2022-21383": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2022-21385": {"epss_score": 0.00036, "epss_percentile": 0.10246}, "CVE-2022-21386": {"epss_score": 0.00601, "epss_percentile": 0.68859}, "CVE-2022-21387": {"epss_score": 0.00771, "epss_percentile": 0.73012}, "CVE-2022-21388": {"epss_score": 0.00081, "epss_percentile": 0.24336}, "CVE-2022-21389": {"epss_score": 0.01786, "epss_percentile": 0.82257}, "CVE-2022-21390": {"epss_score": 0.02174, "epss_percentile": 0.83878}, "CVE-2022-21391": {"epss_score": 0.01659, "epss_percentile": 0.81614}, "CVE-2022-21392": {"epss_score": 0.00204, "epss_percentile": 0.42643}, "CVE-2022-21393": {"epss_score": 0.00435, "epss_percentile": 0.62363}, "CVE-2022-21394": {"epss_score": 0.00123, "epss_percentile": 0.32287}, "CVE-2022-21395": {"epss_score": 0.01406, "epss_percentile": 0.8005}, "CVE-2022-21396": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2022-21397": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2022-21398": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2022-21399": {"epss_score": 0.00211, "epss_percentile": 0.43623}, "CVE-2022-21400": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2022-21401": {"epss_score": 0.00211, "epss_percentile": 0.43623}, "CVE-2022-21402": {"epss_score": 0.0019, "epss_percentile": 0.41092}, "CVE-2022-21403": {"epss_score": 0.00211, "epss_percentile": 0.43623}, "CVE-2022-21404": {"epss_score": 0.01069, "epss_percentile": 0.7725}, "CVE-2022-21405": {"epss_score": 0.00133, "epss_percentile": 0.33655}, "CVE-2022-21409": {"epss_score": 0.00567, "epss_percentile": 0.67856}, "CVE-2022-21410": {"epss_score": 0.01406, "epss_percentile": 0.8005}, "CVE-2022-21411": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2022-21412": {"epss_score": 0.00366, "epss_percentile": 0.58068}, "CVE-2022-21413": {"epss_score": 0.00351, "epss_percentile": 0.56983}, "CVE-2022-21414": {"epss_score": 0.00305, "epss_percentile": 0.53373}, "CVE-2022-21415": {"epss_score": 0.00218, "epss_percentile": 0.44337}, "CVE-2022-21416": {"epss_score": 0.00159, "epss_percentile": 0.37365}, "CVE-2022-21417": {"epss_score": 0.00279, "epss_percentile": 0.50943}, "CVE-2022-21418": {"epss_score": 0.00276, "epss_percentile": 0.50747}, "CVE-2022-21419": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2022-21420": {"epss_score": 0.01786, "epss_percentile": 0.82257}, "CVE-2022-21421": {"epss_score": 0.04294, "epss_percentile": 0.88506}, "CVE-2022-21422": {"epss_score": 0.01001, "epss_percentile": 0.76492}, "CVE-2022-21423": {"epss_score": 0.00351, "epss_percentile": 0.56983}, "CVE-2022-21424": {"epss_score": 0.01566, "epss_percentile": 0.81066}, "CVE-2022-21425": {"epss_score": 0.00171, "epss_percentile": 0.38811}, "CVE-2022-21426": {"epss_score": 0.00062, "epss_percentile": 0.19653}, "CVE-2022-21427": {"epss_score": 0.00062, "epss_percentile": 0.19638}, "CVE-2022-21428": {"epss_score": 0.01377, "epss_percentile": 0.79844}, "CVE-2022-21429": {"epss_score": 0.03628, "epss_percentile": 0.87468}, "CVE-2022-21430": {"epss_score": 0.00872, "epss_percentile": 0.74726}, "CVE-2022-21431": {"epss_score": 0.01662, "epss_percentile": 0.81637}, "CVE-2022-21432": {"epss_score": 0.0013, "epss_percentile": 0.33243}, "CVE-2022-21434": {"epss_score": 0.00108, "epss_percentile": 0.2978}, "CVE-2022-21435": {"epss_score": 0.00218, "epss_percentile": 0.44337}, "CVE-2022-21436": {"epss_score": 0.00305, "epss_percentile": 0.53373}, "CVE-2022-21437": {"epss_score": 0.00218, "epss_percentile": 0.44337}, "CVE-2022-21438": {"epss_score": 0.00305, "epss_percentile": 0.53373}, "CVE-2022-21439": {"epss_score": 0.00179, "epss_percentile": 0.3985}, "CVE-2022-21440": {"epss_score": 0.00284, "epss_percentile": 0.5145}, "CVE-2022-21441": {"epss_score": 0.02191, "epss_percentile": 0.83938}, "CVE-2022-21442": {"epss_score": 0.00138, "epss_percentile": 0.3446}, "CVE-2022-21443": {"epss_score": 0.00058, "epss_percentile": 0.18362}, "CVE-2022-21444": {"epss_score": 0.00096, "epss_percentile": 0.27285}, "CVE-2022-21445": {"epss_score": 0.9219, "epss_percentile": 0.99697}, "CVE-2022-21446": {"epss_score": 0.01142, "epss_percentile": 0.7797}, "CVE-2022-21447": {"epss_score": 0.00601, "epss_percentile": 0.68838}, "CVE-2022-21448": {"epss_score": 0.01151, "epss_percentile": 0.78034}, "CVE-2022-21449": {"epss_score": 0.28342, "epss_percentile": 0.96345}, "CVE-2022-21450": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2022-21451": {"epss_score": 0.0008, "epss_percentile": 0.24198}, "CVE-2022-21452": {"epss_score": 0.00305, "epss_percentile": 0.53373}, "CVE-2022-21453": {"epss_score": 0.01121, "epss_percentile": 0.77769}, "CVE-2022-21454": {"epss_score": 0.00193, "epss_percentile": 0.41432}, "CVE-2022-21455": {"epss_score": 0.00145, "epss_percentile": 0.35456}, "CVE-2022-21456": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2022-21457": {"epss_score": 0.02088, "epss_percentile": 0.83556}, "CVE-2022-21458": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2022-21459": {"epss_score": 0.00284, "epss_percentile": 0.5145}, "CVE-2022-21460": {"epss_score": 0.00338, "epss_percentile": 0.56134}, "CVE-2022-21461": {"epss_score": 0.00105, "epss_percentile": 0.29387}, "CVE-2022-21462": {"epss_score": 0.00195, "epss_percentile": 0.41687}, "CVE-2022-21463": {"epss_score": 0.00216, "epss_percentile": 0.44128}, "CVE-2022-21464": {"epss_score": 0.02016, "epss_percentile": 0.83275}, "CVE-2022-21465": {"epss_score": 0.00162, "epss_percentile": 0.37641}, "CVE-2022-21466": {"epss_score": 0.01729, "epss_percentile": 0.81977}, "CVE-2022-21467": {"epss_score": 0.00601, "epss_percentile": 0.68838}, "CVE-2022-21468": {"epss_score": 0.01151, "epss_percentile": 0.78034}, "CVE-2022-21469": {"epss_score": 0.0044, "epss_percentile": 0.62634}, "CVE-2022-21470": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2022-21471": {"epss_score": 0.00148, "epss_percentile": 0.35853}, "CVE-2022-21472": {"epss_score": 0.00375, "epss_percentile": 0.58613}, "CVE-2022-21473": {"epss_score": 0.00375, "epss_percentile": 0.58613}, "CVE-2022-21474": {"epss_score": 0.00375, "epss_percentile": 0.58613}, "CVE-2022-21475": {"epss_score": 0.00375, "epss_percentile": 0.58613}, "CVE-2022-21476": {"epss_score": 0.00184, "epss_percentile": 0.40446}, "CVE-2022-21477": {"epss_score": 0.00255, "epss_percentile": 0.48682}, "CVE-2022-21478": {"epss_score": 0.00171, "epss_percentile": 0.38811}, "CVE-2022-21479": {"epss_score": 0.00223, "epss_percentile": 0.44856}, "CVE-2022-21480": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2022-21481": {"epss_score": 0.00185, "epss_percentile": 0.40543}, "CVE-2022-21482": {"epss_score": 0.01635, "epss_percentile": 0.81468}, "CVE-2022-21483": {"epss_score": 0.01635, "epss_percentile": 0.81468}, "CVE-2022-21484": {"epss_score": 0.00368, "epss_percentile": 0.5821}, "CVE-2022-21485": {"epss_score": 0.00368, "epss_percentile": 0.5821}, "CVE-2022-21486": {"epss_score": 0.00368, "epss_percentile": 0.5821}, "CVE-2022-21487": {"epss_score": 0.00045, "epss_percentile": 0.13726}, "CVE-2022-21488": {"epss_score": 0.00063, "epss_percentile": 0.1991}, "CVE-2022-21489": {"epss_score": 0.11081, "epss_percentile": 0.93213}, "CVE-2022-21490": {"epss_score": 0.30623, "epss_percentile": 0.96557}, "CVE-2022-21491": {"epss_score": 0.00055, "epss_percentile": 0.17465}, "CVE-2022-21492": {"epss_score": 0.00837, "epss_percentile": 0.74163}, "CVE-2022-21493": {"epss_score": 0.00078, "epss_percentile": 0.23739}, "CVE-2022-21494": {"epss_score": 0.00095, "epss_percentile": 0.27167}, "CVE-2022-21496": {"epss_score": 0.00109, "epss_percentile": 0.29976}, "CVE-2022-21497": {"epss_score": 0.02971, "epss_percentile": 0.86094}, "CVE-2022-21498": {"epss_score": 0.00179, "epss_percentile": 0.39864}, "CVE-2022-21499": {"epss_score": 0.00163, "epss_percentile": 0.37858}, "CVE-2022-21500": {"epss_score": 0.93773, "epss_percentile": 0.99843}, "CVE-2022-21503": {"epss_score": 0.00509, "epss_percentile": 0.65725}, "CVE-2022-21504": {"epss_score": 0.00084, "epss_percentile": 0.2494}, "CVE-2022-21505": {"epss_score": 0.00049, "epss_percentile": 0.15574}, "CVE-2022-21508": {"epss_score": 0.00244, "epss_percentile": 0.47554}, "CVE-2022-21509": {"epss_score": 0.0022, "epss_percentile": 0.4459}, "CVE-2022-21510": {"epss_score": 0.00131, "epss_percentile": 0.33503}, "CVE-2022-21511": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2022-21512": {"epss_score": 0.00099, "epss_percentile": 0.28361}, "CVE-2022-21513": {"epss_score": 0.00135, "epss_percentile": 0.33987}, "CVE-2022-21514": {"epss_score": 0.0121, "epss_percentile": 0.78546}, "CVE-2022-21515": {"epss_score": 0.00748, "epss_percentile": 0.72579}, "CVE-2022-21516": {"epss_score": 0.00776, "epss_percentile": 0.73102}, "CVE-2022-21517": {"epss_score": 0.00146, "epss_percentile": 0.35554}, "CVE-2022-21518": {"epss_score": 0.00572, "epss_percentile": 0.67999}, "CVE-2022-21519": {"epss_score": 0.0036, "epss_percentile": 0.57687}, "CVE-2022-21520": {"epss_score": 0.006, "epss_percentile": 0.68825}, "CVE-2022-21521": {"epss_score": 0.00586, "epss_percentile": 0.68451}, "CVE-2022-21522": {"epss_score": 0.00247, "epss_percentile": 0.47823}, "CVE-2022-21523": {"epss_score": 0.00209, "epss_percentile": 0.43332}, "CVE-2022-21524": {"epss_score": 0.00426, "epss_percentile": 0.61754}, "CVE-2022-21525": {"epss_score": 0.00196, "epss_percentile": 0.41758}, "CVE-2022-21526": {"epss_score": 0.00196, "epss_percentile": 0.41758}, "CVE-2022-21527": {"epss_score": 0.00443, "epss_percentile": 0.62787}, "CVE-2022-21528": {"epss_score": 0.00443, "epss_percentile": 0.62787}, "CVE-2022-21529": {"epss_score": 0.00443, "epss_percentile": 0.62787}, "CVE-2022-21530": {"epss_score": 0.00443, "epss_percentile": 0.62787}, "CVE-2022-21531": {"epss_score": 0.00443, "epss_percentile": 0.62787}, "CVE-2022-21532": {"epss_score": 0.00209, "epss_percentile": 0.43332}, "CVE-2022-21533": {"epss_score": 0.00045, "epss_percentile": 0.14042}, "CVE-2022-21534": {"epss_score": 0.00443, "epss_percentile": 0.62787}, "CVE-2022-21535": {"epss_score": 0.00482, "epss_percentile": 0.64552}, "CVE-2022-21536": {"epss_score": 0.04228, "epss_percentile": 0.88418}, "CVE-2022-21537": {"epss_score": 0.00443, "epss_percentile": 0.62787}, "CVE-2022-21538": {"epss_score": 0.00353, "epss_percentile": 0.57136}, "CVE-2022-21539": {"epss_score": 0.00458, "epss_percentile": 0.63441}, "CVE-2022-21540": {"epss_score": 0.00433, "epss_percentile": 0.62196}, "CVE-2022-21541": {"epss_score": 0.00401, "epss_percentile": 0.60229}, "CVE-2022-21542": {"epss_score": 0.00291, "epss_percentile": 0.52146}, "CVE-2022-21543": {"epss_score": 0.0497, "epss_percentile": 0.8935}, "CVE-2022-21544": {"epss_score": 0.01316, "epss_percentile": 0.79408}, "CVE-2022-21545": {"epss_score": 0.00278, "epss_percentile": 0.50864}, "CVE-2022-21546": {"epss_score": 0.00031, "epss_percentile": 0.08441}, "CVE-2022-21547": {"epss_score": 0.0037, "epss_percentile": 0.5833}, "CVE-2022-21548": {"epss_score": 0.0209, "epss_percentile": 0.83568}, "CVE-2022-21549": {"epss_score": 0.00227, "epss_percentile": 0.45428}, "CVE-2022-21550": {"epss_score": 0.39128, "epss_percentile": 0.97142}, "CVE-2022-21551": {"epss_score": 0.01581, "epss_percentile": 0.81139}, "CVE-2022-21552": {"epss_score": 0.01035, "epss_percentile": 0.76906}, "CVE-2022-21553": {"epss_score": 0.0037, "epss_percentile": 0.5833}, "CVE-2022-21554": {"epss_score": 0.00111, "epss_percentile": 0.30307}, "CVE-2022-21555": {"epss_score": 0.00147, "epss_percentile": 0.35785}, "CVE-2022-21556": {"epss_score": 0.0038, "epss_percentile": 0.58909}, "CVE-2022-21557": {"epss_score": 0.00159, "epss_percentile": 0.37393}, "CVE-2022-21558": {"epss_score": 0.0011, "epss_percentile": 0.30085}, "CVE-2022-21559": {"epss_score": 0.00086, "epss_percentile": 0.25344}, "CVE-2022-21560": {"epss_score": 0.02813, "epss_percentile": 0.85724}, "CVE-2022-21561": {"epss_score": 0.00524, "epss_percentile": 0.66341}, "CVE-2022-21562": {"epss_score": 0.00737, "epss_percentile": 0.72322}, "CVE-2022-21563": {"epss_score": 0.00054, "epss_percentile": 0.17251}, "CVE-2022-21564": {"epss_score": 0.02813, "epss_percentile": 0.85724}, "CVE-2022-21565": {"epss_score": 0.00265, "epss_percentile": 0.49842}, "CVE-2022-21566": {"epss_score": 0.02873, "epss_percentile": 0.85879}, "CVE-2022-21567": {"epss_score": 0.01678, "epss_percentile": 0.8172}, "CVE-2022-21568": {"epss_score": 0.00572, "epss_percentile": 0.67999}, "CVE-2022-21569": {"epss_score": 0.00481, "epss_percentile": 0.64495}, "CVE-2022-21570": {"epss_score": 0.00974, "epss_percentile": 0.76193}, "CVE-2022-21571": {"epss_score": 0.00285, "epss_percentile": 0.51502}, "CVE-2022-21572": {"epss_score": 0.00293, "epss_percentile": 0.52348}, "CVE-2022-21573": {"epss_score": 0.00391, "epss_percentile": 0.5959}, "CVE-2022-21574": {"epss_score": 0.00398, "epss_percentile": 0.60079}, "CVE-2022-21575": {"epss_score": 0.00535, "epss_percentile": 0.66839}, "CVE-2022-21576": {"epss_score": 0.00676, "epss_percentile": 0.70929}, "CVE-2022-21577": {"epss_score": 0.01466, "epss_percentile": 0.80464}, "CVE-2022-21578": {"epss_score": 0.01331, "epss_percentile": 0.79514}, "CVE-2022-21579": {"epss_score": 0.01466, "epss_percentile": 0.80464}, "CVE-2022-21580": {"epss_score": 0.00502, "epss_percentile": 0.65397}, "CVE-2022-21581": {"epss_score": 0.00265, "epss_percentile": 0.49781}, "CVE-2022-21582": {"epss_score": 0.01331, "epss_percentile": 0.79514}, "CVE-2022-21583": {"epss_score": 0.00676, "epss_percentile": 0.70929}, "CVE-2022-21584": {"epss_score": 0.01466, "epss_percentile": 0.80464}, "CVE-2022-21585": {"epss_score": 0.01377, "epss_percentile": 0.79844}, "CVE-2022-21586": {"epss_score": 0.00947, "epss_percentile": 0.75819}, "CVE-2022-21587": {"epss_score": 0.94397, "epss_percentile": 0.99972}, "CVE-2022-21589": {"epss_score": 0.00178, "epss_percentile": 0.39669}, "CVE-2022-21590": {"epss_score": 0.00676, "epss_percentile": 0.70929}, "CVE-2022-21591": {"epss_score": 0.00332, "epss_percentile": 0.55566}, "CVE-2022-21592": {"epss_score": 0.00304, "epss_percentile": 0.53292}, "CVE-2022-21593": {"epss_score": 0.02168, "epss_percentile": 0.8386}, "CVE-2022-21594": {"epss_score": 0.0006, "epss_percentile": 0.19194}, "CVE-2022-21595": {"epss_score": 0.00091, "epss_percentile": 0.26223}, "CVE-2022-21596": {"epss_score": 0.01643, "epss_percentile": 0.81515}, "CVE-2022-21597": {"epss_score": 0.00832, "epss_percentile": 0.74069}, "CVE-2022-21598": {"epss_score": 0.00787, "epss_percentile": 0.73306}, "CVE-2022-21599": {"epss_score": 0.00063, "epss_percentile": 0.19846}, "CVE-2022-21600": {"epss_score": 0.01312, "epss_percentile": 0.79376}, "CVE-2022-21601": {"epss_score": 0.01168, "epss_percentile": 0.7819}, "CVE-2022-21602": {"epss_score": 0.00619, "epss_percentile": 0.6943}, "CVE-2022-21603": {"epss_score": 0.0154, "epss_percentile": 0.80943}, "CVE-2022-21604": {"epss_score": 0.0006, "epss_percentile": 0.19194}, "CVE-2022-21605": {"epss_score": 0.00403, "epss_percentile": 0.60395}, "CVE-2022-21606": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2022-21607": {"epss_score": 0.00419, "epss_percentile": 0.61387}, "CVE-2022-21608": {"epss_score": 0.00081, "epss_percentile": 0.24308}, "CVE-2022-21609": {"epss_score": 0.00604, "epss_percentile": 0.68942}, "CVE-2022-21610": {"epss_score": 0.00071, "epss_percentile": 0.22051}, "CVE-2022-21611": {"epss_score": 0.00022, "epss_percentile": 0.05246}, "CVE-2022-21612": {"epss_score": 0.01389, "epss_percentile": 0.79929}, "CVE-2022-21613": {"epss_score": 0.01334, "epss_percentile": 0.79539}, "CVE-2022-21614": {"epss_score": 0.01648, "epss_percentile": 0.81554}, "CVE-2022-21615": {"epss_score": 0.01661, "epss_percentile": 0.81623}, "CVE-2022-21616": {"epss_score": 0.00045, "epss_percentile": 0.13685}, "CVE-2022-21617": {"epss_score": 0.00081, "epss_percentile": 0.24308}, "CVE-2022-21618": {"epss_score": 0.00184, "epss_percentile": 0.40411}, "CVE-2022-21619": {"epss_score": 0.00209, "epss_percentile": 0.43366}, "CVE-2022-21620": {"epss_score": 0.00285, "epss_percentile": 0.51502}, "CVE-2022-21621": {"epss_score": 0.00059, "epss_percentile": 0.18804}, "CVE-2022-21622": {"epss_score": 0.012, "epss_percentile": 0.78476}, "CVE-2022-21623": {"epss_score": 0.00787, "epss_percentile": 0.73306}, "CVE-2022-21624": {"epss_score": 0.00154, "epss_percentile": 0.36717}, "CVE-2022-21625": {"epss_score": 0.0006, "epss_percentile": 0.19194}, "CVE-2022-21626": {"epss_score": 0.00111, "epss_percentile": 0.30249}, "CVE-2022-21627": {"epss_score": 0.00111, "epss_percentile": 0.30243}, "CVE-2022-21628": {"epss_score": 0.0019, "epss_percentile": 0.41133}, "CVE-2022-21629": {"epss_score": 0.00293, "epss_percentile": 0.52348}, "CVE-2022-21630": {"epss_score": 0.01053, "epss_percentile": 0.77101}, "CVE-2022-21631": {"epss_score": 0.02151, "epss_percentile": 0.83785}, "CVE-2022-21632": {"epss_score": 0.0006, "epss_percentile": 0.19194}, "CVE-2022-21633": {"epss_score": 0.00063, "epss_percentile": 0.19846}, "CVE-2022-21634": {"epss_score": 0.00991, "epss_percentile": 0.76388}, "CVE-2022-21635": {"epss_score": 0.00536, "epss_percentile": 0.66866}, "CVE-2022-21636": {"epss_score": 0.00599, "epss_percentile": 0.68801}, "CVE-2022-21637": {"epss_score": 0.0006, "epss_percentile": 0.19194}, "CVE-2022-21638": {"epss_score": 0.00145, "epss_percentile": 0.35488}, "CVE-2022-21639": {"epss_score": 0.0145, "epss_percentile": 0.80354}, "CVE-2022-21640": {"epss_score": 0.00063, "epss_percentile": 0.19846}, "CVE-2022-21641": {"epss_score": 0.00119, "epss_percentile": 0.31563}, "CVE-2022-21642": {"epss_score": 0.00248, "epss_percentile": 0.47937}, "CVE-2022-21643": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-21644": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-21646": {"epss_score": 0.00343, "epss_percentile": 0.56469}, "CVE-2022-21647": {"epss_score": 0.10866, "epss_percentile": 0.93138}, "CVE-2022-21648": {"epss_score": 0.00311, "epss_percentile": 0.53828}, "CVE-2022-21649": {"epss_score": 0.0037, "epss_percentile": 0.58336}, "CVE-2022-21650": {"epss_score": 0.0037, "epss_percentile": 0.58336}, "CVE-2022-21651": {"epss_score": 0.00262, "epss_percentile": 0.49388}, "CVE-2022-21652": {"epss_score": 0.00303, "epss_percentile": 0.53191}, "CVE-2022-21653": {"epss_score": 0.00141, "epss_percentile": 0.34937}, "CVE-2022-21654": {"epss_score": 0.0006, "epss_percentile": 0.19068}, "CVE-2022-21655": {"epss_score": 0.00057, "epss_percentile": 0.18003}, "CVE-2022-21656": {"epss_score": 0.00017, "epss_percentile": 0.03398}, "CVE-2022-21657": {"epss_score": 0.00039, "epss_percentile": 0.11715}, "CVE-2022-21658": {"epss_score": 0.00891, "epss_percentile": 0.75037}, "CVE-2022-21659": {"epss_score": 0.00343, "epss_percentile": 0.56431}, "CVE-2022-21660": {"epss_score": 0.00707, "epss_percentile": 0.71647}, "CVE-2022-21661": {"epss_score": 0.90904, "epss_percentile": 0.99608}, "CVE-2022-21662": {"epss_score": 0.14759, "epss_percentile": 0.94276}, "CVE-2022-21663": {"epss_score": 0.00451, "epss_percentile": 0.6315}, "CVE-2022-21664": {"epss_score": 0.04985, "epss_percentile": 0.89363}, "CVE-2022-21666": {"epss_score": 0.00494, "epss_percentile": 0.65077}, "CVE-2022-21667": {"epss_score": 0.00706, "epss_percentile": 0.71617}, "CVE-2022-21668": {"epss_score": 0.01583, "epss_percentile": 0.81154}, "CVE-2022-21669": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2022-21670": {"epss_score": 0.01394, "epss_percentile": 0.7997}, "CVE-2022-21671": {"epss_score": 0.00376, "epss_percentile": 0.58669}, "CVE-2022-21672": {"epss_score": 0.0015, "epss_percentile": 0.36085}, "CVE-2022-21673": {"epss_score": 0.00523, "epss_percentile": 0.66289}, "CVE-2022-21675": {"epss_score": 0.01357, "epss_percentile": 0.79725}, "CVE-2022-21676": {"epss_score": 0.04082, "epss_percentile": 0.88222}, "CVE-2022-21677": {"epss_score": 0.00356, "epss_percentile": 0.57363}, "CVE-2022-21678": {"epss_score": 0.00306, "epss_percentile": 0.53424}, "CVE-2022-21679": {"epss_score": 0.00185, "epss_percentile": 0.40486}, "CVE-2022-21680": {"epss_score": 0.0049, "epss_percentile": 0.6492}, "CVE-2022-21681": {"epss_score": 0.00695, "epss_percentile": 0.71368}, "CVE-2022-21682": {"epss_score": 0.00355, "epss_percentile": 0.57258}, "CVE-2022-21683": {"epss_score": 0.00231, "epss_percentile": 0.4577}, "CVE-2022-21684": {"epss_score": 0.00128, "epss_percentile": 0.33033}, "CVE-2022-21685": {"epss_score": 0.00442, "epss_percentile": 0.627}, "CVE-2022-21686": {"epss_score": 0.00625, "epss_percentile": 0.69584}, "CVE-2022-21687": {"epss_score": 0.00328, "epss_percentile": 0.55255}, "CVE-2022-21688": {"epss_score": 0.00386, "epss_percentile": 0.59237}, "CVE-2022-21689": {"epss_score": 0.00344, "epss_percentile": 0.56542}, "CVE-2022-21690": {"epss_score": 0.00334, "epss_percentile": 0.55735}, "CVE-2022-21691": {"epss_score": 0.00158, "epss_percentile": 0.37225}, "CVE-2022-21692": {"epss_score": 0.00152, "epss_percentile": 0.36407}, "CVE-2022-21693": {"epss_score": 0.00368, "epss_percentile": 0.58217}, "CVE-2022-21694": {"epss_score": 0.00255, "epss_percentile": 0.48727}, "CVE-2022-21695": {"epss_score": 0.00278, "epss_percentile": 0.50864}, "CVE-2022-21696": {"epss_score": 0.00209, "epss_percentile": 0.43373}, "CVE-2022-21697": {"epss_score": 0.00365, "epss_percentile": 0.58014}, "CVE-2022-21698": {"epss_score": 0.00279, "epss_percentile": 0.50968}, "CVE-2022-21699": {"epss_score": 0.01461, "epss_percentile": 0.80432}, "CVE-2022-21700": {"epss_score": 0.00322, "epss_percentile": 0.54742}, "CVE-2022-21701": {"epss_score": 0.00225, "epss_percentile": 0.45101}, "CVE-2022-21702": {"epss_score": 0.01249, "epss_percentile": 0.78869}, "CVE-2022-21703": {"epss_score": 0.01377, "epss_percentile": 0.79843}, "CVE-2022-21704": {"epss_score": 0.00042, "epss_percentile": 0.12644}, "CVE-2022-21705": {"epss_score": 0.7849, "epss_percentile": 0.98989}, "CVE-2022-21706": {"epss_score": 0.00138, "epss_percentile": 0.34393}, "CVE-2022-21707": {"epss_score": 0.00118, "epss_percentile": 0.31398}, "CVE-2022-21708": {"epss_score": 0.00202, "epss_percentile": 0.42484}, "CVE-2022-21710": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2022-21711": {"epss_score": 0.00362, "epss_percentile": 0.57787}, "CVE-2022-21712": {"epss_score": 0.00205, "epss_percentile": 0.42714}, "CVE-2022-21713": {"epss_score": 0.00142, "epss_percentile": 0.34995}, "CVE-2022-21715": {"epss_score": 0.00621, "epss_percentile": 0.69475}, "CVE-2022-21716": {"epss_score": 0.00823, "epss_percentile": 0.73922}, "CVE-2022-21718": {"epss_score": 0.01183, "epss_percentile": 0.78323}, "CVE-2022-21719": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2022-21720": {"epss_score": 0.00407, "epss_percentile": 0.60591}, "CVE-2022-21721": {"epss_score": 0.00931, "epss_percentile": 0.75617}, "CVE-2022-21722": {"epss_score": 0.0032, "epss_percentile": 0.54624}, "CVE-2022-21723": {"epss_score": 0.00717, "epss_percentile": 0.71873}, "CVE-2022-21724": {"epss_score": 0.04807, "epss_percentile": 0.89162}, "CVE-2022-21725": {"epss_score": 0.0022, "epss_percentile": 0.44564}, "CVE-2022-21726": {"epss_score": 0.00296, "epss_percentile": 0.52561}, "CVE-2022-21727": {"epss_score": 0.00329, "epss_percentile": 0.5539}, "CVE-2022-21728": {"epss_score": 0.01124, "epss_percentile": 0.778}, "CVE-2022-21729": {"epss_score": 0.0022, "epss_percentile": 0.44564}, "CVE-2022-21730": {"epss_score": 0.00296, "epss_percentile": 0.52561}, "CVE-2022-21731": {"epss_score": 0.00303, "epss_percentile": 0.53235}, "CVE-2022-21732": {"epss_score": 0.0022, "epss_percentile": 0.44564}, "CVE-2022-21733": {"epss_score": 0.00232, "epss_percentile": 0.45935}, "CVE-2022-21734": {"epss_score": 0.0022, "epss_percentile": 0.44564}, "CVE-2022-21735": {"epss_score": 0.0022, "epss_percentile": 0.44564}, "CVE-2022-21736": {"epss_score": 0.0025, "epss_percentile": 0.48212}, "CVE-2022-21737": {"epss_score": 0.0022, "epss_percentile": 0.44564}, "CVE-2022-21738": {"epss_score": 0.0022, "epss_percentile": 0.44564}, "CVE-2022-21739": {"epss_score": 0.00221, "epss_percentile": 0.4463}, "CVE-2022-21740": {"epss_score": 0.00409, "epss_percentile": 0.60723}, "CVE-2022-21741": {"epss_score": 0.00232, "epss_percentile": 0.45935}, "CVE-2022-21742": {"epss_score": 0.00127, "epss_percentile": 0.32789}, "CVE-2022-21743": {"epss_score": 0.00018, "epss_percentile": 0.03602}, "CVE-2022-21744": {"epss_score": 0.05051, "epss_percentile": 0.8944}, "CVE-2022-21745": {"epss_score": 0.00102, "epss_percentile": 0.2884}, "CVE-2022-21746": {"epss_score": 0.00017, "epss_percentile": 0.0323}, "CVE-2022-21747": {"epss_score": 0.00017, "epss_percentile": 0.0323}, "CVE-2022-21748": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-21749": {"epss_score": 0.00015, "epss_percentile": 0.02579}, "CVE-2022-21750": {"epss_score": 0.00018, "epss_percentile": 0.037}, "CVE-2022-21751": {"epss_score": 0.00018, "epss_percentile": 0.037}, "CVE-2022-21752": {"epss_score": 0.00018, "epss_percentile": 0.037}, "CVE-2022-21753": {"epss_score": 0.00018, "epss_percentile": 0.037}, "CVE-2022-21754": {"epss_score": 0.00018, "epss_percentile": 0.037}, "CVE-2022-21755": {"epss_score": 0.00019, "epss_percentile": 0.04196}, "CVE-2022-21756": {"epss_score": 0.00019, "epss_percentile": 0.04196}, "CVE-2022-21757": {"epss_score": 0.00302, "epss_percentile": 0.53086}, "CVE-2022-21758": {"epss_score": 0.00016, "epss_percentile": 0.02736}, "CVE-2022-21759": {"epss_score": 0.00018, "epss_percentile": 0.037}, "CVE-2022-21760": {"epss_score": 0.00021, "epss_percentile": 0.04708}, "CVE-2022-21761": {"epss_score": 0.00021, "epss_percentile": 0.04708}, "CVE-2022-21762": {"epss_score": 0.00021, "epss_percentile": 0.04708}, "CVE-2022-21763": {"epss_score": 0.00014, "epss_percentile": 0.01912}, "CVE-2022-21764": {"epss_score": 0.00014, "epss_percentile": 0.01912}, "CVE-2022-21765": {"epss_score": 0.00033, "epss_percentile": 0.09187}, "CVE-2022-21766": {"epss_score": 0.0006, "epss_percentile": 0.19101}, "CVE-2022-21767": {"epss_score": 0.0003, "epss_percentile": 0.08264}, "CVE-2022-21768": {"epss_score": 0.0003, "epss_percentile": 0.08264}, "CVE-2022-21769": {"epss_score": 0.00039, "epss_percentile": 0.11583}, "CVE-2022-21770": {"epss_score": 0.00015, "epss_percentile": 0.02428}, "CVE-2022-21771": {"epss_score": 0.00012, "epss_percentile": 0.01414}, "CVE-2022-21772": {"epss_score": 0.00011, "epss_percentile": 0.00958}, "CVE-2022-21773": {"epss_score": 0.00014, "epss_percentile": 0.01934}, "CVE-2022-21774": {"epss_score": 0.00014, "epss_percentile": 0.01934}, "CVE-2022-21775": {"epss_score": 0.00012, "epss_percentile": 0.01414}, "CVE-2022-21776": {"epss_score": 0.00012, "epss_percentile": 0.01414}, "CVE-2022-21777": {"epss_score": 0.00013, "epss_percentile": 0.01614}, "CVE-2022-21778": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-21779": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-21780": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-21781": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-21782": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-21783": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-21784": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-21785": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-21786": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-21787": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-21788": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-21789": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2022-21790": {"epss_score": 0.00018, "epss_percentile": 0.03728}, "CVE-2022-21791": {"epss_score": 0.00018, "epss_percentile": 0.03728}, "CVE-2022-21792": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2022-21793": {"epss_score": 0.00049, "epss_percentile": 0.1529}, "CVE-2022-21794": {"epss_score": 0.00124, "epss_percentile": 0.32441}, "CVE-2022-21796": {"epss_score": 0.00667, "epss_percentile": 0.70701}, "CVE-2022-21797": {"epss_score": 0.00222, "epss_percentile": 0.44743}, "CVE-2022-21798": {"epss_score": 0.00117, "epss_percentile": 0.31206}, "CVE-2022-21799": {"epss_score": 0.00151, "epss_percentile": 0.36303}, "CVE-2022-21800": {"epss_score": 0.00077, "epss_percentile": 0.23401}, "CVE-2022-21801": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2022-21802": {"epss_score": 0.00314, "epss_percentile": 0.54124}, "CVE-2022-21803": {"epss_score": 0.00478, "epss_percentile": 0.64395}, "CVE-2022-21804": {"epss_score": 0.00152, "epss_percentile": 0.36371}, "CVE-2022-21805": {"epss_score": 0.00931, "epss_percentile": 0.75619}, "CVE-2022-21806": {"epss_score": 0.01757, "epss_percentile": 0.82134}, "CVE-2022-21807": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2022-21808": {"epss_score": 0.00743, "epss_percentile": 0.72496}, "CVE-2022-21809": {"epss_score": 0.01416, "epss_percentile": 0.80144}, "CVE-2022-21810": {"epss_score": 0.00212, "epss_percentile": 0.43823}, "CVE-2022-21812": {"epss_score": 0.00057, "epss_percentile": 0.17992}, "CVE-2022-21813": {"epss_score": 0.00046, "epss_percentile": 0.141}, "CVE-2022-21814": {"epss_score": 0.00046, "epss_percentile": 0.141}, "CVE-2022-21815": {"epss_score": 0.0004, "epss_percentile": 0.12157}, "CVE-2022-21816": {"epss_score": 0.00034, "epss_percentile": 0.09713}, "CVE-2022-21817": {"epss_score": 0.00908, "epss_percentile": 0.7528}, "CVE-2022-21818": {"epss_score": 0.00079, "epss_percentile": 0.23814}, "CVE-2022-21819": {"epss_score": 0.00238, "epss_percentile": 0.46838}, "CVE-2022-21820": {"epss_score": 0.00746, "epss_percentile": 0.72541}, "CVE-2022-21821": {"epss_score": 0.00324, "epss_percentile": 0.54971}, "CVE-2022-21822": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2022-21823": {"epss_score": 0.00098, "epss_percentile": 0.2766}, "CVE-2022-21824": {"epss_score": 0.00335, "epss_percentile": 0.55837}, "CVE-2022-21825": {"epss_score": 0.00041, "epss_percentile": 0.12461}, "CVE-2022-21826": {"epss_score": 0.08842, "epss_percentile": 0.92281}, "CVE-2022-21827": {"epss_score": 0.00104, "epss_percentile": 0.29181}, "CVE-2022-21828": {"epss_score": 0.15382, "epss_percentile": 0.94421}, "CVE-2022-21829": {"epss_score": 0.00567, "epss_percentile": 0.6786}, "CVE-2022-21830": {"epss_score": 0.00353, "epss_percentile": 0.57171}, "CVE-2022-21831": {"epss_score": 0.01312, "epss_percentile": 0.79376}, "CVE-2022-21833": {"epss_score": 0.00376, "epss_percentile": 0.58662}, "CVE-2022-21834": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2022-21835": {"epss_score": 0.00419, "epss_percentile": 0.61356}, "CVE-2022-21836": {"epss_score": 0.00589, "epss_percentile": 0.68537}, "CVE-2022-21837": {"epss_score": 0.07688, "epss_percentile": 0.91627}, "CVE-2022-21838": {"epss_score": 0.00468, "epss_percentile": 0.63871}, "CVE-2022-21839": {"epss_score": 0.00208, "epss_percentile": 0.43216}, "CVE-2022-21840": {"epss_score": 0.07197, "epss_percentile": 0.91315}, "CVE-2022-21841": {"epss_score": 0.01942, "epss_percentile": 0.8299}, "CVE-2022-21842": {"epss_score": 0.0219, "epss_percentile": 0.83933}, "CVE-2022-21843": {"epss_score": 0.10128, "epss_percentile": 0.92861}, "CVE-2022-21844": {"epss_score": 0.01894, "epss_percentile": 0.82743}, "CVE-2022-21845": {"epss_score": 0.00626, "epss_percentile": 0.69604}, "CVE-2022-21846": {"epss_score": 0.01525, "epss_percentile": 0.80857}, "CVE-2022-21847": {"epss_score": 0.00292, "epss_percentile": 0.52255}, "CVE-2022-21848": {"epss_score": 0.07419, "epss_percentile": 0.91463}, "CVE-2022-21849": {"epss_score": 0.24801, "epss_percentile": 0.95955}, "CVE-2022-21850": {"epss_score": 0.07894, "epss_percentile": 0.91749}, "CVE-2022-21851": {"epss_score": 0.07894, "epss_percentile": 0.91749}, "CVE-2022-21852": {"epss_score": 0.00384, "epss_percentile": 0.59151}, "CVE-2022-21855": {"epss_score": 0.01529, "epss_percentile": 0.80878}, "CVE-2022-21857": {"epss_score": 0.03915, "epss_percentile": 0.87938}, "CVE-2022-21858": {"epss_score": 0.00414, "epss_percentile": 0.6102}, "CVE-2022-21859": {"epss_score": 0.0021, "epss_percentile": 0.43473}, "CVE-2022-21860": {"epss_score": 0.00393, "epss_percentile": 0.59711}, "CVE-2022-21861": {"epss_score": 0.00313, "epss_percentile": 0.54023}, "CVE-2022-21862": {"epss_score": 0.00304, "epss_percentile": 0.53305}, "CVE-2022-21863": {"epss_score": 0.00548, "epss_percentile": 0.67293}, "CVE-2022-21864": {"epss_score": 0.00466, "epss_percentile": 0.63805}, "CVE-2022-21865": {"epss_score": 0.00296, "epss_percentile": 0.52555}, "CVE-2022-21866": {"epss_score": 0.00399, "epss_percentile": 0.60129}, "CVE-2022-21867": {"epss_score": 0.00548, "epss_percentile": 0.67293}, "CVE-2022-21868": {"epss_score": 0.00436, "epss_percentile": 0.62456}, "CVE-2022-21869": {"epss_score": 0.00453, "epss_percentile": 0.63224}, "CVE-2022-21870": {"epss_score": 0.0057, "epss_percentile": 0.67961}, "CVE-2022-21871": {"epss_score": 0.00453, "epss_percentile": 0.63224}, "CVE-2022-21872": {"epss_score": 0.00394, "epss_percentile": 0.59758}, "CVE-2022-21873": {"epss_score": 0.0057, "epss_percentile": 0.67961}, "CVE-2022-21874": {"epss_score": 0.03315, "epss_percentile": 0.86898}, "CVE-2022-21875": {"epss_score": 0.0057, "epss_percentile": 0.67961}, "CVE-2022-21876": {"epss_score": 0.00774, "epss_percentile": 0.7307}, "CVE-2022-21877": {"epss_score": 0.14993, "epss_percentile": 0.94338}, "CVE-2022-21878": {"epss_score": 0.03193, "epss_percentile": 0.86605}, "CVE-2022-21879": {"epss_score": 0.01052, "epss_percentile": 0.77087}, "CVE-2022-21880": {"epss_score": 0.14089, "epss_percentile": 0.9413}, "CVE-2022-21881": {"epss_score": 0.06658, "epss_percentile": 0.90922}, "CVE-2022-21882": {"epss_score": 0.8724, "epss_percentile": 0.99419}, "CVE-2022-21883": {"epss_score": 0.05458, "epss_percentile": 0.89898}, "CVE-2022-21884": {"epss_score": 0.00333, "epss_percentile": 0.55651}, "CVE-2022-21885": {"epss_score": 0.00419, "epss_percentile": 0.61356}, "CVE-2022-21887": {"epss_score": 0.00471, "epss_percentile": 0.64028}, "CVE-2022-21888": {"epss_score": 0.02122, "epss_percentile": 0.8368}, "CVE-2022-21889": {"epss_score": 0.11687, "epss_percentile": 0.93448}, "CVE-2022-21890": {"epss_score": 0.11687, "epss_percentile": 0.93448}, "CVE-2022-21891": {"epss_score": 0.0365, "epss_percentile": 0.87507}, "CVE-2022-21892": {"epss_score": 0.00453, "epss_percentile": 0.63236}, "CVE-2022-21893": {"epss_score": 0.04595, "epss_percentile": 0.88896}, "CVE-2022-21894": {"epss_score": 0.45082, "epss_percentile": 0.97471}, "CVE-2022-21895": {"epss_score": 0.00909, "epss_percentile": 0.75294}, "CVE-2022-21896": {"epss_score": 0.00319, "epss_percentile": 0.54496}, "CVE-2022-21897": {"epss_score": 0.00538, "epss_percentile": 0.66942}, "CVE-2022-21898": {"epss_score": 0.01082, "epss_percentile": 0.77384}, "CVE-2022-21899": {"epss_score": 0.00278, "epss_percentile": 0.50856}, "CVE-2022-21900": {"epss_score": 0.00426, "epss_percentile": 0.6177}, "CVE-2022-21901": {"epss_score": 0.00551, "epss_percentile": 0.67379}, "CVE-2022-21902": {"epss_score": 0.00671, "epss_percentile": 0.70803}, "CVE-2022-21903": {"epss_score": 0.00439, "epss_percentile": 0.62593}, "CVE-2022-21904": {"epss_score": 0.13345, "epss_percentile": 0.93938}, "CVE-2022-21905": {"epss_score": 0.00429, "epss_percentile": 0.61965}, "CVE-2022-21906": {"epss_score": 0.00874, "epss_percentile": 0.74757}, "CVE-2022-21907": {"epss_score": 0.91887, "epss_percentile": 0.99676}, "CVE-2022-21908": {"epss_score": 0.0052, "epss_percentile": 0.66187}, "CVE-2022-21910": {"epss_score": 0.00974, "epss_percentile": 0.76176}, "CVE-2022-21911": {"epss_score": 0.20804, "epss_percentile": 0.95415}, "CVE-2022-21912": {"epss_score": 0.02611, "epss_percentile": 0.85235}, "CVE-2022-21913": {"epss_score": 0.01131, "epss_percentile": 0.77856}, "CVE-2022-21914": {"epss_score": 0.01694, "epss_percentile": 0.81804}, "CVE-2022-21915": {"epss_score": 0.13242, "epss_percentile": 0.9391}, "CVE-2022-21916": {"epss_score": 0.02093, "epss_percentile": 0.83577}, "CVE-2022-21917": {"epss_score": 0.02051, "epss_percentile": 0.834}, "CVE-2022-21918": {"epss_score": 0.01826, "epss_percentile": 0.82435}, "CVE-2022-21919": {"epss_score": 0.00256, "epss_percentile": 0.4878}, "CVE-2022-21920": {"epss_score": 0.07999, "epss_percentile": 0.91816}, "CVE-2022-21921": {"epss_score": 0.01677, "epss_percentile": 0.81714}, "CVE-2022-21922": {"epss_score": 0.08136, "epss_percentile": 0.91897}, "CVE-2022-21924": {"epss_score": 0.01195, "epss_percentile": 0.78432}, "CVE-2022-21925": {"epss_score": 0.02068, "epss_percentile": 0.83463}, "CVE-2022-21926": {"epss_score": 0.0239, "epss_percentile": 0.84598}, "CVE-2022-21927": {"epss_score": 0.01894, "epss_percentile": 0.82743}, "CVE-2022-21928": {"epss_score": 0.01606, "epss_percentile": 0.81304}, "CVE-2022-21929": {"epss_score": 0.00797, "epss_percentile": 0.73494}, "CVE-2022-21930": {"epss_score": 0.00767, "epss_percentile": 0.72958}, "CVE-2022-21931": {"epss_score": 0.00767, "epss_percentile": 0.72958}, "CVE-2022-21932": {"epss_score": 0.00427, "epss_percentile": 0.61773}, "CVE-2022-21933": {"epss_score": 0.00101, "epss_percentile": 0.28574}, "CVE-2022-21934": {"epss_score": 0.0019, "epss_percentile": 0.41102}, "CVE-2022-21935": {"epss_score": 0.00185, "epss_percentile": 0.40549}, "CVE-2022-21936": {"epss_score": 0.0016, "epss_percentile": 0.37465}, "CVE-2022-21937": {"epss_score": 0.00541, "epss_percentile": 0.6706}, "CVE-2022-21938": {"epss_score": 0.0035, "epss_percentile": 0.56946}, "CVE-2022-21939": {"epss_score": 0.00122, "epss_percentile": 0.32056}, "CVE-2022-21940": {"epss_score": 0.00082, "epss_percentile": 0.24568}, "CVE-2022-21941": {"epss_score": 0.1974, "epss_percentile": 0.95234}, "CVE-2022-21944": {"epss_score": 0.0011, "epss_percentile": 0.30224}, "CVE-2022-21945": {"epss_score": 0.00039, "epss_percentile": 0.11779}, "CVE-2022-21946": {"epss_score": 0.00037, "epss_percentile": 0.10654}, "CVE-2022-21947": {"epss_score": 0.00096, "epss_percentile": 0.2735}, "CVE-2022-21948": {"epss_score": 0.00053, "epss_percentile": 0.17009}, "CVE-2022-21949": {"epss_score": 0.01579, "epss_percentile": 0.81126}, "CVE-2022-21950": {"epss_score": 0.00094, "epss_percentile": 0.27068}, "CVE-2022-21951": {"epss_score": 0.00082, "epss_percentile": 0.24527}, "CVE-2022-21952": {"epss_score": 0.00362, "epss_percentile": 0.5776}, "CVE-2022-21953": {"epss_score": 0.0007, "epss_percentile": 0.21932}, "CVE-2022-21954": {"epss_score": 0.00644, "epss_percentile": 0.7008}, "CVE-2022-21957": {"epss_score": 0.06146, "epss_percentile": 0.90518}, "CVE-2022-21958": {"epss_score": 0.02038, "epss_percentile": 0.83361}, "CVE-2022-21959": {"epss_score": 0.02038, "epss_percentile": 0.83361}, "CVE-2022-21960": {"epss_score": 0.02038, "epss_percentile": 0.83361}, "CVE-2022-21961": {"epss_score": 0.02038, "epss_percentile": 0.83361}, "CVE-2022-21962": {"epss_score": 0.01417, "epss_percentile": 0.80148}, "CVE-2022-21963": {"epss_score": 0.01714, "epss_percentile": 0.81892}, "CVE-2022-21964": {"epss_score": 0.02279, "epss_percentile": 0.84239}, "CVE-2022-21965": {"epss_score": 0.12797, "epss_percentile": 0.93776}, "CVE-2022-21967": {"epss_score": 0.00366, "epss_percentile": 0.58062}, "CVE-2022-21968": {"epss_score": 0.01016, "epss_percentile": 0.7668}, "CVE-2022-21969": {"epss_score": 0.02088, "epss_percentile": 0.83557}, "CVE-2022-21970": {"epss_score": 0.01993, "epss_percentile": 0.83182}, "CVE-2022-21971": {"epss_score": 0.86935, "epss_percentile": 0.99405}, "CVE-2022-21972": {"epss_score": 0.48559, "epss_percentile": 0.97643}, "CVE-2022-21973": {"epss_score": 0.0019, "epss_percentile": 0.41054}, "CVE-2022-21974": {"epss_score": 0.08813, "epss_percentile": 0.92267}, "CVE-2022-21975": {"epss_score": 0.00136, "epss_percentile": 0.34092}, "CVE-2022-21977": {"epss_score": 0.0102, "epss_percentile": 0.76736}, "CVE-2022-21978": {"epss_score": 0.00524, "epss_percentile": 0.66363}, "CVE-2022-21979": {"epss_score": 0.01878, "epss_percentile": 0.8267}, "CVE-2022-21980": {"epss_score": 0.13588, "epss_percentile": 0.94003}, "CVE-2022-21981": {"epss_score": 0.00453, "epss_percentile": 0.63208}, "CVE-2022-21983": {"epss_score": 0.04975, "epss_percentile": 0.89355}, "CVE-2022-21984": {"epss_score": 0.07463, "epss_percentile": 0.91486}, "CVE-2022-21985": {"epss_score": 0.00296, "epss_percentile": 0.52618}, "CVE-2022-21986": {"epss_score": 0.017, "epss_percentile": 0.81827}, "CVE-2022-21987": {"epss_score": 0.06906, "epss_percentile": 0.91108}, "CVE-2022-21988": {"epss_score": 0.01437, "epss_percentile": 0.80281}, "CVE-2022-21989": {"epss_score": 0.02128, "epss_percentile": 0.83703}, "CVE-2022-21990": {"epss_score": 0.15438, "epss_percentile": 0.94431}, "CVE-2022-21991": {"epss_score": 0.04369, "epss_percentile": 0.88606}, "CVE-2022-21992": {"epss_score": 0.01107, "epss_percentile": 0.77629}, "CVE-2022-21993": {"epss_score": 0.23968, "epss_percentile": 0.95839}, "CVE-2022-21994": {"epss_score": 0.00523, "epss_percentile": 0.66295}, "CVE-2022-21995": {"epss_score": 0.00841, "epss_percentile": 0.7423}, "CVE-2022-21996": {"epss_score": 0.00385, "epss_percentile": 0.59215}, "CVE-2022-21997": {"epss_score": 0.00295, "epss_percentile": 0.5252}, "CVE-2022-21998": {"epss_score": 0.00406, "epss_percentile": 0.60545}, "CVE-2022-21999": {"epss_score": 0.70092, "epss_percentile": 0.98615}, "CVE-2022-22000": {"epss_score": 0.00523, "epss_percentile": 0.66295}, "CVE-2022-22001": {"epss_score": 0.00389, "epss_percentile": 0.59464}, "CVE-2022-22002": {"epss_score": 0.00273, "epss_percentile": 0.50445}, "CVE-2022-22003": {"epss_score": 0.02123, "epss_percentile": 0.83683}, "CVE-2022-22004": {"epss_score": 0.01403, "epss_percentile": 0.80029}, "CVE-2022-22005": {"epss_score": 0.05375, "epss_percentile": 0.89797}, "CVE-2022-22006": {"epss_score": 0.02586, "epss_percentile": 0.85167}, "CVE-2022-22007": {"epss_score": 0.02586, "epss_percentile": 0.85167}, "CVE-2022-22008": {"epss_score": 0.00156, "epss_percentile": 0.36978}, "CVE-2022-22009": {"epss_score": 0.00358, "epss_percentile": 0.57491}, "CVE-2022-22010": {"epss_score": 0.01057, "epss_percentile": 0.77138}, "CVE-2022-22011": {"epss_score": 0.00366, "epss_percentile": 0.5805}, "CVE-2022-22012": {"epss_score": 0.09863, "epss_percentile": 0.92742}, "CVE-2022-22013": {"epss_score": 0.12982, "epss_percentile": 0.93835}, "CVE-2022-22014": {"epss_score": 0.12982, "epss_percentile": 0.93835}, "CVE-2022-22015": {"epss_score": 0.15382, "epss_percentile": 0.94421}, "CVE-2022-22016": {"epss_score": 0.00259, "epss_percentile": 0.49083}, "CVE-2022-22017": {"epss_score": 0.14642, "epss_percentile": 0.94256}, "CVE-2022-22018": {"epss_score": 0.02746, "epss_percentile": 0.85573}, "CVE-2022-22019": {"epss_score": 0.08594, "epss_percentile": 0.9214}, "CVE-2022-22021": {"epss_score": 0.01811, "epss_percentile": 0.82367}, "CVE-2022-22022": {"epss_score": 0.00267, "epss_percentile": 0.49975}, "CVE-2022-22023": {"epss_score": 0.00278, "epss_percentile": 0.50906}, "CVE-2022-22024": {"epss_score": 0.018, "epss_percentile": 0.82323}, "CVE-2022-22025": {"epss_score": 0.4787, "epss_percentile": 0.97605}, "CVE-2022-22026": {"epss_score": 0.00927, "epss_percentile": 0.7557}, "CVE-2022-22027": {"epss_score": 0.02285, "epss_percentile": 0.84265}, "CVE-2022-22028": {"epss_score": 0.01406, "epss_percentile": 0.80047}, "CVE-2022-22029": {"epss_score": 0.04957, "epss_percentile": 0.8933}, "CVE-2022-22031": {"epss_score": 0.00289, "epss_percentile": 0.52072}, "CVE-2022-22034": {"epss_score": 0.00645, "epss_percentile": 0.70124}, "CVE-2022-22035": {"epss_score": 0.01265, "epss_percentile": 0.79005}, "CVE-2022-22036": {"epss_score": 0.00402, "epss_percentile": 0.60297}, "CVE-2022-22037": {"epss_score": 0.08437, "epss_percentile": 0.92052}, "CVE-2022-22038": {"epss_score": 0.06571, "epss_percentile": 0.90854}, "CVE-2022-22039": {"epss_score": 0.06002, "epss_percentile": 0.90393}, "CVE-2022-22040": {"epss_score": 0.02499, "epss_percentile": 0.84914}, "CVE-2022-22041": {"epss_score": 0.04295, "epss_percentile": 0.88507}, "CVE-2022-22042": {"epss_score": 0.20868, "epss_percentile": 0.95431}, "CVE-2022-22043": {"epss_score": 0.00553, "epss_percentile": 0.67412}, "CVE-2022-22045": {"epss_score": 0.0067, "epss_percentile": 0.7077}, "CVE-2022-22047": {"epss_score": 0.01458, "epss_percentile": 0.80406}, "CVE-2022-22048": {"epss_score": 0.00854, "epss_percentile": 0.7445}, "CVE-2022-22049": {"epss_score": 0.00722, "epss_percentile": 0.71993}, "CVE-2022-22050": {"epss_score": 0.00772, "epss_percentile": 0.73047}, "CVE-2022-22054": {"epss_score": 0.00103, "epss_percentile": 0.29046}, "CVE-2022-22055": {"epss_score": 0.0316, "epss_percentile": 0.8653}, "CVE-2022-22056": {"epss_score": 0.03818, "epss_percentile": 0.87772}, "CVE-2022-22057": {"epss_score": 0.01977, "epss_percentile": 0.83128}, "CVE-2022-22058": {"epss_score": 0.00055, "epss_percentile": 0.17611}, "CVE-2022-22059": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2022-22060": {"epss_score": 0.00107, "epss_percentile": 0.29678}, "CVE-2022-22061": {"epss_score": 0.00042, "epss_percentile": 0.12769}, "CVE-2022-22062": {"epss_score": 0.00199, "epss_percentile": 0.42118}, "CVE-2022-22063": {"epss_score": 0.02616, "epss_percentile": 0.85247}, "CVE-2022-22064": {"epss_score": 0.00369, "epss_percentile": 0.58253}, "CVE-2022-22065": {"epss_score": 0.00369, "epss_percentile": 0.58253}, "CVE-2022-22066": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2022-22067": {"epss_score": 0.00222, "epss_percentile": 0.44742}, "CVE-2022-22068": {"epss_score": 0.0009, "epss_percentile": 0.26158}, "CVE-2022-22069": {"epss_score": 0.00021, "epss_percentile": 0.04696}, "CVE-2022-22070": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2022-22071": {"epss_score": 0.00552, "epss_percentile": 0.67404}, "CVE-2022-22072": {"epss_score": 0.00035, "epss_percentile": 0.09958}, "CVE-2022-22074": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2022-22075": {"epss_score": 0.00054, "epss_percentile": 0.17315}, "CVE-2022-22076": {"epss_score": 0.00054, "epss_percentile": 0.17284}, "CVE-2022-22077": {"epss_score": 0.00055, "epss_percentile": 0.17611}, "CVE-2022-22078": {"epss_score": 0.00084, "epss_percentile": 0.24878}, "CVE-2022-22079": {"epss_score": 0.00063, "epss_percentile": 0.20098}, "CVE-2022-22080": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2022-22081": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2022-22082": {"epss_score": 0.00041, "epss_percentile": 0.12356}, "CVE-2022-22083": {"epss_score": 0.00369, "epss_percentile": 0.58253}, "CVE-2022-22084": {"epss_score": 0.00111, "epss_percentile": 0.30321}, "CVE-2022-22085": {"epss_score": 0.00115, "epss_percentile": 0.30942}, "CVE-2022-22086": {"epss_score": 0.00278, "epss_percentile": 0.50851}, "CVE-2022-22087": {"epss_score": 0.003, "epss_percentile": 0.5291}, "CVE-2022-22088": {"epss_score": 0.00672, "epss_percentile": 0.70812}, "CVE-2022-22089": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2022-22090": {"epss_score": 0.00043, "epss_percentile": 0.13313}, "CVE-2022-22091": {"epss_score": 0.00359, "epss_percentile": 0.5755}, "CVE-2022-22092": {"epss_score": 0.00113, "epss_percentile": 0.30618}, "CVE-2022-22093": {"epss_score": 0.00101, "epss_percentile": 0.28623}, "CVE-2022-22094": {"epss_score": 0.00092, "epss_percentile": 0.26429}, "CVE-2022-22095": {"epss_score": 0.00113, "epss_percentile": 0.30618}, "CVE-2022-22096": {"epss_score": 0.00363, "epss_percentile": 0.57862}, "CVE-2022-22097": {"epss_score": 0.00055, "epss_percentile": 0.17611}, "CVE-2022-22098": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2022-22099": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2022-22100": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2022-22101": {"epss_score": 0.00101, "epss_percentile": 0.28667}, "CVE-2022-22102": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2022-22103": {"epss_score": 0.00039, "epss_percentile": 0.11568}, "CVE-2022-22104": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2022-22105": {"epss_score": 0.0032, "epss_percentile": 0.54589}, "CVE-2022-22106": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2022-22107": {"epss_score": 0.00151, "epss_percentile": 0.36227}, "CVE-2022-22108": {"epss_score": 0.00151, "epss_percentile": 0.36227}, "CVE-2022-22109": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-22110": {"epss_score": 0.0028, "epss_percentile": 0.51031}, "CVE-2022-22111": {"epss_score": 0.00299, "epss_percentile": 0.52865}, "CVE-2022-22112": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-22113": {"epss_score": 0.00299, "epss_percentile": 0.52898}, "CVE-2022-22114": {"epss_score": 0.02046, "epss_percentile": 0.83386}, "CVE-2022-22115": {"epss_score": 0.00373, "epss_percentile": 0.58518}, "CVE-2022-22116": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-22117": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-22120": {"epss_score": 0.00277, "epss_percentile": 0.50789}, "CVE-2022-22121": {"epss_score": 0.00433, "epss_percentile": 0.62207}, "CVE-2022-22123": {"epss_score": 0.00304, "epss_percentile": 0.53255}, "CVE-2022-22124": {"epss_score": 0.00357, "epss_percentile": 0.57437}, "CVE-2022-22125": {"epss_score": 0.00419, "epss_percentile": 0.61371}, "CVE-2022-22126": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-22127": {"epss_score": 0.0039, "epss_percentile": 0.59505}, "CVE-2022-22128": {"epss_score": 0.01694, "epss_percentile": 0.81804}, "CVE-2022-22137": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2022-22138": {"epss_score": 0.00133, "epss_percentile": 0.33632}, "CVE-2022-22139": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2022-22140": {"epss_score": 0.01922, "epss_percentile": 0.82905}, "CVE-2022-22141": {"epss_score": 0.00049, "epss_percentile": 0.15599}, "CVE-2022-22142": {"epss_score": 0.00931, "epss_percentile": 0.75619}, "CVE-2022-22143": {"epss_score": 0.00892, "epss_percentile": 0.75062}, "CVE-2022-22144": {"epss_score": 0.00358, "epss_percentile": 0.57484}, "CVE-2022-22145": {"epss_score": 0.0035, "epss_percentile": 0.5695}, "CVE-2022-22146": {"epss_score": 0.01016, "epss_percentile": 0.76673}, "CVE-2022-22148": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2022-22149": {"epss_score": 0.23148, "epss_percentile": 0.95741}, "CVE-2022-22150": {"epss_score": 0.00858, "epss_percentile": 0.74504}, "CVE-2022-22151": {"epss_score": 0.0035, "epss_percentile": 0.5695}, "CVE-2022-22152": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2022-22153": {"epss_score": 0.0039, "epss_percentile": 0.59508}, "CVE-2022-22154": {"epss_score": 0.00049, "epss_percentile": 0.15492}, "CVE-2022-22155": {"epss_score": 0.00196, "epss_percentile": 0.4176}, "CVE-2022-22156": {"epss_score": 0.00116, "epss_percentile": 0.31045}, "CVE-2022-22157": {"epss_score": 0.00241, "epss_percentile": 0.4733}, "CVE-2022-22159": {"epss_score": 0.0054, "epss_percentile": 0.66997}, "CVE-2022-22160": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2022-22161": {"epss_score": 0.0098, "epss_percentile": 0.76265}, "CVE-2022-22162": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2022-22163": {"epss_score": 0.00078, "epss_percentile": 0.23747}, "CVE-2022-22164": {"epss_score": 0.00309, "epss_percentile": 0.53649}, "CVE-2022-22166": {"epss_score": 0.00195, "epss_percentile": 0.41632}, "CVE-2022-22167": {"epss_score": 0.00255, "epss_percentile": 0.48639}, "CVE-2022-22168": {"epss_score": 0.00076, "epss_percentile": 0.23113}, "CVE-2022-22169": {"epss_score": 0.00277, "epss_percentile": 0.50844}, "CVE-2022-22170": {"epss_score": 0.0039, "epss_percentile": 0.59508}, "CVE-2022-22171": {"epss_score": 0.0039, "epss_percentile": 0.59508}, "CVE-2022-22172": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2022-22173": {"epss_score": 0.00285, "epss_percentile": 0.51526}, "CVE-2022-22174": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-22175": {"epss_score": 0.00302, "epss_percentile": 0.53099}, "CVE-2022-22176": {"epss_score": 0.00078, "epss_percentile": 0.23747}, "CVE-2022-22177": {"epss_score": 0.00241, "epss_percentile": 0.47329}, "CVE-2022-22178": {"epss_score": 0.00463, "epss_percentile": 0.63698}, "CVE-2022-22179": {"epss_score": 0.00063, "epss_percentile": 0.19826}, "CVE-2022-22180": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-22181": {"epss_score": 0.00838, "epss_percentile": 0.74178}, "CVE-2022-22182": {"epss_score": 0.00653, "epss_percentile": 0.70334}, "CVE-2022-22183": {"epss_score": 0.01158, "epss_percentile": 0.7812}, "CVE-2022-22184": {"epss_score": 0.00446, "epss_percentile": 0.62914}, "CVE-2022-22185": {"epss_score": 0.00441, "epss_percentile": 0.62664}, "CVE-2022-22186": {"epss_score": 0.0039, "epss_percentile": 0.59518}, "CVE-2022-22187": {"epss_score": 0.00038, "epss_percentile": 0.11141}, "CVE-2022-22188": {"epss_score": 0.01775, "epss_percentile": 0.82216}, "CVE-2022-22189": {"epss_score": 0.00029, "epss_percentile": 0.07818}, "CVE-2022-22190": {"epss_score": 0.00996, "epss_percentile": 0.76448}, "CVE-2022-22191": {"epss_score": 0.002, "epss_percentile": 0.4227}, "CVE-2022-22192": {"epss_score": 0.00637, "epss_percentile": 0.69882}, "CVE-2022-22193": {"epss_score": 0.00051, "epss_percentile": 0.16052}, "CVE-2022-22194": {"epss_score": 0.00159, "epss_percentile": 0.37417}, "CVE-2022-22195": {"epss_score": 0.00633, "epss_percentile": 0.69766}, "CVE-2022-22196": {"epss_score": 0.00121, "epss_percentile": 0.31876}, "CVE-2022-22197": {"epss_score": 0.00787, "epss_percentile": 0.73321}, "CVE-2022-22198": {"epss_score": 0.0052, "epss_percentile": 0.66211}, "CVE-2022-22201": {"epss_score": 0.00446, "epss_percentile": 0.62914}, "CVE-2022-22202": {"epss_score": 0.00113, "epss_percentile": 0.30611}, "CVE-2022-22203": {"epss_score": 0.00114, "epss_percentile": 0.30846}, "CVE-2022-22204": {"epss_score": 0.00378, "epss_percentile": 0.58831}, "CVE-2022-22205": {"epss_score": 0.00441, "epss_percentile": 0.62664}, "CVE-2022-22206": {"epss_score": 0.0061, "epss_percentile": 0.69161}, "CVE-2022-22207": {"epss_score": 0.00457, "epss_percentile": 0.63386}, "CVE-2022-22208": {"epss_score": 0.00354, "epss_percentile": 0.57231}, "CVE-2022-22209": {"epss_score": 0.01454, "epss_percentile": 0.80383}, "CVE-2022-22210": {"epss_score": 0.00081, "epss_percentile": 0.24306}, "CVE-2022-22211": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-22212": {"epss_score": 0.00441, "epss_percentile": 0.62664}, "CVE-2022-22213": {"epss_score": 0.00278, "epss_percentile": 0.50888}, "CVE-2022-22214": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2022-22215": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2022-22216": {"epss_score": 0.00198, "epss_percentile": 0.42016}, "CVE-2022-22217": {"epss_score": 0.00242, "epss_percentile": 0.47361}, "CVE-2022-22218": {"epss_score": 0.00237, "epss_percentile": 0.46707}, "CVE-2022-22219": {"epss_score": 0.00493, "epss_percentile": 0.65033}, "CVE-2022-22220": {"epss_score": 0.00341, "epss_percentile": 0.56336}, "CVE-2022-22221": {"epss_score": 0.00084, "epss_percentile": 0.24827}, "CVE-2022-22223": {"epss_score": 0.0041, "epss_percentile": 0.60831}, "CVE-2022-22224": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2022-22225": {"epss_score": 0.00224, "epss_percentile": 0.45058}, "CVE-2022-22226": {"epss_score": 0.00112, "epss_percentile": 0.30497}, "CVE-2022-22227": {"epss_score": 0.00524, "epss_percentile": 0.66323}, "CVE-2022-22228": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-22229": {"epss_score": 0.00659, "epss_percentile": 0.70502}, "CVE-2022-22230": {"epss_score": 0.00063, "epss_percentile": 0.19826}, "CVE-2022-22231": {"epss_score": 0.00446, "epss_percentile": 0.62914}, "CVE-2022-22232": {"epss_score": 0.00447, "epss_percentile": 0.62989}, "CVE-2022-22233": {"epss_score": 0.00054, "epss_percentile": 0.1708}, "CVE-2022-22234": {"epss_score": 0.00054, "epss_percentile": 0.1708}, "CVE-2022-22235": {"epss_score": 0.0039, "epss_percentile": 0.59508}, "CVE-2022-22236": {"epss_score": 0.00446, "epss_percentile": 0.62914}, "CVE-2022-22237": {"epss_score": 0.00185, "epss_percentile": 0.40473}, "CVE-2022-22238": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2022-22239": {"epss_score": 0.00051, "epss_percentile": 0.16115}, "CVE-2022-22240": {"epss_score": 0.00056, "epss_percentile": 0.17951}, "CVE-2022-22241": {"epss_score": 0.03641, "epss_percentile": 0.8749}, "CVE-2022-22242": {"epss_score": 0.65638, "epss_percentile": 0.98429}, "CVE-2022-22243": {"epss_score": 0.0052, "epss_percentile": 0.66205}, "CVE-2022-22244": {"epss_score": 0.00947, "epss_percentile": 0.75821}, "CVE-2022-22245": {"epss_score": 0.00479, "epss_percentile": 0.64424}, "CVE-2022-22246": {"epss_score": 0.0052, "epss_percentile": 0.66191}, "CVE-2022-22247": {"epss_score": 0.00161, "epss_percentile": 0.37612}, "CVE-2022-22248": {"epss_score": 0.00032, "epss_percentile": 0.08802}, "CVE-2022-22249": {"epss_score": 0.00107, "epss_percentile": 0.29624}, "CVE-2022-22250": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2022-22251": {"epss_score": 0.00071, "epss_percentile": 0.22202}, "CVE-2022-22252": {"epss_score": 0.00225, "epss_percentile": 0.45101}, "CVE-2022-22253": {"epss_score": 0.00046, "epss_percentile": 0.14308}, "CVE-2022-22254": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-22255": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-22256": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-22257": {"epss_score": 0.00079, "epss_percentile": 0.23993}, "CVE-2022-22258": {"epss_score": 0.0034, "epss_percentile": 0.56237}, "CVE-2022-22259": {"epss_score": 0.00019, "epss_percentile": 0.04187}, "CVE-2022-22260": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-22261": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-22262": {"epss_score": 0.00133, "epss_percentile": 0.33741}, "CVE-2022-22263": {"epss_score": 0.00018, "epss_percentile": 0.04047}, "CVE-2022-22264": {"epss_score": 0.00016, "epss_percentile": 0.02625}, "CVE-2022-22265": {"epss_score": 0.00159, "epss_percentile": 0.37361}, "CVE-2022-22266": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-22267": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-22268": {"epss_score": 0.00019, "epss_percentile": 0.04296}, "CVE-2022-22269": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-22270": {"epss_score": 0.00132, "epss_percentile": 0.33556}, "CVE-2022-22271": {"epss_score": 0.00041, "epss_percentile": 0.12425}, "CVE-2022-22272": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-22273": {"epss_score": 0.01579, "epss_percentile": 0.81128}, "CVE-2022-22274": {"epss_score": 0.40439, "epss_percentile": 0.97218}, "CVE-2022-22275": {"epss_score": 0.00261, "epss_percentile": 0.4929}, "CVE-2022-22276": {"epss_score": 0.00164, "epss_percentile": 0.37972}, "CVE-2022-22277": {"epss_score": 0.00164, "epss_percentile": 0.37972}, "CVE-2022-22278": {"epss_score": 0.00261, "epss_percentile": 0.4929}, "CVE-2022-22279": {"epss_score": 0.00453, "epss_percentile": 0.63238}, "CVE-2022-22280": {"epss_score": 0.04548, "epss_percentile": 0.88837}, "CVE-2022-22281": {"epss_score": 0.00035, "epss_percentile": 0.10074}, "CVE-2022-22282": {"epss_score": 0.00355, "epss_percentile": 0.57323}, "CVE-2022-22283": {"epss_score": 0.00055, "epss_percentile": 0.17641}, "CVE-2022-22284": {"epss_score": 0.00054, "epss_percentile": 0.17336}, "CVE-2022-22285": {"epss_score": 0.00148, "epss_percentile": 0.35841}, "CVE-2022-22286": {"epss_score": 0.00148, "epss_percentile": 0.35841}, "CVE-2022-22287": {"epss_score": 0.00065, "epss_percentile": 0.20653}, "CVE-2022-22288": {"epss_score": 0.00261, "epss_percentile": 0.49255}, "CVE-2022-22289": {"epss_score": 0.00243, "epss_percentile": 0.47429}, "CVE-2022-22290": {"epss_score": 0.00305, "epss_percentile": 0.53371}, "CVE-2022-22291": {"epss_score": 0.00041, "epss_percentile": 0.12425}, "CVE-2022-22292": {"epss_score": 0.00036, "epss_percentile": 0.10515}, "CVE-2022-22293": {"epss_score": 0.00313, "epss_percentile": 0.54028}, "CVE-2022-22294": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-22295": {"epss_score": 0.00642, "epss_percentile": 0.70039}, "CVE-2022-22296": {"epss_score": 0.00131, "epss_percentile": 0.33472}, "CVE-2022-22297": {"epss_score": 0.00073, "epss_percentile": 0.22596}, "CVE-2022-22298": {"epss_score": 0.0008, "epss_percentile": 0.24011}, "CVE-2022-22299": {"epss_score": 0.00197, "epss_percentile": 0.41968}, "CVE-2022-22300": {"epss_score": 0.00143, "epss_percentile": 0.35195}, "CVE-2022-22301": {"epss_score": 0.00192, "epss_percentile": 0.41362}, "CVE-2022-22302": {"epss_score": 0.00071, "epss_percentile": 0.22197}, "CVE-2022-22303": {"epss_score": 0.00057, "epss_percentile": 0.18131}, "CVE-2022-22304": {"epss_score": 0.01743, "epss_percentile": 0.8206}, "CVE-2022-22305": {"epss_score": 0.0005, "epss_percentile": 0.15832}, "CVE-2022-22306": {"epss_score": 0.00102, "epss_percentile": 0.28777}, "CVE-2022-22307": {"epss_score": 0.0002, "epss_percentile": 0.04563}, "CVE-2022-22308": {"epss_score": 0.00165, "epss_percentile": 0.38021}, "CVE-2022-22309": {"epss_score": 0.00047, "epss_percentile": 0.14628}, "CVE-2022-22310": {"epss_score": 0.0022, "epss_percentile": 0.4462}, "CVE-2022-22311": {"epss_score": 0.00172, "epss_percentile": 0.38981}, "CVE-2022-22312": {"epss_score": 0.0057, "epss_percentile": 0.67952}, "CVE-2022-22313": {"epss_score": 0.00027, "epss_percentile": 0.06759}, "CVE-2022-22314": {"epss_score": 0.00052, "epss_percentile": 0.16338}, "CVE-2022-22315": {"epss_score": 0.00221, "epss_percentile": 0.4469}, "CVE-2022-22316": {"epss_score": 0.00198, "epss_percentile": 0.42081}, "CVE-2022-22317": {"epss_score": 0.00113, "epss_percentile": 0.30648}, "CVE-2022-22318": {"epss_score": 0.00113, "epss_percentile": 0.30648}, "CVE-2022-22319": {"epss_score": 0.0031, "epss_percentile": 0.53741}, "CVE-2022-22320": {"epss_score": 0.00195, "epss_percentile": 0.41636}, "CVE-2022-22321": {"epss_score": 0.00025, "epss_percentile": 0.06299}, "CVE-2022-22322": {"epss_score": 0.00215, "epss_percentile": 0.44092}, "CVE-2022-22323": {"epss_score": 0.0057, "epss_percentile": 0.67952}, "CVE-2022-22325": {"epss_score": 0.0004, "epss_percentile": 0.11952}, "CVE-2022-22326": {"epss_score": 0.00054, "epss_percentile": 0.17343}, "CVE-2022-22327": {"epss_score": 0.00096, "epss_percentile": 0.27394}, "CVE-2022-22328": {"epss_score": 0.00048, "epss_percentile": 0.14946}, "CVE-2022-22329": {"epss_score": 0.00172, "epss_percentile": 0.38984}, "CVE-2022-22330": {"epss_score": 0.00134, "epss_percentile": 0.33901}, "CVE-2022-22331": {"epss_score": 0.00109, "epss_percentile": 0.29918}, "CVE-2022-22332": {"epss_score": 0.00238, "epss_percentile": 0.468}, "CVE-2022-22333": {"epss_score": 0.00648, "epss_percentile": 0.70211}, "CVE-2022-22334": {"epss_score": 0.00126, "epss_percentile": 0.32732}, "CVE-2022-22336": {"epss_score": 0.0256, "epss_percentile": 0.85102}, "CVE-2022-22337": {"epss_score": 0.00302, "epss_percentile": 0.53105}, "CVE-2022-22338": {"epss_score": 0.00613, "epss_percentile": 0.69251}, "CVE-2022-22339": {"epss_score": 0.00153, "epss_percentile": 0.36626}, "CVE-2022-22344": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2022-22345": {"epss_score": 0.00195, "epss_percentile": 0.41636}, "CVE-2022-22346": {"epss_score": 0.00094, "epss_percentile": 0.27031}, "CVE-2022-22348": {"epss_score": 0.00044, "epss_percentile": 0.13676}, "CVE-2022-22349": {"epss_score": 0.00382, "epss_percentile": 0.59044}, "CVE-2022-22350": {"epss_score": 0.00043, "epss_percentile": 0.13127}, "CVE-2022-22351": {"epss_score": 0.00268, "epss_percentile": 0.50037}, "CVE-2022-22352": {"epss_score": 0.0053, "epss_percentile": 0.6661}, "CVE-2022-22353": {"epss_score": 0.00141, "epss_percentile": 0.34839}, "CVE-2022-22354": {"epss_score": 0.0018, "epss_percentile": 0.39965}, "CVE-2022-22355": {"epss_score": 0.00224, "epss_percentile": 0.45037}, "CVE-2022-22356": {"epss_score": 0.00186, "epss_percentile": 0.4063}, "CVE-2022-22358": {"epss_score": 0.00418, "epss_percentile": 0.61295}, "CVE-2022-22359": {"epss_score": 0.0008, "epss_percentile": 0.24069}, "CVE-2022-22360": {"epss_score": 0.01166, "epss_percentile": 0.7818}, "CVE-2022-22361": {"epss_score": 0.00077, "epss_percentile": 0.23548}, "CVE-2022-22363": {"epss_score": 0.00064, "epss_percentile": 0.2017}, "CVE-2022-22364": {"epss_score": 0.00028, "epss_percentile": 0.07327}, "CVE-2022-22365": {"epss_score": 0.0024, "epss_percentile": 0.46964}, "CVE-2022-22366": {"epss_score": 0.00046, "epss_percentile": 0.14276}, "CVE-2022-22367": {"epss_score": 0.00018, "epss_percentile": 0.03684}, "CVE-2022-22368": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2022-22369": {"epss_score": 0.00038, "epss_percentile": 0.11312}, "CVE-2022-22370": {"epss_score": 0.00215, "epss_percentile": 0.44092}, "CVE-2022-22371": {"epss_score": 0.00189, "epss_percentile": 0.40984}, "CVE-2022-22373": {"epss_score": 0.00133, "epss_percentile": 0.33714}, "CVE-2022-22374": {"epss_score": 0.0025, "epss_percentile": 0.48106}, "CVE-2022-22375": {"epss_score": 0.00051, "epss_percentile": 0.1631}, "CVE-2022-22377": {"epss_score": 0.0002, "epss_percentile": 0.04419}, "CVE-2022-22380": {"epss_score": 0.00026, "epss_percentile": 0.06536}, "CVE-2022-22384": {"epss_score": 0.00037, "epss_percentile": 0.10991}, "CVE-2022-22385": {"epss_score": 0.00032, "epss_percentile": 0.08825}, "CVE-2022-22386": {"epss_score": 0.0002, "epss_percentile": 0.04419}, "CVE-2022-22387": {"epss_score": 0.00235, "epss_percentile": 0.46224}, "CVE-2022-22389": {"epss_score": 0.00119, "epss_percentile": 0.31647}, "CVE-2022-22390": {"epss_score": 0.0009, "epss_percentile": 0.26039}, "CVE-2022-22391": {"epss_score": 0.00119, "epss_percentile": 0.31669}, "CVE-2022-22392": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-22393": {"epss_score": 0.00181, "epss_percentile": 0.40029}, "CVE-2022-22394": {"epss_score": 0.05327, "epss_percentile": 0.89736}, "CVE-2022-22396": {"epss_score": 0.00087, "epss_percentile": 0.2551}, "CVE-2022-22399": {"epss_score": 0.00101, "epss_percentile": 0.28602}, "CVE-2022-22401": {"epss_score": 0.00019, "epss_percentile": 0.0407}, "CVE-2022-22402": {"epss_score": 0.00135, "epss_percentile": 0.34016}, "CVE-2022-22404": {"epss_score": 0.00198, "epss_percentile": 0.42014}, "CVE-2022-22405": {"epss_score": 0.00016, "epss_percentile": 0.02935}, "CVE-2022-22409": {"epss_score": 0.00097, "epss_percentile": 0.27579}, "CVE-2022-22410": {"epss_score": 0.00276, "epss_percentile": 0.50756}, "CVE-2022-22411": {"epss_score": 0.00094, "epss_percentile": 0.26998}, "CVE-2022-22412": {"epss_score": 0.00085, "epss_percentile": 0.25071}, "CVE-2022-22413": {"epss_score": 0.00261, "epss_percentile": 0.49261}, "CVE-2022-22414": {"epss_score": 0.0004, "epss_percentile": 0.11952}, "CVE-2022-22415": {"epss_score": 0.00161, "epss_percentile": 0.37615}, "CVE-2022-22416": {"epss_score": 0.00097, "epss_percentile": 0.27559}, "CVE-2022-22417": {"epss_score": 0.00121, "epss_percentile": 0.32005}, "CVE-2022-22423": {"epss_score": 0.00038, "epss_percentile": 0.11312}, "CVE-2022-22424": {"epss_score": 0.00028, "epss_percentile": 0.07569}, "CVE-2022-22425": {"epss_score": 0.0042, "epss_percentile": 0.61447}, "CVE-2022-22426": {"epss_score": 0.00038, "epss_percentile": 0.11385}, "CVE-2022-22427": {"epss_score": 0.00191, "epss_percentile": 0.41208}, "CVE-2022-22433": {"epss_score": 0.00248, "epss_percentile": 0.47951}, "CVE-2022-22434": {"epss_score": 0.00048, "epss_percentile": 0.14946}, "CVE-2022-22435": {"epss_score": 0.00215, "epss_percentile": 0.44092}, "CVE-2022-22436": {"epss_score": 0.00215, "epss_percentile": 0.44092}, "CVE-2022-22441": {"epss_score": 0.00186, "epss_percentile": 0.40683}, "CVE-2022-22442": {"epss_score": 0.00221, "epss_percentile": 0.44669}, "CVE-2022-22443": {"epss_score": 0.00215, "epss_percentile": 0.44092}, "CVE-2022-22444": {"epss_score": 0.00108, "epss_percentile": 0.29858}, "CVE-2022-22445": {"epss_score": 0.0022, "epss_percentile": 0.44573}, "CVE-2022-22447": {"epss_score": 0.00057, "epss_percentile": 0.1798}, "CVE-2022-22449": {"epss_score": 0.001, "epss_percentile": 0.28495}, "CVE-2022-22450": {"epss_score": 0.00149, "epss_percentile": 0.35999}, "CVE-2022-22452": {"epss_score": 0.00143, "epss_percentile": 0.35108}, "CVE-2022-22453": {"epss_score": 0.00059, "epss_percentile": 0.18682}, "CVE-2022-22454": {"epss_score": 0.00118, "epss_percentile": 0.31506}, "CVE-2022-22455": {"epss_score": 0.00116, "epss_percentile": 0.31191}, "CVE-2022-22456": {"epss_score": 0.0026, "epss_percentile": 0.49099}, "CVE-2022-22457": {"epss_score": 0.00019, "epss_percentile": 0.04248}, "CVE-2022-22458": {"epss_score": 0.00142, "epss_percentile": 0.35011}, "CVE-2022-22460": {"epss_score": 0.00191, "epss_percentile": 0.4119}, "CVE-2022-22461": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2022-22462": {"epss_score": 0.00044, "epss_percentile": 0.13386}, "CVE-2022-22463": {"epss_score": 0.00239, "epss_percentile": 0.46911}, "CVE-2022-22464": {"epss_score": 0.00112, "epss_percentile": 0.30472}, "CVE-2022-22465": {"epss_score": 0.00032, "epss_percentile": 0.08852}, "CVE-2022-22466": {"epss_score": 0.00077, "epss_percentile": 0.23401}, "CVE-2022-22470": {"epss_score": 9e-05, "epss_percentile": 0.00713}, "CVE-2022-22472": {"epss_score": 0.00203, "epss_percentile": 0.4254}, "CVE-2022-22473": {"epss_score": 0.00075, "epss_percentile": 0.23033}, "CVE-2022-22474": {"epss_score": 0.00355, "epss_percentile": 0.57278}, "CVE-2022-22475": {"epss_score": 0.00086, "epss_percentile": 0.25355}, "CVE-2022-22476": {"epss_score": 0.00089, "epss_percentile": 0.25947}, "CVE-2022-22477": {"epss_score": 0.00487, "epss_percentile": 0.64812}, "CVE-2022-22478": {"epss_score": 0.00054, "epss_percentile": 0.17078}, "CVE-2022-22479": {"epss_score": 0.00089, "epss_percentile": 0.25929}, "CVE-2022-22480": {"epss_score": 0.00238, "epss_percentile": 0.46756}, "CVE-2022-22481": {"epss_score": 0.00172, "epss_percentile": 0.39005}, "CVE-2022-22482": {"epss_score": 0.00198, "epss_percentile": 0.42081}, "CVE-2022-22483": {"epss_score": 0.00236, "epss_percentile": 0.46418}, "CVE-2022-22484": {"epss_score": 0.00019, "epss_percentile": 0.04135}, "CVE-2022-22485": {"epss_score": 0.00182, "epss_percentile": 0.40189}, "CVE-2022-22486": {"epss_score": 0.00028, "epss_percentile": 0.07513}, "CVE-2022-22487": {"epss_score": 0.00276, "epss_percentile": 0.50735}, "CVE-2022-22488": {"epss_score": 0.00114, "epss_percentile": 0.30862}, "CVE-2022-22489": {"epss_score": 0.00606, "epss_percentile": 0.69004}, "CVE-2022-22490": {"epss_score": 0.00262, "epss_percentile": 0.4939}, "CVE-2022-22491": {"epss_score": 0.00025, "epss_percentile": 0.06298}, "CVE-2022-22493": {"epss_score": 0.00111, "epss_percentile": 0.30271}, "CVE-2022-22494": {"epss_score": 0.00471, "epss_percentile": 0.63999}, "CVE-2022-22495": {"epss_score": 0.00221, "epss_percentile": 0.44651}, "CVE-2022-22496": {"epss_score": 0.00131, "epss_percentile": 0.3336}, "CVE-2022-22497": {"epss_score": 0.00286, "epss_percentile": 0.51696}, "CVE-2022-22502": {"epss_score": 0.00215, "epss_percentile": 0.44092}, "CVE-2022-22503": {"epss_score": 0.00121, "epss_percentile": 0.31946}, "CVE-2022-22505": {"epss_score": 0.00206, "epss_percentile": 0.43047}, "CVE-2022-22506": {"epss_score": 0.00037, "epss_percentile": 0.10729}, "CVE-2022-22508": {"epss_score": 0.00107, "epss_percentile": 0.2975}, "CVE-2022-22509": {"epss_score": 0.00285, "epss_percentile": 0.51662}, "CVE-2022-22510": {"epss_score": 0.00442, "epss_percentile": 0.6274}, "CVE-2022-22511": {"epss_score": 0.00074, "epss_percentile": 0.22875}, "CVE-2022-22512": {"epss_score": 0.00103, "epss_percentile": 0.28988}, "CVE-2022-22513": {"epss_score": 0.00548, "epss_percentile": 0.67277}, "CVE-2022-22514": {"epss_score": 0.00683, "epss_percentile": 0.71102}, "CVE-2022-22515": {"epss_score": 0.00279, "epss_percentile": 0.50955}, "CVE-2022-22516": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2022-22517": {"epss_score": 0.01034, "epss_percentile": 0.76883}, "CVE-2022-22518": {"epss_score": 0.0016, "epss_percentile": 0.375}, "CVE-2022-22519": {"epss_score": 0.01306, "epss_percentile": 0.79333}, "CVE-2022-22520": {"epss_score": 0.00299, "epss_percentile": 0.52845}, "CVE-2022-22521": {"epss_score": 0.00123, "epss_percentile": 0.32202}, "CVE-2022-22522": {"epss_score": 0.02078, "epss_percentile": 0.83517}, "CVE-2022-22523": {"epss_score": 0.00217, "epss_percentile": 0.44256}, "CVE-2022-22524": {"epss_score": 0.01276, "epss_percentile": 0.79107}, "CVE-2022-22525": {"epss_score": 0.00679, "epss_percentile": 0.71009}, "CVE-2022-22526": {"epss_score": 0.00331, "epss_percentile": 0.5551}, "CVE-2022-22528": {"epss_score": 0.0012, "epss_percentile": 0.31701}, "CVE-2022-22529": {"epss_score": 0.00454, "epss_percentile": 0.63264}, "CVE-2022-22530": {"epss_score": 0.00487, "epss_percentile": 0.64808}, "CVE-2022-22531": {"epss_score": 0.00373, "epss_percentile": 0.58503}, "CVE-2022-22532": {"epss_score": 0.02075, "epss_percentile": 0.83501}, "CVE-2022-22533": {"epss_score": 0.00752, "epss_percentile": 0.7265}, "CVE-2022-22534": {"epss_score": 0.01469, "epss_percentile": 0.80491}, "CVE-2022-22535": {"epss_score": 0.00187, "epss_percentile": 0.40744}, "CVE-2022-22536": {"epss_score": 0.93833, "epss_percentile": 0.99853}, "CVE-2022-22537": {"epss_score": 0.00379, "epss_percentile": 0.58847}, "CVE-2022-22538": {"epss_score": 0.00253, "epss_percentile": 0.4848}, "CVE-2022-22539": {"epss_score": 0.00253, "epss_percentile": 0.4848}, "CVE-2022-22540": {"epss_score": 0.00447, "epss_percentile": 0.62982}, "CVE-2022-22541": {"epss_score": 0.00285, "epss_percentile": 0.51513}, "CVE-2022-22542": {"epss_score": 0.00699, "epss_percentile": 0.71454}, "CVE-2022-22543": {"epss_score": 0.00578, "epss_percentile": 0.68201}, "CVE-2022-22544": {"epss_score": 0.0043, "epss_percentile": 0.62027}, "CVE-2022-22545": {"epss_score": 0.00362, "epss_percentile": 0.57763}, "CVE-2022-22546": {"epss_score": 0.00378, "epss_percentile": 0.58781}, "CVE-2022-22547": {"epss_score": 0.00617, "epss_percentile": 0.69344}, "CVE-2022-22549": {"epss_score": 0.00385, "epss_percentile": 0.59218}, "CVE-2022-22550": {"epss_score": 0.00036, "epss_percentile": 0.10455}, "CVE-2022-22551": {"epss_score": 0.00139, "epss_percentile": 0.34563}, "CVE-2022-22552": {"epss_score": 0.00209, "epss_percentile": 0.43403}, "CVE-2022-22553": {"epss_score": 0.00464, "epss_percentile": 0.63705}, "CVE-2022-22554": {"epss_score": 0.00042, "epss_percentile": 0.12714}, "CVE-2022-22555": {"epss_score": 0.00564, "epss_percentile": 0.67748}, "CVE-2022-22556": {"epss_score": 0.00686, "epss_percentile": 0.71164}, "CVE-2022-22557": {"epss_score": 0.00039, "epss_percentile": 0.11791}, "CVE-2022-22558": {"epss_score": 0.00123, "epss_percentile": 0.32287}, "CVE-2022-22559": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2022-22560": {"epss_score": 0.00034, "epss_percentile": 0.09565}, "CVE-2022-22561": {"epss_score": 0.00883, "epss_percentile": 0.7492}, "CVE-2022-22562": {"epss_score": 0.00458, "epss_percentile": 0.634}, "CVE-2022-22563": {"epss_score": 0.00042, "epss_percentile": 0.12831}, "CVE-2022-22564": {"epss_score": 0.0007, "epss_percentile": 0.21719}, "CVE-2022-22565": {"epss_score": 0.00132, "epss_percentile": 0.33538}, "CVE-2022-22566": {"epss_score": 0.00042, "epss_percentile": 0.12747}, "CVE-2022-22567": {"epss_score": 0.00022, "epss_percentile": 0.05303}, "CVE-2022-22570": {"epss_score": 0.00543, "epss_percentile": 0.67119}, "CVE-2022-22571": {"epss_score": 0.00146, "epss_percentile": 0.35602}, "CVE-2022-22572": {"epss_score": 0.24665, "epss_percentile": 0.95945}, "CVE-2022-22576": {"epss_score": 0.00241, "epss_percentile": 0.47286}, "CVE-2022-22577": {"epss_score": 0.00287, "epss_percentile": 0.51819}, "CVE-2022-22578": {"epss_score": 0.00299, "epss_percentile": 0.52851}, "CVE-2022-22579": {"epss_score": 0.003, "epss_percentile": 0.52974}, "CVE-2022-22582": {"epss_score": 0.02476, "epss_percentile": 0.84862}, "CVE-2022-22583": {"epss_score": 0.00107, "epss_percentile": 0.29651}, "CVE-2022-22584": {"epss_score": 0.00452, "epss_percentile": 0.63189}, "CVE-2022-22585": {"epss_score": 0.00572, "epss_percentile": 0.68018}, "CVE-2022-22586": {"epss_score": 0.00841, "epss_percentile": 0.74227}, "CVE-2022-22587": {"epss_score": 0.00373, "epss_percentile": 0.58474}, "CVE-2022-22588": {"epss_score": 0.00226, "epss_percentile": 0.45251}, "CVE-2022-22589": {"epss_score": 0.00925, "epss_percentile": 0.75534}, "CVE-2022-22590": {"epss_score": 0.00635, "epss_percentile": 0.69815}, "CVE-2022-22591": {"epss_score": 0.00305, "epss_percentile": 0.53316}, "CVE-2022-22592": {"epss_score": 0.00282, "epss_percentile": 0.51231}, "CVE-2022-22593": {"epss_score": 0.01307, "epss_percentile": 0.79341}, "CVE-2022-22594": {"epss_score": 0.00216, "epss_percentile": 0.44172}, "CVE-2022-22596": {"epss_score": 0.00039, "epss_percentile": 0.11673}, "CVE-2022-22597": {"epss_score": 0.00391, "epss_percentile": 0.59594}, "CVE-2022-22598": {"epss_score": 0.00146, "epss_percentile": 0.35581}, "CVE-2022-22599": {"epss_score": 0.00103, "epss_percentile": 0.28978}, "CVE-2022-22600": {"epss_score": 0.01865, "epss_percentile": 0.82603}, "CVE-2022-22601": {"epss_score": 0.0044, "epss_percentile": 0.62641}, "CVE-2022-22602": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-22603": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-22604": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-22605": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-22606": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-22607": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-22608": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-22609": {"epss_score": 0.00256, "epss_percentile": 0.48824}, "CVE-2022-22610": {"epss_score": 0.00961, "epss_percentile": 0.75982}, "CVE-2022-22611": {"epss_score": 0.00568, "epss_percentile": 0.67885}, "CVE-2022-22612": {"epss_score": 0.00285, "epss_percentile": 0.51517}, "CVE-2022-22613": {"epss_score": 0.00619, "epss_percentile": 0.69428}, "CVE-2022-22614": {"epss_score": 0.00763, "epss_percentile": 0.72855}, "CVE-2022-22615": {"epss_score": 0.00763, "epss_percentile": 0.72855}, "CVE-2022-22616": {"epss_score": 0.17636, "epss_percentile": 0.94882}, "CVE-2022-22617": {"epss_score": 0.00143, "epss_percentile": 0.35094}, "CVE-2022-22618": {"epss_score": 0.00043, "epss_percentile": 0.13341}, "CVE-2022-22620": {"epss_score": 0.04022, "epss_percentile": 0.88134}, "CVE-2022-22621": {"epss_score": 0.00072, "epss_percentile": 0.22309}, "CVE-2022-22622": {"epss_score": 0.00078, "epss_percentile": 0.23572}, "CVE-2022-22624": {"epss_score": 0.00402, "epss_percentile": 0.60306}, "CVE-2022-22625": {"epss_score": 0.00353, "epss_percentile": 0.57134}, "CVE-2022-22626": {"epss_score": 0.00347, "epss_percentile": 0.56746}, "CVE-2022-22627": {"epss_score": 0.00347, "epss_percentile": 0.56746}, "CVE-2022-22628": {"epss_score": 0.00186, "epss_percentile": 0.40603}, "CVE-2022-22629": {"epss_score": 0.19764, "epss_percentile": 0.95238}, "CVE-2022-22630": {"epss_score": 0.00442, "epss_percentile": 0.62744}, "CVE-2022-22631": {"epss_score": 0.00136, "epss_percentile": 0.34201}, "CVE-2022-22632": {"epss_score": 0.00871, "epss_percentile": 0.74712}, "CVE-2022-22633": {"epss_score": 0.00243, "epss_percentile": 0.47506}, "CVE-2022-22634": {"epss_score": 0.00307, "epss_percentile": 0.53505}, "CVE-2022-22635": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2022-22636": {"epss_score": 0.00213, "epss_percentile": 0.43892}, "CVE-2022-22637": {"epss_score": 0.0037, "epss_percentile": 0.58286}, "CVE-2022-22638": {"epss_score": 0.01019, "epss_percentile": 0.76721}, "CVE-2022-22639": {"epss_score": 0.07681, "epss_percentile": 0.91622}, "CVE-2022-22640": {"epss_score": 0.00256, "epss_percentile": 0.48833}, "CVE-2022-22641": {"epss_score": 0.00851, "epss_percentile": 0.74399}, "CVE-2022-22642": {"epss_score": 0.00256, "epss_percentile": 0.4883}, "CVE-2022-22643": {"epss_score": 0.00289, "epss_percentile": 0.52015}, "CVE-2022-22644": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2022-22646": {"epss_score": 0.00046, "epss_percentile": 0.14112}, "CVE-2022-22647": {"epss_score": 0.00098, "epss_percentile": 0.27747}, "CVE-2022-22648": {"epss_score": 0.00148, "epss_percentile": 0.35824}, "CVE-2022-22650": {"epss_score": 0.00096, "epss_percentile": 0.27265}, "CVE-2022-22651": {"epss_score": 0.00382, "epss_percentile": 0.59043}, "CVE-2022-22652": {"epss_score": 0.00065, "epss_percentile": 0.20452}, "CVE-2022-22653": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2022-22654": {"epss_score": 0.00222, "epss_percentile": 0.44753}, "CVE-2022-22655": {"epss_score": 0.00072, "epss_percentile": 0.22413}, "CVE-2022-22656": {"epss_score": 0.00138, "epss_percentile": 0.34466}, "CVE-2022-22657": {"epss_score": 0.00529, "epss_percentile": 0.66592}, "CVE-2022-22658": {"epss_score": 0.00268, "epss_percentile": 0.50069}, "CVE-2022-22659": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2022-22660": {"epss_score": 0.00194, "epss_percentile": 0.41528}, "CVE-2022-22661": {"epss_score": 0.00384, "epss_percentile": 0.59132}, "CVE-2022-22662": {"epss_score": 0.00299, "epss_percentile": 0.52852}, "CVE-2022-22663": {"epss_score": 0.0026, "epss_percentile": 0.49102}, "CVE-2022-22664": {"epss_score": 0.00691, "epss_percentile": 0.7127}, "CVE-2022-22665": {"epss_score": 0.00335, "epss_percentile": 0.55801}, "CVE-2022-22666": {"epss_score": 0.00266, "epss_percentile": 0.49874}, "CVE-2022-22667": {"epss_score": 0.00386, "epss_percentile": 0.59276}, "CVE-2022-22668": {"epss_score": 0.0006, "epss_percentile": 0.19219}, "CVE-2022-22669": {"epss_score": 0.00071, "epss_percentile": 0.21989}, "CVE-2022-22670": {"epss_score": 0.00232, "epss_percentile": 0.45901}, "CVE-2022-22671": {"epss_score": 0.00059, "epss_percentile": 0.18694}, "CVE-2022-22672": {"epss_score": 0.00317, "epss_percentile": 0.54334}, "CVE-2022-22673": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-22674": {"epss_score": 0.00233, "epss_percentile": 0.46058}, "CVE-2022-22675": {"epss_score": 0.00978, "epss_percentile": 0.76234}, "CVE-2022-22676": {"epss_score": 0.00246, "epss_percentile": 0.47791}, "CVE-2022-22677": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2022-22679": {"epss_score": 0.00267, "epss_percentile": 0.49973}, "CVE-2022-22680": {"epss_score": 0.00211, "epss_percentile": 0.43712}, "CVE-2022-22681": {"epss_score": 0.00356, "epss_percentile": 0.57356}, "CVE-2022-22682": {"epss_score": 0.00127, "epss_percentile": 0.32783}, "CVE-2022-22683": {"epss_score": 0.03547, "epss_percentile": 0.87331}, "CVE-2022-22684": {"epss_score": 0.01811, "epss_percentile": 0.82368}, "CVE-2022-22685": {"epss_score": 0.00951, "epss_percentile": 0.75863}, "CVE-2022-22686": {"epss_score": 0.00115, "epss_percentile": 0.31029}, "CVE-2022-22687": {"epss_score": 0.05341, "epss_percentile": 0.89762}, "CVE-2022-22688": {"epss_score": 0.01024, "epss_percentile": 0.76776}, "CVE-2022-22689": {"epss_score": 0.02277, "epss_percentile": 0.84229}, "CVE-2022-22690": {"epss_score": 0.00303, "epss_percentile": 0.53176}, "CVE-2022-22691": {"epss_score": 0.00255, "epss_percentile": 0.48719}, "CVE-2022-22700": {"epss_score": 0.00256, "epss_percentile": 0.48772}, "CVE-2022-22701": {"epss_score": 0.00278, "epss_percentile": 0.5088}, "CVE-2022-22702": {"epss_score": 0.00159, "epss_percentile": 0.37404}, "CVE-2022-22703": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2022-22704": {"epss_score": 0.00418, "epss_percentile": 0.61345}, "CVE-2022-22706": {"epss_score": 0.00093, "epss_percentile": 0.26722}, "CVE-2022-22707": {"epss_score": 0.00304, "epss_percentile": 0.53298}, "CVE-2022-22709": {"epss_score": 0.01894, "epss_percentile": 0.82743}, "CVE-2022-22710": {"epss_score": 0.00383, "epss_percentile": 0.59091}, "CVE-2022-22711": {"epss_score": 0.00278, "epss_percentile": 0.50887}, "CVE-2022-22712": {"epss_score": 0.00212, "epss_percentile": 0.43721}, "CVE-2022-22713": {"epss_score": 0.00195, "epss_percentile": 0.41657}, "CVE-2022-22715": {"epss_score": 0.19913, "epss_percentile": 0.95259}, "CVE-2022-22716": {"epss_score": 0.02801, "epss_percentile": 0.85696}, "CVE-2022-22717": {"epss_score": 0.00426, "epss_percentile": 0.61769}, "CVE-2022-22718": {"epss_score": 0.1103, "epss_percentile": 0.93194}, "CVE-2022-22719": {"epss_score": 0.32203, "epss_percentile": 0.96679}, "CVE-2022-22720": {"epss_score": 0.33369, "epss_percentile": 0.96767}, "CVE-2022-22721": {"epss_score": 0.18952, "epss_percentile": 0.95101}, "CVE-2022-22722": {"epss_score": 0.00158, "epss_percentile": 0.37245}, "CVE-2022-22723": {"epss_score": 0.00071, "epss_percentile": 0.22084}, "CVE-2022-22724": {"epss_score": 0.00482, "epss_percentile": 0.64532}, "CVE-2022-22725": {"epss_score": 0.00071, "epss_percentile": 0.22084}, "CVE-2022-22726": {"epss_score": 0.00328, "epss_percentile": 0.55177}, "CVE-2022-22727": {"epss_score": 0.00929, "epss_percentile": 0.75594}, "CVE-2022-22728": {"epss_score": 0.01797, "epss_percentile": 0.82309}, "CVE-2022-22729": {"epss_score": 0.00143, "epss_percentile": 0.35092}, "CVE-2022-22730": {"epss_score": 0.00404, "epss_percentile": 0.6045}, "CVE-2022-22731": {"epss_score": 0.00253, "epss_percentile": 0.48445}, "CVE-2022-22732": {"epss_score": 0.00156, "epss_percentile": 0.36879}, "CVE-2022-22733": {"epss_score": 0.86064, "epss_percentile": 0.99364}, "CVE-2022-22734": {"epss_score": 0.00209, "epss_percentile": 0.43363}, "CVE-2022-22735": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2022-22736": {"epss_score": 0.00109, "epss_percentile": 0.3006}, "CVE-2022-22737": {"epss_score": 0.00172, "epss_percentile": 0.38938}, "CVE-2022-22738": {"epss_score": 0.00222, "epss_percentile": 0.44758}, "CVE-2022-22739": {"epss_score": 0.00158, "epss_percentile": 0.37202}, "CVE-2022-22740": {"epss_score": 0.00222, "epss_percentile": 0.44758}, "CVE-2022-22741": {"epss_score": 0.00186, "epss_percentile": 0.4068}, "CVE-2022-22742": {"epss_score": 0.00102, "epss_percentile": 0.28762}, "CVE-2022-22743": {"epss_score": 0.00151, "epss_percentile": 0.36334}, "CVE-2022-22744": {"epss_score": 0.00758, "epss_percentile": 0.72774}, "CVE-2022-22745": {"epss_score": 0.00225, "epss_percentile": 0.45141}, "CVE-2022-22746": {"epss_score": 0.0012, "epss_percentile": 0.31785}, "CVE-2022-22747": {"epss_score": 0.00091, "epss_percentile": 0.26228}, "CVE-2022-22748": {"epss_score": 0.00445, "epss_percentile": 0.62883}, "CVE-2022-22749": {"epss_score": 0.00308, "epss_percentile": 0.53643}, "CVE-2022-22750": {"epss_score": 0.00323, "epss_percentile": 0.54917}, "CVE-2022-22751": {"epss_score": 0.00231, "epss_percentile": 0.45799}, "CVE-2022-22752": {"epss_score": 0.00369, "epss_percentile": 0.58262}, "CVE-2022-22753": {"epss_score": 0.00411, "epss_percentile": 0.60875}, "CVE-2022-22754": {"epss_score": 0.00032, "epss_percentile": 0.08766}, "CVE-2022-22755": {"epss_score": 0.00629, "epss_percentile": 0.69674}, "CVE-2022-22756": {"epss_score": 0.00222, "epss_percentile": 0.4472}, "CVE-2022-22757": {"epss_score": 0.00191, "epss_percentile": 0.41271}, "CVE-2022-22758": {"epss_score": 0.00152, "epss_percentile": 0.36375}, "CVE-2022-22759": {"epss_score": 0.00215, "epss_percentile": 0.44041}, "CVE-2022-22760": {"epss_score": 0.0021, "epss_percentile": 0.43447}, "CVE-2022-22761": {"epss_score": 0.00228, "epss_percentile": 0.4552}, "CVE-2022-22762": {"epss_score": 0.00291, "epss_percentile": 0.52187}, "CVE-2022-22763": {"epss_score": 0.00179, "epss_percentile": 0.39842}, "CVE-2022-22764": {"epss_score": 0.00196, "epss_percentile": 0.41801}, "CVE-2022-22765": {"epss_score": 0.00054, "epss_percentile": 0.1709}, "CVE-2022-22766": {"epss_score": 0.00049, "epss_percentile": 0.15355}, "CVE-2022-22767": {"epss_score": 0.00228, "epss_percentile": 0.45497}, "CVE-2022-22769": {"epss_score": 0.00433, "epss_percentile": 0.62207}, "CVE-2022-22770": {"epss_score": 0.0193, "epss_percentile": 0.82939}, "CVE-2022-22771": {"epss_score": 0.0025, "epss_percentile": 0.48105}, "CVE-2022-22772": {"epss_score": 0.01471, "epss_percentile": 0.80501}, "CVE-2022-22773": {"epss_score": 0.00569, "epss_percentile": 0.67921}, "CVE-2022-22774": {"epss_score": 0.00661, "epss_percentile": 0.7057}, "CVE-2022-22775": {"epss_score": 0.00569, "epss_percentile": 0.67921}, "CVE-2022-22776": {"epss_score": 0.00584, "epss_percentile": 0.68383}, "CVE-2022-22777": {"epss_score": 0.00553, "epss_percentile": 0.67414}, "CVE-2022-22778": {"epss_score": 0.00211, "epss_percentile": 0.43635}, "CVE-2022-22779": {"epss_score": 0.00212, "epss_percentile": 0.43808}, "CVE-2022-22780": {"epss_score": 0.00907, "epss_percentile": 0.75261}, "CVE-2022-22781": {"epss_score": 0.00112, "epss_percentile": 0.30416}, "CVE-2022-22782": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2022-22783": {"epss_score": 0.00565, "epss_percentile": 0.67798}, "CVE-2022-22784": {"epss_score": 0.01618, "epss_percentile": 0.8137}, "CVE-2022-22785": {"epss_score": 0.00182, "epss_percentile": 0.40272}, "CVE-2022-22786": {"epss_score": 0.00331, "epss_percentile": 0.55539}, "CVE-2022-22787": {"epss_score": 0.00331, "epss_percentile": 0.55516}, "CVE-2022-22788": {"epss_score": 0.00613, "epss_percentile": 0.6926}, "CVE-2022-22789": {"epss_score": 0.00056, "epss_percentile": 0.1782}, "CVE-2022-22790": {"epss_score": 0.0152, "epss_percentile": 0.80824}, "CVE-2022-22791": {"epss_score": 0.00117, "epss_percentile": 0.31227}, "CVE-2022-22792": {"epss_score": 0.00155, "epss_percentile": 0.36832}, "CVE-2022-22793": {"epss_score": 0.00305, "epss_percentile": 0.53372}, "CVE-2022-22794": {"epss_score": 0.00876, "epss_percentile": 0.74791}, "CVE-2022-22795": {"epss_score": 0.00244, "epss_percentile": 0.47584}, "CVE-2022-22796": {"epss_score": 0.00229, "epss_percentile": 0.45652}, "CVE-2022-22797": {"epss_score": 0.00169, "epss_percentile": 0.38645}, "CVE-2022-22798": {"epss_score": 0.00236, "epss_percentile": 0.46427}, "CVE-2022-22804": {"epss_score": 0.00504, "epss_percentile": 0.65491}, "CVE-2022-22805": {"epss_score": 0.13441, "epss_percentile": 0.93965}, "CVE-2022-22806": {"epss_score": 0.00206, "epss_percentile": 0.42952}, "CVE-2022-22807": {"epss_score": 0.00206, "epss_percentile": 0.43072}, "CVE-2022-22808": {"epss_score": 0.00077, "epss_percentile": 0.23542}, "CVE-2022-22809": {"epss_score": 0.00508, "epss_percentile": 0.65708}, "CVE-2022-22810": {"epss_score": 0.00301, "epss_percentile": 0.53076}, "CVE-2022-22811": {"epss_score": 0.00104, "epss_percentile": 0.29186}, "CVE-2022-22812": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-22813": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2022-22814": {"epss_score": 0.00539, "epss_percentile": 0.6696}, "CVE-2022-22815": {"epss_score": 0.00095, "epss_percentile": 0.27167}, "CVE-2022-22816": {"epss_score": 0.00138, "epss_percentile": 0.34345}, "CVE-2022-22817": {"epss_score": 0.02781, "epss_percentile": 0.8565}, "CVE-2022-22818": {"epss_score": 0.01011, "epss_percentile": 0.76616}, "CVE-2022-22819": {"epss_score": 0.00781, "epss_percentile": 0.7318}, "CVE-2022-22820": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2022-22821": {"epss_score": 0.00154, "epss_percentile": 0.36739}, "CVE-2022-22822": {"epss_score": 0.01328, "epss_percentile": 0.79501}, "CVE-2022-22823": {"epss_score": 0.00431, "epss_percentile": 0.62056}, "CVE-2022-22824": {"epss_score": 0.00431, "epss_percentile": 0.62056}, "CVE-2022-22825": {"epss_score": 0.00206, "epss_percentile": 0.42769}, "CVE-2022-22826": {"epss_score": 0.00206, "epss_percentile": 0.42769}, "CVE-2022-22827": {"epss_score": 0.00279, "epss_percentile": 0.50984}, "CVE-2022-22828": {"epss_score": 0.00737, "epss_percentile": 0.72321}, "CVE-2022-22831": {"epss_score": 0.15862, "epss_percentile": 0.94522}, "CVE-2022-22832": {"epss_score": 0.17581, "epss_percentile": 0.94871}, "CVE-2022-22833": {"epss_score": 0.18718, "epss_percentile": 0.95058}, "CVE-2022-22834": {"epss_score": 0.0424, "epss_percentile": 0.88432}, "CVE-2022-22835": {"epss_score": 0.00349, "epss_percentile": 0.56903}, "CVE-2022-22836": {"epss_score": 0.03128, "epss_percentile": 0.86461}, "CVE-2022-22844": {"epss_score": 0.00059, "epss_percentile": 0.18707}, "CVE-2022-22845": {"epss_score": 0.1348, "epss_percentile": 0.93977}, "CVE-2022-22846": {"epss_score": 0.0032, "epss_percentile": 0.54592}, "CVE-2022-22847": {"epss_score": 0.00462, "epss_percentile": 0.63582}, "CVE-2022-22850": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2022-22851": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2022-22852": {"epss_score": 0.00261, "epss_percentile": 0.49309}, "CVE-2022-22853": {"epss_score": 0.00353, "epss_percentile": 0.5716}, "CVE-2022-22854": {"epss_score": 0.0031, "epss_percentile": 0.53799}, "CVE-2022-22868": {"epss_score": 0.0028, "epss_percentile": 0.51094}, "CVE-2022-22880": {"epss_score": 0.01031, "epss_percentile": 0.76852}, "CVE-2022-22881": {"epss_score": 0.01031, "epss_percentile": 0.76852}, "CVE-2022-22885": {"epss_score": 0.00617, "epss_percentile": 0.69345}, "CVE-2022-22888": {"epss_score": 0.00195, "epss_percentile": 0.41682}, "CVE-2022-22890": {"epss_score": 0.0021, "epss_percentile": 0.4343}, "CVE-2022-22891": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2022-22892": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2022-22893": {"epss_score": 0.00178, "epss_percentile": 0.3974}, "CVE-2022-22894": {"epss_score": 0.00178, "epss_percentile": 0.3974}, "CVE-2022-22895": {"epss_score": 0.00168, "epss_percentile": 0.38503}, "CVE-2022-22897": {"epss_score": 0.9012, "epss_percentile": 0.99562}, "CVE-2022-22899": {"epss_score": 0.00181, "epss_percentile": 0.40126}, "CVE-2022-22901": {"epss_score": 0.00244, "epss_percentile": 0.47586}, "CVE-2022-22908": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2022-22909": {"epss_score": 0.33104, "epss_percentile": 0.96747}, "CVE-2022-22912": {"epss_score": 0.02156, "epss_percentile": 0.8381}, "CVE-2022-22914": {"epss_score": 0.00741, "epss_percentile": 0.72436}, "CVE-2022-22916": {"epss_score": 0.90189, "epss_percentile": 0.99567}, "CVE-2022-22919": {"epss_score": 0.00173, "epss_percentile": 0.39119}, "CVE-2022-22922": {"epss_score": 0.00508, "epss_percentile": 0.65708}, "CVE-2022-22928": {"epss_score": 0.02316, "epss_percentile": 0.84357}, "CVE-2022-22929": {"epss_score": 0.02652, "epss_percentile": 0.85347}, "CVE-2022-22930": {"epss_score": 0.10718, "epss_percentile": 0.93082}, "CVE-2022-22931": {"epss_score": 0.02834, "epss_percentile": 0.85782}, "CVE-2022-22932": {"epss_score": 0.00499, "epss_percentile": 0.65249}, "CVE-2022-22934": {"epss_score": 0.00092, "epss_percentile": 0.26548}, "CVE-2022-22935": {"epss_score": 0.00078, "epss_percentile": 0.23661}, "CVE-2022-22936": {"epss_score": 0.00082, "epss_percentile": 0.24565}, "CVE-2022-22938": {"epss_score": 0.00078, "epss_percentile": 0.23732}, "CVE-2022-22939": {"epss_score": 0.00478, "epss_percentile": 0.64407}, "CVE-2022-22941": {"epss_score": 0.00014, "epss_percentile": 0.02068}, "CVE-2022-22942": {"epss_score": 0.13103, "epss_percentile": 0.93875}, "CVE-2022-22943": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2022-22944": {"epss_score": 0.00446, "epss_percentile": 0.6291}, "CVE-2022-22945": {"epss_score": 0.00131, "epss_percentile": 0.3349}, "CVE-2022-22946": {"epss_score": 0.00982, "epss_percentile": 0.76292}, "CVE-2022-22947": {"epss_score": 0.94461, "epss_percentile": 0.99994}, "CVE-2022-22948": {"epss_score": 0.2601, "epss_percentile": 0.96099}, "CVE-2022-22950": {"epss_score": 0.04122, "epss_percentile": 0.88283}, "CVE-2022-22951": {"epss_score": 0.0469, "epss_percentile": 0.89011}, "CVE-2022-22952": {"epss_score": 0.00617, "epss_percentile": 0.69355}, "CVE-2022-22953": {"epss_score": 0.0024, "epss_percentile": 0.47184}, "CVE-2022-22954": {"epss_score": 0.94444, "epss_percentile": 0.9999}, "CVE-2022-22955": {"epss_score": 0.70112, "epss_percentile": 0.98617}, "CVE-2022-22956": {"epss_score": 0.81455, "epss_percentile": 0.99139}, "CVE-2022-22957": {"epss_score": 0.47263, "epss_percentile": 0.97579}, "CVE-2022-22958": {"epss_score": 0.03022, "epss_percentile": 0.86228}, "CVE-2022-22959": {"epss_score": 0.00292, "epss_percentile": 0.52222}, "CVE-2022-22960": {"epss_score": 0.70421, "epss_percentile": 0.98631}, "CVE-2022-22961": {"epss_score": 0.00389, "epss_percentile": 0.59496}, "CVE-2022-22962": {"epss_score": 0.00031, "epss_percentile": 0.0871}, "CVE-2022-22963": {"epss_score": 0.94462, "epss_percentile": 0.99995}, "CVE-2022-22964": {"epss_score": 0.00037, "epss_percentile": 0.10966}, "CVE-2022-22965": {"epss_score": 0.94441, "epss_percentile": 0.99989}, "CVE-2022-22966": {"epss_score": 0.09933, "epss_percentile": 0.92778}, "CVE-2022-22967": {"epss_score": 0.00504, "epss_percentile": 0.65542}, "CVE-2022-22968": {"epss_score": 0.16181, "epss_percentile": 0.94589}, "CVE-2022-22969": {"epss_score": 0.00665, "epss_percentile": 0.70661}, "CVE-2022-22970": {"epss_score": 0.00164, "epss_percentile": 0.37874}, "CVE-2022-22971": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-22972": {"epss_score": 0.93647, "epss_percentile": 0.9983}, "CVE-2022-22973": {"epss_score": 0.01675, "epss_percentile": 0.81705}, "CVE-2022-22975": {"epss_score": 0.00483, "epss_percentile": 0.64619}, "CVE-2022-22976": {"epss_score": 0.0036, "epss_percentile": 0.57667}, "CVE-2022-22977": {"epss_score": 0.0004, "epss_percentile": 0.1195}, "CVE-2022-22978": {"epss_score": 0.90406, "epss_percentile": 0.99582}, "CVE-2022-22979": {"epss_score": 0.00664, "epss_percentile": 0.70649}, "CVE-2022-22980": {"epss_score": 0.85505, "epss_percentile": 0.99337}, "CVE-2022-22982": {"epss_score": 0.00245, "epss_percentile": 0.47638}, "CVE-2022-22983": {"epss_score": 0.00077, "epss_percentile": 0.23366}, "CVE-2022-22984": {"epss_score": 0.04668, "epss_percentile": 0.88983}, "CVE-2022-22985": {"epss_score": 0.00322, "epss_percentile": 0.54795}, "CVE-2022-22986": {"epss_score": 0.00346, "epss_percentile": 0.56606}, "CVE-2022-22987": {"epss_score": 0.00199, "epss_percentile": 0.42175}, "CVE-2022-22988": {"epss_score": 0.00146, "epss_percentile": 0.35572}, "CVE-2022-22989": {"epss_score": 0.01234, "epss_percentile": 0.78753}, "CVE-2022-22990": {"epss_score": 0.0171, "epss_percentile": 0.81872}, "CVE-2022-22991": {"epss_score": 0.00084, "epss_percentile": 0.24939}, "CVE-2022-22992": {"epss_score": 0.00848, "epss_percentile": 0.74364}, "CVE-2022-22993": {"epss_score": 0.00057, "epss_percentile": 0.18152}, "CVE-2022-22994": {"epss_score": 0.00796, "epss_percentile": 0.73489}, "CVE-2022-22995": {"epss_score": 0.00176, "epss_percentile": 0.39444}, "CVE-2022-22996": {"epss_score": 0.00052, "epss_percentile": 0.16561}, "CVE-2022-22997": {"epss_score": 0.01742, "epss_percentile": 0.82053}, "CVE-2022-22998": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2022-22999": {"epss_score": 0.00484, "epss_percentile": 0.64625}, "CVE-2022-23000": {"epss_score": 0.00048, "epss_percentile": 0.15072}, "CVE-2022-23001": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2022-23002": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2022-23003": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2022-23004": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2022-23005": {"epss_score": 0.00161, "epss_percentile": 0.37604}, "CVE-2022-23006": {"epss_score": 0.00054, "epss_percentile": 0.17313}, "CVE-2022-23008": {"epss_score": 0.00411, "epss_percentile": 0.60886}, "CVE-2022-23009": {"epss_score": 0.00312, "epss_percentile": 0.53971}, "CVE-2022-23010": {"epss_score": 0.00611, "epss_percentile": 0.69187}, "CVE-2022-23011": {"epss_score": 0.00682, "epss_percentile": 0.71072}, "CVE-2022-23012": {"epss_score": 0.00611, "epss_percentile": 0.69187}, "CVE-2022-23013": {"epss_score": 0.01256, "epss_percentile": 0.7894}, "CVE-2022-23014": {"epss_score": 0.00287, "epss_percentile": 0.51819}, "CVE-2022-23015": {"epss_score": 0.00318, "epss_percentile": 0.54457}, "CVE-2022-23016": {"epss_score": 0.00711, "epss_percentile": 0.71738}, "CVE-2022-23017": {"epss_score": 0.00711, "epss_percentile": 0.71738}, "CVE-2022-23018": {"epss_score": 0.00611, "epss_percentile": 0.69187}, "CVE-2022-23019": {"epss_score": 0.00611, "epss_percentile": 0.69187}, "CVE-2022-23020": {"epss_score": 0.00711, "epss_percentile": 0.71738}, "CVE-2022-23021": {"epss_score": 0.00711, "epss_percentile": 0.71738}, "CVE-2022-23022": {"epss_score": 0.00711, "epss_percentile": 0.71738}, "CVE-2022-23023": {"epss_score": 0.00321, "epss_percentile": 0.54738}, "CVE-2022-23024": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2022-23025": {"epss_score": 0.00753, "epss_percentile": 0.72673}, "CVE-2022-23026": {"epss_score": 0.00296, "epss_percentile": 0.52544}, "CVE-2022-23027": {"epss_score": 0.00628, "epss_percentile": 0.69654}, "CVE-2022-23028": {"epss_score": 0.00591, "epss_percentile": 0.68578}, "CVE-2022-23029": {"epss_score": 0.00513, "epss_percentile": 0.65929}, "CVE-2022-23030": {"epss_score": 0.00591, "epss_percentile": 0.68578}, "CVE-2022-23031": {"epss_score": 0.00374, "epss_percentile": 0.58542}, "CVE-2022-23032": {"epss_score": 0.00123, "epss_percentile": 0.32296}, "CVE-2022-23033": {"epss_score": 0.00092, "epss_percentile": 0.26523}, "CVE-2022-23034": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2022-23035": {"epss_score": 0.00125, "epss_percentile": 0.32553}, "CVE-2022-23036": {"epss_score": 0.00078, "epss_percentile": 0.23679}, "CVE-2022-23037": {"epss_score": 0.00089, "epss_percentile": 0.25933}, "CVE-2022-23038": {"epss_score": 0.00078, "epss_percentile": 0.23679}, "CVE-2022-23039": {"epss_score": 0.00078, "epss_percentile": 0.23679}, "CVE-2022-23040": {"epss_score": 0.00078, "epss_percentile": 0.23679}, "CVE-2022-23041": {"epss_score": 0.00078, "epss_percentile": 0.23679}, "CVE-2022-23042": {"epss_score": 0.00078, "epss_percentile": 0.23679}, "CVE-2022-23043": {"epss_score": 0.00578, "epss_percentile": 0.68205}, "CVE-2022-23044": {"epss_score": 0.01315, "epss_percentile": 0.79401}, "CVE-2022-23045": {"epss_score": 0.00328, "epss_percentile": 0.55155}, "CVE-2022-23046": {"epss_score": 0.48978, "epss_percentile": 0.97661}, "CVE-2022-23047": {"epss_score": 0.00854, "epss_percentile": 0.74454}, "CVE-2022-23048": {"epss_score": 0.04582, "epss_percentile": 0.88878}, "CVE-2022-23049": {"epss_score": 0.00833, "epss_percentile": 0.74084}, "CVE-2022-23050": {"epss_score": 0.27373, "epss_percentile": 0.96241}, "CVE-2022-23051": {"epss_score": 0.00163, "epss_percentile": 0.37757}, "CVE-2022-23052": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2022-23053": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-23054": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-23055": {"epss_score": 0.00301, "epss_percentile": 0.52999}, "CVE-2022-23056": {"epss_score": 0.00238, "epss_percentile": 0.46815}, "CVE-2022-23057": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-23058": {"epss_score": 0.00238, "epss_percentile": 0.46815}, "CVE-2022-23059": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-23060": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-23061": {"epss_score": 0.00271, "epss_percentile": 0.50312}, "CVE-2022-23063": {"epss_score": 0.0031, "epss_percentile": 0.53799}, "CVE-2022-23064": {"epss_score": 0.00418, "epss_percentile": 0.61288}, "CVE-2022-23065": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-23066": {"epss_score": 0.01129, "epss_percentile": 0.77834}, "CVE-2022-23067": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2022-23068": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-23071": {"epss_score": 0.00226, "epss_percentile": 0.45313}, "CVE-2022-23072": {"epss_score": 0.00238, "epss_percentile": 0.46815}, "CVE-2022-23073": {"epss_score": 0.00238, "epss_percentile": 0.46815}, "CVE-2022-23074": {"epss_score": 0.00238, "epss_percentile": 0.46815}, "CVE-2022-23077": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-23078": {"epss_score": 0.00198, "epss_percentile": 0.42062}, "CVE-2022-23079": {"epss_score": 0.00296, "epss_percentile": 0.52547}, "CVE-2022-23080": {"epss_score": 0.00179, "epss_percentile": 0.39837}, "CVE-2022-23081": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2022-23082": {"epss_score": 0.00357, "epss_percentile": 0.57471}, "CVE-2022-23083": {"epss_score": 0.00866, "epss_percentile": 0.74641}, "CVE-2022-23084": {"epss_score": 0.00046, "epss_percentile": 0.14308}, "CVE-2022-23085": {"epss_score": 0.00185, "epss_percentile": 0.40459}, "CVE-2022-23086": {"epss_score": 0.00254, "epss_percentile": 0.48555}, "CVE-2022-23087": {"epss_score": 0.00109, "epss_percentile": 0.29905}, "CVE-2022-23088": {"epss_score": 0.07849, "epss_percentile": 0.91718}, "CVE-2022-23089": {"epss_score": 0.00061, "epss_percentile": 0.19423}, "CVE-2022-23090": {"epss_score": 0.00274, "epss_percentile": 0.5051}, "CVE-2022-23091": {"epss_score": 0.00044, "epss_percentile": 0.13587}, "CVE-2022-23092": {"epss_score": 0.00397, "epss_percentile": 0.59968}, "CVE-2022-23093": {"epss_score": 0.03979, "epss_percentile": 0.88056}, "CVE-2022-23094": {"epss_score": 0.01296, "epss_percentile": 0.79253}, "CVE-2022-23095": {"epss_score": 0.0084, "epss_percentile": 0.742}, "CVE-2022-23096": {"epss_score": 0.00082, "epss_percentile": 0.24486}, "CVE-2022-23097": {"epss_score": 0.00094, "epss_percentile": 0.26996}, "CVE-2022-23098": {"epss_score": 0.0008, "epss_percentile": 0.24175}, "CVE-2022-23099": {"epss_score": 0.00677, "epss_percentile": 0.70948}, "CVE-2022-23100": {"epss_score": 0.02534, "epss_percentile": 0.85035}, "CVE-2022-23101": {"epss_score": 0.00493, "epss_percentile": 0.65051}, "CVE-2022-23102": {"epss_score": 0.04852, "epss_percentile": 0.89216}, "CVE-2022-23103": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-23104": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2022-23105": {"epss_score": 0.00024, "epss_percentile": 0.0574}, "CVE-2022-23106": {"epss_score": 0.00158, "epss_percentile": 0.37255}, "CVE-2022-23107": {"epss_score": 0.01651, "epss_percentile": 0.81567}, "CVE-2022-23108": {"epss_score": 0.07811, "epss_percentile": 0.91694}, "CVE-2022-23109": {"epss_score": 0.00097, "epss_percentile": 0.27564}, "CVE-2022-23110": {"epss_score": 0.01966, "epss_percentile": 0.83082}, "CVE-2022-23111": {"epss_score": 0.01244, "epss_percentile": 0.78832}, "CVE-2022-23112": {"epss_score": 0.00097, "epss_percentile": 0.27457}, "CVE-2022-23113": {"epss_score": 0.01407, "epss_percentile": 0.80059}, "CVE-2022-23114": {"epss_score": 0.00021, "epss_percentile": 0.04716}, "CVE-2022-23115": {"epss_score": 0.00182, "epss_percentile": 0.40203}, "CVE-2022-23116": {"epss_score": 0.0008, "epss_percentile": 0.24086}, "CVE-2022-23117": {"epss_score": 0.00108, "epss_percentile": 0.29858}, "CVE-2022-23118": {"epss_score": 0.02322, "epss_percentile": 0.84373}, "CVE-2022-23119": {"epss_score": 0.01216, "epss_percentile": 0.78597}, "CVE-2022-23120": {"epss_score": 0.005, "epss_percentile": 0.65298}, "CVE-2022-23121": {"epss_score": 0.17666, "epss_percentile": 0.94886}, "CVE-2022-23122": {"epss_score": 0.07288, "epss_percentile": 0.91385}, "CVE-2022-23123": {"epss_score": 0.0606, "epss_percentile": 0.90442}, "CVE-2022-23124": {"epss_score": 0.00896, "epss_percentile": 0.75119}, "CVE-2022-23125": {"epss_score": 0.16121, "epss_percentile": 0.94575}, "CVE-2022-23126": {"epss_score": 0.01027, "epss_percentile": 0.76806}, "CVE-2022-23127": {"epss_score": 0.00302, "epss_percentile": 0.53106}, "CVE-2022-23128": {"epss_score": 0.05031, "epss_percentile": 0.89415}, "CVE-2022-23129": {"epss_score": 0.00073, "epss_percentile": 0.22659}, "CVE-2022-23130": {"epss_score": 0.00062, "epss_percentile": 0.19558}, "CVE-2022-23131": {"epss_score": 0.94301, "epss_percentile": 0.9994}, "CVE-2022-23132": {"epss_score": 0.00141, "epss_percentile": 0.34938}, "CVE-2022-23133": {"epss_score": 0.00902, "epss_percentile": 0.75193}, "CVE-2022-23134": {"epss_score": 0.93096, "epss_percentile": 0.99775}, "CVE-2022-23135": {"epss_score": 0.00367, "epss_percentile": 0.58113}, "CVE-2022-23136": {"epss_score": 0.00589, "epss_percentile": 0.6852}, "CVE-2022-23137": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-23138": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2022-23139": {"epss_score": 0.00254, "epss_percentile": 0.48531}, "CVE-2022-23141": {"epss_score": 0.003, "epss_percentile": 0.52984}, "CVE-2022-23142": {"epss_score": 0.00377, "epss_percentile": 0.58771}, "CVE-2022-23143": {"epss_score": 0.00207, "epss_percentile": 0.43091}, "CVE-2022-23144": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-23155": {"epss_score": 0.00736, "epss_percentile": 0.72312}, "CVE-2022-23156": {"epss_score": 0.00042, "epss_percentile": 0.12562}, "CVE-2022-23157": {"epss_score": 0.00053, "epss_percentile": 0.16741}, "CVE-2022-23158": {"epss_score": 0.00064, "epss_percentile": 0.20154}, "CVE-2022-23159": {"epss_score": 0.00201, "epss_percentile": 0.42385}, "CVE-2022-23160": {"epss_score": 0.00103, "epss_percentile": 0.28958}, "CVE-2022-23161": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2022-23163": {"epss_score": 0.00045, "epss_percentile": 0.1375}, "CVE-2022-23165": {"epss_score": 0.0021, "epss_percentile": 0.4344}, "CVE-2022-23166": {"epss_score": 0.00437, "epss_percentile": 0.62531}, "CVE-2022-23167": {"epss_score": 0.00129, "epss_percentile": 0.33087}, "CVE-2022-23168": {"epss_score": 0.00124, "epss_percentile": 0.3242}, "CVE-2022-23169": {"epss_score": 0.00167, "epss_percentile": 0.38362}, "CVE-2022-23170": {"epss_score": 0.00359, "epss_percentile": 0.57615}, "CVE-2022-23171": {"epss_score": 0.00185, "epss_percentile": 0.40515}, "CVE-2022-23172": {"epss_score": 0.00133, "epss_percentile": 0.33678}, "CVE-2022-23173": {"epss_score": 0.00183, "epss_percentile": 0.40307}, "CVE-2022-23176": {"epss_score": 0.09569, "epss_percentile": 0.92604}, "CVE-2022-23178": {"epss_score": 0.93636, "epss_percentile": 0.99826}, "CVE-2022-23179": {"epss_score": 0.0014, "epss_percentile": 0.34775}, "CVE-2022-23180": {"epss_score": 0.00116, "epss_percentile": 0.3111}, "CVE-2022-23181": {"epss_score": 0.00256, "epss_percentile": 0.48839}, "CVE-2022-23182": {"epss_score": 0.00289, "epss_percentile": 0.52003}, "CVE-2022-23183": {"epss_score": 0.00476, "epss_percentile": 0.64274}, "CVE-2022-23184": {"epss_score": 0.00185, "epss_percentile": 0.40514}, "CVE-2022-23186": {"epss_score": 0.02275, "epss_percentile": 0.84227}, "CVE-2022-23187": {"epss_score": 0.01621, "epss_percentile": 0.81391}, "CVE-2022-23188": {"epss_score": 0.0568, "epss_percentile": 0.90116}, "CVE-2022-23189": {"epss_score": 0.00721, "epss_percentile": 0.71983}, "CVE-2022-23190": {"epss_score": 0.02079, "epss_percentile": 0.83525}, "CVE-2022-23191": {"epss_score": 0.02079, "epss_percentile": 0.83525}, "CVE-2022-23192": {"epss_score": 0.02079, "epss_percentile": 0.83525}, "CVE-2022-23193": {"epss_score": 0.02079, "epss_percentile": 0.83525}, "CVE-2022-23194": {"epss_score": 0.02079, "epss_percentile": 0.83525}, "CVE-2022-23195": {"epss_score": 0.02079, "epss_percentile": 0.83525}, "CVE-2022-23196": {"epss_score": 0.02079, "epss_percentile": 0.83525}, "CVE-2022-23197": {"epss_score": 0.02079, "epss_percentile": 0.83525}, "CVE-2022-23198": {"epss_score": 0.00721, "epss_percentile": 0.71983}, "CVE-2022-23199": {"epss_score": 0.00721, "epss_percentile": 0.71983}, "CVE-2022-23200": {"epss_score": 0.02291, "epss_percentile": 0.84284}, "CVE-2022-23201": {"epss_score": 0.0086, "epss_percentile": 0.74539}, "CVE-2022-23202": {"epss_score": 0.07288, "epss_percentile": 0.91385}, "CVE-2022-23203": {"epss_score": 0.18651, "epss_percentile": 0.95047}, "CVE-2022-23204": {"epss_score": 0.02038, "epss_percentile": 0.83359}, "CVE-2022-23205": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-23206": {"epss_score": 0.0084, "epss_percentile": 0.74212}, "CVE-2022-23218": {"epss_score": 0.00523, "epss_percentile": 0.66311}, "CVE-2022-23219": {"epss_score": 0.00523, "epss_percentile": 0.66311}, "CVE-2022-23220": {"epss_score": 0.00094, "epss_percentile": 0.27005}, "CVE-2022-23221": {"epss_score": 0.26568, "epss_percentile": 0.96158}, "CVE-2022-23222": {"epss_score": 0.00726, "epss_percentile": 0.72067}, "CVE-2022-23223": {"epss_score": 0.04553, "epss_percentile": 0.88841}, "CVE-2022-23227": {"epss_score": 0.46439, "epss_percentile": 0.97546}, "CVE-2022-23228": {"epss_score": 0.00345, "epss_percentile": 0.56559}, "CVE-2022-23232": {"epss_score": 0.00335, "epss_percentile": 0.55895}, "CVE-2022-23233": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-23234": {"epss_score": 0.00055, "epss_percentile": 0.17526}, "CVE-2022-23235": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2022-23236": {"epss_score": 0.00092, "epss_percentile": 0.26505}, "CVE-2022-23237": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2022-23238": {"epss_score": 0.00749, "epss_percentile": 0.726}, "CVE-2022-23239": {"epss_score": 0.00074, "epss_percentile": 0.22691}, "CVE-2022-23240": {"epss_score": 0.00085, "epss_percentile": 0.25034}, "CVE-2022-23241": {"epss_score": 0.00346, "epss_percentile": 0.56606}, "CVE-2022-23242": {"epss_score": 0.00141, "epss_percentile": 0.34803}, "CVE-2022-23252": {"epss_score": 0.00344, "epss_percentile": 0.56518}, "CVE-2022-23253": {"epss_score": 0.30215, "epss_percentile": 0.9652}, "CVE-2022-23254": {"epss_score": 0.05934, "epss_percentile": 0.9034}, "CVE-2022-23255": {"epss_score": 0.00143, "epss_percentile": 0.35119}, "CVE-2022-23256": {"epss_score": 0.04119, "epss_percentile": 0.88282}, "CVE-2022-23257": {"epss_score": 0.00203, "epss_percentile": 0.4255}, "CVE-2022-23258": {"epss_score": 0.01052, "epss_percentile": 0.77096}, "CVE-2022-23259": {"epss_score": 0.07373, "epss_percentile": 0.91441}, "CVE-2022-23261": {"epss_score": 0.00821, "epss_percentile": 0.73899}, "CVE-2022-23262": {"epss_score": 0.00804, "epss_percentile": 0.73616}, "CVE-2022-23263": {"epss_score": 0.01176, "epss_percentile": 0.78273}, "CVE-2022-23264": {"epss_score": 0.00167, "epss_percentile": 0.38344}, "CVE-2022-23265": {"epss_score": 0.06109, "epss_percentile": 0.90486}, "CVE-2022-23266": {"epss_score": 0.00409, "epss_percentile": 0.6072}, "CVE-2022-23267": {"epss_score": 0.06422, "epss_percentile": 0.9075}, "CVE-2022-23268": {"epss_score": 0.00276, "epss_percentile": 0.50762}, "CVE-2022-23269": {"epss_score": 0.00492, "epss_percentile": 0.65008}, "CVE-2022-23270": {"epss_score": 0.51101, "epss_percentile": 0.97765}, "CVE-2022-23271": {"epss_score": 0.07211, "epss_percentile": 0.91328}, "CVE-2022-23272": {"epss_score": 0.07206, "epss_percentile": 0.91323}, "CVE-2022-23273": {"epss_score": 0.035, "epss_percentile": 0.87243}, "CVE-2022-23274": {"epss_score": 0.05501, "epss_percentile": 0.89938}, "CVE-2022-23276": {"epss_score": 0.002, "epss_percentile": 0.42222}, "CVE-2022-23277": {"epss_score": 0.76542, "epss_percentile": 0.98895}, "CVE-2022-23278": {"epss_score": 0.02691, "epss_percentile": 0.85437}, "CVE-2022-23279": {"epss_score": 0.01106, "epss_percentile": 0.77619}, "CVE-2022-23280": {"epss_score": 0.03189, "epss_percentile": 0.86593}, "CVE-2022-23281": {"epss_score": 0.00533, "epss_percentile": 0.6677}, "CVE-2022-23282": {"epss_score": 0.01549, "epss_percentile": 0.80982}, "CVE-2022-23283": {"epss_score": 0.00141, "epss_percentile": 0.34944}, "CVE-2022-23284": {"epss_score": 0.09515, "epss_percentile": 0.92582}, "CVE-2022-23285": {"epss_score": 0.18588, "epss_percentile": 0.95037}, "CVE-2022-23286": {"epss_score": 0.00479, "epss_percentile": 0.64418}, "CVE-2022-23287": {"epss_score": 0.00356, "epss_percentile": 0.57368}, "CVE-2022-23288": {"epss_score": 0.00356, "epss_percentile": 0.57368}, "CVE-2022-23290": {"epss_score": 0.0023, "epss_percentile": 0.45693}, "CVE-2022-23291": {"epss_score": 0.00389, "epss_percentile": 0.59464}, "CVE-2022-23292": {"epss_score": 0.00662, "epss_percentile": 0.70604}, "CVE-2022-23293": {"epss_score": 0.00266, "epss_percentile": 0.49863}, "CVE-2022-23294": {"epss_score": 0.07756, "epss_percentile": 0.91661}, "CVE-2022-23295": {"epss_score": 0.02051, "epss_percentile": 0.83404}, "CVE-2022-23296": {"epss_score": 0.00542, "epss_percentile": 0.67085}, "CVE-2022-23297": {"epss_score": 0.00495, "epss_percentile": 0.6511}, "CVE-2022-23298": {"epss_score": 0.0036, "epss_percentile": 0.57655}, "CVE-2022-23299": {"epss_score": 0.00555, "epss_percentile": 0.67488}, "CVE-2022-23300": {"epss_score": 0.02051, "epss_percentile": 0.83404}, "CVE-2022-23301": {"epss_score": 0.02051, "epss_percentile": 0.83404}, "CVE-2022-23302": {"epss_score": 0.00647, "epss_percentile": 0.70202}, "CVE-2022-23303": {"epss_score": 0.00301, "epss_percentile": 0.53012}, "CVE-2022-23304": {"epss_score": 0.00056, "epss_percentile": 0.17798}, "CVE-2022-23305": {"epss_score": 0.07951, "epss_percentile": 0.91784}, "CVE-2022-23307": {"epss_score": 0.01804, "epss_percentile": 0.82343}, "CVE-2022-23308": {"epss_score": 0.00055, "epss_percentile": 0.17381}, "CVE-2022-23312": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-23314": {"epss_score": 0.00402, "epss_percentile": 0.60291}, "CVE-2022-23315": {"epss_score": 0.00678, "epss_percentile": 0.70978}, "CVE-2022-23316": {"epss_score": 0.00329, "epss_percentile": 0.5532}, "CVE-2022-23317": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2022-23318": {"epss_score": 0.00169, "epss_percentile": 0.38527}, "CVE-2022-23319": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2022-23320": {"epss_score": 0.00301, "epss_percentile": 0.53064}, "CVE-2022-23321": {"epss_score": 0.00476, "epss_percentile": 0.64294}, "CVE-2022-23327": {"epss_score": 0.00533, "epss_percentile": 0.66717}, "CVE-2022-23328": {"epss_score": 0.00533, "epss_percentile": 0.66717}, "CVE-2022-23329": {"epss_score": 0.01439, "epss_percentile": 0.8029}, "CVE-2022-23330": {"epss_score": 0.01989, "epss_percentile": 0.83169}, "CVE-2022-23331": {"epss_score": 0.00558, "epss_percentile": 0.67573}, "CVE-2022-23332": {"epss_score": 0.12796, "epss_percentile": 0.93776}, "CVE-2022-23334": {"epss_score": 0.00152, "epss_percentile": 0.36451}, "CVE-2022-23335": {"epss_score": 0.00513, "epss_percentile": 0.65923}, "CVE-2022-23336": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-23337": {"epss_score": 0.10239, "epss_percentile": 0.92907}, "CVE-2022-23340": {"epss_score": 0.00611, "epss_percentile": 0.69176}, "CVE-2022-23342": {"epss_score": 0.00541, "epss_percentile": 0.67048}, "CVE-2022-23345": {"epss_score": 0.00728, "epss_percentile": 0.72106}, "CVE-2022-23346": {"epss_score": 0.00736, "epss_percentile": 0.72301}, "CVE-2022-23347": {"epss_score": 0.72327, "epss_percentile": 0.98704}, "CVE-2022-23348": {"epss_score": 0.00828, "epss_percentile": 0.74002}, "CVE-2022-23349": {"epss_score": 0.00243, "epss_percentile": 0.47456}, "CVE-2022-23350": {"epss_score": 0.00464, "epss_percentile": 0.63737}, "CVE-2022-23352": {"epss_score": 0.0086, "epss_percentile": 0.74531}, "CVE-2022-23357": {"epss_score": 0.01463, "epss_percentile": 0.80442}, "CVE-2022-23358": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-23363": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-23364": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-23365": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-23366": {"epss_score": 0.00271, "epss_percentile": 0.50317}, "CVE-2022-23367": {"epss_score": 0.00083, "epss_percentile": 0.24592}, "CVE-2022-23375": {"epss_score": 0.04547, "epss_percentile": 0.88835}, "CVE-2022-23376": {"epss_score": 0.00281, "epss_percentile": 0.51199}, "CVE-2022-23377": {"epss_score": 0.00509, "epss_percentile": 0.65741}, "CVE-2022-23378": {"epss_score": 0.01655, "epss_percentile": 0.8159}, "CVE-2022-23379": {"epss_score": 0.00555, "epss_percentile": 0.67467}, "CVE-2022-23380": {"epss_score": 0.00239, "epss_percentile": 0.46936}, "CVE-2022-23382": {"epss_score": 0.00028, "epss_percentile": 0.07439}, "CVE-2022-23383": {"epss_score": 0.00326, "epss_percentile": 0.55037}, "CVE-2022-23384": {"epss_score": 0.00132, "epss_percentile": 0.33615}, "CVE-2022-23387": {"epss_score": 0.00296, "epss_percentile": 0.52582}, "CVE-2022-23389": {"epss_score": 0.03934, "epss_percentile": 0.8798}, "CVE-2022-23390": {"epss_score": 0.00411, "epss_percentile": 0.60887}, "CVE-2022-23391": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-23395": {"epss_score": 0.00146, "epss_percentile": 0.35641}, "CVE-2022-23397": {"epss_score": 0.02099, "epss_percentile": 0.83596}, "CVE-2022-23399": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-23400": {"epss_score": 0.00261, "epss_percentile": 0.49269}, "CVE-2022-23401": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2022-23402": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2022-23403": {"epss_score": 0.00131, "epss_percentile": 0.33346}, "CVE-2022-23408": {"epss_score": 0.0039, "epss_percentile": 0.59518}, "CVE-2022-23409": {"epss_score": 0.02429, "epss_percentile": 0.84724}, "CVE-2022-23410": {"epss_score": 0.0072, "epss_percentile": 0.71961}, "CVE-2022-23425": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2022-23426": {"epss_score": 0.00052, "epss_percentile": 0.16406}, "CVE-2022-23427": {"epss_score": 0.00017, "epss_percentile": 0.03177}, "CVE-2022-23428": {"epss_score": 0.00014, "epss_percentile": 0.01992}, "CVE-2022-23429": {"epss_score": 0.00016, "epss_percentile": 0.02846}, "CVE-2022-23431": {"epss_score": 0.00018, "epss_percentile": 0.0402}, "CVE-2022-23432": {"epss_score": 0.00018, "epss_percentile": 0.0402}, "CVE-2022-23433": {"epss_score": 0.00234, "epss_percentile": 0.46109}, "CVE-2022-23434": {"epss_score": 0.00168, "epss_percentile": 0.38409}, "CVE-2022-23435": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2022-23437": {"epss_score": 0.00087, "epss_percentile": 0.25569}, "CVE-2022-23438": {"epss_score": 0.00589, "epss_percentile": 0.68511}, "CVE-2022-23439": {"epss_score": 0.00133, "epss_percentile": 0.33632}, "CVE-2022-23440": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2022-23441": {"epss_score": 0.00723, "epss_percentile": 0.72004}, "CVE-2022-23442": {"epss_score": 0.0024, "epss_percentile": 0.47216}, "CVE-2022-23443": {"epss_score": 0.01756, "epss_percentile": 0.82124}, "CVE-2022-23446": {"epss_score": 0.00049, "epss_percentile": 0.15309}, "CVE-2022-23447": {"epss_score": 0.00108, "epss_percentile": 0.29819}, "CVE-2022-23448": {"epss_score": 0.00027, "epss_percentile": 0.06885}, "CVE-2022-23449": {"epss_score": 0.00048, "epss_percentile": 0.15181}, "CVE-2022-23450": {"epss_score": 0.33344, "epss_percentile": 0.96765}, "CVE-2022-23451": {"epss_score": 0.00368, "epss_percentile": 0.5821}, "CVE-2022-23452": {"epss_score": 0.00423, "epss_percentile": 0.61596}, "CVE-2022-23453": {"epss_score": 0.00175, "epss_percentile": 0.39312}, "CVE-2022-23454": {"epss_score": 0.00134, "epss_percentile": 0.33798}, "CVE-2022-23455": {"epss_score": 0.00134, "epss_percentile": 0.33798}, "CVE-2022-23456": {"epss_score": 0.00299, "epss_percentile": 0.52857}, "CVE-2022-23457": {"epss_score": 0.00323, "epss_percentile": 0.54919}, "CVE-2022-23458": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-23459": {"epss_score": 0.00311, "epss_percentile": 0.53827}, "CVE-2022-23460": {"epss_score": 0.0041, "epss_percentile": 0.60791}, "CVE-2022-23461": {"epss_score": 0.00121, "epss_percentile": 0.32016}, "CVE-2022-23462": {"epss_score": 0.00215, "epss_percentile": 0.44084}, "CVE-2022-23463": {"epss_score": 0.01275, "epss_percentile": 0.79101}, "CVE-2022-23464": {"epss_score": 0.00112, "epss_percentile": 0.30574}, "CVE-2022-23465": {"epss_score": 0.00138, "epss_percentile": 0.34506}, "CVE-2022-23466": {"epss_score": 0.00212, "epss_percentile": 0.4379}, "CVE-2022-23467": {"epss_score": 0.0007, "epss_percentile": 0.217}, "CVE-2022-23468": {"epss_score": 0.00136, "epss_percentile": 0.34193}, "CVE-2022-23469": {"epss_score": 0.00509, "epss_percentile": 0.65747}, "CVE-2022-23470": {"epss_score": 0.00414, "epss_percentile": 0.61028}, "CVE-2022-23471": {"epss_score": 0.00245, "epss_percentile": 0.47689}, "CVE-2022-23472": {"epss_score": 0.00366, "epss_percentile": 0.58017}, "CVE-2022-23473": {"epss_score": 0.00127, "epss_percentile": 0.32874}, "CVE-2022-23474": {"epss_score": 0.00364, "epss_percentile": 0.57916}, "CVE-2022-23475": {"epss_score": 0.00182, "epss_percentile": 0.40241}, "CVE-2022-23476": {"epss_score": 0.00216, "epss_percentile": 0.4413}, "CVE-2022-23477": {"epss_score": 0.00161, "epss_percentile": 0.37573}, "CVE-2022-23478": {"epss_score": 0.0016, "epss_percentile": 0.37515}, "CVE-2022-23479": {"epss_score": 0.0016, "epss_percentile": 0.37515}, "CVE-2022-23480": {"epss_score": 0.0016, "epss_percentile": 0.37515}, "CVE-2022-23481": {"epss_score": 0.00155, "epss_percentile": 0.36838}, "CVE-2022-23482": {"epss_score": 0.00156, "epss_percentile": 0.36949}, "CVE-2022-23483": {"epss_score": 0.00211, "epss_percentile": 0.43666}, "CVE-2022-23484": {"epss_score": 0.0016, "epss_percentile": 0.37515}, "CVE-2022-23485": {"epss_score": 0.00293, "epss_percentile": 0.52289}, "CVE-2022-23486": {"epss_score": 0.00411, "epss_percentile": 0.60874}, "CVE-2022-23487": {"epss_score": 0.00335, "epss_percentile": 0.55808}, "CVE-2022-23488": {"epss_score": 0.0025, "epss_percentile": 0.48253}, "CVE-2022-23490": {"epss_score": 0.00151, "epss_percentile": 0.36359}, "CVE-2022-23491": {"epss_score": 0.00051, "epss_percentile": 0.16163}, "CVE-2022-23492": {"epss_score": 0.00677, "epss_percentile": 0.70952}, "CVE-2022-23493": {"epss_score": 0.00215, "epss_percentile": 0.44063}, "CVE-2022-23494": {"epss_score": 0.025, "epss_percentile": 0.84916}, "CVE-2022-23495": {"epss_score": 0.02161, "epss_percentile": 0.83825}, "CVE-2022-23496": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-23497": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2022-23498": {"epss_score": 0.00106, "epss_percentile": 0.29446}, "CVE-2022-23499": {"epss_score": 0.00223, "epss_percentile": 0.44876}, "CVE-2022-23500": {"epss_score": 0.00411, "epss_percentile": 0.60874}, "CVE-2022-23501": {"epss_score": 0.00187, "epss_percentile": 0.40805}, "CVE-2022-23502": {"epss_score": 0.00151, "epss_percentile": 0.36359}, "CVE-2022-23503": {"epss_score": 0.00474, "epss_percentile": 0.64145}, "CVE-2022-23504": {"epss_score": 0.00313, "epss_percentile": 0.54057}, "CVE-2022-23505": {"epss_score": 0.00405, "epss_percentile": 0.60483}, "CVE-2022-23506": {"epss_score": 0.00339, "epss_percentile": 0.56195}, "CVE-2022-23507": {"epss_score": 0.00073, "epss_percentile": 0.2256}, "CVE-2022-23508": {"epss_score": 0.0003, "epss_percentile": 0.08284}, "CVE-2022-23509": {"epss_score": 0.00016, "epss_percentile": 0.02892}, "CVE-2022-23510": {"epss_score": 0.00404, "epss_percentile": 0.60397}, "CVE-2022-23511": {"epss_score": 0.00174, "epss_percentile": 0.39201}, "CVE-2022-23512": {"epss_score": 0.00432, "epss_percentile": 0.62131}, "CVE-2022-23513": {"epss_score": 0.06699, "epss_percentile": 0.90955}, "CVE-2022-23514": {"epss_score": 0.00293, "epss_percentile": 0.52287}, "CVE-2022-23515": {"epss_score": 0.00299, "epss_percentile": 0.52903}, "CVE-2022-23516": {"epss_score": 0.00041, "epss_percentile": 0.12275}, "CVE-2022-23517": {"epss_score": 0.00305, "epss_percentile": 0.53392}, "CVE-2022-23518": {"epss_score": 0.00322, "epss_percentile": 0.54786}, "CVE-2022-23519": {"epss_score": 0.00163, "epss_percentile": 0.37807}, "CVE-2022-23520": {"epss_score": 0.00426, "epss_percentile": 0.61735}, "CVE-2022-23521": {"epss_score": 0.16356, "epss_percentile": 0.94634}, "CVE-2022-23522": {"epss_score": 0.00898, "epss_percentile": 0.75147}, "CVE-2022-23523": {"epss_score": 0.00045, "epss_percentile": 0.13902}, "CVE-2022-23524": {"epss_score": 0.00048, "epss_percentile": 0.15101}, "CVE-2022-23525": {"epss_score": 0.00042, "epss_percentile": 0.1249}, "CVE-2022-23526": {"epss_score": 0.00042, "epss_percentile": 0.1249}, "CVE-2022-23527": {"epss_score": 0.00459, "epss_percentile": 0.63463}, "CVE-2022-23530": {"epss_score": 0.00814, "epss_percentile": 0.73773}, "CVE-2022-23531": {"epss_score": 0.00152, "epss_percentile": 0.36503}, "CVE-2022-23532": {"epss_score": 0.00103, "epss_percentile": 0.291}, "CVE-2022-23535": {"epss_score": 0.00524, "epss_percentile": 0.66314}, "CVE-2022-23536": {"epss_score": 0.00578, "epss_percentile": 0.68204}, "CVE-2022-23537": {"epss_score": 0.00297, "epss_percentile": 0.52746}, "CVE-2022-23538": {"epss_score": 0.00085, "epss_percentile": 0.2523}, "CVE-2022-23539": {"epss_score": 0.00062, "epss_percentile": 0.19749}, "CVE-2022-23540": {"epss_score": 0.00017, "epss_percentile": 0.03434}, "CVE-2022-23541": {"epss_score": 0.00052, "epss_percentile": 0.16446}, "CVE-2022-23542": {"epss_score": 0.0042, "epss_percentile": 0.61441}, "CVE-2022-23543": {"epss_score": 0.00201, "epss_percentile": 0.4239}, "CVE-2022-23544": {"epss_score": 0.23569, "epss_percentile": 0.95792}, "CVE-2022-23546": {"epss_score": 0.00067, "epss_percentile": 0.20995}, "CVE-2022-23547": {"epss_score": 0.00208, "epss_percentile": 0.4327}, "CVE-2022-23548": {"epss_score": 0.00496, "epss_percentile": 0.65151}, "CVE-2022-23549": {"epss_score": 0.00327, "epss_percentile": 0.55111}, "CVE-2022-23551": {"epss_score": 0.0077, "epss_percentile": 0.72994}, "CVE-2022-23552": {"epss_score": 0.00295, "epss_percentile": 0.52499}, "CVE-2022-23553": {"epss_score": 0.00237, "epss_percentile": 0.46735}, "CVE-2022-23554": {"epss_score": 0.00332, "epss_percentile": 0.55555}, "CVE-2022-23555": {"epss_score": 0.00159, "epss_percentile": 0.37334}, "CVE-2022-23556": {"epss_score": 0.0014, "epss_percentile": 0.34789}, "CVE-2022-23557": {"epss_score": 0.0022, "epss_percentile": 0.44564}, "CVE-2022-23558": {"epss_score": 0.0039, "epss_percentile": 0.59527}, "CVE-2022-23559": {"epss_score": 0.00517, "epss_percentile": 0.66082}, "CVE-2022-23560": {"epss_score": 0.00296, "epss_percentile": 0.52561}, "CVE-2022-23561": {"epss_score": 0.00175, "epss_percentile": 0.39292}, "CVE-2022-23562": {"epss_score": 0.00361, "epss_percentile": 0.57702}, "CVE-2022-23563": {"epss_score": 0.00014, "epss_percentile": 0.02031}, "CVE-2022-23564": {"epss_score": 0.00118, "epss_percentile": 0.31407}, "CVE-2022-23565": {"epss_score": 0.00118, "epss_percentile": 0.31407}, "CVE-2022-23566": {"epss_score": 0.00391, "epss_percentile": 0.59592}, "CVE-2022-23567": {"epss_score": 0.0045, "epss_percentile": 0.63105}, "CVE-2022-23568": {"epss_score": 0.00303, "epss_percentile": 0.53235}, "CVE-2022-23569": {"epss_score": 0.00118, "epss_percentile": 0.31407}, "CVE-2022-23570": {"epss_score": 0.00509, "epss_percentile": 0.65725}, "CVE-2022-23571": {"epss_score": 0.00118, "epss_percentile": 0.31407}, "CVE-2022-23572": {"epss_score": 0.00507, "epss_percentile": 0.65662}, "CVE-2022-23573": {"epss_score": 0.00295, "epss_percentile": 0.52477}, "CVE-2022-23574": {"epss_score": 0.00296, "epss_percentile": 0.52561}, "CVE-2022-23575": {"epss_score": 0.0022, "epss_percentile": 0.44564}, "CVE-2022-23576": {"epss_score": 0.0022, "epss_percentile": 0.44564}, "CVE-2022-23577": {"epss_score": 0.00221, "epss_percentile": 0.4463}, "CVE-2022-23578": {"epss_score": 0.002, "epss_percentile": 0.42252}, "CVE-2022-23579": {"epss_score": 0.00232, "epss_percentile": 0.45935}, "CVE-2022-23580": {"epss_score": 0.00301, "epss_percentile": 0.53013}, "CVE-2022-23581": {"epss_score": 0.00476, "epss_percentile": 0.64266}, "CVE-2022-23582": {"epss_score": 0.0022, "epss_percentile": 0.44564}, "CVE-2022-23583": {"epss_score": 0.00285, "epss_percentile": 0.51533}, "CVE-2022-23584": {"epss_score": 0.00252, "epss_percentile": 0.48381}, "CVE-2022-23585": {"epss_score": 0.00656, "epss_percentile": 0.70438}, "CVE-2022-23586": {"epss_score": 0.00303, "epss_percentile": 0.53235}, "CVE-2022-23587": {"epss_score": 0.00295, "epss_percentile": 0.52482}, "CVE-2022-23588": {"epss_score": 0.00303, "epss_percentile": 0.53235}, "CVE-2022-23589": {"epss_score": 0.00301, "epss_percentile": 0.52995}, "CVE-2022-23590": {"epss_score": 0.00239, "epss_percentile": 0.46854}, "CVE-2022-23591": {"epss_score": 0.00335, "epss_percentile": 0.55817}, "CVE-2022-23592": {"epss_score": 0.00316, "epss_percentile": 0.54243}, "CVE-2022-23593": {"epss_score": 0.00309, "epss_percentile": 0.53685}, "CVE-2022-23594": {"epss_score": 0.00018, "epss_percentile": 0.03967}, "CVE-2022-23595": {"epss_score": 0.00221, "epss_percentile": 0.4463}, "CVE-2022-23596": {"epss_score": 0.0036, "epss_percentile": 0.57635}, "CVE-2022-23597": {"epss_score": 0.0042, "epss_percentile": 0.61425}, "CVE-2022-23598": {"epss_score": 0.00401, "epss_percentile": 0.60253}, "CVE-2022-23599": {"epss_score": 0.00317, "epss_percentile": 0.54385}, "CVE-2022-23600": {"epss_score": 0.00268, "epss_percentile": 0.50086}, "CVE-2022-23601": {"epss_score": 0.00173, "epss_percentile": 0.39135}, "CVE-2022-23602": {"epss_score": 0.00386, "epss_percentile": 0.59237}, "CVE-2022-23603": {"epss_score": 0.00374, "epss_percentile": 0.58552}, "CVE-2022-23604": {"epss_score": 0.00438, "epss_percentile": 0.62568}, "CVE-2022-23605": {"epss_score": 0.00063, "epss_percentile": 0.20064}, "CVE-2022-23606": {"epss_score": 0.00099, "epss_percentile": 0.27856}, "CVE-2022-23607": {"epss_score": 0.00258, "epss_percentile": 0.49006}, "CVE-2022-23608": {"epss_score": 0.01197, "epss_percentile": 0.78445}, "CVE-2022-23609": {"epss_score": 0.00815, "epss_percentile": 0.73784}, "CVE-2022-23610": {"epss_score": 0.00134, "epss_percentile": 0.33843}, "CVE-2022-23611": {"epss_score": 0.01848, "epss_percentile": 0.82526}, "CVE-2022-23612": {"epss_score": 0.00402, "epss_percentile": 0.60308}, "CVE-2022-23613": {"epss_score": 0.00381, "epss_percentile": 0.58986}, "CVE-2022-23614": {"epss_score": 0.43119, "epss_percentile": 0.9737}, "CVE-2022-23615": {"epss_score": 0.00047, "epss_percentile": 0.14877}, "CVE-2022-23616": {"epss_score": 0.02492, "epss_percentile": 0.849}, "CVE-2022-23617": {"epss_score": 0.00066, "epss_percentile": 0.20756}, "CVE-2022-23618": {"epss_score": 0.00281, "epss_percentile": 0.51127}, "CVE-2022-23619": {"epss_score": 0.00069, "epss_percentile": 0.21535}, "CVE-2022-23620": {"epss_score": 0.00307, "epss_percentile": 0.53566}, "CVE-2022-23621": {"epss_score": 0.00105, "epss_percentile": 0.29379}, "CVE-2022-23622": {"epss_score": 0.00827, "epss_percentile": 0.73984}, "CVE-2022-23623": {"epss_score": 0.00377, "epss_percentile": 0.5873}, "CVE-2022-23624": {"epss_score": 0.00377, "epss_percentile": 0.5873}, "CVE-2022-23625": {"epss_score": 0.00376, "epss_percentile": 0.58658}, "CVE-2022-23626": {"epss_score": 0.03782, "epss_percentile": 0.8772}, "CVE-2022-23627": {"epss_score": 0.00696, "epss_percentile": 0.71384}, "CVE-2022-23628": {"epss_score": 0.00311, "epss_percentile": 0.53932}, "CVE-2022-23630": {"epss_score": 0.00611, "epss_percentile": 0.69201}, "CVE-2022-23631": {"epss_score": 0.00398, "epss_percentile": 0.60071}, "CVE-2022-23632": {"epss_score": 0.00557, "epss_percentile": 0.67556}, "CVE-2022-23633": {"epss_score": 0.00271, "epss_percentile": 0.503}, "CVE-2022-23634": {"epss_score": 0.00596, "epss_percentile": 0.68712}, "CVE-2022-23635": {"epss_score": 0.00679, "epss_percentile": 0.71024}, "CVE-2022-23636": {"epss_score": 0.00184, "epss_percentile": 0.40368}, "CVE-2022-23637": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-23638": {"epss_score": 0.00098, "epss_percentile": 0.27678}, "CVE-2022-23639": {"epss_score": 0.00361, "epss_percentile": 0.57723}, "CVE-2022-23640": {"epss_score": 0.0035, "epss_percentile": 0.56975}, "CVE-2022-23641": {"epss_score": 0.00543, "epss_percentile": 0.67112}, "CVE-2022-23642": {"epss_score": 0.81123, "epss_percentile": 0.99122}, "CVE-2022-23643": {"epss_score": 0.00257, "epss_percentile": 0.48908}, "CVE-2022-23644": {"epss_score": 0.00299, "epss_percentile": 0.52865}, "CVE-2022-23645": {"epss_score": 0.0004, "epss_percentile": 0.12187}, "CVE-2022-23646": {"epss_score": 0.01381, "epss_percentile": 0.79869}, "CVE-2022-23647": {"epss_score": 0.00085, "epss_percentile": 0.25094}, "CVE-2022-23648": {"epss_score": 0.08934, "epss_percentile": 0.92326}, "CVE-2022-23649": {"epss_score": 0.00053, "epss_percentile": 0.16993}, "CVE-2022-23650": {"epss_score": 0.00593, "epss_percentile": 0.68638}, "CVE-2022-23651": {"epss_score": 0.00046, "epss_percentile": 0.14176}, "CVE-2022-23652": {"epss_score": 0.00385, "epss_percentile": 0.5923}, "CVE-2022-23653": {"epss_score": 0.00038, "epss_percentile": 0.11424}, "CVE-2022-23654": {"epss_score": 0.00236, "epss_percentile": 0.4636}, "CVE-2022-23655": {"epss_score": 0.00142, "epss_percentile": 0.34968}, "CVE-2022-23656": {"epss_score": 0.00319, "epss_percentile": 0.54474}, "CVE-2022-23657": {"epss_score": 0.03571, "epss_percentile": 0.8737}, "CVE-2022-23658": {"epss_score": 0.02111, "epss_percentile": 0.83647}, "CVE-2022-23659": {"epss_score": 0.00616, "epss_percentile": 0.69339}, "CVE-2022-23660": {"epss_score": 0.02111, "epss_percentile": 0.83647}, "CVE-2022-23661": {"epss_score": 0.02388, "epss_percentile": 0.84587}, "CVE-2022-23662": {"epss_score": 0.02388, "epss_percentile": 0.84587}, "CVE-2022-23663": {"epss_score": 0.02388, "epss_percentile": 0.84587}, "CVE-2022-23664": {"epss_score": 0.02388, "epss_percentile": 0.84587}, "CVE-2022-23665": {"epss_score": 0.02388, "epss_percentile": 0.84587}, "CVE-2022-23666": {"epss_score": 0.02388, "epss_percentile": 0.84587}, "CVE-2022-23667": {"epss_score": 0.01261, "epss_percentile": 0.78974}, "CVE-2022-23668": {"epss_score": 0.00316, "epss_percentile": 0.54233}, "CVE-2022-23669": {"epss_score": 0.00286, "epss_percentile": 0.51722}, "CVE-2022-23670": {"epss_score": 0.00379, "epss_percentile": 0.58864}, "CVE-2022-23671": {"epss_score": 0.00419, "epss_percentile": 0.61358}, "CVE-2022-23672": {"epss_score": 0.03873, "epss_percentile": 0.87884}, "CVE-2022-23673": {"epss_score": 0.03873, "epss_percentile": 0.87884}, "CVE-2022-23674": {"epss_score": 0.00255, "epss_percentile": 0.4872}, "CVE-2022-23675": {"epss_score": 0.00283, "epss_percentile": 0.51386}, "CVE-2022-23676": {"epss_score": 0.06304, "epss_percentile": 0.90659}, "CVE-2022-23677": {"epss_score": 0.06488, "epss_percentile": 0.90794}, "CVE-2022-23678": {"epss_score": 0.00182, "epss_percentile": 0.40237}, "CVE-2022-23679": {"epss_score": 0.00141, "epss_percentile": 0.34826}, "CVE-2022-23680": {"epss_score": 0.00141, "epss_percentile": 0.34826}, "CVE-2022-23681": {"epss_score": 0.00606, "epss_percentile": 0.69024}, "CVE-2022-23682": {"epss_score": 0.00241, "epss_percentile": 0.47257}, "CVE-2022-23683": {"epss_score": 0.01684, "epss_percentile": 0.81746}, "CVE-2022-23684": {"epss_score": 0.00396, "epss_percentile": 0.59887}, "CVE-2022-23685": {"epss_score": 0.00235, "epss_percentile": 0.46322}, "CVE-2022-23686": {"epss_score": 0.00104, "epss_percentile": 0.29123}, "CVE-2022-23687": {"epss_score": 0.00104, "epss_percentile": 0.29123}, "CVE-2022-23688": {"epss_score": 0.00104, "epss_percentile": 0.29123}, "CVE-2022-23689": {"epss_score": 0.00104, "epss_percentile": 0.29123}, "CVE-2022-23690": {"epss_score": 0.00388, "epss_percentile": 0.59363}, "CVE-2022-23691": {"epss_score": 0.00132, "epss_percentile": 0.33566}, "CVE-2022-23692": {"epss_score": 0.00415, "epss_percentile": 0.61158}, "CVE-2022-23693": {"epss_score": 0.00415, "epss_percentile": 0.61158}, "CVE-2022-23694": {"epss_score": 0.00415, "epss_percentile": 0.61158}, "CVE-2022-23695": {"epss_score": 0.00415, "epss_percentile": 0.61158}, "CVE-2022-23696": {"epss_score": 0.00415, "epss_percentile": 0.61158}, "CVE-2022-23697": {"epss_score": 0.00499, "epss_percentile": 0.65246}, "CVE-2022-23698": {"epss_score": 0.00306, "epss_percentile": 0.53449}, "CVE-2022-23699": {"epss_score": 0.00058, "epss_percentile": 0.18428}, "CVE-2022-23700": {"epss_score": 0.00057, "epss_percentile": 0.18025}, "CVE-2022-23701": {"epss_score": 0.00522, "epss_percentile": 0.66285}, "CVE-2022-23702": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2022-23703": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2022-23704": {"epss_score": 0.00496, "epss_percentile": 0.65163}, "CVE-2022-23705": {"epss_score": 0.00493, "epss_percentile": 0.65059}, "CVE-2022-23706": {"epss_score": 0.00499, "epss_percentile": 0.65246}, "CVE-2022-23707": {"epss_score": 0.00511, "epss_percentile": 0.65833}, "CVE-2022-23708": {"epss_score": 0.00408, "epss_percentile": 0.60683}, "CVE-2022-23709": {"epss_score": 0.00221, "epss_percentile": 0.44656}, "CVE-2022-23710": {"epss_score": 0.00616, "epss_percentile": 0.69327}, "CVE-2022-23711": {"epss_score": 0.00338, "epss_percentile": 0.56154}, "CVE-2022-23712": {"epss_score": 0.03234, "epss_percentile": 0.86701}, "CVE-2022-23713": {"epss_score": 0.00914, "epss_percentile": 0.75394}, "CVE-2022-23714": {"epss_score": 0.0011, "epss_percentile": 0.30213}, "CVE-2022-23715": {"epss_score": 0.00284, "epss_percentile": 0.51437}, "CVE-2022-23716": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2022-23717": {"epss_score": 0.00039, "epss_percentile": 0.11693}, "CVE-2022-23718": {"epss_score": 0.00949, "epss_percentile": 0.75838}, "CVE-2022-23719": {"epss_score": 0.00043, "epss_percentile": 0.1307}, "CVE-2022-23720": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2022-23721": {"epss_score": 0.00035, "epss_percentile": 0.10044}, "CVE-2022-23722": {"epss_score": 0.00131, "epss_percentile": 0.33471}, "CVE-2022-23723": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2022-23724": {"epss_score": 0.00084, "epss_percentile": 0.24849}, "CVE-2022-23725": {"epss_score": 0.00034, "epss_percentile": 0.09566}, "CVE-2022-23726": {"epss_score": 0.0021, "epss_percentile": 0.43493}, "CVE-2022-23727": {"epss_score": 0.00134, "epss_percentile": 0.33868}, "CVE-2022-23728": {"epss_score": 0.00017, "epss_percentile": 0.03198}, "CVE-2022-23729": {"epss_score": 0.00014, "epss_percentile": 0.02109}, "CVE-2022-23730": {"epss_score": 0.00274, "epss_percentile": 0.50545}, "CVE-2022-23731": {"epss_score": 0.00864, "epss_percentile": 0.74596}, "CVE-2022-23732": {"epss_score": 0.00476, "epss_percentile": 0.64294}, "CVE-2022-23733": {"epss_score": 0.00267, "epss_percentile": 0.50005}, "CVE-2022-23734": {"epss_score": 0.05298, "epss_percentile": 0.89704}, "CVE-2022-23737": {"epss_score": 0.00153, "epss_percentile": 0.36569}, "CVE-2022-23738": {"epss_score": 0.00333, "epss_percentile": 0.55627}, "CVE-2022-23739": {"epss_score": 0.00297, "epss_percentile": 0.52701}, "CVE-2022-23740": {"epss_score": 0.02923, "epss_percentile": 0.86001}, "CVE-2022-23741": {"epss_score": 0.00869, "epss_percentile": 0.74684}, "CVE-2022-23742": {"epss_score": 0.0009, "epss_percentile": 0.26155}, "CVE-2022-23743": {"epss_score": 0.00104, "epss_percentile": 0.29224}, "CVE-2022-23744": {"epss_score": 0.00122, "epss_percentile": 0.32085}, "CVE-2022-23745": {"epss_score": 0.00534, "epss_percentile": 0.66786}, "CVE-2022-23746": {"epss_score": 0.00328, "epss_percentile": 0.55184}, "CVE-2022-23747": {"epss_score": 0.0049, "epss_percentile": 0.64928}, "CVE-2022-23748": {"epss_score": 0.11737, "epss_percentile": 0.93462}, "CVE-2022-23763": {"epss_score": 0.00131, "epss_percentile": 0.33484}, "CVE-2022-23764": {"epss_score": 0.00444, "epss_percentile": 0.6284}, "CVE-2022-23765": {"epss_score": 0.00219, "epss_percentile": 0.44532}, "CVE-2022-23766": {"epss_score": 0.00345, "epss_percentile": 0.56599}, "CVE-2022-23767": {"epss_score": 0.00557, "epss_percentile": 0.67547}, "CVE-2022-23768": {"epss_score": 0.00707, "epss_percentile": 0.71656}, "CVE-2022-23769": {"epss_score": 0.01949, "epss_percentile": 0.83011}, "CVE-2022-23770": {"epss_score": 0.01409, "epss_percentile": 0.80075}, "CVE-2022-23771": {"epss_score": 0.00134, "epss_percentile": 0.33798}, "CVE-2022-23772": {"epss_score": 0.00017, "epss_percentile": 0.034}, "CVE-2022-23773": {"epss_score": 0.00062, "epss_percentile": 0.19711}, "CVE-2022-23774": {"epss_score": 0.00353, "epss_percentile": 0.57171}, "CVE-2022-23775": {"epss_score": 0.00451, "epss_percentile": 0.63128}, "CVE-2022-23779": {"epss_score": 0.46707, "epss_percentile": 0.97555}, "CVE-2022-23790": {"epss_score": 0.00167, "epss_percentile": 0.38385}, "CVE-2022-23791": {"epss_score": 0.00167, "epss_percentile": 0.38385}, "CVE-2022-23793": {"epss_score": 0.00049, "epss_percentile": 0.15445}, "CVE-2022-23794": {"epss_score": 6e-05, "epss_percentile": 0.00318}, "CVE-2022-23795": {"epss_score": 9e-05, "epss_percentile": 0.00641}, "CVE-2022-23796": {"epss_score": 0.00124, "epss_percentile": 0.32443}, "CVE-2022-23797": {"epss_score": 0.00073, "epss_percentile": 0.22556}, "CVE-2022-23798": {"epss_score": 0.00033, "epss_percentile": 0.09417}, "CVE-2022-23799": {"epss_score": 0.00012, "epss_percentile": 0.01223}, "CVE-2022-23800": {"epss_score": 0.01156, "epss_percentile": 0.7808}, "CVE-2022-23801": {"epss_score": 0.01352, "epss_percentile": 0.79684}, "CVE-2022-23802": {"epss_score": 0.00406, "epss_percentile": 0.6053}, "CVE-2022-23803": {"epss_score": 0.01284, "epss_percentile": 0.7917}, "CVE-2022-23804": {"epss_score": 0.00949, "epss_percentile": 0.7584}, "CVE-2022-23805": {"epss_score": 0.00106, "epss_percentile": 0.29563}, "CVE-2022-23806": {"epss_score": 0.00024, "epss_percentile": 0.05844}, "CVE-2022-23807": {"epss_score": 0.00077, "epss_percentile": 0.23412}, "CVE-2022-23808": {"epss_score": 0.68413, "epss_percentile": 0.98546}, "CVE-2022-23810": {"epss_score": 0.003, "epss_percentile": 0.52983}, "CVE-2022-23812": {"epss_score": 0.14127, "epss_percentile": 0.9414}, "CVE-2022-23813": {"epss_score": 0.00197, "epss_percentile": 0.41862}, "CVE-2022-23814": {"epss_score": 0.00199, "epss_percentile": 0.4211}, "CVE-2022-23815": {"epss_score": 0.00083, "epss_percentile": 0.24598}, "CVE-2022-23817": {"epss_score": 0.00097, "epss_percentile": 0.27582}, "CVE-2022-23818": {"epss_score": 0.00093, "epss_percentile": 0.26632}, "CVE-2022-23820": {"epss_score": 0.00184, "epss_percentile": 0.40439}, "CVE-2022-23821": {"epss_score": 0.00341, "epss_percentile": 0.56301}, "CVE-2022-23822": {"epss_score": 0.00065, "epss_percentile": 0.20572}, "CVE-2022-23823": {"epss_score": 0.00772, "epss_percentile": 0.73046}, "CVE-2022-23824": {"epss_score": 0.00048, "epss_percentile": 0.15016}, "CVE-2022-23825": {"epss_score": 0.00187, "epss_percentile": 0.40744}, "CVE-2022-23829": {"epss_score": 7e-05, "epss_percentile": 0.00354}, "CVE-2022-23830": {"epss_score": 0.00072, "epss_percentile": 0.22383}, "CVE-2022-23831": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-23833": {"epss_score": 0.03594, "epss_percentile": 0.87403}, "CVE-2022-23835": {"epss_score": 0.00361, "epss_percentile": 0.57707}, "CVE-2022-23837": {"epss_score": 0.00989, "epss_percentile": 0.76369}, "CVE-2022-23848": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2022-23849": {"epss_score": 0.00059, "epss_percentile": 0.18877}, "CVE-2022-23850": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2022-23851": {"epss_score": 0.00059, "epss_percentile": 0.18848}, "CVE-2022-23852": {"epss_score": 0.01707, "epss_percentile": 0.81863}, "CVE-2022-23853": {"epss_score": 0.00211, "epss_percentile": 0.43618}, "CVE-2022-23854": {"epss_score": 0.92614, "epss_percentile": 0.9973}, "CVE-2022-23855": {"epss_score": 0.00986, "epss_percentile": 0.76332}, "CVE-2022-23856": {"epss_score": 0.00165, "epss_percentile": 0.38029}, "CVE-2022-23857": {"epss_score": 0.00294, "epss_percentile": 0.52428}, "CVE-2022-23858": {"epss_score": 0.00576, "epss_percentile": 0.6813}, "CVE-2022-23861": {"epss_score": 0.00227, "epss_percentile": 0.45425}, "CVE-2022-23862": {"epss_score": 0.01335, "epss_percentile": 0.79547}, "CVE-2022-23863": {"epss_score": 0.02953, "epss_percentile": 0.86058}, "CVE-2022-23865": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-23868": {"epss_score": 0.00254, "epss_percentile": 0.48564}, "CVE-2022-23869": {"epss_score": 0.00134, "epss_percentile": 0.33787}, "CVE-2022-23871": {"epss_score": 0.00192, "epss_percentile": 0.41298}, "CVE-2022-23872": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-23873": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-23878": {"epss_score": 0.00428, "epss_percentile": 0.61943}, "CVE-2022-23880": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2022-23881": {"epss_score": 0.86657, "epss_percentile": 0.99391}, "CVE-2022-23882": {"epss_score": 0.00286, "epss_percentile": 0.51719}, "CVE-2022-23884": {"epss_score": 0.05099, "epss_percentile": 0.89497}, "CVE-2022-23887": {"epss_score": 0.00229, "epss_percentile": 0.45586}, "CVE-2022-23888": {"epss_score": 0.0045, "epss_percentile": 0.63066}, "CVE-2022-23889": {"epss_score": 0.00289, "epss_percentile": 0.52004}, "CVE-2022-23896": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-23898": {"epss_score": 0.82815, "epss_percentile": 0.99216}, "CVE-2022-23899": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-23900": {"epss_score": 0.05849, "epss_percentile": 0.90262}, "CVE-2022-23901": {"epss_score": 0.00532, "epss_percentile": 0.66697}, "CVE-2022-23902": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-23903": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-23904": {"epss_score": 0.00184, "epss_percentile": 0.40372}, "CVE-2022-23906": {"epss_score": 0.06427, "epss_percentile": 0.90753}, "CVE-2022-23907": {"epss_score": 0.00489, "epss_percentile": 0.64913}, "CVE-2022-23909": {"epss_score": 0.00216, "epss_percentile": 0.4415}, "CVE-2022-23911": {"epss_score": 0.0062, "epss_percentile": 0.6945}, "CVE-2022-23912": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-23913": {"epss_score": 0.00894, "epss_percentile": 0.75083}, "CVE-2022-23915": {"epss_score": 0.01633, "epss_percentile": 0.81464}, "CVE-2022-23916": {"epss_score": 0.00347, "epss_percentile": 0.56742}, "CVE-2022-23918": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-23919": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-23921": {"epss_score": 0.00038, "epss_percentile": 0.11113}, "CVE-2022-23922": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2022-23923": {"epss_score": 0.0015, "epss_percentile": 0.36053}, "CVE-2022-23924": {"epss_score": 0.00305, "epss_percentile": 0.53312}, "CVE-2022-23925": {"epss_score": 0.00062, "epss_percentile": 0.19604}, "CVE-2022-23926": {"epss_score": 0.00062, "epss_percentile": 0.19604}, "CVE-2022-23927": {"epss_score": 0.00062, "epss_percentile": 0.19604}, "CVE-2022-23928": {"epss_score": 0.00305, "epss_percentile": 0.53312}, "CVE-2022-23929": {"epss_score": 0.00062, "epss_percentile": 0.19604}, "CVE-2022-23930": {"epss_score": 0.00062, "epss_percentile": 0.19604}, "CVE-2022-23931": {"epss_score": 0.00062, "epss_percentile": 0.19604}, "CVE-2022-23932": {"epss_score": 0.00062, "epss_percentile": 0.19604}, "CVE-2022-23933": {"epss_score": 0.00062, "epss_percentile": 0.19604}, "CVE-2022-23934": {"epss_score": 0.0006, "epss_percentile": 0.19108}, "CVE-2022-23935": {"epss_score": 0.27752, "epss_percentile": 0.96279}, "CVE-2022-23937": {"epss_score": 0.00184, "epss_percentile": 0.40428}, "CVE-2022-23940": {"epss_score": 0.35871, "epss_percentile": 0.96939}, "CVE-2022-23942": {"epss_score": 0.01383, "epss_percentile": 0.79896}, "CVE-2022-23943": {"epss_score": 0.67604, "epss_percentile": 0.98514}, "CVE-2022-23944": {"epss_score": 0.90239, "epss_percentile": 0.99571}, "CVE-2022-23945": {"epss_score": 0.00987, "epss_percentile": 0.76338}, "CVE-2022-23946": {"epss_score": 0.0075, "epss_percentile": 0.72617}, "CVE-2022-23947": {"epss_score": 0.00547, "epss_percentile": 0.67233}, "CVE-2022-23948": {"epss_score": 0.00321, "epss_percentile": 0.54734}, "CVE-2022-23949": {"epss_score": 0.00404, "epss_percentile": 0.60427}, "CVE-2022-23950": {"epss_score": 0.00387, "epss_percentile": 0.59303}, "CVE-2022-23951": {"epss_score": 0.00064, "epss_percentile": 0.2042}, "CVE-2022-23952": {"epss_score": 0.00366, "epss_percentile": 0.58017}, "CVE-2022-23953": {"epss_score": 0.00402, "epss_percentile": 0.60306}, "CVE-2022-23954": {"epss_score": 0.00391, "epss_percentile": 0.59587}, "CVE-2022-23955": {"epss_score": 0.00391, "epss_percentile": 0.59587}, "CVE-2022-23956": {"epss_score": 0.00402, "epss_percentile": 0.60306}, "CVE-2022-23957": {"epss_score": 0.00056, "epss_percentile": 0.17718}, "CVE-2022-23958": {"epss_score": 0.00391, "epss_percentile": 0.59587}, "CVE-2022-23959": {"epss_score": 0.00346, "epss_percentile": 0.56639}, "CVE-2022-23960": {"epss_score": 0.00179, "epss_percentile": 0.39818}, "CVE-2022-23968": {"epss_score": 0.01267, "epss_percentile": 0.79022}, "CVE-2022-23970": {"epss_score": 0.00074, "epss_percentile": 0.22832}, "CVE-2022-23971": {"epss_score": 0.00074, "epss_percentile": 0.22832}, "CVE-2022-23972": {"epss_score": 0.00051, "epss_percentile": 0.16332}, "CVE-2022-23973": {"epss_score": 0.00077, "epss_percentile": 0.23453}, "CVE-2022-23974": {"epss_score": 0.03726, "epss_percentile": 0.87633}, "CVE-2022-23975": {"epss_score": 0.00184, "epss_percentile": 0.40411}, "CVE-2022-23976": {"epss_score": 0.00212, "epss_percentile": 0.43802}, "CVE-2022-23979": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2022-23980": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-23981": {"epss_score": 0.00135, "epss_percentile": 0.33993}, "CVE-2022-23982": {"epss_score": 0.00532, "epss_percentile": 0.66678}, "CVE-2022-23983": {"epss_score": 0.00114, "epss_percentile": 0.30819}, "CVE-2022-23984": {"epss_score": 0.00653, "epss_percentile": 0.70324}, "CVE-2022-23985": {"epss_score": 0.00271, "epss_percentile": 0.50282}, "CVE-2022-23986": {"epss_score": 0.01109, "epss_percentile": 0.77653}, "CVE-2022-23987": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-23988": {"epss_score": 0.14426, "epss_percentile": 0.9421}, "CVE-2022-23989": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-23990": {"epss_score": 0.037, "epss_percentile": 0.87589}, "CVE-2022-23992": {"epss_score": 0.01693, "epss_percentile": 0.818}, "CVE-2022-23993": {"epss_score": 0.00239, "epss_percentile": 0.46866}, "CVE-2022-23994": {"epss_score": 0.00198, "epss_percentile": 0.42086}, "CVE-2022-23995": {"epss_score": 0.00188, "epss_percentile": 0.40844}, "CVE-2022-23996": {"epss_score": 0.00188, "epss_percentile": 0.40844}, "CVE-2022-23997": {"epss_score": 0.00188, "epss_percentile": 0.40844}, "CVE-2022-23998": {"epss_score": 0.00183, "epss_percentile": 0.40339}, "CVE-2022-23999": {"epss_score": 0.00016, "epss_percentile": 0.02964}, "CVE-2022-24000": {"epss_score": 0.00016, "epss_percentile": 0.02964}, "CVE-2022-24001": {"epss_score": 0.00021, "epss_percentile": 0.04867}, "CVE-2022-24002": {"epss_score": 0.00184, "epss_percentile": 0.40449}, "CVE-2022-24003": {"epss_score": 0.00215, "epss_percentile": 0.44125}, "CVE-2022-24004": {"epss_score": 0.00502, "epss_percentile": 0.65396}, "CVE-2022-24005": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-24006": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-24007": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-24008": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-24009": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-24010": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24011": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24012": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24013": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24014": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24015": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24016": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-24017": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24018": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24019": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24020": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-24021": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24022": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24023": {"epss_score": 0.00122, "epss_percentile": 0.32054}, "CVE-2022-24024": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24025": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24026": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24027": {"epss_score": 0.00541, "epss_percentile": 0.67039}, "CVE-2022-24028": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-24029": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-24030": {"epss_score": 0.00054, "epss_percentile": 0.17092}, "CVE-2022-24031": {"epss_score": 0.00072, "epss_percentile": 0.22319}, "CVE-2022-24032": {"epss_score": 0.00173, "epss_percentile": 0.39068}, "CVE-2022-24035": {"epss_score": 0.00072, "epss_percentile": 0.22377}, "CVE-2022-24036": {"epss_score": 0.01135, "epss_percentile": 0.77906}, "CVE-2022-24037": {"epss_score": 0.00481, "epss_percentile": 0.64489}, "CVE-2022-24038": {"epss_score": 0.0054, "epss_percentile": 0.67019}, "CVE-2022-24039": {"epss_score": 0.02118, "epss_percentile": 0.83668}, "CVE-2022-24040": {"epss_score": 0.00514, "epss_percentile": 0.65945}, "CVE-2022-24041": {"epss_score": 0.00189, "epss_percentile": 0.40989}, "CVE-2022-24042": {"epss_score": 0.00298, "epss_percentile": 0.52798}, "CVE-2022-24043": {"epss_score": 0.00674, "epss_percentile": 0.70877}, "CVE-2022-24044": {"epss_score": 0.00342, "epss_percentile": 0.56366}, "CVE-2022-24045": {"epss_score": 0.00938, "epss_percentile": 0.75712}, "CVE-2022-24046": {"epss_score": 0.07417, "epss_percentile": 0.91461}, "CVE-2022-24047": {"epss_score": 0.02349, "epss_percentile": 0.84466}, "CVE-2022-24048": {"epss_score": 0.00094, "epss_percentile": 0.26971}, "CVE-2022-24049": {"epss_score": 0.37962, "epss_percentile": 0.97078}, "CVE-2022-24050": {"epss_score": 0.00103, "epss_percentile": 0.28934}, "CVE-2022-24051": {"epss_score": 0.00063, "epss_percentile": 0.19995}, "CVE-2022-24052": {"epss_score": 0.00094, "epss_percentile": 0.26971}, "CVE-2022-24055": {"epss_score": 0.00426, "epss_percentile": 0.61763}, "CVE-2022-24056": {"epss_score": 0.01043, "epss_percentile": 0.76987}, "CVE-2022-24057": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2022-24058": {"epss_score": 0.00667, "epss_percentile": 0.70711}, "CVE-2022-24059": {"epss_score": 0.01043, "epss_percentile": 0.76987}, "CVE-2022-24060": {"epss_score": 0.00426, "epss_percentile": 0.61763}, "CVE-2022-24061": {"epss_score": 0.00426, "epss_percentile": 0.61763}, "CVE-2022-24062": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2022-24063": {"epss_score": 0.01089, "epss_percentile": 0.77443}, "CVE-2022-24064": {"epss_score": 0.00478, "epss_percentile": 0.64368}, "CVE-2022-24065": {"epss_score": 0.01775, "epss_percentile": 0.82215}, "CVE-2022-24066": {"epss_score": 0.03036, "epss_percentile": 0.86263}, "CVE-2022-24069": {"epss_score": 0.00069, "epss_percentile": 0.21559}, "CVE-2022-24070": {"epss_score": 0.00714, "epss_percentile": 0.71809}, "CVE-2022-24071": {"epss_score": 0.00206, "epss_percentile": 0.43072}, "CVE-2022-24072": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2022-24073": {"epss_score": 0.00195, "epss_percentile": 0.41646}, "CVE-2022-24074": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2022-24075": {"epss_score": 0.00341, "epss_percentile": 0.56293}, "CVE-2022-24077": {"epss_score": 0.0004, "epss_percentile": 0.1195}, "CVE-2022-24082": {"epss_score": 0.31462, "epss_percentile": 0.96622}, "CVE-2022-24083": {"epss_score": 0.00441, "epss_percentile": 0.62693}, "CVE-2022-24086": {"epss_score": 0.93778, "epss_percentile": 0.99845}, "CVE-2022-24090": {"epss_score": 0.01024, "epss_percentile": 0.76783}, "CVE-2022-24091": {"epss_score": 0.07103, "epss_percentile": 0.91254}, "CVE-2022-24092": {"epss_score": 0.02687, "epss_percentile": 0.8543}, "CVE-2022-24093": {"epss_score": 0.01024, "epss_percentile": 0.7678}, "CVE-2022-24094": {"epss_score": 0.01347, "epss_percentile": 0.79656}, "CVE-2022-24095": {"epss_score": 0.01347, "epss_percentile": 0.79656}, "CVE-2022-24096": {"epss_score": 0.01347, "epss_percentile": 0.79656}, "CVE-2022-24097": {"epss_score": 0.00899, "epss_percentile": 0.75156}, "CVE-2022-24098": {"epss_score": 0.01716, "epss_percentile": 0.819}, "CVE-2022-24099": {"epss_score": 0.0193, "epss_percentile": 0.82938}, "CVE-2022-24101": {"epss_score": 0.02136, "epss_percentile": 0.83727}, "CVE-2022-24102": {"epss_score": 0.02015, "epss_percentile": 0.83273}, "CVE-2022-24103": {"epss_score": 0.05848, "epss_percentile": 0.9026}, "CVE-2022-24104": {"epss_score": 0.05919, "epss_percentile": 0.90321}, "CVE-2022-24105": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-24106": {"epss_score": 0.00122, "epss_percentile": 0.3207}, "CVE-2022-24107": {"epss_score": 0.00089, "epss_percentile": 0.2582}, "CVE-2022-24108": {"epss_score": 0.40643, "epss_percentile": 0.9723}, "CVE-2022-24109": {"epss_score": 0.00122, "epss_percentile": 0.32074}, "CVE-2022-24110": {"epss_score": 0.00306, "epss_percentile": 0.53415}, "CVE-2022-24111": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2022-24112": {"epss_score": 0.94435, "epss_percentile": 0.99984}, "CVE-2022-24113": {"epss_score": 0.00033, "epss_percentile": 0.09344}, "CVE-2022-24114": {"epss_score": 0.0004, "epss_percentile": 0.11907}, "CVE-2022-24115": {"epss_score": 0.00024, "epss_percentile": 0.0585}, "CVE-2022-24116": {"epss_score": 0.00081, "epss_percentile": 0.24319}, "CVE-2022-24117": {"epss_score": 0.00115, "epss_percentile": 0.30924}, "CVE-2022-24118": {"epss_score": 0.00257, "epss_percentile": 0.48851}, "CVE-2022-24119": {"epss_score": 0.0035, "epss_percentile": 0.56919}, "CVE-2022-24120": {"epss_score": 0.00047, "epss_percentile": 0.14493}, "CVE-2022-24121": {"epss_score": 0.00427, "epss_percentile": 0.61887}, "CVE-2022-24122": {"epss_score": 0.00186, "epss_percentile": 0.40693}, "CVE-2022-24123": {"epss_score": 0.012, "epss_percentile": 0.78468}, "CVE-2022-24124": {"epss_score": 0.57377, "epss_percentile": 0.9806}, "CVE-2022-24125": {"epss_score": 0.0909, "epss_percentile": 0.92397}, "CVE-2022-24126": {"epss_score": 0.09852, "epss_percentile": 0.92734}, "CVE-2022-24127": {"epss_score": 0.00158, "epss_percentile": 0.37162}, "CVE-2022-24128": {"epss_score": 0.00376, "epss_percentile": 0.58648}, "CVE-2022-24129": {"epss_score": 0.2188, "epss_percentile": 0.95569}, "CVE-2022-24130": {"epss_score": 0.00429, "epss_percentile": 0.61977}, "CVE-2022-24131": {"epss_score": 0.00427, "epss_percentile": 0.61912}, "CVE-2022-24132": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2022-24135": {"epss_score": 0.00112, "epss_percentile": 0.30456}, "CVE-2022-24136": {"epss_score": 0.00186, "epss_percentile": 0.40614}, "CVE-2022-24138": {"epss_score": 0.0008, "epss_percentile": 0.24182}, "CVE-2022-24139": {"epss_score": 0.00038, "epss_percentile": 0.11342}, "CVE-2022-24140": {"epss_score": 0.00889, "epss_percentile": 0.75018}, "CVE-2022-24141": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2022-24142": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24143": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24144": {"epss_score": 0.10519, "epss_percentile": 0.93016}, "CVE-2022-24145": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24146": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24147": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24148": {"epss_score": 0.09137, "epss_percentile": 0.92417}, "CVE-2022-24149": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24150": {"epss_score": 0.09137, "epss_percentile": 0.92417}, "CVE-2022-24151": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24152": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24153": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24154": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24155": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24156": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24157": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24158": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24159": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24160": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24161": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24162": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24163": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24164": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24165": {"epss_score": 0.1555, "epss_percentile": 0.94455}, "CVE-2022-24166": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24167": {"epss_score": 0.04328, "epss_percentile": 0.88556}, "CVE-2022-24168": {"epss_score": 0.04328, "epss_percentile": 0.88556}, "CVE-2022-24169": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24170": {"epss_score": 0.1555, "epss_percentile": 0.94455}, "CVE-2022-24171": {"epss_score": 0.1555, "epss_percentile": 0.94455}, "CVE-2022-24172": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-24177": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-24181": {"epss_score": 0.04272, "epss_percentile": 0.88477}, "CVE-2022-24187": {"epss_score": 0.00342, "epss_percentile": 0.56372}, "CVE-2022-24188": {"epss_score": 0.00174, "epss_percentile": 0.39167}, "CVE-2022-24189": {"epss_score": 0.00238, "epss_percentile": 0.46773}, "CVE-2022-24190": {"epss_score": 0.0024, "epss_percentile": 0.4695}, "CVE-2022-24191": {"epss_score": 0.00036, "epss_percentile": 0.1036}, "CVE-2022-24193": {"epss_score": 0.19336, "epss_percentile": 0.95165}, "CVE-2022-24196": {"epss_score": 0.00693, "epss_percentile": 0.71325}, "CVE-2022-24197": {"epss_score": 0.00647, "epss_percentile": 0.70184}, "CVE-2022-24198": {"epss_score": 0.00389, "epss_percentile": 0.59459}, "CVE-2022-24206": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-24218": {"epss_score": 0.00475, "epss_percentile": 0.64177}, "CVE-2022-24219": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-24220": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-24221": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-24222": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-24223": {"epss_score": 0.65106, "epss_percentile": 0.98403}, "CVE-2022-24226": {"epss_score": 0.00547, "epss_percentile": 0.67247}, "CVE-2022-24227": {"epss_score": 0.03285, "epss_percentile": 0.86823}, "CVE-2022-24229": {"epss_score": 0.00352, "epss_percentile": 0.5713}, "CVE-2022-24231": {"epss_score": 0.00489, "epss_percentile": 0.64913}, "CVE-2022-24232": {"epss_score": 0.00533, "epss_percentile": 0.6676}, "CVE-2022-24235": {"epss_score": 0.0026, "epss_percentile": 0.49185}, "CVE-2022-24236": {"epss_score": 0.0025, "epss_percentile": 0.48138}, "CVE-2022-24237": {"epss_score": 0.26722, "epss_percentile": 0.9617}, "CVE-2022-24238": {"epss_score": 0.00486, "epss_percentile": 0.64769}, "CVE-2022-24239": {"epss_score": 0.00725, "epss_percentile": 0.72062}, "CVE-2022-24240": {"epss_score": 0.00646, "epss_percentile": 0.70131}, "CVE-2022-24241": {"epss_score": 0.00386, "epss_percentile": 0.59253}, "CVE-2022-24247": {"epss_score": 0.01468, "epss_percentile": 0.80478}, "CVE-2022-24248": {"epss_score": 0.00745, "epss_percentile": 0.72529}, "CVE-2022-24249": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2022-24251": {"epss_score": 0.00668, "epss_percentile": 0.70732}, "CVE-2022-24252": {"epss_score": 0.02155, "epss_percentile": 0.83807}, "CVE-2022-24253": {"epss_score": 0.00668, "epss_percentile": 0.70732}, "CVE-2022-24254": {"epss_score": 0.02636, "epss_percentile": 0.85294}, "CVE-2022-24255": {"epss_score": 0.00308, "epss_percentile": 0.53602}, "CVE-2022-24259": {"epss_score": 0.02918, "epss_percentile": 0.85985}, "CVE-2022-24260": {"epss_score": 0.91405, "epss_percentile": 0.9964}, "CVE-2022-24262": {"epss_score": 0.03913, "epss_percentile": 0.87937}, "CVE-2022-24263": {"epss_score": 0.02041, "epss_percentile": 0.83372}, "CVE-2022-24264": {"epss_score": 0.63624, "epss_percentile": 0.98342}, "CVE-2022-24265": {"epss_score": 0.54717, "epss_percentile": 0.97941}, "CVE-2022-24266": {"epss_score": 0.59035, "epss_percentile": 0.98146}, "CVE-2022-24272": {"epss_score": 0.00458, "epss_percentile": 0.63431}, "CVE-2022-24278": {"epss_score": 0.00729, "epss_percentile": 0.7213}, "CVE-2022-24279": {"epss_score": 0.00523, "epss_percentile": 0.66288}, "CVE-2022-24280": {"epss_score": 0.00224, "epss_percentile": 0.45055}, "CVE-2022-24281": {"epss_score": 0.0067, "epss_percentile": 0.70769}, "CVE-2022-24282": {"epss_score": 0.0277, "epss_percentile": 0.85618}, "CVE-2022-24285": {"epss_score": 0.00029, "epss_percentile": 0.07945}, "CVE-2022-24286": {"epss_score": 0.00029, "epss_percentile": 0.07945}, "CVE-2022-24287": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2022-24288": {"epss_score": 0.90127, "epss_percentile": 0.99563}, "CVE-2022-24289": {"epss_score": 0.03338, "epss_percentile": 0.86938}, "CVE-2022-24290": {"epss_score": 0.00751, "epss_percentile": 0.72642}, "CVE-2022-24291": {"epss_score": 0.01756, "epss_percentile": 0.82131}, "CVE-2022-24292": {"epss_score": 0.01982, "epss_percentile": 0.83141}, "CVE-2022-24293": {"epss_score": 0.01982, "epss_percentile": 0.83141}, "CVE-2022-24294": {"epss_score": 0.04723, "epss_percentile": 0.89058}, "CVE-2022-24295": {"epss_score": 0.05288, "epss_percentile": 0.89695}, "CVE-2022-24296": {"epss_score": 0.0024, "epss_percentile": 0.46967}, "CVE-2022-24297": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2022-24298": {"epss_score": 0.00465, "epss_percentile": 0.6378}, "CVE-2022-24299": {"epss_score": 0.00269, "epss_percentile": 0.50186}, "CVE-2022-24300": {"epss_score": 0.00714, "epss_percentile": 0.7183}, "CVE-2022-24301": {"epss_score": 0.00273, "epss_percentile": 0.50442}, "CVE-2022-24302": {"epss_score": 0.00729, "epss_percentile": 0.72126}, "CVE-2022-24303": {"epss_score": 0.01378, "epss_percentile": 0.79847}, "CVE-2022-24305": {"epss_score": 0.13093, "epss_percentile": 0.93872}, "CVE-2022-24306": {"epss_score": 0.05595, "epss_percentile": 0.90033}, "CVE-2022-24307": {"epss_score": 0.00367, "epss_percentile": 0.58118}, "CVE-2022-24308": {"epss_score": 0.00052, "epss_percentile": 0.16549}, "CVE-2022-24309": {"epss_score": 0.00164, "epss_percentile": 0.37996}, "CVE-2022-24310": {"epss_score": 0.01641, "epss_percentile": 0.81504}, "CVE-2022-24311": {"epss_score": 0.03703, "epss_percentile": 0.87594}, "CVE-2022-24312": {"epss_score": 0.01751, "epss_percentile": 0.82104}, "CVE-2022-24313": {"epss_score": 0.07767, "epss_percentile": 0.91671}, "CVE-2022-24314": {"epss_score": 0.00627, "epss_percentile": 0.69631}, "CVE-2022-24315": {"epss_score": 0.02456, "epss_percentile": 0.848}, "CVE-2022-24316": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2022-24317": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2022-24318": {"epss_score": 0.001, "epss_percentile": 0.28534}, "CVE-2022-24319": {"epss_score": 0.00148, "epss_percentile": 0.35914}, "CVE-2022-24320": {"epss_score": 0.00184, "epss_percentile": 0.40402}, "CVE-2022-24321": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2022-24322": {"epss_score": 0.00221, "epss_percentile": 0.44636}, "CVE-2022-24323": {"epss_score": 0.00221, "epss_percentile": 0.44636}, "CVE-2022-24324": {"epss_score": 0.03678, "epss_percentile": 0.87555}, "CVE-2022-24327": {"epss_score": 2e-05, "epss_percentile": 0.00053}, "CVE-2022-24328": {"epss_score": 3e-05, "epss_percentile": 0.00117}, "CVE-2022-24329": {"epss_score": 2e-05, "epss_percentile": 0.00049}, "CVE-2022-24330": {"epss_score": 3e-05, "epss_percentile": 0.00061}, "CVE-2022-24331": {"epss_score": 6e-05, "epss_percentile": 0.0024}, "CVE-2022-24332": {"epss_score": 3e-05, "epss_percentile": 0.00071}, "CVE-2022-24333": {"epss_score": 2e-05, "epss_percentile": 0.00054}, "CVE-2022-24334": {"epss_score": 3e-05, "epss_percentile": 0.00099}, "CVE-2022-24335": {"epss_score": 4e-05, "epss_percentile": 0.00127}, "CVE-2022-24336": {"epss_score": 4e-05, "epss_percentile": 0.00165}, "CVE-2022-24337": {"epss_score": 2e-05, "epss_percentile": 0.00044}, "CVE-2022-24338": {"epss_score": 0.00011, "epss_percentile": 0.01018}, "CVE-2022-24339": {"epss_score": 0.00012, "epss_percentile": 0.0127}, "CVE-2022-24340": {"epss_score": 4e-05, "epss_percentile": 0.00136}, "CVE-2022-24341": {"epss_score": 3e-05, "epss_percentile": 0.00071}, "CVE-2022-24342": {"epss_score": 0.00077, "epss_percentile": 0.23523}, "CVE-2022-24343": {"epss_score": 2e-05, "epss_percentile": 0.00022}, "CVE-2022-24344": {"epss_score": 9e-05, "epss_percentile": 0.0066}, "CVE-2022-24345": {"epss_score": 2e-05, "epss_percentile": 0.00025}, "CVE-2022-24346": {"epss_score": 1e-05, "epss_percentile": 8e-05}, "CVE-2022-24347": {"epss_score": 9e-05, "epss_percentile": 0.0066}, "CVE-2022-24348": {"epss_score": 0.03447, "epss_percentile": 0.87158}, "CVE-2022-24349": {"epss_score": 0.00261, "epss_percentile": 0.49294}, "CVE-2022-24350": {"epss_score": 0.00049, "epss_percentile": 0.15357}, "CVE-2022-24351": {"epss_score": 0.00032, "epss_percentile": 0.08745}, "CVE-2022-24352": {"epss_score": 0.00042, "epss_percentile": 0.12937}, "CVE-2022-24353": {"epss_score": 0.00042, "epss_percentile": 0.12937}, "CVE-2022-24354": {"epss_score": 0.00289, "epss_percentile": 0.52044}, "CVE-2022-24355": {"epss_score": 0.00374, "epss_percentile": 0.58572}, "CVE-2022-24356": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24357": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24358": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24359": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24360": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24361": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24362": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24363": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24364": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24365": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24366": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24367": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24368": {"epss_score": 0.00506, "epss_percentile": 0.65632}, "CVE-2022-24369": {"epss_score": 0.0066, "epss_percentile": 0.70562}, "CVE-2022-24370": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2022-24372": {"epss_score": 0.00064, "epss_percentile": 0.20325}, "CVE-2022-24373": {"epss_score": 0.00534, "epss_percentile": 0.66781}, "CVE-2022-24374": {"epss_score": 0.00321, "epss_percentile": 0.54675}, "CVE-2022-24375": {"epss_score": 0.00605, "epss_percentile": 0.6897}, "CVE-2022-24376": {"epss_score": 0.02518, "epss_percentile": 0.84991}, "CVE-2022-24377": {"epss_score": 0.0137, "epss_percentile": 0.798}, "CVE-2022-24378": {"epss_score": 0.00131, "epss_percentile": 0.33346}, "CVE-2022-24379": {"epss_score": 0.00065, "epss_percentile": 0.20613}, "CVE-2022-24381": {"epss_score": 0.0033, "epss_percentile": 0.55489}, "CVE-2022-24382": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2022-24383": {"epss_score": 0.00307, "epss_percentile": 0.53521}, "CVE-2022-24384": {"epss_score": 0.51084, "epss_percentile": 0.97764}, "CVE-2022-24385": {"epss_score": 0.00291, "epss_percentile": 0.52152}, "CVE-2022-24386": {"epss_score": 0.00376, "epss_percentile": 0.58683}, "CVE-2022-24387": {"epss_score": 0.00613, "epss_percentile": 0.69242}, "CVE-2022-24388": {"epss_score": 0.00873, "epss_percentile": 0.74742}, "CVE-2022-24389": {"epss_score": 0.00873, "epss_percentile": 0.74742}, "CVE-2022-24390": {"epss_score": 0.00824, "epss_percentile": 0.73934}, "CVE-2022-24391": {"epss_score": 0.00606, "epss_percentile": 0.69015}, "CVE-2022-24392": {"epss_score": 0.00707, "epss_percentile": 0.71663}, "CVE-2022-24393": {"epss_score": 0.00707, "epss_percentile": 0.71663}, "CVE-2022-24394": {"epss_score": 0.00707, "epss_percentile": 0.71663}, "CVE-2022-24395": {"epss_score": 0.00337, "epss_percentile": 0.56057}, "CVE-2022-24396": {"epss_score": 0.00184, "epss_percentile": 0.40457}, "CVE-2022-24397": {"epss_score": 0.00521, "epss_percentile": 0.66222}, "CVE-2022-24398": {"epss_score": 0.00353, "epss_percentile": 0.5719}, "CVE-2022-24399": {"epss_score": 0.00735, "epss_percentile": 0.72294}, "CVE-2022-24400": {"epss_score": 0.00158, "epss_percentile": 0.37215}, "CVE-2022-24401": {"epss_score": 0.00183, "epss_percentile": 0.40309}, "CVE-2022-24402": {"epss_score": 0.00385, "epss_percentile": 0.59208}, "CVE-2022-24403": {"epss_score": 0.00027, "epss_percentile": 0.06903}, "CVE-2022-24404": {"epss_score": 0.00136, "epss_percentile": 0.34128}, "CVE-2022-24405": {"epss_score": 0.08004, "epss_percentile": 0.91823}, "CVE-2022-24406": {"epss_score": 0.00252, "epss_percentile": 0.48335}, "CVE-2022-24407": {"epss_score": 0.00849, "epss_percentile": 0.74375}, "CVE-2022-24408": {"epss_score": 0.00029, "epss_percentile": 0.07945}, "CVE-2022-24409": {"epss_score": 0.00745, "epss_percentile": 0.72515}, "CVE-2022-24410": {"epss_score": 0.00033, "epss_percentile": 0.09291}, "CVE-2022-24411": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2022-24412": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2022-24413": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2022-24414": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2022-24415": {"epss_score": 0.00041, "epss_percentile": 0.12364}, "CVE-2022-24416": {"epss_score": 0.0011, "epss_percentile": 0.30128}, "CVE-2022-24417": {"epss_score": 0.00048, "epss_percentile": 0.1513}, "CVE-2022-24418": {"epss_score": 0.00048, "epss_percentile": 0.1513}, "CVE-2022-24419": {"epss_score": 0.00041, "epss_percentile": 0.12364}, "CVE-2022-24420": {"epss_score": 0.00041, "epss_percentile": 0.12364}, "CVE-2022-24421": {"epss_score": 0.00041, "epss_percentile": 0.12364}, "CVE-2022-24422": {"epss_score": 0.37795, "epss_percentile": 0.9707}, "CVE-2022-24423": {"epss_score": 0.01847, "epss_percentile": 0.82524}, "CVE-2022-24424": {"epss_score": 0.00666, "epss_percentile": 0.7069}, "CVE-2022-24426": {"epss_score": 0.00039, "epss_percentile": 0.11787}, "CVE-2022-24428": {"epss_score": 0.00319, "epss_percentile": 0.54566}, "CVE-2022-24429": {"epss_score": 0.00265, "epss_percentile": 0.49831}, "CVE-2022-24431": {"epss_score": 0.0194, "epss_percentile": 0.8298}, "CVE-2022-24432": {"epss_score": 0.0009, "epss_percentile": 0.2615}, "CVE-2022-24433": {"epss_score": 0.00927, "epss_percentile": 0.75568}, "CVE-2022-24434": {"epss_score": 0.01989, "epss_percentile": 0.83166}, "CVE-2022-24435": {"epss_score": 0.00931, "epss_percentile": 0.75619}, "CVE-2022-24436": {"epss_score": 0.15561, "epss_percentile": 0.94459}, "CVE-2022-24437": {"epss_score": 0.10388, "epss_percentile": 0.9297}, "CVE-2022-24439": {"epss_score": 0.7015, "epss_percentile": 0.9862}, "CVE-2022-24440": {"epss_score": 0.00698, "epss_percentile": 0.71427}, "CVE-2022-24441": {"epss_score": 0.01638, "epss_percentile": 0.81486}, "CVE-2022-24442": {"epss_score": 0.00013, "epss_percentile": 0.01452}, "CVE-2022-24444": {"epss_score": 0.00273, "epss_percentile": 0.50444}, "CVE-2022-24446": {"epss_score": 0.02009, "epss_percentile": 0.83243}, "CVE-2022-24447": {"epss_score": 0.00497, "epss_percentile": 0.65202}, "CVE-2022-24448": {"epss_score": 0.00015, "epss_percentile": 0.02433}, "CVE-2022-24449": {"epss_score": 0.00953, "epss_percentile": 0.75891}, "CVE-2022-24450": {"epss_score": 0.00529, "epss_percentile": 0.66603}, "CVE-2022-24451": {"epss_score": 0.02051, "epss_percentile": 0.83404}, "CVE-2022-24452": {"epss_score": 0.02051, "epss_percentile": 0.83404}, "CVE-2022-24453": {"epss_score": 0.02586, "epss_percentile": 0.85167}, "CVE-2022-24454": {"epss_score": 0.0023, "epss_percentile": 0.45693}, "CVE-2022-24455": {"epss_score": 0.00395, "epss_percentile": 0.59807}, "CVE-2022-24456": {"epss_score": 0.02586, "epss_percentile": 0.85167}, "CVE-2022-24457": {"epss_score": 0.02586, "epss_percentile": 0.85167}, "CVE-2022-24459": {"epss_score": 0.0023, "epss_percentile": 0.45693}, "CVE-2022-24460": {"epss_score": 0.00888, "epss_percentile": 0.75001}, "CVE-2022-24461": {"epss_score": 0.01814, "epss_percentile": 0.82381}, "CVE-2022-24462": {"epss_score": 0.0089, "epss_percentile": 0.75031}, "CVE-2022-24463": {"epss_score": 0.21251, "epss_percentile": 0.95487}, "CVE-2022-24464": {"epss_score": 0.02377, "epss_percentile": 0.84554}, "CVE-2022-24465": {"epss_score": 0.00473, "epss_percentile": 0.64098}, "CVE-2022-24466": {"epss_score": 0.00902, "epss_percentile": 0.75193}, "CVE-2022-24467": {"epss_score": 0.07054, "epss_percentile": 0.91217}, "CVE-2022-24468": {"epss_score": 0.07054, "epss_percentile": 0.91217}, "CVE-2022-24469": {"epss_score": 0.07206, "epss_percentile": 0.91323}, "CVE-2022-24470": {"epss_score": 0.07054, "epss_percentile": 0.91217}, "CVE-2022-24471": {"epss_score": 0.07054, "epss_percentile": 0.91217}, "CVE-2022-24472": {"epss_score": 0.07306, "epss_percentile": 0.91395}, "CVE-2022-24473": {"epss_score": 0.02068, "epss_percentile": 0.83464}, "CVE-2022-24474": {"epss_score": 0.00355, "epss_percentile": 0.57294}, "CVE-2022-24475": {"epss_score": 0.01639, "epss_percentile": 0.81498}, "CVE-2022-24477": {"epss_score": 0.10385, "epss_percentile": 0.92969}, "CVE-2022-24479": {"epss_score": 0.00414, "epss_percentile": 0.61041}, "CVE-2022-24480": {"epss_score": 0.00936, "epss_percentile": 0.75676}, "CVE-2022-24481": {"epss_score": 0.41508, "epss_percentile": 0.97279}, "CVE-2022-24482": {"epss_score": 0.00129, "epss_percentile": 0.33093}, "CVE-2022-24483": {"epss_score": 0.05889, "epss_percentile": 0.90298}, "CVE-2022-24484": {"epss_score": 0.00204, "epss_percentile": 0.42629}, "CVE-2022-24485": {"epss_score": 0.04975, "epss_percentile": 0.89355}, "CVE-2022-24486": {"epss_score": 0.00297, "epss_percentile": 0.52699}, "CVE-2022-24487": {"epss_score": 0.05842, "epss_percentile": 0.90252}, "CVE-2022-24488": {"epss_score": 0.00307, "epss_percentile": 0.53559}, "CVE-2022-24489": {"epss_score": 0.00174, "epss_percentile": 0.39168}, "CVE-2022-24490": {"epss_score": 0.15866, "epss_percentile": 0.94522}, "CVE-2022-24491": {"epss_score": 0.47109, "epss_percentile": 0.97569}, "CVE-2022-24492": {"epss_score": 0.07634, "epss_percentile": 0.91587}, "CVE-2022-24493": {"epss_score": 0.00625, "epss_percentile": 0.69582}, "CVE-2022-24494": {"epss_score": 0.16754, "epss_percentile": 0.94727}, "CVE-2022-24495": {"epss_score": 0.0083, "epss_percentile": 0.74039}, "CVE-2022-24496": {"epss_score": 0.00408, "epss_percentile": 0.60668}, "CVE-2022-24497": {"epss_score": 0.40276, "epss_percentile": 0.9721}, "CVE-2022-24498": {"epss_score": 0.15222, "epss_percentile": 0.94387}, "CVE-2022-24499": {"epss_score": 0.00268, "epss_percentile": 0.50063}, "CVE-2022-24500": {"epss_score": 0.41107, "epss_percentile": 0.97255}, "CVE-2022-24501": {"epss_score": 0.0152, "epss_percentile": 0.80821}, "CVE-2022-24502": {"epss_score": 0.02844, "epss_percentile": 0.85816}, "CVE-2022-24503": {"epss_score": 0.01976, "epss_percentile": 0.83122}, "CVE-2022-24504": {"epss_score": 0.01265, "epss_percentile": 0.79005}, "CVE-2022-24505": {"epss_score": 0.00148, "epss_percentile": 0.35858}, "CVE-2022-24506": {"epss_score": 0.09894, "epss_percentile": 0.92759}, "CVE-2022-24507": {"epss_score": 0.00459, "epss_percentile": 0.63451}, "CVE-2022-24508": {"epss_score": 0.05177, "epss_percentile": 0.89574}, "CVE-2022-24509": {"epss_score": 0.01814, "epss_percentile": 0.82381}, "CVE-2022-24510": {"epss_score": 0.01814, "epss_percentile": 0.82381}, "CVE-2022-24511": {"epss_score": 0.00689, "epss_percentile": 0.71221}, "CVE-2022-24512": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-24513": {"epss_score": 0.00301, "epss_percentile": 0.53047}, "CVE-2022-24515": {"epss_score": 0.01369, "epss_percentile": 0.79793}, "CVE-2022-24516": {"epss_score": 0.13588, "epss_percentile": 0.94003}, "CVE-2022-24517": {"epss_score": 0.07054, "epss_percentile": 0.91217}, "CVE-2022-24518": {"epss_score": 0.09894, "epss_percentile": 0.92759}, "CVE-2022-24519": {"epss_score": 0.09894, "epss_percentile": 0.92759}, "CVE-2022-24520": {"epss_score": 0.07054, "epss_percentile": 0.91217}, "CVE-2022-24521": {"epss_score": 0.07626, "epss_percentile": 0.91581}, "CVE-2022-24522": {"epss_score": 0.02463, "epss_percentile": 0.8483}, "CVE-2022-24523": {"epss_score": 0.05381, "epss_percentile": 0.8981}, "CVE-2022-24525": {"epss_score": 0.00115, "epss_percentile": 0.31035}, "CVE-2022-24526": {"epss_score": 0.00789, "epss_percentile": 0.73347}, "CVE-2022-24527": {"epss_score": 0.00423, "epss_percentile": 0.61626}, "CVE-2022-24528": {"epss_score": 0.05231, "epss_percentile": 0.89638}, "CVE-2022-24530": {"epss_score": 0.00255, "epss_percentile": 0.48673}, "CVE-2022-24532": {"epss_score": 0.0185, "epss_percentile": 0.82534}, "CVE-2022-24533": {"epss_score": 0.08763, "epss_percentile": 0.92244}, "CVE-2022-24534": {"epss_score": 0.04975, "epss_percentile": 0.89355}, "CVE-2022-24536": {"epss_score": 0.09379, "epss_percentile": 0.92523}, "CVE-2022-24537": {"epss_score": 0.00156, "epss_percentile": 0.36978}, "CVE-2022-24538": {"epss_score": 0.03536, "epss_percentile": 0.8731}, "CVE-2022-24539": {"epss_score": 0.17242, "epss_percentile": 0.94804}, "CVE-2022-24540": {"epss_score": 0.00116, "epss_percentile": 0.31199}, "CVE-2022-24541": {"epss_score": 0.08721, "epss_percentile": 0.92226}, "CVE-2022-24542": {"epss_score": 0.01392, "epss_percentile": 0.79957}, "CVE-2022-24543": {"epss_score": 0.0179, "epss_percentile": 0.8228}, "CVE-2022-24544": {"epss_score": 0.00264, "epss_percentile": 0.49711}, "CVE-2022-24545": {"epss_score": 0.04286, "epss_percentile": 0.88493}, "CVE-2022-24546": {"epss_score": 0.00297, "epss_percentile": 0.52699}, "CVE-2022-24547": {"epss_score": 0.002, "epss_percentile": 0.42218}, "CVE-2022-24548": {"epss_score": 0.01193, "epss_percentile": 0.78411}, "CVE-2022-24549": {"epss_score": 0.00174, "epss_percentile": 0.39168}, "CVE-2022-24550": {"epss_score": 0.00432, "epss_percentile": 0.62103}, "CVE-2022-24551": {"epss_score": 0.00294, "epss_percentile": 0.52368}, "CVE-2022-24552": {"epss_score": 0.0109, "epss_percentile": 0.7745}, "CVE-2022-24553": {"epss_score": 0.01721, "epss_percentile": 0.81933}, "CVE-2022-24562": {"epss_score": 0.49159, "epss_percentile": 0.97671}, "CVE-2022-24563": {"epss_score": 0.00464, "epss_percentile": 0.63737}, "CVE-2022-24564": {"epss_score": 0.00616, "epss_percentile": 0.69339}, "CVE-2022-24565": {"epss_score": 0.00609, "epss_percentile": 0.69098}, "CVE-2022-24566": {"epss_score": 0.00502, "epss_percentile": 0.65419}, "CVE-2022-24568": {"epss_score": 0.00316, "epss_percentile": 0.54221}, "CVE-2022-24571": {"epss_score": 0.00484, "epss_percentile": 0.64644}, "CVE-2022-24572": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-24573": {"epss_score": 0.00652, "epss_percentile": 0.70306}, "CVE-2022-24574": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2022-24575": {"epss_score": 0.00251, "epss_percentile": 0.48321}, "CVE-2022-24576": {"epss_score": 0.00149, "epss_percentile": 0.36034}, "CVE-2022-24577": {"epss_score": 0.00132, "epss_percentile": 0.3361}, "CVE-2022-24578": {"epss_score": 0.00133, "epss_percentile": 0.33739}, "CVE-2022-24581": {"epss_score": 0.00387, "epss_percentile": 0.593}, "CVE-2022-24582": {"epss_score": 0.00209, "epss_percentile": 0.43313}, "CVE-2022-24584": {"epss_score": 0.00193, "epss_percentile": 0.41406}, "CVE-2022-24585": {"epss_score": 0.00206, "epss_percentile": 0.42765}, "CVE-2022-24586": {"epss_score": 0.00206, "epss_percentile": 0.42765}, "CVE-2022-24587": {"epss_score": 0.00206, "epss_percentile": 0.42765}, "CVE-2022-24588": {"epss_score": 0.00206, "epss_percentile": 0.42765}, "CVE-2022-24589": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-24590": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-24594": {"epss_score": 0.00278, "epss_percentile": 0.50895}, "CVE-2022-24595": {"epss_score": 0.02717, "epss_percentile": 0.8551}, "CVE-2022-24599": {"epss_score": 0.00202, "epss_percentile": 0.42443}, "CVE-2022-24600": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-24601": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2022-24602": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-24603": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-24604": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-24605": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-24606": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-24607": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-24608": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-24609": {"epss_score": 0.00335, "epss_percentile": 0.55861}, "CVE-2022-24610": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2022-24611": {"epss_score": 0.00177, "epss_percentile": 0.39505}, "CVE-2022-24612": {"epss_score": 0.00237, "epss_percentile": 0.46734}, "CVE-2022-24613": {"epss_score": 0.00213, "epss_percentile": 0.43891}, "CVE-2022-24614": {"epss_score": 0.00278, "epss_percentile": 0.50901}, "CVE-2022-24615": {"epss_score": 0.00278, "epss_percentile": 0.50901}, "CVE-2022-24618": {"epss_score": 0.00023, "epss_percentile": 0.05521}, "CVE-2022-24620": {"epss_score": 0.0027, "epss_percentile": 0.5027}, "CVE-2022-24627": {"epss_score": 0.49889, "epss_percentile": 0.97709}, "CVE-2022-24628": {"epss_score": 0.00101, "epss_percentile": 0.28567}, "CVE-2022-24629": {"epss_score": 0.45658, "epss_percentile": 0.97495}, "CVE-2022-24630": {"epss_score": 0.42602, "epss_percentile": 0.97342}, "CVE-2022-24631": {"epss_score": 0.08459, "epss_percentile": 0.92064}, "CVE-2022-24632": {"epss_score": 0.5694, "epss_percentile": 0.98041}, "CVE-2022-24633": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2022-24637": {"epss_score": 0.93978, "epss_percentile": 0.99879}, "CVE-2022-24643": {"epss_score": 0.01559, "epss_percentile": 0.81033}, "CVE-2022-24644": {"epss_score": 0.10839, "epss_percentile": 0.93129}, "CVE-2022-24646": {"epss_score": 0.00361, "epss_percentile": 0.57705}, "CVE-2022-24647": {"epss_score": 0.00373, "epss_percentile": 0.58471}, "CVE-2022-24651": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2022-24652": {"epss_score": 0.02647, "epss_percentile": 0.85336}, "CVE-2022-24654": {"epss_score": 0.02459, "epss_percentile": 0.84819}, "CVE-2022-24655": {"epss_score": 0.00139, "epss_percentile": 0.34587}, "CVE-2022-24656": {"epss_score": 0.00183, "epss_percentile": 0.40358}, "CVE-2022-24657": {"epss_score": 0.00377, "epss_percentile": 0.5876}, "CVE-2022-24659": {"epss_score": 0.02571, "epss_percentile": 0.85131}, "CVE-2022-24660": {"epss_score": 0.00148, "epss_percentile": 0.35834}, "CVE-2022-24661": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-24663": {"epss_score": 0.01615, "epss_percentile": 0.81349}, "CVE-2022-24664": {"epss_score": 0.01186, "epss_percentile": 0.78347}, "CVE-2022-24665": {"epss_score": 0.0162, "epss_percentile": 0.81383}, "CVE-2022-24666": {"epss_score": 0.02591, "epss_percentile": 0.85182}, "CVE-2022-24667": {"epss_score": 0.00432, "epss_percentile": 0.62112}, "CVE-2022-24668": {"epss_score": 0.00432, "epss_percentile": 0.62112}, "CVE-2022-24669": {"epss_score": 0.00294, "epss_percentile": 0.52409}, "CVE-2022-24670": {"epss_score": 0.00404, "epss_percentile": 0.60429}, "CVE-2022-24671": {"epss_score": 0.0014, "epss_percentile": 0.34696}, "CVE-2022-24672": {"epss_score": 0.00123, "epss_percentile": 0.32315}, "CVE-2022-24673": {"epss_score": 0.08657, "epss_percentile": 0.92175}, "CVE-2022-24674": {"epss_score": 0.00076, "epss_percentile": 0.23144}, "CVE-2022-24675": {"epss_score": 0.00132, "epss_percentile": 0.33566}, "CVE-2022-24676": {"epss_score": 0.00305, "epss_percentile": 0.53353}, "CVE-2022-24677": {"epss_score": 0.02953, "epss_percentile": 0.86057}, "CVE-2022-24678": {"epss_score": 0.00861, "epss_percentile": 0.74554}, "CVE-2022-24679": {"epss_score": 0.00047, "epss_percentile": 0.14617}, "CVE-2022-24680": {"epss_score": 0.00047, "epss_percentile": 0.14617}, "CVE-2022-24681": {"epss_score": 0.10386, "epss_percentile": 0.92969}, "CVE-2022-24682": {"epss_score": 0.87687, "epss_percentile": 0.99438}, "CVE-2022-24683": {"epss_score": 0.00474, "epss_percentile": 0.64137}, "CVE-2022-24684": {"epss_score": 0.00671, "epss_percentile": 0.70806}, "CVE-2022-24685": {"epss_score": 0.00693, "epss_percentile": 0.71326}, "CVE-2022-24686": {"epss_score": 0.00356, "epss_percentile": 0.57326}, "CVE-2022-24687": {"epss_score": 0.00488, "epss_percentile": 0.6486}, "CVE-2022-24688": {"epss_score": 0.03924, "epss_percentile": 0.8796}, "CVE-2022-24689": {"epss_score": 0.00192, "epss_percentile": 0.41323}, "CVE-2022-24690": {"epss_score": 0.02158, "epss_percentile": 0.83817}, "CVE-2022-24691": {"epss_score": 0.0113, "epss_percentile": 0.77847}, "CVE-2022-24692": {"epss_score": 0.00356, "epss_percentile": 0.57344}, "CVE-2022-24693": {"epss_score": 0.01281, "epss_percentile": 0.79148}, "CVE-2022-24694": {"epss_score": 0.00189, "epss_percentile": 0.40999}, "CVE-2022-24695": {"epss_score": 0.00034, "epss_percentile": 0.0979}, "CVE-2022-24696": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2022-24697": {"epss_score": 0.26208, "epss_percentile": 0.96124}, "CVE-2022-24700": {"epss_score": 0.00889, "epss_percentile": 0.75011}, "CVE-2022-24701": {"epss_score": 0.00072, "epss_percentile": 0.22475}, "CVE-2022-24702": {"epss_score": 0.4009, "epss_percentile": 0.97195}, "CVE-2022-24704": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2022-24705": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2022-24706": {"epss_score": 0.94392, "epss_percentile": 0.99969}, "CVE-2022-24707": {"epss_score": 0.02151, "epss_percentile": 0.83787}, "CVE-2022-24708": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-24709": {"epss_score": 0.00391, "epss_percentile": 0.59577}, "CVE-2022-24710": {"epss_score": 0.00311, "epss_percentile": 0.53819}, "CVE-2022-24711": {"epss_score": 0.00413, "epss_percentile": 0.61003}, "CVE-2022-24712": {"epss_score": 0.00131, "epss_percentile": 0.33483}, "CVE-2022-24713": {"epss_score": 0.06541, "epss_percentile": 0.90835}, "CVE-2022-24714": {"epss_score": 0.00334, "epss_percentile": 0.55737}, "CVE-2022-24715": {"epss_score": 0.72512, "epss_percentile": 0.98714}, "CVE-2022-24716": {"epss_score": 0.93378, "epss_percentile": 0.99801}, "CVE-2022-24717": {"epss_score": 0.00308, "epss_percentile": 0.53636}, "CVE-2022-24718": {"epss_score": 0.00582, "epss_percentile": 0.68288}, "CVE-2022-24719": {"epss_score": 0.00248, "epss_percentile": 0.47973}, "CVE-2022-24720": {"epss_score": 0.00877, "epss_percentile": 0.74814}, "CVE-2022-24721": {"epss_score": 0.00177, "epss_percentile": 0.39624}, "CVE-2022-24722": {"epss_score": 0.00359, "epss_percentile": 0.57608}, "CVE-2022-24723": {"epss_score": 0.00464, "epss_percentile": 0.63737}, "CVE-2022-24724": {"epss_score": 0.04189, "epss_percentile": 0.8837}, "CVE-2022-24725": {"epss_score": 0.00296, "epss_percentile": 0.52601}, "CVE-2022-24726": {"epss_score": 0.0041, "epss_percentile": 0.60816}, "CVE-2022-24728": {"epss_score": 0.00718, "epss_percentile": 0.71932}, "CVE-2022-24729": {"epss_score": 0.00632, "epss_percentile": 0.69748}, "CVE-2022-24730": {"epss_score": 0.0028, "epss_percentile": 0.51}, "CVE-2022-24731": {"epss_score": 0.0029, "epss_percentile": 0.52106}, "CVE-2022-24732": {"epss_score": 0.00133, "epss_percentile": 0.33652}, "CVE-2022-24733": {"epss_score": 0.00285, "epss_percentile": 0.51683}, "CVE-2022-24734": {"epss_score": 0.80336, "epss_percentile": 0.99082}, "CVE-2022-24735": {"epss_score": 0.0168, "epss_percentile": 0.81726}, "CVE-2022-24736": {"epss_score": 0.01725, "epss_percentile": 0.81957}, "CVE-2022-24737": {"epss_score": 0.006, "epss_percentile": 0.68833}, "CVE-2022-24738": {"epss_score": 0.00271, "epss_percentile": 0.50319}, "CVE-2022-24739": {"epss_score": 0.00247, "epss_percentile": 0.4787}, "CVE-2022-24740": {"epss_score": 0.00258, "epss_percentile": 0.49019}, "CVE-2022-24741": {"epss_score": 0.00763, "epss_percentile": 0.72855}, "CVE-2022-24742": {"epss_score": 0.00353, "epss_percentile": 0.5715}, "CVE-2022-24743": {"epss_score": 0.00217, "epss_percentile": 0.44289}, "CVE-2022-24744": {"epss_score": 0.00159, "epss_percentile": 0.37406}, "CVE-2022-24745": {"epss_score": 0.00186, "epss_percentile": 0.40659}, "CVE-2022-24746": {"epss_score": 0.0066, "epss_percentile": 0.70524}, "CVE-2022-24747": {"epss_score": 0.00328, "epss_percentile": 0.55165}, "CVE-2022-24748": {"epss_score": 0.00222, "epss_percentile": 0.448}, "CVE-2022-24749": {"epss_score": 0.00308, "epss_percentile": 0.53636}, "CVE-2022-24750": {"epss_score": 0.00093, "epss_percentile": 0.26753}, "CVE-2022-24751": {"epss_score": 0.00204, "epss_percentile": 0.42616}, "CVE-2022-24752": {"epss_score": 0.00558, "epss_percentile": 0.67595}, "CVE-2022-24753": {"epss_score": 0.00136, "epss_percentile": 0.34166}, "CVE-2022-24754": {"epss_score": 0.00286, "epss_percentile": 0.51699}, "CVE-2022-24755": {"epss_score": 0.00475, "epss_percentile": 0.64194}, "CVE-2022-24756": {"epss_score": 0.008, "epss_percentile": 0.73533}, "CVE-2022-24757": {"epss_score": 0.00316, "epss_percentile": 0.54231}, "CVE-2022-24758": {"epss_score": 0.00326, "epss_percentile": 0.55068}, "CVE-2022-24759": {"epss_score": 0.00116, "epss_percentile": 0.31169}, "CVE-2022-24760": {"epss_score": 0.62687, "epss_percentile": 0.98302}, "CVE-2022-24761": {"epss_score": 0.00258, "epss_percentile": 0.48957}, "CVE-2022-24762": {"epss_score": 0.00197, "epss_percentile": 0.41951}, "CVE-2022-24763": {"epss_score": 0.00865, "epss_percentile": 0.74627}, "CVE-2022-24764": {"epss_score": 0.0058, "epss_percentile": 0.68238}, "CVE-2022-24765": {"epss_score": 0.00176, "epss_percentile": 0.39408}, "CVE-2022-24766": {"epss_score": 0.00789, "epss_percentile": 0.73355}, "CVE-2022-24767": {"epss_score": 0.01198, "epss_percentile": 0.78453}, "CVE-2022-24768": {"epss_score": 0.00396, "epss_percentile": 0.59888}, "CVE-2022-24769": {"epss_score": 0.00086, "epss_percentile": 0.25409}, "CVE-2022-24770": {"epss_score": 0.00591, "epss_percentile": 0.68598}, "CVE-2022-24771": {"epss_score": 0.00116, "epss_percentile": 0.31135}, "CVE-2022-24772": {"epss_score": 0.00128, "epss_percentile": 0.32989}, "CVE-2022-24773": {"epss_score": 0.00101, "epss_percentile": 0.28622}, "CVE-2022-24774": {"epss_score": 0.00487, "epss_percentile": 0.64827}, "CVE-2022-24775": {"epss_score": 0.00725, "epss_percentile": 0.72044}, "CVE-2022-24776": {"epss_score": 0.00347, "epss_percentile": 0.56735}, "CVE-2022-24777": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2022-24778": {"epss_score": 0.00333, "epss_percentile": 0.55666}, "CVE-2022-24780": {"epss_score": 0.13446, "epss_percentile": 0.93966}, "CVE-2022-24781": {"epss_score": 0.0022, "epss_percentile": 0.4459}, "CVE-2022-24782": {"epss_score": 0.0039, "epss_percentile": 0.59556}, "CVE-2022-24783": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2022-24784": {"epss_score": 0.00268, "epss_percentile": 0.50022}, "CVE-2022-24785": {"epss_score": 0.00829, "epss_percentile": 0.74016}, "CVE-2022-24786": {"epss_score": 0.00743, "epss_percentile": 0.72463}, "CVE-2022-24787": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2022-24788": {"epss_score": 0.00329, "epss_percentile": 0.55306}, "CVE-2022-24789": {"epss_score": 0.00203, "epss_percentile": 0.42505}, "CVE-2022-24790": {"epss_score": 0.00359, "epss_percentile": 0.57605}, "CVE-2022-24791": {"epss_score": 0.00469, "epss_percentile": 0.63935}, "CVE-2022-24792": {"epss_score": 0.01621, "epss_percentile": 0.81392}, "CVE-2022-24793": {"epss_score": 0.00547, "epss_percentile": 0.6726}, "CVE-2022-24794": {"epss_score": 0.00245, "epss_percentile": 0.47659}, "CVE-2022-24795": {"epss_score": 0.01362, "epss_percentile": 0.79761}, "CVE-2022-24796": {"epss_score": 0.06441, "epss_percentile": 0.90759}, "CVE-2022-24797": {"epss_score": 0.0047, "epss_percentile": 0.63981}, "CVE-2022-24798": {"epss_score": 0.00385, "epss_percentile": 0.59228}, "CVE-2022-24799": {"epss_score": 0.00587, "epss_percentile": 0.68466}, "CVE-2022-24800": {"epss_score": 0.02925, "epss_percentile": 0.86004}, "CVE-2022-24801": {"epss_score": 0.01148, "epss_percentile": 0.78013}, "CVE-2022-24802": {"epss_score": 0.00678, "epss_percentile": 0.70973}, "CVE-2022-24803": {"epss_score": 0.01383, "epss_percentile": 0.79895}, "CVE-2022-24804": {"epss_score": 0.00193, "epss_percentile": 0.41491}, "CVE-2022-24805": {"epss_score": 0.00483, "epss_percentile": 0.64616}, "CVE-2022-24806": {"epss_score": 0.00135, "epss_percentile": 0.33981}, "CVE-2022-24807": {"epss_score": 0.00501, "epss_percentile": 0.65331}, "CVE-2022-24808": {"epss_score": 0.00195, "epss_percentile": 0.41678}, "CVE-2022-24809": {"epss_score": 0.00135, "epss_percentile": 0.3403}, "CVE-2022-24810": {"epss_score": 0.00164, "epss_percentile": 0.37899}, "CVE-2022-24811": {"epss_score": 0.00309, "epss_percentile": 0.53703}, "CVE-2022-24812": {"epss_score": 0.00259, "epss_percentile": 0.49093}, "CVE-2022-24813": {"epss_score": 0.00234, "epss_percentile": 0.46113}, "CVE-2022-24814": {"epss_score": 0.0043, "epss_percentile": 0.62006}, "CVE-2022-24815": {"epss_score": 0.00439, "epss_percentile": 0.62608}, "CVE-2022-24816": {"epss_score": 0.9402, "epss_percentile": 0.99887}, "CVE-2022-24817": {"epss_score": 0.00378, "epss_percentile": 0.58832}, "CVE-2022-24818": {"epss_score": 0.08237, "epss_percentile": 0.91945}, "CVE-2022-24819": {"epss_score": 0.04178, "epss_percentile": 0.88354}, "CVE-2022-24820": {"epss_score": 0.00119, "epss_percentile": 0.3159}, "CVE-2022-24821": {"epss_score": 0.00699, "epss_percentile": 0.71442}, "CVE-2022-24822": {"epss_score": 0.00834, "epss_percentile": 0.74098}, "CVE-2022-24823": {"epss_score": 0.00401, "epss_percentile": 0.60254}, "CVE-2022-24824": {"epss_score": 0.00379, "epss_percentile": 0.58888}, "CVE-2022-24825": {"epss_score": 0.00206, "epss_percentile": 0.42787}, "CVE-2022-24826": {"epss_score": 0.00264, "epss_percentile": 0.49718}, "CVE-2022-24827": {"epss_score": 0.00378, "epss_percentile": 0.58814}, "CVE-2022-24828": {"epss_score": 0.00268, "epss_percentile": 0.50073}, "CVE-2022-24829": {"epss_score": 0.00267, "epss_percentile": 0.50002}, "CVE-2022-24830": {"epss_score": 0.0191, "epss_percentile": 0.82823}, "CVE-2022-24831": {"epss_score": 0.00257, "epss_percentile": 0.48862}, "CVE-2022-24832": {"epss_score": 0.01442, "epss_percentile": 0.80306}, "CVE-2022-24833": {"epss_score": 0.00469, "epss_percentile": 0.63948}, "CVE-2022-24834": {"epss_score": 0.37948, "epss_percentile": 0.97077}, "CVE-2022-24836": {"epss_score": 0.01454, "epss_percentile": 0.80378}, "CVE-2022-24837": {"epss_score": 0.00314, "epss_percentile": 0.5415}, "CVE-2022-24838": {"epss_score": 0.08781, "epss_percentile": 0.92252}, "CVE-2022-24839": {"epss_score": 0.00454, "epss_percentile": 0.63241}, "CVE-2022-24840": {"epss_score": 0.00908, "epss_percentile": 0.75287}, "CVE-2022-24841": {"epss_score": 0.00211, "epss_percentile": 0.43711}, "CVE-2022-24842": {"epss_score": 0.00169, "epss_percentile": 0.38536}, "CVE-2022-24843": {"epss_score": 0.00658, "epss_percentile": 0.70485}, "CVE-2022-24844": {"epss_score": 0.00359, "epss_percentile": 0.57544}, "CVE-2022-24845": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2022-24846": {"epss_score": 0.00551, "epss_percentile": 0.6736}, "CVE-2022-24847": {"epss_score": 0.00291, "epss_percentile": 0.52205}, "CVE-2022-24848": {"epss_score": 0.00463, "epss_percentile": 0.63688}, "CVE-2022-24849": {"epss_score": 0.00314, "epss_percentile": 0.54117}, "CVE-2022-24850": {"epss_score": 0.00187, "epss_percentile": 0.40792}, "CVE-2022-24851": {"epss_score": 0.00939, "epss_percentile": 0.75722}, "CVE-2022-24853": {"epss_score": 0.09729, "epss_percentile": 0.92679}, "CVE-2022-24854": {"epss_score": 0.00281, "epss_percentile": 0.51141}, "CVE-2022-24855": {"epss_score": 0.0042, "epss_percentile": 0.61445}, "CVE-2022-24856": {"epss_score": 0.86046, "epss_percentile": 0.99364}, "CVE-2022-24857": {"epss_score": 0.00506, "epss_percentile": 0.65646}, "CVE-2022-24858": {"epss_score": 0.00318, "epss_percentile": 0.54454}, "CVE-2022-24859": {"epss_score": 0.00127, "epss_percentile": 0.3283}, "CVE-2022-24860": {"epss_score": 0.00342, "epss_percentile": 0.56391}, "CVE-2022-24861": {"epss_score": 0.03062, "epss_percentile": 0.86319}, "CVE-2022-24862": {"epss_score": 0.00226, "epss_percentile": 0.45313}, "CVE-2022-24863": {"epss_score": 0.00569, "epss_percentile": 0.67914}, "CVE-2022-24864": {"epss_score": 0.00309, "epss_percentile": 0.53703}, "CVE-2022-24865": {"epss_score": 0.00342, "epss_percentile": 0.56362}, "CVE-2022-24866": {"epss_score": 0.00167, "epss_percentile": 0.38298}, "CVE-2022-24867": {"epss_score": 0.0036, "epss_percentile": 0.57679}, "CVE-2022-24868": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2022-24869": {"epss_score": 0.00311, "epss_percentile": 0.53819}, "CVE-2022-24870": {"epss_score": 0.00425, "epss_percentile": 0.6169}, "CVE-2022-24871": {"epss_score": 0.00348, "epss_percentile": 0.56811}, "CVE-2022-24872": {"epss_score": 0.00189, "epss_percentile": 0.40933}, "CVE-2022-24873": {"epss_score": 0.0066, "epss_percentile": 0.70524}, "CVE-2022-24875": {"epss_score": 0.00301, "epss_percentile": 0.53056}, "CVE-2022-24876": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-24877": {"epss_score": 0.00617, "epss_percentile": 0.69351}, "CVE-2022-24878": {"epss_score": 0.0031, "epss_percentile": 0.53789}, "CVE-2022-24879": {"epss_score": 0.00135, "epss_percentile": 0.34055}, "CVE-2022-24880": {"epss_score": 0.0025, "epss_percentile": 0.48254}, "CVE-2022-24881": {"epss_score": 0.04696, "epss_percentile": 0.89019}, "CVE-2022-24882": {"epss_score": 0.01114, "epss_percentile": 0.77703}, "CVE-2022-24883": {"epss_score": 0.00816, "epss_percentile": 0.73797}, "CVE-2022-24884": {"epss_score": 0.00124, "epss_percentile": 0.32348}, "CVE-2022-24885": {"epss_score": 0.00094, "epss_percentile": 0.26804}, "CVE-2022-24886": {"epss_score": 0.00078, "epss_percentile": 0.23618}, "CVE-2022-24887": {"epss_score": 0.00231, "epss_percentile": 0.45839}, "CVE-2022-24888": {"epss_score": 0.00382, "epss_percentile": 0.59055}, "CVE-2022-24889": {"epss_score": 0.0016, "epss_percentile": 0.37502}, "CVE-2022-24890": {"epss_score": 0.00249, "epss_percentile": 0.48005}, "CVE-2022-24891": {"epss_score": 0.01043, "epss_percentile": 0.76995}, "CVE-2022-24892": {"epss_score": 0.00285, "epss_percentile": 0.51551}, "CVE-2022-24893": {"epss_score": 0.00109, "epss_percentile": 0.29904}, "CVE-2022-24894": {"epss_score": 0.00122, "epss_percentile": 0.32062}, "CVE-2022-24895": {"epss_score": 0.00019, "epss_percentile": 0.04158}, "CVE-2022-24896": {"epss_score": 0.00157, "epss_percentile": 0.37122}, "CVE-2022-24897": {"epss_score": 0.00408, "epss_percentile": 0.60636}, "CVE-2022-24898": {"epss_score": 0.00127, "epss_percentile": 0.32932}, "CVE-2022-24899": {"epss_score": 0.59505, "epss_percentile": 0.98167}, "CVE-2022-24900": {"epss_score": 0.89168, "epss_percentile": 0.99512}, "CVE-2022-24901": {"epss_score": 0.0015, "epss_percentile": 0.36067}, "CVE-2022-24902": {"epss_score": 0.00149, "epss_percentile": 0.36043}, "CVE-2022-24903": {"epss_score": 0.01074, "epss_percentile": 0.77295}, "CVE-2022-24904": {"epss_score": 0.00327, "epss_percentile": 0.55112}, "CVE-2022-24905": {"epss_score": 0.00264, "epss_percentile": 0.49733}, "CVE-2022-24906": {"epss_score": 0.00288, "epss_percentile": 0.51878}, "CVE-2022-24907": {"epss_score": 0.01165, "epss_percentile": 0.78172}, "CVE-2022-24908": {"epss_score": 0.01165, "epss_percentile": 0.78172}, "CVE-2022-24910": {"epss_score": 0.03127, "epss_percentile": 0.86458}, "CVE-2022-24912": {"epss_score": 0.0021, "epss_percentile": 0.43472}, "CVE-2022-24913": {"epss_score": 0.00029, "epss_percentile": 0.07794}, "CVE-2022-24915": {"epss_score": 0.00333, "epss_percentile": 0.55666}, "CVE-2022-24916": {"epss_score": 0.00419, "epss_percentile": 0.61363}, "CVE-2022-24917": {"epss_score": 0.00369, "epss_percentile": 0.58236}, "CVE-2022-24918": {"epss_score": 0.01185, "epss_percentile": 0.78336}, "CVE-2022-24919": {"epss_score": 0.00369, "epss_percentile": 0.58236}, "CVE-2022-24921": {"epss_score": 0.00018, "epss_percentile": 0.0384}, "CVE-2022-24923": {"epss_score": 0.00062, "epss_percentile": 0.19622}, "CVE-2022-24924": {"epss_score": 0.03843, "epss_percentile": 0.87836}, "CVE-2022-24925": {"epss_score": 0.00048, "epss_percentile": 0.15274}, "CVE-2022-24926": {"epss_score": 0.00481, "epss_percentile": 0.6449}, "CVE-2022-24927": {"epss_score": 0.00145, "epss_percentile": 0.35393}, "CVE-2022-24928": {"epss_score": 0.00013, "epss_percentile": 0.01604}, "CVE-2022-24929": {"epss_score": 0.00018, "epss_percentile": 0.03897}, "CVE-2022-24930": {"epss_score": 0.00179, "epss_percentile": 0.39795}, "CVE-2022-24931": {"epss_score": 0.00015, "epss_percentile": 0.02508}, "CVE-2022-24932": {"epss_score": 0.00022, "epss_percentile": 0.05288}, "CVE-2022-24934": {"epss_score": 0.56205, "epss_percentile": 0.98012}, "CVE-2022-24935": {"epss_score": 0.00261, "epss_percentile": 0.49281}, "CVE-2022-24936": {"epss_score": 0.00446, "epss_percentile": 0.62928}, "CVE-2022-24937": {"epss_score": 0.00607, "epss_percentile": 0.69039}, "CVE-2022-24938": {"epss_score": 0.00505, "epss_percentile": 0.65609}, "CVE-2022-24939": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-24942": {"epss_score": 0.08215, "epss_percentile": 0.91933}, "CVE-2022-24946": {"epss_score": 0.00444, "epss_percentile": 0.62834}, "CVE-2022-24947": {"epss_score": 0.02134, "epss_percentile": 0.83724}, "CVE-2022-24948": {"epss_score": 0.07132, "epss_percentile": 0.91271}, "CVE-2022-24949": {"epss_score": 0.00377, "epss_percentile": 0.587}, "CVE-2022-24950": {"epss_score": 0.00549, "epss_percentile": 0.6732}, "CVE-2022-24951": {"epss_score": 0.00126, "epss_percentile": 0.32758}, "CVE-2022-24952": {"epss_score": 0.00478, "epss_percentile": 0.64394}, "CVE-2022-24953": {"epss_score": 0.0039, "epss_percentile": 0.59505}, "CVE-2022-24954": {"epss_score": 0.00897, "epss_percentile": 0.75135}, "CVE-2022-24955": {"epss_score": 0.00694, "epss_percentile": 0.71361}, "CVE-2022-24956": {"epss_score": 0.00239, "epss_percentile": 0.46914}, "CVE-2022-24957": {"epss_score": 0.002, "epss_percentile": 0.42199}, "CVE-2022-24958": {"epss_score": 0.00047, "epss_percentile": 0.14629}, "CVE-2022-24959": {"epss_score": 0.00055, "epss_percentile": 0.17536}, "CVE-2022-24960": {"epss_score": 0.00246, "epss_percentile": 0.47732}, "CVE-2022-24961": {"epss_score": 0.00752, "epss_percentile": 0.72666}, "CVE-2022-24963": {"epss_score": 0.00119, "epss_percentile": 0.31555}, "CVE-2022-24967": {"epss_score": 0.00267, "epss_percentile": 0.50018}, "CVE-2022-24968": {"epss_score": 0.00182, "epss_percentile": 0.40249}, "CVE-2022-24969": {"epss_score": 0.02387, "epss_percentile": 0.84584}, "CVE-2022-24971": {"epss_score": 0.01013, "epss_percentile": 0.76633}, "CVE-2022-24972": {"epss_score": 0.00046, "epss_percentile": 0.14108}, "CVE-2022-24973": {"epss_score": 0.00028, "epss_percentile": 0.07334}, "CVE-2022-24974": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2022-24975": {"epss_score": 0.00956, "epss_percentile": 0.75925}, "CVE-2022-24976": {"epss_score": 0.00128, "epss_percentile": 0.33072}, "CVE-2022-24977": {"epss_score": 0.28066, "epss_percentile": 0.96305}, "CVE-2022-24978": {"epss_score": 0.00231, "epss_percentile": 0.45809}, "CVE-2022-24979": {"epss_score": 0.00226, "epss_percentile": 0.45287}, "CVE-2022-24980": {"epss_score": 0.00857, "epss_percentile": 0.74491}, "CVE-2022-24981": {"epss_score": 0.00445, "epss_percentile": 0.6286}, "CVE-2022-24982": {"epss_score": 0.00257, "epss_percentile": 0.48922}, "CVE-2022-24983": {"epss_score": 0.02178, "epss_percentile": 0.8389}, "CVE-2022-24984": {"epss_score": 0.02427, "epss_percentile": 0.84719}, "CVE-2022-24985": {"epss_score": 0.00952, "epss_percentile": 0.75882}, "CVE-2022-24986": {"epss_score": 0.00088, "epss_percentile": 0.25641}, "CVE-2022-24988": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2022-24989": {"epss_score": 0.82108, "epss_percentile": 0.99174}, "CVE-2022-24990": {"epss_score": 0.94284, "epss_percentile": 0.99934}, "CVE-2022-24992": {"epss_score": 0.02267, "epss_percentile": 0.842}, "CVE-2022-24995": {"epss_score": 0.00651, "epss_percentile": 0.70288}, "CVE-2022-24999": {"epss_score": 0.03245, "epss_percentile": 0.86742}, "CVE-2022-25003": {"epss_score": 0.00465, "epss_percentile": 0.63774}, "CVE-2022-25004": {"epss_score": 0.00375, "epss_percentile": 0.58611}, "CVE-2022-25008": {"epss_score": 0.00168, "epss_percentile": 0.38469}, "CVE-2022-25010": {"epss_score": 0.00257, "epss_percentile": 0.48877}, "CVE-2022-25012": {"epss_score": 0.00798, "epss_percentile": 0.73506}, "CVE-2022-25013": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-25014": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-25015": {"epss_score": 0.00207, "epss_percentile": 0.43156}, "CVE-2022-25016": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2022-25017": {"epss_score": 0.02828, "epss_percentile": 0.8577}, "CVE-2022-25018": {"epss_score": 0.06556, "epss_percentile": 0.90846}, "CVE-2022-25020": {"epss_score": 0.0099, "epss_percentile": 0.7638}, "CVE-2022-25022": {"epss_score": 0.00683, "epss_percentile": 0.71101}, "CVE-2022-25023": {"epss_score": 0.00387, "epss_percentile": 0.59328}, "CVE-2022-25024": {"epss_score": 0.00107, "epss_percentile": 0.29723}, "CVE-2022-25026": {"epss_score": 0.05994, "epss_percentile": 0.9039}, "CVE-2022-25027": {"epss_score": 0.00167, "epss_percentile": 0.38391}, "CVE-2022-25028": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-25031": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2022-25037": {"epss_score": 0.00327, "epss_percentile": 0.55128}, "CVE-2022-25038": {"epss_score": 0.00476, "epss_percentile": 0.64261}, "CVE-2022-25041": {"epss_score": 0.00369, "epss_percentile": 0.58224}, "CVE-2022-25044": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2022-25045": {"epss_score": 0.00316, "epss_percentile": 0.54221}, "CVE-2022-25046": {"epss_score": 0.04121, "epss_percentile": 0.88283}, "CVE-2022-25047": {"epss_score": 0.00346, "epss_percentile": 0.5664}, "CVE-2022-25048": {"epss_score": 0.16197, "epss_percentile": 0.94591}, "CVE-2022-25050": {"epss_score": 0.00404, "epss_percentile": 0.60449}, "CVE-2022-25051": {"epss_score": 0.00349, "epss_percentile": 0.56911}, "CVE-2022-25060": {"epss_score": 0.74656, "epss_percentile": 0.98811}, "CVE-2022-25061": {"epss_score": 0.86026, "epss_percentile": 0.99363}, "CVE-2022-25062": {"epss_score": 0.28956, "epss_percentile": 0.96404}, "CVE-2022-25064": {"epss_score": 0.63105, "epss_percentile": 0.98321}, "CVE-2022-25069": {"epss_score": 0.01335, "epss_percentile": 0.79549}, "CVE-2022-25072": {"epss_score": 0.05224, "epss_percentile": 0.8963}, "CVE-2022-25073": {"epss_score": 0.05224, "epss_percentile": 0.8963}, "CVE-2022-25074": {"epss_score": 0.05224, "epss_percentile": 0.8963}, "CVE-2022-25075": {"epss_score": 0.38952, "epss_percentile": 0.97129}, "CVE-2022-25076": {"epss_score": 0.05664, "epss_percentile": 0.90101}, "CVE-2022-25077": {"epss_score": 0.51028, "epss_percentile": 0.97759}, "CVE-2022-25078": {"epss_score": 0.05664, "epss_percentile": 0.90101}, "CVE-2022-25079": {"epss_score": 0.05664, "epss_percentile": 0.90101}, "CVE-2022-25080": {"epss_score": 0.05664, "epss_percentile": 0.90101}, "CVE-2022-25081": {"epss_score": 0.05664, "epss_percentile": 0.90101}, "CVE-2022-25082": {"epss_score": 0.89173, "epss_percentile": 0.99513}, "CVE-2022-25083": {"epss_score": 0.05664, "epss_percentile": 0.90101}, "CVE-2022-25084": {"epss_score": 0.84255, "epss_percentile": 0.99281}, "CVE-2022-25089": {"epss_score": 0.4043, "epss_percentile": 0.97218}, "CVE-2022-25090": {"epss_score": 0.11077, "epss_percentile": 0.93211}, "CVE-2022-25091": {"epss_score": 0.00123, "epss_percentile": 0.3227}, "CVE-2022-25094": {"epss_score": 0.03363, "epss_percentile": 0.86997}, "CVE-2022-25095": {"epss_score": 0.01782, "epss_percentile": 0.82245}, "CVE-2022-25096": {"epss_score": 0.00375, "epss_percentile": 0.58611}, "CVE-2022-25098": {"epss_score": 0.00447, "epss_percentile": 0.62985}, "CVE-2022-25099": {"epss_score": 0.00492, "epss_percentile": 0.65016}, "CVE-2022-25101": {"epss_score": 0.00492, "epss_percentile": 0.65016}, "CVE-2022-25104": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2022-25106": {"epss_score": 0.00137, "epss_percentile": 0.34223}, "CVE-2022-25108": {"epss_score": 0.00164, "epss_percentile": 0.3795}, "CVE-2022-25114": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2022-25115": {"epss_score": 0.01713, "epss_percentile": 0.81888}, "CVE-2022-25125": {"epss_score": 0.87806, "epss_percentile": 0.99445}, "CVE-2022-25130": {"epss_score": 0.0446, "epss_percentile": 0.88723}, "CVE-2022-25131": {"epss_score": 0.0446, "epss_percentile": 0.88723}, "CVE-2022-25132": {"epss_score": 0.0446, "epss_percentile": 0.88723}, "CVE-2022-25133": {"epss_score": 0.0446, "epss_percentile": 0.88723}, "CVE-2022-25134": {"epss_score": 0.0446, "epss_percentile": 0.88723}, "CVE-2022-25135": {"epss_score": 0.0446, "epss_percentile": 0.88723}, "CVE-2022-25136": {"epss_score": 0.0446, "epss_percentile": 0.88723}, "CVE-2022-25137": {"epss_score": 0.0446, "epss_percentile": 0.88723}, "CVE-2022-25138": {"epss_score": 0.00589, "epss_percentile": 0.6852}, "CVE-2022-25139": {"epss_score": 0.00506, "epss_percentile": 0.65636}, "CVE-2022-25146": {"epss_score": 0.0014, "epss_percentile": 0.34685}, "CVE-2022-25147": {"epss_score": 0.00048, "epss_percentile": 0.15161}, "CVE-2022-25148": {"epss_score": 0.48461, "epss_percentile": 0.97639}, "CVE-2022-25149": {"epss_score": 0.73381, "epss_percentile": 0.9875}, "CVE-2022-25150": {"epss_score": 0.00299, "epss_percentile": 0.52858}, "CVE-2022-25151": {"epss_score": 0.00286, "epss_percentile": 0.5175}, "CVE-2022-25152": {"epss_score": 0.00449, "epss_percentile": 0.63059}, "CVE-2022-25153": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2022-25154": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2022-25155": {"epss_score": 0.00688, "epss_percentile": 0.71206}, "CVE-2022-25156": {"epss_score": 0.00388, "epss_percentile": 0.59353}, "CVE-2022-25157": {"epss_score": 0.00739, "epss_percentile": 0.72391}, "CVE-2022-25158": {"epss_score": 0.00323, "epss_percentile": 0.54886}, "CVE-2022-25159": {"epss_score": 0.00627, "epss_percentile": 0.69634}, "CVE-2022-25160": {"epss_score": 0.00352, "epss_percentile": 0.57104}, "CVE-2022-25161": {"epss_score": 0.00155, "epss_percentile": 0.3683}, "CVE-2022-25162": {"epss_score": 0.00052, "epss_percentile": 0.16361}, "CVE-2022-25163": {"epss_score": 0.0073, "epss_percentile": 0.7216}, "CVE-2022-25164": {"epss_score": 0.00728, "epss_percentile": 0.72113}, "CVE-2022-25165": {"epss_score": 0.00973, "epss_percentile": 0.76162}, "CVE-2022-25166": {"epss_score": 0.0114, "epss_percentile": 0.77952}, "CVE-2022-25167": {"epss_score": 0.11555, "epss_percentile": 0.93403}, "CVE-2022-25168": {"epss_score": 0.02669, "epss_percentile": 0.85383}, "CVE-2022-25169": {"epss_score": 0.00231, "epss_percentile": 0.45778}, "CVE-2022-25170": {"epss_score": 0.00513, "epss_percentile": 0.65898}, "CVE-2022-25171": {"epss_score": 0.01909, "epss_percentile": 0.82822}, "CVE-2022-25172": {"epss_score": 0.00312, "epss_percentile": 0.53936}, "CVE-2022-25173": {"epss_score": 0.01176, "epss_percentile": 0.78274}, "CVE-2022-25174": {"epss_score": 0.01397, "epss_percentile": 0.79983}, "CVE-2022-25175": {"epss_score": 0.02642, "epss_percentile": 0.8531}, "CVE-2022-25176": {"epss_score": 0.0064, "epss_percentile": 0.69957}, "CVE-2022-25177": {"epss_score": 0.0064, "epss_percentile": 0.69957}, "CVE-2022-25178": {"epss_score": 0.00295, "epss_percentile": 0.52453}, "CVE-2022-25179": {"epss_score": 0.01564, "epss_percentile": 0.81059}, "CVE-2022-25180": {"epss_score": 0.00205, "epss_percentile": 0.42714}, "CVE-2022-25181": {"epss_score": 0.0047, "epss_percentile": 0.63965}, "CVE-2022-25182": {"epss_score": 0.0047, "epss_percentile": 0.63965}, "CVE-2022-25183": {"epss_score": 0.00637, "epss_percentile": 0.69897}, "CVE-2022-25184": {"epss_score": 0.00409, "epss_percentile": 0.60703}, "CVE-2022-25185": {"epss_score": 0.08775, "epss_percentile": 0.9225}, "CVE-2022-25186": {"epss_score": 0.00338, "epss_percentile": 0.56142}, "CVE-2022-25187": {"epss_score": 0.00338, "epss_percentile": 0.56142}, "CVE-2022-25188": {"epss_score": 0.00561, "epss_percentile": 0.67676}, "CVE-2022-25189": {"epss_score": 0.03078, "epss_percentile": 0.86365}, "CVE-2022-25190": {"epss_score": 0.00146, "epss_percentile": 0.35643}, "CVE-2022-25191": {"epss_score": 0.03078, "epss_percentile": 0.86365}, "CVE-2022-25192": {"epss_score": 0.00052, "epss_percentile": 0.16615}, "CVE-2022-25193": {"epss_score": 0.00104, "epss_percentile": 0.29203}, "CVE-2022-25194": {"epss_score": 0.00052, "epss_percentile": 0.16616}, "CVE-2022-25195": {"epss_score": 0.0016, "epss_percentile": 0.37437}, "CVE-2022-25196": {"epss_score": 0.00081, "epss_percentile": 0.24273}, "CVE-2022-25197": {"epss_score": 0.00338, "epss_percentile": 0.56142}, "CVE-2022-25198": {"epss_score": 0.00052, "epss_percentile": 0.16616}, "CVE-2022-25199": {"epss_score": 0.00356, "epss_percentile": 0.57336}, "CVE-2022-25200": {"epss_score": 0.00058, "epss_percentile": 0.18527}, "CVE-2022-25201": {"epss_score": 0.00077, "epss_percentile": 0.23355}, "CVE-2022-25202": {"epss_score": 0.01881, "epss_percentile": 0.82692}, "CVE-2022-25203": {"epss_score": 0.16751, "epss_percentile": 0.94727}, "CVE-2022-25204": {"epss_score": 0.00336, "epss_percentile": 0.55946}, "CVE-2022-25205": {"epss_score": 0.00052, "epss_percentile": 0.16616}, "CVE-2022-25206": {"epss_score": 0.00356, "epss_percentile": 0.57336}, "CVE-2022-25207": {"epss_score": 0.00071, "epss_percentile": 0.22111}, "CVE-2022-25208": {"epss_score": 0.00534, "epss_percentile": 0.66799}, "CVE-2022-25209": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2022-25210": {"epss_score": 0.00338, "epss_percentile": 0.56142}, "CVE-2022-25211": {"epss_score": 0.00267, "epss_percentile": 0.49957}, "CVE-2022-25212": {"epss_score": 0.00071, "epss_percentile": 0.22111}, "CVE-2022-25213": {"epss_score": 0.00041, "epss_percentile": 0.12344}, "CVE-2022-25214": {"epss_score": 0.01248, "epss_percentile": 0.78868}, "CVE-2022-25215": {"epss_score": 0.00386, "epss_percentile": 0.59272}, "CVE-2022-25216": {"epss_score": 0.82777, "epss_percentile": 0.99215}, "CVE-2022-25217": {"epss_score": 0.00037, "epss_percentile": 0.10985}, "CVE-2022-25218": {"epss_score": 0.01158, "epss_percentile": 0.78121}, "CVE-2022-25219": {"epss_score": 0.00112, "epss_percentile": 0.3042}, "CVE-2022-25220": {"epss_score": 0.00305, "epss_percentile": 0.5333}, "CVE-2022-25221": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-25222": {"epss_score": 0.02726, "epss_percentile": 0.85527}, "CVE-2022-25223": {"epss_score": 0.00232, "epss_percentile": 0.45875}, "CVE-2022-25224": {"epss_score": 0.00337, "epss_percentile": 0.56066}, "CVE-2022-25225": {"epss_score": 0.04433, "epss_percentile": 0.88682}, "CVE-2022-25226": {"epss_score": 0.77082, "epss_percentile": 0.9892}, "CVE-2022-25227": {"epss_score": 0.00206, "epss_percentile": 0.42937}, "CVE-2022-25228": {"epss_score": 0.00563, "epss_percentile": 0.67729}, "CVE-2022-25229": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-25230": {"epss_score": 0.00511, "epss_percentile": 0.65825}, "CVE-2022-25231": {"epss_score": 0.00541, "epss_percentile": 0.67058}, "CVE-2022-25234": {"epss_score": 0.00376, "epss_percentile": 0.58652}, "CVE-2022-25235": {"epss_score": 0.13322, "epss_percentile": 0.93932}, "CVE-2022-25236": {"epss_score": 0.09358, "epss_percentile": 0.92515}, "CVE-2022-25237": {"epss_score": 0.92632, "epss_percentile": 0.99731}, "CVE-2022-25238": {"epss_score": 0.00338, "epss_percentile": 0.56154}, "CVE-2022-25241": {"epss_score": 0.00902, "epss_percentile": 0.75196}, "CVE-2022-25242": {"epss_score": 0.00142, "epss_percentile": 0.34977}, "CVE-2022-25243": {"epss_score": 0.00247, "epss_percentile": 0.47821}, "CVE-2022-25244": {"epss_score": 0.00281, "epss_percentile": 0.51185}, "CVE-2022-25245": {"epss_score": 0.02575, "epss_percentile": 0.8514}, "CVE-2022-25246": {"epss_score": 0.01905, "epss_percentile": 0.82796}, "CVE-2022-25247": {"epss_score": 0.02258, "epss_percentile": 0.84177}, "CVE-2022-25248": {"epss_score": 0.00176, "epss_percentile": 0.39427}, "CVE-2022-25249": {"epss_score": 0.01755, "epss_percentile": 0.82122}, "CVE-2022-25250": {"epss_score": 0.00637, "epss_percentile": 0.69893}, "CVE-2022-25251": {"epss_score": 0.00825, "epss_percentile": 0.73949}, "CVE-2022-25252": {"epss_score": 0.00632, "epss_percentile": 0.69752}, "CVE-2022-25255": {"epss_score": 0.00066, "epss_percentile": 0.20732}, "CVE-2022-25256": {"epss_score": 0.00747, "epss_percentile": 0.72564}, "CVE-2022-25258": {"epss_score": 0.00187, "epss_percentile": 0.40755}, "CVE-2022-25259": {"epss_score": 8e-05, "epss_percentile": 0.00555}, "CVE-2022-25260": {"epss_score": 0.00051, "epss_percentile": 0.16121}, "CVE-2022-25261": {"epss_score": 0.00011, "epss_percentile": 0.01018}, "CVE-2022-25262": {"epss_score": 0.00018, "epss_percentile": 0.03716}, "CVE-2022-25263": {"epss_score": 0.00018, "epss_percentile": 0.03872}, "CVE-2022-25264": {"epss_score": 3e-05, "epss_percentile": 0.00088}, "CVE-2022-25265": {"epss_score": 0.00272, "epss_percentile": 0.5036}, "CVE-2022-25266": {"epss_score": 0.00143, "epss_percentile": 0.35174}, "CVE-2022-25267": {"epss_score": 0.00829, "epss_percentile": 0.74012}, "CVE-2022-25268": {"epss_score": 0.00142, "epss_percentile": 0.34977}, "CVE-2022-25269": {"epss_score": 0.00452, "epss_percentile": 0.6316}, "CVE-2022-25270": {"epss_score": 0.00254, "epss_percentile": 0.48622}, "CVE-2022-25271": {"epss_score": 0.00355, "epss_percentile": 0.57288}, "CVE-2022-25273": {"epss_score": 0.00232, "epss_percentile": 0.45894}, "CVE-2022-25274": {"epss_score": 0.00195, "epss_percentile": 0.41682}, "CVE-2022-25275": {"epss_score": 0.00308, "epss_percentile": 0.536}, "CVE-2022-25276": {"epss_score": 0.01243, "epss_percentile": 0.78831}, "CVE-2022-25277": {"epss_score": 0.00276, "epss_percentile": 0.50711}, "CVE-2022-25278": {"epss_score": 0.00375, "epss_percentile": 0.58601}, "CVE-2022-25290": {"epss_score": 0.00141, "epss_percentile": 0.3494}, "CVE-2022-25291": {"epss_score": 0.01923, "epss_percentile": 0.82913}, "CVE-2022-25292": {"epss_score": 0.04134, "epss_percentile": 0.88305}, "CVE-2022-25293": {"epss_score": 0.05945, "epss_percentile": 0.90353}, "CVE-2022-25294": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2022-25295": {"epss_score": 0.00202, "epss_percentile": 0.42476}, "CVE-2022-25296": {"epss_score": 0.00273, "epss_percentile": 0.50422}, "CVE-2022-25297": {"epss_score": 0.00515, "epss_percentile": 0.65973}, "CVE-2022-25298": {"epss_score": 0.00436, "epss_percentile": 0.62471}, "CVE-2022-25299": {"epss_score": 0.00353, "epss_percentile": 0.57167}, "CVE-2022-25301": {"epss_score": 0.00363, "epss_percentile": 0.57893}, "CVE-2022-25302": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-25303": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2022-25304": {"epss_score": 0.00504, "epss_percentile": 0.6549}, "CVE-2022-25305": {"epss_score": 0.03934, "epss_percentile": 0.87979}, "CVE-2022-25306": {"epss_score": 0.01161, "epss_percentile": 0.78147}, "CVE-2022-25307": {"epss_score": 0.01161, "epss_percentile": 0.78147}, "CVE-2022-25308": {"epss_score": 0.00043, "epss_percentile": 0.12969}, "CVE-2022-25309": {"epss_score": 0.0004, "epss_percentile": 0.121}, "CVE-2022-25310": {"epss_score": 0.00035, "epss_percentile": 0.09881}, "CVE-2022-25311": {"epss_score": 0.0019, "epss_percentile": 0.41008}, "CVE-2022-25312": {"epss_score": 0.01769, "epss_percentile": 0.8219}, "CVE-2022-25313": {"epss_score": 0.0013, "epss_percentile": 0.33318}, "CVE-2022-25314": {"epss_score": 0.00365, "epss_percentile": 0.57977}, "CVE-2022-25315": {"epss_score": 0.07704, "epss_percentile": 0.91636}, "CVE-2022-25317": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-25318": {"epss_score": 0.00154, "epss_percentile": 0.3669}, "CVE-2022-25319": {"epss_score": 0.0042, "epss_percentile": 0.61404}, "CVE-2022-25320": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2022-25321": {"epss_score": 0.00419, "epss_percentile": 0.61397}, "CVE-2022-25322": {"epss_score": 0.52702, "epss_percentile": 0.97836}, "CVE-2022-25323": {"epss_score": 0.04955, "epss_percentile": 0.89327}, "CVE-2022-25324": {"epss_score": 0.00332, "epss_percentile": 0.556}, "CVE-2022-25325": {"epss_score": 0.00511, "epss_percentile": 0.65825}, "CVE-2022-25326": {"epss_score": 0.00032, "epss_percentile": 0.08964}, "CVE-2022-25327": {"epss_score": 0.00038, "epss_percentile": 0.11287}, "CVE-2022-25328": {"epss_score": 0.00043, "epss_percentile": 0.13019}, "CVE-2022-25329": {"epss_score": 0.02629, "epss_percentile": 0.85274}, "CVE-2022-25330": {"epss_score": 0.04909, "epss_percentile": 0.89279}, "CVE-2022-25331": {"epss_score": 0.0109, "epss_percentile": 0.77449}, "CVE-2022-25332": {"epss_score": 0.00034, "epss_percentile": 0.09438}, "CVE-2022-25333": {"epss_score": 0.00019, "epss_percentile": 0.04081}, "CVE-2022-25334": {"epss_score": 0.00048, "epss_percentile": 0.1525}, "CVE-2022-25335": {"epss_score": 0.00364, "epss_percentile": 0.57949}, "CVE-2022-25336": {"epss_score": 0.00191, "epss_percentile": 0.41169}, "CVE-2022-25337": {"epss_score": 0.00891, "epss_percentile": 0.75036}, "CVE-2022-25338": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2022-25339": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2022-25342": {"epss_score": 0.00164, "epss_percentile": 0.37866}, "CVE-2022-25343": {"epss_score": 0.01498, "epss_percentile": 0.80696}, "CVE-2022-25344": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-25345": {"epss_score": 0.00394, "epss_percentile": 0.59791}, "CVE-2022-25347": {"epss_score": 0.00635, "epss_percentile": 0.6983}, "CVE-2022-25348": {"epss_score": 0.0008, "epss_percentile": 0.24018}, "CVE-2022-25349": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2022-25350": {"epss_score": 0.00212, "epss_percentile": 0.43823}, "CVE-2022-25352": {"epss_score": 0.00536, "epss_percentile": 0.6685}, "CVE-2022-25354": {"epss_score": 0.00727, "epss_percentile": 0.72082}, "CVE-2022-25355": {"epss_score": 0.01055, "epss_percentile": 0.77118}, "CVE-2022-25356": {"epss_score": 0.72874, "epss_percentile": 0.98727}, "CVE-2022-25357": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2022-25358": {"epss_score": 0.00274, "epss_percentile": 0.50576}, "CVE-2022-25359": {"epss_score": 0.17628, "epss_percentile": 0.94878}, "CVE-2022-25360": {"epss_score": 0.00764, "epss_percentile": 0.72899}, "CVE-2022-25361": {"epss_score": 0.01092, "epss_percentile": 0.77465}, "CVE-2022-25363": {"epss_score": 0.00181, "epss_percentile": 0.40034}, "CVE-2022-25364": {"epss_score": 0.00301, "epss_percentile": 0.5308}, "CVE-2022-25365": {"epss_score": 0.01878, "epss_percentile": 0.82668}, "CVE-2022-25366": {"epss_score": 0.00056, "epss_percentile": 0.178}, "CVE-2022-25368": {"epss_score": 0.00273, "epss_percentile": 0.50428}, "CVE-2022-25370": {"epss_score": 0.01502, "epss_percentile": 0.80721}, "CVE-2022-25371": {"epss_score": 0.01368, "epss_percentile": 0.79786}, "CVE-2022-25372": {"epss_score": 0.00363, "epss_percentile": 0.57863}, "CVE-2022-25373": {"epss_score": 0.249, "epss_percentile": 0.95964}, "CVE-2022-25374": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2022-25375": {"epss_score": 0.0044, "epss_percentile": 0.6264}, "CVE-2022-25377": {"epss_score": 0.00139, "epss_percentile": 0.34596}, "CVE-2022-25389": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2022-25390": {"epss_score": 0.02477, "epss_percentile": 0.84865}, "CVE-2022-25393": {"epss_score": 0.00325, "epss_percentile": 0.55029}, "CVE-2022-25394": {"epss_score": 0.00329, "epss_percentile": 0.55301}, "CVE-2022-25395": {"epss_score": 0.0037, "epss_percentile": 0.58328}, "CVE-2022-25396": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-25398": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-25399": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-25401": {"epss_score": 0.07033, "epss_percentile": 0.91202}, "CVE-2022-25402": {"epss_score": 0.00544, "epss_percentile": 0.67127}, "CVE-2022-25403": {"epss_score": 0.00218, "epss_percentile": 0.44369}, "CVE-2022-25404": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-25405": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-25406": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-25407": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-25408": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-25409": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-25410": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-25411": {"epss_score": 0.10692, "epss_percentile": 0.93072}, "CVE-2022-25412": {"epss_score": 0.00388, "epss_percentile": 0.59356}, "CVE-2022-25413": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-25414": {"epss_score": 0.00561, "epss_percentile": 0.67672}, "CVE-2022-25417": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25418": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25420": {"epss_score": 0.05309, "epss_percentile": 0.89715}, "CVE-2022-25427": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25428": {"epss_score": 0.00407, "epss_percentile": 0.60617}, "CVE-2022-25429": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25431": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25433": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25434": {"epss_score": 0.00561, "epss_percentile": 0.67672}, "CVE-2022-25435": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25437": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25438": {"epss_score": 0.15921, "epss_percentile": 0.94536}, "CVE-2022-25439": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25440": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25441": {"epss_score": 0.15921, "epss_percentile": 0.94536}, "CVE-2022-25445": {"epss_score": 0.00561, "epss_percentile": 0.67672}, "CVE-2022-25446": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25447": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25448": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25449": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25450": {"epss_score": 0.00561, "epss_percentile": 0.67672}, "CVE-2022-25451": {"epss_score": 0.00407, "epss_percentile": 0.60617}, "CVE-2022-25452": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25453": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25454": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25455": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25456": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25457": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25458": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25459": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-25460": {"epss_score": 0.00407, "epss_percentile": 0.60617}, "CVE-2022-25461": {"epss_score": 0.00407, "epss_percentile": 0.60617}, "CVE-2022-25462": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2022-25464": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2022-25465": {"epss_score": 0.00252, "epss_percentile": 0.48337}, "CVE-2022-25471": {"epss_score": 0.01304, "epss_percentile": 0.79312}, "CVE-2022-25477": {"epss_score": 0.00143, "epss_percentile": 0.35152}, "CVE-2022-25478": {"epss_score": 0.00154, "epss_percentile": 0.36701}, "CVE-2022-25479": {"epss_score": 0.02797, "epss_percentile": 0.85686}, "CVE-2022-25480": {"epss_score": 0.00154, "epss_percentile": 0.36701}, "CVE-2022-25481": {"epss_score": 0.20316, "epss_percentile": 0.95325}, "CVE-2022-25484": {"epss_score": 0.00199, "epss_percentile": 0.4215}, "CVE-2022-25485": {"epss_score": 0.3763, "epss_percentile": 0.9706}, "CVE-2022-25486": {"epss_score": 0.68833, "epss_percentile": 0.98565}, "CVE-2022-25487": {"epss_score": 0.89284, "epss_percentile": 0.99518}, "CVE-2022-25488": {"epss_score": 0.72376, "epss_percentile": 0.98706}, "CVE-2022-25489": {"epss_score": 0.08481, "epss_percentile": 0.92074}, "CVE-2022-25490": {"epss_score": 0.00218, "epss_percentile": 0.44369}, "CVE-2022-25491": {"epss_score": 0.00212, "epss_percentile": 0.43762}, "CVE-2022-25492": {"epss_score": 0.00218, "epss_percentile": 0.44369}, "CVE-2022-25493": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-25494": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-25495": {"epss_score": 0.03002, "epss_percentile": 0.86174}, "CVE-2022-25497": {"epss_score": 0.22187, "epss_percentile": 0.95606}, "CVE-2022-25498": {"epss_score": 0.11521, "epss_percentile": 0.93392}, "CVE-2022-25505": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-25506": {"epss_score": 0.00238, "epss_percentile": 0.46792}, "CVE-2022-25507": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-25508": {"epss_score": 0.01412, "epss_percentile": 0.80115}, "CVE-2022-25510": {"epss_score": 0.00289, "epss_percentile": 0.52031}, "CVE-2022-25511": {"epss_score": 0.0017, "epss_percentile": 0.3873}, "CVE-2022-25512": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2022-25514": {"epss_score": 0.00303, "epss_percentile": 0.53181}, "CVE-2022-25515": {"epss_score": 0.0044, "epss_percentile": 0.62648}, "CVE-2022-25516": {"epss_score": 0.0044, "epss_percentile": 0.62648}, "CVE-2022-25517": {"epss_score": 0.00359, "epss_percentile": 0.57614}, "CVE-2022-25518": {"epss_score": 0.00327, "epss_percentile": 0.55121}, "CVE-2022-25521": {"epss_score": 0.00346, "epss_percentile": 0.56706}, "CVE-2022-25523": {"epss_score": 0.00212, "epss_percentile": 0.43745}, "CVE-2022-25546": {"epss_score": 0.00476, "epss_percentile": 0.64257}, "CVE-2022-25547": {"epss_score": 0.00476, "epss_percentile": 0.64257}, "CVE-2022-25548": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25549": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25550": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25551": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25552": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25553": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25554": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25555": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25556": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25557": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25558": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25560": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25561": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25566": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-25568": {"epss_score": 0.89768, "epss_percentile": 0.9954}, "CVE-2022-25569": {"epss_score": 0.01801, "epss_percentile": 0.82324}, "CVE-2022-25570": {"epss_score": 0.00158, "epss_percentile": 0.37203}, "CVE-2022-25571": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2022-25574": {"epss_score": 0.0048, "epss_percentile": 0.64449}, "CVE-2022-25575": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-25576": {"epss_score": 0.00115, "epss_percentile": 0.30978}, "CVE-2022-25577": {"epss_score": 0.00267, "epss_percentile": 0.49964}, "CVE-2022-25578": {"epss_score": 0.01103, "epss_percentile": 0.77592}, "CVE-2022-25581": {"epss_score": 0.00492, "epss_percentile": 0.65016}, "CVE-2022-25582": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-25584": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2022-25585": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-25590": {"epss_score": 0.00401, "epss_percentile": 0.60202}, "CVE-2022-25591": {"epss_score": 0.09744, "epss_percentile": 0.92687}, "CVE-2022-25594": {"epss_score": 0.00317, "epss_percentile": 0.54383}, "CVE-2022-25595": {"epss_score": 0.00064, "epss_percentile": 0.20295}, "CVE-2022-25596": {"epss_score": 0.00077, "epss_percentile": 0.23453}, "CVE-2022-25597": {"epss_score": 0.00217, "epss_percentile": 0.44257}, "CVE-2022-25598": {"epss_score": 0.01305, "epss_percentile": 0.79331}, "CVE-2022-25599": {"epss_score": 0.0025, "epss_percentile": 0.48125}, "CVE-2022-25600": {"epss_score": 0.00137, "epss_percentile": 0.34269}, "CVE-2022-25601": {"epss_score": 0.00332, "epss_percentile": 0.55605}, "CVE-2022-25602": {"epss_score": 0.00821, "epss_percentile": 0.73902}, "CVE-2022-25603": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2022-25604": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2022-25605": {"epss_score": 0.00173, "epss_percentile": 0.39094}, "CVE-2022-25606": {"epss_score": 0.00158, "epss_percentile": 0.37254}, "CVE-2022-25607": {"epss_score": 0.00584, "epss_percentile": 0.6837}, "CVE-2022-25608": {"epss_score": 0.00109, "epss_percentile": 0.30005}, "CVE-2022-25609": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2022-25610": {"epss_score": 0.0031, "epss_percentile": 0.53804}, "CVE-2022-25611": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2022-25612": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2022-25613": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2022-25614": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-25615": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-25617": {"epss_score": 0.00345, "epss_percentile": 0.56555}, "CVE-2022-25618": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2022-25619": {"epss_score": 0.00196, "epss_percentile": 0.41808}, "CVE-2022-25620": {"epss_score": 0.00888, "epss_percentile": 0.75009}, "CVE-2022-25621": {"epss_score": 0.0096, "epss_percentile": 0.75969}, "CVE-2022-25622": {"epss_score": 0.00117, "epss_percentile": 0.3128}, "CVE-2022-25623": {"epss_score": 0.00055, "epss_percentile": 0.17552}, "CVE-2022-25625": {"epss_score": 0.00509, "epss_percentile": 0.65753}, "CVE-2022-25626": {"epss_score": 0.00725, "epss_percentile": 0.72052}, "CVE-2022-25627": {"epss_score": 0.00184, "epss_percentile": 0.40398}, "CVE-2022-25628": {"epss_score": 0.00348, "epss_percentile": 0.56814}, "CVE-2022-25629": {"epss_score": 0.00684, "epss_percentile": 0.71116}, "CVE-2022-25630": {"epss_score": 0.03745, "epss_percentile": 0.87661}, "CVE-2022-25631": {"epss_score": 0.0006, "epss_percentile": 0.18961}, "CVE-2022-25634": {"epss_score": 0.00453, "epss_percentile": 0.6321}, "CVE-2022-25635": {"epss_score": 0.00132, "epss_percentile": 0.33515}, "CVE-2022-25636": {"epss_score": 0.00436, "epss_percentile": 0.62382}, "CVE-2022-25638": {"epss_score": 0.00064, "epss_percentile": 0.20254}, "CVE-2022-25640": {"epss_score": 0.04046, "epss_percentile": 0.88173}, "CVE-2022-25641": {"epss_score": 0.00063, "epss_percentile": 0.19977}, "CVE-2022-25642": {"epss_score": 0.00853, "epss_percentile": 0.74428}, "CVE-2022-25643": {"epss_score": 0.01674, "epss_percentile": 0.81697}, "CVE-2022-25644": {"epss_score": 0.00894, "epss_percentile": 0.75084}, "CVE-2022-25645": {"epss_score": 0.00697, "epss_percentile": 0.71405}, "CVE-2022-25646": {"epss_score": 0.00394, "epss_percentile": 0.59772}, "CVE-2022-25647": {"epss_score": 0.02079, "epss_percentile": 0.83526}, "CVE-2022-25648": {"epss_score": 0.01499, "epss_percentile": 0.80707}, "CVE-2022-25649": {"epss_score": 0.00615, "epss_percentile": 0.69299}, "CVE-2022-25650": {"epss_score": 0.00271, "epss_percentile": 0.5034}, "CVE-2022-25651": {"epss_score": 0.00312, "epss_percentile": 0.53991}, "CVE-2022-25652": {"epss_score": 0.00085, "epss_percentile": 0.25166}, "CVE-2022-25653": {"epss_score": 0.00102, "epss_percentile": 0.28818}, "CVE-2022-25654": {"epss_score": 0.00107, "epss_percentile": 0.29636}, "CVE-2022-25655": {"epss_score": 0.0006, "epss_percentile": 0.19206}, "CVE-2022-25656": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2022-25657": {"epss_score": 0.00299, "epss_percentile": 0.52839}, "CVE-2022-25658": {"epss_score": 0.00307, "epss_percentile": 0.5347}, "CVE-2022-25659": {"epss_score": 0.00388, "epss_percentile": 0.59352}, "CVE-2022-25660": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2022-25661": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2022-25662": {"epss_score": 0.0026, "epss_percentile": 0.49098}, "CVE-2022-25663": {"epss_score": 0.0013, "epss_percentile": 0.33296}, "CVE-2022-25664": {"epss_score": 0.00189, "epss_percentile": 0.41002}, "CVE-2022-25665": {"epss_score": 0.001, "epss_percentile": 0.28559}, "CVE-2022-25666": {"epss_score": 0.00102, "epss_percentile": 0.28799}, "CVE-2022-25667": {"epss_score": 0.00186, "epss_percentile": 0.40585}, "CVE-2022-25668": {"epss_score": 0.00393, "epss_percentile": 0.59745}, "CVE-2022-25669": {"epss_score": 0.00466, "epss_percentile": 0.63792}, "CVE-2022-25670": {"epss_score": 0.00282, "epss_percentile": 0.51224}, "CVE-2022-25671": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2022-25672": {"epss_score": 0.00359, "epss_percentile": 0.5755}, "CVE-2022-25673": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2022-25674": {"epss_score": 0.00291, "epss_percentile": 0.52153}, "CVE-2022-25675": {"epss_score": 0.00114, "epss_percentile": 0.30819}, "CVE-2022-25676": {"epss_score": 0.00102, "epss_percentile": 0.28818}, "CVE-2022-25677": {"epss_score": 0.00094, "epss_percentile": 0.26777}, "CVE-2022-25678": {"epss_score": 0.0021, "epss_percentile": 0.43444}, "CVE-2022-25679": {"epss_score": 0.00095, "epss_percentile": 0.27241}, "CVE-2022-25680": {"epss_score": 0.00052, "epss_percentile": 0.16649}, "CVE-2022-25681": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2022-25682": {"epss_score": 0.00118, "epss_percentile": 0.315}, "CVE-2022-25685": {"epss_score": 0.00307, "epss_percentile": 0.53503}, "CVE-2022-25686": {"epss_score": 0.00299, "epss_percentile": 0.52839}, "CVE-2022-25687": {"epss_score": 0.00385, "epss_percentile": 0.59229}, "CVE-2022-25688": {"epss_score": 0.00388, "epss_percentile": 0.59352}, "CVE-2022-25689": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2022-25690": {"epss_score": 0.00297, "epss_percentile": 0.52709}, "CVE-2022-25691": {"epss_score": 0.00359, "epss_percentile": 0.5755}, "CVE-2022-25692": {"epss_score": 0.00359, "epss_percentile": 0.5755}, "CVE-2022-25693": {"epss_score": 0.00113, "epss_percentile": 0.30618}, "CVE-2022-25694": {"epss_score": 0.0006, "epss_percentile": 0.19206}, "CVE-2022-25695": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2022-25696": {"epss_score": 0.00038, "epss_percentile": 0.11399}, "CVE-2022-25697": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2022-25698": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2022-25702": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2022-25705": {"epss_score": 0.00076, "epss_percentile": 0.23109}, "CVE-2022-25706": {"epss_score": 0.0024, "epss_percentile": 0.46949}, "CVE-2022-25708": {"epss_score": 0.0037, "epss_percentile": 0.58306}, "CVE-2022-25709": {"epss_score": 0.00079, "epss_percentile": 0.23876}, "CVE-2022-25710": {"epss_score": 0.00261, "epss_percentile": 0.49248}, "CVE-2022-25711": {"epss_score": 0.00045, "epss_percentile": 0.13705}, "CVE-2022-25712": {"epss_score": 0.0006, "epss_percentile": 0.19231}, "CVE-2022-25713": {"epss_score": 0.00051, "epss_percentile": 0.16162}, "CVE-2022-25715": {"epss_score": 0.00047, "epss_percentile": 0.14931}, "CVE-2022-25716": {"epss_score": 0.00032, "epss_percentile": 0.08732}, "CVE-2022-25717": {"epss_score": 0.00041, "epss_percentile": 0.12243}, "CVE-2022-25718": {"epss_score": 0.00228, "epss_percentile": 0.45546}, "CVE-2022-25719": {"epss_score": 0.00267, "epss_percentile": 0.49968}, "CVE-2022-25720": {"epss_score": 0.00336, "epss_percentile": 0.56001}, "CVE-2022-25721": {"epss_score": 0.00047, "epss_percentile": 0.14931}, "CVE-2022-25722": {"epss_score": 0.00037, "epss_percentile": 0.10654}, "CVE-2022-25723": {"epss_score": 0.00055, "epss_percentile": 0.17611}, "CVE-2022-25724": {"epss_score": 0.00052, "epss_percentile": 0.16649}, "CVE-2022-25725": {"epss_score": 0.00052, "epss_percentile": 0.16646}, "CVE-2022-25726": {"epss_score": 0.00085, "epss_percentile": 0.25106}, "CVE-2022-25727": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2022-25728": {"epss_score": 0.00107, "epss_percentile": 0.29675}, "CVE-2022-25729": {"epss_score": 0.00192, "epss_percentile": 0.41373}, "CVE-2022-25730": {"epss_score": 0.00085, "epss_percentile": 0.25106}, "CVE-2022-25731": {"epss_score": 0.00163, "epss_percentile": 0.37792}, "CVE-2022-25732": {"epss_score": 0.00107, "epss_percentile": 0.29675}, "CVE-2022-25733": {"epss_score": 0.00218, "epss_percentile": 0.44398}, "CVE-2022-25734": {"epss_score": 0.00194, "epss_percentile": 0.41579}, "CVE-2022-25735": {"epss_score": 0.00194, "epss_percentile": 0.41523}, "CVE-2022-25736": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2022-25737": {"epss_score": 0.00183, "epss_percentile": 0.40336}, "CVE-2022-25738": {"epss_score": 0.00107, "epss_percentile": 0.29675}, "CVE-2022-25739": {"epss_score": 0.00154, "epss_percentile": 0.36645}, "CVE-2022-25740": {"epss_score": 0.00153, "epss_percentile": 0.36523}, "CVE-2022-25741": {"epss_score": 0.00306, "epss_percentile": 0.53446}, "CVE-2022-25742": {"epss_score": 0.00335, "epss_percentile": 0.55866}, "CVE-2022-25743": {"epss_score": 0.00096, "epss_percentile": 0.27396}, "CVE-2022-25745": {"epss_score": 0.00172, "epss_percentile": 0.38929}, "CVE-2022-25746": {"epss_score": 0.00049, "epss_percentile": 0.15611}, "CVE-2022-25747": {"epss_score": 0.00071, "epss_percentile": 0.22164}, "CVE-2022-25748": {"epss_score": 0.00399, "epss_percentile": 0.60114}, "CVE-2022-25749": {"epss_score": 0.00335, "epss_percentile": 0.55866}, "CVE-2022-25750": {"epss_score": 0.00049, "epss_percentile": 0.15464}, "CVE-2022-25751": {"epss_score": 0.03257, "epss_percentile": 0.86765}, "CVE-2022-25752": {"epss_score": 0.0282, "epss_percentile": 0.85743}, "CVE-2022-25753": {"epss_score": 0.04641, "epss_percentile": 0.88953}, "CVE-2022-25754": {"epss_score": 0.00234, "epss_percentile": 0.46095}, "CVE-2022-25755": {"epss_score": 0.0058, "epss_percentile": 0.6825}, "CVE-2022-25756": {"epss_score": 0.0058, "epss_percentile": 0.68246}, "CVE-2022-25757": {"epss_score": 0.00492, "epss_percentile": 0.65009}, "CVE-2022-25758": {"epss_score": 0.00493, "epss_percentile": 0.65025}, "CVE-2022-25759": {"epss_score": 0.02015, "epss_percentile": 0.83271}, "CVE-2022-25760": {"epss_score": 0.0046, "epss_percentile": 0.63512}, "CVE-2022-25761": {"epss_score": 0.0015, "epss_percentile": 0.36072}, "CVE-2022-25762": {"epss_score": 0.00662, "epss_percentile": 0.70595}, "CVE-2022-25763": {"epss_score": 0.00121, "epss_percentile": 0.31822}, "CVE-2022-25765": {"epss_score": 0.88788, "epss_percentile": 0.9949}, "CVE-2022-25766": {"epss_score": 0.04231, "epss_percentile": 0.88423}, "CVE-2022-25767": {"epss_score": 0.03105, "epss_percentile": 0.86417}, "CVE-2022-25768": {"epss_score": 0.00272, "epss_percentile": 0.50354}, "CVE-2022-25769": {"epss_score": 0.00119, "epss_percentile": 0.31589}, "CVE-2022-25770": {"epss_score": 0.00296, "epss_percentile": 0.52569}, "CVE-2022-25772": {"epss_score": 0.02711, "epss_percentile": 0.85493}, "CVE-2022-25773": {"epss_score": 0.00165, "epss_percentile": 0.3802}, "CVE-2022-25774": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2022-25775": {"epss_score": 0.00051, "epss_percentile": 0.16054}, "CVE-2022-25776": {"epss_score": 0.00043, "epss_percentile": 0.12941}, "CVE-2022-25777": {"epss_score": 0.00138, "epss_percentile": 0.34526}, "CVE-2022-25778": {"epss_score": 0.00169, "epss_percentile": 0.38562}, "CVE-2022-25779": {"epss_score": 0.00336, "epss_percentile": 0.55949}, "CVE-2022-25780": {"epss_score": 0.00347, "epss_percentile": 0.56759}, "CVE-2022-25781": {"epss_score": 0.00616, "epss_percentile": 0.69339}, "CVE-2022-25782": {"epss_score": 0.0021, "epss_percentile": 0.43466}, "CVE-2022-25783": {"epss_score": 0.00226, "epss_percentile": 0.45341}, "CVE-2022-25784": {"epss_score": 0.00706, "epss_percentile": 0.71606}, "CVE-2022-25785": {"epss_score": 0.01127, "epss_percentile": 0.77822}, "CVE-2022-25786": {"epss_score": 0.00258, "epss_percentile": 0.48959}, "CVE-2022-25787": {"epss_score": 0.00063, "epss_percentile": 0.19903}, "CVE-2022-25788": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-25789": {"epss_score": 0.00678, "epss_percentile": 0.70981}, "CVE-2022-25790": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-25791": {"epss_score": 0.00068, "epss_percentile": 0.21237}, "CVE-2022-25792": {"epss_score": 0.00853, "epss_percentile": 0.74433}, "CVE-2022-25793": {"epss_score": 0.00062, "epss_percentile": 0.19731}, "CVE-2022-25794": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-25795": {"epss_score": 0.00493, "epss_percentile": 0.6506}, "CVE-2022-25796": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-25797": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2022-25799": {"epss_score": 0.00173, "epss_percentile": 0.39128}, "CVE-2022-25800": {"epss_score": 0.00312, "epss_percentile": 0.54009}, "CVE-2022-25801": {"epss_score": 0.00312, "epss_percentile": 0.54009}, "CVE-2022-25802": {"epss_score": 0.00988, "epss_percentile": 0.76353}, "CVE-2022-25803": {"epss_score": 0.00176, "epss_percentile": 0.39476}, "CVE-2022-25804": {"epss_score": 0.00035, "epss_percentile": 0.09818}, "CVE-2022-25805": {"epss_score": 0.00166, "epss_percentile": 0.38143}, "CVE-2022-25806": {"epss_score": 0.0042, "epss_percentile": 0.61443}, "CVE-2022-25807": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2022-25809": {"epss_score": 0.07447, "epss_percentile": 0.91477}, "CVE-2022-25810": {"epss_score": 0.0019, "epss_percentile": 0.41052}, "CVE-2022-25811": {"epss_score": 0.00728, "epss_percentile": 0.72106}, "CVE-2022-25812": {"epss_score": 0.01322, "epss_percentile": 0.79453}, "CVE-2022-25813": {"epss_score": 0.57511, "epss_percentile": 0.98067}, "CVE-2022-25814": {"epss_score": 0.00015, "epss_percentile": 0.02254}, "CVE-2022-25815": {"epss_score": 0.00015, "epss_percentile": 0.02254}, "CVE-2022-25816": {"epss_score": 0.00019, "epss_percentile": 0.04208}, "CVE-2022-25817": {"epss_score": 0.00019, "epss_percentile": 0.04255}, "CVE-2022-25818": {"epss_score": 0.00178, "epss_percentile": 0.39712}, "CVE-2022-25819": {"epss_score": 0.00018, "epss_percentile": 0.04044}, "CVE-2022-25820": {"epss_score": 0.00025, "epss_percentile": 0.06055}, "CVE-2022-25821": {"epss_score": 0.00017, "epss_percentile": 0.03267}, "CVE-2022-25822": {"epss_score": 0.00016, "epss_percentile": 0.02656}, "CVE-2022-25823": {"epss_score": 0.0006, "epss_percentile": 0.19216}, "CVE-2022-25824": {"epss_score": 0.00062, "epss_percentile": 0.19622}, "CVE-2022-25825": {"epss_score": 0.00057, "epss_percentile": 0.18157}, "CVE-2022-25826": {"epss_score": 0.00133, "epss_percentile": 0.33634}, "CVE-2022-25827": {"epss_score": 0.0006, "epss_percentile": 0.19216}, "CVE-2022-25828": {"epss_score": 0.0006, "epss_percentile": 0.19216}, "CVE-2022-25829": {"epss_score": 0.0006, "epss_percentile": 0.19216}, "CVE-2022-25830": {"epss_score": 0.0006, "epss_percentile": 0.19216}, "CVE-2022-25831": {"epss_score": 0.0002, "epss_percentile": 0.04605}, "CVE-2022-25832": {"epss_score": 0.00043, "epss_percentile": 0.1333}, "CVE-2022-25833": {"epss_score": 0.00019, "epss_percentile": 0.04234}, "CVE-2022-25834": {"epss_score": 0.00194, "epss_percentile": 0.41537}, "CVE-2022-25836": {"epss_score": 0.0019, "epss_percentile": 0.41095}, "CVE-2022-25837": {"epss_score": 0.00189, "epss_percentile": 0.4095}, "CVE-2022-25838": {"epss_score": 0.00326, "epss_percentile": 0.5506}, "CVE-2022-25839": {"epss_score": 0.00205, "epss_percentile": 0.42684}, "CVE-2022-25841": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2022-25842": {"epss_score": 0.02707, "epss_percentile": 0.85469}, "CVE-2022-25844": {"epss_score": 0.01924, "epss_percentile": 0.82917}, "CVE-2022-25845": {"epss_score": 0.89917, "epss_percentile": 0.99549}, "CVE-2022-25847": {"epss_score": 0.00321, "epss_percentile": 0.54674}, "CVE-2022-25848": {"epss_score": 0.00397, "epss_percentile": 0.60051}, "CVE-2022-25849": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-25850": {"epss_score": 0.00317, "epss_percentile": 0.54395}, "CVE-2022-25851": {"epss_score": 0.00537, "epss_percentile": 0.66924}, "CVE-2022-25852": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2022-25853": {"epss_score": 0.00073, "epss_percentile": 0.22587}, "CVE-2022-25854": {"epss_score": 0.00633, "epss_percentile": 0.69769}, "CVE-2022-25855": {"epss_score": 0.00175, "epss_percentile": 0.39372}, "CVE-2022-25856": {"epss_score": 0.0081, "epss_percentile": 0.73716}, "CVE-2022-25857": {"epss_score": 0.0037, "epss_percentile": 0.5828}, "CVE-2022-25858": {"epss_score": 0.02988, "epss_percentile": 0.8614}, "CVE-2022-25860": {"epss_score": 0.41312, "epss_percentile": 0.97265}, "CVE-2022-25862": {"epss_score": 0.0023, "epss_percentile": 0.4572}, "CVE-2022-25863": {"epss_score": 0.00712, "epss_percentile": 0.71771}, "CVE-2022-25864": {"epss_score": 0.00051, "epss_percentile": 0.16273}, "CVE-2022-25865": {"epss_score": 0.01249, "epss_percentile": 0.78873}, "CVE-2022-25866": {"epss_score": 0.01994, "epss_percentile": 0.83188}, "CVE-2022-25867": {"epss_score": 0.00836, "epss_percentile": 0.74149}, "CVE-2022-25869": {"epss_score": 0.05681, "epss_percentile": 0.90117}, "CVE-2022-25871": {"epss_score": 0.00299, "epss_percentile": 0.52845}, "CVE-2022-25872": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2022-25873": {"epss_score": 0.00526, "epss_percentile": 0.66408}, "CVE-2022-25875": {"epss_score": 0.00776, "epss_percentile": 0.73102}, "CVE-2022-25876": {"epss_score": 0.00074, "epss_percentile": 0.22741}, "CVE-2022-25878": {"epss_score": 0.004, "epss_percentile": 0.60161}, "CVE-2022-25880": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-25881": {"epss_score": 0.00169, "epss_percentile": 0.38614}, "CVE-2022-25882": {"epss_score": 0.05236, "epss_percentile": 0.89648}, "CVE-2022-25883": {"epss_score": 0.0033, "epss_percentile": 0.55463}, "CVE-2022-25885": {"epss_score": 0.00893, "epss_percentile": 0.75078}, "CVE-2022-25887": {"epss_score": 0.00053, "epss_percentile": 0.16703}, "CVE-2022-25888": {"epss_score": 0.00504, "epss_percentile": 0.65526}, "CVE-2022-25890": {"epss_score": 0.00638, "epss_percentile": 0.699}, "CVE-2022-25891": {"epss_score": 0.00581, "epss_percentile": 0.68266}, "CVE-2022-25892": {"epss_score": 0.01723, "epss_percentile": 0.81946}, "CVE-2022-25893": {"epss_score": 0.00222, "epss_percentile": 0.44775}, "CVE-2022-25894": {"epss_score": 0.08943, "epss_percentile": 0.9233}, "CVE-2022-25895": {"epss_score": 0.01448, "epss_percentile": 0.80337}, "CVE-2022-25896": {"epss_score": 0.00164, "epss_percentile": 0.37916}, "CVE-2022-25897": {"epss_score": 0.00331, "epss_percentile": 0.55504}, "CVE-2022-25898": {"epss_score": 0.01775, "epss_percentile": 0.82218}, "CVE-2022-25899": {"epss_score": 0.01306, "epss_percentile": 0.79333}, "CVE-2022-25900": {"epss_score": 0.02952, "epss_percentile": 0.86055}, "CVE-2022-25901": {"epss_score": 0.00059, "epss_percentile": 0.18919}, "CVE-2022-25903": {"epss_score": 0.00579, "epss_percentile": 0.68236}, "CVE-2022-25904": {"epss_score": 0.00291, "epss_percentile": 0.5218}, "CVE-2022-25905": {"epss_score": 0.00082, "epss_percentile": 0.24474}, "CVE-2022-25906": {"epss_score": 0.00084, "epss_percentile": 0.24836}, "CVE-2022-25907": {"epss_score": 0.00192, "epss_percentile": 0.41317}, "CVE-2022-25908": {"epss_score": 0.00979, "epss_percentile": 0.76264}, "CVE-2022-25912": {"epss_score": 0.46479, "epss_percentile": 0.97548}, "CVE-2022-25914": {"epss_score": 0.01495, "epss_percentile": 0.80652}, "CVE-2022-25915": {"epss_score": 0.00155, "epss_percentile": 0.36849}, "CVE-2022-25916": {"epss_score": 0.00087, "epss_percentile": 0.25558}, "CVE-2022-25917": {"epss_score": 0.00049, "epss_percentile": 0.15309}, "CVE-2022-25918": {"epss_score": 0.00217, "epss_percentile": 0.44328}, "CVE-2022-25921": {"epss_score": 0.00894, "epss_percentile": 0.75084}, "CVE-2022-25922": {"epss_score": 0.00207, "epss_percentile": 0.43202}, "CVE-2022-25923": {"epss_score": 0.01229, "epss_percentile": 0.78711}, "CVE-2022-25926": {"epss_score": 0.00294, "epss_percentile": 0.52412}, "CVE-2022-25927": {"epss_score": 0.01372, "epss_percentile": 0.79812}, "CVE-2022-25929": {"epss_score": 0.00501, "epss_percentile": 0.65339}, "CVE-2022-25931": {"epss_score": 0.01475, "epss_percentile": 0.80529}, "CVE-2022-25932": {"epss_score": 0.00488, "epss_percentile": 0.64864}, "CVE-2022-25936": {"epss_score": 0.00349, "epss_percentile": 0.56867}, "CVE-2022-25937": {"epss_score": 0.00283, "epss_percentile": 0.51397}, "CVE-2022-25940": {"epss_score": 0.00508, "epss_percentile": 0.65702}, "CVE-2022-25942": {"epss_score": 0.00066, "epss_percentile": 0.20875}, "CVE-2022-25943": {"epss_score": 0.09861, "epss_percentile": 0.92741}, "CVE-2022-25946": {"epss_score": 0.00133, "epss_percentile": 0.3371}, "CVE-2022-25948": {"epss_score": 0.0033, "epss_percentile": 0.55487}, "CVE-2022-25949": {"epss_score": 0.01347, "epss_percentile": 0.79654}, "CVE-2022-25952": {"epss_score": 0.00149, "epss_percentile": 0.36012}, "CVE-2022-25959": {"epss_score": 0.00205, "epss_percentile": 0.42721}, "CVE-2022-25962": {"epss_score": 0.00813, "epss_percentile": 0.73758}, "CVE-2022-25966": {"epss_score": 0.00057, "epss_percentile": 0.17992}, "CVE-2022-25967": {"epss_score": 0.03799, "epss_percentile": 0.8774}, "CVE-2022-25969": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2022-25972": {"epss_score": 0.00069, "epss_percentile": 0.21474}, "CVE-2022-25973": {"epss_score": 0.00289, "epss_percentile": 0.52047}, "CVE-2022-25976": {"epss_score": 0.00044, "epss_percentile": 0.13461}, "CVE-2022-25978": {"epss_score": 0.00109, "epss_percentile": 0.29999}, "CVE-2022-25979": {"epss_score": 0.00124, "epss_percentile": 0.32429}, "CVE-2022-25980": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-25986": {"epss_score": 0.00177, "epss_percentile": 0.39503}, "CVE-2022-25987": {"epss_score": 0.00862, "epss_percentile": 0.74574}, "CVE-2022-25989": {"epss_score": 0.00118, "epss_percentile": 0.31485}, "CVE-2022-25990": {"epss_score": 0.00226, "epss_percentile": 0.45334}, "CVE-2022-25992": {"epss_score": 0.00079, "epss_percentile": 0.23937}, "CVE-2022-25995": {"epss_score": 0.01876, "epss_percentile": 0.8266}, "CVE-2022-25996": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-25999": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2022-26002": {"epss_score": 0.07733, "epss_percentile": 0.9165}, "CVE-2022-26006": {"epss_score": 0.00053, "epss_percentile": 0.16995}, "CVE-2022-26007": {"epss_score": 0.03543, "epss_percentile": 0.8732}, "CVE-2022-26009": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-26013": {"epss_score": 0.00577, "epss_percentile": 0.68157}, "CVE-2022-26017": {"epss_score": 0.00153, "epss_percentile": 0.36594}, "CVE-2022-26019": {"epss_score": 0.01106, "epss_percentile": 0.77613}, "CVE-2022-26020": {"epss_score": 0.00263, "epss_percentile": 0.49478}, "CVE-2022-26022": {"epss_score": 0.00205, "epss_percentile": 0.42721}, "CVE-2022-26023": {"epss_score": 0.00331, "epss_percentile": 0.55503}, "CVE-2022-26024": {"epss_score": 0.00046, "epss_percentile": 0.14077}, "CVE-2022-26026": {"epss_score": 0.00398, "epss_percentile": 0.60079}, "CVE-2022-26028": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2022-26032": {"epss_score": 0.00097, "epss_percentile": 0.2751}, "CVE-2022-26034": {"epss_score": 0.00282, "epss_percentile": 0.51204}, "CVE-2022-26041": {"epss_score": 0.00342, "epss_percentile": 0.56392}, "CVE-2022-26042": {"epss_score": 0.02611, "epss_percentile": 0.85237}, "CVE-2022-26043": {"epss_score": 0.00268, "epss_percentile": 0.50056}, "CVE-2022-26045": {"epss_score": 0.00205, "epss_percentile": 0.42755}, "CVE-2022-26047": {"epss_score": 0.00153, "epss_percentile": 0.36531}, "CVE-2022-26049": {"epss_score": 0.01655, "epss_percentile": 0.81593}, "CVE-2022-26051": {"epss_score": 0.00188, "epss_percentile": 0.40892}, "CVE-2022-26052": {"epss_score": 0.00097, "epss_percentile": 0.2751}, "CVE-2022-26054": {"epss_score": 0.00188, "epss_percentile": 0.40892}, "CVE-2022-26057": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2022-26059": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-26061": {"epss_score": 0.00072, "epss_percentile": 0.22424}, "CVE-2022-26062": {"epss_score": 0.00097, "epss_percentile": 0.2751}, "CVE-2022-26065": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-26067": {"epss_score": 0.00236, "epss_percentile": 0.46442}, "CVE-2022-26068": {"epss_score": 0.00381, "epss_percentile": 0.58978}, "CVE-2022-26069": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-26070": {"epss_score": 0.00263, "epss_percentile": 0.4955}, "CVE-2022-26071": {"epss_score": 0.01476, "epss_percentile": 0.80534}, "CVE-2022-26073": {"epss_score": 0.00084, "epss_percentile": 0.24975}, "CVE-2022-26074": {"epss_score": 0.0014, "epss_percentile": 0.34727}, "CVE-2022-26075": {"epss_score": 0.09062, "epss_percentile": 0.92384}, "CVE-2022-26076": {"epss_score": 0.0007, "epss_percentile": 0.21969}, "CVE-2022-26077": {"epss_score": 0.00156, "epss_percentile": 0.36902}, "CVE-2022-26078": {"epss_score": 0.00367, "epss_percentile": 0.58131}, "CVE-2022-26079": {"epss_score": 0.00128, "epss_percentile": 0.33007}, "CVE-2022-26080": {"epss_score": 0.00242, "epss_percentile": 0.47387}, "CVE-2022-26081": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2022-26082": {"epss_score": 0.02703, "epss_percentile": 0.8546}, "CVE-2022-26083": {"epss_score": 0.00044, "epss_percentile": 0.13419}, "CVE-2022-26085": {"epss_score": 0.02657, "epss_percentile": 0.8536}, "CVE-2022-26086": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2022-26088": {"epss_score": 0.00404, "epss_percentile": 0.60438}, "CVE-2022-26090": {"epss_score": 0.00017, "epss_percentile": 0.03295}, "CVE-2022-26091": {"epss_score": 0.00018, "epss_percentile": 0.03933}, "CVE-2022-26092": {"epss_score": 0.00016, "epss_percentile": 0.02748}, "CVE-2022-26093": {"epss_score": 0.0038, "epss_percentile": 0.58946}, "CVE-2022-26094": {"epss_score": 0.0038, "epss_percentile": 0.58946}, "CVE-2022-26095": {"epss_score": 0.0038, "epss_percentile": 0.58946}, "CVE-2022-26096": {"epss_score": 0.0038, "epss_percentile": 0.58946}, "CVE-2022-26097": {"epss_score": 0.00298, "epss_percentile": 0.52784}, "CVE-2022-26098": {"epss_score": 0.0117, "epss_percentile": 0.78212}, "CVE-2022-26099": {"epss_score": 0.00298, "epss_percentile": 0.52784}, "CVE-2022-26100": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2022-26101": {"epss_score": 0.00655, "epss_percentile": 0.70421}, "CVE-2022-26102": {"epss_score": 0.00183, "epss_percentile": 0.40325}, "CVE-2022-26103": {"epss_score": 0.00176, "epss_percentile": 0.39491}, "CVE-2022-26104": {"epss_score": 0.0017, "epss_percentile": 0.38715}, "CVE-2022-26105": {"epss_score": 0.01324, "epss_percentile": 0.79463}, "CVE-2022-26106": {"epss_score": 0.00253, "epss_percentile": 0.4848}, "CVE-2022-26107": {"epss_score": 0.00379, "epss_percentile": 0.58847}, "CVE-2022-26108": {"epss_score": 0.00379, "epss_percentile": 0.58847}, "CVE-2022-26109": {"epss_score": 0.00253, "epss_percentile": 0.4848}, "CVE-2022-26110": {"epss_score": 0.00447, "epss_percentile": 0.62942}, "CVE-2022-26111": {"epss_score": 0.07371, "epss_percentile": 0.9144}, "CVE-2022-26112": {"epss_score": 0.01769, "epss_percentile": 0.82184}, "CVE-2022-26113": {"epss_score": 0.00121, "epss_percentile": 0.31883}, "CVE-2022-26114": {"epss_score": 0.0083, "epss_percentile": 0.74018}, "CVE-2022-26115": {"epss_score": 0.00129, "epss_percentile": 0.33158}, "CVE-2022-26116": {"epss_score": 0.0062, "epss_percentile": 0.69451}, "CVE-2022-26117": {"epss_score": 0.00463, "epss_percentile": 0.63687}, "CVE-2022-26118": {"epss_score": 0.00108, "epss_percentile": 0.29828}, "CVE-2022-26119": {"epss_score": 0.00041, "epss_percentile": 0.12325}, "CVE-2022-26120": {"epss_score": 0.00629, "epss_percentile": 0.69669}, "CVE-2022-26121": {"epss_score": 0.00176, "epss_percentile": 0.39493}, "CVE-2022-26122": {"epss_score": 0.00118, "epss_percentile": 0.31397}, "CVE-2022-26124": {"epss_score": 0.00127, "epss_percentile": 0.32914}, "CVE-2022-26125": {"epss_score": 0.00074, "epss_percentile": 0.22882}, "CVE-2022-26126": {"epss_score": 0.00077, "epss_percentile": 0.2346}, "CVE-2022-26127": {"epss_score": 0.00095, "epss_percentile": 0.27081}, "CVE-2022-26128": {"epss_score": 0.00095, "epss_percentile": 0.27081}, "CVE-2022-26129": {"epss_score": 0.00095, "epss_percentile": 0.27081}, "CVE-2022-26130": {"epss_score": 0.00446, "epss_percentile": 0.62902}, "CVE-2022-26131": {"epss_score": 0.00245, "epss_percentile": 0.47685}, "CVE-2022-26133": {"epss_score": 0.81388, "epss_percentile": 0.99135}, "CVE-2022-26134": {"epss_score": 0.94408, "epss_percentile": 0.99975}, "CVE-2022-26135": {"epss_score": 0.89339, "epss_percentile": 0.9952}, "CVE-2022-26136": {"epss_score": 0.00638, "epss_percentile": 0.69929}, "CVE-2022-26137": {"epss_score": 0.0021, "epss_percentile": 0.43612}, "CVE-2022-26138": {"epss_score": 0.94319, "epss_percentile": 0.99946}, "CVE-2022-26143": {"epss_score": 0.89199, "epss_percentile": 0.99515}, "CVE-2022-26144": {"epss_score": 0.00866, "epss_percentile": 0.74641}, "CVE-2022-26146": {"epss_score": 0.00504, "epss_percentile": 0.65491}, "CVE-2022-26147": {"epss_score": 0.12604, "epss_percentile": 0.93726}, "CVE-2022-26148": {"epss_score": 0.87108, "epss_percentile": 0.99416}, "CVE-2022-26149": {"epss_score": 0.05056, "epss_percentile": 0.89448}, "CVE-2022-26151": {"epss_score": 0.02459, "epss_percentile": 0.84818}, "CVE-2022-26155": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-26156": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2022-26157": {"epss_score": 0.0017, "epss_percentile": 0.3868}, "CVE-2022-26158": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2022-26159": {"epss_score": 0.88594, "epss_percentile": 0.9948}, "CVE-2022-26169": {"epss_score": 0.00303, "epss_percentile": 0.53228}, "CVE-2022-26170": {"epss_score": 0.00364, "epss_percentile": 0.57912}, "CVE-2022-26171": {"epss_score": 0.00303, "epss_percentile": 0.53228}, "CVE-2022-26173": {"epss_score": 0.00214, "epss_percentile": 0.4399}, "CVE-2022-26174": {"epss_score": 0.02228, "epss_percentile": 0.84076}, "CVE-2022-26180": {"epss_score": 0.00449, "epss_percentile": 0.6305}, "CVE-2022-26181": {"epss_score": 0.00202, "epss_percentile": 0.42402}, "CVE-2022-26183": {"epss_score": 0.00642, "epss_percentile": 0.70036}, "CVE-2022-26184": {"epss_score": 0.00597, "epss_percentile": 0.68739}, "CVE-2022-26186": {"epss_score": 0.0799, "epss_percentile": 0.91809}, "CVE-2022-26187": {"epss_score": 0.22328, "epss_percentile": 0.95624}, "CVE-2022-26188": {"epss_score": 0.19442, "epss_percentile": 0.95182}, "CVE-2022-26189": {"epss_score": 0.19442, "epss_percentile": 0.95182}, "CVE-2022-26197": {"epss_score": 0.00502, "epss_percentile": 0.65419}, "CVE-2022-26198": {"epss_score": 0.00853, "epss_percentile": 0.7444}, "CVE-2022-26201": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-26205": {"epss_score": 0.02235, "epss_percentile": 0.84101}, "CVE-2022-26206": {"epss_score": 0.17336, "epss_percentile": 0.94827}, "CVE-2022-26207": {"epss_score": 0.17336, "epss_percentile": 0.94827}, "CVE-2022-26208": {"epss_score": 0.17336, "epss_percentile": 0.94827}, "CVE-2022-26209": {"epss_score": 0.17336, "epss_percentile": 0.94827}, "CVE-2022-26210": {"epss_score": 0.21005, "epss_percentile": 0.9545}, "CVE-2022-26211": {"epss_score": 0.17336, "epss_percentile": 0.94827}, "CVE-2022-26212": {"epss_score": 0.17336, "epss_percentile": 0.94827}, "CVE-2022-26213": {"epss_score": 0.31512, "epss_percentile": 0.96624}, "CVE-2022-26214": {"epss_score": 0.2647, "epss_percentile": 0.9615}, "CVE-2022-26233": {"epss_score": 0.84035, "epss_percentile": 0.99271}, "CVE-2022-26235": {"epss_score": 0.00034, "epss_percentile": 0.09795}, "CVE-2022-26236": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2022-26237": {"epss_score": 0.00038, "epss_percentile": 0.11154}, "CVE-2022-26238": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2022-26239": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2022-26240": {"epss_score": 0.00206, "epss_percentile": 0.43002}, "CVE-2022-26243": {"epss_score": 0.00406, "epss_percentile": 0.60545}, "CVE-2022-26244": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-26245": {"epss_score": 0.01782, "epss_percentile": 0.82243}, "CVE-2022-26246": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-26247": {"epss_score": 0.00148, "epss_percentile": 0.35806}, "CVE-2022-26249": {"epss_score": 0.01201, "epss_percentile": 0.78484}, "CVE-2022-26250": {"epss_score": 0.00043, "epss_percentile": 0.13009}, "CVE-2022-26251": {"epss_score": 0.01476, "epss_percentile": 0.80535}, "CVE-2022-26252": {"epss_score": 0.02582, "epss_percentile": 0.85157}, "CVE-2022-26254": {"epss_score": 0.00585, "epss_percentile": 0.6843}, "CVE-2022-26255": {"epss_score": 0.01119, "epss_percentile": 0.77752}, "CVE-2022-26258": {"epss_score": 0.87658, "epss_percentile": 0.99436}, "CVE-2022-26259": {"epss_score": 0.01073, "epss_percentile": 0.77291}, "CVE-2022-26260": {"epss_score": 0.00281, "epss_percentile": 0.51114}, "CVE-2022-26263": {"epss_score": 0.10825, "epss_percentile": 0.93126}, "CVE-2022-26265": {"epss_score": 0.72315, "epss_percentile": 0.98704}, "CVE-2022-26266": {"epss_score": 0.00501, "epss_percentile": 0.65342}, "CVE-2022-26267": {"epss_score": 0.00922, "epss_percentile": 0.75493}, "CVE-2022-26268": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-26269": {"epss_score": 0.0008, "epss_percentile": 0.24185}, "CVE-2022-26271": {"epss_score": 0.21262, "epss_percentile": 0.9549}, "CVE-2022-26272": {"epss_score": 0.0303, "epss_percentile": 0.86246}, "CVE-2022-26273": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2022-26276": {"epss_score": 0.00147, "epss_percentile": 0.35672}, "CVE-2022-26278": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-26279": {"epss_score": 0.00989, "epss_percentile": 0.76362}, "CVE-2022-26280": {"epss_score": 0.00123, "epss_percentile": 0.32198}, "CVE-2022-26281": {"epss_score": 0.00165, "epss_percentile": 0.38041}, "CVE-2022-26283": {"epss_score": 0.0158, "epss_percentile": 0.81135}, "CVE-2022-26284": {"epss_score": 0.03203, "epss_percentile": 0.86626}, "CVE-2022-26285": {"epss_score": 0.03203, "epss_percentile": 0.86626}, "CVE-2022-26289": {"epss_score": 0.14056, "epss_percentile": 0.94124}, "CVE-2022-26290": {"epss_score": 0.14056, "epss_percentile": 0.94124}, "CVE-2022-26291": {"epss_score": 0.00105, "epss_percentile": 0.29313}, "CVE-2022-26293": {"epss_score": 0.00375, "epss_percentile": 0.58611}, "CVE-2022-26295": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2022-26296": {"epss_score": 0.00049, "epss_percentile": 0.15424}, "CVE-2022-26300": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2022-26301": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-26302": {"epss_score": 0.00851, "epss_percentile": 0.74401}, "CVE-2022-26303": {"epss_score": 0.00283, "epss_percentile": 0.51353}, "CVE-2022-26305": {"epss_score": 0.00706, "epss_percentile": 0.7161}, "CVE-2022-26306": {"epss_score": 0.00364, "epss_percentile": 0.57949}, "CVE-2022-26307": {"epss_score": 0.00295, "epss_percentile": 0.52448}, "CVE-2022-26308": {"epss_score": 0.0025, "epss_percentile": 0.48104}, "CVE-2022-26309": {"epss_score": 0.00192, "epss_percentile": 0.41317}, "CVE-2022-26310": {"epss_score": 0.00324, "epss_percentile": 0.54932}, "CVE-2022-26311": {"epss_score": 0.00348, "epss_percentile": 0.56805}, "CVE-2022-26313": {"epss_score": 0.00451, "epss_percentile": 0.63122}, "CVE-2022-26314": {"epss_score": 0.01554, "epss_percentile": 0.81}, "CVE-2022-26315": {"epss_score": 0.00147, "epss_percentile": 0.35744}, "CVE-2022-26317": {"epss_score": 0.00441, "epss_percentile": 0.62653}, "CVE-2022-26318": {"epss_score": 0.92547, "epss_percentile": 0.99725}, "CVE-2022-26319": {"epss_score": 0.0006, "epss_percentile": 0.19032}, "CVE-2022-26320": {"epss_score": 0.00523, "epss_percentile": 0.663}, "CVE-2022-26322": {"epss_score": 0.00105, "epss_percentile": 0.29293}, "CVE-2022-26323": {"epss_score": 0.00075, "epss_percentile": 0.23001}, "CVE-2022-26324": {"epss_score": 0.00106, "epss_percentile": 0.29552}, "CVE-2022-26325": {"epss_score": 0.00167, "epss_percentile": 0.3833}, "CVE-2022-26326": {"epss_score": 0.00132, "epss_percentile": 0.33544}, "CVE-2022-26327": {"epss_score": 0.0012, "epss_percentile": 0.31762}, "CVE-2022-26328": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2022-26329": {"epss_score": 0.0035, "epss_percentile": 0.56966}, "CVE-2022-26330": {"epss_score": 0.00272, "epss_percentile": 0.50377}, "CVE-2022-26331": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-26332": {"epss_score": 0.00195, "epss_percentile": 0.41621}, "CVE-2022-26334": {"epss_score": 0.02867, "epss_percentile": 0.85864}, "CVE-2022-26335": {"epss_score": 0.02867, "epss_percentile": 0.85864}, "CVE-2022-26336": {"epss_score": 0.00046, "epss_percentile": 0.14173}, "CVE-2022-26337": {"epss_score": 0.0023, "epss_percentile": 0.45684}, "CVE-2022-26338": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-26340": {"epss_score": 0.00114, "epss_percentile": 0.30747}, "CVE-2022-26341": {"epss_score": 0.00296, "epss_percentile": 0.52558}, "CVE-2022-26342": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-26343": {"epss_score": 0.00065, "epss_percentile": 0.20601}, "CVE-2022-26344": {"epss_score": 0.00034, "epss_percentile": 0.09795}, "CVE-2022-26345": {"epss_score": 0.00072, "epss_percentile": 0.22243}, "CVE-2022-26346": {"epss_score": 0.00335, "epss_percentile": 0.55832}, "CVE-2022-26348": {"epss_score": 0.00114, "epss_percentile": 0.30784}, "CVE-2022-26349": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-26352": {"epss_score": 0.94337, "epss_percentile": 0.9995}, "CVE-2022-26353": {"epss_score": 0.00326, "epss_percentile": 0.55053}, "CVE-2022-26354": {"epss_score": 0.00018, "epss_percentile": 0.03556}, "CVE-2022-26355": {"epss_score": 0.00029, "epss_percentile": 0.07635}, "CVE-2022-26356": {"epss_score": 0.0003, "epss_percentile": 0.08153}, "CVE-2022-26357": {"epss_score": 0.00013, "epss_percentile": 0.01455}, "CVE-2022-26358": {"epss_score": 0.00091, "epss_percentile": 0.26192}, "CVE-2022-26359": {"epss_score": 0.00091, "epss_percentile": 0.26192}, "CVE-2022-26360": {"epss_score": 0.00091, "epss_percentile": 0.26192}, "CVE-2022-26361": {"epss_score": 0.00091, "epss_percentile": 0.26192}, "CVE-2022-26362": {"epss_score": 0.00047, "epss_percentile": 0.14911}, "CVE-2022-26363": {"epss_score": 0.00082, "epss_percentile": 0.24559}, "CVE-2022-26364": {"epss_score": 0.00108, "epss_percentile": 0.29899}, "CVE-2022-26365": {"epss_score": 0.00016, "epss_percentile": 0.02807}, "CVE-2022-26366": {"epss_score": 0.00104, "epss_percentile": 0.2915}, "CVE-2022-26367": {"epss_score": 0.00128, "epss_percentile": 0.33028}, "CVE-2022-26368": {"epss_score": 0.00148, "epss_percentile": 0.35916}, "CVE-2022-26369": {"epss_score": 0.00171, "epss_percentile": 0.38882}, "CVE-2022-26370": {"epss_score": 0.00674, "epss_percentile": 0.70861}, "CVE-2022-26372": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2022-26373": {"epss_score": 0.00174, "epss_percentile": 0.39142}, "CVE-2022-26374": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2022-26375": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-26376": {"epss_score": 0.00497, "epss_percentile": 0.65193}, "CVE-2022-26377": {"epss_score": 0.39296, "epss_percentile": 0.97152}, "CVE-2022-26380": {"epss_score": 0.00582, "epss_percentile": 0.68308}, "CVE-2022-26381": {"epss_score": 0.00117, "epss_percentile": 0.31382}, "CVE-2022-26382": {"epss_score": 0.00294, "epss_percentile": 0.5239}, "CVE-2022-26383": {"epss_score": 0.00217, "epss_percentile": 0.4424}, "CVE-2022-26384": {"epss_score": 0.00099, "epss_percentile": 0.28391}, "CVE-2022-26385": {"epss_score": 0.00352, "epss_percentile": 0.57103}, "CVE-2022-26386": {"epss_score": 0.00085, "epss_percentile": 0.2523}, "CVE-2022-26387": {"epss_score": 0.00092, "epss_percentile": 0.26601}, "CVE-2022-26388": {"epss_score": 0.00115, "epss_percentile": 0.30883}, "CVE-2022-26389": {"epss_score": 0.0008, "epss_percentile": 0.24206}, "CVE-2022-26390": {"epss_score": 0.00052, "epss_percentile": 0.16338}, "CVE-2022-26392": {"epss_score": 0.0025, "epss_percentile": 0.48209}, "CVE-2022-26393": {"epss_score": 0.00204, "epss_percentile": 0.42599}, "CVE-2022-26394": {"epss_score": 0.00085, "epss_percentile": 0.25175}, "CVE-2022-26413": {"epss_score": 0.00626, "epss_percentile": 0.69605}, "CVE-2022-26414": {"epss_score": 0.00038, "epss_percentile": 0.11402}, "CVE-2022-26415": {"epss_score": 0.00869, "epss_percentile": 0.74693}, "CVE-2022-26417": {"epss_score": 0.00279, "epss_percentile": 0.5096}, "CVE-2022-26419": {"epss_score": 0.00677, "epss_percentile": 0.70965}, "CVE-2022-26420": {"epss_score": 0.09062, "epss_percentile": 0.92384}, "CVE-2022-26421": {"epss_score": 0.00097, "epss_percentile": 0.2751}, "CVE-2022-26423": {"epss_score": 0.00484, "epss_percentile": 0.64638}, "CVE-2022-26425": {"epss_score": 0.00097, "epss_percentile": 0.2751}, "CVE-2022-26426": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2022-26427": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2022-26428": {"epss_score": 0.00012, "epss_percentile": 0.01172}, "CVE-2022-26429": {"epss_score": 0.00011, "epss_percentile": 0.00933}, "CVE-2022-26430": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-26431": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-26432": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-26433": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-26434": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-26435": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-26436": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-26437": {"epss_score": 0.01452, "epss_percentile": 0.8037}, "CVE-2022-26438": {"epss_score": 0.00139, "epss_percentile": 0.34612}, "CVE-2022-26439": {"epss_score": 0.00139, "epss_percentile": 0.34612}, "CVE-2022-26440": {"epss_score": 0.00058, "epss_percentile": 0.18301}, "CVE-2022-26441": {"epss_score": 0.00058, "epss_percentile": 0.18301}, "CVE-2022-26442": {"epss_score": 0.00058, "epss_percentile": 0.18301}, "CVE-2022-26443": {"epss_score": 0.00058, "epss_percentile": 0.18301}, "CVE-2022-26444": {"epss_score": 0.00058, "epss_percentile": 0.18301}, "CVE-2022-26445": {"epss_score": 0.00058, "epss_percentile": 0.18301}, "CVE-2022-26446": {"epss_score": 0.00903, "epss_percentile": 0.75201}, "CVE-2022-26447": {"epss_score": 0.00487, "epss_percentile": 0.64826}, "CVE-2022-26448": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2022-26449": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2022-26450": {"epss_score": 0.00014, "epss_percentile": 0.01789}, "CVE-2022-26451": {"epss_score": 0.00016, "epss_percentile": 0.02738}, "CVE-2022-26452": {"epss_score": 0.00016, "epss_percentile": 0.02738}, "CVE-2022-26453": {"epss_score": 0.00018, "epss_percentile": 0.03751}, "CVE-2022-26454": {"epss_score": 0.00015, "epss_percentile": 0.02539}, "CVE-2022-26455": {"epss_score": 0.00013, "epss_percentile": 0.01647}, "CVE-2022-26456": {"epss_score": 0.0002, "epss_percentile": 0.04532}, "CVE-2022-26457": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-26458": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-26459": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-26460": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-26461": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-26462": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-26463": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-26464": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-26465": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-26466": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-26467": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-26468": {"epss_score": 0.00032, "epss_percentile": 0.08995}, "CVE-2022-26469": {"epss_score": 0.00029, "epss_percentile": 0.07819}, "CVE-2022-26470": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-26471": {"epss_score": 0.00022, "epss_percentile": 0.0496}, "CVE-2022-26472": {"epss_score": 0.00022, "epss_percentile": 0.0496}, "CVE-2022-26473": {"epss_score": 0.00016, "epss_percentile": 0.02738}, "CVE-2022-26474": {"epss_score": 0.00015, "epss_percentile": 0.02517}, "CVE-2022-26475": {"epss_score": 0.00045, "epss_percentile": 0.13888}, "CVE-2022-26476": {"epss_score": 0.00127, "epss_percentile": 0.32839}, "CVE-2022-26477": {"epss_score": 0.07001, "epss_percentile": 0.91174}, "CVE-2022-26479": {"epss_score": 0.00788, "epss_percentile": 0.7334}, "CVE-2022-26481": {"epss_score": 0.03364, "epss_percentile": 0.86999}, "CVE-2022-26482": {"epss_score": 0.26097, "epss_percentile": 0.9611}, "CVE-2022-26483": {"epss_score": 0.00217, "epss_percentile": 0.44327}, "CVE-2022-26484": {"epss_score": 0.00258, "epss_percentile": 0.48988}, "CVE-2022-26485": {"epss_score": 0.07065, "epss_percentile": 0.91223}, "CVE-2022-26486": {"epss_score": 0.04863, "epss_percentile": 0.89223}, "CVE-2022-26488": {"epss_score": 0.01669, "epss_percentile": 0.81665}, "CVE-2022-26490": {"epss_score": 0.00024, "epss_percentile": 0.05775}, "CVE-2022-26491": {"epss_score": 0.00889, "epss_percentile": 0.75018}, "CVE-2022-26493": {"epss_score": 0.00083, "epss_percentile": 0.24766}, "CVE-2022-26494": {"epss_score": 0.00403, "epss_percentile": 0.60374}, "CVE-2022-26495": {"epss_score": 0.00223, "epss_percentile": 0.44886}, "CVE-2022-26496": {"epss_score": 0.00455, "epss_percentile": 0.63284}, "CVE-2022-26497": {"epss_score": 0.00258, "epss_percentile": 0.49004}, "CVE-2022-26498": {"epss_score": 0.00451, "epss_percentile": 0.63112}, "CVE-2022-26499": {"epss_score": 0.0019, "epss_percentile": 0.41121}, "CVE-2022-26500": {"epss_score": 0.20116, "epss_percentile": 0.9529}, "CVE-2022-26501": {"epss_score": 0.66731, "epss_percentile": 0.98477}, "CVE-2022-26503": {"epss_score": 0.01769, "epss_percentile": 0.82184}, "CVE-2022-26504": {"epss_score": 0.00599, "epss_percentile": 0.68804}, "CVE-2022-26505": {"epss_score": 0.00185, "epss_percentile": 0.40523}, "CVE-2022-26507": {"epss_score": 0.06696, "epss_percentile": 0.90952}, "CVE-2022-26508": {"epss_score": 0.00286, "epss_percentile": 0.517}, "CVE-2022-26509": {"epss_score": 0.00099, "epss_percentile": 0.27864}, "CVE-2022-26510": {"epss_score": 0.00487, "epss_percentile": 0.64809}, "CVE-2022-26511": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2022-26512": {"epss_score": 0.00097, "epss_percentile": 0.2751}, "CVE-2022-26513": {"epss_score": 0.00476, "epss_percentile": 0.64294}, "CVE-2022-26514": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-26516": {"epss_score": 0.00076, "epss_percentile": 0.23268}, "CVE-2022-26517": {"epss_score": 0.00674, "epss_percentile": 0.70861}, "CVE-2022-26518": {"epss_score": 0.0689, "epss_percentile": 0.91095}, "CVE-2022-26519": {"epss_score": 0.00039, "epss_percentile": 0.11643}, "CVE-2022-26520": {"epss_score": 0.01299, "epss_percentile": 0.7928}, "CVE-2022-26521": {"epss_score": 0.08009, "epss_percentile": 0.91825}, "CVE-2022-26526": {"epss_score": 0.00135, "epss_percentile": 0.33974}, "CVE-2022-26527": {"epss_score": 0.00177, "epss_percentile": 0.39595}, "CVE-2022-26528": {"epss_score": 0.00177, "epss_percentile": 0.39595}, "CVE-2022-26529": {"epss_score": 0.00177, "epss_percentile": 0.39595}, "CVE-2022-26530": {"epss_score": 0.00553, "epss_percentile": 0.67423}, "CVE-2022-26531": {"epss_score": 0.01558, "epss_percentile": 0.81029}, "CVE-2022-26532": {"epss_score": 0.02198, "epss_percentile": 0.83968}, "CVE-2022-26533": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-26534": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2022-26536": {"epss_score": 0.14056, "epss_percentile": 0.94124}, "CVE-2022-26546": {"epss_score": 0.00173, "epss_percentile": 0.39113}, "CVE-2022-26555": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-26562": {"epss_score": 0.02569, "epss_percentile": 0.85123}, "CVE-2022-26563": {"epss_score": 0.00502, "epss_percentile": 0.65379}, "CVE-2022-26564": {"epss_score": 0.00684, "epss_percentile": 0.71125}, "CVE-2022-26565": {"epss_score": 0.00299, "epss_percentile": 0.52851}, "CVE-2022-26572": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2022-26573": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-26579": {"epss_score": 0.00031, "epss_percentile": 0.08417}, "CVE-2022-26580": {"epss_score": 0.01497, "epss_percentile": 0.80691}, "CVE-2022-26581": {"epss_score": 0.00104, "epss_percentile": 0.29217}, "CVE-2022-26582": {"epss_score": 0.00532, "epss_percentile": 0.66698}, "CVE-2022-26585": {"epss_score": 0.44893, "epss_percentile": 0.97458}, "CVE-2022-26588": {"epss_score": 0.00164, "epss_percentile": 0.37869}, "CVE-2022-26589": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2022-26591": {"epss_score": 0.00568, "epss_percentile": 0.67907}, "CVE-2022-26592": {"epss_score": 0.00095, "epss_percentile": 0.27173}, "CVE-2022-26593": {"epss_score": 0.00167, "epss_percentile": 0.3838}, "CVE-2022-26594": {"epss_score": 0.00257, "epss_percentile": 0.48893}, "CVE-2022-26595": {"epss_score": 0.00112, "epss_percentile": 0.3054}, "CVE-2022-26596": {"epss_score": 0.0023, "epss_percentile": 0.45724}, "CVE-2022-26597": {"epss_score": 0.0023, "epss_percentile": 0.45724}, "CVE-2022-26605": {"epss_score": 0.00468, "epss_percentile": 0.63878}, "CVE-2022-26607": {"epss_score": 0.02715, "epss_percentile": 0.85507}, "CVE-2022-26612": {"epss_score": 0.00162, "epss_percentile": 0.37618}, "CVE-2022-26613": {"epss_score": 0.00305, "epss_percentile": 0.53345}, "CVE-2022-26615": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-26616": {"epss_score": 0.0096, "epss_percentile": 0.75963}, "CVE-2022-26619": {"epss_score": 0.00198, "epss_percentile": 0.42035}, "CVE-2022-26624": {"epss_score": 0.00325, "epss_percentile": 0.55007}, "CVE-2022-26627": {"epss_score": 0.00706, "epss_percentile": 0.71609}, "CVE-2022-26628": {"epss_score": 0.00412, "epss_percentile": 0.60927}, "CVE-2022-26629": {"epss_score": 0.27606, "epss_percentile": 0.96262}, "CVE-2022-26630": {"epss_score": 0.00354, "epss_percentile": 0.57234}, "CVE-2022-26631": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-26632": {"epss_score": 0.00402, "epss_percentile": 0.60305}, "CVE-2022-26633": {"epss_score": 0.00402, "epss_percentile": 0.60305}, "CVE-2022-26634": {"epss_score": 0.00137, "epss_percentile": 0.34238}, "CVE-2022-26635": {"epss_score": 0.24293, "epss_percentile": 0.95901}, "CVE-2022-26639": {"epss_score": 0.00478, "epss_percentile": 0.64381}, "CVE-2022-26640": {"epss_score": 0.00478, "epss_percentile": 0.64381}, "CVE-2022-26641": {"epss_score": 0.00478, "epss_percentile": 0.64381}, "CVE-2022-26642": {"epss_score": 0.00478, "epss_percentile": 0.64381}, "CVE-2022-26643": {"epss_score": 0.00298, "epss_percentile": 0.5278}, "CVE-2022-26644": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-26645": {"epss_score": 0.02994, "epss_percentile": 0.86151}, "CVE-2022-26646": {"epss_score": 0.00469, "epss_percentile": 0.63945}, "CVE-2022-26647": {"epss_score": 0.01483, "epss_percentile": 0.80588}, "CVE-2022-26648": {"epss_score": 0.00872, "epss_percentile": 0.74728}, "CVE-2022-26649": {"epss_score": 0.01152, "epss_percentile": 0.78051}, "CVE-2022-26650": {"epss_score": 0.01258, "epss_percentile": 0.78956}, "CVE-2022-26651": {"epss_score": 0.00195, "epss_percentile": 0.41659}, "CVE-2022-26652": {"epss_score": 0.00684, "epss_percentile": 0.71119}, "CVE-2022-26653": {"epss_score": 0.06633, "epss_percentile": 0.90905}, "CVE-2022-26654": {"epss_score": 0.00915, "epss_percentile": 0.75396}, "CVE-2022-26655": {"epss_score": 0.00449, "epss_percentile": 0.63043}, "CVE-2022-26656": {"epss_score": 0.00571, "epss_percentile": 0.67972}, "CVE-2022-26657": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2022-26659": {"epss_score": 0.00084, "epss_percentile": 0.24884}, "CVE-2022-26660": {"epss_score": 0.00148, "epss_percentile": 0.35914}, "CVE-2022-26661": {"epss_score": 0.00484, "epss_percentile": 0.64651}, "CVE-2022-26662": {"epss_score": 0.05585, "epss_percentile": 0.90024}, "CVE-2022-26665": {"epss_score": 0.00487, "epss_percentile": 0.64783}, "CVE-2022-26666": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-26667": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-26668": {"epss_score": 0.00651, "epss_percentile": 0.70302}, "CVE-2022-26669": {"epss_score": 0.00318, "epss_percentile": 0.54458}, "CVE-2022-26670": {"epss_score": 0.04044, "epss_percentile": 0.8817}, "CVE-2022-26671": {"epss_score": 0.00648, "epss_percentile": 0.70209}, "CVE-2022-26672": {"epss_score": 0.01715, "epss_percentile": 0.81897}, "CVE-2022-26673": {"epss_score": 0.0021, "epss_percentile": 0.43464}, "CVE-2022-26674": {"epss_score": 0.04547, "epss_percentile": 0.88836}, "CVE-2022-26675": {"epss_score": 0.00259, "epss_percentile": 0.49038}, "CVE-2022-26676": {"epss_score": 0.00799, "epss_percentile": 0.7353}, "CVE-2022-26688": {"epss_score": 0.00152, "epss_percentile": 0.36377}, "CVE-2022-26690": {"epss_score": 0.00166, "epss_percentile": 0.38179}, "CVE-2022-26691": {"epss_score": 0.00024, "epss_percentile": 0.05967}, "CVE-2022-26693": {"epss_score": 0.00236, "epss_percentile": 0.4646}, "CVE-2022-26694": {"epss_score": 0.00236, "epss_percentile": 0.4646}, "CVE-2022-26696": {"epss_score": 0.00055, "epss_percentile": 0.17551}, "CVE-2022-26697": {"epss_score": 0.00229, "epss_percentile": 0.45612}, "CVE-2022-26698": {"epss_score": 0.00225, "epss_percentile": 0.45143}, "CVE-2022-26699": {"epss_score": 0.00044, "epss_percentile": 0.13496}, "CVE-2022-26700": {"epss_score": 0.00118, "epss_percentile": 0.31516}, "CVE-2022-26701": {"epss_score": 0.00438, "epss_percentile": 0.62546}, "CVE-2022-26702": {"epss_score": 0.00272, "epss_percentile": 0.50349}, "CVE-2022-26703": {"epss_score": 0.0007, "epss_percentile": 0.218}, "CVE-2022-26704": {"epss_score": 0.00332, "epss_percentile": 0.55584}, "CVE-2022-26706": {"epss_score": 0.01412, "epss_percentile": 0.80116}, "CVE-2022-26707": {"epss_score": 0.00078, "epss_percentile": 0.23795}, "CVE-2022-26708": {"epss_score": 0.01608, "epss_percentile": 0.8131}, "CVE-2022-26709": {"epss_score": 0.00146, "epss_percentile": 0.35534}, "CVE-2022-26710": {"epss_score": 0.0015, "epss_percentile": 0.36148}, "CVE-2022-26711": {"epss_score": 0.01615, "epss_percentile": 0.81351}, "CVE-2022-26712": {"epss_score": 0.00345, "epss_percentile": 0.56585}, "CVE-2022-26714": {"epss_score": 0.0048, "epss_percentile": 0.64449}, "CVE-2022-26715": {"epss_score": 0.00151, "epss_percentile": 0.36249}, "CVE-2022-26716": {"epss_score": 0.00138, "epss_percentile": 0.34531}, "CVE-2022-26717": {"epss_score": 0.00769, "epss_percentile": 0.72988}, "CVE-2022-26718": {"epss_score": 0.00164, "epss_percentile": 0.37873}, "CVE-2022-26719": {"epss_score": 0.00252, "epss_percentile": 0.48399}, "CVE-2022-26720": {"epss_score": 0.00271, "epss_percentile": 0.50322}, "CVE-2022-26721": {"epss_score": 0.00335, "epss_percentile": 0.55807}, "CVE-2022-26722": {"epss_score": 0.00173, "epss_percentile": 0.39062}, "CVE-2022-26723": {"epss_score": 0.01215, "epss_percentile": 0.78583}, "CVE-2022-26724": {"epss_score": 0.00042, "epss_percentile": 0.12936}, "CVE-2022-26725": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2022-26726": {"epss_score": 0.08519, "epss_percentile": 0.92098}, "CVE-2022-26727": {"epss_score": 0.00169, "epss_percentile": 0.38528}, "CVE-2022-26728": {"epss_score": 0.00409, "epss_percentile": 0.60784}, "CVE-2022-26730": {"epss_score": 0.00579, "epss_percentile": 0.68235}, "CVE-2022-26731": {"epss_score": 0.00314, "epss_percentile": 0.54151}, "CVE-2022-26736": {"epss_score": 0.00271, "epss_percentile": 0.50322}, "CVE-2022-26737": {"epss_score": 0.00292, "epss_percentile": 0.52273}, "CVE-2022-26738": {"epss_score": 0.00292, "epss_percentile": 0.52273}, "CVE-2022-26739": {"epss_score": 0.00292, "epss_percentile": 0.52273}, "CVE-2022-26740": {"epss_score": 0.00292, "epss_percentile": 0.52273}, "CVE-2022-26741": {"epss_score": 0.00452, "epss_percentile": 0.63185}, "CVE-2022-26742": {"epss_score": 0.00452, "epss_percentile": 0.63185}, "CVE-2022-26743": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2022-26744": {"epss_score": 0.00271, "epss_percentile": 0.50322}, "CVE-2022-26745": {"epss_score": 0.00266, "epss_percentile": 0.49924}, "CVE-2022-26746": {"epss_score": 0.00271, "epss_percentile": 0.50294}, "CVE-2022-26747": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2022-26748": {"epss_score": 0.00693, "epss_percentile": 0.71327}, "CVE-2022-26749": {"epss_score": 0.00452, "epss_percentile": 0.63185}, "CVE-2022-26750": {"epss_score": 0.00452, "epss_percentile": 0.63185}, "CVE-2022-26751": {"epss_score": 0.00627, "epss_percentile": 0.69628}, "CVE-2022-26752": {"epss_score": 0.00452, "epss_percentile": 0.63185}, "CVE-2022-26753": {"epss_score": 0.00452, "epss_percentile": 0.63185}, "CVE-2022-26754": {"epss_score": 0.00452, "epss_percentile": 0.63185}, "CVE-2022-26755": {"epss_score": 0.00283, "epss_percentile": 0.51399}, "CVE-2022-26756": {"epss_score": 0.00292, "epss_percentile": 0.52273}, "CVE-2022-26757": {"epss_score": 0.04042, "epss_percentile": 0.88168}, "CVE-2022-26760": {"epss_score": 0.00246, "epss_percentile": 0.47801}, "CVE-2022-26761": {"epss_score": 0.00213, "epss_percentile": 0.43892}, "CVE-2022-26762": {"epss_score": 0.00047, "epss_percentile": 0.14862}, "CVE-2022-26763": {"epss_score": 0.19484, "epss_percentile": 0.95192}, "CVE-2022-26764": {"epss_score": 0.00342, "epss_percentile": 0.56368}, "CVE-2022-26765": {"epss_score": 0.00028, "epss_percentile": 0.0758}, "CVE-2022-26766": {"epss_score": 0.02232, "epss_percentile": 0.84092}, "CVE-2022-26767": {"epss_score": 0.00127, "epss_percentile": 0.32911}, "CVE-2022-26768": {"epss_score": 0.00831, "epss_percentile": 0.74043}, "CVE-2022-26769": {"epss_score": 0.00248, "epss_percentile": 0.47991}, "CVE-2022-26770": {"epss_score": 0.00266, "epss_percentile": 0.49864}, "CVE-2022-26771": {"epss_score": 0.00257, "epss_percentile": 0.48868}, "CVE-2022-26772": {"epss_score": 0.00264, "epss_percentile": 0.49683}, "CVE-2022-26773": {"epss_score": 0.00249, "epss_percentile": 0.48047}, "CVE-2022-26774": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2022-26775": {"epss_score": 0.01025, "epss_percentile": 0.76792}, "CVE-2022-26776": {"epss_score": 0.011, "epss_percentile": 0.77568}, "CVE-2022-26777": {"epss_score": 0.06633, "epss_percentile": 0.90905}, "CVE-2022-26778": {"epss_score": 0.00104, "epss_percentile": 0.29171}, "CVE-2022-26779": {"epss_score": 0.02847, "epss_percentile": 0.85823}, "CVE-2022-26780": {"epss_score": 0.00876, "epss_percentile": 0.74789}, "CVE-2022-26781": {"epss_score": 0.02181, "epss_percentile": 0.83904}, "CVE-2022-26782": {"epss_score": 0.00906, "epss_percentile": 0.75249}, "CVE-2022-26783": {"epss_score": 0.10499, "epss_percentile": 0.93011}, "CVE-2022-26784": {"epss_score": 0.02669, "epss_percentile": 0.85384}, "CVE-2022-26785": {"epss_score": 0.07382, "epss_percentile": 0.91444}, "CVE-2022-26786": {"epss_score": 0.0044, "epss_percentile": 0.6263}, "CVE-2022-26787": {"epss_score": 0.00402, "epss_percentile": 0.60309}, "CVE-2022-26788": {"epss_score": 0.00398, "epss_percentile": 0.60083}, "CVE-2022-26789": {"epss_score": 0.00408, "epss_percentile": 0.60668}, "CVE-2022-26790": {"epss_score": 0.00396, "epss_percentile": 0.59888}, "CVE-2022-26791": {"epss_score": 0.00408, "epss_percentile": 0.60668}, "CVE-2022-26792": {"epss_score": 0.00402, "epss_percentile": 0.60309}, "CVE-2022-26793": {"epss_score": 0.00394, "epss_percentile": 0.59777}, "CVE-2022-26794": {"epss_score": 0.00388, "epss_percentile": 0.594}, "CVE-2022-26795": {"epss_score": 0.00394, "epss_percentile": 0.59777}, "CVE-2022-26796": {"epss_score": 0.0041, "epss_percentile": 0.6082}, "CVE-2022-26797": {"epss_score": 0.00388, "epss_percentile": 0.594}, "CVE-2022-26798": {"epss_score": 0.0059, "epss_percentile": 0.68546}, "CVE-2022-26801": {"epss_score": 0.00402, "epss_percentile": 0.60309}, "CVE-2022-26802": {"epss_score": 0.00402, "epss_percentile": 0.60309}, "CVE-2022-26803": {"epss_score": 0.00583, "epss_percentile": 0.68355}, "CVE-2022-26804": {"epss_score": 0.01576, "epss_percentile": 0.81115}, "CVE-2022-26805": {"epss_score": 0.02297, "epss_percentile": 0.843}, "CVE-2022-26806": {"epss_score": 0.02244, "epss_percentile": 0.84123}, "CVE-2022-26807": {"epss_score": 0.00122, "epss_percentile": 0.3204}, "CVE-2022-26808": {"epss_score": 0.00118, "epss_percentile": 0.31472}, "CVE-2022-26809": {"epss_score": 0.92562, "epss_percentile": 0.99727}, "CVE-2022-26810": {"epss_score": 0.00255, "epss_percentile": 0.48673}, "CVE-2022-26811": {"epss_score": 0.06971, "epss_percentile": 0.91153}, "CVE-2022-26812": {"epss_score": 0.06422, "epss_percentile": 0.9075}, "CVE-2022-26813": {"epss_score": 0.09379, "epss_percentile": 0.92523}, "CVE-2022-26814": {"epss_score": 0.01765, "epss_percentile": 0.82162}, "CVE-2022-26815": {"epss_score": 0.08589, "epss_percentile": 0.92137}, "CVE-2022-26816": {"epss_score": 0.07382, "epss_percentile": 0.91444}, "CVE-2022-26817": {"epss_score": 0.03357, "epss_percentile": 0.86978}, "CVE-2022-26818": {"epss_score": 0.03045, "epss_percentile": 0.86282}, "CVE-2022-26819": {"epss_score": 0.03388, "epss_percentile": 0.87044}, "CVE-2022-26820": {"epss_score": 0.00874, "epss_percentile": 0.7477}, "CVE-2022-26821": {"epss_score": 0.01616, "epss_percentile": 0.81359}, "CVE-2022-26822": {"epss_score": 0.01616, "epss_percentile": 0.81359}, "CVE-2022-26823": {"epss_score": 0.10145, "epss_percentile": 0.92864}, "CVE-2022-26824": {"epss_score": 0.10145, "epss_percentile": 0.92864}, "CVE-2022-26825": {"epss_score": 0.10145, "epss_percentile": 0.92864}, "CVE-2022-26826": {"epss_score": 0.11213, "epss_percentile": 0.93267}, "CVE-2022-26827": {"epss_score": 0.00151, "epss_percentile": 0.3626}, "CVE-2022-26828": {"epss_score": 0.00129, "epss_percentile": 0.33093}, "CVE-2022-26829": {"epss_score": 0.03388, "epss_percentile": 0.87044}, "CVE-2022-26830": {"epss_score": 0.04158, "epss_percentile": 0.88331}, "CVE-2022-26831": {"epss_score": 0.20893, "epss_percentile": 0.95435}, "CVE-2022-26832": {"epss_score": 0.2627, "epss_percentile": 0.96131}, "CVE-2022-26833": {"epss_score": 0.92531, "epss_percentile": 0.99724}, "CVE-2022-26834": {"epss_score": 0.00352, "epss_percentile": 0.5708}, "CVE-2022-26835": {"epss_score": 0.00505, "epss_percentile": 0.65601}, "CVE-2022-26836": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-26837": {"epss_score": 0.00042, "epss_percentile": 0.1283}, "CVE-2022-26838": {"epss_score": 0.00606, "epss_percentile": 0.68999}, "CVE-2022-26839": {"epss_score": 0.00043, "epss_percentile": 0.12967}, "CVE-2022-26840": {"epss_score": 0.00118, "epss_percentile": 0.31413}, "CVE-2022-26841": {"epss_score": 0.00113, "epss_percentile": 0.30686}, "CVE-2022-26842": {"epss_score": 0.09866, "epss_percentile": 0.92744}, "CVE-2022-26843": {"epss_score": 0.0078, "epss_percentile": 0.73162}, "CVE-2022-26844": {"epss_score": 0.00046, "epss_percentile": 0.14077}, "CVE-2022-26845": {"epss_score": 0.00375, "epss_percentile": 0.58605}, "CVE-2022-26846": {"epss_score": 0.01202, "epss_percentile": 0.7849}, "CVE-2022-26847": {"epss_score": 0.0034, "epss_percentile": 0.56271}, "CVE-2022-26850": {"epss_score": 0.01021, "epss_percentile": 0.76753}, "CVE-2022-26851": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-26852": {"epss_score": 0.01429, "epss_percentile": 0.80225}, "CVE-2022-26854": {"epss_score": 0.002, "epss_percentile": 0.42225}, "CVE-2022-26855": {"epss_score": 0.00033, "epss_percentile": 0.09158}, "CVE-2022-26856": {"epss_score": 0.00042, "epss_percentile": 0.12714}, "CVE-2022-26857": {"epss_score": 0.0025, "epss_percentile": 0.48122}, "CVE-2022-26858": {"epss_score": 0.00041, "epss_percentile": 0.12367}, "CVE-2022-26859": {"epss_score": 0.00029, "epss_percentile": 0.07655}, "CVE-2022-26860": {"epss_score": 0.00052, "epss_percentile": 0.16573}, "CVE-2022-26861": {"epss_score": 0.00044, "epss_percentile": 0.13523}, "CVE-2022-26862": {"epss_score": 0.00037, "epss_percentile": 0.10633}, "CVE-2022-26863": {"epss_score": 0.00037, "epss_percentile": 0.10633}, "CVE-2022-26864": {"epss_score": 0.00037, "epss_percentile": 0.10633}, "CVE-2022-26865": {"epss_score": 0.00058, "epss_percentile": 0.18365}, "CVE-2022-26866": {"epss_score": 0.00205, "epss_percentile": 0.42742}, "CVE-2022-26867": {"epss_score": 0.0029, "epss_percentile": 0.52143}, "CVE-2022-26868": {"epss_score": 0.00054, "epss_percentile": 0.17105}, "CVE-2022-26869": {"epss_score": 0.02557, "epss_percentile": 0.85097}, "CVE-2022-26870": {"epss_score": 0.00924, "epss_percentile": 0.75514}, "CVE-2022-26871": {"epss_score": 0.13592, "epss_percentile": 0.94004}, "CVE-2022-26872": {"epss_score": 0.00157, "epss_percentile": 0.37025}, "CVE-2022-26873": {"epss_score": 0.00066, "epss_percentile": 0.20942}, "CVE-2022-26874": {"epss_score": 0.0031, "epss_percentile": 0.53778}, "CVE-2022-26877": {"epss_score": 0.00353, "epss_percentile": 0.57143}, "CVE-2022-26878": {"epss_score": 0.00105, "epss_percentile": 0.29343}, "CVE-2022-26884": {"epss_score": 0.0119, "epss_percentile": 0.78379}, "CVE-2022-26885": {"epss_score": 0.00659, "epss_percentile": 0.70512}, "CVE-2022-26887": {"epss_score": 0.00425, "epss_percentile": 0.61712}, "CVE-2022-26888": {"epss_score": 0.00524, "epss_percentile": 0.66326}, "CVE-2022-26889": {"epss_score": 0.00141, "epss_percentile": 0.34855}, "CVE-2022-26890": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2022-26891": {"epss_score": 0.01639, "epss_percentile": 0.81498}, "CVE-2022-26894": {"epss_score": 0.01639, "epss_percentile": 0.81498}, "CVE-2022-26895": {"epss_score": 0.01639, "epss_percentile": 0.81498}, "CVE-2022-26896": {"epss_score": 0.06112, "epss_percentile": 0.90488}, "CVE-2022-26897": {"epss_score": 0.06305, "epss_percentile": 0.9066}, "CVE-2022-26898": {"epss_score": 0.06212, "epss_percentile": 0.90571}, "CVE-2022-26899": {"epss_score": 0.00337, "epss_percentile": 0.56036}, "CVE-2022-26900": {"epss_score": 0.01639, "epss_percentile": 0.81498}, "CVE-2022-26901": {"epss_score": 0.00792, "epss_percentile": 0.73417}, "CVE-2022-26903": {"epss_score": 0.02019, "epss_percentile": 0.8329}, "CVE-2022-26904": {"epss_score": 0.28313, "epss_percentile": 0.96342}, "CVE-2022-26905": {"epss_score": 0.00984, "epss_percentile": 0.76313}, "CVE-2022-26907": {"epss_score": 0.0069, "epss_percentile": 0.71257}, "CVE-2022-26908": {"epss_score": 0.01639, "epss_percentile": 0.81498}, "CVE-2022-26909": {"epss_score": 0.01639, "epss_percentile": 0.81498}, "CVE-2022-26910": {"epss_score": 0.00701, "epss_percentile": 0.71499}, "CVE-2022-26911": {"epss_score": 0.1991, "epss_percentile": 0.95258}, "CVE-2022-26912": {"epss_score": 0.01997, "epss_percentile": 0.83197}, "CVE-2022-26913": {"epss_score": 0.04165, "epss_percentile": 0.88341}, "CVE-2022-26914": {"epss_score": 0.00394, "epss_percentile": 0.59777}, "CVE-2022-26915": {"epss_score": 0.20893, "epss_percentile": 0.95435}, "CVE-2022-26916": {"epss_score": 0.01416, "epss_percentile": 0.80142}, "CVE-2022-26917": {"epss_score": 0.01399, "epss_percentile": 0.79995}, "CVE-2022-26918": {"epss_score": 0.01399, "epss_percentile": 0.79995}, "CVE-2022-26919": {"epss_score": 0.04808, "epss_percentile": 0.89163}, "CVE-2022-26920": {"epss_score": 0.00528, "epss_percentile": 0.66558}, "CVE-2022-26921": {"epss_score": 0.00649, "epss_percentile": 0.70235}, "CVE-2022-26923": {"epss_score": 0.91441, "epss_percentile": 0.99643}, "CVE-2022-26924": {"epss_score": 0.09679, "epss_percentile": 0.92656}, "CVE-2022-26925": {"epss_score": 0.37425, "epss_percentile": 0.97045}, "CVE-2022-26926": {"epss_score": 0.01153, "epss_percentile": 0.78059}, "CVE-2022-26927": {"epss_score": 0.28121, "epss_percentile": 0.96312}, "CVE-2022-26928": {"epss_score": 0.001, "epss_percentile": 0.28479}, "CVE-2022-26929": {"epss_score": 0.04913, "epss_percentile": 0.89282}, "CVE-2022-26930": {"epss_score": 0.01173, "epss_percentile": 0.78238}, "CVE-2022-26931": {"epss_score": 0.01707, "epss_percentile": 0.81863}, "CVE-2022-26932": {"epss_score": 0.00304, "epss_percentile": 0.53295}, "CVE-2022-26933": {"epss_score": 0.00511, "epss_percentile": 0.65844}, "CVE-2022-26934": {"epss_score": 0.16671, "epss_percentile": 0.94712}, "CVE-2022-26935": {"epss_score": 0.0049, "epss_percentile": 0.6494}, "CVE-2022-26936": {"epss_score": 0.17166, "epss_percentile": 0.94791}, "CVE-2022-26937": {"epss_score": 0.65583, "epss_percentile": 0.98426}, "CVE-2022-26938": {"epss_score": 0.00246, "epss_percentile": 0.47752}, "CVE-2022-26939": {"epss_score": 0.00246, "epss_percentile": 0.47752}, "CVE-2022-26940": {"epss_score": 0.15611, "epss_percentile": 0.94469}, "CVE-2022-26941": {"epss_score": 0.00134, "epss_percentile": 0.33825}, "CVE-2022-26942": {"epss_score": 0.00058, "epss_percentile": 0.18408}, "CVE-2022-26943": {"epss_score": 0.00165, "epss_percentile": 0.38012}, "CVE-2022-26944": {"epss_score": 0.00389, "epss_percentile": 0.59476}, "CVE-2022-26945": {"epss_score": 0.00078, "epss_percentile": 0.23739}, "CVE-2022-26947": {"epss_score": 0.0023, "epss_percentile": 0.45681}, "CVE-2022-26948": {"epss_score": 0.00256, "epss_percentile": 0.48823}, "CVE-2022-26949": {"epss_score": 0.00206, "epss_percentile": 0.42951}, "CVE-2022-26950": {"epss_score": 0.00134, "epss_percentile": 0.33858}, "CVE-2022-26951": {"epss_score": 0.00494, "epss_percentile": 0.65092}, "CVE-2022-26952": {"epss_score": 0.01345, "epss_percentile": 0.79621}, "CVE-2022-26953": {"epss_score": 0.00659, "epss_percentile": 0.70512}, "CVE-2022-26954": {"epss_score": 0.00282, "epss_percentile": 0.51283}, "CVE-2022-26959": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-26960": {"epss_score": 0.79151, "epss_percentile": 0.99021}, "CVE-2022-26964": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2022-26965": {"epss_score": 0.20453, "epss_percentile": 0.95346}, "CVE-2022-26966": {"epss_score": 0.00034, "epss_percentile": 0.09459}, "CVE-2022-26967": {"epss_score": 0.00099, "epss_percentile": 0.2841}, "CVE-2022-26969": {"epss_score": 0.00909, "epss_percentile": 0.75312}, "CVE-2022-26971": {"epss_score": 0.00172, "epss_percentile": 0.39036}, "CVE-2022-26972": {"epss_score": 0.00337, "epss_percentile": 0.56057}, "CVE-2022-26973": {"epss_score": 0.00206, "epss_percentile": 0.43053}, "CVE-2022-26974": {"epss_score": 0.00337, "epss_percentile": 0.56057}, "CVE-2022-26975": {"epss_score": 0.0023, "epss_percentile": 0.45743}, "CVE-2022-26976": {"epss_score": 0.00322, "epss_percentile": 0.54802}, "CVE-2022-26977": {"epss_score": 0.00337, "epss_percentile": 0.56057}, "CVE-2022-26978": {"epss_score": 0.00337, "epss_percentile": 0.56057}, "CVE-2022-26979": {"epss_score": 0.0047, "epss_percentile": 0.63974}, "CVE-2022-26980": {"epss_score": 0.00459, "epss_percentile": 0.63469}, "CVE-2022-26981": {"epss_score": 0.00344, "epss_percentile": 0.56524}, "CVE-2022-26982": {"epss_score": 0.08009, "epss_percentile": 0.91825}, "CVE-2022-26986": {"epss_score": 0.01565, "epss_percentile": 0.81065}, "CVE-2022-26987": {"epss_score": 0.00536, "epss_percentile": 0.66866}, "CVE-2022-26988": {"epss_score": 0.00536, "epss_percentile": 0.66866}, "CVE-2022-26990": {"epss_score": 0.09563, "epss_percentile": 0.92602}, "CVE-2022-26991": {"epss_score": 0.09563, "epss_percentile": 0.92602}, "CVE-2022-26992": {"epss_score": 0.09563, "epss_percentile": 0.92602}, "CVE-2022-26993": {"epss_score": 0.09563, "epss_percentile": 0.92602}, "CVE-2022-26994": {"epss_score": 0.09563, "epss_percentile": 0.92602}, "CVE-2022-26995": {"epss_score": 0.1381, "epss_percentile": 0.94063}, "CVE-2022-26996": {"epss_score": 0.1381, "epss_percentile": 0.94063}, "CVE-2022-26997": {"epss_score": 0.1381, "epss_percentile": 0.94063}, "CVE-2022-26998": {"epss_score": 0.1381, "epss_percentile": 0.94063}, "CVE-2022-26999": {"epss_score": 0.1381, "epss_percentile": 0.94063}, "CVE-2022-27000": {"epss_score": 0.1381, "epss_percentile": 0.94063}, "CVE-2022-27001": {"epss_score": 0.1381, "epss_percentile": 0.94063}, "CVE-2022-27002": {"epss_score": 0.02327, "epss_percentile": 0.84393}, "CVE-2022-27003": {"epss_score": 0.30651, "epss_percentile": 0.9656}, "CVE-2022-27004": {"epss_score": 0.30651, "epss_percentile": 0.9656}, "CVE-2022-27005": {"epss_score": 0.45939, "epss_percentile": 0.97511}, "CVE-2022-27007": {"epss_score": 0.00469, "epss_percentile": 0.63958}, "CVE-2022-27008": {"epss_score": 0.00419, "epss_percentile": 0.61364}, "CVE-2022-27016": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-27022": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-27041": {"epss_score": 0.00435, "epss_percentile": 0.62339}, "CVE-2022-27043": {"epss_score": 0.20915, "epss_percentile": 0.95442}, "CVE-2022-27044": {"epss_score": 0.00352, "epss_percentile": 0.57095}, "CVE-2022-27046": {"epss_score": 0.00332, "epss_percentile": 0.55577}, "CVE-2022-27047": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2022-27048": {"epss_score": 0.00313, "epss_percentile": 0.5403}, "CVE-2022-27049": {"epss_score": 0.00065, "epss_percentile": 0.20448}, "CVE-2022-27050": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2022-27052": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2022-27055": {"epss_score": 0.00515, "epss_percentile": 0.66009}, "CVE-2022-27061": {"epss_score": 0.03075, "epss_percentile": 0.86358}, "CVE-2022-27062": {"epss_score": 0.00675, "epss_percentile": 0.70908}, "CVE-2022-27063": {"epss_score": 0.007, "epss_percentile": 0.71469}, "CVE-2022-27064": {"epss_score": 0.02515, "epss_percentile": 0.84983}, "CVE-2022-27076": {"epss_score": 0.14056, "epss_percentile": 0.94124}, "CVE-2022-27077": {"epss_score": 0.15655, "epss_percentile": 0.94477}, "CVE-2022-27078": {"epss_score": 0.15655, "epss_percentile": 0.94477}, "CVE-2022-27079": {"epss_score": 0.15655, "epss_percentile": 0.94477}, "CVE-2022-27080": {"epss_score": 0.14056, "epss_percentile": 0.94124}, "CVE-2022-27081": {"epss_score": 0.14056, "epss_percentile": 0.94124}, "CVE-2022-27082": {"epss_score": 0.15655, "epss_percentile": 0.94477}, "CVE-2022-27083": {"epss_score": 0.14056, "epss_percentile": 0.94124}, "CVE-2022-27088": {"epss_score": 0.00141, "epss_percentile": 0.34939}, "CVE-2022-27089": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2022-27090": {"epss_score": 0.00134, "epss_percentile": 0.33869}, "CVE-2022-27094": {"epss_score": 0.00145, "epss_percentile": 0.35353}, "CVE-2022-27095": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2022-27103": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2022-27104": {"epss_score": 0.01003, "epss_percentile": 0.7652}, "CVE-2022-27105": {"epss_score": 0.00474, "epss_percentile": 0.64112}, "CVE-2022-27107": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-27108": {"epss_score": 0.00134, "epss_percentile": 0.33787}, "CVE-2022-27109": {"epss_score": 0.00134, "epss_percentile": 0.33869}, "CVE-2022-27110": {"epss_score": 0.00134, "epss_percentile": 0.33869}, "CVE-2022-27111": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-27114": {"epss_score": 0.00122, "epss_percentile": 0.32174}, "CVE-2022-27115": {"epss_score": 0.14781, "epss_percentile": 0.94283}, "CVE-2022-27123": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-27124": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-27125": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-27126": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-27127": {"epss_score": 0.00189, "epss_percentile": 0.40937}, "CVE-2022-27128": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2022-27129": {"epss_score": 0.00944, "epss_percentile": 0.75788}, "CVE-2022-27131": {"epss_score": 0.00944, "epss_percentile": 0.75788}, "CVE-2022-27133": {"epss_score": 0.00346, "epss_percentile": 0.56608}, "CVE-2022-27134": {"epss_score": 0.03213, "epss_percentile": 0.86659}, "CVE-2022-27135": {"epss_score": 0.00209, "epss_percentile": 0.43313}, "CVE-2022-27139": {"epss_score": 0.06063, "epss_percentile": 0.90445}, "CVE-2022-27140": {"epss_score": 0.0048, "epss_percentile": 0.64478}, "CVE-2022-27145": {"epss_score": 0.00095, "epss_percentile": 0.27166}, "CVE-2022-27146": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2022-27147": {"epss_score": 0.00083, "epss_percentile": 0.24818}, "CVE-2022-27148": {"epss_score": 0.00286, "epss_percentile": 0.51762}, "CVE-2022-27152": {"epss_score": 0.00067, "epss_percentile": 0.20994}, "CVE-2022-27156": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-27157": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2022-27158": {"epss_score": 0.00611, "epss_percentile": 0.69197}, "CVE-2022-27161": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-27162": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-27163": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-27164": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-27165": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-27166": {"epss_score": 0.08595, "epss_percentile": 0.92142}, "CVE-2022-27167": {"epss_score": 0.00034, "epss_percentile": 0.09634}, "CVE-2022-27168": {"epss_score": 0.00421, "epss_percentile": 0.61501}, "CVE-2022-27169": {"epss_score": 0.00596, "epss_percentile": 0.68709}, "CVE-2022-27170": {"epss_score": 0.00092, "epss_percentile": 0.2648}, "CVE-2022-27172": {"epss_score": 0.00361, "epss_percentile": 0.57729}, "CVE-2022-27174": {"epss_score": 0.00098, "epss_percentile": 0.27707}, "CVE-2022-27175": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2022-27176": {"epss_score": 0.00217, "epss_percentile": 0.44276}, "CVE-2022-27177": {"epss_score": 0.02136, "epss_percentile": 0.8373}, "CVE-2022-27178": {"epss_score": 0.00335, "epss_percentile": 0.55832}, "CVE-2022-27179": {"epss_score": 0.00171, "epss_percentile": 0.38854}, "CVE-2022-27180": {"epss_score": 0.00048, "epss_percentile": 0.14962}, "CVE-2022-27181": {"epss_score": 0.00628, "epss_percentile": 0.69654}, "CVE-2022-27182": {"epss_score": 0.00868, "epss_percentile": 0.7467}, "CVE-2022-27183": {"epss_score": 0.00581, "epss_percentile": 0.68271}, "CVE-2022-27184": {"epss_score": 0.00302, "epss_percentile": 0.53099}, "CVE-2022-27185": {"epss_score": 0.00292, "epss_percentile": 0.52216}, "CVE-2022-27187": {"epss_score": 0.00205, "epss_percentile": 0.42747}, "CVE-2022-27188": {"epss_score": 0.00542, "epss_percentile": 0.67062}, "CVE-2022-27189": {"epss_score": 0.00891, "epss_percentile": 0.75047}, "CVE-2022-27191": {"epss_score": 0.00089, "epss_percentile": 0.25889}, "CVE-2022-27192": {"epss_score": 0.00964, "epss_percentile": 0.76038}, "CVE-2022-27193": {"epss_score": 0.00196, "epss_percentile": 0.41801}, "CVE-2022-27194": {"epss_score": 0.00161, "epss_percentile": 0.37527}, "CVE-2022-27195": {"epss_score": 0.01207, "epss_percentile": 0.78529}, "CVE-2022-27196": {"epss_score": 0.15725, "epss_percentile": 0.94493}, "CVE-2022-27197": {"epss_score": 0.01105, "epss_percentile": 0.7761}, "CVE-2022-27198": {"epss_score": 0.0008, "epss_percentile": 0.2418}, "CVE-2022-27199": {"epss_score": 0.00543, "epss_percentile": 0.67106}, "CVE-2022-27200": {"epss_score": 0.05287, "epss_percentile": 0.89694}, "CVE-2022-27201": {"epss_score": 0.0075, "epss_percentile": 0.72618}, "CVE-2022-27202": {"epss_score": 0.14252, "epss_percentile": 0.94174}, "CVE-2022-27203": {"epss_score": 0.00566, "epss_percentile": 0.67808}, "CVE-2022-27204": {"epss_score": 0.0008, "epss_percentile": 0.2418}, "CVE-2022-27205": {"epss_score": 0.00543, "epss_percentile": 0.67106}, "CVE-2022-27206": {"epss_score": 0.00468, "epss_percentile": 0.6391}, "CVE-2022-27207": {"epss_score": 0.05287, "epss_percentile": 0.89694}, "CVE-2022-27208": {"epss_score": 0.00617, "epss_percentile": 0.69354}, "CVE-2022-27209": {"epss_score": 0.00752, "epss_percentile": 0.72664}, "CVE-2022-27210": {"epss_score": 0.00088, "epss_percentile": 0.25709}, "CVE-2022-27211": {"epss_score": 0.00752, "epss_percentile": 0.72664}, "CVE-2022-27212": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-27213": {"epss_score": 0.14252, "epss_percentile": 0.94174}, "CVE-2022-27214": {"epss_score": 0.00098, "epss_percentile": 0.27708}, "CVE-2022-27215": {"epss_score": 0.00906, "epss_percentile": 0.75252}, "CVE-2022-27216": {"epss_score": 0.00599, "epss_percentile": 0.68792}, "CVE-2022-27217": {"epss_score": 0.00435, "epss_percentile": 0.62339}, "CVE-2022-27218": {"epss_score": 0.00462, "epss_percentile": 0.63573}, "CVE-2022-27219": {"epss_score": 0.00177, "epss_percentile": 0.39568}, "CVE-2022-27220": {"epss_score": 0.00177, "epss_percentile": 0.39568}, "CVE-2022-27221": {"epss_score": 0.00368, "epss_percentile": 0.58222}, "CVE-2022-27223": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2022-27224": {"epss_score": 0.13416, "epss_percentile": 0.93956}, "CVE-2022-27225": {"epss_score": 0.00187, "epss_percentile": 0.40713}, "CVE-2022-27226": {"epss_score": 0.02536, "epss_percentile": 0.85038}, "CVE-2022-27227": {"epss_score": 0.00109, "epss_percentile": 0.30021}, "CVE-2022-27228": {"epss_score": 0.91597, "epss_percentile": 0.99656}, "CVE-2022-27229": {"epss_score": 0.00096, "epss_percentile": 0.27367}, "CVE-2022-27230": {"epss_score": 0.00735, "epss_percentile": 0.7229}, "CVE-2022-27231": {"epss_score": 0.00307, "epss_percentile": 0.53506}, "CVE-2022-27233": {"epss_score": 0.00911, "epss_percentile": 0.75324}, "CVE-2022-27234": {"epss_score": 0.00178, "epss_percentile": 0.39728}, "CVE-2022-27235": {"epss_score": 0.00615, "epss_percentile": 0.69299}, "CVE-2022-27237": {"epss_score": 0.00495, "epss_percentile": 0.65111}, "CVE-2022-27238": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-27239": {"epss_score": 0.00045, "epss_percentile": 0.13724}, "CVE-2022-27240": {"epss_score": 0.00315, "epss_percentile": 0.54201}, "CVE-2022-27241": {"epss_score": 0.00537, "epss_percentile": 0.66892}, "CVE-2022-27242": {"epss_score": 0.00063, "epss_percentile": 0.19854}, "CVE-2022-27243": {"epss_score": 0.00218, "epss_percentile": 0.44399}, "CVE-2022-27244": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-27245": {"epss_score": 0.00332, "epss_percentile": 0.55609}, "CVE-2022-27246": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-27247": {"epss_score": 0.00213, "epss_percentile": 0.43947}, "CVE-2022-27248": {"epss_score": 0.00333, "epss_percentile": 0.55676}, "CVE-2022-27249": {"epss_score": 0.05243, "epss_percentile": 0.89654}, "CVE-2022-27250": {"epss_score": 0.00357, "epss_percentile": 0.5746}, "CVE-2022-27254": {"epss_score": 0.03825, "epss_percentile": 0.87791}, "CVE-2022-27255": {"epss_score": 0.25164, "epss_percentile": 0.95992}, "CVE-2022-27256": {"epss_score": 0.00503, "epss_percentile": 0.65467}, "CVE-2022-27257": {"epss_score": 0.00329, "epss_percentile": 0.55392}, "CVE-2022-27258": {"epss_score": 0.00307, "epss_percentile": 0.53532}, "CVE-2022-27260": {"epss_score": 0.00618, "epss_percentile": 0.69368}, "CVE-2022-27261": {"epss_score": 0.00377, "epss_percentile": 0.58715}, "CVE-2022-27262": {"epss_score": 0.01003, "epss_percentile": 0.76522}, "CVE-2022-27263": {"epss_score": 0.01713, "epss_percentile": 0.81891}, "CVE-2022-27268": {"epss_score": 0.00788, "epss_percentile": 0.73332}, "CVE-2022-27269": {"epss_score": 0.00845, "epss_percentile": 0.74291}, "CVE-2022-27270": {"epss_score": 0.01345, "epss_percentile": 0.79624}, "CVE-2022-27271": {"epss_score": 0.01345, "epss_percentile": 0.79624}, "CVE-2022-27272": {"epss_score": 0.01345, "epss_percentile": 0.79624}, "CVE-2022-27273": {"epss_score": 0.01345, "epss_percentile": 0.79624}, "CVE-2022-27274": {"epss_score": 0.01345, "epss_percentile": 0.79624}, "CVE-2022-27275": {"epss_score": 0.01345, "epss_percentile": 0.79624}, "CVE-2022-27276": {"epss_score": 0.01345, "epss_percentile": 0.79624}, "CVE-2022-27277": {"epss_score": 0.00889, "epss_percentile": 0.75019}, "CVE-2022-27279": {"epss_score": 0.00419, "epss_percentile": 0.61376}, "CVE-2022-27280": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-27286": {"epss_score": 0.00275, "epss_percentile": 0.50677}, "CVE-2022-27287": {"epss_score": 0.00275, "epss_percentile": 0.50677}, "CVE-2022-27288": {"epss_score": 0.00376, "epss_percentile": 0.58645}, "CVE-2022-27289": {"epss_score": 0.00376, "epss_percentile": 0.58645}, "CVE-2022-27290": {"epss_score": 0.00376, "epss_percentile": 0.58645}, "CVE-2022-27291": {"epss_score": 0.00376, "epss_percentile": 0.58645}, "CVE-2022-27292": {"epss_score": 0.00295, "epss_percentile": 0.52496}, "CVE-2022-27293": {"epss_score": 0.00436, "epss_percentile": 0.62482}, "CVE-2022-27294": {"epss_score": 0.00436, "epss_percentile": 0.62482}, "CVE-2022-27295": {"epss_score": 0.0043, "epss_percentile": 0.62014}, "CVE-2022-27299": {"epss_score": 0.00218, "epss_percentile": 0.44369}, "CVE-2022-27304": {"epss_score": 0.00409, "epss_percentile": 0.60753}, "CVE-2022-27305": {"epss_score": 0.00332, "epss_percentile": 0.55567}, "CVE-2022-27308": {"epss_score": 0.00526, "epss_percentile": 0.66429}, "CVE-2022-27311": {"epss_score": 0.00271, "epss_percentile": 0.50329}, "CVE-2022-27313": {"epss_score": 0.00525, "epss_percentile": 0.66376}, "CVE-2022-27330": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-27331": {"epss_score": 0.0026, "epss_percentile": 0.49163}, "CVE-2022-27332": {"epss_score": 0.00434, "epss_percentile": 0.6231}, "CVE-2022-27333": {"epss_score": 0.00198, "epss_percentile": 0.42035}, "CVE-2022-27336": {"epss_score": 0.03592, "epss_percentile": 0.87401}, "CVE-2022-27337": {"epss_score": 0.00212, "epss_percentile": 0.43751}, "CVE-2022-27340": {"epss_score": 0.003, "epss_percentile": 0.52964}, "CVE-2022-27341": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-27342": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-27346": {"epss_score": 0.02939, "epss_percentile": 0.8603}, "CVE-2022-27348": {"epss_score": 0.00675, "epss_percentile": 0.70908}, "CVE-2022-27349": {"epss_score": 0.03075, "epss_percentile": 0.86358}, "CVE-2022-27351": {"epss_score": 0.02902, "epss_percentile": 0.85956}, "CVE-2022-27352": {"epss_score": 0.02515, "epss_percentile": 0.84983}, "CVE-2022-27357": {"epss_score": 0.03388, "epss_percentile": 0.87044}, "CVE-2022-27359": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2022-27360": {"epss_score": 0.00625, "epss_percentile": 0.69596}, "CVE-2022-27365": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2022-27366": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2022-27367": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2022-27368": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2022-27369": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2022-27373": {"epss_score": 0.32452, "epss_percentile": 0.96701}, "CVE-2022-27374": {"epss_score": 0.00107, "epss_percentile": 0.29587}, "CVE-2022-27375": {"epss_score": 0.00107, "epss_percentile": 0.29587}, "CVE-2022-27376": {"epss_score": 0.00298, "epss_percentile": 0.52806}, "CVE-2022-27377": {"epss_score": 0.00298, "epss_percentile": 0.52806}, "CVE-2022-27378": {"epss_score": 0.00333, "epss_percentile": 0.55674}, "CVE-2022-27379": {"epss_score": 0.00333, "epss_percentile": 0.55674}, "CVE-2022-27380": {"epss_score": 0.00453, "epss_percentile": 0.63205}, "CVE-2022-27381": {"epss_score": 0.00333, "epss_percentile": 0.55674}, "CVE-2022-27382": {"epss_score": 0.00167, "epss_percentile": 0.38319}, "CVE-2022-27383": {"epss_score": 0.00219, "epss_percentile": 0.44523}, "CVE-2022-27384": {"epss_score": 0.00333, "epss_percentile": 0.55674}, "CVE-2022-27385": {"epss_score": 0.00263, "epss_percentile": 0.49546}, "CVE-2022-27386": {"epss_score": 0.00267, "epss_percentile": 0.49956}, "CVE-2022-27387": {"epss_score": 0.00188, "epss_percentile": 0.40869}, "CVE-2022-27404": {"epss_score": 0.00124, "epss_percentile": 0.32345}, "CVE-2022-27405": {"epss_score": 0.00092, "epss_percentile": 0.26458}, "CVE-2022-27406": {"epss_score": 0.00152, "epss_percentile": 0.36419}, "CVE-2022-27411": {"epss_score": 0.0463, "epss_percentile": 0.88944}, "CVE-2022-27412": {"epss_score": 0.01134, "epss_percentile": 0.77887}, "CVE-2022-27413": {"epss_score": 0.12018, "epss_percentile": 0.93548}, "CVE-2022-27416": {"epss_score": 0.0019, "epss_percentile": 0.41086}, "CVE-2022-27418": {"epss_score": 0.00178, "epss_percentile": 0.3974}, "CVE-2022-27419": {"epss_score": 0.00302, "epss_percentile": 0.53166}, "CVE-2022-27420": {"epss_score": 0.00203, "epss_percentile": 0.42496}, "CVE-2022-27421": {"epss_score": 0.00615, "epss_percentile": 0.69311}, "CVE-2022-27422": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-27423": {"epss_score": 0.00714, "epss_percentile": 0.71816}, "CVE-2022-27425": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-27426": {"epss_score": 0.00395, "epss_percentile": 0.59807}, "CVE-2022-27428": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-27429": {"epss_score": 0.00316, "epss_percentile": 0.54221}, "CVE-2022-27431": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-27432": {"epss_score": 0.00136, "epss_percentile": 0.34119}, "CVE-2022-27434": {"epss_score": 0.01503, "epss_percentile": 0.80727}, "CVE-2022-27435": {"epss_score": 0.00606, "epss_percentile": 0.69003}, "CVE-2022-27436": {"epss_score": 0.00464, "epss_percentile": 0.63712}, "CVE-2022-27438": {"epss_score": 0.12274, "epss_percentile": 0.93619}, "CVE-2022-27441": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2022-27442": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2022-27444": {"epss_score": 0.00172, "epss_percentile": 0.38937}, "CVE-2022-27445": {"epss_score": 0.00312, "epss_percentile": 0.53937}, "CVE-2022-27446": {"epss_score": 0.00187, "epss_percentile": 0.40708}, "CVE-2022-27447": {"epss_score": 0.00219, "epss_percentile": 0.44523}, "CVE-2022-27448": {"epss_score": 0.00172, "epss_percentile": 0.38991}, "CVE-2022-27449": {"epss_score": 0.00187, "epss_percentile": 0.40754}, "CVE-2022-27451": {"epss_score": 0.00102, "epss_percentile": 0.28825}, "CVE-2022-27452": {"epss_score": 0.00127, "epss_percentile": 0.32806}, "CVE-2022-27455": {"epss_score": 0.00102, "epss_percentile": 0.28825}, "CVE-2022-27456": {"epss_score": 0.00127, "epss_percentile": 0.32806}, "CVE-2022-27457": {"epss_score": 0.00102, "epss_percentile": 0.28825}, "CVE-2022-27461": {"epss_score": 0.00204, "epss_percentile": 0.42649}, "CVE-2022-27462": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-27463": {"epss_score": 0.002, "epss_percentile": 0.42196}, "CVE-2022-27466": {"epss_score": 0.00402, "epss_percentile": 0.60291}, "CVE-2022-27468": {"epss_score": 0.01003, "epss_percentile": 0.76522}, "CVE-2022-27469": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2022-27470": {"epss_score": 0.00153, "epss_percentile": 0.3652}, "CVE-2022-27472": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-27473": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-27474": {"epss_score": 0.03956, "epss_percentile": 0.88005}, "CVE-2022-27475": {"epss_score": 0.00396, "epss_percentile": 0.59908}, "CVE-2022-27476": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-27477": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2022-27478": {"epss_score": 0.03213, "epss_percentile": 0.86658}, "CVE-2022-27479": {"epss_score": 0.04979, "epss_percentile": 0.89358}, "CVE-2022-27480": {"epss_score": 0.00362, "epss_percentile": 0.57773}, "CVE-2022-27481": {"epss_score": 0.00195, "epss_percentile": 0.41664}, "CVE-2022-27482": {"epss_score": 0.002, "epss_percentile": 0.42197}, "CVE-2022-27483": {"epss_score": 0.05366, "epss_percentile": 0.89789}, "CVE-2022-27484": {"epss_score": 0.00133, "epss_percentile": 0.33726}, "CVE-2022-27485": {"epss_score": 0.00487, "epss_percentile": 0.64828}, "CVE-2022-27486": {"epss_score": 0.00501, "epss_percentile": 0.65356}, "CVE-2022-27487": {"epss_score": 0.00965, "epss_percentile": 0.7604}, "CVE-2022-27488": {"epss_score": 0.00442, "epss_percentile": 0.62755}, "CVE-2022-27489": {"epss_score": 0.00458, "epss_percentile": 0.63437}, "CVE-2022-27490": {"epss_score": 0.00271, "epss_percentile": 0.50302}, "CVE-2022-27491": {"epss_score": 0.00054, "epss_percentile": 0.17295}, "CVE-2022-27492": {"epss_score": 0.01661, "epss_percentile": 0.81621}, "CVE-2022-27493": {"epss_score": 0.00097, "epss_percentile": 0.27591}, "CVE-2022-27494": {"epss_score": 0.00663, "epss_percentile": 0.70622}, "CVE-2022-27495": {"epss_score": 0.00114, "epss_percentile": 0.30746}, "CVE-2022-27496": {"epss_score": 0.00103, "epss_percentile": 0.29087}, "CVE-2022-27497": {"epss_score": 0.00296, "epss_percentile": 0.52601}, "CVE-2022-27498": {"epss_score": 0.48375, "epss_percentile": 0.97635}, "CVE-2022-27499": {"epss_score": 0.02556, "epss_percentile": 0.85091}, "CVE-2022-27500": {"epss_score": 0.00039, "epss_percentile": 0.11578}, "CVE-2022-27502": {"epss_score": 0.00371, "epss_percentile": 0.58373}, "CVE-2022-27503": {"epss_score": 0.00587, "epss_percentile": 0.68473}, "CVE-2022-27505": {"epss_score": 0.00587, "epss_percentile": 0.68473}, "CVE-2022-27506": {"epss_score": 0.00168, "epss_percentile": 0.38415}, "CVE-2022-27507": {"epss_score": 0.00654, "epss_percentile": 0.70348}, "CVE-2022-27508": {"epss_score": 0.00629, "epss_percentile": 0.69677}, "CVE-2022-27509": {"epss_score": 0.00331, "epss_percentile": 0.55531}, "CVE-2022-27510": {"epss_score": 0.00546, "epss_percentile": 0.67215}, "CVE-2022-27511": {"epss_score": 0.20032, "epss_percentile": 0.95277}, "CVE-2022-27512": {"epss_score": 0.00883, "epss_percentile": 0.74917}, "CVE-2022-27513": {"epss_score": 0.0035, "epss_percentile": 0.5695}, "CVE-2022-27516": {"epss_score": 0.00106, "epss_percentile": 0.29457}, "CVE-2022-27518": {"epss_score": 0.22959, "epss_percentile": 0.9571}, "CVE-2022-27523": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2022-27524": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2022-27525": {"epss_score": 0.00343, "epss_percentile": 0.56461}, "CVE-2022-27526": {"epss_score": 0.00343, "epss_percentile": 0.56461}, "CVE-2022-27527": {"epss_score": 0.00068, "epss_percentile": 0.21237}, "CVE-2022-27528": {"epss_score": 0.00678, "epss_percentile": 0.70981}, "CVE-2022-27529": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2022-27530": {"epss_score": 0.0075, "epss_percentile": 0.72622}, "CVE-2022-27531": {"epss_score": 0.00343, "epss_percentile": 0.56461}, "CVE-2022-27532": {"epss_score": 0.00318, "epss_percentile": 0.5444}, "CVE-2022-27534": {"epss_score": 0.00604, "epss_percentile": 0.68942}, "CVE-2022-27535": {"epss_score": 0.00197, "epss_percentile": 0.41828}, "CVE-2022-27536": {"epss_score": 0.00336, "epss_percentile": 0.55996}, "CVE-2022-27537": {"epss_score": 0.0029, "epss_percentile": 0.52116}, "CVE-2022-27538": {"epss_score": 0.00128, "epss_percentile": 0.33045}, "CVE-2022-27539": {"epss_score": 0.00144, "epss_percentile": 0.35265}, "CVE-2022-27540": {"epss_score": 0.00062, "epss_percentile": 0.19673}, "CVE-2022-27541": {"epss_score": 0.00144, "epss_percentile": 0.35265}, "CVE-2022-27544": {"epss_score": 0.0019, "epss_percentile": 0.41091}, "CVE-2022-27545": {"epss_score": 0.00273, "epss_percentile": 0.50436}, "CVE-2022-27546": {"epss_score": 0.00236, "epss_percentile": 0.46426}, "CVE-2022-27547": {"epss_score": 0.00235, "epss_percentile": 0.46219}, "CVE-2022-27548": {"epss_score": 0.00097, "epss_percentile": 0.27532}, "CVE-2022-27549": {"epss_score": 0.00023, "epss_percentile": 0.05518}, "CVE-2022-27551": {"epss_score": 0.0018, "epss_percentile": 0.39888}, "CVE-2022-27558": {"epss_score": 0.00222, "epss_percentile": 0.44795}, "CVE-2022-27560": {"epss_score": 0.00161, "epss_percentile": 0.3758}, "CVE-2022-27561": {"epss_score": 0.0088, "epss_percentile": 0.74853}, "CVE-2022-27562": {"epss_score": 0.00052, "epss_percentile": 0.16669}, "CVE-2022-27563": {"epss_score": 0.0098, "epss_percentile": 0.76265}, "CVE-2022-27567": {"epss_score": 0.00298, "epss_percentile": 0.52784}, "CVE-2022-27568": {"epss_score": 0.0117, "epss_percentile": 0.78212}, "CVE-2022-27569": {"epss_score": 0.0117, "epss_percentile": 0.78212}, "CVE-2022-27570": {"epss_score": 0.0117, "epss_percentile": 0.78212}, "CVE-2022-27571": {"epss_score": 0.0117, "epss_percentile": 0.78212}, "CVE-2022-27572": {"epss_score": 0.0117, "epss_percentile": 0.78212}, "CVE-2022-27573": {"epss_score": 0.00131, "epss_percentile": 0.3346}, "CVE-2022-27574": {"epss_score": 0.00131, "epss_percentile": 0.33381}, "CVE-2022-27575": {"epss_score": 0.00057, "epss_percentile": 0.18005}, "CVE-2022-27576": {"epss_score": 0.0006, "epss_percentile": 0.18984}, "CVE-2022-27577": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2022-27578": {"epss_score": 0.00058, "epss_percentile": 0.18259}, "CVE-2022-27579": {"epss_score": 0.00184, "epss_percentile": 0.40373}, "CVE-2022-27580": {"epss_score": 0.00184, "epss_percentile": 0.40373}, "CVE-2022-27581": {"epss_score": 0.00068, "epss_percentile": 0.21256}, "CVE-2022-27582": {"epss_score": 0.00752, "epss_percentile": 0.72657}, "CVE-2022-27583": {"epss_score": 0.00335, "epss_percentile": 0.55859}, "CVE-2022-27584": {"epss_score": 0.00752, "epss_percentile": 0.72657}, "CVE-2022-27585": {"epss_score": 0.00882, "epss_percentile": 0.74895}, "CVE-2022-27586": {"epss_score": 0.00752, "epss_percentile": 0.72657}, "CVE-2022-27588": {"epss_score": 0.00947, "epss_percentile": 0.75815}, "CVE-2022-27592": {"epss_score": 0.00038, "epss_percentile": 0.11213}, "CVE-2022-27593": {"epss_score": 0.93262, "epss_percentile": 0.9979}, "CVE-2022-27595": {"epss_score": 0.00087, "epss_percentile": 0.25528}, "CVE-2022-27596": {"epss_score": 0.18942, "epss_percentile": 0.951}, "CVE-2022-27597": {"epss_score": 0.00238, "epss_percentile": 0.46751}, "CVE-2022-27598": {"epss_score": 0.00277, "epss_percentile": 0.50814}, "CVE-2022-27599": {"epss_score": 0.00022, "epss_percentile": 0.05038}, "CVE-2022-27600": {"epss_score": 0.00752, "epss_percentile": 0.72658}, "CVE-2022-27607": {"epss_score": 0.00457, "epss_percentile": 0.63355}, "CVE-2022-27608": {"epss_score": 0.00043, "epss_percentile": 0.13343}, "CVE-2022-27609": {"epss_score": 0.00039, "epss_percentile": 0.11455}, "CVE-2022-27610": {"epss_score": 0.01317, "epss_percentile": 0.79412}, "CVE-2022-27611": {"epss_score": 0.01014, "epss_percentile": 0.76644}, "CVE-2022-27612": {"epss_score": 0.01926, "epss_percentile": 0.82925}, "CVE-2022-27613": {"epss_score": 0.00575, "epss_percentile": 0.68106}, "CVE-2022-27614": {"epss_score": 0.00185, "epss_percentile": 0.40515}, "CVE-2022-27615": {"epss_score": 0.00702, "epss_percentile": 0.71519}, "CVE-2022-27616": {"epss_score": 0.01623, "epss_percentile": 0.81401}, "CVE-2022-27617": {"epss_score": 0.00128, "epss_percentile": 0.33037}, "CVE-2022-27618": {"epss_score": 0.00489, "epss_percentile": 0.64908}, "CVE-2022-27619": {"epss_score": 0.00096, "epss_percentile": 0.27343}, "CVE-2022-27620": {"epss_score": 0.0021, "epss_percentile": 0.43449}, "CVE-2022-27621": {"epss_score": 0.00175, "epss_percentile": 0.39267}, "CVE-2022-27622": {"epss_score": 0.00139, "epss_percentile": 0.34611}, "CVE-2022-27623": {"epss_score": 0.00333, "epss_percentile": 0.55639}, "CVE-2022-27624": {"epss_score": 0.01081, "epss_percentile": 0.77374}, "CVE-2022-27625": {"epss_score": 0.01074, "epss_percentile": 0.77296}, "CVE-2022-27626": {"epss_score": 0.01385, "epss_percentile": 0.79905}, "CVE-2022-27627": {"epss_score": 0.00332, "epss_percentile": 0.55583}, "CVE-2022-27628": {"epss_score": 0.00075, "epss_percentile": 0.23026}, "CVE-2022-27629": {"epss_score": 0.00135, "epss_percentile": 0.34041}, "CVE-2022-27630": {"epss_score": 0.00371, "epss_percentile": 0.58388}, "CVE-2022-27631": {"epss_score": 0.02389, "epss_percentile": 0.84591}, "CVE-2022-27632": {"epss_score": 0.00094, "epss_percentile": 0.27005}, "CVE-2022-27633": {"epss_score": 0.00461, "epss_percentile": 0.6355}, "CVE-2022-27634": {"epss_score": 0.00598, "epss_percentile": 0.68755}, "CVE-2022-27635": {"epss_score": 0.00028, "epss_percentile": 0.07575}, "CVE-2022-27636": {"epss_score": 0.00215, "epss_percentile": 0.44059}, "CVE-2022-27637": {"epss_score": 0.00214, "epss_percentile": 0.4402}, "CVE-2022-27638": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2022-27639": {"epss_score": 0.00205, "epss_percentile": 0.42755}, "CVE-2022-27640": {"epss_score": 0.0025, "epss_percentile": 0.48254}, "CVE-2022-27641": {"epss_score": 0.00166, "epss_percentile": 0.38179}, "CVE-2022-27642": {"epss_score": 0.00036, "epss_percentile": 0.10518}, "CVE-2022-27643": {"epss_score": 0.05186, "epss_percentile": 0.89589}, "CVE-2022-27644": {"epss_score": 0.00109, "epss_percentile": 0.30036}, "CVE-2022-27645": {"epss_score": 0.00114, "epss_percentile": 0.30783}, "CVE-2022-27646": {"epss_score": 0.01252, "epss_percentile": 0.789}, "CVE-2022-27647": {"epss_score": 0.00048, "epss_percentile": 0.15003}, "CVE-2022-27648": {"epss_score": 0.0246, "epss_percentile": 0.8482}, "CVE-2022-27649": {"epss_score": 0.00583, "epss_percentile": 0.68348}, "CVE-2022-27650": {"epss_score": 0.00089, "epss_percentile": 0.2594}, "CVE-2022-27651": {"epss_score": 0.00165, "epss_percentile": 0.38021}, "CVE-2022-27652": {"epss_score": 0.00021, "epss_percentile": 0.04867}, "CVE-2022-27653": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-27654": {"epss_score": 0.00207, "epss_percentile": 0.43133}, "CVE-2022-27655": {"epss_score": 0.00281, "epss_percentile": 0.5115}, "CVE-2022-27656": {"epss_score": 0.00395, "epss_percentile": 0.5985}, "CVE-2022-27657": {"epss_score": 0.00287, "epss_percentile": 0.51833}, "CVE-2022-27658": {"epss_score": 0.0024, "epss_percentile": 0.47203}, "CVE-2022-27659": {"epss_score": 0.00172, "epss_percentile": 0.38993}, "CVE-2022-27660": {"epss_score": 0.00469, "epss_percentile": 0.63933}, "CVE-2022-27661": {"epss_score": 0.00193, "epss_percentile": 0.41486}, "CVE-2022-27662": {"epss_score": 0.00177, "epss_percentile": 0.39549}, "CVE-2022-27664": {"epss_score": 0.00093, "epss_percentile": 0.26666}, "CVE-2022-27665": {"epss_score": 0.01258, "epss_percentile": 0.78954}, "CVE-2022-27666": {"epss_score": 0.00797, "epss_percentile": 0.73497}, "CVE-2022-27667": {"epss_score": 0.0085, "epss_percentile": 0.74391}, "CVE-2022-27668": {"epss_score": 0.02529, "epss_percentile": 0.85022}, "CVE-2022-27669": {"epss_score": 0.00702, "epss_percentile": 0.71508}, "CVE-2022-27670": {"epss_score": 0.00621, "epss_percentile": 0.69485}, "CVE-2022-27671": {"epss_score": 0.00774, "epss_percentile": 0.73065}, "CVE-2022-27672": {"epss_score": 0.00106, "epss_percentile": 0.29561}, "CVE-2022-27673": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2022-27674": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-27677": {"epss_score": 0.00057, "epss_percentile": 0.18103}, "CVE-2022-27772": {"epss_score": 0.00826, "epss_percentile": 0.73974}, "CVE-2022-27773": {"epss_score": 0.06879, "epss_percentile": 0.91089}, "CVE-2022-27774": {"epss_score": 0.00535, "epss_percentile": 0.66831}, "CVE-2022-27775": {"epss_score": 0.00143, "epss_percentile": 0.35108}, "CVE-2022-27776": {"epss_score": 0.00682, "epss_percentile": 0.71064}, "CVE-2022-27777": {"epss_score": 0.01155, "epss_percentile": 0.78071}, "CVE-2022-27778": {"epss_score": 0.00859, "epss_percentile": 0.74517}, "CVE-2022-27779": {"epss_score": 0.00273, "epss_percentile": 0.50423}, "CVE-2022-27780": {"epss_score": 0.00125, "epss_percentile": 0.32532}, "CVE-2022-27781": {"epss_score": 0.00077, "epss_percentile": 0.23432}, "CVE-2022-27782": {"epss_score": 0.00439, "epss_percentile": 0.62598}, "CVE-2022-27783": {"epss_score": 0.03112, "epss_percentile": 0.86426}, "CVE-2022-27784": {"epss_score": 0.03112, "epss_percentile": 0.86426}, "CVE-2022-27785": {"epss_score": 0.05005, "epss_percentile": 0.89384}, "CVE-2022-27786": {"epss_score": 0.05005, "epss_percentile": 0.89384}, "CVE-2022-27787": {"epss_score": 0.01963, "epss_percentile": 0.83073}, "CVE-2022-27788": {"epss_score": 0.02214, "epss_percentile": 0.84026}, "CVE-2022-27789": {"epss_score": 0.05614, "epss_percentile": 0.90053}, "CVE-2022-27790": {"epss_score": 0.05005, "epss_percentile": 0.89384}, "CVE-2022-27791": {"epss_score": 0.01612, "epss_percentile": 0.81334}, "CVE-2022-27792": {"epss_score": 0.01963, "epss_percentile": 0.83073}, "CVE-2022-27793": {"epss_score": 0.01963, "epss_percentile": 0.83073}, "CVE-2022-27794": {"epss_score": 0.01193, "epss_percentile": 0.78408}, "CVE-2022-27795": {"epss_score": 0.05614, "epss_percentile": 0.90053}, "CVE-2022-27796": {"epss_score": 0.05005, "epss_percentile": 0.89384}, "CVE-2022-27797": {"epss_score": 0.05614, "epss_percentile": 0.90053}, "CVE-2022-27798": {"epss_score": 0.02214, "epss_percentile": 0.84026}, "CVE-2022-27799": {"epss_score": 0.05614, "epss_percentile": 0.90053}, "CVE-2022-27800": {"epss_score": 0.05614, "epss_percentile": 0.90053}, "CVE-2022-27801": {"epss_score": 0.05614, "epss_percentile": 0.90053}, "CVE-2022-27802": {"epss_score": 0.05614, "epss_percentile": 0.90053}, "CVE-2022-27803": {"epss_score": 0.00163, "epss_percentile": 0.37794}, "CVE-2022-27804": {"epss_score": 0.00758, "epss_percentile": 0.72777}, "CVE-2022-27805": {"epss_score": 0.00642, "epss_percentile": 0.70039}, "CVE-2022-27806": {"epss_score": 0.00661, "epss_percentile": 0.70577}, "CVE-2022-27807": {"epss_score": 0.00163, "epss_percentile": 0.37794}, "CVE-2022-27808": {"epss_score": 0.00057, "epss_percentile": 0.18172}, "CVE-2022-27810": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-27811": {"epss_score": 0.03359, "epss_percentile": 0.86981}, "CVE-2022-27812": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-27813": {"epss_score": 0.00047, "epss_percentile": 0.14631}, "CVE-2022-27814": {"epss_score": 0.00065, "epss_percentile": 0.20455}, "CVE-2022-27815": {"epss_score": 0.00103, "epss_percentile": 0.28989}, "CVE-2022-27816": {"epss_score": 0.00119, "epss_percentile": 0.31685}, "CVE-2022-27817": {"epss_score": 0.00068, "epss_percentile": 0.21355}, "CVE-2022-27818": {"epss_score": 0.00486, "epss_percentile": 0.64749}, "CVE-2022-27819": {"epss_score": 0.00233, "epss_percentile": 0.46001}, "CVE-2022-27820": {"epss_score": 0.00136, "epss_percentile": 0.34135}, "CVE-2022-27821": {"epss_score": 0.0005, "epss_percentile": 0.15847}, "CVE-2022-27822": {"epss_score": 0.00018, "epss_percentile": 0.03828}, "CVE-2022-27823": {"epss_score": 0.0006, "epss_percentile": 0.191}, "CVE-2022-27824": {"epss_score": 0.0006, "epss_percentile": 0.191}, "CVE-2022-27825": {"epss_score": 0.0006, "epss_percentile": 0.191}, "CVE-2022-27826": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2022-27827": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2022-27828": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2022-27829": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2022-27830": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2022-27831": {"epss_score": 0.00018, "epss_percentile": 0.03527}, "CVE-2022-27832": {"epss_score": 0.00017, "epss_percentile": 0.0319}, "CVE-2022-27833": {"epss_score": 0.00016, "epss_percentile": 0.02982}, "CVE-2022-27834": {"epss_score": 0.00015, "epss_percentile": 0.026}, "CVE-2022-27835": {"epss_score": 0.00041, "epss_percentile": 0.12314}, "CVE-2022-27836": {"epss_score": 0.00012, "epss_percentile": 0.01219}, "CVE-2022-27837": {"epss_score": 0.00303, "epss_percentile": 0.53237}, "CVE-2022-27838": {"epss_score": 0.00041, "epss_percentile": 0.12459}, "CVE-2022-27839": {"epss_score": 0.00161, "epss_percentile": 0.37606}, "CVE-2022-27840": {"epss_score": 0.00045, "epss_percentile": 0.1382}, "CVE-2022-27841": {"epss_score": 0.00061, "epss_percentile": 0.19374}, "CVE-2022-27842": {"epss_score": 0.00058, "epss_percentile": 0.18421}, "CVE-2022-27843": {"epss_score": 0.00058, "epss_percentile": 0.18421}, "CVE-2022-27844": {"epss_score": 0.00879, "epss_percentile": 0.74838}, "CVE-2022-27845": {"epss_score": 0.00498, "epss_percentile": 0.65224}, "CVE-2022-27846": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-27847": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-27848": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2022-27849": {"epss_score": 0.12777, "epss_percentile": 0.93771}, "CVE-2022-27850": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-27851": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-27852": {"epss_score": 0.0031, "epss_percentile": 0.53804}, "CVE-2022-27853": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2022-27854": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2022-27855": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-27856": {"epss_score": 0.00049, "epss_percentile": 0.15604}, "CVE-2022-27858": {"epss_score": 0.01159, "epss_percentile": 0.78123}, "CVE-2022-27859": {"epss_score": 0.00836, "epss_percentile": 0.7413}, "CVE-2022-27860": {"epss_score": 0.00099, "epss_percentile": 0.27841}, "CVE-2022-27861": {"epss_score": 0.00082, "epss_percentile": 0.2443}, "CVE-2022-27862": {"epss_score": 0.01174, "epss_percentile": 0.78252}, "CVE-2022-27863": {"epss_score": 0.00495, "epss_percentile": 0.65123}, "CVE-2022-27864": {"epss_score": 0.00855, "epss_percentile": 0.74466}, "CVE-2022-27865": {"epss_score": 0.00059, "epss_percentile": 0.18677}, "CVE-2022-27866": {"epss_score": 0.00059, "epss_percentile": 0.18677}, "CVE-2022-27867": {"epss_score": 0.00515, "epss_percentile": 0.65975}, "CVE-2022-27868": {"epss_score": 0.00515, "epss_percentile": 0.65975}, "CVE-2022-27869": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2022-27870": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-27871": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2022-27872": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-27873": {"epss_score": 0.0005, "epss_percentile": 0.15823}, "CVE-2022-27874": {"epss_score": 0.00176, "epss_percentile": 0.39444}, "CVE-2022-27875": {"epss_score": 0.00304, "epss_percentile": 0.53241}, "CVE-2022-27878": {"epss_score": 0.00424, "epss_percentile": 0.61654}, "CVE-2022-27879": {"epss_score": 0.00025, "epss_percentile": 0.06364}, "CVE-2022-27880": {"epss_score": 0.00177, "epss_percentile": 0.39549}, "CVE-2022-27881": {"epss_score": 0.01083, "epss_percentile": 0.77388}, "CVE-2022-27882": {"epss_score": 0.00908, "epss_percentile": 0.75281}, "CVE-2022-27883": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2022-27884": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-27885": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-27886": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-27887": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-27888": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2022-27889": {"epss_score": 0.00395, "epss_percentile": 0.59848}, "CVE-2022-27890": {"epss_score": 0.00125, "epss_percentile": 0.32511}, "CVE-2022-27891": {"epss_score": 0.00213, "epss_percentile": 0.43911}, "CVE-2022-27892": {"epss_score": 0.0011, "epss_percentile": 0.30156}, "CVE-2022-27893": {"epss_score": 0.00058, "epss_percentile": 0.18357}, "CVE-2022-27894": {"epss_score": 0.00208, "epss_percentile": 0.43223}, "CVE-2022-27895": {"epss_score": 0.00207, "epss_percentile": 0.43079}, "CVE-2022-27896": {"epss_score": 0.00207, "epss_percentile": 0.43079}, "CVE-2022-27897": {"epss_score": 0.0011, "epss_percentile": 0.30156}, "CVE-2022-27903": {"epss_score": 0.05831, "epss_percentile": 0.90244}, "CVE-2022-27904": {"epss_score": 0.00085, "epss_percentile": 0.25229}, "CVE-2022-27905": {"epss_score": 0.0035, "epss_percentile": 0.56939}, "CVE-2022-27906": {"epss_score": 0.004, "epss_percentile": 0.60173}, "CVE-2022-27907": {"epss_score": 0.00149, "epss_percentile": 0.35948}, "CVE-2022-27908": {"epss_score": 0.07343, "epss_percentile": 0.9142}, "CVE-2022-27909": {"epss_score": 0.00164, "epss_percentile": 0.37904}, "CVE-2022-27910": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-27911": {"epss_score": 6e-05, "epss_percentile": 0.00318}, "CVE-2022-27912": {"epss_score": 6e-05, "epss_percentile": 0.00318}, "CVE-2022-27913": {"epss_score": 0.00147, "epss_percentile": 0.35686}, "CVE-2022-27914": {"epss_score": 0.00085, "epss_percentile": 0.25103}, "CVE-2022-27919": {"epss_score": 0.02148, "epss_percentile": 0.83769}, "CVE-2022-27920": {"epss_score": 0.0028, "epss_percentile": 0.51084}, "CVE-2022-27924": {"epss_score": 0.91955, "epss_percentile": 0.99681}, "CVE-2022-27925": {"epss_score": 0.9431, "epss_percentile": 0.99943}, "CVE-2022-27926": {"epss_score": 0.94248, "epss_percentile": 0.99925}, "CVE-2022-27927": {"epss_score": 0.7453, "epss_percentile": 0.98807}, "CVE-2022-27928": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2022-27929": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2022-27930": {"epss_score": 0.0056, "epss_percentile": 0.67639}, "CVE-2022-27931": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2022-27932": {"epss_score": 0.0056, "epss_percentile": 0.67639}, "CVE-2022-27933": {"epss_score": 0.00534, "epss_percentile": 0.66781}, "CVE-2022-27934": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2022-27935": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2022-27936": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2022-27937": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2022-27938": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2022-27939": {"epss_score": 0.00224, "epss_percentile": 0.4507}, "CVE-2022-27940": {"epss_score": 0.00264, "epss_percentile": 0.497}, "CVE-2022-27941": {"epss_score": 0.00264, "epss_percentile": 0.497}, "CVE-2022-27942": {"epss_score": 0.00264, "epss_percentile": 0.497}, "CVE-2022-27943": {"epss_score": 0.0005, "epss_percentile": 0.15708}, "CVE-2022-27944": {"epss_score": 0.0047, "epss_percentile": 0.63974}, "CVE-2022-27945": {"epss_score": 0.06442, "epss_percentile": 0.9076}, "CVE-2022-27946": {"epss_score": 0.01362, "epss_percentile": 0.79757}, "CVE-2022-27947": {"epss_score": 0.06442, "epss_percentile": 0.9076}, "CVE-2022-27948": {"epss_score": 0.00255, "epss_percentile": 0.48724}, "CVE-2022-27949": {"epss_score": 0.01636, "epss_percentile": 0.8148}, "CVE-2022-27950": {"epss_score": 0.0005, "epss_percentile": 0.15974}, "CVE-2022-27952": {"epss_score": 0.01003, "epss_percentile": 0.76522}, "CVE-2022-27958": {"epss_score": 0.00124, "epss_percentile": 0.32378}, "CVE-2022-27960": {"epss_score": 0.00109, "epss_percentile": 0.29985}, "CVE-2022-27961": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-27962": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-27963": {"epss_score": 0.00064, "epss_percentile": 0.20137}, "CVE-2022-27964": {"epss_score": 0.00067, "epss_percentile": 0.21026}, "CVE-2022-27965": {"epss_score": 0.00067, "epss_percentile": 0.21026}, "CVE-2022-27966": {"epss_score": 0.00067, "epss_percentile": 0.21026}, "CVE-2022-27967": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2022-27968": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2022-27969": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2022-27978": {"epss_score": 0.00223, "epss_percentile": 0.44878}, "CVE-2022-27979": {"epss_score": 0.00172, "epss_percentile": 0.39016}, "CVE-2022-27982": {"epss_score": 0.02307, "epss_percentile": 0.84328}, "CVE-2022-27983": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2022-27984": {"epss_score": 0.24054, "epss_percentile": 0.9585}, "CVE-2022-27985": {"epss_score": 0.24054, "epss_percentile": 0.9585}, "CVE-2022-27991": {"epss_score": 0.00241, "epss_percentile": 0.47252}, "CVE-2022-27992": {"epss_score": 0.00316, "epss_percentile": 0.54236}, "CVE-2022-28000": {"epss_score": 0.00316, "epss_percentile": 0.54236}, "CVE-2022-28001": {"epss_score": 0.00477, "epss_percentile": 0.64304}, "CVE-2022-28002": {"epss_score": 0.00415, "epss_percentile": 0.61131}, "CVE-2022-28005": {"epss_score": 0.12464, "epss_percentile": 0.93681}, "CVE-2022-28006": {"epss_score": 0.00359, "epss_percentile": 0.57595}, "CVE-2022-28007": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-28008": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-28009": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-28010": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-28011": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-28012": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-28013": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-28014": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-28015": {"epss_score": 0.003, "epss_percentile": 0.52943}, "CVE-2022-28016": {"epss_score": 0.003, "epss_percentile": 0.52943}, "CVE-2022-28017": {"epss_score": 0.003, "epss_percentile": 0.52943}, "CVE-2022-28018": {"epss_score": 0.003, "epss_percentile": 0.52943}, "CVE-2022-28019": {"epss_score": 0.003, "epss_percentile": 0.52943}, "CVE-2022-28020": {"epss_score": 0.003, "epss_percentile": 0.52943}, "CVE-2022-28021": {"epss_score": 0.13885, "epss_percentile": 0.94085}, "CVE-2022-28022": {"epss_score": 0.08554, "epss_percentile": 0.92121}, "CVE-2022-28023": {"epss_score": 0.08554, "epss_percentile": 0.92121}, "CVE-2022-28024": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2022-28025": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2022-28026": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2022-28028": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2022-28029": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2022-28030": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2022-28032": {"epss_score": 0.46835, "epss_percentile": 0.97559}, "CVE-2022-28033": {"epss_score": 0.58383, "epss_percentile": 0.98113}, "CVE-2022-28034": {"epss_score": 0.00508, "epss_percentile": 0.65682}, "CVE-2022-28035": {"epss_score": 0.00508, "epss_percentile": 0.65682}, "CVE-2022-28036": {"epss_score": 0.00508, "epss_percentile": 0.65682}, "CVE-2022-28041": {"epss_score": 0.01031, "epss_percentile": 0.76856}, "CVE-2022-28042": {"epss_score": 0.00309, "epss_percentile": 0.53688}, "CVE-2022-28044": {"epss_score": 0.00271, "epss_percentile": 0.50274}, "CVE-2022-28048": {"epss_score": 0.00152, "epss_percentile": 0.36447}, "CVE-2022-28049": {"epss_score": 0.00164, "epss_percentile": 0.3787}, "CVE-2022-28051": {"epss_score": 0.00611, "epss_percentile": 0.69202}, "CVE-2022-28052": {"epss_score": 0.02037, "epss_percentile": 0.83356}, "CVE-2022-28053": {"epss_score": 0.00782, "epss_percentile": 0.73198}, "CVE-2022-28054": {"epss_score": 0.01403, "epss_percentile": 0.80032}, "CVE-2022-28055": {"epss_score": 0.05327, "epss_percentile": 0.89736}, "CVE-2022-28056": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2022-28058": {"epss_score": 0.00605, "epss_percentile": 0.68969}, "CVE-2022-28059": {"epss_score": 0.00605, "epss_percentile": 0.68969}, "CVE-2022-28060": {"epss_score": 0.00323, "epss_percentile": 0.54893}, "CVE-2022-28062": {"epss_score": 0.00919, "epss_percentile": 0.7546}, "CVE-2022-28063": {"epss_score": 0.00329, "epss_percentile": 0.5532}, "CVE-2022-28067": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2022-28068": {"epss_score": 0.00135, "epss_percentile": 0.33973}, "CVE-2022-28069": {"epss_score": 0.00135, "epss_percentile": 0.33973}, "CVE-2022-28070": {"epss_score": 0.00075, "epss_percentile": 0.22965}, "CVE-2022-28071": {"epss_score": 0.00074, "epss_percentile": 0.22779}, "CVE-2022-28072": {"epss_score": 0.00441, "epss_percentile": 0.62668}, "CVE-2022-28073": {"epss_score": 0.00365, "epss_percentile": 0.57962}, "CVE-2022-28074": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2022-28076": {"epss_score": 0.05231, "epss_percentile": 0.89638}, "CVE-2022-28077": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-28078": {"epss_score": 0.0104, "epss_percentile": 0.76959}, "CVE-2022-28079": {"epss_score": 0.83475, "epss_percentile": 0.9925}, "CVE-2022-28080": {"epss_score": 0.7711, "epss_percentile": 0.98922}, "CVE-2022-28081": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-28082": {"epss_score": 0.00631, "epss_percentile": 0.69711}, "CVE-2022-28085": {"epss_score": 0.00206, "epss_percentile": 0.42942}, "CVE-2022-28090": {"epss_score": 0.00996, "epss_percentile": 0.76448}, "CVE-2022-28093": {"epss_score": 0.01201, "epss_percentile": 0.78481}, "CVE-2022-28094": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2022-28096": {"epss_score": 0.0288, "epss_percentile": 0.85898}, "CVE-2022-28099": {"epss_score": 0.00812, "epss_percentile": 0.73744}, "CVE-2022-28101": {"epss_score": 0.0052, "epss_percentile": 0.662}, "CVE-2022-28102": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2022-28104": {"epss_score": 0.00576, "epss_percentile": 0.68144}, "CVE-2022-28105": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-28106": {"epss_score": 0.00364, "epss_percentile": 0.57924}, "CVE-2022-28108": {"epss_score": 0.70347, "epss_percentile": 0.98629}, "CVE-2022-28109": {"epss_score": 0.00349, "epss_percentile": 0.56902}, "CVE-2022-28110": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-28111": {"epss_score": 0.00524, "epss_percentile": 0.66324}, "CVE-2022-28113": {"epss_score": 0.08782, "epss_percentile": 0.92252}, "CVE-2022-28114": {"epss_score": 0.00346, "epss_percentile": 0.56608}, "CVE-2022-28115": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-28116": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-28117": {"epss_score": 0.67131, "epss_percentile": 0.98496}, "CVE-2022-28118": {"epss_score": 0.04041, "epss_percentile": 0.88166}, "CVE-2022-28120": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2022-28126": {"epss_score": 0.00145, "epss_percentile": 0.35424}, "CVE-2022-28127": {"epss_score": 0.05308, "epss_percentile": 0.89715}, "CVE-2022-28128": {"epss_score": 0.0008, "epss_percentile": 0.24018}, "CVE-2022-28129": {"epss_score": 0.00291, "epss_percentile": 0.52181}, "CVE-2022-28131": {"epss_score": 0.00013, "epss_percentile": 0.01536}, "CVE-2022-28132": {"epss_score": 0.00059, "epss_percentile": 0.18709}, "CVE-2022-28133": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-28134": {"epss_score": 0.00906, "epss_percentile": 0.75252}, "CVE-2022-28135": {"epss_score": 0.00641, "epss_percentile": 0.69992}, "CVE-2022-28136": {"epss_score": 0.00072, "epss_percentile": 0.22403}, "CVE-2022-28137": {"epss_score": 0.01319, "epss_percentile": 0.79434}, "CVE-2022-28138": {"epss_score": 0.00064, "epss_percentile": 0.20167}, "CVE-2022-28139": {"epss_score": 0.00543, "epss_percentile": 0.67106}, "CVE-2022-28140": {"epss_score": 0.09171, "epss_percentile": 0.92431}, "CVE-2022-28141": {"epss_score": 0.00547, "epss_percentile": 0.67227}, "CVE-2022-28142": {"epss_score": 0.00063, "epss_percentile": 0.19911}, "CVE-2022-28143": {"epss_score": 0.00059, "epss_percentile": 0.18618}, "CVE-2022-28144": {"epss_score": 0.00127, "epss_percentile": 0.32931}, "CVE-2022-28145": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-28146": {"epss_score": 0.00617, "epss_percentile": 0.69354}, "CVE-2022-28147": {"epss_score": 0.00497, "epss_percentile": 0.65192}, "CVE-2022-28148": {"epss_score": 0.00261, "epss_percentile": 0.49246}, "CVE-2022-28149": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-28150": {"epss_score": 0.00048, "epss_percentile": 0.15118}, "CVE-2022-28151": {"epss_score": 0.00362, "epss_percentile": 0.5776}, "CVE-2022-28152": {"epss_score": 0.00064, "epss_percentile": 0.20167}, "CVE-2022-28153": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-28154": {"epss_score": 0.09171, "epss_percentile": 0.92431}, "CVE-2022-28155": {"epss_score": 0.09171, "epss_percentile": 0.92431}, "CVE-2022-28156": {"epss_score": 0.00617, "epss_percentile": 0.69354}, "CVE-2022-28157": {"epss_score": 0.00802, "epss_percentile": 0.73589}, "CVE-2022-28158": {"epss_score": 0.00403, "epss_percentile": 0.60323}, "CVE-2022-28159": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-28160": {"epss_score": 0.01143, "epss_percentile": 0.77981}, "CVE-2022-28161": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2022-28162": {"epss_score": 0.00024, "epss_percentile": 0.05736}, "CVE-2022-28163": {"epss_score": 0.00608, "epss_percentile": 0.69079}, "CVE-2022-28164": {"epss_score": 0.00085, "epss_percentile": 0.25057}, "CVE-2022-28165": {"epss_score": 0.00764, "epss_percentile": 0.72899}, "CVE-2022-28166": {"epss_score": 0.0014, "epss_percentile": 0.34684}, "CVE-2022-28167": {"epss_score": 0.00215, "epss_percentile": 0.44054}, "CVE-2022-28168": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2022-28169": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2022-28170": {"epss_score": 0.00057, "epss_percentile": 0.18034}, "CVE-2022-28171": {"epss_score": 0.84105, "epss_percentile": 0.99274}, "CVE-2022-28172": {"epss_score": 0.00697, "epss_percentile": 0.71401}, "CVE-2022-28173": {"epss_score": 0.00314, "epss_percentile": 0.54118}, "CVE-2022-28181": {"epss_score": 0.01091, "epss_percentile": 0.7746}, "CVE-2022-28182": {"epss_score": 0.01143, "epss_percentile": 0.77981}, "CVE-2022-28183": {"epss_score": 0.00163, "epss_percentile": 0.37773}, "CVE-2022-28184": {"epss_score": 0.00121, "epss_percentile": 0.31823}, "CVE-2022-28185": {"epss_score": 0.00106, "epss_percentile": 0.29447}, "CVE-2022-28186": {"epss_score": 0.0005, "epss_percentile": 0.15925}, "CVE-2022-28187": {"epss_score": 0.00045, "epss_percentile": 0.1405}, "CVE-2022-28188": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2022-28189": {"epss_score": 0.00122, "epss_percentile": 0.3215}, "CVE-2022-28190": {"epss_score": 0.00122, "epss_percentile": 0.3215}, "CVE-2022-28191": {"epss_score": 0.00068, "epss_percentile": 0.21286}, "CVE-2022-28192": {"epss_score": 0.00092, "epss_percentile": 0.26505}, "CVE-2022-28193": {"epss_score": 0.00195, "epss_percentile": 0.41656}, "CVE-2022-28194": {"epss_score": 0.00083, "epss_percentile": 0.24609}, "CVE-2022-28195": {"epss_score": 0.00062, "epss_percentile": 0.1974}, "CVE-2022-28196": {"epss_score": 0.00242, "epss_percentile": 0.47361}, "CVE-2022-28197": {"epss_score": 0.00062, "epss_percentile": 0.1974}, "CVE-2022-28198": {"epss_score": 0.00068, "epss_percentile": 0.21237}, "CVE-2022-28199": {"epss_score": 0.00779, "epss_percentile": 0.73141}, "CVE-2022-28200": {"epss_score": 0.00059, "epss_percentile": 0.18619}, "CVE-2022-28201": {"epss_score": 0.00067, "epss_percentile": 0.21073}, "CVE-2022-28202": {"epss_score": 0.00527, "epss_percentile": 0.66529}, "CVE-2022-28203": {"epss_score": 0.00418, "epss_percentile": 0.61291}, "CVE-2022-28204": {"epss_score": 0.00383, "epss_percentile": 0.59098}, "CVE-2022-28205": {"epss_score": 0.00341, "epss_percentile": 0.56325}, "CVE-2022-28206": {"epss_score": 0.00355, "epss_percentile": 0.57261}, "CVE-2022-28209": {"epss_score": 0.00359, "epss_percentile": 0.57541}, "CVE-2022-28213": {"epss_score": 0.12617, "epss_percentile": 0.9373}, "CVE-2022-28214": {"epss_score": 0.00025, "epss_percentile": 0.0634}, "CVE-2022-28215": {"epss_score": 0.00424, "epss_percentile": 0.61658}, "CVE-2022-28216": {"epss_score": 0.02311, "epss_percentile": 0.84339}, "CVE-2022-28217": {"epss_score": 0.00257, "epss_percentile": 0.48847}, "CVE-2022-28218": {"epss_score": 0.00064, "epss_percentile": 0.2013}, "CVE-2022-28219": {"epss_score": 0.94202, "epss_percentile": 0.99917}, "CVE-2022-28220": {"epss_score": 0.01851, "epss_percentile": 0.82535}, "CVE-2022-28221": {"epss_score": 0.01195, "epss_percentile": 0.78427}, "CVE-2022-28222": {"epss_score": 0.00345, "epss_percentile": 0.56555}, "CVE-2022-28223": {"epss_score": 0.00467, "epss_percentile": 0.63829}, "CVE-2022-28224": {"epss_score": 0.0028, "epss_percentile": 0.51044}, "CVE-2022-28225": {"epss_score": 0.00033, "epss_percentile": 0.09349}, "CVE-2022-28226": {"epss_score": 0.0003, "epss_percentile": 0.0814}, "CVE-2022-28228": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2022-28229": {"epss_score": 0.00908, "epss_percentile": 0.75278}, "CVE-2022-28230": {"epss_score": 0.03065, "epss_percentile": 0.86336}, "CVE-2022-28231": {"epss_score": 0.01781, "epss_percentile": 0.8224}, "CVE-2022-28232": {"epss_score": 0.03065, "epss_percentile": 0.86336}, "CVE-2022-28233": {"epss_score": 0.03065, "epss_percentile": 0.86336}, "CVE-2022-28234": {"epss_score": 0.0082, "epss_percentile": 0.7389}, "CVE-2022-28235": {"epss_score": 0.0345, "epss_percentile": 0.87164}, "CVE-2022-28236": {"epss_score": 0.00697, "epss_percentile": 0.71411}, "CVE-2022-28237": {"epss_score": 0.0345, "epss_percentile": 0.87164}, "CVE-2022-28238": {"epss_score": 0.03065, "epss_percentile": 0.86336}, "CVE-2022-28239": {"epss_score": 0.01055, "epss_percentile": 0.77116}, "CVE-2022-28240": {"epss_score": 0.03321, "epss_percentile": 0.86913}, "CVE-2022-28241": {"epss_score": 0.01347, "epss_percentile": 0.79657}, "CVE-2022-28242": {"epss_score": 0.02272, "epss_percentile": 0.84219}, "CVE-2022-28243": {"epss_score": 0.00933, "epss_percentile": 0.75645}, "CVE-2022-28244": {"epss_score": 0.01059, "epss_percentile": 0.77152}, "CVE-2022-28245": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2022-28246": {"epss_score": 0.00862, "epss_percentile": 0.74579}, "CVE-2022-28247": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2022-28248": {"epss_score": 0.00659, "epss_percentile": 0.70501}, "CVE-2022-28249": {"epss_score": 0.00707, "epss_percentile": 0.71658}, "CVE-2022-28250": {"epss_score": 0.01491, "epss_percentile": 0.80634}, "CVE-2022-28251": {"epss_score": 0.00527, "epss_percentile": 0.66441}, "CVE-2022-28252": {"epss_score": 0.01279, "epss_percentile": 0.7913}, "CVE-2022-28253": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2022-28254": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2022-28255": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2022-28256": {"epss_score": 0.01491, "epss_percentile": 0.80634}, "CVE-2022-28257": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2022-28258": {"epss_score": 0.00862, "epss_percentile": 0.74579}, "CVE-2022-28259": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2022-28260": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2022-28261": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2022-28262": {"epss_score": 0.00862, "epss_percentile": 0.74579}, "CVE-2022-28263": {"epss_score": 0.00862, "epss_percentile": 0.74579}, "CVE-2022-28264": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2022-28265": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2022-28266": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2022-28267": {"epss_score": 0.00926, "epss_percentile": 0.75544}, "CVE-2022-28268": {"epss_score": 0.03081, "epss_percentile": 0.86373}, "CVE-2022-28269": {"epss_score": 0.01668, "epss_percentile": 0.81658}, "CVE-2022-28270": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28271": {"epss_score": 0.1143, "epss_percentile": 0.93348}, "CVE-2022-28272": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28273": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28274": {"epss_score": 0.02348, "epss_percentile": 0.84458}, "CVE-2022-28275": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28276": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28277": {"epss_score": 0.03023, "epss_percentile": 0.86229}, "CVE-2022-28278": {"epss_score": 0.00788, "epss_percentile": 0.73344}, "CVE-2022-28279": {"epss_score": 0.0345, "epss_percentile": 0.87164}, "CVE-2022-28281": {"epss_score": 0.11778, "epss_percentile": 0.93472}, "CVE-2022-28282": {"epss_score": 0.07764, "epss_percentile": 0.91666}, "CVE-2022-28283": {"epss_score": 0.00323, "epss_percentile": 0.54917}, "CVE-2022-28284": {"epss_score": 0.00369, "epss_percentile": 0.58262}, "CVE-2022-28285": {"epss_score": 0.00188, "epss_percentile": 0.40843}, "CVE-2022-28286": {"epss_score": 0.0016, "epss_percentile": 0.37432}, "CVE-2022-28287": {"epss_score": 0.00352, "epss_percentile": 0.57103}, "CVE-2022-28288": {"epss_score": 0.00424, "epss_percentile": 0.61669}, "CVE-2022-28289": {"epss_score": 0.00278, "epss_percentile": 0.50882}, "CVE-2022-28290": {"epss_score": 0.01901, "epss_percentile": 0.82777}, "CVE-2022-28291": {"epss_score": 0.00271, "epss_percentile": 0.50336}, "CVE-2022-28300": {"epss_score": 0.02414, "epss_percentile": 0.84683}, "CVE-2022-28301": {"epss_score": 0.02301, "epss_percentile": 0.84312}, "CVE-2022-28302": {"epss_score": 0.02301, "epss_percentile": 0.84312}, "CVE-2022-28303": {"epss_score": 0.02414, "epss_percentile": 0.84683}, "CVE-2022-28304": {"epss_score": 0.01707, "epss_percentile": 0.81859}, "CVE-2022-28305": {"epss_score": 0.01791, "epss_percentile": 0.82285}, "CVE-2022-28306": {"epss_score": 0.01791, "epss_percentile": 0.82285}, "CVE-2022-28307": {"epss_score": 0.02414, "epss_percentile": 0.84683}, "CVE-2022-28308": {"epss_score": 0.00659, "epss_percentile": 0.70517}, "CVE-2022-28309": {"epss_score": 0.00628, "epss_percentile": 0.69652}, "CVE-2022-28310": {"epss_score": 0.02301, "epss_percentile": 0.84312}, "CVE-2022-28311": {"epss_score": 0.02414, "epss_percentile": 0.84683}, "CVE-2022-28312": {"epss_score": 0.00659, "epss_percentile": 0.70517}, "CVE-2022-28313": {"epss_score": 0.00659, "epss_percentile": 0.70517}, "CVE-2022-28314": {"epss_score": 0.02301, "epss_percentile": 0.84312}, "CVE-2022-28315": {"epss_score": 0.01791, "epss_percentile": 0.82285}, "CVE-2022-28316": {"epss_score": 0.02414, "epss_percentile": 0.84683}, "CVE-2022-28317": {"epss_score": 0.02414, "epss_percentile": 0.84683}, "CVE-2022-28318": {"epss_score": 0.02414, "epss_percentile": 0.84683}, "CVE-2022-28319": {"epss_score": 0.03304, "epss_percentile": 0.8687}, "CVE-2022-28320": {"epss_score": 0.03151, "epss_percentile": 0.86505}, "CVE-2022-28321": {"epss_score": 0.00077, "epss_percentile": 0.23458}, "CVE-2022-28323": {"epss_score": 0.0037, "epss_percentile": 0.58329}, "CVE-2022-28327": {"epss_score": 0.00129, "epss_percentile": 0.33149}, "CVE-2022-28328": {"epss_score": 0.00552, "epss_percentile": 0.67393}, "CVE-2022-28329": {"epss_score": 0.00257, "epss_percentile": 0.4887}, "CVE-2022-28330": {"epss_score": 0.00337, "epss_percentile": 0.56067}, "CVE-2022-28331": {"epss_score": 0.00245, "epss_percentile": 0.47635}, "CVE-2022-28339": {"epss_score": 0.00033, "epss_percentile": 0.09201}, "CVE-2022-28345": {"epss_score": 0.01458, "epss_percentile": 0.80406}, "CVE-2022-28346": {"epss_score": 0.04828, "epss_percentile": 0.89187}, "CVE-2022-28347": {"epss_score": 0.00758, "epss_percentile": 0.72771}, "CVE-2022-28348": {"epss_score": 0.00464, "epss_percentile": 0.63732}, "CVE-2022-28349": {"epss_score": 0.00427, "epss_percentile": 0.61874}, "CVE-2022-28350": {"epss_score": 0.00579, "epss_percentile": 0.68234}, "CVE-2022-28352": {"epss_score": 0.00218, "epss_percentile": 0.44387}, "CVE-2022-28353": {"epss_score": 0.00368, "epss_percentile": 0.58198}, "CVE-2022-28354": {"epss_score": 0.00076, "epss_percentile": 0.23229}, "CVE-2022-28355": {"epss_score": 0.00357, "epss_percentile": 0.57479}, "CVE-2022-28356": {"epss_score": 0.0002, "epss_percentile": 0.04534}, "CVE-2022-28357": {"epss_score": 0.00228, "epss_percentile": 0.45518}, "CVE-2022-28363": {"epss_score": 0.0781, "epss_percentile": 0.91694}, "CVE-2022-28364": {"epss_score": 0.00388, "epss_percentile": 0.59369}, "CVE-2022-28365": {"epss_score": 0.40631, "epss_percentile": 0.97228}, "CVE-2022-28366": {"epss_score": 0.00179, "epss_percentile": 0.39779}, "CVE-2022-28367": {"epss_score": 0.00282, "epss_percentile": 0.51276}, "CVE-2022-28368": {"epss_score": 0.72243, "epss_percentile": 0.98701}, "CVE-2022-28369": {"epss_score": 0.01076, "epss_percentile": 0.77329}, "CVE-2022-28370": {"epss_score": 0.00117, "epss_percentile": 0.31214}, "CVE-2022-28371": {"epss_score": 0.00208, "epss_percentile": 0.43297}, "CVE-2022-28372": {"epss_score": 0.00249, "epss_percentile": 0.4802}, "CVE-2022-28373": {"epss_score": 0.04386, "epss_percentile": 0.88632}, "CVE-2022-28374": {"epss_score": 0.04433, "epss_percentile": 0.88682}, "CVE-2022-28375": {"epss_score": 0.04386, "epss_percentile": 0.88632}, "CVE-2022-28376": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2022-28377": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2022-28378": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2022-28379": {"epss_score": 0.00518, "epss_percentile": 0.66124}, "CVE-2022-28380": {"epss_score": 0.00652, "epss_percentile": 0.70305}, "CVE-2022-28381": {"epss_score": 0.79342, "epss_percentile": 0.99034}, "CVE-2022-28382": {"epss_score": 0.00669, "epss_percentile": 0.70756}, "CVE-2022-28383": {"epss_score": 0.00116, "epss_percentile": 0.31079}, "CVE-2022-28384": {"epss_score": 0.00104, "epss_percentile": 0.2916}, "CVE-2022-28385": {"epss_score": 0.00091, "epss_percentile": 0.26402}, "CVE-2022-28386": {"epss_score": 0.00121, "epss_percentile": 0.31919}, "CVE-2022-28387": {"epss_score": 0.00195, "epss_percentile": 0.41656}, "CVE-2022-28388": {"epss_score": 0.00019, "epss_percentile": 0.04286}, "CVE-2022-28389": {"epss_score": 0.00015, "epss_percentile": 0.02538}, "CVE-2022-28390": {"epss_score": 0.00014, "epss_percentile": 0.01859}, "CVE-2022-28391": {"epss_score": 0.02386, "epss_percentile": 0.84581}, "CVE-2022-28394": {"epss_score": 0.00087, "epss_percentile": 0.25582}, "CVE-2022-28397": {"epss_score": 0.04027, "epss_percentile": 0.88143}, "CVE-2022-28410": {"epss_score": 0.00377, "epss_percentile": 0.58749}, "CVE-2022-28411": {"epss_score": 0.00377, "epss_percentile": 0.58749}, "CVE-2022-28412": {"epss_score": 0.00377, "epss_percentile": 0.58749}, "CVE-2022-28413": {"epss_score": 0.00377, "epss_percentile": 0.58749}, "CVE-2022-28414": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-28415": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-28416": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-28417": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28420": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28421": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28422": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28423": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28424": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28425": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28426": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28427": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28429": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28431": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28432": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-28433": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28434": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28435": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28436": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28437": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28438": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28439": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28440": {"epss_score": 0.00932, "epss_percentile": 0.75631}, "CVE-2022-28443": {"epss_score": 0.00346, "epss_percentile": 0.56608}, "CVE-2022-28444": {"epss_score": 0.00419, "epss_percentile": 0.61376}, "CVE-2022-28445": {"epss_score": 0.00288, "epss_percentile": 0.51882}, "CVE-2022-28448": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-28449": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-28450": {"epss_score": 0.00154, "epss_percentile": 0.36698}, "CVE-2022-28451": {"epss_score": 0.00652, "epss_percentile": 0.70305}, "CVE-2022-28452": {"epss_score": 0.07102, "epss_percentile": 0.91253}, "CVE-2022-28454": {"epss_score": 0.00747, "epss_percentile": 0.72564}, "CVE-2022-28461": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-28462": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2022-28463": {"epss_score": 0.00103, "epss_percentile": 0.29077}, "CVE-2022-28464": {"epss_score": 0.01064, "epss_percentile": 0.77199}, "CVE-2022-28467": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28468": {"epss_score": 0.00646, "epss_percentile": 0.7014}, "CVE-2022-28470": {"epss_score": 0.00931, "epss_percentile": 0.75621}, "CVE-2022-28471": {"epss_score": 0.00302, "epss_percentile": 0.53084}, "CVE-2022-28477": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2022-28478": {"epss_score": 0.01278, "epss_percentile": 0.79129}, "CVE-2022-28479": {"epss_score": 0.00558, "epss_percentile": 0.67597}, "CVE-2022-28480": {"epss_score": 0.00436, "epss_percentile": 0.62483}, "CVE-2022-28481": {"epss_score": 0.00424, "epss_percentile": 0.61676}, "CVE-2022-28487": {"epss_score": 0.00469, "epss_percentile": 0.63944}, "CVE-2022-28488": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2022-28491": {"epss_score": 0.00801, "epss_percentile": 0.73568}, "CVE-2022-28492": {"epss_score": 0.00131, "epss_percentile": 0.33482}, "CVE-2022-28493": {"epss_score": 0.00144, "epss_percentile": 0.35317}, "CVE-2022-28494": {"epss_score": 0.00801, "epss_percentile": 0.73568}, "CVE-2022-28495": {"epss_score": 0.00801, "epss_percentile": 0.73568}, "CVE-2022-28496": {"epss_score": 0.00275, "epss_percentile": 0.50687}, "CVE-2022-28497": {"epss_score": 0.00229, "epss_percentile": 0.45655}, "CVE-2022-28505": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2022-28506": {"epss_score": 0.0007, "epss_percentile": 0.21797}, "CVE-2022-28507": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-28508": {"epss_score": 0.01452, "epss_percentile": 0.80366}, "CVE-2022-28512": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28521": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2022-28522": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-28523": {"epss_score": 0.00445, "epss_percentile": 0.62886}, "CVE-2022-28524": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28525": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2022-28527": {"epss_score": 0.00384, "epss_percentile": 0.59158}, "CVE-2022-28528": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2022-28530": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2022-28531": {"epss_score": 0.01913, "epss_percentile": 0.82837}, "CVE-2022-28533": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2022-28541": {"epss_score": 0.00117, "epss_percentile": 0.31303}, "CVE-2022-28542": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2022-28543": {"epss_score": 0.00045, "epss_percentile": 0.1391}, "CVE-2022-28544": {"epss_score": 0.0029, "epss_percentile": 0.52106}, "CVE-2022-28545": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-28550": {"epss_score": 0.00094, "epss_percentile": 0.2679}, "CVE-2022-28552": {"epss_score": 0.00239, "epss_percentile": 0.46936}, "CVE-2022-28556": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2022-28557": {"epss_score": 0.16013, "epss_percentile": 0.94559}, "CVE-2022-28560": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-28561": {"epss_score": 0.00561, "epss_percentile": 0.67672}, "CVE-2022-28568": {"epss_score": 0.01526, "epss_percentile": 0.80865}, "CVE-2022-28571": {"epss_score": 0.17842, "epss_percentile": 0.94915}, "CVE-2022-28572": {"epss_score": 0.17522, "epss_percentile": 0.9486}, "CVE-2022-28573": {"epss_score": 0.47533, "epss_percentile": 0.9759}, "CVE-2022-28575": {"epss_score": 0.20315, "epss_percentile": 0.95324}, "CVE-2022-28577": {"epss_score": 0.20315, "epss_percentile": 0.95324}, "CVE-2022-28578": {"epss_score": 0.20315, "epss_percentile": 0.95324}, "CVE-2022-28579": {"epss_score": 0.20315, "epss_percentile": 0.95324}, "CVE-2022-28580": {"epss_score": 0.20315, "epss_percentile": 0.95324}, "CVE-2022-28581": {"epss_score": 0.20315, "epss_percentile": 0.95324}, "CVE-2022-28582": {"epss_score": 0.20315, "epss_percentile": 0.95324}, "CVE-2022-28583": {"epss_score": 0.20315, "epss_percentile": 0.95324}, "CVE-2022-28584": {"epss_score": 0.20315, "epss_percentile": 0.95324}, "CVE-2022-28585": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-28586": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-28588": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-28589": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-28590": {"epss_score": 0.39315, "epss_percentile": 0.97153}, "CVE-2022-28598": {"epss_score": 0.13731, "epss_percentile": 0.94045}, "CVE-2022-28599": {"epss_score": 0.00237, "epss_percentile": 0.46734}, "CVE-2022-28601": {"epss_score": 0.05579, "epss_percentile": 0.90017}, "CVE-2022-28605": {"epss_score": 0.01492, "epss_percentile": 0.80636}, "CVE-2022-28606": {"epss_score": 0.00519, "epss_percentile": 0.66143}, "CVE-2022-28607": {"epss_score": 0.003, "epss_percentile": 0.52917}, "CVE-2022-28611": {"epss_score": 0.00181, "epss_percentile": 0.40108}, "CVE-2022-28612": {"epss_score": 0.00129, "epss_percentile": 0.33195}, "CVE-2022-28613": {"epss_score": 0.00446, "epss_percentile": 0.629}, "CVE-2022-28614": {"epss_score": 0.00506, "epss_percentile": 0.65627}, "CVE-2022-28615": {"epss_score": 0.00949, "epss_percentile": 0.75845}, "CVE-2022-28616": {"epss_score": 0.00492, "epss_percentile": 0.65003}, "CVE-2022-28617": {"epss_score": 0.0049, "epss_percentile": 0.6494}, "CVE-2022-28618": {"epss_score": 0.03023, "epss_percentile": 0.8623}, "CVE-2022-28619": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2022-28620": {"epss_score": 0.00691, "epss_percentile": 0.71275}, "CVE-2022-28621": {"epss_score": 0.00288, "epss_percentile": 0.51947}, "CVE-2022-28622": {"epss_score": 0.00257, "epss_percentile": 0.48915}, "CVE-2022-28623": {"epss_score": 0.00608, "epss_percentile": 0.69079}, "CVE-2022-28624": {"epss_score": 0.00455, "epss_percentile": 0.63296}, "CVE-2022-28625": {"epss_score": 0.00032, "epss_percentile": 0.09001}, "CVE-2022-28626": {"epss_score": 0.00058, "epss_percentile": 0.18301}, "CVE-2022-28627": {"epss_score": 0.00056, "epss_percentile": 0.17678}, "CVE-2022-28628": {"epss_score": 0.00056, "epss_percentile": 0.17678}, "CVE-2022-28629": {"epss_score": 0.00056, "epss_percentile": 0.17876}, "CVE-2022-28630": {"epss_score": 0.00056, "epss_percentile": 0.17956}, "CVE-2022-28631": {"epss_score": 0.00089, "epss_percentile": 0.25911}, "CVE-2022-28632": {"epss_score": 0.00089, "epss_percentile": 0.25911}, "CVE-2022-28633": {"epss_score": 0.00057, "epss_percentile": 0.17972}, "CVE-2022-28634": {"epss_score": 0.00058, "epss_percentile": 0.18301}, "CVE-2022-28635": {"epss_score": 0.00052, "epss_percentile": 0.16533}, "CVE-2022-28636": {"epss_score": 0.00052, "epss_percentile": 0.16533}, "CVE-2022-28637": {"epss_score": 0.00104, "epss_percentile": 0.29246}, "CVE-2022-28638": {"epss_score": 0.0013, "epss_percentile": 0.33241}, "CVE-2022-28639": {"epss_score": 0.00116, "epss_percentile": 0.31038}, "CVE-2022-28640": {"epss_score": 0.00359, "epss_percentile": 0.57589}, "CVE-2022-28641": {"epss_score": 0.03304, "epss_percentile": 0.8687}, "CVE-2022-28642": {"epss_score": 0.03209, "epss_percentile": 0.86648}, "CVE-2022-28643": {"epss_score": 0.03209, "epss_percentile": 0.86648}, "CVE-2022-28644": {"epss_score": 0.03209, "epss_percentile": 0.86648}, "CVE-2022-28645": {"epss_score": 0.00739, "epss_percentile": 0.72353}, "CVE-2022-28646": {"epss_score": 0.03304, "epss_percentile": 0.8687}, "CVE-2022-28647": {"epss_score": 0.03304, "epss_percentile": 0.8687}, "CVE-2022-28648": {"epss_score": 4e-05, "epss_percentile": 0.0013}, "CVE-2022-28649": {"epss_score": 3e-05, "epss_percentile": 0.00079}, "CVE-2022-28650": {"epss_score": 9e-05, "epss_percentile": 0.00712}, "CVE-2022-28651": {"epss_score": 1e-05, "epss_percentile": 0.00012}, "CVE-2022-28652": {"epss_score": 0.00041, "epss_percentile": 0.12219}, "CVE-2022-28653": {"epss_score": 0.00276, "epss_percentile": 0.50719}, "CVE-2022-28654": {"epss_score": 0.00036, "epss_percentile": 0.10215}, "CVE-2022-28655": {"epss_score": 0.00036, "epss_percentile": 0.10406}, "CVE-2022-28656": {"epss_score": 0.00036, "epss_percentile": 0.10215}, "CVE-2022-28657": {"epss_score": 0.0005, "epss_percentile": 0.15888}, "CVE-2022-28658": {"epss_score": 0.00038, "epss_percentile": 0.11128}, "CVE-2022-28660": {"epss_score": 0.00466, "epss_percentile": 0.63806}, "CVE-2022-28661": {"epss_score": 0.00606, "epss_percentile": 0.69003}, "CVE-2022-28662": {"epss_score": 0.0032, "epss_percentile": 0.54631}, "CVE-2022-28663": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-28664": {"epss_score": 0.03105, "epss_percentile": 0.86416}, "CVE-2022-28665": {"epss_score": 0.03764, "epss_percentile": 0.87692}, "CVE-2022-28666": {"epss_score": 0.12792, "epss_percentile": 0.93774}, "CVE-2022-28667": {"epss_score": 0.00236, "epss_percentile": 0.46373}, "CVE-2022-28668": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-28669": {"epss_score": 0.00395, "epss_percentile": 0.59819}, "CVE-2022-28670": {"epss_score": 0.00179, "epss_percentile": 0.3978}, "CVE-2022-28671": {"epss_score": 0.00395, "epss_percentile": 0.59819}, "CVE-2022-28672": {"epss_score": 0.22742, "epss_percentile": 0.95677}, "CVE-2022-28673": {"epss_score": 0.00395, "epss_percentile": 0.59819}, "CVE-2022-28674": {"epss_score": 0.00395, "epss_percentile": 0.59819}, "CVE-2022-28675": {"epss_score": 0.00395, "epss_percentile": 0.59819}, "CVE-2022-28676": {"epss_score": 0.00395, "epss_percentile": 0.59819}, "CVE-2022-28677": {"epss_score": 0.00395, "epss_percentile": 0.59819}, "CVE-2022-28678": {"epss_score": 0.00364, "epss_percentile": 0.57944}, "CVE-2022-28679": {"epss_score": 0.00364, "epss_percentile": 0.57944}, "CVE-2022-28680": {"epss_score": 0.00364, "epss_percentile": 0.57944}, "CVE-2022-28681": {"epss_score": 0.007, "epss_percentile": 0.71481}, "CVE-2022-28682": {"epss_score": 0.02012, "epss_percentile": 0.83253}, "CVE-2022-28683": {"epss_score": 0.02012, "epss_percentile": 0.83253}, "CVE-2022-28684": {"epss_score": 0.24087, "epss_percentile": 0.95868}, "CVE-2022-28685": {"epss_score": 0.14642, "epss_percentile": 0.94256}, "CVE-2022-28686": {"epss_score": 0.01092, "epss_percentile": 0.77468}, "CVE-2022-28687": {"epss_score": 0.01092, "epss_percentile": 0.77468}, "CVE-2022-28688": {"epss_score": 0.01529, "epss_percentile": 0.8088}, "CVE-2022-28689": {"epss_score": 0.00538, "epss_percentile": 0.66928}, "CVE-2022-28690": {"epss_score": 0.00302, "epss_percentile": 0.53099}, "CVE-2022-28691": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2022-28692": {"epss_score": 0.00151, "epss_percentile": 0.36221}, "CVE-2022-28693": {"epss_score": 0.00045, "epss_percentile": 0.13905}, "CVE-2022-28695": {"epss_score": 0.00441, "epss_percentile": 0.62672}, "CVE-2022-28696": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2022-28697": {"epss_score": 0.00186, "epss_percentile": 0.40586}, "CVE-2022-28699": {"epss_score": 0.00063, "epss_percentile": 0.19836}, "CVE-2022-28700": {"epss_score": 0.05014, "epss_percentile": 0.89394}, "CVE-2022-28701": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2022-28702": {"epss_score": 0.0003, "epss_percentile": 0.07979}, "CVE-2022-28703": {"epss_score": 0.03886, "epss_percentile": 0.87904}, "CVE-2022-28704": {"epss_score": 0.08563, "epss_percentile": 0.92126}, "CVE-2022-28705": {"epss_score": 0.00896, "epss_percentile": 0.75117}, "CVE-2022-28706": {"epss_score": 0.00674, "epss_percentile": 0.70861}, "CVE-2022-28707": {"epss_score": 0.00712, "epss_percentile": 0.71749}, "CVE-2022-28708": {"epss_score": 0.00462, "epss_percentile": 0.63615}, "CVE-2022-28709": {"epss_score": 0.0007, "epss_percentile": 0.21741}, "CVE-2022-28710": {"epss_score": 0.02567, "epss_percentile": 0.85118}, "CVE-2022-28711": {"epss_score": 0.00525, "epss_percentile": 0.66371}, "CVE-2022-28712": {"epss_score": 0.0371, "epss_percentile": 0.87604}, "CVE-2022-28713": {"epss_score": 0.00347, "epss_percentile": 0.56754}, "CVE-2022-28714": {"epss_score": 0.00363, "epss_percentile": 0.57893}, "CVE-2022-28715": {"epss_score": 0.00189, "epss_percentile": 0.40923}, "CVE-2022-28716": {"epss_score": 0.01225, "epss_percentile": 0.7868}, "CVE-2022-28717": {"epss_score": 0.00189, "epss_percentile": 0.40964}, "CVE-2022-28718": {"epss_score": 0.00188, "epss_percentile": 0.40892}, "CVE-2022-28719": {"epss_score": 0.07008, "epss_percentile": 0.91181}, "CVE-2022-28721": {"epss_score": 0.00645, "epss_percentile": 0.70105}, "CVE-2022-28722": {"epss_score": 0.00347, "epss_percentile": 0.56765}, "CVE-2022-28730": {"epss_score": 0.11342, "epss_percentile": 0.93316}, "CVE-2022-28731": {"epss_score": 0.06531, "epss_percentile": 0.90825}, "CVE-2022-28732": {"epss_score": 0.08595, "epss_percentile": 0.92142}, "CVE-2022-28733": {"epss_score": 0.00109, "epss_percentile": 0.29931}, "CVE-2022-28734": {"epss_score": 0.00141, "epss_percentile": 0.3492}, "CVE-2022-28735": {"epss_score": 0.00017, "epss_percentile": 0.03104}, "CVE-2022-28736": {"epss_score": 0.00029, "epss_percentile": 0.07846}, "CVE-2022-28737": {"epss_score": 0.00021, "epss_percentile": 0.0477}, "CVE-2022-28738": {"epss_score": 0.00456, "epss_percentile": 0.63346}, "CVE-2022-28739": {"epss_score": 0.00332, "epss_percentile": 0.55589}, "CVE-2022-28740": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2022-28741": {"epss_score": 0.00579, "epss_percentile": 0.6821}, "CVE-2022-28742": {"epss_score": 0.0037, "epss_percentile": 0.58316}, "CVE-2022-28743": {"epss_score": 0.00699, "epss_percentile": 0.71434}, "CVE-2022-28747": {"epss_score": 0.0271, "epss_percentile": 0.85492}, "CVE-2022-28749": {"epss_score": 0.0024, "epss_percentile": 0.46964}, "CVE-2022-28750": {"epss_score": 0.00643, "epss_percentile": 0.70061}, "CVE-2022-28751": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-28752": {"epss_score": 0.0003, "epss_percentile": 0.08113}, "CVE-2022-28753": {"epss_score": 0.00157, "epss_percentile": 0.37138}, "CVE-2022-28754": {"epss_score": 0.00157, "epss_percentile": 0.37138}, "CVE-2022-28755": {"epss_score": 0.00537, "epss_percentile": 0.66888}, "CVE-2022-28756": {"epss_score": 0.00088, "epss_percentile": 0.25756}, "CVE-2022-28757": {"epss_score": 0.00142, "epss_percentile": 0.34984}, "CVE-2022-28758": {"epss_score": 0.00323, "epss_percentile": 0.54922}, "CVE-2022-28759": {"epss_score": 0.00323, "epss_percentile": 0.54922}, "CVE-2022-28760": {"epss_score": 0.00266, "epss_percentile": 0.49859}, "CVE-2022-28761": {"epss_score": 0.00355, "epss_percentile": 0.57259}, "CVE-2022-28762": {"epss_score": 0.00176, "epss_percentile": 0.39413}, "CVE-2022-28763": {"epss_score": 0.01072, "epss_percentile": 0.77281}, "CVE-2022-28764": {"epss_score": 0.00136, "epss_percentile": 0.34123}, "CVE-2022-28766": {"epss_score": 0.00512, "epss_percentile": 0.65867}, "CVE-2022-28768": {"epss_score": 0.00037, "epss_percentile": 0.10637}, "CVE-2022-28770": {"epss_score": 0.00895, "epss_percentile": 0.75106}, "CVE-2022-28771": {"epss_score": 0.00667, "epss_percentile": 0.70698}, "CVE-2022-28772": {"epss_score": 0.01139, "epss_percentile": 0.77938}, "CVE-2022-28773": {"epss_score": 0.01139, "epss_percentile": 0.77938}, "CVE-2022-28774": {"epss_score": 0.00045, "epss_percentile": 0.13741}, "CVE-2022-28775": {"epss_score": 0.0006, "epss_percentile": 0.1908}, "CVE-2022-28776": {"epss_score": 0.0005, "epss_percentile": 0.15662}, "CVE-2022-28777": {"epss_score": 0.00059, "epss_percentile": 0.18694}, "CVE-2022-28778": {"epss_score": 0.00057, "epss_percentile": 0.18033}, "CVE-2022-28779": {"epss_score": 0.00065, "epss_percentile": 0.20455}, "CVE-2022-28780": {"epss_score": 0.00017, "epss_percentile": 0.03339}, "CVE-2022-28781": {"epss_score": 0.00016, "epss_percentile": 0.02922}, "CVE-2022-28782": {"epss_score": 0.00019, "epss_percentile": 0.04156}, "CVE-2022-28783": {"epss_score": 0.00016, "epss_percentile": 0.02625}, "CVE-2022-28784": {"epss_score": 0.00021, "epss_percentile": 0.04747}, "CVE-2022-28785": {"epss_score": 0.00016, "epss_percentile": 0.02872}, "CVE-2022-28786": {"epss_score": 0.00016, "epss_percentile": 0.02872}, "CVE-2022-28787": {"epss_score": 0.00016, "epss_percentile": 0.02872}, "CVE-2022-28788": {"epss_score": 0.00016, "epss_percentile": 0.02872}, "CVE-2022-28789": {"epss_score": 0.00057, "epss_percentile": 0.18157}, "CVE-2022-28790": {"epss_score": 0.00056, "epss_percentile": 0.1796}, "CVE-2022-28791": {"epss_score": 0.00083, "epss_percentile": 0.24732}, "CVE-2022-28792": {"epss_score": 0.00057, "epss_percentile": 0.17968}, "CVE-2022-28793": {"epss_score": 0.00064, "epss_percentile": 0.20131}, "CVE-2022-28794": {"epss_score": 0.00016, "epss_percentile": 0.02646}, "CVE-2022-28795": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2022-28796": {"epss_score": 0.00104, "epss_percentile": 0.29197}, "CVE-2022-28799": {"epss_score": 0.02669, "epss_percentile": 0.85385}, "CVE-2022-28802": {"epss_score": 0.00721, "epss_percentile": 0.7198}, "CVE-2022-28803": {"epss_score": 0.00149, "epss_percentile": 0.36}, "CVE-2022-28805": {"epss_score": 0.00172, "epss_percentile": 0.38935}, "CVE-2022-28806": {"epss_score": 0.00106, "epss_percentile": 0.29424}, "CVE-2022-28807": {"epss_score": 0.00144, "epss_percentile": 0.3531}, "CVE-2022-28808": {"epss_score": 0.00144, "epss_percentile": 0.3531}, "CVE-2022-28809": {"epss_score": 0.00117, "epss_percentile": 0.31264}, "CVE-2022-28810": {"epss_score": 0.9137, "epss_percentile": 0.99637}, "CVE-2022-28811": {"epss_score": 0.00536, "epss_percentile": 0.66855}, "CVE-2022-28812": {"epss_score": 0.01546, "epss_percentile": 0.80965}, "CVE-2022-28813": {"epss_score": 0.00563, "epss_percentile": 0.67712}, "CVE-2022-28814": {"epss_score": 0.01172, "epss_percentile": 0.78232}, "CVE-2022-28815": {"epss_score": 0.00191, "epss_percentile": 0.41217}, "CVE-2022-28816": {"epss_score": 0.00197, "epss_percentile": 0.41961}, "CVE-2022-28818": {"epss_score": 0.00501, "epss_percentile": 0.6535}, "CVE-2022-28819": {"epss_score": 0.02311, "epss_percentile": 0.84337}, "CVE-2022-28820": {"epss_score": 0.01333, "epss_percentile": 0.79531}, "CVE-2022-28821": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28822": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28823": {"epss_score": 0.1143, "epss_percentile": 0.93348}, "CVE-2022-28824": {"epss_score": 0.1143, "epss_percentile": 0.93348}, "CVE-2022-28825": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28826": {"epss_score": 0.01507, "epss_percentile": 0.80752}, "CVE-2022-28827": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28828": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28829": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28830": {"epss_score": 0.01625, "epss_percentile": 0.81418}, "CVE-2022-28831": {"epss_score": 0.00132, "epss_percentile": 0.33608}, "CVE-2022-28832": {"epss_score": 0.00173, "epss_percentile": 0.3911}, "CVE-2022-28833": {"epss_score": 0.00132, "epss_percentile": 0.33608}, "CVE-2022-28834": {"epss_score": 0.00125, "epss_percentile": 0.32585}, "CVE-2022-28835": {"epss_score": 0.00098, "epss_percentile": 0.2771}, "CVE-2022-28836": {"epss_score": 0.00125, "epss_percentile": 0.32585}, "CVE-2022-28837": {"epss_score": 0.01491, "epss_percentile": 0.80634}, "CVE-2022-28838": {"epss_score": 0.03896, "epss_percentile": 0.87916}, "CVE-2022-28839": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28840": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28841": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28842": {"epss_score": 0.1143, "epss_percentile": 0.93348}, "CVE-2022-28843": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28844": {"epss_score": 0.01507, "epss_percentile": 0.80752}, "CVE-2022-28845": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-28846": {"epss_score": 0.05422, "epss_percentile": 0.89863}, "CVE-2022-28847": {"epss_score": 0.05422, "epss_percentile": 0.89863}, "CVE-2022-28848": {"epss_score": 0.05422, "epss_percentile": 0.89863}, "CVE-2022-28849": {"epss_score": 0.22453, "epss_percentile": 0.95636}, "CVE-2022-28850": {"epss_score": 0.02038, "epss_percentile": 0.83359}, "CVE-2022-28851": {"epss_score": 0.06977, "epss_percentile": 0.91157}, "CVE-2022-28852": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-28853": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-28854": {"epss_score": 0.00162, "epss_percentile": 0.37657}, "CVE-2022-28855": {"epss_score": 0.00162, "epss_percentile": 0.37657}, "CVE-2022-28856": {"epss_score": 0.00162, "epss_percentile": 0.37657}, "CVE-2022-28857": {"epss_score": 0.00162, "epss_percentile": 0.37657}, "CVE-2022-28858": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2022-28859": {"epss_score": 0.0027, "epss_percentile": 0.50198}, "CVE-2022-28860": {"epss_score": 0.00254, "epss_percentile": 0.48547}, "CVE-2022-28861": {"epss_score": 0.00139, "epss_percentile": 0.34587}, "CVE-2022-28862": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28863": {"epss_score": 0.0023, "epss_percentile": 0.45676}, "CVE-2022-28864": {"epss_score": 0.00088, "epss_percentile": 0.25674}, "CVE-2022-28865": {"epss_score": 0.00071, "epss_percentile": 0.22149}, "CVE-2022-28866": {"epss_score": 0.0026, "epss_percentile": 0.49182}, "CVE-2022-28867": {"epss_score": 0.00071, "epss_percentile": 0.22149}, "CVE-2022-28868": {"epss_score": 0.00267, "epss_percentile": 0.49955}, "CVE-2022-28869": {"epss_score": 0.00267, "epss_percentile": 0.49955}, "CVE-2022-28870": {"epss_score": 0.00302, "epss_percentile": 0.53123}, "CVE-2022-28871": {"epss_score": 0.00206, "epss_percentile": 0.42948}, "CVE-2022-28872": {"epss_score": 0.00415, "epss_percentile": 0.61149}, "CVE-2022-28873": {"epss_score": 0.00328, "epss_percentile": 0.55259}, "CVE-2022-28874": {"epss_score": 0.00221, "epss_percentile": 0.44661}, "CVE-2022-28875": {"epss_score": 0.0025, "epss_percentile": 0.48251}, "CVE-2022-28876": {"epss_score": 0.00343, "epss_percentile": 0.56449}, "CVE-2022-28877": {"epss_score": 0.00187, "epss_percentile": 0.40709}, "CVE-2022-28878": {"epss_score": 0.00179, "epss_percentile": 0.39833}, "CVE-2022-28879": {"epss_score": 0.00343, "epss_percentile": 0.56449}, "CVE-2022-28880": {"epss_score": 0.00179, "epss_percentile": 0.39833}, "CVE-2022-28881": {"epss_score": 0.00462, "epss_percentile": 0.63584}, "CVE-2022-28882": {"epss_score": 0.00327, "epss_percentile": 0.55129}, "CVE-2022-28883": {"epss_score": 0.00327, "epss_percentile": 0.55129}, "CVE-2022-28884": {"epss_score": 0.00343, "epss_percentile": 0.56449}, "CVE-2022-28885": {"epss_score": 0.00232, "epss_percentile": 0.45861}, "CVE-2022-28886": {"epss_score": 0.00162, "epss_percentile": 0.37727}, "CVE-2022-28887": {"epss_score": 0.00343, "epss_percentile": 0.56449}, "CVE-2022-28888": {"epss_score": 0.05096, "epss_percentile": 0.89494}, "CVE-2022-28889": {"epss_score": 0.02244, "epss_percentile": 0.84126}, "CVE-2022-28890": {"epss_score": 0.00677, "epss_percentile": 0.70952}, "CVE-2022-28892": {"epss_score": 0.00103, "epss_percentile": 0.29048}, "CVE-2022-28893": {"epss_score": 0.00026, "epss_percentile": 0.06534}, "CVE-2022-28895": {"epss_score": 0.33425, "epss_percentile": 0.96774}, "CVE-2022-28896": {"epss_score": 0.33425, "epss_percentile": 0.96774}, "CVE-2022-28901": {"epss_score": 0.33425, "epss_percentile": 0.96774}, "CVE-2022-28905": {"epss_score": 0.11265, "epss_percentile": 0.93286}, "CVE-2022-28906": {"epss_score": 0.20143, "epss_percentile": 0.95292}, "CVE-2022-28907": {"epss_score": 0.11265, "epss_percentile": 0.93286}, "CVE-2022-28908": {"epss_score": 0.11265, "epss_percentile": 0.93286}, "CVE-2022-28909": {"epss_score": 0.0998, "epss_percentile": 0.92801}, "CVE-2022-28910": {"epss_score": 0.11265, "epss_percentile": 0.93286}, "CVE-2022-28911": {"epss_score": 0.11265, "epss_percentile": 0.93286}, "CVE-2022-28912": {"epss_score": 0.11265, "epss_percentile": 0.93286}, "CVE-2022-28913": {"epss_score": 0.11265, "epss_percentile": 0.93286}, "CVE-2022-28915": {"epss_score": 0.33425, "epss_percentile": 0.96774}, "CVE-2022-28917": {"epss_score": 0.02509, "epss_percentile": 0.84944}, "CVE-2022-28918": {"epss_score": 0.00234, "epss_percentile": 0.46174}, "CVE-2022-28919": {"epss_score": 0.00561, "epss_percentile": 0.67667}, "CVE-2022-28920": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-28921": {"epss_score": 0.00196, "epss_percentile": 0.41761}, "CVE-2022-28923": {"epss_score": 0.16987, "epss_percentile": 0.94756}, "CVE-2022-28924": {"epss_score": 0.00288, "epss_percentile": 0.51882}, "CVE-2022-28927": {"epss_score": 0.04158, "epss_percentile": 0.88331}, "CVE-2022-28929": {"epss_score": 0.00218, "epss_percentile": 0.44369}, "CVE-2022-28930": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-28932": {"epss_score": 0.00751, "epss_percentile": 0.72644}, "CVE-2022-28935": {"epss_score": 0.09658, "epss_percentile": 0.92643}, "CVE-2022-28936": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2022-28937": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2022-28940": {"epss_score": 0.00296, "epss_percentile": 0.52616}, "CVE-2022-28944": {"epss_score": 0.12163, "epss_percentile": 0.93586}, "CVE-2022-28945": {"epss_score": 0.00276, "epss_percentile": 0.50772}, "CVE-2022-28946": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2022-28948": {"epss_score": 0.01996, "epss_percentile": 0.83195}, "CVE-2022-28955": {"epss_score": 0.92711, "epss_percentile": 0.99737}, "CVE-2022-28956": {"epss_score": 0.27547, "epss_percentile": 0.96257}, "CVE-2022-28959": {"epss_score": 0.01009, "epss_percentile": 0.76583}, "CVE-2022-28960": {"epss_score": 0.01155, "epss_percentile": 0.7808}, "CVE-2022-28961": {"epss_score": 0.01203, "epss_percentile": 0.78491}, "CVE-2022-28962": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2022-28964": {"epss_score": 0.00133, "epss_percentile": 0.33657}, "CVE-2022-28965": {"epss_score": 0.00464, "epss_percentile": 0.63709}, "CVE-2022-28966": {"epss_score": 0.00146, "epss_percentile": 0.35639}, "CVE-2022-28969": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-28970": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-28971": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-28972": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-28973": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2022-28975": {"epss_score": 0.00178, "epss_percentile": 0.39674}, "CVE-2022-28977": {"epss_score": 0.00402, "epss_percentile": 0.60285}, "CVE-2022-28978": {"epss_score": 0.0012, "epss_percentile": 0.31698}, "CVE-2022-28979": {"epss_score": 0.003, "epss_percentile": 0.52978}, "CVE-2022-28980": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-28981": {"epss_score": 0.00262, "epss_percentile": 0.49366}, "CVE-2022-28982": {"epss_score": 0.00399, "epss_percentile": 0.60132}, "CVE-2022-28985": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-28986": {"epss_score": 0.06296, "epss_percentile": 0.90652}, "CVE-2022-28987": {"epss_score": 0.01558, "epss_percentile": 0.81027}, "CVE-2022-28990": {"epss_score": 0.00124, "epss_percentile": 0.32349}, "CVE-2022-28991": {"epss_score": 0.00276, "epss_percentile": 0.50724}, "CVE-2022-28992": {"epss_score": 0.00183, "epss_percentile": 0.40355}, "CVE-2022-28993": {"epss_score": 0.00358, "epss_percentile": 0.57521}, "CVE-2022-28994": {"epss_score": 0.00775, "epss_percentile": 0.73088}, "CVE-2022-28995": {"epss_score": 0.03062, "epss_percentile": 0.86319}, "CVE-2022-28997": {"epss_score": 0.01773, "epss_percentile": 0.82206}, "CVE-2022-28998": {"epss_score": 0.03621, "epss_percentile": 0.87443}, "CVE-2022-28999": {"epss_score": 0.00586, "epss_percentile": 0.68437}, "CVE-2022-29001": {"epss_score": 0.00378, "epss_percentile": 0.58785}, "CVE-2022-29002": {"epss_score": 0.00118, "epss_percentile": 0.31448}, "CVE-2022-29004": {"epss_score": 0.36016, "epss_percentile": 0.96949}, "CVE-2022-29005": {"epss_score": 0.22122, "epss_percentile": 0.95597}, "CVE-2022-29006": {"epss_score": 0.85946, "epss_percentile": 0.99357}, "CVE-2022-29007": {"epss_score": 0.92276, "epss_percentile": 0.99704}, "CVE-2022-29008": {"epss_score": 0.0069, "epss_percentile": 0.71257}, "CVE-2022-29009": {"epss_score": 0.87745, "epss_percentile": 0.9944}, "CVE-2022-29013": {"epss_score": 0.92694, "epss_percentile": 0.99735}, "CVE-2022-29014": {"epss_score": 0.86201, "epss_percentile": 0.99372}, "CVE-2022-29017": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2022-29020": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-29021": {"epss_score": 0.00257, "epss_percentile": 0.48864}, "CVE-2022-29022": {"epss_score": 0.00189, "epss_percentile": 0.40965}, "CVE-2022-29023": {"epss_score": 0.00257, "epss_percentile": 0.48864}, "CVE-2022-29028": {"epss_score": 0.00285, "epss_percentile": 0.51531}, "CVE-2022-29029": {"epss_score": 0.00285, "epss_percentile": 0.51531}, "CVE-2022-29030": {"epss_score": 0.00285, "epss_percentile": 0.51531}, "CVE-2022-29031": {"epss_score": 0.00285, "epss_percentile": 0.51531}, "CVE-2022-29032": {"epss_score": 0.0054, "epss_percentile": 0.67017}, "CVE-2022-29033": {"epss_score": 0.00293, "epss_percentile": 0.52319}, "CVE-2022-29034": {"epss_score": 0.07048, "epss_percentile": 0.9121}, "CVE-2022-29035": {"epss_score": 3e-05, "epss_percentile": 0.00073}, "CVE-2022-29036": {"epss_score": 0.16348, "epss_percentile": 0.94633}, "CVE-2022-29037": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-29038": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-29039": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-29040": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-29041": {"epss_score": 0.27127, "epss_percentile": 0.96209}, "CVE-2022-29042": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-29043": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-29044": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-29045": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-29046": {"epss_score": 0.24981, "epss_percentile": 0.95974}, "CVE-2022-29047": {"epss_score": 0.00245, "epss_percentile": 0.47668}, "CVE-2022-29048": {"epss_score": 0.00096, "epss_percentile": 0.27294}, "CVE-2022-29049": {"epss_score": 0.03051, "epss_percentile": 0.86291}, "CVE-2022-29050": {"epss_score": 0.00092, "epss_percentile": 0.26594}, "CVE-2022-29051": {"epss_score": 0.00906, "epss_percentile": 0.75252}, "CVE-2022-29052": {"epss_score": 0.00836, "epss_percentile": 0.74144}, "CVE-2022-29053": {"epss_score": 0.00051, "epss_percentile": 0.15984}, "CVE-2022-29054": {"epss_score": 0.00079, "epss_percentile": 0.23823}, "CVE-2022-29055": {"epss_score": 0.00619, "epss_percentile": 0.69425}, "CVE-2022-29056": {"epss_score": 0.09853, "epss_percentile": 0.92736}, "CVE-2022-29057": {"epss_score": 0.002, "epss_percentile": 0.42214}, "CVE-2022-29058": {"epss_score": 0.00232, "epss_percentile": 0.45887}, "CVE-2022-29059": {"epss_score": 0.00087, "epss_percentile": 0.25485}, "CVE-2022-29060": {"epss_score": 0.00479, "epss_percentile": 0.64439}, "CVE-2022-29061": {"epss_score": 0.02948, "epss_percentile": 0.86047}, "CVE-2022-29062": {"epss_score": 0.00746, "epss_percentile": 0.72551}, "CVE-2022-29063": {"epss_score": 0.14133, "epss_percentile": 0.94142}, "CVE-2022-29071": {"epss_score": 0.00049, "epss_percentile": 0.15616}, "CVE-2022-29072": {"epss_score": 0.1807, "epss_percentile": 0.94952}, "CVE-2022-29077": {"epss_score": 0.0092, "epss_percentile": 0.75464}, "CVE-2022-29078": {"epss_score": 0.93462, "epss_percentile": 0.99809}, "CVE-2022-29080": {"epss_score": 0.03315, "epss_percentile": 0.86898}, "CVE-2022-29081": {"epss_score": 0.81477, "epss_percentile": 0.9914}, "CVE-2022-29082": {"epss_score": 0.00077, "epss_percentile": 0.23531}, "CVE-2022-29083": {"epss_score": 0.00109, "epss_percentile": 0.30069}, "CVE-2022-29084": {"epss_score": 0.01427, "epss_percentile": 0.8021}, "CVE-2022-29085": {"epss_score": 0.00103, "epss_percentile": 0.29095}, "CVE-2022-29089": {"epss_score": 0.0019, "epss_percentile": 0.41105}, "CVE-2022-29090": {"epss_score": 0.00139, "epss_percentile": 0.34659}, "CVE-2022-29091": {"epss_score": 0.00351, "epss_percentile": 0.57009}, "CVE-2022-29092": {"epss_score": 0.00054, "epss_percentile": 0.17346}, "CVE-2022-29093": {"epss_score": 0.00106, "epss_percentile": 0.29503}, "CVE-2022-29094": {"epss_score": 0.00106, "epss_percentile": 0.29503}, "CVE-2022-29095": {"epss_score": 0.00722, "epss_percentile": 0.71992}, "CVE-2022-29096": {"epss_score": 0.00597, "epss_percentile": 0.6875}, "CVE-2022-29097": {"epss_score": 0.00202, "epss_percentile": 0.42465}, "CVE-2022-29098": {"epss_score": 0.00433, "epss_percentile": 0.62173}, "CVE-2022-29102": {"epss_score": 0.00468, "epss_percentile": 0.63887}, "CVE-2022-29103": {"epss_score": 0.0026, "epss_percentile": 0.49231}, "CVE-2022-29104": {"epss_score": 0.01592, "epss_percentile": 0.81225}, "CVE-2022-29105": {"epss_score": 0.02445, "epss_percentile": 0.84766}, "CVE-2022-29106": {"epss_score": 0.00246, "epss_percentile": 0.47752}, "CVE-2022-29107": {"epss_score": 0.06002, "epss_percentile": 0.90393}, "CVE-2022-29108": {"epss_score": 0.09895, "epss_percentile": 0.92759}, "CVE-2022-29109": {"epss_score": 0.02682, "epss_percentile": 0.85419}, "CVE-2022-29110": {"epss_score": 0.03494, "epss_percentile": 0.87234}, "CVE-2022-29111": {"epss_score": 0.02746, "epss_percentile": 0.85573}, "CVE-2022-29112": {"epss_score": 0.16671, "epss_percentile": 0.94712}, "CVE-2022-29113": {"epss_score": 0.00163, "epss_percentile": 0.37827}, "CVE-2022-29114": {"epss_score": 0.0046, "epss_percentile": 0.63511}, "CVE-2022-29115": {"epss_score": 0.02445, "epss_percentile": 0.84766}, "CVE-2022-29116": {"epss_score": 0.00318, "epss_percentile": 0.54405}, "CVE-2022-29117": {"epss_score": 0.02187, "epss_percentile": 0.83924}, "CVE-2022-29119": {"epss_score": 0.02746, "epss_percentile": 0.85573}, "CVE-2022-29120": {"epss_score": 0.00448, "epss_percentile": 0.63023}, "CVE-2022-29121": {"epss_score": 0.00427, "epss_percentile": 0.61879}, "CVE-2022-29122": {"epss_score": 0.00448, "epss_percentile": 0.63023}, "CVE-2022-29123": {"epss_score": 0.00347, "epss_percentile": 0.56784}, "CVE-2022-29125": {"epss_score": 0.00326, "epss_percentile": 0.55086}, "CVE-2022-29126": {"epss_score": 0.00285, "epss_percentile": 0.51657}, "CVE-2022-29127": {"epss_score": 0.00383, "epss_percentile": 0.59096}, "CVE-2022-29128": {"epss_score": 0.14363, "epss_percentile": 0.94194}, "CVE-2022-29129": {"epss_score": 0.14363, "epss_percentile": 0.94194}, "CVE-2022-29130": {"epss_score": 0.14207, "epss_percentile": 0.94163}, "CVE-2022-29131": {"epss_score": 0.13231, "epss_percentile": 0.93906}, "CVE-2022-29132": {"epss_score": 0.00491, "epss_percentile": 0.6495}, "CVE-2022-29133": {"epss_score": 0.00278, "epss_percentile": 0.50892}, "CVE-2022-29134": {"epss_score": 0.00607, "epss_percentile": 0.69041}, "CVE-2022-29135": {"epss_score": 0.00285, "epss_percentile": 0.51657}, "CVE-2022-29137": {"epss_score": 0.12982, "epss_percentile": 0.93835}, "CVE-2022-29138": {"epss_score": 0.00227, "epss_percentile": 0.45363}, "CVE-2022-29139": {"epss_score": 0.08902, "epss_percentile": 0.92308}, "CVE-2022-29140": {"epss_score": 0.0152, "epss_percentile": 0.80823}, "CVE-2022-29141": {"epss_score": 0.11333, "epss_percentile": 0.93313}, "CVE-2022-29142": {"epss_score": 0.00384, "epss_percentile": 0.59131}, "CVE-2022-29143": {"epss_score": 0.02154, "epss_percentile": 0.83801}, "CVE-2022-29144": {"epss_score": 0.01502, "epss_percentile": 0.80724}, "CVE-2022-29145": {"epss_score": 0.04834, "epss_percentile": 0.89192}, "CVE-2022-29146": {"epss_score": 0.00707, "epss_percentile": 0.71649}, "CVE-2022-29147": {"epss_score": 0.0134, "epss_percentile": 0.79579}, "CVE-2022-29148": {"epss_score": 0.02746, "epss_percentile": 0.85573}, "CVE-2022-29149": {"epss_score": 0.00217, "epss_percentile": 0.44319}, "CVE-2022-29150": {"epss_score": 0.00285, "epss_percentile": 0.51657}, "CVE-2022-29151": {"epss_score": 0.00285, "epss_percentile": 0.51657}, "CVE-2022-29152": {"epss_score": 0.00388, "epss_percentile": 0.59341}, "CVE-2022-29153": {"epss_score": 0.85724, "epss_percentile": 0.99345}, "CVE-2022-29154": {"epss_score": 0.0035, "epss_percentile": 0.5697}, "CVE-2022-29155": {"epss_score": 0.20934, "epss_percentile": 0.95445}, "CVE-2022-29156": {"epss_score": 0.00156, "epss_percentile": 0.36961}, "CVE-2022-29158": {"epss_score": 0.00483, "epss_percentile": 0.64623}, "CVE-2022-29159": {"epss_score": 0.00142, "epss_percentile": 0.35027}, "CVE-2022-29160": {"epss_score": 0.00075, "epss_percentile": 0.22982}, "CVE-2022-29161": {"epss_score": 0.00218, "epss_percentile": 0.44388}, "CVE-2022-29162": {"epss_score": 0.00138, "epss_percentile": 0.34343}, "CVE-2022-29163": {"epss_score": 0.00539, "epss_percentile": 0.66962}, "CVE-2022-29164": {"epss_score": 0.00334, "epss_percentile": 0.55701}, "CVE-2022-29165": {"epss_score": 0.01629, "epss_percentile": 0.81438}, "CVE-2022-29166": {"epss_score": 0.00845, "epss_percentile": 0.74284}, "CVE-2022-29167": {"epss_score": 0.00107, "epss_percentile": 0.29635}, "CVE-2022-29168": {"epss_score": 0.00644, "epss_percentile": 0.70091}, "CVE-2022-29169": {"epss_score": 0.00652, "epss_percentile": 0.70312}, "CVE-2022-29170": {"epss_score": 0.00105, "epss_percentile": 0.29323}, "CVE-2022-29171": {"epss_score": 0.0224, "epss_percentile": 0.84112}, "CVE-2022-29172": {"epss_score": 0.00207, "epss_percentile": 0.43131}, "CVE-2022-29173": {"epss_score": 0.00131, "epss_percentile": 0.33416}, "CVE-2022-29174": {"epss_score": 0.0035, "epss_percentile": 0.56975}, "CVE-2022-29176": {"epss_score": 0.00961, "epss_percentile": 0.75981}, "CVE-2022-29177": {"epss_score": 0.00433, "epss_percentile": 0.6222}, "CVE-2022-29178": {"epss_score": 0.00184, "epss_percentile": 0.40379}, "CVE-2022-29179": {"epss_score": 0.00144, "epss_percentile": 0.35243}, "CVE-2022-29180": {"epss_score": 0.0025, "epss_percentile": 0.48114}, "CVE-2022-29181": {"epss_score": 0.05756, "epss_percentile": 0.90181}, "CVE-2022-29182": {"epss_score": 0.00612, "epss_percentile": 0.69224}, "CVE-2022-29183": {"epss_score": 0.00569, "epss_percentile": 0.67924}, "CVE-2022-29184": {"epss_score": 0.05295, "epss_percentile": 0.897}, "CVE-2022-29185": {"epss_score": 0.00361, "epss_percentile": 0.57716}, "CVE-2022-29186": {"epss_score": 0.0031, "epss_percentile": 0.53778}, "CVE-2022-29187": {"epss_score": 0.00063, "epss_percentile": 0.19957}, "CVE-2022-29188": {"epss_score": 0.00264, "epss_percentile": 0.49689}, "CVE-2022-29189": {"epss_score": 0.01011, "epss_percentile": 0.76616}, "CVE-2022-29190": {"epss_score": 0.00271, "epss_percentile": 0.50319}, "CVE-2022-29191": {"epss_score": 0.00113, "epss_percentile": 0.30688}, "CVE-2022-29192": {"epss_score": 0.00072, "epss_percentile": 0.22368}, "CVE-2022-29193": {"epss_score": 0.00045, "epss_percentile": 0.13814}, "CVE-2022-29194": {"epss_score": 0.00072, "epss_percentile": 0.22368}, "CVE-2022-29195": {"epss_score": 0.00044, "epss_percentile": 0.13488}, "CVE-2022-29196": {"epss_score": 0.00044, "epss_percentile": 0.13554}, "CVE-2022-29197": {"epss_score": 0.00044, "epss_percentile": 0.13554}, "CVE-2022-29198": {"epss_score": 0.00044, "epss_percentile": 0.13554}, "CVE-2022-29199": {"epss_score": 0.00044, "epss_percentile": 0.13488}, "CVE-2022-29200": {"epss_score": 0.00044, "epss_percentile": 0.13554}, "CVE-2022-29201": {"epss_score": 0.00044, "epss_percentile": 0.13488}, "CVE-2022-29202": {"epss_score": 0.00051, "epss_percentile": 0.16303}, "CVE-2022-29203": {"epss_score": 0.00045, "epss_percentile": 0.13699}, "CVE-2022-29204": {"epss_score": 0.00049, "epss_percentile": 0.15625}, "CVE-2022-29205": {"epss_score": 0.00052, "epss_percentile": 0.16568}, "CVE-2022-29206": {"epss_score": 0.00069, "epss_percentile": 0.2159}, "CVE-2022-29207": {"epss_score": 0.00045, "epss_percentile": 0.1373}, "CVE-2022-29208": {"epss_score": 0.00066, "epss_percentile": 0.20888}, "CVE-2022-29209": {"epss_score": 0.00074, "epss_percentile": 0.22834}, "CVE-2022-29210": {"epss_score": 0.00039, "epss_percentile": 0.11482}, "CVE-2022-29211": {"epss_score": 0.0008, "epss_percentile": 0.24129}, "CVE-2022-29212": {"epss_score": 0.00084, "epss_percentile": 0.24976}, "CVE-2022-29213": {"epss_score": 0.00084, "epss_percentile": 0.24976}, "CVE-2022-29214": {"epss_score": 0.00239, "epss_percentile": 0.46859}, "CVE-2022-29215": {"epss_score": 0.00299, "epss_percentile": 0.52872}, "CVE-2022-29216": {"epss_score": 0.00271, "epss_percentile": 0.50295}, "CVE-2022-29217": {"epss_score": 0.00311, "epss_percentile": 0.53823}, "CVE-2022-29218": {"epss_score": 0.00147, "epss_percentile": 0.35754}, "CVE-2022-29219": {"epss_score": 0.00289, "epss_percentile": 0.51984}, "CVE-2022-29220": {"epss_score": 0.00082, "epss_percentile": 0.24498}, "CVE-2022-29221": {"epss_score": 0.16785, "epss_percentile": 0.94732}, "CVE-2022-29222": {"epss_score": 0.0041, "epss_percentile": 0.60843}, "CVE-2022-29223": {"epss_score": 0.00365, "epss_percentile": 0.58005}, "CVE-2022-29224": {"epss_score": 0.01032, "epss_percentile": 0.76862}, "CVE-2022-29225": {"epss_score": 0.0009, "epss_percentile": 0.26127}, "CVE-2022-29226": {"epss_score": 0.00084, "epss_percentile": 0.24858}, "CVE-2022-29227": {"epss_score": 0.00437, "epss_percentile": 0.62535}, "CVE-2022-29228": {"epss_score": 0.00388, "epss_percentile": 0.59351}, "CVE-2022-29229": {"epss_score": 0.00099, "epss_percentile": 0.27838}, "CVE-2022-29230": {"epss_score": 0.00306, "epss_percentile": 0.53422}, "CVE-2022-29232": {"epss_score": 0.00362, "epss_percentile": 0.57811}, "CVE-2022-29233": {"epss_score": 0.00338, "epss_percentile": 0.56158}, "CVE-2022-29234": {"epss_score": 0.00327, "epss_percentile": 0.551}, "CVE-2022-29235": {"epss_score": 0.00544, "epss_percentile": 0.6714}, "CVE-2022-29236": {"epss_score": 0.00354, "epss_percentile": 0.57205}, "CVE-2022-29237": {"epss_score": 0.00146, "epss_percentile": 0.35621}, "CVE-2022-29238": {"epss_score": 0.00389, "epss_percentile": 0.59488}, "CVE-2022-29240": {"epss_score": 0.00452, "epss_percentile": 0.63167}, "CVE-2022-29241": {"epss_score": 0.00489, "epss_percentile": 0.64884}, "CVE-2022-29242": {"epss_score": 0.01051, "epss_percentile": 0.77086}, "CVE-2022-29243": {"epss_score": 0.00931, "epss_percentile": 0.75617}, "CVE-2022-29244": {"epss_score": 0.01074, "epss_percentile": 0.77295}, "CVE-2022-29245": {"epss_score": 0.00319, "epss_percentile": 0.54464}, "CVE-2022-29246": {"epss_score": 0.02444, "epss_percentile": 0.84762}, "CVE-2022-29247": {"epss_score": 0.00803, "epss_percentile": 0.73607}, "CVE-2022-29248": {"epss_score": 0.00637, "epss_percentile": 0.69883}, "CVE-2022-29249": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2022-29250": {"epss_score": 0.00248, "epss_percentile": 0.47999}, "CVE-2022-29251": {"epss_score": 0.02979, "epss_percentile": 0.86115}, "CVE-2022-29252": {"epss_score": 0.00827, "epss_percentile": 0.73984}, "CVE-2022-29253": {"epss_score": 0.00063, "epss_percentile": 0.19873}, "CVE-2022-29254": {"epss_score": 0.00286, "epss_percentile": 0.5177}, "CVE-2022-29255": {"epss_score": 0.00102, "epss_percentile": 0.28841}, "CVE-2022-29256": {"epss_score": 0.00164, "epss_percentile": 0.37976}, "CVE-2022-29257": {"epss_score": 0.00451, "epss_percentile": 0.63132}, "CVE-2022-29258": {"epss_score": 0.00827, "epss_percentile": 0.73984}, "CVE-2022-29262": {"epss_score": 0.00063, "epss_percentile": 0.20099}, "CVE-2022-29263": {"epss_score": 0.00082, "epss_percentile": 0.245}, "CVE-2022-29264": {"epss_score": 0.00799, "epss_percentile": 0.73525}, "CVE-2022-29265": {"epss_score": 0.01171, "epss_percentile": 0.78221}, "CVE-2022-29266": {"epss_score": 0.36449, "epss_percentile": 0.96978}, "CVE-2022-29269": {"epss_score": 0.05094, "epss_percentile": 0.8949}, "CVE-2022-29270": {"epss_score": 0.00543, "epss_percentile": 0.67106}, "CVE-2022-29271": {"epss_score": 0.00543, "epss_percentile": 0.67106}, "CVE-2022-29272": {"epss_score": 0.04126, "epss_percentile": 0.8829}, "CVE-2022-29273": {"epss_score": 0.47269, "epss_percentile": 0.9758}, "CVE-2022-29275": {"epss_score": 0.00074, "epss_percentile": 0.22731}, "CVE-2022-29276": {"epss_score": 0.00121, "epss_percentile": 0.31835}, "CVE-2022-29277": {"epss_score": 0.00049, "epss_percentile": 0.15569}, "CVE-2022-29278": {"epss_score": 0.00051, "epss_percentile": 0.15989}, "CVE-2022-29279": {"epss_score": 0.00051, "epss_percentile": 0.15989}, "CVE-2022-29281": {"epss_score": 0.0113, "epss_percentile": 0.77853}, "CVE-2022-29286": {"epss_score": 0.00598, "epss_percentile": 0.68784}, "CVE-2022-29287": {"epss_score": 0.00267, "epss_percentile": 0.5002}, "CVE-2022-29296": {"epss_score": 0.00481, "epss_percentile": 0.64511}, "CVE-2022-29298": {"epss_score": 0.82294, "epss_percentile": 0.99185}, "CVE-2022-29302": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2022-29303": {"epss_score": 0.94372, "epss_percentile": 0.99961}, "CVE-2022-29304": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-29305": {"epss_score": 0.00332, "epss_percentile": 0.55601}, "CVE-2022-29306": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-29307": {"epss_score": 0.06668, "epss_percentile": 0.9093}, "CVE-2022-29309": {"epss_score": 0.00243, "epss_percentile": 0.4748}, "CVE-2022-29315": {"epss_score": 0.00356, "epss_percentile": 0.57327}, "CVE-2022-29316": {"epss_score": 0.54326, "epss_percentile": 0.9792}, "CVE-2022-29317": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29318": {"epss_score": 0.00993, "epss_percentile": 0.76418}, "CVE-2022-29320": {"epss_score": 0.00136, "epss_percentile": 0.34081}, "CVE-2022-29321": {"epss_score": 0.01873, "epss_percentile": 0.82646}, "CVE-2022-29322": {"epss_score": 0.02552, "epss_percentile": 0.85083}, "CVE-2022-29323": {"epss_score": 0.01873, "epss_percentile": 0.82646}, "CVE-2022-29324": {"epss_score": 0.01873, "epss_percentile": 0.82646}, "CVE-2022-29325": {"epss_score": 0.01498, "epss_percentile": 0.80695}, "CVE-2022-29326": {"epss_score": 0.01498, "epss_percentile": 0.80695}, "CVE-2022-29327": {"epss_score": 0.01498, "epss_percentile": 0.80695}, "CVE-2022-29328": {"epss_score": 0.02552, "epss_percentile": 0.85083}, "CVE-2022-29329": {"epss_score": 0.02552, "epss_percentile": 0.85083}, "CVE-2022-29330": {"epss_score": 0.00335, "epss_percentile": 0.55895}, "CVE-2022-29332": {"epss_score": 0.01002, "epss_percentile": 0.76505}, "CVE-2022-29333": {"epss_score": 0.00218, "epss_percentile": 0.44345}, "CVE-2022-29334": {"epss_score": 0.00333, "epss_percentile": 0.5566}, "CVE-2022-29337": {"epss_score": 0.30421, "epss_percentile": 0.96537}, "CVE-2022-29339": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2022-29340": {"epss_score": 0.00275, "epss_percentile": 0.50682}, "CVE-2022-29347": {"epss_score": 0.00565, "epss_percentile": 0.67783}, "CVE-2022-29349": {"epss_score": 0.02663, "epss_percentile": 0.85373}, "CVE-2022-29351": {"epss_score": 0.01353, "epss_percentile": 0.79696}, "CVE-2022-29353": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2022-29354": {"epss_score": 0.03874, "epss_percentile": 0.87886}, "CVE-2022-29358": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2022-29359": {"epss_score": 0.00768, "epss_percentile": 0.72966}, "CVE-2022-29360": {"epss_score": 0.00952, "epss_percentile": 0.75874}, "CVE-2022-29361": {"epss_score": 0.31113, "epss_percentile": 0.96589}, "CVE-2022-29362": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-29363": {"epss_score": 0.00204, "epss_percentile": 0.42645}, "CVE-2022-29368": {"epss_score": 0.00201, "epss_percentile": 0.4237}, "CVE-2022-29369": {"epss_score": 0.0041, "epss_percentile": 0.60822}, "CVE-2022-29376": {"epss_score": 0.00578, "epss_percentile": 0.68184}, "CVE-2022-29377": {"epss_score": 0.00296, "epss_percentile": 0.52536}, "CVE-2022-29379": {"epss_score": 0.00497, "epss_percentile": 0.65179}, "CVE-2022-29380": {"epss_score": 0.00282, "epss_percentile": 0.51249}, "CVE-2022-29383": {"epss_score": 0.75246, "epss_percentile": 0.98835}, "CVE-2022-29391": {"epss_score": 0.0048, "epss_percentile": 0.64459}, "CVE-2022-29392": {"epss_score": 0.0048, "epss_percentile": 0.64459}, "CVE-2022-29393": {"epss_score": 0.0048, "epss_percentile": 0.64459}, "CVE-2022-29394": {"epss_score": 0.0048, "epss_percentile": 0.64459}, "CVE-2022-29395": {"epss_score": 0.0048, "epss_percentile": 0.64459}, "CVE-2022-29396": {"epss_score": 0.0048, "epss_percentile": 0.64459}, "CVE-2022-29397": {"epss_score": 0.0048, "epss_percentile": 0.64459}, "CVE-2022-29398": {"epss_score": 0.00478, "epss_percentile": 0.644}, "CVE-2022-29399": {"epss_score": 0.00478, "epss_percentile": 0.644}, "CVE-2022-29402": {"epss_score": 0.00071, "epss_percentile": 0.22068}, "CVE-2022-29404": {"epss_score": 0.01986, "epss_percentile": 0.83159}, "CVE-2022-29405": {"epss_score": 0.01444, "epss_percentile": 0.80321}, "CVE-2022-29406": {"epss_score": 0.00153, "epss_percentile": 0.36586}, "CVE-2022-29408": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-29410": {"epss_score": 0.00336, "epss_percentile": 0.559}, "CVE-2022-29411": {"epss_score": 0.00383, "epss_percentile": 0.59103}, "CVE-2022-29412": {"epss_score": 0.00093, "epss_percentile": 0.26707}, "CVE-2022-29413": {"epss_score": 0.00108, "epss_percentile": 0.29796}, "CVE-2022-29414": {"epss_score": 0.00098, "epss_percentile": 0.27707}, "CVE-2022-29415": {"epss_score": 0.0031, "epss_percentile": 0.53804}, "CVE-2022-29416": {"epss_score": 0.00121, "epss_percentile": 0.32006}, "CVE-2022-29417": {"epss_score": 0.00135, "epss_percentile": 0.33993}, "CVE-2022-29418": {"epss_score": 0.00579, "epss_percentile": 0.6822}, "CVE-2022-29419": {"epss_score": 0.00373, "epss_percentile": 0.58478}, "CVE-2022-29420": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-29421": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-29422": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2022-29423": {"epss_score": 0.00488, "epss_percentile": 0.64849}, "CVE-2022-29424": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2022-29425": {"epss_score": 0.00288, "epss_percentile": 0.51899}, "CVE-2022-29426": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2022-29427": {"epss_score": 0.00148, "epss_percentile": 0.35801}, "CVE-2022-29428": {"epss_score": 0.00195, "epss_percentile": 0.4166}, "CVE-2022-29429": {"epss_score": 0.00677, "epss_percentile": 0.70947}, "CVE-2022-29430": {"epss_score": 0.00135, "epss_percentile": 0.33993}, "CVE-2022-29431": {"epss_score": 0.00144, "epss_percentile": 0.35314}, "CVE-2022-29432": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2022-29433": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2022-29434": {"epss_score": 0.01581, "epss_percentile": 0.81138}, "CVE-2022-29435": {"epss_score": 0.00164, "epss_percentile": 0.37971}, "CVE-2022-29436": {"epss_score": 0.00099, "epss_percentile": 0.27841}, "CVE-2022-29437": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2022-29438": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2022-29439": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-29440": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2022-29441": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-29442": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2022-29443": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2022-29444": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2022-29445": {"epss_score": 0.01141, "epss_percentile": 0.77964}, "CVE-2022-29446": {"epss_score": 0.00695, "epss_percentile": 0.71376}, "CVE-2022-29447": {"epss_score": 0.00695, "epss_percentile": 0.71376}, "CVE-2022-29448": {"epss_score": 0.00978, "epss_percentile": 0.76252}, "CVE-2022-29449": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2022-29450": {"epss_score": 0.00113, "epss_percentile": 0.30632}, "CVE-2022-29451": {"epss_score": 0.00227, "epss_percentile": 0.45455}, "CVE-2022-29452": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2022-29453": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-29454": {"epss_score": 0.00325, "epss_percentile": 0.54997}, "CVE-2022-29455": {"epss_score": 0.48769, "epss_percentile": 0.97653}, "CVE-2022-29457": {"epss_score": 0.08262, "epss_percentile": 0.91957}, "CVE-2022-29458": {"epss_score": 0.00045, "epss_percentile": 0.13815}, "CVE-2022-29464": {"epss_score": 0.94434, "epss_percentile": 0.99983}, "CVE-2022-29465": {"epss_score": 0.10766, "epss_percentile": 0.93097}, "CVE-2022-29466": {"epss_score": 0.00061, "epss_percentile": 0.19398}, "CVE-2022-29467": {"epss_score": 0.00164, "epss_percentile": 0.37904}, "CVE-2022-29468": {"epss_score": 0.01325, "epss_percentile": 0.79476}, "CVE-2022-29470": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2022-29471": {"epss_score": 0.00153, "epss_percentile": 0.36557}, "CVE-2022-29472": {"epss_score": 0.01141, "epss_percentile": 0.77957}, "CVE-2022-29473": {"epss_score": 0.00674, "epss_percentile": 0.70861}, "CVE-2022-29474": {"epss_score": 0.00137, "epss_percentile": 0.34283}, "CVE-2022-29475": {"epss_score": 0.00293, "epss_percentile": 0.52345}, "CVE-2022-29476": {"epss_score": 0.00769, "epss_percentile": 0.72988}, "CVE-2022-29477": {"epss_score": 0.00172, "epss_percentile": 0.38926}, "CVE-2022-29479": {"epss_score": 0.00868, "epss_percentile": 0.7467}, "CVE-2022-29480": {"epss_score": 0.00868, "epss_percentile": 0.7467}, "CVE-2022-29481": {"epss_score": 0.00384, "epss_percentile": 0.59169}, "CVE-2022-29482": {"epss_score": 0.00111, "epss_percentile": 0.30243}, "CVE-2022-29483": {"epss_score": 0.00029, "epss_percentile": 0.07675}, "CVE-2022-29484": {"epss_score": 0.00396, "epss_percentile": 0.59889}, "CVE-2022-29485": {"epss_score": 0.00381, "epss_percentile": 0.58976}, "CVE-2022-29486": {"epss_score": 0.01151, "epss_percentile": 0.78039}, "CVE-2022-29487": {"epss_score": 0.00189, "epss_percentile": 0.40923}, "CVE-2022-29488": {"epss_score": 0.00302, "epss_percentile": 0.53099}, "CVE-2022-29489": {"epss_score": 0.00106, "epss_percentile": 0.29533}, "CVE-2022-29490": {"epss_score": 0.00336, "epss_percentile": 0.55931}, "CVE-2022-29491": {"epss_score": 0.01037, "epss_percentile": 0.7692}, "CVE-2022-29492": {"epss_score": 0.00273, "epss_percentile": 0.50434}, "CVE-2022-29493": {"epss_score": 0.00107, "epss_percentile": 0.29683}, "CVE-2022-29494": {"epss_score": 0.00161, "epss_percentile": 0.3761}, "CVE-2022-29495": {"epss_score": 0.00093, "epss_percentile": 0.26637}, "CVE-2022-29496": {"epss_score": 0.01054, "epss_percentile": 0.77104}, "CVE-2022-29498": {"epss_score": 0.00186, "epss_percentile": 0.40646}, "CVE-2022-29499": {"epss_score": 0.90941, "epss_percentile": 0.9961}, "CVE-2022-29500": {"epss_score": 0.01113, "epss_percentile": 0.77686}, "CVE-2022-29501": {"epss_score": 0.01438, "epss_percentile": 0.80287}, "CVE-2022-29502": {"epss_score": 0.0052, "epss_percentile": 0.66201}, "CVE-2022-29503": {"epss_score": 0.00558, "epss_percentile": 0.6757}, "CVE-2022-29505": {"epss_score": 0.00057, "epss_percentile": 0.18045}, "CVE-2022-29506": {"epss_score": 0.00377, "epss_percentile": 0.58714}, "CVE-2022-29507": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2022-29508": {"epss_score": 0.00084, "epss_percentile": 0.25017}, "CVE-2022-29509": {"epss_score": 0.01639, "epss_percentile": 0.81492}, "CVE-2022-29510": {"epss_score": 0.00085, "epss_percentile": 0.25227}, "CVE-2022-29511": {"epss_score": 0.16554, "epss_percentile": 0.94689}, "CVE-2022-29512": {"epss_score": 0.00256, "epss_percentile": 0.48783}, "CVE-2022-29513": {"epss_score": 0.00175, "epss_percentile": 0.39309}, "CVE-2022-29514": {"epss_score": 0.00826, "epss_percentile": 0.73966}, "CVE-2022-29515": {"epss_score": 0.00025, "epss_percentile": 0.06062}, "CVE-2022-29516": {"epss_score": 0.019, "epss_percentile": 0.82772}, "CVE-2022-29517": {"epss_score": 0.49856, "epss_percentile": 0.97708}, "CVE-2022-29518": {"epss_score": 0.00042, "epss_percentile": 0.12799}, "CVE-2022-29519": {"epss_score": 0.00153, "epss_percentile": 0.36608}, "CVE-2022-29520": {"epss_score": 0.0118, "epss_percentile": 0.78304}, "CVE-2022-29522": {"epss_score": 0.00515, "epss_percentile": 0.65975}, "CVE-2022-29523": {"epss_score": 0.00035, "epss_percentile": 0.09994}, "CVE-2022-29524": {"epss_score": 0.00403, "epss_percentile": 0.60348}, "CVE-2022-29525": {"epss_score": 0.0067, "epss_percentile": 0.70777}, "CVE-2022-29526": {"epss_score": 0.00182, "epss_percentile": 0.40251}, "CVE-2022-29527": {"epss_score": 0.00152, "epss_percentile": 0.3642}, "CVE-2022-29528": {"epss_score": 0.00518, "epss_percentile": 0.66131}, "CVE-2022-29529": {"epss_score": 0.0036, "epss_percentile": 0.57627}, "CVE-2022-29530": {"epss_score": 0.0036, "epss_percentile": 0.57627}, "CVE-2022-29531": {"epss_score": 0.0036, "epss_percentile": 0.57627}, "CVE-2022-29532": {"epss_score": 0.00302, "epss_percentile": 0.53129}, "CVE-2022-29533": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2022-29534": {"epss_score": 0.00254, "epss_percentile": 0.48532}, "CVE-2022-29535": {"epss_score": 0.22189, "epss_percentile": 0.95606}, "CVE-2022-29536": {"epss_score": 0.00151, "epss_percentile": 0.36313}, "CVE-2022-29537": {"epss_score": 0.0007, "epss_percentile": 0.21817}, "CVE-2022-29538": {"epss_score": 0.01713, "epss_percentile": 0.81889}, "CVE-2022-29539": {"epss_score": 0.02172, "epss_percentile": 0.83873}, "CVE-2022-29540": {"epss_score": 0.01145, "epss_percentile": 0.77992}, "CVE-2022-29546": {"epss_score": 0.00252, "epss_percentile": 0.48377}, "CVE-2022-29547": {"epss_score": 0.00168, "epss_percentile": 0.38441}, "CVE-2022-29548": {"epss_score": 0.76361, "epss_percentile": 0.98888}, "CVE-2022-29549": {"epss_score": 0.00074, "epss_percentile": 0.22849}, "CVE-2022-29550": {"epss_score": 0.00169, "epss_percentile": 0.38616}, "CVE-2022-29555": {"epss_score": 0.00123, "epss_percentile": 0.32296}, "CVE-2022-29556": {"epss_score": 0.00428, "epss_percentile": 0.61936}, "CVE-2022-29557": {"epss_score": 0.0011, "epss_percentile": 0.30172}, "CVE-2022-29558": {"epss_score": 0.02559, "epss_percentile": 0.85101}, "CVE-2022-29560": {"epss_score": 0.00966, "epss_percentile": 0.76051}, "CVE-2022-29561": {"epss_score": 0.00212, "epss_percentile": 0.43776}, "CVE-2022-29562": {"epss_score": 0.00213, "epss_percentile": 0.43925}, "CVE-2022-29564": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2022-29566": {"epss_score": 0.00243, "epss_percentile": 0.47432}, "CVE-2022-29567": {"epss_score": 0.00267, "epss_percentile": 0.50007}, "CVE-2022-29577": {"epss_score": 0.00243, "epss_percentile": 0.47474}, "CVE-2022-29578": {"epss_score": 0.00168, "epss_percentile": 0.38441}, "CVE-2022-29580": {"epss_score": 0.00166, "epss_percentile": 0.38189}, "CVE-2022-29581": {"epss_score": 0.00289, "epss_percentile": 0.51996}, "CVE-2022-29582": {"epss_score": 0.00149, "epss_percentile": 0.36001}, "CVE-2022-29583": {"epss_score": 0.00063, "epss_percentile": 0.20076}, "CVE-2022-29584": {"epss_score": 0.00437, "epss_percentile": 0.62535}, "CVE-2022-29585": {"epss_score": 0.0024, "epss_percentile": 0.47203}, "CVE-2022-29586": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2022-29587": {"epss_score": 0.00052, "epss_percentile": 0.16546}, "CVE-2022-29588": {"epss_score": 0.00506, "epss_percentile": 0.65616}, "CVE-2022-29589": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-29591": {"epss_score": 0.00366, "epss_percentile": 0.58065}, "CVE-2022-29592": {"epss_score": 0.1419, "epss_percentile": 0.94159}, "CVE-2022-29593": {"epss_score": 0.08172, "epss_percentile": 0.91914}, "CVE-2022-29594": {"epss_score": 0.0003, "epss_percentile": 0.08178}, "CVE-2022-29596": {"epss_score": 0.01268, "epss_percentile": 0.79029}, "CVE-2022-29597": {"epss_score": 0.06086, "epss_percentile": 0.90466}, "CVE-2022-29598": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-29599": {"epss_score": 0.00449, "epss_percentile": 0.63036}, "CVE-2022-29600": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29601": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29602": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-29603": {"epss_score": 0.00211, "epss_percentile": 0.43679}, "CVE-2022-29604": {"epss_score": 0.00103, "epss_percentile": 0.29047}, "CVE-2022-29605": {"epss_score": 0.0007, "epss_percentile": 0.21718}, "CVE-2022-29606": {"epss_score": 0.00103, "epss_percentile": 0.29047}, "CVE-2022-29607": {"epss_score": 0.0007, "epss_percentile": 0.21718}, "CVE-2022-29608": {"epss_score": 0.00072, "epss_percentile": 0.22377}, "CVE-2022-29609": {"epss_score": 0.0007, "epss_percentile": 0.21718}, "CVE-2022-29610": {"epss_score": 0.0037, "epss_percentile": 0.58283}, "CVE-2022-29611": {"epss_score": 0.00404, "epss_percentile": 0.60447}, "CVE-2022-29612": {"epss_score": 0.00148, "epss_percentile": 0.3593}, "CVE-2022-29613": {"epss_score": 0.00368, "epss_percentile": 0.58221}, "CVE-2022-29614": {"epss_score": 0.0011, "epss_percentile": 0.30206}, "CVE-2022-29615": {"epss_score": 0.00087, "epss_percentile": 0.25463}, "CVE-2022-29616": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2022-29617": {"epss_score": 0.00287, "epss_percentile": 0.51788}, "CVE-2022-29618": {"epss_score": 0.03108, "epss_percentile": 0.86422}, "CVE-2022-29619": {"epss_score": 0.00241, "epss_percentile": 0.47265}, "CVE-2022-29620": {"epss_score": 0.0049, "epss_percentile": 0.64942}, "CVE-2022-29622": {"epss_score": 0.34403, "epss_percentile": 0.96846}, "CVE-2022-29623": {"epss_score": 0.00448, "epss_percentile": 0.6302}, "CVE-2022-29624": {"epss_score": 0.00771, "epss_percentile": 0.73014}, "CVE-2022-29627": {"epss_score": 0.0016, "epss_percentile": 0.37448}, "CVE-2022-29628": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-29631": {"epss_score": 0.00084, "epss_percentile": 0.24972}, "CVE-2022-29632": {"epss_score": 0.01169, "epss_percentile": 0.78199}, "CVE-2022-29633": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2022-29637": {"epss_score": 0.00311, "epss_percentile": 0.53923}, "CVE-2022-29638": {"epss_score": 0.00407, "epss_percentile": 0.60572}, "CVE-2022-29639": {"epss_score": 0.02242, "epss_percentile": 0.84119}, "CVE-2022-29640": {"epss_score": 0.00407, "epss_percentile": 0.60572}, "CVE-2022-29641": {"epss_score": 0.00407, "epss_percentile": 0.60572}, "CVE-2022-29642": {"epss_score": 0.00407, "epss_percentile": 0.60572}, "CVE-2022-29643": {"epss_score": 0.00407, "epss_percentile": 0.60572}, "CVE-2022-29644": {"epss_score": 0.00394, "epss_percentile": 0.59761}, "CVE-2022-29645": {"epss_score": 0.00394, "epss_percentile": 0.59761}, "CVE-2022-29646": {"epss_score": 0.00205, "epss_percentile": 0.42744}, "CVE-2022-29647": {"epss_score": 0.00382, "epss_percentile": 0.59066}, "CVE-2022-29648": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-29649": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-29650": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29651": {"epss_score": 0.00921, "epss_percentile": 0.75485}, "CVE-2022-29652": {"epss_score": 0.00194, "epss_percentile": 0.41592}, "CVE-2022-29653": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-29654": {"epss_score": 0.00032, "epss_percentile": 0.08773}, "CVE-2022-29655": {"epss_score": 0.00993, "epss_percentile": 0.76418}, "CVE-2022-29656": {"epss_score": 0.00608, "epss_percentile": 0.69079}, "CVE-2022-29659": {"epss_score": 0.00359, "epss_percentile": 0.57553}, "CVE-2022-29660": {"epss_score": 0.01782, "epss_percentile": 0.82243}, "CVE-2022-29661": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29662": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29663": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29664": {"epss_score": 0.00279, "epss_percentile": 0.50967}, "CVE-2022-29665": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29666": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29667": {"epss_score": 0.00279, "epss_percentile": 0.50967}, "CVE-2022-29669": {"epss_score": 0.00279, "epss_percentile": 0.50967}, "CVE-2022-29670": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29676": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29680": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29681": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29682": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29683": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29684": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29685": {"epss_score": 0.00279, "epss_percentile": 0.50967}, "CVE-2022-29686": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29687": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29688": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29689": {"epss_score": 0.00297, "epss_percentile": 0.52765}, "CVE-2022-29692": {"epss_score": 0.00169, "epss_percentile": 0.38527}, "CVE-2022-29693": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2022-29694": {"epss_score": 0.00756, "epss_percentile": 0.72732}, "CVE-2022-29695": {"epss_score": 0.00403, "epss_percentile": 0.6036}, "CVE-2022-29700": {"epss_score": 0.00391, "epss_percentile": 0.59582}, "CVE-2022-29701": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2022-29704": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-29709": {"epss_score": 0.00819, "epss_percentile": 0.73873}, "CVE-2022-29710": {"epss_score": 0.00471, "epss_percentile": 0.64022}, "CVE-2022-29711": {"epss_score": 3e-05, "epss_percentile": 0.001}, "CVE-2022-29712": {"epss_score": 0.0002, "epss_percentile": 0.04638}, "CVE-2022-29718": {"epss_score": 0.0009, "epss_percentile": 0.2606}, "CVE-2022-29720": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2022-29721": {"epss_score": 0.00303, "epss_percentile": 0.53175}, "CVE-2022-29725": {"epss_score": 0.00782, "epss_percentile": 0.73198}, "CVE-2022-29727": {"epss_score": 0.01867, "epss_percentile": 0.82617}, "CVE-2022-29728": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-29729": {"epss_score": 0.00859, "epss_percentile": 0.7452}, "CVE-2022-29730": {"epss_score": 0.00643, "epss_percentile": 0.70063}, "CVE-2022-29731": {"epss_score": 0.00106, "epss_percentile": 0.29425}, "CVE-2022-29732": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-29733": {"epss_score": 0.00115, "epss_percentile": 0.3096}, "CVE-2022-29734": {"epss_score": 0.00576, "epss_percentile": 0.68143}, "CVE-2022-29735": {"epss_score": 0.00622, "epss_percentile": 0.69507}, "CVE-2022-29738": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29739": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29741": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29745": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29746": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29747": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2022-29748": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2022-29749": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2022-29750": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2022-29751": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2022-29767": {"epss_score": 0.00308, "epss_percentile": 0.53623}, "CVE-2022-29770": {"epss_score": 0.00199, "epss_percentile": 0.4211}, "CVE-2022-29773": {"epss_score": 0.00274, "epss_percentile": 0.50511}, "CVE-2022-29774": {"epss_score": 0.26042, "epss_percentile": 0.96103}, "CVE-2022-29775": {"epss_score": 0.5275, "epss_percentile": 0.97839}, "CVE-2022-29776": {"epss_score": 0.16162, "epss_percentile": 0.94583}, "CVE-2022-29777": {"epss_score": 0.16162, "epss_percentile": 0.94583}, "CVE-2022-29778": {"epss_score": 0.23101, "epss_percentile": 0.95735}, "CVE-2022-29779": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2022-29780": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2022-29784": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2022-29788": {"epss_score": 0.00312, "epss_percentile": 0.53966}, "CVE-2022-29789": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-29790": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-29791": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-29792": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-29793": {"epss_score": 0.00262, "epss_percentile": 0.49386}, "CVE-2022-29794": {"epss_score": 0.0029, "epss_percentile": 0.52123}, "CVE-2022-29795": {"epss_score": 0.00191, "epss_percentile": 0.41213}, "CVE-2022-29796": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-29797": {"epss_score": 0.00223, "epss_percentile": 0.44943}, "CVE-2022-29798": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2022-29799": {"epss_score": 0.00651, "epss_percentile": 0.70291}, "CVE-2022-29800": {"epss_score": 0.00254, "epss_percentile": 0.48544}, "CVE-2022-29801": {"epss_score": 0.00407, "epss_percentile": 0.60574}, "CVE-2022-29804": {"epss_score": 0.00082, "epss_percentile": 0.24564}, "CVE-2022-29805": {"epss_score": 0.08872, "epss_percentile": 0.92295}, "CVE-2022-29806": {"epss_score": 0.88653, "epss_percentile": 0.99482}, "CVE-2022-29807": {"epss_score": 0.02023, "epss_percentile": 0.83306}, "CVE-2022-29808": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2022-29810": {"epss_score": 0.00099, "epss_percentile": 0.28362}, "CVE-2022-29811": {"epss_score": 6e-05, "epss_percentile": 0.00293}, "CVE-2022-29812": {"epss_score": 1e-05, "epss_percentile": 0.00013}, "CVE-2022-29813": {"epss_score": 2e-05, "epss_percentile": 0.00043}, "CVE-2022-29814": {"epss_score": 2e-05, "epss_percentile": 0.00047}, "CVE-2022-29815": {"epss_score": 2e-05, "epss_percentile": 0.00043}, "CVE-2022-29816": {"epss_score": 2e-05, "epss_percentile": 0.00056}, "CVE-2022-29817": {"epss_score": 7e-05, "epss_percentile": 0.00367}, "CVE-2022-29818": {"epss_score": 1e-05, "epss_percentile": 0.00011}, "CVE-2022-29819": {"epss_score": 2e-05, "epss_percentile": 0.00046}, "CVE-2022-29820": {"epss_score": 1e-05, "epss_percentile": 0.00016}, "CVE-2022-29821": {"epss_score": 1e-05, "epss_percentile": 0.00011}, "CVE-2022-29822": {"epss_score": 0.00318, "epss_percentile": 0.54456}, "CVE-2022-29823": {"epss_score": 0.04159, "epss_percentile": 0.88333}, "CVE-2022-29824": {"epss_score": 0.00074, "epss_percentile": 0.22862}, "CVE-2022-29825": {"epss_score": 0.00359, "epss_percentile": 0.57541}, "CVE-2022-29826": {"epss_score": 0.00234, "epss_percentile": 0.46164}, "CVE-2022-29827": {"epss_score": 0.01013, "epss_percentile": 0.76634}, "CVE-2022-29828": {"epss_score": 0.01013, "epss_percentile": 0.76634}, "CVE-2022-29829": {"epss_score": 0.00668, "epss_percentile": 0.70744}, "CVE-2022-29830": {"epss_score": 0.01546, "epss_percentile": 0.80969}, "CVE-2022-29831": {"epss_score": 0.01633, "epss_percentile": 0.8146}, "CVE-2022-29832": {"epss_score": 0.00473, "epss_percentile": 0.64084}, "CVE-2022-29833": {"epss_score": 0.00725, "epss_percentile": 0.72056}, "CVE-2022-29834": {"epss_score": 0.00856, "epss_percentile": 0.74476}, "CVE-2022-29835": {"epss_score": 0.00077, "epss_percentile": 0.23451}, "CVE-2022-29836": {"epss_score": 0.0017, "epss_percentile": 0.3875}, "CVE-2022-29837": {"epss_score": 0.00092, "epss_percentile": 0.26458}, "CVE-2022-29838": {"epss_score": 0.00155, "epss_percentile": 0.36838}, "CVE-2022-29839": {"epss_score": 0.00101, "epss_percentile": 0.28669}, "CVE-2022-29840": {"epss_score": 0.00038, "epss_percentile": 0.11301}, "CVE-2022-29841": {"epss_score": 0.00276, "epss_percentile": 0.50764}, "CVE-2022-29842": {"epss_score": 0.0087, "epss_percentile": 0.74697}, "CVE-2022-29843": {"epss_score": 0.0084, "epss_percentile": 0.74198}, "CVE-2022-29844": {"epss_score": 0.58541, "epss_percentile": 0.98123}, "CVE-2022-29845": {"epss_score": 0.42249, "epss_percentile": 0.97322}, "CVE-2022-29846": {"epss_score": 0.365, "epss_percentile": 0.96981}, "CVE-2022-29847": {"epss_score": 0.84042, "epss_percentile": 0.99271}, "CVE-2022-29848": {"epss_score": 0.56728, "epss_percentile": 0.98034}, "CVE-2022-29849": {"epss_score": 0.00011, "epss_percentile": 0.00966}, "CVE-2022-29850": {"epss_score": 0.00725, "epss_percentile": 0.72062}, "CVE-2022-29851": {"epss_score": 0.01605, "epss_percentile": 0.81288}, "CVE-2022-29852": {"epss_score": 0.00548, "epss_percentile": 0.67283}, "CVE-2022-29853": {"epss_score": 0.00548, "epss_percentile": 0.67283}, "CVE-2022-29854": {"epss_score": 0.00408, "epss_percentile": 0.60676}, "CVE-2022-29855": {"epss_score": 0.00354, "epss_percentile": 0.57211}, "CVE-2022-29856": {"epss_score": 0.00557, "epss_percentile": 0.67545}, "CVE-2022-29858": {"epss_score": 0.00332, "epss_percentile": 0.55554}, "CVE-2022-29859": {"epss_score": 0.00433, "epss_percentile": 0.6228}, "CVE-2022-29862": {"epss_score": 0.00802, "epss_percentile": 0.7358}, "CVE-2022-29863": {"epss_score": 0.00628, "epss_percentile": 0.69647}, "CVE-2022-29864": {"epss_score": 0.02412, "epss_percentile": 0.84672}, "CVE-2022-29865": {"epss_score": 0.00492, "epss_percentile": 0.64983}, "CVE-2022-29866": {"epss_score": 0.00797, "epss_percentile": 0.73494}, "CVE-2022-29868": {"epss_score": 0.00028, "epss_percentile": 0.07447}, "CVE-2022-29869": {"epss_score": 0.00927, "epss_percentile": 0.75559}, "CVE-2022-29871": {"epss_score": 0.0006, "epss_percentile": 0.19023}, "CVE-2022-29872": {"epss_score": 0.0143, "epss_percentile": 0.80235}, "CVE-2022-29873": {"epss_score": 0.02966, "epss_percentile": 0.86084}, "CVE-2022-29874": {"epss_score": 0.00346, "epss_percentile": 0.56651}, "CVE-2022-29875": {"epss_score": 0.02833, "epss_percentile": 0.85781}, "CVE-2022-29876": {"epss_score": 0.01275, "epss_percentile": 0.79104}, "CVE-2022-29877": {"epss_score": 0.00272, "epss_percentile": 0.50347}, "CVE-2022-29878": {"epss_score": 0.00527, "epss_percentile": 0.66519}, "CVE-2022-29879": {"epss_score": 0.00365, "epss_percentile": 0.57966}, "CVE-2022-29880": {"epss_score": 0.0074, "epss_percentile": 0.72408}, "CVE-2022-29881": {"epss_score": 0.01094, "epss_percentile": 0.77498}, "CVE-2022-29882": {"epss_score": 0.01302, "epss_percentile": 0.79295}, "CVE-2022-29883": {"epss_score": 0.00334, "epss_percentile": 0.55717}, "CVE-2022-29884": {"epss_score": 0.00902, "epss_percentile": 0.75182}, "CVE-2022-29885": {"epss_score": 0.60112, "epss_percentile": 0.98193}, "CVE-2022-29886": {"epss_score": 0.00098, "epss_percentile": 0.27747}, "CVE-2022-29887": {"epss_score": 0.00519, "epss_percentile": 0.66174}, "CVE-2022-29888": {"epss_score": 0.0154, "epss_percentile": 0.80943}, "CVE-2022-29889": {"epss_score": 0.01011, "epss_percentile": 0.76611}, "CVE-2022-29890": {"epss_score": 0.00542, "epss_percentile": 0.67078}, "CVE-2022-29891": {"epss_score": 0.00177, "epss_percentile": 0.39503}, "CVE-2022-29892": {"epss_score": 0.00364, "epss_percentile": 0.5792}, "CVE-2022-29893": {"epss_score": 0.00284, "epss_percentile": 0.51419}, "CVE-2022-29894": {"epss_score": 0.00476, "epss_percentile": 0.64294}, "CVE-2022-29897": {"epss_score": 0.00814, "epss_percentile": 0.73771}, "CVE-2022-29898": {"epss_score": 0.00539, "epss_percentile": 0.6697}, "CVE-2022-29900": {"epss_score": 0.01411, "epss_percentile": 0.80109}, "CVE-2022-29901": {"epss_score": 0.00073, "epss_percentile": 0.22543}, "CVE-2022-29903": {"epss_score": 0.00067, "epss_percentile": 0.20997}, "CVE-2022-29904": {"epss_score": 0.00897, "epss_percentile": 0.75122}, "CVE-2022-29905": {"epss_score": 0.00093, "epss_percentile": 0.26687}, "CVE-2022-29906": {"epss_score": 0.00391, "epss_percentile": 0.59579}, "CVE-2022-29907": {"epss_score": 0.0041, "epss_percentile": 0.60812}, "CVE-2022-29908": {"epss_score": 0.00042, "epss_percentile": 0.12809}, "CVE-2022-29909": {"epss_score": 0.00047, "epss_percentile": 0.14645}, "CVE-2022-29910": {"epss_score": 0.00247, "epss_percentile": 0.47875}, "CVE-2022-29911": {"epss_score": 0.00179, "epss_percentile": 0.39855}, "CVE-2022-29912": {"epss_score": 0.00366, "epss_percentile": 0.58077}, "CVE-2022-29913": {"epss_score": 0.00179, "epss_percentile": 0.39819}, "CVE-2022-29914": {"epss_score": 0.00109, "epss_percentile": 0.29978}, "CVE-2022-29915": {"epss_score": 0.00131, "epss_percentile": 0.335}, "CVE-2022-29916": {"epss_score": 0.00152, "epss_percentile": 0.36408}, "CVE-2022-29917": {"epss_score": 0.00226, "epss_percentile": 0.45258}, "CVE-2022-29918": {"epss_score": 0.00324, "epss_percentile": 0.54973}, "CVE-2022-29919": {"epss_score": 0.00082, "epss_percentile": 0.24416}, "CVE-2022-29922": {"epss_score": 0.0051, "epss_percentile": 0.65762}, "CVE-2022-29923": {"epss_score": 0.003, "epss_percentile": 0.52946}, "CVE-2022-29925": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2022-29927": {"epss_score": 7e-05, "epss_percentile": 0.0044}, "CVE-2022-29928": {"epss_score": 4e-05, "epss_percentile": 0.0017}, "CVE-2022-29929": {"epss_score": 0.00014, "epss_percentile": 0.02057}, "CVE-2022-29930": {"epss_score": 4e-05, "epss_percentile": 0.00171}, "CVE-2022-29931": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-29932": {"epss_score": 0.04363, "epss_percentile": 0.88598}, "CVE-2022-29933": {"epss_score": 0.02319, "epss_percentile": 0.84362}, "CVE-2022-29934": {"epss_score": 0.0004, "epss_percentile": 0.12045}, "CVE-2022-29935": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2022-29936": {"epss_score": 0.01774, "epss_percentile": 0.82213}, "CVE-2022-29937": {"epss_score": 0.0075, "epss_percentile": 0.72625}, "CVE-2022-29938": {"epss_score": 0.00314, "epss_percentile": 0.54126}, "CVE-2022-29939": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2022-29940": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2022-29942": {"epss_score": 0.00187, "epss_percentile": 0.40796}, "CVE-2022-29943": {"epss_score": 0.00341, "epss_percentile": 0.56286}, "CVE-2022-29944": {"epss_score": 0.0005, "epss_percentile": 0.15716}, "CVE-2022-29945": {"epss_score": 0.00218, "epss_percentile": 0.44338}, "CVE-2022-29946": {"epss_score": 0.00108, "epss_percentile": 0.29768}, "CVE-2022-29947": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-29948": {"epss_score": 0.00669, "epss_percentile": 0.70767}, "CVE-2022-29950": {"epss_score": 0.00167, "epss_percentile": 0.38379}, "CVE-2022-29951": {"epss_score": 0.00324, "epss_percentile": 0.54929}, "CVE-2022-29952": {"epss_score": 0.0026, "epss_percentile": 0.49181}, "CVE-2022-29953": {"epss_score": 0.00381, "epss_percentile": 0.58991}, "CVE-2022-29957": {"epss_score": 0.00077, "epss_percentile": 0.23291}, "CVE-2022-29958": {"epss_score": 0.0013, "epss_percentile": 0.33319}, "CVE-2022-29959": {"epss_score": 0.00104, "epss_percentile": 0.29229}, "CVE-2022-29960": {"epss_score": 0.00086, "epss_percentile": 0.2531}, "CVE-2022-29962": {"epss_score": 0.00072, "epss_percentile": 0.22318}, "CVE-2022-29963": {"epss_score": 0.00072, "epss_percentile": 0.22318}, "CVE-2022-29964": {"epss_score": 0.00072, "epss_percentile": 0.22318}, "CVE-2022-29965": {"epss_score": 0.00038, "epss_percentile": 0.11073}, "CVE-2022-29967": {"epss_score": 0.00364, "epss_percentile": 0.57957}, "CVE-2022-29968": {"epss_score": 0.01777, "epss_percentile": 0.82224}, "CVE-2022-29969": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-29970": {"epss_score": 0.00653, "epss_percentile": 0.70325}, "CVE-2022-29971": {"epss_score": 0.00172, "epss_percentile": 0.39018}, "CVE-2022-29972": {"epss_score": 0.00691, "epss_percentile": 0.71281}, "CVE-2022-29973": {"epss_score": 0.00125, "epss_percentile": 0.32595}, "CVE-2022-29974": {"epss_score": 0.00142, "epss_percentile": 0.35084}, "CVE-2022-29975": {"epss_score": 0.0027, "epss_percentile": 0.50242}, "CVE-2022-29976": {"epss_score": 0.0027, "epss_percentile": 0.50242}, "CVE-2022-29977": {"epss_score": 0.003, "epss_percentile": 0.52978}, "CVE-2022-29978": {"epss_score": 0.003, "epss_percentile": 0.52978}, "CVE-2022-29979": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2022-29980": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2022-29981": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2022-29982": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2022-29983": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2022-29984": {"epss_score": 0.00546, "epss_percentile": 0.67202}, "CVE-2022-29985": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29986": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29987": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29988": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29989": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29990": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29992": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29993": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29994": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29995": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29998": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-29999": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-2000": {"epss_score": 0.00334, "epss_percentile": 0.55687}, "CVE-2022-2001": {"epss_score": 0.00319, "epss_percentile": 0.54545}, "CVE-2022-2002": {"epss_score": 0.00068, "epss_percentile": 0.21246}, "CVE-2022-2003": {"epss_score": 0.00136, "epss_percentile": 0.34147}, "CVE-2022-2004": {"epss_score": 0.0013, "epss_percentile": 0.33254}, "CVE-2022-2005": {"epss_score": 0.0011, "epss_percentile": 0.30131}, "CVE-2022-2006": {"epss_score": 0.00195, "epss_percentile": 0.41646}, "CVE-2022-2007": {"epss_score": 0.01084, "epss_percentile": 0.77395}, "CVE-2022-2008": {"epss_score": 0.00731, "epss_percentile": 0.72173}, "CVE-2022-2010": {"epss_score": 0.01131, "epss_percentile": 0.77857}, "CVE-2022-2011": {"epss_score": 0.00357, "epss_percentile": 0.57456}, "CVE-2022-2013": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2022-2014": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2022-2015": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-2016": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2022-2017": {"epss_score": 0.00261, "epss_percentile": 0.49274}, "CVE-2022-2018": {"epss_score": 0.00261, "epss_percentile": 0.49274}, "CVE-2022-2019": {"epss_score": 0.00196, "epss_percentile": 0.41771}, "CVE-2022-2020": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-2022": {"epss_score": 0.00415, "epss_percentile": 0.61136}, "CVE-2022-2023": {"epss_score": 0.00366, "epss_percentile": 0.58067}, "CVE-2022-2024": {"epss_score": 0.44027, "epss_percentile": 0.97416}, "CVE-2022-2025": {"epss_score": 0.11321, "epss_percentile": 0.93307}, "CVE-2022-2026": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2022-2027": {"epss_score": 0.00373, "epss_percentile": 0.58518}, "CVE-2022-2028": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2022-2029": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2022-2030": {"epss_score": 0.01262, "epss_percentile": 0.78984}, "CVE-2022-2031": {"epss_score": 0.0033, "epss_percentile": 0.55494}, "CVE-2022-2032": {"epss_score": 0.00618, "epss_percentile": 0.69379}, "CVE-2022-2034": {"epss_score": 0.33749, "epss_percentile": 0.96801}, "CVE-2022-2035": {"epss_score": 0.00212, "epss_percentile": 0.43815}, "CVE-2022-2036": {"epss_score": 0.00384, "epss_percentile": 0.59128}, "CVE-2022-2037": {"epss_score": 0.00332, "epss_percentile": 0.55591}, "CVE-2022-2039": {"epss_score": 0.0027, "epss_percentile": 0.50229}, "CVE-2022-2040": {"epss_score": 0.0018, "epss_percentile": 0.39964}, "CVE-2022-2041": {"epss_score": 0.00197, "epss_percentile": 0.41908}, "CVE-2022-2042": {"epss_score": 0.00168, "epss_percentile": 0.38434}, "CVE-2022-2043": {"epss_score": 0.00368, "epss_percentile": 0.58222}, "CVE-2022-2044": {"epss_score": 0.00368, "epss_percentile": 0.58222}, "CVE-2022-2046": {"epss_score": 0.00277, "epss_percentile": 0.50802}, "CVE-2022-2047": {"epss_score": 0.01185, "epss_percentile": 0.78343}, "CVE-2022-2048": {"epss_score": 0.01287, "epss_percentile": 0.79197}, "CVE-2022-2049": {"epss_score": 0.00482, "epss_percentile": 0.64532}, "CVE-2022-2050": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-2052": {"epss_score": 0.00344, "epss_percentile": 0.56545}, "CVE-2022-2053": {"epss_score": 0.00559, "epss_percentile": 0.67628}, "CVE-2022-2054": {"epss_score": 0.0013, "epss_percentile": 0.33289}, "CVE-2022-2056": {"epss_score": 0.001, "epss_percentile": 0.28464}, "CVE-2022-2057": {"epss_score": 0.001, "epss_percentile": 0.28464}, "CVE-2022-2058": {"epss_score": 0.001, "epss_percentile": 0.28464}, "CVE-2022-2059": {"epss_score": 0.00618, "epss_percentile": 0.69379}, "CVE-2022-2060": {"epss_score": 0.00511, "epss_percentile": 0.65828}, "CVE-2022-2061": {"epss_score": 0.00059, "epss_percentile": 0.18627}, "CVE-2022-2062": {"epss_score": 0.01251, "epss_percentile": 0.78897}, "CVE-2022-2063": {"epss_score": 0.01073, "epss_percentile": 0.77291}, "CVE-2022-2064": {"epss_score": 0.00311, "epss_percentile": 0.5382}, "CVE-2022-2065": {"epss_score": 0.00267, "epss_percentile": 0.50013}, "CVE-2022-2066": {"epss_score": 0.00371, "epss_percentile": 0.58419}, "CVE-2022-2067": {"epss_score": 0.00809, "epss_percentile": 0.73709}, "CVE-2022-2068": {"epss_score": 0.1858, "epss_percentile": 0.95036}, "CVE-2022-2069": {"epss_score": 0.00065, "epss_percentile": 0.20546}, "CVE-2022-2070": {"epss_score": 0.09438, "epss_percentile": 0.92548}, "CVE-2022-2071": {"epss_score": 0.00101, "epss_percentile": 0.28698}, "CVE-2022-2072": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-2073": {"epss_score": 0.00213, "epss_percentile": 0.43895}, "CVE-2022-2074": {"epss_score": 0.00482, "epss_percentile": 0.64532}, "CVE-2022-2075": {"epss_score": 0.00482, "epss_percentile": 0.64532}, "CVE-2022-2078": {"epss_score": 0.00494, "epss_percentile": 0.65069}, "CVE-2022-2079": {"epss_score": 0.00404, "epss_percentile": 0.60446}, "CVE-2022-2080": {"epss_score": 0.00361, "epss_percentile": 0.57716}, "CVE-2022-2081": {"epss_score": 0.00155, "epss_percentile": 0.36789}, "CVE-2022-2083": {"epss_score": 0.00257, "epss_percentile": 0.48858}, "CVE-2022-2084": {"epss_score": 0.00021, "epss_percentile": 0.04788}, "CVE-2022-2085": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2022-2086": {"epss_score": 0.02098, "epss_percentile": 0.83592}, "CVE-2022-2087": {"epss_score": 0.00201, "epss_percentile": 0.42302}, "CVE-2022-2088": {"epss_score": 0.00128, "epss_percentile": 0.32976}, "CVE-2022-2089": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-2090": {"epss_score": 0.00199, "epss_percentile": 0.42186}, "CVE-2022-2091": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-2092": {"epss_score": 0.0021, "epss_percentile": 0.43586}, "CVE-2022-2093": {"epss_score": 0.00206, "epss_percentile": 0.42998}, "CVE-2022-2094": {"epss_score": 0.00125, "epss_percentile": 0.32551}, "CVE-2022-2095": {"epss_score": 0.00779, "epss_percentile": 0.73137}, "CVE-2022-2097": {"epss_score": 0.00407, "epss_percentile": 0.60611}, "CVE-2022-2098": {"epss_score": 0.00281, "epss_percentile": 0.51139}, "CVE-2022-2099": {"epss_score": 0.00545, "epss_percentile": 0.67156}, "CVE-2022-2100": {"epss_score": 0.00195, "epss_percentile": 0.41695}, "CVE-2022-2101": {"epss_score": 0.00447, "epss_percentile": 0.6294}, "CVE-2022-2102": {"epss_score": 0.0021, "epss_percentile": 0.43469}, "CVE-2022-2103": {"epss_score": 0.00239, "epss_percentile": 0.46912}, "CVE-2022-2104": {"epss_score": 0.00251, "epss_percentile": 0.48288}, "CVE-2022-2105": {"epss_score": 0.00204, "epss_percentile": 0.42663}, "CVE-2022-2106": {"epss_score": 0.00158, "epss_percentile": 0.3729}, "CVE-2022-2107": {"epss_score": 0.00322, "epss_percentile": 0.54858}, "CVE-2022-2108": {"epss_score": 0.00693, "epss_percentile": 0.71337}, "CVE-2022-2111": {"epss_score": 0.00284, "epss_percentile": 0.5142}, "CVE-2022-2112": {"epss_score": 0.00432, "epss_percentile": 0.62123}, "CVE-2022-2113": {"epss_score": 0.00459, "epss_percentile": 0.63472}, "CVE-2022-2114": {"epss_score": 0.00195, "epss_percentile": 0.41695}, "CVE-2022-2115": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-2116": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-2117": {"epss_score": 0.00776, "epss_percentile": 0.73096}, "CVE-2022-2118": {"epss_score": 0.00195, "epss_percentile": 0.41695}, "CVE-2022-2119": {"epss_score": 0.04609, "epss_percentile": 0.88913}, "CVE-2022-2120": {"epss_score": 0.04609, "epss_percentile": 0.88913}, "CVE-2022-2121": {"epss_score": 0.00075, "epss_percentile": 0.22888}, "CVE-2022-2122": {"epss_score": 0.00061, "epss_percentile": 0.19318}, "CVE-2022-2123": {"epss_score": 0.00103, "epss_percentile": 0.28957}, "CVE-2022-2124": {"epss_score": 0.00227, "epss_percentile": 0.45386}, "CVE-2022-2125": {"epss_score": 0.00155, "epss_percentile": 0.368}, "CVE-2022-2126": {"epss_score": 0.00225, "epss_percentile": 0.451}, "CVE-2022-2127": {"epss_score": 0.0115, "epss_percentile": 0.78026}, "CVE-2022-2128": {"epss_score": 0.00397, "epss_percentile": 0.59981}, "CVE-2022-2129": {"epss_score": 0.00236, "epss_percentile": 0.46459}, "CVE-2022-2130": {"epss_score": 0.25773, "epss_percentile": 0.96068}, "CVE-2022-2131": {"epss_score": 0.00271, "epss_percentile": 0.50294}, "CVE-2022-2132": {"epss_score": 0.00732, "epss_percentile": 0.72193}, "CVE-2022-2133": {"epss_score": 0.00241, "epss_percentile": 0.4728}, "CVE-2022-2134": {"epss_score": 0.00277, "epss_percentile": 0.50801}, "CVE-2022-2135": {"epss_score": 0.002, "epss_percentile": 0.42214}, "CVE-2022-2136": {"epss_score": 0.00176, "epss_percentile": 0.39483}, "CVE-2022-2137": {"epss_score": 0.00204, "epss_percentile": 0.42652}, "CVE-2022-2138": {"epss_score": 0.00165, "epss_percentile": 0.38021}, "CVE-2022-2139": {"epss_score": 0.00468, "epss_percentile": 0.63879}, "CVE-2022-2140": {"epss_score": 0.00284, "epss_percentile": 0.51424}, "CVE-2022-2141": {"epss_score": 0.00322, "epss_percentile": 0.54858}, "CVE-2022-2142": {"epss_score": 0.00192, "epss_percentile": 0.41277}, "CVE-2022-2143": {"epss_score": 0.58306, "epss_percentile": 0.98107}, "CVE-2022-2144": {"epss_score": 0.00097, "epss_percentile": 0.27617}, "CVE-2022-2145": {"epss_score": 0.00093, "epss_percentile": 0.26638}, "CVE-2022-2146": {"epss_score": 0.00128, "epss_percentile": 0.33008}, "CVE-2022-2147": {"epss_score": 0.001, "epss_percentile": 0.28534}, "CVE-2022-2148": {"epss_score": 0.00195, "epss_percentile": 0.41695}, "CVE-2022-2149": {"epss_score": 0.00195, "epss_percentile": 0.41695}, "CVE-2022-2151": {"epss_score": 0.00195, "epss_percentile": 0.41695}, "CVE-2022-2152": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2153": {"epss_score": 0.00016, "epss_percentile": 0.02943}, "CVE-2022-2155": {"epss_score": 0.00212, "epss_percentile": 0.43789}, "CVE-2022-2156": {"epss_score": 0.01529, "epss_percentile": 0.80879}, "CVE-2022-2157": {"epss_score": 0.01005, "epss_percentile": 0.76544}, "CVE-2022-2158": {"epss_score": 0.00693, "epss_percentile": 0.71334}, "CVE-2022-2160": {"epss_score": 0.00258, "epss_percentile": 0.48954}, "CVE-2022-2161": {"epss_score": 0.00964, "epss_percentile": 0.76028}, "CVE-2022-2162": {"epss_score": 0.00382, "epss_percentile": 0.59033}, "CVE-2022-2163": {"epss_score": 0.0043, "epss_percentile": 0.6203}, "CVE-2022-2164": {"epss_score": 0.00205, "epss_percentile": 0.42679}, "CVE-2022-2165": {"epss_score": 0.00448, "epss_percentile": 0.6301}, "CVE-2022-2166": {"epss_score": 0.01645, "epss_percentile": 0.81525}, "CVE-2022-2167": {"epss_score": 0.00326, "epss_percentile": 0.55087}, "CVE-2022-2168": {"epss_score": 0.00502, "epss_percentile": 0.6541}, "CVE-2022-2169": {"epss_score": 0.00195, "epss_percentile": 0.41695}, "CVE-2022-2170": {"epss_score": 0.00583, "epss_percentile": 0.68335}, "CVE-2022-2171": {"epss_score": 0.00084, "epss_percentile": 0.24958}, "CVE-2022-2172": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-2173": {"epss_score": 0.00199, "epss_percentile": 0.42186}, "CVE-2022-2174": {"epss_score": 0.22204, "epss_percentile": 0.9561}, "CVE-2022-2175": {"epss_score": 0.00095, "epss_percentile": 0.27118}, "CVE-2022-2177": {"epss_score": 0.0034, "epss_percentile": 0.56274}, "CVE-2022-2178": {"epss_score": 0.00122, "epss_percentile": 0.32121}, "CVE-2022-2179": {"epss_score": 0.00821, "epss_percentile": 0.73907}, "CVE-2022-2180": {"epss_score": 0.07236, "epss_percentile": 0.91341}, "CVE-2022-2181": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-2182": {"epss_score": 0.00828, "epss_percentile": 0.73992}, "CVE-2022-2183": {"epss_score": 0.01058, "epss_percentile": 0.7714}, "CVE-2022-2184": {"epss_score": 0.00195, "epss_percentile": 0.41648}, "CVE-2022-2185": {"epss_score": 0.93208, "epss_percentile": 0.99783}, "CVE-2022-2186": {"epss_score": 0.00195, "epss_percentile": 0.41695}, "CVE-2022-2187": {"epss_score": 0.07773, "epss_percentile": 0.91675}, "CVE-2022-2188": {"epss_score": 0.00105, "epss_percentile": 0.29303}, "CVE-2022-2189": {"epss_score": 0.00095, "epss_percentile": 0.27166}, "CVE-2022-2190": {"epss_score": 0.00473, "epss_percentile": 0.64104}, "CVE-2022-2191": {"epss_score": 0.0056, "epss_percentile": 0.67635}, "CVE-2022-2192": {"epss_score": 0.00678, "epss_percentile": 0.70985}, "CVE-2022-2193": {"epss_score": 0.00696, "epss_percentile": 0.71395}, "CVE-2022-2194": {"epss_score": 0.00195, "epss_percentile": 0.41695}, "CVE-2022-2196": {"epss_score": 0.0003, "epss_percentile": 0.08024}, "CVE-2022-2197": {"epss_score": 0.00211, "epss_percentile": 0.43616}, "CVE-2022-2198": {"epss_score": 0.00182, "epss_percentile": 0.4014}, "CVE-2022-2199": {"epss_score": 0.00361, "epss_percentile": 0.57732}, "CVE-2022-2200": {"epss_score": 0.04872, "epss_percentile": 0.89232}, "CVE-2022-2206": {"epss_score": 0.00129, "epss_percentile": 0.33118}, "CVE-2022-2207": {"epss_score": 0.001, "epss_percentile": 0.28551}, "CVE-2022-2208": {"epss_score": 0.00074, "epss_percentile": 0.22828}, "CVE-2022-2210": {"epss_score": 0.00136, "epss_percentile": 0.34134}, "CVE-2022-2211": {"epss_score": 0.00138, "epss_percentile": 0.34507}, "CVE-2022-2212": {"epss_score": 0.00376, "epss_percentile": 0.58653}, "CVE-2022-2213": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-2214": {"epss_score": 0.00403, "epss_percentile": 0.60338}, "CVE-2022-2215": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2216": {"epss_score": 0.00318, "epss_percentile": 0.54462}, "CVE-2022-2217": {"epss_score": 0.00294, "epss_percentile": 0.52417}, "CVE-2022-2218": {"epss_score": 0.00322, "epss_percentile": 0.54788}, "CVE-2022-2219": {"epss_score": 0.16573, "epss_percentile": 0.94696}, "CVE-2022-2221": {"epss_score": 0.00156, "epss_percentile": 0.36935}, "CVE-2022-2222": {"epss_score": 0.00842, "epss_percentile": 0.74241}, "CVE-2022-2223": {"epss_score": 0.00141, "epss_percentile": 0.34943}, "CVE-2022-2224": {"epss_score": 0.00141, "epss_percentile": 0.34943}, "CVE-2022-2225": {"epss_score": 0.00045, "epss_percentile": 0.13962}, "CVE-2022-2226": {"epss_score": 0.00307, "epss_percentile": 0.5353}, "CVE-2022-2227": {"epss_score": 0.0016, "epss_percentile": 0.37434}, "CVE-2022-2228": {"epss_score": 0.00207, "epss_percentile": 0.43133}, "CVE-2022-2229": {"epss_score": 0.00292, "epss_percentile": 0.52264}, "CVE-2022-2230": {"epss_score": 0.06585, "epss_percentile": 0.90866}, "CVE-2022-2231": {"epss_score": 0.00117, "epss_percentile": 0.3122}, "CVE-2022-2232": {"epss_score": 0.00083, "epss_percentile": 0.24757}, "CVE-2022-2233": {"epss_score": 0.00319, "epss_percentile": 0.54545}, "CVE-2022-2234": {"epss_score": 0.00475, "epss_percentile": 0.64172}, "CVE-2022-2235": {"epss_score": 0.04617, "epss_percentile": 0.88925}, "CVE-2022-2237": {"epss_score": 0.00106, "epss_percentile": 0.29507}, "CVE-2022-2238": {"epss_score": 0.00722, "epss_percentile": 0.71995}, "CVE-2022-2239": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2240": {"epss_score": 0.03352, "epss_percentile": 0.86964}, "CVE-2022-2241": {"epss_score": 0.00287, "epss_percentile": 0.5185}, "CVE-2022-2242": {"epss_score": 0.00347, "epss_percentile": 0.56766}, "CVE-2022-2243": {"epss_score": 0.00183, "epss_percentile": 0.40361}, "CVE-2022-2244": {"epss_score": 0.00235, "epss_percentile": 0.46221}, "CVE-2022-2245": {"epss_score": 0.00104, "epss_percentile": 0.29139}, "CVE-2022-2249": {"epss_score": 0.00058, "epss_percentile": 0.18414}, "CVE-2022-2250": {"epss_score": 0.00289, "epss_percentile": 0.52035}, "CVE-2022-2251": {"epss_score": 0.15514, "epss_percentile": 0.94443}, "CVE-2022-2252": {"epss_score": 0.00215, "epss_percentile": 0.44035}, "CVE-2022-2253": {"epss_score": 0.00471, "epss_percentile": 0.6401}, "CVE-2022-2254": {"epss_score": 0.0019, "epss_percentile": 0.41067}, "CVE-2022-2255": {"epss_score": 0.00378, "epss_percentile": 0.58776}, "CVE-2022-2256": {"epss_score": 0.00882, "epss_percentile": 0.74882}, "CVE-2022-2257": {"epss_score": 0.00098, "epss_percentile": 0.2783}, "CVE-2022-2258": {"epss_score": 0.00195, "epss_percentile": 0.41684}, "CVE-2022-2259": {"epss_score": 0.00128, "epss_percentile": 0.33054}, "CVE-2022-2260": {"epss_score": 0.00148, "epss_percentile": 0.35854}, "CVE-2022-2261": {"epss_score": 0.01093, "epss_percentile": 0.77483}, "CVE-2022-2262": {"epss_score": 0.00261, "epss_percentile": 0.49274}, "CVE-2022-2263": {"epss_score": 0.00261, "epss_percentile": 0.49274}, "CVE-2022-2264": {"epss_score": 0.00125, "epss_percentile": 0.32615}, "CVE-2022-2265": {"epss_score": 0.00725, "epss_percentile": 0.7205}, "CVE-2022-2266": {"epss_score": 0.00335, "epss_percentile": 0.55799}, "CVE-2022-2267": {"epss_score": 0.00198, "epss_percentile": 0.42092}, "CVE-2022-2268": {"epss_score": 0.00956, "epss_percentile": 0.75921}, "CVE-2022-2269": {"epss_score": 0.00517, "epss_percentile": 0.66088}, "CVE-2022-2270": {"epss_score": 0.00156, "epss_percentile": 0.3691}, "CVE-2022-2271": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2272": {"epss_score": 0.24657, "epss_percentile": 0.95944}, "CVE-2022-2273": {"epss_score": 0.00643, "epss_percentile": 0.70048}, "CVE-2022-2274": {"epss_score": 0.55911, "epss_percentile": 0.98002}, "CVE-2022-2275": {"epss_score": 0.00106, "epss_percentile": 0.29533}, "CVE-2022-2276": {"epss_score": 0.00128, "epss_percentile": 0.33008}, "CVE-2022-2277": {"epss_score": 0.00111, "epss_percentile": 0.30346}, "CVE-2022-2278": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-2279": {"epss_score": 0.00153, "epss_percentile": 0.36574}, "CVE-2022-2280": {"epss_score": 0.00322, "epss_percentile": 0.54791}, "CVE-2022-2281": {"epss_score": 0.0028, "epss_percentile": 0.51082}, "CVE-2022-2284": {"epss_score": 0.00185, "epss_percentile": 0.40579}, "CVE-2022-2285": {"epss_score": 0.00194, "epss_percentile": 0.41563}, "CVE-2022-2286": {"epss_score": 0.00185, "epss_percentile": 0.405}, "CVE-2022-2287": {"epss_score": 0.00059, "epss_percentile": 0.18862}, "CVE-2022-2288": {"epss_score": 0.00421, "epss_percentile": 0.61491}, "CVE-2022-2289": {"epss_score": 0.00103, "epss_percentile": 0.29004}, "CVE-2022-2290": {"epss_score": 0.074, "epss_percentile": 0.91452}, "CVE-2022-2291": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-2292": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-2293": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-2294": {"epss_score": 0.01256, "epss_percentile": 0.78941}, "CVE-2022-2295": {"epss_score": 0.01658, "epss_percentile": 0.81608}, "CVE-2022-2296": {"epss_score": 0.01439, "epss_percentile": 0.80291}, "CVE-2022-2297": {"epss_score": 0.69966, "epss_percentile": 0.98611}, "CVE-2022-2298": {"epss_score": 0.00251, "epss_percentile": 0.48331}, "CVE-2022-2299": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-2300": {"epss_score": 0.00181, "epss_percentile": 0.40084}, "CVE-2022-2301": {"epss_score": 0.00134, "epss_percentile": 0.339}, "CVE-2022-2302": {"epss_score": 0.0069, "epss_percentile": 0.71242}, "CVE-2022-2303": {"epss_score": 0.00169, "epss_percentile": 0.38626}, "CVE-2022-2304": {"epss_score": 0.001, "epss_percentile": 0.28475}, "CVE-2022-2305": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2306": {"epss_score": 0.00226, "epss_percentile": 0.45258}, "CVE-2022-2307": {"epss_score": 0.00115, "epss_percentile": 0.30964}, "CVE-2022-2308": {"epss_score": 0.00095, "epss_percentile": 0.27122}, "CVE-2022-2309": {"epss_score": 0.00868, "epss_percentile": 0.74664}, "CVE-2022-2310": {"epss_score": 0.01417, "epss_percentile": 0.80148}, "CVE-2022-2311": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-2312": {"epss_score": 0.00079, "epss_percentile": 0.23817}, "CVE-2022-2313": {"epss_score": 0.00032, "epss_percentile": 0.08766}, "CVE-2022-2314": {"epss_score": 0.88733, "epss_percentile": 0.99487}, "CVE-2022-2315": {"epss_score": 0.0034, "epss_percentile": 0.56274}, "CVE-2022-2316": {"epss_score": 0.00502, "epss_percentile": 0.65419}, "CVE-2022-2317": {"epss_score": 0.00854, "epss_percentile": 0.74453}, "CVE-2022-2318": {"epss_score": 0.00075, "epss_percentile": 0.22941}, "CVE-2022-2319": {"epss_score": 0.00033, "epss_percentile": 0.09171}, "CVE-2022-2320": {"epss_score": 0.0005, "epss_percentile": 0.15898}, "CVE-2022-2321": {"epss_score": 0.0032, "epss_percentile": 0.54609}, "CVE-2022-2323": {"epss_score": 0.01311, "epss_percentile": 0.79372}, "CVE-2022-2324": {"epss_score": 0.00109, "epss_percentile": 0.30042}, "CVE-2022-2325": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2326": {"epss_score": 0.00245, "epss_percentile": 0.47687}, "CVE-2022-2327": {"epss_score": 0.0003, "epss_percentile": 0.08163}, "CVE-2022-2328": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2329": {"epss_score": 0.05804, "epss_percentile": 0.90222}, "CVE-2022-2330": {"epss_score": 0.00343, "epss_percentile": 0.56454}, "CVE-2022-2332": {"epss_score": 0.00052, "epss_percentile": 0.1655}, "CVE-2022-2333": {"epss_score": 0.00212, "epss_percentile": 0.43723}, "CVE-2022-2334": {"epss_score": 0.5964, "epss_percentile": 0.98173}, "CVE-2022-2335": {"epss_score": 0.00987, "epss_percentile": 0.76339}, "CVE-2022-2336": {"epss_score": 0.00239, "epss_percentile": 0.46863}, "CVE-2022-2337": {"epss_score": 0.01088, "epss_percentile": 0.77438}, "CVE-2022-2338": {"epss_score": 0.00034, "epss_percentile": 0.09529}, "CVE-2022-2339": {"epss_score": 0.00757, "epss_percentile": 0.72762}, "CVE-2022-2340": {"epss_score": 0.00298, "epss_percentile": 0.52815}, "CVE-2022-2341": {"epss_score": 0.00191, "epss_percentile": 0.41195}, "CVE-2022-2342": {"epss_score": 0.00282, "epss_percentile": 0.51292}, "CVE-2022-2343": {"epss_score": 0.00108, "epss_percentile": 0.29792}, "CVE-2022-2344": {"epss_score": 0.00043, "epss_percentile": 0.13172}, "CVE-2022-2345": {"epss_score": 0.00043, "epss_percentile": 0.13345}, "CVE-2022-2346": {"epss_score": 0.00076, "epss_percentile": 0.23166}, "CVE-2022-2347": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2022-2350": {"epss_score": 0.00128, "epss_percentile": 0.3296}, "CVE-2022-2351": {"epss_score": 0.00339, "epss_percentile": 0.56172}, "CVE-2022-2352": {"epss_score": 0.0095, "epss_percentile": 0.75856}, "CVE-2022-2353": {"epss_score": 0.00121, "epss_percentile": 0.3192}, "CVE-2022-2354": {"epss_score": 0.0077, "epss_percentile": 0.72999}, "CVE-2022-2355": {"epss_score": 0.0012, "epss_percentile": 0.31693}, "CVE-2022-2356": {"epss_score": 0.00849, "epss_percentile": 0.74369}, "CVE-2022-2357": {"epss_score": 0.00495, "epss_percentile": 0.65134}, "CVE-2022-2361": {"epss_score": 0.00298, "epss_percentile": 0.52815}, "CVE-2022-2362": {"epss_score": 0.00513, "epss_percentile": 0.65897}, "CVE-2022-2363": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-2364": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-2365": {"epss_score": 0.00214, "epss_percentile": 0.44009}, "CVE-2022-2366": {"epss_score": 0.00186, "epss_percentile": 0.40659}, "CVE-2022-2367": {"epss_score": 0.00536, "epss_percentile": 0.66848}, "CVE-2022-2368": {"epss_score": 0.00136, "epss_percentile": 0.34094}, "CVE-2022-2369": {"epss_score": 0.00182, "epss_percentile": 0.4014}, "CVE-2022-2370": {"epss_score": 0.00567, "epss_percentile": 0.67863}, "CVE-2022-2371": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-2372": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2373": {"epss_score": 0.08392, "epss_percentile": 0.92025}, "CVE-2022-2374": {"epss_score": 0.00339, "epss_percentile": 0.56172}, "CVE-2022-2375": {"epss_score": 0.00149, "epss_percentile": 0.35941}, "CVE-2022-2376": {"epss_score": 0.10489, "epss_percentile": 0.93005}, "CVE-2022-2377": {"epss_score": 0.00156, "epss_percentile": 0.36983}, "CVE-2022-2378": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-2379": {"epss_score": 0.36543, "epss_percentile": 0.96986}, "CVE-2022-2380": {"epss_score": 0.00023, "epss_percentile": 0.05335}, "CVE-2022-2381": {"epss_score": 0.00141, "epss_percentile": 0.34865}, "CVE-2022-2382": {"epss_score": 0.00102, "epss_percentile": 0.28758}, "CVE-2022-2383": {"epss_score": 0.06392, "epss_percentile": 0.90719}, "CVE-2022-2384": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2385": {"epss_score": 0.00313, "epss_percentile": 0.54062}, "CVE-2022-2386": {"epss_score": 0.00287, "epss_percentile": 0.5185}, "CVE-2022-2387": {"epss_score": 0.00197, "epss_percentile": 0.41867}, "CVE-2022-2388": {"epss_score": 0.00144, "epss_percentile": 0.35348}, "CVE-2022-2389": {"epss_score": 0.00156, "epss_percentile": 0.36983}, "CVE-2022-2390": {"epss_score": 0.00039, "epss_percentile": 0.11773}, "CVE-2022-2391": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-2392": {"epss_score": 0.00437, "epss_percentile": 0.62537}, "CVE-2022-2393": {"epss_score": 0.00064, "epss_percentile": 0.20109}, "CVE-2022-2394": {"epss_score": 0.00253, "epss_percentile": 0.48481}, "CVE-2022-2395": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2396": {"epss_score": 0.00224, "epss_percentile": 0.45073}, "CVE-2022-2398": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2399": {"epss_score": 0.00573, "epss_percentile": 0.68062}, "CVE-2022-2400": {"epss_score": 0.004, "epss_percentile": 0.60151}, "CVE-2022-2401": {"epss_score": 0.00326, "epss_percentile": 0.55064}, "CVE-2022-2402": {"epss_score": 0.00057, "epss_percentile": 0.18061}, "CVE-2022-2403": {"epss_score": 0.0066, "epss_percentile": 0.7052}, "CVE-2022-2404": {"epss_score": 0.00218, "epss_percentile": 0.44375}, "CVE-2022-2405": {"epss_score": 0.0008, "epss_percentile": 0.24091}, "CVE-2022-2406": {"epss_score": 0.00427, "epss_percentile": 0.6189}, "CVE-2022-2407": {"epss_score": 0.00294, "epss_percentile": 0.52424}, "CVE-2022-2408": {"epss_score": 0.00112, "epss_percentile": 0.30556}, "CVE-2022-2409": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2410": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2411": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-2412": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-2413": {"epss_score": 0.00104, "epss_percentile": 0.29236}, "CVE-2022-2414": {"epss_score": 0.91576, "epss_percentile": 0.99653}, "CVE-2022-2415": {"epss_score": 0.0083, "epss_percentile": 0.74038}, "CVE-2022-2416": {"epss_score": 0.00082, "epss_percentile": 0.24558}, "CVE-2022-2417": {"epss_score": 0.00201, "epss_percentile": 0.42387}, "CVE-2022-2418": {"epss_score": 0.0028, "epss_percentile": 0.51032}, "CVE-2022-2419": {"epss_score": 0.01302, "epss_percentile": 0.793}, "CVE-2022-2420": {"epss_score": 0.00225, "epss_percentile": 0.45104}, "CVE-2022-2421": {"epss_score": 0.01132, "epss_percentile": 0.77869}, "CVE-2022-2422": {"epss_score": 0.00339, "epss_percentile": 0.56164}, "CVE-2022-2423": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2424": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2425": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2426": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2428": {"epss_score": 0.00383, "epss_percentile": 0.59096}, "CVE-2022-2429": {"epss_score": 0.00861, "epss_percentile": 0.74553}, "CVE-2022-2430": {"epss_score": 0.00171, "epss_percentile": 0.38773}, "CVE-2022-2431": {"epss_score": 0.17137, "epss_percentile": 0.94781}, "CVE-2022-2432": {"epss_score": 0.00238, "epss_percentile": 0.46742}, "CVE-2022-2433": {"epss_score": 0.03588, "epss_percentile": 0.87395}, "CVE-2022-2434": {"epss_score": 0.04225, "epss_percentile": 0.88414}, "CVE-2022-2435": {"epss_score": 0.00442, "epss_percentile": 0.62712}, "CVE-2022-2436": {"epss_score": 0.0113, "epss_percentile": 0.77847}, "CVE-2022-2437": {"epss_score": 0.09131, "epss_percentile": 0.92415}, "CVE-2022-2438": {"epss_score": 0.01401, "epss_percentile": 0.8001}, "CVE-2022-2439": {"epss_score": 0.00769, "epss_percentile": 0.72991}, "CVE-2022-2440": {"epss_score": 0.0055, "epss_percentile": 0.67348}, "CVE-2022-2441": {"epss_score": 0.01898, "epss_percentile": 0.82764}, "CVE-2022-2442": {"epss_score": 0.02884, "epss_percentile": 0.85907}, "CVE-2022-2443": {"epss_score": 0.00218, "epss_percentile": 0.4437}, "CVE-2022-2444": {"epss_score": 0.02868, "epss_percentile": 0.85868}, "CVE-2022-2446": {"epss_score": 0.00914, "epss_percentile": 0.75383}, "CVE-2022-2447": {"epss_score": 0.00629, "epss_percentile": 0.6968}, "CVE-2022-2448": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2449": {"epss_score": 0.00144, "epss_percentile": 0.35348}, "CVE-2022-2450": {"epss_score": 0.00153, "epss_percentile": 0.36607}, "CVE-2022-2453": {"epss_score": 0.00051, "epss_percentile": 0.16281}, "CVE-2022-2454": {"epss_score": 0.00045, "epss_percentile": 0.14011}, "CVE-2022-2455": {"epss_score": 0.00269, "epss_percentile": 0.50181}, "CVE-2022-2456": {"epss_score": 0.0028, "epss_percentile": 0.511}, "CVE-2022-2457": {"epss_score": 0.00213, "epss_percentile": 0.4391}, "CVE-2022-2458": {"epss_score": 0.00486, "epss_percentile": 0.64756}, "CVE-2022-2459": {"epss_score": 0.00181, "epss_percentile": 0.40015}, "CVE-2022-2460": {"epss_score": 0.04375, "epss_percentile": 0.88616}, "CVE-2022-2461": {"epss_score": 0.13263, "epss_percentile": 0.93917}, "CVE-2022-2462": {"epss_score": 0.04027, "epss_percentile": 0.88143}, "CVE-2022-2463": {"epss_score": 0.00066, "epss_percentile": 0.20703}, "CVE-2022-2464": {"epss_score": 0.00023, "epss_percentile": 0.0561}, "CVE-2022-2465": {"epss_score": 0.00136, "epss_percentile": 0.34105}, "CVE-2022-2466": {"epss_score": 0.12221, "epss_percentile": 0.93606}, "CVE-2022-2467": {"epss_score": 0.71134, "epss_percentile": 0.98655}, "CVE-2022-2468": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2469": {"epss_score": 0.0007, "epss_percentile": 0.21663}, "CVE-2022-2470": {"epss_score": 0.00472, "epss_percentile": 0.64069}, "CVE-2022-2471": {"epss_score": 0.00631, "epss_percentile": 0.69721}, "CVE-2022-2472": {"epss_score": 0.00195, "epss_percentile": 0.41606}, "CVE-2022-2473": {"epss_score": 0.01037, "epss_percentile": 0.76924}, "CVE-2022-2474": {"epss_score": 0.00165, "epss_percentile": 0.38037}, "CVE-2022-2475": {"epss_score": 0.00163, "epss_percentile": 0.37863}, "CVE-2022-2476": {"epss_score": 0.00158, "epss_percentile": 0.37282}, "CVE-2022-2477": {"epss_score": 0.00294, "epss_percentile": 0.52404}, "CVE-2022-2478": {"epss_score": 0.00314, "epss_percentile": 0.54152}, "CVE-2022-2479": {"epss_score": 0.00154, "epss_percentile": 0.36744}, "CVE-2022-2480": {"epss_score": 0.04515, "epss_percentile": 0.88791}, "CVE-2022-2481": {"epss_score": 0.0058, "epss_percentile": 0.68237}, "CVE-2022-2482": {"epss_score": 0.00066, "epss_percentile": 0.2094}, "CVE-2022-2483": {"epss_score": 0.00056, "epss_percentile": 0.17666}, "CVE-2022-2484": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2022-2485": {"epss_score": 0.00107, "epss_percentile": 0.29647}, "CVE-2022-2486": {"epss_score": 0.94072, "epss_percentile": 0.99897}, "CVE-2022-2487": {"epss_score": 0.93445, "epss_percentile": 0.99807}, "CVE-2022-2488": {"epss_score": 0.93197, "epss_percentile": 0.99782}, "CVE-2022-2489": {"epss_score": 0.00294, "epss_percentile": 0.52367}, "CVE-2022-2490": {"epss_score": 0.00294, "epss_percentile": 0.52367}, "CVE-2022-2491": {"epss_score": 0.00294, "epss_percentile": 0.52367}, "CVE-2022-2492": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2493": {"epss_score": 0.00451, "epss_percentile": 0.63132}, "CVE-2022-2494": {"epss_score": 0.17865, "epss_percentile": 0.94919}, "CVE-2022-2495": {"epss_score": 0.00315, "epss_percentile": 0.54204}, "CVE-2022-2497": {"epss_score": 0.04617, "epss_percentile": 0.88924}, "CVE-2022-2498": {"epss_score": 0.002, "epss_percentile": 0.42242}, "CVE-2022-2499": {"epss_score": 0.00169, "epss_percentile": 0.3861}, "CVE-2022-2500": {"epss_score": 0.02855, "epss_percentile": 0.8584}, "CVE-2022-2501": {"epss_score": 0.0015, "epss_percentile": 0.3614}, "CVE-2022-2502": {"epss_score": 0.00058, "epss_percentile": 0.18449}, "CVE-2022-2503": {"epss_score": 5e-05, "epss_percentile": 0.00221}, "CVE-2022-2504": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-2505": {"epss_score": 0.00212, "epss_percentile": 0.43796}, "CVE-2022-2507": {"epss_score": 0.00246, "epss_percentile": 0.47735}, "CVE-2022-2508": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2022-2509": {"epss_score": 0.00908, "epss_percentile": 0.75278}, "CVE-2022-2510": {"epss_score": 0.00258, "epss_percentile": 0.49025}, "CVE-2022-2511": {"epss_score": 0.00542, "epss_percentile": 0.67078}, "CVE-2022-2512": {"epss_score": 0.00167, "epss_percentile": 0.38341}, "CVE-2022-2513": {"epss_score": 0.00055, "epss_percentile": 0.17599}, "CVE-2022-2514": {"epss_score": 0.00304, "epss_percentile": 0.53251}, "CVE-2022-2515": {"epss_score": 0.00369, "epss_percentile": 0.58251}, "CVE-2022-2516": {"epss_score": 0.00171, "epss_percentile": 0.38773}, "CVE-2022-2517": {"epss_score": 0.00171, "epss_percentile": 0.38773}, "CVE-2022-2518": {"epss_score": 0.0021, "epss_percentile": 0.4344}, "CVE-2022-2519": {"epss_score": 0.00111, "epss_percentile": 0.3027}, "CVE-2022-2520": {"epss_score": 0.00051, "epss_percentile": 0.16256}, "CVE-2022-2521": {"epss_score": 0.00111, "epss_percentile": 0.3027}, "CVE-2022-2522": {"epss_score": 0.00042, "epss_percentile": 0.12897}, "CVE-2022-2523": {"epss_score": 0.00304, "epss_percentile": 0.53251}, "CVE-2022-2525": {"epss_score": 0.00074, "epss_percentile": 0.22773}, "CVE-2022-2526": {"epss_score": 0.00247, "epss_percentile": 0.47842}, "CVE-2022-2527": {"epss_score": 0.00498, "epss_percentile": 0.65227}, "CVE-2022-2528": {"epss_score": 0.00125, "epss_percentile": 0.32527}, "CVE-2022-2529": {"epss_score": 0.00693, "epss_percentile": 0.71326}, "CVE-2022-2531": {"epss_score": 0.00663, "epss_percentile": 0.70622}, "CVE-2022-2532": {"epss_score": 0.00645, "epss_percentile": 0.70115}, "CVE-2022-2533": {"epss_score": 0.0016, "epss_percentile": 0.37468}, "CVE-2022-2534": {"epss_score": 0.00291, "epss_percentile": 0.52184}, "CVE-2022-2535": {"epss_score": 0.09769, "epss_percentile": 0.92695}, "CVE-2022-2536": {"epss_score": 0.01048, "epss_percentile": 0.77052}, "CVE-2022-2537": {"epss_score": 0.00287, "epss_percentile": 0.5185}, "CVE-2022-2538": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-2539": {"epss_score": 0.00257, "epss_percentile": 0.48843}, "CVE-2022-2540": {"epss_score": 0.00183, "epss_percentile": 0.40278}, "CVE-2022-2541": {"epss_score": 0.00293, "epss_percentile": 0.52292}, "CVE-2022-2542": {"epss_score": 0.00291, "epss_percentile": 0.52177}, "CVE-2022-2543": {"epss_score": 0.00519, "epss_percentile": 0.66169}, "CVE-2022-2544": {"epss_score": 0.50013, "epss_percentile": 0.97714}, "CVE-2022-2546": {"epss_score": 0.54546, "epss_percentile": 0.97932}, "CVE-2022-2547": {"epss_score": 0.00734, "epss_percentile": 0.72219}, "CVE-2022-2549": {"epss_score": 0.00127, "epss_percentile": 0.32933}, "CVE-2022-2550": {"epss_score": 0.10445, "epss_percentile": 0.92989}, "CVE-2022-2551": {"epss_score": 0.64813, "epss_percentile": 0.98393}, "CVE-2022-2552": {"epss_score": 0.48477, "epss_percentile": 0.9764}, "CVE-2022-2553": {"epss_score": 0.0018, "epss_percentile": 0.3989}, "CVE-2022-2554": {"epss_score": 0.00425, "epss_percentile": 0.61712}, "CVE-2022-2555": {"epss_score": 0.00184, "epss_percentile": 0.40419}, "CVE-2022-2556": {"epss_score": 0.00218, "epss_percentile": 0.44366}, "CVE-2022-2557": {"epss_score": 0.01249, "epss_percentile": 0.78873}, "CVE-2022-2558": {"epss_score": 0.00417, "epss_percentile": 0.61227}, "CVE-2022-2559": {"epss_score": 0.00537, "epss_percentile": 0.66899}, "CVE-2022-2560": {"epss_score": 0.56623, "epss_percentile": 0.9803}, "CVE-2022-2561": {"epss_score": 0.02198, "epss_percentile": 0.83967}, "CVE-2022-2563": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-2564": {"epss_score": 0.01302, "epss_percentile": 0.79301}, "CVE-2022-2565": {"epss_score": 0.01173, "epss_percentile": 0.78236}, "CVE-2022-2566": {"epss_score": 0.01465, "epss_percentile": 0.80459}, "CVE-2022-2567": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-2568": {"epss_score": 0.0021, "epss_percentile": 0.43497}, "CVE-2022-2569": {"epss_score": 0.00035, "epss_percentile": 0.10155}, "CVE-2022-2571": {"epss_score": 0.00039, "epss_percentile": 0.117}, "CVE-2022-2572": {"epss_score": 0.00392, "epss_percentile": 0.59657}, "CVE-2022-2574": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-2575": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-2576": {"epss_score": 0.00204, "epss_percentile": 0.426}, "CVE-2022-2577": {"epss_score": 0.00294, "epss_percentile": 0.52367}, "CVE-2022-2578": {"epss_score": 0.00309, "epss_percentile": 0.5367}, "CVE-2022-2579": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-2580": {"epss_score": 0.00043, "epss_percentile": 0.13022}, "CVE-2022-2581": {"epss_score": 0.00037, "epss_percentile": 0.10912}, "CVE-2022-2582": {"epss_score": 0.00087, "epss_percentile": 0.25452}, "CVE-2022-2583": {"epss_score": 0.00179, "epss_percentile": 0.39796}, "CVE-2022-2584": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2022-2585": {"epss_score": 0.00412, "epss_percentile": 0.60928}, "CVE-2022-2586": {"epss_score": 0.02871, "epss_percentile": 0.85874}, "CVE-2022-2587": {"epss_score": 0.00655, "epss_percentile": 0.70371}, "CVE-2022-2588": {"epss_score": 0.55292, "epss_percentile": 0.9797}, "CVE-2022-2589": {"epss_score": 0.00234, "epss_percentile": 0.46166}, "CVE-2022-2590": {"epss_score": 0.00445, "epss_percentile": 0.62857}, "CVE-2022-2591": {"epss_score": 0.03814, "epss_percentile": 0.87765}, "CVE-2022-2592": {"epss_score": 0.00492, "epss_percentile": 0.65011}, "CVE-2022-2593": {"epss_score": 0.00537, "epss_percentile": 0.66899}, "CVE-2022-2594": {"epss_score": 0.01795, "epss_percentile": 0.82304}, "CVE-2022-2595": {"epss_score": 0.00358, "epss_percentile": 0.57484}, "CVE-2022-2596": {"epss_score": 0.00214, "epss_percentile": 0.43955}, "CVE-2022-2597": {"epss_score": 0.00141, "epss_percentile": 0.34906}, "CVE-2022-2598": {"epss_score": 0.00096, "epss_percentile": 0.27271}, "CVE-2022-2599": {"epss_score": 0.47329, "epss_percentile": 0.97582}, "CVE-2022-2600": {"epss_score": 0.00188, "epss_percentile": 0.4087}, "CVE-2022-2601": {"epss_score": 0.00063, "epss_percentile": 0.19872}, "CVE-2022-2602": {"epss_score": 0.00953, "epss_percentile": 0.75887}, "CVE-2022-2603": {"epss_score": 0.0093, "epss_percentile": 0.75604}, "CVE-2022-2604": {"epss_score": 0.0093, "epss_percentile": 0.75604}, "CVE-2022-2605": {"epss_score": 0.00442, "epss_percentile": 0.62724}, "CVE-2022-2606": {"epss_score": 0.00992, "epss_percentile": 0.76395}, "CVE-2022-2607": {"epss_score": 0.01042, "epss_percentile": 0.76986}, "CVE-2022-2608": {"epss_score": 0.01042, "epss_percentile": 0.76986}, "CVE-2022-2609": {"epss_score": 0.01042, "epss_percentile": 0.76986}, "CVE-2022-2610": {"epss_score": 0.00385, "epss_percentile": 0.5921}, "CVE-2022-2611": {"epss_score": 0.00362, "epss_percentile": 0.578}, "CVE-2022-2612": {"epss_score": 0.00383, "epss_percentile": 0.5909}, "CVE-2022-2613": {"epss_score": 0.01099, "epss_percentile": 0.77557}, "CVE-2022-2614": {"epss_score": 0.00807, "epss_percentile": 0.73668}, "CVE-2022-2615": {"epss_score": 0.00442, "epss_percentile": 0.62724}, "CVE-2022-2616": {"epss_score": 0.00271, "epss_percentile": 0.50326}, "CVE-2022-2617": {"epss_score": 0.00234, "epss_percentile": 0.46168}, "CVE-2022-2618": {"epss_score": 0.00268, "epss_percentile": 0.50097}, "CVE-2022-2619": {"epss_score": 0.00271, "epss_percentile": 0.50326}, "CVE-2022-2620": {"epss_score": 0.01286, "epss_percentile": 0.7919}, "CVE-2022-2621": {"epss_score": 0.00155, "epss_percentile": 0.3682}, "CVE-2022-2622": {"epss_score": 0.00399, "epss_percentile": 0.60119}, "CVE-2022-2623": {"epss_score": 0.00812, "epss_percentile": 0.73748}, "CVE-2022-2624": {"epss_score": 0.01234, "epss_percentile": 0.78759}, "CVE-2022-2625": {"epss_score": 0.00861, "epss_percentile": 0.74555}, "CVE-2022-2626": {"epss_score": 0.00352, "epss_percentile": 0.57108}, "CVE-2022-2627": {"epss_score": 0.23643, "epss_percentile": 0.95798}, "CVE-2022-2628": {"epss_score": 0.0046, "epss_percentile": 0.63518}, "CVE-2022-2629": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2630": {"epss_score": 0.00254, "epss_percentile": 0.48565}, "CVE-2022-2631": {"epss_score": 0.00309, "epss_percentile": 0.53722}, "CVE-2022-2633": {"epss_score": 0.89676, "epss_percentile": 0.99537}, "CVE-2022-2634": {"epss_score": 0.00244, "epss_percentile": 0.47572}, "CVE-2022-2635": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2636": {"epss_score": 0.00419, "epss_percentile": 0.61384}, "CVE-2022-2637": {"epss_score": 0.00645, "epss_percentile": 0.7012}, "CVE-2022-2638": {"epss_score": 0.0038, "epss_percentile": 0.58941}, "CVE-2022-2639": {"epss_score": 0.01159, "epss_percentile": 0.7813}, "CVE-2022-2640": {"epss_score": 0.00059, "epss_percentile": 0.18807}, "CVE-2022-2641": {"epss_score": 0.00298, "epss_percentile": 0.52826}, "CVE-2022-2642": {"epss_score": 0.00202, "epss_percentile": 0.42417}, "CVE-2022-2643": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2022-2644": {"epss_score": 0.0025, "epss_percentile": 0.48124}, "CVE-2022-2645": {"epss_score": 0.00187, "epss_percentile": 0.40765}, "CVE-2022-2646": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-2647": {"epss_score": 0.0034, "epss_percentile": 0.56264}, "CVE-2022-2648": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2022-2650": {"epss_score": 0.00198, "epss_percentile": 0.41992}, "CVE-2022-2651": {"epss_score": 0.16939, "epss_percentile": 0.9475}, "CVE-2022-2652": {"epss_score": 0.00053, "epss_percentile": 0.16963}, "CVE-2022-2653": {"epss_score": 0.0035, "epss_percentile": 0.56918}, "CVE-2022-2654": {"epss_score": 0.00218, "epss_percentile": 0.44375}, "CVE-2022-2655": {"epss_score": 0.00277, "epss_percentile": 0.5084}, "CVE-2022-2656": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2657": {"epss_score": 0.00112, "epss_percentile": 0.30526}, "CVE-2022-2658": {"epss_score": 0.00113, "epss_percentile": 0.30642}, "CVE-2022-2660": {"epss_score": 0.00227, "epss_percentile": 0.45434}, "CVE-2022-2661": {"epss_score": 0.00218, "epss_percentile": 0.44402}, "CVE-2022-2662": {"epss_score": 0.00276, "epss_percentile": 0.50714}, "CVE-2022-2663": {"epss_score": 0.00155, "epss_percentile": 0.36811}, "CVE-2022-2664": {"epss_score": 0.00315, "epss_percentile": 0.54196}, "CVE-2022-2665": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2666": {"epss_score": 0.0007, "epss_percentile": 0.21767}, "CVE-2022-2667": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2668": {"epss_score": 0.00473, "epss_percentile": 0.64091}, "CVE-2022-2669": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-2671": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2672": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2673": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2674": {"epss_score": 0.00238, "epss_percentile": 0.46837}, "CVE-2022-2675": {"epss_score": 0.00228, "epss_percentile": 0.45474}, "CVE-2022-2676": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2677": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2678": {"epss_score": 0.00381, "epss_percentile": 0.59028}, "CVE-2022-2679": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2680": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2681": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-2682": {"epss_score": 0.00201, "epss_percentile": 0.42387}, "CVE-2022-2683": {"epss_score": 0.00201, "epss_percentile": 0.42387}, "CVE-2022-2684": {"epss_score": 0.00201, "epss_percentile": 0.42387}, "CVE-2022-2685": {"epss_score": 0.00299, "epss_percentile": 0.52853}, "CVE-2022-2686": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-2687": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2688": {"epss_score": 0.00179, "epss_percentile": 0.39791}, "CVE-2022-2689": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-2690": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-2691": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-2692": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-2693": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2694": {"epss_score": 0.00381, "epss_percentile": 0.59028}, "CVE-2022-2695": {"epss_score": 0.00913, "epss_percentile": 0.75382}, "CVE-2022-2696": {"epss_score": 0.00195, "epss_percentile": 0.4168}, "CVE-2022-2697": {"epss_score": 0.00217, "epss_percentile": 0.44291}, "CVE-2022-2698": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2699": {"epss_score": 0.00217, "epss_percentile": 0.44291}, "CVE-2022-2700": {"epss_score": 0.00186, "epss_percentile": 0.40688}, "CVE-2022-2701": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-2702": {"epss_score": 0.00166, "epss_percentile": 0.38163}, "CVE-2022-2703": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2704": {"epss_score": 0.00259, "epss_percentile": 0.49089}, "CVE-2022-2705": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2706": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2707": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2708": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2709": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2710": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2711": {"epss_score": 0.00887, "epss_percentile": 0.74993}, "CVE-2022-2712": {"epss_score": 0.00233, "epss_percentile": 0.46028}, "CVE-2022-2713": {"epss_score": 0.01039, "epss_percentile": 0.76946}, "CVE-2022-2714": {"epss_score": 0.004, "epss_percentile": 0.60178}, "CVE-2022-2715": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2022-2716": {"epss_score": 0.00913, "epss_percentile": 0.75382}, "CVE-2022-2717": {"epss_score": 0.01229, "epss_percentile": 0.78714}, "CVE-2022-2718": {"epss_score": 0.01029, "epss_percentile": 0.76836}, "CVE-2022-2719": {"epss_score": 0.00023, "epss_percentile": 0.05485}, "CVE-2022-2720": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2022-2721": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2022-2722": {"epss_score": 0.00294, "epss_percentile": 0.52367}, "CVE-2022-2723": {"epss_score": 0.00383, "epss_percentile": 0.5908}, "CVE-2022-2724": {"epss_score": 0.00383, "epss_percentile": 0.5908}, "CVE-2022-2725": {"epss_score": 0.003, "epss_percentile": 0.52952}, "CVE-2022-2726": {"epss_score": 0.00145, "epss_percentile": 0.35496}, "CVE-2022-2727": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2728": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2729": {"epss_score": 0.03478, "epss_percentile": 0.87215}, "CVE-2022-2730": {"epss_score": 0.00177, "epss_percentile": 0.39591}, "CVE-2022-2731": {"epss_score": 0.01508, "epss_percentile": 0.80762}, "CVE-2022-2732": {"epss_score": 0.00329, "epss_percentile": 0.55412}, "CVE-2022-2733": {"epss_score": 0.89261, "epss_percentile": 0.99517}, "CVE-2022-2734": {"epss_score": 0.01034, "epss_percentile": 0.76888}, "CVE-2022-2735": {"epss_score": 0.00044, "epss_percentile": 0.13576}, "CVE-2022-2736": {"epss_score": 0.00245, "epss_percentile": 0.47682}, "CVE-2022-2737": {"epss_score": 0.00339, "epss_percentile": 0.56172}, "CVE-2022-2738": {"epss_score": 0.00432, "epss_percentile": 0.62121}, "CVE-2022-2739": {"epss_score": 0.00132, "epss_percentile": 0.33608}, "CVE-2022-2740": {"epss_score": 0.00245, "epss_percentile": 0.47682}, "CVE-2022-2741": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-2742": {"epss_score": 0.00303, "epss_percentile": 0.53184}, "CVE-2022-2743": {"epss_score": 0.00391, "epss_percentile": 0.59585}, "CVE-2022-2744": {"epss_score": 0.00381, "epss_percentile": 0.59028}, "CVE-2022-2745": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2746": {"epss_score": 0.00331, "epss_percentile": 0.55533}, "CVE-2022-2747": {"epss_score": 0.00201, "epss_percentile": 0.42383}, "CVE-2022-2748": {"epss_score": 0.00187, "epss_percentile": 0.40765}, "CVE-2022-2749": {"epss_score": 0.00307, "epss_percentile": 0.53467}, "CVE-2022-2750": {"epss_score": 0.00331, "epss_percentile": 0.55533}, "CVE-2022-2751": {"epss_score": 0.00331, "epss_percentile": 0.55533}, "CVE-2022-2752": {"epss_score": 0.00041, "epss_percentile": 0.12246}, "CVE-2022-2753": {"epss_score": 0.15526, "epss_percentile": 0.94451}, "CVE-2022-2754": {"epss_score": 0.21288, "epss_percentile": 0.95495}, "CVE-2022-2756": {"epss_score": 0.67466, "epss_percentile": 0.98509}, "CVE-2022-2757": {"epss_score": 0.00215, "epss_percentile": 0.44072}, "CVE-2022-2758": {"epss_score": 0.0011, "epss_percentile": 0.30131}, "CVE-2022-2759": {"epss_score": 0.00138, "epss_percentile": 0.34506}, "CVE-2022-2760": {"epss_score": 0.0024, "epss_percentile": 0.46955}, "CVE-2022-2761": {"epss_score": 0.0028, "epss_percentile": 0.51082}, "CVE-2022-2762": {"epss_score": 0.00132, "epss_percentile": 0.33585}, "CVE-2022-2763": {"epss_score": 0.00465, "epss_percentile": 0.63752}, "CVE-2022-2764": {"epss_score": 0.0013, "epss_percentile": 0.33317}, "CVE-2022-2765": {"epss_score": 0.00582, "epss_percentile": 0.68308}, "CVE-2022-2766": {"epss_score": 0.00302, "epss_percentile": 0.53092}, "CVE-2022-2767": {"epss_score": 0.00201, "epss_percentile": 0.42387}, "CVE-2022-2768": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-2769": {"epss_score": 0.00187, "epss_percentile": 0.40765}, "CVE-2022-2770": {"epss_score": 0.00201, "epss_percentile": 0.42383}, "CVE-2022-2771": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2772": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-2773": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-2774": {"epss_score": 0.00201, "epss_percentile": 0.42383}, "CVE-2022-2775": {"epss_score": 0.00273, "epss_percentile": 0.50422}, "CVE-2022-2776": {"epss_score": 0.00271, "epss_percentile": 0.5028}, "CVE-2022-2777": {"epss_score": 0.00134, "epss_percentile": 0.33837}, "CVE-2022-2778": {"epss_score": 0.00591, "epss_percentile": 0.68601}, "CVE-2022-2779": {"epss_score": 0.00381, "epss_percentile": 0.59028}, "CVE-2022-2780": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2022-2781": {"epss_score": 0.0006, "epss_percentile": 0.18953}, "CVE-2022-2782": {"epss_score": 0.00261, "epss_percentile": 0.49285}, "CVE-2022-2783": {"epss_score": 0.00117, "epss_percentile": 0.31215}, "CVE-2022-2785": {"epss_score": 0.00096, "epss_percentile": 0.27447}, "CVE-2022-2787": {"epss_score": 0.004, "epss_percentile": 0.60161}, "CVE-2022-2788": {"epss_score": 0.00099, "epss_percentile": 0.28387}, "CVE-2022-2789": {"epss_score": 0.00031, "epss_percentile": 0.08618}, "CVE-2022-2790": {"epss_score": 0.00028, "epss_percentile": 0.07504}, "CVE-2022-2791": {"epss_score": 0.00048, "epss_percentile": 0.15221}, "CVE-2022-2792": {"epss_score": 0.00101, "epss_percentile": 0.28702}, "CVE-2022-2793": {"epss_score": 0.00021, "epss_percentile": 0.0494}, "CVE-2022-2794": {"epss_score": 0.00267, "epss_percentile": 0.50019}, "CVE-2022-2795": {"epss_score": 0.00527, "epss_percentile": 0.66463}, "CVE-2022-2796": {"epss_score": 0.00197, "epss_percentile": 0.41833}, "CVE-2022-2797": {"epss_score": 0.00166, "epss_percentile": 0.3819}, "CVE-2022-2798": {"epss_score": 0.00869, "epss_percentile": 0.74686}, "CVE-2022-2799": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-2800": {"epss_score": 0.00156, "epss_percentile": 0.36931}, "CVE-2022-2801": {"epss_score": 0.00294, "epss_percentile": 0.52367}, "CVE-2022-2802": {"epss_score": 0.00211, "epss_percentile": 0.43709}, "CVE-2022-2803": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2022-2804": {"epss_score": 0.004, "epss_percentile": 0.60149}, "CVE-2022-2805": {"epss_score": 0.00111, "epss_percentile": 0.30316}, "CVE-2022-2806": {"epss_score": 0.00043, "epss_percentile": 0.13276}, "CVE-2022-2807": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-2808": {"epss_score": 0.00283, "epss_percentile": 0.51364}, "CVE-2022-2809": {"epss_score": 0.00298, "epss_percentile": 0.52778}, "CVE-2022-2811": {"epss_score": 0.00201, "epss_percentile": 0.42387}, "CVE-2022-2812": {"epss_score": 0.00211, "epss_percentile": 0.43709}, "CVE-2022-2813": {"epss_score": 0.00088, "epss_percentile": 0.25763}, "CVE-2022-2814": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-2815": {"epss_score": 0.00267, "epss_percentile": 0.49959}, "CVE-2022-2816": {"epss_score": 0.00038, "epss_percentile": 0.11211}, "CVE-2022-2817": {"epss_score": 0.00056, "epss_percentile": 0.17773}, "CVE-2022-2818": {"epss_score": 0.01424, "epss_percentile": 0.8019}, "CVE-2022-2819": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2022-2820": {"epss_score": 0.00261, "epss_percentile": 0.4925}, "CVE-2022-2821": {"epss_score": 0.00278, "epss_percentile": 0.50849}, "CVE-2022-2822": {"epss_score": 0.00263, "epss_percentile": 0.49407}, "CVE-2022-2823": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2824": {"epss_score": 0.00514, "epss_percentile": 0.65963}, "CVE-2022-2825": {"epss_score": 0.00642, "epss_percentile": 0.70039}, "CVE-2022-2826": {"epss_score": 0.00505, "epss_percentile": 0.6561}, "CVE-2022-2827": {"epss_score": 0.16108, "epss_percentile": 0.94574}, "CVE-2022-2828": {"epss_score": 0.00214, "epss_percentile": 0.4401}, "CVE-2022-2829": {"epss_score": 0.00355, "epss_percentile": 0.57262}, "CVE-2022-2830": {"epss_score": 0.01619, "epss_percentile": 0.81377}, "CVE-2022-2831": {"epss_score": 0.00779, "epss_percentile": 0.73142}, "CVE-2022-2832": {"epss_score": 0.00781, "epss_percentile": 0.73193}, "CVE-2022-2833": {"epss_score": 0.00467, "epss_percentile": 0.63818}, "CVE-2022-2834": {"epss_score": 0.00516, "epss_percentile": 0.66032}, "CVE-2022-2835": {"epss_score": 0.00035, "epss_percentile": 0.09905}, "CVE-2022-2837": {"epss_score": 0.00173, "epss_percentile": 0.3908}, "CVE-2022-2838": {"epss_score": 0.00195, "epss_percentile": 0.41662}, "CVE-2022-2839": {"epss_score": 0.00244, "epss_percentile": 0.47522}, "CVE-2022-2840": {"epss_score": 0.05182, "epss_percentile": 0.89582}, "CVE-2022-2841": {"epss_score": 0.01827, "epss_percentile": 0.82438}, "CVE-2022-2842": {"epss_score": 0.00302, "epss_percentile": 0.53092}, "CVE-2022-2843": {"epss_score": 0.00292, "epss_percentile": 0.52263}, "CVE-2022-2844": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-2845": {"epss_score": 0.00638, "epss_percentile": 0.69919}, "CVE-2022-2846": {"epss_score": 0.0192, "epss_percentile": 0.82887}, "CVE-2022-2847": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2022-2848": {"epss_score": 0.00243, "epss_percentile": 0.47477}, "CVE-2022-2849": {"epss_score": 0.0005, "epss_percentile": 0.15929}, "CVE-2022-2850": {"epss_score": 0.00263, "epss_percentile": 0.49485}, "CVE-2022-2852": {"epss_score": 0.01529, "epss_percentile": 0.80879}, "CVE-2022-2853": {"epss_score": 0.01392, "epss_percentile": 0.7996}, "CVE-2022-2854": {"epss_score": 0.01012, "epss_percentile": 0.76625}, "CVE-2022-2855": {"epss_score": 0.01303, "epss_percentile": 0.79308}, "CVE-2022-2856": {"epss_score": 0.05114, "epss_percentile": 0.89512}, "CVE-2022-2857": {"epss_score": 0.00882, "epss_percentile": 0.74888}, "CVE-2022-2858": {"epss_score": 0.01136, "epss_percentile": 0.77917}, "CVE-2022-2859": {"epss_score": 0.01536, "epss_percentile": 0.80916}, "CVE-2022-2860": {"epss_score": 0.00333, "epss_percentile": 0.55623}, "CVE-2022-2861": {"epss_score": 0.00605, "epss_percentile": 0.68977}, "CVE-2022-2862": {"epss_score": 0.00107, "epss_percentile": 0.29632}, "CVE-2022-2863": {"epss_score": 0.06441, "epss_percentile": 0.90758}, "CVE-2022-2864": {"epss_score": 0.00182, "epss_percentile": 0.40149}, "CVE-2022-2865": {"epss_score": 0.00441, "epss_percentile": 0.62694}, "CVE-2022-2866": {"epss_score": 0.00068, "epss_percentile": 0.21246}, "CVE-2022-2867": {"epss_score": 0.00024, "epss_percentile": 0.05724}, "CVE-2022-2868": {"epss_score": 0.00023, "epss_percentile": 0.05617}, "CVE-2022-2869": {"epss_score": 0.00022, "epss_percentile": 0.05037}, "CVE-2022-2870": {"epss_score": 0.00362, "epss_percentile": 0.5781}, "CVE-2022-2871": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-2872": {"epss_score": 0.00211, "epss_percentile": 0.43678}, "CVE-2022-2873": {"epss_score": 0.00035, "epss_percentile": 0.09877}, "CVE-2022-2874": {"epss_score": 0.00045, "epss_percentile": 0.14066}, "CVE-2022-2876": {"epss_score": 0.00273, "epss_percentile": 0.5045}, "CVE-2022-2877": {"epss_score": 0.00238, "epss_percentile": 0.46768}, "CVE-2022-2879": {"epss_score": 0.00016, "epss_percentile": 0.02656}, "CVE-2022-2880": {"epss_score": 0.00031, "epss_percentile": 0.08711}, "CVE-2022-2881": {"epss_score": 0.03291, "epss_percentile": 0.86837}, "CVE-2022-2882": {"epss_score": 0.01277, "epss_percentile": 0.79111}, "CVE-2022-2883": {"epss_score": 0.00252, "epss_percentile": 0.48357}, "CVE-2022-2884": {"epss_score": 0.74588, "epss_percentile": 0.98809}, "CVE-2022-2885": {"epss_score": 0.00198, "epss_percentile": 0.42078}, "CVE-2022-2886": {"epss_score": 0.00369, "epss_percentile": 0.58244}, "CVE-2022-2887": {"epss_score": 0.00415, "epss_percentile": 0.61135}, "CVE-2022-2888": {"epss_score": 0.00047, "epss_percentile": 0.14769}, "CVE-2022-2889": {"epss_score": 0.00047, "epss_percentile": 0.14855}, "CVE-2022-2890": {"epss_score": 0.00368, "epss_percentile": 0.58178}, "CVE-2022-2891": {"epss_score": 0.00593, "epss_percentile": 0.68648}, "CVE-2022-2892": {"epss_score": 0.00061, "epss_percentile": 0.19286}, "CVE-2022-2893": {"epss_score": 0.00092, "epss_percentile": 0.26514}, "CVE-2022-2894": {"epss_score": 0.00102, "epss_percentile": 0.2874}, "CVE-2022-2895": {"epss_score": 0.00139, "epss_percentile": 0.34633}, "CVE-2022-2896": {"epss_score": 0.00071, "epss_percentile": 0.22146}, "CVE-2022-2897": {"epss_score": 0.00091, "epss_percentile": 0.26249}, "CVE-2022-2898": {"epss_score": 0.00051, "epss_percentile": 0.16281}, "CVE-2022-2900": {"epss_score": 0.00486, "epss_percentile": 0.64767}, "CVE-2022-2901": {"epss_score": 0.00137, "epss_percentile": 0.34205}, "CVE-2022-2903": {"epss_score": 0.00861, "epss_percentile": 0.74564}, "CVE-2022-2904": {"epss_score": 0.04916, "epss_percentile": 0.89285}, "CVE-2022-2905": {"epss_score": 0.00015, "epss_percentile": 0.0259}, "CVE-2022-2906": {"epss_score": 0.00859, "epss_percentile": 0.74512}, "CVE-2022-2907": {"epss_score": 0.01128, "epss_percentile": 0.77825}, "CVE-2022-2908": {"epss_score": 0.00255, "epss_percentile": 0.48646}, "CVE-2022-2909": {"epss_score": 0.00381, "epss_percentile": 0.59028}, "CVE-2022-2912": {"epss_score": 0.00251, "epss_percentile": 0.48316}, "CVE-2022-2913": {"epss_score": 0.00102, "epss_percentile": 0.28823}, "CVE-2022-2915": {"epss_score": 0.02004, "epss_percentile": 0.83227}, "CVE-2022-2921": {"epss_score": 0.00437, "epss_percentile": 0.62533}, "CVE-2022-2922": {"epss_score": 0.00429, "epss_percentile": 0.61992}, "CVE-2022-2923": {"epss_score": 0.00033, "epss_percentile": 0.09188}, "CVE-2022-2924": {"epss_score": 0.00328, "epss_percentile": 0.55189}, "CVE-2022-2925": {"epss_score": 0.0033, "epss_percentile": 0.55456}, "CVE-2022-2926": {"epss_score": 0.02604, "epss_percentile": 0.85217}, "CVE-2022-2927": {"epss_score": 0.00373, "epss_percentile": 0.58467}, "CVE-2022-2928": {"epss_score": 0.00066, "epss_percentile": 0.20878}, "CVE-2022-2929": {"epss_score": 0.00073, "epss_percentile": 0.22512}, "CVE-2022-2930": {"epss_score": 0.00122, "epss_percentile": 0.32063}, "CVE-2022-2931": {"epss_score": 0.00309, "epss_percentile": 0.53675}, "CVE-2022-2932": {"epss_score": 0.0039, "epss_percentile": 0.59557}, "CVE-2022-2933": {"epss_score": 0.0037, "epss_percentile": 0.58312}, "CVE-2022-2934": {"epss_score": 0.00913, "epss_percentile": 0.75382}, "CVE-2022-2935": {"epss_score": 0.00171, "epss_percentile": 0.38773}, "CVE-2022-2936": {"epss_score": 0.00171, "epss_percentile": 0.38773}, "CVE-2022-2937": {"epss_score": 0.00171, "epss_percentile": 0.38773}, "CVE-2022-2938": {"epss_score": 0.00027, "epss_percentile": 0.06911}, "CVE-2022-2939": {"epss_score": 0.00413, "epss_percentile": 0.60964}, "CVE-2022-2941": {"epss_score": 0.04442, "epss_percentile": 0.88695}, "CVE-2022-2943": {"epss_score": 0.01326, "epss_percentile": 0.79483}, "CVE-2022-2945": {"epss_score": 0.01292, "epss_percentile": 0.79232}, "CVE-2022-2946": {"epss_score": 0.00048, "epss_percentile": 0.15078}, "CVE-2022-2947": {"epss_score": 0.00071, "epss_percentile": 0.22202}, "CVE-2022-2948": {"epss_score": 0.00071, "epss_percentile": 0.22172}, "CVE-2022-2949": {"epss_score": 0.00068, "epss_percentile": 0.21341}, "CVE-2022-2950": {"epss_score": 0.00068, "epss_percentile": 0.21341}, "CVE-2022-2951": {"epss_score": 0.00159, "epss_percentile": 0.37358}, "CVE-2022-2952": {"epss_score": 0.00068, "epss_percentile": 0.21246}, "CVE-2022-2953": {"epss_score": 0.00026, "epss_percentile": 0.06428}, "CVE-2022-2956": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-2957": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2022-2958": {"epss_score": 0.00735, "epss_percentile": 0.72299}, "CVE-2022-2959": {"epss_score": 0.00023, "epss_percentile": 0.05591}, "CVE-2022-2961": {"epss_score": 0.00023, "epss_percentile": 0.05344}, "CVE-2022-2962": {"epss_score": 0.00027, "epss_percentile": 0.06816}, "CVE-2022-2963": {"epss_score": 0.00133, "epss_percentile": 0.33657}, "CVE-2022-2964": {"epss_score": 0.00048, "epss_percentile": 0.1513}, "CVE-2022-2965": {"epss_score": 0.00314, "epss_percentile": 0.5409}, "CVE-2022-2966": {"epss_score": 0.002, "epss_percentile": 0.42253}, "CVE-2022-2967": {"epss_score": 0.00137, "epss_percentile": 0.34274}, "CVE-2022-2969": {"epss_score": 0.00201, "epss_percentile": 0.42351}, "CVE-2022-2970": {"epss_score": 0.0021, "epss_percentile": 0.43484}, "CVE-2022-2971": {"epss_score": 0.00086, "epss_percentile": 0.25359}, "CVE-2022-2972": {"epss_score": 0.00249, "epss_percentile": 0.48038}, "CVE-2022-2973": {"epss_score": 0.00107, "epss_percentile": 0.29753}, "CVE-2022-2975": {"epss_score": 0.00047, "epss_percentile": 0.14687}, "CVE-2022-2977": {"epss_score": 0.00024, "epss_percentile": 0.05794}, "CVE-2022-2978": {"epss_score": 0.0002, "epss_percentile": 0.04658}, "CVE-2022-2979": {"epss_score": 0.00074, "epss_percentile": 0.22782}, "CVE-2022-2980": {"epss_score": 0.0005, "epss_percentile": 0.15848}, "CVE-2022-2981": {"epss_score": 0.0084, "epss_percentile": 0.74204}, "CVE-2022-2982": {"epss_score": 0.00057, "epss_percentile": 0.17996}, "CVE-2022-2983": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-2984": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-2985": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2022-2986": {"epss_score": 0.00285, "epss_percentile": 0.51512}, "CVE-2022-2987": {"epss_score": 0.00092, "epss_percentile": 0.26489}, "CVE-2022-2988": {"epss_score": 0.00172, "epss_percentile": 0.38982}, "CVE-2022-2989": {"epss_score": 0.00044, "epss_percentile": 0.13432}, "CVE-2022-2990": {"epss_score": 0.00127, "epss_percentile": 0.3281}, "CVE-2022-2991": {"epss_score": 0.0003, "epss_percentile": 0.08209}, "CVE-2022-2992": {"epss_score": 0.93806, "epss_percentile": 0.99849}, "CVE-2022-2993": {"epss_score": 0.00457, "epss_percentile": 0.63354}, "CVE-2022-2995": {"epss_score": 0.00032, "epss_percentile": 0.08858}, "CVE-2022-2996": {"epss_score": 0.00135, "epss_percentile": 0.34046}, "CVE-2022-2997": {"epss_score": 0.00332, "epss_percentile": 0.55601}, "CVE-2022-2998": {"epss_score": 0.04473, "epss_percentile": 0.88735}, "CVE-2022-30000": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30001": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30002": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30003": {"epss_score": 0.00187, "epss_percentile": 0.40765}, "CVE-2022-30004": {"epss_score": 0.00389, "epss_percentile": 0.59402}, "CVE-2022-30007": {"epss_score": 0.00378, "epss_percentile": 0.58785}, "CVE-2022-30011": {"epss_score": 0.0022, "epss_percentile": 0.44612}, "CVE-2022-30012": {"epss_score": 0.00218, "epss_percentile": 0.44422}, "CVE-2022-30013": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-30014": {"epss_score": 0.00212, "epss_percentile": 0.43759}, "CVE-2022-30015": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-30016": {"epss_score": 0.00299, "epss_percentile": 0.52901}, "CVE-2022-30017": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-30018": {"epss_score": 0.00299, "epss_percentile": 0.52901}, "CVE-2022-30023": {"epss_score": 0.27045, "epss_percentile": 0.962}, "CVE-2022-30024": {"epss_score": 0.12304, "epss_percentile": 0.93628}, "CVE-2022-30025": {"epss_score": 0.00041, "epss_percentile": 0.12372}, "CVE-2022-30028": {"epss_score": 0.00187, "epss_percentile": 0.4073}, "CVE-2022-30033": {"epss_score": 0.00331, "epss_percentile": 0.55548}, "CVE-2022-30034": {"epss_score": 0.00226, "epss_percentile": 0.4533}, "CVE-2022-30036": {"epss_score": 0.00139, "epss_percentile": 0.34566}, "CVE-2022-30037": {"epss_score": 0.00116, "epss_percentile": 0.31194}, "CVE-2022-30040": {"epss_score": 0.00465, "epss_percentile": 0.63768}, "CVE-2022-30045": {"epss_score": 0.00348, "epss_percentile": 0.56835}, "CVE-2022-30047": {"epss_score": 0.00374, "epss_percentile": 0.58548}, "CVE-2022-30048": {"epss_score": 0.00374, "epss_percentile": 0.58548}, "CVE-2022-30049": {"epss_score": 0.00243, "epss_percentile": 0.4748}, "CVE-2022-30050": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-30052": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30053": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30054": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30055": {"epss_score": 0.04428, "epss_percentile": 0.88676}, "CVE-2022-30057": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-30058": {"epss_score": 0.00264, "epss_percentile": 0.49569}, "CVE-2022-30059": {"epss_score": 0.00409, "epss_percentile": 0.60765}, "CVE-2022-30060": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2022-30061": {"epss_score": 0.00392, "epss_percentile": 0.59674}, "CVE-2022-30062": {"epss_score": 0.00382, "epss_percentile": 0.59038}, "CVE-2022-30063": {"epss_score": 0.01393, "epss_percentile": 0.79963}, "CVE-2022-30065": {"epss_score": 0.00636, "epss_percentile": 0.69831}, "CVE-2022-30067": {"epss_score": 0.00068, "epss_percentile": 0.21291}, "CVE-2022-30072": {"epss_score": 0.00258, "epss_percentile": 0.49004}, "CVE-2022-30073": {"epss_score": 0.17607, "epss_percentile": 0.94873}, "CVE-2022-30075": {"epss_score": 0.89263, "epss_percentile": 0.99518}, "CVE-2022-30076": {"epss_score": 0.01995, "epss_percentile": 0.83191}, "CVE-2022-30078": {"epss_score": 0.01608, "epss_percentile": 0.8131}, "CVE-2022-30079": {"epss_score": 0.15713, "epss_percentile": 0.94489}, "CVE-2022-30083": {"epss_score": 0.00486, "epss_percentile": 0.64766}, "CVE-2022-30105": {"epss_score": 0.03438, "epss_percentile": 0.87136}, "CVE-2022-30110": {"epss_score": 0.00144, "epss_percentile": 0.35237}, "CVE-2022-30111": {"epss_score": 0.00117, "epss_percentile": 0.31301}, "CVE-2022-30113": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2022-30114": {"epss_score": 0.03389, "epss_percentile": 0.87045}, "CVE-2022-30115": {"epss_score": 0.00101, "epss_percentile": 0.28586}, "CVE-2022-30117": {"epss_score": 0.00772, "epss_percentile": 0.73042}, "CVE-2022-30118": {"epss_score": 0.00634, "epss_percentile": 0.69794}, "CVE-2022-30119": {"epss_score": 0.00634, "epss_percentile": 0.69794}, "CVE-2022-30120": {"epss_score": 0.01338, "epss_percentile": 0.79565}, "CVE-2022-30121": {"epss_score": 0.00131, "epss_percentile": 0.33478}, "CVE-2022-30122": {"epss_score": 0.01157, "epss_percentile": 0.78108}, "CVE-2022-30123": {"epss_score": 0.02416, "epss_percentile": 0.84688}, "CVE-2022-30124": {"epss_score": 0.00076, "epss_percentile": 0.23241}, "CVE-2022-30126": {"epss_score": 0.01502, "epss_percentile": 0.80722}, "CVE-2022-30127": {"epss_score": 0.0069, "epss_percentile": 0.71249}, "CVE-2022-30128": {"epss_score": 0.0069, "epss_percentile": 0.71249}, "CVE-2022-30129": {"epss_score": 0.36914, "epss_percentile": 0.97009}, "CVE-2022-30130": {"epss_score": 0.05742, "epss_percentile": 0.90172}, "CVE-2022-30131": {"epss_score": 0.00569, "epss_percentile": 0.67932}, "CVE-2022-30132": {"epss_score": 0.00583, "epss_percentile": 0.68352}, "CVE-2022-30133": {"epss_score": 0.21716, "epss_percentile": 0.95552}, "CVE-2022-30134": {"epss_score": 0.03806, "epss_percentile": 0.87751}, "CVE-2022-30135": {"epss_score": 0.00343, "epss_percentile": 0.56429}, "CVE-2022-30136": {"epss_score": 0.41194, "epss_percentile": 0.97257}, "CVE-2022-30137": {"epss_score": 0.0035, "epss_percentile": 0.56953}, "CVE-2022-30138": {"epss_score": 0.00823, "epss_percentile": 0.7393}, "CVE-2022-30139": {"epss_score": 0.05291, "epss_percentile": 0.89697}, "CVE-2022-30140": {"epss_score": 0.01692, "epss_percentile": 0.81791}, "CVE-2022-30141": {"epss_score": 0.09818, "epss_percentile": 0.92715}, "CVE-2022-30142": {"epss_score": 0.04672, "epss_percentile": 0.88988}, "CVE-2022-30143": {"epss_score": 0.04114, "epss_percentile": 0.88276}, "CVE-2022-30144": {"epss_score": 0.01087, "epss_percentile": 0.77426}, "CVE-2022-30145": {"epss_score": 0.05147, "epss_percentile": 0.89546}, "CVE-2022-30146": {"epss_score": 0.04114, "epss_percentile": 0.88276}, "CVE-2022-30147": {"epss_score": 0.01688, "epss_percentile": 0.81763}, "CVE-2022-30148": {"epss_score": 0.00777, "epss_percentile": 0.73113}, "CVE-2022-30149": {"epss_score": 0.0408, "epss_percentile": 0.88217}, "CVE-2022-30150": {"epss_score": 0.02917, "epss_percentile": 0.85985}, "CVE-2022-30151": {"epss_score": 0.00359, "epss_percentile": 0.57552}, "CVE-2022-30152": {"epss_score": 0.18394, "epss_percentile": 0.9501}, "CVE-2022-30153": {"epss_score": 0.08902, "epss_percentile": 0.92308}, "CVE-2022-30154": {"epss_score": 0.01281, "epss_percentile": 0.79147}, "CVE-2022-30155": {"epss_score": 0.03859, "epss_percentile": 0.87862}, "CVE-2022-30157": {"epss_score": 0.13451, "epss_percentile": 0.93969}, "CVE-2022-30158": {"epss_score": 0.09285, "epss_percentile": 0.92484}, "CVE-2022-30159": {"epss_score": 0.03419, "epss_percentile": 0.87097}, "CVE-2022-30160": {"epss_score": 0.04377, "epss_percentile": 0.88619}, "CVE-2022-30161": {"epss_score": 0.08833, "epss_percentile": 0.92275}, "CVE-2022-30162": {"epss_score": 0.00548, "epss_percentile": 0.67271}, "CVE-2022-30163": {"epss_score": 0.00624, "epss_percentile": 0.69558}, "CVE-2022-30164": {"epss_score": 0.00993, "epss_percentile": 0.76414}, "CVE-2022-30165": {"epss_score": 0.07771, "epss_percentile": 0.91673}, "CVE-2022-30166": {"epss_score": 0.07684, "epss_percentile": 0.91624}, "CVE-2022-30167": {"epss_score": 0.02746, "epss_percentile": 0.85573}, "CVE-2022-30168": {"epss_score": 0.02682, "epss_percentile": 0.85419}, "CVE-2022-30170": {"epss_score": 0.02684, "epss_percentile": 0.85423}, "CVE-2022-30171": {"epss_score": 0.04038, "epss_percentile": 0.88161}, "CVE-2022-30172": {"epss_score": 0.04611, "epss_percentile": 0.88915}, "CVE-2022-30173": {"epss_score": 0.02746, "epss_percentile": 0.85573}, "CVE-2022-30174": {"epss_score": 0.03092, "epss_percentile": 0.86398}, "CVE-2022-30175": {"epss_score": 0.01534, "epss_percentile": 0.80906}, "CVE-2022-30176": {"epss_score": 0.03457, "epss_percentile": 0.87174}, "CVE-2022-30177": {"epss_score": 0.02746, "epss_percentile": 0.85573}, "CVE-2022-30178": {"epss_score": 0.02746, "epss_percentile": 0.85573}, "CVE-2022-30179": {"epss_score": 0.02746, "epss_percentile": 0.85573}, "CVE-2022-30180": {"epss_score": 0.02746, "epss_percentile": 0.85573}, "CVE-2022-30181": {"epss_score": 0.00657, "epss_percentile": 0.70457}, "CVE-2022-30184": {"epss_score": 0.00563, "epss_percentile": 0.67724}, "CVE-2022-30187": {"epss_score": 0.00336, "epss_percentile": 0.55915}, "CVE-2022-30188": {"epss_score": 0.03165, "epss_percentile": 0.86538}, "CVE-2022-30189": {"epss_score": 0.06088, "epss_percentile": 0.90466}, "CVE-2022-30190": {"epss_score": 0.93612, "epss_percentile": 0.99824}, "CVE-2022-30192": {"epss_score": 0.01648, "epss_percentile": 0.81542}, "CVE-2022-30193": {"epss_score": 0.02746, "epss_percentile": 0.85573}, "CVE-2022-30194": {"epss_score": 0.01348, "epss_percentile": 0.79664}, "CVE-2022-30196": {"epss_score": 0.07673, "epss_percentile": 0.91617}, "CVE-2022-30197": {"epss_score": 0.00948, "epss_percentile": 0.75826}, "CVE-2022-30198": {"epss_score": 0.01036, "epss_percentile": 0.7692}, "CVE-2022-30200": {"epss_score": 0.02026, "epss_percentile": 0.83316}, "CVE-2022-30202": {"epss_score": 0.0068, "epss_percentile": 0.71031}, "CVE-2022-30203": {"epss_score": 0.01086, "epss_percentile": 0.77411}, "CVE-2022-30205": {"epss_score": 0.0057, "epss_percentile": 0.67971}, "CVE-2022-30206": {"epss_score": 0.23184, "epss_percentile": 0.95747}, "CVE-2022-30208": {"epss_score": 0.04466, "epss_percentile": 0.88729}, "CVE-2022-30209": {"epss_score": 0.04019, "epss_percentile": 0.88127}, "CVE-2022-30211": {"epss_score": 0.04084, "epss_percentile": 0.88225}, "CVE-2022-30212": {"epss_score": 0.00306, "epss_percentile": 0.53466}, "CVE-2022-30213": {"epss_score": 0.00626, "epss_percentile": 0.6962}, "CVE-2022-30214": {"epss_score": 0.00462, "epss_percentile": 0.63588}, "CVE-2022-30215": {"epss_score": 0.05076, "epss_percentile": 0.89468}, "CVE-2022-30216": {"epss_score": 0.56765, "epss_percentile": 0.98036}, "CVE-2022-30220": {"epss_score": 0.00742, "epss_percentile": 0.72461}, "CVE-2022-30221": {"epss_score": 0.05215, "epss_percentile": 0.89619}, "CVE-2022-30222": {"epss_score": 0.00464, "epss_percentile": 0.63728}, "CVE-2022-30223": {"epss_score": 0.02733, "epss_percentile": 0.85547}, "CVE-2022-30224": {"epss_score": 0.00489, "epss_percentile": 0.64875}, "CVE-2022-30225": {"epss_score": 0.00376, "epss_percentile": 0.58683}, "CVE-2022-30226": {"epss_score": 0.00572, "epss_percentile": 0.68024}, "CVE-2022-30228": {"epss_score": 0.00147, "epss_percentile": 0.35783}, "CVE-2022-30229": {"epss_score": 0.00353, "epss_percentile": 0.57146}, "CVE-2022-30230": {"epss_score": 0.00689, "epss_percentile": 0.71229}, "CVE-2022-30231": {"epss_score": 0.00187, "epss_percentile": 0.408}, "CVE-2022-30232": {"epss_score": 0.01067, "epss_percentile": 0.77225}, "CVE-2022-30233": {"epss_score": 0.0033, "epss_percentile": 0.55458}, "CVE-2022-30234": {"epss_score": 0.00469, "epss_percentile": 0.63955}, "CVE-2022-30235": {"epss_score": 0.00337, "epss_percentile": 0.56009}, "CVE-2022-30236": {"epss_score": 0.00511, "epss_percentile": 0.65835}, "CVE-2022-30237": {"epss_score": 0.00105, "epss_percentile": 0.29366}, "CVE-2022-30238": {"epss_score": 0.00367, "epss_percentile": 0.58108}, "CVE-2022-30239": {"epss_score": 0.00172, "epss_percentile": 0.39018}, "CVE-2022-30240": {"epss_score": 0.00172, "epss_percentile": 0.39018}, "CVE-2022-30241": {"epss_score": 0.002, "epss_percentile": 0.42199}, "CVE-2022-30242": {"epss_score": 0.00111, "epss_percentile": 0.30375}, "CVE-2022-30243": {"epss_score": 0.00373, "epss_percentile": 0.58507}, "CVE-2022-30244": {"epss_score": 0.00365, "epss_percentile": 0.57986}, "CVE-2022-30245": {"epss_score": 0.00125, "epss_percentile": 0.32618}, "CVE-2022-30256": {"epss_score": 0.00762, "epss_percentile": 0.72841}, "CVE-2022-30257": {"epss_score": 0.00431, "epss_percentile": 0.62044}, "CVE-2022-30258": {"epss_score": 0.00431, "epss_percentile": 0.62044}, "CVE-2022-30260": {"epss_score": 0.00028, "epss_percentile": 0.07273}, "CVE-2022-30262": {"epss_score": 0.00024, "epss_percentile": 0.05745}, "CVE-2022-30264": {"epss_score": 0.00119, "epss_percentile": 0.31592}, "CVE-2022-30269": {"epss_score": 0.00094, "epss_percentile": 0.27065}, "CVE-2022-30270": {"epss_score": 0.00285, "epss_percentile": 0.51674}, "CVE-2022-30271": {"epss_score": 0.00189, "epss_percentile": 0.40968}, "CVE-2022-30272": {"epss_score": 0.00101, "epss_percentile": 0.28582}, "CVE-2022-30273": {"epss_score": 0.00049, "epss_percentile": 0.15324}, "CVE-2022-30274": {"epss_score": 0.00165, "epss_percentile": 0.38059}, "CVE-2022-30275": {"epss_score": 0.00114, "epss_percentile": 0.30799}, "CVE-2022-30276": {"epss_score": 0.00304, "epss_percentile": 0.53306}, "CVE-2022-30277": {"epss_score": 0.00045, "epss_percentile": 0.13897}, "CVE-2022-30278": {"epss_score": 0.00406, "epss_percentile": 0.60525}, "CVE-2022-30279": {"epss_score": 0.0039, "epss_percentile": 0.59533}, "CVE-2022-30280": {"epss_score": 0.00218, "epss_percentile": 0.44435}, "CVE-2022-30283": {"epss_score": 0.00055, "epss_percentile": 0.17515}, "CVE-2022-30284": {"epss_score": 0.15413, "epss_percentile": 0.94426}, "CVE-2022-30285": {"epss_score": 0.00267, "epss_percentile": 0.49952}, "CVE-2022-30286": {"epss_score": 0.30797, "epss_percentile": 0.96568}, "CVE-2022-30287": {"epss_score": 0.15535, "epss_percentile": 0.94452}, "CVE-2022-30288": {"epss_score": 0.00367, "epss_percentile": 0.58125}, "CVE-2022-30289": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-30290": {"epss_score": 0.00344, "epss_percentile": 0.56515}, "CVE-2022-30292": {"epss_score": 0.02492, "epss_percentile": 0.84899}, "CVE-2022-30293": {"epss_score": 0.00186, "epss_percentile": 0.4061}, "CVE-2022-30295": {"epss_score": 0.00695, "epss_percentile": 0.71372}, "CVE-2022-30296": {"epss_score": 0.00805, "epss_percentile": 0.73644}, "CVE-2022-30297": {"epss_score": 0.00233, "epss_percentile": 0.45982}, "CVE-2022-30298": {"epss_score": 0.00046, "epss_percentile": 0.14077}, "CVE-2022-30299": {"epss_score": 0.0042, "epss_percentile": 0.61406}, "CVE-2022-30300": {"epss_score": 0.0068, "epss_percentile": 0.71035}, "CVE-2022-30301": {"epss_score": 0.00059, "epss_percentile": 0.18779}, "CVE-2022-30302": {"epss_score": 0.00455, "epss_percentile": 0.63296}, "CVE-2022-30303": {"epss_score": 0.01349, "epss_percentile": 0.79668}, "CVE-2022-30304": {"epss_score": 0.00305, "epss_percentile": 0.53342}, "CVE-2022-30305": {"epss_score": 0.00218, "epss_percentile": 0.44397}, "CVE-2022-30306": {"epss_score": 0.00389, "epss_percentile": 0.59489}, "CVE-2022-30307": {"epss_score": 0.00967, "epss_percentile": 0.76068}, "CVE-2022-30308": {"epss_score": 0.0103, "epss_percentile": 0.76837}, "CVE-2022-30309": {"epss_score": 0.00978, "epss_percentile": 0.76242}, "CVE-2022-30310": {"epss_score": 0.01638, "epss_percentile": 0.81487}, "CVE-2022-30311": {"epss_score": 0.00984, "epss_percentile": 0.76317}, "CVE-2022-30312": {"epss_score": 0.00039, "epss_percentile": 0.11755}, "CVE-2022-30313": {"epss_score": 0.00212, "epss_percentile": 0.43741}, "CVE-2022-30314": {"epss_score": 0.00072, "epss_percentile": 0.22393}, "CVE-2022-30315": {"epss_score": 0.01443, "epss_percentile": 0.80315}, "CVE-2022-30316": {"epss_score": 0.0012, "epss_percentile": 0.31732}, "CVE-2022-30317": {"epss_score": 0.00317, "epss_percentile": 0.54382}, "CVE-2022-30318": {"epss_score": 0.03393, "epss_percentile": 0.87055}, "CVE-2022-30319": {"epss_score": 0.00059, "epss_percentile": 0.18676}, "CVE-2022-30320": {"epss_score": 0.00029, "epss_percentile": 0.07683}, "CVE-2022-30321": {"epss_score": 0.01225, "epss_percentile": 0.78681}, "CVE-2022-30322": {"epss_score": 0.00379, "epss_percentile": 0.58882}, "CVE-2022-30323": {"epss_score": 0.00379, "epss_percentile": 0.58882}, "CVE-2022-30324": {"epss_score": 0.00419, "epss_percentile": 0.61391}, "CVE-2022-30325": {"epss_score": 0.00099, "epss_percentile": 0.28392}, "CVE-2022-30326": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-30327": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2022-30328": {"epss_score": 0.00117, "epss_percentile": 0.31326}, "CVE-2022-30329": {"epss_score": 0.00775, "epss_percentile": 0.73082}, "CVE-2022-30330": {"epss_score": 0.0007, "epss_percentile": 0.21688}, "CVE-2022-30331": {"epss_score": 0.00342, "epss_percentile": 0.56353}, "CVE-2022-30332": {"epss_score": 0.00269, "epss_percentile": 0.50165}, "CVE-2022-30333": {"epss_score": 0.92572, "epss_percentile": 0.99728}, "CVE-2022-30334": {"epss_score": 0.00255, "epss_percentile": 0.48701}, "CVE-2022-30335": {"epss_score": 0.00316, "epss_percentile": 0.54231}, "CVE-2022-30337": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-30338": {"epss_score": 0.00052, "epss_percentile": 0.16541}, "CVE-2022-30339": {"epss_score": 0.00082, "epss_percentile": 0.24467}, "CVE-2022-30349": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-30350": {"epss_score": 0.00098, "epss_percentile": 0.27714}, "CVE-2022-30351": {"epss_score": 0.00084, "epss_percentile": 0.24911}, "CVE-2022-30352": {"epss_score": 0.00477, "epss_percentile": 0.64304}, "CVE-2022-30354": {"epss_score": 0.00153, "epss_percentile": 0.36556}, "CVE-2022-30355": {"epss_score": 0.0012, "epss_percentile": 0.3169}, "CVE-2022-30356": {"epss_score": 0.00053, "epss_percentile": 0.16828}, "CVE-2022-30357": {"epss_score": 0.00093, "epss_percentile": 0.26647}, "CVE-2022-30358": {"epss_score": 0.0011, "epss_percentile": 0.30211}, "CVE-2022-30359": {"epss_score": 0.00117, "epss_percentile": 0.3128}, "CVE-2022-30360": {"epss_score": 0.00119, "epss_percentile": 0.31557}, "CVE-2022-30361": {"epss_score": 0.00111, "epss_percentile": 0.30269}, "CVE-2022-30367": {"epss_score": 0.0028, "epss_percentile": 0.51066}, "CVE-2022-30370": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30371": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30372": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30373": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30374": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30375": {"epss_score": 0.0028, "epss_percentile": 0.51066}, "CVE-2022-30376": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30378": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30379": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30381": {"epss_score": 0.00339, "epss_percentile": 0.56207}, "CVE-2022-30384": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30385": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30386": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30387": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30391": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30392": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30393": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30395": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30396": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30398": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30399": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30400": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30401": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30402": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30403": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30404": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30407": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30408": {"epss_score": 0.00339, "epss_percentile": 0.56207}, "CVE-2022-30411": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30412": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30413": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30414": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30415": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30417": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30421": {"epss_score": 0.00035, "epss_percentile": 0.09982}, "CVE-2022-30422": {"epss_score": 0.06591, "epss_percentile": 0.90873}, "CVE-2022-30423": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2022-30425": {"epss_score": 0.18925, "epss_percentile": 0.95098}, "CVE-2022-30426": {"epss_score": 0.00095, "epss_percentile": 0.27198}, "CVE-2022-30427": {"epss_score": 0.00317, "epss_percentile": 0.5439}, "CVE-2022-30428": {"epss_score": 0.00221, "epss_percentile": 0.44678}, "CVE-2022-30429": {"epss_score": 0.00502, "epss_percentile": 0.65419}, "CVE-2022-30448": {"epss_score": 0.00337, "epss_percentile": 0.56015}, "CVE-2022-30449": {"epss_score": 0.00205, "epss_percentile": 0.42701}, "CVE-2022-30450": {"epss_score": 0.03592, "epss_percentile": 0.87401}, "CVE-2022-30451": {"epss_score": 0.01139, "epss_percentile": 0.77936}, "CVE-2022-30452": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30453": {"epss_score": 0.00595, "epss_percentile": 0.68693}, "CVE-2022-30454": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-30455": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-30456": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-30458": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-30459": {"epss_score": 0.003, "epss_percentile": 0.52943}, "CVE-2022-30460": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-30461": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-30462": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-30463": {"epss_score": 0.003, "epss_percentile": 0.52943}, "CVE-2022-30464": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-30466": {"epss_score": 0.00073, "epss_percentile": 0.2259}, "CVE-2022-30467": {"epss_score": 0.0041, "epss_percentile": 0.60842}, "CVE-2022-30469": {"epss_score": 0.01435, "epss_percentile": 0.80269}, "CVE-2022-30470": {"epss_score": 0.08286, "epss_percentile": 0.9197}, "CVE-2022-30472": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2022-30473": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2022-30474": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2022-30475": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2022-30476": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2022-30477": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2022-30478": {"epss_score": 0.00316, "epss_percentile": 0.54231}, "CVE-2022-30481": {"epss_score": 0.00322, "epss_percentile": 0.54781}, "CVE-2022-30482": {"epss_score": 0.00301, "epss_percentile": 0.53007}, "CVE-2022-30489": {"epss_score": 0.29079, "epss_percentile": 0.96416}, "CVE-2022-30490": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30493": {"epss_score": 0.02047, "epss_percentile": 0.83388}, "CVE-2022-30494": {"epss_score": 0.00149, "epss_percentile": 0.35959}, "CVE-2022-30495": {"epss_score": 0.00377, "epss_percentile": 0.58727}, "CVE-2022-30496": {"epss_score": 0.00328, "epss_percentile": 0.55294}, "CVE-2022-30500": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2022-30503": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2022-30506": {"epss_score": 0.02652, "epss_percentile": 0.85347}, "CVE-2022-30508": {"epss_score": 0.00875, "epss_percentile": 0.7478}, "CVE-2022-30510": {"epss_score": 0.23775, "epss_percentile": 0.95815}, "CVE-2022-30511": {"epss_score": 0.23775, "epss_percentile": 0.95815}, "CVE-2022-30512": {"epss_score": 0.71786, "epss_percentile": 0.98681}, "CVE-2022-30513": {"epss_score": 0.07297, "epss_percentile": 0.9139}, "CVE-2022-30514": {"epss_score": 0.07297, "epss_percentile": 0.9139}, "CVE-2022-30515": {"epss_score": 0.00221, "epss_percentile": 0.44712}, "CVE-2022-30516": {"epss_score": 0.00218, "epss_percentile": 0.44369}, "CVE-2022-30517": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-30518": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-30519": {"epss_score": 0.02031, "epss_percentile": 0.83335}, "CVE-2022-30521": {"epss_score": 0.01758, "epss_percentile": 0.82136}, "CVE-2022-30522": {"epss_score": 0.10099, "epss_percentile": 0.92847}, "CVE-2022-30523": {"epss_score": 0.00041, "epss_percentile": 0.12289}, "CVE-2022-30524": {"epss_score": 0.01638, "epss_percentile": 0.81484}, "CVE-2022-30525": {"epss_score": 0.94445, "epss_percentile": 0.9999}, "CVE-2022-30526": {"epss_score": 0.02141, "epss_percentile": 0.83749}, "CVE-2022-30527": {"epss_score": 0.0008, "epss_percentile": 0.24095}, "CVE-2022-30528": {"epss_score": 0.00442, "epss_percentile": 0.6273}, "CVE-2022-30529": {"epss_score": 0.00427, "epss_percentile": 0.61775}, "CVE-2022-30530": {"epss_score": 0.00209, "epss_percentile": 0.43405}, "CVE-2022-30531": {"epss_score": 0.00091, "epss_percentile": 0.26389}, "CVE-2022-30532": {"epss_score": 0.00249, "epss_percentile": 0.4802}, "CVE-2022-30533": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2022-30534": {"epss_score": 0.1272, "epss_percentile": 0.93757}, "CVE-2022-30535": {"epss_score": 0.00543, "epss_percentile": 0.67092}, "CVE-2022-30536": {"epss_score": 0.01658, "epss_percentile": 0.8161}, "CVE-2022-30538": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-30539": {"epss_score": 0.0006, "epss_percentile": 0.19082}, "CVE-2022-30540": {"epss_score": 0.00504, "epss_percentile": 0.65517}, "CVE-2022-30541": {"epss_score": 0.01361, "epss_percentile": 0.79751}, "CVE-2022-30542": {"epss_score": 0.00058, "epss_percentile": 0.18451}, "CVE-2022-30543": {"epss_score": 0.00558, "epss_percentile": 0.67583}, "CVE-2022-30544": {"epss_score": 0.00094, "epss_percentile": 0.26965}, "CVE-2022-30545": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-30546": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-30547": {"epss_score": 0.23929, "epss_percentile": 0.95835}, "CVE-2022-30548": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2022-30549": {"epss_score": 0.00403, "epss_percentile": 0.60348}, "CVE-2022-30550": {"epss_score": 0.00307, "epss_percentile": 0.5352}, "CVE-2022-30551": {"epss_score": 0.01099, "epss_percentile": 0.77556}, "CVE-2022-30552": {"epss_score": 0.00067, "epss_percentile": 0.2107}, "CVE-2022-30556": {"epss_score": 0.00345, "epss_percentile": 0.5655}, "CVE-2022-30557": {"epss_score": 0.00555, "epss_percentile": 0.67458}, "CVE-2022-30560": {"epss_score": 0.00284, "epss_percentile": 0.51429}, "CVE-2022-30561": {"epss_score": 0.0034, "epss_percentile": 0.56225}, "CVE-2022-30562": {"epss_score": 0.00271, "epss_percentile": 0.50299}, "CVE-2022-30563": {"epss_score": 0.00489, "epss_percentile": 0.64869}, "CVE-2022-30564": {"epss_score": 0.0008, "epss_percentile": 0.2407}, "CVE-2022-30570": {"epss_score": 0.00284, "epss_percentile": 0.51437}, "CVE-2022-30571": {"epss_score": 0.00585, "epss_percentile": 0.68417}, "CVE-2022-30572": {"epss_score": 0.00384, "epss_percentile": 0.59155}, "CVE-2022-30573": {"epss_score": 0.00509, "epss_percentile": 0.65749}, "CVE-2022-30574": {"epss_score": 0.00044, "epss_percentile": 0.13474}, "CVE-2022-30575": {"epss_score": 0.00618, "epss_percentile": 0.69382}, "CVE-2022-30576": {"epss_score": 0.00618, "epss_percentile": 0.69382}, "CVE-2022-30577": {"epss_score": 0.0087, "epss_percentile": 0.747}, "CVE-2022-30578": {"epss_score": 0.01192, "epss_percentile": 0.78403}, "CVE-2022-30579": {"epss_score": 0.00247, "epss_percentile": 0.47847}, "CVE-2022-30580": {"epss_score": 0.00026, "epss_percentile": 0.06723}, "CVE-2022-30584": {"epss_score": 0.00485, "epss_percentile": 0.64713}, "CVE-2022-30585": {"epss_score": 0.00192, "epss_percentile": 0.41356}, "CVE-2022-30586": {"epss_score": 0.01105, "epss_percentile": 0.77612}, "CVE-2022-30587": {"epss_score": 0.0024, "epss_percentile": 0.47203}, "CVE-2022-30591": {"epss_score": 0.11856, "epss_percentile": 0.93497}, "CVE-2022-30592": {"epss_score": 0.06815, "epss_percentile": 0.91043}, "CVE-2022-30594": {"epss_score": 0.00024, "epss_percentile": 0.05662}, "CVE-2022-30595": {"epss_score": 0.0048, "epss_percentile": 0.64462}, "CVE-2022-30596": {"epss_score": 0.01161, "epss_percentile": 0.7814}, "CVE-2022-30597": {"epss_score": 0.0053, "epss_percentile": 0.66611}, "CVE-2022-30598": {"epss_score": 0.00506, "epss_percentile": 0.65622}, "CVE-2022-30599": {"epss_score": 0.00817, "epss_percentile": 0.73842}, "CVE-2022-30600": {"epss_score": 0.02931, "epss_percentile": 0.86015}, "CVE-2022-30601": {"epss_score": 0.01676, "epss_percentile": 0.81707}, "CVE-2022-30602": {"epss_score": 0.00396, "epss_percentile": 0.59889}, "CVE-2022-30603": {"epss_score": 0.025, "epss_percentile": 0.84919}, "CVE-2022-30604": {"epss_score": 0.00189, "epss_percentile": 0.40923}, "CVE-2022-30605": {"epss_score": 0.00378, "epss_percentile": 0.58838}, "CVE-2022-30607": {"epss_score": 0.00245, "epss_percentile": 0.47684}, "CVE-2022-30608": {"epss_score": 0.00193, "epss_percentile": 0.41417}, "CVE-2022-30610": {"epss_score": 0.00104, "epss_percentile": 0.2918}, "CVE-2022-30611": {"epss_score": 0.001, "epss_percentile": 0.28456}, "CVE-2022-30613": {"epss_score": 0.00043, "epss_percentile": 0.12969}, "CVE-2022-30614": {"epss_score": 0.00891, "epss_percentile": 0.75048}, "CVE-2022-30615": {"epss_score": 0.00493, "epss_percentile": 0.6503}, "CVE-2022-30616": {"epss_score": 0.00402, "epss_percentile": 0.60289}, "CVE-2022-30617": {"epss_score": 0.00363, "epss_percentile": 0.57849}, "CVE-2022-30618": {"epss_score": 0.00297, "epss_percentile": 0.52767}, "CVE-2022-30619": {"epss_score": 0.00279, "epss_percentile": 0.50925}, "CVE-2022-30620": {"epss_score": 0.00349, "epss_percentile": 0.56887}, "CVE-2022-30621": {"epss_score": 0.00252, "epss_percentile": 0.48401}, "CVE-2022-30622": {"epss_score": 0.0003, "epss_percentile": 0.08293}, "CVE-2022-30623": {"epss_score": 0.00132, "epss_percentile": 0.3358}, "CVE-2022-30624": {"epss_score": 0.00119, "epss_percentile": 0.31585}, "CVE-2022-30625": {"epss_score": 0.00128, "epss_percentile": 0.32959}, "CVE-2022-30626": {"epss_score": 0.00063, "epss_percentile": 0.19996}, "CVE-2022-30627": {"epss_score": 0.0012, "epss_percentile": 0.31722}, "CVE-2022-30628": {"epss_score": 0.00046, "epss_percentile": 0.14288}, "CVE-2022-30629": {"epss_score": 0.00066, "epss_percentile": 0.20756}, "CVE-2022-30630": {"epss_score": 0.00034, "epss_percentile": 0.09544}, "CVE-2022-30631": {"epss_score": 0.00041, "epss_percentile": 0.12268}, "CVE-2022-30632": {"epss_score": 0.00084, "epss_percentile": 0.24997}, "CVE-2022-30633": {"epss_score": 0.00084, "epss_percentile": 0.24997}, "CVE-2022-30634": {"epss_score": 0.00024, "epss_percentile": 0.05796}, "CVE-2022-30635": {"epss_score": 0.00087, "epss_percentile": 0.2549}, "CVE-2022-30636": {"epss_score": 0.00247, "epss_percentile": 0.47907}, "CVE-2022-30637": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2022-30638": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2022-30639": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2022-30640": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2022-30641": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2022-30642": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2022-30643": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2022-30644": {"epss_score": 0.00165, "epss_percentile": 0.38123}, "CVE-2022-30645": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2022-30646": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2022-30647": {"epss_score": 0.22453, "epss_percentile": 0.95636}, "CVE-2022-30648": {"epss_score": 0.22453, "epss_percentile": 0.95636}, "CVE-2022-30649": {"epss_score": 0.07184, "epss_percentile": 0.91305}, "CVE-2022-30650": {"epss_score": 0.04246, "epss_percentile": 0.88441}, "CVE-2022-30651": {"epss_score": 0.02348, "epss_percentile": 0.84458}, "CVE-2022-30652": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-30653": {"epss_score": 0.03964, "epss_percentile": 0.88028}, "CVE-2022-30654": {"epss_score": 0.04246, "epss_percentile": 0.88441}, "CVE-2022-30655": {"epss_score": 0.1143, "epss_percentile": 0.93348}, "CVE-2022-30656": {"epss_score": 0.01507, "epss_percentile": 0.80752}, "CVE-2022-30657": {"epss_score": 0.1143, "epss_percentile": 0.93348}, "CVE-2022-30658": {"epss_score": 0.03172, "epss_percentile": 0.86549}, "CVE-2022-30659": {"epss_score": 0.01507, "epss_percentile": 0.80752}, "CVE-2022-30660": {"epss_score": 0.02958, "epss_percentile": 0.86068}, "CVE-2022-30661": {"epss_score": 0.03172, "epss_percentile": 0.86549}, "CVE-2022-30662": {"epss_score": 0.02958, "epss_percentile": 0.86068}, "CVE-2022-30663": {"epss_score": 0.02958, "epss_percentile": 0.86068}, "CVE-2022-30664": {"epss_score": 0.01335, "epss_percentile": 0.79549}, "CVE-2022-30665": {"epss_score": 0.02958, "epss_percentile": 0.86068}, "CVE-2022-30666": {"epss_score": 0.02038, "epss_percentile": 0.83359}, "CVE-2022-30667": {"epss_score": 0.02038, "epss_percentile": 0.83359}, "CVE-2022-30668": {"epss_score": 0.02038, "epss_percentile": 0.83359}, "CVE-2022-30669": {"epss_score": 0.02038, "epss_percentile": 0.83359}, "CVE-2022-30670": {"epss_score": 0.00841, "epss_percentile": 0.74222}, "CVE-2022-30671": {"epss_score": 0.00162, "epss_percentile": 0.37657}, "CVE-2022-30672": {"epss_score": 0.00162, "epss_percentile": 0.37657}, "CVE-2022-30673": {"epss_score": 0.00181, "epss_percentile": 0.39994}, "CVE-2022-30674": {"epss_score": 0.00153, "epss_percentile": 0.36583}, "CVE-2022-30675": {"epss_score": 0.00181, "epss_percentile": 0.39994}, "CVE-2022-30676": {"epss_score": 0.00181, "epss_percentile": 0.39994}, "CVE-2022-30677": {"epss_score": 0.01287, "epss_percentile": 0.79195}, "CVE-2022-30678": {"epss_score": 0.01287, "epss_percentile": 0.79195}, "CVE-2022-30679": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-30680": {"epss_score": 0.01287, "epss_percentile": 0.79195}, "CVE-2022-30681": {"epss_score": 0.01287, "epss_percentile": 0.79195}, "CVE-2022-30682": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-30683": {"epss_score": 0.00322, "epss_percentile": 0.54859}, "CVE-2022-30684": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-30685": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-30686": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-30687": {"epss_score": 0.00176, "epss_percentile": 0.39467}, "CVE-2022-30688": {"epss_score": 0.00051, "epss_percentile": 0.16311}, "CVE-2022-30689": {"epss_score": 0.0036, "epss_percentile": 0.5762}, "CVE-2022-30690": {"epss_score": 0.15138, "epss_percentile": 0.94371}, "CVE-2022-30691": {"epss_score": 0.00054, "epss_percentile": 0.1708}, "CVE-2022-30692": {"epss_score": 0.00347, "epss_percentile": 0.56784}, "CVE-2022-30693": {"epss_score": 0.00155, "epss_percentile": 0.36831}, "CVE-2022-30694": {"epss_score": 0.00157, "epss_percentile": 0.37062}, "CVE-2022-30695": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2022-30696": {"epss_score": 0.00054, "epss_percentile": 0.17175}, "CVE-2022-30697": {"epss_score": 0.00039, "epss_percentile": 0.11527}, "CVE-2022-30698": {"epss_score": 0.00118, "epss_percentile": 0.31445}, "CVE-2022-30699": {"epss_score": 0.00118, "epss_percentile": 0.31445}, "CVE-2022-30700": {"epss_score": 0.00061, "epss_percentile": 0.19415}, "CVE-2022-30701": {"epss_score": 0.0007, "epss_percentile": 0.21947}, "CVE-2022-30702": {"epss_score": 0.0013, "epss_percentile": 0.33251}, "CVE-2022-30703": {"epss_score": 0.00125, "epss_percentile": 0.32485}, "CVE-2022-30704": {"epss_score": 0.00057, "epss_percentile": 0.17996}, "CVE-2022-30705": {"epss_score": 0.0005, "epss_percentile": 0.15773}, "CVE-2022-30706": {"epss_score": 0.00276, "epss_percentile": 0.5074}, "CVE-2022-30707": {"epss_score": 0.00717, "epss_percentile": 0.71874}, "CVE-2022-30708": {"epss_score": 0.05421, "epss_percentile": 0.89858}, "CVE-2022-30709": {"epss_score": 0.00057, "epss_percentile": 0.18205}, "CVE-2022-30710": {"epss_score": 0.00058, "epss_percentile": 0.18364}, "CVE-2022-30711": {"epss_score": 0.00058, "epss_percentile": 0.18364}, "CVE-2022-30712": {"epss_score": 0.00067, "epss_percentile": 0.20968}, "CVE-2022-30713": {"epss_score": 0.00094, "epss_percentile": 0.26801}, "CVE-2022-30714": {"epss_score": 0.00015, "epss_percentile": 0.0217}, "CVE-2022-30715": {"epss_score": 0.00055, "epss_percentile": 0.17403}, "CVE-2022-30716": {"epss_score": 0.00054, "epss_percentile": 0.1707}, "CVE-2022-30717": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2022-30719": {"epss_score": 0.00057, "epss_percentile": 0.18205}, "CVE-2022-30720": {"epss_score": 0.00057, "epss_percentile": 0.18205}, "CVE-2022-30721": {"epss_score": 0.00057, "epss_percentile": 0.18205}, "CVE-2022-30722": {"epss_score": 0.00059, "epss_percentile": 0.18631}, "CVE-2022-30723": {"epss_score": 0.00019, "epss_percentile": 0.04194}, "CVE-2022-30724": {"epss_score": 0.00019, "epss_percentile": 0.04194}, "CVE-2022-30725": {"epss_score": 0.00019, "epss_percentile": 0.04194}, "CVE-2022-30726": {"epss_score": 0.00015, "epss_percentile": 0.02186}, "CVE-2022-30727": {"epss_score": 0.00031, "epss_percentile": 0.08478}, "CVE-2022-30728": {"epss_score": 0.00015, "epss_percentile": 0.0217}, "CVE-2022-30729": {"epss_score": 0.0002, "epss_percentile": 0.04533}, "CVE-2022-30730": {"epss_score": 0.00054, "epss_percentile": 0.17249}, "CVE-2022-30731": {"epss_score": 0.00054, "epss_percentile": 0.17352}, "CVE-2022-30732": {"epss_score": 0.00214, "epss_percentile": 0.43998}, "CVE-2022-30733": {"epss_score": 0.00215, "epss_percentile": 0.44125}, "CVE-2022-30734": {"epss_score": 0.00215, "epss_percentile": 0.44125}, "CVE-2022-30735": {"epss_score": 0.00175, "epss_percentile": 0.39273}, "CVE-2022-30736": {"epss_score": 0.00184, "epss_percentile": 0.40449}, "CVE-2022-30737": {"epss_score": 0.00215, "epss_percentile": 0.44125}, "CVE-2022-30738": {"epss_score": 0.00291, "epss_percentile": 0.52175}, "CVE-2022-30739": {"epss_score": 0.0016, "epss_percentile": 0.37427}, "CVE-2022-30740": {"epss_score": 0.0006, "epss_percentile": 0.19051}, "CVE-2022-30741": {"epss_score": 0.00058, "epss_percentile": 0.18263}, "CVE-2022-30742": {"epss_score": 0.00058, "epss_percentile": 0.18263}, "CVE-2022-30743": {"epss_score": 0.00184, "epss_percentile": 0.40449}, "CVE-2022-30744": {"epss_score": 0.0006, "epss_percentile": 0.19143}, "CVE-2022-30745": {"epss_score": 0.00054, "epss_percentile": 0.17352}, "CVE-2022-30746": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2022-30747": {"epss_score": 0.00046, "epss_percentile": 0.14122}, "CVE-2022-30748": {"epss_score": 0.00057, "epss_percentile": 0.18131}, "CVE-2022-30749": {"epss_score": 0.00046, "epss_percentile": 0.14461}, "CVE-2022-30750": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-30751": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-30752": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-30753": {"epss_score": 0.00015, "epss_percentile": 0.02153}, "CVE-2022-30754": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2022-30755": {"epss_score": 0.00019, "epss_percentile": 0.04338}, "CVE-2022-30756": {"epss_score": 0.00014, "epss_percentile": 0.01839}, "CVE-2022-30757": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-30758": {"epss_score": 0.00019, "epss_percentile": 0.04273}, "CVE-2022-30759": {"epss_score": 0.001, "epss_percentile": 0.28442}, "CVE-2022-30760": {"epss_score": 0.00134, "epss_percentile": 0.33747}, "CVE-2022-30763": {"epss_score": 0.00465, "epss_percentile": 0.63759}, "CVE-2022-30765": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30767": {"epss_score": 0.0015, "epss_percentile": 0.36051}, "CVE-2022-30768": {"epss_score": 0.00071, "epss_percentile": 0.22}, "CVE-2022-30769": {"epss_score": 0.00173, "epss_percentile": 0.39084}, "CVE-2022-30770": {"epss_score": 0.00678, "epss_percentile": 0.71002}, "CVE-2022-30771": {"epss_score": 0.00051, "epss_percentile": 0.15989}, "CVE-2022-30772": {"epss_score": 0.00071, "epss_percentile": 0.22118}, "CVE-2022-30773": {"epss_score": 0.00093, "epss_percentile": 0.2675}, "CVE-2022-30774": {"epss_score": 0.00052, "epss_percentile": 0.16577}, "CVE-2022-30775": {"epss_score": 0.0022, "epss_percentile": 0.44599}, "CVE-2022-30776": {"epss_score": 0.45526, "epss_percentile": 0.9749}, "CVE-2022-30777": {"epss_score": 0.04147, "epss_percentile": 0.88316}, "CVE-2022-30780": {"epss_score": 0.78868, "epss_percentile": 0.99007}, "CVE-2022-30781": {"epss_score": 0.84335, "epss_percentile": 0.99285}, "CVE-2022-30782": {"epss_score": 0.00316, "epss_percentile": 0.54271}, "CVE-2022-30783": {"epss_score": 0.00023, "epss_percentile": 0.05591}, "CVE-2022-30784": {"epss_score": 0.00019, "epss_percentile": 0.04404}, "CVE-2022-30785": {"epss_score": 0.00025, "epss_percentile": 0.06218}, "CVE-2022-30786": {"epss_score": 0.00021, "epss_percentile": 0.04922}, "CVE-2022-30787": {"epss_score": 0.00023, "epss_percentile": 0.05591}, "CVE-2022-30788": {"epss_score": 0.00021, "epss_percentile": 0.04709}, "CVE-2022-30789": {"epss_score": 0.00021, "epss_percentile": 0.04922}, "CVE-2022-30790": {"epss_score": 0.0034, "epss_percentile": 0.56273}, "CVE-2022-30791": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-30792": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2022-30794": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30795": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30797": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30798": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30799": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30804": {"epss_score": 0.00409, "epss_percentile": 0.60765}, "CVE-2022-30808": {"epss_score": 0.01393, "epss_percentile": 0.79963}, "CVE-2022-30809": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30810": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30813": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30814": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30815": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30816": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30817": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-30818": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30819": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2022-30820": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2022-30821": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2022-30822": {"epss_score": 0.00423, "epss_percentile": 0.61613}, "CVE-2022-30823": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30825": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30826": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30827": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30828": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30829": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30830": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30831": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30832": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30833": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30834": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30835": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30836": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-30837": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-30838": {"epss_score": 0.00307, "epss_percentile": 0.53558}, "CVE-2022-30839": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2022-30842": {"epss_score": 0.00281, "epss_percentile": 0.51178}, "CVE-2022-30843": {"epss_score": 0.003, "epss_percentile": 0.52943}, "CVE-2022-30852": {"epss_score": 0.00189, "epss_percentile": 0.40937}, "CVE-2022-30858": {"epss_score": 0.00054, "epss_percentile": 0.17203}, "CVE-2022-30860": {"epss_score": 0.03416, "epss_percentile": 0.87092}, "CVE-2022-30861": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-30863": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-30874": {"epss_score": 0.00258, "epss_percentile": 0.49004}, "CVE-2022-30875": {"epss_score": 0.00267, "epss_percentile": 0.49989}, "CVE-2022-30877": {"epss_score": 0.01548, "epss_percentile": 0.80975}, "CVE-2022-30882": {"epss_score": 0.01131, "epss_percentile": 0.77865}, "CVE-2022-30885": {"epss_score": 0.0102, "epss_percentile": 0.76731}, "CVE-2022-30886": {"epss_score": 0.00683, "epss_percentile": 0.71093}, "CVE-2022-30887": {"epss_score": 0.10321, "epss_percentile": 0.92943}, "CVE-2022-30898": {"epss_score": 0.00105, "epss_percentile": 0.29278}, "CVE-2022-30899": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2022-30903": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-30904": {"epss_score": 0.00043, "epss_percentile": 0.13269}, "CVE-2022-30909": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30910": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30912": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30913": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30914": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30915": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30916": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30917": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30918": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30919": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30920": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30921": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30922": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30923": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30924": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30925": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30926": {"epss_score": 0.00409, "epss_percentile": 0.60718}, "CVE-2022-30927": {"epss_score": 0.00316, "epss_percentile": 0.54231}, "CVE-2022-30929": {"epss_score": 0.05346, "epss_percentile": 0.8977}, "CVE-2022-30930": {"epss_score": 0.00161, "epss_percentile": 0.37596}, "CVE-2022-30931": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2022-30935": {"epss_score": 0.01507, "epss_percentile": 0.8075}, "CVE-2022-30937": {"epss_score": 0.00532, "epss_percentile": 0.66682}, "CVE-2022-30938": {"epss_score": 0.01833, "epss_percentile": 0.82457}, "CVE-2022-30943": {"epss_score": 0.00151, "epss_percentile": 0.36338}, "CVE-2022-30944": {"epss_score": 0.00045, "epss_percentile": 0.13725}, "CVE-2022-30945": {"epss_score": 0.01684, "epss_percentile": 0.81741}, "CVE-2022-30946": {"epss_score": 0.0005, "epss_percentile": 0.15836}, "CVE-2022-30947": {"epss_score": 0.01568, "epss_percentile": 0.81078}, "CVE-2022-30948": {"epss_score": 0.02828, "epss_percentile": 0.85767}, "CVE-2022-30949": {"epss_score": 0.0083, "epss_percentile": 0.74024}, "CVE-2022-30950": {"epss_score": 0.01202, "epss_percentile": 0.7849}, "CVE-2022-30951": {"epss_score": 0.0091, "epss_percentile": 0.75321}, "CVE-2022-30952": {"epss_score": 0.00431, "epss_percentile": 0.62092}, "CVE-2022-30953": {"epss_score": 0.00045, "epss_percentile": 0.13823}, "CVE-2022-30954": {"epss_score": 0.0034, "epss_percentile": 0.56272}, "CVE-2022-30955": {"epss_score": 0.00806, "epss_percentile": 0.73652}, "CVE-2022-30956": {"epss_score": 0.14063, "epss_percentile": 0.94127}, "CVE-2022-30957": {"epss_score": 0.00455, "epss_percentile": 0.63282}, "CVE-2022-30958": {"epss_score": 0.00068, "epss_percentile": 0.2119}, "CVE-2022-30959": {"epss_score": 0.00806, "epss_percentile": 0.73652}, "CVE-2022-30960": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-30961": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-30962": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-30963": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-30964": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-30965": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-30966": {"epss_score": 0.03717, "epss_percentile": 0.87614}, "CVE-2022-30967": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-30968": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-30969": {"epss_score": 0.00112, "epss_percentile": 0.30411}, "CVE-2022-30970": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-30971": {"epss_score": 0.0163, "epss_percentile": 0.81445}, "CVE-2022-30972": {"epss_score": 0.00074, "epss_percentile": 0.22717}, "CVE-2022-30973": {"epss_score": 0.00213, "epss_percentile": 0.43903}, "CVE-2022-30974": {"epss_score": 0.00043, "epss_percentile": 0.13351}, "CVE-2022-30975": {"epss_score": 0.00094, "epss_percentile": 0.26958}, "CVE-2022-30976": {"epss_score": 0.00239, "epss_percentile": 0.46887}, "CVE-2022-30981": {"epss_score": 0.00708, "epss_percentile": 0.7167}, "CVE-2022-30982": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-30984": {"epss_score": 0.00046, "epss_percentile": 0.14438}, "CVE-2022-30990": {"epss_score": 0.00209, "epss_percentile": 0.43312}, "CVE-2022-30991": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-30992": {"epss_score": 0.00197, "epss_percentile": 0.41856}, "CVE-2022-30993": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2022-30994": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2022-30995": {"epss_score": 0.53792, "epss_percentile": 0.97897}, "CVE-2022-30997": {"epss_score": 0.00697, "epss_percentile": 0.71407}, "CVE-2022-30998": {"epss_score": 0.00404, "epss_percentile": 0.60428}, "CVE-2022-30999": {"epss_score": 0.00487, "epss_percentile": 0.648}, "CVE-2022-31000": {"epss_score": 0.00169, "epss_percentile": 0.38599}, "CVE-2022-31001": {"epss_score": 0.00207, "epss_percentile": 0.43132}, "CVE-2022-31002": {"epss_score": 0.00234, "epss_percentile": 0.46196}, "CVE-2022-31003": {"epss_score": 0.09066, "epss_percentile": 0.92386}, "CVE-2022-31004": {"epss_score": 0.00148, "epss_percentile": 0.35817}, "CVE-2022-31005": {"epss_score": 0.00339, "epss_percentile": 0.56202}, "CVE-2022-31006": {"epss_score": 0.00717, "epss_percentile": 0.71891}, "CVE-2022-31007": {"epss_score": 0.24593, "epss_percentile": 0.95937}, "CVE-2022-31008": {"epss_score": 0.00168, "epss_percentile": 0.38504}, "CVE-2022-31009": {"epss_score": 0.00262, "epss_percentile": 0.49385}, "CVE-2022-31011": {"epss_score": 0.00072, "epss_percentile": 0.2239}, "CVE-2022-31012": {"epss_score": 0.00063, "epss_percentile": 0.19961}, "CVE-2022-31013": {"epss_score": 0.00495, "epss_percentile": 0.65134}, "CVE-2022-31014": {"epss_score": 0.00834, "epss_percentile": 0.74097}, "CVE-2022-31015": {"epss_score": 0.00148, "epss_percentile": 0.35902}, "CVE-2022-31016": {"epss_score": 0.00371, "epss_percentile": 0.58386}, "CVE-2022-31017": {"epss_score": 0.00176, "epss_percentile": 0.39435}, "CVE-2022-31018": {"epss_score": 0.00506, "epss_percentile": 0.65614}, "CVE-2022-31019": {"epss_score": 0.00111, "epss_percentile": 0.3037}, "CVE-2022-31020": {"epss_score": 0.02636, "epss_percentile": 0.85292}, "CVE-2022-31021": {"epss_score": 0.00361, "epss_percentile": 0.5772}, "CVE-2022-31022": {"epss_score": 0.00141, "epss_percentile": 0.34805}, "CVE-2022-31023": {"epss_score": 0.0043, "epss_percentile": 0.62023}, "CVE-2022-31024": {"epss_score": 0.00147, "epss_percentile": 0.35745}, "CVE-2022-31025": {"epss_score": 0.00261, "epss_percentile": 0.49244}, "CVE-2022-31026": {"epss_score": 0.00297, "epss_percentile": 0.52758}, "CVE-2022-31027": {"epss_score": 0.00203, "epss_percentile": 0.42514}, "CVE-2022-31028": {"epss_score": 0.01372, "epss_percentile": 0.79814}, "CVE-2022-31029": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-31030": {"epss_score": 0.00158, "epss_percentile": 0.37199}, "CVE-2022-31031": {"epss_score": 0.00443, "epss_percentile": 0.62767}, "CVE-2022-31032": {"epss_score": 0.00348, "epss_percentile": 0.56827}, "CVE-2022-31033": {"epss_score": 0.00332, "epss_percentile": 0.55588}, "CVE-2022-31034": {"epss_score": 0.00418, "epss_percentile": 0.61342}, "CVE-2022-31035": {"epss_score": 0.00774, "epss_percentile": 0.73067}, "CVE-2022-31036": {"epss_score": 0.00261, "epss_percentile": 0.49307}, "CVE-2022-31037": {"epss_score": 0.00269, "epss_percentile": 0.50183}, "CVE-2022-31038": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2022-31039": {"epss_score": 0.00178, "epss_percentile": 0.39681}, "CVE-2022-31040": {"epss_score": 0.00275, "epss_percentile": 0.50638}, "CVE-2022-31041": {"epss_score": 0.00193, "epss_percentile": 0.41455}, "CVE-2022-31042": {"epss_score": 0.00691, "epss_percentile": 0.71271}, "CVE-2022-31043": {"epss_score": 0.01554, "epss_percentile": 0.81004}, "CVE-2022-31044": {"epss_score": 0.00159, "epss_percentile": 0.37339}, "CVE-2022-31045": {"epss_score": 0.00553, "epss_percentile": 0.67409}, "CVE-2022-31046": {"epss_score": 0.00148, "epss_percentile": 0.35931}, "CVE-2022-31047": {"epss_score": 0.00391, "epss_percentile": 0.59622}, "CVE-2022-31048": {"epss_score": 0.0063, "epss_percentile": 0.69704}, "CVE-2022-31049": {"epss_score": 0.0063, "epss_percentile": 0.69704}, "CVE-2022-31050": {"epss_score": 0.00439, "epss_percentile": 0.62601}, "CVE-2022-31051": {"epss_score": 0.00756, "epss_percentile": 0.72741}, "CVE-2022-31052": {"epss_score": 0.00742, "epss_percentile": 0.72456}, "CVE-2022-31053": {"epss_score": 0.0023, "epss_percentile": 0.45677}, "CVE-2022-31054": {"epss_score": 0.00563, "epss_percentile": 0.67714}, "CVE-2022-31055": {"epss_score": 0.0021, "epss_percentile": 0.43589}, "CVE-2022-31056": {"epss_score": 0.03601, "epss_percentile": 0.8741}, "CVE-2022-31057": {"epss_score": 0.00409, "epss_percentile": 0.60736}, "CVE-2022-31058": {"epss_score": 0.01344, "epss_percentile": 0.79608}, "CVE-2022-31059": {"epss_score": 0.00334, "epss_percentile": 0.55707}, "CVE-2022-31060": {"epss_score": 0.0037, "epss_percentile": 0.58315}, "CVE-2022-31061": {"epss_score": 0.51772, "epss_percentile": 0.97797}, "CVE-2022-31062": {"epss_score": 0.22698, "epss_percentile": 0.9567}, "CVE-2022-31063": {"epss_score": 0.00506, "epss_percentile": 0.65618}, "CVE-2022-31064": {"epss_score": 0.00779, "epss_percentile": 0.73151}, "CVE-2022-31065": {"epss_score": 0.00328, "epss_percentile": 0.55155}, "CVE-2022-31066": {"epss_score": 0.00167, "epss_percentile": 0.38315}, "CVE-2022-31068": {"epss_score": 0.004, "epss_percentile": 0.6015}, "CVE-2022-31069": {"epss_score": 0.00218, "epss_percentile": 0.4437}, "CVE-2022-31070": {"epss_score": 0.00218, "epss_percentile": 0.4437}, "CVE-2022-31071": {"epss_score": 0.00036, "epss_percentile": 0.10497}, "CVE-2022-31072": {"epss_score": 0.00023, "epss_percentile": 0.05423}, "CVE-2022-31073": {"epss_score": 0.00563, "epss_percentile": 0.67714}, "CVE-2022-31074": {"epss_score": 0.00363, "epss_percentile": 0.57902}, "CVE-2022-31075": {"epss_score": 0.00577, "epss_percentile": 0.68155}, "CVE-2022-31076": {"epss_score": 0.00088, "epss_percentile": 0.25687}, "CVE-2022-31077": {"epss_score": 0.00339, "epss_percentile": 0.56199}, "CVE-2022-31078": {"epss_score": 0.00261, "epss_percentile": 0.49275}, "CVE-2022-31079": {"epss_score": 0.00261, "epss_percentile": 0.49275}, "CVE-2022-31080": {"epss_score": 0.00261, "epss_percentile": 0.49275}, "CVE-2022-31081": {"epss_score": 0.00621, "epss_percentile": 0.69493}, "CVE-2022-31082": {"epss_score": 0.00282, "epss_percentile": 0.51219}, "CVE-2022-31083": {"epss_score": 0.00175, "epss_percentile": 0.39263}, "CVE-2022-31084": {"epss_score": 0.01567, "epss_percentile": 0.81075}, "CVE-2022-31085": {"epss_score": 0.00093, "epss_percentile": 0.26747}, "CVE-2022-31086": {"epss_score": 0.01329, "epss_percentile": 0.79503}, "CVE-2022-31087": {"epss_score": 0.00191, "epss_percentile": 0.41176}, "CVE-2022-31088": {"epss_score": 0.00552, "epss_percentile": 0.67403}, "CVE-2022-31089": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2022-31090": {"epss_score": 0.03005, "epss_percentile": 0.86183}, "CVE-2022-31091": {"epss_score": 0.0034, "epss_percentile": 0.56227}, "CVE-2022-31092": {"epss_score": 0.00026, "epss_percentile": 0.06591}, "CVE-2022-31093": {"epss_score": 0.00864, "epss_percentile": 0.74609}, "CVE-2022-31094": {"epss_score": 0.00361, "epss_percentile": 0.57701}, "CVE-2022-31095": {"epss_score": 0.00207, "epss_percentile": 0.43151}, "CVE-2022-31096": {"epss_score": 0.00273, "epss_percentile": 0.50424}, "CVE-2022-31097": {"epss_score": 0.48063, "epss_percentile": 0.97616}, "CVE-2022-31098": {"epss_score": 0.00399, "epss_percentile": 0.6012}, "CVE-2022-31099": {"epss_score": 0.00521, "epss_percentile": 0.6624}, "CVE-2022-31100": {"epss_score": 0.0042, "epss_percentile": 0.61427}, "CVE-2022-31101": {"epss_score": 0.51662, "epss_percentile": 0.97792}, "CVE-2022-31102": {"epss_score": 0.00214, "epss_percentile": 0.43949}, "CVE-2022-31103": {"epss_score": 0.00431, "epss_percentile": 0.62089}, "CVE-2022-31104": {"epss_score": 0.00915, "epss_percentile": 0.75407}, "CVE-2022-31105": {"epss_score": 0.00254, "epss_percentile": 0.48516}, "CVE-2022-31106": {"epss_score": 0.00363, "epss_percentile": 0.57893}, "CVE-2022-31107": {"epss_score": 0.00538, "epss_percentile": 0.6695}, "CVE-2022-31108": {"epss_score": 0.00235, "epss_percentile": 0.46344}, "CVE-2022-31109": {"epss_score": 0.00494, "epss_percentile": 0.65067}, "CVE-2022-31110": {"epss_score": 0.00557, "epss_percentile": 0.67554}, "CVE-2022-31111": {"epss_score": 0.00582, "epss_percentile": 0.68299}, "CVE-2022-31112": {"epss_score": 0.00595, "epss_percentile": 0.68695}, "CVE-2022-31113": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-31115": {"epss_score": 0.00445, "epss_percentile": 0.62884}, "CVE-2022-31116": {"epss_score": 0.00224, "epss_percentile": 0.45043}, "CVE-2022-31117": {"epss_score": 0.00173, "epss_percentile": 0.39105}, "CVE-2022-31118": {"epss_score": 0.0016, "epss_percentile": 0.37454}, "CVE-2022-31119": {"epss_score": 0.00267, "epss_percentile": 0.49966}, "CVE-2022-31120": {"epss_score": 0.00387, "epss_percentile": 0.5933}, "CVE-2022-31121": {"epss_score": 0.00888, "epss_percentile": 0.75009}, "CVE-2022-31122": {"epss_score": 0.00373, "epss_percentile": 0.58526}, "CVE-2022-31123": {"epss_score": 0.00011, "epss_percentile": 0.0099}, "CVE-2022-31124": {"epss_score": 0.00422, "epss_percentile": 0.61555}, "CVE-2022-31125": {"epss_score": 0.12856, "epss_percentile": 0.93803}, "CVE-2022-31126": {"epss_score": 0.91464, "epss_percentile": 0.99646}, "CVE-2022-31127": {"epss_score": 0.00591, "epss_percentile": 0.68585}, "CVE-2022-31128": {"epss_score": 0.00157, "epss_percentile": 0.37024}, "CVE-2022-31129": {"epss_score": 0.04394, "epss_percentile": 0.88637}, "CVE-2022-31130": {"epss_score": 0.00243, "epss_percentile": 0.47506}, "CVE-2022-31131": {"epss_score": 0.00153, "epss_percentile": 0.36605}, "CVE-2022-31132": {"epss_score": 0.00335, "epss_percentile": 0.55867}, "CVE-2022-31133": {"epss_score": 0.00302, "epss_percentile": 0.53129}, "CVE-2022-31134": {"epss_score": 0.00401, "epss_percentile": 0.60255}, "CVE-2022-31135": {"epss_score": 0.00241, "epss_percentile": 0.47326}, "CVE-2022-31136": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-31137": {"epss_score": 0.93971, "epss_percentile": 0.99877}, "CVE-2022-31138": {"epss_score": 0.06089, "epss_percentile": 0.90472}, "CVE-2022-31139": {"epss_score": 0.00341, "epss_percentile": 0.56329}, "CVE-2022-31140": {"epss_score": 0.00412, "epss_percentile": 0.60906}, "CVE-2022-31142": {"epss_score": 0.00742, "epss_percentile": 0.72454}, "CVE-2022-31143": {"epss_score": 0.0022, "epss_percentile": 0.44612}, "CVE-2022-31144": {"epss_score": 0.24411, "epss_percentile": 0.95918}, "CVE-2022-31145": {"epss_score": 0.00375, "epss_percentile": 0.58607}, "CVE-2022-31146": {"epss_score": 0.00441, "epss_percentile": 0.62669}, "CVE-2022-31147": {"epss_score": 0.00438, "epss_percentile": 0.62566}, "CVE-2022-31148": {"epss_score": 0.00687, "epss_percentile": 0.71189}, "CVE-2022-31149": {"epss_score": 0.00436, "epss_percentile": 0.62473}, "CVE-2022-31150": {"epss_score": 0.00619, "epss_percentile": 0.69432}, "CVE-2022-31151": {"epss_score": 0.00107, "epss_percentile": 0.29579}, "CVE-2022-31152": {"epss_score": 0.00693, "epss_percentile": 0.71336}, "CVE-2022-31153": {"epss_score": 0.01109, "epss_percentile": 0.77646}, "CVE-2022-31154": {"epss_score": 0.0015, "epss_percentile": 0.36176}, "CVE-2022-31155": {"epss_score": 0.00159, "epss_percentile": 0.37359}, "CVE-2022-31156": {"epss_score": 0.00193, "epss_percentile": 0.41394}, "CVE-2022-31157": {"epss_score": 0.00114, "epss_percentile": 0.30781}, "CVE-2022-31158": {"epss_score": 0.003, "epss_percentile": 0.52989}, "CVE-2022-31159": {"epss_score": 0.0006, "epss_percentile": 0.191}, "CVE-2022-31160": {"epss_score": 0.10939, "epss_percentile": 0.93166}, "CVE-2022-31161": {"epss_score": 0.84279, "epss_percentile": 0.99281}, "CVE-2022-31162": {"epss_score": 0.00371, "epss_percentile": 0.58388}, "CVE-2022-31163": {"epss_score": 0.06569, "epss_percentile": 0.90852}, "CVE-2022-31164": {"epss_score": 0.00194, "epss_percentile": 0.41523}, "CVE-2022-31166": {"epss_score": 0.01997, "epss_percentile": 0.83207}, "CVE-2022-31167": {"epss_score": 0.00492, "epss_percentile": 0.65017}, "CVE-2022-31168": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2022-31169": {"epss_score": 0.00291, "epss_percentile": 0.52186}, "CVE-2022-31170": {"epss_score": 0.00294, "epss_percentile": 0.52371}, "CVE-2022-31172": {"epss_score": 0.00108, "epss_percentile": 0.29824}, "CVE-2022-31173": {"epss_score": 0.00583, "epss_percentile": 0.6835}, "CVE-2022-31175": {"epss_score": 0.00764, "epss_percentile": 0.72907}, "CVE-2022-31176": {"epss_score": 0.00477, "epss_percentile": 0.64354}, "CVE-2022-31177": {"epss_score": 0.00361, "epss_percentile": 0.57736}, "CVE-2022-31178": {"epss_score": 0.00151, "epss_percentile": 0.36359}, "CVE-2022-31179": {"epss_score": 0.00593, "epss_percentile": 0.68628}, "CVE-2022-31180": {"epss_score": 0.01025, "epss_percentile": 0.76791}, "CVE-2022-31181": {"epss_score": 0.72653, "epss_percentile": 0.98721}, "CVE-2022-31182": {"epss_score": 0.0036, "epss_percentile": 0.57624}, "CVE-2022-31183": {"epss_score": 0.002, "epss_percentile": 0.42244}, "CVE-2022-31184": {"epss_score": 0.00336, "epss_percentile": 0.55932}, "CVE-2022-31185": {"epss_score": 0.0022, "epss_percentile": 0.44612}, "CVE-2022-31186": {"epss_score": 0.00056, "epss_percentile": 0.17721}, "CVE-2022-31187": {"epss_score": 0.0026, "epss_percentile": 0.49103}, "CVE-2022-31188": {"epss_score": 0.35725, "epss_percentile": 0.96928}, "CVE-2022-31189": {"epss_score": 0.0022, "epss_percentile": 0.44612}, "CVE-2022-31190": {"epss_score": 0.0025, "epss_percentile": 0.48092}, "CVE-2022-31191": {"epss_score": 0.0042, "epss_percentile": 0.61402}, "CVE-2022-31192": {"epss_score": 0.003, "epss_percentile": 0.52951}, "CVE-2022-31193": {"epss_score": 0.00249, "epss_percentile": 0.48085}, "CVE-2022-31194": {"epss_score": 0.00787, "epss_percentile": 0.73315}, "CVE-2022-31195": {"epss_score": 0.00787, "epss_percentile": 0.73317}, "CVE-2022-31196": {"epss_score": 0.00291, "epss_percentile": 0.52156}, "CVE-2022-31197": {"epss_score": 0.02723, "epss_percentile": 0.85522}, "CVE-2022-31198": {"epss_score": 0.00253, "epss_percentile": 0.48445}, "CVE-2022-31199": {"epss_score": 0.08052, "epss_percentile": 0.91855}, "CVE-2022-31200": {"epss_score": 0.00095, "epss_percentile": 0.27103}, "CVE-2022-31201": {"epss_score": 0.00264, "epss_percentile": 0.49734}, "CVE-2022-31202": {"epss_score": 0.00581, "epss_percentile": 0.68279}, "CVE-2022-31204": {"epss_score": 0.00172, "epss_percentile": 0.38933}, "CVE-2022-31205": {"epss_score": 0.001, "epss_percentile": 0.28517}, "CVE-2022-31206": {"epss_score": 0.00128, "epss_percentile": 0.33043}, "CVE-2022-31207": {"epss_score": 0.00096, "epss_percentile": 0.27288}, "CVE-2022-31208": {"epss_score": 0.00606, "epss_percentile": 0.69025}, "CVE-2022-31209": {"epss_score": 0.00431, "epss_percentile": 0.62054}, "CVE-2022-31210": {"epss_score": 0.00428, "epss_percentile": 0.61923}, "CVE-2022-31211": {"epss_score": 0.00395, "epss_percentile": 0.59832}, "CVE-2022-31212": {"epss_score": 0.00218, "epss_percentile": 0.4443}, "CVE-2022-31213": {"epss_score": 0.00219, "epss_percentile": 0.44498}, "CVE-2022-31214": {"epss_score": 0.00159, "epss_percentile": 0.37341}, "CVE-2022-31215": {"epss_score": 0.00328, "epss_percentile": 0.55257}, "CVE-2022-31216": {"epss_score": 0.00137, "epss_percentile": 0.3426}, "CVE-2022-31217": {"epss_score": 0.00058, "epss_percentile": 0.18565}, "CVE-2022-31218": {"epss_score": 0.00058, "epss_percentile": 0.18565}, "CVE-2022-31219": {"epss_score": 0.00041, "epss_percentile": 0.12245}, "CVE-2022-31220": {"epss_score": 0.00051, "epss_percentile": 0.1631}, "CVE-2022-31221": {"epss_score": 0.00046, "epss_percentile": 0.14438}, "CVE-2022-31222": {"epss_score": 0.00043, "epss_percentile": 0.13239}, "CVE-2022-31223": {"epss_score": 0.00046, "epss_percentile": 0.14438}, "CVE-2022-31224": {"epss_score": 0.00075, "epss_percentile": 0.22972}, "CVE-2022-31225": {"epss_score": 0.00051, "epss_percentile": 0.1631}, "CVE-2022-31226": {"epss_score": 0.0006, "epss_percentile": 0.18956}, "CVE-2022-31228": {"epss_score": 0.01625, "epss_percentile": 0.81418}, "CVE-2022-31229": {"epss_score": 0.00286, "epss_percentile": 0.51778}, "CVE-2022-31230": {"epss_score": 0.002, "epss_percentile": 0.42225}, "CVE-2022-31232": {"epss_score": 0.01188, "epss_percentile": 0.78367}, "CVE-2022-31233": {"epss_score": 0.0011, "epss_percentile": 0.30177}, "CVE-2022-31234": {"epss_score": 0.01441, "epss_percentile": 0.80301}, "CVE-2022-31237": {"epss_score": 0.00041, "epss_percentile": 0.1242}, "CVE-2022-31238": {"epss_score": 0.00064, "epss_percentile": 0.20186}, "CVE-2022-31239": {"epss_score": 0.00057, "epss_percentile": 0.18042}, "CVE-2022-31243": {"epss_score": 0.00052, "epss_percentile": 0.16577}, "CVE-2022-31244": {"epss_score": 0.00061, "epss_percentile": 0.19318}, "CVE-2022-31245": {"epss_score": 0.22742, "epss_percentile": 0.95676}, "CVE-2022-31246": {"epss_score": 0.00339, "epss_percentile": 0.56178}, "CVE-2022-31247": {"epss_score": 0.00345, "epss_percentile": 0.5658}, "CVE-2022-31248": {"epss_score": 0.00188, "epss_percentile": 0.40882}, "CVE-2022-31249": {"epss_score": 0.00733, "epss_percentile": 0.72206}, "CVE-2022-31250": {"epss_score": 0.00043, "epss_percentile": 0.13085}, "CVE-2022-31251": {"epss_score": 0.00032, "epss_percentile": 0.08829}, "CVE-2022-31252": {"epss_score": 0.00081, "epss_percentile": 0.24322}, "CVE-2022-31253": {"epss_score": 0.00052, "epss_percentile": 0.16573}, "CVE-2022-31254": {"epss_score": 0.00034, "epss_percentile": 0.09561}, "CVE-2022-31255": {"epss_score": 0.00248, "epss_percentile": 0.47998}, "CVE-2022-31256": {"epss_score": 0.00128, "epss_percentile": 0.33027}, "CVE-2022-31257": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2022-31258": {"epss_score": 0.00044, "epss_percentile": 0.13419}, "CVE-2022-31259": {"epss_score": 0.00151, "epss_percentile": 0.36257}, "CVE-2022-31260": {"epss_score": 0.24772, "epss_percentile": 0.95953}, "CVE-2022-31261": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2022-31262": {"epss_score": 0.00983, "epss_percentile": 0.76303}, "CVE-2022-31263": {"epss_score": 0.00217, "epss_percentile": 0.44254}, "CVE-2022-31264": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2022-31265": {"epss_score": 0.01214, "epss_percentile": 0.78576}, "CVE-2022-31266": {"epss_score": 0.00251, "epss_percentile": 0.48284}, "CVE-2022-31267": {"epss_score": 0.00665, "epss_percentile": 0.70655}, "CVE-2022-31268": {"epss_score": 0.90039, "epss_percentile": 0.99558}, "CVE-2022-31269": {"epss_score": 0.6816, "epss_percentile": 0.98533}, "CVE-2022-31273": {"epss_score": 0.00305, "epss_percentile": 0.53383}, "CVE-2022-31277": {"epss_score": 0.00103, "epss_percentile": 0.28921}, "CVE-2022-31282": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2022-31285": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2022-31287": {"epss_score": 0.00165, "epss_percentile": 0.381}, "CVE-2022-31290": {"epss_score": 0.00434, "epss_percentile": 0.62296}, "CVE-2022-31291": {"epss_score": 0.00081, "epss_percentile": 0.2431}, "CVE-2022-31294": {"epss_score": 0.01479, "epss_percentile": 0.80558}, "CVE-2022-31295": {"epss_score": 0.00471, "epss_percentile": 0.64002}, "CVE-2022-31296": {"epss_score": 0.06308, "epss_percentile": 0.90661}, "CVE-2022-31298": {"epss_score": 0.07516, "epss_percentile": 0.91513}, "CVE-2022-31299": {"epss_score": 0.37475, "epss_percentile": 0.9705}, "CVE-2022-31300": {"epss_score": 0.07516, "epss_percentile": 0.91513}, "CVE-2022-31301": {"epss_score": 0.00779, "epss_percentile": 0.73156}, "CVE-2022-31302": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-31303": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-31306": {"epss_score": 0.00136, "epss_percentile": 0.34176}, "CVE-2022-31307": {"epss_score": 0.00263, "epss_percentile": 0.49509}, "CVE-2022-31308": {"epss_score": 0.00667, "epss_percentile": 0.70708}, "CVE-2022-31309": {"epss_score": 0.00398, "epss_percentile": 0.60085}, "CVE-2022-31311": {"epss_score": 0.02725, "epss_percentile": 0.85525}, "CVE-2022-31313": {"epss_score": 0.0065, "epss_percentile": 0.70251}, "CVE-2022-31321": {"epss_score": 0.00403, "epss_percentile": 0.60385}, "CVE-2022-31322": {"epss_score": 0.00109, "epss_percentile": 0.29924}, "CVE-2022-31324": {"epss_score": 0.0029, "epss_percentile": 0.52107}, "CVE-2022-31325": {"epss_score": 0.00359, "epss_percentile": 0.57619}, "CVE-2022-31327": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31328": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31329": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31335": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31336": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31337": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31338": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31339": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-31340": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31342": {"epss_score": 0.00329, "epss_percentile": 0.55303}, "CVE-2022-31343": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31344": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31345": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31346": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31347": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31348": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31350": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31351": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31352": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31353": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31354": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31355": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31356": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31357": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31358": {"epss_score": 0.00874, "epss_percentile": 0.74754}, "CVE-2022-31361": {"epss_score": 0.00278, "epss_percentile": 0.50916}, "CVE-2022-31362": {"epss_score": 0.00613, "epss_percentile": 0.69248}, "CVE-2022-31363": {"epss_score": 0.00039, "epss_percentile": 0.11611}, "CVE-2022-31364": {"epss_score": 0.00039, "epss_percentile": 0.11611}, "CVE-2022-31366": {"epss_score": 0.01363, "epss_percentile": 0.79765}, "CVE-2022-31367": {"epss_score": 0.0063, "epss_percentile": 0.69707}, "CVE-2022-31372": {"epss_score": 0.00486, "epss_percentile": 0.64746}, "CVE-2022-31373": {"epss_score": 0.0219, "epss_percentile": 0.83934}, "CVE-2022-31374": {"epss_score": 0.01447, "epss_percentile": 0.8033}, "CVE-2022-31382": {"epss_score": 0.00713, "epss_percentile": 0.71793}, "CVE-2022-31383": {"epss_score": 0.00713, "epss_percentile": 0.71793}, "CVE-2022-31384": {"epss_score": 0.00713, "epss_percentile": 0.71793}, "CVE-2022-31386": {"epss_score": 0.00223, "epss_percentile": 0.44942}, "CVE-2022-31390": {"epss_score": 0.00292, "epss_percentile": 0.52228}, "CVE-2022-31393": {"epss_score": 0.00292, "epss_percentile": 0.52228}, "CVE-2022-31394": {"epss_score": 0.003, "epss_percentile": 0.52938}, "CVE-2022-31395": {"epss_score": 0.00729, "epss_percentile": 0.72118}, "CVE-2022-31398": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2022-31400": {"epss_score": 0.00321, "epss_percentile": 0.54732}, "CVE-2022-31402": {"epss_score": 0.16683, "epss_percentile": 0.94714}, "CVE-2022-31403": {"epss_score": 0.03153, "epss_percentile": 0.86509}, "CVE-2022-31405": {"epss_score": 0.00058, "epss_percentile": 0.18517}, "CVE-2022-31414": {"epss_score": 0.0071, "epss_percentile": 0.71724}, "CVE-2022-31415": {"epss_score": 0.00241, "epss_percentile": 0.47252}, "CVE-2022-31446": {"epss_score": 0.17698, "epss_percentile": 0.94892}, "CVE-2022-31447": {"epss_score": 0.00433, "epss_percentile": 0.62177}, "CVE-2022-31454": {"epss_score": 0.00076, "epss_percentile": 0.23229}, "CVE-2022-31455": {"epss_score": 0.00076, "epss_percentile": 0.23229}, "CVE-2022-31456": {"epss_score": 0.00083, "epss_percentile": 0.24721}, "CVE-2022-31457": {"epss_score": 0.00239, "epss_percentile": 0.46915}, "CVE-2022-31458": {"epss_score": 0.00072, "epss_percentile": 0.22399}, "CVE-2022-31459": {"epss_score": 0.0015, "epss_percentile": 0.36144}, "CVE-2022-31460": {"epss_score": 0.0617, "epss_percentile": 0.90529}, "CVE-2022-31461": {"epss_score": 0.00162, "epss_percentile": 0.3763}, "CVE-2022-31462": {"epss_score": 0.00172, "epss_percentile": 0.39014}, "CVE-2022-31463": {"epss_score": 0.00244, "epss_percentile": 0.47577}, "CVE-2022-31464": {"epss_score": 0.0003, "epss_percentile": 0.08178}, "CVE-2022-31465": {"epss_score": 0.00044, "epss_percentile": 0.1347}, "CVE-2022-31466": {"epss_score": 0.00036, "epss_percentile": 0.10329}, "CVE-2022-31467": {"epss_score": 0.0007, "epss_percentile": 0.21683}, "CVE-2022-31468": {"epss_score": 0.00206, "epss_percentile": 0.43032}, "CVE-2022-31469": {"epss_score": 0.00832, "epss_percentile": 0.74068}, "CVE-2022-31470": {"epss_score": 0.25054, "epss_percentile": 0.95982}, "CVE-2022-31471": {"epss_score": 0.01518, "epss_percentile": 0.80814}, "CVE-2022-31472": {"epss_score": 0.00151, "epss_percentile": 0.36338}, "CVE-2022-31473": {"epss_score": 0.00985, "epss_percentile": 0.76325}, "CVE-2022-31474": {"epss_score": 0.92613, "epss_percentile": 0.9973}, "CVE-2022-31475": {"epss_score": 0.00461, "epss_percentile": 0.63552}, "CVE-2022-31476": {"epss_score": 0.00082, "epss_percentile": 0.24548}, "CVE-2022-31477": {"epss_score": 0.00074, "epss_percentile": 0.2286}, "CVE-2022-31478": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2022-31479": {"epss_score": 0.09071, "epss_percentile": 0.92386}, "CVE-2022-31480": {"epss_score": 0.00368, "epss_percentile": 0.58168}, "CVE-2022-31481": {"epss_score": 0.0124, "epss_percentile": 0.78812}, "CVE-2022-31482": {"epss_score": 0.00513, "epss_percentile": 0.65876}, "CVE-2022-31483": {"epss_score": 0.00622, "epss_percentile": 0.69497}, "CVE-2022-31484": {"epss_score": 0.00449, "epss_percentile": 0.63058}, "CVE-2022-31485": {"epss_score": 0.00145, "epss_percentile": 0.35523}, "CVE-2022-31486": {"epss_score": 0.00978, "epss_percentile": 0.76253}, "CVE-2022-31487": {"epss_score": 0.00325, "epss_percentile": 0.55029}, "CVE-2022-31488": {"epss_score": 0.00325, "epss_percentile": 0.55029}, "CVE-2022-31489": {"epss_score": 0.00325, "epss_percentile": 0.55029}, "CVE-2022-31491": {"epss_score": 0.00077, "epss_percentile": 0.23357}, "CVE-2022-31492": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2022-31493": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2022-31494": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2022-31495": {"epss_score": 0.00301, "epss_percentile": 0.53063}, "CVE-2022-31496": {"epss_score": 0.00428, "epss_percentile": 0.61924}, "CVE-2022-31497": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2022-31498": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2022-31499": {"epss_score": 0.938, "epss_percentile": 0.99849}, "CVE-2022-31500": {"epss_score": 0.00077, "epss_percentile": 0.23547}, "CVE-2022-31501": {"epss_score": 0.00483, "epss_percentile": 0.64623}, "CVE-2022-31502": {"epss_score": 0.00483, "epss_percentile": 0.64623}, "CVE-2022-31503": {"epss_score": 0.00582, "epss_percentile": 0.68291}, "CVE-2022-31504": {"epss_score": 0.0045, "epss_percentile": 0.63089}, "CVE-2022-31505": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31506": {"epss_score": 0.0045, "epss_percentile": 0.63089}, "CVE-2022-31507": {"epss_score": 0.0059, "epss_percentile": 0.68547}, "CVE-2022-31508": {"epss_score": 0.0045, "epss_percentile": 0.63089}, "CVE-2022-31509": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31510": {"epss_score": 0.0045, "epss_percentile": 0.63089}, "CVE-2022-31511": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31512": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31513": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31514": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31515": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31516": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31517": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31518": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31519": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31520": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31521": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31522": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31523": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31524": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31525": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31526": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31527": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31528": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31529": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31530": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31531": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31532": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31533": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31534": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31535": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31536": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31537": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31538": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31539": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31540": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31541": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31542": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31543": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31544": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31545": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31546": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31547": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31548": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31549": {"epss_score": 0.00483, "epss_percentile": 0.64623}, "CVE-2022-31550": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31551": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31552": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31553": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31554": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31555": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31556": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31557": {"epss_score": 0.00465, "epss_percentile": 0.6375}, "CVE-2022-31558": {"epss_score": 0.00465, "epss_percentile": 0.6375}, "CVE-2022-31559": {"epss_score": 0.00465, "epss_percentile": 0.6375}, "CVE-2022-31560": {"epss_score": 0.00465, "epss_percentile": 0.6375}, "CVE-2022-31561": {"epss_score": 0.00465, "epss_percentile": 0.6375}, "CVE-2022-31562": {"epss_score": 0.00465, "epss_percentile": 0.6375}, "CVE-2022-31563": {"epss_score": 0.00465, "epss_percentile": 0.6375}, "CVE-2022-31564": {"epss_score": 0.00484, "epss_percentile": 0.64636}, "CVE-2022-31565": {"epss_score": 0.00465, "epss_percentile": 0.6375}, "CVE-2022-31566": {"epss_score": 0.00419, "epss_percentile": 0.61376}, "CVE-2022-31567": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31568": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31570": {"epss_score": 0.00587, "epss_percentile": 0.68472}, "CVE-2022-31571": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31572": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31573": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31574": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31575": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31576": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31577": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31578": {"epss_score": 0.0039, "epss_percentile": 0.59525}, "CVE-2022-31579": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31580": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31581": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31582": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31583": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31584": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31585": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31586": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31587": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31588": {"epss_score": 0.00432, "epss_percentile": 0.62157}, "CVE-2022-31589": {"epss_score": 0.00187, "epss_percentile": 0.40744}, "CVE-2022-31590": {"epss_score": 0.00039, "epss_percentile": 0.11448}, "CVE-2022-31591": {"epss_score": 0.00052, "epss_percentile": 0.16478}, "CVE-2022-31592": {"epss_score": 0.00148, "epss_percentile": 0.3593}, "CVE-2022-31593": {"epss_score": 0.00743, "epss_percentile": 0.72471}, "CVE-2022-31594": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2022-31595": {"epss_score": 0.00404, "epss_percentile": 0.60447}, "CVE-2022-31596": {"epss_score": 0.00288, "epss_percentile": 0.51922}, "CVE-2022-31597": {"epss_score": 0.00144, "epss_percentile": 0.35296}, "CVE-2022-31598": {"epss_score": 0.00109, "epss_percentile": 0.29924}, "CVE-2022-31599": {"epss_score": 0.00059, "epss_percentile": 0.18619}, "CVE-2022-31600": {"epss_score": 0.00066, "epss_percentile": 0.20749}, "CVE-2022-31601": {"epss_score": 0.00049, "epss_percentile": 0.15293}, "CVE-2022-31602": {"epss_score": 0.00047, "epss_percentile": 0.14802}, "CVE-2022-31603": {"epss_score": 0.00047, "epss_percentile": 0.14802}, "CVE-2022-31604": {"epss_score": 0.02435, "epss_percentile": 0.84737}, "CVE-2022-31605": {"epss_score": 0.02435, "epss_percentile": 0.84737}, "CVE-2022-31606": {"epss_score": 0.00136, "epss_percentile": 0.34138}, "CVE-2022-31607": {"epss_score": 0.0009, "epss_percentile": 0.26053}, "CVE-2022-31608": {"epss_score": 0.0017, "epss_percentile": 0.38766}, "CVE-2022-31609": {"epss_score": 0.00102, "epss_percentile": 0.28761}, "CVE-2022-31610": {"epss_score": 0.00142, "epss_percentile": 0.35011}, "CVE-2022-31611": {"epss_score": 0.0008, "epss_percentile": 0.24052}, "CVE-2022-31612": {"epss_score": 0.00135, "epss_percentile": 0.34024}, "CVE-2022-31613": {"epss_score": 0.00131, "epss_percentile": 0.33346}, "CVE-2022-31614": {"epss_score": 0.00142, "epss_percentile": 0.35011}, "CVE-2022-31615": {"epss_score": 0.00057, "epss_percentile": 0.18062}, "CVE-2022-31616": {"epss_score": 0.00121, "epss_percentile": 0.31832}, "CVE-2022-31617": {"epss_score": 0.00186, "epss_percentile": 0.40611}, "CVE-2022-31618": {"epss_score": 0.00131, "epss_percentile": 0.33346}, "CVE-2022-31619": {"epss_score": 0.01216, "epss_percentile": 0.78592}, "CVE-2022-31620": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2022-31621": {"epss_score": 0.00033, "epss_percentile": 0.09296}, "CVE-2022-31622": {"epss_score": 0.00034, "epss_percentile": 0.09751}, "CVE-2022-31623": {"epss_score": 0.00033, "epss_percentile": 0.09298}, "CVE-2022-31624": {"epss_score": 0.00034, "epss_percentile": 0.09535}, "CVE-2022-31625": {"epss_score": 0.00766, "epss_percentile": 0.72934}, "CVE-2022-31626": {"epss_score": 0.11683, "epss_percentile": 0.93445}, "CVE-2022-31627": {"epss_score": 0.00171, "epss_percentile": 0.38891}, "CVE-2022-31628": {"epss_score": 0.00032, "epss_percentile": 0.08959}, "CVE-2022-31629": {"epss_score": 0.17321, "epss_percentile": 0.94822}, "CVE-2022-31630": {"epss_score": 0.00061, "epss_percentile": 0.19288}, "CVE-2022-31631": {"epss_score": 0.00562, "epss_percentile": 0.67705}, "CVE-2022-31635": {"epss_score": 0.00147, "epss_percentile": 0.3565}, "CVE-2022-31636": {"epss_score": 0.00147, "epss_percentile": 0.3565}, "CVE-2022-31637": {"epss_score": 0.00147, "epss_percentile": 0.3565}, "CVE-2022-31638": {"epss_score": 0.00147, "epss_percentile": 0.3565}, "CVE-2022-31639": {"epss_score": 0.00147, "epss_percentile": 0.3565}, "CVE-2022-31640": {"epss_score": 0.00104, "epss_percentile": 0.29156}, "CVE-2022-31641": {"epss_score": 0.00104, "epss_percentile": 0.29156}, "CVE-2022-31642": {"epss_score": 0.00108, "epss_percentile": 0.29809}, "CVE-2022-31643": {"epss_score": 0.00072, "epss_percentile": 0.2225}, "CVE-2022-31644": {"epss_score": 0.00102, "epss_percentile": 0.28816}, "CVE-2022-31645": {"epss_score": 0.00106, "epss_percentile": 0.29491}, "CVE-2022-31646": {"epss_score": 0.00102, "epss_percentile": 0.28816}, "CVE-2022-31647": {"epss_score": 0.00043, "epss_percentile": 0.13074}, "CVE-2022-31648": {"epss_score": 0.00458, "epss_percentile": 0.63424}, "CVE-2022-31649": {"epss_score": 0.00386, "epss_percentile": 0.59253}, "CVE-2022-31650": {"epss_score": 0.00063, "epss_percentile": 0.19894}, "CVE-2022-31651": {"epss_score": 0.00063, "epss_percentile": 0.19894}, "CVE-2022-31654": {"epss_score": 0.01264, "epss_percentile": 0.78991}, "CVE-2022-31655": {"epss_score": 0.01264, "epss_percentile": 0.78991}, "CVE-2022-31656": {"epss_score": 0.8447, "epss_percentile": 0.99291}, "CVE-2022-31657": {"epss_score": 0.02461, "epss_percentile": 0.84824}, "CVE-2022-31658": {"epss_score": 0.04817, "epss_percentile": 0.89172}, "CVE-2022-31659": {"epss_score": 0.01987, "epss_percentile": 0.83161}, "CVE-2022-31660": {"epss_score": 0.0497, "epss_percentile": 0.8935}, "CVE-2022-31661": {"epss_score": 0.00159, "epss_percentile": 0.37374}, "CVE-2022-31662": {"epss_score": 0.02191, "epss_percentile": 0.83939}, "CVE-2022-31663": {"epss_score": 0.01183, "epss_percentile": 0.78327}, "CVE-2022-31664": {"epss_score": 0.00217, "epss_percentile": 0.44304}, "CVE-2022-31665": {"epss_score": 0.05516, "epss_percentile": 0.89951}, "CVE-2022-31666": {"epss_score": 0.00094, "epss_percentile": 0.27028}, "CVE-2022-31667": {"epss_score": 0.00078, "epss_percentile": 0.23607}, "CVE-2022-31668": {"epss_score": 0.00056, "epss_percentile": 0.17689}, "CVE-2022-31669": {"epss_score": 0.00066, "epss_percentile": 0.20867}, "CVE-2022-31670": {"epss_score": 0.00121, "epss_percentile": 0.31824}, "CVE-2022-31671": {"epss_score": 0.00101, "epss_percentile": 0.28617}, "CVE-2022-31672": {"epss_score": 0.01047, "epss_percentile": 0.77039}, "CVE-2022-31673": {"epss_score": 0.04854, "epss_percentile": 0.89217}, "CVE-2022-31674": {"epss_score": 0.00351, "epss_percentile": 0.57054}, "CVE-2022-31675": {"epss_score": 0.00278, "epss_percentile": 0.50901}, "CVE-2022-31676": {"epss_score": 0.00072, "epss_percentile": 0.22471}, "CVE-2022-31677": {"epss_score": 0.00282, "epss_percentile": 0.51287}, "CVE-2022-31678": {"epss_score": 0.0314, "epss_percentile": 0.86485}, "CVE-2022-31679": {"epss_score": 0.00227, "epss_percentile": 0.45371}, "CVE-2022-31680": {"epss_score": 0.01501, "epss_percentile": 0.80714}, "CVE-2022-31681": {"epss_score": 0.00136, "epss_percentile": 0.34063}, "CVE-2022-31682": {"epss_score": 0.00489, "epss_percentile": 0.64903}, "CVE-2022-31683": {"epss_score": 0.00216, "epss_percentile": 0.44195}, "CVE-2022-31684": {"epss_score": 0.00366, "epss_percentile": 0.58096}, "CVE-2022-31685": {"epss_score": 0.00287, "epss_percentile": 0.51847}, "CVE-2022-31686": {"epss_score": 0.00959, "epss_percentile": 0.75961}, "CVE-2022-31687": {"epss_score": 0.01042, "epss_percentile": 0.76979}, "CVE-2022-31688": {"epss_score": 0.00481, "epss_percentile": 0.64505}, "CVE-2022-31689": {"epss_score": 0.00845, "epss_percentile": 0.74289}, "CVE-2022-31690": {"epss_score": 0.00241, "epss_percentile": 0.47278}, "CVE-2022-31691": {"epss_score": 0.12269, "epss_percentile": 0.93617}, "CVE-2022-31692": {"epss_score": 0.08385, "epss_percentile": 0.9202}, "CVE-2022-31693": {"epss_score": 0.00049, "epss_percentile": 0.15368}, "CVE-2022-31694": {"epss_score": 0.00067, "epss_percentile": 0.20995}, "CVE-2022-31696": {"epss_score": 0.00602, "epss_percentile": 0.68897}, "CVE-2022-31697": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2022-31698": {"epss_score": 0.03496, "epss_percentile": 0.87238}, "CVE-2022-31699": {"epss_score": 0.00427, "epss_percentile": 0.61879}, "CVE-2022-31700": {"epss_score": 0.02461, "epss_percentile": 0.84825}, "CVE-2022-31701": {"epss_score": 0.00174, "epss_percentile": 0.39169}, "CVE-2022-31702": {"epss_score": 0.01063, "epss_percentile": 0.7719}, "CVE-2022-31703": {"epss_score": 0.00445, "epss_percentile": 0.62864}, "CVE-2022-31704": {"epss_score": 0.90011, "epss_percentile": 0.99557}, "CVE-2022-31705": {"epss_score": 0.01351, "epss_percentile": 0.79682}, "CVE-2022-31706": {"epss_score": 0.87794, "epss_percentile": 0.99444}, "CVE-2022-31707": {"epss_score": 0.00833, "epss_percentile": 0.74096}, "CVE-2022-31708": {"epss_score": 0.00479, "epss_percentile": 0.64419}, "CVE-2022-31710": {"epss_score": 0.00921, "epss_percentile": 0.75483}, "CVE-2022-31711": {"epss_score": 0.77486, "epss_percentile": 0.98938}, "CVE-2022-31733": {"epss_score": 0.00146, "epss_percentile": 0.3564}, "CVE-2022-31734": {"epss_score": 0.00779, "epss_percentile": 0.73139}, "CVE-2022-31735": {"epss_score": 0.00163, "epss_percentile": 0.37824}, "CVE-2022-31736": {"epss_score": 0.0016, "epss_percentile": 0.37487}, "CVE-2022-31737": {"epss_score": 0.00243, "epss_percentile": 0.47425}, "CVE-2022-31738": {"epss_score": 0.00116, "epss_percentile": 0.31078}, "CVE-2022-31739": {"epss_score": 0.00502, "epss_percentile": 0.6537}, "CVE-2022-31740": {"epss_score": 0.00182, "epss_percentile": 0.40188}, "CVE-2022-31741": {"epss_score": 0.00191, "epss_percentile": 0.41185}, "CVE-2022-31742": {"epss_score": 0.00195, "epss_percentile": 0.41665}, "CVE-2022-31743": {"epss_score": 0.00615, "epss_percentile": 0.69289}, "CVE-2022-31744": {"epss_score": 0.0006, "epss_percentile": 0.19241}, "CVE-2022-31745": {"epss_score": 0.00337, "epss_percentile": 0.56051}, "CVE-2022-31746": {"epss_score": 0.0022, "epss_percentile": 0.44574}, "CVE-2022-31747": {"epss_score": 0.00318, "epss_percentile": 0.54457}, "CVE-2022-31748": {"epss_score": 0.00452, "epss_percentile": 0.6319}, "CVE-2022-31749": {"epss_score": 0.0029, "epss_percentile": 0.52093}, "CVE-2022-31751": {"epss_score": 0.00024, "epss_percentile": 0.0602}, "CVE-2022-31752": {"epss_score": 0.00024, "epss_percentile": 0.05889}, "CVE-2022-31753": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-31754": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2022-31755": {"epss_score": 0.00023, "epss_percentile": 0.05516}, "CVE-2022-31756": {"epss_score": 0.00029, "epss_percentile": 0.07692}, "CVE-2022-31757": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-31758": {"epss_score": 0.00019, "epss_percentile": 0.04228}, "CVE-2022-31759": {"epss_score": 0.00021, "epss_percentile": 0.04719}, "CVE-2022-31760": {"epss_score": 0.00127, "epss_percentile": 0.32896}, "CVE-2022-31761": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2022-31762": {"epss_score": 0.00031, "epss_percentile": 0.08478}, "CVE-2022-31763": {"epss_score": 0.00019, "epss_percentile": 0.04095}, "CVE-2022-31764": {"epss_score": 0.00113, "epss_percentile": 0.3065}, "CVE-2022-31765": {"epss_score": 0.00246, "epss_percentile": 0.47748}, "CVE-2022-31766": {"epss_score": 0.01448, "epss_percentile": 0.80335}, "CVE-2022-31767": {"epss_score": 0.01948, "epss_percentile": 0.83009}, "CVE-2022-31768": {"epss_score": 0.00111, "epss_percentile": 0.30298}, "CVE-2022-31769": {"epss_score": 0.00124, "epss_percentile": 0.32421}, "CVE-2022-31770": {"epss_score": 0.00201, "epss_percentile": 0.42381}, "CVE-2022-31772": {"epss_score": 0.00329, "epss_percentile": 0.55389}, "CVE-2022-31773": {"epss_score": 0.00152, "epss_percentile": 0.36445}, "CVE-2022-31774": {"epss_score": 0.00235, "epss_percentile": 0.46224}, "CVE-2022-31775": {"epss_score": 0.00042, "epss_percentile": 0.12749}, "CVE-2022-31776": {"epss_score": 0.00135, "epss_percentile": 0.34002}, "CVE-2022-31777": {"epss_score": 0.00126, "epss_percentile": 0.32705}, "CVE-2022-31778": {"epss_score": 0.00164, "epss_percentile": 0.38009}, "CVE-2022-31779": {"epss_score": 0.00215, "epss_percentile": 0.44046}, "CVE-2022-31780": {"epss_score": 0.00441, "epss_percentile": 0.6269}, "CVE-2022-31781": {"epss_score": 0.01174, "epss_percentile": 0.78256}, "CVE-2022-31782": {"epss_score": 0.00312, "epss_percentile": 0.53983}, "CVE-2022-31783": {"epss_score": 0.00102, "epss_percentile": 0.28813}, "CVE-2022-31784": {"epss_score": 0.01666, "epss_percentile": 0.8165}, "CVE-2022-31786": {"epss_score": 0.00142, "epss_percentile": 0.34989}, "CVE-2022-31787": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31788": {"epss_score": 0.00314, "epss_percentile": 0.5416}, "CVE-2022-31789": {"epss_score": 0.04037, "epss_percentile": 0.8816}, "CVE-2022-31790": {"epss_score": 0.00623, "epss_percentile": 0.69534}, "CVE-2022-31791": {"epss_score": 0.00174, "epss_percentile": 0.39262}, "CVE-2022-31792": {"epss_score": 0.00216, "epss_percentile": 0.44162}, "CVE-2022-31793": {"epss_score": 0.93819, "epss_percentile": 0.99852}, "CVE-2022-31794": {"epss_score": 0.04828, "epss_percentile": 0.89187}, "CVE-2022-31795": {"epss_score": 0.03064, "epss_percentile": 0.86321}, "CVE-2022-31796": {"epss_score": 0.00284, "epss_percentile": 0.51484}, "CVE-2022-31798": {"epss_score": 0.74601, "epss_percentile": 0.98809}, "CVE-2022-31799": {"epss_score": 0.00323, "epss_percentile": 0.54864}, "CVE-2022-31800": {"epss_score": 0.01982, "epss_percentile": 0.83139}, "CVE-2022-31801": {"epss_score": 0.0068, "epss_percentile": 0.71028}, "CVE-2022-31802": {"epss_score": 0.00334, "epss_percentile": 0.55714}, "CVE-2022-31803": {"epss_score": 0.00212, "epss_percentile": 0.4381}, "CVE-2022-31804": {"epss_score": 0.00288, "epss_percentile": 0.51927}, "CVE-2022-31805": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2022-31806": {"epss_score": 0.00538, "epss_percentile": 0.66939}, "CVE-2022-31807": {"epss_score": 0.00017, "epss_percentile": 0.03352}, "CVE-2022-31808": {"epss_score": 0.00086, "epss_percentile": 0.25292}, "CVE-2022-31810": {"epss_score": 0.00345, "epss_percentile": 0.5656}, "CVE-2022-31812": {"epss_score": 0.0014, "epss_percentile": 0.34756}, "CVE-2022-31813": {"epss_score": 0.0003, "epss_percentile": 0.08014}, "CVE-2022-31814": {"epss_score": 0.9436, "epss_percentile": 0.99959}, "CVE-2022-31827": {"epss_score": 0.00366, "epss_percentile": 0.58095}, "CVE-2022-31830": {"epss_score": 0.00307, "epss_percentile": 0.53495}, "CVE-2022-31836": {"epss_score": 0.00452, "epss_percentile": 0.63169}, "CVE-2022-31845": {"epss_score": 0.61681, "epss_percentile": 0.98259}, "CVE-2022-31846": {"epss_score": 0.38199, "epss_percentile": 0.97089}, "CVE-2022-31847": {"epss_score": 0.58442, "epss_percentile": 0.98117}, "CVE-2022-31849": {"epss_score": 0.01721, "epss_percentile": 0.81936}, "CVE-2022-31854": {"epss_score": 0.85495, "epss_percentile": 0.99336}, "CVE-2022-31856": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2022-31860": {"epss_score": 0.01413, "epss_percentile": 0.80117}, "CVE-2022-31861": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-31873": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-31874": {"epss_score": 0.18571, "epss_percentile": 0.95034}, "CVE-2022-31875": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-31876": {"epss_score": 0.00495, "epss_percentile": 0.65123}, "CVE-2022-31877": {"epss_score": 0.00043, "epss_percentile": 0.1333}, "CVE-2022-31879": {"epss_score": 0.01299, "epss_percentile": 0.79283}, "CVE-2022-31883": {"epss_score": 0.00317, "epss_percentile": 0.5438}, "CVE-2022-31884": {"epss_score": 0.00243, "epss_percentile": 0.47504}, "CVE-2022-31885": {"epss_score": 0.35763, "epss_percentile": 0.96932}, "CVE-2022-31886": {"epss_score": 0.0091, "epss_percentile": 0.75322}, "CVE-2022-31887": {"epss_score": 0.00368, "epss_percentile": 0.58172}, "CVE-2022-31888": {"epss_score": 0.00843, "epss_percentile": 0.74262}, "CVE-2022-31889": {"epss_score": 0.00356, "epss_percentile": 0.57398}, "CVE-2022-31890": {"epss_score": 0.05655, "epss_percentile": 0.90089}, "CVE-2022-31897": {"epss_score": 0.01399, "epss_percentile": 0.79998}, "CVE-2022-31898": {"epss_score": 0.3782, "epss_percentile": 0.97072}, "CVE-2022-31901": {"epss_score": 0.00363, "epss_percentile": 0.57865}, "CVE-2022-31902": {"epss_score": 0.0007, "epss_percentile": 0.21816}, "CVE-2022-31904": {"epss_score": 0.0066, "epss_percentile": 0.70524}, "CVE-2022-31906": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-31908": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-31910": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-31911": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-31912": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-31913": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-31914": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-31937": {"epss_score": 0.00853, "epss_percentile": 0.74435}, "CVE-2022-31941": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31943": {"epss_score": 0.00487, "epss_percentile": 0.64824}, "CVE-2022-31945": {"epss_score": 0.00334, "epss_percentile": 0.55794}, "CVE-2022-31946": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31948": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31951": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31952": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31953": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31956": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31957": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31959": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31961": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31962": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31964": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31965": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31966": {"epss_score": 0.00329, "epss_percentile": 0.55303}, "CVE-2022-31969": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31970": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-31971": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-31973": {"epss_score": 0.00329, "epss_percentile": 0.55303}, "CVE-2022-31974": {"epss_score": 0.17631, "epss_percentile": 0.94881}, "CVE-2022-31975": {"epss_score": 0.17631, "epss_percentile": 0.94881}, "CVE-2022-31976": {"epss_score": 0.41622, "epss_percentile": 0.97286}, "CVE-2022-31977": {"epss_score": 0.38136, "epss_percentile": 0.97087}, "CVE-2022-31978": {"epss_score": 0.48185, "epss_percentile": 0.97626}, "CVE-2022-31980": {"epss_score": 0.08046, "epss_percentile": 0.9185}, "CVE-2022-31981": {"epss_score": 0.08046, "epss_percentile": 0.9185}, "CVE-2022-31982": {"epss_score": 0.08046, "epss_percentile": 0.9185}, "CVE-2022-31983": {"epss_score": 0.40465, "epss_percentile": 0.97219}, "CVE-2022-31984": {"epss_score": 0.23519, "epss_percentile": 0.95788}, "CVE-2022-31985": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-31986": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-31988": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-31989": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31990": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31991": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31992": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-31993": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-31994": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-31996": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-31998": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32000": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32001": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32002": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-32003": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32004": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32005": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32006": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32007": {"epss_score": 0.16601, "epss_percentile": 0.947}, "CVE-2022-32008": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32010": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32011": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32012": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32013": {"epss_score": 0.00567, "epss_percentile": 0.67876}, "CVE-2022-32014": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32015": {"epss_score": 0.16601, "epss_percentile": 0.947}, "CVE-2022-32016": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32017": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32018": {"epss_score": 0.16601, "epss_percentile": 0.947}, "CVE-2022-32019": {"epss_score": 0.03559, "epss_percentile": 0.87351}, "CVE-2022-32020": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2022-32021": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32022": {"epss_score": 0.11785, "epss_percentile": 0.93475}, "CVE-2022-32024": {"epss_score": 0.11785, "epss_percentile": 0.93475}, "CVE-2022-32025": {"epss_score": 0.11785, "epss_percentile": 0.93475}, "CVE-2022-32026": {"epss_score": 0.11785, "epss_percentile": 0.93475}, "CVE-2022-32027": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32028": {"epss_score": 0.11785, "epss_percentile": 0.93475}, "CVE-2022-32030": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2022-32031": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2022-32032": {"epss_score": 0.00561, "epss_percentile": 0.67672}, "CVE-2022-32033": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2022-32034": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2022-32035": {"epss_score": 0.00431, "epss_percentile": 0.62095}, "CVE-2022-32036": {"epss_score": 0.00314, "epss_percentile": 0.54131}, "CVE-2022-32037": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2022-32039": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2022-32040": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2022-32041": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2022-32043": {"epss_score": 0.00354, "epss_percentile": 0.57256}, "CVE-2022-32044": {"epss_score": 0.00416, "epss_percentile": 0.61196}, "CVE-2022-32045": {"epss_score": 0.00416, "epss_percentile": 0.61196}, "CVE-2022-32046": {"epss_score": 0.00416, "epss_percentile": 0.61196}, "CVE-2022-32047": {"epss_score": 0.00416, "epss_percentile": 0.61196}, "CVE-2022-32048": {"epss_score": 0.00416, "epss_percentile": 0.61196}, "CVE-2022-32049": {"epss_score": 0.00416, "epss_percentile": 0.61196}, "CVE-2022-32050": {"epss_score": 0.00416, "epss_percentile": 0.61196}, "CVE-2022-32051": {"epss_score": 0.00416, "epss_percentile": 0.61196}, "CVE-2022-32052": {"epss_score": 0.00416, "epss_percentile": 0.61196}, "CVE-2022-32053": {"epss_score": 0.00416, "epss_percentile": 0.61196}, "CVE-2022-32054": {"epss_score": 0.11047, "epss_percentile": 0.93201}, "CVE-2022-32055": {"epss_score": 0.00264, "epss_percentile": 0.49748}, "CVE-2022-32056": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-32058": {"epss_score": 0.00201, "epss_percentile": 0.42353}, "CVE-2022-32060": {"epss_score": 0.05171, "epss_percentile": 0.89571}, "CVE-2022-32061": {"epss_score": 0.00429, "epss_percentile": 0.61993}, "CVE-2022-32065": {"epss_score": 0.00447, "epss_percentile": 0.6296}, "CVE-2022-32073": {"epss_score": 0.01344, "epss_percentile": 0.79612}, "CVE-2022-32074": {"epss_score": 0.00913, "epss_percentile": 0.75368}, "CVE-2022-32081": {"epss_score": 0.00124, "epss_percentile": 0.32358}, "CVE-2022-32082": {"epss_score": 0.00134, "epss_percentile": 0.33895}, "CVE-2022-32083": {"epss_score": 0.0019, "epss_percentile": 0.41093}, "CVE-2022-32084": {"epss_score": 0.00301, "epss_percentile": 0.53077}, "CVE-2022-32085": {"epss_score": 0.00192, "epss_percentile": 0.41292}, "CVE-2022-32086": {"epss_score": 0.00105, "epss_percentile": 0.29281}, "CVE-2022-32087": {"epss_score": 0.01141, "epss_percentile": 0.77954}, "CVE-2022-32088": {"epss_score": 0.00208, "epss_percentile": 0.43286}, "CVE-2022-32089": {"epss_score": 0.00124, "epss_percentile": 0.32358}, "CVE-2022-32091": {"epss_score": 0.00301, "epss_percentile": 0.53077}, "CVE-2022-32092": {"epss_score": 0.2247, "epss_percentile": 0.95639}, "CVE-2022-32093": {"epss_score": 0.00218, "epss_percentile": 0.44369}, "CVE-2022-32094": {"epss_score": 0.3543, "epss_percentile": 0.96909}, "CVE-2022-32095": {"epss_score": 0.00218, "epss_percentile": 0.44369}, "CVE-2022-32096": {"epss_score": 0.00569, "epss_percentile": 0.67911}, "CVE-2022-32101": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-32114": {"epss_score": 0.01882, "epss_percentile": 0.82697}, "CVE-2022-32115": {"epss_score": 0.008, "epss_percentile": 0.73544}, "CVE-2022-32117": {"epss_score": 0.00052, "epss_percentile": 0.16388}, "CVE-2022-32118": {"epss_score": 0.04991, "epss_percentile": 0.89367}, "CVE-2022-32119": {"epss_score": 0.12277, "epss_percentile": 0.9362}, "CVE-2022-32124": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-32125": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-32126": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-32127": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-32128": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-32129": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-32130": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-32131": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-32136": {"epss_score": 0.00306, "epss_percentile": 0.53448}, "CVE-2022-32137": {"epss_score": 0.01044, "epss_percentile": 0.77009}, "CVE-2022-32138": {"epss_score": 0.01077, "epss_percentile": 0.77341}, "CVE-2022-32139": {"epss_score": 0.00306, "epss_percentile": 0.53448}, "CVE-2022-32140": {"epss_score": 0.00333, "epss_percentile": 0.55632}, "CVE-2022-32141": {"epss_score": 0.00306, "epss_percentile": 0.53448}, "CVE-2022-32142": {"epss_score": 0.00787, "epss_percentile": 0.73312}, "CVE-2022-32143": {"epss_score": 0.0101, "epss_percentile": 0.76595}, "CVE-2022-32144": {"epss_score": 0.00036, "epss_percentile": 0.10508}, "CVE-2022-32145": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-32148": {"epss_score": 0.00056, "epss_percentile": 0.17757}, "CVE-2022-32149": {"epss_score": 0.00054, "epss_percentile": 0.1723}, "CVE-2022-32151": {"epss_score": 0.00202, "epss_percentile": 0.42477}, "CVE-2022-32152": {"epss_score": 0.00473, "epss_percentile": 0.64088}, "CVE-2022-32153": {"epss_score": 0.00296, "epss_percentile": 0.52556}, "CVE-2022-32154": {"epss_score": 0.00292, "epss_percentile": 0.52281}, "CVE-2022-32155": {"epss_score": 0.00432, "epss_percentile": 0.62107}, "CVE-2022-32156": {"epss_score": 0.00185, "epss_percentile": 0.40524}, "CVE-2022-32157": {"epss_score": 0.00503, "epss_percentile": 0.65462}, "CVE-2022-32158": {"epss_score": 0.00904, "epss_percentile": 0.75214}, "CVE-2022-32159": {"epss_score": 0.00342, "epss_percentile": 0.56389}, "CVE-2022-32166": {"epss_score": 0.00548, "epss_percentile": 0.67293}, "CVE-2022-32167": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-32168": {"epss_score": 0.00082, "epss_percentile": 0.24442}, "CVE-2022-32169": {"epss_score": 0.00172, "epss_percentile": 0.38958}, "CVE-2022-32170": {"epss_score": 0.00172, "epss_percentile": 0.38958}, "CVE-2022-32171": {"epss_score": 0.00442, "epss_percentile": 0.62747}, "CVE-2022-32172": {"epss_score": 0.00442, "epss_percentile": 0.62747}, "CVE-2022-32173": {"epss_score": 0.002, "epss_percentile": 0.42257}, "CVE-2022-32174": {"epss_score": 0.02656, "epss_percentile": 0.85357}, "CVE-2022-32175": {"epss_score": 0.00104, "epss_percentile": 0.29155}, "CVE-2022-32176": {"epss_score": 0.00611, "epss_percentile": 0.69206}, "CVE-2022-32177": {"epss_score": 0.00668, "epss_percentile": 0.70731}, "CVE-2022-32189": {"epss_score": 0.001, "epss_percentile": 0.28473}, "CVE-2022-32190": {"epss_score": 0.00173, "epss_percentile": 0.39066}, "CVE-2022-32192": {"epss_score": 0.00371, "epss_percentile": 0.58371}, "CVE-2022-32193": {"epss_score": 0.00376, "epss_percentile": 0.58676}, "CVE-2022-32195": {"epss_score": 0.03276, "epss_percentile": 0.86803}, "CVE-2022-32199": {"epss_score": 0.0708, "epss_percentile": 0.91238}, "CVE-2022-32200": {"epss_score": 0.00194, "epss_percentile": 0.41596}, "CVE-2022-32201": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2022-32202": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2022-32203": {"epss_score": 0.01193, "epss_percentile": 0.78409}, "CVE-2022-32204": {"epss_score": 0.00131, "epss_percentile": 0.33417}, "CVE-2022-32205": {"epss_score": 0.02124, "epss_percentile": 0.83689}, "CVE-2022-32206": {"epss_score": 0.02708, "epss_percentile": 0.85479}, "CVE-2022-32207": {"epss_score": 0.00204, "epss_percentile": 0.42665}, "CVE-2022-32208": {"epss_score": 0.00305, "epss_percentile": 0.53339}, "CVE-2022-32209": {"epss_score": 0.05478, "epss_percentile": 0.89916}, "CVE-2022-32210": {"epss_score": 0.00119, "epss_percentile": 0.31614}, "CVE-2022-32211": {"epss_score": 0.00605, "epss_percentile": 0.68975}, "CVE-2022-32212": {"epss_score": 0.00087, "epss_percentile": 0.25453}, "CVE-2022-32213": {"epss_score": 0.89073, "epss_percentile": 0.99508}, "CVE-2022-32214": {"epss_score": 0.45841, "epss_percentile": 0.97504}, "CVE-2022-32215": {"epss_score": 0.88114, "epss_percentile": 0.99458}, "CVE-2022-32217": {"epss_score": 0.00211, "epss_percentile": 0.43637}, "CVE-2022-32218": {"epss_score": 0.00288, "epss_percentile": 0.51916}, "CVE-2022-32219": {"epss_score": 0.00185, "epss_percentile": 0.40466}, "CVE-2022-32220": {"epss_score": 0.00247, "epss_percentile": 0.47886}, "CVE-2022-32221": {"epss_score": 0.02128, "epss_percentile": 0.83703}, "CVE-2022-32222": {"epss_score": 0.00389, "epss_percentile": 0.59404}, "CVE-2022-32223": {"epss_score": 0.07779, "epss_percentile": 0.91678}, "CVE-2022-32224": {"epss_score": 0.02249, "epss_percentile": 0.8414}, "CVE-2022-32225": {"epss_score": 0.00824, "epss_percentile": 0.73939}, "CVE-2022-32226": {"epss_score": 0.00102, "epss_percentile": 0.28767}, "CVE-2022-32227": {"epss_score": 0.00425, "epss_percentile": 0.61694}, "CVE-2022-32228": {"epss_score": 0.0031, "epss_percentile": 0.53756}, "CVE-2022-32229": {"epss_score": 0.0031, "epss_percentile": 0.53756}, "CVE-2022-32230": {"epss_score": 0.28752, "epss_percentile": 0.96382}, "CVE-2022-32231": {"epss_score": 0.00076, "epss_percentile": 0.23237}, "CVE-2022-32234": {"epss_score": 0.00788, "epss_percentile": 0.73341}, "CVE-2022-32235": {"epss_score": 0.00248, "epss_percentile": 0.47933}, "CVE-2022-32236": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2022-32237": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2022-32238": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2022-32239": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2022-32240": {"epss_score": 0.00248, "epss_percentile": 0.47933}, "CVE-2022-32241": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2022-32242": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2022-32243": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2022-32244": {"epss_score": 0.00195, "epss_percentile": 0.41665}, "CVE-2022-32245": {"epss_score": 0.00539, "epss_percentile": 0.66969}, "CVE-2022-32246": {"epss_score": 0.0037, "epss_percentile": 0.58283}, "CVE-2022-32247": {"epss_score": 0.01856, "epss_percentile": 0.82568}, "CVE-2022-32248": {"epss_score": 0.0021, "epss_percentile": 0.43478}, "CVE-2022-32249": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2022-32250": {"epss_score": 0.01206, "epss_percentile": 0.78521}, "CVE-2022-32251": {"epss_score": 0.00305, "epss_percentile": 0.53371}, "CVE-2022-32252": {"epss_score": 0.00062, "epss_percentile": 0.19707}, "CVE-2022-32253": {"epss_score": 0.0018, "epss_percentile": 0.39894}, "CVE-2022-32254": {"epss_score": 0.00292, "epss_percentile": 0.52216}, "CVE-2022-32255": {"epss_score": 0.00242, "epss_percentile": 0.47367}, "CVE-2022-32256": {"epss_score": 0.00204, "epss_percentile": 0.42648}, "CVE-2022-32257": {"epss_score": 0.00452, "epss_percentile": 0.63176}, "CVE-2022-32258": {"epss_score": 0.00264, "epss_percentile": 0.49568}, "CVE-2022-32259": {"epss_score": 0.00186, "epss_percentile": 0.40659}, "CVE-2022-32260": {"epss_score": 0.00099, "epss_percentile": 0.28309}, "CVE-2022-32261": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2022-32262": {"epss_score": 0.0215, "epss_percentile": 0.83779}, "CVE-2022-32263": {"epss_score": 0.00845, "epss_percentile": 0.74286}, "CVE-2022-32264": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2022-32265": {"epss_score": 0.00422, "epss_percentile": 0.61562}, "CVE-2022-32266": {"epss_score": 0.00121, "epss_percentile": 0.31835}, "CVE-2022-32267": {"epss_score": 0.00093, "epss_percentile": 0.2675}, "CVE-2022-32268": {"epss_score": 0.04474, "epss_percentile": 0.88736}, "CVE-2022-32269": {"epss_score": 0.01185, "epss_percentile": 0.78338}, "CVE-2022-32270": {"epss_score": 0.04063, "epss_percentile": 0.88192}, "CVE-2022-32271": {"epss_score": 0.02718, "epss_percentile": 0.85512}, "CVE-2022-32272": {"epss_score": 0.20821, "epss_percentile": 0.95419}, "CVE-2022-32273": {"epss_score": 0.00166, "epss_percentile": 0.38242}, "CVE-2022-32274": {"epss_score": 0.00464, "epss_percentile": 0.63725}, "CVE-2022-32275": {"epss_score": 0.61931, "epss_percentile": 0.98268}, "CVE-2022-32276": {"epss_score": 0.14187, "epss_percentile": 0.94158}, "CVE-2022-32277": {"epss_score": 0.00297, "epss_percentile": 0.52698}, "CVE-2022-32278": {"epss_score": 0.00617, "epss_percentile": 0.69349}, "CVE-2022-32280": {"epss_score": 0.00162, "epss_percentile": 0.37709}, "CVE-2022-32282": {"epss_score": 0.00378, "epss_percentile": 0.58823}, "CVE-2022-32283": {"epss_score": 0.00177, "epss_percentile": 0.39503}, "CVE-2022-32284": {"epss_score": 0.0057, "epss_percentile": 0.67953}, "CVE-2022-32285": {"epss_score": 0.00423, "epss_percentile": 0.61586}, "CVE-2022-32286": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-32287": {"epss_score": 0.00502, "epss_percentile": 0.65397}, "CVE-2022-32289": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-32290": {"epss_score": 0.00069, "epss_percentile": 0.21591}, "CVE-2022-32291": {"epss_score": 0.00654, "epss_percentile": 0.70354}, "CVE-2022-32292": {"epss_score": 0.01719, "epss_percentile": 0.81925}, "CVE-2022-32293": {"epss_score": 0.00347, "epss_percentile": 0.56782}, "CVE-2022-32294": {"epss_score": 0.02171, "epss_percentile": 0.83872}, "CVE-2022-32295": {"epss_score": 0.00619, "epss_percentile": 0.69436}, "CVE-2022-32296": {"epss_score": 0.00039, "epss_percentile": 0.11583}, "CVE-2022-32297": {"epss_score": 0.00509, "epss_percentile": 0.65751}, "CVE-2022-32298": {"epss_score": 0.00275, "epss_percentile": 0.50682}, "CVE-2022-32299": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32300": {"epss_score": 0.00501, "epss_percentile": 0.65342}, "CVE-2022-32301": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-32302": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32308": {"epss_score": 0.00164, "epss_percentile": 0.37909}, "CVE-2022-32310": {"epss_score": 0.00358, "epss_percentile": 0.57521}, "CVE-2022-32311": {"epss_score": 0.00251, "epss_percentile": 0.48267}, "CVE-2022-32317": {"epss_score": 0.00378, "epss_percentile": 0.58792}, "CVE-2022-32318": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2022-32320": {"epss_score": 0.0026, "epss_percentile": 0.49236}, "CVE-2022-32323": {"epss_score": 0.0008, "epss_percentile": 0.24058}, "CVE-2022-32324": {"epss_score": 0.00385, "epss_percentile": 0.59189}, "CVE-2022-32325": {"epss_score": 0.00145, "epss_percentile": 0.35485}, "CVE-2022-32328": {"epss_score": 0.00417, "epss_percentile": 0.61234}, "CVE-2022-32330": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32331": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32332": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32333": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32334": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32335": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32336": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-32337": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-32338": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32339": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32340": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32341": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32342": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32343": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32344": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32345": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32346": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32347": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32348": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32349": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32350": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32351": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32352": {"epss_score": 0.00264, "epss_percentile": 0.49677}, "CVE-2022-32353": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32354": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32355": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32358": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32359": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32362": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32363": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32364": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32365": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32366": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32367": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32368": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32370": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32371": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32372": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32373": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32374": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32375": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32376": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32377": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32378": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32379": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32380": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32381": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32383": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2022-32384": {"epss_score": 0.00152, "epss_percentile": 0.36449}, "CVE-2022-32385": {"epss_score": 0.03075, "epss_percentile": 0.86359}, "CVE-2022-32386": {"epss_score": 0.00855, "epss_percentile": 0.74459}, "CVE-2022-32387": {"epss_score": 0.00951, "epss_percentile": 0.75862}, "CVE-2022-32389": {"epss_score": 0.0018, "epss_percentile": 0.39917}, "CVE-2022-32391": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32392": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32393": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32394": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32395": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32396": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32397": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32398": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32399": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32400": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32401": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32402": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32403": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32404": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32405": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32406": {"epss_score": 0.00161, "epss_percentile": 0.37612}, "CVE-2022-32407": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-32409": {"epss_score": 0.66547, "epss_percentile": 0.98468}, "CVE-2022-32411": {"epss_score": 0.00378, "epss_percentile": 0.58785}, "CVE-2022-32412": {"epss_score": 0.00378, "epss_percentile": 0.58785}, "CVE-2022-32413": {"epss_score": 0.01018, "epss_percentile": 0.76703}, "CVE-2022-32414": {"epss_score": 0.00136, "epss_percentile": 0.34176}, "CVE-2022-32415": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32416": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32417": {"epss_score": 0.42668, "epss_percentile": 0.97346}, "CVE-2022-32420": {"epss_score": 0.02798, "epss_percentile": 0.85686}, "CVE-2022-32425": {"epss_score": 0.00232, "epss_percentile": 0.45955}, "CVE-2022-32427": {"epss_score": 0.00617, "epss_percentile": 0.6936}, "CVE-2022-32429": {"epss_score": 0.86991, "epss_percentile": 0.99407}, "CVE-2022-32430": {"epss_score": 0.77891, "epss_percentile": 0.98958}, "CVE-2022-32433": {"epss_score": 0.00993, "epss_percentile": 0.76418}, "CVE-2022-32434": {"epss_score": 0.00263, "epss_percentile": 0.49505}, "CVE-2022-32441": {"epss_score": 0.00193, "epss_percentile": 0.41447}, "CVE-2022-32442": {"epss_score": 0.00321, "epss_percentile": 0.54644}, "CVE-2022-32444": {"epss_score": 0.03761, "epss_percentile": 0.87688}, "CVE-2022-32449": {"epss_score": 0.13299, "epss_percentile": 0.93925}, "CVE-2022-32450": {"epss_score": 0.0012, "epss_percentile": 0.31797}, "CVE-2022-32453": {"epss_score": 0.00182, "epss_percentile": 0.40236}, "CVE-2022-32454": {"epss_score": 0.04995, "epss_percentile": 0.89371}, "CVE-2022-32455": {"epss_score": 0.00362, "epss_percentile": 0.57819}, "CVE-2022-32456": {"epss_score": 0.01067, "epss_percentile": 0.77231}, "CVE-2022-32457": {"epss_score": 0.00554, "epss_percentile": 0.6744}, "CVE-2022-32458": {"epss_score": 0.01071, "epss_percentile": 0.77261}, "CVE-2022-32469": {"epss_score": 0.00049, "epss_percentile": 0.15498}, "CVE-2022-32470": {"epss_score": 0.00049, "epss_percentile": 0.15498}, "CVE-2022-32471": {"epss_score": 0.00049, "epss_percentile": 0.15498}, "CVE-2022-32473": {"epss_score": 0.00055, "epss_percentile": 0.17596}, "CVE-2022-32474": {"epss_score": 0.00055, "epss_percentile": 0.17596}, "CVE-2022-32475": {"epss_score": 0.00049, "epss_percentile": 0.15498}, "CVE-2022-32476": {"epss_score": 0.00055, "epss_percentile": 0.17596}, "CVE-2022-32477": {"epss_score": 0.00049, "epss_percentile": 0.15498}, "CVE-2022-32478": {"epss_score": 0.00055, "epss_percentile": 0.17596}, "CVE-2022-32480": {"epss_score": 0.0037, "epss_percentile": 0.58342}, "CVE-2022-32481": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2022-32482": {"epss_score": 0.00023, "epss_percentile": 0.05376}, "CVE-2022-32483": {"epss_score": 0.00053, "epss_percentile": 0.16697}, "CVE-2022-32484": {"epss_score": 0.00053, "epss_percentile": 0.16697}, "CVE-2022-32485": {"epss_score": 0.00049, "epss_percentile": 0.15572}, "CVE-2022-32486": {"epss_score": 0.00049, "epss_percentile": 0.15572}, "CVE-2022-32487": {"epss_score": 0.00049, "epss_percentile": 0.15572}, "CVE-2022-32488": {"epss_score": 0.00049, "epss_percentile": 0.15572}, "CVE-2022-32489": {"epss_score": 0.00049, "epss_percentile": 0.15572}, "CVE-2022-32490": {"epss_score": 0.00025, "epss_percentile": 0.06207}, "CVE-2022-32491": {"epss_score": 0.00043, "epss_percentile": 0.13022}, "CVE-2022-32492": {"epss_score": 0.00049, "epss_percentile": 0.15572}, "CVE-2022-32493": {"epss_score": 0.00043, "epss_percentile": 0.13016}, "CVE-2022-32498": {"epss_score": 0.00055, "epss_percentile": 0.17654}, "CVE-2022-32502": {"epss_score": 0.01451, "epss_percentile": 0.8036}, "CVE-2022-32503": {"epss_score": 0.0001, "epss_percentile": 0.0079}, "CVE-2022-32504": {"epss_score": 0.00201, "epss_percentile": 0.42324}, "CVE-2022-32505": {"epss_score": 0.00078, "epss_percentile": 0.23665}, "CVE-2022-32506": {"epss_score": 0.00065, "epss_percentile": 0.20672}, "CVE-2022-32507": {"epss_score": 0.00059, "epss_percentile": 0.18755}, "CVE-2022-32508": {"epss_score": 0.00107, "epss_percentile": 0.29722}, "CVE-2022-32509": {"epss_score": 0.00051, "epss_percentile": 0.16052}, "CVE-2022-32510": {"epss_score": 0.00057, "epss_percentile": 0.18059}, "CVE-2022-32511": {"epss_score": 0.01987, "epss_percentile": 0.83161}, "CVE-2022-32512": {"epss_score": 0.00715, "epss_percentile": 0.71837}, "CVE-2022-32513": {"epss_score": 0.00291, "epss_percentile": 0.52162}, "CVE-2022-32514": {"epss_score": 0.00311, "epss_percentile": 0.53847}, "CVE-2022-32515": {"epss_score": 0.00208, "epss_percentile": 0.43257}, "CVE-2022-32516": {"epss_score": 0.00162, "epss_percentile": 0.37755}, "CVE-2022-32517": {"epss_score": 0.00136, "epss_percentile": 0.3414}, "CVE-2022-32518": {"epss_score": 0.00217, "epss_percentile": 0.44292}, "CVE-2022-32519": {"epss_score": 0.00257, "epss_percentile": 0.48843}, "CVE-2022-32520": {"epss_score": 0.00217, "epss_percentile": 0.44292}, "CVE-2022-32521": {"epss_score": 0.00708, "epss_percentile": 0.71675}, "CVE-2022-32522": {"epss_score": 0.05938, "epss_percentile": 0.90346}, "CVE-2022-32523": {"epss_score": 0.05672, "epss_percentile": 0.90105}, "CVE-2022-32524": {"epss_score": 0.06904, "epss_percentile": 0.91107}, "CVE-2022-32525": {"epss_score": 0.05672, "epss_percentile": 0.90105}, "CVE-2022-32526": {"epss_score": 0.05672, "epss_percentile": 0.90105}, "CVE-2022-32527": {"epss_score": 0.05672, "epss_percentile": 0.90105}, "CVE-2022-32528": {"epss_score": 0.0011, "epss_percentile": 0.30132}, "CVE-2022-32529": {"epss_score": 0.06904, "epss_percentile": 0.91107}, "CVE-2022-32530": {"epss_score": 0.00142, "epss_percentile": 0.34996}, "CVE-2022-32531": {"epss_score": 0.00798, "epss_percentile": 0.73515}, "CVE-2022-32532": {"epss_score": 0.82066, "epss_percentile": 0.99171}, "CVE-2022-32533": {"epss_score": 0.11553, "epss_percentile": 0.93403}, "CVE-2022-32534": {"epss_score": 0.02832, "epss_percentile": 0.85777}, "CVE-2022-32535": {"epss_score": 0.00174, "epss_percentile": 0.39188}, "CVE-2022-32536": {"epss_score": 0.00336, "epss_percentile": 0.55944}, "CVE-2022-32537": {"epss_score": 0.00108, "epss_percentile": 0.2982}, "CVE-2022-32540": {"epss_score": 0.00137, "epss_percentile": 0.34268}, "CVE-2022-32543": {"epss_score": 0.00166, "epss_percentile": 0.3827}, "CVE-2022-32544": {"epss_score": 0.00203, "epss_percentile": 0.42515}, "CVE-2022-32545": {"epss_score": 0.00083, "epss_percentile": 0.24713}, "CVE-2022-32546": {"epss_score": 0.0009, "epss_percentile": 0.26165}, "CVE-2022-32547": {"epss_score": 0.00083, "epss_percentile": 0.24713}, "CVE-2022-32548": {"epss_score": 0.64919, "epss_percentile": 0.98398}, "CVE-2022-32549": {"epss_score": 0.03181, "epss_percentile": 0.8658}, "CVE-2022-32550": {"epss_score": 0.00335, "epss_percentile": 0.55796}, "CVE-2022-32551": {"epss_score": 0.0345, "epss_percentile": 0.87163}, "CVE-2022-32552": {"epss_score": 0.00539, "epss_percentile": 0.66978}, "CVE-2022-32553": {"epss_score": 0.00539, "epss_percentile": 0.66978}, "CVE-2022-32554": {"epss_score": 0.00467, "epss_percentile": 0.63826}, "CVE-2022-32555": {"epss_score": 0.00123, "epss_percentile": 0.32296}, "CVE-2022-32556": {"epss_score": 0.0051, "epss_percentile": 0.6579}, "CVE-2022-32557": {"epss_score": 0.0039, "epss_percentile": 0.59519}, "CVE-2022-32558": {"epss_score": 0.0051, "epss_percentile": 0.6579}, "CVE-2022-32559": {"epss_score": 0.00699, "epss_percentile": 0.71446}, "CVE-2022-32560": {"epss_score": 0.00363, "epss_percentile": 0.57866}, "CVE-2022-32561": {"epss_score": 0.00477, "epss_percentile": 0.64335}, "CVE-2022-32562": {"epss_score": 0.00413, "epss_percentile": 0.6101}, "CVE-2022-32563": {"epss_score": 0.00405, "epss_percentile": 0.60465}, "CVE-2022-32564": {"epss_score": 0.0051, "epss_percentile": 0.6579}, "CVE-2022-32565": {"epss_score": 0.00478, "epss_percentile": 0.64384}, "CVE-2022-32567": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-32569": {"epss_score": 0.00145, "epss_percentile": 0.35424}, "CVE-2022-32570": {"epss_score": 0.00112, "epss_percentile": 0.30526}, "CVE-2022-32572": {"epss_score": 0.23472, "epss_percentile": 0.95782}, "CVE-2022-32573": {"epss_score": 0.17626, "epss_percentile": 0.94877}, "CVE-2022-32574": {"epss_score": 0.01432, "epss_percentile": 0.80253}, "CVE-2022-32575": {"epss_score": 0.00068, "epss_percentile": 0.2121}, "CVE-2022-32576": {"epss_score": 0.0007, "epss_percentile": 0.21972}, "CVE-2022-32577": {"epss_score": 0.00055, "epss_percentile": 0.17381}, "CVE-2022-32578": {"epss_score": 0.00094, "epss_percentile": 0.26772}, "CVE-2022-32579": {"epss_score": 0.00127, "epss_percentile": 0.32939}, "CVE-2022-32582": {"epss_score": 0.00044, "epss_percentile": 0.13589}, "CVE-2022-32583": {"epss_score": 0.00203, "epss_percentile": 0.42515}, "CVE-2022-32585": {"epss_score": 0.00746, "epss_percentile": 0.72543}, "CVE-2022-32586": {"epss_score": 0.01783, "epss_percentile": 0.82248}, "CVE-2022-32587": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-32588": {"epss_score": 0.00225, "epss_percentile": 0.45119}, "CVE-2022-32589": {"epss_score": 0.00361, "epss_percentile": 0.57692}, "CVE-2022-32590": {"epss_score": 0.00019, "epss_percentile": 0.04322}, "CVE-2022-32591": {"epss_score": 0.00361, "epss_percentile": 0.57692}, "CVE-2022-32592": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-32593": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-32594": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2022-32595": {"epss_score": 0.00047, "epss_percentile": 0.14828}, "CVE-2022-32596": {"epss_score": 0.00017, "epss_percentile": 0.0341}, "CVE-2022-32597": {"epss_score": 0.00017, "epss_percentile": 0.0341}, "CVE-2022-32598": {"epss_score": 0.00017, "epss_percentile": 0.0341}, "CVE-2022-32599": {"epss_score": 0.00033, "epss_percentile": 0.09355}, "CVE-2022-32601": {"epss_score": 0.00029, "epss_percentile": 0.07819}, "CVE-2022-32602": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-32603": {"epss_score": 0.00013, "epss_percentile": 0.01647}, "CVE-2022-32605": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-32607": {"epss_score": 0.00015, "epss_percentile": 0.02609}, "CVE-2022-32608": {"epss_score": 0.00012, "epss_percentile": 0.01285}, "CVE-2022-32609": {"epss_score": 0.00018, "epss_percentile": 0.03521}, "CVE-2022-32610": {"epss_score": 0.00018, "epss_percentile": 0.03521}, "CVE-2022-32611": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2022-32612": {"epss_score": 0.00014, "epss_percentile": 0.01789}, "CVE-2022-32613": {"epss_score": 0.00012, "epss_percentile": 0.01172}, "CVE-2022-32614": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-32615": {"epss_score": 0.00013, "epss_percentile": 0.01647}, "CVE-2022-32616": {"epss_score": 0.00013, "epss_percentile": 0.01647}, "CVE-2022-32617": {"epss_score": 0.00029, "epss_percentile": 0.07863}, "CVE-2022-32618": {"epss_score": 0.00029, "epss_percentile": 0.07863}, "CVE-2022-32619": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-32620": {"epss_score": 0.00051, "epss_percentile": 0.16117}, "CVE-2022-32621": {"epss_score": 0.0001, "epss_percentile": 0.00868}, "CVE-2022-32622": {"epss_score": 0.00017, "epss_percentile": 0.0341}, "CVE-2022-32623": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2022-32624": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-32625": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-32626": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-32628": {"epss_score": 0.00017, "epss_percentile": 0.0341}, "CVE-2022-32629": {"epss_score": 0.00017, "epss_percentile": 0.0341}, "CVE-2022-32630": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-32631": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2022-32632": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2022-32633": {"epss_score": 0.0001, "epss_percentile": 0.00849}, "CVE-2022-32634": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-32635": {"epss_score": 0.00035, "epss_percentile": 0.10064}, "CVE-2022-32636": {"epss_score": 0.00039, "epss_percentile": 0.11691}, "CVE-2022-32637": {"epss_score": 0.00039, "epss_percentile": 0.11691}, "CVE-2022-32638": {"epss_score": 0.00012, "epss_percentile": 0.01172}, "CVE-2022-32639": {"epss_score": 0.00018, "epss_percentile": 0.03728}, "CVE-2022-32640": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2022-32641": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2022-32642": {"epss_score": 0.00055, "epss_percentile": 0.17559}, "CVE-2022-32643": {"epss_score": 0.00051, "epss_percentile": 0.16049}, "CVE-2022-32644": {"epss_score": 0.00018, "epss_percentile": 0.03521}, "CVE-2022-32645": {"epss_score": 0.00014, "epss_percentile": 0.01893}, "CVE-2022-32646": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2022-32647": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-32648": {"epss_score": 0.00018, "epss_percentile": 0.03521}, "CVE-2022-32649": {"epss_score": 0.00018, "epss_percentile": 0.03521}, "CVE-2022-32650": {"epss_score": 0.00018, "epss_percentile": 0.03521}, "CVE-2022-32651": {"epss_score": 0.00018, "epss_percentile": 0.03521}, "CVE-2022-32652": {"epss_score": 0.00018, "epss_percentile": 0.03521}, "CVE-2022-32653": {"epss_score": 0.00018, "epss_percentile": 0.03521}, "CVE-2022-32654": {"epss_score": 0.00134, "epss_percentile": 0.33868}, "CVE-2022-32655": {"epss_score": 0.00134, "epss_percentile": 0.33868}, "CVE-2022-32656": {"epss_score": 0.00134, "epss_percentile": 0.33868}, "CVE-2022-32657": {"epss_score": 0.00085, "epss_percentile": 0.25221}, "CVE-2022-32658": {"epss_score": 0.00085, "epss_percentile": 0.25221}, "CVE-2022-32659": {"epss_score": 0.00085, "epss_percentile": 0.25221}, "CVE-2022-32663": {"epss_score": 0.05229, "epss_percentile": 0.89637}, "CVE-2022-32664": {"epss_score": 0.00703, "epss_percentile": 0.71544}, "CVE-2022-32665": {"epss_score": 0.01852, "epss_percentile": 0.82543}, "CVE-2022-32666": {"epss_score": 0.01608, "epss_percentile": 0.81313}, "CVE-2022-32739": {"epss_score": 0.00225, "epss_percentile": 0.4512}, "CVE-2022-32740": {"epss_score": 0.00225, "epss_percentile": 0.4512}, "CVE-2022-32741": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2022-32742": {"epss_score": 0.00196, "epss_percentile": 0.41753}, "CVE-2022-32743": {"epss_score": 0.00904, "epss_percentile": 0.75212}, "CVE-2022-32744": {"epss_score": 0.0036, "epss_percentile": 0.5768}, "CVE-2022-32745": {"epss_score": 0.00388, "epss_percentile": 0.59347}, "CVE-2022-32746": {"epss_score": 0.00257, "epss_percentile": 0.48849}, "CVE-2022-32747": {"epss_score": 0.00027, "epss_percentile": 0.0694}, "CVE-2022-32748": {"epss_score": 0.00078, "epss_percentile": 0.23564}, "CVE-2022-32749": {"epss_score": 0.00673, "epss_percentile": 0.70831}, "CVE-2022-32750": {"epss_score": 0.00309, "epss_percentile": 0.53663}, "CVE-2022-32751": {"epss_score": 0.00077, "epss_percentile": 0.23302}, "CVE-2022-32752": {"epss_score": 0.0009, "epss_percentile": 0.26149}, "CVE-2022-32753": {"epss_score": 0.00014, "epss_percentile": 0.01793}, "CVE-2022-32754": {"epss_score": 0.00114, "epss_percentile": 0.3088}, "CVE-2022-32755": {"epss_score": 0.00043, "epss_percentile": 0.13276}, "CVE-2022-32756": {"epss_score": 0.00039, "epss_percentile": 0.11435}, "CVE-2022-32757": {"epss_score": 0.0004, "epss_percentile": 0.12165}, "CVE-2022-32759": {"epss_score": 0.00141, "epss_percentile": 0.34904}, "CVE-2022-32760": {"epss_score": 0.0037, "epss_percentile": 0.58282}, "CVE-2022-32761": {"epss_score": 0.02272, "epss_percentile": 0.84218}, "CVE-2022-32763": {"epss_score": 0.02361, "epss_percentile": 0.845}, "CVE-2022-32764": {"epss_score": 0.0013, "epss_percentile": 0.33293}, "CVE-2022-32765": {"epss_score": 0.0139, "epss_percentile": 0.79939}, "CVE-2022-32766": {"epss_score": 0.00055, "epss_percentile": 0.17633}, "CVE-2022-32768": {"epss_score": 0.00186, "epss_percentile": 0.40693}, "CVE-2022-32769": {"epss_score": 0.00178, "epss_percentile": 0.39661}, "CVE-2022-32770": {"epss_score": 0.13417, "epss_percentile": 0.93956}, "CVE-2022-32771": {"epss_score": 0.09275, "epss_percentile": 0.92479}, "CVE-2022-32772": {"epss_score": 0.07208, "epss_percentile": 0.91325}, "CVE-2022-32773": {"epss_score": 0.01352, "epss_percentile": 0.79684}, "CVE-2022-32774": {"epss_score": 0.00568, "epss_percentile": 0.67882}, "CVE-2022-32775": {"epss_score": 0.01302, "epss_percentile": 0.79305}, "CVE-2022-32776": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-32777": {"epss_score": 0.01066, "epss_percentile": 0.77215}, "CVE-2022-32778": {"epss_score": 0.01066, "epss_percentile": 0.77215}, "CVE-2022-32781": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2022-32782": {"epss_score": 0.00055, "epss_percentile": 0.17652}, "CVE-2022-32783": {"epss_score": 0.00067, "epss_percentile": 0.2114}, "CVE-2022-32784": {"epss_score": 0.00196, "epss_percentile": 0.41741}, "CVE-2022-32785": {"epss_score": 0.00075, "epss_percentile": 0.23025}, "CVE-2022-32786": {"epss_score": 0.00104, "epss_percentile": 0.29111}, "CVE-2022-32787": {"epss_score": 0.00403, "epss_percentile": 0.6035}, "CVE-2022-32788": {"epss_score": 0.01411, "epss_percentile": 0.8011}, "CVE-2022-32789": {"epss_score": 0.00062, "epss_percentile": 0.19759}, "CVE-2022-32790": {"epss_score": 0.01709, "epss_percentile": 0.81869}, "CVE-2022-32792": {"epss_score": 0.00275, "epss_percentile": 0.50669}, "CVE-2022-32793": {"epss_score": 0.00679, "epss_percentile": 0.71019}, "CVE-2022-32794": {"epss_score": 0.0005, "epss_percentile": 0.15681}, "CVE-2022-32795": {"epss_score": 0.00318, "epss_percentile": 0.54447}, "CVE-2022-32796": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-32797": {"epss_score": 0.00142, "epss_percentile": 0.35038}, "CVE-2022-32798": {"epss_score": 0.00056, "epss_percentile": 0.17789}, "CVE-2022-32799": {"epss_score": 0.00281, "epss_percentile": 0.51112}, "CVE-2022-32800": {"epss_score": 0.00168, "epss_percentile": 0.38446}, "CVE-2022-32801": {"epss_score": 0.0005, "epss_percentile": 0.15823}, "CVE-2022-32802": {"epss_score": 0.00072, "epss_percentile": 0.22305}, "CVE-2022-32805": {"epss_score": 0.00156, "epss_percentile": 0.36895}, "CVE-2022-32807": {"epss_score": 0.00064, "epss_percentile": 0.20298}, "CVE-2022-32810": {"epss_score": 0.00087, "epss_percentile": 0.25467}, "CVE-2022-32811": {"epss_score": 0.00047, "epss_percentile": 0.14577}, "CVE-2022-32812": {"epss_score": 0.0006, "epss_percentile": 0.19153}, "CVE-2022-32813": {"epss_score": 0.00081, "epss_percentile": 0.24237}, "CVE-2022-32814": {"epss_score": 0.00252, "epss_percentile": 0.4838}, "CVE-2022-32815": {"epss_score": 0.00461, "epss_percentile": 0.63549}, "CVE-2022-32816": {"epss_score": 0.00098, "epss_percentile": 0.27693}, "CVE-2022-32817": {"epss_score": 0.00202, "epss_percentile": 0.42487}, "CVE-2022-32818": {"epss_score": 0.00067, "epss_percentile": 0.20996}, "CVE-2022-32819": {"epss_score": 0.00127, "epss_percentile": 0.32898}, "CVE-2022-32820": {"epss_score": 0.00105, "epss_percentile": 0.29372}, "CVE-2022-32821": {"epss_score": 0.00109, "epss_percentile": 0.30021}, "CVE-2022-32823": {"epss_score": 0.00112, "epss_percentile": 0.30488}, "CVE-2022-32824": {"epss_score": 0.00067, "epss_percentile": 0.20983}, "CVE-2022-32825": {"epss_score": 0.00156, "epss_percentile": 0.36895}, "CVE-2022-32826": {"epss_score": 0.00133, "epss_percentile": 0.33686}, "CVE-2022-32827": {"epss_score": 0.00072, "epss_percentile": 0.22349}, "CVE-2022-32828": {"epss_score": 0.00076, "epss_percentile": 0.2323}, "CVE-2022-32829": {"epss_score": 0.00075, "epss_percentile": 0.22893}, "CVE-2022-32830": {"epss_score": 0.00201, "epss_percentile": 0.42326}, "CVE-2022-32831": {"epss_score": 0.00064, "epss_percentile": 0.20298}, "CVE-2022-32832": {"epss_score": 0.11008, "epss_percentile": 0.93188}, "CVE-2022-32833": {"epss_score": 0.00298, "epss_percentile": 0.5278}, "CVE-2022-32834": {"epss_score": 0.00065, "epss_percentile": 0.20591}, "CVE-2022-32835": {"epss_score": 0.00047, "epss_percentile": 0.14926}, "CVE-2022-32836": {"epss_score": 0.0017, "epss_percentile": 0.38652}, "CVE-2022-32837": {"epss_score": 0.00068, "epss_percentile": 0.21202}, "CVE-2022-32838": {"epss_score": 0.00065, "epss_percentile": 0.20503}, "CVE-2022-32839": {"epss_score": 0.02412, "epss_percentile": 0.84668}, "CVE-2022-32840": {"epss_score": 0.00077, "epss_percentile": 0.23535}, "CVE-2022-32841": {"epss_score": 0.00253, "epss_percentile": 0.48482}, "CVE-2022-32842": {"epss_score": 0.00049, "epss_percentile": 0.15357}, "CVE-2022-32843": {"epss_score": 0.00097, "epss_percentile": 0.27573}, "CVE-2022-32844": {"epss_score": 0.00016, "epss_percentile": 0.02612}, "CVE-2022-32845": {"epss_score": 0.00676, "epss_percentile": 0.70943}, "CVE-2022-32846": {"epss_score": 0.00174, "epss_percentile": 0.3916}, "CVE-2022-32847": {"epss_score": 0.01128, "epss_percentile": 0.7783}, "CVE-2022-32848": {"epss_score": 0.00055, "epss_percentile": 0.17449}, "CVE-2022-32849": {"epss_score": 0.0008, "epss_percentile": 0.24022}, "CVE-2022-32851": {"epss_score": 0.00064, "epss_percentile": 0.20298}, "CVE-2022-32852": {"epss_score": 0.00056, "epss_percentile": 0.17789}, "CVE-2022-32853": {"epss_score": 0.00064, "epss_percentile": 0.20298}, "CVE-2022-32854": {"epss_score": 0.0007, "epss_percentile": 0.21881}, "CVE-2022-32855": {"epss_score": 0.00066, "epss_percentile": 0.20851}, "CVE-2022-32857": {"epss_score": 0.00093, "epss_percentile": 0.26716}, "CVE-2022-32858": {"epss_score": 0.00069, "epss_percentile": 0.21549}, "CVE-2022-32859": {"epss_score": 0.00237, "epss_percentile": 0.46684}, "CVE-2022-32860": {"epss_score": 0.0006, "epss_percentile": 0.19153}, "CVE-2022-32861": {"epss_score": 0.00316, "epss_percentile": 0.54278}, "CVE-2022-32862": {"epss_score": 0.03001, "epss_percentile": 0.86167}, "CVE-2022-32863": {"epss_score": 0.00682, "epss_percentile": 0.71061}, "CVE-2022-32864": {"epss_score": 0.00087, "epss_percentile": 0.25498}, "CVE-2022-32865": {"epss_score": 0.00047, "epss_percentile": 0.14862}, "CVE-2022-32866": {"epss_score": 0.00238, "epss_percentile": 0.46808}, "CVE-2022-32867": {"epss_score": 0.00065, "epss_percentile": 0.20595}, "CVE-2022-32868": {"epss_score": 0.00639, "epss_percentile": 0.69948}, "CVE-2022-32870": {"epss_score": 0.0009, "epss_percentile": 0.26082}, "CVE-2022-32871": {"epss_score": 0.00067, "epss_percentile": 0.21182}, "CVE-2022-32872": {"epss_score": 0.00086, "epss_percentile": 0.25347}, "CVE-2022-32875": {"epss_score": 0.00143, "epss_percentile": 0.35101}, "CVE-2022-32876": {"epss_score": 0.00073, "epss_percentile": 0.22509}, "CVE-2022-32877": {"epss_score": 0.00147, "epss_percentile": 0.3577}, "CVE-2022-32879": {"epss_score": 0.00097, "epss_percentile": 0.27533}, "CVE-2022-32880": {"epss_score": 0.00292, "epss_percentile": 0.52214}, "CVE-2022-32881": {"epss_score": 0.0011, "epss_percentile": 0.30154}, "CVE-2022-32882": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2022-32883": {"epss_score": 0.00127, "epss_percentile": 0.32807}, "CVE-2022-32885": {"epss_score": 0.00135, "epss_percentile": 0.34009}, "CVE-2022-32886": {"epss_score": 0.00673, "epss_percentile": 0.70837}, "CVE-2022-32887": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-32888": {"epss_score": 0.007, "epss_percentile": 0.7147}, "CVE-2022-32889": {"epss_score": 0.00054, "epss_percentile": 0.17333}, "CVE-2022-32890": {"epss_score": 0.00249, "epss_percentile": 0.4802}, "CVE-2022-32891": {"epss_score": 0.00121, "epss_percentile": 0.31884}, "CVE-2022-32892": {"epss_score": 0.00347, "epss_percentile": 0.56744}, "CVE-2022-32893": {"epss_score": 0.00225, "epss_percentile": 0.45161}, "CVE-2022-32894": {"epss_score": 0.00314, "epss_percentile": 0.54147}, "CVE-2022-32895": {"epss_score": 0.00049, "epss_percentile": 0.15446}, "CVE-2022-32896": {"epss_score": 0.00035, "epss_percentile": 0.10146}, "CVE-2022-32897": {"epss_score": 0.00437, "epss_percentile": 0.62499}, "CVE-2022-32898": {"epss_score": 0.05344, "epss_percentile": 0.89765}, "CVE-2022-32899": {"epss_score": 0.00084, "epss_percentile": 0.24977}, "CVE-2022-32900": {"epss_score": 0.0003, "epss_percentile": 0.08024}, "CVE-2022-32902": {"epss_score": 0.00011, "epss_percentile": 0.01055}, "CVE-2022-32903": {"epss_score": 0.00122, "epss_percentile": 0.32073}, "CVE-2022-32904": {"epss_score": 0.00147, "epss_percentile": 0.35695}, "CVE-2022-32905": {"epss_score": 0.00061, "epss_percentile": 0.19371}, "CVE-2022-32906": {"epss_score": 0.00107, "epss_percentile": 0.29687}, "CVE-2022-32907": {"epss_score": 0.00136, "epss_percentile": 0.34154}, "CVE-2022-32908": {"epss_score": 0.00132, "epss_percentile": 0.33573}, "CVE-2022-32909": {"epss_score": 0.00067, "epss_percentile": 0.20996}, "CVE-2022-32910": {"epss_score": 0.00231, "epss_percentile": 0.4584}, "CVE-2022-32911": {"epss_score": 0.00237, "epss_percentile": 0.46655}, "CVE-2022-32912": {"epss_score": 0.01199, "epss_percentile": 0.78465}, "CVE-2022-32913": {"epss_score": 0.00111, "epss_percentile": 0.30351}, "CVE-2022-32914": {"epss_score": 0.00286, "epss_percentile": 0.51707}, "CVE-2022-32915": {"epss_score": 0.00062, "epss_percentile": 0.1971}, "CVE-2022-32916": {"epss_score": 0.00082, "epss_percentile": 0.24483}, "CVE-2022-32917": {"epss_score": 0.004, "epss_percentile": 0.60159}, "CVE-2022-32918": {"epss_score": 0.00049, "epss_percentile": 0.155}, "CVE-2022-32919": {"epss_score": 0.00071, "epss_percentile": 0.22031}, "CVE-2022-32920": {"epss_score": 0.00108, "epss_percentile": 0.29811}, "CVE-2022-32922": {"epss_score": 0.00594, "epss_percentile": 0.6866}, "CVE-2022-32923": {"epss_score": 0.00236, "epss_percentile": 0.46373}, "CVE-2022-32924": {"epss_score": 0.00283, "epss_percentile": 0.51409}, "CVE-2022-32925": {"epss_score": 0.00061, "epss_percentile": 0.19296}, "CVE-2022-32926": {"epss_score": 0.0015, "epss_percentile": 0.36047}, "CVE-2022-32927": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2022-32928": {"epss_score": 0.00257, "epss_percentile": 0.48842}, "CVE-2022-32929": {"epss_score": 0.00128, "epss_percentile": 0.33054}, "CVE-2022-32931": {"epss_score": 0.00131, "epss_percentile": 0.33488}, "CVE-2022-32932": {"epss_score": 0.003, "epss_percentile": 0.52921}, "CVE-2022-32933": {"epss_score": 0.00209, "epss_percentile": 0.43417}, "CVE-2022-32934": {"epss_score": 0.01786, "epss_percentile": 0.82256}, "CVE-2022-32935": {"epss_score": 0.00103, "epss_percentile": 0.28929}, "CVE-2022-32936": {"epss_score": 0.00067, "epss_percentile": 0.20996}, "CVE-2022-32938": {"epss_score": 0.0029, "epss_percentile": 0.52098}, "CVE-2022-32939": {"epss_score": 0.00165, "epss_percentile": 0.38031}, "CVE-2022-32940": {"epss_score": 0.00079, "epss_percentile": 0.23943}, "CVE-2022-32941": {"epss_score": 0.0101, "epss_percentile": 0.76603}, "CVE-2022-32942": {"epss_score": 0.00296, "epss_percentile": 0.52589}, "CVE-2022-32943": {"epss_score": 0.00475, "epss_percentile": 0.64186}, "CVE-2022-32944": {"epss_score": 0.00256, "epss_percentile": 0.48812}, "CVE-2022-32945": {"epss_score": 0.00161, "epss_percentile": 0.37586}, "CVE-2022-32946": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2022-32947": {"epss_score": 0.00354, "epss_percentile": 0.57216}, "CVE-2022-32948": {"epss_score": 0.00047, "epss_percentile": 0.14862}, "CVE-2022-32949": {"epss_score": 0.00046, "epss_percentile": 0.14418}, "CVE-2022-32953": {"epss_score": 0.00049, "epss_percentile": 0.15498}, "CVE-2022-32954": {"epss_score": 0.00049, "epss_percentile": 0.15498}, "CVE-2022-32955": {"epss_score": 0.00055, "epss_percentile": 0.17596}, "CVE-2022-32958": {"epss_score": 0.00786, "epss_percentile": 0.7329}, "CVE-2022-32959": {"epss_score": 0.00053, "epss_percentile": 0.16953}, "CVE-2022-32960": {"epss_score": 0.00139, "epss_percentile": 0.34571}, "CVE-2022-32961": {"epss_score": 0.00053, "epss_percentile": 0.16953}, "CVE-2022-32962": {"epss_score": 0.00071, "epss_percentile": 0.22103}, "CVE-2022-32963": {"epss_score": 0.00603, "epss_percentile": 0.689}, "CVE-2022-32964": {"epss_score": 0.0055, "epss_percentile": 0.67337}, "CVE-2022-32965": {"epss_score": 0.02552, "epss_percentile": 0.85084}, "CVE-2022-32966": {"epss_score": 0.00103, "epss_percentile": 0.28922}, "CVE-2022-32967": {"epss_score": 0.00222, "epss_percentile": 0.44743}, "CVE-2022-32969": {"epss_score": 0.00332, "epss_percentile": 0.55612}, "CVE-2022-32970": {"epss_score": 0.00069, "epss_percentile": 0.2146}, "CVE-2022-32971": {"epss_score": 0.0007, "epss_percentile": 0.21932}, "CVE-2022-32972": {"epss_score": 0.00061, "epss_percentile": 0.19299}, "CVE-2022-32973": {"epss_score": 0.00521, "epss_percentile": 0.66222}, "CVE-2022-32974": {"epss_score": 0.00328, "epss_percentile": 0.55177}, "CVE-2022-32978": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2022-32981": {"epss_score": 0.00605, "epss_percentile": 0.68971}, "CVE-2022-32983": {"epss_score": 0.00395, "epss_percentile": 0.59847}, "CVE-2022-32984": {"epss_score": 0.00478, "epss_percentile": 0.6437}, "CVE-2022-32985": {"epss_score": 0.00614, "epss_percentile": 0.69273}, "CVE-2022-32987": {"epss_score": 0.00235, "epss_percentile": 0.46309}, "CVE-2022-32988": {"epss_score": 0.00197, "epss_percentile": 0.41908}, "CVE-2022-32990": {"epss_score": 0.00118, "epss_percentile": 0.31395}, "CVE-2022-32991": {"epss_score": 0.00257, "epss_percentile": 0.4894}, "CVE-2022-32992": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-32993": {"epss_score": 0.00355, "epss_percentile": 0.57326}, "CVE-2022-32994": {"epss_score": 0.00499, "epss_percentile": 0.65247}, "CVE-2022-32995": {"epss_score": 0.00434, "epss_percentile": 0.62289}, "CVE-2022-32996": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2022-32997": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2022-32998": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2022-32999": {"epss_score": 0.00439, "epss_percentile": 0.62577}, "CVE-2022-33000": {"epss_score": 0.00439, "epss_percentile": 0.62577}, "CVE-2022-33001": {"epss_score": 0.00439, "epss_percentile": 0.62577}, "CVE-2022-33002": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2022-33003": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2022-33004": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2022-33005": {"epss_score": 0.0024, "epss_percentile": 0.47182}, "CVE-2022-33007": {"epss_score": 0.00122, "epss_percentile": 0.32054}, "CVE-2022-33009": {"epss_score": 0.00334, "epss_percentile": 0.55735}, "CVE-2022-33011": {"epss_score": 0.00496, "epss_percentile": 0.65155}, "CVE-2022-33012": {"epss_score": 0.01567, "epss_percentile": 0.81075}, "CVE-2022-33021": {"epss_score": 0.00391, "epss_percentile": 0.59641}, "CVE-2022-33023": {"epss_score": 0.00166, "epss_percentile": 0.38178}, "CVE-2022-33024": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2022-33025": {"epss_score": 0.00123, "epss_percentile": 0.32209}, "CVE-2022-33026": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2022-33027": {"epss_score": 0.00169, "epss_percentile": 0.38527}, "CVE-2022-33028": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2022-33032": {"epss_score": 0.00169, "epss_percentile": 0.38527}, "CVE-2022-33033": {"epss_score": 0.00169, "epss_percentile": 0.38527}, "CVE-2022-33034": {"epss_score": 0.00179, "epss_percentile": 0.39765}, "CVE-2022-33035": {"epss_score": 0.00036, "epss_percentile": 0.10256}, "CVE-2022-33036": {"epss_score": 0.00077, "epss_percentile": 0.23305}, "CVE-2022-33037": {"epss_score": 0.00077, "epss_percentile": 0.23305}, "CVE-2022-33042": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-33043": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-33047": {"epss_score": 0.00459, "epss_percentile": 0.63496}, "CVE-2022-33048": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-33049": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-33055": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-33056": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-33057": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-33058": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-33059": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-33060": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-33061": {"epss_score": 0.00274, "epss_percentile": 0.50627}, "CVE-2022-33064": {"epss_score": 0.00023, "epss_percentile": 0.05428}, "CVE-2022-33065": {"epss_score": 0.00017, "epss_percentile": 0.03434}, "CVE-2022-33067": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2022-33068": {"epss_score": 0.00139, "epss_percentile": 0.34634}, "CVE-2022-33069": {"epss_score": 0.00138, "epss_percentile": 0.34499}, "CVE-2022-33070": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2022-33075": {"epss_score": 0.00187, "epss_percentile": 0.40792}, "CVE-2022-33077": {"epss_score": 0.00201, "epss_percentile": 0.4236}, "CVE-2022-33082": {"epss_score": 0.01094, "epss_percentile": 0.77492}, "CVE-2022-33085": {"epss_score": 0.02516, "epss_percentile": 0.84984}, "CVE-2022-33087": {"epss_score": 0.01218, "epss_percentile": 0.78601}, "CVE-2022-33092": {"epss_score": 0.00246, "epss_percentile": 0.47765}, "CVE-2022-33093": {"epss_score": 0.00246, "epss_percentile": 0.47765}, "CVE-2022-33094": {"epss_score": 0.00246, "epss_percentile": 0.47765}, "CVE-2022-33095": {"epss_score": 0.00246, "epss_percentile": 0.47765}, "CVE-2022-33096": {"epss_score": 0.00246, "epss_percentile": 0.47765}, "CVE-2022-33097": {"epss_score": 0.00246, "epss_percentile": 0.47765}, "CVE-2022-33098": {"epss_score": 0.00835, "epss_percentile": 0.74114}, "CVE-2022-33099": {"epss_score": 0.00268, "epss_percentile": 0.50101}, "CVE-2022-33103": {"epss_score": 0.00063, "epss_percentile": 0.20084}, "CVE-2022-33105": {"epss_score": 0.02852, "epss_percentile": 0.85831}, "CVE-2022-33106": {"epss_score": 0.00358, "epss_percentile": 0.57484}, "CVE-2022-33107": {"epss_score": 0.20613, "epss_percentile": 0.95385}, "CVE-2022-33108": {"epss_score": 0.00208, "epss_percentile": 0.43285}, "CVE-2022-33113": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-33114": {"epss_score": 0.00255, "epss_percentile": 0.48717}, "CVE-2022-33116": {"epss_score": 0.00313, "epss_percentile": 0.5405}, "CVE-2022-33119": {"epss_score": 0.02, "epss_percentile": 0.83214}, "CVE-2022-33121": {"epss_score": 0.00085, "epss_percentile": 0.25044}, "CVE-2022-33122": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2022-33124": {"epss_score": 0.00252, "epss_percentile": 0.48359}, "CVE-2022-33127": {"epss_score": 0.0054, "epss_percentile": 0.67002}, "CVE-2022-33128": {"epss_score": 0.00257, "epss_percentile": 0.48855}, "CVE-2022-33137": {"epss_score": 0.00329, "epss_percentile": 0.55305}, "CVE-2022-33138": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-33139": {"epss_score": 0.00409, "epss_percentile": 0.60787}, "CVE-2022-33140": {"epss_score": 0.0356, "epss_percentile": 0.87352}, "CVE-2022-33142": {"epss_score": 0.00689, "epss_percentile": 0.71224}, "CVE-2022-33146": {"epss_score": 0.00598, "epss_percentile": 0.68763}, "CVE-2022-33147": {"epss_score": 0.02434, "epss_percentile": 0.84733}, "CVE-2022-33148": {"epss_score": 0.02653, "epss_percentile": 0.85348}, "CVE-2022-33149": {"epss_score": 0.02653, "epss_percentile": 0.85348}, "CVE-2022-33150": {"epss_score": 0.014, "epss_percentile": 0.80001}, "CVE-2022-33151": {"epss_score": 0.00189, "epss_percentile": 0.40923}, "CVE-2022-33154": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-33155": {"epss_score": 0.00206, "epss_percentile": 0.42915}, "CVE-2022-33156": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-33157": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2022-33158": {"epss_score": 0.00077, "epss_percentile": 0.23442}, "CVE-2022-33159": {"epss_score": 0.00022, "epss_percentile": 0.05226}, "CVE-2022-33160": {"epss_score": 0.00032, "epss_percentile": 0.09041}, "CVE-2022-33161": {"epss_score": 0.00022, "epss_percentile": 0.05242}, "CVE-2022-33162": {"epss_score": 0.00124, "epss_percentile": 0.32396}, "CVE-2022-33163": {"epss_score": 0.00032, "epss_percentile": 0.08868}, "CVE-2022-33164": {"epss_score": 0.00037, "epss_percentile": 0.10637}, "CVE-2022-33165": {"epss_score": 0.00046, "epss_percentile": 0.1416}, "CVE-2022-33166": {"epss_score": 0.00061, "epss_percentile": 0.1942}, "CVE-2022-33167": {"epss_score": 0.00112, "epss_percentile": 0.30462}, "CVE-2022-33168": {"epss_score": 0.00054, "epss_percentile": 0.17248}, "CVE-2022-33169": {"epss_score": 0.00142, "epss_percentile": 0.35086}, "CVE-2022-33171": {"epss_score": 0.05712, "epss_percentile": 0.90142}, "CVE-2022-33172": {"epss_score": 0.0001, "epss_percentile": 0.00824}, "CVE-2022-33173": {"epss_score": 0.0051, "epss_percentile": 0.6579}, "CVE-2022-33174": {"epss_score": 0.81715, "epss_percentile": 0.99152}, "CVE-2022-33175": {"epss_score": 0.00554, "epss_percentile": 0.67447}, "CVE-2022-33176": {"epss_score": 0.00145, "epss_percentile": 0.35424}, "CVE-2022-33177": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-33178": {"epss_score": 0.01711, "epss_percentile": 0.81875}, "CVE-2022-33179": {"epss_score": 0.00101, "epss_percentile": 0.28653}, "CVE-2022-33180": {"epss_score": 0.00057, "epss_percentile": 0.18034}, "CVE-2022-33181": {"epss_score": 0.00057, "epss_percentile": 0.18034}, "CVE-2022-33182": {"epss_score": 0.00081, "epss_percentile": 0.24355}, "CVE-2022-33183": {"epss_score": 0.00728, "epss_percentile": 0.72114}, "CVE-2022-33184": {"epss_score": 0.00117, "epss_percentile": 0.31349}, "CVE-2022-33185": {"epss_score": 0.00217, "epss_percentile": 0.44249}, "CVE-2022-33186": {"epss_score": 0.01327, "epss_percentile": 0.79492}, "CVE-2022-33187": {"epss_score": 0.00335, "epss_percentile": 0.5586}, "CVE-2022-33189": {"epss_score": 0.00886, "epss_percentile": 0.74947}, "CVE-2022-33190": {"epss_score": 0.00064, "epss_percentile": 0.20152}, "CVE-2022-33191": {"epss_score": 0.0018, "epss_percentile": 0.39928}, "CVE-2022-33192": {"epss_score": 0.01341, "epss_percentile": 0.79585}, "CVE-2022-33193": {"epss_score": 0.01341, "epss_percentile": 0.79585}, "CVE-2022-33194": {"epss_score": 0.01341, "epss_percentile": 0.79585}, "CVE-2022-33195": {"epss_score": 0.01811, "epss_percentile": 0.82368}, "CVE-2022-33196": {"epss_score": 0.00029, "epss_percentile": 0.07687}, "CVE-2022-33198": {"epss_score": 0.37457, "epss_percentile": 0.97049}, "CVE-2022-33201": {"epss_score": 0.00099, "epss_percentile": 0.2834}, "CVE-2022-33202": {"epss_score": 0.00101, "epss_percentile": 0.28576}, "CVE-2022-33203": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2022-33204": {"epss_score": 0.01109, "epss_percentile": 0.77651}, "CVE-2022-33205": {"epss_score": 0.01109, "epss_percentile": 0.77651}, "CVE-2022-33206": {"epss_score": 0.01109, "epss_percentile": 0.77651}, "CVE-2022-33207": {"epss_score": 0.01109, "epss_percentile": 0.77651}, "CVE-2022-33208": {"epss_score": 0.00342, "epss_percentile": 0.56394}, "CVE-2022-33209": {"epss_score": 0.00117, "epss_percentile": 0.31226}, "CVE-2022-33210": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2022-33211": {"epss_score": 0.00153, "epss_percentile": 0.36523}, "CVE-2022-33213": {"epss_score": 0.00165, "epss_percentile": 0.38135}, "CVE-2022-33214": {"epss_score": 0.00038, "epss_percentile": 0.11399}, "CVE-2022-33216": {"epss_score": 0.00025, "epss_percentile": 0.06365}, "CVE-2022-33217": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2022-33218": {"epss_score": 0.00044, "epss_percentile": 0.1354}, "CVE-2022-33219": {"epss_score": 0.00098, "epss_percentile": 0.27672}, "CVE-2022-33220": {"epss_score": 0.00019, "epss_percentile": 0.04062}, "CVE-2022-33221": {"epss_score": 0.00036, "epss_percentile": 0.1044}, "CVE-2022-33222": {"epss_score": 0.00097, "epss_percentile": 0.275}, "CVE-2022-33223": {"epss_score": 0.00132, "epss_percentile": 0.33586}, "CVE-2022-33224": {"epss_score": 0.00036, "epss_percentile": 0.10399}, "CVE-2022-33225": {"epss_score": 0.00039, "epss_percentile": 0.11537}, "CVE-2022-33226": {"epss_score": 0.00036, "epss_percentile": 0.10399}, "CVE-2022-33227": {"epss_score": 0.00034, "epss_percentile": 0.09762}, "CVE-2022-33228": {"epss_score": 0.00085, "epss_percentile": 0.25106}, "CVE-2022-33229": {"epss_score": 0.00107, "epss_percentile": 0.29675}, "CVE-2022-33230": {"epss_score": 0.00034, "epss_percentile": 0.09762}, "CVE-2022-33231": {"epss_score": 0.00049, "epss_percentile": 0.15347}, "CVE-2022-33232": {"epss_score": 0.00071, "epss_percentile": 0.22188}, "CVE-2022-33233": {"epss_score": 0.00071, "epss_percentile": 0.22188}, "CVE-2022-33234": {"epss_score": 0.00273, "epss_percentile": 0.5044}, "CVE-2022-33235": {"epss_score": 0.0024, "epss_percentile": 0.46949}, "CVE-2022-33236": {"epss_score": 0.00335, "epss_percentile": 0.55866}, "CVE-2022-33237": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2022-33238": {"epss_score": 0.00359, "epss_percentile": 0.5755}, "CVE-2022-33239": {"epss_score": 0.00335, "epss_percentile": 0.55866}, "CVE-2022-33240": {"epss_score": 0.0004, "epss_percentile": 0.12067}, "CVE-2022-33242": {"epss_score": 0.00055, "epss_percentile": 0.17447}, "CVE-2022-33243": {"epss_score": 0.0006, "epss_percentile": 0.19229}, "CVE-2022-33244": {"epss_score": 0.00164, "epss_percentile": 0.37984}, "CVE-2022-33245": {"epss_score": 0.00037, "epss_percentile": 0.10887}, "CVE-2022-33246": {"epss_score": 0.00041, "epss_percentile": 0.12243}, "CVE-2022-33248": {"epss_score": 0.00093, "epss_percentile": 0.26678}, "CVE-2022-33250": {"epss_score": 0.00164, "epss_percentile": 0.37984}, "CVE-2022-33251": {"epss_score": 0.00145, "epss_percentile": 0.35523}, "CVE-2022-33252": {"epss_score": 0.00083, "epss_percentile": 0.24821}, "CVE-2022-33253": {"epss_score": 0.00149, "epss_percentile": 0.36002}, "CVE-2022-33254": {"epss_score": 0.00164, "epss_percentile": 0.37984}, "CVE-2022-33255": {"epss_score": 0.00107, "epss_percentile": 0.29675}, "CVE-2022-33256": {"epss_score": 0.0012, "epss_percentile": 0.31727}, "CVE-2022-33257": {"epss_score": 0.0005, "epss_percentile": 0.15871}, "CVE-2022-33258": {"epss_score": 0.00085, "epss_percentile": 0.25106}, "CVE-2022-33259": {"epss_score": 0.00153, "epss_percentile": 0.36523}, "CVE-2022-33260": {"epss_score": 0.00041, "epss_percentile": 0.12236}, "CVE-2022-33263": {"epss_score": 0.00033, "epss_percentile": 0.09185}, "CVE-2022-33264": {"epss_score": 0.00094, "epss_percentile": 0.27001}, "CVE-2022-33265": {"epss_score": 0.00145, "epss_percentile": 0.35497}, "CVE-2022-33266": {"epss_score": 0.00059, "epss_percentile": 0.18856}, "CVE-2022-33267": {"epss_score": 0.00034, "epss_percentile": 0.09762}, "CVE-2022-33268": {"epss_score": 0.00142, "epss_percentile": 0.3504}, "CVE-2022-33269": {"epss_score": 0.00057, "epss_percentile": 0.17995}, "CVE-2022-33270": {"epss_score": 0.00102, "epss_percentile": 0.28793}, "CVE-2022-33271": {"epss_score": 0.00122, "epss_percentile": 0.32101}, "CVE-2022-33272": {"epss_score": 0.00164, "epss_percentile": 0.37984}, "CVE-2022-33273": {"epss_score": 0.0003, "epss_percentile": 0.08158}, "CVE-2022-33274": {"epss_score": 0.00055, "epss_percentile": 0.17376}, "CVE-2022-33275": {"epss_score": 0.00044, "epss_percentile": 0.13647}, "CVE-2022-33276": {"epss_score": 0.00071, "epss_percentile": 0.22188}, "CVE-2022-33277": {"epss_score": 0.00071, "epss_percentile": 0.22188}, "CVE-2022-33278": {"epss_score": 0.0006, "epss_percentile": 0.19206}, "CVE-2022-33279": {"epss_score": 0.00256, "epss_percentile": 0.48766}, "CVE-2022-33280": {"epss_score": 0.00112, "epss_percentile": 0.30443}, "CVE-2022-33281": {"epss_score": 0.00023, "epss_percentile": 0.05347}, "CVE-2022-33282": {"epss_score": 0.00051, "epss_percentile": 0.16269}, "CVE-2022-33283": {"epss_score": 0.00122, "epss_percentile": 0.32101}, "CVE-2022-33284": {"epss_score": 0.00122, "epss_percentile": 0.32101}, "CVE-2022-33285": {"epss_score": 0.00211, "epss_percentile": 0.43675}, "CVE-2022-33286": {"epss_score": 0.00165, "epss_percentile": 0.38031}, "CVE-2022-33287": {"epss_score": 0.00085, "epss_percentile": 0.25106}, "CVE-2022-33288": {"epss_score": 0.00057, "epss_percentile": 0.17995}, "CVE-2022-33289": {"epss_score": 0.00043, "epss_percentile": 0.13321}, "CVE-2022-33290": {"epss_score": 0.00167, "epss_percentile": 0.38305}, "CVE-2022-33291": {"epss_score": 0.00085, "epss_percentile": 0.25106}, "CVE-2022-33292": {"epss_score": 0.00049, "epss_percentile": 0.15318}, "CVE-2022-33294": {"epss_score": 0.00132, "epss_percentile": 0.33586}, "CVE-2022-33295": {"epss_score": 0.00097, "epss_percentile": 0.275}, "CVE-2022-33296": {"epss_score": 0.00046, "epss_percentile": 0.14326}, "CVE-2022-33297": {"epss_score": 0.00036, "epss_percentile": 0.1044}, "CVE-2022-33298": {"epss_score": 0.0003, "epss_percentile": 0.08034}, "CVE-2022-33299": {"epss_score": 0.00167, "epss_percentile": 0.38305}, "CVE-2022-33300": {"epss_score": 0.00053, "epss_percentile": 0.16684}, "CVE-2022-33301": {"epss_score": 0.00029, "epss_percentile": 0.07858}, "CVE-2022-33302": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2022-33303": {"epss_score": 0.00052, "epss_percentile": 0.16603}, "CVE-2022-33304": {"epss_score": 0.00106, "epss_percentile": 0.29415}, "CVE-2022-33305": {"epss_score": 0.00106, "epss_percentile": 0.29415}, "CVE-2022-33306": {"epss_score": 0.00165, "epss_percentile": 0.38031}, "CVE-2022-33307": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2022-33309": {"epss_score": 0.00179, "epss_percentile": 0.39766}, "CVE-2022-33311": {"epss_score": 0.00177, "epss_percentile": 0.39503}, "CVE-2022-33312": {"epss_score": 0.00914, "epss_percentile": 0.75393}, "CVE-2022-33313": {"epss_score": 0.0352, "epss_percentile": 0.87285}, "CVE-2022-33314": {"epss_score": 0.00914, "epss_percentile": 0.75393}, "CVE-2022-33315": {"epss_score": 0.00097, "epss_percentile": 0.27468}, "CVE-2022-33316": {"epss_score": 0.00097, "epss_percentile": 0.27468}, "CVE-2022-33317": {"epss_score": 0.00069, "epss_percentile": 0.21468}, "CVE-2022-33318": {"epss_score": 0.01767, "epss_percentile": 0.82176}, "CVE-2022-33319": {"epss_score": 0.00354, "epss_percentile": 0.57204}, "CVE-2022-33320": {"epss_score": 0.00171, "epss_percentile": 0.38839}, "CVE-2022-33321": {"epss_score": 0.00755, "epss_percentile": 0.72721}, "CVE-2022-33322": {"epss_score": 0.01493, "epss_percentile": 0.80642}, "CVE-2022-33323": {"epss_score": 0.00506, "epss_percentile": 0.65637}, "CVE-2022-33324": {"epss_score": 0.01265, "epss_percentile": 0.79008}, "CVE-2022-33325": {"epss_score": 0.00914, "epss_percentile": 0.75393}, "CVE-2022-33326": {"epss_score": 0.0352, "epss_percentile": 0.87285}, "CVE-2022-33327": {"epss_score": 0.0352, "epss_percentile": 0.87285}, "CVE-2022-33328": {"epss_score": 0.0352, "epss_percentile": 0.87285}, "CVE-2022-33329": {"epss_score": 0.00914, "epss_percentile": 0.75393}, "CVE-2022-33631": {"epss_score": 0.01981, "epss_percentile": 0.83138}, "CVE-2022-33632": {"epss_score": 0.00636, "epss_percentile": 0.6987}, "CVE-2022-33633": {"epss_score": 0.06301, "epss_percentile": 0.90656}, "CVE-2022-33634": {"epss_score": 0.00692, "epss_percentile": 0.713}, "CVE-2022-33635": {"epss_score": 0.06886, "epss_percentile": 0.91092}, "CVE-2022-33636": {"epss_score": 0.00506, "epss_percentile": 0.65636}, "CVE-2022-33637": {"epss_score": 0.01195, "epss_percentile": 0.78432}, "CVE-2022-33638": {"epss_score": 0.01811, "epss_percentile": 0.82367}, "CVE-2022-33639": {"epss_score": 0.01811, "epss_percentile": 0.82367}, "CVE-2022-33640": {"epss_score": 0.01352, "epss_percentile": 0.79685}, "CVE-2022-33641": {"epss_score": 0.01153, "epss_percentile": 0.78058}, "CVE-2022-33642": {"epss_score": 0.04744, "epss_percentile": 0.89087}, "CVE-2022-33643": {"epss_score": 0.01153, "epss_percentile": 0.78058}, "CVE-2022-33644": {"epss_score": 0.00307, "epss_percentile": 0.53499}, "CVE-2022-33645": {"epss_score": 0.19014, "epss_percentile": 0.95111}, "CVE-2022-33646": {"epss_score": 0.00892, "epss_percentile": 0.75062}, "CVE-2022-33647": {"epss_score": 0.0095, "epss_percentile": 0.75858}, "CVE-2022-33648": {"epss_score": 0.02034, "epss_percentile": 0.83348}, "CVE-2022-33649": {"epss_score": 0.04608, "epss_percentile": 0.88911}, "CVE-2022-33650": {"epss_score": 0.17879, "epss_percentile": 0.94921}, "CVE-2022-33651": {"epss_score": 0.04744, "epss_percentile": 0.89087}, "CVE-2022-33652": {"epss_score": 0.18724, "epss_percentile": 0.95059}, "CVE-2022-33653": {"epss_score": 0.04744, "epss_percentile": 0.89087}, "CVE-2022-33654": {"epss_score": 0.04551, "epss_percentile": 0.8884}, "CVE-2022-33655": {"epss_score": 0.06009, "epss_percentile": 0.90401}, "CVE-2022-33656": {"epss_score": 0.01153, "epss_percentile": 0.78058}, "CVE-2022-33657": {"epss_score": 0.01153, "epss_percentile": 0.78058}, "CVE-2022-33658": {"epss_score": 0.18724, "epss_percentile": 0.95059}, "CVE-2022-33659": {"epss_score": 0.04744, "epss_percentile": 0.89087}, "CVE-2022-33660": {"epss_score": 0.04744, "epss_percentile": 0.89087}, "CVE-2022-33661": {"epss_score": 0.01153, "epss_percentile": 0.78058}, "CVE-2022-33662": {"epss_score": 0.00657, "epss_percentile": 0.70457}, "CVE-2022-33663": {"epss_score": 0.00657, "epss_percentile": 0.70457}, "CVE-2022-33664": {"epss_score": 0.04744, "epss_percentile": 0.89087}, "CVE-2022-33665": {"epss_score": 0.01153, "epss_percentile": 0.78058}, "CVE-2022-33666": {"epss_score": 0.00657, "epss_percentile": 0.70457}, "CVE-2022-33667": {"epss_score": 0.0123, "epss_percentile": 0.78723}, "CVE-2022-33668": {"epss_score": 0.04596, "epss_percentile": 0.88898}, "CVE-2022-33669": {"epss_score": 0.04744, "epss_percentile": 0.89087}, "CVE-2022-33670": {"epss_score": 0.00855, "epss_percentile": 0.74465}, "CVE-2022-33671": {"epss_score": 0.04744, "epss_percentile": 0.89087}, "CVE-2022-33672": {"epss_score": 0.01153, "epss_percentile": 0.78058}, "CVE-2022-33673": {"epss_score": 0.01153, "epss_percentile": 0.78058}, "CVE-2022-33674": {"epss_score": 0.00365, "epss_percentile": 0.57985}, "CVE-2022-33675": {"epss_score": 0.00398, "epss_percentile": 0.60083}, "CVE-2022-33676": {"epss_score": 0.06907, "epss_percentile": 0.9111}, "CVE-2022-33677": {"epss_score": 0.06212, "epss_percentile": 0.90571}, "CVE-2022-33678": {"epss_score": 0.06907, "epss_percentile": 0.9111}, "CVE-2022-33679": {"epss_score": 0.77878, "epss_percentile": 0.98957}, "CVE-2022-33680": {"epss_score": 0.01182, "epss_percentile": 0.78316}, "CVE-2022-33681": {"epss_score": 0.00074, "epss_percentile": 0.22713}, "CVE-2022-33682": {"epss_score": 0.00284, "epss_percentile": 0.51478}, "CVE-2022-33683": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-33684": {"epss_score": 0.00246, "epss_percentile": 0.47739}, "CVE-2022-33685": {"epss_score": 0.00018, "epss_percentile": 0.04044}, "CVE-2022-33686": {"epss_score": 0.00017, "epss_percentile": 0.03301}, "CVE-2022-33687": {"epss_score": 0.00016, "epss_percentile": 0.02646}, "CVE-2022-33688": {"epss_score": 0.00016, "epss_percentile": 0.02646}, "CVE-2022-33689": {"epss_score": 0.00018, "epss_percentile": 0.03524}, "CVE-2022-33690": {"epss_score": 0.00021, "epss_percentile": 0.04747}, "CVE-2022-33691": {"epss_score": 0.00012, "epss_percentile": 0.01392}, "CVE-2022-33692": {"epss_score": 0.00016, "epss_percentile": 0.02646}, "CVE-2022-33693": {"epss_score": 0.00017, "epss_percentile": 0.03301}, "CVE-2022-33694": {"epss_score": 0.00016, "epss_percentile": 0.02646}, "CVE-2022-33695": {"epss_score": 0.00016, "epss_percentile": 0.02908}, "CVE-2022-33696": {"epss_score": 0.00016, "epss_percentile": 0.02646}, "CVE-2022-33697": {"epss_score": 0.00016, "epss_percentile": 0.02646}, "CVE-2022-33698": {"epss_score": 0.00016, "epss_percentile": 0.02646}, "CVE-2022-33699": {"epss_score": 0.00017, "epss_percentile": 0.03301}, "CVE-2022-33700": {"epss_score": 0.00017, "epss_percentile": 0.03301}, "CVE-2022-33701": {"epss_score": 0.00039, "epss_percentile": 0.11788}, "CVE-2022-33702": {"epss_score": 0.00016, "epss_percentile": 0.02639}, "CVE-2022-33703": {"epss_score": 0.0001, "epss_percentile": 0.00761}, "CVE-2022-33704": {"epss_score": 0.00039, "epss_percentile": 0.11547}, "CVE-2022-33705": {"epss_score": 0.00122, "epss_percentile": 0.32042}, "CVE-2022-33706": {"epss_score": 0.00141, "epss_percentile": 0.34928}, "CVE-2022-33707": {"epss_score": 0.00284, "epss_percentile": 0.51425}, "CVE-2022-33708": {"epss_score": 0.00034, "epss_percentile": 0.09558}, "CVE-2022-33709": {"epss_score": 0.00034, "epss_percentile": 0.09558}, "CVE-2022-33710": {"epss_score": 0.00034, "epss_percentile": 0.09558}, "CVE-2022-33711": {"epss_score": 0.00028, "epss_percentile": 0.07248}, "CVE-2022-33712": {"epss_score": 0.00243, "epss_percentile": 0.47429}, "CVE-2022-33713": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2022-33714": {"epss_score": 0.00018, "epss_percentile": 0.03524}, "CVE-2022-33715": {"epss_score": 0.00018, "epss_percentile": 0.03622}, "CVE-2022-33716": {"epss_score": 0.00018, "epss_percentile": 0.03755}, "CVE-2022-33717": {"epss_score": 0.00017, "epss_percentile": 0.03128}, "CVE-2022-33718": {"epss_score": 0.00018, "epss_percentile": 0.03806}, "CVE-2022-33719": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2022-33720": {"epss_score": 0.00031, "epss_percentile": 0.0832}, "CVE-2022-33721": {"epss_score": 0.00071, "epss_percentile": 0.22009}, "CVE-2022-33722": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-33723": {"epss_score": 0.00046, "epss_percentile": 0.14429}, "CVE-2022-33724": {"epss_score": 9e-05, "epss_percentile": 0.00702}, "CVE-2022-33725": {"epss_score": 0.00067, "epss_percentile": 0.21063}, "CVE-2022-33726": {"epss_score": 0.0002, "epss_percentile": 0.0443}, "CVE-2022-33727": {"epss_score": 0.00046, "epss_percentile": 0.14429}, "CVE-2022-33728": {"epss_score": 0.00017, "epss_percentile": 0.03112}, "CVE-2022-33729": {"epss_score": 0.00019, "epss_percentile": 0.04094}, "CVE-2022-33730": {"epss_score": 0.00038, "epss_percentile": 0.11338}, "CVE-2022-33731": {"epss_score": 0.00015, "epss_percentile": 0.02503}, "CVE-2022-33732": {"epss_score": 0.00016, "epss_percentile": 0.03033}, "CVE-2022-33733": {"epss_score": 0.00054, "epss_percentile": 0.17352}, "CVE-2022-33734": {"epss_score": 0.00057, "epss_percentile": 0.18157}, "CVE-2022-33735": {"epss_score": 0.00042, "epss_percentile": 0.12727}, "CVE-2022-33736": {"epss_score": 0.00601, "epss_percentile": 0.68841}, "CVE-2022-33737": {"epss_score": 0.00342, "epss_percentile": 0.56366}, "CVE-2022-33738": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2022-33739": {"epss_score": 0.00338, "epss_percentile": 0.56161}, "CVE-2022-33740": {"epss_score": 0.00022, "epss_percentile": 0.0504}, "CVE-2022-33741": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2022-33742": {"epss_score": 0.00027, "epss_percentile": 0.07209}, "CVE-2022-33743": {"epss_score": 0.00027, "epss_percentile": 0.06956}, "CVE-2022-33744": {"epss_score": 0.00039, "epss_percentile": 0.11776}, "CVE-2022-33745": {"epss_score": 0.00091, "epss_percentile": 0.26262}, "CVE-2022-33746": {"epss_score": 0.00025, "epss_percentile": 0.06369}, "CVE-2022-33747": {"epss_score": 0.00026, "epss_percentile": 0.06478}, "CVE-2022-33748": {"epss_score": 0.00025, "epss_percentile": 0.06306}, "CVE-2022-33749": {"epss_score": 0.00263, "epss_percentile": 0.49486}, "CVE-2022-33750": {"epss_score": 0.01149, "epss_percentile": 0.78018}, "CVE-2022-33751": {"epss_score": 0.00288, "epss_percentile": 0.51947}, "CVE-2022-33752": {"epss_score": 0.01712, "epss_percentile": 0.81885}, "CVE-2022-33753": {"epss_score": 0.00511, "epss_percentile": 0.65827}, "CVE-2022-33754": {"epss_score": 0.01712, "epss_percentile": 0.81885}, "CVE-2022-33755": {"epss_score": 0.00212, "epss_percentile": 0.43778}, "CVE-2022-33756": {"epss_score": 0.00288, "epss_percentile": 0.51947}, "CVE-2022-33757": {"epss_score": 0.00246, "epss_percentile": 0.4776}, "CVE-2022-33859": {"epss_score": 0.00193, "epss_percentile": 0.41411}, "CVE-2022-33861": {"epss_score": 0.00037, "epss_percentile": 0.1086}, "CVE-2022-33862": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-33869": {"epss_score": 0.00645, "epss_percentile": 0.70104}, "CVE-2022-33870": {"epss_score": 0.00279, "epss_percentile": 0.50936}, "CVE-2022-33871": {"epss_score": 0.00298, "epss_percentile": 0.52806}, "CVE-2022-33872": {"epss_score": 0.03969, "epss_percentile": 0.88035}, "CVE-2022-33873": {"epss_score": 0.21647, "epss_percentile": 0.95543}, "CVE-2022-33874": {"epss_score": 0.03969, "epss_percentile": 0.88035}, "CVE-2022-33875": {"epss_score": 0.00813, "epss_percentile": 0.7376}, "CVE-2022-33876": {"epss_score": 0.00448, "epss_percentile": 0.63027}, "CVE-2022-33877": {"epss_score": 0.00034, "epss_percentile": 0.09551}, "CVE-2022-33878": {"epss_score": 0.00142, "epss_percentile": 0.35087}, "CVE-2022-33879": {"epss_score": 0.00031, "epss_percentile": 0.08438}, "CVE-2022-33880": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-33881": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-33882": {"epss_score": 0.01028, "epss_percentile": 0.76823}, "CVE-2022-33883": {"epss_score": 0.00059, "epss_percentile": 0.18677}, "CVE-2022-33884": {"epss_score": 0.0076, "epss_percentile": 0.72814}, "CVE-2022-33885": {"epss_score": 0.00116, "epss_percentile": 0.31198}, "CVE-2022-33886": {"epss_score": 0.00116, "epss_percentile": 0.31198}, "CVE-2022-33887": {"epss_score": 0.00116, "epss_percentile": 0.31198}, "CVE-2022-33888": {"epss_score": 0.00116, "epss_percentile": 0.31198}, "CVE-2022-33889": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-33890": {"epss_score": 0.00116, "epss_percentile": 0.31198}, "CVE-2022-33891": {"epss_score": 0.93513, "epss_percentile": 0.99813}, "CVE-2022-33892": {"epss_score": 0.00093, "epss_percentile": 0.26675}, "CVE-2022-33894": {"epss_score": 0.00053, "epss_percentile": 0.16853}, "CVE-2022-33896": {"epss_score": 0.00293, "epss_percentile": 0.52299}, "CVE-2022-33897": {"epss_score": 0.01005, "epss_percentile": 0.76536}, "CVE-2022-33898": {"epss_score": 0.00065, "epss_percentile": 0.2067}, "CVE-2022-33900": {"epss_score": 0.00746, "epss_percentile": 0.72545}, "CVE-2022-33901": {"epss_score": 0.1031, "epss_percentile": 0.92938}, "CVE-2022-33902": {"epss_score": 0.00124, "epss_percentile": 0.32364}, "CVE-2022-33903": {"epss_score": 0.00303, "epss_percentile": 0.53226}, "CVE-2022-33905": {"epss_score": 0.00091, "epss_percentile": 0.26258}, "CVE-2022-33906": {"epss_score": 0.00052, "epss_percentile": 0.16577}, "CVE-2022-33907": {"epss_score": 0.00052, "epss_percentile": 0.16577}, "CVE-2022-33908": {"epss_score": 0.00078, "epss_percentile": 0.236}, "CVE-2022-33909": {"epss_score": 0.00091, "epss_percentile": 0.26258}, "CVE-2022-33910": {"epss_score": 0.00251, "epss_percentile": 0.48333}, "CVE-2022-33911": {"epss_score": 0.00486, "epss_percentile": 0.64777}, "CVE-2022-33912": {"epss_score": 0.00029, "epss_percentile": 0.07945}, "CVE-2022-33913": {"epss_score": 0.0024, "epss_percentile": 0.46958}, "CVE-2022-33915": {"epss_score": 0.0007, "epss_percentile": 0.21746}, "CVE-2022-33916": {"epss_score": 0.00313, "epss_percentile": 0.54014}, "CVE-2022-33917": {"epss_score": 0.0103, "epss_percentile": 0.76842}, "CVE-2022-33918": {"epss_score": 0.00024, "epss_percentile": 0.05992}, "CVE-2022-33919": {"epss_score": 0.00057, "epss_percentile": 0.17992}, "CVE-2022-33920": {"epss_score": 0.00063, "epss_percentile": 0.19991}, "CVE-2022-33921": {"epss_score": 0.00063, "epss_percentile": 0.19991}, "CVE-2022-33922": {"epss_score": 0.00043, "epss_percentile": 0.13345}, "CVE-2022-33923": {"epss_score": 0.00305, "epss_percentile": 0.53387}, "CVE-2022-33924": {"epss_score": 0.00079, "epss_percentile": 0.23961}, "CVE-2022-33925": {"epss_score": 0.00209, "epss_percentile": 0.43397}, "CVE-2022-33926": {"epss_score": 0.00204, "epss_percentile": 0.42648}, "CVE-2022-33927": {"epss_score": 0.00252, "epss_percentile": 0.48356}, "CVE-2022-33928": {"epss_score": 0.00098, "epss_percentile": 0.27669}, "CVE-2022-33929": {"epss_score": 0.0084, "epss_percentile": 0.74199}, "CVE-2022-33930": {"epss_score": 0.00311, "epss_percentile": 0.53825}, "CVE-2022-33931": {"epss_score": 0.00239, "epss_percentile": 0.46865}, "CVE-2022-33932": {"epss_score": 0.00298, "epss_percentile": 0.52789}, "CVE-2022-33934": {"epss_score": 0.00131, "epss_percentile": 0.33476}, "CVE-2022-33935": {"epss_score": 0.00232, "epss_percentile": 0.4597}, "CVE-2022-33936": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2022-33937": {"epss_score": 0.0004, "epss_percentile": 0.12078}, "CVE-2022-33938": {"epss_score": 0.00261, "epss_percentile": 0.4927}, "CVE-2022-33939": {"epss_score": 0.00263, "epss_percentile": 0.49504}, "CVE-2022-33941": {"epss_score": 0.05225, "epss_percentile": 0.89632}, "CVE-2022-33942": {"epss_score": 0.00277, "epss_percentile": 0.50781}, "CVE-2022-33943": {"epss_score": 0.0018, "epss_percentile": 0.39928}, "CVE-2022-33944": {"epss_score": 0.00153, "epss_percentile": 0.36546}, "CVE-2022-33945": {"epss_score": 0.00065, "epss_percentile": 0.20613}, "CVE-2022-33946": {"epss_score": 0.00056, "epss_percentile": 0.17672}, "CVE-2022-33947": {"epss_score": 0.00828, "epss_percentile": 0.74002}, "CVE-2022-33948": {"epss_score": 0.00781, "epss_percentile": 0.73187}, "CVE-2022-33953": {"epss_score": 0.00049, "epss_percentile": 0.15377}, "CVE-2022-33954": {"epss_score": 0.0004, "epss_percentile": 0.11974}, "CVE-2022-33955": {"epss_score": 0.00253, "epss_percentile": 0.48495}, "CVE-2022-33959": {"epss_score": 0.00022, "epss_percentile": 0.05279}, "CVE-2022-33960": {"epss_score": 0.00513, "epss_percentile": 0.65906}, "CVE-2022-33961": {"epss_score": 0.00076, "epss_percentile": 0.2308}, "CVE-2022-33962": {"epss_score": 0.00068, "epss_percentile": 0.21232}, "CVE-2022-33963": {"epss_score": 0.00071, "epss_percentile": 0.22036}, "CVE-2022-33964": {"epss_score": 0.00202, "epss_percentile": 0.42405}, "CVE-2022-33965": {"epss_score": 0.39966, "epss_percentile": 0.97189}, "CVE-2022-33967": {"epss_score": 0.00114, "epss_percentile": 0.30844}, "CVE-2022-33968": {"epss_score": 0.00312, "epss_percentile": 0.53961}, "CVE-2022-33969": {"epss_score": 0.01027, "epss_percentile": 0.76805}, "CVE-2022-33970": {"epss_score": 0.01121, "epss_percentile": 0.77775}, "CVE-2022-33971": {"epss_score": 0.00108, "epss_percentile": 0.29808}, "CVE-2022-33972": {"epss_score": 0.00031, "epss_percentile": 0.08647}, "CVE-2022-33973": {"epss_score": 0.00126, "epss_percentile": 0.32778}, "CVE-2022-33974": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2022-33977": {"epss_score": 0.02125, "epss_percentile": 0.83691}, "CVE-2022-33978": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-33980": {"epss_score": 0.87662, "epss_percentile": 0.99437}, "CVE-2022-33981": {"epss_score": 0.00017, "epss_percentile": 0.03184}, "CVE-2022-33982": {"epss_score": 0.00052, "epss_percentile": 0.16577}, "CVE-2022-33983": {"epss_score": 0.00091, "epss_percentile": 0.26258}, "CVE-2022-33984": {"epss_score": 0.00082, "epss_percentile": 0.24572}, "CVE-2022-33985": {"epss_score": 0.00091, "epss_percentile": 0.26258}, "CVE-2022-33986": {"epss_score": 0.00093, "epss_percentile": 0.2675}, "CVE-2022-33987": {"epss_score": 0.00876, "epss_percentile": 0.74797}, "CVE-2022-33988": {"epss_score": 0.00358, "epss_percentile": 0.57519}, "CVE-2022-33989": {"epss_score": 0.00282, "epss_percentile": 0.51241}, "CVE-2022-33990": {"epss_score": 0.00285, "epss_percentile": 0.51671}, "CVE-2022-33991": {"epss_score": 0.00245, "epss_percentile": 0.47689}, "CVE-2022-33992": {"epss_score": 0.00282, "epss_percentile": 0.51241}, "CVE-2022-33993": {"epss_score": 0.00285, "epss_percentile": 0.51671}, "CVE-2022-33994": {"epss_score": 0.00274, "epss_percentile": 0.50514}, "CVE-2022-33995": {"epss_score": 0.00241, "epss_percentile": 0.47235}, "CVE-2022-33996": {"epss_score": 0.00266, "epss_percentile": 0.49918}, "CVE-2022-34000": {"epss_score": 0.00257, "epss_percentile": 0.48943}, "CVE-2022-34001": {"epss_score": 0.00214, "epss_percentile": 0.43981}, "CVE-2022-34002": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2022-34005": {"epss_score": 0.01603, "epss_percentile": 0.81278}, "CVE-2022-34006": {"epss_score": 0.00039, "epss_percentile": 0.11837}, "CVE-2022-34007": {"epss_score": 0.01149, "epss_percentile": 0.7802}, "CVE-2022-34008": {"epss_score": 0.00161, "epss_percentile": 0.376}, "CVE-2022-34009": {"epss_score": 0.00261, "epss_percentile": 0.49282}, "CVE-2022-34011": {"epss_score": 0.00131, "epss_percentile": 0.3341}, "CVE-2022-34012": {"epss_score": 0.00115, "epss_percentile": 0.30908}, "CVE-2022-34013": {"epss_score": 0.00131, "epss_percentile": 0.3341}, "CVE-2022-34020": {"epss_score": 0.00183, "epss_percentile": 0.40351}, "CVE-2022-34021": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-34022": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-34023": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-34024": {"epss_score": 0.00828, "epss_percentile": 0.73994}, "CVE-2022-34025": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2022-34026": {"epss_score": 0.01033, "epss_percentile": 0.76879}, "CVE-2022-34027": {"epss_score": 0.00259, "epss_percentile": 0.4907}, "CVE-2022-34028": {"epss_score": 0.00313, "epss_percentile": 0.54043}, "CVE-2022-34029": {"epss_score": 0.00371, "epss_percentile": 0.58381}, "CVE-2022-34030": {"epss_score": 0.0024, "epss_percentile": 0.46951}, "CVE-2022-34031": {"epss_score": 0.0024, "epss_percentile": 0.46951}, "CVE-2022-34032": {"epss_score": 0.00262, "epss_percentile": 0.49365}, "CVE-2022-34033": {"epss_score": 0.0015, "epss_percentile": 0.36054}, "CVE-2022-34035": {"epss_score": 0.0015, "epss_percentile": 0.36054}, "CVE-2022-34037": {"epss_score": 0.00582, "epss_percentile": 0.68298}, "CVE-2022-34038": {"epss_score": 0.00618, "epss_percentile": 0.69362}, "CVE-2022-34042": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-34043": {"epss_score": 0.00053, "epss_percentile": 0.16943}, "CVE-2022-34045": {"epss_score": 0.36265, "epss_percentile": 0.96965}, "CVE-2022-34046": {"epss_score": 0.57481, "epss_percentile": 0.98065}, "CVE-2022-34047": {"epss_score": 0.59183, "epss_percentile": 0.98154}, "CVE-2022-34048": {"epss_score": 0.049, "epss_percentile": 0.89273}, "CVE-2022-34049": {"epss_score": 0.15517, "epss_percentile": 0.94444}, "CVE-2022-34053": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2022-34054": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2022-34055": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2022-34056": {"epss_score": 0.00439, "epss_percentile": 0.62577}, "CVE-2022-34057": {"epss_score": 0.00646, "epss_percentile": 0.7013}, "CVE-2022-34059": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2022-34060": {"epss_score": 0.00439, "epss_percentile": 0.62577}, "CVE-2022-34061": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2022-34064": {"epss_score": 0.01078, "epss_percentile": 0.7735}, "CVE-2022-34065": {"epss_score": 0.00439, "epss_percentile": 0.62577}, "CVE-2022-34066": {"epss_score": 0.00734, "epss_percentile": 0.72235}, "CVE-2022-34067": {"epss_score": 0.00251, "epss_percentile": 0.48283}, "CVE-2022-34092": {"epss_score": 0.00395, "epss_percentile": 0.59812}, "CVE-2022-34093": {"epss_score": 0.05106, "epss_percentile": 0.89506}, "CVE-2022-34094": {"epss_score": 0.11346, "epss_percentile": 0.93318}, "CVE-2022-34100": {"epss_score": 0.00225, "epss_percentile": 0.4514}, "CVE-2022-34101": {"epss_score": 0.0014, "epss_percentile": 0.34751}, "CVE-2022-34102": {"epss_score": 0.00394, "epss_percentile": 0.59778}, "CVE-2022-34108": {"epss_score": 0.00063, "epss_percentile": 0.19995}, "CVE-2022-34109": {"epss_score": 0.00062, "epss_percentile": 0.1956}, "CVE-2022-34110": {"epss_score": 0.00063, "epss_percentile": 0.19955}, "CVE-2022-34112": {"epss_score": 0.00138, "epss_percentile": 0.34443}, "CVE-2022-34113": {"epss_score": 0.00294, "epss_percentile": 0.52412}, "CVE-2022-34114": {"epss_score": 0.00226, "epss_percentile": 0.45359}, "CVE-2022-34115": {"epss_score": 0.00344, "epss_percentile": 0.56528}, "CVE-2022-34120": {"epss_score": 0.035, "epss_percentile": 0.87245}, "CVE-2022-34121": {"epss_score": 0.27081, "epss_percentile": 0.96205}, "CVE-2022-34125": {"epss_score": 0.01688, "epss_percentile": 0.81764}, "CVE-2022-34126": {"epss_score": 0.00262, "epss_percentile": 0.49331}, "CVE-2022-34127": {"epss_score": 0.04444, "epss_percentile": 0.88696}, "CVE-2022-34128": {"epss_score": 0.14014, "epss_percentile": 0.94114}, "CVE-2022-34132": {"epss_score": 0.00706, "epss_percentile": 0.71611}, "CVE-2022-34133": {"epss_score": 0.00223, "epss_percentile": 0.44938}, "CVE-2022-34134": {"epss_score": 0.00118, "epss_percentile": 0.31462}, "CVE-2022-34138": {"epss_score": 0.00258, "epss_percentile": 0.48972}, "CVE-2022-34140": {"epss_score": 0.00483, "epss_percentile": 0.64615}, "CVE-2022-34144": {"epss_score": 0.00161, "epss_percentile": 0.37551}, "CVE-2022-34145": {"epss_score": 0.00276, "epss_percentile": 0.50741}, "CVE-2022-34146": {"epss_score": 0.00205, "epss_percentile": 0.42721}, "CVE-2022-34147": {"epss_score": 0.00053, "epss_percentile": 0.16853}, "CVE-2022-34148": {"epss_score": 0.00112, "epss_percentile": 0.30441}, "CVE-2022-34149": {"epss_score": 0.00817, "epss_percentile": 0.73844}, "CVE-2022-34150": {"epss_score": 0.00171, "epss_percentile": 0.38797}, "CVE-2022-34151": {"epss_score": 0.01166, "epss_percentile": 0.78182}, "CVE-2022-34152": {"epss_score": 0.00145, "epss_percentile": 0.35424}, "CVE-2022-34153": {"epss_score": 0.00118, "epss_percentile": 0.31413}, "CVE-2022-34154": {"epss_score": 0.01044, "epss_percentile": 0.77}, "CVE-2022-34155": {"epss_score": 0.00253, "epss_percentile": 0.48495}, "CVE-2022-34156": {"epss_score": 0.00099, "epss_percentile": 0.2838}, "CVE-2022-34157": {"epss_score": 0.00124, "epss_percentile": 0.32364}, "CVE-2022-34158": {"epss_score": 0.01087, "epss_percentile": 0.77432}, "CVE-2022-34159": {"epss_score": 0.00131, "epss_percentile": 0.33417}, "CVE-2022-34160": {"epss_score": 0.00299, "epss_percentile": 0.5287}, "CVE-2022-34161": {"epss_score": 0.0019, "epss_percentile": 0.41065}, "CVE-2022-34162": {"epss_score": 0.00265, "epss_percentile": 0.49819}, "CVE-2022-34163": {"epss_score": 0.00492, "epss_percentile": 0.65006}, "CVE-2022-34164": {"epss_score": 0.00118, "epss_percentile": 0.3144}, "CVE-2022-34165": {"epss_score": 0.00203, "epss_percentile": 0.4251}, "CVE-2022-34166": {"epss_score": 0.00428, "epss_percentile": 0.61941}, "CVE-2022-34167": {"epss_score": 0.00277, "epss_percentile": 0.50806}, "CVE-2022-34169": {"epss_score": 0.06658, "epss_percentile": 0.90922}, "CVE-2022-34170": {"epss_score": 0.05054, "epss_percentile": 0.89446}, "CVE-2022-34171": {"epss_score": 0.04332, "epss_percentile": 0.88559}, "CVE-2022-34172": {"epss_score": 0.06403, "epss_percentile": 0.90729}, "CVE-2022-34173": {"epss_score": 0.11821, "epss_percentile": 0.93486}, "CVE-2022-34174": {"epss_score": 0.01929, "epss_percentile": 0.82935}, "CVE-2022-34175": {"epss_score": 0.04136, "epss_percentile": 0.88308}, "CVE-2022-34176": {"epss_score": 0.58997, "epss_percentile": 0.98144}, "CVE-2022-34177": {"epss_score": 0.00092, "epss_percentile": 0.26532}, "CVE-2022-34178": {"epss_score": 0.16129, "epss_percentile": 0.94577}, "CVE-2022-34179": {"epss_score": 0.00307, "epss_percentile": 0.53492}, "CVE-2022-34180": {"epss_score": 0.00558, "epss_percentile": 0.67598}, "CVE-2022-34181": {"epss_score": 0.01342, "epss_percentile": 0.79596}, "CVE-2022-34182": {"epss_score": 0.28641, "epss_percentile": 0.96373}, "CVE-2022-34183": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-34184": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-34185": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-34186": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-34187": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-34188": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-34189": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-34190": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-34191": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-34192": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-34193": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-34194": {"epss_score": 0.2585, "epss_percentile": 0.96084}, "CVE-2022-34195": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-34196": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-34197": {"epss_score": 0.12295, "epss_percentile": 0.93624}, "CVE-2022-34198": {"epss_score": 0.31598, "epss_percentile": 0.96636}, "CVE-2022-34199": {"epss_score": 0.00403, "epss_percentile": 0.60323}, "CVE-2022-34200": {"epss_score": 0.00072, "epss_percentile": 0.22404}, "CVE-2022-34201": {"epss_score": 0.004, "epss_percentile": 0.60171}, "CVE-2022-34202": {"epss_score": 0.00403, "epss_percentile": 0.60323}, "CVE-2022-34203": {"epss_score": 0.00072, "epss_percentile": 0.22404}, "CVE-2022-34204": {"epss_score": 0.004, "epss_percentile": 0.60171}, "CVE-2022-34205": {"epss_score": 0.00064, "epss_percentile": 0.20168}, "CVE-2022-34206": {"epss_score": 0.004, "epss_percentile": 0.60171}, "CVE-2022-34207": {"epss_score": 0.00064, "epss_percentile": 0.20168}, "CVE-2022-34208": {"epss_score": 0.004, "epss_percentile": 0.60171}, "CVE-2022-34209": {"epss_score": 0.0007, "epss_percentile": 0.21662}, "CVE-2022-34210": {"epss_score": 0.004, "epss_percentile": 0.60171}, "CVE-2022-34211": {"epss_score": 0.00064, "epss_percentile": 0.20168}, "CVE-2022-34212": {"epss_score": 0.00508, "epss_percentile": 0.65704}, "CVE-2022-34213": {"epss_score": 0.00403, "epss_percentile": 0.60323}, "CVE-2022-34215": {"epss_score": 0.00226, "epss_percentile": 0.4536}, "CVE-2022-34216": {"epss_score": 0.01344, "epss_percentile": 0.79614}, "CVE-2022-34217": {"epss_score": 0.00417, "epss_percentile": 0.61227}, "CVE-2022-34218": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-34219": {"epss_score": 0.01344, "epss_percentile": 0.79614}, "CVE-2022-34220": {"epss_score": 0.01344, "epss_percentile": 0.79614}, "CVE-2022-34221": {"epss_score": 0.00235, "epss_percentile": 0.46336}, "CVE-2022-34222": {"epss_score": 0.00226, "epss_percentile": 0.4536}, "CVE-2022-34223": {"epss_score": 0.00993, "epss_percentile": 0.76415}, "CVE-2022-34224": {"epss_score": 0.0578, "epss_percentile": 0.90201}, "CVE-2022-34225": {"epss_score": 0.00993, "epss_percentile": 0.76415}, "CVE-2022-34226": {"epss_score": 0.00226, "epss_percentile": 0.4536}, "CVE-2022-34227": {"epss_score": 0.0578, "epss_percentile": 0.90201}, "CVE-2022-34228": {"epss_score": 0.00417, "epss_percentile": 0.61227}, "CVE-2022-34229": {"epss_score": 0.00993, "epss_percentile": 0.76415}, "CVE-2022-34230": {"epss_score": 0.01555, "epss_percentile": 0.81013}, "CVE-2022-34232": {"epss_score": 0.00361, "epss_percentile": 0.57736}, "CVE-2022-34233": {"epss_score": 0.00062, "epss_percentile": 0.19778}, "CVE-2022-34234": {"epss_score": 0.00361, "epss_percentile": 0.57736}, "CVE-2022-34235": {"epss_score": 0.00153, "epss_percentile": 0.36605}, "CVE-2022-34236": {"epss_score": 0.00172, "epss_percentile": 0.38986}, "CVE-2022-34237": {"epss_score": 0.00361, "epss_percentile": 0.57736}, "CVE-2022-34238": {"epss_score": 0.00023, "epss_percentile": 0.05407}, "CVE-2022-34239": {"epss_score": 0.00172, "epss_percentile": 0.38986}, "CVE-2022-34241": {"epss_score": 0.00414, "epss_percentile": 0.61098}, "CVE-2022-34242": {"epss_score": 0.00312, "epss_percentile": 0.54002}, "CVE-2022-34243": {"epss_score": 0.00334, "epss_percentile": 0.55704}, "CVE-2022-34244": {"epss_score": 0.00174, "epss_percentile": 0.39225}, "CVE-2022-34245": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2022-34246": {"epss_score": 0.00185, "epss_percentile": 0.40498}, "CVE-2022-34247": {"epss_score": 0.00176, "epss_percentile": 0.39382}, "CVE-2022-34248": {"epss_score": 0.00189, "epss_percentile": 0.40946}, "CVE-2022-34249": {"epss_score": 0.00264, "epss_percentile": 0.49581}, "CVE-2022-34250": {"epss_score": 0.00264, "epss_percentile": 0.49581}, "CVE-2022-34251": {"epss_score": 0.00255, "epss_percentile": 0.48661}, "CVE-2022-34252": {"epss_score": 0.00057, "epss_percentile": 0.1802}, "CVE-2022-34253": {"epss_score": 0.37194, "epss_percentile": 0.97026}, "CVE-2022-34254": {"epss_score": 0.00599, "epss_percentile": 0.68807}, "CVE-2022-34255": {"epss_score": 0.00512, "epss_percentile": 0.65862}, "CVE-2022-34256": {"epss_score": 0.00409, "epss_percentile": 0.60725}, "CVE-2022-34257": {"epss_score": 0.00769, "epss_percentile": 0.72989}, "CVE-2022-34258": {"epss_score": 0.16184, "epss_percentile": 0.9459}, "CVE-2022-34259": {"epss_score": 0.00232, "epss_percentile": 0.45874}, "CVE-2022-34260": {"epss_score": 0.00088, "epss_percentile": 0.25788}, "CVE-2022-34261": {"epss_score": 0.0022, "epss_percentile": 0.44579}, "CVE-2022-34262": {"epss_score": 0.0022, "epss_percentile": 0.44579}, "CVE-2022-34263": {"epss_score": 0.00246, "epss_percentile": 0.47744}, "CVE-2022-34264": {"epss_score": 0.0022, "epss_percentile": 0.44579}, "CVE-2022-34265": {"epss_score": 0.92734, "epss_percentile": 0.9974}, "CVE-2022-34266": {"epss_score": 0.00049, "epss_percentile": 0.15633}, "CVE-2022-34267": {"epss_score": 0.73904, "epss_percentile": 0.98776}, "CVE-2022-34268": {"epss_score": 0.0016, "epss_percentile": 0.3745}, "CVE-2022-34269": {"epss_score": 0.03333, "epss_percentile": 0.8693}, "CVE-2022-34270": {"epss_score": 0.00208, "epss_percentile": 0.4321}, "CVE-2022-34271": {"epss_score": 0.00501, "epss_percentile": 0.65347}, "CVE-2022-34272": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34273": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34274": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34275": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34276": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34277": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34278": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34279": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34280": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34281": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34282": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2022-34283": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2022-34284": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34285": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2022-34286": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34287": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2022-34288": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2022-34289": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34290": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2022-34291": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2022-34292": {"epss_score": 0.00043, "epss_percentile": 0.13074}, "CVE-2022-34293": {"epss_score": 0.00962, "epss_percentile": 0.75986}, "CVE-2022-34294": {"epss_score": 0.00745, "epss_percentile": 0.72525}, "CVE-2022-34295": {"epss_score": 0.00365, "epss_percentile": 0.57991}, "CVE-2022-34296": {"epss_score": 0.00173, "epss_percentile": 0.39108}, "CVE-2022-34297": {"epss_score": 0.00215, "epss_percentile": 0.44072}, "CVE-2022-34298": {"epss_score": 0.4507, "epss_percentile": 0.9747}, "CVE-2022-34299": {"epss_score": 0.00227, "epss_percentile": 0.45458}, "CVE-2022-34300": {"epss_score": 0.01288, "epss_percentile": 0.79206}, "CVE-2022-34301": {"epss_score": 0.00087, "epss_percentile": 0.25566}, "CVE-2022-34302": {"epss_score": 0.0016, "epss_percentile": 0.37484}, "CVE-2022-34303": {"epss_score": 0.00078, "epss_percentile": 0.23786}, "CVE-2022-34305": {"epss_score": 0.21613, "epss_percentile": 0.9554}, "CVE-2022-34306": {"epss_score": 0.00414, "epss_percentile": 0.61037}, "CVE-2022-34307": {"epss_score": 0.00187, "epss_percentile": 0.4071}, "CVE-2022-34308": {"epss_score": 0.00142, "epss_percentile": 0.35081}, "CVE-2022-34309": {"epss_score": 0.00033, "epss_percentile": 0.09411}, "CVE-2022-34310": {"epss_score": 0.00036, "epss_percentile": 0.10608}, "CVE-2022-34311": {"epss_score": 0.00034, "epss_percentile": 0.09438}, "CVE-2022-34312": {"epss_score": 0.00071, "epss_percentile": 0.22118}, "CVE-2022-34313": {"epss_score": 0.00248, "epss_percentile": 0.47985}, "CVE-2022-34314": {"epss_score": 0.00054, "epss_percentile": 0.17314}, "CVE-2022-34315": {"epss_score": 0.00789, "epss_percentile": 0.73349}, "CVE-2022-34316": {"epss_score": 0.00412, "epss_percentile": 0.60938}, "CVE-2022-34317": {"epss_score": 0.00647, "epss_percentile": 0.70181}, "CVE-2022-34318": {"epss_score": 0.00151, "epss_percentile": 0.3633}, "CVE-2022-34319": {"epss_score": 0.00158, "epss_percentile": 0.37218}, "CVE-2022-34320": {"epss_score": 0.00196, "epss_percentile": 0.41738}, "CVE-2022-34321": {"epss_score": 0.0004, "epss_percentile": 0.11941}, "CVE-2022-34322": {"epss_score": 0.00613, "epss_percentile": 0.6924}, "CVE-2022-34323": {"epss_score": 0.00392, "epss_percentile": 0.59652}, "CVE-2022-34324": {"epss_score": 0.02773, "epss_percentile": 0.85629}, "CVE-2022-34325": {"epss_score": 0.00091, "epss_percentile": 0.26258}, "CVE-2022-34326": {"epss_score": 0.00468, "epss_percentile": 0.63905}, "CVE-2022-34328": {"epss_score": 0.01813, "epss_percentile": 0.82375}, "CVE-2022-34329": {"epss_score": 0.00412, "epss_percentile": 0.60938}, "CVE-2022-34330": {"epss_score": 0.00524, "epss_percentile": 0.66323}, "CVE-2022-34331": {"epss_score": 0.00192, "epss_percentile": 0.41327}, "CVE-2022-34333": {"epss_score": 0.00077, "epss_percentile": 0.23441}, "CVE-2022-34334": {"epss_score": 0.00097, "epss_percentile": 0.27559}, "CVE-2022-34335": {"epss_score": 0.001, "epss_percentile": 0.28465}, "CVE-2022-34336": {"epss_score": 0.00243, "epss_percentile": 0.47476}, "CVE-2022-34338": {"epss_score": 0.0013, "epss_percentile": 0.33326}, "CVE-2022-34339": {"epss_score": 0.00201, "epss_percentile": 0.4238}, "CVE-2022-34344": {"epss_score": 0.00209, "epss_percentile": 0.43329}, "CVE-2022-34345": {"epss_score": 0.0008, "epss_percentile": 0.24154}, "CVE-2022-34346": {"epss_score": 0.00093, "epss_percentile": 0.26633}, "CVE-2022-34347": {"epss_score": 0.00104, "epss_percentile": 0.29139}, "CVE-2022-34348": {"epss_score": 0.00418, "epss_percentile": 0.61295}, "CVE-2022-34350": {"epss_score": 0.00039, "epss_percentile": 0.11701}, "CVE-2022-34351": {"epss_score": 0.00045, "epss_percentile": 0.13887}, "CVE-2022-34352": {"epss_score": 0.00064, "epss_percentile": 0.20383}, "CVE-2022-34354": {"epss_score": 0.00042, "epss_percentile": 0.12651}, "CVE-2022-34355": {"epss_score": 0.00021, "epss_percentile": 0.04773}, "CVE-2022-34356": {"epss_score": 0.00118, "epss_percentile": 0.314}, "CVE-2022-34357": {"epss_score": 0.00072, "epss_percentile": 0.22331}, "CVE-2022-34358": {"epss_score": 0.00235, "epss_percentile": 0.46224}, "CVE-2022-34361": {"epss_score": 0.00168, "epss_percentile": 0.38421}, "CVE-2022-34362": {"epss_score": 0.00171, "epss_percentile": 0.38809}, "CVE-2022-34364": {"epss_score": 0.00046, "epss_percentile": 0.1431}, "CVE-2022-34365": {"epss_score": 0.00432, "epss_percentile": 0.6216}, "CVE-2022-34366": {"epss_score": 0.00191, "epss_percentile": 0.41177}, "CVE-2022-34367": {"epss_score": 0.00216, "epss_percentile": 0.44219}, "CVE-2022-34368": {"epss_score": 0.00099, "epss_percentile": 0.27857}, "CVE-2022-34369": {"epss_score": 0.00388, "epss_percentile": 0.59348}, "CVE-2022-34371": {"epss_score": 0.00479, "epss_percentile": 0.64439}, "CVE-2022-34372": {"epss_score": 0.01857, "epss_percentile": 0.82575}, "CVE-2022-34373": {"epss_score": 0.00049, "epss_percentile": 0.15326}, "CVE-2022-34374": {"epss_score": 0.04896, "epss_percentile": 0.8927}, "CVE-2022-34375": {"epss_score": 0.00392, "epss_percentile": 0.59654}, "CVE-2022-34376": {"epss_score": 0.00023, "epss_percentile": 0.055}, "CVE-2022-34377": {"epss_score": 0.00025, "epss_percentile": 0.06231}, "CVE-2022-34378": {"epss_score": 0.00046, "epss_percentile": 0.14181}, "CVE-2022-34379": {"epss_score": 0.01413, "epss_percentile": 0.80123}, "CVE-2022-34380": {"epss_score": 0.00049, "epss_percentile": 0.15349}, "CVE-2022-34381": {"epss_score": 0.00631, "epss_percentile": 0.69721}, "CVE-2022-34382": {"epss_score": 0.0005, "epss_percentile": 0.15928}, "CVE-2022-34383": {"epss_score": 0.00475, "epss_percentile": 0.64241}, "CVE-2022-34384": {"epss_score": 0.00101, "epss_percentile": 0.28628}, "CVE-2022-34385": {"epss_score": 0.00045, "epss_percentile": 0.13754}, "CVE-2022-34386": {"epss_score": 0.00077, "epss_percentile": 0.2337}, "CVE-2022-34387": {"epss_score": 0.00036, "epss_percentile": 0.10408}, "CVE-2022-34388": {"epss_score": 0.00049, "epss_percentile": 0.15606}, "CVE-2022-34389": {"epss_score": 0.00045, "epss_percentile": 0.13993}, "CVE-2022-34390": {"epss_score": 0.00049, "epss_percentile": 0.15572}, "CVE-2022-34391": {"epss_score": 0.00049, "epss_percentile": 0.15572}, "CVE-2022-34392": {"epss_score": 0.00077, "epss_percentile": 0.2337}, "CVE-2022-34393": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2022-34394": {"epss_score": 0.00114, "epss_percentile": 0.30827}, "CVE-2022-34396": {"epss_score": 0.00045, "epss_percentile": 0.14051}, "CVE-2022-34397": {"epss_score": 0.0002, "epss_percentile": 0.04532}, "CVE-2022-34398": {"epss_score": 0.00048, "epss_percentile": 0.14997}, "CVE-2022-34399": {"epss_score": 0.00051, "epss_percentile": 0.16156}, "CVE-2022-34400": {"epss_score": 0.00047, "epss_percentile": 0.14809}, "CVE-2022-34401": {"epss_score": 0.0004, "epss_percentile": 0.12167}, "CVE-2022-34402": {"epss_score": 0.00254, "epss_percentile": 0.48554}, "CVE-2022-34403": {"epss_score": 0.00042, "epss_percentile": 0.12702}, "CVE-2022-34404": {"epss_score": 0.0005, "epss_percentile": 0.15938}, "CVE-2022-34405": {"epss_score": 0.00117, "epss_percentile": 0.3124}, "CVE-2022-34406": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34407": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34408": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34409": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34410": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34411": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34412": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34413": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34414": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34415": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34416": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34417": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34418": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34419": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34420": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34421": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34422": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34423": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2022-34424": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-34425": {"epss_score": 0.00491, "epss_percentile": 0.64953}, "CVE-2022-34426": {"epss_score": 0.04402, "epss_percentile": 0.88647}, "CVE-2022-34427": {"epss_score": 0.03449, "epss_percentile": 0.87161}, "CVE-2022-34428": {"epss_score": 0.00295, "epss_percentile": 0.52498}, "CVE-2022-34429": {"epss_score": 0.00067, "epss_percentile": 0.21019}, "CVE-2022-34430": {"epss_score": 0.00196, "epss_percentile": 0.41798}, "CVE-2022-34431": {"epss_score": 0.00195, "epss_percentile": 0.41673}, "CVE-2022-34432": {"epss_score": 0.00468, "epss_percentile": 0.63871}, "CVE-2022-34434": {"epss_score": 0.00049, "epss_percentile": 0.15559}, "CVE-2022-34435": {"epss_score": 0.00042, "epss_percentile": 0.12744}, "CVE-2022-34436": {"epss_score": 0.00042, "epss_percentile": 0.12744}, "CVE-2022-34437": {"epss_score": 0.00403, "epss_percentile": 0.60389}, "CVE-2022-34438": {"epss_score": 0.00039, "epss_percentile": 0.1147}, "CVE-2022-34439": {"epss_score": 0.01034, "epss_percentile": 0.76883}, "CVE-2022-34440": {"epss_score": 0.00173, "epss_percentile": 0.39093}, "CVE-2022-34441": {"epss_score": 0.0009, "epss_percentile": 0.26129}, "CVE-2022-34442": {"epss_score": 0.00076, "epss_percentile": 0.23241}, "CVE-2022-34443": {"epss_score": 0.00046, "epss_percentile": 0.14466}, "CVE-2022-34444": {"epss_score": 0.00118, "epss_percentile": 0.31469}, "CVE-2022-34445": {"epss_score": 0.0003, "epss_percentile": 0.08059}, "CVE-2022-34446": {"epss_score": 0.00056, "epss_percentile": 0.17911}, "CVE-2022-34447": {"epss_score": 0.00649, "epss_percentile": 0.70239}, "CVE-2022-34448": {"epss_score": 0.00294, "epss_percentile": 0.52401}, "CVE-2022-34449": {"epss_score": 0.00046, "epss_percentile": 0.14357}, "CVE-2022-34450": {"epss_score": 0.00071, "epss_percentile": 0.22033}, "CVE-2022-34451": {"epss_score": 0.00408, "epss_percentile": 0.60641}, "CVE-2022-34452": {"epss_score": 0.00218, "epss_percentile": 0.44387}, "CVE-2022-34453": {"epss_score": 0.00122, "epss_percentile": 0.32058}, "CVE-2022-34454": {"epss_score": 0.00067, "epss_percentile": 0.21123}, "CVE-2022-34456": {"epss_score": 0.00681, "epss_percentile": 0.71043}, "CVE-2022-34457": {"epss_score": 0.00058, "epss_percentile": 0.18545}, "CVE-2022-34458": {"epss_score": 0.00061, "epss_percentile": 0.19469}, "CVE-2022-34459": {"epss_score": 0.00039, "epss_percentile": 0.11702}, "CVE-2022-34460": {"epss_score": 0.00025, "epss_percentile": 0.06207}, "CVE-2022-34462": {"epss_score": 0.00061, "epss_percentile": 0.19531}, "CVE-2022-34464": {"epss_score": 0.00166, "epss_percentile": 0.38167}, "CVE-2022-34465": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34466": {"epss_score": 0.00707, "epss_percentile": 0.71648}, "CVE-2022-34467": {"epss_score": 0.00437, "epss_percentile": 0.62525}, "CVE-2022-34468": {"epss_score": 0.0014, "epss_percentile": 0.34738}, "CVE-2022-34469": {"epss_score": 0.00062, "epss_percentile": 0.19653}, "CVE-2022-34470": {"epss_score": 0.00201, "epss_percentile": 0.42325}, "CVE-2022-34471": {"epss_score": 0.00174, "epss_percentile": 0.39188}, "CVE-2022-34472": {"epss_score": 0.00171, "epss_percentile": 0.38891}, "CVE-2022-34473": {"epss_score": 0.00542, "epss_percentile": 0.67082}, "CVE-2022-34474": {"epss_score": 0.00238, "epss_percentile": 0.46772}, "CVE-2022-34475": {"epss_score": 0.00531, "epss_percentile": 0.66651}, "CVE-2022-34476": {"epss_score": 0.00588, "epss_percentile": 0.68489}, "CVE-2022-34477": {"epss_score": 0.00353, "epss_percentile": 0.57201}, "CVE-2022-34478": {"epss_score": 0.00161, "epss_percentile": 0.37553}, "CVE-2022-34479": {"epss_score": 0.0012, "epss_percentile": 0.31784}, "CVE-2022-34480": {"epss_score": 0.00312, "epss_percentile": 0.53944}, "CVE-2022-34481": {"epss_score": 0.00199, "epss_percentile": 0.42133}, "CVE-2022-34482": {"epss_score": 0.00386, "epss_percentile": 0.59241}, "CVE-2022-34483": {"epss_score": 0.00522, "epss_percentile": 0.66252}, "CVE-2022-34484": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2022-34485": {"epss_score": 0.00452, "epss_percentile": 0.6319}, "CVE-2022-34486": {"epss_score": 0.01286, "epss_percentile": 0.79186}, "CVE-2022-34487": {"epss_score": 0.52347, "epss_percentile": 0.97821}, "CVE-2022-34488": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2022-34494": {"epss_score": 0.00103, "epss_percentile": 0.28989}, "CVE-2022-34495": {"epss_score": 0.00093, "epss_percentile": 0.26707}, "CVE-2022-34496": {"epss_score": 0.00344, "epss_percentile": 0.56528}, "CVE-2022-34500": {"epss_score": 0.00736, "epss_percentile": 0.72309}, "CVE-2022-34501": {"epss_score": 0.00505, "epss_percentile": 0.65589}, "CVE-2022-34502": {"epss_score": 0.00142, "epss_percentile": 0.35034}, "CVE-2022-34503": {"epss_score": 0.00376, "epss_percentile": 0.58646}, "CVE-2022-34509": {"epss_score": 0.00736, "epss_percentile": 0.72309}, "CVE-2022-34520": {"epss_score": 0.00132, "epss_percentile": 0.33509}, "CVE-2022-34526": {"epss_score": 0.00193, "epss_percentile": 0.41404}, "CVE-2022-34527": {"epss_score": 0.24858, "epss_percentile": 0.95959}, "CVE-2022-34528": {"epss_score": 0.00956, "epss_percentile": 0.75927}, "CVE-2022-34529": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2022-34530": {"epss_score": 0.00195, "epss_percentile": 0.41662}, "CVE-2022-34531": {"epss_score": 0.13892, "epss_percentile": 0.94087}, "CVE-2022-34534": {"epss_score": 0.28876, "epss_percentile": 0.96396}, "CVE-2022-34535": {"epss_score": 0.00586, "epss_percentile": 0.68455}, "CVE-2022-34536": {"epss_score": 0.00265, "epss_percentile": 0.49825}, "CVE-2022-34537": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-34538": {"epss_score": 0.01508, "epss_percentile": 0.80759}, "CVE-2022-34539": {"epss_score": 0.03694, "epss_percentile": 0.87582}, "CVE-2022-34540": {"epss_score": 0.03694, "epss_percentile": 0.87582}, "CVE-2022-34549": {"epss_score": 0.00526, "epss_percentile": 0.66406}, "CVE-2022-34550": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-34551": {"epss_score": 0.00336, "epss_percentile": 0.55928}, "CVE-2022-34555": {"epss_score": 0.01635, "epss_percentile": 0.81471}, "CVE-2022-34556": {"epss_score": 0.0015, "epss_percentile": 0.3615}, "CVE-2022-34557": {"epss_score": 0.00243, "epss_percentile": 0.47514}, "CVE-2022-34558": {"epss_score": 0.0076, "epss_percentile": 0.72802}, "CVE-2022-34560": {"epss_score": 0.00137, "epss_percentile": 0.34325}, "CVE-2022-34561": {"epss_score": 0.00106, "epss_percentile": 0.29405}, "CVE-2022-34562": {"epss_score": 0.0019, "epss_percentile": 0.41141}, "CVE-2022-34567": {"epss_score": 0.00878, "epss_percentile": 0.74829}, "CVE-2022-34568": {"epss_score": 0.00078, "epss_percentile": 0.23564}, "CVE-2022-34570": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2022-34571": {"epss_score": 0.0015, "epss_percentile": 0.36122}, "CVE-2022-34572": {"epss_score": 0.00077, "epss_percentile": 0.23455}, "CVE-2022-34573": {"epss_score": 0.00077, "epss_percentile": 0.23455}, "CVE-2022-34574": {"epss_score": 0.00077, "epss_percentile": 0.23455}, "CVE-2022-34575": {"epss_score": 0.00077, "epss_percentile": 0.23455}, "CVE-2022-34576": {"epss_score": 0.33416, "epss_percentile": 0.96772}, "CVE-2022-34577": {"epss_score": 0.02169, "epss_percentile": 0.83863}, "CVE-2022-34578": {"epss_score": 0.00427, "epss_percentile": 0.61775}, "CVE-2022-34580": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-34586": {"epss_score": 0.00243, "epss_percentile": 0.47514}, "CVE-2022-34588": {"epss_score": 0.00226, "epss_percentile": 0.45359}, "CVE-2022-34590": {"epss_score": 0.03459, "epss_percentile": 0.87177}, "CVE-2022-34592": {"epss_score": 0.18001, "epss_percentile": 0.94942}, "CVE-2022-34593": {"epss_score": 0.00251, "epss_percentile": 0.48286}, "CVE-2022-34594": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-34595": {"epss_score": 0.17859, "epss_percentile": 0.94918}, "CVE-2022-34596": {"epss_score": 0.17859, "epss_percentile": 0.94918}, "CVE-2022-34597": {"epss_score": 0.0591, "epss_percentile": 0.90315}, "CVE-2022-34598": {"epss_score": 0.843, "epss_percentile": 0.99283}, "CVE-2022-34599": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-34600": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-34601": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-34602": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-34603": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-34604": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-34605": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-34606": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-34607": {"epss_score": 0.00598, "epss_percentile": 0.68771}, "CVE-2022-34608": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-34609": {"epss_score": 0.00208, "epss_percentile": 0.43305}, "CVE-2022-34610": {"epss_score": 0.00208, "epss_percentile": 0.43305}, "CVE-2022-34611": {"epss_score": 0.00267, "epss_percentile": 0.50005}, "CVE-2022-34612": {"epss_score": 0.00041, "epss_percentile": 0.12301}, "CVE-2022-34613": {"epss_score": 0.01769, "epss_percentile": 0.82186}, "CVE-2022-34615": {"epss_score": 0.00607, "epss_percentile": 0.69047}, "CVE-2022-34618": {"epss_score": 0.00527, "epss_percentile": 0.66524}, "CVE-2022-34619": {"epss_score": 0.00614, "epss_percentile": 0.69282}, "CVE-2022-34621": {"epss_score": 0.00368, "epss_percentile": 0.58194}, "CVE-2022-34624": {"epss_score": 0.0027, "epss_percentile": 0.50237}, "CVE-2022-34625": {"epss_score": 0.0102, "epss_percentile": 0.76742}, "CVE-2022-34632": {"epss_score": 0.0015, "epss_percentile": 0.3608}, "CVE-2022-34633": {"epss_score": 0.00045, "epss_percentile": 0.13902}, "CVE-2022-34634": {"epss_score": 0.00045, "epss_percentile": 0.13902}, "CVE-2022-34635": {"epss_score": 0.00344, "epss_percentile": 0.56528}, "CVE-2022-34636": {"epss_score": 0.00045, "epss_percentile": 0.13902}, "CVE-2022-34637": {"epss_score": 0.00045, "epss_percentile": 0.13902}, "CVE-2022-34639": {"epss_score": 0.00045, "epss_percentile": 0.13902}, "CVE-2022-34640": {"epss_score": 0.00045, "epss_percentile": 0.13902}, "CVE-2022-34641": {"epss_score": 0.00082, "epss_percentile": 0.24429}, "CVE-2022-34642": {"epss_score": 0.00045, "epss_percentile": 0.13902}, "CVE-2022-34643": {"epss_score": 0.00045, "epss_percentile": 0.13902}, "CVE-2022-34648": {"epss_score": 0.00192, "epss_percentile": 0.41357}, "CVE-2022-34650": {"epss_score": 0.0018, "epss_percentile": 0.39928}, "CVE-2022-34651": {"epss_score": 0.00753, "epss_percentile": 0.72673}, "CVE-2022-34652": {"epss_score": 0.02371, "epss_percentile": 0.84526}, "CVE-2022-34654": {"epss_score": 0.00106, "epss_percentile": 0.29524}, "CVE-2022-34655": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2022-34656": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2022-34657": {"epss_score": 0.0003, "epss_percentile": 0.08018}, "CVE-2022-34658": {"epss_score": 0.00197, "epss_percentile": 0.41898}, "CVE-2022-34659": {"epss_score": 0.0034, "epss_percentile": 0.56265}, "CVE-2022-34660": {"epss_score": 0.00857, "epss_percentile": 0.74492}, "CVE-2022-34661": {"epss_score": 0.00415, "epss_percentile": 0.61122}, "CVE-2022-34662": {"epss_score": 0.00995, "epss_percentile": 0.76439}, "CVE-2022-34663": {"epss_score": 0.00478, "epss_percentile": 0.64395}, "CVE-2022-34665": {"epss_score": 0.00131, "epss_percentile": 0.33346}, "CVE-2022-34666": {"epss_score": 0.00051, "epss_percentile": 0.16189}, "CVE-2022-34667": {"epss_score": 0.00095, "epss_percentile": 0.2716}, "CVE-2022-34668": {"epss_score": 0.27087, "epss_percentile": 0.96206}, "CVE-2022-34669": {"epss_score": 0.00121, "epss_percentile": 0.31839}, "CVE-2022-34670": {"epss_score": 0.00085, "epss_percentile": 0.251}, "CVE-2022-34671": {"epss_score": 0.00552, "epss_percentile": 0.67395}, "CVE-2022-34672": {"epss_score": 0.00117, "epss_percentile": 0.3124}, "CVE-2022-34673": {"epss_score": 0.0005, "epss_percentile": 0.15834}, "CVE-2022-34674": {"epss_score": 0.00089, "epss_percentile": 0.25913}, "CVE-2022-34675": {"epss_score": 0.00086, "epss_percentile": 0.25324}, "CVE-2022-34676": {"epss_score": 0.00066, "epss_percentile": 0.20943}, "CVE-2022-34677": {"epss_score": 0.00051, "epss_percentile": 0.16282}, "CVE-2022-34678": {"epss_score": 0.00061, "epss_percentile": 0.19261}, "CVE-2022-34679": {"epss_score": 0.00064, "epss_percentile": 0.20151}, "CVE-2022-34680": {"epss_score": 0.00067, "epss_percentile": 0.21031}, "CVE-2022-34681": {"epss_score": 0.00053, "epss_percentile": 0.16682}, "CVE-2022-34682": {"epss_score": 0.00083, "epss_percentile": 0.24697}, "CVE-2022-34683": {"epss_score": 0.00052, "epss_percentile": 0.16476}, "CVE-2022-34684": {"epss_score": 0.00075, "epss_percentile": 0.2296}, "CVE-2022-34685": {"epss_score": 0.0127, "epss_percentile": 0.7905}, "CVE-2022-34686": {"epss_score": 0.0127, "epss_percentile": 0.7905}, "CVE-2022-34687": {"epss_score": 0.02034, "epss_percentile": 0.83348}, "CVE-2022-34689": {"epss_score": 0.15708, "epss_percentile": 0.94488}, "CVE-2022-34690": {"epss_score": 0.00864, "epss_percentile": 0.74602}, "CVE-2022-34691": {"epss_score": 0.01862, "epss_percentile": 0.82595}, "CVE-2022-34692": {"epss_score": 0.0421, "epss_percentile": 0.884}, "CVE-2022-34696": {"epss_score": 0.00299, "epss_percentile": 0.52902}, "CVE-2022-34699": {"epss_score": 0.0302, "epss_percentile": 0.86223}, "CVE-2022-34700": {"epss_score": 0.01273, "epss_percentile": 0.79089}, "CVE-2022-34701": {"epss_score": 0.1875, "epss_percentile": 0.95064}, "CVE-2022-34702": {"epss_score": 0.01016, "epss_percentile": 0.76673}, "CVE-2022-34703": {"epss_score": 0.02268, "epss_percentile": 0.84201}, "CVE-2022-34704": {"epss_score": 0.03276, "epss_percentile": 0.86803}, "CVE-2022-34705": {"epss_score": 0.00853, "epss_percentile": 0.74446}, "CVE-2022-34706": {"epss_score": 0.02005, "epss_percentile": 0.83229}, "CVE-2022-34707": {"epss_score": 0.00541, "epss_percentile": 0.67055}, "CVE-2022-34708": {"epss_score": 0.02392, "epss_percentile": 0.84604}, "CVE-2022-34709": {"epss_score": 0.01161, "epss_percentile": 0.78145}, "CVE-2022-34710": {"epss_score": 0.04677, "epss_percentile": 0.88996}, "CVE-2022-34711": {"epss_score": 0.00741, "epss_percentile": 0.72446}, "CVE-2022-34712": {"epss_score": 0.04234, "epss_percentile": 0.88426}, "CVE-2022-34713": {"epss_score": 0.03724, "epss_percentile": 0.8763}, "CVE-2022-34714": {"epss_score": 0.01392, "epss_percentile": 0.7996}, "CVE-2022-34715": {"epss_score": 0.37802, "epss_percentile": 0.97071}, "CVE-2022-34716": {"epss_score": 0.0105, "epss_percentile": 0.77069}, "CVE-2022-34717": {"epss_score": 0.09963, "epss_percentile": 0.92796}, "CVE-2022-34718": {"epss_score": 0.85781, "epss_percentile": 0.99347}, "CVE-2022-34719": {"epss_score": 0.01109, "epss_percentile": 0.77644}, "CVE-2022-34720": {"epss_score": 0.28212, "epss_percentile": 0.96332}, "CVE-2022-34721": {"epss_score": 0.22192, "epss_percentile": 0.95607}, "CVE-2022-34722": {"epss_score": 0.09474, "epss_percentile": 0.92564}, "CVE-2022-34723": {"epss_score": 0.04308, "epss_percentile": 0.88525}, "CVE-2022-34724": {"epss_score": 0.18552, "epss_percentile": 0.95032}, "CVE-2022-34725": {"epss_score": 0.0119, "epss_percentile": 0.78378}, "CVE-2022-34726": {"epss_score": 0.12949, "epss_percentile": 0.93827}, "CVE-2022-34727": {"epss_score": 0.12949, "epss_percentile": 0.93827}, "CVE-2022-34728": {"epss_score": 0.04166, "epss_percentile": 0.88342}, "CVE-2022-34729": {"epss_score": 0.03061, "epss_percentile": 0.86308}, "CVE-2022-34730": {"epss_score": 0.12949, "epss_percentile": 0.93827}, "CVE-2022-34731": {"epss_score": 0.13313, "epss_percentile": 0.93931}, "CVE-2022-34732": {"epss_score": 0.12949, "epss_percentile": 0.93827}, "CVE-2022-34733": {"epss_score": 0.13313, "epss_percentile": 0.93931}, "CVE-2022-34734": {"epss_score": 0.12949, "epss_percentile": 0.93827}, "CVE-2022-34735": {"epss_score": 0.0015, "epss_percentile": 0.36077}, "CVE-2022-34736": {"epss_score": 0.0015, "epss_percentile": 0.36077}, "CVE-2022-34737": {"epss_score": 0.00103, "epss_percentile": 0.2901}, "CVE-2022-34738": {"epss_score": 0.00098, "epss_percentile": 0.27757}, "CVE-2022-34739": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-34740": {"epss_score": 0.00033, "epss_percentile": 0.09288}, "CVE-2022-34741": {"epss_score": 0.00033, "epss_percentile": 0.09288}, "CVE-2022-34742": {"epss_score": 0.0018, "epss_percentile": 0.39973}, "CVE-2022-34743": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-34746": {"epss_score": 0.00286, "epss_percentile": 0.5169}, "CVE-2022-34747": {"epss_score": 0.01816, "epss_percentile": 0.82391}, "CVE-2022-34748": {"epss_score": 0.00418, "epss_percentile": 0.61323}, "CVE-2022-34749": {"epss_score": 0.00491, "epss_percentile": 0.64968}, "CVE-2022-34750": {"epss_score": 0.00451, "epss_percentile": 0.63145}, "CVE-2022-34753": {"epss_score": 0.91845, "epss_percentile": 0.99672}, "CVE-2022-34754": {"epss_score": 0.00087, "epss_percentile": 0.25554}, "CVE-2022-34755": {"epss_score": 0.00062, "epss_percentile": 0.19744}, "CVE-2022-34756": {"epss_score": 0.0187, "epss_percentile": 0.82628}, "CVE-2022-34757": {"epss_score": 0.00174, "epss_percentile": 0.39205}, "CVE-2022-34758": {"epss_score": 0.003, "epss_percentile": 0.5299}, "CVE-2022-34759": {"epss_score": 0.00589, "epss_percentile": 0.68532}, "CVE-2022-34760": {"epss_score": 0.00457, "epss_percentile": 0.63359}, "CVE-2022-34761": {"epss_score": 0.00686, "epss_percentile": 0.71162}, "CVE-2022-34762": {"epss_score": 0.00403, "epss_percentile": 0.60343}, "CVE-2022-34763": {"epss_score": 0.00098, "epss_percentile": 0.27714}, "CVE-2022-34764": {"epss_score": 0.00589, "epss_percentile": 0.68532}, "CVE-2022-34765": {"epss_score": 0.00274, "epss_percentile": 0.50525}, "CVE-2022-34767": {"epss_score": 0.00202, "epss_percentile": 0.42488}, "CVE-2022-34768": {"epss_score": 0.00201, "epss_percentile": 0.4239}, "CVE-2022-34769": {"epss_score": 0.00173, "epss_percentile": 0.39134}, "CVE-2022-34770": {"epss_score": 0.00219, "epss_percentile": 0.44478}, "CVE-2022-34771": {"epss_score": 0.00168, "epss_percentile": 0.38454}, "CVE-2022-34772": {"epss_score": 0.00259, "epss_percentile": 0.4903}, "CVE-2022-34773": {"epss_score": 0.00391, "epss_percentile": 0.59562}, "CVE-2022-34774": {"epss_score": 0.0022, "epss_percentile": 0.44612}, "CVE-2022-34775": {"epss_score": 0.00219, "epss_percentile": 0.44478}, "CVE-2022-34776": {"epss_score": 0.00259, "epss_percentile": 0.49089}, "CVE-2022-34777": {"epss_score": 0.31349, "epss_percentile": 0.96613}, "CVE-2022-34778": {"epss_score": 0.14252, "epss_percentile": 0.94174}, "CVE-2022-34779": {"epss_score": 0.00617, "epss_percentile": 0.69348}, "CVE-2022-34780": {"epss_score": 0.00084, "epss_percentile": 0.24907}, "CVE-2022-34781": {"epss_score": 0.00555, "epss_percentile": 0.67466}, "CVE-2022-34782": {"epss_score": 0.00617, "epss_percentile": 0.69348}, "CVE-2022-34783": {"epss_score": 0.5042, "epss_percentile": 0.97736}, "CVE-2022-34784": {"epss_score": 0.18202, "epss_percentile": 0.94974}, "CVE-2022-34785": {"epss_score": 0.00836, "epss_percentile": 0.74144}, "CVE-2022-34786": {"epss_score": 0.14252, "epss_percentile": 0.94174}, "CVE-2022-34787": {"epss_score": 0.14252, "epss_percentile": 0.94174}, "CVE-2022-34788": {"epss_score": 0.14252, "epss_percentile": 0.94174}, "CVE-2022-34789": {"epss_score": 0.00084, "epss_percentile": 0.24907}, "CVE-2022-34790": {"epss_score": 0.12666, "epss_percentile": 0.93743}, "CVE-2022-34791": {"epss_score": 0.14252, "epss_percentile": 0.94174}, "CVE-2022-34792": {"epss_score": 0.00091, "epss_percentile": 0.26193}, "CVE-2022-34793": {"epss_score": 0.01626, "epss_percentile": 0.81428}, "CVE-2022-34794": {"epss_score": 0.00668, "epss_percentile": 0.7074}, "CVE-2022-34795": {"epss_score": 0.14252, "epss_percentile": 0.94174}, "CVE-2022-34796": {"epss_score": 0.00836, "epss_percentile": 0.74144}, "CVE-2022-34797": {"epss_score": 0.00092, "epss_percentile": 0.26456}, "CVE-2022-34798": {"epss_score": 0.00668, "epss_percentile": 0.7074}, "CVE-2022-34799": {"epss_score": 0.00617, "epss_percentile": 0.69348}, "CVE-2022-34800": {"epss_score": 0.00617, "epss_percentile": 0.69348}, "CVE-2022-34801": {"epss_score": 0.00444, "epss_percentile": 0.62834}, "CVE-2022-34802": {"epss_score": 0.00273, "epss_percentile": 0.50434}, "CVE-2022-34803": {"epss_score": 0.00617, "epss_percentile": 0.69348}, "CVE-2022-34804": {"epss_score": 0.00384, "epss_percentile": 0.59167}, "CVE-2022-34805": {"epss_score": 0.00555, "epss_percentile": 0.67466}, "CVE-2022-34806": {"epss_score": 0.00555, "epss_percentile": 0.67466}, "CVE-2022-34807": {"epss_score": 0.00555, "epss_percentile": 0.67466}, "CVE-2022-34808": {"epss_score": 0.00617, "epss_percentile": 0.69348}, "CVE-2022-34809": {"epss_score": 0.00555, "epss_percentile": 0.67466}, "CVE-2022-34810": {"epss_score": 0.00555, "epss_percentile": 0.67466}, "CVE-2022-34811": {"epss_score": 0.00617, "epss_percentile": 0.69348}, "CVE-2022-34812": {"epss_score": 0.00084, "epss_percentile": 0.24907}, "CVE-2022-34813": {"epss_score": 0.00668, "epss_percentile": 0.7074}, "CVE-2022-34814": {"epss_score": 0.00617, "epss_percentile": 0.69348}, "CVE-2022-34815": {"epss_score": 0.00084, "epss_percentile": 0.24907}, "CVE-2022-34816": {"epss_score": 0.00555, "epss_percentile": 0.67466}, "CVE-2022-34817": {"epss_score": 0.00084, "epss_percentile": 0.24907}, "CVE-2022-34818": {"epss_score": 0.00668, "epss_percentile": 0.7074}, "CVE-2022-34819": {"epss_score": 0.00658, "epss_percentile": 0.70491}, "CVE-2022-34820": {"epss_score": 0.00482, "epss_percentile": 0.64534}, "CVE-2022-34821": {"epss_score": 0.00706, "epss_percentile": 0.71616}, "CVE-2022-34822": {"epss_score": 0.0653, "epss_percentile": 0.90824}, "CVE-2022-34823": {"epss_score": 0.02802, "epss_percentile": 0.857}, "CVE-2022-34824": {"epss_score": 0.02635, "epss_percentile": 0.85292}, "CVE-2022-34825": {"epss_score": 0.03151, "epss_percentile": 0.86506}, "CVE-2022-34826": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2022-34827": {"epss_score": 0.00294, "epss_percentile": 0.52359}, "CVE-2022-34829": {"epss_score": 0.25475, "epss_percentile": 0.96031}, "CVE-2022-34830": {"epss_score": 0.00292, "epss_percentile": 0.52258}, "CVE-2022-34831": {"epss_score": 0.0023, "epss_percentile": 0.45732}, "CVE-2022-34832": {"epss_score": 0.00054, "epss_percentile": 0.17146}, "CVE-2022-34833": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2022-34834": {"epss_score": 0.00061, "epss_percentile": 0.19315}, "CVE-2022-34835": {"epss_score": 0.00309, "epss_percentile": 0.53649}, "CVE-2022-34836": {"epss_score": 0.00529, "epss_percentile": 0.66594}, "CVE-2022-34837": {"epss_score": 0.00046, "epss_percentile": 0.14388}, "CVE-2022-34838": {"epss_score": 0.0005, "epss_percentile": 0.15704}, "CVE-2022-34839": {"epss_score": 0.00521, "epss_percentile": 0.66221}, "CVE-2022-34840": {"epss_score": 0.0007, "epss_percentile": 0.2184}, "CVE-2022-34841": {"epss_score": 0.00092, "epss_percentile": 0.2648}, "CVE-2022-34843": {"epss_score": 0.00068, "epss_percentile": 0.2121}, "CVE-2022-34844": {"epss_score": 0.00462, "epss_percentile": 0.63615}, "CVE-2022-34845": {"epss_score": 0.00273, "epss_percentile": 0.50426}, "CVE-2022-34848": {"epss_score": 0.0007, "epss_percentile": 0.21972}, "CVE-2022-34849": {"epss_score": 0.00073, "epss_percentile": 0.22568}, "CVE-2022-34850": {"epss_score": 0.014, "epss_percentile": 0.80001}, "CVE-2022-34851": {"epss_score": 0.00417, "epss_percentile": 0.61228}, "CVE-2022-34853": {"epss_score": 0.0018, "epss_percentile": 0.39928}, "CVE-2022-34854": {"epss_score": 0.00116, "epss_percentile": 0.31182}, "CVE-2022-34855": {"epss_score": 0.00077, "epss_percentile": 0.23353}, "CVE-2022-34857": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-34858": {"epss_score": 0.00687, "epss_percentile": 0.7119}, "CVE-2022-34862": {"epss_score": 0.00992, "epss_percentile": 0.76393}, "CVE-2022-34864": {"epss_score": 0.00068, "epss_percentile": 0.2121}, "CVE-2022-34865": {"epss_score": 0.00222, "epss_percentile": 0.44791}, "CVE-2022-34866": {"epss_score": 0.00057, "epss_percentile": 0.17992}, "CVE-2022-34867": {"epss_score": 0.00689, "epss_percentile": 0.71226}, "CVE-2022-34868": {"epss_score": 0.00594, "epss_percentile": 0.6867}, "CVE-2022-34869": {"epss_score": 0.00835, "epss_percentile": 0.74125}, "CVE-2022-34870": {"epss_score": 0.02568, "epss_percentile": 0.85121}, "CVE-2022-34871": {"epss_score": 0.03655, "epss_percentile": 0.87513}, "CVE-2022-34872": {"epss_score": 0.0047, "epss_percentile": 0.63979}, "CVE-2022-34873": {"epss_score": 0.00711, "epss_percentile": 0.71737}, "CVE-2022-34874": {"epss_score": 0.00711, "epss_percentile": 0.71737}, "CVE-2022-34875": {"epss_score": 0.00183, "epss_percentile": 0.4034}, "CVE-2022-34876": {"epss_score": 0.53198, "epss_percentile": 0.97863}, "CVE-2022-34877": {"epss_score": 0.49231, "epss_percentile": 0.97674}, "CVE-2022-34878": {"epss_score": 0.56683, "epss_percentile": 0.98033}, "CVE-2022-34879": {"epss_score": 0.00226, "epss_percentile": 0.45253}, "CVE-2022-34881": {"epss_score": 0.00051, "epss_percentile": 0.16263}, "CVE-2022-34882": {"epss_score": 0.00337, "epss_percentile": 0.56011}, "CVE-2022-34883": {"epss_score": 0.01213, "epss_percentile": 0.78569}, "CVE-2022-34884": {"epss_score": 0.00276, "epss_percentile": 0.5071}, "CVE-2022-34885": {"epss_score": 0.00134, "epss_percentile": 0.33771}, "CVE-2022-34886": {"epss_score": 0.07076, "epss_percentile": 0.91233}, "CVE-2022-34887": {"epss_score": 0.00086, "epss_percentile": 0.25427}, "CVE-2022-34888": {"epss_score": 0.00087, "epss_percentile": 0.25634}, "CVE-2022-34889": {"epss_score": 0.001, "epss_percentile": 0.28513}, "CVE-2022-34890": {"epss_score": 0.00098, "epss_percentile": 0.2767}, "CVE-2022-34891": {"epss_score": 0.00067, "epss_percentile": 0.21085}, "CVE-2022-34892": {"epss_score": 0.00076, "epss_percentile": 0.23085}, "CVE-2022-34893": {"epss_score": 0.00318, "epss_percentile": 0.54445}, "CVE-2022-34894": {"epss_score": 2e-05, "epss_percentile": 0.00058}, "CVE-2022-34899": {"epss_score": 0.00076, "epss_percentile": 0.23085}, "CVE-2022-34900": {"epss_score": 0.00098, "epss_percentile": 0.2767}, "CVE-2022-34901": {"epss_score": 0.00098, "epss_percentile": 0.2767}, "CVE-2022-34902": {"epss_score": 0.00098, "epss_percentile": 0.2767}, "CVE-2022-34903": {"epss_score": 0.02397, "epss_percentile": 0.8462}, "CVE-2022-34906": {"epss_score": 0.00285, "epss_percentile": 0.51657}, "CVE-2022-34907": {"epss_score": 0.00518, "epss_percentile": 0.66114}, "CVE-2022-34908": {"epss_score": 0.00136, "epss_percentile": 0.34093}, "CVE-2022-34909": {"epss_score": 0.0004, "epss_percentile": 0.12151}, "CVE-2022-34910": {"epss_score": 0.0001, "epss_percentile": 0.00849}, "CVE-2022-34911": {"epss_score": 0.00435, "epss_percentile": 0.62351}, "CVE-2022-34912": {"epss_score": 0.00236, "epss_percentile": 0.46376}, "CVE-2022-34913": {"epss_score": 0.10321, "epss_percentile": 0.92943}, "CVE-2022-34914": {"epss_score": 0.00895, "epss_percentile": 0.75105}, "CVE-2022-34916": {"epss_score": 0.0266, "epss_percentile": 0.85364}, "CVE-2022-34917": {"epss_score": 0.00062, "epss_percentile": 0.19586}, "CVE-2022-34918": {"epss_score": 0.31583, "epss_percentile": 0.96628}, "CVE-2022-34919": {"epss_score": 0.01392, "epss_percentile": 0.79956}, "CVE-2022-34924": {"epss_score": 0.0014, "epss_percentile": 0.34733}, "CVE-2022-34927": {"epss_score": 0.00052, "epss_percentile": 0.16572}, "CVE-2022-34928": {"epss_score": 0.00226, "epss_percentile": 0.45359}, "CVE-2022-34937": {"epss_score": 0.00323, "epss_percentile": 0.54917}, "CVE-2022-34945": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-34946": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-34947": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-34948": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-34949": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-34950": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-34951": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-34952": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-34953": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-34954": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-34955": {"epss_score": 0.00294, "epss_percentile": 0.52431}, "CVE-2022-34956": {"epss_score": 0.00294, "epss_percentile": 0.52431}, "CVE-2022-34960": {"epss_score": 0.00506, "epss_percentile": 0.65626}, "CVE-2022-34961": {"epss_score": 0.00567, "epss_percentile": 0.67842}, "CVE-2022-34962": {"epss_score": 0.02258, "epss_percentile": 0.84179}, "CVE-2022-34963": {"epss_score": 0.01644, "epss_percentile": 0.81522}, "CVE-2022-34964": {"epss_score": 0.0044, "epss_percentile": 0.62615}, "CVE-2022-34965": {"epss_score": 0.02221, "epss_percentile": 0.84052}, "CVE-2022-34966": {"epss_score": 0.00879, "epss_percentile": 0.74843}, "CVE-2022-34967": {"epss_score": 0.00266, "epss_percentile": 0.49859}, "CVE-2022-34968": {"epss_score": 0.00349, "epss_percentile": 0.56878}, "CVE-2022-34969": {"epss_score": 0.00266, "epss_percentile": 0.49927}, "CVE-2022-34970": {"epss_score": 0.28591, "epss_percentile": 0.9637}, "CVE-2022-34971": {"epss_score": 0.0074, "epss_percentile": 0.724}, "CVE-2022-34972": {"epss_score": 0.00309, "epss_percentile": 0.53694}, "CVE-2022-34973": {"epss_score": 0.00785, "epss_percentile": 0.7326}, "CVE-2022-34974": {"epss_score": 0.22306, "epss_percentile": 0.95621}, "CVE-2022-34981": {"epss_score": 0.00452, "epss_percentile": 0.63161}, "CVE-2022-34982": {"epss_score": 0.00634, "epss_percentile": 0.69799}, "CVE-2022-34983": {"epss_score": 0.00452, "epss_percentile": 0.63161}, "CVE-2022-34988": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-34989": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-34991": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-34992": {"epss_score": 0.00052, "epss_percentile": 0.16388}, "CVE-2022-34993": {"epss_score": 0.00441, "epss_percentile": 0.62689}, "CVE-2022-34998": {"epss_score": 0.00052, "epss_percentile": 0.16388}, "CVE-2022-34999": {"epss_score": 0.00063, "epss_percentile": 0.19883}, "CVE-2022-35000": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2022-35002": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2022-35003": {"epss_score": 0.00052, "epss_percentile": 0.16388}, "CVE-2022-35004": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2022-35007": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35008": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35009": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35010": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35011": {"epss_score": 0.00399, "epss_percentile": 0.60108}, "CVE-2022-35012": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35013": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35014": {"epss_score": 0.0003, "epss_percentile": 0.08251}, "CVE-2022-35015": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2022-35016": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2022-35017": {"epss_score": 0.00032, "epss_percentile": 0.08735}, "CVE-2022-35018": {"epss_score": 0.00031, "epss_percentile": 0.08653}, "CVE-2022-35019": {"epss_score": 0.00031, "epss_percentile": 0.08653}, "CVE-2022-35020": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2022-35021": {"epss_score": 0.00313, "epss_percentile": 0.54017}, "CVE-2022-35022": {"epss_score": 0.00292, "epss_percentile": 0.52227}, "CVE-2022-35023": {"epss_score": 0.0027, "epss_percentile": 0.50206}, "CVE-2022-35024": {"epss_score": 0.00158, "epss_percentile": 0.37256}, "CVE-2022-35025": {"epss_score": 0.0027, "epss_percentile": 0.50206}, "CVE-2022-35026": {"epss_score": 0.0027, "epss_percentile": 0.50206}, "CVE-2022-35027": {"epss_score": 0.0027, "epss_percentile": 0.50206}, "CVE-2022-35028": {"epss_score": 0.0027, "epss_percentile": 0.50206}, "CVE-2022-35029": {"epss_score": 0.0027, "epss_percentile": 0.50206}, "CVE-2022-35030": {"epss_score": 0.0027, "epss_percentile": 0.50206}, "CVE-2022-35031": {"epss_score": 0.0027, "epss_percentile": 0.50206}, "CVE-2022-35032": {"epss_score": 0.00158, "epss_percentile": 0.37256}, "CVE-2022-35034": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35035": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35036": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35037": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35038": {"epss_score": 0.00374, "epss_percentile": 0.58569}, "CVE-2022-35039": {"epss_score": 0.00374, "epss_percentile": 0.58569}, "CVE-2022-35040": {"epss_score": 0.00374, "epss_percentile": 0.58569}, "CVE-2022-35041": {"epss_score": 0.00374, "epss_percentile": 0.58569}, "CVE-2022-35042": {"epss_score": 0.00374, "epss_percentile": 0.58569}, "CVE-2022-35043": {"epss_score": 0.00374, "epss_percentile": 0.58569}, "CVE-2022-35044": {"epss_score": 0.00374, "epss_percentile": 0.58569}, "CVE-2022-35045": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35046": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35047": {"epss_score": 0.00309, "epss_percentile": 0.53685}, "CVE-2022-35048": {"epss_score": 0.00309, "epss_percentile": 0.53685}, "CVE-2022-35049": {"epss_score": 0.00309, "epss_percentile": 0.53685}, "CVE-2022-35050": {"epss_score": 0.00309, "epss_percentile": 0.53685}, "CVE-2022-35051": {"epss_score": 0.00309, "epss_percentile": 0.53685}, "CVE-2022-35052": {"epss_score": 0.00309, "epss_percentile": 0.53685}, "CVE-2022-35053": {"epss_score": 0.00309, "epss_percentile": 0.53685}, "CVE-2022-35054": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35055": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35056": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35058": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35059": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35060": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35061": {"epss_score": 0.00168, "epss_percentile": 0.38431}, "CVE-2022-35062": {"epss_score": 0.00168, "epss_percentile": 0.38431}, "CVE-2022-35063": {"epss_score": 0.00168, "epss_percentile": 0.38431}, "CVE-2022-35064": {"epss_score": 0.00168, "epss_percentile": 0.38431}, "CVE-2022-35065": {"epss_score": 0.0027, "epss_percentile": 0.50206}, "CVE-2022-35066": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35067": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35068": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35069": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35070": {"epss_score": 0.00286, "epss_percentile": 0.51706}, "CVE-2022-35080": {"epss_score": 0.00082, "epss_percentile": 0.24433}, "CVE-2022-35081": {"epss_score": 0.00082, "epss_percentile": 0.24433}, "CVE-2022-35085": {"epss_score": 0.00077, "epss_percentile": 0.23439}, "CVE-2022-35086": {"epss_score": 0.00077, "epss_percentile": 0.23439}, "CVE-2022-35087": {"epss_score": 0.00077, "epss_percentile": 0.23439}, "CVE-2022-35088": {"epss_score": 0.00077, "epss_percentile": 0.23439}, "CVE-2022-35089": {"epss_score": 0.00077, "epss_percentile": 0.23439}, "CVE-2022-35090": {"epss_score": 0.00082, "epss_percentile": 0.24433}, "CVE-2022-35091": {"epss_score": 0.00105, "epss_percentile": 0.29289}, "CVE-2022-35092": {"epss_score": 0.00077, "epss_percentile": 0.23439}, "CVE-2022-35093": {"epss_score": 0.00082, "epss_percentile": 0.24433}, "CVE-2022-35094": {"epss_score": 0.00082, "epss_percentile": 0.24433}, "CVE-2022-35095": {"epss_score": 0.00077, "epss_percentile": 0.23439}, "CVE-2022-35096": {"epss_score": 0.00082, "epss_percentile": 0.24433}, "CVE-2022-35097": {"epss_score": 0.00077, "epss_percentile": 0.23439}, "CVE-2022-35098": {"epss_score": 0.00082, "epss_percentile": 0.24433}, "CVE-2022-35099": {"epss_score": 0.00082, "epss_percentile": 0.24433}, "CVE-2022-35100": {"epss_score": 0.00226, "epss_percentile": 0.45263}, "CVE-2022-35101": {"epss_score": 0.00047, "epss_percentile": 0.14587}, "CVE-2022-35104": {"epss_score": 0.00049, "epss_percentile": 0.15477}, "CVE-2022-35105": {"epss_score": 0.00049, "epss_percentile": 0.15477}, "CVE-2022-35106": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2022-35107": {"epss_score": 0.00049, "epss_percentile": 0.15477}, "CVE-2022-35108": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2022-35109": {"epss_score": 0.00049, "epss_percentile": 0.15637}, "CVE-2022-35110": {"epss_score": 0.00047, "epss_percentile": 0.14587}, "CVE-2022-35111": {"epss_score": 0.00049, "epss_percentile": 0.15477}, "CVE-2022-35113": {"epss_score": 0.00052, "epss_percentile": 0.16347}, "CVE-2022-35114": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-35115": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2022-35117": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-35118": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-35120": {"epss_score": 0.00027, "epss_percentile": 0.06779}, "CVE-2022-35121": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-35122": {"epss_score": 0.01602, "epss_percentile": 0.81268}, "CVE-2022-35131": {"epss_score": 0.14686, "epss_percentile": 0.94264}, "CVE-2022-35132": {"epss_score": 0.12, "epss_percentile": 0.93542}, "CVE-2022-35133": {"epss_score": 0.00369, "epss_percentile": 0.58254}, "CVE-2022-35134": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-35135": {"epss_score": 0.00294, "epss_percentile": 0.52359}, "CVE-2022-35136": {"epss_score": 0.00259, "epss_percentile": 0.49048}, "CVE-2022-35137": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-35142": {"epss_score": 0.00491, "epss_percentile": 0.64948}, "CVE-2022-35143": {"epss_score": 0.00523, "epss_percentile": 0.66286}, "CVE-2022-35144": {"epss_score": 0.00313, "epss_percentile": 0.54019}, "CVE-2022-35147": {"epss_score": 0.01159, "epss_percentile": 0.78126}, "CVE-2022-35148": {"epss_score": 0.00212, "epss_percentile": 0.43754}, "CVE-2022-35150": {"epss_score": 0.00401, "epss_percentile": 0.60204}, "CVE-2022-35151": {"epss_score": 0.02487, "epss_percentile": 0.8489}, "CVE-2022-35153": {"epss_score": 0.0532, "epss_percentile": 0.89729}, "CVE-2022-35154": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-35155": {"epss_score": 0.04549, "epss_percentile": 0.88838}, "CVE-2022-35156": {"epss_score": 0.00476, "epss_percentile": 0.64267}, "CVE-2022-35158": {"epss_score": 0.00266, "epss_percentile": 0.49859}, "CVE-2022-35161": {"epss_score": 0.00365, "epss_percentile": 0.57972}, "CVE-2022-35162": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-35163": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-35164": {"epss_score": 0.00344, "epss_percentile": 0.56528}, "CVE-2022-35165": {"epss_score": 0.00047, "epss_percentile": 0.14587}, "CVE-2022-35166": {"epss_score": 0.00047, "epss_percentile": 0.14587}, "CVE-2022-35167": {"epss_score": 0.0033, "epss_percentile": 0.55431}, "CVE-2022-35168": {"epss_score": 0.00349, "epss_percentile": 0.56876}, "CVE-2022-35169": {"epss_score": 0.0043, "epss_percentile": 0.62011}, "CVE-2022-35170": {"epss_score": 0.00337, "epss_percentile": 0.56057}, "CVE-2022-35171": {"epss_score": 0.00143, "epss_percentile": 0.35162}, "CVE-2022-35172": {"epss_score": 0.00337, "epss_percentile": 0.56057}, "CVE-2022-35173": {"epss_score": 0.00376, "epss_percentile": 0.58682}, "CVE-2022-35174": {"epss_score": 0.00178, "epss_percentile": 0.39681}, "CVE-2022-35175": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-35191": {"epss_score": 0.007, "epss_percentile": 0.71464}, "CVE-2022-35192": {"epss_score": 0.00756, "epss_percentile": 0.72743}, "CVE-2022-35193": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-35194": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-35195": {"epss_score": 0.00427, "epss_percentile": 0.61775}, "CVE-2022-35196": {"epss_score": 0.00134, "epss_percentile": 0.33794}, "CVE-2022-35198": {"epss_score": 0.00275, "epss_percentile": 0.5069}, "CVE-2022-35201": {"epss_score": 0.01619, "epss_percentile": 0.81381}, "CVE-2022-35202": {"epss_score": 0.00053, "epss_percentile": 0.16932}, "CVE-2022-35203": {"epss_score": 0.01206, "epss_percentile": 0.78517}, "CVE-2022-35204": {"epss_score": 0.01179, "epss_percentile": 0.78293}, "CVE-2022-35205": {"epss_score": 8e-05, "epss_percentile": 0.00487}, "CVE-2022-35206": {"epss_score": 0.00026, "epss_percentile": 0.06489}, "CVE-2022-35212": {"epss_score": 0.00669, "epss_percentile": 0.70759}, "CVE-2022-35213": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2022-35216": {"epss_score": 0.00603, "epss_percentile": 0.689}, "CVE-2022-35217": {"epss_score": 0.00067, "epss_percentile": 0.21108}, "CVE-2022-35218": {"epss_score": 0.00047, "epss_percentile": 0.14881}, "CVE-2022-35219": {"epss_score": 0.00047, "epss_percentile": 0.14881}, "CVE-2022-35220": {"epss_score": 0.00786, "epss_percentile": 0.7329}, "CVE-2022-35221": {"epss_score": 0.00378, "epss_percentile": 0.58802}, "CVE-2022-35222": {"epss_score": 0.00069, "epss_percentile": 0.21562}, "CVE-2022-35223": {"epss_score": 0.03452, "epss_percentile": 0.87166}, "CVE-2022-35224": {"epss_score": 0.00557, "epss_percentile": 0.67533}, "CVE-2022-35225": {"epss_score": 0.00337, "epss_percentile": 0.56057}, "CVE-2022-35226": {"epss_score": 0.00348, "epss_percentile": 0.56795}, "CVE-2022-35227": {"epss_score": 0.00302, "epss_percentile": 0.53086}, "CVE-2022-35228": {"epss_score": 0.00182, "epss_percentile": 0.40194}, "CVE-2022-35229": {"epss_score": 0.00516, "epss_percentile": 0.66049}, "CVE-2022-35230": {"epss_score": 0.00559, "epss_percentile": 0.67603}, "CVE-2022-35234": {"epss_score": 0.00188, "epss_percentile": 0.40885}, "CVE-2022-35235": {"epss_score": 0.00983, "epss_percentile": 0.76305}, "CVE-2022-35236": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2022-35238": {"epss_score": 0.00244, "epss_percentile": 0.47585}, "CVE-2022-35239": {"epss_score": 0.00816, "epss_percentile": 0.738}, "CVE-2022-35240": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2022-35241": {"epss_score": 0.00654, "epss_percentile": 0.70346}, "CVE-2022-35242": {"epss_score": 0.00244, "epss_percentile": 0.47585}, "CVE-2022-35243": {"epss_score": 0.00439, "epss_percentile": 0.62601}, "CVE-2022-35244": {"epss_score": 0.0065, "epss_percentile": 0.70272}, "CVE-2022-35245": {"epss_score": 0.00753, "epss_percentile": 0.72673}, "CVE-2022-35246": {"epss_score": 0.00194, "epss_percentile": 0.41561}, "CVE-2022-35247": {"epss_score": 0.00291, "epss_percentile": 0.5221}, "CVE-2022-35248": {"epss_score": 0.00253, "epss_percentile": 0.48463}, "CVE-2022-35249": {"epss_score": 0.00138, "epss_percentile": 0.34517}, "CVE-2022-35250": {"epss_score": 0.00281, "epss_percentile": 0.51148}, "CVE-2022-35251": {"epss_score": 0.00312, "epss_percentile": 0.53949}, "CVE-2022-35252": {"epss_score": 0.00111, "epss_percentile": 0.30253}, "CVE-2022-35254": {"epss_score": 0.09642, "epss_percentile": 0.92637}, "CVE-2022-35255": {"epss_score": 0.0161, "epss_percentile": 0.81321}, "CVE-2022-35256": {"epss_score": 0.0458, "epss_percentile": 0.88875}, "CVE-2022-35257": {"epss_score": 0.0004, "epss_percentile": 0.12193}, "CVE-2022-35258": {"epss_score": 0.09642, "epss_percentile": 0.92637}, "CVE-2022-35259": {"epss_score": 0.00613, "epss_percentile": 0.69263}, "CVE-2022-35260": {"epss_score": 0.00213, "epss_percentile": 0.43889}, "CVE-2022-35261": {"epss_score": 0.00687, "epss_percentile": 0.71186}, "CVE-2022-35262": {"epss_score": 0.00329, "epss_percentile": 0.55397}, "CVE-2022-35263": {"epss_score": 0.00329, "epss_percentile": 0.55397}, "CVE-2022-35264": {"epss_score": 0.00329, "epss_percentile": 0.55397}, "CVE-2022-35265": {"epss_score": 0.00389, "epss_percentile": 0.59492}, "CVE-2022-35266": {"epss_score": 0.00389, "epss_percentile": 0.59492}, "CVE-2022-35267": {"epss_score": 0.00389, "epss_percentile": 0.59492}, "CVE-2022-35268": {"epss_score": 0.00426, "epss_percentile": 0.61764}, "CVE-2022-35269": {"epss_score": 0.00426, "epss_percentile": 0.61764}, "CVE-2022-35270": {"epss_score": 0.00426, "epss_percentile": 0.61764}, "CVE-2022-35271": {"epss_score": 0.00691, "epss_percentile": 0.71278}, "CVE-2022-35272": {"epss_score": 0.00325, "epss_percentile": 0.5502}, "CVE-2022-35273": {"epss_score": 0.0345, "epss_percentile": 0.87162}, "CVE-2022-35275": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2022-35276": {"epss_score": 0.00123, "epss_percentile": 0.32225}, "CVE-2022-35277": {"epss_score": 0.00101, "epss_percentile": 0.28684}, "CVE-2022-35278": {"epss_score": 0.07498, "epss_percentile": 0.91504}, "CVE-2022-35279": {"epss_score": 0.00115, "epss_percentile": 0.31031}, "CVE-2022-35280": {"epss_score": 0.00195, "epss_percentile": 0.41637}, "CVE-2022-35281": {"epss_score": 0.00172, "epss_percentile": 0.38987}, "CVE-2022-35282": {"epss_score": 0.0004, "epss_percentile": 0.12098}, "CVE-2022-35283": {"epss_score": 0.00627, "epss_percentile": 0.6964}, "CVE-2022-35284": {"epss_score": 0.00298, "epss_percentile": 0.52788}, "CVE-2022-35285": {"epss_score": 0.00104, "epss_percentile": 0.29192}, "CVE-2022-35286": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2022-35287": {"epss_score": 0.00072, "epss_percentile": 0.22438}, "CVE-2022-35288": {"epss_score": 0.00161, "epss_percentile": 0.37615}, "CVE-2022-35289": {"epss_score": 0.01572, "epss_percentile": 0.81098}, "CVE-2022-35290": {"epss_score": 0.00348, "epss_percentile": 0.56805}, "CVE-2022-35291": {"epss_score": 0.00231, "epss_percentile": 0.45813}, "CVE-2022-35292": {"epss_score": 0.00088, "epss_percentile": 0.25698}, "CVE-2022-35293": {"epss_score": 0.00664, "epss_percentile": 0.70639}, "CVE-2022-35294": {"epss_score": 0.00379, "epss_percentile": 0.58887}, "CVE-2022-35295": {"epss_score": 0.00496, "epss_percentile": 0.65147}, "CVE-2022-35296": {"epss_score": 0.00377, "epss_percentile": 0.58729}, "CVE-2022-35297": {"epss_score": 0.00351, "epss_percentile": 0.57075}, "CVE-2022-35298": {"epss_score": 0.00538, "epss_percentile": 0.66938}, "CVE-2022-35299": {"epss_score": 0.00623, "epss_percentile": 0.69539}, "CVE-2022-35401": {"epss_score": 0.00065, "epss_percentile": 0.20595}, "CVE-2022-35403": {"epss_score": 0.02812, "epss_percentile": 0.85723}, "CVE-2022-35404": {"epss_score": 0.01118, "epss_percentile": 0.77747}, "CVE-2022-35405": {"epss_score": 0.9442, "epss_percentile": 0.99978}, "CVE-2022-35406": {"epss_score": 0.0024, "epss_percentile": 0.47193}, "CVE-2022-35407": {"epss_score": 0.00159, "epss_percentile": 0.37332}, "CVE-2022-35408": {"epss_score": 0.00084, "epss_percentile": 0.25024}, "CVE-2022-35409": {"epss_score": 0.00892, "epss_percentile": 0.7507}, "CVE-2022-35410": {"epss_score": 0.00355, "epss_percentile": 0.57259}, "CVE-2022-35411": {"epss_score": 0.71334, "epss_percentile": 0.98663}, "CVE-2022-35412": {"epss_score": 0.00064, "epss_percentile": 0.20429}, "CVE-2022-35413": {"epss_score": 0.85969, "epss_percentile": 0.99359}, "CVE-2022-35414": {"epss_score": 0.00297, "epss_percentile": 0.52708}, "CVE-2022-35415": {"epss_score": 0.00049, "epss_percentile": 0.15569}, "CVE-2022-35416": {"epss_score": 0.06779, "epss_percentile": 0.9102}, "CVE-2022-35421": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-35422": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-35426": {"epss_score": 0.00411, "epss_percentile": 0.60885}, "CVE-2022-35433": {"epss_score": 0.00226, "epss_percentile": 0.45277}, "CVE-2022-35434": {"epss_score": 0.00066, "epss_percentile": 0.20854}, "CVE-2022-35447": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35448": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35449": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35450": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35451": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35452": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35453": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35454": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35455": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35456": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35458": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35459": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35460": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35461": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35462": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35463": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35464": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35465": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35466": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35467": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35468": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35469": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35470": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35471": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35472": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35473": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35474": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35475": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2022-35476": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35477": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35478": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35479": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35481": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35482": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35483": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35484": {"epss_score": 0.00314, "epss_percentile": 0.54154}, "CVE-2022-35485": {"epss_score": 0.0027, "epss_percentile": 0.50206}, "CVE-2022-35486": {"epss_score": 0.0027, "epss_percentile": 0.50223}, "CVE-2022-35487": {"epss_score": 0.00805, "epss_percentile": 0.73644}, "CVE-2022-35488": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-35489": {"epss_score": 0.00326, "epss_percentile": 0.55064}, "CVE-2022-35490": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2022-35491": {"epss_score": 0.00405, "epss_percentile": 0.60456}, "CVE-2022-35493": {"epss_score": 0.02192, "epss_percentile": 0.83942}, "CVE-2022-35500": {"epss_score": 0.00198, "epss_percentile": 0.42007}, "CVE-2022-35501": {"epss_score": 0.00198, "epss_percentile": 0.42007}, "CVE-2022-35503": {"epss_score": 0.00199, "epss_percentile": 0.42138}, "CVE-2022-35505": {"epss_score": 0.00382, "epss_percentile": 0.59065}, "CVE-2022-35506": {"epss_score": 0.00348, "epss_percentile": 0.56843}, "CVE-2022-35507": {"epss_score": 0.14332, "epss_percentile": 0.94189}, "CVE-2022-35508": {"epss_score": 0.00653, "epss_percentile": 0.70332}, "CVE-2022-35509": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-35513": {"epss_score": 0.06286, "epss_percentile": 0.90643}, "CVE-2022-35516": {"epss_score": 0.12715, "epss_percentile": 0.93756}, "CVE-2022-35517": {"epss_score": 0.0507, "epss_percentile": 0.89462}, "CVE-2022-35518": {"epss_score": 0.03484, "epss_percentile": 0.87225}, "CVE-2022-35519": {"epss_score": 0.05199, "epss_percentile": 0.89604}, "CVE-2022-35520": {"epss_score": 0.05199, "epss_percentile": 0.89604}, "CVE-2022-35521": {"epss_score": 0.05199, "epss_percentile": 0.89604}, "CVE-2022-35522": {"epss_score": 0.05199, "epss_percentile": 0.89604}, "CVE-2022-35523": {"epss_score": 0.05199, "epss_percentile": 0.89604}, "CVE-2022-35524": {"epss_score": 0.05199, "epss_percentile": 0.89604}, "CVE-2022-35525": {"epss_score": 0.05199, "epss_percentile": 0.89604}, "CVE-2022-35526": {"epss_score": 0.01932, "epss_percentile": 0.82944}, "CVE-2022-35533": {"epss_score": 0.05199, "epss_percentile": 0.89604}, "CVE-2022-35534": {"epss_score": 0.05199, "epss_percentile": 0.89604}, "CVE-2022-35535": {"epss_score": 0.05199, "epss_percentile": 0.89604}, "CVE-2022-35536": {"epss_score": 0.01932, "epss_percentile": 0.82944}, "CVE-2022-35537": {"epss_score": 0.01932, "epss_percentile": 0.82944}, "CVE-2022-35538": {"epss_score": 0.01932, "epss_percentile": 0.82944}, "CVE-2022-35540": {"epss_score": 0.00557, "epss_percentile": 0.67539}, "CVE-2022-35554": {"epss_score": 0.00294, "epss_percentile": 0.52427}, "CVE-2022-35555": {"epss_score": 0.0788, "epss_percentile": 0.91739}, "CVE-2022-35557": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-35558": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-35559": {"epss_score": 0.01442, "epss_percentile": 0.8031}, "CVE-2022-35560": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-35561": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-35569": {"epss_score": 0.00226, "epss_percentile": 0.45333}, "CVE-2022-35572": {"epss_score": 0.00341, "epss_percentile": 0.56327}, "CVE-2022-35582": {"epss_score": 0.00296, "epss_percentile": 0.526}, "CVE-2022-35583": {"epss_score": 0.51691, "epss_percentile": 0.97794}, "CVE-2022-35585": {"epss_score": 0.0023, "epss_percentile": 0.45719}, "CVE-2022-35587": {"epss_score": 0.0023, "epss_percentile": 0.45719}, "CVE-2022-35589": {"epss_score": 0.00191, "epss_percentile": 0.41184}, "CVE-2022-35590": {"epss_score": 0.00191, "epss_percentile": 0.41184}, "CVE-2022-35598": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-35599": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-35601": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-35602": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-35603": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-35605": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-35606": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-35611": {"epss_score": 0.00115, "epss_percentile": 0.30881}, "CVE-2022-35612": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-35613": {"epss_score": 0.00134, "epss_percentile": 0.33798}, "CVE-2022-35619": {"epss_score": 0.06321, "epss_percentile": 0.9067}, "CVE-2022-35620": {"epss_score": 0.25246, "epss_percentile": 0.96002}, "CVE-2022-35621": {"epss_score": 0.00222, "epss_percentile": 0.448}, "CVE-2022-35623": {"epss_score": 0.00208, "epss_percentile": 0.43209}, "CVE-2022-35624": {"epss_score": 0.00507, "epss_percentile": 0.65676}, "CVE-2022-35628": {"epss_score": 0.01913, "epss_percentile": 0.82837}, "CVE-2022-35629": {"epss_score": 0.00157, "epss_percentile": 0.37138}, "CVE-2022-35630": {"epss_score": 0.00542, "epss_percentile": 0.67078}, "CVE-2022-35631": {"epss_score": 0.00108, "epss_percentile": 0.29878}, "CVE-2022-35632": {"epss_score": 0.00496, "epss_percentile": 0.65175}, "CVE-2022-35637": {"epss_score": 0.00537, "epss_percentile": 0.66893}, "CVE-2022-35638": {"epss_score": 0.00041, "epss_percentile": 0.12222}, "CVE-2022-35639": {"epss_score": 0.00392, "epss_percentile": 0.59687}, "CVE-2022-35640": {"epss_score": 0.00022, "epss_percentile": 0.0525}, "CVE-2022-35642": {"epss_score": 0.00493, "epss_percentile": 0.6503}, "CVE-2022-35643": {"epss_score": 0.00631, "epss_percentile": 0.69726}, "CVE-2022-35645": {"epss_score": 0.001, "epss_percentile": 0.28444}, "CVE-2022-35646": {"epss_score": 0.00108, "epss_percentile": 0.299}, "CVE-2022-35648": {"epss_score": 0.00077, "epss_percentile": 0.23358}, "CVE-2022-35649": {"epss_score": 0.07272, "epss_percentile": 0.91375}, "CVE-2022-35650": {"epss_score": 0.01706, "epss_percentile": 0.81855}, "CVE-2022-35651": {"epss_score": 0.00348, "epss_percentile": 0.56848}, "CVE-2022-35652": {"epss_score": 0.00347, "epss_percentile": 0.56785}, "CVE-2022-35653": {"epss_score": 0.82285, "epss_percentile": 0.99184}, "CVE-2022-35654": {"epss_score": 0.00511, "epss_percentile": 0.65841}, "CVE-2022-35655": {"epss_score": 0.00196, "epss_percentile": 0.4182}, "CVE-2022-35656": {"epss_score": 0.00109, "epss_percentile": 0.29976}, "CVE-2022-35664": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-35665": {"epss_score": 0.05413, "epss_percentile": 0.89848}, "CVE-2022-35666": {"epss_score": 0.0101, "epss_percentile": 0.76596}, "CVE-2022-35667": {"epss_score": 0.00417, "epss_percentile": 0.61227}, "CVE-2022-35668": {"epss_score": 0.00058, "epss_percentile": 0.18525}, "CVE-2022-35669": {"epss_score": 0.00195, "epss_percentile": 0.41604}, "CVE-2022-35670": {"epss_score": 0.00361, "epss_percentile": 0.57736}, "CVE-2022-35671": {"epss_score": 0.00172, "epss_percentile": 0.38986}, "CVE-2022-35672": {"epss_score": 0.0023, "epss_percentile": 0.45695}, "CVE-2022-35673": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-35674": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-35675": {"epss_score": 0.00334, "epss_percentile": 0.55704}, "CVE-2022-35676": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-35677": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-35678": {"epss_score": 0.00172, "epss_percentile": 0.38986}, "CVE-2022-35689": {"epss_score": 0.00336, "epss_percentile": 0.56}, "CVE-2022-35690": {"epss_score": 0.15881, "epss_percentile": 0.94525}, "CVE-2022-35691": {"epss_score": 0.00119, "epss_percentile": 0.31555}, "CVE-2022-35692": {"epss_score": 0.00513, "epss_percentile": 0.65937}, "CVE-2022-35693": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-35694": {"epss_score": 0.00674, "epss_percentile": 0.70852}, "CVE-2022-35695": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-35696": {"epss_score": 0.00674, "epss_percentile": 0.70852}, "CVE-2022-35697": {"epss_score": 0.00379, "epss_percentile": 0.58864}, "CVE-2022-35698": {"epss_score": 0.03361, "epss_percentile": 0.86991}, "CVE-2022-35699": {"epss_score": 0.00088, "epss_percentile": 0.25788}, "CVE-2022-35700": {"epss_score": 0.00088, "epss_percentile": 0.25788}, "CVE-2022-35701": {"epss_score": 0.00088, "epss_percentile": 0.25788}, "CVE-2022-35702": {"epss_score": 0.0023, "epss_percentile": 0.45695}, "CVE-2022-35703": {"epss_score": 0.0023, "epss_percentile": 0.45695}, "CVE-2022-35704": {"epss_score": 0.00334, "epss_percentile": 0.55704}, "CVE-2022-35705": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-35706": {"epss_score": 0.00247, "epss_percentile": 0.47863}, "CVE-2022-35707": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-35708": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-35709": {"epss_score": 0.00301, "epss_percentile": 0.52999}, "CVE-2022-35710": {"epss_score": 0.21226, "epss_percentile": 0.9548}, "CVE-2022-35711": {"epss_score": 0.03442, "epss_percentile": 0.87143}, "CVE-2022-35712": {"epss_score": 0.21226, "epss_percentile": 0.9548}, "CVE-2022-35713": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-35714": {"epss_score": 0.00377, "epss_percentile": 0.58746}, "CVE-2022-35715": {"epss_score": 0.00148, "epss_percentile": 0.35886}, "CVE-2022-35716": {"epss_score": 0.00143, "epss_percentile": 0.35151}, "CVE-2022-35717": {"epss_score": 0.00108, "epss_percentile": 0.29813}, "CVE-2022-35719": {"epss_score": 0.00107, "epss_percentile": 0.29751}, "CVE-2022-35720": {"epss_score": 0.00012, "epss_percentile": 0.01271}, "CVE-2022-35721": {"epss_score": 0.0053, "epss_percentile": 0.6661}, "CVE-2022-35722": {"epss_score": 0.0033, "epss_percentile": 0.55458}, "CVE-2022-35724": {"epss_score": 0.00698, "epss_percentile": 0.71425}, "CVE-2022-35725": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2022-35726": {"epss_score": 0.00436, "epss_percentile": 0.62467}, "CVE-2022-35728": {"epss_score": 0.0068, "epss_percentile": 0.71034}, "CVE-2022-35729": {"epss_score": 0.00394, "epss_percentile": 0.59762}, "CVE-2022-35730": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-35733": {"epss_score": 0.01954, "epss_percentile": 0.83031}, "CVE-2022-35734": {"epss_score": 0.00265, "epss_percentile": 0.49825}, "CVE-2022-35735": {"epss_score": 0.01627, "epss_percentile": 0.81434}, "CVE-2022-35737": {"epss_score": 0.51941, "epss_percentile": 0.97802}, "CVE-2022-35739": {"epss_score": 0.01166, "epss_percentile": 0.78178}, "CVE-2022-35740": {"epss_score": 0.0102, "epss_percentile": 0.7674}, "CVE-2022-35741": {"epss_score": 0.1942, "epss_percentile": 0.95179}, "CVE-2022-35742": {"epss_score": 0.08104, "epss_percentile": 0.91881}, "CVE-2022-35743": {"epss_score": 0.0035, "epss_percentile": 0.5692}, "CVE-2022-35744": {"epss_score": 0.15192, "epss_percentile": 0.94381}, "CVE-2022-35745": {"epss_score": 0.02573, "epss_percentile": 0.85135}, "CVE-2022-35746": {"epss_score": 0.00365, "epss_percentile": 0.57974}, "CVE-2022-35747": {"epss_score": 0.0107, "epss_percentile": 0.77254}, "CVE-2022-35748": {"epss_score": 0.46151, "epss_percentile": 0.97533}, "CVE-2022-35749": {"epss_score": 0.00365, "epss_percentile": 0.57974}, "CVE-2022-35750": {"epss_score": 0.04946, "epss_percentile": 0.89318}, "CVE-2022-35751": {"epss_score": 0.07257, "epss_percentile": 0.91354}, "CVE-2022-35752": {"epss_score": 0.02573, "epss_percentile": 0.85135}, "CVE-2022-35753": {"epss_score": 0.02573, "epss_percentile": 0.85135}, "CVE-2022-35754": {"epss_score": 0.00139, "epss_percentile": 0.34586}, "CVE-2022-35755": {"epss_score": 0.18089, "epss_percentile": 0.94956}, "CVE-2022-35756": {"epss_score": 0.14194, "epss_percentile": 0.9416}, "CVE-2022-35757": {"epss_score": 0.00606, "epss_percentile": 0.69014}, "CVE-2022-35758": {"epss_score": 0.00316, "epss_percentile": 0.54241}, "CVE-2022-35759": {"epss_score": 0.04707, "epss_percentile": 0.89032}, "CVE-2022-35760": {"epss_score": 0.01113, "epss_percentile": 0.77688}, "CVE-2022-35761": {"epss_score": 0.02727, "epss_percentile": 0.85532}, "CVE-2022-35762": {"epss_score": 0.02802, "epss_percentile": 0.85699}, "CVE-2022-35763": {"epss_score": 0.02796, "epss_percentile": 0.85683}, "CVE-2022-35764": {"epss_score": 0.02796, "epss_percentile": 0.85683}, "CVE-2022-35765": {"epss_score": 0.02796, "epss_percentile": 0.85683}, "CVE-2022-35766": {"epss_score": 0.00843, "epss_percentile": 0.74249}, "CVE-2022-35767": {"epss_score": 0.01141, "epss_percentile": 0.77964}, "CVE-2022-35768": {"epss_score": 0.01672, "epss_percentile": 0.8168}, "CVE-2022-35769": {"epss_score": 0.1875, "epss_percentile": 0.95064}, "CVE-2022-35770": {"epss_score": 0.15238, "epss_percentile": 0.94391}, "CVE-2022-35771": {"epss_score": 0.02388, "epss_percentile": 0.84588}, "CVE-2022-35772": {"epss_score": 0.01679, "epss_percentile": 0.81721}, "CVE-2022-35773": {"epss_score": 0.0272, "epss_percentile": 0.85517}, "CVE-2022-35774": {"epss_score": 0.02134, "epss_percentile": 0.83723}, "CVE-2022-35775": {"epss_score": 0.01287, "epss_percentile": 0.79196}, "CVE-2022-35776": {"epss_score": 0.00674, "epss_percentile": 0.70874}, "CVE-2022-35777": {"epss_score": 0.00647, "epss_percentile": 0.70183}, "CVE-2022-35779": {"epss_score": 0.01123, "epss_percentile": 0.77789}, "CVE-2022-35780": {"epss_score": 0.01373, "epss_percentile": 0.79818}, "CVE-2022-35781": {"epss_score": 0.01373, "epss_percentile": 0.79818}, "CVE-2022-35782": {"epss_score": 0.01373, "epss_percentile": 0.79818}, "CVE-2022-35783": {"epss_score": 0.02352, "epss_percentile": 0.84472}, "CVE-2022-35784": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35785": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35786": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35787": {"epss_score": 0.06705, "epss_percentile": 0.90958}, "CVE-2022-35788": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35789": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35790": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35791": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35792": {"epss_score": 0.01256, "epss_percentile": 0.7894}, "CVE-2022-35793": {"epss_score": 0.06177, "epss_percentile": 0.90536}, "CVE-2022-35794": {"epss_score": 0.07549, "epss_percentile": 0.91532}, "CVE-2022-35795": {"epss_score": 0.01109, "epss_percentile": 0.77644}, "CVE-2022-35796": {"epss_score": 0.00877, "epss_percentile": 0.74814}, "CVE-2022-35797": {"epss_score": 0.00624, "epss_percentile": 0.69565}, "CVE-2022-35798": {"epss_score": 0.00355, "epss_percentile": 0.57286}, "CVE-2022-35799": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35800": {"epss_score": 0.06705, "epss_percentile": 0.90958}, "CVE-2022-35801": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35802": {"epss_score": 0.12997, "epss_percentile": 0.93839}, "CVE-2022-35803": {"epss_score": 0.0179, "epss_percentile": 0.82278}, "CVE-2022-35804": {"epss_score": 0.13073, "epss_percentile": 0.93865}, "CVE-2022-35805": {"epss_score": 0.08601, "epss_percentile": 0.92145}, "CVE-2022-35806": {"epss_score": 0.02105, "epss_percentile": 0.83622}, "CVE-2022-35807": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35808": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35809": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35810": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35811": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35812": {"epss_score": 0.09514, "epss_percentile": 0.9258}, "CVE-2022-35813": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35814": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35815": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35816": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35817": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35818": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35819": {"epss_score": 0.03915, "epss_percentile": 0.87945}, "CVE-2022-35820": {"epss_score": 0.01071, "epss_percentile": 0.77265}, "CVE-2022-35821": {"epss_score": 0.01963, "epss_percentile": 0.83074}, "CVE-2022-35822": {"epss_score": 0.00837, "epss_percentile": 0.7415}, "CVE-2022-35823": {"epss_score": 0.37375, "epss_percentile": 0.97037}, "CVE-2022-35824": {"epss_score": 0.17704, "epss_percentile": 0.94893}, "CVE-2022-35825": {"epss_score": 0.03409, "epss_percentile": 0.8708}, "CVE-2022-35826": {"epss_score": 0.09092, "epss_percentile": 0.92398}, "CVE-2022-35827": {"epss_score": 0.09092, "epss_percentile": 0.92398}, "CVE-2022-35828": {"epss_score": 0.00575, "epss_percentile": 0.68102}, "CVE-2022-35829": {"epss_score": 0.02557, "epss_percentile": 0.85096}, "CVE-2022-35830": {"epss_score": 0.05704, "epss_percentile": 0.90135}, "CVE-2022-35831": {"epss_score": 0.00646, "epss_percentile": 0.70139}, "CVE-2022-35832": {"epss_score": 0.00744, "epss_percentile": 0.72503}, "CVE-2022-35833": {"epss_score": 0.18733, "epss_percentile": 0.95061}, "CVE-2022-35834": {"epss_score": 0.13216, "epss_percentile": 0.93904}, "CVE-2022-35835": {"epss_score": 0.13313, "epss_percentile": 0.93931}, "CVE-2022-35836": {"epss_score": 0.13313, "epss_percentile": 0.93931}, "CVE-2022-35837": {"epss_score": 0.25179, "epss_percentile": 0.95995}, "CVE-2022-35838": {"epss_score": 0.1871, "epss_percentile": 0.95057}, "CVE-2022-35840": {"epss_score": 0.13313, "epss_percentile": 0.93931}, "CVE-2022-35841": {"epss_score": 0.25245, "epss_percentile": 0.96002}, "CVE-2022-35842": {"epss_score": 0.0049, "epss_percentile": 0.6493}, "CVE-2022-35843": {"epss_score": 0.00512, "epss_percentile": 0.65853}, "CVE-2022-35844": {"epss_score": 0.00342, "epss_percentile": 0.56389}, "CVE-2022-35845": {"epss_score": 0.01357, "epss_percentile": 0.79719}, "CVE-2022-35846": {"epss_score": 0.00758, "epss_percentile": 0.72776}, "CVE-2022-35847": {"epss_score": 0.01429, "epss_percentile": 0.80228}, "CVE-2022-35849": {"epss_score": 0.00313, "epss_percentile": 0.54044}, "CVE-2022-35850": {"epss_score": 0.00213, "epss_percentile": 0.43925}, "CVE-2022-35851": {"epss_score": 0.00838, "epss_percentile": 0.74178}, "CVE-2022-35857": {"epss_score": 0.01773, "epss_percentile": 0.82207}, "CVE-2022-35858": {"epss_score": 0.00053, "epss_percentile": 0.16926}, "CVE-2022-35860": {"epss_score": 0.00051, "epss_percentile": 0.16107}, "CVE-2022-35861": {"epss_score": 0.00044, "epss_percentile": 0.1359}, "CVE-2022-35864": {"epss_score": 0.0122, "epss_percentile": 0.78625}, "CVE-2022-35865": {"epss_score": 0.18092, "epss_percentile": 0.94956}, "CVE-2022-35866": {"epss_score": 0.00448, "epss_percentile": 0.63017}, "CVE-2022-35867": {"epss_score": 0.00104, "epss_percentile": 0.29224}, "CVE-2022-35868": {"epss_score": 0.00077, "epss_percentile": 0.23326}, "CVE-2022-35869": {"epss_score": 0.02561, "epss_percentile": 0.85106}, "CVE-2022-35870": {"epss_score": 0.19374, "epss_percentile": 0.9517}, "CVE-2022-35871": {"epss_score": 0.25204, "epss_percentile": 0.95997}, "CVE-2022-35872": {"epss_score": 0.00945, "epss_percentile": 0.75802}, "CVE-2022-35873": {"epss_score": 0.00495, "epss_percentile": 0.65133}, "CVE-2022-35874": {"epss_score": 0.00478, "epss_percentile": 0.64391}, "CVE-2022-35875": {"epss_score": 0.00478, "epss_percentile": 0.64391}, "CVE-2022-35876": {"epss_score": 0.00478, "epss_percentile": 0.64391}, "CVE-2022-35877": {"epss_score": 0.00478, "epss_percentile": 0.64391}, "CVE-2022-35878": {"epss_score": 0.00134, "epss_percentile": 0.33763}, "CVE-2022-35879": {"epss_score": 0.00134, "epss_percentile": 0.33763}, "CVE-2022-35880": {"epss_score": 0.00134, "epss_percentile": 0.33763}, "CVE-2022-35881": {"epss_score": 0.00134, "epss_percentile": 0.33763}, "CVE-2022-35882": {"epss_score": 0.00369, "epss_percentile": 0.58267}, "CVE-2022-35883": {"epss_score": 0.00058, "epss_percentile": 0.18544}, "CVE-2022-35884": {"epss_score": 0.0165, "epss_percentile": 0.81563}, "CVE-2022-35885": {"epss_score": 0.0165, "epss_percentile": 0.81563}, "CVE-2022-35886": {"epss_score": 0.0165, "epss_percentile": 0.81563}, "CVE-2022-35887": {"epss_score": 0.0165, "epss_percentile": 0.81563}, "CVE-2022-35888": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2022-35890": {"epss_score": 0.00985, "epss_percentile": 0.76327}, "CVE-2022-35893": {"epss_score": 0.00111, "epss_percentile": 0.30361}, "CVE-2022-35894": {"epss_score": 0.00054, "epss_percentile": 0.17256}, "CVE-2022-35895": {"epss_score": 0.00085, "epss_percentile": 0.25136}, "CVE-2022-35896": {"epss_score": 0.0008, "epss_percentile": 0.24118}, "CVE-2022-35897": {"epss_score": 0.00256, "epss_percentile": 0.48834}, "CVE-2022-35898": {"epss_score": 0.00089, "epss_percentile": 0.2592}, "CVE-2022-35899": {"epss_score": 0.00194, "epss_percentile": 0.41586}, "CVE-2022-35900": {"epss_score": 0.0006, "epss_percentile": 0.1915}, "CVE-2022-35901": {"epss_score": 0.0006, "epss_percentile": 0.1915}, "CVE-2022-35902": {"epss_score": 0.0006, "epss_percentile": 0.1915}, "CVE-2022-35903": {"epss_score": 0.0006, "epss_percentile": 0.1915}, "CVE-2022-35904": {"epss_score": 0.0006, "epss_percentile": 0.1915}, "CVE-2022-35905": {"epss_score": 0.0006, "epss_percentile": 0.1915}, "CVE-2022-35906": {"epss_score": 0.0006, "epss_percentile": 0.1915}, "CVE-2022-35908": {"epss_score": 0.00421, "epss_percentile": 0.61491}, "CVE-2022-35909": {"epss_score": 0.00744, "epss_percentile": 0.72505}, "CVE-2022-35910": {"epss_score": 0.00275, "epss_percentile": 0.50648}, "CVE-2022-35911": {"epss_score": 0.00271, "epss_percentile": 0.50287}, "CVE-2022-35912": {"epss_score": 0.04713, "epss_percentile": 0.8904}, "CVE-2022-35913": {"epss_score": 0.00123, "epss_percentile": 0.32336}, "CVE-2022-35914": {"epss_score": 0.94395, "epss_percentile": 0.99971}, "CVE-2022-35915": {"epss_score": 0.00289, "epss_percentile": 0.5202}, "CVE-2022-35916": {"epss_score": 0.00231, "epss_percentile": 0.4583}, "CVE-2022-35917": {"epss_score": 0.00285, "epss_percentile": 0.51671}, "CVE-2022-35918": {"epss_score": 0.02289, "epss_percentile": 0.84276}, "CVE-2022-35919": {"epss_score": 0.08284, "epss_percentile": 0.91969}, "CVE-2022-35920": {"epss_score": 0.00912, "epss_percentile": 0.75355}, "CVE-2022-35921": {"epss_score": 0.00159, "epss_percentile": 0.37359}, "CVE-2022-35922": {"epss_score": 0.00676, "epss_percentile": 0.7092}, "CVE-2022-35923": {"epss_score": 0.00192, "epss_percentile": 0.41336}, "CVE-2022-35924": {"epss_score": 0.0042, "epss_percentile": 0.61459}, "CVE-2022-35925": {"epss_score": 0.00468, "epss_percentile": 0.63883}, "CVE-2022-35926": {"epss_score": 0.00534, "epss_percentile": 0.66781}, "CVE-2022-35927": {"epss_score": 0.00579, "epss_percentile": 0.68233}, "CVE-2022-35928": {"epss_score": 0.00031, "epss_percentile": 0.08453}, "CVE-2022-35929": {"epss_score": 0.00196, "epss_percentile": 0.41748}, "CVE-2022-35930": {"epss_score": 0.00204, "epss_percentile": 0.42592}, "CVE-2022-35931": {"epss_score": 0.00058, "epss_percentile": 0.18399}, "CVE-2022-35932": {"epss_score": 0.00766, "epss_percentile": 0.72945}, "CVE-2022-35933": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-35934": {"epss_score": 0.00039, "epss_percentile": 0.1146}, "CVE-2022-35935": {"epss_score": 0.00108, "epss_percentile": 0.29758}, "CVE-2022-35936": {"epss_score": 0.00141, "epss_percentile": 0.34936}, "CVE-2022-35937": {"epss_score": 0.0012, "epss_percentile": 0.31703}, "CVE-2022-35938": {"epss_score": 0.0012, "epss_percentile": 0.31703}, "CVE-2022-35939": {"epss_score": 0.00219, "epss_percentile": 0.44504}, "CVE-2022-35940": {"epss_score": 0.00181, "epss_percentile": 0.40056}, "CVE-2022-35941": {"epss_score": 0.00379, "epss_percentile": 0.58894}, "CVE-2022-35942": {"epss_score": 0.00182, "epss_percentile": 0.40261}, "CVE-2022-35943": {"epss_score": 0.00145, "epss_percentile": 0.35379}, "CVE-2022-35944": {"epss_score": 0.00504, "epss_percentile": 0.65551}, "CVE-2022-35945": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-35946": {"epss_score": 0.00313, "epss_percentile": 0.54057}, "CVE-2022-35947": {"epss_score": 0.00364, "epss_percentile": 0.57919}, "CVE-2022-35948": {"epss_score": 0.00174, "epss_percentile": 0.3922}, "CVE-2022-35949": {"epss_score": 0.00381, "epss_percentile": 0.58979}, "CVE-2022-35950": {"epss_score": 0.00072, "epss_percentile": 0.22252}, "CVE-2022-35951": {"epss_score": 0.78854, "epss_percentile": 0.99007}, "CVE-2022-35952": {"epss_score": 0.00208, "epss_percentile": 0.43209}, "CVE-2022-35953": {"epss_score": 0.00241, "epss_percentile": 0.4728}, "CVE-2022-35954": {"epss_score": 0.00365, "epss_percentile": 0.57999}, "CVE-2022-35956": {"epss_score": 0.00218, "epss_percentile": 0.44401}, "CVE-2022-35957": {"epss_score": 0.00872, "epss_percentile": 0.74734}, "CVE-2022-35959": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35960": {"epss_score": 0.00198, "epss_percentile": 0.42002}, "CVE-2022-35961": {"epss_score": 0.00156, "epss_percentile": 0.36892}, "CVE-2022-35962": {"epss_score": 0.00545, "epss_percentile": 0.67157}, "CVE-2022-35963": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35964": {"epss_score": 0.00039, "epss_percentile": 0.1146}, "CVE-2022-35965": {"epss_score": 0.00071, "epss_percentile": 0.22088}, "CVE-2022-35966": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35967": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35968": {"epss_score": 0.00067, "epss_percentile": 0.20979}, "CVE-2022-35969": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35970": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35971": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35972": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35973": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35974": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35975": {"epss_score": 0.01255, "epss_percentile": 0.78931}, "CVE-2022-35976": {"epss_score": 0.00344, "epss_percentile": 0.56523}, "CVE-2022-35977": {"epss_score": 0.27655, "epss_percentile": 0.9627}, "CVE-2022-35978": {"epss_score": 0.14523, "epss_percentile": 0.94231}, "CVE-2022-35979": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35980": {"epss_score": 0.00246, "epss_percentile": 0.47789}, "CVE-2022-35981": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35982": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35983": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35984": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35985": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35986": {"epss_score": 0.00066, "epss_percentile": 0.20756}, "CVE-2022-35987": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35988": {"epss_score": 0.0007, "epss_percentile": 0.21715}, "CVE-2022-35989": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35990": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35991": {"epss_score": 0.00263, "epss_percentile": 0.49501}, "CVE-2022-35992": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35993": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35994": {"epss_score": 0.00039, "epss_percentile": 0.1146}, "CVE-2022-35995": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35996": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-35997": {"epss_score": 0.00044, "epss_percentile": 0.13602}, "CVE-2022-35998": {"epss_score": 0.0007, "epss_percentile": 0.21715}, "CVE-2022-35999": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-36000": {"epss_score": 0.00071, "epss_percentile": 0.22088}, "CVE-2022-36001": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-36002": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-36003": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-36004": {"epss_score": 0.0007, "epss_percentile": 0.21715}, "CVE-2022-36005": {"epss_score": 0.00067, "epss_percentile": 0.20979}, "CVE-2022-36006": {"epss_score": 0.01532, "epss_percentile": 0.80894}, "CVE-2022-36007": {"epss_score": 0.00137, "epss_percentile": 0.3432}, "CVE-2022-36008": {"epss_score": 0.00438, "epss_percentile": 0.62538}, "CVE-2022-36009": {"epss_score": 0.00623, "epss_percentile": 0.6954}, "CVE-2022-36010": {"epss_score": 0.00486, "epss_percentile": 0.64766}, "CVE-2022-36011": {"epss_score": 0.00071, "epss_percentile": 0.22088}, "CVE-2022-36012": {"epss_score": 0.00181, "epss_percentile": 0.40056}, "CVE-2022-36013": {"epss_score": 0.00211, "epss_percentile": 0.43636}, "CVE-2022-36014": {"epss_score": 0.00316, "epss_percentile": 0.54287}, "CVE-2022-36015": {"epss_score": 0.00181, "epss_percentile": 0.40056}, "CVE-2022-36016": {"epss_score": 0.00181, "epss_percentile": 0.40056}, "CVE-2022-36017": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-36018": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-36019": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-36020": {"epss_score": 0.00301, "epss_percentile": 0.53072}, "CVE-2022-36021": {"epss_score": 0.60647, "epss_percentile": 0.98214}, "CVE-2022-36022": {"epss_score": 0.0022, "epss_percentile": 0.44612}, "CVE-2022-36023": {"epss_score": 0.00594, "epss_percentile": 0.68673}, "CVE-2022-36024": {"epss_score": 0.00266, "epss_percentile": 0.49867}, "CVE-2022-36025": {"epss_score": 0.00649, "epss_percentile": 0.70243}, "CVE-2022-36026": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2022-36027": {"epss_score": 0.00253, "epss_percentile": 0.48462}, "CVE-2022-36028": {"epss_score": 0.00075, "epss_percentile": 0.22959}, "CVE-2022-36029": {"epss_score": 0.00075, "epss_percentile": 0.22959}, "CVE-2022-36030": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36031": {"epss_score": 0.00246, "epss_percentile": 0.47782}, "CVE-2022-36032": {"epss_score": 0.00308, "epss_percentile": 0.53639}, "CVE-2022-36033": {"epss_score": 0.01637, "epss_percentile": 0.81482}, "CVE-2022-36034": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-36035": {"epss_score": 0.00103, "epss_percentile": 0.29016}, "CVE-2022-36036": {"epss_score": 0.00129, "epss_percentile": 0.33112}, "CVE-2022-36037": {"epss_score": 0.00627, "epss_percentile": 0.69638}, "CVE-2022-36038": {"epss_score": 0.01471, "epss_percentile": 0.80503}, "CVE-2022-36039": {"epss_score": 0.00467, "epss_percentile": 0.63829}, "CVE-2022-36040": {"epss_score": 0.00093, "epss_percentile": 0.26722}, "CVE-2022-36041": {"epss_score": 0.00178, "epss_percentile": 0.39737}, "CVE-2022-36042": {"epss_score": 0.00156, "epss_percentile": 0.37013}, "CVE-2022-36043": {"epss_score": 0.00156, "epss_percentile": 0.37013}, "CVE-2022-36044": {"epss_score": 0.00151, "epss_percentile": 0.36187}, "CVE-2022-36045": {"epss_score": 0.00675, "epss_percentile": 0.70905}, "CVE-2022-36046": {"epss_score": 0.00414, "epss_percentile": 0.6102}, "CVE-2022-36048": {"epss_score": 0.00254, "epss_percentile": 0.48555}, "CVE-2022-36049": {"epss_score": 0.00136, "epss_percentile": 0.34143}, "CVE-2022-36051": {"epss_score": 0.00285, "epss_percentile": 0.51515}, "CVE-2022-36052": {"epss_score": 0.00297, "epss_percentile": 0.52704}, "CVE-2022-36053": {"epss_score": 0.00185, "epss_percentile": 0.40487}, "CVE-2022-36054": {"epss_score": 0.00297, "epss_percentile": 0.52704}, "CVE-2022-36055": {"epss_score": 0.00072, "epss_percentile": 0.22319}, "CVE-2022-36056": {"epss_score": 0.00034, "epss_percentile": 0.09713}, "CVE-2022-36057": {"epss_score": 0.00183, "epss_percentile": 0.40347}, "CVE-2022-36058": {"epss_score": 0.00282, "epss_percentile": 0.51241}, "CVE-2022-36059": {"epss_score": 0.01132, "epss_percentile": 0.77872}, "CVE-2022-36060": {"epss_score": 0.00228, "epss_percentile": 0.45534}, "CVE-2022-36061": {"epss_score": 0.00408, "epss_percentile": 0.60687}, "CVE-2022-36062": {"epss_score": 0.00154, "epss_percentile": 0.36694}, "CVE-2022-36063": {"epss_score": 0.04157, "epss_percentile": 0.8833}, "CVE-2022-36064": {"epss_score": 0.00532, "epss_percentile": 0.66676}, "CVE-2022-36065": {"epss_score": 0.02014, "epss_percentile": 0.8327}, "CVE-2022-36066": {"epss_score": 0.03565, "epss_percentile": 0.87361}, "CVE-2022-36067": {"epss_score": 0.85411, "epss_percentile": 0.99332}, "CVE-2022-36068": {"epss_score": 0.00337, "epss_percentile": 0.56036}, "CVE-2022-36069": {"epss_score": 0.0072, "epss_percentile": 0.71957}, "CVE-2022-36070": {"epss_score": 0.00113, "epss_percentile": 0.30682}, "CVE-2022-36071": {"epss_score": 0.00119, "epss_percentile": 0.31605}, "CVE-2022-36072": {"epss_score": 0.00231, "epss_percentile": 0.4583}, "CVE-2022-36073": {"epss_score": 0.00363, "epss_percentile": 0.57846}, "CVE-2022-36074": {"epss_score": 0.00128, "epss_percentile": 0.33012}, "CVE-2022-36075": {"epss_score": 0.00157, "epss_percentile": 0.37104}, "CVE-2022-36076": {"epss_score": 0.00139, "epss_percentile": 0.34556}, "CVE-2022-36077": {"epss_score": 0.00088, "epss_percentile": 0.25665}, "CVE-2022-36078": {"epss_score": 0.00554, "epss_percentile": 0.67444}, "CVE-2022-36079": {"epss_score": 0.00565, "epss_percentile": 0.67782}, "CVE-2022-36080": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-36081": {"epss_score": 0.00414, "epss_percentile": 0.61028}, "CVE-2022-36082": {"epss_score": 0.0022, "epss_percentile": 0.44612}, "CVE-2022-36083": {"epss_score": 0.00386, "epss_percentile": 0.59263}, "CVE-2022-36084": {"epss_score": 0.0103, "epss_percentile": 0.76844}, "CVE-2022-36085": {"epss_score": 0.00287, "epss_percentile": 0.51811}, "CVE-2022-36086": {"epss_score": 0.00281, "epss_percentile": 0.51199}, "CVE-2022-36087": {"epss_score": 0.00348, "epss_percentile": 0.56823}, "CVE-2022-36088": {"epss_score": 0.00037, "epss_percentile": 0.10651}, "CVE-2022-36089": {"epss_score": 0.00319, "epss_percentile": 0.54551}, "CVE-2022-36090": {"epss_score": 0.01329, "epss_percentile": 0.79504}, "CVE-2022-36091": {"epss_score": 0.00451, "epss_percentile": 0.63112}, "CVE-2022-36092": {"epss_score": 0.00294, "epss_percentile": 0.52437}, "CVE-2022-36093": {"epss_score": 0.045, "epss_percentile": 0.88765}, "CVE-2022-36094": {"epss_score": 0.49213, "epss_percentile": 0.97674}, "CVE-2022-36095": {"epss_score": 0.00112, "epss_percentile": 0.30427}, "CVE-2022-36096": {"epss_score": 0.54514, "epss_percentile": 0.97931}, "CVE-2022-36097": {"epss_score": 0.44185, "epss_percentile": 0.97423}, "CVE-2022-36098": {"epss_score": 0.4365, "epss_percentile": 0.97397}, "CVE-2022-36099": {"epss_score": 0.21705, "epss_percentile": 0.9555}, "CVE-2022-36100": {"epss_score": 0.08275, "epss_percentile": 0.91963}, "CVE-2022-36101": {"epss_score": 0.00465, "epss_percentile": 0.63741}, "CVE-2022-36102": {"epss_score": 0.00612, "epss_percentile": 0.69215}, "CVE-2022-36103": {"epss_score": 0.00259, "epss_percentile": 0.49075}, "CVE-2022-36104": {"epss_score": 0.0056, "epss_percentile": 0.67652}, "CVE-2022-36105": {"epss_score": 0.00283, "epss_percentile": 0.51363}, "CVE-2022-36106": {"epss_score": 0.00198, "epss_percentile": 0.42008}, "CVE-2022-36107": {"epss_score": 0.00687, "epss_percentile": 0.71189}, "CVE-2022-36108": {"epss_score": 0.00687, "epss_percentile": 0.71189}, "CVE-2022-36109": {"epss_score": 0.00029, "epss_percentile": 0.07734}, "CVE-2022-36110": {"epss_score": 0.00283, "epss_percentile": 0.51364}, "CVE-2022-36111": {"epss_score": 0.00292, "epss_percentile": 0.52242}, "CVE-2022-36112": {"epss_score": 0.00169, "epss_percentile": 0.38546}, "CVE-2022-36113": {"epss_score": 0.03685, "epss_percentile": 0.87568}, "CVE-2022-36114": {"epss_score": 0.00341, "epss_percentile": 0.56299}, "CVE-2022-36115": {"epss_score": 0.00625, "epss_percentile": 0.69589}, "CVE-2022-36116": {"epss_score": 0.00407, "epss_percentile": 0.60606}, "CVE-2022-36117": {"epss_score": 0.00345, "epss_percentile": 0.56596}, "CVE-2022-36118": {"epss_score": 0.00345, "epss_percentile": 0.56603}, "CVE-2022-36119": {"epss_score": 0.06908, "epss_percentile": 0.91111}, "CVE-2022-36120": {"epss_score": 0.00832, "epss_percentile": 0.74062}, "CVE-2022-36121": {"epss_score": 0.00345, "epss_percentile": 0.56603}, "CVE-2022-36122": {"epss_score": 0.00071, "epss_percentile": 0.22233}, "CVE-2022-36123": {"epss_score": 0.00024, "epss_percentile": 0.05769}, "CVE-2022-36124": {"epss_score": 0.02955, "epss_percentile": 0.8606}, "CVE-2022-36125": {"epss_score": 0.01244, "epss_percentile": 0.78834}, "CVE-2022-36126": {"epss_score": 0.03866, "epss_percentile": 0.87872}, "CVE-2022-36127": {"epss_score": 0.05156, "epss_percentile": 0.89552}, "CVE-2022-36129": {"epss_score": 0.01467, "epss_percentile": 0.80475}, "CVE-2022-36130": {"epss_score": 0.00168, "epss_percentile": 0.38458}, "CVE-2022-36131": {"epss_score": 0.00399, "epss_percentile": 0.60132}, "CVE-2022-36133": {"epss_score": 0.00368, "epss_percentile": 0.58196}, "CVE-2022-36136": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-36137": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-36139": {"epss_score": 0.00054, "epss_percentile": 0.17325}, "CVE-2022-36140": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-36141": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-36142": {"epss_score": 0.00054, "epss_percentile": 0.17325}, "CVE-2022-36143": {"epss_score": 0.00054, "epss_percentile": 0.17325}, "CVE-2022-36144": {"epss_score": 0.00054, "epss_percentile": 0.17325}, "CVE-2022-36145": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-36146": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-36148": {"epss_score": 0.00042, "epss_percentile": 0.12616}, "CVE-2022-36149": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2022-36150": {"epss_score": 0.00049, "epss_percentile": 0.15477}, "CVE-2022-36151": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2022-36152": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2022-36153": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2022-36155": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2022-36157": {"epss_score": 0.18989, "epss_percentile": 0.95107}, "CVE-2022-36158": {"epss_score": 0.00495, "epss_percentile": 0.65104}, "CVE-2022-36159": {"epss_score": 0.00281, "epss_percentile": 0.51107}, "CVE-2022-36161": {"epss_score": 0.00517, "epss_percentile": 0.66088}, "CVE-2022-36168": {"epss_score": 0.00448, "epss_percentile": 0.63}, "CVE-2022-36170": {"epss_score": 0.00203, "epss_percentile": 0.42523}, "CVE-2022-36171": {"epss_score": 0.00144, "epss_percentile": 0.35296}, "CVE-2022-36173": {"epss_score": 0.00434, "epss_percentile": 0.62301}, "CVE-2022-36174": {"epss_score": 0.00191, "epss_percentile": 0.41193}, "CVE-2022-36179": {"epss_score": 0.00139, "epss_percentile": 0.34539}, "CVE-2022-36180": {"epss_score": 0.00159, "epss_percentile": 0.3741}, "CVE-2022-36182": {"epss_score": 0.00191, "epss_percentile": 0.41263}, "CVE-2022-36186": {"epss_score": 0.00288, "epss_percentile": 0.51914}, "CVE-2022-36190": {"epss_score": 0.00112, "epss_percentile": 0.30523}, "CVE-2022-36191": {"epss_score": 0.00028, "epss_percentile": 0.07248}, "CVE-2022-36193": {"epss_score": 0.02166, "epss_percentile": 0.83849}, "CVE-2022-36194": {"epss_score": 0.00151, "epss_percentile": 0.36326}, "CVE-2022-36197": {"epss_score": 0.00331, "epss_percentile": 0.55525}, "CVE-2022-36198": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36200": {"epss_score": 0.00219, "epss_percentile": 0.44513}, "CVE-2022-36201": {"epss_score": 0.00665, "epss_percentile": 0.70657}, "CVE-2022-36202": {"epss_score": 0.00412, "epss_percentile": 0.60944}, "CVE-2022-36203": {"epss_score": 0.00424, "epss_percentile": 0.61654}, "CVE-2022-36215": {"epss_score": 0.15442, "epss_percentile": 0.94431}, "CVE-2022-36216": {"epss_score": 0.04568, "epss_percentile": 0.88861}, "CVE-2022-36220": {"epss_score": 0.01023, "epss_percentile": 0.7677}, "CVE-2022-36221": {"epss_score": 0.00516, "epss_percentile": 0.66013}, "CVE-2022-36222": {"epss_score": 0.00124, "epss_percentile": 0.32455}, "CVE-2022-36223": {"epss_score": 0.00287, "epss_percentile": 0.5185}, "CVE-2022-36224": {"epss_score": 0.00182, "epss_percentile": 0.40241}, "CVE-2022-36225": {"epss_score": 0.00199, "epss_percentile": 0.42096}, "CVE-2022-36226": {"epss_score": 0.00389, "epss_percentile": 0.59472}, "CVE-2022-36227": {"epss_score": 0.00424, "epss_percentile": 0.61656}, "CVE-2022-36228": {"epss_score": 0.00065, "epss_percentile": 0.20499}, "CVE-2022-36231": {"epss_score": 0.27288, "epss_percentile": 0.96231}, "CVE-2022-36233": {"epss_score": 0.00057, "epss_percentile": 0.181}, "CVE-2022-36234": {"epss_score": 0.00158, "epss_percentile": 0.37176}, "CVE-2022-36242": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36243": {"epss_score": 0.00257, "epss_percentile": 0.48893}, "CVE-2022-36244": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2022-36246": {"epss_score": 0.00074, "epss_percentile": 0.22822}, "CVE-2022-36247": {"epss_score": 0.00079, "epss_percentile": 0.2382}, "CVE-2022-36249": {"epss_score": 0.00035, "epss_percentile": 0.10057}, "CVE-2022-36250": {"epss_score": 0.00076, "epss_percentile": 0.23118}, "CVE-2022-36251": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-36254": {"epss_score": 0.00175, "epss_percentile": 0.39372}, "CVE-2022-36255": {"epss_score": 0.00306, "epss_percentile": 0.53427}, "CVE-2022-36256": {"epss_score": 0.00306, "epss_percentile": 0.53427}, "CVE-2022-36257": {"epss_score": 0.00306, "epss_percentile": 0.53427}, "CVE-2022-36258": {"epss_score": 0.00306, "epss_percentile": 0.53427}, "CVE-2022-36259": {"epss_score": 0.00306, "epss_percentile": 0.53427}, "CVE-2022-36261": {"epss_score": 0.00844, "epss_percentile": 0.74272}, "CVE-2022-36262": {"epss_score": 0.00692, "epss_percentile": 0.71284}, "CVE-2022-36263": {"epss_score": 0.00062, "epss_percentile": 0.19743}, "CVE-2022-36264": {"epss_score": 0.01376, "epss_percentile": 0.79834}, "CVE-2022-36265": {"epss_score": 0.00509, "epss_percentile": 0.65742}, "CVE-2022-36266": {"epss_score": 0.00346, "epss_percentile": 0.56625}, "CVE-2022-36267": {"epss_score": 0.74736, "epss_percentile": 0.98815}, "CVE-2022-36270": {"epss_score": 0.00906, "epss_percentile": 0.75255}, "CVE-2022-36271": {"epss_score": 0.01601, "epss_percentile": 0.81267}, "CVE-2022-36272": {"epss_score": 0.00388, "epss_percentile": 0.59342}, "CVE-2022-36273": {"epss_score": 0.18362, "epss_percentile": 0.95005}, "CVE-2022-36276": {"epss_score": 0.00208, "epss_percentile": 0.43209}, "CVE-2022-36277": {"epss_score": 0.00055, "epss_percentile": 0.17502}, "CVE-2022-36278": {"epss_score": 0.00118, "epss_percentile": 0.31413}, "CVE-2022-36279": {"epss_score": 0.08433, "epss_percentile": 0.9205}, "CVE-2022-36280": {"epss_score": 0.00037, "epss_percentile": 0.10782}, "CVE-2022-36282": {"epss_score": 0.00192, "epss_percentile": 0.41357}, "CVE-2022-36284": {"epss_score": 0.0019, "epss_percentile": 0.41053}, "CVE-2022-36285": {"epss_score": 0.01851, "epss_percentile": 0.82536}, "CVE-2022-36287": {"epss_score": 0.00077, "epss_percentile": 0.23378}, "CVE-2022-36288": {"epss_score": 0.00104, "epss_percentile": 0.29139}, "CVE-2022-36289": {"epss_score": 0.00058, "epss_percentile": 0.18544}, "CVE-2022-36292": {"epss_score": 0.00113, "epss_percentile": 0.30721}, "CVE-2022-36293": {"epss_score": 0.02278, "epss_percentile": 0.84236}, "CVE-2022-36296": {"epss_score": 0.00171, "epss_percentile": 0.38882}, "CVE-2022-36301": {"epss_score": 0.00303, "epss_percentile": 0.5322}, "CVE-2022-36302": {"epss_score": 0.00688, "epss_percentile": 0.71198}, "CVE-2022-36303": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2022-36304": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2022-36305": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2022-36306": {"epss_score": 0.00353, "epss_percentile": 0.5719}, "CVE-2022-36307": {"epss_score": 0.00139, "epss_percentile": 0.34566}, "CVE-2022-36308": {"epss_score": 0.00261, "epss_percentile": 0.49285}, "CVE-2022-36309": {"epss_score": 0.17729, "epss_percentile": 0.94896}, "CVE-2022-36310": {"epss_score": 0.00953, "epss_percentile": 0.7589}, "CVE-2022-36311": {"epss_score": 0.00542, "epss_percentile": 0.67078}, "CVE-2022-36312": {"epss_score": 0.00142, "epss_percentile": 0.34977}, "CVE-2022-36313": {"epss_score": 0.00119, "epss_percentile": 0.31611}, "CVE-2022-36314": {"epss_score": 0.00034, "epss_percentile": 0.09531}, "CVE-2022-36315": {"epss_score": 0.00159, "epss_percentile": 0.37375}, "CVE-2022-36316": {"epss_score": 0.00262, "epss_percentile": 0.4935}, "CVE-2022-36317": {"epss_score": 0.00221, "epss_percentile": 0.44672}, "CVE-2022-36318": {"epss_score": 0.00162, "epss_percentile": 0.37741}, "CVE-2022-36319": {"epss_score": 0.00123, "epss_percentile": 0.32273}, "CVE-2022-36320": {"epss_score": 0.00419, "epss_percentile": 0.614}, "CVE-2022-36321": {"epss_score": 7e-05, "epss_percentile": 0.00363}, "CVE-2022-36322": {"epss_score": 5e-05, "epss_percentile": 0.00225}, "CVE-2022-36323": {"epss_score": 0.00479, "epss_percentile": 0.64417}, "CVE-2022-36324": {"epss_score": 0.01258, "epss_percentile": 0.78952}, "CVE-2022-36325": {"epss_score": 0.00369, "epss_percentile": 0.58275}, "CVE-2022-36326": {"epss_score": 0.0011, "epss_percentile": 0.30082}, "CVE-2022-36327": {"epss_score": 0.00181, "epss_percentile": 0.40124}, "CVE-2022-36328": {"epss_score": 0.00072, "epss_percentile": 0.2239}, "CVE-2022-36329": {"epss_score": 0.00086, "epss_percentile": 0.25287}, "CVE-2022-36330": {"epss_score": 0.00228, "epss_percentile": 0.45461}, "CVE-2022-36331": {"epss_score": 0.00283, "epss_percentile": 0.51372}, "CVE-2022-36336": {"epss_score": 0.00071, "epss_percentile": 0.22067}, "CVE-2022-36337": {"epss_score": 0.0006, "epss_percentile": 0.19029}, "CVE-2022-36338": {"epss_score": 0.00092, "epss_percentile": 0.26509}, "CVE-2022-36339": {"epss_score": 0.00055, "epss_percentile": 0.17519}, "CVE-2022-36340": {"epss_score": 0.00178, "epss_percentile": 0.39726}, "CVE-2022-36341": {"epss_score": 0.00197, "epss_percentile": 0.41898}, "CVE-2022-36343": {"epss_score": 0.00176, "epss_percentile": 0.39407}, "CVE-2022-36344": {"epss_score": 0.00712, "epss_percentile": 0.71772}, "CVE-2022-36345": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2022-36346": {"epss_score": 0.00106, "epss_percentile": 0.29524}, "CVE-2022-36347": {"epss_score": 0.00245, "epss_percentile": 0.47663}, "CVE-2022-36348": {"epss_score": 0.00122, "epss_percentile": 0.32111}, "CVE-2022-36349": {"epss_score": 0.00147, "epss_percentile": 0.35753}, "CVE-2022-36350": {"epss_score": 0.00217, "epss_percentile": 0.4427}, "CVE-2022-36351": {"epss_score": 0.00071, "epss_percentile": 0.22181}, "CVE-2022-36352": {"epss_score": 0.00242, "epss_percentile": 0.47393}, "CVE-2022-36354": {"epss_score": 0.00098, "epss_percentile": 0.27803}, "CVE-2022-36355": {"epss_score": 0.0018, "epss_percentile": 0.39928}, "CVE-2022-36356": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2022-36357": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-36358": {"epss_score": 0.00121, "epss_percentile": 0.31886}, "CVE-2022-36359": {"epss_score": 0.00582, "epss_percentile": 0.68305}, "CVE-2022-36360": {"epss_score": 0.00179, "epss_percentile": 0.39788}, "CVE-2022-36361": {"epss_score": 0.00551, "epss_percentile": 0.67357}, "CVE-2022-36362": {"epss_score": 0.00809, "epss_percentile": 0.73702}, "CVE-2022-36363": {"epss_score": 0.00263, "epss_percentile": 0.4951}, "CVE-2022-36364": {"epss_score": 0.11793, "epss_percentile": 0.93477}, "CVE-2022-36365": {"epss_score": 0.00279, "epss_percentile": 0.50955}, "CVE-2022-36367": {"epss_score": 0.00037, "epss_percentile": 0.10858}, "CVE-2022-36368": {"epss_score": 0.00235, "epss_percentile": 0.46333}, "CVE-2022-36369": {"epss_score": 0.00071, "epss_percentile": 0.22216}, "CVE-2022-36370": {"epss_score": 0.00123, "epss_percentile": 0.32198}, "CVE-2022-36372": {"epss_score": 0.00042, "epss_percentile": 0.12646}, "CVE-2022-36373": {"epss_score": 0.00145, "epss_percentile": 0.35351}, "CVE-2022-36374": {"epss_score": 0.00078, "epss_percentile": 0.23597}, "CVE-2022-36375": {"epss_score": 0.01027, "epss_percentile": 0.76805}, "CVE-2022-36376": {"epss_score": 0.00615, "epss_percentile": 0.69303}, "CVE-2022-36377": {"epss_score": 0.00087, "epss_percentile": 0.25516}, "CVE-2022-36378": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2022-36379": {"epss_score": 0.00141, "epss_percentile": 0.34865}, "CVE-2022-36380": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2022-36381": {"epss_score": 0.05059, "epss_percentile": 0.89451}, "CVE-2022-36382": {"epss_score": 0.00044, "epss_percentile": 0.13549}, "CVE-2022-36383": {"epss_score": 0.0018, "epss_percentile": 0.39928}, "CVE-2022-36384": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2022-36385": {"epss_score": 0.00071, "epss_percentile": 0.22079}, "CVE-2022-36386": {"epss_score": 0.05773, "epss_percentile": 0.90194}, "CVE-2022-36387": {"epss_score": 0.00645, "epss_percentile": 0.7011}, "CVE-2022-36388": {"epss_score": 0.00104, "epss_percentile": 0.2915}, "CVE-2022-36389": {"epss_score": 0.00116, "epss_percentile": 0.31155}, "CVE-2022-36390": {"epss_score": 0.00251, "epss_percentile": 0.48293}, "CVE-2022-36391": {"epss_score": 0.00052, "epss_percentile": 0.16541}, "CVE-2022-36392": {"epss_score": 0.00113, "epss_percentile": 0.30718}, "CVE-2022-36394": {"epss_score": 0.00537, "epss_percentile": 0.66918}, "CVE-2022-36396": {"epss_score": 0.00075, "epss_percentile": 0.23019}, "CVE-2022-36397": {"epss_score": 0.00071, "epss_percentile": 0.22035}, "CVE-2022-36398": {"epss_score": 0.00097, "epss_percentile": 0.2751}, "CVE-2022-36399": {"epss_score": 0.00589, "epss_percentile": 0.68518}, "CVE-2022-36400": {"epss_score": 0.00049, "epss_percentile": 0.15326}, "CVE-2022-36401": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2022-36402": {"epss_score": 0.00023, "epss_percentile": 0.05442}, "CVE-2022-36403": {"epss_score": 0.00068, "epss_percentile": 0.21419}, "CVE-2022-36404": {"epss_score": 0.00108, "epss_percentile": 0.29759}, "CVE-2022-36405": {"epss_score": 0.00197, "epss_percentile": 0.41898}, "CVE-2022-36407": {"epss_score": 0.00083, "epss_percentile": 0.24743}, "CVE-2022-36412": {"epss_score": 0.01497, "epss_percentile": 0.80689}, "CVE-2022-36413": {"epss_score": 0.01001, "epss_percentile": 0.76497}, "CVE-2022-36414": {"epss_score": 0.00058, "epss_percentile": 0.18451}, "CVE-2022-36415": {"epss_score": 0.00056, "epss_percentile": 0.17789}, "CVE-2022-36416": {"epss_score": 0.00082, "epss_percentile": 0.24547}, "CVE-2022-36417": {"epss_score": 0.00093, "epss_percentile": 0.2674}, "CVE-2022-36418": {"epss_score": 0.00231, "epss_percentile": 0.45788}, "CVE-2022-36422": {"epss_score": 0.00151, "epss_percentile": 0.36253}, "CVE-2022-36423": {"epss_score": 0.0013, "epss_percentile": 0.33302}, "CVE-2022-36424": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-36425": {"epss_score": 0.00573, "epss_percentile": 0.68048}, "CVE-2022-36427": {"epss_score": 0.00632, "epss_percentile": 0.69737}, "CVE-2022-36428": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-36429": {"epss_score": 0.00218, "epss_percentile": 0.44366}, "CVE-2022-36431": {"epss_score": 0.03008, "epss_percentile": 0.86189}, "CVE-2022-36432": {"epss_score": 0.00252, "epss_percentile": 0.48373}, "CVE-2022-36433": {"epss_score": 0.00277, "epss_percentile": 0.5084}, "CVE-2022-36436": {"epss_score": 0.01771, "epss_percentile": 0.82195}, "CVE-2022-36437": {"epss_score": 0.00285, "epss_percentile": 0.51659}, "CVE-2022-36438": {"epss_score": 0.00068, "epss_percentile": 0.21266}, "CVE-2022-36439": {"epss_score": 0.001, "epss_percentile": 0.28508}, "CVE-2022-36440": {"epss_score": 0.00239, "epss_percentile": 0.46882}, "CVE-2022-36441": {"epss_score": 0.0005, "epss_percentile": 0.15855}, "CVE-2022-36442": {"epss_score": 0.00034, "epss_percentile": 0.09736}, "CVE-2022-36443": {"epss_score": 0.00037, "epss_percentile": 0.10664}, "CVE-2022-36444": {"epss_score": 0.02294, "epss_percentile": 0.84289}, "CVE-2022-36446": {"epss_score": 0.93625, "epss_percentile": 0.99826}, "CVE-2022-36447": {"epss_score": 0.00216, "epss_percentile": 0.44229}, "CVE-2022-36448": {"epss_score": 0.00078, "epss_percentile": 0.23687}, "CVE-2022-36449": {"epss_score": 0.00454, "epss_percentile": 0.63266}, "CVE-2022-36450": {"epss_score": 0.02522, "epss_percentile": 0.85006}, "CVE-2022-36451": {"epss_score": 0.0031, "epss_percentile": 0.53767}, "CVE-2022-36452": {"epss_score": 0.03204, "epss_percentile": 0.86628}, "CVE-2022-36453": {"epss_score": 0.0041, "epss_percentile": 0.60823}, "CVE-2022-36454": {"epss_score": 0.00218, "epss_percentile": 0.44358}, "CVE-2022-36455": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-36456": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-36458": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-36459": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-36460": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-36461": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-36462": {"epss_score": 0.00055, "epss_percentile": 0.1761}, "CVE-2022-36463": {"epss_score": 0.00071, "epss_percentile": 0.22004}, "CVE-2022-36464": {"epss_score": 0.00071, "epss_percentile": 0.22004}, "CVE-2022-36465": {"epss_score": 0.00071, "epss_percentile": 0.22004}, "CVE-2022-36466": {"epss_score": 0.00055, "epss_percentile": 0.1761}, "CVE-2022-36467": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36468": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36469": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36470": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36471": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36472": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36473": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36474": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36475": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36477": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36478": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36479": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-36480": {"epss_score": 0.00071, "epss_percentile": 0.22004}, "CVE-2022-36481": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-36482": {"epss_score": 0.0018, "epss_percentile": 0.3992}, "CVE-2022-36483": {"epss_score": 0.00071, "epss_percentile": 0.22004}, "CVE-2022-36484": {"epss_score": 0.00071, "epss_percentile": 0.22004}, "CVE-2022-36485": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-36486": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-36487": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-36488": {"epss_score": 0.00071, "epss_percentile": 0.22004}, "CVE-2022-36489": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36490": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36491": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36492": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36493": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36494": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36495": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36496": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36497": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36498": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36499": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36500": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36501": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36502": {"epss_score": 0.00133, "epss_percentile": 0.33671}, "CVE-2022-36503": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36504": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36505": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36506": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36507": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36508": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-36509": {"epss_score": 0.01727, "epss_percentile": 0.81967}, "CVE-2022-36510": {"epss_score": 0.01727, "epss_percentile": 0.81967}, "CVE-2022-36511": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-36513": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-36514": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-36515": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-36516": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-36517": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-36518": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-36519": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-36520": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-36521": {"epss_score": 0.00406, "epss_percentile": 0.60545}, "CVE-2022-36522": {"epss_score": 0.00417, "epss_percentile": 0.61239}, "CVE-2022-36523": {"epss_score": 0.05139, "epss_percentile": 0.89537}, "CVE-2022-36524": {"epss_score": 0.00395, "epss_percentile": 0.59813}, "CVE-2022-36525": {"epss_score": 0.00725, "epss_percentile": 0.72056}, "CVE-2022-36526": {"epss_score": 0.00395, "epss_percentile": 0.5984}, "CVE-2022-36527": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-36529": {"epss_score": 0.00243, "epss_percentile": 0.47514}, "CVE-2022-36530": {"epss_score": 0.00296, "epss_percentile": 0.52554}, "CVE-2022-36532": {"epss_score": 0.24794, "epss_percentile": 0.95954}, "CVE-2022-36533": {"epss_score": 0.00367, "epss_percentile": 0.58139}, "CVE-2022-36534": {"epss_score": 0.80181, "epss_percentile": 0.99075}, "CVE-2022-36536": {"epss_score": 0.48009, "epss_percentile": 0.97614}, "CVE-2022-36537": {"epss_score": 0.93977, "epss_percentile": 0.99878}, "CVE-2022-36539": {"epss_score": 0.06203, "epss_percentile": 0.90563}, "CVE-2022-36542": {"epss_score": 0.00311, "epss_percentile": 0.53839}, "CVE-2022-36543": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36544": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36545": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36546": {"epss_score": 0.00134, "epss_percentile": 0.33794}, "CVE-2022-36547": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-36548": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-36551": {"epss_score": 0.03768, "epss_percentile": 0.87698}, "CVE-2022-36552": {"epss_score": 0.00359, "epss_percentile": 0.57552}, "CVE-2022-36553": {"epss_score": 0.916, "epss_percentile": 0.99657}, "CVE-2022-36554": {"epss_score": 0.02727, "epss_percentile": 0.85531}, "CVE-2022-36555": {"epss_score": 0.00331, "epss_percentile": 0.55539}, "CVE-2022-36556": {"epss_score": 0.0167, "epss_percentile": 0.81669}, "CVE-2022-36557": {"epss_score": 0.01678, "epss_percentile": 0.81719}, "CVE-2022-36558": {"epss_score": 0.00414, "epss_percentile": 0.61098}, "CVE-2022-36559": {"epss_score": 0.0167, "epss_percentile": 0.81669}, "CVE-2022-36560": {"epss_score": 0.00414, "epss_percentile": 0.61098}, "CVE-2022-36561": {"epss_score": 0.00067, "epss_percentile": 0.21088}, "CVE-2022-36562": {"epss_score": 0.00736, "epss_percentile": 0.72315}, "CVE-2022-36563": {"epss_score": 0.00736, "epss_percentile": 0.72315}, "CVE-2022-36564": {"epss_score": 0.00842, "epss_percentile": 0.74243}, "CVE-2022-36565": {"epss_score": 0.00842, "epss_percentile": 0.74243}, "CVE-2022-36566": {"epss_score": 0.05138, "epss_percentile": 0.89537}, "CVE-2022-36568": {"epss_score": 0.00424, "epss_percentile": 0.61668}, "CVE-2022-36569": {"epss_score": 0.00424, "epss_percentile": 0.61668}, "CVE-2022-36570": {"epss_score": 0.00452, "epss_percentile": 0.6318}, "CVE-2022-36571": {"epss_score": 0.00452, "epss_percentile": 0.6318}, "CVE-2022-36572": {"epss_score": 0.03121, "epss_percentile": 0.86449}, "CVE-2022-36573": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-36577": {"epss_score": 0.00112, "epss_percentile": 0.30493}, "CVE-2022-36578": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36579": {"epss_score": 0.00112, "epss_percentile": 0.3048}, "CVE-2022-36580": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-36581": {"epss_score": 0.00309, "epss_percentile": 0.53644}, "CVE-2022-36582": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-36583": {"epss_score": 0.00171, "epss_percentile": 0.3883}, "CVE-2022-36584": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-36585": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-36586": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-36587": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-36588": {"epss_score": 0.00829, "epss_percentile": 0.74012}, "CVE-2022-36593": {"epss_score": 0.00919, "epss_percentile": 0.75453}, "CVE-2022-36594": {"epss_score": 0.00294, "epss_percentile": 0.52431}, "CVE-2022-36599": {"epss_score": 0.00482, "epss_percentile": 0.64543}, "CVE-2022-36600": {"epss_score": 0.00245, "epss_percentile": 0.47634}, "CVE-2022-36601": {"epss_score": 0.02401, "epss_percentile": 0.84639}, "CVE-2022-36602": {"epss_score": 0.02424, "epss_percentile": 0.84711}, "CVE-2022-36603": {"epss_score": 0.02424, "epss_percentile": 0.84711}, "CVE-2022-36604": {"epss_score": 0.00415, "epss_percentile": 0.61142}, "CVE-2022-36605": {"epss_score": 0.00294, "epss_percentile": 0.52431}, "CVE-2022-36606": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36609": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36610": {"epss_score": 0.00056, "epss_percentile": 0.17706}, "CVE-2022-36611": {"epss_score": 0.00056, "epss_percentile": 0.17706}, "CVE-2022-36612": {"epss_score": 0.00056, "epss_percentile": 0.17706}, "CVE-2022-36613": {"epss_score": 0.00056, "epss_percentile": 0.17706}, "CVE-2022-36614": {"epss_score": 0.00056, "epss_percentile": 0.17706}, "CVE-2022-36615": {"epss_score": 0.00056, "epss_percentile": 0.17706}, "CVE-2022-36616": {"epss_score": 0.00056, "epss_percentile": 0.17706}, "CVE-2022-36617": {"epss_score": 0.00243, "epss_percentile": 0.47451}, "CVE-2022-36619": {"epss_score": 0.00803, "epss_percentile": 0.73595}, "CVE-2022-36620": {"epss_score": 0.03832, "epss_percentile": 0.87811}, "CVE-2022-36621": {"epss_score": 0.00456, "epss_percentile": 0.63319}, "CVE-2022-36622": {"epss_score": 0.0064, "epss_percentile": 0.69974}, "CVE-2022-36633": {"epss_score": 0.31616, "epss_percentile": 0.96638}, "CVE-2022-36634": {"epss_score": 0.00502, "epss_percentile": 0.65372}, "CVE-2022-36635": {"epss_score": 0.02052, "epss_percentile": 0.83411}, "CVE-2022-36636": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36637": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-36638": {"epss_score": 0.00505, "epss_percentile": 0.65586}, "CVE-2022-36639": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-36640": {"epss_score": 0.08161, "epss_percentile": 0.9191}, "CVE-2022-36642": {"epss_score": 0.71462, "epss_percentile": 0.9867}, "CVE-2022-36647": {"epss_score": 0.00049, "epss_percentile": 0.15637}, "CVE-2022-36648": {"epss_score": 0.0099, "epss_percentile": 0.76379}, "CVE-2022-36657": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-36659": {"epss_score": 0.0031, "epss_percentile": 0.53749}, "CVE-2022-36660": {"epss_score": 0.00496, "epss_percentile": 0.65157}, "CVE-2022-36661": {"epss_score": 0.0031, "epss_percentile": 0.53749}, "CVE-2022-36663": {"epss_score": 0.16385, "epss_percentile": 0.94642}, "CVE-2022-36664": {"epss_score": 0.02877, "epss_percentile": 0.85884}, "CVE-2022-36667": {"epss_score": 0.0372, "epss_percentile": 0.87618}, "CVE-2022-36668": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-36669": {"epss_score": 0.00745, "epss_percentile": 0.7252}, "CVE-2022-36670": {"epss_score": 0.00048, "epss_percentile": 0.15269}, "CVE-2022-36671": {"epss_score": 0.00141, "epss_percentile": 0.34807}, "CVE-2022-36672": {"epss_score": 0.0028, "epss_percentile": 0.51093}, "CVE-2022-36674": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-36675": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-36676": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-36677": {"epss_score": 0.00255, "epss_percentile": 0.4863}, "CVE-2022-36678": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36679": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36680": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36681": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36682": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36683": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36686": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36687": {"epss_score": 0.00875, "epss_percentile": 0.7478}, "CVE-2022-36688": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36689": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36690": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36692": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36693": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36695": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36696": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36697": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36698": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36699": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36700": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36701": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36703": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36704": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36705": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36706": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36708": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36709": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36711": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36712": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36713": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36714": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36715": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36716": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36719": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36720": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36721": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-36722": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36725": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36727": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-36728": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36729": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36730": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36731": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36732": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36733": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36734": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36735": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36736": {"epss_score": 0.00363, "epss_percentile": 0.57821}, "CVE-2022-36745": {"epss_score": 0.00014, "epss_percentile": 0.01983}, "CVE-2022-36746": {"epss_score": 0.00014, "epss_percentile": 0.01983}, "CVE-2022-36747": {"epss_score": 0.00304, "epss_percentile": 0.53245}, "CVE-2022-36748": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2022-36749": {"epss_score": 0.0325, "epss_percentile": 0.8675}, "CVE-2022-36750": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36752": {"epss_score": 0.02021, "epss_percentile": 0.83298}, "CVE-2022-36754": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-36755": {"epss_score": 0.00997, "epss_percentile": 0.76459}, "CVE-2022-36756": {"epss_score": 0.0764, "epss_percentile": 0.91593}, "CVE-2022-36759": {"epss_score": 0.00228, "epss_percentile": 0.45531}, "CVE-2022-36760": {"epss_score": 0.00271, "epss_percentile": 0.50334}, "CVE-2022-36763": {"epss_score": 0.00055, "epss_percentile": 0.17651}, "CVE-2022-36764": {"epss_score": 0.00036, "epss_percentile": 0.10537}, "CVE-2022-36765": {"epss_score": 0.00036, "epss_percentile": 0.10537}, "CVE-2022-36768": {"epss_score": 0.00048, "epss_percentile": 0.1522}, "CVE-2022-36769": {"epss_score": 0.00127, "epss_percentile": 0.32875}, "CVE-2022-36771": {"epss_score": 0.00124, "epss_percentile": 0.3244}, "CVE-2022-36772": {"epss_score": 0.00162, "epss_percentile": 0.3766}, "CVE-2022-36773": {"epss_score": 0.00972, "epss_percentile": 0.76133}, "CVE-2022-36774": {"epss_score": 0.00089, "epss_percentile": 0.25818}, "CVE-2022-36775": {"epss_score": 0.0013, "epss_percentile": 0.33342}, "CVE-2022-36776": {"epss_score": 0.00377, "epss_percentile": 0.58746}, "CVE-2022-36777": {"epss_score": 0.00079, "epss_percentile": 0.23943}, "CVE-2022-36778": {"epss_score": 0.00204, "epss_percentile": 0.42646}, "CVE-2022-36779": {"epss_score": 0.23075, "epss_percentile": 0.9573}, "CVE-2022-36780": {"epss_score": 0.00178, "epss_percentile": 0.3963}, "CVE-2022-36781": {"epss_score": 0.00359, "epss_percentile": 0.57566}, "CVE-2022-36782": {"epss_score": 0.00218, "epss_percentile": 0.44402}, "CVE-2022-36783": {"epss_score": 0.00168, "epss_percentile": 0.38454}, "CVE-2022-36784": {"epss_score": 0.01851, "epss_percentile": 0.82542}, "CVE-2022-36785": {"epss_score": 0.00444, "epss_percentile": 0.62816}, "CVE-2022-36786": {"epss_score": 0.0044, "epss_percentile": 0.62629}, "CVE-2022-36787": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-36788": {"epss_score": 0.00103, "epss_percentile": 0.29007}, "CVE-2022-36789": {"epss_score": 0.00121, "epss_percentile": 0.31947}, "CVE-2022-36791": {"epss_score": 0.00197, "epss_percentile": 0.41898}, "CVE-2022-36793": {"epss_score": 0.00475, "epss_percentile": 0.64191}, "CVE-2022-36794": {"epss_score": 0.00054, "epss_percentile": 0.17082}, "CVE-2022-36795": {"epss_score": 0.00488, "epss_percentile": 0.64829}, "CVE-2022-36796": {"epss_score": 0.0013, "epss_percentile": 0.33281}, "CVE-2022-36797": {"epss_score": 0.00053, "epss_percentile": 0.16861}, "CVE-2022-36798": {"epss_score": 0.00113, "epss_percentile": 0.30721}, "CVE-2022-36799": {"epss_score": 0.10547, "epss_percentile": 0.93024}, "CVE-2022-36800": {"epss_score": 0.00195, "epss_percentile": 0.41691}, "CVE-2022-36801": {"epss_score": 0.02794, "epss_percentile": 0.85674}, "CVE-2022-36802": {"epss_score": 0.00179, "epss_percentile": 0.39822}, "CVE-2022-36803": {"epss_score": 0.00336, "epss_percentile": 0.55931}, "CVE-2022-36804": {"epss_score": 0.94429, "epss_percentile": 0.99982}, "CVE-2022-36829": {"epss_score": 0.00051, "epss_percentile": 0.16111}, "CVE-2022-36830": {"epss_score": 0.00051, "epss_percentile": 0.16111}, "CVE-2022-36831": {"epss_score": 0.00057, "epss_percentile": 0.18013}, "CVE-2022-36832": {"epss_score": 0.00062, "epss_percentile": 0.19622}, "CVE-2022-36833": {"epss_score": 0.00045, "epss_percentile": 0.13784}, "CVE-2022-36834": {"epss_score": 0.0006, "epss_percentile": 0.19101}, "CVE-2022-36835": {"epss_score": 0.00069, "epss_percentile": 0.21522}, "CVE-2022-36836": {"epss_score": 0.00057, "epss_percentile": 0.18157}, "CVE-2022-36837": {"epss_score": 0.00057, "epss_percentile": 0.18157}, "CVE-2022-36838": {"epss_score": 0.00057, "epss_percentile": 0.18049}, "CVE-2022-36839": {"epss_score": 0.00183, "epss_percentile": 0.40341}, "CVE-2022-36840": {"epss_score": 0.0006, "epss_percentile": 0.19163}, "CVE-2022-36841": {"epss_score": 0.00017, "epss_percentile": 0.035}, "CVE-2022-36842": {"epss_score": 0.00017, "epss_percentile": 0.035}, "CVE-2022-36843": {"epss_score": 0.00017, "epss_percentile": 0.035}, "CVE-2022-36844": {"epss_score": 0.00017, "epss_percentile": 0.035}, "CVE-2022-36845": {"epss_score": 0.00017, "epss_percentile": 0.035}, "CVE-2022-36846": {"epss_score": 0.00017, "epss_percentile": 0.035}, "CVE-2022-36847": {"epss_score": 0.00019, "epss_percentile": 0.04418}, "CVE-2022-36848": {"epss_score": 0.00014, "epss_percentile": 0.02082}, "CVE-2022-36849": {"epss_score": 0.00019, "epss_percentile": 0.04418}, "CVE-2022-36850": {"epss_score": 0.00023, "epss_percentile": 0.05503}, "CVE-2022-36851": {"epss_score": 0.00093, "epss_percentile": 0.26677}, "CVE-2022-36852": {"epss_score": 0.00015, "epss_percentile": 0.02153}, "CVE-2022-36853": {"epss_score": 0.00065, "epss_percentile": 0.20609}, "CVE-2022-36854": {"epss_score": 0.0002, "epss_percentile": 0.04472}, "CVE-2022-36855": {"epss_score": 0.0002, "epss_percentile": 0.04668}, "CVE-2022-36856": {"epss_score": 0.00041, "epss_percentile": 0.12441}, "CVE-2022-36857": {"epss_score": 0.00034, "epss_percentile": 0.09569}, "CVE-2022-36858": {"epss_score": 0.00017, "epss_percentile": 0.035}, "CVE-2022-36859": {"epss_score": 0.00244, "epss_percentile": 0.47624}, "CVE-2022-36860": {"epss_score": 0.00017, "epss_percentile": 0.035}, "CVE-2022-36861": {"epss_score": 0.00016, "epss_percentile": 0.02723}, "CVE-2022-36862": {"epss_score": 0.00017, "epss_percentile": 0.035}, "CVE-2022-36863": {"epss_score": 0.00017, "epss_percentile": 0.035}, "CVE-2022-36864": {"epss_score": 0.0005, "epss_percentile": 0.15839}, "CVE-2022-36865": {"epss_score": 0.00062, "epss_percentile": 0.19622}, "CVE-2022-36866": {"epss_score": 0.00062, "epss_percentile": 0.19622}, "CVE-2022-36867": {"epss_score": 0.00054, "epss_percentile": 0.17352}, "CVE-2022-36868": {"epss_score": 0.00019, "epss_percentile": 0.04094}, "CVE-2022-36869": {"epss_score": 0.00051, "epss_percentile": 0.16278}, "CVE-2022-36870": {"epss_score": 0.00054, "epss_percentile": 0.17352}, "CVE-2022-36871": {"epss_score": 0.00054, "epss_percentile": 0.17352}, "CVE-2022-36872": {"epss_score": 0.00054, "epss_percentile": 0.17352}, "CVE-2022-36873": {"epss_score": 0.0006, "epss_percentile": 0.19133}, "CVE-2022-36874": {"epss_score": 0.00043, "epss_percentile": 0.13125}, "CVE-2022-36875": {"epss_score": 0.00111, "epss_percentile": 0.3024}, "CVE-2022-36876": {"epss_score": 0.0008, "epss_percentile": 0.24073}, "CVE-2022-36877": {"epss_score": 0.00061, "epss_percentile": 0.195}, "CVE-2022-36878": {"epss_score": 0.00061, "epss_percentile": 0.195}, "CVE-2022-36879": {"epss_score": 0.00025, "epss_percentile": 0.06227}, "CVE-2022-36880": {"epss_score": 0.00616, "epss_percentile": 0.69339}, "CVE-2022-36881": {"epss_score": 0.00731, "epss_percentile": 0.7218}, "CVE-2022-36882": {"epss_score": 0.00385, "epss_percentile": 0.59225}, "CVE-2022-36883": {"epss_score": 0.79615, "epss_percentile": 0.99048}, "CVE-2022-36884": {"epss_score": 0.0052, "epss_percentile": 0.66192}, "CVE-2022-36885": {"epss_score": 0.00273, "epss_percentile": 0.50466}, "CVE-2022-36886": {"epss_score": 0.00071, "epss_percentile": 0.22077}, "CVE-2022-36887": {"epss_score": 0.00071, "epss_percentile": 0.22077}, "CVE-2022-36888": {"epss_score": 0.00403, "epss_percentile": 0.60323}, "CVE-2022-36889": {"epss_score": 0.00477, "epss_percentile": 0.64334}, "CVE-2022-36890": {"epss_score": 0.00661, "epss_percentile": 0.70585}, "CVE-2022-36891": {"epss_score": 0.00292, "epss_percentile": 0.5222}, "CVE-2022-36892": {"epss_score": 0.00068, "epss_percentile": 0.21387}, "CVE-2022-36893": {"epss_score": 0.00093, "epss_percentile": 0.2665}, "CVE-2022-36894": {"epss_score": 0.00771, "epss_percentile": 0.73015}, "CVE-2022-36895": {"epss_score": 0.00292, "epss_percentile": 0.5222}, "CVE-2022-36896": {"epss_score": 0.00403, "epss_percentile": 0.60323}, "CVE-2022-36897": {"epss_score": 0.00292, "epss_percentile": 0.5222}, "CVE-2022-36898": {"epss_score": 0.00337, "epss_percentile": 0.56045}, "CVE-2022-36899": {"epss_score": 0.00531, "epss_percentile": 0.66658}, "CVE-2022-36900": {"epss_score": 0.00391, "epss_percentile": 0.5962}, "CVE-2022-36901": {"epss_score": 0.00465, "epss_percentile": 0.63784}, "CVE-2022-36902": {"epss_score": 0.20595, "epss_percentile": 0.95383}, "CVE-2022-36903": {"epss_score": 0.00396, "epss_percentile": 0.59895}, "CVE-2022-36904": {"epss_score": 0.00093, "epss_percentile": 0.2665}, "CVE-2022-36905": {"epss_score": 0.00596, "epss_percentile": 0.68706}, "CVE-2022-36906": {"epss_score": 0.00064, "epss_percentile": 0.20167}, "CVE-2022-36907": {"epss_score": 0.00396, "epss_percentile": 0.59895}, "CVE-2022-36908": {"epss_score": 0.00064, "epss_percentile": 0.20167}, "CVE-2022-36909": {"epss_score": 0.00396, "epss_percentile": 0.59895}, "CVE-2022-36910": {"epss_score": 0.00292, "epss_percentile": 0.5222}, "CVE-2022-36911": {"epss_score": 0.00071, "epss_percentile": 0.22077}, "CVE-2022-36912": {"epss_score": 0.00292, "epss_percentile": 0.5222}, "CVE-2022-36913": {"epss_score": 0.00068, "epss_percentile": 0.21387}, "CVE-2022-36914": {"epss_score": 0.00093, "epss_percentile": 0.2665}, "CVE-2022-36915": {"epss_score": 0.00068, "epss_percentile": 0.21387}, "CVE-2022-36916": {"epss_score": 0.0008, "epss_percentile": 0.2418}, "CVE-2022-36917": {"epss_score": 0.00292, "epss_percentile": 0.5222}, "CVE-2022-36918": {"epss_score": 0.00068, "epss_percentile": 0.21387}, "CVE-2022-36919": {"epss_score": 0.00396, "epss_percentile": 0.59895}, "CVE-2022-36920": {"epss_score": 0.00072, "epss_percentile": 0.22403}, "CVE-2022-36921": {"epss_score": 0.00547, "epss_percentile": 0.67227}, "CVE-2022-36922": {"epss_score": 0.16253, "epss_percentile": 0.94603}, "CVE-2022-36923": {"epss_score": 0.23665, "epss_percentile": 0.958}, "CVE-2022-36924": {"epss_score": 0.00055, "epss_percentile": 0.17376}, "CVE-2022-36925": {"epss_score": 0.00044, "epss_percentile": 0.13521}, "CVE-2022-36926": {"epss_score": 0.00302, "epss_percentile": 0.53112}, "CVE-2022-36927": {"epss_score": 0.00136, "epss_percentile": 0.34192}, "CVE-2022-36928": {"epss_score": 0.00203, "epss_percentile": 0.42516}, "CVE-2022-36929": {"epss_score": 0.00144, "epss_percentile": 0.35323}, "CVE-2022-36930": {"epss_score": 0.00132, "epss_percentile": 0.33566}, "CVE-2022-36934": {"epss_score": 0.11433, "epss_percentile": 0.93351}, "CVE-2022-36937": {"epss_score": 0.00287, "epss_percentile": 0.51845}, "CVE-2022-36938": {"epss_score": 0.02007, "epss_percentile": 0.8324}, "CVE-2022-36943": {"epss_score": 0.00529, "epss_percentile": 0.66602}, "CVE-2022-36944": {"epss_score": 0.70253, "epss_percentile": 0.98624}, "CVE-2022-36945": {"epss_score": 0.02232, "epss_percentile": 0.84092}, "CVE-2022-36946": {"epss_score": 0.05077, "epss_percentile": 0.89469}, "CVE-2022-36947": {"epss_score": 0.00805, "epss_percentile": 0.73644}, "CVE-2022-36948": {"epss_score": 0.00232, "epss_percentile": 0.4597}, "CVE-2022-36949": {"epss_score": 0.0005, "epss_percentile": 0.15928}, "CVE-2022-36950": {"epss_score": 0.01907, "epss_percentile": 0.82812}, "CVE-2022-36951": {"epss_score": 0.00876, "epss_percentile": 0.74786}, "CVE-2022-36952": {"epss_score": 0.00177, "epss_percentile": 0.39569}, "CVE-2022-36953": {"epss_score": 0.00229, "epss_percentile": 0.45638}, "CVE-2022-36954": {"epss_score": 0.00323, "epss_percentile": 0.54889}, "CVE-2022-36955": {"epss_score": 0.00056, "epss_percentile": 0.17789}, "CVE-2022-36956": {"epss_score": 0.00357, "epss_percentile": 0.57451}, "CVE-2022-36957": {"epss_score": 0.01749, "epss_percentile": 0.82087}, "CVE-2022-36958": {"epss_score": 0.14799, "epss_percentile": 0.94287}, "CVE-2022-36960": {"epss_score": 0.00292, "epss_percentile": 0.52234}, "CVE-2022-36961": {"epss_score": 0.11775, "epss_percentile": 0.9347}, "CVE-2022-36962": {"epss_score": 0.01688, "epss_percentile": 0.81764}, "CVE-2022-36963": {"epss_score": 0.00578, "epss_percentile": 0.68191}, "CVE-2022-36964": {"epss_score": 0.02519, "epss_percentile": 0.84996}, "CVE-2022-36965": {"epss_score": 0.01021, "epss_percentile": 0.76747}, "CVE-2022-36966": {"epss_score": 0.0032, "epss_percentile": 0.54574}, "CVE-2022-36967": {"epss_score": 9e-05, "epss_percentile": 0.0061}, "CVE-2022-36968": {"epss_score": 0.00039, "epss_percentile": 0.11586}, "CVE-2022-36969": {"epss_score": 0.02739, "epss_percentile": 0.85555}, "CVE-2022-36970": {"epss_score": 0.01477, "epss_percentile": 0.80548}, "CVE-2022-36971": {"epss_score": 0.22929, "epss_percentile": 0.95707}, "CVE-2022-36972": {"epss_score": 0.01132, "epss_percentile": 0.77872}, "CVE-2022-36973": {"epss_score": 0.01058, "epss_percentile": 0.77143}, "CVE-2022-36974": {"epss_score": 0.09705, "epss_percentile": 0.9267}, "CVE-2022-36975": {"epss_score": 0.01132, "epss_percentile": 0.77872}, "CVE-2022-36976": {"epss_score": 0.01167, "epss_percentile": 0.78185}, "CVE-2022-36977": {"epss_score": 0.04381, "epss_percentile": 0.88625}, "CVE-2022-36978": {"epss_score": 0.14271, "epss_percentile": 0.94176}, "CVE-2022-36979": {"epss_score": 0.01012, "epss_percentile": 0.76621}, "CVE-2022-36980": {"epss_score": 0.0087, "epss_percentile": 0.74698}, "CVE-2022-36981": {"epss_score": 0.27921, "epss_percentile": 0.96296}, "CVE-2022-36982": {"epss_score": 0.00656, "epss_percentile": 0.7044}, "CVE-2022-36983": {"epss_score": 0.00559, "epss_percentile": 0.67604}, "CVE-2022-36984": {"epss_score": 0.00463, "epss_percentile": 0.63669}, "CVE-2022-36985": {"epss_score": 0.00057, "epss_percentile": 0.17992}, "CVE-2022-36986": {"epss_score": 0.00753, "epss_percentile": 0.7267}, "CVE-2022-36987": {"epss_score": 0.0045, "epss_percentile": 0.63076}, "CVE-2022-36988": {"epss_score": 0.00569, "epss_percentile": 0.67914}, "CVE-2022-36989": {"epss_score": 0.01048, "epss_percentile": 0.77055}, "CVE-2022-36990": {"epss_score": 0.00382, "epss_percentile": 0.59062}, "CVE-2022-36991": {"epss_score": 0.00303, "epss_percentile": 0.53222}, "CVE-2022-36992": {"epss_score": 0.01048, "epss_percentile": 0.77055}, "CVE-2022-36993": {"epss_score": 0.01048, "epss_percentile": 0.77055}, "CVE-2022-36994": {"epss_score": 0.00393, "epss_percentile": 0.59726}, "CVE-2022-36995": {"epss_score": 0.00252, "epss_percentile": 0.48379}, "CVE-2022-36996": {"epss_score": 0.00223, "epss_percentile": 0.44851}, "CVE-2022-36997": {"epss_score": 0.00369, "epss_percentile": 0.58277}, "CVE-2022-36998": {"epss_score": 0.00298, "epss_percentile": 0.52785}, "CVE-2022-36999": {"epss_score": 0.00327, "epss_percentile": 0.55111}, "CVE-2022-37000": {"epss_score": 0.00327, "epss_percentile": 0.55111}, "CVE-2022-37001": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2022-37002": {"epss_score": 0.00131, "epss_percentile": 0.33405}, "CVE-2022-37003": {"epss_score": 0.00165, "epss_percentile": 0.38103}, "CVE-2022-37004": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-37005": {"epss_score": 0.00284, "epss_percentile": 0.51472}, "CVE-2022-37006": {"epss_score": 0.00163, "epss_percentile": 0.37817}, "CVE-2022-37007": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-37008": {"epss_score": 0.0006, "epss_percentile": 0.19077}, "CVE-2022-37009": {"epss_score": 4e-05, "epss_percentile": 0.0015}, "CVE-2022-37010": {"epss_score": 2e-05, "epss_percentile": 0.00027}, "CVE-2022-37011": {"epss_score": 0.00914, "epss_percentile": 0.75388}, "CVE-2022-37012": {"epss_score": 0.01095, "epss_percentile": 0.77509}, "CVE-2022-37013": {"epss_score": 0.00906, "epss_percentile": 0.75259}, "CVE-2022-37015": {"epss_score": 0.00508, "epss_percentile": 0.65711}, "CVE-2022-37016": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2022-37017": {"epss_score": 0.06012, "epss_percentile": 0.90409}, "CVE-2022-37018": {"epss_score": 0.00036, "epss_percentile": 0.1025}, "CVE-2022-37019": {"epss_score": 0.0007, "epss_percentile": 0.2171}, "CVE-2022-37020": {"epss_score": 0.00086, "epss_percentile": 0.25376}, "CVE-2022-37021": {"epss_score": 0.00764, "epss_percentile": 0.72903}, "CVE-2022-37022": {"epss_score": 0.00319, "epss_percentile": 0.54553}, "CVE-2022-37023": {"epss_score": 0.00404, "epss_percentile": 0.60451}, "CVE-2022-37024": {"epss_score": 0.51233, "epss_percentile": 0.9777}, "CVE-2022-37025": {"epss_score": 0.00144, "epss_percentile": 0.35283}, "CVE-2022-37026": {"epss_score": 0.00129, "epss_percentile": 0.33148}, "CVE-2022-37027": {"epss_score": 0.06212, "epss_percentile": 0.90571}, "CVE-2022-37028": {"epss_score": 0.00267, "epss_percentile": 0.50005}, "CVE-2022-37030": {"epss_score": 0.00043, "epss_percentile": 0.13208}, "CVE-2022-37032": {"epss_score": 0.00705, "epss_percentile": 0.71575}, "CVE-2022-37033": {"epss_score": 0.00139, "epss_percentile": 0.34594}, "CVE-2022-37034": {"epss_score": 0.00148, "epss_percentile": 0.35807}, "CVE-2022-37035": {"epss_score": 0.03335, "epss_percentile": 0.86933}, "CVE-2022-37041": {"epss_score": 0.00266, "epss_percentile": 0.4991}, "CVE-2022-37042": {"epss_score": 0.94333, "epss_percentile": 0.9995}, "CVE-2022-37043": {"epss_score": 0.00292, "epss_percentile": 0.52251}, "CVE-2022-37044": {"epss_score": 0.00832, "epss_percentile": 0.74064}, "CVE-2022-37047": {"epss_score": 0.00096, "epss_percentile": 0.27332}, "CVE-2022-37048": {"epss_score": 0.00096, "epss_percentile": 0.27332}, "CVE-2022-37049": {"epss_score": 0.00096, "epss_percentile": 0.27332}, "CVE-2022-37050": {"epss_score": 0.00064, "epss_percentile": 0.20174}, "CVE-2022-37051": {"epss_score": 0.00044, "epss_percentile": 0.13575}, "CVE-2022-37052": {"epss_score": 0.00027, "epss_percentile": 0.06814}, "CVE-2022-37053": {"epss_score": 0.18412, "epss_percentile": 0.95013}, "CVE-2022-37055": {"epss_score": 0.70214, "epss_percentile": 0.98622}, "CVE-2022-37056": {"epss_score": 0.43712, "epss_percentile": 0.97399}, "CVE-2022-37057": {"epss_score": 0.31821, "epss_percentile": 0.96652}, "CVE-2022-37059": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-37060": {"epss_score": 0.39512, "epss_percentile": 0.97164}, "CVE-2022-37061": {"epss_score": 0.93519, "epss_percentile": 0.99814}, "CVE-2022-37062": {"epss_score": 0.00761, "epss_percentile": 0.72831}, "CVE-2022-37063": {"epss_score": 0.00346, "epss_percentile": 0.56675}, "CVE-2022-37066": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37067": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37068": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37069": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37070": {"epss_score": 0.15114, "epss_percentile": 0.94367}, "CVE-2022-37071": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37072": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37073": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37074": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-37075": {"epss_score": 0.00071, "epss_percentile": 0.22004}, "CVE-2022-37076": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-37077": {"epss_score": 0.00071, "epss_percentile": 0.22004}, "CVE-2022-37078": {"epss_score": 0.0018, "epss_percentile": 0.3992}, "CVE-2022-37079": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-37080": {"epss_score": 0.00071, "epss_percentile": 0.22004}, "CVE-2022-37081": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-37082": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-37083": {"epss_score": 0.01274, "epss_percentile": 0.79096}, "CVE-2022-37084": {"epss_score": 0.00071, "epss_percentile": 0.22004}, "CVE-2022-37085": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37086": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37087": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37088": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37089": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37090": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37091": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37092": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37093": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37094": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37095": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37096": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37097": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37098": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37099": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37100": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37108": {"epss_score": 0.0111, "epss_percentile": 0.77661}, "CVE-2022-37109": {"epss_score": 0.02509, "epss_percentile": 0.84945}, "CVE-2022-37111": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-37112": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-37113": {"epss_score": 0.0032, "epss_percentile": 0.54598}, "CVE-2022-37122": {"epss_score": 0.58497, "epss_percentile": 0.9812}, "CVE-2022-37123": {"epss_score": 0.11888, "epss_percentile": 0.93507}, "CVE-2022-37125": {"epss_score": 0.2188, "epss_percentile": 0.9557}, "CVE-2022-37128": {"epss_score": 0.01383, "epss_percentile": 0.79894}, "CVE-2022-37129": {"epss_score": 0.11888, "epss_percentile": 0.93507}, "CVE-2022-37130": {"epss_score": 0.3029, "epss_percentile": 0.96525}, "CVE-2022-37133": {"epss_score": 0.0064, "epss_percentile": 0.69972}, "CVE-2022-37134": {"epss_score": 0.01856, "epss_percentile": 0.82572}, "CVE-2022-37137": {"epss_score": 0.00548, "epss_percentile": 0.67283}, "CVE-2022-37138": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-37139": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-37140": {"epss_score": 0.01632, "epss_percentile": 0.81459}, "CVE-2022-37144": {"epss_score": 0.00475, "epss_percentile": 0.64192}, "CVE-2022-37145": {"epss_score": 0.00932, "epss_percentile": 0.75627}, "CVE-2022-37146": {"epss_score": 0.00353, "epss_percentile": 0.57166}, "CVE-2022-37149": {"epss_score": 0.13713, "epss_percentile": 0.9404}, "CVE-2022-37150": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-37151": {"epss_score": 0.00357, "epss_percentile": 0.57481}, "CVE-2022-37152": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-37153": {"epss_score": 0.03431, "epss_percentile": 0.87123}, "CVE-2022-37155": {"epss_score": 0.07766, "epss_percentile": 0.91668}, "CVE-2022-37158": {"epss_score": 0.00299, "epss_percentile": 0.52896}, "CVE-2022-37159": {"epss_score": 0.03379, "epss_percentile": 0.87027}, "CVE-2022-37160": {"epss_score": 0.00272, "epss_percentile": 0.50374}, "CVE-2022-37161": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-37162": {"epss_score": 0.00356, "epss_percentile": 0.57344}, "CVE-2022-37163": {"epss_score": 0.00161, "epss_percentile": 0.37531}, "CVE-2022-37164": {"epss_score": 0.00229, "epss_percentile": 0.45663}, "CVE-2022-37172": {"epss_score": 0.0006, "epss_percentile": 0.19069}, "CVE-2022-37173": {"epss_score": 0.0005, "epss_percentile": 0.15837}, "CVE-2022-37175": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37176": {"epss_score": 0.00329, "epss_percentile": 0.55388}, "CVE-2022-37177": {"epss_score": 0.00119, "epss_percentile": 0.31593}, "CVE-2022-37178": {"epss_score": 0.00441, "epss_percentile": 0.62658}, "CVE-2022-37181": {"epss_score": 0.00669, "epss_percentile": 0.70751}, "CVE-2022-37183": {"epss_score": 0.00448, "epss_percentile": 0.63006}, "CVE-2022-37184": {"epss_score": 0.00585, "epss_percentile": 0.68404}, "CVE-2022-37185": {"epss_score": 0.003, "epss_percentile": 0.52974}, "CVE-2022-37186": {"epss_score": 0.00149, "epss_percentile": 0.35945}, "CVE-2022-37189": {"epss_score": 0.00406, "epss_percentile": 0.60565}, "CVE-2022-37190": {"epss_score": 0.82094, "epss_percentile": 0.99173}, "CVE-2022-37191": {"epss_score": 0.46367, "epss_percentile": 0.97542}, "CVE-2022-37193": {"epss_score": 0.00251, "epss_percentile": 0.48302}, "CVE-2022-37197": {"epss_score": 0.00531, "epss_percentile": 0.66664}, "CVE-2022-37199": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-37201": {"epss_score": 0.01023, "epss_percentile": 0.76769}, "CVE-2022-37202": {"epss_score": 0.01023, "epss_percentile": 0.76769}, "CVE-2022-37203": {"epss_score": 0.01051, "epss_percentile": 0.77076}, "CVE-2022-37204": {"epss_score": 0.01051, "epss_percentile": 0.77076}, "CVE-2022-37205": {"epss_score": 0.01023, "epss_percentile": 0.76769}, "CVE-2022-37207": {"epss_score": 0.01023, "epss_percentile": 0.76769}, "CVE-2022-37208": {"epss_score": 0.01023, "epss_percentile": 0.76769}, "CVE-2022-37209": {"epss_score": 0.01023, "epss_percentile": 0.76769}, "CVE-2022-37223": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-37232": {"epss_score": 0.00853, "epss_percentile": 0.74435}, "CVE-2022-37234": {"epss_score": 0.00075, "epss_percentile": 0.22951}, "CVE-2022-37235": {"epss_score": 0.00853, "epss_percentile": 0.74435}, "CVE-2022-37237": {"epss_score": 0.00266, "epss_percentile": 0.49859}, "CVE-2022-37238": {"epss_score": 0.00638, "epss_percentile": 0.69926}, "CVE-2022-37239": {"epss_score": 0.00548, "epss_percentile": 0.67283}, "CVE-2022-37240": {"epss_score": 0.01139, "epss_percentile": 0.77937}, "CVE-2022-37241": {"epss_score": 0.00548, "epss_percentile": 0.67283}, "CVE-2022-37242": {"epss_score": 0.00852, "epss_percentile": 0.74421}, "CVE-2022-37243": {"epss_score": 0.00548, "epss_percentile": 0.67283}, "CVE-2022-37244": {"epss_score": 0.00548, "epss_percentile": 0.67283}, "CVE-2022-37245": {"epss_score": 0.00548, "epss_percentile": 0.67283}, "CVE-2022-37246": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-37247": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-37248": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-37250": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-37251": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-37253": {"epss_score": 0.00173, "epss_percentile": 0.39118}, "CVE-2022-37254": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-37255": {"epss_score": 0.02458, "epss_percentile": 0.84815}, "CVE-2022-37257": {"epss_score": 0.00485, "epss_percentile": 0.64724}, "CVE-2022-37258": {"epss_score": 0.00474, "epss_percentile": 0.64146}, "CVE-2022-37259": {"epss_score": 0.00348, "epss_percentile": 0.56839}, "CVE-2022-37260": {"epss_score": 0.00348, "epss_percentile": 0.56839}, "CVE-2022-37262": {"epss_score": 0.00348, "epss_percentile": 0.56839}, "CVE-2022-37264": {"epss_score": 0.00474, "epss_percentile": 0.64146}, "CVE-2022-37265": {"epss_score": 0.0039, "epss_percentile": 0.59515}, "CVE-2022-37266": {"epss_score": 0.00474, "epss_percentile": 0.64146}, "CVE-2022-37290": {"epss_score": 0.00035, "epss_percentile": 0.09815}, "CVE-2022-37292": {"epss_score": 0.00048, "epss_percentile": 0.15287}, "CVE-2022-37298": {"epss_score": 0.09428, "epss_percentile": 0.92542}, "CVE-2022-37299": {"epss_score": 0.17152, "epss_percentile": 0.94784}, "CVE-2022-37300": {"epss_score": 0.00571, "epss_percentile": 0.67997}, "CVE-2022-37301": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-37302": {"epss_score": 0.00129, "epss_percentile": 0.33099}, "CVE-2022-37305": {"epss_score": 0.02232, "epss_percentile": 0.84092}, "CVE-2022-37306": {"epss_score": 0.00166, "epss_percentile": 0.38159}, "CVE-2022-37307": {"epss_score": 0.00909, "epss_percentile": 0.75298}, "CVE-2022-37308": {"epss_score": 0.00832, "epss_percentile": 0.74068}, "CVE-2022-37309": {"epss_score": 0.00832, "epss_percentile": 0.74068}, "CVE-2022-37310": {"epss_score": 0.00832, "epss_percentile": 0.74068}, "CVE-2022-37311": {"epss_score": 0.00859, "epss_percentile": 0.74523}, "CVE-2022-37312": {"epss_score": 0.00859, "epss_percentile": 0.74523}, "CVE-2022-37313": {"epss_score": 0.00481, "epss_percentile": 0.64496}, "CVE-2022-37315": {"epss_score": 0.00266, "epss_percentile": 0.49859}, "CVE-2022-37316": {"epss_score": 0.00327, "epss_percentile": 0.55111}, "CVE-2022-37317": {"epss_score": 0.0025, "epss_percentile": 0.48244}, "CVE-2022-37318": {"epss_score": 0.00562, "epss_percentile": 0.67689}, "CVE-2022-37325": {"epss_score": 0.00301, "epss_percentile": 0.53016}, "CVE-2022-37326": {"epss_score": 0.0004, "epss_percentile": 0.12185}, "CVE-2022-37327": {"epss_score": 0.00048, "epss_percentile": 0.15133}, "CVE-2022-37328": {"epss_score": 0.00192, "epss_percentile": 0.41357}, "CVE-2022-37329": {"epss_score": 0.00138, "epss_percentile": 0.34505}, "CVE-2022-37330": {"epss_score": 0.0018, "epss_percentile": 0.39928}, "CVE-2022-37331": {"epss_score": 0.00107, "epss_percentile": 0.29585}, "CVE-2022-37332": {"epss_score": 0.08622, "epss_percentile": 0.92157}, "CVE-2022-37333": {"epss_score": 0.01548, "epss_percentile": 0.80976}, "CVE-2022-37334": {"epss_score": 0.00197, "epss_percentile": 0.41968}, "CVE-2022-37335": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2022-37336": {"epss_score": 0.00023, "epss_percentile": 0.05458}, "CVE-2022-37337": {"epss_score": 0.00238, "epss_percentile": 0.46743}, "CVE-2022-37338": {"epss_score": 0.00197, "epss_percentile": 0.41898}, "CVE-2022-37339": {"epss_score": 0.00197, "epss_percentile": 0.41898}, "CVE-2022-37340": {"epss_score": 0.00125, "epss_percentile": 0.32571}, "CVE-2022-37341": {"epss_score": 0.00036, "epss_percentile": 0.10244}, "CVE-2022-37342": {"epss_score": 0.00369, "epss_percentile": 0.58267}, "CVE-2022-37343": {"epss_score": 0.00035, "epss_percentile": 0.10124}, "CVE-2022-37344": {"epss_score": 0.00705, "epss_percentile": 0.71577}, "CVE-2022-37345": {"epss_score": 0.00161, "epss_percentile": 0.37527}, "CVE-2022-37346": {"epss_score": 0.0203, "epss_percentile": 0.83331}, "CVE-2022-37347": {"epss_score": 0.00191, "epss_percentile": 0.41258}, "CVE-2022-37348": {"epss_score": 0.00191, "epss_percentile": 0.41258}, "CVE-2022-37349": {"epss_score": 0.0135, "epss_percentile": 0.79676}, "CVE-2022-37350": {"epss_score": 0.0135, "epss_percentile": 0.79676}, "CVE-2022-37351": {"epss_score": 0.00675, "epss_percentile": 0.70885}, "CVE-2022-37352": {"epss_score": 0.00675, "epss_percentile": 0.70885}, "CVE-2022-37353": {"epss_score": 0.01148, "epss_percentile": 0.78014}, "CVE-2022-37354": {"epss_score": 0.01536, "epss_percentile": 0.80919}, "CVE-2022-37355": {"epss_score": 0.0279, "epss_percentile": 0.85665}, "CVE-2022-37356": {"epss_score": 0.02527, "epss_percentile": 0.85019}, "CVE-2022-37357": {"epss_score": 0.02527, "epss_percentile": 0.85019}, "CVE-2022-37358": {"epss_score": 0.01536, "epss_percentile": 0.80919}, "CVE-2022-37359": {"epss_score": 0.01536, "epss_percentile": 0.80919}, "CVE-2022-37360": {"epss_score": 0.00675, "epss_percentile": 0.70885}, "CVE-2022-37361": {"epss_score": 0.00881, "epss_percentile": 0.74864}, "CVE-2022-37362": {"epss_score": 0.01536, "epss_percentile": 0.80919}, "CVE-2022-37363": {"epss_score": 0.02527, "epss_percentile": 0.85019}, "CVE-2022-37364": {"epss_score": 0.02527, "epss_percentile": 0.85019}, "CVE-2022-37365": {"epss_score": 0.02225, "epss_percentile": 0.84069}, "CVE-2022-37366": {"epss_score": 0.02225, "epss_percentile": 0.84069}, "CVE-2022-37367": {"epss_score": 0.02225, "epss_percentile": 0.84069}, "CVE-2022-37368": {"epss_score": 0.00773, "epss_percentile": 0.73058}, "CVE-2022-37369": {"epss_score": 0.02527, "epss_percentile": 0.85019}, "CVE-2022-37370": {"epss_score": 0.00881, "epss_percentile": 0.74864}, "CVE-2022-37371": {"epss_score": 0.02527, "epss_percentile": 0.85019}, "CVE-2022-37372": {"epss_score": 0.01536, "epss_percentile": 0.80919}, "CVE-2022-37373": {"epss_score": 0.00881, "epss_percentile": 0.74864}, "CVE-2022-37374": {"epss_score": 0.02527, "epss_percentile": 0.85019}, "CVE-2022-37375": {"epss_score": 0.01062, "epss_percentile": 0.77183}, "CVE-2022-37376": {"epss_score": 0.00739, "epss_percentile": 0.72357}, "CVE-2022-37377": {"epss_score": 0.03321, "epss_percentile": 0.86913}, "CVE-2022-37378": {"epss_score": 0.03321, "epss_percentile": 0.86913}, "CVE-2022-37379": {"epss_score": 0.00765, "epss_percentile": 0.72925}, "CVE-2022-37380": {"epss_score": 0.01204, "epss_percentile": 0.78506}, "CVE-2022-37381": {"epss_score": 0.03321, "epss_percentile": 0.86913}, "CVE-2022-37382": {"epss_score": 0.01204, "epss_percentile": 0.78506}, "CVE-2022-37383": {"epss_score": 0.00765, "epss_percentile": 0.72925}, "CVE-2022-37384": {"epss_score": 0.0239, "epss_percentile": 0.84597}, "CVE-2022-37385": {"epss_score": 0.03321, "epss_percentile": 0.86913}, "CVE-2022-37386": {"epss_score": 0.00765, "epss_percentile": 0.72925}, "CVE-2022-37387": {"epss_score": 0.0239, "epss_percentile": 0.84597}, "CVE-2022-37388": {"epss_score": 0.03764, "epss_percentile": 0.87692}, "CVE-2022-37389": {"epss_score": 0.03321, "epss_percentile": 0.86913}, "CVE-2022-37390": {"epss_score": 0.03419, "epss_percentile": 0.87097}, "CVE-2022-37391": {"epss_score": 0.0239, "epss_percentile": 0.84597}, "CVE-2022-37392": {"epss_score": 0.00406, "epss_percentile": 0.60534}, "CVE-2022-37393": {"epss_score": 0.05122, "epss_percentile": 0.8952}, "CVE-2022-37394": {"epss_score": 0.00051, "epss_percentile": 0.16328}, "CVE-2022-37395": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2022-37396": {"epss_score": 1e-05, "epss_percentile": 4e-05}, "CVE-2022-37397": {"epss_score": 0.00494, "epss_percentile": 0.65092}, "CVE-2022-37398": {"epss_score": 0.00558, "epss_percentile": 0.6757}, "CVE-2022-37400": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2022-37401": {"epss_score": 0.00628, "epss_percentile": 0.69661}, "CVE-2022-37402": {"epss_score": 0.00112, "epss_percentile": 0.30441}, "CVE-2022-37403": {"epss_score": 0.00369, "epss_percentile": 0.58267}, "CVE-2022-37404": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2022-37405": {"epss_score": 0.00116, "epss_percentile": 0.31155}, "CVE-2022-37406": {"epss_score": 0.00396, "epss_percentile": 0.59927}, "CVE-2022-37407": {"epss_score": 0.00251, "epss_percentile": 0.48293}, "CVE-2022-37409": {"epss_score": 0.00085, "epss_percentile": 0.25099}, "CVE-2022-37410": {"epss_score": 0.0005, "epss_percentile": 0.15958}, "CVE-2022-37411": {"epss_score": 0.00104, "epss_percentile": 0.29139}, "CVE-2022-37412": {"epss_score": 0.00369, "epss_percentile": 0.58267}, "CVE-2022-37415": {"epss_score": 0.00103, "epss_percentile": 0.29034}, "CVE-2022-37416": {"epss_score": 0.00245, "epss_percentile": 0.47648}, "CVE-2022-37418": {"epss_score": 0.01502, "epss_percentile": 0.80725}, "CVE-2022-37421": {"epss_score": 0.00322, "epss_percentile": 0.5476}, "CVE-2022-37422": {"epss_score": 0.00542, "epss_percentile": 0.6708}, "CVE-2022-37423": {"epss_score": 0.00256, "epss_percentile": 0.4878}, "CVE-2022-37424": {"epss_score": 0.00263, "epss_percentile": 0.49508}, "CVE-2022-37425": {"epss_score": 0.02052, "epss_percentile": 0.83414}, "CVE-2022-37426": {"epss_score": 0.00367, "epss_percentile": 0.58141}, "CVE-2022-37428": {"epss_score": 0.00053, "epss_percentile": 0.17006}, "CVE-2022-37429": {"epss_score": 0.00322, "epss_percentile": 0.5476}, "CVE-2022-37430": {"epss_score": 0.00322, "epss_percentile": 0.5476}, "CVE-2022-37431": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-37434": {"epss_score": 0.9247, "epss_percentile": 0.99717}, "CVE-2022-37435": {"epss_score": 0.00186, "epss_percentile": 0.40692}, "CVE-2022-37436": {"epss_score": 0.00432, "epss_percentile": 0.62163}, "CVE-2022-37437": {"epss_score": 0.00188, "epss_percentile": 0.40918}, "CVE-2022-37438": {"epss_score": 0.00338, "epss_percentile": 0.56145}, "CVE-2022-37439": {"epss_score": 0.00114, "epss_percentile": 0.30743}, "CVE-2022-37450": {"epss_score": 0.00312, "epss_percentile": 0.54006}, "CVE-2022-37451": {"epss_score": 0.0541, "epss_percentile": 0.89843}, "CVE-2022-37452": {"epss_score": 0.04696, "epss_percentile": 0.89019}, "CVE-2022-37453": {"epss_score": 0.00464, "epss_percentile": 0.63725}, "CVE-2022-37454": {"epss_score": 0.01495, "epss_percentile": 0.80653}, "CVE-2022-37458": {"epss_score": 0.00615, "epss_percentile": 0.69315}, "CVE-2022-37459": {"epss_score": 0.00165, "epss_percentile": 0.38139}, "CVE-2022-37461": {"epss_score": 0.00464, "epss_percentile": 0.63701}, "CVE-2022-37462": {"epss_score": 0.00157, "epss_percentile": 0.37023}, "CVE-2022-37598": {"epss_score": 0.00893, "epss_percentile": 0.75073}, "CVE-2022-37599": {"epss_score": 0.03201, "epss_percentile": 0.86623}, "CVE-2022-37601": {"epss_score": 0.19278, "epss_percentile": 0.95159}, "CVE-2022-37602": {"epss_score": 0.01744, "epss_percentile": 0.82064}, "CVE-2022-37603": {"epss_score": 0.00924, "epss_percentile": 0.75522}, "CVE-2022-37609": {"epss_score": 0.00975, "epss_percentile": 0.76203}, "CVE-2022-37611": {"epss_score": 0.00474, "epss_percentile": 0.64146}, "CVE-2022-37614": {"epss_score": 0.00184, "epss_percentile": 0.40453}, "CVE-2022-37616": {"epss_score": 0.0141, "epss_percentile": 0.80082}, "CVE-2022-37617": {"epss_score": 0.00433, "epss_percentile": 0.62173}, "CVE-2022-37620": {"epss_score": 0.00482, "epss_percentile": 0.6455}, "CVE-2022-37621": {"epss_score": 0.00557, "epss_percentile": 0.67534}, "CVE-2022-37623": {"epss_score": 0.00557, "epss_percentile": 0.67534}, "CVE-2022-37660": {"epss_score": 0.00243, "epss_percentile": 0.47475}, "CVE-2022-37661": {"epss_score": 0.32324, "epss_percentile": 0.96689}, "CVE-2022-37679": {"epss_score": 0.00226, "epss_percentile": 0.45333}, "CVE-2022-37680": {"epss_score": 0.00295, "epss_percentile": 0.52514}, "CVE-2022-37681": {"epss_score": 0.00684, "epss_percentile": 0.71115}, "CVE-2022-37700": {"epss_score": 0.02206, "epss_percentile": 0.84002}, "CVE-2022-37703": {"epss_score": 0.01513, "epss_percentile": 0.80786}, "CVE-2022-37704": {"epss_score": 0.0014, "epss_percentile": 0.34794}, "CVE-2022-37705": {"epss_score": 0.03115, "epss_percentile": 0.86432}, "CVE-2022-37706": {"epss_score": 0.53979, "epss_percentile": 0.97905}, "CVE-2022-37709": {"epss_score": 0.00079, "epss_percentile": 0.23944}, "CVE-2022-37710": {"epss_score": 0.00027, "epss_percentile": 0.07113}, "CVE-2022-37718": {"epss_score": 0.03059, "epss_percentile": 0.86305}, "CVE-2022-37719": {"epss_score": 0.00169, "epss_percentile": 0.38542}, "CVE-2022-37720": {"epss_score": 0.0049, "epss_percentile": 0.64933}, "CVE-2022-37721": {"epss_score": 0.0041, "epss_percentile": 0.60806}, "CVE-2022-37724": {"epss_score": 0.00273, "epss_percentile": 0.50462}, "CVE-2022-37730": {"epss_score": 0.00104, "epss_percentile": 0.29244}, "CVE-2022-37731": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-37734": {"epss_score": 0.01169, "epss_percentile": 0.78204}, "CVE-2022-37767": {"epss_score": 0.00253, "epss_percentile": 0.48441}, "CVE-2022-37768": {"epss_score": 0.0018, "epss_percentile": 0.39901}, "CVE-2022-37769": {"epss_score": 0.00413, "epss_percentile": 0.61001}, "CVE-2022-37770": {"epss_score": 0.00413, "epss_percentile": 0.61001}, "CVE-2022-37771": {"epss_score": 0.00109, "epss_percentile": 0.30038}, "CVE-2022-37772": {"epss_score": 0.00469, "epss_percentile": 0.63948}, "CVE-2022-37773": {"epss_score": 0.00635, "epss_percentile": 0.69825}, "CVE-2022-37774": {"epss_score": 0.00213, "epss_percentile": 0.43927}, "CVE-2022-37775": {"epss_score": 0.00432, "epss_percentile": 0.62123}, "CVE-2022-37777": {"epss_score": 0.02965, "epss_percentile": 0.86079}, "CVE-2022-37778": {"epss_score": 0.02965, "epss_percentile": 0.86079}, "CVE-2022-37779": {"epss_score": 0.02965, "epss_percentile": 0.86079}, "CVE-2022-37780": {"epss_score": 0.02965, "epss_percentile": 0.86079}, "CVE-2022-37781": {"epss_score": 0.00084, "epss_percentile": 0.2498}, "CVE-2022-37783": {"epss_score": 0.01396, "epss_percentile": 0.7998}, "CVE-2022-37785": {"epss_score": 0.0014, "epss_percentile": 0.34733}, "CVE-2022-37786": {"epss_score": 0.00236, "epss_percentile": 0.4641}, "CVE-2022-37787": {"epss_score": 0.00392, "epss_percentile": 0.59655}, "CVE-2022-37794": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-37796": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-37797": {"epss_score": 0.00335, "epss_percentile": 0.55803}, "CVE-2022-37798": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37799": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37800": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37801": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37802": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37803": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37804": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37805": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37806": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37807": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37808": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37809": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37810": {"epss_score": 0.18362, "epss_percentile": 0.95005}, "CVE-2022-37811": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37812": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37813": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37814": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37815": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37816": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-37817": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-37818": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-37819": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-37820": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-37821": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-37822": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-37823": {"epss_score": 0.00133, "epss_percentile": 0.33671}, "CVE-2022-37824": {"epss_score": 0.00133, "epss_percentile": 0.33671}, "CVE-2022-37830": {"epss_score": 0.00209, "epss_percentile": 0.43319}, "CVE-2022-37832": {"epss_score": 0.00344, "epss_percentile": 0.56545}, "CVE-2022-37835": {"epss_score": 0.003, "epss_percentile": 0.52917}, "CVE-2022-37839": {"epss_score": 0.00486, "epss_percentile": 0.64777}, "CVE-2022-37840": {"epss_score": 0.00486, "epss_percentile": 0.64777}, "CVE-2022-37841": {"epss_score": 0.00312, "epss_percentile": 0.53942}, "CVE-2022-37842": {"epss_score": 0.00486, "epss_percentile": 0.64777}, "CVE-2022-37843": {"epss_score": 0.00783, "epss_percentile": 0.73224}, "CVE-2022-37857": {"epss_score": 0.00104, "epss_percentile": 0.29131}, "CVE-2022-37860": {"epss_score": 0.41746, "epss_percentile": 0.97291}, "CVE-2022-37861": {"epss_score": 0.03573, "epss_percentile": 0.87371}, "CVE-2022-37864": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-37865": {"epss_score": 0.00423, "epss_percentile": 0.61619}, "CVE-2022-37866": {"epss_score": 0.00965, "epss_percentile": 0.76047}, "CVE-2022-37877": {"epss_score": 0.00063, "epss_percentile": 0.19991}, "CVE-2022-37878": {"epss_score": 0.00679, "epss_percentile": 0.71022}, "CVE-2022-37879": {"epss_score": 0.00679, "epss_percentile": 0.71022}, "CVE-2022-37880": {"epss_score": 0.00679, "epss_percentile": 0.71022}, "CVE-2022-37881": {"epss_score": 0.00679, "epss_percentile": 0.71022}, "CVE-2022-37882": {"epss_score": 0.00679, "epss_percentile": 0.71022}, "CVE-2022-37883": {"epss_score": 0.00679, "epss_percentile": 0.71022}, "CVE-2022-37884": {"epss_score": 0.00441, "epss_percentile": 0.62664}, "CVE-2022-37885": {"epss_score": 0.01227, "epss_percentile": 0.787}, "CVE-2022-37886": {"epss_score": 0.01227, "epss_percentile": 0.787}, "CVE-2022-37887": {"epss_score": 0.01292, "epss_percentile": 0.79236}, "CVE-2022-37888": {"epss_score": 0.01227, "epss_percentile": 0.787}, "CVE-2022-37889": {"epss_score": 0.01227, "epss_percentile": 0.787}, "CVE-2022-37890": {"epss_score": 0.01881, "epss_percentile": 0.82691}, "CVE-2022-37891": {"epss_score": 0.01881, "epss_percentile": 0.82691}, "CVE-2022-37892": {"epss_score": 0.01476, "epss_percentile": 0.80533}, "CVE-2022-37893": {"epss_score": 0.00486, "epss_percentile": 0.64769}, "CVE-2022-37894": {"epss_score": 0.00243, "epss_percentile": 0.47508}, "CVE-2022-37895": {"epss_score": 0.00638, "epss_percentile": 0.69925}, "CVE-2022-37896": {"epss_score": 0.00282, "epss_percentile": 0.51219}, "CVE-2022-37897": {"epss_score": 0.0077, "epss_percentile": 0.73007}, "CVE-2022-37898": {"epss_score": 0.0115, "epss_percentile": 0.78033}, "CVE-2022-37899": {"epss_score": 0.01909, "epss_percentile": 0.82821}, "CVE-2022-37900": {"epss_score": 0.01909, "epss_percentile": 0.82821}, "CVE-2022-37901": {"epss_score": 0.01909, "epss_percentile": 0.82821}, "CVE-2022-37902": {"epss_score": 0.01909, "epss_percentile": 0.82821}, "CVE-2022-37903": {"epss_score": 0.00572, "epss_percentile": 0.68008}, "CVE-2022-37904": {"epss_score": 0.005, "epss_percentile": 0.6533}, "CVE-2022-37905": {"epss_score": 0.00859, "epss_percentile": 0.74521}, "CVE-2022-37906": {"epss_score": 0.00477, "epss_percentile": 0.64298}, "CVE-2022-37907": {"epss_score": 0.00254, "epss_percentile": 0.48554}, "CVE-2022-37908": {"epss_score": 0.00091, "epss_percentile": 0.26391}, "CVE-2022-37909": {"epss_score": 0.00095, "epss_percentile": 0.27148}, "CVE-2022-37910": {"epss_score": 0.00272, "epss_percentile": 0.50368}, "CVE-2022-37911": {"epss_score": 0.00339, "epss_percentile": 0.56185}, "CVE-2022-37912": {"epss_score": 0.01965, "epss_percentile": 0.8308}, "CVE-2022-37913": {"epss_score": 0.05057, "epss_percentile": 0.89449}, "CVE-2022-37914": {"epss_score": 0.05057, "epss_percentile": 0.89449}, "CVE-2022-37915": {"epss_score": 0.03728, "epss_percentile": 0.87637}, "CVE-2022-37916": {"epss_score": 0.00225, "epss_percentile": 0.45125}, "CVE-2022-37917": {"epss_score": 0.00163, "epss_percentile": 0.37778}, "CVE-2022-37918": {"epss_score": 0.00225, "epss_percentile": 0.45125}, "CVE-2022-37919": {"epss_score": 0.01195, "epss_percentile": 0.78433}, "CVE-2022-37920": {"epss_score": 0.00522, "epss_percentile": 0.66258}, "CVE-2022-37921": {"epss_score": 0.00522, "epss_percentile": 0.66258}, "CVE-2022-37922": {"epss_score": 0.00522, "epss_percentile": 0.66258}, "CVE-2022-37923": {"epss_score": 0.00522, "epss_percentile": 0.66258}, "CVE-2022-37924": {"epss_score": 0.00647, "epss_percentile": 0.70205}, "CVE-2022-37925": {"epss_score": 0.00213, "epss_percentile": 0.43939}, "CVE-2022-37926": {"epss_score": 0.00161, "epss_percentile": 0.37577}, "CVE-2022-37927": {"epss_score": 0.00175, "epss_percentile": 0.39265}, "CVE-2022-37928": {"epss_score": 0.0014, "epss_percentile": 0.34768}, "CVE-2022-37929": {"epss_score": 0.0004, "epss_percentile": 0.12159}, "CVE-2022-37930": {"epss_score": 0.00042, "epss_percentile": 0.12902}, "CVE-2022-37931": {"epss_score": 0.0003, "epss_percentile": 0.0823}, "CVE-2022-37932": {"epss_score": 0.76214, "epss_percentile": 0.98882}, "CVE-2022-37933": {"epss_score": 0.00193, "epss_percentile": 0.41488}, "CVE-2022-37934": {"epss_score": 0.00562, "epss_percentile": 0.67705}, "CVE-2022-37935": {"epss_score": 0.00095, "epss_percentile": 0.27162}, "CVE-2022-37936": {"epss_score": 0.0052, "epss_percentile": 0.66203}, "CVE-2022-37937": {"epss_score": 0.00287, "epss_percentile": 0.51805}, "CVE-2022-37938": {"epss_score": 0.00245, "epss_percentile": 0.47632}, "CVE-2022-37939": {"epss_score": 0.00051, "epss_percentile": 0.1601}, "CVE-2022-37940": {"epss_score": 0.00091, "epss_percentile": 0.26275}, "CVE-2022-37952": {"epss_score": 0.00258, "epss_percentile": 0.49025}, "CVE-2022-37953": {"epss_score": 0.00258, "epss_percentile": 0.49025}, "CVE-2022-37954": {"epss_score": 0.03302, "epss_percentile": 0.86867}, "CVE-2022-37955": {"epss_score": 0.00294, "epss_percentile": 0.52376}, "CVE-2022-37956": {"epss_score": 0.00918, "epss_percentile": 0.75444}, "CVE-2022-37957": {"epss_score": 0.03302, "epss_percentile": 0.86867}, "CVE-2022-37958": {"epss_score": 0.10629, "epss_percentile": 0.93053}, "CVE-2022-37959": {"epss_score": 0.15389, "epss_percentile": 0.94422}, "CVE-2022-37961": {"epss_score": 0.31974, "epss_percentile": 0.96664}, "CVE-2022-37962": {"epss_score": 0.0223, "epss_percentile": 0.84084}, "CVE-2022-37963": {"epss_score": 0.02249, "epss_percentile": 0.84142}, "CVE-2022-37964": {"epss_score": 0.00644, "epss_percentile": 0.70089}, "CVE-2022-37965": {"epss_score": 0.07357, "epss_percentile": 0.9143}, "CVE-2022-37966": {"epss_score": 0.01378, "epss_percentile": 0.79849}, "CVE-2022-37967": {"epss_score": 0.02981, "epss_percentile": 0.86122}, "CVE-2022-37968": {"epss_score": 0.03676, "epss_percentile": 0.87552}, "CVE-2022-37969": {"epss_score": 0.14882, "epss_percentile": 0.94313}, "CVE-2022-37970": {"epss_score": 0.02375, "epss_percentile": 0.84543}, "CVE-2022-37971": {"epss_score": 0.00289, "epss_percentile": 0.52074}, "CVE-2022-37972": {"epss_score": 0.05999, "epss_percentile": 0.90391}, "CVE-2022-37973": {"epss_score": 0.03826, "epss_percentile": 0.87793}, "CVE-2022-37974": {"epss_score": 0.08603, "epss_percentile": 0.92145}, "CVE-2022-37975": {"epss_score": 0.21134, "epss_percentile": 0.95467}, "CVE-2022-37976": {"epss_score": 0.15851, "epss_percentile": 0.94519}, "CVE-2022-37977": {"epss_score": 0.24943, "epss_percentile": 0.95971}, "CVE-2022-37978": {"epss_score": 0.10188, "epss_percentile": 0.92886}, "CVE-2022-37979": {"epss_score": 0.00552, "epss_percentile": 0.67397}, "CVE-2022-37980": {"epss_score": 0.00723, "epss_percentile": 0.72013}, "CVE-2022-37981": {"epss_score": 0.08507, "epss_percentile": 0.92088}, "CVE-2022-37982": {"epss_score": 0.12503, "epss_percentile": 0.93695}, "CVE-2022-37983": {"epss_score": 0.00723, "epss_percentile": 0.72013}, "CVE-2022-37984": {"epss_score": 0.0063, "epss_percentile": 0.69707}, "CVE-2022-37985": {"epss_score": 0.05274, "epss_percentile": 0.89682}, "CVE-2022-37986": {"epss_score": 0.00547, "epss_percentile": 0.67253}, "CVE-2022-37987": {"epss_score": 0.07081, "epss_percentile": 0.91238}, "CVE-2022-37988": {"epss_score": 0.00753, "epss_percentile": 0.72685}, "CVE-2022-37989": {"epss_score": 0.12029, "epss_percentile": 0.93551}, "CVE-2022-37990": {"epss_score": 0.00353, "epss_percentile": 0.57173}, "CVE-2022-37991": {"epss_score": 0.00753, "epss_percentile": 0.72685}, "CVE-2022-37992": {"epss_score": 0.00895, "epss_percentile": 0.75103}, "CVE-2022-37993": {"epss_score": 0.00547, "epss_percentile": 0.67253}, "CVE-2022-37994": {"epss_score": 0.00713, "epss_percentile": 0.71795}, "CVE-2022-37995": {"epss_score": 0.00735, "epss_percentile": 0.72292}, "CVE-2022-37996": {"epss_score": 0.01319, "epss_percentile": 0.79431}, "CVE-2022-37997": {"epss_score": 0.00547, "epss_percentile": 0.67253}, "CVE-2022-37998": {"epss_score": 0.04239, "epss_percentile": 0.88431}, "CVE-2022-37999": {"epss_score": 0.00547, "epss_percentile": 0.67253}, "CVE-2022-38000": {"epss_score": 0.01036, "epss_percentile": 0.7692}, "CVE-2022-38001": {"epss_score": 0.08836, "epss_percentile": 0.92277}, "CVE-2022-38003": {"epss_score": 0.00841, "epss_percentile": 0.74229}, "CVE-2022-38004": {"epss_score": 0.02096, "epss_percentile": 0.83588}, "CVE-2022-38005": {"epss_score": 0.00921, "epss_percentile": 0.75484}, "CVE-2022-38006": {"epss_score": 0.25179, "epss_percentile": 0.95995}, "CVE-2022-38007": {"epss_score": 0.00723, "epss_percentile": 0.72013}, "CVE-2022-38008": {"epss_score": 0.12847, "epss_percentile": 0.93801}, "CVE-2022-38009": {"epss_score": 0.12847, "epss_percentile": 0.93801}, "CVE-2022-38010": {"epss_score": 0.01611, "epss_percentile": 0.8133}, "CVE-2022-38011": {"epss_score": 0.08023, "epss_percentile": 0.91835}, "CVE-2022-38012": {"epss_score": 0.01856, "epss_percentile": 0.8257}, "CVE-2022-38013": {"epss_score": 0.00996, "epss_percentile": 0.76443}, "CVE-2022-38014": {"epss_score": 0.003, "epss_percentile": 0.52917}, "CVE-2022-38015": {"epss_score": 0.00679, "epss_percentile": 0.71014}, "CVE-2022-38016": {"epss_score": 0.00509, "epss_percentile": 0.65756}, "CVE-2022-38017": {"epss_score": 0.00979, "epss_percentile": 0.76256}, "CVE-2022-38019": {"epss_score": 0.07941, "epss_percentile": 0.9178}, "CVE-2022-38020": {"epss_score": 0.02185, "epss_percentile": 0.83919}, "CVE-2022-38021": {"epss_score": 0.0031, "epss_percentile": 0.53753}, "CVE-2022-38022": {"epss_score": 0.00735, "epss_percentile": 0.72285}, "CVE-2022-38023": {"epss_score": 0.00384, "epss_percentile": 0.5913}, "CVE-2022-38025": {"epss_score": 0.01188, "epss_percentile": 0.7837}, "CVE-2022-38026": {"epss_score": 0.00405, "epss_percentile": 0.60484}, "CVE-2022-38027": {"epss_score": 0.00313, "epss_percentile": 0.54046}, "CVE-2022-38028": {"epss_score": 0.05711, "epss_percentile": 0.90142}, "CVE-2022-38029": {"epss_score": 0.05236, "epss_percentile": 0.89648}, "CVE-2022-38030": {"epss_score": 0.01115, "epss_percentile": 0.77705}, "CVE-2022-38031": {"epss_score": 0.17266, "epss_percentile": 0.94811}, "CVE-2022-38032": {"epss_score": 0.00692, "epss_percentile": 0.71302}, "CVE-2022-38033": {"epss_score": 0.17325, "epss_percentile": 0.94823}, "CVE-2022-38034": {"epss_score": 0.09624, "epss_percentile": 0.92629}, "CVE-2022-38036": {"epss_score": 0.23743, "epss_percentile": 0.95812}, "CVE-2022-38037": {"epss_score": 0.02609, "epss_percentile": 0.85231}, "CVE-2022-38038": {"epss_score": 0.03021, "epss_percentile": 0.86225}, "CVE-2022-38039": {"epss_score": 0.01232, "epss_percentile": 0.78737}, "CVE-2022-38040": {"epss_score": 0.17266, "epss_percentile": 0.94811}, "CVE-2022-38041": {"epss_score": 0.27321, "epss_percentile": 0.96237}, "CVE-2022-38042": {"epss_score": 0.05003, "epss_percentile": 0.8938}, "CVE-2022-38043": {"epss_score": 0.0181, "epss_percentile": 0.82362}, "CVE-2022-38044": {"epss_score": 0.11031, "epss_percentile": 0.93195}, "CVE-2022-38045": {"epss_score": 0.13974, "epss_percentile": 0.94104}, "CVE-2022-38046": {"epss_score": 0.1816, "epss_percentile": 0.94968}, "CVE-2022-38047": {"epss_score": 0.01265, "epss_percentile": 0.79005}, "CVE-2022-38048": {"epss_score": 0.06128, "epss_percentile": 0.90498}, "CVE-2022-38049": {"epss_score": 0.07941, "epss_percentile": 0.9178}, "CVE-2022-38050": {"epss_score": 0.03175, "epss_percentile": 0.86568}, "CVE-2022-38051": {"epss_score": 0.02424, "epss_percentile": 0.84712}, "CVE-2022-38053": {"epss_score": 0.49232, "epss_percentile": 0.97674}, "CVE-2022-38054": {"epss_score": 0.0198, "epss_percentile": 0.83135}, "CVE-2022-38055": {"epss_score": 0.0015, "epss_percentile": 0.36071}, "CVE-2022-38056": {"epss_score": 0.00043, "epss_percentile": 0.13058}, "CVE-2022-38057": {"epss_score": 0.00107, "epss_percentile": 0.29633}, "CVE-2022-38058": {"epss_score": 0.00308, "epss_percentile": 0.53618}, "CVE-2022-38059": {"epss_score": 0.00105, "epss_percentile": 0.29362}, "CVE-2022-38060": {"epss_score": 0.00034, "epss_percentile": 0.09792}, "CVE-2022-38061": {"epss_score": 0.00527, "epss_percentile": 0.66523}, "CVE-2022-38062": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-38063": {"epss_score": 0.00054, "epss_percentile": 0.17115}, "CVE-2022-38064": {"epss_score": 0.00052, "epss_percentile": 0.16358}, "CVE-2022-38065": {"epss_score": 0.00171, "epss_percentile": 0.38814}, "CVE-2022-38066": {"epss_score": 0.00291, "epss_percentile": 0.52194}, "CVE-2022-38067": {"epss_score": 0.00244, "epss_percentile": 0.47585}, "CVE-2022-38068": {"epss_score": 0.00369, "epss_percentile": 0.58267}, "CVE-2022-38069": {"epss_score": 0.0007, "epss_percentile": 0.2194}, "CVE-2022-38070": {"epss_score": 0.0035, "epss_percentile": 0.56952}, "CVE-2022-38072": {"epss_score": 0.00085, "epss_percentile": 0.25117}, "CVE-2022-38073": {"epss_score": 0.00295, "epss_percentile": 0.52504}, "CVE-2022-38074": {"epss_score": 0.00515, "epss_percentile": 0.65973}, "CVE-2022-38075": {"epss_score": 0.00093, "epss_percentile": 0.2674}, "CVE-2022-38076": {"epss_score": 0.00073, "epss_percentile": 0.22606}, "CVE-2022-38077": {"epss_score": 0.00088, "epss_percentile": 0.25708}, "CVE-2022-38078": {"epss_score": 0.05225, "epss_percentile": 0.89632}, "CVE-2022-38079": {"epss_score": 0.00104, "epss_percentile": 0.29139}, "CVE-2022-38080": {"epss_score": 0.00369, "epss_percentile": 0.58224}, "CVE-2022-38081": {"epss_score": 0.00044, "epss_percentile": 0.13473}, "CVE-2022-38083": {"epss_score": 0.00026, "epss_percentile": 0.06589}, "CVE-2022-38085": {"epss_score": 0.00149, "epss_percentile": 0.3602}, "CVE-2022-38086": {"epss_score": 0.00105, "epss_percentile": 0.29292}, "CVE-2022-38087": {"epss_score": 0.00039, "epss_percentile": 0.11427}, "CVE-2022-38088": {"epss_score": 0.01102, "epss_percentile": 0.7758}, "CVE-2022-38089": {"epss_score": 0.00369, "epss_percentile": 0.58224}, "CVE-2022-38090": {"epss_score": 0.00055, "epss_percentile": 0.17514}, "CVE-2022-38093": {"epss_score": 0.00184, "epss_percentile": 0.40438}, "CVE-2022-38094": {"epss_score": 0.0345, "epss_percentile": 0.87162}, "CVE-2022-38095": {"epss_score": 0.00106, "epss_percentile": 0.29533}, "CVE-2022-38096": {"epss_score": 0.00021, "epss_percentile": 0.04732}, "CVE-2022-38097": {"epss_score": 0.00527, "epss_percentile": 0.66524}, "CVE-2022-38099": {"epss_score": 0.00127, "epss_percentile": 0.32914}, "CVE-2022-38100": {"epss_score": 0.00212, "epss_percentile": 0.43781}, "CVE-2022-38101": {"epss_score": 0.0007, "epss_percentile": 0.21972}, "CVE-2022-38102": {"epss_score": 0.00014, "epss_percentile": 0.01866}, "CVE-2022-38103": {"epss_score": 0.00052, "epss_percentile": 0.16541}, "CVE-2022-38104": {"epss_score": 0.00904, "epss_percentile": 0.75222}, "CVE-2022-38105": {"epss_score": 0.00261, "epss_percentile": 0.4927}, "CVE-2022-38106": {"epss_score": 0.03379, "epss_percentile": 0.87027}, "CVE-2022-38107": {"epss_score": 0.011, "epss_percentile": 0.77561}, "CVE-2022-38108": {"epss_score": 0.85475, "epss_percentile": 0.99335}, "CVE-2022-38110": {"epss_score": 0.00925, "epss_percentile": 0.7553}, "CVE-2022-38111": {"epss_score": 0.20603, "epss_percentile": 0.95383}, "CVE-2022-38112": {"epss_score": 0.00176, "epss_percentile": 0.39377}, "CVE-2022-38113": {"epss_score": 0.011, "epss_percentile": 0.77561}, "CVE-2022-38114": {"epss_score": 0.01321, "epss_percentile": 0.79445}, "CVE-2022-38115": {"epss_score": 0.01494, "epss_percentile": 0.80651}, "CVE-2022-38116": {"epss_score": 0.00935, "epss_percentile": 0.75674}, "CVE-2022-38117": {"epss_score": 0.0015, "epss_percentile": 0.36145}, "CVE-2022-38118": {"epss_score": 0.0101, "epss_percentile": 0.76591}, "CVE-2022-38119": {"epss_score": 0.02732, "epss_percentile": 0.85543}, "CVE-2022-38120": {"epss_score": 0.48227, "epss_percentile": 0.97627}, "CVE-2022-38121": {"epss_score": 0.44278, "epss_percentile": 0.97427}, "CVE-2022-38122": {"epss_score": 0.00359, "epss_percentile": 0.57607}, "CVE-2022-38123": {"epss_score": 0.00523, "epss_percentile": 0.66287}, "CVE-2022-38124": {"epss_score": 0.0031, "epss_percentile": 0.53758}, "CVE-2022-38125": {"epss_score": 0.00062, "epss_percentile": 0.19584}, "CVE-2022-38129": {"epss_score": 0.03167, "epss_percentile": 0.8654}, "CVE-2022-38130": {"epss_score": 0.79442, "epss_percentile": 0.99038}, "CVE-2022-38131": {"epss_score": 0.03774, "epss_percentile": 0.87708}, "CVE-2022-38132": {"epss_score": 0.00766, "epss_percentile": 0.72936}, "CVE-2022-38133": {"epss_score": 4e-05, "epss_percentile": 0.00124}, "CVE-2022-38134": {"epss_score": 0.00566, "epss_percentile": 0.67832}, "CVE-2022-38135": {"epss_score": 0.00178, "epss_percentile": 0.39722}, "CVE-2022-38136": {"epss_score": 0.00082, "epss_percentile": 0.24474}, "CVE-2022-38137": {"epss_score": 0.00106, "epss_percentile": 0.29524}, "CVE-2022-38138": {"epss_score": 0.00059, "epss_percentile": 0.18753}, "CVE-2022-38139": {"epss_score": 0.00113, "epss_percentile": 0.30721}, "CVE-2022-38140": {"epss_score": 0.00741, "epss_percentile": 0.72434}, "CVE-2022-38141": {"epss_score": 0.00078, "epss_percentile": 0.23616}, "CVE-2022-38142": {"epss_score": 0.01453, "epss_percentile": 0.80375}, "CVE-2022-38143": {"epss_score": 0.00385, "epss_percentile": 0.59204}, "CVE-2022-38144": {"epss_score": 0.00104, "epss_percentile": 0.29139}, "CVE-2022-38145": {"epss_score": 0.00235, "epss_percentile": 0.46214}, "CVE-2022-38146": {"epss_score": 0.00322, "epss_percentile": 0.5476}, "CVE-2022-38147": {"epss_score": 0.00322, "epss_percentile": 0.5476}, "CVE-2022-38148": {"epss_score": 0.00251, "epss_percentile": 0.48283}, "CVE-2022-38149": {"epss_score": 0.0039, "epss_percentile": 0.59521}, "CVE-2022-38150": {"epss_score": 0.00684, "epss_percentile": 0.71116}, "CVE-2022-38152": {"epss_score": 0.05787, "epss_percentile": 0.90209}, "CVE-2022-38153": {"epss_score": 0.0377, "epss_percentile": 0.87701}, "CVE-2022-38155": {"epss_score": 0.00318, "epss_percentile": 0.54427}, "CVE-2022-38156": {"epss_score": 0.00276, "epss_percentile": 0.50771}, "CVE-2022-38161": {"epss_score": 0.00166, "epss_percentile": 0.38256}, "CVE-2022-38162": {"epss_score": 0.00291, "epss_percentile": 0.5218}, "CVE-2022-38163": {"epss_score": 0.00396, "epss_percentile": 0.59863}, "CVE-2022-38164": {"epss_score": 0.00372, "epss_percentile": 0.58458}, "CVE-2022-38165": {"epss_score": 0.01667, "epss_percentile": 0.81656}, "CVE-2022-38166": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2022-38167": {"epss_score": 0.00472, "epss_percentile": 0.64051}, "CVE-2022-38168": {"epss_score": 0.00483, "epss_percentile": 0.64561}, "CVE-2022-38170": {"epss_score": 0.00294, "epss_percentile": 0.52376}, "CVE-2022-38171": {"epss_score": 0.00091, "epss_percentile": 0.26233}, "CVE-2022-38172": {"epss_score": 0.01652, "epss_percentile": 0.81576}, "CVE-2022-38176": {"epss_score": 0.00154, "epss_percentile": 0.36664}, "CVE-2022-38177": {"epss_score": 0.01319, "epss_percentile": 0.79432}, "CVE-2022-38178": {"epss_score": 0.01484, "epss_percentile": 0.80589}, "CVE-2022-38179": {"epss_score": 4e-05, "epss_percentile": 0.00149}, "CVE-2022-38180": {"epss_score": 3e-05, "epss_percentile": 0.00105}, "CVE-2022-38181": {"epss_score": 0.24547, "epss_percentile": 0.95932}, "CVE-2022-38183": {"epss_score": 0.00256, "epss_percentile": 0.48827}, "CVE-2022-38184": {"epss_score": 0.00864, "epss_percentile": 0.74602}, "CVE-2022-38186": {"epss_score": 0.00197, "epss_percentile": 0.41972}, "CVE-2022-38187": {"epss_score": 0.00362, "epss_percentile": 0.57777}, "CVE-2022-38188": {"epss_score": 0.00197, "epss_percentile": 0.41972}, "CVE-2022-38189": {"epss_score": 0.002, "epss_percentile": 0.42214}, "CVE-2022-38190": {"epss_score": 0.00491, "epss_percentile": 0.64945}, "CVE-2022-38191": {"epss_score": 0.00154, "epss_percentile": 0.36724}, "CVE-2022-38192": {"epss_score": 0.002, "epss_percentile": 0.42214}, "CVE-2022-38193": {"epss_score": 0.00622, "epss_percentile": 0.69497}, "CVE-2022-38194": {"epss_score": 0.00034, "epss_percentile": 0.09792}, "CVE-2022-38195": {"epss_score": 0.00258, "epss_percentile": 0.49025}, "CVE-2022-38196": {"epss_score": 0.00932, "epss_percentile": 0.75628}, "CVE-2022-38197": {"epss_score": 0.00626, "epss_percentile": 0.69615}, "CVE-2022-38198": {"epss_score": 0.00528, "epss_percentile": 0.6655}, "CVE-2022-38199": {"epss_score": 0.00198, "epss_percentile": 0.42004}, "CVE-2022-38200": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-38201": {"epss_score": 0.00361, "epss_percentile": 0.57693}, "CVE-2022-38202": {"epss_score": 0.00692, "epss_percentile": 0.71301}, "CVE-2022-38203": {"epss_score": 0.00864, "epss_percentile": 0.74602}, "CVE-2022-38204": {"epss_score": 0.0039, "epss_percentile": 0.59547}, "CVE-2022-38205": {"epss_score": 0.02028, "epss_percentile": 0.83322}, "CVE-2022-38206": {"epss_score": 0.0039, "epss_percentile": 0.59547}, "CVE-2022-38207": {"epss_score": 0.00361, "epss_percentile": 0.57734}, "CVE-2022-38208": {"epss_score": 0.00361, "epss_percentile": 0.57693}, "CVE-2022-38209": {"epss_score": 0.00361, "epss_percentile": 0.57734}, "CVE-2022-38210": {"epss_score": 0.00361, "epss_percentile": 0.57734}, "CVE-2022-38211": {"epss_score": 0.00936, "epss_percentile": 0.7568}, "CVE-2022-38212": {"epss_score": 0.00864, "epss_percentile": 0.74602}, "CVE-2022-38216": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-38220": {"epss_score": 0.00137, "epss_percentile": 0.34252}, "CVE-2022-38221": {"epss_score": 0.0243, "epss_percentile": 0.84726}, "CVE-2022-38222": {"epss_score": 0.00153, "epss_percentile": 0.36509}, "CVE-2022-38223": {"epss_score": 0.00118, "epss_percentile": 0.31459}, "CVE-2022-38227": {"epss_score": 0.00054, "epss_percentile": 0.17325}, "CVE-2022-38228": {"epss_score": 0.00054, "epss_percentile": 0.17325}, "CVE-2022-38229": {"epss_score": 0.00052, "epss_percentile": 0.16572}, "CVE-2022-38230": {"epss_score": 0.00063, "epss_percentile": 0.20075}, "CVE-2022-38231": {"epss_score": 0.00052, "epss_percentile": 0.16388}, "CVE-2022-38233": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-38234": {"epss_score": 0.00047, "epss_percentile": 0.14587}, "CVE-2022-38235": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-38236": {"epss_score": 0.00052, "epss_percentile": 0.16572}, "CVE-2022-38237": {"epss_score": 0.00054, "epss_percentile": 0.17325}, "CVE-2022-38238": {"epss_score": 0.00054, "epss_percentile": 0.17325}, "CVE-2022-38247": {"epss_score": 0.34271, "epss_percentile": 0.96838}, "CVE-2022-38248": {"epss_score": 0.33524, "epss_percentile": 0.96782}, "CVE-2022-38249": {"epss_score": 0.33524, "epss_percentile": 0.96782}, "CVE-2022-38250": {"epss_score": 0.43951, "epss_percentile": 0.9741}, "CVE-2022-38251": {"epss_score": 0.36099, "epss_percentile": 0.96956}, "CVE-2022-38254": {"epss_score": 0.33524, "epss_percentile": 0.96782}, "CVE-2022-38255": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38256": {"epss_score": 0.004, "epss_percentile": 0.60154}, "CVE-2022-38258": {"epss_score": 0.01403, "epss_percentile": 0.80032}, "CVE-2022-38260": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38265": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38266": {"epss_score": 0.00257, "epss_percentile": 0.48892}, "CVE-2022-38267": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38268": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38269": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38272": {"epss_score": 0.00349, "epss_percentile": 0.56892}, "CVE-2022-38273": {"epss_score": 0.00349, "epss_percentile": 0.56892}, "CVE-2022-38274": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-38275": {"epss_score": 0.00349, "epss_percentile": 0.56892}, "CVE-2022-38276": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-38277": {"epss_score": 0.00349, "epss_percentile": 0.56892}, "CVE-2022-38278": {"epss_score": 0.00349, "epss_percentile": 0.56892}, "CVE-2022-38279": {"epss_score": 0.00349, "epss_percentile": 0.56892}, "CVE-2022-38280": {"epss_score": 0.00349, "epss_percentile": 0.56892}, "CVE-2022-38281": {"epss_score": 0.00349, "epss_percentile": 0.56892}, "CVE-2022-38282": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38283": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38284": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38285": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38286": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38291": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2022-38292": {"epss_score": 0.00299, "epss_percentile": 0.52896}, "CVE-2022-38295": {"epss_score": 0.33662, "epss_percentile": 0.96795}, "CVE-2022-38296": {"epss_score": 0.82103, "epss_percentile": 0.99174}, "CVE-2022-38297": {"epss_score": 0.00421, "epss_percentile": 0.61507}, "CVE-2022-38298": {"epss_score": 0.00257, "epss_percentile": 0.48852}, "CVE-2022-38299": {"epss_score": 0.00167, "epss_percentile": 0.38391}, "CVE-2022-38301": {"epss_score": 0.00606, "epss_percentile": 0.69022}, "CVE-2022-38302": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38303": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38304": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38305": {"epss_score": 0.0074, "epss_percentile": 0.724}, "CVE-2022-38306": {"epss_score": 0.00054, "epss_percentile": 0.17325}, "CVE-2022-38307": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-38308": {"epss_score": 0.2805, "epss_percentile": 0.96304}, "CVE-2022-38309": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-38310": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-38311": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-38312": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-38313": {"epss_score": 0.00392, "epss_percentile": 0.59699}, "CVE-2022-38314": {"epss_score": 0.00392, "epss_percentile": 0.59699}, "CVE-2022-38323": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-38325": {"epss_score": 0.00392, "epss_percentile": 0.59699}, "CVE-2022-38326": {"epss_score": 0.00392, "epss_percentile": 0.59699}, "CVE-2022-38329": {"epss_score": 0.00369, "epss_percentile": 0.58274}, "CVE-2022-38333": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2022-38334": {"epss_score": 0.00102, "epss_percentile": 0.28896}, "CVE-2022-38335": {"epss_score": 0.00507, "epss_percentile": 0.65652}, "CVE-2022-38336": {"epss_score": 0.0038, "epss_percentile": 0.58907}, "CVE-2022-38337": {"epss_score": 0.00451, "epss_percentile": 0.6313}, "CVE-2022-38339": {"epss_score": 0.00642, "epss_percentile": 0.70023}, "CVE-2022-38340": {"epss_score": 0.00826, "epss_percentile": 0.73965}, "CVE-2022-38341": {"epss_score": 0.00326, "epss_percentile": 0.55064}, "CVE-2022-38342": {"epss_score": 0.00345, "epss_percentile": 0.56561}, "CVE-2022-38349": {"epss_score": 0.0002, "epss_percentile": 0.04499}, "CVE-2022-38351": {"epss_score": 0.00294, "epss_percentile": 0.52359}, "CVE-2022-38352": {"epss_score": 0.03586, "epss_percentile": 0.87393}, "CVE-2022-38355": {"epss_score": 0.00109, "epss_percentile": 0.29922}, "CVE-2022-38356": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-38357": {"epss_score": 0.00431, "epss_percentile": 0.62044}, "CVE-2022-38358": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-38359": {"epss_score": 0.00212, "epss_percentile": 0.43754}, "CVE-2022-38362": {"epss_score": 0.00867, "epss_percentile": 0.74658}, "CVE-2022-38367": {"epss_score": 0.0078, "epss_percentile": 0.7316}, "CVE-2022-38368": {"epss_score": 0.00434, "epss_percentile": 0.62317}, "CVE-2022-38369": {"epss_score": 0.01867, "epss_percentile": 0.82619}, "CVE-2022-38370": {"epss_score": 0.00918, "epss_percentile": 0.75442}, "CVE-2022-38371": {"epss_score": 0.00859, "epss_percentile": 0.74514}, "CVE-2022-38372": {"epss_score": 0.00052, "epss_percentile": 0.16361}, "CVE-2022-38373": {"epss_score": 0.00838, "epss_percentile": 0.74178}, "CVE-2022-38374": {"epss_score": 0.16678, "epss_percentile": 0.94713}, "CVE-2022-38375": {"epss_score": 0.00369, "epss_percentile": 0.58226}, "CVE-2022-38376": {"epss_score": 0.00825, "epss_percentile": 0.73949}, "CVE-2022-38377": {"epss_score": 0.00164, "epss_percentile": 0.37898}, "CVE-2022-38378": {"epss_score": 0.00043, "epss_percentile": 0.13211}, "CVE-2022-38379": {"epss_score": 0.00629, "epss_percentile": 0.69672}, "CVE-2022-38380": {"epss_score": 0.00199, "epss_percentile": 0.42119}, "CVE-2022-38381": {"epss_score": 0.00271, "epss_percentile": 0.5033}, "CVE-2022-38382": {"epss_score": 0.00092, "epss_percentile": 0.26469}, "CVE-2022-38383": {"epss_score": 0.00046, "epss_percentile": 0.14183}, "CVE-2022-38385": {"epss_score": 0.00153, "epss_percentile": 0.36564}, "CVE-2022-38386": {"epss_score": 0.00069, "epss_percentile": 0.21527}, "CVE-2022-38387": {"epss_score": 0.00328, "epss_percentile": 0.55264}, "CVE-2022-38388": {"epss_score": 0.00036, "epss_percentile": 0.10236}, "CVE-2022-38389": {"epss_score": 0.00029, "epss_percentile": 0.07864}, "CVE-2022-38390": {"epss_score": 0.00281, "epss_percentile": 0.51127}, "CVE-2022-38391": {"epss_score": 0.00059, "epss_percentile": 0.18682}, "CVE-2022-38392": {"epss_score": 0.00071, "epss_percentile": 0.22085}, "CVE-2022-38393": {"epss_score": 0.01701, "epss_percentile": 0.81837}, "CVE-2022-38394": {"epss_score": 0.0175, "epss_percentile": 0.82095}, "CVE-2022-38395": {"epss_score": 0.00401, "epss_percentile": 0.60256}, "CVE-2022-38396": {"epss_score": 0.00195, "epss_percentile": 0.416}, "CVE-2022-38398": {"epss_score": 0.00146, "epss_percentile": 0.35549}, "CVE-2022-38399": {"epss_score": 0.00219, "epss_percentile": 0.44531}, "CVE-2022-38400": {"epss_score": 0.00329, "epss_percentile": 0.55393}, "CVE-2022-38401": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-38402": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-38403": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-38404": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-38405": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-38406": {"epss_score": 0.00195, "epss_percentile": 0.41604}, "CVE-2022-38407": {"epss_score": 0.00195, "epss_percentile": 0.41604}, "CVE-2022-38408": {"epss_score": 0.0025, "epss_percentile": 0.48088}, "CVE-2022-38409": {"epss_score": 0.00167, "epss_percentile": 0.38368}, "CVE-2022-38410": {"epss_score": 0.00167, "epss_percentile": 0.38368}, "CVE-2022-38411": {"epss_score": 0.00247, "epss_percentile": 0.47863}, "CVE-2022-38412": {"epss_score": 0.00312, "epss_percentile": 0.54002}, "CVE-2022-38413": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-38414": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-38415": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-38416": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-38417": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-38418": {"epss_score": 0.04886, "epss_percentile": 0.89254}, "CVE-2022-38419": {"epss_score": 0.02751, "epss_percentile": 0.85582}, "CVE-2022-38420": {"epss_score": 0.00963, "epss_percentile": 0.76002}, "CVE-2022-38421": {"epss_score": 0.05058, "epss_percentile": 0.8945}, "CVE-2022-38422": {"epss_score": 0.0346, "epss_percentile": 0.87178}, "CVE-2022-38423": {"epss_score": 0.01306, "epss_percentile": 0.79335}, "CVE-2022-38424": {"epss_score": 0.03843, "epss_percentile": 0.87834}, "CVE-2022-38425": {"epss_score": 0.00313, "epss_percentile": 0.54069}, "CVE-2022-38426": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-38427": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-38428": {"epss_score": 0.00204, "epss_percentile": 0.42629}, "CVE-2022-38429": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-38430": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-38431": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-38432": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-38433": {"epss_score": 0.00127, "epss_percentile": 0.32929}, "CVE-2022-38434": {"epss_score": 0.0032, "epss_percentile": 0.54592}, "CVE-2022-38435": {"epss_score": 0.00206, "epss_percentile": 0.43074}, "CVE-2022-38436": {"epss_score": 0.00216, "epss_percentile": 0.4415}, "CVE-2022-38437": {"epss_score": 0.00102, "epss_percentile": 0.28745}, "CVE-2022-38438": {"epss_score": 0.00683, "epss_percentile": 0.71089}, "CVE-2022-38439": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-38440": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-38441": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2022-38442": {"epss_score": 0.00334, "epss_percentile": 0.55704}, "CVE-2022-38443": {"epss_score": 0.0022, "epss_percentile": 0.44579}, "CVE-2022-38444": {"epss_score": 0.00334, "epss_percentile": 0.55704}, "CVE-2022-38445": {"epss_score": 0.00334, "epss_percentile": 0.55704}, "CVE-2022-38446": {"epss_score": 0.00334, "epss_percentile": 0.55704}, "CVE-2022-38447": {"epss_score": 0.00334, "epss_percentile": 0.55704}, "CVE-2022-38448": {"epss_score": 0.00334, "epss_percentile": 0.55704}, "CVE-2022-38449": {"epss_score": 0.00119, "epss_percentile": 0.31639}, "CVE-2022-38450": {"epss_score": 0.00193, "epss_percentile": 0.41377}, "CVE-2022-38451": {"epss_score": 0.00617, "epss_percentile": 0.69348}, "CVE-2022-38452": {"epss_score": 0.00147, "epss_percentile": 0.35753}, "CVE-2022-38453": {"epss_score": 0.00028, "epss_percentile": 0.0758}, "CVE-2022-38454": {"epss_score": 0.00104, "epss_percentile": 0.29139}, "CVE-2022-38456": {"epss_score": 0.00329, "epss_percentile": 0.55321}, "CVE-2022-38457": {"epss_score": 0.00025, "epss_percentile": 0.06049}, "CVE-2022-38458": {"epss_score": 0.00121, "epss_percentile": 0.32007}, "CVE-2022-38459": {"epss_score": 0.11584, "epss_percentile": 0.93411}, "CVE-2022-38460": {"epss_score": 0.00712, "epss_percentile": 0.71751}, "CVE-2022-38461": {"epss_score": 0.00214, "epss_percentile": 0.43974}, "CVE-2022-38462": {"epss_score": 0.0068, "epss_percentile": 0.7103}, "CVE-2022-38463": {"epss_score": 0.46526, "epss_percentile": 0.97551}, "CVE-2022-38465": {"epss_score": 0.00114, "epss_percentile": 0.30814}, "CVE-2022-38466": {"epss_score": 0.00031, "epss_percentile": 0.08397}, "CVE-2022-38467": {"epss_score": 0.10541, "epss_percentile": 0.93022}, "CVE-2022-38468": {"epss_score": 0.00094, "epss_percentile": 0.26778}, "CVE-2022-38469": {"epss_score": 0.00223, "epss_percentile": 0.44853}, "CVE-2022-38470": {"epss_score": 0.00106, "epss_percentile": 0.29524}, "CVE-2022-38472": {"epss_score": 0.00133, "epss_percentile": 0.33693}, "CVE-2022-38473": {"epss_score": 0.0027, "epss_percentile": 0.5026}, "CVE-2022-38474": {"epss_score": 0.00191, "epss_percentile": 0.41257}, "CVE-2022-38475": {"epss_score": 0.00169, "epss_percentile": 0.38631}, "CVE-2022-38476": {"epss_score": 0.00146, "epss_percentile": 0.3559}, "CVE-2022-38477": {"epss_score": 0.00189, "epss_percentile": 0.40958}, "CVE-2022-38478": {"epss_score": 0.00271, "epss_percentile": 0.50329}, "CVE-2022-38481": {"epss_score": 0.00833, "epss_percentile": 0.74084}, "CVE-2022-38482": {"epss_score": 0.00554, "epss_percentile": 0.67453}, "CVE-2022-38484": {"epss_score": 0.01256, "epss_percentile": 0.78941}, "CVE-2022-38485": {"epss_score": 0.00143, "epss_percentile": 0.352}, "CVE-2022-38488": {"epss_score": 0.02763, "epss_percentile": 0.85606}, "CVE-2022-38489": {"epss_score": 0.0008, "epss_percentile": 0.24149}, "CVE-2022-38490": {"epss_score": 0.001, "epss_percentile": 0.28461}, "CVE-2022-38491": {"epss_score": 0.00168, "epss_percentile": 0.385}, "CVE-2022-38492": {"epss_score": 0.00098, "epss_percentile": 0.27805}, "CVE-2022-38493": {"epss_score": 0.0008, "epss_percentile": 0.24039}, "CVE-2022-38495": {"epss_score": 0.00054, "epss_percentile": 0.17325}, "CVE-2022-38496": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-38497": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-38509": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-38510": {"epss_score": 0.0006, "epss_percentile": 0.19131}, "CVE-2022-38511": {"epss_score": 0.00348, "epss_percentile": 0.5681}, "CVE-2022-38512": {"epss_score": 0.0022, "epss_percentile": 0.44608}, "CVE-2022-38527": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-38528": {"epss_score": 0.00263, "epss_percentile": 0.49473}, "CVE-2022-38529": {"epss_score": 0.00064, "epss_percentile": 0.204}, "CVE-2022-38530": {"epss_score": 0.00044, "epss_percentile": 0.1349}, "CVE-2022-38531": {"epss_score": 0.03364, "epss_percentile": 0.86999}, "CVE-2022-38532": {"epss_score": 0.01623, "epss_percentile": 0.81404}, "CVE-2022-38533": {"epss_score": 0.00028, "epss_percentile": 0.07238}, "CVE-2022-38534": {"epss_score": 0.03514, "epss_percentile": 0.8727}, "CVE-2022-38535": {"epss_score": 0.03514, "epss_percentile": 0.8727}, "CVE-2022-38537": {"epss_score": 0.00305, "epss_percentile": 0.53378}, "CVE-2022-38538": {"epss_score": 0.00305, "epss_percentile": 0.53378}, "CVE-2022-38539": {"epss_score": 0.00305, "epss_percentile": 0.53378}, "CVE-2022-38540": {"epss_score": 0.00305, "epss_percentile": 0.53378}, "CVE-2022-38541": {"epss_score": 0.00305, "epss_percentile": 0.53378}, "CVE-2022-38542": {"epss_score": 0.00305, "epss_percentile": 0.53378}, "CVE-2022-38545": {"epss_score": 0.01647, "epss_percentile": 0.81538}, "CVE-2022-38546": {"epss_score": 0.00293, "epss_percentile": 0.52317}, "CVE-2022-38547": {"epss_score": 0.00568, "epss_percentile": 0.6789}, "CVE-2022-38550": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-38553": {"epss_score": 0.07869, "epss_percentile": 0.91734}, "CVE-2022-38555": {"epss_score": 0.00662, "epss_percentile": 0.70598}, "CVE-2022-38556": {"epss_score": 0.00358, "epss_percentile": 0.57484}, "CVE-2022-38557": {"epss_score": 0.00722, "epss_percentile": 0.71997}, "CVE-2022-38562": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-38563": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-38564": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-38565": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-38566": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-38567": {"epss_score": 0.0046, "epss_percentile": 0.63522}, "CVE-2022-38568": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-38569": {"epss_score": 0.00417, "epss_percentile": 0.61255}, "CVE-2022-38570": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-38571": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-38573": {"epss_score": 0.00786, "epss_percentile": 0.73278}, "CVE-2022-38576": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38577": {"epss_score": 0.13435, "epss_percentile": 0.93962}, "CVE-2022-38580": {"epss_score": 0.46506, "epss_percentile": 0.9755}, "CVE-2022-38582": {"epss_score": 0.00322, "epss_percentile": 0.54754}, "CVE-2022-38583": {"epss_score": 0.00045, "epss_percentile": 0.1395}, "CVE-2022-38594": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38595": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38599": {"epss_score": 0.00337, "epss_percentile": 0.56048}, "CVE-2022-38600": {"epss_score": 0.00059, "epss_percentile": 0.18688}, "CVE-2022-38604": {"epss_score": 0.04203, "epss_percentile": 0.88391}, "CVE-2022-38605": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38606": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38610": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38611": {"epss_score": 0.0014, "epss_percentile": 0.34801}, "CVE-2022-38613": {"epss_score": 0.0038, "epss_percentile": 0.58961}, "CVE-2022-38614": {"epss_score": 0.00512, "epss_percentile": 0.65852}, "CVE-2022-38615": {"epss_score": 0.00291, "epss_percentile": 0.52211}, "CVE-2022-38616": {"epss_score": 0.00885, "epss_percentile": 0.74941}, "CVE-2022-38617": {"epss_score": 0.00291, "epss_percentile": 0.52211}, "CVE-2022-38618": {"epss_score": 0.00291, "epss_percentile": 0.52211}, "CVE-2022-38619": {"epss_score": 0.00875, "epss_percentile": 0.74783}, "CVE-2022-38621": {"epss_score": 0.02849, "epss_percentile": 0.85825}, "CVE-2022-38625": {"epss_score": 0.00265, "epss_percentile": 0.49838}, "CVE-2022-38627": {"epss_score": 0.71129, "epss_percentile": 0.98654}, "CVE-2022-38628": {"epss_score": 0.08307, "epss_percentile": 0.91983}, "CVE-2022-38633": {"epss_score": 0.00065, "epss_percentile": 0.20564}, "CVE-2022-38637": {"epss_score": 0.19954, "epss_percentile": 0.95266}, "CVE-2022-38638": {"epss_score": 0.00645, "epss_percentile": 0.70126}, "CVE-2022-38639": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-38648": {"epss_score": 0.00146, "epss_percentile": 0.35549}, "CVE-2022-38649": {"epss_score": 0.11975, "epss_percentile": 0.93531}, "CVE-2022-38650": {"epss_score": 0.00846, "epss_percentile": 0.74322}, "CVE-2022-38651": {"epss_score": 0.00314, "epss_percentile": 0.5408}, "CVE-2022-38652": {"epss_score": 0.00628, "epss_percentile": 0.6966}, "CVE-2022-38653": {"epss_score": 0.00424, "epss_percentile": 0.61673}, "CVE-2022-38654": {"epss_score": 0.00052, "epss_percentile": 0.16442}, "CVE-2022-38655": {"epss_score": 0.00174, "epss_percentile": 0.39198}, "CVE-2022-38656": {"epss_score": 0.00692, "epss_percentile": 0.71298}, "CVE-2022-38657": {"epss_score": 0.00139, "epss_percentile": 0.34558}, "CVE-2022-38658": {"epss_score": 0.0016, "epss_percentile": 0.37461}, "CVE-2022-38659": {"epss_score": 0.0005, "epss_percentile": 0.15849}, "CVE-2022-38660": {"epss_score": 0.00255, "epss_percentile": 0.48647}, "CVE-2022-38661": {"epss_score": 0.0004, "epss_percentile": 0.11953}, "CVE-2022-38662": {"epss_score": 0.00194, "epss_percentile": 0.4159}, "CVE-2022-38663": {"epss_score": 0.02223, "epss_percentile": 0.84064}, "CVE-2022-38664": {"epss_score": 0.16253, "epss_percentile": 0.94603}, "CVE-2022-38665": {"epss_score": 0.00465, "epss_percentile": 0.63784}, "CVE-2022-38666": {"epss_score": 0.00071, "epss_percentile": 0.22229}, "CVE-2022-38667": {"epss_score": 0.03092, "epss_percentile": 0.86399}, "CVE-2022-38668": {"epss_score": 0.00366, "epss_percentile": 0.58017}, "CVE-2022-38669": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2022-38670": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2022-38671": {"epss_score": 0.00013, "epss_percentile": 0.01696}, "CVE-2022-38672": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-38673": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-38674": {"epss_score": 0.00038, "epss_percentile": 0.11203}, "CVE-2022-38675": {"epss_score": 0.0002, "epss_percentile": 0.04674}, "CVE-2022-38676": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-38677": {"epss_score": 0.00012, "epss_percentile": 0.01146}, "CVE-2022-38678": {"epss_score": 0.0001, "epss_percentile": 0.00841}, "CVE-2022-38679": {"epss_score": 0.00012, "epss_percentile": 0.01146}, "CVE-2022-38680": {"epss_score": 0.00032, "epss_percentile": 0.09106}, "CVE-2022-38681": {"epss_score": 0.00027, "epss_percentile": 0.06753}, "CVE-2022-38682": {"epss_score": 0.0001, "epss_percentile": 0.00841}, "CVE-2022-38683": {"epss_score": 0.0001, "epss_percentile": 0.00841}, "CVE-2022-38684": {"epss_score": 0.0001, "epss_percentile": 0.00841}, "CVE-2022-38685": {"epss_score": 0.00023, "epss_percentile": 0.05399}, "CVE-2022-38686": {"epss_score": 0.00017, "epss_percentile": 0.0342}, "CVE-2022-38687": {"epss_score": 0.00012, "epss_percentile": 0.01146}, "CVE-2022-38688": {"epss_score": 0.00066, "epss_percentile": 0.20802}, "CVE-2022-38689": {"epss_score": 0.00061, "epss_percentile": 0.19286}, "CVE-2022-38690": {"epss_score": 0.00039, "epss_percentile": 0.11654}, "CVE-2022-38691": {"epss_score": 0.00112, "epss_percentile": 0.3045}, "CVE-2022-38692": {"epss_score": 0.00091, "epss_percentile": 0.26193}, "CVE-2022-38693": {"epss_score": 0.00117, "epss_percentile": 0.31334}, "CVE-2022-38694": {"epss_score": 0.00228, "epss_percentile": 0.45467}, "CVE-2022-38695": {"epss_score": 0.00026, "epss_percentile": 0.06564}, "CVE-2022-38696": {"epss_score": 0.00117, "epss_percentile": 0.31334}, "CVE-2022-38697": {"epss_score": 0.00066, "epss_percentile": 0.20802}, "CVE-2022-38698": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2022-38699": {"epss_score": 0.00208, "epss_percentile": 0.4324}, "CVE-2022-38700": {"epss_score": 0.00103, "epss_percentile": 0.28921}, "CVE-2022-38701": {"epss_score": 0.00044, "epss_percentile": 0.13547}, "CVE-2022-38702": {"epss_score": 0.00217, "epss_percentile": 0.44311}, "CVE-2022-38703": {"epss_score": 0.00338, "epss_percentile": 0.56123}, "CVE-2022-38704": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-38705": {"epss_score": 0.00388, "epss_percentile": 0.59346}, "CVE-2022-38707": {"epss_score": 0.00022, "epss_percentile": 0.05137}, "CVE-2022-38708": {"epss_score": 0.00106, "epss_percentile": 0.295}, "CVE-2022-38709": {"epss_score": 0.00373, "epss_percentile": 0.58481}, "CVE-2022-38710": {"epss_score": 0.00153, "epss_percentile": 0.36625}, "CVE-2022-38712": {"epss_score": 0.00064, "epss_percentile": 0.20422}, "CVE-2022-38714": {"epss_score": 0.00044, "epss_percentile": 0.13375}, "CVE-2022-38715": {"epss_score": 0.08312, "epss_percentile": 0.91986}, "CVE-2022-38716": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-38723": {"epss_score": 0.00879, "epss_percentile": 0.74847}, "CVE-2022-38724": {"epss_score": 0.00322, "epss_percentile": 0.5476}, "CVE-2022-38725": {"epss_score": 0.05872, "epss_percentile": 0.9028}, "CVE-2022-38730": {"epss_score": 0.00031, "epss_percentile": 0.08437}, "CVE-2022-38731": {"epss_score": 0.00291, "epss_percentile": 0.52175}, "CVE-2022-38732": {"epss_score": 0.00277, "epss_percentile": 0.50776}, "CVE-2022-38733": {"epss_score": 0.00379, "epss_percentile": 0.58906}, "CVE-2022-38734": {"epss_score": 0.00133, "epss_percentile": 0.33715}, "CVE-2022-38742": {"epss_score": 0.3468, "epss_percentile": 0.96868}, "CVE-2022-38743": {"epss_score": 0.00101, "epss_percentile": 0.2864}, "CVE-2022-38744": {"epss_score": 0.00375, "epss_percentile": 0.58621}, "CVE-2022-38745": {"epss_score": 0.00087, "epss_percentile": 0.25611}, "CVE-2022-38749": {"epss_score": 0.00559, "epss_percentile": 0.67622}, "CVE-2022-38750": {"epss_score": 0.00088, "epss_percentile": 0.25727}, "CVE-2022-38751": {"epss_score": 0.00178, "epss_percentile": 0.39714}, "CVE-2022-38752": {"epss_score": 0.00163, "epss_percentile": 0.3776}, "CVE-2022-38753": {"epss_score": 0.00275, "epss_percentile": 0.50628}, "CVE-2022-38754": {"epss_score": 0.00368, "epss_percentile": 0.58169}, "CVE-2022-38755": {"epss_score": 0.00202, "epss_percentile": 0.42459}, "CVE-2022-38756": {"epss_score": 0.00254, "epss_percentile": 0.48509}, "CVE-2022-38757": {"epss_score": 0.00425, "epss_percentile": 0.61714}, "CVE-2022-38758": {"epss_score": 0.00369, "epss_percentile": 0.58273}, "CVE-2022-38764": {"epss_score": 0.00073, "epss_percentile": 0.22621}, "CVE-2022-38765": {"epss_score": 0.00318, "epss_percentile": 0.54397}, "CVE-2022-38766": {"epss_score": 0.01292, "epss_percentile": 0.79231}, "CVE-2022-38767": {"epss_score": 0.00177, "epss_percentile": 0.39576}, "CVE-2022-38768": {"epss_score": 0.01013, "epss_percentile": 0.76629}, "CVE-2022-38769": {"epss_score": 0.0024, "epss_percentile": 0.47206}, "CVE-2022-38770": {"epss_score": 0.00176, "epss_percentile": 0.39493}, "CVE-2022-38771": {"epss_score": 0.01155, "epss_percentile": 0.78072}, "CVE-2022-38772": {"epss_score": 0.39138, "epss_percentile": 0.97143}, "CVE-2022-38773": {"epss_score": 0.00132, "epss_percentile": 0.3355}, "CVE-2022-38774": {"epss_score": 0.0008, "epss_percentile": 0.2401}, "CVE-2022-38775": {"epss_score": 0.00141, "epss_percentile": 0.34803}, "CVE-2022-38777": {"epss_score": 0.00092, "epss_percentile": 0.26518}, "CVE-2022-38778": {"epss_score": 0.00802, "epss_percentile": 0.73588}, "CVE-2022-38779": {"epss_score": 0.00163, "epss_percentile": 0.37806}, "CVE-2022-38784": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2022-38786": {"epss_score": 0.00087, "epss_percentile": 0.25463}, "CVE-2022-38787": {"epss_score": 0.00036, "epss_percentile": 0.10491}, "CVE-2022-38788": {"epss_score": 0.00075, "epss_percentile": 0.22972}, "CVE-2022-38789": {"epss_score": 0.00508, "epss_percentile": 0.65701}, "CVE-2022-38790": {"epss_score": 0.00322, "epss_percentile": 0.5476}, "CVE-2022-38791": {"epss_score": 0.00044, "epss_percentile": 0.13628}, "CVE-2022-38792": {"epss_score": 0.00549, "epss_percentile": 0.67317}, "CVE-2022-38794": {"epss_score": 0.20998, "epss_percentile": 0.95449}, "CVE-2022-38795": {"epss_score": 0.0027, "epss_percentile": 0.50227}, "CVE-2022-38796": {"epss_score": 0.00238, "epss_percentile": 0.46756}, "CVE-2022-38801": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-38802": {"epss_score": 0.0051, "epss_percentile": 0.65796}, "CVE-2022-38803": {"epss_score": 0.00272, "epss_percentile": 0.50413}, "CVE-2022-38808": {"epss_score": 0.00226, "epss_percentile": 0.45359}, "CVE-2022-38812": {"epss_score": 0.14202, "epss_percentile": 0.94162}, "CVE-2022-38813": {"epss_score": 0.07464, "epss_percentile": 0.91487}, "CVE-2022-38814": {"epss_score": 0.00113, "epss_percentile": 0.30706}, "CVE-2022-38817": {"epss_score": 0.75533, "epss_percentile": 0.98852}, "CVE-2022-38823": {"epss_score": 0.0042, "epss_percentile": 0.61426}, "CVE-2022-38826": {"epss_score": 0.00571, "epss_percentile": 0.67978}, "CVE-2022-38827": {"epss_score": 0.00702, "epss_percentile": 0.71517}, "CVE-2022-38828": {"epss_score": 0.19148, "epss_percentile": 0.95139}, "CVE-2022-38829": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-38830": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-38831": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-38832": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38833": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38840": {"epss_score": 0.80642, "epss_percentile": 0.99098}, "CVE-2022-38841": {"epss_score": 0.02541, "epss_percentile": 0.85049}, "CVE-2022-38843": {"epss_score": 0.00497, "epss_percentile": 0.65205}, "CVE-2022-38844": {"epss_score": 0.00682, "epss_percentile": 0.71067}, "CVE-2022-38845": {"epss_score": 0.00176, "epss_percentile": 0.39462}, "CVE-2022-38846": {"epss_score": 0.00119, "epss_percentile": 0.31602}, "CVE-2022-38850": {"epss_score": 0.00033, "epss_percentile": 0.09202}, "CVE-2022-38851": {"epss_score": 0.00033, "epss_percentile": 0.09202}, "CVE-2022-38853": {"epss_score": 0.00029, "epss_percentile": 0.0775}, "CVE-2022-38855": {"epss_score": 0.00035, "epss_percentile": 0.09828}, "CVE-2022-38856": {"epss_score": 0.00029, "epss_percentile": 0.0775}, "CVE-2022-38858": {"epss_score": 0.00035, "epss_percentile": 0.09828}, "CVE-2022-38860": {"epss_score": 0.00033, "epss_percentile": 0.09202}, "CVE-2022-38861": {"epss_score": 0.00039, "epss_percentile": 0.11471}, "CVE-2022-38862": {"epss_score": 0.00041, "epss_percentile": 0.12388}, "CVE-2022-38863": {"epss_score": 0.00035, "epss_percentile": 0.09828}, "CVE-2022-38864": {"epss_score": 0.00035, "epss_percentile": 0.09828}, "CVE-2022-38865": {"epss_score": 0.00033, "epss_percentile": 0.09202}, "CVE-2022-38866": {"epss_score": 0.00054, "epss_percentile": 0.17363}, "CVE-2022-38867": {"epss_score": 0.0075, "epss_percentile": 0.72623}, "CVE-2022-38868": {"epss_score": 0.0044, "epss_percentile": 0.62648}, "CVE-2022-38870": {"epss_score": 0.86241, "epss_percentile": 0.99374}, "CVE-2022-38871": {"epss_score": 0.00266, "epss_percentile": 0.49859}, "CVE-2022-38873": {"epss_score": 0.00121, "epss_percentile": 0.31832}, "CVE-2022-38877": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-38878": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-38880": {"epss_score": 0.00408, "epss_percentile": 0.60628}, "CVE-2022-38881": {"epss_score": 0.00756, "epss_percentile": 0.72727}, "CVE-2022-38882": {"epss_score": 0.00756, "epss_percentile": 0.72727}, "CVE-2022-38883": {"epss_score": 0.0041, "epss_percentile": 0.6084}, "CVE-2022-38884": {"epss_score": 0.00756, "epss_percentile": 0.72727}, "CVE-2022-38885": {"epss_score": 0.00756, "epss_percentile": 0.72727}, "CVE-2022-38886": {"epss_score": 0.00756, "epss_percentile": 0.72727}, "CVE-2022-38887": {"epss_score": 0.00756, "epss_percentile": 0.72727}, "CVE-2022-38890": {"epss_score": 0.00042, "epss_percentile": 0.12628}, "CVE-2022-38900": {"epss_score": 0.0061, "epss_percentile": 0.69145}, "CVE-2022-38901": {"epss_score": 0.00314, "epss_percentile": 0.54125}, "CVE-2022-38902": {"epss_score": 0.0023, "epss_percentile": 0.45711}, "CVE-2022-38916": {"epss_score": 0.02476, "epss_percentile": 0.84862}, "CVE-2022-38922": {"epss_score": 0.00347, "epss_percentile": 0.56794}, "CVE-2022-38923": {"epss_score": 0.00347, "epss_percentile": 0.56794}, "CVE-2022-38928": {"epss_score": 0.00116, "epss_percentile": 0.31136}, "CVE-2022-38931": {"epss_score": 0.00671, "epss_percentile": 0.70804}, "CVE-2022-38932": {"epss_score": 0.00049, "epss_percentile": 0.15381}, "CVE-2022-38934": {"epss_score": 0.0005, "epss_percentile": 0.15835}, "CVE-2022-38935": {"epss_score": 0.00235, "epss_percentile": 0.46236}, "CVE-2022-38936": {"epss_score": 0.00266, "epss_percentile": 0.49859}, "CVE-2022-38946": {"epss_score": 0.01033, "epss_percentile": 0.76882}, "CVE-2022-38947": {"epss_score": 0.00254, "epss_percentile": 0.48556}, "CVE-2022-38955": {"epss_score": 0.00097, "epss_percentile": 0.27545}, "CVE-2022-38956": {"epss_score": 0.00155, "epss_percentile": 0.36813}, "CVE-2022-38970": {"epss_score": 0.00425, "epss_percentile": 0.61728}, "CVE-2022-38971": {"epss_score": 0.00086, "epss_percentile": 0.25324}, "CVE-2022-38972": {"epss_score": 0.01278, "epss_percentile": 0.79123}, "CVE-2022-38973": {"epss_score": 0.00036, "epss_percentile": 0.10343}, "CVE-2022-38974": {"epss_score": 0.00349, "epss_percentile": 0.56861}, "CVE-2022-38975": {"epss_score": 0.00217, "epss_percentile": 0.4427}, "CVE-2022-38977": {"epss_score": 0.00125, "epss_percentile": 0.32604}, "CVE-2022-38978": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-38979": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-38980": {"epss_score": 0.00224, "epss_percentile": 0.45036}, "CVE-2022-38981": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2022-38982": {"epss_score": 0.00191, "epss_percentile": 0.41174}, "CVE-2022-38983": {"epss_score": 0.00758, "epss_percentile": 0.72769}, "CVE-2022-38984": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-38985": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-38986": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-38987": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-38988": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-38989": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-38990": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-38991": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-38992": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-38993": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-38994": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-38995": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-38996": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-38997": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-38998": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-38999": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-39000": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-39001": {"epss_score": 0.00192, "epss_percentile": 0.41295}, "CVE-2022-39002": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-39003": {"epss_score": 0.00192, "epss_percentile": 0.4134}, "CVE-2022-39004": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-39005": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-39006": {"epss_score": 0.00148, "epss_percentile": 0.35801}, "CVE-2022-39007": {"epss_score": 0.002, "epss_percentile": 0.42243}, "CVE-2022-39008": {"epss_score": 0.00345, "epss_percentile": 0.56559}, "CVE-2022-39009": {"epss_score": 0.002, "epss_percentile": 0.42243}, "CVE-2022-39010": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-39011": {"epss_score": 0.00156, "epss_percentile": 0.37007}, "CVE-2022-39012": {"epss_score": 0.00182, "epss_percentile": 0.40181}, "CVE-2022-39013": {"epss_score": 0.00494, "epss_percentile": 0.65085}, "CVE-2022-39014": {"epss_score": 0.00246, "epss_percentile": 0.47768}, "CVE-2022-39015": {"epss_score": 0.00326, "epss_percentile": 0.55064}, "CVE-2022-39016": {"epss_score": 0.00567, "epss_percentile": 0.67844}, "CVE-2022-39017": {"epss_score": 0.00255, "epss_percentile": 0.48723}, "CVE-2022-39018": {"epss_score": 0.00379, "epss_percentile": 0.58851}, "CVE-2022-39019": {"epss_score": 0.00656, "epss_percentile": 0.70433}, "CVE-2022-39020": {"epss_score": 0.00304, "epss_percentile": 0.53266}, "CVE-2022-39021": {"epss_score": 0.00257, "epss_percentile": 0.48911}, "CVE-2022-39022": {"epss_score": 0.00258, "epss_percentile": 0.48989}, "CVE-2022-39023": {"epss_score": 0.00239, "epss_percentile": 0.46877}, "CVE-2022-39024": {"epss_score": 0.00644, "epss_percentile": 0.70092}, "CVE-2022-39025": {"epss_score": 0.00404, "epss_percentile": 0.60417}, "CVE-2022-39026": {"epss_score": 0.00154, "epss_percentile": 0.36724}, "CVE-2022-39027": {"epss_score": 0.00167, "epss_percentile": 0.38299}, "CVE-2022-39028": {"epss_score": 0.00445, "epss_percentile": 0.62883}, "CVE-2022-39029": {"epss_score": 0.00219, "epss_percentile": 0.44504}, "CVE-2022-39030": {"epss_score": 0.00849, "epss_percentile": 0.74372}, "CVE-2022-39031": {"epss_score": 0.0017, "epss_percentile": 0.38701}, "CVE-2022-39032": {"epss_score": 0.00581, "epss_percentile": 0.6827}, "CVE-2022-39033": {"epss_score": 0.01468, "epss_percentile": 0.80478}, "CVE-2022-39034": {"epss_score": 0.01078, "epss_percentile": 0.77352}, "CVE-2022-39035": {"epss_score": 0.00597, "epss_percentile": 0.68737}, "CVE-2022-39036": {"epss_score": 0.061, "epss_percentile": 0.90481}, "CVE-2022-39037": {"epss_score": 0.01045, "epss_percentile": 0.77022}, "CVE-2022-39038": {"epss_score": 0.01226, "epss_percentile": 0.78692}, "CVE-2022-39039": {"epss_score": 0.0209, "epss_percentile": 0.83566}, "CVE-2022-39040": {"epss_score": 0.00918, "epss_percentile": 0.7545}, "CVE-2022-39041": {"epss_score": 0.01195, "epss_percentile": 0.78427}, "CVE-2022-39042": {"epss_score": 0.00718, "epss_percentile": 0.71921}, "CVE-2022-39043": {"epss_score": 0.00053, "epss_percentile": 0.16716}, "CVE-2022-39044": {"epss_score": 0.00142, "epss_percentile": 0.35047}, "CVE-2022-39045": {"epss_score": 0.00794, "epss_percentile": 0.73438}, "CVE-2022-39046": {"epss_score": 0.0061, "epss_percentile": 0.69137}, "CVE-2022-39047": {"epss_score": 0.00646, "epss_percentile": 0.70134}, "CVE-2022-39048": {"epss_score": 0.20219, "epss_percentile": 0.95305}, "CVE-2022-39049": {"epss_score": 0.01079, "epss_percentile": 0.77357}, "CVE-2022-39050": {"epss_score": 0.00598, "epss_percentile": 0.68757}, "CVE-2022-39051": {"epss_score": 0.00459, "epss_percentile": 0.6347}, "CVE-2022-39052": {"epss_score": 0.00412, "epss_percentile": 0.60911}, "CVE-2022-39053": {"epss_score": 0.00595, "epss_percentile": 0.68697}, "CVE-2022-39054": {"epss_score": 0.00438, "epss_percentile": 0.62553}, "CVE-2022-39055": {"epss_score": 0.00091, "epss_percentile": 0.26249}, "CVE-2022-39056": {"epss_score": 0.00534, "epss_percentile": 0.66787}, "CVE-2022-39057": {"epss_score": 0.00439, "epss_percentile": 0.62588}, "CVE-2022-39058": {"epss_score": 0.00878, "epss_percentile": 0.7482}, "CVE-2022-39059": {"epss_score": 0.00238, "epss_percentile": 0.46774}, "CVE-2022-39060": {"epss_score": 0.00355, "epss_percentile": 0.5728}, "CVE-2022-39061": {"epss_score": 0.0021, "epss_percentile": 0.43465}, "CVE-2022-39062": {"epss_score": 0.00051, "epss_percentile": 0.16333}, "CVE-2022-39063": {"epss_score": 0.00592, "epss_percentile": 0.68616}, "CVE-2022-39064": {"epss_score": 0.0009, "epss_percentile": 0.26055}, "CVE-2022-39065": {"epss_score": 0.0009, "epss_percentile": 0.26055}, "CVE-2022-39066": {"epss_score": 0.51077, "epss_percentile": 0.97763}, "CVE-2022-39067": {"epss_score": 0.00536, "epss_percentile": 0.66883}, "CVE-2022-39068": {"epss_score": 0.00333, "epss_percentile": 0.5563}, "CVE-2022-39069": {"epss_score": 0.00427, "epss_percentile": 0.61771}, "CVE-2022-39070": {"epss_score": 0.00752, "epss_percentile": 0.72657}, "CVE-2022-39071": {"epss_score": 0.00042, "epss_percentile": 0.12886}, "CVE-2022-39072": {"epss_score": 0.00523, "epss_percentile": 0.66291}, "CVE-2022-39073": {"epss_score": 0.09854, "epss_percentile": 0.92737}, "CVE-2022-39074": {"epss_score": 0.00043, "epss_percentile": 0.1328}, "CVE-2022-39075": {"epss_score": 0.00042, "epss_percentile": 0.12886}, "CVE-2022-39080": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2022-39081": {"epss_score": 0.00057, "epss_percentile": 0.1823}, "CVE-2022-39082": {"epss_score": 0.00057, "epss_percentile": 0.1823}, "CVE-2022-39083": {"epss_score": 0.00057, "epss_percentile": 0.1823}, "CVE-2022-39084": {"epss_score": 0.00057, "epss_percentile": 0.1823}, "CVE-2022-39085": {"epss_score": 0.00057, "epss_percentile": 0.1823}, "CVE-2022-39086": {"epss_score": 0.00057, "epss_percentile": 0.1823}, "CVE-2022-39087": {"epss_score": 0.00057, "epss_percentile": 0.1823}, "CVE-2022-39088": {"epss_score": 0.00057, "epss_percentile": 0.1823}, "CVE-2022-39089": {"epss_score": 0.00014, "epss_percentile": 0.01829}, "CVE-2022-39090": {"epss_score": 0.00012, "epss_percentile": 0.01234}, "CVE-2022-39091": {"epss_score": 0.00012, "epss_percentile": 0.01234}, "CVE-2022-39092": {"epss_score": 0.00012, "epss_percentile": 0.01234}, "CVE-2022-39093": {"epss_score": 0.00012, "epss_percentile": 0.01234}, "CVE-2022-39094": {"epss_score": 0.00013, "epss_percentile": 0.01552}, "CVE-2022-39095": {"epss_score": 0.00013, "epss_percentile": 0.01552}, "CVE-2022-39096": {"epss_score": 0.00013, "epss_percentile": 0.01552}, "CVE-2022-39097": {"epss_score": 0.00015, "epss_percentile": 0.02292}, "CVE-2022-39098": {"epss_score": 0.00015, "epss_percentile": 0.02292}, "CVE-2022-39099": {"epss_score": 0.00015, "epss_percentile": 0.02292}, "CVE-2022-39100": {"epss_score": 0.00013, "epss_percentile": 0.01552}, "CVE-2022-39101": {"epss_score": 0.00013, "epss_percentile": 0.01552}, "CVE-2022-39102": {"epss_score": 0.00013, "epss_percentile": 0.01552}, "CVE-2022-39103": {"epss_score": 0.00012, "epss_percentile": 0.01146}, "CVE-2022-39104": {"epss_score": 0.0001, "epss_percentile": 0.00841}, "CVE-2022-39105": {"epss_score": 0.00018, "epss_percentile": 0.03838}, "CVE-2022-39106": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-39107": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2022-39108": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2022-39109": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2022-39110": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2022-39111": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2022-39112": {"epss_score": 0.00012, "epss_percentile": 0.01146}, "CVE-2022-39113": {"epss_score": 0.00012, "epss_percentile": 0.01146}, "CVE-2022-39114": {"epss_score": 0.00012, "epss_percentile": 0.01146}, "CVE-2022-39115": {"epss_score": 0.00012, "epss_percentile": 0.01146}, "CVE-2022-39116": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-39117": {"epss_score": 0.00014, "epss_percentile": 0.02081}, "CVE-2022-39118": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-39119": {"epss_score": 0.00014, "epss_percentile": 0.01954}, "CVE-2022-39120": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-39121": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-39122": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-39123": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-39124": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-39125": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-39126": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-39127": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-39128": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-39129": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-39130": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-39131": {"epss_score": 0.00011, "epss_percentile": 0.00926}, "CVE-2022-39132": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-39133": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-39134": {"epss_score": 0.00012, "epss_percentile": 0.01334}, "CVE-2022-39135": {"epss_score": 0.00122, "epss_percentile": 0.32094}, "CVE-2022-39136": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39137": {"epss_score": 0.00056, "epss_percentile": 0.17789}, "CVE-2022-39138": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39139": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39140": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39141": {"epss_score": 0.00056, "epss_percentile": 0.17789}, "CVE-2022-39142": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39143": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39144": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39145": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39146": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39147": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39148": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39149": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39150": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39151": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39152": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39153": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39154": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39155": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39156": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-39157": {"epss_score": 0.00116, "epss_percentile": 0.31141}, "CVE-2022-39158": {"epss_score": 0.00859, "epss_percentile": 0.74514}, "CVE-2022-39160": {"epss_score": 0.00345, "epss_percentile": 0.56579}, "CVE-2022-39161": {"epss_score": 0.00037, "epss_percentile": 0.10663}, "CVE-2022-39163": {"epss_score": 0.00042, "epss_percentile": 0.12887}, "CVE-2022-39164": {"epss_score": 0.00135, "epss_percentile": 0.33986}, "CVE-2022-39165": {"epss_score": 0.00112, "epss_percentile": 0.3055}, "CVE-2022-39166": {"epss_score": 0.0009, "epss_percentile": 0.26009}, "CVE-2022-39167": {"epss_score": 0.0007, "epss_percentile": 0.21816}, "CVE-2022-39168": {"epss_score": 0.00205, "epss_percentile": 0.42711}, "CVE-2022-39170": {"epss_score": 0.00479, "epss_percentile": 0.64433}, "CVE-2022-39172": {"epss_score": 0.00074, "epss_percentile": 0.2284}, "CVE-2022-39173": {"epss_score": 0.00953, "epss_percentile": 0.75892}, "CVE-2022-39176": {"epss_score": 0.00092, "epss_percentile": 0.26485}, "CVE-2022-39177": {"epss_score": 0.00058, "epss_percentile": 0.18548}, "CVE-2022-39178": {"epss_score": 0.00147, "epss_percentile": 0.35677}, "CVE-2022-39179": {"epss_score": 0.01384, "epss_percentile": 0.799}, "CVE-2022-39180": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-39181": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-39182": {"epss_score": 0.00063, "epss_percentile": 0.19813}, "CVE-2022-39183": {"epss_score": 0.00104, "epss_percentile": 0.29196}, "CVE-2022-39184": {"epss_score": 0.00052, "epss_percentile": 0.16345}, "CVE-2022-39185": {"epss_score": 0.00127, "epss_percentile": 0.32931}, "CVE-2022-39186": {"epss_score": 0.00034, "epss_percentile": 0.09528}, "CVE-2022-39187": {"epss_score": 0.00075, "epss_percentile": 0.22901}, "CVE-2022-39188": {"epss_score": 0.00028, "epss_percentile": 0.0724}, "CVE-2022-39189": {"epss_score": 0.00019, "epss_percentile": 0.04087}, "CVE-2022-39190": {"epss_score": 0.00055, "epss_percentile": 0.17538}, "CVE-2022-39193": {"epss_score": 0.00104, "epss_percentile": 0.29232}, "CVE-2022-39194": {"epss_score": 0.00309, "epss_percentile": 0.5366}, "CVE-2022-39195": {"epss_score": 0.29329, "epss_percentile": 0.96433}, "CVE-2022-39196": {"epss_score": 0.00431, "epss_percentile": 0.62066}, "CVE-2022-39197": {"epss_score": 0.144, "epss_percentile": 0.94204}, "CVE-2022-39198": {"epss_score": 0.20182, "epss_percentile": 0.95301}, "CVE-2022-39199": {"epss_score": 0.00172, "epss_percentile": 0.39035}, "CVE-2022-39200": {"epss_score": 0.00158, "epss_percentile": 0.37169}, "CVE-2022-39201": {"epss_score": 0.00851, "epss_percentile": 0.74408}, "CVE-2022-39202": {"epss_score": 0.00268, "epss_percentile": 0.50072}, "CVE-2022-39203": {"epss_score": 0.0031, "epss_percentile": 0.53801}, "CVE-2022-39205": {"epss_score": 0.03215, "epss_percentile": 0.86661}, "CVE-2022-39206": {"epss_score": 0.01413, "epss_percentile": 0.8012}, "CVE-2022-39207": {"epss_score": 0.00472, "epss_percentile": 0.64073}, "CVE-2022-39208": {"epss_score": 0.00779, "epss_percentile": 0.73158}, "CVE-2022-39209": {"epss_score": 0.00997, "epss_percentile": 0.76457}, "CVE-2022-39210": {"epss_score": 0.0007, "epss_percentile": 0.21871}, "CVE-2022-39211": {"epss_score": 0.00152, "epss_percentile": 0.36379}, "CVE-2022-39212": {"epss_score": 0.00154, "epss_percentile": 0.36717}, "CVE-2022-39213": {"epss_score": 0.00479, "epss_percentile": 0.64421}, "CVE-2022-39214": {"epss_score": 0.02508, "epss_percentile": 0.84942}, "CVE-2022-39215": {"epss_score": 0.00693, "epss_percentile": 0.71336}, "CVE-2022-39216": {"epss_score": 0.00307, "epss_percentile": 0.53517}, "CVE-2022-39217": {"epss_score": 0.00401, "epss_percentile": 0.60249}, "CVE-2022-39218": {"epss_score": 0.003, "epss_percentile": 0.52917}, "CVE-2022-39219": {"epss_score": 0.00211, "epss_percentile": 0.43686}, "CVE-2022-39220": {"epss_score": 0.00176, "epss_percentile": 0.39462}, "CVE-2022-39221": {"epss_score": 0.00414, "epss_percentile": 0.61028}, "CVE-2022-39222": {"epss_score": 0.01123, "epss_percentile": 0.77792}, "CVE-2022-39224": {"epss_score": 0.00266, "epss_percentile": 0.49943}, "CVE-2022-39225": {"epss_score": 0.0021, "epss_percentile": 0.43465}, "CVE-2022-39226": {"epss_score": 0.00501, "epss_percentile": 0.65365}, "CVE-2022-39227": {"epss_score": 0.68955, "epss_percentile": 0.9857}, "CVE-2022-39228": {"epss_score": 0.00138, "epss_percentile": 0.34427}, "CVE-2022-39229": {"epss_score": 0.00068, "epss_percentile": 0.21311}, "CVE-2022-39230": {"epss_score": 0.00272, "epss_percentile": 0.50377}, "CVE-2022-39231": {"epss_score": 0.00186, "epss_percentile": 0.40616}, "CVE-2022-39232": {"epss_score": 0.00573, "epss_percentile": 0.68044}, "CVE-2022-39233": {"epss_score": 0.00225, "epss_percentile": 0.45145}, "CVE-2022-39234": {"epss_score": 0.00173, "epss_percentile": 0.39067}, "CVE-2022-39236": {"epss_score": 0.00459, "epss_percentile": 0.63479}, "CVE-2022-39237": {"epss_score": 0.00068, "epss_percentile": 0.21332}, "CVE-2022-39238": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2022-39239": {"epss_score": 0.0017, "epss_percentile": 0.38707}, "CVE-2022-39240": {"epss_score": 0.00337, "epss_percentile": 0.56011}, "CVE-2022-39241": {"epss_score": 0.00293, "epss_percentile": 0.52294}, "CVE-2022-39242": {"epss_score": 0.00289, "epss_percentile": 0.5202}, "CVE-2022-39243": {"epss_score": 0.00696, "epss_percentile": 0.71384}, "CVE-2022-39244": {"epss_score": 0.00225, "epss_percentile": 0.45223}, "CVE-2022-39245": {"epss_score": 0.00044, "epss_percentile": 0.13672}, "CVE-2022-39246": {"epss_score": 0.00304, "epss_percentile": 0.5331}, "CVE-2022-39248": {"epss_score": 0.00272, "epss_percentile": 0.5036}, "CVE-2022-39249": {"epss_score": 0.00478, "epss_percentile": 0.64401}, "CVE-2022-39250": {"epss_score": 0.00338, "epss_percentile": 0.56118}, "CVE-2022-39251": {"epss_score": 0.00364, "epss_percentile": 0.57934}, "CVE-2022-39252": {"epss_score": 0.00227, "epss_percentile": 0.45361}, "CVE-2022-39253": {"epss_score": 0.02794, "epss_percentile": 0.85675}, "CVE-2022-39254": {"epss_score": 0.00233, "epss_percentile": 0.45984}, "CVE-2022-39255": {"epss_score": 0.00249, "epss_percentile": 0.48006}, "CVE-2022-39256": {"epss_score": 0.02068, "epss_percentile": 0.83463}, "CVE-2022-39257": {"epss_score": 0.00249, "epss_percentile": 0.48006}, "CVE-2022-39258": {"epss_score": 0.00258, "epss_percentile": 0.48991}, "CVE-2022-39259": {"epss_score": 0.00055, "epss_percentile": 0.17571}, "CVE-2022-39260": {"epss_score": 0.01095, "epss_percentile": 0.77508}, "CVE-2022-39261": {"epss_score": 0.01568, "epss_percentile": 0.81078}, "CVE-2022-39262": {"epss_score": 0.00315, "epss_percentile": 0.54192}, "CVE-2022-39263": {"epss_score": 0.00257, "epss_percentile": 0.48879}, "CVE-2022-39264": {"epss_score": 0.00363, "epss_percentile": 0.57896}, "CVE-2022-39265": {"epss_score": 0.04712, "epss_percentile": 0.89039}, "CVE-2022-39266": {"epss_score": 0.00258, "epss_percentile": 0.48967}, "CVE-2022-39267": {"epss_score": 0.00364, "epss_percentile": 0.57954}, "CVE-2022-39268": {"epss_score": 0.00187, "epss_percentile": 0.40761}, "CVE-2022-39269": {"epss_score": 0.0008, "epss_percentile": 0.24178}, "CVE-2022-39270": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-39271": {"epss_score": 0.0012, "epss_percentile": 0.31767}, "CVE-2022-39272": {"epss_score": 0.00311, "epss_percentile": 0.53822}, "CVE-2022-39273": {"epss_score": 0.00268, "epss_percentile": 0.5008}, "CVE-2022-39274": {"epss_score": 0.02287, "epss_percentile": 0.8427}, "CVE-2022-39275": {"epss_score": 0.00231, "epss_percentile": 0.45843}, "CVE-2022-39276": {"epss_score": 0.00175, "epss_percentile": 0.39326}, "CVE-2022-39277": {"epss_score": 0.00293, "epss_percentile": 0.52343}, "CVE-2022-39278": {"epss_score": 0.00122, "epss_percentile": 0.32038}, "CVE-2022-39279": {"epss_score": 0.00208, "epss_percentile": 0.43223}, "CVE-2022-39280": {"epss_score": 0.00802, "epss_percentile": 0.7358}, "CVE-2022-39281": {"epss_score": 0.00545, "epss_percentile": 0.67164}, "CVE-2022-39282": {"epss_score": 0.00156, "epss_percentile": 0.36992}, "CVE-2022-39283": {"epss_score": 0.0017, "epss_percentile": 0.38671}, "CVE-2022-39284": {"epss_score": 0.00467, "epss_percentile": 0.6382}, "CVE-2022-39285": {"epss_score": 0.0235, "epss_percentile": 0.84468}, "CVE-2022-39286": {"epss_score": 0.00356, "epss_percentile": 0.57349}, "CVE-2022-39287": {"epss_score": 0.00148, "epss_percentile": 0.35861}, "CVE-2022-39288": {"epss_score": 0.05989, "epss_percentile": 0.90384}, "CVE-2022-39289": {"epss_score": 0.00353, "epss_percentile": 0.57166}, "CVE-2022-39290": {"epss_score": 0.01452, "epss_percentile": 0.80368}, "CVE-2022-39291": {"epss_score": 0.02195, "epss_percentile": 0.83953}, "CVE-2022-39292": {"epss_score": 0.00374, "epss_percentile": 0.58531}, "CVE-2022-39293": {"epss_score": 0.00415, "epss_percentile": 0.61147}, "CVE-2022-39294": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-39295": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-39296": {"epss_score": 0.00442, "epss_percentile": 0.62737}, "CVE-2022-39297": {"epss_score": 0.00888, "epss_percentile": 0.74994}, "CVE-2022-39298": {"epss_score": 0.00888, "epss_percentile": 0.74994}, "CVE-2022-39299": {"epss_score": 0.11156, "epss_percentile": 0.93248}, "CVE-2022-39300": {"epss_score": 0.00153, "epss_percentile": 0.36636}, "CVE-2022-39301": {"epss_score": 0.00276, "epss_percentile": 0.5074}, "CVE-2022-39302": {"epss_score": 0.00116, "epss_percentile": 0.31042}, "CVE-2022-39303": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-39304": {"epss_score": 0.00027, "epss_percentile": 0.06942}, "CVE-2022-39305": {"epss_score": 0.00433, "epss_percentile": 0.62221}, "CVE-2022-39306": {"epss_score": 0.00366, "epss_percentile": 0.58057}, "CVE-2022-39307": {"epss_score": 0.00193, "epss_percentile": 0.41441}, "CVE-2022-39308": {"epss_score": 0.00406, "epss_percentile": 0.60536}, "CVE-2022-39309": {"epss_score": 0.00355, "epss_percentile": 0.57289}, "CVE-2022-39310": {"epss_score": 0.00305, "epss_percentile": 0.53394}, "CVE-2022-39311": {"epss_score": 0.09474, "epss_percentile": 0.92563}, "CVE-2022-39312": {"epss_score": 0.00583, "epss_percentile": 0.68349}, "CVE-2022-39313": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-39314": {"epss_score": 0.00194, "epss_percentile": 0.41557}, "CVE-2022-39315": {"epss_score": 0.00439, "epss_percentile": 0.62609}, "CVE-2022-39316": {"epss_score": 0.00139, "epss_percentile": 0.3456}, "CVE-2022-39317": {"epss_score": 0.00073, "epss_percentile": 0.22491}, "CVE-2022-39318": {"epss_score": 0.00139, "epss_percentile": 0.3456}, "CVE-2022-39319": {"epss_score": 0.00099, "epss_percentile": 0.2843}, "CVE-2022-39320": {"epss_score": 0.00064, "epss_percentile": 0.20185}, "CVE-2022-39321": {"epss_score": 0.01536, "epss_percentile": 0.80917}, "CVE-2022-39322": {"epss_score": 0.00925, "epss_percentile": 0.75533}, "CVE-2022-39323": {"epss_score": 0.01203, "epss_percentile": 0.78498}, "CVE-2022-39324": {"epss_score": 0.0009, "epss_percentile": 0.26128}, "CVE-2022-39325": {"epss_score": 0.00687, "epss_percentile": 0.71189}, "CVE-2022-39326": {"epss_score": 0.01075, "epss_percentile": 0.77313}, "CVE-2022-39327": {"epss_score": 0.01311, "epss_percentile": 0.7937}, "CVE-2022-39328": {"epss_score": 0.03426, "epss_percentile": 0.87116}, "CVE-2022-39329": {"epss_score": 0.00172, "epss_percentile": 0.39}, "CVE-2022-39330": {"epss_score": 0.0029, "epss_percentile": 0.5212}, "CVE-2022-39331": {"epss_score": 0.00544, "epss_percentile": 0.67146}, "CVE-2022-39332": {"epss_score": 0.00337, "epss_percentile": 0.56049}, "CVE-2022-39333": {"epss_score": 0.00337, "epss_percentile": 0.56049}, "CVE-2022-39334": {"epss_score": 0.00042, "epss_percentile": 0.1275}, "CVE-2022-39335": {"epss_score": 0.00145, "epss_percentile": 0.35354}, "CVE-2022-39337": {"epss_score": 0.00225, "epss_percentile": 0.45237}, "CVE-2022-39338": {"epss_score": 0.00421, "epss_percentile": 0.61487}, "CVE-2022-39339": {"epss_score": 0.00248, "epss_percentile": 0.4798}, "CVE-2022-39340": {"epss_score": 0.0025, "epss_percentile": 0.48092}, "CVE-2022-39341": {"epss_score": 0.00334, "epss_percentile": 0.55725}, "CVE-2022-39342": {"epss_score": 0.00334, "epss_percentile": 0.55725}, "CVE-2022-39343": {"epss_score": 0.011, "epss_percentile": 0.7757}, "CVE-2022-39344": {"epss_score": 0.01351, "epss_percentile": 0.79682}, "CVE-2022-39345": {"epss_score": 0.00739, "epss_percentile": 0.72356}, "CVE-2022-39346": {"epss_score": 0.00297, "epss_percentile": 0.52744}, "CVE-2022-39347": {"epss_score": 0.00144, "epss_percentile": 0.35328}, "CVE-2022-39348": {"epss_score": 0.01178, "epss_percentile": 0.78281}, "CVE-2022-39349": {"epss_score": 0.00018, "epss_percentile": 0.04045}, "CVE-2022-39350": {"epss_score": 0.00267, "epss_percentile": 0.50005}, "CVE-2022-39351": {"epss_score": 0.00032, "epss_percentile": 0.09061}, "CVE-2022-39352": {"epss_score": 0.00261, "epss_percentile": 0.49282}, "CVE-2022-39353": {"epss_score": 0.0127, "epss_percentile": 0.79049}, "CVE-2022-39354": {"epss_score": 0.00356, "epss_percentile": 0.57389}, "CVE-2022-39355": {"epss_score": 0.00355, "epss_percentile": 0.57286}, "CVE-2022-39356": {"epss_score": 0.00296, "epss_percentile": 0.526}, "CVE-2022-39357": {"epss_score": 0.0103, "epss_percentile": 0.76848}, "CVE-2022-39358": {"epss_score": 0.00211, "epss_percentile": 0.43627}, "CVE-2022-39359": {"epss_score": 0.00206, "epss_percentile": 0.43002}, "CVE-2022-39360": {"epss_score": 0.00159, "epss_percentile": 0.37359}, "CVE-2022-39361": {"epss_score": 0.01607, "epss_percentile": 0.81306}, "CVE-2022-39362": {"epss_score": 0.004, "epss_percentile": 0.60178}, "CVE-2022-39364": {"epss_score": 0.00232, "epss_percentile": 0.45886}, "CVE-2022-39365": {"epss_score": 0.00205, "epss_percentile": 0.42715}, "CVE-2022-39366": {"epss_score": 0.00037, "epss_percentile": 0.10985}, "CVE-2022-39367": {"epss_score": 0.00409, "epss_percentile": 0.60754}, "CVE-2022-39368": {"epss_score": 0.00116, "epss_percentile": 0.31168}, "CVE-2022-39369": {"epss_score": 0.00795, "epss_percentile": 0.73477}, "CVE-2022-39370": {"epss_score": 0.00154, "epss_percentile": 0.367}, "CVE-2022-39371": {"epss_score": 0.00261, "epss_percentile": 0.493}, "CVE-2022-39372": {"epss_score": 0.00288, "epss_percentile": 0.51927}, "CVE-2022-39373": {"epss_score": 0.00299, "epss_percentile": 0.5284}, "CVE-2022-39374": {"epss_score": 0.0016, "epss_percentile": 0.37443}, "CVE-2022-39375": {"epss_score": 0.00291, "epss_percentile": 0.52195}, "CVE-2022-39376": {"epss_score": 0.00216, "epss_percentile": 0.44208}, "CVE-2022-39377": {"epss_score": 0.01294, "epss_percentile": 0.79241}, "CVE-2022-39378": {"epss_score": 0.00274, "epss_percentile": 0.50556}, "CVE-2022-39379": {"epss_score": 0.04579, "epss_percentile": 0.88872}, "CVE-2022-39380": {"epss_score": 0.00063, "epss_percentile": 0.19978}, "CVE-2022-39381": {"epss_score": 0.00237, "epss_percentile": 0.46663}, "CVE-2022-39382": {"epss_score": 0.0202, "epss_percentile": 0.83292}, "CVE-2022-39383": {"epss_score": 0.00196, "epss_percentile": 0.41811}, "CVE-2022-39384": {"epss_score": 0.00556, "epss_percentile": 0.67531}, "CVE-2022-39385": {"epss_score": 0.00244, "epss_percentile": 0.47573}, "CVE-2022-39386": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-39387": {"epss_score": 0.00135, "epss_percentile": 0.33971}, "CVE-2022-39388": {"epss_score": 0.00057, "epss_percentile": 0.18217}, "CVE-2022-39389": {"epss_score": 0.00688, "epss_percentile": 0.71212}, "CVE-2022-39392": {"epss_score": 0.0024, "epss_percentile": 0.46964}, "CVE-2022-39393": {"epss_score": 0.00272, "epss_percentile": 0.50367}, "CVE-2022-39394": {"epss_score": 0.00112, "epss_percentile": 0.3048}, "CVE-2022-39395": {"epss_score": 0.0317, "epss_percentile": 0.86547}, "CVE-2022-39396": {"epss_score": 0.10994, "epss_percentile": 0.93185}, "CVE-2022-39397": {"epss_score": 0.00314, "epss_percentile": 0.54089}, "CVE-2022-39398": {"epss_score": 0.00304, "epss_percentile": 0.53266}, "CVE-2022-39399": {"epss_score": 0.00252, "epss_percentile": 0.48383}, "CVE-2022-39400": {"epss_score": 0.00063, "epss_percentile": 0.19846}, "CVE-2022-39401": {"epss_score": 0.00045, "epss_percentile": 0.14042}, "CVE-2022-39402": {"epss_score": 0.00254, "epss_percentile": 0.48507}, "CVE-2022-39403": {"epss_score": 0.00191, "epss_percentile": 0.41171}, "CVE-2022-39404": {"epss_score": 0.00134, "epss_percentile": 0.33896}, "CVE-2022-39405": {"epss_score": 0.00799, "epss_percentile": 0.73531}, "CVE-2022-39406": {"epss_score": 0.0084, "epss_percentile": 0.74212}, "CVE-2022-39407": {"epss_score": 0.00086, "epss_percentile": 0.25344}, "CVE-2022-39408": {"epss_score": 0.00145, "epss_percentile": 0.35373}, "CVE-2022-39409": {"epss_score": 0.00263, "epss_percentile": 0.49409}, "CVE-2022-39410": {"epss_score": 0.00111, "epss_percentile": 0.30255}, "CVE-2022-39411": {"epss_score": 0.00586, "epss_percentile": 0.68451}, "CVE-2022-39412": {"epss_score": 0.03793, "epss_percentile": 0.87733}, "CVE-2022-39417": {"epss_score": 0.00051, "epss_percentile": 0.16143}, "CVE-2022-39419": {"epss_score": 0.00209, "epss_percentile": 0.43332}, "CVE-2022-39420": {"epss_score": 0.00191, "epss_percentile": 0.41258}, "CVE-2022-39421": {"epss_score": 0.00303, "epss_percentile": 0.53206}, "CVE-2022-39422": {"epss_score": 0.00074, "epss_percentile": 0.22804}, "CVE-2022-39423": {"epss_score": 0.00067, "epss_percentile": 0.20975}, "CVE-2022-39424": {"epss_score": 0.04097, "epss_percentile": 0.88253}, "CVE-2022-39425": {"epss_score": 0.06269, "epss_percentile": 0.90627}, "CVE-2022-39426": {"epss_score": 0.01818, "epss_percentile": 0.82402}, "CVE-2022-39427": {"epss_score": 0.00277, "epss_percentile": 0.50833}, "CVE-2022-39428": {"epss_score": 0.2224, "epss_percentile": 0.95613}, "CVE-2022-39429": {"epss_score": 0.00122, "epss_percentile": 0.32086}, "CVE-2022-39799": {"epss_score": 0.00463, "epss_percentile": 0.63676}, "CVE-2022-39800": {"epss_score": 0.01795, "epss_percentile": 0.82295}, "CVE-2022-39801": {"epss_score": 0.00403, "epss_percentile": 0.60377}, "CVE-2022-39802": {"epss_score": 0.03739, "epss_percentile": 0.87654}, "CVE-2022-39803": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-39804": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-39805": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-39806": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-39807": {"epss_score": 0.00046, "epss_percentile": 0.14333}, "CVE-2022-39808": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-39809": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-39810": {"epss_score": 0.02096, "epss_percentile": 0.83589}, "CVE-2022-39811": {"epss_score": 0.00031, "epss_percentile": 0.08552}, "CVE-2022-39812": {"epss_score": 0.00368, "epss_percentile": 0.58214}, "CVE-2022-39813": {"epss_score": 0.00176, "epss_percentile": 0.39401}, "CVE-2022-39814": {"epss_score": 0.00195, "epss_percentile": 0.41653}, "CVE-2022-39815": {"epss_score": 0.13489, "epss_percentile": 0.93979}, "CVE-2022-39816": {"epss_score": 0.00223, "epss_percentile": 0.44963}, "CVE-2022-39817": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2022-39818": {"epss_score": 0.01745, "epss_percentile": 0.82065}, "CVE-2022-39819": {"epss_score": 0.04039, "epss_percentile": 0.88164}, "CVE-2022-39820": {"epss_score": 0.0007, "epss_percentile": 0.21713}, "CVE-2022-39821": {"epss_score": 0.003, "epss_percentile": 0.52917}, "CVE-2022-39822": {"epss_score": 0.00096, "epss_percentile": 0.27446}, "CVE-2022-39823": {"epss_score": 0.00505, "epss_percentile": 0.65589}, "CVE-2022-39824": {"epss_score": 0.007, "epss_percentile": 0.71472}, "CVE-2022-39828": {"epss_score": 0.00417, "epss_percentile": 0.61226}, "CVE-2022-39829": {"epss_score": 0.00418, "epss_percentile": 0.61289}, "CVE-2022-39830": {"epss_score": 0.00417, "epss_percentile": 0.61226}, "CVE-2022-39831": {"epss_score": 0.00067, "epss_percentile": 0.21141}, "CVE-2022-39832": {"epss_score": 0.00067, "epss_percentile": 0.21141}, "CVE-2022-39833": {"epss_score": 0.09547, "epss_percentile": 0.92593}, "CVE-2022-39834": {"epss_score": 0.00548, "epss_percentile": 0.67283}, "CVE-2022-39835": {"epss_score": 0.00192, "epss_percentile": 0.41281}, "CVE-2022-39836": {"epss_score": 0.00114, "epss_percentile": 0.30758}, "CVE-2022-39837": {"epss_score": 0.00113, "epss_percentile": 0.30613}, "CVE-2022-39838": {"epss_score": 0.00795, "epss_percentile": 0.73464}, "CVE-2022-39839": {"epss_score": 0.00281, "epss_percentile": 0.51144}, "CVE-2022-39840": {"epss_score": 0.00226, "epss_percentile": 0.45333}, "CVE-2022-39842": {"epss_score": 7e-05, "epss_percentile": 0.00416}, "CVE-2022-39843": {"epss_score": 0.00126, "epss_percentile": 0.32689}, "CVE-2022-39844": {"epss_score": 0.00028, "epss_percentile": 0.07318}, "CVE-2022-39845": {"epss_score": 0.00028, "epss_percentile": 0.07318}, "CVE-2022-39846": {"epss_score": 0.0006, "epss_percentile": 0.19143}, "CVE-2022-39847": {"epss_score": 0.0002, "epss_percentile": 0.04543}, "CVE-2022-39848": {"epss_score": 0.00017, "epss_percentile": 0.03112}, "CVE-2022-39849": {"epss_score": 0.00016, "epss_percentile": 0.02947}, "CVE-2022-39850": {"epss_score": 0.00016, "epss_percentile": 0.02947}, "CVE-2022-39851": {"epss_score": 0.00016, "epss_percentile": 0.02611}, "CVE-2022-39852": {"epss_score": 0.00018, "epss_percentile": 0.03759}, "CVE-2022-39853": {"epss_score": 0.0002, "epss_percentile": 0.04668}, "CVE-2022-39854": {"epss_score": 0.00016, "epss_percentile": 0.02762}, "CVE-2022-39855": {"epss_score": 0.00018, "epss_percentile": 0.03637}, "CVE-2022-39856": {"epss_score": 0.00017, "epss_percentile": 0.03112}, "CVE-2022-39857": {"epss_score": 0.00057, "epss_percentile": 0.18157}, "CVE-2022-39858": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2022-39859": {"epss_score": 0.00069, "epss_percentile": 0.21522}, "CVE-2022-39860": {"epss_score": 0.00068, "epss_percentile": 0.21312}, "CVE-2022-39861": {"epss_score": 0.00058, "epss_percentile": 0.18583}, "CVE-2022-39862": {"epss_score": 0.00269, "epss_percentile": 0.50171}, "CVE-2022-39863": {"epss_score": 0.00228, "epss_percentile": 0.45474}, "CVE-2022-39864": {"epss_score": 0.00175, "epss_percentile": 0.39273}, "CVE-2022-39865": {"epss_score": 0.00175, "epss_percentile": 0.39273}, "CVE-2022-39866": {"epss_score": 0.00175, "epss_percentile": 0.39273}, "CVE-2022-39867": {"epss_score": 0.00175, "epss_percentile": 0.39273}, "CVE-2022-39868": {"epss_score": 0.00175, "epss_percentile": 0.39273}, "CVE-2022-39869": {"epss_score": 0.00175, "epss_percentile": 0.39273}, "CVE-2022-39870": {"epss_score": 0.00175, "epss_percentile": 0.39273}, "CVE-2022-39871": {"epss_score": 0.00175, "epss_percentile": 0.39273}, "CVE-2022-39872": {"epss_score": 0.00062, "epss_percentile": 0.19622}, "CVE-2022-39873": {"epss_score": 0.00078, "epss_percentile": 0.23676}, "CVE-2022-39874": {"epss_score": 0.00061, "epss_percentile": 0.19331}, "CVE-2022-39875": {"epss_score": 0.00059, "epss_percentile": 0.1871}, "CVE-2022-39876": {"epss_score": 0.00069, "epss_percentile": 0.21522}, "CVE-2022-39877": {"epss_score": 0.00184, "epss_percentile": 0.40449}, "CVE-2022-39878": {"epss_score": 0.00054, "epss_percentile": 0.17352}, "CVE-2022-39879": {"epss_score": 0.00016, "epss_percentile": 0.0286}, "CVE-2022-39880": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-39881": {"epss_score": 0.00581, "epss_percentile": 0.68283}, "CVE-2022-39882": {"epss_score": 0.00017, "epss_percentile": 0.03247}, "CVE-2022-39883": {"epss_score": 0.00015, "epss_percentile": 0.02429}, "CVE-2022-39884": {"epss_score": 0.00016, "epss_percentile": 0.02894}, "CVE-2022-39885": {"epss_score": 0.00017, "epss_percentile": 0.03257}, "CVE-2022-39886": {"epss_score": 0.00017, "epss_percentile": 0.03257}, "CVE-2022-39887": {"epss_score": 0.00017, "epss_percentile": 0.03214}, "CVE-2022-39888": {"epss_score": 0.00022, "epss_percentile": 0.05062}, "CVE-2022-39889": {"epss_score": 0.00062, "epss_percentile": 0.19622}, "CVE-2022-39890": {"epss_score": 0.00183, "epss_percentile": 0.40339}, "CVE-2022-39891": {"epss_score": 0.0022, "epss_percentile": 0.44604}, "CVE-2022-39892": {"epss_score": 0.00184, "epss_percentile": 0.40423}, "CVE-2022-39893": {"epss_score": 0.00061, "epss_percentile": 0.195}, "CVE-2022-39894": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-39895": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-39896": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-39897": {"epss_score": 0.00016, "epss_percentile": 0.02836}, "CVE-2022-39898": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2022-39899": {"epss_score": 0.0002, "epss_percentile": 0.04685}, "CVE-2022-39900": {"epss_score": 0.00037, "epss_percentile": 0.10929}, "CVE-2022-39901": {"epss_score": 0.0021, "epss_percentile": 0.43445}, "CVE-2022-39902": {"epss_score": 0.00246, "epss_percentile": 0.47785}, "CVE-2022-39903": {"epss_score": 0.00016, "epss_percentile": 0.02894}, "CVE-2022-39904": {"epss_score": 0.00037, "epss_percentile": 0.10641}, "CVE-2022-39905": {"epss_score": 0.00019, "epss_percentile": 0.04273}, "CVE-2022-39906": {"epss_score": 0.00017, "epss_percentile": 0.03243}, "CVE-2022-39907": {"epss_score": 0.00044, "epss_percentile": 0.13639}, "CVE-2022-39908": {"epss_score": 0.00033, "epss_percentile": 0.09312}, "CVE-2022-39909": {"epss_score": 0.00038, "epss_percentile": 0.11142}, "CVE-2022-39910": {"epss_score": 0.00093, "epss_percentile": 0.26677}, "CVE-2022-39911": {"epss_score": 0.00097, "epss_percentile": 0.2757}, "CVE-2022-39912": {"epss_score": 0.00012, "epss_percentile": 0.01426}, "CVE-2022-39913": {"epss_score": 0.00017, "epss_percentile": 0.03257}, "CVE-2022-39914": {"epss_score": 0.00016, "epss_percentile": 0.02894}, "CVE-2022-39915": {"epss_score": 0.00101, "epss_percentile": 0.28679}, "CVE-2022-39944": {"epss_score": 0.02419, "epss_percentile": 0.84699}, "CVE-2022-39945": {"epss_score": 0.00187, "epss_percentile": 0.408}, "CVE-2022-39946": {"epss_score": 0.00151, "epss_percentile": 0.36365}, "CVE-2022-39947": {"epss_score": 0.02052, "epss_percentile": 0.83413}, "CVE-2022-39948": {"epss_score": 0.00157, "epss_percentile": 0.37052}, "CVE-2022-39949": {"epss_score": 0.00047, "epss_percentile": 0.14703}, "CVE-2022-39950": {"epss_score": 0.00731, "epss_percentile": 0.7217}, "CVE-2022-39951": {"epss_score": 0.00402, "epss_percentile": 0.60317}, "CVE-2022-39952": {"epss_score": 0.93777, "epss_percentile": 0.99844}, "CVE-2022-39953": {"epss_score": 0.00058, "epss_percentile": 0.18545}, "CVE-2022-39954": {"epss_score": 0.00056, "epss_percentile": 0.17687}, "CVE-2022-39955": {"epss_score": 0.00151, "epss_percentile": 0.36259}, "CVE-2022-39956": {"epss_score": 0.00092, "epss_percentile": 0.26521}, "CVE-2022-39957": {"epss_score": 0.00066, "epss_percentile": 0.2094}, "CVE-2022-39958": {"epss_score": 0.00161, "epss_percentile": 0.37569}, "CVE-2022-39959": {"epss_score": 0.00575, "epss_percentile": 0.68107}, "CVE-2022-39960": {"epss_score": 0.7815, "epss_percentile": 0.9897}, "CVE-2022-39974": {"epss_score": 0.00287, "epss_percentile": 0.51827}, "CVE-2022-39975": {"epss_score": 0.00157, "epss_percentile": 0.37138}, "CVE-2022-39976": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-39977": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-39978": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-39983": {"epss_score": 0.00381, "epss_percentile": 0.58982}, "CVE-2022-39986": {"epss_score": 0.93057, "epss_percentile": 0.99771}, "CVE-2022-39987": {"epss_score": 0.7635, "epss_percentile": 0.98887}, "CVE-2022-39988": {"epss_score": 0.00175, "epss_percentile": 0.39265}, "CVE-2022-39989": {"epss_score": 0.00077, "epss_percentile": 0.23432}, "CVE-2022-39996": {"epss_score": 0.00082, "epss_percentile": 0.24571}, "CVE-2022-39997": {"epss_score": 0.00372, "epss_percentile": 0.58426}, "CVE-2022-3000": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-3001": {"epss_score": 0.0101, "epss_percentile": 0.76602}, "CVE-2022-3002": {"epss_score": 0.00133, "epss_percentile": 0.33703}, "CVE-2022-3004": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-3005": {"epss_score": 0.00201, "epss_percentile": 0.4239}, "CVE-2022-3007": {"epss_score": 0.0007, "epss_percentile": 0.21782}, "CVE-2022-3008": {"epss_score": 0.11879, "epss_percentile": 0.93502}, "CVE-2022-3010": {"epss_score": 0.00126, "epss_percentile": 0.32685}, "CVE-2022-3012": {"epss_score": 0.00294, "epss_percentile": 0.52367}, "CVE-2022-3013": {"epss_score": 0.00304, "epss_percentile": 0.53245}, "CVE-2022-3014": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-3015": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-3016": {"epss_score": 0.00055, "epss_percentile": 0.17382}, "CVE-2022-3017": {"epss_score": 0.00105, "epss_percentile": 0.29285}, "CVE-2022-3018": {"epss_score": 0.0028, "epss_percentile": 0.51091}, "CVE-2022-3019": {"epss_score": 0.00335, "epss_percentile": 0.55857}, "CVE-2022-3021": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-3023": {"epss_score": 0.00171, "epss_percentile": 0.388}, "CVE-2022-3024": {"epss_score": 0.00074, "epss_percentile": 0.2269}, "CVE-2022-3025": {"epss_score": 0.00093, "epss_percentile": 0.26635}, "CVE-2022-3026": {"epss_score": 0.01163, "epss_percentile": 0.78156}, "CVE-2022-3027": {"epss_score": 0.0005, "epss_percentile": 0.15741}, "CVE-2022-3028": {"epss_score": 0.00018, "epss_percentile": 0.04037}, "CVE-2022-3029": {"epss_score": 0.0054, "epss_percentile": 0.66997}, "CVE-2022-3030": {"epss_score": 0.00288, "epss_percentile": 0.51864}, "CVE-2022-3031": {"epss_score": 0.001, "epss_percentile": 0.28473}, "CVE-2022-3032": {"epss_score": 0.00407, "epss_percentile": 0.6061}, "CVE-2022-3033": {"epss_score": 0.00465, "epss_percentile": 0.63767}, "CVE-2022-3034": {"epss_score": 0.00213, "epss_percentile": 0.4389}, "CVE-2022-3035": {"epss_score": 0.00243, "epss_percentile": 0.47477}, "CVE-2022-3036": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-3037": {"epss_score": 0.00055, "epss_percentile": 0.17418}, "CVE-2022-3038": {"epss_score": 0.35994, "epss_percentile": 0.96945}, "CVE-2022-3039": {"epss_score": 0.00515, "epss_percentile": 0.65984}, "CVE-2022-3040": {"epss_score": 0.00537, "epss_percentile": 0.66925}, "CVE-2022-3041": {"epss_score": 0.00515, "epss_percentile": 0.65984}, "CVE-2022-3042": {"epss_score": 0.00917, "epss_percentile": 0.75426}, "CVE-2022-3043": {"epss_score": 0.01306, "epss_percentile": 0.79337}, "CVE-2022-3044": {"epss_score": 0.00388, "epss_percentile": 0.59362}, "CVE-2022-3045": {"epss_score": 0.01181, "epss_percentile": 0.78308}, "CVE-2022-3046": {"epss_score": 0.00385, "epss_percentile": 0.59212}, "CVE-2022-3047": {"epss_score": 0.00121, "epss_percentile": 0.31933}, "CVE-2022-3048": {"epss_score": 0.00071, "epss_percentile": 0.22228}, "CVE-2022-3049": {"epss_score": 0.01057, "epss_percentile": 0.77132}, "CVE-2022-3050": {"epss_score": 0.01087, "epss_percentile": 0.77428}, "CVE-2022-3051": {"epss_score": 0.01392, "epss_percentile": 0.79959}, "CVE-2022-3052": {"epss_score": 0.01759, "epss_percentile": 0.82142}, "CVE-2022-3053": {"epss_score": 0.00371, "epss_percentile": 0.58417}, "CVE-2022-3054": {"epss_score": 0.00316, "epss_percentile": 0.54219}, "CVE-2022-3055": {"epss_score": 0.00812, "epss_percentile": 0.73742}, "CVE-2022-3056": {"epss_score": 0.00388, "epss_percentile": 0.59362}, "CVE-2022-3057": {"epss_score": 0.00219, "epss_percentile": 0.44511}, "CVE-2022-3058": {"epss_score": 0.00872, "epss_percentile": 0.7473}, "CVE-2022-3059": {"epss_score": 0.00341, "epss_percentile": 0.56323}, "CVE-2022-3060": {"epss_score": 0.0019, "epss_percentile": 0.41127}, "CVE-2022-3061": {"epss_score": 0.00022, "epss_percentile": 0.05317}, "CVE-2022-3062": {"epss_score": 0.48658, "epss_percentile": 0.97647}, "CVE-2022-3064": {"epss_score": 0.01771, "epss_percentile": 0.82199}, "CVE-2022-3065": {"epss_score": 0.00337, "epss_percentile": 0.5601}, "CVE-2022-3066": {"epss_score": 0.00166, "epss_percentile": 0.3818}, "CVE-2022-3067": {"epss_score": 0.00242, "epss_percentile": 0.47402}, "CVE-2022-3068": {"epss_score": 0.00142, "epss_percentile": 0.35002}, "CVE-2022-3069": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-3070": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-3071": {"epss_score": 0.01057, "epss_percentile": 0.77132}, "CVE-2022-3072": {"epss_score": 0.00336, "epss_percentile": 0.55997}, "CVE-2022-3073": {"epss_score": 0.0019, "epss_percentile": 0.41132}, "CVE-2022-3074": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3075": {"epss_score": 0.02991, "epss_percentile": 0.86143}, "CVE-2022-3076": {"epss_score": 0.00811, "epss_percentile": 0.73726}, "CVE-2022-3077": {"epss_score": 0.00019, "epss_percentile": 0.04353}, "CVE-2022-3078": {"epss_score": 0.00107, "epss_percentile": 0.29587}, "CVE-2022-3079": {"epss_score": 0.00321, "epss_percentile": 0.54736}, "CVE-2022-3080": {"epss_score": 0.00067, "epss_percentile": 0.21114}, "CVE-2022-3082": {"epss_score": 0.00081, "epss_percentile": 0.24332}, "CVE-2022-3083": {"epss_score": 0.00032, "epss_percentile": 0.09029}, "CVE-2022-3084": {"epss_score": 0.00068, "epss_percentile": 0.21246}, "CVE-2022-3085": {"epss_score": 0.00065, "epss_percentile": 0.20522}, "CVE-2022-3086": {"epss_score": 0.00244, "epss_percentile": 0.47586}, "CVE-2022-3087": {"epss_score": 0.00057, "epss_percentile": 0.18085}, "CVE-2022-3088": {"epss_score": 0.00048, "epss_percentile": 0.14985}, "CVE-2022-3089": {"epss_score": 0.00023, "epss_percentile": 0.0549}, "CVE-2022-3090": {"epss_score": 0.00297, "epss_percentile": 0.52772}, "CVE-2022-3091": {"epss_score": 0.00119, "epss_percentile": 0.31627}, "CVE-2022-3092": {"epss_score": 0.00068, "epss_percentile": 0.21246}, "CVE-2022-3093": {"epss_score": 0.00105, "epss_percentile": 0.29251}, "CVE-2022-3094": {"epss_score": 0.01285, "epss_percentile": 0.79177}, "CVE-2022-3095": {"epss_score": 0.00106, "epss_percentile": 0.2951}, "CVE-2022-3096": {"epss_score": 0.00199, "epss_percentile": 0.42118}, "CVE-2022-3097": {"epss_score": 0.00144, "epss_percentile": 0.35348}, "CVE-2022-3098": {"epss_score": 0.00106, "epss_percentile": 0.29533}, "CVE-2022-3099": {"epss_score": 0.00095, "epss_percentile": 0.27116}, "CVE-2022-3100": {"epss_score": 0.00028, "epss_percentile": 0.07524}, "CVE-2022-3101": {"epss_score": 0.00014, "epss_percentile": 0.01884}, "CVE-2022-3103": {"epss_score": 0.00073, "epss_percentile": 0.22584}, "CVE-2022-3104": {"epss_score": 0.00019, "epss_percentile": 0.04396}, "CVE-2022-3105": {"epss_score": 0.00019, "epss_percentile": 0.04396}, "CVE-2022-3106": {"epss_score": 0.00019, "epss_percentile": 0.04396}, "CVE-2022-3107": {"epss_score": 0.00013, "epss_percentile": 0.01573}, "CVE-2022-3108": {"epss_score": 0.00019, "epss_percentile": 0.04115}, "CVE-2022-3109": {"epss_score": 0.00181, "epss_percentile": 0.40034}, "CVE-2022-3110": {"epss_score": 0.00099, "epss_percentile": 0.28372}, "CVE-2022-3111": {"epss_score": 0.00013, "epss_percentile": 0.01573}, "CVE-2022-3112": {"epss_score": 0.00019, "epss_percentile": 0.04115}, "CVE-2022-3113": {"epss_score": 0.01172, "epss_percentile": 0.78232}, "CVE-2022-3114": {"epss_score": 0.00012, "epss_percentile": 0.01291}, "CVE-2022-3115": {"epss_score": 0.00019, "epss_percentile": 0.04115}, "CVE-2022-3116": {"epss_score": 0.00138, "epss_percentile": 0.34379}, "CVE-2022-3118": {"epss_score": 0.00238, "epss_percentile": 0.46837}, "CVE-2022-3119": {"epss_score": 0.00154, "epss_percentile": 0.36687}, "CVE-2022-3120": {"epss_score": 0.00238, "epss_percentile": 0.46837}, "CVE-2022-3121": {"epss_score": 0.00137, "epss_percentile": 0.3427}, "CVE-2022-3122": {"epss_score": 0.00294, "epss_percentile": 0.52367}, "CVE-2022-3123": {"epss_score": 0.00766, "epss_percentile": 0.72939}, "CVE-2022-3124": {"epss_score": 0.07544, "epss_percentile": 0.91527}, "CVE-2022-3125": {"epss_score": 0.01611, "epss_percentile": 0.81328}, "CVE-2022-3126": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-3127": {"epss_score": 0.00474, "epss_percentile": 0.64138}, "CVE-2022-3128": {"epss_score": 0.00465, "epss_percentile": 0.63752}, "CVE-2022-3129": {"epss_score": 0.00356, "epss_percentile": 0.57391}, "CVE-2022-3130": {"epss_score": 0.00211, "epss_percentile": 0.43709}, "CVE-2022-3131": {"epss_score": 0.00587, "epss_percentile": 0.68463}, "CVE-2022-3132": {"epss_score": 0.00465, "epss_percentile": 0.63752}, "CVE-2022-3133": {"epss_score": 0.00222, "epss_percentile": 0.44787}, "CVE-2022-3134": {"epss_score": 0.00042, "epss_percentile": 0.12767}, "CVE-2022-3135": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-3136": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3137": {"epss_score": 0.00231, "epss_percentile": 0.45836}, "CVE-2022-3138": {"epss_score": 0.00218, "epss_percentile": 0.44375}, "CVE-2022-3139": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-3140": {"epss_score": 0.01167, "epss_percentile": 0.78185}, "CVE-2022-3141": {"epss_score": 0.01245, "epss_percentile": 0.78839}, "CVE-2022-3142": {"epss_score": 0.22872, "epss_percentile": 0.95702}, "CVE-2022-3143": {"epss_score": 0.0029, "epss_percentile": 0.52112}, "CVE-2022-3144": {"epss_score": 0.00403, "epss_percentile": 0.60375}, "CVE-2022-3145": {"epss_score": 0.00081, "epss_percentile": 0.24282}, "CVE-2022-3146": {"epss_score": 0.00014, "epss_percentile": 0.01884}, "CVE-2022-3147": {"epss_score": 0.00725, "epss_percentile": 0.72054}, "CVE-2022-3148": {"epss_score": 0.00206, "epss_percentile": 0.43041}, "CVE-2022-3149": {"epss_score": 0.00093, "epss_percentile": 0.2674}, "CVE-2022-3150": {"epss_score": 0.01013, "epss_percentile": 0.7663}, "CVE-2022-3151": {"epss_score": 0.00106, "epss_percentile": 0.29533}, "CVE-2022-3152": {"epss_score": 0.002, "epss_percentile": 0.42249}, "CVE-2022-3153": {"epss_score": 0.00045, "epss_percentile": 0.14012}, "CVE-2022-3154": {"epss_score": 0.00167, "epss_percentile": 0.38349}, "CVE-2022-3155": {"epss_score": 0.00102, "epss_percentile": 0.28738}, "CVE-2022-3156": {"epss_score": 0.00014, "epss_percentile": 0.01867}, "CVE-2022-3157": {"epss_score": 0.01501, "epss_percentile": 0.80719}, "CVE-2022-3158": {"epss_score": 0.00168, "epss_percentile": 0.38439}, "CVE-2022-3159": {"epss_score": 0.00164, "epss_percentile": 0.37903}, "CVE-2022-3160": {"epss_score": 0.00119, "epss_percentile": 0.316}, "CVE-2022-3161": {"epss_score": 0.00176, "epss_percentile": 0.39471}, "CVE-2022-3162": {"epss_score": 0.00848, "epss_percentile": 0.74355}, "CVE-2022-3165": {"epss_score": 0.00151, "epss_percentile": 0.36252}, "CVE-2022-3166": {"epss_score": 0.00151, "epss_percentile": 0.36303}, "CVE-2022-3167": {"epss_score": 0.00327, "epss_percentile": 0.55126}, "CVE-2022-3169": {"epss_score": 0.00026, "epss_percentile": 0.06535}, "CVE-2022-3170": {"epss_score": 0.00025, "epss_percentile": 0.06338}, "CVE-2022-3171": {"epss_score": 0.00078, "epss_percentile": 0.23671}, "CVE-2022-3172": {"epss_score": 0.02537, "epss_percentile": 0.85039}, "CVE-2022-3173": {"epss_score": 0.00176, "epss_percentile": 0.39409}, "CVE-2022-3174": {"epss_score": 0.0014, "epss_percentile": 0.34718}, "CVE-2022-3175": {"epss_score": 0.0022, "epss_percentile": 0.44612}, "CVE-2022-3176": {"epss_score": 0.00022, "epss_percentile": 0.05187}, "CVE-2022-3178": {"epss_score": 0.00146, "epss_percentile": 0.35644}, "CVE-2022-3179": {"epss_score": 0.00239, "epss_percentile": 0.46888}, "CVE-2022-3180": {"epss_score": 0.04823, "epss_percentile": 0.8918}, "CVE-2022-3181": {"epss_score": 0.00245, "epss_percentile": 0.47678}, "CVE-2022-3182": {"epss_score": 0.00046, "epss_percentile": 0.14077}, "CVE-2022-3183": {"epss_score": 0.01091, "epss_percentile": 0.77458}, "CVE-2022-3184": {"epss_score": 0.02098, "epss_percentile": 0.83592}, "CVE-2022-3185": {"epss_score": 0.00158, "epss_percentile": 0.37143}, "CVE-2022-3186": {"epss_score": 0.00167, "epss_percentile": 0.38378}, "CVE-2022-3187": {"epss_score": 0.00139, "epss_percentile": 0.34661}, "CVE-2022-3188": {"epss_score": 0.00157, "epss_percentile": 0.37052}, "CVE-2022-3189": {"epss_score": 0.00238, "epss_percentile": 0.46757}, "CVE-2022-3190": {"epss_score": 0.00017, "epss_percentile": 0.0319}, "CVE-2022-3191": {"epss_score": 0.00048, "epss_percentile": 0.15255}, "CVE-2022-3192": {"epss_score": 0.00074, "epss_percentile": 0.22714}, "CVE-2022-3193": {"epss_score": 0.0035, "epss_percentile": 0.56956}, "CVE-2022-3194": {"epss_score": 0.00255, "epss_percentile": 0.4866}, "CVE-2022-3195": {"epss_score": 0.00955, "epss_percentile": 0.7591}, "CVE-2022-3196": {"epss_score": 0.00561, "epss_percentile": 0.67656}, "CVE-2022-3197": {"epss_score": 0.00618, "epss_percentile": 0.69375}, "CVE-2022-3198": {"epss_score": 0.00618, "epss_percentile": 0.69375}, "CVE-2022-3199": {"epss_score": 0.00705, "epss_percentile": 0.71585}, "CVE-2022-3200": {"epss_score": 0.00807, "epss_percentile": 0.73666}, "CVE-2022-3201": {"epss_score": 0.00085, "epss_percentile": 0.25062}, "CVE-2022-3202": {"epss_score": 0.00023, "epss_percentile": 0.05604}, "CVE-2022-3203": {"epss_score": 0.00353, "epss_percentile": 0.57144}, "CVE-2022-3204": {"epss_score": 0.0034, "epss_percentile": 0.5628}, "CVE-2022-3205": {"epss_score": 0.0051, "epss_percentile": 0.65788}, "CVE-2022-3206": {"epss_score": 0.00198, "epss_percentile": 0.42006}, "CVE-2022-3207": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3208": {"epss_score": 0.00184, "epss_percentile": 0.40419}, "CVE-2022-3209": {"epss_score": 0.00218, "epss_percentile": 0.44375}, "CVE-2022-3210": {"epss_score": 0.00521, "epss_percentile": 0.66237}, "CVE-2022-3211": {"epss_score": 0.00019, "epss_percentile": 0.0421}, "CVE-2022-3212": {"epss_score": 0.00266, "epss_percentile": 0.49859}, "CVE-2022-3213": {"epss_score": 0.0003, "epss_percentile": 0.0798}, "CVE-2022-3214": {"epss_score": 0.03544, "epss_percentile": 0.87323}, "CVE-2022-3215": {"epss_score": 0.00233, "epss_percentile": 0.46012}, "CVE-2022-3216": {"epss_score": 0.00359, "epss_percentile": 0.57552}, "CVE-2022-3217": {"epss_score": 0.00488, "epss_percentile": 0.64837}, "CVE-2022-3218": {"epss_score": 0.84624, "epss_percentile": 0.99298}, "CVE-2022-3219": {"epss_score": 0.00013, "epss_percentile": 0.01635}, "CVE-2022-3220": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3221": {"epss_score": 0.00134, "epss_percentile": 0.33764}, "CVE-2022-3222": {"epss_score": 0.00078, "epss_percentile": 0.23747}, "CVE-2022-3223": {"epss_score": 0.00326, "epss_percentile": 0.55087}, "CVE-2022-3224": {"epss_score": 0.00322, "epss_percentile": 0.54819}, "CVE-2022-3225": {"epss_score": 0.00333, "epss_percentile": 0.55647}, "CVE-2022-3226": {"epss_score": 0.00457, "epss_percentile": 0.63386}, "CVE-2022-3228": {"epss_score": 0.00083, "epss_percentile": 0.24741}, "CVE-2022-3229": {"epss_score": 0.88732, "epss_percentile": 0.99487}, "CVE-2022-3231": {"epss_score": 0.00389, "epss_percentile": 0.59492}, "CVE-2022-3232": {"epss_score": 0.00106, "epss_percentile": 0.29411}, "CVE-2022-3233": {"epss_score": 0.00124, "epss_percentile": 0.32363}, "CVE-2022-3234": {"epss_score": 0.00066, "epss_percentile": 0.20875}, "CVE-2022-3235": {"epss_score": 0.00057, "epss_percentile": 0.18227}, "CVE-2022-3236": {"epss_score": 0.91729, "epss_percentile": 0.99664}, "CVE-2022-3237": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-3238": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2022-3239": {"epss_score": 0.00032, "epss_percentile": 0.09038}, "CVE-2022-3240": {"epss_score": 0.00192, "epss_percentile": 0.41359}, "CVE-2022-3241": {"epss_score": 0.04446, "epss_percentile": 0.887}, "CVE-2022-3242": {"epss_score": 0.15577, "epss_percentile": 0.94463}, "CVE-2022-3243": {"epss_score": 0.00537, "epss_percentile": 0.66899}, "CVE-2022-3244": {"epss_score": 0.00137, "epss_percentile": 0.34239}, "CVE-2022-3245": {"epss_score": 0.00388, "epss_percentile": 0.59374}, "CVE-2022-3246": {"epss_score": 0.01054, "epss_percentile": 0.77111}, "CVE-2022-3247": {"epss_score": 0.00199, "epss_percentile": 0.4213}, "CVE-2022-3248": {"epss_score": 0.00046, "epss_percentile": 0.14345}, "CVE-2022-3249": {"epss_score": 0.00896, "epss_percentile": 0.75121}, "CVE-2022-3250": {"epss_score": 0.00352, "epss_percentile": 0.57086}, "CVE-2022-3251": {"epss_score": 0.00123, "epss_percentile": 0.32244}, "CVE-2022-3252": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-3254": {"epss_score": 0.52739, "epss_percentile": 0.97838}, "CVE-2022-3255": {"epss_score": 0.00011, "epss_percentile": 0.00931}, "CVE-2022-3256": {"epss_score": 0.00055, "epss_percentile": 0.17441}, "CVE-2022-3257": {"epss_score": 0.00482, "epss_percentile": 0.64534}, "CVE-2022-3258": {"epss_score": 0.00131, "epss_percentile": 0.33376}, "CVE-2022-3259": {"epss_score": 0.00096, "epss_percentile": 0.27329}, "CVE-2022-3260": {"epss_score": 0.00173, "epss_percentile": 0.39126}, "CVE-2022-3261": {"epss_score": 0.00041, "epss_percentile": 0.12374}, "CVE-2022-3262": {"epss_score": 0.00427, "epss_percentile": 0.61778}, "CVE-2022-3263": {"epss_score": 0.00028, "epss_percentile": 0.07497}, "CVE-2022-3265": {"epss_score": 0.15465, "epss_percentile": 0.94433}, "CVE-2022-3266": {"epss_score": 0.00076, "epss_percentile": 0.23182}, "CVE-2022-3267": {"epss_score": 0.0016, "epss_percentile": 0.37512}, "CVE-2022-3268": {"epss_score": 0.00226, "epss_percentile": 0.45249}, "CVE-2022-3269": {"epss_score": 0.00338, "epss_percentile": 0.56146}, "CVE-2022-3270": {"epss_score": 0.00955, "epss_percentile": 0.75911}, "CVE-2022-3272": {"epss_score": 0.0041, "epss_percentile": 0.60836}, "CVE-2022-3273": {"epss_score": 0.00188, "epss_percentile": 0.40869}, "CVE-2022-3274": {"epss_score": 0.00177, "epss_percentile": 0.39583}, "CVE-2022-3275": {"epss_score": 0.03006, "epss_percentile": 0.86185}, "CVE-2022-3276": {"epss_score": 0.00591, "epss_percentile": 0.6858}, "CVE-2022-3277": {"epss_score": 0.00638, "epss_percentile": 0.69923}, "CVE-2022-3278": {"epss_score": 0.00045, "epss_percentile": 0.13947}, "CVE-2022-3279": {"epss_score": 0.00706, "epss_percentile": 0.71615}, "CVE-2022-3280": {"epss_score": 0.00167, "epss_percentile": 0.38299}, "CVE-2022-3281": {"epss_score": 0.0024, "epss_percentile": 0.46961}, "CVE-2022-3282": {"epss_score": 0.0014, "epss_percentile": 0.34754}, "CVE-2022-3283": {"epss_score": 0.00536, "epss_percentile": 0.66864}, "CVE-2022-3284": {"epss_score": 0.00287, "epss_percentile": 0.51852}, "CVE-2022-3285": {"epss_score": 0.00345, "epss_percentile": 0.56567}, "CVE-2022-3286": {"epss_score": 0.00123, "epss_percentile": 0.32268}, "CVE-2022-3287": {"epss_score": 0.0011, "epss_percentile": 0.30148}, "CVE-2022-3288": {"epss_score": 0.00155, "epss_percentile": 0.36829}, "CVE-2022-3290": {"epss_score": 0.00284, "epss_percentile": 0.51446}, "CVE-2022-3291": {"epss_score": 0.00446, "epss_percentile": 0.62931}, "CVE-2022-3292": {"epss_score": 0.00254, "epss_percentile": 0.48559}, "CVE-2022-3293": {"epss_score": 0.00178, "epss_percentile": 0.39686}, "CVE-2022-3294": {"epss_score": 0.00725, "epss_percentile": 0.72059}, "CVE-2022-3295": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-3296": {"epss_score": 0.00061, "epss_percentile": 0.19287}, "CVE-2022-3297": {"epss_score": 0.00053, "epss_percentile": 0.16901}, "CVE-2022-3298": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-3299": {"epss_score": 0.00339, "epss_percentile": 0.56182}, "CVE-2022-3300": {"epss_score": 0.01196, "epss_percentile": 0.7844}, "CVE-2022-3301": {"epss_score": 0.00253, "epss_percentile": 0.48492}, "CVE-2022-3302": {"epss_score": 0.00797, "epss_percentile": 0.73491}, "CVE-2022-3303": {"epss_score": 0.00019, "epss_percentile": 0.04393}, "CVE-2022-3304": {"epss_score": 0.00382, "epss_percentile": 0.59043}, "CVE-2022-3305": {"epss_score": 0.01021, "epss_percentile": 0.76751}, "CVE-2022-3306": {"epss_score": 0.00615, "epss_percentile": 0.69315}, "CVE-2022-3307": {"epss_score": 0.00392, "epss_percentile": 0.59661}, "CVE-2022-3308": {"epss_score": 0.00131, "epss_percentile": 0.33352}, "CVE-2022-3309": {"epss_score": 0.00168, "epss_percentile": 0.38476}, "CVE-2022-3310": {"epss_score": 0.00133, "epss_percentile": 0.33744}, "CVE-2022-3311": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2022-3312": {"epss_score": 0.00031, "epss_percentile": 0.08546}, "CVE-2022-3313": {"epss_score": 0.00116, "epss_percentile": 0.31179}, "CVE-2022-3314": {"epss_score": 0.00199, "epss_percentile": 0.42185}, "CVE-2022-3315": {"epss_score": 0.00567, "epss_percentile": 0.67837}, "CVE-2022-3316": {"epss_score": 0.00249, "epss_percentile": 0.48082}, "CVE-2022-3317": {"epss_score": 0.00281, "epss_percentile": 0.5113}, "CVE-2022-3318": {"epss_score": 0.00301, "epss_percentile": 0.53019}, "CVE-2022-3320": {"epss_score": 0.00138, "epss_percentile": 0.34514}, "CVE-2022-3321": {"epss_score": 0.00089, "epss_percentile": 0.25919}, "CVE-2022-3322": {"epss_score": 0.00068, "epss_percentile": 0.21366}, "CVE-2022-3323": {"epss_score": 0.00812, "epss_percentile": 0.7375}, "CVE-2022-3324": {"epss_score": 0.00069, "epss_percentile": 0.2162}, "CVE-2022-3325": {"epss_score": 0.00187, "epss_percentile": 0.40741}, "CVE-2022-3326": {"epss_score": 0.00179, "epss_percentile": 0.39819}, "CVE-2022-3327": {"epss_score": 0.00313, "epss_percentile": 0.54038}, "CVE-2022-3328": {"epss_score": 0.00105, "epss_percentile": 0.29343}, "CVE-2022-3330": {"epss_score": 0.00163, "epss_percentile": 0.37779}, "CVE-2022-3331": {"epss_score": 0.00174, "epss_percentile": 0.39148}, "CVE-2022-3332": {"epss_score": 0.0023, "epss_percentile": 0.4574}, "CVE-2022-3333": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2022-3334": {"epss_score": 0.00941, "epss_percentile": 0.7575}, "CVE-2022-3335": {"epss_score": 0.00855, "epss_percentile": 0.74466}, "CVE-2022-3336": {"epss_score": 0.00106, "epss_percentile": 0.29533}, "CVE-2022-3337": {"epss_score": 0.00085, "epss_percentile": 0.25042}, "CVE-2022-3338": {"epss_score": 0.00207, "epss_percentile": 0.43141}, "CVE-2022-3339": {"epss_score": 0.00197, "epss_percentile": 0.41836}, "CVE-2022-3340": {"epss_score": 0.00421, "epss_percentile": 0.61464}, "CVE-2022-3341": {"epss_score": 0.00061, "epss_percentile": 0.19399}, "CVE-2022-3342": {"epss_score": 0.01898, "epss_percentile": 0.82762}, "CVE-2022-3343": {"epss_score": 0.00167, "epss_percentile": 0.38396}, "CVE-2022-3344": {"epss_score": 0.00017, "epss_percentile": 0.03119}, "CVE-2022-3346": {"epss_score": 0.00103, "epss_percentile": 0.29045}, "CVE-2022-3347": {"epss_score": 0.00098, "epss_percentile": 0.27668}, "CVE-2022-3348": {"epss_score": 0.00311, "epss_percentile": 0.53839}, "CVE-2022-3349": {"epss_score": 0.00122, "epss_percentile": 0.32054}, "CVE-2022-3350": {"epss_score": 0.00108, "epss_percentile": 0.29805}, "CVE-2022-3351": {"epss_score": 0.00256, "epss_percentile": 0.48823}, "CVE-2022-3352": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2022-3353": {"epss_score": 0.00448, "epss_percentile": 0.62997}, "CVE-2022-3354": {"epss_score": 0.00258, "epss_percentile": 0.4902}, "CVE-2022-3355": {"epss_score": 0.00122, "epss_percentile": 0.32144}, "CVE-2022-3357": {"epss_score": 0.27109, "epss_percentile": 0.96208}, "CVE-2022-3358": {"epss_score": 0.15626, "epss_percentile": 0.94471}, "CVE-2022-3359": {"epss_score": 0.00907, "epss_percentile": 0.75265}, "CVE-2022-3360": {"epss_score": 0.1516, "epss_percentile": 0.94376}, "CVE-2022-3361": {"epss_score": 0.05899, "epss_percentile": 0.90307}, "CVE-2022-3362": {"epss_score": 0.0034, "epss_percentile": 0.56215}, "CVE-2022-3363": {"epss_score": 0.00467, "epss_percentile": 0.63828}, "CVE-2022-3364": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-3365": {"epss_score": 0.57866, "epss_percentile": 0.98087}, "CVE-2022-3366": {"epss_score": 0.00855, "epss_percentile": 0.74466}, "CVE-2022-3368": {"epss_score": 0.04844, "epss_percentile": 0.89207}, "CVE-2022-3369": {"epss_score": 0.00055, "epss_percentile": 0.17521}, "CVE-2022-3370": {"epss_score": 0.00811, "epss_percentile": 0.73733}, "CVE-2022-3371": {"epss_score": 0.00441, "epss_percentile": 0.62667}, "CVE-2022-3372": {"epss_score": 0.0021, "epss_percentile": 0.43444}, "CVE-2022-3373": {"epss_score": 0.00598, "epss_percentile": 0.68774}, "CVE-2022-3374": {"epss_score": 0.00861, "epss_percentile": 0.74564}, "CVE-2022-3375": {"epss_score": 0.00493, "epss_percentile": 0.65062}, "CVE-2022-3376": {"epss_score": 0.00463, "epss_percentile": 0.63693}, "CVE-2022-3377": {"epss_score": 0.00068, "epss_percentile": 0.21246}, "CVE-2022-3378": {"epss_score": 0.00068, "epss_percentile": 0.21246}, "CVE-2022-3379": {"epss_score": 0.00068, "epss_percentile": 0.21246}, "CVE-2022-3380": {"epss_score": 0.00941, "epss_percentile": 0.7575}, "CVE-2022-3381": {"epss_score": 0.00288, "epss_percentile": 0.51925}, "CVE-2022-3382": {"epss_score": 0.0022, "epss_percentile": 0.44622}, "CVE-2022-3383": {"epss_score": 0.31097, "epss_percentile": 0.96587}, "CVE-2022-3384": {"epss_score": 0.34916, "epss_percentile": 0.96878}, "CVE-2022-3385": {"epss_score": 0.01309, "epss_percentile": 0.79357}, "CVE-2022-3386": {"epss_score": 0.01309, "epss_percentile": 0.79357}, "CVE-2022-3387": {"epss_score": 0.00545, "epss_percentile": 0.67175}, "CVE-2022-3388": {"epss_score": 0.00196, "epss_percentile": 0.41729}, "CVE-2022-3389": {"epss_score": 0.00431, "epss_percentile": 0.6206}, "CVE-2022-3391": {"epss_score": 0.00415, "epss_percentile": 0.61135}, "CVE-2022-3392": {"epss_score": 0.00175, "epss_percentile": 0.39282}, "CVE-2022-3393": {"epss_score": 0.0244, "epss_percentile": 0.84752}, "CVE-2022-3394": {"epss_score": 0.01218, "epss_percentile": 0.78604}, "CVE-2022-3395": {"epss_score": 0.00666, "epss_percentile": 0.70681}, "CVE-2022-3396": {"epss_score": 0.00322, "epss_percentile": 0.54828}, "CVE-2022-3397": {"epss_score": 0.00322, "epss_percentile": 0.54828}, "CVE-2022-3398": {"epss_score": 0.00322, "epss_percentile": 0.54828}, "CVE-2022-3399": {"epss_score": 0.00267, "epss_percentile": 0.50014}, "CVE-2022-3400": {"epss_score": 0.00157, "epss_percentile": 0.3704}, "CVE-2022-3401": {"epss_score": 0.06552, "epss_percentile": 0.90844}, "CVE-2022-3402": {"epss_score": 0.03455, "epss_percentile": 0.87171}, "CVE-2022-3405": {"epss_score": 0.28418, "epss_percentile": 0.96356}, "CVE-2022-3407": {"epss_score": 0.00034, "epss_percentile": 0.09455}, "CVE-2022-3408": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-3409": {"epss_score": 0.00411, "epss_percentile": 0.60874}, "CVE-2022-3411": {"epss_score": 0.00454, "epss_percentile": 0.63244}, "CVE-2022-3413": {"epss_score": 0.0018, "epss_percentile": 0.39919}, "CVE-2022-3414": {"epss_score": 0.0023, "epss_percentile": 0.4574}, "CVE-2022-3415": {"epss_score": 0.01134, "epss_percentile": 0.77886}, "CVE-2022-3416": {"epss_score": 0.15102, "epss_percentile": 0.94363}, "CVE-2022-3417": {"epss_score": 0.00386, "epss_percentile": 0.59279}, "CVE-2022-3418": {"epss_score": 0.01356, "epss_percentile": 0.79714}, "CVE-2022-3419": {"epss_score": 0.00188, "epss_percentile": 0.40861}, "CVE-2022-3420": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3421": {"epss_score": 0.00013, "epss_percentile": 0.01607}, "CVE-2022-3422": {"epss_score": 0.00258, "epss_percentile": 0.48967}, "CVE-2022-3423": {"epss_score": 0.00961, "epss_percentile": 0.75977}, "CVE-2022-3424": {"epss_score": 0.0002, "epss_percentile": 0.04613}, "CVE-2022-3425": {"epss_score": 0.00295, "epss_percentile": 0.52497}, "CVE-2022-3426": {"epss_score": 0.00339, "epss_percentile": 0.56172}, "CVE-2022-3427": {"epss_score": 0.00455, "epss_percentile": 0.63302}, "CVE-2022-3429": {"epss_score": 0.00078, "epss_percentile": 0.23788}, "CVE-2022-3430": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2022-3431": {"epss_score": 0.00035, "epss_percentile": 0.09907}, "CVE-2022-3432": {"epss_score": 0.00117, "epss_percentile": 0.31208}, "CVE-2022-3433": {"epss_score": 0.00296, "epss_percentile": 0.52601}, "CVE-2022-3434": {"epss_score": 0.00812, "epss_percentile": 0.73751}, "CVE-2022-3435": {"epss_score": 0.00061, "epss_percentile": 0.19353}, "CVE-2022-3436": {"epss_score": 0.00162, "epss_percentile": 0.37735}, "CVE-2022-3437": {"epss_score": 0.00625, "epss_percentile": 0.69579}, "CVE-2022-3438": {"epss_score": 0.00117, "epss_percentile": 0.31236}, "CVE-2022-3439": {"epss_score": 0.00159, "epss_percentile": 0.37331}, "CVE-2022-3440": {"epss_score": 0.00104, "epss_percentile": 0.29162}, "CVE-2022-3441": {"epss_score": 0.00108, "epss_percentile": 0.29805}, "CVE-2022-3442": {"epss_score": 0.00248, "epss_percentile": 0.47956}, "CVE-2022-3443": {"epss_score": 0.00238, "epss_percentile": 0.46741}, "CVE-2022-3444": {"epss_score": 0.00139, "epss_percentile": 0.34583}, "CVE-2022-3445": {"epss_score": 0.00354, "epss_percentile": 0.57223}, "CVE-2022-3446": {"epss_score": 0.00429, "epss_percentile": 0.61989}, "CVE-2022-3447": {"epss_score": 0.00085, "epss_percentile": 0.25147}, "CVE-2022-3448": {"epss_score": 0.00191, "epss_percentile": 0.41276}, "CVE-2022-3449": {"epss_score": 0.00089, "epss_percentile": 0.25967}, "CVE-2022-3450": {"epss_score": 0.00245, "epss_percentile": 0.47693}, "CVE-2022-3451": {"epss_score": 0.00078, "epss_percentile": 0.23663}, "CVE-2022-3452": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2022-3453": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2022-3456": {"epss_score": 0.00299, "epss_percentile": 0.52905}, "CVE-2022-3457": {"epss_score": 0.00209, "epss_percentile": 0.43366}, "CVE-2022-3458": {"epss_score": 0.00298, "epss_percentile": 0.52783}, "CVE-2022-3459": {"epss_score": 0.00296, "epss_percentile": 0.5258}, "CVE-2022-3460": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2022-3461": {"epss_score": 0.00062, "epss_percentile": 0.19623}, "CVE-2022-3462": {"epss_score": 0.00137, "epss_percentile": 0.34321}, "CVE-2022-3463": {"epss_score": 0.01307, "epss_percentile": 0.79344}, "CVE-2022-3464": {"epss_score": 0.00299, "epss_percentile": 0.52899}, "CVE-2022-3465": {"epss_score": 0.00379, "epss_percentile": 0.58861}, "CVE-2022-3466": {"epss_score": 0.00022, "epss_percentile": 0.0526}, "CVE-2022-3467": {"epss_score": 0.0023, "epss_percentile": 0.4574}, "CVE-2022-3469": {"epss_score": 0.00339, "epss_percentile": 0.56172}, "CVE-2022-3470": {"epss_score": 0.00267, "epss_percentile": 0.4999}, "CVE-2022-3471": {"epss_score": 0.00212, "epss_percentile": 0.43753}, "CVE-2022-3472": {"epss_score": 0.00261, "epss_percentile": 0.49247}, "CVE-2022-3473": {"epss_score": 0.00267, "epss_percentile": 0.4999}, "CVE-2022-3474": {"epss_score": 0.00062, "epss_percentile": 0.19647}, "CVE-2022-3477": {"epss_score": 0.55323, "epss_percentile": 0.97971}, "CVE-2022-3478": {"epss_score": 0.00066, "epss_percentile": 0.20897}, "CVE-2022-3479": {"epss_score": 0.00198, "epss_percentile": 0.41976}, "CVE-2022-3480": {"epss_score": 0.01076, "epss_percentile": 0.77323}, "CVE-2022-3481": {"epss_score": 0.61537, "epss_percentile": 0.98252}, "CVE-2022-3482": {"epss_score": 0.00312, "epss_percentile": 0.53948}, "CVE-2022-3483": {"epss_score": 0.0033, "epss_percentile": 0.55453}, "CVE-2022-3484": {"epss_score": 0.03299, "epss_percentile": 0.86863}, "CVE-2022-3485": {"epss_score": 0.00799, "epss_percentile": 0.7353}, "CVE-2022-3486": {"epss_score": 0.00381, "epss_percentile": 0.59003}, "CVE-2022-3488": {"epss_score": 0.0969, "epss_percentile": 0.92664}, "CVE-2022-3489": {"epss_score": 0.0014, "epss_percentile": 0.34778}, "CVE-2022-3490": {"epss_score": 0.00855, "epss_percentile": 0.74466}, "CVE-2022-3491": {"epss_score": 0.00019, "epss_percentile": 0.04139}, "CVE-2022-3492": {"epss_score": 0.00909, "epss_percentile": 0.753}, "CVE-2022-3493": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-3494": {"epss_score": 0.00918, "epss_percentile": 0.75441}, "CVE-2022-3495": {"epss_score": 0.00313, "epss_percentile": 0.54043}, "CVE-2022-3496": {"epss_score": 0.00265, "epss_percentile": 0.49808}, "CVE-2022-3497": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-3499": {"epss_score": 0.00374, "epss_percentile": 0.58571}, "CVE-2022-3500": {"epss_score": 0.00135, "epss_percentile": 0.34039}, "CVE-2022-3501": {"epss_score": 0.00172, "epss_percentile": 0.38969}, "CVE-2022-3502": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-3503": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2022-3504": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-3505": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-3506": {"epss_score": 0.01295, "epss_percentile": 0.79251}, "CVE-2022-3509": {"epss_score": 0.00131, "epss_percentile": 0.33489}, "CVE-2022-3510": {"epss_score": 0.00073, "epss_percentile": 0.22496}, "CVE-2022-3511": {"epss_score": 0.00416, "epss_percentile": 0.612}, "CVE-2022-3512": {"epss_score": 0.00136, "epss_percentile": 0.34097}, "CVE-2022-3513": {"epss_score": 0.27897, "epss_percentile": 0.96293}, "CVE-2022-3514": {"epss_score": 0.00083, "epss_percentile": 0.24747}, "CVE-2022-3515": {"epss_score": 0.00141, "epss_percentile": 0.34822}, "CVE-2022-3516": {"epss_score": 6e-05, "epss_percentile": 0.00317}, "CVE-2022-3517": {"epss_score": 0.00416, "epss_percentile": 0.61179}, "CVE-2022-3518": {"epss_score": 0.00224, "epss_percentile": 0.45068}, "CVE-2022-3519": {"epss_score": 0.00242, "epss_percentile": 0.47333}, "CVE-2022-3520": {"epss_score": 0.00062, "epss_percentile": 0.19645}, "CVE-2022-3521": {"epss_score": 0.00031, "epss_percentile": 0.08389}, "CVE-2022-3523": {"epss_score": 0.00084, "epss_percentile": 0.24883}, "CVE-2022-3524": {"epss_score": 0.00095, "epss_percentile": 0.27121}, "CVE-2022-3525": {"epss_score": 5e-05, "epss_percentile": 0.00233}, "CVE-2022-3526": {"epss_score": 0.01016, "epss_percentile": 0.76672}, "CVE-2022-3533": {"epss_score": 0.00023, "epss_percentile": 0.05436}, "CVE-2022-3534": {"epss_score": 0.00026, "epss_percentile": 0.06599}, "CVE-2022-3536": {"epss_score": 0.00084, "epss_percentile": 0.25023}, "CVE-2022-3537": {"epss_score": 0.00182, "epss_percentile": 0.40273}, "CVE-2022-3538": {"epss_score": 0.00277, "epss_percentile": 0.5081}, "CVE-2022-3539": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-3540": {"epss_score": 0.00128, "epss_percentile": 0.32951}, "CVE-2022-3541": {"epss_score": 0.00019, "epss_percentile": 0.0409}, "CVE-2022-3543": {"epss_score": 0.00023, "epss_percentile": 0.05512}, "CVE-2022-3544": {"epss_score": 0.00014, "epss_percentile": 0.01962}, "CVE-2022-3545": {"epss_score": 0.00029, "epss_percentile": 0.07691}, "CVE-2022-3546": {"epss_score": 0.00872, "epss_percentile": 0.74735}, "CVE-2022-3547": {"epss_score": 0.00614, "epss_percentile": 0.69267}, "CVE-2022-3548": {"epss_score": 0.00614, "epss_percentile": 0.69267}, "CVE-2022-3549": {"epss_score": 0.00302, "epss_percentile": 0.53108}, "CVE-2022-3550": {"epss_score": 0.00363, "epss_percentile": 0.57864}, "CVE-2022-3551": {"epss_score": 0.0066, "epss_percentile": 0.7054}, "CVE-2022-3552": {"epss_score": 0.68915, "epss_percentile": 0.98567}, "CVE-2022-3553": {"epss_score": 0.00104, "epss_percentile": 0.2919}, "CVE-2022-3556": {"epss_score": 0.00211, "epss_percentile": 0.43641}, "CVE-2022-3558": {"epss_score": 0.00795, "epss_percentile": 0.73475}, "CVE-2022-3559": {"epss_score": 0.00349, "epss_percentile": 0.56903}, "CVE-2022-3560": {"epss_score": 0.00027, "epss_percentile": 0.07003}, "CVE-2022-3561": {"epss_score": 0.00291, "epss_percentile": 0.52158}, "CVE-2022-3562": {"epss_score": 0.87099, "epss_percentile": 0.99415}, "CVE-2022-3563": {"epss_score": 0.00023, "epss_percentile": 0.05434}, "CVE-2022-3564": {"epss_score": 0.00078, "epss_percentile": 0.2365}, "CVE-2022-3565": {"epss_score": 0.00035, "epss_percentile": 0.10075}, "CVE-2022-3566": {"epss_score": 0.00019, "epss_percentile": 0.0408}, "CVE-2022-3567": {"epss_score": 0.00018, "epss_percentile": 0.03669}, "CVE-2022-3568": {"epss_score": 0.0059, "epss_percentile": 0.68567}, "CVE-2022-3569": {"epss_score": 0.02836, "epss_percentile": 0.85791}, "CVE-2022-3570": {"epss_score": 7e-05, "epss_percentile": 0.00324}, "CVE-2022-3572": {"epss_score": 0.07547, "epss_percentile": 0.91531}, "CVE-2022-3573": {"epss_score": 0.00683, "epss_percentile": 0.71103}, "CVE-2022-3574": {"epss_score": 0.01468, "epss_percentile": 0.80478}, "CVE-2022-3575": {"epss_score": 0.00469, "epss_percentile": 0.63949}, "CVE-2022-3576": {"epss_score": 0.00366, "epss_percentile": 0.58088}, "CVE-2022-3577": {"epss_score": 0.00027, "epss_percentile": 0.06776}, "CVE-2022-3578": {"epss_score": 0.06392, "epss_percentile": 0.90719}, "CVE-2022-3579": {"epss_score": 0.00294, "epss_percentile": 0.52367}, "CVE-2022-3580": {"epss_score": 0.0035, "epss_percentile": 0.56966}, "CVE-2022-3581": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-3582": {"epss_score": 0.00133, "epss_percentile": 0.33715}, "CVE-2022-3583": {"epss_score": 0.00272, "epss_percentile": 0.50381}, "CVE-2022-3584": {"epss_score": 0.0023, "epss_percentile": 0.4574}, "CVE-2022-3585": {"epss_score": 0.00149, "epss_percentile": 0.35975}, "CVE-2022-3586": {"epss_score": 0.00055, "epss_percentile": 0.17439}, "CVE-2022-3587": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-3589": {"epss_score": 0.00421, "epss_percentile": 0.61509}, "CVE-2022-3590": {"epss_score": 0.86525, "epss_percentile": 0.99386}, "CVE-2022-3591": {"epss_score": 0.0011, "epss_percentile": 0.30117}, "CVE-2022-3592": {"epss_score": 0.00713, "epss_percentile": 0.71804}, "CVE-2022-3594": {"epss_score": 0.00312, "epss_percentile": 0.54004}, "CVE-2022-3595": {"epss_score": 0.00014, "epss_percentile": 0.01971}, "CVE-2022-3596": {"epss_score": 0.00293, "epss_percentile": 0.5235}, "CVE-2022-3597": {"epss_score": 0.00026, "epss_percentile": 0.06513}, "CVE-2022-3598": {"epss_score": 0.00047, "epss_percentile": 0.14645}, "CVE-2022-3599": {"epss_score": 0.00035, "epss_percentile": 0.09995}, "CVE-2022-3600": {"epss_score": 0.01307, "epss_percentile": 0.79344}, "CVE-2022-3601": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3602": {"epss_score": 0.81961, "epss_percentile": 0.99167}, "CVE-2022-3603": {"epss_score": 0.0215, "epss_percentile": 0.83782}, "CVE-2022-3604": {"epss_score": 0.00335, "epss_percentile": 0.55835}, "CVE-2022-3605": {"epss_score": 0.00343, "epss_percentile": 0.56452}, "CVE-2022-3606": {"epss_score": 0.00014, "epss_percentile": 0.01971}, "CVE-2022-3607": {"epss_score": 0.00218, "epss_percentile": 0.4444}, "CVE-2022-3608": {"epss_score": 0.00472, "epss_percentile": 0.64056}, "CVE-2022-3609": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3610": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3611": {"epss_score": 0.00066, "epss_percentile": 0.20676}, "CVE-2022-3613": {"epss_score": 0.00072, "epss_percentile": 0.22472}, "CVE-2022-3614": {"epss_score": 0.00214, "epss_percentile": 0.43993}, "CVE-2022-3616": {"epss_score": 0.00263, "epss_percentile": 0.49476}, "CVE-2022-3618": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3619": {"epss_score": 0.00024, "epss_percentile": 0.05777}, "CVE-2022-3620": {"epss_score": 0.01227, "epss_percentile": 0.78694}, "CVE-2022-3621": {"epss_score": 0.00189, "epss_percentile": 0.40995}, "CVE-2022-3622": {"epss_score": 0.00149, "epss_percentile": 0.35942}, "CVE-2022-3623": {"epss_score": 0.00068, "epss_percentile": 0.21353}, "CVE-2022-3624": {"epss_score": 0.00017, "epss_percentile": 0.03128}, "CVE-2022-3625": {"epss_score": 0.00019, "epss_percentile": 0.04077}, "CVE-2022-3626": {"epss_score": 0.00035, "epss_percentile": 0.10015}, "CVE-2022-3627": {"epss_score": 0.00026, "epss_percentile": 0.06513}, "CVE-2022-3628": {"epss_score": 0.00058, "epss_percentile": 0.18306}, "CVE-2022-3629": {"epss_score": 0.00036, "epss_percentile": 0.10606}, "CVE-2022-3630": {"epss_score": 0.00069, "epss_percentile": 0.21602}, "CVE-2022-3631": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3632": {"epss_score": 0.00184, "epss_percentile": 0.40419}, "CVE-2022-3633": {"epss_score": 0.00133, "epss_percentile": 0.33697}, "CVE-2022-3634": {"epss_score": 0.0103, "epss_percentile": 0.76838}, "CVE-2022-3635": {"epss_score": 0.00012, "epss_percentile": 0.01166}, "CVE-2022-3636": {"epss_score": 0.00017, "epss_percentile": 0.03412}, "CVE-2022-3637": {"epss_score": 0.00021, "epss_percentile": 0.04774}, "CVE-2022-3639": {"epss_score": 0.00187, "epss_percentile": 0.40793}, "CVE-2022-3640": {"epss_score": 0.00021, "epss_percentile": 0.04808}, "CVE-2022-3641": {"epss_score": 0.0029, "epss_percentile": 0.52122}, "CVE-2022-3643": {"epss_score": 0.00191, "epss_percentile": 0.41218}, "CVE-2022-3644": {"epss_score": 0.00039, "epss_percentile": 0.11838}, "CVE-2022-3646": {"epss_score": 0.0026, "epss_percentile": 0.49162}, "CVE-2022-3647": {"epss_score": 0.0011, "epss_percentile": 0.30115}, "CVE-2022-3649": {"epss_score": 0.00099, "epss_percentile": 0.28347}, "CVE-2022-3650": {"epss_score": 0.00024, "epss_percentile": 0.05861}, "CVE-2022-3652": {"epss_score": 0.00679, "epss_percentile": 0.71019}, "CVE-2022-3653": {"epss_score": 0.00464, "epss_percentile": 0.6371}, "CVE-2022-3654": {"epss_score": 0.06878, "epss_percentile": 0.91088}, "CVE-2022-3655": {"epss_score": 0.00167, "epss_percentile": 0.38388}, "CVE-2022-3656": {"epss_score": 0.02432, "epss_percentile": 0.8473}, "CVE-2022-3657": {"epss_score": 0.00177, "epss_percentile": 0.39531}, "CVE-2022-3658": {"epss_score": 0.00177, "epss_percentile": 0.39531}, "CVE-2022-3659": {"epss_score": 0.00969, "epss_percentile": 0.761}, "CVE-2022-3660": {"epss_score": 0.00121, "epss_percentile": 0.31831}, "CVE-2022-3661": {"epss_score": 0.00108, "epss_percentile": 0.29859}, "CVE-2022-3662": {"epss_score": 0.00358, "epss_percentile": 0.5754}, "CVE-2022-3663": {"epss_score": 0.00206, "epss_percentile": 0.43076}, "CVE-2022-3664": {"epss_score": 0.00341, "epss_percentile": 0.56315}, "CVE-2022-3665": {"epss_score": 0.00356, "epss_percentile": 0.57391}, "CVE-2022-3666": {"epss_score": 0.00343, "epss_percentile": 0.56447}, "CVE-2022-3667": {"epss_score": 0.00538, "epss_percentile": 0.66944}, "CVE-2022-3668": {"epss_score": 0.00206, "epss_percentile": 0.43076}, "CVE-2022-3669": {"epss_score": 0.00368, "epss_percentile": 0.5822}, "CVE-2022-3670": {"epss_score": 0.00373, "epss_percentile": 0.58516}, "CVE-2022-3671": {"epss_score": 0.00054, "epss_percentile": 0.17217}, "CVE-2022-3672": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-3673": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-3674": {"epss_score": 0.00315, "epss_percentile": 0.54196}, "CVE-2022-3675": {"epss_score": 0.00049, "epss_percentile": 0.15503}, "CVE-2022-3676": {"epss_score": 0.0038, "epss_percentile": 0.58932}, "CVE-2022-3677": {"epss_score": 0.00184, "epss_percentile": 0.40419}, "CVE-2022-3679": {"epss_score": 0.00547, "epss_percentile": 0.67244}, "CVE-2022-3681": {"epss_score": 0.0005, "epss_percentile": 0.15732}, "CVE-2022-3682": {"epss_score": 0.00316, "epss_percentile": 0.54286}, "CVE-2022-3683": {"epss_score": 0.00091, "epss_percentile": 0.26274}, "CVE-2022-3684": {"epss_score": 0.0017, "epss_percentile": 0.38685}, "CVE-2022-3685": {"epss_score": 0.00099, "epss_percentile": 0.28408}, "CVE-2022-3686": {"epss_score": 0.0007, "epss_percentile": 0.21675}, "CVE-2022-3688": {"epss_score": 0.00335, "epss_percentile": 0.55806}, "CVE-2022-3689": {"epss_score": 0.35524, "epss_percentile": 0.96918}, "CVE-2022-3690": {"epss_score": 0.00435, "epss_percentile": 0.62378}, "CVE-2022-3691": {"epss_score": 0.01114, "epss_percentile": 0.77705}, "CVE-2022-3693": {"epss_score": 0.00148, "epss_percentile": 0.35857}, "CVE-2022-3694": {"epss_score": 0.00583, "epss_percentile": 0.68331}, "CVE-2022-3695": {"epss_score": 0.00314, "epss_percentile": 0.54137}, "CVE-2022-3696": {"epss_score": 0.00442, "epss_percentile": 0.62746}, "CVE-2022-3697": {"epss_score": 0.00132, "epss_percentile": 0.33611}, "CVE-2022-3698": {"epss_score": 0.00036, "epss_percentile": 0.10443}, "CVE-2022-3699": {"epss_score": 0.84573, "epss_percentile": 0.99295}, "CVE-2022-3700": {"epss_score": 0.00014, "epss_percentile": 0.02053}, "CVE-2022-3701": {"epss_score": 0.00033, "epss_percentile": 0.09187}, "CVE-2022-3702": {"epss_score": 0.00019, "epss_percentile": 0.04363}, "CVE-2022-3703": {"epss_score": 0.00066, "epss_percentile": 0.20736}, "CVE-2022-3704": {"epss_score": 0.00272, "epss_percentile": 0.50388}, "CVE-2022-3705": {"epss_score": 0.00377, "epss_percentile": 0.58694}, "CVE-2022-3706": {"epss_score": 0.00163, "epss_percentile": 0.37768}, "CVE-2022-3707": {"epss_score": 0.00012, "epss_percentile": 0.01285}, "CVE-2022-3708": {"epss_score": 0.00518, "epss_percentile": 0.66133}, "CVE-2022-3709": {"epss_score": 0.00264, "epss_percentile": 0.49715}, "CVE-2022-3710": {"epss_score": 0.00351, "epss_percentile": 0.57004}, "CVE-2022-3711": {"epss_score": 0.00462, "epss_percentile": 0.63615}, "CVE-2022-3713": {"epss_score": 0.0011, "epss_percentile": 0.30185}, "CVE-2022-3714": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-3715": {"epss_score": 0.00048, "epss_percentile": 0.15076}, "CVE-2022-3716": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-3720": {"epss_score": 0.00746, "epss_percentile": 0.72547}, "CVE-2022-3721": {"epss_score": 0.00128, "epss_percentile": 0.32974}, "CVE-2022-3723": {"epss_score": 0.00523, "epss_percentile": 0.66312}, "CVE-2022-3724": {"epss_score": 0.00376, "epss_percentile": 0.58677}, "CVE-2022-3725": {"epss_score": 0.00067, "epss_percentile": 0.2102}, "CVE-2022-3726": {"epss_score": 0.00334, "epss_percentile": 0.55688}, "CVE-2022-3728": {"epss_score": 0.00127, "epss_percentile": 0.32847}, "CVE-2022-3729": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-3730": {"epss_score": 0.0023, "epss_percentile": 0.4574}, "CVE-2022-3731": {"epss_score": 0.00179, "epss_percentile": 0.39791}, "CVE-2022-3732": {"epss_score": 0.00253, "epss_percentile": 0.48494}, "CVE-2022-3733": {"epss_score": 0.0023, "epss_percentile": 0.4574}, "CVE-2022-3734": {"epss_score": 0.00462, "epss_percentile": 0.63572}, "CVE-2022-3735": {"epss_score": 0.00328, "epss_percentile": 0.55285}, "CVE-2022-3736": {"epss_score": 0.01422, "epss_percentile": 0.80179}, "CVE-2022-3737": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2022-3738": {"epss_score": 0.00134, "epss_percentile": 0.33825}, "CVE-2022-3739": {"epss_score": 0.01813, "epss_percentile": 0.82375}, "CVE-2022-3740": {"epss_score": 0.00058, "epss_percentile": 0.18483}, "CVE-2022-3741": {"epss_score": 0.00361, "epss_percentile": 0.57698}, "CVE-2022-3742": {"epss_score": 0.00021, "epss_percentile": 0.04789}, "CVE-2022-3743": {"epss_score": 0.0003, "epss_percentile": 0.08211}, "CVE-2022-3744": {"epss_score": 0.00025, "epss_percentile": 0.06308}, "CVE-2022-3745": {"epss_score": 0.00031, "epss_percentile": 0.08576}, "CVE-2022-3746": {"epss_score": 0.00025, "epss_percentile": 0.06308}, "CVE-2022-3747": {"epss_score": 0.00847, "epss_percentile": 0.74351}, "CVE-2022-3748": {"epss_score": 0.001, "epss_percentile": 0.28537}, "CVE-2022-3750": {"epss_score": 0.00159, "epss_percentile": 0.37415}, "CVE-2022-3751": {"epss_score": 0.00241, "epss_percentile": 0.47323}, "CVE-2022-3752": {"epss_score": 0.01501, "epss_percentile": 0.80719}, "CVE-2022-3753": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-3754": {"epss_score": 0.00442, "epss_percentile": 0.62753}, "CVE-2022-3758": {"epss_score": 0.00286, "epss_percentile": 0.51739}, "CVE-2022-3759": {"epss_score": 0.00645, "epss_percentile": 0.70124}, "CVE-2022-3760": {"epss_score": 0.0007, "epss_percentile": 0.21974}, "CVE-2022-3761": {"epss_score": 0.00143, "epss_percentile": 0.35218}, "CVE-2022-3762": {"epss_score": 0.0092, "epss_percentile": 0.75469}, "CVE-2022-3763": {"epss_score": 0.0028, "epss_percentile": 0.51022}, "CVE-2022-3764": {"epss_score": 0.00558, "epss_percentile": 0.67581}, "CVE-2022-3765": {"epss_score": 0.00104, "epss_percentile": 0.29154}, "CVE-2022-3766": {"epss_score": 0.0424, "epss_percentile": 0.88432}, "CVE-2022-3767": {"epss_score": 0.00199, "epss_percentile": 0.42171}, "CVE-2022-3768": {"epss_score": 0.56283, "epss_percentile": 0.98017}, "CVE-2022-3769": {"epss_score": 0.00684, "epss_percentile": 0.71124}, "CVE-2022-3770": {"epss_score": 0.0028, "epss_percentile": 0.51022}, "CVE-2022-3771": {"epss_score": 0.00247, "epss_percentile": 0.47818}, "CVE-2022-3774": {"epss_score": 0.005, "epss_percentile": 0.65315}, "CVE-2022-3775": {"epss_score": 0.00078, "epss_percentile": 0.23563}, "CVE-2022-3776": {"epss_score": 0.00685, "epss_percentile": 0.71139}, "CVE-2022-3780": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2022-3781": {"epss_score": 0.001, "epss_percentile": 0.28497}, "CVE-2022-3782": {"epss_score": 0.00108, "epss_percentile": 0.29807}, "CVE-2022-3783": {"epss_score": 0.00299, "epss_percentile": 0.52853}, "CVE-2022-3784": {"epss_score": 0.00369, "epss_percentile": 0.58245}, "CVE-2022-3785": {"epss_score": 0.00386, "epss_percentile": 0.59234}, "CVE-2022-3786": {"epss_score": 0.20706, "epss_percentile": 0.95404}, "CVE-2022-3787": {"epss_score": 0.0001, "epss_percentile": 0.00885}, "CVE-2022-3789": {"epss_score": 0.0025, "epss_percentile": 0.48124}, "CVE-2022-3792": {"epss_score": 0.02346, "epss_percentile": 0.84452}, "CVE-2022-3793": {"epss_score": 0.00178, "epss_percentile": 0.39686}, "CVE-2022-3794": {"epss_score": 0.00175, "epss_percentile": 0.39327}, "CVE-2022-3797": {"epss_score": 0.00294, "epss_percentile": 0.52369}, "CVE-2022-3798": {"epss_score": 0.00282, "epss_percentile": 0.51288}, "CVE-2022-3799": {"epss_score": 0.00128, "epss_percentile": 0.33015}, "CVE-2022-3800": {"epss_score": 0.28747, "epss_percentile": 0.96381}, "CVE-2022-3801": {"epss_score": 0.02701, "epss_percentile": 0.85455}, "CVE-2022-3802": {"epss_score": 0.00282, "epss_percentile": 0.51288}, "CVE-2022-3803": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-3804": {"epss_score": 0.003, "epss_percentile": 0.52951}, "CVE-2022-3805": {"epss_score": 0.12506, "epss_percentile": 0.93695}, "CVE-2022-3806": {"epss_score": 0.00131, "epss_percentile": 0.33418}, "CVE-2022-3807": {"epss_score": 0.00296, "epss_percentile": 0.52598}, "CVE-2022-3809": {"epss_score": 0.0032, "epss_percentile": 0.54626}, "CVE-2022-3810": {"epss_score": 0.0032, "epss_percentile": 0.54626}, "CVE-2022-3811": {"epss_score": 0.00123, "epss_percentile": 0.32313}, "CVE-2022-3812": {"epss_score": 0.00296, "epss_percentile": 0.52598}, "CVE-2022-3813": {"epss_score": 0.00329, "epss_percentile": 0.554}, "CVE-2022-3814": {"epss_score": 0.00296, "epss_percentile": 0.52598}, "CVE-2022-3815": {"epss_score": 0.00296, "epss_percentile": 0.52598}, "CVE-2022-3816": {"epss_score": 0.00501, "epss_percentile": 0.65348}, "CVE-2022-3817": {"epss_score": 0.00501, "epss_percentile": 0.65348}, "CVE-2022-3818": {"epss_score": 0.00193, "epss_percentile": 0.41454}, "CVE-2022-3819": {"epss_score": 0.00106, "epss_percentile": 0.2944}, "CVE-2022-3820": {"epss_score": 0.00076, "epss_percentile": 0.23177}, "CVE-2022-3821": {"epss_score": 0.0002, "epss_percentile": 0.04494}, "CVE-2022-3822": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-3823": {"epss_score": 0.0028, "epss_percentile": 0.51011}, "CVE-2022-3824": {"epss_score": 0.00157, "epss_percentile": 0.37113}, "CVE-2022-3825": {"epss_score": 0.00267, "epss_percentile": 0.4999}, "CVE-2022-3826": {"epss_score": 0.00185, "epss_percentile": 0.4058}, "CVE-2022-3827": {"epss_score": 0.00364, "epss_percentile": 0.57928}, "CVE-2022-3828": {"epss_score": 0.00215, "epss_percentile": 0.44086}, "CVE-2022-3829": {"epss_score": 0.00169, "epss_percentile": 0.38566}, "CVE-2022-3830": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-3831": {"epss_score": 0.00137, "epss_percentile": 0.34321}, "CVE-2022-3832": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3833": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3834": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-3835": {"epss_score": 0.00339, "epss_percentile": 0.56172}, "CVE-2022-3836": {"epss_score": 0.00198, "epss_percentile": 0.4205}, "CVE-2022-3837": {"epss_score": 0.00298, "epss_percentile": 0.52815}, "CVE-2022-3838": {"epss_score": 0.00298, "epss_percentile": 0.52815}, "CVE-2022-3839": {"epss_score": 0.00234, "epss_percentile": 0.46083}, "CVE-2022-3840": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-3841": {"epss_score": 0.0006, "epss_percentile": 0.19216}, "CVE-2022-3842": {"epss_score": 0.03008, "epss_percentile": 0.8619}, "CVE-2022-3843": {"epss_score": 0.00292, "epss_percentile": 0.52269}, "CVE-2022-3844": {"epss_score": 0.0049, "epss_percentile": 0.6492}, "CVE-2022-3845": {"epss_score": 0.00311, "epss_percentile": 0.53921}, "CVE-2022-3846": {"epss_score": 0.00536, "epss_percentile": 0.66848}, "CVE-2022-3847": {"epss_score": 0.00093, "epss_percentile": 0.2674}, "CVE-2022-3848": {"epss_score": 0.00504, "epss_percentile": 0.65494}, "CVE-2022-3849": {"epss_score": 0.00504, "epss_percentile": 0.65494}, "CVE-2022-3850": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-3852": {"epss_score": 0.00207, "epss_percentile": 0.4313}, "CVE-2022-3853": {"epss_score": 0.00085, "epss_percentile": 0.25092}, "CVE-2022-3854": {"epss_score": 0.00055, "epss_percentile": 0.17438}, "CVE-2022-3855": {"epss_score": 0.00157, "epss_percentile": 0.37107}, "CVE-2022-3856": {"epss_score": 0.00746, "epss_percentile": 0.72547}, "CVE-2022-3858": {"epss_score": 0.00746, "epss_percentile": 0.72547}, "CVE-2022-3859": {"epss_score": 0.00179, "epss_percentile": 0.39746}, "CVE-2022-3860": {"epss_score": 0.007, "epss_percentile": 0.71481}, "CVE-2022-3861": {"epss_score": 0.03325, "epss_percentile": 0.86921}, "CVE-2022-3862": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3863": {"epss_score": 0.00258, "epss_percentile": 0.48995}, "CVE-2022-3864": {"epss_score": 0.00035, "epss_percentile": 0.09853}, "CVE-2022-3865": {"epss_score": 0.007, "epss_percentile": 0.71481}, "CVE-2022-3866": {"epss_score": 0.0024, "epss_percentile": 0.46955}, "CVE-2022-3867": {"epss_score": 0.00177, "epss_percentile": 0.39512}, "CVE-2022-3868": {"epss_score": 0.00246, "epss_percentile": 0.47739}, "CVE-2022-3869": {"epss_score": 0.13165, "epss_percentile": 0.9389}, "CVE-2022-3870": {"epss_score": 0.00371, "epss_percentile": 0.58403}, "CVE-2022-3872": {"epss_score": 0.00047, "epss_percentile": 0.14619}, "CVE-2022-3873": {"epss_score": 0.00645, "epss_percentile": 0.70115}, "CVE-2022-3874": {"epss_score": 0.00178, "epss_percentile": 0.39679}, "CVE-2022-3875": {"epss_score": 0.00221, "epss_percentile": 0.44657}, "CVE-2022-3876": {"epss_score": 0.00339, "epss_percentile": 0.56165}, "CVE-2022-3877": {"epss_score": 0.00591, "epss_percentile": 0.68598}, "CVE-2022-3878": {"epss_score": 0.00302, "epss_percentile": 0.53092}, "CVE-2022-3879": {"epss_score": 0.00148, "epss_percentile": 0.358}, "CVE-2022-3880": {"epss_score": 0.0018, "epss_percentile": 0.39921}, "CVE-2022-3881": {"epss_score": 0.00079, "epss_percentile": 0.23962}, "CVE-2022-3882": {"epss_score": 0.00148, "epss_percentile": 0.358}, "CVE-2022-3883": {"epss_score": 0.00135, "epss_percentile": 0.33992}, "CVE-2022-3884": {"epss_score": 0.00043, "epss_percentile": 0.13337}, "CVE-2022-3885": {"epss_score": 0.00221, "epss_percentile": 0.4464}, "CVE-2022-3886": {"epss_score": 0.00276, "epss_percentile": 0.50761}, "CVE-2022-3887": {"epss_score": 0.00314, "epss_percentile": 0.54105}, "CVE-2022-3888": {"epss_score": 0.00359, "epss_percentile": 0.57618}, "CVE-2022-3889": {"epss_score": 0.0028, "epss_percentile": 0.51016}, "CVE-2022-3890": {"epss_score": 0.00445, "epss_percentile": 0.62868}, "CVE-2022-3891": {"epss_score": 0.00952, "epss_percentile": 0.75876}, "CVE-2022-3892": {"epss_score": 0.00193, "epss_percentile": 0.41381}, "CVE-2022-3893": {"epss_score": 0.00271, "epss_percentile": 0.50288}, "CVE-2022-3894": {"epss_score": 0.0008, "epss_percentile": 0.24049}, "CVE-2022-3895": {"epss_score": 0.00186, "epss_percentile": 0.40615}, "CVE-2022-3896": {"epss_score": 0.02659, "epss_percentile": 0.85362}, "CVE-2022-3897": {"epss_score": 0.00242, "epss_percentile": 0.47344}, "CVE-2022-3898": {"epss_score": 0.00099, "epss_percentile": 0.27856}, "CVE-2022-3899": {"epss_score": 0.00135, "epss_percentile": 0.34018}, "CVE-2022-3900": {"epss_score": 0.17814, "epss_percentile": 0.94911}, "CVE-2022-3901": {"epss_score": 0.00138, "epss_percentile": 0.34346}, "CVE-2022-3902": {"epss_score": 0.00239, "epss_percentile": 0.46904}, "CVE-2022-3903": {"epss_score": 0.00015, "epss_percentile": 0.02427}, "CVE-2022-3904": {"epss_score": 0.26459, "epss_percentile": 0.96148}, "CVE-2022-3906": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3907": {"epss_score": 0.00583, "epss_percentile": 0.68331}, "CVE-2022-3908": {"epss_score": 0.06521, "epss_percentile": 0.90819}, "CVE-2022-3909": {"epss_score": 0.00339, "epss_percentile": 0.56172}, "CVE-2022-3910": {"epss_score": 0.00491, "epss_percentile": 0.64961}, "CVE-2022-3911": {"epss_score": 0.00208, "epss_percentile": 0.43258}, "CVE-2022-3912": {"epss_score": 0.0048, "epss_percentile": 0.6446}, "CVE-2022-3913": {"epss_score": 0.00169, "epss_percentile": 0.38641}, "CVE-2022-3915": {"epss_score": 0.03246, "epss_percentile": 0.86744}, "CVE-2022-3916": {"epss_score": 0.00226, "epss_percentile": 0.45361}, "CVE-2022-3917": {"epss_score": 0.00118, "epss_percentile": 0.31504}, "CVE-2022-3918": {"epss_score": 0.00117, "epss_percentile": 0.31296}, "CVE-2022-3919": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3920": {"epss_score": 0.00476, "epss_percentile": 0.64293}, "CVE-2022-3921": {"epss_score": 0.08911, "epss_percentile": 0.92315}, "CVE-2022-3922": {"epss_score": 0.00328, "epss_percentile": 0.55255}, "CVE-2022-3923": {"epss_score": 0.00103, "epss_percentile": 0.28997}, "CVE-2022-3924": {"epss_score": 0.00735, "epss_percentile": 0.72284}, "CVE-2022-3925": {"epss_score": 0.00729, "epss_percentile": 0.7213}, "CVE-2022-3926": {"epss_score": 0.00074, "epss_percentile": 0.22726}, "CVE-2022-3927": {"epss_score": 0.00437, "epss_percentile": 0.625}, "CVE-2022-3928": {"epss_score": 0.00093, "epss_percentile": 0.26694}, "CVE-2022-3929": {"epss_score": 0.00194, "epss_percentile": 0.41572}, "CVE-2022-3930": {"epss_score": 0.0032, "epss_percentile": 0.54579}, "CVE-2022-3933": {"epss_score": 0.05535, "epss_percentile": 0.89971}, "CVE-2022-3934": {"epss_score": 0.10041, "epss_percentile": 0.92825}, "CVE-2022-3935": {"epss_score": 0.00231, "epss_percentile": 0.45836}, "CVE-2022-3936": {"epss_score": 0.00339, "epss_percentile": 0.56172}, "CVE-2022-3937": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-3939": {"epss_score": 0.0041, "epss_percentile": 0.608}, "CVE-2022-3940": {"epss_score": 0.00378, "epss_percentile": 0.5879}, "CVE-2022-3941": {"epss_score": 0.0041, "epss_percentile": 0.60841}, "CVE-2022-3942": {"epss_score": 0.0024, "epss_percentile": 0.47232}, "CVE-2022-3943": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-3944": {"epss_score": 0.00273, "epss_percentile": 0.50428}, "CVE-2022-3945": {"epss_score": 0.00941, "epss_percentile": 0.75758}, "CVE-2022-3946": {"epss_score": 0.00149, "epss_percentile": 0.35969}, "CVE-2022-3947": {"epss_score": 0.00376, "epss_percentile": 0.58642}, "CVE-2022-3948": {"epss_score": 0.00297, "epss_percentile": 0.52711}, "CVE-2022-3949": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-3950": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-3952": {"epss_score": 0.0009, "epss_percentile": 0.26148}, "CVE-2022-3955": {"epss_score": 0.00356, "epss_percentile": 0.57332}, "CVE-2022-3956": {"epss_score": 0.00356, "epss_percentile": 0.57349}, "CVE-2022-3957": {"epss_score": 0.00069, "epss_percentile": 0.21523}, "CVE-2022-3958": {"epss_score": 0.00298, "epss_percentile": 0.52822}, "CVE-2022-3959": {"epss_score": 0.01136, "epss_percentile": 0.77916}, "CVE-2022-3960": {"epss_score": 0.00173, "epss_percentile": 0.39133}, "CVE-2022-3961": {"epss_score": 0.00554, "epss_percentile": 0.67452}, "CVE-2022-3962": {"epss_score": 0.00107, "epss_percentile": 0.29735}, "CVE-2022-3963": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-3964": {"epss_score": 0.00064, "epss_percentile": 0.2013}, "CVE-2022-3965": {"epss_score": 0.0005, "epss_percentile": 0.15967}, "CVE-2022-3966": {"epss_score": 0.00458, "epss_percentile": 0.6343}, "CVE-2022-3967": {"epss_score": 0.00054, "epss_percentile": 0.1723}, "CVE-2022-3968": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-3969": {"epss_score": 0.00083, "epss_percentile": 0.24711}, "CVE-2022-3970": {"epss_score": 0.00105, "epss_percentile": 0.29393}, "CVE-2022-3971": {"epss_score": 0.00235, "epss_percentile": 0.46243}, "CVE-2022-3972": {"epss_score": 0.00281, "epss_percentile": 0.51108}, "CVE-2022-3973": {"epss_score": 0.00281, "epss_percentile": 0.51108}, "CVE-2022-3974": {"epss_score": 0.00522, "epss_percentile": 0.66259}, "CVE-2022-3975": {"epss_score": 0.0027, "epss_percentile": 0.50267}, "CVE-2022-3976": {"epss_score": 0.00204, "epss_percentile": 0.42593}, "CVE-2022-3977": {"epss_score": 0.00026, "epss_percentile": 0.0656}, "CVE-2022-3978": {"epss_score": 0.00127, "epss_percentile": 0.3281}, "CVE-2022-3979": {"epss_score": 0.00554, "epss_percentile": 0.67452}, "CVE-2022-3980": {"epss_score": 0.86806, "epss_percentile": 0.99398}, "CVE-2022-3981": {"epss_score": 0.00924, "epss_percentile": 0.75521}, "CVE-2022-3982": {"epss_score": 0.82236, "epss_percentile": 0.99182}, "CVE-2022-3983": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-3984": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-3985": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-3986": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-3987": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-3988": {"epss_score": 0.00299, "epss_percentile": 0.52853}, "CVE-2022-3989": {"epss_score": 0.00955, "epss_percentile": 0.75915}, "CVE-2022-3990": {"epss_score": 0.00134, "epss_percentile": 0.33798}, "CVE-2022-3991": {"epss_score": 0.00122, "epss_percentile": 0.32043}, "CVE-2022-3992": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-3993": {"epss_score": 0.01093, "epss_percentile": 0.77482}, "CVE-2022-3994": {"epss_score": 0.00355, "epss_percentile": 0.57279}, "CVE-2022-3995": {"epss_score": 0.00111, "epss_percentile": 0.30252}, "CVE-2022-3996": {"epss_score": 0.00172, "epss_percentile": 0.39019}, "CVE-2022-3997": {"epss_score": 0.00139, "epss_percentile": 0.34614}, "CVE-2022-3998": {"epss_score": 0.00193, "epss_percentile": 0.41403}, "CVE-2022-3999": {"epss_score": 0.00176, "epss_percentile": 0.39383}, "CVE-2022-40000": {"epss_score": 0.00168, "epss_percentile": 0.3844}, "CVE-2022-40001": {"epss_score": 0.00168, "epss_percentile": 0.3844}, "CVE-2022-40002": {"epss_score": 0.00168, "epss_percentile": 0.3844}, "CVE-2022-40004": {"epss_score": 0.00909, "epss_percentile": 0.75296}, "CVE-2022-40005": {"epss_score": 0.05028, "epss_percentile": 0.89411}, "CVE-2022-40008": {"epss_score": 0.00476, "epss_percentile": 0.64278}, "CVE-2022-40009": {"epss_score": 0.00527, "epss_percentile": 0.66528}, "CVE-2022-40010": {"epss_score": 0.00071, "epss_percentile": 0.22149}, "CVE-2022-40011": {"epss_score": 0.00296, "epss_percentile": 0.52554}, "CVE-2022-40016": {"epss_score": 0.00229, "epss_percentile": 0.45647}, "CVE-2022-40021": {"epss_score": 0.00391, "epss_percentile": 0.59588}, "CVE-2022-40022": {"epss_score": 0.90838, "epss_percentile": 0.99604}, "CVE-2022-40023": {"epss_score": 0.00955, "epss_percentile": 0.7591}, "CVE-2022-40026": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40027": {"epss_score": 0.0025, "epss_percentile": 0.48148}, "CVE-2022-40028": {"epss_score": 0.00305, "epss_percentile": 0.53391}, "CVE-2022-40029": {"epss_score": 0.00305, "epss_percentile": 0.53391}, "CVE-2022-40030": {"epss_score": 0.00619, "epss_percentile": 0.69402}, "CVE-2022-40032": {"epss_score": 0.7301, "epss_percentile": 0.98732}, "CVE-2022-40034": {"epss_score": 0.00142, "epss_percentile": 0.34972}, "CVE-2022-40035": {"epss_score": 0.00385, "epss_percentile": 0.59198}, "CVE-2022-40036": {"epss_score": 0.00123, "epss_percentile": 0.32207}, "CVE-2022-40037": {"epss_score": 0.01548, "epss_percentile": 0.80975}, "CVE-2022-40043": {"epss_score": 0.00784, "epss_percentile": 0.73242}, "CVE-2022-40044": {"epss_score": 0.00156, "epss_percentile": 0.36918}, "CVE-2022-40047": {"epss_score": 0.19551, "epss_percentile": 0.95205}, "CVE-2022-40048": {"epss_score": 0.02457, "epss_percentile": 0.84802}, "CVE-2022-40049": {"epss_score": 0.00213, "epss_percentile": 0.43907}, "CVE-2022-40050": {"epss_score": 0.00411, "epss_percentile": 0.60885}, "CVE-2022-40055": {"epss_score": 0.00412, "epss_percentile": 0.60944}, "CVE-2022-40067": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-40068": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-40069": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-40070": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-40071": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-40072": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-40073": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-40074": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-40075": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-40076": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-40080": {"epss_score": 0.00151, "epss_percentile": 0.36319}, "CVE-2022-40082": {"epss_score": 0.00372, "epss_percentile": 0.58421}, "CVE-2022-40083": {"epss_score": 0.83084, "epss_percentile": 0.99231}, "CVE-2022-40084": {"epss_score": 0.0022, "epss_percentile": 0.44612}, "CVE-2022-40087": {"epss_score": 0.00989, "epss_percentile": 0.76365}, "CVE-2022-40088": {"epss_score": 0.00426, "epss_percentile": 0.61765}, "CVE-2022-40089": {"epss_score": 0.02869, "epss_percentile": 0.85871}, "CVE-2022-40090": {"epss_score": 0.00012, "epss_percentile": 0.01203}, "CVE-2022-40091": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40092": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40093": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40097": {"epss_score": 0.00207, "epss_percentile": 0.43092}, "CVE-2022-40098": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40099": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40100": {"epss_score": 0.03087, "epss_percentile": 0.86389}, "CVE-2022-40101": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-40102": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-40103": {"epss_score": 0.00065, "epss_percentile": 0.20439}, "CVE-2022-40104": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-40105": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-40106": {"epss_score": 0.00268, "epss_percentile": 0.50093}, "CVE-2022-40107": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-40109": {"epss_score": 0.00306, "epss_percentile": 0.53413}, "CVE-2022-40110": {"epss_score": 0.00395, "epss_percentile": 0.59811}, "CVE-2022-40111": {"epss_score": 0.00405, "epss_percentile": 0.60456}, "CVE-2022-40112": {"epss_score": 0.00395, "epss_percentile": 0.59811}, "CVE-2022-40113": {"epss_score": 0.00296, "epss_percentile": 0.52587}, "CVE-2022-40114": {"epss_score": 0.00294, "epss_percentile": 0.52431}, "CVE-2022-40115": {"epss_score": 0.00185, "epss_percentile": 0.40577}, "CVE-2022-40116": {"epss_score": 0.00294, "epss_percentile": 0.52431}, "CVE-2022-40117": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-40118": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-40119": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-40120": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-40121": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-40122": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2022-40123": {"epss_score": 0.00934, "epss_percentile": 0.75646}, "CVE-2022-40126": {"epss_score": 0.00108, "epss_percentile": 0.29851}, "CVE-2022-40127": {"epss_score": 0.93736, "epss_percentile": 0.99838}, "CVE-2022-40128": {"epss_score": 0.0011, "epss_percentile": 0.30119}, "CVE-2022-40129": {"epss_score": 0.00554, "epss_percentile": 0.67452}, "CVE-2022-40130": {"epss_score": 0.00295, "epss_percentile": 0.52493}, "CVE-2022-40131": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-40132": {"epss_score": 0.00106, "epss_percentile": 0.29533}, "CVE-2022-40133": {"epss_score": 0.00025, "epss_percentile": 0.06049}, "CVE-2022-40134": {"epss_score": 0.0005, "epss_percentile": 0.15975}, "CVE-2022-40135": {"epss_score": 0.0005, "epss_percentile": 0.15975}, "CVE-2022-40136": {"epss_score": 0.0005, "epss_percentile": 0.15975}, "CVE-2022-40137": {"epss_score": 0.00042, "epss_percentile": 0.12498}, "CVE-2022-40138": {"epss_score": 0.01219, "epss_percentile": 0.78617}, "CVE-2022-40139": {"epss_score": 0.12882, "epss_percentile": 0.93811}, "CVE-2022-40140": {"epss_score": 0.00136, "epss_percentile": 0.3411}, "CVE-2022-40141": {"epss_score": 0.00345, "epss_percentile": 0.56586}, "CVE-2022-40142": {"epss_score": 0.00073, "epss_percentile": 0.22621}, "CVE-2022-40143": {"epss_score": 0.00076, "epss_percentile": 0.2327}, "CVE-2022-40144": {"epss_score": 0.00488, "epss_percentile": 0.64846}, "CVE-2022-40145": {"epss_score": 0.05385, "epss_percentile": 0.89819}, "CVE-2022-40146": {"epss_score": 0.41222, "epss_percentile": 0.9726}, "CVE-2022-40147": {"epss_score": 0.0014, "epss_percentile": 0.34781}, "CVE-2022-40149": {"epss_score": 0.00521, "epss_percentile": 0.66245}, "CVE-2022-40150": {"epss_score": 0.00055, "epss_percentile": 0.17428}, "CVE-2022-40151": {"epss_score": 0.00245, "epss_percentile": 0.47649}, "CVE-2022-40152": {"epss_score": 0.00762, "epss_percentile": 0.7284}, "CVE-2022-40159": {"epss_score": 0.01872, "epss_percentile": 0.82638}, "CVE-2022-40160": {"epss_score": 0.01872, "epss_percentile": 0.82638}, "CVE-2022-40176": {"epss_score": 0.00605, "epss_percentile": 0.68976}, "CVE-2022-40177": {"epss_score": 0.00351, "epss_percentile": 0.57006}, "CVE-2022-40178": {"epss_score": 0.00274, "epss_percentile": 0.50532}, "CVE-2022-40179": {"epss_score": 0.00204, "epss_percentile": 0.42632}, "CVE-2022-40180": {"epss_score": 0.00133, "epss_percentile": 0.33676}, "CVE-2022-40181": {"epss_score": 0.00728, "epss_percentile": 0.72116}, "CVE-2022-40182": {"epss_score": 0.00569, "epss_percentile": 0.67912}, "CVE-2022-40183": {"epss_score": 0.00542, "epss_percentile": 0.67078}, "CVE-2022-40184": {"epss_score": 0.00237, "epss_percentile": 0.46721}, "CVE-2022-40186": {"epss_score": 0.00437, "epss_percentile": 0.62513}, "CVE-2022-40187": {"epss_score": 0.00128, "epss_percentile": 0.33036}, "CVE-2022-40188": {"epss_score": 0.00309, "epss_percentile": 0.53669}, "CVE-2022-40189": {"epss_score": 0.24288, "epss_percentile": 0.95901}, "CVE-2022-40190": {"epss_score": 0.00226, "epss_percentile": 0.45254}, "CVE-2022-40191": {"epss_score": 0.0026, "epss_percentile": 0.49178}, "CVE-2022-40192": {"epss_score": 0.0017, "epss_percentile": 0.38718}, "CVE-2022-40193": {"epss_score": 0.00469, "epss_percentile": 0.63946}, "CVE-2022-40194": {"epss_score": 0.0069, "epss_percentile": 0.71237}, "CVE-2022-40195": {"epss_score": 0.00532, "epss_percentile": 0.66683}, "CVE-2022-40196": {"epss_score": 0.001, "epss_percentile": 0.28447}, "CVE-2022-40198": {"epss_score": 0.00075, "epss_percentile": 0.23026}, "CVE-2022-40199": {"epss_score": 0.0024, "epss_percentile": 0.47229}, "CVE-2022-40200": {"epss_score": 0.00849, "epss_percentile": 0.74369}, "CVE-2022-40201": {"epss_score": 0.00104, "epss_percentile": 0.29158}, "CVE-2022-40202": {"epss_score": 0.00957, "epss_percentile": 0.75934}, "CVE-2022-40203": {"epss_score": 0.00101, "epss_percentile": 0.28683}, "CVE-2022-40204": {"epss_score": 0.00677, "epss_percentile": 0.70948}, "CVE-2022-40205": {"epss_score": 0.00188, "epss_percentile": 0.40874}, "CVE-2022-40206": {"epss_score": 0.00211, "epss_percentile": 0.43647}, "CVE-2022-40207": {"epss_score": 0.00069, "epss_percentile": 0.2151}, "CVE-2022-40208": {"epss_score": 0.00077, "epss_percentile": 0.23523}, "CVE-2022-40209": {"epss_score": 0.00287, "epss_percentile": 0.5185}, "CVE-2022-40210": {"epss_score": 0.00061, "epss_percentile": 0.19301}, "CVE-2022-40211": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2022-40213": {"epss_score": 0.0026, "epss_percentile": 0.49178}, "CVE-2022-40215": {"epss_score": 0.00254, "epss_percentile": 0.48507}, "CVE-2022-40216": {"epss_score": 0.00191, "epss_percentile": 0.41209}, "CVE-2022-40217": {"epss_score": 0.01121, "epss_percentile": 0.77775}, "CVE-2022-40218": {"epss_score": 0.00234, "epss_percentile": 0.46154}, "CVE-2022-40219": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-40220": {"epss_score": 0.0034, "epss_percentile": 0.56239}, "CVE-2022-40222": {"epss_score": 0.00954, "epss_percentile": 0.75901}, "CVE-2022-40223": {"epss_score": 0.00346, "epss_percentile": 0.56605}, "CVE-2022-40224": {"epss_score": 0.10104, "epss_percentile": 0.92851}, "CVE-2022-40225": {"epss_score": 0.00267, "epss_percentile": 0.49972}, "CVE-2022-40226": {"epss_score": 0.00344, "epss_percentile": 0.56505}, "CVE-2022-40227": {"epss_score": 0.00101, "epss_percentile": 0.28581}, "CVE-2022-40228": {"epss_score": 0.00059, "epss_percentile": 0.18866}, "CVE-2022-40230": {"epss_score": 0.00291, "epss_percentile": 0.52203}, "CVE-2022-40231": {"epss_score": 0.00077, "epss_percentile": 0.23429}, "CVE-2022-40232": {"epss_score": 0.00064, "epss_percentile": 0.20286}, "CVE-2022-40233": {"epss_score": 0.00117, "epss_percentile": 0.31352}, "CVE-2022-40234": {"epss_score": 0.00154, "epss_percentile": 0.36696}, "CVE-2022-40235": {"epss_score": 0.00462, "epss_percentile": 0.6358}, "CVE-2022-40237": {"epss_score": 0.00071, "epss_percentile": 0.22074}, "CVE-2022-40238": {"epss_score": 0.04288, "epss_percentile": 0.88498}, "CVE-2022-40242": {"epss_score": 0.00137, "epss_percentile": 0.3427}, "CVE-2022-40246": {"epss_score": 0.00161, "epss_percentile": 0.37575}, "CVE-2022-40248": {"epss_score": 0.00415, "epss_percentile": 0.61121}, "CVE-2022-40250": {"epss_score": 0.00206, "epss_percentile": 0.42945}, "CVE-2022-40257": {"epss_score": 0.00386, "epss_percentile": 0.59258}, "CVE-2022-40258": {"epss_score": 0.00126, "epss_percentile": 0.32658}, "CVE-2022-40259": {"epss_score": 0.00302, "epss_percentile": 0.5313}, "CVE-2022-40261": {"epss_score": 0.00132, "epss_percentile": 0.33508}, "CVE-2022-40262": {"epss_score": 0.00072, "epss_percentile": 0.22442}, "CVE-2022-40263": {"epss_score": 0.0004, "epss_percentile": 0.12024}, "CVE-2022-40264": {"epss_score": 0.00247, "epss_percentile": 0.47865}, "CVE-2022-40265": {"epss_score": 0.00279, "epss_percentile": 0.50957}, "CVE-2022-40266": {"epss_score": 0.00484, "epss_percentile": 0.64661}, "CVE-2022-40267": {"epss_score": 0.06181, "epss_percentile": 0.90538}, "CVE-2022-40268": {"epss_score": 0.0035, "epss_percentile": 0.56946}, "CVE-2022-40269": {"epss_score": 0.00196, "epss_percentile": 0.41735}, "CVE-2022-40274": {"epss_score": 0.0025, "epss_percentile": 0.48145}, "CVE-2022-40276": {"epss_score": 0.00068, "epss_percentile": 0.21216}, "CVE-2022-40277": {"epss_score": 0.00113, "epss_percentile": 0.30644}, "CVE-2022-40278": {"epss_score": 0.00791, "epss_percentile": 0.73396}, "CVE-2022-40279": {"epss_score": 0.00743, "epss_percentile": 0.72498}, "CVE-2022-40280": {"epss_score": 0.00417, "epss_percentile": 0.61226}, "CVE-2022-40281": {"epss_score": 0.0028, "epss_percentile": 0.5101}, "CVE-2022-40282": {"epss_score": 0.00619, "epss_percentile": 0.69394}, "CVE-2022-40284": {"epss_score": 0.00043, "epss_percentile": 0.13271}, "CVE-2022-40287": {"epss_score": 0.00388, "epss_percentile": 0.59361}, "CVE-2022-40288": {"epss_score": 0.00388, "epss_percentile": 0.59361}, "CVE-2022-40289": {"epss_score": 0.00988, "epss_percentile": 0.76351}, "CVE-2022-40290": {"epss_score": 0.00482, "epss_percentile": 0.64523}, "CVE-2022-40291": {"epss_score": 0.00182, "epss_percentile": 0.40242}, "CVE-2022-40292": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2022-40293": {"epss_score": 0.00344, "epss_percentile": 0.56545}, "CVE-2022-40294": {"epss_score": 0.00419, "epss_percentile": 0.61384}, "CVE-2022-40295": {"epss_score": 0.00139, "epss_percentile": 0.34625}, "CVE-2022-40296": {"epss_score": 0.00344, "epss_percentile": 0.56545}, "CVE-2022-40297": {"epss_score": 0.01943, "epss_percentile": 0.82992}, "CVE-2022-40298": {"epss_score": 0.00246, "epss_percentile": 0.47768}, "CVE-2022-40299": {"epss_score": 0.00088, "epss_percentile": 0.25762}, "CVE-2022-40300": {"epss_score": 0.38921, "epss_percentile": 0.97127}, "CVE-2022-40302": {"epss_score": 0.00159, "epss_percentile": 0.37336}, "CVE-2022-40303": {"epss_score": 0.00149, "epss_percentile": 0.3594}, "CVE-2022-40304": {"epss_score": 0.00106, "epss_percentile": 0.29565}, "CVE-2022-40305": {"epss_score": 0.00782, "epss_percentile": 0.73212}, "CVE-2022-40306": {"epss_score": 0.0056, "epss_percentile": 0.67652}, "CVE-2022-40307": {"epss_score": 0.00022, "epss_percentile": 0.05274}, "CVE-2022-40308": {"epss_score": 0.0109, "epss_percentile": 0.77453}, "CVE-2022-40309": {"epss_score": 0.01137, "epss_percentile": 0.77927}, "CVE-2022-40310": {"epss_score": 0.00142, "epss_percentile": 0.35028}, "CVE-2022-40311": {"epss_score": 0.00298, "epss_percentile": 0.52815}, "CVE-2022-40312": {"epss_score": 0.00072, "epss_percentile": 0.22411}, "CVE-2022-40313": {"epss_score": 0.00754, "epss_percentile": 0.72699}, "CVE-2022-40314": {"epss_score": 0.09784, "epss_percentile": 0.92701}, "CVE-2022-40315": {"epss_score": 0.00645, "epss_percentile": 0.70099}, "CVE-2022-40316": {"epss_score": 0.0024, "epss_percentile": 0.46942}, "CVE-2022-40317": {"epss_score": 0.02631, "epss_percentile": 0.85282}, "CVE-2022-40318": {"epss_score": 0.00121, "epss_percentile": 0.31993}, "CVE-2022-40319": {"epss_score": 0.10823, "epss_percentile": 0.93123}, "CVE-2022-40320": {"epss_score": 0.00109, "epss_percentile": 0.29971}, "CVE-2022-40322": {"epss_score": 0.00669, "epss_percentile": 0.70759}, "CVE-2022-40323": {"epss_score": 0.00669, "epss_percentile": 0.70759}, "CVE-2022-40324": {"epss_score": 0.00669, "epss_percentile": 0.70759}, "CVE-2022-40325": {"epss_score": 0.00669, "epss_percentile": 0.70759}, "CVE-2022-40337": {"epss_score": 0.01364, "epss_percentile": 0.79771}, "CVE-2022-40341": {"epss_score": 0.01329, "epss_percentile": 0.79505}, "CVE-2022-40347": {"epss_score": 0.02074, "epss_percentile": 0.83499}, "CVE-2022-40348": {"epss_score": 0.00698, "epss_percentile": 0.7142}, "CVE-2022-40352": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40353": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40354": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40357": {"epss_score": 0.02492, "epss_percentile": 0.849}, "CVE-2022-40358": {"epss_score": 0.00285, "epss_percentile": 0.51648}, "CVE-2022-40359": {"epss_score": 0.12355, "epss_percentile": 0.93647}, "CVE-2022-40361": {"epss_score": 0.00263, "epss_percentile": 0.49548}, "CVE-2022-40363": {"epss_score": 0.00182, "epss_percentile": 0.40269}, "CVE-2022-40365": {"epss_score": 0.0047, "epss_percentile": 0.63976}, "CVE-2022-40373": {"epss_score": 0.00349, "epss_percentile": 0.56875}, "CVE-2022-40402": {"epss_score": 0.00243, "epss_percentile": 0.47514}, "CVE-2022-40403": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40404": {"epss_score": 0.00243, "epss_percentile": 0.47514}, "CVE-2022-40405": {"epss_score": 0.00251, "epss_percentile": 0.48283}, "CVE-2022-40407": {"epss_score": 0.0103, "epss_percentile": 0.76842}, "CVE-2022-40408": {"epss_score": 0.00285, "epss_percentile": 0.51648}, "CVE-2022-40424": {"epss_score": 0.00682, "epss_percentile": 0.71084}, "CVE-2022-40425": {"epss_score": 0.0037, "epss_percentile": 0.58339}, "CVE-2022-40426": {"epss_score": 0.0037, "epss_percentile": 0.58339}, "CVE-2022-40427": {"epss_score": 0.00682, "epss_percentile": 0.71084}, "CVE-2022-40428": {"epss_score": 0.0037, "epss_percentile": 0.58339}, "CVE-2022-40429": {"epss_score": 0.0037, "epss_percentile": 0.58339}, "CVE-2022-40430": {"epss_score": 0.0037, "epss_percentile": 0.58339}, "CVE-2022-40431": {"epss_score": 0.0037, "epss_percentile": 0.58339}, "CVE-2022-40432": {"epss_score": 0.0041, "epss_percentile": 0.6084}, "CVE-2022-40434": {"epss_score": 0.00515, "epss_percentile": 0.66001}, "CVE-2022-40435": {"epss_score": 0.0044, "epss_percentile": 0.62615}, "CVE-2022-40438": {"epss_score": 0.00289, "epss_percentile": 0.51981}, "CVE-2022-40439": {"epss_score": 0.00418, "epss_percentile": 0.61273}, "CVE-2022-40440": {"epss_score": 0.00461, "epss_percentile": 0.63546}, "CVE-2022-40443": {"epss_score": 0.03595, "epss_percentile": 0.87404}, "CVE-2022-40444": {"epss_score": 0.00252, "epss_percentile": 0.48379}, "CVE-2022-40446": {"epss_score": 0.00241, "epss_percentile": 0.47329}, "CVE-2022-40447": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40468": {"epss_score": 0.00124, "epss_percentile": 0.32356}, "CVE-2022-40469": {"epss_score": 0.04881, "epss_percentile": 0.89248}, "CVE-2022-40470": {"epss_score": 0.03616, "epss_percentile": 0.87437}, "CVE-2022-40471": {"epss_score": 0.87609, "epss_percentile": 0.99435}, "CVE-2022-40472": {"epss_score": 0.00684, "epss_percentile": 0.71109}, "CVE-2022-40475": {"epss_score": 0.01625, "epss_percentile": 0.81421}, "CVE-2022-40476": {"epss_score": 0.0016, "epss_percentile": 0.37429}, "CVE-2022-40480": {"epss_score": 0.00095, "epss_percentile": 0.27127}, "CVE-2022-40482": {"epss_score": 0.00298, "epss_percentile": 0.52794}, "CVE-2022-40483": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-40484": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-40485": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-40486": {"epss_score": 0.01051, "epss_percentile": 0.77078}, "CVE-2022-40487": {"epss_score": 0.0024, "epss_percentile": 0.47222}, "CVE-2022-40488": {"epss_score": 0.00227, "epss_percentile": 0.45455}, "CVE-2022-40489": {"epss_score": 0.0005, "epss_percentile": 0.15767}, "CVE-2022-40490": {"epss_score": 0.00121, "epss_percentile": 0.31934}, "CVE-2022-40494": {"epss_score": 0.14899, "epss_percentile": 0.94317}, "CVE-2022-40497": {"epss_score": 0.02302, "epss_percentile": 0.84315}, "CVE-2022-40502": {"epss_score": 0.00122, "epss_percentile": 0.32129}, "CVE-2022-40503": {"epss_score": 0.00085, "epss_percentile": 0.25106}, "CVE-2022-40504": {"epss_score": 0.00123, "epss_percentile": 0.32263}, "CVE-2022-40505": {"epss_score": 0.00077, "epss_percentile": 0.23525}, "CVE-2022-40507": {"epss_score": 0.02539, "epss_percentile": 0.85044}, "CVE-2022-40508": {"epss_score": 0.00123, "epss_percentile": 0.32263}, "CVE-2022-40510": {"epss_score": 0.00124, "epss_percentile": 0.32395}, "CVE-2022-40512": {"epss_score": 0.00165, "epss_percentile": 0.38031}, "CVE-2022-40513": {"epss_score": 0.00143, "epss_percentile": 0.35174}, "CVE-2022-40514": {"epss_score": 0.00192, "epss_percentile": 0.41373}, "CVE-2022-40515": {"epss_score": 0.00095, "epss_percentile": 0.27085}, "CVE-2022-40516": {"epss_score": 0.03852, "epss_percentile": 0.87851}, "CVE-2022-40517": {"epss_score": 0.00092, "epss_percentile": 0.26486}, "CVE-2022-40518": {"epss_score": 0.00056, "epss_percentile": 0.17713}, "CVE-2022-40519": {"epss_score": 0.00056, "epss_percentile": 0.17713}, "CVE-2022-40520": {"epss_score": 0.03852, "epss_percentile": 0.87851}, "CVE-2022-40521": {"epss_score": 0.00106, "epss_percentile": 0.29565}, "CVE-2022-40522": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2022-40523": {"epss_score": 0.0004, "epss_percentile": 0.12019}, "CVE-2022-40524": {"epss_score": 0.0002, "epss_percentile": 0.04503}, "CVE-2022-40525": {"epss_score": 0.0004, "epss_percentile": 0.12019}, "CVE-2022-40527": {"epss_score": 0.00164, "epss_percentile": 0.37984}, "CVE-2022-40529": {"epss_score": 0.00033, "epss_percentile": 0.09191}, "CVE-2022-40530": {"epss_score": 0.00058, "epss_percentile": 0.18421}, "CVE-2022-40531": {"epss_score": 0.00071, "epss_percentile": 0.21996}, "CVE-2022-40532": {"epss_score": 0.00057, "epss_percentile": 0.17995}, "CVE-2022-40533": {"epss_score": 0.00044, "epss_percentile": 0.1363}, "CVE-2022-40534": {"epss_score": 0.00044, "epss_percentile": 0.13647}, "CVE-2022-40535": {"epss_score": 0.00139, "epss_percentile": 0.34637}, "CVE-2022-40536": {"epss_score": 0.00108, "epss_percentile": 0.29801}, "CVE-2022-40537": {"epss_score": 0.00095, "epss_percentile": 0.27085}, "CVE-2022-40538": {"epss_score": 0.00145, "epss_percentile": 0.35523}, "CVE-2022-40539": {"epss_score": 0.00038, "epss_percentile": 0.11134}, "CVE-2022-40540": {"epss_score": 0.00064, "epss_percentile": 0.20288}, "CVE-2022-40602": {"epss_score": 0.014, "epss_percentile": 0.80005}, "CVE-2022-40603": {"epss_score": 0.00669, "epss_percentile": 0.70759}, "CVE-2022-40604": {"epss_score": 0.02103, "epss_percentile": 0.83615}, "CVE-2022-40605": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-40606": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-40607": {"epss_score": 0.00382, "epss_percentile": 0.59033}, "CVE-2022-40608": {"epss_score": 0.00697, "epss_percentile": 0.71413}, "CVE-2022-40609": {"epss_score": 0.00089, "epss_percentile": 0.25801}, "CVE-2022-40615": {"epss_score": 0.00104, "epss_percentile": 0.29159}, "CVE-2022-40616": {"epss_score": 0.00132, "epss_percentile": 0.33527}, "CVE-2022-40617": {"epss_score": 0.00195, "epss_percentile": 0.41708}, "CVE-2022-40621": {"epss_score": 0.00294, "epss_percentile": 0.52359}, "CVE-2022-40622": {"epss_score": 0.00103, "epss_percentile": 0.28921}, "CVE-2022-40623": {"epss_score": 0.00309, "epss_percentile": 0.53681}, "CVE-2022-40624": {"epss_score": 0.91092, "epss_percentile": 0.99619}, "CVE-2022-40626": {"epss_score": 0.01866, "epss_percentile": 0.82616}, "CVE-2022-40628": {"epss_score": 0.04937, "epss_percentile": 0.89304}, "CVE-2022-40629": {"epss_score": 0.02313, "epss_percentile": 0.84346}, "CVE-2022-40630": {"epss_score": 0.00449, "epss_percentile": 0.63033}, "CVE-2022-40631": {"epss_score": 0.00673, "epss_percentile": 0.70835}, "CVE-2022-40632": {"epss_score": 0.00096, "epss_percentile": 0.27448}, "CVE-2022-40633": {"epss_score": 0.00037, "epss_percentile": 0.10676}, "CVE-2022-40634": {"epss_score": 0.14522, "epss_percentile": 0.9423}, "CVE-2022-40635": {"epss_score": 0.1299, "epss_percentile": 0.93837}, "CVE-2022-40636": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40637": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40638": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40639": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40640": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40641": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40642": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40643": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40644": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40645": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40646": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40647": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40648": {"epss_score": 0.00357, "epss_percentile": 0.57462}, "CVE-2022-40649": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40650": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40651": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40652": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40653": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40654": {"epss_score": 0.0021, "epss_percentile": 0.43463}, "CVE-2022-40655": {"epss_score": 0.00316, "epss_percentile": 0.54238}, "CVE-2022-40656": {"epss_score": 0.00316, "epss_percentile": 0.54238}, "CVE-2022-40657": {"epss_score": 0.00316, "epss_percentile": 0.54238}, "CVE-2022-40658": {"epss_score": 0.00296, "epss_percentile": 0.52571}, "CVE-2022-40659": {"epss_score": 0.00316, "epss_percentile": 0.54238}, "CVE-2022-40660": {"epss_score": 0.00316, "epss_percentile": 0.54238}, "CVE-2022-40661": {"epss_score": 0.00687, "epss_percentile": 0.71188}, "CVE-2022-40662": {"epss_score": 0.00264, "epss_percentile": 0.4974}, "CVE-2022-40663": {"epss_score": 0.00264, "epss_percentile": 0.4974}, "CVE-2022-40664": {"epss_score": 0.00528, "epss_percentile": 0.66547}, "CVE-2022-40671": {"epss_score": 0.00106, "epss_percentile": 0.29533}, "CVE-2022-40672": {"epss_score": 0.00487, "epss_percentile": 0.64806}, "CVE-2022-40673": {"epss_score": 0.00076, "epss_percentile": 0.23078}, "CVE-2022-40674": {"epss_score": 0.00935, "epss_percentile": 0.75667}, "CVE-2022-40675": {"epss_score": 0.00312, "epss_percentile": 0.54003}, "CVE-2022-40676": {"epss_score": 0.01379, "epss_percentile": 0.79853}, "CVE-2022-40677": {"epss_score": 0.00363, "epss_percentile": 0.57847}, "CVE-2022-40678": {"epss_score": 0.00053, "epss_percentile": 0.1703}, "CVE-2022-40679": {"epss_score": 0.00123, "epss_percentile": 0.32238}, "CVE-2022-40680": {"epss_score": 0.00579, "epss_percentile": 0.68235}, "CVE-2022-40681": {"epss_score": 0.00042, "epss_percentile": 0.12623}, "CVE-2022-40682": {"epss_score": 0.00055, "epss_percentile": 0.17417}, "CVE-2022-40683": {"epss_score": 0.00086, "epss_percentile": 0.25292}, "CVE-2022-40684": {"epss_score": 0.94427, "epss_percentile": 0.99981}, "CVE-2022-40685": {"epss_score": 0.00165, "epss_percentile": 0.38061}, "CVE-2022-40686": {"epss_score": 0.00113, "epss_percentile": 0.30721}, "CVE-2022-40687": {"epss_score": 0.01416, "epss_percentile": 0.80142}, "CVE-2022-40690": {"epss_score": 0.00373, "epss_percentile": 0.58521}, "CVE-2022-40691": {"epss_score": 0.00723, "epss_percentile": 0.72014}, "CVE-2022-40692": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2022-40693": {"epss_score": 0.00118, "epss_percentile": 0.31447}, "CVE-2022-40694": {"epss_score": 0.00298, "epss_percentile": 0.52815}, "CVE-2022-40695": {"epss_score": 0.00166, "epss_percentile": 0.38232}, "CVE-2022-40696": {"epss_score": 0.00498, "epss_percentile": 0.65245}, "CVE-2022-40697": {"epss_score": 0.00153, "epss_percentile": 0.36619}, "CVE-2022-40698": {"epss_score": 0.00261, "epss_percentile": 0.49275}, "CVE-2022-40699": {"epss_score": 0.00157, "epss_percentile": 0.37091}, "CVE-2022-40700": {"epss_score": 0.00733, "epss_percentile": 0.72202}, "CVE-2022-40701": {"epss_score": 0.00928, "epss_percentile": 0.75584}, "CVE-2022-40702": {"epss_score": 0.00043, "epss_percentile": 0.13283}, "CVE-2022-40703": {"epss_score": 0.00093, "epss_percentile": 0.26624}, "CVE-2022-40704": {"epss_score": 0.00097, "epss_percentile": 0.27458}, "CVE-2022-40705": {"epss_score": 0.00127, "epss_percentile": 0.32835}, "CVE-2022-40707": {"epss_score": 0.00176, "epss_percentile": 0.39432}, "CVE-2022-40708": {"epss_score": 0.00176, "epss_percentile": 0.39432}, "CVE-2022-40709": {"epss_score": 0.00176, "epss_percentile": 0.39432}, "CVE-2022-40710": {"epss_score": 0.00172, "epss_percentile": 0.39013}, "CVE-2022-40711": {"epss_score": 0.00352, "epss_percentile": 0.57132}, "CVE-2022-40712": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-40713": {"epss_score": 0.00256, "epss_percentile": 0.48831}, "CVE-2022-40714": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-40715": {"epss_score": 0.00396, "epss_percentile": 0.59876}, "CVE-2022-40716": {"epss_score": 0.00257, "epss_percentile": 0.4886}, "CVE-2022-40717": {"epss_score": 0.0027, "epss_percentile": 0.50198}, "CVE-2022-40718": {"epss_score": 0.00244, "epss_percentile": 0.47577}, "CVE-2022-40719": {"epss_score": 0.00568, "epss_percentile": 0.67878}, "CVE-2022-40720": {"epss_score": 0.00439, "epss_percentile": 0.62586}, "CVE-2022-40721": {"epss_score": 0.00412, "epss_percentile": 0.60931}, "CVE-2022-40722": {"epss_score": 8e-05, "epss_percentile": 0.00552}, "CVE-2022-40723": {"epss_score": 0.00023, "epss_percentile": 0.05429}, "CVE-2022-40724": {"epss_score": 0.00061, "epss_percentile": 0.1944}, "CVE-2022-40725": {"epss_score": 7e-05, "epss_percentile": 0.00325}, "CVE-2022-40732": {"epss_score": 0.0034, "epss_percentile": 0.56231}, "CVE-2022-40733": {"epss_score": 0.00287, "epss_percentile": 0.51845}, "CVE-2022-40734": {"epss_score": 0.92943, "epss_percentile": 0.99762}, "CVE-2022-40735": {"epss_score": 0.01252, "epss_percentile": 0.78899}, "CVE-2022-40736": {"epss_score": 0.00382, "epss_percentile": 0.59054}, "CVE-2022-40737": {"epss_score": 0.00413, "epss_percentile": 0.61001}, "CVE-2022-40738": {"epss_score": 0.00414, "epss_percentile": 0.61109}, "CVE-2022-40739": {"epss_score": 0.00264, "epss_percentile": 0.4975}, "CVE-2022-40740": {"epss_score": 0.01554, "epss_percentile": 0.81003}, "CVE-2022-40741": {"epss_score": 0.02151, "epss_percentile": 0.83785}, "CVE-2022-40742": {"epss_score": 0.00613, "epss_percentile": 0.69248}, "CVE-2022-40743": {"epss_score": 0.01077, "epss_percentile": 0.7734}, "CVE-2022-40744": {"epss_score": 0.00053, "epss_percentile": 0.16683}, "CVE-2022-40745": {"epss_score": 0.00035, "epss_percentile": 0.09876}, "CVE-2022-40746": {"epss_score": 0.00187, "epss_percentile": 0.40806}, "CVE-2022-40747": {"epss_score": 0.00516, "epss_percentile": 0.66051}, "CVE-2022-40748": {"epss_score": 0.00377, "epss_percentile": 0.58746}, "CVE-2022-40750": {"epss_score": 0.00275, "epss_percentile": 0.50694}, "CVE-2022-40751": {"epss_score": 0.00128, "epss_percentile": 0.32946}, "CVE-2022-40752": {"epss_score": 0.02773, "epss_percentile": 0.85628}, "CVE-2022-40753": {"epss_score": 0.00377, "epss_percentile": 0.58746}, "CVE-2022-40754": {"epss_score": 0.08628, "epss_percentile": 0.92162}, "CVE-2022-40755": {"epss_score": 0.00119, "epss_percentile": 0.3156}, "CVE-2022-40756": {"epss_score": 0.00351, "epss_percentile": 0.57071}, "CVE-2022-40757": {"epss_score": 0.0038, "epss_percentile": 0.58908}, "CVE-2022-40758": {"epss_score": 0.0038, "epss_percentile": 0.58908}, "CVE-2022-40759": {"epss_score": 0.00381, "epss_percentile": 0.5899}, "CVE-2022-40760": {"epss_score": 0.00463, "epss_percentile": 0.63667}, "CVE-2022-40761": {"epss_score": 0.00779, "epss_percentile": 0.73153}, "CVE-2022-40762": {"epss_score": 0.0038, "epss_percentile": 0.58908}, "CVE-2022-40764": {"epss_score": 0.0342, "epss_percentile": 0.87099}, "CVE-2022-40765": {"epss_score": 0.03099, "epss_percentile": 0.86406}, "CVE-2022-40766": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2022-40768": {"epss_score": 0.00025, "epss_percentile": 0.06217}, "CVE-2022-40769": {"epss_score": 0.00902, "epss_percentile": 0.75186}, "CVE-2022-40770": {"epss_score": 0.65902, "epss_percentile": 0.98442}, "CVE-2022-40771": {"epss_score": 0.01014, "epss_percentile": 0.76652}, "CVE-2022-40772": {"epss_score": 0.00536, "epss_percentile": 0.66864}, "CVE-2022-40773": {"epss_score": 0.00929, "epss_percentile": 0.75587}, "CVE-2022-40774": {"epss_score": 0.00088, "epss_percentile": 0.25715}, "CVE-2022-40775": {"epss_score": 0.00088, "epss_percentile": 0.25715}, "CVE-2022-40777": {"epss_score": 0.004, "epss_percentile": 0.60178}, "CVE-2022-40778": {"epss_score": 0.00434, "epss_percentile": 0.62306}, "CVE-2022-40784": {"epss_score": 0.00424, "epss_percentile": 0.61668}, "CVE-2022-40785": {"epss_score": 0.02317, "epss_percentile": 0.84359}, "CVE-2022-40797": {"epss_score": 0.09022, "epss_percentile": 0.92371}, "CVE-2022-40798": {"epss_score": 0.00341, "epss_percentile": 0.56327}, "CVE-2022-40799": {"epss_score": 0.43771, "epss_percentile": 0.97402}, "CVE-2022-40805": {"epss_score": 0.00682, "epss_percentile": 0.71084}, "CVE-2022-40806": {"epss_score": 0.00682, "epss_percentile": 0.71084}, "CVE-2022-40807": {"epss_score": 0.00682, "epss_percentile": 0.71084}, "CVE-2022-40808": {"epss_score": 0.00682, "epss_percentile": 0.71084}, "CVE-2022-40809": {"epss_score": 0.00604, "epss_percentile": 0.68961}, "CVE-2022-40810": {"epss_score": 0.00604, "epss_percentile": 0.68961}, "CVE-2022-40811": {"epss_score": 0.00682, "epss_percentile": 0.71084}, "CVE-2022-40812": {"epss_score": 0.00604, "epss_percentile": 0.68961}, "CVE-2022-40816": {"epss_score": 0.00214, "epss_percentile": 0.4401}, "CVE-2022-40817": {"epss_score": 0.00165, "epss_percentile": 0.38115}, "CVE-2022-40824": {"epss_score": 0.00266, "epss_percentile": 0.49894}, "CVE-2022-40825": {"epss_score": 0.00266, "epss_percentile": 0.49894}, "CVE-2022-40826": {"epss_score": 0.00266, "epss_percentile": 0.49894}, "CVE-2022-40827": {"epss_score": 0.00266, "epss_percentile": 0.49894}, "CVE-2022-40828": {"epss_score": 0.00266, "epss_percentile": 0.49894}, "CVE-2022-40829": {"epss_score": 0.00266, "epss_percentile": 0.49894}, "CVE-2022-40830": {"epss_score": 0.00266, "epss_percentile": 0.49894}, "CVE-2022-40831": {"epss_score": 0.00266, "epss_percentile": 0.49894}, "CVE-2022-40832": {"epss_score": 0.00266, "epss_percentile": 0.49894}, "CVE-2022-40833": {"epss_score": 0.00266, "epss_percentile": 0.49894}, "CVE-2022-40834": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-40835": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-40839": {"epss_score": 0.02334, "epss_percentile": 0.84412}, "CVE-2022-40840": {"epss_score": 0.00132, "epss_percentile": 0.33541}, "CVE-2022-40841": {"epss_score": 0.00287, "epss_percentile": 0.5185}, "CVE-2022-40842": {"epss_score": 0.00675, "epss_percentile": 0.70889}, "CVE-2022-40843": {"epss_score": 0.40404, "epss_percentile": 0.97217}, "CVE-2022-40844": {"epss_score": 0.00264, "epss_percentile": 0.49734}, "CVE-2022-40845": {"epss_score": 0.00266, "epss_percentile": 0.49868}, "CVE-2022-40846": {"epss_score": 0.00302, "epss_percentile": 0.53127}, "CVE-2022-40847": {"epss_score": 0.0136, "epss_percentile": 0.79744}, "CVE-2022-40849": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-40851": {"epss_score": 0.00598, "epss_percentile": 0.68771}, "CVE-2022-40853": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-40854": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-40855": {"epss_score": 0.03069, "epss_percentile": 0.86342}, "CVE-2022-40860": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-40861": {"epss_score": 0.00452, "epss_percentile": 0.6318}, "CVE-2022-40862": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-40864": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-40865": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-40866": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-40867": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-40868": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-40869": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-40870": {"epss_score": 0.00546, "epss_percentile": 0.67212}, "CVE-2022-40871": {"epss_score": 0.51559, "epss_percentile": 0.97786}, "CVE-2022-40872": {"epss_score": 0.00199, "epss_percentile": 0.42159}, "CVE-2022-40874": {"epss_score": 0.00413, "epss_percentile": 0.60967}, "CVE-2022-40875": {"epss_score": 0.00374, "epss_percentile": 0.58587}, "CVE-2022-40876": {"epss_score": 0.04458, "epss_percentile": 0.88715}, "CVE-2022-40877": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-40878": {"epss_score": 0.07218, "epss_percentile": 0.91332}, "CVE-2022-40879": {"epss_score": 0.19015, "epss_percentile": 0.95112}, "CVE-2022-40881": {"epss_score": 0.93672, "epss_percentile": 0.99832}, "CVE-2022-40884": {"epss_score": 0.00069, "epss_percentile": 0.21577}, "CVE-2022-40885": {"epss_score": 0.00058, "epss_percentile": 0.18462}, "CVE-2022-40886": {"epss_score": 0.00449, "epss_percentile": 0.6304}, "CVE-2022-40887": {"epss_score": 0.00224, "epss_percentile": 0.45061}, "CVE-2022-40889": {"epss_score": 0.00263, "epss_percentile": 0.49522}, "CVE-2022-40890": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-40895": {"epss_score": 0.01373, "epss_percentile": 0.79816}, "CVE-2022-40896": {"epss_score": 0.00053, "epss_percentile": 0.16825}, "CVE-2022-40897": {"epss_score": 0.00443, "epss_percentile": 0.62797}, "CVE-2022-40898": {"epss_score": 0.00139, "epss_percentile": 0.34641}, "CVE-2022-40899": {"epss_score": 0.00747, "epss_percentile": 0.72565}, "CVE-2022-40903": {"epss_score": 0.00129, "epss_percentile": 0.33185}, "CVE-2022-40912": {"epss_score": 0.00112, "epss_percentile": 0.30474}, "CVE-2022-40916": {"epss_score": 0.00432, "epss_percentile": 0.62159}, "CVE-2022-40918": {"epss_score": 0.04349, "epss_percentile": 0.88582}, "CVE-2022-40921": {"epss_score": 0.00428, "epss_percentile": 0.61959}, "CVE-2022-40922": {"epss_score": 0.00226, "epss_percentile": 0.45263}, "CVE-2022-40923": {"epss_score": 0.00247, "epss_percentile": 0.47848}, "CVE-2022-40924": {"epss_score": 0.00427, "epss_percentile": 0.61775}, "CVE-2022-40925": {"epss_score": 0.00427, "epss_percentile": 0.61775}, "CVE-2022-40926": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40927": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40928": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40929": {"epss_score": 0.00372, "epss_percentile": 0.58449}, "CVE-2022-40931": {"epss_score": 0.00236, "epss_percentile": 0.46376}, "CVE-2022-40932": {"epss_score": 0.00427, "epss_percentile": 0.61775}, "CVE-2022-40933": {"epss_score": 0.00207, "epss_percentile": 0.43092}, "CVE-2022-40934": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40935": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-40939": {"epss_score": 0.00145, "epss_percentile": 0.35459}, "CVE-2022-40942": {"epss_score": 0.00598, "epss_percentile": 0.68771}, "CVE-2022-40943": {"epss_score": 0.00605, "epss_percentile": 0.68972}, "CVE-2022-40944": {"epss_score": 0.00676, "epss_percentile": 0.70938}, "CVE-2022-40946": {"epss_score": 0.01142, "epss_percentile": 0.77971}, "CVE-2022-40954": {"epss_score": 0.01322, "epss_percentile": 0.79448}, "CVE-2022-40955": {"epss_score": 0.03805, "epss_percentile": 0.8775}, "CVE-2022-40956": {"epss_score": 0.0018, "epss_percentile": 0.39903}, "CVE-2022-40957": {"epss_score": 0.00139, "epss_percentile": 0.34655}, "CVE-2022-40958": {"epss_score": 0.00276, "epss_percentile": 0.50765}, "CVE-2022-40959": {"epss_score": 0.00119, "epss_percentile": 0.31578}, "CVE-2022-40960": {"epss_score": 0.00117, "epss_percentile": 0.31292}, "CVE-2022-40961": {"epss_score": 0.00198, "epss_percentile": 0.42093}, "CVE-2022-40962": {"epss_score": 0.00226, "epss_percentile": 0.45271}, "CVE-2022-40963": {"epss_score": 0.00177, "epss_percentile": 0.39496}, "CVE-2022-40964": {"epss_score": 0.00023, "epss_percentile": 0.05448}, "CVE-2022-40965": {"epss_score": 0.00488, "epss_percentile": 0.64858}, "CVE-2022-40966": {"epss_score": 0.0017, "epss_percentile": 0.38671}, "CVE-2022-40967": {"epss_score": 0.00909, "epss_percentile": 0.75299}, "CVE-2022-40968": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-40969": {"epss_score": 0.00411, "epss_percentile": 0.60876}, "CVE-2022-40971": {"epss_score": 0.00071, "epss_percentile": 0.22036}, "CVE-2022-40972": {"epss_score": 0.00094, "epss_percentile": 0.26772}, "CVE-2022-40974": {"epss_score": 0.00071, "epss_percentile": 0.2199}, "CVE-2022-40975": {"epss_score": 0.00107, "epss_percentile": 0.29661}, "CVE-2022-40976": {"epss_score": 0.00047, "epss_percentile": 0.14574}, "CVE-2022-40977": {"epss_score": 0.0075, "epss_percentile": 0.72633}, "CVE-2022-40978": {"epss_score": 2e-05, "epss_percentile": 0.00025}, "CVE-2022-40979": {"epss_score": 4e-05, "epss_percentile": 0.00163}, "CVE-2022-40980": {"epss_score": 0.0043, "epss_percentile": 0.62019}, "CVE-2022-40981": {"epss_score": 0.00048, "epss_percentile": 0.14998}, "CVE-2022-40982": {"epss_score": 0.00731, "epss_percentile": 0.72167}, "CVE-2022-40983": {"epss_score": 0.00529, "epss_percentile": 0.66597}, "CVE-2022-40984": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-40985": {"epss_score": 0.00643, "epss_percentile": 0.70047}, "CVE-2022-40986": {"epss_score": 0.00544, "epss_percentile": 0.67139}, "CVE-2022-40987": {"epss_score": 0.00563, "epss_percentile": 0.67736}, "CVE-2022-40988": {"epss_score": 0.00579, "epss_percentile": 0.68219}, "CVE-2022-40989": {"epss_score": 0.00579, "epss_percentile": 0.68219}, "CVE-2022-40990": {"epss_score": 0.00563, "epss_percentile": 0.67736}, "CVE-2022-40991": {"epss_score": 0.00592, "epss_percentile": 0.68608}, "CVE-2022-40992": {"epss_score": 0.00592, "epss_percentile": 0.68608}, "CVE-2022-40993": {"epss_score": 0.00579, "epss_percentile": 0.68219}, "CVE-2022-40994": {"epss_score": 0.00579, "epss_percentile": 0.68219}, "CVE-2022-40995": {"epss_score": 0.00544, "epss_percentile": 0.67139}, "CVE-2022-40996": {"epss_score": 0.00579, "epss_percentile": 0.68219}, "CVE-2022-40997": {"epss_score": 0.00592, "epss_percentile": 0.68608}, "CVE-2022-40998": {"epss_score": 0.00544, "epss_percentile": 0.67139}, "CVE-2022-40999": {"epss_score": 0.00579, "epss_percentile": 0.68219}, "CVE-2022-41000": {"epss_score": 0.0125, "epss_percentile": 0.78887}, "CVE-2022-41001": {"epss_score": 0.0125, "epss_percentile": 0.78887}, "CVE-2022-41002": {"epss_score": 0.0125, "epss_percentile": 0.78887}, "CVE-2022-41003": {"epss_score": 0.01014, "epss_percentile": 0.76653}, "CVE-2022-41004": {"epss_score": 0.0125, "epss_percentile": 0.78887}, "CVE-2022-41005": {"epss_score": 0.0125, "epss_percentile": 0.78887}, "CVE-2022-41006": {"epss_score": 0.0097, "epss_percentile": 0.76114}, "CVE-2022-41007": {"epss_score": 0.0125, "epss_percentile": 0.78887}, "CVE-2022-41008": {"epss_score": 0.0097, "epss_percentile": 0.76114}, "CVE-2022-41009": {"epss_score": 0.0097, "epss_percentile": 0.76114}, "CVE-2022-41010": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41011": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41012": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41013": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41014": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41015": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41016": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41017": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41018": {"epss_score": 0.00889, "epss_percentile": 0.75021}, "CVE-2022-41019": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41020": {"epss_score": 0.00752, "epss_percentile": 0.72654}, "CVE-2022-41021": {"epss_score": 0.0097, "epss_percentile": 0.76114}, "CVE-2022-41022": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41023": {"epss_score": 0.0097, "epss_percentile": 0.76114}, "CVE-2022-41024": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41025": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41026": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41027": {"epss_score": 0.0125, "epss_percentile": 0.78887}, "CVE-2022-41028": {"epss_score": 0.01013, "epss_percentile": 0.7663}, "CVE-2022-41029": {"epss_score": 0.0125, "epss_percentile": 0.78887}, "CVE-2022-41030": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2022-41031": {"epss_score": 0.07941, "epss_percentile": 0.9178}, "CVE-2022-41032": {"epss_score": 0.18296, "epss_percentile": 0.9499}, "CVE-2022-41033": {"epss_score": 0.00892, "epss_percentile": 0.75067}, "CVE-2022-41034": {"epss_score": 0.55647, "epss_percentile": 0.97987}, "CVE-2022-41035": {"epss_score": 0.00874, "epss_percentile": 0.74767}, "CVE-2022-41036": {"epss_score": 0.17697, "epss_percentile": 0.94891}, "CVE-2022-41037": {"epss_score": 0.17697, "epss_percentile": 0.94891}, "CVE-2022-41038": {"epss_score": 0.10181, "epss_percentile": 0.92882}, "CVE-2022-41039": {"epss_score": 0.00755, "epss_percentile": 0.7272}, "CVE-2022-41040": {"epss_score": 0.9419, "epss_percentile": 0.99916}, "CVE-2022-41042": {"epss_score": 0.00732, "epss_percentile": 0.72189}, "CVE-2022-41043": {"epss_score": 0.01427, "epss_percentile": 0.80217}, "CVE-2022-41044": {"epss_score": 0.00755, "epss_percentile": 0.7272}, "CVE-2022-41045": {"epss_score": 0.00087, "epss_percentile": 0.25471}, "CVE-2022-41047": {"epss_score": 0.14338, "epss_percentile": 0.9419}, "CVE-2022-41048": {"epss_score": 0.14338, "epss_percentile": 0.9419}, "CVE-2022-41049": {"epss_score": 0.12955, "epss_percentile": 0.93829}, "CVE-2022-41050": {"epss_score": 0.01014, "epss_percentile": 0.76653}, "CVE-2022-41051": {"epss_score": 0.02297, "epss_percentile": 0.843}, "CVE-2022-41052": {"epss_score": 0.02244, "epss_percentile": 0.84123}, "CVE-2022-41053": {"epss_score": 0.23963, "epss_percentile": 0.95838}, "CVE-2022-41054": {"epss_score": 0.01014, "epss_percentile": 0.76653}, "CVE-2022-41055": {"epss_score": 0.04842, "epss_percentile": 0.89203}, "CVE-2022-41056": {"epss_score": 0.22047, "epss_percentile": 0.95587}, "CVE-2022-41057": {"epss_score": 0.01136, "epss_percentile": 0.77919}, "CVE-2022-41058": {"epss_score": 0.23963, "epss_percentile": 0.95838}, "CVE-2022-41060": {"epss_score": 0.01718, "epss_percentile": 0.81923}, "CVE-2022-41061": {"epss_score": 0.01205, "epss_percentile": 0.78513}, "CVE-2022-41062": {"epss_score": 0.12847, "epss_percentile": 0.93801}, "CVE-2022-41063": {"epss_score": 0.02249, "epss_percentile": 0.84142}, "CVE-2022-41064": {"epss_score": 0.00106, "epss_percentile": 0.29574}, "CVE-2022-41066": {"epss_score": 0.02272, "epss_percentile": 0.84219}, "CVE-2022-41073": {"epss_score": 0.02508, "epss_percentile": 0.84942}, "CVE-2022-41074": {"epss_score": 0.04765, "epss_percentile": 0.89121}, "CVE-2022-41076": {"epss_score": 0.37557, "epss_percentile": 0.97057}, "CVE-2022-41077": {"epss_score": 0.00895, "epss_percentile": 0.75103}, "CVE-2022-41078": {"epss_score": 0.00994, "epss_percentile": 0.76429}, "CVE-2022-41079": {"epss_score": 0.00994, "epss_percentile": 0.76429}, "CVE-2022-41080": {"epss_score": 0.93795, "epss_percentile": 0.99848}, "CVE-2022-41081": {"epss_score": 0.08417, "epss_percentile": 0.92041}, "CVE-2022-41082": {"epss_score": 0.91557, "epss_percentile": 0.99652}, "CVE-2022-41083": {"epss_score": 0.04402, "epss_percentile": 0.88647}, "CVE-2022-41085": {"epss_score": 0.00857, "epss_percentile": 0.74494}, "CVE-2022-41086": {"epss_score": 0.00269, "epss_percentile": 0.50127}, "CVE-2022-41088": {"epss_score": 0.00539, "epss_percentile": 0.6697}, "CVE-2022-41089": {"epss_score": 0.08332, "epss_percentile": 0.91994}, "CVE-2022-41090": {"epss_score": 0.02234, "epss_percentile": 0.84095}, "CVE-2022-41091": {"epss_score": 0.06783, "epss_percentile": 0.91024}, "CVE-2022-41092": {"epss_score": 0.01197, "epss_percentile": 0.78443}, "CVE-2022-41093": {"epss_score": 0.00086, "epss_percentile": 0.25305}, "CVE-2022-41094": {"epss_score": 0.00895, "epss_percentile": 0.75103}, "CVE-2022-41095": {"epss_score": 0.00895, "epss_percentile": 0.75103}, "CVE-2022-41096": {"epss_score": 0.0098, "epss_percentile": 0.76268}, "CVE-2022-41097": {"epss_score": 0.23122, "epss_percentile": 0.95737}, "CVE-2022-41098": {"epss_score": 0.01561, "epss_percentile": 0.81042}, "CVE-2022-41099": {"epss_score": 0.02265, "epss_percentile": 0.84196}, "CVE-2022-41100": {"epss_score": 0.00086, "epss_percentile": 0.25305}, "CVE-2022-41101": {"epss_score": 0.01014, "epss_percentile": 0.76653}, "CVE-2022-41102": {"epss_score": 0.0118, "epss_percentile": 0.78301}, "CVE-2022-41103": {"epss_score": 0.01603, "epss_percentile": 0.81278}, "CVE-2022-41104": {"epss_score": 0.00675, "epss_percentile": 0.70906}, "CVE-2022-41105": {"epss_score": 0.01718, "epss_percentile": 0.81923}, "CVE-2022-41106": {"epss_score": 0.15354, "epss_percentile": 0.94415}, "CVE-2022-41107": {"epss_score": 0.02249, "epss_percentile": 0.84142}, "CVE-2022-41109": {"epss_score": 0.01159, "epss_percentile": 0.78125}, "CVE-2022-41113": {"epss_score": 0.05901, "epss_percentile": 0.90309}, "CVE-2022-41114": {"epss_score": 0.0061, "epss_percentile": 0.69152}, "CVE-2022-41115": {"epss_score": 0.00786, "epss_percentile": 0.73295}, "CVE-2022-41116": {"epss_score": 0.00596, "epss_percentile": 0.68709}, "CVE-2022-41118": {"epss_score": 0.00626, "epss_percentile": 0.69619}, "CVE-2022-41119": {"epss_score": 0.02244, "epss_percentile": 0.84123}, "CVE-2022-41120": {"epss_score": 0.00846, "epss_percentile": 0.74336}, "CVE-2022-41121": {"epss_score": 0.00534, "epss_percentile": 0.66788}, "CVE-2022-41122": {"epss_score": 0.15389, "epss_percentile": 0.94422}, "CVE-2022-41123": {"epss_score": 0.00325, "epss_percentile": 0.55026}, "CVE-2022-41125": {"epss_score": 0.00923, "epss_percentile": 0.755}, "CVE-2022-41127": {"epss_score": 0.00579, "epss_percentile": 0.68219}, "CVE-2022-41128": {"epss_score": 0.39236, "epss_percentile": 0.97148}, "CVE-2022-41131": {"epss_score": 0.01197, "epss_percentile": 0.78444}, "CVE-2022-41132": {"epss_score": 0.00326, "epss_percentile": 0.55036}, "CVE-2022-41133": {"epss_score": 0.00526, "epss_percentile": 0.66397}, "CVE-2022-41134": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2022-41135": {"epss_score": 0.0018, "epss_percentile": 0.3989}, "CVE-2022-41136": {"epss_score": 0.00102, "epss_percentile": 0.28803}, "CVE-2022-41137": {"epss_score": 0.04042, "epss_percentile": 0.88167}, "CVE-2022-41138": {"epss_score": 0.00533, "epss_percentile": 0.66771}, "CVE-2022-41139": {"epss_score": 0.00356, "epss_percentile": 0.57344}, "CVE-2022-41140": {"epss_score": 0.01508, "epss_percentile": 0.80758}, "CVE-2022-41141": {"epss_score": 0.0014, "epss_percentile": 0.34685}, "CVE-2022-41142": {"epss_score": 0.49891, "epss_percentile": 0.9771}, "CVE-2022-41143": {"epss_score": 0.0218, "epss_percentile": 0.83901}, "CVE-2022-41144": {"epss_score": 0.0218, "epss_percentile": 0.83901}, "CVE-2022-41145": {"epss_score": 0.0093, "epss_percentile": 0.75598}, "CVE-2022-41146": {"epss_score": 0.0093, "epss_percentile": 0.75598}, "CVE-2022-41147": {"epss_score": 0.02107, "epss_percentile": 0.83635}, "CVE-2022-41148": {"epss_score": 0.01605, "epss_percentile": 0.81294}, "CVE-2022-41149": {"epss_score": 0.01605, "epss_percentile": 0.81294}, "CVE-2022-41150": {"epss_score": 0.02107, "epss_percentile": 0.83635}, "CVE-2022-41151": {"epss_score": 0.0218, "epss_percentile": 0.83901}, "CVE-2022-41152": {"epss_score": 0.01605, "epss_percentile": 0.81294}, "CVE-2022-41153": {"epss_score": 0.00795, "epss_percentile": 0.73472}, "CVE-2022-41154": {"epss_score": 0.00543, "epss_percentile": 0.671}, "CVE-2022-41155": {"epss_score": 0.00537, "epss_percentile": 0.66886}, "CVE-2022-41156": {"epss_score": 0.00126, "epss_percentile": 0.32681}, "CVE-2022-41157": {"epss_score": 0.00344, "epss_percentile": 0.56545}, "CVE-2022-41158": {"epss_score": 0.05426, "epss_percentile": 0.89868}, "CVE-2022-41166": {"epss_score": 0.00046, "epss_percentile": 0.14333}, "CVE-2022-41167": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-41168": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-41169": {"epss_score": 0.00046, "epss_percentile": 0.14333}, "CVE-2022-41170": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-41171": {"epss_score": 0.00046, "epss_percentile": 0.14333}, "CVE-2022-41172": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-41173": {"epss_score": 0.00046, "epss_percentile": 0.14333}, "CVE-2022-41174": {"epss_score": 0.00046, "epss_percentile": 0.14333}, "CVE-2022-41175": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-41176": {"epss_score": 0.00046, "epss_percentile": 0.14333}, "CVE-2022-41177": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-41178": {"epss_score": 0.00046, "epss_percentile": 0.14333}, "CVE-2022-41179": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-41180": {"epss_score": 0.0019, "epss_percentile": 0.41085}, "CVE-2022-41181": {"epss_score": 0.00046, "epss_percentile": 0.14333}, "CVE-2022-41182": {"epss_score": 0.00112, "epss_percentile": 0.3055}, "CVE-2022-41183": {"epss_score": 0.00112, "epss_percentile": 0.3055}, "CVE-2022-41184": {"epss_score": 0.00866, "epss_percentile": 0.74634}, "CVE-2022-41185": {"epss_score": 0.00866, "epss_percentile": 0.74634}, "CVE-2022-41186": {"epss_score": 0.01765, "epss_percentile": 0.82169}, "CVE-2022-41187": {"epss_score": 0.01765, "epss_percentile": 0.82169}, "CVE-2022-41188": {"epss_score": 0.00134, "epss_percentile": 0.33775}, "CVE-2022-41189": {"epss_score": 0.01765, "epss_percentile": 0.82169}, "CVE-2022-41190": {"epss_score": 0.01765, "epss_percentile": 0.82169}, "CVE-2022-41191": {"epss_score": 0.01765, "epss_percentile": 0.82169}, "CVE-2022-41192": {"epss_score": 0.00134, "epss_percentile": 0.33775}, "CVE-2022-41193": {"epss_score": 0.02436, "epss_percentile": 0.8474}, "CVE-2022-41194": {"epss_score": 0.00134, "epss_percentile": 0.33775}, "CVE-2022-41195": {"epss_score": 0.01765, "epss_percentile": 0.82169}, "CVE-2022-41196": {"epss_score": 0.01765, "epss_percentile": 0.82169}, "CVE-2022-41197": {"epss_score": 0.00134, "epss_percentile": 0.33775}, "CVE-2022-41198": {"epss_score": 0.01765, "epss_percentile": 0.82169}, "CVE-2022-41199": {"epss_score": 0.01765, "epss_percentile": 0.82169}, "CVE-2022-41200": {"epss_score": 0.01765, "epss_percentile": 0.82169}, "CVE-2022-41201": {"epss_score": 0.01514, "epss_percentile": 0.80793}, "CVE-2022-41202": {"epss_score": 0.01765, "epss_percentile": 0.82169}, "CVE-2022-41203": {"epss_score": 0.01085, "epss_percentile": 0.77409}, "CVE-2022-41204": {"epss_score": 0.00418, "epss_percentile": 0.61279}, "CVE-2022-41205": {"epss_score": 0.00161, "epss_percentile": 0.3757}, "CVE-2022-41206": {"epss_score": 0.00403, "epss_percentile": 0.60383}, "CVE-2022-41207": {"epss_score": 0.00231, "epss_percentile": 0.45852}, "CVE-2022-41208": {"epss_score": 0.00403, "epss_percentile": 0.60383}, "CVE-2022-41209": {"epss_score": 0.00021, "epss_percentile": 0.04799}, "CVE-2022-41210": {"epss_score": 0.00083, "epss_percentile": 0.2461}, "CVE-2022-41211": {"epss_score": 0.00157, "epss_percentile": 0.37069}, "CVE-2022-41212": {"epss_score": 0.00478, "epss_percentile": 0.64379}, "CVE-2022-41214": {"epss_score": 0.00423, "epss_percentile": 0.61602}, "CVE-2022-41215": {"epss_score": 0.00158, "epss_percentile": 0.37294}, "CVE-2022-41216": {"epss_score": 0.00142, "epss_percentile": 0.34988}, "CVE-2022-41217": {"epss_score": 0.00214, "epss_percentile": 0.44003}, "CVE-2022-41218": {"epss_score": 0.00426, "epss_percentile": 0.61742}, "CVE-2022-41220": {"epss_score": 0.12136, "epss_percentile": 0.93582}, "CVE-2022-41221": {"epss_score": 0.00032, "epss_percentile": 0.08822}, "CVE-2022-41222": {"epss_score": 0.00017, "epss_percentile": 0.03293}, "CVE-2022-41223": {"epss_score": 0.03158, "epss_percentile": 0.86519}, "CVE-2022-41224": {"epss_score": 0.03363, "epss_percentile": 0.86995}, "CVE-2022-41225": {"epss_score": 0.20595, "epss_percentile": 0.95383}, "CVE-2022-41226": {"epss_score": 0.0148, "epss_percentile": 0.80563}, "CVE-2022-41227": {"epss_score": 0.00079, "epss_percentile": 0.23855}, "CVE-2022-41228": {"epss_score": 0.00288, "epss_percentile": 0.51872}, "CVE-2022-41229": {"epss_score": 0.09489, "epss_percentile": 0.92571}, "CVE-2022-41230": {"epss_score": 0.00396, "epss_percentile": 0.59895}, "CVE-2022-41231": {"epss_score": 0.00142, "epss_percentile": 0.35017}, "CVE-2022-41232": {"epss_score": 0.00098, "epss_percentile": 0.27753}, "CVE-2022-41233": {"epss_score": 0.00396, "epss_percentile": 0.59895}, "CVE-2022-41234": {"epss_score": 0.00432, "epss_percentile": 0.62132}, "CVE-2022-41235": {"epss_score": 0.00441, "epss_percentile": 0.62675}, "CVE-2022-41236": {"epss_score": 0.00072, "epss_percentile": 0.22404}, "CVE-2022-41237": {"epss_score": 0.01068, "epss_percentile": 0.77239}, "CVE-2022-41238": {"epss_score": 0.01295, "epss_percentile": 0.79253}, "CVE-2022-41239": {"epss_score": 0.20595, "epss_percentile": 0.95383}, "CVE-2022-41240": {"epss_score": 0.16253, "epss_percentile": 0.94603}, "CVE-2022-41241": {"epss_score": 0.01052, "epss_percentile": 0.7709}, "CVE-2022-41242": {"epss_score": 0.00396, "epss_percentile": 0.59895}, "CVE-2022-41243": {"epss_score": 0.00159, "epss_percentile": 0.37419}, "CVE-2022-41244": {"epss_score": 0.00159, "epss_percentile": 0.37419}, "CVE-2022-41245": {"epss_score": 0.00112, "epss_percentile": 0.30477}, "CVE-2022-41246": {"epss_score": 0.00196, "epss_percentile": 0.41783}, "CVE-2022-41247": {"epss_score": 0.00292, "epss_percentile": 0.5222}, "CVE-2022-41248": {"epss_score": 0.00181, "epss_percentile": 0.40113}, "CVE-2022-41249": {"epss_score": 0.0008, "epss_percentile": 0.2418}, "CVE-2022-41250": {"epss_score": 0.00403, "epss_percentile": 0.60323}, "CVE-2022-41251": {"epss_score": 0.00396, "epss_percentile": 0.59895}, "CVE-2022-41252": {"epss_score": 0.00396, "epss_percentile": 0.59895}, "CVE-2022-41253": {"epss_score": 0.00072, "epss_percentile": 0.22403}, "CVE-2022-41254": {"epss_score": 0.00547, "epss_percentile": 0.67227}, "CVE-2022-41255": {"epss_score": 0.00547, "epss_percentile": 0.67227}, "CVE-2022-41258": {"epss_score": 0.00355, "epss_percentile": 0.57263}, "CVE-2022-41259": {"epss_score": 0.00573, "epss_percentile": 0.68067}, "CVE-2022-41260": {"epss_score": 0.00283, "epss_percentile": 0.51389}, "CVE-2022-41261": {"epss_score": 0.00046, "epss_percentile": 0.14415}, "CVE-2022-41262": {"epss_score": 0.01621, "epss_percentile": 0.81387}, "CVE-2022-41263": {"epss_score": 0.00094, "epss_percentile": 0.27061}, "CVE-2022-41264": {"epss_score": 0.00657, "epss_percentile": 0.70456}, "CVE-2022-41266": {"epss_score": 0.0045, "epss_percentile": 0.63103}, "CVE-2022-41267": {"epss_score": 0.00495, "epss_percentile": 0.65118}, "CVE-2022-41268": {"epss_score": 0.0032, "epss_percentile": 0.54613}, "CVE-2022-41271": {"epss_score": 0.00213, "epss_percentile": 0.43878}, "CVE-2022-41272": {"epss_score": 0.00663, "epss_percentile": 0.70618}, "CVE-2022-41273": {"epss_score": 0.0017, "epss_percentile": 0.38656}, "CVE-2022-41274": {"epss_score": 0.00178, "epss_percentile": 0.39694}, "CVE-2022-41275": {"epss_score": 0.00657, "epss_percentile": 0.70463}, "CVE-2022-41278": {"epss_score": 0.00135, "epss_percentile": 0.33986}, "CVE-2022-41279": {"epss_score": 0.00053, "epss_percentile": 0.1687}, "CVE-2022-41280": {"epss_score": 0.00053, "epss_percentile": 0.1687}, "CVE-2022-41281": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-41282": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-41283": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-41284": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-41285": {"epss_score": 0.0011, "epss_percentile": 0.30158}, "CVE-2022-41286": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-41287": {"epss_score": 0.00135, "epss_percentile": 0.33986}, "CVE-2022-41288": {"epss_score": 0.00053, "epss_percentile": 0.1687}, "CVE-2022-41290": {"epss_score": 0.00104, "epss_percentile": 0.2916}, "CVE-2022-41291": {"epss_score": 0.00118, "epss_percentile": 0.31452}, "CVE-2022-41294": {"epss_score": 0.00076, "epss_percentile": 0.23262}, "CVE-2022-41296": {"epss_score": 0.00194, "epss_percentile": 0.41564}, "CVE-2022-41297": {"epss_score": 0.0014, "epss_percentile": 0.34707}, "CVE-2022-41299": {"epss_score": 0.00548, "epss_percentile": 0.67272}, "CVE-2022-41301": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-41302": {"epss_score": 0.00109, "epss_percentile": 0.30001}, "CVE-2022-41303": {"epss_score": 0.00102, "epss_percentile": 0.28807}, "CVE-2022-41304": {"epss_score": 0.0008, "epss_percentile": 0.24151}, "CVE-2022-41305": {"epss_score": 0.00065, "epss_percentile": 0.20564}, "CVE-2022-41306": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-41307": {"epss_score": 0.00075, "epss_percentile": 0.2294}, "CVE-2022-41308": {"epss_score": 0.00063, "epss_percentile": 0.19991}, "CVE-2022-41309": {"epss_score": 0.00225, "epss_percentile": 0.45118}, "CVE-2022-41310": {"epss_score": 0.00225, "epss_percentile": 0.45118}, "CVE-2022-41311": {"epss_score": 0.01259, "epss_percentile": 0.78966}, "CVE-2022-41312": {"epss_score": 0.01259, "epss_percentile": 0.78966}, "CVE-2022-41313": {"epss_score": 0.01259, "epss_percentile": 0.78966}, "CVE-2022-41314": {"epss_score": 0.0007, "epss_percentile": 0.21969}, "CVE-2022-41315": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-41316": {"epss_score": 0.00171, "epss_percentile": 0.38895}, "CVE-2022-41317": {"epss_score": 0.01027, "epss_percentile": 0.76802}, "CVE-2022-41318": {"epss_score": 0.00154, "epss_percentile": 0.36691}, "CVE-2022-41319": {"epss_score": 0.00542, "epss_percentile": 0.67078}, "CVE-2022-41320": {"epss_score": 0.00326, "epss_percentile": 0.55064}, "CVE-2022-41322": {"epss_score": 0.02034, "epss_percentile": 0.83346}, "CVE-2022-41323": {"epss_score": 0.06362, "epss_percentile": 0.907}, "CVE-2022-41324": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2022-41325": {"epss_score": 0.00087, "epss_percentile": 0.25572}, "CVE-2022-41326": {"epss_score": 0.02697, "epss_percentile": 0.85446}, "CVE-2022-41327": {"epss_score": 0.00021, "epss_percentile": 0.04815}, "CVE-2022-41328": {"epss_score": 0.0021, "epss_percentile": 0.43495}, "CVE-2022-41329": {"epss_score": 0.00681, "epss_percentile": 0.71051}, "CVE-2022-41330": {"epss_score": 0.01913, "epss_percentile": 0.82842}, "CVE-2022-41331": {"epss_score": 0.01358, "epss_percentile": 0.79727}, "CVE-2022-41333": {"epss_score": 0.10218, "epss_percentile": 0.92899}, "CVE-2022-41334": {"epss_score": 0.00551, "epss_percentile": 0.67355}, "CVE-2022-41335": {"epss_score": 0.00625, "epss_percentile": 0.69581}, "CVE-2022-41336": {"epss_score": 0.00352, "epss_percentile": 0.57115}, "CVE-2022-41339": {"epss_score": 0.00043, "epss_percentile": 0.13134}, "CVE-2022-41340": {"epss_score": 0.0013, "epss_percentile": 0.33265}, "CVE-2022-41342": {"epss_score": 0.00062, "epss_percentile": 0.19571}, "CVE-2022-41343": {"epss_score": 0.45698, "epss_percentile": 0.97498}, "CVE-2022-41347": {"epss_score": 0.00155, "epss_percentile": 0.36794}, "CVE-2022-41348": {"epss_score": 0.00741, "epss_percentile": 0.72449}, "CVE-2022-41349": {"epss_score": 0.00637, "epss_percentile": 0.69879}, "CVE-2022-41350": {"epss_score": 0.00741, "epss_percentile": 0.72449}, "CVE-2022-41351": {"epss_score": 0.00741, "epss_percentile": 0.72449}, "CVE-2022-41352": {"epss_score": 0.93958, "epss_percentile": 0.99874}, "CVE-2022-41354": {"epss_score": 0.02061, "epss_percentile": 0.83444}, "CVE-2022-41355": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41358": {"epss_score": 0.00251, "epss_percentile": 0.48276}, "CVE-2022-41376": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-41377": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41378": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41379": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-41380": {"epss_score": 0.00827, "epss_percentile": 0.73988}, "CVE-2022-41381": {"epss_score": 0.00827, "epss_percentile": 0.73988}, "CVE-2022-41382": {"epss_score": 0.0035, "epss_percentile": 0.56971}, "CVE-2022-41383": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-41384": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-41385": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-41386": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-41387": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-41390": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-41391": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-41392": {"epss_score": 0.0042, "epss_percentile": 0.61449}, "CVE-2022-41395": {"epss_score": 0.01626, "epss_percentile": 0.81428}, "CVE-2022-41396": {"epss_score": 0.01626, "epss_percentile": 0.81428}, "CVE-2022-41397": {"epss_score": 0.0007, "epss_percentile": 0.21653}, "CVE-2022-41398": {"epss_score": 0.00069, "epss_percentile": 0.21595}, "CVE-2022-41399": {"epss_score": 0.00069, "epss_percentile": 0.21595}, "CVE-2022-41400": {"epss_score": 0.0007, "epss_percentile": 0.21653}, "CVE-2022-41401": {"epss_score": 0.05001, "epss_percentile": 0.89377}, "CVE-2022-41403": {"epss_score": 0.00238, "epss_percentile": 0.4675}, "CVE-2022-41404": {"epss_score": 0.00595, "epss_percentile": 0.6868}, "CVE-2022-41406": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-41407": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41408": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-41409": {"epss_score": 0.00061, "epss_percentile": 0.19302}, "CVE-2022-41412": {"epss_score": 0.86865, "epss_percentile": 0.99402}, "CVE-2022-41413": {"epss_score": 0.03371, "epss_percentile": 0.87012}, "CVE-2022-41414": {"epss_score": 0.00195, "epss_percentile": 0.41662}, "CVE-2022-41415": {"epss_score": 0.00881, "epss_percentile": 0.74862}, "CVE-2022-41416": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41417": {"epss_score": 0.00093, "epss_percentile": 0.26658}, "CVE-2022-41418": {"epss_score": 0.0128, "epss_percentile": 0.79143}, "CVE-2022-41419": {"epss_score": 0.00226, "epss_percentile": 0.45263}, "CVE-2022-41420": {"epss_score": 0.00048, "epss_percentile": 0.15159}, "CVE-2022-41423": {"epss_score": 0.00226, "epss_percentile": 0.45263}, "CVE-2022-41424": {"epss_score": 0.00226, "epss_percentile": 0.45263}, "CVE-2022-41425": {"epss_score": 0.00226, "epss_percentile": 0.45263}, "CVE-2022-41426": {"epss_score": 0.00226, "epss_percentile": 0.45263}, "CVE-2022-41427": {"epss_score": 0.00226, "epss_percentile": 0.45263}, "CVE-2022-41428": {"epss_score": 0.00334, "epss_percentile": 0.5569}, "CVE-2022-41429": {"epss_score": 0.00361, "epss_percentile": 0.57715}, "CVE-2022-41430": {"epss_score": 0.00334, "epss_percentile": 0.5569}, "CVE-2022-41431": {"epss_score": 0.00269, "epss_percentile": 0.50103}, "CVE-2022-41432": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-41433": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-41434": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-41435": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-41436": {"epss_score": 0.00538, "epss_percentile": 0.66939}, "CVE-2022-41437": {"epss_score": 0.02579, "epss_percentile": 0.85149}, "CVE-2022-41439": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41440": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41441": {"epss_score": 0.0698, "epss_percentile": 0.91158}, "CVE-2022-41442": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2022-41443": {"epss_score": 0.0149, "epss_percentile": 0.80628}, "CVE-2022-41444": {"epss_score": 0.00285, "epss_percentile": 0.51515}, "CVE-2022-41445": {"epss_score": 0.00993, "epss_percentile": 0.76404}, "CVE-2022-41446": {"epss_score": 0.03077, "epss_percentile": 0.86361}, "CVE-2022-41471": {"epss_score": 0.00171, "epss_percentile": 0.38801}, "CVE-2022-41472": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-41473": {"epss_score": 0.07139, "epss_percentile": 0.91277}, "CVE-2022-41474": {"epss_score": 0.00111, "epss_percentile": 0.30252}, "CVE-2022-41475": {"epss_score": 0.00118, "epss_percentile": 0.31453}, "CVE-2022-41477": {"epss_score": 0.00237, "epss_percentile": 0.46649}, "CVE-2022-41479": {"epss_score": 0.00283, "epss_percentile": 0.51373}, "CVE-2022-41480": {"epss_score": 0.00557, "epss_percentile": 0.67544}, "CVE-2022-41481": {"epss_score": 0.00557, "epss_percentile": 0.67544}, "CVE-2022-41482": {"epss_score": 0.00557, "epss_percentile": 0.67544}, "CVE-2022-41483": {"epss_score": 0.00557, "epss_percentile": 0.67544}, "CVE-2022-41484": {"epss_score": 0.00557, "epss_percentile": 0.67544}, "CVE-2022-41485": {"epss_score": 0.00557, "epss_percentile": 0.67544}, "CVE-2022-41489": {"epss_score": 0.0009, "epss_percentile": 0.26094}, "CVE-2022-41495": {"epss_score": 0.00391, "epss_percentile": 0.59583}, "CVE-2022-41496": {"epss_score": 0.00358, "epss_percentile": 0.57484}, "CVE-2022-41497": {"epss_score": 0.00358, "epss_percentile": 0.57484}, "CVE-2022-41498": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41500": {"epss_score": 0.00087, "epss_percentile": 0.2551}, "CVE-2022-41504": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-41505": {"epss_score": 0.00049, "epss_percentile": 0.15604}, "CVE-2022-41512": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-41513": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41514": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41515": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41517": {"epss_score": 0.00367, "epss_percentile": 0.58104}, "CVE-2022-41518": {"epss_score": 0.14899, "epss_percentile": 0.94317}, "CVE-2022-41520": {"epss_score": 0.00408, "epss_percentile": 0.60653}, "CVE-2022-41521": {"epss_score": 0.00408, "epss_percentile": 0.60653}, "CVE-2022-41522": {"epss_score": 0.00686, "epss_percentile": 0.71167}, "CVE-2022-41523": {"epss_score": 0.00408, "epss_percentile": 0.60653}, "CVE-2022-41524": {"epss_score": 0.00408, "epss_percentile": 0.60653}, "CVE-2022-41525": {"epss_score": 0.14899, "epss_percentile": 0.94317}, "CVE-2022-41526": {"epss_score": 0.00408, "epss_percentile": 0.60653}, "CVE-2022-41527": {"epss_score": 0.00408, "epss_percentile": 0.60653}, "CVE-2022-41528": {"epss_score": 0.00408, "epss_percentile": 0.60653}, "CVE-2022-41530": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41532": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41533": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-41534": {"epss_score": 0.0111, "epss_percentile": 0.77661}, "CVE-2022-41535": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41536": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41537": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-41538": {"epss_score": 0.00882, "epss_percentile": 0.74896}, "CVE-2022-41539": {"epss_score": 0.00882, "epss_percentile": 0.74896}, "CVE-2022-41540": {"epss_score": 0.04154, "epss_percentile": 0.88326}, "CVE-2022-41541": {"epss_score": 0.0088, "epss_percentile": 0.74859}, "CVE-2022-41542": {"epss_score": 0.002, "epss_percentile": 0.42245}, "CVE-2022-41544": {"epss_score": 0.60815, "epss_percentile": 0.98223}, "CVE-2022-41545": {"epss_score": 0.0002, "epss_percentile": 0.04527}, "CVE-2022-41547": {"epss_score": 0.01855, "epss_percentile": 0.82559}, "CVE-2022-41550": {"epss_score": 0.00224, "epss_percentile": 0.45065}, "CVE-2022-41551": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-41552": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2022-41553": {"epss_score": 0.00046, "epss_percentile": 0.14305}, "CVE-2022-41554": {"epss_score": 0.00083, "epss_percentile": 0.24725}, "CVE-2022-41555": {"epss_score": 0.00488, "epss_percentile": 0.64858}, "CVE-2022-41556": {"epss_score": 0.0039, "epss_percentile": 0.59535}, "CVE-2022-41558": {"epss_score": 0.00766, "epss_percentile": 0.72946}, "CVE-2022-41559": {"epss_score": 0.00983, "epss_percentile": 0.76304}, "CVE-2022-41560": {"epss_score": 0.00393, "epss_percentile": 0.59735}, "CVE-2022-41561": {"epss_score": 0.04248, "epss_percentile": 0.88448}, "CVE-2022-41562": {"epss_score": 0.00892, "epss_percentile": 0.75067}, "CVE-2022-41563": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-41564": {"epss_score": 0.00144, "epss_percentile": 0.35309}, "CVE-2022-41565": {"epss_score": 0.00599, "epss_percentile": 0.68789}, "CVE-2022-41566": {"epss_score": 0.00599, "epss_percentile": 0.68789}, "CVE-2022-41567": {"epss_score": 0.00599, "epss_percentile": 0.68789}, "CVE-2022-41568": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-41570": {"epss_score": 0.00317, "epss_percentile": 0.54327}, "CVE-2022-41571": {"epss_score": 0.00595, "epss_percentile": 0.68687}, "CVE-2022-41572": {"epss_score": 0.00203, "epss_percentile": 0.42558}, "CVE-2022-41573": {"epss_score": 0.01911, "epss_percentile": 0.82829}, "CVE-2022-41574": {"epss_score": 0.00192, "epss_percentile": 0.41293}, "CVE-2022-41575": {"epss_score": 0.00232, "epss_percentile": 0.45861}, "CVE-2022-41576": {"epss_score": 0.00113, "epss_percentile": 0.30699}, "CVE-2022-41577": {"epss_score": 0.00023, "epss_percentile": 0.05505}, "CVE-2022-41578": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-41579": {"epss_score": 0.00086, "epss_percentile": 0.25361}, "CVE-2022-41580": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-41581": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-41582": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-41583": {"epss_score": 0.00101, "epss_percentile": 0.28652}, "CVE-2022-41584": {"epss_score": 0.00023, "epss_percentile": 0.05505}, "CVE-2022-41585": {"epss_score": 0.00023, "epss_percentile": 0.05505}, "CVE-2022-41586": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-41587": {"epss_score": 0.00176, "epss_percentile": 0.39481}, "CVE-2022-41588": {"epss_score": 0.00078, "epss_percentile": 0.23746}, "CVE-2022-41589": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-41590": {"epss_score": 0.00023, "epss_percentile": 0.05344}, "CVE-2022-41591": {"epss_score": 0.00208, "epss_percentile": 0.4321}, "CVE-2022-41592": {"epss_score": 0.00026, "epss_percentile": 0.06462}, "CVE-2022-41593": {"epss_score": 0.00026, "epss_percentile": 0.06462}, "CVE-2022-41594": {"epss_score": 0.00026, "epss_percentile": 0.06462}, "CVE-2022-41595": {"epss_score": 0.00026, "epss_percentile": 0.06462}, "CVE-2022-41596": {"epss_score": 0.00208, "epss_percentile": 0.43306}, "CVE-2022-41597": {"epss_score": 0.00022, "epss_percentile": 0.05041}, "CVE-2022-41598": {"epss_score": 0.00026, "epss_percentile": 0.06462}, "CVE-2022-41599": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-41600": {"epss_score": 0.00026, "epss_percentile": 0.06462}, "CVE-2022-41601": {"epss_score": 0.00026, "epss_percentile": 0.06462}, "CVE-2022-41602": {"epss_score": 0.00026, "epss_percentile": 0.06462}, "CVE-2022-41603": {"epss_score": 0.00026, "epss_percentile": 0.06462}, "CVE-2022-41604": {"epss_score": 0.00025, "epss_percentile": 0.06209}, "CVE-2022-41606": {"epss_score": 0.00412, "epss_percentile": 0.60949}, "CVE-2022-41607": {"epss_score": 0.0019, "epss_percentile": 0.41126}, "CVE-2022-41608": {"epss_score": 0.00047, "epss_percentile": 0.14702}, "CVE-2022-41609": {"epss_score": 0.00427, "epss_percentile": 0.61907}, "CVE-2022-41610": {"epss_score": 0.00048, "epss_percentile": 0.15036}, "CVE-2022-41611": {"epss_score": 0.00358, "epss_percentile": 0.57519}, "CVE-2022-41612": {"epss_score": 0.00054, "epss_percentile": 0.17052}, "CVE-2022-41613": {"epss_score": 0.00179, "epss_percentile": 0.39822}, "CVE-2022-41614": {"epss_score": 0.00069, "epss_percentile": 0.21627}, "CVE-2022-41615": {"epss_score": 0.00093, "epss_percentile": 0.2674}, "CVE-2022-41616": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-41617": {"epss_score": 0.04435, "epss_percentile": 0.88684}, "CVE-2022-41618": {"epss_score": 0.00316, "epss_percentile": 0.54281}, "CVE-2022-41619": {"epss_score": 0.00045, "epss_percentile": 0.14058}, "CVE-2022-41620": {"epss_score": 0.00057, "epss_percentile": 0.18197}, "CVE-2022-41621": {"epss_score": 0.00066, "epss_percentile": 0.20742}, "CVE-2022-41622": {"epss_score": 0.81263, "epss_percentile": 0.9913}, "CVE-2022-41623": {"epss_score": 0.00537, "epss_percentile": 0.66891}, "CVE-2022-41624": {"epss_score": 0.00647, "epss_percentile": 0.70172}, "CVE-2022-41627": {"epss_score": 0.00015, "epss_percentile": 0.02188}, "CVE-2022-41628": {"epss_score": 0.0007, "epss_percentile": 0.21972}, "CVE-2022-41629": {"epss_score": 0.003, "epss_percentile": 0.52947}, "CVE-2022-41633": {"epss_score": 0.00054, "epss_percentile": 0.17115}, "CVE-2022-41634": {"epss_score": 0.00104, "epss_percentile": 0.29139}, "CVE-2022-41635": {"epss_score": 0.00078, "epss_percentile": 0.23609}, "CVE-2022-41636": {"epss_score": 0.00116, "epss_percentile": 0.31105}, "CVE-2022-41638": {"epss_score": 0.00198, "epss_percentile": 0.42007}, "CVE-2022-41639": {"epss_score": 0.00545, "epss_percentile": 0.67155}, "CVE-2022-41640": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2022-41642": {"epss_score": 0.02345, "epss_percentile": 0.84447}, "CVE-2022-41643": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-41644": {"epss_score": 0.00225, "epss_percentile": 0.45229}, "CVE-2022-41645": {"epss_score": 0.00097, "epss_percentile": 0.27455}, "CVE-2022-41646": {"epss_score": 0.00107, "epss_percentile": 0.29604}, "CVE-2022-41648": {"epss_score": 0.00254, "epss_percentile": 0.48511}, "CVE-2022-41649": {"epss_score": 0.00158, "epss_percentile": 0.37184}, "CVE-2022-41651": {"epss_score": 0.00488, "epss_percentile": 0.64858}, "CVE-2022-41652": {"epss_score": 0.00925, "epss_percentile": 0.75527}, "CVE-2022-41653": {"epss_score": 0.0027, "epss_percentile": 0.50271}, "CVE-2022-41654": {"epss_score": 0.00255, "epss_percentile": 0.48712}, "CVE-2022-41655": {"epss_score": 0.00551, "epss_percentile": 0.67375}, "CVE-2022-41657": {"epss_score": 0.17267, "epss_percentile": 0.94812}, "CVE-2022-41658": {"epss_score": 0.00052, "epss_percentile": 0.16541}, "CVE-2022-41659": {"epss_score": 0.00037, "epss_percentile": 0.10857}, "CVE-2022-41660": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-41661": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-41662": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-41663": {"epss_score": 0.0011, "epss_percentile": 0.30158}, "CVE-2022-41664": {"epss_score": 0.00066, "epss_percentile": 0.20889}, "CVE-2022-41665": {"epss_score": 0.01842, "epss_percentile": 0.82499}, "CVE-2022-41666": {"epss_score": 0.00026, "epss_percentile": 0.06675}, "CVE-2022-41667": {"epss_score": 0.00052, "epss_percentile": 0.1661}, "CVE-2022-41668": {"epss_score": 0.00056, "epss_percentile": 0.17876}, "CVE-2022-41669": {"epss_score": 0.00026, "epss_percentile": 0.06675}, "CVE-2022-41670": {"epss_score": 0.00052, "epss_percentile": 0.1661}, "CVE-2022-41671": {"epss_score": 0.00208, "epss_percentile": 0.43283}, "CVE-2022-41672": {"epss_score": 0.00339, "epss_percentile": 0.56205}, "CVE-2022-41674": {"epss_score": 0.00241, "epss_percentile": 0.47278}, "CVE-2022-41675": {"epss_score": 0.01148, "epss_percentile": 0.78011}, "CVE-2022-41676": {"epss_score": 0.0016, "epss_percentile": 0.37435}, "CVE-2022-41677": {"epss_score": 0.00108, "epss_percentile": 0.29853}, "CVE-2022-41678": {"epss_score": 0.80044, "epss_percentile": 0.99069}, "CVE-2022-41679": {"epss_score": 0.00185, "epss_percentile": 0.40552}, "CVE-2022-41680": {"epss_score": 0.00116, "epss_percentile": 0.31194}, "CVE-2022-41681": {"epss_score": 0.00709, "epss_percentile": 0.71696}, "CVE-2022-41684": {"epss_score": 0.00069, "epss_percentile": 0.21433}, "CVE-2022-41685": {"epss_score": 0.00204, "epss_percentile": 0.42596}, "CVE-2022-41686": {"epss_score": 0.00062, "epss_percentile": 0.19646}, "CVE-2022-41687": {"epss_score": 0.00052, "epss_percentile": 0.16541}, "CVE-2022-41688": {"epss_score": 0.00152, "epss_percentile": 0.36405}, "CVE-2022-41689": {"epss_score": 0.00111, "epss_percentile": 0.30248}, "CVE-2022-41690": {"epss_score": 0.00069, "epss_percentile": 0.21619}, "CVE-2022-41691": {"epss_score": 0.00682, "epss_percentile": 0.71072}, "CVE-2022-41692": {"epss_score": 0.00322, "epss_percentile": 0.54804}, "CVE-2022-41693": {"epss_score": 0.0007, "epss_percentile": 0.21972}, "CVE-2022-41694": {"epss_score": 0.00651, "epss_percentile": 0.70303}, "CVE-2022-41695": {"epss_score": 0.00045, "epss_percentile": 0.14058}, "CVE-2022-41696": {"epss_score": 0.00147, "epss_percentile": 0.35708}, "CVE-2022-41697": {"epss_score": 0.21215, "epss_percentile": 0.95478}, "CVE-2022-41698": {"epss_score": 0.00127, "epss_percentile": 0.32818}, "CVE-2022-41699": {"epss_score": 0.00094, "epss_percentile": 0.26772}, "CVE-2022-41700": {"epss_score": 0.00065, "epss_percentile": 0.2067}, "CVE-2022-41701": {"epss_score": 0.00488, "epss_percentile": 0.64858}, "CVE-2022-41702": {"epss_score": 0.00488, "epss_percentile": 0.64858}, "CVE-2022-41703": {"epss_score": 0.00154, "epss_percentile": 0.36717}, "CVE-2022-41704": {"epss_score": 0.00341, "epss_percentile": 0.56345}, "CVE-2022-41705": {"epss_score": 0.05947, "epss_percentile": 0.90354}, "CVE-2022-41706": {"epss_score": 0.00319, "epss_percentile": 0.54533}, "CVE-2022-41707": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2022-41708": {"epss_score": 0.00122, "epss_percentile": 0.32029}, "CVE-2022-41709": {"epss_score": 0.00077, "epss_percentile": 0.23305}, "CVE-2022-41710": {"epss_score": 0.00068, "epss_percentile": 0.21216}, "CVE-2022-41711": {"epss_score": 0.09998, "epss_percentile": 0.9281}, "CVE-2022-41712": {"epss_score": 0.00361, "epss_percentile": 0.57717}, "CVE-2022-41713": {"epss_score": 0.00111, "epss_percentile": 0.3025}, "CVE-2022-41714": {"epss_score": 0.00312, "epss_percentile": 0.53963}, "CVE-2022-41715": {"epss_score": 0.00016, "epss_percentile": 0.03024}, "CVE-2022-41716": {"epss_score": 0.00022, "epss_percentile": 0.04977}, "CVE-2022-41717": {"epss_score": 0.00714, "epss_percentile": 0.71806}, "CVE-2022-41719": {"epss_score": 0.00348, "epss_percentile": 0.56839}, "CVE-2022-41720": {"epss_score": 0.00069, "epss_percentile": 0.21541}, "CVE-2022-41721": {"epss_score": 0.00074, "epss_percentile": 0.22765}, "CVE-2022-41722": {"epss_score": 0.00175, "epss_percentile": 0.39355}, "CVE-2022-41723": {"epss_score": 0.00229, "epss_percentile": 0.45623}, "CVE-2022-41724": {"epss_score": 0.00017, "epss_percentile": 0.03149}, "CVE-2022-41725": {"epss_score": 0.00055, "epss_percentile": 0.17486}, "CVE-2022-41727": {"epss_score": 0.00034, "epss_percentile": 0.09464}, "CVE-2022-41731": {"epss_score": 0.0009, "epss_percentile": 0.26017}, "CVE-2022-41732": {"epss_score": 0.00038, "epss_percentile": 0.11077}, "CVE-2022-41733": {"epss_score": 0.0005, "epss_percentile": 0.15722}, "CVE-2022-41734": {"epss_score": 0.00025, "epss_percentile": 0.06124}, "CVE-2022-41735": {"epss_score": 0.00323, "epss_percentile": 0.54869}, "CVE-2022-41736": {"epss_score": 0.00027, "epss_percentile": 0.0683}, "CVE-2022-41737": {"epss_score": 0.00016, "epss_percentile": 0.02725}, "CVE-2022-41738": {"epss_score": 0.00042, "epss_percentile": 0.12572}, "CVE-2022-41739": {"epss_score": 0.00025, "epss_percentile": 0.0614}, "CVE-2022-41740": {"epss_score": 0.00066, "epss_percentile": 0.20875}, "CVE-2022-41741": {"epss_score": 0.00828, "epss_percentile": 0.73992}, "CVE-2022-41742": {"epss_score": 0.0007, "epss_percentile": 0.21824}, "CVE-2022-41743": {"epss_score": 0.00225, "epss_percentile": 0.45225}, "CVE-2022-41744": {"epss_score": 0.0006, "epss_percentile": 0.19006}, "CVE-2022-41745": {"epss_score": 0.00091, "epss_percentile": 0.26227}, "CVE-2022-41746": {"epss_score": 0.00615, "epss_percentile": 0.69306}, "CVE-2022-41747": {"epss_score": 0.00073, "epss_percentile": 0.22621}, "CVE-2022-41748": {"epss_score": 0.00037, "epss_percentile": 0.10739}, "CVE-2022-41749": {"epss_score": 0.00037, "epss_percentile": 0.1088}, "CVE-2022-41751": {"epss_score": 0.00041, "epss_percentile": 0.12381}, "CVE-2022-41757": {"epss_score": 0.00399, "epss_percentile": 0.60133}, "CVE-2022-41760": {"epss_score": 0.00073, "epss_percentile": 0.22667}, "CVE-2022-41761": {"epss_score": 0.00081, "epss_percentile": 0.24292}, "CVE-2022-41762": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2022-41763": {"epss_score": 0.01462, "epss_percentile": 0.80437}, "CVE-2022-41765": {"epss_score": 0.00211, "epss_percentile": 0.43636}, "CVE-2022-41766": {"epss_score": 0.00052, "epss_percentile": 0.16516}, "CVE-2022-41767": {"epss_score": 0.00211, "epss_percentile": 0.43636}, "CVE-2022-41769": {"epss_score": 0.00047, "epss_percentile": 0.14485}, "CVE-2022-41770": {"epss_score": 0.00691, "epss_percentile": 0.71281}, "CVE-2022-41771": {"epss_score": 0.00069, "epss_percentile": 0.21535}, "CVE-2022-41772": {"epss_score": 0.17267, "epss_percentile": 0.94812}, "CVE-2022-41773": {"epss_score": 0.00603, "epss_percentile": 0.68937}, "CVE-2022-41775": {"epss_score": 0.00161, "epss_percentile": 0.37585}, "CVE-2022-41776": {"epss_score": 0.00358, "epss_percentile": 0.57522}, "CVE-2022-41777": {"epss_score": 0.03831, "epss_percentile": 0.87807}, "CVE-2022-41778": {"epss_score": 0.00133, "epss_percentile": 0.33679}, "CVE-2022-41779": {"epss_score": 0.0115, "epss_percentile": 0.78029}, "CVE-2022-41780": {"epss_score": 0.00121, "epss_percentile": 0.31878}, "CVE-2022-41781": {"epss_score": 0.00588, "epss_percentile": 0.68509}, "CVE-2022-41783": {"epss_score": 0.00054, "epss_percentile": 0.1708}, "CVE-2022-41784": {"epss_score": 0.00094, "epss_percentile": 0.26772}, "CVE-2022-41785": {"epss_score": 0.00179, "epss_percentile": 0.39752}, "CVE-2022-41786": {"epss_score": 0.0009, "epss_percentile": 0.2616}, "CVE-2022-41787": {"epss_score": 0.00753, "epss_percentile": 0.72673}, "CVE-2022-41788": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-41789": {"epss_score": 0.00298, "epss_percentile": 0.52822}, "CVE-2022-41790": {"epss_score": 0.00132, "epss_percentile": 0.3351}, "CVE-2022-41791": {"epss_score": 0.00611, "epss_percentile": 0.69191}, "CVE-2022-41793": {"epss_score": 0.00144, "epss_percentile": 0.35315}, "CVE-2022-41794": {"epss_score": 0.00733, "epss_percentile": 0.72211}, "CVE-2022-41796": {"epss_score": 0.0003, "epss_percentile": 0.08297}, "CVE-2022-41797": {"epss_score": 0.00416, "epss_percentile": 0.6122}, "CVE-2022-41798": {"epss_score": 0.00034, "epss_percentile": 0.09788}, "CVE-2022-41799": {"epss_score": 0.00207, "epss_percentile": 0.43088}, "CVE-2022-41800": {"epss_score": 0.92701, "epss_percentile": 0.99736}, "CVE-2022-41801": {"epss_score": 0.00059, "epss_percentile": 0.18929}, "CVE-2022-41802": {"epss_score": 0.00062, "epss_percentile": 0.19585}, "CVE-2022-41804": {"epss_score": 0.00015, "epss_percentile": 0.02549}, "CVE-2022-41805": {"epss_score": 0.00141, "epss_percentile": 0.34933}, "CVE-2022-41806": {"epss_score": 0.00682, "epss_percentile": 0.71072}, "CVE-2022-41807": {"epss_score": 0.00035, "epss_percentile": 0.09822}, "CVE-2022-41808": {"epss_score": 0.00057, "epss_percentile": 0.18034}, "CVE-2022-41813": {"epss_score": 0.0069, "epss_percentile": 0.71243}, "CVE-2022-41814": {"epss_score": 0.00298, "epss_percentile": 0.52822}, "CVE-2022-41828": {"epss_score": 0.55562, "epss_percentile": 0.97984}, "CVE-2022-41830": {"epss_score": 0.00085, "epss_percentile": 0.25146}, "CVE-2022-41831": {"epss_score": 0.00137, "epss_percentile": 0.34216}, "CVE-2022-41832": {"epss_score": 0.00682, "epss_percentile": 0.71072}, "CVE-2022-41833": {"epss_score": 0.0094, "epss_percentile": 0.75727}, "CVE-2022-41835": {"epss_score": 0.00054, "epss_percentile": 0.17044}, "CVE-2022-41836": {"epss_score": 0.00682, "epss_percentile": 0.71072}, "CVE-2022-41837": {"epss_score": 0.00164, "epss_percentile": 0.38002}, "CVE-2022-41838": {"epss_score": 0.00733, "epss_percentile": 0.72211}, "CVE-2022-41839": {"epss_score": 0.00301, "epss_percentile": 0.53081}, "CVE-2022-41840": {"epss_score": 0.71978, "epss_percentile": 0.9869}, "CVE-2022-41841": {"epss_score": 0.00126, "epss_percentile": 0.32738}, "CVE-2022-41842": {"epss_score": 0.00436, "epss_percentile": 0.6247}, "CVE-2022-41843": {"epss_score": 0.00113, "epss_percentile": 0.30693}, "CVE-2022-41844": {"epss_score": 0.00076, "epss_percentile": 0.23128}, "CVE-2022-41845": {"epss_score": 0.00088, "epss_percentile": 0.2578}, "CVE-2022-41846": {"epss_score": 0.00074, "epss_percentile": 0.2278}, "CVE-2022-41847": {"epss_score": 0.00095, "epss_percentile": 0.2715}, "CVE-2022-41848": {"epss_score": 0.00027, "epss_percentile": 0.06829}, "CVE-2022-41849": {"epss_score": 0.00037, "epss_percentile": 0.10764}, "CVE-2022-41850": {"epss_score": 0.00027, "epss_percentile": 0.06936}, "CVE-2022-41851": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-41853": {"epss_score": 0.7449, "epss_percentile": 0.98802}, "CVE-2022-41854": {"epss_score": 0.00092, "epss_percentile": 0.26459}, "CVE-2022-41858": {"epss_score": 0.00019, "epss_percentile": 0.04376}, "CVE-2022-41859": {"epss_score": 0.0014, "epss_percentile": 0.34749}, "CVE-2022-41860": {"epss_score": 0.00273, "epss_percentile": 0.50462}, "CVE-2022-41861": {"epss_score": 0.00305, "epss_percentile": 0.5333}, "CVE-2022-41862": {"epss_score": 0.00193, "epss_percentile": 0.41418}, "CVE-2022-41870": {"epss_score": 0.01569, "epss_percentile": 0.81081}, "CVE-2022-41871": {"epss_score": 0.00177, "epss_percentile": 0.39517}, "CVE-2022-41873": {"epss_score": 0.00076, "epss_percentile": 0.23182}, "CVE-2022-41874": {"epss_score": 0.00472, "epss_percentile": 0.64037}, "CVE-2022-41875": {"epss_score": 0.15112, "epss_percentile": 0.94366}, "CVE-2022-41876": {"epss_score": 0.10812, "epss_percentile": 0.93118}, "CVE-2022-41877": {"epss_score": 0.00099, "epss_percentile": 0.28404}, "CVE-2022-41878": {"epss_score": 0.00514, "epss_percentile": 0.65968}, "CVE-2022-41879": {"epss_score": 0.00438, "epss_percentile": 0.62565}, "CVE-2022-41880": {"epss_score": 0.00155, "epss_percentile": 0.36797}, "CVE-2022-41881": {"epss_score": 0.00118, "epss_percentile": 0.31482}, "CVE-2022-41882": {"epss_score": 0.00322, "epss_percentile": 0.54802}, "CVE-2022-41883": {"epss_score": 0.00156, "epss_percentile": 0.3697}, "CVE-2022-41884": {"epss_score": 0.00171, "epss_percentile": 0.38858}, "CVE-2022-41885": {"epss_score": 0.0016, "epss_percentile": 0.37444}, "CVE-2022-41886": {"epss_score": 0.00127, "epss_percentile": 0.32806}, "CVE-2022-41887": {"epss_score": 0.00134, "epss_percentile": 0.33859}, "CVE-2022-41888": {"epss_score": 0.00203, "epss_percentile": 0.42561}, "CVE-2022-41889": {"epss_score": 0.00107, "epss_percentile": 0.29614}, "CVE-2022-41890": {"epss_score": 0.00121, "epss_percentile": 0.31942}, "CVE-2022-41891": {"epss_score": 0.00158, "epss_percentile": 0.37188}, "CVE-2022-41892": {"epss_score": 0.00127, "epss_percentile": 0.32924}, "CVE-2022-41893": {"epss_score": 0.00165, "epss_percentile": 0.38034}, "CVE-2022-41894": {"epss_score": 0.00215, "epss_percentile": 0.44044}, "CVE-2022-41895": {"epss_score": 0.00129, "epss_percentile": 0.33221}, "CVE-2022-41896": {"epss_score": 0.00158, "epss_percentile": 0.37188}, "CVE-2022-41897": {"epss_score": 0.00127, "epss_percentile": 0.32806}, "CVE-2022-41898": {"epss_score": 0.00158, "epss_percentile": 0.37188}, "CVE-2022-41899": {"epss_score": 0.00158, "epss_percentile": 0.37188}, "CVE-2022-41900": {"epss_score": 0.01271, "epss_percentile": 0.79053}, "CVE-2022-41901": {"epss_score": 0.00296, "epss_percentile": 0.5259}, "CVE-2022-41902": {"epss_score": 0.0028, "epss_percentile": 0.51014}, "CVE-2022-41903": {"epss_score": 0.24076, "epss_percentile": 0.95868}, "CVE-2022-41904": {"epss_score": 0.002, "epss_percentile": 0.42237}, "CVE-2022-41905": {"epss_score": 0.00266, "epss_percentile": 0.49874}, "CVE-2022-41906": {"epss_score": 0.00379, "epss_percentile": 0.58842}, "CVE-2022-41907": {"epss_score": 0.00126, "epss_percentile": 0.3263}, "CVE-2022-41908": {"epss_score": 0.00265, "epss_percentile": 0.4979}, "CVE-2022-41909": {"epss_score": 0.0041, "epss_percentile": 0.60811}, "CVE-2022-41910": {"epss_score": 0.00261, "epss_percentile": 0.4925}, "CVE-2022-41911": {"epss_score": 0.00134, "epss_percentile": 0.33843}, "CVE-2022-41912": {"epss_score": 0.00285, "epss_percentile": 0.51678}, "CVE-2022-41913": {"epss_score": 0.002, "epss_percentile": 0.42237}, "CVE-2022-41914": {"epss_score": 0.0022, "epss_percentile": 0.44612}, "CVE-2022-41915": {"epss_score": 0.00317, "epss_percentile": 0.54383}, "CVE-2022-41916": {"epss_score": 0.00269, "epss_percentile": 0.50185}, "CVE-2022-41917": {"epss_score": 0.00124, "epss_percentile": 0.32419}, "CVE-2022-41918": {"epss_score": 0.00189, "epss_percentile": 0.40993}, "CVE-2022-41919": {"epss_score": 0.00189, "epss_percentile": 0.40923}, "CVE-2022-41920": {"epss_score": 0.00672, "epss_percentile": 0.70816}, "CVE-2022-41921": {"epss_score": 0.00298, "epss_percentile": 0.52791}, "CVE-2022-41922": {"epss_score": 0.03836, "epss_percentile": 0.87823}, "CVE-2022-41923": {"epss_score": 0.00264, "epss_percentile": 0.49718}, "CVE-2022-41924": {"epss_score": 0.53721, "epss_percentile": 0.97894}, "CVE-2022-41925": {"epss_score": 0.00135, "epss_percentile": 0.33984}, "CVE-2022-41926": {"epss_score": 0.00074, "epss_percentile": 0.22878}, "CVE-2022-41927": {"epss_score": 0.00819, "epss_percentile": 0.73873}, "CVE-2022-41928": {"epss_score": 0.05936, "epss_percentile": 0.90342}, "CVE-2022-41929": {"epss_score": 0.00434, "epss_percentile": 0.62288}, "CVE-2022-41930": {"epss_score": 0.00929, "epss_percentile": 0.75592}, "CVE-2022-41931": {"epss_score": 0.18932, "epss_percentile": 0.951}, "CVE-2022-41932": {"epss_score": 0.00194, "epss_percentile": 0.41556}, "CVE-2022-41933": {"epss_score": 0.00089, "epss_percentile": 0.25985}, "CVE-2022-41934": {"epss_score": 0.23616, "epss_percentile": 0.95796}, "CVE-2022-41935": {"epss_score": 0.00177, "epss_percentile": 0.39629}, "CVE-2022-41936": {"epss_score": 0.00275, "epss_percentile": 0.50654}, "CVE-2022-41937": {"epss_score": 0.09729, "epss_percentile": 0.92679}, "CVE-2022-41938": {"epss_score": 0.01102, "epss_percentile": 0.77579}, "CVE-2022-41939": {"epss_score": 0.00339, "epss_percentile": 0.56204}, "CVE-2022-41940": {"epss_score": 0.02773, "epss_percentile": 0.85628}, "CVE-2022-41941": {"epss_score": 0.00094, "epss_percentile": 0.27068}, "CVE-2022-41942": {"epss_score": 0.0027, "epss_percentile": 0.50196}, "CVE-2022-41943": {"epss_score": 0.00255, "epss_percentile": 0.48643}, "CVE-2022-41944": {"epss_score": 0.00189, "epss_percentile": 0.40925}, "CVE-2022-41945": {"epss_score": 0.00535, "epss_percentile": 0.6684}, "CVE-2022-41946": {"epss_score": 0.00096, "epss_percentile": 0.27338}, "CVE-2022-41947": {"epss_score": 0.00216, "epss_percentile": 0.4416}, "CVE-2022-41948": {"epss_score": 0.00339, "epss_percentile": 0.56195}, "CVE-2022-41949": {"epss_score": 0.00143, "epss_percentile": 0.35216}, "CVE-2022-41950": {"epss_score": 0.00176, "epss_percentile": 0.39424}, "CVE-2022-41951": {"epss_score": 0.00414, "epss_percentile": 0.61104}, "CVE-2022-41952": {"epss_score": 0.00523, "epss_percentile": 0.6631}, "CVE-2022-41953": {"epss_score": 0.00996, "epss_percentile": 0.76453}, "CVE-2022-41954": {"epss_score": 0.00023, "epss_percentile": 0.05349}, "CVE-2022-41955": {"epss_score": 0.02824, "epss_percentile": 0.85754}, "CVE-2022-41956": {"epss_score": 0.00354, "epss_percentile": 0.57215}, "CVE-2022-41957": {"epss_score": 0.00348, "epss_percentile": 0.56839}, "CVE-2022-41958": {"epss_score": 0.00291, "epss_percentile": 0.52192}, "CVE-2022-41960": {"epss_score": 0.0017, "epss_percentile": 0.38766}, "CVE-2022-41961": {"epss_score": 0.00121, "epss_percentile": 0.31918}, "CVE-2022-41962": {"epss_score": 0.00164, "epss_percentile": 0.37908}, "CVE-2022-41963": {"epss_score": 0.00165, "epss_percentile": 0.38062}, "CVE-2022-41964": {"epss_score": 0.00287, "epss_percentile": 0.51863}, "CVE-2022-41965": {"epss_score": 0.00203, "epss_percentile": 0.42564}, "CVE-2022-41966": {"epss_score": 0.04274, "epss_percentile": 0.88479}, "CVE-2022-41967": {"epss_score": 0.00279, "epss_percentile": 0.50958}, "CVE-2022-41968": {"epss_score": 0.00344, "epss_percentile": 0.56484}, "CVE-2022-41969": {"epss_score": 0.00231, "epss_percentile": 0.45776}, "CVE-2022-41970": {"epss_score": 0.00127, "epss_percentile": 0.32812}, "CVE-2022-41971": {"epss_score": 0.0031, "epss_percentile": 0.53785}, "CVE-2022-41972": {"epss_score": 0.00055, "epss_percentile": 0.17571}, "CVE-2022-41973": {"epss_score": 0.00231, "epss_percentile": 0.45832}, "CVE-2022-41974": {"epss_score": 0.00025, "epss_percentile": 0.0637}, "CVE-2022-41975": {"epss_score": 0.00098, "epss_percentile": 0.27821}, "CVE-2022-41976": {"epss_score": 0.00555, "epss_percentile": 0.67473}, "CVE-2022-41977": {"epss_score": 0.00081, "epss_percentile": 0.24369}, "CVE-2022-41978": {"epss_score": 0.04283, "epss_percentile": 0.88491}, "CVE-2022-41979": {"epss_score": 0.00127, "epss_percentile": 0.3294}, "CVE-2022-41980": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-41981": {"epss_score": 0.00275, "epss_percentile": 0.5067}, "CVE-2022-41982": {"epss_score": 0.0007, "epss_percentile": 0.21972}, "CVE-2022-41983": {"epss_score": 0.0013, "epss_percentile": 0.33223}, "CVE-2022-41984": {"epss_score": 0.00028, "epss_percentile": 0.07494}, "CVE-2022-41985": {"epss_score": 0.00047, "epss_percentile": 0.14611}, "CVE-2022-41986": {"epss_score": 0.003, "epss_percentile": 0.52917}, "CVE-2022-41987": {"epss_score": 0.00055, "epss_percentile": 0.17546}, "CVE-2022-41988": {"epss_score": 0.00163, "epss_percentile": 0.37786}, "CVE-2022-41989": {"epss_score": 0.00227, "epss_percentile": 0.45372}, "CVE-2022-41990": {"epss_score": 0.00065, "epss_percentile": 0.20566}, "CVE-2022-41991": {"epss_score": 0.00554, "epss_percentile": 0.67454}, "CVE-2022-41992": {"epss_score": 0.00195, "epss_percentile": 0.41663}, "CVE-2022-41993": {"epss_score": 0.00414, "epss_percentile": 0.61033}, "CVE-2022-41994": {"epss_score": 0.00143, "epss_percentile": 0.35207}, "CVE-2022-41995": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2022-41996": {"epss_score": 0.0054, "epss_percentile": 0.67014}, "CVE-2022-41998": {"epss_score": 0.00096, "epss_percentile": 0.27287}, "CVE-2022-41999": {"epss_score": 0.00141, "epss_percentile": 0.34819}, "CVE-2022-42000": {"epss_score": 0.00298, "epss_percentile": 0.52822}, "CVE-2022-42001": {"epss_score": 0.00298, "epss_percentile": 0.52822}, "CVE-2022-42002": {"epss_score": 0.00342, "epss_percentile": 0.5638}, "CVE-2022-42003": {"epss_score": 0.00328, "epss_percentile": 0.55278}, "CVE-2022-42004": {"epss_score": 0.00259, "epss_percentile": 0.49046}, "CVE-2022-42009": {"epss_score": 0.00186, "epss_percentile": 0.40619}, "CVE-2022-42010": {"epss_score": 0.00057, "epss_percentile": 0.17993}, "CVE-2022-42011": {"epss_score": 0.00106, "epss_percentile": 0.29408}, "CVE-2022-42012": {"epss_score": 0.00107, "epss_percentile": 0.29584}, "CVE-2022-42021": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-42029": {"epss_score": 0.00435, "epss_percentile": 0.62373}, "CVE-2022-42034": {"epss_score": 0.00882, "epss_percentile": 0.74896}, "CVE-2022-42036": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-42037": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-42038": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-42039": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-42040": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-42041": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-42042": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-42043": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-42044": {"epss_score": 0.0045, "epss_percentile": 0.63064}, "CVE-2022-42045": {"epss_score": 0.00681, "epss_percentile": 0.71051}, "CVE-2022-42046": {"epss_score": 0.00993, "epss_percentile": 0.76403}, "CVE-2022-42053": {"epss_score": 0.0136, "epss_percentile": 0.79744}, "CVE-2022-42054": {"epss_score": 0.00317, "epss_percentile": 0.54362}, "CVE-2022-42055": {"epss_score": 0.03246, "epss_percentile": 0.86743}, "CVE-2022-42058": {"epss_score": 0.01081, "epss_percentile": 0.77376}, "CVE-2022-42060": {"epss_score": 0.00531, "epss_percentile": 0.66654}, "CVE-2022-42064": {"epss_score": 0.00238, "epss_percentile": 0.4675}, "CVE-2022-42066": {"epss_score": 0.00206, "epss_percentile": 0.43032}, "CVE-2022-42067": {"epss_score": 0.00076, "epss_percentile": 0.23261}, "CVE-2022-42069": {"epss_score": 0.00103, "epss_percentile": 0.29091}, "CVE-2022-42070": {"epss_score": 0.00078, "epss_percentile": 0.2367}, "CVE-2022-42071": {"epss_score": 0.00111, "epss_percentile": 0.30289}, "CVE-2022-42073": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-42074": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-42075": {"epss_score": 0.00894, "epss_percentile": 0.75084}, "CVE-2022-42077": {"epss_score": 0.00096, "epss_percentile": 0.27318}, "CVE-2022-42078": {"epss_score": 0.00096, "epss_percentile": 0.27318}, "CVE-2022-42079": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-42080": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-42081": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-42086": {"epss_score": 0.00096, "epss_percentile": 0.27318}, "CVE-2022-42087": {"epss_score": 0.00096, "epss_percentile": 0.27318}, "CVE-2022-42092": {"epss_score": 0.01727, "epss_percentile": 0.81969}, "CVE-2022-42094": {"epss_score": 0.18257, "epss_percentile": 0.94982}, "CVE-2022-42095": {"epss_score": 0.53152, "epss_percentile": 0.97858}, "CVE-2022-42096": {"epss_score": 0.21351, "epss_percentile": 0.95505}, "CVE-2022-42097": {"epss_score": 0.00623, "epss_percentile": 0.69552}, "CVE-2022-42098": {"epss_score": 0.01591, "epss_percentile": 0.81221}, "CVE-2022-42099": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-42100": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-42109": {"epss_score": 0.0084, "epss_percentile": 0.74213}, "CVE-2022-42110": {"epss_score": 0.00475, "epss_percentile": 0.64199}, "CVE-2022-42111": {"epss_score": 0.00175, "epss_percentile": 0.3928}, "CVE-2022-42112": {"epss_score": 0.00216, "epss_percentile": 0.44162}, "CVE-2022-42113": {"epss_score": 0.00197, "epss_percentile": 0.41972}, "CVE-2022-42114": {"epss_score": 0.002, "epss_percentile": 0.42214}, "CVE-2022-42115": {"epss_score": 0.002, "epss_percentile": 0.42214}, "CVE-2022-42116": {"epss_score": 0.00197, "epss_percentile": 0.41972}, "CVE-2022-42117": {"epss_score": 0.00096, "epss_percentile": 0.27354}, "CVE-2022-42118": {"epss_score": 0.08478, "epss_percentile": 0.92072}, "CVE-2022-42119": {"epss_score": 0.0064, "epss_percentile": 0.69961}, "CVE-2022-42120": {"epss_score": 0.00815, "epss_percentile": 0.73781}, "CVE-2022-42121": {"epss_score": 0.00605, "epss_percentile": 0.68969}, "CVE-2022-42122": {"epss_score": 0.00815, "epss_percentile": 0.73781}, "CVE-2022-42123": {"epss_score": 0.00418, "epss_percentile": 0.61289}, "CVE-2022-42124": {"epss_score": 0.01185, "epss_percentile": 0.78339}, "CVE-2022-42125": {"epss_score": 0.00418, "epss_percentile": 0.61289}, "CVE-2022-42126": {"epss_score": 0.00144, "epss_percentile": 0.35336}, "CVE-2022-42127": {"epss_score": 0.00186, "epss_percentile": 0.40635}, "CVE-2022-42128": {"epss_score": 0.00186, "epss_percentile": 0.40635}, "CVE-2022-42129": {"epss_score": 0.00191, "epss_percentile": 0.41169}, "CVE-2022-42130": {"epss_score": 0.00191, "epss_percentile": 0.41169}, "CVE-2022-42131": {"epss_score": 0.0013, "epss_percentile": 0.33223}, "CVE-2022-42132": {"epss_score": 0.00328, "epss_percentile": 0.55271}, "CVE-2022-42136": {"epss_score": 0.00172, "epss_percentile": 0.38908}, "CVE-2022-42139": {"epss_score": 0.34529, "epss_percentile": 0.96853}, "CVE-2022-42140": {"epss_score": 0.00743, "epss_percentile": 0.72501}, "CVE-2022-42141": {"epss_score": 0.00317, "epss_percentile": 0.54362}, "CVE-2022-42142": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-42143": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-42147": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-42149": {"epss_score": 0.42841, "epss_percentile": 0.97357}, "CVE-2022-42150": {"epss_score": 0.0026, "epss_percentile": 0.49149}, "CVE-2022-42154": {"epss_score": 0.0076, "epss_percentile": 0.72802}, "CVE-2022-42156": {"epss_score": 0.09235, "epss_percentile": 0.9246}, "CVE-2022-42159": {"epss_score": 0.0051, "epss_percentile": 0.65764}, "CVE-2022-42160": {"epss_score": 0.09235, "epss_percentile": 0.9246}, "CVE-2022-42161": {"epss_score": 0.09235, "epss_percentile": 0.9246}, "CVE-2022-42163": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-42164": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-42165": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-42166": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-42167": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-42168": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-42169": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-42170": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-42171": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-42175": {"epss_score": 0.00065, "epss_percentile": 0.20557}, "CVE-2022-42176": {"epss_score": 0.00122, "epss_percentile": 0.32097}, "CVE-2022-42182": {"epss_score": 0.00579, "epss_percentile": 0.68213}, "CVE-2022-42183": {"epss_score": 0.00176, "epss_percentile": 0.39492}, "CVE-2022-42187": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2022-42188": {"epss_score": 0.00397, "epss_percentile": 0.60051}, "CVE-2022-42189": {"epss_score": 0.02579, "epss_percentile": 0.85149}, "CVE-2022-42197": {"epss_score": 0.00125, "epss_percentile": 0.32479}, "CVE-2022-42198": {"epss_score": 0.004, "epss_percentile": 0.60178}, "CVE-2022-42199": {"epss_score": 0.0016, "epss_percentile": 0.37468}, "CVE-2022-42200": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-42201": {"epss_score": 0.00427, "epss_percentile": 0.61775}, "CVE-2022-42202": {"epss_score": 0.00112, "epss_percentile": 0.30474}, "CVE-2022-42205": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-42206": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-42218": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-42221": {"epss_score": 0.02583, "epss_percentile": 0.85159}, "CVE-2022-42225": {"epss_score": 0.00126, "epss_percentile": 0.32757}, "CVE-2022-42227": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-42229": {"epss_score": 0.00882, "epss_percentile": 0.74896}, "CVE-2022-42230": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-42232": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-42233": {"epss_score": 0.84385, "epss_percentile": 0.99287}, "CVE-2022-42234": {"epss_score": 0.00335, "epss_percentile": 0.55839}, "CVE-2022-42235": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-42236": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-42237": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-42238": {"epss_score": 0.00308, "epss_percentile": 0.53571}, "CVE-2022-42241": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-42242": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-42243": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-42245": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-42246": {"epss_score": 0.00112, "epss_percentile": 0.30493}, "CVE-2022-42247": {"epss_score": 0.00491, "epss_percentile": 0.64947}, "CVE-2022-42248": {"epss_score": 0.0009, "epss_percentile": 0.26074}, "CVE-2022-42249": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-42250": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-42252": {"epss_score": 0.00184, "epss_percentile": 0.4042}, "CVE-2022-42254": {"epss_score": 0.00042, "epss_percentile": 0.12816}, "CVE-2022-42255": {"epss_score": 0.00048, "epss_percentile": 0.15024}, "CVE-2022-42256": {"epss_score": 0.00035, "epss_percentile": 0.1007}, "CVE-2022-42257": {"epss_score": 0.00039, "epss_percentile": 0.11696}, "CVE-2022-42258": {"epss_score": 0.00033, "epss_percentile": 0.09163}, "CVE-2022-42259": {"epss_score": 0.00042, "epss_percentile": 0.12768}, "CVE-2022-42260": {"epss_score": 0.00168, "epss_percentile": 0.38406}, "CVE-2022-42261": {"epss_score": 0.00128, "epss_percentile": 0.32955}, "CVE-2022-42262": {"epss_score": 0.00116, "epss_percentile": 0.31147}, "CVE-2022-42263": {"epss_score": 0.00104, "epss_percentile": 0.2917}, "CVE-2022-42264": {"epss_score": 0.00106, "epss_percentile": 0.29506}, "CVE-2022-42265": {"epss_score": 0.00046, "epss_percentile": 0.14306}, "CVE-2022-42266": {"epss_score": 0.00113, "epss_percentile": 0.30674}, "CVE-2022-42267": {"epss_score": 0.00086, "epss_percentile": 0.2544}, "CVE-2022-42268": {"epss_score": 0.00402, "epss_percentile": 0.60285}, "CVE-2022-42269": {"epss_score": 0.00058, "epss_percentile": 0.18515}, "CVE-2022-42270": {"epss_score": 0.00144, "epss_percentile": 0.35348}, "CVE-2022-42271": {"epss_score": 0.00091, "epss_percentile": 0.26247}, "CVE-2022-42272": {"epss_score": 0.00469, "epss_percentile": 0.6392}, "CVE-2022-42273": {"epss_score": 0.00379, "epss_percentile": 0.58879}, "CVE-2022-42274": {"epss_score": 0.00091, "epss_percentile": 0.26247}, "CVE-2022-42275": {"epss_score": 0.00011, "epss_percentile": 0.01005}, "CVE-2022-42276": {"epss_score": 0.00036, "epss_percentile": 0.10376}, "CVE-2022-42277": {"epss_score": 0.00036, "epss_percentile": 0.10376}, "CVE-2022-42278": {"epss_score": 0.00182, "epss_percentile": 0.40188}, "CVE-2022-42279": {"epss_score": 0.00576, "epss_percentile": 0.68125}, "CVE-2022-42280": {"epss_score": 0.00021, "epss_percentile": 0.04942}, "CVE-2022-42281": {"epss_score": 0.00042, "epss_percentile": 0.12927}, "CVE-2022-42282": {"epss_score": 0.00154, "epss_percentile": 0.3671}, "CVE-2022-42283": {"epss_score": 0.00059, "epss_percentile": 0.18678}, "CVE-2022-42284": {"epss_score": 0.0004, "epss_percentile": 0.12177}, "CVE-2022-42285": {"epss_score": 0.00037, "epss_percentile": 0.10671}, "CVE-2022-42286": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2022-42287": {"epss_score": 0.00041, "epss_percentile": 0.12247}, "CVE-2022-42288": {"epss_score": 0.00294, "epss_percentile": 0.52384}, "CVE-2022-42289": {"epss_score": 0.00461, "epss_percentile": 0.63565}, "CVE-2022-42290": {"epss_score": 0.00424, "epss_percentile": 0.61672}, "CVE-2022-42291": {"epss_score": 0.0006, "epss_percentile": 0.19174}, "CVE-2022-42292": {"epss_score": 0.00045, "epss_percentile": 0.13788}, "CVE-2022-42299": {"epss_score": 0.00277, "epss_percentile": 0.50844}, "CVE-2022-42300": {"epss_score": 0.00462, "epss_percentile": 0.6358}, "CVE-2022-42301": {"epss_score": 0.0024, "epss_percentile": 0.47195}, "CVE-2022-42302": {"epss_score": 0.00714, "epss_percentile": 0.71816}, "CVE-2022-42303": {"epss_score": 0.00741, "epss_percentile": 0.72434}, "CVE-2022-42304": {"epss_score": 0.00741, "epss_percentile": 0.72434}, "CVE-2022-42305": {"epss_score": 0.00382, "epss_percentile": 0.59044}, "CVE-2022-42306": {"epss_score": 0.00093, "epss_percentile": 0.26677}, "CVE-2022-42307": {"epss_score": 0.00178, "epss_percentile": 0.39737}, "CVE-2022-42308": {"epss_score": 0.00165, "epss_percentile": 0.38131}, "CVE-2022-42309": {"epss_score": 0.00053, "epss_percentile": 0.16912}, "CVE-2022-42310": {"epss_score": 0.00023, "epss_percentile": 0.05332}, "CVE-2022-42311": {"epss_score": 0.00087, "epss_percentile": 0.2558}, "CVE-2022-42312": {"epss_score": 0.00065, "epss_percentile": 0.20577}, "CVE-2022-42313": {"epss_score": 0.00065, "epss_percentile": 0.20577}, "CVE-2022-42314": {"epss_score": 0.00065, "epss_percentile": 0.20577}, "CVE-2022-42315": {"epss_score": 0.00065, "epss_percentile": 0.20577}, "CVE-2022-42316": {"epss_score": 0.00089, "epss_percentile": 0.25795}, "CVE-2022-42317": {"epss_score": 0.00087, "epss_percentile": 0.2558}, "CVE-2022-42318": {"epss_score": 0.00064, "epss_percentile": 0.20349}, "CVE-2022-42319": {"epss_score": 0.00025, "epss_percentile": 0.06112}, "CVE-2022-42320": {"epss_score": 0.0004, "epss_percentile": 0.12122}, "CVE-2022-42321": {"epss_score": 0.00029, "epss_percentile": 0.07859}, "CVE-2022-42322": {"epss_score": 0.00033, "epss_percentile": 0.09411}, "CVE-2022-42323": {"epss_score": 0.00033, "epss_percentile": 0.09411}, "CVE-2022-42324": {"epss_score": 0.00024, "epss_percentile": 0.05884}, "CVE-2022-42325": {"epss_score": 0.00033, "epss_percentile": 0.09411}, "CVE-2022-42326": {"epss_score": 0.00033, "epss_percentile": 0.09246}, "CVE-2022-42327": {"epss_score": 0.00012, "epss_percentile": 0.01321}, "CVE-2022-42328": {"epss_score": 0.00013, "epss_percentile": 0.01556}, "CVE-2022-42329": {"epss_score": 0.00015, "epss_percentile": 0.02419}, "CVE-2022-42330": {"epss_score": 0.00192, "epss_percentile": 0.41353}, "CVE-2022-42331": {"epss_score": 0.00043, "epss_percentile": 0.13213}, "CVE-2022-42332": {"epss_score": 0.00037, "epss_percentile": 0.10723}, "CVE-2022-42333": {"epss_score": 0.00395, "epss_percentile": 0.59805}, "CVE-2022-42334": {"epss_score": 0.00046, "epss_percentile": 0.1416}, "CVE-2022-42335": {"epss_score": 0.00063, "epss_percentile": 0.19928}, "CVE-2022-42336": {"epss_score": 0.00048, "epss_percentile": 0.15243}, "CVE-2022-42339": {"epss_score": 0.00366, "epss_percentile": 0.5808}, "CVE-2022-42340": {"epss_score": 0.03021, "epss_percentile": 0.86225}, "CVE-2022-42341": {"epss_score": 0.01577, "epss_percentile": 0.81119}, "CVE-2022-42342": {"epss_score": 0.00069, "epss_percentile": 0.21514}, "CVE-2022-42343": {"epss_score": 0.00799, "epss_percentile": 0.7353}, "CVE-2022-42344": {"epss_score": 0.00165, "epss_percentile": 0.38064}, "CVE-2022-42345": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42346": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42348": {"epss_score": 0.00698, "epss_percentile": 0.7143}, "CVE-2022-42349": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42350": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42351": {"epss_score": 0.00204, "epss_percentile": 0.42624}, "CVE-2022-42352": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42354": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42356": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42357": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42360": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42362": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42364": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42365": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42366": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42367": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-42369": {"epss_score": 0.0071, "epss_percentile": 0.71716}, "CVE-2022-42370": {"epss_score": 0.01605, "epss_percentile": 0.81294}, "CVE-2022-42371": {"epss_score": 0.0218, "epss_percentile": 0.83901}, "CVE-2022-42372": {"epss_score": 0.02107, "epss_percentile": 0.83635}, "CVE-2022-42373": {"epss_score": 0.0218, "epss_percentile": 0.83901}, "CVE-2022-42374": {"epss_score": 0.0218, "epss_percentile": 0.83901}, "CVE-2022-42375": {"epss_score": 0.0093, "epss_percentile": 0.75598}, "CVE-2022-42376": {"epss_score": 0.0093, "epss_percentile": 0.75598}, "CVE-2022-42377": {"epss_score": 0.01665, "epss_percentile": 0.81648}, "CVE-2022-42378": {"epss_score": 0.0218, "epss_percentile": 0.83901}, "CVE-2022-42379": {"epss_score": 0.02246, "epss_percentile": 0.8413}, "CVE-2022-42380": {"epss_score": 0.0218, "epss_percentile": 0.83901}, "CVE-2022-42381": {"epss_score": 0.02933, "epss_percentile": 0.86019}, "CVE-2022-42382": {"epss_score": 0.01568, "epss_percentile": 0.81077}, "CVE-2022-42383": {"epss_score": 0.0093, "epss_percentile": 0.75598}, "CVE-2022-42384": {"epss_score": 0.00636, "epss_percentile": 0.69869}, "CVE-2022-42385": {"epss_score": 0.00846, "epss_percentile": 0.74327}, "CVE-2022-42386": {"epss_score": 0.00612, "epss_percentile": 0.69236}, "CVE-2022-42387": {"epss_score": 0.00612, "epss_percentile": 0.69236}, "CVE-2022-42388": {"epss_score": 0.00686, "epss_percentile": 0.7116}, "CVE-2022-42389": {"epss_score": 0.00686, "epss_percentile": 0.7116}, "CVE-2022-42390": {"epss_score": 0.00686, "epss_percentile": 0.7116}, "CVE-2022-42391": {"epss_score": 0.00686, "epss_percentile": 0.7116}, "CVE-2022-42392": {"epss_score": 0.00686, "epss_percentile": 0.7116}, "CVE-2022-42393": {"epss_score": 0.00636, "epss_percentile": 0.69869}, "CVE-2022-42394": {"epss_score": 0.0218, "epss_percentile": 0.83901}, "CVE-2022-42395": {"epss_score": 0.01562, "epss_percentile": 0.81046}, "CVE-2022-42396": {"epss_score": 0.01616, "epss_percentile": 0.81362}, "CVE-2022-42397": {"epss_score": 0.00846, "epss_percentile": 0.74327}, "CVE-2022-42398": {"epss_score": 0.00846, "epss_percentile": 0.74327}, "CVE-2022-42399": {"epss_score": 0.0218, "epss_percentile": 0.83901}, "CVE-2022-42400": {"epss_score": 0.01562, "epss_percentile": 0.81046}, "CVE-2022-42401": {"epss_score": 0.00846, "epss_percentile": 0.74327}, "CVE-2022-42402": {"epss_score": 0.01562, "epss_percentile": 0.81046}, "CVE-2022-42403": {"epss_score": 0.01616, "epss_percentile": 0.81362}, "CVE-2022-42404": {"epss_score": 0.00636, "epss_percentile": 0.69869}, "CVE-2022-42405": {"epss_score": 0.01155, "epss_percentile": 0.78075}, "CVE-2022-42406": {"epss_score": 0.00846, "epss_percentile": 0.74327}, "CVE-2022-42407": {"epss_score": 0.00846, "epss_percentile": 0.74327}, "CVE-2022-42408": {"epss_score": 0.00905, "epss_percentile": 0.75231}, "CVE-2022-42409": {"epss_score": 0.00636, "epss_percentile": 0.69869}, "CVE-2022-42410": {"epss_score": 0.02246, "epss_percentile": 0.8413}, "CVE-2022-42411": {"epss_score": 0.00636, "epss_percentile": 0.69869}, "CVE-2022-42412": {"epss_score": 0.0093, "epss_percentile": 0.75598}, "CVE-2022-42413": {"epss_score": 0.0093, "epss_percentile": 0.75598}, "CVE-2022-42414": {"epss_score": 0.01319, "epss_percentile": 0.79437}, "CVE-2022-42415": {"epss_score": 0.03015, "epss_percentile": 0.86213}, "CVE-2022-42416": {"epss_score": 0.03015, "epss_percentile": 0.86213}, "CVE-2022-42417": {"epss_score": 0.03162, "epss_percentile": 0.86534}, "CVE-2022-42418": {"epss_score": 0.02242, "epss_percentile": 0.84119}, "CVE-2022-42419": {"epss_score": 0.03015, "epss_percentile": 0.86213}, "CVE-2022-42420": {"epss_score": 0.03015, "epss_percentile": 0.86213}, "CVE-2022-42421": {"epss_score": 0.03015, "epss_percentile": 0.86213}, "CVE-2022-42423": {"epss_score": 0.03162, "epss_percentile": 0.86534}, "CVE-2022-42424": {"epss_score": 0.60201, "epss_percentile": 0.98198}, "CVE-2022-42425": {"epss_score": 0.60201, "epss_percentile": 0.98198}, "CVE-2022-42426": {"epss_score": 0.08595, "epss_percentile": 0.92142}, "CVE-2022-42427": {"epss_score": 0.60201, "epss_percentile": 0.98198}, "CVE-2022-42428": {"epss_score": 0.18386, "epss_percentile": 0.95009}, "CVE-2022-42429": {"epss_score": 0.60201, "epss_percentile": 0.98198}, "CVE-2022-42430": {"epss_score": 0.00092, "epss_percentile": 0.26508}, "CVE-2022-42431": {"epss_score": 0.00092, "epss_percentile": 0.26508}, "CVE-2022-42432": {"epss_score": 0.00065, "epss_percentile": 0.20445}, "CVE-2022-42433": {"epss_score": 0.00019, "epss_percentile": 0.041}, "CVE-2022-42435": {"epss_score": 0.00151, "epss_percentile": 0.36339}, "CVE-2022-42436": {"epss_score": 0.00033, "epss_percentile": 0.09397}, "CVE-2022-42438": {"epss_score": 0.00085, "epss_percentile": 0.25163}, "CVE-2022-42439": {"epss_score": 0.00086, "epss_percentile": 0.25283}, "CVE-2022-42442": {"epss_score": 0.00114, "epss_percentile": 0.30751}, "CVE-2022-42443": {"epss_score": 0.00059, "epss_percentile": 0.18822}, "CVE-2022-42444": {"epss_score": 0.00087, "epss_percentile": 0.25496}, "CVE-2022-42445": {"epss_score": 0.00138, "epss_percentile": 0.34511}, "CVE-2022-42446": {"epss_score": 0.00236, "epss_percentile": 0.46452}, "CVE-2022-42447": {"epss_score": 0.00644, "epss_percentile": 0.70069}, "CVE-2022-42449": {"epss_score": 0.00052, "epss_percentile": 0.16669}, "CVE-2022-42450": {"epss_score": 0.00027, "epss_percentile": 0.06915}, "CVE-2022-42451": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2022-42452": {"epss_score": 0.00386, "epss_percentile": 0.5926}, "CVE-2022-42453": {"epss_score": 0.00103, "epss_percentile": 0.29076}, "CVE-2022-42454": {"epss_score": 0.00123, "epss_percentile": 0.32329}, "CVE-2022-42455": {"epss_score": 0.00034, "epss_percentile": 0.09707}, "CVE-2022-42457": {"epss_score": 0.06451, "epss_percentile": 0.90764}, "CVE-2022-42458": {"epss_score": 0.03357, "epss_percentile": 0.86978}, "CVE-2022-42459": {"epss_score": 0.00659, "epss_percentile": 0.70506}, "CVE-2022-42460": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-42461": {"epss_score": 0.00573, "epss_percentile": 0.68048}, "CVE-2022-42462": {"epss_score": 0.00113, "epss_percentile": 0.30642}, "CVE-2022-42463": {"epss_score": 0.00103, "epss_percentile": 0.28921}, "CVE-2022-42464": {"epss_score": 0.00035, "epss_percentile": 0.09943}, "CVE-2022-42465": {"epss_score": 0.00072, "epss_percentile": 0.22388}, "CVE-2022-42466": {"epss_score": 0.2198, "epss_percentile": 0.95581}, "CVE-2022-42467": {"epss_score": 0.00431, "epss_percentile": 0.62065}, "CVE-2022-42468": {"epss_score": 0.01883, "epss_percentile": 0.82701}, "CVE-2022-42469": {"epss_score": 0.00057, "epss_percentile": 0.17986}, "CVE-2022-42470": {"epss_score": 0.00084, "epss_percentile": 0.2489}, "CVE-2022-42471": {"epss_score": 0.00271, "epss_percentile": 0.50297}, "CVE-2022-42472": {"epss_score": 0.00507, "epss_percentile": 0.65647}, "CVE-2022-42473": {"epss_score": 0.00049, "epss_percentile": 0.1565}, "CVE-2022-42474": {"epss_score": 0.00211, "epss_percentile": 0.43681}, "CVE-2022-42475": {"epss_score": 0.94062, "epss_percentile": 0.99895}, "CVE-2022-42476": {"epss_score": 0.00074, "epss_percentile": 0.22693}, "CVE-2022-42477": {"epss_score": 0.0005, "epss_percentile": 0.15973}, "CVE-2022-42478": {"epss_score": 0.00159, "epss_percentile": 0.373}, "CVE-2022-42484": {"epss_score": 0.00278, "epss_percentile": 0.50889}, "CVE-2022-42485": {"epss_score": 0.00137, "epss_percentile": 0.34216}, "CVE-2022-42486": {"epss_score": 0.00144, "epss_percentile": 0.35341}, "CVE-2022-42488": {"epss_score": 0.0005, "epss_percentile": 0.1582}, "CVE-2022-42490": {"epss_score": 0.01098, "epss_percentile": 0.77542}, "CVE-2022-42491": {"epss_score": 0.01098, "epss_percentile": 0.77542}, "CVE-2022-42492": {"epss_score": 0.01153, "epss_percentile": 0.78062}, "CVE-2022-42493": {"epss_score": 0.01098, "epss_percentile": 0.77542}, "CVE-2022-42494": {"epss_score": 0.00734, "epss_percentile": 0.72236}, "CVE-2022-42496": {"epss_score": 0.02345, "epss_percentile": 0.84447}, "CVE-2022-42497": {"epss_score": 0.02712, "epss_percentile": 0.85501}, "CVE-2022-42498": {"epss_score": 0.01491, "epss_percentile": 0.80633}, "CVE-2022-42499": {"epss_score": 0.0132, "epss_percentile": 0.79439}, "CVE-2022-42500": {"epss_score": 6e-05, "epss_percentile": 0.0031}, "CVE-2022-42501": {"epss_score": 0.00037, "epss_percentile": 0.11008}, "CVE-2022-42502": {"epss_score": 0.00037, "epss_percentile": 0.11008}, "CVE-2022-42503": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42504": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42505": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42506": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42507": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42508": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42509": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42510": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42511": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42512": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-42513": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42514": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-42515": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-42516": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-42517": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-42518": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-42519": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42520": {"epss_score": 0.00019, "epss_percentile": 0.04322}, "CVE-2022-42521": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42522": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-42523": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42524": {"epss_score": 0.0026, "epss_percentile": 0.49181}, "CVE-2022-42525": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42526": {"epss_score": 0.00016, "epss_percentile": 0.03016}, "CVE-2022-42527": {"epss_score": 0.00581, "epss_percentile": 0.68274}, "CVE-2022-42528": {"epss_score": 0.00018, "epss_percentile": 0.04027}, "CVE-2022-42529": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2022-42530": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-42531": {"epss_score": 0.00035, "epss_percentile": 0.09943}, "CVE-2022-42532": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2022-42533": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2022-42534": {"epss_score": 0.00037, "epss_percentile": 0.1063}, "CVE-2022-42535": {"epss_score": 0.00037, "epss_percentile": 0.10884}, "CVE-2022-42536": {"epss_score": 0.02426, "epss_percentile": 0.84716}, "CVE-2022-42537": {"epss_score": 0.02426, "epss_percentile": 0.84716}, "CVE-2022-42538": {"epss_score": 0.0012, "epss_percentile": 0.31705}, "CVE-2022-42539": {"epss_score": 0.0013, "epss_percentile": 0.33262}, "CVE-2022-42540": {"epss_score": 0.0012, "epss_percentile": 0.31705}, "CVE-2022-42541": {"epss_score": 0.02558, "epss_percentile": 0.85099}, "CVE-2022-42542": {"epss_score": 0.00029, "epss_percentile": 0.07666}, "CVE-2022-42543": {"epss_score": 0.00016, "epss_percentile": 0.02821}, "CVE-2022-42544": {"epss_score": 0.00058, "epss_percentile": 0.18599}, "CVE-2022-42698": {"epss_score": 0.00798, "epss_percentile": 0.73514}, "CVE-2022-42699": {"epss_score": 0.06901, "epss_percentile": 0.91104}, "CVE-2022-42703": {"epss_score": 0.00985, "epss_percentile": 0.76328}, "CVE-2022-42704": {"epss_score": 0.00243, "epss_percentile": 0.47478}, "CVE-2022-42705": {"epss_score": 0.00851, "epss_percentile": 0.74395}, "CVE-2022-42706": {"epss_score": 0.0022, "epss_percentile": 0.44592}, "CVE-2022-42707": {"epss_score": 0.0024, "epss_percentile": 0.47203}, "CVE-2022-42710": {"epss_score": 0.00258, "epss_percentile": 0.48952}, "CVE-2022-42711": {"epss_score": 0.00516, "epss_percentile": 0.66012}, "CVE-2022-42715": {"epss_score": 0.00464, "epss_percentile": 0.63712}, "CVE-2022-42716": {"epss_score": 0.00332, "epss_percentile": 0.55568}, "CVE-2022-42717": {"epss_score": 0.00099, "epss_percentile": 0.27842}, "CVE-2022-42718": {"epss_score": 0.0003, "epss_percentile": 0.08179}, "CVE-2022-42719": {"epss_score": 0.00534, "epss_percentile": 0.66783}, "CVE-2022-42720": {"epss_score": 0.00353, "epss_percentile": 0.57194}, "CVE-2022-42721": {"epss_score": 0.00024, "epss_percentile": 0.05971}, "CVE-2022-42722": {"epss_score": 0.00085, "epss_percentile": 0.25237}, "CVE-2022-42724": {"epss_score": 0.00232, "epss_percentile": 0.45932}, "CVE-2022-42725": {"epss_score": 0.00268, "epss_percentile": 0.50093}, "CVE-2022-42731": {"epss_score": 0.00202, "epss_percentile": 0.42404}, "CVE-2022-42732": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2022-42733": {"epss_score": 0.00322, "epss_percentile": 0.54856}, "CVE-2022-42734": {"epss_score": 0.00249, "epss_percentile": 0.4802}, "CVE-2022-42735": {"epss_score": 0.0037, "epss_percentile": 0.583}, "CVE-2022-42743": {"epss_score": 0.00312, "epss_percentile": 0.53963}, "CVE-2022-42744": {"epss_score": 0.00943, "epss_percentile": 0.75771}, "CVE-2022-42745": {"epss_score": 0.00536, "epss_percentile": 0.66848}, "CVE-2022-42746": {"epss_score": 0.03412, "epss_percentile": 0.87087}, "CVE-2022-42747": {"epss_score": 0.03115, "epss_percentile": 0.86433}, "CVE-2022-42748": {"epss_score": 0.02714, "epss_percentile": 0.85505}, "CVE-2022-42749": {"epss_score": 0.02714, "epss_percentile": 0.85505}, "CVE-2022-42750": {"epss_score": 0.00904, "epss_percentile": 0.75211}, "CVE-2022-42751": {"epss_score": 0.00115, "epss_percentile": 0.30959}, "CVE-2022-42753": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-42754": {"epss_score": 0.00016, "epss_percentile": 0.02723}, "CVE-2022-42755": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-42756": {"epss_score": 0.0003, "epss_percentile": 0.08287}, "CVE-2022-42757": {"epss_score": 0.00014, "epss_percentile": 0.01957}, "CVE-2022-42758": {"epss_score": 0.00014, "epss_percentile": 0.01957}, "CVE-2022-42759": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-42760": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-42761": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-42762": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-42763": {"epss_score": 0.00018, "epss_percentile": 0.03838}, "CVE-2022-42764": {"epss_score": 0.00018, "epss_percentile": 0.03838}, "CVE-2022-42765": {"epss_score": 0.00019, "epss_percentile": 0.04141}, "CVE-2022-42766": {"epss_score": 0.00014, "epss_percentile": 0.02013}, "CVE-2022-42767": {"epss_score": 0.0002, "epss_percentile": 0.04434}, "CVE-2022-42768": {"epss_score": 0.00079, "epss_percentile": 0.23902}, "CVE-2022-42769": {"epss_score": 0.00014, "epss_percentile": 0.01957}, "CVE-2022-42770": {"epss_score": 0.00011, "epss_percentile": 0.00926}, "CVE-2022-42771": {"epss_score": 0.00011, "epss_percentile": 0.00926}, "CVE-2022-42772": {"epss_score": 0.00015, "epss_percentile": 0.02248}, "CVE-2022-42773": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-42774": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-42775": {"epss_score": 0.00012, "epss_percentile": 0.01299}, "CVE-2022-42776": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2022-42777": {"epss_score": 0.00015, "epss_percentile": 0.02292}, "CVE-2022-42778": {"epss_score": 0.00016, "epss_percentile": 0.02724}, "CVE-2022-42779": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-42780": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-42781": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-42782": {"epss_score": 0.00014, "epss_percentile": 0.01745}, "CVE-2022-42783": {"epss_score": 0.00015, "epss_percentile": 0.02342}, "CVE-2022-42784": {"epss_score": 0.0013, "epss_percentile": 0.33311}, "CVE-2022-42785": {"epss_score": 0.02132, "epss_percentile": 0.83716}, "CVE-2022-42786": {"epss_score": 0.00123, "epss_percentile": 0.32309}, "CVE-2022-42787": {"epss_score": 0.00578, "epss_percentile": 0.68205}, "CVE-2022-42788": {"epss_score": 0.00059, "epss_percentile": 0.18618}, "CVE-2022-42789": {"epss_score": 0.00141, "epss_percentile": 0.34855}, "CVE-2022-42790": {"epss_score": 0.00143, "epss_percentile": 0.35101}, "CVE-2022-42791": {"epss_score": 0.00192, "epss_percentile": 0.41338}, "CVE-2022-42792": {"epss_score": 0.00053, "epss_percentile": 0.16866}, "CVE-2022-42793": {"epss_score": 0.00031, "epss_percentile": 0.0844}, "CVE-2022-42795": {"epss_score": 0.00849, "epss_percentile": 0.74377}, "CVE-2022-42796": {"epss_score": 0.00038, "epss_percentile": 0.11152}, "CVE-2022-42797": {"epss_score": 0.00078, "epss_percentile": 0.23783}, "CVE-2022-42798": {"epss_score": 0.00083, "epss_percentile": 0.24749}, "CVE-2022-42799": {"epss_score": 0.00882, "epss_percentile": 0.74899}, "CVE-2022-42800": {"epss_score": 0.00212, "epss_percentile": 0.4376}, "CVE-2022-42801": {"epss_score": 0.00238, "epss_percentile": 0.46833}, "CVE-2022-42803": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2022-42805": {"epss_score": 0.00048, "epss_percentile": 0.15139}, "CVE-2022-42806": {"epss_score": 0.00037, "epss_percentile": 0.10672}, "CVE-2022-42807": {"epss_score": 0.00082, "epss_percentile": 0.24407}, "CVE-2022-42808": {"epss_score": 0.02593, "epss_percentile": 0.85187}, "CVE-2022-42809": {"epss_score": 0.001, "epss_percentile": 0.28528}, "CVE-2022-42810": {"epss_score": 0.00069, "epss_percentile": 0.21467}, "CVE-2022-42811": {"epss_score": 0.00072, "epss_percentile": 0.22244}, "CVE-2022-42813": {"epss_score": 0.00709, "epss_percentile": 0.71694}, "CVE-2022-42814": {"epss_score": 0.00063, "epss_percentile": 0.19908}, "CVE-2022-42815": {"epss_score": 0.00067, "epss_percentile": 0.20996}, "CVE-2022-42816": {"epss_score": 0.00039, "epss_percentile": 0.11468}, "CVE-2022-42817": {"epss_score": 0.00408, "epss_percentile": 0.60625}, "CVE-2022-42818": {"epss_score": 0.00348, "epss_percentile": 0.56805}, "CVE-2022-42819": {"epss_score": 0.00156, "epss_percentile": 0.36895}, "CVE-2022-42820": {"epss_score": 0.00054, "epss_percentile": 0.17333}, "CVE-2022-42821": {"epss_score": 0.0001, "epss_percentile": 0.00898}, "CVE-2022-42823": {"epss_score": 0.00523, "epss_percentile": 0.66305}, "CVE-2022-42824": {"epss_score": 0.00029, "epss_percentile": 0.07842}, "CVE-2022-42825": {"epss_score": 0.00098, "epss_percentile": 0.27783}, "CVE-2022-42826": {"epss_score": 0.00094, "epss_percentile": 0.27067}, "CVE-2022-42827": {"epss_score": 0.00207, "epss_percentile": 0.43147}, "CVE-2022-42828": {"epss_score": 0.00185, "epss_percentile": 0.40519}, "CVE-2022-42829": {"epss_score": 0.00075, "epss_percentile": 0.22888}, "CVE-2022-42830": {"epss_score": 0.00049, "epss_percentile": 0.15495}, "CVE-2022-42831": {"epss_score": 0.00038, "epss_percentile": 0.11273}, "CVE-2022-42832": {"epss_score": 0.00038, "epss_percentile": 0.11273}, "CVE-2022-42833": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2022-42834": {"epss_score": 0.00034, "epss_percentile": 0.09786}, "CVE-2022-42837": {"epss_score": 0.05855, "epss_percentile": 0.90266}, "CVE-2022-42838": {"epss_score": 0.00073, "epss_percentile": 0.22613}, "CVE-2022-42839": {"epss_score": 0.00068, "epss_percentile": 0.21221}, "CVE-2022-42840": {"epss_score": 0.00167, "epss_percentile": 0.38386}, "CVE-2022-42841": {"epss_score": 0.00097, "epss_percentile": 0.27455}, "CVE-2022-42842": {"epss_score": 0.01875, "epss_percentile": 0.82656}, "CVE-2022-42843": {"epss_score": 0.00045, "epss_percentile": 0.13818}, "CVE-2022-42844": {"epss_score": 0.00172, "epss_percentile": 0.38975}, "CVE-2022-42845": {"epss_score": 0.00559, "epss_percentile": 0.67623}, "CVE-2022-42846": {"epss_score": 0.00056, "epss_percentile": 0.17716}, "CVE-2022-42847": {"epss_score": 0.00215, "epss_percentile": 0.44077}, "CVE-2022-42848": {"epss_score": 0.00296, "epss_percentile": 0.52589}, "CVE-2022-42849": {"epss_score": 0.00093, "epss_percentile": 0.26688}, "CVE-2022-42850": {"epss_score": 0.00122, "epss_percentile": 0.32019}, "CVE-2022-42851": {"epss_score": 0.00141, "epss_percentile": 0.34855}, "CVE-2022-42852": {"epss_score": 0.00846, "epss_percentile": 0.74333}, "CVE-2022-42853": {"epss_score": 0.00079, "epss_percentile": 0.23994}, "CVE-2022-42854": {"epss_score": 0.00034, "epss_percentile": 0.09729}, "CVE-2022-42855": {"epss_score": 0.00036, "epss_percentile": 0.10409}, "CVE-2022-42856": {"epss_score": 0.00259, "epss_percentile": 0.49036}, "CVE-2022-42858": {"epss_score": 0.00053, "epss_percentile": 0.16707}, "CVE-2022-42859": {"epss_score": 0.00056, "epss_percentile": 0.17949}, "CVE-2022-42860": {"epss_score": 0.00023, "epss_percentile": 0.05506}, "CVE-2022-42861": {"epss_score": 0.00079, "epss_percentile": 0.23918}, "CVE-2022-42862": {"epss_score": 0.00065, "epss_percentile": 0.2046}, "CVE-2022-42863": {"epss_score": 0.01018, "epss_percentile": 0.76699}, "CVE-2022-42864": {"epss_score": 0.06747, "epss_percentile": 0.90999}, "CVE-2022-42865": {"epss_score": 0.00019, "epss_percentile": 0.0407}, "CVE-2022-42866": {"epss_score": 0.00046, "epss_percentile": 0.14114}, "CVE-2022-42867": {"epss_score": 0.05716, "epss_percentile": 0.90146}, "CVE-2022-42878": {"epss_score": 0.00096, "epss_percentile": 0.2726}, "CVE-2022-42879": {"epss_score": 0.00056, "epss_percentile": 0.17959}, "CVE-2022-42880": {"epss_score": 0.00072, "epss_percentile": 0.22427}, "CVE-2022-42882": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-42883": {"epss_score": 0.00772, "epss_percentile": 0.73038}, "CVE-2022-42884": {"epss_score": 0.0009, "epss_percentile": 0.26121}, "CVE-2022-42885": {"epss_score": 0.00144, "epss_percentile": 0.35315}, "CVE-2022-42888": {"epss_score": 0.00261, "epss_percentile": 0.49261}, "CVE-2022-42889": {"epss_score": 0.94161, "epss_percentile": 0.9991}, "CVE-2022-42890": {"epss_score": 0.00341, "epss_percentile": 0.56345}, "CVE-2022-42891": {"epss_score": 0.00249, "epss_percentile": 0.4802}, "CVE-2022-42892": {"epss_score": 0.00269, "epss_percentile": 0.50151}, "CVE-2022-42893": {"epss_score": 0.00249, "epss_percentile": 0.4802}, "CVE-2022-42894": {"epss_score": 0.00317, "epss_percentile": 0.54334}, "CVE-2022-42895": {"epss_score": 0.0007, "epss_percentile": 0.21801}, "CVE-2022-42896": {"epss_score": 0.00457, "epss_percentile": 0.63368}, "CVE-2022-42897": {"epss_score": 0.02899, "epss_percentile": 0.85949}, "CVE-2022-42898": {"epss_score": 0.08368, "epss_percentile": 0.92011}, "CVE-2022-42899": {"epss_score": 0.00689, "epss_percentile": 0.71235}, "CVE-2022-42900": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2022-42901": {"epss_score": 0.00066, "epss_percentile": 0.20889}, "CVE-2022-42902": {"epss_score": 0.00943, "epss_percentile": 0.75776}, "CVE-2022-42903": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2022-42904": {"epss_score": 0.79442, "epss_percentile": 0.99038}, "CVE-2022-42905": {"epss_score": 0.04065, "epss_percentile": 0.88199}, "CVE-2022-42906": {"epss_score": 0.00295, "epss_percentile": 0.52507}, "CVE-2022-42908": {"epss_score": 0.00106, "epss_percentile": 0.29529}, "CVE-2022-42909": {"epss_score": 0.00083, "epss_percentile": 0.24753}, "CVE-2022-42915": {"epss_score": 0.00624, "epss_percentile": 0.69556}, "CVE-2022-42916": {"epss_score": 0.00086, "epss_percentile": 0.25294}, "CVE-2022-42919": {"epss_score": 0.00036, "epss_percentile": 0.10203}, "CVE-2022-42920": {"epss_score": 0.03365, "epss_percentile": 0.87}, "CVE-2022-42923": {"epss_score": 0.00225, "epss_percentile": 0.45222}, "CVE-2022-42924": {"epss_score": 0.00308, "epss_percentile": 0.53626}, "CVE-2022-42925": {"epss_score": 0.00709, "epss_percentile": 0.71696}, "CVE-2022-42927": {"epss_score": 0.00118, "epss_percentile": 0.31505}, "CVE-2022-42928": {"epss_score": 0.00155, "epss_percentile": 0.36795}, "CVE-2022-42929": {"epss_score": 0.00153, "epss_percentile": 0.36643}, "CVE-2022-42930": {"epss_score": 0.00275, "epss_percentile": 0.50654}, "CVE-2022-42931": {"epss_score": 0.00035, "epss_percentile": 0.09985}, "CVE-2022-42932": {"epss_score": 0.00245, "epss_percentile": 0.47707}, "CVE-2022-42933": {"epss_score": 0.00127, "epss_percentile": 0.32791}, "CVE-2022-42934": {"epss_score": 0.00234, "epss_percentile": 0.46098}, "CVE-2022-42935": {"epss_score": 0.00234, "epss_percentile": 0.46098}, "CVE-2022-42936": {"epss_score": 0.00225, "epss_percentile": 0.45118}, "CVE-2022-42937": {"epss_score": 0.00234, "epss_percentile": 0.46098}, "CVE-2022-42938": {"epss_score": 0.00234, "epss_percentile": 0.46098}, "CVE-2022-42939": {"epss_score": 0.00225, "epss_percentile": 0.45118}, "CVE-2022-42940": {"epss_score": 0.00225, "epss_percentile": 0.45118}, "CVE-2022-42941": {"epss_score": 0.00192, "epss_percentile": 0.41354}, "CVE-2022-42942": {"epss_score": 0.00225, "epss_percentile": 0.45118}, "CVE-2022-42943": {"epss_score": 0.00225, "epss_percentile": 0.45118}, "CVE-2022-42944": {"epss_score": 0.00225, "epss_percentile": 0.45118}, "CVE-2022-42945": {"epss_score": 0.00134, "epss_percentile": 0.33848}, "CVE-2022-42946": {"epss_score": 0.00128, "epss_percentile": 0.33045}, "CVE-2022-42947": {"epss_score": 0.00128, "epss_percentile": 0.33045}, "CVE-2022-42948": {"epss_score": 0.19512, "epss_percentile": 0.95195}, "CVE-2022-42949": {"epss_score": 0.00132, "epss_percentile": 0.33611}, "CVE-2022-42950": {"epss_score": 0.00247, "epss_percentile": 0.47867}, "CVE-2022-42951": {"epss_score": 0.00261, "epss_percentile": 0.49306}, "CVE-2022-42953": {"epss_score": 0.10877, "epss_percentile": 0.93143}, "CVE-2022-42954": {"epss_score": 0.00677, "epss_percentile": 0.70948}, "CVE-2022-42955": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2022-42956": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2022-42960": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-42961": {"epss_score": 0.00239, "epss_percentile": 0.46841}, "CVE-2022-42964": {"epss_score": 0.00213, "epss_percentile": 0.43901}, "CVE-2022-42965": {"epss_score": 0.00195, "epss_percentile": 0.4165}, "CVE-2022-42966": {"epss_score": 0.00124, "epss_percentile": 0.32374}, "CVE-2022-42967": {"epss_score": 0.00144, "epss_percentile": 0.35226}, "CVE-2022-42968": {"epss_score": 0.00525, "epss_percentile": 0.66371}, "CVE-2022-42969": {"epss_score": 0.00115, "epss_percentile": 0.30979}, "CVE-2022-42970": {"epss_score": 0.00374, "epss_percentile": 0.58549}, "CVE-2022-42971": {"epss_score": 0.05397, "epss_percentile": 0.89829}, "CVE-2022-42972": {"epss_score": 0.00054, "epss_percentile": 0.17257}, "CVE-2022-42973": {"epss_score": 0.00054, "epss_percentile": 0.17257}, "CVE-2022-42974": {"epss_score": 0.00081, "epss_percentile": 0.24291}, "CVE-2022-42975": {"epss_score": 0.00194, "epss_percentile": 0.41523}, "CVE-2022-42977": {"epss_score": 0.00843, "epss_percentile": 0.7426}, "CVE-2022-42978": {"epss_score": 0.01101, "epss_percentile": 0.77573}, "CVE-2022-42979": {"epss_score": 0.06352, "epss_percentile": 0.90692}, "CVE-2022-42980": {"epss_score": 0.00299, "epss_percentile": 0.52896}, "CVE-2022-42982": {"epss_score": 0.00423, "epss_percentile": 0.61587}, "CVE-2022-42983": {"epss_score": 0.00438, "epss_percentile": 0.62555}, "CVE-2022-42984": {"epss_score": 0.00732, "epss_percentile": 0.72199}, "CVE-2022-42985": {"epss_score": 0.00441, "epss_percentile": 0.62673}, "CVE-2022-42989": {"epss_score": 0.00502, "epss_percentile": 0.65368}, "CVE-2022-42990": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-42991": {"epss_score": 0.00385, "epss_percentile": 0.59202}, "CVE-2022-42992": {"epss_score": 0.00385, "epss_percentile": 0.59202}, "CVE-2022-42993": {"epss_score": 0.00385, "epss_percentile": 0.59202}, "CVE-2022-42998": {"epss_score": 0.01086, "epss_percentile": 0.77421}, "CVE-2022-42999": {"epss_score": 0.07152, "epss_percentile": 0.91287}, "CVE-2022-43000": {"epss_score": 0.01086, "epss_percentile": 0.77421}, "CVE-2022-43001": {"epss_score": 0.01086, "epss_percentile": 0.77421}, "CVE-2022-43002": {"epss_score": 0.01086, "epss_percentile": 0.77421}, "CVE-2022-43003": {"epss_score": 0.01086, "epss_percentile": 0.77421}, "CVE-2022-43014": {"epss_score": 0.01677, "epss_percentile": 0.81713}, "CVE-2022-43015": {"epss_score": 0.01677, "epss_percentile": 0.81713}, "CVE-2022-43016": {"epss_score": 0.0323, "epss_percentile": 0.86696}, "CVE-2022-43017": {"epss_score": 0.09911, "epss_percentile": 0.92769}, "CVE-2022-43018": {"epss_score": 0.09911, "epss_percentile": 0.92769}, "CVE-2022-43019": {"epss_score": 0.16353, "epss_percentile": 0.94633}, "CVE-2022-43020": {"epss_score": 0.00265, "epss_percentile": 0.49777}, "CVE-2022-43021": {"epss_score": 0.00242, "epss_percentile": 0.47382}, "CVE-2022-43022": {"epss_score": 0.00265, "epss_percentile": 0.49777}, "CVE-2022-43023": {"epss_score": 0.00265, "epss_percentile": 0.49777}, "CVE-2022-43024": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43025": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43026": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43027": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43028": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43029": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43030": {"epss_score": 0.02362, "epss_percentile": 0.84504}, "CVE-2022-43031": {"epss_score": 0.00313, "epss_percentile": 0.54071}, "CVE-2022-43032": {"epss_score": 0.00244, "epss_percentile": 0.47584}, "CVE-2022-43033": {"epss_score": 0.00247, "epss_percentile": 0.47848}, "CVE-2022-43034": {"epss_score": 0.00262, "epss_percentile": 0.49336}, "CVE-2022-43035": {"epss_score": 0.00244, "epss_percentile": 0.47584}, "CVE-2022-43037": {"epss_score": 0.00247, "epss_percentile": 0.47848}, "CVE-2022-43038": {"epss_score": 0.00262, "epss_percentile": 0.49336}, "CVE-2022-43039": {"epss_score": 0.00058, "epss_percentile": 0.18462}, "CVE-2022-43040": {"epss_score": 0.00053, "epss_percentile": 0.16851}, "CVE-2022-43042": {"epss_score": 0.00144, "epss_percentile": 0.35234}, "CVE-2022-43043": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-43044": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-43045": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2022-43046": {"epss_score": 0.0035, "epss_percentile": 0.56966}, "CVE-2022-43049": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43050": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-43051": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43052": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43058": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-43061": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-43062": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43063": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43066": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43068": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43071": {"epss_score": 0.00103, "epss_percentile": 0.28932}, "CVE-2022-43074": {"epss_score": 0.0076, "epss_percentile": 0.72802}, "CVE-2022-43076": {"epss_score": 0.0035, "epss_percentile": 0.56966}, "CVE-2022-43078": {"epss_score": 0.0035, "epss_percentile": 0.56966}, "CVE-2022-43079": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-43081": {"epss_score": 0.00251, "epss_percentile": 0.48283}, "CVE-2022-43082": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-43083": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-43084": {"epss_score": 0.0035, "epss_percentile": 0.56966}, "CVE-2022-43085": {"epss_score": 0.00455, "epss_percentile": 0.63283}, "CVE-2022-43086": {"epss_score": 0.0032, "epss_percentile": 0.54624}, "CVE-2022-43096": {"epss_score": 0.00124, "epss_percentile": 0.32454}, "CVE-2022-43097": {"epss_score": 0.00363, "epss_percentile": 0.57892}, "CVE-2022-43101": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43102": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43103": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43104": {"epss_score": 0.00342, "epss_percentile": 0.56355}, "CVE-2022-43105": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43106": {"epss_score": 0.00342, "epss_percentile": 0.56355}, "CVE-2022-43107": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43108": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43109": {"epss_score": 0.07961, "epss_percentile": 0.91791}, "CVE-2022-43110": {"epss_score": 0.00116, "epss_percentile": 0.31083}, "CVE-2022-43117": {"epss_score": 0.02631, "epss_percentile": 0.85282}, "CVE-2022-43118": {"epss_score": 0.00314, "epss_percentile": 0.54127}, "CVE-2022-43119": {"epss_score": 0.00372, "epss_percentile": 0.58446}, "CVE-2022-43120": {"epss_score": 0.00594, "epss_percentile": 0.68669}, "CVE-2022-43121": {"epss_score": 0.00638, "epss_percentile": 0.69929}, "CVE-2022-43124": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43125": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43126": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43127": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43135": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-43138": {"epss_score": 0.00434, "epss_percentile": 0.62296}, "CVE-2022-43140": {"epss_score": 0.79265, "epss_percentile": 0.99028}, "CVE-2022-43142": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-43143": {"epss_score": 0.00617, "epss_percentile": 0.69341}, "CVE-2022-43144": {"epss_score": 0.01911, "epss_percentile": 0.82829}, "CVE-2022-43146": {"epss_score": 0.0086, "epss_percentile": 0.7453}, "CVE-2022-43148": {"epss_score": 0.00049, "epss_percentile": 0.15477}, "CVE-2022-43151": {"epss_score": 0.00047, "epss_percentile": 0.14587}, "CVE-2022-43152": {"epss_score": 0.00049, "epss_percentile": 0.15477}, "CVE-2022-43162": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43163": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43164": {"epss_score": 0.05971, "epss_percentile": 0.90372}, "CVE-2022-43165": {"epss_score": 0.04487, "epss_percentile": 0.88752}, "CVE-2022-43166": {"epss_score": 0.06353, "epss_percentile": 0.90693}, "CVE-2022-43167": {"epss_score": 0.07075, "epss_percentile": 0.91232}, "CVE-2022-43168": {"epss_score": 0.00481, "epss_percentile": 0.64517}, "CVE-2022-43169": {"epss_score": 0.09282, "epss_percentile": 0.92481}, "CVE-2022-43170": {"epss_score": 0.06517, "epss_percentile": 0.90815}, "CVE-2022-43171": {"epss_score": 0.0022, "epss_percentile": 0.44554}, "CVE-2022-43179": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43183": {"epss_score": 0.25526, "epss_percentile": 0.96037}, "CVE-2022-43184": {"epss_score": 0.0756, "epss_percentile": 0.91541}, "CVE-2022-43185": {"epss_score": 0.04792, "epss_percentile": 0.89152}, "CVE-2022-43192": {"epss_score": 0.00146, "epss_percentile": 0.35639}, "CVE-2022-43196": {"epss_score": 0.00328, "epss_percentile": 0.55172}, "CVE-2022-43212": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-43213": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-43214": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-43215": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-43216": {"epss_score": 0.00219, "epss_percentile": 0.44481}, "CVE-2022-43221": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-43222": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-43223": {"epss_score": 0.00317, "epss_percentile": 0.54377}, "CVE-2022-43226": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-43227": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43228": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-43229": {"epss_score": 0.00368, "epss_percentile": 0.58186}, "CVE-2022-43230": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43231": {"epss_score": 0.00455, "epss_percentile": 0.63283}, "CVE-2022-43232": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-43233": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-43234": {"epss_score": 0.0076, "epss_percentile": 0.72802}, "CVE-2022-43235": {"epss_score": 0.0028, "epss_percentile": 0.51014}, "CVE-2022-43236": {"epss_score": 0.0028, "epss_percentile": 0.51014}, "CVE-2022-43237": {"epss_score": 0.0028, "epss_percentile": 0.51014}, "CVE-2022-43238": {"epss_score": 0.00241, "epss_percentile": 0.47241}, "CVE-2022-43239": {"epss_score": 0.0028, "epss_percentile": 0.51014}, "CVE-2022-43240": {"epss_score": 0.00214, "epss_percentile": 0.43983}, "CVE-2022-43241": {"epss_score": 0.0025, "epss_percentile": 0.48142}, "CVE-2022-43242": {"epss_score": 0.00327, "epss_percentile": 0.55123}, "CVE-2022-43243": {"epss_score": 0.00214, "epss_percentile": 0.43983}, "CVE-2022-43244": {"epss_score": 0.0025, "epss_percentile": 0.48142}, "CVE-2022-43245": {"epss_score": 0.0025, "epss_percentile": 0.48142}, "CVE-2022-43248": {"epss_score": 0.00214, "epss_percentile": 0.43983}, "CVE-2022-43249": {"epss_score": 0.00327, "epss_percentile": 0.55123}, "CVE-2022-43250": {"epss_score": 0.0025, "epss_percentile": 0.48142}, "CVE-2022-43252": {"epss_score": 0.00214, "epss_percentile": 0.43983}, "CVE-2022-43253": {"epss_score": 0.00214, "epss_percentile": 0.43983}, "CVE-2022-43254": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-43255": {"epss_score": 0.00028, "epss_percentile": 0.0722}, "CVE-2022-43256": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-43259": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-43260": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-43262": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-43263": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-43264": {"epss_score": 0.00516, "epss_percentile": 0.66035}, "CVE-2022-43265": {"epss_score": 0.00829, "epss_percentile": 0.7401}, "CVE-2022-43271": {"epss_score": 0.01135, "epss_percentile": 0.77897}, "CVE-2022-43272": {"epss_score": 0.00146, "epss_percentile": 0.35579}, "CVE-2022-43275": {"epss_score": 0.00455, "epss_percentile": 0.63283}, "CVE-2022-43276": {"epss_score": 0.00328, "epss_percentile": 0.55292}, "CVE-2022-43277": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-43278": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43279": {"epss_score": 0.00276, "epss_percentile": 0.50742}, "CVE-2022-43280": {"epss_score": 0.00051, "epss_percentile": 0.16281}, "CVE-2022-43281": {"epss_score": 0.00134, "epss_percentile": 0.33758}, "CVE-2022-43282": {"epss_score": 0.00051, "epss_percentile": 0.16281}, "CVE-2022-43283": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2022-43284": {"epss_score": 0.0024, "epss_percentile": 0.46951}, "CVE-2022-43285": {"epss_score": 0.0024, "epss_percentile": 0.46951}, "CVE-2022-43286": {"epss_score": 0.00362, "epss_percentile": 0.57765}, "CVE-2022-43288": {"epss_score": 0.00308, "epss_percentile": 0.53614}, "CVE-2022-43289": {"epss_score": 0.00143, "epss_percentile": 0.3512}, "CVE-2022-43290": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43291": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43292": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43293": {"epss_score": 0.01458, "epss_percentile": 0.80405}, "CVE-2022-43294": {"epss_score": 0.00615, "epss_percentile": 0.69295}, "CVE-2022-43295": {"epss_score": 0.00071, "epss_percentile": 0.2216}, "CVE-2022-43303": {"epss_score": 0.00505, "epss_percentile": 0.65589}, "CVE-2022-43304": {"epss_score": 0.00505, "epss_percentile": 0.65589}, "CVE-2022-43305": {"epss_score": 0.00505, "epss_percentile": 0.65589}, "CVE-2022-43306": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2022-43308": {"epss_score": 0.00107, "epss_percentile": 0.2966}, "CVE-2022-43309": {"epss_score": 0.00032, "epss_percentile": 0.09022}, "CVE-2022-43310": {"epss_score": 0.00025, "epss_percentile": 0.06371}, "CVE-2022-43317": {"epss_score": 0.0034, "epss_percentile": 0.56222}, "CVE-2022-43318": {"epss_score": 0.00243, "epss_percentile": 0.47514}, "CVE-2022-43319": {"epss_score": 0.003, "epss_percentile": 0.52917}, "CVE-2022-43320": {"epss_score": 0.00316, "epss_percentile": 0.5424}, "CVE-2022-43321": {"epss_score": 0.00316, "epss_percentile": 0.5424}, "CVE-2022-43323": {"epss_score": 0.00129, "epss_percentile": 0.33146}, "CVE-2022-43325": {"epss_score": 0.29987, "epss_percentile": 0.96492}, "CVE-2022-43326": {"epss_score": 0.00232, "epss_percentile": 0.45914}, "CVE-2022-43328": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43329": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43330": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43331": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43332": {"epss_score": 0.00471, "epss_percentile": 0.63994}, "CVE-2022-43333": {"epss_score": 0.02926, "epss_percentile": 0.86007}, "CVE-2022-43340": {"epss_score": 0.00085, "epss_percentile": 0.25042}, "CVE-2022-43342": {"epss_score": 0.00589, "epss_percentile": 0.68534}, "CVE-2022-43343": {"epss_score": 0.05136, "epss_percentile": 0.89535}, "CVE-2022-43350": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43351": {"epss_score": 0.0034, "epss_percentile": 0.56245}, "CVE-2022-43352": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43353": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43354": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43355": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-43357": {"epss_score": 0.00207, "epss_percentile": 0.43093}, "CVE-2022-43358": {"epss_score": 0.002, "epss_percentile": 0.42245}, "CVE-2022-43359": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2022-43361": {"epss_score": 0.00226, "epss_percentile": 0.45333}, "CVE-2022-43362": {"epss_score": 0.00241, "epss_percentile": 0.47329}, "CVE-2022-43363": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-43364": {"epss_score": 0.00424, "epss_percentile": 0.61651}, "CVE-2022-43365": {"epss_score": 0.00371, "epss_percentile": 0.5835}, "CVE-2022-43366": {"epss_score": 0.00549, "epss_percentile": 0.67307}, "CVE-2022-43367": {"epss_score": 0.1215, "epss_percentile": 0.93585}, "CVE-2022-43369": {"epss_score": 0.00218, "epss_percentile": 0.44375}, "CVE-2022-43372": {"epss_score": 0.00226, "epss_percentile": 0.45333}, "CVE-2022-43376": {"epss_score": 0.00305, "epss_percentile": 0.53387}, "CVE-2022-43377": {"epss_score": 0.00282, "epss_percentile": 0.51266}, "CVE-2022-43378": {"epss_score": 0.0022, "epss_percentile": 0.44591}, "CVE-2022-43380": {"epss_score": 0.00112, "epss_percentile": 0.3055}, "CVE-2022-43381": {"epss_score": 0.00112, "epss_percentile": 0.3055}, "CVE-2022-43382": {"epss_score": 0.00073, "epss_percentile": 0.22546}, "CVE-2022-43384": {"epss_score": 0.00101, "epss_percentile": 0.28632}, "CVE-2022-43389": {"epss_score": 0.01206, "epss_percentile": 0.7852}, "CVE-2022-43390": {"epss_score": 0.01682, "epss_percentile": 0.81732}, "CVE-2022-43391": {"epss_score": 0.00587, "epss_percentile": 0.68472}, "CVE-2022-43392": {"epss_score": 0.00341, "epss_percentile": 0.56319}, "CVE-2022-43393": {"epss_score": 0.00527, "epss_percentile": 0.66454}, "CVE-2022-43396": {"epss_score": 0.00387, "epss_percentile": 0.59334}, "CVE-2022-43397": {"epss_score": 0.00116, "epss_percentile": 0.31131}, "CVE-2022-43398": {"epss_score": 0.00435, "epss_percentile": 0.62341}, "CVE-2022-43400": {"epss_score": 0.01192, "epss_percentile": 0.78403}, "CVE-2022-43401": {"epss_score": 0.00157, "epss_percentile": 0.37101}, "CVE-2022-43402": {"epss_score": 0.00078, "epss_percentile": 0.2357}, "CVE-2022-43403": {"epss_score": 0.00242, "epss_percentile": 0.47344}, "CVE-2022-43404": {"epss_score": 0.00128, "epss_percentile": 0.32947}, "CVE-2022-43405": {"epss_score": 0.00157, "epss_percentile": 0.37101}, "CVE-2022-43406": {"epss_score": 0.00157, "epss_percentile": 0.37101}, "CVE-2022-43407": {"epss_score": 0.00012, "epss_percentile": 0.01237}, "CVE-2022-43408": {"epss_score": 0.0001, "epss_percentile": 0.00874}, "CVE-2022-43409": {"epss_score": 0.04273, "epss_percentile": 0.88479}, "CVE-2022-43410": {"epss_score": 0.0028, "epss_percentile": 0.51017}, "CVE-2022-43411": {"epss_score": 0.00501, "epss_percentile": 0.65343}, "CVE-2022-43412": {"epss_score": 0.00482, "epss_percentile": 0.64541}, "CVE-2022-43413": {"epss_score": 0.00845, "epss_percentile": 0.74285}, "CVE-2022-43414": {"epss_score": 0.00962, "epss_percentile": 0.75984}, "CVE-2022-43415": {"epss_score": 0.01094, "epss_percentile": 0.77491}, "CVE-2022-43416": {"epss_score": 0.02313, "epss_percentile": 0.84343}, "CVE-2022-43417": {"epss_score": 0.00845, "epss_percentile": 0.74285}, "CVE-2022-43418": {"epss_score": 0.00124, "epss_percentile": 0.32348}, "CVE-2022-43419": {"epss_score": 0.00758, "epss_percentile": 0.72776}, "CVE-2022-43420": {"epss_score": 0.10502, "epss_percentile": 0.93012}, "CVE-2022-43421": {"epss_score": 0.01507, "epss_percentile": 0.80756}, "CVE-2022-43422": {"epss_score": 0.01026, "epss_percentile": 0.76797}, "CVE-2022-43423": {"epss_score": 0.01026, "epss_percentile": 0.76797}, "CVE-2022-43424": {"epss_score": 0.01026, "epss_percentile": 0.76797}, "CVE-2022-43425": {"epss_score": 0.08016, "epss_percentile": 0.91831}, "CVE-2022-43426": {"epss_score": 0.00694, "epss_percentile": 0.71342}, "CVE-2022-43427": {"epss_score": 0.00623, "epss_percentile": 0.69539}, "CVE-2022-43428": {"epss_score": 0.01026, "epss_percentile": 0.76797}, "CVE-2022-43429": {"epss_score": 0.00664, "epss_percentile": 0.70643}, "CVE-2022-43430": {"epss_score": 0.01077, "epss_percentile": 0.77331}, "CVE-2022-43431": {"epss_score": 0.00813, "epss_percentile": 0.73763}, "CVE-2022-43432": {"epss_score": 0.00962, "epss_percentile": 0.75984}, "CVE-2022-43433": {"epss_score": 0.00962, "epss_percentile": 0.75984}, "CVE-2022-43434": {"epss_score": 0.00962, "epss_percentile": 0.75984}, "CVE-2022-43435": {"epss_score": 0.01301, "epss_percentile": 0.79294}, "CVE-2022-43436": {"epss_score": 0.0099, "epss_percentile": 0.76378}, "CVE-2022-43437": {"epss_score": 0.0099, "epss_percentile": 0.76378}, "CVE-2022-43438": {"epss_score": 0.00125, "epss_percentile": 0.3259}, "CVE-2022-43439": {"epss_score": 0.0171, "epss_percentile": 0.81871}, "CVE-2022-43440": {"epss_score": 0.0007, "epss_percentile": 0.21969}, "CVE-2022-43441": {"epss_score": 0.06155, "epss_percentile": 0.90524}, "CVE-2022-43442": {"epss_score": 0.00094, "epss_percentile": 0.27035}, "CVE-2022-43443": {"epss_score": 0.00989, "epss_percentile": 0.76373}, "CVE-2022-43447": {"epss_score": 0.00219, "epss_percentile": 0.44505}, "CVE-2022-43448": {"epss_score": 0.00089, "epss_percentile": 0.25922}, "CVE-2022-43449": {"epss_score": 0.00037, "epss_percentile": 0.11039}, "CVE-2022-43450": {"epss_score": 0.00151, "epss_percentile": 0.36364}, "CVE-2022-43451": {"epss_score": 0.0004, "epss_percentile": 0.11919}, "CVE-2022-43452": {"epss_score": 0.00893, "epss_percentile": 0.75071}, "CVE-2022-43453": {"epss_score": 0.00409, "epss_percentile": 0.60727}, "CVE-2022-43454": {"epss_score": 0.00032, "epss_percentile": 0.09105}, "CVE-2022-43455": {"epss_score": 0.00044, "epss_percentile": 0.13584}, "CVE-2022-43456": {"epss_score": 0.00051, "epss_percentile": 0.16273}, "CVE-2022-43457": {"epss_score": 0.00161, "epss_percentile": 0.37585}, "CVE-2022-43458": {"epss_score": 0.00106, "epss_percentile": 0.29476}, "CVE-2022-43459": {"epss_score": 0.00057, "epss_percentile": 0.18197}, "CVE-2022-43460": {"epss_score": 0.00236, "epss_percentile": 0.46461}, "CVE-2022-43461": {"epss_score": 0.00083, "epss_percentile": 0.24725}, "CVE-2022-43462": {"epss_score": 0.00321, "epss_percentile": 0.54676}, "CVE-2022-43463": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-43464": {"epss_score": 0.00846, "epss_percentile": 0.74329}, "CVE-2022-43465": {"epss_score": 0.00057, "epss_percentile": 0.17969}, "CVE-2022-43466": {"epss_score": 0.00869, "epss_percentile": 0.74685}, "CVE-2022-43467": {"epss_score": 0.00344, "epss_percentile": 0.56507}, "CVE-2022-43468": {"epss_score": 0.00523, "epss_percentile": 0.66296}, "CVE-2022-43469": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2022-43470": {"epss_score": 0.00044, "epss_percentile": 0.13514}, "CVE-2022-43472": {"epss_score": 0.00163, "epss_percentile": 0.37788}, "CVE-2022-43473": {"epss_score": 0.01721, "epss_percentile": 0.81935}, "CVE-2022-43474": {"epss_score": 0.00083, "epss_percentile": 0.24768}, "CVE-2022-43475": {"epss_score": 0.00103, "epss_percentile": 0.29058}, "CVE-2022-43476": {"epss_score": 0.00102, "epss_percentile": 0.28777}, "CVE-2022-43477": {"epss_score": 0.00096, "epss_percentile": 0.2726}, "CVE-2022-43479": {"epss_score": 0.00635, "epss_percentile": 0.69829}, "CVE-2022-43480": {"epss_score": 0.00089, "epss_percentile": 0.25945}, "CVE-2022-43481": {"epss_score": 0.00106, "epss_percentile": 0.29533}, "CVE-2022-43482": {"epss_score": 0.00322, "epss_percentile": 0.54804}, "CVE-2022-43483": {"epss_score": 0.00445, "epss_percentile": 0.62872}, "CVE-2022-43484": {"epss_score": 0.00163, "epss_percentile": 0.37764}, "CVE-2022-43485": {"epss_score": 0.00035, "epss_percentile": 0.09805}, "CVE-2022-43486": {"epss_score": 0.00259, "epss_percentile": 0.49028}, "CVE-2022-43487": {"epss_score": 0.0195, "epss_percentile": 0.83014}, "CVE-2022-43488": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-43490": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-43491": {"epss_score": 0.00135, "epss_percentile": 0.34052}, "CVE-2022-43492": {"epss_score": 0.00417, "epss_percentile": 0.6124}, "CVE-2022-43494": {"epss_score": 0.00198, "epss_percentile": 0.42046}, "CVE-2022-43495": {"epss_score": 0.00268, "epss_percentile": 0.50037}, "CVE-2022-43497": {"epss_score": 0.00882, "epss_percentile": 0.74892}, "CVE-2022-43499": {"epss_score": 0.00257, "epss_percentile": 0.48922}, "CVE-2022-43500": {"epss_score": 0.01282, "epss_percentile": 0.79152}, "CVE-2022-43501": {"epss_score": 0.0028, "epss_percentile": 0.51092}, "CVE-2022-43504": {"epss_score": 0.06008, "epss_percentile": 0.904}, "CVE-2022-43505": {"epss_score": 0.00012, "epss_percentile": 0.01116}, "CVE-2022-43506": {"epss_score": 0.00161, "epss_percentile": 0.37585}, "CVE-2022-43507": {"epss_score": 0.00182, "epss_percentile": 0.4015}, "CVE-2022-43508": {"epss_score": 0.00126, "epss_percentile": 0.32726}, "CVE-2022-43509": {"epss_score": 0.00134, "epss_percentile": 0.33765}, "CVE-2022-43512": {"epss_score": 0.00147, "epss_percentile": 0.35708}, "CVE-2022-43513": {"epss_score": 0.00196, "epss_percentile": 0.41769}, "CVE-2022-43514": {"epss_score": 0.01475, "epss_percentile": 0.80523}, "CVE-2022-43515": {"epss_score": 0.00125, "epss_percentile": 0.32496}, "CVE-2022-43516": {"epss_score": 0.0454, "epss_percentile": 0.88828}, "CVE-2022-43517": {"epss_score": 0.00031, "epss_percentile": 0.08397}, "CVE-2022-43518": {"epss_score": 0.00355, "epss_percentile": 0.57324}, "CVE-2022-43519": {"epss_score": 0.00677, "epss_percentile": 0.7097}, "CVE-2022-43520": {"epss_score": 0.00677, "epss_percentile": 0.7097}, "CVE-2022-43521": {"epss_score": 0.00677, "epss_percentile": 0.7097}, "CVE-2022-43522": {"epss_score": 0.00677, "epss_percentile": 0.7097}, "CVE-2022-43523": {"epss_score": 0.00677, "epss_percentile": 0.7097}, "CVE-2022-43524": {"epss_score": 0.00379, "epss_percentile": 0.58852}, "CVE-2022-43525": {"epss_score": 0.00289, "epss_percentile": 0.52012}, "CVE-2022-43526": {"epss_score": 0.00289, "epss_percentile": 0.52012}, "CVE-2022-43527": {"epss_score": 0.00289, "epss_percentile": 0.52012}, "CVE-2022-43528": {"epss_score": 0.00236, "epss_percentile": 0.46426}, "CVE-2022-43529": {"epss_score": 0.00138, "epss_percentile": 0.34503}, "CVE-2022-43530": {"epss_score": 0.00553, "epss_percentile": 0.67424}, "CVE-2022-43531": {"epss_score": 0.00553, "epss_percentile": 0.67424}, "CVE-2022-43532": {"epss_score": 0.00287, "epss_percentile": 0.51833}, "CVE-2022-43533": {"epss_score": 0.00051, "epss_percentile": 0.16115}, "CVE-2022-43534": {"epss_score": 0.00051, "epss_percentile": 0.16115}, "CVE-2022-43535": {"epss_score": 0.00051, "epss_percentile": 0.16115}, "CVE-2022-43536": {"epss_score": 0.00541, "epss_percentile": 0.67058}, "CVE-2022-43537": {"epss_score": 0.00679, "epss_percentile": 0.71022}, "CVE-2022-43538": {"epss_score": 0.00679, "epss_percentile": 0.71022}, "CVE-2022-43539": {"epss_score": 0.00087, "epss_percentile": 0.25533}, "CVE-2022-43540": {"epss_score": 0.00057, "epss_percentile": 0.18034}, "CVE-2022-43541": {"epss_score": 0.00647, "epss_percentile": 0.70205}, "CVE-2022-43542": {"epss_score": 0.00588, "epss_percentile": 0.68488}, "CVE-2022-43543": {"epss_score": 0.00318, "epss_percentile": 0.54444}, "CVE-2022-43545": {"epss_score": 0.01051, "epss_percentile": 0.77075}, "CVE-2022-43546": {"epss_score": 0.01368, "epss_percentile": 0.79792}, "CVE-2022-43548": {"epss_score": 0.00702, "epss_percentile": 0.71523}, "CVE-2022-43549": {"epss_score": 0.00318, "epss_percentile": 0.54397}, "CVE-2022-43550": {"epss_score": 0.02087, "epss_percentile": 0.83553}, "CVE-2022-43551": {"epss_score": 0.00042, "epss_percentile": 0.12883}, "CVE-2022-43552": {"epss_score": 0.00121, "epss_percentile": 0.31959}, "CVE-2022-43553": {"epss_score": 0.0845, "epss_percentile": 0.92057}, "CVE-2022-43554": {"epss_score": 0.00084, "epss_percentile": 0.25009}, "CVE-2022-43555": {"epss_score": 0.0011, "epss_percentile": 0.30216}, "CVE-2022-43556": {"epss_score": 0.01123, "epss_percentile": 0.77787}, "CVE-2022-43557": {"epss_score": 0.00106, "epss_percentile": 0.2945}, "CVE-2022-43561": {"epss_score": 0.00199, "epss_percentile": 0.42139}, "CVE-2022-43562": {"epss_score": 0.00304, "epss_percentile": 0.5326}, "CVE-2022-43563": {"epss_score": 0.00146, "epss_percentile": 0.35606}, "CVE-2022-43564": {"epss_score": 0.00399, "epss_percentile": 0.60105}, "CVE-2022-43565": {"epss_score": 0.00146, "epss_percentile": 0.35606}, "CVE-2022-43566": {"epss_score": 0.00164, "epss_percentile": 0.37997}, "CVE-2022-43567": {"epss_score": 0.01064, "epss_percentile": 0.77194}, "CVE-2022-43568": {"epss_score": 0.15129, "epss_percentile": 0.94369}, "CVE-2022-43569": {"epss_score": 0.00786, "epss_percentile": 0.73264}, "CVE-2022-43570": {"epss_score": 0.00313, "epss_percentile": 0.54035}, "CVE-2022-43571": {"epss_score": 0.42264, "epss_percentile": 0.97323}, "CVE-2022-43572": {"epss_score": 0.00823, "epss_percentile": 0.73921}, "CVE-2022-43573": {"epss_score": 0.00287, "epss_percentile": 0.51842}, "CVE-2022-43574": {"epss_score": 0.00181, "epss_percentile": 0.40062}, "CVE-2022-43575": {"epss_score": 0.00132, "epss_percentile": 0.33559}, "CVE-2022-43578": {"epss_score": 0.00116, "epss_percentile": 0.31186}, "CVE-2022-43579": {"epss_score": 0.00223, "epss_percentile": 0.44959}, "CVE-2022-43581": {"epss_score": 0.00386, "epss_percentile": 0.59273}, "CVE-2022-43588": {"epss_score": 0.00031, "epss_percentile": 0.08578}, "CVE-2022-43589": {"epss_score": 0.00031, "epss_percentile": 0.08578}, "CVE-2022-43590": {"epss_score": 0.00031, "epss_percentile": 0.08578}, "CVE-2022-43591": {"epss_score": 0.00996, "epss_percentile": 0.76443}, "CVE-2022-43592": {"epss_score": 0.00213, "epss_percentile": 0.43891}, "CVE-2022-43593": {"epss_score": 0.00121, "epss_percentile": 0.31939}, "CVE-2022-43594": {"epss_score": 0.00161, "epss_percentile": 0.37604}, "CVE-2022-43595": {"epss_score": 0.00158, "epss_percentile": 0.37286}, "CVE-2022-43596": {"epss_score": 0.00213, "epss_percentile": 0.43891}, "CVE-2022-43597": {"epss_score": 0.00391, "epss_percentile": 0.59593}, "CVE-2022-43598": {"epss_score": 0.00236, "epss_percentile": 0.46418}, "CVE-2022-43599": {"epss_score": 0.00683, "epss_percentile": 0.711}, "CVE-2022-43600": {"epss_score": 0.00572, "epss_percentile": 0.68027}, "CVE-2022-43601": {"epss_score": 0.00572, "epss_percentile": 0.68027}, "CVE-2022-43602": {"epss_score": 0.0054, "epss_percentile": 0.66991}, "CVE-2022-43603": {"epss_score": 0.00141, "epss_percentile": 0.34819}, "CVE-2022-43604": {"epss_score": 0.03729, "epss_percentile": 0.87637}, "CVE-2022-43605": {"epss_score": 0.06965, "epss_percentile": 0.91152}, "CVE-2022-43606": {"epss_score": 0.00152, "epss_percentile": 0.3642}, "CVE-2022-43607": {"epss_score": 0.00106, "epss_percentile": 0.2949}, "CVE-2022-43608": {"epss_score": 0.00121, "epss_percentile": 0.31822}, "CVE-2022-43609": {"epss_score": 0.01438, "epss_percentile": 0.80287}, "CVE-2022-43610": {"epss_score": 0.00464, "epss_percentile": 0.63732}, "CVE-2022-43611": {"epss_score": 0.00606, "epss_percentile": 0.69026}, "CVE-2022-43612": {"epss_score": 0.00464, "epss_percentile": 0.63732}, "CVE-2022-43613": {"epss_score": 0.01589, "epss_percentile": 0.81196}, "CVE-2022-43614": {"epss_score": 0.02065, "epss_percentile": 0.83456}, "CVE-2022-43615": {"epss_score": 0.00464, "epss_percentile": 0.63732}, "CVE-2022-43616": {"epss_score": 0.02065, "epss_percentile": 0.83456}, "CVE-2022-43617": {"epss_score": 0.01128, "epss_percentile": 0.77829}, "CVE-2022-43618": {"epss_score": 0.01983, "epss_percentile": 0.83146}, "CVE-2022-43619": {"epss_score": 0.00028, "epss_percentile": 0.07296}, "CVE-2022-43620": {"epss_score": 0.00529, "epss_percentile": 0.66586}, "CVE-2022-43621": {"epss_score": 0.01152, "epss_percentile": 0.7805}, "CVE-2022-43622": {"epss_score": 0.00372, "epss_percentile": 0.58461}, "CVE-2022-43623": {"epss_score": 0.00134, "epss_percentile": 0.33842}, "CVE-2022-43624": {"epss_score": 0.00089, "epss_percentile": 0.25981}, "CVE-2022-43625": {"epss_score": 0.00044, "epss_percentile": 0.13495}, "CVE-2022-43626": {"epss_score": 0.00089, "epss_percentile": 0.25981}, "CVE-2022-43627": {"epss_score": 0.00089, "epss_percentile": 0.25981}, "CVE-2022-43628": {"epss_score": 0.00086, "epss_percentile": 0.25362}, "CVE-2022-43629": {"epss_score": 0.00089, "epss_percentile": 0.25981}, "CVE-2022-43630": {"epss_score": 0.00528, "epss_percentile": 0.6654}, "CVE-2022-43631": {"epss_score": 0.00089, "epss_percentile": 0.25981}, "CVE-2022-43632": {"epss_score": 0.00089, "epss_percentile": 0.25981}, "CVE-2022-43633": {"epss_score": 0.00089, "epss_percentile": 0.25981}, "CVE-2022-43634": {"epss_score": 0.04347, "epss_percentile": 0.88578}, "CVE-2022-43635": {"epss_score": 0.00133, "epss_percentile": 0.33655}, "CVE-2022-43636": {"epss_score": 0.00036, "epss_percentile": 0.10252}, "CVE-2022-43637": {"epss_score": 0.02209, "epss_percentile": 0.84012}, "CVE-2022-43638": {"epss_score": 0.04204, "epss_percentile": 0.88393}, "CVE-2022-43639": {"epss_score": 0.02209, "epss_percentile": 0.84012}, "CVE-2022-43640": {"epss_score": 0.00509, "epss_percentile": 0.65721}, "CVE-2022-43641": {"epss_score": 0.00654, "epss_percentile": 0.7035}, "CVE-2022-43642": {"epss_score": 0.00837, "epss_percentile": 0.74157}, "CVE-2022-43643": {"epss_score": 0.00837, "epss_percentile": 0.74157}, "CVE-2022-43644": {"epss_score": 0.00869, "epss_percentile": 0.74694}, "CVE-2022-43645": {"epss_score": 0.00837, "epss_percentile": 0.74157}, "CVE-2022-43646": {"epss_score": 0.00869, "epss_percentile": 0.74694}, "CVE-2022-43647": {"epss_score": 0.00837, "epss_percentile": 0.74157}, "CVE-2022-43648": {"epss_score": 0.0074, "epss_percentile": 0.72406}, "CVE-2022-43649": {"epss_score": 0.03359, "epss_percentile": 0.86982}, "CVE-2022-43650": {"epss_score": 0.01428, "epss_percentile": 0.80221}, "CVE-2022-43651": {"epss_score": 0.00871, "epss_percentile": 0.7471}, "CVE-2022-43652": {"epss_score": 0.00189, "epss_percentile": 0.4095}, "CVE-2022-43653": {"epss_score": 0.00661, "epss_percentile": 0.70583}, "CVE-2022-43654": {"epss_score": 0.02633, "epss_percentile": 0.85287}, "CVE-2022-43655": {"epss_score": 0.00968, "epss_percentile": 0.76075}, "CVE-2022-43656": {"epss_score": 0.00176, "epss_percentile": 0.39494}, "CVE-2022-43660": {"epss_score": 0.00832, "epss_percentile": 0.74059}, "CVE-2022-43662": {"epss_score": 0.00038, "epss_percentile": 0.11127}, "CVE-2022-43663": {"epss_score": 0.2243, "epss_percentile": 0.95633}, "CVE-2022-43664": {"epss_score": 0.00152, "epss_percentile": 0.36469}, "CVE-2022-43665": {"epss_score": 0.00038, "epss_percentile": 0.11204}, "CVE-2022-43666": {"epss_score": 0.00096, "epss_percentile": 0.2726}, "CVE-2022-43667": {"epss_score": 0.00092, "epss_percentile": 0.26565}, "CVE-2022-43668": {"epss_score": 0.00542, "epss_percentile": 0.67078}, "CVE-2022-43670": {"epss_score": 0.00349, "epss_percentile": 0.56872}, "CVE-2022-43671": {"epss_score": 0.51954, "epss_percentile": 0.97804}, "CVE-2022-43672": {"epss_score": 0.51954, "epss_percentile": 0.97804}, "CVE-2022-43673": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2022-43675": {"epss_score": 0.00128, "epss_percentile": 0.33042}, "CVE-2022-43677": {"epss_score": 0.00137, "epss_percentile": 0.34311}, "CVE-2022-43679": {"epss_score": 0.00192, "epss_percentile": 0.41316}, "CVE-2022-43680": {"epss_score": 0.00331, "epss_percentile": 0.55511}, "CVE-2022-43681": {"epss_score": 0.00159, "epss_percentile": 0.37336}, "CVE-2022-43684": {"epss_score": 0.00296, "epss_percentile": 0.52545}, "CVE-2022-43685": {"epss_score": 0.00864, "epss_percentile": 0.74596}, "CVE-2022-43686": {"epss_score": 0.0066, "epss_percentile": 0.70534}, "CVE-2022-43687": {"epss_score": 0.00403, "epss_percentile": 0.60382}, "CVE-2022-43688": {"epss_score": 0.00481, "epss_percentile": 0.64512}, "CVE-2022-43689": {"epss_score": 0.00397, "epss_percentile": 0.6003}, "CVE-2022-43690": {"epss_score": 0.006, "epss_percentile": 0.68823}, "CVE-2022-43691": {"epss_score": 0.00211, "epss_percentile": 0.43706}, "CVE-2022-43692": {"epss_score": 0.00853, "epss_percentile": 0.74443}, "CVE-2022-43693": {"epss_score": 0.00428, "epss_percentile": 0.61954}, "CVE-2022-43694": {"epss_score": 0.00853, "epss_percentile": 0.74443}, "CVE-2022-43695": {"epss_score": 0.00524, "epss_percentile": 0.6634}, "CVE-2022-43696": {"epss_score": 0.00123, "epss_percentile": 0.32297}, "CVE-2022-43697": {"epss_score": 0.00123, "epss_percentile": 0.32297}, "CVE-2022-43698": {"epss_score": 0.00106, "epss_percentile": 0.2952}, "CVE-2022-43699": {"epss_score": 0.00081, "epss_percentile": 0.24358}, "CVE-2022-43701": {"epss_score": 0.00063, "epss_percentile": 0.19847}, "CVE-2022-43702": {"epss_score": 0.0005, "epss_percentile": 0.15949}, "CVE-2022-43703": {"epss_score": 0.00051, "epss_percentile": 0.16231}, "CVE-2022-43704": {"epss_score": 0.00855, "epss_percentile": 0.74468}, "CVE-2022-43705": {"epss_score": 0.00191, "epss_percentile": 0.41273}, "CVE-2022-43706": {"epss_score": 0.00548, "epss_percentile": 0.67283}, "CVE-2022-43707": {"epss_score": 0.0032, "epss_percentile": 0.54582}, "CVE-2022-43708": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-43709": {"epss_score": 0.00313, "epss_percentile": 0.54047}, "CVE-2022-43710": {"epss_score": 0.00141, "epss_percentile": 0.34915}, "CVE-2022-43711": {"epss_score": 0.00271, "epss_percentile": 0.50314}, "CVE-2022-43712": {"epss_score": 0.00043, "epss_percentile": 0.12968}, "CVE-2022-43713": {"epss_score": 0.00047, "epss_percentile": 0.14696}, "CVE-2022-43716": {"epss_score": 0.00256, "epss_percentile": 0.48798}, "CVE-2022-43717": {"epss_score": 0.00315, "epss_percentile": 0.54204}, "CVE-2022-43718": {"epss_score": 0.00705, "epss_percentile": 0.71601}, "CVE-2022-43719": {"epss_score": 0.00098, "epss_percentile": 0.27815}, "CVE-2022-43720": {"epss_score": 0.00444, "epss_percentile": 0.62817}, "CVE-2022-43721": {"epss_score": 0.00193, "epss_percentile": 0.41447}, "CVE-2022-43722": {"epss_score": 0.00056, "epss_percentile": 0.17789}, "CVE-2022-43723": {"epss_score": 0.01114, "epss_percentile": 0.77705}, "CVE-2022-43724": {"epss_score": 0.00678, "epss_percentile": 0.70986}, "CVE-2022-43740": {"epss_score": 0.00131, "epss_percentile": 0.33347}, "CVE-2022-43747": {"epss_score": 0.02068, "epss_percentile": 0.83463}, "CVE-2022-43748": {"epss_score": 0.00232, "epss_percentile": 0.45956}, "CVE-2022-43749": {"epss_score": 0.00252, "epss_percentile": 0.48413}, "CVE-2022-43750": {"epss_score": 0.00069, "epss_percentile": 0.2154}, "CVE-2022-43751": {"epss_score": 0.00073, "epss_percentile": 0.22657}, "CVE-2022-43752": {"epss_score": 0.00094, "epss_percentile": 0.26769}, "CVE-2022-43753": {"epss_score": 0.00285, "epss_percentile": 0.51548}, "CVE-2022-43754": {"epss_score": 0.00246, "epss_percentile": 0.47775}, "CVE-2022-43755": {"epss_score": 0.00133, "epss_percentile": 0.33645}, "CVE-2022-43756": {"epss_score": 0.00382, "epss_percentile": 0.59069}, "CVE-2022-43757": {"epss_score": 0.00102, "epss_percentile": 0.28805}, "CVE-2022-43758": {"epss_score": 0.00138, "epss_percentile": 0.34516}, "CVE-2022-43759": {"epss_score": 0.00077, "epss_percentile": 0.2346}, "CVE-2022-43760": {"epss_score": 0.01315, "epss_percentile": 0.79403}, "CVE-2022-43761": {"epss_score": 0.00094, "epss_percentile": 0.26986}, "CVE-2022-43762": {"epss_score": 0.00284, "epss_percentile": 0.51435}, "CVE-2022-43763": {"epss_score": 0.00249, "epss_percentile": 0.48029}, "CVE-2022-43764": {"epss_score": 0.00327, "epss_percentile": 0.55135}, "CVE-2022-43765": {"epss_score": 0.00249, "epss_percentile": 0.48029}, "CVE-2022-43766": {"epss_score": 0.01569, "epss_percentile": 0.81081}, "CVE-2022-43767": {"epss_score": 0.00262, "epss_percentile": 0.49329}, "CVE-2022-43768": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-43769": {"epss_score": 0.93976, "epss_percentile": 0.99878}, "CVE-2022-43770": {"epss_score": 0.0011, "epss_percentile": 0.30222}, "CVE-2022-43771": {"epss_score": 0.11759, "epss_percentile": 0.93467}, "CVE-2022-43772": {"epss_score": 0.00164, "epss_percentile": 0.37888}, "CVE-2022-43773": {"epss_score": 0.10996, "epss_percentile": 0.93186}, "CVE-2022-43774": {"epss_score": 0.00603, "epss_percentile": 0.68915}, "CVE-2022-43775": {"epss_score": 0.02059, "epss_percentile": 0.83437}, "CVE-2022-43776": {"epss_score": 0.00265, "epss_percentile": 0.49803}, "CVE-2022-43777": {"epss_score": 0.00144, "epss_percentile": 0.35265}, "CVE-2022-43778": {"epss_score": 0.00141, "epss_percentile": 0.34819}, "CVE-2022-43779": {"epss_score": 0.00183, "epss_percentile": 0.40325}, "CVE-2022-43780": {"epss_score": 0.00267, "epss_percentile": 0.50019}, "CVE-2022-43781": {"epss_score": 0.92082, "epss_percentile": 0.9969}, "CVE-2022-43782": {"epss_score": 0.00568, "epss_percentile": 0.67884}, "CVE-2022-43831": {"epss_score": 0.00032, "epss_percentile": 0.08737}, "CVE-2022-43840": {"epss_score": 0.00094, "epss_percentile": 0.27001}, "CVE-2022-43841": {"epss_score": 0.0004, "epss_percentile": 0.12104}, "CVE-2022-43842": {"epss_score": 0.00034, "epss_percentile": 0.09564}, "CVE-2022-43843": {"epss_score": 0.0004, "epss_percentile": 0.12031}, "CVE-2022-43844": {"epss_score": 0.00337, "epss_percentile": 0.56021}, "CVE-2022-43845": {"epss_score": 0.00063, "epss_percentile": 0.20096}, "CVE-2022-43847": {"epss_score": 0.00068, "epss_percentile": 0.21405}, "CVE-2022-43848": {"epss_score": 0.00112, "epss_percentile": 0.3055}, "CVE-2022-43849": {"epss_score": 0.00112, "epss_percentile": 0.3055}, "CVE-2022-43850": {"epss_score": 0.00117, "epss_percentile": 0.31227}, "CVE-2022-43851": {"epss_score": 0.00037, "epss_percentile": 0.10907}, "CVE-2022-43852": {"epss_score": 0.00062, "epss_percentile": 0.19688}, "CVE-2022-43855": {"epss_score": 0.00011, "epss_percentile": 0.01029}, "CVE-2022-43857": {"epss_score": 0.00166, "epss_percentile": 0.38188}, "CVE-2022-43858": {"epss_score": 0.00214, "epss_percentile": 0.43999}, "CVE-2022-43859": {"epss_score": 0.00111, "epss_percentile": 0.30286}, "CVE-2022-43860": {"epss_score": 0.00177, "epss_percentile": 0.39624}, "CVE-2022-43863": {"epss_score": 0.00055, "epss_percentile": 0.17586}, "CVE-2022-43864": {"epss_score": 0.00101, "epss_percentile": 0.28576}, "CVE-2022-43866": {"epss_score": 0.00137, "epss_percentile": 0.3429}, "CVE-2022-43867": {"epss_score": 0.00102, "epss_percentile": 0.28868}, "CVE-2022-43868": {"epss_score": 0.00059, "epss_percentile": 0.18874}, "CVE-2022-43869": {"epss_score": 0.00091, "epss_percentile": 0.26252}, "CVE-2022-43870": {"epss_score": 0.00086, "epss_percentile": 0.25347}, "CVE-2022-43871": {"epss_score": 0.00092, "epss_percentile": 0.26529}, "CVE-2022-43872": {"epss_score": 0.00139, "epss_percentile": 0.34651}, "CVE-2022-43873": {"epss_score": 0.00111, "epss_percentile": 0.303}, "CVE-2022-43874": {"epss_score": 0.00111, "epss_percentile": 0.30302}, "CVE-2022-43875": {"epss_score": 0.00054, "epss_percentile": 0.17059}, "CVE-2022-43877": {"epss_score": 0.00026, "epss_percentile": 0.06418}, "CVE-2022-43880": {"epss_score": 0.00015, "epss_percentile": 0.02295}, "CVE-2022-43883": {"epss_score": 0.00101, "epss_percentile": 0.28563}, "CVE-2022-43887": {"epss_score": 0.00125, "epss_percentile": 0.32575}, "CVE-2022-43889": {"epss_score": 0.00079, "epss_percentile": 0.2386}, "CVE-2022-43890": {"epss_score": 0.00118, "epss_percentile": 0.31442}, "CVE-2022-43891": {"epss_score": 0.00037, "epss_percentile": 0.10925}, "CVE-2022-43892": {"epss_score": 0.00056, "epss_percentile": 0.17913}, "CVE-2022-43893": {"epss_score": 0.00028, "epss_percentile": 0.07557}, "CVE-2022-43900": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2022-43901": {"epss_score": 0.00049, "epss_percentile": 0.15455}, "CVE-2022-43902": {"epss_score": 0.00085, "epss_percentile": 0.25152}, "CVE-2022-43903": {"epss_score": 0.00035, "epss_percentile": 0.10006}, "CVE-2022-43904": {"epss_score": 0.00082, "epss_percentile": 0.24446}, "CVE-2022-43906": {"epss_score": 0.00077, "epss_percentile": 0.23302}, "CVE-2022-43907": {"epss_score": 0.00101, "epss_percentile": 0.28597}, "CVE-2022-43908": {"epss_score": 0.00045, "epss_percentile": 0.14012}, "CVE-2022-43909": {"epss_score": 0.00135, "epss_percentile": 0.34016}, "CVE-2022-43910": {"epss_score": 0.00021, "epss_percentile": 0.04705}, "CVE-2022-43914": {"epss_score": 0.00169, "epss_percentile": 0.3861}, "CVE-2022-43915": {"epss_score": 0.00083, "epss_percentile": 0.2482}, "CVE-2022-43916": {"epss_score": 0.00049, "epss_percentile": 0.15459}, "CVE-2022-43917": {"epss_score": 0.00044, "epss_percentile": 0.13513}, "CVE-2022-43919": {"epss_score": 0.00064, "epss_percentile": 0.20396}, "CVE-2022-43920": {"epss_score": 0.00489, "epss_percentile": 0.64904}, "CVE-2022-43922": {"epss_score": 0.0004, "epss_percentile": 0.12073}, "CVE-2022-43923": {"epss_score": 0.00026, "epss_percentile": 0.06525}, "CVE-2022-43927": {"epss_score": 0.00147, "epss_percentile": 0.3566}, "CVE-2022-43928": {"epss_score": 0.00063, "epss_percentile": 0.19818}, "CVE-2022-43929": {"epss_score": 0.00102, "epss_percentile": 0.28872}, "CVE-2022-43930": {"epss_score": 0.00104, "epss_percentile": 0.29104}, "CVE-2022-43931": {"epss_score": 0.19227, "epss_percentile": 0.95152}, "CVE-2022-43932": {"epss_score": 0.00318, "epss_percentile": 0.54435}, "CVE-2022-43933": {"epss_score": 0.0002, "epss_percentile": 0.04598}, "CVE-2022-43934": {"epss_score": 0.00049, "epss_percentile": 0.15295}, "CVE-2022-43935": {"epss_score": 0.00071, "epss_percentile": 0.22238}, "CVE-2022-43936": {"epss_score": 0.00197, "epss_percentile": 0.4196}, "CVE-2022-43937": {"epss_score": 0.00103, "epss_percentile": 0.28926}, "CVE-2022-43938": {"epss_score": 0.22434, "epss_percentile": 0.95633}, "CVE-2022-43939": {"epss_score": 0.93789, "epss_percentile": 0.99846}, "CVE-2022-43940": {"epss_score": 0.00252, "epss_percentile": 0.48402}, "CVE-2022-43941": {"epss_score": 0.00082, "epss_percentile": 0.24469}, "CVE-2022-43945": {"epss_score": 0.00509, "epss_percentile": 0.65742}, "CVE-2022-43946": {"epss_score": 0.00172, "epss_percentile": 0.38903}, "CVE-2022-43947": {"epss_score": 0.00126, "epss_percentile": 0.3276}, "CVE-2022-43948": {"epss_score": 0.00094, "epss_percentile": 0.26791}, "CVE-2022-43949": {"epss_score": 0.00102, "epss_percentile": 0.28869}, "CVE-2022-43950": {"epss_score": 0.00153, "epss_percentile": 0.36578}, "CVE-2022-43951": {"epss_score": 0.00463, "epss_percentile": 0.63662}, "CVE-2022-43952": {"epss_score": 0.00395, "epss_percentile": 0.5983}, "CVE-2022-43953": {"epss_score": 0.00045, "epss_percentile": 0.13822}, "CVE-2022-43954": {"epss_score": 0.00339, "epss_percentile": 0.56166}, "CVE-2022-43955": {"epss_score": 0.00244, "epss_percentile": 0.47594}, "CVE-2022-43958": {"epss_score": 0.00092, "epss_percentile": 0.26503}, "CVE-2022-43959": {"epss_score": 0.00622, "epss_percentile": 0.69507}, "CVE-2022-43967": {"epss_score": 0.00853, "epss_percentile": 0.74443}, "CVE-2022-43968": {"epss_score": 0.00853, "epss_percentile": 0.74443}, "CVE-2022-43969": {"epss_score": 0.00227, "epss_percentile": 0.45405}, "CVE-2022-43970": {"epss_score": 0.03511, "epss_percentile": 0.87267}, "CVE-2022-43971": {"epss_score": 0.00858, "epss_percentile": 0.74501}, "CVE-2022-43972": {"epss_score": 0.0097, "epss_percentile": 0.76111}, "CVE-2022-43973": {"epss_score": 0.01499, "epss_percentile": 0.80708}, "CVE-2022-43974": {"epss_score": 0.16018, "epss_percentile": 0.94559}, "CVE-2022-43975": {"epss_score": 0.00202, "epss_percentile": 0.42412}, "CVE-2022-43976": {"epss_score": 0.00117, "epss_percentile": 0.31372}, "CVE-2022-43977": {"epss_score": 0.0011, "epss_percentile": 0.30113}, "CVE-2022-43978": {"epss_score": 0.00162, "epss_percentile": 0.37703}, "CVE-2022-43979": {"epss_score": 0.01025, "epss_percentile": 0.76786}, "CVE-2022-43980": {"epss_score": 0.00248, "epss_percentile": 0.47916}, "CVE-2022-43982": {"epss_score": 0.0452, "epss_percentile": 0.88798}, "CVE-2022-43983": {"epss_score": 0.00152, "epss_percentile": 0.36462}, "CVE-2022-43984": {"epss_score": 0.00152, "epss_percentile": 0.36462}, "CVE-2022-43985": {"epss_score": 0.0137, "epss_percentile": 0.79801}, "CVE-2022-43989": {"epss_score": 0.00447, "epss_percentile": 0.62978}, "CVE-2022-43990": {"epss_score": 0.00447, "epss_percentile": 0.62978}, "CVE-2022-43995": {"epss_score": 0.00083, "epss_percentile": 0.24808}, "CVE-2022-43996": {"epss_score": 0.00305, "epss_percentile": 0.53313}, "CVE-2022-43997": {"epss_score": 0.00098, "epss_percentile": 0.2769}, "CVE-2022-43999": {"epss_score": 0.00358, "epss_percentile": 0.57484}, "CVE-2022-44000": {"epss_score": 0.00358, "epss_percentile": 0.57484}, "CVE-2022-44001": {"epss_score": 0.00437, "epss_percentile": 0.62511}, "CVE-2022-44002": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-44003": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-44004": {"epss_score": 0.01574, "epss_percentile": 0.81104}, "CVE-2022-44005": {"epss_score": 0.00202, "epss_percentile": 0.42487}, "CVE-2022-44006": {"epss_score": 0.05706, "epss_percentile": 0.90137}, "CVE-2022-44007": {"epss_score": 0.00383, "epss_percentile": 0.59121}, "CVE-2022-44008": {"epss_score": 0.00329, "epss_percentile": 0.55387}, "CVE-2022-44009": {"epss_score": 0.00209, "epss_percentile": 0.43312}, "CVE-2022-44010": {"epss_score": 0.00313, "epss_percentile": 0.54052}, "CVE-2022-44011": {"epss_score": 0.00086, "epss_percentile": 0.25366}, "CVE-2022-44012": {"epss_score": 0.00264, "epss_percentile": 0.49734}, "CVE-2022-44013": {"epss_score": 0.00311, "epss_percentile": 0.53822}, "CVE-2022-44014": {"epss_score": 0.00337, "epss_percentile": 0.56065}, "CVE-2022-44015": {"epss_score": 0.00857, "epss_percentile": 0.74488}, "CVE-2022-44016": {"epss_score": 0.00397, "epss_percentile": 0.60051}, "CVE-2022-44017": {"epss_score": 0.00275, "epss_percentile": 0.5069}, "CVE-2022-44018": {"epss_score": 0.00541, "epss_percentile": 0.67058}, "CVE-2022-44019": {"epss_score": 0.03622, "epss_percentile": 0.87444}, "CVE-2022-44020": {"epss_score": 0.00094, "epss_percentile": 0.26982}, "CVE-2022-44022": {"epss_score": 0.00165, "epss_percentile": 0.38066}, "CVE-2022-44023": {"epss_score": 0.00165, "epss_percentile": 0.38066}, "CVE-2022-44024": {"epss_score": 0.00717, "epss_percentile": 0.71887}, "CVE-2022-44025": {"epss_score": 0.00717, "epss_percentile": 0.71887}, "CVE-2022-44026": {"epss_score": 0.00287, "epss_percentile": 0.51804}, "CVE-2022-44027": {"epss_score": 0.00717, "epss_percentile": 0.71887}, "CVE-2022-44028": {"epss_score": 0.00717, "epss_percentile": 0.71887}, "CVE-2022-44029": {"epss_score": 0.00717, "epss_percentile": 0.71887}, "CVE-2022-44030": {"epss_score": 0.0035, "epss_percentile": 0.56928}, "CVE-2022-44031": {"epss_score": 0.00669, "epss_percentile": 0.70759}, "CVE-2022-44032": {"epss_score": 0.0002, "epss_percentile": 0.04481}, "CVE-2022-44033": {"epss_score": 0.0002, "epss_percentile": 0.04481}, "CVE-2022-44034": {"epss_score": 0.0002, "epss_percentile": 0.04481}, "CVE-2022-44036": {"epss_score": 0.00916, "epss_percentile": 0.75416}, "CVE-2022-44037": {"epss_score": 0.00075, "epss_percentile": 0.23057}, "CVE-2022-44038": {"epss_score": 0.02926, "epss_percentile": 0.86007}, "CVE-2022-44039": {"epss_score": 0.00915, "epss_percentile": 0.75407}, "CVE-2022-44048": {"epss_score": 0.00505, "epss_percentile": 0.65589}, "CVE-2022-44049": {"epss_score": 0.00508, "epss_percentile": 0.65703}, "CVE-2022-44050": {"epss_score": 0.00505, "epss_percentile": 0.65589}, "CVE-2022-44051": {"epss_score": 0.00505, "epss_percentile": 0.65589}, "CVE-2022-44052": {"epss_score": 0.00505, "epss_percentile": 0.65589}, "CVE-2022-44053": {"epss_score": 0.00505, "epss_percentile": 0.65589}, "CVE-2022-44054": {"epss_score": 0.00659, "epss_percentile": 0.70503}, "CVE-2022-44069": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-44070": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-44071": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-44073": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-44079": {"epss_score": 0.00049, "epss_percentile": 0.15477}, "CVE-2022-44081": {"epss_score": 0.00046, "epss_percentile": 0.14385}, "CVE-2022-44087": {"epss_score": 0.03308, "epss_percentile": 0.86883}, "CVE-2022-44088": {"epss_score": 0.04475, "epss_percentile": 0.88737}, "CVE-2022-44089": {"epss_score": 0.03308, "epss_percentile": 0.86883}, "CVE-2022-44096": {"epss_score": 0.00299, "epss_percentile": 0.52896}, "CVE-2022-44097": {"epss_score": 0.00299, "epss_percentile": 0.52896}, "CVE-2022-44108": {"epss_score": 0.00365, "epss_percentile": 0.57972}, "CVE-2022-44109": {"epss_score": 0.00365, "epss_percentile": 0.57972}, "CVE-2022-44117": {"epss_score": 0.00316, "epss_percentile": 0.5431}, "CVE-2022-44118": {"epss_score": 0.1029, "epss_percentile": 0.9293}, "CVE-2022-44120": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-44136": {"epss_score": 0.00863, "epss_percentile": 0.74587}, "CVE-2022-44137": {"epss_score": 0.0033, "epss_percentile": 0.55488}, "CVE-2022-44139": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-44140": {"epss_score": 0.00226, "epss_percentile": 0.45359}, "CVE-2022-44149": {"epss_score": 0.8137, "epss_percentile": 0.99134}, "CVE-2022-44151": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-44153": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-44156": {"epss_score": 0.00374, "epss_percentile": 0.58587}, "CVE-2022-44158": {"epss_score": 0.00374, "epss_percentile": 0.58587}, "CVE-2022-44163": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-44167": {"epss_score": 0.00374, "epss_percentile": 0.58587}, "CVE-2022-44168": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-44169": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-44171": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-44172": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-44174": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-44175": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-44176": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-44177": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-44178": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-44180": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-44183": {"epss_score": 0.00923, "epss_percentile": 0.7551}, "CVE-2022-44184": {"epss_score": 0.00514, "epss_percentile": 0.65944}, "CVE-2022-44186": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-44187": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-44188": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-44190": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-44191": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-44193": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-44194": {"epss_score": 0.01021, "epss_percentile": 0.76752}, "CVE-2022-44196": {"epss_score": 0.00514, "epss_percentile": 0.65944}, "CVE-2022-44197": {"epss_score": 0.00514, "epss_percentile": 0.65944}, "CVE-2022-44198": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-44199": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-44200": {"epss_score": 0.00654, "epss_percentile": 0.70362}, "CVE-2022-44201": {"epss_score": 0.02137, "epss_percentile": 0.83732}, "CVE-2022-44202": {"epss_score": 0.01359, "epss_percentile": 0.79736}, "CVE-2022-44204": {"epss_score": 0.00869, "epss_percentile": 0.74686}, "CVE-2022-44211": {"epss_score": 0.00233, "epss_percentile": 0.46033}, "CVE-2022-44212": {"epss_score": 0.00278, "epss_percentile": 0.50859}, "CVE-2022-44213": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-44215": {"epss_score": 0.01469, "epss_percentile": 0.8049}, "CVE-2022-44216": {"epss_score": 0.00158, "epss_percentile": 0.37166}, "CVE-2022-44232": {"epss_score": 0.00057, "epss_percentile": 0.18088}, "CVE-2022-44235": {"epss_score": 0.00274, "epss_percentile": 0.50535}, "CVE-2022-44236": {"epss_score": 0.00299, "epss_percentile": 0.52896}, "CVE-2022-44244": {"epss_score": 0.00363, "epss_percentile": 0.57828}, "CVE-2022-44249": {"epss_score": 0.1657, "epss_percentile": 0.94695}, "CVE-2022-44250": {"epss_score": 0.14899, "epss_percentile": 0.94317}, "CVE-2022-44251": {"epss_score": 0.14899, "epss_percentile": 0.94317}, "CVE-2022-44252": {"epss_score": 0.14899, "epss_percentile": 0.94317}, "CVE-2022-44253": {"epss_score": 0.00673, "epss_percentile": 0.7084}, "CVE-2022-44254": {"epss_score": 0.00673, "epss_percentile": 0.7084}, "CVE-2022-44255": {"epss_score": 0.00692, "epss_percentile": 0.71284}, "CVE-2022-44256": {"epss_score": 0.00673, "epss_percentile": 0.7084}, "CVE-2022-44257": {"epss_score": 0.00673, "epss_percentile": 0.7084}, "CVE-2022-44258": {"epss_score": 0.00673, "epss_percentile": 0.7084}, "CVE-2022-44259": {"epss_score": 0.00673, "epss_percentile": 0.7084}, "CVE-2022-44260": {"epss_score": 0.00673, "epss_percentile": 0.7084}, "CVE-2022-44261": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2022-44262": {"epss_score": 0.01208, "epss_percentile": 0.78531}, "CVE-2022-44263": {"epss_score": 0.00101, "epss_percentile": 0.28706}, "CVE-2022-44264": {"epss_score": 0.00089, "epss_percentile": 0.25957}, "CVE-2022-44267": {"epss_score": 0.21438, "epss_percentile": 0.95518}, "CVE-2022-44268": {"epss_score": 0.88664, "epss_percentile": 0.99482}, "CVE-2022-44276": {"epss_score": 0.254, "epss_percentile": 0.96024}, "CVE-2022-44277": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44278": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44279": {"epss_score": 0.00277, "epss_percentile": 0.5084}, "CVE-2022-44280": {"epss_score": 0.0041, "epss_percentile": 0.60827}, "CVE-2022-44283": {"epss_score": 0.00414, "epss_percentile": 0.61038}, "CVE-2022-44284": {"epss_score": 0.00187, "epss_percentile": 0.40765}, "CVE-2022-44289": {"epss_score": 0.0039, "epss_percentile": 0.59528}, "CVE-2022-44290": {"epss_score": 0.54961, "epss_percentile": 0.97955}, "CVE-2022-44291": {"epss_score": 0.54961, "epss_percentile": 0.97955}, "CVE-2022-44294": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44295": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44296": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44297": {"epss_score": 0.00291, "epss_percentile": 0.52158}, "CVE-2022-44298": {"epss_score": 0.00082, "epss_percentile": 0.24564}, "CVE-2022-44299": {"epss_score": 0.00235, "epss_percentile": 0.46312}, "CVE-2022-44303": {"epss_score": 0.00284, "epss_percentile": 0.51455}, "CVE-2022-44310": {"epss_score": 0.00085, "epss_percentile": 0.25035}, "CVE-2022-44311": {"epss_score": 0.04824, "epss_percentile": 0.89182}, "CVE-2022-44312": {"epss_score": 0.00093, "epss_percentile": 0.26717}, "CVE-2022-44313": {"epss_score": 0.00078, "epss_percentile": 0.23595}, "CVE-2022-44314": {"epss_score": 0.00078, "epss_percentile": 0.23595}, "CVE-2022-44315": {"epss_score": 0.00078, "epss_percentile": 0.23595}, "CVE-2022-44316": {"epss_score": 0.00078, "epss_percentile": 0.23595}, "CVE-2022-44317": {"epss_score": 0.00078, "epss_percentile": 0.23595}, "CVE-2022-44318": {"epss_score": 0.00158, "epss_percentile": 0.37258}, "CVE-2022-44319": {"epss_score": 0.00078, "epss_percentile": 0.23595}, "CVE-2022-44320": {"epss_score": 0.00078, "epss_percentile": 0.23595}, "CVE-2022-44321": {"epss_score": 0.00123, "epss_percentile": 0.32186}, "CVE-2022-44343": {"epss_score": 0.00203, "epss_percentile": 0.42573}, "CVE-2022-44345": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44347": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44348": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44349": {"epss_score": 0.00077, "epss_percentile": 0.23545}, "CVE-2022-44351": {"epss_score": 0.00194, "epss_percentile": 0.41524}, "CVE-2022-44354": {"epss_score": 0.01836, "epss_percentile": 0.82473}, "CVE-2022-44355": {"epss_score": 0.00277, "epss_percentile": 0.5084}, "CVE-2022-44356": {"epss_score": 0.53391, "epss_percentile": 0.97874}, "CVE-2022-44361": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-44362": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-44363": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-44365": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-44366": {"epss_score": 0.02427, "epss_percentile": 0.84718}, "CVE-2022-44367": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-44368": {"epss_score": 0.00062, "epss_percentile": 0.19581}, "CVE-2022-44369": {"epss_score": 0.00062, "epss_percentile": 0.19581}, "CVE-2022-44370": {"epss_score": 0.00053, "epss_percentile": 0.16734}, "CVE-2022-44371": {"epss_score": 0.01288, "epss_percentile": 0.79203}, "CVE-2022-44373": {"epss_score": 0.02367, "epss_percentile": 0.84516}, "CVE-2022-44378": {"epss_score": 0.00504, "epss_percentile": 0.65551}, "CVE-2022-44379": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44380": {"epss_score": 0.00233, "epss_percentile": 0.45995}, "CVE-2022-44381": {"epss_score": 0.00241, "epss_percentile": 0.47255}, "CVE-2022-44384": {"epss_score": 0.48689, "epss_percentile": 0.97649}, "CVE-2022-44387": {"epss_score": 0.00112, "epss_percentile": 0.30495}, "CVE-2022-44389": {"epss_score": 0.00096, "epss_percentile": 0.27308}, "CVE-2022-44390": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-44393": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44399": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-44400": {"epss_score": 0.00798, "epss_percentile": 0.73514}, "CVE-2022-44401": {"epss_score": 0.00411, "epss_percentile": 0.60885}, "CVE-2022-44402": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44403": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44411": {"epss_score": 0.00138, "epss_percentile": 0.34363}, "CVE-2022-44413": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44414": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44415": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44419": {"epss_score": 0.0002, "epss_percentile": 0.04581}, "CVE-2022-44420": {"epss_score": 0.00016, "epss_percentile": 0.02639}, "CVE-2022-44421": {"epss_score": 0.0004, "epss_percentile": 0.12071}, "CVE-2022-44422": {"epss_score": 0.0001, "epss_percentile": 0.00841}, "CVE-2022-44423": {"epss_score": 0.0001, "epss_percentile": 0.00841}, "CVE-2022-44424": {"epss_score": 0.0001, "epss_percentile": 0.00841}, "CVE-2022-44425": {"epss_score": 0.00078, "epss_percentile": 0.23756}, "CVE-2022-44426": {"epss_score": 0.00078, "epss_percentile": 0.23756}, "CVE-2022-44427": {"epss_score": 0.0005, "epss_percentile": 0.15667}, "CVE-2022-44428": {"epss_score": 0.0005, "epss_percentile": 0.15667}, "CVE-2022-44429": {"epss_score": 0.0005, "epss_percentile": 0.15667}, "CVE-2022-44430": {"epss_score": 0.0005, "epss_percentile": 0.15667}, "CVE-2022-44431": {"epss_score": 0.0005, "epss_percentile": 0.15667}, "CVE-2022-44432": {"epss_score": 0.00078, "epss_percentile": 0.23756}, "CVE-2022-44433": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2022-44434": {"epss_score": 0.00038, "epss_percentile": 0.11386}, "CVE-2022-44435": {"epss_score": 0.00038, "epss_percentile": 0.11386}, "CVE-2022-44436": {"epss_score": 0.00038, "epss_percentile": 0.11386}, "CVE-2022-44437": {"epss_score": 0.00038, "epss_percentile": 0.11386}, "CVE-2022-44438": {"epss_score": 0.00038, "epss_percentile": 0.11386}, "CVE-2022-44439": {"epss_score": 0.0001, "epss_percentile": 0.00841}, "CVE-2022-44440": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-44441": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-44442": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-44443": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-44444": {"epss_score": 0.00016, "epss_percentile": 0.02642}, "CVE-2022-44445": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-44446": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2022-44447": {"epss_score": 0.00024, "epss_percentile": 0.0584}, "CVE-2022-44448": {"epss_score": 0.00015, "epss_percentile": 0.02466}, "CVE-2022-44449": {"epss_score": 0.00319, "epss_percentile": 0.54528}, "CVE-2022-44451": {"epss_score": 0.00144, "epss_percentile": 0.35315}, "CVE-2022-44455": {"epss_score": 0.00063, "epss_percentile": 0.19955}, "CVE-2022-44456": {"epss_score": 0.35569, "epss_percentile": 0.9692}, "CVE-2022-44457": {"epss_score": 0.0046, "epss_percentile": 0.63529}, "CVE-2022-44462": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-44463": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-44465": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-44466": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-44467": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-44468": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-44469": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-44470": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-44471": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-44473": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-44474": {"epss_score": 0.01739, "epss_percentile": 0.82038}, "CVE-2022-44488": {"epss_score": 0.00418, "epss_percentile": 0.61325}, "CVE-2022-44498": {"epss_score": 0.00257, "epss_percentile": 0.48878}, "CVE-2022-44499": {"epss_score": 0.00257, "epss_percentile": 0.48878}, "CVE-2022-44500": {"epss_score": 0.00257, "epss_percentile": 0.48878}, "CVE-2022-44502": {"epss_score": 0.00066, "epss_percentile": 0.20889}, "CVE-2022-44510": {"epss_score": 0.02166, "epss_percentile": 0.83848}, "CVE-2022-44512": {"epss_score": 0.00227, "epss_percentile": 0.45439}, "CVE-2022-44513": {"epss_score": 0.00227, "epss_percentile": 0.45439}, "CVE-2022-44514": {"epss_score": 0.00254, "epss_percentile": 0.48527}, "CVE-2022-44515": {"epss_score": 0.00042, "epss_percentile": 0.1266}, "CVE-2022-44516": {"epss_score": 0.00042, "epss_percentile": 0.1266}, "CVE-2022-44517": {"epss_score": 0.00042, "epss_percentile": 0.1266}, "CVE-2022-44518": {"epss_score": 0.00254, "epss_percentile": 0.48527}, "CVE-2022-44519": {"epss_score": 0.00052, "epss_percentile": 0.1645}, "CVE-2022-44520": {"epss_score": 0.00254, "epss_percentile": 0.48527}, "CVE-2022-44532": {"epss_score": 0.00314, "epss_percentile": 0.54096}, "CVE-2022-44533": {"epss_score": 0.00679, "epss_percentile": 0.71022}, "CVE-2022-44534": {"epss_score": 0.00776, "epss_percentile": 0.73097}, "CVE-2022-44535": {"epss_score": 0.0092, "epss_percentile": 0.75471}, "CVE-2022-44542": {"epss_score": 0.00884, "epss_percentile": 0.74927}, "CVE-2022-44543": {"epss_score": 0.00228, "epss_percentile": 0.45478}, "CVE-2022-44544": {"epss_score": 0.00544, "epss_percentile": 0.67141}, "CVE-2022-44546": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-44547": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-44548": {"epss_score": 0.00029, "epss_percentile": 0.07659}, "CVE-2022-44549": {"epss_score": 0.00112, "epss_percentile": 0.30525}, "CVE-2022-44550": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-44551": {"epss_score": 0.00191, "epss_percentile": 0.41253}, "CVE-2022-44552": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-44553": {"epss_score": 0.00101, "epss_percentile": 0.28652}, "CVE-2022-44554": {"epss_score": 0.00163, "epss_percentile": 0.37817}, "CVE-2022-44555": {"epss_score": 0.00163, "epss_percentile": 0.37817}, "CVE-2022-44556": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-44557": {"epss_score": 0.00099, "epss_percentile": 0.28316}, "CVE-2022-44558": {"epss_score": 0.00801, "epss_percentile": 0.73566}, "CVE-2022-44559": {"epss_score": 0.00801, "epss_percentile": 0.73566}, "CVE-2022-44560": {"epss_score": 0.00082, "epss_percentile": 0.24453}, "CVE-2022-44561": {"epss_score": 0.00082, "epss_percentile": 0.24453}, "CVE-2022-44562": {"epss_score": 0.00801, "epss_percentile": 0.73566}, "CVE-2022-44563": {"epss_score": 0.00126, "epss_percentile": 0.32779}, "CVE-2022-44564": {"epss_score": 0.0003, "epss_percentile": 0.08275}, "CVE-2022-44565": {"epss_score": 0.00203, "epss_percentile": 0.4252}, "CVE-2022-44566": {"epss_score": 0.01997, "epss_percentile": 0.83196}, "CVE-2022-44567": {"epss_score": 0.05876, "epss_percentile": 0.90286}, "CVE-2022-44569": {"epss_score": 0.0024, "epss_percentile": 0.47201}, "CVE-2022-44570": {"epss_score": 0.03145, "epss_percentile": 0.86494}, "CVE-2022-44571": {"epss_score": 0.03145, "epss_percentile": 0.86494}, "CVE-2022-44572": {"epss_score": 0.00257, "epss_percentile": 0.48857}, "CVE-2022-44574": {"epss_score": 0.21759, "epss_percentile": 0.95556}, "CVE-2022-44575": {"epss_score": 0.00542, "epss_percentile": 0.67078}, "CVE-2022-44576": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-44578": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2022-44580": {"epss_score": 0.00146, "epss_percentile": 0.35582}, "CVE-2022-44581": {"epss_score": 0.00343, "epss_percentile": 0.56441}, "CVE-2022-44582": {"epss_score": 0.00089, "epss_percentile": 0.25945}, "CVE-2022-44583": {"epss_score": 0.00583, "epss_percentile": 0.68331}, "CVE-2022-44584": {"epss_score": 0.00391, "epss_percentile": 0.59624}, "CVE-2022-44585": {"epss_score": 0.00074, "epss_percentile": 0.22715}, "CVE-2022-44586": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-44587": {"epss_score": 0.00519, "epss_percentile": 0.66172}, "CVE-2022-44588": {"epss_score": 0.00381, "epss_percentile": 0.59007}, "CVE-2022-44589": {"epss_score": 0.00691, "epss_percentile": 0.71275}, "CVE-2022-44590": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-44591": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-44593": {"epss_score": 0.00087, "epss_percentile": 0.25617}, "CVE-2022-44594": {"epss_score": 0.00089, "epss_percentile": 0.25945}, "CVE-2022-44595": {"epss_score": 0.00168, "epss_percentile": 0.38477}, "CVE-2022-44606": {"epss_score": 0.04464, "epss_percentile": 0.88727}, "CVE-2022-44608": {"epss_score": 0.00521, "epss_percentile": 0.66238}, "CVE-2022-44610": {"epss_score": 0.00112, "epss_percentile": 0.30425}, "CVE-2022-44611": {"epss_score": 0.00038, "epss_percentile": 0.11057}, "CVE-2022-44612": {"epss_score": 0.0005, "epss_percentile": 0.15698}, "CVE-2022-44617": {"epss_score": 0.00063, "epss_percentile": 0.19929}, "CVE-2022-44619": {"epss_score": 0.00138, "epss_percentile": 0.34355}, "CVE-2022-44620": {"epss_score": 0.00622, "epss_percentile": 0.69496}, "CVE-2022-44621": {"epss_score": 0.09183, "epss_percentile": 0.92435}, "CVE-2022-44622": {"epss_score": 4e-05, "epss_percentile": 0.00142}, "CVE-2022-44623": {"epss_score": 4e-05, "epss_percentile": 0.00154}, "CVE-2022-44624": {"epss_score": 4e-05, "epss_percentile": 0.00154}, "CVE-2022-44625": {"epss_score": 0.00095, "epss_percentile": 0.27084}, "CVE-2022-44626": {"epss_score": 0.00056, "epss_percentile": 0.17962}, "CVE-2022-44627": {"epss_score": 0.00088, "epss_percentile": 0.25752}, "CVE-2022-44628": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-44629": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2022-44631": {"epss_score": 0.00078, "epss_percentile": 0.23774}, "CVE-2022-44632": {"epss_score": 0.00076, "epss_percentile": 0.2308}, "CVE-2022-44633": {"epss_score": 0.00204, "epss_percentile": 0.42638}, "CVE-2022-44634": {"epss_score": 0.00604, "epss_percentile": 0.68967}, "CVE-2022-44635": {"epss_score": 0.12974, "epss_percentile": 0.93833}, "CVE-2022-44636": {"epss_score": 0.00074, "epss_percentile": 0.22711}, "CVE-2022-44637": {"epss_score": 0.00669, "epss_percentile": 0.70759}, "CVE-2022-44638": {"epss_score": 0.00366, "epss_percentile": 0.58092}, "CVE-2022-44640": {"epss_score": 0.01589, "epss_percentile": 0.81196}, "CVE-2022-44641": {"epss_score": 0.00172, "epss_percentile": 0.38999}, "CVE-2022-44643": {"epss_score": 0.0023, "epss_percentile": 0.45716}, "CVE-2022-44644": {"epss_score": 0.00131, "epss_percentile": 0.33368}, "CVE-2022-44645": {"epss_score": 0.03536, "epss_percentile": 0.8731}, "CVE-2022-44646": {"epss_score": 5e-05, "epss_percentile": 0.00218}, "CVE-2022-44647": {"epss_score": 0.00087, "epss_percentile": 0.25543}, "CVE-2022-44648": {"epss_score": 0.00087, "epss_percentile": 0.25543}, "CVE-2022-44649": {"epss_score": 0.00188, "epss_percentile": 0.40885}, "CVE-2022-44650": {"epss_score": 0.00222, "epss_percentile": 0.44722}, "CVE-2022-44651": {"epss_score": 0.00146, "epss_percentile": 0.35543}, "CVE-2022-44652": {"epss_score": 0.00077, "epss_percentile": 0.23442}, "CVE-2022-44653": {"epss_score": 0.00197, "epss_percentile": 0.41828}, "CVE-2022-44654": {"epss_score": 0.00574, "epss_percentile": 0.68088}, "CVE-2022-44666": {"epss_score": 0.67981, "epss_percentile": 0.98527}, "CVE-2022-44667": {"epss_score": 0.01685, "epss_percentile": 0.81751}, "CVE-2022-44668": {"epss_score": 0.00566, "epss_percentile": 0.67826}, "CVE-2022-44669": {"epss_score": 0.00349, "epss_percentile": 0.56895}, "CVE-2022-44670": {"epss_score": 0.0056, "epss_percentile": 0.67649}, "CVE-2022-44671": {"epss_score": 0.01277, "epss_percentile": 0.7912}, "CVE-2022-44673": {"epss_score": 0.02988, "epss_percentile": 0.8614}, "CVE-2022-44674": {"epss_score": 0.00608, "epss_percentile": 0.69066}, "CVE-2022-44675": {"epss_score": 0.06208, "epss_percentile": 0.90567}, "CVE-2022-44676": {"epss_score": 0.0048, "epss_percentile": 0.64468}, "CVE-2022-44677": {"epss_score": 0.0118, "epss_percentile": 0.78301}, "CVE-2022-44678": {"epss_score": 0.01186, "epss_percentile": 0.7835}, "CVE-2022-44679": {"epss_score": 0.00761, "epss_percentile": 0.72819}, "CVE-2022-44680": {"epss_score": 0.0118, "epss_percentile": 0.78301}, "CVE-2022-44681": {"epss_score": 0.01215, "epss_percentile": 0.78586}, "CVE-2022-44682": {"epss_score": 0.00669, "epss_percentile": 0.70765}, "CVE-2022-44683": {"epss_score": 0.02795, "epss_percentile": 0.8568}, "CVE-2022-44684": {"epss_score": 0.00533, "epss_percentile": 0.66712}, "CVE-2022-44687": {"epss_score": 0.01668, "epss_percentile": 0.81659}, "CVE-2022-44688": {"epss_score": 0.0014, "epss_percentile": 0.34707}, "CVE-2022-44689": {"epss_score": 0.01929, "epss_percentile": 0.82935}, "CVE-2022-44690": {"epss_score": 0.30788, "epss_percentile": 0.96568}, "CVE-2022-44691": {"epss_score": 0.07014, "epss_percentile": 0.91187}, "CVE-2022-44692": {"epss_score": 0.02249, "epss_percentile": 0.84142}, "CVE-2022-44693": {"epss_score": 0.11672, "epss_percentile": 0.93441}, "CVE-2022-44694": {"epss_score": 0.01646, "epss_percentile": 0.81537}, "CVE-2022-44695": {"epss_score": 0.02297, "epss_percentile": 0.843}, "CVE-2022-44696": {"epss_score": 0.02297, "epss_percentile": 0.843}, "CVE-2022-44697": {"epss_score": 0.01215, "epss_percentile": 0.78586}, "CVE-2022-44698": {"epss_score": 0.66423, "epss_percentile": 0.98462}, "CVE-2022-44699": {"epss_score": 0.00689, "epss_percentile": 0.71224}, "CVE-2022-44702": {"epss_score": 0.08996, "epss_percentile": 0.92356}, "CVE-2022-44704": {"epss_score": 0.01162, "epss_percentile": 0.78149}, "CVE-2022-44707": {"epss_score": 0.10398, "epss_percentile": 0.92974}, "CVE-2022-44708": {"epss_score": 0.00334, "epss_percentile": 0.5574}, "CVE-2022-44710": {"epss_score": 0.00816, "epss_percentile": 0.73835}, "CVE-2022-44713": {"epss_score": 0.11181, "epss_percentile": 0.93255}, "CVE-2022-44715": {"epss_score": 0.01074, "epss_percentile": 0.77298}, "CVE-2022-44717": {"epss_score": 0.00168, "epss_percentile": 0.38472}, "CVE-2022-44718": {"epss_score": 0.00168, "epss_percentile": 0.38472}, "CVE-2022-44719": {"epss_score": 0.00054, "epss_percentile": 0.17327}, "CVE-2022-44720": {"epss_score": 0.00664, "epss_percentile": 0.7063}, "CVE-2022-44724": {"epss_score": 0.00375, "epss_percentile": 0.5863}, "CVE-2022-44725": {"epss_score": 0.00065, "epss_percentile": 0.20463}, "CVE-2022-44726": {"epss_score": 0.00077, "epss_percentile": 0.23545}, "CVE-2022-44727": {"epss_score": 0.00539, "epss_percentile": 0.66982}, "CVE-2022-44729": {"epss_score": 0.00126, "epss_percentile": 0.32702}, "CVE-2022-44730": {"epss_score": 0.00287, "epss_percentile": 0.51785}, "CVE-2022-44731": {"epss_score": 0.00279, "epss_percentile": 0.50997}, "CVE-2022-44732": {"epss_score": 0.00031, "epss_percentile": 0.08397}, "CVE-2022-44733": {"epss_score": 0.00031, "epss_percentile": 0.08397}, "CVE-2022-44734": {"epss_score": 0.00089, "epss_percentile": 0.25945}, "CVE-2022-44735": {"epss_score": 0.00076, "epss_percentile": 0.2308}, "CVE-2022-44736": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-44737": {"epss_score": 0.00104, "epss_percentile": 0.29139}, "CVE-2022-44738": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-44739": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-44740": {"epss_score": 0.00104, "epss_percentile": 0.29139}, "CVE-2022-44741": {"epss_score": 0.00102, "epss_percentile": 0.28803}, "CVE-2022-44742": {"epss_score": 0.00112, "epss_percentile": 0.30441}, "CVE-2022-44743": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2022-44744": {"epss_score": 0.00053, "epss_percentile": 0.16795}, "CVE-2022-44745": {"epss_score": 0.00065, "epss_percentile": 0.2064}, "CVE-2022-44746": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2022-44747": {"epss_score": 0.00039, "epss_percentile": 0.11535}, "CVE-2022-44748": {"epss_score": 0.04779, "epss_percentile": 0.89135}, "CVE-2022-44749": {"epss_score": 0.00203, "epss_percentile": 0.42575}, "CVE-2022-44750": {"epss_score": 0.04421, "epss_percentile": 0.8867}, "CVE-2022-44751": {"epss_score": 0.04421, "epss_percentile": 0.8867}, "CVE-2022-44752": {"epss_score": 0.03926, "epss_percentile": 0.87965}, "CVE-2022-44753": {"epss_score": 0.04421, "epss_percentile": 0.8867}, "CVE-2022-44754": {"epss_score": 0.03926, "epss_percentile": 0.87965}, "CVE-2022-44755": {"epss_score": 0.03926, "epss_percentile": 0.87965}, "CVE-2022-44756": {"epss_score": 0.00311, "epss_percentile": 0.53825}, "CVE-2022-44757": {"epss_score": 0.00097, "epss_percentile": 0.27534}, "CVE-2022-44758": {"epss_score": 0.00106, "epss_percentile": 0.29494}, "CVE-2022-44759": {"epss_score": 0.00041, "epss_percentile": 0.12399}, "CVE-2022-44760": {"epss_score": 0.00078, "epss_percentile": 0.23674}, "CVE-2022-44784": {"epss_score": 0.00572, "epss_percentile": 0.68022}, "CVE-2022-44785": {"epss_score": 0.01211, "epss_percentile": 0.78555}, "CVE-2022-44786": {"epss_score": 0.00266, "epss_percentile": 0.49944}, "CVE-2022-44787": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-44788": {"epss_score": 0.00291, "epss_percentile": 0.52184}, "CVE-2022-44789": {"epss_score": 0.02594, "epss_percentile": 0.8519}, "CVE-2022-44790": {"epss_score": 0.00876, "epss_percentile": 0.74787}, "CVE-2022-44792": {"epss_score": 0.02346, "epss_percentile": 0.84451}, "CVE-2022-44793": {"epss_score": 0.01438, "epss_percentile": 0.80285}, "CVE-2022-44794": {"epss_score": 0.00729, "epss_percentile": 0.72132}, "CVE-2022-44795": {"epss_score": 0.0029, "epss_percentile": 0.5211}, "CVE-2022-44796": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2022-44797": {"epss_score": 0.00689, "epss_percentile": 0.71219}, "CVE-2022-44801": {"epss_score": 0.0113, "epss_percentile": 0.77853}, "CVE-2022-44804": {"epss_score": 0.00688, "epss_percentile": 0.712}, "CVE-2022-44806": {"epss_score": 0.01359, "epss_percentile": 0.79736}, "CVE-2022-44807": {"epss_score": 0.00688, "epss_percentile": 0.712}, "CVE-2022-44808": {"epss_score": 0.19783, "epss_percentile": 0.9524}, "CVE-2022-44820": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44830": {"epss_score": 0.06532, "epss_percentile": 0.90826}, "CVE-2022-44832": {"epss_score": 0.259, "epss_percentile": 0.96092}, "CVE-2022-44838": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44840": {"epss_score": 0.00021, "epss_percentile": 0.04809}, "CVE-2022-44843": {"epss_score": 0.14899, "epss_percentile": 0.94317}, "CVE-2022-44844": {"epss_score": 0.14899, "epss_percentile": 0.94317}, "CVE-2022-44849": {"epss_score": 0.00087, "epss_percentile": 0.2551}, "CVE-2022-44858": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44859": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44860": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-44870": {"epss_score": 0.00258, "epss_percentile": 0.48989}, "CVE-2022-44874": {"epss_score": 0.00055, "epss_percentile": 0.17571}, "CVE-2022-44875": {"epss_score": 0.01481, "epss_percentile": 0.8057}, "CVE-2022-44877": {"epss_score": 0.94457, "epss_percentile": 0.99993}, "CVE-2022-44897": {"epss_score": 0.01107, "epss_percentile": 0.77626}, "CVE-2022-44898": {"epss_score": 0.00183, "epss_percentile": 0.40364}, "CVE-2022-44900": {"epss_score": 0.3163, "epss_percentile": 0.9664}, "CVE-2022-44910": {"epss_score": 0.00062, "epss_percentile": 0.19623}, "CVE-2022-44928": {"epss_score": 0.15189, "epss_percentile": 0.9438}, "CVE-2022-44929": {"epss_score": 0.02092, "epss_percentile": 0.83573}, "CVE-2022-44930": {"epss_score": 0.2807, "epss_percentile": 0.96306}, "CVE-2022-44931": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-44932": {"epss_score": 0.00415, "epss_percentile": 0.61142}, "CVE-2022-44937": {"epss_score": 0.00096, "epss_percentile": 0.27308}, "CVE-2022-44938": {"epss_score": 0.00411, "epss_percentile": 0.60885}, "CVE-2022-44939": {"epss_score": 0.00077, "epss_percentile": 0.23305}, "CVE-2022-44940": {"epss_score": 0.00099, "epss_percentile": 0.28381}, "CVE-2022-44942": {"epss_score": 0.00207, "epss_percentile": 0.43123}, "CVE-2022-44944": {"epss_score": 0.01093, "epss_percentile": 0.77483}, "CVE-2022-44945": {"epss_score": 0.00909, "epss_percentile": 0.75291}, "CVE-2022-44946": {"epss_score": 0.01093, "epss_percentile": 0.77483}, "CVE-2022-44947": {"epss_score": 0.01093, "epss_percentile": 0.77483}, "CVE-2022-44948": {"epss_score": 0.01722, "epss_percentile": 0.81937}, "CVE-2022-44949": {"epss_score": 0.01801, "epss_percentile": 0.82325}, "CVE-2022-44950": {"epss_score": 0.01801, "epss_percentile": 0.82325}, "CVE-2022-44951": {"epss_score": 0.01722, "epss_percentile": 0.81937}, "CVE-2022-44952": {"epss_score": 0.01757, "epss_percentile": 0.82132}, "CVE-2022-44953": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-44954": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-44955": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-44956": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-44957": {"epss_score": 0.01842, "epss_percentile": 0.825}, "CVE-2022-44959": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-44960": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-44961": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-44962": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-45003": {"epss_score": 0.00221, "epss_percentile": 0.44672}, "CVE-2022-45004": {"epss_score": 0.00316, "epss_percentile": 0.54275}, "CVE-2022-45005": {"epss_score": 0.1215, "epss_percentile": 0.93585}, "CVE-2022-45008": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-45009": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-45010": {"epss_score": 0.0025, "epss_percentile": 0.4817}, "CVE-2022-45012": {"epss_score": 0.00366, "epss_percentile": 0.58057}, "CVE-2022-45013": {"epss_score": 0.00366, "epss_percentile": 0.58057}, "CVE-2022-45014": {"epss_score": 0.00366, "epss_percentile": 0.58057}, "CVE-2022-45015": {"epss_score": 0.00366, "epss_percentile": 0.58057}, "CVE-2022-45016": {"epss_score": 0.00366, "epss_percentile": 0.58057}, "CVE-2022-45017": {"epss_score": 0.00366, "epss_percentile": 0.58057}, "CVE-2022-45019": {"epss_score": 0.00267, "epss_percentile": 0.49965}, "CVE-2022-45020": {"epss_score": 0.00267, "epss_percentile": 0.50008}, "CVE-2022-45025": {"epss_score": 0.59006, "epss_percentile": 0.98145}, "CVE-2022-45026": {"epss_score": 0.00797, "epss_percentile": 0.735}, "CVE-2022-45027": {"epss_score": 0.00312, "epss_percentile": 0.53985}, "CVE-2022-45028": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-45030": {"epss_score": 0.00048, "epss_percentile": 0.15239}, "CVE-2022-45033": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-45036": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-45037": {"epss_score": 0.21323, "epss_percentile": 0.95501}, "CVE-2022-45038": {"epss_score": 0.21323, "epss_percentile": 0.95501}, "CVE-2022-45039": {"epss_score": 0.0094, "epss_percentile": 0.75737}, "CVE-2022-45040": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-45041": {"epss_score": 0.00251, "epss_percentile": 0.48283}, "CVE-2022-45043": {"epss_score": 0.06425, "epss_percentile": 0.90753}, "CVE-2022-45044": {"epss_score": 0.00566, "epss_percentile": 0.67824}, "CVE-2022-45045": {"epss_score": 0.0075, "epss_percentile": 0.72616}, "CVE-2022-45047": {"epss_score": 0.05071, "epss_percentile": 0.89464}, "CVE-2022-45048": {"epss_score": 0.00034, "epss_percentile": 0.09745}, "CVE-2022-45049": {"epss_score": 0.00458, "epss_percentile": 0.63417}, "CVE-2022-45050": {"epss_score": 0.00458, "epss_percentile": 0.63417}, "CVE-2022-45051": {"epss_score": 0.00458, "epss_percentile": 0.63417}, "CVE-2022-45052": {"epss_score": 0.00358, "epss_percentile": 0.57515}, "CVE-2022-45059": {"epss_score": 0.01222, "epss_percentile": 0.7866}, "CVE-2022-45060": {"epss_score": 0.01085, "epss_percentile": 0.77405}, "CVE-2022-45061": {"epss_score": 0.00109, "epss_percentile": 0.29964}, "CVE-2022-45062": {"epss_score": 0.03547, "epss_percentile": 0.87331}, "CVE-2022-45063": {"epss_score": 0.25699, "epss_percentile": 0.96057}, "CVE-2022-45064": {"epss_score": 0.00859, "epss_percentile": 0.74519}, "CVE-2022-45065": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2022-45066": {"epss_score": 0.00573, "epss_percentile": 0.68048}, "CVE-2022-45067": {"epss_score": 0.00094, "epss_percentile": 0.26965}, "CVE-2022-45068": {"epss_score": 0.00057, "epss_percentile": 0.18197}, "CVE-2022-45069": {"epss_score": 0.00759, "epss_percentile": 0.72791}, "CVE-2022-45070": {"epss_score": 0.00176, "epss_percentile": 0.39399}, "CVE-2022-45071": {"epss_score": 0.00202, "epss_percentile": 0.42418}, "CVE-2022-45072": {"epss_score": 0.00267, "epss_percentile": 0.49999}, "CVE-2022-45073": {"epss_score": 0.00079, "epss_percentile": 0.2385}, "CVE-2022-45074": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2022-45076": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-45077": {"epss_score": 0.007, "epss_percentile": 0.71476}, "CVE-2022-45078": {"epss_score": 0.00483, "epss_percentile": 0.64566}, "CVE-2022-45079": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-45080": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2022-45082": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-45083": {"epss_score": 0.00272, "epss_percentile": 0.50377}, "CVE-2022-45084": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2022-45085": {"epss_score": 0.00103, "epss_percentile": 0.28979}, "CVE-2022-45086": {"epss_score": 0.00123, "epss_percentile": 0.32328}, "CVE-2022-45087": {"epss_score": 0.0012, "epss_percentile": 0.31711}, "CVE-2022-45088": {"epss_score": 0.00152, "epss_percentile": 0.36454}, "CVE-2022-45089": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2022-45090": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2022-45091": {"epss_score": 0.00123, "epss_percentile": 0.32328}, "CVE-2022-45092": {"epss_score": 0.35347, "epss_percentile": 0.96902}, "CVE-2022-45093": {"epss_score": 0.01903, "epss_percentile": 0.82788}, "CVE-2022-45094": {"epss_score": 0.00797, "epss_percentile": 0.73495}, "CVE-2022-45095": {"epss_score": 0.00084, "epss_percentile": 0.24891}, "CVE-2022-45096": {"epss_score": 0.00369, "epss_percentile": 0.58244}, "CVE-2022-45097": {"epss_score": 0.00141, "epss_percentile": 0.34929}, "CVE-2022-45098": {"epss_score": 0.00029, "epss_percentile": 0.07663}, "CVE-2022-45099": {"epss_score": 0.00051, "epss_percentile": 0.16053}, "CVE-2022-45100": {"epss_score": 0.00669, "epss_percentile": 0.70762}, "CVE-2022-45101": {"epss_score": 0.03412, "epss_percentile": 0.87088}, "CVE-2022-45102": {"epss_score": 0.00436, "epss_percentile": 0.62473}, "CVE-2022-45103": {"epss_score": 0.00191, "epss_percentile": 0.41177}, "CVE-2022-45104": {"epss_score": 0.04192, "epss_percentile": 0.88377}, "CVE-2022-45109": {"epss_score": 0.00096, "epss_percentile": 0.2726}, "CVE-2022-45112": {"epss_score": 0.0005, "epss_percentile": 0.15859}, "CVE-2022-45113": {"epss_score": 0.00348, "epss_percentile": 0.56812}, "CVE-2022-45115": {"epss_score": 0.00061, "epss_percentile": 0.19523}, "CVE-2022-45118": {"epss_score": 0.00044, "epss_percentile": 0.13474}, "CVE-2022-45121": {"epss_score": 0.00147, "epss_percentile": 0.35708}, "CVE-2022-45122": {"epss_score": 0.00847, "epss_percentile": 0.74346}, "CVE-2022-45124": {"epss_score": 0.08573, "epss_percentile": 0.9213}, "CVE-2022-45126": {"epss_score": 0.00038, "epss_percentile": 0.11127}, "CVE-2022-45127": {"epss_score": 0.00098, "epss_percentile": 0.27684}, "CVE-2022-45128": {"epss_score": 0.00081, "epss_percentile": 0.24232}, "CVE-2022-45129": {"epss_score": 0.00503, "epss_percentile": 0.65445}, "CVE-2022-45130": {"epss_score": 0.00757, "epss_percentile": 0.72762}, "CVE-2022-45132": {"epss_score": 0.04707, "epss_percentile": 0.89033}, "CVE-2022-45133": {"epss_score": 0.0011, "epss_percentile": 0.30184}, "CVE-2022-45134": {"epss_score": 0.00278, "epss_percentile": 0.50893}, "CVE-2022-45135": {"epss_score": 0.0148, "epss_percentile": 0.80563}, "CVE-2022-45136": {"epss_score": 0.01959, "epss_percentile": 0.83053}, "CVE-2022-45137": {"epss_score": 0.00133, "epss_percentile": 0.3365}, "CVE-2022-45138": {"epss_score": 0.00336, "epss_percentile": 0.56003}, "CVE-2022-45139": {"epss_score": 0.00087, "epss_percentile": 0.25468}, "CVE-2022-45140": {"epss_score": 0.01776, "epss_percentile": 0.8222}, "CVE-2022-45141": {"epss_score": 0.00577, "epss_percentile": 0.68164}, "CVE-2022-45142": {"epss_score": 0.00065, "epss_percentile": 0.20529}, "CVE-2022-45143": {"epss_score": 0.0095, "epss_percentile": 0.75853}, "CVE-2022-45144": {"epss_score": 0.00167, "epss_percentile": 0.38386}, "CVE-2022-45145": {"epss_score": 0.00401, "epss_percentile": 0.602}, "CVE-2022-45146": {"epss_score": 0.00117, "epss_percentile": 0.31205}, "CVE-2022-45147": {"epss_score": 0.00093, "epss_percentile": 0.26704}, "CVE-2022-45149": {"epss_score": 0.00265, "epss_percentile": 0.49799}, "CVE-2022-45150": {"epss_score": 0.00722, "epss_percentile": 0.72001}, "CVE-2022-45151": {"epss_score": 0.00675, "epss_percentile": 0.70888}, "CVE-2022-45152": {"epss_score": 0.00358, "epss_percentile": 0.57481}, "CVE-2022-45153": {"epss_score": 0.00058, "epss_percentile": 0.18374}, "CVE-2022-45154": {"epss_score": 0.00013, "epss_percentile": 0.01536}, "CVE-2022-45155": {"epss_score": 0.00034, "epss_percentile": 0.09692}, "CVE-2022-45157": {"epss_score": 0.00071, "epss_percentile": 0.22042}, "CVE-2022-45163": {"epss_score": 0.00141, "epss_percentile": 0.34925}, "CVE-2022-45164": {"epss_score": 0.00046, "epss_percentile": 0.14309}, "CVE-2022-45165": {"epss_score": 0.00103, "epss_percentile": 0.2908}, "CVE-2022-45166": {"epss_score": 0.00114, "epss_percentile": 0.3085}, "CVE-2022-45167": {"epss_score": 0.00161, "epss_percentile": 0.37602}, "CVE-2022-45168": {"epss_score": 0.00046, "epss_percentile": 0.14289}, "CVE-2022-45169": {"epss_score": 0.00021, "epss_percentile": 0.04814}, "CVE-2022-45170": {"epss_score": 0.00043, "epss_percentile": 0.1303}, "CVE-2022-45171": {"epss_score": 0.0241, "epss_percentile": 0.84664}, "CVE-2022-45172": {"epss_score": 0.00148, "epss_percentile": 0.35829}, "CVE-2022-45173": {"epss_score": 0.00027, "epss_percentile": 0.07165}, "CVE-2022-45174": {"epss_score": 0.00027, "epss_percentile": 0.07165}, "CVE-2022-45175": {"epss_score": 0.00188, "epss_percentile": 0.4084}, "CVE-2022-45176": {"epss_score": 0.0034, "epss_percentile": 0.56233}, "CVE-2022-45177": {"epss_score": 0.00114, "epss_percentile": 0.3087}, "CVE-2022-45178": {"epss_score": 0.00324, "epss_percentile": 0.54962}, "CVE-2022-45179": {"epss_score": 0.00084, "epss_percentile": 0.24968}, "CVE-2022-45180": {"epss_score": 0.00116, "epss_percentile": 0.31151}, "CVE-2022-45182": {"epss_score": 0.01077, "epss_percentile": 0.77337}, "CVE-2022-45183": {"epss_score": 0.00483, "epss_percentile": 0.6459}, "CVE-2022-45184": {"epss_score": 0.00239, "epss_percentile": 0.4689}, "CVE-2022-45185": {"epss_score": 0.00324, "epss_percentile": 0.54927}, "CVE-2022-45186": {"epss_score": 0.00156, "epss_percentile": 0.36917}, "CVE-2022-45188": {"epss_score": 0.00059, "epss_percentile": 0.18615}, "CVE-2022-45190": {"epss_score": 9e-05, "epss_percentile": 0.0063}, "CVE-2022-45191": {"epss_score": 0.00028, "epss_percentile": 0.07307}, "CVE-2022-45192": {"epss_score": 0.00041, "epss_percentile": 0.12386}, "CVE-2022-45193": {"epss_score": 0.00078, "epss_percentile": 0.23759}, "CVE-2022-45194": {"epss_score": 0.00206, "epss_percentile": 0.43}, "CVE-2022-45195": {"epss_score": 0.00159, "epss_percentile": 0.37393}, "CVE-2022-45196": {"epss_score": 0.00266, "epss_percentile": 0.49859}, "CVE-2022-45197": {"epss_score": 0.0012, "epss_percentile": 0.31742}, "CVE-2022-45198": {"epss_score": 0.00192, "epss_percentile": 0.41356}, "CVE-2022-45199": {"epss_score": 0.00122, "epss_percentile": 0.32114}, "CVE-2022-45202": {"epss_score": 0.00059, "epss_percentile": 0.18644}, "CVE-2022-45204": {"epss_score": 0.00132, "epss_percentile": 0.33509}, "CVE-2022-45205": {"epss_score": 0.00345, "epss_percentile": 0.56577}, "CVE-2022-45206": {"epss_score": 0.00271, "epss_percentile": 0.50276}, "CVE-2022-45207": {"epss_score": 0.00978, "epss_percentile": 0.76244}, "CVE-2022-45208": {"epss_score": 0.00181, "epss_percentile": 0.40077}, "CVE-2022-45210": {"epss_score": 0.00181, "epss_percentile": 0.40077}, "CVE-2022-45213": {"epss_score": 0.0034, "epss_percentile": 0.56222}, "CVE-2022-45214": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-45215": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-45217": {"epss_score": 0.00296, "epss_percentile": 0.52623}, "CVE-2022-45218": {"epss_score": 0.00253, "epss_percentile": 0.48458}, "CVE-2022-45221": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-45223": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-45224": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2022-45225": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-45227": {"epss_score": 0.00279, "epss_percentile": 0.50977}, "CVE-2022-45228": {"epss_score": 0.00104, "epss_percentile": 0.29172}, "CVE-2022-45269": {"epss_score": 0.27373, "epss_percentile": 0.96241}, "CVE-2022-45275": {"epss_score": 0.0225, "epss_percentile": 0.84157}, "CVE-2022-45276": {"epss_score": 0.01517, "epss_percentile": 0.80805}, "CVE-2022-45278": {"epss_score": 0.00226, "epss_percentile": 0.45359}, "CVE-2022-45280": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-45283": {"epss_score": 0.00041, "epss_percentile": 0.12396}, "CVE-2022-45285": {"epss_score": 0.00124, "epss_percentile": 0.32386}, "CVE-2022-45287": {"epss_score": 0.00102, "epss_percentile": 0.28896}, "CVE-2022-45290": {"epss_score": 0.0063, "epss_percentile": 0.69699}, "CVE-2022-45291": {"epss_score": 0.01122, "epss_percentile": 0.77786}, "CVE-2022-45292": {"epss_score": 0.00319, "epss_percentile": 0.54528}, "CVE-2022-45297": {"epss_score": 0.00299, "epss_percentile": 0.52901}, "CVE-2022-45299": {"epss_score": 0.02364, "epss_percentile": 0.84509}, "CVE-2022-45301": {"epss_score": 0.0013, "epss_percentile": 0.33298}, "CVE-2022-45304": {"epss_score": 0.0013, "epss_percentile": 0.33298}, "CVE-2022-45305": {"epss_score": 0.00114, "epss_percentile": 0.30756}, "CVE-2022-45306": {"epss_score": 0.00114, "epss_percentile": 0.30756}, "CVE-2022-45307": {"epss_score": 0.00114, "epss_percentile": 0.30756}, "CVE-2022-45313": {"epss_score": 0.07298, "epss_percentile": 0.91391}, "CVE-2022-45315": {"epss_score": 0.02194, "epss_percentile": 0.8395}, "CVE-2022-45320": {"epss_score": 0.00309, "epss_percentile": 0.53706}, "CVE-2022-45326": {"epss_score": 0.0056, "epss_percentile": 0.6763}, "CVE-2022-45328": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-45329": {"epss_score": 0.00251, "epss_percentile": 0.48283}, "CVE-2022-45330": {"epss_score": 0.00267, "epss_percentile": 0.49965}, "CVE-2022-45331": {"epss_score": 0.00267, "epss_percentile": 0.49965}, "CVE-2022-45332": {"epss_score": 0.00052, "epss_percentile": 0.16388}, "CVE-2022-45337": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45338": {"epss_score": 0.00134, "epss_percentile": 0.33765}, "CVE-2022-45343": {"epss_score": 0.00051, "epss_percentile": 0.16246}, "CVE-2022-45347": {"epss_score": 0.00122, "epss_percentile": 0.32076}, "CVE-2022-45348": {"epss_score": 0.00692, "epss_percentile": 0.71305}, "CVE-2022-45349": {"epss_score": 0.00064, "epss_percentile": 0.20316}, "CVE-2022-45350": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-45351": {"epss_score": 0.00046, "epss_percentile": 0.1439}, "CVE-2022-45352": {"epss_score": 0.00045, "epss_percentile": 0.14058}, "CVE-2022-45353": {"epss_score": 0.00266, "epss_percentile": 0.49869}, "CVE-2022-45354": {"epss_score": 0.88324, "epss_percentile": 0.99466}, "CVE-2022-45355": {"epss_score": 0.00347, "epss_percentile": 0.56755}, "CVE-2022-45356": {"epss_score": 0.0009, "epss_percentile": 0.26121}, "CVE-2022-45357": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-45358": {"epss_score": 0.00137, "epss_percentile": 0.34216}, "CVE-2022-45359": {"epss_score": 0.11988, "epss_percentile": 0.93538}, "CVE-2022-45360": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-45361": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-45362": {"epss_score": 0.16747, "epss_percentile": 0.94726}, "CVE-2022-45363": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-45364": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-45365": {"epss_score": 0.1672, "epss_percentile": 0.94721}, "CVE-2022-45366": {"epss_score": 0.00077, "epss_percentile": 0.2331}, "CVE-2022-45367": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-45368": {"epss_score": 0.00843, "epss_percentile": 0.74255}, "CVE-2022-45369": {"epss_score": 0.00178, "epss_percentile": 0.39722}, "CVE-2022-45370": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-45371": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-45372": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2022-45373": {"epss_score": 0.00224, "epss_percentile": 0.45011}, "CVE-2022-45374": {"epss_score": 0.00957, "epss_percentile": 0.75939}, "CVE-2022-45375": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-45376": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-45377": {"epss_score": 0.0018, "epss_percentile": 0.39875}, "CVE-2022-45378": {"epss_score": 0.04512, "epss_percentile": 0.88782}, "CVE-2022-45379": {"epss_score": 0.00319, "epss_percentile": 0.54528}, "CVE-2022-45380": {"epss_score": 0.01854, "epss_percentile": 0.82552}, "CVE-2022-45381": {"epss_score": 0.00224, "epss_percentile": 0.45014}, "CVE-2022-45382": {"epss_score": 0.08977, "epss_percentile": 0.92348}, "CVE-2022-45383": {"epss_score": 0.00752, "epss_percentile": 0.72664}, "CVE-2022-45384": {"epss_score": 0.00752, "epss_percentile": 0.72664}, "CVE-2022-45385": {"epss_score": 0.01956, "epss_percentile": 0.83037}, "CVE-2022-45386": {"epss_score": 0.01707, "epss_percentile": 0.81858}, "CVE-2022-45387": {"epss_score": 0.11715, "epss_percentile": 0.93458}, "CVE-2022-45388": {"epss_score": 0.00415, "epss_percentile": 0.61148}, "CVE-2022-45389": {"epss_score": 0.01956, "epss_percentile": 0.83037}, "CVE-2022-45390": {"epss_score": 0.00718, "epss_percentile": 0.71925}, "CVE-2022-45391": {"epss_score": 0.00071, "epss_percentile": 0.22229}, "CVE-2022-45392": {"epss_score": 0.00555, "epss_percentile": 0.67466}, "CVE-2022-45393": {"epss_score": 0.00101, "epss_percentile": 0.28709}, "CVE-2022-45394": {"epss_score": 0.00529, "epss_percentile": 0.66599}, "CVE-2022-45395": {"epss_score": 0.04514, "epss_percentile": 0.88788}, "CVE-2022-45396": {"epss_score": 0.03906, "epss_percentile": 0.87927}, "CVE-2022-45397": {"epss_score": 0.03906, "epss_percentile": 0.87927}, "CVE-2022-45398": {"epss_score": 0.00048, "epss_percentile": 0.15276}, "CVE-2022-45399": {"epss_score": 0.00529, "epss_percentile": 0.66599}, "CVE-2022-45400": {"epss_score": 0.04514, "epss_percentile": 0.88788}, "CVE-2022-45401": {"epss_score": 0.08977, "epss_percentile": 0.92348}, "CVE-2022-45402": {"epss_score": 0.05788, "epss_percentile": 0.90211}, "CVE-2022-45403": {"epss_score": 0.00131, "epss_percentile": 0.33377}, "CVE-2022-45404": {"epss_score": 0.00109, "epss_percentile": 0.29925}, "CVE-2022-45405": {"epss_score": 0.00124, "epss_percentile": 0.32344}, "CVE-2022-45406": {"epss_score": 0.00302, "epss_percentile": 0.53168}, "CVE-2022-45407": {"epss_score": 0.00413, "epss_percentile": 0.61001}, "CVE-2022-45408": {"epss_score": 0.00122, "epss_percentile": 0.32064}, "CVE-2022-45409": {"epss_score": 0.00186, "epss_percentile": 0.40614}, "CVE-2022-45410": {"epss_score": 0.0011, "epss_percentile": 0.30149}, "CVE-2022-45411": {"epss_score": 0.00159, "epss_percentile": 0.37419}, "CVE-2022-45412": {"epss_score": 0.0015, "epss_percentile": 0.36151}, "CVE-2022-45413": {"epss_score": 0.00169, "epss_percentile": 0.38564}, "CVE-2022-45414": {"epss_score": 0.00173, "epss_percentile": 0.3907}, "CVE-2022-45415": {"epss_score": 0.00072, "epss_percentile": 0.22347}, "CVE-2022-45416": {"epss_score": 0.00171, "epss_percentile": 0.38834}, "CVE-2022-45417": {"epss_score": 0.00139, "epss_percentile": 0.34658}, "CVE-2022-45418": {"epss_score": 0.00126, "epss_percentile": 0.32688}, "CVE-2022-45419": {"epss_score": 0.00087, "epss_percentile": 0.25451}, "CVE-2022-45420": {"epss_score": 0.00099, "epss_percentile": 0.27843}, "CVE-2022-45421": {"epss_score": 0.0017, "epss_percentile": 0.38708}, "CVE-2022-45422": {"epss_score": 0.0005, "epss_percentile": 0.15717}, "CVE-2022-45423": {"epss_score": 0.00133, "epss_percentile": 0.33699}, "CVE-2022-45424": {"epss_score": 0.00101, "epss_percentile": 0.287}, "CVE-2022-45425": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2022-45426": {"epss_score": 0.001, "epss_percentile": 0.28444}, "CVE-2022-45427": {"epss_score": 0.00182, "epss_percentile": 0.40222}, "CVE-2022-45428": {"epss_score": 0.00081, "epss_percentile": 0.24291}, "CVE-2022-45429": {"epss_score": 0.00276, "epss_percentile": 0.50734}, "CVE-2022-45430": {"epss_score": 0.00101, "epss_percentile": 0.28577}, "CVE-2022-45431": {"epss_score": 0.00182, "epss_percentile": 0.4024}, "CVE-2022-45432": {"epss_score": 0.00101, "epss_percentile": 0.287}, "CVE-2022-45433": {"epss_score": 0.00101, "epss_percentile": 0.287}, "CVE-2022-45434": {"epss_score": 0.00213, "epss_percentile": 0.43885}, "CVE-2022-45435": {"epss_score": 0.00143, "epss_percentile": 0.35108}, "CVE-2022-45436": {"epss_score": 0.00958, "epss_percentile": 0.75943}, "CVE-2022-45437": {"epss_score": 0.0044, "epss_percentile": 0.62635}, "CVE-2022-45438": {"epss_score": 0.00308, "epss_percentile": 0.53633}, "CVE-2022-45439": {"epss_score": 0.00091, "epss_percentile": 0.26197}, "CVE-2022-45440": {"epss_score": 0.00044, "epss_percentile": 0.13457}, "CVE-2022-45441": {"epss_score": 0.00974, "epss_percentile": 0.76192}, "CVE-2022-45442": {"epss_score": 0.00279, "epss_percentile": 0.50974}, "CVE-2022-45444": {"epss_score": 0.00372, "epss_percentile": 0.58464}, "CVE-2022-45447": {"epss_score": 0.00236, "epss_percentile": 0.46434}, "CVE-2022-45448": {"epss_score": 0.00063, "epss_percentile": 0.19805}, "CVE-2022-45449": {"epss_score": 0.00774, "epss_percentile": 0.73069}, "CVE-2022-45450": {"epss_score": 0.00123, "epss_percentile": 0.32232}, "CVE-2022-45451": {"epss_score": 0.00234, "epss_percentile": 0.46087}, "CVE-2022-45452": {"epss_score": 0.00028, "epss_percentile": 0.07355}, "CVE-2022-45453": {"epss_score": 0.00082, "epss_percentile": 0.24443}, "CVE-2022-45454": {"epss_score": 0.00138, "epss_percentile": 0.34463}, "CVE-2022-45455": {"epss_score": 0.00071, "epss_percentile": 0.22081}, "CVE-2022-45456": {"epss_score": 0.00038, "epss_percentile": 0.1131}, "CVE-2022-45457": {"epss_score": 0.00123, "epss_percentile": 0.32232}, "CVE-2022-45458": {"epss_score": 0.00123, "epss_percentile": 0.32232}, "CVE-2022-45459": {"epss_score": 0.00088, "epss_percentile": 0.25638}, "CVE-2022-45460": {"epss_score": 0.54009, "epss_percentile": 0.97907}, "CVE-2022-45461": {"epss_score": 0.01003, "epss_percentile": 0.76516}, "CVE-2022-45462": {"epss_score": 0.21258, "epss_percentile": 0.95489}, "CVE-2022-45468": {"epss_score": 0.00147, "epss_percentile": 0.35708}, "CVE-2022-45469": {"epss_score": 0.00056, "epss_percentile": 0.17756}, "CVE-2022-45470": {"epss_score": 0.00241, "epss_percentile": 0.47274}, "CVE-2022-45471": {"epss_score": 5e-05, "epss_percentile": 0.00206}, "CVE-2022-45472": {"epss_score": 0.01135, "epss_percentile": 0.77897}, "CVE-2022-45473": {"epss_score": 0.00049, "epss_percentile": 0.15358}, "CVE-2022-45474": {"epss_score": 0.00497, "epss_percentile": 0.65204}, "CVE-2022-45475": {"epss_score": 0.00923, "epss_percentile": 0.75499}, "CVE-2022-45476": {"epss_score": 0.00898, "epss_percentile": 0.75147}, "CVE-2022-45477": {"epss_score": 0.09535, "epss_percentile": 0.92589}, "CVE-2022-45478": {"epss_score": 0.00085, "epss_percentile": 0.25129}, "CVE-2022-45479": {"epss_score": 0.03552, "epss_percentile": 0.87344}, "CVE-2022-45480": {"epss_score": 0.00148, "epss_percentile": 0.35853}, "CVE-2022-45481": {"epss_score": 0.02647, "epss_percentile": 0.85332}, "CVE-2022-45482": {"epss_score": 0.01856, "epss_percentile": 0.82571}, "CVE-2022-45483": {"epss_score": 0.00148, "epss_percentile": 0.35853}, "CVE-2022-45484": {"epss_score": 0.00059, "epss_percentile": 0.18677}, "CVE-2022-45491": {"epss_score": 0.00054, "epss_percentile": 0.17176}, "CVE-2022-45492": {"epss_score": 0.0005, "epss_percentile": 0.15857}, "CVE-2022-45493": {"epss_score": 0.00054, "epss_percentile": 0.17176}, "CVE-2022-45494": {"epss_score": 0.00056, "epss_percentile": 0.17801}, "CVE-2022-45496": {"epss_score": 0.00128, "epss_percentile": 0.33004}, "CVE-2022-45497": {"epss_score": 0.18362, "epss_percentile": 0.95005}, "CVE-2022-45498": {"epss_score": 0.01241, "epss_percentile": 0.78813}, "CVE-2022-45499": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45501": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45503": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45504": {"epss_score": 0.09118, "epss_percentile": 0.92407}, "CVE-2022-45505": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45506": {"epss_score": 0.18362, "epss_percentile": 0.95005}, "CVE-2022-45507": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45508": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45509": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45510": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45511": {"epss_score": 0.00388, "epss_percentile": 0.59366}, "CVE-2022-45512": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45513": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45514": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45515": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45516": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45517": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45518": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45519": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45520": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45521": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45522": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45523": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45524": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45525": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45526": {"epss_score": 0.0036, "epss_percentile": 0.57657}, "CVE-2022-45527": {"epss_score": 0.00387, "epss_percentile": 0.59313}, "CVE-2022-45529": {"epss_score": 0.00277, "epss_percentile": 0.50793}, "CVE-2022-45535": {"epss_score": 0.00277, "epss_percentile": 0.50793}, "CVE-2022-45536": {"epss_score": 0.00102, "epss_percentile": 0.28872}, "CVE-2022-45537": {"epss_score": 0.00166, "epss_percentile": 0.38235}, "CVE-2022-45538": {"epss_score": 0.00166, "epss_percentile": 0.38235}, "CVE-2022-45539": {"epss_score": 0.00152, "epss_percentile": 0.36448}, "CVE-2022-45540": {"epss_score": 0.00152, "epss_percentile": 0.36448}, "CVE-2022-45541": {"epss_score": 0.0018, "epss_percentile": 0.39882}, "CVE-2022-45542": {"epss_score": 0.00099, "epss_percentile": 0.28337}, "CVE-2022-45543": {"epss_score": 0.00169, "epss_percentile": 0.38647}, "CVE-2022-45544": {"epss_score": 0.01051, "epss_percentile": 0.77081}, "CVE-2022-45546": {"epss_score": 0.0006, "epss_percentile": 0.19076}, "CVE-2022-45548": {"epss_score": 0.0039, "epss_percentile": 0.59528}, "CVE-2022-45550": {"epss_score": 0.03165, "epss_percentile": 0.86539}, "CVE-2022-45551": {"epss_score": 0.10804, "epss_percentile": 0.93108}, "CVE-2022-45552": {"epss_score": 0.00174, "epss_percentile": 0.39175}, "CVE-2022-45553": {"epss_score": 0.00508, "epss_percentile": 0.65706}, "CVE-2022-45557": {"epss_score": 0.00116, "epss_percentile": 0.31126}, "CVE-2022-45558": {"epss_score": 0.00116, "epss_percentile": 0.31126}, "CVE-2022-45562": {"epss_score": 0.00249, "epss_percentile": 0.48022}, "CVE-2022-45564": {"epss_score": 0.00174, "epss_percentile": 0.39258}, "CVE-2022-45582": {"epss_score": 0.00286, "epss_percentile": 0.51747}, "CVE-2022-45586": {"epss_score": 0.00044, "epss_percentile": 0.13438}, "CVE-2022-45587": {"epss_score": 0.00044, "epss_percentile": 0.13438}, "CVE-2022-45588": {"epss_score": 0.00055, "epss_percentile": 0.17657}, "CVE-2022-45589": {"epss_score": 0.00232, "epss_percentile": 0.459}, "CVE-2022-45597": {"epss_score": 0.00211, "epss_percentile": 0.43664}, "CVE-2022-45598": {"epss_score": 0.00252, "epss_percentile": 0.48361}, "CVE-2022-45599": {"epss_score": 0.00647, "epss_percentile": 0.70203}, "CVE-2022-45600": {"epss_score": 0.10399, "epss_percentile": 0.92975}, "CVE-2022-45608": {"epss_score": 0.00078, "epss_percentile": 0.23767}, "CVE-2022-45611": {"epss_score": 0.00162, "epss_percentile": 0.37619}, "CVE-2022-45613": {"epss_score": 0.00106, "epss_percentile": 0.29529}, "CVE-2022-45634": {"epss_score": 0.00168, "epss_percentile": 0.38499}, "CVE-2022-45635": {"epss_score": 0.0034, "epss_percentile": 0.56216}, "CVE-2022-45636": {"epss_score": 0.00153, "epss_percentile": 0.36626}, "CVE-2022-45637": {"epss_score": 0.00328, "epss_percentile": 0.55296}, "CVE-2022-45639": {"epss_score": 0.00816, "epss_percentile": 0.73802}, "CVE-2022-45640": {"epss_score": 0.00154, "epss_percentile": 0.36678}, "CVE-2022-45641": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45643": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45644": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45645": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45646": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45647": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45648": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45649": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45650": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45651": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45652": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45653": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45654": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45655": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45656": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45657": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45658": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45659": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45660": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45661": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45663": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45664": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45665": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45666": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45667": {"epss_score": 0.00096, "epss_percentile": 0.27318}, "CVE-2022-45668": {"epss_score": 0.00096, "epss_percentile": 0.27318}, "CVE-2022-45669": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45670": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45671": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45672": {"epss_score": 0.02318, "epss_percentile": 0.84362}, "CVE-2022-45673": {"epss_score": 0.00096, "epss_percentile": 0.27318}, "CVE-2022-45674": {"epss_score": 0.00096, "epss_percentile": 0.27318}, "CVE-2022-45677": {"epss_score": 0.0015, "epss_percentile": 0.36057}, "CVE-2022-45685": {"epss_score": 0.00131, "epss_percentile": 0.33403}, "CVE-2022-45688": {"epss_score": 0.00911, "epss_percentile": 0.75325}, "CVE-2022-45689": {"epss_score": 0.00266, "epss_percentile": 0.49859}, "CVE-2022-45690": {"epss_score": 0.00253, "epss_percentile": 0.4849}, "CVE-2022-45693": {"epss_score": 0.00131, "epss_percentile": 0.33403}, "CVE-2022-45697": {"epss_score": 0.00045, "epss_percentile": 0.13699}, "CVE-2022-45699": {"epss_score": 0.90791, "epss_percentile": 0.996}, "CVE-2022-45701": {"epss_score": 0.55394, "epss_percentile": 0.97975}, "CVE-2022-45703": {"epss_score": 0.00024, "epss_percentile": 0.05971}, "CVE-2022-45706": {"epss_score": 0.00392, "epss_percentile": 0.59699}, "CVE-2022-45707": {"epss_score": 0.00392, "epss_percentile": 0.59699}, "CVE-2022-45708": {"epss_score": 0.00392, "epss_percentile": 0.59699}, "CVE-2022-45709": {"epss_score": 0.0532, "epss_percentile": 0.89728}, "CVE-2022-45710": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-45711": {"epss_score": 0.20316, "epss_percentile": 0.95324}, "CVE-2022-45712": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-45714": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-45715": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-45716": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-45717": {"epss_score": 0.0532, "epss_percentile": 0.89728}, "CVE-2022-45718": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-45719": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-45720": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-45721": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-45722": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2022-45724": {"epss_score": 0.00103, "epss_percentile": 0.28978}, "CVE-2022-45725": {"epss_score": 0.03312, "epss_percentile": 0.86893}, "CVE-2022-45728": {"epss_score": 0.00162, "epss_percentile": 0.37623}, "CVE-2022-45729": {"epss_score": 0.00162, "epss_percentile": 0.37623}, "CVE-2022-45730": {"epss_score": 0.00321, "epss_percentile": 0.54674}, "CVE-2022-45748": {"epss_score": 0.00117, "epss_percentile": 0.31308}, "CVE-2022-45755": {"epss_score": 0.00789, "epss_percentile": 0.73355}, "CVE-2022-45756": {"epss_score": 0.00314, "epss_percentile": 0.54127}, "CVE-2022-45758": {"epss_score": 0.00295, "epss_percentile": 0.52478}, "CVE-2022-45759": {"epss_score": 0.0039, "epss_percentile": 0.59528}, "CVE-2022-45760": {"epss_score": 0.00312, "epss_percentile": 0.53956}, "CVE-2022-45766": {"epss_score": 0.00449, "epss_percentile": 0.6305}, "CVE-2022-45768": {"epss_score": 0.09959, "epss_percentile": 0.92793}, "CVE-2022-45769": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-45770": {"epss_score": 0.00616, "epss_percentile": 0.69337}, "CVE-2022-45771": {"epss_score": 0.3031, "epss_percentile": 0.96527}, "CVE-2022-45778": {"epss_score": 0.00344, "epss_percentile": 0.56545}, "CVE-2022-45781": {"epss_score": 0.00282, "epss_percentile": 0.51271}, "CVE-2022-45782": {"epss_score": 0.00289, "epss_percentile": 0.51995}, "CVE-2022-45783": {"epss_score": 0.18691, "epss_percentile": 0.95054}, "CVE-2022-45786": {"epss_score": 0.00083, "epss_percentile": 0.24734}, "CVE-2022-45787": {"epss_score": 7e-05, "epss_percentile": 0.00442}, "CVE-2022-45788": {"epss_score": 0.00418, "epss_percentile": 0.61269}, "CVE-2022-45789": {"epss_score": 0.00075, "epss_percentile": 0.23017}, "CVE-2022-45790": {"epss_score": 0.00389, "epss_percentile": 0.59451}, "CVE-2022-45792": {"epss_score": 0.00064, "epss_percentile": 0.20325}, "CVE-2022-45793": {"epss_score": 0.00035, "epss_percentile": 0.10131}, "CVE-2022-45794": {"epss_score": 0.00164, "epss_percentile": 0.37989}, "CVE-2022-45796": {"epss_score": 0.03176, "epss_percentile": 0.86571}, "CVE-2022-45797": {"epss_score": 0.00389, "epss_percentile": 0.59409}, "CVE-2022-45798": {"epss_score": 0.0016, "epss_percentile": 0.37484}, "CVE-2022-45801": {"epss_score": 0.00065, "epss_percentile": 0.20479}, "CVE-2022-45802": {"epss_score": 0.00066, "epss_percentile": 0.20762}, "CVE-2022-45803": {"epss_score": 0.00298, "epss_percentile": 0.5282}, "CVE-2022-45804": {"epss_score": 0.00054, "epss_percentile": 0.17304}, "CVE-2022-45805": {"epss_score": 0.29641, "epss_percentile": 0.96463}, "CVE-2022-45806": {"epss_score": 0.00163, "epss_percentile": 0.37814}, "CVE-2022-45807": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2022-45808": {"epss_score": 0.78812, "epss_percentile": 0.99004}, "CVE-2022-45809": {"epss_score": 0.0007, "epss_percentile": 0.21822}, "CVE-2022-45810": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-45811": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2022-45812": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2022-45814": {"epss_score": 0.00116, "epss_percentile": 0.31042}, "CVE-2022-45815": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-45816": {"epss_score": 0.00255, "epss_percentile": 0.48633}, "CVE-2022-45817": {"epss_score": 0.00116, "epss_percentile": 0.31042}, "CVE-2022-45818": {"epss_score": 0.00121, "epss_percentile": 0.3184}, "CVE-2022-45819": {"epss_score": 0.00076, "epss_percentile": 0.23247}, "CVE-2022-45820": {"epss_score": 0.00301, "epss_percentile": 0.52995}, "CVE-2022-45821": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2022-45822": {"epss_score": 0.00565, "epss_percentile": 0.67807}, "CVE-2022-45823": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2022-45824": {"epss_score": 0.00097, "epss_percentile": 0.27597}, "CVE-2022-45825": {"epss_score": 0.00141, "epss_percentile": 0.34834}, "CVE-2022-45826": {"epss_score": 0.00079, "epss_percentile": 0.24}, "CVE-2022-45827": {"epss_score": 0.00117, "epss_percentile": 0.31233}, "CVE-2022-45828": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-45829": {"epss_score": 0.00528, "epss_percentile": 0.6655}, "CVE-2022-45830": {"epss_score": 0.00283, "epss_percentile": 0.51402}, "CVE-2022-45831": {"epss_score": 0.00141, "epss_percentile": 0.34834}, "CVE-2022-45832": {"epss_score": 0.00456, "epss_percentile": 0.63337}, "CVE-2022-45833": {"epss_score": 0.00803, "epss_percentile": 0.73602}, "CVE-2022-45835": {"epss_score": 0.64289, "epss_percentile": 0.98372}, "CVE-2022-45836": {"epss_score": 0.00129, "epss_percentile": 0.33196}, "CVE-2022-45837": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2022-45838": {"epss_score": 0.00183, "epss_percentile": 0.40289}, "CVE-2022-45839": {"epss_score": 0.00171, "epss_percentile": 0.38768}, "CVE-2022-45840": {"epss_score": 0.00109, "epss_percentile": 0.29905}, "CVE-2022-45841": {"epss_score": 0.00075, "epss_percentile": 0.22984}, "CVE-2022-45842": {"epss_score": 0.00152, "epss_percentile": 0.36441}, "CVE-2022-45843": {"epss_score": 0.00186, "epss_percentile": 0.40592}, "CVE-2022-45845": {"epss_score": 0.00394, "epss_percentile": 0.5977}, "CVE-2022-45846": {"epss_score": 0.0009, "epss_percentile": 0.26136}, "CVE-2022-45847": {"epss_score": 0.002, "epss_percentile": 0.42198}, "CVE-2022-45848": {"epss_score": 0.00287, "epss_percentile": 0.5185}, "CVE-2022-45849": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2022-45850": {"epss_score": 0.002, "epss_percentile": 0.42198}, "CVE-2022-45851": {"epss_score": 0.00046, "epss_percentile": 0.1439}, "CVE-2022-45852": {"epss_score": 0.00502, "epss_percentile": 0.65369}, "CVE-2022-45853": {"epss_score": 0.0003, "epss_percentile": 0.08158}, "CVE-2022-45854": {"epss_score": 0.00066, "epss_percentile": 0.20876}, "CVE-2022-45855": {"epss_score": 0.00186, "epss_percentile": 0.40619}, "CVE-2022-45856": {"epss_score": 0.00135, "epss_percentile": 0.34052}, "CVE-2022-45857": {"epss_score": 0.00331, "epss_percentile": 0.55528}, "CVE-2022-45858": {"epss_score": 0.00079, "epss_percentile": 0.23823}, "CVE-2022-45859": {"epss_score": 0.00028, "epss_percentile": 0.07562}, "CVE-2022-45860": {"epss_score": 0.00129, "epss_percentile": 0.33179}, "CVE-2022-45861": {"epss_score": 0.01014, "epss_percentile": 0.76648}, "CVE-2022-45862": {"epss_score": 0.00213, "epss_percentile": 0.43893}, "CVE-2022-45866": {"epss_score": 0.00628, "epss_percentile": 0.69658}, "CVE-2022-45867": {"epss_score": 0.00984, "epss_percentile": 0.76314}, "CVE-2022-45868": {"epss_score": 0.00112, "epss_percentile": 0.30419}, "CVE-2022-45869": {"epss_score": 0.00018, "epss_percentile": 0.03925}, "CVE-2022-45871": {"epss_score": 0.00304, "epss_percentile": 0.53286}, "CVE-2022-45872": {"epss_score": 0.01903, "epss_percentile": 0.82786}, "CVE-2022-45873": {"epss_score": 0.00027, "epss_percentile": 0.07153}, "CVE-2022-45874": {"epss_score": 0.00024, "epss_percentile": 0.05889}, "CVE-2022-45875": {"epss_score": 0.03659, "epss_percentile": 0.87526}, "CVE-2022-45876": {"epss_score": 0.04597, "epss_percentile": 0.889}, "CVE-2022-45877": {"epss_score": 0.00033, "epss_percentile": 0.09245}, "CVE-2022-45884": {"epss_score": 0.00016, "epss_percentile": 0.02703}, "CVE-2022-45885": {"epss_score": 0.00016, "epss_percentile": 0.02703}, "CVE-2022-45886": {"epss_score": 0.00019, "epss_percentile": 0.04409}, "CVE-2022-45887": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2022-45888": {"epss_score": 0.00015, "epss_percentile": 0.02411}, "CVE-2022-45889": {"epss_score": 0.01177, "epss_percentile": 0.7828}, "CVE-2022-45890": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-45891": {"epss_score": 0.00267, "epss_percentile": 0.49973}, "CVE-2022-45892": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-45893": {"epss_score": 0.00318, "epss_percentile": 0.54443}, "CVE-2022-45894": {"epss_score": 0.00711, "epss_percentile": 0.71728}, "CVE-2022-45895": {"epss_score": 0.00337, "epss_percentile": 0.56048}, "CVE-2022-45896": {"epss_score": 0.03001, "epss_percentile": 0.86165}, "CVE-2022-45897": {"epss_score": 0.00154, "epss_percentile": 0.36704}, "CVE-2022-45907": {"epss_score": 0.00186, "epss_percentile": 0.4069}, "CVE-2022-45908": {"epss_score": 0.01055, "epss_percentile": 0.7712}, "CVE-2022-45909": {"epss_score": 0.00525, "epss_percentile": 0.66381}, "CVE-2022-45910": {"epss_score": 0.04382, "epss_percentile": 0.88625}, "CVE-2022-45911": {"epss_score": 0.00528, "epss_percentile": 0.66558}, "CVE-2022-45912": {"epss_score": 0.02388, "epss_percentile": 0.84589}, "CVE-2022-45913": {"epss_score": 0.00527, "epss_percentile": 0.66448}, "CVE-2022-45914": {"epss_score": 0.00298, "epss_percentile": 0.52787}, "CVE-2022-45915": {"epss_score": 0.06146, "epss_percentile": 0.90518}, "CVE-2022-45916": {"epss_score": 0.00653, "epss_percentile": 0.70338}, "CVE-2022-45917": {"epss_score": 0.35756, "epss_percentile": 0.96931}, "CVE-2022-45918": {"epss_score": 0.01114, "epss_percentile": 0.77704}, "CVE-2022-45919": {"epss_score": 0.00021, "epss_percentile": 0.04903}, "CVE-2022-45920": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2022-45921": {"epss_score": 0.00582, "epss_percentile": 0.6831}, "CVE-2022-45922": {"epss_score": 0.00266, "epss_percentile": 0.49925}, "CVE-2022-45923": {"epss_score": 0.00221, "epss_percentile": 0.44671}, "CVE-2022-45924": {"epss_score": 0.00118, "epss_percentile": 0.31447}, "CVE-2022-45925": {"epss_score": 0.04363, "epss_percentile": 0.88599}, "CVE-2022-45926": {"epss_score": 0.03175, "epss_percentile": 0.86567}, "CVE-2022-45927": {"epss_score": 0.00084, "epss_percentile": 0.24919}, "CVE-2022-45928": {"epss_score": 0.00403, "epss_percentile": 0.60356}, "CVE-2022-45929": {"epss_score": 0.00137, "epss_percentile": 0.34272}, "CVE-2022-45930": {"epss_score": 0.00193, "epss_percentile": 0.41487}, "CVE-2022-45931": {"epss_score": 0.0018, "epss_percentile": 0.39895}, "CVE-2022-45932": {"epss_score": 0.0018, "epss_percentile": 0.39895}, "CVE-2022-45933": {"epss_score": 0.93266, "epss_percentile": 0.99791}, "CVE-2022-45934": {"epss_score": 0.00409, "epss_percentile": 0.60722}, "CVE-2022-45935": {"epss_score": 0.00028, "epss_percentile": 0.07576}, "CVE-2022-45936": {"epss_score": 0.00207, "epss_percentile": 0.43087}, "CVE-2022-45937": {"epss_score": 0.00306, "epss_percentile": 0.53402}, "CVE-2022-45938": {"epss_score": 0.19521, "epss_percentile": 0.95199}, "CVE-2022-45939": {"epss_score": 0.00045, "epss_percentile": 0.13723}, "CVE-2022-45942": {"epss_score": 0.1362, "epss_percentile": 0.94016}, "CVE-2022-45956": {"epss_score": 0.00348, "epss_percentile": 0.56824}, "CVE-2022-45957": {"epss_score": 0.02319, "epss_percentile": 0.84363}, "CVE-2022-45962": {"epss_score": 0.00281, "epss_percentile": 0.51196}, "CVE-2022-45963": {"epss_score": 0.00344, "epss_percentile": 0.56545}, "CVE-2022-45966": {"epss_score": 0.00344, "epss_percentile": 0.56528}, "CVE-2022-45968": {"epss_score": 0.00419, "epss_percentile": 0.61384}, "CVE-2022-45969": {"epss_score": 0.01207, "epss_percentile": 0.78524}, "CVE-2022-45970": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-45977": {"epss_score": 0.06425, "epss_percentile": 0.90753}, "CVE-2022-45979": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-45980": {"epss_score": 0.01318, "epss_percentile": 0.7942}, "CVE-2022-45982": {"epss_score": 0.01189, "epss_percentile": 0.78372}, "CVE-2022-45988": {"epss_score": 0.00594, "epss_percentile": 0.68664}, "CVE-2022-45990": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-45995": {"epss_score": 0.01054, "epss_percentile": 0.77108}, "CVE-2022-45996": {"epss_score": 0.11479, "epss_percentile": 0.93379}, "CVE-2022-45997": {"epss_score": 0.00452, "epss_percentile": 0.6318}, "CVE-2022-46020": {"epss_score": 0.86493, "epss_percentile": 0.99385}, "CVE-2022-46021": {"epss_score": 0.00078, "epss_percentile": 0.23591}, "CVE-2022-46025": {"epss_score": 0.0172, "epss_percentile": 0.81931}, "CVE-2022-46047": {"epss_score": 0.00277, "epss_percentile": 0.50793}, "CVE-2022-46051": {"epss_score": 0.00276, "epss_percentile": 0.50742}, "CVE-2022-46058": {"epss_score": 0.0035, "epss_percentile": 0.56966}, "CVE-2022-46059": {"epss_score": 0.00037, "epss_percentile": 0.10982}, "CVE-2022-46061": {"epss_score": 0.00136, "epss_percentile": 0.34098}, "CVE-2022-46062": {"epss_score": 0.00026, "epss_percentile": 0.06579}, "CVE-2022-46070": {"epss_score": 0.00098, "epss_percentile": 0.27682}, "CVE-2022-46071": {"epss_score": 0.74602, "epss_percentile": 0.98809}, "CVE-2022-46072": {"epss_score": 0.0039, "epss_percentile": 0.59521}, "CVE-2022-46073": {"epss_score": 0.29531, "epss_percentile": 0.96451}, "CVE-2022-46074": {"epss_score": 0.00398, "epss_percentile": 0.60079}, "CVE-2022-46076": {"epss_score": 0.01267, "epss_percentile": 0.79022}, "CVE-2022-46080": {"epss_score": 0.16557, "epss_percentile": 0.9469}, "CVE-2022-46081": {"epss_score": 0.003, "epss_percentile": 0.52917}, "CVE-2022-46087": {"epss_score": 0.00599, "epss_percentile": 0.68791}, "CVE-2022-46088": {"epss_score": 0.0009, "epss_percentile": 0.26055}, "CVE-2022-46089": {"epss_score": 0.0013, "epss_percentile": 0.33276}, "CVE-2022-46091": {"epss_score": 0.00154, "epss_percentile": 0.36665}, "CVE-2022-46093": {"epss_score": 0.00128, "epss_percentile": 0.33034}, "CVE-2022-46095": {"epss_score": 0.0034, "epss_percentile": 0.56222}, "CVE-2022-46096": {"epss_score": 0.00301, "epss_percentile": 0.53079}, "CVE-2022-46101": {"epss_score": 0.00552, "epss_percentile": 0.67382}, "CVE-2022-46102": {"epss_score": 0.00344, "epss_percentile": 0.56528}, "CVE-2022-46109": {"epss_score": 0.00178, "epss_percentile": 0.39646}, "CVE-2022-46117": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-46118": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-46119": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-46120": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-46121": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-46122": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-46123": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-46124": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-46125": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-46126": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-46127": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2022-46128": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-46135": {"epss_score": 0.00279, "epss_percentile": 0.50935}, "CVE-2022-46137": {"epss_score": 0.01478, "epss_percentile": 0.80549}, "CVE-2022-46139": {"epss_score": 0.00119, "epss_percentile": 0.31636}, "CVE-2022-46140": {"epss_score": 0.00105, "epss_percentile": 0.29257}, "CVE-2022-46141": {"epss_score": 0.00012, "epss_percentile": 0.01326}, "CVE-2022-46142": {"epss_score": 0.00171, "epss_percentile": 0.38825}, "CVE-2022-46143": {"epss_score": 0.00409, "epss_percentile": 0.60786}, "CVE-2022-46144": {"epss_score": 0.00727, "epss_percentile": 0.72091}, "CVE-2022-46145": {"epss_score": 0.024, "epss_percentile": 0.84638}, "CVE-2022-46146": {"epss_score": 0.00128, "epss_percentile": 0.33046}, "CVE-2022-46147": {"epss_score": 0.0055, "epss_percentile": 0.67342}, "CVE-2022-46148": {"epss_score": 0.00398, "epss_percentile": 0.60088}, "CVE-2022-46149": {"epss_score": 0.00146, "epss_percentile": 0.35583}, "CVE-2022-46150": {"epss_score": 0.00249, "epss_percentile": 0.48051}, "CVE-2022-46151": {"epss_score": 0.00273, "epss_percentile": 0.50462}, "CVE-2022-46152": {"epss_score": 0.00389, "epss_percentile": 0.59401}, "CVE-2022-46153": {"epss_score": 0.00404, "epss_percentile": 0.60409}, "CVE-2022-46154": {"epss_score": 0.02641, "epss_percentile": 0.85305}, "CVE-2022-46155": {"epss_score": 0.00196, "epss_percentile": 0.4175}, "CVE-2022-46156": {"epss_score": 0.00361, "epss_percentile": 0.57733}, "CVE-2022-46157": {"epss_score": 0.01508, "epss_percentile": 0.80757}, "CVE-2022-46158": {"epss_score": 0.0007, "epss_percentile": 0.21697}, "CVE-2022-46159": {"epss_score": 0.0036, "epss_percentile": 0.57683}, "CVE-2022-46160": {"epss_score": 0.00148, "epss_percentile": 0.35893}, "CVE-2022-46161": {"epss_score": 0.01459, "epss_percentile": 0.80412}, "CVE-2022-46162": {"epss_score": 0.01151, "epss_percentile": 0.78043}, "CVE-2022-46163": {"epss_score": 0.00543, "epss_percentile": 0.67116}, "CVE-2022-46164": {"epss_score": 0.61589, "epss_percentile": 0.98253}, "CVE-2022-46165": {"epss_score": 0.0051, "epss_percentile": 0.65769}, "CVE-2022-46166": {"epss_score": 0.24272, "epss_percentile": 0.95898}, "CVE-2022-46167": {"epss_score": 0.00413, "epss_percentile": 0.61012}, "CVE-2022-46168": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-46169": {"epss_score": 0.94468, "epss_percentile": 0.99996}, "CVE-2022-46170": {"epss_score": 0.00311, "epss_percentile": 0.53814}, "CVE-2022-46171": {"epss_score": 0.00509, "epss_percentile": 0.6574}, "CVE-2022-46172": {"epss_score": 0.00263, "epss_percentile": 0.49499}, "CVE-2022-46173": {"epss_score": 0.00491, "epss_percentile": 0.64955}, "CVE-2022-46174": {"epss_score": 0.00048, "epss_percentile": 0.15178}, "CVE-2022-46175": {"epss_score": 0.54083, "epss_percentile": 0.9791}, "CVE-2022-46176": {"epss_score": 0.0012, "epss_percentile": 0.31748}, "CVE-2022-46177": {"epss_score": 0.00396, "epss_percentile": 0.59898}, "CVE-2022-46178": {"epss_score": 0.00578, "epss_percentile": 0.68196}, "CVE-2022-46179": {"epss_score": 0.00053, "epss_percentile": 0.16848}, "CVE-2022-46180": {"epss_score": 0.00406, "epss_percentile": 0.60519}, "CVE-2022-46181": {"epss_score": 0.00475, "epss_percentile": 0.64178}, "CVE-2022-46255": {"epss_score": 0.04718, "epss_percentile": 0.89044}, "CVE-2022-46256": {"epss_score": 0.08294, "epss_percentile": 0.91975}, "CVE-2022-46257": {"epss_score": 0.00068, "epss_percentile": 0.21256}, "CVE-2022-46258": {"epss_score": 0.0007, "epss_percentile": 0.21649}, "CVE-2022-46265": {"epss_score": 0.00631, "epss_percentile": 0.69724}, "CVE-2022-46279": {"epss_score": 0.00081, "epss_percentile": 0.24221}, "CVE-2022-46280": {"epss_score": 0.00344, "epss_percentile": 0.56507}, "CVE-2022-46282": {"epss_score": 0.00111, "epss_percentile": 0.30312}, "CVE-2022-46285": {"epss_score": 0.00082, "epss_percentile": 0.244}, "CVE-2022-46286": {"epss_score": 0.00147, "epss_percentile": 0.35708}, "CVE-2022-46287": {"epss_score": 0.00414, "epss_percentile": 0.61033}, "CVE-2022-46288": {"epss_score": 0.00243, "epss_percentile": 0.47427}, "CVE-2022-46289": {"epss_score": 0.0012, "epss_percentile": 0.31713}, "CVE-2022-46290": {"epss_score": 0.0012, "epss_percentile": 0.31713}, "CVE-2022-46291": {"epss_score": 0.0013, "epss_percentile": 0.33246}, "CVE-2022-46292": {"epss_score": 0.0013, "epss_percentile": 0.33246}, "CVE-2022-46293": {"epss_score": 0.00185, "epss_percentile": 0.40462}, "CVE-2022-46294": {"epss_score": 0.00185, "epss_percentile": 0.40462}, "CVE-2022-46295": {"epss_score": 0.00185, "epss_percentile": 0.40462}, "CVE-2022-46298": {"epss_score": 0.00044, "epss_percentile": 0.13422}, "CVE-2022-46299": {"epss_score": 0.00096, "epss_percentile": 0.2726}, "CVE-2022-46300": {"epss_score": 0.04205, "epss_percentile": 0.88394}, "CVE-2022-46301": {"epss_score": 0.00046, "epss_percentile": 0.14191}, "CVE-2022-46302": {"epss_score": 0.00871, "epss_percentile": 0.74718}, "CVE-2022-46303": {"epss_score": 0.003, "epss_percentile": 0.52987}, "CVE-2022-46304": {"epss_score": 0.02121, "epss_percentile": 0.83679}, "CVE-2022-46305": {"epss_score": 0.00102, "epss_percentile": 0.28826}, "CVE-2022-46306": {"epss_score": 0.03307, "epss_percentile": 0.86878}, "CVE-2022-46307": {"epss_score": 0.00263, "epss_percentile": 0.49502}, "CVE-2022-46308": {"epss_score": 0.00263, "epss_percentile": 0.49502}, "CVE-2022-46309": {"epss_score": 0.00507, "epss_percentile": 0.6566}, "CVE-2022-46310": {"epss_score": 0.00151, "epss_percentile": 0.36212}, "CVE-2022-46311": {"epss_score": 0.00116, "epss_percentile": 0.3115}, "CVE-2022-46312": {"epss_score": 0.00082, "epss_percentile": 0.24453}, "CVE-2022-46313": {"epss_score": 0.00137, "epss_percentile": 0.34285}, "CVE-2022-46314": {"epss_score": 0.00214, "epss_percentile": 0.43948}, "CVE-2022-46315": {"epss_score": 0.003, "epss_percentile": 0.52988}, "CVE-2022-46316": {"epss_score": 0.00206, "epss_percentile": 0.42928}, "CVE-2022-46317": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-46318": {"epss_score": 0.00101, "epss_percentile": 0.28652}, "CVE-2022-46319": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-46320": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-46321": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-46322": {"epss_score": 0.00191, "epss_percentile": 0.4116}, "CVE-2022-46323": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-46324": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-46325": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-46326": {"epss_score": 0.00247, "epss_percentile": 0.47883}, "CVE-2022-46327": {"epss_score": 0.002, "epss_percentile": 0.42243}, "CVE-2022-46328": {"epss_score": 0.00131, "epss_percentile": 0.33441}, "CVE-2022-46329": {"epss_score": 0.00029, "epss_percentile": 0.07603}, "CVE-2022-46330": {"epss_score": 0.0017, "epss_percentile": 0.38684}, "CVE-2022-46331": {"epss_score": 0.00147, "epss_percentile": 0.35778}, "CVE-2022-46332": {"epss_score": 0.0082, "epss_percentile": 0.73892}, "CVE-2022-46333": {"epss_score": 0.01659, "epss_percentile": 0.81613}, "CVE-2022-46334": {"epss_score": 0.00034, "epss_percentile": 0.09795}, "CVE-2022-46337": {"epss_score": 0.00047, "epss_percentile": 0.14501}, "CVE-2022-46338": {"epss_score": 0.00401, "epss_percentile": 0.60246}, "CVE-2022-46340": {"epss_score": 0.0113, "epss_percentile": 0.77842}, "CVE-2022-46341": {"epss_score": 0.01109, "epss_percentile": 0.77654}, "CVE-2022-46342": {"epss_score": 0.00139, "epss_percentile": 0.34532}, "CVE-2022-46343": {"epss_score": 0.01109, "epss_percentile": 0.77654}, "CVE-2022-46344": {"epss_score": 0.00908, "epss_percentile": 0.75278}, "CVE-2022-46345": {"epss_score": 0.00112, "epss_percentile": 0.30569}, "CVE-2022-46346": {"epss_score": 0.00112, "epss_percentile": 0.30569}, "CVE-2022-46347": {"epss_score": 0.00124, "epss_percentile": 0.32381}, "CVE-2022-46348": {"epss_score": 0.00124, "epss_percentile": 0.32381}, "CVE-2022-46349": {"epss_score": 0.00162, "epss_percentile": 0.37691}, "CVE-2022-46350": {"epss_score": 0.00669, "epss_percentile": 0.70759}, "CVE-2022-46351": {"epss_score": 0.00131, "epss_percentile": 0.33346}, "CVE-2022-46352": {"epss_score": 0.00536, "epss_percentile": 0.66882}, "CVE-2022-46353": {"epss_score": 0.01978, "epss_percentile": 0.83129}, "CVE-2022-46354": {"epss_score": 0.00306, "epss_percentile": 0.53463}, "CVE-2022-46355": {"epss_score": 0.00399, "epss_percentile": 0.60142}, "CVE-2022-46356": {"epss_score": 0.00135, "epss_percentile": 0.33949}, "CVE-2022-46357": {"epss_score": 0.00135, "epss_percentile": 0.33949}, "CVE-2022-46358": {"epss_score": 0.00135, "epss_percentile": 0.33949}, "CVE-2022-46359": {"epss_score": 0.00135, "epss_percentile": 0.33949}, "CVE-2022-46360": {"epss_score": 0.00089, "epss_percentile": 0.25922}, "CVE-2022-46361": {"epss_score": 0.00031, "epss_percentile": 0.08714}, "CVE-2022-46363": {"epss_score": 0.00089, "epss_percentile": 0.25839}, "CVE-2022-46364": {"epss_score": 0.00135, "epss_percentile": 0.33997}, "CVE-2022-46365": {"epss_score": 0.00041, "epss_percentile": 0.12246}, "CVE-2022-46366": {"epss_score": 0.025, "epss_percentile": 0.84918}, "CVE-2022-46367": {"epss_score": 0.00062, "epss_percentile": 0.19578}, "CVE-2022-46368": {"epss_score": 0.00071, "epss_percentile": 0.22044}, "CVE-2022-46369": {"epss_score": 0.00073, "epss_percentile": 0.22479}, "CVE-2022-46370": {"epss_score": 0.00028, "epss_percentile": 0.07273}, "CVE-2022-46371": {"epss_score": 0.00112, "epss_percentile": 0.30543}, "CVE-2022-46372": {"epss_score": 0.00081, "epss_percentile": 0.24371}, "CVE-2022-46377": {"epss_score": 0.00505, "epss_percentile": 0.65599}, "CVE-2022-46378": {"epss_score": 0.00168, "epss_percentile": 0.38445}, "CVE-2022-46381": {"epss_score": 0.8313, "epss_percentile": 0.99233}, "CVE-2022-46382": {"epss_score": 0.00227, "epss_percentile": 0.45365}, "CVE-2022-46383": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2022-46387": {"epss_score": 0.00156, "epss_percentile": 0.36889}, "CVE-2022-46389": {"epss_score": 0.00394, "epss_percentile": 0.59772}, "CVE-2022-46391": {"epss_score": 0.00349, "epss_percentile": 0.56903}, "CVE-2022-46392": {"epss_score": 0.002, "epss_percentile": 0.42223}, "CVE-2022-46393": {"epss_score": 0.00809, "epss_percentile": 0.73708}, "CVE-2022-46394": {"epss_score": 0.00238, "epss_percentile": 0.46791}, "CVE-2022-46395": {"epss_score": 0.43733, "epss_percentile": 0.97401}, "CVE-2022-46396": {"epss_score": 0.00087, "epss_percentile": 0.25557}, "CVE-2022-46397": {"epss_score": 0.00259, "epss_percentile": 0.49064}, "CVE-2022-46399": {"epss_score": 0.00213, "epss_percentile": 0.43925}, "CVE-2022-46400": {"epss_score": 0.00107, "epss_percentile": 0.29724}, "CVE-2022-46401": {"epss_score": 0.0012, "epss_percentile": 0.31758}, "CVE-2022-46402": {"epss_score": 0.00064, "epss_percentile": 0.20285}, "CVE-2022-46403": {"epss_score": 0.00456, "epss_percentile": 0.6333}, "CVE-2022-46404": {"epss_score": 0.10914, "epss_percentile": 0.93156}, "CVE-2022-46405": {"epss_score": 0.00722, "epss_percentile": 0.72001}, "CVE-2022-46407": {"epss_score": 0.00096, "epss_percentile": 0.27415}, "CVE-2022-46408": {"epss_score": 0.0111, "epss_percentile": 0.77655}, "CVE-2022-46410": {"epss_score": 0.00335, "epss_percentile": 0.55838}, "CVE-2022-46411": {"epss_score": 0.00335, "epss_percentile": 0.55838}, "CVE-2022-46412": {"epss_score": 0.00393, "epss_percentile": 0.59731}, "CVE-2022-46413": {"epss_score": 0.02161, "epss_percentile": 0.83827}, "CVE-2022-46414": {"epss_score": 0.01728, "epss_percentile": 0.81976}, "CVE-2022-46415": {"epss_score": 0.00311, "epss_percentile": 0.53814}, "CVE-2022-46416": {"epss_score": 0.00371, "epss_percentile": 0.58372}, "CVE-2022-46421": {"epss_score": 0.34379, "epss_percentile": 0.96845}, "CVE-2022-46422": {"epss_score": 0.00118, "epss_percentile": 0.31434}, "CVE-2022-46423": {"epss_score": 0.00455, "epss_percentile": 0.63295}, "CVE-2022-46424": {"epss_score": 0.01143, "epss_percentile": 0.77982}, "CVE-2022-46428": {"epss_score": 0.00183, "epss_percentile": 0.40287}, "CVE-2022-46430": {"epss_score": 0.00183, "epss_percentile": 0.40287}, "CVE-2022-46432": {"epss_score": 0.00143, "epss_percentile": 0.35168}, "CVE-2022-46434": {"epss_score": 0.004, "epss_percentile": 0.60147}, "CVE-2022-46435": {"epss_score": 0.00568, "epss_percentile": 0.67887}, "CVE-2022-46438": {"epss_score": 0.00106, "epss_percentile": 0.29529}, "CVE-2022-46440": {"epss_score": 0.00027, "epss_percentile": 0.07083}, "CVE-2022-46442": {"epss_score": 0.00339, "epss_percentile": 0.56199}, "CVE-2022-46443": {"epss_score": 0.81782, "epss_percentile": 0.99156}, "CVE-2022-46449": {"epss_score": 0.00117, "epss_percentile": 0.3123}, "CVE-2022-46456": {"epss_score": 0.00058, "epss_percentile": 0.18525}, "CVE-2022-46457": {"epss_score": 0.00065, "epss_percentile": 0.20566}, "CVE-2022-46463": {"epss_score": 0.72526, "epss_percentile": 0.98715}, "CVE-2022-46471": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-46472": {"epss_score": 0.00086, "epss_percentile": 0.25424}, "CVE-2022-46475": {"epss_score": 0.1108, "epss_percentile": 0.93212}, "CVE-2022-46476": {"epss_score": 0.56804, "epss_percentile": 0.98037}, "CVE-2022-46478": {"epss_score": 0.00127, "epss_percentile": 0.32802}, "CVE-2022-46480": {"epss_score": 0.00109, "epss_percentile": 0.2994}, "CVE-2022-46484": {"epss_score": 0.00273, "epss_percentile": 0.50463}, "CVE-2022-46485": {"epss_score": 0.01608, "epss_percentile": 0.81313}, "CVE-2022-46486": {"epss_score": 0.00038, "epss_percentile": 0.11326}, "CVE-2022-46487": {"epss_score": 0.00168, "epss_percentile": 0.38405}, "CVE-2022-46489": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2022-46490": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2022-46491": {"epss_score": 0.00096, "epss_percentile": 0.27308}, "CVE-2022-46492": {"epss_score": 0.00288, "epss_percentile": 0.519}, "CVE-2022-46493": {"epss_score": 0.00344, "epss_percentile": 0.56528}, "CVE-2022-46496": {"epss_score": 0.00094, "epss_percentile": 0.26976}, "CVE-2022-46497": {"epss_score": 0.00134, "epss_percentile": 0.3384}, "CVE-2022-46498": {"epss_score": 0.00056, "epss_percentile": 0.17683}, "CVE-2022-46499": {"epss_score": 0.00158, "epss_percentile": 0.37192}, "CVE-2022-46501": {"epss_score": 0.0007, "epss_percentile": 0.21974}, "CVE-2022-46502": {"epss_score": 0.03193, "epss_percentile": 0.86606}, "CVE-2022-46503": {"epss_score": 0.00106, "epss_percentile": 0.29529}, "CVE-2022-46505": {"epss_score": 0.00672, "epss_percentile": 0.7082}, "CVE-2022-46527": {"epss_score": 0.00052, "epss_percentile": 0.16547}, "CVE-2022-46530": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46531": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46532": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46533": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46534": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46535": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46536": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46537": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46538": {"epss_score": 0.18362, "epss_percentile": 0.95005}, "CVE-2022-46539": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46540": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46541": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46542": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46543": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46544": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46545": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46546": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46547": {"epss_score": 0.00436, "epss_percentile": 0.62432}, "CVE-2022-46548": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46549": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46550": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46551": {"epss_score": 0.00336, "epss_percentile": 0.55983}, "CVE-2022-46552": {"epss_score": 0.20679, "epss_percentile": 0.954}, "CVE-2022-46560": {"epss_score": 0.02362, "epss_percentile": 0.84501}, "CVE-2022-46561": {"epss_score": 0.02362, "epss_percentile": 0.84501}, "CVE-2022-46562": {"epss_score": 0.0144, "epss_percentile": 0.80297}, "CVE-2022-46563": {"epss_score": 0.01974, "epss_percentile": 0.83115}, "CVE-2022-46566": {"epss_score": 0.01974, "epss_percentile": 0.83115}, "CVE-2022-46568": {"epss_score": 0.01974, "epss_percentile": 0.83115}, "CVE-2022-46569": {"epss_score": 0.0144, "epss_percentile": 0.80297}, "CVE-2022-46570": {"epss_score": 0.0158, "epss_percentile": 0.81135}, "CVE-2022-46580": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46581": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46582": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46583": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46584": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46585": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46586": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46588": {"epss_score": 0.00499, "epss_percentile": 0.65271}, "CVE-2022-46589": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46590": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46591": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46592": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46593": {"epss_score": 0.00499, "epss_percentile": 0.65271}, "CVE-2022-46594": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46596": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46597": {"epss_score": 0.04123, "epss_percentile": 0.88285}, "CVE-2022-46598": {"epss_score": 0.05193, "epss_percentile": 0.89598}, "CVE-2022-46599": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46600": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46601": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-46603": {"epss_score": 0.0017, "epss_percentile": 0.38727}, "CVE-2022-46604": {"epss_score": 0.37331, "epss_percentile": 0.97034}, "CVE-2022-46609": {"epss_score": 0.00827, "epss_percentile": 0.73988}, "CVE-2022-46610": {"epss_score": 0.03682, "epss_percentile": 0.8756}, "CVE-2022-46622": {"epss_score": 0.00162, "epss_percentile": 0.37623}, "CVE-2022-46623": {"epss_score": 0.00101, "epss_percentile": 0.28574}, "CVE-2022-46624": {"epss_score": 0.00321, "epss_percentile": 0.54674}, "CVE-2022-46631": {"epss_score": 0.04318, "epss_percentile": 0.8854}, "CVE-2022-46634": {"epss_score": 0.04318, "epss_percentile": 0.8854}, "CVE-2022-46637": {"epss_score": 0.00361, "epss_percentile": 0.57708}, "CVE-2022-46639": {"epss_score": 0.00274, "epss_percentile": 0.50543}, "CVE-2022-46640": {"epss_score": 0.03762, "epss_percentile": 0.87689}, "CVE-2022-46641": {"epss_score": 0.02724, "epss_percentile": 0.85523}, "CVE-2022-46642": {"epss_score": 0.02724, "epss_percentile": 0.85523}, "CVE-2022-46645": {"epss_score": 0.0007, "epss_percentile": 0.2187}, "CVE-2022-46646": {"epss_score": 0.001, "epss_percentile": 0.28547}, "CVE-2022-46647": {"epss_score": 0.001, "epss_percentile": 0.28547}, "CVE-2022-46648": {"epss_score": 0.02403, "epss_percentile": 0.84644}, "CVE-2022-46649": {"epss_score": 0.00122, "epss_percentile": 0.32023}, "CVE-2022-46650": {"epss_score": 0.00219, "epss_percentile": 0.44477}, "CVE-2022-46651": {"epss_score": 0.00109, "epss_percentile": 0.29918}, "CVE-2022-46656": {"epss_score": 0.00062, "epss_percentile": 0.19558}, "CVE-2022-46658": {"epss_score": 0.00476, "epss_percentile": 0.64274}, "CVE-2022-46660": {"epss_score": 0.00282, "epss_percentile": 0.51238}, "CVE-2022-46662": {"epss_score": 0.00072, "epss_percentile": 0.22346}, "CVE-2022-46663": {"epss_score": 0.00101, "epss_percentile": 0.28698}, "CVE-2022-46664": {"epss_score": 0.00207, "epss_percentile": 0.43087}, "CVE-2022-46670": {"epss_score": 0.00035, "epss_percentile": 0.09999}, "CVE-2022-46675": {"epss_score": 0.0041, "epss_percentile": 0.60813}, "CVE-2022-46676": {"epss_score": 0.00129, "epss_percentile": 0.33115}, "CVE-2022-46677": {"epss_score": 0.00129, "epss_percentile": 0.33115}, "CVE-2022-46678": {"epss_score": 0.00129, "epss_percentile": 0.3315}, "CVE-2022-46679": {"epss_score": 0.0054, "epss_percentile": 0.67021}, "CVE-2022-46680": {"epss_score": 0.00117, "epss_percentile": 0.31225}, "CVE-2022-46682": {"epss_score": 0.00563, "epss_percentile": 0.6774}, "CVE-2022-46683": {"epss_score": 0.00707, "epss_percentile": 0.71651}, "CVE-2022-46684": {"epss_score": 0.09268, "epss_percentile": 0.92472}, "CVE-2022-46685": {"epss_score": 0.00168, "epss_percentile": 0.38415}, "CVE-2022-46686": {"epss_score": 0.09268, "epss_percentile": 0.92472}, "CVE-2022-46687": {"epss_score": 0.09268, "epss_percentile": 0.92472}, "CVE-2022-46688": {"epss_score": 0.00137, "epss_percentile": 0.34225}, "CVE-2022-46689": {"epss_score": 0.84546, "epss_percentile": 0.99294}, "CVE-2022-46690": {"epss_score": 0.00115, "epss_percentile": 0.3102}, "CVE-2022-46691": {"epss_score": 0.00408, "epss_percentile": 0.60679}, "CVE-2022-46692": {"epss_score": 0.00014, "epss_percentile": 0.01818}, "CVE-2022-46693": {"epss_score": 0.0023, "epss_percentile": 0.45664}, "CVE-2022-46694": {"epss_score": 0.002, "epss_percentile": 0.42263}, "CVE-2022-46695": {"epss_score": 0.00416, "epss_percentile": 0.61182}, "CVE-2022-46696": {"epss_score": 0.00319, "epss_percentile": 0.54533}, "CVE-2022-46697": {"epss_score": 0.00161, "epss_percentile": 0.37601}, "CVE-2022-46698": {"epss_score": 0.00969, "epss_percentile": 0.76103}, "CVE-2022-46699": {"epss_score": 0.00689, "epss_percentile": 0.7122}, "CVE-2022-46700": {"epss_score": 0.00689, "epss_percentile": 0.7122}, "CVE-2022-46701": {"epss_score": 0.00128, "epss_percentile": 0.3299}, "CVE-2022-46702": {"epss_score": 0.00142, "epss_percentile": 0.35026}, "CVE-2022-46703": {"epss_score": 0.00053, "epss_percentile": 0.16714}, "CVE-2022-46704": {"epss_score": 0.00049, "epss_percentile": 0.15505}, "CVE-2022-46705": {"epss_score": 0.00101, "epss_percentile": 0.28666}, "CVE-2022-46706": {"epss_score": 0.00031, "epss_percentile": 0.08338}, "CVE-2022-46709": {"epss_score": 0.00287, "epss_percentile": 0.51863}, "CVE-2022-46710": {"epss_score": 0.00102, "epss_percentile": 0.28821}, "CVE-2022-46712": {"epss_score": 0.00072, "epss_percentile": 0.22317}, "CVE-2022-46713": {"epss_score": 0.0002, "epss_percentile": 0.04623}, "CVE-2022-46715": {"epss_score": 0.00015, "epss_percentile": 0.02249}, "CVE-2022-46716": {"epss_score": 0.00176, "epss_percentile": 0.39472}, "CVE-2022-46717": {"epss_score": 0.00067, "epss_percentile": 0.21182}, "CVE-2022-46718": {"epss_score": 0.0004, "epss_percentile": 0.11949}, "CVE-2022-46720": {"epss_score": 0.00069, "epss_percentile": 0.21561}, "CVE-2022-46721": {"epss_score": 0.00106, "epss_percentile": 0.29501}, "CVE-2022-46722": {"epss_score": 0.00046, "epss_percentile": 0.14159}, "CVE-2022-46723": {"epss_score": 0.00752, "epss_percentile": 0.72657}, "CVE-2022-46724": {"epss_score": 0.00069, "epss_percentile": 0.21607}, "CVE-2022-46725": {"epss_score": 0.00065, "epss_percentile": 0.20473}, "CVE-2022-46732": {"epss_score": 0.00446, "epss_percentile": 0.62893}, "CVE-2022-46733": {"epss_score": 0.00061, "epss_percentile": 0.19511}, "CVE-2022-46738": {"epss_score": 0.00046, "epss_percentile": 0.14318}, "CVE-2022-46740": {"epss_score": 0.0005, "epss_percentile": 0.1574}, "CVE-2022-46741": {"epss_score": 0.00209, "epss_percentile": 0.43316}, "CVE-2022-46742": {"epss_score": 0.0107, "epss_percentile": 0.7726}, "CVE-2022-46751": {"epss_score": 0.00168, "epss_percentile": 0.3847}, "CVE-2022-46752": {"epss_score": 0.00123, "epss_percentile": 0.32215}, "CVE-2022-46754": {"epss_score": 0.00189, "epss_percentile": 0.40949}, "CVE-2022-46755": {"epss_score": 0.00129, "epss_percentile": 0.3315}, "CVE-2022-46756": {"epss_score": 0.00062, "epss_percentile": 0.19554}, "CVE-2022-46761": {"epss_score": 0.00101, "epss_percentile": 0.2862}, "CVE-2022-46762": {"epss_score": 0.00089, "epss_percentile": 0.25888}, "CVE-2022-46763": {"epss_score": 0.0138, "epss_percentile": 0.7986}, "CVE-2022-46764": {"epss_score": 0.27859, "epss_percentile": 0.96288}, "CVE-2022-46768": {"epss_score": 0.03607, "epss_percentile": 0.87419}, "CVE-2022-46769": {"epss_score": 0.00249, "epss_percentile": 0.48041}, "CVE-2022-46770": {"epss_score": 0.16824, "epss_percentile": 0.94735}, "CVE-2022-46771": {"epss_score": 0.00438, "epss_percentile": 0.62556}, "CVE-2022-46773": {"epss_score": 0.00023, "epss_percentile": 0.05427}, "CVE-2022-46774": {"epss_score": 0.00036, "epss_percentile": 0.10252}, "CVE-2022-46781": {"epss_score": 0.00074, "epss_percentile": 0.22711}, "CVE-2022-46782": {"epss_score": 0.00061, "epss_percentile": 0.19478}, "CVE-2022-46783": {"epss_score": 0.001, "epss_percentile": 0.28471}, "CVE-2022-46784": {"epss_score": 0.00241, "epss_percentile": 0.47296}, "CVE-2022-46785": {"epss_score": 0.00549, "epss_percentile": 0.6732}, "CVE-2022-46786": {"epss_score": 0.00458, "epss_percentile": 0.63415}, "CVE-2022-46792": {"epss_score": 0.00504, "epss_percentile": 0.65486}, "CVE-2022-46793": {"epss_score": 0.00054, "epss_percentile": 0.17115}, "CVE-2022-46794": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-46795": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2022-46796": {"epss_score": 0.00109, "epss_percentile": 0.29905}, "CVE-2022-46797": {"epss_score": 0.00053, "epss_percentile": 0.16982}, "CVE-2022-46798": {"epss_score": 0.00054, "epss_percentile": 0.17304}, "CVE-2022-46799": {"epss_score": 0.00091, "epss_percentile": 0.26188}, "CVE-2022-46800": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-46801": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-46802": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-46803": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-46804": {"epss_score": 0.00692, "epss_percentile": 0.71305}, "CVE-2022-46805": {"epss_score": 0.00054, "epss_percentile": 0.17304}, "CVE-2022-46806": {"epss_score": 0.00053, "epss_percentile": 0.16982}, "CVE-2022-46807": {"epss_score": 0.0013, "epss_percentile": 0.33331}, "CVE-2022-46808": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2022-46809": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-46810": {"epss_score": 0.00047, "epss_percentile": 0.14636}, "CVE-2022-46811": {"epss_score": 0.0013, "epss_percentile": 0.33331}, "CVE-2022-46812": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-46813": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-46814": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-46815": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2022-46816": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-46817": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-46818": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2022-46819": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-46820": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-46821": {"epss_score": 0.00692, "epss_percentile": 0.71305}, "CVE-2022-46822": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2022-46823": {"epss_score": 0.00511, "epss_percentile": 0.65838}, "CVE-2022-46824": {"epss_score": 2e-05, "epss_percentile": 0.00027}, "CVE-2022-46825": {"epss_score": 1e-05, "epss_percentile": 0.00013}, "CVE-2022-46826": {"epss_score": 2e-05, "epss_percentile": 0.00021}, "CVE-2022-46827": {"epss_score": 2e-05, "epss_percentile": 0.00025}, "CVE-2022-46828": {"epss_score": 3e-05, "epss_percentile": 0.00082}, "CVE-2022-46829": {"epss_score": 3e-05, "epss_percentile": 0.00095}, "CVE-2022-46830": {"epss_score": 4e-05, "epss_percentile": 0.00167}, "CVE-2022-46831": {"epss_score": 7e-05, "epss_percentile": 0.00356}, "CVE-2022-46832": {"epss_score": 0.00068, "epss_percentile": 0.21256}, "CVE-2022-46833": {"epss_score": 0.00068, "epss_percentile": 0.21256}, "CVE-2022-46834": {"epss_score": 0.00068, "epss_percentile": 0.21256}, "CVE-2022-46835": {"epss_score": 0.00738, "epss_percentile": 0.72338}, "CVE-2022-46836": {"epss_score": 0.00796, "epss_percentile": 0.73478}, "CVE-2022-46838": {"epss_score": 0.00264, "epss_percentile": 0.49706}, "CVE-2022-46839": {"epss_score": 0.00313, "epss_percentile": 0.54071}, "CVE-2022-46840": {"epss_score": 0.0012, "epss_percentile": 0.31729}, "CVE-2022-46841": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2022-46842": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2022-46843": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2022-46844": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2022-46845": {"epss_score": 0.0006, "epss_percentile": 0.19182}, "CVE-2022-46846": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2022-46848": {"epss_score": 0.00106, "epss_percentile": 0.29429}, "CVE-2022-46849": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2022-46850": {"epss_score": 0.00061, "epss_percentile": 0.19447}, "CVE-2022-46851": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2022-46852": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-46853": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2022-46854": {"epss_score": 0.00054, "epss_percentile": 0.17115}, "CVE-2022-46855": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2022-46856": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-46857": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-46858": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2022-46859": {"epss_score": 0.00275, "epss_percentile": 0.50673}, "CVE-2022-46860": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2022-46861": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-46862": {"epss_score": 0.00154, "epss_percentile": 0.36684}, "CVE-2022-46863": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2022-46864": {"epss_score": 0.00091, "epss_percentile": 0.26188}, "CVE-2022-46865": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-46866": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-46867": {"epss_score": 0.00074, "epss_percentile": 0.22876}, "CVE-2022-46868": {"epss_score": 0.00023, "epss_percentile": 0.05378}, "CVE-2022-46869": {"epss_score": 0.00051, "epss_percentile": 0.16318}, "CVE-2022-46870": {"epss_score": 0.1289, "epss_percentile": 0.93813}, "CVE-2022-46871": {"epss_score": 0.00802, "epss_percentile": 0.73592}, "CVE-2022-46872": {"epss_score": 0.00261, "epss_percentile": 0.49278}, "CVE-2022-46873": {"epss_score": 0.00442, "epss_percentile": 0.62739}, "CVE-2022-46874": {"epss_score": 0.00312, "epss_percentile": 0.53967}, "CVE-2022-46875": {"epss_score": 0.00117, "epss_percentile": 0.313}, "CVE-2022-46877": {"epss_score": 0.00416, "epss_percentile": 0.61188}, "CVE-2022-46878": {"epss_score": 0.00352, "epss_percentile": 0.57124}, "CVE-2022-46879": {"epss_score": 0.00436, "epss_percentile": 0.62386}, "CVE-2022-46880": {"epss_score": 0.00147, "epss_percentile": 0.35679}, "CVE-2022-46881": {"epss_score": 0.00198, "epss_percentile": 0.42083}, "CVE-2022-46882": {"epss_score": 0.00257, "epss_percentile": 0.48912}, "CVE-2022-46883": {"epss_score": 0.01167, "epss_percentile": 0.78189}, "CVE-2022-46884": {"epss_score": 0.00209, "epss_percentile": 0.43318}, "CVE-2022-46885": {"epss_score": 0.00479, "epss_percentile": 0.64438}, "CVE-2022-46886": {"epss_score": 0.00105, "epss_percentile": 0.29293}, "CVE-2022-46887": {"epss_score": 0.25937, "epss_percentile": 0.96095}, "CVE-2022-46888": {"epss_score": 0.16278, "epss_percentile": 0.9461}, "CVE-2022-46889": {"epss_score": 0.02281, "epss_percentile": 0.8425}, "CVE-2022-46890": {"epss_score": 0.00072, "epss_percentile": 0.22441}, "CVE-2022-46891": {"epss_score": 0.00263, "epss_percentile": 0.49506}, "CVE-2022-46892": {"epss_score": 0.00288, "epss_percentile": 0.51951}, "CVE-2022-46897": {"epss_score": 0.00046, "epss_percentile": 0.14161}, "CVE-2022-46898": {"epss_score": 0.00126, "epss_percentile": 0.32701}, "CVE-2022-46899": {"epss_score": 0.00056, "epss_percentile": 0.17894}, "CVE-2022-46900": {"epss_score": 0.00096, "epss_percentile": 0.2733}, "CVE-2022-46901": {"epss_score": 0.00096, "epss_percentile": 0.27369}, "CVE-2022-46902": {"epss_score": 0.00082, "epss_percentile": 0.24425}, "CVE-2022-46903": {"epss_score": 0.00629, "epss_percentile": 0.69672}, "CVE-2022-46904": {"epss_score": 0.00629, "epss_percentile": 0.69672}, "CVE-2022-46905": {"epss_score": 0.022, "epss_percentile": 0.83976}, "CVE-2022-46906": {"epss_score": 0.00629, "epss_percentile": 0.69672}, "CVE-2022-46907": {"epss_score": 0.03652, "epss_percentile": 0.8751}, "CVE-2022-46908": {"epss_score": 0.00121, "epss_percentile": 0.31957}, "CVE-2022-46910": {"epss_score": 0.00653, "epss_percentile": 0.70323}, "CVE-2022-46912": {"epss_score": 0.00653, "epss_percentile": 0.70323}, "CVE-2022-46914": {"epss_score": 0.00653, "epss_percentile": 0.70323}, "CVE-2022-46934": {"epss_score": 0.12872, "epss_percentile": 0.93807}, "CVE-2022-46945": {"epss_score": 0.00471, "epss_percentile": 0.64016}, "CVE-2022-46946": {"epss_score": 0.00086, "epss_percentile": 0.25424}, "CVE-2022-46947": {"epss_score": 0.00086, "epss_percentile": 0.25424}, "CVE-2022-46949": {"epss_score": 0.00086, "epss_percentile": 0.25424}, "CVE-2022-46950": {"epss_score": 0.00086, "epss_percentile": 0.25424}, "CVE-2022-46951": {"epss_score": 0.00086, "epss_percentile": 0.25424}, "CVE-2022-46952": {"epss_score": 0.00086, "epss_percentile": 0.25424}, "CVE-2022-46953": {"epss_score": 0.00086, "epss_percentile": 0.25424}, "CVE-2022-46954": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-46955": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-46956": {"epss_score": 0.00086, "epss_percentile": 0.25424}, "CVE-2022-46957": {"epss_score": 0.0034, "epss_percentile": 0.56222}, "CVE-2022-46959": {"epss_score": 0.00279, "epss_percentile": 0.5096}, "CVE-2022-46965": {"epss_score": 0.00098, "epss_percentile": 0.27703}, "CVE-2022-46966": {"epss_score": 0.00255, "epss_percentile": 0.48694}, "CVE-2022-46967": {"epss_score": 0.00853, "epss_percentile": 0.74436}, "CVE-2022-46968": {"epss_score": 0.00401, "epss_percentile": 0.60246}, "CVE-2022-46973": {"epss_score": 0.00303, "epss_percentile": 0.53208}, "CVE-2022-46996": {"epss_score": 0.0071, "epss_percentile": 0.7172}, "CVE-2022-46997": {"epss_score": 0.0071, "epss_percentile": 0.7172}, "CVE-2022-46998": {"epss_score": 0.00377, "epss_percentile": 0.58707}, "CVE-2022-46999": {"epss_score": 0.00312, "epss_percentile": 0.54008}, "CVE-2022-47002": {"epss_score": 0.69749, "epss_percentile": 0.98602}, "CVE-2022-47003": {"epss_score": 0.30275, "epss_percentile": 0.96524}, "CVE-2022-47007": {"epss_score": 9e-05, "epss_percentile": 0.00654}, "CVE-2022-47008": {"epss_score": 9e-05, "epss_percentile": 0.00654}, "CVE-2022-47010": {"epss_score": 9e-05, "epss_percentile": 0.00654}, "CVE-2022-47011": {"epss_score": 9e-05, "epss_percentile": 0.00654}, "CVE-2022-47012": {"epss_score": 0.00075, "epss_percentile": 0.22938}, "CVE-2022-47015": {"epss_score": 0.0018, "epss_percentile": 0.39885}, "CVE-2022-47021": {"epss_score": 0.00075, "epss_percentile": 0.23071}, "CVE-2022-47022": {"epss_score": 0.00042, "epss_percentile": 0.1271}, "CVE-2022-47024": {"epss_score": 0.00034, "epss_percentile": 0.09798}, "CVE-2022-47027": {"epss_score": 0.00557, "epss_percentile": 0.67542}, "CVE-2022-47028": {"epss_score": 0.00029, "epss_percentile": 0.07898}, "CVE-2022-47029": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2022-47034": {"epss_score": 0.00051, "epss_percentile": 0.16233}, "CVE-2022-47035": {"epss_score": 0.00395, "epss_percentile": 0.59835}, "CVE-2022-47036": {"epss_score": 0.00089, "epss_percentile": 0.25977}, "CVE-2022-47037": {"epss_score": 0.00085, "epss_percentile": 0.25124}, "CVE-2022-47040": {"epss_score": 0.00038, "epss_percentile": 0.11318}, "CVE-2022-47042": {"epss_score": 0.00292, "epss_percentile": 0.52261}, "CVE-2022-47052": {"epss_score": 0.00591, "epss_percentile": 0.6858}, "CVE-2022-47053": {"epss_score": 0.00701, "epss_percentile": 0.71493}, "CVE-2022-47065": {"epss_score": 0.0085, "epss_percentile": 0.74387}, "CVE-2022-47069": {"epss_score": 0.00038, "epss_percentile": 0.11332}, "CVE-2022-47070": {"epss_score": 0.00169, "epss_percentile": 0.38541}, "CVE-2022-47071": {"epss_score": 0.03546, "epss_percentile": 0.87328}, "CVE-2022-47072": {"epss_score": 0.00086, "epss_percentile": 0.25374}, "CVE-2022-47073": {"epss_score": 0.00229, "epss_percentile": 0.45613}, "CVE-2022-47075": {"epss_score": 0.92526, "epss_percentile": 0.99723}, "CVE-2022-47076": {"epss_score": 0.18292, "epss_percentile": 0.9499}, "CVE-2022-47083": {"epss_score": 0.03065, "epss_percentile": 0.86334}, "CVE-2022-47085": {"epss_score": 0.001, "epss_percentile": 0.28527}, "CVE-2022-47086": {"epss_score": 0.0003, "epss_percentile": 0.08065}, "CVE-2022-47087": {"epss_score": 0.0014, "epss_percentile": 0.34687}, "CVE-2022-47088": {"epss_score": 0.00134, "epss_percentile": 0.33758}, "CVE-2022-47089": {"epss_score": 0.00134, "epss_percentile": 0.33758}, "CVE-2022-47090": {"epss_score": 0.00035, "epss_percentile": 0.09921}, "CVE-2022-47091": {"epss_score": 0.0005, "epss_percentile": 0.15966}, "CVE-2022-47092": {"epss_score": 0.00132, "epss_percentile": 0.33509}, "CVE-2022-47093": {"epss_score": 0.00142, "epss_percentile": 0.35083}, "CVE-2022-47094": {"epss_score": 0.00037, "epss_percentile": 0.10681}, "CVE-2022-47095": {"epss_score": 0.00083, "epss_percentile": 0.24727}, "CVE-2022-47100": {"epss_score": 0.00226, "epss_percentile": 0.45275}, "CVE-2022-47102": {"epss_score": 0.00209, "epss_percentile": 0.43392}, "CVE-2022-47105": {"epss_score": 0.00445, "epss_percentile": 0.62854}, "CVE-2022-47111": {"epss_score": 0.00027, "epss_percentile": 0.07087}, "CVE-2022-47112": {"epss_score": 0.00027, "epss_percentile": 0.07087}, "CVE-2022-47115": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47116": {"epss_score": 0.00377, "epss_percentile": 0.58695}, "CVE-2022-47117": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47118": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47119": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47120": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47121": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47122": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47123": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47124": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47125": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47126": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47127": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47128": {"epss_score": 0.00395, "epss_percentile": 0.59829}, "CVE-2022-47129": {"epss_score": 0.02144, "epss_percentile": 0.8376}, "CVE-2022-47130": {"epss_score": 0.05539, "epss_percentile": 0.89976}, "CVE-2022-47131": {"epss_score": 0.00367, "epss_percentile": 0.58139}, "CVE-2022-47132": {"epss_score": 0.06043, "epss_percentile": 0.9043}, "CVE-2022-47134": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47135": {"epss_score": 0.00078, "epss_percentile": 0.23609}, "CVE-2022-47136": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47137": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-47138": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47139": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-47140": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2022-47141": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2022-47142": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2022-47143": {"epss_score": 0.00094, "epss_percentile": 0.26965}, "CVE-2022-47144": {"epss_score": 0.00047, "epss_percentile": 0.14636}, "CVE-2022-47145": {"epss_score": 0.00144, "epss_percentile": 0.35324}, "CVE-2022-47146": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2022-47147": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2022-47148": {"epss_score": 0.00089, "epss_percentile": 0.2588}, "CVE-2022-47149": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47151": {"epss_score": 0.00175, "epss_percentile": 0.39343}, "CVE-2022-47152": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-47153": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2022-47154": {"epss_score": 0.00094, "epss_percentile": 0.26965}, "CVE-2022-47155": {"epss_score": 0.00094, "epss_percentile": 0.26965}, "CVE-2022-47157": {"epss_score": 0.00054, "epss_percentile": 0.17052}, "CVE-2022-47158": {"epss_score": 0.00054, "epss_percentile": 0.17052}, "CVE-2022-47159": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47160": {"epss_score": 0.00791, "epss_percentile": 0.73382}, "CVE-2022-47161": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47162": {"epss_score": 0.00094, "epss_percentile": 0.26965}, "CVE-2022-47163": {"epss_score": 0.00094, "epss_percentile": 0.26965}, "CVE-2022-47164": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47165": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47166": {"epss_score": 0.00094, "epss_percentile": 0.26965}, "CVE-2022-47167": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2022-47168": {"epss_score": 0.0013, "epss_percentile": 0.33331}, "CVE-2022-47169": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47170": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2022-47171": {"epss_score": 0.0008, "epss_percentile": 0.24093}, "CVE-2022-47172": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47173": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2022-47174": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47175": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2022-47176": {"epss_score": 0.0013, "epss_percentile": 0.33331}, "CVE-2022-47177": {"epss_score": 0.00078, "epss_percentile": 0.23609}, "CVE-2022-47178": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47179": {"epss_score": 0.00116, "epss_percentile": 0.3116}, "CVE-2022-47180": {"epss_score": 0.00078, "epss_percentile": 0.23609}, "CVE-2022-47181": {"epss_score": 0.00264, "epss_percentile": 0.4972}, "CVE-2022-47182": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2022-47183": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2022-47184": {"epss_score": 0.00206, "epss_percentile": 0.43054}, "CVE-2022-47185": {"epss_score": 0.00232, "epss_percentile": 0.4593}, "CVE-2022-47186": {"epss_score": 0.00092, "epss_percentile": 0.26426}, "CVE-2022-47187": {"epss_score": 0.00113, "epss_percentile": 0.30673}, "CVE-2022-47188": {"epss_score": 0.00272, "epss_percentile": 0.50421}, "CVE-2022-47189": {"epss_score": 0.00226, "epss_percentile": 0.45301}, "CVE-2022-47190": {"epss_score": 0.00963, "epss_percentile": 0.76015}, "CVE-2022-47191": {"epss_score": 0.00122, "epss_percentile": 0.32124}, "CVE-2022-47192": {"epss_score": 0.00821, "epss_percentile": 0.739}, "CVE-2022-47194": {"epss_score": 0.00264, "epss_percentile": 0.49725}, "CVE-2022-47195": {"epss_score": 0.00164, "epss_percentile": 0.37871}, "CVE-2022-47196": {"epss_score": 0.00164, "epss_percentile": 0.37871}, "CVE-2022-47197": {"epss_score": 0.01108, "epss_percentile": 0.77641}, "CVE-2022-47208": {"epss_score": 0.00596, "epss_percentile": 0.68721}, "CVE-2022-47209": {"epss_score": 0.00192, "epss_percentile": 0.41291}, "CVE-2022-47210": {"epss_score": 0.00243, "epss_percentile": 0.4749}, "CVE-2022-47211": {"epss_score": 0.01462, "epss_percentile": 0.8044}, "CVE-2022-47212": {"epss_score": 0.01646, "epss_percentile": 0.81537}, "CVE-2022-47213": {"epss_score": 0.01598, "epss_percentile": 0.81246}, "CVE-2022-47311": {"epss_score": 0.00085, "epss_percentile": 0.25042}, "CVE-2022-47317": {"epss_score": 0.00097, "epss_percentile": 0.27455}, "CVE-2022-47318": {"epss_score": 0.007, "epss_percentile": 0.71469}, "CVE-2022-47320": {"epss_score": 0.00085, "epss_percentile": 0.25122}, "CVE-2022-47322": {"epss_score": 0.0002, "epss_percentile": 0.04466}, "CVE-2022-47323": {"epss_score": 0.00015, "epss_percentile": 0.02342}, "CVE-2022-47324": {"epss_score": 0.00029, "epss_percentile": 0.07588}, "CVE-2022-47325": {"epss_score": 0.00025, "epss_percentile": 0.06375}, "CVE-2022-47326": {"epss_score": 0.00029, "epss_percentile": 0.07588}, "CVE-2022-47327": {"epss_score": 0.0004, "epss_percentile": 0.12071}, "CVE-2022-47328": {"epss_score": 0.00025, "epss_percentile": 0.06375}, "CVE-2022-47329": {"epss_score": 0.00029, "epss_percentile": 0.07588}, "CVE-2022-47330": {"epss_score": 0.00036, "epss_percentile": 0.10317}, "CVE-2022-47331": {"epss_score": 0.00026, "epss_percentile": 0.06406}, "CVE-2022-47332": {"epss_score": 0.00036, "epss_percentile": 0.10317}, "CVE-2022-47333": {"epss_score": 0.0004, "epss_percentile": 0.12071}, "CVE-2022-47334": {"epss_score": 0.00014, "epss_percentile": 0.01829}, "CVE-2022-47335": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47336": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47337": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47338": {"epss_score": 0.00032, "epss_percentile": 0.08775}, "CVE-2022-47339": {"epss_score": 0.00027, "epss_percentile": 0.06953}, "CVE-2022-47340": {"epss_score": 0.00014, "epss_percentile": 0.02039}, "CVE-2022-47341": {"epss_score": 0.00021, "epss_percentile": 0.04709}, "CVE-2022-47342": {"epss_score": 0.00027, "epss_percentile": 0.06761}, "CVE-2022-47343": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2022-47344": {"epss_score": 0.00027, "epss_percentile": 0.06761}, "CVE-2022-47345": {"epss_score": 0.00027, "epss_percentile": 0.06761}, "CVE-2022-47346": {"epss_score": 0.00023, "epss_percentile": 0.05426}, "CVE-2022-47347": {"epss_score": 0.00027, "epss_percentile": 0.06761}, "CVE-2022-47348": {"epss_score": 0.00023, "epss_percentile": 0.05426}, "CVE-2022-47350": {"epss_score": 9e-05, "epss_percentile": 0.00688}, "CVE-2022-47351": {"epss_score": 9e-05, "epss_percentile": 0.00688}, "CVE-2022-47352": {"epss_score": 9e-05, "epss_percentile": 0.00636}, "CVE-2022-47353": {"epss_score": 9e-05, "epss_percentile": 0.00695}, "CVE-2022-47354": {"epss_score": 0.00027, "epss_percentile": 0.07172}, "CVE-2022-47355": {"epss_score": 0.00027, "epss_percentile": 0.07172}, "CVE-2022-47356": {"epss_score": 0.00027, "epss_percentile": 0.07172}, "CVE-2022-47357": {"epss_score": 0.00032, "epss_percentile": 0.08801}, "CVE-2022-47358": {"epss_score": 0.00032, "epss_percentile": 0.08801}, "CVE-2022-47359": {"epss_score": 0.00032, "epss_percentile": 0.08801}, "CVE-2022-47360": {"epss_score": 0.00028, "epss_percentile": 0.07559}, "CVE-2022-47361": {"epss_score": 0.00023, "epss_percentile": 0.05376}, "CVE-2022-47362": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47363": {"epss_score": 0.00016, "epss_percentile": 0.02948}, "CVE-2022-47364": {"epss_score": 0.00015, "epss_percentile": 0.02173}, "CVE-2022-47365": {"epss_score": 0.00017, "epss_percentile": 0.03174}, "CVE-2022-47366": {"epss_score": 0.00017, "epss_percentile": 0.03174}, "CVE-2022-47367": {"epss_score": 0.00026, "epss_percentile": 0.06668}, "CVE-2022-47368": {"epss_score": 0.00016, "epss_percentile": 0.02948}, "CVE-2022-47369": {"epss_score": 0.00016, "epss_percentile": 0.02948}, "CVE-2022-47370": {"epss_score": 0.00038, "epss_percentile": 0.11207}, "CVE-2022-47371": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2022-47372": {"epss_score": 0.00241, "epss_percentile": 0.47299}, "CVE-2022-47373": {"epss_score": 0.00285, "epss_percentile": 0.5165}, "CVE-2022-47374": {"epss_score": 0.00285, "epss_percentile": 0.51534}, "CVE-2022-47375": {"epss_score": 0.00302, "epss_percentile": 0.53167}, "CVE-2022-47376": {"epss_score": 0.00035, "epss_percentile": 0.1016}, "CVE-2022-47377": {"epss_score": 0.00752, "epss_percentile": 0.72657}, "CVE-2022-47378": {"epss_score": 0.00345, "epss_percentile": 0.56568}, "CVE-2022-47379": {"epss_score": 0.04188, "epss_percentile": 0.88369}, "CVE-2022-47380": {"epss_score": 0.03723, "epss_percentile": 0.87627}, "CVE-2022-47381": {"epss_score": 0.03723, "epss_percentile": 0.87627}, "CVE-2022-47382": {"epss_score": 0.03723, "epss_percentile": 0.87627}, "CVE-2022-47383": {"epss_score": 0.03723, "epss_percentile": 0.87627}, "CVE-2022-47384": {"epss_score": 0.03723, "epss_percentile": 0.87627}, "CVE-2022-47385": {"epss_score": 0.03723, "epss_percentile": 0.87627}, "CVE-2022-47386": {"epss_score": 0.03723, "epss_percentile": 0.87627}, "CVE-2022-47387": {"epss_score": 0.03723, "epss_percentile": 0.87627}, "CVE-2022-47388": {"epss_score": 0.03723, "epss_percentile": 0.87627}, "CVE-2022-47389": {"epss_score": 0.03723, "epss_percentile": 0.87627}, "CVE-2022-47390": {"epss_score": 0.03723, "epss_percentile": 0.87627}, "CVE-2022-47391": {"epss_score": 0.00467, "epss_percentile": 0.63811}, "CVE-2022-47392": {"epss_score": 0.00265, "epss_percentile": 0.49815}, "CVE-2022-47393": {"epss_score": 0.0044, "epss_percentile": 0.62614}, "CVE-2022-47395": {"epss_score": 0.00098, "epss_percentile": 0.27684}, "CVE-2022-47406": {"epss_score": 0.00259, "epss_percentile": 0.4905}, "CVE-2022-47407": {"epss_score": 0.00294, "epss_percentile": 0.52409}, "CVE-2022-47408": {"epss_score": 0.00155, "epss_percentile": 0.36758}, "CVE-2022-47409": {"epss_score": 0.00234, "epss_percentile": 0.46161}, "CVE-2022-47410": {"epss_score": 0.00314, "epss_percentile": 0.54111}, "CVE-2022-47411": {"epss_score": 0.00289, "epss_percentile": 0.52047}, "CVE-2022-47412": {"epss_score": 0.00408, "epss_percentile": 0.60649}, "CVE-2022-47413": {"epss_score": 0.00215, "epss_percentile": 0.44055}, "CVE-2022-47414": {"epss_score": 0.00221, "epss_percentile": 0.44683}, "CVE-2022-47415": {"epss_score": 0.00256, "epss_percentile": 0.48795}, "CVE-2022-47416": {"epss_score": 0.00256, "epss_percentile": 0.48795}, "CVE-2022-47417": {"epss_score": 0.00235, "epss_percentile": 0.46335}, "CVE-2022-47418": {"epss_score": 0.00235, "epss_percentile": 0.46335}, "CVE-2022-47419": {"epss_score": 0.00197, "epss_percentile": 0.41969}, "CVE-2022-47420": {"epss_score": 0.00224, "epss_percentile": 0.45011}, "CVE-2022-47421": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2022-47422": {"epss_score": 0.00123, "epss_percentile": 0.32212}, "CVE-2022-47423": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-47424": {"epss_score": 0.00192, "epss_percentile": 0.41286}, "CVE-2022-47425": {"epss_score": 0.00024, "epss_percentile": 0.05661}, "CVE-2022-47426": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2022-47427": {"epss_score": 0.00064, "epss_percentile": 0.20105}, "CVE-2022-47428": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2022-47429": {"epss_score": 0.00131, "epss_percentile": 0.33471}, "CVE-2022-47430": {"epss_score": 0.00275, "epss_percentile": 0.50673}, "CVE-2022-47431": {"epss_score": 0.00113, "epss_percentile": 0.307}, "CVE-2022-47432": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2022-47433": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2022-47434": {"epss_score": 0.00054, "epss_percentile": 0.17052}, "CVE-2022-47435": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-47436": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-47437": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-47438": {"epss_score": 0.00069, "epss_percentile": 0.21631}, "CVE-2022-47439": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2022-47440": {"epss_score": 0.00094, "epss_percentile": 0.26965}, "CVE-2022-47441": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2022-47442": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2022-47443": {"epss_score": 0.00067, "epss_percentile": 0.21038}, "CVE-2022-47444": {"epss_score": 0.0024, "epss_percentile": 0.46946}, "CVE-2022-47445": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2022-47446": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-47447": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2022-47448": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2022-47449": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2022-47450": {"epss_score": 0.0004, "epss_percentile": 0.12071}, "CVE-2022-47451": {"epss_score": 0.00054, "epss_percentile": 0.17262}, "CVE-2022-47452": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47453": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47454": {"epss_score": 0.00038, "epss_percentile": 0.1135}, "CVE-2022-47455": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47456": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47457": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47458": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47459": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47460": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47461": {"epss_score": 0.00032, "epss_percentile": 0.09089}, "CVE-2022-47462": {"epss_score": 0.00032, "epss_percentile": 0.09089}, "CVE-2022-47463": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47464": {"epss_score": 0.00024, "epss_percentile": 0.05871}, "CVE-2022-47465": {"epss_score": 0.00024, "epss_percentile": 0.05987}, "CVE-2022-47466": {"epss_score": 0.00033, "epss_percentile": 0.09243}, "CVE-2022-47467": {"epss_score": 0.00033, "epss_percentile": 0.09243}, "CVE-2022-47468": {"epss_score": 0.00033, "epss_percentile": 0.09243}, "CVE-2022-47469": {"epss_score": 0.00014, "epss_percentile": 0.01829}, "CVE-2022-47470": {"epss_score": 0.00014, "epss_percentile": 0.01829}, "CVE-2022-47471": {"epss_score": 0.00013, "epss_percentile": 0.01444}, "CVE-2022-47472": {"epss_score": 0.00013, "epss_percentile": 0.01444}, "CVE-2022-47473": {"epss_score": 0.00013, "epss_percentile": 0.01444}, "CVE-2022-47474": {"epss_score": 0.00013, "epss_percentile": 0.01444}, "CVE-2022-47475": {"epss_score": 0.00013, "epss_percentile": 0.01444}, "CVE-2022-47476": {"epss_score": 0.00013, "epss_percentile": 0.01444}, "CVE-2022-47477": {"epss_score": 0.00013, "epss_percentile": 0.01444}, "CVE-2022-47478": {"epss_score": 0.00013, "epss_percentile": 0.01444}, "CVE-2022-47479": {"epss_score": 0.00025, "epss_percentile": 0.06312}, "CVE-2022-47480": {"epss_score": 0.00027, "epss_percentile": 0.06855}, "CVE-2022-47481": {"epss_score": 0.00027, "epss_percentile": 0.06855}, "CVE-2022-47482": {"epss_score": 0.00027, "epss_percentile": 0.06855}, "CVE-2022-47483": {"epss_score": 0.00027, "epss_percentile": 0.06855}, "CVE-2022-47484": {"epss_score": 0.00027, "epss_percentile": 0.06855}, "CVE-2022-47485": {"epss_score": 0.00011, "epss_percentile": 0.00946}, "CVE-2022-47486": {"epss_score": 0.00014, "epss_percentile": 0.01829}, "CVE-2022-47487": {"epss_score": 0.00014, "epss_percentile": 0.02039}, "CVE-2022-47488": {"epss_score": 0.00011, "epss_percentile": 0.00946}, "CVE-2022-47489": {"epss_score": 0.00022, "epss_percentile": 0.05259}, "CVE-2022-47490": {"epss_score": 0.00023, "epss_percentile": 0.05399}, "CVE-2022-47491": {"epss_score": 0.00011, "epss_percentile": 0.00946}, "CVE-2022-47492": {"epss_score": 0.00023, "epss_percentile": 0.05399}, "CVE-2022-47493": {"epss_score": 0.00023, "epss_percentile": 0.05399}, "CVE-2022-47494": {"epss_score": 0.00011, "epss_percentile": 0.00946}, "CVE-2022-47495": {"epss_score": 0.00011, "epss_percentile": 0.00946}, "CVE-2022-47496": {"epss_score": 0.00011, "epss_percentile": 0.00946}, "CVE-2022-47497": {"epss_score": 0.00011, "epss_percentile": 0.00946}, "CVE-2022-47498": {"epss_score": 0.00011, "epss_percentile": 0.00946}, "CVE-2022-47499": {"epss_score": 0.00011, "epss_percentile": 0.00946}, "CVE-2022-47500": {"epss_score": 0.0274, "epss_percentile": 0.85558}, "CVE-2022-47501": {"epss_score": 0.8349, "epss_percentile": 0.9925}, "CVE-2022-47502": {"epss_score": 0.00116, "epss_percentile": 0.31068}, "CVE-2022-47503": {"epss_score": 0.0063, "epss_percentile": 0.69702}, "CVE-2022-47504": {"epss_score": 0.0063, "epss_percentile": 0.69702}, "CVE-2022-47505": {"epss_score": 0.00061, "epss_percentile": 0.19372}, "CVE-2022-47506": {"epss_score": 0.00149, "epss_percentile": 0.36012}, "CVE-2022-47507": {"epss_score": 0.0063, "epss_percentile": 0.69702}, "CVE-2022-47508": {"epss_score": 0.00154, "epss_percentile": 0.36666}, "CVE-2022-47509": {"epss_score": 0.00828, "epss_percentile": 0.73993}, "CVE-2022-47512": {"epss_score": 0.00093, "epss_percentile": 0.26709}, "CVE-2022-47514": {"epss_score": 0.00625, "epss_percentile": 0.69579}, "CVE-2022-47515": {"epss_score": 0.00667, "epss_percentile": 0.70722}, "CVE-2022-47516": {"epss_score": 0.00238, "epss_percentile": 0.46841}, "CVE-2022-47517": {"epss_score": 0.00976, "epss_percentile": 0.76216}, "CVE-2022-47518": {"epss_score": 0.00027, "epss_percentile": 0.06818}, "CVE-2022-47519": {"epss_score": 0.00029, "epss_percentile": 0.0775}, "CVE-2022-47520": {"epss_score": 0.00026, "epss_percentile": 0.0662}, "CVE-2022-47521": {"epss_score": 0.00029, "epss_percentile": 0.07931}, "CVE-2022-47522": {"epss_score": 0.15949, "epss_percentile": 0.94542}, "CVE-2022-47523": {"epss_score": 0.58279, "epss_percentile": 0.98106}, "CVE-2022-47524": {"epss_score": 0.00363, "epss_percentile": 0.57881}, "CVE-2022-47525": {"epss_score": 0.00167, "epss_percentile": 0.38293}, "CVE-2022-47526": {"epss_score": 0.02128, "epss_percentile": 0.83702}, "CVE-2022-47529": {"epss_score": 0.03353, "epss_percentile": 0.86968}, "CVE-2022-47531": {"epss_score": 0.0006, "epss_percentile": 0.19234}, "CVE-2022-47532": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2022-47542": {"epss_score": 0.00228, "epss_percentile": 0.45515}, "CVE-2022-47543": {"epss_score": 0.00175, "epss_percentile": 0.39348}, "CVE-2022-47544": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2022-47547": {"epss_score": 0.00129, "epss_percentile": 0.33194}, "CVE-2022-47549": {"epss_score": 0.00069, "epss_percentile": 0.21629}, "CVE-2022-47551": {"epss_score": 0.00062, "epss_percentile": 0.19589}, "CVE-2022-47553": {"epss_score": 0.00115, "epss_percentile": 0.30905}, "CVE-2022-47554": {"epss_score": 0.00112, "epss_percentile": 0.30455}, "CVE-2022-47555": {"epss_score": 0.00408, "epss_percentile": 0.60666}, "CVE-2022-47556": {"epss_score": 0.00117, "epss_percentile": 0.3137}, "CVE-2022-47557": {"epss_score": 0.00035, "epss_percentile": 0.09812}, "CVE-2022-47558": {"epss_score": 0.00122, "epss_percentile": 0.3209}, "CVE-2022-47559": {"epss_score": 0.00112, "epss_percentile": 0.30567}, "CVE-2022-47560": {"epss_score": 0.00042, "epss_percentile": 0.12803}, "CVE-2022-47561": {"epss_score": 0.00031, "epss_percentile": 0.08458}, "CVE-2022-47562": {"epss_score": 0.00268, "epss_percentile": 0.50034}, "CVE-2022-47577": {"epss_score": 0.00054, "epss_percentile": 0.1707}, "CVE-2022-47578": {"epss_score": 0.00032, "epss_percentile": 0.08813}, "CVE-2022-47581": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2022-47583": {"epss_score": 0.00281, "epss_percentile": 0.51135}, "CVE-2022-47586": {"epss_score": 0.00144, "epss_percentile": 0.35345}, "CVE-2022-47587": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-47588": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2022-47589": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2022-47590": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2022-47591": {"epss_score": 0.00113, "epss_percentile": 0.307}, "CVE-2022-47592": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2022-47593": {"epss_score": 0.00213, "epss_percentile": 0.43906}, "CVE-2022-47594": {"epss_score": 0.00091, "epss_percentile": 0.26387}, "CVE-2022-47595": {"epss_score": 0.00305, "epss_percentile": 0.5332}, "CVE-2022-47596": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2022-47597": {"epss_score": 0.00282, "epss_percentile": 0.51203}, "CVE-2022-47598": {"epss_score": 0.00054, "epss_percentile": 0.17052}, "CVE-2022-47599": {"epss_score": 0.00124, "epss_percentile": 0.32349}, "CVE-2022-47600": {"epss_score": 0.00091, "epss_percentile": 0.26188}, "CVE-2022-47601": {"epss_score": 0.00179, "epss_percentile": 0.39828}, "CVE-2022-47602": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2022-47603": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2022-47604": {"epss_score": 0.00231, "epss_percentile": 0.45777}, "CVE-2022-47605": {"epss_score": 0.00225, "epss_percentile": 0.45132}, "CVE-2022-47606": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-47607": {"epss_score": 0.00159, "epss_percentile": 0.3739}, "CVE-2022-47608": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2022-47609": {"epss_score": 0.00065, "epss_percentile": 0.20566}, "CVE-2022-47610": {"epss_score": 0.00167, "epss_percentile": 0.38376}, "CVE-2022-47611": {"epss_score": 0.00092, "epss_percentile": 0.26501}, "CVE-2022-47612": {"epss_score": 0.00089, "epss_percentile": 0.2588}, "CVE-2022-47613": {"epss_score": 0.00159, "epss_percentile": 0.3739}, "CVE-2022-47614": {"epss_score": 0.00126, "epss_percentile": 0.32756}, "CVE-2022-47615": {"epss_score": 0.878, "epss_percentile": 0.99445}, "CVE-2022-47616": {"epss_score": 0.00336, "epss_percentile": 0.55942}, "CVE-2022-47617": {"epss_score": 0.00194, "epss_percentile": 0.41557}, "CVE-2022-47618": {"epss_score": 0.00569, "epss_percentile": 0.67923}, "CVE-2022-47629": {"epss_score": 0.01529, "epss_percentile": 0.80875}, "CVE-2022-47630": {"epss_score": 0.00443, "epss_percentile": 0.62764}, "CVE-2022-47631": {"epss_score": 0.00068, "epss_percentile": 0.21214}, "CVE-2022-47632": {"epss_score": 0.00066, "epss_percentile": 0.2082}, "CVE-2022-47633": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2022-47634": {"epss_score": 0.00214, "epss_percentile": 0.4401}, "CVE-2022-47635": {"epss_score": 0.00344, "epss_percentile": 0.56545}, "CVE-2022-47636": {"epss_score": 0.00123, "epss_percentile": 0.32188}, "CVE-2022-47637": {"epss_score": 0.00057, "epss_percentile": 0.18159}, "CVE-2022-47648": {"epss_score": 0.00057, "epss_percentile": 0.18172}, "CVE-2022-47653": {"epss_score": 0.00134, "epss_percentile": 0.33758}, "CVE-2022-47654": {"epss_score": 0.0014, "epss_percentile": 0.34687}, "CVE-2022-47655": {"epss_score": 0.00028, "epss_percentile": 0.07563}, "CVE-2022-47656": {"epss_score": 0.00134, "epss_percentile": 0.33758}, "CVE-2022-47657": {"epss_score": 0.00036, "epss_percentile": 0.102}, "CVE-2022-47658": {"epss_score": 0.0014, "epss_percentile": 0.34687}, "CVE-2022-47659": {"epss_score": 0.00036, "epss_percentile": 0.102}, "CVE-2022-47660": {"epss_score": 0.00034, "epss_percentile": 0.09546}, "CVE-2022-47661": {"epss_score": 0.00036, "epss_percentile": 0.102}, "CVE-2022-47662": {"epss_score": 0.00025, "epss_percentile": 0.0629}, "CVE-2022-47663": {"epss_score": 0.00036, "epss_percentile": 0.102}, "CVE-2022-47664": {"epss_score": 0.00044, "epss_percentile": 0.13503}, "CVE-2022-47665": {"epss_score": 0.0006, "epss_percentile": 0.18979}, "CVE-2022-47673": {"epss_score": 0.00016, "epss_percentile": 0.02853}, "CVE-2022-47695": {"epss_score": 0.00019, "epss_percentile": 0.041}, "CVE-2022-47696": {"epss_score": 0.00016, "epss_percentile": 0.02853}, "CVE-2022-47697": {"epss_score": 0.0011, "epss_percentile": 0.30113}, "CVE-2022-47698": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2022-47699": {"epss_score": 0.0011, "epss_percentile": 0.30113}, "CVE-2022-47700": {"epss_score": 0.0008, "epss_percentile": 0.24019}, "CVE-2022-47701": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2022-47703": {"epss_score": 0.00113, "epss_percentile": 0.30723}, "CVE-2022-47714": {"epss_score": 0.00061, "epss_percentile": 0.19478}, "CVE-2022-47715": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2022-47717": {"epss_score": 0.00113, "epss_percentile": 0.30723}, "CVE-2022-47732": {"epss_score": 0.00195, "epss_percentile": 0.41644}, "CVE-2022-47740": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-47745": {"epss_score": 0.02717, "epss_percentile": 0.85511}, "CVE-2022-47747": {"epss_score": 0.00171, "epss_percentile": 0.3884}, "CVE-2022-47757": {"epss_score": 0.00147, "epss_percentile": 0.35799}, "CVE-2022-47758": {"epss_score": 0.00564, "epss_percentile": 0.67746}, "CVE-2022-47762": {"epss_score": 0.00148, "epss_percentile": 0.35857}, "CVE-2022-47766": {"epss_score": 0.00122, "epss_percentile": 0.32089}, "CVE-2022-47767": {"epss_score": 0.00458, "epss_percentile": 0.63441}, "CVE-2022-47768": {"epss_score": 0.00274, "epss_percentile": 0.50543}, "CVE-2022-47769": {"epss_score": 0.00385, "epss_percentile": 0.59212}, "CVE-2022-47770": {"epss_score": 0.00122, "epss_percentile": 0.32157}, "CVE-2022-47780": {"epss_score": 0.00309, "epss_percentile": 0.53686}, "CVE-2022-47790": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-47848": {"epss_score": 0.00166, "epss_percentile": 0.38249}, "CVE-2022-47853": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2022-47854": {"epss_score": 0.00125, "epss_percentile": 0.32539}, "CVE-2022-47859": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-47860": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-47861": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-47862": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-47864": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-47865": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-47866": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-47870": {"epss_score": 0.00231, "epss_percentile": 0.45778}, "CVE-2022-47872": {"epss_score": 0.00427, "epss_percentile": 0.61908}, "CVE-2022-47873": {"epss_score": 0.0008, "epss_percentile": 0.24143}, "CVE-2022-47874": {"epss_score": 0.2676, "epss_percentile": 0.96174}, "CVE-2022-47875": {"epss_score": 0.07403, "epss_percentile": 0.91454}, "CVE-2022-47876": {"epss_score": 0.03994, "epss_percentile": 0.88082}, "CVE-2022-47877": {"epss_score": 0.01338, "epss_percentile": 0.79565}, "CVE-2022-47878": {"epss_score": 0.19172, "epss_percentile": 0.95143}, "CVE-2022-47879": {"epss_score": 0.02928, "epss_percentile": 0.86012}, "CVE-2022-47880": {"epss_score": 0.00721, "epss_percentile": 0.71975}, "CVE-2022-47881": {"epss_score": 0.00347, "epss_percentile": 0.56762}, "CVE-2022-47891": {"epss_score": 0.00088, "epss_percentile": 0.25762}, "CVE-2022-47892": {"epss_score": 0.00123, "epss_percentile": 0.32197}, "CVE-2022-47893": {"epss_score": 0.01724, "epss_percentile": 0.81947}, "CVE-2022-47894": {"epss_score": 0.00369, "epss_percentile": 0.58258}, "CVE-2022-47895": {"epss_score": 3e-05, "epss_percentile": 0.00083}, "CVE-2022-47896": {"epss_score": 3e-05, "epss_percentile": 0.00067}, "CVE-2022-47908": {"epss_score": 0.00102, "epss_percentile": 0.28838}, "CVE-2022-47909": {"epss_score": 0.00168, "epss_percentile": 0.38448}, "CVE-2022-47911": {"epss_score": 0.00445, "epss_percentile": 0.62872}, "CVE-2022-47915": {"epss_score": 0.00139, "epss_percentile": 0.34594}, "CVE-2022-47917": {"epss_score": 0.00079, "epss_percentile": 0.23868}, "CVE-2022-47924": {"epss_score": 0.00029, "epss_percentile": 0.07763}, "CVE-2022-47925": {"epss_score": 0.00241, "epss_percentile": 0.47254}, "CVE-2022-47926": {"epss_score": 0.00449, "epss_percentile": 0.63053}, "CVE-2022-47927": {"epss_score": 0.00045, "epss_percentile": 0.13761}, "CVE-2022-47928": {"epss_score": 0.00338, "epss_percentile": 0.56109}, "CVE-2022-47929": {"epss_score": 0.0002, "epss_percentile": 0.04521}, "CVE-2022-47930": {"epss_score": 0.00058, "epss_percentile": 0.18307}, "CVE-2022-47931": {"epss_score": 0.00055, "epss_percentile": 0.1738}, "CVE-2022-47932": {"epss_score": 0.00758, "epss_percentile": 0.72771}, "CVE-2022-47933": {"epss_score": 0.00725, "epss_percentile": 0.72049}, "CVE-2022-47934": {"epss_score": 0.00725, "epss_percentile": 0.72049}, "CVE-2022-47935": {"epss_score": 0.00114, "epss_percentile": 0.30842}, "CVE-2022-47936": {"epss_score": 0.00157, "epss_percentile": 0.37027}, "CVE-2022-47937": {"epss_score": 0.00173, "epss_percentile": 0.39047}, "CVE-2022-47938": {"epss_score": 0.03645, "epss_percentile": 0.87499}, "CVE-2022-47939": {"epss_score": 0.00942, "epss_percentile": 0.75765}, "CVE-2022-47940": {"epss_score": 0.00172, "epss_percentile": 0.38909}, "CVE-2022-47941": {"epss_score": 0.00297, "epss_percentile": 0.52681}, "CVE-2022-47942": {"epss_score": 0.00123, "epss_percentile": 0.32287}, "CVE-2022-47943": {"epss_score": 0.0129, "epss_percentile": 0.79219}, "CVE-2022-47945": {"epss_score": 0.89889, "epss_percentile": 0.99547}, "CVE-2022-47946": {"epss_score": 0.00017, "epss_percentile": 0.03315}, "CVE-2022-47949": {"epss_score": 0.52025, "epss_percentile": 0.97806}, "CVE-2022-47950": {"epss_score": 0.00193, "epss_percentile": 0.41443}, "CVE-2022-47951": {"epss_score": 0.0063, "epss_percentile": 0.69687}, "CVE-2022-47952": {"epss_score": 0.0217, "epss_percentile": 0.83867}, "CVE-2022-47965": {"epss_score": 0.00106, "epss_percentile": 0.29501}, "CVE-2022-47966": {"epss_score": 0.94385, "epss_percentile": 0.99967}, "CVE-2022-47967": {"epss_score": 0.00114, "epss_percentile": 0.30842}, "CVE-2022-47968": {"epss_score": 0.00285, "epss_percentile": 0.51648}, "CVE-2022-47974": {"epss_score": 0.00064, "epss_percentile": 0.20251}, "CVE-2022-47975": {"epss_score": 0.00241, "epss_percentile": 0.47332}, "CVE-2022-47976": {"epss_score": 0.0015, "epss_percentile": 0.36136}, "CVE-2022-47977": {"epss_score": 0.00114, "epss_percentile": 0.30842}, "CVE-2022-47983": {"epss_score": 0.00303, "epss_percentile": 0.53233}, "CVE-2022-47984": {"epss_score": 0.00058, "epss_percentile": 0.18521}, "CVE-2022-47986": {"epss_score": 0.94303, "epss_percentile": 0.99941}, "CVE-2022-47990": {"epss_score": 0.00023, "epss_percentile": 0.05508}, "CVE-2022-48006": {"epss_score": 0.00152, "epss_percentile": 0.36455}, "CVE-2022-48007": {"epss_score": 0.00199, "epss_percentile": 0.4213}, "CVE-2022-48008": {"epss_score": 0.01908, "epss_percentile": 0.82817}, "CVE-2022-48010": {"epss_score": 0.00214, "epss_percentile": 0.43979}, "CVE-2022-48011": {"epss_score": 0.01165, "epss_percentile": 0.78171}, "CVE-2022-48012": {"epss_score": 0.03793, "epss_percentile": 0.87733}, "CVE-2022-48013": {"epss_score": 0.00259, "epss_percentile": 0.49031}, "CVE-2022-48019": {"epss_score": 0.00074, "epss_percentile": 0.22862}, "CVE-2022-48020": {"epss_score": 0.00089, "epss_percentile": 0.25816}, "CVE-2022-48021": {"epss_score": 0.00444, "epss_percentile": 0.62841}, "CVE-2022-48022": {"epss_score": 0.00265, "epss_percentile": 0.49791}, "CVE-2022-48023": {"epss_score": 0.00179, "epss_percentile": 0.39829}, "CVE-2022-48063": {"epss_score": 9e-05, "epss_percentile": 0.0074}, "CVE-2022-48064": {"epss_score": 0.0001, "epss_percentile": 0.00906}, "CVE-2022-48065": {"epss_score": 0.00019, "epss_percentile": 0.04413}, "CVE-2022-48066": {"epss_score": 0.00062, "epss_percentile": 0.19729}, "CVE-2022-48067": {"epss_score": 0.0004, "epss_percentile": 0.11992}, "CVE-2022-48069": {"epss_score": 0.01323, "epss_percentile": 0.79456}, "CVE-2022-48070": {"epss_score": 0.00189, "epss_percentile": 0.40988}, "CVE-2022-48071": {"epss_score": 0.00058, "epss_percentile": 0.18355}, "CVE-2022-48072": {"epss_score": 0.00189, "epss_percentile": 0.40988}, "CVE-2022-48073": {"epss_score": 0.00058, "epss_percentile": 0.18355}, "CVE-2022-48074": {"epss_score": 0.0006, "epss_percentile": 0.19241}, "CVE-2022-48077": {"epss_score": 0.0004, "epss_percentile": 0.12174}, "CVE-2022-48078": {"epss_score": 0.00171, "epss_percentile": 0.38819}, "CVE-2022-48079": {"epss_score": 0.00722, "epss_percentile": 0.72}, "CVE-2022-48082": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2022-48085": {"epss_score": 0.00126, "epss_percentile": 0.32666}, "CVE-2022-48090": {"epss_score": 0.00073, "epss_percentile": 0.22628}, "CVE-2022-48091": {"epss_score": 0.00116, "epss_percentile": 0.31064}, "CVE-2022-48093": {"epss_score": 0.01504, "epss_percentile": 0.80735}, "CVE-2022-48094": {"epss_score": 0.00094, "epss_percentile": 0.27034}, "CVE-2022-48107": {"epss_score": 0.04683, "epss_percentile": 0.89003}, "CVE-2022-48108": {"epss_score": 0.04683, "epss_percentile": 0.89003}, "CVE-2022-48110": {"epss_score": 0.01101, "epss_percentile": 0.77575}, "CVE-2022-48111": {"epss_score": 0.00167, "epss_percentile": 0.38337}, "CVE-2022-48113": {"epss_score": 0.00362, "epss_percentile": 0.57817}, "CVE-2022-48114": {"epss_score": 0.00089, "epss_percentile": 0.25801}, "CVE-2022-48115": {"epss_score": 0.00115, "epss_percentile": 0.31009}, "CVE-2022-48116": {"epss_score": 0.014, "epss_percentile": 0.80005}, "CVE-2022-48118": {"epss_score": 0.00208, "epss_percentile": 0.43294}, "CVE-2022-48120": {"epss_score": 0.00118, "epss_percentile": 0.31443}, "CVE-2022-48121": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2022-48122": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2022-48123": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2022-48124": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2022-48125": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2022-48126": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2022-48130": {"epss_score": 0.00186, "epss_percentile": 0.40629}, "CVE-2022-48140": {"epss_score": 0.00091, "epss_percentile": 0.26284}, "CVE-2022-48149": {"epss_score": 0.0013, "epss_percentile": 0.33322}, "CVE-2022-48150": {"epss_score": 0.00361, "epss_percentile": 0.57717}, "CVE-2022-48152": {"epss_score": 0.00087, "epss_percentile": 0.25568}, "CVE-2022-48161": {"epss_score": 0.00091, "epss_percentile": 0.26234}, "CVE-2022-48164": {"epss_score": 0.83123, "epss_percentile": 0.99232}, "CVE-2022-48165": {"epss_score": 0.79241, "epss_percentile": 0.99026}, "CVE-2022-48166": {"epss_score": 0.73259, "epss_percentile": 0.98744}, "CVE-2022-48174": {"epss_score": 0.00679, "epss_percentile": 0.71016}, "CVE-2022-48175": {"epss_score": 0.06882, "epss_percentile": 0.91091}, "CVE-2022-48176": {"epss_score": 0.00065, "epss_percentile": 0.20501}, "CVE-2022-48177": {"epss_score": 0.01901, "epss_percentile": 0.82778}, "CVE-2022-48178": {"epss_score": 0.0144, "epss_percentile": 0.80297}, "CVE-2022-48181": {"epss_score": 0.00032, "epss_percentile": 0.09012}, "CVE-2022-48182": {"epss_score": 0.00127, "epss_percentile": 0.32847}, "CVE-2022-48183": {"epss_score": 0.00127, "epss_percentile": 0.32847}, "CVE-2022-48186": {"epss_score": 0.00074, "epss_percentile": 0.22767}, "CVE-2022-48188": {"epss_score": 0.00032, "epss_percentile": 0.09012}, "CVE-2022-48189": {"epss_score": 0.00022, "epss_percentile": 0.04966}, "CVE-2022-48191": {"epss_score": 0.00062, "epss_percentile": 0.19673}, "CVE-2022-48192": {"epss_score": 0.00065, "epss_percentile": 0.20623}, "CVE-2022-48193": {"epss_score": 0.0004, "epss_percentile": 0.11864}, "CVE-2022-48194": {"epss_score": 0.69672, "epss_percentile": 0.98598}, "CVE-2022-48195": {"epss_score": 0.00402, "epss_percentile": 0.60268}, "CVE-2022-48196": {"epss_score": 0.0125, "epss_percentile": 0.78883}, "CVE-2022-48197": {"epss_score": 0.09738, "epss_percentile": 0.92681}, "CVE-2022-48198": {"epss_score": 0.00451, "epss_percentile": 0.63148}, "CVE-2022-48199": {"epss_score": 0.00887, "epss_percentile": 0.74968}, "CVE-2022-48216": {"epss_score": 0.0041, "epss_percentile": 0.60814}, "CVE-2022-48217": {"epss_score": 0.00452, "epss_percentile": 0.63197}, "CVE-2022-48219": {"epss_score": 0.0003, "epss_percentile": 0.08204}, "CVE-2022-48220": {"epss_score": 0.0003, "epss_percentile": 0.08204}, "CVE-2022-48221": {"epss_score": 0.00136, "epss_percentile": 0.34202}, "CVE-2022-48222": {"epss_score": 0.00058, "epss_percentile": 0.18302}, "CVE-2022-48223": {"epss_score": 0.00037, "epss_percentile": 0.10934}, "CVE-2022-48224": {"epss_score": 0.00057, "epss_percentile": 0.18185}, "CVE-2022-48225": {"epss_score": 0.00024, "epss_percentile": 0.05971}, "CVE-2022-48226": {"epss_score": 0.00033, "epss_percentile": 0.09194}, "CVE-2022-48227": {"epss_score": 0.00057, "epss_percentile": 0.18193}, "CVE-2022-48228": {"epss_score": 0.0003, "epss_percentile": 0.08221}, "CVE-2022-48230": {"epss_score": 0.00116, "epss_percentile": 0.31158}, "CVE-2022-48231": {"epss_score": 0.00026, "epss_percentile": 0.0655}, "CVE-2022-48232": {"epss_score": 0.00022, "epss_percentile": 0.05028}, "CVE-2022-48233": {"epss_score": 0.00022, "epss_percentile": 0.05028}, "CVE-2022-48234": {"epss_score": 0.00014, "epss_percentile": 0.01996}, "CVE-2022-48235": {"epss_score": 0.00012, "epss_percentile": 0.0132}, "CVE-2022-48236": {"epss_score": 0.00016, "epss_percentile": 0.02779}, "CVE-2022-48237": {"epss_score": 0.0001, "epss_percentile": 0.00904}, "CVE-2022-48238": {"epss_score": 0.0001, "epss_percentile": 0.00904}, "CVE-2022-48239": {"epss_score": 0.0001, "epss_percentile": 0.00904}, "CVE-2022-48240": {"epss_score": 0.0001, "epss_percentile": 0.00904}, "CVE-2022-48241": {"epss_score": 0.00026, "epss_percentile": 0.06425}, "CVE-2022-48242": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2022-48243": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2022-48244": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2022-48245": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2022-48246": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2022-48247": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2022-48248": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2022-48249": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2022-48250": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2022-48251": {"epss_score": 0.00153, "epss_percentile": 0.36623}, "CVE-2022-48252": {"epss_score": 0.0136, "epss_percentile": 0.7975}, "CVE-2022-48253": {"epss_score": 0.21866, "epss_percentile": 0.95568}, "CVE-2022-48254": {"epss_score": 0.00013, "epss_percentile": 0.01697}, "CVE-2022-48255": {"epss_score": 0.01716, "epss_percentile": 0.81907}, "CVE-2022-48256": {"epss_score": 0.00092, "epss_percentile": 0.26415}, "CVE-2022-48257": {"epss_score": 0.00168, "epss_percentile": 0.38506}, "CVE-2022-48258": {"epss_score": 0.00197, "epss_percentile": 0.41901}, "CVE-2022-48259": {"epss_score": 0.00415, "epss_percentile": 0.61141}, "CVE-2022-48260": {"epss_score": 0.00153, "epss_percentile": 0.36565}, "CVE-2022-48261": {"epss_score": 0.00116, "epss_percentile": 0.31158}, "CVE-2022-48279": {"epss_score": 0.00337, "epss_percentile": 0.56016}, "CVE-2022-48281": {"epss_score": 8e-05, "epss_percentile": 0.00515}, "CVE-2022-48282": {"epss_score": 0.00467, "epss_percentile": 0.63861}, "CVE-2022-48283": {"epss_score": 0.00135, "epss_percentile": 0.3397}, "CVE-2022-48284": {"epss_score": 0.00135, "epss_percentile": 0.3397}, "CVE-2022-48285": {"epss_score": 0.00825, "epss_percentile": 0.73958}, "CVE-2022-48286": {"epss_score": 0.00092, "epss_percentile": 0.26524}, "CVE-2022-48287": {"epss_score": 0.00046, "epss_percentile": 0.14396}, "CVE-2022-48288": {"epss_score": 0.00093, "epss_percentile": 0.2672}, "CVE-2022-48289": {"epss_score": 0.00093, "epss_percentile": 0.2672}, "CVE-2022-48290": {"epss_score": 0.00067, "epss_percentile": 0.21059}, "CVE-2022-48291": {"epss_score": 0.00014, "epss_percentile": 0.02089}, "CVE-2022-48292": {"epss_score": 0.00042, "epss_percentile": 0.1256}, "CVE-2022-48293": {"epss_score": 0.00042, "epss_percentile": 0.1256}, "CVE-2022-48294": {"epss_score": 0.00093, "epss_percentile": 0.2672}, "CVE-2022-48295": {"epss_score": 0.00062, "epss_percentile": 0.19706}, "CVE-2022-48296": {"epss_score": 0.00062, "epss_percentile": 0.19706}, "CVE-2022-48297": {"epss_score": 0.00108, "epss_percentile": 0.29776}, "CVE-2022-48298": {"epss_score": 0.00108, "epss_percentile": 0.29776}, "CVE-2022-48299": {"epss_score": 0.00093, "epss_percentile": 0.2672}, "CVE-2022-48300": {"epss_score": 0.00093, "epss_percentile": 0.2672}, "CVE-2022-48301": {"epss_score": 0.00062, "epss_percentile": 0.19706}, "CVE-2022-48302": {"epss_score": 0.00092, "epss_percentile": 0.26524}, "CVE-2022-48303": {"epss_score": 0.00057, "epss_percentile": 0.17965}, "CVE-2022-48305": {"epss_score": 8e-05, "epss_percentile": 0.005}, "CVE-2022-48306": {"epss_score": 0.00102, "epss_percentile": 0.2872}, "CVE-2022-48307": {"epss_score": 0.00176, "epss_percentile": 0.39416}, "CVE-2022-48308": {"epss_score": 0.0017, "epss_percentile": 0.38673}, "CVE-2022-48309": {"epss_score": 0.00141, "epss_percentile": 0.34904}, "CVE-2022-48310": {"epss_score": 0.00022, "epss_percentile": 0.05022}, "CVE-2022-48311": {"epss_score": 0.00504, "epss_percentile": 0.65509}, "CVE-2022-48312": {"epss_score": 0.00082, "epss_percentile": 0.24441}, "CVE-2022-48313": {"epss_score": 0.00013, "epss_percentile": 0.01458}, "CVE-2022-48314": {"epss_score": 0.00013, "epss_percentile": 0.01458}, "CVE-2022-48317": {"epss_score": 0.00167, "epss_percentile": 0.384}, "CVE-2022-48318": {"epss_score": 0.00251, "epss_percentile": 0.48321}, "CVE-2022-48319": {"epss_score": 0.00086, "epss_percentile": 0.2542}, "CVE-2022-48320": {"epss_score": 0.00127, "epss_percentile": 0.32787}, "CVE-2022-48321": {"epss_score": 0.00051, "epss_percentile": 0.16264}, "CVE-2022-48322": {"epss_score": 0.00473, "epss_percentile": 0.64076}, "CVE-2022-48323": {"epss_score": 0.9069, "epss_percentile": 0.99596}, "CVE-2022-48324": {"epss_score": 0.00502, "epss_percentile": 0.65411}, "CVE-2022-48325": {"epss_score": 0.00736, "epss_percentile": 0.72304}, "CVE-2022-48326": {"epss_score": 0.00887, "epss_percentile": 0.74972}, "CVE-2022-48327": {"epss_score": 0.00502, "epss_percentile": 0.65411}, "CVE-2022-48328": {"epss_score": 0.00174, "epss_percentile": 0.39145}, "CVE-2022-48329": {"epss_score": 0.0014, "epss_percentile": 0.34706}, "CVE-2022-48330": {"epss_score": 0.00043, "epss_percentile": 0.13275}, "CVE-2022-48331": {"epss_score": 0.00075, "epss_percentile": 0.23021}, "CVE-2022-48332": {"epss_score": 0.00075, "epss_percentile": 0.23021}, "CVE-2022-48333": {"epss_score": 0.00075, "epss_percentile": 0.23021}, "CVE-2022-48334": {"epss_score": 0.00075, "epss_percentile": 0.23021}, "CVE-2022-48335": {"epss_score": 0.00121, "epss_percentile": 0.32013}, "CVE-2022-48336": {"epss_score": 0.00121, "epss_percentile": 0.32013}, "CVE-2022-48337": {"epss_score": 0.00304, "epss_percentile": 0.53289}, "CVE-2022-48338": {"epss_score": 0.00121, "epss_percentile": 0.31829}, "CVE-2022-48339": {"epss_score": 0.00091, "epss_percentile": 0.26252}, "CVE-2022-48340": {"epss_score": 0.00104, "epss_percentile": 0.29236}, "CVE-2022-48341": {"epss_score": 0.00351, "epss_percentile": 0.57014}, "CVE-2022-48342": {"epss_score": 2e-05, "epss_percentile": 0.00049}, "CVE-2022-48343": {"epss_score": 0.04504, "epss_percentile": 0.88769}, "CVE-2022-48344": {"epss_score": 0.00066, "epss_percentile": 0.20692}, "CVE-2022-48345": {"epss_score": 0.00454, "epss_percentile": 0.63265}, "CVE-2022-48346": {"epss_score": 0.00093, "epss_percentile": 0.26644}, "CVE-2022-48347": {"epss_score": 0.00138, "epss_percentile": 0.34532}, "CVE-2022-48348": {"epss_score": 0.00119, "epss_percentile": 0.31654}, "CVE-2022-48349": {"epss_score": 0.00128, "epss_percentile": 0.32989}, "CVE-2022-48350": {"epss_score": 0.00101, "epss_percentile": 0.28577}, "CVE-2022-48351": {"epss_score": 0.00123, "epss_percentile": 0.32191}, "CVE-2022-48352": {"epss_score": 0.00123, "epss_percentile": 0.32191}, "CVE-2022-48353": {"epss_score": 0.00123, "epss_percentile": 0.32205}, "CVE-2022-48354": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2022-48355": {"epss_score": 0.00053, "epss_percentile": 0.16836}, "CVE-2022-48356": {"epss_score": 0.00105, "epss_percentile": 0.29299}, "CVE-2022-48357": {"epss_score": 0.00123, "epss_percentile": 0.32191}, "CVE-2022-48358": {"epss_score": 0.00073, "epss_percentile": 0.22524}, "CVE-2022-48359": {"epss_score": 0.00217, "epss_percentile": 0.44248}, "CVE-2022-48360": {"epss_score": 0.00101, "epss_percentile": 0.28577}, "CVE-2022-48361": {"epss_score": 0.001, "epss_percentile": 0.28529}, "CVE-2022-48362": {"epss_score": 0.01703, "epss_percentile": 0.81844}, "CVE-2022-48363": {"epss_score": 0.00098, "epss_percentile": 0.27664}, "CVE-2022-48364": {"epss_score": 0.00101, "epss_percentile": 0.28592}, "CVE-2022-48365": {"epss_score": 0.0021, "epss_percentile": 0.43483}, "CVE-2022-48366": {"epss_score": 0.0022, "epss_percentile": 0.44616}, "CVE-2022-48367": {"epss_score": 0.00262, "epss_percentile": 0.4933}, "CVE-2022-48368": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2022-48369": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2022-48370": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2022-48371": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2022-48372": {"epss_score": 0.00011, "epss_percentile": 0.00946}, "CVE-2022-48373": {"epss_score": 0.0001, "epss_percentile": 0.00904}, "CVE-2022-48374": {"epss_score": 0.0001, "epss_percentile": 0.00904}, "CVE-2022-48375": {"epss_score": 0.00029, "epss_percentile": 0.07861}, "CVE-2022-48376": {"epss_score": 0.00029, "epss_percentile": 0.07861}, "CVE-2022-48377": {"epss_score": 0.00022, "epss_percentile": 0.05306}, "CVE-2022-48378": {"epss_score": 0.00017, "epss_percentile": 0.03108}, "CVE-2022-48379": {"epss_score": 0.00022, "epss_percentile": 0.05306}, "CVE-2022-48380": {"epss_score": 0.00012, "epss_percentile": 0.01163}, "CVE-2022-48381": {"epss_score": 0.00012, "epss_percentile": 0.01163}, "CVE-2022-48382": {"epss_score": 0.00011, "epss_percentile": 0.01061}, "CVE-2022-48383": {"epss_score": 0.00031, "epss_percentile": 0.08449}, "CVE-2022-48384": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2022-48385": {"epss_score": 0.0001, "epss_percentile": 0.00904}, "CVE-2022-48386": {"epss_score": 0.00011, "epss_percentile": 0.01047}, "CVE-2022-48387": {"epss_score": 0.0001, "epss_percentile": 0.00904}, "CVE-2022-48388": {"epss_score": 0.00031, "epss_percentile": 0.08505}, "CVE-2022-48389": {"epss_score": 0.00012, "epss_percentile": 0.01163}, "CVE-2022-48390": {"epss_score": 0.00037, "epss_percentile": 0.10894}, "CVE-2022-48391": {"epss_score": 0.00023, "epss_percentile": 0.05399}, "CVE-2022-48392": {"epss_score": 0.00027, "epss_percentile": 0.06748}, "CVE-2022-48422": {"epss_score": 0.00029, "epss_percentile": 0.07749}, "CVE-2022-48423": {"epss_score": 0.00016, "epss_percentile": 0.02855}, "CVE-2022-48424": {"epss_score": 0.00016, "epss_percentile": 0.02855}, "CVE-2022-48425": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-48426": {"epss_score": 0.0007, "epss_percentile": 0.217}, "CVE-2022-48427": {"epss_score": 0.00071, "epss_percentile": 0.22139}, "CVE-2022-48428": {"epss_score": 0.04861, "epss_percentile": 0.89222}, "CVE-2022-48429": {"epss_score": 0.00025, "epss_percentile": 0.06059}, "CVE-2022-48430": {"epss_score": 3e-05, "epss_percentile": 0.00119}, "CVE-2022-48431": {"epss_score": 1e-05, "epss_percentile": 9e-05}, "CVE-2022-48432": {"epss_score": 1e-05, "epss_percentile": 5e-05}, "CVE-2022-48433": {"epss_score": 3e-05, "epss_percentile": 0.00064}, "CVE-2022-48434": {"epss_score": 0.00254, "epss_percentile": 0.48506}, "CVE-2022-48435": {"epss_score": 1e-05, "epss_percentile": 0.00016}, "CVE-2022-48437": {"epss_score": 0.00089, "epss_percentile": 0.25889}, "CVE-2022-48438": {"epss_score": 9e-05, "epss_percentile": 0.00627}, "CVE-2022-48439": {"epss_score": 9e-05, "epss_percentile": 0.0074}, "CVE-2022-48440": {"epss_score": 0.00024, "epss_percentile": 0.0589}, "CVE-2022-48441": {"epss_score": 0.00024, "epss_percentile": 0.0589}, "CVE-2022-48442": {"epss_score": 0.00024, "epss_percentile": 0.0589}, "CVE-2022-48443": {"epss_score": 0.00024, "epss_percentile": 0.05817}, "CVE-2022-48444": {"epss_score": 0.00024, "epss_percentile": 0.05817}, "CVE-2022-48445": {"epss_score": 0.00024, "epss_percentile": 0.05817}, "CVE-2022-48446": {"epss_score": 0.0003, "epss_percentile": 0.08054}, "CVE-2022-48447": {"epss_score": 0.00023, "epss_percentile": 0.05399}, "CVE-2022-48448": {"epss_score": 0.00017, "epss_percentile": 0.03207}, "CVE-2022-48450": {"epss_score": 0.00011, "epss_percentile": 0.00977}, "CVE-2022-48451": {"epss_score": 8e-05, "epss_percentile": 0.00579}, "CVE-2022-48452": {"epss_score": 0.00012, "epss_percentile": 0.01161}, "CVE-2022-48453": {"epss_score": 9e-05, "epss_percentile": 0.00684}, "CVE-2022-48454": {"epss_score": 0.00026, "epss_percentile": 0.06596}, "CVE-2022-48455": {"epss_score": 0.00034, "epss_percentile": 0.0969}, "CVE-2022-48456": {"epss_score": 0.00016, "epss_percentile": 0.0304}, "CVE-2022-48457": {"epss_score": 0.00019, "epss_percentile": 0.04057}, "CVE-2022-48458": {"epss_score": 0.00034, "epss_percentile": 0.0969}, "CVE-2022-48459": {"epss_score": 0.00014, "epss_percentile": 0.02039}, "CVE-2022-48460": {"epss_score": 0.00046, "epss_percentile": 0.14398}, "CVE-2022-48461": {"epss_score": 0.00017, "epss_percentile": 0.03315}, "CVE-2022-48462": {"epss_score": 0.00013, "epss_percentile": 0.01541}, "CVE-2022-48463": {"epss_score": 0.00014, "epss_percentile": 0.01998}, "CVE-2022-48464": {"epss_score": 0.00014, "epss_percentile": 0.01998}, "CVE-2022-48468": {"epss_score": 0.00024, "epss_percentile": 0.05742}, "CVE-2022-48469": {"epss_score": 0.00053, "epss_percentile": 0.16704}, "CVE-2022-48470": {"epss_score": 7e-05, "epss_percentile": 0.0046}, "CVE-2022-48471": {"epss_score": 0.00096, "epss_percentile": 0.27396}, "CVE-2022-48472": {"epss_score": 0.02725, "epss_percentile": 0.85526}, "CVE-2022-48473": {"epss_score": 0.00074, "epss_percentile": 0.2271}, "CVE-2022-48474": {"epss_score": 0.01661, "epss_percentile": 0.81626}, "CVE-2022-48475": {"epss_score": 0.00727, "epss_percentile": 0.72085}, "CVE-2022-48476": {"epss_score": 3e-05, "epss_percentile": 0.00112}, "CVE-2022-48477": {"epss_score": 2e-05, "epss_percentile": 0.0003}, "CVE-2022-48478": {"epss_score": 0.00163, "epss_percentile": 0.3781}, "CVE-2022-48479": {"epss_score": 0.00163, "epss_percentile": 0.3781}, "CVE-2022-48480": {"epss_score": 0.00166, "epss_percentile": 0.3818}, "CVE-2022-48481": {"epss_score": 2e-05, "epss_percentile": 0.00044}, "CVE-2022-48482": {"epss_score": 0.00761, "epss_percentile": 0.72822}, "CVE-2022-48483": {"epss_score": 0.00316, "epss_percentile": 0.54286}, "CVE-2022-48486": {"epss_score": 0.00073, "epss_percentile": 0.22574}, "CVE-2022-48487": {"epss_score": 0.00074, "epss_percentile": 0.2271}, "CVE-2022-48488": {"epss_score": 0.00023, "epss_percentile": 0.05629}, "CVE-2022-48489": {"epss_score": 0.00083, "epss_percentile": 0.24706}, "CVE-2022-48490": {"epss_score": 0.00073, "epss_percentile": 0.22574}, "CVE-2022-48491": {"epss_score": 0.00067, "epss_percentile": 0.21}, "CVE-2022-48492": {"epss_score": 0.00063, "epss_percentile": 0.20084}, "CVE-2022-48493": {"epss_score": 0.00063, "epss_percentile": 0.20084}, "CVE-2022-48494": {"epss_score": 0.00062, "epss_percentile": 0.1975}, "CVE-2022-48495": {"epss_score": 0.00074, "epss_percentile": 0.22869}, "CVE-2022-48496": {"epss_score": 0.00062, "epss_percentile": 0.1975}, "CVE-2022-48497": {"epss_score": 0.00073, "epss_percentile": 0.22574}, "CVE-2022-48498": {"epss_score": 0.00063, "epss_percentile": 0.20084}, "CVE-2022-48499": {"epss_score": 0.00063, "epss_percentile": 0.20084}, "CVE-2022-48500": {"epss_score": 0.00063, "epss_percentile": 0.20084}, "CVE-2022-48501": {"epss_score": 0.00095, "epss_percentile": 0.27231}, "CVE-2022-48502": {"epss_score": 0.00011, "epss_percentile": 0.01097}, "CVE-2022-48503": {"epss_score": 0.00325, "epss_percentile": 0.55006}, "CVE-2022-48504": {"epss_score": 0.00139, "epss_percentile": 0.34626}, "CVE-2022-48505": {"epss_score": 0.00045, "epss_percentile": 0.13911}, "CVE-2022-48506": {"epss_score": 0.00063, "epss_percentile": 0.19945}, "CVE-2022-48507": {"epss_score": 0.00048, "epss_percentile": 0.14941}, "CVE-2022-48508": {"epss_score": 0.00054, "epss_percentile": 0.17278}, "CVE-2022-48509": {"epss_score": 0.00076, "epss_percentile": 0.23091}, "CVE-2022-48510": {"epss_score": 0.00121, "epss_percentile": 0.3194}, "CVE-2022-48511": {"epss_score": 0.00121, "epss_percentile": 0.32011}, "CVE-2022-48512": {"epss_score": 0.00104, "epss_percentile": 0.29161}, "CVE-2022-48513": {"epss_score": 0.00043, "epss_percentile": 0.13008}, "CVE-2022-48514": {"epss_score": 0.00107, "epss_percentile": 0.29662}, "CVE-2022-48515": {"epss_score": 0.0008, "epss_percentile": 0.24193}, "CVE-2022-48516": {"epss_score": 0.00094, "epss_percentile": 0.2698}, "CVE-2022-48517": {"epss_score": 0.00084, "epss_percentile": 0.24885}, "CVE-2022-48518": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2022-48519": {"epss_score": 0.00091, "epss_percentile": 0.264}, "CVE-2022-48520": {"epss_score": 0.0012, "epss_percentile": 0.31692}, "CVE-2022-48521": {"epss_score": 0.00137, "epss_percentile": 0.34284}, "CVE-2022-48522": {"epss_score": 0.13298, "epss_percentile": 0.93925}, "CVE-2022-48538": {"epss_score": 0.0006, "epss_percentile": 0.19109}, "CVE-2022-48541": {"epss_score": 0.00697, "epss_percentile": 0.71401}, "CVE-2022-48545": {"epss_score": 0.00064, "epss_percentile": 0.20142}, "CVE-2022-48547": {"epss_score": 0.00597, "epss_percentile": 0.68753}, "CVE-2022-48554": {"epss_score": 0.00023, "epss_percentile": 0.05429}, "CVE-2022-48560": {"epss_score": 0.00187, "epss_percentile": 0.40702}, "CVE-2022-48564": {"epss_score": 0.00107, "epss_percentile": 0.29698}, "CVE-2022-48565": {"epss_score": 0.07274, "epss_percentile": 0.91378}, "CVE-2022-48566": {"epss_score": 0.0009, "epss_percentile": 0.26155}, "CVE-2022-48570": {"epss_score": 0.00523, "epss_percentile": 0.66302}, "CVE-2022-48571": {"epss_score": 0.0006, "epss_percentile": 0.19031}, "CVE-2022-48577": {"epss_score": 0.0015, "epss_percentile": 0.36112}, "CVE-2022-48578": {"epss_score": 0.00171, "epss_percentile": 0.38794}, "CVE-2022-48579": {"epss_score": 0.00076, "epss_percentile": 0.23181}, "CVE-2022-48580": {"epss_score": 0.0041, "epss_percentile": 0.60833}, "CVE-2022-48581": {"epss_score": 0.0041, "epss_percentile": 0.60833}, "CVE-2022-48582": {"epss_score": 0.0041, "epss_percentile": 0.60833}, "CVE-2022-48583": {"epss_score": 0.0041, "epss_percentile": 0.60833}, "CVE-2022-48584": {"epss_score": 0.0041, "epss_percentile": 0.60833}, "CVE-2022-48585": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48586": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48587": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48588": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48589": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48590": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48591": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48592": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48593": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48594": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48595": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48596": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48597": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48598": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48599": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48600": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48601": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48602": {"epss_score": 0.00069, "epss_percentile": 0.21594}, "CVE-2022-48603": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48604": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2022-48605": {"epss_score": 0.00193, "epss_percentile": 0.41454}, "CVE-2022-48606": {"epss_score": 0.00214, "epss_percentile": 0.43988}, "CVE-2022-48610": {"epss_score": 0.00026, "epss_percentile": 0.06383}, "CVE-2022-48611": {"epss_score": 0.00061, "epss_percentile": 0.1937}, "CVE-2022-48612": {"epss_score": 0.00117, "epss_percentile": 0.31299}, "CVE-2022-48613": {"epss_score": 0.00042, "epss_percentile": 0.12578}, "CVE-2022-48614": {"epss_score": 0.00137, "epss_percentile": 0.34266}, "CVE-2022-48615": {"epss_score": 0.00022, "epss_percentile": 0.05231}, "CVE-2022-48616": {"epss_score": 0.00198, "epss_percentile": 0.41973}, "CVE-2022-48618": {"epss_score": 0.00134, "epss_percentile": 0.33822}, "CVE-2022-48619": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2022-48620": {"epss_score": 0.00803, "epss_percentile": 0.73594}, "CVE-2022-48621": {"epss_score": 0.00042, "epss_percentile": 0.1279}, "CVE-2022-48622": {"epss_score": 0.00077, "epss_percentile": 0.23462}, "CVE-2022-48623": {"epss_score": 0.0008, "epss_percentile": 0.24066}, "CVE-2022-48624": {"epss_score": 0.00366, "epss_percentile": 0.58026}, "CVE-2022-48625": {"epss_score": 0.00177, "epss_percentile": 0.39582}, "CVE-2022-48626": {"epss_score": 0.00015, "epss_percentile": 0.0253}, "CVE-2022-48627": {"epss_score": 8e-05, "epss_percentile": 0.00497}, "CVE-2022-48628": {"epss_score": 8e-05, "epss_percentile": 0.00578}, "CVE-2022-48629": {"epss_score": 0.00015, "epss_percentile": 0.0223}, "CVE-2022-48630": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2022-48631": {"epss_score": 0.00012, "epss_percentile": 0.01388}, "CVE-2022-48632": {"epss_score": 0.00016, "epss_percentile": 0.02639}, "CVE-2022-48633": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2022-48634": {"epss_score": 0.00011, "epss_percentile": 0.01097}, "CVE-2022-48635": {"epss_score": 7e-05, "epss_percentile": 0.0033}, "CVE-2022-48636": {"epss_score": 8e-05, "epss_percentile": 0.00538}, "CVE-2022-48637": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2022-48638": {"epss_score": 0.00018, "epss_percentile": 0.03907}, "CVE-2022-48639": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2022-48640": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2022-48641": {"epss_score": 0.00014, "epss_percentile": 0.02023}, "CVE-2022-48642": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2022-48643": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2022-48644": {"epss_score": 0.00011, "epss_percentile": 0.01009}, "CVE-2022-48645": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2022-48646": {"epss_score": 9e-05, "epss_percentile": 0.00711}, "CVE-2022-48647": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2022-48648": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2022-48649": {"epss_score": 0.00019, "epss_percentile": 0.04293}, "CVE-2022-48650": {"epss_score": 0.00011, "epss_percentile": 0.01087}, "CVE-2022-48651": {"epss_score": 4e-05, "epss_percentile": 0.00169}, "CVE-2022-48652": {"epss_score": 0.00011, "epss_percentile": 0.0099}, "CVE-2022-48653": {"epss_score": 4e-05, "epss_percentile": 0.00137}, "CVE-2022-48654": {"epss_score": 0.0002, "epss_percentile": 0.04441}, "CVE-2022-48655": {"epss_score": 0.0005, "epss_percentile": 0.15721}, "CVE-2022-48656": {"epss_score": 0.00017, "epss_percentile": 0.03104}, "CVE-2022-48657": {"epss_score": 0.0002, "epss_percentile": 0.04633}, "CVE-2022-48658": {"epss_score": 0.0002, "epss_percentile": 0.04633}, "CVE-2022-48659": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2022-48660": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2022-48661": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2022-48662": {"epss_score": 0.00016, "epss_percentile": 0.0273}, "CVE-2022-48663": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2022-48664": {"epss_score": 0.0001, "epss_percentile": 0.00789}, "CVE-2022-48665": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2022-48666": {"epss_score": 0.00015, "epss_percentile": 0.02161}, "CVE-2022-48667": {"epss_score": 0.00017, "epss_percentile": 0.03376}, "CVE-2022-48668": {"epss_score": 0.00017, "epss_percentile": 0.03376}, "CVE-2022-48669": {"epss_score": 9e-05, "epss_percentile": 0.00742}, "CVE-2022-48670": {"epss_score": 0.00014, "epss_percentile": 0.0201}, "CVE-2022-48671": {"epss_score": 7e-05, "epss_percentile": 0.00341}, "CVE-2022-48672": {"epss_score": 0.00015, "epss_percentile": 0.02413}, "CVE-2022-48673": {"epss_score": 9e-05, "epss_percentile": 0.0072}, "CVE-2022-48674": {"epss_score": 9e-05, "epss_percentile": 0.0071}, "CVE-2022-48675": {"epss_score": 8e-05, "epss_percentile": 0.00563}, "CVE-2022-48681": {"epss_score": 0.00082, "epss_percentile": 0.24428}, "CVE-2022-48682": {"epss_score": 0.00041, "epss_percentile": 0.12304}, "CVE-2022-48683": {"epss_score": 0.00114, "epss_percentile": 0.3078}, "CVE-2022-48684": {"epss_score": 0.0026, "epss_percentile": 0.49218}, "CVE-2022-48685": {"epss_score": 0.00041, "epss_percentile": 0.12212}, "CVE-2022-48686": {"epss_score": 0.00017, "epss_percentile": 0.03306}, "CVE-2022-48687": {"epss_score": 8e-05, "epss_percentile": 0.00523}, "CVE-2022-48688": {"epss_score": 8e-05, "epss_percentile": 0.0059}, "CVE-2022-48689": {"epss_score": 0.00015, "epss_percentile": 0.02158}, "CVE-2022-48690": {"epss_score": 0.00017, "epss_percentile": 0.03154}, "CVE-2022-48691": {"epss_score": 0.00018, "epss_percentile": 0.03686}, "CVE-2022-48692": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2022-48693": {"epss_score": 8e-05, "epss_percentile": 0.00576}, "CVE-2022-48694": {"epss_score": 0.00015, "epss_percentile": 0.0234}, "CVE-2022-48695": {"epss_score": 0.00014, "epss_percentile": 0.02118}, "CVE-2022-48696": {"epss_score": 0.00016, "epss_percentile": 0.02793}, "CVE-2022-48697": {"epss_score": 0.00015, "epss_percentile": 0.02243}, "CVE-2022-48698": {"epss_score": 0.00018, "epss_percentile": 0.03944}, "CVE-2022-48699": {"epss_score": 0.0001, "epss_percentile": 0.00915}, "CVE-2022-48701": {"epss_score": 9e-05, "epss_percentile": 0.00714}, "CVE-2022-48702": {"epss_score": 0.00014, "epss_percentile": 0.02118}, "CVE-2022-48703": {"epss_score": 8e-05, "epss_percentile": 0.00578}, "CVE-2022-48704": {"epss_score": 8e-05, "epss_percentile": 0.00538}, "CVE-2022-48705": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2022-48706": {"epss_score": 8e-05, "epss_percentile": 0.0051}, "CVE-2022-48707": {"epss_score": 0.00107, "epss_percentile": 0.29649}, "CVE-2022-48708": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2022-48709": {"epss_score": 0.0002, "epss_percentile": 0.04499}, "CVE-2022-48710": {"epss_score": 0.00013, "epss_percentile": 0.01594}, "CVE-2022-48711": {"epss_score": 0.00014, "epss_percentile": 0.01988}, "CVE-2022-48712": {"epss_score": 0.00038, "epss_percentile": 0.11289}, "CVE-2022-48713": {"epss_score": 0.00053, "epss_percentile": 0.16836}, "CVE-2022-48714": {"epss_score": 0.00034, "epss_percentile": 0.09453}, "CVE-2022-48715": {"epss_score": 0.00025, "epss_percentile": 0.06205}, "CVE-2022-48716": {"epss_score": 0.00106, "epss_percentile": 0.29406}, "CVE-2022-48717": {"epss_score": 0.00035, "epss_percentile": 0.09808}, "CVE-2022-48718": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2022-48719": {"epss_score": 0.00024, "epss_percentile": 0.05884}, "CVE-2022-48720": {"epss_score": 0.00018, "epss_percentile": 0.03894}, "CVE-2022-48721": {"epss_score": 0.00033, "epss_percentile": 0.09174}, "CVE-2022-48722": {"epss_score": 0.00026, "epss_percentile": 0.06453}, "CVE-2022-48723": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2022-48724": {"epss_score": 0.00014, "epss_percentile": 0.02023}, "CVE-2022-48725": {"epss_score": 0.00045, "epss_percentile": 0.13907}, "CVE-2022-48726": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2022-48727": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2022-48728": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2022-48729": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2022-48730": {"epss_score": 0.00021, "epss_percentile": 0.04718}, "CVE-2022-48731": {"epss_score": 0.00017, "epss_percentile": 0.03248}, "CVE-2022-48732": {"epss_score": 0.00016, "epss_percentile": 0.03029}, "CVE-2022-48733": {"epss_score": 0.00012, "epss_percentile": 0.01195}, "CVE-2022-48734": {"epss_score": 0.00015, "epss_percentile": 0.0215}, "CVE-2022-48735": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2022-48738": {"epss_score": 0.00014, "epss_percentile": 0.01868}, "CVE-2022-48739": {"epss_score": 0.00018, "epss_percentile": 0.04029}, "CVE-2022-48740": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2022-48741": {"epss_score": 0.00047, "epss_percentile": 0.14871}, "CVE-2022-48742": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2022-48743": {"epss_score": 6e-05, "epss_percentile": 0.00303}, "CVE-2022-48744": {"epss_score": 0.00018, "epss_percentile": 0.0356}, "CVE-2022-48745": {"epss_score": 0.00027, "epss_percentile": 0.06879}, "CVE-2022-48746": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2022-48747": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2022-48748": {"epss_score": 0.00031, "epss_percentile": 0.08466}, "CVE-2022-48749": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2022-48750": {"epss_score": 0.00023, "epss_percentile": 0.05468}, "CVE-2022-48751": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2022-48752": {"epss_score": 0.00033, "epss_percentile": 0.09174}, "CVE-2022-48753": {"epss_score": 0.00029, "epss_percentile": 0.07928}, "CVE-2022-48754": {"epss_score": 0.00023, "epss_percentile": 0.05622}, "CVE-2022-48755": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2022-48756": {"epss_score": 0.00026, "epss_percentile": 0.06588}, "CVE-2022-48757": {"epss_score": 0.00012, "epss_percentile": 0.01425}, "CVE-2022-48758": {"epss_score": 0.00016, "epss_percentile": 0.02617}, "CVE-2022-48759": {"epss_score": 0.00027, "epss_percentile": 0.06765}, "CVE-2022-48760": {"epss_score": 0.0001, "epss_percentile": 0.00911}, "CVE-2022-48761": {"epss_score": 0.00033, "epss_percentile": 0.09391}, "CVE-2022-48762": {"epss_score": 0.00047, "epss_percentile": 0.1491}, "CVE-2022-48763": {"epss_score": 0.00032, "epss_percentile": 0.09096}, "CVE-2022-48764": {"epss_score": 0.0003, "epss_percentile": 0.08195}, "CVE-2022-48765": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2022-48766": {"epss_score": 0.00017, "epss_percentile": 0.03208}, "CVE-2022-48767": {"epss_score": 0.00033, "epss_percentile": 0.09169}, "CVE-2022-48768": {"epss_score": 0.00035, "epss_percentile": 0.09826}, "CVE-2022-48769": {"epss_score": 0.00033, "epss_percentile": 0.09174}, "CVE-2022-48770": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2022-48771": {"epss_score": 0.00028, "epss_percentile": 0.07241}, "CVE-2022-48772": {"epss_score": 0.0001, "epss_percentile": 0.0076}, "CVE-2022-48773": {"epss_score": 8e-05, "epss_percentile": 0.00564}, "CVE-2022-48774": {"epss_score": 0.00026, "epss_percentile": 0.06574}, "CVE-2022-48775": {"epss_score": 8e-05, "epss_percentile": 0.00495}, "CVE-2022-48776": {"epss_score": 0.00027, "epss_percentile": 0.06752}, "CVE-2022-48777": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2022-48778": {"epss_score": 0.00022, "epss_percentile": 0.05042}, "CVE-2022-48779": {"epss_score": 0.00018, "epss_percentile": 0.0356}, "CVE-2022-48780": {"epss_score": 0.00018, "epss_percentile": 0.03893}, "CVE-2022-48781": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2022-48782": {"epss_score": 0.00036, "epss_percentile": 0.10555}, "CVE-2022-48783": {"epss_score": 0.00019, "epss_percentile": 0.0408}, "CVE-2022-48784": {"epss_score": 0.00014, "epss_percentile": 0.01892}, "CVE-2022-48785": {"epss_score": 0.00014, "epss_percentile": 0.02017}, "CVE-2022-48786": {"epss_score": 8e-05, "epss_percentile": 0.00538}, "CVE-2022-48787": {"epss_score": 0.00016, "epss_percentile": 0.02793}, "CVE-2022-48788": {"epss_score": 0.00012, "epss_percentile": 0.01223}, "CVE-2022-48789": {"epss_score": 0.00021, "epss_percentile": 0.04945}, "CVE-2022-48790": {"epss_score": 0.00012, "epss_percentile": 0.01223}, "CVE-2022-48791": {"epss_score": 0.00012, "epss_percentile": 0.01184}, "CVE-2022-48792": {"epss_score": 0.00012, "epss_percentile": 0.01184}, "CVE-2022-48793": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2022-48794": {"epss_score": 0.00023, "epss_percentile": 0.05523}, "CVE-2022-48795": {"epss_score": 0.00028, "epss_percentile": 0.07241}, "CVE-2022-48796": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2022-48797": {"epss_score": 0.00018, "epss_percentile": 0.03893}, "CVE-2022-48798": {"epss_score": 0.00015, "epss_percentile": 0.02598}, "CVE-2022-48799": {"epss_score": 0.00014, "epss_percentile": 0.02037}, "CVE-2022-48800": {"epss_score": 0.00013, "epss_percentile": 0.01612}, "CVE-2022-48801": {"epss_score": 0.0002, "epss_percentile": 0.04424}, "CVE-2022-48802": {"epss_score": 0.0001, "epss_percentile": 0.00813}, "CVE-2022-48803": {"epss_score": 0.00011, "epss_percentile": 0.00952}, "CVE-2022-48804": {"epss_score": 8e-05, "epss_percentile": 0.00581}, "CVE-2022-48805": {"epss_score": 0.00014, "epss_percentile": 0.01923}, "CVE-2022-48806": {"epss_score": 0.00035, "epss_percentile": 0.09814}, "CVE-2022-48807": {"epss_score": 0.00018, "epss_percentile": 0.03893}, "CVE-2022-48808": {"epss_score": 0.00028, "epss_percentile": 0.07283}, "CVE-2022-48809": {"epss_score": 0.00015, "epss_percentile": 0.02127}, "CVE-2022-48810": {"epss_score": 0.00019, "epss_percentile": 0.0437}, "CVE-2022-48811": {"epss_score": 0.00028, "epss_percentile": 0.07512}, "CVE-2022-48812": {"epss_score": 0.00033, "epss_percentile": 0.09174}, "CVE-2022-48813": {"epss_score": 0.00033, "epss_percentile": 0.09174}, "CVE-2022-48814": {"epss_score": 0.00033, "epss_percentile": 0.09384}, "CVE-2022-48815": {"epss_score": 0.00033, "epss_percentile": 0.09174}, "CVE-2022-48816": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2022-48817": {"epss_score": 0.00033, "epss_percentile": 0.09384}, "CVE-2022-48818": {"epss_score": 0.00033, "epss_percentile": 0.09384}, "CVE-2022-48819": {"epss_score": 0.00033, "epss_percentile": 0.09298}, "CVE-2022-48820": {"epss_score": 0.00034, "epss_percentile": 0.09453}, "CVE-2022-48821": {"epss_score": 0.00047, "epss_percentile": 0.14499}, "CVE-2022-48822": {"epss_score": 0.00035, "epss_percentile": 0.09808}, "CVE-2022-48823": {"epss_score": 0.00029, "epss_percentile": 0.07688}, "CVE-2022-48824": {"epss_score": 0.00036, "epss_percentile": 0.10372}, "CVE-2022-48825": {"epss_score": 0.00033, "epss_percentile": 0.09384}, "CVE-2022-48826": {"epss_score": 0.00023, "epss_percentile": 0.05636}, "CVE-2022-48827": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2022-48828": {"epss_score": 0.00021, "epss_percentile": 0.04771}, "CVE-2022-48829": {"epss_score": 0.00036, "epss_percentile": 0.10292}, "CVE-2022-48830": {"epss_score": 0.00022, "epss_percentile": 0.05149}, "CVE-2022-48831": {"epss_score": 0.00033, "epss_percentile": 0.09384}, "CVE-2022-48832": {"epss_score": 0.00031, "epss_percentile": 0.08709}, "CVE-2022-48833": {"epss_score": 0.00021, "epss_percentile": 0.04925}, "CVE-2022-48834": {"epss_score": 0.00022, "epss_percentile": 0.05042}, "CVE-2022-48835": {"epss_score": 0.00015, "epss_percentile": 0.02369}, "CVE-2022-48836": {"epss_score": 7e-05, "epss_percentile": 0.00375}, "CVE-2022-48837": {"epss_score": 0.00015, "epss_percentile": 0.02475}, "CVE-2022-48838": {"epss_score": 0.00012, "epss_percentile": 0.01144}, "CVE-2022-48839": {"epss_score": 7e-05, "epss_percentile": 0.00366}, "CVE-2022-48840": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2022-48841": {"epss_score": 9e-05, "epss_percentile": 0.00604}, "CVE-2022-48842": {"epss_score": 8e-05, "epss_percentile": 0.00481}, "CVE-2022-48844": {"epss_score": 0.0003, "epss_percentile": 0.08156}, "CVE-2022-48845": {"epss_score": 0.00023, "epss_percentile": 0.05449}, "CVE-2022-48846": {"epss_score": 0.00032, "epss_percentile": 0.09096}, "CVE-2022-48847": {"epss_score": 0.00034, "epss_percentile": 0.09659}, "CVE-2022-48848": {"epss_score": 0.00049, "epss_percentile": 0.15627}, "CVE-2022-48849": {"epss_score": 6e-05, "epss_percentile": 0.00288}, "CVE-2022-48850": {"epss_score": 0.00023, "epss_percentile": 0.05449}, "CVE-2022-48851": {"epss_score": 0.00028, "epss_percentile": 0.07354}, "CVE-2022-48852": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-48853": {"epss_score": 0.00013, "epss_percentile": 0.01459}, "CVE-2022-48854": {"epss_score": 0.00073, "epss_percentile": 0.22662}, "CVE-2022-48855": {"epss_score": 0.00022, "epss_percentile": 0.0503}, "CVE-2022-48856": {"epss_score": 0.00022, "epss_percentile": 0.05162}, "CVE-2022-48857": {"epss_score": 0.00021, "epss_percentile": 0.04832}, "CVE-2022-48858": {"epss_score": 0.00035, "epss_percentile": 0.09927}, "CVE-2022-48859": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2022-48860": {"epss_score": 0.00025, "epss_percentile": 0.06148}, "CVE-2022-48861": {"epss_score": 0.00061, "epss_percentile": 0.19264}, "CVE-2022-48862": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2022-48863": {"epss_score": 0.00019, "epss_percentile": 0.04221}, "CVE-2022-48864": {"epss_score": 0.00023, "epss_percentile": 0.0535}, "CVE-2022-48865": {"epss_score": 0.00019, "epss_percentile": 0.0429}, "CVE-2022-48866": {"epss_score": 0.00019, "epss_percentile": 0.04211}, "CVE-2022-48867": {"epss_score": 0.00015, "epss_percentile": 0.02249}, "CVE-2022-48868": {"epss_score": 9e-05, "epss_percentile": 0.00662}, "CVE-2022-48869": {"epss_score": 0.00016, "epss_percentile": 0.02806}, "CVE-2022-48870": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2022-48871": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2022-48872": {"epss_score": 0.00017, "epss_percentile": 0.03374}, "CVE-2022-48873": {"epss_score": 0.00022, "epss_percentile": 0.0496}, "CVE-2022-48874": {"epss_score": 0.0002, "epss_percentile": 0.04675}, "CVE-2022-48875": {"epss_score": 0.00015, "epss_percentile": 0.02147}, "CVE-2022-48876": {"epss_score": 0.00037, "epss_percentile": 0.10794}, "CVE-2022-48877": {"epss_score": 0.00015, "epss_percentile": 0.02588}, "CVE-2022-48878": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2022-48879": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2022-48880": {"epss_score": 0.00015, "epss_percentile": 0.02598}, "CVE-2022-48881": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2022-48882": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2022-48883": {"epss_score": 0.00015, "epss_percentile": 0.0229}, "CVE-2022-48884": {"epss_score": 0.0003, "epss_percentile": 0.08143}, "CVE-2022-48885": {"epss_score": 0.00014, "epss_percentile": 0.02025}, "CVE-2022-48886": {"epss_score": 0.0003, "epss_percentile": 0.08053}, "CVE-2022-48887": {"epss_score": 0.00013, "epss_percentile": 0.01562}, "CVE-2022-48888": {"epss_score": 0.0003, "epss_percentile": 0.08015}, "CVE-2022-48889": {"epss_score": 0.00014, "epss_percentile": 0.02025}, "CVE-2022-48890": {"epss_score": 0.00014, "epss_percentile": 0.02025}, "CVE-2022-48891": {"epss_score": 0.00011, "epss_percentile": 0.01058}, "CVE-2022-48892": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2022-48893": {"epss_score": 8e-05, "epss_percentile": 0.00506}, "CVE-2022-48894": {"epss_score": 0.00018, "epss_percentile": 0.03657}, "CVE-2022-48895": {"epss_score": 6e-05, "epss_percentile": 0.00241}, "CVE-2022-48896": {"epss_score": 0.00016, "epss_percentile": 0.02806}, "CVE-2022-48897": {"epss_score": 0.00037, "epss_percentile": 0.10721}, "CVE-2022-48898": {"epss_score": 0.00012, "epss_percentile": 0.01237}, "CVE-2022-48899": {"epss_score": 0.00012, "epss_percentile": 0.01288}, "CVE-2022-48901": {"epss_score": 0.00015, "epss_percentile": 0.02302}, "CVE-2022-48902": {"epss_score": 0.0003, "epss_percentile": 0.08225}, "CVE-2022-48903": {"epss_score": 0.00028, "epss_percentile": 0.07283}, "CVE-2022-48904": {"epss_score": 0.00028, "epss_percentile": 0.07261}, "CVE-2022-48905": {"epss_score": 0.00022, "epss_percentile": 0.05162}, "CVE-2022-48906": {"epss_score": 0.00028, "epss_percentile": 0.07283}, "CVE-2022-48907": {"epss_score": 0.00027, "epss_percentile": 0.0717}, "CVE-2022-48908": {"epss_score": 0.00035, "epss_percentile": 0.09927}, "CVE-2022-48909": {"epss_score": 0.00033, "epss_percentile": 0.09293}, "CVE-2022-48910": {"epss_score": 0.00021, "epss_percentile": 0.04893}, "CVE-2022-48911": {"epss_score": 0.00012, "epss_percentile": 0.01358}, "CVE-2022-48912": {"epss_score": 0.00023, "epss_percentile": 0.05627}, "CVE-2022-48913": {"epss_score": 0.00029, "epss_percentile": 0.07728}, "CVE-2022-48914": {"epss_score": 0.00022, "epss_percentile": 0.05175}, "CVE-2022-48915": {"epss_score": 0.00028, "epss_percentile": 0.07332}, "CVE-2022-48916": {"epss_score": 0.00028, "epss_percentile": 0.07283}, "CVE-2022-48918": {"epss_score": 0.00028, "epss_percentile": 0.07332}, "CVE-2022-48919": {"epss_score": 0.0002, "epss_percentile": 0.04474}, "CVE-2022-48920": {"epss_score": 0.0002, "epss_percentile": 0.04523}, "CVE-2022-48921": {"epss_score": 0.00022, "epss_percentile": 0.04964}, "CVE-2022-48922": {"epss_score": 0.00033, "epss_percentile": 0.09174}, "CVE-2022-48923": {"epss_score": 0.00015, "epss_percentile": 0.0227}, "CVE-2022-48924": {"epss_score": 0.00029, "epss_percentile": 0.07924}, "CVE-2022-48925": {"epss_score": 0.00023, "epss_percentile": 0.05476}, "CVE-2022-48926": {"epss_score": 0.00028, "epss_percentile": 0.07354}, "CVE-2022-48927": {"epss_score": 0.00032, "epss_percentile": 0.09042}, "CVE-2022-48928": {"epss_score": 0.00021, "epss_percentile": 0.04832}, "CVE-2022-48929": {"epss_score": 0.00028, "epss_percentile": 0.07261}, "CVE-2022-48930": {"epss_score": 0.00017, "epss_percentile": 0.03091}, "CVE-2022-48931": {"epss_score": 0.00015, "epss_percentile": 0.02432}, "CVE-2022-48932": {"epss_score": 0.00026, "epss_percentile": 0.0652}, "CVE-2022-48933": {"epss_score": 0.00017, "epss_percentile": 0.03268}, "CVE-2022-48934": {"epss_score": 0.00029, "epss_percentile": 0.07818}, "CVE-2022-48935": {"epss_score": 0.00015, "epss_percentile": 0.0227}, "CVE-2022-48937": {"epss_score": 0.00022, "epss_percentile": 0.05061}, "CVE-2022-48938": {"epss_score": 0.00012, "epss_percentile": 0.01178}, "CVE-2022-48939": {"epss_score": 8e-05, "epss_percentile": 0.00542}, "CVE-2022-48940": {"epss_score": 0.00027, "epss_percentile": 0.0717}, "CVE-2022-48941": {"epss_score": 0.00023, "epss_percentile": 0.05617}, "CVE-2022-48942": {"epss_score": 0.00028, "epss_percentile": 0.07283}, "CVE-2022-48943": {"epss_score": 0.00021, "epss_percentile": 0.04902}, "CVE-2022-48944": {"epss_score": 0.00016, "epss_percentile": 0.02897}, "CVE-2022-48945": {"epss_score": 0.00014, "epss_percentile": 0.0177}, "CVE-2022-48946": {"epss_score": 7e-05, "epss_percentile": 0.00376}, "CVE-2022-48947": {"epss_score": 7e-05, "epss_percentile": 0.00327}, "CVE-2022-48948": {"epss_score": 0.00012, "epss_percentile": 0.01262}, "CVE-2022-48949": {"epss_score": 7e-05, "epss_percentile": 0.00343}, "CVE-2022-48950": {"epss_score": 0.00045, "epss_percentile": 0.13772}, "CVE-2022-48951": {"epss_score": 0.00012, "epss_percentile": 0.0114}, "CVE-2022-48952": {"epss_score": 0.00022, "epss_percentile": 0.05282}, "CVE-2022-48953": {"epss_score": 9e-05, "epss_percentile": 0.00736}, "CVE-2022-48954": {"epss_score": 0.00013, "epss_percentile": 0.01666}, "CVE-2022-48955": {"epss_score": 9e-05, "epss_percentile": 0.00722}, "CVE-2022-48956": {"epss_score": 0.00013, "epss_percentile": 0.01606}, "CVE-2022-48957": {"epss_score": 0.00019, "epss_percentile": 0.04186}, "CVE-2022-48958": {"epss_score": 8e-05, "epss_percentile": 0.00571}, "CVE-2022-48959": {"epss_score": 9e-05, "epss_percentile": 0.00722}, "CVE-2022-48960": {"epss_score": 0.00013, "epss_percentile": 0.0148}, "CVE-2022-48961": {"epss_score": 9e-05, "epss_percentile": 0.00736}, "CVE-2022-48962": {"epss_score": 0.00013, "epss_percentile": 0.0148}, "CVE-2022-48963": {"epss_score": 0.00128, "epss_percentile": 0.33021}, "CVE-2022-48964": {"epss_score": 0.00038, "epss_percentile": 0.11317}, "CVE-2022-48965": {"epss_score": 0.00145, "epss_percentile": 0.35415}, "CVE-2022-48966": {"epss_score": 8e-05, "epss_percentile": 0.00526}, "CVE-2022-48967": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-48968": {"epss_score": 9e-05, "epss_percentile": 0.00722}, "CVE-2022-48969": {"epss_score": 7e-05, "epss_percentile": 0.00351}, "CVE-2022-48970": {"epss_score": 0.0001, "epss_percentile": 0.00754}, "CVE-2022-48971": {"epss_score": 7e-05, "epss_percentile": 0.00445}, "CVE-2022-48972": {"epss_score": 7e-05, "epss_percentile": 0.00399}, "CVE-2022-48973": {"epss_score": 7e-05, "epss_percentile": 0.00399}, "CVE-2022-48974": {"epss_score": 0.00057, "epss_percentile": 0.18184}, "CVE-2022-48975": {"epss_score": 9e-05, "epss_percentile": 0.00722}, "CVE-2022-48976": {"epss_score": 0.0001, "epss_percentile": 0.00884}, "CVE-2022-48977": {"epss_score": 0.0001, "epss_percentile": 0.00754}, "CVE-2022-48978": {"epss_score": 7e-05, "epss_percentile": 0.00327}, "CVE-2022-48979": {"epss_score": 8e-05, "epss_percentile": 0.00516}, "CVE-2022-48980": {"epss_score": 0.00017, "epss_percentile": 0.03203}, "CVE-2022-48981": {"epss_score": 0.00017, "epss_percentile": 0.0333}, "CVE-2022-48982": {"epss_score": 0.00044, "epss_percentile": 0.13662}, "CVE-2022-48983": {"epss_score": 0.00024, "epss_percentile": 0.05767}, "CVE-2022-48984": {"epss_score": 0.00128, "epss_percentile": 0.33021}, "CVE-2022-48985": {"epss_score": 0.00011, "epss_percentile": 0.01019}, "CVE-2022-48986": {"epss_score": 0.00023, "epss_percentile": 0.05403}, "CVE-2022-48987": {"epss_score": 7e-05, "epss_percentile": 0.00399}, "CVE-2022-48988": {"epss_score": 0.00013, "epss_percentile": 0.01606}, "CVE-2022-48989": {"epss_score": 0.00038, "epss_percentile": 0.11098}, "CVE-2022-48990": {"epss_score": 0.00011, "epss_percentile": 0.00981}, "CVE-2022-48991": {"epss_score": 0.00013, "epss_percentile": 0.01454}, "CVE-2022-48992": {"epss_score": 7e-05, "epss_percentile": 0.00327}, "CVE-2022-48994": {"epss_score": 7e-05, "epss_percentile": 0.00327}, "CVE-2022-48995": {"epss_score": 9e-05, "epss_percentile": 0.00722}, "CVE-2022-48996": {"epss_score": 0.00021, "epss_percentile": 0.04866}, "CVE-2022-48997": {"epss_score": 0.0001, "epss_percentile": 0.00754}, "CVE-2022-48998": {"epss_score": 0.00016, "epss_percentile": 0.02887}, "CVE-2022-48999": {"epss_score": 0.00017, "epss_percentile": 0.03493}, "CVE-2022-49000": {"epss_score": 9e-05, "epss_percentile": 0.00736}, "CVE-2022-49001": {"epss_score": 0.0006, "epss_percentile": 0.19144}, "CVE-2022-49002": {"epss_score": 7e-05, "epss_percentile": 0.00405}, "CVE-2022-49003": {"epss_score": 3e-05, "epss_percentile": 0.00084}, "CVE-2022-49004": {"epss_score": 0.00022, "epss_percentile": 0.05282}, "CVE-2022-49005": {"epss_score": 7e-05, "epss_percentile": 0.00399}, "CVE-2022-49006": {"epss_score": 0.0002, "epss_percentile": 0.04461}, "CVE-2022-49007": {"epss_score": 7e-05, "epss_percentile": 0.00327}, "CVE-2022-49008": {"epss_score": 0.00128, "epss_percentile": 0.33021}, "CVE-2022-49009": {"epss_score": 0.00099, "epss_percentile": 0.2835}, "CVE-2022-49010": {"epss_score": 7e-05, "epss_percentile": 0.00399}, "CVE-2022-49011": {"epss_score": 7e-05, "epss_percentile": 0.00388}, "CVE-2022-49012": {"epss_score": 9e-05, "epss_percentile": 0.00652}, "CVE-2022-49013": {"epss_score": 0.00023, "epss_percentile": 0.05459}, "CVE-2022-49014": {"epss_score": 0.00013, "epss_percentile": 0.01606}, "CVE-2022-49015": {"epss_score": 0.00013, "epss_percentile": 0.01454}, "CVE-2022-49016": {"epss_score": 9e-05, "epss_percentile": 0.00722}, "CVE-2022-49017": {"epss_score": 0.00017, "epss_percentile": 0.03203}, "CVE-2022-49018": {"epss_score": 0.00016, "epss_percentile": 0.03027}, "CVE-2022-49019": {"epss_score": 0.0001, "epss_percentile": 0.00754}, "CVE-2022-49020": {"epss_score": 8e-05, "epss_percentile": 0.00571}, "CVE-2022-49021": {"epss_score": 7e-05, "epss_percentile": 0.00327}, "CVE-2022-49022": {"epss_score": 0.00013, "epss_percentile": 0.01666}, "CVE-2022-49023": {"epss_score": 0.00016, "epss_percentile": 0.02662}, "CVE-2022-49024": {"epss_score": 9e-05, "epss_percentile": 0.00731}, "CVE-2022-49025": {"epss_score": 0.00017, "epss_percentile": 0.03395}, "CVE-2022-49026": {"epss_score": 0.00013, "epss_percentile": 0.01689}, "CVE-2022-49027": {"epss_score": 9e-05, "epss_percentile": 0.00683}, "CVE-2022-49028": {"epss_score": 9e-05, "epss_percentile": 0.00736}, "CVE-2022-49029": {"epss_score": 0.00012, "epss_percentile": 0.0114}, "CVE-2022-49030": {"epss_score": 0.00015, "epss_percentile": 0.02504}, "CVE-2022-49031": {"epss_score": 7e-05, "epss_percentile": 0.00407}, "CVE-2022-49032": {"epss_score": 7e-05, "epss_percentile": 0.00407}, "CVE-2022-49033": {"epss_score": 7e-05, "epss_percentile": 0.00357}, "CVE-2022-49034": {"epss_score": 0.00027, "epss_percentile": 0.06823}, "CVE-2022-49035": {"epss_score": 0.00028, "epss_percentile": 0.07487}, "CVE-2022-49037": {"epss_score": 0.00425, "epss_percentile": 0.61708}, "CVE-2022-49038": {"epss_score": 0.00121, "epss_percentile": 0.32004}, "CVE-2022-49039": {"epss_score": 0.00048, "epss_percentile": 0.14955}, "CVE-2022-49040": {"epss_score": 0.00071, "epss_percentile": 0.22199}, "CVE-2022-49041": {"epss_score": 0.00071, "epss_percentile": 0.22199}, "CVE-2022-49043": {"epss_score": 0.00028, "epss_percentile": 0.07265}, "CVE-2022-49044": {"epss_score": 0.00062, "epss_percentile": 0.19712}, "CVE-2022-49046": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49047": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2022-49048": {"epss_score": 0.00052, "epss_percentile": 0.16496}, "CVE-2022-49049": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49050": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49051": {"epss_score": 0.00071, "epss_percentile": 0.22136}, "CVE-2022-49052": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49053": {"epss_score": 0.00077, "epss_percentile": 0.23431}, "CVE-2022-49054": {"epss_score": 0.00025, "epss_percentile": 0.06272}, "CVE-2022-49055": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49057": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49058": {"epss_score": 0.00073, "epss_percentile": 0.22663}, "CVE-2022-49059": {"epss_score": 0.0002, "epss_percentile": 0.04609}, "CVE-2022-49060": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49061": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49062": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2022-49063": {"epss_score": 0.00039, "epss_percentile": 0.11642}, "CVE-2022-49064": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49065": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49066": {"epss_score": 0.00049, "epss_percentile": 0.15473}, "CVE-2022-49067": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49068": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49069": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49070": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49071": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49072": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49073": {"epss_score": 0.00053, "epss_percentile": 0.16835}, "CVE-2022-49074": {"epss_score": 0.00052, "epss_percentile": 0.16496}, "CVE-2022-49075": {"epss_score": 0.00049, "epss_percentile": 0.15473}, "CVE-2022-49076": {"epss_score": 0.00036, "epss_percentile": 0.10291}, "CVE-2022-49077": {"epss_score": 0.00052, "epss_percentile": 0.16627}, "CVE-2022-49078": {"epss_score": 0.00097, "epss_percentile": 0.27622}, "CVE-2022-49079": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2022-49080": {"epss_score": 0.00031, "epss_percentile": 0.08651}, "CVE-2022-49081": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49082": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49083": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49084": {"epss_score": 0.00052, "epss_percentile": 0.16496}, "CVE-2022-49085": {"epss_score": 0.0007, "epss_percentile": 0.21695}, "CVE-2022-49086": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49087": {"epss_score": 0.00053, "epss_percentile": 0.16835}, "CVE-2022-49088": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49089": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49090": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49091": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49092": {"epss_score": 0.00023, "epss_percentile": 0.05378}, "CVE-2022-49093": {"epss_score": 0.00045, "epss_percentile": 0.1381}, "CVE-2022-49094": {"epss_score": 0.00053, "epss_percentile": 0.16835}, "CVE-2022-49095": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49096": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49097": {"epss_score": 0.00045, "epss_percentile": 0.13733}, "CVE-2022-49098": {"epss_score": 0.00052, "epss_percentile": 0.16496}, "CVE-2022-49099": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49100": {"epss_score": 0.00052, "epss_percentile": 0.16627}, "CVE-2022-49102": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2022-49103": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49104": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49105": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49106": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2022-49107": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49108": {"epss_score": 0.00025, "epss_percentile": 0.06272}, "CVE-2022-49109": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49110": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2022-49111": {"epss_score": 0.00039, "epss_percentile": 0.11674}, "CVE-2022-49112": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49113": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49114": {"epss_score": 0.00065, "epss_percentile": 0.20607}, "CVE-2022-49115": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49116": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49117": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49118": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49119": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49120": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49121": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49122": {"epss_score": 0.00053, "epss_percentile": 0.16867}, "CVE-2022-49123": {"epss_score": 0.00025, "epss_percentile": 0.06239}, "CVE-2022-49124": {"epss_score": 0.00036, "epss_percentile": 0.10363}, "CVE-2022-49125": {"epss_score": 0.00032, "epss_percentile": 0.09028}, "CVE-2022-49126": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2022-49127": {"epss_score": 0.00064, "epss_percentile": 0.20323}, "CVE-2022-49128": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2022-49129": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49130": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49131": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49132": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49133": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49134": {"epss_score": 0.00032, "epss_percentile": 0.09028}, "CVE-2022-49135": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2022-49136": {"epss_score": 0.00036, "epss_percentile": 0.10314}, "CVE-2022-49137": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49138": {"epss_score": 0.00062, "epss_percentile": 0.19649}, "CVE-2022-49139": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49141": {"epss_score": 0.00052, "epss_percentile": 0.16409}, "CVE-2022-49142": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49144": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49145": {"epss_score": 0.00057, "epss_percentile": 0.18124}, "CVE-2022-49146": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49147": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49148": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49149": {"epss_score": 0.00027, "epss_percentile": 0.0708}, "CVE-2022-49150": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49151": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49152": {"epss_score": 0.00024, "epss_percentile": 0.0598}, "CVE-2022-49153": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49154": {"epss_score": 0.0003, "epss_percentile": 0.08238}, "CVE-2022-49155": {"epss_score": 0.00049, "epss_percentile": 0.15473}, "CVE-2022-49156": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49157": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2022-49158": {"epss_score": 0.00025, "epss_percentile": 0.06249}, "CVE-2022-49159": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49160": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49161": {"epss_score": 0.00052, "epss_percentile": 0.16409}, "CVE-2022-49162": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49163": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49164": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49165": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49166": {"epss_score": 0.00052, "epss_percentile": 0.16627}, "CVE-2022-49167": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49168": {"epss_score": 0.00013, "epss_percentile": 0.01477}, "CVE-2022-49169": {"epss_score": 0.00068, "epss_percentile": 0.21269}, "CVE-2022-49170": {"epss_score": 0.00036, "epss_percentile": 0.10291}, "CVE-2022-49171": {"epss_score": 0.00033, "epss_percentile": 0.09292}, "CVE-2022-49172": {"epss_score": 0.0003, "epss_percentile": 0.07986}, "CVE-2022-49173": {"epss_score": 0.00038, "epss_percentile": 0.11366}, "CVE-2022-49174": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49175": {"epss_score": 0.00052, "epss_percentile": 0.16627}, "CVE-2022-49176": {"epss_score": 0.0005, "epss_percentile": 0.15652}, "CVE-2022-49177": {"epss_score": 0.00032, "epss_percentile": 0.09028}, "CVE-2022-49178": {"epss_score": 0.00025, "epss_percentile": 0.06272}, "CVE-2022-49179": {"epss_score": 0.0005, "epss_percentile": 0.15652}, "CVE-2022-49180": {"epss_score": 0.00049, "epss_percentile": 0.15331}, "CVE-2022-49182": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49183": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49184": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49185": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49186": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2022-49187": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49188": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49189": {"epss_score": 0.00042, "epss_percentile": 0.12827}, "CVE-2022-49190": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49191": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49192": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49193": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49194": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49195": {"epss_score": 0.00068, "epss_percentile": 0.21269}, "CVE-2022-49196": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49197": {"epss_score": 0.00052, "epss_percentile": 0.16627}, "CVE-2022-49198": {"epss_score": 0.00068, "epss_percentile": 0.21269}, "CVE-2022-49199": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49200": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49201": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2022-49202": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49203": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49204": {"epss_score": 0.00052, "epss_percentile": 0.16496}, "CVE-2022-49205": {"epss_score": 0.00053, "epss_percentile": 0.16835}, "CVE-2022-49206": {"epss_score": 0.00052, "epss_percentile": 0.16496}, "CVE-2022-49207": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49208": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49209": {"epss_score": 0.00062, "epss_percentile": 0.19733}, "CVE-2022-49210": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49211": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49212": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49213": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49214": {"epss_score": 0.00043, "epss_percentile": 0.13312}, "CVE-2022-49215": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2022-49216": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49217": {"epss_score": 0.00033, "epss_percentile": 0.09232}, "CVE-2022-49218": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2022-49219": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49220": {"epss_score": 0.00052, "epss_percentile": 0.16496}, "CVE-2022-49221": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49222": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49223": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49224": {"epss_score": 0.00056, "epss_percentile": 0.17805}, "CVE-2022-49225": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49226": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49227": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49228": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49229": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49230": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49231": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49232": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49233": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49234": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2022-49235": {"epss_score": 0.00022, "epss_percentile": 0.04974}, "CVE-2022-49236": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49237": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49238": {"epss_score": 0.00046, "epss_percentile": 0.14467}, "CVE-2022-49239": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49240": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49241": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49242": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49243": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49244": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49245": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49246": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49247": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49248": {"epss_score": 0.00036, "epss_percentile": 0.10536}, "CVE-2022-49249": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49250": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49251": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49252": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49253": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49254": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49255": {"epss_score": 0.00042, "epss_percentile": 0.12827}, "CVE-2022-49256": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49257": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49258": {"epss_score": 0.00036, "epss_percentile": 0.10291}, "CVE-2022-49259": {"epss_score": 0.00052, "epss_percentile": 0.16496}, "CVE-2022-49260": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49261": {"epss_score": 0.00015, "epss_percentile": 0.02296}, "CVE-2022-49262": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49263": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49264": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49265": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49266": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49267": {"epss_score": 0.00025, "epss_percentile": 0.06297}, "CVE-2022-49268": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49269": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49270": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49271": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49272": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49273": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49274": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49275": {"epss_score": 0.00034, "epss_percentile": 0.09687}, "CVE-2022-49276": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49277": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49278": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49279": {"epss_score": 0.00049, "epss_percentile": 0.15331}, "CVE-2022-49280": {"epss_score": 0.00075, "epss_percentile": 0.22997}, "CVE-2022-49281": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2022-49282": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49283": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49284": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49285": {"epss_score": 0.00045, "epss_percentile": 0.13744}, "CVE-2022-49286": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49287": {"epss_score": 0.00098, "epss_percentile": 0.27811}, "CVE-2022-49288": {"epss_score": 0.00029, "epss_percentile": 0.07736}, "CVE-2022-49289": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49290": {"epss_score": 0.00027, "epss_percentile": 0.06889}, "CVE-2022-49291": {"epss_score": 0.00029, "epss_percentile": 0.07736}, "CVE-2022-49292": {"epss_score": 0.00029, "epss_percentile": 0.07736}, "CVE-2022-49293": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49294": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2022-49295": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49296": {"epss_score": 0.00029, "epss_percentile": 0.0782}, "CVE-2022-49297": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49298": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49300": {"epss_score": 0.00022, "epss_percentile": 0.05174}, "CVE-2022-49301": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49302": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49303": {"epss_score": 0.00025, "epss_percentile": 0.06239}, "CVE-2022-49304": {"epss_score": 0.00021, "epss_percentile": 0.04802}, "CVE-2022-49305": {"epss_score": 0.00022, "epss_percentile": 0.05174}, "CVE-2022-49306": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2022-49307": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49308": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49309": {"epss_score": 0.00022, "epss_percentile": 0.05174}, "CVE-2022-49310": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49311": {"epss_score": 0.00042, "epss_percentile": 0.12816}, "CVE-2022-49312": {"epss_score": 0.00097, "epss_percentile": 0.27627}, "CVE-2022-49313": {"epss_score": 0.00021, "epss_percentile": 0.04802}, "CVE-2022-49314": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49315": {"epss_score": 0.00021, "epss_percentile": 0.04802}, "CVE-2022-49316": {"epss_score": 0.00022, "epss_percentile": 0.05174}, "CVE-2022-49317": {"epss_score": 0.00013, "epss_percentile": 0.01712}, "CVE-2022-49318": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49319": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49320": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49321": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49322": {"epss_score": 0.00022, "epss_percentile": 0.05174}, "CVE-2022-49323": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49324": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49325": {"epss_score": 0.00025, "epss_percentile": 0.06249}, "CVE-2022-49326": {"epss_score": 0.00011, "epss_percentile": 0.01086}, "CVE-2022-49327": {"epss_score": 0.0004, "epss_percentile": 0.12107}, "CVE-2022-49328": {"epss_score": 0.00013, "epss_percentile": 0.01477}, "CVE-2022-49329": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49330": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49331": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49332": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49333": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2022-49334": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49335": {"epss_score": 0.00029, "epss_percentile": 0.07868}, "CVE-2022-49336": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49337": {"epss_score": 0.00021, "epss_percentile": 0.04802}, "CVE-2022-49338": {"epss_score": 0.00052, "epss_percentile": 0.16409}, "CVE-2022-49339": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49340": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49341": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49342": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49343": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49344": {"epss_score": 0.0004, "epss_percentile": 0.12113}, "CVE-2022-49345": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49346": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49347": {"epss_score": 0.00023, "epss_percentile": 0.05519}, "CVE-2022-49348": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49349": {"epss_score": 0.00027, "epss_percentile": 0.07168}, "CVE-2022-49350": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49351": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49352": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49353": {"epss_score": 0.00052, "epss_percentile": 0.16409}, "CVE-2022-49354": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49356": {"epss_score": 0.00068, "epss_percentile": 0.21269}, "CVE-2022-49357": {"epss_score": 0.00024, "epss_percentile": 0.05736}, "CVE-2022-49358": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49359": {"epss_score": 0.00036, "epss_percentile": 0.10447}, "CVE-2022-49360": {"epss_score": 0.00066, "epss_percentile": 0.20743}, "CVE-2022-49361": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49362": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49363": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49364": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49365": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49366": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49367": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49368": {"epss_score": 0.00034, "epss_percentile": 0.09687}, "CVE-2022-49369": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49370": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49371": {"epss_score": 0.00033, "epss_percentile": 0.0918}, "CVE-2022-49372": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49373": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49374": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49375": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49376": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49377": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49378": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49379": {"epss_score": 0.00027, "epss_percentile": 0.0708}, "CVE-2022-49380": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49381": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49382": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49383": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49384": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49385": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49386": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49387": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49388": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49389": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49390": {"epss_score": 0.00036, "epss_percentile": 0.10447}, "CVE-2022-49391": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2022-49392": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49393": {"epss_score": 0.00016, "epss_percentile": 0.0265}, "CVE-2022-49394": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49395": {"epss_score": 0.00027, "epss_percentile": 0.07168}, "CVE-2022-49396": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49397": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49398": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49399": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49400": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49401": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2022-49402": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49403": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49404": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49405": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49406": {"epss_score": 0.00042, "epss_percentile": 0.12915}, "CVE-2022-49407": {"epss_score": 0.00027, "epss_percentile": 0.07168}, "CVE-2022-49408": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2022-49409": {"epss_score": 0.0003, "epss_percentile": 0.08272}, "CVE-2022-49410": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49411": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49412": {"epss_score": 0.0003, "epss_percentile": 0.08227}, "CVE-2022-49413": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49414": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49415": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49416": {"epss_score": 0.00034, "epss_percentile": 0.09687}, "CVE-2022-49417": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2022-49418": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49419": {"epss_score": 0.0007, "epss_percentile": 0.21838}, "CVE-2022-49420": {"epss_score": 0.00032, "epss_percentile": 0.09028}, "CVE-2022-49421": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49422": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49423": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49424": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49425": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49426": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49427": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49428": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49429": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49430": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2022-49431": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49432": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49433": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49434": {"epss_score": 0.00022, "epss_percentile": 0.05174}, "CVE-2022-49435": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49436": {"epss_score": 0.00052, "epss_percentile": 0.16409}, "CVE-2022-49437": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49438": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49439": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49440": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2022-49441": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2022-49442": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49443": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2022-49444": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49445": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49446": {"epss_score": 0.00027, "epss_percentile": 0.0708}, "CVE-2022-49447": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49448": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49449": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49450": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49451": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49452": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49453": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49454": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49455": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49456": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49457": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49458": {"epss_score": 0.00068, "epss_percentile": 0.21269}, "CVE-2022-49459": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49460": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49461": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2022-49462": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49463": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49464": {"epss_score": 0.00068, "epss_percentile": 0.21243}, "CVE-2022-49465": {"epss_score": 0.0003, "epss_percentile": 0.08014}, "CVE-2022-49466": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49467": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49468": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49469": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2022-49470": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49471": {"epss_score": 0.00025, "epss_percentile": 0.06297}, "CVE-2022-49472": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49473": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49474": {"epss_score": 0.00034, "epss_percentile": 0.09687}, "CVE-2022-49475": {"epss_score": 0.00012, "epss_percentile": 0.01267}, "CVE-2022-49476": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49477": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49478": {"epss_score": 0.00027, "epss_percentile": 0.07168}, "CVE-2022-49479": {"epss_score": 0.00036, "epss_percentile": 0.10447}, "CVE-2022-49480": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49481": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49482": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49483": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2022-49484": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49485": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49486": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49487": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49488": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49489": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49490": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49491": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49492": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49493": {"epss_score": 0.00044, "epss_percentile": 0.13548}, "CVE-2022-49494": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49495": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49496": {"epss_score": 0.00025, "epss_percentile": 0.06239}, "CVE-2022-49497": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49498": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49499": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49500": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49501": {"epss_score": 0.0003, "epss_percentile": 0.08227}, "CVE-2022-49502": {"epss_score": 0.00097, "epss_percentile": 0.27627}, "CVE-2022-49503": {"epss_score": 0.00034, "epss_percentile": 0.09687}, "CVE-2022-49504": {"epss_score": 0.00032, "epss_percentile": 0.09028}, "CVE-2022-49505": {"epss_score": 0.00041, "epss_percentile": 0.12288}, "CVE-2022-49506": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49507": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49508": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49509": {"epss_score": 0.00025, "epss_percentile": 0.06245}, "CVE-2022-49510": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2022-49511": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49512": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49513": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49514": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2022-49515": {"epss_score": 0.00031, "epss_percentile": 0.0847}, "CVE-2022-49516": {"epss_score": 0.00032, "epss_percentile": 0.09028}, "CVE-2022-49517": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49518": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2022-49519": {"epss_score": 0.00036, "epss_percentile": 0.10291}, "CVE-2022-49520": {"epss_score": 0.00029, "epss_percentile": 0.07766}, "CVE-2022-49521": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49522": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49523": {"epss_score": 0.00097, "epss_percentile": 0.27627}, "CVE-2022-49524": {"epss_score": 0.00029, "epss_percentile": 0.07736}, "CVE-2022-49525": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49526": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49527": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49528": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49529": {"epss_score": 0.00032, "epss_percentile": 0.09028}, "CVE-2022-49530": {"epss_score": 0.00027, "epss_percentile": 0.07168}, "CVE-2022-49531": {"epss_score": 0.00025, "epss_percentile": 0.06239}, "CVE-2022-49532": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49533": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49534": {"epss_score": 0.00032, "epss_percentile": 0.09028}, "CVE-2022-49535": {"epss_score": 0.0003, "epss_percentile": 0.08014}, "CVE-2022-49536": {"epss_score": 0.00023, "epss_percentile": 0.05352}, "CVE-2022-49537": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2022-49538": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49539": {"epss_score": 0.00052, "epss_percentile": 0.16409}, "CVE-2022-49540": {"epss_score": 0.0004, "epss_percentile": 0.12107}, "CVE-2022-49541": {"epss_score": 0.0003, "epss_percentile": 0.08227}, "CVE-2022-49542": {"epss_score": 0.00023, "epss_percentile": 0.05352}, "CVE-2022-49543": {"epss_score": 0.00038, "epss_percentile": 0.11366}, "CVE-2022-49544": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2022-49545": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49546": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49547": {"epss_score": 0.00029, "epss_percentile": 0.0782}, "CVE-2022-49548": {"epss_score": 0.00036, "epss_percentile": 0.10291}, "CVE-2022-49549": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49550": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49551": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49552": {"epss_score": 0.00038, "epss_percentile": 0.11142}, "CVE-2022-49553": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49554": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49555": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49556": {"epss_score": 0.00077, "epss_percentile": 0.23327}, "CVE-2022-49557": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49558": {"epss_score": 0.00052, "epss_percentile": 0.16496}, "CVE-2022-49559": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49560": {"epss_score": 0.00036, "epss_percentile": 0.10291}, "CVE-2022-49561": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49562": {"epss_score": 0.00038, "epss_percentile": 0.11366}, "CVE-2022-49563": {"epss_score": 0.00025, "epss_percentile": 0.06272}, "CVE-2022-49564": {"epss_score": 0.00025, "epss_percentile": 0.06272}, "CVE-2022-49565": {"epss_score": 0.00052, "epss_percentile": 0.16409}, "CVE-2022-49566": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49567": {"epss_score": 0.00025, "epss_percentile": 0.06272}, "CVE-2022-49568": {"epss_score": 0.00092, "epss_percentile": 0.26532}, "CVE-2022-49569": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49570": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49571": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49572": {"epss_score": 0.00022, "epss_percentile": 0.05174}, "CVE-2022-49573": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49574": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49575": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49576": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2022-49577": {"epss_score": 0.00027, "epss_percentile": 0.0708}, "CVE-2022-49578": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2022-49579": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2022-49580": {"epss_score": 0.00027, "epss_percentile": 0.0708}, "CVE-2022-49581": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49582": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49583": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49584": {"epss_score": 0.00027, "epss_percentile": 0.0708}, "CVE-2022-49585": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2022-49586": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49587": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49588": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2022-49589": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49590": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49591": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49592": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49593": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49594": {"epss_score": 0.00027, "epss_percentile": 0.0708}, "CVE-2022-49595": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49596": {"epss_score": 0.00027, "epss_percentile": 0.0708}, "CVE-2022-49597": {"epss_score": 0.0004, "epss_percentile": 0.12107}, "CVE-2022-49598": {"epss_score": 0.00022, "epss_percentile": 0.05174}, "CVE-2022-49599": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2022-49600": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2022-49601": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49602": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49603": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2022-49604": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49605": {"epss_score": 0.00042, "epss_percentile": 0.12749}, "CVE-2022-49606": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2022-49607": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49608": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49609": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49610": {"epss_score": 0.00042, "epss_percentile": 0.12823}, "CVE-2022-49611": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49612": {"epss_score": 0.00055, "epss_percentile": 0.17416}, "CVE-2022-49613": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49615": {"epss_score": 0.00047, "epss_percentile": 0.14666}, "CVE-2022-49616": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49617": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2022-49618": {"epss_score": 0.00054, "epss_percentile": 0.17346}, "CVE-2022-49619": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49620": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49621": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49622": {"epss_score": 0.00038, "epss_percentile": 0.11211}, "CVE-2022-49623": {"epss_score": 0.00025, "epss_percentile": 0.06297}, "CVE-2022-49624": {"epss_score": 0.00068, "epss_percentile": 0.21269}, "CVE-2022-49625": {"epss_score": 0.00015, "epss_percentile": 0.02229}, "CVE-2022-49626": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49627": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49628": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49629": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2022-49630": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2022-49631": {"epss_score": 0.00027, "epss_percentile": 0.0708}, "CVE-2022-49632": {"epss_score": 0.0002, "epss_percentile": 0.04425}, "CVE-2022-49633": {"epss_score": 0.00025, "epss_percentile": 0.06069}, "CVE-2022-49634": {"epss_score": 0.00055, "epss_percentile": 0.17494}, "CVE-2022-49635": {"epss_score": 0.00052, "epss_percentile": 0.16466}, "CVE-2022-49636": {"epss_score": 0.00053, "epss_percentile": 0.16715}, "CVE-2022-49637": {"epss_score": 0.00027, "epss_percentile": 0.0708}, "CVE-2022-49638": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2022-49639": {"epss_score": 0.00022, "epss_percentile": 0.05174}, "CVE-2022-49640": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2022-49641": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2022-49642": {"epss_score": 0.00066, "epss_percentile": 0.20743}, "CVE-2022-49643": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49644": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49645": {"epss_score": 0.00036, "epss_percentile": 0.10291}, "CVE-2022-49646": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49647": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49648": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49649": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49650": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49651": {"epss_score": 0.00038, "epss_percentile": 0.11211}, "CVE-2022-49652": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49653": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2022-49654": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2022-49655": {"epss_score": 0.00022, "epss_percentile": 0.05166}, "CVE-2022-49656": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49657": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49658": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49659": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49661": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49662": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49663": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49664": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49665": {"epss_score": 0.00052, "epss_percentile": 0.16409}, "CVE-2022-49666": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49667": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49668": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49669": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2022-49670": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49671": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49672": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49673": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49674": {"epss_score": 0.00019, "epss_percentile": 0.04075}, "CVE-2022-49675": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49676": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49677": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49678": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49679": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49680": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49681": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49682": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49683": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49684": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49685": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49686": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2022-49687": {"epss_score": 0.00133, "epss_percentile": 0.33647}, "CVE-2022-49688": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49691": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49692": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49693": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49694": {"epss_score": 0.00046, "epss_percentile": 0.14467}, "CVE-2022-49695": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49696": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49697": {"epss_score": 0.00066, "epss_percentile": 0.20743}, "CVE-2022-49698": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49699": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49700": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49701": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49702": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2022-49703": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49704": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49705": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49706": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49707": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49708": {"epss_score": 0.0003, "epss_percentile": 0.08272}, "CVE-2022-49709": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49710": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2022-49711": {"epss_score": 0.00036, "epss_percentile": 0.10447}, "CVE-2022-49712": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49713": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49714": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49715": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49716": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49717": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49718": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2022-49719": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49720": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2022-49721": {"epss_score": 0.00036, "epss_percentile": 0.10251}, "CVE-2022-49722": {"epss_score": 0.00047, "epss_percentile": 0.14497}, "CVE-2022-49723": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2022-49724": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2022-49725": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2022-49726": {"epss_score": 0.00035, "epss_percentile": 0.10035}, "CVE-2022-49727": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49728": {"epss_score": 0.00038, "epss_percentile": 0.11347}, "CVE-2022-49729": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49731": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2022-49732": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2022-49733": {"epss_score": 0.0004, "epss_percentile": 0.12107}, "CVE-2022-49737": {"epss_score": 0.0017, "epss_percentile": 0.38664}, "CVE-2022-49738": {"epss_score": 0.00035, "epss_percentile": 0.10015}, "CVE-2022-49739": {"epss_score": 0.00022, "epss_percentile": 0.04963}, "CVE-2022-49740": {"epss_score": 0.00031, "epss_percentile": 0.08639}, "CVE-2022-49741": {"epss_score": 0.00031, "epss_percentile": 0.08413}, "CVE-2022-49742": {"epss_score": 0.00016, "epss_percentile": 0.02925}, "CVE-2022-49743": {"epss_score": 0.00016, "epss_percentile": 0.02739}, "CVE-2022-49744": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2022-49745": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2022-49746": {"epss_score": 0.00019, "epss_percentile": 0.04198}, "CVE-2022-49747": {"epss_score": 0.00016, "epss_percentile": 0.0295}, "CVE-2022-49748": {"epss_score": 0.00021, "epss_percentile": 0.04767}, "CVE-2022-49749": {"epss_score": 0.00021, "epss_percentile": 0.04938}, "CVE-2022-49750": {"epss_score": 0.00021, "epss_percentile": 0.04795}, "CVE-2022-49751": {"epss_score": 0.00023, "epss_percentile": 0.05656}, "CVE-2022-49752": {"epss_score": 0.00016, "epss_percentile": 0.0295}, "CVE-2022-49753": {"epss_score": 0.00039, "epss_percentile": 0.11594}, "CVE-2022-49754": {"epss_score": 0.00029, "epss_percentile": 0.07738}, "CVE-2022-49755": {"epss_score": 0.00022, "epss_percentile": 0.04983}, "CVE-2022-49756": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2022-49757": {"epss_score": 0.00023, "epss_percentile": 0.05656}, "CVE-2022-49758": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2022-49759": {"epss_score": 0.00019, "epss_percentile": 0.04202}, "CVE-2022-49760": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2022-49761": {"epss_score": 0.00021, "epss_percentile": 0.04918}, "CVE-2022-49762": {"epss_score": 0.00014, "epss_percentile": 0.01892}, "CVE-2022-49763": {"epss_score": 0.00014, "epss_percentile": 0.02}, "CVE-2022-49764": {"epss_score": 0.00018, "epss_percentile": 0.03854}, "CVE-2022-49765": {"epss_score": 9e-05, "epss_percentile": 0.0069}, "CVE-2022-49766": {"epss_score": 0.00017, "epss_percentile": 0.03398}, "CVE-2022-49767": {"epss_score": 0.00014, "epss_percentile": 0.01892}, "CVE-2022-49768": {"epss_score": 0.00013, "epss_percentile": 0.01708}, "CVE-2022-49769": {"epss_score": 0.00014, "epss_percentile": 0.01892}, "CVE-2022-49770": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2022-49771": {"epss_score": 0.00011, "epss_percentile": 0.01002}, "CVE-2022-49772": {"epss_score": 0.00014, "epss_percentile": 0.01892}, "CVE-2022-49773": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49774": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49775": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2022-49776": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49777": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49778": {"epss_score": 8e-05, "epss_percentile": 0.00593}, "CVE-2022-49779": {"epss_score": 0.00017, "epss_percentile": 0.03513}, "CVE-2022-49780": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49781": {"epss_score": 0.00012, "epss_percentile": 0.01241}, "CVE-2022-49782": {"epss_score": 8e-05, "epss_percentile": 0.00492}, "CVE-2022-49783": {"epss_score": 0.00019, "epss_percentile": 0.04093}, "CVE-2022-49784": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49785": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49786": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49787": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49788": {"epss_score": 0.00011, "epss_percentile": 0.01051}, "CVE-2022-49789": {"epss_score": 0.00017, "epss_percentile": 0.03513}, "CVE-2022-49790": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2022-49791": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49792": {"epss_score": 0.00018, "epss_percentile": 0.03939}, "CVE-2022-49793": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49794": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49795": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49796": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49797": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49798": {"epss_score": 0.00011, "epss_percentile": 0.0093}, "CVE-2022-49799": {"epss_score": 0.00018, "epss_percentile": 0.03939}, "CVE-2022-49800": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49801": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49802": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49803": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49804": {"epss_score": 0.00021, "epss_percentile": 0.04879}, "CVE-2022-49805": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49806": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49807": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49808": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49809": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49810": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49811": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2022-49812": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49813": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49814": {"epss_score": 0.00013, "epss_percentile": 0.01708}, "CVE-2022-49815": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49817": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49818": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49819": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49820": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49821": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49822": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49823": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49824": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49825": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49826": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2022-49827": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49828": {"epss_score": 0.00014, "epss_percentile": 0.01777}, "CVE-2022-49829": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49830": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49831": {"epss_score": 0.00012, "epss_percentile": 0.0116}, "CVE-2022-49832": {"epss_score": 0.00023, "epss_percentile": 0.05452}, "CVE-2022-49833": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49834": {"epss_score": 0.00014, "epss_percentile": 0.02}, "CVE-2022-49835": {"epss_score": 0.00014, "epss_percentile": 0.01892}, "CVE-2022-49836": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49837": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49838": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49839": {"epss_score": 0.00014, "epss_percentile": 0.02045}, "CVE-2022-49840": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2022-49841": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49842": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2022-49844": {"epss_score": 0.00021, "epss_percentile": 0.04879}, "CVE-2022-49845": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2022-49846": {"epss_score": 0.00016, "epss_percentile": 0.02799}, "CVE-2022-49847": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49848": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49849": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49850": {"epss_score": 0.00013, "epss_percentile": 0.01708}, "CVE-2022-49851": {"epss_score": 0.00018, "epss_percentile": 0.03939}, "CVE-2022-49852": {"epss_score": 0.00048, "epss_percentile": 0.14934}, "CVE-2022-49853": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49854": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49855": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49857": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49858": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49859": {"epss_score": 0.00014, "epss_percentile": 0.0203}, "CVE-2022-49860": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49861": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49862": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49863": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2022-49864": {"epss_score": 0.00012, "epss_percentile": 0.0116}, "CVE-2022-49865": {"epss_score": 0.00053, "epss_percentile": 0.16944}, "CVE-2022-49866": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49867": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49868": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49869": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2022-49870": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2022-49871": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49872": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49873": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49874": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49875": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49876": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49877": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2022-49878": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49879": {"epss_score": 0.00022, "epss_percentile": 0.05029}, "CVE-2022-49880": {"epss_score": 0.00014, "epss_percentile": 0.01892}, "CVE-2022-49881": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49882": {"epss_score": 0.00021, "epss_percentile": 0.04879}, "CVE-2022-49883": {"epss_score": 0.00021, "epss_percentile": 0.04879}, "CVE-2022-49884": {"epss_score": 0.00012, "epss_percentile": 0.01241}, "CVE-2022-49885": {"epss_score": 0.00015, "epss_percentile": 0.02124}, "CVE-2022-49886": {"epss_score": 0.00013, "epss_percentile": 0.01566}, "CVE-2022-49887": {"epss_score": 0.00025, "epss_percentile": 0.06309}, "CVE-2022-49888": {"epss_score": 0.00014, "epss_percentile": 0.0203}, "CVE-2022-49889": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49890": {"epss_score": 0.00017, "epss_percentile": 0.03268}, "CVE-2022-49891": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49892": {"epss_score": 0.00018, "epss_percentile": 0.03939}, "CVE-2022-49893": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49894": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49895": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49896": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49898": {"epss_score": 0.00016, "epss_percentile": 0.0286}, "CVE-2022-49899": {"epss_score": 0.00013, "epss_percentile": 0.01473}, "CVE-2022-49900": {"epss_score": 0.00018, "epss_percentile": 0.03939}, "CVE-2022-49901": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49902": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49903": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49904": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49905": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49906": {"epss_score": 0.00016, "epss_percentile": 0.0286}, "CVE-2022-49907": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2022-49908": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49910": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2022-49911": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49912": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49913": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2022-49914": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49915": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49916": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49917": {"epss_score": 0.00014, "epss_percentile": 0.02}, "CVE-2022-49918": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49919": {"epss_score": 0.00014, "epss_percentile": 0.0178}, "CVE-2022-49920": {"epss_score": 0.00011, "epss_percentile": 0.0093}, "CVE-2022-49921": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2022-49922": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49923": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49924": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2022-49925": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2022-49926": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49927": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2022-49928": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2022-49929": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49930": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2022-49931": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2022-49932": {"epss_score": 0.00012, "epss_percentile": 0.0116}, "CVE-2022-49934": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-49935": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2022-49936": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-49937": {"epss_score": 0.00014, "epss_percentile": 0.02035}, "CVE-2022-49938": {"epss_score": 0.00012, "epss_percentile": 0.01151}, "CVE-2022-49939": {"epss_score": 0.00011, "epss_percentile": 0.01025}, "CVE-2022-49940": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-49942": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-49943": {"epss_score": 0.00014, "epss_percentile": 0.02056}, "CVE-2022-49944": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49945": {"epss_score": 0.0002, "epss_percentile": 0.04565}, "CVE-2022-49946": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2022-49947": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-49948": {"epss_score": 9e-05, "epss_percentile": 0.00702}, "CVE-2022-49949": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49950": {"epss_score": 0.00018, "epss_percentile": 0.03598}, "CVE-2022-49951": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2022-49952": {"epss_score": 0.00018, "epss_percentile": 0.03598}, "CVE-2022-49953": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49954": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-49955": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49956": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-49957": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-49958": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-49959": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-49960": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49961": {"epss_score": 0.00019, "epss_percentile": 0.04368}, "CVE-2022-49962": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49963": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49964": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49965": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49966": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-49967": {"epss_score": 0.00011, "epss_percentile": 0.01003}, "CVE-2022-49968": {"epss_score": 0.00012, "epss_percentile": 0.01139}, "CVE-2022-49969": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-49970": {"epss_score": 0.00028, "epss_percentile": 0.07292}, "CVE-2022-49971": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49972": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49973": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-49974": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49975": {"epss_score": 0.00015, "epss_percentile": 0.02277}, "CVE-2022-49976": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49977": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-49978": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-49979": {"epss_score": 0.00012, "epss_percentile": 0.01151}, "CVE-2022-49980": {"epss_score": 0.00017, "epss_percentile": 0.03401}, "CVE-2022-49981": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-49982": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-49983": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-49984": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-49985": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2022-49986": {"epss_score": 0.00012, "epss_percentile": 0.01139}, "CVE-2022-49987": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-49989": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-49990": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-49991": {"epss_score": 0.00026, "epss_percentile": 0.06387}, "CVE-2022-49992": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49993": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-49994": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-49995": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2022-49996": {"epss_score": 0.00026, "epss_percentile": 0.06387}, "CVE-2022-49997": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-49998": {"epss_score": 0.00024, "epss_percentile": 0.06024}, "CVE-2022-49999": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2022-4000": {"epss_score": 0.00207, "epss_percentile": 0.43111}, "CVE-2022-4001": {"epss_score": 0.0006, "epss_percentile": 0.19071}, "CVE-2022-4002": {"epss_score": 0.0049, "epss_percentile": 0.64916}, "CVE-2022-4003": {"epss_score": 0.00145, "epss_percentile": 0.35526}, "CVE-2022-4004": {"epss_score": 0.00153, "epss_percentile": 0.36607}, "CVE-2022-4005": {"epss_score": 0.00252, "epss_percentile": 0.48373}, "CVE-2022-4006": {"epss_score": 0.00246, "epss_percentile": 0.47731}, "CVE-2022-4007": {"epss_score": 0.00699, "epss_percentile": 0.71442}, "CVE-2022-4008": {"epss_score": 0.00036, "epss_percentile": 0.10325}, "CVE-2022-4009": {"epss_score": 0.00471, "epss_percentile": 0.64018}, "CVE-2022-4010": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-4011": {"epss_score": 0.00354, "epss_percentile": 0.57204}, "CVE-2022-4012": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2022-4013": {"epss_score": 0.00149, "epss_percentile": 0.35995}, "CVE-2022-4014": {"epss_score": 0.00143, "epss_percentile": 0.35223}, "CVE-2022-4015": {"epss_score": 0.00291, "epss_percentile": 0.52193}, "CVE-2022-4016": {"epss_score": 0.00269, "epss_percentile": 0.50164}, "CVE-2022-4017": {"epss_score": 0.00208, "epss_percentile": 0.4327}, "CVE-2022-4018": {"epss_score": 0.004, "epss_percentile": 0.60182}, "CVE-2022-4019": {"epss_score": 0.00689, "epss_percentile": 0.71234}, "CVE-2022-4020": {"epss_score": 0.00082, "epss_percentile": 0.24406}, "CVE-2022-4021": {"epss_score": 0.00137, "epss_percentile": 0.34325}, "CVE-2022-4022": {"epss_score": 0.00171, "epss_percentile": 0.38773}, "CVE-2022-4023": {"epss_score": 0.00077, "epss_percentile": 0.23381}, "CVE-2022-4024": {"epss_score": 0.00321, "epss_percentile": 0.54687}, "CVE-2022-4025": {"epss_score": 0.00255, "epss_percentile": 0.48672}, "CVE-2022-4027": {"epss_score": 0.01288, "epss_percentile": 0.79203}, "CVE-2022-4028": {"epss_score": 0.00196, "epss_percentile": 0.41813}, "CVE-2022-4029": {"epss_score": 0.03204, "epss_percentile": 0.86629}, "CVE-2022-4030": {"epss_score": 0.05429, "epss_percentile": 0.89873}, "CVE-2022-4031": {"epss_score": 0.00283, "epss_percentile": 0.5139}, "CVE-2022-4032": {"epss_score": 0.01846, "epss_percentile": 0.82513}, "CVE-2022-4033": {"epss_score": 0.00215, "epss_percentile": 0.44041}, "CVE-2022-4034": {"epss_score": 0.02482, "epss_percentile": 0.84877}, "CVE-2022-4035": {"epss_score": 0.01846, "epss_percentile": 0.82513}, "CVE-2022-4036": {"epss_score": 0.00077, "epss_percentile": 0.23538}, "CVE-2022-4037": {"epss_score": 0.00342, "epss_percentile": 0.56393}, "CVE-2022-4039": {"epss_score": 0.00121, "epss_percentile": 0.32017}, "CVE-2022-4041": {"epss_score": 0.01053, "epss_percentile": 0.77103}, "CVE-2022-4042": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-4043": {"epss_score": 0.14154, "epss_percentile": 0.94145}, "CVE-2022-4044": {"epss_score": 0.00593, "epss_percentile": 0.68637}, "CVE-2022-4045": {"epss_score": 0.00451, "epss_percentile": 0.63144}, "CVE-2022-4046": {"epss_score": 0.00762, "epss_percentile": 0.72837}, "CVE-2022-4047": {"epss_score": 0.73303, "epss_percentile": 0.98746}, "CVE-2022-4048": {"epss_score": 0.00036, "epss_percentile": 0.10513}, "CVE-2022-4049": {"epss_score": 0.80436, "epss_percentile": 0.99088}, "CVE-2022-4050": {"epss_score": 0.79909, "epss_percentile": 0.99062}, "CVE-2022-4051": {"epss_score": 0.00202, "epss_percentile": 0.42408}, "CVE-2022-4052": {"epss_score": 0.00204, "epss_percentile": 0.42631}, "CVE-2022-4053": {"epss_score": 0.00203, "epss_percentile": 0.42554}, "CVE-2022-4054": {"epss_score": 0.00239, "epss_percentile": 0.46904}, "CVE-2022-4055": {"epss_score": 0.00038, "epss_percentile": 0.1116}, "CVE-2022-4057": {"epss_score": 0.58814, "epss_percentile": 0.98138}, "CVE-2022-4058": {"epss_score": 0.00085, "epss_percentile": 0.25092}, "CVE-2022-4059": {"epss_score": 0.75778, "epss_percentile": 0.98864}, "CVE-2022-4060": {"epss_score": 0.91121, "epss_percentile": 0.9962}, "CVE-2022-4061": {"epss_score": 0.22249, "epss_percentile": 0.95614}, "CVE-2022-4062": {"epss_score": 0.00069, "epss_percentile": 0.2151}, "CVE-2022-4063": {"epss_score": 0.90722, "epss_percentile": 0.99597}, "CVE-2022-4064": {"epss_score": 0.00311, "epss_percentile": 0.53813}, "CVE-2022-4065": {"epss_score": 0.00451, "epss_percentile": 0.63129}, "CVE-2022-4066": {"epss_score": 0.00317, "epss_percentile": 0.54378}, "CVE-2022-4067": {"epss_score": 0.87331, "epss_percentile": 0.99424}, "CVE-2022-4068": {"epss_score": 0.54367, "epss_percentile": 0.97923}, "CVE-2022-4069": {"epss_score": 0.87331, "epss_percentile": 0.99424}, "CVE-2022-4070": {"epss_score": 3e-05, "epss_percentile": 0.00102}, "CVE-2022-4087": {"epss_score": 0.00232, "epss_percentile": 0.45913}, "CVE-2022-4088": {"epss_score": 0.00281, "epss_percentile": 0.51108}, "CVE-2022-4089": {"epss_score": 0.00218, "epss_percentile": 0.44406}, "CVE-2022-4090": {"epss_score": 0.00103, "epss_percentile": 0.28972}, "CVE-2022-4091": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2022-4092": {"epss_score": 0.03796, "epss_percentile": 0.87736}, "CVE-2022-4093": {"epss_score": 0.00415, "epss_percentile": 0.61156}, "CVE-2022-4095": {"epss_score": 0.00013, "epss_percentile": 0.0165}, "CVE-2022-4096": {"epss_score": 0.07265, "epss_percentile": 0.91359}, "CVE-2022-4097": {"epss_score": 0.00187, "epss_percentile": 0.40721}, "CVE-2022-4098": {"epss_score": 0.00091, "epss_percentile": 0.26192}, "CVE-2022-4099": {"epss_score": 0.0435, "epss_percentile": 0.88584}, "CVE-2022-4100": {"epss_score": 0.0008, "epss_percentile": 0.24136}, "CVE-2022-4101": {"epss_score": 0.49912, "epss_percentile": 0.97711}, "CVE-2022-4102": {"epss_score": 0.00101, "epss_percentile": 0.28648}, "CVE-2022-4103": {"epss_score": 0.00073, "epss_percentile": 0.2249}, "CVE-2022-4104": {"epss_score": 0.00055, "epss_percentile": 0.17571}, "CVE-2022-4105": {"epss_score": 0.00327, "epss_percentile": 0.55107}, "CVE-2022-4106": {"epss_score": 0.01161, "epss_percentile": 0.78143}, "CVE-2022-4107": {"epss_score": 0.00135, "epss_percentile": 0.34022}, "CVE-2022-4108": {"epss_score": 0.00604, "epss_percentile": 0.68967}, "CVE-2022-4109": {"epss_score": 0.0053, "epss_percentile": 0.66611}, "CVE-2022-4110": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-4111": {"epss_score": 0.00385, "epss_percentile": 0.59196}, "CVE-2022-4112": {"epss_score": 0.00257, "epss_percentile": 0.48861}, "CVE-2022-4114": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2022-4115": {"epss_score": 0.00101, "epss_percentile": 0.28636}, "CVE-2022-4116": {"epss_score": 0.11875, "epss_percentile": 0.93501}, "CVE-2022-4117": {"epss_score": 0.83515, "epss_percentile": 0.99251}, "CVE-2022-4118": {"epss_score": 0.0043, "epss_percentile": 0.62029}, "CVE-2022-4119": {"epss_score": 0.00326, "epss_percentile": 0.55055}, "CVE-2022-4120": {"epss_score": 0.07685, "epss_percentile": 0.91626}, "CVE-2022-4121": {"epss_score": 0.00073, "epss_percentile": 0.22617}, "CVE-2022-4122": {"epss_score": 0.00167, "epss_percentile": 0.38348}, "CVE-2022-4123": {"epss_score": 0.00041, "epss_percentile": 0.12331}, "CVE-2022-4124": {"epss_score": 0.0012, "epss_percentile": 0.31709}, "CVE-2022-4125": {"epss_score": 0.00206, "epss_percentile": 0.42945}, "CVE-2022-4126": {"epss_score": 0.0027, "epss_percentile": 0.50253}, "CVE-2022-4127": {"epss_score": 0.00114, "epss_percentile": 0.30819}, "CVE-2022-4128": {"epss_score": 0.00036, "epss_percentile": 0.10505}, "CVE-2022-4129": {"epss_score": 0.0002, "epss_percentile": 0.04587}, "CVE-2022-4130": {"epss_score": 0.00121, "epss_percentile": 0.3183}, "CVE-2022-4131": {"epss_score": 0.00096, "epss_percentile": 0.27321}, "CVE-2022-4132": {"epss_score": 0.00066, "epss_percentile": 0.20869}, "CVE-2022-4134": {"epss_score": 0.00111, "epss_percentile": 0.30378}, "CVE-2022-4135": {"epss_score": 0.0014, "epss_percentile": 0.34719}, "CVE-2022-4136": {"epss_score": 0.00428, "epss_percentile": 0.61954}, "CVE-2022-4137": {"epss_score": 0.00393, "epss_percentile": 0.59704}, "CVE-2022-4138": {"epss_score": 0.00113, "epss_percentile": 0.30607}, "CVE-2022-4139": {"epss_score": 0.00013, "epss_percentile": 0.01608}, "CVE-2022-4140": {"epss_score": 0.67923, "epss_percentile": 0.98525}, "CVE-2022-4141": {"epss_score": 0.00039, "epss_percentile": 0.11835}, "CVE-2022-4142": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-4143": {"epss_score": 0.00192, "epss_percentile": 0.41325}, "CVE-2022-4144": {"epss_score": 0.0002, "epss_percentile": 0.04668}, "CVE-2022-4145": {"epss_score": 0.00081, "epss_percentile": 0.24361}, "CVE-2022-4146": {"epss_score": 0.00211, "epss_percentile": 0.43617}, "CVE-2022-4147": {"epss_score": 0.0032, "epss_percentile": 0.54583}, "CVE-2022-4148": {"epss_score": 0.00065, "epss_percentile": 0.20551}, "CVE-2022-4149": {"epss_score": 0.00027, "epss_percentile": 0.06738}, "CVE-2022-4150": {"epss_score": 0.00871, "epss_percentile": 0.74715}, "CVE-2022-4151": {"epss_score": 0.00741, "epss_percentile": 0.72441}, "CVE-2022-4152": {"epss_score": 0.00871, "epss_percentile": 0.74715}, "CVE-2022-4153": {"epss_score": 0.00583, "epss_percentile": 0.68328}, "CVE-2022-4154": {"epss_score": 0.00846, "epss_percentile": 0.74328}, "CVE-2022-4155": {"epss_score": 0.01348, "epss_percentile": 0.79664}, "CVE-2022-4156": {"epss_score": 0.00761, "epss_percentile": 0.72828}, "CVE-2022-4157": {"epss_score": 0.00813, "epss_percentile": 0.73757}, "CVE-2022-4158": {"epss_score": 0.00958, "epss_percentile": 0.75947}, "CVE-2022-4159": {"epss_score": 0.00741, "epss_percentile": 0.72441}, "CVE-2022-4160": {"epss_score": 0.0077, "epss_percentile": 0.72994}, "CVE-2022-4161": {"epss_score": 0.00741, "epss_percentile": 0.72441}, "CVE-2022-4162": {"epss_score": 0.00741, "epss_percentile": 0.72441}, "CVE-2022-4163": {"epss_score": 0.00583, "epss_percentile": 0.68328}, "CVE-2022-4164": {"epss_score": 0.00583, "epss_percentile": 0.68328}, "CVE-2022-4165": {"epss_score": 0.00741, "epss_percentile": 0.72441}, "CVE-2022-4166": {"epss_score": 0.00741, "epss_percentile": 0.72441}, "CVE-2022-4167": {"epss_score": 0.00136, "epss_percentile": 0.34127}, "CVE-2022-4169": {"epss_score": 0.0048, "epss_percentile": 0.64455}, "CVE-2022-4170": {"epss_score": 0.01758, "epss_percentile": 0.82136}, "CVE-2022-4171": {"epss_score": 0.00319, "epss_percentile": 0.54486}, "CVE-2022-4172": {"epss_score": 0.0003, "epss_percentile": 0.08238}, "CVE-2022-4173": {"epss_score": 0.00408, "epss_percentile": 0.6065}, "CVE-2022-4174": {"epss_score": 0.00826, "epss_percentile": 0.73973}, "CVE-2022-4175": {"epss_score": 0.00162, "epss_percentile": 0.37629}, "CVE-2022-4176": {"epss_score": 0.00425, "epss_percentile": 0.61706}, "CVE-2022-4177": {"epss_score": 0.00094, "epss_percentile": 0.27075}, "CVE-2022-4178": {"epss_score": 0.08446, "epss_percentile": 0.92054}, "CVE-2022-4179": {"epss_score": 0.00073, "epss_percentile": 0.22615}, "CVE-2022-4180": {"epss_score": 0.001, "epss_percentile": 0.28541}, "CVE-2022-4181": {"epss_score": 0.00267, "epss_percentile": 0.50017}, "CVE-2022-4182": {"epss_score": 0.00079, "epss_percentile": 0.23963}, "CVE-2022-4183": {"epss_score": 0.00083, "epss_percentile": 0.2461}, "CVE-2022-4184": {"epss_score": 0.00078, "epss_percentile": 0.23592}, "CVE-2022-4185": {"epss_score": 0.0019, "epss_percentile": 0.41079}, "CVE-2022-4186": {"epss_score": 0.0004, "epss_percentile": 0.11969}, "CVE-2022-4187": {"epss_score": 0.00084, "epss_percentile": 0.24862}, "CVE-2022-4188": {"epss_score": 0.00082, "epss_percentile": 0.24543}, "CVE-2022-4189": {"epss_score": 0.0004, "epss_percentile": 0.11969}, "CVE-2022-4190": {"epss_score": 0.00071, "epss_percentile": 0.22089}, "CVE-2022-4191": {"epss_score": 0.00222, "epss_percentile": 0.44731}, "CVE-2022-4192": {"epss_score": 0.00252, "epss_percentile": 0.48352}, "CVE-2022-4193": {"epss_score": 0.00059, "epss_percentile": 0.18658}, "CVE-2022-4194": {"epss_score": 0.00222, "epss_percentile": 0.44731}, "CVE-2022-4195": {"epss_score": 0.0007, "epss_percentile": 0.21724}, "CVE-2022-4196": {"epss_score": 0.00123, "epss_percentile": 0.32313}, "CVE-2022-4197": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-4198": {"epss_score": 0.00247, "epss_percentile": 0.47844}, "CVE-2022-4199": {"epss_score": 0.00095, "epss_percentile": 0.27239}, "CVE-2022-4200": {"epss_score": 0.00182, "epss_percentile": 0.40272}, "CVE-2022-4201": {"epss_score": 0.0016, "epss_percentile": 0.375}, "CVE-2022-4202": {"epss_score": 0.00111, "epss_percentile": 0.30325}, "CVE-2022-4203": {"epss_score": 0.00642, "epss_percentile": 0.70021}, "CVE-2022-4205": {"epss_score": 0.00031, "epss_percentile": 0.08319}, "CVE-2022-4206": {"epss_score": 0.00169, "epss_percentile": 0.38631}, "CVE-2022-4207": {"epss_score": 0.00274, "epss_percentile": 0.50506}, "CVE-2022-4208": {"epss_score": 0.01971, "epss_percentile": 0.83097}, "CVE-2022-4209": {"epss_score": 0.01807, "epss_percentile": 0.82352}, "CVE-2022-4210": {"epss_score": 0.01817, "epss_percentile": 0.82397}, "CVE-2022-4211": {"epss_score": 0.01817, "epss_percentile": 0.82397}, "CVE-2022-4212": {"epss_score": 0.01807, "epss_percentile": 0.82352}, "CVE-2022-4213": {"epss_score": 0.03777, "epss_percentile": 0.8771}, "CVE-2022-4214": {"epss_score": 0.01807, "epss_percentile": 0.82352}, "CVE-2022-4215": {"epss_score": 0.02493, "epss_percentile": 0.84902}, "CVE-2022-4216": {"epss_score": 0.0069, "epss_percentile": 0.71248}, "CVE-2022-4217": {"epss_score": 0.00754, "epss_percentile": 0.72699}, "CVE-2022-4218": {"epss_score": 0.00178, "epss_percentile": 0.39724}, "CVE-2022-4219": {"epss_score": 0.00128, "epss_percentile": 0.33018}, "CVE-2022-4220": {"epss_score": 0.00128, "epss_percentile": 0.33018}, "CVE-2022-4221": {"epss_score": 0.55206, "epss_percentile": 0.97965}, "CVE-2022-4222": {"epss_score": 0.00217, "epss_percentile": 0.44266}, "CVE-2022-4223": {"epss_score": 0.78158, "epss_percentile": 0.98971}, "CVE-2022-4224": {"epss_score": 0.00745, "epss_percentile": 0.72528}, "CVE-2022-4226": {"epss_score": 0.00415, "epss_percentile": 0.61135}, "CVE-2022-4227": {"epss_score": 0.00287, "epss_percentile": 0.5185}, "CVE-2022-4228": {"epss_score": 0.00416, "epss_percentile": 0.6119}, "CVE-2022-4229": {"epss_score": 0.00457, "epss_percentile": 0.63362}, "CVE-2022-4230": {"epss_score": 0.21607, "epss_percentile": 0.95538}, "CVE-2022-4231": {"epss_score": 0.00202, "epss_percentile": 0.42476}, "CVE-2022-4232": {"epss_score": 0.00057, "epss_percentile": 0.18127}, "CVE-2022-4233": {"epss_score": 0.00333, "epss_percentile": 0.55634}, "CVE-2022-4234": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2022-4235": {"epss_score": 0.00102, "epss_percentile": 0.28828}, "CVE-2022-4236": {"epss_score": 0.00562, "epss_percentile": 0.67701}, "CVE-2022-4237": {"epss_score": 0.01246, "epss_percentile": 0.78857}, "CVE-2022-4239": {"epss_score": 0.0019, "epss_percentile": 0.41136}, "CVE-2022-4240": {"epss_score": 0.00011, "epss_percentile": 0.01092}, "CVE-2022-4242": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-4243": {"epss_score": 0.00288, "epss_percentile": 0.51908}, "CVE-2022-4244": {"epss_score": 0.00369, "epss_percentile": 0.58259}, "CVE-2022-4245": {"epss_score": 0.00138, "epss_percentile": 0.34357}, "CVE-2022-4246": {"epss_score": 0.00329, "epss_percentile": 0.554}, "CVE-2022-4247": {"epss_score": 0.00166, "epss_percentile": 0.38225}, "CVE-2022-4248": {"epss_score": 0.00193, "epss_percentile": 0.41403}, "CVE-2022-4249": {"epss_score": 0.00198, "epss_percentile": 0.42041}, "CVE-2022-4250": {"epss_score": 0.00177, "epss_percentile": 0.3954}, "CVE-2022-4251": {"epss_score": 0.00173, "epss_percentile": 0.39053}, "CVE-2022-4252": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2022-4253": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2022-4254": {"epss_score": 0.00091, "epss_percentile": 0.2625}, "CVE-2022-4255": {"epss_score": 0.00185, "epss_percentile": 0.40485}, "CVE-2022-4256": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2022-4257": {"epss_score": 0.04197, "epss_percentile": 0.88381}, "CVE-2022-4258": {"epss_score": 0.00034, "epss_percentile": 0.09664}, "CVE-2022-4259": {"epss_score": 0.00202, "epss_percentile": 0.42472}, "CVE-2022-4260": {"epss_score": 0.0097, "epss_percentile": 0.7611}, "CVE-2022-4261": {"epss_score": 0.00208, "epss_percentile": 0.43281}, "CVE-2022-4262": {"epss_score": 0.06353, "epss_percentile": 0.90693}, "CVE-2022-4264": {"epss_score": 0.00165, "epss_percentile": 0.38115}, "CVE-2022-4265": {"epss_score": 0.00133, "epss_percentile": 0.33649}, "CVE-2022-4266": {"epss_score": 0.00097, "epss_percentile": 0.27589}, "CVE-2022-4267": {"epss_score": 0.00199, "epss_percentile": 0.42167}, "CVE-2022-4268": {"epss_score": 0.00537, "epss_percentile": 0.66899}, "CVE-2022-4269": {"epss_score": 0.00025, "epss_percentile": 0.06148}, "CVE-2022-4270": {"epss_score": 0.00196, "epss_percentile": 0.41749}, "CVE-2022-4271": {"epss_score": 0.00235, "epss_percentile": 0.46205}, "CVE-2022-4272": {"epss_score": 0.00373, "epss_percentile": 0.58504}, "CVE-2022-4273": {"epss_score": 0.00357, "epss_percentile": 0.57455}, "CVE-2022-4274": {"epss_score": 0.00202, "epss_percentile": 0.42408}, "CVE-2022-4275": {"epss_score": 0.00202, "epss_percentile": 0.42408}, "CVE-2022-4276": {"epss_score": 0.00231, "epss_percentile": 0.45773}, "CVE-2022-4277": {"epss_score": 0.00294, "epss_percentile": 0.52367}, "CVE-2022-4278": {"epss_score": 0.00313, "epss_percentile": 0.54043}, "CVE-2022-4279": {"epss_score": 0.00307, "epss_percentile": 0.53482}, "CVE-2022-4280": {"epss_score": 0.00212, "epss_percentile": 0.438}, "CVE-2022-4281": {"epss_score": 0.00129, "epss_percentile": 0.3311}, "CVE-2022-4282": {"epss_score": 0.00407, "epss_percentile": 0.60573}, "CVE-2022-4283": {"epss_score": 0.00176, "epss_percentile": 0.39399}, "CVE-2022-4285": {"epss_score": 0.00029, "epss_percentile": 0.07645}, "CVE-2022-4286": {"epss_score": 0.00233, "epss_percentile": 0.4601}, "CVE-2022-4287": {"epss_score": 0.00371, "epss_percentile": 0.58385}, "CVE-2022-4289": {"epss_score": 0.01968, "epss_percentile": 0.83087}, "CVE-2022-4290": {"epss_score": 0.00325, "epss_percentile": 0.55002}, "CVE-2022-4291": {"epss_score": 0.00114, "epss_percentile": 0.30743}, "CVE-2022-4292": {"epss_score": 0.00324, "epss_percentile": 0.54971}, "CVE-2022-4293": {"epss_score": 0.0021, "epss_percentile": 0.43612}, "CVE-2022-4294": {"epss_score": 0.00075, "epss_percentile": 0.22962}, "CVE-2022-4295": {"epss_score": 0.16021, "epss_percentile": 0.9456}, "CVE-2022-4296": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2022-4297": {"epss_score": 0.02563, "epss_percentile": 0.8511}, "CVE-2022-4298": {"epss_score": 0.55741, "epss_percentile": 0.97993}, "CVE-2022-4299": {"epss_score": 0.00113, "epss_percentile": 0.30642}, "CVE-2022-4300": {"epss_score": 0.004, "epss_percentile": 0.60149}, "CVE-2022-4301": {"epss_score": 0.14279, "epss_percentile": 0.94178}, "CVE-2022-4302": {"epss_score": 0.05593, "epss_percentile": 0.90032}, "CVE-2022-4303": {"epss_score": 0.00099, "epss_percentile": 0.28356}, "CVE-2022-4304": {"epss_score": 0.00255, "epss_percentile": 0.48721}, "CVE-2022-4305": {"epss_score": 0.88869, "epss_percentile": 0.99496}, "CVE-2022-4306": {"epss_score": 0.10701, "epss_percentile": 0.93075}, "CVE-2022-4307": {"epss_score": 0.00767, "epss_percentile": 0.72949}, "CVE-2022-4308": {"epss_score": 0.00041, "epss_percentile": 0.1241}, "CVE-2022-4309": {"epss_score": 0.00089, "epss_percentile": 0.2588}, "CVE-2022-4310": {"epss_score": 0.01249, "epss_percentile": 0.78876}, "CVE-2022-4311": {"epss_score": 0.0048, "epss_percentile": 0.64464}, "CVE-2022-4312": {"epss_score": 0.00058, "epss_percentile": 0.18543}, "CVE-2022-4313": {"epss_score": 0.00274, "epss_percentile": 0.50555}, "CVE-2022-4314": {"epss_score": 0.00425, "epss_percentile": 0.61704}, "CVE-2022-4315": {"epss_score": 0.00098, "epss_percentile": 0.27713}, "CVE-2022-4317": {"epss_score": 0.00152, "epss_percentile": 0.36502}, "CVE-2022-4318": {"epss_score": 0.00042, "epss_percentile": 0.12589}, "CVE-2022-4320": {"epss_score": 0.15457, "epss_percentile": 0.94432}, "CVE-2022-4321": {"epss_score": 0.1032, "epss_percentile": 0.92942}, "CVE-2022-4322": {"epss_score": 0.00525, "epss_percentile": 0.66388}, "CVE-2022-4323": {"epss_score": 0.00323, "epss_percentile": 0.54869}, "CVE-2022-4324": {"epss_score": 0.05593, "epss_percentile": 0.90032}, "CVE-2022-4325": {"epss_score": 0.12454, "epss_percentile": 0.93678}, "CVE-2022-4326": {"epss_score": 0.00026, "epss_percentile": 0.06551}, "CVE-2022-4328": {"epss_score": 0.82956, "epss_percentile": 0.99223}, "CVE-2022-4329": {"epss_score": 0.00336, "epss_percentile": 0.55947}, "CVE-2022-4330": {"epss_score": 0.00113, "epss_percentile": 0.30642}, "CVE-2022-4331": {"epss_score": 0.00122, "epss_percentile": 0.32096}, "CVE-2022-4332": {"epss_score": 0.00047, "epss_percentile": 0.14646}, "CVE-2022-4333": {"epss_score": 0.00646, "epss_percentile": 0.70149}, "CVE-2022-4335": {"epss_score": 0.00254, "epss_percentile": 0.48522}, "CVE-2022-4336": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-4337": {"epss_score": 0.00356, "epss_percentile": 0.57388}, "CVE-2022-4338": {"epss_score": 0.00484, "epss_percentile": 0.64639}, "CVE-2022-4340": {"epss_score": 0.00326, "epss_percentile": 0.55035}, "CVE-2022-4341": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-4342": {"epss_score": 0.01017, "epss_percentile": 0.76682}, "CVE-2022-4343": {"epss_score": 0.00039, "epss_percentile": 0.1162}, "CVE-2022-4344": {"epss_score": 0.00097, "epss_percentile": 0.27632}, "CVE-2022-4345": {"epss_score": 0.00081, "epss_percentile": 0.24235}, "CVE-2022-4346": {"epss_score": 0.00146, "epss_percentile": 0.35543}, "CVE-2022-4347": {"epss_score": 0.00177, "epss_percentile": 0.3954}, "CVE-2022-4348": {"epss_score": 0.00177, "epss_percentile": 0.3954}, "CVE-2022-4349": {"epss_score": 0.00107, "epss_percentile": 0.29602}, "CVE-2022-4350": {"epss_score": 0.00177, "epss_percentile": 0.3954}, "CVE-2022-4351": {"epss_score": 0.00702, "epss_percentile": 0.71506}, "CVE-2022-4352": {"epss_score": 0.00746, "epss_percentile": 0.72547}, "CVE-2022-4353": {"epss_score": 0.00285, "epss_percentile": 0.51648}, "CVE-2022-4354": {"epss_score": 0.00362, "epss_percentile": 0.57764}, "CVE-2022-4355": {"epss_score": 0.00604, "epss_percentile": 0.68954}, "CVE-2022-4356": {"epss_score": 0.00642, "epss_percentile": 0.70031}, "CVE-2022-4357": {"epss_score": 0.02111, "epss_percentile": 0.83647}, "CVE-2022-4358": {"epss_score": 0.00537, "epss_percentile": 0.66899}, "CVE-2022-4359": {"epss_score": 0.00537, "epss_percentile": 0.66899}, "CVE-2022-4360": {"epss_score": 0.00642, "epss_percentile": 0.70031}, "CVE-2022-4361": {"epss_score": 0.01241, "epss_percentile": 0.78819}, "CVE-2022-4362": {"epss_score": 0.00403, "epss_percentile": 0.60321}, "CVE-2022-4363": {"epss_score": 0.00021, "epss_percentile": 0.04743}, "CVE-2022-4364": {"epss_score": 0.13363, "epss_percentile": 0.93942}, "CVE-2022-4365": {"epss_score": 0.00578, "epss_percentile": 0.68198}, "CVE-2022-4366": {"epss_score": 0.00263, "epss_percentile": 0.49407}, "CVE-2022-4368": {"epss_score": 0.00162, "epss_percentile": 0.37724}, "CVE-2022-4369": {"epss_score": 0.00218, "epss_percentile": 0.44375}, "CVE-2022-4370": {"epss_score": 0.00537, "epss_percentile": 0.66899}, "CVE-2022-4371": {"epss_score": 0.00587, "epss_percentile": 0.68463}, "CVE-2022-4372": {"epss_score": 0.00537, "epss_percentile": 0.66899}, "CVE-2022-4373": {"epss_score": 0.00537, "epss_percentile": 0.66899}, "CVE-2022-4374": {"epss_score": 0.00206, "epss_percentile": 0.42933}, "CVE-2022-4375": {"epss_score": 0.31675, "epss_percentile": 0.96641}, "CVE-2022-4376": {"epss_score": 0.00124, "epss_percentile": 0.32434}, "CVE-2022-4377": {"epss_score": 0.00201, "epss_percentile": 0.42387}, "CVE-2022-4378": {"epss_score": 0.00024, "epss_percentile": 0.05856}, "CVE-2022-4379": {"epss_score": 0.00549, "epss_percentile": 0.67313}, "CVE-2022-4381": {"epss_score": 0.00252, "epss_percentile": 0.48373}, "CVE-2022-4382": {"epss_score": 0.00023, "epss_percentile": 0.05451}, "CVE-2022-4383": {"epss_score": 0.00694, "epss_percentile": 0.71341}, "CVE-2022-4384": {"epss_score": 0.00605, "epss_percentile": 0.68984}, "CVE-2022-4385": {"epss_score": 0.00085, "epss_percentile": 0.25029}, "CVE-2022-4386": {"epss_score": 0.00097, "epss_percentile": 0.27572}, "CVE-2022-4390": {"epss_score": 0.00431, "epss_percentile": 0.62044}, "CVE-2022-4391": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4392": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4393": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4394": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4395": {"epss_score": 0.7549, "epss_percentile": 0.98848}, "CVE-2022-4396": {"epss_score": 0.00424, "epss_percentile": 0.6166}, "CVE-2022-4397": {"epss_score": 0.00162, "epss_percentile": 0.3769}, "CVE-2022-4398": {"epss_score": 0.00248, "epss_percentile": 0.47959}, "CVE-2022-4399": {"epss_score": 0.0044, "epss_percentile": 0.62638}, "CVE-2022-4400": {"epss_score": 0.00187, "epss_percentile": 0.40794}, "CVE-2022-4401": {"epss_score": 0.00285, "epss_percentile": 0.51648}, "CVE-2022-4402": {"epss_score": 0.00756, "epss_percentile": 0.72743}, "CVE-2022-4403": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-4407": {"epss_score": 0.0462, "epss_percentile": 0.88929}, "CVE-2022-4408": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-4409": {"epss_score": 0.00154, "epss_percentile": 0.36709}, "CVE-2022-4410": {"epss_score": 0.00171, "epss_percentile": 0.38867}, "CVE-2022-4413": {"epss_score": 0.00234, "epss_percentile": 0.4619}, "CVE-2022-4414": {"epss_score": 0.00321, "epss_percentile": 0.54674}, "CVE-2022-4415": {"epss_score": 0.00029, "epss_percentile": 0.07588}, "CVE-2022-4416": {"epss_score": 0.00273, "epss_percentile": 0.5045}, "CVE-2022-4417": {"epss_score": 0.0044, "epss_percentile": 0.62628}, "CVE-2022-4418": {"epss_score": 0.00022, "epss_percentile": 0.04988}, "CVE-2022-4421": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-4422": {"epss_score": 0.00099, "epss_percentile": 0.28345}, "CVE-2022-4426": {"epss_score": 0.00284, "epss_percentile": 0.51491}, "CVE-2022-4427": {"epss_score": 0.00342, "epss_percentile": 0.56351}, "CVE-2022-4428": {"epss_score": 0.00203, "epss_percentile": 0.4256}, "CVE-2022-4429": {"epss_score": 0.00032, "epss_percentile": 0.08762}, "CVE-2022-4431": {"epss_score": 0.00145, "epss_percentile": 0.35418}, "CVE-2022-4432": {"epss_score": 0.0005, "epss_percentile": 0.15711}, "CVE-2022-4433": {"epss_score": 0.00056, "epss_percentile": 0.17895}, "CVE-2022-4434": {"epss_score": 0.0005, "epss_percentile": 0.15711}, "CVE-2022-4435": {"epss_score": 0.00056, "epss_percentile": 0.17895}, "CVE-2022-4436": {"epss_score": 0.00278, "epss_percentile": 0.50852}, "CVE-2022-4437": {"epss_score": 0.00232, "epss_percentile": 0.4591}, "CVE-2022-4438": {"epss_score": 0.00335, "epss_percentile": 0.55815}, "CVE-2022-4439": {"epss_score": 0.00401, "epss_percentile": 0.60204}, "CVE-2022-4440": {"epss_score": 0.00278, "epss_percentile": 0.50852}, "CVE-2022-4441": {"epss_score": 0.0081, "epss_percentile": 0.7372}, "CVE-2022-4442": {"epss_score": 0.00114, "epss_percentile": 0.30827}, "CVE-2022-4443": {"epss_score": 0.00089, "epss_percentile": 0.2588}, "CVE-2022-4444": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4445": {"epss_score": 0.01609, "epss_percentile": 0.81316}, "CVE-2022-4446": {"epss_score": 0.00724, "epss_percentile": 0.72036}, "CVE-2022-4447": {"epss_score": 0.77901, "epss_percentile": 0.98959}, "CVE-2022-4448": {"epss_score": 0.00423, "epss_percentile": 0.61588}, "CVE-2022-4449": {"epss_score": 0.00164, "epss_percentile": 0.3794}, "CVE-2022-4450": {"epss_score": 0.0014, "epss_percentile": 0.34729}, "CVE-2022-4451": {"epss_score": 0.0015, "epss_percentile": 0.36121}, "CVE-2022-4452": {"epss_score": 0.00174, "epss_percentile": 0.39225}, "CVE-2022-4453": {"epss_score": 0.00209, "epss_percentile": 0.43392}, "CVE-2022-4454": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-4455": {"epss_score": 0.00245, "epss_percentile": 0.47662}, "CVE-2022-4456": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-4457": {"epss_score": 0.00043, "epss_percentile": 0.13024}, "CVE-2022-4458": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2022-4459": {"epss_score": 0.00438, "epss_percentile": 0.62543}, "CVE-2022-4460": {"epss_score": 0.0015, "epss_percentile": 0.36121}, "CVE-2022-4462": {"epss_score": 0.00183, "epss_percentile": 0.40334}, "CVE-2022-4464": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4465": {"epss_score": 0.00197, "epss_percentile": 0.41931}, "CVE-2022-4466": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4467": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4468": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4469": {"epss_score": 0.00292, "epss_percentile": 0.52226}, "CVE-2022-4470": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4471": {"epss_score": 0.00612, "epss_percentile": 0.69231}, "CVE-2022-4472": {"epss_score": 0.00164, "epss_percentile": 0.3794}, "CVE-2022-4473": {"epss_score": 0.00438, "epss_percentile": 0.62543}, "CVE-2022-4474": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4475": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4476": {"epss_score": 0.00292, "epss_percentile": 0.52226}, "CVE-2022-4477": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4478": {"epss_score": 0.00175, "epss_percentile": 0.39341}, "CVE-2022-4479": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4480": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4481": {"epss_score": 0.00238, "epss_percentile": 0.46747}, "CVE-2022-4482": {"epss_score": 0.00158, "epss_percentile": 0.37298}, "CVE-2022-4483": {"epss_score": 0.00202, "epss_percentile": 0.42427}, "CVE-2022-4484": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4485": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4486": {"epss_score": 0.00202, "epss_percentile": 0.42427}, "CVE-2022-4487": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4488": {"epss_score": 0.00591, "epss_percentile": 0.68596}, "CVE-2022-4489": {"epss_score": 0.00901, "epss_percentile": 0.75167}, "CVE-2022-4491": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4492": {"epss_score": 0.00157, "epss_percentile": 0.37123}, "CVE-2022-4493": {"epss_score": 0.00582, "epss_percentile": 0.68297}, "CVE-2022-4494": {"epss_score": 0.00789, "epss_percentile": 0.73361}, "CVE-2022-4495": {"epss_score": 0.00267, "epss_percentile": 0.50005}, "CVE-2022-4496": {"epss_score": 0.00266, "epss_percentile": 0.49886}, "CVE-2022-4497": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4498": {"epss_score": 0.00529, "epss_percentile": 0.66584}, "CVE-2022-4499": {"epss_score": 0.00059, "epss_percentile": 0.18753}, "CVE-2022-4501": {"epss_score": 0.0015, "epss_percentile": 0.36144}, "CVE-2022-4502": {"epss_score": 0.04169, "epss_percentile": 0.88345}, "CVE-2022-4503": {"epss_score": 0.00805, "epss_percentile": 0.73643}, "CVE-2022-4504": {"epss_score": 0.00427, "epss_percentile": 0.61898}, "CVE-2022-4505": {"epss_score": 0.00514, "epss_percentile": 0.65963}, "CVE-2022-4506": {"epss_score": 0.0021, "epss_percentile": 0.4347}, "CVE-2022-4507": {"epss_score": 0.00209, "epss_percentile": 0.43392}, "CVE-2022-4508": {"epss_score": 0.00209, "epss_percentile": 0.43392}, "CVE-2022-4509": {"epss_score": 0.0016, "epss_percentile": 0.37479}, "CVE-2022-4510": {"epss_score": 0.4177, "epss_percentile": 0.97293}, "CVE-2022-4511": {"epss_score": 0.00379, "epss_percentile": 0.58861}, "CVE-2022-4512": {"epss_score": 0.00563, "epss_percentile": 0.67718}, "CVE-2022-4513": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4514": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4515": {"epss_score": 0.01029, "epss_percentile": 0.76834}, "CVE-2022-4519": {"epss_score": 0.00264, "epss_percentile": 0.49717}, "CVE-2022-4520": {"epss_score": 0.00322, "epss_percentile": 0.54746}, "CVE-2022-4521": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2022-4522": {"epss_score": 0.0027, "epss_percentile": 0.50267}, "CVE-2022-4523": {"epss_score": 0.00392, "epss_percentile": 0.59676}, "CVE-2022-4524": {"epss_score": 0.00269, "epss_percentile": 0.50103}, "CVE-2022-4525": {"epss_score": 0.00267, "epss_percentile": 0.50005}, "CVE-2022-4526": {"epss_score": 0.00392, "epss_percentile": 0.59676}, "CVE-2022-4527": {"epss_score": 0.0032, "epss_percentile": 0.54621}, "CVE-2022-4529": {"epss_score": 0.00053, "epss_percentile": 0.16737}, "CVE-2022-4532": {"epss_score": 0.00109, "epss_percentile": 0.29966}, "CVE-2022-4533": {"epss_score": 0.00058, "epss_percentile": 0.18283}, "CVE-2022-4534": {"epss_score": 0.00043, "epss_percentile": 0.13213}, "CVE-2022-4536": {"epss_score": 0.00062, "epss_percentile": 0.19662}, "CVE-2022-4537": {"epss_score": 0.00107, "epss_percentile": 0.29626}, "CVE-2022-4539": {"epss_score": 0.05147, "epss_percentile": 0.89543}, "CVE-2022-4541": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2022-4542": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4543": {"epss_score": 0.00238, "epss_percentile": 0.46833}, "CVE-2022-4544": {"epss_score": 0.00202, "epss_percentile": 0.42427}, "CVE-2022-4545": {"epss_score": 0.0016, "epss_percentile": 0.37479}, "CVE-2022-4546": {"epss_score": 0.00644, "epss_percentile": 0.70097}, "CVE-2022-4547": {"epss_score": 0.00337, "epss_percentile": 0.56041}, "CVE-2022-4548": {"epss_score": 0.0008, "epss_percentile": 0.24047}, "CVE-2022-4549": {"epss_score": 0.00135, "epss_percentile": 0.33969}, "CVE-2022-4550": {"epss_score": 0.00136, "epss_percentile": 0.34137}, "CVE-2022-4551": {"epss_score": 0.00332, "epss_percentile": 0.5558}, "CVE-2022-4552": {"epss_score": 0.00159, "epss_percentile": 0.37356}, "CVE-2022-4553": {"epss_score": 0.00116, "epss_percentile": 0.3116}, "CVE-2022-4554": {"epss_score": 0.00098, "epss_percentile": 0.27812}, "CVE-2022-4555": {"epss_score": 0.00651, "epss_percentile": 0.70286}, "CVE-2022-4556": {"epss_score": 0.00166, "epss_percentile": 0.3827}, "CVE-2022-4557": {"epss_score": 0.00097, "epss_percentile": 0.27479}, "CVE-2022-4558": {"epss_score": 0.0027, "epss_percentile": 0.50267}, "CVE-2022-4559": {"epss_score": 0.00406, "epss_percentile": 0.60519}, "CVE-2022-4560": {"epss_score": 0.00267, "epss_percentile": 0.50005}, "CVE-2022-4561": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2022-4562": {"epss_score": 0.00497, "epss_percentile": 0.652}, "CVE-2022-4563": {"epss_score": 0.00201, "epss_percentile": 0.4236}, "CVE-2022-4564": {"epss_score": 0.00214, "epss_percentile": 0.44}, "CVE-2022-4565": {"epss_score": 0.00273, "epss_percentile": 0.50432}, "CVE-2022-4566": {"epss_score": 0.00376, "epss_percentile": 0.58642}, "CVE-2022-4567": {"epss_score": 0.00165, "epss_percentile": 0.38047}, "CVE-2022-4568": {"epss_score": 0.00037, "epss_percentile": 0.10922}, "CVE-2022-4569": {"epss_score": 0.0004, "epss_percentile": 0.12033}, "CVE-2022-4570": {"epss_score": 0.00145, "epss_percentile": 0.35418}, "CVE-2022-4571": {"epss_score": 0.00223, "epss_percentile": 0.44899}, "CVE-2022-4572": {"epss_score": 0.00584, "epss_percentile": 0.68397}, "CVE-2022-4573": {"epss_score": 0.00025, "epss_percentile": 0.06056}, "CVE-2022-4574": {"epss_score": 0.00022, "epss_percentile": 0.05281}, "CVE-2022-4575": {"epss_score": 5e-05, "epss_percentile": 0.0021}, "CVE-2022-4576": {"epss_score": 0.00145, "epss_percentile": 0.35418}, "CVE-2022-4577": {"epss_score": 0.00467, "epss_percentile": 0.63832}, "CVE-2022-4578": {"epss_score": 0.00158, "epss_percentile": 0.37298}, "CVE-2022-4580": {"epss_score": 0.00367, "epss_percentile": 0.58107}, "CVE-2022-4581": {"epss_score": 0.00211, "epss_percentile": 0.43701}, "CVE-2022-4582": {"epss_score": 0.0027, "epss_percentile": 0.50267}, "CVE-2022-4583": {"epss_score": 0.01008, "epss_percentile": 0.76565}, "CVE-2022-4584": {"epss_score": 0.00525, "epss_percentile": 0.66381}, "CVE-2022-4585": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4586": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4587": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4588": {"epss_score": 0.00311, "epss_percentile": 0.53921}, "CVE-2022-4589": {"epss_score": 0.00218, "epss_percentile": 0.44434}, "CVE-2022-4590": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4591": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4592": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2022-4593": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-4594": {"epss_score": 0.00426, "epss_percentile": 0.61746}, "CVE-2022-4595": {"epss_score": 0.0027, "epss_percentile": 0.50267}, "CVE-2022-4596": {"epss_score": 0.0027, "epss_percentile": 0.50267}, "CVE-2022-4597": {"epss_score": 0.00392, "epss_percentile": 0.59676}, "CVE-2022-4598": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4599": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4600": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4601": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4602": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4603": {"epss_score": 0.00138, "epss_percentile": 0.34368}, "CVE-2022-4604": {"epss_score": 0.0022, "epss_percentile": 0.44547}, "CVE-2022-4605": {"epss_score": 0.00338, "epss_percentile": 0.56145}, "CVE-2022-4606": {"epss_score": 0.12007, "epss_percentile": 0.93545}, "CVE-2022-4607": {"epss_score": 0.0044, "epss_percentile": 0.62629}, "CVE-2022-4608": {"epss_score": 0.00052, "epss_percentile": 0.16547}, "CVE-2022-4609": {"epss_score": 0.0032, "epss_percentile": 0.54641}, "CVE-2022-4610": {"epss_score": 0.00066, "epss_percentile": 0.20906}, "CVE-2022-4611": {"epss_score": 0.03906, "epss_percentile": 0.87926}, "CVE-2022-4612": {"epss_score": 0.00209, "epss_percentile": 0.43408}, "CVE-2022-4613": {"epss_score": 0.00262, "epss_percentile": 0.49381}, "CVE-2022-4614": {"epss_score": 0.00307, "epss_percentile": 0.53521}, "CVE-2022-4615": {"epss_score": 0.00947, "epss_percentile": 0.75815}, "CVE-2022-4616": {"epss_score": 0.09903, "epss_percentile": 0.92764}, "CVE-2022-4617": {"epss_score": 0.00195, "epss_percentile": 0.41706}, "CVE-2022-4619": {"epss_score": 0.00242, "epss_percentile": 0.47344}, "CVE-2022-4621": {"epss_score": 0.00166, "epss_percentile": 0.38158}, "CVE-2022-4622": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4623": {"epss_score": 0.00092, "epss_percentile": 0.26577}, "CVE-2022-4624": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4625": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4626": {"epss_score": 0.00549, "epss_percentile": 0.6731}, "CVE-2022-4627": {"epss_score": 0.00175, "epss_percentile": 0.39341}, "CVE-2022-4628": {"epss_score": 0.00332, "epss_percentile": 0.5558}, "CVE-2022-4629": {"epss_score": 0.00175, "epss_percentile": 0.39341}, "CVE-2022-4630": {"epss_score": 0.00097, "epss_percentile": 0.27561}, "CVE-2022-4631": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-4632": {"epss_score": 0.00272, "epss_percentile": 0.50411}, "CVE-2022-4633": {"epss_score": 0.00167, "epss_percentile": 0.38363}, "CVE-2022-4634": {"epss_score": 0.00922, "epss_percentile": 0.75491}, "CVE-2022-4636": {"epss_score": 0.00243, "epss_percentile": 0.47471}, "CVE-2022-4637": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2022-4638": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2022-4639": {"epss_score": 0.00182, "epss_percentile": 0.40219}, "CVE-2022-4640": {"epss_score": 0.00177, "epss_percentile": 0.3954}, "CVE-2022-4641": {"epss_score": 0.00068, "epss_percentile": 0.2127}, "CVE-2022-4642": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2022-4643": {"epss_score": 0.03837, "epss_percentile": 0.87825}, "CVE-2022-4644": {"epss_score": 0.00319, "epss_percentile": 0.54543}, "CVE-2022-4645": {"epss_score": 0.00011, "epss_percentile": 0.01043}, "CVE-2022-4646": {"epss_score": 0.00136, "epss_percentile": 0.34197}, "CVE-2022-4647": {"epss_score": 0.00544, "epss_percentile": 0.67151}, "CVE-2022-4648": {"epss_score": 0.00164, "epss_percentile": 0.3794}, "CVE-2022-4649": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4650": {"epss_score": 0.00202, "epss_percentile": 0.42427}, "CVE-2022-4651": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4652": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4653": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4654": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4655": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4656": {"epss_score": 0.00367, "epss_percentile": 0.58107}, "CVE-2022-4657": {"epss_score": 0.00411, "epss_percentile": 0.60882}, "CVE-2022-4658": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4661": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4662": {"epss_score": 5e-05, "epss_percentile": 0.00201}, "CVE-2022-4663": {"epss_score": 0.00196, "epss_percentile": 0.41736}, "CVE-2022-4664": {"epss_score": 0.00467, "epss_percentile": 0.63832}, "CVE-2022-4665": {"epss_score": 0.00243, "epss_percentile": 0.47411}, "CVE-2022-4666": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4667": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4668": {"epss_score": 0.00175, "epss_percentile": 0.39341}, "CVE-2022-4669": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4670": {"epss_score": 0.00549, "epss_percentile": 0.6731}, "CVE-2022-4671": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4672": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4673": {"epss_score": 0.00158, "epss_percentile": 0.37298}, "CVE-2022-4674": {"epss_score": 0.0046, "epss_percentile": 0.63515}, "CVE-2022-4675": {"epss_score": 0.00172, "epss_percentile": 0.39027}, "CVE-2022-4676": {"epss_score": 0.0011, "epss_percentile": 0.30128}, "CVE-2022-4677": {"epss_score": 0.0046, "epss_percentile": 0.63515}, "CVE-2022-4678": {"epss_score": 0.00423, "epss_percentile": 0.61588}, "CVE-2022-4679": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4680": {"epss_score": 0.00411, "epss_percentile": 0.60873}, "CVE-2022-4681": {"epss_score": 0.04453, "epss_percentile": 0.88709}, "CVE-2022-4682": {"epss_score": 0.00695, "epss_percentile": 0.7137}, "CVE-2022-4683": {"epss_score": 0.00137, "epss_percentile": 0.34211}, "CVE-2022-4684": {"epss_score": 0.00269, "epss_percentile": 0.50109}, "CVE-2022-4686": {"epss_score": 0.00139, "epss_percentile": 0.34657}, "CVE-2022-4687": {"epss_score": 0.00278, "epss_percentile": 0.50879}, "CVE-2022-4688": {"epss_score": 0.00269, "epss_percentile": 0.50109}, "CVE-2022-4689": {"epss_score": 0.00282, "epss_percentile": 0.51237}, "CVE-2022-4690": {"epss_score": 0.00261, "epss_percentile": 0.49285}, "CVE-2022-4691": {"epss_score": 0.00336, "epss_percentile": 0.55997}, "CVE-2022-4692": {"epss_score": 0.0023, "epss_percentile": 0.45721}, "CVE-2022-4693": {"epss_score": 0.03233, "epss_percentile": 0.867}, "CVE-2022-4694": {"epss_score": 0.00302, "epss_percentile": 0.53101}, "CVE-2022-4695": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2022-4696": {"epss_score": 0.00014, "epss_percentile": 0.01983}, "CVE-2022-4697": {"epss_score": 0.00396, "epss_percentile": 0.59927}, "CVE-2022-4698": {"epss_score": 0.00396, "epss_percentile": 0.59927}, "CVE-2022-4699": {"epss_score": 0.00226, "epss_percentile": 0.45299}, "CVE-2022-4700": {"epss_score": 0.0012, "epss_percentile": 0.31783}, "CVE-2022-4701": {"epss_score": 0.00167, "epss_percentile": 0.38306}, "CVE-2022-4702": {"epss_score": 0.00062, "epss_percentile": 0.19778}, "CVE-2022-4703": {"epss_score": 0.00085, "epss_percentile": 0.25097}, "CVE-2022-4704": {"epss_score": 0.00069, "epss_percentile": 0.21517}, "CVE-2022-4705": {"epss_score": 0.00085, "epss_percentile": 0.25243}, "CVE-2022-4706": {"epss_score": 0.0016, "epss_percentile": 0.37479}, "CVE-2022-4707": {"epss_score": 0.00104, "epss_percentile": 0.29235}, "CVE-2022-4708": {"epss_score": 0.00085, "epss_percentile": 0.25243}, "CVE-2022-4709": {"epss_score": 0.00085, "epss_percentile": 0.25243}, "CVE-2022-4710": {"epss_score": 0.00837, "epss_percentile": 0.74154}, "CVE-2022-4711": {"epss_score": 0.00084, "epss_percentile": 0.24881}, "CVE-2022-4712": {"epss_score": 0.01805, "epss_percentile": 0.82345}, "CVE-2022-4714": {"epss_score": 0.00164, "epss_percentile": 0.3794}, "CVE-2022-4715": {"epss_score": 0.00164, "epss_percentile": 0.3794}, "CVE-2022-4716": {"epss_score": 0.00175, "epss_percentile": 0.39341}, "CVE-2022-4717": {"epss_score": 0.00473, "epss_percentile": 0.64102}, "CVE-2022-4718": {"epss_score": 0.00175, "epss_percentile": 0.39341}, "CVE-2022-4719": {"epss_score": 0.00483, "epss_percentile": 0.64576}, "CVE-2022-4720": {"epss_score": 0.00215, "epss_percentile": 0.44099}, "CVE-2022-4721": {"epss_score": 0.00355, "epss_percentile": 0.57278}, "CVE-2022-4722": {"epss_score": 0.00164, "epss_percentile": 0.37892}, "CVE-2022-4723": {"epss_score": 0.00236, "epss_percentile": 0.46349}, "CVE-2022-4724": {"epss_score": 0.00248, "epss_percentile": 0.47933}, "CVE-2022-4725": {"epss_score": 0.00381, "epss_percentile": 0.58986}, "CVE-2022-4726": {"epss_score": 0.00179, "epss_percentile": 0.39791}, "CVE-2022-4727": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2022-4728": {"epss_score": 0.00306, "epss_percentile": 0.53444}, "CVE-2022-4729": {"epss_score": 0.00136, "epss_percentile": 0.34135}, "CVE-2022-4730": {"epss_score": 0.00298, "epss_percentile": 0.52793}, "CVE-2022-4731": {"epss_score": 0.00354, "epss_percentile": 0.57233}, "CVE-2022-4732": {"epss_score": 0.01113, "epss_percentile": 0.77683}, "CVE-2022-4733": {"epss_score": 0.00756, "epss_percentile": 0.72738}, "CVE-2022-4734": {"epss_score": 0.00341, "epss_percentile": 0.56329}, "CVE-2022-4735": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2022-4736": {"epss_score": 0.00392, "epss_percentile": 0.59676}, "CVE-2022-4737": {"epss_score": 0.00145, "epss_percentile": 0.35457}, "CVE-2022-4738": {"epss_score": 0.00337, "epss_percentile": 0.56029}, "CVE-2022-4739": {"epss_score": 0.00238, "epss_percentile": 0.46837}, "CVE-2022-4740": {"epss_score": 0.00402, "epss_percentile": 0.60307}, "CVE-2022-4741": {"epss_score": 0.00445, "epss_percentile": 0.62863}, "CVE-2022-4742": {"epss_score": 0.00089, "epss_percentile": 0.25888}, "CVE-2022-4743": {"epss_score": 0.00057, "epss_percentile": 0.18188}, "CVE-2022-4744": {"epss_score": 0.0008, "epss_percentile": 0.24093}, "CVE-2022-4745": {"epss_score": 0.00257, "epss_percentile": 0.48858}, "CVE-2022-4746": {"epss_score": 0.00403, "epss_percentile": 0.60376}, "CVE-2022-4747": {"epss_score": 0.00355, "epss_percentile": 0.57274}, "CVE-2022-4748": {"epss_score": 0.00646, "epss_percentile": 0.70127}, "CVE-2022-4749": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4750": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4751": {"epss_score": 0.0015, "epss_percentile": 0.36121}, "CVE-2022-4752": {"epss_score": 0.00164, "epss_percentile": 0.3794}, "CVE-2022-4753": {"epss_score": 0.0015, "epss_percentile": 0.36121}, "CVE-2022-4754": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4755": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2022-4756": {"epss_score": 0.00255, "epss_percentile": 0.4865}, "CVE-2022-4757": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4758": {"epss_score": 0.00145, "epss_percentile": 0.35418}, "CVE-2022-4759": {"epss_score": 0.00563, "epss_percentile": 0.67718}, "CVE-2022-4760": {"epss_score": 0.00158, "epss_percentile": 0.37298}, "CVE-2022-4761": {"epss_score": 0.00211, "epss_percentile": 0.43682}, "CVE-2022-4762": {"epss_score": 0.00279, "epss_percentile": 0.50933}, "CVE-2022-4763": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4764": {"epss_score": 0.00193, "epss_percentile": 0.41449}, "CVE-2022-4765": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4766": {"epss_score": 0.00147, "epss_percentile": 0.35774}, "CVE-2022-4767": {"epss_score": 0.00294, "epss_percentile": 0.52417}, "CVE-2022-4768": {"epss_score": 0.0061, "epss_percentile": 0.69158}, "CVE-2022-4769": {"epss_score": 0.00317, "epss_percentile": 0.54332}, "CVE-2022-4770": {"epss_score": 0.00242, "epss_percentile": 0.47387}, "CVE-2022-4771": {"epss_score": 0.00314, "epss_percentile": 0.54137}, "CVE-2022-4772": {"epss_score": 0.00201, "epss_percentile": 0.42354}, "CVE-2022-4773": {"epss_score": 0.0014, "epss_percentile": 0.34704}, "CVE-2022-4774": {"epss_score": 0.0526, "epss_percentile": 0.89668}, "CVE-2022-4775": {"epss_score": 0.00145, "epss_percentile": 0.35418}, "CVE-2022-4776": {"epss_score": 0.00226, "epss_percentile": 0.45299}, "CVE-2022-4777": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4778": {"epss_score": 0.00484, "epss_percentile": 0.64637}, "CVE-2022-4779": {"epss_score": 0.0028, "epss_percentile": 0.51002}, "CVE-2022-4780": {"epss_score": 0.00051, "epss_percentile": 0.16181}, "CVE-2022-4781": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4782": {"epss_score": 0.00101, "epss_percentile": 0.28636}, "CVE-2022-4783": {"epss_score": 0.00279, "epss_percentile": 0.50933}, "CVE-2022-4784": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4785": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4786": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4787": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4788": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4789": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4790": {"epss_score": 0.00145, "epss_percentile": 0.35418}, "CVE-2022-4791": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4792": {"epss_score": 0.00302, "epss_percentile": 0.5312}, "CVE-2022-4793": {"epss_score": 0.00211, "epss_percentile": 0.43682}, "CVE-2022-4794": {"epss_score": 0.00257, "epss_percentile": 0.4885}, "CVE-2022-4795": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4796": {"epss_score": 0.00334, "epss_percentile": 0.55733}, "CVE-2022-4797": {"epss_score": 0.00337, "epss_percentile": 0.56045}, "CVE-2022-4798": {"epss_score": 0.00156, "epss_percentile": 0.36973}, "CVE-2022-4799": {"epss_score": 0.0024, "epss_percentile": 0.4696}, "CVE-2022-4800": {"epss_score": 0.00191, "epss_percentile": 0.41264}, "CVE-2022-4801": {"epss_score": 0.00225, "epss_percentile": 0.45081}, "CVE-2022-4802": {"epss_score": 0.00215, "epss_percentile": 0.44041}, "CVE-2022-4803": {"epss_score": 0.00132, "epss_percentile": 0.33572}, "CVE-2022-4804": {"epss_score": 0.00376, "epss_percentile": 0.58668}, "CVE-2022-4805": {"epss_score": 0.00254, "epss_percentile": 0.48527}, "CVE-2022-4806": {"epss_score": 0.00035, "epss_percentile": 0.10071}, "CVE-2022-4807": {"epss_score": 0.00196, "epss_percentile": 0.41736}, "CVE-2022-4808": {"epss_score": 0.00217, "epss_percentile": 0.44308}, "CVE-2022-4809": {"epss_score": 0.00337, "epss_percentile": 0.56027}, "CVE-2022-4810": {"epss_score": 0.00172, "epss_percentile": 0.38958}, "CVE-2022-4811": {"epss_score": 0.00191, "epss_percentile": 0.41204}, "CVE-2022-4812": {"epss_score": 0.00166, "epss_percentile": 0.38153}, "CVE-2022-4813": {"epss_score": 0.00259, "epss_percentile": 0.49035}, "CVE-2022-4814": {"epss_score": 0.00259, "epss_percentile": 0.49035}, "CVE-2022-4815": {"epss_score": 0.00509, "epss_percentile": 0.65743}, "CVE-2022-4816": {"epss_score": 0.00046, "epss_percentile": 0.14377}, "CVE-2022-4817": {"epss_score": 0.00247, "epss_percentile": 0.47815}, "CVE-2022-4818": {"epss_score": 0.00383, "epss_percentile": 0.5909}, "CVE-2022-4819": {"epss_score": 0.00311, "epss_percentile": 0.53921}, "CVE-2022-4820": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2022-4821": {"epss_score": 0.00313, "epss_percentile": 0.54019}, "CVE-2022-4822": {"epss_score": 0.00313, "epss_percentile": 0.54019}, "CVE-2022-4823": {"epss_score": 0.00332, "epss_percentile": 0.55568}, "CVE-2022-4824": {"epss_score": 0.00467, "epss_percentile": 0.63832}, "CVE-2022-4825": {"epss_score": 0.00335, "epss_percentile": 0.55899}, "CVE-2022-4826": {"epss_score": 0.00279, "epss_percentile": 0.50933}, "CVE-2022-4827": {"epss_score": 0.00149, "epss_percentile": 0.36025}, "CVE-2022-4828": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4829": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4830": {"epss_score": 0.18601, "epss_percentile": 0.9504}, "CVE-2022-4831": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4832": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2022-4833": {"epss_score": 0.00304, "epss_percentile": 0.53248}, "CVE-2022-4834": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4835": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2022-4836": {"epss_score": 0.0027, "epss_percentile": 0.50227}, "CVE-2022-4837": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2022-4838": {"epss_score": 0.00367, "epss_percentile": 0.58107}, "CVE-2022-4839": {"epss_score": 0.00178, "epss_percentile": 0.39698}, "CVE-2022-4840": {"epss_score": 0.0027, "epss_percentile": 0.50272}, "CVE-2022-4841": {"epss_score": 0.00282, "epss_percentile": 0.51286}, "CVE-2022-4842": {"epss_score": 0.00018, "epss_percentile": 0.03825}, "CVE-2022-4843": {"epss_score": 0.00052, "epss_percentile": 0.16349}, "CVE-2022-4844": {"epss_score": 0.0017, "epss_percentile": 0.38749}, "CVE-2022-4845": {"epss_score": 0.00091, "epss_percentile": 0.26388}, "CVE-2022-4846": {"epss_score": 0.00094, "epss_percentile": 0.268}, "CVE-2022-4847": {"epss_score": 0.0033, "epss_percentile": 0.55492}, "CVE-2022-4848": {"epss_score": 0.00179, "epss_percentile": 0.39819}, "CVE-2022-4849": {"epss_score": 0.0016, "epss_percentile": 0.37512}, "CVE-2022-4850": {"epss_score": 0.00114, "epss_percentile": 0.30872}, "CVE-2022-4851": {"epss_score": 0.00419, "epss_percentile": 0.61386}, "CVE-2022-4855": {"epss_score": 0.02907, "epss_percentile": 0.85964}, "CVE-2022-4856": {"epss_score": 0.00357, "epss_percentile": 0.57404}, "CVE-2022-4857": {"epss_score": 0.00341, "epss_percentile": 0.56328}, "CVE-2022-4858": {"epss_score": 0.00286, "epss_percentile": 0.51688}, "CVE-2022-4859": {"epss_score": 0.00355, "epss_percentile": 0.57279}, "CVE-2022-4860": {"epss_score": 0.00351, "epss_percentile": 0.57037}, "CVE-2022-4861": {"epss_score": 0.00289, "epss_percentile": 0.52}, "CVE-2022-4862": {"epss_score": 0.00287, "epss_percentile": 0.51816}, "CVE-2022-4863": {"epss_score": 0.00241, "epss_percentile": 0.4726}, "CVE-2022-4864": {"epss_score": 0.00299, "epss_percentile": 0.52901}, "CVE-2022-4865": {"epss_score": 0.002, "epss_percentile": 0.42205}, "CVE-2022-4866": {"epss_score": 0.00282, "epss_percentile": 0.5123}, "CVE-2022-4867": {"epss_score": 0.00135, "epss_percentile": 0.33975}, "CVE-2022-4868": {"epss_score": 0.00243, "epss_percentile": 0.47497}, "CVE-2022-4869": {"epss_score": 0.00326, "epss_percentile": 0.55041}, "CVE-2022-4870": {"epss_score": 0.00186, "epss_percentile": 0.4065}, "CVE-2022-4871": {"epss_score": 0.0027, "epss_percentile": 0.50207}, "CVE-2022-4872": {"epss_score": 0.00718, "epss_percentile": 0.71934}, "CVE-2022-4873": {"epss_score": 0.10825, "epss_percentile": 0.93125}, "CVE-2022-4874": {"epss_score": 0.00303, "epss_percentile": 0.53192}, "CVE-2022-4875": {"epss_score": 0.00405, "epss_percentile": 0.60486}, "CVE-2022-4876": {"epss_score": 0.00341, "epss_percentile": 0.5629}, "CVE-2022-4877": {"epss_score": 0.00269, "epss_percentile": 0.50174}, "CVE-2022-4878": {"epss_score": 0.00282, "epss_percentile": 0.51238}, "CVE-2022-4879": {"epss_score": 0.00215, "epss_percentile": 0.44079}, "CVE-2022-4880": {"epss_score": 0.0014, "epss_percentile": 0.34793}, "CVE-2022-4881": {"epss_score": 0.00088, "epss_percentile": 0.25772}, "CVE-2022-4882": {"epss_score": 0.00159, "epss_percentile": 0.37396}, "CVE-2022-4883": {"epss_score": 0.00198, "epss_percentile": 0.42089}, "CVE-2022-4884": {"epss_score": 0.00072, "epss_percentile": 0.22303}, "CVE-2022-4885": {"epss_score": 0.00084, "epss_percentile": 0.24851}, "CVE-2022-4886": {"epss_score": 0.00186, "epss_percentile": 0.40644}, "CVE-2022-4888": {"epss_score": 0.00316, "epss_percentile": 0.54273}, "CVE-2022-4889": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2022-4890": {"epss_score": 0.00105, "epss_percentile": 0.29254}, "CVE-2022-4891": {"epss_score": 0.00157, "epss_percentile": 0.37136}, "CVE-2022-4892": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2022-4894": {"epss_score": 0.00122, "epss_percentile": 0.3209}, "CVE-2022-4895": {"epss_score": 0.00081, "epss_percentile": 0.24267}, "CVE-2022-4896": {"epss_score": 0.01319, "epss_percentile": 0.79434}, "CVE-2022-4897": {"epss_score": 0.13401, "epss_percentile": 0.93952}, "CVE-2022-4898": {"epss_score": 0.0004, "epss_percentile": 0.12044}, "CVE-2022-4899": {"epss_score": 0.00205, "epss_percentile": 0.42753}, "CVE-2022-4900": {"epss_score": 0.00127, "epss_percentile": 0.32814}, "CVE-2022-4901": {"epss_score": 0.00187, "epss_percentile": 0.40777}, "CVE-2022-4902": {"epss_score": 0.00815, "epss_percentile": 0.73793}, "CVE-2022-4903": {"epss_score": 0.00052, "epss_percentile": 0.16617}, "CVE-2022-4904": {"epss_score": 0.00159, "epss_percentile": 0.3734}, "CVE-2022-4905": {"epss_score": 0.00248, "epss_percentile": 0.47977}, "CVE-2022-4906": {"epss_score": 0.32112, "epss_percentile": 0.96672}, "CVE-2022-4907": {"epss_score": 0.01448, "epss_percentile": 0.80336}, "CVE-2022-4908": {"epss_score": 0.00562, "epss_percentile": 0.67682}, "CVE-2022-4909": {"epss_score": 0.00028, "epss_percentile": 0.07305}, "CVE-2022-4910": {"epss_score": 0.00049, "epss_percentile": 0.15465}, "CVE-2022-4911": {"epss_score": 0.00032, "epss_percentile": 0.08751}, "CVE-2022-4912": {"epss_score": 0.00612, "epss_percentile": 0.69228}, "CVE-2022-4913": {"epss_score": 0.00156, "epss_percentile": 0.36885}, "CVE-2022-4914": {"epss_score": 0.0006, "epss_percentile": 0.19093}, "CVE-2022-4915": {"epss_score": 0.00156, "epss_percentile": 0.36885}, "CVE-2022-4916": {"epss_score": 0.00711, "epss_percentile": 0.71731}, "CVE-2022-4917": {"epss_score": 0.0012, "epss_percentile": 0.31755}, "CVE-2022-4918": {"epss_score": 0.00711, "epss_percentile": 0.71731}, "CVE-2022-4919": {"epss_score": 0.00711, "epss_percentile": 0.71731}, "CVE-2022-4920": {"epss_score": 0.00812, "epss_percentile": 0.73742}, "CVE-2022-4921": {"epss_score": 0.00963, "epss_percentile": 0.76018}, "CVE-2022-4922": {"epss_score": 0.00156, "epss_percentile": 0.36885}, "CVE-2022-4923": {"epss_score": 0.00051, "epss_percentile": 0.16259}, "CVE-2022-4924": {"epss_score": 0.00752, "epss_percentile": 0.72667}, "CVE-2022-4925": {"epss_score": 0.0009, "epss_percentile": 0.26139}, "CVE-2022-4926": {"epss_score": 0.00047, "epss_percentile": 0.14885}, "CVE-2022-4927": {"epss_score": 0.00067, "epss_percentile": 0.21106}, "CVE-2022-4928": {"epss_score": 0.00085, "epss_percentile": 0.25112}, "CVE-2022-4929": {"epss_score": 0.00085, "epss_percentile": 0.25112}, "CVE-2022-4930": {"epss_score": 0.00085, "epss_percentile": 0.25112}, "CVE-2022-4931": {"epss_score": 0.00115, "epss_percentile": 0.30899}, "CVE-2022-4932": {"epss_score": 0.00115, "epss_percentile": 0.30899}, "CVE-2022-4933": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2022-4934": {"epss_score": 0.00196, "epss_percentile": 0.41801}, "CVE-2022-4935": {"epss_score": 0.00082, "epss_percentile": 0.24568}, "CVE-2022-4936": {"epss_score": 0.00102, "epss_percentile": 0.28759}, "CVE-2022-4937": {"epss_score": 0.00317, "epss_percentile": 0.54313}, "CVE-2022-4938": {"epss_score": 0.00102, "epss_percentile": 0.28759}, "CVE-2022-4939": {"epss_score": 0.06291, "epss_percentile": 0.90648}, "CVE-2022-4940": {"epss_score": 0.11237, "epss_percentile": 0.93275}, "CVE-2022-4941": {"epss_score": 0.00156, "epss_percentile": 0.36888}, "CVE-2022-4942": {"epss_score": 0.00072, "epss_percentile": 0.22333}, "CVE-2022-4943": {"epss_score": 0.00339, "epss_percentile": 0.56168}, "CVE-2022-4944": {"epss_score": 0.02628, "epss_percentile": 0.85274}, "CVE-2022-4945": {"epss_score": 0.00028, "epss_percentile": 0.07257}, "CVE-2022-4946": {"epss_score": 0.00386, "epss_percentile": 0.59268}, "CVE-2022-4948": {"epss_score": 0.00028, "epss_percentile": 0.0731}, "CVE-2022-4949": {"epss_score": 0.06268, "epss_percentile": 0.90625}, "CVE-2022-4950": {"epss_score": 0.03886, "epss_percentile": 0.87904}, "CVE-2022-4952": {"epss_score": 0.00049, "epss_percentile": 0.15364}, "CVE-2022-4953": {"epss_score": 0.08952, "epss_percentile": 0.92335}, "CVE-2022-4954": {"epss_score": 0.00101, "epss_percentile": 0.28573}, "CVE-2022-4955": {"epss_score": 0.00026, "epss_percentile": 0.06581}, "CVE-2022-4956": {"epss_score": 0.00123, "epss_percentile": 0.32261}, "CVE-2022-4957": {"epss_score": 0.00559, "epss_percentile": 0.67626}, "CVE-2022-4958": {"epss_score": 0.00137, "epss_percentile": 0.3426}, "CVE-2022-4959": {"epss_score": 0.00198, "epss_percentile": 0.42016}, "CVE-2022-4960": {"epss_score": 0.0007, "epss_percentile": 0.21645}, "CVE-2022-4961": {"epss_score": 0.00074, "epss_percentile": 0.22704}, "CVE-2022-4962": {"epss_score": 0.00076, "epss_percentile": 0.23252}, "CVE-2022-4963": {"epss_score": 0.0011, "epss_percentile": 0.30104}, "CVE-2022-4964": {"epss_score": 0.00055, "epss_percentile": 0.17614}, "CVE-2022-4965": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2022-4966": {"epss_score": 0.00101, "epss_percentile": 0.28566}, "CVE-2022-4967": {"epss_score": 0.00047, "epss_percentile": 0.1458}, "CVE-2022-4968": {"epss_score": 0.00365, "epss_percentile": 0.57998}, "CVE-2022-4969": {"epss_score": 0.00094, "epss_percentile": 0.26957}, "CVE-2022-4971": {"epss_score": 0.06718, "epss_percentile": 0.90965}, "CVE-2022-4972": {"epss_score": 0.01314, "epss_percentile": 0.79387}, "CVE-2022-4973": {"epss_score": 0.00937, "epss_percentile": 0.75693}, "CVE-2022-4974": {"epss_score": 0.00151, "epss_percentile": 0.36367}, "CVE-2022-4975": {"epss_score": 0.00124, "epss_percentile": 0.32394}, "CVE-2022-4976": {"epss_score": 0.00069, "epss_percentile": 0.2152}, "CVE-2022-4978": {"epss_score": 0.32431, "epss_percentile": 0.96699}, "CVE-2022-4979": {"epss_score": 0.00012, "epss_percentile": 0.01134}, "CVE-2022-4980": {"epss_score": 0.00706, "epss_percentile": 0.71614}, "CVE-2022-4981": {"epss_score": 0.00014, "epss_percentile": 0.02112}, "CVE-2022-4982": {"epss_score": 0.0009, "epss_percentile": 0.26124}, "CVE-2022-4983": {"epss_score": 0.00098, "epss_percentile": 0.27826}, "CVE-2022-4984": {"epss_score": 0.00227, "epss_percentile": 0.45395}, "CVE-2022-4985": {"epss_score": 0.00141, "epss_percentile": 0.34916}, "CVE-2022-50000": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50001": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50002": {"epss_score": 0.00023, "epss_percentile": 0.05462}, "CVE-2022-50003": {"epss_score": 0.00023, "epss_percentile": 0.05481}, "CVE-2022-50004": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50005": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2022-50006": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50007": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50008": {"epss_score": 0.00013, "epss_percentile": 0.01511}, "CVE-2022-50009": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50010": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50011": {"epss_score": 0.00012, "epss_percentile": 0.01151}, "CVE-2022-50012": {"epss_score": 0.00012, "epss_percentile": 0.01151}, "CVE-2022-50013": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50014": {"epss_score": 0.00015, "epss_percentile": 0.02516}, "CVE-2022-50015": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50016": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50017": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50019": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50020": {"epss_score": 0.00021, "epss_percentile": 0.04771}, "CVE-2022-50021": {"epss_score": 0.00015, "epss_percentile": 0.0223}, "CVE-2022-50022": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-50023": {"epss_score": 0.00012, "epss_percentile": 0.01151}, "CVE-2022-50024": {"epss_score": 0.00012, "epss_percentile": 0.01151}, "CVE-2022-50025": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50026": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2022-50027": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50028": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50029": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50030": {"epss_score": 0.00014, "epss_percentile": 0.01961}, "CVE-2022-50032": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50033": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50034": {"epss_score": 0.00015, "epss_percentile": 0.02346}, "CVE-2022-50035": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2022-50036": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50037": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50038": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50039": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50040": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2022-50041": {"epss_score": 8e-05, "epss_percentile": 0.00502}, "CVE-2022-50042": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50043": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50044": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2022-50045": {"epss_score": 0.00012, "epss_percentile": 0.01139}, "CVE-2022-50046": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50047": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50048": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50049": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50050": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2022-50051": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2022-50052": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2022-50053": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2022-50054": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50055": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50056": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50057": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50058": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50059": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50060": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50061": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50062": {"epss_score": 0.00013, "epss_percentile": 0.01494}, "CVE-2022-50063": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50064": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2022-50065": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50066": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2022-50067": {"epss_score": 0.00014, "epss_percentile": 0.01987}, "CVE-2022-50068": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50069": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50070": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2022-50071": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2022-50072": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-50073": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50074": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50075": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50076": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50077": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50078": {"epss_score": 0.00026, "epss_percentile": 0.06387}, "CVE-2022-50079": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2022-50080": {"epss_score": 0.00031, "epss_percentile": 0.08412}, "CVE-2022-50082": {"epss_score": 0.00024, "epss_percentile": 0.05811}, "CVE-2022-50084": {"epss_score": 0.00013, "epss_percentile": 0.01709}, "CVE-2022-50085": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-50086": {"epss_score": 0.00014, "epss_percentile": 0.02035}, "CVE-2022-50087": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-50088": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50089": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50090": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2022-50091": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50092": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50093": {"epss_score": 0.00012, "epss_percentile": 0.0116}, "CVE-2022-50094": {"epss_score": 9e-05, "epss_percentile": 0.00718}, "CVE-2022-50095": {"epss_score": 0.00015, "epss_percentile": 0.02346}, "CVE-2022-50096": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50097": {"epss_score": 0.00014, "epss_percentile": 0.01987}, "CVE-2022-50098": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50099": {"epss_score": 0.00014, "epss_percentile": 0.01987}, "CVE-2022-50100": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50101": {"epss_score": 0.00014, "epss_percentile": 0.01987}, "CVE-2022-50102": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50103": {"epss_score": 0.00015, "epss_percentile": 0.02346}, "CVE-2022-50104": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50105": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50106": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50107": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50108": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50109": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50110": {"epss_score": 0.00031, "epss_percentile": 0.08715}, "CVE-2022-50111": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50112": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50113": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50114": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50115": {"epss_score": 0.00015, "epss_percentile": 0.02138}, "CVE-2022-50116": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2022-50117": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50118": {"epss_score": 0.00013, "epss_percentile": 0.01494}, "CVE-2022-50119": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50120": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50121": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50122": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50123": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50124": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50125": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50126": {"epss_score": 0.00012, "epss_percentile": 0.01262}, "CVE-2022-50127": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50129": {"epss_score": 0.00015, "epss_percentile": 0.02346}, "CVE-2022-50130": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50131": {"epss_score": 0.00015, "epss_percentile": 0.02346}, "CVE-2022-50132": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50133": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50134": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50135": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50136": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50137": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2022-50138": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50139": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50140": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50141": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50142": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-50143": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50144": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50145": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50146": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50147": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2022-50148": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50149": {"epss_score": 0.00011, "epss_percentile": 0.01096}, "CVE-2022-50151": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2022-50152": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50153": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50154": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50155": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50156": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-50157": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50158": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50159": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50160": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50161": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50162": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50163": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2022-50164": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-50165": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50166": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2022-50167": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50168": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2022-50169": {"epss_score": 0.0004, "epss_percentile": 0.12022}, "CVE-2022-50170": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50171": {"epss_score": 0.00011, "epss_percentile": 0.0093}, "CVE-2022-50172": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50173": {"epss_score": 0.00012, "epss_percentile": 0.01139}, "CVE-2022-50174": {"epss_score": 0.00012, "epss_percentile": 0.01123}, "CVE-2022-50175": {"epss_score": 0.00031, "epss_percentile": 0.08332}, "CVE-2022-50176": {"epss_score": 0.00014, "epss_percentile": 0.01972}, "CVE-2022-50177": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50178": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50179": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-50181": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50182": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2022-50183": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50184": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50185": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-50186": {"epss_score": 0.00015, "epss_percentile": 0.02228}, "CVE-2022-50187": {"epss_score": 0.00012, "epss_percentile": 0.01123}, "CVE-2022-50188": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50189": {"epss_score": 0.00026, "epss_percentile": 0.06625}, "CVE-2022-50190": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2022-50191": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50192": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2022-50193": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50194": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50195": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50196": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50197": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50198": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50199": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50200": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-50201": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2022-50202": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50203": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50204": {"epss_score": 0.00014, "epss_percentile": 0.02035}, "CVE-2022-50205": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50206": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2022-50207": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50208": {"epss_score": 0.00018, "epss_percentile": 0.03569}, "CVE-2022-50209": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50210": {"epss_score": 0.00013, "epss_percentile": 0.01624}, "CVE-2022-50211": {"epss_score": 0.00013, "epss_percentile": 0.01644}, "CVE-2022-50212": {"epss_score": 0.00015, "epss_percentile": 0.02346}, "CVE-2022-50213": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-50214": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2022-50215": {"epss_score": 0.00013, "epss_percentile": 0.01624}, "CVE-2022-50217": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2022-50218": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50219": {"epss_score": 0.00015, "epss_percentile": 0.02346}, "CVE-2022-50220": {"epss_score": 0.00014, "epss_percentile": 0.02073}, "CVE-2022-50221": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2022-50222": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2022-50223": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50224": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50225": {"epss_score": 0.00012, "epss_percentile": 0.0124}, "CVE-2022-50226": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2022-50227": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50228": {"epss_score": 0.00014, "epss_percentile": 0.0197}, "CVE-2022-50229": {"epss_score": 0.00014, "epss_percentile": 0.02073}, "CVE-2022-50230": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50231": {"epss_score": 0.00018, "epss_percentile": 0.03732}, "CVE-2022-50232": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2022-50233": {"epss_score": 0.00017, "epss_percentile": 0.03204}, "CVE-2022-50234": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2022-50235": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2022-50236": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50237": {"epss_score": 4e-05, "epss_percentile": 0.00156}, "CVE-2022-50238": {"epss_score": 0.00122, "epss_percentile": 0.32158}, "CVE-2022-50239": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2022-50240": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2022-50241": {"epss_score": 0.00018, "epss_percentile": 0.03618}, "CVE-2022-50242": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50243": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2022-50244": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50245": {"epss_score": 0.00017, "epss_percentile": 0.03298}, "CVE-2022-50246": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50247": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50248": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2022-50249": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50250": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2022-50251": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50252": {"epss_score": 0.00016, "epss_percentile": 0.02824}, "CVE-2022-50253": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2022-50254": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2022-50255": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2022-50256": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2022-50257": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50258": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2022-50259": {"epss_score": 0.00014, "epss_percentile": 0.01824}, "CVE-2022-50260": {"epss_score": 0.00022, "epss_percentile": 0.04985}, "CVE-2022-50261": {"epss_score": 0.00016, "epss_percentile": 0.02686}, "CVE-2022-50262": {"epss_score": 0.00021, "epss_percentile": 0.04922}, "CVE-2022-50263": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50264": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50265": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50266": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50267": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50268": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50269": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50270": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50271": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50272": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50273": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50274": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2022-50275": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50276": {"epss_score": 0.00023, "epss_percentile": 0.05642}, "CVE-2022-50277": {"epss_score": 0.00011, "epss_percentile": 0.00977}, "CVE-2022-50278": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50279": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2022-50280": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50281": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2022-50282": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50283": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2022-50284": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50285": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50286": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2022-50287": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50288": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50289": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50291": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50292": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2022-50293": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2022-50294": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50295": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2022-50296": {"epss_score": 0.00016, "epss_percentile": 0.02686}, "CVE-2022-50297": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50298": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50299": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50300": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2022-50301": {"epss_score": 0.00017, "epss_percentile": 0.03298}, "CVE-2022-50302": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2022-50303": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2022-50304": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50305": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2022-50306": {"epss_score": 0.00016, "epss_percentile": 0.0296}, "CVE-2022-50307": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2022-50308": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2022-50309": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50310": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2022-50311": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50312": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50313": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50314": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2022-50315": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2022-50316": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50317": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50318": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50319": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50320": {"epss_score": 0.00017, "epss_percentile": 0.03145}, "CVE-2022-50321": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50322": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50323": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50324": {"epss_score": 0.00016, "epss_percentile": 0.02686}, "CVE-2022-50325": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2022-50326": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2022-50327": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2022-50328": {"epss_score": 0.00018, "epss_percentile": 0.03618}, "CVE-2022-50329": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2022-50330": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50331": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50332": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2022-50333": {"epss_score": 0.00016, "epss_percentile": 0.02824}, "CVE-2022-50334": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2022-50335": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50336": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50337": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2022-50339": {"epss_score": 0.00015, "epss_percentile": 0.0235}, "CVE-2022-50340": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2022-50341": {"epss_score": 0.0001, "epss_percentile": 0.00863}, "CVE-2022-50342": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50343": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50344": {"epss_score": 0.00016, "epss_percentile": 0.02686}, "CVE-2022-50346": {"epss_score": 0.00016, "epss_percentile": 0.02686}, "CVE-2022-50347": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50348": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50349": {"epss_score": 0.00016, "epss_percentile": 0.02686}, "CVE-2022-50350": {"epss_score": 0.00014, "epss_percentile": 0.01767}, "CVE-2022-50351": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50352": {"epss_score": 0.00023, "epss_percentile": 0.05642}, "CVE-2022-50353": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50354": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50355": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50356": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50357": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50358": {"epss_score": 0.0003, "epss_percentile": 0.0821}, "CVE-2022-50359": {"epss_score": 0.00016, "epss_percentile": 0.02686}, "CVE-2022-50360": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2022-50361": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50362": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2022-50363": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2022-50364": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2022-50365": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50366": {"epss_score": 0.00016, "epss_percentile": 0.02824}, "CVE-2022-50367": {"epss_score": 0.00016, "epss_percentile": 0.02824}, "CVE-2022-50368": {"epss_score": 0.00021, "epss_percentile": 0.04804}, "CVE-2022-50369": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2022-50370": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50371": {"epss_score": 0.00014, "epss_percentile": 0.01767}, "CVE-2022-50372": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2022-50373": {"epss_score": 0.00013, "epss_percentile": 0.01455}, "CVE-2022-50374": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2022-50375": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50376": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50378": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2022-50379": {"epss_score": 0.00013, "epss_percentile": 0.01537}, "CVE-2022-50380": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50381": {"epss_score": 0.00016, "epss_percentile": 0.02686}, "CVE-2022-50382": {"epss_score": 0.00014, "epss_percentile": 0.01795}, "CVE-2022-50383": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50384": {"epss_score": 0.00017, "epss_percentile": 0.03298}, "CVE-2022-50385": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2022-50386": {"epss_score": 0.00083, "epss_percentile": 0.24804}, "CVE-2022-50387": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50388": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2022-50389": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50390": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50391": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50392": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50393": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50394": {"epss_score": 0.00017, "epss_percentile": 0.03298}, "CVE-2022-50395": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50396": {"epss_score": 0.00016, "epss_percentile": 0.02867}, "CVE-2022-50398": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2022-50399": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50400": {"epss_score": 0.00017, "epss_percentile": 0.03422}, "CVE-2022-50401": {"epss_score": 0.00017, "epss_percentile": 0.03298}, "CVE-2022-50402": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2022-50404": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50405": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50406": {"epss_score": 0.00021, "epss_percentile": 0.04692}, "CVE-2022-50407": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50408": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2022-50409": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2022-50410": {"epss_score": 0.00017, "epss_percentile": 0.03145}, "CVE-2022-50411": {"epss_score": 0.00016, "epss_percentile": 0.02824}, "CVE-2022-50412": {"epss_score": 0.00018, "epss_percentile": 0.03853}, "CVE-2022-50413": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2022-50414": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2022-50415": {"epss_score": 0.00016, "epss_percentile": 0.02686}, "CVE-2022-50416": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50417": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2022-50418": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2022-50419": {"epss_score": 0.00016, "epss_percentile": 0.02824}, "CVE-2022-50420": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2022-50421": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2022-50422": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2022-50423": {"epss_score": 0.00017, "epss_percentile": 0.03298}, "CVE-2022-50424": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2022-50425": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-50426": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50427": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50428": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50429": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50430": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50431": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50432": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50433": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-50434": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50435": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50436": {"epss_score": 0.00015, "epss_percentile": 0.02589}, "CVE-2022-50437": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50438": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50439": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50440": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50441": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50442": {"epss_score": 0.0003, "epss_percentile": 0.08263}, "CVE-2022-50443": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50444": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50445": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50446": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50447": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50448": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50449": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50451": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50452": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50453": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50454": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50456": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50457": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50458": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50459": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50460": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50461": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50462": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50463": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50464": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50465": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50466": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50467": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50468": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50469": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50470": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50471": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50472": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50473": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50474": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50475": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50476": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50477": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50478": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50479": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-50480": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50481": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50482": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50483": {"epss_score": 0.00027, "epss_percentile": 0.06841}, "CVE-2022-50484": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50485": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50486": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50488": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50489": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50490": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50491": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50492": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-50493": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50494": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50496": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50497": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50498": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50499": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50500": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-50501": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50503": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50504": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50505": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50506": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-50507": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50508": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-50509": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50510": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50511": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50512": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50513": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50514": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50515": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50516": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50517": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-50518": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50519": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50520": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50521": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50522": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50523": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50524": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50525": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50526": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-50527": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50528": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50529": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50530": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-50531": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50532": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50533": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50534": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50535": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50536": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50537": {"epss_score": 0.00049, "epss_percentile": 0.15362}, "CVE-2022-50538": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50539": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50540": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50541": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50542": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50543": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50544": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50545": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50546": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50547": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50548": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50549": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50550": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50551": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50552": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50553": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50554": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50555": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50556": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50557": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50558": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50559": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50560": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50561": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2022-50562": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50563": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50564": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50565": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50566": {"epss_score": 0.00066, "epss_percentile": 0.20751}, "CVE-2022-50567": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50568": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50569": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50570": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50571": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-50572": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50573": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2022-50574": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50575": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2022-50576": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50577": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2022-50578": {"epss_score": 0.00049, "epss_percentile": 0.15362}, "CVE-2022-50579": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50580": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50581": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2022-50582": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2022-50583": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50584": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2022-50585": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2022-50586": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2022-50587": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2022-50588": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2022-50589": {"epss_score": 0.00226, "epss_percentile": 0.45355}, "CVE-2022-50590": {"epss_score": 0.00041, "epss_percentile": 0.12333}, "CVE-2022-50591": {"epss_score": 0.00154, "epss_percentile": 0.36692}, "CVE-2022-50592": {"epss_score": 0.00213, "epss_percentile": 0.43929}, "CVE-2022-50593": {"epss_score": 0.00233, "epss_percentile": 0.46034}, "CVE-2022-50594": {"epss_score": 0.00153, "epss_percentile": 0.36616}, "CVE-2022-50595": {"epss_score": 0.00213, "epss_percentile": 0.43929}, "CVE-2022-50596": {"epss_score": 0.06893, "epss_percentile": 0.91097}, "CVE-2022-50614": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50615": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50616": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50617": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50618": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50619": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50620": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50621": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2022-50622": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50623": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50624": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50625": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50626": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50627": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50628": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50629": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50630": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50631": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50632": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50633": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50634": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50635": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50636": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50637": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50638": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50639": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50640": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50641": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50642": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50643": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50644": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50645": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50646": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50647": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50648": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2022-50649": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50650": {"epss_score": 0.00024, "epss_percentile": 0.05678}, "CVE-2022-50651": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50652": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50653": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50654": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50655": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50656": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50657": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2022-50658": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50659": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50660": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50661": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50662": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50663": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50664": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50665": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50666": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50667": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50668": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50669": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50670": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50671": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50672": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50673": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50674": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50675": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50676": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50677": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50678": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50679": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50680": {"epss_score": 0.00027, "epss_percentile": 0.06856}, "CVE-2022-50681": {"epss_score": 0.00039, "epss_percentile": 0.1171}, "CVE-2022-50682": {"epss_score": 0.00038, "epss_percentile": 0.11097}, "CVE-2022-50683": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2022-50684": {"epss_score": 0.00033, "epss_percentile": 0.09217}, "CVE-2022-50685": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2022-50686": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2022-50687": {"epss_score": 0.00013, "epss_percentile": 0.01591}, "CVE-2022-50688": {"epss_score": 0.00013, "epss_percentile": 0.01677}, "CVE-2022-50689": {"epss_score": 0.00012, "epss_percentile": 0.01142}, "CVE-2022-50690": {"epss_score": 0.00014, "epss_percentile": 0.01793}, "CVE-2022-50691": {"epss_score": 0.00206, "epss_percentile": 0.43062}, "CVE-2022-50692": {"epss_score": 0.00048, "epss_percentile": 0.1503}, "CVE-2022-50694": {"epss_score": 0.00082, "epss_percentile": 0.24547}, "CVE-2022-50695": {"epss_score": 0.0008, "epss_percentile": 0.24196}, "CVE-2022-50696": {"epss_score": 0.00036, "epss_percentile": 0.1023}, "CVE-2022-50697": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50698": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50699": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50700": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50701": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50702": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50703": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50704": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50705": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50706": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50707": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50708": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50709": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50710": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50711": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2022-50712": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50713": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50714": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50715": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50716": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50717": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50718": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50719": {"epss_score": 0.00102, "epss_percentile": 0.28806}, "CVE-2022-50720": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50721": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50722": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50723": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2022-50724": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50725": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50726": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50727": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50728": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50729": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50730": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50731": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50732": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50733": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50734": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50735": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50736": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50737": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50738": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50739": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50740": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50741": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50742": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50743": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50744": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50745": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50746": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50747": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50748": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50749": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50750": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50751": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50752": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50753": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50754": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50755": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50756": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50757": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50758": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50759": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50760": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50761": {"epss_score": 0.00058, "epss_percentile": 0.18382}, "CVE-2022-50762": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50763": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50764": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50765": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50766": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50767": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50768": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50769": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50770": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50771": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50772": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2022-50773": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50774": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50775": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50776": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50777": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50778": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50779": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50780": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50781": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50782": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50783": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50784": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50785": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50786": {"epss_score": 0.00031, "epss_percentile": 0.0854}, "CVE-2022-50787": {"epss_score": 0.00055, "epss_percentile": 0.17538}, "CVE-2022-50788": {"epss_score": 0.00117, "epss_percentile": 0.3134}, "CVE-2022-50789": {"epss_score": 0.01209, "epss_percentile": 0.7854}, "CVE-2022-50790": {"epss_score": 0.00199, "epss_percentile": 0.4216}, "CVE-2022-50791": {"epss_score": 0.0132, "epss_percentile": 0.7944}, "CVE-2022-50792": {"epss_score": 0.00201, "epss_percentile": 0.42335}, "CVE-2022-50793": {"epss_score": 0.00221, "epss_percentile": 0.44688}, "CVE-2022-50794": {"epss_score": 0.00312, "epss_percentile": 0.53958}, "CVE-2022-50795": {"epss_score": 0.01209, "epss_percentile": 0.7854}, "CVE-2022-50796": {"epss_score": 0.00157, "epss_percentile": 0.37099}, "CVE-2022-50799": {"epss_score": 0.00054, "epss_percentile": 0.17327}, "CVE-2022-50800": {"epss_score": 0.0004, "epss_percentile": 0.12046}, "CVE-2022-50801": {"epss_score": 0.0004, "epss_percentile": 0.12163}, "CVE-2022-50802": {"epss_score": 0.00078, "epss_percentile": 0.23766}, "CVE-2022-50803": {"epss_score": 0.0007, "epss_percentile": 0.21651}, "CVE-2022-50804": {"epss_score": 0.00019, "epss_percentile": 0.04109}, "CVE-2022-50809": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50810": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50811": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50812": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50813": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50814": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50815": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50816": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50817": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50818": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50819": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50820": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50821": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50822": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50823": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50824": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50825": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50826": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50827": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50828": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50829": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50830": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50832": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50833": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50834": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50835": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50836": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50837": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50838": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50839": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50840": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50841": {"epss_score": 0.00027, "epss_percentile": 0.06781}, "CVE-2022-50842": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50843": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50844": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50845": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50846": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50847": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50848": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50849": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50850": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50851": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50852": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2022-50853": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50854": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50855": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50856": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50857": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50858": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50859": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50860": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50861": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50862": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2022-50863": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50864": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50865": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50866": {"epss_score": 0.00058, "epss_percentile": 0.18382}, "CVE-2022-50867": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2022-50868": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50869": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50870": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50871": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50872": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50873": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50874": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50875": {"epss_score": 0.00043, "epss_percentile": 0.1307}, "CVE-2022-50876": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50877": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50878": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50879": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50880": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50881": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2022-50882": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50883": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2022-50884": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50885": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2022-50886": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50887": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2022-50888": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2022-50889": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-0001": {"epss_score": 0.00348, "epss_percentile": 0.56842}, "CVE-2023-0002": {"epss_score": 0.00105, "epss_percentile": 0.29294}, "CVE-2023-0003": {"epss_score": 0.01051, "epss_percentile": 0.77082}, "CVE-2023-0004": {"epss_score": 0.0116, "epss_percentile": 0.78136}, "CVE-2023-0005": {"epss_score": 0.00311, "epss_percentile": 0.53919}, "CVE-2023-0006": {"epss_score": 0.00038, "epss_percentile": 0.11138}, "CVE-2023-0007": {"epss_score": 0.0051, "epss_percentile": 0.65792}, "CVE-2023-0008": {"epss_score": 0.00271, "epss_percentile": 0.50293}, "CVE-2023-0009": {"epss_score": 0.00046, "epss_percentile": 0.1424}, "CVE-2023-0010": {"epss_score": 0.00662, "epss_percentile": 0.70593}, "CVE-2023-0011": {"epss_score": 0.00076, "epss_percentile": 0.23098}, "CVE-2023-0012": {"epss_score": 0.00108, "epss_percentile": 0.29808}, "CVE-2023-0013": {"epss_score": 0.00484, "epss_percentile": 0.64639}, "CVE-2023-0014": {"epss_score": 0.00412, "epss_percentile": 0.60941}, "CVE-2023-0015": {"epss_score": 0.00354, "epss_percentile": 0.5722}, "CVE-2023-0016": {"epss_score": 0.00221, "epss_percentile": 0.44705}, "CVE-2023-0017": {"epss_score": 0.04748, "epss_percentile": 0.89101}, "CVE-2023-0018": {"epss_score": 0.00636, "epss_percentile": 0.69876}, "CVE-2023-0019": {"epss_score": 0.00294, "epss_percentile": 0.52438}, "CVE-2023-0020": {"epss_score": 0.00195, "epss_percentile": 0.41633}, "CVE-2023-0021": {"epss_score": 0.01156, "epss_percentile": 0.78105}, "CVE-2023-0022": {"epss_score": 0.004, "epss_percentile": 0.60155}, "CVE-2023-0023": {"epss_score": 0.00156, "epss_percentile": 0.36915}, "CVE-2023-0024": {"epss_score": 0.0031, "epss_percentile": 0.53802}, "CVE-2023-0025": {"epss_score": 0.0023, "epss_percentile": 0.45744}, "CVE-2023-0026": {"epss_score": 0.00098, "epss_percentile": 0.27663}, "CVE-2023-0027": {"epss_score": 0.00046, "epss_percentile": 0.14172}, "CVE-2023-0028": {"epss_score": 0.00575, "epss_percentile": 0.68107}, "CVE-2023-0029": {"epss_score": 0.00501, "epss_percentile": 0.65348}, "CVE-2023-0030": {"epss_score": 0.00022, "epss_percentile": 0.05243}, "CVE-2023-0033": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0034": {"epss_score": 0.00367, "epss_percentile": 0.58107}, "CVE-2023-0035": {"epss_score": 8e-05, "epss_percentile": 0.00525}, "CVE-2023-0036": {"epss_score": 8e-05, "epss_percentile": 0.00525}, "CVE-2023-0037": {"epss_score": 0.66547, "epss_percentile": 0.98468}, "CVE-2023-0038": {"epss_score": 0.01991, "epss_percentile": 0.83175}, "CVE-2023-0040": {"epss_score": 0.00106, "epss_percentile": 0.29435}, "CVE-2023-0041": {"epss_score": 0.00048, "epss_percentile": 0.15034}, "CVE-2023-0042": {"epss_score": 0.00088, "epss_percentile": 0.25724}, "CVE-2023-0043": {"epss_score": 0.00148, "epss_percentile": 0.35844}, "CVE-2023-0044": {"epss_score": 0.00109, "epss_percentile": 0.2999}, "CVE-2023-0045": {"epss_score": 0.00192, "epss_percentile": 0.41292}, "CVE-2023-0046": {"epss_score": 0.00416, "epss_percentile": 0.6117}, "CVE-2023-0048": {"epss_score": 0.02551, "epss_percentile": 0.85077}, "CVE-2023-0049": {"epss_score": 0.00032, "epss_percentile": 0.08771}, "CVE-2023-0050": {"epss_score": 0.78278, "epss_percentile": 0.98976}, "CVE-2023-0051": {"epss_score": 0.00023, "epss_percentile": 0.05611}, "CVE-2023-0052": {"epss_score": 0.00102, "epss_percentile": 0.28815}, "CVE-2023-0053": {"epss_score": 0.00063, "epss_percentile": 0.19994}, "CVE-2023-0054": {"epss_score": 0.00018, "epss_percentile": 0.03751}, "CVE-2023-0055": {"epss_score": 0.00145, "epss_percentile": 0.35394}, "CVE-2023-0056": {"epss_score": 0.00211, "epss_percentile": 0.43645}, "CVE-2023-0057": {"epss_score": 0.00366, "epss_percentile": 0.58016}, "CVE-2023-0058": {"epss_score": 0.00076, "epss_percentile": 0.23257}, "CVE-2023-0059": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0060": {"epss_score": 0.00332, "epss_percentile": 0.5558}, "CVE-2023-0061": {"epss_score": 0.00425, "epss_percentile": 0.61711}, "CVE-2023-0062": {"epss_score": 0.00367, "epss_percentile": 0.58107}, "CVE-2023-0063": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0064": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2023-0065": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0066": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2023-0067": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0068": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0069": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0070": {"epss_score": 0.00467, "epss_percentile": 0.63832}, "CVE-2023-0071": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2023-0072": {"epss_score": 0.00417, "epss_percentile": 0.61257}, "CVE-2023-0073": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0074": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2023-0075": {"epss_score": 0.00469, "epss_percentile": 0.63953}, "CVE-2023-0076": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2023-0077": {"epss_score": 0.01045, "epss_percentile": 0.77014}, "CVE-2023-0078": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2023-0079": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-0080": {"epss_score": 0.01334, "epss_percentile": 0.79542}, "CVE-2023-0081": {"epss_score": 0.00378, "epss_percentile": 0.588}, "CVE-2023-0082": {"epss_score": 0.00289, "epss_percentile": 0.52025}, "CVE-2023-0083": {"epss_score": 0.00026, "epss_percentile": 0.06424}, "CVE-2023-0084": {"epss_score": 0.29948, "epss_percentile": 0.96489}, "CVE-2023-0085": {"epss_score": 0.00105, "epss_percentile": 0.2926}, "CVE-2023-0086": {"epss_score": 0.00081, "epss_percentile": 0.24355}, "CVE-2023-0087": {"epss_score": 0.00228, "epss_percentile": 0.4552}, "CVE-2023-0088": {"epss_score": 0.00209, "epss_percentile": 0.43318}, "CVE-2023-0089": {"epss_score": 0.00385, "epss_percentile": 0.59185}, "CVE-2023-0090": {"epss_score": 0.00369, "epss_percentile": 0.58249}, "CVE-2023-0091": {"epss_score": 0.00084, "epss_percentile": 0.2486}, "CVE-2023-0092": {"epss_score": 0.00298, "epss_percentile": 0.52828}, "CVE-2023-0093": {"epss_score": 0.00471, "epss_percentile": 0.64012}, "CVE-2023-0094": {"epss_score": 0.00266, "epss_percentile": 0.49844}, "CVE-2023-0095": {"epss_score": 0.00367, "epss_percentile": 0.58107}, "CVE-2023-0096": {"epss_score": 0.00332, "epss_percentile": 0.5558}, "CVE-2023-0097": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0098": {"epss_score": 0.00578, "epss_percentile": 0.6819}, "CVE-2023-0099": {"epss_score": 0.5362, "epss_percentile": 0.97885}, "CVE-2023-0100": {"epss_score": 0.00383, "epss_percentile": 0.59079}, "CVE-2023-0101": {"epss_score": 0.00186, "epss_percentile": 0.40641}, "CVE-2023-0102": {"epss_score": 0.00101, "epss_percentile": 0.28669}, "CVE-2023-0103": {"epss_score": 0.00087, "epss_percentile": 0.25478}, "CVE-2023-0104": {"epss_score": 0.03023, "epss_percentile": 0.86231}, "CVE-2023-0105": {"epss_score": 0.00175, "epss_percentile": 0.3928}, "CVE-2023-0106": {"epss_score": 0.0031, "epss_percentile": 0.53776}, "CVE-2023-0107": {"epss_score": 0.00212, "epss_percentile": 0.43791}, "CVE-2023-0108": {"epss_score": 0.001, "epss_percentile": 0.2853}, "CVE-2023-0109": {"epss_score": 0.00198, "epss_percentile": 0.42063}, "CVE-2023-0110": {"epss_score": 0.00212, "epss_percentile": 0.43791}, "CVE-2023-0111": {"epss_score": 0.00119, "epss_percentile": 0.31574}, "CVE-2023-0112": {"epss_score": 0.00296, "epss_percentile": 0.52567}, "CVE-2023-0113": {"epss_score": 0.00416, "epss_percentile": 0.61183}, "CVE-2023-0114": {"epss_score": 0.0006, "epss_percentile": 0.19091}, "CVE-2023-0116": {"epss_score": 0.00099, "epss_percentile": 0.28342}, "CVE-2023-0117": {"epss_score": 0.00038, "epss_percentile": 0.11396}, "CVE-2023-0118": {"epss_score": 0.00035, "epss_percentile": 0.1007}, "CVE-2023-0119": {"epss_score": 0.00231, "epss_percentile": 0.45849}, "CVE-2023-0120": {"epss_score": 0.00089, "epss_percentile": 0.25932}, "CVE-2023-0121": {"epss_score": 0.01251, "epss_percentile": 0.78894}, "CVE-2023-0122": {"epss_score": 0.00137, "epss_percentile": 0.34234}, "CVE-2023-0123": {"epss_score": 0.00055, "epss_percentile": 0.17504}, "CVE-2023-0124": {"epss_score": 0.00043, "epss_percentile": 0.12953}, "CVE-2023-0125": {"epss_score": 0.0009, "epss_percentile": 0.26075}, "CVE-2023-0126": {"epss_score": 0.93047, "epss_percentile": 0.9977}, "CVE-2023-0127": {"epss_score": 0.00391, "epss_percentile": 0.59627}, "CVE-2023-0128": {"epss_score": 0.0064, "epss_percentile": 0.69963}, "CVE-2023-0129": {"epss_score": 0.00128, "epss_percentile": 0.33066}, "CVE-2023-0130": {"epss_score": 0.00155, "epss_percentile": 0.36853}, "CVE-2023-0131": {"epss_score": 0.00031, "epss_percentile": 0.08683}, "CVE-2023-0132": {"epss_score": 0.00129, "epss_percentile": 0.33169}, "CVE-2023-0133": {"epss_score": 0.00077, "epss_percentile": 0.23299}, "CVE-2023-0134": {"epss_score": 0.00088, "epss_percentile": 0.25737}, "CVE-2023-0135": {"epss_score": 0.00088, "epss_percentile": 0.25737}, "CVE-2023-0136": {"epss_score": 0.00554, "epss_percentile": 0.67443}, "CVE-2023-0137": {"epss_score": 0.001, "epss_percentile": 0.28469}, "CVE-2023-0138": {"epss_score": 0.00723, "epss_percentile": 0.72026}, "CVE-2023-0139": {"epss_score": 0.00049, "epss_percentile": 0.15444}, "CVE-2023-0140": {"epss_score": 0.00063, "epss_percentile": 0.19938}, "CVE-2023-0141": {"epss_score": 0.00128, "epss_percentile": 0.33032}, "CVE-2023-0142": {"epss_score": 0.0019, "epss_percentile": 0.41081}, "CVE-2023-0143": {"epss_score": 0.00552, "epss_percentile": 0.67398}, "CVE-2023-0144": {"epss_score": 0.00316, "epss_percentile": 0.5424}, "CVE-2023-0145": {"epss_score": 0.00195, "epss_percentile": 0.41681}, "CVE-2023-0146": {"epss_score": 0.00335, "epss_percentile": 0.55899}, "CVE-2023-0147": {"epss_score": 0.00335, "epss_percentile": 0.55899}, "CVE-2023-0148": {"epss_score": 0.00467, "epss_percentile": 0.63832}, "CVE-2023-0149": {"epss_score": 0.00467, "epss_percentile": 0.63832}, "CVE-2023-0150": {"epss_score": 0.00423, "epss_percentile": 0.61588}, "CVE-2023-0151": {"epss_score": 0.00332, "epss_percentile": 0.5558}, "CVE-2023-0152": {"epss_score": 0.00119, "epss_percentile": 0.31657}, "CVE-2023-0153": {"epss_score": 0.00289, "epss_percentile": 0.52025}, "CVE-2023-0154": {"epss_score": 0.00467, "epss_percentile": 0.63832}, "CVE-2023-0155": {"epss_score": 0.00094, "epss_percentile": 0.26781}, "CVE-2023-0156": {"epss_score": 0.54647, "epss_percentile": 0.97937}, "CVE-2023-0157": {"epss_score": 0.41558, "epss_percentile": 0.97283}, "CVE-2023-0158": {"epss_score": 0.00307, "epss_percentile": 0.535}, "CVE-2023-0159": {"epss_score": 0.91507, "epss_percentile": 0.99649}, "CVE-2023-0160": {"epss_score": 0.00011, "epss_percentile": 0.01004}, "CVE-2023-0162": {"epss_score": 0.00134, "epss_percentile": 0.33849}, "CVE-2023-0163": {"epss_score": 0.00089, "epss_percentile": 0.25926}, "CVE-2023-0164": {"epss_score": 0.0023, "epss_percentile": 0.45722}, "CVE-2023-0165": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2023-0166": {"epss_score": 0.00359, "epss_percentile": 0.57593}, "CVE-2023-0167": {"epss_score": 0.00249, "epss_percentile": 0.48026}, "CVE-2023-0168": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2023-0169": {"epss_score": 0.00426, "epss_percentile": 0.61771}, "CVE-2023-0170": {"epss_score": 0.00434, "epss_percentile": 0.62294}, "CVE-2023-0171": {"epss_score": 0.00402, "epss_percentile": 0.6031}, "CVE-2023-0172": {"epss_score": 0.0018, "epss_percentile": 0.39976}, "CVE-2023-0173": {"epss_score": 0.00434, "epss_percentile": 0.62294}, "CVE-2023-0174": {"epss_score": 0.00467, "epss_percentile": 0.63832}, "CVE-2023-0175": {"epss_score": 0.00137, "epss_percentile": 0.34216}, "CVE-2023-0176": {"epss_score": 0.00434, "epss_percentile": 0.62294}, "CVE-2023-0177": {"epss_score": 0.00289, "epss_percentile": 0.52025}, "CVE-2023-0178": {"epss_score": 0.00332, "epss_percentile": 0.5558}, "CVE-2023-0179": {"epss_score": 0.00333, "epss_percentile": 0.55627}, "CVE-2023-0180": {"epss_score": 0.00064, "epss_percentile": 0.20328}, "CVE-2023-0181": {"epss_score": 0.00039, "epss_percentile": 0.11558}, "CVE-2023-0182": {"epss_score": 0.00064, "epss_percentile": 0.20149}, "CVE-2023-0183": {"epss_score": 0.00094, "epss_percentile": 0.27}, "CVE-2023-0184": {"epss_score": 0.0009, "epss_percentile": 0.26123}, "CVE-2023-0185": {"epss_score": 0.00038, "epss_percentile": 0.11122}, "CVE-2023-0186": {"epss_score": 0.00048, "epss_percentile": 0.15226}, "CVE-2023-0187": {"epss_score": 0.0006, "epss_percentile": 0.1899}, "CVE-2023-0188": {"epss_score": 0.00093, "epss_percentile": 0.26604}, "CVE-2023-0189": {"epss_score": 0.00123, "epss_percentile": 0.32264}, "CVE-2023-0190": {"epss_score": 0.00083, "epss_percentile": 0.248}, "CVE-2023-0191": {"epss_score": 0.00086, "epss_percentile": 0.25337}, "CVE-2023-0192": {"epss_score": 0.00026, "epss_percentile": 0.06482}, "CVE-2023-0193": {"epss_score": 0.00047, "epss_percentile": 0.14694}, "CVE-2023-0194": {"epss_score": 0.00079, "epss_percentile": 0.23982}, "CVE-2023-0195": {"epss_score": 0.00053, "epss_percentile": 0.1675}, "CVE-2023-0196": {"epss_score": 0.00044, "epss_percentile": 0.13396}, "CVE-2023-0197": {"epss_score": 0.00048, "epss_percentile": 0.15112}, "CVE-2023-0198": {"epss_score": 0.00075, "epss_percentile": 0.23053}, "CVE-2023-0199": {"epss_score": 0.0007, "epss_percentile": 0.21973}, "CVE-2023-0200": {"epss_score": 0.00039, "epss_percentile": 0.11447}, "CVE-2023-0201": {"epss_score": 0.00033, "epss_percentile": 0.09147}, "CVE-2023-0202": {"epss_score": 0.00033, "epss_percentile": 0.09377}, "CVE-2023-0203": {"epss_score": 0.00043, "epss_percentile": 0.13322}, "CVE-2023-0204": {"epss_score": 0.0013, "epss_percentile": 0.33294}, "CVE-2023-0205": {"epss_score": 0.00043, "epss_percentile": 0.13322}, "CVE-2023-0206": {"epss_score": 0.00032, "epss_percentile": 0.08969}, "CVE-2023-0207": {"epss_score": 0.00026, "epss_percentile": 0.06667}, "CVE-2023-0208": {"epss_score": 0.0007, "epss_percentile": 0.21825}, "CVE-2023-0209": {"epss_score": 9e-05, "epss_percentile": 0.00689}, "CVE-2023-0210": {"epss_score": 0.00424, "epss_percentile": 0.61677}, "CVE-2023-0212": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0213": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2023-0214": {"epss_score": 0.07035, "epss_percentile": 0.91203}, "CVE-2023-0215": {"epss_score": 0.00545, "epss_percentile": 0.67154}, "CVE-2023-0216": {"epss_score": 0.00829, "epss_percentile": 0.74015}, "CVE-2023-0217": {"epss_score": 0.00479, "epss_percentile": 0.64439}, "CVE-2023-0219": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2023-0220": {"epss_score": 0.00502, "epss_percentile": 0.65398}, "CVE-2023-0221": {"epss_score": 0.00012, "epss_percentile": 0.01147}, "CVE-2023-0223": {"epss_score": 0.01224, "epss_percentile": 0.78678}, "CVE-2023-0224": {"epss_score": 0.00998, "epss_percentile": 0.76469}, "CVE-2023-0225": {"epss_score": 0.00435, "epss_percentile": 0.62356}, "CVE-2023-0227": {"epss_score": 0.00279, "epss_percentile": 0.50942}, "CVE-2023-0228": {"epss_score": 0.00131, "epss_percentile": 0.33461}, "CVE-2023-0229": {"epss_score": 0.00086, "epss_percentile": 0.25408}, "CVE-2023-0230": {"epss_score": 0.00226, "epss_percentile": 0.45299}, "CVE-2023-0231": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2023-0232": {"epss_score": 0.00386, "epss_percentile": 0.59279}, "CVE-2023-0233": {"epss_score": 0.00092, "epss_percentile": 0.26577}, "CVE-2023-0234": {"epss_score": 0.14354, "epss_percentile": 0.94192}, "CVE-2023-0236": {"epss_score": 0.20076, "epss_percentile": 0.95285}, "CVE-2023-0238": {"epss_score": 0.00019, "epss_percentile": 0.04206}, "CVE-2023-0240": {"epss_score": 0.00024, "epss_percentile": 0.05957}, "CVE-2023-0241": {"epss_score": 0.00453, "epss_percentile": 0.63204}, "CVE-2023-0242": {"epss_score": 0.00279, "epss_percentile": 0.50971}, "CVE-2023-0243": {"epss_score": 0.00073, "epss_percentile": 0.22478}, "CVE-2023-0244": {"epss_score": 0.00073, "epss_percentile": 0.22478}, "CVE-2023-0245": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-0246": {"epss_score": 0.00088, "epss_percentile": 0.25769}, "CVE-2023-0247": {"epss_score": 0.00036, "epss_percentile": 0.10237}, "CVE-2023-0248": {"epss_score": 0.00098, "epss_percentile": 0.27748}, "CVE-2023-0249": {"epss_score": 0.00048, "epss_percentile": 0.15082}, "CVE-2023-0250": {"epss_score": 0.01449, "epss_percentile": 0.80342}, "CVE-2023-0251": {"epss_score": 0.00062, "epss_percentile": 0.197}, "CVE-2023-0252": {"epss_score": 0.00316, "epss_percentile": 0.5424}, "CVE-2023-0254": {"epss_score": 0.0035, "epss_percentile": 0.56916}, "CVE-2023-0255": {"epss_score": 0.00933, "epss_percentile": 0.75634}, "CVE-2023-0256": {"epss_score": 0.00056, "epss_percentile": 0.1789}, "CVE-2023-0257": {"epss_score": 0.0006, "epss_percentile": 0.18973}, "CVE-2023-0258": {"epss_score": 0.00068, "epss_percentile": 0.21218}, "CVE-2023-0259": {"epss_score": 0.00527, "epss_percentile": 0.66472}, "CVE-2023-0260": {"epss_score": 0.00671, "epss_percentile": 0.70792}, "CVE-2023-0261": {"epss_score": 0.3054, "epss_percentile": 0.96549}, "CVE-2023-0262": {"epss_score": 0.006, "epss_percentile": 0.68826}, "CVE-2023-0263": {"epss_score": 0.00646, "epss_percentile": 0.70127}, "CVE-2023-0264": {"epss_score": 0.03942, "epss_percentile": 0.8799}, "CVE-2023-0265": {"epss_score": 0.00477, "epss_percentile": 0.64321}, "CVE-2023-0266": {"epss_score": 0.00127, "epss_percentile": 0.32872}, "CVE-2023-0267": {"epss_score": 0.00156, "epss_percentile": 0.36959}, "CVE-2023-0268": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2023-0270": {"epss_score": 0.00289, "epss_percentile": 0.52025}, "CVE-2023-0271": {"epss_score": 0.00197, "epss_percentile": 0.41931}, "CVE-2023-0272": {"epss_score": 0.0019, "epss_percentile": 0.41111}, "CVE-2023-0273": {"epss_score": 0.00137, "epss_percentile": 0.34216}, "CVE-2023-0274": {"epss_score": 0.00129, "epss_percentile": 0.33089}, "CVE-2023-0275": {"epss_score": 0.00473, "epss_percentile": 0.64102}, "CVE-2023-0276": {"epss_score": 0.00092, "epss_percentile": 0.26577}, "CVE-2023-0277": {"epss_score": 0.00232, "epss_percentile": 0.45936}, "CVE-2023-0278": {"epss_score": 0.00307, "epss_percentile": 0.53525}, "CVE-2023-0279": {"epss_score": 0.00307, "epss_percentile": 0.53525}, "CVE-2023-0280": {"epss_score": 0.00155, "epss_percentile": 0.36841}, "CVE-2023-0281": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-0282": {"epss_score": 0.00411, "epss_percentile": 0.60877}, "CVE-2023-0283": {"epss_score": 0.00073, "epss_percentile": 0.22478}, "CVE-2023-0284": {"epss_score": 0.0053, "epss_percentile": 0.66616}, "CVE-2023-0285": {"epss_score": 0.00215, "epss_percentile": 0.44029}, "CVE-2023-0286": {"epss_score": 0.88356, "epss_percentile": 0.99468}, "CVE-2023-0287": {"epss_score": 0.00148, "epss_percentile": 0.3583}, "CVE-2023-0288": {"epss_score": 0.00037, "epss_percentile": 0.10877}, "CVE-2023-0289": {"epss_score": 0.00079, "epss_percentile": 0.23888}, "CVE-2023-0290": {"epss_score": 0.00233, "epss_percentile": 0.45983}, "CVE-2023-0291": {"epss_score": 0.00104, "epss_percentile": 0.29228}, "CVE-2023-0292": {"epss_score": 0.00335, "epss_percentile": 0.55833}, "CVE-2023-0293": {"epss_score": 0.00034, "epss_percentile": 0.09692}, "CVE-2023-0294": {"epss_score": 0.001, "epss_percentile": 0.28432}, "CVE-2023-0295": {"epss_score": 0.00139, "epss_percentile": 0.34649}, "CVE-2023-0296": {"epss_score": 0.00045, "epss_percentile": 0.13698}, "CVE-2023-0297": {"epss_score": 0.94001, "epss_percentile": 0.99883}, "CVE-2023-0298": {"epss_score": 0.00065, "epss_percentile": 0.20573}, "CVE-2023-0299": {"epss_score": 0.00357, "epss_percentile": 0.574}, "CVE-2023-0300": {"epss_score": 0.00082, "epss_percentile": 0.24587}, "CVE-2023-0301": {"epss_score": 0.00066, "epss_percentile": 0.2086}, "CVE-2023-0302": {"epss_score": 0.00045, "epss_percentile": 0.14056}, "CVE-2023-0303": {"epss_score": 0.00059, "epss_percentile": 0.1865}, "CVE-2023-0304": {"epss_score": 0.00059, "epss_percentile": 0.1865}, "CVE-2023-0305": {"epss_score": 0.00059, "epss_percentile": 0.1865}, "CVE-2023-0306": {"epss_score": 0.00109, "epss_percentile": 0.2999}, "CVE-2023-0307": {"epss_score": 0.00522, "epss_percentile": 0.66259}, "CVE-2023-0308": {"epss_score": 0.00109, "epss_percentile": 0.3002}, "CVE-2023-0309": {"epss_score": 0.00109, "epss_percentile": 0.3002}, "CVE-2023-0310": {"epss_score": 0.00114, "epss_percentile": 0.3087}, "CVE-2023-0311": {"epss_score": 0.0033, "epss_percentile": 0.55491}, "CVE-2023-0312": {"epss_score": 0.00354, "epss_percentile": 0.57242}, "CVE-2023-0313": {"epss_score": 0.00072, "epss_percentile": 0.22315}, "CVE-2023-0314": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2023-0315": {"epss_score": 0.89918, "epss_percentile": 0.9955}, "CVE-2023-0316": {"epss_score": 0.00095, "epss_percentile": 0.27089}, "CVE-2023-0317": {"epss_score": 0.00107, "epss_percentile": 0.29692}, "CVE-2023-0319": {"epss_score": 0.005, "epss_percentile": 0.65295}, "CVE-2023-0320": {"epss_score": 0.00105, "epss_percentile": 0.29369}, "CVE-2023-0321": {"epss_score": 0.00335, "epss_percentile": 0.55816}, "CVE-2023-0322": {"epss_score": 0.00194, "epss_percentile": 0.41586}, "CVE-2023-0323": {"epss_score": 3e-05, "epss_percentile": 0.001}, "CVE-2023-0324": {"epss_score": 0.02576, "epss_percentile": 0.85141}, "CVE-2023-0325": {"epss_score": 0.00099, "epss_percentile": 0.28317}, "CVE-2023-0326": {"epss_score": 0.00162, "epss_percentile": 0.37723}, "CVE-2023-0327": {"epss_score": 0.00096, "epss_percentile": 0.27349}, "CVE-2023-0328": {"epss_score": 0.00107, "epss_percentile": 0.29607}, "CVE-2023-0329": {"epss_score": 0.08064, "epss_percentile": 0.91864}, "CVE-2023-0330": {"epss_score": 0.00031, "epss_percentile": 0.08541}, "CVE-2023-0331": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2023-0332": {"epss_score": 0.00072, "epss_percentile": 0.22469}, "CVE-2023-0333": {"epss_score": 0.00332, "epss_percentile": 0.5558}, "CVE-2023-0334": {"epss_score": 0.22931, "epss_percentile": 0.95707}, "CVE-2023-0335": {"epss_score": 0.0009, "epss_percentile": 0.26141}, "CVE-2023-0336": {"epss_score": 0.0009, "epss_percentile": 0.26141}, "CVE-2023-0337": {"epss_score": 0.00068, "epss_percentile": 0.21369}, "CVE-2023-0338": {"epss_score": 0.00068, "epss_percentile": 0.21369}, "CVE-2023-0339": {"epss_score": 0.00163, "epss_percentile": 0.37761}, "CVE-2023-0340": {"epss_score": 0.00504, "epss_percentile": 0.65521}, "CVE-2023-0341": {"epss_score": 0.00879, "epss_percentile": 0.74849}, "CVE-2023-0342": {"epss_score": 0.20917, "epss_percentile": 0.95442}, "CVE-2023-0343": {"epss_score": 0.00127, "epss_percentile": 0.32818}, "CVE-2023-0344": {"epss_score": 0.00077, "epss_percentile": 0.23551}, "CVE-2023-0345": {"epss_score": 0.00127, "epss_percentile": 0.32812}, "CVE-2023-0346": {"epss_score": 0.00103, "epss_percentile": 0.28999}, "CVE-2023-0347": {"epss_score": 0.00111, "epss_percentile": 0.30286}, "CVE-2023-0348": {"epss_score": 0.00101, "epss_percentile": 0.28597}, "CVE-2023-0349": {"epss_score": 0.00109, "epss_percentile": 0.29962}, "CVE-2023-0350": {"epss_score": 0.00075, "epss_percentile": 0.22915}, "CVE-2023-0351": {"epss_score": 0.00275, "epss_percentile": 0.50667}, "CVE-2023-0352": {"epss_score": 0.00115, "epss_percentile": 0.31022}, "CVE-2023-0353": {"epss_score": 0.00056, "epss_percentile": 0.17867}, "CVE-2023-0354": {"epss_score": 0.00157, "epss_percentile": 0.37058}, "CVE-2023-0355": {"epss_score": 0.00135, "epss_percentile": 0.33935}, "CVE-2023-0356": {"epss_score": 0.00113, "epss_percentile": 0.30615}, "CVE-2023-0357": {"epss_score": 0.00108, "epss_percentile": 0.29786}, "CVE-2023-0358": {"epss_score": 0.00046, "epss_percentile": 0.14074}, "CVE-2023-0359": {"epss_score": 0.00228, "epss_percentile": 0.45522}, "CVE-2023-0360": {"epss_score": 0.00402, "epss_percentile": 0.6031}, "CVE-2023-0361": {"epss_score": 0.03132, "epss_percentile": 0.86475}, "CVE-2023-0362": {"epss_score": 0.00378, "epss_percentile": 0.58795}, "CVE-2023-0363": {"epss_score": 0.00137, "epss_percentile": 0.34216}, "CVE-2023-0364": {"epss_score": 0.00137, "epss_percentile": 0.34216}, "CVE-2023-0365": {"epss_score": 0.00149, "epss_percentile": 0.36025}, "CVE-2023-0366": {"epss_score": 0.00251, "epss_percentile": 0.48314}, "CVE-2023-0367": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-0368": {"epss_score": 0.00092, "epss_percentile": 0.26577}, "CVE-2023-0369": {"epss_score": 0.00149, "epss_percentile": 0.36025}, "CVE-2023-0370": {"epss_score": 0.00149, "epss_percentile": 0.36025}, "CVE-2023-0371": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0372": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0373": {"epss_score": 0.00473, "epss_percentile": 0.64102}, "CVE-2023-0374": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-0375": {"epss_score": 0.00269, "epss_percentile": 0.50163}, "CVE-2023-0376": {"epss_score": 0.00229, "epss_percentile": 0.45587}, "CVE-2023-0377": {"epss_score": 0.00226, "epss_percentile": 0.45299}, "CVE-2023-0378": {"epss_score": 0.00211, "epss_percentile": 0.43682}, "CVE-2023-0379": {"epss_score": 0.00316, "epss_percentile": 0.5424}, "CVE-2023-0380": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0381": {"epss_score": 0.00414, "epss_percentile": 0.61035}, "CVE-2023-0382": {"epss_score": 0.00073, "epss_percentile": 0.22499}, "CVE-2023-0383": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-0384": {"epss_score": 0.00069, "epss_percentile": 0.21459}, "CVE-2023-0385": {"epss_score": 0.00089, "epss_percentile": 0.2589}, "CVE-2023-0386": {"epss_score": 0.59949, "epss_percentile": 0.98188}, "CVE-2023-0388": {"epss_score": 0.00277, "epss_percentile": 0.5082}, "CVE-2023-0389": {"epss_score": 0.00164, "epss_percentile": 0.37957}, "CVE-2023-0391": {"epss_score": 0.00109, "epss_percentile": 0.3}, "CVE-2023-0392": {"epss_score": 0.00051, "epss_percentile": 0.16043}, "CVE-2023-0394": {"epss_score": 0.0003, "epss_percentile": 0.08209}, "CVE-2023-0395": {"epss_score": 0.00137, "epss_percentile": 0.34216}, "CVE-2023-0396": {"epss_score": 0.00055, "epss_percentile": 0.17561}, "CVE-2023-0397": {"epss_score": 0.00037, "epss_percentile": 0.10739}, "CVE-2023-0398": {"epss_score": 0.00238, "epss_percentile": 0.46761}, "CVE-2023-0399": {"epss_score": 0.00149, "epss_percentile": 0.36025}, "CVE-2023-0400": {"epss_score": 0.00108, "epss_percentile": 0.29851}, "CVE-2023-0401": {"epss_score": 0.01007, "epss_percentile": 0.76561}, "CVE-2023-0402": {"epss_score": 0.00032, "epss_percentile": 0.08783}, "CVE-2023-0403": {"epss_score": 0.00063, "epss_percentile": 0.19933}, "CVE-2023-0404": {"epss_score": 0.00032, "epss_percentile": 0.09038}, "CVE-2023-0405": {"epss_score": 0.00136, "epss_percentile": 0.34188}, "CVE-2023-0406": {"epss_score": 0.00256, "epss_percentile": 0.48768}, "CVE-2023-0410": {"epss_score": 0.00169, "epss_percentile": 0.38605}, "CVE-2023-0411": {"epss_score": 0.00151, "epss_percentile": 0.36214}, "CVE-2023-0412": {"epss_score": 0.00149, "epss_percentile": 0.35954}, "CVE-2023-0413": {"epss_score": 0.00119, "epss_percentile": 0.31533}, "CVE-2023-0414": {"epss_score": 0.00079, "epss_percentile": 0.23854}, "CVE-2023-0415": {"epss_score": 0.00119, "epss_percentile": 0.31533}, "CVE-2023-0416": {"epss_score": 0.00073, "epss_percentile": 0.22665}, "CVE-2023-0417": {"epss_score": 0.00062, "epss_percentile": 0.19675}, "CVE-2023-0418": {"epss_score": 0.00144, "epss_percentile": 0.35239}, "CVE-2023-0419": {"epss_score": 0.00273, "epss_percentile": 0.50469}, "CVE-2023-0420": {"epss_score": 0.00067, "epss_percentile": 0.21034}, "CVE-2023-0421": {"epss_score": 0.00549, "epss_percentile": 0.67295}, "CVE-2023-0422": {"epss_score": 0.00112, "epss_percentile": 0.30441}, "CVE-2023-0423": {"epss_score": 0.00112, "epss_percentile": 0.30441}, "CVE-2023-0424": {"epss_score": 0.00118, "epss_percentile": 0.31454}, "CVE-2023-0425": {"epss_score": 0.00176, "epss_percentile": 0.39386}, "CVE-2023-0426": {"epss_score": 0.0016, "epss_percentile": 0.37515}, "CVE-2023-0428": {"epss_score": 0.00401, "epss_percentile": 0.60243}, "CVE-2023-0429": {"epss_score": 0.00113, "epss_percentile": 0.30642}, "CVE-2023-0430": {"epss_score": 0.00071, "epss_percentile": 0.22169}, "CVE-2023-0431": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-0432": {"epss_score": 0.00275, "epss_percentile": 0.50639}, "CVE-2023-0433": {"epss_score": 0.00031, "epss_percentile": 0.08413}, "CVE-2023-0434": {"epss_score": 0.00173, "epss_percentile": 0.39116}, "CVE-2023-0435": {"epss_score": 0.00312, "epss_percentile": 0.53965}, "CVE-2023-0436": {"epss_score": 0.00268, "epss_percentile": 0.50071}, "CVE-2023-0437": {"epss_score": 0.00043, "epss_percentile": 0.13361}, "CVE-2023-0438": {"epss_score": 0.00142, "epss_percentile": 0.35002}, "CVE-2023-0439": {"epss_score": 0.00092, "epss_percentile": 0.26577}, "CVE-2023-0440": {"epss_score": 0.001, "epss_percentile": 0.28557}, "CVE-2023-0441": {"epss_score": 0.00282, "epss_percentile": 0.51215}, "CVE-2023-0442": {"epss_score": 0.00148, "epss_percentile": 0.35844}, "CVE-2023-0443": {"epss_score": 0.00125, "epss_percentile": 0.32612}, "CVE-2023-0444": {"epss_score": 0.00319, "epss_percentile": 0.54529}, "CVE-2023-0446": {"epss_score": 0.00139, "epss_percentile": 0.34649}, "CVE-2023-0447": {"epss_score": 0.00081, "epss_percentile": 0.2422}, "CVE-2023-0448": {"epss_score": 0.2765, "epss_percentile": 0.96268}, "CVE-2023-0450": {"epss_score": 0.01282, "epss_percentile": 0.79152}, "CVE-2023-0451": {"epss_score": 0.00153, "epss_percentile": 0.36536}, "CVE-2023-0452": {"epss_score": 0.00095, "epss_percentile": 0.27194}, "CVE-2023-0453": {"epss_score": 0.00149, "epss_percentile": 0.35946}, "CVE-2023-0454": {"epss_score": 0.00118, "epss_percentile": 0.31397}, "CVE-2023-0455": {"epss_score": 0.04881, "epss_percentile": 0.89247}, "CVE-2023-0456": {"epss_score": 0.00195, "epss_percentile": 0.41668}, "CVE-2023-0457": {"epss_score": 0.01778, "epss_percentile": 0.82228}, "CVE-2023-0458": {"epss_score": 0.0008, "epss_percentile": 0.24049}, "CVE-2023-0459": {"epss_score": 0.00011, "epss_percentile": 0.00927}, "CVE-2023-0460": {"epss_score": 0.00016, "epss_percentile": 0.0268}, "CVE-2023-0461": {"epss_score": 0.00128, "epss_percentile": 0.33038}, "CVE-2023-0462": {"epss_score": 0.00079, "epss_percentile": 0.23822}, "CVE-2023-0463": {"epss_score": 0.00143, "epss_percentile": 0.35143}, "CVE-2023-0464": {"epss_score": 0.00834, "epss_percentile": 0.74106}, "CVE-2023-0465": {"epss_score": 0.00387, "epss_percentile": 0.59327}, "CVE-2023-0466": {"epss_score": 0.00666, "epss_percentile": 0.70696}, "CVE-2023-0467": {"epss_score": 0.00207, "epss_percentile": 0.43191}, "CVE-2023-0468": {"epss_score": 0.00014, "epss_percentile": 0.02018}, "CVE-2023-0469": {"epss_score": 0.00019, "epss_percentile": 0.04279}, "CVE-2023-0470": {"epss_score": 0.00209, "epss_percentile": 0.43414}, "CVE-2023-0471": {"epss_score": 0.00163, "epss_percentile": 0.37763}, "CVE-2023-0472": {"epss_score": 0.00219, "epss_percentile": 0.44513}, "CVE-2023-0473": {"epss_score": 0.00166, "epss_percentile": 0.38159}, "CVE-2023-0474": {"epss_score": 0.00143, "epss_percentile": 0.35223}, "CVE-2023-0475": {"epss_score": 0.00078, "epss_percentile": 0.23639}, "CVE-2023-0476": {"epss_score": 0.00306, "epss_percentile": 0.53445}, "CVE-2023-0477": {"epss_score": 0.00419, "epss_percentile": 0.6135}, "CVE-2023-0479": {"epss_score": 0.00235, "epss_percentile": 0.46328}, "CVE-2023-0480": {"epss_score": 0.00145, "epss_percentile": 0.35445}, "CVE-2023-0481": {"epss_score": 0.0004, "epss_percentile": 0.12055}, "CVE-2023-0482": {"epss_score": 0.00039, "epss_percentile": 0.11639}, "CVE-2023-0483": {"epss_score": 0.00142, "epss_percentile": 0.35003}, "CVE-2023-0484": {"epss_score": 0.00083, "epss_percentile": 0.24789}, "CVE-2023-0485": {"epss_score": 0.00295, "epss_percentile": 0.52495}, "CVE-2023-0486": {"epss_score": 0.00147, "epss_percentile": 0.35747}, "CVE-2023-0487": {"epss_score": 0.00293, "epss_percentile": 0.52352}, "CVE-2023-0488": {"epss_score": 0.00335, "epss_percentile": 0.55806}, "CVE-2023-0489": {"epss_score": 0.00092, "epss_percentile": 0.26577}, "CVE-2023-0490": {"epss_score": 0.00092, "epss_percentile": 0.26577}, "CVE-2023-0491": {"epss_score": 0.00141, "epss_percentile": 0.34929}, "CVE-2023-0492": {"epss_score": 0.00138, "epss_percentile": 0.34418}, "CVE-2023-0493": {"epss_score": 0.01362, "epss_percentile": 0.79759}, "CVE-2023-0494": {"epss_score": 0.00577, "epss_percentile": 0.68157}, "CVE-2023-0495": {"epss_score": 0.00091, "epss_percentile": 0.26261}, "CVE-2023-0496": {"epss_score": 0.00083, "epss_percentile": 0.24789}, "CVE-2023-0497": {"epss_score": 0.00116, "epss_percentile": 0.31131}, "CVE-2023-0498": {"epss_score": 0.00091, "epss_percentile": 0.26261}, "CVE-2023-0499": {"epss_score": 0.00083, "epss_percentile": 0.24789}, "CVE-2023-0500": {"epss_score": 0.00124, "epss_percentile": 0.32372}, "CVE-2023-0501": {"epss_score": 0.00124, "epss_percentile": 0.32372}, "CVE-2023-0502": {"epss_score": 0.00124, "epss_percentile": 0.32372}, "CVE-2023-0503": {"epss_score": 0.00083, "epss_percentile": 0.24789}, "CVE-2023-0504": {"epss_score": 0.00091, "epss_percentile": 0.26261}, "CVE-2023-0505": {"epss_score": 0.00083, "epss_percentile": 0.24789}, "CVE-2023-0506": {"epss_score": 0.00066, "epss_percentile": 0.20927}, "CVE-2023-0507": {"epss_score": 0.66153, "epss_percentile": 0.98453}, "CVE-2023-0508": {"epss_score": 0.03744, "epss_percentile": 0.87659}, "CVE-2023-0509": {"epss_score": 0.00248, "epss_percentile": 0.47991}, "CVE-2023-0511": {"epss_score": 0.00115, "epss_percentile": 0.30955}, "CVE-2023-0512": {"epss_score": 0.00026, "epss_percentile": 0.06429}, "CVE-2023-0513": {"epss_score": 0.00353, "epss_percentile": 0.57149}, "CVE-2023-0514": {"epss_score": 0.12454, "epss_percentile": 0.93678}, "CVE-2023-0515": {"epss_score": 0.00288, "epss_percentile": 0.51901}, "CVE-2023-0516": {"epss_score": 0.00381, "epss_percentile": 0.59016}, "CVE-2023-0518": {"epss_score": 0.00595, "epss_percentile": 0.68684}, "CVE-2023-0519": {"epss_score": 0.00082, "epss_percentile": 0.2447}, "CVE-2023-0520": {"epss_score": 0.00071, "epss_percentile": 0.22181}, "CVE-2023-0522": {"epss_score": 0.0009, "epss_percentile": 0.26167}, "CVE-2023-0523": {"epss_score": 0.22148, "epss_percentile": 0.95601}, "CVE-2023-0524": {"epss_score": 0.00184, "epss_percentile": 0.40405}, "CVE-2023-0525": {"epss_score": 0.00314, "epss_percentile": 0.5409}, "CVE-2023-0526": {"epss_score": 0.00119, "epss_percentile": 0.31657}, "CVE-2023-0527": {"epss_score": 0.06896, "epss_percentile": 0.911}, "CVE-2023-0528": {"epss_score": 0.00075, "epss_percentile": 0.22939}, "CVE-2023-0529": {"epss_score": 0.00075, "epss_percentile": 0.22939}, "CVE-2023-0530": {"epss_score": 0.0006, "epss_percentile": 0.19062}, "CVE-2023-0531": {"epss_score": 0.00064, "epss_percentile": 0.20357}, "CVE-2023-0532": {"epss_score": 0.00064, "epss_percentile": 0.20357}, "CVE-2023-0533": {"epss_score": 0.00064, "epss_percentile": 0.20357}, "CVE-2023-0534": {"epss_score": 0.00064, "epss_percentile": 0.20357}, "CVE-2023-0535": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0536": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-0537": {"epss_score": 0.00152, "epss_percentile": 0.36442}, "CVE-2023-0538": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0539": {"epss_score": 0.00192, "epss_percentile": 0.41346}, "CVE-2023-0540": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0541": {"epss_score": 0.00211, "epss_percentile": 0.43682}, "CVE-2023-0542": {"epss_score": 0.00119, "epss_percentile": 0.31657}, "CVE-2023-0543": {"epss_score": 0.00113, "epss_percentile": 0.30642}, "CVE-2023-0544": {"epss_score": 0.00089, "epss_percentile": 0.25945}, "CVE-2023-0545": {"epss_score": 0.00098, "epss_percentile": 0.27667}, "CVE-2023-0546": {"epss_score": 0.00149, "epss_percentile": 0.36025}, "CVE-2023-0547": {"epss_score": 0.00127, "epss_percentile": 0.32791}, "CVE-2023-0548": {"epss_score": 0.00157, "epss_percentile": 0.37107}, "CVE-2023-0549": {"epss_score": 0.00134, "epss_percentile": 0.33756}, "CVE-2023-0550": {"epss_score": 0.00071, "epss_percentile": 0.2201}, "CVE-2023-0551": {"epss_score": 0.00033, "epss_percentile": 0.09368}, "CVE-2023-0552": {"epss_score": 0.14864, "epss_percentile": 0.94304}, "CVE-2023-0553": {"epss_score": 0.00231, "epss_percentile": 0.45767}, "CVE-2023-0554": {"epss_score": 0.00074, "epss_percentile": 0.22768}, "CVE-2023-0555": {"epss_score": 0.00057, "epss_percentile": 0.17982}, "CVE-2023-0556": {"epss_score": 0.00302, "epss_percentile": 0.53126}, "CVE-2023-0557": {"epss_score": 0.00547, "epss_percentile": 0.67255}, "CVE-2023-0558": {"epss_score": 0.00231, "epss_percentile": 0.4584}, "CVE-2023-0559": {"epss_score": 0.00151, "epss_percentile": 0.36247}, "CVE-2023-0560": {"epss_score": 0.00069, "epss_percentile": 0.2155}, "CVE-2023-0561": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-0562": {"epss_score": 0.81836, "epss_percentile": 0.9916}, "CVE-2023-0563": {"epss_score": 0.29762, "epss_percentile": 0.96473}, "CVE-2023-0564": {"epss_score": 0.0014, "epss_percentile": 0.34689}, "CVE-2023-0565": {"epss_score": 0.00195, "epss_percentile": 0.41621}, "CVE-2023-0566": {"epss_score": 0.00071, "epss_percentile": 0.2222}, "CVE-2023-0567": {"epss_score": 0.00035, "epss_percentile": 0.1004}, "CVE-2023-0568": {"epss_score": 0.00128, "epss_percentile": 0.33022}, "CVE-2023-0569": {"epss_score": 0.00142, "epss_percentile": 0.34978}, "CVE-2023-0570": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-0571": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2023-0572": {"epss_score": 0.00118, "epss_percentile": 0.31466}, "CVE-2023-0574": {"epss_score": 0.0009, "epss_percentile": 0.26018}, "CVE-2023-0575": {"epss_score": 0.001, "epss_percentile": 0.28496}, "CVE-2023-0577": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-0578": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-0579": {"epss_score": 0.00277, "epss_percentile": 0.5082}, "CVE-2023-0580": {"epss_score": 0.00265, "epss_percentile": 0.49751}, "CVE-2023-0581": {"epss_score": 0.0026, "epss_percentile": 0.49174}, "CVE-2023-0582": {"epss_score": 0.00035, "epss_percentile": 0.09996}, "CVE-2023-0583": {"epss_score": 0.00042, "epss_percentile": 0.12907}, "CVE-2023-0584": {"epss_score": 0.00042, "epss_percentile": 0.12907}, "CVE-2023-0585": {"epss_score": 0.02059, "epss_percentile": 0.83436}, "CVE-2023-0586": {"epss_score": 0.00171, "epss_percentile": 0.38774}, "CVE-2023-0587": {"epss_score": 0.31835, "epss_percentile": 0.96653}, "CVE-2023-0588": {"epss_score": 0.00108, "epss_percentile": 0.29847}, "CVE-2023-0589": {"epss_score": 0.00137, "epss_percentile": 0.34216}, "CVE-2023-0590": {"epss_score": 0.00012, "epss_percentile": 0.01156}, "CVE-2023-0591": {"epss_score": 0.0022, "epss_percentile": 0.44614}, "CVE-2023-0592": {"epss_score": 0.00074, "epss_percentile": 0.22746}, "CVE-2023-0593": {"epss_score": 0.00074, "epss_percentile": 0.22746}, "CVE-2023-0594": {"epss_score": 0.39806, "epss_percentile": 0.97181}, "CVE-2023-0595": {"epss_score": 0.00089, "epss_percentile": 0.25839}, "CVE-2023-0597": {"epss_score": 0.00017, "epss_percentile": 0.03254}, "CVE-2023-0598": {"epss_score": 0.0007, "epss_percentile": 0.21668}, "CVE-2023-0599": {"epss_score": 0.00478, "epss_percentile": 0.64391}, "CVE-2023-0600": {"epss_score": 0.77404, "epss_percentile": 0.98935}, "CVE-2023-0602": {"epss_score": 0.0565, "epss_percentile": 0.90084}, "CVE-2023-0603": {"epss_score": 0.07631, "epss_percentile": 0.91584}, "CVE-2023-0604": {"epss_score": 0.00152, "epss_percentile": 0.36442}, "CVE-2023-0605": {"epss_score": 0.00112, "epss_percentile": 0.30441}, "CVE-2023-0606": {"epss_score": 0.00167, "epss_percentile": 0.38369}, "CVE-2023-0607": {"epss_score": 0.0009, "epss_percentile": 0.26096}, "CVE-2023-0608": {"epss_score": 0.00143, "epss_percentile": 0.35152}, "CVE-2023-0609": {"epss_score": 0.00629, "epss_percentile": 0.69667}, "CVE-2023-0610": {"epss_score": 0.00171, "epss_percentile": 0.38807}, "CVE-2023-0611": {"epss_score": 0.00841, "epss_percentile": 0.74228}, "CVE-2023-0612": {"epss_score": 0.00122, "epss_percentile": 0.32041}, "CVE-2023-0613": {"epss_score": 0.00093, "epss_percentile": 0.26727}, "CVE-2023-0614": {"epss_score": 0.00231, "epss_percentile": 0.45773}, "CVE-2023-0615": {"epss_score": 8e-05, "epss_percentile": 0.00574}, "CVE-2023-0616": {"epss_score": 0.00104, "epss_percentile": 0.29227}, "CVE-2023-0617": {"epss_score": 0.00159, "epss_percentile": 0.37387}, "CVE-2023-0618": {"epss_score": 0.00093, "epss_percentile": 0.26727}, "CVE-2023-0619": {"epss_score": 0.00046, "epss_percentile": 0.1441}, "CVE-2023-0620": {"epss_score": 0.00075, "epss_percentile": 0.23017}, "CVE-2023-0621": {"epss_score": 0.00062, "epss_percentile": 0.19666}, "CVE-2023-0622": {"epss_score": 0.00047, "epss_percentile": 0.14883}, "CVE-2023-0623": {"epss_score": 0.00047, "epss_percentile": 0.14883}, "CVE-2023-0624": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-0625": {"epss_score": 0.00405, "epss_percentile": 0.60485}, "CVE-2023-0626": {"epss_score": 0.00405, "epss_percentile": 0.60485}, "CVE-2023-0627": {"epss_score": 0.00035, "epss_percentile": 0.09819}, "CVE-2023-0628": {"epss_score": 0.00066, "epss_percentile": 0.20848}, "CVE-2023-0629": {"epss_score": 0.00021, "epss_percentile": 0.04785}, "CVE-2023-0630": {"epss_score": 0.92822, "epss_percentile": 0.99752}, "CVE-2023-0631": {"epss_score": 0.8003, "epss_percentile": 0.99068}, "CVE-2023-0632": {"epss_score": 0.00269, "epss_percentile": 0.50191}, "CVE-2023-0633": {"epss_score": 0.0007, "epss_percentile": 0.21647}, "CVE-2023-0635": {"epss_score": 0.00117, "epss_percentile": 0.31365}, "CVE-2023-0636": {"epss_score": 0.00202, "epss_percentile": 0.4249}, "CVE-2023-0637": {"epss_score": 0.00088, "epss_percentile": 0.25775}, "CVE-2023-0638": {"epss_score": 0.00242, "epss_percentile": 0.47381}, "CVE-2023-0639": {"epss_score": 0.00065, "epss_percentile": 0.20457}, "CVE-2023-0640": {"epss_score": 0.01219, "epss_percentile": 0.78611}, "CVE-2023-0641": {"epss_score": 0.00348, "epss_percentile": 0.56849}, "CVE-2023-0642": {"epss_score": 0.00281, "epss_percentile": 0.51141}, "CVE-2023-0643": {"epss_score": 0.00322, "epss_percentile": 0.54747}, "CVE-2023-0644": {"epss_score": 0.00253, "epss_percentile": 0.48471}, "CVE-2023-0645": {"epss_score": 0.00062, "epss_percentile": 0.19566}, "CVE-2023-0646": {"epss_score": 0.00749, "epss_percentile": 0.72596}, "CVE-2023-0647": {"epss_score": 0.00749, "epss_percentile": 0.72596}, "CVE-2023-0648": {"epss_score": 0.00749, "epss_percentile": 0.72596}, "CVE-2023-0649": {"epss_score": 0.00749, "epss_percentile": 0.72596}, "CVE-2023-0650": {"epss_score": 0.0019, "epss_percentile": 0.4109}, "CVE-2023-0651": {"epss_score": 0.00103, "epss_percentile": 0.28996}, "CVE-2023-0652": {"epss_score": 0.00315, "epss_percentile": 0.54181}, "CVE-2023-0654": {"epss_score": 0.00048, "epss_percentile": 0.14973}, "CVE-2023-0655": {"epss_score": 0.00254, "epss_percentile": 0.485}, "CVE-2023-0656": {"epss_score": 0.38433, "epss_percentile": 0.971}, "CVE-2023-0657": {"epss_score": 0.0004, "epss_percentile": 0.11968}, "CVE-2023-0658": {"epss_score": 0.00118, "epss_percentile": 0.31404}, "CVE-2023-0659": {"epss_score": 0.00118, "epss_percentile": 0.31404}, "CVE-2023-0660": {"epss_score": 0.00212, "epss_percentile": 0.43821}, "CVE-2023-0661": {"epss_score": 0.00223, "epss_percentile": 0.44885}, "CVE-2023-0662": {"epss_score": 0.001, "epss_percentile": 0.28512}, "CVE-2023-0663": {"epss_score": 0.00131, "epss_percentile": 0.33381}, "CVE-2023-0664": {"epss_score": 0.00018, "epss_percentile": 0.0389}, "CVE-2023-0665": {"epss_score": 0.00079, "epss_percentile": 0.23888}, "CVE-2023-0666": {"epss_score": 0.01174, "epss_percentile": 0.78249}, "CVE-2023-0667": {"epss_score": 0.00265, "epss_percentile": 0.49786}, "CVE-2023-0668": {"epss_score": 0.01119, "epss_percentile": 0.77756}, "CVE-2023-0669": {"epss_score": 0.94378, "epss_percentile": 0.99963}, "CVE-2023-0670": {"epss_score": 0.01317, "epss_percentile": 0.79418}, "CVE-2023-0671": {"epss_score": 0.00177, "epss_percentile": 0.3952}, "CVE-2023-0673": {"epss_score": 0.00056, "epss_percentile": 0.1789}, "CVE-2023-0674": {"epss_score": 0.00071, "epss_percentile": 0.22023}, "CVE-2023-0675": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-0676": {"epss_score": 0.00394, "epss_percentile": 0.59752}, "CVE-2023-0677": {"epss_score": 0.00123, "epss_percentile": 0.32208}, "CVE-2023-0678": {"epss_score": 0.63963, "epss_percentile": 0.98357}, "CVE-2023-0679": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-0681": {"epss_score": 0.00066, "epss_percentile": 0.20943}, "CVE-2023-0683": {"epss_score": 0.0024, "epss_percentile": 0.46945}, "CVE-2023-0684": {"epss_score": 0.00057, "epss_percentile": 0.18146}, "CVE-2023-0685": {"epss_score": 0.00104, "epss_percentile": 0.29232}, "CVE-2023-0686": {"epss_score": 0.00142, "epss_percentile": 0.35086}, "CVE-2023-0687": {"epss_score": 0.0007, "epss_percentile": 0.21818}, "CVE-2023-0688": {"epss_score": 0.00241, "epss_percentile": 0.47326}, "CVE-2023-0689": {"epss_score": 0.00132, "epss_percentile": 0.33576}, "CVE-2023-0690": {"epss_score": 0.00026, "epss_percentile": 0.06593}, "CVE-2023-0691": {"epss_score": 0.00127, "epss_percentile": 0.32879}, "CVE-2023-0692": {"epss_score": 0.00127, "epss_percentile": 0.32879}, "CVE-2023-0693": {"epss_score": 0.00241, "epss_percentile": 0.47321}, "CVE-2023-0694": {"epss_score": 0.00241, "epss_percentile": 0.47321}, "CVE-2023-0695": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-0696": {"epss_score": 0.00163, "epss_percentile": 0.3783}, "CVE-2023-0697": {"epss_score": 0.00109, "epss_percentile": 0.30043}, "CVE-2023-0698": {"epss_score": 0.00164, "epss_percentile": 0.37976}, "CVE-2023-0699": {"epss_score": 0.00285, "epss_percentile": 0.51515}, "CVE-2023-0700": {"epss_score": 0.00142, "epss_percentile": 0.34957}, "CVE-2023-0701": {"epss_score": 0.00403, "epss_percentile": 0.60351}, "CVE-2023-0702": {"epss_score": 0.00177, "epss_percentile": 0.39586}, "CVE-2023-0703": {"epss_score": 0.00278, "epss_percentile": 0.50878}, "CVE-2023-0704": {"epss_score": 0.00034, "epss_percentile": 0.09517}, "CVE-2023-0705": {"epss_score": 0.0028, "epss_percentile": 0.51023}, "CVE-2023-0706": {"epss_score": 0.00048, "epss_percentile": 0.15252}, "CVE-2023-0707": {"epss_score": 0.00048, "epss_percentile": 0.15252}, "CVE-2023-0708": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-0709": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-0710": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-0711": {"epss_score": 0.00057, "epss_percentile": 0.18146}, "CVE-2023-0712": {"epss_score": 0.00057, "epss_percentile": 0.18146}, "CVE-2023-0713": {"epss_score": 0.00036, "epss_percentile": 0.10611}, "CVE-2023-0714": {"epss_score": 0.13921, "epss_percentile": 0.94093}, "CVE-2023-0715": {"epss_score": 0.00057, "epss_percentile": 0.18146}, "CVE-2023-0716": {"epss_score": 0.00057, "epss_percentile": 0.18146}, "CVE-2023-0717": {"epss_score": 0.00057, "epss_percentile": 0.18146}, "CVE-2023-0718": {"epss_score": 0.00031, "epss_percentile": 0.0857}, "CVE-2023-0719": {"epss_score": 0.00057, "epss_percentile": 0.18146}, "CVE-2023-0720": {"epss_score": 0.00057, "epss_percentile": 0.18146}, "CVE-2023-0721": {"epss_score": 0.00554, "epss_percentile": 0.6745}, "CVE-2023-0722": {"epss_score": 0.00104, "epss_percentile": 0.29232}, "CVE-2023-0723": {"epss_score": 0.00104, "epss_percentile": 0.29232}, "CVE-2023-0724": {"epss_score": 0.00104, "epss_percentile": 0.29232}, "CVE-2023-0725": {"epss_score": 0.00104, "epss_percentile": 0.29232}, "CVE-2023-0726": {"epss_score": 0.00104, "epss_percentile": 0.29232}, "CVE-2023-0727": {"epss_score": 0.00104, "epss_percentile": 0.29232}, "CVE-2023-0728": {"epss_score": 0.00114, "epss_percentile": 0.30745}, "CVE-2023-0729": {"epss_score": 0.00067, "epss_percentile": 0.21013}, "CVE-2023-0730": {"epss_score": 0.00104, "epss_percentile": 0.29232}, "CVE-2023-0731": {"epss_score": 0.001, "epss_percentile": 0.2848}, "CVE-2023-0732": {"epss_score": 0.00075, "epss_percentile": 0.22896}, "CVE-2023-0733": {"epss_score": 0.00464, "epss_percentile": 0.63738}, "CVE-2023-0734": {"epss_score": 0.00095, "epss_percentile": 0.27152}, "CVE-2023-0735": {"epss_score": 0.00152, "epss_percentile": 0.36426}, "CVE-2023-0736": {"epss_score": 0.00173, "epss_percentile": 0.39136}, "CVE-2023-0737": {"epss_score": 0.00079, "epss_percentile": 0.23876}, "CVE-2023-0738": {"epss_score": 0.00113, "epss_percentile": 0.3063}, "CVE-2023-0739": {"epss_score": 0.00179, "epss_percentile": 0.39772}, "CVE-2023-0740": {"epss_score": 0.0011, "epss_percentile": 0.30222}, "CVE-2023-0741": {"epss_score": 0.0015, "epss_percentile": 0.36116}, "CVE-2023-0742": {"epss_score": 0.0015, "epss_percentile": 0.36116}, "CVE-2023-0743": {"epss_score": 0.00138, "epss_percentile": 0.34424}, "CVE-2023-0744": {"epss_score": 0.03644, "epss_percentile": 0.87497}, "CVE-2023-0745": {"epss_score": 0.00098, "epss_percentile": 0.27818}, "CVE-2023-0746": {"epss_score": 0.00115, "epss_percentile": 0.30986}, "CVE-2023-0747": {"epss_score": 0.00075, "epss_percentile": 0.23039}, "CVE-2023-0748": {"epss_score": 0.00314, "epss_percentile": 0.54078}, "CVE-2023-0749": {"epss_score": 0.00296, "epss_percentile": 0.52596}, "CVE-2023-0750": {"epss_score": 0.00061, "epss_percentile": 0.19339}, "CVE-2023-0751": {"epss_score": 0.0033, "epss_percentile": 0.55454}, "CVE-2023-0754": {"epss_score": 0.00141, "epss_percentile": 0.34922}, "CVE-2023-0755": {"epss_score": 0.01717, "epss_percentile": 0.81919}, "CVE-2023-0756": {"epss_score": 0.00194, "epss_percentile": 0.41588}, "CVE-2023-0757": {"epss_score": 0.00811, "epss_percentile": 0.73726}, "CVE-2023-0758": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-0759": {"epss_score": 0.00054, "epss_percentile": 0.17113}, "CVE-2023-0760": {"epss_score": 0.00045, "epss_percentile": 0.13798}, "CVE-2023-0761": {"epss_score": 0.00056, "epss_percentile": 0.17924}, "CVE-2023-0762": {"epss_score": 0.00056, "epss_percentile": 0.17924}, "CVE-2023-0763": {"epss_score": 0.00056, "epss_percentile": 0.17924}, "CVE-2023-0764": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-0765": {"epss_score": 0.00224, "epss_percentile": 0.45019}, "CVE-2023-0766": {"epss_score": 0.00082, "epss_percentile": 0.24417}, "CVE-2023-0767": {"epss_score": 0.0022, "epss_percentile": 0.44545}, "CVE-2023-0768": {"epss_score": 0.00328, "epss_percentile": 0.55158}, "CVE-2023-0769": {"epss_score": 0.00284, "epss_percentile": 0.51493}, "CVE-2023-0770": {"epss_score": 0.00043, "epss_percentile": 0.13177}, "CVE-2023-0771": {"epss_score": 0.00109, "epss_percentile": 0.30044}, "CVE-2023-0772": {"epss_score": 0.0044, "epss_percentile": 0.62621}, "CVE-2023-0773": {"epss_score": 0.00626, "epss_percentile": 0.69607}, "CVE-2023-0774": {"epss_score": 0.00059, "epss_percentile": 0.18814}, "CVE-2023-0775": {"epss_score": 0.00036, "epss_percentile": 0.10457}, "CVE-2023-0776": {"epss_score": 0.00157, "epss_percentile": 0.37058}, "CVE-2023-0777": {"epss_score": 0.71906, "epss_percentile": 0.98685}, "CVE-2023-0778": {"epss_score": 0.00117, "epss_percentile": 0.3133}, "CVE-2023-0779": {"epss_score": 0.00214, "epss_percentile": 0.43989}, "CVE-2023-0780": {"epss_score": 0.00211, "epss_percentile": 0.43622}, "CVE-2023-0781": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-0782": {"epss_score": 0.00115, "epss_percentile": 0.30994}, "CVE-2023-0783": {"epss_score": 0.0008, "epss_percentile": 0.24115}, "CVE-2023-0784": {"epss_score": 0.00065, "epss_percentile": 0.20616}, "CVE-2023-0785": {"epss_score": 0.0012, "epss_percentile": 0.3174}, "CVE-2023-0786": {"epss_score": 0.00102, "epss_percentile": 0.28847}, "CVE-2023-0787": {"epss_score": 0.00133, "epss_percentile": 0.33629}, "CVE-2023-0788": {"epss_score": 0.00145, "epss_percentile": 0.35395}, "CVE-2023-0789": {"epss_score": 0.01039, "epss_percentile": 0.76944}, "CVE-2023-0790": {"epss_score": 0.00149, "epss_percentile": 0.35943}, "CVE-2023-0791": {"epss_score": 0.001, "epss_percentile": 0.28469}, "CVE-2023-0792": {"epss_score": 0.00338, "epss_percentile": 0.5611}, "CVE-2023-0793": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-0794": {"epss_score": 0.00109, "epss_percentile": 0.30008}, "CVE-2023-0795": {"epss_score": 0.00011, "epss_percentile": 0.01101}, "CVE-2023-0796": {"epss_score": 0.00011, "epss_percentile": 0.01101}, "CVE-2023-0797": {"epss_score": 0.00011, "epss_percentile": 0.01101}, "CVE-2023-0798": {"epss_score": 0.00011, "epss_percentile": 0.01101}, "CVE-2023-0799": {"epss_score": 0.00013, "epss_percentile": 0.0154}, "CVE-2023-0800": {"epss_score": 0.00023, "epss_percentile": 0.05635}, "CVE-2023-0801": {"epss_score": 0.00023, "epss_percentile": 0.05635}, "CVE-2023-0802": {"epss_score": 0.00023, "epss_percentile": 0.05635}, "CVE-2023-0803": {"epss_score": 0.00023, "epss_percentile": 0.05635}, "CVE-2023-0804": {"epss_score": 0.00017, "epss_percentile": 0.03108}, "CVE-2023-0805": {"epss_score": 0.00056, "epss_percentile": 0.17665}, "CVE-2023-0808": {"epss_score": 0.00038, "epss_percentile": 0.11403}, "CVE-2023-0809": {"epss_score": 0.00029, "epss_percentile": 0.07926}, "CVE-2023-0810": {"epss_score": 0.00106, "epss_percentile": 0.29559}, "CVE-2023-0811": {"epss_score": 0.00172, "epss_percentile": 0.38913}, "CVE-2023-0812": {"epss_score": 0.00321, "epss_percentile": 0.54652}, "CVE-2023-0813": {"epss_score": 0.00113, "epss_percentile": 0.30717}, "CVE-2023-0814": {"epss_score": 0.0031, "epss_percentile": 0.53791}, "CVE-2023-0815": {"epss_score": 0.00287, "epss_percentile": 0.51852}, "CVE-2023-0816": {"epss_score": 0.00085, "epss_percentile": 0.25173}, "CVE-2023-0817": {"epss_score": 0.00054, "epss_percentile": 0.17265}, "CVE-2023-0818": {"epss_score": 0.00028, "epss_percentile": 0.07278}, "CVE-2023-0819": {"epss_score": 0.00048, "epss_percentile": 0.15172}, "CVE-2023-0820": {"epss_score": 0.00132, "epss_percentile": 0.33553}, "CVE-2023-0821": {"epss_score": 0.00253, "epss_percentile": 0.48456}, "CVE-2023-0822": {"epss_score": 0.00031, "epss_percentile": 0.08575}, "CVE-2023-0823": {"epss_score": 0.00149, "epss_percentile": 0.36025}, "CVE-2023-0824": {"epss_score": 0.00149, "epss_percentile": 0.35952}, "CVE-2023-0827": {"epss_score": 0.00021, "epss_percentile": 0.04901}, "CVE-2023-0828": {"epss_score": 0.00257, "epss_percentile": 0.48943}, "CVE-2023-0829": {"epss_score": 0.00089, "epss_percentile": 0.25938}, "CVE-2023-0830": {"epss_score": 0.32729, "epss_percentile": 0.9672}, "CVE-2023-0831": {"epss_score": 0.00063, "epss_percentile": 0.19811}, "CVE-2023-0832": {"epss_score": 0.00063, "epss_percentile": 0.19811}, "CVE-2023-0833": {"epss_score": 0.00036, "epss_percentile": 0.1021}, "CVE-2023-0834": {"epss_score": 0.00099, "epss_percentile": 0.28396}, "CVE-2023-0835": {"epss_score": 0.00135, "epss_percentile": 0.33993}, "CVE-2023-0836": {"epss_score": 5e-05, "epss_percentile": 0.00178}, "CVE-2023-0837": {"epss_score": 0.00059, "epss_percentile": 0.1871}, "CVE-2023-0838": {"epss_score": 0.00727, "epss_percentile": 0.72094}, "CVE-2023-0839": {"epss_score": 0.0011, "epss_percentile": 0.30113}, "CVE-2023-0840": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2023-0841": {"epss_score": 0.00272, "epss_percentile": 0.50366}, "CVE-2023-0842": {"epss_score": 0.00211, "epss_percentile": 0.43664}, "CVE-2023-0844": {"epss_score": 0.00129, "epss_percentile": 0.33166}, "CVE-2023-0845": {"epss_score": 0.00336, "epss_percentile": 0.5593}, "CVE-2023-0846": {"epss_score": 0.0029, "epss_percentile": 0.5212}, "CVE-2023-0847": {"epss_score": 0.02089, "epss_percentile": 0.8356}, "CVE-2023-0848": {"epss_score": 0.00065, "epss_percentile": 0.20508}, "CVE-2023-0849": {"epss_score": 0.00104, "epss_percentile": 0.29201}, "CVE-2023-0850": {"epss_score": 0.0005, "epss_percentile": 0.15665}, "CVE-2023-0851": {"epss_score": 0.0024, "epss_percentile": 0.47215}, "CVE-2023-0852": {"epss_score": 0.0024, "epss_percentile": 0.47215}, "CVE-2023-0853": {"epss_score": 0.0024, "epss_percentile": 0.47215}, "CVE-2023-0854": {"epss_score": 0.00169, "epss_percentile": 0.38557}, "CVE-2023-0855": {"epss_score": 0.00169, "epss_percentile": 0.38557}, "CVE-2023-0856": {"epss_score": 0.00169, "epss_percentile": 0.38557}, "CVE-2023-0857": {"epss_score": 0.00062, "epss_percentile": 0.19618}, "CVE-2023-0858": {"epss_score": 0.00088, "epss_percentile": 0.2565}, "CVE-2023-0859": {"epss_score": 0.00056, "epss_percentile": 0.17896}, "CVE-2023-0860": {"epss_score": 0.00241, "epss_percentile": 0.47261}, "CVE-2023-0861": {"epss_score": 0.01811, "epss_percentile": 0.8237}, "CVE-2023-0862": {"epss_score": 0.01014, "epss_percentile": 0.76648}, "CVE-2023-0863": {"epss_score": 0.00095, "epss_percentile": 0.27084}, "CVE-2023-0864": {"epss_score": 0.00041, "epss_percentile": 0.12361}, "CVE-2023-0865": {"epss_score": 0.04065, "epss_percentile": 0.88199}, "CVE-2023-0866": {"epss_score": 0.00048, "epss_percentile": 0.15172}, "CVE-2023-0867": {"epss_score": 0.00111, "epss_percentile": 0.304}, "CVE-2023-0868": {"epss_score": 0.00441, "epss_percentile": 0.62677}, "CVE-2023-0869": {"epss_score": 0.00121, "epss_percentile": 0.31955}, "CVE-2023-0870": {"epss_score": 0.00039, "epss_percentile": 0.11581}, "CVE-2023-0871": {"epss_score": 0.00037, "epss_percentile": 0.10635}, "CVE-2023-0872": {"epss_score": 0.03064, "epss_percentile": 0.86322}, "CVE-2023-0873": {"epss_score": 0.00185, "epss_percentile": 0.40468}, "CVE-2023-0874": {"epss_score": 0.00112, "epss_percentile": 0.30441}, "CVE-2023-0875": {"epss_score": 0.0028, "epss_percentile": 0.5108}, "CVE-2023-0876": {"epss_score": 0.09476, "epss_percentile": 0.92564}, "CVE-2023-0877": {"epss_score": 0.00157, "epss_percentile": 0.37099}, "CVE-2023-0878": {"epss_score": 0.0011, "epss_percentile": 0.30083}, "CVE-2023-0879": {"epss_score": 0.00075, "epss_percentile": 0.23039}, "CVE-2023-0880": {"epss_score": 0.00073, "epss_percentile": 0.22613}, "CVE-2023-0881": {"epss_score": 0.00171, "epss_percentile": 0.38812}, "CVE-2023-0882": {"epss_score": 0.00067, "epss_percentile": 0.21144}, "CVE-2023-0883": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-0887": {"epss_score": 0.00037, "epss_percentile": 0.10785}, "CVE-2023-0888": {"epss_score": 0.00119, "epss_percentile": 0.31645}, "CVE-2023-0889": {"epss_score": 0.00081, "epss_percentile": 0.24243}, "CVE-2023-0890": {"epss_score": 0.00278, "epss_percentile": 0.50853}, "CVE-2023-0891": {"epss_score": 0.00092, "epss_percentile": 0.26577}, "CVE-2023-0892": {"epss_score": 0.00083, "epss_percentile": 0.24605}, "CVE-2023-0893": {"epss_score": 0.00122, "epss_percentile": 0.32112}, "CVE-2023-0894": {"epss_score": 0.00089, "epss_percentile": 0.25945}, "CVE-2023-0895": {"epss_score": 0.00363, "epss_percentile": 0.57875}, "CVE-2023-0896": {"epss_score": 0.00094, "epss_percentile": 0.26961}, "CVE-2023-0897": {"epss_score": 0.00082, "epss_percentile": 0.24445}, "CVE-2023-0898": {"epss_score": 0.00036, "epss_percentile": 0.10343}, "CVE-2023-0899": {"epss_score": 0.00108, "epss_percentile": 0.29847}, "CVE-2023-0900": {"epss_score": 0.04805, "epss_percentile": 0.8916}, "CVE-2023-0901": {"epss_score": 0.00108, "epss_percentile": 0.29831}, "CVE-2023-0902": {"epss_score": 0.00881, "epss_percentile": 0.74876}, "CVE-2023-0903": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-0904": {"epss_score": 0.00087, "epss_percentile": 0.25613}, "CVE-2023-0905": {"epss_score": 0.0107, "epss_percentile": 0.77256}, "CVE-2023-0906": {"epss_score": 0.00074, "epss_percentile": 0.22831}, "CVE-2023-0907": {"epss_score": 0.00041, "epss_percentile": 0.12281}, "CVE-2023-0908": {"epss_score": 0.00076, "epss_percentile": 0.2318}, "CVE-2023-0909": {"epss_score": 0.00028, "epss_percentile": 0.07335}, "CVE-2023-0910": {"epss_score": 0.00047, "epss_percentile": 0.14704}, "CVE-2023-0911": {"epss_score": 0.00278, "epss_percentile": 0.50853}, "CVE-2023-0912": {"epss_score": 0.00153, "epss_percentile": 0.36584}, "CVE-2023-0913": {"epss_score": 0.00141, "epss_percentile": 0.34829}, "CVE-2023-0914": {"epss_score": 0.00088, "epss_percentile": 0.2576}, "CVE-2023-0915": {"epss_score": 0.00087, "epss_percentile": 0.25613}, "CVE-2023-0916": {"epss_score": 0.008, "epss_percentile": 0.73535}, "CVE-2023-0917": {"epss_score": 0.00065, "epss_percentile": 0.20616}, "CVE-2023-0918": {"epss_score": 0.00103, "epss_percentile": 0.28996}, "CVE-2023-0919": {"epss_score": 0.00077, "epss_percentile": 0.2341}, "CVE-2023-0921": {"epss_score": 0.20025, "epss_percentile": 0.95276}, "CVE-2023-0922": {"epss_score": 0.00215, "epss_percentile": 0.44027}, "CVE-2023-0923": {"epss_score": 0.00137, "epss_percentile": 0.34219}, "CVE-2023-0924": {"epss_score": 0.00221, "epss_percentile": 0.44705}, "CVE-2023-0925": {"epss_score": 0.00198, "epss_percentile": 0.42067}, "CVE-2023-0926": {"epss_score": 0.00087, "epss_percentile": 0.25458}, "CVE-2023-0927": {"epss_score": 0.00277, "epss_percentile": 0.50797}, "CVE-2023-0928": {"epss_score": 0.00204, "epss_percentile": 0.42628}, "CVE-2023-0929": {"epss_score": 0.00185, "epss_percentile": 0.40507}, "CVE-2023-0930": {"epss_score": 0.00567, "epss_percentile": 0.6784}, "CVE-2023-0931": {"epss_score": 0.00108, "epss_percentile": 0.29768}, "CVE-2023-0932": {"epss_score": 0.00376, "epss_percentile": 0.58667}, "CVE-2023-0933": {"epss_score": 0.00318, "epss_percentile": 0.54403}, "CVE-2023-0934": {"epss_score": 0.00076, "epss_percentile": 0.2322}, "CVE-2023-0935": {"epss_score": 0.00851, "epss_percentile": 0.74401}, "CVE-2023-0936": {"epss_score": 0.0004, "epss_percentile": 0.11941}, "CVE-2023-0937": {"epss_score": 0.0024, "epss_percentile": 0.46962}, "CVE-2023-0938": {"epss_score": 0.0009, "epss_percentile": 0.26025}, "CVE-2023-0939": {"epss_score": 0.00135, "epss_percentile": 0.33989}, "CVE-2023-0940": {"epss_score": 0.00288, "epss_percentile": 0.51884}, "CVE-2023-0941": {"epss_score": 0.00251, "epss_percentile": 0.48318}, "CVE-2023-0942": {"epss_score": 0.34698, "epss_percentile": 0.96869}, "CVE-2023-0943": {"epss_score": 0.00849, "epss_percentile": 0.74371}, "CVE-2023-0944": {"epss_score": 0.00047, "epss_percentile": 0.14851}, "CVE-2023-0945": {"epss_score": 0.00075, "epss_percentile": 0.22896}, "CVE-2023-0946": {"epss_score": 0.00056, "epss_percentile": 0.1789}, "CVE-2023-0947": {"epss_score": 0.79336, "epss_percentile": 0.99034}, "CVE-2023-0948": {"epss_score": 0.19296, "epss_percentile": 0.95161}, "CVE-2023-0949": {"epss_score": 0.00159, "epss_percentile": 0.37307}, "CVE-2023-0950": {"epss_score": 0.00059, "epss_percentile": 0.18752}, "CVE-2023-0951": {"epss_score": 0.00286, "epss_percentile": 0.5169}, "CVE-2023-0952": {"epss_score": 0.00211, "epss_percentile": 0.43642}, "CVE-2023-0953": {"epss_score": 0.00359, "epss_percentile": 0.57542}, "CVE-2023-0954": {"epss_score": 0.00084, "epss_percentile": 0.24876}, "CVE-2023-0955": {"epss_score": 0.0067, "epss_percentile": 0.70782}, "CVE-2023-0956": {"epss_score": 0.00592, "epss_percentile": 0.68621}, "CVE-2023-0957": {"epss_score": 0.00265, "epss_percentile": 0.49817}, "CVE-2023-0958": {"epss_score": 0.00224, "epss_percentile": 0.45047}, "CVE-2023-0959": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-0960": {"epss_score": 0.00073, "epss_percentile": 0.22611}, "CVE-2023-0961": {"epss_score": 0.0007, "epss_percentile": 0.21765}, "CVE-2023-0962": {"epss_score": 0.00071, "epss_percentile": 0.22197}, "CVE-2023-0963": {"epss_score": 0.0178, "epss_percentile": 0.82237}, "CVE-2023-0964": {"epss_score": 0.00056, "epss_percentile": 0.1789}, "CVE-2023-0965": {"epss_score": 0.0007, "epss_percentile": 0.21664}, "CVE-2023-0966": {"epss_score": 0.00081, "epss_percentile": 0.24273}, "CVE-2023-0967": {"epss_score": 0.00066, "epss_percentile": 0.2071}, "CVE-2023-0968": {"epss_score": 0.12288, "epss_percentile": 0.93623}, "CVE-2023-0969": {"epss_score": 0.0003, "epss_percentile": 0.08162}, "CVE-2023-0970": {"epss_score": 0.0003, "epss_percentile": 0.08255}, "CVE-2023-0971": {"epss_score": 9e-05, "epss_percentile": 0.00704}, "CVE-2023-0972": {"epss_score": 0.0004, "epss_percentile": 0.11901}, "CVE-2023-0973": {"epss_score": 0.00042, "epss_percentile": 0.12901}, "CVE-2023-0975": {"epss_score": 0.00054, "epss_percentile": 0.17155}, "CVE-2023-0976": {"epss_score": 0.00154, "epss_percentile": 0.36751}, "CVE-2023-0977": {"epss_score": 0.00253, "epss_percentile": 0.48459}, "CVE-2023-0978": {"epss_score": 0.00181, "epss_percentile": 0.40089}, "CVE-2023-0979": {"epss_score": 0.00135, "epss_percentile": 0.33989}, "CVE-2023-0980": {"epss_score": 0.00047, "epss_percentile": 0.14704}, "CVE-2023-0981": {"epss_score": 0.00061, "epss_percentile": 0.1947}, "CVE-2023-0982": {"epss_score": 0.00061, "epss_percentile": 0.1947}, "CVE-2023-0983": {"epss_score": 0.00146, "epss_percentile": 0.3562}, "CVE-2023-0985": {"epss_score": 0.00023, "epss_percentile": 0.05349}, "CVE-2023-0986": {"epss_score": 0.00047, "epss_percentile": 0.14704}, "CVE-2023-0987": {"epss_score": 0.00088, "epss_percentile": 0.25769}, "CVE-2023-0988": {"epss_score": 0.00083, "epss_percentile": 0.24785}, "CVE-2023-0989": {"epss_score": 0.00065, "epss_percentile": 0.20532}, "CVE-2023-0992": {"epss_score": 0.34496, "epss_percentile": 0.9685}, "CVE-2023-0993": {"epss_score": 0.00073, "epss_percentile": 0.22633}, "CVE-2023-0994": {"epss_score": 0.00868, "epss_percentile": 0.74676}, "CVE-2023-0995": {"epss_score": 0.00111, "epss_percentile": 0.30376}, "CVE-2023-0996": {"epss_score": 0.0019, "epss_percentile": 0.41089}, "CVE-2023-0997": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-0998": {"epss_score": 0.00062, "epss_percentile": 0.19632}, "CVE-2023-0999": {"epss_score": 0.00551, "epss_percentile": 0.67374}, "CVE-2023-1000": {"epss_score": 0.0082, "epss_percentile": 0.7388}, "CVE-2023-1001": {"epss_score": 0.00184, "epss_percentile": 0.40406}, "CVE-2023-1002": {"epss_score": 0.00266, "epss_percentile": 0.49885}, "CVE-2023-1003": {"epss_score": 0.00046, "epss_percentile": 0.14093}, "CVE-2023-1004": {"epss_score": 0.00046, "epss_percentile": 0.14093}, "CVE-2023-1005": {"epss_score": 0.00042, "epss_percentile": 0.12698}, "CVE-2023-1006": {"epss_score": 0.00064, "epss_percentile": 0.20318}, "CVE-2023-1007": {"epss_score": 0.00295, "epss_percentile": 0.52484}, "CVE-2023-1008": {"epss_score": 0.00046, "epss_percentile": 0.1429}, "CVE-2023-1009": {"epss_score": 0.03646, "epss_percentile": 0.875}, "CVE-2023-1010": {"epss_score": 0.00089, "epss_percentile": 0.25855}, "CVE-2023-1011": {"epss_score": 0.0009, "epss_percentile": 0.26143}, "CVE-2023-1013": {"epss_score": 0.00113, "epss_percentile": 0.3063}, "CVE-2023-1014": {"epss_score": 0.00102, "epss_percentile": 0.28879}, "CVE-2023-1016": {"epss_score": 0.00052, "epss_percentile": 0.16562}, "CVE-2023-1017": {"epss_score": 0.01225, "epss_percentile": 0.78685}, "CVE-2023-1018": {"epss_score": 0.0099, "epss_percentile": 0.76377}, "CVE-2023-1019": {"epss_score": 0.00092, "epss_percentile": 0.26577}, "CVE-2023-1020": {"epss_score": 0.80433, "epss_percentile": 0.99088}, "CVE-2023-1021": {"epss_score": 0.00076, "epss_percentile": 0.2308}, "CVE-2023-1022": {"epss_score": 0.00091, "epss_percentile": 0.2626}, "CVE-2023-1023": {"epss_score": 0.00091, "epss_percentile": 0.2626}, "CVE-2023-1024": {"epss_score": 0.00098, "epss_percentile": 0.27701}, "CVE-2023-1025": {"epss_score": 0.00122, "epss_percentile": 0.32112}, "CVE-2023-1026": {"epss_score": 0.00176, "epss_percentile": 0.39473}, "CVE-2023-1027": {"epss_score": 0.00093, "epss_percentile": 0.26643}, "CVE-2023-1028": {"epss_score": 0.00099, "epss_percentile": 0.27844}, "CVE-2023-1029": {"epss_score": 0.00092, "epss_percentile": 0.2659}, "CVE-2023-1030": {"epss_score": 0.00126, "epss_percentile": 0.32642}, "CVE-2023-1031": {"epss_score": 0.00887, "epss_percentile": 0.74966}, "CVE-2023-1032": {"epss_score": 0.00012, "epss_percentile": 0.01157}, "CVE-2023-1033": {"epss_score": 0.00369, "epss_percentile": 0.58223}, "CVE-2023-1034": {"epss_score": 0.01462, "epss_percentile": 0.80436}, "CVE-2023-1035": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1036": {"epss_score": 0.001, "epss_percentile": 0.28522}, "CVE-2023-1037": {"epss_score": 0.00072, "epss_percentile": 0.22469}, "CVE-2023-1038": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-1039": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1040": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1041": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2023-1042": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2023-1043": {"epss_score": 0.00067, "epss_percentile": 0.21167}, "CVE-2023-1044": {"epss_score": 0.00083, "epss_percentile": 0.24609}, "CVE-2023-1045": {"epss_score": 0.00071, "epss_percentile": 0.22073}, "CVE-2023-1046": {"epss_score": 0.0007, "epss_percentile": 0.21823}, "CVE-2023-1047": {"epss_score": 0.0014, "epss_percentile": 0.348}, "CVE-2023-1048": {"epss_score": 0.00137, "epss_percentile": 0.34227}, "CVE-2023-1049": {"epss_score": 0.00101, "epss_percentile": 0.28714}, "CVE-2023-1050": {"epss_score": 0.0007, "epss_percentile": 0.21692}, "CVE-2023-1051": {"epss_score": 0.00095, "epss_percentile": 0.2723}, "CVE-2023-1053": {"epss_score": 0.00047, "epss_percentile": 0.14484}, "CVE-2023-1054": {"epss_score": 0.00052, "epss_percentile": 0.16339}, "CVE-2023-1055": {"epss_score": 0.00055, "epss_percentile": 0.17375}, "CVE-2023-1056": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1057": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1058": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1059": {"epss_score": 0.00039, "epss_percentile": 0.11539}, "CVE-2023-1060": {"epss_score": 0.00113, "epss_percentile": 0.3063}, "CVE-2023-1061": {"epss_score": 0.00053, "epss_percentile": 0.16696}, "CVE-2023-1062": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1063": {"epss_score": 0.00071, "epss_percentile": 0.22136}, "CVE-2023-1064": {"epss_score": 0.00248, "epss_percentile": 0.47917}, "CVE-2023-1065": {"epss_score": 0.00107, "epss_percentile": 0.29601}, "CVE-2023-1067": {"epss_score": 2e-05, "epss_percentile": 0.00058}, "CVE-2023-1068": {"epss_score": 0.00092, "epss_percentile": 0.2659}, "CVE-2023-1069": {"epss_score": 0.0019, "epss_percentile": 0.41111}, "CVE-2023-1070": {"epss_score": 0.00104, "epss_percentile": 0.29112}, "CVE-2023-1071": {"epss_score": 0.00052, "epss_percentile": 0.16575}, "CVE-2023-1072": {"epss_score": 0.00261, "epss_percentile": 0.49315}, "CVE-2023-1073": {"epss_score": 0.00016, "epss_percentile": 0.02966}, "CVE-2023-1074": {"epss_score": 0.0001, "epss_percentile": 0.00882}, "CVE-2023-1075": {"epss_score": 8e-05, "epss_percentile": 0.00574}, "CVE-2023-1076": {"epss_score": 8e-05, "epss_percentile": 0.00532}, "CVE-2023-1077": {"epss_score": 0.00018, "epss_percentile": 0.03595}, "CVE-2023-1078": {"epss_score": 0.00019, "epss_percentile": 0.0422}, "CVE-2023-1079": {"epss_score": 0.00016, "epss_percentile": 0.02959}, "CVE-2023-1080": {"epss_score": 0.26356, "epss_percentile": 0.96139}, "CVE-2023-1081": {"epss_score": 0.00097, "epss_percentile": 0.27564}, "CVE-2023-1082": {"epss_score": 0.00531, "epss_percentile": 0.66667}, "CVE-2023-1083": {"epss_score": 0.00444, "epss_percentile": 0.62838}, "CVE-2023-1084": {"epss_score": 0.01186, "epss_percentile": 0.78347}, "CVE-2023-1086": {"epss_score": 0.00717, "epss_percentile": 0.71884}, "CVE-2023-1087": {"epss_score": 0.00083, "epss_percentile": 0.24789}, "CVE-2023-1088": {"epss_score": 0.00091, "epss_percentile": 0.26261}, "CVE-2023-1089": {"epss_score": 0.00083, "epss_percentile": 0.24789}, "CVE-2023-1090": {"epss_score": 0.00105, "epss_percentile": 0.29357}, "CVE-2023-1091": {"epss_score": 0.00104, "epss_percentile": 0.29166}, "CVE-2023-1092": {"epss_score": 0.00128, "epss_percentile": 0.33001}, "CVE-2023-1093": {"epss_score": 0.00083, "epss_percentile": 0.24789}, "CVE-2023-1094": {"epss_score": 0.00654, "epss_percentile": 0.70349}, "CVE-2023-1095": {"epss_score": 0.00013, "epss_percentile": 0.015}, "CVE-2023-1096": {"epss_score": 0.00687, "epss_percentile": 0.71188}, "CVE-2023-1097": {"epss_score": 0.00604, "epss_percentile": 0.68949}, "CVE-2023-1098": {"epss_score": 0.00212, "epss_percentile": 0.43721}, "CVE-2023-1099": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1100": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-1101": {"epss_score": 0.00414, "epss_percentile": 0.61092}, "CVE-2023-1104": {"epss_score": 0.00109, "epss_percentile": 0.29911}, "CVE-2023-1105": {"epss_score": 0.00058, "epss_percentile": 0.18417}, "CVE-2023-1106": {"epss_score": 0.00235, "epss_percentile": 0.46331}, "CVE-2023-1107": {"epss_score": 0.00106, "epss_percentile": 0.29427}, "CVE-2023-1108": {"epss_score": 0.02563, "epss_percentile": 0.8511}, "CVE-2023-1109": {"epss_score": 0.00176, "epss_percentile": 0.39461}, "CVE-2023-1110": {"epss_score": 0.00092, "epss_percentile": 0.26577}, "CVE-2023-1111": {"epss_score": 0.0009, "epss_percentile": 0.26092}, "CVE-2023-1112": {"epss_score": 0.24243, "epss_percentile": 0.95896}, "CVE-2023-1113": {"epss_score": 0.00075, "epss_percentile": 0.23006}, "CVE-2023-1114": {"epss_score": 0.00347, "epss_percentile": 0.56743}, "CVE-2023-1115": {"epss_score": 6e-05, "epss_percentile": 0.00302}, "CVE-2023-1116": {"epss_score": 2e-05, "epss_percentile": 0.00023}, "CVE-2023-1117": {"epss_score": 1e-05, "epss_percentile": 0.00014}, "CVE-2023-1118": {"epss_score": 0.00015, "epss_percentile": 0.02389}, "CVE-2023-1119": {"epss_score": 0.21072, "epss_percentile": 0.9546}, "CVE-2023-1120": {"epss_score": 0.00122, "epss_percentile": 0.32112}, "CVE-2023-1121": {"epss_score": 0.00112, "epss_percentile": 0.30441}, "CVE-2023-1122": {"epss_score": 0.00112, "epss_percentile": 0.30441}, "CVE-2023-1124": {"epss_score": 0.00457, "epss_percentile": 0.63392}, "CVE-2023-1125": {"epss_score": 0.00073, "epss_percentile": 0.22534}, "CVE-2023-1126": {"epss_score": 0.00118, "epss_percentile": 0.31454}, "CVE-2023-1127": {"epss_score": 0.00035, "epss_percentile": 0.10137}, "CVE-2023-1129": {"epss_score": 0.00075, "epss_percentile": 0.22884}, "CVE-2023-1130": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1131": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2023-1132": {"epss_score": 0.00073, "epss_percentile": 0.22587}, "CVE-2023-1133": {"epss_score": 0.86992, "epss_percentile": 0.99407}, "CVE-2023-1134": {"epss_score": 0.00096, "epss_percentile": 0.27246}, "CVE-2023-1135": {"epss_score": 0.00026, "epss_percentile": 0.06586}, "CVE-2023-1136": {"epss_score": 0.00023, "epss_percentile": 0.05357}, "CVE-2023-1137": {"epss_score": 0.00092, "epss_percentile": 0.26512}, "CVE-2023-1138": {"epss_score": 0.00096, "epss_percentile": 0.27443}, "CVE-2023-1139": {"epss_score": 0.01183, "epss_percentile": 0.78322}, "CVE-2023-1140": {"epss_score": 0.00652, "epss_percentile": 0.70309}, "CVE-2023-1141": {"epss_score": 0.00902, "epss_percentile": 0.75195}, "CVE-2023-1142": {"epss_score": 0.00033, "epss_percentile": 0.09199}, "CVE-2023-1143": {"epss_score": 0.00133, "epss_percentile": 0.33683}, "CVE-2023-1144": {"epss_score": 0.00014, "epss_percentile": 0.01851}, "CVE-2023-1145": {"epss_score": 0.00311, "epss_percentile": 0.5381}, "CVE-2023-1146": {"epss_score": 0.00102, "epss_percentile": 0.28839}, "CVE-2023-1147": {"epss_score": 0.00111, "epss_percentile": 0.30376}, "CVE-2023-1148": {"epss_score": 0.00095, "epss_percentile": 0.27237}, "CVE-2023-1149": {"epss_score": 0.00109, "epss_percentile": 0.29965}, "CVE-2023-1150": {"epss_score": 0.00203, "epss_percentile": 0.42556}, "CVE-2023-1151": {"epss_score": 0.00071, "epss_percentile": 0.22136}, "CVE-2023-1152": {"epss_score": 0.0007, "epss_percentile": 0.21692}, "CVE-2023-1153": {"epss_score": 0.00103, "epss_percentile": 0.28998}, "CVE-2023-1154": {"epss_score": 0.00113, "epss_percentile": 0.3063}, "CVE-2023-1155": {"epss_score": 0.00104, "epss_percentile": 0.29152}, "CVE-2023-1156": {"epss_score": 0.00088, "epss_percentile": 0.25769}, "CVE-2023-1157": {"epss_score": 0.00031, "epss_percentile": 0.08331}, "CVE-2023-1158": {"epss_score": 0.00166, "epss_percentile": 0.38238}, "CVE-2023-1159": {"epss_score": 0.00123, "epss_percentile": 0.32335}, "CVE-2023-1160": {"epss_score": 0.00119, "epss_percentile": 0.31538}, "CVE-2023-1161": {"epss_score": 0.00161, "epss_percentile": 0.3756}, "CVE-2023-1162": {"epss_score": 0.41458, "epss_percentile": 0.97275}, "CVE-2023-1163": {"epss_score": 0.00538, "epss_percentile": 0.66926}, "CVE-2023-1164": {"epss_score": 0.00043, "epss_percentile": 0.12967}, "CVE-2023-1165": {"epss_score": 0.0008, "epss_percentile": 0.24204}, "CVE-2023-1166": {"epss_score": 0.00076, "epss_percentile": 0.2308}, "CVE-2023-1167": {"epss_score": 0.00252, "epss_percentile": 0.48408}, "CVE-2023-1168": {"epss_score": 0.01979, "epss_percentile": 0.83132}, "CVE-2023-1169": {"epss_score": 0.00065, "epss_percentile": 0.20552}, "CVE-2023-1170": {"epss_score": 0.00058, "epss_percentile": 0.1837}, "CVE-2023-1172": {"epss_score": 0.00751, "epss_percentile": 0.72643}, "CVE-2023-1174": {"epss_score": 0.0007, "epss_percentile": 0.21653}, "CVE-2023-1175": {"epss_score": 0.00031, "epss_percentile": 0.08321}, "CVE-2023-1176": {"epss_score": 0.00078, "epss_percentile": 0.23754}, "CVE-2023-1177": {"epss_score": 0.93237, "epss_percentile": 0.99786}, "CVE-2023-1178": {"epss_score": 0.02085, "epss_percentile": 0.83545}, "CVE-2023-1179": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2023-1180": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2023-1181": {"epss_score": 0.00074, "epss_percentile": 0.2283}, "CVE-2023-1183": {"epss_score": 0.04978, "epss_percentile": 0.89357}, "CVE-2023-1184": {"epss_score": 0.00081, "epss_percentile": 0.24237}, "CVE-2023-1185": {"epss_score": 0.00081, "epss_percentile": 0.24237}, "CVE-2023-1186": {"epss_score": 0.00051, "epss_percentile": 0.15995}, "CVE-2023-1187": {"epss_score": 0.00042, "epss_percentile": 0.12834}, "CVE-2023-1188": {"epss_score": 0.00051, "epss_percentile": 0.15995}, "CVE-2023-1189": {"epss_score": 0.00043, "epss_percentile": 0.13182}, "CVE-2023-1190": {"epss_score": 0.00056, "epss_percentile": 0.17806}, "CVE-2023-1191": {"epss_score": 0.00194, "epss_percentile": 0.41572}, "CVE-2023-1192": {"epss_score": 0.00026, "epss_percentile": 0.06572}, "CVE-2023-1193": {"epss_score": 0.00067, "epss_percentile": 0.21017}, "CVE-2023-1194": {"epss_score": 0.0005, "epss_percentile": 0.15933}, "CVE-2023-1195": {"epss_score": 0.00016, "epss_percentile": 0.02797}, "CVE-2023-1196": {"epss_score": 0.00334, "epss_percentile": 0.55721}, "CVE-2023-1197": {"epss_score": 0.00062, "epss_percentile": 0.19766}, "CVE-2023-1198": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-1200": {"epss_score": 0.00088, "epss_percentile": 0.25769}, "CVE-2023-1201": {"epss_score": 0.00288, "epss_percentile": 0.51918}, "CVE-2023-1202": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2023-1203": {"epss_score": 0.00344, "epss_percentile": 0.56531}, "CVE-2023-1204": {"epss_score": 0.00304, "epss_percentile": 0.53247}, "CVE-2023-1205": {"epss_score": 0.00101, "epss_percentile": 0.28663}, "CVE-2023-1206": {"epss_score": 0.00039, "epss_percentile": 0.11654}, "CVE-2023-1207": {"epss_score": 0.00215, "epss_percentile": 0.44043}, "CVE-2023-1208": {"epss_score": 0.02427, "epss_percentile": 0.84718}, "CVE-2023-1209": {"epss_score": 0.00378, "epss_percentile": 0.58831}, "CVE-2023-1210": {"epss_score": 0.00069, "epss_percentile": 0.21543}, "CVE-2023-1211": {"epss_score": 0.00323, "epss_percentile": 0.54871}, "CVE-2023-1212": {"epss_score": 0.00102, "epss_percentile": 0.28821}, "CVE-2023-1213": {"epss_score": 0.00123, "epss_percentile": 0.32316}, "CVE-2023-1214": {"epss_score": 0.00155, "epss_percentile": 0.36848}, "CVE-2023-1215": {"epss_score": 0.00124, "epss_percentile": 0.32436}, "CVE-2023-1216": {"epss_score": 0.00091, "epss_percentile": 0.26174}, "CVE-2023-1217": {"epss_score": 0.00041, "epss_percentile": 0.12322}, "CVE-2023-1218": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2023-1219": {"epss_score": 0.00162, "epss_percentile": 0.37741}, "CVE-2023-1220": {"epss_score": 0.00162, "epss_percentile": 0.37741}, "CVE-2023-1221": {"epss_score": 0.00014, "epss_percentile": 0.01982}, "CVE-2023-1222": {"epss_score": 0.00117, "epss_percentile": 0.31216}, "CVE-2023-1223": {"epss_score": 0.00069, "epss_percentile": 0.21558}, "CVE-2023-1224": {"epss_score": 0.00017, "epss_percentile": 0.03096}, "CVE-2023-1225": {"epss_score": 0.00016, "epss_percentile": 0.02951}, "CVE-2023-1226": {"epss_score": 0.00014, "epss_percentile": 0.01882}, "CVE-2023-1227": {"epss_score": 0.00209, "epss_percentile": 0.4338}, "CVE-2023-1228": {"epss_score": 0.00014, "epss_percentile": 0.01917}, "CVE-2023-1229": {"epss_score": 0.00017, "epss_percentile": 0.03311}, "CVE-2023-1230": {"epss_score": 0.00079, "epss_percentile": 0.23856}, "CVE-2023-1231": {"epss_score": 0.00041, "epss_percentile": 0.12458}, "CVE-2023-1232": {"epss_score": 0.00069, "epss_percentile": 0.21558}, "CVE-2023-1233": {"epss_score": 0.00053, "epss_percentile": 0.16889}, "CVE-2023-1234": {"epss_score": 0.00335, "epss_percentile": 0.5586}, "CVE-2023-1235": {"epss_score": 0.00168, "epss_percentile": 0.38443}, "CVE-2023-1236": {"epss_score": 0.00062, "epss_percentile": 0.19562}, "CVE-2023-1237": {"epss_score": 0.00101, "epss_percentile": 0.28619}, "CVE-2023-1238": {"epss_score": 0.00114, "epss_percentile": 0.3085}, "CVE-2023-1239": {"epss_score": 0.0007, "epss_percentile": 0.21867}, "CVE-2023-1240": {"epss_score": 0.0012, "epss_percentile": 0.31726}, "CVE-2023-1241": {"epss_score": 0.0012, "epss_percentile": 0.31726}, "CVE-2023-1242": {"epss_score": 0.0012, "epss_percentile": 0.31726}, "CVE-2023-1243": {"epss_score": 0.0007, "epss_percentile": 0.21867}, "CVE-2023-1244": {"epss_score": 0.00117, "epss_percentile": 0.31223}, "CVE-2023-1245": {"epss_score": 0.00115, "epss_percentile": 0.30992}, "CVE-2023-1246": {"epss_score": 0.00091, "epss_percentile": 0.26234}, "CVE-2023-1248": {"epss_score": 0.00401, "epss_percentile": 0.60206}, "CVE-2023-1249": {"epss_score": 0.00043, "epss_percentile": 0.13335}, "CVE-2023-1250": {"epss_score": 0.00049, "epss_percentile": 0.15361}, "CVE-2023-1251": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-1252": {"epss_score": 0.00018, "epss_percentile": 0.03909}, "CVE-2023-1253": {"epss_score": 0.00067, "epss_percentile": 0.20985}, "CVE-2023-1254": {"epss_score": 0.00088, "epss_percentile": 0.25769}, "CVE-2023-1255": {"epss_score": 0.00048, "epss_percentile": 0.14974}, "CVE-2023-1256": {"epss_score": 0.00151, "epss_percentile": 0.36334}, "CVE-2023-1257": {"epss_score": 0.00109, "epss_percentile": 0.30072}, "CVE-2023-1258": {"epss_score": 0.07575, "epss_percentile": 0.91547}, "CVE-2023-1259": {"epss_score": 0.00095, "epss_percentile": 0.2715}, "CVE-2023-1260": {"epss_score": 0.00058, "epss_percentile": 0.18364}, "CVE-2023-1261": {"epss_score": 0.00072, "epss_percentile": 0.22249}, "CVE-2023-1262": {"epss_score": 0.00072, "epss_percentile": 0.22249}, "CVE-2023-1263": {"epss_score": 0.10375, "epss_percentile": 0.92964}, "CVE-2023-1264": {"epss_score": 0.00032, "epss_percentile": 0.08849}, "CVE-2023-1265": {"epss_score": 0.00033, "epss_percentile": 0.09168}, "CVE-2023-1267": {"epss_score": 0.00143, "epss_percentile": 0.35224}, "CVE-2023-1269": {"epss_score": 0.00446, "epss_percentile": 0.62926}, "CVE-2023-1270": {"epss_score": 0.00064, "epss_percentile": 0.20204}, "CVE-2023-1273": {"epss_score": 0.10801, "epss_percentile": 0.93106}, "CVE-2023-1274": {"epss_score": 0.00401, "epss_percentile": 0.60213}, "CVE-2023-1275": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2023-1276": {"epss_score": 0.00061, "epss_percentile": 0.19391}, "CVE-2023-1277": {"epss_score": 0.00253, "epss_percentile": 0.48456}, "CVE-2023-1278": {"epss_score": 0.00434, "epss_percentile": 0.62286}, "CVE-2023-1279": {"epss_score": 0.00046, "epss_percentile": 0.14138}, "CVE-2023-1281": {"epss_score": 0.00015, "epss_percentile": 0.02248}, "CVE-2023-1282": {"epss_score": 0.00562, "epss_percentile": 0.67686}, "CVE-2023-1283": {"epss_score": 0.00346, "epss_percentile": 0.56633}, "CVE-2023-1285": {"epss_score": 0.00363, "epss_percentile": 0.57831}, "CVE-2023-1286": {"epss_score": 2e-05, "epss_percentile": 0.00028}, "CVE-2023-1287": {"epss_score": 0.0321, "epss_percentile": 0.86648}, "CVE-2023-1288": {"epss_score": 0.00136, "epss_percentile": 0.34126}, "CVE-2023-1289": {"epss_score": 0.00129, "epss_percentile": 0.33128}, "CVE-2023-1290": {"epss_score": 0.00242, "epss_percentile": 0.47338}, "CVE-2023-1291": {"epss_score": 0.00242, "epss_percentile": 0.47338}, "CVE-2023-1292": {"epss_score": 0.00242, "epss_percentile": 0.47338}, "CVE-2023-1293": {"epss_score": 0.00055, "epss_percentile": 0.17407}, "CVE-2023-1294": {"epss_score": 0.00232, "epss_percentile": 0.45942}, "CVE-2023-1295": {"epss_score": 0.0002, "epss_percentile": 0.04674}, "CVE-2023-1296": {"epss_score": 0.00372, "epss_percentile": 0.58441}, "CVE-2023-1297": {"epss_score": 0.00178, "epss_percentile": 0.39721}, "CVE-2023-1298": {"epss_score": 0.00924, "epss_percentile": 0.75515}, "CVE-2023-1299": {"epss_score": 0.002, "epss_percentile": 0.42197}, "CVE-2023-1300": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1301": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1302": {"epss_score": 0.00123, "epss_percentile": 0.32307}, "CVE-2023-1303": {"epss_score": 0.00103, "epss_percentile": 0.28996}, "CVE-2023-1304": {"epss_score": 0.00199, "epss_percentile": 0.42129}, "CVE-2023-1305": {"epss_score": 0.00152, "epss_percentile": 0.36376}, "CVE-2023-1306": {"epss_score": 0.00337, "epss_percentile": 0.56058}, "CVE-2023-1307": {"epss_score": 0.00059, "epss_percentile": 0.1866}, "CVE-2023-1308": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1309": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1310": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1311": {"epss_score": 0.00065, "epss_percentile": 0.20636}, "CVE-2023-1312": {"epss_score": 6e-05, "epss_percentile": 0.00321}, "CVE-2023-1313": {"epss_score": 0.00122, "epss_percentile": 0.32096}, "CVE-2023-1314": {"epss_score": 0.00072, "epss_percentile": 0.22372}, "CVE-2023-1315": {"epss_score": 0.33835, "epss_percentile": 0.96808}, "CVE-2023-1316": {"epss_score": 0.00105, "epss_percentile": 0.29272}, "CVE-2023-1317": {"epss_score": 0.06223, "epss_percentile": 0.90582}, "CVE-2023-1318": {"epss_score": 0.12866, "epss_percentile": 0.93804}, "CVE-2023-1319": {"epss_score": 0.00087, "epss_percentile": 0.25538}, "CVE-2023-1320": {"epss_score": 0.0046, "epss_percentile": 0.63499}, "CVE-2023-1321": {"epss_score": 0.00056, "epss_percentile": 0.1789}, "CVE-2023-1322": {"epss_score": 0.00047, "epss_percentile": 0.14704}, "CVE-2023-1323": {"epss_score": 0.00124, "epss_percentile": 0.32446}, "CVE-2023-1324": {"epss_score": 0.00233, "epss_percentile": 0.45984}, "CVE-2023-1325": {"epss_score": 0.00267, "epss_percentile": 0.49967}, "CVE-2023-1326": {"epss_score": 0.04087, "epss_percentile": 0.88229}, "CVE-2023-1327": {"epss_score": 0.00145, "epss_percentile": 0.35435}, "CVE-2023-1328": {"epss_score": 0.00071, "epss_percentile": 0.22015}, "CVE-2023-1329": {"epss_score": 0.03025, "epss_percentile": 0.86238}, "CVE-2023-1330": {"epss_score": 0.00124, "epss_percentile": 0.32372}, "CVE-2023-1331": {"epss_score": 0.0009, "epss_percentile": 0.26167}, "CVE-2023-1333": {"epss_score": 0.00088, "epss_percentile": 0.25754}, "CVE-2023-1334": {"epss_score": 0.00088, "epss_percentile": 0.25754}, "CVE-2023-1335": {"epss_score": 0.00088, "epss_percentile": 0.25754}, "CVE-2023-1336": {"epss_score": 0.00088, "epss_percentile": 0.25754}, "CVE-2023-1337": {"epss_score": 0.01703, "epss_percentile": 0.81844}, "CVE-2023-1338": {"epss_score": 0.00088, "epss_percentile": 0.25754}, "CVE-2023-1339": {"epss_score": 0.00088, "epss_percentile": 0.25754}, "CVE-2023-1340": {"epss_score": 0.00071, "epss_percentile": 0.22237}, "CVE-2023-1341": {"epss_score": 0.00071, "epss_percentile": 0.22237}, "CVE-2023-1342": {"epss_score": 0.00071, "epss_percentile": 0.22237}, "CVE-2023-1343": {"epss_score": 0.00071, "epss_percentile": 0.22237}, "CVE-2023-1344": {"epss_score": 0.00071, "epss_percentile": 0.22237}, "CVE-2023-1345": {"epss_score": 0.00071, "epss_percentile": 0.22237}, "CVE-2023-1346": {"epss_score": 0.00071, "epss_percentile": 0.22237}, "CVE-2023-1347": {"epss_score": 0.17719, "epss_percentile": 0.94895}, "CVE-2023-1349": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2023-1350": {"epss_score": 0.00451, "epss_percentile": 0.63147}, "CVE-2023-1351": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-1352": {"epss_score": 0.00067, "epss_percentile": 0.20985}, "CVE-2023-1353": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2023-1354": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2023-1355": {"epss_score": 0.00033, "epss_percentile": 0.09122}, "CVE-2023-1356": {"epss_score": 0.00256, "epss_percentile": 0.48838}, "CVE-2023-1357": {"epss_score": 0.00056, "epss_percentile": 0.17881}, "CVE-2023-1358": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-1359": {"epss_score": 0.00077, "epss_percentile": 0.23301}, "CVE-2023-1360": {"epss_score": 0.00057, "epss_percentile": 0.18234}, "CVE-2023-1361": {"epss_score": 0.00087, "epss_percentile": 0.25569}, "CVE-2023-1362": {"epss_score": 0.65799, "epss_percentile": 0.98439}, "CVE-2023-1363": {"epss_score": 0.00088, "epss_percentile": 0.25769}, "CVE-2023-1364": {"epss_score": 0.00059, "epss_percentile": 0.1865}, "CVE-2023-1365": {"epss_score": 0.00063, "epss_percentile": 0.19871}, "CVE-2023-1366": {"epss_score": 0.00071, "epss_percentile": 0.22119}, "CVE-2023-1367": {"epss_score": 0.00062, "epss_percentile": 0.19766}, "CVE-2023-1368": {"epss_score": 0.00067, "epss_percentile": 0.20985}, "CVE-2023-1369": {"epss_score": 0.00061, "epss_percentile": 0.19496}, "CVE-2023-1370": {"epss_score": 0.00014, "epss_percentile": 0.01855}, "CVE-2023-1371": {"epss_score": 0.00222, "epss_percentile": 0.44755}, "CVE-2023-1372": {"epss_score": 0.01213, "epss_percentile": 0.78566}, "CVE-2023-1373": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-1374": {"epss_score": 0.00202, "epss_percentile": 0.42489}, "CVE-2023-1375": {"epss_score": 0.00053, "epss_percentile": 0.16983}, "CVE-2023-1377": {"epss_score": 0.00146, "epss_percentile": 0.3562}, "CVE-2023-1378": {"epss_score": 0.00078, "epss_percentile": 0.23758}, "CVE-2023-1379": {"epss_score": 0.00202, "epss_percentile": 0.42473}, "CVE-2023-1380": {"epss_score": 0.00021, "epss_percentile": 0.04925}, "CVE-2023-1381": {"epss_score": 0.06675, "epss_percentile": 0.90935}, "CVE-2023-1382": {"epss_score": 9e-05, "epss_percentile": 0.006}, "CVE-2023-1383": {"epss_score": 0.00073, "epss_percentile": 0.22504}, "CVE-2023-1384": {"epss_score": 0.00153, "epss_percentile": 0.36642}, "CVE-2023-1385": {"epss_score": 0.0004, "epss_percentile": 0.121}, "CVE-2023-1386": {"epss_score": 0.00016, "epss_percentile": 0.02847}, "CVE-2023-1387": {"epss_score": 0.00307, "epss_percentile": 0.53494}, "CVE-2023-1388": {"epss_score": 0.00443, "epss_percentile": 0.62756}, "CVE-2023-1389": {"epss_score": 0.93807, "epss_percentile": 0.9985}, "CVE-2023-1390": {"epss_score": 0.0064, "epss_percentile": 0.69976}, "CVE-2023-1391": {"epss_score": 0.00069, "epss_percentile": 0.21599}, "CVE-2023-1392": {"epss_score": 0.00103, "epss_percentile": 0.28996}, "CVE-2023-1393": {"epss_score": 0.0006, "epss_percentile": 0.19223}, "CVE-2023-1394": {"epss_score": 0.00067, "epss_percentile": 0.2101}, "CVE-2023-1395": {"epss_score": 0.00088, "epss_percentile": 0.25769}, "CVE-2023-1396": {"epss_score": 0.00088, "epss_percentile": 0.25769}, "CVE-2023-1397": {"epss_score": 0.00088, "epss_percentile": 0.25769}, "CVE-2023-1398": {"epss_score": 0.00123, "epss_percentile": 0.32299}, "CVE-2023-1399": {"epss_score": 0.00693, "epss_percentile": 0.71334}, "CVE-2023-1400": {"epss_score": 0.00156, "epss_percentile": 0.36889}, "CVE-2023-1401": {"epss_score": 0.00096, "epss_percentile": 0.27324}, "CVE-2023-1402": {"epss_score": 0.00241, "epss_percentile": 0.47297}, "CVE-2023-1403": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-1404": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-1405": {"epss_score": 0.00268, "epss_percentile": 0.50067}, "CVE-2023-1406": {"epss_score": 0.0649, "epss_percentile": 0.90794}, "CVE-2023-1407": {"epss_score": 0.00067, "epss_percentile": 0.21106}, "CVE-2023-1408": {"epss_score": 0.20508, "epss_percentile": 0.95358}, "CVE-2023-1409": {"epss_score": 0.00469, "epss_percentile": 0.63932}, "CVE-2023-1410": {"epss_score": 0.01255, "epss_percentile": 0.78924}, "CVE-2023-1412": {"epss_score": 0.00123, "epss_percentile": 0.32251}, "CVE-2023-1413": {"epss_score": 0.00128, "epss_percentile": 0.32988}, "CVE-2023-1414": {"epss_score": 0.00046, "epss_percentile": 0.14299}, "CVE-2023-1415": {"epss_score": 0.00251, "epss_percentile": 0.48318}, "CVE-2023-1416": {"epss_score": 0.00202, "epss_percentile": 0.42473}, "CVE-2023-1417": {"epss_score": 0.00304, "epss_percentile": 0.53289}, "CVE-2023-1418": {"epss_score": 0.00391, "epss_percentile": 0.5957}, "CVE-2023-1419": {"epss_score": 0.00126, "epss_percentile": 0.3264}, "CVE-2023-1420": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-1421": {"epss_score": 0.00928, "epss_percentile": 0.75579}, "CVE-2023-1424": {"epss_score": 0.02516, "epss_percentile": 0.84985}, "CVE-2023-1425": {"epss_score": 0.00291, "epss_percentile": 0.52145}, "CVE-2023-1426": {"epss_score": 0.00335, "epss_percentile": 0.55861}, "CVE-2023-1427": {"epss_score": 0.00138, "epss_percentile": 0.34518}, "CVE-2023-1428": {"epss_score": 0.0002, "epss_percentile": 0.04629}, "CVE-2023-1429": {"epss_score": 2e-05, "epss_percentile": 0.00043}, "CVE-2023-1430": {"epss_score": 0.01192, "epss_percentile": 0.78398}, "CVE-2023-1431": {"epss_score": 0.00227, "epss_percentile": 0.45457}, "CVE-2023-1432": {"epss_score": 0.00053, "epss_percentile": 0.169}, "CVE-2023-1433": {"epss_score": 0.00126, "epss_percentile": 0.32682}, "CVE-2023-1435": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-1436": {"epss_score": 0.00024, "epss_percentile": 0.05847}, "CVE-2023-1437": {"epss_score": 0.00146, "epss_percentile": 0.35636}, "CVE-2023-1439": {"epss_score": 0.00056, "epss_percentile": 0.17768}, "CVE-2023-1440": {"epss_score": 0.00056, "epss_percentile": 0.17768}, "CVE-2023-1441": {"epss_score": 0.00056, "epss_percentile": 0.17768}, "CVE-2023-1442": {"epss_score": 0.00063, "epss_percentile": 0.201}, "CVE-2023-1443": {"epss_score": 0.00153, "epss_percentile": 0.36631}, "CVE-2023-1444": {"epss_score": 0.00098, "epss_percentile": 0.27808}, "CVE-2023-1445": {"epss_score": 0.00034, "epss_percentile": 0.09699}, "CVE-2023-1446": {"epss_score": 0.00034, "epss_percentile": 0.09571}, "CVE-2023-1447": {"epss_score": 0.00089, "epss_percentile": 0.25869}, "CVE-2023-1448": {"epss_score": 0.00033, "epss_percentile": 0.09414}, "CVE-2023-1449": {"epss_score": 0.00034, "epss_percentile": 0.09478}, "CVE-2023-1450": {"epss_score": 0.00026, "epss_percentile": 0.06389}, "CVE-2023-1451": {"epss_score": 0.00026, "epss_percentile": 0.06389}, "CVE-2023-1452": {"epss_score": 0.00033, "epss_percentile": 0.09414}, "CVE-2023-1453": {"epss_score": 0.0003, "epss_percentile": 0.08159}, "CVE-2023-1454": {"epss_score": 0.93335, "epss_percentile": 0.99797}, "CVE-2023-1455": {"epss_score": 0.00047, "epss_percentile": 0.14786}, "CVE-2023-1456": {"epss_score": 0.0019, "epss_percentile": 0.41112}, "CVE-2023-1457": {"epss_score": 0.0021, "epss_percentile": 0.43438}, "CVE-2023-1458": {"epss_score": 0.00662, "epss_percentile": 0.70592}, "CVE-2023-1459": {"epss_score": 0.00056, "epss_percentile": 0.17768}, "CVE-2023-1460": {"epss_score": 0.00051, "epss_percentile": 0.16117}, "CVE-2023-1461": {"epss_score": 0.00056, "epss_percentile": 0.17768}, "CVE-2023-1462": {"epss_score": 0.00037, "epss_percentile": 0.10771}, "CVE-2023-1463": {"epss_score": 0.00028, "epss_percentile": 0.07275}, "CVE-2023-1464": {"epss_score": 0.00059, "epss_percentile": 0.18724}, "CVE-2023-1465": {"epss_score": 0.00099, "epss_percentile": 0.28345}, "CVE-2023-1466": {"epss_score": 0.00047, "epss_percentile": 0.14798}, "CVE-2023-1467": {"epss_score": 0.00076, "epss_percentile": 0.23108}, "CVE-2023-1468": {"epss_score": 0.00047, "epss_percentile": 0.14798}, "CVE-2023-1469": {"epss_score": 0.00155, "epss_percentile": 0.36757}, "CVE-2023-1470": {"epss_score": 0.00117, "epss_percentile": 0.31232}, "CVE-2023-1471": {"epss_score": 0.00218, "epss_percentile": 0.4443}, "CVE-2023-1472": {"epss_score": 0.00061, "epss_percentile": 0.19493}, "CVE-2023-1473": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-1474": {"epss_score": 0.00056, "epss_percentile": 0.17768}, "CVE-2023-1475": {"epss_score": 0.00056, "epss_percentile": 0.17768}, "CVE-2023-1476": {"epss_score": 0.00019, "epss_percentile": 0.04195}, "CVE-2023-1477": {"epss_score": 0.00139, "epss_percentile": 0.34533}, "CVE-2023-1478": {"epss_score": 0.00461, "epss_percentile": 0.63541}, "CVE-2023-1479": {"epss_score": 0.00083, "epss_percentile": 0.2475}, "CVE-2023-1480": {"epss_score": 0.00056, "epss_percentile": 0.17768}, "CVE-2023-1481": {"epss_score": 0.00074, "epss_percentile": 0.22783}, "CVE-2023-1482": {"epss_score": 0.00069, "epss_percentile": 0.21518}, "CVE-2023-1483": {"epss_score": 0.00056, "epss_percentile": 0.17768}, "CVE-2023-1484": {"epss_score": 0.00188, "epss_percentile": 0.40915}, "CVE-2023-1485": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1486": {"epss_score": 0.00031, "epss_percentile": 0.08645}, "CVE-2023-1487": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1488": {"epss_score": 0.00538, "epss_percentile": 0.66946}, "CVE-2023-1489": {"epss_score": 0.00272, "epss_percentile": 0.50367}, "CVE-2023-1490": {"epss_score": 0.00032, "epss_percentile": 0.09075}, "CVE-2023-1491": {"epss_score": 0.00032, "epss_percentile": 0.09075}, "CVE-2023-1492": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1493": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1494": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-1495": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1496": {"epss_score": 0.17247, "epss_percentile": 0.94807}, "CVE-2023-1497": {"epss_score": 0.00096, "epss_percentile": 0.27417}, "CVE-2023-1498": {"epss_score": 0.00152, "epss_percentile": 0.36456}, "CVE-2023-1499": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1500": {"epss_score": 0.00086, "epss_percentile": 0.25321}, "CVE-2023-1501": {"epss_score": 0.00098, "epss_percentile": 0.27796}, "CVE-2023-1502": {"epss_score": 0.00056, "epss_percentile": 0.17715}, "CVE-2023-1503": {"epss_score": 0.00056, "epss_percentile": 0.17715}, "CVE-2023-1504": {"epss_score": 0.00056, "epss_percentile": 0.17715}, "CVE-2023-1505": {"epss_score": 0.00056, "epss_percentile": 0.17724}, "CVE-2023-1506": {"epss_score": 0.0005, "epss_percentile": 0.15926}, "CVE-2023-1507": {"epss_score": 0.00074, "epss_percentile": 0.22738}, "CVE-2023-1508": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-1509": {"epss_score": 0.00872, "epss_percentile": 0.74736}, "CVE-2023-1513": {"epss_score": 0.00012, "epss_percentile": 0.01427}, "CVE-2023-1514": {"epss_score": 0.00071, "epss_percentile": 0.22051}, "CVE-2023-1515": {"epss_score": 2e-05, "epss_percentile": 0.0005}, "CVE-2023-1516": {"epss_score": 0.00041, "epss_percentile": 0.1237}, "CVE-2023-1517": {"epss_score": 2e-05, "epss_percentile": 0.00045}, "CVE-2023-1518": {"epss_score": 0.00066, "epss_percentile": 0.20805}, "CVE-2023-1521": {"epss_score": 0.00237, "epss_percentile": 0.4666}, "CVE-2023-1522": {"epss_score": 0.00354, "epss_percentile": 0.57231}, "CVE-2023-1523": {"epss_score": 0.00124, "epss_percentile": 0.32347}, "CVE-2023-1524": {"epss_score": 0.00183, "epss_percentile": 0.40358}, "CVE-2023-1525": {"epss_score": 0.00105, "epss_percentile": 0.29357}, "CVE-2023-1526": {"epss_score": 0.0009, "epss_percentile": 0.26046}, "CVE-2023-1527": {"epss_score": 0.00078, "epss_percentile": 0.23681}, "CVE-2023-1528": {"epss_score": 0.00405, "epss_percentile": 0.60463}, "CVE-2023-1529": {"epss_score": 0.00279, "epss_percentile": 0.50961}, "CVE-2023-1530": {"epss_score": 0.00359, "epss_percentile": 0.57603}, "CVE-2023-1531": {"epss_score": 0.00434, "epss_percentile": 0.62312}, "CVE-2023-1532": {"epss_score": 0.00467, "epss_percentile": 0.63838}, "CVE-2023-1533": {"epss_score": 0.00328, "epss_percentile": 0.55277}, "CVE-2023-1534": {"epss_score": 0.00315, "epss_percentile": 0.54201}, "CVE-2023-1535": {"epss_score": 0.00085, "epss_percentile": 0.25128}, "CVE-2023-1536": {"epss_score": 0.00085, "epss_percentile": 0.25128}, "CVE-2023-1537": {"epss_score": 0.00044, "epss_percentile": 0.13625}, "CVE-2023-1538": {"epss_score": 0.00105, "epss_percentile": 0.29355}, "CVE-2023-1539": {"epss_score": 0.00053, "epss_percentile": 0.16829}, "CVE-2023-1540": {"epss_score": 0.00105, "epss_percentile": 0.29355}, "CVE-2023-1541": {"epss_score": 0.00049, "epss_percentile": 0.15568}, "CVE-2023-1542": {"epss_score": 0.0008, "epss_percentile": 0.24097}, "CVE-2023-1543": {"epss_score": 0.00085, "epss_percentile": 0.25222}, "CVE-2023-1544": {"epss_score": 0.00061, "epss_percentile": 0.19352}, "CVE-2023-1545": {"epss_score": 0.11323, "epss_percentile": 0.93308}, "CVE-2023-1546": {"epss_score": 0.25305, "epss_percentile": 0.96011}, "CVE-2023-1547": {"epss_score": 0.00077, "epss_percentile": 0.23434}, "CVE-2023-1548": {"epss_score": 0.00021, "epss_percentile": 0.04755}, "CVE-2023-1549": {"epss_score": 0.18983, "epss_percentile": 0.95106}, "CVE-2023-1550": {"epss_score": 0.00099, "epss_percentile": 0.28394}, "CVE-2023-1552": {"epss_score": 0.00047, "epss_percentile": 0.14872}, "CVE-2023-1554": {"epss_score": 0.00083, "epss_percentile": 0.24605}, "CVE-2023-1555": {"epss_score": 0.00062, "epss_percentile": 0.19723}, "CVE-2023-1556": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1557": {"epss_score": 0.00058, "epss_percentile": 0.18432}, "CVE-2023-1558": {"epss_score": 0.00098, "epss_percentile": 0.27796}, "CVE-2023-1559": {"epss_score": 0.00066, "epss_percentile": 0.20883}, "CVE-2023-1560": {"epss_score": 0.00035, "epss_percentile": 0.09924}, "CVE-2023-1561": {"epss_score": 0.00096, "epss_percentile": 0.27417}, "CVE-2023-1562": {"epss_score": 0.00211, "epss_percentile": 0.43629}, "CVE-2023-1563": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1564": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1565": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1566": {"epss_score": 0.00056, "epss_percentile": 0.17712}, "CVE-2023-1567": {"epss_score": 0.00086, "epss_percentile": 0.25321}, "CVE-2023-1568": {"epss_score": 0.00086, "epss_percentile": 0.25321}, "CVE-2023-1569": {"epss_score": 0.00074, "epss_percentile": 0.22738}, "CVE-2023-1570": {"epss_score": 0.00035, "epss_percentile": 0.09947}, "CVE-2023-1571": {"epss_score": 0.00061, "epss_percentile": 0.19317}, "CVE-2023-1572": {"epss_score": 0.00087, "epss_percentile": 0.25591}, "CVE-2023-1573": {"epss_score": 0.00074, "epss_percentile": 0.22783}, "CVE-2023-1574": {"epss_score": 0.00177, "epss_percentile": 0.3955}, "CVE-2023-1575": {"epss_score": 0.00138, "epss_percentile": 0.34423}, "CVE-2023-1577": {"epss_score": 0.0009, "epss_percentile": 0.26132}, "CVE-2023-1578": {"epss_score": 0.8553, "epss_percentile": 0.99338}, "CVE-2023-1579": {"epss_score": 0.00052, "epss_percentile": 0.16508}, "CVE-2023-1580": {"epss_score": 0.00201, "epss_percentile": 0.42281}, "CVE-2023-1582": {"epss_score": 0.00014, "epss_percentile": 0.0193}, "CVE-2023-1583": {"epss_score": 9e-05, "epss_percentile": 0.006}, "CVE-2023-1584": {"epss_score": 0.00291, "epss_percentile": 0.52187}, "CVE-2023-1585": {"epss_score": 0.0006, "epss_percentile": 0.19181}, "CVE-2023-1586": {"epss_score": 0.00111, "epss_percentile": 0.30374}, "CVE-2023-1587": {"epss_score": 0.00053, "epss_percentile": 0.1697}, "CVE-2023-1589": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1590": {"epss_score": 0.00072, "epss_percentile": 0.22325}, "CVE-2023-1591": {"epss_score": 0.00056, "epss_percentile": 0.17724}, "CVE-2023-1592": {"epss_score": 0.00056, "epss_percentile": 0.17724}, "CVE-2023-1593": {"epss_score": 0.00074, "epss_percentile": 0.22738}, "CVE-2023-1594": {"epss_score": 0.00319, "epss_percentile": 0.54554}, "CVE-2023-1595": {"epss_score": 0.00311, "epss_percentile": 0.5393}, "CVE-2023-1596": {"epss_score": 0.00108, "epss_percentile": 0.29775}, "CVE-2023-1597": {"epss_score": 0.00259, "epss_percentile": 0.49066}, "CVE-2023-1602": {"epss_score": 0.00365, "epss_percentile": 0.57976}, "CVE-2023-1603": {"epss_score": 0.00035, "epss_percentile": 0.10085}, "CVE-2023-1604": {"epss_score": 0.00328, "epss_percentile": 0.55297}, "CVE-2023-1605": {"epss_score": 0.00472, "epss_percentile": 0.64044}, "CVE-2023-1606": {"epss_score": 0.00126, "epss_percentile": 0.3273}, "CVE-2023-1607": {"epss_score": 0.0008, "epss_percentile": 0.24049}, "CVE-2023-1608": {"epss_score": 0.0006, "epss_percentile": 0.1916}, "CVE-2023-1609": {"epss_score": 0.0008, "epss_percentile": 0.24073}, "CVE-2023-1610": {"epss_score": 0.0006, "epss_percentile": 0.1916}, "CVE-2023-1611": {"epss_score": 7e-05, "epss_percentile": 0.00411}, "CVE-2023-1612": {"epss_score": 0.00222, "epss_percentile": 0.44841}, "CVE-2023-1613": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1614": {"epss_score": 0.00114, "epss_percentile": 0.30875}, "CVE-2023-1615": {"epss_score": 0.00202, "epss_percentile": 0.42431}, "CVE-2023-1616": {"epss_score": 0.00114, "epss_percentile": 0.30863}, "CVE-2023-1617": {"epss_score": 0.00109, "epss_percentile": 0.29965}, "CVE-2023-1618": {"epss_score": 0.00133, "epss_percentile": 0.3371}, "CVE-2023-1619": {"epss_score": 0.00172, "epss_percentile": 0.39017}, "CVE-2023-1620": {"epss_score": 0.00138, "epss_percentile": 0.34501}, "CVE-2023-1621": {"epss_score": 0.01107, "epss_percentile": 0.77624}, "CVE-2023-1623": {"epss_score": 0.00091, "epss_percentile": 0.26234}, "CVE-2023-1624": {"epss_score": 0.0009, "epss_percentile": 0.26167}, "CVE-2023-1625": {"epss_score": 0.00212, "epss_percentile": 0.43815}, "CVE-2023-1626": {"epss_score": 0.00045, "epss_percentile": 0.13946}, "CVE-2023-1627": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1628": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1629": {"epss_score": 0.00288, "epss_percentile": 0.51916}, "CVE-2023-1630": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1631": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1633": {"epss_score": 0.00024, "epss_percentile": 0.05661}, "CVE-2023-1634": {"epss_score": 0.00083, "epss_percentile": 0.24616}, "CVE-2023-1635": {"epss_score": 0.00095, "epss_percentile": 0.27191}, "CVE-2023-1636": {"epss_score": 0.00074, "epss_percentile": 0.22678}, "CVE-2023-1637": {"epss_score": 0.00016, "epss_percentile": 0.02796}, "CVE-2023-1638": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1639": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1640": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1641": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1642": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1643": {"epss_score": 0.00043, "epss_percentile": 0.13226}, "CVE-2023-1644": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1645": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2023-1646": {"epss_score": 0.00116, "epss_percentile": 0.31171}, "CVE-2023-1647": {"epss_score": 0.0009, "epss_percentile": 0.26101}, "CVE-2023-1649": {"epss_score": 0.00098, "epss_percentile": 0.27667}, "CVE-2023-1650": {"epss_score": 0.44448, "epss_percentile": 0.97437}, "CVE-2023-1651": {"epss_score": 0.00108, "epss_percentile": 0.29783}, "CVE-2023-1652": {"epss_score": 0.00012, "epss_percentile": 0.01165}, "CVE-2023-1654": {"epss_score": 0.00031, "epss_percentile": 0.08516}, "CVE-2023-1655": {"epss_score": 0.00048, "epss_percentile": 0.15181}, "CVE-2023-1656": {"epss_score": 0.00132, "epss_percentile": 0.33592}, "CVE-2023-1660": {"epss_score": 0.00312, "epss_percentile": 0.53968}, "CVE-2023-1661": {"epss_score": 0.0007, "epss_percentile": 0.21648}, "CVE-2023-1663": {"epss_score": 0.00123, "epss_percentile": 0.32258}, "CVE-2023-1664": {"epss_score": 0.00238, "epss_percentile": 0.46809}, "CVE-2023-1665": {"epss_score": 0.00208, "epss_percentile": 0.43282}, "CVE-2023-1666": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1667": {"epss_score": 0.01151, "epss_percentile": 0.78041}, "CVE-2023-1668": {"epss_score": 0.003, "epss_percentile": 0.52937}, "CVE-2023-1669": {"epss_score": 0.18983, "epss_percentile": 0.95106}, "CVE-2023-1670": {"epss_score": 0.00046, "epss_percentile": 0.14123}, "CVE-2023-1671": {"epss_score": 0.94296, "epss_percentile": 0.99939}, "CVE-2023-1672": {"epss_score": 0.00028, "epss_percentile": 0.07339}, "CVE-2023-1674": {"epss_score": 0.00066, "epss_percentile": 0.20818}, "CVE-2023-1675": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1676": {"epss_score": 0.00062, "epss_percentile": 0.19719}, "CVE-2023-1677": {"epss_score": 0.0004, "epss_percentile": 0.12011}, "CVE-2023-1678": {"epss_score": 0.00045, "epss_percentile": 0.13946}, "CVE-2023-1679": {"epss_score": 0.00143, "epss_percentile": 0.35225}, "CVE-2023-1680": {"epss_score": 0.00122, "epss_percentile": 0.32093}, "CVE-2023-1681": {"epss_score": 0.0012, "epss_percentile": 0.31712}, "CVE-2023-1682": {"epss_score": 0.00107, "epss_percentile": 0.29634}, "CVE-2023-1683": {"epss_score": 0.00056, "epss_percentile": 0.17682}, "CVE-2023-1684": {"epss_score": 0.00066, "epss_percentile": 0.20883}, "CVE-2023-1685": {"epss_score": 0.01254, "epss_percentile": 0.78919}, "CVE-2023-1686": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1687": {"epss_score": 0.00105, "epss_percentile": 0.29325}, "CVE-2023-1688": {"epss_score": 0.00105, "epss_percentile": 0.29325}, "CVE-2023-1689": {"epss_score": 0.00074, "epss_percentile": 0.22738}, "CVE-2023-1690": {"epss_score": 0.00074, "epss_percentile": 0.22738}, "CVE-2023-1691": {"epss_score": 0.00076, "epss_percentile": 0.23209}, "CVE-2023-1692": {"epss_score": 0.0009, "epss_percentile": 0.26169}, "CVE-2023-1693": {"epss_score": 0.00092, "epss_percentile": 0.26534}, "CVE-2023-1694": {"epss_score": 0.00092, "epss_percentile": 0.26534}, "CVE-2023-1695": {"epss_score": 0.00065, "epss_percentile": 0.20571}, "CVE-2023-1696": {"epss_score": 0.00094, "epss_percentile": 0.27037}, "CVE-2023-1697": {"epss_score": 0.00102, "epss_percentile": 0.28756}, "CVE-2023-1698": {"epss_score": 0.93841, "epss_percentile": 0.99855}, "CVE-2023-1699": {"epss_score": 0.00089, "epss_percentile": 0.25925}, "CVE-2023-1701": {"epss_score": 3e-05, "epss_percentile": 0.00109}, "CVE-2023-1702": {"epss_score": 2e-05, "epss_percentile": 0.00022}, "CVE-2023-1703": {"epss_score": 3e-05, "epss_percentile": 0.00123}, "CVE-2023-1704": {"epss_score": 2e-05, "epss_percentile": 0.00031}, "CVE-2023-1705": {"epss_score": 5e-05, "epss_percentile": 0.00216}, "CVE-2023-1707": {"epss_score": 0.00406, "epss_percentile": 0.60566}, "CVE-2023-1708": {"epss_score": 0.07459, "epss_percentile": 0.91483}, "CVE-2023-1709": {"epss_score": 0.00127, "epss_percentile": 0.32838}, "CVE-2023-1710": {"epss_score": 0.0206, "epss_percentile": 0.83443}, "CVE-2023-1711": {"epss_score": 0.00089, "epss_percentile": 0.25951}, "CVE-2023-1712": {"epss_score": 0.00355, "epss_percentile": 0.57265}, "CVE-2023-1713": {"epss_score": 0.03851, "epss_percentile": 0.87849}, "CVE-2023-1714": {"epss_score": 0.02444, "epss_percentile": 0.84762}, "CVE-2023-1715": {"epss_score": 0.00067, "epss_percentile": 0.21164}, "CVE-2023-1716": {"epss_score": 0.00606, "epss_percentile": 0.69017}, "CVE-2023-1717": {"epss_score": 0.01789, "epss_percentile": 0.82275}, "CVE-2023-1718": {"epss_score": 0.46454, "epss_percentile": 0.97547}, "CVE-2023-1719": {"epss_score": 0.84768, "epss_percentile": 0.99304}, "CVE-2023-1720": {"epss_score": 0.01018, "epss_percentile": 0.76706}, "CVE-2023-1721": {"epss_score": 0.00078, "epss_percentile": 0.23581}, "CVE-2023-1722": {"epss_score": 0.00062, "epss_percentile": 0.19617}, "CVE-2023-1723": {"epss_score": 0.00102, "epss_percentile": 0.28725}, "CVE-2023-1724": {"epss_score": 0.00057, "epss_percentile": 0.18224}, "CVE-2023-1725": {"epss_score": 0.00103, "epss_percentile": 0.28988}, "CVE-2023-1726": {"epss_score": 0.00097, "epss_percentile": 0.27621}, "CVE-2023-1728": {"epss_score": 0.00333, "epss_percentile": 0.55654}, "CVE-2023-1729": {"epss_score": 0.00058, "epss_percentile": 0.1856}, "CVE-2023-1730": {"epss_score": 0.75117, "epss_percentile": 0.98831}, "CVE-2023-1731": {"epss_score": 0.00208, "epss_percentile": 0.43238}, "CVE-2023-1732": {"epss_score": 0.00192, "epss_percentile": 0.41291}, "CVE-2023-1733": {"epss_score": 0.00738, "epss_percentile": 0.72348}, "CVE-2023-1734": {"epss_score": 0.00075, "epss_percentile": 0.22951}, "CVE-2023-1735": {"epss_score": 0.00056, "epss_percentile": 0.17724}, "CVE-2023-1736": {"epss_score": 0.00031, "epss_percentile": 0.08395}, "CVE-2023-1737": {"epss_score": 0.00056, "epss_percentile": 0.17715}, "CVE-2023-1738": {"epss_score": 0.00056, "epss_percentile": 0.17724}, "CVE-2023-1739": {"epss_score": 0.00082, "epss_percentile": 0.24489}, "CVE-2023-1740": {"epss_score": 0.0006, "epss_percentile": 0.19211}, "CVE-2023-1741": {"epss_score": 0.00048, "epss_percentile": 0.14954}, "CVE-2023-1742": {"epss_score": 0.00072, "epss_percentile": 0.22325}, "CVE-2023-1743": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1744": {"epss_score": 0.00098, "epss_percentile": 0.27796}, "CVE-2023-1745": {"epss_score": 0.00062, "epss_percentile": 0.19681}, "CVE-2023-1746": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1747": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1748": {"epss_score": 0.00111, "epss_percentile": 0.30404}, "CVE-2023-1749": {"epss_score": 0.00191, "epss_percentile": 0.41262}, "CVE-2023-1750": {"epss_score": 0.00268, "epss_percentile": 0.50062}, "CVE-2023-1751": {"epss_score": 0.00289, "epss_percentile": 0.52076}, "CVE-2023-1752": {"epss_score": 0.00165, "epss_percentile": 0.38084}, "CVE-2023-1753": {"epss_score": 0.0008, "epss_percentile": 0.24086}, "CVE-2023-1754": {"epss_score": 0.00068, "epss_percentile": 0.21208}, "CVE-2023-1755": {"epss_score": 0.00113, "epss_percentile": 0.30664}, "CVE-2023-1756": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2023-1757": {"epss_score": 0.0011, "epss_percentile": 0.30177}, "CVE-2023-1758": {"epss_score": 0.00085, "epss_percentile": 0.25128}, "CVE-2023-1759": {"epss_score": 0.00066, "epss_percentile": 0.20933}, "CVE-2023-1760": {"epss_score": 0.00095, "epss_percentile": 0.27078}, "CVE-2023-1761": {"epss_score": 0.00081, "epss_percentile": 0.24327}, "CVE-2023-1762": {"epss_score": 0.00188, "epss_percentile": 0.4088}, "CVE-2023-1763": {"epss_score": 0.00046, "epss_percentile": 0.14191}, "CVE-2023-1764": {"epss_score": 0.00023, "epss_percentile": 0.05421}, "CVE-2023-1765": {"epss_score": 0.00111, "epss_percentile": 0.30403}, "CVE-2023-1766": {"epss_score": 0.00177, "epss_percentile": 0.39621}, "CVE-2023-1767": {"epss_score": 0.03174, "epss_percentile": 0.86556}, "CVE-2023-1768": {"epss_score": 0.00203, "epss_percentile": 0.42532}, "CVE-2023-1769": {"epss_score": 0.00122, "epss_percentile": 0.32093}, "CVE-2023-1770": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1771": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1772": {"epss_score": 0.00083, "epss_percentile": 0.24797}, "CVE-2023-1773": {"epss_score": 0.02102, "epss_percentile": 0.83608}, "CVE-2023-1774": {"epss_score": 0.00191, "epss_percentile": 0.41176}, "CVE-2023-1775": {"epss_score": 0.00221, "epss_percentile": 0.44657}, "CVE-2023-1776": {"epss_score": 0.00593, "epss_percentile": 0.68632}, "CVE-2023-1777": {"epss_score": 0.00289, "epss_percentile": 0.52004}, "CVE-2023-1778": {"epss_score": 0.00263, "epss_percentile": 0.49521}, "CVE-2023-1779": {"epss_score": 0.00063, "epss_percentile": 0.19887}, "CVE-2023-1780": {"epss_score": 0.12604, "epss_percentile": 0.93726}, "CVE-2023-1782": {"epss_score": 0.00341, "epss_percentile": 0.56295}, "CVE-2023-1783": {"epss_score": 0.00077, "epss_percentile": 0.2345}, "CVE-2023-1784": {"epss_score": 0.00122, "epss_percentile": 0.32137}, "CVE-2023-1785": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1786": {"epss_score": 0.0002, "epss_percentile": 0.0462}, "CVE-2023-1787": {"epss_score": 0.00286, "epss_percentile": 0.51701}, "CVE-2023-1788": {"epss_score": 0.00093, "epss_percentile": 0.26702}, "CVE-2023-1789": {"epss_score": 0.00052, "epss_percentile": 0.16352}, "CVE-2023-1790": {"epss_score": 0.0012, "epss_percentile": 0.31712}, "CVE-2023-1791": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-1792": {"epss_score": 0.00078, "epss_percentile": 0.23557}, "CVE-2023-1793": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1794": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1795": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1796": {"epss_score": 0.00088, "epss_percentile": 0.25757}, "CVE-2023-1797": {"epss_score": 0.00098, "epss_percentile": 0.27796}, "CVE-2023-1798": {"epss_score": 0.00095, "epss_percentile": 0.27191}, "CVE-2023-1799": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1800": {"epss_score": 0.25667, "epss_percentile": 0.96054}, "CVE-2023-1801": {"epss_score": 0.00068, "epss_percentile": 0.21308}, "CVE-2023-1802": {"epss_score": 0.00054, "epss_percentile": 0.17244}, "CVE-2023-1803": {"epss_score": 0.00023, "epss_percentile": 0.05345}, "CVE-2023-1804": {"epss_score": 0.00138, "epss_percentile": 0.34384}, "CVE-2023-1805": {"epss_score": 0.00108, "epss_percentile": 0.29847}, "CVE-2023-1806": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-1807": {"epss_score": 0.00122, "epss_percentile": 0.32137}, "CVE-2023-1809": {"epss_score": 0.0023, "epss_percentile": 0.45675}, "CVE-2023-1810": {"epss_score": 0.00943, "epss_percentile": 0.75769}, "CVE-2023-1811": {"epss_score": 0.0066, "epss_percentile": 0.7052}, "CVE-2023-1812": {"epss_score": 0.0087, "epss_percentile": 0.74695}, "CVE-2023-1813": {"epss_score": 0.0005, "epss_percentile": 0.15678}, "CVE-2023-1814": {"epss_score": 0.00068, "epss_percentile": 0.2134}, "CVE-2023-1815": {"epss_score": 0.00689, "epss_percentile": 0.71232}, "CVE-2023-1816": {"epss_score": 0.00454, "epss_percentile": 0.63266}, "CVE-2023-1817": {"epss_score": 0.00116, "epss_percentile": 0.31138}, "CVE-2023-1818": {"epss_score": 0.00689, "epss_percentile": 0.71232}, "CVE-2023-1819": {"epss_score": 0.00296, "epss_percentile": 0.52532}, "CVE-2023-1820": {"epss_score": 0.00823, "epss_percentile": 0.73931}, "CVE-2023-1821": {"epss_score": 0.00379, "epss_percentile": 0.58897}, "CVE-2023-1822": {"epss_score": 0.00646, "epss_percentile": 0.70146}, "CVE-2023-1823": {"epss_score": 0.00068, "epss_percentile": 0.2134}, "CVE-2023-1825": {"epss_score": 0.00286, "epss_percentile": 0.51692}, "CVE-2023-1826": {"epss_score": 0.00832, "epss_percentile": 0.74069}, "CVE-2023-1827": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1829": {"epss_score": 0.00202, "epss_percentile": 0.42451}, "CVE-2023-1831": {"epss_score": 0.00076, "epss_percentile": 0.23126}, "CVE-2023-1832": {"epss_score": 0.00116, "epss_percentile": 0.3116}, "CVE-2023-1833": {"epss_score": 0.00023, "epss_percentile": 0.05345}, "CVE-2023-1834": {"epss_score": 0.00184, "epss_percentile": 0.40405}, "CVE-2023-1835": {"epss_score": 0.18094, "epss_percentile": 0.94956}, "CVE-2023-1836": {"epss_score": 0.01072, "epss_percentile": 0.77282}, "CVE-2023-1837": {"epss_score": 0.00048, "epss_percentile": 0.15002}, "CVE-2023-1838": {"epss_score": 0.00019, "epss_percentile": 0.04109}, "CVE-2023-1839": {"epss_score": 0.00083, "epss_percentile": 0.24605}, "CVE-2023-1840": {"epss_score": 0.00138, "epss_percentile": 0.34423}, "CVE-2023-1841": {"epss_score": 0.00222, "epss_percentile": 0.44725}, "CVE-2023-1843": {"epss_score": 0.00093, "epss_percentile": 0.26629}, "CVE-2023-1844": {"epss_score": 0.00065, "epss_percentile": 0.20552}, "CVE-2023-1845": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1846": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1847": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1848": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1849": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1850": {"epss_score": 0.00072, "epss_percentile": 0.22325}, "CVE-2023-1851": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1852": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1853": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-1854": {"epss_score": 0.00065, "epss_percentile": 0.20592}, "CVE-2023-1855": {"epss_score": 0.00013, "epss_percentile": 0.01689}, "CVE-2023-1856": {"epss_score": 0.00072, "epss_percentile": 0.22325}, "CVE-2023-1857": {"epss_score": 0.00076, "epss_percentile": 0.23124}, "CVE-2023-1858": {"epss_score": 0.00092, "epss_percentile": 0.26524}, "CVE-2023-1859": {"epss_score": 0.0001, "epss_percentile": 0.00834}, "CVE-2023-1860": {"epss_score": 0.00074, "epss_percentile": 0.22738}, "CVE-2023-1861": {"epss_score": 0.00093, "epss_percentile": 0.26661}, "CVE-2023-1862": {"epss_score": 0.00318, "epss_percentile": 0.54439}, "CVE-2023-1863": {"epss_score": 0.00195, "epss_percentile": 0.41671}, "CVE-2023-1864": {"epss_score": 0.00099, "epss_percentile": 0.28363}, "CVE-2023-1865": {"epss_score": 0.00118, "epss_percentile": 0.31463}, "CVE-2023-1866": {"epss_score": 0.00055, "epss_percentile": 0.1763}, "CVE-2023-1867": {"epss_score": 0.00061, "epss_percentile": 0.19525}, "CVE-2023-1868": {"epss_score": 0.00116, "epss_percentile": 0.31098}, "CVE-2023-1869": {"epss_score": 0.00114, "epss_percentile": 0.30747}, "CVE-2023-1870": {"epss_score": 0.00087, "epss_percentile": 0.2547}, "CVE-2023-1871": {"epss_score": 0.00087, "epss_percentile": 0.25467}, "CVE-2023-1872": {"epss_score": 0.00023, "epss_percentile": 0.05605}, "CVE-2023-1873": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-1874": {"epss_score": 0.04462, "epss_percentile": 0.88724}, "CVE-2023-1875": {"epss_score": 0.00088, "epss_percentile": 0.25723}, "CVE-2023-1877": {"epss_score": 0.00631, "epss_percentile": 0.69726}, "CVE-2023-1878": {"epss_score": 0.00085, "epss_percentile": 0.25128}, "CVE-2023-1879": {"epss_score": 0.00077, "epss_percentile": 0.23469}, "CVE-2023-1880": {"epss_score": 0.3857, "epss_percentile": 0.97106}, "CVE-2023-1881": {"epss_score": 0.00116, "epss_percentile": 0.31039}, "CVE-2023-1882": {"epss_score": 0.0011, "epss_percentile": 0.30177}, "CVE-2023-1883": {"epss_score": 0.00331, "epss_percentile": 0.55526}, "CVE-2023-1884": {"epss_score": 0.00141, "epss_percentile": 0.34901}, "CVE-2023-1885": {"epss_score": 0.00081, "epss_percentile": 0.24327}, "CVE-2023-1886": {"epss_score": 0.00242, "epss_percentile": 0.47352}, "CVE-2023-1887": {"epss_score": 0.00104, "epss_percentile": 0.29212}, "CVE-2023-1888": {"epss_score": 0.00258, "epss_percentile": 0.48949}, "CVE-2023-1889": {"epss_score": 0.00072, "epss_percentile": 0.22293}, "CVE-2023-1890": {"epss_score": 0.10824, "epss_percentile": 0.93124}, "CVE-2023-1891": {"epss_score": 0.00099, "epss_percentile": 0.28345}, "CVE-2023-1892": {"epss_score": 0.79594, "epss_percentile": 0.99047}, "CVE-2023-1893": {"epss_score": 0.01843, "epss_percentile": 0.82502}, "CVE-2023-1894": {"epss_score": 0.00045, "epss_percentile": 0.1401}, "CVE-2023-1895": {"epss_score": 0.00135, "epss_percentile": 0.33973}, "CVE-2023-1897": {"epss_score": 0.00038, "epss_percentile": 0.1139}, "CVE-2023-1898": {"epss_score": 0.00076, "epss_percentile": 0.23098}, "CVE-2023-1899": {"epss_score": 0.00035, "epss_percentile": 0.10149}, "CVE-2023-1900": {"epss_score": 0.0003, "epss_percentile": 0.08155}, "CVE-2023-1901": {"epss_score": 0.00209, "epss_percentile": 0.43412}, "CVE-2023-1902": {"epss_score": 0.00169, "epss_percentile": 0.38528}, "CVE-2023-1903": {"epss_score": 0.0019, "epss_percentile": 0.41101}, "CVE-2023-1904": {"epss_score": 0.00248, "epss_percentile": 0.47961}, "CVE-2023-1905": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-1906": {"epss_score": 0.00029, "epss_percentile": 0.07682}, "CVE-2023-1907": {"epss_score": 0.00097, "epss_percentile": 0.27512}, "CVE-2023-1908": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-1909": {"epss_score": 0.00058, "epss_percentile": 0.18367}, "CVE-2023-1910": {"epss_score": 0.00053, "epss_percentile": 0.1679}, "CVE-2023-1911": {"epss_score": 0.00094, "epss_percentile": 0.27012}, "CVE-2023-1912": {"epss_score": 0.01248, "epss_percentile": 0.78869}, "CVE-2023-1913": {"epss_score": 0.00138, "epss_percentile": 0.34423}, "CVE-2023-1915": {"epss_score": 0.00108, "epss_percentile": 0.29847}, "CVE-2023-1916": {"epss_score": 0.00017, "epss_percentile": 0.03095}, "CVE-2023-1917": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-1918": {"epss_score": 0.00078, "epss_percentile": 0.2373}, "CVE-2023-1919": {"epss_score": 0.00078, "epss_percentile": 0.2373}, "CVE-2023-1920": {"epss_score": 0.00078, "epss_percentile": 0.2373}, "CVE-2023-1921": {"epss_score": 0.00078, "epss_percentile": 0.2373}, "CVE-2023-1922": {"epss_score": 0.00078, "epss_percentile": 0.2373}, "CVE-2023-1923": {"epss_score": 0.00078, "epss_percentile": 0.2373}, "CVE-2023-1924": {"epss_score": 0.00078, "epss_percentile": 0.2373}, "CVE-2023-1925": {"epss_score": 0.00078, "epss_percentile": 0.2373}, "CVE-2023-1926": {"epss_score": 0.00078, "epss_percentile": 0.2373}, "CVE-2023-1927": {"epss_score": 0.00078, "epss_percentile": 0.2373}, "CVE-2023-1928": {"epss_score": 0.00083, "epss_percentile": 0.24626}, "CVE-2023-1929": {"epss_score": 0.00108, "epss_percentile": 0.29849}, "CVE-2023-1930": {"epss_score": 0.00083, "epss_percentile": 0.24626}, "CVE-2023-1931": {"epss_score": 0.00083, "epss_percentile": 0.24626}, "CVE-2023-1932": {"epss_score": 0.00236, "epss_percentile": 0.46449}, "CVE-2023-1934": {"epss_score": 0.00062, "epss_percentile": 0.1974}, "CVE-2023-1935": {"epss_score": 0.00019, "epss_percentile": 0.04194}, "CVE-2023-1936": {"epss_score": 0.00271, "epss_percentile": 0.5028}, "CVE-2023-1937": {"epss_score": 0.00066, "epss_percentile": 0.20888}, "CVE-2023-1938": {"epss_score": 0.07128, "epss_percentile": 0.91268}, "CVE-2023-1939": {"epss_score": 0.00188, "epss_percentile": 0.40875}, "CVE-2023-1940": {"epss_score": 0.00059, "epss_percentile": 0.18721}, "CVE-2023-1941": {"epss_score": 0.00066, "epss_percentile": 0.20818}, "CVE-2023-1942": {"epss_score": 0.0009, "epss_percentile": 0.26051}, "CVE-2023-1943": {"epss_score": 0.00095, "epss_percentile": 0.27095}, "CVE-2023-1944": {"epss_score": 0.00026, "epss_percentile": 0.06581}, "CVE-2023-1945": {"epss_score": 0.00129, "epss_percentile": 0.33208}, "CVE-2023-1946": {"epss_score": 0.00056, "epss_percentile": 0.17963}, "CVE-2023-1947": {"epss_score": 0.0015, "epss_percentile": 0.36123}, "CVE-2023-1948": {"epss_score": 0.00086, "epss_percentile": 0.25321}, "CVE-2023-1949": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-1950": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-1951": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1952": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1953": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1954": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1955": {"epss_score": 0.00066, "epss_percentile": 0.20818}, "CVE-2023-1956": {"epss_score": 0.00198, "epss_percentile": 0.42019}, "CVE-2023-1957": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1958": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1959": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1960": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1961": {"epss_score": 0.00074, "epss_percentile": 0.22857}, "CVE-2023-1962": {"epss_score": 0.00065, "epss_percentile": 0.2048}, "CVE-2023-1963": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1964": {"epss_score": 0.00153, "epss_percentile": 0.36544}, "CVE-2023-1965": {"epss_score": 0.00057, "epss_percentile": 0.18234}, "CVE-2023-1966": {"epss_score": 0.00303, "epss_percentile": 0.53168}, "CVE-2023-1967": {"epss_score": 0.00126, "epss_percentile": 0.32639}, "CVE-2023-1968": {"epss_score": 0.00125, "epss_percentile": 0.32473}, "CVE-2023-1969": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-1970": {"epss_score": 0.00087, "epss_percentile": 0.25606}, "CVE-2023-1971": {"epss_score": 0.00052, "epss_percentile": 0.16464}, "CVE-2023-1972": {"epss_score": 0.00045, "epss_percentile": 0.13903}, "CVE-2023-1973": {"epss_score": 0.00727, "epss_percentile": 0.72102}, "CVE-2023-1974": {"epss_score": 0.00422, "epss_percentile": 0.61545}, "CVE-2023-1975": {"epss_score": 0.00077, "epss_percentile": 0.23285}, "CVE-2023-1976": {"epss_score": 0.00067, "epss_percentile": 0.21043}, "CVE-2023-1977": {"epss_score": 0.00277, "epss_percentile": 0.50796}, "CVE-2023-1978": {"epss_score": 0.00926, "epss_percentile": 0.7555}, "CVE-2023-1979": {"epss_score": 0.00423, "epss_percentile": 0.61623}, "CVE-2023-1980": {"epss_score": 0.00073, "epss_percentile": 0.22626}, "CVE-2023-1981": {"epss_score": 0.00015, "epss_percentile": 0.02243}, "CVE-2023-1982": {"epss_score": 0.00047, "epss_percentile": 0.14831}, "CVE-2023-1983": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-1984": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-1985": {"epss_score": 0.00087, "epss_percentile": 0.25477}, "CVE-2023-1986": {"epss_score": 0.0008, "epss_percentile": 0.24049}, "CVE-2023-1987": {"epss_score": 0.00087, "epss_percentile": 0.25477}, "CVE-2023-1988": {"epss_score": 0.00087, "epss_percentile": 0.25591}, "CVE-2023-1989": {"epss_score": 0.00016, "epss_percentile": 0.0261}, "CVE-2023-1990": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2023-1992": {"epss_score": 0.0028, "epss_percentile": 0.51085}, "CVE-2023-1993": {"epss_score": 0.00243, "epss_percentile": 0.47453}, "CVE-2023-1994": {"epss_score": 0.00253, "epss_percentile": 0.48455}, "CVE-2023-1995": {"epss_score": 0.00169, "epss_percentile": 0.38546}, "CVE-2023-1996": {"epss_score": 0.00368, "epss_percentile": 0.58198}, "CVE-2023-1997": {"epss_score": 0.00324, "epss_percentile": 0.54964}, "CVE-2023-1998": {"epss_score": 0.00039, "epss_percentile": 0.11569}, "CVE-2023-1999": {"epss_score": 0.00408, "epss_percentile": 0.60649}, "CVE-2023-20002": {"epss_score": 0.00011, "epss_percentile": 0.00948}, "CVE-2023-20003": {"epss_score": 0.00016, "epss_percentile": 0.02682}, "CVE-2023-20004": {"epss_score": 0.00056, "epss_percentile": 0.17776}, "CVE-2023-20005": {"epss_score": 0.00059, "epss_percentile": 0.18924}, "CVE-2023-20006": {"epss_score": 0.00458, "epss_percentile": 0.63436}, "CVE-2023-20007": {"epss_score": 0.0032, "epss_percentile": 0.54615}, "CVE-2023-20008": {"epss_score": 0.00026, "epss_percentile": 0.06559}, "CVE-2023-20009": {"epss_score": 0.003, "epss_percentile": 0.52912}, "CVE-2023-20010": {"epss_score": 0.00197, "epss_percentile": 0.4183}, "CVE-2023-20011": {"epss_score": 0.00686, "epss_percentile": 0.71161}, "CVE-2023-20012": {"epss_score": 0.00014, "epss_percentile": 0.01913}, "CVE-2023-20013": {"epss_score": 0.00059, "epss_percentile": 0.18871}, "CVE-2023-20014": {"epss_score": 0.00711, "epss_percentile": 0.71744}, "CVE-2023-20015": {"epss_score": 0.00037, "epss_percentile": 0.10858}, "CVE-2023-20016": {"epss_score": 0.00071, "epss_percentile": 0.22233}, "CVE-2023-20017": {"epss_score": 0.00059, "epss_percentile": 0.18871}, "CVE-2023-20018": {"epss_score": 0.00105, "epss_percentile": 0.29347}, "CVE-2023-20019": {"epss_score": 0.00256, "epss_percentile": 0.4874}, "CVE-2023-20020": {"epss_score": 0.00444, "epss_percentile": 0.62831}, "CVE-2023-20021": {"epss_score": 0.00067, "epss_percentile": 0.21162}, "CVE-2023-20022": {"epss_score": 0.00067, "epss_percentile": 0.21162}, "CVE-2023-20023": {"epss_score": 0.00067, "epss_percentile": 0.21162}, "CVE-2023-20024": {"epss_score": 0.00627, "epss_percentile": 0.69629}, "CVE-2023-20025": {"epss_score": 0.00359, "epss_percentile": 0.57617}, "CVE-2023-20026": {"epss_score": 0.00368, "epss_percentile": 0.58189}, "CVE-2023-20027": {"epss_score": 0.00764, "epss_percentile": 0.729}, "CVE-2023-20028": {"epss_score": 0.0012, "epss_percentile": 0.31718}, "CVE-2023-20029": {"epss_score": 0.00024, "epss_percentile": 0.05954}, "CVE-2023-20030": {"epss_score": 0.00287, "epss_percentile": 0.51834}, "CVE-2023-20031": {"epss_score": 0.00017, "epss_percentile": 0.035}, "CVE-2023-20032": {"epss_score": 0.09737, "epss_percentile": 0.92681}, "CVE-2023-20033": {"epss_score": 0.00159, "epss_percentile": 0.37338}, "CVE-2023-20034": {"epss_score": 0.00416, "epss_percentile": 0.61186}, "CVE-2023-20035": {"epss_score": 0.00047, "epss_percentile": 0.14755}, "CVE-2023-20036": {"epss_score": 0.0588, "epss_percentile": 0.90289}, "CVE-2023-20037": {"epss_score": 0.00092, "epss_percentile": 0.26445}, "CVE-2023-20038": {"epss_score": 0.00053, "epss_percentile": 0.16931}, "CVE-2023-20039": {"epss_score": 0.00035, "epss_percentile": 0.10141}, "CVE-2023-20040": {"epss_score": 0.01973, "epss_percentile": 0.83111}, "CVE-2023-20041": {"epss_score": 0.00107, "epss_percentile": 0.29697}, "CVE-2023-20042": {"epss_score": 0.00253, "epss_percentile": 0.48459}, "CVE-2023-20043": {"epss_score": 0.00053, "epss_percentile": 0.16858}, "CVE-2023-20044": {"epss_score": 0.00037, "epss_percentile": 0.10792}, "CVE-2023-20045": {"epss_score": 0.00054, "epss_percentile": 0.1726}, "CVE-2023-20046": {"epss_score": 0.00554, "epss_percentile": 0.67455}, "CVE-2023-20047": {"epss_score": 0.00124, "epss_percentile": 0.32397}, "CVE-2023-20048": {"epss_score": 0.03383, "epss_percentile": 0.87035}, "CVE-2023-20049": {"epss_score": 0.01064, "epss_percentile": 0.77195}, "CVE-2023-20050": {"epss_score": 0.00078, "epss_percentile": 0.23664}, "CVE-2023-20051": {"epss_score": 0.0048, "epss_percentile": 0.64464}, "CVE-2023-20052": {"epss_score": 0.1026, "epss_percentile": 0.92917}, "CVE-2023-20053": {"epss_score": 0.00134, "epss_percentile": 0.33789}, "CVE-2023-20055": {"epss_score": 0.00966, "epss_percentile": 0.76054}, "CVE-2023-20056": {"epss_score": 0.00057, "epss_percentile": 0.18171}, "CVE-2023-20057": {"epss_score": 0.0008, "epss_percentile": 0.24057}, "CVE-2023-20058": {"epss_score": 0.00256, "epss_percentile": 0.4874}, "CVE-2023-20059": {"epss_score": 0.00119, "epss_percentile": 0.31674}, "CVE-2023-20060": {"epss_score": 0.00373, "epss_percentile": 0.58493}, "CVE-2023-20061": {"epss_score": 0.00166, "epss_percentile": 0.38191}, "CVE-2023-20062": {"epss_score": 0.00165, "epss_percentile": 0.38009}, "CVE-2023-20063": {"epss_score": 0.00037, "epss_percentile": 0.10817}, "CVE-2023-20064": {"epss_score": 0.00143, "epss_percentile": 0.35219}, "CVE-2023-20065": {"epss_score": 0.00051, "epss_percentile": 0.16287}, "CVE-2023-20066": {"epss_score": 0.00467, "epss_percentile": 0.63848}, "CVE-2023-20067": {"epss_score": 0.00049, "epss_percentile": 0.15608}, "CVE-2023-20068": {"epss_score": 0.0012, "epss_percentile": 0.3169}, "CVE-2023-20069": {"epss_score": 0.00122, "epss_percentile": 0.32072}, "CVE-2023-20070": {"epss_score": 0.00138, "epss_percentile": 0.3451}, "CVE-2023-20071": {"epss_score": 0.00047, "epss_percentile": 0.14698}, "CVE-2023-20072": {"epss_score": 0.00682, "epss_percentile": 0.71074}, "CVE-2023-20073": {"epss_score": 0.9134, "epss_percentile": 0.99635}, "CVE-2023-20074": {"epss_score": 0.00059, "epss_percentile": 0.18924}, "CVE-2023-20075": {"epss_score": 0.00059, "epss_percentile": 0.1881}, "CVE-2023-20076": {"epss_score": 0.00496, "epss_percentile": 0.65155}, "CVE-2023-20077": {"epss_score": 0.00057, "epss_percentile": 0.18016}, "CVE-2023-20078": {"epss_score": 0.08249, "epss_percentile": 0.91948}, "CVE-2023-20079": {"epss_score": 0.1357, "epss_percentile": 0.93999}, "CVE-2023-20080": {"epss_score": 0.00165, "epss_percentile": 0.38121}, "CVE-2023-20081": {"epss_score": 0.00147, "epss_percentile": 0.35702}, "CVE-2023-20082": {"epss_score": 0.00146, "epss_percentile": 0.35593}, "CVE-2023-20083": {"epss_score": 0.00333, "epss_percentile": 0.55648}, "CVE-2023-20084": {"epss_score": 0.00103, "epss_percentile": 0.28979}, "CVE-2023-20085": {"epss_score": 0.00184, "epss_percentile": 0.40426}, "CVE-2023-20086": {"epss_score": 0.00545, "epss_percentile": 0.67176}, "CVE-2023-20087": {"epss_score": 0.00057, "epss_percentile": 0.18016}, "CVE-2023-20088": {"epss_score": 0.00492, "epss_percentile": 0.64989}, "CVE-2023-20089": {"epss_score": 0.00129, "epss_percentile": 0.33084}, "CVE-2023-20090": {"epss_score": 0.0005, "epss_percentile": 0.15936}, "CVE-2023-20091": {"epss_score": 0.00069, "epss_percentile": 0.2156}, "CVE-2023-20092": {"epss_score": 0.0007, "epss_percentile": 0.21683}, "CVE-2023-20093": {"epss_score": 0.00082, "epss_percentile": 0.24466}, "CVE-2023-20094": {"epss_score": 0.00089, "epss_percentile": 0.25926}, "CVE-2023-20095": {"epss_score": 0.00159, "epss_percentile": 0.37359}, "CVE-2023-20096": {"epss_score": 0.00176, "epss_percentile": 0.39416}, "CVE-2023-20097": {"epss_score": 0.00065, "epss_percentile": 0.20546}, "CVE-2023-20098": {"epss_score": 0.00067, "epss_percentile": 0.21082}, "CVE-2023-20100": {"epss_score": 0.00613, "epss_percentile": 0.69253}, "CVE-2023-20101": {"epss_score": 0.00715, "epss_percentile": 0.71831}, "CVE-2023-20102": {"epss_score": 0.02357, "epss_percentile": 0.84485}, "CVE-2023-20103": {"epss_score": 0.00173, "epss_percentile": 0.39115}, "CVE-2023-20104": {"epss_score": 0.00168, "epss_percentile": 0.38473}, "CVE-2023-20105": {"epss_score": 0.00097, "epss_percentile": 0.27459}, "CVE-2023-20106": {"epss_score": 0.00112, "epss_percentile": 0.30496}, "CVE-2023-20107": {"epss_score": 0.00404, "epss_percentile": 0.60415}, "CVE-2023-20108": {"epss_score": 0.00241, "epss_percentile": 0.47299}, "CVE-2023-20109": {"epss_score": 0.00576, "epss_percentile": 0.68148}, "CVE-2023-20110": {"epss_score": 0.00186, "epss_percentile": 0.40647}, "CVE-2023-20111": {"epss_score": 0.0015, "epss_percentile": 0.36128}, "CVE-2023-20112": {"epss_score": 0.00055, "epss_percentile": 0.17654}, "CVE-2023-20113": {"epss_score": 0.00226, "epss_percentile": 0.45265}, "CVE-2023-20114": {"epss_score": 0.00164, "epss_percentile": 0.37903}, "CVE-2023-20115": {"epss_score": 0.00308, "epss_percentile": 0.53582}, "CVE-2023-20116": {"epss_score": 0.00326, "epss_percentile": 0.55073}, "CVE-2023-20117": {"epss_score": 0.13637, "epss_percentile": 0.94019}, "CVE-2023-20118": {"epss_score": 0.03364, "epss_percentile": 0.86997}, "CVE-2023-20119": {"epss_score": 0.00081, "epss_percentile": 0.24266}, "CVE-2023-20120": {"epss_score": 0.0012, "epss_percentile": 0.31718}, "CVE-2023-20121": {"epss_score": 0.00077, "epss_percentile": 0.23543}, "CVE-2023-20122": {"epss_score": 0.00068, "epss_percentile": 0.21313}, "CVE-2023-20123": {"epss_score": 0.00019, "epss_percentile": 0.04077}, "CVE-2023-20124": {"epss_score": 0.00079, "epss_percentile": 0.23821}, "CVE-2023-20125": {"epss_score": 0.00326, "epss_percentile": 0.55038}, "CVE-2023-20126": {"epss_score": 0.70188, "epss_percentile": 0.98621}, "CVE-2023-20127": {"epss_score": 0.00175, "epss_percentile": 0.39287}, "CVE-2023-20128": {"epss_score": 0.13637, "epss_percentile": 0.94019}, "CVE-2023-20129": {"epss_score": 0.00175, "epss_percentile": 0.39287}, "CVE-2023-20130": {"epss_score": 0.00072, "epss_percentile": 0.22403}, "CVE-2023-20131": {"epss_score": 0.00148, "epss_percentile": 0.35894}, "CVE-2023-20132": {"epss_score": 0.00164, "epss_percentile": 0.37911}, "CVE-2023-20133": {"epss_score": 0.00108, "epss_percentile": 0.29812}, "CVE-2023-20134": {"epss_score": 0.00115, "epss_percentile": 0.3101}, "CVE-2023-20135": {"epss_score": 0.00016, "epss_percentile": 0.02682}, "CVE-2023-20136": {"epss_score": 0.001, "epss_percentile": 0.28433}, "CVE-2023-20137": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20138": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20139": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20140": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20141": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20142": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20143": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20144": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20145": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20146": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20147": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20148": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20149": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20150": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20151": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-20152": {"epss_score": 0.00067, "epss_percentile": 0.21162}, "CVE-2023-20153": {"epss_score": 0.00067, "epss_percentile": 0.21162}, "CVE-2023-20154": {"epss_score": 0.00074, "epss_percentile": 0.22709}, "CVE-2023-20155": {"epss_score": 0.00386, "epss_percentile": 0.59268}, "CVE-2023-20156": {"epss_score": 0.00305, "epss_percentile": 0.53356}, "CVE-2023-20157": {"epss_score": 0.00305, "epss_percentile": 0.53356}, "CVE-2023-20158": {"epss_score": 0.00305, "epss_percentile": 0.53356}, "CVE-2023-20159": {"epss_score": 0.03336, "epss_percentile": 0.86936}, "CVE-2023-20160": {"epss_score": 0.03336, "epss_percentile": 0.86936}, "CVE-2023-20161": {"epss_score": 0.03336, "epss_percentile": 0.86936}, "CVE-2023-20162": {"epss_score": 0.00305, "epss_percentile": 0.53356}, "CVE-2023-20163": {"epss_score": 0.00383, "epss_percentile": 0.59084}, "CVE-2023-20164": {"epss_score": 0.00383, "epss_percentile": 0.59084}, "CVE-2023-20166": {"epss_score": 0.00075, "epss_percentile": 0.22902}, "CVE-2023-20167": {"epss_score": 0.00193, "epss_percentile": 0.41417}, "CVE-2023-20168": {"epss_score": 0.00108, "epss_percentile": 0.29821}, "CVE-2023-20169": {"epss_score": 0.00067, "epss_percentile": 0.21016}, "CVE-2023-20170": {"epss_score": 0.00033, "epss_percentile": 0.09391}, "CVE-2023-20171": {"epss_score": 0.00146, "epss_percentile": 0.35607}, "CVE-2023-20172": {"epss_score": 0.00116, "epss_percentile": 0.31068}, "CVE-2023-20173": {"epss_score": 0.00086, "epss_percentile": 0.25384}, "CVE-2023-20174": {"epss_score": 0.00064, "epss_percentile": 0.20302}, "CVE-2023-20175": {"epss_score": 0.00096, "epss_percentile": 0.27444}, "CVE-2023-20176": {"epss_score": 0.00123, "epss_percentile": 0.32307}, "CVE-2023-20177": {"epss_score": 9e-05, "epss_percentile": 0.00606}, "CVE-2023-20178": {"epss_score": 0.27048, "epss_percentile": 0.96201}, "CVE-2023-20179": {"epss_score": 0.00081, "epss_percentile": 0.24296}, "CVE-2023-20180": {"epss_score": 0.00226, "epss_percentile": 0.45247}, "CVE-2023-20181": {"epss_score": 0.00137, "epss_percentile": 0.34331}, "CVE-2023-20182": {"epss_score": 0.00207, "epss_percentile": 0.43133}, "CVE-2023-20183": {"epss_score": 0.00154, "epss_percentile": 0.36695}, "CVE-2023-20184": {"epss_score": 0.00123, "epss_percentile": 0.32331}, "CVE-2023-20185": {"epss_score": 0.00139, "epss_percentile": 0.34644}, "CVE-2023-20186": {"epss_score": 0.00111, "epss_percentile": 0.30247}, "CVE-2023-20187": {"epss_score": 0.00376, "epss_percentile": 0.58651}, "CVE-2023-20188": {"epss_score": 0.00065, "epss_percentile": 0.20488}, "CVE-2023-20189": {"epss_score": 0.04304, "epss_percentile": 0.88519}, "CVE-2023-20190": {"epss_score": 0.00047, "epss_percentile": 0.14759}, "CVE-2023-20191": {"epss_score": 0.00043, "epss_percentile": 0.13008}, "CVE-2023-20192": {"epss_score": 0.00206, "epss_percentile": 0.43072}, "CVE-2023-20193": {"epss_score": 0.00028, "epss_percentile": 0.07291}, "CVE-2023-20194": {"epss_score": 0.00061, "epss_percentile": 0.19498}, "CVE-2023-20195": {"epss_score": 0.00631, "epss_percentile": 0.69732}, "CVE-2023-20196": {"epss_score": 0.00423, "epss_percentile": 0.61599}, "CVE-2023-20197": {"epss_score": 0.00438, "epss_percentile": 0.62574}, "CVE-2023-20198": {"epss_score": 0.94069, "epss_percentile": 0.99897}, "CVE-2023-20199": {"epss_score": 0.00014, "epss_percentile": 0.01932}, "CVE-2023-20200": {"epss_score": 0.00529, "epss_percentile": 0.66588}, "CVE-2023-20201": {"epss_score": 0.0005, "epss_percentile": 0.15868}, "CVE-2023-20202": {"epss_score": 0.00078, "epss_percentile": 0.23662}, "CVE-2023-20203": {"epss_score": 0.00088, "epss_percentile": 0.25733}, "CVE-2023-20204": {"epss_score": 0.0012, "epss_percentile": 0.31718}, "CVE-2023-20205": {"epss_score": 0.00088, "epss_percentile": 0.25733}, "CVE-2023-20206": {"epss_score": 0.00088, "epss_percentile": 0.25747}, "CVE-2023-20207": {"epss_score": 0.00055, "epss_percentile": 0.17629}, "CVE-2023-20208": {"epss_score": 0.00047, "epss_percentile": 0.14634}, "CVE-2023-20209": {"epss_score": 0.30117, "epss_percentile": 0.96512}, "CVE-2023-20210": {"epss_score": 0.00021, "epss_percentile": 0.04751}, "CVE-2023-20211": {"epss_score": 0.0008, "epss_percentile": 0.24157}, "CVE-2023-20212": {"epss_score": 0.00802, "epss_percentile": 0.73588}, "CVE-2023-20213": {"epss_score": 0.00035, "epss_percentile": 0.10068}, "CVE-2023-20214": {"epss_score": 0.0015, "epss_percentile": 0.36115}, "CVE-2023-20215": {"epss_score": 0.00065, "epss_percentile": 0.20537}, "CVE-2023-20216": {"epss_score": 0.00012, "epss_percentile": 0.01204}, "CVE-2023-20217": {"epss_score": 0.0005, "epss_percentile": 0.15732}, "CVE-2023-20218": {"epss_score": 0.00102, "epss_percentile": 0.2887}, "CVE-2023-20219": {"epss_score": 0.00448, "epss_percentile": 0.63008}, "CVE-2023-20220": {"epss_score": 0.00366, "epss_percentile": 0.58054}, "CVE-2023-20221": {"epss_score": 0.00392, "epss_percentile": 0.59679}, "CVE-2023-20222": {"epss_score": 0.00072, "epss_percentile": 0.22455}, "CVE-2023-20223": {"epss_score": 0.00169, "epss_percentile": 0.38641}, "CVE-2023-20224": {"epss_score": 0.00046, "epss_percentile": 0.14193}, "CVE-2023-20226": {"epss_score": 0.00178, "epss_percentile": 0.39665}, "CVE-2023-20227": {"epss_score": 0.0047, "epss_percentile": 0.63971}, "CVE-2023-20228": {"epss_score": 0.00079, "epss_percentile": 0.23911}, "CVE-2023-20229": {"epss_score": 0.0008, "epss_percentile": 0.24055}, "CVE-2023-20230": {"epss_score": 0.00186, "epss_percentile": 0.4066}, "CVE-2023-20231": {"epss_score": 0.00636, "epss_percentile": 0.69873}, "CVE-2023-20232": {"epss_score": 0.00097, "epss_percentile": 0.2751}, "CVE-2023-20233": {"epss_score": 0.00118, "epss_percentile": 0.31386}, "CVE-2023-20234": {"epss_score": 0.00019, "epss_percentile": 0.04269}, "CVE-2023-20235": {"epss_score": 0.00177, "epss_percentile": 0.39621}, "CVE-2023-20236": {"epss_score": 0.00015, "epss_percentile": 0.02296}, "CVE-2023-20237": {"epss_score": 0.00051, "epss_percentile": 0.16051}, "CVE-2023-20238": {"epss_score": 0.30707, "epss_percentile": 0.96562}, "CVE-2023-20240": {"epss_score": 0.00034, "epss_percentile": 0.09654}, "CVE-2023-20241": {"epss_score": 0.00034, "epss_percentile": 0.09654}, "CVE-2023-20242": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2023-20243": {"epss_score": 0.00377, "epss_percentile": 0.58694}, "CVE-2023-20244": {"epss_score": 0.00166, "epss_percentile": 0.38193}, "CVE-2023-20245": {"epss_score": 0.00032, "epss_percentile": 0.09115}, "CVE-2023-20246": {"epss_score": 0.00065, "epss_percentile": 0.20532}, "CVE-2023-20247": {"epss_score": 0.00026, "epss_percentile": 0.06589}, "CVE-2023-20248": {"epss_score": 0.00104, "epss_percentile": 0.29195}, "CVE-2023-20249": {"epss_score": 0.00104, "epss_percentile": 0.29195}, "CVE-2023-20250": {"epss_score": 0.00244, "epss_percentile": 0.47583}, "CVE-2023-20251": {"epss_score": 0.00098, "epss_percentile": 0.2771}, "CVE-2023-20252": {"epss_score": 0.01011, "epss_percentile": 0.7661}, "CVE-2023-20253": {"epss_score": 5e-05, "epss_percentile": 0.00232}, "CVE-2023-20254": {"epss_score": 0.00322, "epss_percentile": 0.54793}, "CVE-2023-20255": {"epss_score": 0.00074, "epss_percentile": 0.22751}, "CVE-2023-20256": {"epss_score": 0.0003, "epss_percentile": 0.08164}, "CVE-2023-20257": {"epss_score": 0.0006, "epss_percentile": 0.19164}, "CVE-2023-20258": {"epss_score": 0.00048, "epss_percentile": 0.15148}, "CVE-2023-20259": {"epss_score": 0.00143, "epss_percentile": 0.35107}, "CVE-2023-20260": {"epss_score": 0.00021, "epss_percentile": 0.04775}, "CVE-2023-20261": {"epss_score": 0.00124, "epss_percentile": 0.32346}, "CVE-2023-20262": {"epss_score": 0.00322, "epss_percentile": 0.54861}, "CVE-2023-20263": {"epss_score": 0.00364, "epss_percentile": 0.57949}, "CVE-2023-20264": {"epss_score": 0.00069, "epss_percentile": 0.21632}, "CVE-2023-20265": {"epss_score": 0.00077, "epss_percentile": 0.23288}, "CVE-2023-20266": {"epss_score": 0.00058, "epss_percentile": 0.18307}, "CVE-2023-20267": {"epss_score": 0.00011, "epss_percentile": 0.0108}, "CVE-2023-20268": {"epss_score": 0.00026, "epss_percentile": 0.06415}, "CVE-2023-20269": {"epss_score": 0.0088, "epss_percentile": 0.7485}, "CVE-2023-20270": {"epss_score": 0.00014, "epss_percentile": 0.0183}, "CVE-2023-20271": {"epss_score": 0.00087, "epss_percentile": 0.25606}, "CVE-2023-20272": {"epss_score": 0.00302, "epss_percentile": 0.53126}, "CVE-2023-20273": {"epss_score": 0.92502, "epss_percentile": 0.99721}, "CVE-2023-20274": {"epss_score": 0.00035, "epss_percentile": 0.09991}, "CVE-2023-20275": {"epss_score": 0.0004, "epss_percentile": 0.1208}, "CVE-2023-20507": {"epss_score": 0.00034, "epss_percentile": 0.09449}, "CVE-2023-20508": {"epss_score": 0.00025, "epss_percentile": 0.06119}, "CVE-2023-20509": {"epss_score": 0.00044, "epss_percentile": 0.13614}, "CVE-2023-20510": {"epss_score": 0.00034, "epss_percentile": 0.09623}, "CVE-2023-20512": {"epss_score": 0.00053, "epss_percentile": 0.16852}, "CVE-2023-20513": {"epss_score": 0.00092, "epss_percentile": 0.26562}, "CVE-2023-20515": {"epss_score": 0.00033, "epss_percentile": 0.09187}, "CVE-2023-20516": {"epss_score": 0.00042, "epss_percentile": 0.12886}, "CVE-2023-20518": {"epss_score": 0.00052, "epss_percentile": 0.16381}, "CVE-2023-20519": {"epss_score": 0.00071, "epss_percentile": 0.22184}, "CVE-2023-20520": {"epss_score": 0.00312, "epss_percentile": 0.53986}, "CVE-2023-20521": {"epss_score": 0.00037, "epss_percentile": 0.1074}, "CVE-2023-20522": {"epss_score": 0.00183, "epss_percentile": 0.40327}, "CVE-2023-20523": {"epss_score": 0.00075, "epss_percentile": 0.23039}, "CVE-2023-20524": {"epss_score": 0.00147, "epss_percentile": 0.35782}, "CVE-2023-20525": {"epss_score": 0.00147, "epss_percentile": 0.35682}, "CVE-2023-20526": {"epss_score": 0.0004, "epss_percentile": 0.12014}, "CVE-2023-20527": {"epss_score": 0.00147, "epss_percentile": 0.35682}, "CVE-2023-20528": {"epss_score": 0.00083, "epss_percentile": 0.24785}, "CVE-2023-20529": {"epss_score": 0.00246, "epss_percentile": 0.47807}, "CVE-2023-20530": {"epss_score": 0.00183, "epss_percentile": 0.40327}, "CVE-2023-20531": {"epss_score": 0.00246, "epss_percentile": 0.47807}, "CVE-2023-20532": {"epss_score": 0.00093, "epss_percentile": 0.26668}, "CVE-2023-20533": {"epss_score": 0.00033, "epss_percentile": 0.09125}, "CVE-2023-20555": {"epss_score": 0.00054, "epss_percentile": 0.17211}, "CVE-2023-20556": {"epss_score": 0.00043, "epss_percentile": 0.1331}, "CVE-2023-20558": {"epss_score": 0.00313, "epss_percentile": 0.54031}, "CVE-2023-20559": {"epss_score": 0.00313, "epss_percentile": 0.54031}, "CVE-2023-20560": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2023-20561": {"epss_score": 0.00043, "epss_percentile": 0.1331}, "CVE-2023-20562": {"epss_score": 0.08428, "epss_percentile": 0.92047}, "CVE-2023-20563": {"epss_score": 0.00131, "epss_percentile": 0.33487}, "CVE-2023-20564": {"epss_score": 0.0003, "epss_percentile": 0.08237}, "CVE-2023-20565": {"epss_score": 0.00131, "epss_percentile": 0.33487}, "CVE-2023-20566": {"epss_score": 0.00049, "epss_percentile": 0.15355}, "CVE-2023-20567": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2023-20568": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2023-20569": {"epss_score": 0.00633, "epss_percentile": 0.69761}, "CVE-2023-20570": {"epss_score": 0.0003, "epss_percentile": 0.08257}, "CVE-2023-20571": {"epss_score": 0.00391, "epss_percentile": 0.59569}, "CVE-2023-20573": {"epss_score": 0.00089, "epss_percentile": 0.25928}, "CVE-2023-20575": {"epss_score": 0.00332, "epss_percentile": 0.55604}, "CVE-2023-20578": {"epss_score": 0.00076, "epss_percentile": 0.23148}, "CVE-2023-20579": {"epss_score": 7e-05, "epss_percentile": 0.00395}, "CVE-2023-20581": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2023-20582": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2023-20583": {"epss_score": 0.00113, "epss_percentile": 0.30619}, "CVE-2023-20584": {"epss_score": 0.00015, "epss_percentile": 0.02125}, "CVE-2023-20586": {"epss_score": 0.0023, "epss_percentile": 0.45687}, "CVE-2023-20587": {"epss_score": 0.00035, "epss_percentile": 0.09939}, "CVE-2023-20588": {"epss_score": 0.07781, "epss_percentile": 0.91678}, "CVE-2023-20589": {"epss_score": 0.00108, "epss_percentile": 0.29869}, "CVE-2023-20591": {"epss_score": 0.00335, "epss_percentile": 0.55811}, "CVE-2023-20592": {"epss_score": 0.0036, "epss_percentile": 0.57632}, "CVE-2023-20593": {"epss_score": 0.05876, "epss_percentile": 0.90286}, "CVE-2023-20594": {"epss_score": 0.00053, "epss_percentile": 0.16955}, "CVE-2023-20596": {"epss_score": 0.0053, "epss_percentile": 0.6662}, "CVE-2023-20597": {"epss_score": 0.00082, "epss_percentile": 0.24499}, "CVE-2023-20598": {"epss_score": 0.01465, "epss_percentile": 0.80456}, "CVE-2023-20599": {"epss_score": 0.00019, "epss_percentile": 0.04223}, "CVE-2023-20602": {"epss_score": 0.00027, "epss_percentile": 0.06807}, "CVE-2023-20604": {"epss_score": 0.00028, "epss_percentile": 0.07363}, "CVE-2023-20605": {"epss_score": 0.00037, "epss_percentile": 0.10924}, "CVE-2023-20606": {"epss_score": 0.00037, "epss_percentile": 0.10769}, "CVE-2023-20607": {"epss_score": 0.00035, "epss_percentile": 0.1012}, "CVE-2023-20608": {"epss_score": 0.00044, "epss_percentile": 0.13553}, "CVE-2023-20609": {"epss_score": 0.00043, "epss_percentile": 0.13277}, "CVE-2023-20610": {"epss_score": 0.00065, "epss_percentile": 0.20583}, "CVE-2023-20611": {"epss_score": 0.0007, "epss_percentile": 0.21682}, "CVE-2023-20612": {"epss_score": 0.00048, "epss_percentile": 0.15103}, "CVE-2023-20613": {"epss_score": 0.00048, "epss_percentile": 0.15103}, "CVE-2023-20614": {"epss_score": 0.00048, "epss_percentile": 0.15103}, "CVE-2023-20615": {"epss_score": 0.00048, "epss_percentile": 0.15103}, "CVE-2023-20616": {"epss_score": 0.00085, "epss_percentile": 0.25177}, "CVE-2023-20618": {"epss_score": 0.00051, "epss_percentile": 0.15983}, "CVE-2023-20619": {"epss_score": 0.00051, "epss_percentile": 0.15983}, "CVE-2023-20620": {"epss_score": 0.00013, "epss_percentile": 0.01671}, "CVE-2023-20621": {"epss_score": 0.00015, "epss_percentile": 0.02131}, "CVE-2023-20623": {"epss_score": 0.0002, "epss_percentile": 0.04596}, "CVE-2023-20624": {"epss_score": 0.00026, "epss_percentile": 0.06529}, "CVE-2023-20625": {"epss_score": 0.0003, "epss_percentile": 0.08259}, "CVE-2023-20626": {"epss_score": 0.00019, "epss_percentile": 0.04293}, "CVE-2023-20627": {"epss_score": 0.00026, "epss_percentile": 0.06529}, "CVE-2023-20628": {"epss_score": 0.0003, "epss_percentile": 0.08259}, "CVE-2023-20630": {"epss_score": 0.00015, "epss_percentile": 0.02131}, "CVE-2023-20632": {"epss_score": 0.00015, "epss_percentile": 0.02131}, "CVE-2023-20633": {"epss_score": 0.00015, "epss_percentile": 0.02131}, "CVE-2023-20634": {"epss_score": 0.00011, "epss_percentile": 0.00989}, "CVE-2023-20635": {"epss_score": 0.00015, "epss_percentile": 0.02539}, "CVE-2023-20636": {"epss_score": 0.00025, "epss_percentile": 0.06232}, "CVE-2023-20637": {"epss_score": 0.00026, "epss_percentile": 0.06529}, "CVE-2023-20638": {"epss_score": 0.00026, "epss_percentile": 0.06529}, "CVE-2023-20639": {"epss_score": 0.00026, "epss_percentile": 0.06529}, "CVE-2023-20640": {"epss_score": 0.00026, "epss_percentile": 0.06529}, "CVE-2023-20641": {"epss_score": 0.00025, "epss_percentile": 0.06232}, "CVE-2023-20642": {"epss_score": 0.00026, "epss_percentile": 0.06529}, "CVE-2023-20643": {"epss_score": 0.00026, "epss_percentile": 0.06529}, "CVE-2023-20644": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20645": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20646": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20647": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20648": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20649": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20650": {"epss_score": 0.00026, "epss_percentile": 0.06529}, "CVE-2023-20651": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20652": {"epss_score": 0.00014, "epss_percentile": 0.01792}, "CVE-2023-20653": {"epss_score": 0.00014, "epss_percentile": 0.01792}, "CVE-2023-20654": {"epss_score": 0.00013, "epss_percentile": 0.01609}, "CVE-2023-20655": {"epss_score": 0.00042, "epss_percentile": 0.12619}, "CVE-2023-20656": {"epss_score": 0.00021, "epss_percentile": 0.0469}, "CVE-2023-20657": {"epss_score": 0.00014, "epss_percentile": 0.01792}, "CVE-2023-20658": {"epss_score": 0.00014, "epss_percentile": 0.01792}, "CVE-2023-20659": {"epss_score": 0.00026, "epss_percentile": 0.06529}, "CVE-2023-20660": {"epss_score": 0.00036, "epss_percentile": 0.10556}, "CVE-2023-20661": {"epss_score": 0.00041, "epss_percentile": 0.12297}, "CVE-2023-20662": {"epss_score": 0.00041, "epss_percentile": 0.12297}, "CVE-2023-20663": {"epss_score": 0.00041, "epss_percentile": 0.12297}, "CVE-2023-20664": {"epss_score": 0.00028, "epss_percentile": 0.07289}, "CVE-2023-20665": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20666": {"epss_score": 0.00026, "epss_percentile": 0.06529}, "CVE-2023-20670": {"epss_score": 0.00026, "epss_percentile": 0.06529}, "CVE-2023-20673": {"epss_score": 0.00022, "epss_percentile": 0.05197}, "CVE-2023-20674": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20675": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20676": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20677": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20679": {"epss_score": 0.00027, "epss_percentile": 0.06741}, "CVE-2023-20680": {"epss_score": 9e-05, "epss_percentile": 0.00732}, "CVE-2023-20681": {"epss_score": 0.0001, "epss_percentile": 0.00858}, "CVE-2023-20682": {"epss_score": 0.00041, "epss_percentile": 0.12297}, "CVE-2023-20684": {"epss_score": 0.00029, "epss_percentile": 0.07833}, "CVE-2023-20685": {"epss_score": 0.00029, "epss_percentile": 0.07833}, "CVE-2023-20686": {"epss_score": 0.00011, "epss_percentile": 0.00958}, "CVE-2023-20687": {"epss_score": 0.00011, "epss_percentile": 0.00958}, "CVE-2023-20688": {"epss_score": 0.00023, "epss_percentile": 0.05499}, "CVE-2023-20689": {"epss_score": 0.01096, "epss_percentile": 0.77516}, "CVE-2023-20690": {"epss_score": 0.01096, "epss_percentile": 0.77516}, "CVE-2023-20691": {"epss_score": 0.01096, "epss_percentile": 0.77516}, "CVE-2023-20692": {"epss_score": 0.01096, "epss_percentile": 0.77516}, "CVE-2023-20693": {"epss_score": 0.01096, "epss_percentile": 0.77516}, "CVE-2023-20694": {"epss_score": 0.0001, "epss_percentile": 0.00843}, "CVE-2023-20695": {"epss_score": 0.0001, "epss_percentile": 0.00843}, "CVE-2023-20696": {"epss_score": 0.0001, "epss_percentile": 0.00843}, "CVE-2023-20697": {"epss_score": 0.00014, "epss_percentile": 0.01747}, "CVE-2023-20698": {"epss_score": 0.00014, "epss_percentile": 0.01747}, "CVE-2023-20699": {"epss_score": 0.0001, "epss_percentile": 0.00843}, "CVE-2023-20700": {"epss_score": 0.00013, "epss_percentile": 0.01726}, "CVE-2023-20701": {"epss_score": 0.00013, "epss_percentile": 0.01726}, "CVE-2023-20702": {"epss_score": 0.01762, "epss_percentile": 0.82153}, "CVE-2023-20703": {"epss_score": 0.0002, "epss_percentile": 0.04552}, "CVE-2023-20704": {"epss_score": 0.0002, "epss_percentile": 0.04552}, "CVE-2023-20705": {"epss_score": 0.0002, "epss_percentile": 0.04552}, "CVE-2023-20706": {"epss_score": 0.0002, "epss_percentile": 0.04552}, "CVE-2023-20707": {"epss_score": 0.00019, "epss_percentile": 0.04209}, "CVE-2023-20708": {"epss_score": 0.00013, "epss_percentile": 0.01581}, "CVE-2023-20709": {"epss_score": 0.0002, "epss_percentile": 0.04446}, "CVE-2023-20710": {"epss_score": 0.0002, "epss_percentile": 0.04446}, "CVE-2023-20711": {"epss_score": 0.00016, "epss_percentile": 0.02792}, "CVE-2023-20712": {"epss_score": 0.00012, "epss_percentile": 0.01222}, "CVE-2023-20715": {"epss_score": 0.00012, "epss_percentile": 0.01222}, "CVE-2023-20716": {"epss_score": 0.00012, "epss_percentile": 0.01222}, "CVE-2023-20717": {"epss_score": 0.00015, "epss_percentile": 0.02128}, "CVE-2023-20718": {"epss_score": 0.00022, "epss_percentile": 0.0528}, "CVE-2023-20719": {"epss_score": 0.00015, "epss_percentile": 0.02131}, "CVE-2023-20720": {"epss_score": 0.00022, "epss_percentile": 0.04975}, "CVE-2023-20721": {"epss_score": 9e-05, "epss_percentile": 0.00634}, "CVE-2023-20722": {"epss_score": 8e-05, "epss_percentile": 0.00591}, "CVE-2023-20723": {"epss_score": 0.00015, "epss_percentile": 0.02509}, "CVE-2023-20724": {"epss_score": 0.00015, "epss_percentile": 0.02509}, "CVE-2023-20725": {"epss_score": 0.00012, "epss_percentile": 0.01222}, "CVE-2023-20726": {"epss_score": 0.00016, "epss_percentile": 0.02618}, "CVE-2023-20727": {"epss_score": 0.0002, "epss_percentile": 0.04446}, "CVE-2023-20728": {"epss_score": 0.0002, "epss_percentile": 0.04446}, "CVE-2023-20729": {"epss_score": 0.0002, "epss_percentile": 0.04446}, "CVE-2023-20730": {"epss_score": 0.0002, "epss_percentile": 0.04446}, "CVE-2023-20731": {"epss_score": 0.0002, "epss_percentile": 0.04446}, "CVE-2023-20732": {"epss_score": 0.00025, "epss_percentile": 0.06238}, "CVE-2023-20733": {"epss_score": 0.00025, "epss_percentile": 0.06272}, "CVE-2023-20734": {"epss_score": 0.00022, "epss_percentile": 0.0528}, "CVE-2023-20735": {"epss_score": 0.00022, "epss_percentile": 0.04966}, "CVE-2023-20736": {"epss_score": 0.00017, "epss_percentile": 0.0317}, "CVE-2023-20737": {"epss_score": 0.00025, "epss_percentile": 0.06272}, "CVE-2023-20738": {"epss_score": 0.00022, "epss_percentile": 0.0528}, "CVE-2023-20739": {"epss_score": 0.0003, "epss_percentile": 0.08258}, "CVE-2023-20740": {"epss_score": 0.0003, "epss_percentile": 0.08258}, "CVE-2023-20741": {"epss_score": 0.0002, "epss_percentile": 0.04446}, "CVE-2023-20742": {"epss_score": 0.0002, "epss_percentile": 0.04446}, "CVE-2023-20743": {"epss_score": 0.00024, "epss_percentile": 0.05659}, "CVE-2023-20744": {"epss_score": 0.00024, "epss_percentile": 0.05812}, "CVE-2023-20745": {"epss_score": 0.00024, "epss_percentile": 0.05659}, "CVE-2023-20746": {"epss_score": 0.00024, "epss_percentile": 0.05659}, "CVE-2023-20747": {"epss_score": 0.00022, "epss_percentile": 0.05283}, "CVE-2023-20748": {"epss_score": 0.00018, "epss_percentile": 0.03745}, "CVE-2023-20749": {"epss_score": 0.00022, "epss_percentile": 0.0528}, "CVE-2023-20750": {"epss_score": 0.00012, "epss_percentile": 0.01206}, "CVE-2023-20751": {"epss_score": 0.00012, "epss_percentile": 0.01222}, "CVE-2023-20752": {"epss_score": 0.00012, "epss_percentile": 0.01222}, "CVE-2023-20753": {"epss_score": 0.00028, "epss_percentile": 0.07263}, "CVE-2023-20754": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20755": {"epss_score": 0.00011, "epss_percentile": 0.00988}, "CVE-2023-20756": {"epss_score": 0.00011, "epss_percentile": 0.00988}, "CVE-2023-20757": {"epss_score": 0.00011, "epss_percentile": 0.00988}, "CVE-2023-20758": {"epss_score": 0.0001, "epss_percentile": 0.0085}, "CVE-2023-20759": {"epss_score": 0.0001, "epss_percentile": 0.0085}, "CVE-2023-20760": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20761": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20766": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20767": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20768": {"epss_score": 0.00031, "epss_percentile": 0.08568}, "CVE-2023-20771": {"epss_score": 0.00016, "epss_percentile": 0.02794}, "CVE-2023-20772": {"epss_score": 0.00025, "epss_percentile": 0.06374}, "CVE-2023-20773": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2023-20774": {"epss_score": 0.00027, "epss_percentile": 0.06779}, "CVE-2023-20775": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20780": {"epss_score": 0.00019, "epss_percentile": 0.04078}, "CVE-2023-20781": {"epss_score": 0.0001, "epss_percentile": 0.00782}, "CVE-2023-20782": {"epss_score": 0.00011, "epss_percentile": 0.01059}, "CVE-2023-20783": {"epss_score": 0.00011, "epss_percentile": 0.00988}, "CVE-2023-20784": {"epss_score": 0.00011, "epss_percentile": 0.00988}, "CVE-2023-20785": {"epss_score": 0.00016, "epss_percentile": 0.02794}, "CVE-2023-20786": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20787": {"epss_score": 0.00017, "epss_percentile": 0.03256}, "CVE-2023-20788": {"epss_score": 0.00017, "epss_percentile": 0.03256}, "CVE-2023-20789": {"epss_score": 0.00014, "epss_percentile": 0.01855}, "CVE-2023-20790": {"epss_score": 0.00014, "epss_percentile": 0.01855}, "CVE-2023-20793": {"epss_score": 0.0001, "epss_percentile": 0.00782}, "CVE-2023-20795": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20796": {"epss_score": 0.0001, "epss_percentile": 0.00782}, "CVE-2023-20797": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20798": {"epss_score": 0.00018, "epss_percentile": 0.03745}, "CVE-2023-20800": {"epss_score": 0.00025, "epss_percentile": 0.06374}, "CVE-2023-20801": {"epss_score": 0.00017, "epss_percentile": 0.03256}, "CVE-2023-20802": {"epss_score": 0.00015, "epss_percentile": 0.02427}, "CVE-2023-20803": {"epss_score": 0.00015, "epss_percentile": 0.02162}, "CVE-2023-20804": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20805": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20806": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20807": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20808": {"epss_score": 0.00011, "epss_percentile": 0.00988}, "CVE-2023-20809": {"epss_score": 0.00011, "epss_percentile": 0.00988}, "CVE-2023-20810": {"epss_score": 8e-05, "epss_percentile": 0.00573}, "CVE-2023-20811": {"epss_score": 0.00011, "epss_percentile": 0.00988}, "CVE-2023-20812": {"epss_score": 8e-05, "epss_percentile": 0.00573}, "CVE-2023-20813": {"epss_score": 0.00013, "epss_percentile": 0.01657}, "CVE-2023-20814": {"epss_score": 0.00015, "epss_percentile": 0.02427}, "CVE-2023-20815": {"epss_score": 0.00015, "epss_percentile": 0.02427}, "CVE-2023-20816": {"epss_score": 0.00015, "epss_percentile": 0.02162}, "CVE-2023-20817": {"epss_score": 0.00015, "epss_percentile": 0.02427}, "CVE-2023-20818": {"epss_score": 0.00013, "epss_percentile": 0.01657}, "CVE-2023-20819": {"epss_score": 0.01538, "epss_percentile": 0.80924}, "CVE-2023-20820": {"epss_score": 0.01103, "epss_percentile": 0.7759}, "CVE-2023-20821": {"epss_score": 0.0002, "epss_percentile": 0.04508}, "CVE-2023-20822": {"epss_score": 0.0002, "epss_percentile": 0.04508}, "CVE-2023-20823": {"epss_score": 0.00013, "epss_percentile": 0.01446}, "CVE-2023-20824": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-20825": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-20826": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-20827": {"epss_score": 0.00015, "epss_percentile": 0.02553}, "CVE-2023-20828": {"epss_score": 0.0002, "epss_percentile": 0.04508}, "CVE-2023-20829": {"epss_score": 0.0002, "epss_percentile": 0.04508}, "CVE-2023-20830": {"epss_score": 0.0002, "epss_percentile": 0.04508}, "CVE-2023-20831": {"epss_score": 0.0002, "epss_percentile": 0.04508}, "CVE-2023-20832": {"epss_score": 0.0002, "epss_percentile": 0.04508}, "CVE-2023-20833": {"epss_score": 0.00017, "epss_percentile": 0.03327}, "CVE-2023-20834": {"epss_score": 0.00016, "epss_percentile": 0.02753}, "CVE-2023-20835": {"epss_score": 0.00016, "epss_percentile": 0.03029}, "CVE-2023-20836": {"epss_score": 0.00017, "epss_percentile": 0.03418}, "CVE-2023-20837": {"epss_score": 0.0002, "epss_percentile": 0.04508}, "CVE-2023-20838": {"epss_score": 0.00017, "epss_percentile": 0.03418}, "CVE-2023-20839": {"epss_score": 0.00018, "epss_percentile": 0.03745}, "CVE-2023-20840": {"epss_score": 0.00027, "epss_percentile": 0.06779}, "CVE-2023-20841": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20842": {"epss_score": 0.0002, "epss_percentile": 0.04508}, "CVE-2023-20843": {"epss_score": 0.00018, "epss_percentile": 0.03745}, "CVE-2023-20844": {"epss_score": 0.00018, "epss_percentile": 0.03745}, "CVE-2023-20845": {"epss_score": 0.00018, "epss_percentile": 0.03745}, "CVE-2023-20846": {"epss_score": 0.00018, "epss_percentile": 0.03745}, "CVE-2023-20847": {"epss_score": 0.00012, "epss_percentile": 0.01302}, "CVE-2023-20848": {"epss_score": 0.00027, "epss_percentile": 0.06779}, "CVE-2023-20849": {"epss_score": 0.00021, "epss_percentile": 0.04868}, "CVE-2023-20850": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-20851": {"epss_score": 0.00014, "epss_percentile": 0.0176}, "CVE-2023-20852": {"epss_score": 0.00481, "epss_percentile": 0.64502}, "CVE-2023-20853": {"epss_score": 0.00481, "epss_percentile": 0.64502}, "CVE-2023-20854": {"epss_score": 0.00172, "epss_percentile": 0.39026}, "CVE-2023-20855": {"epss_score": 0.00104, "epss_percentile": 0.291}, "CVE-2023-20856": {"epss_score": 0.00367, "epss_percentile": 0.58117}, "CVE-2023-20857": {"epss_score": 0.00069, "epss_percentile": 0.21626}, "CVE-2023-20858": {"epss_score": 0.05584, "epss_percentile": 0.90022}, "CVE-2023-20859": {"epss_score": 0.00073, "epss_percentile": 0.22623}, "CVE-2023-20860": {"epss_score": 0.55048, "epss_percentile": 0.97958}, "CVE-2023-20861": {"epss_score": 0.00341, "epss_percentile": 0.56337}, "CVE-2023-20862": {"epss_score": 0.00372, "epss_percentile": 0.58434}, "CVE-2023-20863": {"epss_score": 0.00775, "epss_percentile": 0.73088}, "CVE-2023-20864": {"epss_score": 0.92927, "epss_percentile": 0.99761}, "CVE-2023-20865": {"epss_score": 0.00542, "epss_percentile": 0.67085}, "CVE-2023-20866": {"epss_score": 0.00462, "epss_percentile": 0.63589}, "CVE-2023-20867": {"epss_score": 0.02719, "epss_percentile": 0.85514}, "CVE-2023-20868": {"epss_score": 0.00153, "epss_percentile": 0.36566}, "CVE-2023-20869": {"epss_score": 0.0238, "epss_percentile": 0.84563}, "CVE-2023-20870": {"epss_score": 0.00082, "epss_percentile": 0.24549}, "CVE-2023-20871": {"epss_score": 0.00073, "epss_percentile": 0.22585}, "CVE-2023-20872": {"epss_score": 0.00647, "epss_percentile": 0.70207}, "CVE-2023-20873": {"epss_score": 0.00335, "epss_percentile": 0.55808}, "CVE-2023-20877": {"epss_score": 0.00392, "epss_percentile": 0.597}, "CVE-2023-20878": {"epss_score": 0.00611, "epss_percentile": 0.69178}, "CVE-2023-20879": {"epss_score": 0.00049, "epss_percentile": 0.15558}, "CVE-2023-20880": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2023-20881": {"epss_score": 0.00111, "epss_percentile": 0.30331}, "CVE-2023-20882": {"epss_score": 0.00177, "epss_percentile": 0.39612}, "CVE-2023-20883": {"epss_score": 0.00408, "epss_percentile": 0.60687}, "CVE-2023-20884": {"epss_score": 0.0027, "epss_percentile": 0.50254}, "CVE-2023-20885": {"epss_score": 0.00182, "epss_percentile": 0.4023}, "CVE-2023-20886": {"epss_score": 0.00358, "epss_percentile": 0.57531}, "CVE-2023-20887": {"epss_score": 0.94393, "epss_percentile": 0.9997}, "CVE-2023-20888": {"epss_score": 0.90925, "epss_percentile": 0.9961}, "CVE-2023-20889": {"epss_score": 0.89973, "epss_percentile": 0.99554}, "CVE-2023-20890": {"epss_score": 0.00788, "epss_percentile": 0.73323}, "CVE-2023-20891": {"epss_score": 0.00243, "epss_percentile": 0.47486}, "CVE-2023-20892": {"epss_score": 0.02678, "epss_percentile": 0.85411}, "CVE-2023-20893": {"epss_score": 0.0233, "epss_percentile": 0.844}, "CVE-2023-20894": {"epss_score": 0.46587, "epss_percentile": 0.97552}, "CVE-2023-20895": {"epss_score": 0.00396, "epss_percentile": 0.59891}, "CVE-2023-20896": {"epss_score": 0.00289, "epss_percentile": 0.52006}, "CVE-2023-20897": {"epss_score": 0.0011, "epss_percentile": 0.30238}, "CVE-2023-20898": {"epss_score": 0.00123, "epss_percentile": 0.32305}, "CVE-2023-20899": {"epss_score": 0.00138, "epss_percentile": 0.34377}, "CVE-2023-20900": {"epss_score": 0.00836, "epss_percentile": 0.74134}, "CVE-2023-20902": {"epss_score": 0.00298, "epss_percentile": 0.52798}, "CVE-2023-20903": {"epss_score": 0.00188, "epss_percentile": 0.40875}, "CVE-2023-20904": {"epss_score": 0.00038, "epss_percentile": 0.11426}, "CVE-2023-20905": {"epss_score": 0.00036, "epss_percentile": 0.10492}, "CVE-2023-20906": {"epss_score": 3e-05, "epss_percentile": 0.00094}, "CVE-2023-20908": {"epss_score": 0.00047, "epss_percentile": 0.1463}, "CVE-2023-20909": {"epss_score": 0.00062, "epss_percentile": 0.19724}, "CVE-2023-20910": {"epss_score": 0.00022, "epss_percentile": 0.0526}, "CVE-2023-20911": {"epss_score": 0.00014, "epss_percentile": 0.01852}, "CVE-2023-20912": {"epss_score": 0.00034, "epss_percentile": 0.09477}, "CVE-2023-20913": {"epss_score": 0.00032, "epss_percentile": 0.08776}, "CVE-2023-20914": {"epss_score": 2e-05, "epss_percentile": 0.00042}, "CVE-2023-20915": {"epss_score": 0.00055, "epss_percentile": 0.17488}, "CVE-2023-20916": {"epss_score": 0.0001, "epss_percentile": 0.00846}, "CVE-2023-20917": {"epss_score": 0.00024, "epss_percentile": 0.05669}, "CVE-2023-20918": {"epss_score": 0.01114, "epss_percentile": 0.77698}, "CVE-2023-20919": {"epss_score": 0.00052, "epss_percentile": 0.16581}, "CVE-2023-20920": {"epss_score": 0.00037, "epss_percentile": 0.10771}, "CVE-2023-20921": {"epss_score": 0.00105, "epss_percentile": 0.29254}, "CVE-2023-20922": {"epss_score": 0.00044, "epss_percentile": 0.136}, "CVE-2023-20923": {"epss_score": 0.0001, "epss_percentile": 0.00748}, "CVE-2023-20924": {"epss_score": 0.00017, "epss_percentile": 0.03195}, "CVE-2023-20925": {"epss_score": 0.00038, "epss_percentile": 0.11351}, "CVE-2023-20926": {"epss_score": 5e-05, "epss_percentile": 0.00204}, "CVE-2023-20927": {"epss_score": 3e-05, "epss_percentile": 0.0012}, "CVE-2023-20928": {"epss_score": 0.00099, "epss_percentile": 0.27844}, "CVE-2023-20929": {"epss_score": 0.00017, "epss_percentile": 0.03097}, "CVE-2023-20930": {"epss_score": 0.00023, "epss_percentile": 0.05638}, "CVE-2023-20931": {"epss_score": 0.00014, "epss_percentile": 0.02026}, "CVE-2023-20932": {"epss_score": 0.00017, "epss_percentile": 0.03088}, "CVE-2023-20933": {"epss_score": 0.00019, "epss_percentile": 0.04139}, "CVE-2023-20934": {"epss_score": 3e-05, "epss_percentile": 0.00109}, "CVE-2023-20935": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2023-20936": {"epss_score": 0.0002, "epss_percentile": 0.04642}, "CVE-2023-20937": {"epss_score": 0.00042, "epss_percentile": 0.12913}, "CVE-2023-20938": {"epss_score": 0.00189, "epss_percentile": 0.40924}, "CVE-2023-20939": {"epss_score": 0.00015, "epss_percentile": 0.02158}, "CVE-2023-20940": {"epss_score": 0.00011, "epss_percentile": 0.0099}, "CVE-2023-20941": {"epss_score": 0.00023, "epss_percentile": 0.0538}, "CVE-2023-20942": {"epss_score": 0.0001, "epss_percentile": 0.0087}, "CVE-2023-20943": {"epss_score": 0.0002, "epss_percentile": 0.0453}, "CVE-2023-20944": {"epss_score": 0.00022, "epss_percentile": 0.05163}, "CVE-2023-20945": {"epss_score": 0.00018, "epss_percentile": 0.04018}, "CVE-2023-20946": {"epss_score": 0.001, "epss_percentile": 0.28494}, "CVE-2023-20947": {"epss_score": 3e-05, "epss_percentile": 0.00094}, "CVE-2023-20948": {"epss_score": 0.00521, "epss_percentile": 0.66246}, "CVE-2023-20949": {"epss_score": 0.00035, "epss_percentile": 0.1006}, "CVE-2023-20950": {"epss_score": 3e-05, "epss_percentile": 0.00104}, "CVE-2023-20951": {"epss_score": 0.02128, "epss_percentile": 0.83703}, "CVE-2023-20952": {"epss_score": 0.00017, "epss_percentile": 0.03097}, "CVE-2023-20953": {"epss_score": 3e-05, "epss_percentile": 0.00122}, "CVE-2023-20954": {"epss_score": 0.02013, "epss_percentile": 0.83256}, "CVE-2023-20955": {"epss_score": 4e-05, "epss_percentile": 0.00148}, "CVE-2023-20956": {"epss_score": 0.00012, "epss_percentile": 0.01331}, "CVE-2023-20957": {"epss_score": 3e-05, "epss_percentile": 0.00098}, "CVE-2023-20958": {"epss_score": 0.00022, "epss_percentile": 0.05184}, "CVE-2023-20959": {"epss_score": 0.00013, "epss_percentile": 0.01512}, "CVE-2023-20960": {"epss_score": 0.0003, "epss_percentile": 0.0822}, "CVE-2023-20962": {"epss_score": 0.00015, "epss_percentile": 0.02126}, "CVE-2023-20963": {"epss_score": 0.02157, "epss_percentile": 0.83812}, "CVE-2023-20964": {"epss_score": 0.00013, "epss_percentile": 0.01486}, "CVE-2023-20965": {"epss_score": 0.01036, "epss_percentile": 0.76918}, "CVE-2023-20966": {"epss_score": 0.00014, "epss_percentile": 0.02026}, "CVE-2023-20967": {"epss_score": 0.00016, "epss_percentile": 0.02796}, "CVE-2023-20968": {"epss_score": 0.00011, "epss_percentile": 0.00973}, "CVE-2023-20969": {"epss_score": 0.00016, "epss_percentile": 0.02802}, "CVE-2023-20970": {"epss_score": 0.00016, "epss_percentile": 0.02802}, "CVE-2023-20971": {"epss_score": 0.00011, "epss_percentile": 0.01053}, "CVE-2023-20972": {"epss_score": 0.00013, "epss_percentile": 0.01569}, "CVE-2023-20973": {"epss_score": 0.00013, "epss_percentile": 0.01569}, "CVE-2023-20974": {"epss_score": 0.00013, "epss_percentile": 0.01569}, "CVE-2023-20975": {"epss_score": 2e-05, "epss_percentile": 0.0006}, "CVE-2023-20976": {"epss_score": 0.00011, "epss_percentile": 0.01007}, "CVE-2023-20977": {"epss_score": 0.00013, "epss_percentile": 0.01451}, "CVE-2023-20979": {"epss_score": 0.00015, "epss_percentile": 0.02487}, "CVE-2023-20980": {"epss_score": 0.00015, "epss_percentile": 0.02487}, "CVE-2023-20981": {"epss_score": 0.00013, "epss_percentile": 0.01451}, "CVE-2023-20982": {"epss_score": 0.00013, "epss_percentile": 0.01451}, "CVE-2023-20983": {"epss_score": 0.00013, "epss_percentile": 0.01451}, "CVE-2023-20984": {"epss_score": 0.00013, "epss_percentile": 0.01451}, "CVE-2023-20985": {"epss_score": 0.00013, "epss_percentile": 0.01519}, "CVE-2023-20986": {"epss_score": 0.00013, "epss_percentile": 0.01451}, "CVE-2023-20987": {"epss_score": 0.00019, "epss_percentile": 0.04225}, "CVE-2023-20988": {"epss_score": 0.00019, "epss_percentile": 0.04225}, "CVE-2023-20989": {"epss_score": 0.00013, "epss_percentile": 0.01451}, "CVE-2023-20990": {"epss_score": 0.00013, "epss_percentile": 0.01451}, "CVE-2023-20991": {"epss_score": 0.00013, "epss_percentile": 0.01451}, "CVE-2023-20992": {"epss_score": 0.00019, "epss_percentile": 0.04225}, "CVE-2023-20993": {"epss_score": 0.00013, "epss_percentile": 0.01519}, "CVE-2023-20994": {"epss_score": 0.00014, "epss_percentile": 0.01792}, "CVE-2023-20995": {"epss_score": 4e-05, "epss_percentile": 0.00135}, "CVE-2023-20996": {"epss_score": 0.0002, "epss_percentile": 0.04677}, "CVE-2023-20997": {"epss_score": 0.0002, "epss_percentile": 0.04677}, "CVE-2023-20998": {"epss_score": 0.0002, "epss_percentile": 0.04677}, "CVE-2023-20999": {"epss_score": 0.00027, "epss_percentile": 0.06782}, "CVE-2023-21000": {"epss_score": 0.00015, "epss_percentile": 0.02516}, "CVE-2023-21001": {"epss_score": 0.00016, "epss_percentile": 0.02888}, "CVE-2023-21002": {"epss_score": 4e-05, "epss_percentile": 0.00135}, "CVE-2023-21003": {"epss_score": 4e-05, "epss_percentile": 0.00135}, "CVE-2023-21004": {"epss_score": 4e-05, "epss_percentile": 0.00135}, "CVE-2023-21005": {"epss_score": 4e-05, "epss_percentile": 0.00135}, "CVE-2023-21006": {"epss_score": 0.0002, "epss_percentile": 0.0448}, "CVE-2023-21007": {"epss_score": 0.00016, "epss_percentile": 0.02802}, "CVE-2023-21008": {"epss_score": 0.0002, "epss_percentile": 0.0448}, "CVE-2023-21009": {"epss_score": 0.0002, "epss_percentile": 0.0448}, "CVE-2023-21010": {"epss_score": 0.0002, "epss_percentile": 0.0448}, "CVE-2023-21011": {"epss_score": 0.0002, "epss_percentile": 0.0448}, "CVE-2023-21012": {"epss_score": 0.00052, "epss_percentile": 0.16356}, "CVE-2023-21013": {"epss_score": 0.0002, "epss_percentile": 0.0448}, "CVE-2023-21014": {"epss_score": 0.00019, "epss_percentile": 0.0414}, "CVE-2023-21015": {"epss_score": 4e-05, "epss_percentile": 0.00135}, "CVE-2023-21016": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2023-21017": {"epss_score": 0.00014, "epss_percentile": 0.01802}, "CVE-2023-21018": {"epss_score": 0.00015, "epss_percentile": 0.02154}, "CVE-2023-21019": {"epss_score": 0.00031, "epss_percentile": 0.08622}, "CVE-2023-21020": {"epss_score": 0.00015, "epss_percentile": 0.02154}, "CVE-2023-21021": {"epss_score": 0.00016, "epss_percentile": 0.02888}, "CVE-2023-21022": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2023-21024": {"epss_score": 0.00036, "epss_percentile": 0.10494}, "CVE-2023-21025": {"epss_score": 0.00019, "epss_percentile": 0.0414}, "CVE-2023-21026": {"epss_score": 0.00026, "epss_percentile": 0.06722}, "CVE-2023-21027": {"epss_score": 0.00193, "epss_percentile": 0.41443}, "CVE-2023-21028": {"epss_score": 0.00477, "epss_percentile": 0.64352}, "CVE-2023-21029": {"epss_score": 0.00017, "epss_percentile": 0.0331}, "CVE-2023-21030": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2023-21031": {"epss_score": 0.00012, "epss_percentile": 0.01247}, "CVE-2023-21032": {"epss_score": 0.00023, "epss_percentile": 0.05452}, "CVE-2023-21033": {"epss_score": 0.00028, "epss_percentile": 0.07267}, "CVE-2023-21034": {"epss_score": 3e-05, "epss_percentile": 0.00111}, "CVE-2023-21035": {"epss_score": 5e-05, "epss_percentile": 0.00212}, "CVE-2023-21036": {"epss_score": 0.0019, "epss_percentile": 0.41134}, "CVE-2023-21038": {"epss_score": 0.00015, "epss_percentile": 0.02154}, "CVE-2023-21039": {"epss_score": 0.00019, "epss_percentile": 0.0414}, "CVE-2023-21040": {"epss_score": 0.00028, "epss_percentile": 0.073}, "CVE-2023-21041": {"epss_score": 0.00018, "epss_percentile": 0.04022}, "CVE-2023-21042": {"epss_score": 0.00014, "epss_percentile": 0.01874}, "CVE-2023-21043": {"epss_score": 0.00014, "epss_percentile": 0.01874}, "CVE-2023-21044": {"epss_score": 0.00035, "epss_percentile": 0.09825}, "CVE-2023-21045": {"epss_score": 0.00037, "epss_percentile": 0.10787}, "CVE-2023-21046": {"epss_score": 0.00035, "epss_percentile": 0.09825}, "CVE-2023-21047": {"epss_score": 0.00035, "epss_percentile": 0.09825}, "CVE-2023-21048": {"epss_score": 0.00035, "epss_percentile": 0.09825}, "CVE-2023-21049": {"epss_score": 0.00035, "epss_percentile": 0.09825}, "CVE-2023-21050": {"epss_score": 0.00019, "epss_percentile": 0.04055}, "CVE-2023-21051": {"epss_score": 0.00025, "epss_percentile": 0.06245}, "CVE-2023-21052": {"epss_score": 0.00014, "epss_percentile": 0.01792}, "CVE-2023-21053": {"epss_score": 0.00477, "epss_percentile": 0.64352}, "CVE-2023-21054": {"epss_score": 0.02029, "epss_percentile": 0.83327}, "CVE-2023-21055": {"epss_score": 0.00015, "epss_percentile": 0.02154}, "CVE-2023-21056": {"epss_score": 0.00015, "epss_percentile": 0.02417}, "CVE-2023-21057": {"epss_score": 0.03361, "epss_percentile": 0.86991}, "CVE-2023-21058": {"epss_score": 0.03361, "epss_percentile": 0.86991}, "CVE-2023-21059": {"epss_score": 0.00477, "epss_percentile": 0.64352}, "CVE-2023-21060": {"epss_score": 0.00624, "epss_percentile": 0.69555}, "CVE-2023-21061": {"epss_score": 0.00089, "epss_percentile": 0.25949}, "CVE-2023-21062": {"epss_score": 0.00018, "epss_percentile": 0.03659}, "CVE-2023-21063": {"epss_score": 0.00018, "epss_percentile": 0.03659}, "CVE-2023-21064": {"epss_score": 0.00018, "epss_percentile": 0.03659}, "CVE-2023-21065": {"epss_score": 0.00014, "epss_percentile": 0.01792}, "CVE-2023-21066": {"epss_score": 0.02782, "epss_percentile": 0.85652}, "CVE-2023-21067": {"epss_score": 0.00082, "epss_percentile": 0.24437}, "CVE-2023-21068": {"epss_score": 0.00016, "epss_percentile": 0.02888}, "CVE-2023-21069": {"epss_score": 0.00014, "epss_percentile": 0.01792}, "CVE-2023-21070": {"epss_score": 0.00014, "epss_percentile": 0.01792}, "CVE-2023-21071": {"epss_score": 0.0001, "epss_percentile": 0.00858}, "CVE-2023-21072": {"epss_score": 0.00017, "epss_percentile": 0.03141}, "CVE-2023-21073": {"epss_score": 0.00017, "epss_percentile": 0.03141}, "CVE-2023-21075": {"epss_score": 0.00017, "epss_percentile": 0.03141}, "CVE-2023-21076": {"epss_score": 0.00017, "epss_percentile": 0.03141}, "CVE-2023-21077": {"epss_score": 0.00017, "epss_percentile": 0.03141}, "CVE-2023-21078": {"epss_score": 0.00017, "epss_percentile": 0.03141}, "CVE-2023-21079": {"epss_score": 0.00011, "epss_percentile": 0.00931}, "CVE-2023-21080": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2023-21081": {"epss_score": 4e-05, "epss_percentile": 0.00126}, "CVE-2023-21082": {"epss_score": 0.00014, "epss_percentile": 0.0212}, "CVE-2023-21083": {"epss_score": 3e-05, "epss_percentile": 0.00099}, "CVE-2023-21084": {"epss_score": 0.00012, "epss_percentile": 0.01222}, "CVE-2023-21085": {"epss_score": 0.00032, "epss_percentile": 0.0902}, "CVE-2023-21086": {"epss_score": 3e-05, "epss_percentile": 0.00102}, "CVE-2023-21087": {"epss_score": 0.00032, "epss_percentile": 0.08785}, "CVE-2023-21088": {"epss_score": 4e-05, "epss_percentile": 0.00126}, "CVE-2023-21089": {"epss_score": 0.00016, "epss_percentile": 0.02796}, "CVE-2023-21090": {"epss_score": 0.00027, "epss_percentile": 0.06789}, "CVE-2023-21091": {"epss_score": 0.00018, "epss_percentile": 0.03573}, "CVE-2023-21092": {"epss_score": 0.0001, "epss_percentile": 0.00859}, "CVE-2023-21093": {"epss_score": 0.00025, "epss_percentile": 0.06348}, "CVE-2023-21094": {"epss_score": 0.00013, "epss_percentile": 0.01597}, "CVE-2023-21095": {"epss_score": 3e-05, "epss_percentile": 0.0009}, "CVE-2023-21096": {"epss_score": 0.01909, "epss_percentile": 0.8282}, "CVE-2023-21097": {"epss_score": 0.00116, "epss_percentile": 0.31148}, "CVE-2023-21098": {"epss_score": 0.00015, "epss_percentile": 0.02419}, "CVE-2023-21099": {"epss_score": 0.00021, "epss_percentile": 0.04944}, "CVE-2023-21100": {"epss_score": 0.00019, "epss_percentile": 0.04416}, "CVE-2023-21101": {"epss_score": 0.00011, "epss_percentile": 0.01073}, "CVE-2023-21102": {"epss_score": 4e-05, "epss_percentile": 0.00166}, "CVE-2023-21103": {"epss_score": 0.00031, "epss_percentile": 0.08517}, "CVE-2023-21104": {"epss_score": 0.00014, "epss_percentile": 0.0212}, "CVE-2023-21105": {"epss_score": 0.00012, "epss_percentile": 0.01347}, "CVE-2023-21106": {"epss_score": 0.0002, "epss_percentile": 0.04582}, "CVE-2023-21107": {"epss_score": 0.00014, "epss_percentile": 0.019}, "CVE-2023-21108": {"epss_score": 0.00744, "epss_percentile": 0.72514}, "CVE-2023-21109": {"epss_score": 0.00012, "epss_percentile": 0.01267}, "CVE-2023-21110": {"epss_score": 0.00019, "epss_percentile": 0.04059}, "CVE-2023-21111": {"epss_score": 0.00015, "epss_percentile": 0.02285}, "CVE-2023-21112": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2023-21113": {"epss_score": 0.00066, "epss_percentile": 0.20807}, "CVE-2023-21114": {"epss_score": 0.00066, "epss_percentile": 0.20807}, "CVE-2023-21115": {"epss_score": 0.00015, "epss_percentile": 0.02441}, "CVE-2023-21116": {"epss_score": 0.00015, "epss_percentile": 0.02193}, "CVE-2023-21117": {"epss_score": 3e-05, "epss_percentile": 0.00085}, "CVE-2023-21118": {"epss_score": 0.00048, "epss_percentile": 0.15072}, "CVE-2023-21120": {"epss_score": 0.00011, "epss_percentile": 0.01073}, "CVE-2023-21121": {"epss_score": 9e-05, "epss_percentile": 0.00642}, "CVE-2023-21122": {"epss_score": 3e-05, "epss_percentile": 0.00104}, "CVE-2023-21123": {"epss_score": 3e-05, "epss_percentile": 0.00104}, "CVE-2023-21124": {"epss_score": 0.00024, "epss_percentile": 0.05823}, "CVE-2023-21125": {"epss_score": 0.00014, "epss_percentile": 0.01773}, "CVE-2023-21126": {"epss_score": 0.00013, "epss_percentile": 0.01542}, "CVE-2023-21127": {"epss_score": 0.01019, "epss_percentile": 0.7672}, "CVE-2023-21128": {"epss_score": 0.00016, "epss_percentile": 0.02825}, "CVE-2023-21129": {"epss_score": 3e-05, "epss_percentile": 0.00115}, "CVE-2023-21130": {"epss_score": 0.01065, "epss_percentile": 0.77209}, "CVE-2023-21131": {"epss_score": 3e-05, "epss_percentile": 0.00104}, "CVE-2023-21132": {"epss_score": 4e-05, "epss_percentile": 0.00161}, "CVE-2023-21133": {"epss_score": 4e-05, "epss_percentile": 0.00161}, "CVE-2023-21134": {"epss_score": 4e-05, "epss_percentile": 0.00161}, "CVE-2023-21135": {"epss_score": 0.0001, "epss_percentile": 0.00844}, "CVE-2023-21136": {"epss_score": 9e-05, "epss_percentile": 0.00739}, "CVE-2023-21137": {"epss_score": 0.00026, "epss_percentile": 0.06617}, "CVE-2023-21138": {"epss_score": 9e-05, "epss_percentile": 0.00642}, "CVE-2023-21139": {"epss_score": 0.00012, "epss_percentile": 0.01241}, "CVE-2023-21140": {"epss_score": 4e-05, "epss_percentile": 0.00161}, "CVE-2023-21141": {"epss_score": 3e-05, "epss_percentile": 0.00097}, "CVE-2023-21142": {"epss_score": 3e-05, "epss_percentile": 0.00097}, "CVE-2023-21143": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2023-21144": {"epss_score": 0.18862, "epss_percentile": 0.95081}, "CVE-2023-21145": {"epss_score": 7e-05, "epss_percentile": 0.00412}, "CVE-2023-21146": {"epss_score": 0.00022, "epss_percentile": 0.05154}, "CVE-2023-21147": {"epss_score": 0.0004, "epss_percentile": 0.1192}, "CVE-2023-21148": {"epss_score": 0.00034, "epss_percentile": 0.09778}, "CVE-2023-21149": {"epss_score": 0.00026, "epss_percentile": 0.06414}, "CVE-2023-21150": {"epss_score": 0.00034, "epss_percentile": 0.09778}, "CVE-2023-21151": {"epss_score": 0.00025, "epss_percentile": 0.06368}, "CVE-2023-21152": {"epss_score": 0.00047, "epss_percentile": 0.14621}, "CVE-2023-21153": {"epss_score": 0.00028, "epss_percentile": 0.07488}, "CVE-2023-21154": {"epss_score": 0.00034, "epss_percentile": 0.09778}, "CVE-2023-21155": {"epss_score": 0.00047, "epss_percentile": 0.14621}, "CVE-2023-21156": {"epss_score": 0.00025, "epss_percentile": 0.06351}, "CVE-2023-21157": {"epss_score": 0.00029, "epss_percentile": 0.07974}, "CVE-2023-21158": {"epss_score": 0.00022, "epss_percentile": 0.04986}, "CVE-2023-21159": {"epss_score": 0.00018, "epss_percentile": 0.03935}, "CVE-2023-21160": {"epss_score": 0.00029, "epss_percentile": 0.07904}, "CVE-2023-21161": {"epss_score": 0.00018, "epss_percentile": 0.03935}, "CVE-2023-21162": {"epss_score": 0.00112, "epss_percentile": 0.30538}, "CVE-2023-21163": {"epss_score": 0.00112, "epss_percentile": 0.30538}, "CVE-2023-21164": {"epss_score": 0.00112, "epss_percentile": 0.30538}, "CVE-2023-21165": {"epss_score": 0.00024, "epss_percentile": 0.05845}, "CVE-2023-21166": {"epss_score": 0.00112, "epss_percentile": 0.30538}, "CVE-2023-21167": {"epss_score": 0.00023, "epss_percentile": 0.05513}, "CVE-2023-21168": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2023-21169": {"epss_score": 0.00031, "epss_percentile": 0.08434}, "CVE-2023-21170": {"epss_score": 0.00031, "epss_percentile": 0.08434}, "CVE-2023-21171": {"epss_score": 0.00023, "epss_percentile": 0.05372}, "CVE-2023-21172": {"epss_score": 6e-05, "epss_percentile": 0.00285}, "CVE-2023-21173": {"epss_score": 0.00063, "epss_percentile": 0.19982}, "CVE-2023-21174": {"epss_score": 6e-05, "epss_percentile": 0.00285}, "CVE-2023-21175": {"epss_score": 5e-05, "epss_percentile": 0.00219}, "CVE-2023-21176": {"epss_score": 0.00029, "epss_percentile": 0.07655}, "CVE-2023-21177": {"epss_score": 0.00027, "epss_percentile": 0.06765}, "CVE-2023-21178": {"epss_score": 0.00016, "epss_percentile": 0.02741}, "CVE-2023-21179": {"epss_score": 6e-05, "epss_percentile": 0.00286}, "CVE-2023-21180": {"epss_score": 0.00384, "epss_percentile": 0.59178}, "CVE-2023-21181": {"epss_score": 0.00022, "epss_percentile": 0.04986}, "CVE-2023-21182": {"epss_score": 0.00028, "epss_percentile": 0.07507}, "CVE-2023-21183": {"epss_score": 0.00034, "epss_percentile": 0.09468}, "CVE-2023-21184": {"epss_score": 7e-05, "epss_percentile": 0.00356}, "CVE-2023-21185": {"epss_score": 0.00022, "epss_percentile": 0.05018}, "CVE-2023-21186": {"epss_score": 0.01711, "epss_percentile": 0.8188}, "CVE-2023-21187": {"epss_score": 0.00029, "epss_percentile": 0.0794}, "CVE-2023-21188": {"epss_score": 0.00022, "epss_percentile": 0.04986}, "CVE-2023-21189": {"epss_score": 5e-05, "epss_percentile": 0.0023}, "CVE-2023-21190": {"epss_score": 0.00022, "epss_percentile": 0.05238}, "CVE-2023-21191": {"epss_score": 7e-05, "epss_percentile": 0.00356}, "CVE-2023-21192": {"epss_score": 0.00018, "epss_percentile": 0.03962}, "CVE-2023-21193": {"epss_score": 0.00562, "epss_percentile": 0.67705}, "CVE-2023-21194": {"epss_score": 0.00025, "epss_percentile": 0.06143}, "CVE-2023-21195": {"epss_score": 0.00033, "epss_percentile": 0.09394}, "CVE-2023-21196": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-21197": {"epss_score": 0.00562, "epss_percentile": 0.67705}, "CVE-2023-21198": {"epss_score": 0.00034, "epss_percentile": 0.09481}, "CVE-2023-21199": {"epss_score": 0.00025, "epss_percentile": 0.06143}, "CVE-2023-21200": {"epss_score": 0.00025, "epss_percentile": 0.06163}, "CVE-2023-21201": {"epss_score": 0.01711, "epss_percentile": 0.8188}, "CVE-2023-21202": {"epss_score": 0.00038, "epss_percentile": 0.1116}, "CVE-2023-21203": {"epss_score": 0.00018, "epss_percentile": 0.0362}, "CVE-2023-21204": {"epss_score": 0.00025, "epss_percentile": 0.06143}, "CVE-2023-21205": {"epss_score": 0.00041, "epss_percentile": 0.12462}, "CVE-2023-21206": {"epss_score": 0.00031, "epss_percentile": 0.08325}, "CVE-2023-21207": {"epss_score": 0.00024, "epss_percentile": 0.05801}, "CVE-2023-21208": {"epss_score": 0.00018, "epss_percentile": 0.03958}, "CVE-2023-21209": {"epss_score": 0.00029, "epss_percentile": 0.07936}, "CVE-2023-21210": {"epss_score": 0.00018, "epss_percentile": 0.03958}, "CVE-2023-21211": {"epss_score": 0.00029, "epss_percentile": 0.07904}, "CVE-2023-21212": {"epss_score": 0.0003, "epss_percentile": 0.0802}, "CVE-2023-21213": {"epss_score": 0.0003, "epss_percentile": 0.0802}, "CVE-2023-21214": {"epss_score": 0.00029, "epss_percentile": 0.07898}, "CVE-2023-21215": {"epss_score": 0.00105, "epss_percentile": 0.29305}, "CVE-2023-21216": {"epss_score": 0.00141, "epss_percentile": 0.34951}, "CVE-2023-21217": {"epss_score": 0.00115, "epss_percentile": 0.30972}, "CVE-2023-21218": {"epss_score": 0.00105, "epss_percentile": 0.29305}, "CVE-2023-21219": {"epss_score": 0.0036, "epss_percentile": 0.57633}, "CVE-2023-21220": {"epss_score": 0.0036, "epss_percentile": 0.57633}, "CVE-2023-21222": {"epss_score": 0.00023, "epss_percentile": 0.05372}, "CVE-2023-21223": {"epss_score": 0.00664, "epss_percentile": 0.70641}, "CVE-2023-21224": {"epss_score": 0.00804, "epss_percentile": 0.73625}, "CVE-2023-21225": {"epss_score": 6e-05, "epss_percentile": 0.00291}, "CVE-2023-21226": {"epss_score": 0.00664, "epss_percentile": 0.70641}, "CVE-2023-21227": {"epss_score": 0.00106, "epss_percentile": 0.2956}, "CVE-2023-21228": {"epss_score": 0.00105, "epss_percentile": 0.29305}, "CVE-2023-21229": {"epss_score": 3e-05, "epss_percentile": 0.00099}, "CVE-2023-21230": {"epss_score": 0.0001, "epss_percentile": 0.00835}, "CVE-2023-21231": {"epss_score": 0.00011, "epss_percentile": 0.01032}, "CVE-2023-21232": {"epss_score": 4e-05, "epss_percentile": 0.00173}, "CVE-2023-21233": {"epss_score": 0.00138, "epss_percentile": 0.34419}, "CVE-2023-21234": {"epss_score": 0.00013, "epss_percentile": 0.01589}, "CVE-2023-21235": {"epss_score": 4e-05, "epss_percentile": 0.00136}, "CVE-2023-21236": {"epss_score": 0.00023, "epss_percentile": 0.05372}, "CVE-2023-21237": {"epss_score": 0.00703, "epss_percentile": 0.71548}, "CVE-2023-21238": {"epss_score": 0.00029, "epss_percentile": 0.07733}, "CVE-2023-21239": {"epss_score": 0.00016, "epss_percentile": 0.02826}, "CVE-2023-21240": {"epss_score": 0.00019, "epss_percentile": 0.04278}, "CVE-2023-21241": {"epss_score": 0.00018, "epss_percentile": 0.03556}, "CVE-2023-21242": {"epss_score": 0.00901, "epss_percentile": 0.75175}, "CVE-2023-21243": {"epss_score": 0.00014, "epss_percentile": 0.02078}, "CVE-2023-21244": {"epss_score": 9e-05, "epss_percentile": 0.00724}, "CVE-2023-21245": {"epss_score": 0.00015, "epss_percentile": 0.02545}, "CVE-2023-21246": {"epss_score": 0.00016, "epss_percentile": 0.02961}, "CVE-2023-21247": {"epss_score": 3e-05, "epss_percentile": 0.00097}, "CVE-2023-21248": {"epss_score": 3e-05, "epss_percentile": 0.00097}, "CVE-2023-21249": {"epss_score": 3e-05, "epss_percentile": 0.00079}, "CVE-2023-21250": {"epss_score": 0.00631, "epss_percentile": 0.69732}, "CVE-2023-21251": {"epss_score": 4e-05, "epss_percentile": 0.00148}, "CVE-2023-21252": {"epss_score": 0.00035, "epss_percentile": 0.10121}, "CVE-2023-21253": {"epss_score": 0.00058, "epss_percentile": 0.18578}, "CVE-2023-21254": {"epss_score": 0.00013, "epss_percentile": 0.01619}, "CVE-2023-21255": {"epss_score": 0.00064, "epss_percentile": 0.20138}, "CVE-2023-21256": {"epss_score": 0.00016, "epss_percentile": 0.02985}, "CVE-2023-21257": {"epss_score": 0.00015, "epss_percentile": 0.02545}, "CVE-2023-21260": {"epss_score": 0.00017, "epss_percentile": 0.03056}, "CVE-2023-21262": {"epss_score": 0.0004, "epss_percentile": 0.12137}, "CVE-2023-21263": {"epss_score": 0.00115, "epss_percentile": 0.30972}, "CVE-2023-21264": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2023-21265": {"epss_score": 0.00152, "epss_percentile": 0.36467}, "CVE-2023-21266": {"epss_score": 3e-05, "epss_percentile": 0.00095}, "CVE-2023-21267": {"epss_score": 5e-05, "epss_percentile": 0.00188}, "CVE-2023-21268": {"epss_score": 0.00018, "epss_percentile": 0.03764}, "CVE-2023-21269": {"epss_score": 3e-05, "epss_percentile": 0.00097}, "CVE-2023-21270": {"epss_score": 0.0003, "epss_percentile": 0.08055}, "CVE-2023-21271": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2023-21272": {"epss_score": 0.00014, "epss_percentile": 0.02019}, "CVE-2023-21273": {"epss_score": 0.00032, "epss_percentile": 0.0902}, "CVE-2023-21274": {"epss_score": 0.00024, "epss_percentile": 0.05768}, "CVE-2023-21275": {"epss_score": 3e-05, "epss_percentile": 0.00111}, "CVE-2023-21276": {"epss_score": 0.00016, "epss_percentile": 0.02729}, "CVE-2023-21277": {"epss_score": 0.00018, "epss_percentile": 0.03911}, "CVE-2023-21278": {"epss_score": 0.00025, "epss_percentile": 0.06062}, "CVE-2023-21279": {"epss_score": 0.00018, "epss_percentile": 0.03911}, "CVE-2023-21280": {"epss_score": 0.00019, "epss_percentile": 0.04278}, "CVE-2023-21281": {"epss_score": 0.00016, "epss_percentile": 0.03041}, "CVE-2023-21282": {"epss_score": 0.00953, "epss_percentile": 0.75887}, "CVE-2023-21283": {"epss_score": 0.00021, "epss_percentile": 0.04753}, "CVE-2023-21284": {"epss_score": 0.00022, "epss_percentile": 0.05152}, "CVE-2023-21285": {"epss_score": 0.00033, "epss_percentile": 0.0929}, "CVE-2023-21286": {"epss_score": 0.00016, "epss_percentile": 0.03041}, "CVE-2023-21287": {"epss_score": 0.00562, "epss_percentile": 0.67696}, "CVE-2023-21288": {"epss_score": 0.00077, "epss_percentile": 0.23407}, "CVE-2023-21289": {"epss_score": 4e-05, "epss_percentile": 0.00139}, "CVE-2023-21290": {"epss_score": 3e-05, "epss_percentile": 0.00121}, "CVE-2023-21291": {"epss_score": 0.00019, "epss_percentile": 0.04166}, "CVE-2023-21292": {"epss_score": 0.00018, "epss_percentile": 0.03911}, "CVE-2023-21293": {"epss_score": 0.00017, "epss_percentile": 0.0325}, "CVE-2023-21294": {"epss_score": 0.00017, "epss_percentile": 0.03299}, "CVE-2023-21295": {"epss_score": 0.00019, "epss_percentile": 0.04407}, "CVE-2023-21296": {"epss_score": 0.00014, "epss_percentile": 0.01882}, "CVE-2023-21297": {"epss_score": 3e-05, "epss_percentile": 0.0007}, "CVE-2023-21298": {"epss_score": 0.00016, "epss_percentile": 0.02796}, "CVE-2023-21299": {"epss_score": 0.00015, "epss_percentile": 0.0228}, "CVE-2023-21300": {"epss_score": 0.00018, "epss_percentile": 0.04014}, "CVE-2023-21301": {"epss_score": 0.00015, "epss_percentile": 0.0242}, "CVE-2023-21302": {"epss_score": 0.00015, "epss_percentile": 0.0228}, "CVE-2023-21303": {"epss_score": 0.00017, "epss_percentile": 0.03114}, "CVE-2023-21304": {"epss_score": 0.00017, "epss_percentile": 0.03114}, "CVE-2023-21305": {"epss_score": 0.00019, "epss_percentile": 0.04357}, "CVE-2023-21306": {"epss_score": 0.00019, "epss_percentile": 0.04388}, "CVE-2023-21307": {"epss_score": 4e-05, "epss_percentile": 0.00145}, "CVE-2023-21308": {"epss_score": 0.00022, "epss_percentile": 0.05132}, "CVE-2023-21309": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2023-21310": {"epss_score": 0.00013, "epss_percentile": 0.01511}, "CVE-2023-21311": {"epss_score": 4e-05, "epss_percentile": 0.00132}, "CVE-2023-21312": {"epss_score": 0.00017, "epss_percentile": 0.0309}, "CVE-2023-21313": {"epss_score": 0.00014, "epss_percentile": 0.019}, "CVE-2023-21314": {"epss_score": 0.00014, "epss_percentile": 0.01816}, "CVE-2023-21315": {"epss_score": 0.00051, "epss_percentile": 0.16172}, "CVE-2023-21316": {"epss_score": 0.00015, "epss_percentile": 0.0228}, "CVE-2023-21317": {"epss_score": 0.00015, "epss_percentile": 0.0228}, "CVE-2023-21318": {"epss_score": 0.00015, "epss_percentile": 0.0228}, "CVE-2023-21319": {"epss_score": 0.00017, "epss_percentile": 0.0309}, "CVE-2023-21320": {"epss_score": 0.00017, "epss_percentile": 0.0309}, "CVE-2023-21321": {"epss_score": 0.00028, "epss_percentile": 0.0734}, "CVE-2023-21323": {"epss_score": 0.00027, "epss_percentile": 0.0711}, "CVE-2023-21324": {"epss_score": 0.00026, "epss_percentile": 0.06627}, "CVE-2023-21325": {"epss_score": 0.00027, "epss_percentile": 0.0711}, "CVE-2023-21326": {"epss_score": 0.00026, "epss_percentile": 0.06558}, "CVE-2023-21327": {"epss_score": 0.00026, "epss_percentile": 0.06558}, "CVE-2023-21328": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2023-21329": {"epss_score": 0.00031, "epss_percentile": 0.0868}, "CVE-2023-21330": {"epss_score": 0.00031, "epss_percentile": 0.08417}, "CVE-2023-21331": {"epss_score": 0.00023, "epss_percentile": 0.05373}, "CVE-2023-21332": {"epss_score": 0.00031, "epss_percentile": 0.08417}, "CVE-2023-21333": {"epss_score": 0.00031, "epss_percentile": 0.08417}, "CVE-2023-21334": {"epss_score": 0.00049, "epss_percentile": 0.15353}, "CVE-2023-21335": {"epss_score": 0.00017, "epss_percentile": 0.03132}, "CVE-2023-21336": {"epss_score": 0.00017, "epss_percentile": 0.03132}, "CVE-2023-21337": {"epss_score": 0.00016, "epss_percentile": 0.02849}, "CVE-2023-21338": {"epss_score": 0.00017, "epss_percentile": 0.0325}, "CVE-2023-21339": {"epss_score": 0.02032, "epss_percentile": 0.83336}, "CVE-2023-21340": {"epss_score": 0.00017, "epss_percentile": 0.03299}, "CVE-2023-21341": {"epss_score": 4e-05, "epss_percentile": 0.00141}, "CVE-2023-21342": {"epss_score": 0.00029, "epss_percentile": 0.07947}, "CVE-2023-21343": {"epss_score": 0.0003, "epss_percentile": 0.08233}, "CVE-2023-21344": {"epss_score": 0.00031, "epss_percentile": 0.08417}, "CVE-2023-21345": {"epss_score": 0.00024, "epss_percentile": 0.0584}, "CVE-2023-21346": {"epss_score": 0.00024, "epss_percentile": 0.0584}, "CVE-2023-21347": {"epss_score": 0.00867, "epss_percentile": 0.74648}, "CVE-2023-21348": {"epss_score": 0.00015, "epss_percentile": 0.02599}, "CVE-2023-21349": {"epss_score": 0.00031, "epss_percentile": 0.08645}, "CVE-2023-21350": {"epss_score": 0.00017, "epss_percentile": 0.03182}, "CVE-2023-21351": {"epss_score": 0.00019, "epss_percentile": 0.0423}, "CVE-2023-21352": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2023-21353": {"epss_score": 0.00607, "epss_percentile": 0.69059}, "CVE-2023-21354": {"epss_score": 0.00018, "epss_percentile": 0.04014}, "CVE-2023-21355": {"epss_score": 0.0002, "epss_percentile": 0.04599}, "CVE-2023-21356": {"epss_score": 0.0004, "epss_percentile": 0.12073}, "CVE-2023-21357": {"epss_score": 0.00014, "epss_percentile": 0.01963}, "CVE-2023-21358": {"epss_score": 0.00016, "epss_percentile": 0.02914}, "CVE-2023-21359": {"epss_score": 9e-05, "epss_percentile": 0.00693}, "CVE-2023-21360": {"epss_score": 7e-05, "epss_percentile": 0.00413}, "CVE-2023-21361": {"epss_score": 0.00048, "epss_percentile": 0.15051}, "CVE-2023-21362": {"epss_score": 0.0002, "epss_percentile": 0.04581}, "CVE-2023-21364": {"epss_score": 0.00024, "epss_percentile": 0.0567}, "CVE-2023-21365": {"epss_score": 0.00017, "epss_percentile": 0.03493}, "CVE-2023-21366": {"epss_score": 0.00013, "epss_percentile": 0.01676}, "CVE-2023-21367": {"epss_score": 0.00015, "epss_percentile": 0.02602}, "CVE-2023-21368": {"epss_score": 0.00028, "epss_percentile": 0.07358}, "CVE-2023-21369": {"epss_score": 5e-05, "epss_percentile": 0.00191}, "CVE-2023-21370": {"epss_score": 0.00011, "epss_percentile": 0.0097}, "CVE-2023-21371": {"epss_score": 0.00011, "epss_percentile": 0.0097}, "CVE-2023-21372": {"epss_score": 0.00027, "epss_percentile": 0.06897}, "CVE-2023-21373": {"epss_score": 0.00014, "epss_percentile": 0.019}, "CVE-2023-21374": {"epss_score": 5e-05, "epss_percentile": 0.00198}, "CVE-2023-21375": {"epss_score": 0.00022, "epss_percentile": 0.05153}, "CVE-2023-21376": {"epss_score": 0.0002, "epss_percentile": 0.04482}, "CVE-2023-21377": {"epss_score": 5e-05, "epss_percentile": 0.00209}, "CVE-2023-21378": {"epss_score": 0.00026, "epss_percentile": 0.06591}, "CVE-2023-21379": {"epss_score": 0.00014, "epss_percentile": 0.01762}, "CVE-2023-21380": {"epss_score": 0.00022, "epss_percentile": 0.04999}, "CVE-2023-21381": {"epss_score": 0.00023, "epss_percentile": 0.05649}, "CVE-2023-21382": {"epss_score": 0.00019, "epss_percentile": 0.04166}, "CVE-2023-21383": {"epss_score": 0.00021, "epss_percentile": 0.0473}, "CVE-2023-21384": {"epss_score": 4e-05, "epss_percentile": 0.00158}, "CVE-2023-21385": {"epss_score": 0.00052, "epss_percentile": 0.16462}, "CVE-2023-21387": {"epss_score": 6e-05, "epss_percentile": 0.00285}, "CVE-2023-21388": {"epss_score": 9e-05, "epss_percentile": 0.00687}, "CVE-2023-21389": {"epss_score": 9e-05, "epss_percentile": 0.00687}, "CVE-2023-21390": {"epss_score": 9e-05, "epss_percentile": 0.00687}, "CVE-2023-21391": {"epss_score": 0.00866, "epss_percentile": 0.74629}, "CVE-2023-21392": {"epss_score": 0.00056, "epss_percentile": 0.17963}, "CVE-2023-21393": {"epss_score": 0.00039, "epss_percentile": 0.11778}, "CVE-2023-21394": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2023-21395": {"epss_score": 0.00716, "epss_percentile": 0.71867}, "CVE-2023-21396": {"epss_score": 0.00041, "epss_percentile": 0.12311}, "CVE-2023-21397": {"epss_score": 0.0003, "epss_percentile": 0.08233}, "CVE-2023-21398": {"epss_score": 0.00061, "epss_percentile": 0.19457}, "CVE-2023-21399": {"epss_score": 3e-05, "epss_percentile": 0.00063}, "CVE-2023-21400": {"epss_score": 0.00036, "epss_percentile": 0.10376}, "CVE-2023-21401": {"epss_score": 0.00105, "epss_percentile": 0.29305}, "CVE-2023-21402": {"epss_score": 0.00111, "epss_percentile": 0.3028}, "CVE-2023-21403": {"epss_score": 0.00105, "epss_percentile": 0.29305}, "CVE-2023-21404": {"epss_score": 0.00126, "epss_percentile": 0.32666}, "CVE-2023-21405": {"epss_score": 0.00069, "epss_percentile": 0.2143}, "CVE-2023-21406": {"epss_score": 0.00084, "epss_percentile": 0.24849}, "CVE-2023-21407": {"epss_score": 0.00239, "epss_percentile": 0.46892}, "CVE-2023-21408": {"epss_score": 0.00102, "epss_percentile": 0.28847}, "CVE-2023-21409": {"epss_score": 0.00134, "epss_percentile": 0.33823}, "CVE-2023-21410": {"epss_score": 0.00171, "epss_percentile": 0.38855}, "CVE-2023-21411": {"epss_score": 0.00171, "epss_percentile": 0.38855}, "CVE-2023-21412": {"epss_score": 0.00156, "epss_percentile": 0.37}, "CVE-2023-21413": {"epss_score": 0.00695, "epss_percentile": 0.71376}, "CVE-2023-21414": {"epss_score": 0.00012, "epss_percentile": 0.01134}, "CVE-2023-21415": {"epss_score": 0.00133, "epss_percentile": 0.33746}, "CVE-2023-21416": {"epss_score": 0.00115, "epss_percentile": 0.30892}, "CVE-2023-21417": {"epss_score": 0.00193, "epss_percentile": 0.41398}, "CVE-2023-21418": {"epss_score": 0.00165, "epss_percentile": 0.38118}, "CVE-2023-21419": {"epss_score": 0.00075, "epss_percentile": 0.22919}, "CVE-2023-21420": {"epss_score": 0.00122, "epss_percentile": 0.32091}, "CVE-2023-21421": {"epss_score": 0.00046, "epss_percentile": 0.14087}, "CVE-2023-21422": {"epss_score": 0.00062, "epss_percentile": 0.19614}, "CVE-2023-21423": {"epss_score": 0.00062, "epss_percentile": 0.19614}, "CVE-2023-21424": {"epss_score": 0.00036, "epss_percentile": 0.10345}, "CVE-2023-21425": {"epss_score": 0.00075, "epss_percentile": 0.22919}, "CVE-2023-21426": {"epss_score": 0.00102, "epss_percentile": 0.28719}, "CVE-2023-21427": {"epss_score": 0.00067, "epss_percentile": 0.21147}, "CVE-2023-21428": {"epss_score": 0.00041, "epss_percentile": 0.12249}, "CVE-2023-21429": {"epss_score": 0.00117, "epss_percentile": 0.31341}, "CVE-2023-21430": {"epss_score": 0.00052, "epss_percentile": 0.16461}, "CVE-2023-21431": {"epss_score": 0.00096, "epss_percentile": 0.27409}, "CVE-2023-21432": {"epss_score": 0.00048, "epss_percentile": 0.15182}, "CVE-2023-21433": {"epss_score": 0.02737, "epss_percentile": 0.85552}, "CVE-2023-21434": {"epss_score": 0.11422, "epss_percentile": 0.93344}, "CVE-2023-21435": {"epss_score": 0.00066, "epss_percentile": 0.20694}, "CVE-2023-21436": {"epss_score": 0.00105, "epss_percentile": 0.29267}, "CVE-2023-21437": {"epss_score": 0.00067, "epss_percentile": 0.21014}, "CVE-2023-21438": {"epss_score": 0.00087, "epss_percentile": 0.25486}, "CVE-2023-21439": {"epss_score": 0.00052, "epss_percentile": 0.16461}, "CVE-2023-21440": {"epss_score": 0.00096, "epss_percentile": 0.27398}, "CVE-2023-21441": {"epss_score": 0.00049, "epss_percentile": 0.15506}, "CVE-2023-21442": {"epss_score": 0.00063, "epss_percentile": 0.20097}, "CVE-2023-21443": {"epss_score": 0.00064, "epss_percentile": 0.2033}, "CVE-2023-21444": {"epss_score": 0.00064, "epss_percentile": 0.2033}, "CVE-2023-21445": {"epss_score": 0.00042, "epss_percentile": 0.12704}, "CVE-2023-21446": {"epss_score": 0.00047, "epss_percentile": 0.14645}, "CVE-2023-21447": {"epss_score": 0.00054, "epss_percentile": 0.17199}, "CVE-2023-21448": {"epss_score": 0.00104, "epss_percentile": 0.292}, "CVE-2023-21449": {"epss_score": 0.00066, "epss_percentile": 0.20938}, "CVE-2023-21450": {"epss_score": 0.00128, "epss_percentile": 0.33001}, "CVE-2023-21451": {"epss_score": 0.00046, "epss_percentile": 0.14318}, "CVE-2023-21452": {"epss_score": 0.00093, "epss_percentile": 0.2673}, "CVE-2023-21453": {"epss_score": 0.00028, "epss_percentile": 0.07566}, "CVE-2023-21454": {"epss_score": 0.0012, "epss_percentile": 0.31733}, "CVE-2023-21455": {"epss_score": 0.00237, "epss_percentile": 0.46689}, "CVE-2023-21456": {"epss_score": 0.00129, "epss_percentile": 0.33188}, "CVE-2023-21457": {"epss_score": 0.00042, "epss_percentile": 0.12733}, "CVE-2023-21458": {"epss_score": 0.00061, "epss_percentile": 0.19499}, "CVE-2023-21459": {"epss_score": 0.00085, "epss_percentile": 0.25052}, "CVE-2023-21460": {"epss_score": 0.00045, "epss_percentile": 0.13886}, "CVE-2023-21461": {"epss_score": 0.00043, "epss_percentile": 0.13226}, "CVE-2023-21462": {"epss_score": 0.00044, "epss_percentile": 0.13424}, "CVE-2023-21463": {"epss_score": 0.00069, "epss_percentile": 0.2148}, "CVE-2023-21464": {"epss_score": 0.00044, "epss_percentile": 0.13522}, "CVE-2023-21465": {"epss_score": 0.00074, "epss_percentile": 0.22677}, "CVE-2023-21466": {"epss_score": 0.00014, "epss_percentile": 0.02082}, "CVE-2023-21467": {"epss_score": 0.00095, "epss_percentile": 0.27097}, "CVE-2023-21468": {"epss_score": 0.00023, "epss_percentile": 0.05458}, "CVE-2023-21469": {"epss_score": 0.00026, "epss_percentile": 0.06567}, "CVE-2023-21470": {"epss_score": 0.00026, "epss_percentile": 0.06567}, "CVE-2023-21471": {"epss_score": 0.00026, "epss_percentile": 0.06567}, "CVE-2023-21472": {"epss_score": 0.00083, "epss_percentile": 0.24723}, "CVE-2023-21473": {"epss_score": 0.00083, "epss_percentile": 0.24723}, "CVE-2023-21474": {"epss_score": 0.00022, "epss_percentile": 0.0503}, "CVE-2023-21475": {"epss_score": 0.00026, "epss_percentile": 0.06564}, "CVE-2023-21476": {"epss_score": 0.00026, "epss_percentile": 0.06564}, "CVE-2023-21477": {"epss_score": 0.00021, "epss_percentile": 0.04744}, "CVE-2023-21478": {"epss_score": 0.00031, "epss_percentile": 0.08591}, "CVE-2023-21479": {"epss_score": 0.00108, "epss_percentile": 0.29774}, "CVE-2023-21480": {"epss_score": 0.0005, "epss_percentile": 0.15733}, "CVE-2023-21481": {"epss_score": 0.00097, "epss_percentile": 0.27623}, "CVE-2023-21482": {"epss_score": 0.00027, "epss_percentile": 0.07084}, "CVE-2023-21483": {"epss_score": 0.00021, "epss_percentile": 0.04726}, "CVE-2023-21484": {"epss_score": 0.00027, "epss_percentile": 0.07156}, "CVE-2023-21485": {"epss_score": 0.00072, "epss_percentile": 0.22343}, "CVE-2023-21486": {"epss_score": 0.00072, "epss_percentile": 0.22343}, "CVE-2023-21487": {"epss_score": 0.00032, "epss_percentile": 0.09077}, "CVE-2023-21488": {"epss_score": 0.00027, "epss_percentile": 0.07156}, "CVE-2023-21489": {"epss_score": 0.00083, "epss_percentile": 0.24701}, "CVE-2023-21490": {"epss_score": 0.00031, "epss_percentile": 0.08442}, "CVE-2023-21491": {"epss_score": 0.00041, "epss_percentile": 0.12331}, "CVE-2023-21492": {"epss_score": 0.0022, "epss_percentile": 0.44614}, "CVE-2023-21493": {"epss_score": 0.00048, "epss_percentile": 0.15141}, "CVE-2023-21494": {"epss_score": 0.00784, "epss_percentile": 0.73235}, "CVE-2023-21495": {"epss_score": 0.0004, "epss_percentile": 0.11966}, "CVE-2023-21496": {"epss_score": 0.00072, "epss_percentile": 0.22351}, "CVE-2023-21497": {"epss_score": 0.00034, "epss_percentile": 0.09703}, "CVE-2023-21498": {"epss_score": 0.00026, "epss_percentile": 0.06416}, "CVE-2023-21499": {"epss_score": 0.00032, "epss_percentile": 0.08745}, "CVE-2023-21500": {"epss_score": 0.00026, "epss_percentile": 0.06424}, "CVE-2023-21501": {"epss_score": 0.00023, "epss_percentile": 0.05612}, "CVE-2023-21502": {"epss_score": 0.00038, "epss_percentile": 0.11424}, "CVE-2023-21503": {"epss_score": 0.00571, "epss_percentile": 0.67983}, "CVE-2023-21504": {"epss_score": 0.00571, "epss_percentile": 0.67983}, "CVE-2023-21505": {"epss_score": 0.00114, "epss_percentile": 0.30773}, "CVE-2023-21506": {"epss_score": 0.00032, "epss_percentile": 0.08745}, "CVE-2023-21507": {"epss_score": 0.00035, "epss_percentile": 0.09884}, "CVE-2023-21508": {"epss_score": 0.00032, "epss_percentile": 0.08745}, "CVE-2023-21509": {"epss_score": 0.00032, "epss_percentile": 0.08745}, "CVE-2023-21510": {"epss_score": 0.00035, "epss_percentile": 0.09884}, "CVE-2023-21511": {"epss_score": 0.00035, "epss_percentile": 0.09884}, "CVE-2023-21512": {"epss_score": 0.00072, "epss_percentile": 0.22467}, "CVE-2023-21513": {"epss_score": 0.00156, "epss_percentile": 0.36889}, "CVE-2023-21514": {"epss_score": 0.00135, "epss_percentile": 0.3394}, "CVE-2023-21515": {"epss_score": 0.00183, "epss_percentile": 0.40306}, "CVE-2023-21516": {"epss_score": 0.00362, "epss_percentile": 0.57813}, "CVE-2023-21517": {"epss_score": 0.06943, "epss_percentile": 0.91132}, "CVE-2023-21518": {"epss_score": 0.00112, "epss_percentile": 0.30576}, "CVE-2023-21520": {"epss_score": 0.00176, "epss_percentile": 0.39457}, "CVE-2023-21521": {"epss_score": 0.00457, "epss_percentile": 0.63387}, "CVE-2023-21522": {"epss_score": 0.00941, "epss_percentile": 0.75751}, "CVE-2023-21523": {"epss_score": 0.00471, "epss_percentile": 0.64005}, "CVE-2023-21524": {"epss_score": 0.00403, "epss_percentile": 0.60324}, "CVE-2023-21525": {"epss_score": 0.00569, "epss_percentile": 0.67915}, "CVE-2023-21526": {"epss_score": 0.00759, "epss_percentile": 0.72783}, "CVE-2023-21527": {"epss_score": 0.04824, "epss_percentile": 0.89181}, "CVE-2023-21528": {"epss_score": 0.00123, "epss_percentile": 0.32207}, "CVE-2023-21529": {"epss_score": 0.24748, "epss_percentile": 0.95951}, "CVE-2023-21531": {"epss_score": 0.00144, "epss_percentile": 0.35229}, "CVE-2023-21532": {"epss_score": 0.00194, "epss_percentile": 0.41525}, "CVE-2023-21535": {"epss_score": 0.00132, "epss_percentile": 0.33527}, "CVE-2023-21536": {"epss_score": 0.00211, "epss_percentile": 0.43671}, "CVE-2023-21537": {"epss_score": 0.00163, "epss_percentile": 0.37831}, "CVE-2023-21538": {"epss_score": 0.00556, "epss_percentile": 0.67519}, "CVE-2023-21539": {"epss_score": 0.00713, "epss_percentile": 0.71784}, "CVE-2023-21540": {"epss_score": 0.01529, "epss_percentile": 0.80877}, "CVE-2023-21541": {"epss_score": 0.00225, "epss_percentile": 0.45148}, "CVE-2023-21542": {"epss_score": 0.00312, "epss_percentile": 0.53947}, "CVE-2023-21543": {"epss_score": 0.01809, "epss_percentile": 0.82358}, "CVE-2023-21546": {"epss_score": 0.00185, "epss_percentile": 0.40517}, "CVE-2023-21547": {"epss_score": 0.04364, "epss_percentile": 0.886}, "CVE-2023-21548": {"epss_score": 0.00151, "epss_percentile": 0.3632}, "CVE-2023-21549": {"epss_score": 0.02377, "epss_percentile": 0.84554}, "CVE-2023-21550": {"epss_score": 0.01529, "epss_percentile": 0.80877}, "CVE-2023-21551": {"epss_score": 0.0009, "epss_percentile": 0.25997}, "CVE-2023-21552": {"epss_score": 0.01602, "epss_percentile": 0.81268}, "CVE-2023-21553": {"epss_score": 0.00401, "epss_percentile": 0.60247}, "CVE-2023-21554": {"epss_score": 0.92162, "epss_percentile": 0.99695}, "CVE-2023-21555": {"epss_score": 0.00185, "epss_percentile": 0.40517}, "CVE-2023-21556": {"epss_score": 0.00747, "epss_percentile": 0.72563}, "CVE-2023-21557": {"epss_score": 0.00843, "epss_percentile": 0.74259}, "CVE-2023-21558": {"epss_score": 0.00223, "epss_percentile": 0.44867}, "CVE-2023-21559": {"epss_score": 0.01529, "epss_percentile": 0.80877}, "CVE-2023-21560": {"epss_score": 0.00728, "epss_percentile": 0.72112}, "CVE-2023-21561": {"epss_score": 0.00261, "epss_percentile": 0.49314}, "CVE-2023-21563": {"epss_score": 0.00461, "epss_percentile": 0.63547}, "CVE-2023-21564": {"epss_score": 0.01367, "epss_percentile": 0.79786}, "CVE-2023-21565": {"epss_score": 0.02059, "epss_percentile": 0.83434}, "CVE-2023-21566": {"epss_score": 0.0057, "epss_percentile": 0.67956}, "CVE-2023-21567": {"epss_score": 0.00391, "epss_percentile": 0.59642}, "CVE-2023-21568": {"epss_score": 0.00119, "epss_percentile": 0.31583}, "CVE-2023-21569": {"epss_score": 0.00279, "epss_percentile": 0.50969}, "CVE-2023-21570": {"epss_score": 0.0025, "epss_percentile": 0.481}, "CVE-2023-21571": {"epss_score": 0.0025, "epss_percentile": 0.481}, "CVE-2023-21572": {"epss_score": 0.00254, "epss_percentile": 0.48572}, "CVE-2023-21573": {"epss_score": 0.0025, "epss_percentile": 0.481}, "CVE-2023-21574": {"epss_score": 0.00093, "epss_percentile": 0.26647}, "CVE-2023-21575": {"epss_score": 0.00126, "epss_percentile": 0.32722}, "CVE-2023-21576": {"epss_score": 0.00126, "epss_percentile": 0.32722}, "CVE-2023-21577": {"epss_score": 0.00025, "epss_percentile": 0.06166}, "CVE-2023-21578": {"epss_score": 0.00025, "epss_percentile": 0.06166}, "CVE-2023-21579": {"epss_score": 0.01671, "epss_percentile": 0.81674}, "CVE-2023-21581": {"epss_score": 0.00084, "epss_percentile": 0.2492}, "CVE-2023-21582": {"epss_score": 0.0015, "epss_percentile": 0.36126}, "CVE-2023-21583": {"epss_score": 0.00025, "epss_percentile": 0.06166}, "CVE-2023-21584": {"epss_score": 0.00034, "epss_percentile": 0.0953}, "CVE-2023-21585": {"epss_score": 0.00084, "epss_percentile": 0.2492}, "CVE-2023-21586": {"epss_score": 0.01417, "epss_percentile": 0.80152}, "CVE-2023-21587": {"epss_score": 0.00244, "epss_percentile": 0.47565}, "CVE-2023-21588": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2023-21589": {"epss_score": 0.00187, "epss_percentile": 0.40749}, "CVE-2023-21590": {"epss_score": 0.00187, "epss_percentile": 0.40749}, "CVE-2023-21591": {"epss_score": 0.00026, "epss_percentile": 0.06442}, "CVE-2023-21592": {"epss_score": 0.00026, "epss_percentile": 0.06442}, "CVE-2023-21593": {"epss_score": 0.00131, "epss_percentile": 0.33351}, "CVE-2023-21594": {"epss_score": 0.0028, "epss_percentile": 0.51094}, "CVE-2023-21595": {"epss_score": 0.00187, "epss_percentile": 0.40749}, "CVE-2023-21596": {"epss_score": 0.00158, "epss_percentile": 0.37236}, "CVE-2023-21597": {"epss_score": 0.00215, "epss_percentile": 0.44073}, "CVE-2023-21598": {"epss_score": 0.00036, "epss_percentile": 0.10234}, "CVE-2023-21599": {"epss_score": 0.00028, "epss_percentile": 0.07272}, "CVE-2023-21601": {"epss_score": 0.00038, "epss_percentile": 0.11196}, "CVE-2023-21603": {"epss_score": 0.00031, "epss_percentile": 0.0857}, "CVE-2023-21604": {"epss_score": 0.02653, "epss_percentile": 0.85349}, "CVE-2023-21605": {"epss_score": 0.02653, "epss_percentile": 0.85349}, "CVE-2023-21606": {"epss_score": 0.01745, "epss_percentile": 0.82066}, "CVE-2023-21607": {"epss_score": 0.00404, "epss_percentile": 0.60435}, "CVE-2023-21608": {"epss_score": 0.85043, "epss_percentile": 0.99314}, "CVE-2023-21609": {"epss_score": 0.02051, "epss_percentile": 0.83402}, "CVE-2023-21610": {"epss_score": 0.02855, "epss_percentile": 0.85837}, "CVE-2023-21611": {"epss_score": 0.00106, "epss_percentile": 0.29552}, "CVE-2023-21612": {"epss_score": 0.00106, "epss_percentile": 0.29552}, "CVE-2023-21613": {"epss_score": 0.00064, "epss_percentile": 0.20396}, "CVE-2023-21614": {"epss_score": 0.00058, "epss_percentile": 0.18361}, "CVE-2023-21615": {"epss_score": 0.01156, "epss_percentile": 0.78104}, "CVE-2023-21616": {"epss_score": 0.01806, "epss_percentile": 0.82349}, "CVE-2023-21618": {"epss_score": 0.00069, "epss_percentile": 0.21551}, "CVE-2023-21619": {"epss_score": 0.00126, "epss_percentile": 0.32722}, "CVE-2023-21620": {"epss_score": 0.00025, "epss_percentile": 0.06166}, "CVE-2023-21621": {"epss_score": 0.00067, "epss_percentile": 0.20969}, "CVE-2023-21622": {"epss_score": 0.00126, "epss_percentile": 0.32722}, "CVE-2023-21624": {"epss_score": 0.0004, "epss_percentile": 0.11928}, "CVE-2023-21625": {"epss_score": 0.00074, "epss_percentile": 0.22678}, "CVE-2023-21626": {"epss_score": 0.0005, "epss_percentile": 0.15768}, "CVE-2023-21627": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2023-21628": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-21629": {"epss_score": 0.00073, "epss_percentile": 0.22573}, "CVE-2023-21630": {"epss_score": 0.00067, "epss_percentile": 0.21052}, "CVE-2023-21631": {"epss_score": 0.00074, "epss_percentile": 0.22811}, "CVE-2023-21632": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-21633": {"epss_score": 0.00029, "epss_percentile": 0.07827}, "CVE-2023-21634": {"epss_score": 0.0004, "epss_percentile": 0.12192}, "CVE-2023-21635": {"epss_score": 0.00029, "epss_percentile": 0.07827}, "CVE-2023-21636": {"epss_score": 0.00021, "epss_percentile": 0.04849}, "CVE-2023-21637": {"epss_score": 0.00029, "epss_percentile": 0.07827}, "CVE-2023-21638": {"epss_score": 0.00034, "epss_percentile": 0.09649}, "CVE-2023-21639": {"epss_score": 0.00029, "epss_percentile": 0.07827}, "CVE-2023-21640": {"epss_score": 0.00029, "epss_percentile": 0.07827}, "CVE-2023-21641": {"epss_score": 0.00032, "epss_percentile": 0.09069}, "CVE-2023-21642": {"epss_score": 0.00051, "epss_percentile": 0.16181}, "CVE-2023-21643": {"epss_score": 0.00067, "epss_percentile": 0.21156}, "CVE-2023-21644": {"epss_score": 0.0002, "epss_percentile": 0.04626}, "CVE-2023-21646": {"epss_score": 0.00087, "epss_percentile": 0.25479}, "CVE-2023-21647": {"epss_score": 0.00203, "epss_percentile": 0.42516}, "CVE-2023-21648": {"epss_score": 0.00036, "epss_percentile": 0.10399}, "CVE-2023-21649": {"epss_score": 0.00034, "epss_percentile": 0.09762}, "CVE-2023-21650": {"epss_score": 0.00036, "epss_percentile": 0.10399}, "CVE-2023-21651": {"epss_score": 0.00052, "epss_percentile": 0.16458}, "CVE-2023-21652": {"epss_score": 0.00047, "epss_percentile": 0.14581}, "CVE-2023-21653": {"epss_score": 0.00087, "epss_percentile": 0.25479}, "CVE-2023-21654": {"epss_score": 0.0002, "epss_percentile": 0.04503}, "CVE-2023-21655": {"epss_score": 0.0002, "epss_percentile": 0.04626}, "CVE-2023-21656": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-21657": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2023-21658": {"epss_score": 0.00123, "epss_percentile": 0.32301}, "CVE-2023-21659": {"epss_score": 0.00122, "epss_percentile": 0.32067}, "CVE-2023-21660": {"epss_score": 0.00158, "epss_percentile": 0.37222}, "CVE-2023-21661": {"epss_score": 0.00158, "epss_percentile": 0.37222}, "CVE-2023-21662": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-21663": {"epss_score": 0.0002, "epss_percentile": 0.04503}, "CVE-2023-21664": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-21665": {"epss_score": 0.0007, "epss_percentile": 0.21951}, "CVE-2023-21666": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2023-21667": {"epss_score": 0.00066, "epss_percentile": 0.20752}, "CVE-2023-21669": {"epss_score": 0.0008, "epss_percentile": 0.24137}, "CVE-2023-21670": {"epss_score": 0.00046, "epss_percentile": 0.1436}, "CVE-2023-21671": {"epss_score": 0.00062, "epss_percentile": 0.19568}, "CVE-2023-21672": {"epss_score": 0.00045, "epss_percentile": 0.13977}, "CVE-2023-21673": {"epss_score": 0.00024, "epss_percentile": 0.06029}, "CVE-2023-21674": {"epss_score": 0.12848, "epss_percentile": 0.93802}, "CVE-2023-21675": {"epss_score": 0.0025, "epss_percentile": 0.48251}, "CVE-2023-21676": {"epss_score": 0.03996, "epss_percentile": 0.88084}, "CVE-2023-21677": {"epss_score": 0.0292, "epss_percentile": 0.85991}, "CVE-2023-21678": {"epss_score": 0.00292, "epss_percentile": 0.52231}, "CVE-2023-21679": {"epss_score": 0.00177, "epss_percentile": 0.39518}, "CVE-2023-21680": {"epss_score": 0.00154, "epss_percentile": 0.36673}, "CVE-2023-21681": {"epss_score": 0.00327, "epss_percentile": 0.55095}, "CVE-2023-21682": {"epss_score": 0.02185, "epss_percentile": 0.83916}, "CVE-2023-21683": {"epss_score": 0.06434, "epss_percentile": 0.90755}, "CVE-2023-21684": {"epss_score": 0.03007, "epss_percentile": 0.86186}, "CVE-2023-21685": {"epss_score": 0.01328, "epss_percentile": 0.79495}, "CVE-2023-21686": {"epss_score": 0.00354, "epss_percentile": 0.57241}, "CVE-2023-21687": {"epss_score": 0.00414, "epss_percentile": 0.61041}, "CVE-2023-21688": {"epss_score": 0.02385, "epss_percentile": 0.84577}, "CVE-2023-21689": {"epss_score": 0.27658, "epss_percentile": 0.9627}, "CVE-2023-21690": {"epss_score": 0.21014, "epss_percentile": 0.95451}, "CVE-2023-21691": {"epss_score": 0.0104, "epss_percentile": 0.76953}, "CVE-2023-21692": {"epss_score": 0.30476, "epss_percentile": 0.96543}, "CVE-2023-21693": {"epss_score": 0.00711, "epss_percentile": 0.71744}, "CVE-2023-21694": {"epss_score": 0.00131, "epss_percentile": 0.33357}, "CVE-2023-21695": {"epss_score": 0.01011, "epss_percentile": 0.76609}, "CVE-2023-21697": {"epss_score": 0.00344, "epss_percentile": 0.56497}, "CVE-2023-21699": {"epss_score": 0.01195, "epss_percentile": 0.78432}, "CVE-2023-21700": {"epss_score": 0.05916, "epss_percentile": 0.90319}, "CVE-2023-21701": {"epss_score": 0.01129, "epss_percentile": 0.77841}, "CVE-2023-21702": {"epss_score": 0.03142, "epss_percentile": 0.8649}, "CVE-2023-21703": {"epss_score": 0.00212, "epss_percentile": 0.43748}, "CVE-2023-21704": {"epss_score": 0.00313, "epss_percentile": 0.54075}, "CVE-2023-21705": {"epss_score": 0.00611, "epss_percentile": 0.69199}, "CVE-2023-21706": {"epss_score": 0.00599, "epss_percentile": 0.68793}, "CVE-2023-21707": {"epss_score": 0.6344, "epss_percentile": 0.98334}, "CVE-2023-21708": {"epss_score": 0.04475, "epss_percentile": 0.88738}, "CVE-2023-21709": {"epss_score": 0.03581, "epss_percentile": 0.87385}, "CVE-2023-21710": {"epss_score": 0.0069, "epss_percentile": 0.71243}, "CVE-2023-21712": {"epss_score": 0.00616, "epss_percentile": 0.69326}, "CVE-2023-21713": {"epss_score": 0.00376, "epss_percentile": 0.58652}, "CVE-2023-21714": {"epss_score": 0.00311, "epss_percentile": 0.53927}, "CVE-2023-21715": {"epss_score": 0.0101, "epss_percentile": 0.76604}, "CVE-2023-21716": {"epss_score": 0.91148, "epss_percentile": 0.99622}, "CVE-2023-21717": {"epss_score": 0.01845, "epss_percentile": 0.82509}, "CVE-2023-21718": {"epss_score": 0.00441, "epss_percentile": 0.62657}, "CVE-2023-21719": {"epss_score": 0.0239, "epss_percentile": 0.84599}, "CVE-2023-21720": {"epss_score": 0.0023, "epss_percentile": 0.45729}, "CVE-2023-21721": {"epss_score": 0.01624, "epss_percentile": 0.81414}, "CVE-2023-21722": {"epss_score": 0.00342, "epss_percentile": 0.56381}, "CVE-2023-21724": {"epss_score": 0.00141, "epss_percentile": 0.34864}, "CVE-2023-21725": {"epss_score": 0.00105, "epss_percentile": 0.29335}, "CVE-2023-21726": {"epss_score": 0.00103, "epss_percentile": 0.29081}, "CVE-2023-21727": {"epss_score": 0.02516, "epss_percentile": 0.84988}, "CVE-2023-21728": {"epss_score": 0.00419, "epss_percentile": 0.6137}, "CVE-2023-21729": {"epss_score": 0.01321, "epss_percentile": 0.79446}, "CVE-2023-21730": {"epss_score": 0.00307, "epss_percentile": 0.53567}, "CVE-2023-21732": {"epss_score": 0.01139, "epss_percentile": 0.77941}, "CVE-2023-21733": {"epss_score": 0.00118, "epss_percentile": 0.31412}, "CVE-2023-21734": {"epss_score": 0.00789, "epss_percentile": 0.73352}, "CVE-2023-21735": {"epss_score": 0.00357, "epss_percentile": 0.57436}, "CVE-2023-21736": {"epss_score": 0.00402, "epss_percentile": 0.6027}, "CVE-2023-21737": {"epss_score": 0.01053, "epss_percentile": 0.77099}, "CVE-2023-21738": {"epss_score": 0.00862, "epss_percentile": 0.74572}, "CVE-2023-21739": {"epss_score": 0.00146, "epss_percentile": 0.35538}, "CVE-2023-21740": {"epss_score": 0.00353, "epss_percentile": 0.57145}, "CVE-2023-21741": {"epss_score": 0.00969, "epss_percentile": 0.76097}, "CVE-2023-21742": {"epss_score": 0.17021, "epss_percentile": 0.94761}, "CVE-2023-21743": {"epss_score": 0.02457, "epss_percentile": 0.84803}, "CVE-2023-21744": {"epss_score": 0.0831, "epss_percentile": 0.91984}, "CVE-2023-21745": {"epss_score": 0.00153, "epss_percentile": 0.36631}, "CVE-2023-21746": {"epss_score": 0.52622, "epss_percentile": 0.97833}, "CVE-2023-21747": {"epss_score": 0.00216, "epss_percentile": 0.44141}, "CVE-2023-21748": {"epss_score": 0.00316, "epss_percentile": 0.54222}, "CVE-2023-21749": {"epss_score": 0.00405, "epss_percentile": 0.60461}, "CVE-2023-21750": {"epss_score": 0.0051, "epss_percentile": 0.65797}, "CVE-2023-21751": {"epss_score": 0.00248, "epss_percentile": 0.47912}, "CVE-2023-21752": {"epss_score": 0.47313, "epss_percentile": 0.97581}, "CVE-2023-21753": {"epss_score": 0.00878, "epss_percentile": 0.74831}, "CVE-2023-21754": {"epss_score": 0.00554, "epss_percentile": 0.67438}, "CVE-2023-21755": {"epss_score": 0.00618, "epss_percentile": 0.69372}, "CVE-2023-21756": {"epss_score": 0.00124, "epss_percentile": 0.3236}, "CVE-2023-21757": {"epss_score": 0.05507, "epss_percentile": 0.89944}, "CVE-2023-21758": {"epss_score": 0.52964, "epss_percentile": 0.97848}, "CVE-2023-21759": {"epss_score": 0.00867, "epss_percentile": 0.74657}, "CVE-2023-21760": {"epss_score": 0.00207, "epss_percentile": 0.43196}, "CVE-2023-21761": {"epss_score": 0.03462, "epss_percentile": 0.87184}, "CVE-2023-21762": {"epss_score": 0.00153, "epss_percentile": 0.36631}, "CVE-2023-21763": {"epss_score": 0.0034, "epss_percentile": 0.56236}, "CVE-2023-21764": {"epss_score": 0.00278, "epss_percentile": 0.50861}, "CVE-2023-21765": {"epss_score": 0.00677, "epss_percentile": 0.70952}, "CVE-2023-21766": {"epss_score": 0.04369, "epss_percentile": 0.88606}, "CVE-2023-21767": {"epss_score": 0.00223, "epss_percentile": 0.44867}, "CVE-2023-21768": {"epss_score": 0.71808, "epss_percentile": 0.98681}, "CVE-2023-21769": {"epss_score": 0.49652, "epss_percentile": 0.97699}, "CVE-2023-21771": {"epss_score": 0.00164, "epss_percentile": 0.37867}, "CVE-2023-21772": {"epss_score": 0.00489, "epss_percentile": 0.64906}, "CVE-2023-21773": {"epss_score": 0.00627, "epss_percentile": 0.6963}, "CVE-2023-21774": {"epss_score": 0.00489, "epss_percentile": 0.64906}, "CVE-2023-21775": {"epss_score": 0.00159, "epss_percentile": 0.37342}, "CVE-2023-21776": {"epss_score": 0.0054, "epss_percentile": 0.67015}, "CVE-2023-21777": {"epss_score": 0.00153, "epss_percentile": 0.36564}, "CVE-2023-21778": {"epss_score": 0.00236, "epss_percentile": 0.46453}, "CVE-2023-21779": {"epss_score": 0.0038, "epss_percentile": 0.58943}, "CVE-2023-21780": {"epss_score": 0.01169, "epss_percentile": 0.78201}, "CVE-2023-21781": {"epss_score": 0.01267, "epss_percentile": 0.79019}, "CVE-2023-21782": {"epss_score": 0.01267, "epss_percentile": 0.79019}, "CVE-2023-21783": {"epss_score": 0.0095, "epss_percentile": 0.75851}, "CVE-2023-21784": {"epss_score": 0.01267, "epss_percentile": 0.79019}, "CVE-2023-21785": {"epss_score": 0.00622, "epss_percentile": 0.69504}, "CVE-2023-21786": {"epss_score": 0.01267, "epss_percentile": 0.79019}, "CVE-2023-21787": {"epss_score": 0.00622, "epss_percentile": 0.69504}, "CVE-2023-21788": {"epss_score": 0.00423, "epss_percentile": 0.61587}, "CVE-2023-21789": {"epss_score": 0.00622, "epss_percentile": 0.69495}, "CVE-2023-21790": {"epss_score": 0.01267, "epss_percentile": 0.79019}, "CVE-2023-21791": {"epss_score": 0.01267, "epss_percentile": 0.79019}, "CVE-2023-21792": {"epss_score": 0.01267, "epss_percentile": 0.79019}, "CVE-2023-21793": {"epss_score": 0.01267, "epss_percentile": 0.79019}, "CVE-2023-21794": {"epss_score": 0.00244, "epss_percentile": 0.47575}, "CVE-2023-21795": {"epss_score": 0.00196, "epss_percentile": 0.4179}, "CVE-2023-21796": {"epss_score": 0.00159, "epss_percentile": 0.37342}, "CVE-2023-21797": {"epss_score": 0.00354, "epss_percentile": 0.57241}, "CVE-2023-21798": {"epss_score": 0.00446, "epss_percentile": 0.62934}, "CVE-2023-21799": {"epss_score": 0.00228, "epss_percentile": 0.45469}, "CVE-2023-21800": {"epss_score": 0.0062, "epss_percentile": 0.69445}, "CVE-2023-21801": {"epss_score": 0.00119, "epss_percentile": 0.31663}, "CVE-2023-21802": {"epss_score": 0.00441, "epss_percentile": 0.62657}, "CVE-2023-21803": {"epss_score": 0.02671, "epss_percentile": 0.85388}, "CVE-2023-21804": {"epss_score": 0.00123, "epss_percentile": 0.32207}, "CVE-2023-21805": {"epss_score": 0.00285, "epss_percentile": 0.51651}, "CVE-2023-21806": {"epss_score": 0.0023, "epss_percentile": 0.45728}, "CVE-2023-21807": {"epss_score": 0.00235, "epss_percentile": 0.46229}, "CVE-2023-21808": {"epss_score": 0.01139, "epss_percentile": 0.7794}, "CVE-2023-21809": {"epss_score": 0.00276, "epss_percentile": 0.50735}, "CVE-2023-21811": {"epss_score": 0.03142, "epss_percentile": 0.8649}, "CVE-2023-21812": {"epss_score": 0.02979, "epss_percentile": 0.86115}, "CVE-2023-21813": {"epss_score": 0.03142, "epss_percentile": 0.8649}, "CVE-2023-21815": {"epss_score": 0.00351, "epss_percentile": 0.57055}, "CVE-2023-21816": {"epss_score": 0.05313, "epss_percentile": 0.89719}, "CVE-2023-21817": {"epss_score": 0.0073, "epss_percentile": 0.72156}, "CVE-2023-21818": {"epss_score": 0.25713, "epss_percentile": 0.96058}, "CVE-2023-21819": {"epss_score": 0.34974, "epss_percentile": 0.9688}, "CVE-2023-21820": {"epss_score": 0.01107, "epss_percentile": 0.77627}, "CVE-2023-21822": {"epss_score": 0.00767, "epss_percentile": 0.72959}, "CVE-2023-21823": {"epss_score": 0.06669, "epss_percentile": 0.90932}, "CVE-2023-21824": {"epss_score": 0.00086, "epss_percentile": 0.25435}, "CVE-2023-21825": {"epss_score": 0.00348, "epss_percentile": 0.56844}, "CVE-2023-21826": {"epss_score": 0.00356, "epss_percentile": 0.57388}, "CVE-2023-21827": {"epss_score": 0.00362, "epss_percentile": 0.57794}, "CVE-2023-21828": {"epss_score": 0.00663, "epss_percentile": 0.70614}, "CVE-2023-21829": {"epss_score": 0.0038, "epss_percentile": 0.58959}, "CVE-2023-21830": {"epss_score": 0.00095, "epss_percentile": 0.27189}, "CVE-2023-21831": {"epss_score": 0.00348, "epss_percentile": 0.56844}, "CVE-2023-21832": {"epss_score": 0.01068, "epss_percentile": 0.77236}, "CVE-2023-21833": {"epss_score": 0.00271, "epss_percentile": 0.50336}, "CVE-2023-21834": {"epss_score": 0.00192, "epss_percentile": 0.41308}, "CVE-2023-21835": {"epss_score": 0.00044, "epss_percentile": 0.13583}, "CVE-2023-21836": {"epss_score": 0.00113, "epss_percentile": 0.30634}, "CVE-2023-21837": {"epss_score": 0.00789, "epss_percentile": 0.73362}, "CVE-2023-21838": {"epss_score": 0.00426, "epss_percentile": 0.61736}, "CVE-2023-21839": {"epss_score": 0.94175, "epss_percentile": 0.99912}, "CVE-2023-21840": {"epss_score": 0.0011, "epss_percentile": 0.30115}, "CVE-2023-21841": {"epss_score": 0.00789, "epss_percentile": 0.73362}, "CVE-2023-21842": {"epss_score": 0.00789, "epss_percentile": 0.73362}, "CVE-2023-21843": {"epss_score": 0.00092, "epss_percentile": 0.26519}, "CVE-2023-21844": {"epss_score": 0.00288, "epss_percentile": 0.51877}, "CVE-2023-21845": {"epss_score": 0.00288, "epss_percentile": 0.51877}, "CVE-2023-21846": {"epss_score": 0.00819, "epss_percentile": 0.73866}, "CVE-2023-21847": {"epss_score": 0.00288, "epss_percentile": 0.51877}, "CVE-2023-21848": {"epss_score": 0.00819, "epss_percentile": 0.73866}, "CVE-2023-21849": {"epss_score": 0.00424, "epss_percentile": 0.61681}, "CVE-2023-21850": {"epss_score": 0.00262, "epss_percentile": 0.49388}, "CVE-2023-21851": {"epss_score": 0.00193, "epss_percentile": 0.41421}, "CVE-2023-21852": {"epss_score": 0.00193, "epss_percentile": 0.41421}, "CVE-2023-21853": {"epss_score": 0.00262, "epss_percentile": 0.49388}, "CVE-2023-21854": {"epss_score": 0.00193, "epss_percentile": 0.41421}, "CVE-2023-21855": {"epss_score": 0.00193, "epss_percentile": 0.41421}, "CVE-2023-21856": {"epss_score": 0.00193, "epss_percentile": 0.41421}, "CVE-2023-21857": {"epss_score": 0.00193, "epss_percentile": 0.41421}, "CVE-2023-21858": {"epss_score": 0.0018, "epss_percentile": 0.39864}, "CVE-2023-21859": {"epss_score": 0.00086, "epss_percentile": 0.25435}, "CVE-2023-21860": {"epss_score": 0.0025, "epss_percentile": 0.48126}, "CVE-2023-21861": {"epss_score": 0.00288, "epss_percentile": 0.51877}, "CVE-2023-21862": {"epss_score": 0.00785, "epss_percentile": 0.73247}, "CVE-2023-21863": {"epss_score": 0.0008, "epss_percentile": 0.24088}, "CVE-2023-21864": {"epss_score": 0.0008, "epss_percentile": 0.24088}, "CVE-2023-21865": {"epss_score": 0.00083, "epss_percentile": 0.24731}, "CVE-2023-21866": {"epss_score": 0.00181, "epss_percentile": 0.401}, "CVE-2023-21867": {"epss_score": 0.00083, "epss_percentile": 0.24731}, "CVE-2023-21868": {"epss_score": 0.00113, "epss_percentile": 0.30666}, "CVE-2023-21869": {"epss_score": 0.00084, "epss_percentile": 0.24962}, "CVE-2023-21870": {"epss_score": 0.00083, "epss_percentile": 0.24731}, "CVE-2023-21871": {"epss_score": 0.0008, "epss_percentile": 0.24088}, "CVE-2023-21872": {"epss_score": 0.00177, "epss_percentile": 0.39532}, "CVE-2023-21873": {"epss_score": 0.0008, "epss_percentile": 0.24088}, "CVE-2023-21874": {"epss_score": 0.00043, "epss_percentile": 0.13312}, "CVE-2023-21875": {"epss_score": 0.00155, "epss_percentile": 0.36859}, "CVE-2023-21876": {"epss_score": 0.00115, "epss_percentile": 0.30997}, "CVE-2023-21877": {"epss_score": 0.00112, "epss_percentile": 0.30572}, "CVE-2023-21878": {"epss_score": 0.00111, "epss_percentile": 0.303}, "CVE-2023-21879": {"epss_score": 0.00115, "epss_percentile": 0.30997}, "CVE-2023-21880": {"epss_score": 0.00084, "epss_percentile": 0.24862}, "CVE-2023-21881": {"epss_score": 0.00086, "epss_percentile": 0.25301}, "CVE-2023-21882": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2023-21883": {"epss_score": 0.00082, "epss_percentile": 0.24589}, "CVE-2023-21884": {"epss_score": 0.00033, "epss_percentile": 0.09322}, "CVE-2023-21885": {"epss_score": 0.00063, "epss_percentile": 0.19992}, "CVE-2023-21886": {"epss_score": 0.00789, "epss_percentile": 0.73346}, "CVE-2023-21887": {"epss_score": 0.49353, "epss_percentile": 0.9768}, "CVE-2023-21888": {"epss_score": 0.0029, "epss_percentile": 0.52122}, "CVE-2023-21889": {"epss_score": 0.00063, "epss_percentile": 0.19992}, "CVE-2023-21890": {"epss_score": 0.01008, "epss_percentile": 0.76566}, "CVE-2023-21891": {"epss_score": 0.00288, "epss_percentile": 0.51877}, "CVE-2023-21892": {"epss_score": 0.00376, "epss_percentile": 0.58665}, "CVE-2023-21893": {"epss_score": 0.01065, "epss_percentile": 0.77214}, "CVE-2023-21894": {"epss_score": 0.0016, "epss_percentile": 0.37446}, "CVE-2023-21896": {"epss_score": 0.00128, "epss_percentile": 0.3304}, "CVE-2023-21898": {"epss_score": 0.00045, "epss_percentile": 0.13887}, "CVE-2023-21899": {"epss_score": 0.00045, "epss_percentile": 0.13887}, "CVE-2023-21900": {"epss_score": 0.00074, "epss_percentile": 0.22692}, "CVE-2023-21901": {"epss_score": 0.00168, "epss_percentile": 0.38444}, "CVE-2023-21902": {"epss_score": 0.00431, "epss_percentile": 0.6209}, "CVE-2023-21903": {"epss_score": 0.00173, "epss_percentile": 0.39055}, "CVE-2023-21904": {"epss_score": 0.00173, "epss_percentile": 0.39055}, "CVE-2023-21905": {"epss_score": 0.0072, "epss_percentile": 0.71958}, "CVE-2023-21906": {"epss_score": 0.00706, "epss_percentile": 0.71613}, "CVE-2023-21907": {"epss_score": 0.00331, "epss_percentile": 0.55534}, "CVE-2023-21908": {"epss_score": 0.00331, "epss_percentile": 0.55534}, "CVE-2023-21909": {"epss_score": 0.00305, "epss_percentile": 0.53329}, "CVE-2023-21910": {"epss_score": 0.00305, "epss_percentile": 0.53329}, "CVE-2023-21911": {"epss_score": 0.0011, "epss_percentile": 0.30189}, "CVE-2023-21912": {"epss_score": 0.0014, "epss_percentile": 0.34734}, "CVE-2023-21913": {"epss_score": 0.00165, "epss_percentile": 0.38112}, "CVE-2023-21915": {"epss_score": 0.00343, "epss_percentile": 0.56425}, "CVE-2023-21916": {"epss_score": 0.00415, "epss_percentile": 0.61122}, "CVE-2023-21917": {"epss_score": 0.00145, "epss_percentile": 0.3546}, "CVE-2023-21918": {"epss_score": 0.00129, "epss_percentile": 0.33092}, "CVE-2023-21919": {"epss_score": 0.0011, "epss_percentile": 0.30189}, "CVE-2023-21920": {"epss_score": 0.0011, "epss_percentile": 0.30189}, "CVE-2023-21921": {"epss_score": 0.00343, "epss_percentile": 0.56425}, "CVE-2023-21922": {"epss_score": 0.00731, "epss_percentile": 0.72173}, "CVE-2023-21923": {"epss_score": 0.00541, "epss_percentile": 0.6706}, "CVE-2023-21924": {"epss_score": 0.00132, "epss_percentile": 0.33506}, "CVE-2023-21925": {"epss_score": 0.00163, "epss_percentile": 0.37832}, "CVE-2023-21926": {"epss_score": 0.00242, "epss_percentile": 0.47337}, "CVE-2023-21927": {"epss_score": 0.00453, "epss_percentile": 0.63227}, "CVE-2023-21928": {"epss_score": 0.00064, "epss_percentile": 0.20292}, "CVE-2023-21929": {"epss_score": 0.00129, "epss_percentile": 0.33141}, "CVE-2023-21930": {"epss_score": 0.00145, "epss_percentile": 0.35441}, "CVE-2023-21931": {"epss_score": 0.84922, "epss_percentile": 0.99311}, "CVE-2023-21932": {"epss_score": 0.20266, "epss_percentile": 0.9531}, "CVE-2023-21933": {"epss_score": 0.00112, "epss_percentile": 0.30487}, "CVE-2023-21934": {"epss_score": 0.00381, "epss_percentile": 0.59021}, "CVE-2023-21935": {"epss_score": 0.00112, "epss_percentile": 0.30487}, "CVE-2023-21936": {"epss_score": 0.0036, "epss_percentile": 0.57666}, "CVE-2023-21937": {"epss_score": 0.00075, "epss_percentile": 0.23038}, "CVE-2023-21938": {"epss_score": 0.00075, "epss_percentile": 0.23038}, "CVE-2023-21939": {"epss_score": 0.01746, "epss_percentile": 0.82072}, "CVE-2023-21940": {"epss_score": 0.00112, "epss_percentile": 0.30487}, "CVE-2023-21941": {"epss_score": 0.00271, "epss_percentile": 0.50336}, "CVE-2023-21942": {"epss_score": 0.00293, "epss_percentile": 0.52325}, "CVE-2023-21943": {"epss_score": 0.00293, "epss_percentile": 0.52325}, "CVE-2023-21944": {"epss_score": 0.00293, "epss_percentile": 0.52325}, "CVE-2023-21945": {"epss_score": 0.00112, "epss_percentile": 0.30487}, "CVE-2023-21946": {"epss_score": 0.00204, "epss_percentile": 0.42618}, "CVE-2023-21947": {"epss_score": 0.0011, "epss_percentile": 0.30189}, "CVE-2023-21948": {"epss_score": 0.00258, "epss_percentile": 0.48984}, "CVE-2023-21949": {"epss_score": 0.00138, "epss_percentile": 0.34464}, "CVE-2023-21950": {"epss_score": 0.00158, "epss_percentile": 0.37218}, "CVE-2023-21952": {"epss_score": 0.00305, "epss_percentile": 0.53329}, "CVE-2023-21953": {"epss_score": 0.0011, "epss_percentile": 0.30189}, "CVE-2023-21954": {"epss_score": 0.00042, "epss_percentile": 0.12912}, "CVE-2023-21955": {"epss_score": 0.00112, "epss_percentile": 0.30487}, "CVE-2023-21956": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2023-21959": {"epss_score": 0.00271, "epss_percentile": 0.50336}, "CVE-2023-21960": {"epss_score": 0.00213, "epss_percentile": 0.43829}, "CVE-2023-21961": {"epss_score": 0.00067, "epss_percentile": 0.20982}, "CVE-2023-21962": {"epss_score": 0.00112, "epss_percentile": 0.30487}, "CVE-2023-21963": {"epss_score": 0.00065, "epss_percentile": 0.2057}, "CVE-2023-21964": {"epss_score": 0.00507, "epss_percentile": 0.65655}, "CVE-2023-21965": {"epss_score": 0.00305, "epss_percentile": 0.53329}, "CVE-2023-21966": {"epss_score": 0.00039, "epss_percentile": 0.11698}, "CVE-2023-21967": {"epss_score": 0.00061, "epss_percentile": 0.19352}, "CVE-2023-21968": {"epss_score": 0.00069, "epss_percentile": 0.2149}, "CVE-2023-21969": {"epss_score": 0.00161, "epss_percentile": 0.3752}, "CVE-2023-21970": {"epss_score": 0.00305, "epss_percentile": 0.53329}, "CVE-2023-21971": {"epss_score": 0.00134, "epss_percentile": 0.33766}, "CVE-2023-21972": {"epss_score": 0.0004, "epss_percentile": 0.1203}, "CVE-2023-21973": {"epss_score": 0.00215, "epss_percentile": 0.44123}, "CVE-2023-21974": {"epss_score": 0.00519, "epss_percentile": 0.66171}, "CVE-2023-21975": {"epss_score": 0.00519, "epss_percentile": 0.66171}, "CVE-2023-21976": {"epss_score": 0.00045, "epss_percentile": 0.14042}, "CVE-2023-21977": {"epss_score": 0.00048, "epss_percentile": 0.14946}, "CVE-2023-21978": {"epss_score": 0.00113, "epss_percentile": 0.30601}, "CVE-2023-21979": {"epss_score": 0.00618, "epss_percentile": 0.69369}, "CVE-2023-21980": {"epss_score": 0.00319, "epss_percentile": 0.54553}, "CVE-2023-21981": {"epss_score": 0.00437, "epss_percentile": 0.62506}, "CVE-2023-21982": {"epss_score": 0.0004, "epss_percentile": 0.1203}, "CVE-2023-21983": {"epss_score": 0.00134, "epss_percentile": 0.33766}, "CVE-2023-21984": {"epss_score": 0.00226, "epss_percentile": 0.45327}, "CVE-2023-21985": {"epss_score": 0.00144, "epss_percentile": 0.35255}, "CVE-2023-21986": {"epss_score": 0.00091, "epss_percentile": 0.26375}, "CVE-2023-21987": {"epss_score": 0.07135, "epss_percentile": 0.91273}, "CVE-2023-21988": {"epss_score": 0.00062, "epss_percentile": 0.19746}, "CVE-2023-21989": {"epss_score": 0.00062, "epss_percentile": 0.19582}, "CVE-2023-21990": {"epss_score": 0.00065, "epss_percentile": 0.20514}, "CVE-2023-21991": {"epss_score": 0.00046, "epss_percentile": 0.14165}, "CVE-2023-21992": {"epss_score": 0.0036, "epss_percentile": 0.57666}, "CVE-2023-21993": {"epss_score": 0.00566, "epss_percentile": 0.67812}, "CVE-2023-21994": {"epss_score": 0.00128, "epss_percentile": 0.3306}, "CVE-2023-21996": {"epss_score": 0.00507, "epss_percentile": 0.65655}, "CVE-2023-21997": {"epss_score": 0.00271, "epss_percentile": 0.50336}, "CVE-2023-21998": {"epss_score": 0.00032, "epss_percentile": 0.08863}, "CVE-2023-21999": {"epss_score": 0.00049, "epss_percentile": 0.1565}, "CVE-2023-22000": {"epss_score": 0.00036, "epss_percentile": 0.10547}, "CVE-2023-22001": {"epss_score": 0.00035, "epss_percentile": 0.09993}, "CVE-2023-22002": {"epss_score": 0.00064, "epss_percentile": 0.20296}, "CVE-2023-22003": {"epss_score": 0.00089, "epss_percentile": 0.25961}, "CVE-2023-22004": {"epss_score": 0.00168, "epss_percentile": 0.38475}, "CVE-2023-22005": {"epss_score": 0.0004, "epss_percentile": 0.12064}, "CVE-2023-22006": {"epss_score": 0.00123, "epss_percentile": 0.32269}, "CVE-2023-22007": {"epss_score": 0.00043, "epss_percentile": 0.13328}, "CVE-2023-22008": {"epss_score": 0.00041, "epss_percentile": 0.1227}, "CVE-2023-22009": {"epss_score": 0.00271, "epss_percentile": 0.50336}, "CVE-2023-22010": {"epss_score": 0.00182, "epss_percentile": 0.40188}, "CVE-2023-22011": {"epss_score": 0.00093, "epss_percentile": 0.26631}, "CVE-2023-22012": {"epss_score": 0.00144, "epss_percentile": 0.35242}, "CVE-2023-22013": {"epss_score": 0.00144, "epss_percentile": 0.35242}, "CVE-2023-22014": {"epss_score": 0.00106, "epss_percentile": 0.29487}, "CVE-2023-22015": {"epss_score": 0.00138, "epss_percentile": 0.34522}, "CVE-2023-22016": {"epss_score": 0.0004, "epss_percentile": 0.12007}, "CVE-2023-22017": {"epss_score": 0.0006, "epss_percentile": 0.18934}, "CVE-2023-22018": {"epss_score": 0.00577, "epss_percentile": 0.68149}, "CVE-2023-22019": {"epss_score": 0.00269, "epss_percentile": 0.50111}, "CVE-2023-22020": {"epss_score": 0.00215, "epss_percentile": 0.44123}, "CVE-2023-22021": {"epss_score": 0.00091, "epss_percentile": 0.26379}, "CVE-2023-22022": {"epss_score": 0.00305, "epss_percentile": 0.53329}, "CVE-2023-22023": {"epss_score": 0.00128, "epss_percentile": 0.3304}, "CVE-2023-22024": {"epss_score": 0.00023, "epss_percentile": 0.05474}, "CVE-2023-22025": {"epss_score": 0.0014, "epss_percentile": 0.34668}, "CVE-2023-22026": {"epss_score": 0.0014, "epss_percentile": 0.34735}, "CVE-2023-22027": {"epss_score": 0.00091, "epss_percentile": 0.26379}, "CVE-2023-22028": {"epss_score": 0.00118, "epss_percentile": 0.31514}, "CVE-2023-22029": {"epss_score": 0.00106, "epss_percentile": 0.29483}, "CVE-2023-22031": {"epss_score": 0.00117, "epss_percentile": 0.31351}, "CVE-2023-22032": {"epss_score": 0.00124, "epss_percentile": 0.32417}, "CVE-2023-22033": {"epss_score": 0.00041, "epss_percentile": 0.1227}, "CVE-2023-22034": {"epss_score": 0.00127, "epss_percentile": 0.32897}, "CVE-2023-22035": {"epss_score": 0.00362, "epss_percentile": 0.57789}, "CVE-2023-22036": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-22037": {"epss_score": 0.00113, "epss_percentile": 0.30601}, "CVE-2023-22038": {"epss_score": 0.00033, "epss_percentile": 0.09424}, "CVE-2023-22039": {"epss_score": 0.00215, "epss_percentile": 0.44123}, "CVE-2023-22040": {"epss_score": 0.00157, "epss_percentile": 0.37133}, "CVE-2023-22041": {"epss_score": 0.00058, "epss_percentile": 0.18364}, "CVE-2023-22042": {"epss_score": 0.00247, "epss_percentile": 0.47857}, "CVE-2023-22043": {"epss_score": 0.00249, "epss_percentile": 0.48084}, "CVE-2023-22044": {"epss_score": 0.00122, "epss_percentile": 0.32105}, "CVE-2023-22045": {"epss_score": 0.00121, "epss_percentile": 0.32003}, "CVE-2023-22046": {"epss_score": 0.00041, "epss_percentile": 0.1227}, "CVE-2023-22047": {"epss_score": 0.91427, "epss_percentile": 0.99643}, "CVE-2023-22048": {"epss_score": 0.00079, "epss_percentile": 0.23999}, "CVE-2023-22049": {"epss_score": 0.00071, "epss_percentile": 0.22216}, "CVE-2023-22050": {"epss_score": 0.00182, "epss_percentile": 0.40258}, "CVE-2023-22051": {"epss_score": 0.00207, "epss_percentile": 0.43116}, "CVE-2023-22052": {"epss_score": 0.00122, "epss_percentile": 0.3202}, "CVE-2023-22053": {"epss_score": 0.00071, "epss_percentile": 0.22162}, "CVE-2023-22054": {"epss_score": 0.0004, "epss_percentile": 0.12064}, "CVE-2023-22055": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2023-22056": {"epss_score": 0.00137, "epss_percentile": 0.34318}, "CVE-2023-22057": {"epss_score": 0.00052, "epss_percentile": 0.16564}, "CVE-2023-22058": {"epss_score": 0.00137, "epss_percentile": 0.34318}, "CVE-2023-22059": {"epss_score": 0.00252, "epss_percentile": 0.48361}, "CVE-2023-22060": {"epss_score": 0.00229, "epss_percentile": 0.45639}, "CVE-2023-22061": {"epss_score": 0.00182, "epss_percentile": 0.40258}, "CVE-2023-22062": {"epss_score": 0.00196, "epss_percentile": 0.4182}, "CVE-2023-22064": {"epss_score": 0.00067, "epss_percentile": 0.21132}, "CVE-2023-22065": {"epss_score": 0.00067, "epss_percentile": 0.21132}, "CVE-2023-22066": {"epss_score": 0.00067, "epss_percentile": 0.21132}, "CVE-2023-22067": {"epss_score": 0.00172, "epss_percentile": 0.39013}, "CVE-2023-22068": {"epss_score": 0.00027, "epss_percentile": 0.06889}, "CVE-2023-22069": {"epss_score": 0.005, "epss_percentile": 0.65302}, "CVE-2023-22070": {"epss_score": 0.00067, "epss_percentile": 0.21132}, "CVE-2023-22071": {"epss_score": 0.00052, "epss_percentile": 0.16362}, "CVE-2023-22072": {"epss_score": 0.00661, "epss_percentile": 0.70584}, "CVE-2023-22073": {"epss_score": 0.00067, "epss_percentile": 0.21084}, "CVE-2023-22074": {"epss_score": 0.00059, "epss_percentile": 0.18807}, "CVE-2023-22075": {"epss_score": 0.00048, "epss_percentile": 0.15099}, "CVE-2023-22076": {"epss_score": 0.0019, "epss_percentile": 0.41089}, "CVE-2023-22077": {"epss_score": 0.00033, "epss_percentile": 0.09384}, "CVE-2023-22078": {"epss_score": 0.00027, "epss_percentile": 0.06889}, "CVE-2023-22079": {"epss_score": 0.00136, "epss_percentile": 0.34176}, "CVE-2023-22080": {"epss_score": 0.00192, "epss_percentile": 0.41287}, "CVE-2023-22081": {"epss_score": 0.00097, "epss_percentile": 0.2746}, "CVE-2023-22082": {"epss_score": 0.00176, "epss_percentile": 0.39389}, "CVE-2023-22083": {"epss_score": 0.00144, "epss_percentile": 0.35325}, "CVE-2023-22084": {"epss_score": 0.01255, "epss_percentile": 0.78928}, "CVE-2023-22085": {"epss_score": 0.0043, "epss_percentile": 0.62028}, "CVE-2023-22086": {"epss_score": 0.00293, "epss_percentile": 0.52325}, "CVE-2023-22087": {"epss_score": 0.00439, "epss_percentile": 0.6259}, "CVE-2023-22088": {"epss_score": 0.00133, "epss_percentile": 0.33739}, "CVE-2023-22089": {"epss_score": 0.00465, "epss_percentile": 0.63769}, "CVE-2023-22090": {"epss_score": 0.0015, "epss_percentile": 0.36086}, "CVE-2023-22091": {"epss_score": 0.00207, "epss_percentile": 0.43168}, "CVE-2023-22092": {"epss_score": 0.00067, "epss_percentile": 0.21132}, "CVE-2023-22093": {"epss_score": 0.00106, "epss_percentile": 0.29483}, "CVE-2023-22094": {"epss_score": 0.00065, "epss_percentile": 0.20539}, "CVE-2023-22095": {"epss_score": 0.00125, "epss_percentile": 0.32577}, "CVE-2023-22096": {"epss_score": 0.00117, "epss_percentile": 0.31302}, "CVE-2023-22097": {"epss_score": 0.00067, "epss_percentile": 0.21132}, "CVE-2023-22098": {"epss_score": 0.03423, "epss_percentile": 0.87106}, "CVE-2023-22099": {"epss_score": 0.00081, "epss_percentile": 0.24352}, "CVE-2023-22100": {"epss_score": 0.00144, "epss_percentile": 0.35316}, "CVE-2023-22101": {"epss_score": 0.00279, "epss_percentile": 0.50995}, "CVE-2023-22102": {"epss_score": 0.02816, "epss_percentile": 0.85735}, "CVE-2023-22103": {"epss_score": 0.00067, "epss_percentile": 0.21132}, "CVE-2023-22104": {"epss_score": 0.00027, "epss_percentile": 0.06889}, "CVE-2023-22105": {"epss_score": 0.00098, "epss_percentile": 0.27747}, "CVE-2023-22106": {"epss_score": 0.0015, "epss_percentile": 0.36086}, "CVE-2023-22107": {"epss_score": 0.00106, "epss_percentile": 0.29483}, "CVE-2023-22108": {"epss_score": 0.00269, "epss_percentile": 0.50111}, "CVE-2023-22109": {"epss_score": 0.00098, "epss_percentile": 0.27747}, "CVE-2023-22110": {"epss_score": 0.00067, "epss_percentile": 0.21132}, "CVE-2023-22111": {"epss_score": 0.00067, "epss_percentile": 0.21132}, "CVE-2023-22112": {"epss_score": 0.00067, "epss_percentile": 0.21132}, "CVE-2023-22113": {"epss_score": 0.00025, "epss_percentile": 0.06136}, "CVE-2023-22114": {"epss_score": 0.00067, "epss_percentile": 0.21132}, "CVE-2023-22115": {"epss_score": 0.00067, "epss_percentile": 0.21132}, "CVE-2023-22117": {"epss_score": 0.00098, "epss_percentile": 0.27747}, "CVE-2023-22118": {"epss_score": 0.00071, "epss_percentile": 0.22048}, "CVE-2023-22119": {"epss_score": 0.00079, "epss_percentile": 0.23996}, "CVE-2023-22121": {"epss_score": 0.00106, "epss_percentile": 0.29483}, "CVE-2023-22122": {"epss_score": 0.0008, "epss_percentile": 0.24133}, "CVE-2023-22123": {"epss_score": 0.00176, "epss_percentile": 0.39389}, "CVE-2023-22124": {"epss_score": 0.00176, "epss_percentile": 0.39389}, "CVE-2023-22125": {"epss_score": 0.00176, "epss_percentile": 0.39389}, "CVE-2023-22126": {"epss_score": 0.00144, "epss_percentile": 0.35325}, "CVE-2023-22127": {"epss_score": 0.00093, "epss_percentile": 0.26724}, "CVE-2023-22128": {"epss_score": 0.00337, "epss_percentile": 0.56035}, "CVE-2023-22129": {"epss_score": 0.00034, "epss_percentile": 0.09484}, "CVE-2023-22130": {"epss_score": 0.00077, "epss_percentile": 0.23356}, "CVE-2023-22226": {"epss_score": 0.00164, "epss_percentile": 0.38002}, "CVE-2023-22227": {"epss_score": 0.00126, "epss_percentile": 0.32722}, "CVE-2023-22228": {"epss_score": 0.00121, "epss_percentile": 0.31915}, "CVE-2023-22229": {"epss_score": 0.00164, "epss_percentile": 0.37991}, "CVE-2023-22230": {"epss_score": 0.00126, "epss_percentile": 0.32722}, "CVE-2023-22231": {"epss_score": 0.00028, "epss_percentile": 0.07272}, "CVE-2023-22232": {"epss_score": 0.88427, "epss_percentile": 0.99472}, "CVE-2023-22233": {"epss_score": 0.00028, "epss_percentile": 0.07272}, "CVE-2023-22234": {"epss_score": 0.00203, "epss_percentile": 0.42529}, "CVE-2023-22235": {"epss_score": 0.0024, "epss_percentile": 0.47187}, "CVE-2023-22236": {"epss_score": 0.00214, "epss_percentile": 0.44017}, "CVE-2023-22237": {"epss_score": 0.00164, "epss_percentile": 0.37991}, "CVE-2023-22238": {"epss_score": 0.00164, "epss_percentile": 0.37991}, "CVE-2023-22239": {"epss_score": 0.00098, "epss_percentile": 0.27742}, "CVE-2023-22240": {"epss_score": 0.00329, "epss_percentile": 0.55406}, "CVE-2023-22241": {"epss_score": 0.00329, "epss_percentile": 0.55406}, "CVE-2023-22242": {"epss_score": 0.00834, "epss_percentile": 0.74098}, "CVE-2023-22243": {"epss_score": 0.00214, "epss_percentile": 0.44017}, "CVE-2023-22244": {"epss_score": 0.00304, "epss_percentile": 0.53296}, "CVE-2023-22246": {"epss_score": 0.00304, "epss_percentile": 0.53296}, "CVE-2023-22247": {"epss_score": 0.00919, "epss_percentile": 0.75459}, "CVE-2023-22248": {"epss_score": 0.00145, "epss_percentile": 0.35361}, "CVE-2023-22249": {"epss_score": 0.18138, "epss_percentile": 0.94962}, "CVE-2023-22250": {"epss_score": 0.00048, "epss_percentile": 0.15237}, "CVE-2023-22251": {"epss_score": 0.00278, "epss_percentile": 0.50848}, "CVE-2023-22252": {"epss_score": 0.0122, "epss_percentile": 0.78621}, "CVE-2023-22253": {"epss_score": 0.0122, "epss_percentile": 0.78621}, "CVE-2023-22254": {"epss_score": 0.01156, "epss_percentile": 0.78104}, "CVE-2023-22256": {"epss_score": 0.00417, "epss_percentile": 0.61243}, "CVE-2023-22257": {"epss_score": 0.0044, "epss_percentile": 0.62638}, "CVE-2023-22258": {"epss_score": 0.0044, "epss_percentile": 0.62638}, "CVE-2023-22259": {"epss_score": 0.0044, "epss_percentile": 0.62638}, "CVE-2023-22260": {"epss_score": 0.00417, "epss_percentile": 0.61243}, "CVE-2023-22261": {"epss_score": 0.00417, "epss_percentile": 0.61243}, "CVE-2023-22262": {"epss_score": 0.00417, "epss_percentile": 0.61243}, "CVE-2023-22263": {"epss_score": 0.0044, "epss_percentile": 0.62638}, "CVE-2023-22264": {"epss_score": 0.00417, "epss_percentile": 0.61243}, "CVE-2023-22265": {"epss_score": 0.00417, "epss_percentile": 0.61243}, "CVE-2023-22266": {"epss_score": 0.00417, "epss_percentile": 0.61243}, "CVE-2023-22268": {"epss_score": 0.00325, "epss_percentile": 0.55003}, "CVE-2023-22269": {"epss_score": 0.01156, "epss_percentile": 0.78104}, "CVE-2023-22271": {"epss_score": 0.00063, "epss_percentile": 0.1989}, "CVE-2023-22272": {"epss_score": 0.00353, "epss_percentile": 0.57193}, "CVE-2023-22273": {"epss_score": 0.03037, "epss_percentile": 0.86264}, "CVE-2023-22274": {"epss_score": 0.00215, "epss_percentile": 0.44102}, "CVE-2023-22275": {"epss_score": 0.00403, "epss_percentile": 0.60384}, "CVE-2023-22276": {"epss_score": 0.00029, "epss_percentile": 0.07976}, "CVE-2023-22277": {"epss_score": 0.00044, "epss_percentile": 0.13464}, "CVE-2023-22278": {"epss_score": 0.00179, "epss_percentile": 0.39838}, "CVE-2023-22279": {"epss_score": 0.01104, "epss_percentile": 0.77598}, "CVE-2023-22280": {"epss_score": 0.00612, "epss_percentile": 0.69227}, "CVE-2023-22281": {"epss_score": 0.00484, "epss_percentile": 0.64654}, "CVE-2023-22282": {"epss_score": 0.00059, "epss_percentile": 0.18813}, "CVE-2023-22283": {"epss_score": 0.00088, "epss_percentile": 0.25704}, "CVE-2023-22285": {"epss_score": 0.00207, "epss_percentile": 0.43207}, "CVE-2023-22286": {"epss_score": 0.00371, "epss_percentile": 0.58353}, "CVE-2023-22288": {"epss_score": 0.00639, "epss_percentile": 0.69953}, "CVE-2023-22290": {"epss_score": 0.00171, "epss_percentile": 0.38768}, "CVE-2023-22291": {"epss_score": 0.0008, "epss_percentile": 0.24128}, "CVE-2023-22292": {"epss_score": 0.00072, "epss_percentile": 0.22458}, "CVE-2023-22293": {"epss_score": 0.00062, "epss_percentile": 0.19718}, "CVE-2023-22294": {"epss_score": 0.00225, "epss_percentile": 0.45133}, "CVE-2023-22295": {"epss_score": 0.00042, "epss_percentile": 0.12619}, "CVE-2023-22296": {"epss_score": 0.00701, "epss_percentile": 0.71492}, "CVE-2023-22297": {"epss_score": 0.00078, "epss_percentile": 0.23635}, "CVE-2023-22298": {"epss_score": 0.00698, "epss_percentile": 0.7143}, "CVE-2023-22299": {"epss_score": 0.00657, "epss_percentile": 0.70472}, "CVE-2023-22300": {"epss_score": 0.00189, "epss_percentile": 0.40952}, "CVE-2023-22301": {"epss_score": 0.00085, "epss_percentile": 0.25232}, "CVE-2023-22302": {"epss_score": 0.00484, "epss_percentile": 0.64654}, "CVE-2023-22303": {"epss_score": 0.00421, "epss_percentile": 0.61529}, "CVE-2023-22304": {"epss_score": 0.00534, "epss_percentile": 0.66781}, "CVE-2023-22305": {"epss_score": 0.00059, "epss_percentile": 0.18697}, "CVE-2023-22306": {"epss_score": 0.00186, "epss_percentile": 0.40593}, "CVE-2023-22307": {"epss_score": 0.00042, "epss_percentile": 0.12567}, "CVE-2023-22308": {"epss_score": 0.0009, "epss_percentile": 0.26008}, "CVE-2023-22309": {"epss_score": 0.00435, "epss_percentile": 0.62365}, "CVE-2023-22310": {"epss_score": 0.00042, "epss_percentile": 0.12937}, "CVE-2023-22311": {"epss_score": 0.00084, "epss_percentile": 0.25012}, "CVE-2023-22312": {"epss_score": 0.00074, "epss_percentile": 0.22824}, "CVE-2023-22313": {"epss_score": 0.0007, "epss_percentile": 0.21674}, "CVE-2023-22314": {"epss_score": 0.00044, "epss_percentile": 0.13464}, "CVE-2023-22315": {"epss_score": 0.00037, "epss_percentile": 0.10886}, "CVE-2023-22316": {"epss_score": 0.00091, "epss_percentile": 0.26384}, "CVE-2023-22317": {"epss_score": 0.00044, "epss_percentile": 0.13464}, "CVE-2023-22318": {"epss_score": 0.00152, "epss_percentile": 0.36464}, "CVE-2023-22319": {"epss_score": 0.00024, "epss_percentile": 0.05661}, "CVE-2023-22320": {"epss_score": 0.00138, "epss_percentile": 0.34345}, "CVE-2023-22321": {"epss_score": 0.00042, "epss_percentile": 0.12619}, "CVE-2023-22322": {"epss_score": 0.00025, "epss_percentile": 0.06221}, "CVE-2023-22323": {"epss_score": 0.00428, "epss_percentile": 0.61932}, "CVE-2023-22324": {"epss_score": 0.00223, "epss_percentile": 0.44864}, "CVE-2023-22325": {"epss_score": 0.00315, "epss_percentile": 0.54162}, "CVE-2023-22326": {"epss_score": 0.00239, "epss_percentile": 0.46884}, "CVE-2023-22327": {"epss_score": 0.00088, "epss_percentile": 0.25696}, "CVE-2023-22329": {"epss_score": 0.00043, "epss_percentile": 0.13062}, "CVE-2023-22330": {"epss_score": 0.00035, "epss_percentile": 0.09813}, "CVE-2023-22331": {"epss_score": 0.01651, "epss_percentile": 0.81567}, "CVE-2023-22332": {"epss_score": 0.00122, "epss_percentile": 0.32053}, "CVE-2023-22333": {"epss_score": 0.0126, "epss_percentile": 0.78972}, "CVE-2023-22334": {"epss_score": 0.00751, "epss_percentile": 0.72647}, "CVE-2023-22335": {"epss_score": 0.00184, "epss_percentile": 0.40381}, "CVE-2023-22336": {"epss_score": 0.0156, "epss_percentile": 0.81037}, "CVE-2023-22337": {"epss_score": 0.00136, "epss_percentile": 0.3417}, "CVE-2023-22338": {"epss_score": 0.00041, "epss_percentile": 0.12397}, "CVE-2023-22339": {"epss_score": 0.00322, "epss_percentile": 0.54756}, "CVE-2023-22340": {"epss_score": 0.00483, "epss_percentile": 0.64564}, "CVE-2023-22341": {"epss_score": 0.00483, "epss_percentile": 0.64564}, "CVE-2023-22342": {"epss_score": 0.00075, "epss_percentile": 0.2289}, "CVE-2023-22344": {"epss_score": 0.01052, "epss_percentile": 0.77086}, "CVE-2023-22345": {"epss_score": 0.00066, "epss_percentile": 0.20905}, "CVE-2023-22346": {"epss_score": 0.00066, "epss_percentile": 0.20905}, "CVE-2023-22347": {"epss_score": 0.00066, "epss_percentile": 0.20905}, "CVE-2023-22348": {"epss_score": 0.00153, "epss_percentile": 0.36539}, "CVE-2023-22349": {"epss_score": 0.00066, "epss_percentile": 0.20905}, "CVE-2023-22350": {"epss_score": 0.00066, "epss_percentile": 0.20905}, "CVE-2023-22351": {"epss_score": 0.00047, "epss_percentile": 0.14657}, "CVE-2023-22353": {"epss_score": 0.00066, "epss_percentile": 0.20905}, "CVE-2023-22354": {"epss_score": 0.00042, "epss_percentile": 0.12619}, "CVE-2023-22355": {"epss_score": 0.00083, "epss_percentile": 0.24768}, "CVE-2023-22356": {"epss_score": 0.00035, "epss_percentile": 0.09813}, "CVE-2023-22357": {"epss_score": 0.01636, "epss_percentile": 0.81476}, "CVE-2023-22358": {"epss_score": 0.00105, "epss_percentile": 0.29337}, "CVE-2023-22359": {"epss_score": 0.00263, "epss_percentile": 0.49471}, "CVE-2023-22360": {"epss_score": 0.00099, "epss_percentile": 0.28398}, "CVE-2023-22361": {"epss_score": 0.05221, "epss_percentile": 0.89625}, "CVE-2023-22362": {"epss_score": 0.00197, "epss_percentile": 0.4183}, "CVE-2023-22363": {"epss_score": 0.0015, "epss_percentile": 0.36076}, "CVE-2023-22365": {"epss_score": 0.00129, "epss_percentile": 0.33207}, "CVE-2023-22366": {"epss_score": 0.0004, "epss_percentile": 0.12178}, "CVE-2023-22367": {"epss_score": 0.00149, "epss_percentile": 0.36042}, "CVE-2023-22368": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2023-22370": {"epss_score": 0.00141, "epss_percentile": 0.349}, "CVE-2023-22371": {"epss_score": 0.00248, "epss_percentile": 0.47941}, "CVE-2023-22372": {"epss_score": 0.00208, "epss_percentile": 0.43293}, "CVE-2023-22373": {"epss_score": 0.00765, "epss_percentile": 0.72911}, "CVE-2023-22374": {"epss_score": 0.05801, "epss_percentile": 0.90219}, "CVE-2023-22375": {"epss_score": 0.00339, "epss_percentile": 0.56187}, "CVE-2023-22376": {"epss_score": 0.00289, "epss_percentile": 0.52023}, "CVE-2023-22377": {"epss_score": 0.00138, "epss_percentile": 0.34441}, "CVE-2023-22378": {"epss_score": 0.00171, "epss_percentile": 0.38832}, "CVE-2023-22379": {"epss_score": 0.00057, "epss_percentile": 0.18063}, "CVE-2023-22380": {"epss_score": 0.00138, "epss_percentile": 0.34441}, "CVE-2023-22381": {"epss_score": 0.00153, "epss_percentile": 0.36538}, "CVE-2023-22382": {"epss_score": 0.00026, "epss_percentile": 0.06457}, "CVE-2023-22383": {"epss_score": 0.0004, "epss_percentile": 0.12192}, "CVE-2023-22384": {"epss_score": 0.0002, "epss_percentile": 0.04626}, "CVE-2023-22385": {"epss_score": 0.00126, "epss_percentile": 0.32683}, "CVE-2023-22386": {"epss_score": 0.00051, "epss_percentile": 0.16162}, "CVE-2023-22387": {"epss_score": 0.00051, "epss_percentile": 0.16162}, "CVE-2023-22388": {"epss_score": 0.00164, "epss_percentile": 0.37936}, "CVE-2023-22389": {"epss_score": 0.00067, "epss_percentile": 0.21159}, "CVE-2023-22390": {"epss_score": 0.00096, "epss_percentile": 0.27355}, "CVE-2023-22391": {"epss_score": 0.00188, "epss_percentile": 0.40895}, "CVE-2023-22392": {"epss_score": 0.00066, "epss_percentile": 0.20679}, "CVE-2023-22393": {"epss_score": 0.00219, "epss_percentile": 0.44483}, "CVE-2023-22394": {"epss_score": 0.0022, "epss_percentile": 0.44547}, "CVE-2023-22395": {"epss_score": 0.00095, "epss_percentile": 0.27157}, "CVE-2023-22396": {"epss_score": 0.00066, "epss_percentile": 0.20855}, "CVE-2023-22397": {"epss_score": 0.00088, "epss_percentile": 0.25635}, "CVE-2023-22398": {"epss_score": 0.00055, "epss_percentile": 0.17542}, "CVE-2023-22399": {"epss_score": 0.00246, "epss_percentile": 0.47807}, "CVE-2023-22400": {"epss_score": 0.00292, "epss_percentile": 0.52214}, "CVE-2023-22401": {"epss_score": 0.00182, "epss_percentile": 0.40193}, "CVE-2023-22402": {"epss_score": 0.00247, "epss_percentile": 0.47865}, "CVE-2023-22403": {"epss_score": 0.00406, "epss_percentile": 0.60526}, "CVE-2023-22404": {"epss_score": 0.00267, "epss_percentile": 0.49966}, "CVE-2023-22405": {"epss_score": 0.00156, "epss_percentile": 0.36968}, "CVE-2023-22406": {"epss_score": 0.00132, "epss_percentile": 0.336}, "CVE-2023-22407": {"epss_score": 0.00156, "epss_percentile": 0.36968}, "CVE-2023-22408": {"epss_score": 0.00164, "epss_percentile": 0.37932}, "CVE-2023-22409": {"epss_score": 0.00055, "epss_percentile": 0.17542}, "CVE-2023-22410": {"epss_score": 0.00306, "epss_percentile": 0.53411}, "CVE-2023-22411": {"epss_score": 0.00247, "epss_percentile": 0.47865}, "CVE-2023-22412": {"epss_score": 0.00252, "epss_percentile": 0.48406}, "CVE-2023-22413": {"epss_score": 0.00347, "epss_percentile": 0.56784}, "CVE-2023-22414": {"epss_score": 0.00116, "epss_percentile": 0.31123}, "CVE-2023-22415": {"epss_score": 0.00306, "epss_percentile": 0.53411}, "CVE-2023-22416": {"epss_score": 0.00454, "epss_percentile": 0.63269}, "CVE-2023-22417": {"epss_score": 0.00344, "epss_percentile": 0.56517}, "CVE-2023-22418": {"epss_score": 0.00268, "epss_percentile": 0.50078}, "CVE-2023-22419": {"epss_score": 0.0009, "epss_percentile": 0.26101}, "CVE-2023-22421": {"epss_score": 0.0009, "epss_percentile": 0.26101}, "CVE-2023-22422": {"epss_score": 0.00411, "epss_percentile": 0.60847}, "CVE-2023-22424": {"epss_score": 0.00103, "epss_percentile": 0.29063}, "CVE-2023-22425": {"epss_score": 0.00403, "epss_percentile": 0.60368}, "CVE-2023-22427": {"epss_score": 0.00296, "epss_percentile": 0.52586}, "CVE-2023-22428": {"epss_score": 0.00037, "epss_percentile": 0.10786}, "CVE-2023-22429": {"epss_score": 0.00032, "epss_percentile": 0.09105}, "CVE-2023-22432": {"epss_score": 0.38217, "epss_percentile": 0.9709}, "CVE-2023-22435": {"epss_score": 0.00054, "epss_percentile": 0.17068}, "CVE-2023-22436": {"epss_score": 0.00041, "epss_percentile": 0.1243}, "CVE-2023-22438": {"epss_score": 0.00328, "epss_percentile": 0.5528}, "CVE-2023-22439": {"epss_score": 0.00062, "epss_percentile": 0.19666}, "CVE-2023-22440": {"epss_score": 0.00062, "epss_percentile": 0.19558}, "CVE-2023-22441": {"epss_score": 0.01119, "epss_percentile": 0.77755}, "CVE-2023-22442": {"epss_score": 0.00055, "epss_percentile": 0.1762}, "CVE-2023-22443": {"epss_score": 0.00054, "epss_percentile": 0.17081}, "CVE-2023-22444": {"epss_score": 0.00035, "epss_percentile": 0.09813}, "CVE-2023-22447": {"epss_score": 0.00095, "epss_percentile": 0.27141}, "CVE-2023-22448": {"epss_score": 0.0012, "epss_percentile": 0.31749}, "CVE-2023-22449": {"epss_score": 0.0003, "epss_percentile": 0.08149}, "CVE-2023-22450": {"epss_score": 0.00085, "epss_percentile": 0.2514}, "CVE-2023-22451": {"epss_score": 0.00401, "epss_percentile": 0.60216}, "CVE-2023-22452": {"epss_score": 0.00322, "epss_percentile": 0.54754}, "CVE-2023-22453": {"epss_score": 0.00274, "epss_percentile": 0.50556}, "CVE-2023-22454": {"epss_score": 0.00293, "epss_percentile": 0.52349}, "CVE-2023-22455": {"epss_score": 0.00377, "epss_percentile": 0.58728}, "CVE-2023-22456": {"epss_score": 0.00208, "epss_percentile": 0.43298}, "CVE-2023-22457": {"epss_score": 0.02936, "epss_percentile": 0.86025}, "CVE-2023-22458": {"epss_score": 0.67775, "epss_percentile": 0.9852}, "CVE-2023-22460": {"epss_score": 0.00476, "epss_percentile": 0.64272}, "CVE-2023-22461": {"epss_score": 0.00588, "epss_percentile": 0.68496}, "CVE-2023-22462": {"epss_score": 0.08023, "epss_percentile": 0.91836}, "CVE-2023-22463": {"epss_score": 0.91521, "epss_percentile": 0.99649}, "CVE-2023-22464": {"epss_score": 0.00237, "epss_percentile": 0.46737}, "CVE-2023-22465": {"epss_score": 0.00335, "epss_percentile": 0.55808}, "CVE-2023-22466": {"epss_score": 0.00127, "epss_percentile": 0.32912}, "CVE-2023-22467": {"epss_score": 0.00682, "epss_percentile": 0.71076}, "CVE-2023-22468": {"epss_score": 0.00278, "epss_percentile": 0.50904}, "CVE-2023-22469": {"epss_score": 0.00184, "epss_percentile": 0.40395}, "CVE-2023-22470": {"epss_score": 0.00096, "epss_percentile": 0.27273}, "CVE-2023-22471": {"epss_score": 0.00044, "epss_percentile": 0.1355}, "CVE-2023-22472": {"epss_score": 0.00158, "epss_percentile": 0.37294}, "CVE-2023-22473": {"epss_score": 0.00028, "epss_percentile": 0.07449}, "CVE-2023-22474": {"epss_score": 0.00082, "epss_percentile": 0.24404}, "CVE-2023-22475": {"epss_score": 0.00432, "epss_percentile": 0.62116}, "CVE-2023-22476": {"epss_score": 0.0028, "epss_percentile": 0.51038}, "CVE-2023-22477": {"epss_score": 0.00282, "epss_percentile": 0.51267}, "CVE-2023-22478": {"epss_score": 0.83671, "epss_percentile": 0.99257}, "CVE-2023-22479": {"epss_score": 0.00122, "epss_percentile": 0.3211}, "CVE-2023-22480": {"epss_score": 0.79241, "epss_percentile": 0.99026}, "CVE-2023-22481": {"epss_score": 0.00058, "epss_percentile": 0.18395}, "CVE-2023-22482": {"epss_score": 0.00284, "epss_percentile": 0.51485}, "CVE-2023-22483": {"epss_score": 0.00074, "epss_percentile": 0.22791}, "CVE-2023-22484": {"epss_score": 0.00089, "epss_percentile": 0.2584}, "CVE-2023-22485": {"epss_score": 0.00438, "epss_percentile": 0.62553}, "CVE-2023-22486": {"epss_score": 0.00086, "epss_percentile": 0.25425}, "CVE-2023-22487": {"epss_score": 0.00088, "epss_percentile": 0.25677}, "CVE-2023-22488": {"epss_score": 0.00046, "epss_percentile": 0.14193}, "CVE-2023-22489": {"epss_score": 0.00113, "epss_percentile": 0.30604}, "CVE-2023-22490": {"epss_score": 0.00128, "epss_percentile": 0.33062}, "CVE-2023-22491": {"epss_score": 0.00204, "epss_percentile": 0.42641}, "CVE-2023-22492": {"epss_score": 0.00106, "epss_percentile": 0.29419}, "CVE-2023-22493": {"epss_score": 0.00168, "epss_percentile": 0.38522}, "CVE-2023-22495": {"epss_score": 0.00025, "epss_percentile": 0.06218}, "CVE-2023-22496": {"epss_score": 0.00353, "epss_percentile": 0.57191}, "CVE-2023-22497": {"epss_score": 0.0009, "epss_percentile": 0.26014}, "CVE-2023-22499": {"epss_score": 0.00093, "epss_percentile": 0.26736}, "CVE-2023-22500": {"epss_score": 0.0059, "epss_percentile": 0.68555}, "CVE-2023-22501": {"epss_score": 0.01949, "epss_percentile": 0.83012}, "CVE-2023-22503": {"epss_score": 0.00288, "epss_percentile": 0.51926}, "CVE-2023-22504": {"epss_score": 0.00148, "epss_percentile": 0.35912}, "CVE-2023-22505": {"epss_score": 0.02231, "epss_percentile": 0.84088}, "CVE-2023-22506": {"epss_score": 0.04887, "epss_percentile": 0.89257}, "CVE-2023-22508": {"epss_score": 0.06704, "epss_percentile": 0.90957}, "CVE-2023-22512": {"epss_score": 0.07066, "epss_percentile": 0.91224}, "CVE-2023-22513": {"epss_score": 0.11648, "epss_percentile": 0.93429}, "CVE-2023-22514": {"epss_score": 0.00748, "epss_percentile": 0.72577}, "CVE-2023-22515": {"epss_score": 0.94326, "epss_percentile": 0.99948}, "CVE-2023-22516": {"epss_score": 0.01725, "epss_percentile": 0.81953}, "CVE-2023-22518": {"epss_score": 0.94375, "epss_percentile": 0.99962}, "CVE-2023-22521": {"epss_score": 0.00864, "epss_percentile": 0.7461}, "CVE-2023-22522": {"epss_score": 0.42294, "epss_percentile": 0.97324}, "CVE-2023-22523": {"epss_score": 0.07188, "epss_percentile": 0.91309}, "CVE-2023-22524": {"epss_score": 0.34969, "epss_percentile": 0.9688}, "CVE-2023-22526": {"epss_score": 0.00584, "epss_percentile": 0.68358}, "CVE-2023-22527": {"epss_score": 0.94363, "epss_percentile": 0.99959}, "CVE-2023-22551": {"epss_score": 0.09166, "epss_percentile": 0.92428}, "CVE-2023-22572": {"epss_score": 0.00063, "epss_percentile": 0.19944}, "CVE-2023-22573": {"epss_score": 0.00061, "epss_percentile": 0.19469}, "CVE-2023-22574": {"epss_score": 0.00342, "epss_percentile": 0.56361}, "CVE-2023-22575": {"epss_score": 0.00299, "epss_percentile": 0.52894}, "CVE-2023-22576": {"epss_score": 0.0004, "epss_percentile": 0.1189}, "CVE-2023-22577": {"epss_score": 0.0014, "epss_percentile": 0.34768}, "CVE-2023-22578": {"epss_score": 0.00172, "epss_percentile": 0.3898}, "CVE-2023-22579": {"epss_score": 0.00131, "epss_percentile": 0.33445}, "CVE-2023-22580": {"epss_score": 0.00118, "epss_percentile": 0.31404}, "CVE-2023-22581": {"epss_score": 0.00128, "epss_percentile": 0.33058}, "CVE-2023-22582": {"epss_score": 0.00105, "epss_percentile": 0.2937}, "CVE-2023-22583": {"epss_score": 0.00073, "epss_percentile": 0.22583}, "CVE-2023-22584": {"epss_score": 0.00047, "epss_percentile": 0.14612}, "CVE-2023-22585": {"epss_score": 0.00105, "epss_percentile": 0.2937}, "CVE-2023-22586": {"epss_score": 0.00096, "epss_percentile": 0.27277}, "CVE-2023-22591": {"epss_score": 0.00028, "epss_percentile": 0.07295}, "CVE-2023-22592": {"epss_score": 0.00026, "epss_percentile": 0.06536}, "CVE-2023-22593": {"epss_score": 0.00025, "epss_percentile": 0.06051}, "CVE-2023-22594": {"epss_score": 0.0009, "epss_percentile": 0.26161}, "CVE-2023-22595": {"epss_score": 0.0011, "epss_percentile": 0.30237}, "CVE-2023-22597": {"epss_score": 0.00106, "epss_percentile": 0.29534}, "CVE-2023-22598": {"epss_score": 0.0058, "epss_percentile": 0.68246}, "CVE-2023-22599": {"epss_score": 0.00055, "epss_percentile": 0.17428}, "CVE-2023-22600": {"epss_score": 0.00125, "epss_percentile": 0.32596}, "CVE-2023-22601": {"epss_score": 0.00155, "epss_percentile": 0.36767}, "CVE-2023-22602": {"epss_score": 0.0015, "epss_percentile": 0.36091}, "CVE-2023-22610": {"epss_score": 0.00294, "epss_percentile": 0.52386}, "CVE-2023-22611": {"epss_score": 0.00381, "epss_percentile": 0.59011}, "CVE-2023-22612": {"epss_score": 0.00202, "epss_percentile": 0.42394}, "CVE-2023-22613": {"epss_score": 0.00079, "epss_percentile": 0.24001}, "CVE-2023-22614": {"epss_score": 0.00168, "epss_percentile": 0.38468}, "CVE-2023-22615": {"epss_score": 0.00237, "epss_percentile": 0.46726}, "CVE-2023-22616": {"epss_score": 0.00066, "epss_percentile": 0.20942}, "CVE-2023-22617": {"epss_score": 0.01118, "epss_percentile": 0.77746}, "CVE-2023-22618": {"epss_score": 0.00045, "epss_percentile": 0.13958}, "CVE-2023-22620": {"epss_score": 0.878, "epss_percentile": 0.99444}, "CVE-2023-22621": {"epss_score": 0.82899, "epss_percentile": 0.99221}, "CVE-2023-22622": {"epss_score": 0.0545, "epss_percentile": 0.8989}, "CVE-2023-22624": {"epss_score": 0.00893, "epss_percentile": 0.7508}, "CVE-2023-22626": {"epss_score": 0.0017, "epss_percentile": 0.38663}, "CVE-2023-22629": {"epss_score": 0.81824, "epss_percentile": 0.99159}, "CVE-2023-22630": {"epss_score": 0.00084, "epss_percentile": 0.24909}, "CVE-2023-22633": {"epss_score": 0.00177, "epss_percentile": 0.39618}, "CVE-2023-22635": {"epss_score": 0.00044, "epss_percentile": 0.13504}, "CVE-2023-22636": {"epss_score": 0.00059, "epss_percentile": 0.18804}, "CVE-2023-22637": {"epss_score": 0.00483, "epss_percentile": 0.64577}, "CVE-2023-22638": {"epss_score": 0.00924, "epss_percentile": 0.75525}, "CVE-2023-22639": {"epss_score": 0.00048, "epss_percentile": 0.14944}, "CVE-2023-22640": {"epss_score": 0.00362, "epss_percentile": 0.57755}, "CVE-2023-22641": {"epss_score": 0.00142, "epss_percentile": 0.3502}, "CVE-2023-22642": {"epss_score": 0.00116, "epss_percentile": 0.31045}, "CVE-2023-22643": {"epss_score": 0.00109, "epss_percentile": 0.30006}, "CVE-2023-22644": {"epss_score": 0.00053, "epss_percentile": 0.16936}, "CVE-2023-22645": {"epss_score": 0.00114, "epss_percentile": 0.30842}, "CVE-2023-22647": {"epss_score": 0.00585, "epss_percentile": 0.68408}, "CVE-2023-22648": {"epss_score": 0.00132, "epss_percentile": 0.33543}, "CVE-2023-22649": {"epss_score": 0.38653, "epss_percentile": 0.97111}, "CVE-2023-22650": {"epss_score": 0.00116, "epss_percentile": 0.31064}, "CVE-2023-22651": {"epss_score": 0.0025, "epss_percentile": 0.48108}, "CVE-2023-22652": {"epss_score": 0.00068, "epss_percentile": 0.21259}, "CVE-2023-22653": {"epss_score": 0.01026, "epss_percentile": 0.76799}, "CVE-2023-22654": {"epss_score": 0.00803, "epss_percentile": 0.73601}, "CVE-2023-22655": {"epss_score": 0.00035, "epss_percentile": 0.09813}, "CVE-2023-22656": {"epss_score": 0.00025, "epss_percentile": 0.06259}, "CVE-2023-22657": {"epss_score": 0.00196, "epss_percentile": 0.41772}, "CVE-2023-22659": {"epss_score": 0.00467, "epss_percentile": 0.63856}, "CVE-2023-22660": {"epss_score": 0.0055, "epss_percentile": 0.67325}, "CVE-2023-22661": {"epss_score": 0.00092, "epss_percentile": 0.26517}, "CVE-2023-22662": {"epss_score": 0.00042, "epss_percentile": 0.12892}, "CVE-2023-22663": {"epss_score": 0.00235, "epss_percentile": 0.46241}, "CVE-2023-22664": {"epss_score": 0.00484, "epss_percentile": 0.64654}, "CVE-2023-22665": {"epss_score": 0.0087, "epss_percentile": 0.74697}, "CVE-2023-22666": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-22667": {"epss_score": 0.00051, "epss_percentile": 0.16162}, "CVE-2023-22668": {"epss_score": 0.0004, "epss_percentile": 0.12192}, "CVE-2023-22669": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2023-22670": {"epss_score": 0.00061, "epss_percentile": 0.19358}, "CVE-2023-22671": {"epss_score": 0.04563, "epss_percentile": 0.88854}, "CVE-2023-22672": {"epss_score": 0.00065, "epss_percentile": 0.20495}, "CVE-2023-22673": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-22674": {"epss_score": 0.00086, "epss_percentile": 0.25308}, "CVE-2023-22675": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2023-22676": {"epss_score": 0.00262, "epss_percentile": 0.49344}, "CVE-2023-22677": {"epss_score": 0.00692, "epss_percentile": 0.71305}, "CVE-2023-22678": {"epss_score": 0.00064, "epss_percentile": 0.20105}, "CVE-2023-22679": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-22680": {"epss_score": 0.00086, "epss_percentile": 0.25363}, "CVE-2023-22681": {"epss_score": 0.00083, "epss_percentile": 0.24789}, "CVE-2023-22682": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-22683": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-22684": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-22685": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-22686": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-22687": {"epss_score": 0.00282, "epss_percentile": 0.51203}, "CVE-2023-22688": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-22689": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-22690": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-22691": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-22692": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-22693": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2023-22694": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-22695": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-22696": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-22697": {"epss_score": 0.00298, "epss_percentile": 0.528}, "CVE-2023-22698": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-22699": {"epss_score": 0.00078, "epss_percentile": 0.23736}, "CVE-2023-22700": {"epss_score": 0.00089, "epss_percentile": 0.2588}, "CVE-2023-22701": {"epss_score": 0.00341, "epss_percentile": 0.56295}, "CVE-2023-22702": {"epss_score": 0.00105, "epss_percentile": 0.29362}, "CVE-2023-22703": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-22704": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-22705": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-22706": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-22707": {"epss_score": 0.00069, "epss_percentile": 0.21631}, "CVE-2023-22708": {"epss_score": 0.00139, "epss_percentile": 0.34625}, "CVE-2023-22709": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-22710": {"epss_score": 0.0009, "epss_percentile": 0.261}, "CVE-2023-22711": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-22712": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-22713": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2023-22714": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-22715": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-22716": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-22717": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-22718": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-22719": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2023-22720": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-22721": {"epss_score": 0.00098, "epss_percentile": 0.27681}, "CVE-2023-22722": {"epss_score": 0.00271, "epss_percentile": 0.50315}, "CVE-2023-22724": {"epss_score": 0.00181, "epss_percentile": 0.40036}, "CVE-2023-22725": {"epss_score": 0.00198, "epss_percentile": 0.42018}, "CVE-2023-22726": {"epss_score": 0.01874, "epss_percentile": 0.82653}, "CVE-2023-22727": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2023-22728": {"epss_score": 0.00342, "epss_percentile": 0.5638}, "CVE-2023-22729": {"epss_score": 0.00197, "epss_percentile": 0.41832}, "CVE-2023-22730": {"epss_score": 0.00235, "epss_percentile": 0.46204}, "CVE-2023-22731": {"epss_score": 0.06221, "epss_percentile": 0.90579}, "CVE-2023-22732": {"epss_score": 0.00303, "epss_percentile": 0.53182}, "CVE-2023-22733": {"epss_score": 0.00193, "epss_percentile": 0.41379}, "CVE-2023-22734": {"epss_score": 0.0017, "epss_percentile": 0.38672}, "CVE-2023-22735": {"epss_score": 0.00322, "epss_percentile": 0.54755}, "CVE-2023-22736": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2023-22737": {"epss_score": 0.0006, "epss_percentile": 0.19192}, "CVE-2023-22738": {"epss_score": 0.00143, "epss_percentile": 0.35112}, "CVE-2023-22739": {"epss_score": 0.00391, "epss_percentile": 0.59567}, "CVE-2023-22740": {"epss_score": 0.00065, "epss_percentile": 0.20521}, "CVE-2023-22741": {"epss_score": 0.01575, "epss_percentile": 0.81111}, "CVE-2023-22742": {"epss_score": 0.00121, "epss_percentile": 0.31817}, "CVE-2023-22743": {"epss_score": 0.00024, "epss_percentile": 0.05891}, "CVE-2023-22745": {"epss_score": 0.00026, "epss_percentile": 0.0655}, "CVE-2023-22746": {"epss_score": 0.00101, "epss_percentile": 0.28575}, "CVE-2023-22747": {"epss_score": 0.00957, "epss_percentile": 0.75929}, "CVE-2023-22748": {"epss_score": 0.00957, "epss_percentile": 0.75929}, "CVE-2023-22749": {"epss_score": 0.00957, "epss_percentile": 0.75929}, "CVE-2023-22750": {"epss_score": 0.00957, "epss_percentile": 0.75929}, "CVE-2023-22751": {"epss_score": 0.02424, "epss_percentile": 0.8471}, "CVE-2023-22752": {"epss_score": 0.03256, "epss_percentile": 0.86763}, "CVE-2023-22753": {"epss_score": 0.03256, "epss_percentile": 0.86763}, "CVE-2023-22754": {"epss_score": 0.03256, "epss_percentile": 0.86763}, "CVE-2023-22755": {"epss_score": 0.03256, "epss_percentile": 0.86763}, "CVE-2023-22756": {"epss_score": 0.03256, "epss_percentile": 0.86763}, "CVE-2023-22757": {"epss_score": 0.03256, "epss_percentile": 0.86763}, "CVE-2023-22758": {"epss_score": 0.00482, "epss_percentile": 0.64529}, "CVE-2023-22759": {"epss_score": 0.00482, "epss_percentile": 0.64529}, "CVE-2023-22760": {"epss_score": 0.00482, "epss_percentile": 0.64529}, "CVE-2023-22761": {"epss_score": 0.00482, "epss_percentile": 0.64529}, "CVE-2023-22762": {"epss_score": 0.00333, "epss_percentile": 0.5566}, "CVE-2023-22763": {"epss_score": 0.00333, "epss_percentile": 0.5566}, "CVE-2023-22764": {"epss_score": 0.00333, "epss_percentile": 0.5566}, "CVE-2023-22765": {"epss_score": 0.00333, "epss_percentile": 0.5566}, "CVE-2023-22766": {"epss_score": 0.00333, "epss_percentile": 0.5566}, "CVE-2023-22767": {"epss_score": 0.00333, "epss_percentile": 0.5566}, "CVE-2023-22768": {"epss_score": 0.00333, "epss_percentile": 0.5566}, "CVE-2023-22769": {"epss_score": 0.00333, "epss_percentile": 0.5566}, "CVE-2023-22770": {"epss_score": 0.00333, "epss_percentile": 0.5566}, "CVE-2023-22771": {"epss_score": 0.00111, "epss_percentile": 0.30259}, "CVE-2023-22772": {"epss_score": 0.00415, "epss_percentile": 0.61112}, "CVE-2023-22773": {"epss_score": 0.00435, "epss_percentile": 0.62328}, "CVE-2023-22774": {"epss_score": 0.00435, "epss_percentile": 0.62328}, "CVE-2023-22775": {"epss_score": 0.00212, "epss_percentile": 0.43784}, "CVE-2023-22776": {"epss_score": 0.00224, "epss_percentile": 0.44977}, "CVE-2023-22777": {"epss_score": 0.00164, "epss_percentile": 0.37906}, "CVE-2023-22778": {"epss_score": 0.00107, "epss_percentile": 0.29727}, "CVE-2023-22779": {"epss_score": 0.00876, "epss_percentile": 0.74795}, "CVE-2023-22780": {"epss_score": 0.00876, "epss_percentile": 0.74795}, "CVE-2023-22781": {"epss_score": 0.00876, "epss_percentile": 0.74795}, "CVE-2023-22782": {"epss_score": 0.00876, "epss_percentile": 0.74795}, "CVE-2023-22783": {"epss_score": 0.00876, "epss_percentile": 0.74795}, "CVE-2023-22784": {"epss_score": 0.00876, "epss_percentile": 0.74795}, "CVE-2023-22785": {"epss_score": 0.00876, "epss_percentile": 0.74795}, "CVE-2023-22786": {"epss_score": 0.00876, "epss_percentile": 0.74795}, "CVE-2023-22787": {"epss_score": 0.00186, "epss_percentile": 0.40656}, "CVE-2023-22788": {"epss_score": 0.003, "epss_percentile": 0.52979}, "CVE-2023-22789": {"epss_score": 0.003, "epss_percentile": 0.52979}, "CVE-2023-22790": {"epss_score": 0.003, "epss_percentile": 0.52979}, "CVE-2023-22791": {"epss_score": 0.00134, "epss_percentile": 0.33823}, "CVE-2023-22792": {"epss_score": 0.0236, "epss_percentile": 0.84495}, "CVE-2023-22794": {"epss_score": 0.05265, "epss_percentile": 0.89672}, "CVE-2023-22795": {"epss_score": 0.0136, "epss_percentile": 0.79739}, "CVE-2023-22796": {"epss_score": 0.01496, "epss_percentile": 0.80683}, "CVE-2023-22797": {"epss_score": 0.00124, "epss_percentile": 0.32338}, "CVE-2023-22798": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2023-22799": {"epss_score": 0.01409, "epss_percentile": 0.80073}, "CVE-2023-22803": {"epss_score": 0.00076, "epss_percentile": 0.23268}, "CVE-2023-22804": {"epss_score": 0.00088, "epss_percentile": 0.25637}, "CVE-2023-22805": {"epss_score": 0.00102, "epss_percentile": 0.28797}, "CVE-2023-22806": {"epss_score": 0.00054, "epss_percentile": 0.1731}, "CVE-2023-22807": {"epss_score": 0.00109, "epss_percentile": 0.30024}, "CVE-2023-22808": {"epss_score": 0.00087, "epss_percentile": 0.25557}, "CVE-2023-22809": {"epss_score": 0.51473, "epss_percentile": 0.97781}, "CVE-2023-22812": {"epss_score": 0.0011, "epss_percentile": 0.301}, "CVE-2023-22813": {"epss_score": 0.00139, "epss_percentile": 0.34644}, "CVE-2023-22814": {"epss_score": 0.00074, "epss_percentile": 0.22686}, "CVE-2023-22815": {"epss_score": 0.00325, "epss_percentile": 0.55034}, "CVE-2023-22816": {"epss_score": 0.00527, "epss_percentile": 0.66451}, "CVE-2023-22817": {"epss_score": 0.00086, "epss_percentile": 0.25437}, "CVE-2023-22818": {"epss_score": 0.00021, "epss_percentile": 0.04772}, "CVE-2023-22819": {"epss_score": 0.00151, "epss_percentile": 0.36219}, "CVE-2023-22832": {"epss_score": 0.00243, "epss_percentile": 0.47504}, "CVE-2023-22833": {"epss_score": 0.0005, "epss_percentile": 0.15877}, "CVE-2023-22834": {"epss_score": 0.0004, "epss_percentile": 0.12015}, "CVE-2023-22835": {"epss_score": 0.00299, "epss_percentile": 0.52904}, "CVE-2023-22836": {"epss_score": 0.00056, "epss_percentile": 0.1776}, "CVE-2023-22838": {"epss_score": 0.00347, "epss_percentile": 0.56758}, "CVE-2023-22839": {"epss_score": 0.00483, "epss_percentile": 0.64564}, "CVE-2023-22840": {"epss_score": 0.00059, "epss_percentile": 0.18801}, "CVE-2023-22841": {"epss_score": 0.00091, "epss_percentile": 0.26253}, "CVE-2023-22842": {"epss_score": 0.00411, "epss_percentile": 0.60847}, "CVE-2023-22843": {"epss_score": 0.00093, "epss_percentile": 0.26633}, "CVE-2023-22844": {"epss_score": 0.00027, "epss_percentile": 0.06753}, "CVE-2023-22845": {"epss_score": 0.00094, "epss_percentile": 0.26973}, "CVE-2023-22846": {"epss_score": 0.00042, "epss_percentile": 0.12619}, "CVE-2023-22847": {"epss_score": 0.00102, "epss_percentile": 0.28724}, "CVE-2023-22848": {"epss_score": 0.00059, "epss_percentile": 0.18657}, "CVE-2023-22849": {"epss_score": 0.00169, "epss_percentile": 0.38634}, "CVE-2023-22850": {"epss_score": 0.0083, "epss_percentile": 0.74021}, "CVE-2023-22851": {"epss_score": 0.00411, "epss_percentile": 0.60851}, "CVE-2023-22852": {"epss_score": 0.00198, "epss_percentile": 0.4206}, "CVE-2023-22853": {"epss_score": 0.00946, "epss_percentile": 0.75809}, "CVE-2023-22854": {"epss_score": 0.00524, "epss_percentile": 0.66364}, "CVE-2023-22855": {"epss_score": 0.66811, "epss_percentile": 0.9848}, "CVE-2023-22856": {"epss_score": 0.00114, "epss_percentile": 0.3087}, "CVE-2023-22857": {"epss_score": 0.00111, "epss_percentile": 0.304}, "CVE-2023-22858": {"epss_score": 0.00079, "epss_percentile": 0.23966}, "CVE-2023-22860": {"epss_score": 0.00116, "epss_percentile": 0.31186}, "CVE-2023-22862": {"epss_score": 0.00064, "epss_percentile": 0.20362}, "CVE-2023-22863": {"epss_score": 0.0003, "epss_percentile": 0.08231}, "CVE-2023-22868": {"epss_score": 0.00234, "epss_percentile": 0.46098}, "CVE-2023-22869": {"epss_score": 0.00046, "epss_percentile": 0.1436}, "CVE-2023-22870": {"epss_score": 0.00022, "epss_percentile": 0.05185}, "CVE-2023-22874": {"epss_score": 0.00019, "epss_percentile": 0.04271}, "CVE-2023-22875": {"epss_score": 0.00058, "epss_percentile": 0.18273}, "CVE-2023-22876": {"epss_score": 0.0009, "epss_percentile": 0.25999}, "CVE-2023-22877": {"epss_score": 0.00176, "epss_percentile": 0.39468}, "CVE-2023-22878": {"epss_score": 0.0001, "epss_percentile": 0.00912}, "CVE-2023-22880": {"epss_score": 0.00372, "epss_percentile": 0.58437}, "CVE-2023-22881": {"epss_score": 0.00425, "epss_percentile": 0.61721}, "CVE-2023-22882": {"epss_score": 0.00555, "epss_percentile": 0.67497}, "CVE-2023-22883": {"epss_score": 0.00043, "epss_percentile": 0.13181}, "CVE-2023-22884": {"epss_score": 0.6394, "epss_percentile": 0.98356}, "CVE-2023-22886": {"epss_score": 0.00272, "epss_percentile": 0.50412}, "CVE-2023-22887": {"epss_score": 0.00413, "epss_percentile": 0.60991}, "CVE-2023-22888": {"epss_score": 0.00133, "epss_percentile": 0.33741}, "CVE-2023-22889": {"epss_score": 0.04373, "epss_percentile": 0.88612}, "CVE-2023-22890": {"epss_score": 0.00406, "epss_percentile": 0.60526}, "CVE-2023-22891": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2023-22892": {"epss_score": 0.00284, "epss_percentile": 0.5145}, "CVE-2023-22893": {"epss_score": 0.66479, "epss_percentile": 0.98464}, "CVE-2023-22894": {"epss_score": 0.17555, "epss_percentile": 0.94866}, "CVE-2023-22895": {"epss_score": 0.00145, "epss_percentile": 0.35407}, "CVE-2023-22897": {"epss_score": 0.88764, "epss_percentile": 0.99488}, "CVE-2023-22898": {"epss_score": 0.00132, "epss_percentile": 0.33548}, "CVE-2023-22899": {"epss_score": 0.00171, "epss_percentile": 0.38836}, "CVE-2023-22900": {"epss_score": 0.00384, "epss_percentile": 0.59175}, "CVE-2023-22901": {"epss_score": 0.00058, "epss_percentile": 0.18379}, "CVE-2023-22902": {"epss_score": 0.00067, "epss_percentile": 0.21135}, "CVE-2023-22903": {"epss_score": 0.00119, "epss_percentile": 0.31674}, "CVE-2023-22906": {"epss_score": 0.00152, "epss_percentile": 0.36423}, "CVE-2023-22909": {"epss_score": 0.00223, "epss_percentile": 0.44873}, "CVE-2023-22910": {"epss_score": 0.00611, "epss_percentile": 0.6921}, "CVE-2023-22911": {"epss_score": 0.00375, "epss_percentile": 0.58609}, "CVE-2023-22912": {"epss_score": 0.00287, "epss_percentile": 0.5184}, "CVE-2023-22913": {"epss_score": 0.00945, "epss_percentile": 0.75796}, "CVE-2023-22914": {"epss_score": 0.00922, "epss_percentile": 0.75493}, "CVE-2023-22915": {"epss_score": 0.00999, "epss_percentile": 0.76477}, "CVE-2023-22916": {"epss_score": 0.00479, "epss_percentile": 0.64432}, "CVE-2023-22917": {"epss_score": 0.00949, "epss_percentile": 0.75844}, "CVE-2023-22918": {"epss_score": 0.00208, "epss_percentile": 0.43256}, "CVE-2023-22919": {"epss_score": 0.01176, "epss_percentile": 0.78275}, "CVE-2023-22920": {"epss_score": 0.00977, "epss_percentile": 0.76217}, "CVE-2023-22921": {"epss_score": 0.00302, "epss_percentile": 0.53125}, "CVE-2023-22922": {"epss_score": 0.00526, "epss_percentile": 0.66432}, "CVE-2023-22923": {"epss_score": 0.00422, "epss_percentile": 0.61547}, "CVE-2023-22924": {"epss_score": 0.00418, "epss_percentile": 0.61273}, "CVE-2023-22931": {"epss_score": 0.0012, "epss_percentile": 0.31811}, "CVE-2023-22932": {"epss_score": 0.00709, "epss_percentile": 0.71695}, "CVE-2023-22933": {"epss_score": 0.00848, "epss_percentile": 0.74357}, "CVE-2023-22934": {"epss_score": 0.00116, "epss_percentile": 0.31108}, "CVE-2023-22935": {"epss_score": 0.00142, "epss_percentile": 0.35077}, "CVE-2023-22936": {"epss_score": 0.00119, "epss_percentile": 0.31659}, "CVE-2023-22937": {"epss_score": 0.00331, "epss_percentile": 0.55505}, "CVE-2023-22938": {"epss_score": 0.00194, "epss_percentile": 0.41518}, "CVE-2023-22939": {"epss_score": 0.00105, "epss_percentile": 0.29289}, "CVE-2023-22940": {"epss_score": 0.00291, "epss_percentile": 0.52161}, "CVE-2023-22941": {"epss_score": 0.00776, "epss_percentile": 0.73104}, "CVE-2023-22942": {"epss_score": 0.00084, "epss_percentile": 0.24868}, "CVE-2023-22943": {"epss_score": 0.00297, "epss_percentile": 0.52742}, "CVE-2023-22945": {"epss_score": 0.001, "epss_percentile": 0.28528}, "CVE-2023-22946": {"epss_score": 0.00283, "epss_percentile": 0.51409}, "CVE-2023-22947": {"epss_score": 0.00024, "epss_percentile": 0.06015}, "CVE-2023-22948": {"epss_score": 0.00092, "epss_percentile": 0.2658}, "CVE-2023-22949": {"epss_score": 0.00049, "epss_percentile": 0.15289}, "CVE-2023-22950": {"epss_score": 0.00221, "epss_percentile": 0.44654}, "CVE-2023-22951": {"epss_score": 0.00102, "epss_percentile": 0.28737}, "CVE-2023-22952": {"epss_score": 0.93075, "epss_percentile": 0.99774}, "CVE-2023-22953": {"epss_score": 0.02182, "epss_percentile": 0.8391}, "CVE-2023-22955": {"epss_score": 0.00066, "epss_percentile": 0.20866}, "CVE-2023-22956": {"epss_score": 0.00305, "epss_percentile": 0.53335}, "CVE-2023-22957": {"epss_score": 0.00305, "epss_percentile": 0.53335}, "CVE-2023-22958": {"epss_score": 0.00099, "epss_percentile": 0.28357}, "CVE-2023-22959": {"epss_score": 0.02523, "epss_percentile": 0.85006}, "CVE-2023-22960": {"epss_score": 0.62488, "epss_percentile": 0.98294}, "CVE-2023-22963": {"epss_score": 0.00126, "epss_percentile": 0.32748}, "CVE-2023-22964": {"epss_score": 0.0015, "epss_percentile": 0.36095}, "CVE-2023-22970": {"epss_score": 0.00746, "epss_percentile": 0.72548}, "CVE-2023-22971": {"epss_score": 0.01567, "epss_percentile": 0.81074}, "CVE-2023-22972": {"epss_score": 0.00094, "epss_percentile": 0.26952}, "CVE-2023-22973": {"epss_score": 0.01563, "epss_percentile": 0.81049}, "CVE-2023-22974": {"epss_score": 0.03583, "epss_percentile": 0.87388}, "CVE-2023-22975": {"epss_score": 0.00106, "epss_percentile": 0.29466}, "CVE-2023-22984": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-22985": {"epss_score": 0.00544, "epss_percentile": 0.67133}, "CVE-2023-22995": {"epss_score": 0.00011, "epss_percentile": 0.01099}, "CVE-2023-22996": {"epss_score": 0.00017, "epss_percentile": 0.03306}, "CVE-2023-22997": {"epss_score": 0.00014, "epss_percentile": 0.0191}, "CVE-2023-22998": {"epss_score": 0.00019, "epss_percentile": 0.04224}, "CVE-2023-22999": {"epss_score": 0.00017, "epss_percentile": 0.03306}, "CVE-2023-23000": {"epss_score": 0.00011, "epss_percentile": 0.01088}, "CVE-2023-23001": {"epss_score": 0.00014, "epss_percentile": 0.0191}, "CVE-2023-23002": {"epss_score": 0.00016, "epss_percentile": 0.03017}, "CVE-2023-23003": {"epss_score": 0.00027, "epss_percentile": 0.06878}, "CVE-2023-23004": {"epss_score": 0.00023, "epss_percentile": 0.0541}, "CVE-2023-23005": {"epss_score": 0.00016, "epss_percentile": 0.02907}, "CVE-2023-23006": {"epss_score": 0.00014, "epss_percentile": 0.0191}, "CVE-2023-23007": {"epss_score": 0.0008, "epss_percentile": 0.24178}, "CVE-2023-23009": {"epss_score": 0.00322, "epss_percentile": 0.54802}, "CVE-2023-23010": {"epss_score": 0.00111, "epss_percentile": 0.30385}, "CVE-2023-23011": {"epss_score": 0.00124, "epss_percentile": 0.32386}, "CVE-2023-23012": {"epss_score": 0.00098, "epss_percentile": 0.27775}, "CVE-2023-23014": {"epss_score": 0.0009, "epss_percentile": 0.26007}, "CVE-2023-23015": {"epss_score": 0.00426, "epss_percentile": 0.61766}, "CVE-2023-23019": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2023-23021": {"epss_score": 0.00283, "epss_percentile": 0.51349}, "CVE-2023-23022": {"epss_score": 0.00283, "epss_percentile": 0.51349}, "CVE-2023-23024": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-23026": {"epss_score": 0.00125, "epss_percentile": 0.32497}, "CVE-2023-23039": {"epss_score": 0.00019, "epss_percentile": 0.04176}, "CVE-2023-23040": {"epss_score": 0.0006, "epss_percentile": 0.19076}, "CVE-2023-23059": {"epss_score": 0.00115, "epss_percentile": 0.30883}, "CVE-2023-23063": {"epss_score": 0.62021, "epss_percentile": 0.98273}, "CVE-2023-23064": {"epss_score": 0.0014, "epss_percentile": 0.34773}, "CVE-2023-23073": {"epss_score": 0.13912, "epss_percentile": 0.94091}, "CVE-2023-23074": {"epss_score": 0.81044, "epss_percentile": 0.99117}, "CVE-2023-23075": {"epss_score": 0.05005, "epss_percentile": 0.89382}, "CVE-2023-23076": {"epss_score": 0.54222, "epss_percentile": 0.97915}, "CVE-2023-23077": {"epss_score": 0.13912, "epss_percentile": 0.94091}, "CVE-2023-23078": {"epss_score": 0.13912, "epss_percentile": 0.94091}, "CVE-2023-23080": {"epss_score": 0.05413, "epss_percentile": 0.89848}, "CVE-2023-23082": {"epss_score": 0.00079, "epss_percentile": 0.23977}, "CVE-2023-23086": {"epss_score": 0.00182, "epss_percentile": 0.40248}, "CVE-2023-23087": {"epss_score": 0.00105, "epss_percentile": 0.29249}, "CVE-2023-23088": {"epss_score": 0.00162, "epss_percentile": 0.37649}, "CVE-2023-23108": {"epss_score": 0.00155, "epss_percentile": 0.36767}, "CVE-2023-23109": {"epss_score": 0.0012, "epss_percentile": 0.31709}, "CVE-2023-23110": {"epss_score": 0.00153, "epss_percentile": 0.36511}, "CVE-2023-23119": {"epss_score": 0.00042, "epss_percentile": 0.12933}, "CVE-2023-23120": {"epss_score": 0.00042, "epss_percentile": 0.12933}, "CVE-2023-23126": {"epss_score": 0.00136, "epss_percentile": 0.34094}, "CVE-2023-23127": {"epss_score": 0.00058, "epss_percentile": 0.18355}, "CVE-2023-23128": {"epss_score": 0.00095, "epss_percentile": 0.27228}, "CVE-2023-23130": {"epss_score": 0.0006, "epss_percentile": 0.19076}, "CVE-2023-23131": {"epss_score": 0.00109, "epss_percentile": 0.30034}, "CVE-2023-23132": {"epss_score": 0.00143, "epss_percentile": 0.35175}, "CVE-2023-23135": {"epss_score": 0.00125, "epss_percentile": 0.32535}, "CVE-2023-23136": {"epss_score": 0.00173, "epss_percentile": 0.39044}, "CVE-2023-23143": {"epss_score": 0.00081, "epss_percentile": 0.24207}, "CVE-2023-23144": {"epss_score": 0.00029, "epss_percentile": 0.07903}, "CVE-2023-23145": {"epss_score": 0.00041, "epss_percentile": 0.12423}, "CVE-2023-23149": {"epss_score": 0.0014, "epss_percentile": 0.34701}, "CVE-2023-23150": {"epss_score": 0.00227, "epss_percentile": 0.45373}, "CVE-2023-23151": {"epss_score": 0.00234, "epss_percentile": 0.46118}, "CVE-2023-23155": {"epss_score": 0.00468, "epss_percentile": 0.63885}, "CVE-2023-23156": {"epss_score": 0.01462, "epss_percentile": 0.80439}, "CVE-2023-23157": {"epss_score": 0.0013, "epss_percentile": 0.33264}, "CVE-2023-23158": {"epss_score": 0.0013, "epss_percentile": 0.33264}, "CVE-2023-23161": {"epss_score": 0.07984, "epss_percentile": 0.91803}, "CVE-2023-23162": {"epss_score": 0.00531, "epss_percentile": 0.6667}, "CVE-2023-23163": {"epss_score": 0.00721, "epss_percentile": 0.71979}, "CVE-2023-23169": {"epss_score": 0.00722, "epss_percentile": 0.71999}, "CVE-2023-23192": {"epss_score": 0.02519, "epss_percentile": 0.84996}, "CVE-2023-23205": {"epss_score": 0.00027, "epss_percentile": 0.06926}, "CVE-2023-23208": {"epss_score": 0.00368, "epss_percentile": 0.58198}, "CVE-2023-23277": {"epss_score": 0.00079, "epss_percentile": 0.23917}, "CVE-2023-23279": {"epss_score": 0.00309, "epss_percentile": 0.53686}, "CVE-2023-23286": {"epss_score": 0.01021, "epss_percentile": 0.76752}, "CVE-2023-23294": {"epss_score": 0.01142, "epss_percentile": 0.77977}, "CVE-2023-23295": {"epss_score": 0.01498, "epss_percentile": 0.80702}, "CVE-2023-23296": {"epss_score": 0.00092, "epss_percentile": 0.26428}, "CVE-2023-23298": {"epss_score": 0.00568, "epss_percentile": 0.67882}, "CVE-2023-23299": {"epss_score": 0.00116, "epss_percentile": 0.31166}, "CVE-2023-23300": {"epss_score": 0.00327, "epss_percentile": 0.55143}, "CVE-2023-23301": {"epss_score": 0.00289, "epss_percentile": 0.51982}, "CVE-2023-23302": {"epss_score": 0.00327, "epss_percentile": 0.55143}, "CVE-2023-23303": {"epss_score": 0.00306, "epss_percentile": 0.53441}, "CVE-2023-23304": {"epss_score": 0.00134, "epss_percentile": 0.33759}, "CVE-2023-23305": {"epss_score": 0.00356, "epss_percentile": 0.57366}, "CVE-2023-23306": {"epss_score": 0.00509, "epss_percentile": 0.65737}, "CVE-2023-23313": {"epss_score": 0.02304, "epss_percentile": 0.84321}, "CVE-2023-23314": {"epss_score": 0.00238, "epss_percentile": 0.46789}, "CVE-2023-23315": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-23324": {"epss_score": 0.00211, "epss_percentile": 0.43715}, "CVE-2023-23325": {"epss_score": 0.00802, "epss_percentile": 0.73589}, "CVE-2023-23326": {"epss_score": 0.01517, "epss_percentile": 0.8081}, "CVE-2023-23327": {"epss_score": 0.0015, "epss_percentile": 0.36145}, "CVE-2023-23328": {"epss_score": 0.00128, "epss_percentile": 0.33063}, "CVE-2023-23330": {"epss_score": 0.00085, "epss_percentile": 0.25152}, "CVE-2023-23331": {"epss_score": 0.00091, "epss_percentile": 0.26196}, "CVE-2023-23333": {"epss_score": 0.94216, "epss_percentile": 0.99918}, "CVE-2023-23342": {"epss_score": 0.00055, "epss_percentile": 0.17367}, "CVE-2023-23343": {"epss_score": 0.00047, "epss_percentile": 0.14789}, "CVE-2023-23344": {"epss_score": 0.00134, "epss_percentile": 0.33766}, "CVE-2023-23346": {"epss_score": 0.00035, "epss_percentile": 0.09873}, "CVE-2023-23347": {"epss_score": 0.00035, "epss_percentile": 0.09873}, "CVE-2023-23348": {"epss_score": 0.00076, "epss_percentile": 0.23127}, "CVE-2023-23349": {"epss_score": 0.00013, "epss_percentile": 0.01693}, "CVE-2023-23354": {"epss_score": 0.00101, "epss_percentile": 0.28567}, "CVE-2023-23355": {"epss_score": 0.00279, "epss_percentile": 0.5097}, "CVE-2023-23356": {"epss_score": 0.00076, "epss_percentile": 0.23176}, "CVE-2023-23357": {"epss_score": 0.00126, "epss_percentile": 0.32771}, "CVE-2023-23362": {"epss_score": 0.00433, "epss_percentile": 0.62189}, "CVE-2023-23363": {"epss_score": 0.00659, "epss_percentile": 0.70499}, "CVE-2023-23364": {"epss_score": 0.00659, "epss_percentile": 0.70499}, "CVE-2023-23365": {"epss_score": 0.00147, "epss_percentile": 0.35754}, "CVE-2023-23366": {"epss_score": 0.00147, "epss_percentile": 0.35754}, "CVE-2023-23367": {"epss_score": 0.00163, "epss_percentile": 0.37821}, "CVE-2023-23368": {"epss_score": 0.03562, "epss_percentile": 0.87355}, "CVE-2023-23369": {"epss_score": 0.11812, "epss_percentile": 0.93483}, "CVE-2023-23370": {"epss_score": 0.00024, "epss_percentile": 0.05724}, "CVE-2023-23371": {"epss_score": 0.00014, "epss_percentile": 0.01991}, "CVE-2023-23372": {"epss_score": 0.00225, "epss_percentile": 0.45106}, "CVE-2023-23373": {"epss_score": 0.00279, "epss_percentile": 0.50941}, "CVE-2023-23374": {"epss_score": 0.00139, "epss_percentile": 0.34572}, "CVE-2023-23375": {"epss_score": 0.0043, "epss_percentile": 0.62026}, "CVE-2023-23376": {"epss_score": 0.20051, "epss_percentile": 0.95281}, "CVE-2023-23377": {"epss_score": 0.00901, "epss_percentile": 0.75175}, "CVE-2023-23378": {"epss_score": 0.00831, "epss_percentile": 0.74043}, "CVE-2023-23379": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2023-23381": {"epss_score": 0.00132, "epss_percentile": 0.33614}, "CVE-2023-23382": {"epss_score": 0.01037, "epss_percentile": 0.76928}, "CVE-2023-23383": {"epss_score": 0.02243, "epss_percentile": 0.8412}, "CVE-2023-23384": {"epss_score": 0.00835, "epss_percentile": 0.74123}, "CVE-2023-23385": {"epss_score": 0.00402, "epss_percentile": 0.603}, "CVE-2023-23388": {"epss_score": 0.12838, "epss_percentile": 0.93798}, "CVE-2023-23389": {"epss_score": 0.00084, "epss_percentile": 0.24919}, "CVE-2023-23390": {"epss_score": 0.00901, "epss_percentile": 0.75175}, "CVE-2023-23391": {"epss_score": 0.00242, "epss_percentile": 0.47368}, "CVE-2023-23392": {"epss_score": 0.05281, "epss_percentile": 0.89689}, "CVE-2023-23393": {"epss_score": 0.00117, "epss_percentile": 0.3131}, "CVE-2023-23394": {"epss_score": 0.00511, "epss_percentile": 0.65823}, "CVE-2023-23395": {"epss_score": 0.01126, "epss_percentile": 0.77812}, "CVE-2023-23396": {"epss_score": 0.04919, "epss_percentile": 0.8929}, "CVE-2023-23397": {"epss_score": 0.93641, "epss_percentile": 0.99828}, "CVE-2023-23398": {"epss_score": 0.00478, "epss_percentile": 0.64402}, "CVE-2023-23399": {"epss_score": 0.02043, "epss_percentile": 0.83378}, "CVE-2023-23400": {"epss_score": 0.01275, "epss_percentile": 0.79105}, "CVE-2023-23401": {"epss_score": 0.00412, "epss_percentile": 0.60945}, "CVE-2023-23402": {"epss_score": 0.01153, "epss_percentile": 0.78054}, "CVE-2023-23403": {"epss_score": 0.0328, "epss_percentile": 0.86813}, "CVE-2023-23404": {"epss_score": 0.006, "epss_percentile": 0.68822}, "CVE-2023-23405": {"epss_score": 0.01097, "epss_percentile": 0.77528}, "CVE-2023-23406": {"epss_score": 0.0328, "epss_percentile": 0.86813}, "CVE-2023-23407": {"epss_score": 0.00184, "epss_percentile": 0.40372}, "CVE-2023-23408": {"epss_score": 0.02429, "epss_percentile": 0.84724}, "CVE-2023-23409": {"epss_score": 0.01148, "epss_percentile": 0.78016}, "CVE-2023-23410": {"epss_score": 0.26754, "epss_percentile": 0.96173}, "CVE-2023-23411": {"epss_score": 0.00084, "epss_percentile": 0.24914}, "CVE-2023-23412": {"epss_score": 0.00122, "epss_percentile": 0.32041}, "CVE-2023-23413": {"epss_score": 0.00488, "epss_percentile": 0.64863}, "CVE-2023-23414": {"epss_score": 0.00184, "epss_percentile": 0.40372}, "CVE-2023-23415": {"epss_score": 0.03768, "epss_percentile": 0.87698}, "CVE-2023-23416": {"epss_score": 0.04161, "epss_percentile": 0.88335}, "CVE-2023-23417": {"epss_score": 0.00451, "epss_percentile": 0.63111}, "CVE-2023-23418": {"epss_score": 0.00173, "epss_percentile": 0.39121}, "CVE-2023-23419": {"epss_score": 0.0017, "epss_percentile": 0.38677}, "CVE-2023-23420": {"epss_score": 0.00263, "epss_percentile": 0.49536}, "CVE-2023-23421": {"epss_score": 0.00327, "epss_percentile": 0.55137}, "CVE-2023-23422": {"epss_score": 0.00318, "epss_percentile": 0.54429}, "CVE-2023-23423": {"epss_score": 0.00318, "epss_percentile": 0.54429}, "CVE-2023-23424": {"epss_score": 0.00214, "epss_percentile": 0.44021}, "CVE-2023-23426": {"epss_score": 0.00058, "epss_percentile": 0.18418}, "CVE-2023-23427": {"epss_score": 0.00064, "epss_percentile": 0.2015}, "CVE-2023-23428": {"epss_score": 0.00079, "epss_percentile": 0.23985}, "CVE-2023-23429": {"epss_score": 0.00088, "epss_percentile": 0.25742}, "CVE-2023-23430": {"epss_score": 0.00079, "epss_percentile": 0.23985}, "CVE-2023-23431": {"epss_score": 0.0003, "epss_percentile": 0.08066}, "CVE-2023-23432": {"epss_score": 0.0003, "epss_percentile": 0.08066}, "CVE-2023-23433": {"epss_score": 0.0002, "epss_percentile": 0.04496}, "CVE-2023-23434": {"epss_score": 0.00059, "epss_percentile": 0.18852}, "CVE-2023-23435": {"epss_score": 0.00026, "epss_percentile": 0.06659}, "CVE-2023-23436": {"epss_score": 0.00016, "epss_percentile": 0.02983}, "CVE-2023-23437": {"epss_score": 0.00113, "epss_percentile": 0.30695}, "CVE-2023-23438": {"epss_score": 0.00037, "epss_percentile": 0.11005}, "CVE-2023-23439": {"epss_score": 0.00045, "epss_percentile": 0.13681}, "CVE-2023-23440": {"epss_score": 0.00152, "epss_percentile": 0.36486}, "CVE-2023-23441": {"epss_score": 0.00042, "epss_percentile": 0.12727}, "CVE-2023-23442": {"epss_score": 0.0003, "epss_percentile": 0.08229}, "CVE-2023-23443": {"epss_score": 0.0003, "epss_percentile": 0.08229}, "CVE-2023-23444": {"epss_score": 0.00567, "epss_percentile": 0.67839}, "CVE-2023-23445": {"epss_score": 0.00164, "epss_percentile": 0.37881}, "CVE-2023-23446": {"epss_score": 0.00169, "epss_percentile": 0.38645}, "CVE-2023-23447": {"epss_score": 0.00318, "epss_percentile": 0.54454}, "CVE-2023-23448": {"epss_score": 0.00136, "epss_percentile": 0.34082}, "CVE-2023-23449": {"epss_score": 0.00184, "epss_percentile": 0.40435}, "CVE-2023-23450": {"epss_score": 0.0022, "epss_percentile": 0.44547}, "CVE-2023-23451": {"epss_score": 0.00185, "epss_percentile": 0.40544}, "CVE-2023-23452": {"epss_score": 0.03312, "epss_percentile": 0.86894}, "CVE-2023-23453": {"epss_score": 0.03312, "epss_percentile": 0.86894}, "CVE-2023-23454": {"epss_score": 0.00053, "epss_percentile": 0.1693}, "CVE-2023-23455": {"epss_score": 0.00023, "epss_percentile": 0.05612}, "CVE-2023-23456": {"epss_score": 0.00013, "epss_percentile": 0.01672}, "CVE-2023-23457": {"epss_score": 0.00027, "epss_percentile": 0.06885}, "CVE-2023-23458": {"epss_score": 0.00115, "epss_percentile": 0.31011}, "CVE-2023-23459": {"epss_score": 0.00096, "epss_percentile": 0.27265}, "CVE-2023-23460": {"epss_score": 0.00043, "epss_percentile": 0.13327}, "CVE-2023-23461": {"epss_score": 0.00131, "epss_percentile": 0.33418}, "CVE-2023-23462": {"epss_score": 0.00131, "epss_percentile": 0.33418}, "CVE-2023-23463": {"epss_score": 0.00104, "epss_percentile": 0.29196}, "CVE-2023-23464": {"epss_score": 0.00097, "epss_percentile": 0.2758}, "CVE-2023-23465": {"epss_score": 0.00099, "epss_percentile": 0.28394}, "CVE-2023-23466": {"epss_score": 0.00066, "epss_percentile": 0.20879}, "CVE-2023-23467": {"epss_score": 0.00111, "epss_percentile": 0.304}, "CVE-2023-23468": {"epss_score": 0.00019, "epss_percentile": 0.04053}, "CVE-2023-23469": {"epss_score": 0.00033, "epss_percentile": 0.09397}, "CVE-2023-23470": {"epss_score": 0.00068, "epss_percentile": 0.21285}, "CVE-2023-23472": {"epss_score": 0.0013, "epss_percentile": 0.33315}, "CVE-2023-23473": {"epss_score": 0.00037, "epss_percentile": 0.10669}, "CVE-2023-23474": {"epss_score": 0.00048, "epss_percentile": 0.15103}, "CVE-2023-23475": {"epss_score": 0.00205, "epss_percentile": 0.42708}, "CVE-2023-23476": {"epss_score": 0.00061, "epss_percentile": 0.19468}, "CVE-2023-23477": {"epss_score": 0.00108, "epss_percentile": 0.29851}, "CVE-2023-23480": {"epss_score": 0.00135, "epss_percentile": 0.34016}, "CVE-2023-23481": {"epss_score": 0.00135, "epss_percentile": 0.34016}, "CVE-2023-23482": {"epss_score": 0.00053, "epss_percentile": 0.16698}, "CVE-2023-23487": {"epss_score": 0.00067, "epss_percentile": 0.2103}, "CVE-2023-23488": {"epss_score": 0.84182, "epss_percentile": 0.99278}, "CVE-2023-23489": {"epss_score": 0.83311, "epss_percentile": 0.99244}, "CVE-2023-23490": {"epss_score": 0.00945, "epss_percentile": 0.75795}, "CVE-2023-23491": {"epss_score": 0.07588, "epss_percentile": 0.91557}, "CVE-2023-23492": {"epss_score": 0.86984, "epss_percentile": 0.99406}, "CVE-2023-23493": {"epss_score": 0.00028, "epss_percentile": 0.07232}, "CVE-2023-23494": {"epss_score": 0.00237, "epss_percentile": 0.46686}, "CVE-2023-23495": {"epss_score": 0.00093, "epss_percentile": 0.26718}, "CVE-2023-23496": {"epss_score": 0.00231, "epss_percentile": 0.45785}, "CVE-2023-23497": {"epss_score": 0.00027, "epss_percentile": 0.07095}, "CVE-2023-23498": {"epss_score": 0.00033, "epss_percentile": 0.09154}, "CVE-2023-23499": {"epss_score": 0.00033, "epss_percentile": 0.09362}, "CVE-2023-23500": {"epss_score": 0.00045, "epss_percentile": 0.13963}, "CVE-2023-23501": {"epss_score": 0.0005, "epss_percentile": 0.15946}, "CVE-2023-23502": {"epss_score": 0.00045, "epss_percentile": 0.1407}, "CVE-2023-23503": {"epss_score": 0.00012, "epss_percentile": 0.01294}, "CVE-2023-23504": {"epss_score": 0.0006, "epss_percentile": 0.18933}, "CVE-2023-23505": {"epss_score": 0.00029, "epss_percentile": 0.07943}, "CVE-2023-23506": {"epss_score": 0.00029, "epss_percentile": 0.07905}, "CVE-2023-23507": {"epss_score": 0.00033, "epss_percentile": 0.0932}, "CVE-2023-23508": {"epss_score": 0.00012, "epss_percentile": 0.0125}, "CVE-2023-23510": {"epss_score": 0.00029, "epss_percentile": 0.07905}, "CVE-2023-23511": {"epss_score": 0.00014, "epss_percentile": 0.01772}, "CVE-2023-23512": {"epss_score": 0.00164, "epss_percentile": 0.37896}, "CVE-2023-23513": {"epss_score": 0.00429, "epss_percentile": 0.62001}, "CVE-2023-23514": {"epss_score": 0.0038, "epss_percentile": 0.58968}, "CVE-2023-23516": {"epss_score": 0.00036, "epss_percentile": 0.10164}, "CVE-2023-23517": {"epss_score": 0.00191, "epss_percentile": 0.41163}, "CVE-2023-23518": {"epss_score": 0.00175, "epss_percentile": 0.39371}, "CVE-2023-23519": {"epss_score": 0.00155, "epss_percentile": 0.36764}, "CVE-2023-23520": {"epss_score": 0.00107, "epss_percentile": 0.29677}, "CVE-2023-23522": {"epss_score": 0.00046, "epss_percentile": 0.14171}, "CVE-2023-23523": {"epss_score": 0.00044, "epss_percentile": 0.1339}, "CVE-2023-23524": {"epss_score": 0.00124, "epss_percentile": 0.32388}, "CVE-2023-23525": {"epss_score": 0.0004, "epss_percentile": 0.11957}, "CVE-2023-23526": {"epss_score": 0.00036, "epss_percentile": 0.105}, "CVE-2023-23527": {"epss_score": 0.00031, "epss_percentile": 0.08715}, "CVE-2023-23528": {"epss_score": 0.00055, "epss_percentile": 0.17565}, "CVE-2023-23529": {"epss_score": 0.00045, "epss_percentile": 0.1377}, "CVE-2023-23530": {"epss_score": 0.00088, "epss_percentile": 0.25686}, "CVE-2023-23531": {"epss_score": 0.00505, "epss_percentile": 0.65599}, "CVE-2023-23532": {"epss_score": 0.00043, "epss_percentile": 0.13009}, "CVE-2023-23533": {"epss_score": 0.00028, "epss_percentile": 0.0751}, "CVE-2023-23534": {"epss_score": 0.00039, "epss_percentile": 0.11651}, "CVE-2023-23535": {"epss_score": 0.00023, "epss_percentile": 0.05624}, "CVE-2023-23536": {"epss_score": 0.00191, "epss_percentile": 0.41218}, "CVE-2023-23537": {"epss_score": 0.00041, "epss_percentile": 0.12444}, "CVE-2023-23538": {"epss_score": 0.00025, "epss_percentile": 0.06303}, "CVE-2023-23539": {"epss_score": 0.00052, "epss_percentile": 0.16625}, "CVE-2023-23540": {"epss_score": 0.00057, "epss_percentile": 0.18173}, "CVE-2023-23541": {"epss_score": 0.00042, "epss_percentile": 0.12738}, "CVE-2023-23542": {"epss_score": 0.00048, "epss_percentile": 0.15247}, "CVE-2023-23543": {"epss_score": 0.00047, "epss_percentile": 0.14584}, "CVE-2023-23545": {"epss_score": 0.00535, "epss_percentile": 0.66834}, "CVE-2023-23546": {"epss_score": 0.00132, "epss_percentile": 0.33559}, "CVE-2023-23547": {"epss_score": 0.00471, "epss_percentile": 0.64026}, "CVE-2023-23548": {"epss_score": 0.00435, "epss_percentile": 0.62365}, "CVE-2023-23549": {"epss_score": 0.00053, "epss_percentile": 0.16878}, "CVE-2023-23550": {"epss_score": 0.00186, "epss_percentile": 0.40593}, "CVE-2023-23551": {"epss_score": 0.00121, "epss_percentile": 0.31949}, "CVE-2023-23552": {"epss_score": 0.53047, "epss_percentile": 0.97853}, "CVE-2023-23553": {"epss_score": 0.00087, "epss_percentile": 0.25543}, "CVE-2023-23554": {"epss_score": 0.001, "epss_percentile": 0.28445}, "CVE-2023-23555": {"epss_score": 0.00484, "epss_percentile": 0.64654}, "CVE-2023-23556": {"epss_score": 0.00408, "epss_percentile": 0.60656}, "CVE-2023-23557": {"epss_score": 0.0054, "epss_percentile": 0.6701}, "CVE-2023-23558": {"epss_score": 0.00048, "epss_percentile": 0.152}, "CVE-2023-23559": {"epss_score": 0.00023, "epss_percentile": 0.05377}, "CVE-2023-23560": {"epss_score": 0.01041, "epss_percentile": 0.76964}, "CVE-2023-23561": {"epss_score": 0.00047, "epss_percentile": 0.1471}, "CVE-2023-23562": {"epss_score": 0.00128, "epss_percentile": 0.33026}, "CVE-2023-23563": {"epss_score": 0.00125, "epss_percentile": 0.32599}, "CVE-2023-23564": {"epss_score": 0.00959, "epss_percentile": 0.75957}, "CVE-2023-23565": {"epss_score": 0.0013, "epss_percentile": 0.33249}, "CVE-2023-23566": {"epss_score": 0.00293, "epss_percentile": 0.52295}, "CVE-2023-23567": {"epss_score": 0.00223, "epss_percentile": 0.44864}, "CVE-2023-23568": {"epss_score": 0.00071, "epss_percentile": 0.22034}, "CVE-2023-23569": {"epss_score": 0.0012, "epss_percentile": 0.31703}, "CVE-2023-23570": {"epss_score": 0.00042, "epss_percentile": 0.12607}, "CVE-2023-23571": {"epss_score": 0.00093, "epss_percentile": 0.26652}, "CVE-2023-23572": {"epss_score": 0.00385, "epss_percentile": 0.59206}, "CVE-2023-23573": {"epss_score": 0.00074, "epss_percentile": 0.2288}, "CVE-2023-23574": {"epss_score": 0.00209, "epss_percentile": 0.43368}, "CVE-2023-23575": {"epss_score": 0.0021, "epss_percentile": 0.43445}, "CVE-2023-23576": {"epss_score": 0.00079, "epss_percentile": 0.2387}, "CVE-2023-23577": {"epss_score": 0.00082, "epss_percentile": 0.24555}, "CVE-2023-23578": {"epss_score": 0.00336, "epss_percentile": 0.55947}, "CVE-2023-23579": {"epss_score": 0.00043, "epss_percentile": 0.13313}, "CVE-2023-23580": {"epss_score": 0.00081, "epss_percentile": 0.24251}, "CVE-2023-23581": {"epss_score": 0.00068, "epss_percentile": 0.21303}, "CVE-2023-23582": {"epss_score": 0.0014, "epss_percentile": 0.34759}, "CVE-2023-23583": {"epss_score": 0.00035, "epss_percentile": 0.09923}, "CVE-2023-23584": {"epss_score": 0.00168, "epss_percentile": 0.38432}, "CVE-2023-23585": {"epss_score": 0.00055, "epss_percentile": 0.17405}, "CVE-2023-23586": {"epss_score": 0.00014, "epss_percentile": 0.02011}, "CVE-2023-23588": {"epss_score": 0.00039, "epss_percentile": 0.11653}, "CVE-2023-23589": {"epss_score": 0.00258, "epss_percentile": 0.48992}, "CVE-2023-23590": {"epss_score": 0.18069, "epss_percentile": 0.94952}, "CVE-2023-23591": {"epss_score": 0.00088, "epss_percentile": 0.25774}, "CVE-2023-23592": {"epss_score": 0.00218, "epss_percentile": 0.44372}, "CVE-2023-23594": {"epss_score": 0.00339, "epss_percentile": 0.56189}, "CVE-2023-23595": {"epss_score": 0.0023, "epss_percentile": 0.45729}, "CVE-2023-23596": {"epss_score": 0.01311, "epss_percentile": 0.79369}, "CVE-2023-23597": {"epss_score": 0.00075, "epss_percentile": 0.22973}, "CVE-2023-23598": {"epss_score": 0.00179, "epss_percentile": 0.39817}, "CVE-2023-23599": {"epss_score": 0.00125, "epss_percentile": 0.32567}, "CVE-2023-23600": {"epss_score": 0.00187, "epss_percentile": 0.4075}, "CVE-2023-23601": {"epss_score": 0.00104, "epss_percentile": 0.29172}, "CVE-2023-23602": {"epss_score": 0.00128, "epss_percentile": 0.32944}, "CVE-2023-23603": {"epss_score": 0.0016, "epss_percentile": 0.37475}, "CVE-2023-23604": {"epss_score": 0.00028, "epss_percentile": 0.0744}, "CVE-2023-23605": {"epss_score": 0.00136, "epss_percentile": 0.34141}, "CVE-2023-23606": {"epss_score": 0.00159, "epss_percentile": 0.37421}, "CVE-2023-23607": {"epss_score": 0.02126, "epss_percentile": 0.83694}, "CVE-2023-23608": {"epss_score": 0.0044, "epss_percentile": 0.62636}, "CVE-2023-23609": {"epss_score": 0.00092, "epss_percentile": 0.26483}, "CVE-2023-23610": {"epss_score": 0.00192, "epss_percentile": 0.41347}, "CVE-2023-23611": {"epss_score": 0.00196, "epss_percentile": 0.41751}, "CVE-2023-23612": {"epss_score": 0.00122, "epss_percentile": 0.32125}, "CVE-2023-23613": {"epss_score": 0.0021, "epss_percentile": 0.43429}, "CVE-2023-23614": {"epss_score": 0.0023, "epss_percentile": 0.45716}, "CVE-2023-23615": {"epss_score": 0.00074, "epss_percentile": 0.22855}, "CVE-2023-23616": {"epss_score": 0.00071, "epss_percentile": 0.22197}, "CVE-2023-23617": {"epss_score": 0.00195, "epss_percentile": 0.41705}, "CVE-2023-23618": {"epss_score": 0.00067, "epss_percentile": 0.21112}, "CVE-2023-23619": {"epss_score": 0.00275, "epss_percentile": 0.50642}, "CVE-2023-23620": {"epss_score": 0.00128, "epss_percentile": 0.33014}, "CVE-2023-23621": {"epss_score": 0.00091, "epss_percentile": 0.26224}, "CVE-2023-23622": {"epss_score": 0.00271, "epss_percentile": 0.50338}, "CVE-2023-23623": {"epss_score": 0.00501, "epss_percentile": 0.65336}, "CVE-2023-23624": {"epss_score": 0.00109, "epss_percentile": 0.29991}, "CVE-2023-23625": {"epss_score": 0.00291, "epss_percentile": 0.52174}, "CVE-2023-23626": {"epss_score": 0.00239, "epss_percentile": 0.46924}, "CVE-2023-23627": {"epss_score": 0.00378, "epss_percentile": 0.58808}, "CVE-2023-23628": {"epss_score": 0.0011, "epss_percentile": 0.30129}, "CVE-2023-23629": {"epss_score": 0.00047, "epss_percentile": 0.14624}, "CVE-2023-23630": {"epss_score": 0.00232, "epss_percentile": 0.45887}, "CVE-2023-23631": {"epss_score": 0.00377, "epss_percentile": 0.58748}, "CVE-2023-23632": {"epss_score": 0.0001, "epss_percentile": 0.00877}, "CVE-2023-23634": {"epss_score": 0.02215, "epss_percentile": 0.84027}, "CVE-2023-23635": {"epss_score": 0.00616, "epss_percentile": 0.69323}, "CVE-2023-23636": {"epss_score": 0.00783, "epss_percentile": 0.73224}, "CVE-2023-23637": {"epss_score": 0.00127, "epss_percentile": 0.32881}, "CVE-2023-23638": {"epss_score": 0.68129, "epss_percentile": 0.98532}, "CVE-2023-23639": {"epss_score": 0.00282, "epss_percentile": 0.51214}, "CVE-2023-23640": {"epss_score": 0.00282, "epss_percentile": 0.51214}, "CVE-2023-23641": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23645": {"epss_score": 0.01001, "epss_percentile": 0.76493}, "CVE-2023-23646": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2023-23647": {"epss_score": 0.00056, "epss_percentile": 0.17673}, "CVE-2023-23649": {"epss_score": 0.00666, "epss_percentile": 0.70673}, "CVE-2023-23650": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-23651": {"epss_score": 0.00147, "epss_percentile": 0.35701}, "CVE-2023-23654": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23656": {"epss_score": 0.00464, "epss_percentile": 0.63703}, "CVE-2023-23657": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23659": {"epss_score": 0.00094, "epss_percentile": 0.26965}, "CVE-2023-23660": {"epss_score": 0.00124, "epss_percentile": 0.32444}, "CVE-2023-23664": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23667": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23668": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23670": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-23671": {"epss_score": 0.00061, "epss_percentile": 0.19334}, "CVE-2023-23672": {"epss_score": 0.00108, "epss_percentile": 0.29857}, "CVE-2023-23673": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23674": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23675": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23676": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23677": {"epss_score": 0.00112, "epss_percentile": 0.30441}, "CVE-2023-23678": {"epss_score": 0.00483, "epss_percentile": 0.64566}, "CVE-2023-23679": {"epss_score": 0.00027, "epss_percentile": 0.06978}, "CVE-2023-23680": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-23681": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-23682": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23683": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23684": {"epss_score": 0.00131, "epss_percentile": 0.33481}, "CVE-2023-23685": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-23686": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-23687": {"epss_score": 0.00098, "epss_percentile": 0.27681}, "CVE-2023-23688": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23689": {"epss_score": 0.00152, "epss_percentile": 0.36426}, "CVE-2023-23690": {"epss_score": 0.00098, "epss_percentile": 0.27824}, "CVE-2023-23691": {"epss_score": 0.00572, "epss_percentile": 0.68034}, "CVE-2023-23692": {"epss_score": 0.00966, "epss_percentile": 0.76062}, "CVE-2023-23693": {"epss_score": 0.00091, "epss_percentile": 0.26172}, "CVE-2023-23694": {"epss_score": 0.00181, "epss_percentile": 0.40036}, "CVE-2023-23695": {"epss_score": 0.00194, "epss_percentile": 0.41522}, "CVE-2023-23696": {"epss_score": 0.00094, "epss_percentile": 0.26771}, "CVE-2023-23697": {"epss_score": 0.0005, "epss_percentile": 0.1573}, "CVE-2023-23698": {"epss_score": 0.00071, "epss_percentile": 0.2205}, "CVE-2023-23699": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23700": {"epss_score": 0.00432, "epss_percentile": 0.62132}, "CVE-2023-23701": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23702": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-23703": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23704": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-23705": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-23706": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-23707": {"epss_score": 0.00069, "epss_percentile": 0.21631}, "CVE-2023-23708": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23709": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23710": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23711": {"epss_score": 0.00089, "epss_percentile": 0.2588}, "CVE-2023-23712": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-23713": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-23714": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2023-23715": {"epss_score": 0.00151, "epss_percentile": 0.36231}, "CVE-2023-23716": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-23717": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23718": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23719": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2023-23720": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23721": {"epss_score": 0.00088, "epss_percentile": 0.25708}, "CVE-2023-23722": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23723": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23724": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-23725": {"epss_score": 0.00115, "epss_percentile": 0.30925}, "CVE-2023-23726": {"epss_score": 0.00065, "epss_percentile": 0.2066}, "CVE-2023-23727": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23728": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-23729": {"epss_score": 0.00033, "epss_percentile": 0.09336}, "CVE-2023-23730": {"epss_score": 0.00133, "epss_percentile": 0.33687}, "CVE-2023-23731": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-23732": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23733": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23734": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23735": {"epss_score": 0.00339, "epss_percentile": 0.56182}, "CVE-2023-23737": {"epss_score": 0.00147, "epss_percentile": 0.3569}, "CVE-2023-23738": {"epss_score": 0.00352, "epss_percentile": 0.57134}, "CVE-2023-23749": {"epss_score": 0.00123, "epss_percentile": 0.32335}, "CVE-2023-23750": {"epss_score": 6e-05, "epss_percentile": 0.00281}, "CVE-2023-23751": {"epss_score": 7e-05, "epss_percentile": 0.00338}, "CVE-2023-23752": {"epss_score": 0.94517, "epss_percentile": 1.0}, "CVE-2023-23753": {"epss_score": 0.00272, "epss_percentile": 0.50392}, "CVE-2023-23754": {"epss_score": 0.00016, "epss_percentile": 0.02931}, "CVE-2023-23755": {"epss_score": 4e-05, "epss_percentile": 0.0014}, "CVE-2023-23756": {"epss_score": 0.0008, "epss_percentile": 0.24131}, "CVE-2023-23757": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-23758": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-23759": {"epss_score": 0.0021, "epss_percentile": 0.43435}, "CVE-2023-23760": {"epss_score": 0.00642, "epss_percentile": 0.70043}, "CVE-2023-23761": {"epss_score": 0.0009, "epss_percentile": 0.2613}, "CVE-2023-23762": {"epss_score": 0.00162, "epss_percentile": 0.3769}, "CVE-2023-23763": {"epss_score": 0.00111, "epss_percentile": 0.30355}, "CVE-2023-23764": {"epss_score": 0.00146, "epss_percentile": 0.35605}, "CVE-2023-23765": {"epss_score": 0.00076, "epss_percentile": 0.23167}, "CVE-2023-23766": {"epss_score": 0.00107, "epss_percentile": 0.29664}, "CVE-2023-23770": {"epss_score": 0.00111, "epss_percentile": 0.304}, "CVE-2023-23771": {"epss_score": 0.00031, "epss_percentile": 0.08644}, "CVE-2023-23772": {"epss_score": 0.00029, "epss_percentile": 0.07654}, "CVE-2023-23773": {"epss_score": 0.00029, "epss_percentile": 0.07654}, "CVE-2023-23774": {"epss_score": 0.00028, "epss_percentile": 0.07246}, "CVE-2023-23775": {"epss_score": 0.00064, "epss_percentile": 0.20177}, "CVE-2023-23776": {"epss_score": 0.00073, "epss_percentile": 0.22535}, "CVE-2023-23777": {"epss_score": 0.00309, "epss_percentile": 0.5367}, "CVE-2023-23778": {"epss_score": 0.00222, "epss_percentile": 0.44824}, "CVE-2023-23779": {"epss_score": 0.00165, "epss_percentile": 0.38077}, "CVE-2023-23780": {"epss_score": 0.00738, "epss_percentile": 0.72343}, "CVE-2023-23781": {"epss_score": 0.0034, "epss_percentile": 0.56242}, "CVE-2023-23782": {"epss_score": 0.00112, "epss_percentile": 0.30436}, "CVE-2023-23783": {"epss_score": 0.00055, "epss_percentile": 0.1758}, "CVE-2023-23784": {"epss_score": 0.00225, "epss_percentile": 0.45235}, "CVE-2023-23785": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23786": {"epss_score": 0.00056, "epss_percentile": 0.17673}, "CVE-2023-23787": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-23788": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23789": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23790": {"epss_score": 0.00072, "epss_percentile": 0.22277}, "CVE-2023-23791": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-23792": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-23793": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23794": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23795": {"epss_score": 0.00061, "epss_percentile": 0.1929}, "CVE-2023-23796": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2023-23797": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-23798": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23799": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23800": {"epss_score": 0.00181, "epss_percentile": 0.40075}, "CVE-2023-23801": {"epss_score": 0.00115, "epss_percentile": 0.30978}, "CVE-2023-23802": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2023-23803": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-23804": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-23806": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23807": {"epss_score": 0.00054, "epss_percentile": 0.17052}, "CVE-2023-23808": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23809": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23810": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23811": {"epss_score": 0.00054, "epss_percentile": 0.17052}, "CVE-2023-23812": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23813": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-23814": {"epss_score": 0.00082, "epss_percentile": 0.24495}, "CVE-2023-23815": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-23816": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23817": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23818": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23819": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23820": {"epss_score": 0.00158, "epss_percentile": 0.37289}, "CVE-2023-23821": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23822": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23823": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-23824": {"epss_score": 0.00172, "epss_percentile": 0.38911}, "CVE-2023-23825": {"epss_score": 0.00134, "epss_percentile": 0.33906}, "CVE-2023-23826": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23827": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23828": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23829": {"epss_score": 0.00051, "epss_percentile": 0.16045}, "CVE-2023-23830": {"epss_score": 0.00191, "epss_percentile": 0.41274}, "CVE-2023-23831": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2023-23832": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23833": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2023-23834": {"epss_score": 0.00228, "epss_percentile": 0.45514}, "CVE-2023-23835": {"epss_score": 0.00025, "epss_percentile": 0.06041}, "CVE-2023-23836": {"epss_score": 0.44216, "epss_percentile": 0.97424}, "CVE-2023-23837": {"epss_score": 0.0047, "epss_percentile": 0.63961}, "CVE-2023-23838": {"epss_score": 0.00784, "epss_percentile": 0.73238}, "CVE-2023-23839": {"epss_score": 0.00346, "epss_percentile": 0.5664}, "CVE-2023-23840": {"epss_score": 0.00291, "epss_percentile": 0.52157}, "CVE-2023-23841": {"epss_score": 0.00075, "epss_percentile": 0.23072}, "CVE-2023-23842": {"epss_score": 0.00298, "epss_percentile": 0.52807}, "CVE-2023-23843": {"epss_score": 0.00107, "epss_percentile": 0.2975}, "CVE-2023-23844": {"epss_score": 0.00109, "epss_percentile": 0.29998}, "CVE-2023-23845": {"epss_score": 0.00291, "epss_percentile": 0.52157}, "CVE-2023-23846": {"epss_score": 0.00191, "epss_percentile": 0.41217}, "CVE-2023-23847": {"epss_score": 0.00043, "epss_percentile": 0.13291}, "CVE-2023-23848": {"epss_score": 0.00093, "epss_percentile": 0.26682}, "CVE-2023-23849": {"epss_score": 0.00138, "epss_percentile": 0.34508}, "CVE-2023-23850": {"epss_score": 0.00098, "epss_percentile": 0.27723}, "CVE-2023-23851": {"epss_score": 0.00209, "epss_percentile": 0.4333}, "CVE-2023-23852": {"epss_score": 0.00591, "epss_percentile": 0.68602}, "CVE-2023-23853": {"epss_score": 0.00316, "epss_percentile": 0.54237}, "CVE-2023-23854": {"epss_score": 0.00086, "epss_percentile": 0.25365}, "CVE-2023-23855": {"epss_score": 0.00075, "epss_percentile": 0.23049}, "CVE-2023-23856": {"epss_score": 0.00283, "epss_percentile": 0.51413}, "CVE-2023-23857": {"epss_score": 0.00378, "epss_percentile": 0.58834}, "CVE-2023-23858": {"epss_score": 0.00294, "epss_percentile": 0.52395}, "CVE-2023-23859": {"epss_score": 0.0061, "epss_percentile": 0.6915}, "CVE-2023-23860": {"epss_score": 0.00341, "epss_percentile": 0.56297}, "CVE-2023-23861": {"epss_score": 0.00064, "epss_percentile": 0.20105}, "CVE-2023-23862": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23863": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23864": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-23865": {"epss_score": 0.00089, "epss_percentile": 0.2588}, "CVE-2023-23866": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23867": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23868": {"epss_score": 0.00092, "epss_percentile": 0.26427}, "CVE-2023-23869": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-23870": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23871": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-23872": {"epss_score": 0.00698, "epss_percentile": 0.71428}, "CVE-2023-23873": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23874": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23875": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23876": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23877": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23878": {"epss_score": 0.00069, "epss_percentile": 0.21631}, "CVE-2023-23879": {"epss_score": 0.00097, "epss_percentile": 0.27575}, "CVE-2023-23880": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23881": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23882": {"epss_score": 0.00052, "epss_percentile": 0.16367}, "CVE-2023-23883": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23884": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23885": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-23886": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-23887": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-23888": {"epss_score": 0.00382, "epss_percentile": 0.59076}, "CVE-2023-23889": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23890": {"epss_score": 0.00072, "epss_percentile": 0.22277}, "CVE-2023-23891": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-23892": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23893": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-23894": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-23895": {"epss_score": 0.00294, "epss_percentile": 0.52429}, "CVE-2023-23896": {"epss_score": 0.00086, "epss_percentile": 0.25307}, "CVE-2023-23897": {"epss_score": 0.40065, "epss_percentile": 0.97193}, "CVE-2023-23898": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-23899": {"epss_score": 0.00089, "epss_percentile": 0.2588}, "CVE-2023-23900": {"epss_score": 0.00186, "epss_percentile": 0.4061}, "CVE-2023-23901": {"epss_score": 0.00472, "epss_percentile": 0.64032}, "CVE-2023-23902": {"epss_score": 0.01529, "epss_percentile": 0.80876}, "CVE-2023-23903": {"epss_score": 0.00126, "epss_percentile": 0.32678}, "CVE-2023-23904": {"epss_score": 0.00048, "epss_percentile": 0.14995}, "CVE-2023-23906": {"epss_score": 0.00726, "epss_percentile": 0.72074}, "CVE-2023-23907": {"epss_score": 0.00239, "epss_percentile": 0.46915}, "CVE-2023-23908": {"epss_score": 0.00012, "epss_percentile": 0.01219}, "CVE-2023-23909": {"epss_score": 0.00096, "epss_percentile": 0.2726}, "CVE-2023-23910": {"epss_score": 0.00053, "epss_percentile": 0.16797}, "CVE-2023-23911": {"epss_score": 0.00121, "epss_percentile": 0.31891}, "CVE-2023-23912": {"epss_score": 0.02026, "epss_percentile": 0.83318}, "CVE-2023-23913": {"epss_score": 0.00065, "epss_percentile": 0.20535}, "CVE-2023-23914": {"epss_score": 0.00175, "epss_percentile": 0.39371}, "CVE-2023-23915": {"epss_score": 0.0003, "epss_percentile": 0.08034}, "CVE-2023-23916": {"epss_score": 0.0006, "epss_percentile": 0.19178}, "CVE-2023-23917": {"epss_score": 0.00494, "epss_percentile": 0.65084}, "CVE-2023-23918": {"epss_score": 0.00018, "epss_percentile": 0.03541}, "CVE-2023-23919": {"epss_score": 0.00565, "epss_percentile": 0.67793}, "CVE-2023-23920": {"epss_score": 0.00091, "epss_percentile": 0.26279}, "CVE-2023-23921": {"epss_score": 0.00238, "epss_percentile": 0.46825}, "CVE-2023-23922": {"epss_score": 0.00248, "epss_percentile": 0.47976}, "CVE-2023-23923": {"epss_score": 0.00432, "epss_percentile": 0.62128}, "CVE-2023-23924": {"epss_score": 0.56601, "epss_percentile": 0.98029}, "CVE-2023-23925": {"epss_score": 0.00277, "epss_percentile": 0.50816}, "CVE-2023-23926": {"epss_score": 0.00175, "epss_percentile": 0.39353}, "CVE-2023-23927": {"epss_score": 0.0955, "epss_percentile": 0.92594}, "CVE-2023-23928": {"epss_score": 0.00027, "epss_percentile": 0.07137}, "CVE-2023-23929": {"epss_score": 0.00101, "epss_percentile": 0.28596}, "CVE-2023-23930": {"epss_score": 0.00729, "epss_percentile": 0.72127}, "CVE-2023-23931": {"epss_score": 0.0066, "epss_percentile": 0.70532}, "CVE-2023-23932": {"epss_score": 0.00083, "epss_percentile": 0.24747}, "CVE-2023-23933": {"epss_score": 0.00113, "epss_percentile": 0.30676}, "CVE-2023-23934": {"epss_score": 0.00258, "epss_percentile": 0.48967}, "CVE-2023-23935": {"epss_score": 0.00286, "epss_percentile": 0.51752}, "CVE-2023-23936": {"epss_score": 0.00453, "epss_percentile": 0.63215}, "CVE-2023-23937": {"epss_score": 3e-05, "epss_percentile": 0.00112}, "CVE-2023-23938": {"epss_score": 0.00168, "epss_percentile": 0.38447}, "CVE-2023-23939": {"epss_score": 0.00335, "epss_percentile": 0.55852}, "CVE-2023-23940": {"epss_score": 9e-05, "epss_percentile": 0.00621}, "CVE-2023-23941": {"epss_score": 0.00075, "epss_percentile": 0.22894}, "CVE-2023-23942": {"epss_score": 0.01106, "epss_percentile": 0.77616}, "CVE-2023-23943": {"epss_score": 0.00439, "epss_percentile": 0.62607}, "CVE-2023-23944": {"epss_score": 0.00602, "epss_percentile": 0.68897}, "CVE-2023-23946": {"epss_score": 0.02424, "epss_percentile": 0.84711}, "CVE-2023-23947": {"epss_score": 0.00218, "epss_percentile": 0.44357}, "CVE-2023-23948": {"epss_score": 0.00134, "epss_percentile": 0.33828}, "CVE-2023-23949": {"epss_score": 0.00641, "epss_percentile": 0.69992}, "CVE-2023-23950": {"epss_score": 0.00875, "epss_percentile": 0.74773}, "CVE-2023-23951": {"epss_score": 0.00792, "epss_percentile": 0.73416}, "CVE-2023-23952": {"epss_score": 0.00688, "epss_percentile": 0.71207}, "CVE-2023-23953": {"epss_score": 0.00053, "epss_percentile": 0.16862}, "CVE-2023-23954": {"epss_score": 0.00331, "epss_percentile": 0.55537}, "CVE-2023-23955": {"epss_score": 0.00105, "epss_percentile": 0.29319}, "CVE-2023-23956": {"epss_score": 0.06679, "epss_percentile": 0.90938}, "CVE-2023-23957": {"epss_score": 0.00276, "epss_percentile": 0.50707}, "CVE-2023-23958": {"epss_score": 0.00238, "epss_percentile": 0.46805}, "CVE-2023-23969": {"epss_score": 0.03499, "epss_percentile": 0.87242}, "CVE-2023-23970": {"epss_score": 0.00314, "epss_percentile": 0.54089}, "CVE-2023-23971": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23972": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23973": {"epss_score": 0.00186, "epss_percentile": 0.40664}, "CVE-2023-23974": {"epss_score": 0.00134, "epss_percentile": 0.33898}, "CVE-2023-23975": {"epss_score": 0.0021, "epss_percentile": 0.43443}, "CVE-2023-23976": {"epss_score": 0.00074, "epss_percentile": 0.22824}, "CVE-2023-23977": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-23978": {"epss_score": 0.00276, "epss_percentile": 0.50751}, "CVE-2023-23979": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-23980": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23981": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23982": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23983": {"epss_score": 0.00064, "epss_percentile": 0.20336}, "CVE-2023-23984": {"epss_score": 0.00134, "epss_percentile": 0.33898}, "CVE-2023-23985": {"epss_score": 0.00072, "epss_percentile": 0.22421}, "CVE-2023-23986": {"epss_score": 0.0013, "epss_percentile": 0.33237}, "CVE-2023-23987": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23988": {"epss_score": 0.00295, "epss_percentile": 0.52471}, "CVE-2023-23989": {"epss_score": 0.00064, "epss_percentile": 0.20169}, "CVE-2023-23990": {"epss_score": 0.00147, "epss_percentile": 0.35799}, "CVE-2023-23991": {"epss_score": 0.00223, "epss_percentile": 0.44867}, "CVE-2023-23992": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2023-23993": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-23994": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23995": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-23996": {"epss_score": 0.00241, "epss_percentile": 0.47291}, "CVE-2023-23997": {"epss_score": 0.00092, "epss_percentile": 0.26501}, "CVE-2023-23998": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-23999": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-24000": {"epss_score": 0.00324, "epss_percentile": 0.54969}, "CVE-2023-24001": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-24002": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-24003": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-24004": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-24005": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-24006": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-24007": {"epss_score": 0.00078, "epss_percentile": 0.23609}, "CVE-2023-24008": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2023-24009": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-24010": {"epss_score": 0.00134, "epss_percentile": 0.33912}, "CVE-2023-24011": {"epss_score": 0.00134, "epss_percentile": 0.33912}, "CVE-2023-24012": {"epss_score": 0.00134, "epss_percentile": 0.33912}, "CVE-2023-24014": {"epss_score": 0.00046, "epss_percentile": 0.14437}, "CVE-2023-24015": {"epss_score": 0.00099, "epss_percentile": 0.27842}, "CVE-2023-24016": {"epss_score": 0.00079, "epss_percentile": 0.23947}, "CVE-2023-24018": {"epss_score": 0.00143, "epss_percentile": 0.35191}, "CVE-2023-24019": {"epss_score": 0.00075, "epss_percentile": 0.23021}, "CVE-2023-24020": {"epss_score": 0.00016, "epss_percentile": 0.02693}, "CVE-2023-24021": {"epss_score": 0.0009, "epss_percentile": 0.26137}, "CVE-2023-24022": {"epss_score": 0.0096, "epss_percentile": 0.75968}, "CVE-2023-24023": {"epss_score": 0.00203, "epss_percentile": 0.42509}, "CVE-2023-24025": {"epss_score": 0.00193, "epss_percentile": 0.4142}, "CVE-2023-24026": {"epss_score": 0.00124, "epss_percentile": 0.32386}, "CVE-2023-24027": {"epss_score": 0.00124, "epss_percentile": 0.32386}, "CVE-2023-24028": {"epss_score": 0.00119, "epss_percentile": 0.31674}, "CVE-2023-24029": {"epss_score": 0.00217, "epss_percentile": 0.44258}, "CVE-2023-24030": {"epss_score": 0.00106, "epss_percentile": 0.29435}, "CVE-2023-24031": {"epss_score": 0.00355, "epss_percentile": 0.5729}, "CVE-2023-24032": {"epss_score": 0.00071, "epss_percentile": 0.22025}, "CVE-2023-24033": {"epss_score": 0.00655, "epss_percentile": 0.70411}, "CVE-2023-24038": {"epss_score": 0.00097, "epss_percentile": 0.27554}, "CVE-2023-24039": {"epss_score": 0.00141, "epss_percentile": 0.34813}, "CVE-2023-24040": {"epss_score": 0.00116, "epss_percentile": 0.31109}, "CVE-2023-24042": {"epss_score": 0.00123, "epss_percentile": 0.32328}, "CVE-2023-24044": {"epss_score": 0.55507, "epss_percentile": 0.9798}, "CVE-2023-24045": {"epss_score": 0.00115, "epss_percentile": 0.31011}, "CVE-2023-24046": {"epss_score": 0.00048, "epss_percentile": 0.14965}, "CVE-2023-24047": {"epss_score": 0.00029, "epss_percentile": 0.07607}, "CVE-2023-24048": {"epss_score": 0.00108, "epss_percentile": 0.2982}, "CVE-2023-24049": {"epss_score": 0.00117, "epss_percentile": 0.31299}, "CVE-2023-24050": {"epss_score": 0.0012, "epss_percentile": 0.31731}, "CVE-2023-24051": {"epss_score": 0.00117, "epss_percentile": 0.31299}, "CVE-2023-24052": {"epss_score": 0.0009, "epss_percentile": 0.25996}, "CVE-2023-24055": {"epss_score": 0.40868, "epss_percentile": 0.97241}, "CVE-2023-24056": {"epss_score": 0.00023, "epss_percentile": 0.05329}, "CVE-2023-24057": {"epss_score": 0.00808, "epss_percentile": 0.7369}, "CVE-2023-24058": {"epss_score": 0.00158, "epss_percentile": 0.37299}, "CVE-2023-24059": {"epss_score": 0.02978, "epss_percentile": 0.86111}, "CVE-2023-24060": {"epss_score": 0.0021, "epss_percentile": 0.43475}, "CVE-2023-24062": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2023-24063": {"epss_score": 0.00233, "epss_percentile": 0.46024}, "CVE-2023-24064": {"epss_score": 0.00293, "epss_percentile": 0.52314}, "CVE-2023-24065": {"epss_score": 0.00128, "epss_percentile": 0.33043}, "CVE-2023-24068": {"epss_score": 0.00113, "epss_percentile": 0.30703}, "CVE-2023-24069": {"epss_score": 0.00071, "epss_percentile": 0.21992}, "CVE-2023-24070": {"epss_score": 0.00124, "epss_percentile": 0.32386}, "CVE-2023-24078": {"epss_score": 0.6714, "epss_percentile": 0.98496}, "CVE-2023-24080": {"epss_score": 0.00122, "epss_percentile": 0.32036}, "CVE-2023-24081": {"epss_score": 0.00124, "epss_percentile": 0.32349}, "CVE-2023-24084": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-24086": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-24093": {"epss_score": 0.00114, "epss_percentile": 0.30801}, "CVE-2023-24094": {"epss_score": 0.00052, "epss_percentile": 0.16616}, "CVE-2023-24095": {"epss_score": 0.00196, "epss_percentile": 0.41778}, "CVE-2023-24096": {"epss_score": 0.00196, "epss_percentile": 0.41778}, "CVE-2023-24097": {"epss_score": 0.00196, "epss_percentile": 0.41778}, "CVE-2023-24098": {"epss_score": 0.00196, "epss_percentile": 0.41778}, "CVE-2023-24099": {"epss_score": 0.00196, "epss_percentile": 0.41778}, "CVE-2023-24104": {"epss_score": 0.00033, "epss_percentile": 0.09337}, "CVE-2023-24107": {"epss_score": 0.00156, "epss_percentile": 0.36964}, "CVE-2023-24108": {"epss_score": 0.00196, "epss_percentile": 0.41728}, "CVE-2023-24114": {"epss_score": 0.01824, "epss_percentile": 0.82425}, "CVE-2023-24117": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24118": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24119": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24120": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24121": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24122": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24123": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24124": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24125": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24126": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24127": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24128": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24129": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24130": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24131": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24132": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24133": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24134": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-24135": {"epss_score": 0.00185, "epss_percentile": 0.40551}, "CVE-2023-24138": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24139": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24140": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24141": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24142": {"epss_score": 0.01824, "epss_percentile": 0.82424}, "CVE-2023-24143": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24144": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24145": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24146": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24147": {"epss_score": 0.00133, "epss_percentile": 0.33717}, "CVE-2023-24148": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24149": {"epss_score": 0.00134, "epss_percentile": 0.33819}, "CVE-2023-24150": {"epss_score": 0.01574, "epss_percentile": 0.81105}, "CVE-2023-24151": {"epss_score": 0.0171, "epss_percentile": 0.81874}, "CVE-2023-24152": {"epss_score": 0.0171, "epss_percentile": 0.81874}, "CVE-2023-24153": {"epss_score": 0.0171, "epss_percentile": 0.81874}, "CVE-2023-24154": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24155": {"epss_score": 0.00134, "epss_percentile": 0.33819}, "CVE-2023-24156": {"epss_score": 0.01574, "epss_percentile": 0.81105}, "CVE-2023-24157": {"epss_score": 0.01574, "epss_percentile": 0.81105}, "CVE-2023-24159": {"epss_score": 0.01824, "epss_percentile": 0.82424}, "CVE-2023-24160": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24161": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24162": {"epss_score": 0.00203, "epss_percentile": 0.42556}, "CVE-2023-24163": {"epss_score": 0.00156, "epss_percentile": 0.36964}, "CVE-2023-24164": {"epss_score": 0.00513, "epss_percentile": 0.65915}, "CVE-2023-24165": {"epss_score": 0.00513, "epss_percentile": 0.65915}, "CVE-2023-24166": {"epss_score": 0.00489, "epss_percentile": 0.64883}, "CVE-2023-24167": {"epss_score": 0.00513, "epss_percentile": 0.65915}, "CVE-2023-24169": {"epss_score": 0.00513, "epss_percentile": 0.65915}, "CVE-2023-24170": {"epss_score": 0.00513, "epss_percentile": 0.65915}, "CVE-2023-24180": {"epss_score": 0.00085, "epss_percentile": 0.25141}, "CVE-2023-24181": {"epss_score": 0.00118, "epss_percentile": 0.31415}, "CVE-2023-24182": {"epss_score": 0.00118, "epss_percentile": 0.31415}, "CVE-2023-24184": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2023-24187": {"epss_score": 0.00047, "epss_percentile": 0.14633}, "CVE-2023-24188": {"epss_score": 0.00321, "epss_percentile": 0.54678}, "CVE-2023-24189": {"epss_score": 0.00132, "epss_percentile": 0.33611}, "CVE-2023-24191": {"epss_score": 0.00149, "epss_percentile": 0.35975}, "CVE-2023-24192": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-24194": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-24195": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-24197": {"epss_score": 0.00072, "epss_percentile": 0.22441}, "CVE-2023-24198": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-24199": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-24200": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-24201": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-24202": {"epss_score": 0.00131, "epss_percentile": 0.33418}, "CVE-2023-24203": {"epss_score": 0.00302, "epss_percentile": 0.53137}, "CVE-2023-24204": {"epss_score": 0.00352, "epss_percentile": 0.57133}, "CVE-2023-24205": {"epss_score": 0.01098, "epss_percentile": 0.77539}, "CVE-2023-24206": {"epss_score": 0.00077, "epss_percentile": 0.23546}, "CVE-2023-24212": {"epss_score": 0.00171, "epss_percentile": 0.38819}, "CVE-2023-24217": {"epss_score": 0.01906, "epss_percentile": 0.82809}, "CVE-2023-24219": {"epss_score": 0.0032, "epss_percentile": 0.54614}, "CVE-2023-24220": {"epss_score": 0.0032, "epss_percentile": 0.54614}, "CVE-2023-24221": {"epss_score": 0.0032, "epss_percentile": 0.54614}, "CVE-2023-24229": {"epss_score": 0.01441, "epss_percentile": 0.80306}, "CVE-2023-24230": {"epss_score": 0.00121, "epss_percentile": 0.3194}, "CVE-2023-24231": {"epss_score": 0.00087, "epss_percentile": 0.25538}, "CVE-2023-24232": {"epss_score": 0.00087, "epss_percentile": 0.25538}, "CVE-2023-24233": {"epss_score": 0.00091, "epss_percentile": 0.26253}, "CVE-2023-24234": {"epss_score": 0.00091, "epss_percentile": 0.26253}, "CVE-2023-24236": {"epss_score": 0.0198, "epss_percentile": 0.83135}, "CVE-2023-24238": {"epss_score": 0.0198, "epss_percentile": 0.83135}, "CVE-2023-24241": {"epss_score": 0.00077, "epss_percentile": 0.23546}, "CVE-2023-24243": {"epss_score": 0.88609, "epss_percentile": 0.9948}, "CVE-2023-24249": {"epss_score": 0.43257, "epss_percentile": 0.97379}, "CVE-2023-24251": {"epss_score": 0.00141, "epss_percentile": 0.3482}, "CVE-2023-24253": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-24256": {"epss_score": 0.00049, "epss_percentile": 0.15293}, "CVE-2023-24258": {"epss_score": 0.00745, "epss_percentile": 0.72532}, "CVE-2023-24261": {"epss_score": 0.06044, "epss_percentile": 0.90432}, "CVE-2023-24269": {"epss_score": 0.00125, "epss_percentile": 0.32554}, "CVE-2023-24276": {"epss_score": 0.01402, "epss_percentile": 0.8002}, "CVE-2023-24278": {"epss_score": 0.49739, "epss_percentile": 0.97703}, "CVE-2023-24279": {"epss_score": 0.0018, "epss_percentile": 0.39901}, "CVE-2023-24282": {"epss_score": 0.00234, "epss_percentile": 0.46114}, "CVE-2023-24294": {"epss_score": 0.00209, "epss_percentile": 0.43417}, "CVE-2023-24295": {"epss_score": 0.00051, "epss_percentile": 0.16312}, "CVE-2023-24304": {"epss_score": 0.00054, "epss_percentile": 0.17178}, "CVE-2023-24308": {"epss_score": 0.00038, "epss_percentile": 0.11202}, "CVE-2023-24317": {"epss_score": 0.04961, "epss_percentile": 0.89334}, "CVE-2023-24320": {"epss_score": 0.00728, "epss_percentile": 0.72106}, "CVE-2023-24322": {"epss_score": 0.19147, "epss_percentile": 0.95138}, "CVE-2023-24323": {"epss_score": 0.00238, "epss_percentile": 0.46838}, "CVE-2023-24329": {"epss_score": 0.01305, "epss_percentile": 0.79324}, "CVE-2023-24330": {"epss_score": 0.00951, "epss_percentile": 0.75869}, "CVE-2023-24331": {"epss_score": 0.05633, "epss_percentile": 0.9007}, "CVE-2023-24332": {"epss_score": 0.00117, "epss_percentile": 0.3134}, "CVE-2023-24333": {"epss_score": 0.00087, "epss_percentile": 0.2558}, "CVE-2023-24334": {"epss_score": 0.00117, "epss_percentile": 0.31278}, "CVE-2023-24343": {"epss_score": 0.03218, "epss_percentile": 0.86667}, "CVE-2023-24344": {"epss_score": 0.01675, "epss_percentile": 0.81704}, "CVE-2023-24345": {"epss_score": 0.00424, "epss_percentile": 0.61677}, "CVE-2023-24346": {"epss_score": 0.0039, "epss_percentile": 0.59534}, "CVE-2023-24347": {"epss_score": 0.00384, "epss_percentile": 0.59182}, "CVE-2023-24348": {"epss_score": 0.00661, "epss_percentile": 0.70582}, "CVE-2023-24349": {"epss_score": 0.00661, "epss_percentile": 0.70582}, "CVE-2023-24350": {"epss_score": 0.00661, "epss_percentile": 0.70582}, "CVE-2023-24351": {"epss_score": 0.00745, "epss_percentile": 0.72521}, "CVE-2023-24352": {"epss_score": 0.00514, "epss_percentile": 0.65943}, "CVE-2023-24364": {"epss_score": 0.00344, "epss_percentile": 0.56525}, "CVE-2023-24366": {"epss_score": 0.00305, "epss_percentile": 0.53344}, "CVE-2023-24369": {"epss_score": 0.00693, "epss_percentile": 0.71334}, "CVE-2023-24372": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-24373": {"epss_score": 0.00503, "epss_percentile": 0.6544}, "CVE-2023-24374": {"epss_score": 0.00131, "epss_percentile": 0.33498}, "CVE-2023-24375": {"epss_score": 0.00059, "epss_percentile": 0.18751}, "CVE-2023-24376": {"epss_score": 0.00117, "epss_percentile": 0.31233}, "CVE-2023-24377": {"epss_score": 0.00094, "epss_percentile": 0.26965}, "CVE-2023-24378": {"epss_score": 0.00131, "epss_percentile": 0.33498}, "CVE-2023-24379": {"epss_score": 0.00653, "epss_percentile": 0.70321}, "CVE-2023-24380": {"epss_score": 0.001, "epss_percentile": 0.28492}, "CVE-2023-24381": {"epss_score": 0.00108, "epss_percentile": 0.29755}, "CVE-2023-24382": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2023-24383": {"epss_score": 0.00108, "epss_percentile": 0.29755}, "CVE-2023-24384": {"epss_score": 0.00128, "epss_percentile": 0.32949}, "CVE-2023-24385": {"epss_score": 0.00063, "epss_percentile": 0.19871}, "CVE-2023-24386": {"epss_score": 0.00117, "epss_percentile": 0.31233}, "CVE-2023-24387": {"epss_score": 0.00108, "epss_percentile": 0.29755}, "CVE-2023-24388": {"epss_score": 0.00064, "epss_percentile": 0.20336}, "CVE-2023-24389": {"epss_score": 0.00063, "epss_percentile": 0.19871}, "CVE-2023-24390": {"epss_score": 0.0009, "epss_percentile": 0.261}, "CVE-2023-24391": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-24392": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2023-24393": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-24394": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-24395": {"epss_score": 0.00094, "epss_percentile": 0.26788}, "CVE-2023-24396": {"epss_score": 0.00108, "epss_percentile": 0.29755}, "CVE-2023-24397": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-24398": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-24399": {"epss_score": 0.00131, "epss_percentile": 0.33498}, "CVE-2023-24400": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2023-24401": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-24402": {"epss_score": 0.00117, "epss_percentile": 0.3128}, "CVE-2023-24403": {"epss_score": 0.00108, "epss_percentile": 0.29755}, "CVE-2023-24404": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2023-24405": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-24406": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-24407": {"epss_score": 0.00167, "epss_percentile": 0.38307}, "CVE-2023-24408": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-24409": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-24410": {"epss_score": 0.00498, "epss_percentile": 0.6522}, "CVE-2023-24411": {"epss_score": 0.00085, "epss_percentile": 0.25178}, "CVE-2023-24412": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-24413": {"epss_score": 0.0009, "epss_percentile": 0.261}, "CVE-2023-24414": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-24415": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2023-24416": {"epss_score": 0.00094, "epss_percentile": 0.26985}, "CVE-2023-24417": {"epss_score": 0.00056, "epss_percentile": 0.17924}, "CVE-2023-24418": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-24419": {"epss_score": 0.00096, "epss_percentile": 0.2727}, "CVE-2023-24420": {"epss_score": 0.00129, "epss_percentile": 0.33196}, "CVE-2023-24421": {"epss_score": 0.00056, "epss_percentile": 0.17886}, "CVE-2023-24422": {"epss_score": 0.00019, "epss_percentile": 0.04101}, "CVE-2023-24423": {"epss_score": 0.00075, "epss_percentile": 0.23046}, "CVE-2023-24424": {"epss_score": 0.00671, "epss_percentile": 0.70793}, "CVE-2023-24425": {"epss_score": 0.00529, "epss_percentile": 0.66583}, "CVE-2023-24426": {"epss_score": 0.00687, "epss_percentile": 0.71178}, "CVE-2023-24427": {"epss_score": 0.00717, "epss_percentile": 0.71915}, "CVE-2023-24428": {"epss_score": 0.00075, "epss_percentile": 0.23046}, "CVE-2023-24429": {"epss_score": 0.00264, "epss_percentile": 0.49732}, "CVE-2023-24430": {"epss_score": 0.00663, "epss_percentile": 0.70616}, "CVE-2023-24431": {"epss_score": 0.00456, "epss_percentile": 0.63346}, "CVE-2023-24432": {"epss_score": 0.00095, "epss_percentile": 0.27182}, "CVE-2023-24433": {"epss_score": 0.00409, "epss_percentile": 0.60761}, "CVE-2023-24434": {"epss_score": 0.00129, "epss_percentile": 0.33185}, "CVE-2023-24435": {"epss_score": 0.00529, "epss_percentile": 0.66583}, "CVE-2023-24436": {"epss_score": 0.00589, "epss_percentile": 0.68534}, "CVE-2023-24437": {"epss_score": 0.00095, "epss_percentile": 0.27182}, "CVE-2023-24438": {"epss_score": 0.00535, "epss_percentile": 0.66822}, "CVE-2023-24439": {"epss_score": 0.00049, "epss_percentile": 0.15443}, "CVE-2023-24440": {"epss_score": 0.00049, "epss_percentile": 0.15443}, "CVE-2023-24441": {"epss_score": 0.00663, "epss_percentile": 0.70616}, "CVE-2023-24442": {"epss_score": 0.00054, "epss_percentile": 0.17141}, "CVE-2023-24443": {"epss_score": 0.00663, "epss_percentile": 0.70616}, "CVE-2023-24444": {"epss_score": 0.00983, "epss_percentile": 0.76308}, "CVE-2023-24445": {"epss_score": 0.00685, "epss_percentile": 0.71146}, "CVE-2023-24446": {"epss_score": 0.00129, "epss_percentile": 0.33185}, "CVE-2023-24447": {"epss_score": 0.00103, "epss_percentile": 0.29098}, "CVE-2023-24448": {"epss_score": 0.00294, "epss_percentile": 0.52428}, "CVE-2023-24449": {"epss_score": 0.0024, "epss_percentile": 0.47189}, "CVE-2023-24450": {"epss_score": 0.00242, "epss_percentile": 0.47391}, "CVE-2023-24451": {"epss_score": 0.00456, "epss_percentile": 0.63346}, "CVE-2023-24452": {"epss_score": 0.00135, "epss_percentile": 0.34036}, "CVE-2023-24453": {"epss_score": 0.0032, "epss_percentile": 0.54628}, "CVE-2023-24454": {"epss_score": 0.00049, "epss_percentile": 0.15443}, "CVE-2023-24455": {"epss_score": 0.0024, "epss_percentile": 0.47189}, "CVE-2023-24456": {"epss_score": 0.00333, "epss_percentile": 0.55635}, "CVE-2023-24457": {"epss_score": 0.00096, "epss_percentile": 0.27397}, "CVE-2023-24458": {"epss_score": 0.00141, "epss_percentile": 0.34814}, "CVE-2023-24459": {"epss_score": 0.00414, "epss_percentile": 0.61036}, "CVE-2023-24460": {"epss_score": 0.00118, "epss_percentile": 0.31419}, "CVE-2023-24461": {"epss_score": 0.00145, "epss_percentile": 0.35402}, "CVE-2023-24463": {"epss_score": 0.00078, "epss_percentile": 0.23762}, "CVE-2023-24464": {"epss_score": 0.00767, "epss_percentile": 0.72955}, "CVE-2023-24465": {"epss_score": 0.00029, "epss_percentile": 0.07908}, "CVE-2023-24466": {"epss_score": 0.00029, "epss_percentile": 0.07654}, "CVE-2023-24467": {"epss_score": 0.00545, "epss_percentile": 0.67172}, "CVE-2023-24468": {"epss_score": 0.00379, "epss_percentile": 0.5886}, "CVE-2023-24469": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2023-24470": {"epss_score": 0.00107, "epss_percentile": 0.29585}, "CVE-2023-24471": {"epss_score": 0.00142, "epss_percentile": 0.34989}, "CVE-2023-24472": {"epss_score": 0.00037, "epss_percentile": 0.10724}, "CVE-2023-24473": {"epss_score": 0.0009, "epss_percentile": 0.25993}, "CVE-2023-24474": {"epss_score": 0.00035, "epss_percentile": 0.09818}, "CVE-2023-24475": {"epss_score": 0.00087, "epss_percentile": 0.25447}, "CVE-2023-24476": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2023-24477": {"epss_score": 0.00043, "epss_percentile": 0.13081}, "CVE-2023-24478": {"epss_score": 0.00062, "epss_percentile": 0.19782}, "CVE-2023-24479": {"epss_score": 0.00078, "epss_percentile": 0.23771}, "CVE-2023-24480": {"epss_score": 0.00035, "epss_percentile": 0.10048}, "CVE-2023-24481": {"epss_score": 0.00057, "epss_percentile": 0.18198}, "CVE-2023-24482": {"epss_score": 0.00384, "epss_percentile": 0.59182}, "CVE-2023-24483": {"epss_score": 0.00186, "epss_percentile": 0.40615}, "CVE-2023-24484": {"epss_score": 0.00105, "epss_percentile": 0.29386}, "CVE-2023-24485": {"epss_score": 0.00128, "epss_percentile": 0.33067}, "CVE-2023-24486": {"epss_score": 0.00058, "epss_percentile": 0.18484}, "CVE-2023-24487": {"epss_score": 0.22385, "epss_percentile": 0.95628}, "CVE-2023-24488": {"epss_score": 0.91357, "epss_percentile": 0.99636}, "CVE-2023-24489": {"epss_score": 0.94389, "epss_percentile": 0.99969}, "CVE-2023-24490": {"epss_score": 0.00056, "epss_percentile": 0.17751}, "CVE-2023-24491": {"epss_score": 0.00075, "epss_percentile": 0.22926}, "CVE-2023-24492": {"epss_score": 0.00331, "epss_percentile": 0.55512}, "CVE-2023-24493": {"epss_score": 0.00212, "epss_percentile": 0.43784}, "CVE-2023-24494": {"epss_score": 0.00243, "epss_percentile": 0.47478}, "CVE-2023-24495": {"epss_score": 0.00144, "epss_percentile": 0.35309}, "CVE-2023-24496": {"epss_score": 0.00145, "epss_percentile": 0.3537}, "CVE-2023-24497": {"epss_score": 0.00111, "epss_percentile": 0.30251}, "CVE-2023-24498": {"epss_score": 0.00099, "epss_percentile": 0.27868}, "CVE-2023-24499": {"epss_score": 0.00049, "epss_percentile": 0.15316}, "CVE-2023-24500": {"epss_score": 0.00026, "epss_percentile": 0.06672}, "CVE-2023-24501": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2023-24502": {"epss_score": 0.0002, "epss_percentile": 0.04567}, "CVE-2023-24503": {"epss_score": 0.00026, "epss_percentile": 0.06672}, "CVE-2023-24504": {"epss_score": 0.00034, "epss_percentile": 0.09666}, "CVE-2023-24505": {"epss_score": 0.00193, "epss_percentile": 0.41381}, "CVE-2023-24506": {"epss_score": 0.00202, "epss_percentile": 0.42444}, "CVE-2023-24507": {"epss_score": 0.00169, "epss_percentile": 0.38552}, "CVE-2023-24508": {"epss_score": 0.00266, "epss_percentile": 0.49903}, "CVE-2023-24509": {"epss_score": 0.00059, "epss_percentile": 0.18822}, "CVE-2023-24510": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-24511": {"epss_score": 0.00042, "epss_percentile": 0.12617}, "CVE-2023-24512": {"epss_score": 0.00087, "epss_percentile": 0.25597}, "CVE-2023-24513": {"epss_score": 0.00134, "epss_percentile": 0.3385}, "CVE-2023-24514": {"epss_score": 0.00299, "epss_percentile": 0.52859}, "CVE-2023-24515": {"epss_score": 0.00233, "epss_percentile": 0.4605}, "CVE-2023-24516": {"epss_score": 0.00397, "epss_percentile": 0.59969}, "CVE-2023-24517": {"epss_score": 0.00299, "epss_percentile": 0.52869}, "CVE-2023-24518": {"epss_score": 0.0009, "epss_percentile": 0.26125}, "CVE-2023-24519": {"epss_score": 0.00463, "epss_percentile": 0.63661}, "CVE-2023-24520": {"epss_score": 0.00463, "epss_percentile": 0.63661}, "CVE-2023-24521": {"epss_score": 0.00615, "epss_percentile": 0.69309}, "CVE-2023-24522": {"epss_score": 0.00615, "epss_percentile": 0.69309}, "CVE-2023-24523": {"epss_score": 0.00043, "epss_percentile": 0.12952}, "CVE-2023-24524": {"epss_score": 0.00213, "epss_percentile": 0.43825}, "CVE-2023-24525": {"epss_score": 0.004, "epss_percentile": 0.60188}, "CVE-2023-24526": {"epss_score": 0.00331, "epss_percentile": 0.55513}, "CVE-2023-24527": {"epss_score": 0.00228, "epss_percentile": 0.45491}, "CVE-2023-24528": {"epss_score": 0.00238, "epss_percentile": 0.46812}, "CVE-2023-24529": {"epss_score": 0.00273, "epss_percentile": 0.50427}, "CVE-2023-24530": {"epss_score": 0.00334, "epss_percentile": 0.55706}, "CVE-2023-24531": {"epss_score": 0.00481, "epss_percentile": 0.64489}, "CVE-2023-24532": {"epss_score": 0.00025, "epss_percentile": 0.06306}, "CVE-2023-24533": {"epss_score": 0.00096, "epss_percentile": 0.27299}, "CVE-2023-24534": {"epss_score": 0.00045, "epss_percentile": 0.13721}, "CVE-2023-24535": {"epss_score": 0.0045, "epss_percentile": 0.63059}, "CVE-2023-24536": {"epss_score": 0.00066, "epss_percentile": 0.20745}, "CVE-2023-24537": {"epss_score": 0.00013, "epss_percentile": 0.01457}, "CVE-2023-24538": {"epss_score": 0.00646, "epss_percentile": 0.70146}, "CVE-2023-24539": {"epss_score": 0.00065, "epss_percentile": 0.20545}, "CVE-2023-24540": {"epss_score": 0.00243, "epss_percentile": 0.47486}, "CVE-2023-24542": {"epss_score": 0.00106, "epss_percentile": 0.2952}, "CVE-2023-24544": {"epss_score": 0.0009, "epss_percentile": 0.26163}, "CVE-2023-24545": {"epss_score": 0.00273, "epss_percentile": 0.50425}, "CVE-2023-24546": {"epss_score": 0.00121, "epss_percentile": 0.31995}, "CVE-2023-24547": {"epss_score": 0.00019, "epss_percentile": 0.04224}, "CVE-2023-24548": {"epss_score": 0.00054, "epss_percentile": 0.17311}, "CVE-2023-24549": {"epss_score": 0.00092, "epss_percentile": 0.26472}, "CVE-2023-24550": {"epss_score": 0.00092, "epss_percentile": 0.26472}, "CVE-2023-24551": {"epss_score": 0.00092, "epss_percentile": 0.26472}, "CVE-2023-24552": {"epss_score": 0.00113, "epss_percentile": 0.30639}, "CVE-2023-24553": {"epss_score": 0.0012, "epss_percentile": 0.31767}, "CVE-2023-24554": {"epss_score": 0.0012, "epss_percentile": 0.31767}, "CVE-2023-24555": {"epss_score": 0.00135, "epss_percentile": 0.33943}, "CVE-2023-24556": {"epss_score": 0.0012, "epss_percentile": 0.31767}, "CVE-2023-24557": {"epss_score": 0.0012, "epss_percentile": 0.31767}, "CVE-2023-24558": {"epss_score": 0.00113, "epss_percentile": 0.30639}, "CVE-2023-24559": {"epss_score": 0.00113, "epss_percentile": 0.30639}, "CVE-2023-24560": {"epss_score": 0.00086, "epss_percentile": 0.25394}, "CVE-2023-24561": {"epss_score": 0.00086, "epss_percentile": 0.25394}, "CVE-2023-24562": {"epss_score": 0.00086, "epss_percentile": 0.25394}, "CVE-2023-24563": {"epss_score": 0.00086, "epss_percentile": 0.25394}, "CVE-2023-24564": {"epss_score": 0.00082, "epss_percentile": 0.24496}, "CVE-2023-24565": {"epss_score": 0.00106, "epss_percentile": 0.29402}, "CVE-2023-24566": {"epss_score": 0.00102, "epss_percentile": 0.28727}, "CVE-2023-24567": {"epss_score": 0.00212, "epss_percentile": 0.43721}, "CVE-2023-24568": {"epss_score": 0.00064, "epss_percentile": 0.20391}, "CVE-2023-24569": {"epss_score": 0.00041, "epss_percentile": 0.12396}, "CVE-2023-24571": {"epss_score": 0.00031, "epss_percentile": 0.08666}, "CVE-2023-24572": {"epss_score": 0.0005, "epss_percentile": 0.1573}, "CVE-2023-24573": {"epss_score": 0.00061, "epss_percentile": 0.19261}, "CVE-2023-24574": {"epss_score": 0.0086, "epss_percentile": 0.74524}, "CVE-2023-24575": {"epss_score": 0.00046, "epss_percentile": 0.14466}, "CVE-2023-24576": {"epss_score": 0.01029, "epss_percentile": 0.76827}, "CVE-2023-24577": {"epss_score": 0.00108, "epss_percentile": 0.29878}, "CVE-2023-24578": {"epss_score": 0.00037, "epss_percentile": 0.10742}, "CVE-2023-24579": {"epss_score": 0.00052, "epss_percentile": 0.16456}, "CVE-2023-24580": {"epss_score": 0.18744, "epss_percentile": 0.95062}, "CVE-2023-24581": {"epss_score": 0.00119, "epss_percentile": 0.31663}, "CVE-2023-24582": {"epss_score": 0.00153, "epss_percentile": 0.36622}, "CVE-2023-24583": {"epss_score": 0.00153, "epss_percentile": 0.36622}, "CVE-2023-24584": {"epss_score": 0.00334, "epss_percentile": 0.55734}, "CVE-2023-24585": {"epss_score": 0.00301, "epss_percentile": 0.53056}, "CVE-2023-24586": {"epss_score": 0.00186, "epss_percentile": 0.4068}, "CVE-2023-24587": {"epss_score": 0.00041, "epss_percentile": 0.12384}, "CVE-2023-24588": {"epss_score": 0.00131, "epss_percentile": 0.3349}, "CVE-2023-24589": {"epss_score": 0.00039, "epss_percentile": 0.1143}, "CVE-2023-24590": {"epss_score": 0.00146, "epss_percentile": 0.3564}, "CVE-2023-24591": {"epss_score": 0.00109, "epss_percentile": 0.29958}, "CVE-2023-24592": {"epss_score": 0.00148, "epss_percentile": 0.35855}, "CVE-2023-24594": {"epss_score": 0.00136, "epss_percentile": 0.34082}, "CVE-2023-24595": {"epss_score": 0.00177, "epss_percentile": 0.396}, "CVE-2023-24597": {"epss_score": 0.00084, "epss_percentile": 0.2493}, "CVE-2023-24598": {"epss_score": 0.00078, "epss_percentile": 0.23798}, "CVE-2023-24599": {"epss_score": 0.00064, "epss_percentile": 0.20268}, "CVE-2023-24600": {"epss_score": 0.00042, "epss_percentile": 0.12916}, "CVE-2023-24601": {"epss_score": 0.00166, "epss_percentile": 0.38248}, "CVE-2023-24602": {"epss_score": 0.00166, "epss_percentile": 0.38248}, "CVE-2023-24603": {"epss_score": 0.00069, "epss_percentile": 0.21459}, "CVE-2023-24604": {"epss_score": 0.00047, "epss_percentile": 0.14889}, "CVE-2023-24605": {"epss_score": 0.0006, "epss_percentile": 0.19192}, "CVE-2023-24607": {"epss_score": 0.00321, "epss_percentile": 0.54676}, "CVE-2023-24609": {"epss_score": 0.00241, "epss_percentile": 0.47258}, "CVE-2023-24610": {"epss_score": 0.07747, "epss_percentile": 0.91657}, "CVE-2023-24612": {"epss_score": 0.00459, "epss_percentile": 0.63479}, "CVE-2023-24613": {"epss_score": 0.00414, "epss_percentile": 0.61016}, "CVE-2023-24619": {"epss_score": 0.00067, "epss_percentile": 0.21049}, "CVE-2023-24620": {"epss_score": 0.00021, "epss_percentile": 0.04935}, "CVE-2023-24621": {"epss_score": 0.00034, "epss_percentile": 0.09623}, "CVE-2023-24622": {"epss_score": 0.00232, "epss_percentile": 0.45914}, "CVE-2023-24623": {"epss_score": 0.00081, "epss_percentile": 0.24267}, "CVE-2023-24625": {"epss_score": 0.00079, "epss_percentile": 0.23881}, "CVE-2023-24626": {"epss_score": 0.00048, "epss_percentile": 0.14955}, "CVE-2023-24641": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-24642": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-24643": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-24646": {"epss_score": 0.00164, "epss_percentile": 0.37868}, "CVE-2023-24647": {"epss_score": 0.00078, "epss_percentile": 0.23789}, "CVE-2023-24648": {"epss_score": 0.00155, "epss_percentile": 0.36784}, "CVE-2023-24651": {"epss_score": 0.00085, "epss_percentile": 0.25236}, "CVE-2023-24652": {"epss_score": 0.00335, "epss_percentile": 0.55841}, "CVE-2023-24653": {"epss_score": 0.00335, "epss_percentile": 0.55841}, "CVE-2023-24654": {"epss_score": 0.00438, "epss_percentile": 0.62551}, "CVE-2023-24655": {"epss_score": 0.00251, "epss_percentile": 0.48277}, "CVE-2023-24656": {"epss_score": 0.00335, "epss_percentile": 0.55841}, "CVE-2023-24657": {"epss_score": 0.0274, "epss_percentile": 0.85558}, "CVE-2023-24671": {"epss_score": 0.00026, "epss_percentile": 0.06559}, "CVE-2023-24674": {"epss_score": 0.00022, "epss_percentile": 0.0523}, "CVE-2023-24675": {"epss_score": 0.00088, "epss_percentile": 0.25644}, "CVE-2023-24676": {"epss_score": 0.00092, "epss_percentile": 0.26498}, "CVE-2023-24678": {"epss_score": 0.001, "epss_percentile": 0.28468}, "CVE-2023-24684": {"epss_score": 0.00111, "epss_percentile": 0.30285}, "CVE-2023-24685": {"epss_score": 0.00476, "epss_percentile": 0.64277}, "CVE-2023-24686": {"epss_score": 0.00139, "epss_percentile": 0.34637}, "CVE-2023-24687": {"epss_score": 0.00407, "epss_percentile": 0.60567}, "CVE-2023-24688": {"epss_score": 0.01258, "epss_percentile": 0.78952}, "CVE-2023-24689": {"epss_score": 0.00382, "epss_percentile": 0.59053}, "CVE-2023-24690": {"epss_score": 0.00194, "epss_percentile": 0.41548}, "CVE-2023-24698": {"epss_score": 0.00295, "epss_percentile": 0.52514}, "CVE-2023-24709": {"epss_score": 0.43391, "epss_percentile": 0.97384}, "CVE-2023-24720": {"epss_score": 0.00153, "epss_percentile": 0.36615}, "CVE-2023-24721": {"epss_score": 0.00105, "epss_percentile": 0.29369}, "CVE-2023-24724": {"epss_score": 0.00564, "epss_percentile": 0.67753}, "CVE-2023-24726": {"epss_score": 0.00693, "epss_percentile": 0.71313}, "CVE-2023-24728": {"epss_score": 0.00427, "epss_percentile": 0.61876}, "CVE-2023-24729": {"epss_score": 0.01447, "epss_percentile": 0.80332}, "CVE-2023-24730": {"epss_score": 0.01447, "epss_percentile": 0.80332}, "CVE-2023-24731": {"epss_score": 0.00427, "epss_percentile": 0.61876}, "CVE-2023-24732": {"epss_score": 0.00427, "epss_percentile": 0.61876}, "CVE-2023-24733": {"epss_score": 0.11698, "epss_percentile": 0.93454}, "CVE-2023-24734": {"epss_score": 0.11291, "epss_percentile": 0.93295}, "CVE-2023-24735": {"epss_score": 0.09478, "epss_percentile": 0.92565}, "CVE-2023-24736": {"epss_score": 0.05188, "epss_percentile": 0.89592}, "CVE-2023-24737": {"epss_score": 0.1156, "epss_percentile": 0.93405}, "CVE-2023-24744": {"epss_score": 0.00053, "epss_percentile": 0.16833}, "CVE-2023-24747": {"epss_score": 0.00115, "epss_percentile": 0.30882}, "CVE-2023-24751": {"epss_score": 0.0036, "epss_percentile": 0.57654}, "CVE-2023-24752": {"epss_score": 0.00033, "epss_percentile": 0.0941}, "CVE-2023-24754": {"epss_score": 0.00033, "epss_percentile": 0.0941}, "CVE-2023-24755": {"epss_score": 0.00033, "epss_percentile": 0.0941}, "CVE-2023-24756": {"epss_score": 0.00033, "epss_percentile": 0.0941}, "CVE-2023-24757": {"epss_score": 0.00023, "epss_percentile": 0.05389}, "CVE-2023-24758": {"epss_score": 0.00033, "epss_percentile": 0.0941}, "CVE-2023-24760": {"epss_score": 0.00583, "epss_percentile": 0.68348}, "CVE-2023-24762": {"epss_score": 0.02449, "epss_percentile": 0.84774}, "CVE-2023-24763": {"epss_score": 0.0009, "epss_percentile": 0.26033}, "CVE-2023-24769": {"epss_score": 0.00725, "epss_percentile": 0.72054}, "CVE-2023-24773": {"epss_score": 0.00115, "epss_percentile": 0.3092}, "CVE-2023-24774": {"epss_score": 0.00698, "epss_percentile": 0.71426}, "CVE-2023-24775": {"epss_score": 0.63558, "epss_percentile": 0.98337}, "CVE-2023-24776": {"epss_score": 0.01824, "epss_percentile": 0.82425}, "CVE-2023-24777": {"epss_score": 0.00082, "epss_percentile": 0.24564}, "CVE-2023-24780": {"epss_score": 0.00313, "epss_percentile": 0.54029}, "CVE-2023-24781": {"epss_score": 0.0009, "epss_percentile": 0.26085}, "CVE-2023-24782": {"epss_score": 0.0009, "epss_percentile": 0.26085}, "CVE-2023-24785": {"epss_score": 0.00024, "epss_percentile": 0.06029}, "CVE-2023-24788": {"epss_score": 0.01069, "epss_percentile": 0.77246}, "CVE-2023-24789": {"epss_score": 0.00141, "epss_percentile": 0.34897}, "CVE-2023-24795": {"epss_score": 0.00152, "epss_percentile": 0.36405}, "CVE-2023-24796": {"epss_score": 0.04546, "epss_percentile": 0.88834}, "CVE-2023-24797": {"epss_score": 0.01085, "epss_percentile": 0.774}, "CVE-2023-24798": {"epss_score": 0.0063, "epss_percentile": 0.69698}, "CVE-2023-24799": {"epss_score": 0.0063, "epss_percentile": 0.69698}, "CVE-2023-24800": {"epss_score": 0.00854, "epss_percentile": 0.74452}, "CVE-2023-24804": {"epss_score": 0.0046, "epss_percentile": 0.63534}, "CVE-2023-24805": {"epss_score": 0.08221, "epss_percentile": 0.91937}, "CVE-2023-24807": {"epss_score": 0.0025, "epss_percentile": 0.48104}, "CVE-2023-24808": {"epss_score": 0.00123, "epss_percentile": 0.32199}, "CVE-2023-24809": {"epss_score": 0.00056, "epss_percentile": 0.17761}, "CVE-2023-24810": {"epss_score": 0.00219, "epss_percentile": 0.44498}, "CVE-2023-24811": {"epss_score": 0.00211, "epss_percentile": 0.43669}, "CVE-2023-24812": {"epss_score": 0.00344, "epss_percentile": 0.56525}, "CVE-2023-24813": {"epss_score": 0.04401, "epss_percentile": 0.88646}, "CVE-2023-24814": {"epss_score": 0.00296, "epss_percentile": 0.52554}, "CVE-2023-24815": {"epss_score": 0.00225, "epss_percentile": 0.45224}, "CVE-2023-24816": {"epss_score": 0.00473, "epss_percentile": 0.64093}, "CVE-2023-24817": {"epss_score": 0.00154, "epss_percentile": 0.36686}, "CVE-2023-24818": {"epss_score": 0.00275, "epss_percentile": 0.50648}, "CVE-2023-24819": {"epss_score": 0.00392, "epss_percentile": 0.59669}, "CVE-2023-24820": {"epss_score": 0.00197, "epss_percentile": 0.41871}, "CVE-2023-24821": {"epss_score": 0.0024, "epss_percentile": 0.46942}, "CVE-2023-24822": {"epss_score": 0.00179, "epss_percentile": 0.39746}, "CVE-2023-24823": {"epss_score": 0.00458, "epss_percentile": 0.63432}, "CVE-2023-24824": {"epss_score": 0.00284, "epss_percentile": 0.51485}, "CVE-2023-24825": {"epss_score": 0.00298, "epss_percentile": 0.52838}, "CVE-2023-24826": {"epss_score": 0.00205, "epss_percentile": 0.42676}, "CVE-2023-24827": {"epss_score": 0.0023, "epss_percentile": 0.45741}, "CVE-2023-24828": {"epss_score": 0.0012, "epss_percentile": 0.31757}, "CVE-2023-24829": {"epss_score": 0.00206, "epss_percentile": 0.43044}, "CVE-2023-24830": {"epss_score": 0.00157, "epss_percentile": 0.37064}, "CVE-2023-24831": {"epss_score": 0.00094, "epss_percentile": 0.2701}, "CVE-2023-24832": {"epss_score": 0.0018, "epss_percentile": 0.39895}, "CVE-2023-24833": {"epss_score": 0.00199, "epss_percentile": 0.42161}, "CVE-2023-24834": {"epss_score": 0.00086, "epss_percentile": 0.25431}, "CVE-2023-24835": {"epss_score": 0.00286, "epss_percentile": 0.51735}, "CVE-2023-24836": {"epss_score": 0.00444, "epss_percentile": 0.62806}, "CVE-2023-24837": {"epss_score": 0.00424, "epss_percentile": 0.61683}, "CVE-2023-24838": {"epss_score": 0.01797, "epss_percentile": 0.8231}, "CVE-2023-24839": {"epss_score": 0.00127, "epss_percentile": 0.32815}, "CVE-2023-24840": {"epss_score": 0.00286, "epss_percentile": 0.51735}, "CVE-2023-24841": {"epss_score": 0.00286, "epss_percentile": 0.51735}, "CVE-2023-24842": {"epss_score": 0.00166, "epss_percentile": 0.38245}, "CVE-2023-24843": {"epss_score": 0.00087, "epss_percentile": 0.25479}, "CVE-2023-24844": {"epss_score": 0.00027, "epss_percentile": 0.06831}, "CVE-2023-24845": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2023-24847": {"epss_score": 0.00178, "epss_percentile": 0.39723}, "CVE-2023-24848": {"epss_score": 0.0012, "epss_percentile": 0.31794}, "CVE-2023-24849": {"epss_score": 0.00137, "epss_percentile": 0.3431}, "CVE-2023-24850": {"epss_score": 0.0003, "epss_percentile": 0.08175}, "CVE-2023-24851": {"epss_score": 0.00052, "epss_percentile": 0.16355}, "CVE-2023-24852": {"epss_score": 0.00054, "epss_percentile": 0.17061}, "CVE-2023-24853": {"epss_score": 0.0003, "epss_percentile": 0.08175}, "CVE-2023-24854": {"epss_score": 0.00052, "epss_percentile": 0.16355}, "CVE-2023-24855": {"epss_score": 0.00213, "epss_percentile": 0.43928}, "CVE-2023-24856": {"epss_score": 0.05545, "epss_percentile": 0.89982}, "CVE-2023-24857": {"epss_score": 0.03893, "epss_percentile": 0.87912}, "CVE-2023-24858": {"epss_score": 0.03751, "epss_percentile": 0.87674}, "CVE-2023-24859": {"epss_score": 0.05433, "epss_percentile": 0.89878}, "CVE-2023-24860": {"epss_score": 0.03851, "epss_percentile": 0.8785}, "CVE-2023-24861": {"epss_score": 0.00106, "epss_percentile": 0.29551}, "CVE-2023-24862": {"epss_score": 0.00157, "epss_percentile": 0.37085}, "CVE-2023-24863": {"epss_score": 0.02321, "epss_percentile": 0.84371}, "CVE-2023-24864": {"epss_score": 0.00577, "epss_percentile": 0.68161}, "CVE-2023-24865": {"epss_score": 0.0575, "epss_percentile": 0.90177}, "CVE-2023-24866": {"epss_score": 0.01935, "epss_percentile": 0.82959}, "CVE-2023-24867": {"epss_score": 0.0328, "epss_percentile": 0.86813}, "CVE-2023-24868": {"epss_score": 0.0328, "epss_percentile": 0.86813}, "CVE-2023-24869": {"epss_score": 0.01097, "epss_percentile": 0.77528}, "CVE-2023-24870": {"epss_score": 0.02159, "epss_percentile": 0.8382}, "CVE-2023-24871": {"epss_score": 0.55699, "epss_percentile": 0.97989}, "CVE-2023-24872": {"epss_score": 0.0328, "epss_percentile": 0.86813}, "CVE-2023-24876": {"epss_score": 0.0328, "epss_percentile": 0.86813}, "CVE-2023-24879": {"epss_score": 0.00264, "epss_percentile": 0.49735}, "CVE-2023-24880": {"epss_score": 0.77286, "epss_percentile": 0.9893}, "CVE-2023-24881": {"epss_score": 0.00263, "epss_percentile": 0.49473}, "CVE-2023-24882": {"epss_score": 0.00456, "epss_percentile": 0.63353}, "CVE-2023-24883": {"epss_score": 0.02993, "epss_percentile": 0.86148}, "CVE-2023-24884": {"epss_score": 0.00371, "epss_percentile": 0.58371}, "CVE-2023-24885": {"epss_score": 0.00504, "epss_percentile": 0.6552}, "CVE-2023-24886": {"epss_score": 0.00371, "epss_percentile": 0.58371}, "CVE-2023-24887": {"epss_score": 0.02704, "epss_percentile": 0.85462}, "CVE-2023-24890": {"epss_score": 0.01168, "epss_percentile": 0.78192}, "CVE-2023-24891": {"epss_score": 0.00264, "epss_percentile": 0.49735}, "CVE-2023-24892": {"epss_score": 0.04132, "epss_percentile": 0.883}, "CVE-2023-24893": {"epss_score": 0.01165, "epss_percentile": 0.78175}, "CVE-2023-24895": {"epss_score": 0.01415, "epss_percentile": 0.80139}, "CVE-2023-24896": {"epss_score": 0.00343, "epss_percentile": 0.56438}, "CVE-2023-24897": {"epss_score": 0.02552, "epss_percentile": 0.85082}, "CVE-2023-24898": {"epss_score": 0.03226, "epss_percentile": 0.86686}, "CVE-2023-24899": {"epss_score": 0.0007, "epss_percentile": 0.21694}, "CVE-2023-24900": {"epss_score": 0.0044, "epss_percentile": 0.62632}, "CVE-2023-24901": {"epss_score": 0.00353, "epss_percentile": 0.57162}, "CVE-2023-24902": {"epss_score": 0.02245, "epss_percentile": 0.84127}, "CVE-2023-24903": {"epss_score": 0.00645, "epss_percentile": 0.70114}, "CVE-2023-24904": {"epss_score": 0.00125, "epss_percentile": 0.32585}, "CVE-2023-24905": {"epss_score": 0.00412, "epss_percentile": 0.60923}, "CVE-2023-24906": {"epss_score": 0.02321, "epss_percentile": 0.84371}, "CVE-2023-24907": {"epss_score": 0.0328, "epss_percentile": 0.86813}, "CVE-2023-24908": {"epss_score": 0.01097, "epss_percentile": 0.77528}, "CVE-2023-24909": {"epss_score": 0.03522, "epss_percentile": 0.8729}, "CVE-2023-24910": {"epss_score": 0.00197, "epss_percentile": 0.41843}, "CVE-2023-24911": {"epss_score": 0.01862, "epss_percentile": 0.82596}, "CVE-2023-24912": {"epss_score": 0.02937, "epss_percentile": 0.86026}, "CVE-2023-24913": {"epss_score": 0.0328, "epss_percentile": 0.86813}, "CVE-2023-24914": {"epss_score": 0.00088, "epss_percentile": 0.25707}, "CVE-2023-24919": {"epss_score": 0.00264, "epss_percentile": 0.49735}, "CVE-2023-24920": {"epss_score": 0.00204, "epss_percentile": 0.42636}, "CVE-2023-24921": {"epss_score": 0.00264, "epss_percentile": 0.49735}, "CVE-2023-24922": {"epss_score": 0.03827, "epss_percentile": 0.87795}, "CVE-2023-24923": {"epss_score": 0.00456, "epss_percentile": 0.63353}, "CVE-2023-24924": {"epss_score": 0.02516, "epss_percentile": 0.84988}, "CVE-2023-24925": {"epss_score": 0.02516, "epss_percentile": 0.84988}, "CVE-2023-24926": {"epss_score": 0.02516, "epss_percentile": 0.84988}, "CVE-2023-24927": {"epss_score": 0.00371, "epss_percentile": 0.58371}, "CVE-2023-24928": {"epss_score": 0.02516, "epss_percentile": 0.84988}, "CVE-2023-24929": {"epss_score": 0.00371, "epss_percentile": 0.58371}, "CVE-2023-24930": {"epss_score": 0.00329, "epss_percentile": 0.55322}, "CVE-2023-24931": {"epss_score": 0.03376, "epss_percentile": 0.87021}, "CVE-2023-24932": {"epss_score": 0.00683, "epss_percentile": 0.71094}, "CVE-2023-24934": {"epss_score": 0.00906, "epss_percentile": 0.75247}, "CVE-2023-24935": {"epss_score": 0.00174, "epss_percentile": 0.39173}, "CVE-2023-24936": {"epss_score": 0.01471, "epss_percentile": 0.80499}, "CVE-2023-24937": {"epss_score": 0.05435, "epss_percentile": 0.8988}, "CVE-2023-24938": {"epss_score": 0.05288, "epss_percentile": 0.89694}, "CVE-2023-24939": {"epss_score": 0.03518, "epss_percentile": 0.8728}, "CVE-2023-24940": {"epss_score": 0.03647, "epss_percentile": 0.87504}, "CVE-2023-24941": {"epss_score": 0.40219, "epss_percentile": 0.97207}, "CVE-2023-24942": {"epss_score": 0.02977, "epss_percentile": 0.86106}, "CVE-2023-24943": {"epss_score": 0.01302, "epss_percentile": 0.79305}, "CVE-2023-24944": {"epss_score": 0.00184, "epss_percentile": 0.4038}, "CVE-2023-24945": {"epss_score": 0.00327, "epss_percentile": 0.55093}, "CVE-2023-24946": {"epss_score": 0.00095, "epss_percentile": 0.27121}, "CVE-2023-24947": {"epss_score": 0.00141, "epss_percentile": 0.34815}, "CVE-2023-24948": {"epss_score": 0.00361, "epss_percentile": 0.57748}, "CVE-2023-24949": {"epss_score": 0.06763, "epss_percentile": 0.9101}, "CVE-2023-24950": {"epss_score": 0.29866, "epss_percentile": 0.96482}, "CVE-2023-24953": {"epss_score": 0.0102, "epss_percentile": 0.76735}, "CVE-2023-24954": {"epss_score": 0.0204, "epss_percentile": 0.83366}, "CVE-2023-24955": {"epss_score": 0.91453, "epss_percentile": 0.99644}, "CVE-2023-24956": {"epss_score": 0.00078, "epss_percentile": 0.23552}, "CVE-2023-24957": {"epss_score": 0.0012, "epss_percentile": 0.31803}, "CVE-2023-24958": {"epss_score": 0.00193, "epss_percentile": 0.41408}, "CVE-2023-24959": {"epss_score": 0.00046, "epss_percentile": 0.14088}, "CVE-2023-24960": {"epss_score": 0.00108, "epss_percentile": 0.29841}, "CVE-2023-24964": {"epss_score": 0.00016, "epss_percentile": 0.02829}, "CVE-2023-24965": {"epss_score": 0.00061, "epss_percentile": 0.19255}, "CVE-2023-24966": {"epss_score": 0.00097, "epss_percentile": 0.27596}, "CVE-2023-24971": {"epss_score": 0.00086, "epss_percentile": 0.2544}, "CVE-2023-24975": {"epss_score": 0.00092, "epss_percentile": 0.26602}, "CVE-2023-24977": {"epss_score": 0.00328, "epss_percentile": 0.55276}, "CVE-2023-24978": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24979": {"epss_score": 0.00086, "epss_percentile": 0.25394}, "CVE-2023-24980": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24981": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24982": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24983": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24984": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24985": {"epss_score": 0.00086, "epss_percentile": 0.25394}, "CVE-2023-24986": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24987": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24988": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24989": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24990": {"epss_score": 0.00086, "epss_percentile": 0.25394}, "CVE-2023-24991": {"epss_score": 0.00086, "epss_percentile": 0.25394}, "CVE-2023-24992": {"epss_score": 0.00086, "epss_percentile": 0.25394}, "CVE-2023-24993": {"epss_score": 0.00086, "epss_percentile": 0.25394}, "CVE-2023-24994": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24995": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24996": {"epss_score": 0.00113, "epss_percentile": 0.30626}, "CVE-2023-24997": {"epss_score": 0.003, "epss_percentile": 0.5299}, "CVE-2023-24998": {"epss_score": 0.47785, "epss_percentile": 0.97601}, "CVE-2023-24999": {"epss_score": 0.00108, "epss_percentile": 0.29779}, "CVE-2023-25000": {"epss_score": 0.00028, "epss_percentile": 0.07216}, "CVE-2023-25001": {"epss_score": 0.00098, "epss_percentile": 0.27807}, "CVE-2023-25002": {"epss_score": 0.00188, "epss_percentile": 0.40849}, "CVE-2023-25003": {"epss_score": 0.00054, "epss_percentile": 0.17198}, "CVE-2023-25004": {"epss_score": 0.00083, "epss_percentile": 0.24796}, "CVE-2023-25005": {"epss_score": 0.00079, "epss_percentile": 0.23971}, "CVE-2023-25006": {"epss_score": 0.00075, "epss_percentile": 0.23024}, "CVE-2023-25007": {"epss_score": 0.00083, "epss_percentile": 0.24796}, "CVE-2023-25008": {"epss_score": 0.00109, "epss_percentile": 0.29991}, "CVE-2023-25009": {"epss_score": 0.00083, "epss_percentile": 0.24796}, "CVE-2023-25010": {"epss_score": 0.00097, "epss_percentile": 0.27625}, "CVE-2023-25011": {"epss_score": 0.00045, "epss_percentile": 0.13954}, "CVE-2023-25012": {"epss_score": 0.00022, "epss_percentile": 0.05042}, "CVE-2023-25013": {"epss_score": 0.00093, "epss_percentile": 0.2661}, "CVE-2023-25014": {"epss_score": 0.00101, "epss_percentile": 0.28588}, "CVE-2023-25015": {"epss_score": 0.00288, "epss_percentile": 0.51917}, "CVE-2023-25016": {"epss_score": 0.00181, "epss_percentile": 0.40085}, "CVE-2023-25017": {"epss_score": 0.001, "epss_percentile": 0.28471}, "CVE-2023-25018": {"epss_score": 0.00067, "epss_percentile": 0.21135}, "CVE-2023-25019": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-25020": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-25021": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25022": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25023": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25024": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25025": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25026": {"epss_score": 0.0015, "epss_percentile": 0.36059}, "CVE-2023-25027": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25028": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25029": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25030": {"epss_score": 0.00113, "epss_percentile": 0.30721}, "CVE-2023-25031": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25032": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-25033": {"epss_score": 0.00055, "epss_percentile": 0.17571}, "CVE-2023-25034": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25035": {"epss_score": 0.00109, "epss_percentile": 0.29905}, "CVE-2023-25036": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2023-25037": {"epss_score": 0.0015, "epss_percentile": 0.36059}, "CVE-2023-25038": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25039": {"epss_score": 0.00061, "epss_percentile": 0.19393}, "CVE-2023-25040": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-25041": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-25042": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-25043": {"epss_score": 0.0013, "epss_percentile": 0.33245}, "CVE-2023-25044": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-25045": {"epss_score": 0.00307, "epss_percentile": 0.53515}, "CVE-2023-25046": {"epss_score": 0.00086, "epss_percentile": 0.25442}, "CVE-2023-25047": {"epss_score": 0.00417, "epss_percentile": 0.6124}, "CVE-2023-25048": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-25049": {"epss_score": 0.00086, "epss_percentile": 0.25363}, "CVE-2023-25050": {"epss_score": 0.00743, "epss_percentile": 0.72464}, "CVE-2023-25051": {"epss_score": 0.00077, "epss_percentile": 0.23287}, "CVE-2023-25052": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25054": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2023-25055": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2023-25056": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25057": {"epss_score": 0.00366, "epss_percentile": 0.58053}, "CVE-2023-25058": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25059": {"epss_score": 0.00293, "epss_percentile": 0.52331}, "CVE-2023-25060": {"epss_score": 0.00177, "epss_percentile": 0.39609}, "CVE-2023-25061": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-25062": {"epss_score": 0.00398, "epss_percentile": 0.60076}, "CVE-2023-25063": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-25064": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25065": {"epss_score": 0.0012, "epss_percentile": 0.31806}, "CVE-2023-25066": {"epss_score": 0.00094, "epss_percentile": 0.26965}, "CVE-2023-25067": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-25068": {"epss_score": 0.0005, "epss_percentile": 0.15781}, "CVE-2023-25069": {"epss_score": 0.00338, "epss_percentile": 0.56069}, "CVE-2023-25070": {"epss_score": 0.0026, "epss_percentile": 0.49166}, "CVE-2023-25071": {"epss_score": 0.00074, "epss_percentile": 0.22728}, "CVE-2023-25072": {"epss_score": 0.00517, "epss_percentile": 0.6607}, "CVE-2023-25073": {"epss_score": 0.00048, "epss_percentile": 0.15041}, "CVE-2023-25074": {"epss_score": 0.00037, "epss_percentile": 0.10786}, "CVE-2023-25075": {"epss_score": 0.00189, "epss_percentile": 0.40958}, "CVE-2023-25076": {"epss_score": 0.31188, "epss_percentile": 0.966}, "CVE-2023-25077": {"epss_score": 0.00695, "epss_percentile": 0.71369}, "CVE-2023-25078": {"epss_score": 0.00071, "epss_percentile": 0.2219}, "CVE-2023-25080": {"epss_score": 0.00133, "epss_percentile": 0.33637}, "CVE-2023-25081": {"epss_score": 0.00084, "epss_percentile": 0.24867}, "CVE-2023-25082": {"epss_score": 0.00084, "epss_percentile": 0.24867}, "CVE-2023-25083": {"epss_score": 0.00081, "epss_percentile": 0.24213}, "CVE-2023-25084": {"epss_score": 0.00084, "epss_percentile": 0.24867}, "CVE-2023-25085": {"epss_score": 0.00081, "epss_percentile": 0.24213}, "CVE-2023-25086": {"epss_score": 0.00084, "epss_percentile": 0.24867}, "CVE-2023-25087": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25088": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25089": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25090": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25091": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25092": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25093": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25094": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25095": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25096": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25097": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25098": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25099": {"epss_score": 0.00117, "epss_percentile": 0.31204}, "CVE-2023-25100": {"epss_score": 0.00121, "epss_percentile": 0.31936}, "CVE-2023-25101": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25102": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25103": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25104": {"epss_score": 0.00117, "epss_percentile": 0.31204}, "CVE-2023-25105": {"epss_score": 0.00121, "epss_percentile": 0.31936}, "CVE-2023-25106": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25107": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25108": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25109": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25110": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25111": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25112": {"epss_score": 0.00117, "epss_percentile": 0.31204}, "CVE-2023-25113": {"epss_score": 0.00121, "epss_percentile": 0.31936}, "CVE-2023-25114": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25115": {"epss_score": 0.00121, "epss_percentile": 0.31936}, "CVE-2023-25116": {"epss_score": 0.00121, "epss_percentile": 0.31936}, "CVE-2023-25117": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25118": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25119": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25120": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25121": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25122": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-25123": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25124": {"epss_score": 0.00129, "epss_percentile": 0.33203}, "CVE-2023-25131": {"epss_score": 0.00345, "epss_percentile": 0.56582}, "CVE-2023-25132": {"epss_score": 0.0024, "epss_percentile": 0.46961}, "CVE-2023-25133": {"epss_score": 0.00233, "epss_percentile": 0.45985}, "CVE-2023-25134": {"epss_score": 0.00049, "epss_percentile": 0.1556}, "CVE-2023-25135": {"epss_score": 0.9321, "epss_percentile": 0.99784}, "CVE-2023-25136": {"epss_score": 0.90974, "epss_percentile": 0.99613}, "CVE-2023-25139": {"epss_score": 0.00163, "epss_percentile": 0.37809}, "CVE-2023-25140": {"epss_score": 0.0011, "epss_percentile": 0.301}, "CVE-2023-25141": {"epss_score": 0.00714, "epss_percentile": 0.71814}, "CVE-2023-25143": {"epss_score": 0.06181, "epss_percentile": 0.90538}, "CVE-2023-25144": {"epss_score": 0.00076, "epss_percentile": 0.23147}, "CVE-2023-25145": {"epss_score": 0.00056, "epss_percentile": 0.17821}, "CVE-2023-25146": {"epss_score": 0.00056, "epss_percentile": 0.17821}, "CVE-2023-25147": {"epss_score": 0.00013, "epss_percentile": 0.01487}, "CVE-2023-25148": {"epss_score": 0.00056, "epss_percentile": 0.17821}, "CVE-2023-25149": {"epss_score": 0.00116, "epss_percentile": 0.31038}, "CVE-2023-25150": {"epss_score": 0.00234, "epss_percentile": 0.46125}, "CVE-2023-25151": {"epss_score": 0.00201, "epss_percentile": 0.42322}, "CVE-2023-25152": {"epss_score": 0.00395, "epss_percentile": 0.59812}, "CVE-2023-25153": {"epss_score": 0.00123, "epss_percentile": 0.3221}, "CVE-2023-25154": {"epss_score": 0.00287, "epss_percentile": 0.51804}, "CVE-2023-25155": {"epss_score": 0.02909, "epss_percentile": 0.85968}, "CVE-2023-25156": {"epss_score": 0.00289, "epss_percentile": 0.52039}, "CVE-2023-25157": {"epss_score": 0.93866, "epss_percentile": 0.9986}, "CVE-2023-25158": {"epss_score": 0.03907, "epss_percentile": 0.8793}, "CVE-2023-25159": {"epss_score": 0.00176, "epss_percentile": 0.39441}, "CVE-2023-25160": {"epss_score": 0.0034, "epss_percentile": 0.56228}, "CVE-2023-25161": {"epss_score": 0.00111, "epss_percentile": 0.30386}, "CVE-2023-25162": {"epss_score": 0.00148, "epss_percentile": 0.35802}, "CVE-2023-25163": {"epss_score": 0.00826, "epss_percentile": 0.73962}, "CVE-2023-25164": {"epss_score": 0.00349, "epss_percentile": 0.56893}, "CVE-2023-25165": {"epss_score": 0.00161, "epss_percentile": 0.37571}, "CVE-2023-25166": {"epss_score": 0.01086, "epss_percentile": 0.77423}, "CVE-2023-25167": {"epss_score": 0.00702, "epss_percentile": 0.71507}, "CVE-2023-25168": {"epss_score": 0.00344, "epss_percentile": 0.56539}, "CVE-2023-25169": {"epss_score": 0.0031, "epss_percentile": 0.53763}, "CVE-2023-25170": {"epss_score": 0.00032, "epss_percentile": 0.08764}, "CVE-2023-25171": {"epss_score": 0.00322, "epss_percentile": 0.54821}, "CVE-2023-25172": {"epss_score": 0.00643, "epss_percentile": 0.70065}, "CVE-2023-25173": {"epss_score": 0.00022, "epss_percentile": 0.0516}, "CVE-2023-25174": {"epss_score": 0.00065, "epss_percentile": 0.20604}, "CVE-2023-25175": {"epss_score": 0.0004, "epss_percentile": 0.12138}, "CVE-2023-25176": {"epss_score": 0.001, "epss_percentile": 0.28487}, "CVE-2023-25177": {"epss_score": 0.00061, "epss_percentile": 0.1928}, "CVE-2023-25178": {"epss_score": 0.00892, "epss_percentile": 0.75068}, "CVE-2023-25179": {"epss_score": 0.0007, "epss_percentile": 0.2187}, "CVE-2023-25181": {"epss_score": 0.00303, "epss_percentile": 0.53178}, "CVE-2023-25182": {"epss_score": 0.00048, "epss_percentile": 0.15034}, "CVE-2023-25183": {"epss_score": 0.00043, "epss_percentile": 0.13359}, "CVE-2023-25184": {"epss_score": 0.00517, "epss_percentile": 0.6607}, "CVE-2023-25185": {"epss_score": 0.0003, "epss_percentile": 0.08089}, "CVE-2023-25186": {"epss_score": 0.00027, "epss_percentile": 0.06814}, "CVE-2023-25187": {"epss_score": 0.00157, "epss_percentile": 0.37133}, "CVE-2023-25188": {"epss_score": 0.00031, "epss_percentile": 0.08575}, "CVE-2023-25189": {"epss_score": 0.00076, "epss_percentile": 0.23166}, "CVE-2023-25191": {"epss_score": 0.00222, "epss_percentile": 0.44788}, "CVE-2023-25192": {"epss_score": 0.00216, "epss_percentile": 0.44206}, "CVE-2023-25193": {"epss_score": 0.00054, "epss_percentile": 0.17261}, "CVE-2023-25194": {"epss_score": 0.94055, "epss_percentile": 0.99894}, "CVE-2023-25195": {"epss_score": 0.00124, "epss_percentile": 0.32345}, "CVE-2023-25196": {"epss_score": 0.00473, "epss_percentile": 0.64104}, "CVE-2023-25197": {"epss_score": 0.00187, "epss_percentile": 0.40725}, "CVE-2023-25199": {"epss_score": 0.00128, "epss_percentile": 0.33048}, "CVE-2023-25200": {"epss_score": 0.00145, "epss_percentile": 0.35496}, "CVE-2023-25201": {"epss_score": 0.008, "epss_percentile": 0.73559}, "CVE-2023-25206": {"epss_score": 0.00083, "epss_percentile": 0.24785}, "CVE-2023-25207": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-25210": {"epss_score": 0.00151, "epss_percentile": 0.36353}, "CVE-2023-25211": {"epss_score": 0.00151, "epss_percentile": 0.36353}, "CVE-2023-25212": {"epss_score": 0.00151, "epss_percentile": 0.36353}, "CVE-2023-25213": {"epss_score": 0.00151, "epss_percentile": 0.36353}, "CVE-2023-25214": {"epss_score": 0.00151, "epss_percentile": 0.36353}, "CVE-2023-25215": {"epss_score": 0.00151, "epss_percentile": 0.36353}, "CVE-2023-25216": {"epss_score": 0.00151, "epss_percentile": 0.36353}, "CVE-2023-25217": {"epss_score": 0.00198, "epss_percentile": 0.42044}, "CVE-2023-25218": {"epss_score": 0.00151, "epss_percentile": 0.36353}, "CVE-2023-25219": {"epss_score": 0.00151, "epss_percentile": 0.36353}, "CVE-2023-25220": {"epss_score": 0.00151, "epss_percentile": 0.36353}, "CVE-2023-25221": {"epss_score": 0.00038, "epss_percentile": 0.11156}, "CVE-2023-25222": {"epss_score": 0.00419, "epss_percentile": 0.61361}, "CVE-2023-25223": {"epss_score": 0.00332, "epss_percentile": 0.55585}, "CVE-2023-25230": {"epss_score": 0.00054, "epss_percentile": 0.1709}, "CVE-2023-25231": {"epss_score": 0.00223, "epss_percentile": 0.44967}, "CVE-2023-25233": {"epss_score": 0.00171, "epss_percentile": 0.38819}, "CVE-2023-25234": {"epss_score": 0.72018, "epss_percentile": 0.98692}, "CVE-2023-25235": {"epss_score": 0.18285, "epss_percentile": 0.94989}, "CVE-2023-25240": {"epss_score": 3e-05, "epss_percentile": 0.00116}, "CVE-2023-25241": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-25260": {"epss_score": 0.0033, "epss_percentile": 0.55416}, "CVE-2023-25261": {"epss_score": 0.06725, "epss_percentile": 0.90971}, "CVE-2023-25262": {"epss_score": 0.00447, "epss_percentile": 0.62968}, "CVE-2023-25263": {"epss_score": 0.0003, "epss_percentile": 0.08081}, "CVE-2023-25264": {"epss_score": 0.0013, "epss_percentile": 0.3323}, "CVE-2023-25265": {"epss_score": 0.0027, "epss_percentile": 0.50237}, "CVE-2023-25266": {"epss_score": 0.01959, "epss_percentile": 0.83051}, "CVE-2023-25267": {"epss_score": 0.00168, "epss_percentile": 0.38497}, "CVE-2023-25279": {"epss_score": 0.71926, "epss_percentile": 0.98687}, "CVE-2023-25280": {"epss_score": 0.92752, "epss_percentile": 0.99743}, "CVE-2023-25281": {"epss_score": 0.003, "epss_percentile": 0.5291}, "CVE-2023-25282": {"epss_score": 0.00444, "epss_percentile": 0.62814}, "CVE-2023-25283": {"epss_score": 0.00538, "epss_percentile": 0.66934}, "CVE-2023-25289": {"epss_score": 0.03241, "epss_percentile": 0.86733}, "CVE-2023-25292": {"epss_score": 0.00244, "epss_percentile": 0.4762}, "CVE-2023-25295": {"epss_score": 0.00118, "epss_percentile": 0.31429}, "CVE-2023-25303": {"epss_score": 0.00468, "epss_percentile": 0.63876}, "CVE-2023-25304": {"epss_score": 0.00138, "epss_percentile": 0.34398}, "CVE-2023-25305": {"epss_score": 0.00518, "epss_percentile": 0.66092}, "CVE-2023-25306": {"epss_score": 0.00283, "epss_percentile": 0.51366}, "CVE-2023-25307": {"epss_score": 0.0016, "epss_percentile": 0.37502}, "CVE-2023-25309": {"epss_score": 0.0013, "epss_percentile": 0.33337}, "CVE-2023-25313": {"epss_score": 0.01853, "epss_percentile": 0.8255}, "CVE-2023-25314": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-25330": {"epss_score": 0.00607, "epss_percentile": 0.6904}, "CVE-2023-25341": {"epss_score": 0.00156, "epss_percentile": 0.36963}, "CVE-2023-25344": {"epss_score": 0.00164, "epss_percentile": 0.37907}, "CVE-2023-25345": {"epss_score": 0.00714, "epss_percentile": 0.71807}, "CVE-2023-25346": {"epss_score": 0.09598, "epss_percentile": 0.92615}, "CVE-2023-25347": {"epss_score": 0.00268, "epss_percentile": 0.50057}, "CVE-2023-25348": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2023-25350": {"epss_score": 0.00092, "epss_percentile": 0.26578}, "CVE-2023-25355": {"epss_score": 0.08309, "epss_percentile": 0.91983}, "CVE-2023-25356": {"epss_score": 0.19973, "epss_percentile": 0.95269}, "CVE-2023-25358": {"epss_score": 0.00138, "epss_percentile": 0.34522}, "CVE-2023-25360": {"epss_score": 0.00185, "epss_percentile": 0.40545}, "CVE-2023-25361": {"epss_score": 0.00185, "epss_percentile": 0.40545}, "CVE-2023-25362": {"epss_score": 0.00185, "epss_percentile": 0.40545}, "CVE-2023-25363": {"epss_score": 0.00185, "epss_percentile": 0.40545}, "CVE-2023-25364": {"epss_score": 0.00142, "epss_percentile": 0.35075}, "CVE-2023-25365": {"epss_score": 0.00049, "epss_percentile": 0.1533}, "CVE-2023-25366": {"epss_score": 0.0022, "epss_percentile": 0.44605}, "CVE-2023-25367": {"epss_score": 0.03405, "epss_percentile": 0.87074}, "CVE-2023-25368": {"epss_score": 0.0024, "epss_percentile": 0.47213}, "CVE-2023-25369": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-25392": {"epss_score": 0.00091, "epss_percentile": 0.26393}, "CVE-2023-25394": {"epss_score": 0.00041, "epss_percentile": 0.12271}, "CVE-2023-25395": {"epss_score": 0.01523, "epss_percentile": 0.80844}, "CVE-2023-25396": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2023-25399": {"epss_score": 0.0016, "epss_percentile": 0.37509}, "CVE-2023-25402": {"epss_score": 0.00083, "epss_percentile": 0.246}, "CVE-2023-25403": {"epss_score": 0.00025, "epss_percentile": 0.06263}, "CVE-2023-25407": {"epss_score": 0.00197, "epss_percentile": 0.41826}, "CVE-2023-25409": {"epss_score": 0.0007, "epss_percentile": 0.217}, "CVE-2023-25411": {"epss_score": 0.00191, "epss_percentile": 0.41191}, "CVE-2023-25413": {"epss_score": 0.00315, "epss_percentile": 0.54192}, "CVE-2023-25414": {"epss_score": 0.00064, "epss_percentile": 0.20424}, "CVE-2023-25415": {"epss_score": 0.00108, "epss_percentile": 0.29807}, "CVE-2023-25428": {"epss_score": 0.00032, "epss_percentile": 0.08957}, "CVE-2023-25431": {"epss_score": 0.00087, "epss_percentile": 0.25538}, "CVE-2023-25432": {"epss_score": 0.00086, "epss_percentile": 0.25424}, "CVE-2023-25433": {"epss_score": 0.00026, "epss_percentile": 0.06585}, "CVE-2023-25434": {"epss_score": 0.00209, "epss_percentile": 0.43366}, "CVE-2023-25435": {"epss_score": 0.00033, "epss_percentile": 0.09214}, "CVE-2023-25437": {"epss_score": 0.07286, "epss_percentile": 0.91384}, "CVE-2023-25438": {"epss_score": 0.01965, "epss_percentile": 0.83081}, "CVE-2023-25439": {"epss_score": 0.00159, "epss_percentile": 0.37305}, "CVE-2023-25440": {"epss_score": 0.00204, "epss_percentile": 0.42659}, "CVE-2023-25442": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25443": {"epss_score": 0.00056, "epss_percentile": 0.17924}, "CVE-2023-25444": {"epss_score": 0.00691, "epss_percentile": 0.71274}, "CVE-2023-25445": {"epss_score": 0.00057, "epss_percentile": 0.18013}, "CVE-2023-25446": {"epss_score": 0.00062, "epss_percentile": 0.1963}, "CVE-2023-25447": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25448": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-25449": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25450": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-25451": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25452": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25453": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-25454": {"epss_score": 0.00186, "epss_percentile": 0.40628}, "CVE-2023-25455": {"epss_score": 0.00087, "epss_percentile": 0.25617}, "CVE-2023-25456": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25457": {"epss_score": 0.00074, "epss_percentile": 0.2273}, "CVE-2023-25458": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25459": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-25460": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25461": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25462": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-25463": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-25464": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25465": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-25466": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-25467": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-25468": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25469": {"epss_score": 0.00064, "epss_percentile": 0.20322}, "CVE-2023-25470": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25471": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-25472": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25473": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2023-25474": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25475": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2023-25476": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-25477": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-25478": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25479": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25480": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25481": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-25482": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2023-25483": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-25484": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25485": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25486": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-25487": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25488": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-25489": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25490": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25491": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25492": {"epss_score": 0.00151, "epss_percentile": 0.36323}, "CVE-2023-25493": {"epss_score": 0.00017, "epss_percentile": 0.03304}, "CVE-2023-25494": {"epss_score": 0.00024, "epss_percentile": 0.05768}, "CVE-2023-25495": {"epss_score": 0.00107, "epss_percentile": 0.29739}, "CVE-2023-25496": {"epss_score": 0.00034, "epss_percentile": 0.09688}, "CVE-2023-25499": {"epss_score": 0.00235, "epss_percentile": 0.46322}, "CVE-2023-25500": {"epss_score": 0.00295, "epss_percentile": 0.52512}, "CVE-2023-25504": {"epss_score": 0.00046, "epss_percentile": 0.14288}, "CVE-2023-25505": {"epss_score": 0.00072, "epss_percentile": 0.22315}, "CVE-2023-25506": {"epss_score": 0.00039, "epss_percentile": 0.11447}, "CVE-2023-25507": {"epss_score": 0.00189, "epss_percentile": 0.40996}, "CVE-2023-25508": {"epss_score": 0.00039, "epss_percentile": 0.11643}, "CVE-2023-25509": {"epss_score": 0.00025, "epss_percentile": 0.0624}, "CVE-2023-25510": {"epss_score": 0.00037, "epss_percentile": 0.10767}, "CVE-2023-25511": {"epss_score": 0.00037, "epss_percentile": 0.10767}, "CVE-2023-25512": {"epss_score": 0.00065, "epss_percentile": 0.2044}, "CVE-2023-25513": {"epss_score": 0.00065, "epss_percentile": 0.2044}, "CVE-2023-25514": {"epss_score": 0.00067, "epss_percentile": 0.21097}, "CVE-2023-25515": {"epss_score": 0.00051, "epss_percentile": 0.16139}, "CVE-2023-25516": {"epss_score": 0.00024, "epss_percentile": 0.06019}, "CVE-2023-25517": {"epss_score": 0.0006, "epss_percentile": 0.18933}, "CVE-2023-25518": {"epss_score": 0.00082, "epss_percentile": 0.24462}, "CVE-2023-25519": {"epss_score": 0.00064, "epss_percentile": 0.20181}, "CVE-2023-25520": {"epss_score": 0.00022, "epss_percentile": 0.04982}, "CVE-2023-25521": {"epss_score": 0.00021, "epss_percentile": 0.04902}, "CVE-2023-25522": {"epss_score": 0.00029, "epss_percentile": 0.07585}, "CVE-2023-25523": {"epss_score": 0.00035, "epss_percentile": 0.10014}, "CVE-2023-25524": {"epss_score": 0.00152, "epss_percentile": 0.36506}, "CVE-2023-25525": {"epss_score": 0.00202, "epss_percentile": 0.42458}, "CVE-2023-25526": {"epss_score": 0.0005, "epss_percentile": 0.15836}, "CVE-2023-25527": {"epss_score": 0.00062, "epss_percentile": 0.1973}, "CVE-2023-25528": {"epss_score": 0.00492, "epss_percentile": 0.65004}, "CVE-2023-25529": {"epss_score": 0.003, "epss_percentile": 0.52939}, "CVE-2023-25530": {"epss_score": 0.00316, "epss_percentile": 0.54217}, "CVE-2023-25531": {"epss_score": 0.00228, "epss_percentile": 0.45504}, "CVE-2023-25532": {"epss_score": 0.00202, "epss_percentile": 0.42458}, "CVE-2023-25533": {"epss_score": 0.00141, "epss_percentile": 0.34827}, "CVE-2023-25534": {"epss_score": 0.00219, "epss_percentile": 0.4451}, "CVE-2023-25535": {"epss_score": 0.00047, "epss_percentile": 0.14482}, "CVE-2023-25536": {"epss_score": 0.00048, "epss_percentile": 0.15007}, "CVE-2023-25537": {"epss_score": 0.00034, "epss_percentile": 0.09688}, "CVE-2023-25539": {"epss_score": 0.01123, "epss_percentile": 0.7779}, "CVE-2023-25540": {"epss_score": 0.00025, "epss_percentile": 0.06321}, "CVE-2023-25542": {"epss_score": 0.00044, "epss_percentile": 0.13522}, "CVE-2023-25543": {"epss_score": 0.0003, "epss_percentile": 0.08309}, "CVE-2023-25544": {"epss_score": 0.00212, "epss_percentile": 0.43721}, "CVE-2023-25545": {"epss_score": 0.00089, "epss_percentile": 0.25838}, "CVE-2023-25546": {"epss_score": 0.00027, "epss_percentile": 0.07208}, "CVE-2023-25547": {"epss_score": 0.04157, "epss_percentile": 0.8833}, "CVE-2023-25548": {"epss_score": 0.00318, "epss_percentile": 0.54438}, "CVE-2023-25549": {"epss_score": 0.02755, "epss_percentile": 0.85588}, "CVE-2023-25550": {"epss_score": 0.02755, "epss_percentile": 0.85588}, "CVE-2023-25551": {"epss_score": 0.00274, "epss_percentile": 0.50484}, "CVE-2023-25552": {"epss_score": 0.00222, "epss_percentile": 0.44716}, "CVE-2023-25553": {"epss_score": 0.00376, "epss_percentile": 0.58667}, "CVE-2023-25554": {"epss_score": 0.00135, "epss_percentile": 0.33945}, "CVE-2023-25555": {"epss_score": 0.00475, "epss_percentile": 0.6419}, "CVE-2023-25556": {"epss_score": 0.00123, "epss_percentile": 0.32326}, "CVE-2023-25557": {"epss_score": 0.00633, "epss_percentile": 0.69765}, "CVE-2023-25558": {"epss_score": 0.05931, "epss_percentile": 0.90338}, "CVE-2023-25559": {"epss_score": 0.00124, "epss_percentile": 0.32355}, "CVE-2023-25560": {"epss_score": 0.00187, "epss_percentile": 0.4074}, "CVE-2023-25561": {"epss_score": 0.00236, "epss_percentile": 0.46379}, "CVE-2023-25562": {"epss_score": 0.00032, "epss_percentile": 0.08805}, "CVE-2023-25563": {"epss_score": 0.00059, "epss_percentile": 0.1891}, "CVE-2023-25564": {"epss_score": 0.00083, "epss_percentile": 0.24752}, "CVE-2023-25565": {"epss_score": 0.00067, "epss_percentile": 0.21146}, "CVE-2023-25566": {"epss_score": 0.00108, "epss_percentile": 0.29788}, "CVE-2023-25567": {"epss_score": 0.00067, "epss_percentile": 0.21146}, "CVE-2023-25568": {"epss_score": 0.00466, "epss_percentile": 0.63791}, "CVE-2023-25569": {"epss_score": 0.00085, "epss_percentile": 0.25106}, "CVE-2023-25570": {"epss_score": 0.00107, "epss_percentile": 0.2961}, "CVE-2023-25571": {"epss_score": 0.00435, "epss_percentile": 0.62343}, "CVE-2023-25572": {"epss_score": 0.01152, "epss_percentile": 0.78046}, "CVE-2023-25573": {"epss_score": 0.93455, "epss_percentile": 0.99808}, "CVE-2023-25574": {"epss_score": 0.00234, "epss_percentile": 0.4608}, "CVE-2023-25575": {"epss_score": 0.00768, "epss_percentile": 0.72964}, "CVE-2023-25576": {"epss_score": 0.00292, "epss_percentile": 0.52275}, "CVE-2023-25577": {"epss_score": 0.00354, "epss_percentile": 0.57232}, "CVE-2023-25578": {"epss_score": 0.01099, "epss_percentile": 0.77558}, "CVE-2023-25579": {"epss_score": 0.00091, "epss_percentile": 0.26207}, "CVE-2023-25581": {"epss_score": 0.16894, "epss_percentile": 0.94743}, "CVE-2023-25582": {"epss_score": 0.0021, "epss_percentile": 0.43429}, "CVE-2023-25583": {"epss_score": 0.0021, "epss_percentile": 0.43429}, "CVE-2023-25584": {"epss_score": 0.00014, "epss_percentile": 0.01962}, "CVE-2023-25585": {"epss_score": 0.00022, "epss_percentile": 0.04988}, "CVE-2023-25586": {"epss_score": 0.00024, "epss_percentile": 0.05663}, "CVE-2023-25588": {"epss_score": 0.0002, "epss_percentile": 0.04537}, "CVE-2023-25589": {"epss_score": 0.01391, "epss_percentile": 0.79952}, "CVE-2023-25590": {"epss_score": 0.00057, "epss_percentile": 0.18213}, "CVE-2023-25591": {"epss_score": 0.00097, "epss_percentile": 0.27577}, "CVE-2023-25592": {"epss_score": 0.0009, "epss_percentile": 0.26013}, "CVE-2023-25593": {"epss_score": 0.0009, "epss_percentile": 0.26013}, "CVE-2023-25594": {"epss_score": 0.00141, "epss_percentile": 0.34929}, "CVE-2023-25595": {"epss_score": 0.00051, "epss_percentile": 0.16232}, "CVE-2023-25596": {"epss_score": 0.00087, "epss_percentile": 0.25577}, "CVE-2023-25597": {"epss_score": 0.00315, "epss_percentile": 0.54169}, "CVE-2023-25598": {"epss_score": 0.00317, "epss_percentile": 0.54329}, "CVE-2023-25599": {"epss_score": 0.00294, "epss_percentile": 0.52376}, "CVE-2023-25600": {"epss_score": 0.00049, "epss_percentile": 0.15461}, "CVE-2023-25601": {"epss_score": 0.00058, "epss_percentile": 0.18422}, "CVE-2023-25602": {"epss_score": 0.00112, "epss_percentile": 0.30436}, "CVE-2023-25603": {"epss_score": 0.00199, "epss_percentile": 0.42112}, "CVE-2023-25604": {"epss_score": 0.00078, "epss_percentile": 0.23788}, "CVE-2023-25605": {"epss_score": 0.00239, "epss_percentile": 0.46889}, "CVE-2023-25606": {"epss_score": 0.00208, "epss_percentile": 0.43225}, "CVE-2023-25607": {"epss_score": 0.00151, "epss_percentile": 0.36186}, "CVE-2023-25608": {"epss_score": 0.00231, "epss_percentile": 0.45843}, "CVE-2023-25609": {"epss_score": 0.00158, "epss_percentile": 0.37196}, "CVE-2023-25610": {"epss_score": 0.25025, "epss_percentile": 0.9598}, "CVE-2023-25611": {"epss_score": 0.00131, "epss_percentile": 0.33502}, "CVE-2023-25613": {"epss_score": 0.00189, "epss_percentile": 0.40959}, "CVE-2023-25614": {"epss_score": 0.00566, "epss_percentile": 0.67815}, "CVE-2023-25615": {"epss_score": 0.0029, "epss_percentile": 0.52111}, "CVE-2023-25616": {"epss_score": 0.00637, "epss_percentile": 0.6989}, "CVE-2023-25617": {"epss_score": 0.02985, "epss_percentile": 0.86131}, "CVE-2023-25618": {"epss_score": 0.00255, "epss_percentile": 0.48729}, "CVE-2023-25619": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-25620": {"epss_score": 0.00062, "epss_percentile": 0.19606}, "CVE-2023-25621": {"epss_score": 0.0006, "epss_percentile": 0.19083}, "CVE-2023-25632": {"epss_score": 7e-05, "epss_percentile": 0.00431}, "CVE-2023-25642": {"epss_score": 0.00224, "epss_percentile": 0.44999}, "CVE-2023-25643": {"epss_score": 0.0028, "epss_percentile": 0.51037}, "CVE-2023-25644": {"epss_score": 0.00312, "epss_percentile": 0.53938}, "CVE-2023-25645": {"epss_score": 0.00034, "epss_percentile": 0.09549}, "CVE-2023-25646": {"epss_score": 0.00098, "epss_percentile": 0.27722}, "CVE-2023-25647": {"epss_score": 0.00062, "epss_percentile": 0.19779}, "CVE-2023-25648": {"epss_score": 0.00068, "epss_percentile": 0.21352}, "CVE-2023-25649": {"epss_score": 0.00142, "epss_percentile": 0.34963}, "CVE-2023-25650": {"epss_score": 0.0026, "epss_percentile": 0.49229}, "CVE-2023-25651": {"epss_score": 0.00044, "epss_percentile": 0.13632}, "CVE-2023-25652": {"epss_score": 0.0264, "epss_percentile": 0.853}, "CVE-2023-25653": {"epss_score": 0.00357, "epss_percentile": 0.57465}, "CVE-2023-25654": {"epss_score": 0.01674, "epss_percentile": 0.81692}, "CVE-2023-25655": {"epss_score": 0.00317, "epss_percentile": 0.54393}, "CVE-2023-25656": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2023-25657": {"epss_score": 0.02407, "epss_percentile": 0.84656}, "CVE-2023-25658": {"epss_score": 0.00044, "epss_percentile": 0.13672}, "CVE-2023-25659": {"epss_score": 0.0017, "epss_percentile": 0.38734}, "CVE-2023-25660": {"epss_score": 0.002, "epss_percentile": 0.42259}, "CVE-2023-25661": {"epss_score": 0.00132, "epss_percentile": 0.33534}, "CVE-2023-25662": {"epss_score": 0.00126, "epss_percentile": 0.32773}, "CVE-2023-25663": {"epss_score": 0.00172, "epss_percentile": 0.39019}, "CVE-2023-25664": {"epss_score": 0.00088, "epss_percentile": 0.25763}, "CVE-2023-25665": {"epss_score": 0.00104, "epss_percentile": 0.29217}, "CVE-2023-25666": {"epss_score": 0.00045, "epss_percentile": 0.13808}, "CVE-2023-25667": {"epss_score": 0.00176, "epss_percentile": 0.39442}, "CVE-2023-25668": {"epss_score": 0.01611, "epss_percentile": 0.8133}, "CVE-2023-25669": {"epss_score": 0.00172, "epss_percentile": 0.38955}, "CVE-2023-25670": {"epss_score": 0.002, "epss_percentile": 0.42259}, "CVE-2023-25671": {"epss_score": 0.00266, "epss_percentile": 0.49865}, "CVE-2023-25672": {"epss_score": 0.00085, "epss_percentile": 0.25119}, "CVE-2023-25673": {"epss_score": 0.00233, "epss_percentile": 0.46076}, "CVE-2023-25674": {"epss_score": 0.00326, "epss_percentile": 0.5507}, "CVE-2023-25675": {"epss_score": 0.00172, "epss_percentile": 0.38955}, "CVE-2023-25676": {"epss_score": 0.002, "epss_percentile": 0.42259}, "CVE-2023-25680": {"epss_score": 0.0008, "epss_percentile": 0.24189}, "CVE-2023-25681": {"epss_score": 0.00035, "epss_percentile": 0.09926}, "CVE-2023-25682": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-25683": {"epss_score": 0.00062, "epss_percentile": 0.19644}, "CVE-2023-25684": {"epss_score": 0.00049, "epss_percentile": 0.15294}, "CVE-2023-25686": {"epss_score": 0.00022, "epss_percentile": 0.05044}, "CVE-2023-25687": {"epss_score": 0.00134, "epss_percentile": 0.33893}, "CVE-2023-25688": {"epss_score": 0.00097, "epss_percentile": 0.27543}, "CVE-2023-25689": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2023-25690": {"epss_score": 0.67037, "epss_percentile": 0.98491}, "CVE-2023-25691": {"epss_score": 0.0015, "epss_percentile": 0.36114}, "CVE-2023-25692": {"epss_score": 0.00314, "epss_percentile": 0.5409}, "CVE-2023-25693": {"epss_score": 0.0071, "epss_percentile": 0.71711}, "CVE-2023-25695": {"epss_score": 0.00442, "epss_percentile": 0.62724}, "CVE-2023-25696": {"epss_score": 0.0071, "epss_percentile": 0.71711}, "CVE-2023-25697": {"epss_score": 0.00206, "epss_percentile": 0.42781}, "CVE-2023-25698": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-25699": {"epss_score": 0.01436, "epss_percentile": 0.80275}, "CVE-2023-25700": {"epss_score": 0.00224, "epss_percentile": 0.45011}, "CVE-2023-25701": {"epss_score": 0.00624, "epss_percentile": 0.69571}, "CVE-2023-25702": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25703": {"epss_score": 0.00177, "epss_percentile": 0.39609}, "CVE-2023-25704": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25705": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25706": {"epss_score": 0.0004, "epss_percentile": 0.12024}, "CVE-2023-25707": {"epss_score": 0.00065, "epss_percentile": 0.20566}, "CVE-2023-25708": {"epss_score": 0.00088, "epss_percentile": 0.25708}, "CVE-2023-25709": {"epss_score": 0.00064, "epss_percentile": 0.20105}, "CVE-2023-25710": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25711": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-25712": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25713": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-25714": {"epss_score": 0.00304, "epss_percentile": 0.53262}, "CVE-2023-25715": {"epss_score": 0.0005, "epss_percentile": 0.15864}, "CVE-2023-25716": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25717": {"epss_score": 0.94239, "epss_percentile": 0.99923}, "CVE-2023-25718": {"epss_score": 0.00126, "epss_percentile": 0.32728}, "CVE-2023-25719": {"epss_score": 0.00293, "epss_percentile": 0.52352}, "CVE-2023-25721": {"epss_score": 0.00269, "epss_percentile": 0.50182}, "CVE-2023-25722": {"epss_score": 0.00054, "epss_percentile": 0.17213}, "CVE-2023-25725": {"epss_score": 0.20671, "epss_percentile": 0.95399}, "CVE-2023-25727": {"epss_score": 0.07535, "epss_percentile": 0.91522}, "CVE-2023-25728": {"epss_score": 0.00179, "epss_percentile": 0.39817}, "CVE-2023-25729": {"epss_score": 0.00116, "epss_percentile": 0.3108}, "CVE-2023-25730": {"epss_score": 0.00095, "epss_percentile": 0.27143}, "CVE-2023-25731": {"epss_score": 0.00228, "epss_percentile": 0.45491}, "CVE-2023-25732": {"epss_score": 0.00143, "epss_percentile": 0.35185}, "CVE-2023-25733": {"epss_score": 0.0019, "epss_percentile": 0.4108}, "CVE-2023-25734": {"epss_score": 0.00168, "epss_percentile": 0.38424}, "CVE-2023-25735": {"epss_score": 0.00156, "epss_percentile": 0.3689}, "CVE-2023-25736": {"epss_score": 0.00375, "epss_percentile": 0.58604}, "CVE-2023-25737": {"epss_score": 0.00161, "epss_percentile": 0.37548}, "CVE-2023-25738": {"epss_score": 0.00134, "epss_percentile": 0.33768}, "CVE-2023-25739": {"epss_score": 0.00183, "epss_percentile": 0.40366}, "CVE-2023-25740": {"epss_score": 0.00231, "epss_percentile": 0.45851}, "CVE-2023-25741": {"epss_score": 0.00186, "epss_percentile": 0.40647}, "CVE-2023-25742": {"epss_score": 0.00099, "epss_percentile": 0.2835}, "CVE-2023-25743": {"epss_score": 0.00079, "epss_percentile": 0.23894}, "CVE-2023-25744": {"epss_score": 0.00136, "epss_percentile": 0.34141}, "CVE-2023-25745": {"epss_score": 0.00251, "epss_percentile": 0.48316}, "CVE-2023-25746": {"epss_score": 0.00136, "epss_percentile": 0.34141}, "CVE-2023-25747": {"epss_score": 0.00185, "epss_percentile": 0.40467}, "CVE-2023-25748": {"epss_score": 0.00126, "epss_percentile": 0.32662}, "CVE-2023-25749": {"epss_score": 0.00126, "epss_percentile": 0.32662}, "CVE-2023-25750": {"epss_score": 0.00111, "epss_percentile": 0.30385}, "CVE-2023-25751": {"epss_score": 0.00102, "epss_percentile": 0.28757}, "CVE-2023-25752": {"epss_score": 0.00098, "epss_percentile": 0.27647}, "CVE-2023-25753": {"epss_score": 0.00746, "epss_percentile": 0.72551}, "CVE-2023-25754": {"epss_score": 0.00296, "epss_percentile": 0.52623}, "CVE-2023-25755": {"epss_score": 0.00077, "epss_percentile": 0.23458}, "CVE-2023-25756": {"epss_score": 0.00056, "epss_percentile": 0.17719}, "CVE-2023-25757": {"epss_score": 0.00114, "epss_percentile": 0.30751}, "CVE-2023-25758": {"epss_score": 0.00096, "epss_percentile": 0.27331}, "CVE-2023-25759": {"epss_score": 0.01206, "epss_percentile": 0.7852}, "CVE-2023-25760": {"epss_score": 0.00228, "epss_percentile": 0.45471}, "CVE-2023-25761": {"epss_score": 0.01511, "epss_percentile": 0.80774}, "CVE-2023-25762": {"epss_score": 0.60432, "epss_percentile": 0.98206}, "CVE-2023-25763": {"epss_score": 0.07556, "epss_percentile": 0.91539}, "CVE-2023-25764": {"epss_score": 0.07556, "epss_percentile": 0.91539}, "CVE-2023-25765": {"epss_score": 0.0004, "epss_percentile": 0.12108}, "CVE-2023-25766": {"epss_score": 0.00182, "epss_percentile": 0.40261}, "CVE-2023-25767": {"epss_score": 0.00087, "epss_percentile": 0.25483}, "CVE-2023-25768": {"epss_score": 0.00094, "epss_percentile": 0.26998}, "CVE-2023-25769": {"epss_score": 0.00056, "epss_percentile": 0.17959}, "CVE-2023-25770": {"epss_score": 0.00054, "epss_percentile": 0.17149}, "CVE-2023-25771": {"epss_score": 0.00052, "epss_percentile": 0.16346}, "CVE-2023-25772": {"epss_score": 0.00054, "epss_percentile": 0.17329}, "CVE-2023-25773": {"epss_score": 0.00059, "epss_percentile": 0.18846}, "CVE-2023-25774": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-25775": {"epss_score": 0.00301, "epss_percentile": 0.53051}, "CVE-2023-25776": {"epss_score": 0.00064, "epss_percentile": 0.20169}, "CVE-2023-25777": {"epss_score": 0.00078, "epss_percentile": 0.23584}, "CVE-2023-25779": {"epss_score": 0.00109, "epss_percentile": 0.30001}, "CVE-2023-25780": {"epss_score": 0.0003, "epss_percentile": 0.08155}, "CVE-2023-25781": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25782": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25783": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25784": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25785": {"epss_score": 0.00072, "epss_percentile": 0.22421}, "CVE-2023-25786": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25787": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25788": {"epss_score": 0.00065, "epss_percentile": 0.20566}, "CVE-2023-25789": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25790": {"epss_score": 0.0014, "epss_percentile": 0.34782}, "CVE-2023-25791": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2023-25792": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25793": {"epss_score": 0.00069, "epss_percentile": 0.21494}, "CVE-2023-25794": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25795": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-25796": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25797": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25798": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-25799": {"epss_score": 0.006, "epss_percentile": 0.68823}, "CVE-2023-25800": {"epss_score": 0.00245, "epss_percentile": 0.47649}, "CVE-2023-25801": {"epss_score": 0.00073, "epss_percentile": 0.22666}, "CVE-2023-25802": {"epss_score": 0.00615, "epss_percentile": 0.69308}, "CVE-2023-25803": {"epss_score": 0.00885, "epss_percentile": 0.74947}, "CVE-2023-25804": {"epss_score": 0.00354, "epss_percentile": 0.57222}, "CVE-2023-25805": {"epss_score": 0.00777, "epss_percentile": 0.73122}, "CVE-2023-25806": {"epss_score": 0.00303, "epss_percentile": 0.53203}, "CVE-2023-25807": {"epss_score": 0.00848, "epss_percentile": 0.74357}, "CVE-2023-25809": {"epss_score": 0.00033, "epss_percentile": 0.09341}, "CVE-2023-25810": {"epss_score": 0.00106, "epss_percentile": 0.29529}, "CVE-2023-25811": {"epss_score": 0.00106, "epss_percentile": 0.29529}, "CVE-2023-25812": {"epss_score": 0.00114, "epss_percentile": 0.30874}, "CVE-2023-25813": {"epss_score": 0.03983, "epss_percentile": 0.88061}, "CVE-2023-25814": {"epss_score": 0.00098, "epss_percentile": 0.27691}, "CVE-2023-25815": {"epss_score": 0.00085, "epss_percentile": 0.25224}, "CVE-2023-25816": {"epss_score": 0.0017, "epss_percentile": 0.38748}, "CVE-2023-25817": {"epss_score": 0.00123, "epss_percentile": 0.32332}, "CVE-2023-25818": {"epss_score": 0.00388, "epss_percentile": 0.59365}, "CVE-2023-25819": {"epss_score": 0.00112, "epss_percentile": 0.30543}, "CVE-2023-25820": {"epss_score": 0.00144, "epss_percentile": 0.35246}, "CVE-2023-25821": {"epss_score": 0.00321, "epss_percentile": 0.54693}, "CVE-2023-25822": {"epss_score": 0.00293, "epss_percentile": 0.5229}, "CVE-2023-25823": {"epss_score": 0.00121, "epss_percentile": 0.32008}, "CVE-2023-25824": {"epss_score": 0.00476, "epss_percentile": 0.64293}, "CVE-2023-25825": {"epss_score": 0.0066, "epss_percentile": 0.70522}, "CVE-2023-25826": {"epss_score": 0.83984, "epss_percentile": 0.99268}, "CVE-2023-25827": {"epss_score": 0.00226, "epss_percentile": 0.45255}, "CVE-2023-25828": {"epss_score": 0.00635, "epss_percentile": 0.69825}, "CVE-2023-25829": {"epss_score": 0.00422, "epss_percentile": 0.61559}, "CVE-2023-25830": {"epss_score": 0.00217, "epss_percentile": 0.44246}, "CVE-2023-25831": {"epss_score": 0.00217, "epss_percentile": 0.44246}, "CVE-2023-25832": {"epss_score": 0.00155, "epss_percentile": 0.3686}, "CVE-2023-25833": {"epss_score": 0.00318, "epss_percentile": 0.54435}, "CVE-2023-25834": {"epss_score": 0.00111, "epss_percentile": 0.30304}, "CVE-2023-25835": {"epss_score": 0.00134, "epss_percentile": 0.33854}, "CVE-2023-25836": {"epss_score": 0.0023, "epss_percentile": 0.45731}, "CVE-2023-25837": {"epss_score": 0.00161, "epss_percentile": 0.37526}, "CVE-2023-25838": {"epss_score": 0.00632, "epss_percentile": 0.69744}, "CVE-2023-25839": {"epss_score": 0.00061, "epss_percentile": 0.19483}, "CVE-2023-25840": {"epss_score": 0.00176, "epss_percentile": 0.39404}, "CVE-2023-25841": {"epss_score": 0.00646, "epss_percentile": 0.7014}, "CVE-2023-25848": {"epss_score": 0.00103, "epss_percentile": 0.2897}, "CVE-2023-25859": {"epss_score": 0.0011, "epss_percentile": 0.30228}, "CVE-2023-25860": {"epss_score": 0.00142, "epss_percentile": 0.35019}, "CVE-2023-25861": {"epss_score": 0.0015, "epss_percentile": 0.36126}, "CVE-2023-25862": {"epss_score": 0.00023, "epss_percentile": 0.05615}, "CVE-2023-25863": {"epss_score": 0.00176, "epss_percentile": 0.39438}, "CVE-2023-25864": {"epss_score": 0.00166, "epss_percentile": 0.38151}, "CVE-2023-25865": {"epss_score": 0.00099, "epss_percentile": 0.28356}, "CVE-2023-25866": {"epss_score": 0.00135, "epss_percentile": 0.33933}, "CVE-2023-25867": {"epss_score": 0.00099, "epss_percentile": 0.28356}, "CVE-2023-25868": {"epss_score": 0.00166, "epss_percentile": 0.38151}, "CVE-2023-25869": {"epss_score": 0.00176, "epss_percentile": 0.39438}, "CVE-2023-25870": {"epss_score": 0.00135, "epss_percentile": 0.33933}, "CVE-2023-25871": {"epss_score": 0.0024, "epss_percentile": 0.47187}, "CVE-2023-25872": {"epss_score": 0.00166, "epss_percentile": 0.38151}, "CVE-2023-25873": {"epss_score": 0.00176, "epss_percentile": 0.39438}, "CVE-2023-25874": {"epss_score": 0.00166, "epss_percentile": 0.38151}, "CVE-2023-25875": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-25876": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-25877": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-25878": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-25879": {"epss_score": 0.00105, "epss_percentile": 0.2925}, "CVE-2023-25880": {"epss_score": 0.00142, "epss_percentile": 0.35019}, "CVE-2023-25881": {"epss_score": 0.00105, "epss_percentile": 0.2925}, "CVE-2023-25882": {"epss_score": 0.00175, "epss_percentile": 0.39299}, "CVE-2023-25883": {"epss_score": 0.00175, "epss_percentile": 0.39299}, "CVE-2023-25884": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-25885": {"epss_score": 0.00166, "epss_percentile": 0.38151}, "CVE-2023-25886": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-25887": {"epss_score": 0.00176, "epss_percentile": 0.39438}, "CVE-2023-25888": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-25889": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-25890": {"epss_score": 0.00166, "epss_percentile": 0.38151}, "CVE-2023-25891": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-25892": {"epss_score": 0.00176, "epss_percentile": 0.39438}, "CVE-2023-25893": {"epss_score": 0.0024, "epss_percentile": 0.47187}, "CVE-2023-25894": {"epss_score": 0.00227, "epss_percentile": 0.45437}, "CVE-2023-25895": {"epss_score": 0.00175, "epss_percentile": 0.39299}, "CVE-2023-25896": {"epss_score": 0.0024, "epss_percentile": 0.47187}, "CVE-2023-25897": {"epss_score": 0.00175, "epss_percentile": 0.39299}, "CVE-2023-25898": {"epss_score": 0.00166, "epss_percentile": 0.38151}, "CVE-2023-25899": {"epss_score": 0.0024, "epss_percentile": 0.47187}, "CVE-2023-25900": {"epss_score": 0.00176, "epss_percentile": 0.39438}, "CVE-2023-25901": {"epss_score": 0.00099, "epss_percentile": 0.28356}, "CVE-2023-25902": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-25903": {"epss_score": 0.00135, "epss_percentile": 0.33933}, "CVE-2023-25904": {"epss_score": 0.00176, "epss_percentile": 0.39438}, "CVE-2023-25905": {"epss_score": 0.00142, "epss_percentile": 0.35019}, "CVE-2023-25906": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-25907": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-25908": {"epss_score": 0.00305, "epss_percentile": 0.53393}, "CVE-2023-25909": {"epss_score": 0.00504, "epss_percentile": 0.65549}, "CVE-2023-25910": {"epss_score": 0.00443, "epss_percentile": 0.62802}, "CVE-2023-25911": {"epss_score": 0.00689, "epss_percentile": 0.71221}, "CVE-2023-25912": {"epss_score": 0.00098, "epss_percentile": 0.27691}, "CVE-2023-25913": {"epss_score": 0.00083, "epss_percentile": 0.2471}, "CVE-2023-25914": {"epss_score": 0.00176, "epss_percentile": 0.39461}, "CVE-2023-25915": {"epss_score": 0.00445, "epss_percentile": 0.62879}, "CVE-2023-25921": {"epss_score": 0.00067, "epss_percentile": 0.21162}, "CVE-2023-25922": {"epss_score": 0.00052, "epss_percentile": 0.16583}, "CVE-2023-25923": {"epss_score": 0.00048, "epss_percentile": 0.15233}, "CVE-2023-25924": {"epss_score": 0.0008, "epss_percentile": 0.24177}, "CVE-2023-25925": {"epss_score": 0.00148, "epss_percentile": 0.35887}, "CVE-2023-25926": {"epss_score": 0.00036, "epss_percentile": 0.10243}, "CVE-2023-25927": {"epss_score": 0.00145, "epss_percentile": 0.35359}, "CVE-2023-25928": {"epss_score": 0.00141, "epss_percentile": 0.34924}, "CVE-2023-25929": {"epss_score": 0.00157, "epss_percentile": 0.37102}, "CVE-2023-25930": {"epss_score": 0.00095, "epss_percentile": 0.27124}, "CVE-2023-25931": {"epss_score": 0.00137, "epss_percentile": 0.34218}, "CVE-2023-25933": {"epss_score": 0.00477, "epss_percentile": 0.64301}, "CVE-2023-25934": {"epss_score": 0.0007, "epss_percentile": 0.21639}, "CVE-2023-25936": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-25937": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-25938": {"epss_score": 0.00021, "epss_percentile": 0.04751}, "CVE-2023-25940": {"epss_score": 0.0004, "epss_percentile": 0.11879}, "CVE-2023-25941": {"epss_score": 0.00045, "epss_percentile": 0.13705}, "CVE-2023-25942": {"epss_score": 0.00283, "epss_percentile": 0.5141}, "CVE-2023-25944": {"epss_score": 0.00061, "epss_percentile": 0.19266}, "CVE-2023-25945": {"epss_score": 0.00101, "epss_percentile": 0.28676}, "CVE-2023-25946": {"epss_score": 0.00035, "epss_percentile": 0.09991}, "CVE-2023-25947": {"epss_score": 0.00029, "epss_percentile": 0.07908}, "CVE-2023-25948": {"epss_score": 0.00078, "epss_percentile": 0.23746}, "CVE-2023-25949": {"epss_score": 0.00056, "epss_percentile": 0.17959}, "CVE-2023-25950": {"epss_score": 0.00058, "epss_percentile": 0.18543}, "CVE-2023-25951": {"epss_score": 0.00068, "epss_percentile": 0.21324}, "CVE-2023-25952": {"epss_score": 0.00054, "epss_percentile": 0.17264}, "CVE-2023-25953": {"epss_score": 0.00187, "epss_percentile": 0.40782}, "CVE-2023-25954": {"epss_score": 0.00016, "epss_percentile": 0.02886}, "CVE-2023-25955": {"epss_score": 0.0005, "epss_percentile": 0.15692}, "CVE-2023-25956": {"epss_score": 0.00431, "epss_percentile": 0.62066}, "CVE-2023-25957": {"epss_score": 0.00029, "epss_percentile": 0.07977}, "CVE-2023-25958": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25959": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-25960": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-25961": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-25962": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25963": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25964": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25965": {"epss_score": 0.00618, "epss_percentile": 0.69365}, "CVE-2023-25966": {"epss_score": 0.00266, "epss_percentile": 0.49909}, "CVE-2023-25967": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25968": {"epss_score": 0.00088, "epss_percentile": 0.25708}, "CVE-2023-25970": {"epss_score": 0.00313, "epss_percentile": 0.54071}, "CVE-2023-25971": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25972": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25973": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2023-25974": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25975": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-25976": {"epss_score": 0.00077, "epss_percentile": 0.23287}, "CVE-2023-25977": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25978": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25979": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-25980": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25981": {"epss_score": 0.00071, "epss_percentile": 0.22144}, "CVE-2023-25982": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-25983": {"epss_score": 0.00692, "epss_percentile": 0.71305}, "CVE-2023-25984": {"epss_score": 0.00063, "epss_percentile": 0.19871}, "CVE-2023-25985": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-25986": {"epss_score": 0.0007, "epss_percentile": 0.2193}, "CVE-2023-25987": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-25988": {"epss_score": 0.00199, "epss_percentile": 0.42131}, "CVE-2023-25989": {"epss_score": 0.00232, "epss_percentile": 0.45909}, "CVE-2023-25990": {"epss_score": 0.00245, "epss_percentile": 0.47649}, "CVE-2023-25991": {"epss_score": 0.00068, "epss_percentile": 0.21252}, "CVE-2023-25992": {"epss_score": 0.00067, "epss_percentile": 0.21073}, "CVE-2023-25993": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-25994": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-25995": {"epss_score": 0.00123, "epss_percentile": 0.32243}, "CVE-2023-25997": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2023-25998": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2023-25999": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2023-26000": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2023-26001": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2023-26002": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2023-26003": {"epss_score": 0.00036, "epss_percentile": 0.1031}, "CVE-2023-26005": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2023-26008": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-26009": {"epss_score": 0.0061, "epss_percentile": 0.69148}, "CVE-2023-26010": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26011": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-26012": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26013": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-26014": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-26015": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-26016": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26017": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26020": {"epss_score": 0.00265, "epss_percentile": 0.49815}, "CVE-2023-26021": {"epss_score": 0.00079, "epss_percentile": 0.24001}, "CVE-2023-26022": {"epss_score": 0.00108, "epss_percentile": 0.29828}, "CVE-2023-26023": {"epss_score": 0.00064, "epss_percentile": 0.20383}, "CVE-2023-26024": {"epss_score": 0.00012, "epss_percentile": 0.01336}, "CVE-2023-26026": {"epss_score": 0.00069, "epss_percentile": 0.21508}, "CVE-2023-26031": {"epss_score": 0.16285, "epss_percentile": 0.94611}, "CVE-2023-26032": {"epss_score": 0.00244, "epss_percentile": 0.47529}, "CVE-2023-26033": {"epss_score": 0.00251, "epss_percentile": 0.48261}, "CVE-2023-26034": {"epss_score": 0.00494, "epss_percentile": 0.65085}, "CVE-2023-26035": {"epss_score": 0.49634, "epss_percentile": 0.97698}, "CVE-2023-26036": {"epss_score": 0.00181, "epss_percentile": 0.40101}, "CVE-2023-26037": {"epss_score": 0.00179, "epss_percentile": 0.39841}, "CVE-2023-26038": {"epss_score": 0.00188, "epss_percentile": 0.40808}, "CVE-2023-26039": {"epss_score": 0.01349, "epss_percentile": 0.79667}, "CVE-2023-26040": {"epss_score": 0.00211, "epss_percentile": 0.43646}, "CVE-2023-26041": {"epss_score": 0.00439, "epss_percentile": 0.62589}, "CVE-2023-26042": {"epss_score": 0.00572, "epss_percentile": 0.68}, "CVE-2023-26043": {"epss_score": 0.00357, "epss_percentile": 0.57403}, "CVE-2023-26044": {"epss_score": 0.00115, "epss_percentile": 0.30956}, "CVE-2023-26045": {"epss_score": 0.00304, "epss_percentile": 0.53269}, "CVE-2023-26046": {"epss_score": 0.00282, "epss_percentile": 0.51275}, "CVE-2023-26047": {"epss_score": 0.00051, "epss_percentile": 0.16157}, "CVE-2023-26048": {"epss_score": 0.39409, "epss_percentile": 0.97159}, "CVE-2023-26049": {"epss_score": 0.00353, "epss_percentile": 0.57142}, "CVE-2023-26051": {"epss_score": 0.00972, "epss_percentile": 0.7614}, "CVE-2023-26052": {"epss_score": 0.00798, "epss_percentile": 0.73516}, "CVE-2023-26053": {"epss_score": 0.00398, "epss_percentile": 0.6006}, "CVE-2023-26054": {"epss_score": 0.00891, "epss_percentile": 0.75036}, "CVE-2023-26055": {"epss_score": 0.01331, "epss_percentile": 0.79516}, "CVE-2023-26056": {"epss_score": 0.0034, "epss_percentile": 0.56213}, "CVE-2023-26057": {"epss_score": 0.00065, "epss_percentile": 0.20625}, "CVE-2023-26058": {"epss_score": 0.00065, "epss_percentile": 0.20625}, "CVE-2023-26059": {"epss_score": 0.00087, "epss_percentile": 0.2553}, "CVE-2023-26060": {"epss_score": 0.00094, "epss_percentile": 0.26783}, "CVE-2023-26061": {"epss_score": 0.00087, "epss_percentile": 0.2553}, "CVE-2023-26062": {"epss_score": 0.00058, "epss_percentile": 0.18508}, "CVE-2023-26063": {"epss_score": 0.00464, "epss_percentile": 0.63704}, "CVE-2023-26064": {"epss_score": 0.00397, "epss_percentile": 0.59969}, "CVE-2023-26065": {"epss_score": 0.00397, "epss_percentile": 0.59969}, "CVE-2023-26066": {"epss_score": 0.00292, "epss_percentile": 0.52259}, "CVE-2023-26067": {"epss_score": 0.92175, "epss_percentile": 0.99696}, "CVE-2023-26068": {"epss_score": 0.77712, "epss_percentile": 0.98949}, "CVE-2023-26069": {"epss_score": 0.00292, "epss_percentile": 0.52259}, "CVE-2023-26070": {"epss_score": 0.00239, "epss_percentile": 0.46858}, "CVE-2023-26071": {"epss_score": 0.00116, "epss_percentile": 0.31069}, "CVE-2023-26072": {"epss_score": 0.00272, "epss_percentile": 0.50412}, "CVE-2023-26073": {"epss_score": 0.00272, "epss_percentile": 0.50412}, "CVE-2023-26074": {"epss_score": 0.00356, "epss_percentile": 0.57367}, "CVE-2023-26075": {"epss_score": 0.00332, "epss_percentile": 0.55601}, "CVE-2023-26076": {"epss_score": 0.00177, "epss_percentile": 0.39557}, "CVE-2023-26077": {"epss_score": 0.00043, "epss_percentile": 0.13331}, "CVE-2023-26078": {"epss_score": 0.0007, "epss_percentile": 0.21725}, "CVE-2023-26081": {"epss_score": 0.00157, "epss_percentile": 0.37102}, "CVE-2023-26083": {"epss_score": 0.05173, "epss_percentile": 0.89572}, "CVE-2023-26084": {"epss_score": 0.00226, "epss_percentile": 0.45286}, "CVE-2023-26085": {"epss_score": 0.00043, "epss_percentile": 0.13138}, "CVE-2023-26088": {"epss_score": 0.00463, "epss_percentile": 0.63664}, "CVE-2023-26089": {"epss_score": 0.00219, "epss_percentile": 0.4448}, "CVE-2023-26091": {"epss_score": 0.00458, "epss_percentile": 0.63438}, "CVE-2023-26092": {"epss_score": 0.00541, "epss_percentile": 0.67034}, "CVE-2023-26093": {"epss_score": 0.00541, "epss_percentile": 0.67034}, "CVE-2023-26095": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-26097": {"epss_score": 0.00024, "epss_percentile": 0.05811}, "CVE-2023-26098": {"epss_score": 0.00042, "epss_percentile": 0.12704}, "CVE-2023-26099": {"epss_score": 0.00045, "epss_percentile": 0.13891}, "CVE-2023-26100": {"epss_score": 9e-05, "epss_percentile": 0.00641}, "CVE-2023-26101": {"epss_score": 0.00117, "epss_percentile": 0.31334}, "CVE-2023-26102": {"epss_score": 0.00079, "epss_percentile": 0.23825}, "CVE-2023-26103": {"epss_score": 0.00123, "epss_percentile": 0.32316}, "CVE-2023-26104": {"epss_score": 0.00101, "epss_percentile": 0.28709}, "CVE-2023-26105": {"epss_score": 0.00079, "epss_percentile": 0.23825}, "CVE-2023-26106": {"epss_score": 0.00085, "epss_percentile": 0.25036}, "CVE-2023-26107": {"epss_score": 0.00061, "epss_percentile": 0.19298}, "CVE-2023-26108": {"epss_score": 0.00117, "epss_percentile": 0.31242}, "CVE-2023-26109": {"epss_score": 0.00115, "epss_percentile": 0.31019}, "CVE-2023-26110": {"epss_score": 0.00208, "epss_percentile": 0.43258}, "CVE-2023-26111": {"epss_score": 0.0112, "epss_percentile": 0.77764}, "CVE-2023-26112": {"epss_score": 0.00066, "epss_percentile": 0.207}, "CVE-2023-26113": {"epss_score": 0.00189, "epss_percentile": 0.40924}, "CVE-2023-26114": {"epss_score": 0.00066, "epss_percentile": 0.20675}, "CVE-2023-26115": {"epss_score": 0.00031, "epss_percentile": 0.08533}, "CVE-2023-26116": {"epss_score": 0.00336, "epss_percentile": 0.55999}, "CVE-2023-26117": {"epss_score": 0.00392, "epss_percentile": 0.59662}, "CVE-2023-26118": {"epss_score": 0.00645, "epss_percentile": 0.70103}, "CVE-2023-26119": {"epss_score": 0.04647, "epss_percentile": 0.88961}, "CVE-2023-26120": {"epss_score": 0.00152, "epss_percentile": 0.36495}, "CVE-2023-26121": {"epss_score": 0.00099, "epss_percentile": 0.28382}, "CVE-2023-26122": {"epss_score": 0.03154, "epss_percentile": 0.86511}, "CVE-2023-26123": {"epss_score": 0.00117, "epss_percentile": 0.3135}, "CVE-2023-26125": {"epss_score": 0.00129, "epss_percentile": 0.33105}, "CVE-2023-26126": {"epss_score": 0.0027, "epss_percentile": 0.50194}, "CVE-2023-26127": {"epss_score": 0.0016, "epss_percentile": 0.37455}, "CVE-2023-26128": {"epss_score": 0.0021, "epss_percentile": 0.43483}, "CVE-2023-26129": {"epss_score": 0.00322, "epss_percentile": 0.54817}, "CVE-2023-26130": {"epss_score": 0.00187, "epss_percentile": 0.40734}, "CVE-2023-26131": {"epss_score": 0.00245, "epss_percentile": 0.47636}, "CVE-2023-26132": {"epss_score": 0.00196, "epss_percentile": 0.41748}, "CVE-2023-26133": {"epss_score": 0.00061, "epss_percentile": 0.19339}, "CVE-2023-26134": {"epss_score": 0.00221, "epss_percentile": 0.44699}, "CVE-2023-26135": {"epss_score": 0.00076, "epss_percentile": 0.23209}, "CVE-2023-26136": {"epss_score": 0.06872, "epss_percentile": 0.91086}, "CVE-2023-26137": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-26138": {"epss_score": 0.00239, "epss_percentile": 0.46857}, "CVE-2023-26139": {"epss_score": 0.00109, "epss_percentile": 0.30061}, "CVE-2023-26140": {"epss_score": 0.00149, "epss_percentile": 0.35976}, "CVE-2023-26141": {"epss_score": 0.004, "epss_percentile": 0.6018}, "CVE-2023-26142": {"epss_score": 0.00219, "epss_percentile": 0.44528}, "CVE-2023-26143": {"epss_score": 0.00063, "epss_percentile": 0.19866}, "CVE-2023-26144": {"epss_score": 0.01703, "epss_percentile": 0.81844}, "CVE-2023-26145": {"epss_score": 0.01771, "epss_percentile": 0.82198}, "CVE-2023-26146": {"epss_score": 0.00197, "epss_percentile": 0.41934}, "CVE-2023-26147": {"epss_score": 0.0012, "epss_percentile": 0.31723}, "CVE-2023-26148": {"epss_score": 0.00125, "epss_percentile": 0.32504}, "CVE-2023-26149": {"epss_score": 0.01237, "epss_percentile": 0.78781}, "CVE-2023-26150": {"epss_score": 0.00161, "epss_percentile": 0.37559}, "CVE-2023-26151": {"epss_score": 0.00148, "epss_percentile": 0.35862}, "CVE-2023-26152": {"epss_score": 0.00766, "epss_percentile": 0.72935}, "CVE-2023-26153": {"epss_score": 0.00265, "epss_percentile": 0.49812}, "CVE-2023-26154": {"epss_score": 0.00362, "epss_percentile": 0.57753}, "CVE-2023-26155": {"epss_score": 0.00155, "epss_percentile": 0.36858}, "CVE-2023-26156": {"epss_score": 0.00619, "epss_percentile": 0.69426}, "CVE-2023-26157": {"epss_score": 0.00043, "epss_percentile": 0.12973}, "CVE-2023-26158": {"epss_score": 0.00086, "epss_percentile": 0.25369}, "CVE-2023-26159": {"epss_score": 0.00083, "epss_percentile": 0.24739}, "CVE-2023-26203": {"epss_score": 0.00044, "epss_percentile": 0.13674}, "CVE-2023-26204": {"epss_score": 0.00203, "epss_percentile": 0.42504}, "CVE-2023-26205": {"epss_score": 0.00203, "epss_percentile": 0.4254}, "CVE-2023-26206": {"epss_score": 0.00069, "epss_percentile": 0.21583}, "CVE-2023-26207": {"epss_score": 0.00187, "epss_percentile": 0.40758}, "CVE-2023-26208": {"epss_score": 0.07272, "epss_percentile": 0.91376}, "CVE-2023-26209": {"epss_score": 0.07272, "epss_percentile": 0.91376}, "CVE-2023-26210": {"epss_score": 0.00171, "epss_percentile": 0.38816}, "CVE-2023-26211": {"epss_score": 0.02034, "epss_percentile": 0.83345}, "CVE-2023-26213": {"epss_score": 0.04845, "epss_percentile": 0.89207}, "CVE-2023-26214": {"epss_score": 0.00599, "epss_percentile": 0.68789}, "CVE-2023-26215": {"epss_score": 0.00245, "epss_percentile": 0.47666}, "CVE-2023-26216": {"epss_score": 0.00201, "epss_percentile": 0.42319}, "CVE-2023-26217": {"epss_score": 0.00194, "epss_percentile": 0.41576}, "CVE-2023-26218": {"epss_score": 0.00196, "epss_percentile": 0.41811}, "CVE-2023-26219": {"epss_score": 0.00202, "epss_percentile": 0.42409}, "CVE-2023-26220": {"epss_score": 0.00111, "epss_percentile": 0.3039}, "CVE-2023-26221": {"epss_score": 0.00061, "epss_percentile": 0.19255}, "CVE-2023-26222": {"epss_score": 0.00411, "epss_percentile": 0.60888}, "CVE-2023-26226": {"epss_score": 0.00052, "epss_percentile": 0.16596}, "CVE-2023-26234": {"epss_score": 0.00085, "epss_percentile": 0.25135}, "CVE-2023-26235": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-26236": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2023-26237": {"epss_score": 0.00011, "epss_percentile": 0.01112}, "CVE-2023-26238": {"epss_score": 0.00053, "epss_percentile": 0.16902}, "CVE-2023-26239": {"epss_score": 0.00059, "epss_percentile": 0.18665}, "CVE-2023-26242": {"epss_score": 0.00017, "epss_percentile": 0.03185}, "CVE-2023-26243": {"epss_score": 0.00045, "epss_percentile": 0.13769}, "CVE-2023-26244": {"epss_score": 0.00018, "epss_percentile": 0.03889}, "CVE-2023-26245": {"epss_score": 0.00018, "epss_percentile": 0.03889}, "CVE-2023-26246": {"epss_score": 0.0001, "epss_percentile": 0.00841}, "CVE-2023-26248": {"epss_score": 0.0006, "epss_percentile": 0.19207}, "CVE-2023-26249": {"epss_score": 0.00291, "epss_percentile": 0.52174}, "CVE-2023-26253": {"epss_score": 0.00048, "epss_percentile": 0.15039}, "CVE-2023-26255": {"epss_score": 0.93558, "epss_percentile": 0.99817}, "CVE-2023-26256": {"epss_score": 0.92045, "epss_percentile": 0.99688}, "CVE-2023-26257": {"epss_score": 0.00144, "epss_percentile": 0.35252}, "CVE-2023-26258": {"epss_score": 0.73541, "epss_percentile": 0.9876}, "CVE-2023-26260": {"epss_score": 0.00378, "epss_percentile": 0.58797}, "CVE-2023-26261": {"epss_score": 0.00028, "epss_percentile": 0.07312}, "CVE-2023-26262": {"epss_score": 0.10965, "epss_percentile": 0.93178}, "CVE-2023-26263": {"epss_score": 0.00052, "epss_percentile": 0.16382}, "CVE-2023-26264": {"epss_score": 0.00052, "epss_percentile": 0.16382}, "CVE-2023-26265": {"epss_score": 0.00134, "epss_percentile": 0.3391}, "CVE-2023-26266": {"epss_score": 0.00033, "epss_percentile": 0.09361}, "CVE-2023-26267": {"epss_score": 0.00084, "epss_percentile": 0.24912}, "CVE-2023-26268": {"epss_score": 0.00031, "epss_percentile": 0.08576}, "CVE-2023-26269": {"epss_score": 0.0127, "epss_percentile": 0.79045}, "CVE-2023-26270": {"epss_score": 0.00118, "epss_percentile": 0.31515}, "CVE-2023-26271": {"epss_score": 0.00048, "epss_percentile": 0.15174}, "CVE-2023-26272": {"epss_score": 0.00035, "epss_percentile": 0.09985}, "CVE-2023-26273": {"epss_score": 0.0005, "epss_percentile": 0.15785}, "CVE-2023-26274": {"epss_score": 0.00135, "epss_percentile": 0.34016}, "CVE-2023-26276": {"epss_score": 0.00029, "epss_percentile": 0.07763}, "CVE-2023-26277": {"epss_score": 0.00045, "epss_percentile": 0.13792}, "CVE-2023-26278": {"epss_score": 0.00025, "epss_percentile": 0.06105}, "CVE-2023-26279": {"epss_score": 0.00014, "epss_percentile": 0.01972}, "CVE-2023-26280": {"epss_score": 0.00051, "epss_percentile": 0.1613}, "CVE-2023-26281": {"epss_score": 0.00058, "epss_percentile": 0.18523}, "CVE-2023-26282": {"epss_score": 0.00023, "epss_percentile": 0.05625}, "CVE-2023-26283": {"epss_score": 0.00126, "epss_percentile": 0.32678}, "CVE-2023-26284": {"epss_score": 0.00116, "epss_percentile": 0.31049}, "CVE-2023-26285": {"epss_score": 0.00057, "epss_percentile": 0.18224}, "CVE-2023-26286": {"epss_score": 0.00046, "epss_percentile": 0.1429}, "CVE-2023-26288": {"epss_score": 0.0006, "epss_percentile": 0.19081}, "CVE-2023-26289": {"epss_score": 0.00115, "epss_percentile": 0.30986}, "CVE-2023-26290": {"epss_score": 0.00544, "epss_percentile": 0.67133}, "CVE-2023-26291": {"epss_score": 0.00544, "epss_percentile": 0.67133}, "CVE-2023-26292": {"epss_score": 0.00544, "epss_percentile": 0.67133}, "CVE-2023-26293": {"epss_score": 0.00047, "epss_percentile": 0.14832}, "CVE-2023-26294": {"epss_score": 0.00657, "epss_percentile": 0.70473}, "CVE-2023-26295": {"epss_score": 0.02382, "epss_percentile": 0.84568}, "CVE-2023-26296": {"epss_score": 0.025, "epss_percentile": 0.84917}, "CVE-2023-26297": {"epss_score": 0.025, "epss_percentile": 0.84917}, "CVE-2023-26298": {"epss_score": 0.025, "epss_percentile": 0.84917}, "CVE-2023-26299": {"epss_score": 0.00154, "epss_percentile": 0.36663}, "CVE-2023-26300": {"epss_score": 0.00134, "epss_percentile": 0.33832}, "CVE-2023-26301": {"epss_score": 0.0068, "epss_percentile": 0.71031}, "CVE-2023-26302": {"epss_score": 0.00022, "epss_percentile": 0.05133}, "CVE-2023-26303": {"epss_score": 0.00026, "epss_percentile": 0.06613}, "CVE-2023-26309": {"epss_score": 0.01002, "epss_percentile": 0.7651}, "CVE-2023-26310": {"epss_score": 0.00511, "epss_percentile": 0.65835}, "CVE-2023-26311": {"epss_score": 0.01002, "epss_percentile": 0.7651}, "CVE-2023-26314": {"epss_score": 0.00686, "epss_percentile": 0.7116}, "CVE-2023-26315": {"epss_score": 0.67496, "epss_percentile": 0.9851}, "CVE-2023-26316": {"epss_score": 0.00368, "epss_percentile": 0.58198}, "CVE-2023-26317": {"epss_score": 0.00485, "epss_percentile": 0.64723}, "CVE-2023-26318": {"epss_score": 0.0089, "epss_percentile": 0.75027}, "CVE-2023-26319": {"epss_score": 0.00716, "epss_percentile": 0.71864}, "CVE-2023-26320": {"epss_score": 0.01015, "epss_percentile": 0.76666}, "CVE-2023-26321": {"epss_score": 0.00363, "epss_percentile": 0.57844}, "CVE-2023-26322": {"epss_score": 0.00152, "epss_percentile": 0.36496}, "CVE-2023-26323": {"epss_score": 0.00172, "epss_percentile": 0.38975}, "CVE-2023-26324": {"epss_score": 0.00048, "epss_percentile": 0.15202}, "CVE-2023-26325": {"epss_score": 0.00626, "epss_percentile": 0.69611}, "CVE-2023-26326": {"epss_score": 0.42528, "epss_percentile": 0.97336}, "CVE-2023-26327": {"epss_score": 0.00031, "epss_percentile": 0.08694}, "CVE-2023-26328": {"epss_score": 0.00142, "epss_percentile": 0.35019}, "CVE-2023-26329": {"epss_score": 0.00033, "epss_percentile": 0.09334}, "CVE-2023-26330": {"epss_score": 0.00142, "epss_percentile": 0.35019}, "CVE-2023-26331": {"epss_score": 0.00033, "epss_percentile": 0.09334}, "CVE-2023-26332": {"epss_score": 0.00033, "epss_percentile": 0.09334}, "CVE-2023-26333": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-26334": {"epss_score": 0.00142, "epss_percentile": 0.35019}, "CVE-2023-26335": {"epss_score": 0.00176, "epss_percentile": 0.39438}, "CVE-2023-26336": {"epss_score": 0.0024, "epss_percentile": 0.47187}, "CVE-2023-26337": {"epss_score": 0.00166, "epss_percentile": 0.38151}, "CVE-2023-26338": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26339": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-26340": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-26341": {"epss_score": 0.00022, "epss_percentile": 0.05193}, "CVE-2023-26342": {"epss_score": 0.00022, "epss_percentile": 0.05193}, "CVE-2023-26343": {"epss_score": 0.00022, "epss_percentile": 0.05193}, "CVE-2023-26344": {"epss_score": 0.00022, "epss_percentile": 0.05193}, "CVE-2023-26345": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-26346": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-26347": {"epss_score": 0.85696, "epss_percentile": 0.99344}, "CVE-2023-26348": {"epss_score": 0.00023, "epss_percentile": 0.05615}, "CVE-2023-26349": {"epss_score": 0.00027, "epss_percentile": 0.06878}, "CVE-2023-26350": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-26351": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-26352": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-26353": {"epss_score": 0.00068, "epss_percentile": 0.21266}, "CVE-2023-26354": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-26355": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-26356": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-26358": {"epss_score": 0.00162, "epss_percentile": 0.37687}, "CVE-2023-26359": {"epss_score": 0.86789, "epss_percentile": 0.99397}, "CVE-2023-26360": {"epss_score": 0.9433, "epss_percentile": 0.99949}, "CVE-2023-26361": {"epss_score": 0.28979, "epss_percentile": 0.96407}, "CVE-2023-26364": {"epss_score": 0.00168, "epss_percentile": 0.38445}, "CVE-2023-26366": {"epss_score": 0.00324, "epss_percentile": 0.54964}, "CVE-2023-26367": {"epss_score": 0.00331, "epss_percentile": 0.55534}, "CVE-2023-26368": {"epss_score": 0.00113, "epss_percentile": 0.30594}, "CVE-2023-26369": {"epss_score": 0.00563, "epss_percentile": 0.67712}, "CVE-2023-26370": {"epss_score": 0.00052, "epss_percentile": 0.16534}, "CVE-2023-26371": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-26372": {"epss_score": 0.00142, "epss_percentile": 0.35019}, "CVE-2023-26373": {"epss_score": 0.00142, "epss_percentile": 0.35019}, "CVE-2023-26374": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26375": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26376": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26377": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26378": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26379": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26380": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26381": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26382": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26383": {"epss_score": 0.00175, "epss_percentile": 0.39299}, "CVE-2023-26384": {"epss_score": 0.0024, "epss_percentile": 0.47187}, "CVE-2023-26385": {"epss_score": 0.00023, "epss_percentile": 0.05615}, "CVE-2023-26386": {"epss_score": 0.00023, "epss_percentile": 0.05615}, "CVE-2023-26387": {"epss_score": 0.00023, "epss_percentile": 0.05615}, "CVE-2023-26388": {"epss_score": 0.00105, "epss_percentile": 0.2925}, "CVE-2023-26389": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-26390": {"epss_score": 0.00175, "epss_percentile": 0.39299}, "CVE-2023-26391": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-26392": {"epss_score": 0.0024, "epss_percentile": 0.47187}, "CVE-2023-26393": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-26394": {"epss_score": 0.00175, "epss_percentile": 0.39299}, "CVE-2023-26395": {"epss_score": 0.01689, "epss_percentile": 0.8177}, "CVE-2023-26396": {"epss_score": 0.02077, "epss_percentile": 0.83513}, "CVE-2023-26397": {"epss_score": 0.00079, "epss_percentile": 0.23856}, "CVE-2023-26398": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-26400": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26401": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26402": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-26403": {"epss_score": 0.00023, "epss_percentile": 0.05615}, "CVE-2023-26404": {"epss_score": 0.00033, "epss_percentile": 0.09237}, "CVE-2023-26405": {"epss_score": 0.00391, "epss_percentile": 0.59586}, "CVE-2023-26406": {"epss_score": 0.01375, "epss_percentile": 0.79831}, "CVE-2023-26407": {"epss_score": 0.00391, "epss_percentile": 0.59586}, "CVE-2023-26408": {"epss_score": 0.01375, "epss_percentile": 0.79831}, "CVE-2023-26409": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-26410": {"epss_score": 0.0024, "epss_percentile": 0.47187}, "CVE-2023-26411": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2023-26412": {"epss_score": 0.00201, "epss_percentile": 0.42334}, "CVE-2023-26413": {"epss_score": 0.00175, "epss_percentile": 0.39299}, "CVE-2023-26414": {"epss_score": 0.0024, "epss_percentile": 0.47187}, "CVE-2023-26415": {"epss_score": 0.00142, "epss_percentile": 0.35019}, "CVE-2023-26416": {"epss_score": 0.00175, "epss_percentile": 0.39299}, "CVE-2023-26417": {"epss_score": 0.0281, "epss_percentile": 0.85719}, "CVE-2023-26418": {"epss_score": 0.0281, "epss_percentile": 0.85719}, "CVE-2023-26419": {"epss_score": 0.0281, "epss_percentile": 0.85719}, "CVE-2023-26420": {"epss_score": 0.0281, "epss_percentile": 0.85719}, "CVE-2023-26421": {"epss_score": 0.01689, "epss_percentile": 0.8177}, "CVE-2023-26422": {"epss_score": 0.02225, "epss_percentile": 0.84067}, "CVE-2023-26423": {"epss_score": 0.02225, "epss_percentile": 0.84067}, "CVE-2023-26424": {"epss_score": 0.0281, "epss_percentile": 0.85719}, "CVE-2023-26425": {"epss_score": 0.02196, "epss_percentile": 0.83954}, "CVE-2023-26426": {"epss_score": 0.00254, "epss_percentile": 0.485}, "CVE-2023-26427": {"epss_score": 0.00053, "epss_percentile": 0.16726}, "CVE-2023-26428": {"epss_score": 0.00184, "epss_percentile": 0.40369}, "CVE-2023-26429": {"epss_score": 0.00135, "epss_percentile": 0.34051}, "CVE-2023-26430": {"epss_score": 0.00062, "epss_percentile": 0.19556}, "CVE-2023-26431": {"epss_score": 0.00188, "epss_percentile": 0.40881}, "CVE-2023-26432": {"epss_score": 0.00098, "epss_percentile": 0.2769}, "CVE-2023-26433": {"epss_score": 0.00098, "epss_percentile": 0.2769}, "CVE-2023-26434": {"epss_score": 0.00098, "epss_percentile": 0.2769}, "CVE-2023-26435": {"epss_score": 0.00132, "epss_percentile": 0.33594}, "CVE-2023-26436": {"epss_score": 0.0016, "epss_percentile": 0.37471}, "CVE-2023-26437": {"epss_score": 6e-05, "epss_percentile": 0.00296}, "CVE-2023-26438": {"epss_score": 0.00025, "epss_percentile": 0.06278}, "CVE-2023-26439": {"epss_score": 0.00054, "epss_percentile": 0.17165}, "CVE-2023-26440": {"epss_score": 0.00054, "epss_percentile": 0.17165}, "CVE-2023-26441": {"epss_score": 0.00035, "epss_percentile": 0.09901}, "CVE-2023-26442": {"epss_score": 0.00035, "epss_percentile": 0.09816}, "CVE-2023-26443": {"epss_score": 0.00049, "epss_percentile": 0.15568}, "CVE-2023-26445": {"epss_score": 0.00058, "epss_percentile": 0.1838}, "CVE-2023-26446": {"epss_score": 0.00083, "epss_percentile": 0.2463}, "CVE-2023-26447": {"epss_score": 0.00083, "epss_percentile": 0.2463}, "CVE-2023-26448": {"epss_score": 0.00083, "epss_percentile": 0.2463}, "CVE-2023-26449": {"epss_score": 0.00107, "epss_percentile": 0.29644}, "CVE-2023-26450": {"epss_score": 0.00107, "epss_percentile": 0.29644}, "CVE-2023-26451": {"epss_score": 0.00087, "epss_percentile": 0.25486}, "CVE-2023-26452": {"epss_score": 0.00055, "epss_percentile": 0.1742}, "CVE-2023-26453": {"epss_score": 0.00055, "epss_percentile": 0.1742}, "CVE-2023-26454": {"epss_score": 0.00055, "epss_percentile": 0.1742}, "CVE-2023-26455": {"epss_score": 0.00027, "epss_percentile": 0.0689}, "CVE-2023-26456": {"epss_score": 0.00159, "epss_percentile": 0.37409}, "CVE-2023-26457": {"epss_score": 0.00387, "epss_percentile": 0.59329}, "CVE-2023-26458": {"epss_score": 0.002, "epss_percentile": 0.42232}, "CVE-2023-26459": {"epss_score": 0.00133, "epss_percentile": 0.33648}, "CVE-2023-26460": {"epss_score": 0.00257, "epss_percentile": 0.48851}, "CVE-2023-26461": {"epss_score": 0.00157, "epss_percentile": 0.37066}, "CVE-2023-26462": {"epss_score": 0.00733, "epss_percentile": 0.72204}, "CVE-2023-26463": {"epss_score": 0.12161, "epss_percentile": 0.93586}, "CVE-2023-26464": {"epss_score": 0.00114, "epss_percentile": 0.3082}, "CVE-2023-26465": {"epss_score": 0.00487, "epss_percentile": 0.64803}, "CVE-2023-26466": {"epss_score": 0.00065, "epss_percentile": 0.20447}, "CVE-2023-26467": {"epss_score": 0.00164, "epss_percentile": 0.38001}, "CVE-2023-26468": {"epss_score": 0.00125, "epss_percentile": 0.32587}, "CVE-2023-26469": {"epss_score": 0.93246, "epss_percentile": 0.99788}, "CVE-2023-26470": {"epss_score": 0.00309, "epss_percentile": 0.53647}, "CVE-2023-26471": {"epss_score": 0.01446, "epss_percentile": 0.80326}, "CVE-2023-26472": {"epss_score": 0.01181, "epss_percentile": 0.78309}, "CVE-2023-26473": {"epss_score": 0.00182, "epss_percentile": 0.40183}, "CVE-2023-26474": {"epss_score": 0.00546, "epss_percentile": 0.67209}, "CVE-2023-26475": {"epss_score": 0.23644, "epss_percentile": 0.95798}, "CVE-2023-26476": {"epss_score": 0.00365, "epss_percentile": 0.58005}, "CVE-2023-26477": {"epss_score": 0.45936, "epss_percentile": 0.9751}, "CVE-2023-26478": {"epss_score": 0.0039, "epss_percentile": 0.59518}, "CVE-2023-26479": {"epss_score": 0.00229, "epss_percentile": 0.45646}, "CVE-2023-26480": {"epss_score": 0.01001, "epss_percentile": 0.76497}, "CVE-2023-26481": {"epss_score": 0.00056, "epss_percentile": 0.17919}, "CVE-2023-26482": {"epss_score": 0.66252, "epss_percentile": 0.98456}, "CVE-2023-26483": {"epss_score": 0.00256, "epss_percentile": 0.48767}, "CVE-2023-26484": {"epss_score": 0.00311, "epss_percentile": 0.53843}, "CVE-2023-26485": {"epss_score": 0.00109, "epss_percentile": 0.30059}, "CVE-2023-26486": {"epss_score": 0.00195, "epss_percentile": 0.4168}, "CVE-2023-26487": {"epss_score": 0.00185, "epss_percentile": 0.40581}, "CVE-2023-26488": {"epss_score": 0.001, "epss_percentile": 0.28479}, "CVE-2023-26489": {"epss_score": 0.02286, "epss_percentile": 0.84269}, "CVE-2023-26490": {"epss_score": 0.00574, "epss_percentile": 0.68087}, "CVE-2023-26491": {"epss_score": 0.0042, "epss_percentile": 0.61451}, "CVE-2023-26492": {"epss_score": 0.00057, "epss_percentile": 0.18135}, "CVE-2023-26493": {"epss_score": 0.01159, "epss_percentile": 0.78128}, "CVE-2023-26494": {"epss_score": 0.00212, "epss_percentile": 0.43782}, "CVE-2023-26495": {"epss_score": 0.00063, "epss_percentile": 0.19881}, "CVE-2023-26496": {"epss_score": 0.20817, "epss_percentile": 0.95418}, "CVE-2023-26497": {"epss_score": 0.06088, "epss_percentile": 0.90467}, "CVE-2023-26498": {"epss_score": 0.20817, "epss_percentile": 0.95418}, "CVE-2023-26509": {"epss_score": 0.00218, "epss_percentile": 0.4442}, "CVE-2023-26510": {"epss_score": 0.00107, "epss_percentile": 0.29611}, "CVE-2023-26511": {"epss_score": 0.01134, "epss_percentile": 0.77895}, "CVE-2023-26512": {"epss_score": 0.00073, "epss_percentile": 0.22524}, "CVE-2023-26513": {"epss_score": 0.0067, "epss_percentile": 0.7077}, "CVE-2023-26514": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-26515": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26516": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-26517": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26518": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-26519": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26520": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-26521": {"epss_score": 0.00236, "epss_percentile": 0.46391}, "CVE-2023-26522": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-26523": {"epss_score": 0.00236, "epss_percentile": 0.46391}, "CVE-2023-26524": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-26525": {"epss_score": 0.00131, "epss_percentile": 0.33428}, "CVE-2023-26526": {"epss_score": 0.00614, "epss_percentile": 0.69283}, "CVE-2023-26527": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26528": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26529": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-26530": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-26531": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-26532": {"epss_score": 0.00123, "epss_percentile": 0.32321}, "CVE-2023-26533": {"epss_score": 0.00679, "epss_percentile": 0.71007}, "CVE-2023-26534": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26535": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-26536": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-26537": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26538": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26539": {"epss_score": 0.00066, "epss_percentile": 0.20954}, "CVE-2023-26540": {"epss_score": 0.0061, "epss_percentile": 0.69148}, "CVE-2023-26541": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-26542": {"epss_score": 0.00053, "epss_percentile": 0.16989}, "CVE-2023-26543": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-26544": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2023-26545": {"epss_score": 0.00013, "epss_percentile": 0.01651}, "CVE-2023-26546": {"epss_score": 0.0635, "epss_percentile": 0.90691}, "CVE-2023-26547": {"epss_score": 0.00046, "epss_percentile": 0.14277}, "CVE-2023-26548": {"epss_score": 0.00141, "epss_percentile": 0.34826}, "CVE-2023-26549": {"epss_score": 0.00118, "epss_percentile": 0.31394}, "CVE-2023-26550": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-26551": {"epss_score": 0.00207, "epss_percentile": 0.43085}, "CVE-2023-26552": {"epss_score": 0.00166, "epss_percentile": 0.38229}, "CVE-2023-26553": {"epss_score": 0.00402, "epss_percentile": 0.60311}, "CVE-2023-26554": {"epss_score": 0.00207, "epss_percentile": 0.43085}, "CVE-2023-26555": {"epss_score": 0.00557, "epss_percentile": 0.67557}, "CVE-2023-26556": {"epss_score": 0.00364, "epss_percentile": 0.57958}, "CVE-2023-26557": {"epss_score": 0.00115, "epss_percentile": 0.30952}, "CVE-2023-26559": {"epss_score": 0.00882, "epss_percentile": 0.74899}, "CVE-2023-26560": {"epss_score": 0.00261, "epss_percentile": 0.49264}, "CVE-2023-26562": {"epss_score": 0.00134, "epss_percentile": 0.33909}, "CVE-2023-26563": {"epss_score": 0.00974, "epss_percentile": 0.76174}, "CVE-2023-26564": {"epss_score": 0.0028, "epss_percentile": 0.51101}, "CVE-2023-26566": {"epss_score": 0.00589, "epss_percentile": 0.68515}, "CVE-2023-26567": {"epss_score": 0.00083, "epss_percentile": 0.24712}, "CVE-2023-26568": {"epss_score": 0.00153, "epss_percentile": 0.3664}, "CVE-2023-26569": {"epss_score": 0.00165, "epss_percentile": 0.3805}, "CVE-2023-26570": {"epss_score": 0.00307, "epss_percentile": 0.53562}, "CVE-2023-26571": {"epss_score": 0.00237, "epss_percentile": 0.46728}, "CVE-2023-26572": {"epss_score": 0.00153, "epss_percentile": 0.3664}, "CVE-2023-26573": {"epss_score": 0.00181, "epss_percentile": 0.40074}, "CVE-2023-26574": {"epss_score": 0.00307, "epss_percentile": 0.53562}, "CVE-2023-26575": {"epss_score": 0.00072, "epss_percentile": 0.22252}, "CVE-2023-26576": {"epss_score": 0.00307, "epss_percentile": 0.53562}, "CVE-2023-26577": {"epss_score": 0.00237, "epss_percentile": 0.46709}, "CVE-2023-26578": {"epss_score": 0.00328, "epss_percentile": 0.55192}, "CVE-2023-26579": {"epss_score": 0.00276, "epss_percentile": 0.50702}, "CVE-2023-26580": {"epss_score": 0.00256, "epss_percentile": 0.48742}, "CVE-2023-26581": {"epss_score": 0.00153, "epss_percentile": 0.3664}, "CVE-2023-26582": {"epss_score": 0.00153, "epss_percentile": 0.3664}, "CVE-2023-26583": {"epss_score": 0.00153, "epss_percentile": 0.3664}, "CVE-2023-26584": {"epss_score": 0.00165, "epss_percentile": 0.3805}, "CVE-2023-26585": {"epss_score": 0.00059, "epss_percentile": 0.18657}, "CVE-2023-26586": {"epss_score": 0.00084, "epss_percentile": 0.24971}, "CVE-2023-26587": {"epss_score": 0.00059, "epss_percentile": 0.18778}, "CVE-2023-26588": {"epss_score": 0.00191, "epss_percentile": 0.41163}, "CVE-2023-26589": {"epss_score": 0.00056, "epss_percentile": 0.17791}, "CVE-2023-26590": {"epss_score": 0.00027, "epss_percentile": 0.06942}, "CVE-2023-26591": {"epss_score": 0.00101, "epss_percentile": 0.28704}, "CVE-2023-26592": {"epss_score": 0.00074, "epss_percentile": 0.22824}, "CVE-2023-26593": {"epss_score": 0.00039, "epss_percentile": 0.11629}, "CVE-2023-26595": {"epss_score": 0.00437, "epss_percentile": 0.62495}, "CVE-2023-26596": {"epss_score": 0.00041, "epss_percentile": 0.12252}, "CVE-2023-26597": {"epss_score": 0.00052, "epss_percentile": 0.16547}, "CVE-2023-26599": {"epss_score": 0.00368, "epss_percentile": 0.58171}, "CVE-2023-26600": {"epss_score": 0.00154, "epss_percentile": 0.36693}, "CVE-2023-26601": {"epss_score": 0.04943, "epss_percentile": 0.89311}, "CVE-2023-26602": {"epss_score": 0.75598, "epss_percentile": 0.98857}, "CVE-2023-26603": {"epss_score": 0.00043, "epss_percentile": 0.13271}, "CVE-2023-26604": {"epss_score": 0.05009, "epss_percentile": 0.89388}, "CVE-2023-26605": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2023-26606": {"epss_score": 0.00014, "epss_percentile": 0.01964}, "CVE-2023-26607": {"epss_score": 0.00046, "epss_percentile": 0.14425}, "CVE-2023-26608": {"epss_score": 0.00099, "epss_percentile": 0.28337}, "CVE-2023-26609": {"epss_score": 0.37236, "epss_percentile": 0.97029}, "CVE-2023-26612": {"epss_score": 0.02078, "epss_percentile": 0.8352}, "CVE-2023-26613": {"epss_score": 0.68946, "epss_percentile": 0.98569}, "CVE-2023-26615": {"epss_score": 0.00084, "epss_percentile": 0.24852}, "CVE-2023-26616": {"epss_score": 0.02078, "epss_percentile": 0.8352}, "CVE-2023-26686": {"epss_score": 0.00501, "epss_percentile": 0.65349}, "CVE-2023-26687": {"epss_score": 0.00692, "epss_percentile": 0.71306}, "CVE-2023-26688": {"epss_score": 0.00046, "epss_percentile": 0.14319}, "CVE-2023-26689": {"epss_score": 0.00141, "epss_percentile": 0.34844}, "CVE-2023-26690": {"epss_score": 0.00976, "epss_percentile": 0.76209}, "CVE-2023-26691": {"epss_score": 0.00571, "epss_percentile": 0.6798}, "CVE-2023-26692": {"epss_score": 0.0315, "epss_percentile": 0.86505}, "CVE-2023-26733": {"epss_score": 0.00087, "epss_percentile": 0.25464}, "CVE-2023-26735": {"epss_score": 0.00202, "epss_percentile": 0.42469}, "CVE-2023-26750": {"epss_score": 0.0913, "epss_percentile": 0.92414}, "CVE-2023-26756": {"epss_score": 0.0019, "epss_percentile": 0.41133}, "CVE-2023-26758": {"epss_score": 0.00148, "epss_percentile": 0.35857}, "CVE-2023-26759": {"epss_score": 0.01101, "epss_percentile": 0.77576}, "CVE-2023-26760": {"epss_score": 0.00058, "epss_percentile": 0.18355}, "CVE-2023-26762": {"epss_score": 0.00131, "epss_percentile": 0.33445}, "CVE-2023-26767": {"epss_score": 0.00282, "epss_percentile": 0.51263}, "CVE-2023-26768": {"epss_score": 0.00293, "epss_percentile": 0.52331}, "CVE-2023-26769": {"epss_score": 0.00325, "epss_percentile": 0.55002}, "CVE-2023-26770": {"epss_score": 0.00209, "epss_percentile": 0.43414}, "CVE-2023-26771": {"epss_score": 0.00124, "epss_percentile": 0.32354}, "CVE-2023-26773": {"epss_score": 0.00092, "epss_percentile": 0.26582}, "CVE-2023-26774": {"epss_score": 0.0016, "epss_percentile": 0.37442}, "CVE-2023-26775": {"epss_score": 0.08505, "epss_percentile": 0.92087}, "CVE-2023-26776": {"epss_score": 0.01551, "epss_percentile": 0.80991}, "CVE-2023-26777": {"epss_score": 0.00148, "epss_percentile": 0.35848}, "CVE-2023-26779": {"epss_score": 0.01337, "epss_percentile": 0.79559}, "CVE-2023-26780": {"epss_score": 0.00077, "epss_percentile": 0.23546}, "CVE-2023-26781": {"epss_score": 0.00269, "epss_percentile": 0.50121}, "CVE-2023-26782": {"epss_score": 0.00242, "epss_percentile": 0.47334}, "CVE-2023-26784": {"epss_score": 0.0014, "epss_percentile": 0.34712}, "CVE-2023-26785": {"epss_score": 0.49644, "epss_percentile": 0.97698}, "CVE-2023-26788": {"epss_score": 0.00494, "epss_percentile": 0.65067}, "CVE-2023-26789": {"epss_score": 0.00131, "epss_percentile": 0.33442}, "CVE-2023-26793": {"epss_score": 0.01181, "epss_percentile": 0.78308}, "CVE-2023-26800": {"epss_score": 0.00185, "epss_percentile": 0.40465}, "CVE-2023-26801": {"epss_score": 0.47105, "epss_percentile": 0.97569}, "CVE-2023-26802": {"epss_score": 0.84594, "epss_percentile": 0.99296}, "CVE-2023-26805": {"epss_score": 0.00151, "epss_percentile": 0.36314}, "CVE-2023-26806": {"epss_score": 0.00151, "epss_percentile": 0.36314}, "CVE-2023-26813": {"epss_score": 0.0025, "epss_percentile": 0.48138}, "CVE-2023-26817": {"epss_score": 0.01807, "epss_percentile": 0.82354}, "CVE-2023-26818": {"epss_score": 0.03181, "epss_percentile": 0.86581}, "CVE-2023-26819": {"epss_score": 0.00037, "epss_percentile": 0.10634}, "CVE-2023-26820": {"epss_score": 0.00129, "epss_percentile": 0.33129}, "CVE-2023-26822": {"epss_score": 0.06409, "epss_percentile": 0.90739}, "CVE-2023-26829": {"epss_score": 0.00294, "epss_percentile": 0.52406}, "CVE-2023-26830": {"epss_score": 0.00207, "epss_percentile": 0.43124}, "CVE-2023-26839": {"epss_score": 0.0013, "epss_percentile": 0.33312}, "CVE-2023-26840": {"epss_score": 0.00051, "epss_percentile": 0.163}, "CVE-2023-26841": {"epss_score": 0.00357, "epss_percentile": 0.57463}, "CVE-2023-26842": {"epss_score": 0.17468, "epss_percentile": 0.94854}, "CVE-2023-26843": {"epss_score": 0.12574, "epss_percentile": 0.93719}, "CVE-2023-26845": {"epss_score": 0.00064, "epss_percentile": 0.20364}, "CVE-2023-26846": {"epss_score": 0.00105, "epss_percentile": 0.29369}, "CVE-2023-26847": {"epss_score": 0.00566, "epss_percentile": 0.67808}, "CVE-2023-26848": {"epss_score": 0.01389, "epss_percentile": 0.79927}, "CVE-2023-26852": {"epss_score": 0.06846, "epss_percentile": 0.91065}, "CVE-2023-26855": {"epss_score": 0.00225, "epss_percentile": 0.45084}, "CVE-2023-26856": {"epss_score": 0.00086, "epss_percentile": 0.25248}, "CVE-2023-26857": {"epss_score": 0.00117, "epss_percentile": 0.31294}, "CVE-2023-26858": {"epss_score": 0.0027, "epss_percentile": 0.50208}, "CVE-2023-26859": {"epss_score": 0.00379, "epss_percentile": 0.5889}, "CVE-2023-26860": {"epss_score": 0.00248, "epss_percentile": 0.47928}, "CVE-2023-26861": {"epss_score": 0.00264, "epss_percentile": 0.49724}, "CVE-2023-26864": {"epss_score": 0.00243, "epss_percentile": 0.47453}, "CVE-2023-26865": {"epss_score": 0.0038, "epss_percentile": 0.5896}, "CVE-2023-26866": {"epss_score": 0.05594, "epss_percentile": 0.90032}, "CVE-2023-26876": {"epss_score": 0.47542, "epss_percentile": 0.97591}, "CVE-2023-26877": {"epss_score": 0.00148, "epss_percentile": 0.35832}, "CVE-2023-26905": {"epss_score": 0.00082, "epss_percentile": 0.24579}, "CVE-2023-26911": {"epss_score": 0.00024, "epss_percentile": 0.05674}, "CVE-2023-26912": {"epss_score": 0.00312, "epss_percentile": 0.53954}, "CVE-2023-26913": {"epss_score": 0.00123, "epss_percentile": 0.32203}, "CVE-2023-26916": {"epss_score": 0.00058, "epss_percentile": 0.18426}, "CVE-2023-26917": {"epss_score": 0.00076, "epss_percentile": 0.23127}, "CVE-2023-26918": {"epss_score": 0.02407, "epss_percentile": 0.84655}, "CVE-2023-26919": {"epss_score": 0.00179, "epss_percentile": 0.39844}, "CVE-2023-26920": {"epss_score": 0.00226, "epss_percentile": 0.45278}, "CVE-2023-26921": {"epss_score": 0.0133, "epss_percentile": 0.79513}, "CVE-2023-26922": {"epss_score": 0.00863, "epss_percentile": 0.74589}, "CVE-2023-26923": {"epss_score": 0.00057, "epss_percentile": 0.18149}, "CVE-2023-26924": {"epss_score": 0.00033, "epss_percentile": 0.09125}, "CVE-2023-26925": {"epss_score": 0.0097, "epss_percentile": 0.76115}, "CVE-2023-26930": {"epss_score": 0.0003, "epss_percentile": 0.08221}, "CVE-2023-26941": {"epss_score": 0.00038, "epss_percentile": 0.11393}, "CVE-2023-26942": {"epss_score": 0.00038, "epss_percentile": 0.11393}, "CVE-2023-26943": {"epss_score": 0.00038, "epss_percentile": 0.11393}, "CVE-2023-26948": {"epss_score": 0.00085, "epss_percentile": 0.25035}, "CVE-2023-26949": {"epss_score": 0.00152, "epss_percentile": 0.36455}, "CVE-2023-26950": {"epss_score": 0.00099, "epss_percentile": 0.28337}, "CVE-2023-26951": {"epss_score": 0.00105, "epss_percentile": 0.29369}, "CVE-2023-26952": {"epss_score": 0.00099, "epss_percentile": 0.28337}, "CVE-2023-26953": {"epss_score": 0.00087, "epss_percentile": 0.25538}, "CVE-2023-26954": {"epss_score": 0.00099, "epss_percentile": 0.28337}, "CVE-2023-26955": {"epss_score": 0.00099, "epss_percentile": 0.28337}, "CVE-2023-26956": {"epss_score": 0.00085, "epss_percentile": 0.25035}, "CVE-2023-26957": {"epss_score": 0.00075, "epss_percentile": 0.23003}, "CVE-2023-26958": {"epss_score": 0.00086, "epss_percentile": 0.25367}, "CVE-2023-26959": {"epss_score": 0.0009, "epss_percentile": 0.26024}, "CVE-2023-26961": {"epss_score": 0.0033, "epss_percentile": 0.55436}, "CVE-2023-26964": {"epss_score": 0.00356, "epss_percentile": 0.57334}, "CVE-2023-26965": {"epss_score": 9e-05, "epss_percentile": 0.00618}, "CVE-2023-26966": {"epss_score": 0.00028, "epss_percentile": 0.0754}, "CVE-2023-26968": {"epss_score": 0.00217, "epss_percentile": 0.44283}, "CVE-2023-26969": {"epss_score": 0.00274, "epss_percentile": 0.50543}, "CVE-2023-26974": {"epss_score": 0.00046, "epss_percentile": 0.14413}, "CVE-2023-26976": {"epss_score": 0.47389, "epss_percentile": 0.97585}, "CVE-2023-26978": {"epss_score": 0.01509, "epss_percentile": 0.80764}, "CVE-2023-26979": {"epss_score": 0.0003, "epss_percentile": 0.08282}, "CVE-2023-26980": {"epss_score": 0.00013, "epss_percentile": 0.01431}, "CVE-2023-26982": {"epss_score": 0.01209, "epss_percentile": 0.78538}, "CVE-2023-26984": {"epss_score": 0.0104, "epss_percentile": 0.7696}, "CVE-2023-26986": {"epss_score": 0.00432, "epss_percentile": 0.62128}, "CVE-2023-26987": {"epss_score": 0.00072, "epss_percentile": 0.22439}, "CVE-2023-26991": {"epss_score": 0.00036, "epss_percentile": 0.10391}, "CVE-2023-26998": {"epss_score": 0.00671, "epss_percentile": 0.70803}, "CVE-2023-26999": {"epss_score": 0.01179, "epss_percentile": 0.78288}, "CVE-2023-27000": {"epss_score": 0.00772, "epss_percentile": 0.73035}, "CVE-2023-27001": {"epss_score": 0.00112, "epss_percentile": 0.30499}, "CVE-2023-27008": {"epss_score": 0.25117, "epss_percentile": 0.95987}, "CVE-2023-27010": {"epss_score": 0.00129, "epss_percentile": 0.33123}, "CVE-2023-27012": {"epss_score": 0.00371, "epss_percentile": 0.58363}, "CVE-2023-27013": {"epss_score": 0.00165, "epss_percentile": 0.38048}, "CVE-2023-27014": {"epss_score": 0.00371, "epss_percentile": 0.58363}, "CVE-2023-27015": {"epss_score": 0.00371, "epss_percentile": 0.58363}, "CVE-2023-27016": {"epss_score": 0.00445, "epss_percentile": 0.62854}, "CVE-2023-27017": {"epss_score": 0.00165, "epss_percentile": 0.38048}, "CVE-2023-27018": {"epss_score": 0.00165, "epss_percentile": 0.38048}, "CVE-2023-27019": {"epss_score": 0.00165, "epss_percentile": 0.38048}, "CVE-2023-27020": {"epss_score": 0.00165, "epss_percentile": 0.38048}, "CVE-2023-27021": {"epss_score": 0.00151, "epss_percentile": 0.36353}, "CVE-2023-27025": {"epss_score": 0.00109, "epss_percentile": 0.2992}, "CVE-2023-27032": {"epss_score": 0.4769, "epss_percentile": 0.97597}, "CVE-2023-27033": {"epss_score": 0.00123, "epss_percentile": 0.32214}, "CVE-2023-27034": {"epss_score": 0.89821, "epss_percentile": 0.99544}, "CVE-2023-27035": {"epss_score": 0.19258, "epss_percentile": 0.95156}, "CVE-2023-27037": {"epss_score": 0.04073, "epss_percentile": 0.88207}, "CVE-2023-27040": {"epss_score": 0.02258, "epss_percentile": 0.84178}, "CVE-2023-27041": {"epss_score": 0.00341, "epss_percentile": 0.56291}, "CVE-2023-27042": {"epss_score": 0.00151, "epss_percentile": 0.36323}, "CVE-2023-27043": {"epss_score": 0.00164, "epss_percentile": 0.37997}, "CVE-2023-27052": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-27054": {"epss_score": 0.00417, "epss_percentile": 0.61239}, "CVE-2023-27055": {"epss_score": 0.00117, "epss_percentile": 0.31337}, "CVE-2023-27059": {"epss_score": 0.00424, "epss_percentile": 0.61663}, "CVE-2023-27060": {"epss_score": 0.01662, "epss_percentile": 0.81635}, "CVE-2023-27061": {"epss_score": 0.00615, "epss_percentile": 0.69297}, "CVE-2023-27062": {"epss_score": 0.00251, "epss_percentile": 0.48319}, "CVE-2023-27063": {"epss_score": 0.00782, "epss_percentile": 0.73205}, "CVE-2023-27064": {"epss_score": 0.00251, "epss_percentile": 0.48319}, "CVE-2023-27065": {"epss_score": 0.00251, "epss_percentile": 0.48319}, "CVE-2023-27066": {"epss_score": 0.00384, "epss_percentile": 0.59153}, "CVE-2023-27067": {"epss_score": 0.00458, "epss_percentile": 0.63442}, "CVE-2023-27068": {"epss_score": 0.012, "epss_percentile": 0.78467}, "CVE-2023-27069": {"epss_score": 0.00115, "epss_percentile": 0.3096}, "CVE-2023-27070": {"epss_score": 0.00115, "epss_percentile": 0.3096}, "CVE-2023-27073": {"epss_score": 0.00075, "epss_percentile": 0.22895}, "CVE-2023-27074": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-27075": {"epss_score": 0.00085, "epss_percentile": 0.25145}, "CVE-2023-27076": {"epss_score": 0.12247, "epss_percentile": 0.93611}, "CVE-2023-27077": {"epss_score": 0.00542, "epss_percentile": 0.67087}, "CVE-2023-27078": {"epss_score": 0.02069, "epss_percentile": 0.83468}, "CVE-2023-27079": {"epss_score": 0.01697, "epss_percentile": 0.81815}, "CVE-2023-27082": {"epss_score": 0.0004, "epss_percentile": 0.12178}, "CVE-2023-27083": {"epss_score": 0.00306, "epss_percentile": 0.53412}, "CVE-2023-27084": {"epss_score": 0.00026, "epss_percentile": 0.06485}, "CVE-2023-27087": {"epss_score": 0.00085, "epss_percentile": 0.25096}, "CVE-2023-27088": {"epss_score": 0.00089, "epss_percentile": 0.25971}, "CVE-2023-27089": {"epss_score": 0.0011, "epss_percentile": 0.30117}, "CVE-2023-27090": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-27091": {"epss_score": 0.00072, "epss_percentile": 0.22366}, "CVE-2023-27092": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-27093": {"epss_score": 0.00106, "epss_percentile": 0.29466}, "CVE-2023-27094": {"epss_score": 0.00248, "epss_percentile": 0.47964}, "CVE-2023-27095": {"epss_score": 0.00068, "epss_percentile": 0.21241}, "CVE-2023-27096": {"epss_score": 0.00146, "epss_percentile": 0.35642}, "CVE-2023-27098": {"epss_score": 0.00047, "epss_percentile": 0.14612}, "CVE-2023-27100": {"epss_score": 0.02577, "epss_percentile": 0.85143}, "CVE-2023-27102": {"epss_score": 0.002, "epss_percentile": 0.42228}, "CVE-2023-27103": {"epss_score": 0.00547, "epss_percentile": 0.67262}, "CVE-2023-27105": {"epss_score": 0.004, "epss_percentile": 0.60173}, "CVE-2023-27107": {"epss_score": 0.00504, "epss_percentile": 0.65524}, "CVE-2023-27108": {"epss_score": 0.00084, "epss_percentile": 0.2493}, "CVE-2023-27112": {"epss_score": 0.00139, "epss_percentile": 0.3461}, "CVE-2023-27113": {"epss_score": 0.00139, "epss_percentile": 0.3461}, "CVE-2023-27114": {"epss_score": 0.00075, "epss_percentile": 0.22885}, "CVE-2023-27115": {"epss_score": 0.00052, "epss_percentile": 0.16646}, "CVE-2023-27116": {"epss_score": 0.00024, "epss_percentile": 0.05822}, "CVE-2023-27117": {"epss_score": 0.00075, "epss_percentile": 0.22956}, "CVE-2023-27119": {"epss_score": 0.00037, "epss_percentile": 0.10987}, "CVE-2023-27121": {"epss_score": 0.04765, "epss_percentile": 0.89122}, "CVE-2023-27126": {"epss_score": 0.00044, "epss_percentile": 0.13513}, "CVE-2023-27130": {"epss_score": 0.00222, "epss_percentile": 0.44792}, "CVE-2023-27131": {"epss_score": 0.00318, "epss_percentile": 0.54444}, "CVE-2023-27132": {"epss_score": 0.00121, "epss_percentile": 0.31997}, "CVE-2023-27133": {"epss_score": 0.00093, "epss_percentile": 0.26744}, "CVE-2023-27135": {"epss_score": 0.01961, "epss_percentile": 0.83061}, "CVE-2023-27148": {"epss_score": 0.00063, "epss_percentile": 0.1988}, "CVE-2023-27149": {"epss_score": 0.00063, "epss_percentile": 0.1988}, "CVE-2023-27150": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-27151": {"epss_score": 0.00378, "epss_percentile": 0.58834}, "CVE-2023-27152": {"epss_score": 0.00147, "epss_percentile": 0.35666}, "CVE-2023-27159": {"epss_score": 0.84688, "epss_percentile": 0.993}, "CVE-2023-27160": {"epss_score": 0.00308, "epss_percentile": 0.53577}, "CVE-2023-27161": {"epss_score": 0.00701, "epss_percentile": 0.71492}, "CVE-2023-27162": {"epss_score": 0.00123, "epss_percentile": 0.32267}, "CVE-2023-27163": {"epss_score": 0.92878, "epss_percentile": 0.99757}, "CVE-2023-27164": {"epss_score": 0.00193, "epss_percentile": 0.41446}, "CVE-2023-27167": {"epss_score": 0.00413, "epss_percentile": 0.61008}, "CVE-2023-27168": {"epss_score": 0.00237, "epss_percentile": 0.46686}, "CVE-2023-27169": {"epss_score": 0.00157, "epss_percentile": 0.37108}, "CVE-2023-27170": {"epss_score": 0.00569, "epss_percentile": 0.67918}, "CVE-2023-27172": {"epss_score": 0.00086, "epss_percentile": 0.25309}, "CVE-2023-27178": {"epss_score": 0.00354, "epss_percentile": 0.57234}, "CVE-2023-27179": {"epss_score": 0.86446, "epss_percentile": 0.99383}, "CVE-2023-27180": {"epss_score": 0.00301, "epss_percentile": 0.53076}, "CVE-2023-27191": {"epss_score": 0.00095, "epss_percentile": 0.27168}, "CVE-2023-27192": {"epss_score": 0.00139, "epss_percentile": 0.34557}, "CVE-2023-27193": {"epss_score": 0.0021, "epss_percentile": 0.43489}, "CVE-2023-27195": {"epss_score": 0.00293, "epss_percentile": 0.52351}, "CVE-2023-27197": {"epss_score": 0.00026, "epss_percentile": 0.06579}, "CVE-2023-27198": {"epss_score": 0.00081, "epss_percentile": 0.24361}, "CVE-2023-27199": {"epss_score": 6e-05, "epss_percentile": 0.00288}, "CVE-2023-27202": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-27203": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-27204": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-27205": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-27206": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-27207": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-27208": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-27210": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-27211": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-27212": {"epss_score": 0.00114, "epss_percentile": 0.30797}, "CVE-2023-27213": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-27214": {"epss_score": 0.00083, "epss_percentile": 0.24781}, "CVE-2023-27216": {"epss_score": 0.31133, "epss_percentile": 0.96596}, "CVE-2023-27217": {"epss_score": 0.00248, "epss_percentile": 0.47979}, "CVE-2023-27224": {"epss_score": 0.0022, "epss_percentile": 0.44591}, "CVE-2023-27225": {"epss_score": 0.0036, "epss_percentile": 0.5768}, "CVE-2023-27229": {"epss_score": 0.06522, "epss_percentile": 0.9082}, "CVE-2023-27231": {"epss_score": 0.03129, "epss_percentile": 0.86462}, "CVE-2023-27232": {"epss_score": 0.01509, "epss_percentile": 0.80764}, "CVE-2023-27233": {"epss_score": 0.0031, "epss_percentile": 0.53732}, "CVE-2023-27234": {"epss_score": 0.00132, "epss_percentile": 0.33582}, "CVE-2023-27235": {"epss_score": 0.00267, "epss_percentile": 0.49974}, "CVE-2023-27237": {"epss_score": 0.00143, "epss_percentile": 0.35186}, "CVE-2023-27238": {"epss_score": 0.00337, "epss_percentile": 0.56044}, "CVE-2023-27239": {"epss_score": 0.00151, "epss_percentile": 0.36314}, "CVE-2023-27240": {"epss_score": 0.03282, "epss_percentile": 0.86817}, "CVE-2023-27241": {"epss_score": 0.00529, "epss_percentile": 0.66581}, "CVE-2023-27242": {"epss_score": 0.00105, "epss_percentile": 0.29369}, "CVE-2023-27243": {"epss_score": 0.001, "epss_percentile": 0.28494}, "CVE-2023-27245": {"epss_score": 0.00544, "epss_percentile": 0.67133}, "CVE-2023-27246": {"epss_score": 0.00153, "epss_percentile": 0.36628}, "CVE-2023-27247": {"epss_score": 0.0002, "epss_percentile": 0.04592}, "CVE-2023-27249": {"epss_score": 0.00038, "epss_percentile": 0.11368}, "CVE-2023-27250": {"epss_score": 0.00341, "epss_percentile": 0.56291}, "CVE-2023-27253": {"epss_score": 0.7918, "epss_percentile": 0.99022}, "CVE-2023-27254": {"epss_score": 0.00153, "epss_percentile": 0.3664}, "CVE-2023-27255": {"epss_score": 0.00153, "epss_percentile": 0.3664}, "CVE-2023-27256": {"epss_score": 0.00382, "epss_percentile": 0.59043}, "CVE-2023-27257": {"epss_score": 0.00357, "epss_percentile": 0.57401}, "CVE-2023-27258": {"epss_score": 0.00357, "epss_percentile": 0.57401}, "CVE-2023-27259": {"epss_score": 0.00357, "epss_percentile": 0.57401}, "CVE-2023-27260": {"epss_score": 0.00153, "epss_percentile": 0.3664}, "CVE-2023-27261": {"epss_score": 0.00195, "epss_percentile": 0.41669}, "CVE-2023-27262": {"epss_score": 0.00153, "epss_percentile": 0.3664}, "CVE-2023-27263": {"epss_score": 0.00159, "epss_percentile": 0.37364}, "CVE-2023-27264": {"epss_score": 0.00053, "epss_percentile": 0.1704}, "CVE-2023-27265": {"epss_score": 0.00224, "epss_percentile": 0.45063}, "CVE-2023-27266": {"epss_score": 0.00224, "epss_percentile": 0.45063}, "CVE-2023-27267": {"epss_score": 0.07933, "epss_percentile": 0.91773}, "CVE-2023-27268": {"epss_score": 0.00345, "epss_percentile": 0.56561}, "CVE-2023-27269": {"epss_score": 0.00404, "epss_percentile": 0.60449}, "CVE-2023-27270": {"epss_score": 0.00258, "epss_percentile": 0.48957}, "CVE-2023-27271": {"epss_score": 0.00189, "epss_percentile": 0.40995}, "CVE-2023-27272": {"epss_score": 0.00057, "epss_percentile": 0.1813}, "CVE-2023-27279": {"epss_score": 0.00132, "epss_percentile": 0.33546}, "CVE-2023-27283": {"epss_score": 0.00052, "epss_percentile": 0.16564}, "CVE-2023-27284": {"epss_score": 0.00109, "epss_percentile": 0.29997}, "CVE-2023-27285": {"epss_score": 0.00019, "epss_percentile": 0.04328}, "CVE-2023-27286": {"epss_score": 0.00068, "epss_percentile": 0.2132}, "CVE-2023-27290": {"epss_score": 0.05164, "epss_percentile": 0.89562}, "CVE-2023-27291": {"epss_score": 0.00031, "epss_percentile": 0.08516}, "CVE-2023-27292": {"epss_score": 0.07744, "epss_percentile": 0.91655}, "CVE-2023-27293": {"epss_score": 0.02056, "epss_percentile": 0.83422}, "CVE-2023-27294": {"epss_score": 0.00393, "epss_percentile": 0.59701}, "CVE-2023-27295": {"epss_score": 0.00298, "epss_percentile": 0.52812}, "CVE-2023-27296": {"epss_score": 0.00221, "epss_percentile": 0.44688}, "CVE-2023-27298": {"epss_score": 0.00267, "epss_percentile": 0.49971}, "CVE-2023-27300": {"epss_score": 0.00097, "epss_percentile": 0.27531}, "CVE-2023-27301": {"epss_score": 0.00077, "epss_percentile": 0.23541}, "CVE-2023-27303": {"epss_score": 0.00074, "epss_percentile": 0.22819}, "CVE-2023-27304": {"epss_score": 0.00077, "epss_percentile": 0.23526}, "CVE-2023-27305": {"epss_score": 0.00048, "epss_percentile": 0.15189}, "CVE-2023-27306": {"epss_score": 0.00055, "epss_percentile": 0.17427}, "CVE-2023-27307": {"epss_score": 0.00092, "epss_percentile": 0.26556}, "CVE-2023-27308": {"epss_score": 0.00051, "epss_percentile": 0.16048}, "CVE-2023-27309": {"epss_score": 0.00289, "epss_percentile": 0.52039}, "CVE-2023-27310": {"epss_score": 0.00335, "epss_percentile": 0.55899}, "CVE-2023-27311": {"epss_score": 0.00184, "epss_percentile": 0.40433}, "CVE-2023-27312": {"epss_score": 0.00127, "epss_percentile": 0.32888}, "CVE-2023-27313": {"epss_score": 0.00176, "epss_percentile": 0.39405}, "CVE-2023-27314": {"epss_score": 0.00601, "epss_percentile": 0.68839}, "CVE-2023-27315": {"epss_score": 0.00098, "epss_percentile": 0.2772}, "CVE-2023-27316": {"epss_score": 0.00127, "epss_percentile": 0.32864}, "CVE-2023-27317": {"epss_score": 0.00337, "epss_percentile": 0.56025}, "CVE-2023-27318": {"epss_score": 0.00317, "epss_percentile": 0.54333}, "CVE-2023-27319": {"epss_score": 0.00236, "epss_percentile": 0.46428}, "CVE-2023-27320": {"epss_score": 0.00181, "epss_percentile": 0.40102}, "CVE-2023-27321": {"epss_score": 0.01004, "epss_percentile": 0.76526}, "CVE-2023-27322": {"epss_score": 0.00116, "epss_percentile": 0.31109}, "CVE-2023-27323": {"epss_score": 0.00092, "epss_percentile": 0.26426}, "CVE-2023-27324": {"epss_score": 0.00116, "epss_percentile": 0.31109}, "CVE-2023-27325": {"epss_score": 0.00116, "epss_percentile": 0.31109}, "CVE-2023-27326": {"epss_score": 0.02771, "epss_percentile": 0.85619}, "CVE-2023-27327": {"epss_score": 0.00059, "epss_percentile": 0.18824}, "CVE-2023-27328": {"epss_score": 0.00209, "epss_percentile": 0.43405}, "CVE-2023-27329": {"epss_score": 0.33505, "epss_percentile": 0.9678}, "CVE-2023-27330": {"epss_score": 0.33505, "epss_percentile": 0.9678}, "CVE-2023-27331": {"epss_score": 0.33505, "epss_percentile": 0.9678}, "CVE-2023-27332": {"epss_score": 0.00923, "epss_percentile": 0.75512}, "CVE-2023-27333": {"epss_score": 0.00601, "epss_percentile": 0.68848}, "CVE-2023-27334": {"epss_score": 0.00592, "epss_percentile": 0.68603}, "CVE-2023-27335": {"epss_score": 0.0055, "epss_percentile": 0.67341}, "CVE-2023-27336": {"epss_score": 0.00286, "epss_percentile": 0.51755}, "CVE-2023-27337": {"epss_score": 0.01476, "epss_percentile": 0.80533}, "CVE-2023-27338": {"epss_score": 0.00892, "epss_percentile": 0.75068}, "CVE-2023-27339": {"epss_score": 0.0256, "epss_percentile": 0.85103}, "CVE-2023-27340": {"epss_score": 0.01476, "epss_percentile": 0.80533}, "CVE-2023-27341": {"epss_score": 0.0256, "epss_percentile": 0.85103}, "CVE-2023-27342": {"epss_score": 0.01476, "epss_percentile": 0.80533}, "CVE-2023-27343": {"epss_score": 0.01476, "epss_percentile": 0.80533}, "CVE-2023-27344": {"epss_score": 0.01476, "epss_percentile": 0.80533}, "CVE-2023-27345": {"epss_score": 0.01476, "epss_percentile": 0.80533}, "CVE-2023-27346": {"epss_score": 0.01597, "epss_percentile": 0.81242}, "CVE-2023-27347": {"epss_score": 0.00115, "epss_percentile": 0.30924}, "CVE-2023-27348": {"epss_score": 0.01476, "epss_percentile": 0.80533}, "CVE-2023-27349": {"epss_score": 0.03017, "epss_percentile": 0.86218}, "CVE-2023-27350": {"epss_score": 0.94257, "epss_percentile": 0.99928}, "CVE-2023-27351": {"epss_score": 0.47366, "epss_percentile": 0.97584}, "CVE-2023-27352": {"epss_score": 0.00055, "epss_percentile": 0.17634}, "CVE-2023-27353": {"epss_score": 0.00053, "epss_percentile": 0.17008}, "CVE-2023-27354": {"epss_score": 0.00093, "epss_percentile": 0.26674}, "CVE-2023-27355": {"epss_score": 0.00055, "epss_percentile": 0.17634}, "CVE-2023-27356": {"epss_score": 0.00262, "epss_percentile": 0.49392}, "CVE-2023-27357": {"epss_score": 0.00203, "epss_percentile": 0.42541}, "CVE-2023-27358": {"epss_score": 0.00762, "epss_percentile": 0.72849}, "CVE-2023-27359": {"epss_score": 0.01874, "epss_percentile": 0.82648}, "CVE-2023-27360": {"epss_score": 0.00717, "epss_percentile": 0.71879}, "CVE-2023-27361": {"epss_score": 0.03983, "epss_percentile": 0.88061}, "CVE-2023-27362": {"epss_score": 0.00196, "epss_percentile": 0.41812}, "CVE-2023-27363": {"epss_score": 0.81009, "epss_percentile": 0.99116}, "CVE-2023-27364": {"epss_score": 0.02397, "epss_percentile": 0.8462}, "CVE-2023-27365": {"epss_score": 0.02397, "epss_percentile": 0.8462}, "CVE-2023-27366": {"epss_score": 0.01812, "epss_percentile": 0.82373}, "CVE-2023-27367": {"epss_score": 0.0021, "epss_percentile": 0.43439}, "CVE-2023-27368": {"epss_score": 0.00053, "epss_percentile": 0.16905}, "CVE-2023-27369": {"epss_score": 0.00053, "epss_percentile": 0.16905}, "CVE-2023-27370": {"epss_score": 0.00018, "epss_percentile": 0.03561}, "CVE-2023-27371": {"epss_score": 0.00109, "epss_percentile": 0.29933}, "CVE-2023-27372": {"epss_score": 0.93378, "epss_percentile": 0.99801}, "CVE-2023-27373": {"epss_score": 0.00062, "epss_percentile": 0.19722}, "CVE-2023-27375": {"epss_score": 0.00307, "epss_percentile": 0.53562}, "CVE-2023-27376": {"epss_score": 0.00307, "epss_percentile": 0.53562}, "CVE-2023-27377": {"epss_score": 0.00307, "epss_percentile": 0.53562}, "CVE-2023-27378": {"epss_score": 0.00354, "epss_percentile": 0.57225}, "CVE-2023-27379": {"epss_score": 0.00165, "epss_percentile": 0.38058}, "CVE-2023-27380": {"epss_score": 0.00284, "epss_percentile": 0.51447}, "CVE-2023-27382": {"epss_score": 0.00062, "epss_percentile": 0.19558}, "CVE-2023-27383": {"epss_score": 0.00071, "epss_percentile": 0.22216}, "CVE-2023-27384": {"epss_score": 0.00077, "epss_percentile": 0.23526}, "CVE-2023-27385": {"epss_score": 0.00086, "epss_percentile": 0.25281}, "CVE-2023-27386": {"epss_score": 0.00083, "epss_percentile": 0.24768}, "CVE-2023-27387": {"epss_score": 0.01063, "epss_percentile": 0.77188}, "CVE-2023-27388": {"epss_score": 0.01331, "epss_percentile": 0.79517}, "CVE-2023-27389": {"epss_score": 0.01417, "epss_percentile": 0.80146}, "CVE-2023-27390": {"epss_score": 0.00094, "epss_percentile": 0.27039}, "CVE-2023-27391": {"epss_score": 0.00042, "epss_percentile": 0.12674}, "CVE-2023-27392": {"epss_score": 0.0003, "epss_percentile": 0.08285}, "CVE-2023-27394": {"epss_score": 0.03747, "epss_percentile": 0.87665}, "CVE-2023-27395": {"epss_score": 0.00562, "epss_percentile": 0.67706}, "CVE-2023-27396": {"epss_score": 0.01544, "epss_percentile": 0.80959}, "CVE-2023-27397": {"epss_score": 0.00778, "epss_percentile": 0.73129}, "CVE-2023-27398": {"epss_score": 0.00092, "epss_percentile": 0.26472}, "CVE-2023-27399": {"epss_score": 0.00092, "epss_percentile": 0.26472}, "CVE-2023-27400": {"epss_score": 0.00086, "epss_percentile": 0.25394}, "CVE-2023-27401": {"epss_score": 0.0012, "epss_percentile": 0.31767}, "CVE-2023-27402": {"epss_score": 0.0012, "epss_percentile": 0.31767}, "CVE-2023-27403": {"epss_score": 0.00087, "epss_percentile": 0.25605}, "CVE-2023-27404": {"epss_score": 0.02877, "epss_percentile": 0.85885}, "CVE-2023-27405": {"epss_score": 0.0012, "epss_percentile": 0.31767}, "CVE-2023-27406": {"epss_score": 0.00086, "epss_percentile": 0.25394}, "CVE-2023-27407": {"epss_score": 0.01215, "epss_percentile": 0.78585}, "CVE-2023-27408": {"epss_score": 0.0003, "epss_percentile": 0.08052}, "CVE-2023-27409": {"epss_score": 0.0007, "epss_percentile": 0.21712}, "CVE-2023-27410": {"epss_score": 0.00079, "epss_percentile": 0.23977}, "CVE-2023-27411": {"epss_score": 0.00569, "epss_percentile": 0.67937}, "CVE-2023-27412": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-27413": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-27414": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-27415": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-27416": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-27417": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-27418": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-27419": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-27420": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-27421": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-27422": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-27423": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-27424": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2023-27425": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-27426": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-27427": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-27428": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-27429": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-27430": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-27431": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-27432": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-27433": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-27434": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-27435": {"epss_score": 0.00065, "epss_percentile": 0.20566}, "CVE-2023-27436": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-27437": {"epss_score": 0.0028, "epss_percentile": 0.50999}, "CVE-2023-27438": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-27439": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-27440": {"epss_score": 0.00457, "epss_percentile": 0.63375}, "CVE-2023-27441": {"epss_score": 0.00051, "epss_percentile": 0.16103}, "CVE-2023-27442": {"epss_score": 0.00123, "epss_percentile": 0.32324}, "CVE-2023-27443": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-27444": {"epss_score": 0.00074, "epss_percentile": 0.2276}, "CVE-2023-27445": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-27446": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-27447": {"epss_score": 0.00282, "epss_percentile": 0.51203}, "CVE-2023-27448": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-27449": {"epss_score": 0.0015, "epss_percentile": 0.36048}, "CVE-2023-27450": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-27451": {"epss_score": 0.00162, "epss_percentile": 0.37695}, "CVE-2023-27452": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-27453": {"epss_score": 0.00059, "epss_percentile": 0.18737}, "CVE-2023-27454": {"epss_score": 0.00071, "epss_percentile": 0.22058}, "CVE-2023-27455": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-27456": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-27457": {"epss_score": 0.00082, "epss_percentile": 0.24422}, "CVE-2023-27458": {"epss_score": 0.00082, "epss_percentile": 0.24422}, "CVE-2023-27459": {"epss_score": 0.00191, "epss_percentile": 0.41178}, "CVE-2023-27460": {"epss_score": 0.0046, "epss_percentile": 0.63499}, "CVE-2023-27461": {"epss_score": 0.00082, "epss_percentile": 0.24424}, "CVE-2023-27462": {"epss_score": 0.00178, "epss_percentile": 0.39719}, "CVE-2023-27463": {"epss_score": 0.00719, "epss_percentile": 0.71947}, "CVE-2023-27464": {"epss_score": 0.00275, "epss_percentile": 0.50682}, "CVE-2023-27465": {"epss_score": 0.00102, "epss_percentile": 0.28839}, "CVE-2023-27469": {"epss_score": 0.0018, "epss_percentile": 0.39936}, "CVE-2023-27470": {"epss_score": 0.00669, "epss_percentile": 0.70768}, "CVE-2023-27471": {"epss_score": 0.00038, "epss_percentile": 0.11078}, "CVE-2023-27472": {"epss_score": 0.0015, "epss_percentile": 0.36149}, "CVE-2023-27474": {"epss_score": 0.00704, "epss_percentile": 0.71551}, "CVE-2023-27475": {"epss_score": 0.00328, "epss_percentile": 0.55278}, "CVE-2023-27476": {"epss_score": 0.00149, "epss_percentile": 0.36041}, "CVE-2023-27477": {"epss_score": 0.00346, "epss_percentile": 0.56631}, "CVE-2023-27478": {"epss_score": 0.00183, "epss_percentile": 0.40315}, "CVE-2023-27479": {"epss_score": 0.01782, "epss_percentile": 0.82242}, "CVE-2023-27480": {"epss_score": 0.01261, "epss_percentile": 0.78974}, "CVE-2023-27481": {"epss_score": 0.00285, "epss_percentile": 0.51542}, "CVE-2023-27482": {"epss_score": 0.87145, "epss_percentile": 0.99417}, "CVE-2023-27483": {"epss_score": 0.00811, "epss_percentile": 0.73726}, "CVE-2023-27484": {"epss_score": 0.00126, "epss_percentile": 0.327}, "CVE-2023-27485": {"epss_score": 0.00089, "epss_percentile": 0.25841}, "CVE-2023-27486": {"epss_score": 0.00203, "epss_percentile": 0.42495}, "CVE-2023-27487": {"epss_score": 0.00018, "epss_percentile": 0.03754}, "CVE-2023-27488": {"epss_score": 0.00023, "epss_percentile": 0.05487}, "CVE-2023-27489": {"epss_score": 0.00535, "epss_percentile": 0.66826}, "CVE-2023-27490": {"epss_score": 0.00227, "epss_percentile": 0.45446}, "CVE-2023-27491": {"epss_score": 0.00013, "epss_percentile": 0.01609}, "CVE-2023-27492": {"epss_score": 0.00026, "epss_percentile": 0.06541}, "CVE-2023-27493": {"epss_score": 9e-05, "epss_percentile": 0.00604}, "CVE-2023-27494": {"epss_score": 0.00809, "epss_percentile": 0.73708}, "CVE-2023-27495": {"epss_score": 0.00097, "epss_percentile": 0.2763}, "CVE-2023-27496": {"epss_score": 0.00024, "epss_percentile": 0.05969}, "CVE-2023-27497": {"epss_score": 0.00315, "epss_percentile": 0.54163}, "CVE-2023-27498": {"epss_score": 0.00267, "epss_percentile": 0.49963}, "CVE-2023-27499": {"epss_score": 0.00521, "epss_percentile": 0.66219}, "CVE-2023-27500": {"epss_score": 0.00404, "epss_percentile": 0.60449}, "CVE-2023-27501": {"epss_score": 0.00213, "epss_percentile": 0.43901}, "CVE-2023-27502": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2023-27504": {"epss_score": 0.00062, "epss_percentile": 0.19577}, "CVE-2023-27505": {"epss_score": 0.00045, "epss_percentile": 0.13781}, "CVE-2023-27506": {"epss_score": 0.00058, "epss_percentile": 0.18485}, "CVE-2023-27507": {"epss_score": 0.01478, "epss_percentile": 0.80556}, "CVE-2023-27509": {"epss_score": 0.00044, "epss_percentile": 0.13529}, "CVE-2023-27510": {"epss_score": 0.00414, "epss_percentile": 0.61035}, "CVE-2023-27512": {"epss_score": 0.00396, "epss_percentile": 0.59918}, "CVE-2023-27513": {"epss_score": 0.00196, "epss_percentile": 0.41805}, "CVE-2023-27514": {"epss_score": 0.01751, "epss_percentile": 0.82106}, "CVE-2023-27515": {"epss_score": 0.00372, "epss_percentile": 0.58462}, "CVE-2023-27516": {"epss_score": 0.0005, "epss_percentile": 0.15739}, "CVE-2023-27517": {"epss_score": 0.00044, "epss_percentile": 0.13529}, "CVE-2023-27518": {"epss_score": 0.01278, "epss_percentile": 0.79121}, "CVE-2023-27519": {"epss_score": 0.00047, "epss_percentile": 0.14809}, "CVE-2023-27520": {"epss_score": 0.00265, "epss_percentile": 0.49799}, "CVE-2023-27521": {"epss_score": 0.01751, "epss_percentile": 0.82106}, "CVE-2023-27522": {"epss_score": 0.0064, "epss_percentile": 0.69977}, "CVE-2023-27523": {"epss_score": 0.00068, "epss_percentile": 0.21297}, "CVE-2023-27524": {"epss_score": 0.84085, "epss_percentile": 0.99273}, "CVE-2023-27525": {"epss_score": 0.00199, "epss_percentile": 0.42181}, "CVE-2023-27526": {"epss_score": 0.00119, "epss_percentile": 0.31569}, "CVE-2023-27527": {"epss_score": 0.00039, "epss_percentile": 0.11594}, "CVE-2023-27529": {"epss_score": 0.00062, "epss_percentile": 0.19775}, "CVE-2023-27530": {"epss_score": 0.02064, "epss_percentile": 0.83453}, "CVE-2023-27531": {"epss_score": 0.00091, "epss_percentile": 0.26293}, "CVE-2023-27532": {"epss_score": 0.82973, "epss_percentile": 0.99224}, "CVE-2023-27533": {"epss_score": 0.00098, "epss_percentile": 0.27686}, "CVE-2023-27534": {"epss_score": 0.00092, "epss_percentile": 0.26469}, "CVE-2023-27535": {"epss_score": 0.00074, "epss_percentile": 0.22704}, "CVE-2023-27536": {"epss_score": 9e-05, "epss_percentile": 0.00638}, "CVE-2023-27537": {"epss_score": 0.00078, "epss_percentile": 0.23568}, "CVE-2023-27538": {"epss_score": 0.0001, "epss_percentile": 0.00891}, "CVE-2023-27539": {"epss_score": 0.0021, "epss_percentile": 0.43497}, "CVE-2023-27540": {"epss_score": 0.00082, "epss_percentile": 0.24484}, "CVE-2023-27545": {"epss_score": 0.0003, "epss_percentile": 0.0822}, "CVE-2023-27554": {"epss_score": 0.0001, "epss_percentile": 0.00751}, "CVE-2023-27555": {"epss_score": 0.00037, "epss_percentile": 0.11037}, "CVE-2023-27556": {"epss_score": 0.0005, "epss_percentile": 0.15972}, "CVE-2023-27557": {"epss_score": 0.00029, "epss_percentile": 0.07763}, "CVE-2023-27558": {"epss_score": 0.00029, "epss_percentile": 0.07778}, "CVE-2023-27559": {"epss_score": 0.00096, "epss_percentile": 0.27343}, "CVE-2023-27560": {"epss_score": 0.00153, "epss_percentile": 0.3655}, "CVE-2023-27561": {"epss_score": 0.00126, "epss_percentile": 0.32775}, "CVE-2023-27562": {"epss_score": 0.01106, "epss_percentile": 0.77615}, "CVE-2023-27563": {"epss_score": 0.00253, "epss_percentile": 0.48441}, "CVE-2023-27564": {"epss_score": 0.03658, "epss_percentile": 0.87521}, "CVE-2023-27566": {"epss_score": 0.03153, "epss_percentile": 0.86509}, "CVE-2023-27567": {"epss_score": 0.00101, "epss_percentile": 0.28709}, "CVE-2023-27568": {"epss_score": 0.0012, "epss_percentile": 0.31786}, "CVE-2023-27569": {"epss_score": 0.00082, "epss_percentile": 0.24579}, "CVE-2023-27570": {"epss_score": 0.00082, "epss_percentile": 0.24579}, "CVE-2023-27571": {"epss_score": 0.00235, "epss_percentile": 0.46205}, "CVE-2023-27572": {"epss_score": 0.00274, "epss_percentile": 0.50487}, "CVE-2023-27574": {"epss_score": 0.00101, "epss_percentile": 0.28662}, "CVE-2023-27576": {"epss_score": 0.0001, "epss_percentile": 0.00884}, "CVE-2023-27577": {"epss_score": 0.00111, "epss_percentile": 0.30308}, "CVE-2023-27578": {"epss_score": 0.00172, "epss_percentile": 0.38912}, "CVE-2023-27579": {"epss_score": 0.00172, "epss_percentile": 0.38955}, "CVE-2023-27580": {"epss_score": 0.00128, "epss_percentile": 0.32947}, "CVE-2023-27581": {"epss_score": 0.04695, "epss_percentile": 0.89017}, "CVE-2023-27582": {"epss_score": 0.00138, "epss_percentile": 0.3446}, "CVE-2023-27583": {"epss_score": 0.00283, "epss_percentile": 0.51373}, "CVE-2023-27584": {"epss_score": 0.64638, "epss_percentile": 0.98387}, "CVE-2023-27585": {"epss_score": 0.00473, "epss_percentile": 0.64105}, "CVE-2023-27586": {"epss_score": 0.00069, "epss_percentile": 0.21617}, "CVE-2023-27587": {"epss_score": 0.86724, "epss_percentile": 0.99393}, "CVE-2023-27588": {"epss_score": 0.00526, "epss_percentile": 0.66422}, "CVE-2023-27589": {"epss_score": 0.00116, "epss_percentile": 0.31138}, "CVE-2023-27590": {"epss_score": 0.00039, "epss_percentile": 0.11581}, "CVE-2023-27591": {"epss_score": 0.00244, "epss_percentile": 0.47596}, "CVE-2023-27592": {"epss_score": 0.0048, "epss_percentile": 0.64476}, "CVE-2023-27593": {"epss_score": 0.00014, "epss_percentile": 0.02062}, "CVE-2023-27594": {"epss_score": 0.00045, "epss_percentile": 0.13906}, "CVE-2023-27595": {"epss_score": 0.00044, "epss_percentile": 0.13676}, "CVE-2023-27596": {"epss_score": 0.00086, "epss_percentile": 0.25309}, "CVE-2023-27597": {"epss_score": 0.00086, "epss_percentile": 0.25309}, "CVE-2023-27598": {"epss_score": 0.00106, "epss_percentile": 0.29458}, "CVE-2023-27599": {"epss_score": 0.00106, "epss_percentile": 0.29458}, "CVE-2023-27600": {"epss_score": 0.00297, "epss_percentile": 0.5275}, "CVE-2023-27601": {"epss_score": 0.00297, "epss_percentile": 0.5275}, "CVE-2023-27602": {"epss_score": 0.00527, "epss_percentile": 0.66468}, "CVE-2023-27603": {"epss_score": 0.00366, "epss_percentile": 0.58073}, "CVE-2023-27604": {"epss_score": 0.00265, "epss_percentile": 0.49765}, "CVE-2023-27605": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-27606": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2023-27607": {"epss_score": 0.00097, "epss_percentile": 0.27513}, "CVE-2023-27608": {"epss_score": 0.00052, "epss_percentile": 0.1657}, "CVE-2023-27609": {"epss_score": 0.00114, "epss_percentile": 0.30776}, "CVE-2023-27610": {"epss_score": 0.00152, "epss_percentile": 0.36496}, "CVE-2023-27611": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-27612": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-27613": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-27614": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-27615": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-27616": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-27617": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-27618": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-27619": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-27620": {"epss_score": 0.00097, "epss_percentile": 0.27492}, "CVE-2023-27621": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-27622": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-27623": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-27624": {"epss_score": 0.00992, "epss_percentile": 0.76397}, "CVE-2023-27625": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-27626": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2023-27627": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-27628": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-27629": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-27630": {"epss_score": 0.00326, "epss_percentile": 0.55079}, "CVE-2023-27631": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-27632": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-27633": {"epss_score": 0.00082, "epss_percentile": 0.24424}, "CVE-2023-27634": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-27635": {"epss_score": 0.00062, "epss_percentile": 0.19682}, "CVE-2023-27636": {"epss_score": 0.00446, "epss_percentile": 0.62902}, "CVE-2023-27637": {"epss_score": 0.58686, "epss_percentile": 0.98132}, "CVE-2023-27638": {"epss_score": 0.58686, "epss_percentile": 0.98132}, "CVE-2023-27639": {"epss_score": 0.79834, "epss_percentile": 0.99057}, "CVE-2023-27640": {"epss_score": 0.79834, "epss_percentile": 0.99057}, "CVE-2023-27641": {"epss_score": 0.4036, "epss_percentile": 0.97214}, "CVE-2023-27643": {"epss_score": 0.00341, "epss_percentile": 0.56289}, "CVE-2023-27645": {"epss_score": 0.00538, "epss_percentile": 0.66944}, "CVE-2023-27647": {"epss_score": 0.00032, "epss_percentile": 0.08791}, "CVE-2023-27648": {"epss_score": 0.03722, "epss_percentile": 0.87623}, "CVE-2023-27649": {"epss_score": 0.00229, "epss_percentile": 0.45585}, "CVE-2023-27650": {"epss_score": 0.01987, "epss_percentile": 0.83163}, "CVE-2023-27651": {"epss_score": 0.0004, "epss_percentile": 0.12003}, "CVE-2023-27652": {"epss_score": 0.00025, "epss_percentile": 0.06145}, "CVE-2023-27653": {"epss_score": 0.00095, "epss_percentile": 0.27168}, "CVE-2023-27654": {"epss_score": 0.00129, "epss_percentile": 0.33116}, "CVE-2023-27666": {"epss_score": 0.00131, "epss_percentile": 0.33442}, "CVE-2023-27667": {"epss_score": 0.00099, "epss_percentile": 0.28408}, "CVE-2023-27700": {"epss_score": 0.00079, "epss_percentile": 0.23815}, "CVE-2023-27701": {"epss_score": 0.00044, "epss_percentile": 0.13423}, "CVE-2023-27703": {"epss_score": 0.00045, "epss_percentile": 0.13771}, "CVE-2023-27704": {"epss_score": 0.0004, "epss_percentile": 0.11967}, "CVE-2023-27705": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-27706": {"epss_score": 0.00069, "epss_percentile": 0.21478}, "CVE-2023-27707": {"epss_score": 0.01295, "epss_percentile": 0.79248}, "CVE-2023-27709": {"epss_score": 0.01295, "epss_percentile": 0.79248}, "CVE-2023-27711": {"epss_score": 0.00337, "epss_percentile": 0.56064}, "CVE-2023-27716": {"epss_score": 0.00089, "epss_percentile": 0.25977}, "CVE-2023-27718": {"epss_score": 0.01467, "epss_percentile": 0.80468}, "CVE-2023-27719": {"epss_score": 0.01467, "epss_percentile": 0.80468}, "CVE-2023-27720": {"epss_score": 0.01085, "epss_percentile": 0.774}, "CVE-2023-27727": {"epss_score": 0.00071, "epss_percentile": 0.22196}, "CVE-2023-27728": {"epss_score": 0.00093, "epss_percentile": 0.26725}, "CVE-2023-27729": {"epss_score": 0.00097, "epss_percentile": 0.27531}, "CVE-2023-27730": {"epss_score": 0.00093, "epss_percentile": 0.26725}, "CVE-2023-27733": {"epss_score": 0.00069, "epss_percentile": 0.21479}, "CVE-2023-27734": {"epss_score": 0.00036, "epss_percentile": 0.10318}, "CVE-2023-27739": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2023-27742": {"epss_score": 0.00266, "epss_percentile": 0.49903}, "CVE-2023-27744": {"epss_score": 0.01353, "epss_percentile": 0.79694}, "CVE-2023-27745": {"epss_score": 0.00102, "epss_percentile": 0.28808}, "CVE-2023-27746": {"epss_score": 0.04208, "epss_percentile": 0.88398}, "CVE-2023-27747": {"epss_score": 0.00505, "epss_percentile": 0.65583}, "CVE-2023-27748": {"epss_score": 0.00254, "epss_percentile": 0.48514}, "CVE-2023-27754": {"epss_score": 0.00072, "epss_percentile": 0.22243}, "CVE-2023-27755": {"epss_score": 0.0012, "epss_percentile": 0.31805}, "CVE-2023-27757": {"epss_score": 0.00143, "epss_percentile": 0.35102}, "CVE-2023-27759": {"epss_score": 0.0017, "epss_percentile": 0.38744}, "CVE-2023-27760": {"epss_score": 0.00375, "epss_percentile": 0.58596}, "CVE-2023-27761": {"epss_score": 0.00176, "epss_percentile": 0.39421}, "CVE-2023-27762": {"epss_score": 0.00344, "epss_percentile": 0.56503}, "CVE-2023-27763": {"epss_score": 0.00176, "epss_percentile": 0.39421}, "CVE-2023-27764": {"epss_score": 0.00344, "epss_percentile": 0.56503}, "CVE-2023-27765": {"epss_score": 0.00344, "epss_percentile": 0.56503}, "CVE-2023-27766": {"epss_score": 0.00344, "epss_percentile": 0.56503}, "CVE-2023-27767": {"epss_score": 0.00344, "epss_percentile": 0.56503}, "CVE-2023-27768": {"epss_score": 0.00344, "epss_percentile": 0.56503}, "CVE-2023-27769": {"epss_score": 0.00344, "epss_percentile": 0.56503}, "CVE-2023-27770": {"epss_score": 0.00363, "epss_percentile": 0.57894}, "CVE-2023-27771": {"epss_score": 0.00344, "epss_percentile": 0.56503}, "CVE-2023-27772": {"epss_score": 0.00218, "epss_percentile": 0.4443}, "CVE-2023-27775": {"epss_score": 0.00659, "epss_percentile": 0.7051}, "CVE-2023-27776": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2023-27777": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-27779": {"epss_score": 0.0013, "epss_percentile": 0.33272}, "CVE-2023-27781": {"epss_score": 0.00171, "epss_percentile": 0.38835}, "CVE-2023-27783": {"epss_score": 0.00658, "epss_percentile": 0.70488}, "CVE-2023-27784": {"epss_score": 0.00399, "epss_percentile": 0.60115}, "CVE-2023-27785": {"epss_score": 0.00368, "epss_percentile": 0.58174}, "CVE-2023-27786": {"epss_score": 0.00306, "epss_percentile": 0.5346}, "CVE-2023-27787": {"epss_score": 0.00368, "epss_percentile": 0.58174}, "CVE-2023-27788": {"epss_score": 0.00165, "epss_percentile": 0.3812}, "CVE-2023-27789": {"epss_score": 0.00138, "epss_percentile": 0.34364}, "CVE-2023-27791": {"epss_score": 0.01131, "epss_percentile": 0.77867}, "CVE-2023-27792": {"epss_score": 0.00036, "epss_percentile": 0.10313}, "CVE-2023-27793": {"epss_score": 0.00047, "epss_percentile": 0.14884}, "CVE-2023-27795": {"epss_score": 0.00047, "epss_percentile": 0.14884}, "CVE-2023-27796": {"epss_score": 0.0142, "epss_percentile": 0.80168}, "CVE-2023-27801": {"epss_score": 0.00077, "epss_percentile": 0.23372}, "CVE-2023-27802": {"epss_score": 0.00077, "epss_percentile": 0.23372}, "CVE-2023-27803": {"epss_score": 0.0008, "epss_percentile": 0.24084}, "CVE-2023-27804": {"epss_score": 0.0008, "epss_percentile": 0.24084}, "CVE-2023-27805": {"epss_score": 0.0008, "epss_percentile": 0.24084}, "CVE-2023-27806": {"epss_score": 0.0008, "epss_percentile": 0.24084}, "CVE-2023-27807": {"epss_score": 0.0008, "epss_percentile": 0.24084}, "CVE-2023-27808": {"epss_score": 0.00077, "epss_percentile": 0.23372}, "CVE-2023-27810": {"epss_score": 0.00077, "epss_percentile": 0.23372}, "CVE-2023-27812": {"epss_score": 0.0046, "epss_percentile": 0.63529}, "CVE-2023-27821": {"epss_score": 0.02573, "epss_percentile": 0.85136}, "CVE-2023-27823": {"epss_score": 0.01771, "epss_percentile": 0.82194}, "CVE-2023-27826": {"epss_score": 0.07272, "epss_percentile": 0.91376}, "CVE-2023-27830": {"epss_score": 0.00115, "epss_percentile": 0.30976}, "CVE-2023-27836": {"epss_score": 0.01061, "epss_percentile": 0.77174}, "CVE-2023-27837": {"epss_score": 0.01486, "epss_percentile": 0.80605}, "CVE-2023-27842": {"epss_score": 0.46925, "epss_percentile": 0.97562}, "CVE-2023-27843": {"epss_score": 0.00198, "epss_percentile": 0.42018}, "CVE-2023-27844": {"epss_score": 0.00216, "epss_percentile": 0.44129}, "CVE-2023-27845": {"epss_score": 0.00525, "epss_percentile": 0.66379}, "CVE-2023-27846": {"epss_score": 0.00572, "epss_percentile": 0.68007}, "CVE-2023-27847": {"epss_score": 0.68607, "epss_percentile": 0.98556}, "CVE-2023-27848": {"epss_score": 0.04551, "epss_percentile": 0.8884}, "CVE-2023-27849": {"epss_score": 0.03764, "epss_percentile": 0.87693}, "CVE-2023-27850": {"epss_score": 0.00076, "epss_percentile": 0.23106}, "CVE-2023-27851": {"epss_score": 0.00183, "epss_percentile": 0.40297}, "CVE-2023-27852": {"epss_score": 0.00239, "epss_percentile": 0.46902}, "CVE-2023-27853": {"epss_score": 0.03785, "epss_percentile": 0.87724}, "CVE-2023-27854": {"epss_score": 0.0003, "epss_percentile": 0.08058}, "CVE-2023-27855": {"epss_score": 0.62912, "epss_percentile": 0.98313}, "CVE-2023-27856": {"epss_score": 0.51099, "epss_percentile": 0.97764}, "CVE-2023-27857": {"epss_score": 0.22998, "epss_percentile": 0.95715}, "CVE-2023-27858": {"epss_score": 0.00075, "epss_percentile": 0.23014}, "CVE-2023-27859": {"epss_score": 0.00091, "epss_percentile": 0.26408}, "CVE-2023-27860": {"epss_score": 0.00066, "epss_percentile": 0.20707}, "CVE-2023-27861": {"epss_score": 0.00025, "epss_percentile": 0.06116}, "CVE-2023-27863": {"epss_score": 0.00057, "epss_percentile": 0.18002}, "CVE-2023-27864": {"epss_score": 0.00052, "epss_percentile": 0.16579}, "CVE-2023-27866": {"epss_score": 0.00295, "epss_percentile": 0.5247}, "CVE-2023-27867": {"epss_score": 0.00258, "epss_percentile": 0.48996}, "CVE-2023-27868": {"epss_score": 0.00258, "epss_percentile": 0.48996}, "CVE-2023-27869": {"epss_score": 0.00258, "epss_percentile": 0.48996}, "CVE-2023-27870": {"epss_score": 0.00062, "epss_percentile": 0.19644}, "CVE-2023-27871": {"epss_score": 0.00061, "epss_percentile": 0.19317}, "CVE-2023-27873": {"epss_score": 0.00057, "epss_percentile": 0.18178}, "CVE-2023-27874": {"epss_score": 0.00204, "epss_percentile": 0.42646}, "CVE-2023-27875": {"epss_score": 0.00052, "epss_percentile": 0.16517}, "CVE-2023-27876": {"epss_score": 0.00054, "epss_percentile": 0.17082}, "CVE-2023-27877": {"epss_score": 0.00059, "epss_percentile": 0.18741}, "CVE-2023-27879": {"epss_score": 0.00098, "epss_percentile": 0.27755}, "CVE-2023-27881": {"epss_score": 0.00058, "epss_percentile": 0.18383}, "CVE-2023-27882": {"epss_score": 0.00329, "epss_percentile": 0.55403}, "CVE-2023-27886": {"epss_score": 0.00282, "epss_percentile": 0.5128}, "CVE-2023-27887": {"epss_score": 0.00055, "epss_percentile": 0.17589}, "CVE-2023-27888": {"epss_score": 0.00297, "epss_percentile": 0.5268}, "CVE-2023-27889": {"epss_score": 0.0072, "epss_percentile": 0.71966}, "CVE-2023-27890": {"epss_score": 0.00133, "epss_percentile": 0.33701}, "CVE-2023-27891": {"epss_score": 0.00236, "epss_percentile": 0.46461}, "CVE-2023-27892": {"epss_score": 0.00042, "epss_percentile": 0.12921}, "CVE-2023-27893": {"epss_score": 0.04493, "epss_percentile": 0.8876}, "CVE-2023-27894": {"epss_score": 0.00206, "epss_percentile": 0.43064}, "CVE-2023-27895": {"epss_score": 0.00212, "epss_percentile": 0.43797}, "CVE-2023-27896": {"epss_score": 0.00189, "epss_percentile": 0.40995}, "CVE-2023-27897": {"epss_score": 0.02229, "epss_percentile": 0.84082}, "CVE-2023-27898": {"epss_score": 0.01131, "epss_percentile": 0.77862}, "CVE-2023-27899": {"epss_score": 0.00031, "epss_percentile": 0.0868}, "CVE-2023-27900": {"epss_score": 0.00135, "epss_percentile": 0.33987}, "CVE-2023-27901": {"epss_score": 0.00135, "epss_percentile": 0.33987}, "CVE-2023-27902": {"epss_score": 0.00271, "epss_percentile": 0.50325}, "CVE-2023-27903": {"epss_score": 0.00058, "epss_percentile": 0.18271}, "CVE-2023-27904": {"epss_score": 0.002, "epss_percentile": 0.42204}, "CVE-2023-27905": {"epss_score": 0.01822, "epss_percentile": 0.82416}, "CVE-2023-27906": {"epss_score": 0.00083, "epss_percentile": 0.24807}, "CVE-2023-27907": {"epss_score": 0.00083, "epss_percentile": 0.24796}, "CVE-2023-27908": {"epss_score": 0.00081, "epss_percentile": 0.24257}, "CVE-2023-27909": {"epss_score": 0.00064, "epss_percentile": 0.20175}, "CVE-2023-27910": {"epss_score": 0.00063, "epss_percentile": 0.20066}, "CVE-2023-27911": {"epss_score": 0.00063, "epss_percentile": 0.20066}, "CVE-2023-27912": {"epss_score": 0.00075, "epss_percentile": 0.23063}, "CVE-2023-27913": {"epss_score": 0.00075, "epss_percentile": 0.23063}, "CVE-2023-27914": {"epss_score": 0.00093, "epss_percentile": 0.26657}, "CVE-2023-27915": {"epss_score": 0.00072, "epss_percentile": 0.22329}, "CVE-2023-27916": {"epss_score": 0.00055, "epss_percentile": 0.17605}, "CVE-2023-27917": {"epss_score": 0.0239, "epss_percentile": 0.84597}, "CVE-2023-27918": {"epss_score": 0.00206, "epss_percentile": 0.43065}, "CVE-2023-27919": {"epss_score": 0.00096, "epss_percentile": 0.27341}, "CVE-2023-27920": {"epss_score": 0.00137, "epss_percentile": 0.34253}, "CVE-2023-27921": {"epss_score": 0.00042, "epss_percentile": 0.12483}, "CVE-2023-27922": {"epss_score": 0.09826, "epss_percentile": 0.92722}, "CVE-2023-27923": {"epss_score": 0.00518, "epss_percentile": 0.66106}, "CVE-2023-27925": {"epss_score": 0.00668, "epss_percentile": 0.70724}, "CVE-2023-27926": {"epss_score": 0.00668, "epss_percentile": 0.70724}, "CVE-2023-27927": {"epss_score": 0.00031, "epss_percentile": 0.08714}, "CVE-2023-27928": {"epss_score": 0.00027, "epss_percentile": 0.06827}, "CVE-2023-27929": {"epss_score": 0.00031, "epss_percentile": 0.08328}, "CVE-2023-27930": {"epss_score": 0.00054, "epss_percentile": 0.17266}, "CVE-2023-27931": {"epss_score": 0.00026, "epss_percentile": 0.06454}, "CVE-2023-27932": {"epss_score": 0.0001, "epss_percentile": 0.00901}, "CVE-2023-27933": {"epss_score": 0.00044, "epss_percentile": 0.13434}, "CVE-2023-27934": {"epss_score": 0.01896, "epss_percentile": 0.82751}, "CVE-2023-27935": {"epss_score": 0.01198, "epss_percentile": 0.78456}, "CVE-2023-27936": {"epss_score": 0.0003, "epss_percentile": 0.0826}, "CVE-2023-27937": {"epss_score": 0.00056, "epss_percentile": 0.17725}, "CVE-2023-27938": {"epss_score": 0.00099, "epss_percentile": 0.28356}, "CVE-2023-27939": {"epss_score": 0.00046, "epss_percentile": 0.14322}, "CVE-2023-27940": {"epss_score": 0.00031, "epss_percentile": 0.08678}, "CVE-2023-27941": {"epss_score": 0.00078, "epss_percentile": 0.23625}, "CVE-2023-27942": {"epss_score": 0.00027, "epss_percentile": 0.07077}, "CVE-2023-27943": {"epss_score": 0.00149, "epss_percentile": 0.35956}, "CVE-2023-27944": {"epss_score": 0.00032, "epss_percentile": 0.08792}, "CVE-2023-27945": {"epss_score": 0.00054, "epss_percentile": 0.17196}, "CVE-2023-27946": {"epss_score": 0.00082, "epss_percentile": 0.24399}, "CVE-2023-27947": {"epss_score": 0.00046, "epss_percentile": 0.14322}, "CVE-2023-27948": {"epss_score": 0.00046, "epss_percentile": 0.14322}, "CVE-2023-27949": {"epss_score": 0.00044, "epss_percentile": 0.13586}, "CVE-2023-27950": {"epss_score": 0.00053, "epss_percentile": 0.16998}, "CVE-2023-27951": {"epss_score": 8e-05, "epss_percentile": 0.00481}, "CVE-2023-27952": {"epss_score": 6e-05, "epss_percentile": 0.00293}, "CVE-2023-27953": {"epss_score": 0.00731, "epss_percentile": 0.7218}, "CVE-2023-27954": {"epss_score": 0.00177, "epss_percentile": 0.39548}, "CVE-2023-27955": {"epss_score": 0.00046, "epss_percentile": 0.14134}, "CVE-2023-27956": {"epss_score": 0.00046, "epss_percentile": 0.14134}, "CVE-2023-27957": {"epss_score": 0.0008, "epss_percentile": 0.24179}, "CVE-2023-27958": {"epss_score": 0.00326, "epss_percentile": 0.5506}, "CVE-2023-27959": {"epss_score": 0.00046, "epss_percentile": 0.14388}, "CVE-2023-27960": {"epss_score": 0.00095, "epss_percentile": 0.27241}, "CVE-2023-27961": {"epss_score": 0.00026, "epss_percentile": 0.06454}, "CVE-2023-27962": {"epss_score": 0.00033, "epss_percentile": 0.09367}, "CVE-2023-27963": {"epss_score": 0.00096, "epss_percentile": 0.27369}, "CVE-2023-27964": {"epss_score": 0.04031, "epss_percentile": 0.88151}, "CVE-2023-27965": {"epss_score": 0.00037, "epss_percentile": 0.10935}, "CVE-2023-27966": {"epss_score": 0.00069, "epss_percentile": 0.21496}, "CVE-2023-27967": {"epss_score": 0.00088, "epss_percentile": 0.25635}, "CVE-2023-27968": {"epss_score": 0.00078, "epss_percentile": 0.23635}, "CVE-2023-27969": {"epss_score": 0.00082, "epss_percentile": 0.24434}, "CVE-2023-27970": {"epss_score": 0.00046, "epss_percentile": 0.14388}, "CVE-2023-27971": {"epss_score": 0.00637, "epss_percentile": 0.69898}, "CVE-2023-27972": {"epss_score": 0.03025, "epss_percentile": 0.86238}, "CVE-2023-27973": {"epss_score": 0.03025, "epss_percentile": 0.86238}, "CVE-2023-27974": {"epss_score": 0.00167, "epss_percentile": 0.38402}, "CVE-2023-27975": {"epss_score": 0.00062, "epss_percentile": 0.19777}, "CVE-2023-27976": {"epss_score": 0.00426, "epss_percentile": 0.61769}, "CVE-2023-27977": {"epss_score": 0.00075, "epss_percentile": 0.23051}, "CVE-2023-27978": {"epss_score": 0.14337, "epss_percentile": 0.94189}, "CVE-2023-27979": {"epss_score": 0.00093, "epss_percentile": 0.26634}, "CVE-2023-27980": {"epss_score": 0.02809, "epss_percentile": 0.85713}, "CVE-2023-27981": {"epss_score": 0.01902, "epss_percentile": 0.82782}, "CVE-2023-27982": {"epss_score": 0.01711, "epss_percentile": 0.81883}, "CVE-2023-27983": {"epss_score": 0.00084, "epss_percentile": 0.24926}, "CVE-2023-27984": {"epss_score": 0.00439, "epss_percentile": 0.62578}, "CVE-2023-27985": {"epss_score": 0.00046, "epss_percentile": 0.14112}, "CVE-2023-27986": {"epss_score": 0.00053, "epss_percentile": 0.16828}, "CVE-2023-27987": {"epss_score": 0.00142, "epss_percentile": 0.35007}, "CVE-2023-27988": {"epss_score": 0.00337, "epss_percentile": 0.56064}, "CVE-2023-27989": {"epss_score": 0.00379, "epss_percentile": 0.58877}, "CVE-2023-27990": {"epss_score": 0.00146, "epss_percentile": 0.35551}, "CVE-2023-27991": {"epss_score": 0.01028, "epss_percentile": 0.76822}, "CVE-2023-27992": {"epss_score": 0.84007, "epss_percentile": 0.9927}, "CVE-2023-27993": {"epss_score": 0.00069, "epss_percentile": 0.21512}, "CVE-2023-27995": {"epss_score": 0.02328, "epss_percentile": 0.84396}, "CVE-2023-27997": {"epss_score": 0.89916, "epss_percentile": 0.99549}, "CVE-2023-27998": {"epss_score": 0.00218, "epss_percentile": 0.44401}, "CVE-2023-27999": {"epss_score": 0.0017, "epss_percentile": 0.38738}, "CVE-2023-28000": {"epss_score": 0.00084, "epss_percentile": 0.24996}, "CVE-2023-28001": {"epss_score": 0.00077, "epss_percentile": 0.23366}, "CVE-2023-28002": {"epss_score": 6e-05, "epss_percentile": 0.003}, "CVE-2023-28003": {"epss_score": 0.00249, "epss_percentile": 0.48042}, "CVE-2023-28004": {"epss_score": 0.01177, "epss_percentile": 0.78279}, "CVE-2023-28005": {"epss_score": 0.00049, "epss_percentile": 0.15425}, "CVE-2023-28006": {"epss_score": 0.00034, "epss_percentile": 0.09586}, "CVE-2023-28008": {"epss_score": 0.00181, "epss_percentile": 0.39993}, "CVE-2023-28009": {"epss_score": 0.00103, "epss_percentile": 0.29009}, "CVE-2023-28010": {"epss_score": 0.00096, "epss_percentile": 0.2741}, "CVE-2023-28012": {"epss_score": 0.00499, "epss_percentile": 0.65283}, "CVE-2023-28013": {"epss_score": 0.001, "epss_percentile": 0.28505}, "CVE-2023-28014": {"epss_score": 0.00108, "epss_percentile": 0.29778}, "CVE-2023-28015": {"epss_score": 0.0022, "epss_percentile": 0.44587}, "CVE-2023-28016": {"epss_score": 0.00166, "epss_percentile": 0.38226}, "CVE-2023-28017": {"epss_score": 0.00783, "epss_percentile": 0.73217}, "CVE-2023-28018": {"epss_score": 0.00046, "epss_percentile": 0.14427}, "CVE-2023-28019": {"epss_score": 0.00116, "epss_percentile": 0.31064}, "CVE-2023-28020": {"epss_score": 0.00171, "epss_percentile": 0.38838}, "CVE-2023-28021": {"epss_score": 0.00114, "epss_percentile": 0.30786}, "CVE-2023-28022": {"epss_score": 0.00401, "epss_percentile": 0.60205}, "CVE-2023-28023": {"epss_score": 0.00067, "epss_percentile": 0.21033}, "CVE-2023-28025": {"epss_score": 0.00056, "epss_percentile": 0.17817}, "CVE-2023-28026": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28027": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28028": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28029": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28030": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28031": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28032": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28033": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28034": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28035": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28036": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28039": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28040": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28041": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28042": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28043": {"epss_score": 0.00101, "epss_percentile": 0.28565}, "CVE-2023-28044": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28045": {"epss_score": 0.00088, "epss_percentile": 0.25658}, "CVE-2023-28046": {"epss_score": 0.00034, "epss_percentile": 0.09692}, "CVE-2023-28047": {"epss_score": 0.00034, "epss_percentile": 0.0944}, "CVE-2023-28049": {"epss_score": 0.00025, "epss_percentile": 0.06262}, "CVE-2023-28050": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28051": {"epss_score": 0.00065, "epss_percentile": 0.20447}, "CVE-2023-28052": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28053": {"epss_score": 0.00097, "epss_percentile": 0.27539}, "CVE-2023-28054": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28055": {"epss_score": 0.00075, "epss_percentile": 0.22887}, "CVE-2023-28056": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28058": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28059": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28060": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28061": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-28062": {"epss_score": 0.00072, "epss_percentile": 0.22454}, "CVE-2023-28063": {"epss_score": 0.00013, "epss_percentile": 0.01711}, "CVE-2023-28064": {"epss_score": 0.00091, "epss_percentile": 0.26225}, "CVE-2023-28065": {"epss_score": 0.00057, "epss_percentile": 0.1805}, "CVE-2023-28066": {"epss_score": 0.00043, "epss_percentile": 0.13081}, "CVE-2023-28068": {"epss_score": 0.00044, "epss_percentile": 0.13414}, "CVE-2023-28069": {"epss_score": 0.00319, "epss_percentile": 0.54476}, "CVE-2023-28070": {"epss_score": 0.00059, "epss_percentile": 0.18846}, "CVE-2023-28071": {"epss_score": 0.00043, "epss_percentile": 0.13285}, "CVE-2023-28072": {"epss_score": 0.00053, "epss_percentile": 0.16713}, "CVE-2023-28073": {"epss_score": 0.00011, "epss_percentile": 0.00931}, "CVE-2023-28074": {"epss_score": 0.00053, "epss_percentile": 0.16687}, "CVE-2023-28075": {"epss_score": 0.00032, "epss_percentile": 0.08729}, "CVE-2023-28076": {"epss_score": 0.00102, "epss_percentile": 0.28793}, "CVE-2023-28077": {"epss_score": 0.0004, "epss_percentile": 0.12057}, "CVE-2023-28078": {"epss_score": 0.0037, "epss_percentile": 0.58333}, "CVE-2023-28079": {"epss_score": 0.00039, "epss_percentile": 0.11586}, "CVE-2023-28080": {"epss_score": 0.00046, "epss_percentile": 0.14182}, "CVE-2023-28081": {"epss_score": 0.00408, "epss_percentile": 0.60656}, "CVE-2023-28083": {"epss_score": 0.00215, "epss_percentile": 0.44104}, "CVE-2023-28084": {"epss_score": 0.00052, "epss_percentile": 0.16492}, "CVE-2023-28085": {"epss_score": 0.00081, "epss_percentile": 0.243}, "CVE-2023-28086": {"epss_score": 0.00052, "epss_percentile": 0.16587}, "CVE-2023-28087": {"epss_score": 0.00052, "epss_percentile": 0.16587}, "CVE-2023-28088": {"epss_score": 0.0011, "epss_percentile": 0.30239}, "CVE-2023-28089": {"epss_score": 0.00061, "epss_percentile": 0.19398}, "CVE-2023-28090": {"epss_score": 0.00052, "epss_percentile": 0.16587}, "CVE-2023-28091": {"epss_score": 0.00089, "epss_percentile": 0.25909}, "CVE-2023-28092": {"epss_score": 0.0019, "epss_percentile": 0.41136}, "CVE-2023-28093": {"epss_score": 0.00144, "epss_percentile": 0.35326}, "CVE-2023-28094": {"epss_score": 0.00216, "epss_percentile": 0.44189}, "CVE-2023-28095": {"epss_score": 0.00283, "epss_percentile": 0.51294}, "CVE-2023-28096": {"epss_score": 0.00285, "epss_percentile": 0.51516}, "CVE-2023-28097": {"epss_score": 0.00283, "epss_percentile": 0.51294}, "CVE-2023-28098": {"epss_score": 0.00097, "epss_percentile": 0.2752}, "CVE-2023-28099": {"epss_score": 0.00097, "epss_percentile": 0.2752}, "CVE-2023-28100": {"epss_score": 0.00494, "epss_percentile": 0.65094}, "CVE-2023-28101": {"epss_score": 0.00267, "epss_percentile": 0.49982}, "CVE-2023-28102": {"epss_score": 0.00916, "epss_percentile": 0.75419}, "CVE-2023-28103": {"epss_score": 0.00343, "epss_percentile": 0.56459}, "CVE-2023-28104": {"epss_score": 0.00599, "epss_percentile": 0.68789}, "CVE-2023-28105": {"epss_score": 0.00116, "epss_percentile": 0.31046}, "CVE-2023-28106": {"epss_score": 0.00063, "epss_percentile": 0.20047}, "CVE-2023-28107": {"epss_score": 0.00202, "epss_percentile": 0.42465}, "CVE-2023-28108": {"epss_score": 0.00036, "epss_percentile": 0.10454}, "CVE-2023-28109": {"epss_score": 0.00179, "epss_percentile": 0.39799}, "CVE-2023-28110": {"epss_score": 0.00534, "epss_percentile": 0.66795}, "CVE-2023-28111": {"epss_score": 0.00107, "epss_percentile": 0.29732}, "CVE-2023-28112": {"epss_score": 0.00481, "epss_percentile": 0.64501}, "CVE-2023-28113": {"epss_score": 0.00118, "epss_percentile": 0.31517}, "CVE-2023-28114": {"epss_score": 0.00039, "epss_percentile": 0.11457}, "CVE-2023-28115": {"epss_score": 0.16753, "epss_percentile": 0.94727}, "CVE-2023-28116": {"epss_score": 0.00374, "epss_percentile": 0.58574}, "CVE-2023-28117": {"epss_score": 0.00192, "epss_percentile": 0.41373}, "CVE-2023-28118": {"epss_score": 0.00222, "epss_percentile": 0.44803}, "CVE-2023-28119": {"epss_score": 0.00185, "epss_percentile": 0.40464}, "CVE-2023-28120": {"epss_score": 0.00214, "epss_percentile": 0.44}, "CVE-2023-28121": {"epss_score": 0.93348, "epss_percentile": 0.99799}, "CVE-2023-28122": {"epss_score": 0.0006, "epss_percentile": 0.19072}, "CVE-2023-28123": {"epss_score": 0.00059, "epss_percentile": 0.18665}, "CVE-2023-28124": {"epss_score": 0.00029, "epss_percentile": 0.07949}, "CVE-2023-28125": {"epss_score": 0.00226, "epss_percentile": 0.4524}, "CVE-2023-28126": {"epss_score": 0.00463, "epss_percentile": 0.63684}, "CVE-2023-28127": {"epss_score": 0.28387, "epss_percentile": 0.96349}, "CVE-2023-28128": {"epss_score": 0.88064, "epss_percentile": 0.99456}, "CVE-2023-28129": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2023-28130": {"epss_score": 0.03911, "epss_percentile": 0.87933}, "CVE-2023-28131": {"epss_score": 0.00954, "epss_percentile": 0.75898}, "CVE-2023-28133": {"epss_score": 0.01839, "epss_percentile": 0.82489}, "CVE-2023-28134": {"epss_score": 0.00043, "epss_percentile": 0.13081}, "CVE-2023-28140": {"epss_score": 0.00151, "epss_percentile": 0.36342}, "CVE-2023-28141": {"epss_score": 0.00043, "epss_percentile": 0.13061}, "CVE-2023-28142": {"epss_score": 0.00061, "epss_percentile": 0.19374}, "CVE-2023-28143": {"epss_score": 0.00034, "epss_percentile": 0.09665}, "CVE-2023-28144": {"epss_score": 0.00054, "epss_percentile": 0.17254}, "CVE-2023-28147": {"epss_score": 0.00073, "epss_percentile": 0.22567}, "CVE-2023-28149": {"epss_score": 0.00064, "epss_percentile": 0.20152}, "CVE-2023-28150": {"epss_score": 0.00073, "epss_percentile": 0.22508}, "CVE-2023-28151": {"epss_score": 0.00073, "epss_percentile": 0.22508}, "CVE-2023-28152": {"epss_score": 0.00073, "epss_percentile": 0.22508}, "CVE-2023-28153": {"epss_score": 0.00075, "epss_percentile": 0.2303}, "CVE-2023-28154": {"epss_score": 0.01449, "epss_percentile": 0.80344}, "CVE-2023-28155": {"epss_score": 0.0054, "epss_percentile": 0.67006}, "CVE-2023-28158": {"epss_score": 0.00133, "epss_percentile": 0.33641}, "CVE-2023-28159": {"epss_score": 0.00126, "epss_percentile": 0.32662}, "CVE-2023-28160": {"epss_score": 0.00128, "epss_percentile": 0.32985}, "CVE-2023-28161": {"epss_score": 0.00116, "epss_percentile": 0.31175}, "CVE-2023-28162": {"epss_score": 0.00123, "epss_percentile": 0.32258}, "CVE-2023-28163": {"epss_score": 0.00231, "epss_percentile": 0.45804}, "CVE-2023-28164": {"epss_score": 0.0008, "epss_percentile": 0.24012}, "CVE-2023-28165": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-28166": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-28167": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-28168": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-28169": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28170": {"epss_score": 0.00218, "epss_percentile": 0.44425}, "CVE-2023-28171": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-28172": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-28173": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-28174": {"epss_score": 0.00066, "epss_percentile": 0.20954}, "CVE-2023-28175": {"epss_score": 0.00144, "epss_percentile": 0.35244}, "CVE-2023-28176": {"epss_score": 0.00146, "epss_percentile": 0.35622}, "CVE-2023-28177": {"epss_score": 0.00224, "epss_percentile": 0.45052}, "CVE-2023-28178": {"epss_score": 0.00011, "epss_percentile": 0.00968}, "CVE-2023-28179": {"epss_score": 0.00061, "epss_percentile": 0.19471}, "CVE-2023-28180": {"epss_score": 0.00183, "epss_percentile": 0.40293}, "CVE-2023-28181": {"epss_score": 0.00049, "epss_percentile": 0.15445}, "CVE-2023-28182": {"epss_score": 0.00079, "epss_percentile": 0.23822}, "CVE-2023-28185": {"epss_score": 0.00036, "epss_percentile": 0.10203}, "CVE-2023-28187": {"epss_score": 0.00219, "epss_percentile": 0.44492}, "CVE-2023-28188": {"epss_score": 0.00608, "epss_percentile": 0.69081}, "CVE-2023-28189": {"epss_score": 0.001, "epss_percentile": 0.28526}, "CVE-2023-28190": {"epss_score": 0.00051, "epss_percentile": 0.16138}, "CVE-2023-28191": {"epss_score": 9e-05, "epss_percentile": 0.00744}, "CVE-2023-28192": {"epss_score": 0.00045, "epss_percentile": 0.13724}, "CVE-2023-28194": {"epss_score": 0.00037, "epss_percentile": 0.10865}, "CVE-2023-28195": {"epss_score": 0.00067, "epss_percentile": 0.21022}, "CVE-2023-28197": {"epss_score": 0.00095, "epss_percentile": 0.27234}, "CVE-2023-28198": {"epss_score": 0.00055, "epss_percentile": 0.17529}, "CVE-2023-28199": {"epss_score": 0.00046, "epss_percentile": 0.14322}, "CVE-2023-28200": {"epss_score": 0.00085, "epss_percentile": 0.25039}, "CVE-2023-28201": {"epss_score": 0.01991, "epss_percentile": 0.83175}, "CVE-2023-28202": {"epss_score": 0.00025, "epss_percentile": 0.0625}, "CVE-2023-28203": {"epss_score": 0.00055, "epss_percentile": 0.17548}, "CVE-2023-28204": {"epss_score": 0.00048, "epss_percentile": 0.15234}, "CVE-2023-28205": {"epss_score": 0.00092, "epss_percentile": 0.26444}, "CVE-2023-28206": {"epss_score": 0.26311, "epss_percentile": 0.96137}, "CVE-2023-28207": {"epss_score": 0.00021, "epss_percentile": 0.04871}, "CVE-2023-28208": {"epss_score": 0.00175, "epss_percentile": 0.3931}, "CVE-2023-28209": {"epss_score": 0.00064, "epss_percentile": 0.20109}, "CVE-2023-28210": {"epss_score": 0.00064, "epss_percentile": 0.20109}, "CVE-2023-28211": {"epss_score": 0.00083, "epss_percentile": 0.24736}, "CVE-2023-28212": {"epss_score": 0.00083, "epss_percentile": 0.24736}, "CVE-2023-28213": {"epss_score": 0.00083, "epss_percentile": 0.24736}, "CVE-2023-28214": {"epss_score": 0.00083, "epss_percentile": 0.24736}, "CVE-2023-28215": {"epss_score": 0.00064, "epss_percentile": 0.20109}, "CVE-2023-28216": {"epss_score": 0.00129, "epss_percentile": 0.33121}, "CVE-2023-28217": {"epss_score": 0.00798, "epss_percentile": 0.73516}, "CVE-2023-28218": {"epss_score": 0.23445, "epss_percentile": 0.95777}, "CVE-2023-28219": {"epss_score": 0.06389, "epss_percentile": 0.90717}, "CVE-2023-28220": {"epss_score": 0.04876, "epss_percentile": 0.89241}, "CVE-2023-28221": {"epss_score": 0.00147, "epss_percentile": 0.35722}, "CVE-2023-28222": {"epss_score": 0.00424, "epss_percentile": 0.61685}, "CVE-2023-28223": {"epss_score": 0.00401, "epss_percentile": 0.60207}, "CVE-2023-28224": {"epss_score": 0.00151, "epss_percentile": 0.36312}, "CVE-2023-28225": {"epss_score": 0.0012, "epss_percentile": 0.31693}, "CVE-2023-28226": {"epss_score": 0.00508, "epss_percentile": 0.65707}, "CVE-2023-28227": {"epss_score": 0.03433, "epss_percentile": 0.87128}, "CVE-2023-28228": {"epss_score": 0.00237, "epss_percentile": 0.46657}, "CVE-2023-28229": {"epss_score": 0.07158, "epss_percentile": 0.91291}, "CVE-2023-28231": {"epss_score": 0.67341, "epss_percentile": 0.98502}, "CVE-2023-28232": {"epss_score": 0.00114, "epss_percentile": 0.30766}, "CVE-2023-28233": {"epss_score": 0.03657, "epss_percentile": 0.8752}, "CVE-2023-28234": {"epss_score": 0.03657, "epss_percentile": 0.8752}, "CVE-2023-28235": {"epss_score": 0.00159, "epss_percentile": 0.37413}, "CVE-2023-28236": {"epss_score": 0.00135, "epss_percentile": 0.34053}, "CVE-2023-28237": {"epss_score": 0.00429, "epss_percentile": 0.61993}, "CVE-2023-28238": {"epss_score": 0.00657, "epss_percentile": 0.70471}, "CVE-2023-28240": {"epss_score": 0.0018, "epss_percentile": 0.39885}, "CVE-2023-28241": {"epss_score": 0.03657, "epss_percentile": 0.8752}, "CVE-2023-28243": {"epss_score": 0.00371, "epss_percentile": 0.58371}, "CVE-2023-28244": {"epss_score": 0.03386, "epss_percentile": 0.8704}, "CVE-2023-28246": {"epss_score": 0.00112, "epss_percentile": 0.30545}, "CVE-2023-28247": {"epss_score": 0.03346, "epss_percentile": 0.86952}, "CVE-2023-28248": {"epss_score": 0.00251, "epss_percentile": 0.4827}, "CVE-2023-28249": {"epss_score": 0.00268, "epss_percentile": 0.501}, "CVE-2023-28250": {"epss_score": 0.05023, "epss_percentile": 0.89404}, "CVE-2023-28251": {"epss_score": 0.00165, "epss_percentile": 0.38064}, "CVE-2023-28252": {"epss_score": 0.54717, "epss_percentile": 0.97941}, "CVE-2023-28253": {"epss_score": 0.00176, "epss_percentile": 0.39386}, "CVE-2023-28254": {"epss_score": 0.00972, "epss_percentile": 0.76132}, "CVE-2023-28255": {"epss_score": 0.00239, "epss_percentile": 0.46901}, "CVE-2023-28256": {"epss_score": 0.00239, "epss_percentile": 0.46901}, "CVE-2023-28260": {"epss_score": 0.01873, "epss_percentile": 0.82645}, "CVE-2023-28261": {"epss_score": 0.00124, "epss_percentile": 0.32466}, "CVE-2023-28262": {"epss_score": 0.00162, "epss_percentile": 0.37741}, "CVE-2023-28263": {"epss_score": 0.00239, "epss_percentile": 0.46859}, "CVE-2023-28266": {"epss_score": 0.05965, "epss_percentile": 0.9037}, "CVE-2023-28267": {"epss_score": 0.0087, "epss_percentile": 0.74699}, "CVE-2023-28268": {"epss_score": 0.00835, "epss_percentile": 0.7412}, "CVE-2023-28269": {"epss_score": 0.00168, "epss_percentile": 0.38424}, "CVE-2023-28270": {"epss_score": 0.0016, "epss_percentile": 0.37428}, "CVE-2023-28271": {"epss_score": 0.002, "epss_percentile": 0.42242}, "CVE-2023-28272": {"epss_score": 0.00305, "epss_percentile": 0.53392}, "CVE-2023-28273": {"epss_score": 0.00073, "epss_percentile": 0.22652}, "CVE-2023-28274": {"epss_score": 0.01444, "epss_percentile": 0.80318}, "CVE-2023-28275": {"epss_score": 0.00435, "epss_percentile": 0.62356}, "CVE-2023-28276": {"epss_score": 0.00173, "epss_percentile": 0.39108}, "CVE-2023-28277": {"epss_score": 0.01249, "epss_percentile": 0.78875}, "CVE-2023-28278": {"epss_score": 0.00239, "epss_percentile": 0.46901}, "CVE-2023-28283": {"epss_score": 0.00681, "epss_percentile": 0.71049}, "CVE-2023-28284": {"epss_score": 0.00162, "epss_percentile": 0.37639}, "CVE-2023-28285": {"epss_score": 0.01574, "epss_percentile": 0.81105}, "CVE-2023-28286": {"epss_score": 0.00122, "epss_percentile": 0.32019}, "CVE-2023-28287": {"epss_score": 0.00623, "epss_percentile": 0.69533}, "CVE-2023-28288": {"epss_score": 0.07953, "epss_percentile": 0.91786}, "CVE-2023-28290": {"epss_score": 0.00065, "epss_percentile": 0.20473}, "CVE-2023-28291": {"epss_score": 0.00322, "epss_percentile": 0.54803}, "CVE-2023-28292": {"epss_score": 0.00878, "epss_percentile": 0.74824}, "CVE-2023-28293": {"epss_score": 0.06797, "epss_percentile": 0.91033}, "CVE-2023-28295": {"epss_score": 0.00461, "epss_percentile": 0.6355}, "CVE-2023-28296": {"epss_score": 0.01096, "epss_percentile": 0.77523}, "CVE-2023-28297": {"epss_score": 0.01944, "epss_percentile": 0.82995}, "CVE-2023-28298": {"epss_score": 0.0011, "epss_percentile": 0.30225}, "CVE-2023-28299": {"epss_score": 0.0012, "epss_percentile": 0.31701}, "CVE-2023-28300": {"epss_score": 0.00869, "epss_percentile": 0.74687}, "CVE-2023-28301": {"epss_score": 0.01531, "epss_percentile": 0.8089}, "CVE-2023-28302": {"epss_score": 0.30217, "epss_percentile": 0.9652}, "CVE-2023-28303": {"epss_score": 0.00524, "epss_percentile": 0.6634}, "CVE-2023-28304": {"epss_score": 0.00393, "epss_percentile": 0.59748}, "CVE-2023-28305": {"epss_score": 0.00228, "epss_percentile": 0.45537}, "CVE-2023-28306": {"epss_score": 0.00228, "epss_percentile": 0.45537}, "CVE-2023-28307": {"epss_score": 0.00228, "epss_percentile": 0.45537}, "CVE-2023-28308": {"epss_score": 0.00228, "epss_percentile": 0.45537}, "CVE-2023-28309": {"epss_score": 0.00412, "epss_percentile": 0.60928}, "CVE-2023-28310": {"epss_score": 0.05397, "epss_percentile": 0.8983}, "CVE-2023-28311": {"epss_score": 0.01642, "epss_percentile": 0.81513}, "CVE-2023-28312": {"epss_score": 0.00294, "epss_percentile": 0.52385}, "CVE-2023-28313": {"epss_score": 0.00406, "epss_percentile": 0.60531}, "CVE-2023-28314": {"epss_score": 0.00378, "epss_percentile": 0.58805}, "CVE-2023-28316": {"epss_score": 0.00244, "epss_percentile": 0.4756}, "CVE-2023-28317": {"epss_score": 0.00068, "epss_percentile": 0.21343}, "CVE-2023-28318": {"epss_score": 0.00032, "epss_percentile": 0.09088}, "CVE-2023-28319": {"epss_score": 0.0032, "epss_percentile": 0.54625}, "CVE-2023-28320": {"epss_score": 0.00641, "epss_percentile": 0.70015}, "CVE-2023-28321": {"epss_score": 0.00297, "epss_percentile": 0.5268}, "CVE-2023-28322": {"epss_score": 0.00462, "epss_percentile": 0.63624}, "CVE-2023-28323": {"epss_score": 0.045, "epss_percentile": 0.88766}, "CVE-2023-28324": {"epss_score": 0.78595, "epss_percentile": 0.98993}, "CVE-2023-28325": {"epss_score": 0.00155, "epss_percentile": 0.3686}, "CVE-2023-28326": {"epss_score": 0.00229, "epss_percentile": 0.4561}, "CVE-2023-28327": {"epss_score": 9e-05, "epss_percentile": 0.006}, "CVE-2023-28328": {"epss_score": 0.00012, "epss_percentile": 0.01393}, "CVE-2023-28329": {"epss_score": 0.00311, "epss_percentile": 0.53932}, "CVE-2023-28330": {"epss_score": 0.00401, "epss_percentile": 0.60245}, "CVE-2023-28331": {"epss_score": 0.00677, "epss_percentile": 0.70956}, "CVE-2023-28332": {"epss_score": 0.00555, "epss_percentile": 0.67476}, "CVE-2023-28333": {"epss_score": 0.00816, "epss_percentile": 0.73801}, "CVE-2023-28334": {"epss_score": 0.00316, "epss_percentile": 0.54218}, "CVE-2023-28335": {"epss_score": 0.00345, "epss_percentile": 0.56588}, "CVE-2023-28336": {"epss_score": 0.00241, "epss_percentile": 0.47297}, "CVE-2023-28337": {"epss_score": 0.00085, "epss_percentile": 0.25165}, "CVE-2023-28338": {"epss_score": 0.00086, "epss_percentile": 0.25309}, "CVE-2023-28339": {"epss_score": 0.00111, "epss_percentile": 0.3031}, "CVE-2023-28340": {"epss_score": 0.00981, "epss_percentile": 0.76277}, "CVE-2023-28341": {"epss_score": 0.85459, "epss_percentile": 0.99333}, "CVE-2023-28342": {"epss_score": 0.84362, "epss_percentile": 0.99285}, "CVE-2023-28343": {"epss_score": 0.94174, "epss_percentile": 0.99911}, "CVE-2023-28344": {"epss_score": 0.0008, "epss_percentile": 0.24028}, "CVE-2023-28345": {"epss_score": 0.00022, "epss_percentile": 0.05042}, "CVE-2023-28346": {"epss_score": 0.00085, "epss_percentile": 0.25097}, "CVE-2023-28347": {"epss_score": 0.01152, "epss_percentile": 0.7805}, "CVE-2023-28348": {"epss_score": 0.00039, "epss_percentile": 0.11795}, "CVE-2023-28349": {"epss_score": 0.00597, "epss_percentile": 0.68738}, "CVE-2023-28350": {"epss_score": 0.00182, "epss_percentile": 0.40217}, "CVE-2023-28351": {"epss_score": 0.0003, "epss_percentile": 0.07989}, "CVE-2023-28352": {"epss_score": 0.00028, "epss_percentile": 0.07532}, "CVE-2023-28353": {"epss_score": 0.00063, "epss_percentile": 0.20103}, "CVE-2023-28354": {"epss_score": 0.06206, "epss_percentile": 0.90566}, "CVE-2023-28356": {"epss_score": 0.00218, "epss_percentile": 0.444}, "CVE-2023-28357": {"epss_score": 0.00096, "epss_percentile": 0.27346}, "CVE-2023-28358": {"epss_score": 0.00321, "epss_percentile": 0.54679}, "CVE-2023-28359": {"epss_score": 0.00138, "epss_percentile": 0.34348}, "CVE-2023-28360": {"epss_score": 0.00151, "epss_percentile": 0.36311}, "CVE-2023-28361": {"epss_score": 0.0016, "epss_percentile": 0.37449}, "CVE-2023-28362": {"epss_score": 0.00207, "epss_percentile": 0.43086}, "CVE-2023-28364": {"epss_score": 0.00122, "epss_percentile": 0.3213}, "CVE-2023-28365": {"epss_score": 0.00304, "epss_percentile": 0.53294}, "CVE-2023-28366": {"epss_score": 0.00082, "epss_percentile": 0.24447}, "CVE-2023-28367": {"epss_score": 0.00518, "epss_percentile": 0.66106}, "CVE-2023-28368": {"epss_score": 0.00046, "epss_percentile": 0.14302}, "CVE-2023-28369": {"epss_score": 0.00084, "epss_percentile": 0.24897}, "CVE-2023-28370": {"epss_score": 0.00486, "epss_percentile": 0.64742}, "CVE-2023-28371": {"epss_score": 0.00896, "epss_percentile": 0.75112}, "CVE-2023-28372": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2023-28373": {"epss_score": 0.00041, "epss_percentile": 0.12227}, "CVE-2023-28374": {"epss_score": 0.00067, "epss_percentile": 0.21024}, "CVE-2023-28375": {"epss_score": 0.1149, "epss_percentile": 0.93383}, "CVE-2023-28376": {"epss_score": 0.00081, "epss_percentile": 0.24283}, "CVE-2023-28377": {"epss_score": 0.00072, "epss_percentile": 0.22359}, "CVE-2023-28378": {"epss_score": 0.00042, "epss_percentile": 0.12714}, "CVE-2023-28379": {"epss_score": 0.00284, "epss_percentile": 0.51491}, "CVE-2023-28380": {"epss_score": 0.00194, "epss_percentile": 0.41565}, "CVE-2023-28381": {"epss_score": 0.00296, "epss_percentile": 0.52624}, "CVE-2023-28382": {"epss_score": 0.0043, "epss_percentile": 0.6202}, "CVE-2023-28383": {"epss_score": 0.00057, "epss_percentile": 0.18015}, "CVE-2023-28384": {"epss_score": 0.68366, "epss_percentile": 0.98544}, "CVE-2023-28385": {"epss_score": 0.00041, "epss_percentile": 0.12212}, "CVE-2023-28386": {"epss_score": 0.00091, "epss_percentile": 0.26401}, "CVE-2023-28387": {"epss_score": 0.0003, "epss_percentile": 0.08303}, "CVE-2023-28388": {"epss_score": 0.00147, "epss_percentile": 0.35664}, "CVE-2023-28389": {"epss_score": 0.00028, "epss_percentile": 0.07311}, "CVE-2023-28390": {"epss_score": 0.0007, "epss_percentile": 0.2164}, "CVE-2023-28391": {"epss_score": 0.00365, "epss_percentile": 0.57968}, "CVE-2023-28392": {"epss_score": 0.00363, "epss_percentile": 0.57897}, "CVE-2023-28393": {"epss_score": 0.00156, "epss_percentile": 0.36954}, "CVE-2023-28394": {"epss_score": 0.0046, "epss_percentile": 0.63516}, "CVE-2023-28395": {"epss_score": 0.00016, "epss_percentile": 0.02836}, "CVE-2023-28396": {"epss_score": 0.00038, "epss_percentile": 0.11279}, "CVE-2023-28397": {"epss_score": 0.00064, "epss_percentile": 0.20181}, "CVE-2023-28398": {"epss_score": 0.00031, "epss_percentile": 0.08509}, "CVE-2023-28399": {"epss_score": 0.00051, "epss_percentile": 0.16318}, "CVE-2023-28400": {"epss_score": 0.03984, "epss_percentile": 0.88062}, "CVE-2023-28401": {"epss_score": 0.00067, "epss_percentile": 0.21137}, "CVE-2023-28402": {"epss_score": 0.00062, "epss_percentile": 0.19577}, "CVE-2023-28404": {"epss_score": 0.00092, "epss_percentile": 0.26438}, "CVE-2023-28405": {"epss_score": 0.00061, "epss_percentile": 0.19266}, "CVE-2023-28406": {"epss_score": 0.00604, "epss_percentile": 0.68957}, "CVE-2023-28407": {"epss_score": 0.00095, "epss_percentile": 0.27105}, "CVE-2023-28408": {"epss_score": 0.02803, "epss_percentile": 0.85703}, "CVE-2023-28409": {"epss_score": 0.03595, "epss_percentile": 0.87404}, "CVE-2023-28410": {"epss_score": 0.00067, "epss_percentile": 0.21043}, "CVE-2023-28411": {"epss_score": 0.00046, "epss_percentile": 0.14392}, "CVE-2023-28412": {"epss_score": 0.00103, "epss_percentile": 0.29099}, "CVE-2023-28413": {"epss_score": 0.05972, "epss_percentile": 0.90373}, "CVE-2023-28414": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28415": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-28416": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-28417": {"epss_score": 0.0012, "epss_percentile": 0.31729}, "CVE-2023-28418": {"epss_score": 0.00115, "epss_percentile": 0.30921}, "CVE-2023-28419": {"epss_score": 0.00052, "epss_percentile": 0.16567}, "CVE-2023-28420": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-28421": {"epss_score": 0.00589, "epss_percentile": 0.68518}, "CVE-2023-28422": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-28423": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28424": {"epss_score": 0.00816, "epss_percentile": 0.73798}, "CVE-2023-28425": {"epss_score": 0.4508, "epss_percentile": 0.97471}, "CVE-2023-28427": {"epss_score": 0.00272, "epss_percentile": 0.50372}, "CVE-2023-28428": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2023-28429": {"epss_score": 8e-05, "epss_percentile": 0.00495}, "CVE-2023-28430": {"epss_score": 0.00102, "epss_percentile": 0.28719}, "CVE-2023-28431": {"epss_score": 0.00249, "epss_percentile": 0.4802}, "CVE-2023-28432": {"epss_score": 0.94113, "epss_percentile": 0.99905}, "CVE-2023-28433": {"epss_score": 0.00272, "epss_percentile": 0.50418}, "CVE-2023-28434": {"epss_score": 0.46005, "epss_percentile": 0.97517}, "CVE-2023-28435": {"epss_score": 0.00327, "epss_percentile": 0.55094}, "CVE-2023-28436": {"epss_score": 0.00072, "epss_percentile": 0.22408}, "CVE-2023-28437": {"epss_score": 0.00293, "epss_percentile": 0.523}, "CVE-2023-28438": {"epss_score": 4e-05, "epss_percentile": 0.00142}, "CVE-2023-28439": {"epss_score": 0.00317, "epss_percentile": 0.5438}, "CVE-2023-28440": {"epss_score": 0.00173, "epss_percentile": 0.39128}, "CVE-2023-28441": {"epss_score": 0.00199, "epss_percentile": 0.42133}, "CVE-2023-28442": {"epss_score": 0.00254, "epss_percentile": 0.48571}, "CVE-2023-28443": {"epss_score": 0.00044, "epss_percentile": 0.13511}, "CVE-2023-28444": {"epss_score": 0.00078, "epss_percentile": 0.23763}, "CVE-2023-28445": {"epss_score": 0.00354, "epss_percentile": 0.57245}, "CVE-2023-28446": {"epss_score": 0.01545, "epss_percentile": 0.80964}, "CVE-2023-28447": {"epss_score": 0.00615, "epss_percentile": 0.6929}, "CVE-2023-28448": {"epss_score": 0.00057, "epss_percentile": 0.18012}, "CVE-2023-28450": {"epss_score": 0.0001, "epss_percentile": 0.00865}, "CVE-2023-28451": {"epss_score": 0.00128, "epss_percentile": 0.32964}, "CVE-2023-28452": {"epss_score": 0.00042, "epss_percentile": 0.12581}, "CVE-2023-28455": {"epss_score": 0.00143, "epss_percentile": 0.35192}, "CVE-2023-28456": {"epss_score": 0.00144, "epss_percentile": 0.35236}, "CVE-2023-28457": {"epss_score": 0.00152, "epss_percentile": 0.36428}, "CVE-2023-28458": {"epss_score": 0.7431, "epss_percentile": 0.98795}, "CVE-2023-28459": {"epss_score": 0.00261, "epss_percentile": 0.49296}, "CVE-2023-28460": {"epss_score": 0.00694, "epss_percentile": 0.71354}, "CVE-2023-28461": {"epss_score": 0.87179, "epss_percentile": 0.99418}, "CVE-2023-28462": {"epss_score": 0.02022, "epss_percentile": 0.83299}, "CVE-2023-28464": {"epss_score": 0.00013, "epss_percentile": 0.0167}, "CVE-2023-28465": {"epss_score": 0.0055, "epss_percentile": 0.67338}, "CVE-2023-28466": {"epss_score": 0.00019, "epss_percentile": 0.04328}, "CVE-2023-28467": {"epss_score": 0.00128, "epss_percentile": 0.32988}, "CVE-2023-28468": {"epss_score": 0.00043, "epss_percentile": 0.13223}, "CVE-2023-28469": {"epss_score": 0.00073, "epss_percentile": 0.22567}, "CVE-2023-28470": {"epss_score": 0.00247, "epss_percentile": 0.47833}, "CVE-2023-28471": {"epss_score": 0.00983, "epss_percentile": 0.76302}, "CVE-2023-28472": {"epss_score": 0.00256, "epss_percentile": 0.48778}, "CVE-2023-28473": {"epss_score": 0.00148, "epss_percentile": 0.35888}, "CVE-2023-28474": {"epss_score": 0.00983, "epss_percentile": 0.76302}, "CVE-2023-28475": {"epss_score": 0.01066, "epss_percentile": 0.77215}, "CVE-2023-28476": {"epss_score": 0.00983, "epss_percentile": 0.76302}, "CVE-2023-28477": {"epss_score": 0.0077, "epss_percentile": 0.73003}, "CVE-2023-28478": {"epss_score": 0.00057, "epss_percentile": 0.18198}, "CVE-2023-28479": {"epss_score": 0.00098, "epss_percentile": 0.27784}, "CVE-2023-28480": {"epss_score": 0.00078, "epss_percentile": 0.23604}, "CVE-2023-28481": {"epss_score": 0.00061, "epss_percentile": 0.1938}, "CVE-2023-28482": {"epss_score": 0.00055, "epss_percentile": 0.17572}, "CVE-2023-28483": {"epss_score": 0.00023, "epss_percentile": 0.0545}, "CVE-2023-28484": {"epss_score": 0.00242, "epss_percentile": 0.47342}, "CVE-2023-28485": {"epss_score": 0.00158, "epss_percentile": 0.37171}, "CVE-2023-28486": {"epss_score": 0.00099, "epss_percentile": 0.28359}, "CVE-2023-28487": {"epss_score": 0.00099, "epss_percentile": 0.28359}, "CVE-2023-28488": {"epss_score": 0.00044, "epss_percentile": 0.13398}, "CVE-2023-28489": {"epss_score": 0.02607, "epss_percentile": 0.85228}, "CVE-2023-28490": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-28491": {"epss_score": 0.00141, "epss_percentile": 0.34868}, "CVE-2023-28492": {"epss_score": 0.00236, "epss_percentile": 0.46391}, "CVE-2023-28493": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-28494": {"epss_score": 0.00246, "epss_percentile": 0.47757}, "CVE-2023-28495": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-28496": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28497": {"epss_score": 0.00051, "epss_percentile": 0.16103}, "CVE-2023-28498": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-28499": {"epss_score": 0.0022, "epss_percentile": 0.44549}, "CVE-2023-28500": {"epss_score": 0.11255, "epss_percentile": 0.9328}, "CVE-2023-28501": {"epss_score": 0.02385, "epss_percentile": 0.84577}, "CVE-2023-28502": {"epss_score": 0.80599, "epss_percentile": 0.99096}, "CVE-2023-28503": {"epss_score": 0.63172, "epss_percentile": 0.98322}, "CVE-2023-28504": {"epss_score": 0.02385, "epss_percentile": 0.84577}, "CVE-2023-28505": {"epss_score": 0.00224, "epss_percentile": 0.45004}, "CVE-2023-28506": {"epss_score": 0.00244, "epss_percentile": 0.47609}, "CVE-2023-28507": {"epss_score": 0.00198, "epss_percentile": 0.42088}, "CVE-2023-28508": {"epss_score": 0.00199, "epss_percentile": 0.42098}, "CVE-2023-28509": {"epss_score": 0.00075, "epss_percentile": 0.22992}, "CVE-2023-28512": {"epss_score": 0.00053, "epss_percentile": 0.16984}, "CVE-2023-28513": {"epss_score": 0.00059, "epss_percentile": 0.18833}, "CVE-2023-28514": {"epss_score": 0.00022, "epss_percentile": 0.05157}, "CVE-2023-28517": {"epss_score": 0.00055, "epss_percentile": 0.17436}, "CVE-2023-28520": {"epss_score": 0.00135, "epss_percentile": 0.34016}, "CVE-2023-28522": {"epss_score": 0.00042, "epss_percentile": 0.126}, "CVE-2023-28523": {"epss_score": 0.00029, "epss_percentile": 0.07863}, "CVE-2023-28525": {"epss_score": 0.00088, "epss_percentile": 0.25751}, "CVE-2023-28526": {"epss_score": 0.00018, "epss_percentile": 0.03926}, "CVE-2023-28527": {"epss_score": 0.00018, "epss_percentile": 0.03926}, "CVE-2023-28528": {"epss_score": 0.02265, "epss_percentile": 0.84196}, "CVE-2023-28529": {"epss_score": 0.00104, "epss_percentile": 0.29243}, "CVE-2023-28530": {"epss_score": 0.00099, "epss_percentile": 0.28319}, "CVE-2023-28531": {"epss_score": 0.00328, "epss_percentile": 0.55188}, "CVE-2023-28532": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-28533": {"epss_score": 0.00053, "epss_percentile": 0.16927}, "CVE-2023-28534": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-28535": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-28536": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-28537": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-28538": {"epss_score": 0.0003, "epss_percentile": 0.08175}, "CVE-2023-28539": {"epss_score": 0.00032, "epss_percentile": 0.08982}, "CVE-2023-28540": {"epss_score": 0.00067, "epss_percentile": 0.21055}, "CVE-2023-28541": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2023-28542": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2023-28543": {"epss_score": 0.0008, "epss_percentile": 0.24006}, "CVE-2023-28544": {"epss_score": 0.00024, "epss_percentile": 0.05775}, "CVE-2023-28545": {"epss_score": 0.0004, "epss_percentile": 0.12192}, "CVE-2023-28546": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-28547": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2023-28548": {"epss_score": 0.00024, "epss_percentile": 0.05775}, "CVE-2023-28549": {"epss_score": 0.00027, "epss_percentile": 0.0694}, "CVE-2023-28550": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-28551": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-28553": {"epss_score": 0.00056, "epss_percentile": 0.17853}, "CVE-2023-28554": {"epss_score": 0.00056, "epss_percentile": 0.17853}, "CVE-2023-28555": {"epss_score": 0.00123, "epss_percentile": 0.32301}, "CVE-2023-28556": {"epss_score": 0.00045, "epss_percentile": 0.13714}, "CVE-2023-28557": {"epss_score": 0.00045, "epss_percentile": 0.13977}, "CVE-2023-28558": {"epss_score": 0.0003, "epss_percentile": 0.08175}, "CVE-2023-28559": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-28560": {"epss_score": 0.00024, "epss_percentile": 0.05775}, "CVE-2023-28561": {"epss_score": 0.00144, "epss_percentile": 0.35298}, "CVE-2023-28562": {"epss_score": 0.0008, "epss_percentile": 0.24006}, "CVE-2023-28563": {"epss_score": 0.00054, "epss_percentile": 0.17317}, "CVE-2023-28564": {"epss_score": 0.0003, "epss_percentile": 0.08175}, "CVE-2023-28565": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-28566": {"epss_score": 0.00056, "epss_percentile": 0.17853}, "CVE-2023-28567": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-28568": {"epss_score": 0.00054, "epss_percentile": 0.17317}, "CVE-2023-28569": {"epss_score": 0.00054, "epss_percentile": 0.17317}, "CVE-2023-28570": {"epss_score": 0.0004, "epss_percentile": 0.12192}, "CVE-2023-28571": {"epss_score": 0.00027, "epss_percentile": 0.07113}, "CVE-2023-28572": {"epss_score": 0.00102, "epss_percentile": 0.28827}, "CVE-2023-28573": {"epss_score": 0.00033, "epss_percentile": 0.09354}, "CVE-2023-28574": {"epss_score": 0.00045, "epss_percentile": 0.14011}, "CVE-2023-28575": {"epss_score": 0.00038, "epss_percentile": 0.11117}, "CVE-2023-28576": {"epss_score": 0.00024, "epss_percentile": 0.05795}, "CVE-2023-28577": {"epss_score": 0.00031, "epss_percentile": 0.08431}, "CVE-2023-28578": {"epss_score": 0.00111, "epss_percentile": 0.30317}, "CVE-2023-28579": {"epss_score": 0.00042, "epss_percentile": 0.12492}, "CVE-2023-28580": {"epss_score": 0.00043, "epss_percentile": 0.12952}, "CVE-2023-28581": {"epss_score": 0.00133, "epss_percentile": 0.33635}, "CVE-2023-28582": {"epss_score": 0.00167, "epss_percentile": 0.38331}, "CVE-2023-28583": {"epss_score": 0.00041, "epss_percentile": 0.12438}, "CVE-2023-28584": {"epss_score": 0.00061, "epss_percentile": 0.19543}, "CVE-2023-28585": {"epss_score": 0.0004, "epss_percentile": 0.12192}, "CVE-2023-28586": {"epss_score": 0.00039, "epss_percentile": 0.11775}, "CVE-2023-28587": {"epss_score": 0.00068, "epss_percentile": 0.21396}, "CVE-2023-28588": {"epss_score": 0.00618, "epss_percentile": 0.69382}, "CVE-2023-28596": {"epss_score": 0.00086, "epss_percentile": 0.25383}, "CVE-2023-28597": {"epss_score": 0.0098, "epss_percentile": 0.76272}, "CVE-2023-28598": {"epss_score": 0.00299, "epss_percentile": 0.52883}, "CVE-2023-28599": {"epss_score": 0.00395, "epss_percentile": 0.59832}, "CVE-2023-28600": {"epss_score": 0.00056, "epss_percentile": 0.17925}, "CVE-2023-28601": {"epss_score": 0.00262, "epss_percentile": 0.49348}, "CVE-2023-28602": {"epss_score": 0.00078, "epss_percentile": 0.23584}, "CVE-2023-28603": {"epss_score": 0.00021, "epss_percentile": 0.04916}, "CVE-2023-28604": {"epss_score": 0.00781, "epss_percentile": 0.73189}, "CVE-2023-28606": {"epss_score": 0.00114, "epss_percentile": 0.30827}, "CVE-2023-28607": {"epss_score": 0.00114, "epss_percentile": 0.30827}, "CVE-2023-28609": {"epss_score": 0.00163, "epss_percentile": 0.37773}, "CVE-2023-28610": {"epss_score": 0.0033, "epss_percentile": 0.5548}, "CVE-2023-28611": {"epss_score": 0.00106, "epss_percentile": 0.29406}, "CVE-2023-28613": {"epss_score": 0.00371, "epss_percentile": 0.58351}, "CVE-2023-28614": {"epss_score": 0.03157, "epss_percentile": 0.86517}, "CVE-2023-28616": {"epss_score": 0.00097, "epss_percentile": 0.27481}, "CVE-2023-28617": {"epss_score": 0.00028, "epss_percentile": 0.07495}, "CVE-2023-28618": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-28619": {"epss_score": 0.00048, "epss_percentile": 0.1522}, "CVE-2023-28620": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28621": {"epss_score": 0.00212, "epss_percentile": 0.4373}, "CVE-2023-28622": {"epss_score": 0.00043, "epss_percentile": 0.131}, "CVE-2023-28623": {"epss_score": 0.00051, "epss_percentile": 0.16311}, "CVE-2023-28625": {"epss_score": 0.00138, "epss_percentile": 0.34501}, "CVE-2023-28626": {"epss_score": 0.00318, "epss_percentile": 0.54443}, "CVE-2023-28627": {"epss_score": 0.00324, "epss_percentile": 0.54933}, "CVE-2023-28628": {"epss_score": 0.00179, "epss_percentile": 0.39793}, "CVE-2023-28629": {"epss_score": 0.00437, "epss_percentile": 0.62521}, "CVE-2023-28630": {"epss_score": 0.00075, "epss_percentile": 0.2291}, "CVE-2023-28631": {"epss_score": 0.0031, "epss_percentile": 0.53804}, "CVE-2023-28632": {"epss_score": 0.00261, "epss_percentile": 0.49311}, "CVE-2023-28633": {"epss_score": 0.00256, "epss_percentile": 0.48794}, "CVE-2023-28634": {"epss_score": 0.00289, "epss_percentile": 0.52052}, "CVE-2023-28635": {"epss_score": 0.00307, "epss_percentile": 0.53492}, "CVE-2023-28636": {"epss_score": 0.00525, "epss_percentile": 0.6638}, "CVE-2023-28637": {"epss_score": 0.02986, "epss_percentile": 0.86133}, "CVE-2023-28638": {"epss_score": 0.00559, "epss_percentile": 0.67602}, "CVE-2023-28639": {"epss_score": 0.01207, "epss_percentile": 0.78528}, "CVE-2023-28640": {"epss_score": 0.00153, "epss_percentile": 0.36541}, "CVE-2023-28642": {"epss_score": 0.00011, "epss_percentile": 0.00981}, "CVE-2023-28643": {"epss_score": 0.00695, "epss_percentile": 0.71381}, "CVE-2023-28644": {"epss_score": 0.00758, "epss_percentile": 0.72763}, "CVE-2023-28645": {"epss_score": 0.00097, "epss_percentile": 0.27597}, "CVE-2023-28646": {"epss_score": 0.00014, "epss_percentile": 0.01745}, "CVE-2023-28647": {"epss_score": 0.00051, "epss_percentile": 0.16214}, "CVE-2023-28648": {"epss_score": 0.00967, "epss_percentile": 0.7607}, "CVE-2023-28649": {"epss_score": 0.00065, "epss_percentile": 0.20464}, "CVE-2023-28650": {"epss_score": 0.00189, "epss_percentile": 0.40952}, "CVE-2023-28651": {"epss_score": 0.14965, "epss_percentile": 0.94335}, "CVE-2023-28652": {"epss_score": 0.00099, "epss_percentile": 0.28393}, "CVE-2023-28653": {"epss_score": 0.00045, "epss_percentile": 0.13988}, "CVE-2023-28654": {"epss_score": 0.00102, "epss_percentile": 0.28856}, "CVE-2023-28655": {"epss_score": 0.00122, "epss_percentile": 0.3208}, "CVE-2023-28656": {"epss_score": 0.00204, "epss_percentile": 0.42608}, "CVE-2023-28657": {"epss_score": 0.00168, "epss_percentile": 0.38504}, "CVE-2023-28658": {"epss_score": 0.00045, "epss_percentile": 0.13781}, "CVE-2023-28659": {"epss_score": 0.00448, "epss_percentile": 0.63003}, "CVE-2023-28660": {"epss_score": 0.00448, "epss_percentile": 0.63003}, "CVE-2023-28661": {"epss_score": 0.0041, "epss_percentile": 0.60807}, "CVE-2023-28662": {"epss_score": 0.68419, "epss_percentile": 0.98546}, "CVE-2023-28663": {"epss_score": 0.00448, "epss_percentile": 0.63003}, "CVE-2023-28664": {"epss_score": 0.00191, "epss_percentile": 0.41183}, "CVE-2023-28665": {"epss_score": 0.20137, "epss_percentile": 0.95291}, "CVE-2023-28666": {"epss_score": 0.00191, "epss_percentile": 0.41183}, "CVE-2023-28667": {"epss_score": 0.00708, "epss_percentile": 0.71666}, "CVE-2023-28668": {"epss_score": 0.00129, "epss_percentile": 0.33085}, "CVE-2023-28669": {"epss_score": 0.03602, "epss_percentile": 0.87412}, "CVE-2023-28670": {"epss_score": 0.01781, "epss_percentile": 0.82241}, "CVE-2023-28671": {"epss_score": 0.00155, "epss_percentile": 0.36854}, "CVE-2023-28672": {"epss_score": 0.00198, "epss_percentile": 0.42011}, "CVE-2023-28673": {"epss_score": 0.00221, "epss_percentile": 0.44632}, "CVE-2023-28674": {"epss_score": 0.00198, "epss_percentile": 0.42004}, "CVE-2023-28675": {"epss_score": 0.00155, "epss_percentile": 0.36775}, "CVE-2023-28676": {"epss_score": 0.00656, "epss_percentile": 0.70436}, "CVE-2023-28677": {"epss_score": 0.00688, "epss_percentile": 0.71199}, "CVE-2023-28678": {"epss_score": 0.03172, "epss_percentile": 0.86551}, "CVE-2023-28679": {"epss_score": 0.03986, "epss_percentile": 0.88065}, "CVE-2023-28680": {"epss_score": 0.00202, "epss_percentile": 0.42469}, "CVE-2023-28681": {"epss_score": 0.00207, "epss_percentile": 0.43153}, "CVE-2023-28682": {"epss_score": 0.00207, "epss_percentile": 0.43153}, "CVE-2023-28683": {"epss_score": 0.00207, "epss_percentile": 0.43153}, "CVE-2023-28684": {"epss_score": 0.002, "epss_percentile": 0.4227}, "CVE-2023-28685": {"epss_score": 0.00231, "epss_percentile": 0.45775}, "CVE-2023-28686": {"epss_score": 0.00156, "epss_percentile": 0.36885}, "CVE-2023-28687": {"epss_score": 0.00229, "epss_percentile": 0.4562}, "CVE-2023-28688": {"epss_score": 0.00062, "epss_percentile": 0.19624}, "CVE-2023-28689": {"epss_score": 0.00203, "epss_percentile": 0.42567}, "CVE-2023-28690": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-28692": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-28693": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-28694": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-28695": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28696": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-28697": {"epss_score": 0.00391, "epss_percentile": 0.59627}, "CVE-2023-28698": {"epss_score": 0.00399, "epss_percentile": 0.60093}, "CVE-2023-28699": {"epss_score": 0.00325, "epss_percentile": 0.55005}, "CVE-2023-28700": {"epss_score": 0.00039, "epss_percentile": 0.11652}, "CVE-2023-28701": {"epss_score": 0.00333, "epss_percentile": 0.55656}, "CVE-2023-28702": {"epss_score": 0.00554, "epss_percentile": 0.67442}, "CVE-2023-28703": {"epss_score": 0.00311, "epss_percentile": 0.53822}, "CVE-2023-28704": {"epss_score": 0.0041, "epss_percentile": 0.60818}, "CVE-2023-28705": {"epss_score": 0.00054, "epss_percentile": 0.1733}, "CVE-2023-28706": {"epss_score": 0.0145, "epss_percentile": 0.80353}, "CVE-2023-28707": {"epss_score": 0.00383, "epss_percentile": 0.5912}, "CVE-2023-28708": {"epss_score": 0.00098, "epss_percentile": 0.27683}, "CVE-2023-28709": {"epss_score": 0.00474, "epss_percentile": 0.6416}, "CVE-2023-28710": {"epss_score": 0.00374, "epss_percentile": 0.58534}, "CVE-2023-28711": {"epss_score": 0.0006, "epss_percentile": 0.19022}, "CVE-2023-28712": {"epss_score": 0.00158, "epss_percentile": 0.37215}, "CVE-2023-28713": {"epss_score": 0.00092, "epss_percentile": 0.26484}, "CVE-2023-28714": {"epss_score": 0.00041, "epss_percentile": 0.12212}, "CVE-2023-28715": {"epss_score": 0.0005, "epss_percentile": 0.159}, "CVE-2023-28716": {"epss_score": 0.0009, "epss_percentile": 0.26003}, "CVE-2023-28718": {"epss_score": 0.00094, "epss_percentile": 0.27064}, "CVE-2023-28720": {"epss_score": 0.00088, "epss_percentile": 0.25642}, "CVE-2023-28722": {"epss_score": 0.00074, "epss_percentile": 0.22836}, "CVE-2023-28723": {"epss_score": 0.00096, "epss_percentile": 0.2726}, "CVE-2023-28724": {"epss_score": 0.00075, "epss_percentile": 0.22961}, "CVE-2023-28725": {"epss_score": 0.08667, "epss_percentile": 0.92181}, "CVE-2023-28726": {"epss_score": 0.00382, "epss_percentile": 0.59069}, "CVE-2023-28727": {"epss_score": 0.0001, "epss_percentile": 0.0089}, "CVE-2023-28728": {"epss_score": 0.00037, "epss_percentile": 0.10802}, "CVE-2023-28729": {"epss_score": 0.0003, "epss_percentile": 0.08214}, "CVE-2023-28730": {"epss_score": 0.00029, "epss_percentile": 0.07653}, "CVE-2023-28731": {"epss_score": 0.02734, "epss_percentile": 0.85548}, "CVE-2023-28732": {"epss_score": 0.00154, "epss_percentile": 0.36647}, "CVE-2023-28733": {"epss_score": 0.00155, "epss_percentile": 0.36827}, "CVE-2023-28736": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2023-28737": {"epss_score": 0.00064, "epss_percentile": 0.20181}, "CVE-2023-28738": {"epss_score": 0.00067, "epss_percentile": 0.21052}, "CVE-2023-28739": {"epss_score": 0.00051, "epss_percentile": 0.16042}, "CVE-2023-28740": {"epss_score": 0.00083, "epss_percentile": 0.24768}, "CVE-2023-28741": {"epss_score": 0.00088, "epss_percentile": 0.25716}, "CVE-2023-28742": {"epss_score": 0.02327, "epss_percentile": 0.84392}, "CVE-2023-28743": {"epss_score": 0.00053, "epss_percentile": 0.16796}, "CVE-2023-28744": {"epss_score": 0.0013, "epss_percentile": 0.33313}, "CVE-2023-28745": {"epss_score": 0.00127, "epss_percentile": 0.32804}, "CVE-2023-28746": {"epss_score": 0.00051, "epss_percentile": 0.16107}, "CVE-2023-28747": {"epss_score": 0.00053, "epss_percentile": 0.16989}, "CVE-2023-28748": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-28749": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-28750": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-28751": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28753": {"epss_score": 0.06815, "epss_percentile": 0.91043}, "CVE-2023-28754": {"epss_score": 0.00182, "epss_percentile": 0.40219}, "CVE-2023-28755": {"epss_score": 0.0034, "epss_percentile": 0.56217}, "CVE-2023-28756": {"epss_score": 0.00854, "epss_percentile": 0.74448}, "CVE-2023-28758": {"epss_score": 0.00046, "epss_percentile": 0.1441}, "CVE-2023-28759": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2023-28760": {"epss_score": 0.01769, "epss_percentile": 0.8219}, "CVE-2023-28761": {"epss_score": 0.0028, "epss_percentile": 0.51043}, "CVE-2023-28762": {"epss_score": 0.00159, "epss_percentile": 0.37344}, "CVE-2023-28763": {"epss_score": 0.00287, "epss_percentile": 0.51785}, "CVE-2023-28764": {"epss_score": 0.0026, "epss_percentile": 0.4915}, "CVE-2023-28765": {"epss_score": 0.10942, "epss_percentile": 0.93167}, "CVE-2023-28766": {"epss_score": 0.00225, "epss_percentile": 0.4516}, "CVE-2023-28767": {"epss_score": 0.00124, "epss_percentile": 0.3238}, "CVE-2023-28768": {"epss_score": 0.0011, "epss_percentile": 0.30168}, "CVE-2023-28769": {"epss_score": 0.68259, "epss_percentile": 0.98538}, "CVE-2023-28770": {"epss_score": 0.83693, "epss_percentile": 0.99259}, "CVE-2023-28771": {"epss_score": 0.94346, "epss_percentile": 0.99953}, "CVE-2023-28772": {"epss_score": 0.00148, "epss_percentile": 0.35852}, "CVE-2023-28773": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-28774": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28775": {"epss_score": 0.00152, "epss_percentile": 0.36406}, "CVE-2023-28776": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-28777": {"epss_score": 0.00441, "epss_percentile": 0.62667}, "CVE-2023-28778": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28779": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-28780": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-28781": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-28782": {"epss_score": 0.00151, "epss_percentile": 0.36186}, "CVE-2023-28783": {"epss_score": 0.00043, "epss_percentile": 0.131}, "CVE-2023-28784": {"epss_score": 0.00087, "epss_percentile": 0.25547}, "CVE-2023-28785": {"epss_score": 0.00085, "epss_percentile": 0.25031}, "CVE-2023-28786": {"epss_score": 0.00154, "epss_percentile": 0.3674}, "CVE-2023-28787": {"epss_score": 0.00139, "epss_percentile": 0.34663}, "CVE-2023-28788": {"epss_score": 0.00147, "epss_percentile": 0.35701}, "CVE-2023-28789": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-28790": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-28791": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-28792": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-28793": {"epss_score": 0.00042, "epss_percentile": 0.12709}, "CVE-2023-28794": {"epss_score": 0.00068, "epss_percentile": 0.21418}, "CVE-2023-28795": {"epss_score": 0.00026, "epss_percentile": 0.06562}, "CVE-2023-28796": {"epss_score": 0.00012, "epss_percentile": 0.01284}, "CVE-2023-28797": {"epss_score": 0.00032, "epss_percentile": 0.09024}, "CVE-2023-28798": {"epss_score": 0.00186, "epss_percentile": 0.40584}, "CVE-2023-28799": {"epss_score": 0.00111, "epss_percentile": 0.30364}, "CVE-2023-28800": {"epss_score": 0.00158, "epss_percentile": 0.37171}, "CVE-2023-28801": {"epss_score": 0.00054, "epss_percentile": 0.17068}, "CVE-2023-28802": {"epss_score": 0.00088, "epss_percentile": 0.25662}, "CVE-2023-28803": {"epss_score": 7e-05, "epss_percentile": 0.00402}, "CVE-2023-28804": {"epss_score": 0.0003, "epss_percentile": 0.08297}, "CVE-2023-28805": {"epss_score": 0.00076, "epss_percentile": 0.23214}, "CVE-2023-28806": {"epss_score": 0.00022, "epss_percentile": 0.05198}, "CVE-2023-28807": {"epss_score": 0.00038, "epss_percentile": 0.11212}, "CVE-2023-28808": {"epss_score": 0.00479, "epss_percentile": 0.64447}, "CVE-2023-28809": {"epss_score": 0.00133, "epss_percentile": 0.33628}, "CVE-2023-28810": {"epss_score": 0.00405, "epss_percentile": 0.60486}, "CVE-2023-28811": {"epss_score": 0.00054, "epss_percentile": 0.17065}, "CVE-2023-28812": {"epss_score": 0.0033, "epss_percentile": 0.55498}, "CVE-2023-28813": {"epss_score": 0.00145, "epss_percentile": 0.35379}, "CVE-2023-28814": {"epss_score": 0.00064, "epss_percentile": 0.20262}, "CVE-2023-28815": {"epss_score": 0.00318, "epss_percentile": 0.54445}, "CVE-2023-28818": {"epss_score": 0.00067, "epss_percentile": 0.21108}, "CVE-2023-28819": {"epss_score": 0.02042, "epss_percentile": 0.83377}, "CVE-2023-28820": {"epss_score": 0.0055, "epss_percentile": 0.67345}, "CVE-2023-28821": {"epss_score": 0.00157, "epss_percentile": 0.3713}, "CVE-2023-28823": {"epss_score": 0.00061, "epss_percentile": 0.19266}, "CVE-2023-28824": {"epss_score": 0.00142, "epss_percentile": 0.35091}, "CVE-2023-28826": {"epss_score": 0.00022, "epss_percentile": 0.05237}, "CVE-2023-28827": {"epss_score": 0.00488, "epss_percentile": 0.64848}, "CVE-2023-28828": {"epss_score": 0.0022, "epss_percentile": 0.44576}, "CVE-2023-28829": {"epss_score": 0.00079, "epss_percentile": 0.23999}, "CVE-2023-28830": {"epss_score": 0.0007, "epss_percentile": 0.2165}, "CVE-2023-28831": {"epss_score": 0.00428, "epss_percentile": 0.61941}, "CVE-2023-28832": {"epss_score": 0.00794, "epss_percentile": 0.73439}, "CVE-2023-28833": {"epss_score": 0.0022, "epss_percentile": 0.44558}, "CVE-2023-28834": {"epss_score": 0.0098, "epss_percentile": 0.76273}, "CVE-2023-28835": {"epss_score": 0.00919, "epss_percentile": 0.75457}, "CVE-2023-28836": {"epss_score": 0.00938, "epss_percentile": 0.75705}, "CVE-2023-28837": {"epss_score": 0.00203, "epss_percentile": 0.4254}, "CVE-2023-28838": {"epss_score": 0.00456, "epss_percentile": 0.63354}, "CVE-2023-28839": {"epss_score": 0.00145, "epss_percentile": 0.3544}, "CVE-2023-28840": {"epss_score": 0.00425, "epss_percentile": 0.61698}, "CVE-2023-28841": {"epss_score": 0.02777, "epss_percentile": 0.85642}, "CVE-2023-28842": {"epss_score": 0.006, "epss_percentile": 0.68826}, "CVE-2023-28843": {"epss_score": 0.00273, "epss_percentile": 0.50433}, "CVE-2023-28844": {"epss_score": 0.00344, "epss_percentile": 0.56519}, "CVE-2023-28845": {"epss_score": 0.00322, "epss_percentile": 0.54814}, "CVE-2023-28846": {"epss_score": 0.00333, "epss_percentile": 0.55633}, "CVE-2023-28847": {"epss_score": 0.00543, "epss_percentile": 0.67111}, "CVE-2023-28848": {"epss_score": 0.00751, "epss_percentile": 0.72639}, "CVE-2023-28849": {"epss_score": 0.00534, "epss_percentile": 0.66779}, "CVE-2023-28850": {"epss_score": 0.00028, "epss_percentile": 0.07357}, "CVE-2023-28851": {"epss_score": 0.00615, "epss_percentile": 0.69303}, "CVE-2023-28852": {"epss_score": 0.00553, "epss_percentile": 0.67411}, "CVE-2023-28853": {"epss_score": 0.00363, "epss_percentile": 0.57876}, "CVE-2023-28854": {"epss_score": 0.01278, "epss_percentile": 0.79126}, "CVE-2023-28855": {"epss_score": 0.00162, "epss_percentile": 0.37653}, "CVE-2023-28856": {"epss_score": 0.00122, "epss_percentile": 0.32139}, "CVE-2023-28857": {"epss_score": 0.00182, "epss_percentile": 0.40241}, "CVE-2023-28858": {"epss_score": 0.01396, "epss_percentile": 0.79981}, "CVE-2023-28859": {"epss_score": 0.00261, "epss_percentile": 0.49284}, "CVE-2023-28862": {"epss_score": 0.00044, "epss_percentile": 0.13424}, "CVE-2023-28863": {"epss_score": 0.0018, "epss_percentile": 0.39879}, "CVE-2023-28864": {"epss_score": 0.00053, "epss_percentile": 0.16961}, "CVE-2023-28865": {"epss_score": 0.00242, "epss_percentile": 0.47384}, "CVE-2023-28866": {"epss_score": 0.00023, "epss_percentile": 0.05481}, "CVE-2023-28867": {"epss_score": 0.00106, "epss_percentile": 0.29417}, "CVE-2023-28868": {"epss_score": 0.00129, "epss_percentile": 0.33123}, "CVE-2023-28869": {"epss_score": 0.00103, "epss_percentile": 0.29062}, "CVE-2023-28870": {"epss_score": 0.00042, "epss_percentile": 0.12828}, "CVE-2023-28871": {"epss_score": 0.00094, "epss_percentile": 0.26957}, "CVE-2023-28872": {"epss_score": 0.00149, "epss_percentile": 0.35993}, "CVE-2023-28873": {"epss_score": 0.00088, "epss_percentile": 0.25779}, "CVE-2023-28874": {"epss_score": 0.00078, "epss_percentile": 0.23639}, "CVE-2023-28875": {"epss_score": 0.00071, "epss_percentile": 0.22149}, "CVE-2023-28876": {"epss_score": 0.00053, "epss_percentile": 0.16692}, "CVE-2023-28877": {"epss_score": 0.00102, "epss_percentile": 0.28879}, "CVE-2023-28879": {"epss_score": 0.33633, "epss_percentile": 0.96789}, "CVE-2023-28882": {"epss_score": 0.00059, "epss_percentile": 0.18917}, "CVE-2023-28883": {"epss_score": 0.00082, "epss_percentile": 0.24579}, "CVE-2023-28884": {"epss_score": 0.00274, "epss_percentile": 0.50536}, "CVE-2023-28885": {"epss_score": 0.00048, "epss_percentile": 0.1528}, "CVE-2023-28892": {"epss_score": 0.00404, "epss_percentile": 0.60397}, "CVE-2023-28895": {"epss_score": 0.00114, "epss_percentile": 0.3076}, "CVE-2023-28896": {"epss_score": 0.0003, "epss_percentile": 0.08271}, "CVE-2023-28897": {"epss_score": 0.00048, "epss_percentile": 0.15201}, "CVE-2023-28898": {"epss_score": 0.00029, "epss_percentile": 0.07819}, "CVE-2023-28899": {"epss_score": 0.0002, "epss_percentile": 0.04657}, "CVE-2023-28900": {"epss_score": 0.00062, "epss_percentile": 0.19677}, "CVE-2023-28901": {"epss_score": 0.00063, "epss_percentile": 0.19823}, "CVE-2023-28902": {"epss_score": 0.00011, "epss_percentile": 0.01114}, "CVE-2023-28903": {"epss_score": 0.00011, "epss_percentile": 0.01114}, "CVE-2023-28904": {"epss_score": 0.00027, "epss_percentile": 0.06912}, "CVE-2023-28905": {"epss_score": 0.00017, "epss_percentile": 0.03483}, "CVE-2023-28906": {"epss_score": 0.00043, "epss_percentile": 0.13009}, "CVE-2023-28907": {"epss_score": 0.00014, "epss_percentile": 0.02042}, "CVE-2023-28908": {"epss_score": 0.00021, "epss_percentile": 0.04778}, "CVE-2023-28909": {"epss_score": 0.00028, "epss_percentile": 0.07335}, "CVE-2023-28910": {"epss_score": 0.00017, "epss_percentile": 0.03333}, "CVE-2023-28911": {"epss_score": 0.00032, "epss_percentile": 0.0904}, "CVE-2023-28912": {"epss_score": 8e-05, "epss_percentile": 0.00508}, "CVE-2023-28929": {"epss_score": 0.00046, "epss_percentile": 0.14107}, "CVE-2023-28930": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-28931": {"epss_score": 0.00063, "epss_percentile": 0.19871}, "CVE-2023-28932": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28933": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28934": {"epss_score": 0.00063, "epss_percentile": 0.19871}, "CVE-2023-28935": {"epss_score": 0.00456, "epss_percentile": 0.6334}, "CVE-2023-28936": {"epss_score": 0.00287, "epss_percentile": 0.51851}, "CVE-2023-28937": {"epss_score": 0.00132, "epss_percentile": 0.33614}, "CVE-2023-28938": {"epss_score": 0.00023, "epss_percentile": 0.05626}, "CVE-2023-28949": {"epss_score": 0.00043, "epss_percentile": 0.13229}, "CVE-2023-28950": {"epss_score": 0.00033, "epss_percentile": 0.094}, "CVE-2023-28952": {"epss_score": 0.0007, "epss_percentile": 0.21651}, "CVE-2023-28953": {"epss_score": 0.00051, "epss_percentile": 0.16071}, "CVE-2023-28955": {"epss_score": 0.00075, "epss_percentile": 0.2304}, "CVE-2023-28956": {"epss_score": 0.00025, "epss_percentile": 0.06063}, "CVE-2023-28958": {"epss_score": 0.00111, "epss_percentile": 0.30348}, "CVE-2023-28959": {"epss_score": 0.00081, "epss_percentile": 0.24299}, "CVE-2023-28960": {"epss_score": 0.00043, "epss_percentile": 0.13081}, "CVE-2023-28961": {"epss_score": 0.00149, "epss_percentile": 0.35961}, "CVE-2023-28962": {"epss_score": 0.00239, "epss_percentile": 0.46884}, "CVE-2023-28963": {"epss_score": 0.00202, "epss_percentile": 0.42403}, "CVE-2023-28964": {"epss_score": 0.00235, "epss_percentile": 0.4622}, "CVE-2023-28965": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-28966": {"epss_score": 0.00027, "epss_percentile": 0.06952}, "CVE-2023-28967": {"epss_score": 0.00161, "epss_percentile": 0.37529}, "CVE-2023-28968": {"epss_score": 0.00209, "epss_percentile": 0.43383}, "CVE-2023-28970": {"epss_score": 0.00081, "epss_percentile": 0.24299}, "CVE-2023-28971": {"epss_score": 0.00066, "epss_percentile": 0.20939}, "CVE-2023-28972": {"epss_score": 0.00043, "epss_percentile": 0.13362}, "CVE-2023-28973": {"epss_score": 0.00031, "epss_percentile": 0.08458}, "CVE-2023-28974": {"epss_score": 0.00081, "epss_percentile": 0.24299}, "CVE-2023-28975": {"epss_score": 0.00102, "epss_percentile": 0.28756}, "CVE-2023-28976": {"epss_score": 0.00187, "epss_percentile": 0.40729}, "CVE-2023-28978": {"epss_score": 0.00277, "epss_percentile": 0.50818}, "CVE-2023-28979": {"epss_score": 0.00019, "epss_percentile": 0.04248}, "CVE-2023-28980": {"epss_score": 0.00048, "epss_percentile": 0.15221}, "CVE-2023-28981": {"epss_score": 0.0006, "epss_percentile": 0.18968}, "CVE-2023-28982": {"epss_score": 0.00233, "epss_percentile": 0.45982}, "CVE-2023-28983": {"epss_score": 0.00646, "epss_percentile": 0.7013}, "CVE-2023-28984": {"epss_score": 0.00056, "epss_percentile": 0.17849}, "CVE-2023-28985": {"epss_score": 0.00137, "epss_percentile": 0.34332}, "CVE-2023-28986": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-28987": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-28988": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28989": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-28990": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-28991": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-28992": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-28993": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-28994": {"epss_score": 0.0009, "epss_percentile": 0.261}, "CVE-2023-28995": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-28997": {"epss_score": 0.00659, "epss_percentile": 0.70509}, "CVE-2023-28998": {"epss_score": 0.00773, "epss_percentile": 0.73056}, "CVE-2023-28999": {"epss_score": 0.00364, "epss_percentile": 0.57908}, "CVE-2023-29000": {"epss_score": 0.00934, "epss_percentile": 0.75648}, "CVE-2023-29001": {"epss_score": 0.00187, "epss_percentile": 0.40735}, "CVE-2023-29002": {"epss_score": 0.00052, "epss_percentile": 0.16491}, "CVE-2023-29003": {"epss_score": 0.00462, "epss_percentile": 0.63582}, "CVE-2023-29004": {"epss_score": 0.00245, "epss_percentile": 0.47666}, "CVE-2023-29005": {"epss_score": 0.00309, "epss_percentile": 0.53654}, "CVE-2023-29006": {"epss_score": 0.00861, "epss_percentile": 0.74566}, "CVE-2023-29007": {"epss_score": 0.00928, "epss_percentile": 0.75587}, "CVE-2023-29008": {"epss_score": 0.00156, "epss_percentile": 0.36959}, "CVE-2023-29009": {"epss_score": 0.0055, "epss_percentile": 0.6733}, "CVE-2023-29010": {"epss_score": 0.00196, "epss_percentile": 0.41783}, "CVE-2023-29011": {"epss_score": 0.00078, "epss_percentile": 0.23786}, "CVE-2023-29012": {"epss_score": 0.00087, "epss_percentile": 0.25619}, "CVE-2023-29013": {"epss_score": 0.0369, "epss_percentile": 0.87575}, "CVE-2023-29014": {"epss_score": 0.00878, "epss_percentile": 0.74822}, "CVE-2023-29015": {"epss_score": 0.00878, "epss_percentile": 0.74822}, "CVE-2023-29016": {"epss_score": 0.00878, "epss_percentile": 0.74822}, "CVE-2023-29017": {"epss_score": 0.7806, "epss_percentile": 0.98967}, "CVE-2023-29018": {"epss_score": 0.00274, "epss_percentile": 0.5058}, "CVE-2023-29019": {"epss_score": 0.00185, "epss_percentile": 0.4055}, "CVE-2023-29020": {"epss_score": 0.00072, "epss_percentile": 0.22304}, "CVE-2023-29022": {"epss_score": 0.00106, "epss_percentile": 0.29451}, "CVE-2023-29023": {"epss_score": 0.00229, "epss_percentile": 0.45642}, "CVE-2023-29024": {"epss_score": 0.00096, "epss_percentile": 0.27268}, "CVE-2023-29025": {"epss_score": 0.00093, "epss_percentile": 0.26751}, "CVE-2023-29026": {"epss_score": 0.00106, "epss_percentile": 0.29451}, "CVE-2023-29027": {"epss_score": 0.00106, "epss_percentile": 0.29451}, "CVE-2023-29028": {"epss_score": 0.00106, "epss_percentile": 0.29451}, "CVE-2023-29029": {"epss_score": 0.00106, "epss_percentile": 0.29451}, "CVE-2023-29030": {"epss_score": 0.00121, "epss_percentile": 0.31826}, "CVE-2023-29031": {"epss_score": 0.00121, "epss_percentile": 0.31826}, "CVE-2023-29032": {"epss_score": 0.00123, "epss_percentile": 0.32179}, "CVE-2023-29043": {"epss_score": 0.0012, "epss_percentile": 0.31805}, "CVE-2023-29044": {"epss_score": 0.00156, "epss_percentile": 0.36975}, "CVE-2023-29045": {"epss_score": 0.00156, "epss_percentile": 0.36975}, "CVE-2023-29046": {"epss_score": 0.00061, "epss_percentile": 0.19496}, "CVE-2023-29047": {"epss_score": 0.0005, "epss_percentile": 0.15738}, "CVE-2023-29048": {"epss_score": 0.00376, "epss_percentile": 0.58675}, "CVE-2023-29049": {"epss_score": 0.00219, "epss_percentile": 0.44491}, "CVE-2023-29050": {"epss_score": 0.00108, "epss_percentile": 0.29854}, "CVE-2023-29051": {"epss_score": 0.00143, "epss_percentile": 0.35203}, "CVE-2023-29052": {"epss_score": 0.00191, "epss_percentile": 0.41161}, "CVE-2023-29053": {"epss_score": 0.00106, "epss_percentile": 0.2943}, "CVE-2023-29054": {"epss_score": 0.00119, "epss_percentile": 0.31666}, "CVE-2023-29055": {"epss_score": 0.00135, "epss_percentile": 0.33976}, "CVE-2023-29056": {"epss_score": 0.00151, "epss_percentile": 0.36263}, "CVE-2023-29057": {"epss_score": 0.00117, "epss_percentile": 0.3138}, "CVE-2023-29058": {"epss_score": 0.00059, "epss_percentile": 0.18908}, "CVE-2023-29059": {"epss_score": 0.00227, "epss_percentile": 0.4544}, "CVE-2023-29060": {"epss_score": 0.00052, "epss_percentile": 0.1637}, "CVE-2023-29061": {"epss_score": 0.00034, "epss_percentile": 0.09731}, "CVE-2023-29062": {"epss_score": 0.00088, "epss_percentile": 0.25661}, "CVE-2023-29063": {"epss_score": 0.00075, "epss_percentile": 0.23047}, "CVE-2023-29064": {"epss_score": 0.00043, "epss_percentile": 0.13179}, "CVE-2023-29065": {"epss_score": 0.00043, "epss_percentile": 0.13003}, "CVE-2023-29066": {"epss_score": 0.00038, "epss_percentile": 0.11073}, "CVE-2023-29067": {"epss_score": 0.00072, "epss_percentile": 0.22329}, "CVE-2023-29068": {"epss_score": 0.00061, "epss_percentile": 0.19296}, "CVE-2023-29069": {"epss_score": 0.008, "epss_percentile": 0.73536}, "CVE-2023-29073": {"epss_score": 0.00335, "epss_percentile": 0.55858}, "CVE-2023-29074": {"epss_score": 0.00312, "epss_percentile": 0.53986}, "CVE-2023-29075": {"epss_score": 0.00312, "epss_percentile": 0.53986}, "CVE-2023-29076": {"epss_score": 0.00297, "epss_percentile": 0.52713}, "CVE-2023-29080": {"epss_score": 0.00041, "epss_percentile": 0.1229}, "CVE-2023-29081": {"epss_score": 0.00027, "epss_percentile": 0.07123}, "CVE-2023-29084": {"epss_score": 0.93878, "epss_percentile": 0.99863}, "CVE-2023-29085": {"epss_score": 0.01411, "epss_percentile": 0.80085}, "CVE-2023-29086": {"epss_score": 0.00973, "epss_percentile": 0.76158}, "CVE-2023-29087": {"epss_score": 0.00973, "epss_percentile": 0.76158}, "CVE-2023-29088": {"epss_score": 0.00203, "epss_percentile": 0.4258}, "CVE-2023-29089": {"epss_score": 0.00203, "epss_percentile": 0.4258}, "CVE-2023-29090": {"epss_score": 0.00203, "epss_percentile": 0.4258}, "CVE-2023-29091": {"epss_score": 0.00203, "epss_percentile": 0.4258}, "CVE-2023-29092": {"epss_score": 0.00045, "epss_percentile": 0.13989}, "CVE-2023-29093": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-29094": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-29095": {"epss_score": 0.00164, "epss_percentile": 0.37893}, "CVE-2023-29096": {"epss_score": 0.00147, "epss_percentile": 0.35701}, "CVE-2023-29097": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-29098": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-29099": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-29100": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-29101": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-29102": {"epss_score": 0.00218, "epss_percentile": 0.44425}, "CVE-2023-29103": {"epss_score": 0.00151, "epss_percentile": 0.36204}, "CVE-2023-29104": {"epss_score": 0.00496, "epss_percentile": 0.65141}, "CVE-2023-29105": {"epss_score": 0.00239, "epss_percentile": 0.4689}, "CVE-2023-29106": {"epss_score": 0.004, "epss_percentile": 0.60151}, "CVE-2023-29107": {"epss_score": 0.00289, "epss_percentile": 0.52075}, "CVE-2023-29108": {"epss_score": 0.00211, "epss_percentile": 0.43703}, "CVE-2023-29109": {"epss_score": 0.0042, "epss_percentile": 0.61446}, "CVE-2023-29110": {"epss_score": 0.0042, "epss_percentile": 0.61446}, "CVE-2023-29111": {"epss_score": 0.00289, "epss_percentile": 0.52001}, "CVE-2023-29112": {"epss_score": 0.0042, "epss_percentile": 0.61446}, "CVE-2023-29113": {"epss_score": 0.00016, "epss_percentile": 0.02636}, "CVE-2023-29114": {"epss_score": 0.00087, "epss_percentile": 0.25576}, "CVE-2023-29115": {"epss_score": 0.0014, "epss_percentile": 0.34715}, "CVE-2023-29116": {"epss_score": 0.00158, "epss_percentile": 0.37251}, "CVE-2023-29117": {"epss_score": 0.00013, "epss_percentile": 0.01676}, "CVE-2023-29118": {"epss_score": 0.00202, "epss_percentile": 0.42422}, "CVE-2023-29119": {"epss_score": 0.00202, "epss_percentile": 0.42422}, "CVE-2023-29120": {"epss_score": 0.00113, "epss_percentile": 0.30616}, "CVE-2023-29121": {"epss_score": 0.00095, "epss_percentile": 0.27231}, "CVE-2023-29122": {"epss_score": 0.00046, "epss_percentile": 0.14138}, "CVE-2023-29125": {"epss_score": 0.00159, "epss_percentile": 0.37317}, "CVE-2023-29126": {"epss_score": 0.00018, "epss_percentile": 0.03716}, "CVE-2023-29128": {"epss_score": 0.00057, "epss_percentile": 0.18009}, "CVE-2023-29129": {"epss_score": 0.00071, "epss_percentile": 0.2212}, "CVE-2023-29130": {"epss_score": 0.00196, "epss_percentile": 0.41733}, "CVE-2023-29131": {"epss_score": 0.00021, "epss_percentile": 0.04831}, "CVE-2023-29132": {"epss_score": 0.00041, "epss_percentile": 0.12319}, "CVE-2023-29134": {"epss_score": 0.00232, "epss_percentile": 0.45965}, "CVE-2023-29137": {"epss_score": 0.00096, "epss_percentile": 0.27339}, "CVE-2023-29139": {"epss_score": 0.00049, "epss_percentile": 0.15451}, "CVE-2023-29140": {"epss_score": 0.00091, "epss_percentile": 0.26258}, "CVE-2023-29141": {"epss_score": 0.00235, "epss_percentile": 0.46334}, "CVE-2023-29144": {"epss_score": 0.00014, "epss_percentile": 0.01861}, "CVE-2023-29145": {"epss_score": 0.00072, "epss_percentile": 0.22443}, "CVE-2023-29147": {"epss_score": 0.00012, "epss_percentile": 0.01233}, "CVE-2023-29150": {"epss_score": 0.0009, "epss_percentile": 0.26003}, "CVE-2023-29151": {"epss_score": 0.00082, "epss_percentile": 0.24555}, "CVE-2023-29152": {"epss_score": 0.00024, "epss_percentile": 0.05673}, "CVE-2023-29153": {"epss_score": 0.00097, "epss_percentile": 0.27497}, "CVE-2023-29154": {"epss_score": 0.11943, "epss_percentile": 0.93522}, "CVE-2023-29155": {"epss_score": 0.00116, "epss_percentile": 0.31147}, "CVE-2023-29156": {"epss_score": 0.00032, "epss_percentile": 0.08831}, "CVE-2023-29157": {"epss_score": 0.00085, "epss_percentile": 0.2516}, "CVE-2023-29158": {"epss_score": 0.00039, "epss_percentile": 0.11838}, "CVE-2023-29159": {"epss_score": 0.01332, "epss_percentile": 0.79522}, "CVE-2023-29160": {"epss_score": 0.00043, "epss_percentile": 0.13129}, "CVE-2023-29161": {"epss_score": 0.00196, "epss_percentile": 0.41805}, "CVE-2023-29162": {"epss_score": 0.00042, "epss_percentile": 0.12496}, "CVE-2023-29163": {"epss_score": 0.00308, "epss_percentile": 0.53582}, "CVE-2023-29164": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2023-29165": {"epss_score": 0.00106, "epss_percentile": 0.2952}, "CVE-2023-29166": {"epss_score": 0.00246, "epss_percentile": 0.4775}, "CVE-2023-29167": {"epss_score": 0.00035, "epss_percentile": 0.09965}, "CVE-2023-29168": {"epss_score": 0.00074, "epss_percentile": 0.2286}, "CVE-2023-29169": {"epss_score": 0.0009, "epss_percentile": 0.26003}, "CVE-2023-29170": {"epss_score": 0.00079, "epss_percentile": 0.23936}, "CVE-2023-29171": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-29172": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-29173": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-29174": {"epss_score": 0.00148, "epss_percentile": 0.35918}, "CVE-2023-29175": {"epss_score": 0.00091, "epss_percentile": 0.26236}, "CVE-2023-29177": {"epss_score": 0.00058, "epss_percentile": 0.18469}, "CVE-2023-29178": {"epss_score": 0.00127, "epss_percentile": 0.32923}, "CVE-2023-29179": {"epss_score": 0.00502, "epss_percentile": 0.65404}, "CVE-2023-29180": {"epss_score": 0.00466, "epss_percentile": 0.63801}, "CVE-2023-29181": {"epss_score": 0.00277, "epss_percentile": 0.50837}, "CVE-2023-29182": {"epss_score": 0.00039, "epss_percentile": 0.11614}, "CVE-2023-29183": {"epss_score": 0.0059, "epss_percentile": 0.68565}, "CVE-2023-29184": {"epss_score": 0.00018, "epss_percentile": 0.0357}, "CVE-2023-29185": {"epss_score": 0.00287, "epss_percentile": 0.51785}, "CVE-2023-29186": {"epss_score": 0.22137, "epss_percentile": 0.956}, "CVE-2023-29187": {"epss_score": 0.0006, "epss_percentile": 0.1897}, "CVE-2023-29188": {"epss_score": 0.00336, "epss_percentile": 0.55944}, "CVE-2023-29189": {"epss_score": 0.00352, "epss_percentile": 0.57079}, "CVE-2023-29192": {"epss_score": 0.00056, "epss_percentile": 0.17756}, "CVE-2023-29193": {"epss_score": 0.00279, "epss_percentile": 0.50955}, "CVE-2023-29194": {"epss_score": 0.001, "epss_percentile": 0.28515}, "CVE-2023-29195": {"epss_score": 0.00114, "epss_percentile": 0.30786}, "CVE-2023-29196": {"epss_score": 0.00116, "epss_percentile": 0.31173}, "CVE-2023-29197": {"epss_score": 0.02483, "epss_percentile": 0.84879}, "CVE-2023-29198": {"epss_score": 0.00148, "epss_percentile": 0.35883}, "CVE-2023-29199": {"epss_score": 0.2341, "epss_percentile": 0.95774}, "CVE-2023-29200": {"epss_score": 0.00264, "epss_percentile": 0.49751}, "CVE-2023-29201": {"epss_score": 0.02712, "epss_percentile": 0.85502}, "CVE-2023-29202": {"epss_score": 0.0245, "epss_percentile": 0.8478}, "CVE-2023-29203": {"epss_score": 0.00157, "epss_percentile": 0.37107}, "CVE-2023-29204": {"epss_score": 0.09834, "epss_percentile": 0.92725}, "CVE-2023-29205": {"epss_score": 0.03014, "epss_percentile": 0.86208}, "CVE-2023-29206": {"epss_score": 0.06345, "epss_percentile": 0.90685}, "CVE-2023-29207": {"epss_score": 0.02491, "epss_percentile": 0.84896}, "CVE-2023-29208": {"epss_score": 0.00226, "epss_percentile": 0.45357}, "CVE-2023-29209": {"epss_score": 0.02475, "epss_percentile": 0.84858}, "CVE-2023-29210": {"epss_score": 0.07986, "epss_percentile": 0.91806}, "CVE-2023-29211": {"epss_score": 0.08472, "epss_percentile": 0.92071}, "CVE-2023-29212": {"epss_score": 0.08472, "epss_percentile": 0.92071}, "CVE-2023-29213": {"epss_score": 0.01073, "epss_percentile": 0.77293}, "CVE-2023-29214": {"epss_score": 0.07278, "epss_percentile": 0.91381}, "CVE-2023-29215": {"epss_score": 0.04767, "epss_percentile": 0.89124}, "CVE-2023-29216": {"epss_score": 0.04767, "epss_percentile": 0.89124}, "CVE-2023-29218": {"epss_score": 0.0023, "epss_percentile": 0.45672}, "CVE-2023-29234": {"epss_score": 0.88971, "epss_percentile": 0.99502}, "CVE-2023-29235": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-29236": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-29237": {"epss_score": 0.0015, "epss_percentile": 0.36048}, "CVE-2023-29238": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-29239": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-29240": {"epss_score": 0.00094, "epss_percentile": 0.27009}, "CVE-2023-29241": {"epss_score": 0.00125, "epss_percentile": 0.32599}, "CVE-2023-29242": {"epss_score": 0.00059, "epss_percentile": 0.18846}, "CVE-2023-29243": {"epss_score": 0.00033, "epss_percentile": 0.09354}, "CVE-2023-29244": {"epss_score": 0.00037, "epss_percentile": 0.10925}, "CVE-2023-29245": {"epss_score": 0.0011, "epss_percentile": 0.3022}, "CVE-2023-29246": {"epss_score": 0.00071, "epss_percentile": 0.22049}, "CVE-2023-29247": {"epss_score": 0.00308, "epss_percentile": 0.53599}, "CVE-2023-29255": {"epss_score": 0.0008, "epss_percentile": 0.24107}, "CVE-2023-29256": {"epss_score": 0.00062, "epss_percentile": 0.19576}, "CVE-2023-29257": {"epss_score": 0.00124, "epss_percentile": 0.32451}, "CVE-2023-29258": {"epss_score": 0.00117, "epss_percentile": 0.31329}, "CVE-2023-29259": {"epss_score": 0.00066, "epss_percentile": 0.20707}, "CVE-2023-29260": {"epss_score": 0.00048, "epss_percentile": 0.1515}, "CVE-2023-29261": {"epss_score": 0.00016, "epss_percentile": 0.02895}, "CVE-2023-29267": {"epss_score": 0.00133, "epss_percentile": 0.3369}, "CVE-2023-29268": {"epss_score": 0.01136, "epss_percentile": 0.77921}, "CVE-2023-29273": {"epss_score": 0.00166, "epss_percentile": 0.38187}, "CVE-2023-29274": {"epss_score": 0.00166, "epss_percentile": 0.38187}, "CVE-2023-29275": {"epss_score": 0.00166, "epss_percentile": 0.38187}, "CVE-2023-29276": {"epss_score": 0.0012, "epss_percentile": 0.31745}, "CVE-2023-29277": {"epss_score": 0.00024, "epss_percentile": 0.05824}, "CVE-2023-29278": {"epss_score": 0.0012, "epss_percentile": 0.31745}, "CVE-2023-29279": {"epss_score": 0.00024, "epss_percentile": 0.05824}, "CVE-2023-29280": {"epss_score": 0.00157, "epss_percentile": 0.37091}, "CVE-2023-29281": {"epss_score": 0.00157, "epss_percentile": 0.37091}, "CVE-2023-29282": {"epss_score": 0.00114, "epss_percentile": 0.30753}, "CVE-2023-29283": {"epss_score": 0.0014, "epss_percentile": 0.34715}, "CVE-2023-29284": {"epss_score": 0.0014, "epss_percentile": 0.34715}, "CVE-2023-29285": {"epss_score": 0.0012, "epss_percentile": 0.31745}, "CVE-2023-29286": {"epss_score": 0.00023, "epss_percentile": 0.05382}, "CVE-2023-29287": {"epss_score": 0.00263, "epss_percentile": 0.49503}, "CVE-2023-29288": {"epss_score": 0.0014, "epss_percentile": 0.34704}, "CVE-2023-29289": {"epss_score": 0.00322, "epss_percentile": 0.5486}, "CVE-2023-29290": {"epss_score": 0.00125, "epss_percentile": 0.32568}, "CVE-2023-29291": {"epss_score": 0.00453, "epss_percentile": 0.63216}, "CVE-2023-29292": {"epss_score": 0.00352, "epss_percentile": 0.57098}, "CVE-2023-29293": {"epss_score": 0.00038, "epss_percentile": 0.11389}, "CVE-2023-29294": {"epss_score": 0.00169, "epss_percentile": 0.38533}, "CVE-2023-29295": {"epss_score": 0.00103, "epss_percentile": 0.28985}, "CVE-2023-29296": {"epss_score": 0.00103, "epss_percentile": 0.28985}, "CVE-2023-29297": {"epss_score": 0.06748, "epss_percentile": 0.91}, "CVE-2023-29298": {"epss_score": 0.9429, "epss_percentile": 0.99936}, "CVE-2023-29299": {"epss_score": 0.00243, "epss_percentile": 0.47499}, "CVE-2023-29300": {"epss_score": 0.93799, "epss_percentile": 0.99848}, "CVE-2023-29301": {"epss_score": 0.00436, "epss_percentile": 0.62447}, "CVE-2023-29302": {"epss_score": 0.03112, "epss_percentile": 0.86427}, "CVE-2023-29303": {"epss_score": 0.00119, "epss_percentile": 0.31641}, "CVE-2023-29304": {"epss_score": 0.03112, "epss_percentile": 0.86427}, "CVE-2023-29305": {"epss_score": 0.01071, "epss_percentile": 0.77269}, "CVE-2023-29306": {"epss_score": 0.01071, "epss_percentile": 0.77269}, "CVE-2023-29307": {"epss_score": 0.00844, "epss_percentile": 0.74279}, "CVE-2023-29308": {"epss_score": 0.00141, "epss_percentile": 0.34803}, "CVE-2023-29309": {"epss_score": 0.00033, "epss_percentile": 0.09163}, "CVE-2023-29310": {"epss_score": 0.00033, "epss_percentile": 0.09163}, "CVE-2023-29311": {"epss_score": 0.00033, "epss_percentile": 0.09163}, "CVE-2023-29312": {"epss_score": 0.00044, "epss_percentile": 0.13435}, "CVE-2023-29313": {"epss_score": 0.00033, "epss_percentile": 0.09163}, "CVE-2023-29314": {"epss_score": 0.00044, "epss_percentile": 0.13435}, "CVE-2023-29315": {"epss_score": 0.00033, "epss_percentile": 0.09163}, "CVE-2023-29316": {"epss_score": 0.00044, "epss_percentile": 0.13435}, "CVE-2023-29317": {"epss_score": 0.00033, "epss_percentile": 0.09163}, "CVE-2023-29318": {"epss_score": 0.00033, "epss_percentile": 0.09163}, "CVE-2023-29319": {"epss_score": 0.00044, "epss_percentile": 0.13435}, "CVE-2023-29320": {"epss_score": 0.00134, "epss_percentile": 0.33827}, "CVE-2023-29321": {"epss_score": 0.00147, "epss_percentile": 0.35753}, "CVE-2023-29322": {"epss_score": 0.03814, "epss_percentile": 0.87764}, "CVE-2023-29323": {"epss_score": 0.00039, "epss_percentile": 0.11621}, "CVE-2023-29324": {"epss_score": 0.02256, "epss_percentile": 0.84171}, "CVE-2023-29325": {"epss_score": 0.21045, "epss_percentile": 0.95456}, "CVE-2023-29326": {"epss_score": 0.00555, "epss_percentile": 0.67473}, "CVE-2023-29328": {"epss_score": 0.00598, "epss_percentile": 0.68776}, "CVE-2023-29330": {"epss_score": 0.00598, "epss_percentile": 0.68776}, "CVE-2023-29331": {"epss_score": 0.01136, "epss_percentile": 0.77915}, "CVE-2023-29332": {"epss_score": 0.16445, "epss_percentile": 0.94661}, "CVE-2023-29333": {"epss_score": 0.00315, "epss_percentile": 0.54185}, "CVE-2023-29334": {"epss_score": 0.00329, "epss_percentile": 0.55305}, "CVE-2023-29335": {"epss_score": 0.00328, "epss_percentile": 0.5527}, "CVE-2023-29336": {"epss_score": 0.79462, "epss_percentile": 0.9904}, "CVE-2023-29337": {"epss_score": 0.00431, "epss_percentile": 0.62041}, "CVE-2023-29338": {"epss_score": 0.00647, "epss_percentile": 0.70182}, "CVE-2023-29340": {"epss_score": 0.00256, "epss_percentile": 0.48766}, "CVE-2023-29341": {"epss_score": 0.00835, "epss_percentile": 0.74119}, "CVE-2023-29343": {"epss_score": 0.14161, "epss_percentile": 0.94146}, "CVE-2023-29344": {"epss_score": 0.00842, "epss_percentile": 0.74241}, "CVE-2023-29345": {"epss_score": 0.00283, "epss_percentile": 0.51357}, "CVE-2023-29346": {"epss_score": 0.00211, "epss_percentile": 0.43628}, "CVE-2023-29347": {"epss_score": 0.00337, "epss_percentile": 0.56044}, "CVE-2023-29348": {"epss_score": 0.0069, "epss_percentile": 0.71246}, "CVE-2023-29349": {"epss_score": 0.00554, "epss_percentile": 0.67447}, "CVE-2023-29350": {"epss_score": 0.00173, "epss_percentile": 0.39078}, "CVE-2023-29351": {"epss_score": 0.03175, "epss_percentile": 0.86562}, "CVE-2023-29352": {"epss_score": 0.00252, "epss_percentile": 0.48355}, "CVE-2023-29353": {"epss_score": 0.00173, "epss_percentile": 0.39052}, "CVE-2023-29354": {"epss_score": 0.00256, "epss_percentile": 0.48822}, "CVE-2023-29355": {"epss_score": 0.01431, "epss_percentile": 0.80241}, "CVE-2023-29356": {"epss_score": 0.00555, "epss_percentile": 0.67457}, "CVE-2023-29357": {"epss_score": 0.94356, "epss_percentile": 0.99957}, "CVE-2023-29358": {"epss_score": 0.02601, "epss_percentile": 0.85206}, "CVE-2023-29359": {"epss_score": 0.00157, "epss_percentile": 0.3702}, "CVE-2023-29360": {"epss_score": 0.2211, "epss_percentile": 0.95596}, "CVE-2023-29361": {"epss_score": 0.0143, "epss_percentile": 0.80237}, "CVE-2023-29362": {"epss_score": 0.00506, "epss_percentile": 0.65623}, "CVE-2023-29363": {"epss_score": 0.05856, "epss_percentile": 0.90268}, "CVE-2023-29364": {"epss_score": 0.00386, "epss_percentile": 0.59276}, "CVE-2023-29365": {"epss_score": 0.01131, "epss_percentile": 0.77859}, "CVE-2023-29366": {"epss_score": 0.01131, "epss_percentile": 0.77859}, "CVE-2023-29367": {"epss_score": 0.00268, "epss_percentile": 0.50096}, "CVE-2023-29368": {"epss_score": 0.00135, "epss_percentile": 0.33999}, "CVE-2023-29369": {"epss_score": 0.03945, "epss_percentile": 0.87993}, "CVE-2023-29370": {"epss_score": 0.01131, "epss_percentile": 0.77859}, "CVE-2023-29371": {"epss_score": 0.01382, "epss_percentile": 0.79887}, "CVE-2023-29372": {"epss_score": 0.00561, "epss_percentile": 0.6768}, "CVE-2023-29373": {"epss_score": 0.00501, "epss_percentile": 0.65362}, "CVE-2023-29374": {"epss_score": 0.02994, "epss_percentile": 0.86149}, "CVE-2023-29375": {"epss_score": 0.01497, "epss_percentile": 0.80693}, "CVE-2023-29376": {"epss_score": 0.00051, "epss_percentile": 0.16175}, "CVE-2023-29380": {"epss_score": 0.01382, "epss_percentile": 0.79887}, "CVE-2023-29381": {"epss_score": 0.01399, "epss_percentile": 0.79999}, "CVE-2023-29382": {"epss_score": 0.00565, "epss_percentile": 0.67792}, "CVE-2023-29383": {"epss_score": 0.00034, "epss_percentile": 0.09799}, "CVE-2023-29384": {"epss_score": 0.04107, "epss_percentile": 0.88267}, "CVE-2023-29385": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-29386": {"epss_score": 0.0031, "epss_percentile": 0.53754}, "CVE-2023-29387": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-29388": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-29389": {"epss_score": 0.00121, "epss_percentile": 0.31877}, "CVE-2023-29400": {"epss_score": 0.00048, "epss_percentile": 0.15049}, "CVE-2023-29401": {"epss_score": 0.00476, "epss_percentile": 0.64251}, "CVE-2023-29402": {"epss_score": 0.00124, "epss_percentile": 0.32384}, "CVE-2023-29403": {"epss_score": 9e-05, "epss_percentile": 0.00716}, "CVE-2023-29404": {"epss_score": 0.00083, "epss_percentile": 0.24744}, "CVE-2023-29405": {"epss_score": 0.00326, "epss_percentile": 0.55049}, "CVE-2023-29406": {"epss_score": 0.00258, "epss_percentile": 0.49015}, "CVE-2023-29407": {"epss_score": 0.00419, "epss_percentile": 0.6137}, "CVE-2023-29408": {"epss_score": 0.00209, "epss_percentile": 0.43415}, "CVE-2023-29409": {"epss_score": 0.00112, "epss_percentile": 0.30437}, "CVE-2023-29410": {"epss_score": 0.00116, "epss_percentile": 0.31186}, "CVE-2023-29411": {"epss_score": 0.05993, "epss_percentile": 0.90389}, "CVE-2023-29412": {"epss_score": 0.04666, "epss_percentile": 0.88981}, "CVE-2023-29413": {"epss_score": 0.00262, "epss_percentile": 0.49379}, "CVE-2023-29414": {"epss_score": 0.00067, "epss_percentile": 0.21026}, "CVE-2023-29415": {"epss_score": 0.00145, "epss_percentile": 0.35457}, "CVE-2023-29416": {"epss_score": 0.00117, "epss_percentile": 0.31225}, "CVE-2023-29417": {"epss_score": 0.00123, "epss_percentile": 0.32244}, "CVE-2023-29418": {"epss_score": 0.00132, "epss_percentile": 0.33593}, "CVE-2023-29419": {"epss_score": 0.00132, "epss_percentile": 0.33593}, "CVE-2023-29420": {"epss_score": 0.00132, "epss_percentile": 0.33593}, "CVE-2023-29421": {"epss_score": 0.00134, "epss_percentile": 0.33899}, "CVE-2023-29422": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-29423": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-29424": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-29425": {"epss_score": 0.00051, "epss_percentile": 0.16103}, "CVE-2023-29426": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-29427": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-29428": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-29429": {"epss_score": 0.00111, "epss_percentile": 0.30346}, "CVE-2023-29430": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-29431": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-29432": {"epss_score": 0.00147, "epss_percentile": 0.3569}, "CVE-2023-29433": {"epss_score": 0.00142, "epss_percentile": 0.35024}, "CVE-2023-29434": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-29435": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-29436": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-29437": {"epss_score": 0.00085, "epss_percentile": 0.25031}, "CVE-2023-29438": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-29439": {"epss_score": 0.71752, "epss_percentile": 0.98679}, "CVE-2023-29440": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-29441": {"epss_score": 0.00181, "epss_percentile": 0.40105}, "CVE-2023-29442": {"epss_score": 0.04474, "epss_percentile": 0.88737}, "CVE-2023-29443": {"epss_score": 0.00545, "epss_percentile": 0.67173}, "CVE-2023-29444": {"epss_score": 0.0003, "epss_percentile": 0.08285}, "CVE-2023-29445": {"epss_score": 0.00045, "epss_percentile": 0.13773}, "CVE-2023-29446": {"epss_score": 0.00071, "epss_percentile": 0.22232}, "CVE-2023-29447": {"epss_score": 0.00053, "epss_percentile": 0.16738}, "CVE-2023-29449": {"epss_score": 0.00689, "epss_percentile": 0.71219}, "CVE-2023-29450": {"epss_score": 0.00254, "epss_percentile": 0.48516}, "CVE-2023-29451": {"epss_score": 0.001, "epss_percentile": 0.28561}, "CVE-2023-29452": {"epss_score": 0.01801, "epss_percentile": 0.82329}, "CVE-2023-29453": {"epss_score": 0.00428, "epss_percentile": 0.61946}, "CVE-2023-29454": {"epss_score": 0.00412, "epss_percentile": 0.60939}, "CVE-2023-29455": {"epss_score": 0.00586, "epss_percentile": 0.68439}, "CVE-2023-29456": {"epss_score": 0.00093, "epss_percentile": 0.26675}, "CVE-2023-29457": {"epss_score": 0.00367, "epss_percentile": 0.58133}, "CVE-2023-29458": {"epss_score": 0.00103, "epss_percentile": 0.28926}, "CVE-2023-29459": {"epss_score": 0.00158, "epss_percentile": 0.3729}, "CVE-2023-29460": {"epss_score": 0.00368, "epss_percentile": 0.58197}, "CVE-2023-29461": {"epss_score": 0.00368, "epss_percentile": 0.58197}, "CVE-2023-29462": {"epss_score": 0.00031, "epss_percentile": 0.08648}, "CVE-2023-29463": {"epss_score": 0.00026, "epss_percentile": 0.06597}, "CVE-2023-29464": {"epss_score": 0.02543, "epss_percentile": 0.85057}, "CVE-2023-29465": {"epss_score": 0.00028, "epss_percentile": 0.0725}, "CVE-2023-29468": {"epss_score": 0.53865, "epss_percentile": 0.979}, "CVE-2023-29469": {"epss_score": 0.00051, "epss_percentile": 0.16011}, "CVE-2023-29471": {"epss_score": 0.00032, "epss_percentile": 0.08815}, "CVE-2023-29473": {"epss_score": 0.00559, "epss_percentile": 0.67619}, "CVE-2023-29474": {"epss_score": 0.0067, "epss_percentile": 0.70776}, "CVE-2023-29475": {"epss_score": 0.0067, "epss_percentile": 0.70776}, "CVE-2023-29476": {"epss_score": 0.00196, "epss_percentile": 0.41787}, "CVE-2023-29478": {"epss_score": 0.05165, "epss_percentile": 0.89565}, "CVE-2023-29479": {"epss_score": 0.00078, "epss_percentile": 0.23682}, "CVE-2023-29480": {"epss_score": 0.00036, "epss_percentile": 0.10423}, "CVE-2023-29483": {"epss_score": 0.04954, "epss_percentile": 0.89326}, "CVE-2023-29484": {"epss_score": 0.00102, "epss_percentile": 0.28743}, "CVE-2023-29485": {"epss_score": 0.00058, "epss_percentile": 0.18583}, "CVE-2023-29486": {"epss_score": 0.00124, "epss_percentile": 0.32399}, "CVE-2023-29487": {"epss_score": 0.00073, "epss_percentile": 0.22592}, "CVE-2023-29489": {"epss_score": 0.92926, "epss_percentile": 0.99761}, "CVE-2023-29491": {"epss_score": 0.00066, "epss_percentile": 0.2076}, "CVE-2023-29492": {"epss_score": 0.18067, "epss_percentile": 0.94951}, "CVE-2023-29494": {"epss_score": 0.00035, "epss_percentile": 0.10067}, "CVE-2023-29495": {"epss_score": 0.00055, "epss_percentile": 0.17565}, "CVE-2023-29497": {"epss_score": 0.00119, "epss_percentile": 0.3161}, "CVE-2023-29498": {"epss_score": 0.00022, "epss_percentile": 0.05023}, "CVE-2023-29499": {"epss_score": 0.0012, "epss_percentile": 0.31772}, "CVE-2023-29500": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2023-29501": {"epss_score": 0.00181, "epss_percentile": 0.40016}, "CVE-2023-29502": {"epss_score": 0.00043, "epss_percentile": 0.13181}, "CVE-2023-29503": {"epss_score": 0.00052, "epss_percentile": 0.16536}, "CVE-2023-29504": {"epss_score": 0.00144, "epss_percentile": 0.35344}, "CVE-2023-29505": {"epss_score": 0.00371, "epss_percentile": 0.5836}, "CVE-2023-29506": {"epss_score": 0.41315, "epss_percentile": 0.97265}, "CVE-2023-29507": {"epss_score": 0.00708, "epss_percentile": 0.71676}, "CVE-2023-29508": {"epss_score": 0.00524, "epss_percentile": 0.66339}, "CVE-2023-29509": {"epss_score": 0.33327, "epss_percentile": 0.96763}, "CVE-2023-29510": {"epss_score": 0.03016, "epss_percentile": 0.86215}, "CVE-2023-29511": {"epss_score": 0.02138, "epss_percentile": 0.83741}, "CVE-2023-29512": {"epss_score": 0.02151, "epss_percentile": 0.83784}, "CVE-2023-29513": {"epss_score": 0.00553, "epss_percentile": 0.67432}, "CVE-2023-29514": {"epss_score": 0.0377, "epss_percentile": 0.877}, "CVE-2023-29515": {"epss_score": 0.01341, "epss_percentile": 0.79583}, "CVE-2023-29516": {"epss_score": 0.20283, "epss_percentile": 0.95313}, "CVE-2023-29517": {"epss_score": 0.01924, "epss_percentile": 0.82916}, "CVE-2023-29518": {"epss_score": 0.02151, "epss_percentile": 0.83784}, "CVE-2023-29519": {"epss_score": 0.12472, "epss_percentile": 0.93683}, "CVE-2023-29520": {"epss_score": 0.00162, "epss_percentile": 0.37622}, "CVE-2023-29521": {"epss_score": 0.01192, "epss_percentile": 0.784}, "CVE-2023-29522": {"epss_score": 0.02827, "epss_percentile": 0.85766}, "CVE-2023-29523": {"epss_score": 0.14654, "epss_percentile": 0.94258}, "CVE-2023-29524": {"epss_score": 0.422, "epss_percentile": 0.97318}, "CVE-2023-29525": {"epss_score": 0.24029, "epss_percentile": 0.95848}, "CVE-2023-29526": {"epss_score": 0.02677, "epss_percentile": 0.85406}, "CVE-2023-29527": {"epss_score": 0.00641, "epss_percentile": 0.69988}, "CVE-2023-29528": {"epss_score": 0.04252, "epss_percentile": 0.88454}, "CVE-2023-29529": {"epss_score": 0.00227, "epss_percentile": 0.45366}, "CVE-2023-29530": {"epss_score": 0.00179, "epss_percentile": 0.39809}, "CVE-2023-29531": {"epss_score": 0.01069, "epss_percentile": 0.77246}, "CVE-2023-29532": {"epss_score": 0.00075, "epss_percentile": 0.22919}, "CVE-2023-29533": {"epss_score": 0.0013, "epss_percentile": 0.33252}, "CVE-2023-29534": {"epss_score": 0.00454, "epss_percentile": 0.63271}, "CVE-2023-29535": {"epss_score": 0.00393, "epss_percentile": 0.59734}, "CVE-2023-29536": {"epss_score": 0.00178, "epss_percentile": 0.39689}, "CVE-2023-29537": {"epss_score": 0.00186, "epss_percentile": 0.40618}, "CVE-2023-29538": {"epss_score": 0.00124, "epss_percentile": 0.32432}, "CVE-2023-29539": {"epss_score": 0.00196, "epss_percentile": 0.41732}, "CVE-2023-29540": {"epss_score": 0.00139, "epss_percentile": 0.34558}, "CVE-2023-29541": {"epss_score": 0.00187, "epss_percentile": 0.40757}, "CVE-2023-29542": {"epss_score": 0.00107, "epss_percentile": 0.29689}, "CVE-2023-29543": {"epss_score": 0.00214, "epss_percentile": 0.43969}, "CVE-2023-29544": {"epss_score": 0.0015, "epss_percentile": 0.36058}, "CVE-2023-29545": {"epss_score": 0.00344, "epss_percentile": 0.56506}, "CVE-2023-29546": {"epss_score": 0.00292, "epss_percentile": 0.52274}, "CVE-2023-29547": {"epss_score": 0.00153, "epss_percentile": 0.36537}, "CVE-2023-29548": {"epss_score": 0.00129, "epss_percentile": 0.3316}, "CVE-2023-29549": {"epss_score": 0.00078, "epss_percentile": 0.23649}, "CVE-2023-29550": {"epss_score": 0.00178, "epss_percentile": 0.39689}, "CVE-2023-29551": {"epss_score": 0.00209, "epss_percentile": 0.43318}, "CVE-2023-29552": {"epss_score": 0.92962, "epss_percentile": 0.99764}, "CVE-2023-29562": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-29566": {"epss_score": 0.02172, "epss_percentile": 0.83874}, "CVE-2023-29569": {"epss_score": 0.0003, "epss_percentile": 0.08206}, "CVE-2023-29570": {"epss_score": 0.00023, "epss_percentile": 0.05484}, "CVE-2023-29571": {"epss_score": 0.00035, "epss_percentile": 0.09891}, "CVE-2023-29573": {"epss_score": 0.00059, "epss_percentile": 0.18883}, "CVE-2023-29574": {"epss_score": 0.00033, "epss_percentile": 0.09298}, "CVE-2023-29575": {"epss_score": 0.00054, "epss_percentile": 0.17041}, "CVE-2023-29576": {"epss_score": 0.00053, "epss_percentile": 0.16796}, "CVE-2023-29578": {"epss_score": 0.00173, "epss_percentile": 0.39056}, "CVE-2023-29579": {"epss_score": 0.00028, "epss_percentile": 0.0753}, "CVE-2023-29580": {"epss_score": 0.00112, "epss_percentile": 0.30557}, "CVE-2023-29581": {"epss_score": 0.00028, "epss_percentile": 0.0758}, "CVE-2023-29582": {"epss_score": 0.0003, "epss_percentile": 0.08294}, "CVE-2023-29583": {"epss_score": 0.00037, "epss_percentile": 0.11005}, "CVE-2023-29584": {"epss_score": 0.00257, "epss_percentile": 0.48943}, "CVE-2023-29586": {"epss_score": 0.00034, "epss_percentile": 0.09484}, "CVE-2023-29596": {"epss_score": 0.00034, "epss_percentile": 0.09751}, "CVE-2023-29597": {"epss_score": 0.00077, "epss_percentile": 0.23357}, "CVE-2023-29598": {"epss_score": 0.00077, "epss_percentile": 0.23347}, "CVE-2023-29621": {"epss_score": 0.00153, "epss_percentile": 0.36628}, "CVE-2023-29622": {"epss_score": 0.18602, "epss_percentile": 0.95041}, "CVE-2023-29623": {"epss_score": 0.12517, "epss_percentile": 0.93704}, "CVE-2023-29625": {"epss_score": 0.00153, "epss_percentile": 0.36628}, "CVE-2023-29626": {"epss_score": 0.00078, "epss_percentile": 0.23591}, "CVE-2023-29627": {"epss_score": 0.00153, "epss_percentile": 0.36628}, "CVE-2023-29629": {"epss_score": 0.008, "epss_percentile": 0.73537}, "CVE-2023-29630": {"epss_score": 0.008, "epss_percentile": 0.73537}, "CVE-2023-29631": {"epss_score": 0.0014, "epss_percentile": 0.34692}, "CVE-2023-29632": {"epss_score": 0.008, "epss_percentile": 0.73537}, "CVE-2023-29635": {"epss_score": 0.00574, "epss_percentile": 0.6807}, "CVE-2023-29636": {"epss_score": 0.00452, "epss_percentile": 0.63196}, "CVE-2023-29637": {"epss_score": 0.00084, "epss_percentile": 0.24885}, "CVE-2023-29638": {"epss_score": 0.00421, "epss_percentile": 0.61492}, "CVE-2023-29639": {"epss_score": 0.00421, "epss_percentile": 0.61492}, "CVE-2023-29641": {"epss_score": 0.0044, "epss_percentile": 0.62639}, "CVE-2023-29643": {"epss_score": 0.00432, "epss_percentile": 0.62127}, "CVE-2023-29656": {"epss_score": 0.00027, "epss_percentile": 0.06885}, "CVE-2023-29657": {"epss_score": 0.00177, "epss_percentile": 0.39496}, "CVE-2023-29659": {"epss_score": 0.00136, "epss_percentile": 0.34195}, "CVE-2023-29665": {"epss_score": 0.01957, "epss_percentile": 0.83043}, "CVE-2023-29680": {"epss_score": 0.00018, "epss_percentile": 0.03933}, "CVE-2023-29681": {"epss_score": 0.00018, "epss_percentile": 0.03933}, "CVE-2023-29689": {"epss_score": 0.52298, "epss_percentile": 0.97818}, "CVE-2023-29693": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-29696": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-29707": {"epss_score": 0.00075, "epss_percentile": 0.22954}, "CVE-2023-29708": {"epss_score": 0.04963, "epss_percentile": 0.89338}, "CVE-2023-29709": {"epss_score": 0.0003, "epss_percentile": 0.08068}, "CVE-2023-29711": {"epss_score": 0.00231, "epss_percentile": 0.45859}, "CVE-2023-29712": {"epss_score": 0.00318, "epss_percentile": 0.5446}, "CVE-2023-29713": {"epss_score": 0.00318, "epss_percentile": 0.5446}, "CVE-2023-29714": {"epss_score": 0.00318, "epss_percentile": 0.5446}, "CVE-2023-29720": {"epss_score": 0.00091, "epss_percentile": 0.26277}, "CVE-2023-29721": {"epss_score": 0.00219, "epss_percentile": 0.44472}, "CVE-2023-29722": {"epss_score": 0.00136, "epss_percentile": 0.34122}, "CVE-2023-29723": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-29724": {"epss_score": 0.00054, "epss_percentile": 0.17053}, "CVE-2023-29725": {"epss_score": 0.00026, "epss_percentile": 0.06623}, "CVE-2023-29726": {"epss_score": 0.00226, "epss_percentile": 0.45315}, "CVE-2023-29727": {"epss_score": 0.0012, "epss_percentile": 0.31811}, "CVE-2023-29728": {"epss_score": 0.00409, "epss_percentile": 0.60754}, "CVE-2023-29731": {"epss_score": 0.00082, "epss_percentile": 0.24567}, "CVE-2023-29732": {"epss_score": 0.00291, "epss_percentile": 0.52147}, "CVE-2023-29733": {"epss_score": 0.00045, "epss_percentile": 0.13951}, "CVE-2023-29734": {"epss_score": 0.00296, "epss_percentile": 0.52563}, "CVE-2023-29735": {"epss_score": 0.00056, "epss_percentile": 0.17795}, "CVE-2023-29736": {"epss_score": 0.00248, "epss_percentile": 0.47953}, "CVE-2023-29737": {"epss_score": 0.00066, "epss_percentile": 0.20936}, "CVE-2023-29738": {"epss_score": 0.00195, "epss_percentile": 0.4169}, "CVE-2023-29739": {"epss_score": 0.00158, "epss_percentile": 0.3715}, "CVE-2023-29740": {"epss_score": 0.00076, "epss_percentile": 0.2316}, "CVE-2023-29741": {"epss_score": 0.00111, "epss_percentile": 0.3028}, "CVE-2023-29742": {"epss_score": 0.0014, "epss_percentile": 0.34749}, "CVE-2023-29743": {"epss_score": 0.00175, "epss_percentile": 0.3927}, "CVE-2023-29745": {"epss_score": 0.00053, "epss_percentile": 0.16859}, "CVE-2023-29746": {"epss_score": 0.00468, "epss_percentile": 0.63885}, "CVE-2023-29747": {"epss_score": 0.00346, "epss_percentile": 0.56634}, "CVE-2023-29748": {"epss_score": 0.00173, "epss_percentile": 0.39067}, "CVE-2023-29749": {"epss_score": 0.00051, "epss_percentile": 0.15989}, "CVE-2023-29751": {"epss_score": 0.00027, "epss_percentile": 0.07005}, "CVE-2023-29752": {"epss_score": 0.00079, "epss_percentile": 0.23894}, "CVE-2023-29753": {"epss_score": 0.00027, "epss_percentile": 0.07005}, "CVE-2023-29755": {"epss_score": 0.00088, "epss_percentile": 0.25783}, "CVE-2023-29756": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2023-29757": {"epss_score": 0.00097, "epss_percentile": 0.27549}, "CVE-2023-29758": {"epss_score": 0.00036, "epss_percentile": 0.10502}, "CVE-2023-29759": {"epss_score": 0.00036, "epss_percentile": 0.10502}, "CVE-2023-29761": {"epss_score": 0.00036, "epss_percentile": 0.10502}, "CVE-2023-29766": {"epss_score": 0.00081, "epss_percentile": 0.24327}, "CVE-2023-29767": {"epss_score": 0.00044, "epss_percentile": 0.13502}, "CVE-2023-29770": {"epss_score": 0.00155, "epss_percentile": 0.36877}, "CVE-2023-29772": {"epss_score": 0.02562, "epss_percentile": 0.85109}, "CVE-2023-29774": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-29778": {"epss_score": 0.2538, "epss_percentile": 0.96022}, "CVE-2023-29779": {"epss_score": 0.00317, "epss_percentile": 0.54382}, "CVE-2023-29780": {"epss_score": 0.00246, "epss_percentile": 0.47738}, "CVE-2023-29790": {"epss_score": 0.00068, "epss_percentile": 0.21338}, "CVE-2023-29791": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-29798": {"epss_score": 0.01389, "epss_percentile": 0.79927}, "CVE-2023-29799": {"epss_score": 0.01389, "epss_percentile": 0.79927}, "CVE-2023-29800": {"epss_score": 0.01389, "epss_percentile": 0.79927}, "CVE-2023-29801": {"epss_score": 0.01389, "epss_percentile": 0.79927}, "CVE-2023-29802": {"epss_score": 0.01389, "epss_percentile": 0.79927}, "CVE-2023-29803": {"epss_score": 0.01389, "epss_percentile": 0.79927}, "CVE-2023-29804": {"epss_score": 0.47017, "epss_percentile": 0.97565}, "CVE-2023-29805": {"epss_score": 0.0109, "epss_percentile": 0.7745}, "CVE-2023-29808": {"epss_score": 0.01007, "epss_percentile": 0.76564}, "CVE-2023-29809": {"epss_score": 0.02438, "epss_percentile": 0.84744}, "CVE-2023-29815": {"epss_score": 0.00073, "epss_percentile": 0.22493}, "CVE-2023-29818": {"epss_score": 5e-05, "epss_percentile": 0.00237}, "CVE-2023-29819": {"epss_score": 0.00013, "epss_percentile": 0.01649}, "CVE-2023-29820": {"epss_score": 0.00025, "epss_percentile": 0.06258}, "CVE-2023-29824": {"epss_score": 0.00374, "epss_percentile": 0.58541}, "CVE-2023-29827": {"epss_score": 0.77665, "epss_percentile": 0.98947}, "CVE-2023-29835": {"epss_score": 0.00214, "epss_percentile": 0.43966}, "CVE-2023-29836": {"epss_score": 0.00322, "epss_percentile": 0.54829}, "CVE-2023-29837": {"epss_score": 0.00095, "epss_percentile": 0.27173}, "CVE-2023-29838": {"epss_score": 0.00032, "epss_percentile": 0.08813}, "CVE-2023-29839": {"epss_score": 0.00283, "epss_percentile": 0.5136}, "CVE-2023-29842": {"epss_score": 0.00085, "epss_percentile": 0.25039}, "CVE-2023-29847": {"epss_score": 0.00098, "epss_percentile": 0.27713}, "CVE-2023-29848": {"epss_score": 0.00182, "epss_percentile": 0.40276}, "CVE-2023-29849": {"epss_score": 0.00167, "epss_percentile": 0.38379}, "CVE-2023-29850": {"epss_score": 0.00241, "epss_percentile": 0.47261}, "CVE-2023-29854": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-29855": {"epss_score": 0.00109, "epss_percentile": 0.29949}, "CVE-2023-29856": {"epss_score": 0.00234, "epss_percentile": 0.46084}, "CVE-2023-29857": {"epss_score": 0.00084, "epss_percentile": 0.2493}, "CVE-2023-29860": {"epss_score": 0.00068, "epss_percentile": 0.21263}, "CVE-2023-29861": {"epss_score": 0.01973, "epss_percentile": 0.8311}, "CVE-2023-29862": {"epss_score": 0.01973, "epss_percentile": 0.8311}, "CVE-2023-29863": {"epss_score": 0.00079, "epss_percentile": 0.23996}, "CVE-2023-29867": {"epss_score": 0.00259, "epss_percentile": 0.49076}, "CVE-2023-29868": {"epss_score": 0.00141, "epss_percentile": 0.34833}, "CVE-2023-29881": {"epss_score": 0.00125, "epss_percentile": 0.32483}, "CVE-2023-29887": {"epss_score": 0.88637, "epss_percentile": 0.99481}, "CVE-2023-29905": {"epss_score": 0.00064, "epss_percentile": 0.20203}, "CVE-2023-29906": {"epss_score": 0.00064, "epss_percentile": 0.20203}, "CVE-2023-29907": {"epss_score": 0.00064, "epss_percentile": 0.20203}, "CVE-2023-29908": {"epss_score": 0.00064, "epss_percentile": 0.20203}, "CVE-2023-29909": {"epss_score": 0.00064, "epss_percentile": 0.20203}, "CVE-2023-29910": {"epss_score": 0.00064, "epss_percentile": 0.20203}, "CVE-2023-29911": {"epss_score": 0.00064, "epss_percentile": 0.20203}, "CVE-2023-29912": {"epss_score": 0.00064, "epss_percentile": 0.20203}, "CVE-2023-29913": {"epss_score": 0.00064, "epss_percentile": 0.20203}, "CVE-2023-29914": {"epss_score": 0.00064, "epss_percentile": 0.20203}, "CVE-2023-29915": {"epss_score": 0.00064, "epss_percentile": 0.20203}, "CVE-2023-29916": {"epss_score": 0.00061, "epss_percentile": 0.19531}, "CVE-2023-29917": {"epss_score": 0.00061, "epss_percentile": 0.19531}, "CVE-2023-29918": {"epss_score": 0.05473, "epss_percentile": 0.8991}, "CVE-2023-29919": {"epss_score": 0.91855, "epss_percentile": 0.99673}, "CVE-2023-29921": {"epss_score": 0.0017, "epss_percentile": 0.38766}, "CVE-2023-29922": {"epss_score": 0.90264, "epss_percentile": 0.99572}, "CVE-2023-29923": {"epss_score": 0.82151, "epss_percentile": 0.99176}, "CVE-2023-29924": {"epss_score": 0.01362, "epss_percentile": 0.79756}, "CVE-2023-29926": {"epss_score": 0.01506, "epss_percentile": 0.80745}, "CVE-2023-29927": {"epss_score": 0.00015, "epss_percentile": 0.02394}, "CVE-2023-29929": {"epss_score": 0.03618, "epss_percentile": 0.87439}, "CVE-2023-29930": {"epss_score": 0.18773, "epss_percentile": 0.95067}, "CVE-2023-29931": {"epss_score": 0.00393, "epss_percentile": 0.5972}, "CVE-2023-29932": {"epss_score": 0.00026, "epss_percentile": 0.06426}, "CVE-2023-29933": {"epss_score": 0.00016, "epss_percentile": 0.02858}, "CVE-2023-29934": {"epss_score": 0.00026, "epss_percentile": 0.06426}, "CVE-2023-29935": {"epss_score": 9e-05, "epss_percentile": 0.00703}, "CVE-2023-29939": {"epss_score": 0.00025, "epss_percentile": 0.06207}, "CVE-2023-29941": {"epss_score": 0.00031, "epss_percentile": 0.08414}, "CVE-2023-29942": {"epss_score": 0.00019, "epss_percentile": 0.04298}, "CVE-2023-29944": {"epss_score": 0.0488, "epss_percentile": 0.89246}, "CVE-2023-29950": {"epss_score": 0.00078, "epss_percentile": 0.2377}, "CVE-2023-29961": {"epss_score": 0.00718, "epss_percentile": 0.71919}, "CVE-2023-29962": {"epss_score": 0.00098, "epss_percentile": 0.2779}, "CVE-2023-29963": {"epss_score": 0.01121, "epss_percentile": 0.77768}, "CVE-2023-29973": {"epss_score": 0.00261, "epss_percentile": 0.49267}, "CVE-2023-29974": {"epss_score": 0.0027, "epss_percentile": 0.50194}, "CVE-2023-29975": {"epss_score": 0.00082, "epss_percentile": 0.24545}, "CVE-2023-29983": {"epss_score": 0.3053, "epss_percentile": 0.96548}, "CVE-2023-29984": {"epss_score": 0.00207, "epss_percentile": 0.43163}, "CVE-2023-29985": {"epss_score": 0.00211, "epss_percentile": 0.43672}, "CVE-2023-29986": {"epss_score": 0.00279, "epss_percentile": 0.50933}, "CVE-2023-29994": {"epss_score": 0.00078, "epss_percentile": 0.236}, "CVE-2023-29995": {"epss_score": 0.00078, "epss_percentile": 0.236}, "CVE-2023-29996": {"epss_score": 0.00069, "epss_percentile": 0.21489}, "CVE-2023-29998": {"epss_score": 0.00071, "epss_percentile": 0.22199}, "CVE-2023-2000": {"epss_score": 0.00169, "epss_percentile": 0.38544}, "CVE-2023-2001": {"epss_score": 0.00419, "epss_percentile": 0.61387}, "CVE-2023-2002": {"epss_score": 0.00422, "epss_percentile": 0.61553}, "CVE-2023-2003": {"epss_score": 0.00274, "epss_percentile": 0.50536}, "CVE-2023-2005": {"epss_score": 0.00065, "epss_percentile": 0.20548}, "CVE-2023-2006": {"epss_score": 0.00019, "epss_percentile": 0.04051}, "CVE-2023-2007": {"epss_score": 0.00028, "epss_percentile": 0.07491}, "CVE-2023-2008": {"epss_score": 0.0105, "epss_percentile": 0.77073}, "CVE-2023-2009": {"epss_score": 0.01944, "epss_percentile": 0.82998}, "CVE-2023-2010": {"epss_score": 0.00069, "epss_percentile": 0.21525}, "CVE-2023-2013": {"epss_score": 0.00139, "epss_percentile": 0.34653}, "CVE-2023-2014": {"epss_score": 0.0007, "epss_percentile": 0.21651}, "CVE-2023-2015": {"epss_score": 0.07671, "epss_percentile": 0.91614}, "CVE-2023-2017": {"epss_score": 0.01388, "epss_percentile": 0.79922}, "CVE-2023-2019": {"epss_score": 0.00016, "epss_percentile": 0.02888}, "CVE-2023-2020": {"epss_score": 0.00102, "epss_percentile": 0.28743}, "CVE-2023-2021": {"epss_score": 0.00073, "epss_percentile": 0.2248}, "CVE-2023-2022": {"epss_score": 0.00071, "epss_percentile": 0.22177}, "CVE-2023-2023": {"epss_score": 0.83097, "epss_percentile": 0.99231}, "CVE-2023-2024": {"epss_score": 0.00188, "epss_percentile": 0.40853}, "CVE-2023-2025": {"epss_score": 0.00103, "epss_percentile": 0.29096}, "CVE-2023-2026": {"epss_score": 0.00086, "epss_percentile": 0.25276}, "CVE-2023-2027": {"epss_score": 0.00276, "epss_percentile": 0.5074}, "CVE-2023-2028": {"epss_score": 0.00073, "epss_percentile": 0.22557}, "CVE-2023-2029": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-2030": {"epss_score": 0.00034, "epss_percentile": 0.09731}, "CVE-2023-2031": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-2032": {"epss_score": 0.00207, "epss_percentile": 0.43137}, "CVE-2023-2033": {"epss_score": 0.20463, "epss_percentile": 0.95349}, "CVE-2023-2034": {"epss_score": 0.08462, "epss_percentile": 0.92065}, "CVE-2023-2035": {"epss_score": 0.00068, "epss_percentile": 0.21354}, "CVE-2023-2036": {"epss_score": 0.00057, "epss_percentile": 0.18094}, "CVE-2023-2037": {"epss_score": 0.0007, "epss_percentile": 0.21958}, "CVE-2023-2038": {"epss_score": 0.00057, "epss_percentile": 0.18094}, "CVE-2023-2039": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-2040": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-2041": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-2042": {"epss_score": 0.00122, "epss_percentile": 0.32076}, "CVE-2023-2043": {"epss_score": 0.00047, "epss_percentile": 0.14483}, "CVE-2023-2044": {"epss_score": 0.00074, "epss_percentile": 0.22738}, "CVE-2023-2045": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-2046": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-2047": {"epss_score": 0.00057, "epss_percentile": 0.18094}, "CVE-2023-2048": {"epss_score": 0.00057, "epss_percentile": 0.18094}, "CVE-2023-2049": {"epss_score": 0.00057, "epss_percentile": 0.18094}, "CVE-2023-2050": {"epss_score": 0.00072, "epss_percentile": 0.22325}, "CVE-2023-2051": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-2052": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-2053": {"epss_score": 0.00058, "epss_percentile": 0.18447}, "CVE-2023-2054": {"epss_score": 0.00058, "epss_percentile": 0.18447}, "CVE-2023-2055": {"epss_score": 0.00095, "epss_percentile": 0.27191}, "CVE-2023-2056": {"epss_score": 0.00121, "epss_percentile": 0.31926}, "CVE-2023-2057": {"epss_score": 0.00076, "epss_percentile": 0.23124}, "CVE-2023-2058": {"epss_score": 0.00089, "epss_percentile": 0.2591}, "CVE-2023-2059": {"epss_score": 0.04964, "epss_percentile": 0.8934}, "CVE-2023-2060": {"epss_score": 0.00322, "epss_percentile": 0.5483}, "CVE-2023-2061": {"epss_score": 0.00424, "epss_percentile": 0.61684}, "CVE-2023-2062": {"epss_score": 0.00056, "epss_percentile": 0.17749}, "CVE-2023-2063": {"epss_score": 0.00359, "epss_percentile": 0.57568}, "CVE-2023-2064": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-2065": {"epss_score": 0.00018, "epss_percentile": 0.03981}, "CVE-2023-2066": {"epss_score": 0.0006, "epss_percentile": 0.19171}, "CVE-2023-2067": {"epss_score": 0.00066, "epss_percentile": 0.20859}, "CVE-2023-2068": {"epss_score": 0.72576, "epss_percentile": 0.98716}, "CVE-2023-2069": {"epss_score": 0.00217, "epss_percentile": 0.44326}, "CVE-2023-2071": {"epss_score": 0.00666, "epss_percentile": 0.70695}, "CVE-2023-2072": {"epss_score": 0.00661, "epss_percentile": 0.70575}, "CVE-2023-2073": {"epss_score": 0.00062, "epss_percentile": 0.19555}, "CVE-2023-2074": {"epss_score": 0.00104, "epss_percentile": 0.29104}, "CVE-2023-2075": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-2076": {"epss_score": 0.00124, "epss_percentile": 0.32458}, "CVE-2023-2077": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2023-2078": {"epss_score": 0.00041, "epss_percentile": 0.1223}, "CVE-2023-2079": {"epss_score": 0.00046, "epss_percentile": 0.14427}, "CVE-2023-2080": {"epss_score": 0.00202, "epss_percentile": 0.42466}, "CVE-2023-2082": {"epss_score": 0.0009, "epss_percentile": 0.26131}, "CVE-2023-2083": {"epss_score": 0.00076, "epss_percentile": 0.23075}, "CVE-2023-2084": {"epss_score": 0.00105, "epss_percentile": 0.29288}, "CVE-2023-2085": {"epss_score": 0.00117, "epss_percentile": 0.31331}, "CVE-2023-2086": {"epss_score": 0.00117, "epss_percentile": 0.31331}, "CVE-2023-2087": {"epss_score": 0.00077, "epss_percentile": 0.23536}, "CVE-2023-2088": {"epss_score": 0.00162, "epss_percentile": 0.37654}, "CVE-2023-2089": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-2090": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-2091": {"epss_score": 0.00247, "epss_percentile": 0.47884}, "CVE-2023-2092": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-2093": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-2094": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-2095": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-2096": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2023-2097": {"epss_score": 0.0007, "epss_percentile": 0.21958}, "CVE-2023-2098": {"epss_score": 0.00093, "epss_percentile": 0.26738}, "CVE-2023-2099": {"epss_score": 0.00086, "epss_percentile": 0.25321}, "CVE-2023-2100": {"epss_score": 0.00086, "epss_percentile": 0.25321}, "CVE-2023-2101": {"epss_score": 0.00146, "epss_percentile": 0.35592}, "CVE-2023-2102": {"epss_score": 0.00093, "epss_percentile": 0.26613}, "CVE-2023-2103": {"epss_score": 0.00077, "epss_percentile": 0.23469}, "CVE-2023-2104": {"epss_score": 0.00075, "epss_percentile": 0.23049}, "CVE-2023-2105": {"epss_score": 0.00547, "epss_percentile": 0.67232}, "CVE-2023-2106": {"epss_score": 0.00072, "epss_percentile": 0.22382}, "CVE-2023-2107": {"epss_score": 0.00072, "epss_percentile": 0.22325}, "CVE-2023-2108": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2109": {"epss_score": 0.00095, "epss_percentile": 0.27198}, "CVE-2023-2110": {"epss_score": 0.00079, "epss_percentile": 0.23916}, "CVE-2023-2111": {"epss_score": 0.0022, "epss_percentile": 0.44621}, "CVE-2023-2112": {"epss_score": 0.00027, "epss_percentile": 0.07138}, "CVE-2023-2113": {"epss_score": 0.00076, "epss_percentile": 0.2308}, "CVE-2023-2114": {"epss_score": 0.75568, "epss_percentile": 0.98854}, "CVE-2023-2117": {"epss_score": 0.00109, "epss_percentile": 0.29979}, "CVE-2023-2118": {"epss_score": 0.00229, "epss_percentile": 0.45653}, "CVE-2023-2119": {"epss_score": 0.0092, "epss_percentile": 0.75475}, "CVE-2023-2120": {"epss_score": 0.0092, "epss_percentile": 0.75475}, "CVE-2023-2121": {"epss_score": 0.00486, "epss_percentile": 0.64771}, "CVE-2023-2122": {"epss_score": 0.22608, "epss_percentile": 0.95657}, "CVE-2023-2123": {"epss_score": 0.15708, "epss_percentile": 0.94488}, "CVE-2023-2124": {"epss_score": 0.00019, "epss_percentile": 0.0438}, "CVE-2023-2130": {"epss_score": 0.81183, "epss_percentile": 0.99127}, "CVE-2023-2131": {"epss_score": 0.00789, "epss_percentile": 0.73363}, "CVE-2023-2132": {"epss_score": 0.0135, "epss_percentile": 0.79675}, "CVE-2023-2133": {"epss_score": 0.00655, "epss_percentile": 0.70367}, "CVE-2023-2134": {"epss_score": 0.00655, "epss_percentile": 0.70367}, "CVE-2023-2135": {"epss_score": 0.00488, "epss_percentile": 0.6486}, "CVE-2023-2136": {"epss_score": 0.00448, "epss_percentile": 0.63031}, "CVE-2023-2137": {"epss_score": 0.00353, "epss_percentile": 0.57161}, "CVE-2023-2138": {"epss_score": 0.00089, "epss_percentile": 0.25977}, "CVE-2023-2139": {"epss_score": 0.00297, "epss_percentile": 0.52696}, "CVE-2023-2140": {"epss_score": 0.00162, "epss_percentile": 0.37619}, "CVE-2023-2141": {"epss_score": 0.04096, "epss_percentile": 0.8825}, "CVE-2023-2142": {"epss_score": 0.0012, "epss_percentile": 0.31711}, "CVE-2023-2143": {"epss_score": 0.00171, "epss_percentile": 0.38768}, "CVE-2023-2144": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2145": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2146": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2147": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2148": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2149": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2150": {"epss_score": 0.00055, "epss_percentile": 0.17438}, "CVE-2023-2151": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2152": {"epss_score": 0.00103, "epss_percentile": 0.29057}, "CVE-2023-2153": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2154": {"epss_score": 0.0006, "epss_percentile": 0.18932}, "CVE-2023-2155": {"epss_score": 0.00061, "epss_percentile": 0.19267}, "CVE-2023-2156": {"epss_score": 0.00473, "epss_percentile": 0.64088}, "CVE-2023-2157": {"epss_score": 0.00023, "epss_percentile": 0.05325}, "CVE-2023-2158": {"epss_score": 0.00216, "epss_percentile": 0.44189}, "CVE-2023-2159": {"epss_score": 0.00128, "epss_percentile": 0.33003}, "CVE-2023-2160": {"epss_score": 0.00056, "epss_percentile": 0.17747}, "CVE-2023-2161": {"epss_score": 0.00032, "epss_percentile": 0.09043}, "CVE-2023-2162": {"epss_score": 8e-05, "epss_percentile": 0.00551}, "CVE-2023-2163": {"epss_score": 0.00168, "epss_percentile": 0.38437}, "CVE-2023-2164": {"epss_score": 0.46485, "epss_percentile": 0.97548}, "CVE-2023-2166": {"epss_score": 9e-05, "epss_percentile": 0.006}, "CVE-2023-2168": {"epss_score": 0.00123, "epss_percentile": 0.32315}, "CVE-2023-2169": {"epss_score": 0.00123, "epss_percentile": 0.32315}, "CVE-2023-2170": {"epss_score": 0.00123, "epss_percentile": 0.32315}, "CVE-2023-2171": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-2172": {"epss_score": 0.00095, "epss_percentile": 0.27164}, "CVE-2023-2173": {"epss_score": 0.00095, "epss_percentile": 0.27164}, "CVE-2023-2174": {"epss_score": 0.0005, "epss_percentile": 0.15829}, "CVE-2023-2176": {"epss_score": 0.00018, "epss_percentile": 0.03563}, "CVE-2023-2177": {"epss_score": 0.00011, "epss_percentile": 0.00997}, "CVE-2023-2178": {"epss_score": 0.02873, "epss_percentile": 0.85877}, "CVE-2023-2179": {"epss_score": 0.00067, "epss_percentile": 0.21044}, "CVE-2023-2180": {"epss_score": 0.00412, "epss_percentile": 0.60918}, "CVE-2023-2181": {"epss_score": 0.0035, "epss_percentile": 0.56959}, "CVE-2023-2182": {"epss_score": 0.00326, "epss_percentile": 0.55071}, "CVE-2023-2183": {"epss_score": 0.00879, "epss_percentile": 0.74837}, "CVE-2023-2184": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-2186": {"epss_score": 0.00231, "epss_percentile": 0.45844}, "CVE-2023-2187": {"epss_score": 0.00101, "epss_percentile": 0.28659}, "CVE-2023-2188": {"epss_score": 0.00291, "epss_percentile": 0.52148}, "CVE-2023-2189": {"epss_score": 0.00049, "epss_percentile": 0.15478}, "CVE-2023-2190": {"epss_score": 0.00127, "epss_percentile": 0.32885}, "CVE-2023-2191": {"epss_score": 0.00072, "epss_percentile": 0.22379}, "CVE-2023-2193": {"epss_score": 0.0013, "epss_percentile": 0.33257}, "CVE-2023-2194": {"epss_score": 0.00015, "epss_percentile": 0.02331}, "CVE-2023-2195": {"epss_score": 0.00476, "epss_percentile": 0.64267}, "CVE-2023-2196": {"epss_score": 0.00653, "epss_percentile": 0.70331}, "CVE-2023-2197": {"epss_score": 0.00026, "epss_percentile": 0.06669}, "CVE-2023-2198": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2023-2199": {"epss_score": 0.01916, "epss_percentile": 0.82858}, "CVE-2023-2200": {"epss_score": 0.00946, "epss_percentile": 0.75809}, "CVE-2023-2201": {"epss_score": 0.00177, "epss_percentile": 0.39628}, "CVE-2023-2202": {"epss_score": 0.00073, "epss_percentile": 0.22546}, "CVE-2023-2203": {"epss_score": 0.00101, "epss_percentile": 0.28617}, "CVE-2023-2204": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2205": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2206": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2207": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2208": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2209": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2210": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2211": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2212": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2213": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2214": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2215": {"epss_score": 0.03312, "epss_percentile": 0.86895}, "CVE-2023-2216": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2217": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2218": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2219": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2220": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2023-2221": {"epss_score": 0.00189, "epss_percentile": 0.4097}, "CVE-2023-2223": {"epss_score": 0.00105, "epss_percentile": 0.29357}, "CVE-2023-2224": {"epss_score": 0.00924, "epss_percentile": 0.75525}, "CVE-2023-2225": {"epss_score": 0.00066, "epss_percentile": 0.20925}, "CVE-2023-2226": {"epss_score": 0.00042, "epss_percentile": 0.1283}, "CVE-2023-2227": {"epss_score": 0.90923, "epss_percentile": 0.99609}, "CVE-2023-2228": {"epss_score": 0.00061, "epss_percentile": 0.19268}, "CVE-2023-2229": {"epss_score": 0.0021, "epss_percentile": 0.43448}, "CVE-2023-2231": {"epss_score": 0.00178, "epss_percentile": 0.3972}, "CVE-2023-2232": {"epss_score": 0.01771, "epss_percentile": 0.82194}, "CVE-2023-2233": {"epss_score": 0.00071, "epss_percentile": 0.22034}, "CVE-2023-2234": {"epss_score": 0.00039, "epss_percentile": 0.11536}, "CVE-2023-2235": {"epss_score": 0.00013, "epss_percentile": 0.01607}, "CVE-2023-2236": {"epss_score": 0.00025, "epss_percentile": 0.06121}, "CVE-2023-2237": {"epss_score": 0.00225, "epss_percentile": 0.45086}, "CVE-2023-2239": {"epss_score": 0.00086, "epss_percentile": 0.25411}, "CVE-2023-2240": {"epss_score": 0.00075, "epss_percentile": 0.23071}, "CVE-2023-2241": {"epss_score": 0.00046, "epss_percentile": 0.14139}, "CVE-2023-2242": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2243": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2244": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2245": {"epss_score": 0.00292, "epss_percentile": 0.52257}, "CVE-2023-2246": {"epss_score": 0.01046, "epss_percentile": 0.77024}, "CVE-2023-2247": {"epss_score": 0.0022, "epss_percentile": 0.44587}, "CVE-2023-2249": {"epss_score": 0.46775, "epss_percentile": 0.97558}, "CVE-2023-2250": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2023-2251": {"epss_score": 0.00422, "epss_percentile": 0.61549}, "CVE-2023-2252": {"epss_score": 0.10304, "epss_percentile": 0.92935}, "CVE-2023-2253": {"epss_score": 0.00093, "epss_percentile": 0.26655}, "CVE-2023-2254": {"epss_score": 0.00069, "epss_percentile": 0.21519}, "CVE-2023-2255": {"epss_score": 0.49445, "epss_percentile": 0.97687}, "CVE-2023-2256": {"epss_score": 0.06383, "epss_percentile": 0.90714}, "CVE-2023-2257": {"epss_score": 0.00016, "epss_percentile": 0.02634}, "CVE-2023-2258": {"epss_score": 0.00104, "epss_percentile": 0.29126}, "CVE-2023-2259": {"epss_score": 0.00079, "epss_percentile": 0.23945}, "CVE-2023-2260": {"epss_score": 0.00031, "epss_percentile": 0.08536}, "CVE-2023-2261": {"epss_score": 0.00142, "epss_percentile": 0.35009}, "CVE-2023-2262": {"epss_score": 0.04482, "epss_percentile": 0.88744}, "CVE-2023-2263": {"epss_score": 0.00116, "epss_percentile": 0.31079}, "CVE-2023-2264": {"epss_score": 0.00054, "epss_percentile": 0.17136}, "CVE-2023-2265": {"epss_score": 0.00139, "epss_percentile": 0.34646}, "CVE-2023-2266": {"epss_score": 0.00259, "epss_percentile": 0.4905}, "CVE-2023-2267": {"epss_score": 0.00246, "epss_percentile": 0.47732}, "CVE-2023-2268": {"epss_score": 0.00161, "epss_percentile": 0.37526}, "CVE-2023-2269": {"epss_score": 0.00021, "epss_percentile": 0.04707}, "CVE-2023-2270": {"epss_score": 0.00031, "epss_percentile": 0.08652}, "CVE-2023-2271": {"epss_score": 0.00056, "epss_percentile": 0.17924}, "CVE-2023-2272": {"epss_score": 0.18279, "epss_percentile": 0.94988}, "CVE-2023-2273": {"epss_score": 0.00191, "epss_percentile": 0.41193}, "CVE-2023-2275": {"epss_score": 0.00091, "epss_percentile": 0.26279}, "CVE-2023-2276": {"epss_score": 0.00147, "epss_percentile": 0.35701}, "CVE-2023-2277": {"epss_score": 0.00121, "epss_percentile": 0.31838}, "CVE-2023-2278": {"epss_score": 0.00775, "epss_percentile": 0.73081}, "CVE-2023-2279": {"epss_score": 0.0005, "epss_percentile": 0.15835}, "CVE-2023-2280": {"epss_score": 0.00093, "epss_percentile": 0.26629}, "CVE-2023-2281": {"epss_score": 0.00319, "epss_percentile": 0.54469}, "CVE-2023-2282": {"epss_score": 0.00076, "epss_percentile": 0.23124}, "CVE-2023-2283": {"epss_score": 0.00213, "epss_percentile": 0.43826}, "CVE-2023-2284": {"epss_score": 0.00066, "epss_percentile": 0.20874}, "CVE-2023-2285": {"epss_score": 0.00048, "epss_percentile": 0.15251}, "CVE-2023-2286": {"epss_score": 0.00067, "epss_percentile": 0.21019}, "CVE-2023-2287": {"epss_score": 0.00092, "epss_percentile": 0.26513}, "CVE-2023-2288": {"epss_score": 0.14895, "epss_percentile": 0.94314}, "CVE-2023-2289": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-2290": {"epss_score": 0.0004, "epss_percentile": 0.11961}, "CVE-2023-2291": {"epss_score": 0.0002, "epss_percentile": 0.04592}, "CVE-2023-2293": {"epss_score": 0.00061, "epss_percentile": 0.19267}, "CVE-2023-2294": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2295": {"epss_score": 0.01671, "epss_percentile": 0.81673}, "CVE-2023-2296": {"epss_score": 0.00099, "epss_percentile": 0.28345}, "CVE-2023-2297": {"epss_score": 0.00181, "epss_percentile": 0.40033}, "CVE-2023-2298": {"epss_score": 0.0078, "epss_percentile": 0.73165}, "CVE-2023-2299": {"epss_score": 0.00111, "epss_percentile": 0.30256}, "CVE-2023-2300": {"epss_score": 0.00107, "epss_percentile": 0.29658}, "CVE-2023-2301": {"epss_score": 0.00146, "epss_percentile": 0.35543}, "CVE-2023-2302": {"epss_score": 0.00107, "epss_percentile": 0.29658}, "CVE-2023-2303": {"epss_score": 0.00146, "epss_percentile": 0.35543}, "CVE-2023-2304": {"epss_score": 0.00905, "epss_percentile": 0.75235}, "CVE-2023-2305": {"epss_score": 0.00102, "epss_percentile": 0.28837}, "CVE-2023-2306": {"epss_score": 0.00107, "epss_percentile": 0.29736}, "CVE-2023-2307": {"epss_score": 0.00049, "epss_percentile": 0.15633}, "CVE-2023-2309": {"epss_score": 0.11967, "epss_percentile": 0.93528}, "CVE-2023-2310": {"epss_score": 0.0057, "epss_percentile": 0.67944}, "CVE-2023-2311": {"epss_score": 0.00055, "epss_percentile": 0.17563}, "CVE-2023-2312": {"epss_score": 0.00411, "epss_percentile": 0.60898}, "CVE-2023-2313": {"epss_score": 0.00534, "epss_percentile": 0.66793}, "CVE-2023-2314": {"epss_score": 0.00031, "epss_percentile": 0.08711}, "CVE-2023-2315": {"epss_score": 0.00273, "epss_percentile": 0.50445}, "CVE-2023-2316": {"epss_score": 0.0028, "epss_percentile": 0.5102}, "CVE-2023-2317": {"epss_score": 0.49283, "epss_percentile": 0.97677}, "CVE-2023-2318": {"epss_score": 0.00061, "epss_percentile": 0.19425}, "CVE-2023-2319": {"epss_score": 0.0011, "epss_percentile": 0.30201}, "CVE-2023-2320": {"epss_score": 0.00099, "epss_percentile": 0.28345}, "CVE-2023-2321": {"epss_score": 0.00099, "epss_percentile": 0.28345}, "CVE-2023-2322": {"epss_score": 2e-05, "epss_percentile": 0.00029}, "CVE-2023-2323": {"epss_score": 2e-05, "epss_percentile": 0.00029}, "CVE-2023-2324": {"epss_score": 0.00099, "epss_percentile": 0.28345}, "CVE-2023-2325": {"epss_score": 0.00081, "epss_percentile": 0.24363}, "CVE-2023-2326": {"epss_score": 0.0009, "epss_percentile": 0.26167}, "CVE-2023-2327": {"epss_score": 2e-05, "epss_percentile": 0.00039}, "CVE-2023-2328": {"epss_score": 2e-05, "epss_percentile": 0.00039}, "CVE-2023-2329": {"epss_score": 0.00121, "epss_percentile": 0.3195}, "CVE-2023-2330": {"epss_score": 0.00121, "epss_percentile": 0.3195}, "CVE-2023-2331": {"epss_score": 0.00053, "epss_percentile": 0.16971}, "CVE-2023-2332": {"epss_score": 2e-05, "epss_percentile": 0.00052}, "CVE-2023-2333": {"epss_score": 0.02189, "epss_percentile": 0.8393}, "CVE-2023-2334": {"epss_score": 0.00012, "epss_percentile": 0.01329}, "CVE-2023-2335": {"epss_score": 0.00074, "epss_percentile": 0.22691}, "CVE-2023-2336": {"epss_score": 6e-05, "epss_percentile": 0.00303}, "CVE-2023-2337": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-2338": {"epss_score": 0.09986, "epss_percentile": 0.92805}, "CVE-2023-2339": {"epss_score": 3e-05, "epss_percentile": 0.00081}, "CVE-2023-2340": {"epss_score": 1e-05, "epss_percentile": 0.00019}, "CVE-2023-2341": {"epss_score": 6e-05, "epss_percentile": 0.00265}, "CVE-2023-2342": {"epss_score": 3e-05, "epss_percentile": 0.00067}, "CVE-2023-2343": {"epss_score": 1e-05, "epss_percentile": 0.00014}, "CVE-2023-2344": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2345": {"epss_score": 0.00049, "epss_percentile": 0.15626}, "CVE-2023-2346": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2347": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2348": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2349": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2350": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2351": {"epss_score": 0.00104, "epss_percentile": 0.29174}, "CVE-2023-2352": {"epss_score": 0.00088, "epss_percentile": 0.25657}, "CVE-2023-2353": {"epss_score": 0.00065, "epss_percentile": 0.20552}, "CVE-2023-2354": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-2355": {"epss_score": 0.0004, "epss_percentile": 0.12017}, "CVE-2023-2356": {"epss_score": 0.88125, "epss_percentile": 0.99459}, "CVE-2023-2358": {"epss_score": 0.00059, "epss_percentile": 0.18866}, "CVE-2023-2359": {"epss_score": 0.04205, "epss_percentile": 0.88393}, "CVE-2023-2360": {"epss_score": 0.00197, "epss_percentile": 0.41959}, "CVE-2023-2361": {"epss_score": 5e-05, "epss_percentile": 0.00205}, "CVE-2023-2362": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-2363": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2364": {"epss_score": 0.00111, "epss_percentile": 0.30269}, "CVE-2023-2365": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2366": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2023-2367": {"epss_score": 0.00054, "epss_percentile": 0.17096}, "CVE-2023-2368": {"epss_score": 0.00047, "epss_percentile": 0.14897}, "CVE-2023-2369": {"epss_score": 0.00054, "epss_percentile": 0.17096}, "CVE-2023-2370": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2023-2371": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2372": {"epss_score": 0.00059, "epss_percentile": 0.1892}, "CVE-2023-2373": {"epss_score": 0.01045, "epss_percentile": 0.77021}, "CVE-2023-2374": {"epss_score": 0.01146, "epss_percentile": 0.77997}, "CVE-2023-2375": {"epss_score": 0.03427, "epss_percentile": 0.87117}, "CVE-2023-2376": {"epss_score": 0.01045, "epss_percentile": 0.77021}, "CVE-2023-2377": {"epss_score": 0.01045, "epss_percentile": 0.77021}, "CVE-2023-2378": {"epss_score": 0.01045, "epss_percentile": 0.77021}, "CVE-2023-2379": {"epss_score": 0.00094, "epss_percentile": 0.26779}, "CVE-2023-2380": {"epss_score": 0.00075, "epss_percentile": 0.2307}, "CVE-2023-2381": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2382": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2383": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2384": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2385": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2386": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2387": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2388": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2389": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2390": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2391": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2392": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2393": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2394": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2023-2395": {"epss_score": 0.00093, "epss_percentile": 0.26713}, "CVE-2023-2396": {"epss_score": 0.00093, "epss_percentile": 0.26713}, "CVE-2023-2397": {"epss_score": 0.00059, "epss_percentile": 0.1892}, "CVE-2023-2398": {"epss_score": 0.00128, "epss_percentile": 0.32988}, "CVE-2023-2399": {"epss_score": 0.00099, "epss_percentile": 0.28345}, "CVE-2023-2400": {"epss_score": 0.00105, "epss_percentile": 0.29259}, "CVE-2023-2401": {"epss_score": 0.00076, "epss_percentile": 0.2308}, "CVE-2023-2402": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-2404": {"epss_score": 0.00101, "epss_percentile": 0.28641}, "CVE-2023-2405": {"epss_score": 0.00055, "epss_percentile": 0.17613}, "CVE-2023-2406": {"epss_score": 0.00101, "epss_percentile": 0.28641}, "CVE-2023-2407": {"epss_score": 0.00055, "epss_percentile": 0.17613}, "CVE-2023-2408": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2409": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2410": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2411": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2412": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2413": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-2414": {"epss_score": 0.00071, "epss_percentile": 0.2209}, "CVE-2023-2415": {"epss_score": 0.00033, "epss_percentile": 0.09355}, "CVE-2023-2416": {"epss_score": 0.00072, "epss_percentile": 0.22459}, "CVE-2023-2417": {"epss_score": 0.00029, "epss_percentile": 0.07936}, "CVE-2023-2418": {"epss_score": 0.00102, "epss_percentile": 0.28895}, "CVE-2023-2419": {"epss_score": 0.00059, "epss_percentile": 0.18716}, "CVE-2023-2420": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2421": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-2422": {"epss_score": 0.00294, "epss_percentile": 0.52412}, "CVE-2023-2423": {"epss_score": 0.0005, "epss_percentile": 0.15741}, "CVE-2023-2424": {"epss_score": 0.001, "epss_percentile": 0.28449}, "CVE-2023-2425": {"epss_score": 0.00061, "epss_percentile": 0.19267}, "CVE-2023-2426": {"epss_score": 0.00016, "epss_percentile": 0.02758}, "CVE-2023-2427": {"epss_score": 0.00075, "epss_percentile": 0.22954}, "CVE-2023-2428": {"epss_score": 0.00136, "epss_percentile": 0.34114}, "CVE-2023-2429": {"epss_score": 0.00208, "epss_percentile": 0.43296}, "CVE-2023-2430": {"epss_score": 0.00012, "epss_percentile": 0.01408}, "CVE-2023-2431": {"epss_score": 0.0001, "epss_percentile": 0.00768}, "CVE-2023-2433": {"epss_score": 0.00122, "epss_percentile": 0.32108}, "CVE-2023-2434": {"epss_score": 0.00038, "epss_percentile": 0.11097}, "CVE-2023-2435": {"epss_score": 0.00141, "epss_percentile": 0.34845}, "CVE-2023-2436": {"epss_score": 0.0011, "epss_percentile": 0.302}, "CVE-2023-2437": {"epss_score": 0.73462, "epss_percentile": 0.98757}, "CVE-2023-2438": {"epss_score": 0.00148, "epss_percentile": 0.35886}, "CVE-2023-2439": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-2440": {"epss_score": 0.00092, "epss_percentile": 0.26561}, "CVE-2023-2442": {"epss_score": 0.83689, "epss_percentile": 0.99258}, "CVE-2023-2443": {"epss_score": 0.00121, "epss_percentile": 0.31886}, "CVE-2023-2444": {"epss_score": 0.001, "epss_percentile": 0.28496}, "CVE-2023-2445": {"epss_score": 0.00122, "epss_percentile": 0.32132}, "CVE-2023-2446": {"epss_score": 0.00238, "epss_percentile": 0.46761}, "CVE-2023-2447": {"epss_score": 0.00229, "epss_percentile": 0.45655}, "CVE-2023-2448": {"epss_score": 0.00409, "epss_percentile": 0.60731}, "CVE-2023-2449": {"epss_score": 0.00484, "epss_percentile": 0.64636}, "CVE-2023-2450": {"epss_score": 0.00123, "epss_percentile": 0.32315}, "CVE-2023-2451": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2452": {"epss_score": 0.00123, "epss_percentile": 0.32315}, "CVE-2023-2453": {"epss_score": 0.00159, "epss_percentile": 0.37325}, "CVE-2023-2454": {"epss_score": 0.00275, "epss_percentile": 0.50649}, "CVE-2023-2455": {"epss_score": 0.00212, "epss_percentile": 0.43795}, "CVE-2023-2457": {"epss_score": 0.00217, "epss_percentile": 0.44309}, "CVE-2023-2458": {"epss_score": 0.00217, "epss_percentile": 0.44309}, "CVE-2023-2459": {"epss_score": 0.00039, "epss_percentile": 0.11669}, "CVE-2023-2460": {"epss_score": 0.00035, "epss_percentile": 0.09991}, "CVE-2023-2461": {"epss_score": 0.00538, "epss_percentile": 0.66937}, "CVE-2023-2462": {"epss_score": 0.00318, "epss_percentile": 0.54401}, "CVE-2023-2463": {"epss_score": 0.00318, "epss_percentile": 0.54401}, "CVE-2023-2464": {"epss_score": 0.00193, "epss_percentile": 0.41448}, "CVE-2023-2465": {"epss_score": 0.00272, "epss_percentile": 0.50393}, "CVE-2023-2466": {"epss_score": 0.00318, "epss_percentile": 0.54401}, "CVE-2023-2467": {"epss_score": 0.00034, "epss_percentile": 0.09457}, "CVE-2023-2468": {"epss_score": 0.00318, "epss_percentile": 0.54401}, "CVE-2023-2470": {"epss_score": 0.00097, "epss_percentile": 0.27562}, "CVE-2023-2472": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-2473": {"epss_score": 0.00047, "epss_percentile": 0.14926}, "CVE-2023-2474": {"epss_score": 0.00053, "epss_percentile": 0.16852}, "CVE-2023-2475": {"epss_score": 0.00064, "epss_percentile": 0.20195}, "CVE-2023-2476": {"epss_score": 0.00064, "epss_percentile": 0.20195}, "CVE-2023-2477": {"epss_score": 0.00064, "epss_percentile": 0.20195}, "CVE-2023-2478": {"epss_score": 0.00356, "epss_percentile": 0.57396}, "CVE-2023-2479": {"epss_score": 0.93314, "epss_percentile": 0.99796}, "CVE-2023-2480": {"epss_score": 0.00039, "epss_percentile": 0.11721}, "CVE-2023-2481": {"epss_score": 0.00086, "epss_percentile": 0.25411}, "CVE-2023-2482": {"epss_score": 0.00254, "epss_percentile": 0.48526}, "CVE-2023-2484": {"epss_score": 0.00307, "epss_percentile": 0.5347}, "CVE-2023-2485": {"epss_score": 0.00157, "epss_percentile": 0.37057}, "CVE-2023-2487": {"epss_score": 0.00618, "epss_percentile": 0.69365}, "CVE-2023-2488": {"epss_score": 0.00348, "epss_percentile": 0.56849}, "CVE-2023-2489": {"epss_score": 0.00089, "epss_percentile": 0.25945}, "CVE-2023-2490": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-2491": {"epss_score": 0.00063, "epss_percentile": 0.2006}, "CVE-2023-2492": {"epss_score": 0.00189, "epss_percentile": 0.4097}, "CVE-2023-2493": {"epss_score": 0.00237, "epss_percentile": 0.4664}, "CVE-2023-2494": {"epss_score": 0.00101, "epss_percentile": 0.28634}, "CVE-2023-2495": {"epss_score": 0.00054, "epss_percentile": 0.17316}, "CVE-2023-2496": {"epss_score": 0.02323, "epss_percentile": 0.84377}, "CVE-2023-2497": {"epss_score": 0.00143, "epss_percentile": 0.3517}, "CVE-2023-2498": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-2499": {"epss_score": 0.005, "epss_percentile": 0.65318}, "CVE-2023-2500": {"epss_score": 0.00579, "epss_percentile": 0.68228}, "CVE-2023-2503": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-2504": {"epss_score": 0.00061, "epss_percentile": 0.19474}, "CVE-2023-2505": {"epss_score": 0.00075, "epss_percentile": 0.22958}, "CVE-2023-2507": {"epss_score": 0.00089, "epss_percentile": 0.25894}, "CVE-2023-2508": {"epss_score": 0.00028, "epss_percentile": 0.07299}, "CVE-2023-2509": {"epss_score": 0.00169, "epss_percentile": 0.38535}, "CVE-2023-2512": {"epss_score": 0.00293, "epss_percentile": 0.5232}, "CVE-2023-2513": {"epss_score": 0.00015, "epss_percentile": 0.02271}, "CVE-2023-2514": {"epss_score": 0.00153, "epss_percentile": 0.36594}, "CVE-2023-2515": {"epss_score": 0.00106, "epss_percentile": 0.29423}, "CVE-2023-2516": {"epss_score": 0.0071, "epss_percentile": 0.71713}, "CVE-2023-2517": {"epss_score": 0.00049, "epss_percentile": 0.15501}, "CVE-2023-2518": {"epss_score": 0.11445, "epss_percentile": 0.93363}, "CVE-2023-2519": {"epss_score": 0.00045, "epss_percentile": 0.13817}, "CVE-2023-2520": {"epss_score": 0.00262, "epss_percentile": 0.49402}, "CVE-2023-2521": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-2522": {"epss_score": 0.2377, "epss_percentile": 0.95814}, "CVE-2023-2523": {"epss_score": 0.90185, "epss_percentile": 0.99567}, "CVE-2023-2524": {"epss_score": 0.00049, "epss_percentile": 0.15626}, "CVE-2023-2526": {"epss_score": 0.00065, "epss_percentile": 0.20434}, "CVE-2023-2527": {"epss_score": 0.00076, "epss_percentile": 0.2313}, "CVE-2023-2528": {"epss_score": 0.00105, "epss_percentile": 0.29372}, "CVE-2023-2529": {"epss_score": 0.00107, "epss_percentile": 0.29716}, "CVE-2023-2530": {"epss_score": 0.05712, "epss_percentile": 0.90142}, "CVE-2023-2531": {"epss_score": 0.00081, "epss_percentile": 0.24307}, "CVE-2023-2533": {"epss_score": 0.36322, "epss_percentile": 0.9697}, "CVE-2023-2534": {"epss_score": 0.00105, "epss_percentile": 0.29252}, "CVE-2023-2538": {"epss_score": 0.00061, "epss_percentile": 0.19441}, "CVE-2023-2541": {"epss_score": 0.00334, "epss_percentile": 0.55685}, "CVE-2023-2544": {"epss_score": 0.0004, "epss_percentile": 0.1195}, "CVE-2023-2545": {"epss_score": 0.00099, "epss_percentile": 0.27857}, "CVE-2023-2546": {"epss_score": 0.02041, "epss_percentile": 0.83368}, "CVE-2023-2547": {"epss_score": 0.00036, "epss_percentile": 0.10439}, "CVE-2023-2548": {"epss_score": 0.00036, "epss_percentile": 0.10496}, "CVE-2023-2549": {"epss_score": 0.00092, "epss_percentile": 0.26561}, "CVE-2023-2550": {"epss_score": 0.00039, "epss_percentile": 0.11839}, "CVE-2023-2551": {"epss_score": 0.00628, "epss_percentile": 0.69659}, "CVE-2023-2552": {"epss_score": 0.00143, "epss_percentile": 0.35206}, "CVE-2023-2553": {"epss_score": 0.00047, "epss_percentile": 0.14773}, "CVE-2023-2554": {"epss_score": 0.01204, "epss_percentile": 0.78504}, "CVE-2023-2555": {"epss_score": 0.00058, "epss_percentile": 0.18448}, "CVE-2023-2556": {"epss_score": 0.00058, "epss_percentile": 0.18448}, "CVE-2023-2557": {"epss_score": 0.00053, "epss_percentile": 0.16688}, "CVE-2023-2558": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-2560": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2561": {"epss_score": 0.00061, "epss_percentile": 0.19393}, "CVE-2023-2562": {"epss_score": 0.00105, "epss_percentile": 0.29288}, "CVE-2023-2563": {"epss_score": 0.00069, "epss_percentile": 0.21594}, "CVE-2023-2564": {"epss_score": 0.38245, "epss_percentile": 0.97091}, "CVE-2023-2565": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2566": {"epss_score": 0.01614, "epss_percentile": 0.81345}, "CVE-2023-2567": {"epss_score": 0.0013, "epss_percentile": 0.33272}, "CVE-2023-2568": {"epss_score": 0.00128, "epss_percentile": 0.32988}, "CVE-2023-2569": {"epss_score": 0.00049, "epss_percentile": 0.15416}, "CVE-2023-2570": {"epss_score": 0.00036, "epss_percentile": 0.10202}, "CVE-2023-2571": {"epss_score": 0.00167, "epss_percentile": 0.38362}, "CVE-2023-2572": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-2573": {"epss_score": 0.02021, "epss_percentile": 0.83298}, "CVE-2023-2574": {"epss_score": 0.01498, "epss_percentile": 0.80696}, "CVE-2023-2575": {"epss_score": 0.02179, "epss_percentile": 0.83893}, "CVE-2023-2576": {"epss_score": 0.00088, "epss_percentile": 0.25679}, "CVE-2023-2578": {"epss_score": 0.0008, "epss_percentile": 0.24111}, "CVE-2023-2579": {"epss_score": 0.14858, "epss_percentile": 0.94303}, "CVE-2023-2580": {"epss_score": 0.00089, "epss_percentile": 0.25945}, "CVE-2023-2582": {"epss_score": 0.00196, "epss_percentile": 0.41797}, "CVE-2023-2583": {"epss_score": 0.00109, "epss_percentile": 0.2991}, "CVE-2023-2584": {"epss_score": 0.00123, "epss_percentile": 0.32315}, "CVE-2023-2585": {"epss_score": 0.00112, "epss_percentile": 0.3057}, "CVE-2023-2586": {"epss_score": 0.00587, "epss_percentile": 0.68486}, "CVE-2023-2587": {"epss_score": 0.00154, "epss_percentile": 0.36714}, "CVE-2023-2588": {"epss_score": 0.00414, "epss_percentile": 0.61105}, "CVE-2023-2589": {"epss_score": 0.00194, "epss_percentile": 0.41552}, "CVE-2023-2590": {"epss_score": 0.00051, "epss_percentile": 0.16214}, "CVE-2023-2591": {"epss_score": 0.00282, "epss_percentile": 0.51268}, "CVE-2023-2592": {"epss_score": 0.00254, "epss_percentile": 0.48526}, "CVE-2023-2593": {"epss_score": 0.00013, "epss_percentile": 0.01667}, "CVE-2023-2594": {"epss_score": 0.00105, "epss_percentile": 0.29247}, "CVE-2023-2595": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2596": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2597": {"epss_score": 0.00024, "epss_percentile": 0.05898}, "CVE-2023-2598": {"epss_score": 0.00799, "epss_percentile": 0.73525}, "CVE-2023-2599": {"epss_score": 0.00102, "epss_percentile": 0.28736}, "CVE-2023-2600": {"epss_score": 0.00089, "epss_percentile": 0.25945}, "CVE-2023-2601": {"epss_score": 0.001, "epss_percentile": 0.28548}, "CVE-2023-2602": {"epss_score": 0.00015, "epss_percentile": 0.02476}, "CVE-2023-2603": {"epss_score": 0.01146, "epss_percentile": 0.78003}, "CVE-2023-2604": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-2605": {"epss_score": 0.00128, "epss_percentile": 0.32988}, "CVE-2023-2606": {"epss_score": 0.00072, "epss_percentile": 0.22475}, "CVE-2023-2607": {"epss_score": 0.00317, "epss_percentile": 0.54344}, "CVE-2023-2608": {"epss_score": 0.00072, "epss_percentile": 0.22385}, "CVE-2023-2609": {"epss_score": 0.00017, "epss_percentile": 0.03135}, "CVE-2023-2610": {"epss_score": 0.00013, "epss_percentile": 0.01447}, "CVE-2023-2611": {"epss_score": 0.00082, "epss_percentile": 0.24445}, "CVE-2023-2612": {"epss_score": 0.00019, "epss_percentile": 0.04417}, "CVE-2023-2614": {"epss_score": 3e-05, "epss_percentile": 0.00076}, "CVE-2023-2615": {"epss_score": 3e-05, "epss_percentile": 0.00076}, "CVE-2023-2616": {"epss_score": 3e-05, "epss_percentile": 0.00076}, "CVE-2023-2617": {"epss_score": 0.0004, "epss_percentile": 0.12099}, "CVE-2023-2618": {"epss_score": 0.00037, "epss_percentile": 0.10657}, "CVE-2023-2619": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2620": {"epss_score": 0.00316, "epss_percentile": 0.54272}, "CVE-2023-2621": {"epss_score": 0.00109, "epss_percentile": 0.30019}, "CVE-2023-2622": {"epss_score": 0.0013, "epss_percentile": 0.33328}, "CVE-2023-2623": {"epss_score": 0.00276, "epss_percentile": 0.50714}, "CVE-2023-2624": {"epss_score": 0.10752, "epss_percentile": 0.93093}, "CVE-2023-2625": {"epss_score": 0.0015, "epss_percentile": 0.36047}, "CVE-2023-2626": {"epss_score": 0.0001, "epss_percentile": 0.00752}, "CVE-2023-2627": {"epss_score": 0.00059, "epss_percentile": 0.18917}, "CVE-2023-2628": {"epss_score": 0.00143, "epss_percentile": 0.35206}, "CVE-2023-2629": {"epss_score": 1e-05, "epss_percentile": 0.0001}, "CVE-2023-2630": {"epss_score": 2e-05, "epss_percentile": 0.00039}, "CVE-2023-2631": {"epss_score": 0.00476, "epss_percentile": 0.64267}, "CVE-2023-2632": {"epss_score": 0.00303, "epss_percentile": 0.53181}, "CVE-2023-2633": {"epss_score": 0.00176, "epss_percentile": 0.39465}, "CVE-2023-2634": {"epss_score": 0.00345, "epss_percentile": 0.56587}, "CVE-2023-2635": {"epss_score": 0.00087, "epss_percentile": 0.25619}, "CVE-2023-2636": {"epss_score": 0.04597, "epss_percentile": 0.88901}, "CVE-2023-2637": {"epss_score": 5e-05, "epss_percentile": 0.00187}, "CVE-2023-2638": {"epss_score": 3e-05, "epss_percentile": 0.00098}, "CVE-2023-2639": {"epss_score": 0.0004, "epss_percentile": 0.12096}, "CVE-2023-2640": {"epss_score": 0.91622, "epss_percentile": 0.99659}, "CVE-2023-2641": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2023-2642": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2643": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2644": {"epss_score": 0.00026, "epss_percentile": 0.06715}, "CVE-2023-2645": {"epss_score": 0.05617, "epss_percentile": 0.90056}, "CVE-2023-2646": {"epss_score": 0.00023, "epss_percentile": 0.05391}, "CVE-2023-2647": {"epss_score": 0.02353, "epss_percentile": 0.84475}, "CVE-2023-2648": {"epss_score": 0.93096, "epss_percentile": 0.99775}, "CVE-2023-2649": {"epss_score": 0.01403, "epss_percentile": 0.80028}, "CVE-2023-2650": {"epss_score": 0.91857, "epss_percentile": 0.99673}, "CVE-2023-2652": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2653": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2654": {"epss_score": 0.00128, "epss_percentile": 0.32988}, "CVE-2023-2655": {"epss_score": 0.00715, "epss_percentile": 0.71841}, "CVE-2023-2656": {"epss_score": 0.00118, "epss_percentile": 0.31446}, "CVE-2023-2657": {"epss_score": 0.00149, "epss_percentile": 0.35959}, "CVE-2023-2658": {"epss_score": 0.00137, "epss_percentile": 0.34334}, "CVE-2023-2659": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2023-2660": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2661": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2662": {"epss_score": 0.00024, "epss_percentile": 0.06018}, "CVE-2023-2663": {"epss_score": 0.00064, "epss_percentile": 0.20254}, "CVE-2023-2664": {"epss_score": 0.00011, "epss_percentile": 0.01088}, "CVE-2023-2665": {"epss_score": 0.00082, "epss_percentile": 0.24462}, "CVE-2023-2666": {"epss_score": 0.00074, "epss_percentile": 0.22736}, "CVE-2023-2667": {"epss_score": 0.00101, "epss_percentile": 0.28647}, "CVE-2023-2668": {"epss_score": 0.00122, "epss_percentile": 0.32101}, "CVE-2023-2669": {"epss_score": 0.00122, "epss_percentile": 0.32101}, "CVE-2023-2670": {"epss_score": 0.00245, "epss_percentile": 0.47685}, "CVE-2023-2671": {"epss_score": 0.00096, "epss_percentile": 0.27319}, "CVE-2023-2672": {"epss_score": 0.00134, "epss_percentile": 0.33755}, "CVE-2023-2673": {"epss_score": 0.00021, "epss_percentile": 0.0492}, "CVE-2023-2674": {"epss_score": 0.00206, "epss_percentile": 0.42927}, "CVE-2023-2675": {"epss_score": 0.00111, "epss_percentile": 0.30278}, "CVE-2023-2676": {"epss_score": 0.00235, "epss_percentile": 0.4631}, "CVE-2023-2677": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2678": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-2679": {"epss_score": 0.00101, "epss_percentile": 0.28679}, "CVE-2023-2680": {"epss_score": 0.0003, "epss_percentile": 0.08217}, "CVE-2023-2681": {"epss_score": 0.00565, "epss_percentile": 0.67799}, "CVE-2023-2682": {"epss_score": 0.0018, "epss_percentile": 0.3998}, "CVE-2023-2683": {"epss_score": 0.00032, "epss_percentile": 0.09074}, "CVE-2023-2684": {"epss_score": 0.00098, "epss_percentile": 0.27667}, "CVE-2023-2685": {"epss_score": 0.00038, "epss_percentile": 0.1134}, "CVE-2023-2686": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-2687": {"epss_score": 0.00041, "epss_percentile": 0.12229}, "CVE-2023-2688": {"epss_score": 0.00189, "epss_percentile": 0.40948}, "CVE-2023-2689": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2690": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2691": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-2692": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-2693": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2694": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2695": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2696": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2023-2697": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2698": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2699": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2700": {"epss_score": 0.0003, "epss_percentile": 0.08142}, "CVE-2023-2701": {"epss_score": 0.00108, "epss_percentile": 0.29847}, "CVE-2023-2702": {"epss_score": 0.00018, "epss_percentile": 0.03981}, "CVE-2023-2703": {"epss_score": 0.00068, "epss_percentile": 0.21338}, "CVE-2023-2704": {"epss_score": 0.00242, "epss_percentile": 0.47358}, "CVE-2023-2705": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-2706": {"epss_score": 0.0099, "epss_percentile": 0.76376}, "CVE-2023-2707": {"epss_score": 0.00091, "epss_percentile": 0.26244}, "CVE-2023-2708": {"epss_score": 0.00382, "epss_percentile": 0.59058}, "CVE-2023-2709": {"epss_score": 0.00095, "epss_percentile": 0.27085}, "CVE-2023-2710": {"epss_score": 0.00382, "epss_percentile": 0.59058}, "CVE-2023-2711": {"epss_score": 0.0013, "epss_percentile": 0.333}, "CVE-2023-2712": {"epss_score": 0.0027, "epss_percentile": 0.50253}, "CVE-2023-2713": {"epss_score": 0.00021, "epss_percentile": 0.04716}, "CVE-2023-2714": {"epss_score": 0.00064, "epss_percentile": 0.20308}, "CVE-2023-2715": {"epss_score": 0.00088, "epss_percentile": 0.25672}, "CVE-2023-2716": {"epss_score": 0.001, "epss_percentile": 0.28561}, "CVE-2023-2717": {"epss_score": 0.0005, "epss_percentile": 0.1584}, "CVE-2023-2718": {"epss_score": 0.00496, "epss_percentile": 0.65165}, "CVE-2023-2719": {"epss_score": 0.03466, "epss_percentile": 0.8719}, "CVE-2023-2721": {"epss_score": 0.00231, "epss_percentile": 0.45791}, "CVE-2023-2722": {"epss_score": 0.00252, "epss_percentile": 0.48374}, "CVE-2023-2723": {"epss_score": 0.12813, "epss_percentile": 0.93781}, "CVE-2023-2724": {"epss_score": 0.1275, "epss_percentile": 0.93763}, "CVE-2023-2725": {"epss_score": 0.11274, "epss_percentile": 0.93288}, "CVE-2023-2726": {"epss_score": 0.0003, "epss_percentile": 0.08236}, "CVE-2023-2727": {"epss_score": 0.00174, "epss_percentile": 0.39163}, "CVE-2023-2728": {"epss_score": 0.04843, "epss_percentile": 0.89203}, "CVE-2023-2729": {"epss_score": 0.00214, "epss_percentile": 0.43969}, "CVE-2023-2730": {"epss_score": 5e-05, "epss_percentile": 0.00205}, "CVE-2023-2731": {"epss_score": 0.0001, "epss_percentile": 0.00784}, "CVE-2023-2732": {"epss_score": 0.90424, "epss_percentile": 0.99582}, "CVE-2023-2733": {"epss_score": 0.00271, "epss_percentile": 0.50285}, "CVE-2023-2734": {"epss_score": 0.60337, "epss_percentile": 0.98204}, "CVE-2023-2735": {"epss_score": 0.0013, "epss_percentile": 0.33257}, "CVE-2023-2736": {"epss_score": 0.00112, "epss_percentile": 0.30539}, "CVE-2023-2737": {"epss_score": 0.00015, "epss_percentile": 0.02466}, "CVE-2023-2738": {"epss_score": 0.00084, "epss_percentile": 0.24892}, "CVE-2023-2739": {"epss_score": 0.0006, "epss_percentile": 0.19237}, "CVE-2023-2740": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2742": {"epss_score": 0.00098, "epss_percentile": 0.27667}, "CVE-2023-2743": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-2744": {"epss_score": 0.28228, "epss_percentile": 0.96334}, "CVE-2023-2745": {"epss_score": 0.75986, "epss_percentile": 0.98872}, "CVE-2023-2746": {"epss_score": 0.00138, "epss_percentile": 0.34354}, "CVE-2023-2747": {"epss_score": 0.00031, "epss_percentile": 0.0834}, "CVE-2023-2749": {"epss_score": 0.00103, "epss_percentile": 0.28987}, "CVE-2023-2750": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-2751": {"epss_score": 0.00077, "epss_percentile": 0.23367}, "CVE-2023-2752": {"epss_score": 0.00232, "epss_percentile": 0.45938}, "CVE-2023-2753": {"epss_score": 0.00168, "epss_percentile": 0.38417}, "CVE-2023-2754": {"epss_score": 0.00741, "epss_percentile": 0.72442}, "CVE-2023-2756": {"epss_score": 0.0562, "epss_percentile": 0.9006}, "CVE-2023-2757": {"epss_score": 0.00037, "epss_percentile": 0.10786}, "CVE-2023-2758": {"epss_score": 0.00209, "epss_percentile": 0.43372}, "CVE-2023-2759": {"epss_score": 0.00066, "epss_percentile": 0.20709}, "CVE-2023-2760": {"epss_score": 0.00046, "epss_percentile": 0.14085}, "CVE-2023-2761": {"epss_score": 0.00179, "epss_percentile": 0.39825}, "CVE-2023-2762": {"epss_score": 0.00052, "epss_percentile": 0.16369}, "CVE-2023-2763": {"epss_score": 0.00047, "epss_percentile": 0.14632}, "CVE-2023-2764": {"epss_score": 0.00056, "epss_percentile": 0.17811}, "CVE-2023-2765": {"epss_score": 0.00189, "epss_percentile": 0.40963}, "CVE-2023-2766": {"epss_score": 0.91816, "epss_percentile": 0.99669}, "CVE-2023-2767": {"epss_score": 0.0011, "epss_percentile": 0.302}, "CVE-2023-2768": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2769": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2770": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2771": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2772": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2773": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-2774": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2775": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2776": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2023-2778": {"epss_score": 0.00137, "epss_percentile": 0.34249}, "CVE-2023-2779": {"epss_score": 0.31029, "epss_percentile": 0.96583}, "CVE-2023-2780": {"epss_score": 0.86155, "epss_percentile": 0.99371}, "CVE-2023-2781": {"epss_score": 0.00357, "epss_percentile": 0.57399}, "CVE-2023-2782": {"epss_score": 0.00059, "epss_percentile": 0.18665}, "CVE-2023-2783": {"epss_score": 0.00133, "epss_percentile": 0.33677}, "CVE-2023-2784": {"epss_score": 0.00058, "epss_percentile": 0.18522}, "CVE-2023-2785": {"epss_score": 0.00115, "epss_percentile": 0.30961}, "CVE-2023-2786": {"epss_score": 0.00077, "epss_percentile": 0.23368}, "CVE-2023-2787": {"epss_score": 0.00141, "epss_percentile": 0.34941}, "CVE-2023-2788": {"epss_score": 0.00074, "epss_percentile": 0.22711}, "CVE-2023-2789": {"epss_score": 0.00215, "epss_percentile": 0.44027}, "CVE-2023-2790": {"epss_score": 0.00028, "epss_percentile": 0.07327}, "CVE-2023-2791": {"epss_score": 0.00117, "epss_percentile": 0.31221}, "CVE-2023-2792": {"epss_score": 0.00215, "epss_percentile": 0.44099}, "CVE-2023-2793": {"epss_score": 0.00227, "epss_percentile": 0.45363}, "CVE-2023-2794": {"epss_score": 0.00179, "epss_percentile": 0.39805}, "CVE-2023-2795": {"epss_score": 0.00089, "epss_percentile": 0.25945}, "CVE-2023-2796": {"epss_score": 0.77502, "epss_percentile": 0.98938}, "CVE-2023-2797": {"epss_score": 0.00467, "epss_percentile": 0.63856}, "CVE-2023-2798": {"epss_score": 0.00073, "epss_percentile": 0.22559}, "CVE-2023-2799": {"epss_score": 0.00065, "epss_percentile": 0.20441}, "CVE-2023-2800": {"epss_score": 0.00018, "epss_percentile": 0.03629}, "CVE-2023-2801": {"epss_score": 0.00623, "epss_percentile": 0.69542}, "CVE-2023-2802": {"epss_score": 0.00069, "epss_percentile": 0.21519}, "CVE-2023-2803": {"epss_score": 0.00108, "epss_percentile": 0.29847}, "CVE-2023-2804": {"epss_score": 0.00061, "epss_percentile": 0.1933}, "CVE-2023-2805": {"epss_score": 0.00232, "epss_percentile": 0.45936}, "CVE-2023-2806": {"epss_score": 0.00131, "epss_percentile": 0.33367}, "CVE-2023-2807": {"epss_score": 0.00063, "epss_percentile": 0.20061}, "CVE-2023-2808": {"epss_score": 0.0017, "epss_percentile": 0.3871}, "CVE-2023-2809": {"epss_score": 0.00149, "epss_percentile": 0.36026}, "CVE-2023-2811": {"epss_score": 0.00098, "epss_percentile": 0.27667}, "CVE-2023-2812": {"epss_score": 0.00094, "epss_percentile": 0.26972}, "CVE-2023-2813": {"epss_score": 0.02244, "epss_percentile": 0.84124}, "CVE-2023-2814": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2815": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2816": {"epss_score": 0.00225, "epss_percentile": 0.45096}, "CVE-2023-2817": {"epss_score": 0.00159, "epss_percentile": 0.37397}, "CVE-2023-2818": {"epss_score": 0.00041, "epss_percentile": 0.12377}, "CVE-2023-2819": {"epss_score": 0.00072, "epss_percentile": 0.22266}, "CVE-2023-2820": {"epss_score": 0.00056, "epss_percentile": 0.17896}, "CVE-2023-2822": {"epss_score": 0.83672, "epss_percentile": 0.99257}, "CVE-2023-2823": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2824": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2825": {"epss_score": 0.93022, "epss_percentile": 0.99768}, "CVE-2023-2826": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-2827": {"epss_score": 0.00081, "epss_percentile": 0.24326}, "CVE-2023-2828": {"epss_score": 0.00667, "epss_percentile": 0.70717}, "CVE-2023-2829": {"epss_score": 0.00072, "epss_percentile": 0.22376}, "CVE-2023-2830": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-2831": {"epss_score": 0.00118, "epss_percentile": 0.31458}, "CVE-2023-2832": {"epss_score": 0.00061, "epss_percentile": 0.19276}, "CVE-2023-2833": {"epss_score": 0.25633, "epss_percentile": 0.96052}, "CVE-2023-2834": {"epss_score": 0.00421, "epss_percentile": 0.61493}, "CVE-2023-2835": {"epss_score": 0.00677, "epss_percentile": 0.70958}, "CVE-2023-2836": {"epss_score": 0.00121, "epss_percentile": 0.31924}, "CVE-2023-2837": {"epss_score": 0.00026, "epss_percentile": 0.06432}, "CVE-2023-2838": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2023-2839": {"epss_score": 0.00061, "epss_percentile": 0.19246}, "CVE-2023-2840": {"epss_score": 0.0008, "epss_percentile": 0.24156}, "CVE-2023-2841": {"epss_score": 0.00488, "epss_percentile": 0.64856}, "CVE-2023-2842": {"epss_score": 0.00095, "epss_percentile": 0.27094}, "CVE-2023-2843": {"epss_score": 0.00328, "epss_percentile": 0.55158}, "CVE-2023-2844": {"epss_score": 0.00018, "epss_percentile": 0.03525}, "CVE-2023-2845": {"epss_score": 0.00063, "epss_percentile": 0.20058}, "CVE-2023-2846": {"epss_score": 0.00086, "epss_percentile": 0.25273}, "CVE-2023-2847": {"epss_score": 0.00044, "epss_percentile": 0.13414}, "CVE-2023-2848": {"epss_score": 0.0014, "epss_percentile": 0.34709}, "CVE-2023-2850": {"epss_score": 0.00127, "epss_percentile": 0.32788}, "CVE-2023-2851": {"epss_score": 0.00077, "epss_percentile": 0.23434}, "CVE-2023-2852": {"epss_score": 0.00067, "epss_percentile": 0.21122}, "CVE-2023-2853": {"epss_score": 0.00289, "epss_percentile": 0.52075}, "CVE-2023-2854": {"epss_score": 0.00049, "epss_percentile": 0.15567}, "CVE-2023-2855": {"epss_score": 0.0005, "epss_percentile": 0.1569}, "CVE-2023-2856": {"epss_score": 0.00037, "epss_percentile": 0.10641}, "CVE-2023-2857": {"epss_score": 0.00049, "epss_percentile": 0.15567}, "CVE-2023-2858": {"epss_score": 0.00054, "epss_percentile": 0.17176}, "CVE-2023-2859": {"epss_score": 0.05769, "epss_percentile": 0.90191}, "CVE-2023-2860": {"epss_score": 8e-05, "epss_percentile": 0.00548}, "CVE-2023-2861": {"epss_score": 0.00041, "epss_percentile": 0.12342}, "CVE-2023-2862": {"epss_score": 0.00373, "epss_percentile": 0.58522}, "CVE-2023-2863": {"epss_score": 0.00021, "epss_percentile": 0.04702}, "CVE-2023-2864": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-2865": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2866": {"epss_score": 0.00023, "epss_percentile": 0.05354}, "CVE-2023-2868": {"epss_score": 0.90297, "epss_percentile": 0.99576}, "CVE-2023-2869": {"epss_score": 0.00073, "epss_percentile": 0.22633}, "CVE-2023-2870": {"epss_score": 0.00026, "epss_percentile": 0.06483}, "CVE-2023-2871": {"epss_score": 0.00026, "epss_percentile": 0.06483}, "CVE-2023-2872": {"epss_score": 0.00028, "epss_percentile": 0.07255}, "CVE-2023-2873": {"epss_score": 0.00095, "epss_percentile": 0.27231}, "CVE-2023-2874": {"epss_score": 0.00028, "epss_percentile": 0.07255}, "CVE-2023-2875": {"epss_score": 0.00028, "epss_percentile": 0.07255}, "CVE-2023-2876": {"epss_score": 0.00188, "epss_percentile": 0.40895}, "CVE-2023-2877": {"epss_score": 0.68996, "epss_percentile": 0.98572}, "CVE-2023-2878": {"epss_score": 0.00063, "epss_percentile": 0.19999}, "CVE-2023-2879": {"epss_score": 0.00115, "epss_percentile": 0.30886}, "CVE-2023-2880": {"epss_score": 0.00089, "epss_percentile": 0.25908}, "CVE-2023-2881": {"epss_score": 1e-05, "epss_percentile": 0.00019}, "CVE-2023-2882": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2023-2883": {"epss_score": 0.00018, "epss_percentile": 0.03981}, "CVE-2023-2884": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-2885": {"epss_score": 0.00076, "epss_percentile": 0.23118}, "CVE-2023-2886": {"epss_score": 0.00051, "epss_percentile": 0.16301}, "CVE-2023-2887": {"epss_score": 0.00021, "epss_percentile": 0.04716}, "CVE-2023-2888": {"epss_score": 0.00064, "epss_percentile": 0.2017}, "CVE-2023-2889": {"epss_score": 0.00069, "epss_percentile": 0.21618}, "CVE-2023-2891": {"epss_score": 0.00073, "epss_percentile": 0.22492}, "CVE-2023-2892": {"epss_score": 0.00068, "epss_percentile": 0.21322}, "CVE-2023-2893": {"epss_score": 0.00066, "epss_percentile": 0.20708}, "CVE-2023-2894": {"epss_score": 0.00095, "epss_percentile": 0.27132}, "CVE-2023-2895": {"epss_score": 0.00073, "epss_percentile": 0.22492}, "CVE-2023-2896": {"epss_score": 0.00073, "epss_percentile": 0.22492}, "CVE-2023-2897": {"epss_score": 0.00058, "epss_percentile": 0.18373}, "CVE-2023-2898": {"epss_score": 0.00019, "epss_percentile": 0.04053}, "CVE-2023-2899": {"epss_score": 0.00119, "epss_percentile": 0.31657}, "CVE-2023-2900": {"epss_score": 0.00048, "epss_percentile": 0.14963}, "CVE-2023-2901": {"epss_score": 0.00077, "epss_percentile": 0.23321}, "CVE-2023-2902": {"epss_score": 0.00075, "epss_percentile": 0.23017}, "CVE-2023-2903": {"epss_score": 0.00188, "epss_percentile": 0.40871}, "CVE-2023-2904": {"epss_score": 0.00124, "epss_percentile": 0.32378}, "CVE-2023-2905": {"epss_score": 0.00243, "epss_percentile": 0.47497}, "CVE-2023-2906": {"epss_score": 0.00132, "epss_percentile": 0.33544}, "CVE-2023-2907": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-2908": {"epss_score": 0.00013, "epss_percentile": 0.01721}, "CVE-2023-2909": {"epss_score": 0.00302, "epss_percentile": 0.53101}, "CVE-2023-2910": {"epss_score": 0.00555, "epss_percentile": 0.67478}, "CVE-2023-2911": {"epss_score": 0.0019, "epss_percentile": 0.41093}, "CVE-2023-2912": {"epss_score": 0.00185, "epss_percentile": 0.40467}, "CVE-2023-2913": {"epss_score": 0.00047, "epss_percentile": 0.14696}, "CVE-2023-2914": {"epss_score": 0.24162, "epss_percentile": 0.95881}, "CVE-2023-2915": {"epss_score": 0.08974, "epss_percentile": 0.92345}, "CVE-2023-2916": {"epss_score": 0.29501, "epss_percentile": 0.96448}, "CVE-2023-2917": {"epss_score": 0.40689, "epss_percentile": 0.97232}, "CVE-2023-2919": {"epss_score": 0.00139, "epss_percentile": 0.34628}, "CVE-2023-2921": {"epss_score": 0.00054, "epss_percentile": 0.17133}, "CVE-2023-2922": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-2923": {"epss_score": 0.00097, "epss_percentile": 0.27468}, "CVE-2023-2924": {"epss_score": 0.06224, "epss_percentile": 0.90584}, "CVE-2023-2925": {"epss_score": 0.0009, "epss_percentile": 0.26132}, "CVE-2023-2926": {"epss_score": 0.00052, "epss_percentile": 0.1651}, "CVE-2023-2927": {"epss_score": 0.00071, "epss_percentile": 0.22196}, "CVE-2023-2928": {"epss_score": 0.60329, "epss_percentile": 0.98204}, "CVE-2023-2929": {"epss_score": 0.00535, "epss_percentile": 0.66824}, "CVE-2023-2930": {"epss_score": 0.00101, "epss_percentile": 0.28582}, "CVE-2023-2931": {"epss_score": 0.00309, "epss_percentile": 0.53674}, "CVE-2023-2932": {"epss_score": 0.00309, "epss_percentile": 0.53674}, "CVE-2023-2933": {"epss_score": 0.00309, "epss_percentile": 0.53674}, "CVE-2023-2934": {"epss_score": 0.00725, "epss_percentile": 0.72061}, "CVE-2023-2935": {"epss_score": 0.09386, "epss_percentile": 0.92527}, "CVE-2023-2936": {"epss_score": 0.09386, "epss_percentile": 0.92527}, "CVE-2023-2937": {"epss_score": 0.00128, "epss_percentile": 0.33055}, "CVE-2023-2938": {"epss_score": 0.00128, "epss_percentile": 0.33055}, "CVE-2023-2939": {"epss_score": 0.00021, "epss_percentile": 0.0485}, "CVE-2023-2940": {"epss_score": 0.00022, "epss_percentile": 0.05014}, "CVE-2023-2941": {"epss_score": 0.00083, "epss_percentile": 0.24765}, "CVE-2023-2942": {"epss_score": 0.00342, "epss_percentile": 0.56388}, "CVE-2023-2943": {"epss_score": 0.00118, "epss_percentile": 0.31463}, "CVE-2023-2944": {"epss_score": 0.00064, "epss_percentile": 0.20306}, "CVE-2023-2945": {"epss_score": 0.00255, "epss_percentile": 0.48696}, "CVE-2023-2946": {"epss_score": 0.00067, "epss_percentile": 0.21105}, "CVE-2023-2947": {"epss_score": 0.2089, "epss_percentile": 0.95432}, "CVE-2023-2948": {"epss_score": 0.85498, "epss_percentile": 0.99336}, "CVE-2023-2949": {"epss_score": 0.72388, "epss_percentile": 0.98707}, "CVE-2023-2950": {"epss_score": 0.0036, "epss_percentile": 0.57654}, "CVE-2023-2951": {"epss_score": 0.00165, "epss_percentile": 0.38131}, "CVE-2023-2952": {"epss_score": 0.00027, "epss_percentile": 0.06915}, "CVE-2023-2953": {"epss_score": 0.01466, "epss_percentile": 0.80467}, "CVE-2023-2954": {"epss_score": 0.00106, "epss_percentile": 0.29427}, "CVE-2023-2955": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-2957": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-2958": {"epss_score": 0.00021, "epss_percentile": 0.04716}, "CVE-2023-2959": {"epss_score": 0.00026, "epss_percentile": 0.06627}, "CVE-2023-2960": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-2961": {"epss_score": 0.00023, "epss_percentile": 0.05405}, "CVE-2023-2962": {"epss_score": 0.00048, "epss_percentile": 0.15224}, "CVE-2023-2963": {"epss_score": 0.0009, "epss_percentile": 0.25991}, "CVE-2023-2964": {"epss_score": 0.00166, "epss_percentile": 0.38163}, "CVE-2023-2967": {"epss_score": 0.00099, "epss_percentile": 0.28424}, "CVE-2023-2968": {"epss_score": 0.00399, "epss_percentile": 0.60106}, "CVE-2023-2970": {"epss_score": 0.00047, "epss_percentile": 0.14755}, "CVE-2023-2971": {"epss_score": 0.00096, "epss_percentile": 0.2728}, "CVE-2023-2972": {"epss_score": 0.00085, "epss_percentile": 0.25099}, "CVE-2023-2973": {"epss_score": 0.00059, "epss_percentile": 0.1892}, "CVE-2023-2974": {"epss_score": 0.0042, "epss_percentile": 0.61402}, "CVE-2023-2975": {"epss_score": 0.00185, "epss_percentile": 0.40578}, "CVE-2023-2976": {"epss_score": 0.00079, "epss_percentile": 0.23915}, "CVE-2023-2977": {"epss_score": 0.00023, "epss_percentile": 0.05502}, "CVE-2023-2978": {"epss_score": 0.00034, "epss_percentile": 0.09791}, "CVE-2023-2979": {"epss_score": 0.00044, "epss_percentile": 0.1353}, "CVE-2023-2980": {"epss_score": 0.00083, "epss_percentile": 0.24722}, "CVE-2023-2981": {"epss_score": 0.00076, "epss_percentile": 0.23173}, "CVE-2023-2982": {"epss_score": 0.72493, "epss_percentile": 0.98713}, "CVE-2023-2983": {"epss_score": 5e-05, "epss_percentile": 0.00202}, "CVE-2023-2984": {"epss_score": 5e-05, "epss_percentile": 0.00228}, "CVE-2023-2985": {"epss_score": 9e-05, "epss_percentile": 0.00621}, "CVE-2023-2986": {"epss_score": 0.92255, "epss_percentile": 0.99703}, "CVE-2023-2987": {"epss_score": 0.00099, "epss_percentile": 0.2836}, "CVE-2023-2989": {"epss_score": 0.00072, "epss_percentile": 0.22372}, "CVE-2023-2990": {"epss_score": 0.0016, "epss_percentile": 0.37497}, "CVE-2023-2991": {"epss_score": 0.0022, "epss_percentile": 0.44587}, "CVE-2023-2992": {"epss_score": 0.00218, "epss_percentile": 0.44428}, "CVE-2023-2993": {"epss_score": 0.0008, "epss_percentile": 0.24038}, "CVE-2023-2995": {"epss_score": 0.00179, "epss_percentile": 0.39766}, "CVE-2023-2996": {"epss_score": 0.02775, "epss_percentile": 0.85634}, "CVE-2023-2998": {"epss_score": 0.00179, "epss_percentile": 0.39848}, "CVE-2023-2999": {"epss_score": 0.00074, "epss_percentile": 0.22802}, "CVE-2023-30013": {"epss_score": 0.91748, "epss_percentile": 0.99665}, "CVE-2023-30014": {"epss_score": 0.00934, "epss_percentile": 0.7566}, "CVE-2023-30015": {"epss_score": 0.00934, "epss_percentile": 0.7566}, "CVE-2023-30016": {"epss_score": 0.01017, "epss_percentile": 0.76692}, "CVE-2023-30018": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-30019": {"epss_score": 0.56226, "epss_percentile": 0.98013}, "CVE-2023-30024": {"epss_score": 0.00055, "epss_percentile": 0.17468}, "CVE-2023-30053": {"epss_score": 0.04222, "epss_percentile": 0.88411}, "CVE-2023-30054": {"epss_score": 0.04309, "epss_percentile": 0.88529}, "CVE-2023-30056": {"epss_score": 0.00209, "epss_percentile": 0.43378}, "CVE-2023-30057": {"epss_score": 0.00355, "epss_percentile": 0.57294}, "CVE-2023-30058": {"epss_score": 0.00088, "epss_percentile": 0.25695}, "CVE-2023-30061": {"epss_score": 0.00224, "epss_percentile": 0.45005}, "CVE-2023-30063": {"epss_score": 0.00125, "epss_percentile": 0.32499}, "CVE-2023-30065": {"epss_score": 0.01024, "epss_percentile": 0.76778}, "CVE-2023-30076": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-30077": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-30082": {"epss_score": 0.00284, "epss_percentile": 0.51468}, "CVE-2023-30083": {"epss_score": 0.00025, "epss_percentile": 0.06351}, "CVE-2023-30084": {"epss_score": 0.00023, "epss_percentile": 0.05635}, "CVE-2023-30085": {"epss_score": 0.00029, "epss_percentile": 0.07665}, "CVE-2023-30086": {"epss_score": 0.00063, "epss_percentile": 0.20065}, "CVE-2023-30087": {"epss_score": 0.00043, "epss_percentile": 0.13218}, "CVE-2023-30088": {"epss_score": 0.00035, "epss_percentile": 0.10003}, "CVE-2023-30090": {"epss_score": 0.00115, "epss_percentile": 0.30945}, "CVE-2023-30092": {"epss_score": 0.00245, "epss_percentile": 0.47636}, "CVE-2023-30093": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-30094": {"epss_score": 0.00532, "epss_percentile": 0.66679}, "CVE-2023-30095": {"epss_score": 0.00489, "epss_percentile": 0.649}, "CVE-2023-30096": {"epss_score": 0.00489, "epss_percentile": 0.649}, "CVE-2023-30097": {"epss_score": 0.00489, "epss_percentile": 0.649}, "CVE-2023-30106": {"epss_score": 0.00105, "epss_percentile": 0.29285}, "CVE-2023-30111": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-30112": {"epss_score": 0.00062, "epss_percentile": 0.19709}, "CVE-2023-30122": {"epss_score": 0.00115, "epss_percentile": 0.30945}, "CVE-2023-30123": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-30124": {"epss_score": 0.00085, "epss_percentile": 0.25145}, "CVE-2023-30125": {"epss_score": 0.00109, "epss_percentile": 0.2994}, "CVE-2023-30130": {"epss_score": 0.05521, "epss_percentile": 0.89958}, "CVE-2023-30131": {"epss_score": 0.0024, "epss_percentile": 0.46942}, "CVE-2023-30132": {"epss_score": 0.0002, "epss_percentile": 0.04658}, "CVE-2023-30135": {"epss_score": 0.0205, "epss_percentile": 0.83398}, "CVE-2023-30145": {"epss_score": 0.58834, "epss_percentile": 0.98139}, "CVE-2023-30146": {"epss_score": 0.01495, "epss_percentile": 0.80652}, "CVE-2023-30148": {"epss_score": 0.00035, "epss_percentile": 0.09919}, "CVE-2023-30149": {"epss_score": 0.10577, "epss_percentile": 0.93033}, "CVE-2023-30150": {"epss_score": 0.5798, "epss_percentile": 0.98094}, "CVE-2023-30151": {"epss_score": 0.00982, "epss_percentile": 0.76289}, "CVE-2023-30153": {"epss_score": 0.00269, "epss_percentile": 0.50121}, "CVE-2023-30154": {"epss_score": 0.00293, "epss_percentile": 0.52306}, "CVE-2023-30172": {"epss_score": 0.0046, "epss_percentile": 0.63514}, "CVE-2023-30177": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-30179": {"epss_score": 0.04157, "epss_percentile": 0.88329}, "CVE-2023-30184": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-30185": {"epss_score": 0.00483, "epss_percentile": 0.6462}, "CVE-2023-30186": {"epss_score": 0.00934, "epss_percentile": 0.75655}, "CVE-2023-30187": {"epss_score": 0.01876, "epss_percentile": 0.82661}, "CVE-2023-30188": {"epss_score": 0.00846, "epss_percentile": 0.74332}, "CVE-2023-30189": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-30191": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-30192": {"epss_score": 0.32771, "epss_percentile": 0.96723}, "CVE-2023-30194": {"epss_score": 0.73529, "epss_percentile": 0.98759}, "CVE-2023-30195": {"epss_score": 0.00082, "epss_percentile": 0.24462}, "CVE-2023-30196": {"epss_score": 0.00238, "epss_percentile": 0.4676}, "CVE-2023-30197": {"epss_score": 0.00105, "epss_percentile": 0.29361}, "CVE-2023-30198": {"epss_score": 0.04394, "epss_percentile": 0.88638}, "CVE-2023-30199": {"epss_score": 0.00105, "epss_percentile": 0.29361}, "CVE-2023-30200": {"epss_score": 0.00098, "epss_percentile": 0.27709}, "CVE-2023-30203": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-30204": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-30205": {"epss_score": 0.00069, "epss_percentile": 0.21499}, "CVE-2023-30207": {"epss_score": 0.00022, "epss_percentile": 0.05241}, "CVE-2023-30210": {"epss_score": 0.118, "epss_percentile": 0.93481}, "CVE-2023-30211": {"epss_score": 0.00224, "epss_percentile": 0.45011}, "CVE-2023-30212": {"epss_score": 0.66021, "epss_percentile": 0.98447}, "CVE-2023-30216": {"epss_score": 0.0005, "epss_percentile": 0.1582}, "CVE-2023-30222": {"epss_score": 0.00301, "epss_percentile": 0.53012}, "CVE-2023-30223": {"epss_score": 0.00027, "epss_percentile": 0.06955}, "CVE-2023-30226": {"epss_score": 0.00044, "epss_percentile": 0.13517}, "CVE-2023-30237": {"epss_score": 0.00025, "epss_percentile": 0.06242}, "CVE-2023-30242": {"epss_score": 0.00073, "epss_percentile": 0.22583}, "CVE-2023-30243": {"epss_score": 0.00062, "epss_percentile": 0.19709}, "CVE-2023-30245": {"epss_score": 0.01265, "epss_percentile": 0.79005}, "CVE-2023-30246": {"epss_score": 0.00934, "epss_percentile": 0.7566}, "CVE-2023-30247": {"epss_score": 0.01385, "epss_percentile": 0.79902}, "CVE-2023-30253": {"epss_score": 0.88215, "epss_percentile": 0.99462}, "CVE-2023-30256": {"epss_score": 0.7776, "epss_percentile": 0.98952}, "CVE-2023-30257": {"epss_score": 0.00043, "epss_percentile": 0.13136}, "CVE-2023-30258": {"epss_score": 0.93708, "epss_percentile": 0.99836}, "CVE-2023-30259": {"epss_score": 0.00032, "epss_percentile": 0.08962}, "CVE-2023-30260": {"epss_score": 0.02674, "epss_percentile": 0.85397}, "CVE-2023-30261": {"epss_score": 0.53692, "epss_percentile": 0.97892}, "CVE-2023-30262": {"epss_score": 0.0384, "epss_percentile": 0.8783}, "CVE-2023-30264": {"epss_score": 0.00107, "epss_percentile": 0.29629}, "CVE-2023-30265": {"epss_score": 0.00264, "epss_percentile": 0.49697}, "CVE-2023-30266": {"epss_score": 0.00098, "epss_percentile": 0.27784}, "CVE-2023-30267": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-30268": {"epss_score": 0.00162, "epss_percentile": 0.37689}, "CVE-2023-30269": {"epss_score": 0.0007, "epss_percentile": 0.21658}, "CVE-2023-30280": {"epss_score": 0.04879, "epss_percentile": 0.89243}, "CVE-2023-30281": {"epss_score": 0.00055, "epss_percentile": 0.17531}, "CVE-2023-30282": {"epss_score": 0.0007, "epss_percentile": 0.21722}, "CVE-2023-30285": {"epss_score": 0.00226, "epss_percentile": 0.45259}, "CVE-2023-30297": {"epss_score": 0.00037, "epss_percentile": 0.10742}, "CVE-2023-30300": {"epss_score": 0.00019, "epss_percentile": 0.04415}, "CVE-2023-30305": {"epss_score": 0.00317, "epss_percentile": 0.5435}, "CVE-2023-30306": {"epss_score": 0.0033, "epss_percentile": 0.55437}, "CVE-2023-30307": {"epss_score": 0.00162, "epss_percentile": 0.37665}, "CVE-2023-30308": {"epss_score": 0.0015, "epss_percentile": 0.36153}, "CVE-2023-30309": {"epss_score": 0.00092, "epss_percentile": 0.26472}, "CVE-2023-30310": {"epss_score": 0.00347, "epss_percentile": 0.5675}, "CVE-2023-30311": {"epss_score": 0.00347, "epss_percentile": 0.5675}, "CVE-2023-30312": {"epss_score": 0.00135, "epss_percentile": 0.3404}, "CVE-2023-30313": {"epss_score": 0.00347, "epss_percentile": 0.5675}, "CVE-2023-30314": {"epss_score": 0.00347, "epss_percentile": 0.56761}, "CVE-2023-30319": {"epss_score": 0.00145, "epss_percentile": 0.35371}, "CVE-2023-30320": {"epss_score": 0.00145, "epss_percentile": 0.3538}, "CVE-2023-30321": {"epss_score": 0.00145, "epss_percentile": 0.3538}, "CVE-2023-30322": {"epss_score": 0.00123, "epss_percentile": 0.32308}, "CVE-2023-30323": {"epss_score": 0.00065, "epss_percentile": 0.20599}, "CVE-2023-30325": {"epss_score": 0.00065, "epss_percentile": 0.20599}, "CVE-2023-30326": {"epss_score": 0.00132, "epss_percentile": 0.33581}, "CVE-2023-30328": {"epss_score": 0.00061, "epss_percentile": 0.19375}, "CVE-2023-30330": {"epss_score": 0.01114, "epss_percentile": 0.77693}, "CVE-2023-30331": {"epss_score": 0.0025, "epss_percentile": 0.48256}, "CVE-2023-30333": {"epss_score": 0.00107, "epss_percentile": 0.29635}, "CVE-2023-30334": {"epss_score": 0.00269, "epss_percentile": 0.50187}, "CVE-2023-30338": {"epss_score": 0.00421, "epss_percentile": 0.61492}, "CVE-2023-30347": {"epss_score": 0.00233, "epss_percentile": 0.45986}, "CVE-2023-30349": {"epss_score": 0.07722, "epss_percentile": 0.91644}, "CVE-2023-30350": {"epss_score": 0.01991, "epss_percentile": 0.83176}, "CVE-2023-30351": {"epss_score": 0.00033, "epss_percentile": 0.09281}, "CVE-2023-30352": {"epss_score": 0.00089, "epss_percentile": 0.25977}, "CVE-2023-30353": {"epss_score": 0.01589, "epss_percentile": 0.81195}, "CVE-2023-30354": {"epss_score": 0.00042, "epss_percentile": 0.12667}, "CVE-2023-30356": {"epss_score": 0.00051, "epss_percentile": 0.16301}, "CVE-2023-30362": {"epss_score": 0.0015, "epss_percentile": 0.3605}, "CVE-2023-30363": {"epss_score": 0.0036, "epss_percentile": 0.57635}, "CVE-2023-30367": {"epss_score": 0.00072, "epss_percentile": 0.2235}, "CVE-2023-30368": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-30369": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-30370": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-30371": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-30372": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-30373": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-30375": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-30376": {"epss_score": 0.00158, "epss_percentile": 0.37194}, "CVE-2023-30378": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-30380": {"epss_score": 0.00662, "epss_percentile": 0.70596}, "CVE-2023-30382": {"epss_score": 0.00039, "epss_percentile": 0.11791}, "CVE-2023-30383": {"epss_score": 0.00299, "epss_percentile": 0.52841}, "CVE-2023-30394": {"epss_score": 0.00346, "epss_percentile": 0.56603}, "CVE-2023-30399": {"epss_score": 0.00066, "epss_percentile": 0.20872}, "CVE-2023-30400": {"epss_score": 0.00398, "epss_percentile": 0.60074}, "CVE-2023-30402": {"epss_score": 0.00029, "epss_percentile": 0.07663}, "CVE-2023-30403": {"epss_score": 0.00065, "epss_percentile": 0.20506}, "CVE-2023-30404": {"epss_score": 0.02518, "epss_percentile": 0.84993}, "CVE-2023-30405": {"epss_score": 0.05333, "epss_percentile": 0.8974}, "CVE-2023-30406": {"epss_score": 0.00054, "epss_percentile": 0.17041}, "CVE-2023-30408": {"epss_score": 0.00054, "epss_percentile": 0.17041}, "CVE-2023-30410": {"epss_score": 0.00056, "epss_percentile": 0.17749}, "CVE-2023-30414": {"epss_score": 0.00073, "epss_percentile": 0.2256}, "CVE-2023-30415": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2023-30417": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-30421": {"epss_score": 0.0002, "epss_percentile": 0.04621}, "CVE-2023-30428": {"epss_score": 0.00098, "epss_percentile": 0.27816}, "CVE-2023-30429": {"epss_score": 0.00069, "epss_percentile": 0.21534}, "CVE-2023-30430": {"epss_score": 0.0004, "epss_percentile": 0.12135}, "CVE-2023-30431": {"epss_score": 0.00035, "epss_percentile": 0.09984}, "CVE-2023-30433": {"epss_score": 0.00053, "epss_percentile": 0.16935}, "CVE-2023-30434": {"epss_score": 0.00017, "epss_percentile": 0.03448}, "CVE-2023-30435": {"epss_score": 0.001, "epss_percentile": 0.2853}, "CVE-2023-30436": {"epss_score": 0.00096, "epss_percentile": 0.27285}, "CVE-2023-30437": {"epss_score": 0.00103, "epss_percentile": 0.28969}, "CVE-2023-30438": {"epss_score": 0.00028, "epss_percentile": 0.07512}, "CVE-2023-30440": {"epss_score": 0.00019, "epss_percentile": 0.04371}, "CVE-2023-30441": {"epss_score": 0.00037, "epss_percentile": 0.10728}, "CVE-2023-30442": {"epss_score": 0.00089, "epss_percentile": 0.25978}, "CVE-2023-30443": {"epss_score": 0.00066, "epss_percentile": 0.20746}, "CVE-2023-30444": {"epss_score": 0.00051, "epss_percentile": 0.1611}, "CVE-2023-30445": {"epss_score": 0.00043, "epss_percentile": 0.13138}, "CVE-2023-30446": {"epss_score": 0.00089, "epss_percentile": 0.25978}, "CVE-2023-30447": {"epss_score": 0.00089, "epss_percentile": 0.25978}, "CVE-2023-30448": {"epss_score": 0.00043, "epss_percentile": 0.13138}, "CVE-2023-30449": {"epss_score": 0.00043, "epss_percentile": 0.13138}, "CVE-2023-30450": {"epss_score": 0.00084, "epss_percentile": 0.24978}, "CVE-2023-30451": {"epss_score": 0.00255, "epss_percentile": 0.4872}, "CVE-2023-30452": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-30453": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-30454": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-30455": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-30456": {"epss_score": 0.00013, "epss_percentile": 0.01664}, "CVE-2023-30458": {"epss_score": 0.00188, "epss_percentile": 0.40911}, "CVE-2023-30459": {"epss_score": 0.45588, "epss_percentile": 0.97492}, "CVE-2023-30463": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-30464": {"epss_score": 0.00055, "epss_percentile": 0.17557}, "CVE-2023-30465": {"epss_score": 0.00163, "epss_percentile": 0.37834}, "CVE-2023-30466": {"epss_score": 0.00906, "epss_percentile": 0.7525}, "CVE-2023-30467": {"epss_score": 0.00316, "epss_percentile": 0.54288}, "CVE-2023-30469": {"epss_score": 0.00323, "epss_percentile": 0.5492}, "CVE-2023-30470": {"epss_score": 0.02199, "epss_percentile": 0.83968}, "CVE-2023-30471": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-30472": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-30473": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30474": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-30475": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30476": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-30477": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-30478": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-30479": {"epss_score": 0.0021, "epss_percentile": 0.43443}, "CVE-2023-30480": {"epss_score": 0.00061, "epss_percentile": 0.19393}, "CVE-2023-30481": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30482": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2023-30483": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30484": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-30485": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30486": {"epss_score": 0.04865, "epss_percentile": 0.89228}, "CVE-2023-30487": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30488": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-30489": {"epss_score": 0.00427, "epss_percentile": 0.61783}, "CVE-2023-30490": {"epss_score": 0.00255, "epss_percentile": 0.48705}, "CVE-2023-30491": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-30492": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-30493": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-30494": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30495": {"epss_score": 0.00131, "epss_percentile": 0.33428}, "CVE-2023-30496": {"epss_score": 0.00087, "epss_percentile": 0.25547}, "CVE-2023-30497": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-30498": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30499": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30500": {"epss_score": 0.0012, "epss_percentile": 0.31739}, "CVE-2023-30501": {"epss_score": 0.00149, "epss_percentile": 0.36016}, "CVE-2023-30502": {"epss_score": 0.00149, "epss_percentile": 0.36016}, "CVE-2023-30503": {"epss_score": 0.00149, "epss_percentile": 0.36016}, "CVE-2023-30504": {"epss_score": 0.00149, "epss_percentile": 0.36016}, "CVE-2023-30505": {"epss_score": 0.00149, "epss_percentile": 0.36016}, "CVE-2023-30506": {"epss_score": 0.00149, "epss_percentile": 0.36016}, "CVE-2023-30507": {"epss_score": 0.00054, "epss_percentile": 0.17271}, "CVE-2023-30508": {"epss_score": 0.00054, "epss_percentile": 0.17271}, "CVE-2023-30509": {"epss_score": 0.00054, "epss_percentile": 0.17271}, "CVE-2023-30510": {"epss_score": 0.00044, "epss_percentile": 0.13583}, "CVE-2023-30512": {"epss_score": 0.00077, "epss_percentile": 0.23532}, "CVE-2023-30513": {"epss_score": 0.00086, "epss_percentile": 0.25302}, "CVE-2023-30514": {"epss_score": 0.00037, "epss_percentile": 0.10782}, "CVE-2023-30515": {"epss_score": 0.00036, "epss_percentile": 0.10441}, "CVE-2023-30516": {"epss_score": 0.00049, "epss_percentile": 0.15621}, "CVE-2023-30517": {"epss_score": 0.00037, "epss_percentile": 0.10652}, "CVE-2023-30518": {"epss_score": 0.00093, "epss_percentile": 0.26611}, "CVE-2023-30519": {"epss_score": 0.00176, "epss_percentile": 0.3947}, "CVE-2023-30520": {"epss_score": 0.01202, "epss_percentile": 0.78485}, "CVE-2023-30521": {"epss_score": 0.00111, "epss_percentile": 0.30267}, "CVE-2023-30522": {"epss_score": 0.00057, "epss_percentile": 0.18026}, "CVE-2023-30523": {"epss_score": 0.0004, "epss_percentile": 0.12139}, "CVE-2023-30524": {"epss_score": 0.00088, "epss_percentile": 0.25697}, "CVE-2023-30525": {"epss_score": 0.00095, "epss_percentile": 0.27111}, "CVE-2023-30526": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-30527": {"epss_score": 0.0004, "epss_percentile": 0.12139}, "CVE-2023-30528": {"epss_score": 0.00036, "epss_percentile": 0.10441}, "CVE-2023-30529": {"epss_score": 0.0016, "epss_percentile": 0.37512}, "CVE-2023-30530": {"epss_score": 0.0004, "epss_percentile": 0.12139}, "CVE-2023-30531": {"epss_score": 0.00036, "epss_percentile": 0.10441}, "CVE-2023-30532": {"epss_score": 0.0009, "epss_percentile": 0.26123}, "CVE-2023-30533": {"epss_score": 0.03841, "epss_percentile": 0.87832}, "CVE-2023-30534": {"epss_score": 0.41972, "epss_percentile": 0.97304}, "CVE-2023-30535": {"epss_score": 0.02065, "epss_percentile": 0.83457}, "CVE-2023-30536": {"epss_score": 0.0011, "epss_percentile": 0.30151}, "CVE-2023-30537": {"epss_score": 0.02151, "epss_percentile": 0.83784}, "CVE-2023-30538": {"epss_score": 0.00127, "epss_percentile": 0.32788}, "CVE-2023-30539": {"epss_score": 0.003, "epss_percentile": 0.52956}, "CVE-2023-30540": {"epss_score": 0.00641, "epss_percentile": 0.6999}, "CVE-2023-30541": {"epss_score": 0.00105, "epss_percentile": 0.29294}, "CVE-2023-30542": {"epss_score": 0.00175, "epss_percentile": 0.39354}, "CVE-2023-30543": {"epss_score": 0.00041, "epss_percentile": 0.12277}, "CVE-2023-30544": {"epss_score": 0.00395, "epss_percentile": 0.59849}, "CVE-2023-30545": {"epss_score": 0.00447, "epss_percentile": 0.62987}, "CVE-2023-30546": {"epss_score": 0.00213, "epss_percentile": 0.43829}, "CVE-2023-30547": {"epss_score": 0.83556, "epss_percentile": 0.99253}, "CVE-2023-30548": {"epss_score": 0.01899, "epss_percentile": 0.82767}, "CVE-2023-30549": {"epss_score": 0.00033, "epss_percentile": 0.09319}, "CVE-2023-30550": {"epss_score": 0.00034, "epss_percentile": 0.09695}, "CVE-2023-30551": {"epss_score": 0.00423, "epss_percentile": 0.61625}, "CVE-2023-30552": {"epss_score": 0.00749, "epss_percentile": 0.72594}, "CVE-2023-30553": {"epss_score": 0.00749, "epss_percentile": 0.72594}, "CVE-2023-30554": {"epss_score": 0.00329, "epss_percentile": 0.55413}, "CVE-2023-30555": {"epss_score": 0.00749, "epss_percentile": 0.72594}, "CVE-2023-30556": {"epss_score": 0.00329, "epss_percentile": 0.55413}, "CVE-2023-30557": {"epss_score": 0.01014, "epss_percentile": 0.76652}, "CVE-2023-30558": {"epss_score": 0.00749, "epss_percentile": 0.72594}, "CVE-2023-30559": {"epss_score": 0.00069, "epss_percentile": 0.21544}, "CVE-2023-30560": {"epss_score": 0.00111, "epss_percentile": 0.30281}, "CVE-2023-30561": {"epss_score": 0.00046, "epss_percentile": 0.14108}, "CVE-2023-30562": {"epss_score": 0.00062, "epss_percentile": 0.19717}, "CVE-2023-30563": {"epss_score": 0.00477, "epss_percentile": 0.64307}, "CVE-2023-30564": {"epss_score": 0.00106, "epss_percentile": 0.29409}, "CVE-2023-30565": {"epss_score": 0.0016, "epss_percentile": 0.37484}, "CVE-2023-30570": {"epss_score": 0.00195, "epss_percentile": 0.41604}, "CVE-2023-30571": {"epss_score": 0.00013, "epss_percentile": 0.01605}, "CVE-2023-30575": {"epss_score": 0.00104, "epss_percentile": 0.2912}, "CVE-2023-30576": {"epss_score": 0.00206, "epss_percentile": 0.42941}, "CVE-2023-30577": {"epss_score": 0.00149, "epss_percentile": 0.35936}, "CVE-2023-30581": {"epss_score": 0.00017, "epss_percentile": 0.03186}, "CVE-2023-30582": {"epss_score": 0.00072, "epss_percentile": 0.22425}, "CVE-2023-30583": {"epss_score": 0.00016, "epss_percentile": 0.02808}, "CVE-2023-30584": {"epss_score": 0.00021, "epss_percentile": 0.04771}, "CVE-2023-30585": {"epss_score": 0.02122, "epss_percentile": 0.83683}, "CVE-2023-30586": {"epss_score": 0.00062, "epss_percentile": 0.19756}, "CVE-2023-30587": {"epss_score": 0.00018, "epss_percentile": 0.03928}, "CVE-2023-30588": {"epss_score": 0.00028, "epss_percentile": 0.07254}, "CVE-2023-30589": {"epss_score": 0.01767, "epss_percentile": 0.82174}, "CVE-2023-30590": {"epss_score": 0.00879, "epss_percentile": 0.74844}, "CVE-2023-30591": {"epss_score": 0.01785, "epss_percentile": 0.82254}, "CVE-2023-30601": {"epss_score": 0.00018, "epss_percentile": 0.03833}, "CVE-2023-30602": {"epss_score": 0.00087, "epss_percentile": 0.25608}, "CVE-2023-30603": {"epss_score": 0.00531, "epss_percentile": 0.66667}, "CVE-2023-30604": {"epss_score": 0.00378, "epss_percentile": 0.58828}, "CVE-2023-30605": {"epss_score": 0.00749, "epss_percentile": 0.72594}, "CVE-2023-30606": {"epss_score": 0.00054, "epss_percentile": 0.17113}, "CVE-2023-30607": {"epss_score": 0.00113, "epss_percentile": 0.30609}, "CVE-2023-30608": {"epss_score": 0.01223, "epss_percentile": 0.78665}, "CVE-2023-30609": {"epss_score": 0.00385, "epss_percentile": 0.59215}, "CVE-2023-30610": {"epss_score": 0.00095, "epss_percentile": 0.27226}, "CVE-2023-30611": {"epss_score": 0.0022, "epss_percentile": 0.44587}, "CVE-2023-30612": {"epss_score": 0.00052, "epss_percentile": 0.1662}, "CVE-2023-30613": {"epss_score": 0.00316, "epss_percentile": 0.54274}, "CVE-2023-30614": {"epss_score": 0.0044, "epss_percentile": 0.62613}, "CVE-2023-30615": {"epss_score": 0.00544, "epss_percentile": 0.67131}, "CVE-2023-30616": {"epss_score": 0.00206, "epss_percentile": 0.43033}, "CVE-2023-30617": {"epss_score": 0.00122, "epss_percentile": 0.32122}, "CVE-2023-30618": {"epss_score": 0.0003, "epss_percentile": 0.07989}, "CVE-2023-30619": {"epss_score": 0.00422, "epss_percentile": 0.6156}, "CVE-2023-30620": {"epss_score": 0.01179, "epss_percentile": 0.78296}, "CVE-2023-30621": {"epss_score": 0.00752, "epss_percentile": 0.72652}, "CVE-2023-30622": {"epss_score": 0.00039, "epss_percentile": 0.11861}, "CVE-2023-30623": {"epss_score": 0.01343, "epss_percentile": 0.79602}, "CVE-2023-30624": {"epss_score": 0.00101, "epss_percentile": 0.28645}, "CVE-2023-30625": {"epss_score": 0.88827, "epss_percentile": 0.99492}, "CVE-2023-30626": {"epss_score": 0.00962, "epss_percentile": 0.75994}, "CVE-2023-30627": {"epss_score": 0.00601, "epss_percentile": 0.68834}, "CVE-2023-30628": {"epss_score": 0.01816, "epss_percentile": 0.82393}, "CVE-2023-30629": {"epss_score": 0.00205, "epss_percentile": 0.42759}, "CVE-2023-30630": {"epss_score": 0.00039, "epss_percentile": 0.11806}, "CVE-2023-30631": {"epss_score": 0.00544, "epss_percentile": 0.67149}, "CVE-2023-30633": {"epss_score": 0.00135, "epss_percentile": 0.33988}, "CVE-2023-30635": {"epss_score": 0.00286, "epss_percentile": 0.51717}, "CVE-2023-30636": {"epss_score": 0.00286, "epss_percentile": 0.51717}, "CVE-2023-30637": {"epss_score": 0.00079, "epss_percentile": 0.23903}, "CVE-2023-30638": {"epss_score": 0.00805, "epss_percentile": 0.7364}, "CVE-2023-30639": {"epss_score": 0.00208, "epss_percentile": 0.43286}, "CVE-2023-30640": {"epss_score": 0.0004, "epss_percentile": 0.11922}, "CVE-2023-30641": {"epss_score": 0.00085, "epss_percentile": 0.25114}, "CVE-2023-30642": {"epss_score": 0.0004, "epss_percentile": 0.11922}, "CVE-2023-30643": {"epss_score": 0.00041, "epss_percentile": 0.12476}, "CVE-2023-30644": {"epss_score": 0.00066, "epss_percentile": 0.20908}, "CVE-2023-30645": {"epss_score": 0.00066, "epss_percentile": 0.20908}, "CVE-2023-30646": {"epss_score": 0.00066, "epss_percentile": 0.20908}, "CVE-2023-30647": {"epss_score": 0.00066, "epss_percentile": 0.20908}, "CVE-2023-30648": {"epss_score": 0.00043, "epss_percentile": 0.13168}, "CVE-2023-30649": {"epss_score": 0.00066, "epss_percentile": 0.20908}, "CVE-2023-30650": {"epss_score": 0.00038, "epss_percentile": 0.11111}, "CVE-2023-30651": {"epss_score": 0.00038, "epss_percentile": 0.11111}, "CVE-2023-30652": {"epss_score": 0.00038, "epss_percentile": 0.11111}, "CVE-2023-30653": {"epss_score": 0.00038, "epss_percentile": 0.11111}, "CVE-2023-30654": {"epss_score": 0.00024, "epss_percentile": 0.05677}, "CVE-2023-30655": {"epss_score": 0.00038, "epss_percentile": 0.11163}, "CVE-2023-30656": {"epss_score": 0.00038, "epss_percentile": 0.11163}, "CVE-2023-30657": {"epss_score": 0.00039, "epss_percentile": 0.11626}, "CVE-2023-30658": {"epss_score": 0.00038, "epss_percentile": 0.11163}, "CVE-2023-30659": {"epss_score": 0.00039, "epss_percentile": 0.11626}, "CVE-2023-30660": {"epss_score": 0.00054, "epss_percentile": 0.17108}, "CVE-2023-30661": {"epss_score": 0.00054, "epss_percentile": 0.17108}, "CVE-2023-30662": {"epss_score": 0.00054, "epss_percentile": 0.17108}, "CVE-2023-30663": {"epss_score": 0.00042, "epss_percentile": 0.12766}, "CVE-2023-30664": {"epss_score": 0.00038, "epss_percentile": 0.11163}, "CVE-2023-30665": {"epss_score": 0.00049, "epss_percentile": 0.1533}, "CVE-2023-30666": {"epss_score": 0.00042, "epss_percentile": 0.12766}, "CVE-2023-30667": {"epss_score": 0.00038, "epss_percentile": 0.11324}, "CVE-2023-30668": {"epss_score": 0.00029, "epss_percentile": 0.07697}, "CVE-2023-30669": {"epss_score": 0.00029, "epss_percentile": 0.07697}, "CVE-2023-30670": {"epss_score": 0.00028, "epss_percentile": 0.0729}, "CVE-2023-30671": {"epss_score": 0.0003, "epss_percentile": 0.08259}, "CVE-2023-30672": {"epss_score": 0.00058, "epss_percentile": 0.18293}, "CVE-2023-30673": {"epss_score": 0.00037, "epss_percentile": 0.10642}, "CVE-2023-30674": {"epss_score": 0.001, "epss_percentile": 0.28458}, "CVE-2023-30675": {"epss_score": 0.00036, "epss_percentile": 0.10258}, "CVE-2023-30676": {"epss_score": 0.00089, "epss_percentile": 0.25931}, "CVE-2023-30677": {"epss_score": 0.00089, "epss_percentile": 0.25931}, "CVE-2023-30678": {"epss_score": 0.00122, "epss_percentile": 0.32128}, "CVE-2023-30679": {"epss_score": 0.00042, "epss_percentile": 0.12606}, "CVE-2023-30680": {"epss_score": 0.00056, "epss_percentile": 0.17872}, "CVE-2023-30681": {"epss_score": 0.00028, "epss_percentile": 0.07329}, "CVE-2023-30682": {"epss_score": 0.0004, "epss_percentile": 0.11966}, "CVE-2023-30683": {"epss_score": 0.0004, "epss_percentile": 0.11966}, "CVE-2023-30684": {"epss_score": 0.0004, "epss_percentile": 0.11966}, "CVE-2023-30685": {"epss_score": 0.00054, "epss_percentile": 0.17154}, "CVE-2023-30686": {"epss_score": 0.00029, "epss_percentile": 0.07697}, "CVE-2023-30687": {"epss_score": 0.00029, "epss_percentile": 0.07697}, "CVE-2023-30688": {"epss_score": 0.00029, "epss_percentile": 0.07697}, "CVE-2023-30689": {"epss_score": 0.00029, "epss_percentile": 0.07697}, "CVE-2023-30690": {"epss_score": 0.00044, "epss_percentile": 0.13463}, "CVE-2023-30691": {"epss_score": 0.00065, "epss_percentile": 0.20571}, "CVE-2023-30692": {"epss_score": 0.00108, "epss_percentile": 0.29843}, "CVE-2023-30693": {"epss_score": 8e-05, "epss_percentile": 0.00483}, "CVE-2023-30694": {"epss_score": 0.00029, "epss_percentile": 0.07697}, "CVE-2023-30695": {"epss_score": 0.00029, "epss_percentile": 0.07697}, "CVE-2023-30696": {"epss_score": 0.00028, "epss_percentile": 0.07329}, "CVE-2023-30697": {"epss_score": 0.00028, "epss_percentile": 0.07329}, "CVE-2023-30698": {"epss_score": 0.00037, "epss_percentile": 0.10638}, "CVE-2023-30699": {"epss_score": 0.02241, "epss_percentile": 0.84116}, "CVE-2023-30700": {"epss_score": 0.00053, "epss_percentile": 0.17038}, "CVE-2023-30701": {"epss_score": 0.00048, "epss_percentile": 0.15141}, "CVE-2023-30702": {"epss_score": 0.00035, "epss_percentile": 0.10137}, "CVE-2023-30703": {"epss_score": 0.00153, "epss_percentile": 0.36565}, "CVE-2023-30704": {"epss_score": 0.0006, "epss_percentile": 0.19072}, "CVE-2023-30705": {"epss_score": 0.00048, "epss_percentile": 0.15141}, "CVE-2023-30706": {"epss_score": 0.00222, "epss_percentile": 0.44768}, "CVE-2023-30707": {"epss_score": 0.00046, "epss_percentile": 0.14415}, "CVE-2023-30708": {"epss_score": 0.00254, "epss_percentile": 0.48573}, "CVE-2023-30709": {"epss_score": 0.00056, "epss_percentile": 0.17682}, "CVE-2023-30710": {"epss_score": 0.00076, "epss_percentile": 0.23231}, "CVE-2023-30711": {"epss_score": 0.00107, "epss_percentile": 0.29679}, "CVE-2023-30712": {"epss_score": 0.001, "epss_percentile": 0.28457}, "CVE-2023-30713": {"epss_score": 0.00074, "epss_percentile": 0.22704}, "CVE-2023-30714": {"epss_score": 0.00129, "epss_percentile": 0.33075}, "CVE-2023-30715": {"epss_score": 0.00134, "epss_percentile": 0.3379}, "CVE-2023-30716": {"epss_score": 0.00099, "epss_percentile": 0.284}, "CVE-2023-30717": {"epss_score": 0.00134, "epss_percentile": 0.3379}, "CVE-2023-30718": {"epss_score": 0.00062, "epss_percentile": 0.19758}, "CVE-2023-30719": {"epss_score": 0.0011, "epss_percentile": 0.30148}, "CVE-2023-30720": {"epss_score": 0.00089, "epss_percentile": 0.25966}, "CVE-2023-30721": {"epss_score": 0.00065, "epss_percentile": 0.20479}, "CVE-2023-30722": {"epss_score": 0.00086, "epss_percentile": 0.25321}, "CVE-2023-30723": {"epss_score": 0.00218, "epss_percentile": 0.44352}, "CVE-2023-30724": {"epss_score": 0.00135, "epss_percentile": 0.34044}, "CVE-2023-30725": {"epss_score": 0.00117, "epss_percentile": 0.31323}, "CVE-2023-30726": {"epss_score": 0.00089, "epss_percentile": 0.25966}, "CVE-2023-30727": {"epss_score": 0.00094, "epss_percentile": 0.26795}, "CVE-2023-30728": {"epss_score": 0.00064, "epss_percentile": 0.20134}, "CVE-2023-30729": {"epss_score": 0.00271, "epss_percentile": 0.50318}, "CVE-2023-30730": {"epss_score": 0.00085, "epss_percentile": 0.25158}, "CVE-2023-30731": {"epss_score": 0.00069, "epss_percentile": 0.21591}, "CVE-2023-30732": {"epss_score": 0.00088, "epss_percentile": 0.25638}, "CVE-2023-30733": {"epss_score": 0.00052, "epss_percentile": 0.16363}, "CVE-2023-30734": {"epss_score": 0.00086, "epss_percentile": 0.253}, "CVE-2023-30735": {"epss_score": 0.00048, "epss_percentile": 0.14992}, "CVE-2023-30736": {"epss_score": 0.00097, "epss_percentile": 0.27617}, "CVE-2023-30737": {"epss_score": 0.00086, "epss_percentile": 0.253}, "CVE-2023-30738": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2023-30739": {"epss_score": 0.00049, "epss_percentile": 0.15293}, "CVE-2023-30740": {"epss_score": 0.00151, "epss_percentile": 0.36349}, "CVE-2023-30741": {"epss_score": 0.00193, "epss_percentile": 0.41411}, "CVE-2023-30742": {"epss_score": 0.0035, "epss_percentile": 0.56962}, "CVE-2023-30743": {"epss_score": 0.00134, "epss_percentile": 0.33898}, "CVE-2023-30744": {"epss_score": 0.00234, "epss_percentile": 0.46177}, "CVE-2023-30745": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-30746": {"epss_score": 0.00069, "epss_percentile": 0.21494}, "CVE-2023-30747": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30748": {"epss_score": 0.00112, "epss_percentile": 0.30514}, "CVE-2023-30749": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-30750": {"epss_score": 0.00131, "epss_percentile": 0.33428}, "CVE-2023-30751": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-30752": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-30753": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30754": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30755": {"epss_score": 0.00317, "epss_percentile": 0.5439}, "CVE-2023-30756": {"epss_score": 0.00401, "epss_percentile": 0.60257}, "CVE-2023-30757": {"epss_score": 0.00063, "epss_percentile": 0.19853}, "CVE-2023-30758": {"epss_score": 0.00236, "epss_percentile": 0.46433}, "CVE-2023-30759": {"epss_score": 0.00049, "epss_percentile": 0.15624}, "CVE-2023-30760": {"epss_score": 0.00081, "epss_percentile": 0.24357}, "CVE-2023-30762": {"epss_score": 0.00244, "epss_percentile": 0.47566}, "CVE-2023-30763": {"epss_score": 0.00035, "epss_percentile": 0.10067}, "CVE-2023-30764": {"epss_score": 0.01727, "epss_percentile": 0.8197}, "CVE-2023-30765": {"epss_score": 0.00677, "epss_percentile": 0.70953}, "CVE-2023-30766": {"epss_score": 0.00282, "epss_percentile": 0.51205}, "CVE-2023-30767": {"epss_score": 0.00068, "epss_percentile": 0.21219}, "CVE-2023-30768": {"epss_score": 0.00041, "epss_percentile": 0.12212}, "CVE-2023-30769": {"epss_score": 0.00281, "epss_percentile": 0.51182}, "CVE-2023-30770": {"epss_score": 0.00311, "epss_percentile": 0.53853}, "CVE-2023-30771": {"epss_score": 0.00221, "epss_percentile": 0.4469}, "CVE-2023-30772": {"epss_score": 0.00059, "epss_percentile": 0.18753}, "CVE-2023-30774": {"epss_score": 0.00022, "epss_percentile": 0.04992}, "CVE-2023-30775": {"epss_score": 0.00053, "epss_percentile": 0.16984}, "CVE-2023-30776": {"epss_score": 0.00308, "epss_percentile": 0.53583}, "CVE-2023-30777": {"epss_score": 0.85422, "epss_percentile": 0.99333}, "CVE-2023-30778": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-30779": {"epss_score": 0.0009, "epss_percentile": 0.261}, "CVE-2023-30780": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-30781": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30782": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30783": {"epss_score": 0.0015, "epss_percentile": 0.36098}, "CVE-2023-30784": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-30785": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30786": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-30787": {"epss_score": 0.00257, "epss_percentile": 0.48853}, "CVE-2023-30788": {"epss_score": 0.00257, "epss_percentile": 0.48853}, "CVE-2023-30789": {"epss_score": 0.00476, "epss_percentile": 0.64292}, "CVE-2023-30790": {"epss_score": 0.00257, "epss_percentile": 0.48853}, "CVE-2023-30791": {"epss_score": 0.00086, "epss_percentile": 0.25298}, "CVE-2023-30792": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-30795": {"epss_score": 0.00103, "epss_percentile": 0.29097}, "CVE-2023-30796": {"epss_score": 0.00089, "epss_percentile": 0.25952}, "CVE-2023-30797": {"epss_score": 0.00191, "epss_percentile": 0.41215}, "CVE-2023-30798": {"epss_score": 0.00726, "epss_percentile": 0.72069}, "CVE-2023-30799": {"epss_score": 0.00267, "epss_percentile": 0.4998}, "CVE-2023-30800": {"epss_score": 0.04437, "epss_percentile": 0.88689}, "CVE-2023-30801": {"epss_score": 0.00728, "epss_percentile": 0.7211}, "CVE-2023-30802": {"epss_score": 0.00188, "epss_percentile": 0.40853}, "CVE-2023-30803": {"epss_score": 0.00671, "epss_percentile": 0.70789}, "CVE-2023-30804": {"epss_score": 0.05344, "epss_percentile": 0.89766}, "CVE-2023-30805": {"epss_score": 0.18746, "epss_percentile": 0.95063}, "CVE-2023-30806": {"epss_score": 0.1704, "epss_percentile": 0.94763}, "CVE-2023-30837": {"epss_score": 0.0016, "epss_percentile": 0.37506}, "CVE-2023-30838": {"epss_score": 0.00516, "epss_percentile": 0.66055}, "CVE-2023-30839": {"epss_score": 0.08347, "epss_percentile": 0.92003}, "CVE-2023-30840": {"epss_score": 0.00033, "epss_percentile": 0.09132}, "CVE-2023-30841": {"epss_score": 0.00013, "epss_percentile": 0.0163}, "CVE-2023-30843": {"epss_score": 0.00227, "epss_percentile": 0.45428}, "CVE-2023-30844": {"epss_score": 0.00349, "epss_percentile": 0.56884}, "CVE-2023-30845": {"epss_score": 0.00123, "epss_percentile": 0.32226}, "CVE-2023-30846": {"epss_score": 0.02437, "epss_percentile": 0.84743}, "CVE-2023-30847": {"epss_score": 0.00261, "epss_percentile": 0.49254}, "CVE-2023-30848": {"epss_score": 0.0008, "epss_percentile": 0.24174}, "CVE-2023-30849": {"epss_score": 0.0008, "epss_percentile": 0.24174}, "CVE-2023-30850": {"epss_score": 0.00083, "epss_percentile": 0.24823}, "CVE-2023-30851": {"epss_score": 0.00113, "epss_percentile": 0.30656}, "CVE-2023-30852": {"epss_score": 3e-05, "epss_percentile": 0.0009}, "CVE-2023-30853": {"epss_score": 0.0014, "epss_percentile": 0.34774}, "CVE-2023-30854": {"epss_score": 0.6389, "epss_percentile": 0.98354}, "CVE-2023-30855": {"epss_score": 2e-05, "epss_percentile": 0.00047}, "CVE-2023-30856": {"epss_score": 0.00139, "epss_percentile": 0.34608}, "CVE-2023-30857": {"epss_score": 0.00219, "epss_percentile": 0.44532}, "CVE-2023-30858": {"epss_score": 0.00126, "epss_percentile": 0.32668}, "CVE-2023-30859": {"epss_score": 0.00301, "epss_percentile": 0.53021}, "CVE-2023-30860": {"epss_score": 0.03751, "epss_percentile": 0.87674}, "CVE-2023-30861": {"epss_score": 0.0018, "epss_percentile": 0.39867}, "CVE-2023-30863": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2023-30864": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2023-30865": {"epss_score": 0.00021, "epss_percentile": 0.04932}, "CVE-2023-30866": {"epss_score": 0.00021, "epss_percentile": 0.04932}, "CVE-2023-30867": {"epss_score": 0.00402, "epss_percentile": 0.60311}, "CVE-2023-30868": {"epss_score": 0.54053, "epss_percentile": 0.97909}, "CVE-2023-30869": {"epss_score": 0.33893, "epss_percentile": 0.96813}, "CVE-2023-30870": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-30871": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30872": {"epss_score": 0.00133, "epss_percentile": 0.33669}, "CVE-2023-30873": {"epss_score": 0.00312, "epss_percentile": 0.53951}, "CVE-2023-30874": {"epss_score": 0.00063, "epss_percentile": 0.19871}, "CVE-2023-30875": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-30876": {"epss_score": 0.00063, "epss_percentile": 0.19871}, "CVE-2023-30877": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-30897": {"epss_score": 0.00058, "epss_percentile": 0.18508}, "CVE-2023-30898": {"epss_score": 0.01986, "epss_percentile": 0.83157}, "CVE-2023-30899": {"epss_score": 0.01986, "epss_percentile": 0.83157}, "CVE-2023-30900": {"epss_score": 0.00095, "epss_percentile": 0.27154}, "CVE-2023-30901": {"epss_score": 0.00145, "epss_percentile": 0.35451}, "CVE-2023-30902": {"epss_score": 0.00037, "epss_percentile": 0.10682}, "CVE-2023-30903": {"epss_score": 0.00145, "epss_percentile": 0.35352}, "CVE-2023-30904": {"epss_score": 0.00043, "epss_percentile": 0.13273}, "CVE-2023-30905": {"epss_score": 0.00058, "epss_percentile": 0.18508}, "CVE-2023-30906": {"epss_score": 0.00077, "epss_percentile": 0.23537}, "CVE-2023-30908": {"epss_score": 0.01648, "epss_percentile": 0.81555}, "CVE-2023-30909": {"epss_score": 0.04957, "epss_percentile": 0.89331}, "CVE-2023-30910": {"epss_score": 0.00106, "epss_percentile": 0.29417}, "CVE-2023-30911": {"epss_score": 0.00057, "epss_percentile": 0.1817}, "CVE-2023-30912": {"epss_score": 0.00964, "epss_percentile": 0.76035}, "CVE-2023-30913": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-30914": {"epss_score": 0.00021, "epss_percentile": 0.04932}, "CVE-2023-30915": {"epss_score": 0.00021, "epss_percentile": 0.04932}, "CVE-2023-30916": {"epss_score": 0.00031, "epss_percentile": 0.08505}, "CVE-2023-30917": {"epss_score": 0.00031, "epss_percentile": 0.08505}, "CVE-2023-30918": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-30919": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-30920": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-30921": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-30922": {"epss_score": 0.00021, "epss_percentile": 0.04932}, "CVE-2023-30923": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-30924": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-30925": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-30926": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-30927": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-30928": {"epss_score": 0.00031, "epss_percentile": 0.08505}, "CVE-2023-30929": {"epss_score": 0.00026, "epss_percentile": 0.0672}, "CVE-2023-30930": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-30931": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-30932": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-30933": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-30934": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-30935": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-30936": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-30937": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-30938": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-30939": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-30940": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-30941": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-30942": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-30943": {"epss_score": 0.20709, "epss_percentile": 0.95405}, "CVE-2023-30944": {"epss_score": 0.00793, "epss_percentile": 0.73423}, "CVE-2023-30945": {"epss_score": 0.00434, "epss_percentile": 0.62324}, "CVE-2023-30946": {"epss_score": 0.00284, "epss_percentile": 0.51495}, "CVE-2023-30948": {"epss_score": 0.00203, "epss_percentile": 0.4253}, "CVE-2023-30949": {"epss_score": 0.00085, "epss_percentile": 0.25038}, "CVE-2023-30950": {"epss_score": 0.00136, "epss_percentile": 0.34118}, "CVE-2023-30951": {"epss_score": 0.00107, "epss_percentile": 0.29715}, "CVE-2023-30952": {"epss_score": 0.00261, "epss_percentile": 0.493}, "CVE-2023-30954": {"epss_score": 0.00113, "epss_percentile": 0.30584}, "CVE-2023-30955": {"epss_score": 0.00066, "epss_percentile": 0.20862}, "CVE-2023-30956": {"epss_score": 0.00202, "epss_percentile": 0.42484}, "CVE-2023-30958": {"epss_score": 0.00181, "epss_percentile": 0.39992}, "CVE-2023-30959": {"epss_score": 0.00175, "epss_percentile": 0.39354}, "CVE-2023-30960": {"epss_score": 0.00139, "epss_percentile": 0.34662}, "CVE-2023-30961": {"epss_score": 0.00414, "epss_percentile": 0.61105}, "CVE-2023-30962": {"epss_score": 0.00635, "epss_percentile": 0.69827}, "CVE-2023-30963": {"epss_score": 0.00296, "epss_percentile": 0.52625}, "CVE-2023-30967": {"epss_score": 0.00393, "epss_percentile": 0.59739}, "CVE-2023-30968": {"epss_score": 0.00101, "epss_percentile": 0.2863}, "CVE-2023-30969": {"epss_score": 0.00203, "epss_percentile": 0.42508}, "CVE-2023-30970": {"epss_score": 0.00117, "epss_percentile": 0.31267}, "CVE-2023-30971": {"epss_score": 0.00034, "epss_percentile": 0.0971}, "CVE-2023-30985": {"epss_score": 0.00089, "epss_percentile": 0.25919}, "CVE-2023-30986": {"epss_score": 0.00065, "epss_percentile": 0.20538}, "CVE-2023-30987": {"epss_score": 0.00052, "epss_percentile": 0.16623}, "CVE-2023-30988": {"epss_score": 0.00021, "epss_percentile": 0.04797}, "CVE-2023-30989": {"epss_score": 0.00021, "epss_percentile": 0.04797}, "CVE-2023-30990": {"epss_score": 0.00106, "epss_percentile": 0.29419}, "CVE-2023-30991": {"epss_score": 0.00042, "epss_percentile": 0.12737}, "CVE-2023-30993": {"epss_score": 0.00062, "epss_percentile": 0.19644}, "CVE-2023-30994": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2023-30995": {"epss_score": 0.00016, "epss_percentile": 0.0303}, "CVE-2023-30996": {"epss_score": 0.00073, "epss_percentile": 0.22625}, "CVE-2023-30997": {"epss_score": 0.00059, "epss_percentile": 0.18835}, "CVE-2023-30998": {"epss_score": 0.00059, "epss_percentile": 0.18835}, "CVE-2023-30999": {"epss_score": 0.00052, "epss_percentile": 0.16344}, "CVE-2023-31001": {"epss_score": 0.00041, "epss_percentile": 0.12348}, "CVE-2023-31002": {"epss_score": 0.00013, "epss_percentile": 0.01608}, "CVE-2023-31003": {"epss_score": 0.00031, "epss_percentile": 0.08435}, "CVE-2023-31004": {"epss_score": 0.00133, "epss_percentile": 0.33745}, "CVE-2023-31005": {"epss_score": 0.00028, "epss_percentile": 0.07312}, "CVE-2023-31006": {"epss_score": 0.00048, "epss_percentile": 0.14977}, "CVE-2023-31007": {"epss_score": 0.00063, "epss_percentile": 0.19997}, "CVE-2023-31008": {"epss_score": 0.00076, "epss_percentile": 0.23219}, "CVE-2023-31009": {"epss_score": 0.00325, "epss_percentile": 0.55026}, "CVE-2023-31010": {"epss_score": 0.00143, "epss_percentile": 0.35221}, "CVE-2023-31011": {"epss_score": 0.00182, "epss_percentile": 0.40144}, "CVE-2023-31012": {"epss_score": 0.0019, "epss_percentile": 0.41139}, "CVE-2023-31013": {"epss_score": 0.0019, "epss_percentile": 0.41139}, "CVE-2023-31014": {"epss_score": 0.00033, "epss_percentile": 0.09368}, "CVE-2023-31015": {"epss_score": 0.0005, "epss_percentile": 0.15655}, "CVE-2023-31016": {"epss_score": 0.00044, "epss_percentile": 0.13437}, "CVE-2023-31017": {"epss_score": 0.00022, "epss_percentile": 0.05274}, "CVE-2023-31018": {"epss_score": 0.00051, "epss_percentile": 0.16245}, "CVE-2023-31019": {"epss_score": 0.0003, "epss_percentile": 0.08166}, "CVE-2023-31020": {"epss_score": 0.00022, "epss_percentile": 0.05151}, "CVE-2023-31021": {"epss_score": 0.00047, "epss_percentile": 0.1484}, "CVE-2023-31022": {"epss_score": 0.00075, "epss_percentile": 0.22983}, "CVE-2023-31023": {"epss_score": 0.00027, "epss_percentile": 0.07002}, "CVE-2023-31024": {"epss_score": 0.0035, "epss_percentile": 0.56977}, "CVE-2023-31025": {"epss_score": 0.002, "epss_percentile": 0.42246}, "CVE-2023-31026": {"epss_score": 0.00019, "epss_percentile": 0.04093}, "CVE-2023-31027": {"epss_score": 0.00027, "epss_percentile": 0.06911}, "CVE-2023-31028": {"epss_score": 0.00024, "epss_percentile": 0.05968}, "CVE-2023-31029": {"epss_score": 0.0018, "epss_percentile": 0.39873}, "CVE-2023-31030": {"epss_score": 0.0018, "epss_percentile": 0.39873}, "CVE-2023-31031": {"epss_score": 0.00034, "epss_percentile": 0.09619}, "CVE-2023-31032": {"epss_score": 0.00037, "epss_percentile": 0.10661}, "CVE-2023-31033": {"epss_score": 0.00045, "epss_percentile": 0.13704}, "CVE-2023-31034": {"epss_score": 9e-05, "epss_percentile": 0.00712}, "CVE-2023-31035": {"epss_score": 0.00034, "epss_percentile": 0.09583}, "CVE-2023-31036": {"epss_score": 0.00207, "epss_percentile": 0.43196}, "CVE-2023-31037": {"epss_score": 0.00094, "epss_percentile": 0.26974}, "CVE-2023-31038": {"epss_score": 0.00388, "epss_percentile": 0.59341}, "CVE-2023-31039": {"epss_score": 0.00323, "epss_percentile": 0.5489}, "CVE-2023-31041": {"epss_score": 0.00113, "epss_percentile": 0.30609}, "CVE-2023-31042": {"epss_score": 0.00056, "epss_percentile": 0.17733}, "CVE-2023-31043": {"epss_score": 0.00041, "epss_percentile": 0.12441}, "CVE-2023-31045": {"epss_score": 0.00097, "epss_percentile": 0.27551}, "CVE-2023-31046": {"epss_score": 0.00194, "epss_percentile": 0.41581}, "CVE-2023-31047": {"epss_score": 0.00058, "epss_percentile": 0.18465}, "CVE-2023-31048": {"epss_score": 0.00407, "epss_percentile": 0.60574}, "CVE-2023-31056": {"epss_score": 0.00133, "epss_percentile": 0.33644}, "CVE-2023-31058": {"epss_score": 0.00155, "epss_percentile": 0.36775}, "CVE-2023-31059": {"epss_score": 0.91605, "epss_percentile": 0.99657}, "CVE-2023-31060": {"epss_score": 0.00856, "epss_percentile": 0.74483}, "CVE-2023-31061": {"epss_score": 0.00578, "epss_percentile": 0.68183}, "CVE-2023-31062": {"epss_score": 0.00169, "epss_percentile": 0.38612}, "CVE-2023-31064": {"epss_score": 0.00145, "epss_percentile": 0.35404}, "CVE-2023-31065": {"epss_score": 0.00171, "epss_percentile": 0.38893}, "CVE-2023-31066": {"epss_score": 0.00233, "epss_percentile": 0.46047}, "CVE-2023-31067": {"epss_score": 0.01884, "epss_percentile": 0.82705}, "CVE-2023-31068": {"epss_score": 0.01501, "epss_percentile": 0.80715}, "CVE-2023-31069": {"epss_score": 0.01135, "epss_percentile": 0.77909}, "CVE-2023-31071": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-31072": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-31073": {"epss_score": 0.0013, "epss_percentile": 0.33331}, "CVE-2023-31074": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-31075": {"epss_score": 0.00123, "epss_percentile": 0.32324}, "CVE-2023-31076": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-31077": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-31078": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-31079": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-31080": {"epss_score": 0.0039, "epss_percentile": 0.59516}, "CVE-2023-31081": {"epss_score": 0.00019, "epss_percentile": 0.04277}, "CVE-2023-31082": {"epss_score": 0.00017, "epss_percentile": 0.03196}, "CVE-2023-31083": {"epss_score": 6e-05, "epss_percentile": 0.00243}, "CVE-2023-31084": {"epss_score": 0.00011, "epss_percentile": 0.01062}, "CVE-2023-31085": {"epss_score": 0.0002, "epss_percentile": 0.04686}, "CVE-2023-31086": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-31087": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-31088": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-31089": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-31090": {"epss_score": 0.00314, "epss_percentile": 0.54089}, "CVE-2023-31091": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-31092": {"epss_score": 0.00117, "epss_percentile": 0.31219}, "CVE-2023-31093": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-31094": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-31095": {"epss_score": 0.00202, "epss_percentile": 0.42475}, "CVE-2023-31096": {"epss_score": 0.00022, "epss_percentile": 0.05304}, "CVE-2023-31098": {"epss_score": 0.00169, "epss_percentile": 0.38612}, "CVE-2023-31099": {"epss_score": 0.82296, "epss_percentile": 0.99186}, "CVE-2023-31100": {"epss_score": 0.00059, "epss_percentile": 0.18684}, "CVE-2023-31101": {"epss_score": 0.00143, "epss_percentile": 0.3518}, "CVE-2023-31102": {"epss_score": 0.374, "epss_percentile": 0.97043}, "CVE-2023-31103": {"epss_score": 0.00145, "epss_percentile": 0.35404}, "CVE-2023-31114": {"epss_score": 0.00245, "epss_percentile": 0.4773}, "CVE-2023-31115": {"epss_score": 0.00208, "epss_percentile": 0.43284}, "CVE-2023-31116": {"epss_score": 0.00216, "epss_percentile": 0.44189}, "CVE-2023-31122": {"epss_score": 0.0043, "epss_percentile": 0.62033}, "CVE-2023-31123": {"epss_score": 0.0032, "epss_percentile": 0.54584}, "CVE-2023-31124": {"epss_score": 0.0007, "epss_percentile": 0.21726}, "CVE-2023-31125": {"epss_score": 0.00703, "epss_percentile": 0.71532}, "CVE-2023-31126": {"epss_score": 0.03268, "epss_percentile": 0.86787}, "CVE-2023-31127": {"epss_score": 0.01133, "epss_percentile": 0.77879}, "CVE-2023-31128": {"epss_score": 0.01474, "epss_percentile": 0.80523}, "CVE-2023-31129": {"epss_score": 0.00314, "epss_percentile": 0.54119}, "CVE-2023-31130": {"epss_score": 0.00011, "epss_percentile": 0.00969}, "CVE-2023-31131": {"epss_score": 0.00298, "epss_percentile": 0.52812}, "CVE-2023-31132": {"epss_score": 0.00119, "epss_percentile": 0.31677}, "CVE-2023-31133": {"epss_score": 0.17041, "epss_percentile": 0.94764}, "CVE-2023-31134": {"epss_score": 0.00207, "epss_percentile": 0.43127}, "CVE-2023-31135": {"epss_score": 0.00049, "epss_percentile": 0.15643}, "CVE-2023-31136": {"epss_score": 0.00204, "epss_percentile": 0.42669}, "CVE-2023-31137": {"epss_score": 0.01027, "epss_percentile": 0.76807}, "CVE-2023-31138": {"epss_score": 0.0004, "epss_percentile": 0.12056}, "CVE-2023-31139": {"epss_score": 0.00064, "epss_percentile": 0.20206}, "CVE-2023-31140": {"epss_score": 0.00276, "epss_percentile": 0.50747}, "CVE-2023-31141": {"epss_score": 0.00408, "epss_percentile": 0.60641}, "CVE-2023-31142": {"epss_score": 0.00104, "epss_percentile": 0.29195}, "CVE-2023-31143": {"epss_score": 0.00114, "epss_percentile": 0.30817}, "CVE-2023-31144": {"epss_score": 0.00455, "epss_percentile": 0.63313}, "CVE-2023-31145": {"epss_score": 0.0019, "epss_percentile": 0.41075}, "CVE-2023-31146": {"epss_score": 0.00165, "epss_percentile": 0.38045}, "CVE-2023-31147": {"epss_score": 0.00087, "epss_percentile": 0.25515}, "CVE-2023-31148": {"epss_score": 0.00856, "epss_percentile": 0.74478}, "CVE-2023-31149": {"epss_score": 0.00856, "epss_percentile": 0.74478}, "CVE-2023-31150": {"epss_score": 0.00115, "epss_percentile": 0.30905}, "CVE-2023-31151": {"epss_score": 0.00123, "epss_percentile": 0.32254}, "CVE-2023-31152": {"epss_score": 0.00029, "epss_percentile": 0.07785}, "CVE-2023-31153": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2023-31154": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2023-31155": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2023-31156": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2023-31157": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2023-31158": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2023-31159": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2023-31160": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2023-31161": {"epss_score": 0.00232, "epss_percentile": 0.45914}, "CVE-2023-31162": {"epss_score": 0.00028, "epss_percentile": 0.07307}, "CVE-2023-31163": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2023-31164": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2023-31165": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2023-31166": {"epss_score": 0.00151, "epss_percentile": 0.36258}, "CVE-2023-31167": {"epss_score": 0.00096, "epss_percentile": 0.27297}, "CVE-2023-31168": {"epss_score": 0.00069, "epss_percentile": 0.21482}, "CVE-2023-31169": {"epss_score": 0.00056, "epss_percentile": 0.17761}, "CVE-2023-31170": {"epss_score": 0.00072, "epss_percentile": 0.22472}, "CVE-2023-31171": {"epss_score": 0.00027, "epss_percentile": 0.06928}, "CVE-2023-31172": {"epss_score": 0.00056, "epss_percentile": 0.17694}, "CVE-2023-31173": {"epss_score": 8e-05, "epss_percentile": 0.00556}, "CVE-2023-31174": {"epss_score": 0.00047, "epss_percentile": 0.14578}, "CVE-2023-31175": {"epss_score": 0.00092, "epss_percentile": 0.26473}, "CVE-2023-31176": {"epss_score": 0.00124, "epss_percentile": 0.32387}, "CVE-2023-31177": {"epss_score": 0.00165, "epss_percentile": 0.38104}, "CVE-2023-31178": {"epss_score": 0.00119, "epss_percentile": 0.31669}, "CVE-2023-31179": {"epss_score": 0.00242, "epss_percentile": 0.47402}, "CVE-2023-31180": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2023-31181": {"epss_score": 0.0026, "epss_percentile": 0.49152}, "CVE-2023-31182": {"epss_score": 0.00067, "epss_percentile": 0.21061}, "CVE-2023-31183": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2023-31184": {"epss_score": 0.03393, "epss_percentile": 0.87054}, "CVE-2023-31185": {"epss_score": 0.03009, "epss_percentile": 0.86193}, "CVE-2023-31186": {"epss_score": 0.00084, "epss_percentile": 0.2493}, "CVE-2023-31187": {"epss_score": 0.00065, "epss_percentile": 0.20625}, "CVE-2023-31188": {"epss_score": 0.00083, "epss_percentile": 0.24631}, "CVE-2023-31189": {"epss_score": 0.00066, "epss_percentile": 0.20821}, "CVE-2023-31190": {"epss_score": 0.00084, "epss_percentile": 0.24924}, "CVE-2023-31191": {"epss_score": 0.00043, "epss_percentile": 0.13276}, "CVE-2023-31192": {"epss_score": 0.00402, "epss_percentile": 0.60271}, "CVE-2023-31193": {"epss_score": 0.00041, "epss_percentile": 0.12266}, "CVE-2023-31194": {"epss_score": 0.00058, "epss_percentile": 0.184}, "CVE-2023-31195": {"epss_score": 0.00033, "epss_percentile": 0.09425}, "CVE-2023-31196": {"epss_score": 0.00354, "epss_percentile": 0.57226}, "CVE-2023-31197": {"epss_score": 0.00061, "epss_percentile": 0.19266}, "CVE-2023-31198": {"epss_score": 0.01111, "epss_percentile": 0.77672}, "CVE-2023-31199": {"epss_score": 0.00046, "epss_percentile": 0.14189}, "CVE-2023-31200": {"epss_score": 0.00029, "epss_percentile": 0.07774}, "CVE-2023-31203": {"epss_score": 0.00096, "epss_percentile": 0.27449}, "CVE-2023-31206": {"epss_score": 0.00145, "epss_percentile": 0.35404}, "CVE-2023-31207": {"epss_score": 0.00047, "epss_percentile": 0.14776}, "CVE-2023-31208": {"epss_score": 0.00513, "epss_percentile": 0.65905}, "CVE-2023-31209": {"epss_score": 0.0056, "epss_percentile": 0.6764}, "CVE-2023-31210": {"epss_score": 0.00122, "epss_percentile": 0.32175}, "CVE-2023-31211": {"epss_score": 0.00122, "epss_percentile": 0.32105}, "CVE-2023-31212": {"epss_score": 0.00441, "epss_percentile": 0.62651}, "CVE-2023-31213": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2023-31214": {"epss_score": 0.00132, "epss_percentile": 0.33602}, "CVE-2023-31215": {"epss_score": 0.00314, "epss_percentile": 0.54089}, "CVE-2023-31216": {"epss_score": 0.00074, "epss_percentile": 0.22751}, "CVE-2023-31217": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-31218": {"epss_score": 0.00064, "epss_percentile": 0.20284}, "CVE-2023-31219": {"epss_score": 0.00156, "epss_percentile": 0.36917}, "CVE-2023-31220": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-31221": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-31222": {"epss_score": 0.2853, "epss_percentile": 0.96365}, "CVE-2023-31223": {"epss_score": 0.00127, "epss_percentile": 0.32838}, "CVE-2023-31224": {"epss_score": 0.00079, "epss_percentile": 0.23994}, "CVE-2023-31225": {"epss_score": 0.00013, "epss_percentile": 0.0159}, "CVE-2023-31226": {"epss_score": 0.00083, "epss_percentile": 0.24631}, "CVE-2023-31227": {"epss_score": 0.00083, "epss_percentile": 0.24631}, "CVE-2023-31228": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-31229": {"epss_score": 0.00202, "epss_percentile": 0.42475}, "CVE-2023-31230": {"epss_score": 0.00061, "epss_percentile": 0.19252}, "CVE-2023-31231": {"epss_score": 0.00062, "epss_percentile": 0.19593}, "CVE-2023-31232": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-31233": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-31234": {"epss_score": 0.00124, "epss_percentile": 0.32431}, "CVE-2023-31235": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-31236": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-31237": {"epss_score": 0.00202, "epss_percentile": 0.42475}, "CVE-2023-31238": {"epss_score": 0.00105, "epss_percentile": 0.29284}, "CVE-2023-31239": {"epss_score": 0.00076, "epss_percentile": 0.23185}, "CVE-2023-31240": {"epss_score": 0.00054, "epss_percentile": 0.17363}, "CVE-2023-31241": {"epss_score": 0.00014, "epss_percentile": 0.0203}, "CVE-2023-31242": {"epss_score": 0.00019, "epss_percentile": 0.04227}, "CVE-2023-31244": {"epss_score": 0.00038, "epss_percentile": 0.11268}, "CVE-2023-31245": {"epss_score": 0.00059, "epss_percentile": 0.18658}, "CVE-2023-31246": {"epss_score": 0.00061, "epss_percentile": 0.19333}, "CVE-2023-31247": {"epss_score": 0.00365, "epss_percentile": 0.57968}, "CVE-2023-31248": {"epss_score": 0.00204, "epss_percentile": 0.42633}, "CVE-2023-31250": {"epss_score": 0.00257, "epss_percentile": 0.48885}, "CVE-2023-31271": {"epss_score": 0.00084, "epss_percentile": 0.25012}, "CVE-2023-31272": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-31273": {"epss_score": 0.00365, "epss_percentile": 0.58004}, "CVE-2023-31274": {"epss_score": 0.00248, "epss_percentile": 0.4796}, "CVE-2023-31275": {"epss_score": 0.00967, "epss_percentile": 0.76073}, "CVE-2023-31276": {"epss_score": 0.00034, "epss_percentile": 0.09439}, "CVE-2023-31277": {"epss_score": 0.00077, "epss_percentile": 0.23429}, "CVE-2023-31278": {"epss_score": 0.00055, "epss_percentile": 0.17605}, "CVE-2023-31279": {"epss_score": 0.00106, "epss_percentile": 0.29526}, "CVE-2023-31280": {"epss_score": 0.00091, "epss_percentile": 0.26383}, "CVE-2023-31284": {"epss_score": 0.00043, "epss_percentile": 0.13227}, "CVE-2023-31285": {"epss_score": 0.00714, "epss_percentile": 0.71819}, "CVE-2023-31286": {"epss_score": 0.00333, "epss_percentile": 0.55623}, "CVE-2023-31287": {"epss_score": 0.00087, "epss_percentile": 0.25582}, "CVE-2023-31289": {"epss_score": 0.00277, "epss_percentile": 0.50842}, "CVE-2023-31290": {"epss_score": 0.00258, "epss_percentile": 0.48983}, "CVE-2023-31292": {"epss_score": 0.00018, "epss_percentile": 0.03561}, "CVE-2023-31293": {"epss_score": 0.00092, "epss_percentile": 0.26446}, "CVE-2023-31294": {"epss_score": 0.00233, "epss_percentile": 0.46029}, "CVE-2023-31295": {"epss_score": 0.00233, "epss_percentile": 0.46029}, "CVE-2023-31296": {"epss_score": 0.00186, "epss_percentile": 0.40644}, "CVE-2023-31297": {"epss_score": 0.00061, "epss_percentile": 0.19315}, "CVE-2023-31298": {"epss_score": 0.00187, "epss_percentile": 0.40734}, "CVE-2023-31299": {"epss_score": 0.00268, "epss_percentile": 0.50088}, "CVE-2023-31300": {"epss_score": 0.00103, "epss_percentile": 0.29007}, "CVE-2023-31301": {"epss_score": 0.00282, "epss_percentile": 0.51233}, "CVE-2023-31302": {"epss_score": 0.00282, "epss_percentile": 0.51233}, "CVE-2023-31304": {"epss_score": 0.00048, "epss_percentile": 0.15006}, "CVE-2023-31305": {"epss_score": 0.00062, "epss_percentile": 0.19783}, "CVE-2023-31306": {"epss_score": 0.00025, "epss_percentile": 0.06273}, "CVE-2023-31307": {"epss_score": 0.00061, "epss_percentile": 0.19307}, "CVE-2023-31310": {"epss_score": 0.00062, "epss_percentile": 0.19714}, "CVE-2023-31315": {"epss_score": 0.00032, "epss_percentile": 0.08786}, "CVE-2023-31320": {"epss_score": 0.06639, "epss_percentile": 0.9091}, "CVE-2023-31322": {"epss_score": 0.00025, "epss_percentile": 0.06297}, "CVE-2023-31325": {"epss_score": 0.00021, "epss_percentile": 0.04744}, "CVE-2023-31326": {"epss_score": 0.00019, "epss_percentile": 0.04255}, "CVE-2023-31330": {"epss_score": 0.0002, "epss_percentile": 0.04485}, "CVE-2023-31331": {"epss_score": 0.0003, "epss_percentile": 0.08309}, "CVE-2023-31339": {"epss_score": 0.00097, "epss_percentile": 0.2759}, "CVE-2023-31341": {"epss_score": 0.00074, "epss_percentile": 0.22878}, "CVE-2023-31342": {"epss_score": 0.00021, "epss_percentile": 0.048}, "CVE-2023-31343": {"epss_score": 0.00021, "epss_percentile": 0.048}, "CVE-2023-31345": {"epss_score": 0.00021, "epss_percentile": 0.048}, "CVE-2023-31346": {"epss_score": 0.00036, "epss_percentile": 0.10525}, "CVE-2023-31347": {"epss_score": 0.00046, "epss_percentile": 0.14144}, "CVE-2023-31348": {"epss_score": 0.00234, "epss_percentile": 0.4617}, "CVE-2023-31349": {"epss_score": 0.00219, "epss_percentile": 0.44445}, "CVE-2023-31351": {"epss_score": 0.00021, "epss_percentile": 0.04724}, "CVE-2023-31352": {"epss_score": 0.00035, "epss_percentile": 0.10135}, "CVE-2023-31355": {"epss_score": 0.00795, "epss_percentile": 0.73477}, "CVE-2023-31356": {"epss_score": 0.00034, "epss_percentile": 0.09452}, "CVE-2023-31358": {"epss_score": 0.00015, "epss_percentile": 0.02125}, "CVE-2023-31359": {"epss_score": 0.00013, "epss_percentile": 0.01521}, "CVE-2023-31360": {"epss_score": 0.00017, "epss_percentile": 0.03379}, "CVE-2023-31361": {"epss_score": 0.00031, "epss_percentile": 0.08623}, "CVE-2023-31365": {"epss_score": 0.00023, "epss_percentile": 0.05522}, "CVE-2023-31366": {"epss_score": 0.00108, "epss_percentile": 0.2979}, "CVE-2023-31403": {"epss_score": 0.00124, "epss_percentile": 0.32465}, "CVE-2023-31404": {"epss_score": 0.00192, "epss_percentile": 0.41366}, "CVE-2023-31405": {"epss_score": 0.00172, "epss_percentile": 0.38952}, "CVE-2023-31406": {"epss_score": 0.00251, "epss_percentile": 0.48288}, "CVE-2023-31407": {"epss_score": 0.00305, "epss_percentile": 0.53339}, "CVE-2023-31408": {"epss_score": 0.00034, "epss_percentile": 0.09434}, "CVE-2023-31409": {"epss_score": 0.00225, "epss_percentile": 0.45236}, "CVE-2023-31410": {"epss_score": 0.00066, "epss_percentile": 0.2091}, "CVE-2023-31411": {"epss_score": 0.00165, "epss_percentile": 0.38042}, "CVE-2023-31412": {"epss_score": 0.00087, "epss_percentile": 0.25559}, "CVE-2023-31413": {"epss_score": 0.00068, "epss_percentile": 0.21258}, "CVE-2023-31414": {"epss_score": 0.00219, "epss_percentile": 0.44533}, "CVE-2023-31415": {"epss_score": 0.00619, "epss_percentile": 0.69399}, "CVE-2023-31416": {"epss_score": 0.00149, "epss_percentile": 0.35961}, "CVE-2023-31417": {"epss_score": 0.00052, "epss_percentile": 0.16645}, "CVE-2023-31418": {"epss_score": 0.00876, "epss_percentile": 0.74784}, "CVE-2023-31419": {"epss_score": 0.22319, "epss_percentile": 0.95622}, "CVE-2023-31421": {"epss_score": 0.00093, "epss_percentile": 0.26741}, "CVE-2023-31422": {"epss_score": 0.00257, "epss_percentile": 0.48867}, "CVE-2023-31423": {"epss_score": 0.00055, "epss_percentile": 0.17579}, "CVE-2023-31424": {"epss_score": 0.00553, "epss_percentile": 0.67425}, "CVE-2023-31425": {"epss_score": 0.00111, "epss_percentile": 0.30315}, "CVE-2023-31426": {"epss_score": 0.00159, "epss_percentile": 0.37301}, "CVE-2023-31427": {"epss_score": 0.00062, "epss_percentile": 0.19584}, "CVE-2023-31428": {"epss_score": 0.00044, "epss_percentile": 0.13602}, "CVE-2023-31429": {"epss_score": 0.00111, "epss_percentile": 0.30362}, "CVE-2023-31430": {"epss_score": 0.00044, "epss_percentile": 0.13504}, "CVE-2023-31431": {"epss_score": 0.00044, "epss_percentile": 0.13504}, "CVE-2023-31432": {"epss_score": 0.00057, "epss_percentile": 0.18022}, "CVE-2023-31433": {"epss_score": 0.00328, "epss_percentile": 0.55158}, "CVE-2023-31434": {"epss_score": 0.0014, "epss_percentile": 0.3467}, "CVE-2023-31435": {"epss_score": 0.00225, "epss_percentile": 0.45143}, "CVE-2023-31436": {"epss_score": 0.00036, "epss_percentile": 0.10231}, "CVE-2023-31437": {"epss_score": 0.00128, "epss_percentile": 0.32943}, "CVE-2023-31438": {"epss_score": 0.001, "epss_percentile": 0.285}, "CVE-2023-31439": {"epss_score": 0.00094, "epss_percentile": 0.26955}, "CVE-2023-31441": {"epss_score": 0.00028, "epss_percentile": 0.0756}, "CVE-2023-31442": {"epss_score": 0.00119, "epss_percentile": 0.3156}, "CVE-2023-31444": {"epss_score": 0.00178, "epss_percentile": 0.39638}, "CVE-2023-31445": {"epss_score": 0.01822, "epss_percentile": 0.82411}, "CVE-2023-31446": {"epss_score": 0.92671, "epss_percentile": 0.99734}, "CVE-2023-31447": {"epss_score": 0.00238, "epss_percentile": 0.46804}, "CVE-2023-31448": {"epss_score": 0.00097, "epss_percentile": 0.27555}, "CVE-2023-31449": {"epss_score": 0.00097, "epss_percentile": 0.27555}, "CVE-2023-31450": {"epss_score": 0.00097, "epss_percentile": 0.27555}, "CVE-2023-31452": {"epss_score": 0.01332, "epss_percentile": 0.79524}, "CVE-2023-31453": {"epss_score": 0.00141, "epss_percentile": 0.34834}, "CVE-2023-31454": {"epss_score": 0.00141, "epss_percentile": 0.34834}, "CVE-2023-31455": {"epss_score": 0.00277, "epss_percentile": 0.50842}, "CVE-2023-31456": {"epss_score": 0.00172, "epss_percentile": 0.38912}, "CVE-2023-31457": {"epss_score": 0.00519, "epss_percentile": 0.66154}, "CVE-2023-31458": {"epss_score": 0.00273, "epss_percentile": 0.50435}, "CVE-2023-31459": {"epss_score": 0.00088, "epss_percentile": 0.25756}, "CVE-2023-31460": {"epss_score": 0.0255, "epss_percentile": 0.85073}, "CVE-2023-31461": {"epss_score": 0.01997, "epss_percentile": 0.83196}, "CVE-2023-31462": {"epss_score": 0.02387, "epss_percentile": 0.84582}, "CVE-2023-31465": {"epss_score": 0.90545, "epss_percentile": 0.99588}, "CVE-2023-31466": {"epss_score": 0.00092, "epss_percentile": 0.26419}, "CVE-2023-31468": {"epss_score": 0.00094, "epss_percentile": 0.26987}, "CVE-2023-31469": {"epss_score": 0.00097, "epss_percentile": 0.27554}, "CVE-2023-31470": {"epss_score": 0.00221, "epss_percentile": 0.44682}, "CVE-2023-31471": {"epss_score": 0.00496, "epss_percentile": 0.65135}, "CVE-2023-31472": {"epss_score": 0.28495, "epss_percentile": 0.96363}, "CVE-2023-31473": {"epss_score": 0.01971, "epss_percentile": 0.83096}, "CVE-2023-31474": {"epss_score": 0.00207, "epss_percentile": 0.43139}, "CVE-2023-31475": {"epss_score": 0.22151, "epss_percentile": 0.95602}, "CVE-2023-31476": {"epss_score": 0.00071, "epss_percentile": 0.2213}, "CVE-2023-31477": {"epss_score": 0.00236, "epss_percentile": 0.46351}, "CVE-2023-31478": {"epss_score": 0.79867, "epss_percentile": 0.99058}, "CVE-2023-31483": {"epss_score": 0.00333, "epss_percentile": 0.55622}, "CVE-2023-31484": {"epss_score": 0.01069, "epss_percentile": 0.77244}, "CVE-2023-31485": {"epss_score": 0.00125, "epss_percentile": 0.326}, "CVE-2023-31486": {"epss_score": 0.0056, "epss_percentile": 0.67655}, "CVE-2023-31488": {"epss_score": 0.00908, "epss_percentile": 0.75288}, "CVE-2023-31489": {"epss_score": 0.00248, "epss_percentile": 0.47986}, "CVE-2023-31490": {"epss_score": 0.04493, "epss_percentile": 0.88759}, "CVE-2023-31492": {"epss_score": 0.00238, "epss_percentile": 0.46839}, "CVE-2023-31493": {"epss_score": 0.0189, "epss_percentile": 0.82726}, "CVE-2023-31497": {"epss_score": 0.11437, "epss_percentile": 0.93361}, "CVE-2023-31498": {"epss_score": 0.07157, "epss_percentile": 0.9129}, "CVE-2023-31502": {"epss_score": 0.00822, "epss_percentile": 0.73911}, "CVE-2023-31505": {"epss_score": 0.00969, "epss_percentile": 0.761}, "CVE-2023-31506": {"epss_score": 0.00046, "epss_percentile": 0.14301}, "CVE-2023-31517": {"epss_score": 0.00077, "epss_percentile": 0.23446}, "CVE-2023-31518": {"epss_score": 0.00025, "epss_percentile": 0.0614}, "CVE-2023-31519": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-31528": {"epss_score": 0.01154, "epss_percentile": 0.7807}, "CVE-2023-31529": {"epss_score": 0.01154, "epss_percentile": 0.7807}, "CVE-2023-31530": {"epss_score": 0.01154, "epss_percentile": 0.7807}, "CVE-2023-31531": {"epss_score": 0.01154, "epss_percentile": 0.7807}, "CVE-2023-31541": {"epss_score": 0.04208, "epss_percentile": 0.88398}, "CVE-2023-31543": {"epss_score": 0.00643, "epss_percentile": 0.70057}, "CVE-2023-31544": {"epss_score": 0.00085, "epss_percentile": 0.25145}, "CVE-2023-31546": {"epss_score": 0.21195, "epss_percentile": 0.95474}, "CVE-2023-31548": {"epss_score": 0.19158, "epss_percentile": 0.95141}, "CVE-2023-31555": {"epss_score": 0.0009, "epss_percentile": 0.26094}, "CVE-2023-31556": {"epss_score": 0.00094, "epss_percentile": 0.26768}, "CVE-2023-31566": {"epss_score": 0.00107, "epss_percentile": 0.29753}, "CVE-2023-31567": {"epss_score": 0.00132, "epss_percentile": 0.33599}, "CVE-2023-31568": {"epss_score": 0.00159, "epss_percentile": 0.37333}, "CVE-2023-31569": {"epss_score": 0.05158, "epss_percentile": 0.89554}, "CVE-2023-31572": {"epss_score": 0.00109, "epss_percentile": 0.30031}, "CVE-2023-31576": {"epss_score": 0.00115, "epss_percentile": 0.30955}, "CVE-2023-31579": {"epss_score": 0.00219, "epss_percentile": 0.44446}, "CVE-2023-31580": {"epss_score": 0.00174, "epss_percentile": 0.39186}, "CVE-2023-31581": {"epss_score": 0.00181, "epss_percentile": 0.4007}, "CVE-2023-31582": {"epss_score": 0.00167, "epss_percentile": 0.38397}, "CVE-2023-31584": {"epss_score": 0.00747, "epss_percentile": 0.72574}, "CVE-2023-31585": {"epss_score": 0.00107, "epss_percentile": 0.29663}, "CVE-2023-31587": {"epss_score": 0.01917, "epss_percentile": 0.82871}, "CVE-2023-31594": {"epss_score": 0.00297, "epss_percentile": 0.52697}, "CVE-2023-31595": {"epss_score": 0.00379, "epss_percentile": 0.58861}, "CVE-2023-31597": {"epss_score": 0.00105, "epss_percentile": 0.29353}, "CVE-2023-31606": {"epss_score": 0.01038, "epss_percentile": 0.76939}, "CVE-2023-31607": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2023-31608": {"epss_score": 0.0008, "epss_percentile": 0.24072}, "CVE-2023-31609": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2023-31610": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2023-31611": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2023-31612": {"epss_score": 0.0008, "epss_percentile": 0.24072}, "CVE-2023-31613": {"epss_score": 0.00209, "epss_percentile": 0.43369}, "CVE-2023-31614": {"epss_score": 0.0008, "epss_percentile": 0.24072}, "CVE-2023-31615": {"epss_score": 0.0008, "epss_percentile": 0.24072}, "CVE-2023-31616": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2023-31617": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2023-31618": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2023-31619": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2023-31620": {"epss_score": 0.0007, "epss_percentile": 0.21979}, "CVE-2023-31621": {"epss_score": 0.0007, "epss_percentile": 0.21979}, "CVE-2023-31622": {"epss_score": 0.0007, "epss_percentile": 0.21979}, "CVE-2023-31623": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2023-31624": {"epss_score": 0.0007, "epss_percentile": 0.21979}, "CVE-2023-31625": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2023-31626": {"epss_score": 0.00096, "epss_percentile": 0.27291}, "CVE-2023-31627": {"epss_score": 0.0007, "epss_percentile": 0.21979}, "CVE-2023-31628": {"epss_score": 0.00059, "epss_percentile": 0.18701}, "CVE-2023-31629": {"epss_score": 0.00092, "epss_percentile": 0.26533}, "CVE-2023-31630": {"epss_score": 0.00092, "epss_percentile": 0.26533}, "CVE-2023-31631": {"epss_score": 0.00092, "epss_percentile": 0.26533}, "CVE-2023-31634": {"epss_score": 0.00937, "epss_percentile": 0.75692}, "CVE-2023-31654": {"epss_score": 0.00432, "epss_percentile": 0.62118}, "CVE-2023-31655": {"epss_score": 0.00369, "epss_percentile": 0.5823}, "CVE-2023-31664": {"epss_score": 0.18351, "epss_percentile": 0.95001}, "CVE-2023-31669": {"epss_score": 0.00019, "epss_percentile": 0.04349}, "CVE-2023-31670": {"epss_score": 0.00246, "epss_percentile": 0.478}, "CVE-2023-31671": {"epss_score": 0.00069, "epss_percentile": 0.21587}, "CVE-2023-31672": {"epss_score": 0.00224, "epss_percentile": 0.45011}, "CVE-2023-31677": {"epss_score": 0.0007, "epss_percentile": 0.21722}, "CVE-2023-31678": {"epss_score": 0.00067, "epss_percentile": 0.20967}, "CVE-2023-31679": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-31689": {"epss_score": 0.05053, "epss_percentile": 0.89442}, "CVE-2023-31698": {"epss_score": 0.00363, "epss_percentile": 0.57846}, "CVE-2023-31699": {"epss_score": 0.00313, "epss_percentile": 0.54056}, "CVE-2023-31700": {"epss_score": 0.01254, "epss_percentile": 0.78923}, "CVE-2023-31701": {"epss_score": 0.01254, "epss_percentile": 0.78923}, "CVE-2023-31702": {"epss_score": 0.01794, "epss_percentile": 0.82292}, "CVE-2023-31703": {"epss_score": 0.01316, "epss_percentile": 0.79404}, "CVE-2023-31704": {"epss_score": 0.01201, "epss_percentile": 0.7848}, "CVE-2023-31705": {"epss_score": 0.00225, "epss_percentile": 0.45133}, "CVE-2023-31707": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-31708": {"epss_score": 0.0007, "epss_percentile": 0.21677}, "CVE-2023-31710": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-31714": {"epss_score": 0.01371, "epss_percentile": 0.79805}, "CVE-2023-31716": {"epss_score": 0.37109, "epss_percentile": 0.9702}, "CVE-2023-31717": {"epss_score": 0.30816, "epss_percentile": 0.96569}, "CVE-2023-31718": {"epss_score": 0.09852, "epss_percentile": 0.92735}, "CVE-2023-31719": {"epss_score": 0.65459, "epss_percentile": 0.98419}, "CVE-2023-31722": {"epss_score": 0.00117, "epss_percentile": 0.31218}, "CVE-2023-31723": {"epss_score": 0.00024, "epss_percentile": 0.05684}, "CVE-2023-31724": {"epss_score": 0.00036, "epss_percentile": 0.1045}, "CVE-2023-31725": {"epss_score": 0.00023, "epss_percentile": 0.05631}, "CVE-2023-31726": {"epss_score": 0.01759, "epss_percentile": 0.82139}, "CVE-2023-31728": {"epss_score": 0.0002, "epss_percentile": 0.04583}, "CVE-2023-31729": {"epss_score": 0.00761, "epss_percentile": 0.72824}, "CVE-2023-31740": {"epss_score": 0.00456, "epss_percentile": 0.63333}, "CVE-2023-31741": {"epss_score": 0.00456, "epss_percentile": 0.63333}, "CVE-2023-31742": {"epss_score": 0.62908, "epss_percentile": 0.98312}, "CVE-2023-31746": {"epss_score": 0.01425, "epss_percentile": 0.80198}, "CVE-2023-31747": {"epss_score": 0.00885, "epss_percentile": 0.74939}, "CVE-2023-31748": {"epss_score": 0.00105, "epss_percentile": 0.29376}, "CVE-2023-31752": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-31753": {"epss_score": 0.02978, "epss_percentile": 0.86114}, "CVE-2023-31754": {"epss_score": 0.00147, "epss_percentile": 0.35652}, "CVE-2023-31756": {"epss_score": 0.02987, "epss_percentile": 0.86137}, "CVE-2023-31757": {"epss_score": 0.00072, "epss_percentile": 0.22406}, "CVE-2023-31759": {"epss_score": 0.00045, "epss_percentile": 0.14003}, "CVE-2023-31761": {"epss_score": 0.00042, "epss_percentile": 0.12596}, "CVE-2023-31762": {"epss_score": 0.00042, "epss_percentile": 0.12596}, "CVE-2023-31763": {"epss_score": 0.00042, "epss_percentile": 0.12596}, "CVE-2023-31779": {"epss_score": 0.00196, "epss_percentile": 0.41802}, "CVE-2023-31794": {"epss_score": 0.00022, "epss_percentile": 0.05152}, "CVE-2023-31799": {"epss_score": 0.00341, "epss_percentile": 0.56328}, "CVE-2023-31800": {"epss_score": 0.00464, "epss_percentile": 0.63736}, "CVE-2023-31801": {"epss_score": 0.00447, "epss_percentile": 0.62942}, "CVE-2023-31802": {"epss_score": 0.00464, "epss_percentile": 0.63736}, "CVE-2023-31803": {"epss_score": 0.00328, "epss_percentile": 0.55295}, "CVE-2023-31804": {"epss_score": 0.00464, "epss_percentile": 0.63736}, "CVE-2023-31805": {"epss_score": 0.00392, "epss_percentile": 0.59645}, "CVE-2023-31806": {"epss_score": 0.00464, "epss_percentile": 0.63736}, "CVE-2023-31807": {"epss_score": 0.00464, "epss_percentile": 0.63736}, "CVE-2023-31808": {"epss_score": 0.00139, "epss_percentile": 0.34585}, "CVE-2023-31814": {"epss_score": 0.00183, "epss_percentile": 0.40278}, "CVE-2023-31816": {"epss_score": 0.00067, "epss_percentile": 0.21072}, "CVE-2023-31818": {"epss_score": 0.00057, "epss_percentile": 0.18181}, "CVE-2023-31819": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2023-31820": {"epss_score": 0.00036, "epss_percentile": 0.10557}, "CVE-2023-31821": {"epss_score": 0.00036, "epss_percentile": 0.10557}, "CVE-2023-31822": {"epss_score": 0.00036, "epss_percentile": 0.10557}, "CVE-2023-31823": {"epss_score": 0.00036, "epss_percentile": 0.10557}, "CVE-2023-31824": {"epss_score": 0.00088, "epss_percentile": 0.25778}, "CVE-2023-31825": {"epss_score": 0.00036, "epss_percentile": 0.10557}, "CVE-2023-31826": {"epss_score": 0.00039, "epss_percentile": 0.1146}, "CVE-2023-31842": {"epss_score": 0.00068, "epss_percentile": 0.21399}, "CVE-2023-31843": {"epss_score": 0.00068, "epss_percentile": 0.21399}, "CVE-2023-31844": {"epss_score": 0.00068, "epss_percentile": 0.21399}, "CVE-2023-31845": {"epss_score": 0.00068, "epss_percentile": 0.21399}, "CVE-2023-31847": {"epss_score": 0.0008, "epss_percentile": 0.24164}, "CVE-2023-31848": {"epss_score": 0.00065, "epss_percentile": 0.20446}, "CVE-2023-31851": {"epss_score": 0.00139, "epss_percentile": 0.34616}, "CVE-2023-31852": {"epss_score": 0.00587, "epss_percentile": 0.68485}, "CVE-2023-31853": {"epss_score": 0.00139, "epss_percentile": 0.34616}, "CVE-2023-31854": {"epss_score": 0.00105, "epss_percentile": 0.29364}, "CVE-2023-31856": {"epss_score": 0.02062, "epss_percentile": 0.83445}, "CVE-2023-31857": {"epss_score": 0.01023, "epss_percentile": 0.76774}, "CVE-2023-31860": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-31861": {"epss_score": 0.00283, "epss_percentile": 0.51366}, "CVE-2023-31862": {"epss_score": 0.00085, "epss_percentile": 0.25145}, "CVE-2023-31867": {"epss_score": 0.00083, "epss_percentile": 0.24759}, "CVE-2023-31868": {"epss_score": 0.00091, "epss_percentile": 0.26275}, "CVE-2023-31871": {"epss_score": 7e-05, "epss_percentile": 0.004}, "CVE-2023-31873": {"epss_score": 0.00307, "epss_percentile": 0.53519}, "CVE-2023-31874": {"epss_score": 0.01243, "epss_percentile": 0.7883}, "CVE-2023-31889": {"epss_score": 0.00061, "epss_percentile": 0.19337}, "CVE-2023-31890": {"epss_score": 0.00137, "epss_percentile": 0.34231}, "CVE-2023-31893": {"epss_score": 0.00085, "epss_percentile": 0.25147}, "CVE-2023-31902": {"epss_score": 0.60624, "epss_percentile": 0.98213}, "CVE-2023-31903": {"epss_score": 0.04383, "epss_percentile": 0.88627}, "CVE-2023-31904": {"epss_score": 0.00381, "epss_percentile": 0.58986}, "CVE-2023-31906": {"epss_score": 0.00076, "epss_percentile": 0.2309}, "CVE-2023-31907": {"epss_score": 0.0007, "epss_percentile": 0.21638}, "CVE-2023-31908": {"epss_score": 0.0007, "epss_percentile": 0.21638}, "CVE-2023-31910": {"epss_score": 0.00076, "epss_percentile": 0.2309}, "CVE-2023-31913": {"epss_score": 0.00077, "epss_percentile": 0.23386}, "CVE-2023-31914": {"epss_score": 0.00043, "epss_percentile": 0.13323}, "CVE-2023-31916": {"epss_score": 0.00077, "epss_percentile": 0.23386}, "CVE-2023-31918": {"epss_score": 0.00077, "epss_percentile": 0.23386}, "CVE-2023-31919": {"epss_score": 0.00077, "epss_percentile": 0.23386}, "CVE-2023-31920": {"epss_score": 0.00198, "epss_percentile": 0.42084}, "CVE-2023-31921": {"epss_score": 0.0007, "epss_percentile": 0.21723}, "CVE-2023-31922": {"epss_score": 0.00078, "epss_percentile": 0.236}, "CVE-2023-31923": {"epss_score": 0.00065, "epss_percentile": 0.20536}, "CVE-2023-31925": {"epss_score": 0.00039, "epss_percentile": 0.11721}, "CVE-2023-31926": {"epss_score": 0.00034, "epss_percentile": 0.0979}, "CVE-2023-31927": {"epss_score": 0.0036, "epss_percentile": 0.57682}, "CVE-2023-31928": {"epss_score": 0.00121, "epss_percentile": 0.31996}, "CVE-2023-31932": {"epss_score": 0.00963, "epss_percentile": 0.76015}, "CVE-2023-31933": {"epss_score": 0.00885, "epss_percentile": 0.74938}, "CVE-2023-31934": {"epss_score": 0.0006, "epss_percentile": 0.1907}, "CVE-2023-31935": {"epss_score": 0.00066, "epss_percentile": 0.20855}, "CVE-2023-31936": {"epss_score": 0.00885, "epss_percentile": 0.74938}, "CVE-2023-31937": {"epss_score": 0.00824, "epss_percentile": 0.73933}, "CVE-2023-31938": {"epss_score": 0.00885, "epss_percentile": 0.74938}, "CVE-2023-31939": {"epss_score": 0.00885, "epss_percentile": 0.74938}, "CVE-2023-31940": {"epss_score": 0.00885, "epss_percentile": 0.74938}, "CVE-2023-31941": {"epss_score": 0.00969, "epss_percentile": 0.761}, "CVE-2023-31942": {"epss_score": 0.00151, "epss_percentile": 0.36303}, "CVE-2023-31943": {"epss_score": 0.00885, "epss_percentile": 0.74938}, "CVE-2023-31944": {"epss_score": 0.01268, "epss_percentile": 0.79027}, "CVE-2023-31945": {"epss_score": 0.01268, "epss_percentile": 0.79027}, "CVE-2023-31946": {"epss_score": 0.01388, "epss_percentile": 0.7992}, "CVE-2023-31972": {"epss_score": 0.00023, "epss_percentile": 0.05631}, "CVE-2023-31973": {"epss_score": 0.00024, "epss_percentile": 0.05963}, "CVE-2023-31974": {"epss_score": 0.00023, "epss_percentile": 0.05631}, "CVE-2023-31975": {"epss_score": 0.0002, "epss_percentile": 0.04505}, "CVE-2023-31976": {"epss_score": 0.00226, "epss_percentile": 0.45271}, "CVE-2023-31979": {"epss_score": 0.00058, "epss_percentile": 0.1848}, "CVE-2023-31981": {"epss_score": 0.00041, "epss_percentile": 0.12304}, "CVE-2023-31982": {"epss_score": 0.00044, "epss_percentile": 0.13675}, "CVE-2023-31983": {"epss_score": 0.00465, "epss_percentile": 0.63774}, "CVE-2023-31985": {"epss_score": 0.00356, "epss_percentile": 0.57366}, "CVE-2023-31986": {"epss_score": 0.00356, "epss_percentile": 0.57366}, "CVE-2023-31994": {"epss_score": 0.00095, "epss_percentile": 0.27088}, "CVE-2023-31995": {"epss_score": 0.00377, "epss_percentile": 0.5875}, "CVE-2023-31996": {"epss_score": 0.0144, "epss_percentile": 0.80296}, "CVE-2023-31997": {"epss_score": 0.00036, "epss_percentile": 0.10511}, "CVE-2023-31998": {"epss_score": 0.00301, "epss_percentile": 0.53013}, "CVE-2023-31999": {"epss_score": 0.01306, "epss_percentile": 0.79337}, "CVE-2023-32000": {"epss_score": 0.00282, "epss_percentile": 0.51253}, "CVE-2023-32002": {"epss_score": 0.00042, "epss_percentile": 0.12615}, "CVE-2023-32003": {"epss_score": 0.00062, "epss_percentile": 0.19639}, "CVE-2023-32004": {"epss_score": 0.00115, "epss_percentile": 0.30937}, "CVE-2023-32005": {"epss_score": 0.00978, "epss_percentile": 0.76254}, "CVE-2023-32006": {"epss_score": 0.00072, "epss_percentile": 0.2231}, "CVE-2023-32007": {"epss_score": 0.91155, "epss_percentile": 0.99624}, "CVE-2023-32008": {"epss_score": 0.00437, "epss_percentile": 0.62489}, "CVE-2023-32009": {"epss_score": 0.00119, "epss_percentile": 0.31659}, "CVE-2023-32010": {"epss_score": 0.00113, "epss_percentile": 0.30601}, "CVE-2023-32011": {"epss_score": 0.03509, "epss_percentile": 0.87263}, "CVE-2023-32012": {"epss_score": 0.00207, "epss_percentile": 0.43203}, "CVE-2023-32013": {"epss_score": 0.00333, "epss_percentile": 0.5564}, "CVE-2023-32014": {"epss_score": 0.04719, "epss_percentile": 0.89046}, "CVE-2023-32015": {"epss_score": 0.02721, "epss_percentile": 0.85518}, "CVE-2023-32016": {"epss_score": 0.00239, "epss_percentile": 0.46889}, "CVE-2023-32017": {"epss_score": 0.00138, "epss_percentile": 0.34385}, "CVE-2023-32018": {"epss_score": 0.01043, "epss_percentile": 0.76992}, "CVE-2023-32019": {"epss_score": 0.02317, "epss_percentile": 0.84359}, "CVE-2023-32020": {"epss_score": 0.01259, "epss_percentile": 0.78962}, "CVE-2023-32021": {"epss_score": 0.01549, "epss_percentile": 0.80983}, "CVE-2023-32022": {"epss_score": 0.00785, "epss_percentile": 0.73255}, "CVE-2023-32024": {"epss_score": 0.00282, "epss_percentile": 0.51228}, "CVE-2023-32025": {"epss_score": 0.01131, "epss_percentile": 0.77859}, "CVE-2023-32026": {"epss_score": 0.01131, "epss_percentile": 0.77859}, "CVE-2023-32027": {"epss_score": 0.01131, "epss_percentile": 0.77859}, "CVE-2023-32028": {"epss_score": 0.01043, "epss_percentile": 0.76992}, "CVE-2023-32029": {"epss_score": 0.38955, "epss_percentile": 0.9713}, "CVE-2023-32030": {"epss_score": 0.05241, "epss_percentile": 0.89651}, "CVE-2023-32031": {"epss_score": 0.45467, "epss_percentile": 0.97488}, "CVE-2023-32032": {"epss_score": 0.00189, "epss_percentile": 0.40971}, "CVE-2023-32033": {"epss_score": 0.00348, "epss_percentile": 0.56842}, "CVE-2023-32034": {"epss_score": 0.03672, "epss_percentile": 0.87545}, "CVE-2023-32035": {"epss_score": 0.03672, "epss_percentile": 0.87545}, "CVE-2023-32037": {"epss_score": 0.00169, "epss_percentile": 0.38644}, "CVE-2023-32038": {"epss_score": 0.00379, "epss_percentile": 0.58886}, "CVE-2023-32039": {"epss_score": 0.00229, "epss_percentile": 0.45641}, "CVE-2023-32040": {"epss_score": 0.00229, "epss_percentile": 0.45641}, "CVE-2023-32041": {"epss_score": 0.0071, "epss_percentile": 0.71703}, "CVE-2023-32042": {"epss_score": 0.00432, "epss_percentile": 0.62134}, "CVE-2023-32043": {"epss_score": 0.00065, "epss_percentile": 0.20607}, "CVE-2023-32044": {"epss_score": 0.03228, "epss_percentile": 0.8669}, "CVE-2023-32045": {"epss_score": 0.03228, "epss_percentile": 0.8669}, "CVE-2023-32046": {"epss_score": 0.42658, "epss_percentile": 0.97345}, "CVE-2023-32047": {"epss_score": 0.01093, "epss_percentile": 0.7748}, "CVE-2023-32049": {"epss_score": 0.09063, "epss_percentile": 0.92385}, "CVE-2023-32050": {"epss_score": 0.00122, "epss_percentile": 0.32121}, "CVE-2023-32051": {"epss_score": 0.00374, "epss_percentile": 0.58566}, "CVE-2023-32052": {"epss_score": 0.0048, "epss_percentile": 0.64465}, "CVE-2023-32053": {"epss_score": 0.00139, "epss_percentile": 0.34559}, "CVE-2023-32054": {"epss_score": 0.00408, "epss_percentile": 0.60641}, "CVE-2023-32055": {"epss_score": 0.00082, "epss_percentile": 0.24509}, "CVE-2023-32056": {"epss_score": 0.00842, "epss_percentile": 0.74246}, "CVE-2023-32057": {"epss_score": 0.02525, "epss_percentile": 0.85012}, "CVE-2023-32058": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-32059": {"epss_score": 0.00064, "epss_percentile": 0.20364}, "CVE-2023-32060": {"epss_score": 0.00065, "epss_percentile": 0.20625}, "CVE-2023-32061": {"epss_score": 0.00072, "epss_percentile": 0.22388}, "CVE-2023-32062": {"epss_score": 0.00195, "epss_percentile": 0.4167}, "CVE-2023-32063": {"epss_score": 0.00195, "epss_percentile": 0.4167}, "CVE-2023-32064": {"epss_score": 0.0008, "epss_percentile": 0.24065}, "CVE-2023-32065": {"epss_score": 0.00188, "epss_percentile": 0.40895}, "CVE-2023-32066": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-32067": {"epss_score": 0.00353, "epss_percentile": 0.57186}, "CVE-2023-32068": {"epss_score": 0.63377, "epss_percentile": 0.98331}, "CVE-2023-32069": {"epss_score": 0.03057, "epss_percentile": 0.86303}, "CVE-2023-32070": {"epss_score": 0.04167, "epss_percentile": 0.88342}, "CVE-2023-32071": {"epss_score": 0.53502, "epss_percentile": 0.9788}, "CVE-2023-32072": {"epss_score": 0.0031, "epss_percentile": 0.53768}, "CVE-2023-32073": {"epss_score": 0.0394, "epss_percentile": 0.87988}, "CVE-2023-32074": {"epss_score": 0.00306, "epss_percentile": 0.53444}, "CVE-2023-32075": {"epss_score": 0.00012, "epss_percentile": 0.0113}, "CVE-2023-32076": {"epss_score": 0.00044, "epss_percentile": 0.13382}, "CVE-2023-32077": {"epss_score": 0.84662, "epss_percentile": 0.99299}, "CVE-2023-32078": {"epss_score": 0.00118, "epss_percentile": 0.31486}, "CVE-2023-32079": {"epss_score": 0.00554, "epss_percentile": 0.67439}, "CVE-2023-32080": {"epss_score": 0.00218, "epss_percentile": 0.44429}, "CVE-2023-32081": {"epss_score": 0.00293, "epss_percentile": 0.52319}, "CVE-2023-32082": {"epss_score": 0.00224, "epss_percentile": 0.45044}, "CVE-2023-32083": {"epss_score": 0.00391, "epss_percentile": 0.59583}, "CVE-2023-32084": {"epss_score": 0.05725, "epss_percentile": 0.90155}, "CVE-2023-32085": {"epss_score": 0.00227, "epss_percentile": 0.45436}, "CVE-2023-32087": {"epss_score": 0.00111, "epss_percentile": 0.3039}, "CVE-2023-32088": {"epss_score": 0.00111, "epss_percentile": 0.3039}, "CVE-2023-32089": {"epss_score": 0.00111, "epss_percentile": 0.3039}, "CVE-2023-32090": {"epss_score": 0.00216, "epss_percentile": 0.44189}, "CVE-2023-32091": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-32092": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32093": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32094": {"epss_score": 0.0012, "epss_percentile": 0.31729}, "CVE-2023-32095": {"epss_score": 0.00692, "epss_percentile": 0.71305}, "CVE-2023-32096": {"epss_score": 0.00082, "epss_percentile": 0.24552}, "CVE-2023-32097": {"epss_score": 0.00082, "epss_percentile": 0.24552}, "CVE-2023-32098": {"epss_score": 0.00086, "epss_percentile": 0.25411}, "CVE-2023-32099": {"epss_score": 0.00086, "epss_percentile": 0.25411}, "CVE-2023-32100": {"epss_score": 0.00086, "epss_percentile": 0.25411}, "CVE-2023-32101": {"epss_score": 0.00213, "epss_percentile": 0.43838}, "CVE-2023-32102": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-32103": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-32104": {"epss_score": 0.0007, "epss_percentile": 0.21758}, "CVE-2023-32105": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-32106": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-32107": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-32108": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-32109": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-32110": {"epss_score": 0.00637, "epss_percentile": 0.69878}, "CVE-2023-32111": {"epss_score": 0.00155, "epss_percentile": 0.36834}, "CVE-2023-32112": {"epss_score": 0.00043, "epss_percentile": 0.13208}, "CVE-2023-32113": {"epss_score": 0.00183, "epss_percentile": 0.40349}, "CVE-2023-32114": {"epss_score": 0.00064, "epss_percentile": 0.2025}, "CVE-2023-32115": {"epss_score": 0.00139, "epss_percentile": 0.34629}, "CVE-2023-32116": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-32117": {"epss_score": 0.91548, "epss_percentile": 0.99652}, "CVE-2023-32118": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-32119": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32120": {"epss_score": 0.00101, "epss_percentile": 0.28656}, "CVE-2023-32121": {"epss_score": 0.00199, "epss_percentile": 0.42156}, "CVE-2023-32122": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-32123": {"epss_score": 0.00061, "epss_percentile": 0.19252}, "CVE-2023-32124": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-32125": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32126": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-32127": {"epss_score": 0.00072, "epss_percentile": 0.22421}, "CVE-2023-32128": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-32129": {"epss_score": 0.00173, "epss_percentile": 0.3908}, "CVE-2023-32130": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-32131": {"epss_score": 0.02056, "epss_percentile": 0.83424}, "CVE-2023-32132": {"epss_score": 0.02056, "epss_percentile": 0.83424}, "CVE-2023-32133": {"epss_score": 0.02056, "epss_percentile": 0.83424}, "CVE-2023-32134": {"epss_score": 0.00816, "epss_percentile": 0.73799}, "CVE-2023-32135": {"epss_score": 0.00734, "epss_percentile": 0.7224}, "CVE-2023-32136": {"epss_score": 0.00632, "epss_percentile": 0.69735}, "CVE-2023-32137": {"epss_score": 0.00158, "epss_percentile": 0.37222}, "CVE-2023-32138": {"epss_score": 0.00517, "epss_percentile": 0.66061}, "CVE-2023-32139": {"epss_score": 0.00517, "epss_percentile": 0.66061}, "CVE-2023-32140": {"epss_score": 0.00754, "epss_percentile": 0.72691}, "CVE-2023-32141": {"epss_score": 0.00343, "epss_percentile": 0.56429}, "CVE-2023-32142": {"epss_score": 0.00343, "epss_percentile": 0.56429}, "CVE-2023-32143": {"epss_score": 0.00528, "epss_percentile": 0.66565}, "CVE-2023-32144": {"epss_score": 0.00517, "epss_percentile": 0.66061}, "CVE-2023-32145": {"epss_score": 0.00137, "epss_percentile": 0.34301}, "CVE-2023-32146": {"epss_score": 0.00325, "epss_percentile": 0.54988}, "CVE-2023-32147": {"epss_score": 0.00313, "epss_percentile": 0.54037}, "CVE-2023-32148": {"epss_score": 0.00273, "epss_percentile": 0.50432}, "CVE-2023-32149": {"epss_score": 0.00664, "epss_percentile": 0.70635}, "CVE-2023-32150": {"epss_score": 0.00467, "epss_percentile": 0.63862}, "CVE-2023-32151": {"epss_score": 0.00313, "epss_percentile": 0.54037}, "CVE-2023-32152": {"epss_score": 0.00285, "epss_percentile": 0.51544}, "CVE-2023-32153": {"epss_score": 0.00467, "epss_percentile": 0.63862}, "CVE-2023-32154": {"epss_score": 0.03073, "epss_percentile": 0.86354}, "CVE-2023-32155": {"epss_score": 0.0008, "epss_percentile": 0.24143}, "CVE-2023-32156": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2023-32157": {"epss_score": 0.00112, "epss_percentile": 0.3049}, "CVE-2023-32158": {"epss_score": 0.01476, "epss_percentile": 0.80533}, "CVE-2023-32159": {"epss_score": 0.0256, "epss_percentile": 0.85103}, "CVE-2023-32160": {"epss_score": 0.0256, "epss_percentile": 0.85103}, "CVE-2023-32161": {"epss_score": 0.0256, "epss_percentile": 0.85103}, "CVE-2023-32162": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2023-32163": {"epss_score": 0.0008, "epss_percentile": 0.24021}, "CVE-2023-32164": {"epss_score": 0.36295, "epss_percentile": 0.96967}, "CVE-2023-32165": {"epss_score": 0.43443, "epss_percentile": 0.97387}, "CVE-2023-32166": {"epss_score": 0.43646, "epss_percentile": 0.97397}, "CVE-2023-32167": {"epss_score": 0.67929, "epss_percentile": 0.98525}, "CVE-2023-32168": {"epss_score": 0.01723, "epss_percentile": 0.81942}, "CVE-2023-32169": {"epss_score": 0.02737, "epss_percentile": 0.85551}, "CVE-2023-32170": {"epss_score": 0.00622, "epss_percentile": 0.69494}, "CVE-2023-32171": {"epss_score": 0.01353, "epss_percentile": 0.79694}, "CVE-2023-32172": {"epss_score": 0.00705, "epss_percentile": 0.71584}, "CVE-2023-32173": {"epss_score": 0.01666, "epss_percentile": 0.81652}, "CVE-2023-32174": {"epss_score": 0.06768, "epss_percentile": 0.91013}, "CVE-2023-32175": {"epss_score": 0.00226, "epss_percentile": 0.45261}, "CVE-2023-32176": {"epss_score": 0.00077, "epss_percentile": 0.23375}, "CVE-2023-32177": {"epss_score": 0.00068, "epss_percentile": 0.21317}, "CVE-2023-32178": {"epss_score": 0.00251, "epss_percentile": 0.48275}, "CVE-2023-32179": {"epss_score": 0.00251, "epss_percentile": 0.48275}, "CVE-2023-32181": {"epss_score": 0.00063, "epss_percentile": 0.19848}, "CVE-2023-32182": {"epss_score": 0.00022, "epss_percentile": 0.05243}, "CVE-2023-32183": {"epss_score": 0.00061, "epss_percentile": 0.19292}, "CVE-2023-32184": {"epss_score": 0.00068, "epss_percentile": 0.21283}, "CVE-2023-32186": {"epss_score": 0.00281, "epss_percentile": 0.51138}, "CVE-2023-32187": {"epss_score": 0.0023, "epss_percentile": 0.45695}, "CVE-2023-32188": {"epss_score": 0.00166, "epss_percentile": 0.38162}, "CVE-2023-32189": {"epss_score": 0.00041, "epss_percentile": 0.12294}, "CVE-2023-32190": {"epss_score": 0.00102, "epss_percentile": 0.28726}, "CVE-2023-32191": {"epss_score": 0.00145, "epss_percentile": 0.3545}, "CVE-2023-32192": {"epss_score": 0.00256, "epss_percentile": 0.48778}, "CVE-2023-32193": {"epss_score": 0.00167, "epss_percentile": 0.38338}, "CVE-2023-32194": {"epss_score": 0.0009, "epss_percentile": 0.26083}, "CVE-2023-32196": {"epss_score": 0.00041, "epss_percentile": 0.12432}, "CVE-2023-32197": {"epss_score": 0.0001, "epss_percentile": 0.00866}, "CVE-2023-32199": {"epss_score": 0.00012, "epss_percentile": 0.0122}, "CVE-2023-32200": {"epss_score": 0.00635, "epss_percentile": 0.69827}, "CVE-2023-32201": {"epss_score": 0.00076, "epss_percentile": 0.23185}, "CVE-2023-32202": {"epss_score": 0.00044, "epss_percentile": 0.13668}, "CVE-2023-32203": {"epss_score": 0.00042, "epss_percentile": 0.12908}, "CVE-2023-32204": {"epss_score": 0.00115, "epss_percentile": 0.30922}, "CVE-2023-32205": {"epss_score": 0.00186, "epss_percentile": 0.40689}, "CVE-2023-32206": {"epss_score": 0.00189, "epss_percentile": 0.40982}, "CVE-2023-32207": {"epss_score": 0.00249, "epss_percentile": 0.48007}, "CVE-2023-32208": {"epss_score": 0.00211, "epss_percentile": 0.43671}, "CVE-2023-32209": {"epss_score": 0.00148, "epss_percentile": 0.35824}, "CVE-2023-32210": {"epss_score": 0.0018, "epss_percentile": 0.39886}, "CVE-2023-32211": {"epss_score": 0.00137, "epss_percentile": 0.34281}, "CVE-2023-32212": {"epss_score": 0.00186, "epss_percentile": 0.40689}, "CVE-2023-32213": {"epss_score": 0.00231, "epss_percentile": 0.45821}, "CVE-2023-32214": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2023-32215": {"epss_score": 0.00251, "epss_percentile": 0.48278}, "CVE-2023-32216": {"epss_score": 0.0028, "epss_percentile": 0.51034}, "CVE-2023-32217": {"epss_score": 0.00603, "epss_percentile": 0.68904}, "CVE-2023-32218": {"epss_score": 0.00071, "epss_percentile": 0.22226}, "CVE-2023-32219": {"epss_score": 0.00056, "epss_percentile": 0.1773}, "CVE-2023-32220": {"epss_score": 0.00035, "epss_percentile": 0.1013}, "CVE-2023-32221": {"epss_score": 0.0003, "epss_percentile": 0.08094}, "CVE-2023-32222": {"epss_score": 0.00358, "epss_percentile": 0.57504}, "CVE-2023-32223": {"epss_score": 0.00133, "epss_percentile": 0.33649}, "CVE-2023-32224": {"epss_score": 0.00909, "epss_percentile": 0.75313}, "CVE-2023-32225": {"epss_score": 0.00072, "epss_percentile": 0.22328}, "CVE-2023-32226": {"epss_score": 0.00056, "epss_percentile": 0.17793}, "CVE-2023-32227": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2023-32228": {"epss_score": 0.00072, "epss_percentile": 0.22305}, "CVE-2023-32229": {"epss_score": 0.00128, "epss_percentile": 0.32962}, "CVE-2023-32230": {"epss_score": 0.00083, "epss_percentile": 0.24617}, "CVE-2023-32231": {"epss_score": 0.00596, "epss_percentile": 0.68707}, "CVE-2023-32232": {"epss_score": 0.0046, "epss_percentile": 0.63537}, "CVE-2023-32233": {"epss_score": 0.00519, "epss_percentile": 0.6618}, "CVE-2023-32235": {"epss_score": 0.94094, "epss_percentile": 0.99902}, "CVE-2023-32236": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32237": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2023-32238": {"epss_score": 0.00059, "epss_percentile": 0.18647}, "CVE-2023-32239": {"epss_score": 0.00115, "epss_percentile": 0.30921}, "CVE-2023-32240": {"epss_score": 0.0012, "epss_percentile": 0.31729}, "CVE-2023-32241": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32242": {"epss_score": 0.00735, "epss_percentile": 0.72288}, "CVE-2023-32243": {"epss_score": 0.93638, "epss_percentile": 0.99827}, "CVE-2023-32244": {"epss_score": 0.00245, "epss_percentile": 0.47627}, "CVE-2023-32245": {"epss_score": 0.00153, "epss_percentile": 0.36613}, "CVE-2023-32246": {"epss_score": 0.00084, "epss_percentile": 0.2488}, "CVE-2023-32247": {"epss_score": 0.00083, "epss_percentile": 0.24807}, "CVE-2023-32248": {"epss_score": 0.00109, "epss_percentile": 0.30025}, "CVE-2023-32249": {"epss_score": 0.00052, "epss_percentile": 0.16462}, "CVE-2023-32250": {"epss_score": 0.00104, "epss_percentile": 0.29228}, "CVE-2023-32251": {"epss_score": 0.00055, "epss_percentile": 0.17382}, "CVE-2023-32252": {"epss_score": 0.00133, "epss_percentile": 0.3372}, "CVE-2023-32253": {"epss_score": 0.00066, "epss_percentile": 0.20935}, "CVE-2023-32254": {"epss_score": 0.00068, "epss_percentile": 0.21265}, "CVE-2023-32255": {"epss_score": 0.00047, "epss_percentile": 0.14898}, "CVE-2023-32256": {"epss_score": 0.00081, "epss_percentile": 0.24228}, "CVE-2023-32257": {"epss_score": 0.00114, "epss_percentile": 0.30871}, "CVE-2023-32258": {"epss_score": 0.00101, "epss_percentile": 0.28563}, "CVE-2023-32259": {"epss_score": 0.00047, "epss_percentile": 0.14767}, "CVE-2023-32260": {"epss_score": 0.00062, "epss_percentile": 0.19703}, "CVE-2023-32261": {"epss_score": 0.00255, "epss_percentile": 0.48694}, "CVE-2023-32262": {"epss_score": 0.00388, "epss_percentile": 0.59372}, "CVE-2023-32263": {"epss_score": 0.00237, "epss_percentile": 0.46641}, "CVE-2023-32264": {"epss_score": 0.00044, "epss_percentile": 0.13601}, "CVE-2023-32265": {"epss_score": 0.00163, "epss_percentile": 0.37813}, "CVE-2023-32266": {"epss_score": 0.00056, "epss_percentile": 0.17725}, "CVE-2023-32267": {"epss_score": 0.00163, "epss_percentile": 0.3782}, "CVE-2023-32268": {"epss_score": 0.00066, "epss_percentile": 0.20841}, "CVE-2023-32269": {"epss_score": 0.00011, "epss_percentile": 0.00932}, "CVE-2023-32270": {"epss_score": 0.00062, "epss_percentile": 0.19656}, "CVE-2023-32271": {"epss_score": 0.00103, "epss_percentile": 0.2893}, "CVE-2023-32272": {"epss_score": 0.00079, "epss_percentile": 0.23955}, "CVE-2023-32273": {"epss_score": 0.00076, "epss_percentile": 0.23185}, "CVE-2023-32274": {"epss_score": 0.00102, "epss_percentile": 0.28719}, "CVE-2023-32275": {"epss_score": 0.00058, "epss_percentile": 0.18546}, "CVE-2023-32276": {"epss_score": 0.00076, "epss_percentile": 0.23185}, "CVE-2023-32277": {"epss_score": 0.00036, "epss_percentile": 0.10231}, "CVE-2023-32278": {"epss_score": 0.00085, "epss_percentile": 0.25075}, "CVE-2023-32279": {"epss_score": 0.0028, "epss_percentile": 0.51039}, "CVE-2023-32280": {"epss_score": 0.00221, "epss_percentile": 0.44686}, "CVE-2023-32281": {"epss_score": 0.00055, "epss_percentile": 0.17605}, "CVE-2023-32282": {"epss_score": 0.00019, "epss_percentile": 0.04323}, "CVE-2023-32283": {"epss_score": 0.00096, "epss_percentile": 0.27355}, "CVE-2023-32284": {"epss_score": 0.00196, "epss_percentile": 0.41735}, "CVE-2023-32285": {"epss_score": 0.00028, "epss_percentile": 0.07503}, "CVE-2023-32288": {"epss_score": 0.00081, "epss_percentile": 0.24294}, "CVE-2023-32289": {"epss_score": 0.00055, "epss_percentile": 0.17605}, "CVE-2023-32290": {"epss_score": 0.00097, "epss_percentile": 0.27563}, "CVE-2023-32291": {"epss_score": 0.00262, "epss_percentile": 0.49334}, "CVE-2023-32292": {"epss_score": 0.00063, "epss_percentile": 0.19871}, "CVE-2023-32293": {"epss_score": 0.00194, "epss_percentile": 0.41536}, "CVE-2023-32294": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-32295": {"epss_score": 0.00179, "epss_percentile": 0.39804}, "CVE-2023-32296": {"epss_score": 0.0009, "epss_percentile": 0.261}, "CVE-2023-32297": {"epss_score": 0.00645, "epss_percentile": 0.70109}, "CVE-2023-32298": {"epss_score": 0.00235, "epss_percentile": 0.46328}, "CVE-2023-32299": {"epss_score": 0.00265, "epss_percentile": 0.49793}, "CVE-2023-32300": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32301": {"epss_score": 0.002, "epss_percentile": 0.42216}, "CVE-2023-32303": {"epss_score": 0.00073, "epss_percentile": 0.22642}, "CVE-2023-32305": {"epss_score": 0.00848, "epss_percentile": 0.74366}, "CVE-2023-32306": {"epss_score": 0.00484, "epss_percentile": 0.64662}, "CVE-2023-32307": {"epss_score": 0.00388, "epss_percentile": 0.59365}, "CVE-2023-32308": {"epss_score": 0.00115, "epss_percentile": 0.30907}, "CVE-2023-32309": {"epss_score": 0.03574, "epss_percentile": 0.87376}, "CVE-2023-32310": {"epss_score": 0.00146, "epss_percentile": 0.35546}, "CVE-2023-32311": {"epss_score": 0.00081, "epss_percentile": 0.24209}, "CVE-2023-32312": {"epss_score": 0.0022, "epss_percentile": 0.44615}, "CVE-2023-32313": {"epss_score": 0.005, "epss_percentile": 0.65295}, "CVE-2023-32314": {"epss_score": 0.69875, "epss_percentile": 0.98607}, "CVE-2023-32315": {"epss_score": 0.94441, "epss_percentile": 0.99989}, "CVE-2023-32316": {"epss_score": 0.00107, "epss_percentile": 0.29583}, "CVE-2023-32317": {"epss_score": 0.00378, "epss_percentile": 0.58799}, "CVE-2023-32318": {"epss_score": 0.00059, "epss_percentile": 0.18861}, "CVE-2023-32319": {"epss_score": 0.00202, "epss_percentile": 0.42484}, "CVE-2023-32320": {"epss_score": 0.00414, "epss_percentile": 0.61107}, "CVE-2023-32321": {"epss_score": 0.02878, "epss_percentile": 0.85888}, "CVE-2023-32322": {"epss_score": 0.00283, "epss_percentile": 0.51412}, "CVE-2023-32323": {"epss_score": 0.00127, "epss_percentile": 0.32819}, "CVE-2023-32324": {"epss_score": 0.00282, "epss_percentile": 0.51225}, "CVE-2023-32325": {"epss_score": 0.00492, "epss_percentile": 0.65001}, "CVE-2023-32327": {"epss_score": 0.00046, "epss_percentile": 0.14303}, "CVE-2023-32328": {"epss_score": 0.00032, "epss_percentile": 0.08785}, "CVE-2023-32329": {"epss_score": 0.00013, "epss_percentile": 0.01621}, "CVE-2023-32330": {"epss_score": 0.00074, "epss_percentile": 0.22835}, "CVE-2023-32331": {"epss_score": 0.00088, "epss_percentile": 0.25702}, "CVE-2023-32332": {"epss_score": 0.0005, "epss_percentile": 0.15704}, "CVE-2023-32333": {"epss_score": 0.00081, "epss_percentile": 0.24353}, "CVE-2023-32334": {"epss_score": 0.00076, "epss_percentile": 0.23252}, "CVE-2023-32335": {"epss_score": 0.00077, "epss_percentile": 0.23451}, "CVE-2023-32336": {"epss_score": 0.00193, "epss_percentile": 0.41405}, "CVE-2023-32337": {"epss_score": 0.00042, "epss_percentile": 0.12752}, "CVE-2023-32338": {"epss_score": 0.00019, "epss_percentile": 0.04209}, "CVE-2023-32339": {"epss_score": 0.00145, "epss_percentile": 0.35506}, "CVE-2023-32340": {"epss_score": 0.00101, "epss_percentile": 0.28643}, "CVE-2023-32341": {"epss_score": 0.00036, "epss_percentile": 0.10614}, "CVE-2023-32342": {"epss_score": 0.00057, "epss_percentile": 0.18143}, "CVE-2023-32344": {"epss_score": 0.00033, "epss_percentile": 0.0915}, "CVE-2023-32346": {"epss_score": 0.00128, "epss_percentile": 0.32998}, "CVE-2023-32347": {"epss_score": 0.0014, "epss_percentile": 0.34731}, "CVE-2023-32348": {"epss_score": 0.00113, "epss_percentile": 0.3069}, "CVE-2023-32349": {"epss_score": 0.00049, "epss_percentile": 0.1563}, "CVE-2023-32350": {"epss_score": 0.00303, "epss_percentile": 0.53215}, "CVE-2023-32351": {"epss_score": 0.00053, "epss_percentile": 0.16831}, "CVE-2023-32352": {"epss_score": 8e-05, "epss_percentile": 0.00538}, "CVE-2023-32353": {"epss_score": 0.01067, "epss_percentile": 0.77231}, "CVE-2023-32354": {"epss_score": 0.00031, "epss_percentile": 0.08328}, "CVE-2023-32355": {"epss_score": 0.00027, "epss_percentile": 0.06821}, "CVE-2023-32356": {"epss_score": 0.00064, "epss_percentile": 0.20109}, "CVE-2023-32357": {"epss_score": 0.00024, "epss_percentile": 0.05741}, "CVE-2023-32358": {"epss_score": 0.00117, "epss_percentile": 0.31309}, "CVE-2023-32359": {"epss_score": 0.00099, "epss_percentile": 0.28364}, "CVE-2023-32360": {"epss_score": 0.00064, "epss_percentile": 0.20326}, "CVE-2023-32361": {"epss_score": 0.00021, "epss_percentile": 0.04783}, "CVE-2023-32362": {"epss_score": 0.00236, "epss_percentile": 0.46432}, "CVE-2023-32363": {"epss_score": 7e-05, "epss_percentile": 0.00349}, "CVE-2023-32364": {"epss_score": 0.08126, "epss_percentile": 0.91893}, "CVE-2023-32365": {"epss_score": 0.00041, "epss_percentile": 0.12295}, "CVE-2023-32366": {"epss_score": 0.00078, "epss_percentile": 0.23751}, "CVE-2023-32367": {"epss_score": 0.00039, "epss_percentile": 0.11651}, "CVE-2023-32368": {"epss_score": 0.00031, "epss_percentile": 0.08328}, "CVE-2023-32369": {"epss_score": 0.00031, "epss_percentile": 0.08391}, "CVE-2023-32370": {"epss_score": 0.00029, "epss_percentile": 0.07661}, "CVE-2023-32371": {"epss_score": 0.00028, "epss_percentile": 0.0751}, "CVE-2023-32372": {"epss_score": 0.00031, "epss_percentile": 0.08328}, "CVE-2023-32373": {"epss_score": 0.00018, "epss_percentile": 0.03621}, "CVE-2023-32375": {"epss_score": 0.00029, "epss_percentile": 0.07699}, "CVE-2023-32376": {"epss_score": 0.0003, "epss_percentile": 0.08163}, "CVE-2023-32377": {"epss_score": 0.00194, "epss_percentile": 0.41578}, "CVE-2023-32378": {"epss_score": 0.00132, "epss_percentile": 0.33616}, "CVE-2023-32379": {"epss_score": 0.00067, "epss_percentile": 0.21168}, "CVE-2023-32380": {"epss_score": 0.0004, "epss_percentile": 0.12067}, "CVE-2023-32381": {"epss_score": 0.00053, "epss_percentile": 0.16933}, "CVE-2023-32382": {"epss_score": 0.00032, "epss_percentile": 0.08789}, "CVE-2023-32383": {"epss_score": 0.00158, "epss_percentile": 0.37161}, "CVE-2023-32384": {"epss_score": 0.00049, "epss_percentile": 0.15431}, "CVE-2023-32385": {"epss_score": 0.00032, "epss_percentile": 0.08793}, "CVE-2023-32386": {"epss_score": 0.00049, "epss_percentile": 0.15296}, "CVE-2023-32387": {"epss_score": 0.01153, "epss_percentile": 0.78061}, "CVE-2023-32388": {"epss_score": 0.00011, "epss_percentile": 0.00953}, "CVE-2023-32389": {"epss_score": 0.00054, "epss_percentile": 0.17231}, "CVE-2023-32390": {"epss_score": 0.00068, "epss_percentile": 0.21238}, "CVE-2023-32391": {"epss_score": 0.00046, "epss_percentile": 0.14346}, "CVE-2023-32392": {"epss_score": 0.00023, "epss_percentile": 0.05624}, "CVE-2023-32393": {"epss_score": 0.00237, "epss_percentile": 0.46724}, "CVE-2023-32394": {"epss_score": 0.00048, "epss_percentile": 0.15108}, "CVE-2023-32395": {"epss_score": 0.00024, "epss_percentile": 0.05843}, "CVE-2023-32396": {"epss_score": 0.00021, "epss_percentile": 0.04717}, "CVE-2023-32397": {"epss_score": 0.001, "epss_percentile": 0.28523}, "CVE-2023-32398": {"epss_score": 0.00049, "epss_percentile": 0.15431}, "CVE-2023-32399": {"epss_score": 0.00039, "epss_percentile": 0.1166}, "CVE-2023-32400": {"epss_score": 0.0002, "epss_percentile": 0.04627}, "CVE-2023-32401": {"epss_score": 0.00083, "epss_percentile": 0.24705}, "CVE-2023-32402": {"epss_score": 0.00135, "epss_percentile": 0.34047}, "CVE-2023-32403": {"epss_score": 0.00023, "epss_percentile": 0.05624}, "CVE-2023-32404": {"epss_score": 0.00011, "epss_percentile": 0.01114}, "CVE-2023-32405": {"epss_score": 0.00037, "epss_percentile": 0.10976}, "CVE-2023-32407": {"epss_score": 0.02751, "epss_percentile": 0.85581}, "CVE-2023-32408": {"epss_score": 0.00023, "epss_percentile": 0.05624}, "CVE-2023-32409": {"epss_score": 0.0025, "epss_percentile": 0.48102}, "CVE-2023-32410": {"epss_score": 0.00031, "epss_percentile": 0.08328}, "CVE-2023-32411": {"epss_score": 0.00013, "epss_percentile": 0.01585}, "CVE-2023-32412": {"epss_score": 0.01001, "epss_percentile": 0.76494}, "CVE-2023-32413": {"epss_score": 0.00585, "epss_percentile": 0.68429}, "CVE-2023-32414": {"epss_score": 0.00029, "epss_percentile": 0.07829}, "CVE-2023-32415": {"epss_score": 0.00036, "epss_percentile": 0.10242}, "CVE-2023-32416": {"epss_score": 0.00041, "epss_percentile": 0.12444}, "CVE-2023-32417": {"epss_score": 0.00069, "epss_percentile": 0.21607}, "CVE-2023-32418": {"epss_score": 0.00076, "epss_percentile": 0.23217}, "CVE-2023-32419": {"epss_score": 0.01527, "epss_percentile": 0.80869}, "CVE-2023-32420": {"epss_score": 0.0003, "epss_percentile": 0.08149}, "CVE-2023-32421": {"epss_score": 0.00123, "epss_percentile": 0.32322}, "CVE-2023-32422": {"epss_score": 0.00167, "epss_percentile": 0.38352}, "CVE-2023-32423": {"epss_score": 0.00172, "epss_percentile": 0.39036}, "CVE-2023-32424": {"epss_score": 7e-05, "epss_percentile": 0.00377}, "CVE-2023-32425": {"epss_score": 0.00086, "epss_percentile": 0.25291}, "CVE-2023-32426": {"epss_score": 0.00065, "epss_percentile": 0.20624}, "CVE-2023-32427": {"epss_score": 0.00108, "epss_percentile": 0.29817}, "CVE-2023-32428": {"epss_score": 0.00912, "epss_percentile": 0.75357}, "CVE-2023-32429": {"epss_score": 0.00013, "epss_percentile": 0.01525}, "CVE-2023-32432": {"epss_score": 0.00041, "epss_percentile": 0.12427}, "CVE-2023-32433": {"epss_score": 0.00049, "epss_percentile": 0.15431}, "CVE-2023-32434": {"epss_score": 0.64205, "epss_percentile": 0.9837}, "CVE-2023-32435": {"epss_score": 0.00415, "epss_percentile": 0.61135}, "CVE-2023-32436": {"epss_score": 0.00082, "epss_percentile": 0.24485}, "CVE-2023-32437": {"epss_score": 0.00066, "epss_percentile": 0.20755}, "CVE-2023-32438": {"epss_score": 0.00049, "epss_percentile": 0.15326}, "CVE-2023-32439": {"epss_score": 0.00987, "epss_percentile": 0.76339}, "CVE-2023-32441": {"epss_score": 0.00049, "epss_percentile": 0.15431}, "CVE-2023-32442": {"epss_score": 0.00028, "epss_percentile": 0.0751}, "CVE-2023-32443": {"epss_score": 0.00107, "epss_percentile": 0.29594}, "CVE-2023-32444": {"epss_score": 0.00117, "epss_percentile": 0.31348}, "CVE-2023-32445": {"epss_score": 0.00468, "epss_percentile": 0.63868}, "CVE-2023-32446": {"epss_score": 0.00025, "epss_percentile": 0.06301}, "CVE-2023-32447": {"epss_score": 0.00025, "epss_percentile": 0.06301}, "CVE-2023-32448": {"epss_score": 0.00025, "epss_percentile": 0.06301}, "CVE-2023-32449": {"epss_score": 5e-05, "epss_percentile": 0.00233}, "CVE-2023-32450": {"epss_score": 0.0005, "epss_percentile": 0.15943}, "CVE-2023-32451": {"epss_score": 0.0003, "epss_percentile": 0.08309}, "CVE-2023-32453": {"epss_score": 0.0003, "epss_percentile": 0.08033}, "CVE-2023-32454": {"epss_score": 0.0002, "epss_percentile": 0.04494}, "CVE-2023-32455": {"epss_score": 0.00025, "epss_percentile": 0.06301}, "CVE-2023-32457": {"epss_score": 0.00618, "epss_percentile": 0.69368}, "CVE-2023-32458": {"epss_score": 0.00064, "epss_percentile": 0.20181}, "CVE-2023-32460": {"epss_score": 0.00051, "epss_percentile": 0.16121}, "CVE-2023-32461": {"epss_score": 0.00065, "epss_percentile": 0.20626}, "CVE-2023-32462": {"epss_score": 0.01703, "epss_percentile": 0.8184}, "CVE-2023-32463": {"epss_score": 0.00183, "epss_percentile": 0.40351}, "CVE-2023-32464": {"epss_score": 0.00071, "epss_percentile": 0.22146}, "CVE-2023-32465": {"epss_score": 0.00123, "epss_percentile": 0.32317}, "CVE-2023-32466": {"epss_score": 0.00093, "epss_percentile": 0.26727}, "CVE-2023-32467": {"epss_score": 0.00078, "epss_percentile": 0.23555}, "CVE-2023-32468": {"epss_score": 0.00139, "epss_percentile": 0.34663}, "CVE-2023-32469": {"epss_score": 0.00034, "epss_percentile": 0.09803}, "CVE-2023-32470": {"epss_score": 0.00019, "epss_percentile": 0.04173}, "CVE-2023-32471": {"epss_score": 0.00106, "epss_percentile": 0.29403}, "CVE-2023-32472": {"epss_score": 0.00105, "epss_percentile": 0.29376}, "CVE-2023-32474": {"epss_score": 0.00015, "epss_percentile": 0.02157}, "CVE-2023-32475": {"epss_score": 0.00015, "epss_percentile": 0.02186}, "CVE-2023-32476": {"epss_score": 0.00041, "epss_percentile": 0.12321}, "CVE-2023-32477": {"epss_score": 0.0011, "epss_percentile": 0.30179}, "CVE-2023-32478": {"epss_score": 0.0016, "epss_percentile": 0.3743}, "CVE-2023-32479": {"epss_score": 0.00043, "epss_percentile": 0.13222}, "CVE-2023-32480": {"epss_score": 0.00059, "epss_percentile": 0.18675}, "CVE-2023-32481": {"epss_score": 0.00129, "epss_percentile": 0.33166}, "CVE-2023-32482": {"epss_score": 0.00077, "epss_percentile": 0.23455}, "CVE-2023-32483": {"epss_score": 0.00022, "epss_percentile": 0.05248}, "CVE-2023-32484": {"epss_score": 0.00149, "epss_percentile": 0.35935}, "CVE-2023-32485": {"epss_score": 0.00253, "epss_percentile": 0.48493}, "CVE-2023-32486": {"epss_score": 0.00054, "epss_percentile": 0.17284}, "CVE-2023-32487": {"epss_score": 0.00037, "epss_percentile": 0.10738}, "CVE-2023-32488": {"epss_score": 0.00167, "epss_percentile": 0.38398}, "CVE-2023-32489": {"epss_score": 9e-05, "epss_percentile": 0.00603}, "CVE-2023-32490": {"epss_score": 0.0003, "epss_percentile": 0.08272}, "CVE-2023-32491": {"epss_score": 0.00125, "epss_percentile": 0.32546}, "CVE-2023-32492": {"epss_score": 0.00033, "epss_percentile": 0.09292}, "CVE-2023-32493": {"epss_score": 0.00428, "epss_percentile": 0.61917}, "CVE-2023-32494": {"epss_score": 0.0003, "epss_percentile": 0.08272}, "CVE-2023-32495": {"epss_score": 0.00054, "epss_percentile": 0.17284}, "CVE-2023-32496": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-32497": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-32498": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-32499": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32500": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32501": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32502": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32503": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-32504": {"epss_score": 0.00123, "epss_percentile": 0.32321}, "CVE-2023-32505": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-32506": {"epss_score": 0.00146, "epss_percentile": 0.35581}, "CVE-2023-32507": {"epss_score": 0.00165, "epss_percentile": 0.38076}, "CVE-2023-32508": {"epss_score": 0.00212, "epss_percentile": 0.4375}, "CVE-2023-32509": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32510": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32511": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32512": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32513": {"epss_score": 0.00303, "epss_percentile": 0.53214}, "CVE-2023-32514": {"epss_score": 0.00098, "epss_percentile": 0.27832}, "CVE-2023-32515": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-32516": {"epss_score": 0.00103, "epss_percentile": 0.29097}, "CVE-2023-32517": {"epss_score": 0.00202, "epss_percentile": 0.42475}, "CVE-2023-32518": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32519": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-32520": {"epss_score": 0.00426, "epss_percentile": 0.61734}, "CVE-2023-32521": {"epss_score": 0.71112, "epss_percentile": 0.98654}, "CVE-2023-32522": {"epss_score": 0.01213, "epss_percentile": 0.78565}, "CVE-2023-32523": {"epss_score": 0.0017, "epss_percentile": 0.38737}, "CVE-2023-32524": {"epss_score": 0.0017, "epss_percentile": 0.38737}, "CVE-2023-32525": {"epss_score": 0.00212, "epss_percentile": 0.43812}, "CVE-2023-32526": {"epss_score": 0.00212, "epss_percentile": 0.43812}, "CVE-2023-32527": {"epss_score": 0.03428, "epss_percentile": 0.87118}, "CVE-2023-32528": {"epss_score": 0.03428, "epss_percentile": 0.87118}, "CVE-2023-32529": {"epss_score": 0.02611, "epss_percentile": 0.85235}, "CVE-2023-32530": {"epss_score": 0.03216, "epss_percentile": 0.86663}, "CVE-2023-32531": {"epss_score": 0.0079, "epss_percentile": 0.73372}, "CVE-2023-32532": {"epss_score": 0.0079, "epss_percentile": 0.73372}, "CVE-2023-32533": {"epss_score": 0.0079, "epss_percentile": 0.73372}, "CVE-2023-32534": {"epss_score": 0.0079, "epss_percentile": 0.73372}, "CVE-2023-32535": {"epss_score": 0.0079, "epss_percentile": 0.73372}, "CVE-2023-32536": {"epss_score": 0.00385, "epss_percentile": 0.59209}, "CVE-2023-32537": {"epss_score": 0.00385, "epss_percentile": 0.59209}, "CVE-2023-32538": {"epss_score": 0.00076, "epss_percentile": 0.23185}, "CVE-2023-32539": {"epss_score": 0.00042, "epss_percentile": 0.12908}, "CVE-2023-32540": {"epss_score": 0.0009, "epss_percentile": 0.26062}, "CVE-2023-32541": {"epss_score": 0.00248, "epss_percentile": 0.48}, "CVE-2023-32542": {"epss_score": 0.00081, "epss_percentile": 0.24294}, "CVE-2023-32543": {"epss_score": 0.00045, "epss_percentile": 0.13781}, "CVE-2023-32544": {"epss_score": 0.00046, "epss_percentile": 0.1442}, "CVE-2023-32545": {"epss_score": 0.00055, "epss_percentile": 0.17605}, "CVE-2023-32546": {"epss_score": 0.00042, "epss_percentile": 0.1263}, "CVE-2023-32547": {"epss_score": 0.00045, "epss_percentile": 0.13781}, "CVE-2023-32548": {"epss_score": 0.00893, "epss_percentile": 0.75076}, "CVE-2023-32549": {"epss_score": 0.00193, "epss_percentile": 0.41378}, "CVE-2023-32550": {"epss_score": 0.00168, "epss_percentile": 0.38404}, "CVE-2023-32551": {"epss_score": 0.00168, "epss_percentile": 0.38456}, "CVE-2023-32552": {"epss_score": 0.00251, "epss_percentile": 0.4827}, "CVE-2023-32553": {"epss_score": 0.00245, "epss_percentile": 0.4766}, "CVE-2023-32554": {"epss_score": 0.0004, "epss_percentile": 0.12055}, "CVE-2023-32555": {"epss_score": 0.0004, "epss_percentile": 0.12055}, "CVE-2023-32556": {"epss_score": 0.00059, "epss_percentile": 0.18878}, "CVE-2023-32557": {"epss_score": 0.0534, "epss_percentile": 0.89758}, "CVE-2023-32558": {"epss_score": 0.00193, "epss_percentile": 0.414}, "CVE-2023-32559": {"epss_score": 0.00054, "epss_percentile": 0.17288}, "CVE-2023-32560": {"epss_score": 0.91909, "epss_percentile": 0.99677}, "CVE-2023-32561": {"epss_score": 0.00097, "epss_percentile": 0.27532}, "CVE-2023-32562": {"epss_score": 0.27344, "epss_percentile": 0.96239}, "CVE-2023-32563": {"epss_score": 0.92509, "epss_percentile": 0.99723}, "CVE-2023-32564": {"epss_score": 0.27344, "epss_percentile": 0.96239}, "CVE-2023-32565": {"epss_score": 0.00371, "epss_percentile": 0.584}, "CVE-2023-32566": {"epss_score": 0.00371, "epss_percentile": 0.584}, "CVE-2023-32567": {"epss_score": 0.00367, "epss_percentile": 0.58118}, "CVE-2023-32568": {"epss_score": 0.00197, "epss_percentile": 0.4195}, "CVE-2023-32569": {"epss_score": 0.00211, "epss_percentile": 0.43617}, "CVE-2023-32570": {"epss_score": 0.0007, "epss_percentile": 0.21982}, "CVE-2023-32571": {"epss_score": 0.77786, "epss_percentile": 0.98954}, "CVE-2023-32572": {"epss_score": 0.00041, "epss_percentile": 0.12223}, "CVE-2023-32573": {"epss_score": 0.00063, "epss_percentile": 0.19996}, "CVE-2023-32574": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2023-32575": {"epss_score": 0.00063, "epss_percentile": 0.19937}, "CVE-2023-32576": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2023-32577": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-32578": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-32579": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32580": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-32581": {"epss_score": 0.00184, "epss_percentile": 0.40412}, "CVE-2023-32582": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-32583": {"epss_score": 0.00068, "epss_percentile": 0.2141}, "CVE-2023-32584": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-32585": {"epss_score": 0.00255, "epss_percentile": 0.48705}, "CVE-2023-32586": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-32587": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32588": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-32589": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-32590": {"epss_score": 0.01801, "epss_percentile": 0.82325}, "CVE-2023-32591": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-32592": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32593": {"epss_score": 0.00108, "epss_percentile": 0.29864}, "CVE-2023-32594": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32595": {"epss_score": 0.00053, "epss_percentile": 0.16927}, "CVE-2023-32596": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-32597": {"epss_score": 0.00047, "epss_percentile": 0.14783}, "CVE-2023-32598": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32599": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-32600": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-32601": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2023-32602": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32603": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32604": {"epss_score": 0.00385, "epss_percentile": 0.59209}, "CVE-2023-32605": {"epss_score": 0.00385, "epss_percentile": 0.59209}, "CVE-2023-32607": {"epss_score": 0.00297, "epss_percentile": 0.5268}, "CVE-2023-32608": {"epss_score": 0.00427, "epss_percentile": 0.6188}, "CVE-2023-32609": {"epss_score": 0.00059, "epss_percentile": 0.18665}, "CVE-2023-32610": {"epss_score": 0.00529, "epss_percentile": 0.66601}, "CVE-2023-32611": {"epss_score": 0.00037, "epss_percentile": 0.10838}, "CVE-2023-32612": {"epss_score": 0.00072, "epss_percentile": 0.22391}, "CVE-2023-32613": {"epss_score": 0.00032, "epss_percentile": 0.0877}, "CVE-2023-32614": {"epss_score": 0.00156, "epss_percentile": 0.36954}, "CVE-2023-32615": {"epss_score": 0.00056, "epss_percentile": 0.1775}, "CVE-2023-32616": {"epss_score": 0.00016, "epss_percentile": 0.02614}, "CVE-2023-32617": {"epss_score": 0.00035, "epss_percentile": 0.10036}, "CVE-2023-32618": {"epss_score": 0.00168, "epss_percentile": 0.38425}, "CVE-2023-32619": {"epss_score": 0.00089, "epss_percentile": 0.25822}, "CVE-2023-32620": {"epss_score": 0.0004, "epss_percentile": 0.12182}, "CVE-2023-32621": {"epss_score": 0.00072, "epss_percentile": 0.22391}, "CVE-2023-32622": {"epss_score": 0.00076, "epss_percentile": 0.23219}, "CVE-2023-32623": {"epss_score": 0.0574, "epss_percentile": 0.90168}, "CVE-2023-32624": {"epss_score": 0.00511, "epss_percentile": 0.65829}, "CVE-2023-32625": {"epss_score": 0.00124, "epss_percentile": 0.32373}, "CVE-2023-32626": {"epss_score": 0.00536, "epss_percentile": 0.6686}, "CVE-2023-32627": {"epss_score": 0.00049, "epss_percentile": 0.15574}, "CVE-2023-32628": {"epss_score": 0.00215, "epss_percentile": 0.44103}, "CVE-2023-32629": {"epss_score": 0.62839, "epss_percentile": 0.98309}, "CVE-2023-32632": {"epss_score": 0.0017, "epss_percentile": 0.3871}, "CVE-2023-32633": {"epss_score": 0.00044, "epss_percentile": 0.13491}, "CVE-2023-32634": {"epss_score": 0.00033, "epss_percentile": 0.09407}, "CVE-2023-32635": {"epss_score": 0.00022, "epss_percentile": 0.05023}, "CVE-2023-32636": {"epss_score": 0.00179, "epss_percentile": 0.39821}, "CVE-2023-32637": {"epss_score": 0.00199, "epss_percentile": 0.42143}, "CVE-2023-32638": {"epss_score": 0.00064, "epss_percentile": 0.20193}, "CVE-2023-32639": {"epss_score": 0.00038, "epss_percentile": 0.11098}, "CVE-2023-32641": {"epss_score": 0.00092, "epss_percentile": 0.26555}, "CVE-2023-32642": {"epss_score": 0.00084, "epss_percentile": 0.24914}, "CVE-2023-32643": {"epss_score": 0.00044, "epss_percentile": 0.13482}, "CVE-2023-32644": {"epss_score": 0.00072, "epss_percentile": 0.22383}, "CVE-2023-32645": {"epss_score": 0.00063, "epss_percentile": 0.19829}, "CVE-2023-32646": {"epss_score": 0.00083, "epss_percentile": 0.24768}, "CVE-2023-32647": {"epss_score": 0.00062, "epss_percentile": 0.19605}, "CVE-2023-32649": {"epss_score": 0.00132, "epss_percentile": 0.33597}, "CVE-2023-32650": {"epss_score": 0.00039, "epss_percentile": 0.11718}, "CVE-2023-32651": {"epss_score": 0.00034, "epss_percentile": 0.098}, "CVE-2023-32652": {"epss_score": 0.0009, "epss_percentile": 0.26102}, "CVE-2023-32653": {"epss_score": 0.00146, "epss_percentile": 0.3557}, "CVE-2023-32654": {"epss_score": 0.00132, "epss_percentile": 0.33571}, "CVE-2023-32655": {"epss_score": 0.00096, "epss_percentile": 0.27367}, "CVE-2023-32656": {"epss_score": 0.00058, "epss_percentile": 0.18485}, "CVE-2023-32657": {"epss_score": 0.00074, "epss_percentile": 0.2286}, "CVE-2023-32658": {"epss_score": 0.00156, "epss_percentile": 0.36916}, "CVE-2023-32659": {"epss_score": 0.00042, "epss_percentile": 0.12706}, "CVE-2023-32660": {"epss_score": 0.00148, "epss_percentile": 0.359}, "CVE-2023-32661": {"epss_score": 0.00113, "epss_percentile": 0.30718}, "CVE-2023-32662": {"epss_score": 0.00047, "epss_percentile": 0.14482}, "CVE-2023-32663": {"epss_score": 0.00045, "epss_percentile": 0.13781}, "CVE-2023-32664": {"epss_score": 0.01393, "epss_percentile": 0.79962}, "CVE-2023-32665": {"epss_score": 0.00059, "epss_percentile": 0.18835}, "CVE-2023-32666": {"epss_score": 0.00027, "epss_percentile": 0.0682}, "CVE-2023-32668": {"epss_score": 0.00068, "epss_percentile": 0.21317}, "CVE-2023-32669": {"epss_score": 0.00046, "epss_percentile": 0.1418}, "CVE-2023-32670": {"epss_score": 0.0019, "epss_percentile": 0.41061}, "CVE-2023-32671": {"epss_score": 0.00177, "epss_percentile": 0.39615}, "CVE-2023-32672": {"epss_score": 0.00163, "epss_percentile": 0.37775}, "CVE-2023-32673": {"epss_score": 0.00626, "epss_percentile": 0.69611}, "CVE-2023-32674": {"epss_score": 0.00637, "epss_percentile": 0.69898}, "CVE-2023-32675": {"epss_score": 0.00182, "epss_percentile": 0.4023}, "CVE-2023-32676": {"epss_score": 0.00378, "epss_percentile": 0.58799}, "CVE-2023-32677": {"epss_score": 0.00068, "epss_percentile": 0.21378}, "CVE-2023-32678": {"epss_score": 0.0003, "epss_percentile": 0.08232}, "CVE-2023-32679": {"epss_score": 0.25669, "epss_percentile": 0.96054}, "CVE-2023-32680": {"epss_score": 0.0014, "epss_percentile": 0.34712}, "CVE-2023-32681": {"epss_score": 0.06121, "epss_percentile": 0.90494}, "CVE-2023-32682": {"epss_score": 0.00675, "epss_percentile": 0.70896}, "CVE-2023-32683": {"epss_score": 0.00251, "epss_percentile": 0.48317}, "CVE-2023-32684": {"epss_score": 0.00076, "epss_percentile": 0.2316}, "CVE-2023-32685": {"epss_score": 0.00524, "epss_percentile": 0.66362}, "CVE-2023-32686": {"epss_score": 0.00691, "epss_percentile": 0.71277}, "CVE-2023-32687": {"epss_score": 0.00157, "epss_percentile": 0.37057}, "CVE-2023-32688": {"epss_score": 0.00152, "epss_percentile": 0.36406}, "CVE-2023-32689": {"epss_score": 0.00268, "epss_percentile": 0.50096}, "CVE-2023-32690": {"epss_score": 0.00146, "epss_percentile": 0.35615}, "CVE-2023-32691": {"epss_score": 0.00215, "epss_percentile": 0.44099}, "CVE-2023-32692": {"epss_score": 0.00575, "epss_percentile": 0.68103}, "CVE-2023-32693": {"epss_score": 0.0018, "epss_percentile": 0.39899}, "CVE-2023-32694": {"epss_score": 0.00232, "epss_percentile": 0.45927}, "CVE-2023-32695": {"epss_score": 0.00162, "epss_percentile": 0.37724}, "CVE-2023-32696": {"epss_score": 0.0021, "epss_percentile": 0.43472}, "CVE-2023-32697": {"epss_score": 0.05401, "epss_percentile": 0.89832}, "CVE-2023-32698": {"epss_score": 0.00184, "epss_percentile": 0.40447}, "CVE-2023-32699": {"epss_score": 0.00931, "epss_percentile": 0.7562}, "CVE-2023-32700": {"epss_score": 0.00388, "epss_percentile": 0.59386}, "CVE-2023-32701": {"epss_score": 0.00093, "epss_percentile": 0.26635}, "CVE-2023-32706": {"epss_score": 0.00215, "epss_percentile": 0.44101}, "CVE-2023-32707": {"epss_score": 0.84179, "epss_percentile": 0.99277}, "CVE-2023-32708": {"epss_score": 0.00151, "epss_percentile": 0.3623}, "CVE-2023-32709": {"epss_score": 0.00164, "epss_percentile": 0.37904}, "CVE-2023-32710": {"epss_score": 0.00281, "epss_percentile": 0.51197}, "CVE-2023-32711": {"epss_score": 0.00366, "epss_percentile": 0.58063}, "CVE-2023-32712": {"epss_score": 0.00279, "epss_percentile": 0.50935}, "CVE-2023-32713": {"epss_score": 0.00156, "epss_percentile": 0.36888}, "CVE-2023-32714": {"epss_score": 0.32575, "epss_percentile": 0.96708}, "CVE-2023-32715": {"epss_score": 0.00422, "epss_percentile": 0.61556}, "CVE-2023-32716": {"epss_score": 0.00209, "epss_percentile": 0.43406}, "CVE-2023-32717": {"epss_score": 0.00119, "epss_percentile": 0.31677}, "CVE-2023-32721": {"epss_score": 0.00715, "epss_percentile": 0.71834}, "CVE-2023-32722": {"epss_score": 0.00357, "epss_percentile": 0.57476}, "CVE-2023-32723": {"epss_score": 0.00126, "epss_percentile": 0.3263}, "CVE-2023-32724": {"epss_score": 0.0072, "epss_percentile": 0.7196}, "CVE-2023-32725": {"epss_score": 0.00204, "epss_percentile": 0.42662}, "CVE-2023-32726": {"epss_score": 0.00134, "epss_percentile": 0.3377}, "CVE-2023-32727": {"epss_score": 0.00464, "epss_percentile": 0.63723}, "CVE-2023-32728": {"epss_score": 0.00799, "epss_percentile": 0.73526}, "CVE-2023-32731": {"epss_score": 0.0007, "epss_percentile": 0.2176}, "CVE-2023-32732": {"epss_score": 0.00023, "epss_percentile": 0.05389}, "CVE-2023-32734": {"epss_score": 0.00057, "epss_percentile": 0.18173}, "CVE-2023-32735": {"epss_score": 0.00058, "epss_percentile": 0.18269}, "CVE-2023-32736": {"epss_score": 0.00045, "epss_percentile": 0.13775}, "CVE-2023-32737": {"epss_score": 0.00055, "epss_percentile": 0.17448}, "CVE-2023-32738": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-32739": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32740": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32741": {"epss_score": 0.00204, "epss_percentile": 0.42613}, "CVE-2023-32742": {"epss_score": 0.0007, "epss_percentile": 0.21696}, "CVE-2023-32743": {"epss_score": 0.00133, "epss_percentile": 0.33669}, "CVE-2023-32744": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32745": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32746": {"epss_score": 0.00081, "epss_percentile": 0.24347}, "CVE-2023-32747": {"epss_score": 0.00098, "epss_percentile": 0.27685}, "CVE-2023-32748": {"epss_score": 0.00351, "epss_percentile": 0.57073}, "CVE-2023-32749": {"epss_score": 0.48732, "epss_percentile": 0.97651}, "CVE-2023-32750": {"epss_score": 0.02257, "epss_percentile": 0.84176}, "CVE-2023-32751": {"epss_score": 0.00795, "epss_percentile": 0.73469}, "CVE-2023-32752": {"epss_score": 0.00786, "epss_percentile": 0.73295}, "CVE-2023-32753": {"epss_score": 0.00403, "epss_percentile": 0.60385}, "CVE-2023-32754": {"epss_score": 0.00275, "epss_percentile": 0.50631}, "CVE-2023-32755": {"epss_score": 0.0016, "epss_percentile": 0.37508}, "CVE-2023-32756": {"epss_score": 0.00119, "epss_percentile": 0.31594}, "CVE-2023-32757": {"epss_score": 0.00548, "epss_percentile": 0.67268}, "CVE-2023-32758": {"epss_score": 0.00156, "epss_percentile": 0.36912}, "CVE-2023-32759": {"epss_score": 0.00171, "epss_percentile": 0.38884}, "CVE-2023-32760": {"epss_score": 0.00167, "epss_percentile": 0.38325}, "CVE-2023-32761": {"epss_score": 0.00328, "epss_percentile": 0.55266}, "CVE-2023-32762": {"epss_score": 0.00126, "epss_percentile": 0.32665}, "CVE-2023-32763": {"epss_score": 0.00091, "epss_percentile": 0.2627}, "CVE-2023-32764": {"epss_score": 0.00061, "epss_percentile": 0.19478}, "CVE-2023-32766": {"epss_score": 0.00136, "epss_percentile": 0.34148}, "CVE-2023-32767": {"epss_score": 0.00087, "epss_percentile": 0.25553}, "CVE-2023-32781": {"epss_score": 0.42231, "epss_percentile": 0.9732}, "CVE-2023-32782": {"epss_score": 0.21928, "epss_percentile": 0.95573}, "CVE-2023-32783": {"epss_score": 0.00137, "epss_percentile": 0.34245}, "CVE-2023-32784": {"epss_score": 0.75503, "epss_percentile": 0.98849}, "CVE-2023-32786": {"epss_score": 0.00149, "epss_percentile": 0.35999}, "CVE-2023-32787": {"epss_score": 0.00232, "epss_percentile": 0.45959}, "CVE-2023-32788": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-32789": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-32790": {"epss_score": 0.00118, "epss_percentile": 0.31469}, "CVE-2023-32791": {"epss_score": 0.00056, "epss_percentile": 0.17773}, "CVE-2023-32792": {"epss_score": 0.00056, "epss_percentile": 0.17773}, "CVE-2023-32793": {"epss_score": 0.00081, "epss_percentile": 0.24347}, "CVE-2023-32794": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-32795": {"epss_score": 0.00168, "epss_percentile": 0.38449}, "CVE-2023-32796": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-32797": {"epss_score": 0.00054, "epss_percentile": 0.17218}, "CVE-2023-32798": {"epss_score": 0.0018, "epss_percentile": 0.39884}, "CVE-2023-32799": {"epss_score": 0.00227, "epss_percentile": 0.45365}, "CVE-2023-32800": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-32801": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32802": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-32804": {"epss_score": 0.00146, "epss_percentile": 0.35625}, "CVE-2023-32805": {"epss_score": 0.0001, "epss_percentile": 0.00909}, "CVE-2023-32806": {"epss_score": 0.00015, "epss_percentile": 0.02198}, "CVE-2023-32807": {"epss_score": 0.00013, "epss_percentile": 0.01544}, "CVE-2023-32808": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2023-32809": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2023-32810": {"epss_score": 0.00023, "epss_percentile": 0.05638}, "CVE-2023-32811": {"epss_score": 0.00011, "epss_percentile": 0.01007}, "CVE-2023-32812": {"epss_score": 0.00023, "epss_percentile": 0.05441}, "CVE-2023-32813": {"epss_score": 0.0001, "epss_percentile": 0.00822}, "CVE-2023-32814": {"epss_score": 0.00013, "epss_percentile": 0.01544}, "CVE-2023-32815": {"epss_score": 0.00013, "epss_percentile": 0.01544}, "CVE-2023-32816": {"epss_score": 0.00013, "epss_percentile": 0.01544}, "CVE-2023-32817": {"epss_score": 0.00013, "epss_percentile": 0.01544}, "CVE-2023-32818": {"epss_score": 0.00024, "epss_percentile": 0.0579}, "CVE-2023-32819": {"epss_score": 0.00014, "epss_percentile": 0.01855}, "CVE-2023-32820": {"epss_score": 0.0044, "epss_percentile": 0.62616}, "CVE-2023-32821": {"epss_score": 4e-05, "epss_percentile": 0.00132}, "CVE-2023-32822": {"epss_score": 0.0002, "epss_percentile": 0.04508}, "CVE-2023-32823": {"epss_score": 0.0001, "epss_percentile": 0.00828}, "CVE-2023-32824": {"epss_score": 0.0001, "epss_percentile": 0.00909}, "CVE-2023-32825": {"epss_score": 0.00017, "epss_percentile": 0.03495}, "CVE-2023-32826": {"epss_score": 0.00011, "epss_percentile": 0.01068}, "CVE-2023-32827": {"epss_score": 0.00011, "epss_percentile": 0.01068}, "CVE-2023-32828": {"epss_score": 0.00032, "epss_percentile": 0.08999}, "CVE-2023-32829": {"epss_score": 0.00024, "epss_percentile": 0.05747}, "CVE-2023-32830": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-32831": {"epss_score": 0.0004, "epss_percentile": 0.1203}, "CVE-2023-32832": {"epss_score": 0.00032, "epss_percentile": 0.08866}, "CVE-2023-32834": {"epss_score": 0.00012, "epss_percentile": 0.01292}, "CVE-2023-32835": {"epss_score": 0.00018, "epss_percentile": 0.03959}, "CVE-2023-32836": {"epss_score": 0.0001, "epss_percentile": 0.00847}, "CVE-2023-32837": {"epss_score": 0.00038, "epss_percentile": 0.11349}, "CVE-2023-32838": {"epss_score": 0.0002, "epss_percentile": 0.04508}, "CVE-2023-32839": {"epss_score": 0.00022, "epss_percentile": 0.05182}, "CVE-2023-32840": {"epss_score": 0.0003, "epss_percentile": 0.08277}, "CVE-2023-32841": {"epss_score": 0.01804, "epss_percentile": 0.82344}, "CVE-2023-32842": {"epss_score": 0.05395, "epss_percentile": 0.89827}, "CVE-2023-32843": {"epss_score": 0.00588, "epss_percentile": 0.68488}, "CVE-2023-32844": {"epss_score": 0.05395, "epss_percentile": 0.89827}, "CVE-2023-32845": {"epss_score": 0.03266, "epss_percentile": 0.86784}, "CVE-2023-32846": {"epss_score": 0.05395, "epss_percentile": 0.89827}, "CVE-2023-32847": {"epss_score": 0.00054, "epss_percentile": 0.17228}, "CVE-2023-32848": {"epss_score": 0.00018, "epss_percentile": 0.04006}, "CVE-2023-32849": {"epss_score": 0.00026, "epss_percentile": 0.06421}, "CVE-2023-32850": {"epss_score": 0.00054, "epss_percentile": 0.17228}, "CVE-2023-32851": {"epss_score": 0.00063, "epss_percentile": 0.19882}, "CVE-2023-32852": {"epss_score": 0.00025, "epss_percentile": 0.06257}, "CVE-2023-32853": {"epss_score": 0.00033, "epss_percentile": 0.09429}, "CVE-2023-32854": {"epss_score": 0.00033, "epss_percentile": 0.09429}, "CVE-2023-32855": {"epss_score": 0.00029, "epss_percentile": 0.0766}, "CVE-2023-32856": {"epss_score": 0.00041, "epss_percentile": 0.12437}, "CVE-2023-32857": {"epss_score": 0.00041, "epss_percentile": 0.12437}, "CVE-2023-32858": {"epss_score": 0.00025, "epss_percentile": 0.06258}, "CVE-2023-32859": {"epss_score": 0.00037, "epss_percentile": 0.10818}, "CVE-2023-32860": {"epss_score": 0.00039, "epss_percentile": 0.11549}, "CVE-2023-32861": {"epss_score": 0.00044, "epss_percentile": 0.13431}, "CVE-2023-32862": {"epss_score": 0.00035, "epss_percentile": 0.09996}, "CVE-2023-32863": {"epss_score": 0.00042, "epss_percentile": 0.12774}, "CVE-2023-32864": {"epss_score": 0.00033, "epss_percentile": 0.09429}, "CVE-2023-32865": {"epss_score": 0.00027, "epss_percentile": 0.06849}, "CVE-2023-32866": {"epss_score": 0.00033, "epss_percentile": 0.09429}, "CVE-2023-32867": {"epss_score": 0.00027, "epss_percentile": 0.06849}, "CVE-2023-32868": {"epss_score": 0.00033, "epss_percentile": 0.09429}, "CVE-2023-32869": {"epss_score": 0.00033, "epss_percentile": 0.09429}, "CVE-2023-32870": {"epss_score": 0.00044, "epss_percentile": 0.13431}, "CVE-2023-32871": {"epss_score": 4e-05, "epss_percentile": 0.00134}, "CVE-2023-32872": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-32873": {"epss_score": 0.0002, "epss_percentile": 0.04667}, "CVE-2023-32874": {"epss_score": 0.03195, "epss_percentile": 0.86609}, "CVE-2023-32875": {"epss_score": 0.00014, "epss_percentile": 0.01855}, "CVE-2023-32876": {"epss_score": 0.00014, "epss_percentile": 0.01855}, "CVE-2023-32877": {"epss_score": 0.0001, "epss_percentile": 0.00909}, "CVE-2023-32878": {"epss_score": 8e-05, "epss_percentile": 0.00552}, "CVE-2023-32879": {"epss_score": 0.0001, "epss_percentile": 0.00909}, "CVE-2023-32880": {"epss_score": 0.00011, "epss_percentile": 0.01}, "CVE-2023-32881": {"epss_score": 0.00011, "epss_percentile": 0.00932}, "CVE-2023-32882": {"epss_score": 8e-05, "epss_percentile": 0.00474}, "CVE-2023-32883": {"epss_score": 0.00021, "epss_percentile": 0.04735}, "CVE-2023-32884": {"epss_score": 0.00021, "epss_percentile": 0.04735}, "CVE-2023-32885": {"epss_score": 0.00021, "epss_percentile": 0.04735}, "CVE-2023-32886": {"epss_score": 0.01298, "epss_percentile": 0.79272}, "CVE-2023-32887": {"epss_score": 0.01761, "epss_percentile": 0.82151}, "CVE-2023-32888": {"epss_score": 0.02368, "epss_percentile": 0.84518}, "CVE-2023-32889": {"epss_score": 0.00933, "epss_percentile": 0.75641}, "CVE-2023-32890": {"epss_score": 0.00395, "epss_percentile": 0.59837}, "CVE-2023-32891": {"epss_score": 0.00015, "epss_percentile": 0.02531}, "CVE-2023-32955": {"epss_score": 0.0027, "epss_percentile": 0.50255}, "CVE-2023-32956": {"epss_score": 0.0353, "epss_percentile": 0.87302}, "CVE-2023-32957": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-32958": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-32960": {"epss_score": 0.00061, "epss_percentile": 0.19251}, "CVE-2023-32961": {"epss_score": 0.0495, "epss_percentile": 0.89323}, "CVE-2023-32962": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-32963": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-32964": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-32965": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-32966": {"epss_score": 0.00172, "epss_percentile": 0.38958}, "CVE-2023-32967": {"epss_score": 0.00035, "epss_percentile": 0.10047}, "CVE-2023-32968": {"epss_score": 0.00062, "epss_percentile": 0.19599}, "CVE-2023-32969": {"epss_score": 0.00091, "epss_percentile": 0.26228}, "CVE-2023-32970": {"epss_score": 0.00099, "epss_percentile": 0.28385}, "CVE-2023-32971": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-32972": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-32973": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-32974": {"epss_score": 0.00171, "epss_percentile": 0.389}, "CVE-2023-32975": {"epss_score": 0.00068, "epss_percentile": 0.21212}, "CVE-2023-32976": {"epss_score": 0.0011, "epss_percentile": 0.30203}, "CVE-2023-32977": {"epss_score": 0.02963, "epss_percentile": 0.86075}, "CVE-2023-32978": {"epss_score": 0.001, "epss_percentile": 0.28484}, "CVE-2023-32979": {"epss_score": 0.00098, "epss_percentile": 0.27719}, "CVE-2023-32980": {"epss_score": 0.00135, "epss_percentile": 0.33966}, "CVE-2023-32981": {"epss_score": 0.00784, "epss_percentile": 0.73244}, "CVE-2023-32982": {"epss_score": 0.00081, "epss_percentile": 0.24231}, "CVE-2023-32983": {"epss_score": 0.00081, "epss_percentile": 0.24231}, "CVE-2023-32984": {"epss_score": 0.02557, "epss_percentile": 0.85095}, "CVE-2023-32985": {"epss_score": 0.14914, "epss_percentile": 0.94321}, "CVE-2023-32986": {"epss_score": 0.05323, "epss_percentile": 0.8973}, "CVE-2023-32987": {"epss_score": 0.00215, "epss_percentile": 0.44039}, "CVE-2023-32988": {"epss_score": 0.00176, "epss_percentile": 0.39465}, "CVE-2023-32989": {"epss_score": 0.00215, "epss_percentile": 0.44039}, "CVE-2023-32990": {"epss_score": 0.00124, "epss_percentile": 0.32351}, "CVE-2023-32991": {"epss_score": 0.00192, "epss_percentile": 0.41281}, "CVE-2023-32992": {"epss_score": 0.00529, "epss_percentile": 0.66591}, "CVE-2023-32993": {"epss_score": 0.0014, "epss_percentile": 0.34702}, "CVE-2023-32994": {"epss_score": 0.00127, "epss_percentile": 0.3281}, "CVE-2023-32995": {"epss_score": 0.00215, "epss_percentile": 0.44039}, "CVE-2023-32996": {"epss_score": 0.00124, "epss_percentile": 0.32351}, "CVE-2023-32997": {"epss_score": 0.00189, "epss_percentile": 0.40998}, "CVE-2023-32998": {"epss_score": 0.00357, "epss_percentile": 0.57436}, "CVE-2023-32999": {"epss_score": 0.00137, "epss_percentile": 0.34213}, "CVE-2023-33000": {"epss_score": 0.00176, "epss_percentile": 0.3944}, "CVE-2023-33001": {"epss_score": 0.00245, "epss_percentile": 0.47648}, "CVE-2023-33002": {"epss_score": 0.05647, "epss_percentile": 0.90082}, "CVE-2023-33003": {"epss_score": 0.001, "epss_percentile": 0.28484}, "CVE-2023-33004": {"epss_score": 0.00114, "epss_percentile": 0.30748}, "CVE-2023-33005": {"epss_score": 0.00188, "epss_percentile": 0.40917}, "CVE-2023-33006": {"epss_score": 0.00195, "epss_percentile": 0.41711}, "CVE-2023-33007": {"epss_score": 0.02557, "epss_percentile": 0.85095}, "CVE-2023-33008": {"epss_score": 0.00137, "epss_percentile": 0.34264}, "CVE-2023-33009": {"epss_score": 0.06166, "epss_percentile": 0.90528}, "CVE-2023-33010": {"epss_score": 0.05845, "epss_percentile": 0.90255}, "CVE-2023-33011": {"epss_score": 0.00116, "epss_percentile": 0.31101}, "CVE-2023-33012": {"epss_score": 0.07723, "epss_percentile": 0.91645}, "CVE-2023-33013": {"epss_score": 0.01274, "epss_percentile": 0.7909}, "CVE-2023-33014": {"epss_score": 0.00077, "epss_percentile": 0.23524}, "CVE-2023-33015": {"epss_score": 0.00071, "epss_percentile": 0.2214}, "CVE-2023-33016": {"epss_score": 0.00091, "epss_percentile": 0.26287}, "CVE-2023-33017": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-33018": {"epss_score": 0.00062, "epss_percentile": 0.19568}, "CVE-2023-33019": {"epss_score": 0.00063, "epss_percentile": 0.20101}, "CVE-2023-33020": {"epss_score": 0.00061, "epss_percentile": 0.19543}, "CVE-2023-33021": {"epss_score": 0.00029, "epss_percentile": 0.07843}, "CVE-2023-33022": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-33023": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2023-33024": {"epss_score": 0.0004, "epss_percentile": 0.12192}, "CVE-2023-33025": {"epss_score": 0.00209, "epss_percentile": 0.43381}, "CVE-2023-33026": {"epss_score": 0.00194, "epss_percentile": 0.41596}, "CVE-2023-33027": {"epss_score": 0.00194, "epss_percentile": 0.41596}, "CVE-2023-33028": {"epss_score": 0.00103, "epss_percentile": 0.29088}, "CVE-2023-33029": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2023-33030": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-33031": {"epss_score": 0.00062, "epss_percentile": 0.19568}, "CVE-2023-33032": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-33033": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-33034": {"epss_score": 0.00059, "epss_percentile": 0.18813}, "CVE-2023-33035": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2023-33036": {"epss_score": 0.00049, "epss_percentile": 0.15617}, "CVE-2023-33037": {"epss_score": 0.00033, "epss_percentile": 0.09177}, "CVE-2023-33038": {"epss_score": 0.00042, "epss_percentile": 0.12929}, "CVE-2023-33039": {"epss_score": 0.0003, "epss_percentile": 0.08175}, "CVE-2023-33040": {"epss_score": 0.00147, "epss_percentile": 0.35683}, "CVE-2023-33041": {"epss_score": 0.00148, "epss_percentile": 0.35893}, "CVE-2023-33042": {"epss_score": 0.00244, "epss_percentile": 0.47583}, "CVE-2023-33043": {"epss_score": 0.00244, "epss_percentile": 0.47583}, "CVE-2023-33044": {"epss_score": 0.00244, "epss_percentile": 0.47583}, "CVE-2023-33045": {"epss_score": 0.0021, "epss_percentile": 0.4359}, "CVE-2023-33046": {"epss_score": 0.00018, "epss_percentile": 0.03718}, "CVE-2023-33047": {"epss_score": 0.00188, "epss_percentile": 0.409}, "CVE-2023-33048": {"epss_score": 0.00194, "epss_percentile": 0.41596}, "CVE-2023-33049": {"epss_score": 0.00092, "epss_percentile": 0.26591}, "CVE-2023-33053": {"epss_score": 0.00128, "epss_percentile": 0.32968}, "CVE-2023-33054": {"epss_score": 0.0013, "epss_percentile": 0.33273}, "CVE-2023-33055": {"epss_score": 0.00062, "epss_percentile": 0.19568}, "CVE-2023-33056": {"epss_score": 0.00173, "epss_percentile": 0.39059}, "CVE-2023-33057": {"epss_score": 0.00096, "epss_percentile": 0.27407}, "CVE-2023-33058": {"epss_score": 0.00082, "epss_percentile": 0.24464}, "CVE-2023-33059": {"epss_score": 0.00062, "epss_percentile": 0.19568}, "CVE-2023-33060": {"epss_score": 0.00031, "epss_percentile": 0.08501}, "CVE-2023-33061": {"epss_score": 0.00188, "epss_percentile": 0.409}, "CVE-2023-33062": {"epss_score": 0.00188, "epss_percentile": 0.409}, "CVE-2023-33063": {"epss_score": 0.0044, "epss_percentile": 0.62643}, "CVE-2023-33064": {"epss_score": 0.00024, "epss_percentile": 0.05799}, "CVE-2023-33065": {"epss_score": 0.00027, "epss_percentile": 0.07154}, "CVE-2023-33066": {"epss_score": 0.0007, "epss_percentile": 0.21686}, "CVE-2023-33067": {"epss_score": 0.0002, "epss_percentile": 0.04626}, "CVE-2023-33068": {"epss_score": 0.0002, "epss_percentile": 0.04503}, "CVE-2023-33069": {"epss_score": 0.0002, "epss_percentile": 0.04626}, "CVE-2023-33070": {"epss_score": 0.00054, "epss_percentile": 0.17141}, "CVE-2023-33071": {"epss_score": 0.00065, "epss_percentile": 0.20612}, "CVE-2023-33072": {"epss_score": 0.00029, "epss_percentile": 0.07843}, "CVE-2023-33074": {"epss_score": 0.0003, "epss_percentile": 0.08175}, "CVE-2023-33076": {"epss_score": 0.00031, "epss_percentile": 0.08652}, "CVE-2023-33077": {"epss_score": 0.0002, "epss_percentile": 0.04626}, "CVE-2023-33078": {"epss_score": 0.0003, "epss_percentile": 0.08187}, "CVE-2023-33079": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-33080": {"epss_score": 0.00194, "epss_percentile": 0.41596}, "CVE-2023-33081": {"epss_score": 0.00147, "epss_percentile": 0.35683}, "CVE-2023-33082": {"epss_score": 0.00195, "epss_percentile": 0.41657}, "CVE-2023-33083": {"epss_score": 0.002, "epss_percentile": 0.4225}, "CVE-2023-33084": {"epss_score": 0.00143, "epss_percentile": 0.35145}, "CVE-2023-33085": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-33086": {"epss_score": 0.00143, "epss_percentile": 0.35145}, "CVE-2023-33087": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-33088": {"epss_score": 0.00068, "epss_percentile": 0.21396}, "CVE-2023-33089": {"epss_score": 0.00222, "epss_percentile": 0.44715}, "CVE-2023-33090": {"epss_score": 0.00061, "epss_percentile": 0.19277}, "CVE-2023-33092": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-33094": {"epss_score": 0.00078, "epss_percentile": 0.23771}, "CVE-2023-33095": {"epss_score": 0.00144, "epss_percentile": 0.35295}, "CVE-2023-33096": {"epss_score": 0.00144, "epss_percentile": 0.35295}, "CVE-2023-33097": {"epss_score": 0.00147, "epss_percentile": 0.35683}, "CVE-2023-33098": {"epss_score": 0.00188, "epss_percentile": 0.409}, "CVE-2023-33099": {"epss_score": 0.00124, "epss_percentile": 0.32457}, "CVE-2023-33100": {"epss_score": 0.00124, "epss_percentile": 0.32457}, "CVE-2023-33101": {"epss_score": 0.00107, "epss_percentile": 0.29678}, "CVE-2023-33103": {"epss_score": 0.00144, "epss_percentile": 0.35295}, "CVE-2023-33104": {"epss_score": 0.00144, "epss_percentile": 0.35295}, "CVE-2023-33105": {"epss_score": 0.02377, "epss_percentile": 0.84553}, "CVE-2023-33106": {"epss_score": 0.0016, "epss_percentile": 0.37499}, "CVE-2023-33107": {"epss_score": 0.00246, "epss_percentile": 0.47755}, "CVE-2023-33108": {"epss_score": 0.0006, "epss_percentile": 0.19089}, "CVE-2023-33109": {"epss_score": 0.00173, "epss_percentile": 0.39059}, "CVE-2023-33110": {"epss_score": 0.00085, "epss_percentile": 0.2518}, "CVE-2023-33111": {"epss_score": 0.00047, "epss_percentile": 0.14701}, "CVE-2023-33112": {"epss_score": 0.00229, "epss_percentile": 0.45647}, "CVE-2023-33113": {"epss_score": 0.0011, "epss_percentile": 0.30193}, "CVE-2023-33114": {"epss_score": 0.00112, "epss_percentile": 0.30499}, "CVE-2023-33115": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2023-33116": {"epss_score": 0.00322, "epss_percentile": 0.54825}, "CVE-2023-33117": {"epss_score": 0.0011, "epss_percentile": 0.30193}, "CVE-2023-33118": {"epss_score": 0.0011, "epss_percentile": 0.30193}, "CVE-2023-33119": {"epss_score": 0.00048, "epss_percentile": 0.14983}, "CVE-2023-33120": {"epss_score": 0.00136, "epss_percentile": 0.34166}, "CVE-2023-33121": {"epss_score": 0.0004, "epss_percentile": 0.11965}, "CVE-2023-33122": {"epss_score": 0.00089, "epss_percentile": 0.25919}, "CVE-2023-33123": {"epss_score": 0.00089, "epss_percentile": 0.25952}, "CVE-2023-33124": {"epss_score": 0.00066, "epss_percentile": 0.20678}, "CVE-2023-33126": {"epss_score": 0.01521, "epss_percentile": 0.80832}, "CVE-2023-33127": {"epss_score": 0.02081, "epss_percentile": 0.83535}, "CVE-2023-33128": {"epss_score": 0.0174, "epss_percentile": 0.82042}, "CVE-2023-33129": {"epss_score": 0.03642, "epss_percentile": 0.87494}, "CVE-2023-33130": {"epss_score": 0.00408, "epss_percentile": 0.60656}, "CVE-2023-33131": {"epss_score": 0.02618, "epss_percentile": 0.85252}, "CVE-2023-33132": {"epss_score": 0.00281, "epss_percentile": 0.51199}, "CVE-2023-33133": {"epss_score": 0.35863, "epss_percentile": 0.96938}, "CVE-2023-33134": {"epss_score": 0.00511, "epss_percentile": 0.65842}, "CVE-2023-33135": {"epss_score": 0.01372, "epss_percentile": 0.79813}, "CVE-2023-33136": {"epss_score": 0.00662, "epss_percentile": 0.70602}, "CVE-2023-33137": {"epss_score": 0.02565, "epss_percentile": 0.85115}, "CVE-2023-33139": {"epss_score": 0.01135, "epss_percentile": 0.77907}, "CVE-2023-33140": {"epss_score": 0.04964, "epss_percentile": 0.89339}, "CVE-2023-33141": {"epss_score": 0.03268, "epss_percentile": 0.86786}, "CVE-2023-33142": {"epss_score": 0.01717, "epss_percentile": 0.81908}, "CVE-2023-33143": {"epss_score": 0.0015, "epss_percentile": 0.36178}, "CVE-2023-33144": {"epss_score": 0.00641, "epss_percentile": 0.69984}, "CVE-2023-33145": {"epss_score": 0.07104, "epss_percentile": 0.91254}, "CVE-2023-33146": {"epss_score": 0.01131, "epss_percentile": 0.77859}, "CVE-2023-33148": {"epss_score": 0.0127, "epss_percentile": 0.79047}, "CVE-2023-33149": {"epss_score": 0.00766, "epss_percentile": 0.72938}, "CVE-2023-33150": {"epss_score": 0.0019, "epss_percentile": 0.41051}, "CVE-2023-33151": {"epss_score": 0.00543, "epss_percentile": 0.67101}, "CVE-2023-33152": {"epss_score": 0.00957, "epss_percentile": 0.75931}, "CVE-2023-33153": {"epss_score": 0.00421, "epss_percentile": 0.61496}, "CVE-2023-33154": {"epss_score": 0.01128, "epss_percentile": 0.77829}, "CVE-2023-33155": {"epss_score": 0.00146, "epss_percentile": 0.35534}, "CVE-2023-33156": {"epss_score": 0.00077, "epss_percentile": 0.23322}, "CVE-2023-33157": {"epss_score": 0.07314, "epss_percentile": 0.91403}, "CVE-2023-33158": {"epss_score": 0.00374, "epss_percentile": 0.58566}, "CVE-2023-33159": {"epss_score": 0.00228, "epss_percentile": 0.45522}, "CVE-2023-33160": {"epss_score": 0.06303, "epss_percentile": 0.90658}, "CVE-2023-33161": {"epss_score": 0.00766, "epss_percentile": 0.72938}, "CVE-2023-33162": {"epss_score": 0.00768, "epss_percentile": 0.72978}, "CVE-2023-33163": {"epss_score": 0.00143, "epss_percentile": 0.35187}, "CVE-2023-33164": {"epss_score": 0.03672, "epss_percentile": 0.87545}, "CVE-2023-33165": {"epss_score": 0.01371, "epss_percentile": 0.7981}, "CVE-2023-33166": {"epss_score": 0.03672, "epss_percentile": 0.87545}, "CVE-2023-33167": {"epss_score": 0.03672, "epss_percentile": 0.87545}, "CVE-2023-33168": {"epss_score": 0.03672, "epss_percentile": 0.87545}, "CVE-2023-33169": {"epss_score": 0.03672, "epss_percentile": 0.87545}, "CVE-2023-33170": {"epss_score": 0.00215, "epss_percentile": 0.44041}, "CVE-2023-33171": {"epss_score": 0.00253, "epss_percentile": 0.48463}, "CVE-2023-33172": {"epss_score": 0.03672, "epss_percentile": 0.87545}, "CVE-2023-33173": {"epss_score": 0.03672, "epss_percentile": 0.87545}, "CVE-2023-33174": {"epss_score": 0.00282, "epss_percentile": 0.51264}, "CVE-2023-33175": {"epss_score": 0.00472, "epss_percentile": 0.6403}, "CVE-2023-33176": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2023-33177": {"epss_score": 0.03421, "epss_percentile": 0.87102}, "CVE-2023-33178": {"epss_score": 0.00195, "epss_percentile": 0.41627}, "CVE-2023-33179": {"epss_score": 0.00283, "epss_percentile": 0.51377}, "CVE-2023-33180": {"epss_score": 0.00283, "epss_percentile": 0.51377}, "CVE-2023-33181": {"epss_score": 0.0024, "epss_percentile": 0.47227}, "CVE-2023-33182": {"epss_score": 0.00154, "epss_percentile": 0.36684}, "CVE-2023-33183": {"epss_score": 0.00184, "epss_percentile": 0.40406}, "CVE-2023-33184": {"epss_score": 0.00125, "epss_percentile": 0.32508}, "CVE-2023-33185": {"epss_score": 0.00055, "epss_percentile": 0.17531}, "CVE-2023-33186": {"epss_score": 0.00254, "epss_percentile": 0.48562}, "CVE-2023-33187": {"epss_score": 0.0006, "epss_percentile": 0.19184}, "CVE-2023-33188": {"epss_score": 0.00041, "epss_percentile": 0.12238}, "CVE-2023-33189": {"epss_score": 0.00196, "epss_percentile": 0.4181}, "CVE-2023-33190": {"epss_score": 0.00166, "epss_percentile": 0.38192}, "CVE-2023-33191": {"epss_score": 0.00125, "epss_percentile": 0.32467}, "CVE-2023-33192": {"epss_score": 0.00197, "epss_percentile": 0.41837}, "CVE-2023-33193": {"epss_score": 0.43629, "epss_percentile": 0.97396}, "CVE-2023-33194": {"epss_score": 0.00049, "epss_percentile": 0.15492}, "CVE-2023-33195": {"epss_score": 0.0055, "epss_percentile": 0.67344}, "CVE-2023-33196": {"epss_score": 0.00075, "epss_percentile": 0.23048}, "CVE-2023-33197": {"epss_score": 0.00298, "epss_percentile": 0.52828}, "CVE-2023-33198": {"epss_score": 0.00157, "epss_percentile": 0.3714}, "CVE-2023-33199": {"epss_score": 0.00111, "epss_percentile": 0.30244}, "CVE-2023-33200": {"epss_score": 0.00066, "epss_percentile": 0.20771}, "CVE-2023-33201": {"epss_score": 0.00356, "epss_percentile": 0.5739}, "CVE-2023-33202": {"epss_score": 0.00159, "epss_percentile": 0.37403}, "CVE-2023-33203": {"epss_score": 0.00015, "epss_percentile": 0.02591}, "CVE-2023-33204": {"epss_score": 0.00031, "epss_percentile": 0.0853}, "CVE-2023-33206": {"epss_score": 0.00608, "epss_percentile": 0.69077}, "CVE-2023-33207": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-33208": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-33209": {"epss_score": 0.00131, "epss_percentile": 0.33428}, "CVE-2023-33210": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-33211": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-33212": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-33213": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-33214": {"epss_score": 0.00053, "epss_percentile": 0.16989}, "CVE-2023-33215": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-33216": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-33217": {"epss_score": 0.0012, "epss_percentile": 0.31753}, "CVE-2023-33218": {"epss_score": 0.01219, "epss_percentile": 0.78615}, "CVE-2023-33219": {"epss_score": 0.00901, "epss_percentile": 0.75167}, "CVE-2023-33220": {"epss_score": 0.00857, "epss_percentile": 0.74497}, "CVE-2023-33221": {"epss_score": 0.00545, "epss_percentile": 0.67161}, "CVE-2023-33222": {"epss_score": 0.03534, "epss_percentile": 0.87309}, "CVE-2023-33224": {"epss_score": 0.00126, "epss_percentile": 0.32639}, "CVE-2023-33225": {"epss_score": 0.00107, "epss_percentile": 0.2975}, "CVE-2023-33226": {"epss_score": 0.03552, "epss_percentile": 0.87343}, "CVE-2023-33227": {"epss_score": 0.03552, "epss_percentile": 0.87343}, "CVE-2023-33228": {"epss_score": 0.00043, "epss_percentile": 0.13311}, "CVE-2023-33229": {"epss_score": 0.00797, "epss_percentile": 0.7349}, "CVE-2023-33231": {"epss_score": 0.00492, "epss_percentile": 0.65009}, "CVE-2023-33234": {"epss_score": 0.00289, "epss_percentile": 0.52049}, "CVE-2023-33235": {"epss_score": 0.00637, "epss_percentile": 0.69896}, "CVE-2023-33236": {"epss_score": 0.0005, "epss_percentile": 0.15776}, "CVE-2023-33237": {"epss_score": 0.00224, "epss_percentile": 0.44997}, "CVE-2023-33238": {"epss_score": 0.00245, "epss_percentile": 0.4765}, "CVE-2023-33239": {"epss_score": 0.01044, "epss_percentile": 0.77002}, "CVE-2023-33240": {"epss_score": 0.00044, "epss_percentile": 0.13414}, "CVE-2023-33241": {"epss_score": 0.00207, "epss_percentile": 0.43091}, "CVE-2023-33242": {"epss_score": 0.03396, "epss_percentile": 0.8706}, "CVE-2023-33243": {"epss_score": 0.12314, "epss_percentile": 0.93635}, "CVE-2023-33244": {"epss_score": 0.00094, "epss_percentile": 0.26954}, "CVE-2023-33245": {"epss_score": 0.00532, "epss_percentile": 0.66672}, "CVE-2023-33246": {"epss_score": 0.94388, "epss_percentile": 0.99968}, "CVE-2023-33247": {"epss_score": 0.00121, "epss_percentile": 0.31839}, "CVE-2023-33248": {"epss_score": 0.00558, "epss_percentile": 0.67572}, "CVE-2023-33250": {"epss_score": 0.00023, "epss_percentile": 0.05422}, "CVE-2023-33251": {"epss_score": 0.00036, "epss_percentile": 0.10213}, "CVE-2023-33252": {"epss_score": 0.00092, "epss_percentile": 0.26523}, "CVE-2023-33253": {"epss_score": 0.40986, "epss_percentile": 0.97248}, "CVE-2023-33254": {"epss_score": 0.00078, "epss_percentile": 0.23765}, "CVE-2023-33255": {"epss_score": 0.01312, "epss_percentile": 0.79375}, "CVE-2023-33257": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-33263": {"epss_score": 0.00302, "epss_percentile": 0.53085}, "CVE-2023-33264": {"epss_score": 0.0161, "epss_percentile": 0.8132}, "CVE-2023-33265": {"epss_score": 0.00172, "epss_percentile": 0.38975}, "CVE-2023-33268": {"epss_score": 0.01068, "epss_percentile": 0.77241}, "CVE-2023-33269": {"epss_score": 0.0124, "epss_percentile": 0.78805}, "CVE-2023-33270": {"epss_score": 0.01141, "epss_percentile": 0.77967}, "CVE-2023-33271": {"epss_score": 0.00983, "epss_percentile": 0.763}, "CVE-2023-33272": {"epss_score": 0.01141, "epss_percentile": 0.77967}, "CVE-2023-33273": {"epss_score": 0.01141, "epss_percentile": 0.77967}, "CVE-2023-33274": {"epss_score": 0.00255, "epss_percentile": 0.48689}, "CVE-2023-33276": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-33277": {"epss_score": 0.00091, "epss_percentile": 0.26407}, "CVE-2023-33278": {"epss_score": 0.00272, "epss_percentile": 0.50392}, "CVE-2023-33279": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-33280": {"epss_score": 0.00272, "epss_percentile": 0.50392}, "CVE-2023-33281": {"epss_score": 0.00031, "epss_percentile": 0.08336}, "CVE-2023-33282": {"epss_score": 0.0009, "epss_percentile": 0.25989}, "CVE-2023-33283": {"epss_score": 0.00013, "epss_percentile": 0.016}, "CVE-2023-33284": {"epss_score": 0.01087, "epss_percentile": 0.7743}, "CVE-2023-33285": {"epss_score": 0.00092, "epss_percentile": 0.26591}, "CVE-2023-33287": {"epss_score": 0.00098, "epss_percentile": 0.27697}, "CVE-2023-33288": {"epss_score": 8e-05, "epss_percentile": 0.00568}, "CVE-2023-33289": {"epss_score": 0.00352, "epss_percentile": 0.5712}, "CVE-2023-33290": {"epss_score": 0.00064, "epss_percentile": 0.20183}, "CVE-2023-33291": {"epss_score": 0.00063, "epss_percentile": 0.20085}, "CVE-2023-33293": {"epss_score": 0.00162, "epss_percentile": 0.37664}, "CVE-2023-33294": {"epss_score": 0.00324, "epss_percentile": 0.54935}, "CVE-2023-33295": {"epss_score": 0.00534, "epss_percentile": 0.66786}, "CVE-2023-33297": {"epss_score": 0.00294, "epss_percentile": 0.52433}, "CVE-2023-33298": {"epss_score": 0.00229, "epss_percentile": 0.4564}, "CVE-2023-33299": {"epss_score": 0.09988, "epss_percentile": 0.92806}, "CVE-2023-33300": {"epss_score": 0.03932, "epss_percentile": 0.87977}, "CVE-2023-33301": {"epss_score": 0.00131, "epss_percentile": 0.33382}, "CVE-2023-33302": {"epss_score": 0.00135, "epss_percentile": 0.33994}, "CVE-2023-33303": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2023-33304": {"epss_score": 4e-05, "epss_percentile": 0.00127}, "CVE-2023-33305": {"epss_score": 0.00142, "epss_percentile": 0.35081}, "CVE-2023-33306": {"epss_score": 0.00201, "epss_percentile": 0.42357}, "CVE-2023-33307": {"epss_score": 0.00071, "epss_percentile": 0.22172}, "CVE-2023-33308": {"epss_score": 0.0593, "epss_percentile": 0.90335}, "CVE-2023-33309": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-33310": {"epss_score": 0.00393, "epss_percentile": 0.59717}, "CVE-2023-33311": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-33312": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-33313": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-33314": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-33315": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-33316": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-33317": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-33318": {"epss_score": 0.00314, "epss_percentile": 0.54089}, "CVE-2023-33319": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-33320": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-33321": {"epss_score": 0.0028, "epss_percentile": 0.51099}, "CVE-2023-33322": {"epss_score": 0.00141, "epss_percentile": 0.34849}, "CVE-2023-33323": {"epss_score": 0.00066, "epss_percentile": 0.20954}, "CVE-2023-33324": {"epss_score": 0.00128, "epss_percentile": 0.3305}, "CVE-2023-33325": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-33326": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-33327": {"epss_score": 0.00348, "epss_percentile": 0.56814}, "CVE-2023-33328": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-33329": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-33330": {"epss_score": 0.00131, "epss_percentile": 0.33428}, "CVE-2023-33331": {"epss_score": 0.00144, "epss_percentile": 0.35247}, "CVE-2023-33332": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-33333": {"epss_score": 0.00184, "epss_percentile": 0.40397}, "CVE-2023-33335": {"epss_score": 0.00056, "epss_percentile": 0.17848}, "CVE-2023-33336": {"epss_score": 0.00036, "epss_percentile": 0.10364}, "CVE-2023-33338": {"epss_score": 0.66882, "epss_percentile": 0.98485}, "CVE-2023-33355": {"epss_score": 0.00074, "epss_percentile": 0.22725}, "CVE-2023-33356": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-33359": {"epss_score": 0.00151, "epss_percentile": 0.36337}, "CVE-2023-33361": {"epss_score": 0.00374, "epss_percentile": 0.58561}, "CVE-2023-33362": {"epss_score": 0.01165, "epss_percentile": 0.78177}, "CVE-2023-33363": {"epss_score": 0.00084, "epss_percentile": 0.24913}, "CVE-2023-33364": {"epss_score": 0.02413, "epss_percentile": 0.84673}, "CVE-2023-33365": {"epss_score": 0.00308, "epss_percentile": 0.53607}, "CVE-2023-33366": {"epss_score": 0.00049, "epss_percentile": 0.15317}, "CVE-2023-33367": {"epss_score": 0.01075, "epss_percentile": 0.77304}, "CVE-2023-33368": {"epss_score": 0.00158, "epss_percentile": 0.37291}, "CVE-2023-33369": {"epss_score": 0.00593, "epss_percentile": 0.68635}, "CVE-2023-33370": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-33371": {"epss_score": 0.00063, "epss_percentile": 0.19877}, "CVE-2023-33372": {"epss_score": 0.00021, "epss_percentile": 0.04716}, "CVE-2023-33373": {"epss_score": 0.00039, "epss_percentile": 0.11586}, "CVE-2023-33374": {"epss_score": 0.01265, "epss_percentile": 0.79007}, "CVE-2023-33375": {"epss_score": 0.00075, "epss_percentile": 0.23021}, "CVE-2023-33376": {"epss_score": 0.00088, "epss_percentile": 0.25667}, "CVE-2023-33377": {"epss_score": 0.00394, "epss_percentile": 0.59779}, "CVE-2023-33378": {"epss_score": 0.00088, "epss_percentile": 0.25667}, "CVE-2023-33379": {"epss_score": 0.00083, "epss_percentile": 0.24738}, "CVE-2023-33381": {"epss_score": 0.58012, "epss_percentile": 0.98095}, "CVE-2023-33383": {"epss_score": 0.00516, "epss_percentile": 0.66049}, "CVE-2023-33386": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-33387": {"epss_score": 0.00506, "epss_percentile": 0.65613}, "CVE-2023-33394": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-33404": {"epss_score": 0.81438, "epss_percentile": 0.99137}, "CVE-2023-33405": {"epss_score": 0.57674, "epss_percentile": 0.98078}, "CVE-2023-33408": {"epss_score": 0.00214, "epss_percentile": 0.43953}, "CVE-2023-33409": {"epss_score": 0.00121, "epss_percentile": 0.31829}, "CVE-2023-33410": {"epss_score": 0.00647, "epss_percentile": 0.70182}, "CVE-2023-33411": {"epss_score": 0.01331, "epss_percentile": 0.79514}, "CVE-2023-33412": {"epss_score": 0.01426, "epss_percentile": 0.80204}, "CVE-2023-33413": {"epss_score": 0.01837, "epss_percentile": 0.82482}, "CVE-2023-33438": {"epss_score": 0.00053, "epss_percentile": 0.16679}, "CVE-2023-33439": {"epss_score": 0.33989, "epss_percentile": 0.96819}, "CVE-2023-33440": {"epss_score": 0.84935, "epss_percentile": 0.99311}, "CVE-2023-33443": {"epss_score": 0.00078, "epss_percentile": 0.23659}, "CVE-2023-33457": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-33460": {"epss_score": 0.0011, "epss_percentile": 0.3016}, "CVE-2023-33461": {"epss_score": 0.00054, "epss_percentile": 0.17348}, "CVE-2023-33466": {"epss_score": 0.2101, "epss_percentile": 0.95451}, "CVE-2023-33468": {"epss_score": 0.00035, "epss_percentile": 0.09995}, "CVE-2023-33469": {"epss_score": 0.00061, "epss_percentile": 0.19308}, "CVE-2023-33472": {"epss_score": 0.01642, "epss_percentile": 0.81512}, "CVE-2023-33476": {"epss_score": 0.00643, "epss_percentile": 0.70048}, "CVE-2023-33477": {"epss_score": 0.00743, "epss_percentile": 0.72499}, "CVE-2023-33478": {"epss_score": 0.00352, "epss_percentile": 0.57099}, "CVE-2023-33479": {"epss_score": 0.00352, "epss_percentile": 0.57099}, "CVE-2023-33480": {"epss_score": 0.05116, "epss_percentile": 0.89513}, "CVE-2023-33481": {"epss_score": 0.00352, "epss_percentile": 0.57099}, "CVE-2023-33485": {"epss_score": 0.00342, "epss_percentile": 0.56402}, "CVE-2023-33486": {"epss_score": 0.00752, "epss_percentile": 0.72658}, "CVE-2023-33487": {"epss_score": 0.00752, "epss_percentile": 0.72658}, "CVE-2023-33492": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-33493": {"epss_score": 0.00778, "epss_percentile": 0.73129}, "CVE-2023-33495": {"epss_score": 0.00181, "epss_percentile": 0.40083}, "CVE-2023-33496": {"epss_score": 0.00103, "epss_percentile": 0.29064}, "CVE-2023-33498": {"epss_score": 0.00107, "epss_percentile": 0.29639}, "CVE-2023-33507": {"epss_score": 0.00168, "epss_percentile": 0.38462}, "CVE-2023-33508": {"epss_score": 0.02042, "epss_percentile": 0.83373}, "CVE-2023-33509": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2023-33510": {"epss_score": 0.69616, "epss_percentile": 0.98594}, "CVE-2023-33515": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-33517": {"epss_score": 0.00217, "epss_percentile": 0.44328}, "CVE-2023-33518": {"epss_score": 0.00058, "epss_percentile": 0.18284}, "CVE-2023-33524": {"epss_score": 0.00213, "epss_percentile": 0.43878}, "CVE-2023-33528": {"epss_score": 0.00197, "epss_percentile": 0.41934}, "CVE-2023-33530": {"epss_score": 0.01043, "epss_percentile": 0.76993}, "CVE-2023-33532": {"epss_score": 0.30261, "epss_percentile": 0.96523}, "CVE-2023-33533": {"epss_score": 0.05318, "epss_percentile": 0.89726}, "CVE-2023-33534": {"epss_score": 0.00105, "epss_percentile": 0.29392}, "CVE-2023-33536": {"epss_score": 0.00125, "epss_percentile": 0.32574}, "CVE-2023-33537": {"epss_score": 0.00125, "epss_percentile": 0.32574}, "CVE-2023-33538": {"epss_score": 0.9132, "epss_percentile": 0.99633}, "CVE-2023-33544": {"epss_score": 0.00051, "epss_percentile": 0.16243}, "CVE-2023-33546": {"epss_score": 0.00031, "epss_percentile": 0.08713}, "CVE-2023-33548": {"epss_score": 0.00163, "epss_percentile": 0.37823}, "CVE-2023-33551": {"epss_score": 0.0137, "epss_percentile": 0.79798}, "CVE-2023-33552": {"epss_score": 0.00695, "epss_percentile": 0.7138}, "CVE-2023-33553": {"epss_score": 0.00039, "epss_percentile": 0.11706}, "CVE-2023-33556": {"epss_score": 0.01454, "epss_percentile": 0.80381}, "CVE-2023-33557": {"epss_score": 0.00263, "epss_percentile": 0.49544}, "CVE-2023-33558": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-33559": {"epss_score": 0.00156, "epss_percentile": 0.36976}, "CVE-2023-33560": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-33561": {"epss_score": 0.00107, "epss_percentile": 0.29629}, "CVE-2023-33562": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-33563": {"epss_score": 0.00357, "epss_percentile": 0.57457}, "CVE-2023-33564": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-33568": {"epss_score": 0.8984, "epss_percentile": 0.99546}, "CVE-2023-33569": {"epss_score": 0.00209, "epss_percentile": 0.43403}, "CVE-2023-33570": {"epss_score": 0.0037, "epss_percentile": 0.58279}, "CVE-2023-33580": {"epss_score": 0.00696, "epss_percentile": 0.71385}, "CVE-2023-33584": {"epss_score": 0.302, "epss_percentile": 0.96518}, "CVE-2023-33591": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-33592": {"epss_score": 0.01881, "epss_percentile": 0.82694}, "CVE-2023-33595": {"epss_score": 0.00059, "epss_percentile": 0.18752}, "CVE-2023-33599": {"epss_score": 0.00405, "epss_percentile": 0.60465}, "CVE-2023-33601": {"epss_score": 0.00124, "epss_percentile": 0.32417}, "CVE-2023-33604": {"epss_score": 0.00099, "epss_percentile": 0.28371}, "CVE-2023-33613": {"epss_score": 0.00034, "epss_percentile": 0.09756}, "CVE-2023-33617": {"epss_score": 0.37365, "epss_percentile": 0.97036}, "CVE-2023-33620": {"epss_score": 0.0008, "epss_percentile": 0.24129}, "CVE-2023-33621": {"epss_score": 0.00056, "epss_percentile": 0.17676}, "CVE-2023-33625": {"epss_score": 0.89184, "epss_percentile": 0.99513}, "CVE-2023-33626": {"epss_score": 0.01629, "epss_percentile": 0.81439}, "CVE-2023-33627": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33628": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33629": {"epss_score": 0.86613, "epss_percentile": 0.9939}, "CVE-2023-33630": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33631": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33632": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33633": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33634": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33635": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33636": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33637": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33638": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33639": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33640": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33641": {"epss_score": 0.00092, "epss_percentile": 0.26553}, "CVE-2023-33642": {"epss_score": 0.001, "epss_percentile": 0.28532}, "CVE-2023-33643": {"epss_score": 0.001, "epss_percentile": 0.28532}, "CVE-2023-33651": {"epss_score": 0.00392, "epss_percentile": 0.59694}, "CVE-2023-33652": {"epss_score": 0.02777, "epss_percentile": 0.85641}, "CVE-2023-33653": {"epss_score": 0.02054, "epss_percentile": 0.83419}, "CVE-2023-33656": {"epss_score": 0.00061, "epss_percentile": 0.19375}, "CVE-2023-33657": {"epss_score": 0.0007, "epss_percentile": 0.21765}, "CVE-2023-33658": {"epss_score": 0.00093, "epss_percentile": 0.26628}, "CVE-2023-33659": {"epss_score": 0.00086, "epss_percentile": 0.25379}, "CVE-2023-33660": {"epss_score": 0.00093, "epss_percentile": 0.26628}, "CVE-2023-33661": {"epss_score": 0.00456, "epss_percentile": 0.63347}, "CVE-2023-33663": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-33664": {"epss_score": 0.00205, "epss_percentile": 0.42739}, "CVE-2023-33665": {"epss_score": 0.00056, "epss_percentile": 0.17748}, "CVE-2023-33666": {"epss_score": 0.00056, "epss_percentile": 0.17748}, "CVE-2023-33668": {"epss_score": 0.00704, "epss_percentile": 0.71573}, "CVE-2023-33669": {"epss_score": 0.26153, "epss_percentile": 0.96117}, "CVE-2023-33670": {"epss_score": 0.00131, "epss_percentile": 0.33495}, "CVE-2023-33671": {"epss_score": 0.00243, "epss_percentile": 0.47422}, "CVE-2023-33672": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-33673": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-33675": {"epss_score": 0.01385, "epss_percentile": 0.79904}, "CVE-2023-33676": {"epss_score": 0.00472, "epss_percentile": 0.64054}, "CVE-2023-33677": {"epss_score": 0.00056, "epss_percentile": 0.17778}, "CVE-2023-33684": {"epss_score": 0.00013, "epss_percentile": 0.0161}, "CVE-2023-33690": {"epss_score": 0.00126, "epss_percentile": 0.32629}, "CVE-2023-33693": {"epss_score": 0.001, "epss_percentile": 0.28446}, "CVE-2023-33695": {"epss_score": 0.00026, "epss_percentile": 0.06431}, "CVE-2023-33706": {"epss_score": 0.0008, "epss_percentile": 0.24095}, "CVE-2023-33716": {"epss_score": 0.0005, "epss_percentile": 0.15764}, "CVE-2023-33717": {"epss_score": 0.00023, "epss_percentile": 0.05631}, "CVE-2023-33718": {"epss_score": 0.00129, "epss_percentile": 0.33135}, "CVE-2023-33719": {"epss_score": 0.0005, "epss_percentile": 0.15764}, "CVE-2023-33720": {"epss_score": 0.00066, "epss_percentile": 0.20909}, "CVE-2023-33722": {"epss_score": 0.01974, "epss_percentile": 0.83113}, "CVE-2023-33725": {"epss_score": 0.00194, "epss_percentile": 0.4156}, "CVE-2023-33730": {"epss_score": 0.0119, "epss_percentile": 0.78378}, "CVE-2023-33731": {"epss_score": 0.00361, "epss_percentile": 0.57726}, "CVE-2023-33732": {"epss_score": 0.00393, "epss_percentile": 0.59741}, "CVE-2023-33733": {"epss_score": 0.29468, "epss_percentile": 0.96445}, "CVE-2023-33734": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-33735": {"epss_score": 0.74487, "epss_percentile": 0.98802}, "CVE-2023-33736": {"epss_score": 0.00171, "epss_percentile": 0.38872}, "CVE-2023-33740": {"epss_score": 0.00071, "epss_percentile": 0.2221}, "CVE-2023-33741": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-33742": {"epss_score": 0.00043, "epss_percentile": 0.13287}, "CVE-2023-33743": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-33744": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2023-33745": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2023-33747": {"epss_score": 0.0012, "epss_percentile": 0.31799}, "CVE-2023-33750": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-33751": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-33754": {"epss_score": 0.00068, "epss_percentile": 0.2129}, "CVE-2023-33756": {"epss_score": 0.00545, "epss_percentile": 0.67156}, "CVE-2023-33757": {"epss_score": 0.00062, "epss_percentile": 0.19716}, "CVE-2023-33758": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-33759": {"epss_score": 0.00039, "epss_percentile": 0.11706}, "CVE-2023-33760": {"epss_score": 0.00062, "epss_percentile": 0.19716}, "CVE-2023-33761": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-33762": {"epss_score": 0.00072, "epss_percentile": 0.223}, "CVE-2023-33763": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-33764": {"epss_score": 0.00092, "epss_percentile": 0.26419}, "CVE-2023-33768": {"epss_score": 0.0156, "epss_percentile": 0.8104}, "CVE-2023-33770": {"epss_score": 0.00023, "epss_percentile": 0.05503}, "CVE-2023-33777": {"epss_score": 0.00523, "epss_percentile": 0.66304}, "CVE-2023-33778": {"epss_score": 0.00104, "epss_percentile": 0.29218}, "CVE-2023-33779": {"epss_score": 0.00089, "epss_percentile": 0.25808}, "CVE-2023-33780": {"epss_score": 0.00452, "epss_percentile": 0.63196}, "CVE-2023-33781": {"epss_score": 0.61498, "epss_percentile": 0.98251}, "CVE-2023-33782": {"epss_score": 0.46514, "epss_percentile": 0.9755}, "CVE-2023-33785": {"epss_score": 0.00085, "epss_percentile": 0.25145}, "CVE-2023-33786": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-33787": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-33788": {"epss_score": 0.00224, "epss_percentile": 0.45013}, "CVE-2023-33789": {"epss_score": 0.00085, "epss_percentile": 0.25145}, "CVE-2023-33790": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-33791": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-33792": {"epss_score": 0.00085, "epss_percentile": 0.25145}, "CVE-2023-33793": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-33794": {"epss_score": 0.0023, "epss_percentile": 0.45706}, "CVE-2023-33795": {"epss_score": 0.00086, "epss_percentile": 0.25248}, "CVE-2023-33796": {"epss_score": 0.00225, "epss_percentile": 0.4523}, "CVE-2023-33797": {"epss_score": 0.0023, "epss_percentile": 0.45706}, "CVE-2023-33798": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-33799": {"epss_score": 0.00085, "epss_percentile": 0.25145}, "CVE-2023-33800": {"epss_score": 0.00111, "epss_percentile": 0.30376}, "CVE-2023-33802": {"epss_score": 0.00054, "epss_percentile": 0.17073}, "CVE-2023-33806": {"epss_score": 0.00112, "epss_percentile": 0.30484}, "CVE-2023-33817": {"epss_score": 0.12001, "epss_percentile": 0.93543}, "CVE-2023-33829": {"epss_score": 0.02564, "epss_percentile": 0.85111}, "CVE-2023-33831": {"epss_score": 0.93354, "epss_percentile": 0.99799}, "CVE-2023-33832": {"epss_score": 0.00013, "epss_percentile": 0.01662}, "CVE-2023-33833": {"epss_score": 0.00019, "epss_percentile": 0.04179}, "CVE-2023-33834": {"epss_score": 0.00046, "epss_percentile": 0.14141}, "CVE-2023-33835": {"epss_score": 0.00048, "epss_percentile": 0.15054}, "CVE-2023-33836": {"epss_score": 0.00063, "epss_percentile": 0.19981}, "CVE-2023-33837": {"epss_score": 0.00019, "epss_percentile": 0.04168}, "CVE-2023-33838": {"epss_score": 0.00013, "epss_percentile": 0.01681}, "CVE-2023-33839": {"epss_score": 0.00146, "epss_percentile": 0.35559}, "CVE-2023-33840": {"epss_score": 0.00055, "epss_percentile": 0.1747}, "CVE-2023-33842": {"epss_score": 0.00022, "epss_percentile": 0.05157}, "CVE-2023-33843": {"epss_score": 0.00108, "epss_percentile": 0.29876}, "CVE-2023-33844": {"epss_score": 0.00036, "epss_percentile": 0.10354}, "CVE-2023-33846": {"epss_score": 0.00076, "epss_percentile": 0.23131}, "CVE-2023-33847": {"epss_score": 0.00066, "epss_percentile": 0.20747}, "CVE-2023-33848": {"epss_score": 0.00055, "epss_percentile": 0.1754}, "CVE-2023-33849": {"epss_score": 0.00046, "epss_percentile": 0.14081}, "CVE-2023-33850": {"epss_score": 0.00045, "epss_percentile": 0.137}, "CVE-2023-33851": {"epss_score": 0.0004, "epss_percentile": 0.12007}, "CVE-2023-33852": {"epss_score": 0.00058, "epss_percentile": 0.18549}, "CVE-2023-33855": {"epss_score": 0.00073, "epss_percentile": 0.22618}, "CVE-2023-33857": {"epss_score": 0.00052, "epss_percentile": 0.16564}, "CVE-2023-33859": {"epss_score": 0.0012, "epss_percentile": 0.31787}, "CVE-2023-33860": {"epss_score": 0.00045, "epss_percentile": 0.13734}, "CVE-2023-33861": {"epss_score": 0.0003, "epss_percentile": 0.08308}, "CVE-2023-33863": {"epss_score": 0.00177, "epss_percentile": 0.39499}, "CVE-2023-33864": {"epss_score": 0.00188, "epss_percentile": 0.40901}, "CVE-2023-33865": {"epss_score": 0.00027, "epss_percentile": 0.06842}, "CVE-2023-33866": {"epss_score": 0.00137, "epss_percentile": 0.34259}, "CVE-2023-33867": {"epss_score": 0.00038, "epss_percentile": 0.11424}, "CVE-2023-33868": {"epss_score": 0.00056, "epss_percentile": 0.17962}, "CVE-2023-33869": {"epss_score": 0.00251, "epss_percentile": 0.48307}, "CVE-2023-33870": {"epss_score": 0.00051, "epss_percentile": 0.16042}, "CVE-2023-33871": {"epss_score": 0.00714, "epss_percentile": 0.7183}, "CVE-2023-33872": {"epss_score": 0.00081, "epss_percentile": 0.24388}, "CVE-2023-33873": {"epss_score": 0.00135, "epss_percentile": 0.34037}, "CVE-2023-33874": {"epss_score": 0.00156, "epss_percentile": 0.36916}, "CVE-2023-33875": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2023-33876": {"epss_score": 0.0013, "epss_percentile": 0.33313}, "CVE-2023-33877": {"epss_score": 0.00055, "epss_percentile": 0.17421}, "CVE-2023-33878": {"epss_score": 0.00096, "epss_percentile": 0.27367}, "CVE-2023-33879": {"epss_score": 0.00025, "epss_percentile": 0.0636}, "CVE-2023-33880": {"epss_score": 0.00025, "epss_percentile": 0.0636}, "CVE-2023-33881": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-33882": {"epss_score": 0.00039, "epss_percentile": 0.11773}, "CVE-2023-33883": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-33884": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-33885": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-33886": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-33887": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-33888": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-33889": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-33890": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-33891": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-33892": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-33893": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-33894": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-33895": {"epss_score": 0.00024, "epss_percentile": 0.05683}, "CVE-2023-33896": {"epss_score": 0.00011, "epss_percentile": 0.00959}, "CVE-2023-33897": {"epss_score": 0.0001, "epss_percentile": 0.00782}, "CVE-2023-33898": {"epss_score": 0.00059, "epss_percentile": 0.1878}, "CVE-2023-33899": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-33900": {"epss_score": 0.00021, "epss_percentile": 0.04932}, "CVE-2023-33901": {"epss_score": 0.00021, "epss_percentile": 0.04856}, "CVE-2023-33902": {"epss_score": 0.00033, "epss_percentile": 0.09354}, "CVE-2023-33903": {"epss_score": 0.00019, "epss_percentile": 0.0436}, "CVE-2023-33904": {"epss_score": 0.00012, "epss_percentile": 0.01386}, "CVE-2023-33905": {"epss_score": 0.00011, "epss_percentile": 0.00959}, "CVE-2023-33906": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-33907": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-33908": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-33909": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-33910": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-33911": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-33912": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-33913": {"epss_score": 0.00455, "epss_percentile": 0.63305}, "CVE-2023-33914": {"epss_score": 0.00054, "epss_percentile": 0.17299}, "CVE-2023-33915": {"epss_score": 0.00176, "epss_percentile": 0.39495}, "CVE-2023-33916": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-33917": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-33918": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-33919": {"epss_score": 0.10615, "epss_percentile": 0.93049}, "CVE-2023-33920": {"epss_score": 0.0011, "epss_percentile": 0.3011}, "CVE-2023-33921": {"epss_score": 0.00144, "epss_percentile": 0.35241}, "CVE-2023-33922": {"epss_score": 0.00227, "epss_percentile": 0.45404}, "CVE-2023-33923": {"epss_score": 0.00068, "epss_percentile": 0.21205}, "CVE-2023-33924": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-33925": {"epss_score": 0.00087, "epss_percentile": 0.25547}, "CVE-2023-33926": {"epss_score": 0.00072, "epss_percentile": 0.22277}, "CVE-2023-33927": {"epss_score": 0.00441, "epss_percentile": 0.62651}, "CVE-2023-33928": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-33929": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-33930": {"epss_score": 0.00841, "epss_percentile": 0.74219}, "CVE-2023-33931": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-33933": {"epss_score": 0.0012, "epss_percentile": 0.31763}, "CVE-2023-33934": {"epss_score": 0.00333, "epss_percentile": 0.55681}, "CVE-2023-33937": {"epss_score": 0.00142, "epss_percentile": 0.34961}, "CVE-2023-33938": {"epss_score": 0.00104, "epss_percentile": 0.29168}, "CVE-2023-33939": {"epss_score": 0.00142, "epss_percentile": 0.34961}, "CVE-2023-33940": {"epss_score": 0.00091, "epss_percentile": 0.26285}, "CVE-2023-33941": {"epss_score": 0.00329, "epss_percentile": 0.55307}, "CVE-2023-33942": {"epss_score": 0.00142, "epss_percentile": 0.34961}, "CVE-2023-33943": {"epss_score": 0.00142, "epss_percentile": 0.34961}, "CVE-2023-33944": {"epss_score": 0.00104, "epss_percentile": 0.29168}, "CVE-2023-33945": {"epss_score": 0.00282, "epss_percentile": 0.51293}, "CVE-2023-33946": {"epss_score": 0.00145, "epss_percentile": 0.35524}, "CVE-2023-33947": {"epss_score": 0.00145, "epss_percentile": 0.35524}, "CVE-2023-33948": {"epss_score": 0.0025, "epss_percentile": 0.48146}, "CVE-2023-33949": {"epss_score": 0.00175, "epss_percentile": 0.39337}, "CVE-2023-33950": {"epss_score": 0.00448, "epss_percentile": 0.6301}, "CVE-2023-33951": {"epss_score": 5e-05, "epss_percentile": 0.00216}, "CVE-2023-33952": {"epss_score": 9e-05, "epss_percentile": 0.00601}, "CVE-2023-33953": {"epss_score": 0.00116, "epss_percentile": 0.31173}, "CVE-2023-33955": {"epss_score": 0.00266, "epss_percentile": 0.49885}, "CVE-2023-33956": {"epss_score": 0.00047, "epss_percentile": 0.14929}, "CVE-2023-33957": {"epss_score": 0.00045, "epss_percentile": 0.14061}, "CVE-2023-33958": {"epss_score": 0.00068, "epss_percentile": 0.21237}, "CVE-2023-33959": {"epss_score": 0.0011, "epss_percentile": 0.30127}, "CVE-2023-33960": {"epss_score": 0.001, "epss_percentile": 0.28562}, "CVE-2023-33961": {"epss_score": 0.00284, "epss_percentile": 0.51448}, "CVE-2023-33962": {"epss_score": 0.00521, "epss_percentile": 0.66228}, "CVE-2023-33963": {"epss_score": 0.01595, "epss_percentile": 0.81238}, "CVE-2023-33964": {"epss_score": 0.00162, "epss_percentile": 0.37661}, "CVE-2023-33965": {"epss_score": 0.06333, "epss_percentile": 0.90676}, "CVE-2023-33966": {"epss_score": 0.00141, "epss_percentile": 0.349}, "CVE-2023-33967": {"epss_score": 0.00484, "epss_percentile": 0.64647}, "CVE-2023-33968": {"epss_score": 0.00063, "epss_percentile": 0.1996}, "CVE-2023-33969": {"epss_score": 0.00085, "epss_percentile": 0.25093}, "CVE-2023-33970": {"epss_score": 0.00244, "epss_percentile": 0.47599}, "CVE-2023-33971": {"epss_score": 0.01578, "epss_percentile": 0.81122}, "CVE-2023-33972": {"epss_score": 0.00165, "epss_percentile": 0.38043}, "CVE-2023-33973": {"epss_score": 0.00218, "epss_percentile": 0.44426}, "CVE-2023-33974": {"epss_score": 0.00181, "epss_percentile": 0.40092}, "CVE-2023-33975": {"epss_score": 0.00349, "epss_percentile": 0.56873}, "CVE-2023-33976": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2023-33977": {"epss_score": 0.03799, "epss_percentile": 0.8774}, "CVE-2023-33979": {"epss_score": 0.00358, "epss_percentile": 0.5752}, "CVE-2023-33980": {"epss_score": 0.0016, "epss_percentile": 0.37497}, "CVE-2023-33981": {"epss_score": 0.00119, "epss_percentile": 0.31677}, "CVE-2023-33982": {"epss_score": 0.00097, "epss_percentile": 0.27481}, "CVE-2023-33983": {"epss_score": 0.00086, "epss_percentile": 0.25377}, "CVE-2023-33984": {"epss_score": 0.00433, "epss_percentile": 0.622}, "CVE-2023-33985": {"epss_score": 0.00399, "epss_percentile": 0.60095}, "CVE-2023-33986": {"epss_score": 0.00416, "epss_percentile": 0.61219}, "CVE-2023-33987": {"epss_score": 0.00144, "epss_percentile": 0.35252}, "CVE-2023-33988": {"epss_score": 0.0042, "epss_percentile": 0.61437}, "CVE-2023-33989": {"epss_score": 0.00248, "epss_percentile": 0.47911}, "CVE-2023-33990": {"epss_score": 0.00037, "epss_percentile": 0.1089}, "CVE-2023-33991": {"epss_score": 0.00216, "epss_percentile": 0.44237}, "CVE-2023-33992": {"epss_score": 0.0009, "epss_percentile": 0.26141}, "CVE-2023-33993": {"epss_score": 0.00227, "epss_percentile": 0.45386}, "CVE-2023-33994": {"epss_score": 0.00186, "epss_percentile": 0.40628}, "CVE-2023-33995": {"epss_score": 0.00122, "epss_percentile": 0.32131}, "CVE-2023-33996": {"epss_score": 0.00384, "epss_percentile": 0.59125}, "CVE-2023-33997": {"epss_score": 0.00087, "epss_percentile": 0.25547}, "CVE-2023-33998": {"epss_score": 0.00152, "epss_percentile": 0.36394}, "CVE-2023-34000": {"epss_score": 0.00466, "epss_percentile": 0.63809}, "CVE-2023-34001": {"epss_score": 0.00114, "epss_percentile": 0.3081}, "CVE-2023-34002": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-34003": {"epss_score": 0.00094, "epss_percentile": 0.27076}, "CVE-2023-34004": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-34005": {"epss_score": 0.00083, "epss_percentile": 0.24752}, "CVE-2023-34006": {"epss_score": 0.00066, "epss_percentile": 0.20954}, "CVE-2023-34007": {"epss_score": 0.00314, "epss_percentile": 0.54089}, "CVE-2023-34008": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-34009": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-34010": {"epss_score": 0.00076, "epss_percentile": 0.23223}, "CVE-2023-34011": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-34012": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-34013": {"epss_score": 0.0015, "epss_percentile": 0.36177}, "CVE-2023-34014": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2023-34015": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-34017": {"epss_score": 0.00096, "epss_percentile": 0.27354}, "CVE-2023-34018": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-34019": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-34020": {"epss_score": 0.04017, "epss_percentile": 0.88124}, "CVE-2023-34021": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-34022": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-34023": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-34024": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-34025": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-34026": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-34027": {"epss_score": 0.00158, "epss_percentile": 0.37228}, "CVE-2023-34028": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-34029": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-34030": {"epss_score": 0.00137, "epss_percentile": 0.3421}, "CVE-2023-34031": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-34032": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-34033": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-34034": {"epss_score": 0.47909, "epss_percentile": 0.97608}, "CVE-2023-34035": {"epss_score": 0.02176, "epss_percentile": 0.83885}, "CVE-2023-34036": {"epss_score": 0.00306, "epss_percentile": 0.53457}, "CVE-2023-34037": {"epss_score": 0.00776, "epss_percentile": 0.73094}, "CVE-2023-34038": {"epss_score": 0.00535, "epss_percentile": 0.66821}, "CVE-2023-34039": {"epss_score": 0.92234, "epss_percentile": 0.99702}, "CVE-2023-34040": {"epss_score": 0.27362, "epss_percentile": 0.9624}, "CVE-2023-34041": {"epss_score": 0.00159, "epss_percentile": 0.37324}, "CVE-2023-34042": {"epss_score": 0.00043, "epss_percentile": 0.13092}, "CVE-2023-34043": {"epss_score": 0.00039, "epss_percentile": 0.11527}, "CVE-2023-34044": {"epss_score": 0.0006, "epss_percentile": 0.19231}, "CVE-2023-34045": {"epss_score": 0.00092, "epss_percentile": 0.26436}, "CVE-2023-34046": {"epss_score": 0.00108, "epss_percentile": 0.29763}, "CVE-2023-34047": {"epss_score": 0.00475, "epss_percentile": 0.64195}, "CVE-2023-34048": {"epss_score": 0.93213, "epss_percentile": 0.99784}, "CVE-2023-34049": {"epss_score": 0.00052, "epss_percentile": 0.16635}, "CVE-2023-34050": {"epss_score": 0.41073, "epss_percentile": 0.97252}, "CVE-2023-34051": {"epss_score": 0.57738, "epss_percentile": 0.98081}, "CVE-2023-34052": {"epss_score": 0.00026, "epss_percentile": 0.06389}, "CVE-2023-34053": {"epss_score": 0.00613, "epss_percentile": 0.69263}, "CVE-2023-34054": {"epss_score": 0.0017, "epss_percentile": 0.38663}, "CVE-2023-34055": {"epss_score": 0.00282, "epss_percentile": 0.51278}, "CVE-2023-34056": {"epss_score": 0.00256, "epss_percentile": 0.48775}, "CVE-2023-34057": {"epss_score": 0.00076, "epss_percentile": 0.23163}, "CVE-2023-34058": {"epss_score": 0.00032, "epss_percentile": 0.08749}, "CVE-2023-34059": {"epss_score": 0.00066, "epss_percentile": 0.20878}, "CVE-2023-34060": {"epss_score": 0.00066, "epss_percentile": 0.20926}, "CVE-2023-34061": {"epss_score": 0.00171, "epss_percentile": 0.3882}, "CVE-2023-34062": {"epss_score": 0.01851, "epss_percentile": 0.82535}, "CVE-2023-34063": {"epss_score": 0.00171, "epss_percentile": 0.38811}, "CVE-2023-34064": {"epss_score": 0.00035, "epss_percentile": 0.10136}, "CVE-2023-34085": {"epss_score": 0.00194, "epss_percentile": 0.41529}, "CVE-2023-34086": {"epss_score": 0.00035, "epss_percentile": 0.10067}, "CVE-2023-34087": {"epss_score": 0.00057, "epss_percentile": 0.18188}, "CVE-2023-34088": {"epss_score": 0.00096, "epss_percentile": 0.27325}, "CVE-2023-34089": {"epss_score": 0.00116, "epss_percentile": 0.31094}, "CVE-2023-34090": {"epss_score": 0.00257, "epss_percentile": 0.48912}, "CVE-2023-34091": {"epss_score": 0.00046, "epss_percentile": 0.14147}, "CVE-2023-34092": {"epss_score": 0.00558, "epss_percentile": 0.67582}, "CVE-2023-34093": {"epss_score": 0.00069, "epss_percentile": 0.21564}, "CVE-2023-34094": {"epss_score": 0.00261, "epss_percentile": 0.49296}, "CVE-2023-34095": {"epss_score": 0.00388, "epss_percentile": 0.59351}, "CVE-2023-34096": {"epss_score": 0.45105, "epss_percentile": 0.97474}, "CVE-2023-34097": {"epss_score": 0.00166, "epss_percentile": 0.3827}, "CVE-2023-34098": {"epss_score": 0.00205, "epss_percentile": 0.42727}, "CVE-2023-34099": {"epss_score": 0.00105, "epss_percentile": 0.29313}, "CVE-2023-34100": {"epss_score": 0.00061, "epss_percentile": 0.19298}, "CVE-2023-34101": {"epss_score": 0.00153, "epss_percentile": 0.36537}, "CVE-2023-34102": {"epss_score": 0.08165, "epss_percentile": 0.91912}, "CVE-2023-34103": {"epss_score": 0.00516, "epss_percentile": 0.66031}, "CVE-2023-34104": {"epss_score": 0.00273, "epss_percentile": 0.50424}, "CVE-2023-34105": {"epss_score": 0.82764, "epss_percentile": 0.99213}, "CVE-2023-34106": {"epss_score": 0.00177, "epss_percentile": 0.39622}, "CVE-2023-34107": {"epss_score": 0.00177, "epss_percentile": 0.39622}, "CVE-2023-34108": {"epss_score": 0.00465, "epss_percentile": 0.63765}, "CVE-2023-34109": {"epss_score": 0.0016, "epss_percentile": 0.37497}, "CVE-2023-34110": {"epss_score": 0.00388, "epss_percentile": 0.59352}, "CVE-2023-34111": {"epss_score": 0.00439, "epss_percentile": 0.62585}, "CVE-2023-34112": {"epss_score": 0.02011, "epss_percentile": 0.83249}, "CVE-2023-34114": {"epss_score": 0.00287, "epss_percentile": 0.51803}, "CVE-2023-34115": {"epss_score": 0.00051, "epss_percentile": 0.16192}, "CVE-2023-34116": {"epss_score": 0.00307, "epss_percentile": 0.53489}, "CVE-2023-34117": {"epss_score": 0.00042, "epss_percentile": 0.12586}, "CVE-2023-34118": {"epss_score": 0.00035, "epss_percentile": 0.10122}, "CVE-2023-34119": {"epss_score": 0.00049, "epss_percentile": 0.15591}, "CVE-2023-34120": {"epss_score": 0.00025, "epss_percentile": 0.06047}, "CVE-2023-34121": {"epss_score": 0.00426, "epss_percentile": 0.6175}, "CVE-2023-34123": {"epss_score": 0.00099, "epss_percentile": 0.2843}, "CVE-2023-34124": {"epss_score": 0.91038, "epss_percentile": 0.99615}, "CVE-2023-34125": {"epss_score": 0.10187, "epss_percentile": 0.92885}, "CVE-2023-34126": {"epss_score": 0.00287, "epss_percentile": 0.51839}, "CVE-2023-34127": {"epss_score": 0.90206, "epss_percentile": 0.99569}, "CVE-2023-34128": {"epss_score": 0.0021, "epss_percentile": 0.43467}, "CVE-2023-34129": {"epss_score": 0.33308, "epss_percentile": 0.96762}, "CVE-2023-34130": {"epss_score": 0.0011, "epss_percentile": 0.30202}, "CVE-2023-34131": {"epss_score": 0.00349, "epss_percentile": 0.56889}, "CVE-2023-34132": {"epss_score": 0.68192, "epss_percentile": 0.98535}, "CVE-2023-34133": {"epss_score": 0.53826, "epss_percentile": 0.97898}, "CVE-2023-34134": {"epss_score": 0.00324, "epss_percentile": 0.54957}, "CVE-2023-34135": {"epss_score": 0.00162, "epss_percentile": 0.37733}, "CVE-2023-34136": {"epss_score": 0.00347, "epss_percentile": 0.56777}, "CVE-2023-34137": {"epss_score": 0.00069, "epss_percentile": 0.21497}, "CVE-2023-34138": {"epss_score": 0.00113, "epss_percentile": 0.30621}, "CVE-2023-34139": {"epss_score": 0.00217, "epss_percentile": 0.44322}, "CVE-2023-34140": {"epss_score": 0.00099, "epss_percentile": 0.27864}, "CVE-2023-34141": {"epss_score": 0.00113, "epss_percentile": 0.30621}, "CVE-2023-34142": {"epss_score": 0.00099, "epss_percentile": 0.2839}, "CVE-2023-34143": {"epss_score": 0.00067, "epss_percentile": 0.21178}, "CVE-2023-34144": {"epss_score": 0.00043, "epss_percentile": 0.12962}, "CVE-2023-34145": {"epss_score": 0.00043, "epss_percentile": 0.12962}, "CVE-2023-34146": {"epss_score": 0.00091, "epss_percentile": 0.26174}, "CVE-2023-34147": {"epss_score": 0.00091, "epss_percentile": 0.26174}, "CVE-2023-34148": {"epss_score": 0.00091, "epss_percentile": 0.26174}, "CVE-2023-34149": {"epss_score": 0.00062, "epss_percentile": 0.19755}, "CVE-2023-34150": {"epss_score": 0.00067, "epss_percentile": 0.21183}, "CVE-2023-34151": {"epss_score": 0.00064, "epss_percentile": 0.20292}, "CVE-2023-34152": {"epss_score": 0.69305, "epss_percentile": 0.98583}, "CVE-2023-34153": {"epss_score": 0.00696, "epss_percentile": 0.71385}, "CVE-2023-34154": {"epss_score": 0.00063, "epss_percentile": 0.1994}, "CVE-2023-34155": {"epss_score": 0.00087, "epss_percentile": 0.25556}, "CVE-2023-34156": {"epss_score": 0.00038, "epss_percentile": 0.11207}, "CVE-2023-34157": {"epss_score": 0.00039, "epss_percentile": 0.11693}, "CVE-2023-34158": {"epss_score": 0.00056, "epss_percentile": 0.17908}, "CVE-2023-34159": {"epss_score": 0.00127, "epss_percentile": 0.32841}, "CVE-2023-34160": {"epss_score": 0.00056, "epss_percentile": 0.17908}, "CVE-2023-34161": {"epss_score": 0.00075, "epss_percentile": 0.22884}, "CVE-2023-34162": {"epss_score": 0.00087, "epss_percentile": 0.25556}, "CVE-2023-34163": {"epss_score": 0.00087, "epss_percentile": 0.25556}, "CVE-2023-34164": {"epss_score": 0.00098, "epss_percentile": 0.27677}, "CVE-2023-34165": {"epss_score": 0.0005, "epss_percentile": 0.15697}, "CVE-2023-34166": {"epss_score": 0.00102, "epss_percentile": 0.28755}, "CVE-2023-34167": {"epss_score": 0.00056, "epss_percentile": 0.17908}, "CVE-2023-34168": {"epss_score": 0.00128, "epss_percentile": 0.33046}, "CVE-2023-34169": {"epss_score": 0.00112, "epss_percentile": 0.30494}, "CVE-2023-34170": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-34171": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-34172": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-34173": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-34174": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-34175": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-34176": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-34177": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-34178": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-34179": {"epss_score": 0.00199, "epss_percentile": 0.42156}, "CVE-2023-34180": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-34181": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-34182": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-34183": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-34184": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-34185": {"epss_score": 0.0007, "epss_percentile": 0.21758}, "CVE-2023-34186": {"epss_score": 0.00597, "epss_percentile": 0.68738}, "CVE-2023-34187": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-34188": {"epss_score": 0.00111, "epss_percentile": 0.30241}, "CVE-2023-34189": {"epss_score": 0.00107, "epss_percentile": 0.29609}, "CVE-2023-34192": {"epss_score": 0.89435, "epss_percentile": 0.99526}, "CVE-2023-34193": {"epss_score": 0.00337, "epss_percentile": 0.5605}, "CVE-2023-34194": {"epss_score": 0.01033, "epss_percentile": 0.76874}, "CVE-2023-34195": {"epss_score": 0.00094, "epss_percentile": 0.26968}, "CVE-2023-34196": {"epss_score": 0.00076, "epss_percentile": 0.23147}, "CVE-2023-34197": {"epss_score": 0.00111, "epss_percentile": 0.30314}, "CVE-2023-34198": {"epss_score": 0.00286, "epss_percentile": 0.51779}, "CVE-2023-34203": {"epss_score": 0.00693, "epss_percentile": 0.71322}, "CVE-2023-34204": {"epss_score": 0.00127, "epss_percentile": 0.328}, "CVE-2023-34205": {"epss_score": 0.00052, "epss_percentile": 0.16368}, "CVE-2023-34207": {"epss_score": 0.00293, "epss_percentile": 0.52292}, "CVE-2023-34208": {"epss_score": 0.00089, "epss_percentile": 0.25915}, "CVE-2023-34209": {"epss_score": 0.00079, "epss_percentile": 0.23897}, "CVE-2023-34210": {"epss_score": 0.00054, "epss_percentile": 0.17307}, "CVE-2023-34212": {"epss_score": 0.01438, "epss_percentile": 0.80284}, "CVE-2023-34213": {"epss_score": 0.0037, "epss_percentile": 0.58327}, "CVE-2023-34214": {"epss_score": 0.00205, "epss_percentile": 0.42751}, "CVE-2023-34215": {"epss_score": 0.00248, "epss_percentile": 0.47955}, "CVE-2023-34216": {"epss_score": 0.00268, "epss_percentile": 0.50058}, "CVE-2023-34217": {"epss_score": 0.0023, "epss_percentile": 0.45727}, "CVE-2023-34218": {"epss_score": 2e-05, "epss_percentile": 0.00037}, "CVE-2023-34219": {"epss_score": 2e-05, "epss_percentile": 0.00046}, "CVE-2023-34220": {"epss_score": 0.0772, "epss_percentile": 0.91642}, "CVE-2023-34221": {"epss_score": 0.00079, "epss_percentile": 0.2388}, "CVE-2023-34222": {"epss_score": 0.00032, "epss_percentile": 0.0886}, "CVE-2023-34223": {"epss_score": 4e-05, "epss_percentile": 0.00156}, "CVE-2023-34224": {"epss_score": 3e-05, "epss_percentile": 0.00117}, "CVE-2023-34225": {"epss_score": 0.06047, "epss_percentile": 0.90433}, "CVE-2023-34226": {"epss_score": 0.00032, "epss_percentile": 0.0886}, "CVE-2023-34227": {"epss_score": 4e-05, "epss_percentile": 0.00149}, "CVE-2023-34228": {"epss_score": 2e-05, "epss_percentile": 0.00057}, "CVE-2023-34229": {"epss_score": 0.00079, "epss_percentile": 0.2388}, "CVE-2023-34230": {"epss_score": 0.02985, "epss_percentile": 0.86132}, "CVE-2023-34231": {"epss_score": 0.00566, "epss_percentile": 0.67833}, "CVE-2023-34232": {"epss_score": 0.00531, "epss_percentile": 0.66647}, "CVE-2023-34233": {"epss_score": 0.00566, "epss_percentile": 0.67833}, "CVE-2023-34234": {"epss_score": 0.00081, "epss_percentile": 0.24293}, "CVE-2023-34235": {"epss_score": 0.0164, "epss_percentile": 0.81501}, "CVE-2023-34236": {"epss_score": 0.00093, "epss_percentile": 0.26646}, "CVE-2023-34237": {"epss_score": 0.02759, "epss_percentile": 0.85596}, "CVE-2023-34238": {"epss_score": 0.00451, "epss_percentile": 0.63123}, "CVE-2023-34239": {"epss_score": 0.0021, "epss_percentile": 0.43434}, "CVE-2023-34240": {"epss_score": 0.00208, "epss_percentile": 0.43278}, "CVE-2023-34241": {"epss_score": 0.00046, "epss_percentile": 0.14078}, "CVE-2023-34242": {"epss_score": 0.00055, "epss_percentile": 0.17567}, "CVE-2023-34243": {"epss_score": 0.00185, "epss_percentile": 0.40484}, "CVE-2023-34244": {"epss_score": 0.00736, "epss_percentile": 0.72314}, "CVE-2023-34245": {"epss_score": 0.00496, "epss_percentile": 0.65153}, "CVE-2023-34246": {"epss_score": 0.00376, "epss_percentile": 0.58671}, "CVE-2023-34247": {"epss_score": 0.00024, "epss_percentile": 0.05789}, "CVE-2023-34249": {"epss_score": 0.00067, "epss_percentile": 0.21066}, "CVE-2023-34250": {"epss_score": 0.00109, "epss_percentile": 0.29974}, "CVE-2023-34251": {"epss_score": 0.02535, "epss_percentile": 0.85036}, "CVE-2023-34252": {"epss_score": 0.00351, "epss_percentile": 0.57071}, "CVE-2023-34253": {"epss_score": 0.01572, "epss_percentile": 0.81096}, "CVE-2023-34254": {"epss_score": 0.00278, "epss_percentile": 0.50864}, "CVE-2023-34256": {"epss_score": 0.00015, "epss_percentile": 0.02343}, "CVE-2023-34257": {"epss_score": 0.00095, "epss_percentile": 0.27223}, "CVE-2023-34258": {"epss_score": 0.00189, "epss_percentile": 0.41002}, "CVE-2023-34259": {"epss_score": 0.92452, "epss_percentile": 0.99715}, "CVE-2023-34260": {"epss_score": 0.03408, "epss_percentile": 0.87079}, "CVE-2023-34261": {"epss_score": 0.00368, "epss_percentile": 0.58168}, "CVE-2023-34262": {"epss_score": 0.00735, "epss_percentile": 0.72296}, "CVE-2023-34263": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-34264": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34265": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-34266": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34267": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34268": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34269": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34270": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34271": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34272": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34273": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34274": {"epss_score": 0.00728, "epss_percentile": 0.72108}, "CVE-2023-34275": {"epss_score": 0.00212, "epss_percentile": 0.4378}, "CVE-2023-34276": {"epss_score": 0.00212, "epss_percentile": 0.4378}, "CVE-2023-34277": {"epss_score": 0.00212, "epss_percentile": 0.4378}, "CVE-2023-34278": {"epss_score": 0.00212, "epss_percentile": 0.4378}, "CVE-2023-34279": {"epss_score": 0.03212, "epss_percentile": 0.86656}, "CVE-2023-34280": {"epss_score": 0.00212, "epss_percentile": 0.4378}, "CVE-2023-34281": {"epss_score": 0.00212, "epss_percentile": 0.4378}, "CVE-2023-34282": {"epss_score": 0.00728, "epss_percentile": 0.72108}, "CVE-2023-34283": {"epss_score": 0.00366, "epss_percentile": 0.5805}, "CVE-2023-34284": {"epss_score": 0.00031, "epss_percentile": 0.08461}, "CVE-2023-34285": {"epss_score": 0.01091, "epss_percentile": 0.77459}, "CVE-2023-34286": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-34287": {"epss_score": 0.00779, "epss_percentile": 0.7315}, "CVE-2023-34288": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34289": {"epss_score": 0.01188, "epss_percentile": 0.78361}, "CVE-2023-34290": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34291": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34292": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-34293": {"epss_score": 0.01495, "epss_percentile": 0.80658}, "CVE-2023-34294": {"epss_score": 0.00645, "epss_percentile": 0.70125}, "CVE-2023-34295": {"epss_score": 0.01495, "epss_percentile": 0.80658}, "CVE-2023-34296": {"epss_score": 0.01495, "epss_percentile": 0.80658}, "CVE-2023-34297": {"epss_score": 0.01495, "epss_percentile": 0.80658}, "CVE-2023-34298": {"epss_score": 0.00116, "epss_percentile": 0.31073}, "CVE-2023-34299": {"epss_score": 0.01188, "epss_percentile": 0.78361}, "CVE-2023-34300": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34301": {"epss_score": 0.00553, "epss_percentile": 0.67408}, "CVE-2023-34302": {"epss_score": 0.01188, "epss_percentile": 0.78361}, "CVE-2023-34303": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34304": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34305": {"epss_score": 0.00804, "epss_percentile": 0.73608}, "CVE-2023-34306": {"epss_score": 0.01581, "epss_percentile": 0.81138}, "CVE-2023-34307": {"epss_score": 0.015, "epss_percentile": 0.80713}, "CVE-2023-34308": {"epss_score": 0.02056, "epss_percentile": 0.83424}, "CVE-2023-34309": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34310": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-34311": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-34312": {"epss_score": 0.03507, "epss_percentile": 0.87259}, "CVE-2023-34314": {"epss_score": 0.00067, "epss_percentile": 0.21092}, "CVE-2023-34315": {"epss_score": 0.00064, "epss_percentile": 0.20193}, "CVE-2023-34316": {"epss_score": 0.00016, "epss_percentile": 0.02617}, "CVE-2023-34317": {"epss_score": 0.00074, "epss_percentile": 0.22729}, "CVE-2023-34318": {"epss_score": 0.00033, "epss_percentile": 0.09335}, "CVE-2023-34319": {"epss_score": 0.00014, "epss_percentile": 0.01853}, "CVE-2023-34320": {"epss_score": 0.00067, "epss_percentile": 0.21127}, "CVE-2023-34321": {"epss_score": 0.00055, "epss_percentile": 0.17528}, "CVE-2023-34322": {"epss_score": 0.00058, "epss_percentile": 0.18609}, "CVE-2023-34323": {"epss_score": 0.00087, "epss_percentile": 0.25615}, "CVE-2023-34324": {"epss_score": 0.00088, "epss_percentile": 0.25747}, "CVE-2023-34325": {"epss_score": 0.0007, "epss_percentile": 0.21807}, "CVE-2023-34326": {"epss_score": 0.00066, "epss_percentile": 0.2068}, "CVE-2023-34327": {"epss_score": 0.00072, "epss_percentile": 0.22396}, "CVE-2023-34328": {"epss_score": 0.00072, "epss_percentile": 0.22396}, "CVE-2023-34329": {"epss_score": 0.00016, "epss_percentile": 0.02959}, "CVE-2023-34330": {"epss_score": 0.00037, "epss_percentile": 0.10988}, "CVE-2023-34332": {"epss_score": 0.00029, "epss_percentile": 0.07589}, "CVE-2023-34333": {"epss_score": 0.00029, "epss_percentile": 0.07589}, "CVE-2023-34334": {"epss_score": 0.00278, "epss_percentile": 0.50861}, "CVE-2023-34335": {"epss_score": 0.0003, "epss_percentile": 0.07982}, "CVE-2023-34336": {"epss_score": 0.00332, "epss_percentile": 0.55613}, "CVE-2023-34337": {"epss_score": 0.00116, "epss_percentile": 0.31049}, "CVE-2023-34338": {"epss_score": 0.00186, "epss_percentile": 0.40595}, "CVE-2023-34339": {"epss_score": 1e-05, "epss_percentile": 0.00018}, "CVE-2023-34340": {"epss_score": 0.00094, "epss_percentile": 0.2701}, "CVE-2023-34341": {"epss_score": 0.00173, "epss_percentile": 0.39086}, "CVE-2023-34342": {"epss_score": 0.00216, "epss_percentile": 0.44223}, "CVE-2023-34343": {"epss_score": 0.00278, "epss_percentile": 0.50861}, "CVE-2023-34344": {"epss_score": 0.0022, "epss_percentile": 0.44587}, "CVE-2023-34345": {"epss_score": 0.00187, "epss_percentile": 0.40757}, "CVE-2023-34346": {"epss_score": 0.00288, "epss_percentile": 0.519}, "CVE-2023-34347": {"epss_score": 0.00123, "epss_percentile": 0.32315}, "CVE-2023-34348": {"epss_score": 0.00246, "epss_percentile": 0.4776}, "CVE-2023-34349": {"epss_score": 0.0004, "epss_percentile": 0.11925}, "CVE-2023-34350": {"epss_score": 0.00075, "epss_percentile": 0.22921}, "CVE-2023-34351": {"epss_score": 0.00176, "epss_percentile": 0.39441}, "CVE-2023-34352": {"epss_score": 0.00208, "epss_percentile": 0.43283}, "CVE-2023-34353": {"epss_score": 0.00047, "epss_percentile": 0.14495}, "CVE-2023-34354": {"epss_score": 0.00124, "epss_percentile": 0.32437}, "CVE-2023-34355": {"epss_score": 0.00082, "epss_percentile": 0.24555}, "CVE-2023-34356": {"epss_score": 0.00296, "epss_percentile": 0.52624}, "CVE-2023-34357": {"epss_score": 0.00027, "epss_percentile": 0.06938}, "CVE-2023-34358": {"epss_score": 0.00268, "epss_percentile": 0.50072}, "CVE-2023-34359": {"epss_score": 0.00265, "epss_percentile": 0.49805}, "CVE-2023-34360": {"epss_score": 0.0004, "epss_percentile": 0.12018}, "CVE-2023-34362": {"epss_score": 0.94254, "epss_percentile": 0.99928}, "CVE-2023-34363": {"epss_score": 0.00213, "epss_percentile": 0.43921}, "CVE-2023-34364": {"epss_score": 0.0007, "epss_percentile": 0.21641}, "CVE-2023-34365": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-34366": {"epss_score": 0.00177, "epss_percentile": 0.39598}, "CVE-2023-34367": {"epss_score": 0.01152, "epss_percentile": 0.78046}, "CVE-2023-34368": {"epss_score": 0.00066, "epss_percentile": 0.20954}, "CVE-2023-34369": {"epss_score": 0.00061, "epss_percentile": 0.19286}, "CVE-2023-34370": {"epss_score": 0.00118, "epss_percentile": 0.3139}, "CVE-2023-34371": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-34372": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-34373": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-34374": {"epss_score": 0.00045, "epss_percentile": 0.13698}, "CVE-2023-34375": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-34376": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-34377": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-34378": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-34379": {"epss_score": 0.00043, "epss_percentile": 0.13283}, "CVE-2023-34381": {"epss_score": 0.00163, "epss_percentile": 0.37844}, "CVE-2023-34382": {"epss_score": 0.0015, "epss_percentile": 0.36173}, "CVE-2023-34383": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-34384": {"epss_score": 0.00059, "epss_percentile": 0.18737}, "CVE-2023-34385": {"epss_score": 0.00314, "epss_percentile": 0.54089}, "CVE-2023-34386": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-34387": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-34388": {"epss_score": 0.00119, "epss_percentile": 0.31544}, "CVE-2023-34389": {"epss_score": 0.00344, "epss_percentile": 0.56536}, "CVE-2023-34390": {"epss_score": 0.00321, "epss_percentile": 0.54691}, "CVE-2023-34391": {"epss_score": 0.00026, "epss_percentile": 0.06428}, "CVE-2023-34392": {"epss_score": 0.00088, "epss_percentile": 0.25651}, "CVE-2023-34394": {"epss_score": 0.00051, "epss_percentile": 0.16159}, "CVE-2023-34395": {"epss_score": 0.00167, "epss_percentile": 0.38317}, "CVE-2023-34396": {"epss_score": 0.00115, "epss_percentile": 0.30963}, "CVE-2023-34397": {"epss_score": 0.0022, "epss_percentile": 0.44601}, "CVE-2023-34398": {"epss_score": 0.00171, "epss_percentile": 0.38838}, "CVE-2023-34399": {"epss_score": 0.00202, "epss_percentile": 0.4243}, "CVE-2023-34400": {"epss_score": 0.00257, "epss_percentile": 0.48849}, "CVE-2023-34401": {"epss_score": 0.00085, "epss_percentile": 0.25227}, "CVE-2023-34402": {"epss_score": 0.0004, "epss_percentile": 0.11894}, "CVE-2023-34403": {"epss_score": 0.00034, "epss_percentile": 0.09575}, "CVE-2023-34404": {"epss_score": 0.00045, "epss_percentile": 0.13687}, "CVE-2023-34406": {"epss_score": 0.00031, "epss_percentile": 0.08325}, "CVE-2023-34407": {"epss_score": 0.01106, "epss_percentile": 0.77617}, "CVE-2023-34408": {"epss_score": 0.00401, "epss_percentile": 0.60201}, "CVE-2023-34409": {"epss_score": 0.03466, "epss_percentile": 0.87189}, "CVE-2023-34410": {"epss_score": 0.00107, "epss_percentile": 0.29594}, "CVE-2023-34411": {"epss_score": 0.00096, "epss_percentile": 0.27242}, "CVE-2023-34412": {"epss_score": 0.00038, "epss_percentile": 0.11093}, "CVE-2023-34414": {"epss_score": 0.00058, "epss_percentile": 0.18469}, "CVE-2023-34415": {"epss_score": 0.00096, "epss_percentile": 0.27348}, "CVE-2023-34416": {"epss_score": 0.00238, "epss_percentile": 0.4675}, "CVE-2023-34417": {"epss_score": 0.00307, "epss_percentile": 0.53486}, "CVE-2023-34418": {"epss_score": 0.00229, "epss_percentile": 0.45635}, "CVE-2023-34419": {"epss_score": 0.00037, "epss_percentile": 0.10902}, "CVE-2023-34420": {"epss_score": 0.00325, "epss_percentile": 0.55015}, "CVE-2023-34421": {"epss_score": 0.00096, "epss_percentile": 0.27275}, "CVE-2023-34422": {"epss_score": 0.00096, "epss_percentile": 0.27275}, "CVE-2023-34423": {"epss_score": 0.00245, "epss_percentile": 0.47673}, "CVE-2023-34424": {"epss_score": 0.00051, "epss_percentile": 0.1633}, "CVE-2023-34425": {"epss_score": 0.00481, "epss_percentile": 0.64518}, "CVE-2023-34426": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-34427": {"epss_score": 0.00058, "epss_percentile": 0.18485}, "CVE-2023-34429": {"epss_score": 0.00065, "epss_percentile": 0.20558}, "CVE-2023-34430": {"epss_score": 0.00144, "epss_percentile": 0.35344}, "CVE-2023-34431": {"epss_score": 0.00057, "epss_percentile": 0.18142}, "CVE-2023-34432": {"epss_score": 0.00036, "epss_percentile": 0.10382}, "CVE-2023-34433": {"epss_score": 0.00055, "epss_percentile": 0.17467}, "CVE-2023-34434": {"epss_score": 0.00385, "epss_percentile": 0.59217}, "CVE-2023-34435": {"epss_score": 0.00084, "epss_percentile": 0.24986}, "CVE-2023-34436": {"epss_score": 0.00042, "epss_percentile": 0.12706}, "CVE-2023-34437": {"epss_score": 0.00085, "epss_percentile": 0.25035}, "CVE-2023-34438": {"epss_score": 0.00034, "epss_percentile": 0.09554}, "CVE-2023-34439": {"epss_score": 0.00492, "epss_percentile": 0.65001}, "CVE-2023-34440": {"epss_score": 0.00034, "epss_percentile": 0.09758}, "CVE-2023-34441": {"epss_score": 0.00028, "epss_percentile": 0.07357}, "CVE-2023-34442": {"epss_score": 0.00043, "epss_percentile": 0.13336}, "CVE-2023-34443": {"epss_score": 0.00132, "epss_percentile": 0.33538}, "CVE-2023-34444": {"epss_score": 0.00635, "epss_percentile": 0.69828}, "CVE-2023-34445": {"epss_score": 0.00635, "epss_percentile": 0.69828}, "CVE-2023-34446": {"epss_score": 0.0078, "epss_percentile": 0.73175}, "CVE-2023-34447": {"epss_score": 0.01181, "epss_percentile": 0.78309}, "CVE-2023-34448": {"epss_score": 0.08075, "epss_percentile": 0.91869}, "CVE-2023-34449": {"epss_score": 0.00178, "epss_percentile": 0.39648}, "CVE-2023-34450": {"epss_score": 0.00048, "epss_percentile": 0.15239}, "CVE-2023-34451": {"epss_score": 0.00236, "epss_percentile": 0.46358}, "CVE-2023-34452": {"epss_score": 0.00621, "epss_percentile": 0.69476}, "CVE-2023-34453": {"epss_score": 0.01822, "epss_percentile": 0.82412}, "CVE-2023-34454": {"epss_score": 0.00589, "epss_percentile": 0.68529}, "CVE-2023-34455": {"epss_score": 0.00611, "epss_percentile": 0.6918}, "CVE-2023-34457": {"epss_score": 0.02401, "epss_percentile": 0.8464}, "CVE-2023-34458": {"epss_score": 0.02176, "epss_percentile": 0.83883}, "CVE-2023-34459": {"epss_score": 0.00787, "epss_percentile": 0.73321}, "CVE-2023-34460": {"epss_score": 0.00067, "epss_percentile": 0.20967}, "CVE-2023-34461": {"epss_score": 0.00094, "epss_percentile": 0.27041}, "CVE-2023-34462": {"epss_score": 0.01091, "epss_percentile": 0.77456}, "CVE-2023-34463": {"epss_score": 0.00134, "epss_percentile": 0.33843}, "CVE-2023-34464": {"epss_score": 0.01552, "epss_percentile": 0.80994}, "CVE-2023-34465": {"epss_score": 0.00551, "epss_percentile": 0.67372}, "CVE-2023-34466": {"epss_score": 0.0019, "epss_percentile": 0.4105}, "CVE-2023-34467": {"epss_score": 0.01611, "epss_percentile": 0.81329}, "CVE-2023-34468": {"epss_score": 0.77205, "epss_percentile": 0.98925}, "CVE-2023-34469": {"epss_score": 0.00069, "epss_percentile": 0.21568}, "CVE-2023-34470": {"epss_score": 0.0006, "epss_percentile": 0.19174}, "CVE-2023-34471": {"epss_score": 0.00062, "epss_percentile": 0.19657}, "CVE-2023-34472": {"epss_score": 0.00203, "epss_percentile": 0.4251}, "CVE-2023-34473": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2023-34474": {"epss_score": 0.00028, "epss_percentile": 0.07483}, "CVE-2023-34475": {"epss_score": 0.00023, "epss_percentile": 0.05434}, "CVE-2023-34476": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-34477": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-34478": {"epss_score": 0.00041, "epss_percentile": 0.12457}, "CVE-2023-34486": {"epss_score": 0.00153, "epss_percentile": 0.36532}, "CVE-2023-34487": {"epss_score": 0.00076, "epss_percentile": 0.23281}, "CVE-2023-34488": {"epss_score": 0.00103, "epss_percentile": 0.29051}, "CVE-2023-34494": {"epss_score": 0.00225, "epss_percentile": 0.4508}, "CVE-2023-34537": {"epss_score": 0.12787, "epss_percentile": 0.93773}, "CVE-2023-34540": {"epss_score": 0.01322, "epss_percentile": 0.7945}, "CVE-2023-34541": {"epss_score": 0.00116, "epss_percentile": 0.31158}, "CVE-2023-34545": {"epss_score": 0.00293, "epss_percentile": 0.52306}, "CVE-2023-34548": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-34551": {"epss_score": 0.02815, "epss_percentile": 0.85729}, "CVE-2023-34552": {"epss_score": 0.0067, "epss_percentile": 0.70786}, "CVE-2023-34553": {"epss_score": 0.0004, "epss_percentile": 0.12078}, "CVE-2023-34561": {"epss_score": 0.00362, "epss_percentile": 0.57791}, "CVE-2023-34563": {"epss_score": 0.18517, "epss_percentile": 0.95027}, "CVE-2023-34565": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-34566": {"epss_score": 0.00172, "epss_percentile": 0.38954}, "CVE-2023-34567": {"epss_score": 0.00031, "epss_percentile": 0.08678}, "CVE-2023-34568": {"epss_score": 0.00034, "epss_percentile": 0.09773}, "CVE-2023-34569": {"epss_score": 0.00034, "epss_percentile": 0.09773}, "CVE-2023-34570": {"epss_score": 0.00034, "epss_percentile": 0.09773}, "CVE-2023-34571": {"epss_score": 0.00034, "epss_percentile": 0.09773}, "CVE-2023-34575": {"epss_score": 0.00269, "epss_percentile": 0.50121}, "CVE-2023-34576": {"epss_score": 0.00216, "epss_percentile": 0.44202}, "CVE-2023-34577": {"epss_score": 0.00269, "epss_percentile": 0.50121}, "CVE-2023-34581": {"epss_score": 0.00235, "epss_percentile": 0.46215}, "CVE-2023-34596": {"epss_score": 0.00033, "epss_percentile": 0.09157}, "CVE-2023-34597": {"epss_score": 0.00033, "epss_percentile": 0.09157}, "CVE-2023-34598": {"epss_score": 0.90829, "epss_percentile": 0.99603}, "CVE-2023-34599": {"epss_score": 0.49308, "epss_percentile": 0.97678}, "CVE-2023-34600": {"epss_score": 0.58077, "epss_percentile": 0.98099}, "CVE-2023-34601": {"epss_score": 0.00061, "epss_percentile": 0.19501}, "CVE-2023-34602": {"epss_score": 0.00353, "epss_percentile": 0.57185}, "CVE-2023-34603": {"epss_score": 0.00254, "epss_percentile": 0.48514}, "CVE-2023-34609": {"epss_score": 0.00193, "epss_percentile": 0.41489}, "CVE-2023-34610": {"epss_score": 0.00117, "epss_percentile": 0.31221}, "CVE-2023-34611": {"epss_score": 0.00063, "epss_percentile": 0.19987}, "CVE-2023-34612": {"epss_score": 0.00125, "epss_percentile": 0.32549}, "CVE-2023-34613": {"epss_score": 0.00074, "epss_percentile": 0.22835}, "CVE-2023-34614": {"epss_score": 0.00068, "epss_percentile": 0.21303}, "CVE-2023-34615": {"epss_score": 0.00069, "epss_percentile": 0.21545}, "CVE-2023-34616": {"epss_score": 0.00063, "epss_percentile": 0.19987}, "CVE-2023-34617": {"epss_score": 0.00063, "epss_percentile": 0.19987}, "CVE-2023-34620": {"epss_score": 0.00125, "epss_percentile": 0.32549}, "CVE-2023-34623": {"epss_score": 0.00055, "epss_percentile": 0.17549}, "CVE-2023-34624": {"epss_score": 0.00167, "epss_percentile": 0.3834}, "CVE-2023-34625": {"epss_score": 0.00022, "epss_percentile": 0.04991}, "CVE-2023-34626": {"epss_score": 0.00264, "epss_percentile": 0.49579}, "CVE-2023-34634": {"epss_score": 0.3751, "epss_percentile": 0.97051}, "CVE-2023-34635": {"epss_score": 0.00175, "epss_percentile": 0.39295}, "CVE-2023-34637": {"epss_score": 0.00106, "epss_percentile": 0.29448}, "CVE-2023-34641": {"epss_score": 0.00046, "epss_percentile": 0.14093}, "CVE-2023-34642": {"epss_score": 0.00064, "epss_percentile": 0.20147}, "CVE-2023-34644": {"epss_score": 0.08544, "epss_percentile": 0.92114}, "CVE-2023-34645": {"epss_score": 0.00094, "epss_percentile": 0.27007}, "CVE-2023-34647": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2023-34648": {"epss_score": 0.00225, "epss_percentile": 0.45141}, "CVE-2023-34650": {"epss_score": 0.00305, "epss_percentile": 0.53333}, "CVE-2023-34651": {"epss_score": 0.00305, "epss_percentile": 0.53333}, "CVE-2023-34652": {"epss_score": 0.00305, "epss_percentile": 0.53333}, "CVE-2023-34654": {"epss_score": 0.00128, "epss_percentile": 0.33042}, "CVE-2023-34656": {"epss_score": 0.00084, "epss_percentile": 0.24851}, "CVE-2023-34657": {"epss_score": 0.00064, "epss_percentile": 0.20299}, "CVE-2023-34658": {"epss_score": 0.00065, "epss_percentile": 0.20469}, "CVE-2023-34659": {"epss_score": 0.91195, "epss_percentile": 0.99626}, "CVE-2023-34660": {"epss_score": 0.00068, "epss_percentile": 0.21193}, "CVE-2023-34666": {"epss_score": 0.00105, "epss_percentile": 0.29391}, "CVE-2023-34669": {"epss_score": 0.00079, "epss_percentile": 0.23951}, "CVE-2023-34671": {"epss_score": 0.00116, "epss_percentile": 0.31135}, "CVE-2023-34672": {"epss_score": 0.00076, "epss_percentile": 0.23102}, "CVE-2023-34673": {"epss_score": 0.00091, "epss_percentile": 0.26214}, "CVE-2023-34723": {"epss_score": 0.05114, "epss_percentile": 0.89513}, "CVE-2023-34724": {"epss_score": 0.00053, "epss_percentile": 0.1691}, "CVE-2023-34725": {"epss_score": 0.00044, "epss_percentile": 0.13453}, "CVE-2023-34732": {"epss_score": 0.00035, "epss_percentile": 0.09875}, "CVE-2023-34733": {"epss_score": 0.00044, "epss_percentile": 0.13422}, "CVE-2023-34734": {"epss_score": 0.00149, "epss_percentile": 0.36041}, "CVE-2023-34735": {"epss_score": 0.00071, "epss_percentile": 0.22138}, "CVE-2023-34736": {"epss_score": 0.00103, "epss_percentile": 0.29055}, "CVE-2023-34738": {"epss_score": 0.00157, "epss_percentile": 0.37068}, "CVE-2023-34747": {"epss_score": 0.2608, "epss_percentile": 0.96108}, "CVE-2023-34750": {"epss_score": 0.00402, "epss_percentile": 0.60302}, "CVE-2023-34751": {"epss_score": 0.33243, "epss_percentile": 0.96755}, "CVE-2023-34752": {"epss_score": 0.30198, "epss_percentile": 0.96518}, "CVE-2023-34753": {"epss_score": 0.33243, "epss_percentile": 0.96755}, "CVE-2023-34754": {"epss_score": 0.10342, "epss_percentile": 0.9295}, "CVE-2023-34755": {"epss_score": 0.33243, "epss_percentile": 0.96755}, "CVE-2023-34756": {"epss_score": 0.33243, "epss_percentile": 0.96755}, "CVE-2023-34758": {"epss_score": 0.0005, "epss_percentile": 0.15838}, "CVE-2023-34761": {"epss_score": 0.00029, "epss_percentile": 0.0761}, "CVE-2023-34795": {"epss_score": 0.00032, "epss_percentile": 0.09043}, "CVE-2023-34796": {"epss_score": 0.00858, "epss_percentile": 0.74501}, "CVE-2023-34797": {"epss_score": 0.00068, "epss_percentile": 0.21342}, "CVE-2023-34798": {"epss_score": 0.00115, "epss_percentile": 0.30945}, "CVE-2023-34800": {"epss_score": 0.68946, "epss_percentile": 0.98569}, "CVE-2023-34823": {"epss_score": 0.00037, "epss_percentile": 0.10937}, "CVE-2023-34824": {"epss_score": 0.00037, "epss_percentile": 0.10937}, "CVE-2023-34829": {"epss_score": 0.00027, "epss_percentile": 0.06897}, "CVE-2023-34830": {"epss_score": 0.00549, "epss_percentile": 0.67297}, "CVE-2023-34831": {"epss_score": 0.00623, "epss_percentile": 0.69555}, "CVE-2023-34832": {"epss_score": 0.00134, "epss_percentile": 0.33826}, "CVE-2023-34833": {"epss_score": 0.00124, "epss_percentile": 0.32431}, "CVE-2023-34834": {"epss_score": 0.02659, "epss_percentile": 0.85363}, "CVE-2023-34835": {"epss_score": 0.01362, "epss_percentile": 0.7976}, "CVE-2023-34836": {"epss_score": 0.0158, "epss_percentile": 0.81132}, "CVE-2023-34837": {"epss_score": 0.0158, "epss_percentile": 0.81132}, "CVE-2023-34838": {"epss_score": 0.0158, "epss_percentile": 0.81132}, "CVE-2023-34839": {"epss_score": 0.00808, "epss_percentile": 0.737}, "CVE-2023-34840": {"epss_score": 0.00269, "epss_percentile": 0.50116}, "CVE-2023-34842": {"epss_score": 0.0214, "epss_percentile": 0.83747}, "CVE-2023-34843": {"epss_score": 0.91885, "epss_percentile": 0.99675}, "CVE-2023-34844": {"epss_score": 0.00099, "epss_percentile": 0.28363}, "CVE-2023-34845": {"epss_score": 0.00504, "epss_percentile": 0.65525}, "CVE-2023-34849": {"epss_score": 0.01322, "epss_percentile": 0.79449}, "CVE-2023-34852": {"epss_score": 0.00388, "epss_percentile": 0.59361}, "CVE-2023-34853": {"epss_score": 0.00133, "epss_percentile": 0.33682}, "CVE-2023-34855": {"epss_score": 0.00066, "epss_percentile": 0.20733}, "CVE-2023-34856": {"epss_score": 0.00086, "epss_percentile": 0.25358}, "CVE-2023-34865": {"epss_score": 0.00785, "epss_percentile": 0.73258}, "CVE-2023-34867": {"epss_score": 0.0009, "epss_percentile": 0.26094}, "CVE-2023-34868": {"epss_score": 0.0009, "epss_percentile": 0.26094}, "CVE-2023-34869": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-34872": {"epss_score": 0.00166, "epss_percentile": 0.38144}, "CVE-2023-34873": {"epss_score": 0.00117, "epss_percentile": 0.31372}, "CVE-2023-34878": {"epss_score": 0.00193, "epss_percentile": 0.41378}, "CVE-2023-34880": {"epss_score": 0.00174, "epss_percentile": 0.39217}, "CVE-2023-34916": {"epss_score": 0.00174, "epss_percentile": 0.39259}, "CVE-2023-34917": {"epss_score": 0.00183, "epss_percentile": 0.40353}, "CVE-2023-34923": {"epss_score": 0.00273, "epss_percentile": 0.50451}, "CVE-2023-34924": {"epss_score": 0.00147, "epss_percentile": 0.35773}, "CVE-2023-34927": {"epss_score": 0.00275, "epss_percentile": 0.50668}, "CVE-2023-34928": {"epss_score": 0.01831, "epss_percentile": 0.82449}, "CVE-2023-34929": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-34930": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-34931": {"epss_score": 0.00088, "epss_percentile": 0.25679}, "CVE-2023-34932": {"epss_score": 0.00088, "epss_percentile": 0.25679}, "CVE-2023-34933": {"epss_score": 0.00098, "epss_percentile": 0.27819}, "CVE-2023-34934": {"epss_score": 0.00098, "epss_percentile": 0.27819}, "CVE-2023-34935": {"epss_score": 0.00098, "epss_percentile": 0.27819}, "CVE-2023-34936": {"epss_score": 0.00098, "epss_percentile": 0.27819}, "CVE-2023-34937": {"epss_score": 0.00088, "epss_percentile": 0.25679}, "CVE-2023-34939": {"epss_score": 0.12428, "epss_percentile": 0.93667}, "CVE-2023-34940": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-34941": {"epss_score": 0.0517, "epss_percentile": 0.89569}, "CVE-2023-34942": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-34944": {"epss_score": 0.00489, "epss_percentile": 0.64902}, "CVE-2023-34958": {"epss_score": 0.0014, "epss_percentile": 0.34709}, "CVE-2023-34959": {"epss_score": 0.00256, "epss_percentile": 0.4882}, "CVE-2023-34960": {"epss_score": 0.94089, "epss_percentile": 0.999}, "CVE-2023-34961": {"epss_score": 0.00435, "epss_percentile": 0.62365}, "CVE-2023-34962": {"epss_score": 0.00233, "epss_percentile": 0.46027}, "CVE-2023-34965": {"epss_score": 0.00285, "epss_percentile": 0.51532}, "CVE-2023-34966": {"epss_score": 0.13565, "epss_percentile": 0.93998}, "CVE-2023-34967": {"epss_score": 0.18271, "epss_percentile": 0.94986}, "CVE-2023-34968": {"epss_score": 0.02387, "epss_percentile": 0.84581}, "CVE-2023-34969": {"epss_score": 0.00829, "epss_percentile": 0.74014}, "CVE-2023-34970": {"epss_score": 0.00066, "epss_percentile": 0.20771}, "CVE-2023-34971": {"epss_score": 0.00039, "epss_percentile": 0.11836}, "CVE-2023-34972": {"epss_score": 0.0004, "epss_percentile": 0.11923}, "CVE-2023-34973": {"epss_score": 0.00197, "epss_percentile": 0.4187}, "CVE-2023-34974": {"epss_score": 0.00321, "epss_percentile": 0.54689}, "CVE-2023-34975": {"epss_score": 0.00081, "epss_percentile": 0.24279}, "CVE-2023-34976": {"epss_score": 0.00059, "epss_percentile": 0.18828}, "CVE-2023-34977": {"epss_score": 0.002, "epss_percentile": 0.42236}, "CVE-2023-34979": {"epss_score": 0.00069, "epss_percentile": 0.21487}, "CVE-2023-34980": {"epss_score": 0.00049, "epss_percentile": 0.15296}, "CVE-2023-34981": {"epss_score": 0.00258, "epss_percentile": 0.4895}, "CVE-2023-34982": {"epss_score": 0.00089, "epss_percentile": 0.25811}, "CVE-2023-34983": {"epss_score": 0.00047, "epss_percentile": 0.14854}, "CVE-2023-34984": {"epss_score": 0.00367, "epss_percentile": 0.58102}, "CVE-2023-34985": {"epss_score": 0.01478, "epss_percentile": 0.80551}, "CVE-2023-34986": {"epss_score": 0.01478, "epss_percentile": 0.80551}, "CVE-2023-34987": {"epss_score": 0.01478, "epss_percentile": 0.80551}, "CVE-2023-34988": {"epss_score": 0.01478, "epss_percentile": 0.80551}, "CVE-2023-34989": {"epss_score": 0.01478, "epss_percentile": 0.80551}, "CVE-2023-34990": {"epss_score": 0.31763, "epss_percentile": 0.96646}, "CVE-2023-34991": {"epss_score": 0.08018, "epss_percentile": 0.91832}, "CVE-2023-34992": {"epss_score": 0.78472, "epss_percentile": 0.98987}, "CVE-2023-34993": {"epss_score": 0.86419, "epss_percentile": 0.99381}, "CVE-2023-34994": {"epss_score": 0.00056, "epss_percentile": 0.17893}, "CVE-2023-34995": {"epss_score": 0.00104, "epss_percentile": 0.29146}, "CVE-2023-34997": {"epss_score": 0.00048, "epss_percentile": 0.15189}, "CVE-2023-34998": {"epss_score": 9e-05, "epss_percentile": 0.00616}, "CVE-2023-34999": {"epss_score": 0.00062, "epss_percentile": 0.1978}, "CVE-2023-35001": {"epss_score": 0.00247, "epss_percentile": 0.47819}, "CVE-2023-35002": {"epss_score": 0.00411, "epss_percentile": 0.60879}, "CVE-2023-35003": {"epss_score": 0.00091, "epss_percentile": 0.26204}, "CVE-2023-35004": {"epss_score": 0.00055, "epss_percentile": 0.17442}, "CVE-2023-35005": {"epss_score": 0.00187, "epss_percentile": 0.40737}, "CVE-2023-35006": {"epss_score": 0.00097, "epss_percentile": 0.27595}, "CVE-2023-35009": {"epss_score": 0.00059, "epss_percentile": 0.18733}, "CVE-2023-35011": {"epss_score": 0.00053, "epss_percentile": 0.16899}, "CVE-2023-35012": {"epss_score": 0.00023, "epss_percentile": 0.05407}, "CVE-2023-35013": {"epss_score": 0.00024, "epss_percentile": 0.05955}, "CVE-2023-35016": {"epss_score": 0.00063, "epss_percentile": 0.19845}, "CVE-2023-35017": {"epss_score": 0.00013, "epss_percentile": 0.01492}, "CVE-2023-35018": {"epss_score": 0.00069, "epss_percentile": 0.21427}, "CVE-2023-35019": {"epss_score": 0.00112, "epss_percentile": 0.30481}, "CVE-2023-35020": {"epss_score": 0.00065, "epss_percentile": 0.20442}, "CVE-2023-35022": {"epss_score": 0.00011, "epss_percentile": 0.00957}, "CVE-2023-35024": {"epss_score": 0.00062, "epss_percentile": 0.19782}, "CVE-2023-35029": {"epss_score": 0.00302, "epss_percentile": 0.53104}, "CVE-2023-35030": {"epss_score": 0.01011, "epss_percentile": 0.76613}, "CVE-2023-35031": {"epss_score": 0.02252, "epss_percentile": 0.84163}, "CVE-2023-35032": {"epss_score": 0.01974, "epss_percentile": 0.83114}, "CVE-2023-35033": {"epss_score": 0.02252, "epss_percentile": 0.84163}, "CVE-2023-35034": {"epss_score": 0.02985, "epss_percentile": 0.8613}, "CVE-2023-35035": {"epss_score": 0.02252, "epss_percentile": 0.84163}, "CVE-2023-35036": {"epss_score": 0.34331, "epss_percentile": 0.96843}, "CVE-2023-35037": {"epss_score": 0.00184, "epss_percentile": 0.40412}, "CVE-2023-35038": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-35039": {"epss_score": 0.00681, "epss_percentile": 0.7106}, "CVE-2023-35040": {"epss_score": 0.00401, "epss_percentile": 0.60217}, "CVE-2023-35041": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-35042": {"epss_score": 0.31141, "epss_percentile": 0.96597}, "CVE-2023-35043": {"epss_score": 0.00087, "epss_percentile": 0.25547}, "CVE-2023-35044": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-35045": {"epss_score": 0.00168, "epss_percentile": 0.38425}, "CVE-2023-35046": {"epss_score": 0.00108, "epss_percentile": 0.29857}, "CVE-2023-35047": {"epss_score": 0.0007, "epss_percentile": 0.21758}, "CVE-2023-35048": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-35049": {"epss_score": 0.00353, "epss_percentile": 0.57191}, "CVE-2023-35050": {"epss_score": 0.00096, "epss_percentile": 0.27377}, "CVE-2023-35051": {"epss_score": 0.00233, "epss_percentile": 0.45971}, "CVE-2023-35052": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2023-35053": {"epss_score": 3e-05, "epss_percentile": 0.00066}, "CVE-2023-35054": {"epss_score": 0.00041, "epss_percentile": 0.1228}, "CVE-2023-35055": {"epss_score": 0.00262, "epss_percentile": 0.49394}, "CVE-2023-35056": {"epss_score": 0.00262, "epss_percentile": 0.49394}, "CVE-2023-35057": {"epss_score": 0.00031, "epss_percentile": 0.08442}, "CVE-2023-35060": {"epss_score": 0.00144, "epss_percentile": 0.35344}, "CVE-2023-35061": {"epss_score": 0.0008, "epss_percentile": 0.24111}, "CVE-2023-35062": {"epss_score": 0.00047, "epss_percentile": 0.14482}, "CVE-2023-35064": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-35065": {"epss_score": 0.00061, "epss_percentile": 0.19515}, "CVE-2023-35066": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-35067": {"epss_score": 0.00082, "epss_percentile": 0.24462}, "CVE-2023-35068": {"epss_score": 0.00061, "epss_percentile": 0.19515}, "CVE-2023-35069": {"epss_score": 0.00105, "epss_percentile": 0.29361}, "CVE-2023-35070": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-35071": {"epss_score": 0.0015, "epss_percentile": 0.36084}, "CVE-2023-35072": {"epss_score": 0.00061, "epss_percentile": 0.19515}, "CVE-2023-35074": {"epss_score": 0.00598, "epss_percentile": 0.68766}, "CVE-2023-35075": {"epss_score": 0.0051, "epss_percentile": 0.65768}, "CVE-2023-35077": {"epss_score": 0.01048, "epss_percentile": 0.77056}, "CVE-2023-35078": {"epss_score": 0.94482, "epss_percentile": 0.99998}, "CVE-2023-35080": {"epss_score": 0.00412, "epss_percentile": 0.60937}, "CVE-2023-35081": {"epss_score": 0.9272, "epss_percentile": 0.99739}, "CVE-2023-35082": {"epss_score": 0.94423, "epss_percentile": 0.99979}, "CVE-2023-35083": {"epss_score": 0.01167, "epss_percentile": 0.78186}, "CVE-2023-35084": {"epss_score": 0.01627, "epss_percentile": 0.81432}, "CVE-2023-35085": {"epss_score": 0.05402, "epss_percentile": 0.89833}, "CVE-2023-35086": {"epss_score": 0.73869, "epss_percentile": 0.98774}, "CVE-2023-35087": {"epss_score": 0.01058, "epss_percentile": 0.77138}, "CVE-2023-35088": {"epss_score": 0.00513, "epss_percentile": 0.6593}, "CVE-2023-35089": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-35090": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-35091": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-35092": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-35093": {"epss_score": 0.00219, "epss_percentile": 0.44528}, "CVE-2023-35094": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-35095": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-35096": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-35097": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-35098": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-35110": {"epss_score": 0.00172, "epss_percentile": 0.38933}, "CVE-2023-35116": {"epss_score": 0.00019, "epss_percentile": 0.04078}, "CVE-2023-35120": {"epss_score": 0.00075, "epss_percentile": 0.23053}, "CVE-2023-35121": {"epss_score": 0.00043, "epss_percentile": 0.13352}, "CVE-2023-35123": {"epss_score": 0.00115, "epss_percentile": 0.30893}, "CVE-2023-35124": {"epss_score": 0.00093, "epss_percentile": 0.26729}, "CVE-2023-35126": {"epss_score": 0.00158, "epss_percentile": 0.37293}, "CVE-2023-35127": {"epss_score": 0.00103, "epss_percentile": 0.29035}, "CVE-2023-35128": {"epss_score": 0.0003, "epss_percentile": 0.08308}, "CVE-2023-35131": {"epss_score": 0.00594, "epss_percentile": 0.68667}, "CVE-2023-35132": {"epss_score": 0.00222, "epss_percentile": 0.44776}, "CVE-2023-35133": {"epss_score": 0.0028, "epss_percentile": 0.51089}, "CVE-2023-35134": {"epss_score": 0.00068, "epss_percentile": 0.21353}, "CVE-2023-35136": {"epss_score": 0.00085, "epss_percentile": 0.25218}, "CVE-2023-35137": {"epss_score": 0.00124, "epss_percentile": 0.32339}, "CVE-2023-35138": {"epss_score": 0.10519, "epss_percentile": 0.93016}, "CVE-2023-35139": {"epss_score": 0.00118, "epss_percentile": 0.31398}, "CVE-2023-35140": {"epss_score": 0.00045, "epss_percentile": 0.13784}, "CVE-2023-35141": {"epss_score": 0.00092, "epss_percentile": 0.2642}, "CVE-2023-35142": {"epss_score": 0.00068, "epss_percentile": 0.21242}, "CVE-2023-35143": {"epss_score": 0.03906, "epss_percentile": 0.87929}, "CVE-2023-35144": {"epss_score": 0.03606, "epss_percentile": 0.87416}, "CVE-2023-35145": {"epss_score": 0.00446, "epss_percentile": 0.6291}, "CVE-2023-35146": {"epss_score": 0.09955, "epss_percentile": 0.9279}, "CVE-2023-35147": {"epss_score": 0.00067, "epss_percentile": 0.21082}, "CVE-2023-35148": {"epss_score": 0.00102, "epss_percentile": 0.28841}, "CVE-2023-35149": {"epss_score": 0.00067, "epss_percentile": 0.21082}, "CVE-2023-35150": {"epss_score": 0.3348, "epss_percentile": 0.96777}, "CVE-2023-35151": {"epss_score": 0.00208, "epss_percentile": 0.43264}, "CVE-2023-35152": {"epss_score": 0.00907, "epss_percentile": 0.75272}, "CVE-2023-35153": {"epss_score": 0.02094, "epss_percentile": 0.8358}, "CVE-2023-35154": {"epss_score": 0.00181, "epss_percentile": 0.40029}, "CVE-2023-35155": {"epss_score": 0.40467, "epss_percentile": 0.9722}, "CVE-2023-35156": {"epss_score": 0.09278, "epss_percentile": 0.9248}, "CVE-2023-35157": {"epss_score": 0.01237, "epss_percentile": 0.78777}, "CVE-2023-35158": {"epss_score": 0.07644, "epss_percentile": 0.91598}, "CVE-2023-35159": {"epss_score": 0.03375, "epss_percentile": 0.87017}, "CVE-2023-35160": {"epss_score": 0.12078, "epss_percentile": 0.93561}, "CVE-2023-35161": {"epss_score": 0.12078, "epss_percentile": 0.93561}, "CVE-2023-35162": {"epss_score": 0.12078, "epss_percentile": 0.93561}, "CVE-2023-35163": {"epss_score": 0.00061, "epss_percentile": 0.19388}, "CVE-2023-35164": {"epss_score": 0.00061, "epss_percentile": 0.19501}, "CVE-2023-35165": {"epss_score": 0.00049, "epss_percentile": 0.15317}, "CVE-2023-35166": {"epss_score": 0.30217, "epss_percentile": 0.9652}, "CVE-2023-35167": {"epss_score": 0.00055, "epss_percentile": 0.17529}, "CVE-2023-35168": {"epss_score": 0.00063, "epss_percentile": 0.19912}, "CVE-2023-35169": {"epss_score": 0.04725, "epss_percentile": 0.89061}, "CVE-2023-35171": {"epss_score": 0.00339, "epss_percentile": 0.56206}, "CVE-2023-35172": {"epss_score": 0.00497, "epss_percentile": 0.65187}, "CVE-2023-35173": {"epss_score": 0.00185, "epss_percentile": 0.4058}, "CVE-2023-35174": {"epss_score": 0.00463, "epss_percentile": 0.63666}, "CVE-2023-35175": {"epss_score": 0.0342, "epss_percentile": 0.871}, "CVE-2023-35176": {"epss_score": 0.00287, "epss_percentile": 0.51839}, "CVE-2023-35177": {"epss_score": 0.00238, "epss_percentile": 0.46754}, "CVE-2023-35178": {"epss_score": 0.00238, "epss_percentile": 0.46754}, "CVE-2023-35179": {"epss_score": 0.00064, "epss_percentile": 0.20296}, "CVE-2023-35180": {"epss_score": 0.49133, "epss_percentile": 0.9767}, "CVE-2023-35181": {"epss_score": 0.00107, "epss_percentile": 0.29659}, "CVE-2023-35182": {"epss_score": 0.04645, "epss_percentile": 0.88959}, "CVE-2023-35183": {"epss_score": 0.00076, "epss_percentile": 0.23096}, "CVE-2023-35184": {"epss_score": 0.10596, "epss_percentile": 0.93041}, "CVE-2023-35185": {"epss_score": 0.00151, "epss_percentile": 0.36259}, "CVE-2023-35186": {"epss_score": 0.09608, "epss_percentile": 0.9262}, "CVE-2023-35187": {"epss_score": 0.02021, "epss_percentile": 0.83296}, "CVE-2023-35188": {"epss_score": 0.00998, "epss_percentile": 0.76473}, "CVE-2023-35189": {"epss_score": 0.00327, "epss_percentile": 0.5513}, "CVE-2023-35191": {"epss_score": 0.00035, "epss_percentile": 0.09816}, "CVE-2023-35192": {"epss_score": 0.00168, "epss_percentile": 0.38425}, "CVE-2023-35193": {"epss_score": 0.00296, "epss_percentile": 0.52624}, "CVE-2023-35194": {"epss_score": 0.00296, "epss_percentile": 0.52624}, "CVE-2023-35296": {"epss_score": 0.04108, "epss_percentile": 0.88268}, "CVE-2023-35297": {"epss_score": 0.00265, "epss_percentile": 0.49827}, "CVE-2023-35298": {"epss_score": 0.00756, "epss_percentile": 0.72728}, "CVE-2023-35299": {"epss_score": 0.00167, "epss_percentile": 0.38296}, "CVE-2023-35300": {"epss_score": 0.02829, "epss_percentile": 0.85771}, "CVE-2023-35302": {"epss_score": 0.03462, "epss_percentile": 0.87183}, "CVE-2023-35303": {"epss_score": 0.00672, "epss_percentile": 0.70825}, "CVE-2023-35304": {"epss_score": 0.00123, "epss_percentile": 0.32196}, "CVE-2023-35305": {"epss_score": 0.00123, "epss_percentile": 0.32196}, "CVE-2023-35306": {"epss_score": 0.00245, "epss_percentile": 0.47658}, "CVE-2023-35308": {"epss_score": 0.01019, "epss_percentile": 0.76722}, "CVE-2023-35309": {"epss_score": 0.00691, "epss_percentile": 0.71263}, "CVE-2023-35310": {"epss_score": 0.00224, "epss_percentile": 0.45001}, "CVE-2023-35311": {"epss_score": 0.00475, "epss_percentile": 0.64178}, "CVE-2023-35312": {"epss_score": 0.00394, "epss_percentile": 0.59793}, "CVE-2023-35313": {"epss_score": 0.00508, "epss_percentile": 0.65712}, "CVE-2023-35314": {"epss_score": 0.03672, "epss_percentile": 0.87545}, "CVE-2023-35315": {"epss_score": 0.0036, "epss_percentile": 0.57636}, "CVE-2023-35316": {"epss_score": 0.0339, "epss_percentile": 0.87048}, "CVE-2023-35317": {"epss_score": 0.0011, "epss_percentile": 0.30103}, "CVE-2023-35318": {"epss_score": 0.03672, "epss_percentile": 0.87545}, "CVE-2023-35319": {"epss_score": 0.03672, "epss_percentile": 0.87545}, "CVE-2023-35320": {"epss_score": 0.0014, "epss_percentile": 0.34719}, "CVE-2023-35321": {"epss_score": 0.0363, "epss_percentile": 0.87472}, "CVE-2023-35322": {"epss_score": 0.026, "epss_percentile": 0.85206}, "CVE-2023-35323": {"epss_score": 0.01037, "epss_percentile": 0.7693}, "CVE-2023-35324": {"epss_score": 0.00229, "epss_percentile": 0.45641}, "CVE-2023-35325": {"epss_score": 0.00863, "epss_percentile": 0.74586}, "CVE-2023-35326": {"epss_score": 0.00108, "epss_percentile": 0.2986}, "CVE-2023-35328": {"epss_score": 0.00115, "epss_percentile": 0.30953}, "CVE-2023-35329": {"epss_score": 0.00792, "epss_percentile": 0.73412}, "CVE-2023-35330": {"epss_score": 0.01077, "epss_percentile": 0.77341}, "CVE-2023-35331": {"epss_score": 0.00157, "epss_percentile": 0.3704}, "CVE-2023-35332": {"epss_score": 0.0006, "epss_percentile": 0.19148}, "CVE-2023-35333": {"epss_score": 0.018, "epss_percentile": 0.82317}, "CVE-2023-35335": {"epss_score": 0.00225, "epss_percentile": 0.45149}, "CVE-2023-35336": {"epss_score": 0.00579, "epss_percentile": 0.68222}, "CVE-2023-35337": {"epss_score": 0.00136, "epss_percentile": 0.34149}, "CVE-2023-35338": {"epss_score": 0.03356, "epss_percentile": 0.86974}, "CVE-2023-35339": {"epss_score": 0.00762, "epss_percentile": 0.7284}, "CVE-2023-35340": {"epss_score": 0.00076, "epss_percentile": 0.2315}, "CVE-2023-35341": {"epss_score": 0.00243, "epss_percentile": 0.47474}, "CVE-2023-35342": {"epss_score": 0.0014, "epss_percentile": 0.34719}, "CVE-2023-35343": {"epss_score": 0.00324, "epss_percentile": 0.54953}, "CVE-2023-35344": {"epss_score": 0.00226, "epss_percentile": 0.45254}, "CVE-2023-35345": {"epss_score": 0.00226, "epss_percentile": 0.45254}, "CVE-2023-35346": {"epss_score": 0.00226, "epss_percentile": 0.45254}, "CVE-2023-35347": {"epss_score": 0.00136, "epss_percentile": 0.34169}, "CVE-2023-35348": {"epss_score": 0.00439, "epss_percentile": 0.62584}, "CVE-2023-35349": {"epss_score": 0.01159, "epss_percentile": 0.78125}, "CVE-2023-35350": {"epss_score": 0.01242, "epss_percentile": 0.78822}, "CVE-2023-35351": {"epss_score": 0.00293, "epss_percentile": 0.52302}, "CVE-2023-35352": {"epss_score": 0.03482, "epss_percentile": 0.87221}, "CVE-2023-35353": {"epss_score": 0.00258, "epss_percentile": 0.49011}, "CVE-2023-35355": {"epss_score": 0.0006, "epss_percentile": 0.18987}, "CVE-2023-35356": {"epss_score": 0.00426, "epss_percentile": 0.6173}, "CVE-2023-35357": {"epss_score": 0.00202, "epss_percentile": 0.42433}, "CVE-2023-35358": {"epss_score": 0.00202, "epss_percentile": 0.42433}, "CVE-2023-35359": {"epss_score": 0.02345, "epss_percentile": 0.84447}, "CVE-2023-35360": {"epss_score": 0.00103, "epss_percentile": 0.2905}, "CVE-2023-35361": {"epss_score": 0.00103, "epss_percentile": 0.2905}, "CVE-2023-35362": {"epss_score": 0.00076, "epss_percentile": 0.2315}, "CVE-2023-35363": {"epss_score": 0.00228, "epss_percentile": 0.4554}, "CVE-2023-35364": {"epss_score": 0.00284, "epss_percentile": 0.51417}, "CVE-2023-35365": {"epss_score": 0.0231, "epss_percentile": 0.84335}, "CVE-2023-35366": {"epss_score": 0.02051, "epss_percentile": 0.83401}, "CVE-2023-35367": {"epss_score": 0.02051, "epss_percentile": 0.83401}, "CVE-2023-35368": {"epss_score": 0.00396, "epss_percentile": 0.59876}, "CVE-2023-35371": {"epss_score": 0.00766, "epss_percentile": 0.72938}, "CVE-2023-35372": {"epss_score": 0.00458, "epss_percentile": 0.634}, "CVE-2023-35373": {"epss_score": 0.00605, "epss_percentile": 0.68982}, "CVE-2023-35374": {"epss_score": 0.00826, "epss_percentile": 0.73959}, "CVE-2023-35376": {"epss_score": 0.00951, "epss_percentile": 0.7587}, "CVE-2023-35377": {"epss_score": 0.00951, "epss_percentile": 0.7587}, "CVE-2023-35378": {"epss_score": 0.00076, "epss_percentile": 0.2315}, "CVE-2023-35379": {"epss_score": 0.00105, "epss_percentile": 0.29344}, "CVE-2023-35380": {"epss_score": 0.02219, "epss_percentile": 0.84044}, "CVE-2023-35381": {"epss_score": 0.00261, "epss_percentile": 0.49305}, "CVE-2023-35382": {"epss_score": 0.03282, "epss_percentile": 0.86819}, "CVE-2023-35383": {"epss_score": 0.03199, "epss_percentile": 0.86618}, "CVE-2023-35384": {"epss_score": 0.00144, "epss_percentile": 0.35308}, "CVE-2023-35385": {"epss_score": 0.03195, "epss_percentile": 0.8661}, "CVE-2023-35386": {"epss_score": 0.02888, "epss_percentile": 0.85915}, "CVE-2023-35387": {"epss_score": 0.00341, "epss_percentile": 0.56344}, "CVE-2023-35388": {"epss_score": 0.00446, "epss_percentile": 0.6291}, "CVE-2023-35389": {"epss_score": 0.00074, "epss_percentile": 0.22709}, "CVE-2023-35390": {"epss_score": 0.02009, "epss_percentile": 0.83244}, "CVE-2023-35391": {"epss_score": 0.02103, "epss_percentile": 0.83611}, "CVE-2023-35392": {"epss_score": 0.00135, "epss_percentile": 0.34011}, "CVE-2023-35393": {"epss_score": 0.0027, "epss_percentile": 0.50259}, "CVE-2023-35394": {"epss_score": 0.00202, "epss_percentile": 0.42417}, "CVE-2023-35618": {"epss_score": 0.00477, "epss_percentile": 0.64298}, "CVE-2023-35619": {"epss_score": 0.01357, "epss_percentile": 0.79717}, "CVE-2023-35621": {"epss_score": 0.00555, "epss_percentile": 0.67468}, "CVE-2023-35622": {"epss_score": 0.00282, "epss_percentile": 0.5127}, "CVE-2023-35624": {"epss_score": 0.00287, "epss_percentile": 0.51809}, "CVE-2023-35625": {"epss_score": 0.00656, "epss_percentile": 0.70435}, "CVE-2023-35628": {"epss_score": 0.17104, "epss_percentile": 0.94775}, "CVE-2023-35629": {"epss_score": 0.00217, "epss_percentile": 0.44283}, "CVE-2023-35630": {"epss_score": 0.0258, "epss_percentile": 0.85151}, "CVE-2023-35631": {"epss_score": 0.0157, "epss_percentile": 0.81092}, "CVE-2023-35632": {"epss_score": 0.04036, "epss_percentile": 0.88157}, "CVE-2023-35633": {"epss_score": 0.02708, "epss_percentile": 0.85477}, "CVE-2023-35634": {"epss_score": 0.00189, "epss_percentile": 0.41003}, "CVE-2023-35635": {"epss_score": 0.00613, "epss_percentile": 0.69246}, "CVE-2023-35636": {"epss_score": 0.11602, "epss_percentile": 0.93416}, "CVE-2023-35638": {"epss_score": 0.00973, "epss_percentile": 0.76161}, "CVE-2023-35639": {"epss_score": 0.00904, "epss_percentile": 0.75221}, "CVE-2023-35641": {"epss_score": 0.05218, "epss_percentile": 0.89621}, "CVE-2023-35642": {"epss_score": 0.00491, "epss_percentile": 0.64957}, "CVE-2023-35643": {"epss_score": 0.00729, "epss_percentile": 0.72135}, "CVE-2023-35644": {"epss_score": 0.04036, "epss_percentile": 0.88157}, "CVE-2023-35645": {"epss_score": 0.00015, "epss_percentile": 0.02187}, "CVE-2023-35646": {"epss_score": 0.02782, "epss_percentile": 0.85652}, "CVE-2023-35647": {"epss_score": 0.00709, "epss_percentile": 0.71693}, "CVE-2023-35648": {"epss_score": 0.00709, "epss_percentile": 0.71693}, "CVE-2023-35649": {"epss_score": 0.01651, "epss_percentile": 0.8157}, "CVE-2023-35652": {"epss_score": 0.00191, "epss_percentile": 0.41144}, "CVE-2023-35653": {"epss_score": 4e-05, "epss_percentile": 0.00156}, "CVE-2023-35654": {"epss_score": 0.00025, "epss_percentile": 0.06167}, "CVE-2023-35655": {"epss_score": 0.00029, "epss_percentile": 0.07911}, "CVE-2023-35656": {"epss_score": 0.001, "epss_percentile": 0.28492}, "CVE-2023-35657": {"epss_score": 6e-05, "epss_percentile": 0.00247}, "CVE-2023-35658": {"epss_score": 0.00026, "epss_percentile": 0.06488}, "CVE-2023-35659": {"epss_score": 0.00064, "epss_percentile": 0.20351}, "CVE-2023-35660": {"epss_score": 0.00019, "epss_percentile": 0.04394}, "CVE-2023-35661": {"epss_score": 0.00664, "epss_percentile": 0.70641}, "CVE-2023-35662": {"epss_score": 0.02782, "epss_percentile": 0.85652}, "CVE-2023-35663": {"epss_score": 0.001, "epss_percentile": 0.28492}, "CVE-2023-35664": {"epss_score": 0.0002, "epss_percentile": 0.04561}, "CVE-2023-35665": {"epss_score": 0.00012, "epss_percentile": 0.01178}, "CVE-2023-35666": {"epss_score": 0.00013, "epss_percentile": 0.01458}, "CVE-2023-35667": {"epss_score": 0.00011, "epss_percentile": 0.01031}, "CVE-2023-35668": {"epss_score": 0.00028, "epss_percentile": 0.07293}, "CVE-2023-35669": {"epss_score": 0.00017, "epss_percentile": 0.0333}, "CVE-2023-35670": {"epss_score": 0.00024, "epss_percentile": 0.05991}, "CVE-2023-35671": {"epss_score": 0.00191, "epss_percentile": 0.41264}, "CVE-2023-35673": {"epss_score": 0.00025, "epss_percentile": 0.06358}, "CVE-2023-35674": {"epss_score": 0.00087, "epss_percentile": 0.25622}, "CVE-2023-35675": {"epss_score": 0.00019, "epss_percentile": 0.041}, "CVE-2023-35676": {"epss_score": 0.00012, "epss_percentile": 0.01178}, "CVE-2023-35677": {"epss_score": 0.00015, "epss_percentile": 0.0223}, "CVE-2023-35679": {"epss_score": 0.00023, "epss_percentile": 0.0563}, "CVE-2023-35680": {"epss_score": 0.00023, "epss_percentile": 0.0551}, "CVE-2023-35681": {"epss_score": 0.00629, "epss_percentile": 0.6968}, "CVE-2023-35682": {"epss_score": 0.00017, "epss_percentile": 0.03482}, "CVE-2023-35683": {"epss_score": 0.00017, "epss_percentile": 0.03353}, "CVE-2023-35684": {"epss_score": 0.00026, "epss_percentile": 0.06488}, "CVE-2023-35685": {"epss_score": 0.0003, "epss_percentile": 0.08081}, "CVE-2023-35686": {"epss_score": 0.00035, "epss_percentile": 0.09926}, "CVE-2023-35687": {"epss_score": 0.00011, "epss_percentile": 0.01075}, "CVE-2023-35689": {"epss_score": 0.00011, "epss_percentile": 0.01032}, "CVE-2023-35690": {"epss_score": 0.00105, "epss_percentile": 0.29305}, "CVE-2023-35691": {"epss_score": 0.0064, "epss_percentile": 0.69969}, "CVE-2023-35692": {"epss_score": 0.0001, "epss_percentile": 0.0089}, "CVE-2023-35693": {"epss_score": 0.00013, "epss_percentile": 0.01434}, "CVE-2023-35694": {"epss_score": 0.00358, "epss_percentile": 0.57511}, "CVE-2023-35695": {"epss_score": 0.00157, "epss_percentile": 0.37086}, "CVE-2023-35696": {"epss_score": 0.00143, "epss_percentile": 0.35205}, "CVE-2023-35697": {"epss_score": 0.00272, "epss_percentile": 0.50418}, "CVE-2023-35698": {"epss_score": 0.00217, "epss_percentile": 0.44291}, "CVE-2023-35699": {"epss_score": 0.0004, "epss_percentile": 0.11869}, "CVE-2023-35701": {"epss_score": 0.00417, "epss_percentile": 0.61232}, "CVE-2023-35702": {"epss_score": 0.00038, "epss_percentile": 0.11367}, "CVE-2023-35703": {"epss_score": 0.00046, "epss_percentile": 0.14092}, "CVE-2023-35704": {"epss_score": 0.00046, "epss_percentile": 0.14274}, "CVE-2023-35708": {"epss_score": 0.28841, "epss_percentile": 0.96393}, "CVE-2023-35709": {"epss_score": 0.00779, "epss_percentile": 0.7315}, "CVE-2023-35710": {"epss_score": 0.01188, "epss_percentile": 0.78361}, "CVE-2023-35711": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-35712": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-35713": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-35714": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-35715": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-35716": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-35717": {"epss_score": 0.00046, "epss_percentile": 0.1414}, "CVE-2023-35718": {"epss_score": 0.02285, "epss_percentile": 0.84265}, "CVE-2023-35719": {"epss_score": 0.00109, "epss_percentile": 0.30026}, "CVE-2023-35720": {"epss_score": 0.00157, "epss_percentile": 0.37078}, "CVE-2023-35721": {"epss_score": 0.04182, "epss_percentile": 0.88358}, "CVE-2023-35722": {"epss_score": 0.00819, "epss_percentile": 0.73867}, "CVE-2023-35723": {"epss_score": 0.00795, "epss_percentile": 0.73469}, "CVE-2023-35724": {"epss_score": 0.00126, "epss_percentile": 0.32694}, "CVE-2023-35725": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-35726": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35727": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35728": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35729": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35730": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35731": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35732": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35733": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35734": {"epss_score": 0.00838, "epss_percentile": 0.7418}, "CVE-2023-35735": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35736": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35737": {"epss_score": 0.01729, "epss_percentile": 0.8198}, "CVE-2023-35738": {"epss_score": 0.01729, "epss_percentile": 0.8198}, "CVE-2023-35739": {"epss_score": 0.01729, "epss_percentile": 0.8198}, "CVE-2023-35740": {"epss_score": 0.01729, "epss_percentile": 0.8198}, "CVE-2023-35741": {"epss_score": 0.01729, "epss_percentile": 0.8198}, "CVE-2023-35742": {"epss_score": 0.01729, "epss_percentile": 0.8198}, "CVE-2023-35743": {"epss_score": 0.0112, "epss_percentile": 0.77766}, "CVE-2023-35744": {"epss_score": 0.07561, "epss_percentile": 0.91542}, "CVE-2023-35745": {"epss_score": 0.01729, "epss_percentile": 0.8198}, "CVE-2023-35746": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35747": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35748": {"epss_score": 0.03496, "epss_percentile": 0.87237}, "CVE-2023-35749": {"epss_score": 0.04312, "epss_percentile": 0.88533}, "CVE-2023-35750": {"epss_score": 0.00266, "epss_percentile": 0.49945}, "CVE-2023-35751": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35752": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35753": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35754": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35755": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35756": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-35757": {"epss_score": 0.03222, "epss_percentile": 0.86675}, "CVE-2023-35759": {"epss_score": 0.00173, "epss_percentile": 0.39077}, "CVE-2023-35762": {"epss_score": 0.00429, "epss_percentile": 0.6199}, "CVE-2023-35763": {"epss_score": 0.00067, "epss_percentile": 0.21056}, "CVE-2023-35764": {"epss_score": 0.00237, "epss_percentile": 0.46644}, "CVE-2023-35765": {"epss_score": 0.00062, "epss_percentile": 0.19573}, "CVE-2023-35767": {"epss_score": 0.00353, "epss_percentile": 0.57183}, "CVE-2023-35769": {"epss_score": 0.00144, "epss_percentile": 0.35344}, "CVE-2023-35772": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-35773": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-35774": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-35775": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-35776": {"epss_score": 0.00389, "epss_percentile": 0.5946}, "CVE-2023-35777": {"epss_score": 0.00177, "epss_percentile": 0.39535}, "CVE-2023-35778": {"epss_score": 0.0007, "epss_percentile": 0.21758}, "CVE-2023-35779": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2023-35780": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-35781": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-35782": {"epss_score": 0.00291, "epss_percentile": 0.52165}, "CVE-2023-35783": {"epss_score": 0.00257, "epss_percentile": 0.48857}, "CVE-2023-35784": {"epss_score": 0.00107, "epss_percentile": 0.29727}, "CVE-2023-35785": {"epss_score": 0.00304, "epss_percentile": 0.53263}, "CVE-2023-35786": {"epss_score": 0.00497, "epss_percentile": 0.65209}, "CVE-2023-35788": {"epss_score": 9e-05, "epss_percentile": 0.00611}, "CVE-2023-35789": {"epss_score": 0.00018, "epss_percentile": 0.03926}, "CVE-2023-35790": {"epss_score": 0.0007, "epss_percentile": 0.2198}, "CVE-2023-35791": {"epss_score": 0.00071, "epss_percentile": 0.22226}, "CVE-2023-35792": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-35793": {"epss_score": 0.00403, "epss_percentile": 0.60374}, "CVE-2023-35794": {"epss_score": 0.00313, "epss_percentile": 0.54023}, "CVE-2023-35796": {"epss_score": 0.00229, "epss_percentile": 0.45572}, "CVE-2023-35797": {"epss_score": 0.00863, "epss_percentile": 0.74591}, "CVE-2023-35798": {"epss_score": 0.00095, "epss_percentile": 0.27135}, "CVE-2023-35799": {"epss_score": 0.00026, "epss_percentile": 0.06465}, "CVE-2023-35800": {"epss_score": 0.00095, "epss_percentile": 0.27099}, "CVE-2023-35801": {"epss_score": 0.00313, "epss_percentile": 0.54011}, "CVE-2023-35802": {"epss_score": 0.02771, "epss_percentile": 0.8562}, "CVE-2023-35803": {"epss_score": 0.0547, "epss_percentile": 0.89908}, "CVE-2023-35808": {"epss_score": 0.00265, "epss_percentile": 0.49762}, "CVE-2023-35809": {"epss_score": 0.00363, "epss_percentile": 0.57894}, "CVE-2023-35810": {"epss_score": 0.00267, "epss_percentile": 0.4998}, "CVE-2023-35811": {"epss_score": 0.00231, "epss_percentile": 0.45799}, "CVE-2023-35812": {"epss_score": 0.00137, "epss_percentile": 0.34263}, "CVE-2023-35813": {"epss_score": 0.93522, "epss_percentile": 0.99814}, "CVE-2023-35814": {"epss_score": 0.00142, "epss_percentile": 0.35082}, "CVE-2023-35815": {"epss_score": 0.00071, "epss_percentile": 0.2203}, "CVE-2023-35816": {"epss_score": 0.00083, "epss_percentile": 0.24606}, "CVE-2023-35817": {"epss_score": 0.00101, "epss_percentile": 0.28594}, "CVE-2023-35818": {"epss_score": 0.00138, "epss_percentile": 0.34507}, "CVE-2023-35823": {"epss_score": 0.00014, "epss_percentile": 0.01988}, "CVE-2023-35824": {"epss_score": 0.00013, "epss_percentile": 0.01582}, "CVE-2023-35826": {"epss_score": 0.00027, "epss_percentile": 0.06948}, "CVE-2023-35827": {"epss_score": 0.00014, "epss_percentile": 0.01792}, "CVE-2023-35828": {"epss_score": 0.0005, "epss_percentile": 0.15931}, "CVE-2023-35829": {"epss_score": 0.00048, "epss_percentile": 0.15111}, "CVE-2023-35830": {"epss_score": 0.01503, "epss_percentile": 0.80728}, "CVE-2023-35833": {"epss_score": 0.00101, "epss_percentile": 0.28565}, "CVE-2023-35835": {"epss_score": 0.00198, "epss_percentile": 0.42068}, "CVE-2023-35836": {"epss_score": 0.00117, "epss_percentile": 0.31265}, "CVE-2023-35837": {"epss_score": 0.00132, "epss_percentile": 0.33512}, "CVE-2023-35838": {"epss_score": 0.00068, "epss_percentile": 0.21382}, "CVE-2023-35839": {"epss_score": 0.00132, "epss_percentile": 0.33518}, "CVE-2023-35840": {"epss_score": 0.05222, "epss_percentile": 0.89628}, "CVE-2023-35841": {"epss_score": 0.00155, "epss_percentile": 0.36829}, "CVE-2023-35843": {"epss_score": 0.91956, "epss_percentile": 0.99681}, "CVE-2023-35844": {"epss_score": 0.91817, "epss_percentile": 0.99669}, "CVE-2023-35845": {"epss_score": 0.00018, "epss_percentile": 0.03742}, "CVE-2023-35846": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-35847": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2023-35848": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-35849": {"epss_score": 0.00207, "epss_percentile": 0.43139}, "CVE-2023-35850": {"epss_score": 0.00225, "epss_percentile": 0.45162}, "CVE-2023-35851": {"epss_score": 0.00071, "epss_percentile": 0.22186}, "CVE-2023-35852": {"epss_score": 0.00577, "epss_percentile": 0.68169}, "CVE-2023-35853": {"epss_score": 0.00551, "epss_percentile": 0.67351}, "CVE-2023-35854": {"epss_score": 0.03066, "epss_percentile": 0.86337}, "CVE-2023-35855": {"epss_score": 0.00121, "epss_percentile": 0.31942}, "CVE-2023-35856": {"epss_score": 0.00049, "epss_percentile": 0.15564}, "CVE-2023-35857": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2023-35858": {"epss_score": 0.00735, "epss_percentile": 0.72296}, "CVE-2023-35859": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2023-35860": {"epss_score": 0.02607, "epss_percentile": 0.85228}, "CVE-2023-35861": {"epss_score": 0.00972, "epss_percentile": 0.76131}, "CVE-2023-35862": {"epss_score": 0.00099, "epss_percentile": 0.28339}, "CVE-2023-35863": {"epss_score": 0.00036, "epss_percentile": 0.10163}, "CVE-2023-35866": {"epss_score": 0.00021, "epss_percentile": 0.04717}, "CVE-2023-35867": {"epss_score": 0.00083, "epss_percentile": 0.24617}, "CVE-2023-35870": {"epss_score": 0.00095, "epss_percentile": 0.27151}, "CVE-2023-35871": {"epss_score": 0.00381, "epss_percentile": 0.58997}, "CVE-2023-35872": {"epss_score": 0.00129, "epss_percentile": 0.33162}, "CVE-2023-35873": {"epss_score": 0.00129, "epss_percentile": 0.33162}, "CVE-2023-35874": {"epss_score": 0.00102, "epss_percentile": 0.28735}, "CVE-2023-35875": {"epss_score": 0.00205, "epss_percentile": 0.42752}, "CVE-2023-35876": {"epss_score": 0.00092, "epss_percentile": 0.2648}, "CVE-2023-35877": {"epss_score": 0.00064, "epss_percentile": 0.20144}, "CVE-2023-35878": {"epss_score": 0.00127, "epss_percentile": 0.32891}, "CVE-2023-35879": {"epss_score": 0.00441, "epss_percentile": 0.62651}, "CVE-2023-35880": {"epss_score": 0.00053, "epss_percentile": 0.16989}, "CVE-2023-35881": {"epss_score": 0.00796, "epss_percentile": 0.73477}, "CVE-2023-35882": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-35883": {"epss_score": 0.00114, "epss_percentile": 0.30766}, "CVE-2023-35884": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-35885": {"epss_score": 0.94122, "epss_percentile": 0.99906}, "CVE-2023-35887": {"epss_score": 0.001, "epss_percentile": 0.28466}, "CVE-2023-35888": {"epss_score": 0.0002, "epss_percentile": 0.04475}, "CVE-2023-35890": {"epss_score": 0.00011, "epss_percentile": 0.01064}, "CVE-2023-35892": {"epss_score": 0.00023, "epss_percentile": 0.05361}, "CVE-2023-35893": {"epss_score": 0.00201, "epss_percentile": 0.42355}, "CVE-2023-35894": {"epss_score": 0.00064, "epss_percentile": 0.20212}, "CVE-2023-35895": {"epss_score": 0.00219, "epss_percentile": 0.44475}, "CVE-2023-35896": {"epss_score": 0.00046, "epss_percentile": 0.14137}, "CVE-2023-35897": {"epss_score": 0.00021, "epss_percentile": 0.04786}, "CVE-2023-35898": {"epss_score": 0.00067, "epss_percentile": 0.20993}, "CVE-2023-35899": {"epss_score": 0.00089, "epss_percentile": 0.25866}, "CVE-2023-35900": {"epss_score": 0.00068, "epss_percentile": 0.21383}, "CVE-2023-35901": {"epss_score": 0.00027, "epss_percentile": 0.07138}, "CVE-2023-35905": {"epss_score": 0.00135, "epss_percentile": 0.34016}, "CVE-2023-35906": {"epss_score": 0.00013, "epss_percentile": 0.01566}, "CVE-2023-35907": {"epss_score": 0.00059, "epss_percentile": 0.1873}, "CVE-2023-35908": {"epss_score": 0.00138, "epss_percentile": 0.34356}, "CVE-2023-35909": {"epss_score": 0.0033, "epss_percentile": 0.55496}, "CVE-2023-35910": {"epss_score": 0.00211, "epss_percentile": 0.43621}, "CVE-2023-35911": {"epss_score": 0.00229, "epss_percentile": 0.45611}, "CVE-2023-35912": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-35913": {"epss_score": 0.00077, "epss_percentile": 0.23287}, "CVE-2023-35914": {"epss_score": 0.00178, "epss_percentile": 0.3965}, "CVE-2023-35915": {"epss_score": 0.00146, "epss_percentile": 0.35588}, "CVE-2023-35916": {"epss_score": 0.00178, "epss_percentile": 0.3965}, "CVE-2023-35917": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-35918": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-35920": {"epss_score": 0.00734, "epss_percentile": 0.72246}, "CVE-2023-35921": {"epss_score": 0.00734, "epss_percentile": 0.72246}, "CVE-2023-35924": {"epss_score": 0.13234, "epss_percentile": 0.93907}, "CVE-2023-35925": {"epss_score": 0.00242, "epss_percentile": 0.47378}, "CVE-2023-35926": {"epss_score": 0.0242, "epss_percentile": 0.84702}, "CVE-2023-35927": {"epss_score": 0.00177, "epss_percentile": 0.39499}, "CVE-2023-35928": {"epss_score": 0.00365, "epss_percentile": 0.57983}, "CVE-2023-35929": {"epss_score": 0.00422, "epss_percentile": 0.6156}, "CVE-2023-35930": {"epss_score": 0.00129, "epss_percentile": 0.33127}, "CVE-2023-35931": {"epss_score": 0.00256, "epss_percentile": 0.48793}, "CVE-2023-35932": {"epss_score": 0.00955, "epss_percentile": 0.75918}, "CVE-2023-35933": {"epss_score": 0.00226, "epss_percentile": 0.45306}, "CVE-2023-35934": {"epss_score": 0.00646, "epss_percentile": 0.70145}, "CVE-2023-35936": {"epss_score": 0.00037, "epss_percentile": 0.10908}, "CVE-2023-35937": {"epss_score": 0.00037, "epss_percentile": 0.10784}, "CVE-2023-35938": {"epss_score": 0.001, "epss_percentile": 0.28449}, "CVE-2023-35939": {"epss_score": 0.0018, "epss_percentile": 0.39909}, "CVE-2023-35940": {"epss_score": 0.00272, "epss_percentile": 0.50388}, "CVE-2023-35941": {"epss_score": 0.00058, "epss_percentile": 0.18359}, "CVE-2023-35942": {"epss_score": 0.00019, "epss_percentile": 0.04222}, "CVE-2023-35943": {"epss_score": 9e-05, "epss_percentile": 0.0069}, "CVE-2023-35944": {"epss_score": 9e-05, "epss_percentile": 0.00696}, "CVE-2023-35945": {"epss_score": 0.00125, "epss_percentile": 0.32502}, "CVE-2023-35946": {"epss_score": 0.00106, "epss_percentile": 0.29564}, "CVE-2023-35947": {"epss_score": 0.00141, "epss_percentile": 0.34822}, "CVE-2023-35948": {"epss_score": 0.00181, "epss_percentile": 0.40029}, "CVE-2023-35949": {"epss_score": 0.00139, "epss_percentile": 0.34607}, "CVE-2023-35950": {"epss_score": 0.00139, "epss_percentile": 0.34607}, "CVE-2023-35951": {"epss_score": 0.00139, "epss_percentile": 0.34607}, "CVE-2023-35952": {"epss_score": 0.00139, "epss_percentile": 0.34607}, "CVE-2023-35953": {"epss_score": 0.00139, "epss_percentile": 0.34607}, "CVE-2023-35955": {"epss_score": 0.0007, "epss_percentile": 0.21981}, "CVE-2023-35956": {"epss_score": 0.0007, "epss_percentile": 0.21981}, "CVE-2023-35957": {"epss_score": 0.0007, "epss_percentile": 0.21981}, "CVE-2023-35958": {"epss_score": 0.00059, "epss_percentile": 0.18684}, "CVE-2023-35959": {"epss_score": 0.00079, "epss_percentile": 0.23827}, "CVE-2023-35960": {"epss_score": 0.00079, "epss_percentile": 0.23827}, "CVE-2023-35961": {"epss_score": 0.00094, "epss_percentile": 0.27061}, "CVE-2023-35962": {"epss_score": 0.00079, "epss_percentile": 0.23827}, "CVE-2023-35963": {"epss_score": 0.00079, "epss_percentile": 0.23827}, "CVE-2023-35964": {"epss_score": 0.00094, "epss_percentile": 0.27061}, "CVE-2023-35965": {"epss_score": 0.00264, "epss_percentile": 0.49726}, "CVE-2023-35966": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-35967": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-35968": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-35969": {"epss_score": 0.00043, "epss_percentile": 0.1329}, "CVE-2023-35970": {"epss_score": 0.00052, "epss_percentile": 0.16621}, "CVE-2023-35971": {"epss_score": 0.00301, "epss_percentile": 0.53057}, "CVE-2023-35972": {"epss_score": 0.00276, "epss_percentile": 0.50716}, "CVE-2023-35973": {"epss_score": 0.00406, "epss_percentile": 0.6056}, "CVE-2023-35974": {"epss_score": 0.00406, "epss_percentile": 0.6056}, "CVE-2023-35975": {"epss_score": 0.0017, "epss_percentile": 0.38726}, "CVE-2023-35976": {"epss_score": 0.00216, "epss_percentile": 0.44153}, "CVE-2023-35977": {"epss_score": 0.00216, "epss_percentile": 0.44153}, "CVE-2023-35978": {"epss_score": 0.00136, "epss_percentile": 0.34145}, "CVE-2023-35979": {"epss_score": 0.00121, "epss_percentile": 0.31881}, "CVE-2023-35980": {"epss_score": 0.00876, "epss_percentile": 0.74795}, "CVE-2023-35981": {"epss_score": 0.01697, "epss_percentile": 0.81816}, "CVE-2023-35982": {"epss_score": 0.00876, "epss_percentile": 0.74795}, "CVE-2023-35983": {"epss_score": 0.00027, "epss_percentile": 0.06821}, "CVE-2023-35984": {"epss_score": 0.00091, "epss_percentile": 0.26376}, "CVE-2023-35985": {"epss_score": 0.00246, "epss_percentile": 0.47741}, "CVE-2023-35986": {"epss_score": 0.00094, "epss_percentile": 0.2704}, "CVE-2023-35987": {"epss_score": 0.00088, "epss_percentile": 0.25638}, "CVE-2023-35989": {"epss_score": 0.00042, "epss_percentile": 0.12706}, "CVE-2023-35990": {"epss_score": 0.00046, "epss_percentile": 0.14315}, "CVE-2023-35991": {"epss_score": 0.00336, "epss_percentile": 0.55951}, "CVE-2023-35992": {"epss_score": 0.00025, "epss_percentile": 0.06368}, "CVE-2023-35993": {"epss_score": 0.00049, "epss_percentile": 0.15431}, "CVE-2023-35994": {"epss_score": 0.0005, "epss_percentile": 0.15894}, "CVE-2023-35995": {"epss_score": 0.0005, "epss_percentile": 0.15894}, "CVE-2023-35996": {"epss_score": 0.00042, "epss_percentile": 0.12706}, "CVE-2023-35997": {"epss_score": 0.0005, "epss_percentile": 0.15894}, "CVE-2023-35998": {"epss_score": 0.00091, "epss_percentile": 0.264}, "CVE-2023-36000": {"epss_score": 0.00086, "epss_percentile": 0.25342}, "CVE-2023-36002": {"epss_score": 0.00066, "epss_percentile": 0.2094}, "CVE-2023-36003": {"epss_score": 0.38566, "epss_percentile": 0.97106}, "CVE-2023-36004": {"epss_score": 0.00177, "epss_percentile": 0.39529}, "CVE-2023-36005": {"epss_score": 0.08837, "epss_percentile": 0.92277}, "CVE-2023-36006": {"epss_score": 0.00209, "epss_percentile": 0.43381}, "CVE-2023-36007": {"epss_score": 0.00192, "epss_percentile": 0.41371}, "CVE-2023-36008": {"epss_score": 0.00987, "epss_percentile": 0.76346}, "CVE-2023-36009": {"epss_score": 0.0019, "epss_percentile": 0.41111}, "CVE-2023-36010": {"epss_score": 0.03324, "epss_percentile": 0.86919}, "CVE-2023-36011": {"epss_score": 0.00102, "epss_percentile": 0.28836}, "CVE-2023-36012": {"epss_score": 0.00904, "epss_percentile": 0.75214}, "CVE-2023-36013": {"epss_score": 0.02494, "epss_percentile": 0.84903}, "CVE-2023-36014": {"epss_score": 0.00415, "epss_percentile": 0.61154}, "CVE-2023-36016": {"epss_score": 0.0016, "epss_percentile": 0.37507}, "CVE-2023-36017": {"epss_score": 0.02717, "epss_percentile": 0.85509}, "CVE-2023-36018": {"epss_score": 0.01606, "epss_percentile": 0.81304}, "CVE-2023-36019": {"epss_score": 0.01076, "epss_percentile": 0.77326}, "CVE-2023-36020": {"epss_score": 0.00103, "epss_percentile": 0.29}, "CVE-2023-36021": {"epss_score": 0.00233, "epss_percentile": 0.46058}, "CVE-2023-36022": {"epss_score": 0.00428, "epss_percentile": 0.61928}, "CVE-2023-36024": {"epss_score": 0.00139, "epss_percentile": 0.34586}, "CVE-2023-36025": {"epss_score": 0.90206, "epss_percentile": 0.99569}, "CVE-2023-36026": {"epss_score": 0.00228, "epss_percentile": 0.45541}, "CVE-2023-36027": {"epss_score": 0.00137, "epss_percentile": 0.34269}, "CVE-2023-36028": {"epss_score": 0.00536, "epss_percentile": 0.66849}, "CVE-2023-36029": {"epss_score": 0.0012, "epss_percentile": 0.31789}, "CVE-2023-36030": {"epss_score": 0.00228, "epss_percentile": 0.45485}, "CVE-2023-36031": {"epss_score": 0.00228, "epss_percentile": 0.45529}, "CVE-2023-36033": {"epss_score": 0.00908, "epss_percentile": 0.75277}, "CVE-2023-36034": {"epss_score": 0.00626, "epss_percentile": 0.696}, "CVE-2023-36035": {"epss_score": 0.04094, "epss_percentile": 0.88246}, "CVE-2023-36036": {"epss_score": 0.01223, "epss_percentile": 0.78664}, "CVE-2023-36037": {"epss_score": 0.00197, "epss_percentile": 0.41964}, "CVE-2023-36038": {"epss_score": 0.07176, "epss_percentile": 0.913}, "CVE-2023-36039": {"epss_score": 0.04094, "epss_percentile": 0.88246}, "CVE-2023-36041": {"epss_score": 0.03371, "epss_percentile": 0.8701}, "CVE-2023-36042": {"epss_score": 0.00104, "epss_percentile": 0.29204}, "CVE-2023-36043": {"epss_score": 0.00326, "epss_percentile": 0.55084}, "CVE-2023-36045": {"epss_score": 0.00319, "epss_percentile": 0.54531}, "CVE-2023-36046": {"epss_score": 0.0021, "epss_percentile": 0.43434}, "CVE-2023-36047": {"epss_score": 0.00352, "epss_percentile": 0.57102}, "CVE-2023-36049": {"epss_score": 0.03486, "epss_percentile": 0.87227}, "CVE-2023-36050": {"epss_score": 0.04094, "epss_percentile": 0.88246}, "CVE-2023-36052": {"epss_score": 0.00396, "epss_percentile": 0.59934}, "CVE-2023-36053": {"epss_score": 0.08919, "epss_percentile": 0.92319}, "CVE-2023-36054": {"epss_score": 0.00648, "epss_percentile": 0.70216}, "CVE-2023-36076": {"epss_score": 0.43936, "epss_percentile": 0.97409}, "CVE-2023-36081": {"epss_score": 0.00177, "epss_percentile": 0.39617}, "CVE-2023-36082": {"epss_score": 0.00434, "epss_percentile": 0.62303}, "CVE-2023-36085": {"epss_score": 0.00219, "epss_percentile": 0.44528}, "CVE-2023-36088": {"epss_score": 0.00082, "epss_percentile": 0.24539}, "CVE-2023-36089": {"epss_score": 0.00377, "epss_percentile": 0.58773}, "CVE-2023-36090": {"epss_score": 0.00394, "epss_percentile": 0.59798}, "CVE-2023-36091": {"epss_score": 0.00377, "epss_percentile": 0.58773}, "CVE-2023-36092": {"epss_score": 0.00394, "epss_percentile": 0.59798}, "CVE-2023-36093": {"epss_score": 0.00085, "epss_percentile": 0.25145}, "CVE-2023-36095": {"epss_score": 0.02309, "epss_percentile": 0.84331}, "CVE-2023-36097": {"epss_score": 0.00316, "epss_percentile": 0.54217}, "CVE-2023-36100": {"epss_score": 0.00079, "epss_percentile": 0.23982}, "CVE-2023-36103": {"epss_score": 0.09843, "epss_percentile": 0.92731}, "CVE-2023-36106": {"epss_score": 0.00123, "epss_percentile": 0.32261}, "CVE-2023-36109": {"epss_score": 0.2036, "epss_percentile": 0.95333}, "CVE-2023-36118": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2023-36121": {"epss_score": 0.01381, "epss_percentile": 0.79867}, "CVE-2023-36123": {"epss_score": 0.11909, "epss_percentile": 0.93511}, "CVE-2023-36126": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-36127": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-36131": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-36132": {"epss_score": 0.00107, "epss_percentile": 0.29629}, "CVE-2023-36133": {"epss_score": 0.00107, "epss_percentile": 0.29629}, "CVE-2023-36134": {"epss_score": 0.00318, "epss_percentile": 0.54455}, "CVE-2023-36135": {"epss_score": 0.00097, "epss_percentile": 0.27567}, "CVE-2023-36136": {"epss_score": 0.00045, "epss_percentile": 0.1404}, "CVE-2023-36137": {"epss_score": 0.00105, "epss_percentile": 0.29265}, "CVE-2023-36138": {"epss_score": 0.00135, "epss_percentile": 0.33969}, "CVE-2023-36139": {"epss_score": 0.00337, "epss_percentile": 0.56021}, "CVE-2023-36140": {"epss_score": 0.00065, "epss_percentile": 0.20555}, "CVE-2023-36141": {"epss_score": 0.00084, "epss_percentile": 0.2493}, "CVE-2023-36143": {"epss_score": 0.10687, "epss_percentile": 0.93071}, "CVE-2023-36144": {"epss_score": 0.86394, "epss_percentile": 0.9938}, "CVE-2023-36146": {"epss_score": 0.00119, "epss_percentile": 0.31657}, "CVE-2023-36158": {"epss_score": 0.00116, "epss_percentile": 0.31066}, "CVE-2023-36159": {"epss_score": 0.00097, "epss_percentile": 0.27621}, "CVE-2023-36160": {"epss_score": 0.00032, "epss_percentile": 0.08971}, "CVE-2023-36161": {"epss_score": 0.00071, "epss_percentile": 0.22145}, "CVE-2023-36162": {"epss_score": 0.00295, "epss_percentile": 0.52451}, "CVE-2023-36163": {"epss_score": 0.13243, "epss_percentile": 0.93911}, "CVE-2023-36177": {"epss_score": 0.29015, "epss_percentile": 0.96411}, "CVE-2023-36183": {"epss_score": 0.00077, "epss_percentile": 0.23358}, "CVE-2023-36184": {"epss_score": 0.00052, "epss_percentile": 0.16376}, "CVE-2023-36187": {"epss_score": 0.04535, "epss_percentile": 0.88816}, "CVE-2023-36188": {"epss_score": 0.02118, "epss_percentile": 0.8367}, "CVE-2023-36189": {"epss_score": 0.00146, "epss_percentile": 0.35601}, "CVE-2023-36192": {"epss_score": 0.00041, "epss_percentile": 0.12304}, "CVE-2023-36193": {"epss_score": 0.00034, "epss_percentile": 0.09685}, "CVE-2023-36198": {"epss_score": 0.00048, "epss_percentile": 0.15275}, "CVE-2023-36199": {"epss_score": 0.00063, "epss_percentile": 0.19907}, "CVE-2023-36201": {"epss_score": 0.00112, "epss_percentile": 0.30577}, "CVE-2023-36210": {"epss_score": 0.09666, "epss_percentile": 0.92647}, "CVE-2023-36211": {"epss_score": 0.00117, "epss_percentile": 0.31282}, "CVE-2023-36212": {"epss_score": 0.46159, "epss_percentile": 0.97534}, "CVE-2023-36213": {"epss_score": 0.00525, "epss_percentile": 0.66379}, "CVE-2023-36217": {"epss_score": 0.07131, "epss_percentile": 0.91271}, "CVE-2023-36220": {"epss_score": 0.02661, "epss_percentile": 0.85369}, "CVE-2023-36222": {"epss_score": 0.00204, "epss_percentile": 0.42591}, "CVE-2023-36223": {"epss_score": 0.00204, "epss_percentile": 0.42591}, "CVE-2023-36234": {"epss_score": 0.0008, "epss_percentile": 0.24174}, "CVE-2023-36235": {"epss_score": 0.00075, "epss_percentile": 0.23023}, "CVE-2023-36236": {"epss_score": 0.00229, "epss_percentile": 0.45644}, "CVE-2023-36237": {"epss_score": 0.00183, "epss_percentile": 0.40287}, "CVE-2023-36238": {"epss_score": 0.00149, "epss_percentile": 0.36036}, "CVE-2023-36239": {"epss_score": 0.00226, "epss_percentile": 0.45271}, "CVE-2023-36243": {"epss_score": 0.00058, "epss_percentile": 0.18471}, "CVE-2023-36250": {"epss_score": 0.03602, "epss_percentile": 0.87412}, "CVE-2023-36252": {"epss_score": 0.0116, "epss_percentile": 0.78132}, "CVE-2023-36255": {"epss_score": 0.87697, "epss_percentile": 0.99439}, "CVE-2023-36256": {"epss_score": 0.00056, "epss_percentile": 0.17772}, "CVE-2023-36258": {"epss_score": 0.00487, "epss_percentile": 0.64827}, "CVE-2023-36259": {"epss_score": 0.00087, "epss_percentile": 0.25614}, "CVE-2023-36260": {"epss_score": 0.00365, "epss_percentile": 0.5801}, "CVE-2023-36263": {"epss_score": 0.00051, "epss_percentile": 0.16029}, "CVE-2023-36266": {"epss_score": 0.00232, "epss_percentile": 0.45913}, "CVE-2023-36271": {"epss_score": 0.00148, "epss_percentile": 0.35917}, "CVE-2023-36272": {"epss_score": 0.00158, "epss_percentile": 0.37217}, "CVE-2023-36273": {"epss_score": 0.00146, "epss_percentile": 0.35542}, "CVE-2023-36274": {"epss_score": 0.00158, "epss_percentile": 0.37217}, "CVE-2023-36281": {"epss_score": 0.68533, "epss_percentile": 0.98552}, "CVE-2023-36284": {"epss_score": 0.24278, "epss_percentile": 0.959}, "CVE-2023-36287": {"epss_score": 0.20464, "epss_percentile": 0.95351}, "CVE-2023-36288": {"epss_score": 0.00108, "epss_percentile": 0.29759}, "CVE-2023-36289": {"epss_score": 0.23724, "epss_percentile": 0.95809}, "CVE-2023-36291": {"epss_score": 0.00544, "epss_percentile": 0.67135}, "CVE-2023-36293": {"epss_score": 0.00089, "epss_percentile": 0.25812}, "CVE-2023-36298": {"epss_score": 0.06586, "epss_percentile": 0.90867}, "CVE-2023-36299": {"epss_score": 0.08753, "epss_percentile": 0.92242}, "CVE-2023-36301": {"epss_score": 0.00492, "epss_percentile": 0.6501}, "CVE-2023-36306": {"epss_score": 0.06137, "epss_percentile": 0.9051}, "CVE-2023-36307": {"epss_score": 0.00032, "epss_percentile": 0.08867}, "CVE-2023-36308": {"epss_score": 0.00025, "epss_percentile": 0.06144}, "CVE-2023-36309": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-36310": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-36311": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-36312": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2023-36313": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-36314": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-36315": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-36317": {"epss_score": 0.00076, "epss_percentile": 0.23262}, "CVE-2023-36319": {"epss_score": 0.25437, "epss_percentile": 0.96028}, "CVE-2023-36321": {"epss_score": 0.00113, "epss_percentile": 0.30607}, "CVE-2023-36325": {"epss_score": 0.00227, "epss_percentile": 0.45366}, "CVE-2023-36326": {"epss_score": 0.00108, "epss_percentile": 0.29766}, "CVE-2023-36327": {"epss_score": 0.00108, "epss_percentile": 0.29766}, "CVE-2023-36328": {"epss_score": 0.00548, "epss_percentile": 0.67265}, "CVE-2023-36337": {"epss_score": 0.0003, "epss_percentile": 0.08079}, "CVE-2023-36338": {"epss_score": 0.00029, "epss_percentile": 0.07678}, "CVE-2023-36339": {"epss_score": 0.00082, "epss_percentile": 0.24462}, "CVE-2023-36340": {"epss_score": 0.0021, "epss_percentile": 0.43481}, "CVE-2023-36344": {"epss_score": 0.00052, "epss_percentile": 0.1664}, "CVE-2023-36345": {"epss_score": 0.0036, "epss_percentile": 0.57674}, "CVE-2023-36346": {"epss_score": 0.09444, "epss_percentile": 0.92551}, "CVE-2023-36347": {"epss_score": 0.82577, "epss_percentile": 0.992}, "CVE-2023-36348": {"epss_score": 0.04171, "epss_percentile": 0.88347}, "CVE-2023-36351": {"epss_score": 0.01128, "epss_percentile": 0.7783}, "CVE-2023-36354": {"epss_score": 0.00109, "epss_percentile": 0.30029}, "CVE-2023-36355": {"epss_score": 0.41455, "epss_percentile": 0.97274}, "CVE-2023-36356": {"epss_score": 0.00068, "epss_percentile": 0.21309}, "CVE-2023-36357": {"epss_score": 0.0009, "epss_percentile": 0.26023}, "CVE-2023-36358": {"epss_score": 0.00084, "epss_percentile": 0.24854}, "CVE-2023-36359": {"epss_score": 0.00109, "epss_percentile": 0.30029}, "CVE-2023-36361": {"epss_score": 0.00332, "epss_percentile": 0.55561}, "CVE-2023-36362": {"epss_score": 0.00067, "epss_percentile": 0.21158}, "CVE-2023-36363": {"epss_score": 0.00067, "epss_percentile": 0.21158}, "CVE-2023-36364": {"epss_score": 0.00067, "epss_percentile": 0.21158}, "CVE-2023-36365": {"epss_score": 0.00064, "epss_percentile": 0.20183}, "CVE-2023-36366": {"epss_score": 0.00064, "epss_percentile": 0.20183}, "CVE-2023-36367": {"epss_score": 0.00064, "epss_percentile": 0.20183}, "CVE-2023-36368": {"epss_score": 0.00064, "epss_percentile": 0.20183}, "CVE-2023-36369": {"epss_score": 0.00083, "epss_percentile": 0.24801}, "CVE-2023-36370": {"epss_score": 0.00083, "epss_percentile": 0.24801}, "CVE-2023-36371": {"epss_score": 0.00064, "epss_percentile": 0.20183}, "CVE-2023-36375": {"epss_score": 0.0058, "epss_percentile": 0.68254}, "CVE-2023-36376": {"epss_score": 0.0007, "epss_percentile": 0.21811}, "CVE-2023-36377": {"epss_score": 0.00104, "epss_percentile": 0.2921}, "CVE-2023-36380": {"epss_score": 0.00063, "epss_percentile": 0.19929}, "CVE-2023-36381": {"epss_score": 0.00109, "epss_percentile": 0.29903}, "CVE-2023-36382": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-36383": {"epss_score": 0.00038, "epss_percentile": 0.11184}, "CVE-2023-36384": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-36385": {"epss_score": 0.00096, "epss_percentile": 0.27354}, "CVE-2023-36386": {"epss_score": 0.00468, "epss_percentile": 0.63888}, "CVE-2023-36387": {"epss_score": 0.00021, "epss_percentile": 0.04885}, "CVE-2023-36388": {"epss_score": 0.00126, "epss_percentile": 0.32629}, "CVE-2023-36389": {"epss_score": 0.00468, "epss_percentile": 0.63888}, "CVE-2023-36390": {"epss_score": 0.00611, "epss_percentile": 0.69207}, "CVE-2023-36391": {"epss_score": 0.01647, "epss_percentile": 0.8154}, "CVE-2023-36392": {"epss_score": 0.00718, "epss_percentile": 0.71924}, "CVE-2023-36393": {"epss_score": 0.00408, "epss_percentile": 0.60623}, "CVE-2023-36394": {"epss_score": 0.01054, "epss_percentile": 0.77104}, "CVE-2023-36395": {"epss_score": 0.0122, "epss_percentile": 0.78621}, "CVE-2023-36396": {"epss_score": 0.0049, "epss_percentile": 0.64931}, "CVE-2023-36397": {"epss_score": 0.03225, "epss_percentile": 0.86684}, "CVE-2023-36398": {"epss_score": 0.00058, "epss_percentile": 0.18584}, "CVE-2023-36399": {"epss_score": 0.01113, "epss_percentile": 0.77693}, "CVE-2023-36400": {"epss_score": 0.01558, "epss_percentile": 0.81031}, "CVE-2023-36401": {"epss_score": 0.00319, "epss_percentile": 0.54529}, "CVE-2023-36402": {"epss_score": 0.00166, "epss_percentile": 0.38236}, "CVE-2023-36403": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2023-36404": {"epss_score": 0.00217, "epss_percentile": 0.4426}, "CVE-2023-36405": {"epss_score": 0.00119, "epss_percentile": 0.3167}, "CVE-2023-36406": {"epss_score": 0.00245, "epss_percentile": 0.47688}, "CVE-2023-36407": {"epss_score": 0.14542, "epss_percentile": 0.94237}, "CVE-2023-36408": {"epss_score": 0.00131, "epss_percentile": 0.33449}, "CVE-2023-36409": {"epss_score": 0.01774, "epss_percentile": 0.82212}, "CVE-2023-36410": {"epss_score": 0.00228, "epss_percentile": 0.45529}, "CVE-2023-36413": {"epss_score": 0.02668, "epss_percentile": 0.85381}, "CVE-2023-36414": {"epss_score": 0.02835, "epss_percentile": 0.85789}, "CVE-2023-36415": {"epss_score": 0.01059, "epss_percentile": 0.77151}, "CVE-2023-36416": {"epss_score": 0.00285, "epss_percentile": 0.51511}, "CVE-2023-36417": {"epss_score": 0.00433, "epss_percentile": 0.62203}, "CVE-2023-36418": {"epss_score": 0.00559, "epss_percentile": 0.67623}, "CVE-2023-36419": {"epss_score": 0.00679, "epss_percentile": 0.7101}, "CVE-2023-36420": {"epss_score": 0.00433, "epss_percentile": 0.62203}, "CVE-2023-36422": {"epss_score": 0.00718, "epss_percentile": 0.71921}, "CVE-2023-36423": {"epss_score": 0.00574, "epss_percentile": 0.68087}, "CVE-2023-36424": {"epss_score": 0.20288, "epss_percentile": 0.95315}, "CVE-2023-36425": {"epss_score": 0.00207, "epss_percentile": 0.43161}, "CVE-2023-36427": {"epss_score": 0.09416, "epss_percentile": 0.92538}, "CVE-2023-36428": {"epss_score": 0.00169, "epss_percentile": 0.38637}, "CVE-2023-36429": {"epss_score": 0.01344, "epss_percentile": 0.79613}, "CVE-2023-36431": {"epss_score": 0.06827, "epss_percentile": 0.91052}, "CVE-2023-36433": {"epss_score": 0.01859, "epss_percentile": 0.82582}, "CVE-2023-36434": {"epss_score": 0.02926, "epss_percentile": 0.86005}, "CVE-2023-36435": {"epss_score": 0.01743, "epss_percentile": 0.82055}, "CVE-2023-36436": {"epss_score": 0.00298, "epss_percentile": 0.52795}, "CVE-2023-36437": {"epss_score": 0.00501, "epss_percentile": 0.65342}, "CVE-2023-36438": {"epss_score": 0.00816, "epss_percentile": 0.738}, "CVE-2023-36439": {"epss_score": 0.00632, "epss_percentile": 0.69748}, "CVE-2023-36456": {"epss_score": 0.00418, "epss_percentile": 0.61271}, "CVE-2023-36457": {"epss_score": 0.02632, "epss_percentile": 0.85285}, "CVE-2023-36458": {"epss_score": 0.02632, "epss_percentile": 0.85285}, "CVE-2023-36459": {"epss_score": 0.00219, "epss_percentile": 0.44485}, "CVE-2023-36460": {"epss_score": 0.34243, "epss_percentile": 0.96835}, "CVE-2023-36461": {"epss_score": 0.00217, "epss_percentile": 0.44246}, "CVE-2023-36462": {"epss_score": 0.01506, "epss_percentile": 0.80747}, "CVE-2023-36463": {"epss_score": 0.0005, "epss_percentile": 0.15957}, "CVE-2023-36464": {"epss_score": 0.00025, "epss_percentile": 0.06281}, "CVE-2023-36465": {"epss_score": 0.0007, "epss_percentile": 0.21699}, "CVE-2023-36466": {"epss_score": 0.00056, "epss_percentile": 0.17888}, "CVE-2023-36467": {"epss_score": 0.02449, "epss_percentile": 0.84776}, "CVE-2023-36468": {"epss_score": 0.10284, "epss_percentile": 0.92926}, "CVE-2023-36469": {"epss_score": 0.47067, "epss_percentile": 0.97568}, "CVE-2023-36470": {"epss_score": 0.14173, "epss_percentile": 0.94154}, "CVE-2023-36471": {"epss_score": 0.0081, "epss_percentile": 0.73716}, "CVE-2023-36472": {"epss_score": 0.00137, "epss_percentile": 0.34229}, "CVE-2023-36473": {"epss_score": 0.00193, "epss_percentile": 0.41451}, "CVE-2023-36474": {"epss_score": 0.00865, "epss_percentile": 0.74628}, "CVE-2023-36475": {"epss_score": 0.07546, "epss_percentile": 0.9153}, "CVE-2023-36476": {"epss_score": 0.00156, "epss_percentile": 0.37016}, "CVE-2023-36477": {"epss_score": 0.02453, "epss_percentile": 0.84793}, "CVE-2023-36478": {"epss_score": 0.01459, "epss_percentile": 0.80412}, "CVE-2023-36479": {"epss_score": 0.01383, "epss_percentile": 0.79891}, "CVE-2023-36480": {"epss_score": 0.02863, "epss_percentile": 0.85857}, "CVE-2023-36481": {"epss_score": 0.00221, "epss_percentile": 0.44668}, "CVE-2023-36482": {"epss_score": 0.00066, "epss_percentile": 0.2089}, "CVE-2023-36483": {"epss_score": 0.00084, "epss_percentile": 0.24921}, "CVE-2023-36484": {"epss_score": 0.00105, "epss_percentile": 0.29265}, "CVE-2023-36485": {"epss_score": 0.00672, "epss_percentile": 0.70825}, "CVE-2023-36486": {"epss_score": 0.00672, "epss_percentile": 0.70825}, "CVE-2023-36487": {"epss_score": 0.00444, "epss_percentile": 0.62849}, "CVE-2023-36488": {"epss_score": 0.00088, "epss_percentile": 0.25779}, "CVE-2023-36489": {"epss_score": 0.0014, "epss_percentile": 0.34798}, "CVE-2023-36490": {"epss_score": 0.00032, "epss_percentile": 0.08982}, "CVE-2023-36492": {"epss_score": 0.00675, "epss_percentile": 0.70889}, "CVE-2023-36493": {"epss_score": 0.00127, "epss_percentile": 0.32804}, "CVE-2023-36494": {"epss_score": 0.00079, "epss_percentile": 0.2386}, "CVE-2023-36495": {"epss_score": 0.00463, "epss_percentile": 0.63691}, "CVE-2023-36496": {"epss_score": 0.00039, "epss_percentile": 0.11615}, "CVE-2023-36497": {"epss_score": 0.00073, "epss_percentile": 0.22547}, "CVE-2023-36498": {"epss_score": 0.00781, "epss_percentile": 0.73182}, "CVE-2023-36499": {"epss_score": 0.00348, "epss_percentile": 0.56798}, "CVE-2023-36501": {"epss_score": 0.00087, "epss_percentile": 0.25547}, "CVE-2023-36502": {"epss_score": 0.00096, "epss_percentile": 0.27354}, "CVE-2023-36503": {"epss_score": 0.00081, "epss_percentile": 0.24347}, "CVE-2023-36504": {"epss_score": 0.00304, "epss_percentile": 0.53271}, "CVE-2023-36505": {"epss_score": 0.00394, "epss_percentile": 0.59787}, "CVE-2023-36506": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-36507": {"epss_score": 0.00366, "epss_percentile": 0.58053}, "CVE-2023-36508": {"epss_score": 0.00441, "epss_percentile": 0.62651}, "CVE-2023-36509": {"epss_score": 0.00027, "epss_percentile": 0.06956}, "CVE-2023-36510": {"epss_score": 0.00119, "epss_percentile": 0.31585}, "CVE-2023-36511": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-36512": {"epss_score": 0.00096, "epss_percentile": 0.27377}, "CVE-2023-36513": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-36514": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-36515": {"epss_score": 0.00504, "epss_percentile": 0.65523}, "CVE-2023-36516": {"epss_score": 0.00446, "epss_percentile": 0.62921}, "CVE-2023-36517": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-36518": {"epss_score": 0.0018, "epss_percentile": 0.39879}, "CVE-2023-36519": {"epss_score": 0.00203, "epss_percentile": 0.42543}, "CVE-2023-36520": {"epss_score": 0.00056, "epss_percentile": 0.17733}, "CVE-2023-36521": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2023-36522": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-36523": {"epss_score": 0.00366, "epss_percentile": 0.58053}, "CVE-2023-36525": {"epss_score": 0.00072, "epss_percentile": 0.224}, "CVE-2023-36526": {"epss_score": 0.00142, "epss_percentile": 0.35024}, "CVE-2023-36527": {"epss_score": 0.00692, "epss_percentile": 0.71305}, "CVE-2023-36528": {"epss_score": 0.00213, "epss_percentile": 0.4388}, "CVE-2023-36529": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-36530": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-36531": {"epss_score": 0.06272, "epss_percentile": 0.90629}, "CVE-2023-36532": {"epss_score": 0.00523, "epss_percentile": 0.66296}, "CVE-2023-36533": {"epss_score": 0.00324, "epss_percentile": 0.54961}, "CVE-2023-36534": {"epss_score": 0.00475, "epss_percentile": 0.6425}, "CVE-2023-36535": {"epss_score": 0.00173, "epss_percentile": 0.39111}, "CVE-2023-36536": {"epss_score": 0.00055, "epss_percentile": 0.1753}, "CVE-2023-36537": {"epss_score": 0.0003, "epss_percentile": 0.08066}, "CVE-2023-36538": {"epss_score": 0.0004, "epss_percentile": 0.11991}, "CVE-2023-36539": {"epss_score": 0.00139, "epss_percentile": 0.34582}, "CVE-2023-36540": {"epss_score": 0.00034, "epss_percentile": 0.09464}, "CVE-2023-36541": {"epss_score": 0.00298, "epss_percentile": 0.52777}, "CVE-2023-36542": {"epss_score": 0.01251, "epss_percentile": 0.78895}, "CVE-2023-36543": {"epss_score": 0.00806, "epss_percentile": 0.73663}, "CVE-2023-36547": {"epss_score": 0.01407, "epss_percentile": 0.80057}, "CVE-2023-36548": {"epss_score": 0.01407, "epss_percentile": 0.80057}, "CVE-2023-36549": {"epss_score": 0.02903, "epss_percentile": 0.85957}, "CVE-2023-36550": {"epss_score": 0.01407, "epss_percentile": 0.80057}, "CVE-2023-36551": {"epss_score": 0.00474, "epss_percentile": 0.64158}, "CVE-2023-36553": {"epss_score": 0.01825, "epss_percentile": 0.8243}, "CVE-2023-36554": {"epss_score": 0.00202, "epss_percentile": 0.4242}, "CVE-2023-36555": {"epss_score": 0.00124, "epss_percentile": 0.3244}, "CVE-2023-36556": {"epss_score": 0.00275, "epss_percentile": 0.50687}, "CVE-2023-36557": {"epss_score": 0.00243, "epss_percentile": 0.4741}, "CVE-2023-36558": {"epss_score": 0.00324, "epss_percentile": 0.5497}, "CVE-2023-36559": {"epss_score": 0.00185, "epss_percentile": 0.40529}, "CVE-2023-36560": {"epss_score": 0.0417, "epss_percentile": 0.88346}, "CVE-2023-36561": {"epss_score": 0.00274, "epss_percentile": 0.50517}, "CVE-2023-36562": {"epss_score": 0.00345, "epss_percentile": 0.56584}, "CVE-2023-36563": {"epss_score": 0.02473, "epss_percentile": 0.84851}, "CVE-2023-36564": {"epss_score": 0.00135, "epss_percentile": 0.33934}, "CVE-2023-36565": {"epss_score": 0.00094, "epss_percentile": 0.2703}, "CVE-2023-36566": {"epss_score": 0.09686, "epss_percentile": 0.92662}, "CVE-2023-36567": {"epss_score": 0.05289, "epss_percentile": 0.89695}, "CVE-2023-36568": {"epss_score": 0.0022, "epss_percentile": 0.44587}, "CVE-2023-36569": {"epss_score": 0.00147, "epss_percentile": 0.35792}, "CVE-2023-36570": {"epss_score": 0.00423, "epss_percentile": 0.61622}, "CVE-2023-36571": {"epss_score": 0.00423, "epss_percentile": 0.61622}, "CVE-2023-36572": {"epss_score": 0.00423, "epss_percentile": 0.61622}, "CVE-2023-36573": {"epss_score": 0.00423, "epss_percentile": 0.61622}, "CVE-2023-36574": {"epss_score": 0.00423, "epss_percentile": 0.61622}, "CVE-2023-36575": {"epss_score": 0.00423, "epss_percentile": 0.61622}, "CVE-2023-36576": {"epss_score": 0.00496, "epss_percentile": 0.6514}, "CVE-2023-36577": {"epss_score": 0.00191, "epss_percentile": 0.41256}, "CVE-2023-36578": {"epss_score": 0.00296, "epss_percentile": 0.52582}, "CVE-2023-36579": {"epss_score": 0.06827, "epss_percentile": 0.91052}, "CVE-2023-36581": {"epss_score": 0.00387, "epss_percentile": 0.59309}, "CVE-2023-36582": {"epss_score": 0.00653, "epss_percentile": 0.7032}, "CVE-2023-36583": {"epss_score": 0.00611, "epss_percentile": 0.69199}, "CVE-2023-36584": {"epss_score": 0.18516, "epss_percentile": 0.95027}, "CVE-2023-36585": {"epss_score": 0.03669, "epss_percentile": 0.87537}, "CVE-2023-36589": {"epss_score": 0.00423, "epss_percentile": 0.61622}, "CVE-2023-36590": {"epss_score": 0.0031, "epss_percentile": 0.53748}, "CVE-2023-36591": {"epss_score": 0.00423, "epss_percentile": 0.61622}, "CVE-2023-36592": {"epss_score": 0.00423, "epss_percentile": 0.61622}, "CVE-2023-36593": {"epss_score": 0.0065, "epss_percentile": 0.70249}, "CVE-2023-36594": {"epss_score": 0.02772, "epss_percentile": 0.85622}, "CVE-2023-36596": {"epss_score": 0.00303, "epss_percentile": 0.53232}, "CVE-2023-36598": {"epss_score": 0.00461, "epss_percentile": 0.63559}, "CVE-2023-36602": {"epss_score": 0.03748, "epss_percentile": 0.87669}, "CVE-2023-36603": {"epss_score": 0.03748, "epss_percentile": 0.87669}, "CVE-2023-36605": {"epss_score": 0.00102, "epss_percentile": 0.28769}, "CVE-2023-36606": {"epss_score": 0.49765, "epss_percentile": 0.97705}, "CVE-2023-36607": {"epss_score": 0.00097, "epss_percentile": 0.27541}, "CVE-2023-36608": {"epss_score": 0.00045, "epss_percentile": 0.13967}, "CVE-2023-36609": {"epss_score": 0.00069, "epss_percentile": 0.21629}, "CVE-2023-36610": {"epss_score": 0.00121, "epss_percentile": 0.31813}, "CVE-2023-36611": {"epss_score": 0.00082, "epss_percentile": 0.24503}, "CVE-2023-36612": {"epss_score": 0.00301, "epss_percentile": 0.52996}, "CVE-2023-36617": {"epss_score": 0.01074, "epss_percentile": 0.77303}, "CVE-2023-36618": {"epss_score": 0.00868, "epss_percentile": 0.74675}, "CVE-2023-36619": {"epss_score": 0.00884, "epss_percentile": 0.74927}, "CVE-2023-36620": {"epss_score": 0.00071, "epss_percentile": 0.22088}, "CVE-2023-36621": {"epss_score": 0.00104, "epss_percentile": 0.29214}, "CVE-2023-36622": {"epss_score": 0.00271, "epss_percentile": 0.50327}, "CVE-2023-36623": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2023-36624": {"epss_score": 0.00085, "epss_percentile": 0.25123}, "CVE-2023-36627": {"epss_score": 0.00038, "epss_percentile": 0.11078}, "CVE-2023-36628": {"epss_score": 0.00168, "epss_percentile": 0.38431}, "CVE-2023-36629": {"epss_score": 0.00042, "epss_percentile": 0.12626}, "CVE-2023-36630": {"epss_score": 0.00088, "epss_percentile": 0.25728}, "CVE-2023-36631": {"epss_score": 8e-05, "epss_percentile": 0.00581}, "CVE-2023-36632": {"epss_score": 0.00112, "epss_percentile": 0.3058}, "CVE-2023-36633": {"epss_score": 0.00197, "epss_percentile": 0.41905}, "CVE-2023-36634": {"epss_score": 0.00125, "epss_percentile": 0.32574}, "CVE-2023-36635": {"epss_score": 0.00102, "epss_percentile": 0.28823}, "CVE-2023-36637": {"epss_score": 0.0027, "epss_percentile": 0.50247}, "CVE-2023-36638": {"epss_score": 0.00132, "epss_percentile": 0.33516}, "CVE-2023-36639": {"epss_score": 0.00173, "epss_percentile": 0.39076}, "CVE-2023-36640": {"epss_score": 0.00087, "epss_percentile": 0.25572}, "CVE-2023-36641": {"epss_score": 0.00474, "epss_percentile": 0.64144}, "CVE-2023-36642": {"epss_score": 0.00102, "epss_percentile": 0.28857}, "CVE-2023-36643": {"epss_score": 0.00861, "epss_percentile": 0.74565}, "CVE-2023-36644": {"epss_score": 0.00677, "epss_percentile": 0.7095}, "CVE-2023-36645": {"epss_score": 0.00241, "epss_percentile": 0.47244}, "CVE-2023-36646": {"epss_score": 0.0034, "epss_percentile": 0.56268}, "CVE-2023-36647": {"epss_score": 0.00073, "epss_percentile": 0.22611}, "CVE-2023-36648": {"epss_score": 0.00591, "epss_percentile": 0.68577}, "CVE-2023-36649": {"epss_score": 0.00103, "epss_percentile": 0.29065}, "CVE-2023-36650": {"epss_score": 0.00061, "epss_percentile": 0.19427}, "CVE-2023-36651": {"epss_score": 0.00279, "epss_percentile": 0.50964}, "CVE-2023-36652": {"epss_score": 0.00052, "epss_percentile": 0.16517}, "CVE-2023-36654": {"epss_score": 0.0022, "epss_percentile": 0.44572}, "CVE-2023-36655": {"epss_score": 0.00106, "epss_percentile": 0.29474}, "CVE-2023-36656": {"epss_score": 0.00473, "epss_percentile": 0.64091}, "CVE-2023-36657": {"epss_score": 0.00409, "epss_percentile": 0.60722}, "CVE-2023-36658": {"epss_score": 0.00122, "epss_percentile": 0.32069}, "CVE-2023-36659": {"epss_score": 0.01937, "epss_percentile": 0.82964}, "CVE-2023-36660": {"epss_score": 0.00109, "epss_percentile": 0.29998}, "CVE-2023-36661": {"epss_score": 0.60666, "epss_percentile": 0.98216}, "CVE-2023-36662": {"epss_score": 0.00452, "epss_percentile": 0.63196}, "CVE-2023-36663": {"epss_score": 0.00325, "epss_percentile": 0.55007}, "CVE-2023-36664": {"epss_score": 0.06431, "epss_percentile": 0.90755}, "CVE-2023-36665": {"epss_score": 0.01673, "epss_percentile": 0.81688}, "CVE-2023-36666": {"epss_score": 0.00118, "epss_percentile": 0.31429}, "CVE-2023-36667": {"epss_score": 0.01004, "epss_percentile": 0.76527}, "CVE-2023-36669": {"epss_score": 0.00216, "epss_percentile": 0.44139}, "CVE-2023-36670": {"epss_score": 0.00309, "epss_percentile": 0.53682}, "CVE-2023-36671": {"epss_score": 0.00033, "epss_percentile": 0.09373}, "CVE-2023-36672": {"epss_score": 0.00032, "epss_percentile": 0.0902}, "CVE-2023-36673": {"epss_score": 0.0004, "epss_percentile": 0.12021}, "CVE-2023-36674": {"epss_score": 0.00044, "epss_percentile": 0.13384}, "CVE-2023-36675": {"epss_score": 0.00526, "epss_percentile": 0.66429}, "CVE-2023-36676": {"epss_score": 0.00209, "epss_percentile": 0.43329}, "CVE-2023-36677": {"epss_score": 0.00211, "epss_percentile": 0.43621}, "CVE-2023-36678": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-36679": {"epss_score": 0.00356, "epss_percentile": 0.57364}, "CVE-2023-36680": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-36681": {"epss_score": 0.00685, "epss_percentile": 0.7114}, "CVE-2023-36682": {"epss_score": 0.00174, "epss_percentile": 0.39212}, "CVE-2023-36683": {"epss_score": 0.00644, "epss_percentile": 0.70074}, "CVE-2023-36684": {"epss_score": 0.00642, "epss_percentile": 0.70035}, "CVE-2023-36685": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-36686": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-36687": {"epss_score": 0.00047, "epss_percentile": 0.14827}, "CVE-2023-36688": {"epss_score": 0.00078, "epss_percentile": 0.2377}, "CVE-2023-36689": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-36690": {"epss_score": 0.00072, "epss_percentile": 0.22277}, "CVE-2023-36691": {"epss_score": 0.00098, "epss_percentile": 0.27832}, "CVE-2023-36692": {"epss_score": 0.00063, "epss_percentile": 0.19871}, "CVE-2023-36693": {"epss_score": 0.00077, "epss_percentile": 0.23287}, "CVE-2023-36694": {"epss_score": 0.00161, "epss_percentile": 0.37529}, "CVE-2023-36695": {"epss_score": 0.00244, "epss_percentile": 0.47595}, "CVE-2023-36696": {"epss_score": 0.00108, "epss_percentile": 0.29756}, "CVE-2023-36697": {"epss_score": 0.00144, "epss_percentile": 0.3525}, "CVE-2023-36698": {"epss_score": 0.0008, "epss_percentile": 0.2411}, "CVE-2023-36701": {"epss_score": 0.00095, "epss_percentile": 0.27225}, "CVE-2023-36702": {"epss_score": 0.00273, "epss_percentile": 0.50436}, "CVE-2023-36703": {"epss_score": 0.07996, "epss_percentile": 0.91812}, "CVE-2023-36704": {"epss_score": 0.00247, "epss_percentile": 0.47846}, "CVE-2023-36705": {"epss_score": 0.00162, "epss_percentile": 0.37665}, "CVE-2023-36706": {"epss_score": 0.0608, "epss_percentile": 0.90462}, "CVE-2023-36707": {"epss_score": 0.04988, "epss_percentile": 0.89365}, "CVE-2023-36709": {"epss_score": 0.03748, "epss_percentile": 0.87669}, "CVE-2023-36710": {"epss_score": 0.00228, "epss_percentile": 0.45463}, "CVE-2023-36711": {"epss_score": 0.00108, "epss_percentile": 0.29812}, "CVE-2023-36712": {"epss_score": 0.00258, "epss_percentile": 0.49006}, "CVE-2023-36713": {"epss_score": 0.02083, "epss_percentile": 0.8354}, "CVE-2023-36717": {"epss_score": 0.00064, "epss_percentile": 0.20401}, "CVE-2023-36718": {"epss_score": 0.00107, "epss_percentile": 0.29729}, "CVE-2023-36719": {"epss_score": 0.00134, "epss_percentile": 0.33912}, "CVE-2023-36720": {"epss_score": 0.00529, "epss_percentile": 0.66601}, "CVE-2023-36721": {"epss_score": 0.00086, "epss_percentile": 0.25359}, "CVE-2023-36722": {"epss_score": 0.00068, "epss_percentile": 0.21407}, "CVE-2023-36723": {"epss_score": 0.08189, "epss_percentile": 0.9192}, "CVE-2023-36724": {"epss_score": 0.00102, "epss_percentile": 0.28768}, "CVE-2023-36725": {"epss_score": 0.00086, "epss_percentile": 0.25359}, "CVE-2023-36726": {"epss_score": 0.00102, "epss_percentile": 0.28769}, "CVE-2023-36727": {"epss_score": 0.00602, "epss_percentile": 0.68891}, "CVE-2023-36728": {"epss_score": 0.0008, "epss_percentile": 0.24184}, "CVE-2023-36729": {"epss_score": 0.00095, "epss_percentile": 0.27225}, "CVE-2023-36730": {"epss_score": 0.00532, "epss_percentile": 0.66683}, "CVE-2023-36731": {"epss_score": 0.00721, "epss_percentile": 0.71981}, "CVE-2023-36732": {"epss_score": 0.00103, "epss_percentile": 0.28971}, "CVE-2023-36735": {"epss_score": 0.00718, "epss_percentile": 0.71921}, "CVE-2023-36736": {"epss_score": 0.00205, "epss_percentile": 0.42684}, "CVE-2023-36737": {"epss_score": 0.00223, "epss_percentile": 0.44849}, "CVE-2023-36739": {"epss_score": 0.0027, "epss_percentile": 0.50226}, "CVE-2023-36740": {"epss_score": 0.0027, "epss_percentile": 0.50226}, "CVE-2023-36741": {"epss_score": 0.00902, "epss_percentile": 0.75189}, "CVE-2023-36742": {"epss_score": 0.00235, "epss_percentile": 0.46213}, "CVE-2023-36743": {"epss_score": 0.01236, "epss_percentile": 0.78772}, "CVE-2023-36744": {"epss_score": 0.00296, "epss_percentile": 0.52571}, "CVE-2023-36745": {"epss_score": 0.73589, "epss_percentile": 0.98763}, "CVE-2023-36746": {"epss_score": 0.00043, "epss_percentile": 0.13001}, "CVE-2023-36747": {"epss_score": 0.00031, "epss_percentile": 0.08637}, "CVE-2023-36748": {"epss_score": 0.00048, "epss_percentile": 0.1528}, "CVE-2023-36749": {"epss_score": 0.00083, "epss_percentile": 0.24805}, "CVE-2023-36750": {"epss_score": 0.0082, "epss_percentile": 0.73883}, "CVE-2023-36751": {"epss_score": 0.0082, "epss_percentile": 0.73883}, "CVE-2023-36752": {"epss_score": 0.0082, "epss_percentile": 0.73883}, "CVE-2023-36753": {"epss_score": 0.0082, "epss_percentile": 0.73883}, "CVE-2023-36754": {"epss_score": 0.00686, "epss_percentile": 0.71165}, "CVE-2023-36755": {"epss_score": 0.00706, "epss_percentile": 0.71612}, "CVE-2023-36756": {"epss_score": 0.00402, "epss_percentile": 0.60295}, "CVE-2023-36757": {"epss_score": 0.00244, "epss_percentile": 0.47569}, "CVE-2023-36758": {"epss_score": 0.00155, "epss_percentile": 0.3677}, "CVE-2023-36759": {"epss_score": 0.00326, "epss_percentile": 0.55072}, "CVE-2023-36760": {"epss_score": 0.0027, "epss_percentile": 0.50226}, "CVE-2023-36761": {"epss_score": 0.07326, "epss_percentile": 0.91411}, "CVE-2023-36762": {"epss_score": 0.00107, "epss_percentile": 0.29668}, "CVE-2023-36763": {"epss_score": 0.0128, "epss_percentile": 0.79139}, "CVE-2023-36764": {"epss_score": 0.0102, "epss_percentile": 0.76731}, "CVE-2023-36765": {"epss_score": 0.00102, "epss_percentile": 0.2874}, "CVE-2023-36766": {"epss_score": 0.00383, "epss_percentile": 0.59096}, "CVE-2023-36767": {"epss_score": 0.00327, "epss_percentile": 0.55139}, "CVE-2023-36769": {"epss_score": 0.00103, "epss_percentile": 0.28981}, "CVE-2023-36770": {"epss_score": 0.0027, "epss_percentile": 0.50226}, "CVE-2023-36771": {"epss_score": 0.00319, "epss_percentile": 0.54531}, "CVE-2023-36772": {"epss_score": 0.00319, "epss_percentile": 0.54531}, "CVE-2023-36773": {"epss_score": 0.00319, "epss_percentile": 0.54531}, "CVE-2023-36776": {"epss_score": 0.00949, "epss_percentile": 0.75839}, "CVE-2023-36777": {"epss_score": 0.00525, "epss_percentile": 0.6639}, "CVE-2023-36778": {"epss_score": 0.01387, "epss_percentile": 0.79918}, "CVE-2023-36780": {"epss_score": 0.00702, "epss_percentile": 0.71524}, "CVE-2023-36785": {"epss_score": 0.00566, "epss_percentile": 0.67817}, "CVE-2023-36786": {"epss_score": 0.00726, "epss_percentile": 0.72066}, "CVE-2023-36787": {"epss_score": 0.03845, "epss_percentile": 0.87842}, "CVE-2023-36788": {"epss_score": 0.00382, "epss_percentile": 0.59055}, "CVE-2023-36789": {"epss_score": 0.00725, "epss_percentile": 0.72047}, "CVE-2023-36790": {"epss_score": 0.0019, "epss_percentile": 0.41057}, "CVE-2023-36792": {"epss_score": 0.01286, "epss_percentile": 0.79182}, "CVE-2023-36793": {"epss_score": 0.01533, "epss_percentile": 0.80898}, "CVE-2023-36794": {"epss_score": 0.00991, "epss_percentile": 0.76386}, "CVE-2023-36796": {"epss_score": 0.00997, "epss_percentile": 0.76458}, "CVE-2023-36799": {"epss_score": 0.01143, "epss_percentile": 0.77981}, "CVE-2023-36800": {"epss_score": 0.00228, "epss_percentile": 0.45529}, "CVE-2023-36801": {"epss_score": 0.00248, "epss_percentile": 0.47964}, "CVE-2023-36802": {"epss_score": 0.78911, "epss_percentile": 0.99011}, "CVE-2023-36803": {"epss_score": 0.00499, "epss_percentile": 0.6526}, "CVE-2023-36804": {"epss_score": 0.00071, "epss_percentile": 0.21991}, "CVE-2023-36805": {"epss_score": 0.00221, "epss_percentile": 0.44635}, "CVE-2023-36806": {"epss_score": 0.00192, "epss_percentile": 0.41367}, "CVE-2023-36807": {"epss_score": 0.00219, "epss_percentile": 0.44475}, "CVE-2023-36808": {"epss_score": 0.1866, "epss_percentile": 0.95048}, "CVE-2023-36809": {"epss_score": 0.00567, "epss_percentile": 0.67849}, "CVE-2023-36810": {"epss_score": 0.00123, "epss_percentile": 0.32327}, "CVE-2023-36811": {"epss_score": 0.00062, "epss_percentile": 0.1956}, "CVE-2023-36812": {"epss_score": 0.84907, "epss_percentile": 0.9931}, "CVE-2023-36813": {"epss_score": 0.00051, "epss_percentile": 0.16267}, "CVE-2023-36814": {"epss_score": 0.00218, "epss_percentile": 0.44396}, "CVE-2023-36815": {"epss_score": 0.00194, "epss_percentile": 0.41531}, "CVE-2023-36816": {"epss_score": 0.00556, "epss_percentile": 0.6753}, "CVE-2023-36817": {"epss_score": 0.00086, "epss_percentile": 0.25426}, "CVE-2023-36818": {"epss_score": 0.00292, "epss_percentile": 0.52281}, "CVE-2023-36819": {"epss_score": 0.00126, "epss_percentile": 0.32629}, "CVE-2023-36820": {"epss_score": 0.0049, "epss_percentile": 0.64941}, "CVE-2023-36821": {"epss_score": 0.02508, "epss_percentile": 0.84941}, "CVE-2023-36822": {"epss_score": 0.00592, "epss_percentile": 0.68606}, "CVE-2023-36823": {"epss_score": 0.00332, "epss_percentile": 0.55561}, "CVE-2023-36824": {"epss_score": 0.90842, "epss_percentile": 0.99604}, "CVE-2023-36825": {"epss_score": 0.05411, "epss_percentile": 0.89846}, "CVE-2023-36826": {"epss_score": 0.0018, "epss_percentile": 0.3997}, "CVE-2023-36827": {"epss_score": 0.00134, "epss_percentile": 0.33869}, "CVE-2023-36828": {"epss_score": 0.00236, "epss_percentile": 0.46436}, "CVE-2023-36829": {"epss_score": 0.0015, "epss_percentile": 0.36056}, "CVE-2023-36830": {"epss_score": 0.00138, "epss_percentile": 0.34508}, "CVE-2023-36831": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-36832": {"epss_score": 0.00197, "epss_percentile": 0.41912}, "CVE-2023-36833": {"epss_score": 0.00101, "epss_percentile": 0.28617}, "CVE-2023-36834": {"epss_score": 0.00095, "epss_percentile": 0.27093}, "CVE-2023-36835": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-36836": {"epss_score": 0.00051, "epss_percentile": 0.16161}, "CVE-2023-36838": {"epss_score": 0.00042, "epss_percentile": 0.12751}, "CVE-2023-36839": {"epss_score": 0.00039, "epss_percentile": 0.11694}, "CVE-2023-36840": {"epss_score": 0.00069, "epss_percentile": 0.21587}, "CVE-2023-36841": {"epss_score": 0.00126, "epss_percentile": 0.32747}, "CVE-2023-36842": {"epss_score": 0.00038, "epss_percentile": 0.11408}, "CVE-2023-36843": {"epss_score": 0.00086, "epss_percentile": 0.25374}, "CVE-2023-36844": {"epss_score": 0.94302, "epss_percentile": 0.99941}, "CVE-2023-36845": {"epss_score": 0.94355, "epss_percentile": 0.99957}, "CVE-2023-36846": {"epss_score": 0.94226, "epss_percentile": 0.9992}, "CVE-2023-36847": {"epss_score": 0.94042, "epss_percentile": 0.99891}, "CVE-2023-36848": {"epss_score": 0.00081, "epss_percentile": 0.24299}, "CVE-2023-36849": {"epss_score": 0.00085, "epss_percentile": 0.25234}, "CVE-2023-36850": {"epss_score": 0.0006, "epss_percentile": 0.18968}, "CVE-2023-36851": {"epss_score": 0.15289, "epss_percentile": 0.94402}, "CVE-2023-36853": {"epss_score": 0.00031, "epss_percentile": 0.08504}, "CVE-2023-36854": {"epss_score": 0.00042, "epss_percentile": 0.12809}, "CVE-2023-36857": {"epss_score": 0.00062, "epss_percentile": 0.19646}, "CVE-2023-36858": {"epss_score": 0.00071, "epss_percentile": 0.22041}, "CVE-2023-36859": {"epss_score": 0.00103, "epss_percentile": 0.29065}, "CVE-2023-36860": {"epss_score": 0.00221, "epss_percentile": 0.44643}, "CVE-2023-36861": {"epss_score": 0.0005, "epss_percentile": 0.15894}, "CVE-2023-36862": {"epss_score": 0.00063, "epss_percentile": 0.19831}, "CVE-2023-36864": {"epss_score": 0.00065, "epss_percentile": 0.20655}, "CVE-2023-36865": {"epss_score": 0.00766, "epss_percentile": 0.72938}, "CVE-2023-36866": {"epss_score": 0.00458, "epss_percentile": 0.634}, "CVE-2023-36867": {"epss_score": 0.00252, "epss_percentile": 0.48375}, "CVE-2023-36868": {"epss_score": 0.00132, "epss_percentile": 0.33567}, "CVE-2023-36869": {"epss_score": 0.00181, "epss_percentile": 0.40075}, "CVE-2023-36871": {"epss_score": 0.00262, "epss_percentile": 0.49328}, "CVE-2023-36872": {"epss_score": 0.00253, "epss_percentile": 0.48484}, "CVE-2023-36873": {"epss_score": 0.00414, "epss_percentile": 0.61029}, "CVE-2023-36874": {"epss_score": 0.68731, "epss_percentile": 0.9856}, "CVE-2023-36876": {"epss_score": 0.00102, "epss_percentile": 0.28869}, "CVE-2023-36877": {"epss_score": 0.0027, "epss_percentile": 0.50259}, "CVE-2023-36878": {"epss_score": 0.00111, "epss_percentile": 0.30262}, "CVE-2023-36880": {"epss_score": 0.0101, "epss_percentile": 0.766}, "CVE-2023-36881": {"epss_score": 0.00241, "epss_percentile": 0.47292}, "CVE-2023-36882": {"epss_score": 0.00379, "epss_percentile": 0.58886}, "CVE-2023-36883": {"epss_score": 0.00204, "epss_percentile": 0.42615}, "CVE-2023-36884": {"epss_score": 0.9322, "epss_percentile": 0.99785}, "CVE-2023-36886": {"epss_score": 0.00228, "epss_percentile": 0.45529}, "CVE-2023-36887": {"epss_score": 0.01177, "epss_percentile": 0.78279}, "CVE-2023-36888": {"epss_score": 0.00163, "epss_percentile": 0.37827}, "CVE-2023-36889": {"epss_score": 0.00146, "epss_percentile": 0.35589}, "CVE-2023-36890": {"epss_score": 0.02215, "epss_percentile": 0.84028}, "CVE-2023-36891": {"epss_score": 0.00247, "epss_percentile": 0.47862}, "CVE-2023-36892": {"epss_score": 0.00247, "epss_percentile": 0.47862}, "CVE-2023-36893": {"epss_score": 0.00817, "epss_percentile": 0.73844}, "CVE-2023-36894": {"epss_score": 0.01341, "epss_percentile": 0.79582}, "CVE-2023-36895": {"epss_score": 0.00631, "epss_percentile": 0.69731}, "CVE-2023-36896": {"epss_score": 0.00766, "epss_percentile": 0.72938}, "CVE-2023-36897": {"epss_score": 0.00156, "epss_percentile": 0.37008}, "CVE-2023-36898": {"epss_score": 0.00299, "epss_percentile": 0.52842}, "CVE-2023-36899": {"epss_score": 0.69655, "epss_percentile": 0.98596}, "CVE-2023-36900": {"epss_score": 0.24034, "epss_percentile": 0.95848}, "CVE-2023-36902": {"epss_score": 0.00335, "epss_percentile": 0.55864}, "CVE-2023-36903": {"epss_score": 0.00773, "epss_percentile": 0.73049}, "CVE-2023-36904": {"epss_score": 0.00124, "epss_percentile": 0.3236}, "CVE-2023-36905": {"epss_score": 0.03753, "epss_percentile": 0.87678}, "CVE-2023-36906": {"epss_score": 0.04028, "epss_percentile": 0.88146}, "CVE-2023-36907": {"epss_score": 0.04028, "epss_percentile": 0.88146}, "CVE-2023-36908": {"epss_score": 0.00221, "epss_percentile": 0.44713}, "CVE-2023-36909": {"epss_score": 0.00466, "epss_percentile": 0.63803}, "CVE-2023-36910": {"epss_score": 0.03462, "epss_percentile": 0.87185}, "CVE-2023-36911": {"epss_score": 0.03462, "epss_percentile": 0.87185}, "CVE-2023-36912": {"epss_score": 0.0483, "epss_percentile": 0.8919}, "CVE-2023-36913": {"epss_score": 0.00443, "epss_percentile": 0.62789}, "CVE-2023-36914": {"epss_score": 0.00182, "epss_percentile": 0.40187}, "CVE-2023-36915": {"epss_score": 0.0005, "epss_percentile": 0.15894}, "CVE-2023-36916": {"epss_score": 0.0005, "epss_percentile": 0.15894}, "CVE-2023-36917": {"epss_score": 0.00073, "epss_percentile": 0.22642}, "CVE-2023-36918": {"epss_score": 0.0042, "epss_percentile": 0.61437}, "CVE-2023-36919": {"epss_score": 0.00277, "epss_percentile": 0.50818}, "CVE-2023-36920": {"epss_score": 0.00109, "epss_percentile": 0.29999}, "CVE-2023-36921": {"epss_score": 0.00309, "epss_percentile": 0.53721}, "CVE-2023-36922": {"epss_score": 0.00171, "epss_percentile": 0.38884}, "CVE-2023-36923": {"epss_score": 0.00064, "epss_percentile": 0.20421}, "CVE-2023-36924": {"epss_score": 0.00095, "epss_percentile": 0.27193}, "CVE-2023-36925": {"epss_score": 0.00495, "epss_percentile": 0.65101}, "CVE-2023-36926": {"epss_score": 0.00219, "epss_percentile": 0.44443}, "CVE-2023-36932": {"epss_score": 0.17875, "epss_percentile": 0.94921}, "CVE-2023-36933": {"epss_score": 0.19155, "epss_percentile": 0.9514}, "CVE-2023-36934": {"epss_score": 0.9139, "epss_percentile": 0.99638}, "CVE-2023-36936": {"epss_score": 0.00213, "epss_percentile": 0.43926}, "CVE-2023-36939": {"epss_score": 0.00132, "epss_percentile": 0.33581}, "CVE-2023-36940": {"epss_score": 0.00088, "epss_percentile": 0.25644}, "CVE-2023-36941": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-36942": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-36947": {"epss_score": 0.00907, "epss_percentile": 0.75263}, "CVE-2023-36950": {"epss_score": 0.00907, "epss_percentile": 0.75263}, "CVE-2023-36952": {"epss_score": 0.0021, "epss_percentile": 0.43481}, "CVE-2023-36953": {"epss_score": 0.02985, "epss_percentile": 0.86129}, "CVE-2023-36954": {"epss_score": 0.02985, "epss_percentile": 0.86129}, "CVE-2023-36955": {"epss_score": 0.0021, "epss_percentile": 0.43481}, "CVE-2023-36968": {"epss_score": 0.00187, "epss_percentile": 0.40729}, "CVE-2023-36969": {"epss_score": 0.62561, "epss_percentile": 0.98297}, "CVE-2023-36970": {"epss_score": 0.00129, "epss_percentile": 0.331}, "CVE-2023-36980": {"epss_score": 0.00067, "epss_percentile": 0.20967}, "CVE-2023-36983": {"epss_score": 0.00123, "epss_percentile": 0.32295}, "CVE-2023-36984": {"epss_score": 0.00123, "epss_percentile": 0.32295}, "CVE-2023-36992": {"epss_score": 0.0031, "epss_percentile": 0.53742}, "CVE-2023-36993": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-36994": {"epss_score": 0.00112, "epss_percentile": 0.30418}, "CVE-2023-36995": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-36998": {"epss_score": 0.00141, "epss_percentile": 0.34829}, "CVE-2023-37002": {"epss_score": 0.00035, "epss_percentile": 0.09861}, "CVE-2023-37003": {"epss_score": 0.00035, "epss_percentile": 0.09861}, "CVE-2023-37004": {"epss_score": 0.00035, "epss_percentile": 0.09861}, "CVE-2023-37005": {"epss_score": 0.00035, "epss_percentile": 0.09861}, "CVE-2023-37006": {"epss_score": 0.00035, "epss_percentile": 0.09861}, "CVE-2023-37007": {"epss_score": 0.00035, "epss_percentile": 0.09861}, "CVE-2023-37008": {"epss_score": 0.00027, "epss_percentile": 0.06817}, "CVE-2023-37009": {"epss_score": 0.0009, "epss_percentile": 0.26051}, "CVE-2023-37010": {"epss_score": 0.0009, "epss_percentile": 0.26051}, "CVE-2023-37011": {"epss_score": 0.0009, "epss_percentile": 0.26051}, "CVE-2023-37012": {"epss_score": 0.00035, "epss_percentile": 0.09861}, "CVE-2023-37013": {"epss_score": 0.00092, "epss_percentile": 0.26567}, "CVE-2023-37014": {"epss_score": 0.00252, "epss_percentile": 0.48341}, "CVE-2023-37015": {"epss_score": 0.00099, "epss_percentile": 0.28414}, "CVE-2023-37016": {"epss_score": 0.00099, "epss_percentile": 0.28414}, "CVE-2023-37017": {"epss_score": 0.00099, "epss_percentile": 0.28414}, "CVE-2023-37018": {"epss_score": 0.00099, "epss_percentile": 0.28414}, "CVE-2023-37019": {"epss_score": 0.00099, "epss_percentile": 0.28414}, "CVE-2023-37020": {"epss_score": 0.00099, "epss_percentile": 0.28414}, "CVE-2023-37021": {"epss_score": 0.00099, "epss_percentile": 0.28414}, "CVE-2023-37022": {"epss_score": 0.00252, "epss_percentile": 0.48341}, "CVE-2023-37023": {"epss_score": 0.00099, "epss_percentile": 0.28414}, "CVE-2023-37024": {"epss_score": 0.00256, "epss_percentile": 0.48775}, "CVE-2023-37025": {"epss_score": 0.00136, "epss_percentile": 0.34152}, "CVE-2023-37026": {"epss_score": 0.00136, "epss_percentile": 0.34152}, "CVE-2023-37027": {"epss_score": 0.00133, "epss_percentile": 0.33637}, "CVE-2023-37028": {"epss_score": 0.00147, "epss_percentile": 0.35797}, "CVE-2023-37029": {"epss_score": 0.00146, "epss_percentile": 0.356}, "CVE-2023-37030": {"epss_score": 0.00154, "epss_percentile": 0.36708}, "CVE-2023-37031": {"epss_score": 0.00154, "epss_percentile": 0.36708}, "CVE-2023-37032": {"epss_score": 0.01134, "epss_percentile": 0.77893}, "CVE-2023-37033": {"epss_score": 0.00154, "epss_percentile": 0.36708}, "CVE-2023-37034": {"epss_score": 0.00154, "epss_percentile": 0.36708}, "CVE-2023-37035": {"epss_score": 0.00136, "epss_percentile": 0.34152}, "CVE-2023-37036": {"epss_score": 0.00154, "epss_percentile": 0.36708}, "CVE-2023-37037": {"epss_score": 0.00154, "epss_percentile": 0.36708}, "CVE-2023-37038": {"epss_score": 0.00154, "epss_percentile": 0.36708}, "CVE-2023-37039": {"epss_score": 0.00148, "epss_percentile": 0.35846}, "CVE-2023-37049": {"epss_score": 0.00102, "epss_percentile": 0.28802}, "CVE-2023-37057": {"epss_score": 0.07233, "epss_percentile": 0.91339}, "CVE-2023-37058": {"epss_score": 0.01106, "epss_percentile": 0.77614}, "CVE-2023-37061": {"epss_score": 0.00339, "epss_percentile": 0.56168}, "CVE-2023-37062": {"epss_score": 0.00389, "epss_percentile": 0.59408}, "CVE-2023-37063": {"epss_score": 0.00389, "epss_percentile": 0.59408}, "CVE-2023-37064": {"epss_score": 0.00389, "epss_percentile": 0.59408}, "CVE-2023-37065": {"epss_score": 0.00389, "epss_percentile": 0.59408}, "CVE-2023-37066": {"epss_score": 0.00389, "epss_percentile": 0.59408}, "CVE-2023-37067": {"epss_score": 0.00389, "epss_percentile": 0.59408}, "CVE-2023-37068": {"epss_score": 0.00269, "epss_percentile": 0.50121}, "CVE-2023-37069": {"epss_score": 0.00073, "epss_percentile": 0.22583}, "CVE-2023-37070": {"epss_score": 0.00076, "epss_percentile": 0.23262}, "CVE-2023-37117": {"epss_score": 0.00252, "epss_percentile": 0.48386}, "CVE-2023-37122": {"epss_score": 0.00082, "epss_percentile": 0.24542}, "CVE-2023-37124": {"epss_score": 0.00082, "epss_percentile": 0.24542}, "CVE-2023-37125": {"epss_score": 0.00082, "epss_percentile": 0.24542}, "CVE-2023-37131": {"epss_score": 0.0005, "epss_percentile": 0.15875}, "CVE-2023-37132": {"epss_score": 0.00082, "epss_percentile": 0.24542}, "CVE-2023-37133": {"epss_score": 0.00082, "epss_percentile": 0.24542}, "CVE-2023-37134": {"epss_score": 0.00082, "epss_percentile": 0.24542}, "CVE-2023-37135": {"epss_score": 0.00082, "epss_percentile": 0.24542}, "CVE-2023-37136": {"epss_score": 0.00082, "epss_percentile": 0.24542}, "CVE-2023-37139": {"epss_score": 0.00258, "epss_percentile": 0.49015}, "CVE-2023-37140": {"epss_score": 0.00182, "epss_percentile": 0.40143}, "CVE-2023-37141": {"epss_score": 0.00182, "epss_percentile": 0.40143}, "CVE-2023-37142": {"epss_score": 0.00182, "epss_percentile": 0.40143}, "CVE-2023-37143": {"epss_score": 0.00247, "epss_percentile": 0.4783}, "CVE-2023-37144": {"epss_score": 0.01141, "epss_percentile": 0.77967}, "CVE-2023-37145": {"epss_score": 0.01454, "epss_percentile": 0.80381}, "CVE-2023-37146": {"epss_score": 0.01454, "epss_percentile": 0.80381}, "CVE-2023-37148": {"epss_score": 0.01454, "epss_percentile": 0.80381}, "CVE-2023-37149": {"epss_score": 0.01454, "epss_percentile": 0.80381}, "CVE-2023-37150": {"epss_score": 0.00335, "epss_percentile": 0.55862}, "CVE-2023-37152": {"epss_score": 0.01307, "epss_percentile": 0.79343}, "CVE-2023-37153": {"epss_score": 0.00159, "epss_percentile": 0.37374}, "CVE-2023-37154": {"epss_score": 0.00043, "epss_percentile": 0.13311}, "CVE-2023-37164": {"epss_score": 0.00522, "epss_percentile": 0.66261}, "CVE-2023-37165": {"epss_score": 0.03263, "epss_percentile": 0.86777}, "CVE-2023-37170": {"epss_score": 0.03254, "epss_percentile": 0.86758}, "CVE-2023-37171": {"epss_score": 0.01454, "epss_percentile": 0.80381}, "CVE-2023-37172": {"epss_score": 0.01454, "epss_percentile": 0.80381}, "CVE-2023-37173": {"epss_score": 0.01579, "epss_percentile": 0.8113}, "CVE-2023-37174": {"epss_score": 0.0005, "epss_percentile": 0.15764}, "CVE-2023-37177": {"epss_score": 0.01267, "epss_percentile": 0.7902}, "CVE-2023-37185": {"epss_score": 0.00193, "epss_percentile": 0.41397}, "CVE-2023-37186": {"epss_score": 0.00193, "epss_percentile": 0.41397}, "CVE-2023-37187": {"epss_score": 0.00193, "epss_percentile": 0.41397}, "CVE-2023-37188": {"epss_score": 0.00185, "epss_percentile": 0.40577}, "CVE-2023-37189": {"epss_score": 0.00522, "epss_percentile": 0.6625}, "CVE-2023-37190": {"epss_score": 0.00089, "epss_percentile": 0.259}, "CVE-2023-37191": {"epss_score": 0.0041, "epss_percentile": 0.608}, "CVE-2023-37192": {"epss_score": 0.00037, "epss_percentile": 0.1065}, "CVE-2023-37194": {"epss_score": 0.00018, "epss_percentile": 0.03752}, "CVE-2023-37195": {"epss_score": 0.00017, "epss_percentile": 0.03442}, "CVE-2023-37196": {"epss_score": 0.00329, "epss_percentile": 0.55411}, "CVE-2023-37197": {"epss_score": 0.00329, "epss_percentile": 0.55411}, "CVE-2023-37198": {"epss_score": 0.01639, "epss_percentile": 0.81493}, "CVE-2023-37199": {"epss_score": 0.01689, "epss_percentile": 0.81768}, "CVE-2023-37200": {"epss_score": 0.00039, "epss_percentile": 0.11674}, "CVE-2023-37201": {"epss_score": 0.00755, "epss_percentile": 0.72713}, "CVE-2023-37202": {"epss_score": 0.00611, "epss_percentile": 0.69183}, "CVE-2023-37203": {"epss_score": 0.00049, "epss_percentile": 0.15418}, "CVE-2023-37204": {"epss_score": 0.00167, "epss_percentile": 0.38366}, "CVE-2023-37205": {"epss_score": 0.00199, "epss_percentile": 0.4213}, "CVE-2023-37206": {"epss_score": 0.00175, "epss_percentile": 0.39263}, "CVE-2023-37207": {"epss_score": 0.00502, "epss_percentile": 0.65399}, "CVE-2023-37208": {"epss_score": 0.00045, "epss_percentile": 0.13918}, "CVE-2023-37209": {"epss_score": 0.00243, "epss_percentile": 0.47459}, "CVE-2023-37210": {"epss_score": 0.0014, "epss_percentile": 0.34704}, "CVE-2023-37211": {"epss_score": 0.00515, "epss_percentile": 0.66009}, "CVE-2023-37212": {"epss_score": 0.00249, "epss_percentile": 0.48001}, "CVE-2023-37213": {"epss_score": 0.00452, "epss_percentile": 0.63187}, "CVE-2023-37214": {"epss_score": 0.00104, "epss_percentile": 0.29126}, "CVE-2023-37215": {"epss_score": 0.00048, "epss_percentile": 0.14974}, "CVE-2023-37216": {"epss_score": 0.00055, "epss_percentile": 0.17656}, "CVE-2023-37217": {"epss_score": 0.00084, "epss_percentile": 0.2493}, "CVE-2023-37218": {"epss_score": 0.00105, "epss_percentile": 0.29361}, "CVE-2023-37219": {"epss_score": 0.00049, "epss_percentile": 0.15381}, "CVE-2023-37220": {"epss_score": 0.00048, "epss_percentile": 0.14951}, "CVE-2023-37221": {"epss_score": 0.00084, "epss_percentile": 0.24838}, "CVE-2023-37222": {"epss_score": 0.00065, "epss_percentile": 0.20543}, "CVE-2023-37223": {"epss_score": 0.00526, "epss_percentile": 0.66421}, "CVE-2023-37224": {"epss_score": 0.00049, "epss_percentile": 0.15455}, "CVE-2023-37225": {"epss_score": 0.00213, "epss_percentile": 0.43847}, "CVE-2023-37226": {"epss_score": 0.00173, "epss_percentile": 0.39071}, "CVE-2023-37227": {"epss_score": 0.00188, "epss_percentile": 0.40904}, "CVE-2023-37229": {"epss_score": 0.00198, "epss_percentile": 0.42046}, "CVE-2023-37230": {"epss_score": 0.00146, "epss_percentile": 0.35549}, "CVE-2023-37231": {"epss_score": 0.00162, "epss_percentile": 0.37619}, "CVE-2023-37232": {"epss_score": 0.00263, "epss_percentile": 0.49542}, "CVE-2023-37233": {"epss_score": 0.0032, "epss_percentile": 0.54612}, "CVE-2023-37234": {"epss_score": 0.00239, "epss_percentile": 0.46919}, "CVE-2023-37237": {"epss_score": 0.00103, "epss_percentile": 0.29066}, "CVE-2023-37238": {"epss_score": 0.00057, "epss_percentile": 0.18226}, "CVE-2023-37239": {"epss_score": 0.00037, "epss_percentile": 0.10624}, "CVE-2023-37240": {"epss_score": 0.00102, "epss_percentile": 0.28875}, "CVE-2023-37241": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-37242": {"epss_score": 0.00084, "epss_percentile": 0.24953}, "CVE-2023-37243": {"epss_score": 0.0004, "epss_percentile": 0.12012}, "CVE-2023-37244": {"epss_score": 0.00093, "epss_percentile": 0.26683}, "CVE-2023-37245": {"epss_score": 0.00068, "epss_percentile": 0.21397}, "CVE-2023-37246": {"epss_score": 0.00084, "epss_percentile": 0.24916}, "CVE-2023-37247": {"epss_score": 0.00084, "epss_percentile": 0.24916}, "CVE-2023-37248": {"epss_score": 0.00068, "epss_percentile": 0.21377}, "CVE-2023-37249": {"epss_score": 0.00104, "epss_percentile": 0.29133}, "CVE-2023-37250": {"epss_score": 0.00145, "epss_percentile": 0.3543}, "CVE-2023-37251": {"epss_score": 0.00491, "epss_percentile": 0.64955}, "CVE-2023-37254": {"epss_score": 0.00118, "epss_percentile": 0.31409}, "CVE-2023-37255": {"epss_score": 0.0009, "epss_percentile": 0.26084}, "CVE-2023-37256": {"epss_score": 0.0009, "epss_percentile": 0.26084}, "CVE-2023-37257": {"epss_score": 0.00452, "epss_percentile": 0.63196}, "CVE-2023-37258": {"epss_score": 0.00187, "epss_percentile": 0.4077}, "CVE-2023-37259": {"epss_score": 0.0022, "epss_percentile": 0.44539}, "CVE-2023-37260": {"epss_score": 0.01826, "epss_percentile": 0.82432}, "CVE-2023-37261": {"epss_score": 0.00161, "epss_percentile": 0.3752}, "CVE-2023-37262": {"epss_score": 0.00152, "epss_percentile": 0.36419}, "CVE-2023-37263": {"epss_score": 0.00085, "epss_percentile": 0.25189}, "CVE-2023-37264": {"epss_score": 0.00082, "epss_percentile": 0.24416}, "CVE-2023-37265": {"epss_score": 0.91121, "epss_percentile": 0.99621}, "CVE-2023-37266": {"epss_score": 0.8916, "epss_percentile": 0.99512}, "CVE-2023-37267": {"epss_score": 0.00313, "epss_percentile": 0.54046}, "CVE-2023-37268": {"epss_score": 0.00166, "epss_percentile": 0.38227}, "CVE-2023-37269": {"epss_score": 0.01092, "epss_percentile": 0.77464}, "CVE-2023-37270": {"epss_score": 0.59212, "epss_percentile": 0.98154}, "CVE-2023-37271": {"epss_score": 0.0023, "epss_percentile": 0.45682}, "CVE-2023-37272": {"epss_score": 0.00236, "epss_percentile": 0.46408}, "CVE-2023-37273": {"epss_score": 0.00047, "epss_percentile": 0.14695}, "CVE-2023-37274": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2023-37275": {"epss_score": 0.00064, "epss_percentile": 0.2029}, "CVE-2023-37276": {"epss_score": 0.05775, "epss_percentile": 0.90197}, "CVE-2023-37277": {"epss_score": 0.02256, "epss_percentile": 0.84168}, "CVE-2023-37278": {"epss_score": 0.00221, "epss_percentile": 0.44673}, "CVE-2023-37279": {"epss_score": 0.00741, "epss_percentile": 0.72442}, "CVE-2023-37280": {"epss_score": 0.00014, "epss_percentile": 0.01859}, "CVE-2023-37281": {"epss_score": 0.0015, "epss_percentile": 0.36137}, "CVE-2023-37282": {"epss_score": 0.0005, "epss_percentile": 0.15894}, "CVE-2023-37283": {"epss_score": 0.0005, "epss_percentile": 0.15935}, "CVE-2023-37284": {"epss_score": 0.00021, "epss_percentile": 0.04711}, "CVE-2023-37285": {"epss_score": 0.00298, "epss_percentile": 0.52825}, "CVE-2023-37286": {"epss_score": 0.01354, "epss_percentile": 0.79704}, "CVE-2023-37287": {"epss_score": 0.0016, "epss_percentile": 0.37444}, "CVE-2023-37288": {"epss_score": 0.00202, "epss_percentile": 0.42401}, "CVE-2023-37289": {"epss_score": 0.00403, "epss_percentile": 0.60385}, "CVE-2023-37290": {"epss_score": 0.00146, "epss_percentile": 0.35614}, "CVE-2023-37291": {"epss_score": 0.00238, "epss_percentile": 0.4682}, "CVE-2023-37292": {"epss_score": 0.00338, "epss_percentile": 0.56128}, "CVE-2023-37293": {"epss_score": 0.00037, "epss_percentile": 0.10917}, "CVE-2023-37294": {"epss_score": 0.00039, "epss_percentile": 0.11671}, "CVE-2023-37295": {"epss_score": 0.00039, "epss_percentile": 0.11671}, "CVE-2023-37296": {"epss_score": 0.00039, "epss_percentile": 0.11671}, "CVE-2023-37297": {"epss_score": 0.00039, "epss_percentile": 0.11671}, "CVE-2023-37298": {"epss_score": 0.00316, "epss_percentile": 0.54229}, "CVE-2023-37299": {"epss_score": 0.00316, "epss_percentile": 0.54229}, "CVE-2023-37300": {"epss_score": 0.0015, "epss_percentile": 0.36122}, "CVE-2023-37301": {"epss_score": 0.00049, "epss_percentile": 0.15567}, "CVE-2023-37302": {"epss_score": 0.01578, "epss_percentile": 0.81124}, "CVE-2023-37303": {"epss_score": 0.00186, "epss_percentile": 0.40594}, "CVE-2023-37304": {"epss_score": 0.00352, "epss_percentile": 0.57093}, "CVE-2023-37305": {"epss_score": 0.00157, "epss_percentile": 0.37106}, "CVE-2023-37306": {"epss_score": 0.00279, "epss_percentile": 0.50958}, "CVE-2023-37307": {"epss_score": 0.00102, "epss_percentile": 0.28869}, "CVE-2023-37308": {"epss_score": 0.01549, "epss_percentile": 0.80981}, "CVE-2023-37310": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-37311": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37312": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37313": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37314": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37315": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37316": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37317": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37318": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37319": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37320": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37321": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37322": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37323": {"epss_score": 0.0123, "epss_percentile": 0.78726}, "CVE-2023-37324": {"epss_score": 0.01855, "epss_percentile": 0.82566}, "CVE-2023-37325": {"epss_score": 0.00185, "epss_percentile": 0.40507}, "CVE-2023-37326": {"epss_score": 0.02203, "epss_percentile": 0.83991}, "CVE-2023-37327": {"epss_score": 0.03475, "epss_percentile": 0.87207}, "CVE-2023-37328": {"epss_score": 0.07706, "epss_percentile": 0.91636}, "CVE-2023-37329": {"epss_score": 0.0474, "epss_percentile": 0.89079}, "CVE-2023-37330": {"epss_score": 0.0027, "epss_percentile": 0.50254}, "CVE-2023-37331": {"epss_score": 0.00809, "epss_percentile": 0.73706}, "CVE-2023-37332": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-37333": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-37334": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-37335": {"epss_score": 0.00779, "epss_percentile": 0.7315}, "CVE-2023-37336": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-37337": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-37338": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-37339": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-37340": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-37341": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-37342": {"epss_score": 0.00779, "epss_percentile": 0.7315}, "CVE-2023-37343": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-37344": {"epss_score": 0.00779, "epss_percentile": 0.7315}, "CVE-2023-37345": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-37346": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-37347": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-37348": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-37349": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-37350": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-37351": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-37352": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-37353": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-37354": {"epss_score": 0.00794, "epss_percentile": 0.73449}, "CVE-2023-37355": {"epss_score": 0.00222, "epss_percentile": 0.44806}, "CVE-2023-37356": {"epss_score": 0.00185, "epss_percentile": 0.40579}, "CVE-2023-37357": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-37358": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-37359": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-37360": {"epss_score": 0.00051, "epss_percentile": 0.16286}, "CVE-2023-37361": {"epss_score": 0.00053, "epss_percentile": 0.17031}, "CVE-2023-37362": {"epss_score": 0.00048, "epss_percentile": 0.15145}, "CVE-2023-37364": {"epss_score": 0.00211, "epss_percentile": 0.43635}, "CVE-2023-37365": {"epss_score": 0.00068, "epss_percentile": 0.21295}, "CVE-2023-37367": {"epss_score": 0.00048, "epss_percentile": 0.14944}, "CVE-2023-37368": {"epss_score": 0.00139, "epss_percentile": 0.34644}, "CVE-2023-37369": {"epss_score": 0.00283, "epss_percentile": 0.51403}, "CVE-2023-37372": {"epss_score": 0.00684, "epss_percentile": 0.71111}, "CVE-2023-37373": {"epss_score": 0.00294, "epss_percentile": 0.52397}, "CVE-2023-37374": {"epss_score": 0.00084, "epss_percentile": 0.24916}, "CVE-2023-37375": {"epss_score": 0.00084, "epss_percentile": 0.24916}, "CVE-2023-37376": {"epss_score": 0.0008, "epss_percentile": 0.24066}, "CVE-2023-37377": {"epss_score": 0.00038, "epss_percentile": 0.11106}, "CVE-2023-37378": {"epss_score": 0.00271, "epss_percentile": 0.50292}, "CVE-2023-37379": {"epss_score": 0.00233, "epss_percentile": 0.45997}, "CVE-2023-37385": {"epss_score": 0.00267, "epss_percentile": 0.49959}, "CVE-2023-37386": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-37387": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-37388": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-37389": {"epss_score": 0.00478, "epss_percentile": 0.64393}, "CVE-2023-37390": {"epss_score": 0.00158, "epss_percentile": 0.37228}, "CVE-2023-37391": {"epss_score": 0.00047, "epss_percentile": 0.14827}, "CVE-2023-37392": {"epss_score": 0.00059, "epss_percentile": 0.18737}, "CVE-2023-37393": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-37394": {"epss_score": 0.00206, "epss_percentile": 0.42925}, "CVE-2023-37395": {"epss_score": 0.00069, "epss_percentile": 0.21576}, "CVE-2023-37396": {"epss_score": 0.00025, "epss_percentile": 0.06314}, "CVE-2023-37397": {"epss_score": 0.00032, "epss_percentile": 0.08849}, "CVE-2023-37398": {"epss_score": 0.00059, "epss_percentile": 0.1873}, "CVE-2023-37400": {"epss_score": 0.00026, "epss_percentile": 0.06408}, "CVE-2023-37401": {"epss_score": 0.0004, "epss_percentile": 0.11916}, "CVE-2023-37404": {"epss_score": 0.00095, "epss_percentile": 0.27157}, "CVE-2023-37405": {"epss_score": 0.00036, "epss_percentile": 0.10373}, "CVE-2023-37407": {"epss_score": 0.00277, "epss_percentile": 0.50793}, "CVE-2023-37410": {"epss_score": 0.00021, "epss_percentile": 0.04753}, "CVE-2023-37411": {"epss_score": 0.00092, "epss_percentile": 0.26585}, "CVE-2023-37412": {"epss_score": 0.00054, "epss_percentile": 0.17219}, "CVE-2023-37413": {"epss_score": 0.00075, "epss_percentile": 0.22921}, "CVE-2023-37415": {"epss_score": 0.00356, "epss_percentile": 0.57368}, "CVE-2023-37416": {"epss_score": 0.00078, "epss_percentile": 0.23613}, "CVE-2023-37417": {"epss_score": 0.00079, "epss_percentile": 0.23808}, "CVE-2023-37418": {"epss_score": 0.00068, "epss_percentile": 0.21368}, "CVE-2023-37419": {"epss_score": 0.00068, "epss_percentile": 0.21368}, "CVE-2023-37420": {"epss_score": 0.00057, "epss_percentile": 0.18075}, "CVE-2023-37421": {"epss_score": 0.00116, "epss_percentile": 0.31164}, "CVE-2023-37422": {"epss_score": 0.00116, "epss_percentile": 0.31164}, "CVE-2023-37423": {"epss_score": 0.00116, "epss_percentile": 0.31164}, "CVE-2023-37424": {"epss_score": 0.01925, "epss_percentile": 0.8292}, "CVE-2023-37425": {"epss_score": 0.00423, "epss_percentile": 0.616}, "CVE-2023-37426": {"epss_score": 0.00247, "epss_percentile": 0.47838}, "CVE-2023-37427": {"epss_score": 0.00582, "epss_percentile": 0.68295}, "CVE-2023-37428": {"epss_score": 0.01388, "epss_percentile": 0.79921}, "CVE-2023-37429": {"epss_score": 0.00109, "epss_percentile": 0.30034}, "CVE-2023-37430": {"epss_score": 0.00109, "epss_percentile": 0.30034}, "CVE-2023-37431": {"epss_score": 0.00109, "epss_percentile": 0.30034}, "CVE-2023-37432": {"epss_score": 0.00109, "epss_percentile": 0.30034}, "CVE-2023-37433": {"epss_score": 0.00109, "epss_percentile": 0.30034}, "CVE-2023-37434": {"epss_score": 0.00101, "epss_percentile": 0.28665}, "CVE-2023-37435": {"epss_score": 0.00158, "epss_percentile": 0.37175}, "CVE-2023-37436": {"epss_score": 0.00158, "epss_percentile": 0.37175}, "CVE-2023-37437": {"epss_score": 0.00161, "epss_percentile": 0.37542}, "CVE-2023-37438": {"epss_score": 0.00156, "epss_percentile": 0.36891}, "CVE-2023-37439": {"epss_score": 0.00167, "epss_percentile": 0.3839}, "CVE-2023-37440": {"epss_score": 0.00335, "epss_percentile": 0.55862}, "CVE-2023-37442": {"epss_score": 0.00085, "epss_percentile": 0.25097}, "CVE-2023-37443": {"epss_score": 0.00103, "epss_percentile": 0.2897}, "CVE-2023-37444": {"epss_score": 0.00102, "epss_percentile": 0.28766}, "CVE-2023-37445": {"epss_score": 0.00116, "epss_percentile": 0.31173}, "CVE-2023-37446": {"epss_score": 0.00116, "epss_percentile": 0.31173}, "CVE-2023-37447": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-37448": {"epss_score": 0.00124, "epss_percentile": 0.32377}, "CVE-2023-37450": {"epss_score": 0.00054, "epss_percentile": 0.17193}, "CVE-2023-37453": {"epss_score": 0.00013, "epss_percentile": 0.01433}, "CVE-2023-37454": {"epss_score": 7e-05, "epss_percentile": 0.00461}, "CVE-2023-37455": {"epss_score": 0.0019, "epss_percentile": 0.41131}, "CVE-2023-37456": {"epss_score": 0.00586, "epss_percentile": 0.68445}, "CVE-2023-37457": {"epss_score": 0.00076, "epss_percentile": 0.23075}, "CVE-2023-37459": {"epss_score": 0.00205, "epss_percentile": 0.42677}, "CVE-2023-37460": {"epss_score": 0.38439, "epss_percentile": 0.97101}, "CVE-2023-37461": {"epss_score": 0.00081, "epss_percentile": 0.24206}, "CVE-2023-37462": {"epss_score": 0.91454, "epss_percentile": 0.99645}, "CVE-2023-37463": {"epss_score": 0.00264, "epss_percentile": 0.49681}, "CVE-2023-37464": {"epss_score": 0.00186, "epss_percentile": 0.40606}, "CVE-2023-37466": {"epss_score": 0.06394, "epss_percentile": 0.90721}, "CVE-2023-37467": {"epss_score": 0.00222, "epss_percentile": 0.44742}, "CVE-2023-37468": {"epss_score": 0.00026, "epss_percentile": 0.06426}, "CVE-2023-37469": {"epss_score": 0.00406, "epss_percentile": 0.6053}, "CVE-2023-37470": {"epss_score": 0.03351, "epss_percentile": 0.86962}, "CVE-2023-37471": {"epss_score": 0.00749, "epss_percentile": 0.72594}, "CVE-2023-37472": {"epss_score": 0.00078, "epss_percentile": 0.23617}, "CVE-2023-37473": {"epss_score": 0.00132, "epss_percentile": 0.33568}, "CVE-2023-37474": {"epss_score": 0.89933, "epss_percentile": 0.9955}, "CVE-2023-37475": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2023-37476": {"epss_score": 0.00116, "epss_percentile": 0.31041}, "CVE-2023-37477": {"epss_score": 0.00575, "epss_percentile": 0.68111}, "CVE-2023-37478": {"epss_score": 0.01368, "epss_percentile": 0.79792}, "CVE-2023-37479": {"epss_score": 0.00247, "epss_percentile": 0.47831}, "CVE-2023-37480": {"epss_score": 0.00035, "epss_percentile": 0.09816}, "CVE-2023-37481": {"epss_score": 0.00081, "epss_percentile": 0.24208}, "CVE-2023-37482": {"epss_score": 0.00064, "epss_percentile": 0.20195}, "CVE-2023-37483": {"epss_score": 0.00582, "epss_percentile": 0.68288}, "CVE-2023-37484": {"epss_score": 0.00182, "epss_percentile": 0.40195}, "CVE-2023-37486": {"epss_score": 0.00138, "epss_percentile": 0.34516}, "CVE-2023-37487": {"epss_score": 0.00196, "epss_percentile": 0.41771}, "CVE-2023-37488": {"epss_score": 0.00291, "epss_percentile": 0.52189}, "CVE-2023-37489": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2023-37490": {"epss_score": 0.00057, "epss_percentile": 0.18203}, "CVE-2023-37491": {"epss_score": 0.00042, "epss_percentile": 0.12929}, "CVE-2023-37492": {"epss_score": 0.00088, "epss_percentile": 0.25773}, "CVE-2023-37495": {"epss_score": 0.00249, "epss_percentile": 0.4803}, "CVE-2023-37496": {"epss_score": 0.00183, "epss_percentile": 0.40364}, "CVE-2023-37497": {"epss_score": 0.00128, "epss_percentile": 0.33071}, "CVE-2023-37498": {"epss_score": 0.00277, "epss_percentile": 0.50837}, "CVE-2023-37499": {"epss_score": 0.00468, "epss_percentile": 0.63888}, "CVE-2023-37500": {"epss_score": 0.00468, "epss_percentile": 0.63888}, "CVE-2023-37501": {"epss_score": 0.00319, "epss_percentile": 0.54568}, "CVE-2023-37502": {"epss_score": 0.00089, "epss_percentile": 0.25979}, "CVE-2023-37503": {"epss_score": 0.00089, "epss_percentile": 0.25958}, "CVE-2023-37504": {"epss_score": 0.00093, "epss_percentile": 0.26638}, "CVE-2023-37511": {"epss_score": 0.00229, "epss_percentile": 0.45593}, "CVE-2023-37512": {"epss_score": 0.00081, "epss_percentile": 0.24357}, "CVE-2023-37513": {"epss_score": 0.00081, "epss_percentile": 0.24357}, "CVE-2023-37516": {"epss_score": 0.00019, "epss_percentile": 0.04096}, "CVE-2023-37517": {"epss_score": 0.00031, "epss_percentile": 0.08398}, "CVE-2023-37518": {"epss_score": 0.00117, "epss_percentile": 0.31242}, "CVE-2023-37519": {"epss_score": 0.00161, "epss_percentile": 0.37519}, "CVE-2023-37520": {"epss_score": 0.00161, "epss_percentile": 0.37519}, "CVE-2023-37521": {"epss_score": 0.00219, "epss_percentile": 0.44509}, "CVE-2023-37522": {"epss_score": 0.0014, "epss_percentile": 0.34778}, "CVE-2023-37523": {"epss_score": 0.00131, "epss_percentile": 0.33381}, "CVE-2023-37526": {"epss_score": 0.0018, "epss_percentile": 0.39869}, "CVE-2023-37527": {"epss_score": 0.0012, "epss_percentile": 0.31718}, "CVE-2023-37528": {"epss_score": 0.00281, "epss_percentile": 0.51146}, "CVE-2023-37529": {"epss_score": 0.00597, "epss_percentile": 0.68737}, "CVE-2023-37530": {"epss_score": 0.00777, "epss_percentile": 0.73111}, "CVE-2023-37531": {"epss_score": 0.00543, "epss_percentile": 0.67114}, "CVE-2023-37532": {"epss_score": 0.00082, "epss_percentile": 0.24567}, "CVE-2023-37533": {"epss_score": 0.00116, "epss_percentile": 0.31063}, "CVE-2023-37534": {"epss_score": 0.00042, "epss_percentile": 0.12573}, "CVE-2023-37535": {"epss_score": 0.00027, "epss_percentile": 0.0698}, "CVE-2023-37536": {"epss_score": 0.00998, "epss_percentile": 0.76474}, "CVE-2023-37537": {"epss_score": 0.00027, "epss_percentile": 0.06911}, "CVE-2023-37538": {"epss_score": 0.00226, "epss_percentile": 0.45315}, "CVE-2023-37539": {"epss_score": 0.00186, "epss_percentile": 0.4064}, "CVE-2023-37540": {"epss_score": 0.0003, "epss_percentile": 0.08176}, "CVE-2023-37541": {"epss_score": 0.00235, "epss_percentile": 0.4623}, "CVE-2023-37543": {"epss_score": 0.00473, "epss_percentile": 0.64081}, "CVE-2023-37544": {"epss_score": 0.00067, "epss_percentile": 0.21072}, "CVE-2023-37545": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37546": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37547": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37548": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37549": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37550": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37551": {"epss_score": 0.00062, "epss_percentile": 0.19692}, "CVE-2023-37552": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37553": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37554": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37555": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37556": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37557": {"epss_score": 0.00051, "epss_percentile": 0.16309}, "CVE-2023-37558": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37559": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2023-37560": {"epss_score": 0.00402, "epss_percentile": 0.60303}, "CVE-2023-37561": {"epss_score": 0.00323, "epss_percentile": 0.54897}, "CVE-2023-37562": {"epss_score": 0.00167, "epss_percentile": 0.3833}, "CVE-2023-37563": {"epss_score": 0.00111, "epss_percentile": 0.30399}, "CVE-2023-37564": {"epss_score": 0.00359, "epss_percentile": 0.57606}, "CVE-2023-37565": {"epss_score": 0.00148, "epss_percentile": 0.35846}, "CVE-2023-37566": {"epss_score": 0.005, "epss_percentile": 0.65326}, "CVE-2023-37567": {"epss_score": 0.029, "epss_percentile": 0.85952}, "CVE-2023-37568": {"epss_score": 0.00129, "epss_percentile": 0.33119}, "CVE-2023-37569": {"epss_score": 0.63023, "epss_percentile": 0.98318}, "CVE-2023-37570": {"epss_score": 0.00241, "epss_percentile": 0.47243}, "CVE-2023-37571": {"epss_score": 0.0032, "epss_percentile": 0.54635}, "CVE-2023-37572": {"epss_score": 0.0021, "epss_percentile": 0.43441}, "CVE-2023-37573": {"epss_score": 0.00117, "epss_percentile": 0.31374}, "CVE-2023-37574": {"epss_score": 0.00098, "epss_percentile": 0.27702}, "CVE-2023-37575": {"epss_score": 0.00098, "epss_percentile": 0.27702}, "CVE-2023-37576": {"epss_score": 0.00086, "epss_percentile": 0.25311}, "CVE-2023-37577": {"epss_score": 0.00086, "epss_percentile": 0.25311}, "CVE-2023-37578": {"epss_score": 0.00103, "epss_percentile": 0.29009}, "CVE-2023-37579": {"epss_score": 0.00089, "epss_percentile": 0.25924}, "CVE-2023-37580": {"epss_score": 0.93918, "epss_percentile": 0.99868}, "CVE-2023-37581": {"epss_score": 0.00505, "epss_percentile": 0.6559}, "CVE-2023-37582": {"epss_score": 0.93986, "epss_percentile": 0.9988}, "CVE-2023-37596": {"epss_score": 0.00559, "epss_percentile": 0.67611}, "CVE-2023-37597": {"epss_score": 0.00559, "epss_percentile": 0.67611}, "CVE-2023-37598": {"epss_score": 0.00335, "epss_percentile": 0.55809}, "CVE-2023-37599": {"epss_score": 0.89362, "epss_percentile": 0.99522}, "CVE-2023-37600": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-37601": {"epss_score": 0.00101, "epss_percentile": 0.28648}, "CVE-2023-37602": {"epss_score": 0.00298, "epss_percentile": 0.52826}, "CVE-2023-37605": {"epss_score": 0.00052, "epss_percentile": 0.16375}, "CVE-2023-37607": {"epss_score": 0.00269, "epss_percentile": 0.50106}, "CVE-2023-37608": {"epss_score": 0.00088, "epss_percentile": 0.25778}, "CVE-2023-37611": {"epss_score": 0.0027, "epss_percentile": 0.50268}, "CVE-2023-37613": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-37623": {"epss_score": 0.00074, "epss_percentile": 0.2273}, "CVE-2023-37624": {"epss_score": 0.00086, "epss_percentile": 0.25396}, "CVE-2023-37625": {"epss_score": 0.01634, "epss_percentile": 0.81466}, "CVE-2023-37627": {"epss_score": 0.00021, "epss_percentile": 0.04805}, "CVE-2023-37628": {"epss_score": 0.00224, "epss_percentile": 0.45011}, "CVE-2023-37629": {"epss_score": 0.90434, "epss_percentile": 0.99583}, "CVE-2023-37630": {"epss_score": 0.00549, "epss_percentile": 0.67295}, "CVE-2023-37635": {"epss_score": 0.0878, "epss_percentile": 0.92251}, "CVE-2023-37636": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-37644": {"epss_score": 0.00094, "epss_percentile": 0.26772}, "CVE-2023-37645": {"epss_score": 0.52496, "epss_percentile": 0.97829}, "CVE-2023-37646": {"epss_score": 0.00129, "epss_percentile": 0.33095}, "CVE-2023-37647": {"epss_score": 0.00302, "epss_percentile": 0.531}, "CVE-2023-37649": {"epss_score": 0.0053, "epss_percentile": 0.66635}, "CVE-2023-37650": {"epss_score": 0.0111, "epss_percentile": 0.7766}, "CVE-2023-37656": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2023-37657": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-37658": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2023-37659": {"epss_score": 0.01266, "epss_percentile": 0.7901}, "CVE-2023-37677": {"epss_score": 0.01289, "epss_percentile": 0.79214}, "CVE-2023-37679": {"epss_score": 0.93688, "epss_percentile": 0.99834}, "CVE-2023-37682": {"epss_score": 0.00072, "epss_percentile": 0.223}, "CVE-2023-37683": {"epss_score": 0.00125, "epss_percentile": 0.32533}, "CVE-2023-37684": {"epss_score": 0.00125, "epss_percentile": 0.32533}, "CVE-2023-37685": {"epss_score": 0.00125, "epss_percentile": 0.32533}, "CVE-2023-37686": {"epss_score": 0.00125, "epss_percentile": 0.32533}, "CVE-2023-37687": {"epss_score": 0.00152, "epss_percentile": 0.36401}, "CVE-2023-37688": {"epss_score": 0.00147, "epss_percentile": 0.35645}, "CVE-2023-37689": {"epss_score": 0.00147, "epss_percentile": 0.35645}, "CVE-2023-37690": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-37692": {"epss_score": 0.00305, "epss_percentile": 0.53367}, "CVE-2023-37700": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37701": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37702": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37703": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37704": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37705": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37706": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37707": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37710": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37711": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37712": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37714": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37715": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37716": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37717": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37718": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37719": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37721": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37722": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37723": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37728": {"epss_score": 0.11915, "epss_percentile": 0.93515}, "CVE-2023-37732": {"epss_score": 0.00025, "epss_percentile": 0.06059}, "CVE-2023-37733": {"epss_score": 0.00093, "epss_percentile": 0.26624}, "CVE-2023-37734": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37739": {"epss_score": 0.07884, "epss_percentile": 0.91742}, "CVE-2023-37742": {"epss_score": 0.00506, "epss_percentile": 0.65613}, "CVE-2023-37743": {"epss_score": 0.00095, "epss_percentile": 0.27102}, "CVE-2023-37744": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-37745": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-37746": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-37748": {"epss_score": 0.00023, "epss_percentile": 0.05484}, "CVE-2023-37749": {"epss_score": 0.00055, "epss_percentile": 0.17411}, "CVE-2023-37754": {"epss_score": 0.66249, "epss_percentile": 0.98456}, "CVE-2023-37755": {"epss_score": 0.01433, "epss_percentile": 0.80258}, "CVE-2023-37756": {"epss_score": 0.06635, "epss_percentile": 0.90907}, "CVE-2023-37758": {"epss_score": 0.00138, "epss_percentile": 0.34529}, "CVE-2023-37759": {"epss_score": 0.03462, "epss_percentile": 0.87183}, "CVE-2023-37765": {"epss_score": 0.00049, "epss_percentile": 0.15558}, "CVE-2023-37766": {"epss_score": 0.0005, "epss_percentile": 0.15764}, "CVE-2023-37767": {"epss_score": 0.0005, "epss_percentile": 0.15764}, "CVE-2023-37769": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2023-37770": {"epss_score": 0.00077, "epss_percentile": 0.23471}, "CVE-2023-37771": {"epss_score": 0.04778, "epss_percentile": 0.89133}, "CVE-2023-37772": {"epss_score": 0.0027, "epss_percentile": 0.50234}, "CVE-2023-37777": {"epss_score": 0.00123, "epss_percentile": 0.32184}, "CVE-2023-37781": {"epss_score": 0.00465, "epss_percentile": 0.6377}, "CVE-2023-37785": {"epss_score": 0.00068, "epss_percentile": 0.21383}, "CVE-2023-37786": {"epss_score": 0.00146, "epss_percentile": 0.35635}, "CVE-2023-37787": {"epss_score": 0.00063, "epss_percentile": 0.1988}, "CVE-2023-37788": {"epss_score": 0.00221, "epss_percentile": 0.44634}, "CVE-2023-37790": {"epss_score": 0.0014, "epss_percentile": 0.34706}, "CVE-2023-37791": {"epss_score": 0.282, "epss_percentile": 0.96331}, "CVE-2023-37793": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-37794": {"epss_score": 0.01061, "epss_percentile": 0.77174}, "CVE-2023-37798": {"epss_score": 0.00083, "epss_percentile": 0.2463}, "CVE-2023-37822": {"epss_score": 0.00059, "epss_percentile": 0.18663}, "CVE-2023-37824": {"epss_score": 0.00138, "epss_percentile": 0.3451}, "CVE-2023-37826": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-37827": {"epss_score": 0.00219, "epss_percentile": 0.4445}, "CVE-2023-37828": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-37829": {"epss_score": 0.00157, "epss_percentile": 0.3705}, "CVE-2023-37830": {"epss_score": 0.00213, "epss_percentile": 0.43877}, "CVE-2023-37831": {"epss_score": 0.00176, "epss_percentile": 0.39457}, "CVE-2023-37832": {"epss_score": 0.00178, "epss_percentile": 0.39698}, "CVE-2023-37833": {"epss_score": 0.00046, "epss_percentile": 0.14424}, "CVE-2023-37836": {"epss_score": 0.00089, "epss_percentile": 0.25852}, "CVE-2023-37837": {"epss_score": 0.00108, "epss_percentile": 0.2986}, "CVE-2023-37839": {"epss_score": 0.00656, "epss_percentile": 0.70434}, "CVE-2023-37847": {"epss_score": 0.00302, "epss_percentile": 0.531}, "CVE-2023-37849": {"epss_score": 0.00062, "epss_percentile": 0.19663}, "CVE-2023-37855": {"epss_score": 0.00072, "epss_percentile": 0.2246}, "CVE-2023-37856": {"epss_score": 0.00072, "epss_percentile": 0.2246}, "CVE-2023-37857": {"epss_score": 0.00062, "epss_percentile": 0.19655}, "CVE-2023-37858": {"epss_score": 0.00027, "epss_percentile": 0.06916}, "CVE-2023-37859": {"epss_score": 0.00274, "epss_percentile": 0.50506}, "CVE-2023-37860": {"epss_score": 0.00181, "epss_percentile": 0.40071}, "CVE-2023-37861": {"epss_score": 0.01051, "epss_percentile": 0.77081}, "CVE-2023-37862": {"epss_score": 0.00277, "epss_percentile": 0.50774}, "CVE-2023-37863": {"epss_score": 0.00325, "epss_percentile": 0.54979}, "CVE-2023-37864": {"epss_score": 0.00237, "epss_percentile": 0.4672}, "CVE-2023-37865": {"epss_score": 0.00114, "epss_percentile": 0.3081}, "CVE-2023-37866": {"epss_score": 0.0025, "epss_percentile": 0.48124}, "CVE-2023-37867": {"epss_score": 0.00235, "epss_percentile": 0.46341}, "CVE-2023-37868": {"epss_score": 0.00679, "epss_percentile": 0.71007}, "CVE-2023-37869": {"epss_score": 0.004, "epss_percentile": 0.60172}, "CVE-2023-37870": {"epss_score": 0.00391, "epss_percentile": 0.59584}, "CVE-2023-37871": {"epss_score": 0.00108, "epss_percentile": 0.29802}, "CVE-2023-37872": {"epss_score": 0.00148, "epss_percentile": 0.35909}, "CVE-2023-37873": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-37874": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-37875": {"epss_score": 0.00132, "epss_percentile": 0.33577}, "CVE-2023-37878": {"epss_score": 0.00103, "epss_percentile": 0.29011}, "CVE-2023-37879": {"epss_score": 0.00248, "epss_percentile": 0.47974}, "CVE-2023-37881": {"epss_score": 0.00145, "epss_percentile": 0.35449}, "CVE-2023-37885": {"epss_score": 0.00061, "epss_percentile": 0.19393}, "CVE-2023-37886": {"epss_score": 0.00044, "epss_percentile": 0.13534}, "CVE-2023-37887": {"epss_score": 0.00171, "epss_percentile": 0.38813}, "CVE-2023-37888": {"epss_score": 0.00647, "epss_percentile": 0.70183}, "CVE-2023-37889": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-37890": {"epss_score": 0.00259, "epss_percentile": 0.49031}, "CVE-2023-37891": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-37892": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-37893": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-37894": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-37895": {"epss_score": 0.08774, "epss_percentile": 0.92249}, "CVE-2023-37896": {"epss_score": 0.00649, "epss_percentile": 0.70232}, "CVE-2023-37897": {"epss_score": 0.00097, "epss_percentile": 0.27545}, "CVE-2023-37898": {"epss_score": 0.0051, "epss_percentile": 0.65759}, "CVE-2023-37899": {"epss_score": 0.00202, "epss_percentile": 0.42463}, "CVE-2023-37900": {"epss_score": 0.00068, "epss_percentile": 0.21293}, "CVE-2023-37901": {"epss_score": 0.00421, "epss_percentile": 0.61509}, "CVE-2023-37902": {"epss_score": 0.00072, "epss_percentile": 0.22437}, "CVE-2023-37903": {"epss_score": 0.39234, "epss_percentile": 0.97148}, "CVE-2023-37904": {"epss_score": 0.0017, "epss_percentile": 0.38701}, "CVE-2023-37905": {"epss_score": 0.00495, "epss_percentile": 0.65121}, "CVE-2023-37906": {"epss_score": 0.00148, "epss_percentile": 0.35922}, "CVE-2023-37907": {"epss_score": 0.00042, "epss_percentile": 0.12918}, "CVE-2023-37908": {"epss_score": 0.00933, "epss_percentile": 0.75644}, "CVE-2023-37909": {"epss_score": 0.1046, "epss_percentile": 0.92993}, "CVE-2023-37910": {"epss_score": 0.00574, "epss_percentile": 0.68075}, "CVE-2023-37911": {"epss_score": 0.00337, "epss_percentile": 0.56017}, "CVE-2023-37912": {"epss_score": 0.09887, "epss_percentile": 0.92753}, "CVE-2023-37913": {"epss_score": 0.03734, "epss_percentile": 0.87648}, "CVE-2023-37914": {"epss_score": 0.0432, "epss_percentile": 0.88542}, "CVE-2023-37915": {"epss_score": 0.00312, "epss_percentile": 0.54008}, "CVE-2023-37916": {"epss_score": 0.00182, "epss_percentile": 0.4023}, "CVE-2023-37917": {"epss_score": 0.00108, "epss_percentile": 0.29804}, "CVE-2023-37918": {"epss_score": 0.0022, "epss_percentile": 0.44588}, "CVE-2023-37919": {"epss_score": 0.00113, "epss_percentile": 0.30698}, "CVE-2023-37920": {"epss_score": 0.00112, "epss_percentile": 0.30411}, "CVE-2023-37921": {"epss_score": 0.00068, "epss_percentile": 0.21368}, "CVE-2023-37922": {"epss_score": 0.00069, "epss_percentile": 0.21511}, "CVE-2023-37923": {"epss_score": 0.00068, "epss_percentile": 0.21368}, "CVE-2023-37924": {"epss_score": 0.77066, "epss_percentile": 0.98919}, "CVE-2023-37925": {"epss_score": 0.00072, "epss_percentile": 0.22429}, "CVE-2023-37926": {"epss_score": 0.00032, "epss_percentile": 0.09097}, "CVE-2023-37927": {"epss_score": 0.0085, "epss_percentile": 0.74389}, "CVE-2023-37928": {"epss_score": 0.01847, "epss_percentile": 0.82522}, "CVE-2023-37929": {"epss_score": 0.0146, "epss_percentile": 0.80416}, "CVE-2023-37930": {"epss_score": 0.00197, "epss_percentile": 0.4193}, "CVE-2023-37931": {"epss_score": 0.00199, "epss_percentile": 0.42154}, "CVE-2023-37932": {"epss_score": 0.00484, "epss_percentile": 0.64633}, "CVE-2023-37933": {"epss_score": 0.00075, "epss_percentile": 0.22931}, "CVE-2023-37934": {"epss_score": 0.00143, "epss_percentile": 0.35206}, "CVE-2023-37935": {"epss_score": 0.00192, "epss_percentile": 0.41364}, "CVE-2023-37936": {"epss_score": 0.00234, "epss_percentile": 0.46163}, "CVE-2023-37937": {"epss_score": 0.00124, "epss_percentile": 0.32353}, "CVE-2023-37939": {"epss_score": 0.00059, "epss_percentile": 0.18912}, "CVE-2023-37940": {"epss_score": 0.00073, "epss_percentile": 0.22579}, "CVE-2023-37941": {"epss_score": 0.83972, "epss_percentile": 0.99267}, "CVE-2023-37942": {"epss_score": 0.00052, "epss_percentile": 0.16479}, "CVE-2023-37943": {"epss_score": 0.00029, "epss_percentile": 0.07754}, "CVE-2023-37944": {"epss_score": 0.00099, "epss_percentile": 0.27869}, "CVE-2023-37945": {"epss_score": 0.0007, "epss_percentile": 0.21867}, "CVE-2023-37946": {"epss_score": 0.00081, "epss_percentile": 0.24219}, "CVE-2023-37947": {"epss_score": 0.00082, "epss_percentile": 0.24436}, "CVE-2023-37948": {"epss_score": 0.00076, "epss_percentile": 0.2324}, "CVE-2023-37949": {"epss_score": 0.00108, "epss_percentile": 0.29837}, "CVE-2023-37950": {"epss_score": 0.00074, "epss_percentile": 0.22775}, "CVE-2023-37951": {"epss_score": 0.00066, "epss_percentile": 0.2093}, "CVE-2023-37952": {"epss_score": 0.00049, "epss_percentile": 0.15588}, "CVE-2023-37953": {"epss_score": 0.00066, "epss_percentile": 0.2093}, "CVE-2023-37954": {"epss_score": 0.00048, "epss_percentile": 0.15228}, "CVE-2023-37955": {"epss_score": 0.00043, "epss_percentile": 0.13341}, "CVE-2023-37956": {"epss_score": 0.00052, "epss_percentile": 0.16474}, "CVE-2023-37957": {"epss_score": 0.0007, "epss_percentile": 0.21806}, "CVE-2023-37958": {"epss_score": 0.00266, "epss_percentile": 0.49889}, "CVE-2023-37959": {"epss_score": 0.00091, "epss_percentile": 0.264}, "CVE-2023-37960": {"epss_score": 0.00463, "epss_percentile": 0.63692}, "CVE-2023-37961": {"epss_score": 0.0007, "epss_percentile": 0.21806}, "CVE-2023-37962": {"epss_score": 0.00201, "epss_percentile": 0.42352}, "CVE-2023-37963": {"epss_score": 0.00109, "epss_percentile": 0.29954}, "CVE-2023-37964": {"epss_score": 0.00181, "epss_percentile": 0.40036}, "CVE-2023-37965": {"epss_score": 0.00149, "epss_percentile": 0.3602}, "CVE-2023-37966": {"epss_score": 0.00441, "epss_percentile": 0.62651}, "CVE-2023-37967": {"epss_score": 0.00369, "epss_percentile": 0.58272}, "CVE-2023-37968": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-37969": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-37970": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-37971": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-37972": {"epss_score": 0.00693, "epss_percentile": 0.71319}, "CVE-2023-37973": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-37974": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-37975": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-37976": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-37977": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-37978": {"epss_score": 0.00135, "epss_percentile": 0.34005}, "CVE-2023-37979": {"epss_score": 0.45008, "epss_percentile": 0.97466}, "CVE-2023-37980": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-37981": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-37982": {"epss_score": 0.00114, "epss_percentile": 0.30766}, "CVE-2023-37983": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-37984": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-37985": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-37986": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-37987": {"epss_score": 0.00186, "epss_percentile": 0.40628}, "CVE-2023-37988": {"epss_score": 0.13345, "epss_percentile": 0.93938}, "CVE-2023-37989": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-37990": {"epss_score": 0.00147, "epss_percentile": 0.35772}, "CVE-2023-37991": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-37992": {"epss_score": 0.00106, "epss_percentile": 0.29522}, "CVE-2023-37993": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-37994": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2023-37995": {"epss_score": 0.0005, "epss_percentile": 0.15783}, "CVE-2023-37996": {"epss_score": 0.00116, "epss_percentile": 0.31063}, "CVE-2023-37997": {"epss_score": 0.0009, "epss_percentile": 0.261}, "CVE-2023-37998": {"epss_score": 0.00103, "epss_percentile": 0.29077}, "CVE-2023-37999": {"epss_score": 0.5541, "epss_percentile": 0.97976}, "CVE-2023-38000": {"epss_score": 0.00347, "epss_percentile": 0.56761}, "CVE-2023-38001": {"epss_score": 0.00031, "epss_percentile": 0.08463}, "CVE-2023-38002": {"epss_score": 0.00017, "epss_percentile": 0.03141}, "CVE-2023-38003": {"epss_score": 0.00047, "epss_percentile": 0.14645}, "CVE-2023-38007": {"epss_score": 0.00023, "epss_percentile": 0.0548}, "CVE-2023-38009": {"epss_score": 0.00044, "epss_percentile": 0.13584}, "CVE-2023-38012": {"epss_score": 0.00104, "epss_percentile": 0.29109}, "CVE-2023-38013": {"epss_score": 0.0011, "epss_percentile": 0.30146}, "CVE-2023-38018": {"epss_score": 0.00072, "epss_percentile": 0.2234}, "CVE-2023-38019": {"epss_score": 0.00079, "epss_percentile": 0.23838}, "CVE-2023-38020": {"epss_score": 0.00036, "epss_percentile": 0.10454}, "CVE-2023-38021": {"epss_score": 0.00035, "epss_percentile": 0.09858}, "CVE-2023-38022": {"epss_score": 0.00038, "epss_percentile": 0.11346}, "CVE-2023-38023": {"epss_score": 0.0003, "epss_percentile": 0.08083}, "CVE-2023-38024": {"epss_score": 0.00531, "epss_percentile": 0.66667}, "CVE-2023-38025": {"epss_score": 0.01661, "epss_percentile": 0.81625}, "CVE-2023-38026": {"epss_score": 0.00423, "epss_percentile": 0.61604}, "CVE-2023-38027": {"epss_score": 0.00858, "epss_percentile": 0.74499}, "CVE-2023-38028": {"epss_score": 0.00074, "epss_percentile": 0.22689}, "CVE-2023-38029": {"epss_score": 0.00274, "epss_percentile": 0.50517}, "CVE-2023-38030": {"epss_score": 0.00129, "epss_percentile": 0.33189}, "CVE-2023-38031": {"epss_score": 0.00563, "epss_percentile": 0.67731}, "CVE-2023-38032": {"epss_score": 0.00694, "epss_percentile": 0.71342}, "CVE-2023-38033": {"epss_score": 0.007, "epss_percentile": 0.71463}, "CVE-2023-38034": {"epss_score": 0.02739, "epss_percentile": 0.85555}, "CVE-2023-38035": {"epss_score": 0.94438, "epss_percentile": 0.99986}, "CVE-2023-38036": {"epss_score": 0.02033, "epss_percentile": 0.83344}, "CVE-2023-38037": {"epss_score": 0.0007, "epss_percentile": 0.21776}, "CVE-2023-38039": {"epss_score": 0.14467, "epss_percentile": 0.94218}, "CVE-2023-38040": {"epss_score": 0.05715, "epss_percentile": 0.90145}, "CVE-2023-38041": {"epss_score": 0.00425, "epss_percentile": 0.61709}, "CVE-2023-38042": {"epss_score": 0.00176, "epss_percentile": 0.39408}, "CVE-2023-38043": {"epss_score": 0.00273, "epss_percentile": 0.50427}, "CVE-2023-38044": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-38045": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-38046": {"epss_score": 0.00194, "epss_percentile": 0.41579}, "CVE-2023-38047": {"epss_score": 0.00114, "epss_percentile": 0.30836}, "CVE-2023-38048": {"epss_score": 0.00223, "epss_percentile": 0.44883}, "CVE-2023-38049": {"epss_score": 0.00223, "epss_percentile": 0.44883}, "CVE-2023-38050": {"epss_score": 0.00154, "epss_percentile": 0.36666}, "CVE-2023-38051": {"epss_score": 0.00223, "epss_percentile": 0.44883}, "CVE-2023-38052": {"epss_score": 0.00223, "epss_percentile": 0.44883}, "CVE-2023-38053": {"epss_score": 0.00223, "epss_percentile": 0.44883}, "CVE-2023-38054": {"epss_score": 0.00223, "epss_percentile": 0.44883}, "CVE-2023-38055": {"epss_score": 0.00166, "epss_percentile": 0.38147}, "CVE-2023-38056": {"epss_score": 0.00381, "epss_percentile": 0.58984}, "CVE-2023-38057": {"epss_score": 0.00284, "epss_percentile": 0.51459}, "CVE-2023-38058": {"epss_score": 0.00153, "epss_percentile": 0.36521}, "CVE-2023-38059": {"epss_score": 0.00284, "epss_percentile": 0.51459}, "CVE-2023-38060": {"epss_score": 0.00194, "epss_percentile": 0.41546}, "CVE-2023-38061": {"epss_score": 0.00079, "epss_percentile": 0.2388}, "CVE-2023-38062": {"epss_score": 4e-05, "epss_percentile": 0.00152}, "CVE-2023-38063": {"epss_score": 0.00079, "epss_percentile": 0.2388}, "CVE-2023-38064": {"epss_score": 4e-05, "epss_percentile": 0.00152}, "CVE-2023-38065": {"epss_score": 0.00079, "epss_percentile": 0.2388}, "CVE-2023-38066": {"epss_score": 0.00032, "epss_percentile": 0.0886}, "CVE-2023-38067": {"epss_score": 4e-05, "epss_percentile": 0.00152}, "CVE-2023-38068": {"epss_score": 2e-05, "epss_percentile": 0.00035}, "CVE-2023-38069": {"epss_score": 1e-05, "epss_percentile": 0.00017}, "CVE-2023-38070": {"epss_score": 0.00038, "epss_percentile": 0.11298}, "CVE-2023-38071": {"epss_score": 0.00071, "epss_percentile": 0.22091}, "CVE-2023-38072": {"epss_score": 0.00041, "epss_percentile": 0.12233}, "CVE-2023-38073": {"epss_score": 0.00085, "epss_percentile": 0.25174}, "CVE-2023-38074": {"epss_score": 0.00085, "epss_percentile": 0.25174}, "CVE-2023-38075": {"epss_score": 0.00084, "epss_percentile": 0.2485}, "CVE-2023-38076": {"epss_score": 0.00075, "epss_percentile": 0.23045}, "CVE-2023-38077": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-38078": {"epss_score": 0.00222, "epss_percentile": 0.44806}, "CVE-2023-38079": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-38080": {"epss_score": 0.00809, "epss_percentile": 0.73706}, "CVE-2023-38081": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-38082": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-38083": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-38084": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-38085": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-38086": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-38087": {"epss_score": 0.00485, "epss_percentile": 0.64715}, "CVE-2023-38088": {"epss_score": 0.0027, "epss_percentile": 0.50254}, "CVE-2023-38089": {"epss_score": 0.005, "epss_percentile": 0.65292}, "CVE-2023-38090": {"epss_score": 0.00684, "epss_percentile": 0.71114}, "CVE-2023-38091": {"epss_score": 0.00376, "epss_percentile": 0.58669}, "CVE-2023-38092": {"epss_score": 0.00684, "epss_percentile": 0.71114}, "CVE-2023-38093": {"epss_score": 0.00684, "epss_percentile": 0.71114}, "CVE-2023-38094": {"epss_score": 0.00684, "epss_percentile": 0.71114}, "CVE-2023-38095": {"epss_score": 0.09202, "epss_percentile": 0.92447}, "CVE-2023-38096": {"epss_score": 0.74927, "epss_percentile": 0.98824}, "CVE-2023-38097": {"epss_score": 0.04279, "epss_percentile": 0.88487}, "CVE-2023-38098": {"epss_score": 0.79363, "epss_percentile": 0.99035}, "CVE-2023-38099": {"epss_score": 0.00837, "epss_percentile": 0.74162}, "CVE-2023-38100": {"epss_score": 0.00106, "epss_percentile": 0.2956}, "CVE-2023-38101": {"epss_score": 0.05699, "epss_percentile": 0.9013}, "CVE-2023-38102": {"epss_score": 0.00347, "epss_percentile": 0.56759}, "CVE-2023-38103": {"epss_score": 0.04536, "epss_percentile": 0.88818}, "CVE-2023-38104": {"epss_score": 0.0282, "epss_percentile": 0.85743}, "CVE-2023-38105": {"epss_score": 0.00468, "epss_percentile": 0.63884}, "CVE-2023-38106": {"epss_score": 0.00468, "epss_percentile": 0.63884}, "CVE-2023-38107": {"epss_score": 0.01812, "epss_percentile": 0.82373}, "CVE-2023-38108": {"epss_score": 0.00358, "epss_percentile": 0.57522}, "CVE-2023-38109": {"epss_score": 0.00314, "epss_percentile": 0.5414}, "CVE-2023-38110": {"epss_score": 0.00314, "epss_percentile": 0.5414}, "CVE-2023-38111": {"epss_score": 0.01812, "epss_percentile": 0.82373}, "CVE-2023-38112": {"epss_score": 0.01812, "epss_percentile": 0.82373}, "CVE-2023-38113": {"epss_score": 0.00494, "epss_percentile": 0.65085}, "CVE-2023-38114": {"epss_score": 0.01812, "epss_percentile": 0.82373}, "CVE-2023-38115": {"epss_score": 0.00314, "epss_percentile": 0.5414}, "CVE-2023-38116": {"epss_score": 0.00314, "epss_percentile": 0.5414}, "CVE-2023-38117": {"epss_score": 0.01812, "epss_percentile": 0.82373}, "CVE-2023-38118": {"epss_score": 0.02082, "epss_percentile": 0.83537}, "CVE-2023-38119": {"epss_score": 0.02082, "epss_percentile": 0.83537}, "CVE-2023-38120": {"epss_score": 0.02114, "epss_percentile": 0.83654}, "CVE-2023-38121": {"epss_score": 0.01727, "epss_percentile": 0.81969}, "CVE-2023-38122": {"epss_score": 0.00565, "epss_percentile": 0.6779}, "CVE-2023-38123": {"epss_score": 0.00299, "epss_percentile": 0.52839}, "CVE-2023-38124": {"epss_score": 0.53761, "epss_percentile": 0.97896}, "CVE-2023-38125": {"epss_score": 0.0066, "epss_percentile": 0.70525}, "CVE-2023-38126": {"epss_score": 0.06481, "epss_percentile": 0.90788}, "CVE-2023-38127": {"epss_score": 0.0018, "epss_percentile": 0.39933}, "CVE-2023-38128": {"epss_score": 0.00207, "epss_percentile": 0.43159}, "CVE-2023-38130": {"epss_score": 0.01091, "epss_percentile": 0.77459}, "CVE-2023-38131": {"epss_score": 0.00146, "epss_percentile": 0.35626}, "CVE-2023-38132": {"epss_score": 0.00168, "epss_percentile": 0.38469}, "CVE-2023-38133": {"epss_score": 0.00543, "epss_percentile": 0.67092}, "CVE-2023-38135": {"epss_score": 0.00054, "epss_percentile": 0.17201}, "CVE-2023-38136": {"epss_score": 0.00045, "epss_percentile": 0.13816}, "CVE-2023-38138": {"epss_score": 0.00519, "epss_percentile": 0.66166}, "CVE-2023-38139": {"epss_score": 0.00584, "epss_percentile": 0.68384}, "CVE-2023-38140": {"epss_score": 0.00282, "epss_percentile": 0.51215}, "CVE-2023-38141": {"epss_score": 0.00312, "epss_percentile": 0.53969}, "CVE-2023-38142": {"epss_score": 0.04835, "epss_percentile": 0.89193}, "CVE-2023-38143": {"epss_score": 0.01242, "epss_percentile": 0.7882}, "CVE-2023-38144": {"epss_score": 0.01242, "epss_percentile": 0.7882}, "CVE-2023-38146": {"epss_score": 0.86455, "epss_percentile": 0.99384}, "CVE-2023-38147": {"epss_score": 0.00084, "epss_percentile": 0.24919}, "CVE-2023-38148": {"epss_score": 0.04178, "epss_percentile": 0.88353}, "CVE-2023-38149": {"epss_score": 0.05411, "epss_percentile": 0.89845}, "CVE-2023-38150": {"epss_score": 0.00535, "epss_percentile": 0.66838}, "CVE-2023-38151": {"epss_score": 0.00336, "epss_percentile": 0.55995}, "CVE-2023-38152": {"epss_score": 0.0239, "epss_percentile": 0.84599}, "CVE-2023-38154": {"epss_score": 0.00247, "epss_percentile": 0.47885}, "CVE-2023-38155": {"epss_score": 0.00341, "epss_percentile": 0.56297}, "CVE-2023-38156": {"epss_score": 0.0024, "epss_percentile": 0.46968}, "CVE-2023-38157": {"epss_score": 0.00519, "epss_percentile": 0.66185}, "CVE-2023-38158": {"epss_score": 0.00871, "epss_percentile": 0.74718}, "CVE-2023-38159": {"epss_score": 0.01021, "epss_percentile": 0.76754}, "CVE-2023-38160": {"epss_score": 0.00221, "epss_percentile": 0.4465}, "CVE-2023-38161": {"epss_score": 0.00071, "epss_percentile": 0.21991}, "CVE-2023-38162": {"epss_score": 0.0689, "epss_percentile": 0.91095}, "CVE-2023-38163": {"epss_score": 0.00368, "epss_percentile": 0.58194}, "CVE-2023-38164": {"epss_score": 0.00248, "epss_percentile": 0.47987}, "CVE-2023-38166": {"epss_score": 0.00218, "epss_percentile": 0.44352}, "CVE-2023-38167": {"epss_score": 0.00761, "epss_percentile": 0.72819}, "CVE-2023-38169": {"epss_score": 0.00379, "epss_percentile": 0.58886}, "CVE-2023-38170": {"epss_score": 0.00766, "epss_percentile": 0.72938}, "CVE-2023-38171": {"epss_score": 0.06774, "epss_percentile": 0.91017}, "CVE-2023-38172": {"epss_score": 0.03228, "epss_percentile": 0.8669}, "CVE-2023-38173": {"epss_score": 0.00249, "epss_percentile": 0.48083}, "CVE-2023-38174": {"epss_score": 0.00448, "epss_percentile": 0.62997}, "CVE-2023-38175": {"epss_score": 0.00256, "epss_percentile": 0.48813}, "CVE-2023-38176": {"epss_score": 0.00122, "epss_percentile": 0.32121}, "CVE-2023-38177": {"epss_score": 0.00185, "epss_percentile": 0.40501}, "CVE-2023-38178": {"epss_score": 0.01904, "epss_percentile": 0.82788}, "CVE-2023-38180": {"epss_score": 0.00882, "epss_percentile": 0.74881}, "CVE-2023-38181": {"epss_score": 0.23018, "epss_percentile": 0.95719}, "CVE-2023-38182": {"epss_score": 0.00705, "epss_percentile": 0.71603}, "CVE-2023-38184": {"epss_score": 0.03113, "epss_percentile": 0.86429}, "CVE-2023-38185": {"epss_score": 0.02112, "epss_percentile": 0.83649}, "CVE-2023-38186": {"epss_score": 0.01957, "epss_percentile": 0.83045}, "CVE-2023-38187": {"epss_score": 0.00992, "epss_percentile": 0.76396}, "CVE-2023-38188": {"epss_score": 0.00241, "epss_percentile": 0.47292}, "CVE-2023-38190": {"epss_score": 0.00066, "epss_percentile": 0.20816}, "CVE-2023-38191": {"epss_score": 0.00298, "epss_percentile": 0.52786}, "CVE-2023-38192": {"epss_score": 0.06209, "epss_percentile": 0.90568}, "CVE-2023-38193": {"epss_score": 0.01701, "epss_percentile": 0.81836}, "CVE-2023-38194": {"epss_score": 0.04349, "epss_percentile": 0.88582}, "CVE-2023-38195": {"epss_score": 0.00134, "epss_percentile": 0.33846}, "CVE-2023-38197": {"epss_score": 0.00052, "epss_percentile": 0.16341}, "CVE-2023-38198": {"epss_score": 0.00196, "epss_percentile": 0.41715}, "CVE-2023-38199": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2023-38200": {"epss_score": 0.00618, "epss_percentile": 0.6937}, "CVE-2023-38201": {"epss_score": 0.00017, "epss_percentile": 0.03213}, "CVE-2023-38203": {"epss_score": 0.94264, "epss_percentile": 0.99929}, "CVE-2023-38204": {"epss_score": 0.77995, "epss_percentile": 0.98963}, "CVE-2023-38205": {"epss_score": 0.9431, "epss_percentile": 0.99943}, "CVE-2023-38206": {"epss_score": 0.00093, "epss_percentile": 0.267}, "CVE-2023-38207": {"epss_score": 0.00697, "epss_percentile": 0.71413}, "CVE-2023-38208": {"epss_score": 0.03434, "epss_percentile": 0.8713}, "CVE-2023-38209": {"epss_score": 0.00132, "epss_percentile": 0.3352}, "CVE-2023-38210": {"epss_score": 0.00111, "epss_percentile": 0.30397}, "CVE-2023-38211": {"epss_score": 0.00116, "epss_percentile": 0.31066}, "CVE-2023-38212": {"epss_score": 0.00148, "epss_percentile": 0.35825}, "CVE-2023-38213": {"epss_score": 0.00034, "epss_percentile": 0.09567}, "CVE-2023-38214": {"epss_score": 0.00305, "epss_percentile": 0.53337}, "CVE-2023-38215": {"epss_score": 0.00305, "epss_percentile": 0.53337}, "CVE-2023-38216": {"epss_score": 0.00021, "epss_percentile": 0.04844}, "CVE-2023-38217": {"epss_score": 0.00022, "epss_percentile": 0.05246}, "CVE-2023-38218": {"epss_score": 0.00692, "epss_percentile": 0.71306}, "CVE-2023-38219": {"epss_score": 0.0152, "epss_percentile": 0.80826}, "CVE-2023-38220": {"epss_score": 0.00153, "epss_percentile": 0.36553}, "CVE-2023-38221": {"epss_score": 0.01682, "epss_percentile": 0.81732}, "CVE-2023-38222": {"epss_score": 0.06654, "epss_percentile": 0.90918}, "CVE-2023-38223": {"epss_score": 0.05187, "epss_percentile": 0.89591}, "CVE-2023-38224": {"epss_score": 0.06539, "epss_percentile": 0.90831}, "CVE-2023-38225": {"epss_score": 0.04156, "epss_percentile": 0.88328}, "CVE-2023-38226": {"epss_score": 0.05187, "epss_percentile": 0.89591}, "CVE-2023-38227": {"epss_score": 0.06654, "epss_percentile": 0.90918}, "CVE-2023-38228": {"epss_score": 0.06654, "epss_percentile": 0.90918}, "CVE-2023-38229": {"epss_score": 0.05007, "epss_percentile": 0.89387}, "CVE-2023-38230": {"epss_score": 0.00119, "epss_percentile": 0.31641}, "CVE-2023-38231": {"epss_score": 0.05187, "epss_percentile": 0.89591}, "CVE-2023-38232": {"epss_score": 0.00093, "epss_percentile": 0.26639}, "CVE-2023-38233": {"epss_score": 0.05187, "epss_percentile": 0.89591}, "CVE-2023-38234": {"epss_score": 0.01735, "epss_percentile": 0.82005}, "CVE-2023-38235": {"epss_score": 0.00095, "epss_percentile": 0.27171}, "CVE-2023-38236": {"epss_score": 0.00262, "epss_percentile": 0.49327}, "CVE-2023-38237": {"epss_score": 0.00095, "epss_percentile": 0.27171}, "CVE-2023-38238": {"epss_score": 0.0009, "epss_percentile": 0.26077}, "CVE-2023-38239": {"epss_score": 0.00095, "epss_percentile": 0.27171}, "CVE-2023-38240": {"epss_score": 0.00095, "epss_percentile": 0.27171}, "CVE-2023-38241": {"epss_score": 0.00095, "epss_percentile": 0.27171}, "CVE-2023-38242": {"epss_score": 0.00095, "epss_percentile": 0.27171}, "CVE-2023-38243": {"epss_score": 0.00062, "epss_percentile": 0.19638}, "CVE-2023-38244": {"epss_score": 0.00095, "epss_percentile": 0.27171}, "CVE-2023-38245": {"epss_score": 0.00262, "epss_percentile": 0.49404}, "CVE-2023-38246": {"epss_score": 0.00153, "epss_percentile": 0.36549}, "CVE-2023-38247": {"epss_score": 0.00095, "epss_percentile": 0.27171}, "CVE-2023-38248": {"epss_score": 0.00095, "epss_percentile": 0.27171}, "CVE-2023-38249": {"epss_score": 0.01682, "epss_percentile": 0.81732}, "CVE-2023-38250": {"epss_score": 0.01682, "epss_percentile": 0.81732}, "CVE-2023-38251": {"epss_score": 0.00232, "epss_percentile": 0.45877}, "CVE-2023-38252": {"epss_score": 0.00018, "epss_percentile": 0.03677}, "CVE-2023-38253": {"epss_score": 0.00023, "epss_percentile": 0.05495}, "CVE-2023-38254": {"epss_score": 0.00807, "epss_percentile": 0.73669}, "CVE-2023-38255": {"epss_score": 0.00104, "epss_percentile": 0.29221}, "CVE-2023-38256": {"epss_score": 0.00071, "epss_percentile": 0.22075}, "CVE-2023-38257": {"epss_score": 0.00204, "epss_percentile": 0.42622}, "CVE-2023-38258": {"epss_score": 0.00042, "epss_percentile": 0.12567}, "CVE-2023-38259": {"epss_score": 0.00044, "epss_percentile": 0.13538}, "CVE-2023-38261": {"epss_score": 0.00045, "epss_percentile": 0.13816}, "CVE-2023-38263": {"epss_score": 0.0003, "epss_percentile": 0.08181}, "CVE-2023-38264": {"epss_score": 0.00086, "epss_percentile": 0.25299}, "CVE-2023-38267": {"epss_score": 0.00012, "epss_percentile": 0.01296}, "CVE-2023-38268": {"epss_score": 0.00038, "epss_percentile": 0.11178}, "CVE-2023-38271": {"epss_score": 0.00131, "epss_percentile": 0.3337}, "CVE-2023-38272": {"epss_score": 0.00043, "epss_percentile": 0.13096}, "CVE-2023-38273": {"epss_score": 0.0005, "epss_percentile": 0.15668}, "CVE-2023-38275": {"epss_score": 0.00026, "epss_percentile": 0.06613}, "CVE-2023-38276": {"epss_score": 0.00026, "epss_percentile": 0.06613}, "CVE-2023-38280": {"epss_score": 0.00028, "epss_percentile": 0.07333}, "CVE-2023-38283": {"epss_score": 0.00094, "epss_percentile": 0.27028}, "CVE-2023-38285": {"epss_score": 0.00487, "epss_percentile": 0.64822}, "CVE-2023-38286": {"epss_score": 0.00173, "epss_percentile": 0.39057}, "CVE-2023-38290": {"epss_score": 0.00048, "epss_percentile": 0.15057}, "CVE-2023-38291": {"epss_score": 0.00048, "epss_percentile": 0.15242}, "CVE-2023-38292": {"epss_score": 0.00082, "epss_percentile": 0.24439}, "CVE-2023-38293": {"epss_score": 0.00244, "epss_percentile": 0.47578}, "CVE-2023-38294": {"epss_score": 0.00034, "epss_percentile": 0.09654}, "CVE-2023-38295": {"epss_score": 0.00065, "epss_percentile": 0.20588}, "CVE-2023-38296": {"epss_score": 0.00066, "epss_percentile": 0.20767}, "CVE-2023-38297": {"epss_score": 0.00081, "epss_percentile": 0.24365}, "CVE-2023-38298": {"epss_score": 0.0013, "epss_percentile": 0.33293}, "CVE-2023-38299": {"epss_score": 0.00051, "epss_percentile": 0.16032}, "CVE-2023-38300": {"epss_score": 0.00054, "epss_percentile": 0.1728}, "CVE-2023-38301": {"epss_score": 0.00035, "epss_percentile": 0.10125}, "CVE-2023-38302": {"epss_score": 0.00124, "epss_percentile": 0.32431}, "CVE-2023-38303": {"epss_score": 0.00204, "epss_percentile": 0.42647}, "CVE-2023-38304": {"epss_score": 0.0012, "epss_percentile": 0.3171}, "CVE-2023-38305": {"epss_score": 0.00406, "epss_percentile": 0.6055}, "CVE-2023-38306": {"epss_score": 0.00399, "epss_percentile": 0.60096}, "CVE-2023-38307": {"epss_score": 0.00083, "epss_percentile": 0.24737}, "CVE-2023-38308": {"epss_score": 0.00528, "epss_percentile": 0.66575}, "CVE-2023-38309": {"epss_score": 0.00528, "epss_percentile": 0.66575}, "CVE-2023-38310": {"epss_score": 0.00167, "epss_percentile": 0.38343}, "CVE-2023-38311": {"epss_score": 0.00167, "epss_percentile": 0.38343}, "CVE-2023-38312": {"epss_score": 0.00591, "epss_percentile": 0.686}, "CVE-2023-38313": {"epss_score": 0.0026, "epss_percentile": 0.49182}, "CVE-2023-38314": {"epss_score": 0.00629, "epss_percentile": 0.69669}, "CVE-2023-38315": {"epss_score": 0.00227, "epss_percentile": 0.45363}, "CVE-2023-38316": {"epss_score": 0.01245, "epss_percentile": 0.78843}, "CVE-2023-38317": {"epss_score": 0.00241, "epss_percentile": 0.4725}, "CVE-2023-38318": {"epss_score": 0.00241, "epss_percentile": 0.4725}, "CVE-2023-38319": {"epss_score": 0.00241, "epss_percentile": 0.4725}, "CVE-2023-38320": {"epss_score": 0.00589, "epss_percentile": 0.68523}, "CVE-2023-38321": {"epss_score": 0.00041, "epss_percentile": 0.12221}, "CVE-2023-38322": {"epss_score": 0.00675, "epss_percentile": 0.70912}, "CVE-2023-38323": {"epss_score": 0.00241, "epss_percentile": 0.4725}, "CVE-2023-38324": {"epss_score": 0.00427, "epss_percentile": 0.61906}, "CVE-2023-38325": {"epss_score": 0.01197, "epss_percentile": 0.78445}, "CVE-2023-38327": {"epss_score": 0.00039, "epss_percentile": 0.1166}, "CVE-2023-38328": {"epss_score": 0.00054, "epss_percentile": 0.17254}, "CVE-2023-38329": {"epss_score": 0.00033, "epss_percentile": 0.09297}, "CVE-2023-38330": {"epss_score": 0.00155, "epss_percentile": 0.36854}, "CVE-2023-38331": {"epss_score": 0.03508, "epss_percentile": 0.87262}, "CVE-2023-38332": {"epss_score": 0.0146, "epss_percentile": 0.80419}, "CVE-2023-38333": {"epss_score": 0.05953, "epss_percentile": 0.90359}, "CVE-2023-38334": {"epss_score": 0.00186, "epss_percentile": 0.40596}, "CVE-2023-38335": {"epss_score": 0.00075, "epss_percentile": 0.22896}, "CVE-2023-38336": {"epss_score": 0.00729, "epss_percentile": 0.72128}, "CVE-2023-38337": {"epss_score": 0.00186, "epss_percentile": 0.40608}, "CVE-2023-38343": {"epss_score": 0.00431, "epss_percentile": 0.62055}, "CVE-2023-38344": {"epss_score": 0.0084, "epss_percentile": 0.74212}, "CVE-2023-38346": {"epss_score": 0.0123, "epss_percentile": 0.78721}, "CVE-2023-38347": {"epss_score": 0.00435, "epss_percentile": 0.62365}, "CVE-2023-38348": {"epss_score": 0.00172, "epss_percentile": 0.38958}, "CVE-2023-38349": {"epss_score": 0.00098, "epss_percentile": 0.27771}, "CVE-2023-38350": {"epss_score": 0.00119, "epss_percentile": 0.31579}, "CVE-2023-38351": {"epss_score": 0.03175, "epss_percentile": 0.86564}, "CVE-2023-38352": {"epss_score": 0.03175, "epss_percentile": 0.86564}, "CVE-2023-38353": {"epss_score": 0.00146, "epss_percentile": 0.35566}, "CVE-2023-38354": {"epss_score": 0.03175, "epss_percentile": 0.86564}, "CVE-2023-38355": {"epss_score": 0.03175, "epss_percentile": 0.86564}, "CVE-2023-38356": {"epss_score": 0.03175, "epss_percentile": 0.86564}, "CVE-2023-38357": {"epss_score": 0.02869, "epss_percentile": 0.8587}, "CVE-2023-38359": {"epss_score": 0.00087, "epss_percentile": 0.25597}, "CVE-2023-38360": {"epss_score": 0.00075, "epss_percentile": 0.23002}, "CVE-2023-38361": {"epss_score": 0.00031, "epss_percentile": 0.0855}, "CVE-2023-38362": {"epss_score": 0.00043, "epss_percentile": 0.13233}, "CVE-2023-38363": {"epss_score": 0.0006, "epss_percentile": 0.19163}, "CVE-2023-38364": {"epss_score": 0.00068, "epss_percentile": 0.21231}, "CVE-2023-38366": {"epss_score": 0.00054, "epss_percentile": 0.17275}, "CVE-2023-38367": {"epss_score": 0.0006, "epss_percentile": 0.19172}, "CVE-2023-38368": {"epss_score": 0.00018, "epss_percentile": 0.03959}, "CVE-2023-38369": {"epss_score": 0.00053, "epss_percentile": 0.16994}, "CVE-2023-38370": {"epss_score": 0.00047, "epss_percentile": 0.14656}, "CVE-2023-38371": {"epss_score": 0.00065, "epss_percentile": 0.20528}, "CVE-2023-38372": {"epss_score": 0.0006, "epss_percentile": 0.19232}, "CVE-2023-38378": {"epss_score": 0.00603, "epss_percentile": 0.68902}, "CVE-2023-38379": {"epss_score": 0.00066, "epss_percentile": 0.20759}, "CVE-2023-38380": {"epss_score": 0.00087, "epss_percentile": 0.25561}, "CVE-2023-38381": {"epss_score": 0.00116, "epss_percentile": 0.31063}, "CVE-2023-38382": {"epss_score": 0.00094, "epss_percentile": 0.26794}, "CVE-2023-38383": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-38384": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-38385": {"epss_score": 0.00404, "epss_percentile": 0.60399}, "CVE-2023-38386": {"epss_score": 0.00226, "epss_percentile": 0.45296}, "CVE-2023-38387": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-38388": {"epss_score": 0.20409, "epss_percentile": 0.95339}, "CVE-2023-38389": {"epss_score": 0.11848, "epss_percentile": 0.93494}, "CVE-2023-38390": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-38391": {"epss_score": 0.00199, "epss_percentile": 0.42156}, "CVE-2023-38392": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-38393": {"epss_score": 0.00331, "epss_percentile": 0.55502}, "CVE-2023-38394": {"epss_score": 0.00385, "epss_percentile": 0.59208}, "CVE-2023-38395": {"epss_score": 0.00123, "epss_percentile": 0.32237}, "CVE-2023-38396": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-38397": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-38398": {"epss_score": 0.00147, "epss_percentile": 0.35772}, "CVE-2023-38399": {"epss_score": 0.0063, "epss_percentile": 0.6969}, "CVE-2023-38400": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-38401": {"epss_score": 0.00103, "epss_percentile": 0.2906}, "CVE-2023-38402": {"epss_score": 0.00138, "epss_percentile": 0.34511}, "CVE-2023-38403": {"epss_score": 0.01253, "epss_percentile": 0.78917}, "CVE-2023-38404": {"epss_score": 0.00115, "epss_percentile": 0.30932}, "CVE-2023-38405": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-38406": {"epss_score": 0.00123, "epss_percentile": 0.32272}, "CVE-2023-38407": {"epss_score": 0.00161, "epss_percentile": 0.37612}, "CVE-2023-38408": {"epss_score": 0.68749, "epss_percentile": 0.98562}, "CVE-2023-38409": {"epss_score": 6e-05, "epss_percentile": 0.00295}, "CVE-2023-38410": {"epss_score": 0.00032, "epss_percentile": 0.09102}, "CVE-2023-38411": {"epss_score": 0.00043, "epss_percentile": 0.13088}, "CVE-2023-38412": {"epss_score": 0.00348, "epss_percentile": 0.56798}, "CVE-2023-38417": {"epss_score": 0.00012, "epss_percentile": 0.01267}, "CVE-2023-38418": {"epss_score": 0.00056, "epss_percentile": 0.17912}, "CVE-2023-38419": {"epss_score": 0.00164, "epss_percentile": 0.37972}, "CVE-2023-38420": {"epss_score": 0.00109, "epss_percentile": 0.29921}, "CVE-2023-38421": {"epss_score": 0.00042, "epss_percentile": 0.12567}, "CVE-2023-38422": {"epss_score": 0.00078, "epss_percentile": 0.23662}, "CVE-2023-38423": {"epss_score": 0.00342, "epss_percentile": 0.56376}, "CVE-2023-38424": {"epss_score": 0.00053, "epss_percentile": 0.16936}, "CVE-2023-38425": {"epss_score": 0.00181, "epss_percentile": 0.40113}, "CVE-2023-38426": {"epss_score": 0.00063, "epss_percentile": 0.1998}, "CVE-2023-38427": {"epss_score": 0.00087, "epss_percentile": 0.2555}, "CVE-2023-38428": {"epss_score": 0.00066, "epss_percentile": 0.20695}, "CVE-2023-38429": {"epss_score": 0.00047, "epss_percentile": 0.14804}, "CVE-2023-38430": {"epss_score": 0.00066, "epss_percentile": 0.20695}, "CVE-2023-38431": {"epss_score": 0.00066, "epss_percentile": 0.20695}, "CVE-2023-38432": {"epss_score": 0.00063, "epss_percentile": 0.1998}, "CVE-2023-38433": {"epss_score": 0.53203, "epss_percentile": 0.97863}, "CVE-2023-38434": {"epss_score": 0.01391, "epss_percentile": 0.79954}, "CVE-2023-38435": {"epss_score": 0.01205, "epss_percentile": 0.78511}, "CVE-2023-38436": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-38437": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-38438": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-38439": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-38440": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-38441": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-38442": {"epss_score": 0.00021, "epss_percentile": 0.04717}, "CVE-2023-38443": {"epss_score": 0.00027, "epss_percentile": 0.06748}, "CVE-2023-38444": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-38445": {"epss_score": 0.00012, "epss_percentile": 0.01301}, "CVE-2023-38446": {"epss_score": 0.00012, "epss_percentile": 0.01301}, "CVE-2023-38447": {"epss_score": 0.00012, "epss_percentile": 0.01301}, "CVE-2023-38448": {"epss_score": 0.00012, "epss_percentile": 0.01301}, "CVE-2023-38449": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-38450": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-38451": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-38452": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-38453": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-38454": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-38455": {"epss_score": 0.00027, "epss_percentile": 0.06748}, "CVE-2023-38456": {"epss_score": 0.00027, "epss_percentile": 0.06748}, "CVE-2023-38457": {"epss_score": 0.00017, "epss_percentile": 0.03207}, "CVE-2023-38458": {"epss_score": 0.00027, "epss_percentile": 0.06748}, "CVE-2023-38459": {"epss_score": 0.00035, "epss_percentile": 0.09848}, "CVE-2023-38460": {"epss_score": 0.00035, "epss_percentile": 0.09848}, "CVE-2023-38461": {"epss_score": 0.00017, "epss_percentile": 0.03207}, "CVE-2023-38462": {"epss_score": 0.00017, "epss_percentile": 0.03207}, "CVE-2023-38463": {"epss_score": 0.00017, "epss_percentile": 0.03207}, "CVE-2023-38464": {"epss_score": 0.00027, "epss_percentile": 0.06748}, "CVE-2023-38465": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-38466": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-38467": {"epss_score": 7e-05, "epss_percentile": 0.00354}, "CVE-2023-38468": {"epss_score": 7e-05, "epss_percentile": 0.00388}, "CVE-2023-38469": {"epss_score": 0.0001, "epss_percentile": 0.00792}, "CVE-2023-38470": {"epss_score": 0.0001, "epss_percentile": 0.00792}, "CVE-2023-38471": {"epss_score": 8e-05, "epss_percentile": 0.00494}, "CVE-2023-38472": {"epss_score": 0.0001, "epss_percentile": 0.00792}, "CVE-2023-38473": {"epss_score": 0.0001, "epss_percentile": 0.00792}, "CVE-2023-38474": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-38475": {"epss_score": 0.00276, "epss_percentile": 0.50736}, "CVE-2023-38476": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-38477": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-38478": {"epss_score": 0.00114, "epss_percentile": 0.30766}, "CVE-2023-38479": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-38480": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-38481": {"epss_score": 0.00114, "epss_percentile": 0.30766}, "CVE-2023-38482": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-38483": {"epss_score": 0.00108, "epss_percentile": 0.29857}, "CVE-2023-38484": {"epss_score": 0.00223, "epss_percentile": 0.44879}, "CVE-2023-38485": {"epss_score": 0.00211, "epss_percentile": 0.43706}, "CVE-2023-38486": {"epss_score": 0.00015, "epss_percentile": 0.02365}, "CVE-2023-38487": {"epss_score": 0.00071, "epss_percentile": 0.22084}, "CVE-2023-38488": {"epss_score": 0.0007, "epss_percentile": 0.21707}, "CVE-2023-38489": {"epss_score": 0.00155, "epss_percentile": 0.36831}, "CVE-2023-38490": {"epss_score": 0.18066, "epss_percentile": 0.94951}, "CVE-2023-38491": {"epss_score": 0.00148, "epss_percentile": 0.35932}, "CVE-2023-38492": {"epss_score": 0.00098, "epss_percentile": 0.27695}, "CVE-2023-38493": {"epss_score": 0.00169, "epss_percentile": 0.38626}, "CVE-2023-38494": {"epss_score": 0.00056, "epss_percentile": 0.17792}, "CVE-2023-38495": {"epss_score": 0.00242, "epss_percentile": 0.47368}, "CVE-2023-38496": {"epss_score": 0.00042, "epss_percentile": 0.12569}, "CVE-2023-38497": {"epss_score": 0.05657, "epss_percentile": 0.90094}, "CVE-2023-38498": {"epss_score": 0.00152, "epss_percentile": 0.36498}, "CVE-2023-38499": {"epss_score": 0.02302, "epss_percentile": 0.84314}, "CVE-2023-38500": {"epss_score": 0.00341, "epss_percentile": 0.56312}, "CVE-2023-38501": {"epss_score": 0.81105, "epss_percentile": 0.9912}, "CVE-2023-38502": {"epss_score": 0.00194, "epss_percentile": 0.41544}, "CVE-2023-38503": {"epss_score": 0.00107, "epss_percentile": 0.2964}, "CVE-2023-38504": {"epss_score": 0.00225, "epss_percentile": 0.45084}, "CVE-2023-38505": {"epss_score": 0.00162, "epss_percentile": 0.37648}, "CVE-2023-38506": {"epss_score": 0.00468, "epss_percentile": 0.63914}, "CVE-2023-38507": {"epss_score": 0.00255, "epss_percentile": 0.48694}, "CVE-2023-38508": {"epss_score": 0.00148, "epss_percentile": 0.35871}, "CVE-2023-38509": {"epss_score": 0.00364, "epss_percentile": 0.57954}, "CVE-2023-38510": {"epss_score": 0.00121, "epss_percentile": 0.31922}, "CVE-2023-38511": {"epss_score": 0.00623, "epss_percentile": 0.69533}, "CVE-2023-38512": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-38513": {"epss_score": 0.00053, "epss_percentile": 0.16937}, "CVE-2023-38514": {"epss_score": 0.00049, "epss_percentile": 0.15481}, "CVE-2023-38515": {"epss_score": 0.00135, "epss_percentile": 0.34005}, "CVE-2023-38516": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-38517": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-38518": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-38519": {"epss_score": 0.0014, "epss_percentile": 0.34695}, "CVE-2023-38520": {"epss_score": 0.00206, "epss_percentile": 0.4292}, "CVE-2023-38521": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-38522": {"epss_score": 0.00294, "epss_percentile": 0.52401}, "CVE-2023-38523": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2023-38524": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-38525": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-38526": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-38527": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-38528": {"epss_score": 0.00073, "epss_percentile": 0.22511}, "CVE-2023-38529": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-38530": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-38531": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-38532": {"epss_score": 0.00046, "epss_percentile": 0.14469}, "CVE-2023-38533": {"epss_score": 0.00053, "epss_percentile": 0.1672}, "CVE-2023-38534": {"epss_score": 0.00194, "epss_percentile": 0.41582}, "CVE-2023-38535": {"epss_score": 0.00136, "epss_percentile": 0.34126}, "CVE-2023-38536": {"epss_score": 0.00111, "epss_percentile": 0.30341}, "CVE-2023-38537": {"epss_score": 0.00111, "epss_percentile": 0.30388}, "CVE-2023-38538": {"epss_score": 0.0009, "epss_percentile": 0.26142}, "CVE-2023-38541": {"epss_score": 0.00037, "epss_percentile": 0.10925}, "CVE-2023-38543": {"epss_score": 0.00192, "epss_percentile": 0.41287}, "CVE-2023-38544": {"epss_score": 0.00173, "epss_percentile": 0.39066}, "CVE-2023-38545": {"epss_score": 0.2625, "epss_percentile": 0.9613}, "CVE-2023-38546": {"epss_score": 0.00256, "epss_percentile": 0.48802}, "CVE-2023-38547": {"epss_score": 0.10762, "epss_percentile": 0.93096}, "CVE-2023-38548": {"epss_score": 0.00983, "epss_percentile": 0.76301}, "CVE-2023-38549": {"epss_score": 0.01613, "epss_percentile": 0.81342}, "CVE-2023-38551": {"epss_score": 0.00583, "epss_percentile": 0.68357}, "CVE-2023-38552": {"epss_score": 0.00397, "epss_percentile": 0.59934}, "CVE-2023-38553": {"epss_score": 0.00014, "epss_percentile": 0.02036}, "CVE-2023-38554": {"epss_score": 0.0001, "epss_percentile": 0.00822}, "CVE-2023-38555": {"epss_score": 0.00053, "epss_percentile": 0.16876}, "CVE-2023-38556": {"epss_score": 0.00299, "epss_percentile": 0.5287}, "CVE-2023-38557": {"epss_score": 0.00016, "epss_percentile": 0.03024}, "CVE-2023-38558": {"epss_score": 0.00028, "epss_percentile": 0.07572}, "CVE-2023-38559": {"epss_score": 0.00014, "epss_percentile": 0.01819}, "CVE-2023-38560": {"epss_score": 0.00018, "epss_percentile": 0.03751}, "CVE-2023-38561": {"epss_score": 0.0004, "epss_percentile": 0.12181}, "CVE-2023-38562": {"epss_score": 0.00268, "epss_percentile": 0.50053}, "CVE-2023-38563": {"epss_score": 0.0014, "epss_percentile": 0.34798}, "CVE-2023-38564": {"epss_score": 0.00115, "epss_percentile": 0.30998}, "CVE-2023-38565": {"epss_score": 0.00034, "epss_percentile": 0.09454}, "CVE-2023-38566": {"epss_score": 0.00144, "epss_percentile": 0.35344}, "CVE-2023-38568": {"epss_score": 0.00132, "epss_percentile": 0.33621}, "CVE-2023-38569": {"epss_score": 0.00327, "epss_percentile": 0.55103}, "CVE-2023-38570": {"epss_score": 0.00069, "epss_percentile": 0.2154}, "CVE-2023-38571": {"epss_score": 0.12144, "epss_percentile": 0.93583}, "CVE-2023-38572": {"epss_score": 0.00532, "epss_percentile": 0.6668}, "CVE-2023-38573": {"epss_score": 0.0002, "epss_percentile": 0.04599}, "CVE-2023-38574": {"epss_score": 0.0022, "epss_percentile": 0.44573}, "CVE-2023-38575": {"epss_score": 0.0003, "epss_percentile": 0.08069}, "CVE-2023-38576": {"epss_score": 0.00129, "epss_percentile": 0.33119}, "CVE-2023-38579": {"epss_score": 0.00071, "epss_percentile": 0.22048}, "CVE-2023-38580": {"epss_score": 0.00055, "epss_percentile": 0.17379}, "CVE-2023-38581": {"epss_score": 0.00172, "epss_percentile": 0.3904}, "CVE-2023-38582": {"epss_score": 0.0008, "epss_percentile": 0.24071}, "CVE-2023-38583": {"epss_score": 0.00052, "epss_percentile": 0.1651}, "CVE-2023-38584": {"epss_score": 0.00055, "epss_percentile": 0.17412}, "CVE-2023-38585": {"epss_score": 0.01614, "epss_percentile": 0.81343}, "CVE-2023-38586": {"epss_score": 0.00399, "epss_percentile": 0.60092}, "CVE-2023-38587": {"epss_score": 0.00053, "epss_percentile": 0.16796}, "CVE-2023-38588": {"epss_score": 0.00078, "epss_percentile": 0.23667}, "CVE-2023-38590": {"epss_score": 0.01625, "epss_percentile": 0.81422}, "CVE-2023-38591": {"epss_score": 0.00348, "epss_percentile": 0.56798}, "CVE-2023-38592": {"epss_score": 0.00727, "epss_percentile": 0.72098}, "CVE-2023-38593": {"epss_score": 0.00024, "epss_percentile": 0.05673}, "CVE-2023-38594": {"epss_score": 0.00437, "epss_percentile": 0.62534}, "CVE-2023-38595": {"epss_score": 0.00992, "epss_percentile": 0.76391}, "CVE-2023-38596": {"epss_score": 0.00022, "epss_percentile": 0.05031}, "CVE-2023-38597": {"epss_score": 0.00536, "epss_percentile": 0.66862}, "CVE-2023-38598": {"epss_score": 0.00463, "epss_percentile": 0.63677}, "CVE-2023-38599": {"epss_score": 0.00543, "epss_percentile": 0.67092}, "CVE-2023-38600": {"epss_score": 0.00663, "epss_percentile": 0.70623}, "CVE-2023-38601": {"epss_score": 0.00108, "epss_percentile": 0.29806}, "CVE-2023-38602": {"epss_score": 0.00025, "epss_percentile": 0.06239}, "CVE-2023-38603": {"epss_score": 0.00387, "epss_percentile": 0.59311}, "CVE-2023-38604": {"epss_score": 0.00446, "epss_percentile": 0.62894}, "CVE-2023-38605": {"epss_score": 0.0008, "epss_percentile": 0.24105}, "CVE-2023-38606": {"epss_score": 0.00088, "epss_percentile": 0.25734}, "CVE-2023-38607": {"epss_score": 0.00096, "epss_percentile": 0.27323}, "CVE-2023-38608": {"epss_score": 0.00039, "epss_percentile": 0.11436}, "CVE-2023-38609": {"epss_score": 0.00675, "epss_percentile": 0.70914}, "CVE-2023-38610": {"epss_score": 0.00061, "epss_percentile": 0.19293}, "CVE-2023-38611": {"epss_score": 0.00992, "epss_percentile": 0.76391}, "CVE-2023-38612": {"epss_score": 0.00042, "epss_percentile": 0.1257}, "CVE-2023-38614": {"epss_score": 0.00041, "epss_percentile": 0.12253}, "CVE-2023-38615": {"epss_score": 0.00093, "epss_percentile": 0.26603}, "CVE-2023-38616": {"epss_score": 0.00059, "epss_percentile": 0.18806}, "CVE-2023-38617": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-38618": {"epss_score": 0.0011, "epss_percentile": 0.30204}, "CVE-2023-38619": {"epss_score": 0.0011, "epss_percentile": 0.30204}, "CVE-2023-38620": {"epss_score": 0.00098, "epss_percentile": 0.27649}, "CVE-2023-38621": {"epss_score": 0.00075, "epss_percentile": 0.22904}, "CVE-2023-38622": {"epss_score": 0.00075, "epss_percentile": 0.22904}, "CVE-2023-38623": {"epss_score": 0.00075, "epss_percentile": 0.22904}, "CVE-2023-38624": {"epss_score": 0.00148, "epss_percentile": 0.35905}, "CVE-2023-38625": {"epss_score": 0.00148, "epss_percentile": 0.35905}, "CVE-2023-38626": {"epss_score": 0.00148, "epss_percentile": 0.35905}, "CVE-2023-38627": {"epss_score": 0.00148, "epss_percentile": 0.35905}, "CVE-2023-38632": {"epss_score": 0.26778, "epss_percentile": 0.9618}, "CVE-2023-38633": {"epss_score": 0.43614, "epss_percentile": 0.97395}, "CVE-2023-38640": {"epss_score": 0.00055, "epss_percentile": 0.17546}, "CVE-2023-38641": {"epss_score": 0.00054, "epss_percentile": 0.17284}, "CVE-2023-38646": {"epss_score": 0.94255, "epss_percentile": 0.99928}, "CVE-2023-38647": {"epss_score": 0.00506, "epss_percentile": 0.65625}, "CVE-2023-38648": {"epss_score": 0.00042, "epss_percentile": 0.1289}, "CVE-2023-38649": {"epss_score": 0.00065, "epss_percentile": 0.20655}, "CVE-2023-38650": {"epss_score": 0.00036, "epss_percentile": 0.10197}, "CVE-2023-38651": {"epss_score": 0.00036, "epss_percentile": 0.10197}, "CVE-2023-38652": {"epss_score": 0.00029, "epss_percentile": 0.07861}, "CVE-2023-38653": {"epss_score": 0.00035, "epss_percentile": 0.09987}, "CVE-2023-38654": {"epss_score": 0.00073, "epss_percentile": 0.22495}, "CVE-2023-38655": {"epss_score": 0.00135, "epss_percentile": 0.34009}, "CVE-2023-38657": {"epss_score": 0.00042, "epss_percentile": 0.1289}, "CVE-2023-38665": {"epss_score": 0.00047, "epss_percentile": 0.14792}, "CVE-2023-38666": {"epss_score": 0.0005, "epss_percentile": 0.15829}, "CVE-2023-38667": {"epss_score": 0.00032, "epss_percentile": 0.09032}, "CVE-2023-38668": {"epss_score": 0.00032, "epss_percentile": 0.09032}, "CVE-2023-38669": {"epss_score": 0.0029, "epss_percentile": 0.52127}, "CVE-2023-38670": {"epss_score": 0.00168, "epss_percentile": 0.38499}, "CVE-2023-38671": {"epss_score": 0.00341, "epss_percentile": 0.56289}, "CVE-2023-38672": {"epss_score": 0.00097, "epss_percentile": 0.27558}, "CVE-2023-38673": {"epss_score": 0.00342, "epss_percentile": 0.56375}, "CVE-2023-38674": {"epss_score": 0.00097, "epss_percentile": 0.27558}, "CVE-2023-38675": {"epss_score": 0.00097, "epss_percentile": 0.27558}, "CVE-2023-38676": {"epss_score": 0.00113, "epss_percentile": 0.30685}, "CVE-2023-38677": {"epss_score": 0.00097, "epss_percentile": 0.27558}, "CVE-2023-38678": {"epss_score": 0.00096, "epss_percentile": 0.2737}, "CVE-2023-38679": {"epss_score": 0.00068, "epss_percentile": 0.21377}, "CVE-2023-38680": {"epss_score": 0.00068, "epss_percentile": 0.21377}, "CVE-2023-38681": {"epss_score": 0.00068, "epss_percentile": 0.21377}, "CVE-2023-38682": {"epss_score": 0.00089, "epss_percentile": 0.25952}, "CVE-2023-38683": {"epss_score": 0.00068, "epss_percentile": 0.21377}, "CVE-2023-38684": {"epss_score": 0.00147, "epss_percentile": 0.35653}, "CVE-2023-38685": {"epss_score": 0.00295, "epss_percentile": 0.52512}, "CVE-2023-38686": {"epss_score": 0.00054, "epss_percentile": 0.17338}, "CVE-2023-38687": {"epss_score": 0.00505, "epss_percentile": 0.65602}, "CVE-2023-38688": {"epss_score": 0.00554, "epss_percentile": 0.67433}, "CVE-2023-38689": {"epss_score": 0.03325, "epss_percentile": 0.8692}, "CVE-2023-38690": {"epss_score": 0.00133, "epss_percentile": 0.3368}, "CVE-2023-38691": {"epss_score": 0.00062, "epss_percentile": 0.19757}, "CVE-2023-38692": {"epss_score": 0.00749, "epss_percentile": 0.72608}, "CVE-2023-38693": {"epss_score": 0.00189, "epss_percentile": 0.40971}, "CVE-2023-38694": {"epss_score": 0.00491, "epss_percentile": 0.6496}, "CVE-2023-38695": {"epss_score": 0.00296, "epss_percentile": 0.52542}, "CVE-2023-38697": {"epss_score": 0.00191, "epss_percentile": 0.41192}, "CVE-2023-38698": {"epss_score": 0.0011, "epss_percentile": 0.30107}, "CVE-2023-38699": {"epss_score": 0.00093, "epss_percentile": 0.26735}, "CVE-2023-38700": {"epss_score": 0.00266, "epss_percentile": 0.49885}, "CVE-2023-38701": {"epss_score": 0.0011, "epss_percentile": 0.30101}, "CVE-2023-38702": {"epss_score": 0.00267, "epss_percentile": 0.50001}, "CVE-2023-38703": {"epss_score": 0.00381, "epss_percentile": 0.58999}, "CVE-2023-38704": {"epss_score": 0.00563, "epss_percentile": 0.6772}, "CVE-2023-38706": {"epss_score": 0.00292, "epss_percentile": 0.52281}, "CVE-2023-38708": {"epss_score": 3e-05, "epss_percentile": 0.00113}, "CVE-2023-38709": {"epss_score": 0.04356, "epss_percentile": 0.8859}, "CVE-2023-38710": {"epss_score": 0.00062, "epss_percentile": 0.19555}, "CVE-2023-38711": {"epss_score": 0.00062, "epss_percentile": 0.19609}, "CVE-2023-38712": {"epss_score": 0.00045, "epss_percentile": 0.14067}, "CVE-2023-38713": {"epss_score": 0.0011, "epss_percentile": 0.30146}, "CVE-2023-38714": {"epss_score": 0.0011, "epss_percentile": 0.30146}, "CVE-2023-38716": {"epss_score": 0.0011, "epss_percentile": 0.30146}, "CVE-2023-38718": {"epss_score": 0.00066, "epss_percentile": 0.20707}, "CVE-2023-38719": {"epss_score": 9e-05, "epss_percentile": 0.00594}, "CVE-2023-38720": {"epss_score": 0.00046, "epss_percentile": 0.14125}, "CVE-2023-38721": {"epss_score": 0.00021, "epss_percentile": 0.04797}, "CVE-2023-38722": {"epss_score": 0.00058, "epss_percentile": 0.1827}, "CVE-2023-38723": {"epss_score": 0.00068, "epss_percentile": 0.21211}, "CVE-2023-38724": {"epss_score": 0.00133, "epss_percentile": 0.33647}, "CVE-2023-38727": {"epss_score": 0.00123, "epss_percentile": 0.32238}, "CVE-2023-38728": {"epss_score": 0.00037, "epss_percentile": 0.10903}, "CVE-2023-38729": {"epss_score": 0.00069, "epss_percentile": 0.2163}, "CVE-2023-38730": {"epss_score": 0.00038, "epss_percentile": 0.1118}, "CVE-2023-38732": {"epss_score": 0.00057, "epss_percentile": 0.18012}, "CVE-2023-38733": {"epss_score": 0.00068, "epss_percentile": 0.2142}, "CVE-2023-38734": {"epss_score": 0.00074, "epss_percentile": 0.22751}, "CVE-2023-38735": {"epss_score": 0.00011, "epss_percentile": 0.01073}, "CVE-2023-38736": {"epss_score": 0.00034, "epss_percentile": 0.09804}, "CVE-2023-38737": {"epss_score": 0.00024, "epss_percentile": 0.06029}, "CVE-2023-38738": {"epss_score": 0.00057, "epss_percentile": 0.1801}, "CVE-2023-38739": {"epss_score": 0.00025, "epss_percentile": 0.06302}, "CVE-2023-38740": {"epss_score": 0.00039, "epss_percentile": 0.11806}, "CVE-2023-38741": {"epss_score": 0.00094, "epss_percentile": 0.27043}, "CVE-2023-38743": {"epss_score": 0.19342, "epss_percentile": 0.95166}, "CVE-2023-38744": {"epss_score": 0.00237, "epss_percentile": 0.46653}, "CVE-2023-38745": {"epss_score": 0.0004, "epss_percentile": 0.12158}, "CVE-2023-38746": {"epss_score": 0.00113, "epss_percentile": 0.30704}, "CVE-2023-38747": {"epss_score": 0.00139, "epss_percentile": 0.34647}, "CVE-2023-38748": {"epss_score": 0.00096, "epss_percentile": 0.27257}, "CVE-2023-38750": {"epss_score": 0.00288, "epss_percentile": 0.51875}, "CVE-2023-38751": {"epss_score": 0.00078, "epss_percentile": 0.23798}, "CVE-2023-38752": {"epss_score": 0.00078, "epss_percentile": 0.23798}, "CVE-2023-38758": {"epss_score": 0.00081, "epss_percentile": 0.24214}, "CVE-2023-38759": {"epss_score": 0.00337, "epss_percentile": 0.5602}, "CVE-2023-38760": {"epss_score": 0.00064, "epss_percentile": 0.2019}, "CVE-2023-38761": {"epss_score": 0.00224, "epss_percentile": 0.45045}, "CVE-2023-38762": {"epss_score": 0.00067, "epss_percentile": 0.21091}, "CVE-2023-38763": {"epss_score": 0.00063, "epss_percentile": 0.19824}, "CVE-2023-38764": {"epss_score": 0.00067, "epss_percentile": 0.21091}, "CVE-2023-38765": {"epss_score": 0.00067, "epss_percentile": 0.21091}, "CVE-2023-38766": {"epss_score": 0.00209, "epss_percentile": 0.43407}, "CVE-2023-38767": {"epss_score": 0.00067, "epss_percentile": 0.21091}, "CVE-2023-38768": {"epss_score": 0.00067, "epss_percentile": 0.21091}, "CVE-2023-38769": {"epss_score": 0.00067, "epss_percentile": 0.21091}, "CVE-2023-38770": {"epss_score": 0.00067, "epss_percentile": 0.21091}, "CVE-2023-38771": {"epss_score": 0.00067, "epss_percentile": 0.21091}, "CVE-2023-38773": {"epss_score": 0.00067, "epss_percentile": 0.21091}, "CVE-2023-38802": {"epss_score": 0.00772, "epss_percentile": 0.73034}, "CVE-2023-38817": {"epss_score": 0.00205, "epss_percentile": 0.42756}, "CVE-2023-38823": {"epss_score": 0.04064, "epss_percentile": 0.88194}, "CVE-2023-38825": {"epss_score": 0.00065, "epss_percentile": 0.2055}, "CVE-2023-38826": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-38827": {"epss_score": 0.00119, "epss_percentile": 0.31602}, "CVE-2023-38829": {"epss_score": 0.15267, "epss_percentile": 0.94395}, "CVE-2023-38830": {"epss_score": 0.00068, "epss_percentile": 0.21338}, "CVE-2023-38831": {"epss_score": 0.93845, "epss_percentile": 0.99856}, "CVE-2023-38836": {"epss_score": 0.88743, "epss_percentile": 0.99487}, "CVE-2023-38838": {"epss_score": 0.0004, "epss_percentile": 0.12075}, "CVE-2023-38839": {"epss_score": 0.00048, "epss_percentile": 0.15258}, "CVE-2023-38840": {"epss_score": 0.02141, "epss_percentile": 0.8375}, "CVE-2023-38843": {"epss_score": 0.00144, "epss_percentile": 0.35312}, "CVE-2023-38844": {"epss_score": 0.00198, "epss_percentile": 0.42024}, "CVE-2023-38845": {"epss_score": 0.00221, "epss_percentile": 0.44706}, "CVE-2023-38846": {"epss_score": 0.00221, "epss_percentile": 0.44706}, "CVE-2023-38847": {"epss_score": 0.00268, "epss_percentile": 0.50046}, "CVE-2023-38848": {"epss_score": 0.00275, "epss_percentile": 0.50631}, "CVE-2023-38849": {"epss_score": 0.00268, "epss_percentile": 0.50046}, "CVE-2023-38850": {"epss_score": 0.00028, "epss_percentile": 0.07438}, "CVE-2023-38851": {"epss_score": 0.00754, "epss_percentile": 0.72695}, "CVE-2023-38852": {"epss_score": 0.00736, "epss_percentile": 0.72314}, "CVE-2023-38853": {"epss_score": 0.00754, "epss_percentile": 0.72695}, "CVE-2023-38854": {"epss_score": 0.00754, "epss_percentile": 0.72695}, "CVE-2023-38855": {"epss_score": 0.00754, "epss_percentile": 0.72695}, "CVE-2023-38856": {"epss_score": 0.00754, "epss_percentile": 0.72695}, "CVE-2023-38857": {"epss_score": 0.00386, "epss_percentile": 0.59242}, "CVE-2023-38858": {"epss_score": 0.00671, "epss_percentile": 0.70798}, "CVE-2023-38860": {"epss_score": 0.01361, "epss_percentile": 0.79752}, "CVE-2023-38861": {"epss_score": 0.01461, "epss_percentile": 0.80433}, "CVE-2023-38862": {"epss_score": 0.00121, "epss_percentile": 0.31988}, "CVE-2023-38863": {"epss_score": 0.00121, "epss_percentile": 0.31988}, "CVE-2023-38864": {"epss_score": 0.00121, "epss_percentile": 0.31988}, "CVE-2023-38865": {"epss_score": 0.01141, "epss_percentile": 0.77967}, "CVE-2023-38866": {"epss_score": 0.01141, "epss_percentile": 0.77967}, "CVE-2023-38870": {"epss_score": 0.00153, "epss_percentile": 0.36569}, "CVE-2023-38871": {"epss_score": 0.00205, "epss_percentile": 0.42703}, "CVE-2023-38872": {"epss_score": 0.00297, "epss_percentile": 0.52745}, "CVE-2023-38873": {"epss_score": 0.00206, "epss_percentile": 0.4306}, "CVE-2023-38874": {"epss_score": 0.20512, "epss_percentile": 0.95359}, "CVE-2023-38875": {"epss_score": 0.04392, "epss_percentile": 0.88636}, "CVE-2023-38876": {"epss_score": 0.06147, "epss_percentile": 0.90519}, "CVE-2023-38877": {"epss_score": 0.00262, "epss_percentile": 0.49359}, "CVE-2023-38878": {"epss_score": 0.00068, "epss_percentile": 0.21312}, "CVE-2023-38879": {"epss_score": 0.11974, "epss_percentile": 0.9353}, "CVE-2023-38880": {"epss_score": 0.00137, "epss_percentile": 0.34282}, "CVE-2023-38881": {"epss_score": 0.00167, "epss_percentile": 0.38346}, "CVE-2023-38882": {"epss_score": 0.00167, "epss_percentile": 0.38346}, "CVE-2023-38883": {"epss_score": 0.00167, "epss_percentile": 0.38346}, "CVE-2023-38884": {"epss_score": 0.00356, "epss_percentile": 0.57335}, "CVE-2023-38885": {"epss_score": 0.00273, "epss_percentile": 0.50433}, "CVE-2023-38886": {"epss_score": 0.48494, "epss_percentile": 0.97641}, "CVE-2023-38887": {"epss_score": 0.03022, "epss_percentile": 0.86229}, "CVE-2023-38888": {"epss_score": 0.05006, "epss_percentile": 0.89385}, "CVE-2023-38889": {"epss_score": 0.0027, "epss_percentile": 0.50216}, "CVE-2023-38890": {"epss_score": 0.03209, "epss_percentile": 0.86647}, "CVE-2023-38891": {"epss_score": 0.01866, "epss_percentile": 0.82614}, "CVE-2023-38894": {"epss_score": 0.02025, "epss_percentile": 0.83311}, "CVE-2023-38896": {"epss_score": 0.00788, "epss_percentile": 0.7334}, "CVE-2023-38898": {"epss_score": 0.00382, "epss_percentile": 0.59074}, "CVE-2023-38899": {"epss_score": 0.00044, "epss_percentile": 0.1368}, "CVE-2023-38902": {"epss_score": 0.01832, "epss_percentile": 0.82454}, "CVE-2023-38904": {"epss_score": 0.00297, "epss_percentile": 0.52754}, "CVE-2023-38905": {"epss_score": 0.00079, "epss_percentile": 0.23994}, "CVE-2023-38906": {"epss_score": 0.00053, "epss_percentile": 0.17032}, "CVE-2023-38907": {"epss_score": 0.00253, "epss_percentile": 0.48478}, "CVE-2023-38908": {"epss_score": 0.00056, "epss_percentile": 0.1778}, "CVE-2023-38909": {"epss_score": 0.00051, "epss_percentile": 0.16127}, "CVE-2023-38910": {"epss_score": 0.00248, "epss_percentile": 0.47954}, "CVE-2023-38911": {"epss_score": 0.00123, "epss_percentile": 0.32233}, "CVE-2023-38912": {"epss_score": 0.04057, "epss_percentile": 0.88187}, "CVE-2023-38913": {"epss_score": 0.00088, "epss_percentile": 0.25647}, "CVE-2023-38915": {"epss_score": 0.00526, "epss_percentile": 0.66437}, "CVE-2023-38916": {"epss_score": 0.0087, "epss_percentile": 0.74705}, "CVE-2023-38920": {"epss_score": 0.00152, "epss_percentile": 0.36392}, "CVE-2023-38921": {"epss_score": 0.01869, "epss_percentile": 0.82624}, "CVE-2023-38922": {"epss_score": 0.00348, "epss_percentile": 0.56798}, "CVE-2023-38924": {"epss_score": 0.0033, "epss_percentile": 0.55498}, "CVE-2023-38925": {"epss_score": 0.21138, "epss_percentile": 0.95468}, "CVE-2023-38926": {"epss_score": 0.00348, "epss_percentile": 0.56798}, "CVE-2023-38928": {"epss_score": 0.01639, "epss_percentile": 0.81489}, "CVE-2023-38929": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-38930": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-38931": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-38932": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-38933": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-38934": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-38935": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-38936": {"epss_score": 0.00334, "epss_percentile": 0.55734}, "CVE-2023-38937": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-38938": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-38939": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-38940": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-38941": {"epss_score": 0.05238, "epss_percentile": 0.89649}, "CVE-2023-38942": {"epss_score": 0.04645, "epss_percentile": 0.88958}, "CVE-2023-38943": {"epss_score": 0.03227, "epss_percentile": 0.86687}, "CVE-2023-38944": {"epss_score": 0.00178, "epss_percentile": 0.39716}, "CVE-2023-38945": {"epss_score": 0.00045, "epss_percentile": 0.14057}, "CVE-2023-38946": {"epss_score": 0.00057, "epss_percentile": 0.18095}, "CVE-2023-38947": {"epss_score": 0.00157, "epss_percentile": 0.37127}, "CVE-2023-38948": {"epss_score": 0.00177, "epss_percentile": 0.39624}, "CVE-2023-38949": {"epss_score": 0.00143, "epss_percentile": 0.35096}, "CVE-2023-38950": {"epss_score": 0.80791, "epss_percentile": 0.99106}, "CVE-2023-38951": {"epss_score": 0.10213, "epss_percentile": 0.92896}, "CVE-2023-38952": {"epss_score": 0.21436, "epss_percentile": 0.95518}, "CVE-2023-38954": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-38955": {"epss_score": 0.00119, "epss_percentile": 0.31648}, "CVE-2023-38956": {"epss_score": 0.00276, "epss_percentile": 0.50764}, "CVE-2023-38958": {"epss_score": 0.00135, "epss_percentile": 0.33936}, "CVE-2023-38960": {"epss_score": 0.00036, "epss_percentile": 0.1038}, "CVE-2023-38961": {"epss_score": 0.06861, "epss_percentile": 0.9108}, "CVE-2023-38964": {"epss_score": 0.04722, "epss_percentile": 0.89055}, "CVE-2023-38965": {"epss_score": 0.00103, "epss_percentile": 0.28997}, "CVE-2023-38969": {"epss_score": 0.00331, "epss_percentile": 0.55499}, "CVE-2023-38970": {"epss_score": 0.00303, "epss_percentile": 0.53232}, "CVE-2023-38971": {"epss_score": 0.00331, "epss_percentile": 0.55499}, "CVE-2023-38973": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-38974": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-38975": {"epss_score": 0.00396, "epss_percentile": 0.59886}, "CVE-2023-38976": {"epss_score": 0.03461, "epss_percentile": 0.87182}, "CVE-2023-38988": {"epss_score": 0.00056, "epss_percentile": 0.17866}, "CVE-2023-38989": {"epss_score": 0.00047, "epss_percentile": 0.14479}, "CVE-2023-38990": {"epss_score": 0.00168, "epss_percentile": 0.38422}, "CVE-2023-38991": {"epss_score": 0.00035, "epss_percentile": 0.10122}, "CVE-2023-38992": {"epss_score": 0.66947, "epss_percentile": 0.98487}, "CVE-2023-38994": {"epss_score": 0.00035, "epss_percentile": 0.09809}, "CVE-2023-38995": {"epss_score": 0.00388, "epss_percentile": 0.59395}, "CVE-2023-38996": {"epss_score": 0.00057, "epss_percentile": 0.18219}, "CVE-2023-38997": {"epss_score": 0.00904, "epss_percentile": 0.75211}, "CVE-2023-38998": {"epss_score": 0.00173, "epss_percentile": 0.39094}, "CVE-2023-38999": {"epss_score": 0.0013, "epss_percentile": 0.33247}, "CVE-2023-39000": {"epss_score": 0.0021, "epss_percentile": 0.43499}, "CVE-2023-39001": {"epss_score": 0.04893, "epss_percentile": 0.89268}, "CVE-2023-39002": {"epss_score": 0.23578, "epss_percentile": 0.95794}, "CVE-2023-39003": {"epss_score": 0.00286, "epss_percentile": 0.51695}, "CVE-2023-39004": {"epss_score": 0.00116, "epss_percentile": 0.31183}, "CVE-2023-39005": {"epss_score": 0.00456, "epss_percentile": 0.6332}, "CVE-2023-39006": {"epss_score": 0.00098, "epss_percentile": 0.27729}, "CVE-2023-39007": {"epss_score": 0.41893, "epss_percentile": 0.973}, "CVE-2023-39008": {"epss_score": 0.04608, "epss_percentile": 0.88911}, "CVE-2023-39010": {"epss_score": 0.0015, "epss_percentile": 0.36103}, "CVE-2023-39013": {"epss_score": 0.00105, "epss_percentile": 0.29307}, "CVE-2023-39015": {"epss_score": 0.00105, "epss_percentile": 0.29307}, "CVE-2023-39016": {"epss_score": 0.00096, "epss_percentile": 0.27419}, "CVE-2023-39017": {"epss_score": 0.00696, "epss_percentile": 0.71389}, "CVE-2023-39018": {"epss_score": 0.00096, "epss_percentile": 0.27419}, "CVE-2023-39020": {"epss_score": 0.00104, "epss_percentile": 0.29126}, "CVE-2023-39021": {"epss_score": 0.00113, "epss_percentile": 0.30635}, "CVE-2023-39022": {"epss_score": 0.00113, "epss_percentile": 0.30635}, "CVE-2023-39023": {"epss_score": 0.00104, "epss_percentile": 0.29126}, "CVE-2023-39026": {"epss_score": 0.82666, "epss_percentile": 0.99205}, "CVE-2023-39039": {"epss_score": 0.00068, "epss_percentile": 0.21385}, "CVE-2023-39040": {"epss_score": 0.00068, "epss_percentile": 0.21385}, "CVE-2023-39041": {"epss_score": 0.00093, "epss_percentile": 0.26649}, "CVE-2023-39042": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-39043": {"epss_score": 0.00079, "epss_percentile": 0.23988}, "CVE-2023-39044": {"epss_score": 0.00093, "epss_percentile": 0.26649}, "CVE-2023-39045": {"epss_score": 0.00093, "epss_percentile": 0.26649}, "CVE-2023-39046": {"epss_score": 0.00068, "epss_percentile": 0.21385}, "CVE-2023-39047": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-39048": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-39049": {"epss_score": 0.00068, "epss_percentile": 0.21385}, "CVE-2023-39050": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-39051": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-39052": {"epss_score": 0.00093, "epss_percentile": 0.26649}, "CVE-2023-39053": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-39054": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-39056": {"epss_score": 0.00068, "epss_percentile": 0.21385}, "CVE-2023-39057": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-39058": {"epss_score": 0.00089, "epss_percentile": 0.25948}, "CVE-2023-39059": {"epss_score": 0.0159, "epss_percentile": 0.812}, "CVE-2023-39061": {"epss_score": 0.00534, "epss_percentile": 0.66792}, "CVE-2023-39062": {"epss_score": 0.35464, "epss_percentile": 0.96914}, "CVE-2023-39063": {"epss_score": 0.01533, "epss_percentile": 0.80899}, "CVE-2023-39067": {"epss_score": 0.00126, "epss_percentile": 0.32657}, "CVE-2023-39068": {"epss_score": 0.00839, "epss_percentile": 0.74195}, "CVE-2023-39069": {"epss_score": 0.00937, "epss_percentile": 0.75696}, "CVE-2023-39070": {"epss_score": 0.00031, "epss_percentile": 0.08622}, "CVE-2023-39073": {"epss_score": 0.01673, "epss_percentile": 0.8169}, "CVE-2023-39075": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2023-39076": {"epss_score": 0.00029, "epss_percentile": 0.07907}, "CVE-2023-39086": {"epss_score": 0.00049, "epss_percentile": 0.15495}, "CVE-2023-39094": {"epss_score": 0.00188, "epss_percentile": 0.40903}, "CVE-2023-39096": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-39097": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-39106": {"epss_score": 0.01742, "epss_percentile": 0.82054}, "CVE-2023-39107": {"epss_score": 0.00346, "epss_percentile": 0.56633}, "CVE-2023-39108": {"epss_score": 0.74826, "epss_percentile": 0.98819}, "CVE-2023-39109": {"epss_score": 0.74826, "epss_percentile": 0.98819}, "CVE-2023-39110": {"epss_score": 0.76853, "epss_percentile": 0.98908}, "CVE-2023-39112": {"epss_score": 0.00054, "epss_percentile": 0.17279}, "CVE-2023-39113": {"epss_score": 0.00023, "epss_percentile": 0.05484}, "CVE-2023-39114": {"epss_score": 0.00023, "epss_percentile": 0.05484}, "CVE-2023-39115": {"epss_score": 0.0204, "epss_percentile": 0.83366}, "CVE-2023-39121": {"epss_score": 0.01735, "epss_percentile": 0.82007}, "CVE-2023-39122": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-39125": {"epss_score": 0.00063, "epss_percentile": 0.19987}, "CVE-2023-39128": {"epss_score": 0.00024, "epss_percentile": 0.05668}, "CVE-2023-39129": {"epss_score": 0.00019, "epss_percentile": 0.04298}, "CVE-2023-39130": {"epss_score": 0.00038, "epss_percentile": 0.11131}, "CVE-2023-39135": {"epss_score": 0.00472, "epss_percentile": 0.64047}, "CVE-2023-39136": {"epss_score": 0.00053, "epss_percentile": 0.16932}, "CVE-2023-39137": {"epss_score": 0.00043, "epss_percentile": 0.13013}, "CVE-2023-39138": {"epss_score": 0.00114, "epss_percentile": 0.30862}, "CVE-2023-39139": {"epss_score": 0.00046, "epss_percentile": 0.14083}, "CVE-2023-39141": {"epss_score": 0.85587, "epss_percentile": 0.9934}, "CVE-2023-39143": {"epss_score": 0.88783, "epss_percentile": 0.99489}, "CVE-2023-39144": {"epss_score": 0.00082, "epss_percentile": 0.24428}, "CVE-2023-39147": {"epss_score": 0.00214, "epss_percentile": 0.44006}, "CVE-2023-39150": {"epss_score": 0.00204, "epss_percentile": 0.42601}, "CVE-2023-39151": {"epss_score": 0.01057, "epss_percentile": 0.7713}, "CVE-2023-39152": {"epss_score": 0.00114, "epss_percentile": 0.30815}, "CVE-2023-39153": {"epss_score": 0.0008, "epss_percentile": 0.24138}, "CVE-2023-39154": {"epss_score": 0.00063, "epss_percentile": 0.201}, "CVE-2023-39155": {"epss_score": 0.0008, "epss_percentile": 0.24123}, "CVE-2023-39156": {"epss_score": 0.00048, "epss_percentile": 0.15228}, "CVE-2023-39157": {"epss_score": 0.00331, "epss_percentile": 0.55542}, "CVE-2023-39158": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-39159": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-39161": {"epss_score": 0.00257, "epss_percentile": 0.48862}, "CVE-2023-39162": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-39163": {"epss_score": 0.0063, "epss_percentile": 0.6969}, "CVE-2023-39164": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-39165": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-39166": {"epss_score": 0.00061, "epss_percentile": 0.19252}, "CVE-2023-39167": {"epss_score": 0.00284, "epss_percentile": 0.51433}, "CVE-2023-39169": {"epss_score": 0.00278, "epss_percentile": 0.50892}, "CVE-2023-39171": {"epss_score": 0.00224, "epss_percentile": 0.45015}, "CVE-2023-39172": {"epss_score": 0.00194, "epss_percentile": 0.41578}, "CVE-2023-39173": {"epss_score": 3e-05, "epss_percentile": 0.00076}, "CVE-2023-39174": {"epss_score": 2e-05, "epss_percentile": 0.00024}, "CVE-2023-39175": {"epss_score": 0.00032, "epss_percentile": 0.0886}, "CVE-2023-39176": {"epss_score": 0.00087, "epss_percentile": 0.25578}, "CVE-2023-39179": {"epss_score": 0.00056, "epss_percentile": 0.17687}, "CVE-2023-39180": {"epss_score": 0.00059, "epss_percentile": 0.18912}, "CVE-2023-39181": {"epss_score": 0.00073, "epss_percentile": 0.22511}, "CVE-2023-39182": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-39183": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-39184": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-39185": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-39186": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-39187": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-39188": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2023-39189": {"epss_score": 9e-05, "epss_percentile": 0.00607}, "CVE-2023-39191": {"epss_score": 0.00012, "epss_percentile": 0.01251}, "CVE-2023-39192": {"epss_score": 9e-05, "epss_percentile": 0.00736}, "CVE-2023-39193": {"epss_score": 8e-05, "epss_percentile": 0.00489}, "CVE-2023-39194": {"epss_score": 9e-05, "epss_percentile": 0.00617}, "CVE-2023-39196": {"epss_score": 0.00118, "epss_percentile": 0.31438}, "CVE-2023-39197": {"epss_score": 0.00039, "epss_percentile": 0.11529}, "CVE-2023-39198": {"epss_score": 8e-05, "epss_percentile": 0.00501}, "CVE-2023-39199": {"epss_score": 0.00103, "epss_percentile": 0.28961}, "CVE-2023-39201": {"epss_score": 0.00095, "epss_percentile": 0.27232}, "CVE-2023-39202": {"epss_score": 0.00027, "epss_percentile": 0.07001}, "CVE-2023-39203": {"epss_score": 0.00167, "epss_percentile": 0.38395}, "CVE-2023-39204": {"epss_score": 0.00273, "epss_percentile": 0.50438}, "CVE-2023-39205": {"epss_score": 0.00282, "epss_percentile": 0.51239}, "CVE-2023-39206": {"epss_score": 0.00312, "epss_percentile": 0.54007}, "CVE-2023-39208": {"epss_score": 0.00064, "epss_percentile": 0.20106}, "CVE-2023-39209": {"epss_score": 0.00098, "epss_percentile": 0.27725}, "CVE-2023-39210": {"epss_score": 0.00034, "epss_percentile": 0.09698}, "CVE-2023-39211": {"epss_score": 0.00029, "epss_percentile": 0.07656}, "CVE-2023-39212": {"epss_score": 0.0004, "epss_percentile": 0.11924}, "CVE-2023-39213": {"epss_score": 0.00848, "epss_percentile": 0.74366}, "CVE-2023-39214": {"epss_score": 0.00323, "epss_percentile": 0.54915}, "CVE-2023-39215": {"epss_score": 0.00287, "epss_percentile": 0.51833}, "CVE-2023-39216": {"epss_score": 0.00355, "epss_percentile": 0.57261}, "CVE-2023-39217": {"epss_score": 0.00167, "epss_percentile": 0.38382}, "CVE-2023-39218": {"epss_score": 0.00259, "epss_percentile": 0.49058}, "CVE-2023-39219": {"epss_score": 0.00171, "epss_percentile": 0.38834}, "CVE-2023-39221": {"epss_score": 0.00157, "epss_percentile": 0.37126}, "CVE-2023-39222": {"epss_score": 0.008, "epss_percentile": 0.73546}, "CVE-2023-39223": {"epss_score": 0.00092, "epss_percentile": 0.26419}, "CVE-2023-39224": {"epss_score": 0.00078, "epss_percentile": 0.23667}, "CVE-2023-39226": {"epss_score": 0.00244, "epss_percentile": 0.47518}, "CVE-2023-39227": {"epss_score": 0.00083, "epss_percentile": 0.24702}, "CVE-2023-39228": {"epss_score": 0.00108, "epss_percentile": 0.29843}, "CVE-2023-39230": {"epss_score": 0.00064, "epss_percentile": 0.20193}, "CVE-2023-39231": {"epss_score": 0.00145, "epss_percentile": 0.35441}, "CVE-2023-39233": {"epss_score": 0.00309, "epss_percentile": 0.53705}, "CVE-2023-39234": {"epss_score": 0.0005, "epss_percentile": 0.15894}, "CVE-2023-39235": {"epss_score": 0.00042, "epss_percentile": 0.12706}, "CVE-2023-39236": {"epss_score": 0.007, "epss_percentile": 0.71463}, "CVE-2023-39237": {"epss_score": 0.00601, "epss_percentile": 0.6884}, "CVE-2023-39238": {"epss_score": 0.03202, "epss_percentile": 0.86625}, "CVE-2023-39239": {"epss_score": 0.00848, "epss_percentile": 0.74365}, "CVE-2023-39240": {"epss_score": 0.00848, "epss_percentile": 0.74365}, "CVE-2023-39244": {"epss_score": 0.00578, "epss_percentile": 0.68187}, "CVE-2023-39245": {"epss_score": 0.00302, "epss_percentile": 0.53084}, "CVE-2023-39246": {"epss_score": 0.00022, "epss_percentile": 0.05271}, "CVE-2023-39248": {"epss_score": 0.00135, "epss_percentile": 0.33944}, "CVE-2023-39249": {"epss_score": 0.00011, "epss_percentile": 0.0109}, "CVE-2023-39250": {"epss_score": 0.00046, "epss_percentile": 0.14188}, "CVE-2023-39251": {"epss_score": 0.00035, "epss_percentile": 0.09894}, "CVE-2023-39252": {"epss_score": 0.00064, "epss_percentile": 0.20145}, "CVE-2023-39253": {"epss_score": 0.0003, "epss_percentile": 0.08309}, "CVE-2023-39254": {"epss_score": 0.00044, "epss_percentile": 0.13466}, "CVE-2023-39256": {"epss_score": 0.00031, "epss_percentile": 0.08548}, "CVE-2023-39257": {"epss_score": 0.00031, "epss_percentile": 0.08548}, "CVE-2023-39259": {"epss_score": 0.00045, "epss_percentile": 0.13899}, "CVE-2023-39261": {"epss_score": 3e-05, "epss_percentile": 0.00123}, "CVE-2023-39264": {"epss_score": 0.00097, "epss_percentile": 0.27519}, "CVE-2023-39265": {"epss_score": 0.72889, "epss_percentile": 0.98728}, "CVE-2023-39266": {"epss_score": 0.00257, "epss_percentile": 0.48845}, "CVE-2023-39267": {"epss_score": 0.00298, "epss_percentile": 0.5279}, "CVE-2023-39268": {"epss_score": 0.00182, "epss_percentile": 0.40206}, "CVE-2023-39269": {"epss_score": 0.00285, "epss_percentile": 0.51534}, "CVE-2023-39270": {"epss_score": 0.00057, "epss_percentile": 0.18188}, "CVE-2023-39271": {"epss_score": 0.00057, "epss_percentile": 0.18188}, "CVE-2023-39272": {"epss_score": 0.00048, "epss_percentile": 0.15173}, "CVE-2023-39273": {"epss_score": 0.00078, "epss_percentile": 0.23613}, "CVE-2023-39274": {"epss_score": 0.00078, "epss_percentile": 0.23613}, "CVE-2023-39275": {"epss_score": 0.00078, "epss_percentile": 0.23613}, "CVE-2023-39276": {"epss_score": 0.00484, "epss_percentile": 0.64661}, "CVE-2023-39277": {"epss_score": 0.00484, "epss_percentile": 0.64661}, "CVE-2023-39278": {"epss_score": 0.00484, "epss_percentile": 0.64661}, "CVE-2023-39279": {"epss_score": 0.00484, "epss_percentile": 0.64661}, "CVE-2023-39280": {"epss_score": 0.00484, "epss_percentile": 0.64661}, "CVE-2023-39281": {"epss_score": 0.00232, "epss_percentile": 0.45888}, "CVE-2023-39283": {"epss_score": 0.00098, "epss_percentile": 0.27755}, "CVE-2023-39284": {"epss_score": 0.00057, "epss_percentile": 0.18195}, "CVE-2023-39285": {"epss_score": 0.0011, "epss_percentile": 0.30182}, "CVE-2023-39286": {"epss_score": 0.0011, "epss_percentile": 0.30182}, "CVE-2023-39287": {"epss_score": 0.00145, "epss_percentile": 0.35522}, "CVE-2023-39288": {"epss_score": 0.00145, "epss_percentile": 0.35522}, "CVE-2023-39289": {"epss_score": 0.00249, "epss_percentile": 0.4805}, "CVE-2023-39290": {"epss_score": 0.00123, "epss_percentile": 0.32201}, "CVE-2023-39291": {"epss_score": 0.00123, "epss_percentile": 0.32201}, "CVE-2023-39292": {"epss_score": 0.00272, "epss_percentile": 0.50392}, "CVE-2023-39293": {"epss_score": 0.00785, "epss_percentile": 0.73248}, "CVE-2023-39294": {"epss_score": 0.00125, "epss_percentile": 0.32615}, "CVE-2023-39295": {"epss_score": 0.00407, "epss_percentile": 0.6062}, "CVE-2023-39296": {"epss_score": 0.00417, "epss_percentile": 0.61231}, "CVE-2023-39297": {"epss_score": 0.00301, "epss_percentile": 0.52994}, "CVE-2023-39298": {"epss_score": 0.00049, "epss_percentile": 0.1557}, "CVE-2023-39299": {"epss_score": 0.0013, "epss_percentile": 0.33309}, "CVE-2023-39300": {"epss_score": 0.00144, "epss_percentile": 0.35313}, "CVE-2023-39301": {"epss_score": 0.00149, "epss_percentile": 0.36042}, "CVE-2023-39302": {"epss_score": 0.00093, "epss_percentile": 0.26749}, "CVE-2023-39303": {"epss_score": 0.00196, "epss_percentile": 0.41749}, "CVE-2023-39305": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-39306": {"epss_score": 0.0017, "epss_percentile": 0.38676}, "CVE-2023-39307": {"epss_score": 0.00656, "epss_percentile": 0.70432}, "CVE-2023-39308": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-39309": {"epss_score": 0.00224, "epss_percentile": 0.45042}, "CVE-2023-39310": {"epss_score": 0.00107, "epss_percentile": 0.29661}, "CVE-2023-39311": {"epss_score": 0.00174, "epss_percentile": 0.39206}, "CVE-2023-39312": {"epss_score": 0.00439, "epss_percentile": 0.62597}, "CVE-2023-39313": {"epss_score": 0.00437, "epss_percentile": 0.62519}, "CVE-2023-39314": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-39316": {"epss_score": 0.00089, "epss_percentile": 0.25878}, "CVE-2023-39317": {"epss_score": 0.00081, "epss_percentile": 0.24215}, "CVE-2023-39318": {"epss_score": 0.00085, "epss_percentile": 0.2504}, "CVE-2023-39319": {"epss_score": 0.00085, "epss_percentile": 0.2504}, "CVE-2023-39320": {"epss_score": 0.00798, "epss_percentile": 0.73512}, "CVE-2023-39321": {"epss_score": 0.00055, "epss_percentile": 0.17571}, "CVE-2023-39322": {"epss_score": 0.00042, "epss_percentile": 0.127}, "CVE-2023-39323": {"epss_score": 0.0006, "epss_percentile": 0.19079}, "CVE-2023-39325": {"epss_score": 0.0015, "epss_percentile": 0.36069}, "CVE-2023-39326": {"epss_score": 0.00064, "epss_percentile": 0.20432}, "CVE-2023-39327": {"epss_score": 0.00048, "epss_percentile": 0.15036}, "CVE-2023-39328": {"epss_score": 0.00013, "epss_percentile": 0.017}, "CVE-2023-39329": {"epss_score": 0.0016, "epss_percentile": 0.37467}, "CVE-2023-39331": {"epss_score": 0.00641, "epss_percentile": 0.70016}, "CVE-2023-39332": {"epss_score": 0.00509, "epss_percentile": 0.6572}, "CVE-2023-39333": {"epss_score": 0.00087, "epss_percentile": 0.25497}, "CVE-2023-39335": {"epss_score": 0.01615, "epss_percentile": 0.8135}, "CVE-2023-39336": {"epss_score": 0.00781, "epss_percentile": 0.73191}, "CVE-2023-39337": {"epss_score": 0.01136, "epss_percentile": 0.77919}, "CVE-2023-39338": {"epss_score": 0.01215, "epss_percentile": 0.78591}, "CVE-2023-39339": {"epss_score": 0.00756, "epss_percentile": 0.72747}, "CVE-2023-39340": {"epss_score": 0.00392, "epss_percentile": 0.59691}, "CVE-2023-39341": {"epss_score": 0.00027, "epss_percentile": 0.07088}, "CVE-2023-39342": {"epss_score": 0.0006, "epss_percentile": 0.19053}, "CVE-2023-39343": {"epss_score": 0.00362, "epss_percentile": 0.5781}, "CVE-2023-39344": {"epss_score": 0.03604, "epss_percentile": 0.87414}, "CVE-2023-39345": {"epss_score": 0.00079, "epss_percentile": 0.23898}, "CVE-2023-39346": {"epss_score": 0.02051, "epss_percentile": 0.83402}, "CVE-2023-39347": {"epss_score": 0.00042, "epss_percentile": 0.12621}, "CVE-2023-39348": {"epss_score": 0.0022, "epss_percentile": 0.44587}, "CVE-2023-39349": {"epss_score": 0.0008, "epss_percentile": 0.24089}, "CVE-2023-39350": {"epss_score": 0.00327, "epss_percentile": 0.55145}, "CVE-2023-39351": {"epss_score": 0.00099, "epss_percentile": 0.28409}, "CVE-2023-39352": {"epss_score": 0.00136, "epss_percentile": 0.34119}, "CVE-2023-39353": {"epss_score": 0.0008, "epss_percentile": 0.24107}, "CVE-2023-39354": {"epss_score": 0.00211, "epss_percentile": 0.43671}, "CVE-2023-39355": {"epss_score": 0.00277, "epss_percentile": 0.5078}, "CVE-2023-39356": {"epss_score": 0.00145, "epss_percentile": 0.3544}, "CVE-2023-39357": {"epss_score": 0.01417, "epss_percentile": 0.80147}, "CVE-2023-39358": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2023-39359": {"epss_score": 0.04724, "epss_percentile": 0.8906}, "CVE-2023-39360": {"epss_score": 0.00523, "epss_percentile": 0.66311}, "CVE-2023-39361": {"epss_score": 0.93059, "epss_percentile": 0.99772}, "CVE-2023-39362": {"epss_score": 0.86745, "epss_percentile": 0.99394}, "CVE-2023-39363": {"epss_score": 0.00072, "epss_percentile": 0.22367}, "CVE-2023-39364": {"epss_score": 0.00166, "epss_percentile": 0.38173}, "CVE-2023-39365": {"epss_score": 0.0017, "epss_percentile": 0.38726}, "CVE-2023-39366": {"epss_score": 0.00331, "epss_percentile": 0.55527}, "CVE-2023-39367": {"epss_score": 0.03851, "epss_percentile": 0.87848}, "CVE-2023-39368": {"epss_score": 0.00221, "epss_percentile": 0.44703}, "CVE-2023-39369": {"epss_score": 0.00091, "epss_percentile": 0.26176}, "CVE-2023-39370": {"epss_score": 0.00084, "epss_percentile": 0.24865}, "CVE-2023-39371": {"epss_score": 0.00072, "epss_percentile": 0.22323}, "CVE-2023-39372": {"epss_score": 0.00052, "epss_percentile": 0.16636}, "CVE-2023-39373": {"epss_score": 0.00011, "epss_percentile": 0.01115}, "CVE-2023-39374": {"epss_score": 0.00052, "epss_percentile": 0.16633}, "CVE-2023-39375": {"epss_score": 0.00146, "epss_percentile": 0.35557}, "CVE-2023-39376": {"epss_score": 0.00079, "epss_percentile": 0.23913}, "CVE-2023-39377": {"epss_score": 0.00347, "epss_percentile": 0.56793}, "CVE-2023-39378": {"epss_score": 0.00117, "epss_percentile": 0.31341}, "CVE-2023-39379": {"epss_score": 0.00043, "epss_percentile": 0.13287}, "CVE-2023-39380": {"epss_score": 0.00062, "epss_percentile": 0.19569}, "CVE-2023-39381": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-39382": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-39383": {"epss_score": 0.00059, "epss_percentile": 0.189}, "CVE-2023-39384": {"epss_score": 0.00062, "epss_percentile": 0.19569}, "CVE-2023-39385": {"epss_score": 0.00082, "epss_percentile": 0.24441}, "CVE-2023-39386": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-39387": {"epss_score": 0.00057, "epss_percentile": 0.18226}, "CVE-2023-39388": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-39389": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-39390": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-39391": {"epss_score": 0.00081, "epss_percentile": 0.24227}, "CVE-2023-39392": {"epss_score": 0.00027, "epss_percentile": 0.06901}, "CVE-2023-39393": {"epss_score": 0.00027, "epss_percentile": 0.06901}, "CVE-2023-39394": {"epss_score": 0.00059, "epss_percentile": 0.18616}, "CVE-2023-39395": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-39396": {"epss_score": 0.00096, "epss_percentile": 0.27448}, "CVE-2023-39397": {"epss_score": 0.00084, "epss_percentile": 0.24881}, "CVE-2023-39398": {"epss_score": 0.00066, "epss_percentile": 0.20891}, "CVE-2023-39399": {"epss_score": 0.00066, "epss_percentile": 0.20891}, "CVE-2023-39400": {"epss_score": 0.00102, "epss_percentile": 0.28866}, "CVE-2023-39401": {"epss_score": 0.00102, "epss_percentile": 0.28866}, "CVE-2023-39402": {"epss_score": 0.00102, "epss_percentile": 0.28866}, "CVE-2023-39403": {"epss_score": 0.00057, "epss_percentile": 0.18064}, "CVE-2023-39404": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-39405": {"epss_score": 0.00104, "epss_percentile": 0.29161}, "CVE-2023-39406": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-39407": {"epss_score": 0.00152, "epss_percentile": 0.36397}, "CVE-2023-39408": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-39409": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-39410": {"epss_score": 0.00061, "epss_percentile": 0.19319}, "CVE-2023-39411": {"epss_score": 0.00049, "epss_percentile": 0.15379}, "CVE-2023-39412": {"epss_score": 0.00158, "epss_percentile": 0.37224}, "CVE-2023-39413": {"epss_score": 0.00025, "epss_percentile": 0.06368}, "CVE-2023-39414": {"epss_score": 0.00031, "epss_percentile": 0.08318}, "CVE-2023-39415": {"epss_score": 0.00338, "epss_percentile": 0.56127}, "CVE-2023-39416": {"epss_score": 0.00563, "epss_percentile": 0.67724}, "CVE-2023-39417": {"epss_score": 0.00606, "epss_percentile": 0.69}, "CVE-2023-39418": {"epss_score": 0.00439, "epss_percentile": 0.62578}, "CVE-2023-39419": {"epss_score": 0.00073, "epss_percentile": 0.22511}, "CVE-2023-39420": {"epss_score": 0.00302, "epss_percentile": 0.53133}, "CVE-2023-39421": {"epss_score": 0.00055, "epss_percentile": 0.17602}, "CVE-2023-39422": {"epss_score": 0.00065, "epss_percentile": 0.2056}, "CVE-2023-39423": {"epss_score": 0.00083, "epss_percentile": 0.24619}, "CVE-2023-39424": {"epss_score": 0.00409, "epss_percentile": 0.60787}, "CVE-2023-39425": {"epss_score": 0.00084, "epss_percentile": 0.25012}, "CVE-2023-39427": {"epss_score": 0.00099, "epss_percentile": 0.28313}, "CVE-2023-39429": {"epss_score": 0.00309, "epss_percentile": 0.53705}, "CVE-2023-39431": {"epss_score": 0.00268, "epss_percentile": 0.50058}, "CVE-2023-39432": {"epss_score": 0.00064, "epss_percentile": 0.20181}, "CVE-2023-39433": {"epss_score": 0.00048, "epss_percentile": 0.15008}, "CVE-2023-39434": {"epss_score": 0.00651, "epss_percentile": 0.70274}, "CVE-2023-39435": {"epss_score": 0.00338, "epss_percentile": 0.56156}, "CVE-2023-39436": {"epss_score": 0.00171, "epss_percentile": 0.38838}, "CVE-2023-39437": {"epss_score": 0.00113, "epss_percentile": 0.30621}, "CVE-2023-39438": {"epss_score": 0.00165, "epss_percentile": 0.38043}, "CVE-2023-39439": {"epss_score": 0.00303, "epss_percentile": 0.53221}, "CVE-2023-39440": {"epss_score": 0.00031, "epss_percentile": 0.08569}, "CVE-2023-39441": {"epss_score": 0.0024, "epss_percentile": 0.47233}, "CVE-2023-39443": {"epss_score": 0.00101, "epss_percentile": 0.28703}, "CVE-2023-39444": {"epss_score": 0.00084, "epss_percentile": 0.2502}, "CVE-2023-39445": {"epss_score": 0.00131, "epss_percentile": 0.33372}, "CVE-2023-39446": {"epss_score": 0.00067, "epss_percentile": 0.21175}, "CVE-2023-39447": {"epss_score": 0.00146, "epss_percentile": 0.35642}, "CVE-2023-39448": {"epss_score": 0.04727, "epss_percentile": 0.89067}, "CVE-2023-39452": {"epss_score": 0.00085, "epss_percentile": 0.25035}, "CVE-2023-39453": {"epss_score": 0.00299, "epss_percentile": 0.52857}, "CVE-2023-39454": {"epss_score": 0.00455, "epss_percentile": 0.63279}, "CVE-2023-39455": {"epss_score": 0.01516, "epss_percentile": 0.80799}, "CVE-2023-39456": {"epss_score": 0.07819, "epss_percentile": 0.91697}, "CVE-2023-39457": {"epss_score": 0.00378, "epss_percentile": 0.58786}, "CVE-2023-39458": {"epss_score": 0.00015, "epss_percentile": 0.02407}, "CVE-2023-39459": {"epss_score": 0.00341, "epss_percentile": 0.56342}, "CVE-2023-39460": {"epss_score": 0.01064, "epss_percentile": 0.77198}, "CVE-2023-39461": {"epss_score": 0.00163, "epss_percentile": 0.37782}, "CVE-2023-39462": {"epss_score": 0.00456, "epss_percentile": 0.63316}, "CVE-2023-39463": {"epss_score": 0.00557, "epss_percentile": 0.67552}, "CVE-2023-39464": {"epss_score": 0.0023, "epss_percentile": 0.45721}, "CVE-2023-39465": {"epss_score": 0.00107, "epss_percentile": 0.29639}, "CVE-2023-39466": {"epss_score": 0.00113, "epss_percentile": 0.30663}, "CVE-2023-39467": {"epss_score": 0.00079, "epss_percentile": 0.23858}, "CVE-2023-39468": {"epss_score": 0.01151, "epss_percentile": 0.78034}, "CVE-2023-39469": {"epss_score": 0.55123, "epss_percentile": 0.97962}, "CVE-2023-39470": {"epss_score": 0.12209, "epss_percentile": 0.93603}, "CVE-2023-39471": {"epss_score": 0.00622, "epss_percentile": 0.69495}, "CVE-2023-39472": {"epss_score": 0.00534, "epss_percentile": 0.66786}, "CVE-2023-39473": {"epss_score": 0.29897, "epss_percentile": 0.96485}, "CVE-2023-39474": {"epss_score": 0.01051, "epss_percentile": 0.7708}, "CVE-2023-39475": {"epss_score": 0.02339, "epss_percentile": 0.84428}, "CVE-2023-39476": {"epss_score": 0.02339, "epss_percentile": 0.84428}, "CVE-2023-39477": {"epss_score": 0.00337, "epss_percentile": 0.56054}, "CVE-2023-39478": {"epss_score": 0.00308, "epss_percentile": 0.53631}, "CVE-2023-39479": {"epss_score": 0.00568, "epss_percentile": 0.67901}, "CVE-2023-39480": {"epss_score": 0.00264, "epss_percentile": 0.49567}, "CVE-2023-39481": {"epss_score": 0.00259, "epss_percentile": 0.49064}, "CVE-2023-39482": {"epss_score": 0.00167, "epss_percentile": 0.3832}, "CVE-2023-39483": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-39484": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-39485": {"epss_score": 0.00736, "epss_percentile": 0.72306}, "CVE-2023-39486": {"epss_score": 0.00736, "epss_percentile": 0.72306}, "CVE-2023-39487": {"epss_score": 0.00279, "epss_percentile": 0.50987}, "CVE-2023-39488": {"epss_score": 0.01, "epss_percentile": 0.76486}, "CVE-2023-39489": {"epss_score": 0.00935, "epss_percentile": 0.75672}, "CVE-2023-39490": {"epss_score": 0.01096, "epss_percentile": 0.77519}, "CVE-2023-39491": {"epss_score": 0.01, "epss_percentile": 0.76486}, "CVE-2023-39492": {"epss_score": 0.01033, "epss_percentile": 0.76877}, "CVE-2023-39493": {"epss_score": 0.00474, "epss_percentile": 0.64138}, "CVE-2023-39494": {"epss_score": 0.01636, "epss_percentile": 0.81479}, "CVE-2023-39495": {"epss_score": 0.0021, "epss_percentile": 0.43453}, "CVE-2023-39496": {"epss_score": 0.00935, "epss_percentile": 0.75672}, "CVE-2023-39497": {"epss_score": 0.00935, "epss_percentile": 0.75672}, "CVE-2023-39498": {"epss_score": 0.01096, "epss_percentile": 0.77519}, "CVE-2023-39499": {"epss_score": 0.00935, "epss_percentile": 0.75672}, "CVE-2023-39500": {"epss_score": 0.00935, "epss_percentile": 0.75672}, "CVE-2023-39501": {"epss_score": 0.00935, "epss_percentile": 0.75672}, "CVE-2023-39502": {"epss_score": 0.00935, "epss_percentile": 0.75672}, "CVE-2023-39503": {"epss_score": 0.00319, "epss_percentile": 0.54464}, "CVE-2023-39504": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-39505": {"epss_score": 0.00152, "epss_percentile": 0.36487}, "CVE-2023-39506": {"epss_score": 0.00788, "epss_percentile": 0.73336}, "CVE-2023-39507": {"epss_score": 0.00071, "epss_percentile": 0.22226}, "CVE-2023-39508": {"epss_score": 0.00705, "epss_percentile": 0.71578}, "CVE-2023-39509": {"epss_score": 0.00131, "epss_percentile": 0.33372}, "CVE-2023-39510": {"epss_score": 0.0045, "epss_percentile": 0.63094}, "CVE-2023-39511": {"epss_score": 0.00512, "epss_percentile": 0.65853}, "CVE-2023-39512": {"epss_score": 0.0045, "epss_percentile": 0.63094}, "CVE-2023-39513": {"epss_score": 0.00234, "epss_percentile": 0.46076}, "CVE-2023-39514": {"epss_score": 0.00292, "epss_percentile": 0.5226}, "CVE-2023-39515": {"epss_score": 0.00235, "epss_percentile": 0.46242}, "CVE-2023-39516": {"epss_score": 0.00259, "epss_percentile": 0.49045}, "CVE-2023-39517": {"epss_score": 0.00617, "epss_percentile": 0.69362}, "CVE-2023-39518": {"epss_score": 0.0093, "epss_percentile": 0.75605}, "CVE-2023-39519": {"epss_score": 0.00064, "epss_percentile": 0.20421}, "CVE-2023-39520": {"epss_score": 0.0003, "epss_percentile": 0.08245}, "CVE-2023-39521": {"epss_score": 0.00263, "epss_percentile": 0.49515}, "CVE-2023-39522": {"epss_score": 0.00672, "epss_percentile": 0.70813}, "CVE-2023-39523": {"epss_score": 0.01685, "epss_percentile": 0.81748}, "CVE-2023-39524": {"epss_score": 0.00301, "epss_percentile": 0.52994}, "CVE-2023-39525": {"epss_score": 0.01046, "epss_percentile": 0.77026}, "CVE-2023-39526": {"epss_score": 0.09741, "epss_percentile": 0.92687}, "CVE-2023-39527": {"epss_score": 0.01344, "epss_percentile": 0.79619}, "CVE-2023-39528": {"epss_score": 0.00516, "epss_percentile": 0.66052}, "CVE-2023-39529": {"epss_score": 0.00615, "epss_percentile": 0.69298}, "CVE-2023-39530": {"epss_score": 0.00666, "epss_percentile": 0.70686}, "CVE-2023-39531": {"epss_score": 0.00115, "epss_percentile": 0.30946}, "CVE-2023-39532": {"epss_score": 0.01355, "epss_percentile": 0.79707}, "CVE-2023-39533": {"epss_score": 0.0011, "epss_percentile": 0.3021}, "CVE-2023-39534": {"epss_score": 0.00088, "epss_percentile": 0.2565}, "CVE-2023-39535": {"epss_score": 0.00066, "epss_percentile": 0.20703}, "CVE-2023-39536": {"epss_score": 0.00056, "epss_percentile": 0.17916}, "CVE-2023-39537": {"epss_score": 0.00066, "epss_percentile": 0.20703}, "CVE-2023-39538": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2023-39539": {"epss_score": 0.00338, "epss_percentile": 0.56115}, "CVE-2023-39540": {"epss_score": 0.00385, "epss_percentile": 0.59219}, "CVE-2023-39541": {"epss_score": 0.00385, "epss_percentile": 0.59219}, "CVE-2023-39542": {"epss_score": 0.00109, "epss_percentile": 0.29986}, "CVE-2023-39543": {"epss_score": 0.00266, "epss_percentile": 0.49898}, "CVE-2023-39544": {"epss_score": 0.00069, "epss_percentile": 0.21618}, "CVE-2023-39545": {"epss_score": 0.00072, "epss_percentile": 0.22422}, "CVE-2023-39546": {"epss_score": 0.00069, "epss_percentile": 0.21618}, "CVE-2023-39547": {"epss_score": 0.00069, "epss_percentile": 0.21618}, "CVE-2023-39548": {"epss_score": 0.00098, "epss_percentile": 0.27784}, "CVE-2023-39549": {"epss_score": 0.00093, "epss_percentile": 0.2673}, "CVE-2023-39550": {"epss_score": 0.00348, "epss_percentile": 0.56798}, "CVE-2023-39551": {"epss_score": 0.00638, "epss_percentile": 0.69903}, "CVE-2023-39553": {"epss_score": 0.01897, "epss_percentile": 0.82756}, "CVE-2023-39558": {"epss_score": 0.00089, "epss_percentile": 0.25867}, "CVE-2023-39559": {"epss_score": 0.00085, "epss_percentile": 0.25153}, "CVE-2023-39560": {"epss_score": 0.60798, "epss_percentile": 0.98222}, "CVE-2023-39562": {"epss_score": 0.0002, "epss_percentile": 0.0452}, "CVE-2023-39575": {"epss_score": 0.0021, "epss_percentile": 0.43493}, "CVE-2023-39578": {"epss_score": 0.01426, "epss_percentile": 0.80204}, "CVE-2023-39582": {"epss_score": 0.00111, "epss_percentile": 0.30406}, "CVE-2023-39584": {"epss_score": 0.04095, "epss_percentile": 0.88248}, "CVE-2023-39593": {"epss_score": 0.00431, "epss_percentile": 0.62093}, "CVE-2023-39598": {"epss_score": 0.56383, "epss_percentile": 0.9802}, "CVE-2023-39599": {"epss_score": 0.00236, "epss_percentile": 0.4643}, "CVE-2023-39600": {"epss_score": 0.03219, "epss_percentile": 0.86667}, "CVE-2023-39610": {"epss_score": 0.00068, "epss_percentile": 0.21354}, "CVE-2023-39611": {"epss_score": 0.00105, "epss_percentile": 0.29361}, "CVE-2023-39612": {"epss_score": 0.00125, "epss_percentile": 0.32596}, "CVE-2023-39615": {"epss_score": 0.00112, "epss_percentile": 0.30526}, "CVE-2023-39616": {"epss_score": 0.00068, "epss_percentile": 0.2124}, "CVE-2023-39617": {"epss_score": 0.06028, "epss_percentile": 0.9042}, "CVE-2023-39618": {"epss_score": 0.06028, "epss_percentile": 0.9042}, "CVE-2023-39619": {"epss_score": 0.00167, "epss_percentile": 0.38379}, "CVE-2023-39620": {"epss_score": 0.00066, "epss_percentile": 0.20681}, "CVE-2023-39631": {"epss_score": 0.02868, "epss_percentile": 0.85866}, "CVE-2023-39637": {"epss_score": 0.00957, "epss_percentile": 0.75935}, "CVE-2023-39638": {"epss_score": 0.02388, "epss_percentile": 0.84587}, "CVE-2023-39639": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2023-39640": {"epss_score": 0.00272, "epss_percentile": 0.50392}, "CVE-2023-39641": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2023-39642": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2023-39643": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2023-39645": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-39646": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-39647": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-39648": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-39649": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-39650": {"epss_score": 0.28918, "epss_percentile": 0.964}, "CVE-2023-39651": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-39652": {"epss_score": 0.00072, "epss_percentile": 0.223}, "CVE-2023-39654": {"epss_score": 0.00103, "epss_percentile": 0.29051}, "CVE-2023-39655": {"epss_score": 0.00104, "epss_percentile": 0.29126}, "CVE-2023-39659": {"epss_score": 0.01201, "epss_percentile": 0.78479}, "CVE-2023-39660": {"epss_score": 0.0063, "epss_percentile": 0.6969}, "CVE-2023-39661": {"epss_score": 0.01361, "epss_percentile": 0.79752}, "CVE-2023-39662": {"epss_score": 0.02855, "epss_percentile": 0.85837}, "CVE-2023-39663": {"epss_score": 0.00188, "epss_percentile": 0.40854}, "CVE-2023-39665": {"epss_score": 0.0026, "epss_percentile": 0.49173}, "CVE-2023-39666": {"epss_score": 0.00608, "epss_percentile": 0.69076}, "CVE-2023-39667": {"epss_score": 0.0026, "epss_percentile": 0.49173}, "CVE-2023-39668": {"epss_score": 0.0026, "epss_percentile": 0.49173}, "CVE-2023-39669": {"epss_score": 0.0036, "epss_percentile": 0.57664}, "CVE-2023-39670": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-39671": {"epss_score": 0.00717, "epss_percentile": 0.71884}, "CVE-2023-39672": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-39673": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-39674": {"epss_score": 0.00717, "epss_percentile": 0.71884}, "CVE-2023-39675": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-39676": {"epss_score": 0.06128, "epss_percentile": 0.90499}, "CVE-2023-39677": {"epss_score": 0.8045, "epss_percentile": 0.99089}, "CVE-2023-39678": {"epss_score": 0.00083, "epss_percentile": 0.24721}, "CVE-2023-39680": {"epss_score": 0.00098, "epss_percentile": 0.2782}, "CVE-2023-39681": {"epss_score": 0.04417, "epss_percentile": 0.88666}, "CVE-2023-39683": {"epss_score": 0.00101, "epss_percentile": 0.28596}, "CVE-2023-39685": {"epss_score": 0.00278, "epss_percentile": 0.50902}, "CVE-2023-39691": {"epss_score": 0.00312, "epss_percentile": 0.53969}, "CVE-2023-39695": {"epss_score": 0.00058, "epss_percentile": 0.18391}, "CVE-2023-39699": {"epss_score": 0.00537, "epss_percentile": 0.66893}, "CVE-2023-39700": {"epss_score": 0.10602, "epss_percentile": 0.93043}, "CVE-2023-39703": {"epss_score": 0.00093, "epss_percentile": 0.26605}, "CVE-2023-39707": {"epss_score": 0.00192, "epss_percentile": 0.41361}, "CVE-2023-39708": {"epss_score": 0.00125, "epss_percentile": 0.3257}, "CVE-2023-39709": {"epss_score": 0.0015, "epss_percentile": 0.36151}, "CVE-2023-39710": {"epss_score": 0.00136, "epss_percentile": 0.34124}, "CVE-2023-39711": {"epss_score": 0.00115, "epss_percentile": 0.30971}, "CVE-2023-39712": {"epss_score": 0.00272, "epss_percentile": 0.50359}, "CVE-2023-39714": {"epss_score": 0.00125, "epss_percentile": 0.3257}, "CVE-2023-39726": {"epss_score": 0.01589, "epss_percentile": 0.81195}, "CVE-2023-39731": {"epss_score": 0.00188, "epss_percentile": 0.40895}, "CVE-2023-39732": {"epss_score": 0.00186, "epss_percentile": 0.40631}, "CVE-2023-39733": {"epss_score": 0.00195, "epss_percentile": 0.41707}, "CVE-2023-39734": {"epss_score": 0.00375, "epss_percentile": 0.58623}, "CVE-2023-39735": {"epss_score": 0.00214, "epss_percentile": 0.4398}, "CVE-2023-39736": {"epss_score": 0.00214, "epss_percentile": 0.4398}, "CVE-2023-39737": {"epss_score": 0.00214, "epss_percentile": 0.4398}, "CVE-2023-39739": {"epss_score": 0.00214, "epss_percentile": 0.4398}, "CVE-2023-39740": {"epss_score": 0.00186, "epss_percentile": 0.40631}, "CVE-2023-39741": {"epss_score": 0.0003, "epss_percentile": 0.08294}, "CVE-2023-39742": {"epss_score": 0.00019, "epss_percentile": 0.04157}, "CVE-2023-39743": {"epss_score": 0.00038, "epss_percentile": 0.1121}, "CVE-2023-39745": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-39747": {"epss_score": 0.11596, "epss_percentile": 0.93415}, "CVE-2023-39748": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-39749": {"epss_score": 0.01914, "epss_percentile": 0.82849}, "CVE-2023-39750": {"epss_score": 0.55358, "epss_percentile": 0.97974}, "CVE-2023-39751": {"epss_score": 0.11596, "epss_percentile": 0.93415}, "CVE-2023-39776": {"epss_score": 0.00115, "epss_percentile": 0.30945}, "CVE-2023-39777": {"epss_score": 0.00147, "epss_percentile": 0.35711}, "CVE-2023-39780": {"epss_score": 0.44173, "epss_percentile": 0.97422}, "CVE-2023-39784": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-39785": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-39786": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-39796": {"epss_score": 0.77185, "epss_percentile": 0.98925}, "CVE-2023-39801": {"epss_score": 0.00033, "epss_percentile": 0.09157}, "CVE-2023-39804": {"epss_score": 0.00067, "epss_percentile": 0.20969}, "CVE-2023-39805": {"epss_score": 0.00073, "epss_percentile": 0.22583}, "CVE-2023-39806": {"epss_score": 0.00073, "epss_percentile": 0.22583}, "CVE-2023-39807": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-39808": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2023-39809": {"epss_score": 0.00515, "epss_percentile": 0.66007}, "CVE-2023-39810": {"epss_score": 0.00092, "epss_percentile": 0.26568}, "CVE-2023-39827": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-39828": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-39829": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-39834": {"epss_score": 0.00729, "epss_percentile": 0.72128}, "CVE-2023-39841": {"epss_score": 0.00013, "epss_percentile": 0.01561}, "CVE-2023-39842": {"epss_score": 0.00013, "epss_percentile": 0.01561}, "CVE-2023-39843": {"epss_score": 0.00013, "epss_percentile": 0.01561}, "CVE-2023-39846": {"epss_score": 0.00173, "epss_percentile": 0.39118}, "CVE-2023-39850": {"epss_score": 0.00183, "epss_percentile": 0.40283}, "CVE-2023-39851": {"epss_score": 0.00277, "epss_percentile": 0.50775}, "CVE-2023-39852": {"epss_score": 0.0078, "epss_percentile": 0.73171}, "CVE-2023-39853": {"epss_score": 0.00165, "epss_percentile": 0.38132}, "CVE-2023-39854": {"epss_score": 0.00063, "epss_percentile": 0.19926}, "CVE-2023-39902": {"epss_score": 0.00099, "epss_percentile": 0.28416}, "CVE-2023-39903": {"epss_score": 0.00033, "epss_percentile": 0.09215}, "CVE-2023-39908": {"epss_score": 0.00207, "epss_percentile": 0.43139}, "CVE-2023-39909": {"epss_score": 0.00203, "epss_percentile": 0.42559}, "CVE-2023-39910": {"epss_score": 0.0014, "epss_percentile": 0.34699}, "CVE-2023-39912": {"epss_score": 0.00815, "epss_percentile": 0.73785}, "CVE-2023-39913": {"epss_score": 0.00542, "epss_percentile": 0.67086}, "CVE-2023-39914": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-39915": {"epss_score": 0.00346, "epss_percentile": 0.56709}, "CVE-2023-39916": {"epss_score": 0.0015, "epss_percentile": 0.36091}, "CVE-2023-39917": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-39918": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-39919": {"epss_score": 0.00063, "epss_percentile": 0.19871}, "CVE-2023-39920": {"epss_score": 0.00359, "epss_percentile": 0.57598}, "CVE-2023-39921": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-39922": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2023-39923": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-39924": {"epss_score": 0.00126, "epss_percentile": 0.32739}, "CVE-2023-39925": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-39926": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-39928": {"epss_score": 0.0019, "epss_percentile": 0.41077}, "CVE-2023-39929": {"epss_score": 0.00022, "epss_percentile": 0.0499}, "CVE-2023-39930": {"epss_score": 0.00043, "epss_percentile": 0.13071}, "CVE-2023-39932": {"epss_score": 0.00105, "epss_percentile": 0.29318}, "CVE-2023-39933": {"epss_score": 0.00145, "epss_percentile": 0.35353}, "CVE-2023-39935": {"epss_score": 0.00078, "epss_percentile": 0.23667}, "CVE-2023-39936": {"epss_score": 0.00131, "epss_percentile": 0.33458}, "CVE-2023-39938": {"epss_score": 0.004, "epss_percentile": 0.60172}, "CVE-2023-39939": {"epss_score": 0.00179, "epss_percentile": 0.3985}, "CVE-2023-39941": {"epss_score": 0.00132, "epss_percentile": 0.33528}, "CVE-2023-39943": {"epss_score": 0.00037, "epss_percentile": 0.1084}, "CVE-2023-39944": {"epss_score": 0.0132, "epss_percentile": 0.79441}, "CVE-2023-39945": {"epss_score": 0.00086, "epss_percentile": 0.25362}, "CVE-2023-39946": {"epss_score": 0.00085, "epss_percentile": 0.25181}, "CVE-2023-39947": {"epss_score": 0.00105, "epss_percentile": 0.29317}, "CVE-2023-39948": {"epss_score": 0.00123, "epss_percentile": 0.32263}, "CVE-2023-39949": {"epss_score": 0.00086, "epss_percentile": 0.25366}, "CVE-2023-39950": {"epss_score": 0.00067, "epss_percentile": 0.21122}, "CVE-2023-39951": {"epss_score": 0.00185, "epss_percentile": 0.40514}, "CVE-2023-39952": {"epss_score": 0.00234, "epss_percentile": 0.46118}, "CVE-2023-39953": {"epss_score": 0.0049, "epss_percentile": 0.64925}, "CVE-2023-39954": {"epss_score": 0.00374, "epss_percentile": 0.58545}, "CVE-2023-39955": {"epss_score": 0.00705, "epss_percentile": 0.71574}, "CVE-2023-39956": {"epss_score": 0.00027, "epss_percentile": 0.06951}, "CVE-2023-39957": {"epss_score": 0.00374, "epss_percentile": 0.58578}, "CVE-2023-39958": {"epss_score": 0.00353, "epss_percentile": 0.57143}, "CVE-2023-39959": {"epss_score": 0.0066, "epss_percentile": 0.70526}, "CVE-2023-39960": {"epss_score": 0.00239, "epss_percentile": 0.46919}, "CVE-2023-39961": {"epss_score": 0.00252, "epss_percentile": 0.48376}, "CVE-2023-39962": {"epss_score": 0.00239, "epss_percentile": 0.46897}, "CVE-2023-39963": {"epss_score": 0.00137, "epss_percentile": 0.34221}, "CVE-2023-39964": {"epss_score": 0.00236, "epss_percentile": 0.46351}, "CVE-2023-39965": {"epss_score": 0.00088, "epss_percentile": 0.2573}, "CVE-2023-39966": {"epss_score": 0.00185, "epss_percentile": 0.40474}, "CVE-2023-39967": {"epss_score": 0.00695, "epss_percentile": 0.71374}, "CVE-2023-39968": {"epss_score": 0.00421, "epss_percentile": 0.61525}, "CVE-2023-39969": {"epss_score": 0.00095, "epss_percentile": 0.27219}, "CVE-2023-39970": {"epss_score": 0.01506, "epss_percentile": 0.80745}, "CVE-2023-39971": {"epss_score": 0.0032, "epss_percentile": 0.54635}, "CVE-2023-39972": {"epss_score": 0.00102, "epss_percentile": 0.28743}, "CVE-2023-39973": {"epss_score": 0.00102, "epss_percentile": 0.28743}, "CVE-2023-39974": {"epss_score": 0.00162, "epss_percentile": 0.37664}, "CVE-2023-39975": {"epss_score": 0.00905, "epss_percentile": 0.75242}, "CVE-2023-39976": {"epss_score": 0.00167, "epss_percentile": 0.38389}, "CVE-2023-39978": {"epss_score": 0.00035, "epss_percentile": 0.09875}, "CVE-2023-39979": {"epss_score": 0.00268, "epss_percentile": 0.5007}, "CVE-2023-39980": {"epss_score": 0.0042, "epss_percentile": 0.61454}, "CVE-2023-39981": {"epss_score": 0.00225, "epss_percentile": 0.4513}, "CVE-2023-39982": {"epss_score": 0.00151, "epss_percentile": 0.3619}, "CVE-2023-39983": {"epss_score": 0.00358, "epss_percentile": 0.57503}, "CVE-2023-39984": {"epss_score": 0.00051, "epss_percentile": 0.16262}, "CVE-2023-39985": {"epss_score": 0.00051, "epss_percentile": 0.16262}, "CVE-2023-39986": {"epss_score": 0.00047, "epss_percentile": 0.14831}, "CVE-2023-39987": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-39988": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-39989": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-39990": {"epss_score": 0.00215, "epss_percentile": 0.44096}, "CVE-2023-39991": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-39992": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-39993": {"epss_score": 0.00113, "epss_percentile": 0.306}, "CVE-2023-39994": {"epss_score": 0.0013, "epss_percentile": 0.33331}, "CVE-2023-39995": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-39996": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-39997": {"epss_score": 0.00327, "epss_percentile": 0.55122}, "CVE-2023-39998": {"epss_score": 0.00167, "epss_percentile": 0.38338}, "CVE-2023-39999": {"epss_score": 0.00895, "epss_percentile": 0.75103}, "CVE-2023-3000": {"epss_score": 0.00024, "epss_percentile": 0.05799}, "CVE-2023-3001": {"epss_score": 0.04053, "epss_percentile": 0.88179}, "CVE-2023-3003": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2023-3004": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-3005": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-3006": {"epss_score": 0.00014, "epss_percentile": 0.0206}, "CVE-2023-3007": {"epss_score": 0.00097, "epss_percentile": 0.27575}, "CVE-2023-3008": {"epss_score": 0.00123, "epss_percentile": 0.32288}, "CVE-2023-3009": {"epss_score": 0.01494, "epss_percentile": 0.80651}, "CVE-2023-3010": {"epss_score": 0.00644, "epss_percentile": 0.70092}, "CVE-2023-3011": {"epss_score": 0.00067, "epss_percentile": 0.21145}, "CVE-2023-3012": {"epss_score": 0.0003, "epss_percentile": 0.08306}, "CVE-2023-3013": {"epss_score": 0.00021, "epss_percentile": 0.04897}, "CVE-2023-3014": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-3015": {"epss_score": 0.00057, "epss_percentile": 0.18215}, "CVE-2023-3016": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-3017": {"epss_score": 0.00069, "epss_percentile": 0.21582}, "CVE-2023-3018": {"epss_score": 0.00058, "epss_percentile": 0.18295}, "CVE-2023-3019": {"epss_score": 0.00012, "epss_percentile": 0.01154}, "CVE-2023-3020": {"epss_score": 0.00087, "epss_percentile": 0.25567}, "CVE-2023-3021": {"epss_score": 0.00044, "epss_percentile": 0.13422}, "CVE-2023-3022": {"epss_score": 0.00016, "epss_percentile": 0.02749}, "CVE-2023-3023": {"epss_score": 0.00205, "epss_percentile": 0.42698}, "CVE-2023-3024": {"epss_score": 0.0008, "epss_percentile": 0.24147}, "CVE-2023-3025": {"epss_score": 0.00252, "epss_percentile": 0.48409}, "CVE-2023-3026": {"epss_score": 0.00136, "epss_percentile": 0.34124}, "CVE-2023-3027": {"epss_score": 0.00034, "epss_percentile": 0.09585}, "CVE-2023-3028": {"epss_score": 0.00028, "epss_percentile": 0.07295}, "CVE-2023-3029": {"epss_score": 0.00061, "epss_percentile": 0.19487}, "CVE-2023-3031": {"epss_score": 0.0008, "epss_percentile": 0.2418}, "CVE-2023-3032": {"epss_score": 0.00066, "epss_percentile": 0.20885}, "CVE-2023-3033": {"epss_score": 0.00072, "epss_percentile": 0.22369}, "CVE-2023-3034": {"epss_score": 0.0007, "epss_percentile": 0.21933}, "CVE-2023-3035": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3036": {"epss_score": 0.0047, "epss_percentile": 0.63987}, "CVE-2023-3037": {"epss_score": 0.00312, "epss_percentile": 0.54}, "CVE-2023-3038": {"epss_score": 0.00058, "epss_percentile": 0.18513}, "CVE-2023-3039": {"epss_score": 0.0005, "epss_percentile": 0.15869}, "CVE-2023-3040": {"epss_score": 0.00103, "epss_percentile": 0.28989}, "CVE-2023-3041": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2023-3042": {"epss_score": 0.00177, "epss_percentile": 0.39543}, "CVE-2023-3043": {"epss_score": 0.00037, "epss_percentile": 0.10917}, "CVE-2023-3044": {"epss_score": 0.00036, "epss_percentile": 0.10502}, "CVE-2023-3045": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-3046": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-3047": {"epss_score": 0.07116, "epss_percentile": 0.9126}, "CVE-2023-3048": {"epss_score": 0.0004, "epss_percentile": 0.11891}, "CVE-2023-3049": {"epss_score": 0.01413, "epss_percentile": 0.80121}, "CVE-2023-3050": {"epss_score": 0.00033, "epss_percentile": 0.09132}, "CVE-2023-3051": {"epss_score": 0.00122, "epss_percentile": 0.32108}, "CVE-2023-3052": {"epss_score": 0.00137, "epss_percentile": 0.34269}, "CVE-2023-3053": {"epss_score": 0.00052, "epss_percentile": 0.16477}, "CVE-2023-3055": {"epss_score": 0.0006, "epss_percentile": 0.18966}, "CVE-2023-3056": {"epss_score": 0.00155, "epss_percentile": 0.36788}, "CVE-2023-3057": {"epss_score": 0.00155, "epss_percentile": 0.36788}, "CVE-2023-3058": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3059": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-3060": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3061": {"epss_score": 0.00079, "epss_percentile": 0.23812}, "CVE-2023-3062": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3063": {"epss_score": 0.00056, "epss_percentile": 0.17747}, "CVE-2023-3064": {"epss_score": 0.00088, "epss_percentile": 0.25733}, "CVE-2023-3065": {"epss_score": 0.00051, "epss_percentile": 0.16124}, "CVE-2023-3066": {"epss_score": 0.00069, "epss_percentile": 0.21507}, "CVE-2023-3067": {"epss_score": 0.00055, "epss_percentile": 0.17642}, "CVE-2023-3068": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3069": {"epss_score": 0.00078, "epss_percentile": 0.23749}, "CVE-2023-3070": {"epss_score": 0.00096, "epss_percentile": 0.27451}, "CVE-2023-3071": {"epss_score": 0.00066, "epss_percentile": 0.20806}, "CVE-2023-3072": {"epss_score": 0.00042, "epss_percentile": 0.12731}, "CVE-2023-3073": {"epss_score": 0.0006, "epss_percentile": 0.18967}, "CVE-2023-3074": {"epss_score": 0.00062, "epss_percentile": 0.19787}, "CVE-2023-3075": {"epss_score": 0.00054, "epss_percentile": 0.17132}, "CVE-2023-3076": {"epss_score": 0.2672, "epss_percentile": 0.96169}, "CVE-2023-3077": {"epss_score": 0.40251, "epss_percentile": 0.97208}, "CVE-2023-3078": {"epss_score": 0.00038, "epss_percentile": 0.11416}, "CVE-2023-3079": {"epss_score": 0.01123, "epss_percentile": 0.77788}, "CVE-2023-3080": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-3081": {"epss_score": 0.00656, "epss_percentile": 0.70443}, "CVE-2023-3082": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-3083": {"epss_score": 0.00101, "epss_percentile": 0.28627}, "CVE-2023-3084": {"epss_score": 0.00438, "epss_percentile": 0.62568}, "CVE-2023-3085": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-3086": {"epss_score": 0.00464, "epss_percentile": 0.63709}, "CVE-2023-3087": {"epss_score": 0.00656, "epss_percentile": 0.70443}, "CVE-2023-3088": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-3089": {"epss_score": 0.00053, "epss_percentile": 0.16736}, "CVE-2023-3090": {"epss_score": 0.00012, "epss_percentile": 0.01325}, "CVE-2023-3091": {"epss_score": 0.00031, "epss_percentile": 0.08641}, "CVE-2023-3092": {"epss_score": 0.01157, "epss_percentile": 0.78113}, "CVE-2023-3093": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-3094": {"epss_score": 0.00057, "epss_percentile": 0.1821}, "CVE-2023-3095": {"epss_score": 0.00042, "epss_percentile": 0.12653}, "CVE-2023-3096": {"epss_score": 0.0003, "epss_percentile": 0.08142}, "CVE-2023-3097": {"epss_score": 0.00194, "epss_percentile": 0.41576}, "CVE-2023-3098": {"epss_score": 0.00037, "epss_percentile": 0.10721}, "CVE-2023-3099": {"epss_score": 0.00057, "epss_percentile": 0.18107}, "CVE-2023-3100": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3102": {"epss_score": 0.0037, "epss_percentile": 0.58336}, "CVE-2023-3103": {"epss_score": 0.00029, "epss_percentile": 0.0759}, "CVE-2023-3104": {"epss_score": 0.00209, "epss_percentile": 0.43424}, "CVE-2023-3105": {"epss_score": 0.00051, "epss_percentile": 0.16327}, "CVE-2023-3106": {"epss_score": 0.00012, "epss_percentile": 0.01259}, "CVE-2023-3107": {"epss_score": 0.00211, "epss_percentile": 0.43632}, "CVE-2023-3108": {"epss_score": 0.00013, "epss_percentile": 0.01591}, "CVE-2023-3109": {"epss_score": 0.0006, "epss_percentile": 0.18967}, "CVE-2023-3110": {"epss_score": 0.00047, "epss_percentile": 0.14625}, "CVE-2023-3111": {"epss_score": 0.00013, "epss_percentile": 0.01665}, "CVE-2023-3112": {"epss_score": 0.00059, "epss_percentile": 0.18867}, "CVE-2023-3113": {"epss_score": 0.00105, "epss_percentile": 0.29326}, "CVE-2023-3114": {"epss_score": 0.00158, "epss_percentile": 0.37146}, "CVE-2023-3115": {"epss_score": 0.00038, "epss_percentile": 0.11107}, "CVE-2023-3116": {"epss_score": 0.00021, "epss_percentile": 0.04755}, "CVE-2023-3118": {"epss_score": 0.00136, "epss_percentile": 0.34099}, "CVE-2023-3119": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3120": {"epss_score": 0.00057, "epss_percentile": 0.18159}, "CVE-2023-3121": {"epss_score": 0.00036, "epss_percentile": 0.10296}, "CVE-2023-3122": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-3124": {"epss_score": 0.26009, "epss_percentile": 0.96099}, "CVE-2023-3125": {"epss_score": 0.00077, "epss_percentile": 0.23552}, "CVE-2023-3126": {"epss_score": 0.00103, "epss_percentile": 0.28979}, "CVE-2023-3127": {"epss_score": 0.00137, "epss_percentile": 0.34224}, "CVE-2023-3128": {"epss_score": 0.01879, "epss_percentile": 0.82672}, "CVE-2023-3129": {"epss_score": 0.00255, "epss_percentile": 0.48653}, "CVE-2023-3130": {"epss_score": 0.00113, "epss_percentile": 0.30718}, "CVE-2023-3131": {"epss_score": 0.0025, "epss_percentile": 0.48127}, "CVE-2023-3132": {"epss_score": 0.0042, "epss_percentile": 0.61404}, "CVE-2023-3133": {"epss_score": 0.01147, "epss_percentile": 0.78003}, "CVE-2023-3134": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-3135": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-3136": {"epss_score": 0.00601, "epss_percentile": 0.68846}, "CVE-2023-3138": {"epss_score": 0.0011, "epss_percentile": 0.30237}, "CVE-2023-3139": {"epss_score": 0.03912, "epss_percentile": 0.87936}, "CVE-2023-3140": {"epss_score": 0.0012, "epss_percentile": 0.31807}, "CVE-2023-3141": {"epss_score": 7e-05, "epss_percentile": 0.0044}, "CVE-2023-3142": {"epss_score": 0.00053, "epss_percentile": 0.16984}, "CVE-2023-3143": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-3144": {"epss_score": 0.00075, "epss_percentile": 0.22908}, "CVE-2023-3145": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2023-3146": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2023-3147": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-3148": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-3149": {"epss_score": 0.00132, "epss_percentile": 0.33542}, "CVE-2023-3150": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2023-3151": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-3152": {"epss_score": 0.00043, "epss_percentile": 0.13264}, "CVE-2023-3153": {"epss_score": 0.00069, "epss_percentile": 0.21545}, "CVE-2023-3154": {"epss_score": 0.00459, "epss_percentile": 0.6345}, "CVE-2023-3155": {"epss_score": 0.00342, "epss_percentile": 0.5635}, "CVE-2023-3158": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-3159": {"epss_score": 0.00012, "epss_percentile": 0.01158}, "CVE-2023-3160": {"epss_score": 0.00044, "epss_percentile": 0.13517}, "CVE-2023-3161": {"epss_score": 0.00013, "epss_percentile": 0.01437}, "CVE-2023-3162": {"epss_score": 0.00271, "epss_percentile": 0.50326}, "CVE-2023-3163": {"epss_score": 0.00412, "epss_percentile": 0.60949}, "CVE-2023-3164": {"epss_score": 0.0001, "epss_percentile": 0.00863}, "CVE-2023-3165": {"epss_score": 0.00098, "epss_percentile": 0.27652}, "CVE-2023-3166": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-3167": {"epss_score": 0.00294, "epss_percentile": 0.52402}, "CVE-2023-3168": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-3169": {"epss_score": 0.36625, "epss_percentile": 0.96991}, "CVE-2023-3170": {"epss_score": 0.00126, "epss_percentile": 0.32641}, "CVE-2023-3171": {"epss_score": 0.0018, "epss_percentile": 0.39934}, "CVE-2023-3172": {"epss_score": 0.00247, "epss_percentile": 0.47843}, "CVE-2023-3173": {"epss_score": 0.00103, "epss_percentile": 0.29008}, "CVE-2023-3175": {"epss_score": 0.00132, "epss_percentile": 0.33524}, "CVE-2023-3176": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-3177": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-3178": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2023-3179": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-3180": {"epss_score": 0.00012, "epss_percentile": 0.0135}, "CVE-2023-3181": {"epss_score": 0.00025, "epss_percentile": 0.06323}, "CVE-2023-3182": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-3183": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2023-3184": {"epss_score": 0.00927, "epss_percentile": 0.75569}, "CVE-2023-3186": {"epss_score": 0.04883, "epss_percentile": 0.89251}, "CVE-2023-3187": {"epss_score": 0.00456, "epss_percentile": 0.63335}, "CVE-2023-3188": {"epss_score": 0.48696, "epss_percentile": 0.9765}, "CVE-2023-3189": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3190": {"epss_score": 0.00087, "epss_percentile": 0.2563}, "CVE-2023-3191": {"epss_score": 0.00101, "epss_percentile": 0.28633}, "CVE-2023-3192": {"epss_score": 0.00146, "epss_percentile": 0.3559}, "CVE-2023-3193": {"epss_score": 0.00178, "epss_percentile": 0.39692}, "CVE-2023-3195": {"epss_score": 0.00019, "epss_percentile": 0.04101}, "CVE-2023-3196": {"epss_score": 0.0005, "epss_percentile": 0.1584}, "CVE-2023-3197": {"epss_score": 0.00481, "epss_percentile": 0.64486}, "CVE-2023-3198": {"epss_score": 0.00099, "epss_percentile": 0.27837}, "CVE-2023-3199": {"epss_score": 0.00099, "epss_percentile": 0.27837}, "CVE-2023-3200": {"epss_score": 0.00067, "epss_percentile": 0.21019}, "CVE-2023-3201": {"epss_score": 0.00067, "epss_percentile": 0.21019}, "CVE-2023-3202": {"epss_score": 0.00067, "epss_percentile": 0.21019}, "CVE-2023-3203": {"epss_score": 0.00082, "epss_percentile": 0.24415}, "CVE-2023-3204": {"epss_score": 0.00214, "epss_percentile": 0.44004}, "CVE-2023-3205": {"epss_score": 0.0057, "epss_percentile": 0.67952}, "CVE-2023-3206": {"epss_score": 0.02688, "epss_percentile": 0.85432}, "CVE-2023-3208": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3209": {"epss_score": 0.00056, "epss_percentile": 0.17708}, "CVE-2023-3210": {"epss_score": 0.00406, "epss_percentile": 0.60523}, "CVE-2023-3211": {"epss_score": 0.00604, "epss_percentile": 0.68942}, "CVE-2023-3212": {"epss_score": 0.00021, "epss_percentile": 0.04691}, "CVE-2023-3213": {"epss_score": 0.00291, "epss_percentile": 0.52201}, "CVE-2023-3214": {"epss_score": 0.01524, "epss_percentile": 0.80853}, "CVE-2023-3215": {"epss_score": 0.19982, "epss_percentile": 0.9527}, "CVE-2023-3216": {"epss_score": 0.0076, "epss_percentile": 0.72816}, "CVE-2023-3217": {"epss_score": 0.16587, "epss_percentile": 0.94698}, "CVE-2023-3218": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2023-3219": {"epss_score": 0.75972, "epss_percentile": 0.98872}, "CVE-2023-3220": {"epss_score": 0.00011, "epss_percentile": 0.01004}, "CVE-2023-3221": {"epss_score": 0.00077, "epss_percentile": 0.23354}, "CVE-2023-3222": {"epss_score": 0.00064, "epss_percentile": 0.20385}, "CVE-2023-3223": {"epss_score": 0.00879, "epss_percentile": 0.74849}, "CVE-2023-3224": {"epss_score": 0.01931, "epss_percentile": 0.8294}, "CVE-2023-3225": {"epss_score": 0.00255, "epss_percentile": 0.48653}, "CVE-2023-3226": {"epss_score": 0.00171, "epss_percentile": 0.38784}, "CVE-2023-3227": {"epss_score": 0.00047, "epss_percentile": 0.14772}, "CVE-2023-3228": {"epss_score": 0.00077, "epss_percentile": 0.23525}, "CVE-2023-3229": {"epss_score": 0.00057, "epss_percentile": 0.18096}, "CVE-2023-3230": {"epss_score": 0.00047, "epss_percentile": 0.14826}, "CVE-2023-3231": {"epss_score": 0.00279, "epss_percentile": 0.50953}, "CVE-2023-3232": {"epss_score": 0.00076, "epss_percentile": 0.23143}, "CVE-2023-3233": {"epss_score": 0.00058, "epss_percentile": 0.18295}, "CVE-2023-3234": {"epss_score": 0.00097, "epss_percentile": 0.27501}, "CVE-2023-3235": {"epss_score": 0.00057, "epss_percentile": 0.1798}, "CVE-2023-3236": {"epss_score": 0.00057, "epss_percentile": 0.1798}, "CVE-2023-3237": {"epss_score": 0.00067, "epss_percentile": 0.21079}, "CVE-2023-3238": {"epss_score": 0.00065, "epss_percentile": 0.20506}, "CVE-2023-3239": {"epss_score": 0.00109, "epss_percentile": 0.29956}, "CVE-2023-3240": {"epss_score": 0.00109, "epss_percentile": 0.29956}, "CVE-2023-3241": {"epss_score": 0.00109, "epss_percentile": 0.29956}, "CVE-2023-3242": {"epss_score": 0.00285, "epss_percentile": 0.51685}, "CVE-2023-3243": {"epss_score": 0.00145, "epss_percentile": 0.35408}, "CVE-2023-3244": {"epss_score": 0.03303, "epss_percentile": 0.86868}, "CVE-2023-3245": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-3246": {"epss_score": 0.00048, "epss_percentile": 0.15188}, "CVE-2023-3247": {"epss_score": 0.00232, "epss_percentile": 0.45962}, "CVE-2023-3248": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-3249": {"epss_score": 0.00071, "epss_percentile": 0.22031}, "CVE-2023-3251": {"epss_score": 0.00157, "epss_percentile": 0.37139}, "CVE-2023-3252": {"epss_score": 0.00206, "epss_percentile": 0.42769}, "CVE-2023-3253": {"epss_score": 0.00206, "epss_percentile": 0.43043}, "CVE-2023-3254": {"epss_score": 0.00063, "epss_percentile": 0.19811}, "CVE-2023-3255": {"epss_score": 0.00127, "epss_percentile": 0.32911}, "CVE-2023-3256": {"epss_score": 0.00066, "epss_percentile": 0.20769}, "CVE-2023-3259": {"epss_score": 0.00154, "epss_percentile": 0.36715}, "CVE-2023-3260": {"epss_score": 0.00451, "epss_percentile": 0.63129}, "CVE-2023-3261": {"epss_score": 0.00194, "epss_percentile": 0.4159}, "CVE-2023-3262": {"epss_score": 0.00071, "epss_percentile": 0.22078}, "CVE-2023-3263": {"epss_score": 0.00074, "epss_percentile": 0.22702}, "CVE-2023-3264": {"epss_score": 0.00103, "epss_percentile": 0.2893}, "CVE-2023-3265": {"epss_score": 0.00195, "epss_percentile": 0.41627}, "CVE-2023-3266": {"epss_score": 0.00084, "epss_percentile": 0.25024}, "CVE-2023-3267": {"epss_score": 0.00232, "epss_percentile": 0.45941}, "CVE-2023-3268": {"epss_score": 6e-05, "epss_percentile": 0.0029}, "CVE-2023-3269": {"epss_score": 0.0022, "epss_percentile": 0.44559}, "CVE-2023-3270": {"epss_score": 0.00242, "epss_percentile": 0.47384}, "CVE-2023-3271": {"epss_score": 0.00176, "epss_percentile": 0.39411}, "CVE-2023-3272": {"epss_score": 0.00089, "epss_percentile": 0.25812}, "CVE-2023-3273": {"epss_score": 0.00557, "epss_percentile": 0.67546}, "CVE-2023-3274": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2023-3275": {"epss_score": 0.00045, "epss_percentile": 0.13713}, "CVE-2023-3276": {"epss_score": 0.00099, "epss_percentile": 0.2838}, "CVE-2023-3277": {"epss_score": 0.33706, "epss_percentile": 0.96799}, "CVE-2023-3279": {"epss_score": 0.00762, "epss_percentile": 0.72836}, "CVE-2023-3280": {"epss_score": 0.00068, "epss_percentile": 0.21239}, "CVE-2023-3282": {"epss_score": 0.00026, "epss_percentile": 0.0659}, "CVE-2023-3285": {"epss_score": 0.00154, "epss_percentile": 0.36676}, "CVE-2023-3286": {"epss_score": 0.00154, "epss_percentile": 0.36676}, "CVE-2023-3287": {"epss_score": 0.00231, "epss_percentile": 0.45836}, "CVE-2023-3288": {"epss_score": 0.00216, "epss_percentile": 0.44223}, "CVE-2023-3289": {"epss_score": 0.00154, "epss_percentile": 0.36676}, "CVE-2023-3290": {"epss_score": 0.00154, "epss_percentile": 0.36676}, "CVE-2023-3291": {"epss_score": 0.00085, "epss_percentile": 0.25235}, "CVE-2023-3292": {"epss_score": 0.00182, "epss_percentile": 0.40196}, "CVE-2023-3293": {"epss_score": 0.00068, "epss_percentile": 0.21319}, "CVE-2023-3294": {"epss_score": 0.00068, "epss_percentile": 0.21238}, "CVE-2023-3295": {"epss_score": 0.04654, "epss_percentile": 0.88967}, "CVE-2023-3297": {"epss_score": 0.00056, "epss_percentile": 0.17795}, "CVE-2023-3299": {"epss_score": 0.00257, "epss_percentile": 0.48848}, "CVE-2023-3300": {"epss_score": 0.00619, "epss_percentile": 0.69431}, "CVE-2023-3301": {"epss_score": 6e-05, "epss_percentile": 0.00296}, "CVE-2023-3302": {"epss_score": 0.00047, "epss_percentile": 0.14635}, "CVE-2023-3303": {"epss_score": 0.00061, "epss_percentile": 0.19388}, "CVE-2023-3304": {"epss_score": 0.00066, "epss_percentile": 0.2068}, "CVE-2023-3305": {"epss_score": 0.00054, "epss_percentile": 0.17322}, "CVE-2023-3306": {"epss_score": 0.53698, "epss_percentile": 0.97893}, "CVE-2023-3307": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-3308": {"epss_score": 0.00096, "epss_percentile": 0.2726}, "CVE-2023-3309": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2023-3310": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-3311": {"epss_score": 0.00069, "epss_percentile": 0.21582}, "CVE-2023-3312": {"epss_score": 0.00054, "epss_percentile": 0.17322}, "CVE-2023-3313": {"epss_score": 0.00182, "epss_percentile": 0.40192}, "CVE-2023-3314": {"epss_score": 0.00444, "epss_percentile": 0.62806}, "CVE-2023-3315": {"epss_score": 0.00176, "epss_percentile": 0.39465}, "CVE-2023-3316": {"epss_score": 0.00023, "epss_percentile": 0.0546}, "CVE-2023-3317": {"epss_score": 9e-05, "epss_percentile": 0.00625}, "CVE-2023-3318": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3319": {"epss_score": 0.00096, "epss_percentile": 0.27362}, "CVE-2023-3320": {"epss_score": 0.00982, "epss_percentile": 0.76298}, "CVE-2023-3321": {"epss_score": 0.00122, "epss_percentile": 0.32175}, "CVE-2023-3322": {"epss_score": 0.00106, "epss_percentile": 0.29495}, "CVE-2023-3323": {"epss_score": 0.00176, "epss_percentile": 0.39407}, "CVE-2023-3324": {"epss_score": 0.00403, "epss_percentile": 0.60323}, "CVE-2023-3325": {"epss_score": 0.0009, "epss_percentile": 0.26025}, "CVE-2023-3326": {"epss_score": 0.00483, "epss_percentile": 0.64594}, "CVE-2023-3328": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-3329": {"epss_score": 0.00065, "epss_percentile": 0.20638}, "CVE-2023-3330": {"epss_score": 0.00089, "epss_percentile": 0.2595}, "CVE-2023-3331": {"epss_score": 0.00111, "epss_percentile": 0.30398}, "CVE-2023-3332": {"epss_score": 0.00069, "epss_percentile": 0.21499}, "CVE-2023-3333": {"epss_score": 0.00079, "epss_percentile": 0.23945}, "CVE-2023-3335": {"epss_score": 0.001, "epss_percentile": 0.28468}, "CVE-2023-3336": {"epss_score": 0.00181, "epss_percentile": 0.4012}, "CVE-2023-3337": {"epss_score": 0.00141, "epss_percentile": 0.34835}, "CVE-2023-3338": {"epss_score": 0.11233, "epss_percentile": 0.93273}, "CVE-2023-3339": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-3340": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3341": {"epss_score": 0.00172, "epss_percentile": 0.39}, "CVE-2023-3342": {"epss_score": 0.03345, "epss_percentile": 0.86951}, "CVE-2023-3343": {"epss_score": 0.00358, "epss_percentile": 0.57527}, "CVE-2023-3344": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-3345": {"epss_score": 0.64843, "epss_percentile": 0.98395}, "CVE-2023-3346": {"epss_score": 0.01039, "epss_percentile": 0.76941}, "CVE-2023-3347": {"epss_score": 0.00419, "epss_percentile": 0.61368}, "CVE-2023-3348": {"epss_score": 0.00208, "epss_percentile": 0.43268}, "CVE-2023-3349": {"epss_score": 0.00122, "epss_percentile": 0.32098}, "CVE-2023-3350": {"epss_score": 0.00044, "epss_percentile": 0.13374}, "CVE-2023-3352": {"epss_score": 0.00092, "epss_percentile": 0.26554}, "CVE-2023-3354": {"epss_score": 0.00067, "epss_percentile": 0.21115}, "CVE-2023-3355": {"epss_score": 0.00017, "epss_percentile": 0.03168}, "CVE-2023-3356": {"epss_score": 0.0007, "epss_percentile": 0.21936}, "CVE-2023-3357": {"epss_score": 0.00015, "epss_percentile": 0.02335}, "CVE-2023-3358": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2023-3359": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2023-3361": {"epss_score": 0.00041, "epss_percentile": 0.12234}, "CVE-2023-3362": {"epss_score": 0.00562, "epss_percentile": 0.67695}, "CVE-2023-3363": {"epss_score": 0.00018, "epss_percentile": 0.0354}, "CVE-2023-3364": {"epss_score": 0.04708, "epss_percentile": 0.89034}, "CVE-2023-3365": {"epss_score": 0.00115, "epss_percentile": 0.31012}, "CVE-2023-3366": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-3368": {"epss_score": 0.84764, "epss_percentile": 0.99303}, "CVE-2023-3369": {"epss_score": 0.00106, "epss_percentile": 0.29423}, "CVE-2023-3371": {"epss_score": 0.00444, "epss_percentile": 0.62814}, "CVE-2023-3372": {"epss_score": 0.00266, "epss_percentile": 0.49844}, "CVE-2023-3373": {"epss_score": 0.00477, "epss_percentile": 0.64297}, "CVE-2023-3374": {"epss_score": 0.001, "epss_percentile": 0.28481}, "CVE-2023-3375": {"epss_score": 0.00121, "epss_percentile": 0.31816}, "CVE-2023-3376": {"epss_score": 0.0009, "epss_percentile": 0.25991}, "CVE-2023-3377": {"epss_score": 0.00078, "epss_percentile": 0.23608}, "CVE-2023-3379": {"epss_score": 0.00026, "epss_percentile": 0.06439}, "CVE-2023-3380": {"epss_score": 0.47965, "epss_percentile": 0.97611}, "CVE-2023-3381": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2023-3382": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-3383": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3384": {"epss_score": 0.00338, "epss_percentile": 0.56114}, "CVE-2023-3385": {"epss_score": 0.00111, "epss_percentile": 0.30282}, "CVE-2023-3386": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-3387": {"epss_score": 0.00125, "epss_percentile": 0.32536}, "CVE-2023-3388": {"epss_score": 0.63522, "epss_percentile": 0.98336}, "CVE-2023-3389": {"epss_score": 0.00021, "epss_percentile": 0.0477}, "CVE-2023-3390": {"epss_score": 0.00095, "epss_percentile": 0.27219}, "CVE-2023-3391": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3392": {"epss_score": 0.00526, "epss_percentile": 0.66412}, "CVE-2023-3393": {"epss_score": 0.00083, "epss_percentile": 0.24711}, "CVE-2023-3394": {"epss_score": 0.00081, "epss_percentile": 0.24374}, "CVE-2023-3395": {"epss_score": 0.00038, "epss_percentile": 0.11413}, "CVE-2023-3396": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-3397": {"epss_score": 8e-05, "epss_percentile": 0.0051}, "CVE-2023-3398": {"epss_score": 0.00086, "epss_percentile": 0.2528}, "CVE-2023-3399": {"epss_score": 0.00034, "epss_percentile": 0.09771}, "CVE-2023-3401": {"epss_score": 0.00232, "epss_percentile": 0.45896}, "CVE-2023-3403": {"epss_score": 0.00051, "epss_percentile": 0.16176}, "CVE-2023-3404": {"epss_score": 0.00143, "epss_percentile": 0.35166}, "CVE-2023-3405": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2023-3406": {"epss_score": 0.00098, "epss_percentile": 0.27793}, "CVE-2023-3407": {"epss_score": 0.00067, "epss_percentile": 0.21019}, "CVE-2023-3408": {"epss_score": 0.00181, "epss_percentile": 0.4008}, "CVE-2023-3409": {"epss_score": 0.00069, "epss_percentile": 0.21442}, "CVE-2023-3410": {"epss_score": 0.002, "epss_percentile": 0.42261}, "CVE-2023-3411": {"epss_score": 0.00064, "epss_percentile": 0.20284}, "CVE-2023-3412": {"epss_score": 0.00087, "epss_percentile": 0.25485}, "CVE-2023-3413": {"epss_score": 0.00221, "epss_percentile": 0.44693}, "CVE-2023-3414": {"epss_score": 0.00035, "epss_percentile": 0.09805}, "CVE-2023-3416": {"epss_score": 0.00364, "epss_percentile": 0.57939}, "CVE-2023-3417": {"epss_score": 0.00161, "epss_percentile": 0.37537}, "CVE-2023-3419": {"epss_score": 0.0033, "epss_percentile": 0.55417}, "CVE-2023-3420": {"epss_score": 0.04475, "epss_percentile": 0.88738}, "CVE-2023-3421": {"epss_score": 0.00627, "epss_percentile": 0.69633}, "CVE-2023-3422": {"epss_score": 0.00195, "epss_percentile": 0.41617}, "CVE-2023-3423": {"epss_score": 0.00067, "epss_percentile": 0.21093}, "CVE-2023-3424": {"epss_score": 0.00604, "epss_percentile": 0.68955}, "CVE-2023-3425": {"epss_score": 0.00128, "epss_percentile": 0.33016}, "CVE-2023-3426": {"epss_score": 0.00324, "epss_percentile": 0.54949}, "CVE-2023-3427": {"epss_score": 0.00049, "epss_percentile": 0.15501}, "CVE-2023-3428": {"epss_score": 0.00023, "epss_percentile": 0.05501}, "CVE-2023-3430": {"epss_score": 0.00529, "epss_percentile": 0.66604}, "CVE-2023-3431": {"epss_score": 0.00166, "epss_percentile": 0.38188}, "CVE-2023-3432": {"epss_score": 0.00182, "epss_percentile": 0.40156}, "CVE-2023-3433": {"epss_score": 0.00024, "epss_percentile": 0.05792}, "CVE-2023-3434": {"epss_score": 0.00067, "epss_percentile": 0.21136}, "CVE-2023-3435": {"epss_score": 0.00631, "epss_percentile": 0.69713}, "CVE-2023-3436": {"epss_score": 0.00016, "epss_percentile": 0.02873}, "CVE-2023-3438": {"epss_score": 0.00031, "epss_percentile": 0.08338}, "CVE-2023-3439": {"epss_score": 9e-05, "epss_percentile": 0.00612}, "CVE-2023-3440": {"epss_score": 0.00089, "epss_percentile": 0.25955}, "CVE-2023-3441": {"epss_score": 0.00071, "epss_percentile": 0.22018}, "CVE-2023-3442": {"epss_score": 0.00033, "epss_percentile": 0.09363}, "CVE-2023-3443": {"epss_score": 0.00055, "epss_percentile": 0.17462}, "CVE-2023-3444": {"epss_score": 0.00233, "epss_percentile": 0.46041}, "CVE-2023-3445": {"epss_score": 0.00104, "epss_percentile": 0.29211}, "CVE-2023-3446": {"epss_score": 0.00949, "epss_percentile": 0.75849}, "CVE-2023-3447": {"epss_score": 0.00446, "epss_percentile": 0.62927}, "CVE-2023-3449": {"epss_score": 0.00272, "epss_percentile": 0.50353}, "CVE-2023-3450": {"epss_score": 0.61259, "epss_percentile": 0.98242}, "CVE-2023-3452": {"epss_score": 0.4462, "epss_percentile": 0.97446}, "CVE-2023-3453": {"epss_score": 0.00032, "epss_percentile": 0.09039}, "CVE-2023-3454": {"epss_score": 0.04903, "epss_percentile": 0.89274}, "CVE-2023-3455": {"epss_score": 0.00054, "epss_percentile": 0.17109}, "CVE-2023-3456": {"epss_score": 0.00087, "epss_percentile": 0.2545}, "CVE-2023-3457": {"epss_score": 0.00067, "epss_percentile": 0.21168}, "CVE-2023-3458": {"epss_score": 0.00062, "epss_percentile": 0.19681}, "CVE-2023-3459": {"epss_score": 0.00152, "epss_percentile": 0.36379}, "CVE-2023-3460": {"epss_score": 0.92899, "epss_percentile": 0.99758}, "CVE-2023-3462": {"epss_score": 0.01006, "epss_percentile": 0.76548}, "CVE-2023-3463": {"epss_score": 0.0012, "epss_percentile": 0.31779}, "CVE-2023-3464": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-3465": {"epss_score": 0.00098, "epss_percentile": 0.27652}, "CVE-2023-3466": {"epss_score": 0.01118, "epss_percentile": 0.77748}, "CVE-2023-3467": {"epss_score": 0.00429, "epss_percentile": 0.6199}, "CVE-2023-3469": {"epss_score": 0.00165, "epss_percentile": 0.38044}, "CVE-2023-3470": {"epss_score": 0.00071, "epss_percentile": 0.22207}, "CVE-2023-3471": {"epss_score": 0.00104, "epss_percentile": 0.29197}, "CVE-2023-3472": {"epss_score": 0.00088, "epss_percentile": 0.25743}, "CVE-2023-3473": {"epss_score": 0.00048, "epss_percentile": 0.15224}, "CVE-2023-3474": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3475": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3476": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3477": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3478": {"epss_score": 0.00054, "epss_percentile": 0.17096}, "CVE-2023-3479": {"epss_score": 0.26384, "epss_percentile": 0.96142}, "CVE-2023-3481": {"epss_score": 0.00179, "epss_percentile": 0.39799}, "CVE-2023-3482": {"epss_score": 0.00199, "epss_percentile": 0.42144}, "CVE-2023-3484": {"epss_score": 0.00107, "epss_percentile": 0.29646}, "CVE-2023-3485": {"epss_score": 0.00021, "epss_percentile": 0.04832}, "CVE-2023-3486": {"epss_score": 0.02434, "epss_percentile": 0.84735}, "CVE-2023-3487": {"epss_score": 0.00269, "epss_percentile": 0.50179}, "CVE-2023-3488": {"epss_score": 0.00076, "epss_percentile": 0.23223}, "CVE-2023-3489": {"epss_score": 0.00109, "epss_percentile": 0.30036}, "CVE-2023-3490": {"epss_score": 0.00063, "epss_percentile": 0.20089}, "CVE-2023-3491": {"epss_score": 0.00084, "epss_percentile": 0.24917}, "CVE-2023-3492": {"epss_score": 0.00096, "epss_percentile": 0.27415}, "CVE-2023-3493": {"epss_score": 0.00091, "epss_percentile": 0.26401}, "CVE-2023-3494": {"epss_score": 0.00191, "epss_percentile": 0.41171}, "CVE-2023-3495": {"epss_score": 0.00051, "epss_percentile": 0.16262}, "CVE-2023-3497": {"epss_score": 0.00019, "epss_percentile": 0.04211}, "CVE-2023-3499": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-3500": {"epss_score": 0.00498, "epss_percentile": 0.65215}, "CVE-2023-3501": {"epss_score": 0.00239, "epss_percentile": 0.46877}, "CVE-2023-3502": {"epss_score": 0.00046, "epss_percentile": 0.14091}, "CVE-2023-3503": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2023-3504": {"epss_score": 0.00058, "epss_percentile": 0.18505}, "CVE-2023-3505": {"epss_score": 0.00062, "epss_percentile": 0.19689}, "CVE-2023-3506": {"epss_score": 0.00062, "epss_percentile": 0.19689}, "CVE-2023-3507": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-3508": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-3509": {"epss_score": 0.0003, "epss_percentile": 0.08164}, "CVE-2023-3510": {"epss_score": 0.00108, "epss_percentile": 0.29783}, "CVE-2023-3511": {"epss_score": 0.00021, "epss_percentile": 0.04772}, "CVE-2023-3512": {"epss_score": 0.00095, "epss_percentile": 0.27162}, "CVE-2023-3513": {"epss_score": 0.00096, "epss_percentile": 0.27414}, "CVE-2023-3514": {"epss_score": 0.00078, "epss_percentile": 0.23675}, "CVE-2023-3515": {"epss_score": 0.00059, "epss_percentile": 0.18631}, "CVE-2023-3517": {"epss_score": 0.00123, "epss_percentile": 0.32209}, "CVE-2023-3518": {"epss_score": 0.00167, "epss_percentile": 0.38274}, "CVE-2023-3519": {"epss_score": 0.93993, "epss_percentile": 0.99882}, "CVE-2023-3520": {"epss_score": 0.00035, "epss_percentile": 0.10132}, "CVE-2023-3521": {"epss_score": 0.15059, "epss_percentile": 0.94353}, "CVE-2023-3522": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-3523": {"epss_score": 0.00034, "epss_percentile": 0.09433}, "CVE-2023-3524": {"epss_score": 0.00325, "epss_percentile": 0.54981}, "CVE-2023-3525": {"epss_score": 0.00085, "epss_percentile": 0.25164}, "CVE-2023-3526": {"epss_score": 0.00613, "epss_percentile": 0.69257}, "CVE-2023-3527": {"epss_score": 0.00076, "epss_percentile": 0.2318}, "CVE-2023-3528": {"epss_score": 0.00047, "epss_percentile": 0.14639}, "CVE-2023-3529": {"epss_score": 0.00093, "epss_percentile": 0.26626}, "CVE-2023-3531": {"epss_score": 0.00101, "epss_percentile": 0.28633}, "CVE-2023-3532": {"epss_score": 0.00081, "epss_percentile": 0.24298}, "CVE-2023-3533": {"epss_score": 0.03241, "epss_percentile": 0.86732}, "CVE-2023-3534": {"epss_score": 0.00055, "epss_percentile": 0.17371}, "CVE-2023-3535": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3536": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3537": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3538": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3539": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3540": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3541": {"epss_score": 0.00078, "epss_percentile": 0.23592}, "CVE-2023-3542": {"epss_score": 0.00062, "epss_percentile": 0.19689}, "CVE-2023-3543": {"epss_score": 0.00081, "epss_percentile": 0.24318}, "CVE-2023-3544": {"epss_score": 0.00062, "epss_percentile": 0.19689}, "CVE-2023-3545": {"epss_score": 0.02987, "epss_percentile": 0.86135}, "CVE-2023-3547": {"epss_score": 0.00202, "epss_percentile": 0.42451}, "CVE-2023-3548": {"epss_score": 0.00134, "epss_percentile": 0.33751}, "CVE-2023-3550": {"epss_score": 0.00185, "epss_percentile": 0.40464}, "CVE-2023-3551": {"epss_score": 0.00174, "epss_percentile": 0.39188}, "CVE-2023-3552": {"epss_score": 0.00273, "epss_percentile": 0.50473}, "CVE-2023-3553": {"epss_score": 0.00487, "epss_percentile": 0.64782}, "CVE-2023-3554": {"epss_score": 0.00255, "epss_percentile": 0.48689}, "CVE-2023-3555": {"epss_score": 0.00255, "epss_percentile": 0.48689}, "CVE-2023-3556": {"epss_score": 0.00249, "epss_percentile": 0.48032}, "CVE-2023-3557": {"epss_score": 0.00249, "epss_percentile": 0.48032}, "CVE-2023-3558": {"epss_score": 0.00249, "epss_percentile": 0.48032}, "CVE-2023-3559": {"epss_score": 0.00255, "epss_percentile": 0.48689}, "CVE-2023-3560": {"epss_score": 0.00069, "epss_percentile": 0.21428}, "CVE-2023-3561": {"epss_score": 0.00249, "epss_percentile": 0.48032}, "CVE-2023-3562": {"epss_score": 0.00249, "epss_percentile": 0.48032}, "CVE-2023-3563": {"epss_score": 0.00255, "epss_percentile": 0.48689}, "CVE-2023-3564": {"epss_score": 0.00255, "epss_percentile": 0.48689}, "CVE-2023-3565": {"epss_score": 0.00086, "epss_percentile": 0.25285}, "CVE-2023-3566": {"epss_score": 0.00054, "epss_percentile": 0.17068}, "CVE-2023-3567": {"epss_score": 8e-05, "epss_percentile": 0.00505}, "CVE-2023-3568": {"epss_score": 0.00035, "epss_percentile": 0.09857}, "CVE-2023-3569": {"epss_score": 0.00198, "epss_percentile": 0.42001}, "CVE-2023-3570": {"epss_score": 0.00466, "epss_percentile": 0.63798}, "CVE-2023-3571": {"epss_score": 0.00401, "epss_percentile": 0.60206}, "CVE-2023-3572": {"epss_score": 0.00711, "epss_percentile": 0.71736}, "CVE-2023-3573": {"epss_score": 0.00669, "epss_percentile": 0.70755}, "CVE-2023-3574": {"epss_score": 2e-05, "epss_percentile": 0.00027}, "CVE-2023-3575": {"epss_score": 0.00152, "epss_percentile": 0.36442}, "CVE-2023-3576": {"epss_score": 0.0002, "epss_percentile": 0.04469}, "CVE-2023-3577": {"epss_score": 0.00158, "epss_percentile": 0.37197}, "CVE-2023-3578": {"epss_score": 0.69641, "epss_percentile": 0.98595}, "CVE-2023-3579": {"epss_score": 0.00184, "epss_percentile": 0.40426}, "CVE-2023-3580": {"epss_score": 0.00087, "epss_percentile": 0.25574}, "CVE-2023-3581": {"epss_score": 0.00128, "epss_percentile": 0.33031}, "CVE-2023-3582": {"epss_score": 0.00123, "epss_percentile": 0.32192}, "CVE-2023-3584": {"epss_score": 0.00117, "epss_percentile": 0.31221}, "CVE-2023-3585": {"epss_score": 0.00135, "epss_percentile": 0.34045}, "CVE-2023-3586": {"epss_score": 0.0016, "epss_percentile": 0.37485}, "CVE-2023-3587": {"epss_score": 0.0006, "epss_percentile": 0.19147}, "CVE-2023-3588": {"epss_score": 0.00111, "epss_percentile": 0.3039}, "CVE-2023-3589": {"epss_score": 0.00155, "epss_percentile": 0.36791}, "CVE-2023-3590": {"epss_score": 0.00288, "epss_percentile": 0.51867}, "CVE-2023-3591": {"epss_score": 0.00199, "epss_percentile": 0.42145}, "CVE-2023-3592": {"epss_score": 0.00038, "epss_percentile": 0.11215}, "CVE-2023-3593": {"epss_score": 0.00118, "epss_percentile": 0.31458}, "CVE-2023-3595": {"epss_score": 0.12251, "epss_percentile": 0.93612}, "CVE-2023-3596": {"epss_score": 0.00505, "epss_percentile": 0.65606}, "CVE-2023-3597": {"epss_score": 0.00104, "epss_percentile": 0.2918}, "CVE-2023-3598": {"epss_score": 0.00534, "epss_percentile": 0.66793}, "CVE-2023-3599": {"epss_score": 0.00084, "epss_percentile": 0.24892}, "CVE-2023-3600": {"epss_score": 0.00181, "epss_percentile": 0.40093}, "CVE-2023-3601": {"epss_score": 0.00143, "epss_percentile": 0.35204}, "CVE-2023-3603": {"epss_score": 0.0012, "epss_percentile": 0.31709}, "CVE-2023-3604": {"epss_score": 0.00274, "epss_percentile": 0.50563}, "CVE-2023-3605": {"epss_score": 0.00048, "epss_percentile": 0.15147}, "CVE-2023-3606": {"epss_score": 0.01184, "epss_percentile": 0.78332}, "CVE-2023-3607": {"epss_score": 0.00306, "epss_percentile": 0.53455}, "CVE-2023-3608": {"epss_score": 0.00956, "epss_percentile": 0.75925}, "CVE-2023-3609": {"epss_score": 0.00014, "epss_percentile": 0.01996}, "CVE-2023-3610": {"epss_score": 0.00019, "epss_percentile": 0.04329}, "CVE-2023-3611": {"epss_score": 0.00015, "epss_percentile": 0.02603}, "CVE-2023-3612": {"epss_score": 0.00071, "epss_percentile": 0.22127}, "CVE-2023-3613": {"epss_score": 0.00117, "epss_percentile": 0.31348}, "CVE-2023-3614": {"epss_score": 0.0007, "epss_percentile": 0.21762}, "CVE-2023-3615": {"epss_score": 0.00216, "epss_percentile": 0.44128}, "CVE-2023-3616": {"epss_score": 0.00061, "epss_percentile": 0.19515}, "CVE-2023-3617": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2023-3618": {"epss_score": 0.00215, "epss_percentile": 0.44034}, "CVE-2023-3619": {"epss_score": 0.00039, "epss_percentile": 0.11668}, "CVE-2023-3620": {"epss_score": 0.00124, "epss_percentile": 0.32455}, "CVE-2023-3621": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3622": {"epss_score": 0.00073, "epss_percentile": 0.22503}, "CVE-2023-3623": {"epss_score": 0.00085, "epss_percentile": 0.25236}, "CVE-2023-3624": {"epss_score": 0.00037, "epss_percentile": 0.10915}, "CVE-2023-3625": {"epss_score": 0.0009, "epss_percentile": 0.26042}, "CVE-2023-3626": {"epss_score": 0.00091, "epss_percentile": 0.26273}, "CVE-2023-3627": {"epss_score": 0.0007, "epss_percentile": 0.21745}, "CVE-2023-3628": {"epss_score": 0.00115, "epss_percentile": 0.30983}, "CVE-2023-3629": {"epss_score": 0.00078, "epss_percentile": 0.23627}, "CVE-2023-3631": {"epss_score": 0.0006, "epss_percentile": 0.18937}, "CVE-2023-3632": {"epss_score": 0.00021, "epss_percentile": 0.04716}, "CVE-2023-3633": {"epss_score": 0.00228, "epss_percentile": 0.45499}, "CVE-2023-3635": {"epss_score": 0.00375, "epss_percentile": 0.58633}, "CVE-2023-3636": {"epss_score": 0.00082, "epss_percentile": 0.24425}, "CVE-2023-3637": {"epss_score": 0.00214, "epss_percentile": 0.4402}, "CVE-2023-3638": {"epss_score": 0.00205, "epss_percentile": 0.42679}, "CVE-2023-3640": {"epss_score": 0.00136, "epss_percentile": 0.34185}, "CVE-2023-3641": {"epss_score": 0.0007, "epss_percentile": 0.21933}, "CVE-2023-3642": {"epss_score": 0.00078, "epss_percentile": 0.23593}, "CVE-2023-3643": {"epss_score": 0.10142, "epss_percentile": 0.92863}, "CVE-2023-3644": {"epss_score": 0.00039, "epss_percentile": 0.11668}, "CVE-2023-3645": {"epss_score": 0.00089, "epss_percentile": 0.259}, "CVE-2023-3646": {"epss_score": 0.00147, "epss_percentile": 0.35711}, "CVE-2023-3647": {"epss_score": 0.00198, "epss_percentile": 0.4205}, "CVE-2023-3648": {"epss_score": 0.00022, "epss_percentile": 0.04977}, "CVE-2023-3649": {"epss_score": 0.0002, "epss_percentile": 0.04568}, "CVE-2023-3650": {"epss_score": 0.01298, "epss_percentile": 0.79273}, "CVE-2023-3651": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-3652": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-3653": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-3654": {"epss_score": 0.00011, "epss_percentile": 0.01055}, "CVE-2023-3655": {"epss_score": 0.00074, "epss_percentile": 0.22843}, "CVE-2023-3656": {"epss_score": 0.01306, "epss_percentile": 0.79334}, "CVE-2023-3657": {"epss_score": 0.00047, "epss_percentile": 0.14639}, "CVE-2023-3658": {"epss_score": 0.00047, "epss_percentile": 0.14639}, "CVE-2023-3659": {"epss_score": 0.00062, "epss_percentile": 0.19689}, "CVE-2023-3660": {"epss_score": 0.00055, "epss_percentile": 0.17476}, "CVE-2023-3661": {"epss_score": 0.00039, "epss_percentile": 0.11668}, "CVE-2023-3662": {"epss_score": 0.00022, "epss_percentile": 0.05249}, "CVE-2023-3663": {"epss_score": 0.0049, "epss_percentile": 0.64924}, "CVE-2023-3664": {"epss_score": 0.0035, "epss_percentile": 0.56925}, "CVE-2023-3665": {"epss_score": 0.00076, "epss_percentile": 0.23223}, "CVE-2023-3666": {"epss_score": 0.00048, "epss_percentile": 0.15286}, "CVE-2023-3667": {"epss_score": 0.00089, "epss_percentile": 0.259}, "CVE-2023-3668": {"epss_score": 0.00072, "epss_percentile": 0.2225}, "CVE-2023-3669": {"epss_score": 0.00026, "epss_percentile": 0.06726}, "CVE-2023-3670": {"epss_score": 0.00019, "epss_percentile": 0.0406}, "CVE-2023-3671": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-3672": {"epss_score": 0.00069, "epss_percentile": 0.21627}, "CVE-2023-3673": {"epss_score": 0.0928, "epss_percentile": 0.92481}, "CVE-2023-3674": {"epss_score": 0.00021, "epss_percentile": 0.04934}, "CVE-2023-3675": {"epss_score": 0.00364, "epss_percentile": 0.57942}, "CVE-2023-3676": {"epss_score": 0.40738, "epss_percentile": 0.97236}, "CVE-2023-3677": {"epss_score": 0.00225, "epss_percentile": 0.45086}, "CVE-2023-3678": {"epss_score": 0.00037, "epss_percentile": 0.10915}, "CVE-2023-3679": {"epss_score": 0.00037, "epss_percentile": 0.10915}, "CVE-2023-3680": {"epss_score": 0.00037, "epss_percentile": 0.10915}, "CVE-2023-3681": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3682": {"epss_score": 0.00048, "epss_percentile": 0.15279}, "CVE-2023-3683": {"epss_score": 0.00064, "epss_percentile": 0.20355}, "CVE-2023-3684": {"epss_score": 0.00045, "epss_percentile": 0.13732}, "CVE-2023-3685": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3686": {"epss_score": 0.00045, "epss_percentile": 0.13713}, "CVE-2023-3687": {"epss_score": 0.00045, "epss_percentile": 0.13713}, "CVE-2023-3688": {"epss_score": 0.00037, "epss_percentile": 0.10915}, "CVE-2023-3689": {"epss_score": 0.00045, "epss_percentile": 0.13713}, "CVE-2023-3690": {"epss_score": 0.00045, "epss_percentile": 0.13713}, "CVE-2023-3691": {"epss_score": 0.00076, "epss_percentile": 0.23173}, "CVE-2023-3692": {"epss_score": 0.00053, "epss_percentile": 0.16732}, "CVE-2023-3693": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2023-3694": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3695": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3696": {"epss_score": 0.00308, "epss_percentile": 0.53619}, "CVE-2023-3697": {"epss_score": 0.0031, "epss_percentile": 0.53756}, "CVE-2023-3698": {"epss_score": 0.00258, "epss_percentile": 0.48987}, "CVE-2023-3699": {"epss_score": 0.00049, "epss_percentile": 0.15587}, "CVE-2023-3700": {"epss_score": 0.00017, "epss_percentile": 0.03191}, "CVE-2023-3701": {"epss_score": 0.0009, "epss_percentile": 0.26049}, "CVE-2023-3703": {"epss_score": 0.00077, "epss_percentile": 0.23298}, "CVE-2023-3704": {"epss_score": 0.00099, "epss_percentile": 0.28308}, "CVE-2023-3705": {"epss_score": 0.00217, "epss_percentile": 0.4433}, "CVE-2023-3706": {"epss_score": 0.00146, "epss_percentile": 0.35538}, "CVE-2023-3707": {"epss_score": 0.00146, "epss_percentile": 0.35538}, "CVE-2023-3708": {"epss_score": 0.00742, "epss_percentile": 0.72462}, "CVE-2023-3709": {"epss_score": 0.00182, "epss_percentile": 0.40187}, "CVE-2023-3710": {"epss_score": 0.91703, "epss_percentile": 0.99663}, "CVE-2023-3711": {"epss_score": 0.00122, "epss_percentile": 0.32109}, "CVE-2023-3712": {"epss_score": 0.00033, "epss_percentile": 0.09406}, "CVE-2023-3713": {"epss_score": 0.00079, "epss_percentile": 0.23817}, "CVE-2023-3714": {"epss_score": 0.00137, "epss_percentile": 0.34235}, "CVE-2023-3716": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-3717": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-3718": {"epss_score": 0.01103, "epss_percentile": 0.77591}, "CVE-2023-3720": {"epss_score": 0.0006, "epss_percentile": 0.18956}, "CVE-2023-3721": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-3722": {"epss_score": 0.50868, "epss_percentile": 0.97753}, "CVE-2023-3724": {"epss_score": 0.00082, "epss_percentile": 0.24411}, "CVE-2023-3725": {"epss_score": 0.00562, "epss_percentile": 0.677}, "CVE-2023-3726": {"epss_score": 0.00059, "epss_percentile": 0.18918}, "CVE-2023-3727": {"epss_score": 0.00513, "epss_percentile": 0.65907}, "CVE-2023-3728": {"epss_score": 0.00513, "epss_percentile": 0.65907}, "CVE-2023-3729": {"epss_score": 0.00483, "epss_percentile": 0.64576}, "CVE-2023-3730": {"epss_score": 0.00484, "epss_percentile": 0.64665}, "CVE-2023-3731": {"epss_score": 0.00054, "epss_percentile": 0.17304}, "CVE-2023-3732": {"epss_score": 0.00699, "epss_percentile": 0.71445}, "CVE-2023-3733": {"epss_score": 0.00183, "epss_percentile": 0.40318}, "CVE-2023-3734": {"epss_score": 0.00173, "epss_percentile": 0.39065}, "CVE-2023-3735": {"epss_score": 0.00183, "epss_percentile": 0.40318}, "CVE-2023-3736": {"epss_score": 0.00132, "epss_percentile": 0.33597}, "CVE-2023-3737": {"epss_score": 0.00173, "epss_percentile": 0.39065}, "CVE-2023-3738": {"epss_score": 0.00137, "epss_percentile": 0.34228}, "CVE-2023-3739": {"epss_score": 0.00526, "epss_percentile": 0.66405}, "CVE-2023-3740": {"epss_score": 0.00127, "epss_percentile": 0.32883}, "CVE-2023-3741": {"epss_score": 0.00547, "epss_percentile": 0.67261}, "CVE-2023-3742": {"epss_score": 8e-05, "epss_percentile": 0.00487}, "CVE-2023-3743": {"epss_score": 0.00089, "epss_percentile": 0.25917}, "CVE-2023-3744": {"epss_score": 0.00098, "epss_percentile": 0.27806}, "CVE-2023-3745": {"epss_score": 0.00015, "epss_percentile": 0.02222}, "CVE-2023-3746": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-3747": {"epss_score": 0.00031, "epss_percentile": 0.08501}, "CVE-2023-3748": {"epss_score": 0.0002, "epss_percentile": 0.04687}, "CVE-2023-3749": {"epss_score": 0.00036, "epss_percentile": 0.10375}, "CVE-2023-3750": {"epss_score": 0.00115, "epss_percentile": 0.30981}, "CVE-2023-3751": {"epss_score": 0.00037, "epss_percentile": 0.10915}, "CVE-2023-3752": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3753": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3754": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3755": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3756": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3757": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3758": {"epss_score": 0.00042, "epss_percentile": 0.12729}, "CVE-2023-3759": {"epss_score": 0.00079, "epss_percentile": 0.23812}, "CVE-2023-3760": {"epss_score": 0.00052, "epss_percentile": 0.1651}, "CVE-2023-3761": {"epss_score": 0.00047, "epss_percentile": 0.14599}, "CVE-2023-3762": {"epss_score": 0.00039, "epss_percentile": 0.1164}, "CVE-2023-3763": {"epss_score": 0.00048, "epss_percentile": 0.14963}, "CVE-2023-3764": {"epss_score": 0.00067, "epss_percentile": 0.21019}, "CVE-2023-3765": {"epss_score": 0.9279, "epss_percentile": 0.9975}, "CVE-2023-3766": {"epss_score": 0.00451, "epss_percentile": 0.63127}, "CVE-2023-3767": {"epss_score": 0.00787, "epss_percentile": 0.7332}, "CVE-2023-3768": {"epss_score": 0.00057, "epss_percentile": 0.18027}, "CVE-2023-3769": {"epss_score": 0.00057, "epss_percentile": 0.18027}, "CVE-2023-3770": {"epss_score": 0.00068, "epss_percentile": 0.21398}, "CVE-2023-3771": {"epss_score": 0.00177, "epss_percentile": 0.39587}, "CVE-2023-3772": {"epss_score": 0.00014, "epss_percentile": 0.01893}, "CVE-2023-3773": {"epss_score": 0.00021, "epss_percentile": 0.0482}, "CVE-2023-3774": {"epss_score": 0.00486, "epss_percentile": 0.64747}, "CVE-2023-3775": {"epss_score": 0.00362, "epss_percentile": 0.57753}, "CVE-2023-3776": {"epss_score": 0.0004, "epss_percentile": 0.1189}, "CVE-2023-3777": {"epss_score": 0.00032, "epss_percentile": 0.09043}, "CVE-2023-3779": {"epss_score": 0.00215, "epss_percentile": 0.44049}, "CVE-2023-3781": {"epss_score": 0.00013, "epss_percentile": 0.01634}, "CVE-2023-3782": {"epss_score": 0.00203, "epss_percentile": 0.425}, "CVE-2023-3783": {"epss_score": 0.00082, "epss_percentile": 0.24512}, "CVE-2023-3784": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3785": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3786": {"epss_score": 0.00032, "epss_percentile": 0.09114}, "CVE-2023-3787": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3788": {"epss_score": 0.00099, "epss_percentile": 0.28418}, "CVE-2023-3789": {"epss_score": 0.00099, "epss_percentile": 0.28418}, "CVE-2023-3790": {"epss_score": 0.00099, "epss_percentile": 0.28418}, "CVE-2023-3791": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3792": {"epss_score": 0.0012, "epss_percentile": 0.31714}, "CVE-2023-3793": {"epss_score": 0.00045, "epss_percentile": 0.13713}, "CVE-2023-3794": {"epss_score": 0.00077, "epss_percentile": 0.23444}, "CVE-2023-3795": {"epss_score": 0.00045, "epss_percentile": 0.13713}, "CVE-2023-3796": {"epss_score": 0.0006, "epss_percentile": 0.19083}, "CVE-2023-3797": {"epss_score": 0.00085, "epss_percentile": 0.25236}, "CVE-2023-3798": {"epss_score": 0.00085, "epss_percentile": 0.25236}, "CVE-2023-3799": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3800": {"epss_score": 0.00055, "epss_percentile": 0.17436}, "CVE-2023-3801": {"epss_score": 0.00034, "epss_percentile": 0.09618}, "CVE-2023-3802": {"epss_score": 0.0019, "epss_percentile": 0.41067}, "CVE-2023-3803": {"epss_score": 0.00086, "epss_percentile": 0.25379}, "CVE-2023-3804": {"epss_score": 0.00084, "epss_percentile": 0.24892}, "CVE-2023-3805": {"epss_score": 0.00067, "epss_percentile": 0.21079}, "CVE-2023-3806": {"epss_score": 0.00079, "epss_percentile": 0.23812}, "CVE-2023-3807": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3808": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3809": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3810": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3811": {"epss_score": 0.00057, "epss_percentile": 0.1821}, "CVE-2023-3812": {"epss_score": 8e-05, "epss_percentile": 0.00533}, "CVE-2023-3813": {"epss_score": 0.01241, "epss_percentile": 0.78814}, "CVE-2023-3814": {"epss_score": 0.00157, "epss_percentile": 0.3712}, "CVE-2023-3815": {"epss_score": 0.00076, "epss_percentile": 0.23173}, "CVE-2023-3817": {"epss_score": 0.0032, "epss_percentile": 0.54582}, "CVE-2023-3819": {"epss_score": 2e-05, "epss_percentile": 0.00031}, "CVE-2023-3820": {"epss_score": 0.3911, "epss_percentile": 0.97139}, "CVE-2023-3821": {"epss_score": 5e-05, "epss_percentile": 0.00231}, "CVE-2023-3822": {"epss_score": 0.08943, "epss_percentile": 0.9233}, "CVE-2023-3823": {"epss_score": 0.00276, "epss_percentile": 0.50762}, "CVE-2023-3824": {"epss_score": 0.32167, "epss_percentile": 0.96675}, "CVE-2023-3825": {"epss_score": 0.00074, "epss_percentile": 0.22701}, "CVE-2023-3826": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-3827": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3828": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3829": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3830": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3831": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3832": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3833": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3834": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3835": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3836": {"epss_score": 0.90929, "epss_percentile": 0.9961}, "CVE-2023-3837": {"epss_score": 0.00055, "epss_percentile": 0.17586}, "CVE-2023-3838": {"epss_score": 0.00055, "epss_percentile": 0.17586}, "CVE-2023-3839": {"epss_score": 0.0005, "epss_percentile": 0.15771}, "CVE-2023-3840": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3841": {"epss_score": 0.0005, "epss_percentile": 0.15783}, "CVE-2023-3842": {"epss_score": 0.00031, "epss_percentile": 0.08641}, "CVE-2023-3843": {"epss_score": 0.08663, "epss_percentile": 0.9218}, "CVE-2023-3844": {"epss_score": 0.08663, "epss_percentile": 0.9218}, "CVE-2023-3845": {"epss_score": 0.08663, "epss_percentile": 0.9218}, "CVE-2023-3846": {"epss_score": 0.08663, "epss_percentile": 0.9218}, "CVE-2023-3847": {"epss_score": 0.08663, "epss_percentile": 0.9218}, "CVE-2023-3848": {"epss_score": 0.08663, "epss_percentile": 0.9218}, "CVE-2023-3849": {"epss_score": 0.08663, "epss_percentile": 0.9218}, "CVE-2023-3850": {"epss_score": 0.00048, "epss_percentile": 0.15279}, "CVE-2023-3852": {"epss_score": 0.04345, "epss_percentile": 0.88574}, "CVE-2023-3853": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3854": {"epss_score": 0.00045, "epss_percentile": 0.13713}, "CVE-2023-3855": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3856": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3857": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3858": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3859": {"epss_score": 0.00045, "epss_percentile": 0.13713}, "CVE-2023-3860": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3861": {"epss_score": 0.00064, "epss_percentile": 0.20355}, "CVE-2023-3862": {"epss_score": 0.00067, "epss_percentile": 0.21072}, "CVE-2023-3863": {"epss_score": 0.00011, "epss_percentile": 0.00926}, "CVE-2023-3864": {"epss_score": 0.00196, "epss_percentile": 0.4175}, "CVE-2023-3865": {"epss_score": 0.00044, "epss_percentile": 0.13376}, "CVE-2023-3866": {"epss_score": 0.00032, "epss_percentile": 0.08785}, "CVE-2023-3867": {"epss_score": 0.00197, "epss_percentile": 0.41859}, "CVE-2023-3869": {"epss_score": 0.00221, "epss_percentile": 0.44671}, "CVE-2023-3871": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-3872": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-3873": {"epss_score": 0.0005, "epss_percentile": 0.15711}, "CVE-2023-3874": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-3875": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-3876": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-3877": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-3878": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-3879": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-3880": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-3881": {"epss_score": 0.00109, "epss_percentile": 0.29973}, "CVE-2023-3882": {"epss_score": 0.00095, "epss_percentile": 0.27144}, "CVE-2023-3883": {"epss_score": 0.00472, "epss_percentile": 0.64072}, "CVE-2023-3884": {"epss_score": 0.00196, "epss_percentile": 0.41821}, "CVE-2023-3885": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3886": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3887": {"epss_score": 0.00076, "epss_percentile": 0.23173}, "CVE-2023-3888": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-3889": {"epss_score": 0.00104, "epss_percentile": 0.29186}, "CVE-2023-3890": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3891": {"epss_score": 0.00085, "epss_percentile": 0.2517}, "CVE-2023-3892": {"epss_score": 0.00112, "epss_percentile": 0.30497}, "CVE-2023-3893": {"epss_score": 0.03694, "epss_percentile": 0.87581}, "CVE-2023-3894": {"epss_score": 0.0005, "epss_percentile": 0.15691}, "CVE-2023-3896": {"epss_score": 0.00328, "epss_percentile": 0.5516}, "CVE-2023-3897": {"epss_score": 0.0118, "epss_percentile": 0.78298}, "CVE-2023-3898": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-3899": {"epss_score": 0.00026, "epss_percentile": 0.06538}, "CVE-2023-3900": {"epss_score": 0.00216, "epss_percentile": 0.44186}, "CVE-2023-3904": {"epss_score": 0.00023, "epss_percentile": 0.05435}, "CVE-2023-3906": {"epss_score": 0.00219, "epss_percentile": 0.4451}, "CVE-2023-3907": {"epss_score": 0.00026, "epss_percentile": 0.06552}, "CVE-2023-3909": {"epss_score": 0.00023, "epss_percentile": 0.05435}, "CVE-2023-3914": {"epss_score": 0.00042, "epss_percentile": 0.127}, "CVE-2023-3915": {"epss_score": 0.00034, "epss_percentile": 0.09729}, "CVE-2023-3917": {"epss_score": 0.00133, "epss_percentile": 0.33643}, "CVE-2023-3920": {"epss_score": 0.00195, "epss_percentile": 0.41648}, "CVE-2023-3922": {"epss_score": 0.00073, "epss_percentile": 0.22604}, "CVE-2023-3932": {"epss_score": 0.00067, "epss_percentile": 0.21061}, "CVE-2023-3933": {"epss_score": 0.01013, "epss_percentile": 0.76635}, "CVE-2023-3935": {"epss_score": 0.00413, "epss_percentile": 0.61007}, "CVE-2023-3936": {"epss_score": 0.09688, "epss_percentile": 0.92663}, "CVE-2023-3937": {"epss_score": 0.00186, "epss_percentile": 0.4069}, "CVE-2023-3938": {"epss_score": 0.00175, "epss_percentile": 0.39349}, "CVE-2023-3939": {"epss_score": 0.01291, "epss_percentile": 0.7923}, "CVE-2023-3940": {"epss_score": 0.00856, "epss_percentile": 0.74481}, "CVE-2023-3941": {"epss_score": 0.00658, "epss_percentile": 0.70482}, "CVE-2023-3942": {"epss_score": 0.00222, "epss_percentile": 0.44729}, "CVE-2023-3943": {"epss_score": 0.00769, "epss_percentile": 0.72983}, "CVE-2023-3944": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3945": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-3946": {"epss_score": 0.00246, "epss_percentile": 0.478}, "CVE-2023-3947": {"epss_score": 0.00206, "epss_percentile": 0.43032}, "CVE-2023-3949": {"epss_score": 0.00108, "epss_percentile": 0.29842}, "CVE-2023-3950": {"epss_score": 0.00042, "epss_percentile": 0.12826}, "CVE-2023-3953": {"epss_score": 0.0006, "epss_percentile": 0.19181}, "CVE-2023-3954": {"epss_score": 0.00128, "epss_percentile": 0.32988}, "CVE-2023-3955": {"epss_score": 0.00762, "epss_percentile": 0.72849}, "CVE-2023-3956": {"epss_score": 0.00466, "epss_percentile": 0.6379}, "CVE-2023-3957": {"epss_score": 0.00053, "epss_percentile": 0.16983}, "CVE-2023-3958": {"epss_score": 0.00163, "epss_percentile": 0.37823}, "CVE-2023-3959": {"epss_score": 0.00497, "epss_percentile": 0.65186}, "CVE-2023-3961": {"epss_score": 0.01941, "epss_percentile": 0.82983}, "CVE-2023-3962": {"epss_score": 0.01013, "epss_percentile": 0.76635}, "CVE-2023-3964": {"epss_score": 0.00093, "epss_percentile": 0.26737}, "CVE-2023-3965": {"epss_score": 0.01013, "epss_percentile": 0.76635}, "CVE-2023-3966": {"epss_score": 0.00045, "epss_percentile": 0.13686}, "CVE-2023-3967": {"epss_score": 0.00181, "epss_percentile": 0.40018}, "CVE-2023-3969": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3970": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3971": {"epss_score": 0.00443, "epss_percentile": 0.62787}, "CVE-2023-3972": {"epss_score": 8e-05, "epss_percentile": 0.0058}, "CVE-2023-3973": {"epss_score": 0.00067, "epss_percentile": 0.21065}, "CVE-2023-3974": {"epss_score": 0.00298, "epss_percentile": 0.52805}, "CVE-2023-3975": {"epss_score": 0.00559, "epss_percentile": 0.67612}, "CVE-2023-3977": {"epss_score": 0.00449, "epss_percentile": 0.63033}, "CVE-2023-3978": {"epss_score": 0.00095, "epss_percentile": 0.27129}, "CVE-2023-3979": {"epss_score": 0.0006, "epss_percentile": 0.19198}, "CVE-2023-3980": {"epss_score": 0.0007, "epss_percentile": 0.21936}, "CVE-2023-3981": {"epss_score": 0.00046, "epss_percentile": 0.14091}, "CVE-2023-3982": {"epss_score": 0.0007, "epss_percentile": 0.21936}, "CVE-2023-3983": {"epss_score": 0.00108, "epss_percentile": 0.29892}, "CVE-2023-3984": {"epss_score": 0.00045, "epss_percentile": 0.13713}, "CVE-2023-3985": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2023-3986": {"epss_score": 0.00059, "epss_percentile": 0.18778}, "CVE-2023-3987": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2023-3988": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-3989": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-3990": {"epss_score": 0.0816, "epss_percentile": 0.91909}, "CVE-2023-3991": {"epss_score": 0.01281, "epss_percentile": 0.79148}, "CVE-2023-3992": {"epss_score": 0.00099, "epss_percentile": 0.28345}, "CVE-2023-3993": {"epss_score": 0.0008, "epss_percentile": 0.24189}, "CVE-2023-3994": {"epss_score": 0.00215, "epss_percentile": 0.44101}, "CVE-2023-3996": {"epss_score": 0.00182, "epss_percentile": 0.40154}, "CVE-2023-3997": {"epss_score": 0.00077, "epss_percentile": 0.23449}, "CVE-2023-3998": {"epss_score": 0.00221, "epss_percentile": 0.44671}, "CVE-2023-3999": {"epss_score": 0.00015, "epss_percentile": 0.02221}, "CVE-2023-40000": {"epss_score": 0.80074, "epss_percentile": 0.9907}, "CVE-2023-40001": {"epss_score": 0.00152, "epss_percentile": 0.36394}, "CVE-2023-40002": {"epss_score": 0.0029, "epss_percentile": 0.52104}, "CVE-2023-40003": {"epss_score": 0.00312, "epss_percentile": 0.53942}, "CVE-2023-40004": {"epss_score": 0.06089, "epss_percentile": 0.90471}, "CVE-2023-40005": {"epss_score": 0.00417, "epss_percentile": 0.61221}, "CVE-2023-40007": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-40008": {"epss_score": 0.00055, "epss_percentile": 0.17587}, "CVE-2023-40009": {"epss_score": 0.00047, "epss_percentile": 0.14827}, "CVE-2023-40010": {"epss_score": 0.00147, "epss_percentile": 0.3569}, "CVE-2023-40011": {"epss_score": 0.00084, "epss_percentile": 0.24861}, "CVE-2023-40012": {"epss_score": 0.00042, "epss_percentile": 0.12937}, "CVE-2023-40013": {"epss_score": 0.00145, "epss_percentile": 0.35375}, "CVE-2023-40014": {"epss_score": 0.00478, "epss_percentile": 0.6438}, "CVE-2023-40015": {"epss_score": 0.00072, "epss_percentile": 0.22437}, "CVE-2023-40017": {"epss_score": 0.00085, "epss_percentile": 0.25124}, "CVE-2023-40018": {"epss_score": 0.00551, "epss_percentile": 0.67352}, "CVE-2023-40019": {"epss_score": 0.00227, "epss_percentile": 0.45363}, "CVE-2023-40020": {"epss_score": 0.00186, "epss_percentile": 0.40685}, "CVE-2023-40021": {"epss_score": 0.00173, "epss_percentile": 0.39058}, "CVE-2023-40022": {"epss_score": 0.00073, "epss_percentile": 0.22647}, "CVE-2023-40023": {"epss_score": 0.00157, "epss_percentile": 0.371}, "CVE-2023-40024": {"epss_score": 0.00473, "epss_percentile": 0.641}, "CVE-2023-40025": {"epss_score": 0.00156, "epss_percentile": 0.36886}, "CVE-2023-40026": {"epss_score": 0.00214, "epss_percentile": 0.4399}, "CVE-2023-40027": {"epss_score": 0.00256, "epss_percentile": 0.4882}, "CVE-2023-40028": {"epss_score": 0.75814, "epss_percentile": 0.98865}, "CVE-2023-40029": {"epss_score": 0.00934, "epss_percentile": 0.75652}, "CVE-2023-40030": {"epss_score": 0.00098, "epss_percentile": 0.278}, "CVE-2023-40031": {"epss_score": 0.00359, "epss_percentile": 0.57607}, "CVE-2023-40032": {"epss_score": 0.00074, "epss_percentile": 0.22698}, "CVE-2023-40033": {"epss_score": 0.00204, "epss_percentile": 0.42637}, "CVE-2023-40034": {"epss_score": 0.00299, "epss_percentile": 0.52879}, "CVE-2023-40035": {"epss_score": 0.0025, "epss_percentile": 0.48097}, "CVE-2023-40036": {"epss_score": 0.00046, "epss_percentile": 0.14137}, "CVE-2023-40037": {"epss_score": 0.01837, "epss_percentile": 0.82483}, "CVE-2023-40038": {"epss_score": 0.0005, "epss_percentile": 0.15872}, "CVE-2023-40039": {"epss_score": 0.00533, "epss_percentile": 0.66712}, "CVE-2023-40040": {"epss_score": 0.00095, "epss_percentile": 0.27211}, "CVE-2023-40041": {"epss_score": 0.00286, "epss_percentile": 0.5175}, "CVE-2023-40042": {"epss_score": 0.00294, "epss_percentile": 0.5237}, "CVE-2023-40043": {"epss_score": 0.00468, "epss_percentile": 0.63869}, "CVE-2023-40044": {"epss_score": 0.94449, "epss_percentile": 0.9999}, "CVE-2023-40045": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2023-40046": {"epss_score": 0.00178, "epss_percentile": 0.39661}, "CVE-2023-40047": {"epss_score": 0.00021, "epss_percentile": 0.04728}, "CVE-2023-40048": {"epss_score": 0.00548, "epss_percentile": 0.67291}, "CVE-2023-40049": {"epss_score": 0.00379, "epss_percentile": 0.58862}, "CVE-2023-40050": {"epss_score": 0.09887, "epss_percentile": 0.92753}, "CVE-2023-40051": {"epss_score": 0.00024, "epss_percentile": 0.05813}, "CVE-2023-40052": {"epss_score": 0.0003, "epss_percentile": 0.08226}, "CVE-2023-40053": {"epss_score": 0.00056, "epss_percentile": 0.17892}, "CVE-2023-40054": {"epss_score": 0.01389, "epss_percentile": 0.7993}, "CVE-2023-40055": {"epss_score": 0.03552, "epss_percentile": 0.87343}, "CVE-2023-40056": {"epss_score": 0.00095, "epss_percentile": 0.27127}, "CVE-2023-40057": {"epss_score": 0.1168, "epss_percentile": 0.93444}, "CVE-2023-40058": {"epss_score": 0.00266, "epss_percentile": 0.49947}, "CVE-2023-40060": {"epss_score": 0.00032, "epss_percentile": 0.08817}, "CVE-2023-40061": {"epss_score": 0.00084, "epss_percentile": 0.24826}, "CVE-2023-40062": {"epss_score": 0.02414, "epss_percentile": 0.8468}, "CVE-2023-40067": {"epss_score": 0.00125, "epss_percentile": 0.32583}, "CVE-2023-40068": {"epss_score": 0.24752, "epss_percentile": 0.95951}, "CVE-2023-40069": {"epss_score": 0.00929, "epss_percentile": 0.75588}, "CVE-2023-40070": {"epss_score": 0.00156, "epss_percentile": 0.36933}, "CVE-2023-40071": {"epss_score": 0.00093, "epss_percentile": 0.26742}, "CVE-2023-40072": {"epss_score": 0.02097, "epss_percentile": 0.83591}, "CVE-2023-40073": {"epss_score": 0.00054, "epss_percentile": 0.17169}, "CVE-2023-40074": {"epss_score": 0.00089, "epss_percentile": 0.25947}, "CVE-2023-40075": {"epss_score": 0.00066, "epss_percentile": 0.20732}, "CVE-2023-40076": {"epss_score": 0.00012, "epss_percentile": 0.01411}, "CVE-2023-40077": {"epss_score": 0.0993, "epss_percentile": 0.92776}, "CVE-2023-40078": {"epss_score": 0.00106, "epss_percentile": 0.29481}, "CVE-2023-40079": {"epss_score": 6e-05, "epss_percentile": 0.00269}, "CVE-2023-40080": {"epss_score": 0.00039, "epss_percentile": 0.11805}, "CVE-2023-40081": {"epss_score": 0.00029, "epss_percentile": 0.07841}, "CVE-2023-40082": {"epss_score": 0.00984, "epss_percentile": 0.76312}, "CVE-2023-40083": {"epss_score": 0.00077, "epss_percentile": 0.23472}, "CVE-2023-40084": {"epss_score": 0.00054, "epss_percentile": 0.17151}, "CVE-2023-40085": {"epss_score": 0.00042, "epss_percentile": 0.12887}, "CVE-2023-40087": {"epss_score": 0.00079, "epss_percentile": 0.23992}, "CVE-2023-40088": {"epss_score": 0.00461, "epss_percentile": 0.63558}, "CVE-2023-40089": {"epss_score": 0.00036, "epss_percentile": 0.10513}, "CVE-2023-40090": {"epss_score": 0.00016, "epss_percentile": 0.02926}, "CVE-2023-40091": {"epss_score": 0.00038, "epss_percentile": 0.11092}, "CVE-2023-40092": {"epss_score": 0.00054, "epss_percentile": 0.17169}, "CVE-2023-40093": {"epss_score": 0.00047, "epss_percentile": 0.14581}, "CVE-2023-40094": {"epss_score": 5e-05, "epss_percentile": 0.00204}, "CVE-2023-40095": {"epss_score": 0.00038, "epss_percentile": 0.1132}, "CVE-2023-40096": {"epss_score": 0.00067, "epss_percentile": 0.21091}, "CVE-2023-40097": {"epss_score": 0.00029, "epss_percentile": 0.07814}, "CVE-2023-40098": {"epss_score": 0.00052, "epss_percentile": 0.16371}, "CVE-2023-40100": {"epss_score": 0.0002, "epss_percentile": 0.04483}, "CVE-2023-40101": {"epss_score": 0.00022, "epss_percentile": 0.0495}, "CVE-2023-40103": {"epss_score": 0.00114, "epss_percentile": 0.30856}, "CVE-2023-40104": {"epss_score": 0.00224, "epss_percentile": 0.4507}, "CVE-2023-40105": {"epss_score": 0.00019, "epss_percentile": 0.04166}, "CVE-2023-40106": {"epss_score": 3e-05, "epss_percentile": 0.00097}, "CVE-2023-40107": {"epss_score": 0.00021, "epss_percentile": 0.04731}, "CVE-2023-40108": {"epss_score": 0.00022, "epss_percentile": 0.04952}, "CVE-2023-40109": {"epss_score": 3e-05, "epss_percentile": 0.00082}, "CVE-2023-40110": {"epss_score": 0.00025, "epss_percentile": 0.06368}, "CVE-2023-40111": {"epss_score": 0.00019, "epss_percentile": 0.04357}, "CVE-2023-40112": {"epss_score": 0.00031, "epss_percentile": 0.08622}, "CVE-2023-40113": {"epss_score": 0.00019, "epss_percentile": 0.04166}, "CVE-2023-40114": {"epss_score": 0.0002, "epss_percentile": 0.04531}, "CVE-2023-40115": {"epss_score": 0.00046, "epss_percentile": 0.1417}, "CVE-2023-40116": {"epss_score": 5e-05, "epss_percentile": 0.00176}, "CVE-2023-40117": {"epss_score": 7e-05, "epss_percentile": 0.004}, "CVE-2023-40120": {"epss_score": 3e-05, "epss_percentile": 0.00069}, "CVE-2023-40121": {"epss_score": 0.00085, "epss_percentile": 0.25155}, "CVE-2023-40122": {"epss_score": 0.00053, "epss_percentile": 0.16684}, "CVE-2023-40123": {"epss_score": 4e-05, "epss_percentile": 0.00139}, "CVE-2023-40124": {"epss_score": 0.00021, "epss_percentile": 0.04946}, "CVE-2023-40125": {"epss_score": 3e-05, "epss_percentile": 0.00111}, "CVE-2023-40127": {"epss_score": 0.00023, "epss_percentile": 0.05467}, "CVE-2023-40128": {"epss_score": 0.00019, "epss_percentile": 0.0415}, "CVE-2023-40129": {"epss_score": 0.00038, "epss_percentile": 0.1128}, "CVE-2023-40130": {"epss_score": 0.00014, "epss_percentile": 0.01799}, "CVE-2023-40131": {"epss_score": 0.00014, "epss_percentile": 0.0205}, "CVE-2023-40132": {"epss_score": 7e-05, "epss_percentile": 0.00367}, "CVE-2023-40133": {"epss_score": 0.00038, "epss_percentile": 0.11274}, "CVE-2023-40134": {"epss_score": 0.00021, "epss_percentile": 0.04764}, "CVE-2023-40135": {"epss_score": 0.00021, "epss_percentile": 0.04764}, "CVE-2023-40136": {"epss_score": 0.00021, "epss_percentile": 0.04764}, "CVE-2023-40137": {"epss_score": 0.00021, "epss_percentile": 0.04764}, "CVE-2023-40138": {"epss_score": 0.00021, "epss_percentile": 0.04764}, "CVE-2023-40139": {"epss_score": 0.00023, "epss_percentile": 0.05347}, "CVE-2023-40140": {"epss_score": 0.00054, "epss_percentile": 0.17284}, "CVE-2023-40141": {"epss_score": 0.00029, "epss_percentile": 0.07898}, "CVE-2023-40142": {"epss_score": 7e-05, "epss_percentile": 0.00356}, "CVE-2023-40143": {"epss_score": 0.00098, "epss_percentile": 0.27718}, "CVE-2023-40144": {"epss_score": 0.08334, "epss_percentile": 0.91995}, "CVE-2023-40145": {"epss_score": 0.00406, "epss_percentile": 0.6053}, "CVE-2023-40146": {"epss_score": 0.01013, "epss_percentile": 0.76635}, "CVE-2023-40148": {"epss_score": 0.00083, "epss_percentile": 0.24631}, "CVE-2023-40150": {"epss_score": 0.00638, "epss_percentile": 0.69904}, "CVE-2023-40151": {"epss_score": 0.00254, "epss_percentile": 0.48562}, "CVE-2023-40152": {"epss_score": 0.00083, "epss_percentile": 0.24784}, "CVE-2023-40153": {"epss_score": 0.00259, "epss_percentile": 0.49092}, "CVE-2023-40154": {"epss_score": 0.00051, "epss_percentile": 0.16042}, "CVE-2023-40155": {"epss_score": 0.00042, "epss_percentile": 0.12478}, "CVE-2023-40156": {"epss_score": 0.00152, "epss_percentile": 0.36416}, "CVE-2023-40158": {"epss_score": 0.02562, "epss_percentile": 0.85107}, "CVE-2023-40160": {"epss_score": 0.00093, "epss_percentile": 0.26729}, "CVE-2023-40161": {"epss_score": 0.00063, "epss_percentile": 0.19856}, "CVE-2023-40163": {"epss_score": 0.00151, "epss_percentile": 0.36252}, "CVE-2023-40164": {"epss_score": 0.00082, "epss_percentile": 0.24449}, "CVE-2023-40165": {"epss_score": 0.00109, "epss_percentile": 0.30074}, "CVE-2023-40166": {"epss_score": 0.00082, "epss_percentile": 0.24449}, "CVE-2023-40167": {"epss_score": 0.05222, "epss_percentile": 0.89627}, "CVE-2023-40168": {"epss_score": 0.00243, "epss_percentile": 0.47411}, "CVE-2023-40170": {"epss_score": 0.00633, "epss_percentile": 0.69784}, "CVE-2023-40171": {"epss_score": 0.00102, "epss_percentile": 0.28871}, "CVE-2023-40172": {"epss_score": 0.00055, "epss_percentile": 0.17587}, "CVE-2023-40173": {"epss_score": 0.00065, "epss_percentile": 0.20523}, "CVE-2023-40174": {"epss_score": 0.00072, "epss_percentile": 0.22326}, "CVE-2023-40175": {"epss_score": 0.004, "epss_percentile": 0.60167}, "CVE-2023-40176": {"epss_score": 0.32094, "epss_percentile": 0.96671}, "CVE-2023-40177": {"epss_score": 0.02113, "epss_percentile": 0.83652}, "CVE-2023-40178": {"epss_score": 0.00041, "epss_percentile": 0.12312}, "CVE-2023-40179": {"epss_score": 0.00084, "epss_percentile": 0.2493}, "CVE-2023-40180": {"epss_score": 0.00585, "epss_percentile": 0.68427}, "CVE-2023-40181": {"epss_score": 0.00197, "epss_percentile": 0.41932}, "CVE-2023-40182": {"epss_score": 0.00084, "epss_percentile": 0.2493}, "CVE-2023-40183": {"epss_score": 0.00102, "epss_percentile": 0.28895}, "CVE-2023-40184": {"epss_score": 0.00049, "epss_percentile": 0.15327}, "CVE-2023-40185": {"epss_score": 0.00084, "epss_percentile": 0.24837}, "CVE-2023-40186": {"epss_score": 0.00112, "epss_percentile": 0.30456}, "CVE-2023-40187": {"epss_score": 0.00238, "epss_percentile": 0.46792}, "CVE-2023-40188": {"epss_score": 0.00074, "epss_percentile": 0.22695}, "CVE-2023-40191": {"epss_score": 0.00392, "epss_percentile": 0.5965}, "CVE-2023-40193": {"epss_score": 0.00092, "epss_percentile": 0.26562}, "CVE-2023-40194": {"epss_score": 0.00017, "epss_percentile": 0.03207}, "CVE-2023-40195": {"epss_score": 0.02599, "epss_percentile": 0.85203}, "CVE-2023-40196": {"epss_score": 0.0009, "epss_percentile": 0.261}, "CVE-2023-40197": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2023-40198": {"epss_score": 0.00047, "epss_percentile": 0.14827}, "CVE-2023-40199": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-40201": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-40202": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-40203": {"epss_score": 0.00385, "epss_percentile": 0.59203}, "CVE-2023-40204": {"epss_score": 0.00218, "epss_percentile": 0.44425}, "CVE-2023-40205": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-40206": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-40207": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-40208": {"epss_score": 0.06005, "epss_percentile": 0.90396}, "CVE-2023-40209": {"epss_score": 0.00174, "epss_percentile": 0.39145}, "CVE-2023-40210": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-40211": {"epss_score": 0.43263, "epss_percentile": 0.97379}, "CVE-2023-40212": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-40213": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-40214": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-40215": {"epss_score": 0.00199, "epss_percentile": 0.42156}, "CVE-2023-40216": {"epss_score": 0.0004, "epss_percentile": 0.11908}, "CVE-2023-40217": {"epss_score": 0.01749, "epss_percentile": 0.82084}, "CVE-2023-40218": {"epss_score": 0.00011, "epss_percentile": 0.01085}, "CVE-2023-40219": {"epss_score": 0.00457, "epss_percentile": 0.63375}, "CVE-2023-40220": {"epss_score": 0.0006, "epss_percentile": 0.19116}, "CVE-2023-40221": {"epss_score": 0.00105, "epss_percentile": 0.29278}, "CVE-2023-40222": {"epss_score": 0.00036, "epss_percentile": 0.10496}, "CVE-2023-40224": {"epss_score": 0.00095, "epss_percentile": 0.27086}, "CVE-2023-40225": {"epss_score": 0.00029, "epss_percentile": 0.07756}, "CVE-2023-40235": {"epss_score": 0.00243, "epss_percentile": 0.475}, "CVE-2023-40236": {"epss_score": 0.00037, "epss_percentile": 0.10976}, "CVE-2023-40238": {"epss_score": 0.00132, "epss_percentile": 0.33525}, "CVE-2023-40239": {"epss_score": 0.00206, "epss_percentile": 0.43069}, "CVE-2023-40250": {"epss_score": 0.00053, "epss_percentile": 0.16944}, "CVE-2023-40251": {"epss_score": 0.0003, "epss_percentile": 0.08031}, "CVE-2023-40252": {"epss_score": 0.00038, "epss_percentile": 0.11325}, "CVE-2023-40253": {"epss_score": 0.00034, "epss_percentile": 0.0973}, "CVE-2023-40254": {"epss_score": 0.0004, "epss_percentile": 0.12176}, "CVE-2023-40256": {"epss_score": 0.00137, "epss_percentile": 0.3422}, "CVE-2023-40260": {"epss_score": 0.00049, "epss_percentile": 0.15472}, "CVE-2023-40261": {"epss_score": 0.00176, "epss_percentile": 0.39409}, "CVE-2023-40262": {"epss_score": 0.00297, "epss_percentile": 0.52771}, "CVE-2023-40263": {"epss_score": 0.00503, "epss_percentile": 0.65464}, "CVE-2023-40264": {"epss_score": 0.00261, "epss_percentile": 0.49277}, "CVE-2023-40265": {"epss_score": 0.01385, "epss_percentile": 0.79906}, "CVE-2023-40266": {"epss_score": 0.00321, "epss_percentile": 0.54695}, "CVE-2023-40267": {"epss_score": 0.00382, "epss_percentile": 0.59032}, "CVE-2023-40271": {"epss_score": 0.00152, "epss_percentile": 0.36418}, "CVE-2023-40272": {"epss_score": 0.00576, "epss_percentile": 0.68134}, "CVE-2023-40273": {"epss_score": 0.00335, "epss_percentile": 0.55857}, "CVE-2023-40274": {"epss_score": 0.02034, "epss_percentile": 0.83347}, "CVE-2023-40275": {"epss_score": 0.0035, "epss_percentile": 0.56925}, "CVE-2023-40276": {"epss_score": 0.00665, "epss_percentile": 0.70652}, "CVE-2023-40277": {"epss_score": 0.00299, "epss_percentile": 0.52862}, "CVE-2023-40278": {"epss_score": 0.07553, "epss_percentile": 0.91537}, "CVE-2023-40279": {"epss_score": 0.17527, "epss_percentile": 0.94861}, "CVE-2023-40280": {"epss_score": 0.01104, "epss_percentile": 0.776}, "CVE-2023-40281": {"epss_score": 0.00353, "epss_percentile": 0.57182}, "CVE-2023-40282": {"epss_score": 0.00189, "epss_percentile": 0.40973}, "CVE-2023-40283": {"epss_score": 0.00011, "epss_percentile": 0.01004}, "CVE-2023-40284": {"epss_score": 0.00709, "epss_percentile": 0.71698}, "CVE-2023-40285": {"epss_score": 0.00249, "epss_percentile": 0.48038}, "CVE-2023-40286": {"epss_score": 0.00546, "epss_percentile": 0.67221}, "CVE-2023-40287": {"epss_score": 0.00546, "epss_percentile": 0.67221}, "CVE-2023-40288": {"epss_score": 0.00546, "epss_percentile": 0.67221}, "CVE-2023-40289": {"epss_score": 0.00208, "epss_percentile": 0.43255}, "CVE-2023-40290": {"epss_score": 0.00709, "epss_percentile": 0.71698}, "CVE-2023-40291": {"epss_score": 0.00082, "epss_percentile": 0.24556}, "CVE-2023-40292": {"epss_score": 0.00059, "epss_percentile": 0.18879}, "CVE-2023-40293": {"epss_score": 0.00359, "epss_percentile": 0.5757}, "CVE-2023-40294": {"epss_score": 0.01991, "epss_percentile": 0.83175}, "CVE-2023-40295": {"epss_score": 0.00876, "epss_percentile": 0.74786}, "CVE-2023-40296": {"epss_score": 0.02276, "epss_percentile": 0.84228}, "CVE-2023-40297": {"epss_score": 0.03994, "epss_percentile": 0.88082}, "CVE-2023-40299": {"epss_score": 0.0004, "epss_percentile": 0.12014}, "CVE-2023-40300": {"epss_score": 0.00608, "epss_percentile": 0.69085}, "CVE-2023-40301": {"epss_score": 0.01072, "epss_percentile": 0.77276}, "CVE-2023-40302": {"epss_score": 0.00369, "epss_percentile": 0.58242}, "CVE-2023-40303": {"epss_score": 0.00046, "epss_percentile": 0.14471}, "CVE-2023-40305": {"epss_score": 0.00076, "epss_percentile": 0.23105}, "CVE-2023-40306": {"epss_score": 0.00097, "epss_percentile": 0.2755}, "CVE-2023-40307": {"epss_score": 0.00079, "epss_percentile": 0.23941}, "CVE-2023-40308": {"epss_score": 0.00131, "epss_percentile": 0.33399}, "CVE-2023-40309": {"epss_score": 0.00162, "epss_percentile": 0.37618}, "CVE-2023-40310": {"epss_score": 0.00404, "epss_percentile": 0.60409}, "CVE-2023-40311": {"epss_score": 0.00133, "epss_percentile": 0.337}, "CVE-2023-40312": {"epss_score": 0.00149, "epss_percentile": 0.36013}, "CVE-2023-40313": {"epss_score": 0.00054, "epss_percentile": 0.17073}, "CVE-2023-40314": {"epss_score": 0.00215, "epss_percentile": 0.44024}, "CVE-2023-40315": {"epss_score": 0.03684, "epss_percentile": 0.87567}, "CVE-2023-40327": {"epss_score": 0.00157, "epss_percentile": 0.37064}, "CVE-2023-40328": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-40329": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-40330": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2023-40331": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-40332": {"epss_score": 0.00631, "epss_percentile": 0.69731}, "CVE-2023-40333": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2023-40334": {"epss_score": 0.00276, "epss_percentile": 0.50736}, "CVE-2023-40335": {"epss_score": 0.00061, "epss_percentile": 0.19251}, "CVE-2023-40336": {"epss_score": 0.00117, "epss_percentile": 0.31238}, "CVE-2023-40337": {"epss_score": 0.00062, "epss_percentile": 0.19647}, "CVE-2023-40338": {"epss_score": 0.00109, "epss_percentile": 0.29947}, "CVE-2023-40339": {"epss_score": 0.00251, "epss_percentile": 0.48287}, "CVE-2023-40340": {"epss_score": 0.00098, "epss_percentile": 0.27649}, "CVE-2023-40341": {"epss_score": 0.00421, "epss_percentile": 0.61525}, "CVE-2023-40342": {"epss_score": 0.04677, "epss_percentile": 0.88996}, "CVE-2023-40343": {"epss_score": 0.00101, "epss_percentile": 0.28681}, "CVE-2023-40344": {"epss_score": 0.00078, "epss_percentile": 0.23624}, "CVE-2023-40345": {"epss_score": 0.00127, "epss_percentile": 0.32828}, "CVE-2023-40346": {"epss_score": 0.01038, "epss_percentile": 0.7694}, "CVE-2023-40347": {"epss_score": 0.00114, "epss_percentile": 0.30869}, "CVE-2023-40348": {"epss_score": 0.00191, "epss_percentile": 0.41184}, "CVE-2023-40349": {"epss_score": 0.00157, "epss_percentile": 0.37017}, "CVE-2023-40350": {"epss_score": 0.02687, "epss_percentile": 0.8543}, "CVE-2023-40351": {"epss_score": 0.00048, "epss_percentile": 0.15228}, "CVE-2023-40352": {"epss_score": 0.00172, "epss_percentile": 0.38925}, "CVE-2023-40353": {"epss_score": 0.00033, "epss_percentile": 0.09333}, "CVE-2023-40354": {"epss_score": 0.00094, "epss_percentile": 0.2676}, "CVE-2023-40355": {"epss_score": 0.15395, "epss_percentile": 0.94423}, "CVE-2023-40356": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-40357": {"epss_score": 0.00098, "epss_percentile": 0.27697}, "CVE-2023-40359": {"epss_score": 0.00127, "epss_percentile": 0.32783}, "CVE-2023-40360": {"epss_score": 0.00041, "epss_percentile": 0.12343}, "CVE-2023-40361": {"epss_score": 0.00059, "epss_percentile": 0.18915}, "CVE-2023-40362": {"epss_score": 0.0478, "epss_percentile": 0.89136}, "CVE-2023-40363": {"epss_score": 0.00037, "epss_percentile": 0.10782}, "CVE-2023-40367": {"epss_score": 0.0006, "epss_percentile": 0.18964}, "CVE-2023-40368": {"epss_score": 0.00019, "epss_percentile": 0.04068}, "CVE-2023-40370": {"epss_score": 0.00066, "epss_percentile": 0.20707}, "CVE-2023-40371": {"epss_score": 0.0001, "epss_percentile": 0.00912}, "CVE-2023-40372": {"epss_score": 0.00035, "epss_percentile": 0.09969}, "CVE-2023-40373": {"epss_score": 0.00035, "epss_percentile": 0.09969}, "CVE-2023-40374": {"epss_score": 0.00039, "epss_percentile": 0.11582}, "CVE-2023-40375": {"epss_score": 0.0002, "epss_percentile": 0.04619}, "CVE-2023-40376": {"epss_score": 0.00031, "epss_percentile": 0.08688}, "CVE-2023-40377": {"epss_score": 0.00025, "epss_percentile": 0.06287}, "CVE-2023-40378": {"epss_score": 0.00024, "epss_percentile": 0.05668}, "CVE-2023-40383": {"epss_score": 0.00066, "epss_percentile": 0.20874}, "CVE-2023-40384": {"epss_score": 0.00019, "epss_percentile": 0.04053}, "CVE-2023-40385": {"epss_score": 0.00208, "epss_percentile": 0.43218}, "CVE-2023-40386": {"epss_score": 0.00119, "epss_percentile": 0.3161}, "CVE-2023-40388": {"epss_score": 0.00295, "epss_percentile": 0.52481}, "CVE-2023-40389": {"epss_score": 0.00041, "epss_percentile": 0.12362}, "CVE-2023-40390": {"epss_score": 0.00122, "epss_percentile": 0.32136}, "CVE-2023-40391": {"epss_score": 0.00021, "epss_percentile": 0.04783}, "CVE-2023-40392": {"epss_score": 0.00075, "epss_percentile": 0.23063}, "CVE-2023-40393": {"epss_score": 0.00368, "epss_percentile": 0.5819}, "CVE-2023-40394": {"epss_score": 0.00089, "epss_percentile": 0.25941}, "CVE-2023-40395": {"epss_score": 0.00023, "epss_percentile": 0.05649}, "CVE-2023-40396": {"epss_score": 0.00243, "epss_percentile": 0.47511}, "CVE-2023-40397": {"epss_score": 0.01195, "epss_percentile": 0.78433}, "CVE-2023-40398": {"epss_score": 0.00146, "epss_percentile": 0.35619}, "CVE-2023-40399": {"epss_score": 0.00021, "epss_percentile": 0.04783}, "CVE-2023-40400": {"epss_score": 0.01587, "epss_percentile": 0.81183}, "CVE-2023-40401": {"epss_score": 0.00089, "epss_percentile": 0.25945}, "CVE-2023-40402": {"epss_score": 0.00093, "epss_percentile": 0.26718}, "CVE-2023-40403": {"epss_score": 0.00126, "epss_percentile": 0.32628}, "CVE-2023-40404": {"epss_score": 0.01222, "epss_percentile": 0.78654}, "CVE-2023-40405": {"epss_score": 0.00047, "epss_percentile": 0.14584}, "CVE-2023-40406": {"epss_score": 0.00039, "epss_percentile": 0.1173}, "CVE-2023-40407": {"epss_score": 0.00758, "epss_percentile": 0.72765}, "CVE-2023-40408": {"epss_score": 0.00148, "epss_percentile": 0.35894}, "CVE-2023-40409": {"epss_score": 0.00027, "epss_percentile": 0.06746}, "CVE-2023-40410": {"epss_score": 0.0002, "epss_percentile": 0.04681}, "CVE-2023-40411": {"epss_score": 0.00122, "epss_percentile": 0.32136}, "CVE-2023-40412": {"epss_score": 0.00027, "epss_percentile": 0.06746}, "CVE-2023-40413": {"epss_score": 0.00026, "epss_percentile": 0.06568}, "CVE-2023-40414": {"epss_score": 0.00253, "epss_percentile": 0.48464}, "CVE-2023-40416": {"epss_score": 0.00218, "epss_percentile": 0.44421}, "CVE-2023-40417": {"epss_score": 0.00423, "epss_percentile": 0.61636}, "CVE-2023-40418": {"epss_score": 0.00131, "epss_percentile": 0.33491}, "CVE-2023-40419": {"epss_score": 0.00028, "epss_percentile": 0.07337}, "CVE-2023-40420": {"epss_score": 0.00199, "epss_percentile": 0.42113}, "CVE-2023-40421": {"epss_score": 0.00019, "epss_percentile": 0.04094}, "CVE-2023-40422": {"epss_score": 0.00086, "epss_percentile": 0.2544}, "CVE-2023-40423": {"epss_score": 0.00035, "epss_percentile": 0.09942}, "CVE-2023-40424": {"epss_score": 0.00048, "epss_percentile": 0.15251}, "CVE-2023-40425": {"epss_score": 0.00061, "epss_percentile": 0.19475}, "CVE-2023-40426": {"epss_score": 0.00028, "epss_percentile": 0.07572}, "CVE-2023-40427": {"epss_score": 0.00026, "epss_percentile": 0.06488}, "CVE-2023-40428": {"epss_score": 0.00123, "epss_percentile": 0.32322}, "CVE-2023-40429": {"epss_score": 0.00044, "epss_percentile": 0.13389}, "CVE-2023-40430": {"epss_score": 0.00124, "epss_percentile": 0.32464}, "CVE-2023-40431": {"epss_score": 0.00093, "epss_percentile": 0.26603}, "CVE-2023-40432": {"epss_score": 0.00035, "epss_percentile": 0.10067}, "CVE-2023-40433": {"epss_score": 0.00017, "epss_percentile": 0.03355}, "CVE-2023-40434": {"epss_score": 0.00051, "epss_percentile": 0.16264}, "CVE-2023-40435": {"epss_score": 0.00123, "epss_percentile": 0.32322}, "CVE-2023-40436": {"epss_score": 0.00393, "epss_percentile": 0.59718}, "CVE-2023-40437": {"epss_score": 0.00072, "epss_percentile": 0.22473}, "CVE-2023-40438": {"epss_score": 0.00061, "epss_percentile": 0.19391}, "CVE-2023-40439": {"epss_score": 0.00056, "epss_percentile": 0.17798}, "CVE-2023-40440": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2023-40441": {"epss_score": 0.00246, "epss_percentile": 0.47746}, "CVE-2023-40442": {"epss_score": 0.00047, "epss_percentile": 0.14584}, "CVE-2023-40443": {"epss_score": 0.00112, "epss_percentile": 0.30508}, "CVE-2023-40444": {"epss_score": 0.00031, "epss_percentile": 0.08678}, "CVE-2023-40445": {"epss_score": 0.0016, "epss_percentile": 0.37457}, "CVE-2023-40446": {"epss_score": 0.00038, "epss_percentile": 0.11179}, "CVE-2023-40447": {"epss_score": 0.00226, "epss_percentile": 0.45239}, "CVE-2023-40448": {"epss_score": 0.0163, "epss_percentile": 0.81443}, "CVE-2023-40449": {"epss_score": 0.00019, "epss_percentile": 0.04259}, "CVE-2023-40450": {"epss_score": 0.00031, "epss_percentile": 0.08334}, "CVE-2023-40451": {"epss_score": 0.00272, "epss_percentile": 0.50389}, "CVE-2023-40452": {"epss_score": 0.00021, "epss_percentile": 0.04805}, "CVE-2023-40453": {"epss_score": 0.00418, "epss_percentile": 0.61274}, "CVE-2023-40454": {"epss_score": 0.00026, "epss_percentile": 0.0638}, "CVE-2023-40455": {"epss_score": 0.00301, "epss_percentile": 0.53066}, "CVE-2023-40456": {"epss_score": 0.00027, "epss_percentile": 0.06875}, "CVE-2023-40457": {"epss_score": 0.00082, "epss_percentile": 0.24496}, "CVE-2023-40458": {"epss_score": 0.00016, "epss_percentile": 0.02813}, "CVE-2023-40459": {"epss_score": 0.013, "epss_percentile": 0.79288}, "CVE-2023-40460": {"epss_score": 4e-05, "epss_percentile": 0.0017}, "CVE-2023-40461": {"epss_score": 0.0001, "epss_percentile": 0.00796}, "CVE-2023-40462": {"epss_score": 0.00011, "epss_percentile": 0.01096}, "CVE-2023-40463": {"epss_score": 0.00015, "epss_percentile": 0.02475}, "CVE-2023-40464": {"epss_score": 8e-05, "epss_percentile": 0.00512}, "CVE-2023-40465": {"epss_score": 2e-05, "epss_percentile": 0.00031}, "CVE-2023-40468": {"epss_score": 0.00319, "epss_percentile": 0.54464}, "CVE-2023-40469": {"epss_score": 0.00319, "epss_percentile": 0.54464}, "CVE-2023-40470": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-40471": {"epss_score": 0.00646, "epss_percentile": 0.70132}, "CVE-2023-40472": {"epss_score": 0.00646, "epss_percentile": 0.70132}, "CVE-2023-40473": {"epss_score": 0.00182, "epss_percentile": 0.40253}, "CVE-2023-40474": {"epss_score": 0.07047, "epss_percentile": 0.9121}, "CVE-2023-40475": {"epss_score": 0.06534, "epss_percentile": 0.90826}, "CVE-2023-40476": {"epss_score": 0.09366, "epss_percentile": 0.92518}, "CVE-2023-40477": {"epss_score": 0.92803, "epss_percentile": 0.99751}, "CVE-2023-40478": {"epss_score": 0.00341, "epss_percentile": 0.56298}, "CVE-2023-40479": {"epss_score": 0.0213, "epss_percentile": 0.8371}, "CVE-2023-40480": {"epss_score": 0.0213, "epss_percentile": 0.8371}, "CVE-2023-40481": {"epss_score": 0.03476, "epss_percentile": 0.87208}, "CVE-2023-40482": {"epss_score": 0.00282, "epss_percentile": 0.51275}, "CVE-2023-40483": {"epss_score": 0.00297, "epss_percentile": 0.52684}, "CVE-2023-40484": {"epss_score": 0.00453, "epss_percentile": 0.6322}, "CVE-2023-40485": {"epss_score": 0.00453, "epss_percentile": 0.6322}, "CVE-2023-40486": {"epss_score": 0.00453, "epss_percentile": 0.6322}, "CVE-2023-40487": {"epss_score": 0.00317, "epss_percentile": 0.54379}, "CVE-2023-40488": {"epss_score": 0.00302, "epss_percentile": 0.53109}, "CVE-2023-40489": {"epss_score": 0.00308, "epss_percentile": 0.53593}, "CVE-2023-40490": {"epss_score": 0.00801, "epss_percentile": 0.73572}, "CVE-2023-40491": {"epss_score": 0.00302, "epss_percentile": 0.53109}, "CVE-2023-40492": {"epss_score": 0.39853, "epss_percentile": 0.97184}, "CVE-2023-40493": {"epss_score": 0.01986, "epss_percentile": 0.8316}, "CVE-2023-40494": {"epss_score": 0.39853, "epss_percentile": 0.97184}, "CVE-2023-40495": {"epss_score": 0.19153, "epss_percentile": 0.95139}, "CVE-2023-40496": {"epss_score": 0.19153, "epss_percentile": 0.95139}, "CVE-2023-40497": {"epss_score": 0.36579, "epss_percentile": 0.96989}, "CVE-2023-40498": {"epss_score": 0.89119, "epss_percentile": 0.99509}, "CVE-2023-40499": {"epss_score": 0.0188, "epss_percentile": 0.82684}, "CVE-2023-40500": {"epss_score": 0.01044, "epss_percentile": 0.77007}, "CVE-2023-40501": {"epss_score": 0.01044, "epss_percentile": 0.77007}, "CVE-2023-40502": {"epss_score": 0.27344, "epss_percentile": 0.96239}, "CVE-2023-40503": {"epss_score": 0.00074, "epss_percentile": 0.22774}, "CVE-2023-40504": {"epss_score": 0.91198, "epss_percentile": 0.99626}, "CVE-2023-40505": {"epss_score": 0.01711, "epss_percentile": 0.81878}, "CVE-2023-40506": {"epss_score": 0.00096, "epss_percentile": 0.27405}, "CVE-2023-40507": {"epss_score": 0.00083, "epss_percentile": 0.24606}, "CVE-2023-40508": {"epss_score": 0.01912, "epss_percentile": 0.82834}, "CVE-2023-40509": {"epss_score": 0.01912, "epss_percentile": 0.82834}, "CVE-2023-40510": {"epss_score": 0.00178, "epss_percentile": 0.39674}, "CVE-2023-40511": {"epss_score": 0.00178, "epss_percentile": 0.39674}, "CVE-2023-40512": {"epss_score": 0.00159, "epss_percentile": 0.37405}, "CVE-2023-40513": {"epss_score": 0.00159, "epss_percentile": 0.37405}, "CVE-2023-40514": {"epss_score": 0.00159, "epss_percentile": 0.37405}, "CVE-2023-40515": {"epss_score": 0.00206, "epss_percentile": 0.43032}, "CVE-2023-40516": {"epss_score": 0.00024, "epss_percentile": 0.05843}, "CVE-2023-40517": {"epss_score": 0.0125, "epss_percentile": 0.7888}, "CVE-2023-40518": {"epss_score": 0.00155, "epss_percentile": 0.368}, "CVE-2023-40519": {"epss_score": 0.00058, "epss_percentile": 0.18526}, "CVE-2023-40520": {"epss_score": 0.00027, "epss_percentile": 0.06875}, "CVE-2023-40528": {"epss_score": 6e-05, "epss_percentile": 0.00242}, "CVE-2023-40529": {"epss_score": 0.00125, "epss_percentile": 0.32536}, "CVE-2023-40530": {"epss_score": 0.00081, "epss_percentile": 0.24238}, "CVE-2023-40531": {"epss_score": 0.00092, "epss_percentile": 0.26562}, "CVE-2023-40532": {"epss_score": 0.00219, "epss_percentile": 0.44487}, "CVE-2023-40534": {"epss_score": 0.00571, "epss_percentile": 0.67986}, "CVE-2023-40535": {"epss_score": 0.00174, "epss_percentile": 0.39143}, "CVE-2023-40536": {"epss_score": 0.00056, "epss_percentile": 0.17682}, "CVE-2023-40537": {"epss_score": 0.00361, "epss_percentile": 0.57699}, "CVE-2023-40540": {"epss_score": 0.00057, "epss_percentile": 0.18169}, "CVE-2023-40541": {"epss_score": 0.00128, "epss_percentile": 0.33056}, "CVE-2023-40542": {"epss_score": 0.00576, "epss_percentile": 0.68145}, "CVE-2023-40544": {"epss_score": 0.00017, "epss_percentile": 0.03421}, "CVE-2023-40545": {"epss_score": 0.00066, "epss_percentile": 0.2085}, "CVE-2023-40546": {"epss_score": 0.00028, "epss_percentile": 0.07225}, "CVE-2023-40547": {"epss_score": 0.04175, "epss_percentile": 0.88351}, "CVE-2023-40548": {"epss_score": 0.00035, "epss_percentile": 0.09988}, "CVE-2023-40549": {"epss_score": 0.00028, "epss_percentile": 0.07225}, "CVE-2023-40550": {"epss_score": 0.00026, "epss_percentile": 0.06726}, "CVE-2023-40551": {"epss_score": 0.00016, "epss_percentile": 0.03039}, "CVE-2023-40552": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-40553": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-40554": {"epss_score": 0.00133, "epss_percentile": 0.33632}, "CVE-2023-40555": {"epss_score": 0.00151, "epss_percentile": 0.36186}, "CVE-2023-40556": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-40557": {"epss_score": 0.00212, "epss_percentile": 0.43785}, "CVE-2023-40558": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-40559": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-40560": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-40561": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-40567": {"epss_score": 0.00245, "epss_percentile": 0.47675}, "CVE-2023-40569": {"epss_score": 0.00112, "epss_percentile": 0.30456}, "CVE-2023-40570": {"epss_score": 0.00325, "epss_percentile": 0.55}, "CVE-2023-40571": {"epss_score": 0.01722, "epss_percentile": 0.8194}, "CVE-2023-40572": {"epss_score": 0.01802, "epss_percentile": 0.82333}, "CVE-2023-40573": {"epss_score": 0.03522, "epss_percentile": 0.87289}, "CVE-2023-40574": {"epss_score": 0.00125, "epss_percentile": 0.32548}, "CVE-2023-40575": {"epss_score": 0.00123, "epss_percentile": 0.32293}, "CVE-2023-40576": {"epss_score": 0.00118, "epss_percentile": 0.31387}, "CVE-2023-40577": {"epss_score": 0.01994, "epss_percentile": 0.83188}, "CVE-2023-40579": {"epss_score": 0.00065, "epss_percentile": 0.20648}, "CVE-2023-40580": {"epss_score": 0.00066, "epss_percentile": 0.20694}, "CVE-2023-40581": {"epss_score": 0.09992, "epss_percentile": 0.92807}, "CVE-2023-40582": {"epss_score": 0.0684, "epss_percentile": 0.91061}, "CVE-2023-40583": {"epss_score": 0.00241, "epss_percentile": 0.47325}, "CVE-2023-40584": {"epss_score": 0.0053, "epss_percentile": 0.66627}, "CVE-2023-40585": {"epss_score": 0.00104, "epss_percentile": 0.29188}, "CVE-2023-40586": {"epss_score": 0.0023, "epss_percentile": 0.45695}, "CVE-2023-40587": {"epss_score": 0.00448, "epss_percentile": 0.63022}, "CVE-2023-40588": {"epss_score": 0.00089, "epss_percentile": 0.25804}, "CVE-2023-40589": {"epss_score": 0.00145, "epss_percentile": 0.35399}, "CVE-2023-40590": {"epss_score": 0.00387, "epss_percentile": 0.59287}, "CVE-2023-40591": {"epss_score": 0.00315, "epss_percentile": 0.54201}, "CVE-2023-40592": {"epss_score": 0.00262, "epss_percentile": 0.49381}, "CVE-2023-40593": {"epss_score": 0.00164, "epss_percentile": 0.37968}, "CVE-2023-40594": {"epss_score": 0.00149, "epss_percentile": 0.35933}, "CVE-2023-40595": {"epss_score": 0.0056, "epss_percentile": 0.67655}, "CVE-2023-40596": {"epss_score": 0.00066, "epss_percentile": 0.20932}, "CVE-2023-40597": {"epss_score": 0.0007, "epss_percentile": 0.21957}, "CVE-2023-40598": {"epss_score": 0.0011, "epss_percentile": 0.30215}, "CVE-2023-40599": {"epss_score": 0.00541, "epss_percentile": 0.67052}, "CVE-2023-40600": {"epss_score": 0.16364, "epss_percentile": 0.94636}, "CVE-2023-40601": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-40602": {"epss_score": 0.00114, "epss_percentile": 0.30766}, "CVE-2023-40603": {"epss_score": 0.00206, "epss_percentile": 0.42925}, "CVE-2023-40604": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-40605": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2023-40606": {"epss_score": 0.00483, "epss_percentile": 0.64566}, "CVE-2023-40607": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-40608": {"epss_score": 0.0014, "epss_percentile": 0.34683}, "CVE-2023-40609": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-40610": {"epss_score": 0.00313, "epss_percentile": 0.54011}, "CVE-2023-40611": {"epss_score": 0.00124, "epss_percentile": 0.32343}, "CVE-2023-40612": {"epss_score": 0.00037, "epss_percentile": 0.10655}, "CVE-2023-40617": {"epss_score": 0.00106, "epss_percentile": 0.29476}, "CVE-2023-40618": {"epss_score": 0.00106, "epss_percentile": 0.29476}, "CVE-2023-40619": {"epss_score": 0.03455, "epss_percentile": 0.87172}, "CVE-2023-40621": {"epss_score": 0.00336, "epss_percentile": 0.55952}, "CVE-2023-40622": {"epss_score": 0.00132, "epss_percentile": 0.33558}, "CVE-2023-40623": {"epss_score": 0.00153, "epss_percentile": 0.36618}, "CVE-2023-40624": {"epss_score": 0.0011, "epss_percentile": 0.30086}, "CVE-2023-40625": {"epss_score": 0.00147, "epss_percentile": 0.35788}, "CVE-2023-40626": {"epss_score": 0.00031, "epss_percentile": 0.08567}, "CVE-2023-40627": {"epss_score": 0.00574, "epss_percentile": 0.68084}, "CVE-2023-40628": {"epss_score": 0.00574, "epss_percentile": 0.68084}, "CVE-2023-40629": {"epss_score": 0.00731, "epss_percentile": 0.72184}, "CVE-2023-40630": {"epss_score": 0.00277, "epss_percentile": 0.50833}, "CVE-2023-40631": {"epss_score": 0.00012, "epss_percentile": 0.01349}, "CVE-2023-40632": {"epss_score": 0.00498, "epss_percentile": 0.65229}, "CVE-2023-40633": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-40634": {"epss_score": 0.00027, "epss_percentile": 0.06748}, "CVE-2023-40635": {"epss_score": 0.00027, "epss_percentile": 0.06748}, "CVE-2023-40636": {"epss_score": 0.00012, "epss_percentile": 0.01349}, "CVE-2023-40637": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-40638": {"epss_score": 0.00012, "epss_percentile": 0.01161}, "CVE-2023-40639": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-40640": {"epss_score": 0.00017, "epss_percentile": 0.03207}, "CVE-2023-40641": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-40642": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-40643": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-40644": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-40645": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-40646": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-40647": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-40648": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-40649": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2023-40650": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-40651": {"epss_score": 9e-05, "epss_percentile": 0.00733}, "CVE-2023-40652": {"epss_score": 7e-05, "epss_percentile": 0.00402}, "CVE-2023-40653": {"epss_score": 7e-05, "epss_percentile": 0.00387}, "CVE-2023-40654": {"epss_score": 7e-05, "epss_percentile": 0.00387}, "CVE-2023-40655": {"epss_score": 0.00574, "epss_percentile": 0.68084}, "CVE-2023-40656": {"epss_score": 0.00574, "epss_percentile": 0.68084}, "CVE-2023-40657": {"epss_score": 0.00574, "epss_percentile": 0.68084}, "CVE-2023-40658": {"epss_score": 0.00574, "epss_percentile": 0.68084}, "CVE-2023-40659": {"epss_score": 0.00574, "epss_percentile": 0.68084}, "CVE-2023-40660": {"epss_score": 0.0004, "epss_percentile": 0.12135}, "CVE-2023-40661": {"epss_score": 0.0032, "epss_percentile": 0.54638}, "CVE-2023-40662": {"epss_score": 0.00693, "epss_percentile": 0.71319}, "CVE-2023-40663": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2023-40664": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-40665": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-40667": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-40668": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2023-40669": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2023-40670": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-40671": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-40672": {"epss_score": 0.00125, "epss_percentile": 0.32582}, "CVE-2023-40673": {"epss_score": 0.00279, "epss_percentile": 0.50997}, "CVE-2023-40674": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-40675": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2023-40676": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-40677": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-40678": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-40679": {"epss_score": 0.00071, "epss_percentile": 0.22155}, "CVE-2023-40680": {"epss_score": 0.0016, "epss_percentile": 0.37502}, "CVE-2023-40681": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-40682": {"epss_score": 0.00019, "epss_percentile": 0.04068}, "CVE-2023-40683": {"epss_score": 0.00024, "epss_percentile": 0.05897}, "CVE-2023-40684": {"epss_score": 0.00074, "epss_percentile": 0.22708}, "CVE-2023-40685": {"epss_score": 0.00021, "epss_percentile": 0.04797}, "CVE-2023-40686": {"epss_score": 0.00024, "epss_percentile": 0.06013}, "CVE-2023-40687": {"epss_score": 0.00117, "epss_percentile": 0.31329}, "CVE-2023-40691": {"epss_score": 0.0005, "epss_percentile": 0.15655}, "CVE-2023-40692": {"epss_score": 0.00077, "epss_percentile": 0.23466}, "CVE-2023-40694": {"epss_score": 0.00037, "epss_percentile": 0.10895}, "CVE-2023-40695": {"epss_score": 0.00036, "epss_percentile": 0.10543}, "CVE-2023-40696": {"epss_score": 0.00047, "epss_percentile": 0.14497}, "CVE-2023-40699": {"epss_score": 0.00068, "epss_percentile": 0.21254}, "CVE-2023-40702": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-40703": {"epss_score": 0.00091, "epss_percentile": 0.26293}, "CVE-2023-40704": {"epss_score": 0.00079, "epss_percentile": 0.23849}, "CVE-2023-40705": {"epss_score": 0.00174, "epss_percentile": 0.39143}, "CVE-2023-40706": {"epss_score": 0.00079, "epss_percentile": 0.2394}, "CVE-2023-40707": {"epss_score": 0.00058, "epss_percentile": 0.18369}, "CVE-2023-40708": {"epss_score": 0.00108, "epss_percentile": 0.29764}, "CVE-2023-40709": {"epss_score": 0.00091, "epss_percentile": 0.26243}, "CVE-2023-40710": {"epss_score": 0.00091, "epss_percentile": 0.26243}, "CVE-2023-40711": {"epss_score": 0.00182, "epss_percentile": 0.40218}, "CVE-2023-40712": {"epss_score": 0.00136, "epss_percentile": 0.34161}, "CVE-2023-40714": {"epss_score": 0.00363, "epss_percentile": 0.57895}, "CVE-2023-40715": {"epss_score": 0.00063, "epss_percentile": 0.20078}, "CVE-2023-40716": {"epss_score": 0.00074, "epss_percentile": 0.22879}, "CVE-2023-40717": {"epss_score": 0.00073, "epss_percentile": 0.22573}, "CVE-2023-40718": {"epss_score": 0.00031, "epss_percentile": 0.08682}, "CVE-2023-40719": {"epss_score": 0.00045, "epss_percentile": 0.13792}, "CVE-2023-40720": {"epss_score": 0.00041, "epss_percentile": 0.12318}, "CVE-2023-40721": {"epss_score": 0.00035, "epss_percentile": 0.10047}, "CVE-2023-40723": {"epss_score": 0.00145, "epss_percentile": 0.35457}, "CVE-2023-40724": {"epss_score": 0.00034, "epss_percentile": 0.09571}, "CVE-2023-40725": {"epss_score": 0.00078, "epss_percentile": 0.23664}, "CVE-2023-40726": {"epss_score": 0.00141, "epss_percentile": 0.34811}, "CVE-2023-40727": {"epss_score": 0.00035, "epss_percentile": 0.09855}, "CVE-2023-40728": {"epss_score": 0.00063, "epss_percentile": 0.19866}, "CVE-2023-40729": {"epss_score": 0.00182, "epss_percentile": 0.40265}, "CVE-2023-40730": {"epss_score": 0.00124, "epss_percentile": 0.32434}, "CVE-2023-40731": {"epss_score": 0.00156, "epss_percentile": 0.37009}, "CVE-2023-40732": {"epss_score": 0.00102, "epss_percentile": 0.28752}, "CVE-2023-40735": {"epss_score": 0.00147, "epss_percentile": 0.35745}, "CVE-2023-40743": {"epss_score": 0.00991, "epss_percentile": 0.76384}, "CVE-2023-40745": {"epss_score": 0.00259, "epss_percentile": 0.49034}, "CVE-2023-40747": {"epss_score": 0.00085, "epss_percentile": 0.2509}, "CVE-2023-40748": {"epss_score": 0.44459, "epss_percentile": 0.97438}, "CVE-2023-40749": {"epss_score": 0.24809, "epss_percentile": 0.95956}, "CVE-2023-40750": {"epss_score": 0.01268, "epss_percentile": 0.79028}, "CVE-2023-40751": {"epss_score": 0.0114, "epss_percentile": 0.77953}, "CVE-2023-40752": {"epss_score": 0.01268, "epss_percentile": 0.79028}, "CVE-2023-40753": {"epss_score": 0.00833, "epss_percentile": 0.74088}, "CVE-2023-40754": {"epss_score": 0.00357, "epss_percentile": 0.57457}, "CVE-2023-40755": {"epss_score": 0.01363, "epss_percentile": 0.79764}, "CVE-2023-40756": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-40757": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-40758": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-40759": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-40760": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-40761": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-40762": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-40763": {"epss_score": 0.00313, "epss_percentile": 0.54071}, "CVE-2023-40764": {"epss_score": 0.00107, "epss_percentile": 0.29629}, "CVE-2023-40765": {"epss_score": 0.00107, "epss_percentile": 0.29629}, "CVE-2023-40766": {"epss_score": 0.00107, "epss_percentile": 0.29629}, "CVE-2023-40767": {"epss_score": 0.00107, "epss_percentile": 0.29629}, "CVE-2023-40771": {"epss_score": 0.00149, "epss_percentile": 0.36044}, "CVE-2023-40779": {"epss_score": 0.28157, "epss_percentile": 0.96327}, "CVE-2023-40781": {"epss_score": 0.00238, "epss_percentile": 0.46786}, "CVE-2023-40784": {"epss_score": 0.00167, "epss_percentile": 0.38308}, "CVE-2023-40786": {"epss_score": 0.00085, "epss_percentile": 0.25145}, "CVE-2023-40787": {"epss_score": 0.01158, "epss_percentile": 0.78121}, "CVE-2023-40788": {"epss_score": 0.00072, "epss_percentile": 0.22363}, "CVE-2023-40791": {"epss_score": 0.00042, "epss_percentile": 0.12816}, "CVE-2023-40796": {"epss_score": 0.0011, "epss_percentile": 0.302}, "CVE-2023-40797": {"epss_score": 0.00123, "epss_percentile": 0.32259}, "CVE-2023-40798": {"epss_score": 0.00123, "epss_percentile": 0.32259}, "CVE-2023-40799": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40800": {"epss_score": 0.00123, "epss_percentile": 0.32259}, "CVE-2023-40801": {"epss_score": 0.00121, "epss_percentile": 0.31882}, "CVE-2023-40802": {"epss_score": 0.00054, "epss_percentile": 0.17246}, "CVE-2023-40809": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-40810": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-40812": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-40813": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-40814": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-40815": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-40816": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-40817": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-40819": {"epss_score": 0.00257, "epss_percentile": 0.48846}, "CVE-2023-40825": {"epss_score": 0.00982, "epss_percentile": 0.76288}, "CVE-2023-40826": {"epss_score": 0.00665, "epss_percentile": 0.70655}, "CVE-2023-40827": {"epss_score": 0.00563, "epss_percentile": 0.67741}, "CVE-2023-40828": {"epss_score": 0.00778, "epss_percentile": 0.73125}, "CVE-2023-40829": {"epss_score": 0.00082, "epss_percentile": 0.24462}, "CVE-2023-40830": {"epss_score": 0.00126, "epss_percentile": 0.32683}, "CVE-2023-40833": {"epss_score": 0.00436, "epss_percentile": 0.6246}, "CVE-2023-40834": {"epss_score": 0.0042, "epss_percentile": 0.6146}, "CVE-2023-40837": {"epss_score": 0.00114, "epss_percentile": 0.3076}, "CVE-2023-40838": {"epss_score": 0.00153, "epss_percentile": 0.36595}, "CVE-2023-40839": {"epss_score": 0.00114, "epss_percentile": 0.3076}, "CVE-2023-40840": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40841": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40842": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40843": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40844": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40845": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40846": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40847": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40848": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40850": {"epss_score": 0.00713, "epss_percentile": 0.71797}, "CVE-2023-40851": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-40852": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-40857": {"epss_score": 0.01304, "epss_percentile": 0.7932}, "CVE-2023-40868": {"epss_score": 0.03747, "epss_percentile": 0.87664}, "CVE-2023-40869": {"epss_score": 0.05595, "epss_percentile": 0.90034}, "CVE-2023-40874": {"epss_score": 0.00072, "epss_percentile": 0.22406}, "CVE-2023-40875": {"epss_score": 0.00072, "epss_percentile": 0.22406}, "CVE-2023-40876": {"epss_score": 0.00072, "epss_percentile": 0.22406}, "CVE-2023-40877": {"epss_score": 0.00072, "epss_percentile": 0.22406}, "CVE-2023-40889": {"epss_score": 0.00545, "epss_percentile": 0.67178}, "CVE-2023-40890": {"epss_score": 0.00137, "epss_percentile": 0.34259}, "CVE-2023-40891": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40892": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40893": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40894": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40895": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40896": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40897": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40898": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40899": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40900": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40901": {"epss_score": 0.00134, "epss_percentile": 0.33826}, "CVE-2023-40902": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40904": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40915": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-40918": {"epss_score": 0.00179, "epss_percentile": 0.39828}, "CVE-2023-40920": {"epss_score": 0.0007, "epss_percentile": 0.21648}, "CVE-2023-40921": {"epss_score": 0.0016, "epss_percentile": 0.37491}, "CVE-2023-40922": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-40923": {"epss_score": 0.00069, "epss_percentile": 0.21594}, "CVE-2023-40924": {"epss_score": 0.09128, "epss_percentile": 0.92413}, "CVE-2023-40930": {"epss_score": 0.12956, "epss_percentile": 0.9383}, "CVE-2023-40931": {"epss_score": 0.86844, "epss_percentile": 0.99401}, "CVE-2023-40932": {"epss_score": 0.01959, "epss_percentile": 0.83054}, "CVE-2023-40933": {"epss_score": 0.18083, "epss_percentile": 0.94954}, "CVE-2023-40934": {"epss_score": 0.01173, "epss_percentile": 0.78235}, "CVE-2023-40942": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-40944": {"epss_score": 0.00061, "epss_percentile": 0.19297}, "CVE-2023-40945": {"epss_score": 0.00178, "epss_percentile": 0.39694}, "CVE-2023-40946": {"epss_score": 0.00056, "epss_percentile": 0.17748}, "CVE-2023-40953": {"epss_score": 0.0007, "epss_percentile": 0.2169}, "CVE-2023-40954": {"epss_score": 0.00619, "epss_percentile": 0.69429}, "CVE-2023-40955": {"epss_score": 0.01943, "epss_percentile": 0.82994}, "CVE-2023-40956": {"epss_score": 0.00865, "epss_percentile": 0.74618}, "CVE-2023-40957": {"epss_score": 0.01943, "epss_percentile": 0.82994}, "CVE-2023-40958": {"epss_score": 0.03229, "epss_percentile": 0.86693}, "CVE-2023-40968": {"epss_score": 0.00425, "epss_percentile": 0.61714}, "CVE-2023-40969": {"epss_score": 0.00098, "epss_percentile": 0.27771}, "CVE-2023-40970": {"epss_score": 0.00087, "epss_percentile": 0.25588}, "CVE-2023-40980": {"epss_score": 0.01289, "epss_percentile": 0.79214}, "CVE-2023-40982": {"epss_score": 0.0026, "epss_percentile": 0.49169}, "CVE-2023-40983": {"epss_score": 0.00878, "epss_percentile": 0.74832}, "CVE-2023-40984": {"epss_score": 0.00353, "epss_percentile": 0.57169}, "CVE-2023-40985": {"epss_score": 0.0026, "epss_percentile": 0.49169}, "CVE-2023-40986": {"epss_score": 0.0026, "epss_percentile": 0.49169}, "CVE-2023-40989": {"epss_score": 0.38139, "epss_percentile": 0.97087}, "CVE-2023-40992": {"epss_score": 0.0002, "epss_percentile": 0.04642}, "CVE-2023-40997": {"epss_score": 0.00341, "epss_percentile": 0.56346}, "CVE-2023-40998": {"epss_score": 0.00857, "epss_percentile": 0.74494}, "CVE-2023-41000": {"epss_score": 0.00028, "epss_percentile": 0.07316}, "CVE-2023-41005": {"epss_score": 0.00907, "epss_percentile": 0.75264}, "CVE-2023-41009": {"epss_score": 0.02804, "epss_percentile": 0.85704}, "CVE-2023-41010": {"epss_score": 0.00053, "epss_percentile": 0.17004}, "CVE-2023-41011": {"epss_score": 0.08638, "epss_percentile": 0.92166}, "CVE-2023-41012": {"epss_score": 0.05524, "epss_percentile": 0.89961}, "CVE-2023-41013": {"epss_score": 0.00172, "epss_percentile": 0.38956}, "CVE-2023-41014": {"epss_score": 0.00158, "epss_percentile": 0.37179}, "CVE-2023-41015": {"epss_score": 0.00099, "epss_percentile": 0.28354}, "CVE-2023-41027": {"epss_score": 0.00083, "epss_percentile": 0.24602}, "CVE-2023-41028": {"epss_score": 0.00109, "epss_percentile": 0.29984}, "CVE-2023-41029": {"epss_score": 0.00175, "epss_percentile": 0.39339}, "CVE-2023-41030": {"epss_score": 0.00112, "epss_percentile": 0.30433}, "CVE-2023-41031": {"epss_score": 0.00259, "epss_percentile": 0.49082}, "CVE-2023-41032": {"epss_score": 0.0012, "epss_percentile": 0.31765}, "CVE-2023-41033": {"epss_score": 0.00117, "epss_percentile": 0.313}, "CVE-2023-41034": {"epss_score": 0.00109, "epss_percentile": 0.30005}, "CVE-2023-41036": {"epss_score": 0.00166, "epss_percentile": 0.38197}, "CVE-2023-41037": {"epss_score": 0.00076, "epss_percentile": 0.23093}, "CVE-2023-41038": {"epss_score": 0.00109, "epss_percentile": 0.29931}, "CVE-2023-41039": {"epss_score": 0.0008, "epss_percentile": 0.24169}, "CVE-2023-41040": {"epss_score": 0.00391, "epss_percentile": 0.59566}, "CVE-2023-41041": {"epss_score": 0.00223, "epss_percentile": 0.44897}, "CVE-2023-41042": {"epss_score": 0.00054, "epss_percentile": 0.1726}, "CVE-2023-41043": {"epss_score": 0.00089, "epss_percentile": 0.25804}, "CVE-2023-41044": {"epss_score": 0.00203, "epss_percentile": 0.42582}, "CVE-2023-41045": {"epss_score": 0.00134, "epss_percentile": 0.33832}, "CVE-2023-41046": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2023-41047": {"epss_score": 0.00127, "epss_percentile": 0.32891}, "CVE-2023-41048": {"epss_score": 0.00503, "epss_percentile": 0.65446}, "CVE-2023-41049": {"epss_score": 0.00291, "epss_percentile": 0.5217}, "CVE-2023-41050": {"epss_score": 0.00235, "epss_percentile": 0.46338}, "CVE-2023-41051": {"epss_score": 0.00018, "epss_percentile": 0.03827}, "CVE-2023-41052": {"epss_score": 0.0007, "epss_percentile": 0.21662}, "CVE-2023-41053": {"epss_score": 0.00644, "epss_percentile": 0.70082}, "CVE-2023-41054": {"epss_score": 0.0079, "epss_percentile": 0.7337}, "CVE-2023-41055": {"epss_score": 0.00504, "epss_percentile": 0.65488}, "CVE-2023-41056": {"epss_score": 0.06792, "epss_percentile": 0.91029}, "CVE-2023-41057": {"epss_score": 0.00079, "epss_percentile": 0.23976}, "CVE-2023-41058": {"epss_score": 0.00214, "epss_percentile": 0.4398}, "CVE-2023-41060": {"epss_score": 0.01949, "epss_percentile": 0.8301}, "CVE-2023-41061": {"epss_score": 0.00985, "epss_percentile": 0.7632}, "CVE-2023-41063": {"epss_score": 0.00035, "epss_percentile": 0.09811}, "CVE-2023-41064": {"epss_score": 0.89898, "epss_percentile": 0.99548}, "CVE-2023-41065": {"epss_score": 0.00024, "epss_percentile": 0.06006}, "CVE-2023-41066": {"epss_score": 0.00128, "epss_percentile": 0.33026}, "CVE-2023-41067": {"epss_score": 0.00039, "epss_percentile": 0.11638}, "CVE-2023-41068": {"epss_score": 0.00027, "epss_percentile": 0.069}, "CVE-2023-41069": {"epss_score": 0.00079, "epss_percentile": 0.23999}, "CVE-2023-41070": {"epss_score": 0.00041, "epss_percentile": 0.12235}, "CVE-2023-41071": {"epss_score": 0.00046, "epss_percentile": 0.14181}, "CVE-2023-41072": {"epss_score": 0.00023, "epss_percentile": 0.05624}, "CVE-2023-41073": {"epss_score": 0.00032, "epss_percentile": 0.08774}, "CVE-2023-41074": {"epss_score": 0.01121, "epss_percentile": 0.7777}, "CVE-2023-41075": {"epss_score": 0.00139, "epss_percentile": 0.34615}, "CVE-2023-41076": {"epss_score": 0.00049, "epss_percentile": 0.15314}, "CVE-2023-41077": {"epss_score": 0.00051, "epss_percentile": 0.16177}, "CVE-2023-41078": {"epss_score": 0.00034, "epss_percentile": 0.09454}, "CVE-2023-41079": {"epss_score": 0.00028, "epss_percentile": 0.07572}, "CVE-2023-41080": {"epss_score": 0.11344, "epss_percentile": 0.93317}, "CVE-2023-41081": {"epss_score": 0.00025, "epss_percentile": 0.06155}, "CVE-2023-41082": {"epss_score": 0.00055, "epss_percentile": 0.17602}, "CVE-2023-41084": {"epss_score": 0.00073, "epss_percentile": 0.22568}, "CVE-2023-41085": {"epss_score": 0.00576, "epss_percentile": 0.68145}, "CVE-2023-41086": {"epss_score": 0.00321, "epss_percentile": 0.54676}, "CVE-2023-41088": {"epss_score": 0.00087, "epss_percentile": 0.25529}, "CVE-2023-41089": {"epss_score": 0.00221, "epss_percentile": 0.44646}, "CVE-2023-41090": {"epss_score": 0.00026, "epss_percentile": 0.06438}, "CVE-2023-41091": {"epss_score": 0.00144, "epss_percentile": 0.35344}, "CVE-2023-41092": {"epss_score": 0.00081, "epss_percentile": 0.24355}, "CVE-2023-41093": {"epss_score": 0.00154, "epss_percentile": 0.36739}, "CVE-2023-41094": {"epss_score": 0.00081, "epss_percentile": 0.24294}, "CVE-2023-41095": {"epss_score": 0.00036, "epss_percentile": 0.10409}, "CVE-2023-41096": {"epss_score": 0.00018, "epss_percentile": 0.03941}, "CVE-2023-41097": {"epss_score": 0.00107, "epss_percentile": 0.29588}, "CVE-2023-41098": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-41099": {"epss_score": 0.00044, "epss_percentile": 0.13414}, "CVE-2023-41100": {"epss_score": 0.00085, "epss_percentile": 0.2504}, "CVE-2023-41101": {"epss_score": 0.05439, "epss_percentile": 0.89883}, "CVE-2023-41102": {"epss_score": 0.0009, "epss_percentile": 0.26151}, "CVE-2023-41103": {"epss_score": 0.00098, "epss_percentile": 0.27697}, "CVE-2023-41104": {"epss_score": 0.0018, "epss_percentile": 0.39916}, "CVE-2023-41105": {"epss_score": 0.0037, "epss_percentile": 0.58342}, "CVE-2023-41106": {"epss_score": 0.00369, "epss_percentile": 0.58261}, "CVE-2023-41107": {"epss_score": 0.0041, "epss_percentile": 0.60841}, "CVE-2023-41108": {"epss_score": 0.0222, "epss_percentile": 0.84049}, "CVE-2023-41109": {"epss_score": 0.92122, "epss_percentile": 0.99692}, "CVE-2023-41111": {"epss_score": 0.00318, "epss_percentile": 0.54449}, "CVE-2023-41112": {"epss_score": 0.00192, "epss_percentile": 0.41323}, "CVE-2023-41113": {"epss_score": 0.0009, "epss_percentile": 0.25995}, "CVE-2023-41114": {"epss_score": 0.00084, "epss_percentile": 0.24971}, "CVE-2023-41115": {"epss_score": 0.0014, "epss_percentile": 0.34698}, "CVE-2023-41116": {"epss_score": 0.00062, "epss_percentile": 0.19676}, "CVE-2023-41117": {"epss_score": 0.00077, "epss_percentile": 0.2329}, "CVE-2023-41118": {"epss_score": 0.00065, "epss_percentile": 0.20446}, "CVE-2023-41119": {"epss_score": 0.0008, "epss_percentile": 0.24085}, "CVE-2023-41120": {"epss_score": 0.00046, "epss_percentile": 0.14125}, "CVE-2023-41121": {"epss_score": 0.00682, "epss_percentile": 0.71066}, "CVE-2023-41127": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-41128": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-41129": {"epss_score": 0.00137, "epss_percentile": 0.34209}, "CVE-2023-41130": {"epss_score": 0.00219, "epss_percentile": 0.44486}, "CVE-2023-41131": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-41132": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-41133": {"epss_score": 0.00076, "epss_percentile": 0.23163}, "CVE-2023-41134": {"epss_score": 0.00147, "epss_percentile": 0.35698}, "CVE-2023-41136": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-41137": {"epss_score": 0.00072, "epss_percentile": 0.22437}, "CVE-2023-41138": {"epss_score": 0.0002, "epss_percentile": 0.04495}, "CVE-2023-41139": {"epss_score": 0.00055, "epss_percentile": 0.17573}, "CVE-2023-41140": {"epss_score": 0.00077, "epss_percentile": 0.23316}, "CVE-2023-41145": {"epss_score": 0.00356, "epss_percentile": 0.57352}, "CVE-2023-41146": {"epss_score": 0.00329, "epss_percentile": 0.55401}, "CVE-2023-41149": {"epss_score": 0.00526, "epss_percentile": 0.66407}, "CVE-2023-41150": {"epss_score": 0.00255, "epss_percentile": 0.48701}, "CVE-2023-41151": {"epss_score": 0.00447, "epss_percentile": 0.62942}, "CVE-2023-41152": {"epss_score": 0.00115, "epss_percentile": 0.31026}, "CVE-2023-41153": {"epss_score": 0.00111, "epss_percentile": 0.30315}, "CVE-2023-41154": {"epss_score": 0.00115, "epss_percentile": 0.31026}, "CVE-2023-41155": {"epss_score": 0.00115, "epss_percentile": 0.31026}, "CVE-2023-41156": {"epss_score": 0.00126, "epss_percentile": 0.32645}, "CVE-2023-41157": {"epss_score": 0.00115, "epss_percentile": 0.30988}, "CVE-2023-41158": {"epss_score": 0.00115, "epss_percentile": 0.31026}, "CVE-2023-41159": {"epss_score": 0.00126, "epss_percentile": 0.32645}, "CVE-2023-41160": {"epss_score": 0.0011, "epss_percentile": 0.30117}, "CVE-2023-41161": {"epss_score": 0.00115, "epss_percentile": 0.31026}, "CVE-2023-41162": {"epss_score": 0.00124, "epss_percentile": 0.3235}, "CVE-2023-41163": {"epss_score": 0.0008, "epss_percentile": 0.24051}, "CVE-2023-41164": {"epss_score": 0.00406, "epss_percentile": 0.60538}, "CVE-2023-41165": {"epss_score": 0.00575, "epss_percentile": 0.68117}, "CVE-2023-41166": {"epss_score": 0.00231, "epss_percentile": 0.45833}, "CVE-2023-41167": {"epss_score": 0.00243, "epss_percentile": 0.47432}, "CVE-2023-41168": {"epss_score": 0.00743, "epss_percentile": 0.7247}, "CVE-2023-41169": {"epss_score": 0.00743, "epss_percentile": 0.7247}, "CVE-2023-41170": {"epss_score": 0.00328, "epss_percentile": 0.55152}, "CVE-2023-41171": {"epss_score": 0.00685, "epss_percentile": 0.71151}, "CVE-2023-41172": {"epss_score": 0.00468, "epss_percentile": 0.63882}, "CVE-2023-41173": {"epss_score": 0.00268, "epss_percentile": 0.50034}, "CVE-2023-41174": {"epss_score": 0.00036, "epss_percentile": 0.10605}, "CVE-2023-41175": {"epss_score": 0.0026, "epss_percentile": 0.49217}, "CVE-2023-41176": {"epss_score": 0.00289, "epss_percentile": 0.51996}, "CVE-2023-41177": {"epss_score": 0.00289, "epss_percentile": 0.51996}, "CVE-2023-41178": {"epss_score": 0.00289, "epss_percentile": 0.51996}, "CVE-2023-41179": {"epss_score": 0.02312, "epss_percentile": 0.84341}, "CVE-2023-41180": {"epss_score": 0.0007, "epss_percentile": 0.21801}, "CVE-2023-41181": {"epss_score": 0.00941, "epss_percentile": 0.75752}, "CVE-2023-41182": {"epss_score": 0.02465, "epss_percentile": 0.84834}, "CVE-2023-41183": {"epss_score": 0.00045, "epss_percentile": 0.13745}, "CVE-2023-41184": {"epss_score": 0.00184, "epss_percentile": 0.40445}, "CVE-2023-41185": {"epss_score": 0.01284, "epss_percentile": 0.79168}, "CVE-2023-41186": {"epss_score": 0.00878, "epss_percentile": 0.7483}, "CVE-2023-41187": {"epss_score": 0.01547, "epss_percentile": 0.80971}, "CVE-2023-41188": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41189": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41190": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41191": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41192": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41193": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41194": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41195": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41196": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41197": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41198": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41199": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41200": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41201": {"epss_score": 0.01756, "epss_percentile": 0.82129}, "CVE-2023-41202": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41203": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41204": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41205": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41206": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41207": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41208": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41209": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41210": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41211": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41212": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41213": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41214": {"epss_score": 0.02772, "epss_percentile": 0.85627}, "CVE-2023-41215": {"epss_score": 0.01694, "epss_percentile": 0.81804}, "CVE-2023-41216": {"epss_score": 0.00718, "epss_percentile": 0.71918}, "CVE-2023-41217": {"epss_score": 0.00722, "epss_percentile": 0.72001}, "CVE-2023-41218": {"epss_score": 0.00473, "epss_percentile": 0.64097}, "CVE-2023-41219": {"epss_score": 0.00718, "epss_percentile": 0.71918}, "CVE-2023-41220": {"epss_score": 0.00718, "epss_percentile": 0.71918}, "CVE-2023-41221": {"epss_score": 0.00473, "epss_percentile": 0.64097}, "CVE-2023-41222": {"epss_score": 0.00718, "epss_percentile": 0.71918}, "CVE-2023-41223": {"epss_score": 0.00473, "epss_percentile": 0.64097}, "CVE-2023-41224": {"epss_score": 0.00473, "epss_percentile": 0.64097}, "CVE-2023-41225": {"epss_score": 0.00718, "epss_percentile": 0.71918}, "CVE-2023-41226": {"epss_score": 0.00718, "epss_percentile": 0.71918}, "CVE-2023-41227": {"epss_score": 0.00718, "epss_percentile": 0.71918}, "CVE-2023-41228": {"epss_score": 0.00718, "epss_percentile": 0.71918}, "CVE-2023-41229": {"epss_score": 0.00517, "epss_percentile": 0.66061}, "CVE-2023-41230": {"epss_score": 0.00783, "epss_percentile": 0.73223}, "CVE-2023-41231": {"epss_score": 0.00048, "epss_percentile": 0.15189}, "CVE-2023-41232": {"epss_score": 0.00041, "epss_percentile": 0.12444}, "CVE-2023-41233": {"epss_score": 0.00235, "epss_percentile": 0.46332}, "CVE-2023-41234": {"epss_score": 0.00059, "epss_percentile": 0.18874}, "CVE-2023-41235": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-41236": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-41237": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-41238": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2023-41239": {"epss_score": 0.00172, "epss_percentile": 0.39038}, "CVE-2023-41240": {"epss_score": 0.00206, "epss_percentile": 0.42925}, "CVE-2023-41241": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-41242": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2023-41243": {"epss_score": 0.00206, "epss_percentile": 0.43063}, "CVE-2023-41244": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-41248": {"epss_score": 0.00044, "epss_percentile": 0.13658}, "CVE-2023-41249": {"epss_score": 0.02407, "epss_percentile": 0.84656}, "CVE-2023-41250": {"epss_score": 0.00032, "epss_percentile": 0.09009}, "CVE-2023-41251": {"epss_score": 0.0582, "epss_percentile": 0.90233}, "CVE-2023-41252": {"epss_score": 0.00059, "epss_percentile": 0.18697}, "CVE-2023-41253": {"epss_score": 0.00226, "epss_percentile": 0.45296}, "CVE-2023-41254": {"epss_score": 0.00021, "epss_percentile": 0.0478}, "CVE-2023-41255": {"epss_score": 0.00125, "epss_percentile": 0.32559}, "CVE-2023-41256": {"epss_score": 0.00022, "epss_percentile": 0.05169}, "CVE-2023-41257": {"epss_score": 0.00011, "epss_percentile": 0.00956}, "CVE-2023-41259": {"epss_score": 0.0019, "epss_percentile": 0.41133}, "CVE-2023-41260": {"epss_score": 0.00249, "epss_percentile": 0.48049}, "CVE-2023-41261": {"epss_score": 0.00156, "epss_percentile": 0.36961}, "CVE-2023-41262": {"epss_score": 0.00114, "epss_percentile": 0.30874}, "CVE-2023-41263": {"epss_score": 0.00117, "epss_percentile": 0.31335}, "CVE-2023-41264": {"epss_score": 0.00037, "epss_percentile": 0.10905}, "CVE-2023-41265": {"epss_score": 0.92043, "epss_percentile": 0.99687}, "CVE-2023-41266": {"epss_score": 0.94295, "epss_percentile": 0.99938}, "CVE-2023-41267": {"epss_score": 0.00492, "epss_percentile": 0.65007}, "CVE-2023-41268": {"epss_score": 0.00073, "epss_percentile": 0.22591}, "CVE-2023-41270": {"epss_score": 0.00082, "epss_percentile": 0.24458}, "CVE-2023-41273": {"epss_score": 0.00051, "epss_percentile": 0.16177}, "CVE-2023-41274": {"epss_score": 0.0007, "epss_percentile": 0.21869}, "CVE-2023-41275": {"epss_score": 0.00048, "epss_percentile": 0.14945}, "CVE-2023-41276": {"epss_score": 0.00048, "epss_percentile": 0.14945}, "CVE-2023-41277": {"epss_score": 0.00048, "epss_percentile": 0.14945}, "CVE-2023-41278": {"epss_score": 0.00061, "epss_percentile": 0.19433}, "CVE-2023-41279": {"epss_score": 0.00061, "epss_percentile": 0.19433}, "CVE-2023-41280": {"epss_score": 0.00061, "epss_percentile": 0.19433}, "CVE-2023-41281": {"epss_score": 0.00095, "epss_percentile": 0.27239}, "CVE-2023-41282": {"epss_score": 0.00176, "epss_percentile": 0.39429}, "CVE-2023-41283": {"epss_score": 0.00176, "epss_percentile": 0.39429}, "CVE-2023-41284": {"epss_score": 0.0009, "epss_percentile": 0.26078}, "CVE-2023-41285": {"epss_score": 0.0009, "epss_percentile": 0.26078}, "CVE-2023-41287": {"epss_score": 0.00131, "epss_percentile": 0.33374}, "CVE-2023-41288": {"epss_score": 0.00183, "epss_percentile": 0.40348}, "CVE-2023-41289": {"epss_score": 0.0049, "epss_percentile": 0.6493}, "CVE-2023-41290": {"epss_score": 0.00208, "epss_percentile": 0.43304}, "CVE-2023-41291": {"epss_score": 0.00085, "epss_percentile": 0.25062}, "CVE-2023-41292": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-41293": {"epss_score": 0.0015, "epss_percentile": 0.36097}, "CVE-2023-41294": {"epss_score": 0.00232, "epss_percentile": 0.45897}, "CVE-2023-41295": {"epss_score": 0.00086, "epss_percentile": 0.25436}, "CVE-2023-41296": {"epss_score": 0.00123, "epss_percentile": 0.32271}, "CVE-2023-41297": {"epss_score": 0.00193, "epss_percentile": 0.41454}, "CVE-2023-41298": {"epss_score": 0.0015, "epss_percentile": 0.36097}, "CVE-2023-41299": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-41300": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-41301": {"epss_score": 0.00114, "epss_percentile": 0.30867}, "CVE-2023-41302": {"epss_score": 0.00149, "epss_percentile": 0.36026}, "CVE-2023-41303": {"epss_score": 0.00174, "epss_percentile": 0.3915}, "CVE-2023-41304": {"epss_score": 0.00057, "epss_percentile": 0.18226}, "CVE-2023-41305": {"epss_score": 0.00096, "epss_percentile": 0.27356}, "CVE-2023-41306": {"epss_score": 0.0008, "epss_percentile": 0.24117}, "CVE-2023-41307": {"epss_score": 0.0015, "epss_percentile": 0.36097}, "CVE-2023-41308": {"epss_score": 0.00112, "epss_percentile": 0.30412}, "CVE-2023-41309": {"epss_score": 0.00128, "epss_percentile": 0.33054}, "CVE-2023-41310": {"epss_score": 0.00035, "epss_percentile": 0.10046}, "CVE-2023-41311": {"epss_score": 0.00117, "epss_percentile": 0.31283}, "CVE-2023-41312": {"epss_score": 0.00117, "epss_percentile": 0.31283}, "CVE-2023-41313": {"epss_score": 0.00188, "epss_percentile": 0.40873}, "CVE-2023-41314": {"epss_score": 0.00384, "epss_percentile": 0.59179}, "CVE-2023-41316": {"epss_score": 0.00174, "epss_percentile": 0.39147}, "CVE-2023-41317": {"epss_score": 0.00207, "epss_percentile": 0.43079}, "CVE-2023-41318": {"epss_score": 0.00499, "epss_percentile": 0.65254}, "CVE-2023-41319": {"epss_score": 0.00059, "epss_percentile": 0.18914}, "CVE-2023-41320": {"epss_score": 0.00992, "epss_percentile": 0.76398}, "CVE-2023-41321": {"epss_score": 0.0027, "epss_percentile": 0.5026}, "CVE-2023-41322": {"epss_score": 0.00206, "epss_percentile": 0.42774}, "CVE-2023-41323": {"epss_score": 0.00494, "epss_percentile": 0.65095}, "CVE-2023-41324": {"epss_score": 0.00175, "epss_percentile": 0.39351}, "CVE-2023-41325": {"epss_score": 0.00061, "epss_percentile": 0.19521}, "CVE-2023-41326": {"epss_score": 0.00341, "epss_percentile": 0.56325}, "CVE-2023-41327": {"epss_score": 0.00116, "epss_percentile": 0.31137}, "CVE-2023-41328": {"epss_score": 0.00195, "epss_percentile": 0.41643}, "CVE-2023-41329": {"epss_score": 0.00168, "epss_percentile": 0.38438}, "CVE-2023-41330": {"epss_score": 0.01332, "epss_percentile": 0.79526}, "CVE-2023-41331": {"epss_score": 0.03958, "epss_percentile": 0.88007}, "CVE-2023-41332": {"epss_score": 0.00052, "epss_percentile": 0.16355}, "CVE-2023-41333": {"epss_score": 0.00012, "epss_percentile": 0.01204}, "CVE-2023-41334": {"epss_score": 0.04306, "epss_percentile": 0.88523}, "CVE-2023-41335": {"epss_score": 0.00142, "epss_percentile": 0.35051}, "CVE-2023-41336": {"epss_score": 0.01045, "epss_percentile": 0.77018}, "CVE-2023-41337": {"epss_score": 0.00081, "epss_percentile": 0.24335}, "CVE-2023-41338": {"epss_score": 0.00334, "epss_percentile": 0.55741}, "CVE-2023-41339": {"epss_score": 0.00175, "epss_percentile": 0.39276}, "CVE-2023-41343": {"epss_score": 0.00052, "epss_percentile": 0.16618}, "CVE-2023-41344": {"epss_score": 0.00085, "epss_percentile": 0.25119}, "CVE-2023-41345": {"epss_score": 0.00769, "epss_percentile": 0.72986}, "CVE-2023-41346": {"epss_score": 0.00649, "epss_percentile": 0.70231}, "CVE-2023-41347": {"epss_score": 0.00649, "epss_percentile": 0.70231}, "CVE-2023-41348": {"epss_score": 0.00649, "epss_percentile": 0.70231}, "CVE-2023-41349": {"epss_score": 0.00311, "epss_percentile": 0.53853}, "CVE-2023-41350": {"epss_score": 0.00063, "epss_percentile": 0.19804}, "CVE-2023-41351": {"epss_score": 0.00086, "epss_percentile": 0.2534}, "CVE-2023-41352": {"epss_score": 0.00179, "epss_percentile": 0.39792}, "CVE-2023-41353": {"epss_score": 0.00269, "epss_percentile": 0.50181}, "CVE-2023-41354": {"epss_score": 0.00059, "epss_percentile": 0.18851}, "CVE-2023-41355": {"epss_score": 0.00296, "epss_percentile": 0.52604}, "CVE-2023-41356": {"epss_score": 0.00082, "epss_percentile": 0.24412}, "CVE-2023-41357": {"epss_score": 0.00293, "epss_percentile": 0.52292}, "CVE-2023-41358": {"epss_score": 0.0035, "epss_percentile": 0.56961}, "CVE-2023-41359": {"epss_score": 0.00187, "epss_percentile": 0.4076}, "CVE-2023-41360": {"epss_score": 0.00244, "epss_percentile": 0.47572}, "CVE-2023-41361": {"epss_score": 0.00381, "epss_percentile": 0.59013}, "CVE-2023-41362": {"epss_score": 0.22031, "epss_percentile": 0.95586}, "CVE-2023-41363": {"epss_score": 0.00064, "epss_percentile": 0.20268}, "CVE-2023-41364": {"epss_score": 0.00079, "epss_percentile": 0.23996}, "CVE-2023-41365": {"epss_score": 0.00115, "epss_percentile": 0.30963}, "CVE-2023-41366": {"epss_score": 0.0022, "epss_percentile": 0.44575}, "CVE-2023-41367": {"epss_score": 0.00188, "epss_percentile": 0.40834}, "CVE-2023-41368": {"epss_score": 0.00152, "epss_percentile": 0.36472}, "CVE-2023-41369": {"epss_score": 0.00109, "epss_percentile": 0.30043}, "CVE-2023-41372": {"epss_score": 0.00073, "epss_percentile": 0.22512}, "CVE-2023-41373": {"epss_score": 0.02644, "epss_percentile": 0.85319}, "CVE-2023-41374": {"epss_score": 0.00079, "epss_percentile": 0.23971}, "CVE-2023-41375": {"epss_score": 0.00076, "epss_percentile": 0.23081}, "CVE-2023-41376": {"epss_score": 0.00071, "epss_percentile": 0.22029}, "CVE-2023-41378": {"epss_score": 0.00225, "epss_percentile": 0.45084}, "CVE-2023-41387": {"epss_score": 0.00542, "epss_percentile": 0.67061}, "CVE-2023-41419": {"epss_score": 0.0388, "epss_percentile": 0.87895}, "CVE-2023-41423": {"epss_score": 0.00414, "epss_percentile": 0.61106}, "CVE-2023-41425": {"epss_score": 0.91079, "epss_percentile": 0.99618}, "CVE-2023-41436": {"epss_score": 0.00122, "epss_percentile": 0.32088}, "CVE-2023-41442": {"epss_score": 0.02713, "epss_percentile": 0.85502}, "CVE-2023-41443": {"epss_score": 0.00885, "epss_percentile": 0.74938}, "CVE-2023-41444": {"epss_score": 0.00206, "epss_percentile": 0.43054}, "CVE-2023-41445": {"epss_score": 0.00666, "epss_percentile": 0.70676}, "CVE-2023-41446": {"epss_score": 0.00666, "epss_percentile": 0.70676}, "CVE-2023-41447": {"epss_score": 0.00666, "epss_percentile": 0.70676}, "CVE-2023-41448": {"epss_score": 0.00779, "epss_percentile": 0.73141}, "CVE-2023-41449": {"epss_score": 0.0507, "epss_percentile": 0.89462}, "CVE-2023-41450": {"epss_score": 0.03019, "epss_percentile": 0.86221}, "CVE-2023-41451": {"epss_score": 0.00666, "epss_percentile": 0.70676}, "CVE-2023-41452": {"epss_score": 0.04361, "epss_percentile": 0.88596}, "CVE-2023-41453": {"epss_score": 0.00902, "epss_percentile": 0.75194}, "CVE-2023-41471": {"epss_score": 0.0004, "epss_percentile": 0.12155}, "CVE-2023-41474": {"epss_score": 0.74867, "epss_percentile": 0.98821}, "CVE-2023-41484": {"epss_score": 0.0009, "epss_percentile": 0.26079}, "CVE-2023-41503": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2023-41504": {"epss_score": 0.00118, "epss_percentile": 0.31452}, "CVE-2023-41505": {"epss_score": 0.00185, "epss_percentile": 0.40514}, "CVE-2023-41506": {"epss_score": 0.00102, "epss_percentile": 0.28745}, "CVE-2023-41507": {"epss_score": 0.00509, "epss_percentile": 0.65752}, "CVE-2023-41508": {"epss_score": 0.07165, "epss_percentile": 0.91294}, "CVE-2023-41519": {"epss_score": 0.0002, "epss_percentile": 0.04611}, "CVE-2023-41520": {"epss_score": 0.00022, "epss_percentile": 0.05302}, "CVE-2023-41521": {"epss_score": 0.00022, "epss_percentile": 0.05302}, "CVE-2023-41522": {"epss_score": 0.00022, "epss_percentile": 0.05302}, "CVE-2023-41523": {"epss_score": 0.00022, "epss_percentile": 0.05302}, "CVE-2023-41524": {"epss_score": 0.00022, "epss_percentile": 0.05302}, "CVE-2023-41525": {"epss_score": 0.0003, "epss_percentile": 0.08192}, "CVE-2023-41526": {"epss_score": 0.0003, "epss_percentile": 0.08192}, "CVE-2023-41527": {"epss_score": 0.0003, "epss_percentile": 0.08192}, "CVE-2023-41528": {"epss_score": 0.0003, "epss_percentile": 0.08192}, "CVE-2023-41529": {"epss_score": 0.0002, "epss_percentile": 0.04611}, "CVE-2023-41530": {"epss_score": 0.0003, "epss_percentile": 0.08192}, "CVE-2023-41531": {"epss_score": 0.00022, "epss_percentile": 0.05302}, "CVE-2023-41532": {"epss_score": 0.00022, "epss_percentile": 0.05302}, "CVE-2023-41537": {"epss_score": 0.00076, "epss_percentile": 0.23229}, "CVE-2023-41538": {"epss_score": 0.12939, "epss_percentile": 0.93822}, "CVE-2023-41539": {"epss_score": 0.00062, "epss_percentile": 0.19709}, "CVE-2023-41542": {"epss_score": 0.00227, "epss_percentile": 0.45459}, "CVE-2023-41543": {"epss_score": 0.00968, "epss_percentile": 0.76081}, "CVE-2023-41544": {"epss_score": 0.17615, "epss_percentile": 0.94875}, "CVE-2023-41552": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-41553": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-41554": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-41555": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-41556": {"epss_score": 0.00158, "epss_percentile": 0.37194}, "CVE-2023-41557": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-41558": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-41559": {"epss_score": 0.00158, "epss_percentile": 0.37194}, "CVE-2023-41560": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-41561": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-41562": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-41563": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-41564": {"epss_score": 0.20137, "epss_percentile": 0.95292}, "CVE-2023-41566": {"epss_score": 0.00038, "epss_percentile": 0.11341}, "CVE-2023-41570": {"epss_score": 0.00089, "epss_percentile": 0.25834}, "CVE-2023-41575": {"epss_score": 0.00119, "epss_percentile": 0.31568}, "CVE-2023-41578": {"epss_score": 0.01705, "epss_percentile": 0.81849}, "CVE-2023-41580": {"epss_score": 0.0056, "epss_percentile": 0.67648}, "CVE-2023-41588": {"epss_score": 0.0023, "epss_percentile": 0.45735}, "CVE-2023-41591": {"epss_score": 0.00054, "epss_percentile": 0.17295}, "CVE-2023-41592": {"epss_score": 0.02181, "epss_percentile": 0.83903}, "CVE-2023-41593": {"epss_score": 0.00353, "epss_percentile": 0.57139}, "CVE-2023-41594": {"epss_score": 0.00525, "epss_percentile": 0.66375}, "CVE-2023-41595": {"epss_score": 0.00091, "epss_percentile": 0.2622}, "CVE-2023-41597": {"epss_score": 0.11489, "epss_percentile": 0.93382}, "CVE-2023-41599": {"epss_score": 0.91669, "epss_percentile": 0.99661}, "CVE-2023-41601": {"epss_score": 0.00181, "epss_percentile": 0.40112}, "CVE-2023-41603": {"epss_score": 0.00228, "epss_percentile": 0.45479}, "CVE-2023-41609": {"epss_score": 0.00069, "epss_percentile": 0.21532}, "CVE-2023-41610": {"epss_score": 0.0008, "epss_percentile": 0.24149}, "CVE-2023-41611": {"epss_score": 0.00112, "epss_percentile": 0.30581}, "CVE-2023-41612": {"epss_score": 0.00063, "epss_percentile": 0.20086}, "CVE-2023-41613": {"epss_score": 0.00378, "epss_percentile": 0.58781}, "CVE-2023-41614": {"epss_score": 0.00061, "epss_percentile": 0.19315}, "CVE-2023-41615": {"epss_score": 0.00109, "epss_percentile": 0.30019}, "CVE-2023-41616": {"epss_score": 0.00173, "epss_percentile": 0.39066}, "CVE-2023-41618": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2023-41619": {"epss_score": 0.00235, "epss_percentile": 0.46338}, "CVE-2023-41621": {"epss_score": 0.0529, "epss_percentile": 0.89695}, "CVE-2023-41623": {"epss_score": 0.00881, "epss_percentile": 0.74877}, "CVE-2023-41626": {"epss_score": 0.00085, "epss_percentile": 0.2518}, "CVE-2023-41627": {"epss_score": 0.0024, "epss_percentile": 0.4719}, "CVE-2023-41628": {"epss_score": 0.0019, "epss_percentile": 0.41121}, "CVE-2023-41629": {"epss_score": 0.00105, "epss_percentile": 0.29361}, "CVE-2023-41630": {"epss_score": 0.01461, "epss_percentile": 0.80433}, "CVE-2023-41631": {"epss_score": 0.01385, "epss_percentile": 0.79909}, "CVE-2023-41633": {"epss_score": 0.00021, "epss_percentile": 0.0482}, "CVE-2023-41635": {"epss_score": 0.00072, "epss_percentile": 0.22374}, "CVE-2023-41636": {"epss_score": 0.00187, "epss_percentile": 0.40737}, "CVE-2023-41637": {"epss_score": 0.00443, "epss_percentile": 0.62768}, "CVE-2023-41638": {"epss_score": 0.00156, "epss_percentile": 0.36976}, "CVE-2023-41640": {"epss_score": 0.00104, "epss_percentile": 0.29133}, "CVE-2023-41642": {"epss_score": 0.17013, "epss_percentile": 0.9476}, "CVE-2023-41646": {"epss_score": 0.00058, "epss_percentile": 0.18312}, "CVE-2023-41648": {"epss_score": 0.00114, "epss_percentile": 0.30766}, "CVE-2023-41649": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-41650": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-41651": {"epss_score": 0.00115, "epss_percentile": 0.30927}, "CVE-2023-41652": {"epss_score": 0.04778, "epss_percentile": 0.89133}, "CVE-2023-41653": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2023-41654": {"epss_score": 0.00051, "epss_percentile": 0.16103}, "CVE-2023-41655": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41656": {"epss_score": 0.00057, "epss_percentile": 0.18013}, "CVE-2023-41657": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41658": {"epss_score": 0.00059, "epss_percentile": 0.18917}, "CVE-2023-41659": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-41660": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-41661": {"epss_score": 0.0008, "epss_percentile": 0.2417}, "CVE-2023-41662": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-41663": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-41664": {"epss_score": 0.00291, "epss_percentile": 0.52193}, "CVE-2023-41665": {"epss_score": 0.00319, "epss_percentile": 0.54559}, "CVE-2023-41666": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-41667": {"epss_score": 0.0007, "epss_percentile": 0.2193}, "CVE-2023-41668": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-41669": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-41670": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-41671": {"epss_score": 0.00196, "epss_percentile": 0.418}, "CVE-2023-41672": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-41673": {"epss_score": 0.0016, "epss_percentile": 0.37455}, "CVE-2023-41675": {"epss_score": 0.00402, "epss_percentile": 0.60269}, "CVE-2023-41676": {"epss_score": 0.00251, "epss_percentile": 0.48269}, "CVE-2023-41677": {"epss_score": 0.00319, "epss_percentile": 0.54569}, "CVE-2023-41678": {"epss_score": 0.00281, "epss_percentile": 0.5113}, "CVE-2023-41679": {"epss_score": 0.00187, "epss_percentile": 0.40701}, "CVE-2023-41680": {"epss_score": 0.00146, "epss_percentile": 0.35552}, "CVE-2023-41681": {"epss_score": 0.00144, "epss_percentile": 0.35271}, "CVE-2023-41682": {"epss_score": 0.00445, "epss_percentile": 0.62877}, "CVE-2023-41683": {"epss_score": 0.00203, "epss_percentile": 0.42543}, "CVE-2023-41684": {"epss_score": 0.00137, "epss_percentile": 0.34272}, "CVE-2023-41685": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-41686": {"epss_score": 0.00121, "epss_percentile": 0.31825}, "CVE-2023-41687": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-41688": {"epss_score": 0.00142, "epss_percentile": 0.35024}, "CVE-2023-41689": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2023-41690": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-41691": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-41692": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-41693": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-41694": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-41695": {"epss_score": 0.00357, "epss_percentile": 0.57438}, "CVE-2023-41697": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-41699": {"epss_score": 0.00071, "epss_percentile": 0.22226}, "CVE-2023-41703": {"epss_score": 0.00544, "epss_percentile": 0.67147}, "CVE-2023-41704": {"epss_score": 0.00343, "epss_percentile": 0.5644}, "CVE-2023-41705": {"epss_score": 0.00251, "epss_percentile": 0.48303}, "CVE-2023-41706": {"epss_score": 0.00251, "epss_percentile": 0.48303}, "CVE-2023-41707": {"epss_score": 0.00251, "epss_percentile": 0.48303}, "CVE-2023-41708": {"epss_score": 0.0041, "epss_percentile": 0.60821}, "CVE-2023-41710": {"epss_score": 0.00183, "epss_percentile": 0.40363}, "CVE-2023-41711": {"epss_score": 0.00484, "epss_percentile": 0.64661}, "CVE-2023-41712": {"epss_score": 0.00484, "epss_percentile": 0.64661}, "CVE-2023-41713": {"epss_score": 0.00293, "epss_percentile": 0.52316}, "CVE-2023-41715": {"epss_score": 0.0026, "epss_percentile": 0.49168}, "CVE-2023-41717": {"epss_score": 0.0012, "epss_percentile": 0.31772}, "CVE-2023-41718": {"epss_score": 0.00204, "epss_percentile": 0.42624}, "CVE-2023-41719": {"epss_score": 0.03146, "epss_percentile": 0.86496}, "CVE-2023-41720": {"epss_score": 0.00125, "epss_percentile": 0.32568}, "CVE-2023-41721": {"epss_score": 0.00239, "epss_percentile": 0.46901}, "CVE-2023-41723": {"epss_score": 0.01436, "epss_percentile": 0.80276}, "CVE-2023-41724": {"epss_score": 0.06296, "epss_percentile": 0.90651}, "CVE-2023-41725": {"epss_score": 0.0018, "epss_percentile": 0.39905}, "CVE-2023-41726": {"epss_score": 0.00062, "epss_percentile": 0.1958}, "CVE-2023-41727": {"epss_score": 0.01892, "epss_percentile": 0.82736}, "CVE-2023-41728": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-41729": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41730": {"epss_score": 0.00137, "epss_percentile": 0.34271}, "CVE-2023-41731": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41732": {"epss_score": 0.00051, "epss_percentile": 0.16103}, "CVE-2023-41733": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41734": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41735": {"epss_score": 0.00693, "epss_percentile": 0.71319}, "CVE-2023-41736": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41737": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41738": {"epss_score": 0.00757, "epss_percentile": 0.72762}, "CVE-2023-41739": {"epss_score": 0.00476, "epss_percentile": 0.64281}, "CVE-2023-41740": {"epss_score": 0.00236, "epss_percentile": 0.4639}, "CVE-2023-41741": {"epss_score": 0.00249, "epss_percentile": 0.48015}, "CVE-2023-41742": {"epss_score": 0.00094, "epss_percentile": 0.26959}, "CVE-2023-41743": {"epss_score": 0.00025, "epss_percentile": 0.06063}, "CVE-2023-41744": {"epss_score": 0.00016, "epss_percentile": 0.0268}, "CVE-2023-41745": {"epss_score": 0.00029, "epss_percentile": 0.07589}, "CVE-2023-41746": {"epss_score": 0.00831, "epss_percentile": 0.74053}, "CVE-2023-41747": {"epss_score": 0.00106, "epss_percentile": 0.29472}, "CVE-2023-41748": {"epss_score": 0.00831, "epss_percentile": 0.74053}, "CVE-2023-41749": {"epss_score": 0.0006, "epss_percentile": 0.19151}, "CVE-2023-41750": {"epss_score": 0.0008, "epss_percentile": 0.24188}, "CVE-2023-41751": {"epss_score": 0.00032, "epss_percentile": 0.09071}, "CVE-2023-41752": {"epss_score": 0.00474, "epss_percentile": 0.64149}, "CVE-2023-41763": {"epss_score": 0.12665, "epss_percentile": 0.93743}, "CVE-2023-41764": {"epss_score": 0.001, "epss_percentile": 0.28524}, "CVE-2023-41765": {"epss_score": 0.00218, "epss_percentile": 0.44352}, "CVE-2023-41766": {"epss_score": 0.00801, "epss_percentile": 0.73566}, "CVE-2023-41767": {"epss_score": 0.00218, "epss_percentile": 0.44352}, "CVE-2023-41768": {"epss_score": 0.00218, "epss_percentile": 0.44352}, "CVE-2023-41769": {"epss_score": 0.00218, "epss_percentile": 0.44352}, "CVE-2023-41770": {"epss_score": 0.00218, "epss_percentile": 0.44352}, "CVE-2023-41771": {"epss_score": 0.00218, "epss_percentile": 0.44352}, "CVE-2023-41772": {"epss_score": 0.20986, "epss_percentile": 0.95448}, "CVE-2023-41773": {"epss_score": 0.00218, "epss_percentile": 0.44352}, "CVE-2023-41774": {"epss_score": 0.00218, "epss_percentile": 0.44352}, "CVE-2023-41775": {"epss_score": 9e-05, "epss_percentile": 0.00732}, "CVE-2023-41776": {"epss_score": 0.0003, "epss_percentile": 0.08245}, "CVE-2023-41779": {"epss_score": 0.00023, "epss_percentile": 0.05494}, "CVE-2023-41780": {"epss_score": 0.00022, "epss_percentile": 0.04999}, "CVE-2023-41781": {"epss_score": 0.00061, "epss_percentile": 0.1944}, "CVE-2023-41782": {"epss_score": 0.00041, "epss_percentile": 0.12244}, "CVE-2023-41783": {"epss_score": 0.00089, "epss_percentile": 0.25873}, "CVE-2023-41784": {"epss_score": 0.00036, "epss_percentile": 0.10214}, "CVE-2023-41786": {"epss_score": 0.00078, "epss_percentile": 0.23632}, "CVE-2023-41787": {"epss_score": 0.00104, "epss_percentile": 0.29203}, "CVE-2023-41788": {"epss_score": 0.00085, "epss_percentile": 0.25029}, "CVE-2023-41789": {"epss_score": 0.00085, "epss_percentile": 0.25141}, "CVE-2023-41790": {"epss_score": 0.00145, "epss_percentile": 0.35514}, "CVE-2023-41791": {"epss_score": 0.00153, "epss_percentile": 0.36545}, "CVE-2023-41792": {"epss_score": 0.00041, "epss_percentile": 0.12357}, "CVE-2023-41793": {"epss_score": 0.00104, "epss_percentile": 0.2917}, "CVE-2023-41796": {"epss_score": 0.00047, "epss_percentile": 0.14641}, "CVE-2023-41797": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-41798": {"epss_score": 0.00692, "epss_percentile": 0.71305}, "CVE-2023-41800": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41801": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-41802": {"epss_score": 0.00143, "epss_percentile": 0.35109}, "CVE-2023-41803": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-41804": {"epss_score": 0.00361, "epss_percentile": 0.5773}, "CVE-2023-41805": {"epss_score": 0.00153, "epss_percentile": 0.36568}, "CVE-2023-41806": {"epss_score": 0.00072, "epss_percentile": 0.22254}, "CVE-2023-41807": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2023-41808": {"epss_score": 0.00095, "epss_percentile": 0.27104}, "CVE-2023-41810": {"epss_score": 0.00044, "epss_percentile": 0.13603}, "CVE-2023-41811": {"epss_score": 0.00044, "epss_percentile": 0.13603}, "CVE-2023-41812": {"epss_score": 0.0004, "epss_percentile": 0.11931}, "CVE-2023-41813": {"epss_score": 0.00513, "epss_percentile": 0.65906}, "CVE-2023-41814": {"epss_score": 0.00689, "epss_percentile": 0.71234}, "CVE-2023-41815": {"epss_score": 0.00135, "epss_percentile": 0.33941}, "CVE-2023-41816": {"epss_score": 0.00022, "epss_percentile": 0.05179}, "CVE-2023-41817": {"epss_score": 0.00028, "epss_percentile": 0.07306}, "CVE-2023-41818": {"epss_score": 0.00029, "epss_percentile": 0.0767}, "CVE-2023-41819": {"epss_score": 0.00031, "epss_percentile": 0.08393}, "CVE-2023-41820": {"epss_score": 0.0003, "epss_percentile": 0.08236}, "CVE-2023-41821": {"epss_score": 0.0003, "epss_percentile": 0.08236}, "CVE-2023-41822": {"epss_score": 0.00028, "epss_percentile": 0.07264}, "CVE-2023-41823": {"epss_score": 0.00031, "epss_percentile": 0.08443}, "CVE-2023-41824": {"epss_score": 0.00028, "epss_percentile": 0.07306}, "CVE-2023-41825": {"epss_score": 0.00027, "epss_percentile": 0.06937}, "CVE-2023-41826": {"epss_score": 0.0003, "epss_percentile": 0.08215}, "CVE-2023-41827": {"epss_score": 0.00065, "epss_percentile": 0.20662}, "CVE-2023-41828": {"epss_score": 0.00031, "epss_percentile": 0.08443}, "CVE-2023-41829": {"epss_score": 0.0007, "epss_percentile": 0.21711}, "CVE-2023-41830": {"epss_score": 0.0003, "epss_percentile": 0.08196}, "CVE-2023-41833": {"epss_score": 0.00044, "epss_percentile": 0.13383}, "CVE-2023-41834": {"epss_score": 0.01372, "epss_percentile": 0.79812}, "CVE-2023-41835": {"epss_score": 0.00224, "epss_percentile": 0.45023}, "CVE-2023-41836": {"epss_score": 0.00094, "epss_percentile": 0.26966}, "CVE-2023-41838": {"epss_score": 0.00231, "epss_percentile": 0.45848}, "CVE-2023-41840": {"epss_score": 0.00075, "epss_percentile": 0.23029}, "CVE-2023-41841": {"epss_score": 0.00187, "epss_percentile": 0.40709}, "CVE-2023-41842": {"epss_score": 0.00068, "epss_percentile": 0.21344}, "CVE-2023-41843": {"epss_score": 0.00183, "epss_percentile": 0.40286}, "CVE-2023-41844": {"epss_score": 0.00438, "epss_percentile": 0.62569}, "CVE-2023-41846": {"epss_score": 0.00077, "epss_percentile": 0.23284}, "CVE-2023-41847": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-41848": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-41849": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2023-41850": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-41851": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-41852": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-41853": {"epss_score": 0.00147, "epss_percentile": 0.35772}, "CVE-2023-41854": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-41855": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41856": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-41857": {"epss_score": 0.0013, "epss_percentile": 0.33237}, "CVE-2023-41858": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-41859": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41860": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2023-41861": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2023-41862": {"epss_score": 0.00173, "epss_percentile": 0.39109}, "CVE-2023-41863": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-41864": {"epss_score": 0.00147, "epss_percentile": 0.35657}, "CVE-2023-41865": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-41866": {"epss_score": 0.00276, "epss_percentile": 0.5072}, "CVE-2023-41867": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-41868": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-41869": {"epss_score": 0.0018, "epss_percentile": 0.39879}, "CVE-2023-41870": {"epss_score": 0.00547, "epss_percentile": 0.67263}, "CVE-2023-41871": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-41872": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-41873": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-41874": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-41875": {"epss_score": 0.00417, "epss_percentile": 0.61221}, "CVE-2023-41876": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-41877": {"epss_score": 0.01221, "epss_percentile": 0.78644}, "CVE-2023-41878": {"epss_score": 0.00139, "epss_percentile": 0.34655}, "CVE-2023-41879": {"epss_score": 0.00102, "epss_percentile": 0.28871}, "CVE-2023-41880": {"epss_score": 0.00183, "epss_percentile": 0.40307}, "CVE-2023-41881": {"epss_score": 0.00078, "epss_percentile": 0.23797}, "CVE-2023-41882": {"epss_score": 0.00145, "epss_percentile": 0.3538}, "CVE-2023-41884": {"epss_score": 0.00359, "epss_percentile": 0.576}, "CVE-2023-41885": {"epss_score": 0.0035, "epss_percentile": 0.5694}, "CVE-2023-41886": {"epss_score": 0.04296, "epss_percentile": 0.88509}, "CVE-2023-41887": {"epss_score": 0.59772, "epss_percentile": 0.98181}, "CVE-2023-41888": {"epss_score": 0.00316, "epss_percentile": 0.54243}, "CVE-2023-41889": {"epss_score": 0.00154, "epss_percentile": 0.36685}, "CVE-2023-41890": {"epss_score": 0.00135, "epss_percentile": 0.33971}, "CVE-2023-41891": {"epss_score": 0.00327, "epss_percentile": 0.55146}, "CVE-2023-41892": {"epss_score": 0.93942, "epss_percentile": 0.99872}, "CVE-2023-41893": {"epss_score": 0.00262, "epss_percentile": 0.49401}, "CVE-2023-41894": {"epss_score": 0.00193, "epss_percentile": 0.41444}, "CVE-2023-41895": {"epss_score": 0.00506, "epss_percentile": 0.65629}, "CVE-2023-41896": {"epss_score": 0.00204, "epss_percentile": 0.42613}, "CVE-2023-41897": {"epss_score": 0.01875, "epss_percentile": 0.82656}, "CVE-2023-41898": {"epss_score": 0.00127, "epss_percentile": 0.32807}, "CVE-2023-41899": {"epss_score": 0.00162, "epss_percentile": 0.37648}, "CVE-2023-41900": {"epss_score": 0.00131, "epss_percentile": 0.33497}, "CVE-2023-41902": {"epss_score": 0.0005, "epss_percentile": 0.15663}, "CVE-2023-41904": {"epss_score": 0.00053, "epss_percentile": 0.16881}, "CVE-2023-41905": {"epss_score": 0.00262, "epss_percentile": 0.49328}, "CVE-2023-41908": {"epss_score": 0.00072, "epss_percentile": 0.22274}, "CVE-2023-41909": {"epss_score": 0.00078, "epss_percentile": 0.2366}, "CVE-2023-41910": {"epss_score": 0.00134, "epss_percentile": 0.33805}, "CVE-2023-41911": {"epss_score": 0.00067, "epss_percentile": 0.21067}, "CVE-2023-41913": {"epss_score": 0.05318, "epss_percentile": 0.89725}, "CVE-2023-41914": {"epss_score": 0.00061, "epss_percentile": 0.19258}, "CVE-2023-41915": {"epss_score": 0.01033, "epss_percentile": 0.7688}, "CVE-2023-41916": {"epss_score": 0.00232, "epss_percentile": 0.45898}, "CVE-2023-41917": {"epss_score": 0.025, "epss_percentile": 0.84917}, "CVE-2023-41918": {"epss_score": 0.00282, "epss_percentile": 0.51276}, "CVE-2023-41919": {"epss_score": 0.00141, "epss_percentile": 0.34931}, "CVE-2023-41920": {"epss_score": 0.00141, "epss_percentile": 0.34931}, "CVE-2023-41921": {"epss_score": 0.0013, "epss_percentile": 0.33303}, "CVE-2023-41922": {"epss_score": 0.00149, "epss_percentile": 0.35992}, "CVE-2023-41923": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2023-41926": {"epss_score": 0.0013, "epss_percentile": 0.33268}, "CVE-2023-41927": {"epss_score": 0.0004, "epss_percentile": 0.12177}, "CVE-2023-41928": {"epss_score": 0.0004, "epss_percentile": 0.12177}, "CVE-2023-41929": {"epss_score": 0.00028, "epss_percentile": 0.07214}, "CVE-2023-41930": {"epss_score": 0.00131, "epss_percentile": 0.33404}, "CVE-2023-41931": {"epss_score": 0.00399, "epss_percentile": 0.60111}, "CVE-2023-41932": {"epss_score": 0.00049, "epss_percentile": 0.15428}, "CVE-2023-41933": {"epss_score": 0.0005, "epss_percentile": 0.15901}, "CVE-2023-41934": {"epss_score": 0.0008, "epss_percentile": 0.24123}, "CVE-2023-41935": {"epss_score": 0.00072, "epss_percentile": 0.2233}, "CVE-2023-41936": {"epss_score": 0.00072, "epss_percentile": 0.2233}, "CVE-2023-41937": {"epss_score": 0.00052, "epss_percentile": 0.16383}, "CVE-2023-41938": {"epss_score": 0.00044, "epss_percentile": 0.13661}, "CVE-2023-41939": {"epss_score": 0.00044, "epss_percentile": 0.13433}, "CVE-2023-41940": {"epss_score": 0.05371, "epss_percentile": 0.89794}, "CVE-2023-41941": {"epss_score": 0.00052, "epss_percentile": 0.16396}, "CVE-2023-41942": {"epss_score": 0.00044, "epss_percentile": 0.13661}, "CVE-2023-41943": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2023-41944": {"epss_score": 0.00118, "epss_percentile": 0.31401}, "CVE-2023-41945": {"epss_score": 0.00044, "epss_percentile": 0.13433}, "CVE-2023-41946": {"epss_score": 0.00069, "epss_percentile": 0.21496}, "CVE-2023-41947": {"epss_score": 0.00052, "epss_percentile": 0.16396}, "CVE-2023-41948": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41949": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-41950": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-41951": {"epss_score": 0.00233, "epss_percentile": 0.45986}, "CVE-2023-41952": {"epss_score": 0.0018, "epss_percentile": 0.39884}, "CVE-2023-41953": {"epss_score": 0.00254, "epss_percentile": 0.48626}, "CVE-2023-41954": {"epss_score": 0.13029, "epss_percentile": 0.93849}, "CVE-2023-41955": {"epss_score": 0.00348, "epss_percentile": 0.56814}, "CVE-2023-41956": {"epss_score": 0.00461, "epss_percentile": 0.63552}, "CVE-2023-41957": {"epss_score": 0.00135, "epss_percentile": 0.33981}, "CVE-2023-41960": {"epss_score": 0.00066, "epss_percentile": 0.20909}, "CVE-2023-41961": {"epss_score": 0.00144, "epss_percentile": 0.35344}, "CVE-2023-41962": {"epss_score": 0.0032, "epss_percentile": 0.5458}, "CVE-2023-41963": {"epss_score": 0.00573, "epss_percentile": 0.68064}, "CVE-2023-41964": {"epss_score": 0.00198, "epss_percentile": 0.41984}, "CVE-2023-41965": {"epss_score": 0.00116, "epss_percentile": 0.31162}, "CVE-2023-41966": {"epss_score": 0.00074, "epss_percentile": 0.2282}, "CVE-2023-41967": {"epss_score": 0.00115, "epss_percentile": 0.30909}, "CVE-2023-41968": {"epss_score": 0.00024, "epss_percentile": 0.05957}, "CVE-2023-41969": {"epss_score": 0.00096, "epss_percentile": 0.2727}, "CVE-2023-41970": {"epss_score": 0.00043, "epss_percentile": 0.13325}, "CVE-2023-41971": {"epss_score": 0.00074, "epss_percentile": 0.22858}, "CVE-2023-41972": {"epss_score": 0.00078, "epss_percentile": 0.23612}, "CVE-2023-41973": {"epss_score": 0.00056, "epss_percentile": 0.17941}, "CVE-2023-41974": {"epss_score": 0.00226, "epss_percentile": 0.45252}, "CVE-2023-41975": {"epss_score": 0.00177, "epss_percentile": 0.395}, "CVE-2023-41976": {"epss_score": 0.00264, "epss_percentile": 0.49738}, "CVE-2023-41977": {"epss_score": 0.00169, "epss_percentile": 0.38552}, "CVE-2023-41979": {"epss_score": 0.00069, "epss_percentile": 0.21636}, "CVE-2023-41980": {"epss_score": 0.00015, "epss_percentile": 0.02151}, "CVE-2023-41981": {"epss_score": 7e-05, "epss_percentile": 0.00338}, "CVE-2023-41982": {"epss_score": 0.00067, "epss_percentile": 0.20998}, "CVE-2023-41983": {"epss_score": 0.01108, "epss_percentile": 0.77633}, "CVE-2023-41984": {"epss_score": 0.00035, "epss_percentile": 0.10069}, "CVE-2023-41986": {"epss_score": 0.00036, "epss_percentile": 0.10305}, "CVE-2023-41987": {"epss_score": 0.00122, "epss_percentile": 0.32136}, "CVE-2023-41988": {"epss_score": 0.00088, "epss_percentile": 0.25645}, "CVE-2023-41989": {"epss_score": 0.00114, "epss_percentile": 0.30767}, "CVE-2023-41990": {"epss_score": 0.02687, "epss_percentile": 0.85431}, "CVE-2023-41991": {"epss_score": 0.04215, "epss_percentile": 0.88405}, "CVE-2023-41992": {"epss_score": 0.01257, "epss_percentile": 0.78947}, "CVE-2023-41993": {"epss_score": 0.21475, "epss_percentile": 0.95523}, "CVE-2023-41994": {"epss_score": 0.00124, "epss_percentile": 0.32464}, "CVE-2023-41995": {"epss_score": 0.0011, "epss_percentile": 0.30116}, "CVE-2023-41996": {"epss_score": 0.0009, "epss_percentile": 0.26038}, "CVE-2023-41997": {"epss_score": 0.00067, "epss_percentile": 0.20998}, "CVE-2023-41998": {"epss_score": 0.15294, "epss_percentile": 0.94403}, "CVE-2023-41999": {"epss_score": 0.00145, "epss_percentile": 0.35425}, "CVE-2023-42000": {"epss_score": 0.01245, "epss_percentile": 0.78842}, "CVE-2023-42004": {"epss_score": 0.00121, "epss_percentile": 0.31829}, "CVE-2023-42005": {"epss_score": 0.00119, "epss_percentile": 0.31605}, "CVE-2023-42006": {"epss_score": 0.00028, "epss_percentile": 0.07582}, "CVE-2023-42007": {"epss_score": 0.00036, "epss_percentile": 0.10354}, "CVE-2023-42009": {"epss_score": 0.00074, "epss_percentile": 0.22708}, "CVE-2023-42010": {"epss_score": 0.00122, "epss_percentile": 0.32022}, "CVE-2023-42011": {"epss_score": 0.00052, "epss_percentile": 0.16599}, "CVE-2023-42012": {"epss_score": 0.0002, "epss_percentile": 0.04483}, "CVE-2023-42013": {"epss_score": 0.00052, "epss_percentile": 0.16448}, "CVE-2023-42014": {"epss_score": 0.00101, "epss_percentile": 0.28666}, "CVE-2023-42015": {"epss_score": 0.00058, "epss_percentile": 0.18394}, "CVE-2023-42016": {"epss_score": 0.00033, "epss_percentile": 0.09214}, "CVE-2023-42017": {"epss_score": 0.00092, "epss_percentile": 0.26565}, "CVE-2023-42019": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2023-42022": {"epss_score": 0.0006, "epss_percentile": 0.19227}, "CVE-2023-42027": {"epss_score": 0.0004, "epss_percentile": 0.12149}, "CVE-2023-42029": {"epss_score": 0.00059, "epss_percentile": 0.18733}, "CVE-2023-42031": {"epss_score": 0.00092, "epss_percentile": 0.26443}, "CVE-2023-42032": {"epss_score": 0.00606, "epss_percentile": 0.69024}, "CVE-2023-42033": {"epss_score": 0.01606, "epss_percentile": 0.81297}, "CVE-2023-42034": {"epss_score": 0.0037, "epss_percentile": 0.58314}, "CVE-2023-42035": {"epss_score": 0.00332, "epss_percentile": 0.55551}, "CVE-2023-42036": {"epss_score": 0.00677, "epss_percentile": 0.70956}, "CVE-2023-42037": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-42038": {"epss_score": 0.01188, "epss_percentile": 0.78361}, "CVE-2023-42039": {"epss_score": 0.01188, "epss_percentile": 0.78361}, "CVE-2023-42040": {"epss_score": 0.02161, "epss_percentile": 0.83827}, "CVE-2023-42041": {"epss_score": 0.0176, "epss_percentile": 0.82147}, "CVE-2023-42042": {"epss_score": 0.0176, "epss_percentile": 0.82147}, "CVE-2023-42043": {"epss_score": 0.02001, "epss_percentile": 0.83219}, "CVE-2023-42044": {"epss_score": 0.01822, "epss_percentile": 0.82414}, "CVE-2023-42045": {"epss_score": 0.02001, "epss_percentile": 0.83219}, "CVE-2023-42046": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42047": {"epss_score": 0.01711, "epss_percentile": 0.81878}, "CVE-2023-42048": {"epss_score": 0.00784, "epss_percentile": 0.73241}, "CVE-2023-42049": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42050": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42051": {"epss_score": 0.01711, "epss_percentile": 0.81878}, "CVE-2023-42052": {"epss_score": 0.00523, "epss_percentile": 0.66302}, "CVE-2023-42053": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42054": {"epss_score": 0.00523, "epss_percentile": 0.66302}, "CVE-2023-42055": {"epss_score": 0.02001, "epss_percentile": 0.83219}, "CVE-2023-42056": {"epss_score": 0.0071, "epss_percentile": 0.71702}, "CVE-2023-42057": {"epss_score": 0.01822, "epss_percentile": 0.82414}, "CVE-2023-42058": {"epss_score": 0.01822, "epss_percentile": 0.82414}, "CVE-2023-42059": {"epss_score": 0.02455, "epss_percentile": 0.84796}, "CVE-2023-42060": {"epss_score": 0.02001, "epss_percentile": 0.83219}, "CVE-2023-42061": {"epss_score": 0.01711, "epss_percentile": 0.81878}, "CVE-2023-42062": {"epss_score": 0.02001, "epss_percentile": 0.83219}, "CVE-2023-42063": {"epss_score": 0.02001, "epss_percentile": 0.83219}, "CVE-2023-42064": {"epss_score": 0.02001, "epss_percentile": 0.83219}, "CVE-2023-42065": {"epss_score": 0.00523, "epss_percentile": 0.66302}, "CVE-2023-42066": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42067": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42068": {"epss_score": 0.00784, "epss_percentile": 0.73241}, "CVE-2023-42069": {"epss_score": 0.01887, "epss_percentile": 0.82718}, "CVE-2023-42070": {"epss_score": 0.00459, "epss_percentile": 0.63461}, "CVE-2023-42071": {"epss_score": 0.01711, "epss_percentile": 0.81878}, "CVE-2023-42072": {"epss_score": 0.00523, "epss_percentile": 0.66302}, "CVE-2023-42073": {"epss_score": 0.00784, "epss_percentile": 0.73241}, "CVE-2023-42074": {"epss_score": 0.00957, "epss_percentile": 0.75937}, "CVE-2023-42075": {"epss_score": 0.01711, "epss_percentile": 0.81878}, "CVE-2023-42076": {"epss_score": 0.02968, "epss_percentile": 0.86088}, "CVE-2023-42077": {"epss_score": 0.02968, "epss_percentile": 0.86088}, "CVE-2023-42078": {"epss_score": 0.01711, "epss_percentile": 0.81878}, "CVE-2023-42079": {"epss_score": 0.00784, "epss_percentile": 0.73241}, "CVE-2023-42080": {"epss_score": 0.01711, "epss_percentile": 0.81878}, "CVE-2023-42081": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42082": {"epss_score": 0.01711, "epss_percentile": 0.81878}, "CVE-2023-42083": {"epss_score": 0.02645, "epss_percentile": 0.85321}, "CVE-2023-42084": {"epss_score": 0.00784, "epss_percentile": 0.73241}, "CVE-2023-42085": {"epss_score": 0.02645, "epss_percentile": 0.85321}, "CVE-2023-42086": {"epss_score": 0.02455, "epss_percentile": 0.84796}, "CVE-2023-42087": {"epss_score": 0.00523, "epss_percentile": 0.66302}, "CVE-2023-42088": {"epss_score": 0.01891, "epss_percentile": 0.82728}, "CVE-2023-42089": {"epss_score": 0.00549, "epss_percentile": 0.67308}, "CVE-2023-42090": {"epss_score": 0.00409, "epss_percentile": 0.6072}, "CVE-2023-42091": {"epss_score": 0.01947, "epss_percentile": 0.83006}, "CVE-2023-42092": {"epss_score": 0.01947, "epss_percentile": 0.83006}, "CVE-2023-42093": {"epss_score": 0.00629, "epss_percentile": 0.69687}, "CVE-2023-42094": {"epss_score": 0.01947, "epss_percentile": 0.83006}, "CVE-2023-42095": {"epss_score": 0.00401, "epss_percentile": 0.60201}, "CVE-2023-42096": {"epss_score": 0.02212, "epss_percentile": 0.84023}, "CVE-2023-42097": {"epss_score": 0.01947, "epss_percentile": 0.83006}, "CVE-2023-42098": {"epss_score": 0.00629, "epss_percentile": 0.69687}, "CVE-2023-42099": {"epss_score": 0.00085, "epss_percentile": 0.25125}, "CVE-2023-42100": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-42101": {"epss_score": 0.00553, "epss_percentile": 0.67408}, "CVE-2023-42102": {"epss_score": 0.00553, "epss_percentile": 0.67408}, "CVE-2023-42103": {"epss_score": 0.00609, "epss_percentile": 0.691}, "CVE-2023-42104": {"epss_score": 0.00591, "epss_percentile": 0.68586}, "CVE-2023-42105": {"epss_score": 0.00569, "epss_percentile": 0.67936}, "CVE-2023-42106": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42107": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42108": {"epss_score": 0.01455, "epss_percentile": 0.80385}, "CVE-2023-42109": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42110": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42111": {"epss_score": 0.01455, "epss_percentile": 0.80385}, "CVE-2023-42112": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42113": {"epss_score": 0.0059, "epss_percentile": 0.68543}, "CVE-2023-42114": {"epss_score": 0.13895, "epss_percentile": 0.94088}, "CVE-2023-42115": {"epss_score": 0.72904, "epss_percentile": 0.98729}, "CVE-2023-42116": {"epss_score": 0.06734, "epss_percentile": 0.90991}, "CVE-2023-42117": {"epss_score": 0.0735, "epss_percentile": 0.91425}, "CVE-2023-42118": {"epss_score": 0.03014, "epss_percentile": 0.86209}, "CVE-2023-42119": {"epss_score": 0.00731, "epss_percentile": 0.72171}, "CVE-2023-42120": {"epss_score": 0.01771, "epss_percentile": 0.82195}, "CVE-2023-42121": {"epss_score": 0.01174, "epss_percentile": 0.78254}, "CVE-2023-42122": {"epss_score": 0.00169, "epss_percentile": 0.38627}, "CVE-2023-42123": {"epss_score": 0.01266, "epss_percentile": 0.79012}, "CVE-2023-42124": {"epss_score": 0.0006, "epss_percentile": 0.19228}, "CVE-2023-42125": {"epss_score": 0.00107, "epss_percentile": 0.29728}, "CVE-2023-42126": {"epss_score": 0.00107, "epss_percentile": 0.29728}, "CVE-2023-42127": {"epss_score": 0.00736, "epss_percentile": 0.72306}, "CVE-2023-42128": {"epss_score": 0.00561, "epss_percentile": 0.67656}, "CVE-2023-42129": {"epss_score": 0.04392, "epss_percentile": 0.88636}, "CVE-2023-42130": {"epss_score": 0.11314, "epss_percentile": 0.93304}, "CVE-2023-42131": {"epss_score": 0.00429, "epss_percentile": 0.61982}, "CVE-2023-42132": {"epss_score": 0.00028, "epss_percentile": 0.07491}, "CVE-2023-42133": {"epss_score": 0.00016, "epss_percentile": 0.02848}, "CVE-2023-42134": {"epss_score": 0.00085, "epss_percentile": 0.25162}, "CVE-2023-42135": {"epss_score": 0.00049, "epss_percentile": 0.15618}, "CVE-2023-42136": {"epss_score": 0.00078, "epss_percentile": 0.23762}, "CVE-2023-42137": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-42138": {"epss_score": 0.0007, "epss_percentile": 0.21655}, "CVE-2023-42143": {"epss_score": 0.00135, "epss_percentile": 0.34039}, "CVE-2023-42144": {"epss_score": 0.00031, "epss_percentile": 0.08688}, "CVE-2023-42147": {"epss_score": 0.00043, "epss_percentile": 0.13287}, "CVE-2023-42178": {"epss_score": 0.00054, "epss_percentile": 0.17191}, "CVE-2023-42180": {"epss_score": 0.00091, "epss_percentile": 0.26383}, "CVE-2023-42183": {"epss_score": 0.00196, "epss_percentile": 0.41815}, "CVE-2023-42188": {"epss_score": 0.00107, "epss_percentile": 0.29637}, "CVE-2023-42189": {"epss_score": 0.00523, "epss_percentile": 0.66287}, "CVE-2023-42222": {"epss_score": 0.04367, "epss_percentile": 0.88604}, "CVE-2023-42225": {"epss_score": 0.00587, "epss_percentile": 0.68471}, "CVE-2023-42226": {"epss_score": 0.00587, "epss_percentile": 0.68471}, "CVE-2023-42227": {"epss_score": 0.00587, "epss_percentile": 0.68471}, "CVE-2023-42228": {"epss_score": 0.00162, "epss_percentile": 0.37712}, "CVE-2023-42229": {"epss_score": 0.0095, "epss_percentile": 0.75852}, "CVE-2023-42230": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2023-42231": {"epss_score": 0.00135, "epss_percentile": 0.3398}, "CVE-2023-42232": {"epss_score": 0.00587, "epss_percentile": 0.68471}, "CVE-2023-42233": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2023-42234": {"epss_score": 0.00046, "epss_percentile": 0.14294}, "CVE-2023-42235": {"epss_score": 0.001, "epss_percentile": 0.28436}, "CVE-2023-42236": {"epss_score": 0.00081, "epss_percentile": 0.24314}, "CVE-2023-42237": {"epss_score": 0.001, "epss_percentile": 0.28436}, "CVE-2023-42238": {"epss_score": 0.001, "epss_percentile": 0.28436}, "CVE-2023-42239": {"epss_score": 0.001, "epss_percentile": 0.28436}, "CVE-2023-42240": {"epss_score": 0.001, "epss_percentile": 0.28436}, "CVE-2023-42241": {"epss_score": 0.001, "epss_percentile": 0.28436}, "CVE-2023-42242": {"epss_score": 0.001, "epss_percentile": 0.28436}, "CVE-2023-42243": {"epss_score": 0.00095, "epss_percentile": 0.27171}, "CVE-2023-42244": {"epss_score": 0.00111, "epss_percentile": 0.30318}, "CVE-2023-42245": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2023-42246": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2023-42247": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2023-42248": {"epss_score": 0.00164, "epss_percentile": 0.37956}, "CVE-2023-42249": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2023-42250": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2023-42253": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-42261": {"epss_score": 0.0016, "epss_percentile": 0.37459}, "CVE-2023-42268": {"epss_score": 0.0045, "epss_percentile": 0.6309}, "CVE-2023-42270": {"epss_score": 0.00236, "epss_percentile": 0.46431}, "CVE-2023-42276": {"epss_score": 0.00211, "epss_percentile": 0.43628}, "CVE-2023-42277": {"epss_score": 0.00211, "epss_percentile": 0.43628}, "CVE-2023-42278": {"epss_score": 0.00431, "epss_percentile": 0.62053}, "CVE-2023-42279": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-42280": {"epss_score": 0.00283, "epss_percentile": 0.51366}, "CVE-2023-42282": {"epss_score": 0.00539, "epss_percentile": 0.66978}, "CVE-2023-42283": {"epss_score": 0.06141, "epss_percentile": 0.90513}, "CVE-2023-42284": {"epss_score": 0.0538, "epss_percentile": 0.89809}, "CVE-2023-42286": {"epss_score": 0.00273, "epss_percentile": 0.50437}, "CVE-2023-42295": {"epss_score": 0.0146, "epss_percentile": 0.80415}, "CVE-2023-42298": {"epss_score": 0.00019, "epss_percentile": 0.04403}, "CVE-2023-42299": {"epss_score": 0.13231, "epss_percentile": 0.93906}, "CVE-2023-42307": {"epss_score": 0.00128, "epss_percentile": 0.33042}, "CVE-2023-42308": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-42319": {"epss_score": 0.0051, "epss_percentile": 0.65801}, "CVE-2023-42320": {"epss_score": 0.02141, "epss_percentile": 0.8375}, "CVE-2023-42321": {"epss_score": 0.00846, "epss_percentile": 0.74333}, "CVE-2023-42322": {"epss_score": 0.00321, "epss_percentile": 0.54646}, "CVE-2023-42323": {"epss_score": 0.01687, "epss_percentile": 0.81759}, "CVE-2023-42325": {"epss_score": 0.48312, "epss_percentile": 0.9763}, "CVE-2023-42326": {"epss_score": 0.86136, "epss_percentile": 0.99369}, "CVE-2023-42327": {"epss_score": 0.48312, "epss_percentile": 0.9763}, "CVE-2023-42328": {"epss_score": 0.03936, "epss_percentile": 0.87984}, "CVE-2023-42331": {"epss_score": 0.01086, "epss_percentile": 0.77418}, "CVE-2023-42334": {"epss_score": 0.00063, "epss_percentile": 0.20091}, "CVE-2023-42335": {"epss_score": 0.01871, "epss_percentile": 0.82636}, "CVE-2023-42336": {"epss_score": 0.02363, "epss_percentile": 0.84505}, "CVE-2023-42358": {"epss_score": 0.00661, "epss_percentile": 0.70576}, "CVE-2023-42359": {"epss_score": 0.00269, "epss_percentile": 0.50121}, "CVE-2023-42361": {"epss_score": 0.00134, "epss_percentile": 0.33764}, "CVE-2023-42362": {"epss_score": 0.00108, "epss_percentile": 0.29771}, "CVE-2023-42363": {"epss_score": 0.00026, "epss_percentile": 0.06568}, "CVE-2023-42364": {"epss_score": 0.00032, "epss_percentile": 0.08953}, "CVE-2023-42365": {"epss_score": 0.00032, "epss_percentile": 0.08953}, "CVE-2023-42366": {"epss_score": 0.00024, "epss_percentile": 0.06017}, "CVE-2023-42371": {"epss_score": 0.00375, "epss_percentile": 0.58632}, "CVE-2023-42374": {"epss_score": 0.02775, "epss_percentile": 0.85636}, "CVE-2023-42387": {"epss_score": 0.00085, "epss_percentile": 0.25229}, "CVE-2023-42398": {"epss_score": 0.12123, "epss_percentile": 0.93572}, "CVE-2023-42399": {"epss_score": 0.00136, "epss_percentile": 0.34173}, "CVE-2023-42404": {"epss_score": 0.00089, "epss_percentile": 0.25875}, "CVE-2023-42405": {"epss_score": 0.00132, "epss_percentile": 0.33601}, "CVE-2023-42406": {"epss_score": 0.19711, "epss_percentile": 0.9523}, "CVE-2023-42419": {"epss_score": 0.00031, "epss_percentile": 0.08478}, "CVE-2023-42425": {"epss_score": 0.0495, "epss_percentile": 0.89322}, "CVE-2023-42426": {"epss_score": 0.0062, "epss_percentile": 0.69451}, "CVE-2023-42427": {"epss_score": 0.00375, "epss_percentile": 0.586}, "CVE-2023-42428": {"epss_score": 0.02118, "epss_percentile": 0.83669}, "CVE-2023-42429": {"epss_score": 0.00051, "epss_percentile": 0.16066}, "CVE-2023-42431": {"epss_score": 0.00054, "epss_percentile": 0.17314}, "CVE-2023-42433": {"epss_score": 0.00056, "epss_percentile": 0.17797}, "CVE-2023-42435": {"epss_score": 0.00096, "epss_percentile": 0.27264}, "CVE-2023-42436": {"epss_score": 0.00452, "epss_percentile": 0.63196}, "CVE-2023-42438": {"epss_score": 0.001, "epss_percentile": 0.28523}, "CVE-2023-42439": {"epss_score": 0.00072, "epss_percentile": 0.2225}, "CVE-2023-42441": {"epss_score": 0.00151, "epss_percentile": 0.36324}, "CVE-2023-42442": {"epss_score": 0.87887, "epss_percentile": 0.99448}, "CVE-2023-42443": {"epss_score": 0.00225, "epss_percentile": 0.4514}, "CVE-2023-42444": {"epss_score": 0.00552, "epss_percentile": 0.6738}, "CVE-2023-42445": {"epss_score": 0.00365, "epss_percentile": 0.57993}, "CVE-2023-42446": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2023-42447": {"epss_score": 0.00517, "epss_percentile": 0.66086}, "CVE-2023-42448": {"epss_score": 0.01707, "epss_percentile": 0.8186}, "CVE-2023-42449": {"epss_score": 0.00232, "epss_percentile": 0.45931}, "CVE-2023-42450": {"epss_score": 0.00367, "epss_percentile": 0.58116}, "CVE-2023-42451": {"epss_score": 0.00304, "epss_percentile": 0.53305}, "CVE-2023-42452": {"epss_score": 0.00623, "epss_percentile": 0.69553}, "CVE-2023-42453": {"epss_score": 0.00225, "epss_percentile": 0.45236}, "CVE-2023-42454": {"epss_score": 0.00101, "epss_percentile": 0.28678}, "CVE-2023-42455": {"epss_score": 0.00142, "epss_percentile": 0.35001}, "CVE-2023-42456": {"epss_score": 0.00113, "epss_percentile": 0.30633}, "CVE-2023-42457": {"epss_score": 0.00232, "epss_percentile": 0.45959}, "CVE-2023-42458": {"epss_score": 0.00313, "epss_percentile": 0.54025}, "CVE-2023-42459": {"epss_score": 0.00288, "epss_percentile": 0.51925}, "CVE-2023-42460": {"epss_score": 0.00048, "epss_percentile": 0.15158}, "CVE-2023-42461": {"epss_score": 0.00906, "epss_percentile": 0.75247}, "CVE-2023-42462": {"epss_score": 0.00543, "epss_percentile": 0.6712}, "CVE-2023-42463": {"epss_score": 0.00067, "epss_percentile": 0.21026}, "CVE-2023-42464": {"epss_score": 0.07695, "epss_percentile": 0.91631}, "CVE-2023-42465": {"epss_score": 4e-05, "epss_percentile": 0.00123}, "CVE-2023-42467": {"epss_score": 0.00011, "epss_percentile": 0.01006}, "CVE-2023-42468": {"epss_score": 0.00302, "epss_percentile": 0.53126}, "CVE-2023-42469": {"epss_score": 0.00062, "epss_percentile": 0.19757}, "CVE-2023-42470": {"epss_score": 0.12795, "epss_percentile": 0.93775}, "CVE-2023-42471": {"epss_score": 0.03016, "epss_percentile": 0.86215}, "CVE-2023-42472": {"epss_score": 0.00216, "epss_percentile": 0.44158}, "CVE-2023-42473": {"epss_score": 0.00147, "epss_percentile": 0.35788}, "CVE-2023-42474": {"epss_score": 0.00213, "epss_percentile": 0.43831}, "CVE-2023-42475": {"epss_score": 0.002, "epss_percentile": 0.42263}, "CVE-2023-42476": {"epss_score": 0.00109, "epss_percentile": 0.30028}, "CVE-2023-42477": {"epss_score": 0.00092, "epss_percentile": 0.26601}, "CVE-2023-42478": {"epss_score": 0.00052, "epss_percentile": 0.16602}, "CVE-2023-42479": {"epss_score": 0.00149, "epss_percentile": 0.36005}, "CVE-2023-42480": {"epss_score": 0.00104, "epss_percentile": 0.29157}, "CVE-2023-42481": {"epss_score": 0.00075, "epss_percentile": 0.22987}, "CVE-2023-42482": {"epss_score": 0.00076, "epss_percentile": 0.23214}, "CVE-2023-42483": {"epss_score": 0.0002, "epss_percentile": 0.04614}, "CVE-2023-42486": {"epss_score": 0.00107, "epss_percentile": 0.29693}, "CVE-2023-42487": {"epss_score": 0.00353, "epss_percentile": 0.57149}, "CVE-2023-42488": {"epss_score": 0.0022, "epss_percentile": 0.44628}, "CVE-2023-42489": {"epss_score": 0.00197, "epss_percentile": 0.41831}, "CVE-2023-42490": {"epss_score": 0.00216, "epss_percentile": 0.44217}, "CVE-2023-42491": {"epss_score": 0.00165, "epss_percentile": 0.3801}, "CVE-2023-42492": {"epss_score": 0.00121, "epss_percentile": 0.31877}, "CVE-2023-42493": {"epss_score": 0.00121, "epss_percentile": 0.31877}, "CVE-2023-42494": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2023-42495": {"epss_score": 0.00348, "epss_percentile": 0.56825}, "CVE-2023-42496": {"epss_score": 0.00377, "epss_percentile": 0.58699}, "CVE-2023-42497": {"epss_score": 0.00192, "epss_percentile": 0.41285}, "CVE-2023-42498": {"epss_score": 0.00377, "epss_percentile": 0.58699}, "CVE-2023-42501": {"epss_score": 0.00105, "epss_percentile": 0.29267}, "CVE-2023-42502": {"epss_score": 0.00071, "epss_percentile": 0.22186}, "CVE-2023-42503": {"epss_score": 0.00011, "epss_percentile": 0.01041}, "CVE-2023-42504": {"epss_score": 0.00201, "epss_percentile": 0.42352}, "CVE-2023-42505": {"epss_score": 0.00044, "epss_percentile": 0.1341}, "CVE-2023-42506": {"epss_score": 0.0007, "epss_percentile": 0.21655}, "CVE-2023-42507": {"epss_score": 0.00086, "epss_percentile": 0.25281}, "CVE-2023-42508": {"epss_score": 0.00362, "epss_percentile": 0.57782}, "CVE-2023-42509": {"epss_score": 0.00275, "epss_percentile": 0.50681}, "CVE-2023-42520": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2023-42521": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2023-42522": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2023-42523": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2023-42524": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2023-42525": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2023-42526": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2023-42527": {"epss_score": 0.0004, "epss_percentile": 0.12138}, "CVE-2023-42528": {"epss_score": 0.00036, "epss_percentile": 0.10292}, "CVE-2023-42529": {"epss_score": 0.00049, "epss_percentile": 0.15293}, "CVE-2023-42530": {"epss_score": 0.0015, "epss_percentile": 0.36128}, "CVE-2023-42531": {"epss_score": 0.00021, "epss_percentile": 0.04719}, "CVE-2023-42532": {"epss_score": 0.00264, "epss_percentile": 0.49707}, "CVE-2023-42533": {"epss_score": 0.00139, "epss_percentile": 0.34641}, "CVE-2023-42534": {"epss_score": 0.00054, "epss_percentile": 0.1725}, "CVE-2023-42535": {"epss_score": 0.00085, "epss_percentile": 0.25155}, "CVE-2023-42536": {"epss_score": 0.00073, "epss_percentile": 0.22555}, "CVE-2023-42537": {"epss_score": 0.00073, "epss_percentile": 0.22555}, "CVE-2023-42538": {"epss_score": 0.00066, "epss_percentile": 0.20739}, "CVE-2023-42539": {"epss_score": 0.00089, "epss_percentile": 0.25966}, "CVE-2023-42540": {"epss_score": 0.00116, "epss_percentile": 0.31077}, "CVE-2023-42541": {"epss_score": 0.00283, "epss_percentile": 0.51373}, "CVE-2023-42542": {"epss_score": 0.00088, "epss_percentile": 0.2577}, "CVE-2023-42543": {"epss_score": 0.00257, "epss_percentile": 0.48872}, "CVE-2023-42544": {"epss_score": 0.0008, "epss_percentile": 0.2415}, "CVE-2023-42545": {"epss_score": 0.00257, "epss_percentile": 0.48872}, "CVE-2023-42546": {"epss_score": 0.00168, "epss_percentile": 0.38468}, "CVE-2023-42547": {"epss_score": 0.00124, "epss_percentile": 0.32365}, "CVE-2023-42548": {"epss_score": 0.00229, "epss_percentile": 0.45553}, "CVE-2023-42549": {"epss_score": 0.00124, "epss_percentile": 0.32365}, "CVE-2023-42550": {"epss_score": 0.00229, "epss_percentile": 0.45553}, "CVE-2023-42551": {"epss_score": 0.00168, "epss_percentile": 0.38468}, "CVE-2023-42552": {"epss_score": 0.00072, "epss_percentile": 0.22343}, "CVE-2023-42553": {"epss_score": 0.00283, "epss_percentile": 0.51373}, "CVE-2023-42554": {"epss_score": 0.00033, "epss_percentile": 0.09156}, "CVE-2023-42555": {"epss_score": 0.00133, "epss_percentile": 0.33655}, "CVE-2023-42556": {"epss_score": 0.00099, "epss_percentile": 0.28315}, "CVE-2023-42557": {"epss_score": 0.00065, "epss_percentile": 0.20555}, "CVE-2023-42558": {"epss_score": 0.00056, "epss_percentile": 0.17894}, "CVE-2023-42559": {"epss_score": 0.00045, "epss_percentile": 0.13685}, "CVE-2023-42560": {"epss_score": 0.00132, "epss_percentile": 0.33591}, "CVE-2023-42561": {"epss_score": 0.00211, "epss_percentile": 0.43705}, "CVE-2023-42562": {"epss_score": 0.00164, "epss_percentile": 0.37982}, "CVE-2023-42563": {"epss_score": 0.00156, "epss_percentile": 0.37002}, "CVE-2023-42564": {"epss_score": 0.00104, "epss_percentile": 0.29245}, "CVE-2023-42565": {"epss_score": 0.00082, "epss_percentile": 0.24513}, "CVE-2023-42566": {"epss_score": 0.00089, "epss_percentile": 0.25937}, "CVE-2023-42567": {"epss_score": 0.00123, "epss_percentile": 0.32179}, "CVE-2023-42568": {"epss_score": 0.00075, "epss_percentile": 0.22904}, "CVE-2023-42569": {"epss_score": 0.00113, "epss_percentile": 0.30611}, "CVE-2023-42570": {"epss_score": 0.00128, "epss_percentile": 0.32975}, "CVE-2023-42571": {"epss_score": 0.00224, "epss_percentile": 0.4497}, "CVE-2023-42572": {"epss_score": 0.00099, "epss_percentile": 0.28315}, "CVE-2023-42573": {"epss_score": 0.00101, "epss_percentile": 0.28598}, "CVE-2023-42574": {"epss_score": 0.00072, "epss_percentile": 0.22405}, "CVE-2023-42575": {"epss_score": 0.00042, "epss_percentile": 0.12741}, "CVE-2023-42576": {"epss_score": 0.0003, "epss_percentile": 0.08184}, "CVE-2023-42577": {"epss_score": 0.00141, "epss_percentile": 0.34849}, "CVE-2023-42578": {"epss_score": 0.00271, "epss_percentile": 0.50333}, "CVE-2023-42579": {"epss_score": 0.00061, "epss_percentile": 0.19277}, "CVE-2023-42580": {"epss_score": 0.00365, "epss_percentile": 0.57985}, "CVE-2023-42581": {"epss_score": 0.00291, "epss_percentile": 0.52176}, "CVE-2023-42627": {"epss_score": 0.00208, "epss_percentile": 0.43269}, "CVE-2023-42628": {"epss_score": 0.00159, "epss_percentile": 0.37389}, "CVE-2023-42629": {"epss_score": 0.00208, "epss_percentile": 0.43269}, "CVE-2023-42631": {"epss_score": 0.00022, "epss_percentile": 0.04979}, "CVE-2023-42632": {"epss_score": 0.00029, "epss_percentile": 0.07841}, "CVE-2023-42633": {"epss_score": 0.00029, "epss_percentile": 0.07841}, "CVE-2023-42634": {"epss_score": 0.00029, "epss_percentile": 0.07841}, "CVE-2023-42635": {"epss_score": 0.00029, "epss_percentile": 0.07841}, "CVE-2023-42636": {"epss_score": 0.00029, "epss_percentile": 0.07841}, "CVE-2023-42637": {"epss_score": 0.00029, "epss_percentile": 0.07841}, "CVE-2023-42638": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-42639": {"epss_score": 0.00029, "epss_percentile": 0.07841}, "CVE-2023-42640": {"epss_score": 0.00029, "epss_percentile": 0.07841}, "CVE-2023-42641": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-42642": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-42643": {"epss_score": 0.00016, "epss_percentile": 0.0277}, "CVE-2023-42644": {"epss_score": 0.0004, "epss_percentile": 0.11879}, "CVE-2023-42645": {"epss_score": 0.00024, "epss_percentile": 0.06028}, "CVE-2023-42646": {"epss_score": 0.00021, "epss_percentile": 0.04932}, "CVE-2023-42647": {"epss_score": 0.00045, "epss_percentile": 0.13982}, "CVE-2023-42648": {"epss_score": 0.0004, "epss_percentile": 0.11879}, "CVE-2023-42649": {"epss_score": 0.00045, "epss_percentile": 0.13982}, "CVE-2023-42650": {"epss_score": 0.0004, "epss_percentile": 0.11879}, "CVE-2023-42651": {"epss_score": 0.0004, "epss_percentile": 0.11879}, "CVE-2023-42652": {"epss_score": 0.0004, "epss_percentile": 0.11879}, "CVE-2023-42653": {"epss_score": 0.00026, "epss_percentile": 0.06596}, "CVE-2023-42654": {"epss_score": 0.00027, "epss_percentile": 0.06765}, "CVE-2023-42655": {"epss_score": 0.00018, "epss_percentile": 0.03884}, "CVE-2023-42656": {"epss_score": 0.00019, "epss_percentile": 0.0429}, "CVE-2023-42657": {"epss_score": 0.00605, "epss_percentile": 0.68978}, "CVE-2023-42658": {"epss_score": 0.00147, "epss_percentile": 0.35655}, "CVE-2023-42659": {"epss_score": 0.00036, "epss_percentile": 0.10387}, "CVE-2023-42660": {"epss_score": 0.00592, "epss_percentile": 0.68628}, "CVE-2023-42661": {"epss_score": 0.01283, "epss_percentile": 0.79161}, "CVE-2023-42662": {"epss_score": 0.00279, "epss_percentile": 0.50939}, "CVE-2023-42663": {"epss_score": 0.00511, "epss_percentile": 0.65816}, "CVE-2023-42664": {"epss_score": 0.00805, "epss_percentile": 0.7363}, "CVE-2023-42666": {"epss_score": 0.00197, "epss_percentile": 0.41829}, "CVE-2023-42667": {"epss_score": 0.00045, "epss_percentile": 0.14066}, "CVE-2023-42668": {"epss_score": 0.00056, "epss_percentile": 0.17797}, "CVE-2023-42669": {"epss_score": 0.00578, "epss_percentile": 0.68195}, "CVE-2023-42670": {"epss_score": 0.00636, "epss_percentile": 0.69873}, "CVE-2023-42671": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42672": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42673": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42674": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-42675": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-42676": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42677": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42678": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42679": {"epss_score": 7e-05, "epss_percentile": 0.0035}, "CVE-2023-42680": {"epss_score": 0.0001, "epss_percentile": 0.0078}, "CVE-2023-42681": {"epss_score": 0.00022, "epss_percentile": 0.05263}, "CVE-2023-42682": {"epss_score": 8e-05, "epss_percentile": 0.00468}, "CVE-2023-42683": {"epss_score": 0.0001, "epss_percentile": 0.0078}, "CVE-2023-42684": {"epss_score": 0.0001, "epss_percentile": 0.0078}, "CVE-2023-42685": {"epss_score": 0.00025, "epss_percentile": 0.06146}, "CVE-2023-42686": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-42687": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-42688": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-42689": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-42690": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-42691": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-42692": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-42693": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-42694": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-42695": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-42696": {"epss_score": 0.00019, "epss_percentile": 0.04245}, "CVE-2023-42697": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-42698": {"epss_score": 0.00015, "epss_percentile": 0.02463}, "CVE-2023-42699": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42700": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42701": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42702": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42703": {"epss_score": 0.00024, "epss_percentile": 0.05897}, "CVE-2023-42704": {"epss_score": 0.00024, "epss_percentile": 0.05897}, "CVE-2023-42705": {"epss_score": 0.00024, "epss_percentile": 0.05897}, "CVE-2023-42706": {"epss_score": 0.00024, "epss_percentile": 0.05897}, "CVE-2023-42707": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42708": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42709": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2023-42710": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42711": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42712": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42713": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42714": {"epss_score": 0.00012, "epss_percentile": 0.01202}, "CVE-2023-42715": {"epss_score": 0.00015, "epss_percentile": 0.02251}, "CVE-2023-42716": {"epss_score": 0.00343, "epss_percentile": 0.5644}, "CVE-2023-42717": {"epss_score": 0.00343, "epss_percentile": 0.5644}, "CVE-2023-42718": {"epss_score": 0.00015, "epss_percentile": 0.02251}, "CVE-2023-42719": {"epss_score": 0.00038, "epss_percentile": 0.11136}, "CVE-2023-42720": {"epss_score": 0.00038, "epss_percentile": 0.11136}, "CVE-2023-42721": {"epss_score": 0.00039, "epss_percentile": 0.11695}, "CVE-2023-42722": {"epss_score": 0.00033, "epss_percentile": 0.09375}, "CVE-2023-42723": {"epss_score": 0.00039, "epss_percentile": 0.11615}, "CVE-2023-42724": {"epss_score": 0.00022, "epss_percentile": 0.05308}, "CVE-2023-42725": {"epss_score": 0.00025, "epss_percentile": 0.06052}, "CVE-2023-42726": {"epss_score": 0.00025, "epss_percentile": 0.06052}, "CVE-2023-42727": {"epss_score": 0.00019, "epss_percentile": 0.04173}, "CVE-2023-42728": {"epss_score": 0.00038, "epss_percentile": 0.11136}, "CVE-2023-42729": {"epss_score": 0.00015, "epss_percentile": 0.02477}, "CVE-2023-42730": {"epss_score": 0.00024, "epss_percentile": 0.05897}, "CVE-2023-42731": {"epss_score": 0.0002, "epss_percentile": 0.04517}, "CVE-2023-42732": {"epss_score": 0.00024, "epss_percentile": 0.05897}, "CVE-2023-42733": {"epss_score": 0.00024, "epss_percentile": 0.05897}, "CVE-2023-42734": {"epss_score": 0.00024, "epss_percentile": 0.05897}, "CVE-2023-42735": {"epss_score": 0.0002, "epss_percentile": 0.04514}, "CVE-2023-42736": {"epss_score": 0.00022, "epss_percentile": 0.05017}, "CVE-2023-42737": {"epss_score": 0.00023, "epss_percentile": 0.05647}, "CVE-2023-42738": {"epss_score": 0.00022, "epss_percentile": 0.05017}, "CVE-2023-42739": {"epss_score": 0.00022, "epss_percentile": 0.04989}, "CVE-2023-42740": {"epss_score": 0.00022, "epss_percentile": 0.05017}, "CVE-2023-42741": {"epss_score": 0.00023, "epss_percentile": 0.05647}, "CVE-2023-42742": {"epss_score": 0.00031, "epss_percentile": 0.08444}, "CVE-2023-42743": {"epss_score": 0.00022, "epss_percentile": 0.05017}, "CVE-2023-42744": {"epss_score": 0.00038, "epss_percentile": 0.11302}, "CVE-2023-42745": {"epss_score": 0.00022, "epss_percentile": 0.05017}, "CVE-2023-42746": {"epss_score": 0.00022, "epss_percentile": 0.04989}, "CVE-2023-42747": {"epss_score": 0.00022, "epss_percentile": 0.05017}, "CVE-2023-42748": {"epss_score": 0.00022, "epss_percentile": 0.05017}, "CVE-2023-42749": {"epss_score": 0.00023, "epss_percentile": 0.05647}, "CVE-2023-42750": {"epss_score": 0.00018, "epss_percentile": 0.03621}, "CVE-2023-42751": {"epss_score": 0.00015, "epss_percentile": 0.02477}, "CVE-2023-42752": {"epss_score": 9e-05, "epss_percentile": 0.00699}, "CVE-2023-42753": {"epss_score": 0.00014, "epss_percentile": 0.01787}, "CVE-2023-42754": {"epss_score": 0.0001, "epss_percentile": 0.00828}, "CVE-2023-42755": {"epss_score": 7e-05, "epss_percentile": 0.00353}, "CVE-2023-42756": {"epss_score": 7e-05, "epss_percentile": 0.00351}, "CVE-2023-42757": {"epss_score": 0.00069, "epss_percentile": 0.21591}, "CVE-2023-42765": {"epss_score": 0.00072, "epss_percentile": 0.22304}, "CVE-2023-42766": {"epss_score": 0.00051, "epss_percentile": 0.16326}, "CVE-2023-42768": {"epss_score": 0.00428, "epss_percentile": 0.6192}, "CVE-2023-42769": {"epss_score": 0.00069, "epss_percentile": 0.21616}, "CVE-2023-42770": {"epss_score": 0.00142, "epss_percentile": 0.3502}, "CVE-2023-42771": {"epss_score": 0.00028, "epss_percentile": 0.07298}, "CVE-2023-42772": {"epss_score": 0.00048, "epss_percentile": 0.14956}, "CVE-2023-42773": {"epss_score": 0.00184, "epss_percentile": 0.40411}, "CVE-2023-42774": {"epss_score": 0.00024, "epss_percentile": 0.05966}, "CVE-2023-42776": {"epss_score": 0.001, "epss_percentile": 0.28487}, "CVE-2023-42780": {"epss_score": 0.0013, "epss_percentile": 0.33227}, "CVE-2023-42781": {"epss_score": 0.00054, "epss_percentile": 0.17219}, "CVE-2023-42782": {"epss_score": 0.00321, "epss_percentile": 0.5474}, "CVE-2023-42783": {"epss_score": 0.0086, "epss_percentile": 0.7454}, "CVE-2023-42784": {"epss_score": 0.00138, "epss_percentile": 0.3452}, "CVE-2023-42785": {"epss_score": 0.00738, "epss_percentile": 0.72335}, "CVE-2023-42786": {"epss_score": 0.00738, "epss_percentile": 0.72335}, "CVE-2023-42787": {"epss_score": 0.0075, "epss_percentile": 0.72617}, "CVE-2023-42788": {"epss_score": 0.00305, "epss_percentile": 0.53388}, "CVE-2023-42789": {"epss_score": 0.23641, "epss_percentile": 0.95798}, "CVE-2023-42790": {"epss_score": 0.00131, "epss_percentile": 0.33483}, "CVE-2023-42791": {"epss_score": 0.14375, "epss_percentile": 0.94197}, "CVE-2023-42792": {"epss_score": 0.00741, "epss_percentile": 0.72444}, "CVE-2023-42793": {"epss_score": 0.92913, "epss_percentile": 0.9976}, "CVE-2023-42794": {"epss_score": 0.00317, "epss_percentile": 0.5435}, "CVE-2023-42795": {"epss_score": 0.00692, "epss_percentile": 0.71307}, "CVE-2023-42796": {"epss_score": 0.00287, "epss_percentile": 0.518}, "CVE-2023-42797": {"epss_score": 0.00294, "epss_percentile": 0.52372}, "CVE-2023-42798": {"epss_score": 0.00107, "epss_percentile": 0.29617}, "CVE-2023-42799": {"epss_score": 0.00533, "epss_percentile": 0.66776}, "CVE-2023-42800": {"epss_score": 0.00649, "epss_percentile": 0.70233}, "CVE-2023-42801": {"epss_score": 0.00361, "epss_percentile": 0.57741}, "CVE-2023-42802": {"epss_score": 0.03898, "epss_percentile": 0.87918}, "CVE-2023-42803": {"epss_score": 0.00095, "epss_percentile": 0.27104}, "CVE-2023-42804": {"epss_score": 0.00235, "epss_percentile": 0.46228}, "CVE-2023-42805": {"epss_score": 0.00185, "epss_percentile": 0.40487}, "CVE-2023-42806": {"epss_score": 0.00066, "epss_percentile": 0.20947}, "CVE-2023-42807": {"epss_score": 0.00045, "epss_percentile": 0.13702}, "CVE-2023-42808": {"epss_score": 0.00114, "epss_percentile": 0.30806}, "CVE-2023-42809": {"epss_score": 0.00922, "epss_percentile": 0.75487}, "CVE-2023-42810": {"epss_score": 0.02061, "epss_percentile": 0.83443}, "CVE-2023-42811": {"epss_score": 0.00016, "epss_percentile": 0.0261}, "CVE-2023-42812": {"epss_score": 0.00076, "epss_percentile": 0.23095}, "CVE-2023-42813": {"epss_score": 0.0033, "epss_percentile": 0.55451}, "CVE-2023-42814": {"epss_score": 0.00131, "epss_percentile": 0.33505}, "CVE-2023-42815": {"epss_score": 0.00131, "epss_percentile": 0.33505}, "CVE-2023-42816": {"epss_score": 0.00218, "epss_percentile": 0.44394}, "CVE-2023-42817": {"epss_score": 4e-05, "epss_percentile": 0.00165}, "CVE-2023-42818": {"epss_score": 0.00156, "epss_percentile": 0.36966}, "CVE-2023-42819": {"epss_score": 0.36909, "epss_percentile": 0.97009}, "CVE-2023-42820": {"epss_score": 0.62787, "epss_percentile": 0.98308}, "CVE-2023-42821": {"epss_score": 0.00369, "epss_percentile": 0.58268}, "CVE-2023-42822": {"epss_score": 0.00336, "epss_percentile": 0.55941}, "CVE-2023-42823": {"epss_score": 0.00047, "epss_percentile": 0.14849}, "CVE-2023-42824": {"epss_score": 0.01364, "epss_percentile": 0.79771}, "CVE-2023-42826": {"epss_score": 0.00056, "epss_percentile": 0.17696}, "CVE-2023-42828": {"epss_score": 0.0013, "epss_percentile": 0.33282}, "CVE-2023-42829": {"epss_score": 0.00455, "epss_percentile": 0.63311}, "CVE-2023-42830": {"epss_score": 0.00067, "epss_percentile": 0.21022}, "CVE-2023-42831": {"epss_score": 0.00083, "epss_percentile": 0.24704}, "CVE-2023-42832": {"epss_score": 0.00066, "epss_percentile": 0.20956}, "CVE-2023-42833": {"epss_score": 0.00606, "epss_percentile": 0.69027}, "CVE-2023-42834": {"epss_score": 0.00023, "epss_percentile": 0.0565}, "CVE-2023-42835": {"epss_score": 0.00103, "epss_percentile": 0.29009}, "CVE-2023-42836": {"epss_score": 0.00202, "epss_percentile": 0.42483}, "CVE-2023-42838": {"epss_score": 0.0003, "epss_percentile": 0.08095}, "CVE-2023-42839": {"epss_score": 0.00022, "epss_percentile": 0.05237}, "CVE-2023-42840": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2023-42841": {"epss_score": 0.00046, "epss_percentile": 0.14434}, "CVE-2023-42842": {"epss_score": 0.00041, "epss_percentile": 0.12444}, "CVE-2023-42843": {"epss_score": 0.00085, "epss_percentile": 0.25118}, "CVE-2023-42844": {"epss_score": 0.00342, "epss_percentile": 0.56351}, "CVE-2023-42845": {"epss_score": 0.00146, "epss_percentile": 0.35608}, "CVE-2023-42846": {"epss_score": 0.00216, "epss_percentile": 0.44199}, "CVE-2023-42847": {"epss_score": 0.00154, "epss_percentile": 0.36748}, "CVE-2023-42848": {"epss_score": 0.0003, "epss_percentile": 0.08187}, "CVE-2023-42849": {"epss_score": 0.00184, "epss_percentile": 0.40455}, "CVE-2023-42850": {"epss_score": 0.00031, "epss_percentile": 0.08678}, "CVE-2023-42852": {"epss_score": 0.02353, "epss_percentile": 0.84474}, "CVE-2023-42853": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2023-42854": {"epss_score": 0.00022, "epss_percentile": 0.05131}, "CVE-2023-42855": {"epss_score": 0.0004, "epss_percentile": 0.12097}, "CVE-2023-42856": {"epss_score": 0.00047, "epss_percentile": 0.1486}, "CVE-2023-42857": {"epss_score": 0.00027, "epss_percentile": 0.06827}, "CVE-2023-42858": {"epss_score": 0.00027, "epss_percentile": 0.06829}, "CVE-2023-42859": {"epss_score": 0.00017, "epss_percentile": 0.03407}, "CVE-2023-42860": {"epss_score": 0.00448, "epss_percentile": 0.63013}, "CVE-2023-42861": {"epss_score": 0.00056, "epss_percentile": 0.17756}, "CVE-2023-42862": {"epss_score": 0.00193, "epss_percentile": 0.41386}, "CVE-2023-42865": {"epss_score": 0.00193, "epss_percentile": 0.41386}, "CVE-2023-42866": {"epss_score": 0.00365, "epss_percentile": 0.57973}, "CVE-2023-42867": {"epss_score": 0.00095, "epss_percentile": 0.27182}, "CVE-2023-42869": {"epss_score": 0.00136, "epss_percentile": 0.34191}, "CVE-2023-42870": {"epss_score": 0.00138, "epss_percentile": 0.34365}, "CVE-2023-42871": {"epss_score": 0.00118, "epss_percentile": 0.31405}, "CVE-2023-42872": {"epss_score": 0.00066, "epss_percentile": 0.20749}, "CVE-2023-42873": {"epss_score": 0.00056, "epss_percentile": 0.17881}, "CVE-2023-42874": {"epss_score": 0.00075, "epss_percentile": 0.22957}, "CVE-2023-42875": {"epss_score": 0.00094, "epss_percentile": 0.26991}, "CVE-2023-42876": {"epss_score": 0.00126, "epss_percentile": 0.3268}, "CVE-2023-42877": {"epss_score": 0.00019, "epss_percentile": 0.04357}, "CVE-2023-42878": {"epss_score": 0.00023, "epss_percentile": 0.05486}, "CVE-2023-42881": {"epss_score": 0.00123, "epss_percentile": 0.32178}, "CVE-2023-42882": {"epss_score": 0.00068, "epss_percentile": 0.21211}, "CVE-2023-42883": {"epss_score": 0.00032, "epss_percentile": 0.08815}, "CVE-2023-42884": {"epss_score": 0.0002, "epss_percentile": 0.04622}, "CVE-2023-42886": {"epss_score": 0.00036, "epss_percentile": 0.10302}, "CVE-2023-42887": {"epss_score": 0.0004, "epss_percentile": 0.12097}, "CVE-2023-42888": {"epss_score": 0.00023, "epss_percentile": 0.0537}, "CVE-2023-42889": {"epss_score": 0.00056, "epss_percentile": 0.17929}, "CVE-2023-42890": {"epss_score": 0.00402, "epss_percentile": 0.60267}, "CVE-2023-42891": {"epss_score": 0.00022, "epss_percentile": 0.05063}, "CVE-2023-42892": {"epss_score": 0.00058, "epss_percentile": 0.18283}, "CVE-2023-42893": {"epss_score": 0.00014, "epss_percentile": 0.02012}, "CVE-2023-42894": {"epss_score": 0.00021, "epss_percentile": 0.04845}, "CVE-2023-42896": {"epss_score": 0.00028, "epss_percentile": 0.07475}, "CVE-2023-42897": {"epss_score": 0.00069, "epss_percentile": 0.21556}, "CVE-2023-42898": {"epss_score": 0.00026, "epss_percentile": 0.06534}, "CVE-2023-42899": {"epss_score": 0.00027, "epss_percentile": 0.06899}, "CVE-2023-42900": {"epss_score": 0.00066, "epss_percentile": 0.20934}, "CVE-2023-42901": {"epss_score": 0.00035, "epss_percentile": 0.09964}, "CVE-2023-42902": {"epss_score": 0.00035, "epss_percentile": 0.09964}, "CVE-2023-42903": {"epss_score": 0.00035, "epss_percentile": 0.09964}, "CVE-2023-42904": {"epss_score": 0.00035, "epss_percentile": 0.09964}, "CVE-2023-42905": {"epss_score": 0.00035, "epss_percentile": 0.09964}, "CVE-2023-42906": {"epss_score": 0.00097, "epss_percentile": 0.2763}, "CVE-2023-42907": {"epss_score": 0.00035, "epss_percentile": 0.09964}, "CVE-2023-42908": {"epss_score": 0.00035, "epss_percentile": 0.09964}, "CVE-2023-42909": {"epss_score": 0.00035, "epss_percentile": 0.09964}, "CVE-2023-42910": {"epss_score": 0.00137, "epss_percentile": 0.34204}, "CVE-2023-42911": {"epss_score": 0.00035, "epss_percentile": 0.09964}, "CVE-2023-42912": {"epss_score": 0.00035, "epss_percentile": 0.09964}, "CVE-2023-42913": {"epss_score": 0.00283, "epss_percentile": 0.51354}, "CVE-2023-42914": {"epss_score": 0.00022, "epss_percentile": 0.05056}, "CVE-2023-42916": {"epss_score": 0.00047, "epss_percentile": 0.14687}, "CVE-2023-42917": {"epss_score": 0.00068, "epss_percentile": 0.21219}, "CVE-2023-42918": {"epss_score": 0.00072, "epss_percentile": 0.22384}, "CVE-2023-42919": {"epss_score": 0.00021, "epss_percentile": 0.0478}, "CVE-2023-42920": {"epss_score": 0.00058, "epss_percentile": 0.1842}, "CVE-2023-42922": {"epss_score": 0.0002, "epss_percentile": 0.04622}, "CVE-2023-42923": {"epss_score": 0.00177, "epss_percentile": 0.39497}, "CVE-2023-42924": {"epss_score": 0.00022, "epss_percentile": 0.05183}, "CVE-2023-42925": {"epss_score": 0.00128, "epss_percentile": 0.33016}, "CVE-2023-42926": {"epss_score": 0.00077, "epss_percentile": 0.23467}, "CVE-2023-42928": {"epss_score": 0.00039, "epss_percentile": 0.11592}, "CVE-2023-42929": {"epss_score": 0.00116, "epss_percentile": 0.31183}, "CVE-2023-42930": {"epss_score": 0.00033, "epss_percentile": 0.09388}, "CVE-2023-42931": {"epss_score": 0.02155, "epss_percentile": 0.83804}, "CVE-2023-42932": {"epss_score": 0.00021, "epss_percentile": 0.04845}, "CVE-2023-42933": {"epss_score": 0.0011, "epss_percentile": 0.30173}, "CVE-2023-42934": {"epss_score": 0.00072, "epss_percentile": 0.2238}, "CVE-2023-42935": {"epss_score": 0.00036, "epss_percentile": 0.10214}, "CVE-2023-42936": {"epss_score": 0.00044, "epss_percentile": 0.13366}, "CVE-2023-42937": {"epss_score": 0.0002, "epss_percentile": 0.04622}, "CVE-2023-42938": {"epss_score": 0.00058, "epss_percentile": 0.18457}, "CVE-2023-42939": {"epss_score": 0.00059, "epss_percentile": 0.18863}, "CVE-2023-42940": {"epss_score": 0.00173, "epss_percentile": 0.39087}, "CVE-2023-42941": {"epss_score": 0.001, "epss_percentile": 0.28487}, "CVE-2023-42942": {"epss_score": 0.00096, "epss_percentile": 0.27337}, "CVE-2023-42943": {"epss_score": 0.00224, "epss_percentile": 0.44971}, "CVE-2023-42945": {"epss_score": 0.00057, "epss_percentile": 0.1812}, "CVE-2023-42946": {"epss_score": 0.00082, "epss_percentile": 0.24485}, "CVE-2023-42947": {"epss_score": 0.00041, "epss_percentile": 0.12306}, "CVE-2023-42948": {"epss_score": 0.00151, "epss_percentile": 0.36334}, "CVE-2023-42949": {"epss_score": 0.00142, "epss_percentile": 0.35076}, "CVE-2023-42950": {"epss_score": 0.007, "epss_percentile": 0.71471}, "CVE-2023-42951": {"epss_score": 0.00095, "epss_percentile": 0.2714}, "CVE-2023-42952": {"epss_score": 0.00015, "epss_percentile": 0.02278}, "CVE-2023-42953": {"epss_score": 0.00018, "epss_percentile": 0.03909}, "CVE-2023-42954": {"epss_score": 0.00287, "epss_percentile": 0.51813}, "CVE-2023-42955": {"epss_score": 0.00188, "epss_percentile": 0.40905}, "CVE-2023-42956": {"epss_score": 0.00252, "epss_percentile": 0.4834}, "CVE-2023-42957": {"epss_score": 0.00086, "epss_percentile": 0.25439}, "CVE-2023-42958": {"epss_score": 0.00098, "epss_percentile": 0.27742}, "CVE-2023-42959": {"epss_score": 0.00085, "epss_percentile": 0.25113}, "CVE-2023-42961": {"epss_score": 0.00122, "epss_percentile": 0.32116}, "CVE-2023-42962": {"epss_score": 0.00879, "epss_percentile": 0.74834}, "CVE-2023-42969": {"epss_score": 0.00025, "epss_percentile": 0.06037}, "CVE-2023-42970": {"epss_score": 0.00152, "epss_percentile": 0.36488}, "CVE-2023-42973": {"epss_score": 0.0002, "epss_percentile": 0.04588}, "CVE-2023-42974": {"epss_score": 0.00054, "epss_percentile": 0.17289}, "CVE-2023-42977": {"epss_score": 0.00058, "epss_percentile": 0.18512}, "CVE-2023-42981": {"epss_score": 0.00122, "epss_percentile": 0.32134}, "CVE-2023-42982": {"epss_score": 0.00073, "epss_percentile": 0.2248}, "CVE-2023-42983": {"epss_score": 0.00073, "epss_percentile": 0.2248}, "CVE-2023-43000": {"epss_score": 0.00046, "epss_percentile": 0.14302}, "CVE-2023-43013": {"epss_score": 0.00037, "epss_percentile": 0.1077}, "CVE-2023-43014": {"epss_score": 0.00111, "epss_percentile": 0.30391}, "CVE-2023-43015": {"epss_score": 0.0006, "epss_percentile": 0.18964}, "CVE-2023-43016": {"epss_score": 0.00137, "epss_percentile": 0.34273}, "CVE-2023-43017": {"epss_score": 0.0002, "epss_percentile": 0.04545}, "CVE-2023-43018": {"epss_score": 0.00048, "epss_percentile": 0.15137}, "CVE-2023-43021": {"epss_score": 0.00043, "epss_percentile": 0.13026}, "CVE-2023-43029": {"epss_score": 0.00079, "epss_percentile": 0.23824}, "CVE-2023-43035": {"epss_score": 0.00022, "epss_percentile": 0.04989}, "CVE-2023-43037": {"epss_score": 0.00077, "epss_percentile": 0.23436}, "CVE-2023-43039": {"epss_score": 0.00019, "epss_percentile": 0.04416}, "CVE-2023-43040": {"epss_score": 0.06202, "epss_percentile": 0.90561}, "CVE-2023-43041": {"epss_score": 0.00047, "epss_percentile": 0.14854}, "CVE-2023-43042": {"epss_score": 0.0013, "epss_percentile": 0.33248}, "CVE-2023-43043": {"epss_score": 0.00023, "epss_percentile": 0.0562}, "CVE-2023-43044": {"epss_score": 0.00087, "epss_percentile": 0.25542}, "CVE-2023-43045": {"epss_score": 0.0003, "epss_percentile": 0.08254}, "CVE-2023-43051": {"epss_score": 0.00171, "epss_percentile": 0.38828}, "CVE-2023-43052": {"epss_score": 0.00081, "epss_percentile": 0.24236}, "CVE-2023-43054": {"epss_score": 0.00147, "epss_percentile": 0.3571}, "CVE-2023-43057": {"epss_score": 0.0006, "epss_percentile": 0.18964}, "CVE-2023-43058": {"epss_score": 0.00046, "epss_percentile": 0.14307}, "CVE-2023-43064": {"epss_score": 0.00032, "epss_percentile": 0.08962}, "CVE-2023-43065": {"epss_score": 0.0004, "epss_percentile": 0.11919}, "CVE-2023-43066": {"epss_score": 4e-05, "epss_percentile": 0.00168}, "CVE-2023-43067": {"epss_score": 0.00022, "epss_percentile": 0.05001}, "CVE-2023-43068": {"epss_score": 0.00341, "epss_percentile": 0.56302}, "CVE-2023-43069": {"epss_score": 0.00085, "epss_percentile": 0.25072}, "CVE-2023-43070": {"epss_score": 0.00057, "epss_percentile": 0.18043}, "CVE-2023-43071": {"epss_score": 0.00112, "epss_percentile": 0.30512}, "CVE-2023-43072": {"epss_score": 0.00034, "epss_percentile": 0.09742}, "CVE-2023-43073": {"epss_score": 0.00067, "epss_percentile": 0.21034}, "CVE-2023-43074": {"epss_score": 0.00035, "epss_percentile": 0.09992}, "CVE-2023-43076": {"epss_score": 0.00572, "epss_percentile": 0.68034}, "CVE-2023-43078": {"epss_score": 0.00042, "epss_percentile": 0.12581}, "CVE-2023-43079": {"epss_score": 0.00024, "epss_percentile": 0.06028}, "CVE-2023-43081": {"epss_score": 0.00036, "epss_percentile": 0.10282}, "CVE-2023-43082": {"epss_score": 0.00148, "epss_percentile": 0.35829}, "CVE-2023-43086": {"epss_score": 0.0003, "epss_percentile": 0.08245}, "CVE-2023-43087": {"epss_score": 0.00121, "epss_percentile": 0.31955}, "CVE-2023-43088": {"epss_score": 0.00051, "epss_percentile": 0.16011}, "CVE-2023-43089": {"epss_score": 0.00022, "epss_percentile": 0.04976}, "CVE-2023-43090": {"epss_score": 0.00093, "epss_percentile": 0.26663}, "CVE-2023-43091": {"epss_score": 0.00287, "epss_percentile": 0.51784}, "CVE-2023-43102": {"epss_score": 0.00481, "epss_percentile": 0.64518}, "CVE-2023-43103": {"epss_score": 0.0042, "epss_percentile": 0.61407}, "CVE-2023-43114": {"epss_score": 0.00051, "epss_percentile": 0.16046}, "CVE-2023-43115": {"epss_score": 0.21336, "epss_percentile": 0.95502}, "CVE-2023-43116": {"epss_score": 0.00091, "epss_percentile": 0.26209}, "CVE-2023-43118": {"epss_score": 0.00115, "epss_percentile": 0.30977}, "CVE-2023-43119": {"epss_score": 0.00373, "epss_percentile": 0.58525}, "CVE-2023-43120": {"epss_score": 0.01588, "epss_percentile": 0.8119}, "CVE-2023-43121": {"epss_score": 0.01402, "epss_percentile": 0.80014}, "CVE-2023-43122": {"epss_score": 0.00041, "epss_percentile": 0.12233}, "CVE-2023-43123": {"epss_score": 0.00036, "epss_percentile": 0.10399}, "CVE-2023-43124": {"epss_score": 0.00079, "epss_percentile": 0.23962}, "CVE-2023-43125": {"epss_score": 0.0015, "epss_percentile": 0.36088}, "CVE-2023-43128": {"epss_score": 0.0109, "epss_percentile": 0.77455}, "CVE-2023-43129": {"epss_score": 0.0109, "epss_percentile": 0.77455}, "CVE-2023-43130": {"epss_score": 0.0109, "epss_percentile": 0.77455}, "CVE-2023-43131": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-43132": {"epss_score": 0.00156, "epss_percentile": 0.3689}, "CVE-2023-43134": {"epss_score": 0.00091, "epss_percentile": 0.26377}, "CVE-2023-43135": {"epss_score": 0.00091, "epss_percentile": 0.26377}, "CVE-2023-43137": {"epss_score": 0.01228, "epss_percentile": 0.78708}, "CVE-2023-43138": {"epss_score": 0.01228, "epss_percentile": 0.78708}, "CVE-2023-43139": {"epss_score": 0.01589, "epss_percentile": 0.81195}, "CVE-2023-43141": {"epss_score": 0.00074, "epss_percentile": 0.22726}, "CVE-2023-43144": {"epss_score": 0.02778, "epss_percentile": 0.85644}, "CVE-2023-43147": {"epss_score": 0.00263, "epss_percentile": 0.49506}, "CVE-2023-43148": {"epss_score": 0.00758, "epss_percentile": 0.72772}, "CVE-2023-43149": {"epss_score": 0.00773, "epss_percentile": 0.7306}, "CVE-2023-43154": {"epss_score": 0.00415, "epss_percentile": 0.61111}, "CVE-2023-43176": {"epss_score": 0.00225, "epss_percentile": 0.45099}, "CVE-2023-43177": {"epss_score": 0.76822, "epss_percentile": 0.98907}, "CVE-2023-43183": {"epss_score": 0.00109, "epss_percentile": 0.29954}, "CVE-2023-43187": {"epss_score": 0.90105, "epss_percentile": 0.9956}, "CVE-2023-43191": {"epss_score": 0.00176, "epss_percentile": 0.39467}, "CVE-2023-43192": {"epss_score": 0.00167, "epss_percentile": 0.38344}, "CVE-2023-43193": {"epss_score": 0.00605, "epss_percentile": 0.68972}, "CVE-2023-43194": {"epss_score": 0.00236, "epss_percentile": 0.46461}, "CVE-2023-43196": {"epss_score": 0.00702, "epss_percentile": 0.71513}, "CVE-2023-43197": {"epss_score": 0.00702, "epss_percentile": 0.71513}, "CVE-2023-43198": {"epss_score": 0.00702, "epss_percentile": 0.71513}, "CVE-2023-43199": {"epss_score": 0.00702, "epss_percentile": 0.71513}, "CVE-2023-43200": {"epss_score": 0.00702, "epss_percentile": 0.71513}, "CVE-2023-43201": {"epss_score": 0.01914, "epss_percentile": 0.82849}, "CVE-2023-43202": {"epss_score": 0.01497, "epss_percentile": 0.80687}, "CVE-2023-43203": {"epss_score": 0.00506, "epss_percentile": 0.65642}, "CVE-2023-43204": {"epss_score": 0.01497, "epss_percentile": 0.80687}, "CVE-2023-43206": {"epss_score": 0.01608, "epss_percentile": 0.81311}, "CVE-2023-43207": {"epss_score": 0.01497, "epss_percentile": 0.80687}, "CVE-2023-43208": {"epss_score": 0.94416, "epss_percentile": 0.99977}, "CVE-2023-43216": {"epss_score": 0.00362, "epss_percentile": 0.57799}, "CVE-2023-43222": {"epss_score": 0.00228, "epss_percentile": 0.45527}, "CVE-2023-43226": {"epss_score": 0.00156, "epss_percentile": 0.36935}, "CVE-2023-43232": {"epss_score": 0.00585, "epss_percentile": 0.68414}, "CVE-2023-43233": {"epss_score": 0.00197, "epss_percentile": 0.41934}, "CVE-2023-43234": {"epss_score": 0.00261, "epss_percentile": 0.49267}, "CVE-2023-43235": {"epss_score": 0.01914, "epss_percentile": 0.82849}, "CVE-2023-43236": {"epss_score": 0.01914, "epss_percentile": 0.82849}, "CVE-2023-43237": {"epss_score": 0.55358, "epss_percentile": 0.97974}, "CVE-2023-43238": {"epss_score": 0.01914, "epss_percentile": 0.82849}, "CVE-2023-43239": {"epss_score": 0.55358, "epss_percentile": 0.97974}, "CVE-2023-43240": {"epss_score": 0.55358, "epss_percentile": 0.97974}, "CVE-2023-43241": {"epss_score": 0.01914, "epss_percentile": 0.82849}, "CVE-2023-43242": {"epss_score": 0.02484, "epss_percentile": 0.84882}, "CVE-2023-43250": {"epss_score": 0.00176, "epss_percentile": 0.3943}, "CVE-2023-43251": {"epss_score": 0.00235, "epss_percentile": 0.46199}, "CVE-2023-43252": {"epss_score": 0.00238, "epss_percentile": 0.46775}, "CVE-2023-43256": {"epss_score": 0.00125, "epss_percentile": 0.32496}, "CVE-2023-43260": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-43261": {"epss_score": 0.93058, "epss_percentile": 0.99772}, "CVE-2023-43263": {"epss_score": 0.00956, "epss_percentile": 0.75924}, "CVE-2023-43267": {"epss_score": 0.00223, "epss_percentile": 0.4485}, "CVE-2023-43268": {"epss_score": 0.00124, "epss_percentile": 0.32414}, "CVE-2023-43269": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-43270": {"epss_score": 0.01836, "epss_percentile": 0.82471}, "CVE-2023-43271": {"epss_score": 0.00225, "epss_percentile": 0.45121}, "CVE-2023-43274": {"epss_score": 0.00062, "epss_percentile": 0.19709}, "CVE-2023-43275": {"epss_score": 0.00131, "epss_percentile": 0.3338}, "CVE-2023-43278": {"epss_score": 0.0023, "epss_percentile": 0.45716}, "CVE-2023-43279": {"epss_score": 0.00015, "epss_percentile": 0.02235}, "CVE-2023-43281": {"epss_score": 0.00212, "epss_percentile": 0.43775}, "CVE-2023-43284": {"epss_score": 0.30329, "epss_percentile": 0.9653}, "CVE-2023-43291": {"epss_score": 0.13133, "epss_percentile": 0.93882}, "CVE-2023-43292": {"epss_score": 0.00101, "epss_percentile": 0.28585}, "CVE-2023-43295": {"epss_score": 0.00291, "epss_percentile": 0.52209}, "CVE-2023-43297": {"epss_score": 0.00137, "epss_percentile": 0.34222}, "CVE-2023-43298": {"epss_score": 0.00162, "epss_percentile": 0.37642}, "CVE-2023-43299": {"epss_score": 0.00162, "epss_percentile": 0.37642}, "CVE-2023-43300": {"epss_score": 0.00228, "epss_percentile": 0.45524}, "CVE-2023-43301": {"epss_score": 0.00241, "epss_percentile": 0.47278}, "CVE-2023-43302": {"epss_score": 0.00228, "epss_percentile": 0.45524}, "CVE-2023-43303": {"epss_score": 0.00228, "epss_percentile": 0.45524}, "CVE-2023-43304": {"epss_score": 0.00198, "epss_percentile": 0.42091}, "CVE-2023-43305": {"epss_score": 0.00102, "epss_percentile": 0.28807}, "CVE-2023-43309": {"epss_score": 0.00063, "epss_percentile": 0.1988}, "CVE-2023-43314": {"epss_score": 0.00218, "epss_percentile": 0.44375}, "CVE-2023-43317": {"epss_score": 0.06957, "epss_percentile": 0.91146}, "CVE-2023-43318": {"epss_score": 0.00421, "epss_percentile": 0.6153}, "CVE-2023-43319": {"epss_score": 0.00256, "epss_percentile": 0.48787}, "CVE-2023-43320": {"epss_score": 0.03153, "epss_percentile": 0.86508}, "CVE-2023-43321": {"epss_score": 0.00229, "epss_percentile": 0.45557}, "CVE-2023-43322": {"epss_score": 0.00664, "epss_percentile": 0.70638}, "CVE-2023-43323": {"epss_score": 0.68741, "epss_percentile": 0.98561}, "CVE-2023-43325": {"epss_score": 0.09271, "epss_percentile": 0.92475}, "CVE-2023-43326": {"epss_score": 0.23151, "epss_percentile": 0.95741}, "CVE-2023-43331": {"epss_score": 0.0027, "epss_percentile": 0.5025}, "CVE-2023-43336": {"epss_score": 0.0008, "epss_percentile": 0.24069}, "CVE-2023-43338": {"epss_score": 0.0029, "epss_percentile": 0.52136}, "CVE-2023-43339": {"epss_score": 0.00176, "epss_percentile": 0.39377}, "CVE-2023-43340": {"epss_score": 0.01088, "epss_percentile": 0.77439}, "CVE-2023-43341": {"epss_score": 0.00319, "epss_percentile": 0.54554}, "CVE-2023-43342": {"epss_score": 0.00217, "epss_percentile": 0.44251}, "CVE-2023-43343": {"epss_score": 0.00486, "epss_percentile": 0.64748}, "CVE-2023-43344": {"epss_score": 0.00389, "epss_percentile": 0.59477}, "CVE-2023-43345": {"epss_score": 0.00139, "epss_percentile": 0.34658}, "CVE-2023-43346": {"epss_score": 0.00484, "epss_percentile": 0.64637}, "CVE-2023-43352": {"epss_score": 0.00664, "epss_percentile": 0.7063}, "CVE-2023-43353": {"epss_score": 0.00235, "epss_percentile": 0.46222}, "CVE-2023-43354": {"epss_score": 0.00235, "epss_percentile": 0.46222}, "CVE-2023-43355": {"epss_score": 0.00504, "epss_percentile": 0.65521}, "CVE-2023-43356": {"epss_score": 0.00255, "epss_percentile": 0.48734}, "CVE-2023-43357": {"epss_score": 0.00255, "epss_percentile": 0.48734}, "CVE-2023-43358": {"epss_score": 0.00152, "epss_percentile": 0.36488}, "CVE-2023-43359": {"epss_score": 0.00112, "epss_percentile": 0.30513}, "CVE-2023-43360": {"epss_score": 0.00386, "epss_percentile": 0.5924}, "CVE-2023-43361": {"epss_score": 0.00028, "epss_percentile": 0.07316}, "CVE-2023-43364": {"epss_score": 0.29638, "epss_percentile": 0.96463}, "CVE-2023-43371": {"epss_score": 0.00296, "epss_percentile": 0.52581}, "CVE-2023-43373": {"epss_score": 0.17195, "epss_percentile": 0.94796}, "CVE-2023-43374": {"epss_score": 0.17195, "epss_percentile": 0.94796}, "CVE-2023-43375": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-43376": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-43377": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2023-43378": {"epss_score": 0.00053, "epss_percentile": 0.16872}, "CVE-2023-43381": {"epss_score": 0.00633, "epss_percentile": 0.69764}, "CVE-2023-43382": {"epss_score": 0.02724, "epss_percentile": 0.85523}, "CVE-2023-43449": {"epss_score": 0.00165, "epss_percentile": 0.38118}, "CVE-2023-43453": {"epss_score": 0.03931, "epss_percentile": 0.87973}, "CVE-2023-43454": {"epss_score": 0.03931, "epss_percentile": 0.87973}, "CVE-2023-43455": {"epss_score": 0.03931, "epss_percentile": 0.87973}, "CVE-2023-43456": {"epss_score": 0.0084, "epss_percentile": 0.74202}, "CVE-2023-43457": {"epss_score": 0.01265, "epss_percentile": 0.79008}, "CVE-2023-43458": {"epss_score": 0.00342, "epss_percentile": 0.56352}, "CVE-2023-43468": {"epss_score": 0.01752, "epss_percentile": 0.82109}, "CVE-2023-43469": {"epss_score": 0.01411, "epss_percentile": 0.80109}, "CVE-2023-43470": {"epss_score": 0.01297, "epss_percentile": 0.79268}, "CVE-2023-43472": {"epss_score": 0.74435, "epss_percentile": 0.988}, "CVE-2023-43477": {"epss_score": 0.20768, "epss_percentile": 0.9541}, "CVE-2023-43478": {"epss_score": 0.04132, "epss_percentile": 0.88301}, "CVE-2023-43481": {"epss_score": 0.01382, "epss_percentile": 0.79888}, "CVE-2023-43482": {"epss_score": 0.04174, "epss_percentile": 0.8835}, "CVE-2023-43484": {"epss_score": 0.00234, "epss_percentile": 0.46161}, "CVE-2023-43485": {"epss_score": 0.00226, "epss_percentile": 0.45296}, "CVE-2023-43487": {"epss_score": 0.00037, "epss_percentile": 0.11006}, "CVE-2023-43488": {"epss_score": 0.0006, "epss_percentile": 0.19205}, "CVE-2023-43489": {"epss_score": 0.00094, "epss_percentile": 0.26802}, "CVE-2023-43490": {"epss_score": 0.00022, "epss_percentile": 0.05245}, "CVE-2023-43491": {"epss_score": 0.00599, "epss_percentile": 0.68791}, "CVE-2023-43492": {"epss_score": 0.0008, "epss_percentile": 0.2405}, "CVE-2023-43493": {"epss_score": 0.00393, "epss_percentile": 0.59725}, "CVE-2023-43494": {"epss_score": 0.48623, "epss_percentile": 0.97645}, "CVE-2023-43495": {"epss_score": 0.00746, "epss_percentile": 0.72536}, "CVE-2023-43496": {"epss_score": 0.00184, "epss_percentile": 0.40418}, "CVE-2023-43497": {"epss_score": 0.00066, "epss_percentile": 0.2073}, "CVE-2023-43498": {"epss_score": 0.00104, "epss_percentile": 0.29141}, "CVE-2023-43499": {"epss_score": 0.04105, "epss_percentile": 0.88266}, "CVE-2023-43500": {"epss_score": 0.00063, "epss_percentile": 0.19932}, "CVE-2023-43501": {"epss_score": 0.00036, "epss_percentile": 0.10524}, "CVE-2023-43502": {"epss_score": 0.00043, "epss_percentile": 0.13341}, "CVE-2023-43503": {"epss_score": 0.00215, "epss_percentile": 0.44024}, "CVE-2023-43504": {"epss_score": 0.00231, "epss_percentile": 0.45846}, "CVE-2023-43505": {"epss_score": 0.00168, "epss_percentile": 0.38427}, "CVE-2023-43506": {"epss_score": 0.00115, "epss_percentile": 0.30928}, "CVE-2023-43507": {"epss_score": 0.00414, "epss_percentile": 0.61023}, "CVE-2023-43508": {"epss_score": 0.00102, "epss_percentile": 0.28858}, "CVE-2023-43509": {"epss_score": 0.00276, "epss_percentile": 0.5071}, "CVE-2023-43510": {"epss_score": 0.0029, "epss_percentile": 0.52086}, "CVE-2023-43511": {"epss_score": 0.00325, "epss_percentile": 0.55032}, "CVE-2023-43512": {"epss_score": 0.00294, "epss_percentile": 0.52403}, "CVE-2023-43513": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-43514": {"epss_score": 0.00112, "epss_percentile": 0.30499}, "CVE-2023-43515": {"epss_score": 0.00048, "epss_percentile": 0.14949}, "CVE-2023-43516": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-43517": {"epss_score": 0.00048, "epss_percentile": 0.15002}, "CVE-2023-43518": {"epss_score": 0.00107, "epss_percentile": 0.29734}, "CVE-2023-43519": {"epss_score": 0.00107, "epss_percentile": 0.29734}, "CVE-2023-43520": {"epss_score": 0.00266, "epss_percentile": 0.49898}, "CVE-2023-43521": {"epss_score": 0.0003, "epss_percentile": 0.08261}, "CVE-2023-43522": {"epss_score": 0.00145, "epss_percentile": 0.35427}, "CVE-2023-43523": {"epss_score": 0.00144, "epss_percentile": 0.35248}, "CVE-2023-43524": {"epss_score": 0.00042, "epss_percentile": 0.12492}, "CVE-2023-43525": {"epss_score": 0.00042, "epss_percentile": 0.12492}, "CVE-2023-43526": {"epss_score": 0.00042, "epss_percentile": 0.12492}, "CVE-2023-43527": {"epss_score": 0.00064, "epss_percentile": 0.20289}, "CVE-2023-43528": {"epss_score": 0.00056, "epss_percentile": 0.17853}, "CVE-2023-43529": {"epss_score": 0.00153, "epss_percentile": 0.36574}, "CVE-2023-43530": {"epss_score": 0.00056, "epss_percentile": 0.17958}, "CVE-2023-43531": {"epss_score": 0.00062, "epss_percentile": 0.19568}, "CVE-2023-43532": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-43533": {"epss_score": 0.00122, "epss_percentile": 0.32067}, "CVE-2023-43534": {"epss_score": 0.0021, "epss_percentile": 0.43473}, "CVE-2023-43535": {"epss_score": 0.00053, "epss_percentile": 0.17027}, "CVE-2023-43536": {"epss_score": 0.00123, "epss_percentile": 0.32301}, "CVE-2023-43537": {"epss_score": 0.00124, "epss_percentile": 0.32389}, "CVE-2023-43538": {"epss_score": 0.00055, "epss_percentile": 0.17542}, "CVE-2023-43539": {"epss_score": 0.00194, "epss_percentile": 0.41559}, "CVE-2023-43540": {"epss_score": 0.00124, "epss_percentile": 0.32383}, "CVE-2023-43541": {"epss_score": 0.00095, "epss_percentile": 0.27114}, "CVE-2023-43542": {"epss_score": 0.00055, "epss_percentile": 0.17542}, "CVE-2023-43543": {"epss_score": 0.00037, "epss_percentile": 0.10903}, "CVE-2023-43544": {"epss_score": 0.00037, "epss_percentile": 0.10903}, "CVE-2023-43545": {"epss_score": 0.00037, "epss_percentile": 0.10903}, "CVE-2023-43546": {"epss_score": 0.00095, "epss_percentile": 0.27114}, "CVE-2023-43547": {"epss_score": 0.00095, "epss_percentile": 0.27114}, "CVE-2023-43548": {"epss_score": 0.00144, "epss_percentile": 0.35345}, "CVE-2023-43549": {"epss_score": 0.00095, "epss_percentile": 0.27114}, "CVE-2023-43550": {"epss_score": 0.00095, "epss_percentile": 0.27114}, "CVE-2023-43551": {"epss_score": 0.00095, "epss_percentile": 0.27137}, "CVE-2023-43552": {"epss_score": 0.00227, "epss_percentile": 0.45385}, "CVE-2023-43553": {"epss_score": 0.00291, "epss_percentile": 0.52176}, "CVE-2023-43554": {"epss_score": 0.00055, "epss_percentile": 0.17542}, "CVE-2023-43555": {"epss_score": 0.00127, "epss_percentile": 0.32829}, "CVE-2023-43556": {"epss_score": 0.00055, "epss_percentile": 0.17542}, "CVE-2023-43566": {"epss_score": 0.00016, "epss_percentile": 0.02638}, "CVE-2023-43567": {"epss_score": 0.00066, "epss_percentile": 0.20941}, "CVE-2023-43568": {"epss_score": 0.00066, "epss_percentile": 0.2077}, "CVE-2023-43569": {"epss_score": 0.00066, "epss_percentile": 0.20941}, "CVE-2023-43570": {"epss_score": 0.00047, "epss_percentile": 0.14808}, "CVE-2023-43571": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2023-43572": {"epss_score": 0.00036, "epss_percentile": 0.10201}, "CVE-2023-43573": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2023-43574": {"epss_score": 0.00036, "epss_percentile": 0.10201}, "CVE-2023-43575": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2023-43576": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2023-43577": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2023-43578": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2023-43579": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2023-43580": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2023-43581": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2023-43582": {"epss_score": 0.00163, "epss_percentile": 0.37828}, "CVE-2023-43583": {"epss_score": 0.00118, "epss_percentile": 0.31505}, "CVE-2023-43585": {"epss_score": 0.00129, "epss_percentile": 0.33117}, "CVE-2023-43586": {"epss_score": 0.00076, "epss_percentile": 0.23247}, "CVE-2023-43588": {"epss_score": 0.00268, "epss_percentile": 0.5008}, "CVE-2023-43590": {"epss_score": 0.00113, "epss_percentile": 0.30654}, "CVE-2023-43591": {"epss_score": 0.00081, "epss_percentile": 0.24372}, "CVE-2023-43608": {"epss_score": 0.00122, "epss_percentile": 0.32028}, "CVE-2023-43609": {"epss_score": 0.00157, "epss_percentile": 0.37054}, "CVE-2023-43610": {"epss_score": 0.00441, "epss_percentile": 0.62667}, "CVE-2023-43611": {"epss_score": 0.00105, "epss_percentile": 0.29273}, "CVE-2023-43612": {"epss_score": 0.00022, "epss_percentile": 0.04998}, "CVE-2023-43614": {"epss_score": 0.00235, "epss_percentile": 0.46332}, "CVE-2023-43615": {"epss_score": 0.00309, "epss_percentile": 0.53704}, "CVE-2023-43616": {"epss_score": 0.00078, "epss_percentile": 0.23586}, "CVE-2023-43617": {"epss_score": 0.00128, "epss_percentile": 0.33068}, "CVE-2023-43618": {"epss_score": 0.00076, "epss_percentile": 0.23276}, "CVE-2023-43619": {"epss_score": 0.00038, "epss_percentile": 0.11389}, "CVE-2023-43620": {"epss_score": 0.00038, "epss_percentile": 0.11389}, "CVE-2023-43621": {"epss_score": 0.00042, "epss_percentile": 0.12834}, "CVE-2023-43622": {"epss_score": 0.59064, "epss_percentile": 0.98147}, "CVE-2023-43623": {"epss_score": 0.0023, "epss_percentile": 0.45677}, "CVE-2023-43624": {"epss_score": 0.00036, "epss_percentile": 0.10609}, "CVE-2023-43625": {"epss_score": 0.00993, "epss_percentile": 0.7641}, "CVE-2023-43626": {"epss_score": 0.0005, "epss_percentile": 0.15661}, "CVE-2023-43627": {"epss_score": 0.00128, "epss_percentile": 0.32953}, "CVE-2023-43628": {"epss_score": 0.00202, "epss_percentile": 0.42428}, "CVE-2023-43629": {"epss_score": 0.00074, "epss_percentile": 0.22794}, "CVE-2023-43630": {"epss_score": 0.00013, "epss_percentile": 0.01538}, "CVE-2023-43631": {"epss_score": 0.00035, "epss_percentile": 0.10123}, "CVE-2023-43632": {"epss_score": 0.00084, "epss_percentile": 0.25026}, "CVE-2023-43633": {"epss_score": 0.00027, "epss_percentile": 0.06938}, "CVE-2023-43634": {"epss_score": 0.00035, "epss_percentile": 0.10123}, "CVE-2023-43635": {"epss_score": 0.00013, "epss_percentile": 0.01538}, "CVE-2023-43636": {"epss_score": 0.00025, "epss_percentile": 0.06117}, "CVE-2023-43637": {"epss_score": 0.00027, "epss_percentile": 0.06938}, "CVE-2023-43640": {"epss_score": 0.00267, "epss_percentile": 0.50017}, "CVE-2023-43641": {"epss_score": 0.81559, "epss_percentile": 0.99145}, "CVE-2023-43642": {"epss_score": 0.0019, "epss_percentile": 0.41055}, "CVE-2023-43643": {"epss_score": 0.00463, "epss_percentile": 0.63667}, "CVE-2023-43644": {"epss_score": 0.00174, "epss_percentile": 0.39218}, "CVE-2023-43645": {"epss_score": 0.00346, "epss_percentile": 0.56709}, "CVE-2023-43646": {"epss_score": 0.00833, "epss_percentile": 0.7409}, "CVE-2023-43647": {"epss_score": 0.00572, "epss_percentile": 0.68006}, "CVE-2023-43648": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2023-43649": {"epss_score": 0.00107, "epss_percentile": 0.2973}, "CVE-2023-43650": {"epss_score": 0.00391, "epss_percentile": 0.59625}, "CVE-2023-43651": {"epss_score": 0.13919, "epss_percentile": 0.94092}, "CVE-2023-43652": {"epss_score": 0.00629, "epss_percentile": 0.69674}, "CVE-2023-43654": {"epss_score": 0.91846, "epss_percentile": 0.99672}, "CVE-2023-43655": {"epss_score": 0.01891, "epss_percentile": 0.82731}, "CVE-2023-43656": {"epss_score": 0.00296, "epss_percentile": 0.52578}, "CVE-2023-43657": {"epss_score": 0.00412, "epss_percentile": 0.60952}, "CVE-2023-43658": {"epss_score": 0.00566, "epss_percentile": 0.67809}, "CVE-2023-43659": {"epss_score": 0.00628, "epss_percentile": 0.69651}, "CVE-2023-43660": {"epss_score": 0.00038, "epss_percentile": 0.11099}, "CVE-2023-43661": {"epss_score": 0.18169, "epss_percentile": 0.94969}, "CVE-2023-43662": {"epss_score": 0.91689, "epss_percentile": 0.99662}, "CVE-2023-43663": {"epss_score": 0.00102, "epss_percentile": 0.28815}, "CVE-2023-43664": {"epss_score": 0.00239, "epss_percentile": 0.469}, "CVE-2023-43665": {"epss_score": 0.0279, "epss_percentile": 0.85665}, "CVE-2023-43666": {"epss_score": 0.00524, "epss_percentile": 0.66353}, "CVE-2023-43667": {"epss_score": 0.01932, "epss_percentile": 0.82947}, "CVE-2023-43668": {"epss_score": 0.00054, "epss_percentile": 0.17358}, "CVE-2023-43669": {"epss_score": 0.03217, "epss_percentile": 0.86665}, "CVE-2023-43683": {"epss_score": 0.00072, "epss_percentile": 0.22296}, "CVE-2023-43687": {"epss_score": 0.0008, "epss_percentile": 0.24188}, "CVE-2023-43692": {"epss_score": 0.00077, "epss_percentile": 0.2346}, "CVE-2023-43694": {"epss_score": 0.00028, "epss_percentile": 0.07481}, "CVE-2023-43696": {"epss_score": 0.00222, "epss_percentile": 0.44805}, "CVE-2023-43697": {"epss_score": 0.00354, "epss_percentile": 0.5725}, "CVE-2023-43698": {"epss_score": 0.00114, "epss_percentile": 0.30805}, "CVE-2023-43699": {"epss_score": 0.00198, "epss_percentile": 0.42028}, "CVE-2023-43700": {"epss_score": 0.00193, "epss_percentile": 0.41391}, "CVE-2023-43701": {"epss_score": 0.00188, "epss_percentile": 0.40845}, "CVE-2023-43702": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43703": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43704": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43705": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43706": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43707": {"epss_score": 0.00105, "epss_percentile": 0.29322}, "CVE-2023-43708": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43709": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43710": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43711": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43712": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43713": {"epss_score": 0.00105, "epss_percentile": 0.29322}, "CVE-2023-43714": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43715": {"epss_score": 0.00105, "epss_percentile": 0.29322}, "CVE-2023-43716": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43717": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43718": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43719": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43720": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43721": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43722": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43723": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43724": {"epss_score": 0.00105, "epss_percentile": 0.29322}, "CVE-2023-43725": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43726": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43727": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43728": {"epss_score": 0.00105, "epss_percentile": 0.29322}, "CVE-2023-43729": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43730": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43731": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43732": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43733": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43734": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43735": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-43739": {"epss_score": 0.00218, "epss_percentile": 0.44361}, "CVE-2023-43740": {"epss_score": 0.02099, "epss_percentile": 0.83594}, "CVE-2023-43741": {"epss_score": 0.00011, "epss_percentile": 0.00971}, "CVE-2023-43742": {"epss_score": 0.0009, "epss_percentile": 0.26007}, "CVE-2023-43743": {"epss_score": 0.00087, "epss_percentile": 0.25557}, "CVE-2023-43744": {"epss_score": 0.00186, "epss_percentile": 0.40691}, "CVE-2023-43745": {"epss_score": 0.00042, "epss_percentile": 0.12561}, "CVE-2023-43746": {"epss_score": 0.00056, "epss_percentile": 0.17955}, "CVE-2023-43747": {"epss_score": 0.00028, "epss_percentile": 0.07311}, "CVE-2023-43748": {"epss_score": 0.00094, "epss_percentile": 0.27076}, "CVE-2023-43751": {"epss_score": 0.00127, "epss_percentile": 0.32804}, "CVE-2023-43752": {"epss_score": 0.00157, "epss_percentile": 0.37106}, "CVE-2023-43753": {"epss_score": 0.00023, "epss_percentile": 0.05503}, "CVE-2023-43754": {"epss_score": 0.00352, "epss_percentile": 0.57123}, "CVE-2023-43755": {"epss_score": 0.00789, "epss_percentile": 0.73349}, "CVE-2023-43756": {"epss_score": 0.00032, "epss_percentile": 0.08996}, "CVE-2023-43757": {"epss_score": 0.00044, "epss_percentile": 0.13659}, "CVE-2023-43758": {"epss_score": 0.00038, "epss_percentile": 0.11234}, "CVE-2023-43760": {"epss_score": 0.00244, "epss_percentile": 0.47615}, "CVE-2023-43761": {"epss_score": 0.00286, "epss_percentile": 0.51697}, "CVE-2023-43762": {"epss_score": 0.02277, "epss_percentile": 0.84229}, "CVE-2023-43763": {"epss_score": 0.00435, "epss_percentile": 0.62365}, "CVE-2023-43765": {"epss_score": 0.00244, "epss_percentile": 0.47615}, "CVE-2023-43766": {"epss_score": 0.00044, "epss_percentile": 0.13414}, "CVE-2023-43767": {"epss_score": 0.0021, "epss_percentile": 0.43499}, "CVE-2023-43768": {"epss_score": 0.00504, "epss_percentile": 0.65526}, "CVE-2023-43769": {"epss_score": 0.0015, "epss_percentile": 0.36134}, "CVE-2023-43770": {"epss_score": 0.73059, "epss_percentile": 0.98735}, "CVE-2023-43771": {"epss_score": 0.0004, "epss_percentile": 0.11902}, "CVE-2023-43775": {"epss_score": 0.0005, "epss_percentile": 0.15953}, "CVE-2023-43776": {"epss_score": 0.00028, "epss_percentile": 0.07356}, "CVE-2023-43777": {"epss_score": 0.00055, "epss_percentile": 0.17615}, "CVE-2023-43782": {"epss_score": 0.00018, "epss_percentile": 0.0385}, "CVE-2023-43783": {"epss_score": 0.0005, "epss_percentile": 0.15979}, "CVE-2023-43784": {"epss_score": 0.00152, "epss_percentile": 0.3649}, "CVE-2023-43785": {"epss_score": 0.001, "epss_percentile": 0.28453}, "CVE-2023-43786": {"epss_score": 0.00084, "epss_percentile": 0.24886}, "CVE-2023-43787": {"epss_score": 0.00042, "epss_percentile": 0.12605}, "CVE-2023-43788": {"epss_score": 0.00023, "epss_percentile": 0.05337}, "CVE-2023-43789": {"epss_score": 0.00035, "epss_percentile": 0.10155}, "CVE-2023-43790": {"epss_score": 0.00779, "epss_percentile": 0.73144}, "CVE-2023-43791": {"epss_score": 0.00824, "epss_percentile": 0.73935}, "CVE-2023-43792": {"epss_score": 0.0034, "epss_percentile": 0.5623}, "CVE-2023-43793": {"epss_score": 0.00214, "epss_percentile": 0.43959}, "CVE-2023-43794": {"epss_score": 0.00263, "epss_percentile": 0.49523}, "CVE-2023-43795": {"epss_score": 0.89488, "epss_percentile": 0.99528}, "CVE-2023-43796": {"epss_score": 0.00212, "epss_percentile": 0.43815}, "CVE-2023-43797": {"epss_score": 0.00071, "epss_percentile": 0.2201}, "CVE-2023-43798": {"epss_score": 0.00031, "epss_percentile": 0.08618}, "CVE-2023-43799": {"epss_score": 0.00088, "epss_percentile": 0.25781}, "CVE-2023-43800": {"epss_score": 0.00031, "epss_percentile": 0.0864}, "CVE-2023-43801": {"epss_score": 0.0003, "epss_percentile": 0.08083}, "CVE-2023-43802": {"epss_score": 0.0008, "epss_percentile": 0.24053}, "CVE-2023-43803": {"epss_score": 0.0002, "epss_percentile": 0.04521}, "CVE-2023-43804": {"epss_score": 0.00867, "epss_percentile": 0.74656}, "CVE-2023-43805": {"epss_score": 0.00157, "epss_percentile": 0.3711}, "CVE-2023-43809": {"epss_score": 0.00184, "epss_percentile": 0.40449}, "CVE-2023-43810": {"epss_score": 0.00316, "epss_percentile": 0.54222}, "CVE-2023-43813": {"epss_score": 0.00299, "epss_percentile": 0.52877}, "CVE-2023-43814": {"epss_score": 0.00318, "epss_percentile": 0.54428}, "CVE-2023-43815": {"epss_score": 0.00068, "epss_percentile": 0.21283}, "CVE-2023-43816": {"epss_score": 0.00064, "epss_percentile": 0.20355}, "CVE-2023-43817": {"epss_score": 0.00098, "epss_percentile": 0.27831}, "CVE-2023-43818": {"epss_score": 0.00925, "epss_percentile": 0.75528}, "CVE-2023-43819": {"epss_score": 0.00885, "epss_percentile": 0.74945}, "CVE-2023-43820": {"epss_score": 0.00946, "epss_percentile": 0.75814}, "CVE-2023-43821": {"epss_score": 0.00946, "epss_percentile": 0.75814}, "CVE-2023-43822": {"epss_score": 0.00885, "epss_percentile": 0.74945}, "CVE-2023-43823": {"epss_score": 0.00885, "epss_percentile": 0.74945}, "CVE-2023-43824": {"epss_score": 0.00946, "epss_percentile": 0.75814}, "CVE-2023-43825": {"epss_score": 0.00096, "epss_percentile": 0.27374}, "CVE-2023-43826": {"epss_score": 0.0009, "epss_percentile": 0.26127}, "CVE-2023-43828": {"epss_score": 0.0027, "epss_percentile": 0.5025}, "CVE-2023-43830": {"epss_score": 0.0027, "epss_percentile": 0.5025}, "CVE-2023-43835": {"epss_score": 0.03503, "epss_percentile": 0.87252}, "CVE-2023-43836": {"epss_score": 0.00058, "epss_percentile": 0.18426}, "CVE-2023-43838": {"epss_score": 0.00496, "epss_percentile": 0.65157}, "CVE-2023-43842": {"epss_score": 0.01174, "epss_percentile": 0.78248}, "CVE-2023-43843": {"epss_score": 0.01174, "epss_percentile": 0.78248}, "CVE-2023-43844": {"epss_score": 0.00218, "epss_percentile": 0.44415}, "CVE-2023-43845": {"epss_score": 0.00478, "epss_percentile": 0.64376}, "CVE-2023-43846": {"epss_score": 0.00402, "epss_percentile": 0.60303}, "CVE-2023-43847": {"epss_score": 0.00546, "epss_percentile": 0.67225}, "CVE-2023-43848": {"epss_score": 0.01528, "epss_percentile": 0.80874}, "CVE-2023-43849": {"epss_score": 0.01111, "epss_percentile": 0.77665}, "CVE-2023-43850": {"epss_score": 0.01006, "epss_percentile": 0.76555}, "CVE-2023-43856": {"epss_score": 0.00158, "epss_percentile": 0.3721}, "CVE-2023-43857": {"epss_score": 0.00251, "epss_percentile": 0.4832}, "CVE-2023-43860": {"epss_score": 0.00954, "epss_percentile": 0.759}, "CVE-2023-43861": {"epss_score": 0.00954, "epss_percentile": 0.759}, "CVE-2023-43862": {"epss_score": 0.00954, "epss_percentile": 0.759}, "CVE-2023-43863": {"epss_score": 0.00954, "epss_percentile": 0.759}, "CVE-2023-43864": {"epss_score": 0.00954, "epss_percentile": 0.759}, "CVE-2023-43865": {"epss_score": 0.00954, "epss_percentile": 0.759}, "CVE-2023-43866": {"epss_score": 0.00954, "epss_percentile": 0.759}, "CVE-2023-43867": {"epss_score": 0.00954, "epss_percentile": 0.759}, "CVE-2023-43868": {"epss_score": 0.00478, "epss_percentile": 0.64376}, "CVE-2023-43869": {"epss_score": 0.03352, "epss_percentile": 0.86964}, "CVE-2023-43870": {"epss_score": 0.00068, "epss_percentile": 0.21353}, "CVE-2023-43871": {"epss_score": 0.00214, "epss_percentile": 0.43954}, "CVE-2023-43872": {"epss_score": 0.00597, "epss_percentile": 0.68753}, "CVE-2023-43873": {"epss_score": 0.00225, "epss_percentile": 0.45234}, "CVE-2023-43874": {"epss_score": 0.0039, "epss_percentile": 0.59515}, "CVE-2023-43875": {"epss_score": 0.026, "epss_percentile": 0.85205}, "CVE-2023-43876": {"epss_score": 0.00261, "epss_percentile": 0.49293}, "CVE-2023-43877": {"epss_score": 0.00147, "epss_percentile": 0.35669}, "CVE-2023-43878": {"epss_score": 0.00291, "epss_percentile": 0.52189}, "CVE-2023-43879": {"epss_score": 0.00217, "epss_percentile": 0.44306}, "CVE-2023-43884": {"epss_score": 0.00184, "epss_percentile": 0.40422}, "CVE-2023-43885": {"epss_score": 0.00093, "epss_percentile": 0.26626}, "CVE-2023-43886": {"epss_score": 0.0014, "epss_percentile": 0.34791}, "CVE-2023-43887": {"epss_score": 0.00166, "epss_percentile": 0.38233}, "CVE-2023-43890": {"epss_score": 0.0139, "epss_percentile": 0.79934}, "CVE-2023-43891": {"epss_score": 0.02354, "epss_percentile": 0.84479}, "CVE-2023-43892": {"epss_score": 0.02985, "epss_percentile": 0.86129}, "CVE-2023-43893": {"epss_score": 0.02354, "epss_percentile": 0.84479}, "CVE-2023-43896": {"epss_score": 0.00089, "epss_percentile": 0.25891}, "CVE-2023-43898": {"epss_score": 0.00024, "epss_percentile": 0.05964}, "CVE-2023-43899": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2023-43900": {"epss_score": 0.00195, "epss_percentile": 0.41689}, "CVE-2023-43901": {"epss_score": 0.00201, "epss_percentile": 0.42329}, "CVE-2023-43902": {"epss_score": 0.00323, "epss_percentile": 0.54894}, "CVE-2023-43905": {"epss_score": 0.00082, "epss_percentile": 0.24462}, "CVE-2023-43906": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-43907": {"epss_score": 0.00025, "epss_percentile": 0.06344}, "CVE-2023-43909": {"epss_score": 0.0008, "epss_percentile": 0.24138}, "CVE-2023-43944": {"epss_score": 0.00086, "epss_percentile": 0.25417}, "CVE-2023-43951": {"epss_score": 0.00053, "epss_percentile": 0.16978}, "CVE-2023-43952": {"epss_score": 0.00039, "epss_percentile": 0.11722}, "CVE-2023-43953": {"epss_score": 0.00092, "epss_percentile": 0.26419}, "CVE-2023-43955": {"epss_score": 0.00574, "epss_percentile": 0.68094}, "CVE-2023-43958": {"epss_score": 0.01651, "epss_percentile": 0.81569}, "CVE-2023-43959": {"epss_score": 0.07991, "epss_percentile": 0.9181}, "CVE-2023-43960": {"epss_score": 0.0619, "epss_percentile": 0.90547}, "CVE-2023-43961": {"epss_score": 0.00096, "epss_percentile": 0.27262}, "CVE-2023-43962": {"epss_score": 0.00115, "epss_percentile": 0.30962}, "CVE-2023-43971": {"epss_score": 0.00389, "epss_percentile": 0.59452}, "CVE-2023-43976": {"epss_score": 0.00076, "epss_percentile": 0.23156}, "CVE-2023-43979": {"epss_score": 0.00076, "epss_percentile": 0.23281}, "CVE-2023-43980": {"epss_score": 0.00103, "epss_percentile": 0.29051}, "CVE-2023-43981": {"epss_score": 0.00105, "epss_percentile": 0.29398}, "CVE-2023-43982": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2023-43983": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-43984": {"epss_score": 0.00189, "epss_percentile": 0.4099}, "CVE-2023-43985": {"epss_score": 0.00145, "epss_percentile": 0.35432}, "CVE-2023-43986": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2023-43988": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-43989": {"epss_score": 0.0008, "epss_percentile": 0.24035}, "CVE-2023-43990": {"epss_score": 0.0008, "epss_percentile": 0.24035}, "CVE-2023-43991": {"epss_score": 0.0008, "epss_percentile": 0.24035}, "CVE-2023-43992": {"epss_score": 0.0008, "epss_percentile": 0.24035}, "CVE-2023-43993": {"epss_score": 0.0008, "epss_percentile": 0.24035}, "CVE-2023-43994": {"epss_score": 0.0008, "epss_percentile": 0.24035}, "CVE-2023-43995": {"epss_score": 0.0008, "epss_percentile": 0.24035}, "CVE-2023-43996": {"epss_score": 0.0008, "epss_percentile": 0.24035}, "CVE-2023-43997": {"epss_score": 0.0008, "epss_percentile": 0.24035}, "CVE-2023-43998": {"epss_score": 0.0008, "epss_percentile": 0.24035}, "CVE-2023-43999": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-44000": {"epss_score": 0.0008, "epss_percentile": 0.24035}, "CVE-2023-44001": {"epss_score": 0.0008, "epss_percentile": 0.24035}, "CVE-2023-44008": {"epss_score": 0.09375, "epss_percentile": 0.92521}, "CVE-2023-44009": {"epss_score": 0.09375, "epss_percentile": 0.92521}, "CVE-2023-44011": {"epss_score": 0.13232, "epss_percentile": 0.93906}, "CVE-2023-44012": {"epss_score": 0.15202, "epss_percentile": 0.94383}, "CVE-2023-44013": {"epss_score": 0.00423, "epss_percentile": 0.6159}, "CVE-2023-44014": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-44015": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-44016": {"epss_score": 0.00423, "epss_percentile": 0.6159}, "CVE-2023-44017": {"epss_score": 0.00423, "epss_percentile": 0.6159}, "CVE-2023-44018": {"epss_score": 0.04547, "epss_percentile": 0.88834}, "CVE-2023-44019": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-44020": {"epss_score": 0.00423, "epss_percentile": 0.6159}, "CVE-2023-44021": {"epss_score": 0.00423, "epss_percentile": 0.6159}, "CVE-2023-44022": {"epss_score": 0.00423, "epss_percentile": 0.6159}, "CVE-2023-44023": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-44024": {"epss_score": 0.01017, "epss_percentile": 0.76692}, "CVE-2023-44025": {"epss_score": 0.02604, "epss_percentile": 0.85216}, "CVE-2023-44031": {"epss_score": 0.00062, "epss_percentile": 0.19618}, "CVE-2023-44037": {"epss_score": 0.00082, "epss_percentile": 0.24482}, "CVE-2023-44038": {"epss_score": 0.00157, "epss_percentile": 0.37126}, "CVE-2023-44039": {"epss_score": 0.00407, "epss_percentile": 0.60608}, "CVE-2023-44040": {"epss_score": 0.00809, "epss_percentile": 0.73702}, "CVE-2023-44042": {"epss_score": 0.00196, "epss_percentile": 0.41818}, "CVE-2023-44043": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2023-44044": {"epss_score": 0.00267, "epss_percentile": 0.4998}, "CVE-2023-44047": {"epss_score": 0.00158, "epss_percentile": 0.37197}, "CVE-2023-44048": {"epss_score": 0.00205, "epss_percentile": 0.42675}, "CVE-2023-44061": {"epss_score": 0.04969, "epss_percentile": 0.89345}, "CVE-2023-44075": {"epss_score": 0.00202, "epss_percentile": 0.4249}, "CVE-2023-44077": {"epss_score": 0.00079, "epss_percentile": 0.23964}, "CVE-2023-44080": {"epss_score": 0.04019, "epss_percentile": 0.88126}, "CVE-2023-44081": {"epss_score": 0.0014, "epss_percentile": 0.34799}, "CVE-2023-44082": {"epss_score": 0.0014, "epss_percentile": 0.34799}, "CVE-2023-44083": {"epss_score": 0.0014, "epss_percentile": 0.34799}, "CVE-2023-44084": {"epss_score": 0.00166, "epss_percentile": 0.38224}, "CVE-2023-44085": {"epss_score": 0.00166, "epss_percentile": 0.38224}, "CVE-2023-44086": {"epss_score": 0.00166, "epss_percentile": 0.38224}, "CVE-2023-44087": {"epss_score": 0.00166, "epss_percentile": 0.38224}, "CVE-2023-44088": {"epss_score": 0.00195, "epss_percentile": 0.41626}, "CVE-2023-44089": {"epss_score": 0.0011, "epss_percentile": 0.30181}, "CVE-2023-44090": {"epss_score": 0.00122, "epss_percentile": 0.32125}, "CVE-2023-44091": {"epss_score": 0.00285, "epss_percentile": 0.51518}, "CVE-2023-44092": {"epss_score": 0.00128, "epss_percentile": 0.33001}, "CVE-2023-44093": {"epss_score": 0.00081, "epss_percentile": 0.24227}, "CVE-2023-44094": {"epss_score": 0.00032, "epss_percentile": 0.08731}, "CVE-2023-44095": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-44096": {"epss_score": 0.0007, "epss_percentile": 0.21708}, "CVE-2023-44097": {"epss_score": 0.00081, "epss_percentile": 0.24227}, "CVE-2023-44098": {"epss_score": 0.0007, "epss_percentile": 0.21819}, "CVE-2023-44099": {"epss_score": 0.00099, "epss_percentile": 0.27867}, "CVE-2023-44100": {"epss_score": 0.00069, "epss_percentile": 0.21615}, "CVE-2023-44101": {"epss_score": 0.00071, "epss_percentile": 0.22146}, "CVE-2023-44102": {"epss_score": 0.00027, "epss_percentile": 0.0692}, "CVE-2023-44103": {"epss_score": 0.00081, "epss_percentile": 0.24227}, "CVE-2023-44104": {"epss_score": 0.00069, "epss_percentile": 0.21615}, "CVE-2023-44105": {"epss_score": 0.00074, "epss_percentile": 0.22818}, "CVE-2023-44106": {"epss_score": 0.00084, "epss_percentile": 0.24953}, "CVE-2023-44107": {"epss_score": 0.00088, "epss_percentile": 0.25762}, "CVE-2023-44108": {"epss_score": 0.00062, "epss_percentile": 0.19659}, "CVE-2023-44109": {"epss_score": 0.00157, "epss_percentile": 0.37114}, "CVE-2023-44110": {"epss_score": 0.00022, "epss_percentile": 0.05026}, "CVE-2023-44111": {"epss_score": 0.0007, "epss_percentile": 0.21708}, "CVE-2023-44112": {"epss_score": 0.00128, "epss_percentile": 0.32948}, "CVE-2023-44113": {"epss_score": 0.00088, "epss_percentile": 0.25695}, "CVE-2023-44114": {"epss_score": 0.00081, "epss_percentile": 0.24227}, "CVE-2023-44115": {"epss_score": 0.0015, "epss_percentile": 0.36097}, "CVE-2023-44116": {"epss_score": 0.00074, "epss_percentile": 0.22818}, "CVE-2023-44117": {"epss_score": 0.0008, "epss_percentile": 0.24193}, "CVE-2023-44118": {"epss_score": 0.00077, "epss_percentile": 0.23465}, "CVE-2023-44119": {"epss_score": 0.00056, "epss_percentile": 0.17718}, "CVE-2023-44120": {"epss_score": 0.00083, "epss_percentile": 0.248}, "CVE-2023-44121": {"epss_score": 0.0003, "epss_percentile": 0.0799}, "CVE-2023-44122": {"epss_score": 0.00019, "epss_percentile": 0.04223}, "CVE-2023-44123": {"epss_score": 0.0002, "epss_percentile": 0.04424}, "CVE-2023-44124": {"epss_score": 0.00021, "epss_percentile": 0.04706}, "CVE-2023-44125": {"epss_score": 0.0002, "epss_percentile": 0.04424}, "CVE-2023-44126": {"epss_score": 0.00046, "epss_percentile": 0.14182}, "CVE-2023-44127": {"epss_score": 0.00046, "epss_percentile": 0.14182}, "CVE-2023-44128": {"epss_score": 0.00022, "epss_percentile": 0.04991}, "CVE-2023-44129": {"epss_score": 0.00034, "epss_percentile": 0.09437}, "CVE-2023-44141": {"epss_score": 0.00047, "epss_percentile": 0.14642}, "CVE-2023-44142": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2023-44143": {"epss_score": 0.00151, "epss_percentile": 0.36262}, "CVE-2023-44144": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-44145": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-44146": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-44147": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2023-44148": {"epss_score": 0.00269, "epss_percentile": 0.50103}, "CVE-2023-44149": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2023-44150": {"epss_score": 0.00618, "epss_percentile": 0.69365}, "CVE-2023-44151": {"epss_score": 0.00158, "epss_percentile": 0.37285}, "CVE-2023-44152": {"epss_score": 0.00257, "epss_percentile": 0.48918}, "CVE-2023-44153": {"epss_score": 0.00139, "epss_percentile": 0.34596}, "CVE-2023-44154": {"epss_score": 0.00251, "epss_percentile": 0.48269}, "CVE-2023-44155": {"epss_score": 0.00124, "epss_percentile": 0.3242}, "CVE-2023-44156": {"epss_score": 0.00236, "epss_percentile": 0.46435}, "CVE-2023-44157": {"epss_score": 0.00046, "epss_percentile": 0.14184}, "CVE-2023-44158": {"epss_score": 0.00279, "epss_percentile": 0.50978}, "CVE-2023-44159": {"epss_score": 0.00132, "epss_percentile": 0.3355}, "CVE-2023-44160": {"epss_score": 0.00248, "epss_percentile": 0.47951}, "CVE-2023-44161": {"epss_score": 0.00248, "epss_percentile": 0.47951}, "CVE-2023-44163": {"epss_score": 0.00218, "epss_percentile": 0.44361}, "CVE-2023-44164": {"epss_score": 0.00218, "epss_percentile": 0.44361}, "CVE-2023-44166": {"epss_score": 0.00218, "epss_percentile": 0.44361}, "CVE-2023-44169": {"epss_score": 0.00362, "epss_percentile": 0.57799}, "CVE-2023-44170": {"epss_score": 0.00362, "epss_percentile": 0.57799}, "CVE-2023-44171": {"epss_score": 0.00362, "epss_percentile": 0.57799}, "CVE-2023-44172": {"epss_score": 0.00362, "epss_percentile": 0.57799}, "CVE-2023-44173": {"epss_score": 0.00088, "epss_percentile": 0.25648}, "CVE-2023-44174": {"epss_score": 0.00123, "epss_percentile": 0.32182}, "CVE-2023-44175": {"epss_score": 0.00171, "epss_percentile": 0.38864}, "CVE-2023-44176": {"epss_score": 0.00058, "epss_percentile": 0.1828}, "CVE-2023-44177": {"epss_score": 0.00058, "epss_percentile": 0.1828}, "CVE-2023-44178": {"epss_score": 0.00058, "epss_percentile": 0.1828}, "CVE-2023-44181": {"epss_score": 0.00093, "epss_percentile": 0.26638}, "CVE-2023-44182": {"epss_score": 0.00115, "epss_percentile": 0.30997}, "CVE-2023-44183": {"epss_score": 0.00038, "epss_percentile": 0.11415}, "CVE-2023-44184": {"epss_score": 0.00134, "epss_percentile": 0.3392}, "CVE-2023-44185": {"epss_score": 0.00146, "epss_percentile": 0.35633}, "CVE-2023-44186": {"epss_score": 0.00155, "epss_percentile": 0.3676}, "CVE-2023-44187": {"epss_score": 0.00038, "epss_percentile": 0.1129}, "CVE-2023-44188": {"epss_score": 0.00102, "epss_percentile": 0.2875}, "CVE-2023-44189": {"epss_score": 6e-05, "epss_percentile": 0.00312}, "CVE-2023-44190": {"epss_score": 0.0001, "epss_percentile": 0.00874}, "CVE-2023-44191": {"epss_score": 0.00126, "epss_percentile": 0.32747}, "CVE-2023-44192": {"epss_score": 0.00145, "epss_percentile": 0.35507}, "CVE-2023-44193": {"epss_score": 0.00031, "epss_percentile": 0.08679}, "CVE-2023-44194": {"epss_score": 0.00024, "epss_percentile": 0.05848}, "CVE-2023-44195": {"epss_score": 0.00102, "epss_percentile": 0.28783}, "CVE-2023-44196": {"epss_score": 0.00035, "epss_percentile": 0.10048}, "CVE-2023-44197": {"epss_score": 0.00145, "epss_percentile": 0.35507}, "CVE-2023-44198": {"epss_score": 0.00076, "epss_percentile": 0.23251}, "CVE-2023-44199": {"epss_score": 0.00149, "epss_percentile": 0.35944}, "CVE-2023-44201": {"epss_score": 0.00038, "epss_percentile": 0.11275}, "CVE-2023-44203": {"epss_score": 0.00067, "epss_percentile": 0.21172}, "CVE-2023-44204": {"epss_score": 0.00051, "epss_percentile": 0.16126}, "CVE-2023-44205": {"epss_score": 0.00314, "epss_percentile": 0.54092}, "CVE-2023-44206": {"epss_score": 0.00531, "epss_percentile": 0.66669}, "CVE-2023-44207": {"epss_score": 0.0021, "epss_percentile": 0.43446}, "CVE-2023-44208": {"epss_score": 0.00116, "epss_percentile": 0.31146}, "CVE-2023-44209": {"epss_score": 0.00033, "epss_percentile": 0.09319}, "CVE-2023-44210": {"epss_score": 0.00038, "epss_percentile": 0.11235}, "CVE-2023-44211": {"epss_score": 0.00032, "epss_percentile": 0.08835}, "CVE-2023-44212": {"epss_score": 0.00034, "epss_percentile": 0.09534}, "CVE-2023-44213": {"epss_score": 0.0007, "epss_percentile": 0.21836}, "CVE-2023-44214": {"epss_score": 0.00053, "epss_percentile": 0.17022}, "CVE-2023-44216": {"epss_score": 0.00494, "epss_percentile": 0.65091}, "CVE-2023-44217": {"epss_score": 0.00062, "epss_percentile": 0.1972}, "CVE-2023-44218": {"epss_score": 0.00085, "epss_percentile": 0.25227}, "CVE-2023-44219": {"epss_score": 0.00044, "epss_percentile": 0.13414}, "CVE-2023-44220": {"epss_score": 0.00026, "epss_percentile": 0.06655}, "CVE-2023-44221": {"epss_score": 0.1834, "epss_percentile": 0.94998}, "CVE-2023-44227": {"epss_score": 0.00165, "epss_percentile": 0.38068}, "CVE-2023-44228": {"epss_score": 0.00093, "epss_percentile": 0.26706}, "CVE-2023-44229": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-44230": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-44231": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-44232": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-44233": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-44234": {"epss_score": 0.00174, "epss_percentile": 0.39145}, "CVE-2023-44235": {"epss_score": 0.00189, "epss_percentile": 0.40929}, "CVE-2023-44236": {"epss_score": 0.00051, "epss_percentile": 0.16103}, "CVE-2023-44237": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-44238": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-44239": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-44240": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-44241": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-44242": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-44243": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-44244": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-44245": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-44246": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-44247": {"epss_score": 0.00234, "epss_percentile": 0.46081}, "CVE-2023-44248": {"epss_score": 0.0004, "epss_percentile": 0.12}, "CVE-2023-44249": {"epss_score": 0.00195, "epss_percentile": 0.41658}, "CVE-2023-44250": {"epss_score": 0.00126, "epss_percentile": 0.32749}, "CVE-2023-44251": {"epss_score": 0.00627, "epss_percentile": 0.69635}, "CVE-2023-44252": {"epss_score": 0.00239, "epss_percentile": 0.46911}, "CVE-2023-44253": {"epss_score": 0.0033, "epss_percentile": 0.55463}, "CVE-2023-44254": {"epss_score": 0.00185, "epss_percentile": 0.4052}, "CVE-2023-44255": {"epss_score": 0.00125, "epss_percentile": 0.32476}, "CVE-2023-44256": {"epss_score": 0.0072, "epss_percentile": 0.71957}, "CVE-2023-44257": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-44258": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-44259": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-44260": {"epss_score": 0.0007, "epss_percentile": 0.2193}, "CVE-2023-44261": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-44262": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-44263": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-44264": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-44265": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-44266": {"epss_score": 0.00063, "epss_percentile": 0.19871}, "CVE-2023-44267": {"epss_score": 0.00085, "epss_percentile": 0.2506}, "CVE-2023-44270": {"epss_score": 0.00176, "epss_percentile": 0.39386}, "CVE-2023-44271": {"epss_score": 0.00148, "epss_percentile": 0.3592}, "CVE-2023-44272": {"epss_score": 0.00387, "epss_percentile": 0.59316}, "CVE-2023-44273": {"epss_score": 0.00223, "epss_percentile": 0.44853}, "CVE-2023-44275": {"epss_score": 0.0028, "epss_percentile": 0.51035}, "CVE-2023-44276": {"epss_score": 0.00197, "epss_percentile": 0.41846}, "CVE-2023-44277": {"epss_score": 0.00066, "epss_percentile": 0.20696}, "CVE-2023-44278": {"epss_score": 0.0008, "epss_percentile": 0.24014}, "CVE-2023-44279": {"epss_score": 0.0001, "epss_percentile": 0.00772}, "CVE-2023-44281": {"epss_score": 0.0002, "epss_percentile": 0.04546}, "CVE-2023-44282": {"epss_score": 0.00043, "epss_percentile": 0.13081}, "CVE-2023-44283": {"epss_score": 0.00051, "epss_percentile": 0.16205}, "CVE-2023-44284": {"epss_score": 0.00233, "epss_percentile": 0.45972}, "CVE-2023-44285": {"epss_score": 0.00062, "epss_percentile": 0.19718}, "CVE-2023-44286": {"epss_score": 0.00159, "epss_percentile": 0.37362}, "CVE-2023-44288": {"epss_score": 0.00135, "epss_percentile": 0.33944}, "CVE-2023-44289": {"epss_score": 0.00031, "epss_percentile": 0.08548}, "CVE-2023-44290": {"epss_score": 0.00031, "epss_percentile": 0.08548}, "CVE-2023-44291": {"epss_score": 0.02886, "epss_percentile": 0.85911}, "CVE-2023-44292": {"epss_score": 0.00043, "epss_percentile": 0.13081}, "CVE-2023-44293": {"epss_score": 0.00308, "epss_percentile": 0.536}, "CVE-2023-44294": {"epss_score": 0.00308, "epss_percentile": 0.536}, "CVE-2023-44295": {"epss_score": 0.00083, "epss_percentile": 0.24791}, "CVE-2023-44296": {"epss_score": 0.00035, "epss_percentile": 0.10152}, "CVE-2023-44297": {"epss_score": 0.00025, "epss_percentile": 0.06304}, "CVE-2023-44298": {"epss_score": 0.00053, "epss_percentile": 0.1704}, "CVE-2023-44300": {"epss_score": 0.00096, "epss_percentile": 0.27243}, "CVE-2023-44301": {"epss_score": 0.0042, "epss_percentile": 0.61405}, "CVE-2023-44302": {"epss_score": 0.05083, "epss_percentile": 0.89474}, "CVE-2023-44303": {"epss_score": 0.00084, "epss_percentile": 0.24879}, "CVE-2023-44304": {"epss_score": 0.02302, "epss_percentile": 0.84315}, "CVE-2023-44305": {"epss_score": 0.05161, "epss_percentile": 0.8956}, "CVE-2023-44306": {"epss_score": 0.017, "epss_percentile": 0.81831}, "CVE-2023-44308": {"epss_score": 0.00191, "epss_percentile": 0.41196}, "CVE-2023-44309": {"epss_score": 0.00199, "epss_percentile": 0.42171}, "CVE-2023-44310": {"epss_score": 0.00199, "epss_percentile": 0.42171}, "CVE-2023-44311": {"epss_score": 0.00192, "epss_percentile": 0.41285}, "CVE-2023-44312": {"epss_score": 0.00044, "epss_percentile": 0.13378}, "CVE-2023-44313": {"epss_score": 0.64585, "epss_percentile": 0.98384}, "CVE-2023-44315": {"epss_score": 0.00471, "epss_percentile": 0.64005}, "CVE-2023-44317": {"epss_score": 0.00149, "epss_percentile": 0.36039}, "CVE-2023-44318": {"epss_score": 0.00156, "epss_percentile": 0.36968}, "CVE-2023-44319": {"epss_score": 0.00055, "epss_percentile": 0.17406}, "CVE-2023-44320": {"epss_score": 0.00179, "epss_percentile": 0.39825}, "CVE-2023-44321": {"epss_score": 0.00096, "epss_percentile": 0.27344}, "CVE-2023-44322": {"epss_score": 0.00152, "epss_percentile": 0.36418}, "CVE-2023-44323": {"epss_score": 0.00247, "epss_percentile": 0.47812}, "CVE-2023-44324": {"epss_score": 0.00221, "epss_percentile": 0.44637}, "CVE-2023-44325": {"epss_score": 0.00031, "epss_percentile": 0.08664}, "CVE-2023-44326": {"epss_score": 0.00044, "epss_percentile": 0.13612}, "CVE-2023-44327": {"epss_score": 0.0002, "epss_percentile": 0.0466}, "CVE-2023-44328": {"epss_score": 0.00015, "epss_percentile": 0.02286}, "CVE-2023-44329": {"epss_score": 0.00016, "epss_percentile": 0.02702}, "CVE-2023-44330": {"epss_score": 0.00086, "epss_percentile": 0.25348}, "CVE-2023-44331": {"epss_score": 0.00016, "epss_percentile": 0.02702}, "CVE-2023-44332": {"epss_score": 0.00016, "epss_percentile": 0.02702}, "CVE-2023-44333": {"epss_score": 0.00016, "epss_percentile": 0.02702}, "CVE-2023-44334": {"epss_score": 0.00028, "epss_percentile": 0.07227}, "CVE-2023-44335": {"epss_score": 0.00016, "epss_percentile": 0.02702}, "CVE-2023-44336": {"epss_score": 0.01175, "epss_percentile": 0.78263}, "CVE-2023-44337": {"epss_score": 0.01606, "epss_percentile": 0.81296}, "CVE-2023-44338": {"epss_score": 0.01606, "epss_percentile": 0.81296}, "CVE-2023-44339": {"epss_score": 0.00088, "epss_percentile": 0.25739}, "CVE-2023-44340": {"epss_score": 0.00088, "epss_percentile": 0.25739}, "CVE-2023-44341": {"epss_score": 0.001, "epss_percentile": 0.28448}, "CVE-2023-44342": {"epss_score": 0.00029, "epss_percentile": 0.07817}, "CVE-2023-44343": {"epss_score": 0.00029, "epss_percentile": 0.07817}, "CVE-2023-44344": {"epss_score": 0.00029, "epss_percentile": 0.07817}, "CVE-2023-44345": {"epss_score": 0.00061, "epss_percentile": 0.19267}, "CVE-2023-44346": {"epss_score": 0.00038, "epss_percentile": 0.11221}, "CVE-2023-44347": {"epss_score": 0.00112, "epss_percentile": 0.30551}, "CVE-2023-44348": {"epss_score": 0.00088, "epss_percentile": 0.25739}, "CVE-2023-44350": {"epss_score": 0.6189, "epss_percentile": 0.98266}, "CVE-2023-44351": {"epss_score": 0.3201, "epss_percentile": 0.96666}, "CVE-2023-44352": {"epss_score": 0.8274, "epss_percentile": 0.99211}, "CVE-2023-44353": {"epss_score": 0.90264, "epss_percentile": 0.99573}, "CVE-2023-44355": {"epss_score": 0.01322, "epss_percentile": 0.79448}, "CVE-2023-44356": {"epss_score": 0.00088, "epss_percentile": 0.25739}, "CVE-2023-44357": {"epss_score": 0.00088, "epss_percentile": 0.25739}, "CVE-2023-44358": {"epss_score": 0.00088, "epss_percentile": 0.25739}, "CVE-2023-44359": {"epss_score": 0.01248, "epss_percentile": 0.78863}, "CVE-2023-44360": {"epss_score": 0.00088, "epss_percentile": 0.25739}, "CVE-2023-44361": {"epss_score": 0.00083, "epss_percentile": 0.2481}, "CVE-2023-44362": {"epss_score": 0.00021, "epss_percentile": 0.04847}, "CVE-2023-44365": {"epss_score": 0.01233, "epss_percentile": 0.78743}, "CVE-2023-44366": {"epss_score": 0.01233, "epss_percentile": 0.78743}, "CVE-2023-44367": {"epss_score": 0.01248, "epss_percentile": 0.78863}, "CVE-2023-44371": {"epss_score": 0.01248, "epss_percentile": 0.78863}, "CVE-2023-44372": {"epss_score": 0.00564, "epss_percentile": 0.67746}, "CVE-2023-44373": {"epss_score": 0.00502, "epss_percentile": 0.65415}, "CVE-2023-44374": {"epss_score": 0.00143, "epss_percentile": 0.352}, "CVE-2023-44378": {"epss_score": 0.00035, "epss_percentile": 0.10043}, "CVE-2023-44379": {"epss_score": 0.00622, "epss_percentile": 0.69531}, "CVE-2023-44381": {"epss_score": 0.00175, "epss_percentile": 0.39336}, "CVE-2023-44382": {"epss_score": 0.00246, "epss_percentile": 0.47758}, "CVE-2023-44383": {"epss_score": 0.0093, "epss_percentile": 0.75606}, "CVE-2023-44384": {"epss_score": 0.00096, "epss_percentile": 0.27377}, "CVE-2023-44385": {"epss_score": 0.02589, "epss_percentile": 0.85178}, "CVE-2023-44386": {"epss_score": 0.00052, "epss_percentile": 0.16638}, "CVE-2023-44387": {"epss_score": 0.00063, "epss_percentile": 0.19929}, "CVE-2023-44388": {"epss_score": 0.00207, "epss_percentile": 0.43137}, "CVE-2023-44389": {"epss_score": 0.00339, "epss_percentile": 0.56196}, "CVE-2023-44390": {"epss_score": 0.00161, "epss_percentile": 0.37575}, "CVE-2023-44391": {"epss_score": 0.00284, "epss_percentile": 0.51459}, "CVE-2023-44392": {"epss_score": 0.07329, "epss_percentile": 0.91412}, "CVE-2023-44393": {"epss_score": 0.04696, "epss_percentile": 0.89018}, "CVE-2023-44394": {"epss_score": 0.00479, "epss_percentile": 0.64421}, "CVE-2023-44395": {"epss_score": 0.00135, "epss_percentile": 0.34006}, "CVE-2023-44396": {"epss_score": 0.00836, "epss_percentile": 0.74145}, "CVE-2023-44397": {"epss_score": 0.0002, "epss_percentile": 0.04514}, "CVE-2023-44398": {"epss_score": 0.00473, "epss_percentile": 0.64108}, "CVE-2023-44399": {"epss_score": 0.00352, "epss_percentile": 0.57128}, "CVE-2023-44400": {"epss_score": 0.00042, "epss_percentile": 0.12663}, "CVE-2023-44401": {"epss_score": 0.00187, "epss_percentile": 0.40762}, "CVE-2023-44402": {"epss_score": 0.00115, "epss_percentile": 0.30892}, "CVE-2023-44403": {"epss_score": 0.02338, "epss_percentile": 0.84424}, "CVE-2023-44404": {"epss_score": 0.02203, "epss_percentile": 0.83993}, "CVE-2023-44405": {"epss_score": 0.02203, "epss_percentile": 0.83993}, "CVE-2023-44406": {"epss_score": 0.02499, "epss_percentile": 0.84915}, "CVE-2023-44407": {"epss_score": 0.02203, "epss_percentile": 0.83993}, "CVE-2023-44408": {"epss_score": 0.02203, "epss_percentile": 0.83993}, "CVE-2023-44409": {"epss_score": 0.02203, "epss_percentile": 0.83993}, "CVE-2023-44410": {"epss_score": 0.00484, "epss_percentile": 0.64644}, "CVE-2023-44411": {"epss_score": 0.0102, "epss_percentile": 0.76734}, "CVE-2023-44412": {"epss_score": 0.09111, "epss_percentile": 0.92404}, "CVE-2023-44413": {"epss_score": 0.00699, "epss_percentile": 0.71455}, "CVE-2023-44414": {"epss_score": 0.03851, "epss_percentile": 0.8785}, "CVE-2023-44415": {"epss_score": 0.0055, "epss_percentile": 0.67329}, "CVE-2023-44416": {"epss_score": 0.01554, "epss_percentile": 0.81002}, "CVE-2023-44417": {"epss_score": 0.02203, "epss_percentile": 0.83993}, "CVE-2023-44418": {"epss_score": 0.00675, "epss_percentile": 0.70906}, "CVE-2023-44419": {"epss_score": 0.00675, "epss_percentile": 0.70906}, "CVE-2023-44420": {"epss_score": 0.00128, "epss_percentile": 0.33069}, "CVE-2023-44421": {"epss_score": 0.00094, "epss_percentile": 0.26951}, "CVE-2023-44422": {"epss_score": 0.00094, "epss_percentile": 0.26951}, "CVE-2023-44423": {"epss_score": 0.00094, "epss_percentile": 0.26951}, "CVE-2023-44424": {"epss_score": 0.00094, "epss_percentile": 0.26951}, "CVE-2023-44425": {"epss_score": 0.00094, "epss_percentile": 0.26951}, "CVE-2023-44426": {"epss_score": 0.00094, "epss_percentile": 0.26951}, "CVE-2023-44427": {"epss_score": 0.00094, "epss_percentile": 0.26951}, "CVE-2023-44428": {"epss_score": 0.02809, "epss_percentile": 0.85713}, "CVE-2023-44429": {"epss_score": 0.0485, "epss_percentile": 0.89213}, "CVE-2023-44430": {"epss_score": 0.02076, "epss_percentile": 0.83509}, "CVE-2023-44431": {"epss_score": 0.02464, "epss_percentile": 0.84832}, "CVE-2023-44432": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-44433": {"epss_score": 0.00279, "epss_percentile": 0.50987}, "CVE-2023-44434": {"epss_score": 0.00319, "epss_percentile": 0.54464}, "CVE-2023-44435": {"epss_score": 0.00569, "epss_percentile": 0.6792}, "CVE-2023-44436": {"epss_score": 0.00569, "epss_percentile": 0.6792}, "CVE-2023-44437": {"epss_score": 0.0046, "epss_percentile": 0.63535}, "CVE-2023-44438": {"epss_score": 0.00871, "epss_percentile": 0.74716}, "CVE-2023-44439": {"epss_score": 0.00871, "epss_percentile": 0.74716}, "CVE-2023-44440": {"epss_score": 0.00904, "epss_percentile": 0.75222}, "CVE-2023-44441": {"epss_score": 0.11742, "epss_percentile": 0.93463}, "CVE-2023-44442": {"epss_score": 0.6033, "epss_percentile": 0.98204}, "CVE-2023-44443": {"epss_score": 0.63756, "epss_percentile": 0.98347}, "CVE-2023-44444": {"epss_score": 0.50045, "epss_percentile": 0.97715}, "CVE-2023-44445": {"epss_score": 0.03224, "epss_percentile": 0.86682}, "CVE-2023-44446": {"epss_score": 0.0386, "epss_percentile": 0.87864}, "CVE-2023-44447": {"epss_score": 0.00127, "epss_percentile": 0.32868}, "CVE-2023-44448": {"epss_score": 0.00601, "epss_percentile": 0.68848}, "CVE-2023-44449": {"epss_score": 0.15093, "epss_percentile": 0.9436}, "CVE-2023-44450": {"epss_score": 0.392, "epss_percentile": 0.97145}, "CVE-2023-44451": {"epss_score": 0.55828, "epss_percentile": 0.97998}, "CVE-2023-44452": {"epss_score": 0.20665, "epss_percentile": 0.95398}, "CVE-2023-44463": {"epss_score": 0.00157, "epss_percentile": 0.37102}, "CVE-2023-44464": {"epss_score": 0.00177, "epss_percentile": 0.39514}, "CVE-2023-44466": {"epss_score": 0.15852, "epss_percentile": 0.9452}, "CVE-2023-44467": {"epss_score": 0.00115, "epss_percentile": 0.31022}, "CVE-2023-44469": {"epss_score": 0.00363, "epss_percentile": 0.57899}, "CVE-2023-44470": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-44471": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-44472": {"epss_score": 0.00064, "epss_percentile": 0.20316}, "CVE-2023-44473": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-44474": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-44475": {"epss_score": 0.00106, "epss_percentile": 0.29522}, "CVE-2023-44476": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-44477": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-44478": {"epss_score": 0.00123, "epss_percentile": 0.32257}, "CVE-2023-44479": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-44480": {"epss_score": 0.00071, "epss_percentile": 0.22109}, "CVE-2023-44481": {"epss_score": 0.0011, "epss_percentile": 0.30155}, "CVE-2023-44482": {"epss_score": 0.0011, "epss_percentile": 0.30155}, "CVE-2023-44483": {"epss_score": 0.00169, "epss_percentile": 0.3862}, "CVE-2023-44484": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-44487": {"epss_score": 0.94424, "epss_percentile": 0.9998}, "CVE-2023-44488": {"epss_score": 0.01446, "epss_percentile": 0.80327}, "CVE-2023-44689": {"epss_score": 0.00056, "epss_percentile": 0.1773}, "CVE-2023-44690": {"epss_score": 0.00074, "epss_percentile": 0.22829}, "CVE-2023-44693": {"epss_score": 0.1058, "epss_percentile": 0.93034}, "CVE-2023-44694": {"epss_score": 0.00147, "epss_percentile": 0.35796}, "CVE-2023-44709": {"epss_score": 0.0029, "epss_percentile": 0.52132}, "CVE-2023-44752": {"epss_score": 0.00136, "epss_percentile": 0.34062}, "CVE-2023-44753": {"epss_score": 0.00053, "epss_percentile": 0.16872}, "CVE-2023-44755": {"epss_score": 0.00059, "epss_percentile": 0.18737}, "CVE-2023-44758": {"epss_score": 0.00112, "epss_percentile": 0.30513}, "CVE-2023-44760": {"epss_score": 0.00207, "epss_percentile": 0.43187}, "CVE-2023-44761": {"epss_score": 0.00298, "epss_percentile": 0.528}, "CVE-2023-44762": {"epss_score": 0.00219, "epss_percentile": 0.4452}, "CVE-2023-44763": {"epss_score": 0.00269, "epss_percentile": 0.50188}, "CVE-2023-44764": {"epss_score": 0.00214, "epss_percentile": 0.43953}, "CVE-2023-44765": {"epss_score": 0.00298, "epss_percentile": 0.528}, "CVE-2023-44766": {"epss_score": 0.00172, "epss_percentile": 0.38998}, "CVE-2023-44767": {"epss_score": 0.00164, "epss_percentile": 0.37867}, "CVE-2023-44769": {"epss_score": 0.0077, "epss_percentile": 0.73007}, "CVE-2023-44770": {"epss_score": 0.00219, "epss_percentile": 0.4452}, "CVE-2023-44771": {"epss_score": 0.00219, "epss_percentile": 0.4452}, "CVE-2023-44794": {"epss_score": 0.01961, "epss_percentile": 0.83059}, "CVE-2023-44796": {"epss_score": 0.00055, "epss_percentile": 0.17647}, "CVE-2023-44807": {"epss_score": 0.03252, "epss_percentile": 0.86752}, "CVE-2023-44808": {"epss_score": 0.043, "epss_percentile": 0.88515}, "CVE-2023-44809": {"epss_score": 0.02453, "epss_percentile": 0.84792}, "CVE-2023-44811": {"epss_score": 0.03316, "epss_percentile": 0.869}, "CVE-2023-44812": {"epss_score": 0.49696, "epss_percentile": 0.977}, "CVE-2023-44813": {"epss_score": 0.37798, "epss_percentile": 0.97071}, "CVE-2023-44821": {"epss_score": 0.00058, "epss_percentile": 0.18394}, "CVE-2023-44824": {"epss_score": 0.00049, "epss_percentile": 0.1563}, "CVE-2023-44826": {"epss_score": 0.00192, "epss_percentile": 0.41304}, "CVE-2023-44827": {"epss_score": 0.00254, "epss_percentile": 0.48621}, "CVE-2023-44828": {"epss_score": 0.0034, "epss_percentile": 0.56262}, "CVE-2023-44829": {"epss_score": 0.0034, "epss_percentile": 0.56262}, "CVE-2023-44830": {"epss_score": 0.0034, "epss_percentile": 0.56262}, "CVE-2023-44831": {"epss_score": 0.00495, "epss_percentile": 0.65104}, "CVE-2023-44832": {"epss_score": 0.00495, "epss_percentile": 0.65104}, "CVE-2023-44833": {"epss_score": 0.0034, "epss_percentile": 0.56262}, "CVE-2023-44834": {"epss_score": 0.0034, "epss_percentile": 0.56262}, "CVE-2023-44835": {"epss_score": 0.0034, "epss_percentile": 0.56262}, "CVE-2023-44836": {"epss_score": 0.0034, "epss_percentile": 0.56262}, "CVE-2023-44837": {"epss_score": 0.0034, "epss_percentile": 0.56262}, "CVE-2023-44838": {"epss_score": 0.0034, "epss_percentile": 0.56262}, "CVE-2023-44839": {"epss_score": 0.11762, "epss_percentile": 0.93467}, "CVE-2023-44846": {"epss_score": 0.00418, "epss_percentile": 0.61268}, "CVE-2023-44847": {"epss_score": 0.00177, "epss_percentile": 0.3957}, "CVE-2023-44848": {"epss_score": 0.0023, "epss_percentile": 0.45676}, "CVE-2023-44852": {"epss_score": 0.0027, "epss_percentile": 0.5026}, "CVE-2023-44853": {"epss_score": 0.00232, "epss_percentile": 0.45927}, "CVE-2023-44854": {"epss_score": 0.0008, "epss_percentile": 0.24025}, "CVE-2023-44855": {"epss_score": 0.00258, "epss_percentile": 0.4901}, "CVE-2023-44856": {"epss_score": 0.00084, "epss_percentile": 0.24854}, "CVE-2023-44857": {"epss_score": 0.0036, "epss_percentile": 0.57632}, "CVE-2023-44860": {"epss_score": 0.10459, "epss_percentile": 0.92992}, "CVE-2023-44915": {"epss_score": 0.00029, "epss_percentile": 0.07838}, "CVE-2023-44954": {"epss_score": 0.00578, "epss_percentile": 0.68189}, "CVE-2023-44959": {"epss_score": 0.47058, "epss_percentile": 0.97568}, "CVE-2023-44961": {"epss_score": 0.06156, "epss_percentile": 0.90524}, "CVE-2023-44962": {"epss_score": 0.03189, "epss_percentile": 0.86592}, "CVE-2023-44973": {"epss_score": 0.00443, "epss_percentile": 0.62768}, "CVE-2023-44974": {"epss_score": 0.14303, "epss_percentile": 0.94183}, "CVE-2023-44976": {"epss_score": 0.00015, "epss_percentile": 0.02148}, "CVE-2023-44981": {"epss_score": 0.00027, "epss_percentile": 0.07159}, "CVE-2023-44982": {"epss_score": 0.00296, "epss_percentile": 0.52561}, "CVE-2023-44983": {"epss_score": 0.00332, "epss_percentile": 0.5555}, "CVE-2023-44984": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-44985": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-44986": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-44987": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-44988": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2023-44989": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2023-44990": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-44991": {"epss_score": 0.00348, "epss_percentile": 0.56818}, "CVE-2023-44993": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-44994": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-44995": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-44996": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-44997": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-44998": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-44999": {"epss_score": 0.00123, "epss_percentile": 0.32321}, "CVE-2023-45000": {"epss_score": 0.00395, "epss_percentile": 0.59819}, "CVE-2023-45001": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-45002": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-45003": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45004": {"epss_score": 0.00087, "epss_percentile": 0.25484}, "CVE-2023-45005": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45006": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45007": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45008": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-45009": {"epss_score": 0.00256, "epss_percentile": 0.4882}, "CVE-2023-45010": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-45011": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-45012": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45015": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45018": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45019": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45024": {"epss_score": 0.00101, "epss_percentile": 0.28716}, "CVE-2023-45025": {"epss_score": 0.0018, "epss_percentile": 0.39918}, "CVE-2023-45026": {"epss_score": 0.00057, "epss_percentile": 0.17966}, "CVE-2023-45027": {"epss_score": 0.00057, "epss_percentile": 0.17966}, "CVE-2023-45028": {"epss_score": 0.00035, "epss_percentile": 0.09987}, "CVE-2023-45035": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-45036": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-45037": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-45038": {"epss_score": 0.04873, "epss_percentile": 0.89234}, "CVE-2023-45039": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-45040": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-45041": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-45042": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-45043": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-45044": {"epss_score": 0.00081, "epss_percentile": 0.24278}, "CVE-2023-45045": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-45046": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-45047": {"epss_score": 0.00072, "epss_percentile": 0.22277}, "CVE-2023-45048": {"epss_score": 0.0009, "epss_percentile": 0.26136}, "CVE-2023-45049": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-45050": {"epss_score": 0.00275, "epss_percentile": 0.50672}, "CVE-2023-45051": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-45052": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-45053": {"epss_score": 0.00236, "epss_percentile": 0.46433}, "CVE-2023-45054": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45055": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-45056": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-45057": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-45058": {"epss_score": 0.0007, "epss_percentile": 0.2193}, "CVE-2023-45059": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-45060": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-45061": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2023-45062": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45063": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-45064": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45065": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45066": {"epss_score": 0.00266, "epss_percentile": 0.49906}, "CVE-2023-45067": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-45068": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-45069": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-45070": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45071": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45072": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-45073": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-45074": {"epss_score": 0.00224, "epss_percentile": 0.45011}, "CVE-2023-45075": {"epss_score": 0.00035, "epss_percentile": 0.10067}, "CVE-2023-45076": {"epss_score": 0.00035, "epss_percentile": 0.10067}, "CVE-2023-45077": {"epss_score": 0.00035, "epss_percentile": 0.10067}, "CVE-2023-45078": {"epss_score": 0.00035, "epss_percentile": 0.10067}, "CVE-2023-45079": {"epss_score": 0.00035, "epss_percentile": 0.10067}, "CVE-2023-45083": {"epss_score": 0.00024, "epss_percentile": 0.05956}, "CVE-2023-45084": {"epss_score": 0.00029, "epss_percentile": 0.07943}, "CVE-2023-45085": {"epss_score": 0.00031, "epss_percentile": 0.08542}, "CVE-2023-45101": {"epss_score": 0.0006, "epss_percentile": 0.18975}, "CVE-2023-45102": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-45103": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-45104": {"epss_score": 0.00177, "epss_percentile": 0.39591}, "CVE-2023-45105": {"epss_score": 0.00114, "epss_percentile": 0.30766}, "CVE-2023-45106": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-45107": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-45108": {"epss_score": 0.0007, "epss_percentile": 0.2193}, "CVE-2023-45109": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-45110": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-45111": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45115": {"epss_score": 0.00117, "epss_percentile": 0.31293}, "CVE-2023-45116": {"epss_score": 0.00116, "epss_percentile": 0.3104}, "CVE-2023-45117": {"epss_score": 0.00097, "epss_percentile": 0.27567}, "CVE-2023-45118": {"epss_score": 0.00117, "epss_percentile": 0.31293}, "CVE-2023-45119": {"epss_score": 0.00129, "epss_percentile": 0.33193}, "CVE-2023-45120": {"epss_score": 0.00116, "epss_percentile": 0.3104}, "CVE-2023-45121": {"epss_score": 0.00129, "epss_percentile": 0.33193}, "CVE-2023-45128": {"epss_score": 0.00155, "epss_percentile": 0.36826}, "CVE-2023-45129": {"epss_score": 0.00243, "epss_percentile": 0.47417}, "CVE-2023-45130": {"epss_score": 0.00253, "epss_percentile": 0.48456}, "CVE-2023-45131": {"epss_score": 0.07392, "epss_percentile": 0.91449}, "CVE-2023-45132": {"epss_score": 0.00062, "epss_percentile": 0.19575}, "CVE-2023-45133": {"epss_score": 0.00093, "epss_percentile": 0.26654}, "CVE-2023-45134": {"epss_score": 0.04811, "epss_percentile": 0.89166}, "CVE-2023-45135": {"epss_score": 0.04811, "epss_percentile": 0.89166}, "CVE-2023-45136": {"epss_score": 0.74955, "epss_percentile": 0.98826}, "CVE-2023-45137": {"epss_score": 0.01696, "epss_percentile": 0.81807}, "CVE-2023-45138": {"epss_score": 0.78432, "epss_percentile": 0.98986}, "CVE-2023-45139": {"epss_score": 0.00172, "epss_percentile": 0.38939}, "CVE-2023-45140": {"epss_score": 0.00233, "epss_percentile": 0.4601}, "CVE-2023-45141": {"epss_score": 0.00119, "epss_percentile": 0.3156}, "CVE-2023-45142": {"epss_score": 0.01159, "epss_percentile": 0.78129}, "CVE-2023-45143": {"epss_score": 0.00097, "epss_percentile": 0.2755}, "CVE-2023-45144": {"epss_score": 0.04053, "epss_percentile": 0.88178}, "CVE-2023-45145": {"epss_score": 0.00582, "epss_percentile": 0.68296}, "CVE-2023-45146": {"epss_score": 0.0312, "epss_percentile": 0.86447}, "CVE-2023-45147": {"epss_score": 0.00223, "epss_percentile": 0.44851}, "CVE-2023-45148": {"epss_score": 0.00177, "epss_percentile": 0.39601}, "CVE-2023-45149": {"epss_score": 0.00179, "epss_percentile": 0.39832}, "CVE-2023-45150": {"epss_score": 0.00118, "epss_percentile": 0.31394}, "CVE-2023-45151": {"epss_score": 0.0063, "epss_percentile": 0.69694}, "CVE-2023-45152": {"epss_score": 0.00021, "epss_percentile": 0.04871}, "CVE-2023-45158": {"epss_score": 0.15027, "epss_percentile": 0.94348}, "CVE-2023-45159": {"epss_score": 0.00155, "epss_percentile": 0.36779}, "CVE-2023-45160": {"epss_score": 0.0027, "epss_percentile": 0.50234}, "CVE-2023-45161": {"epss_score": 0.00118, "epss_percentile": 0.31399}, "CVE-2023-45162": {"epss_score": 0.00086, "epss_percentile": 0.25303}, "CVE-2023-45163": {"epss_score": 0.00114, "epss_percentile": 0.30872}, "CVE-2023-45165": {"epss_score": 0.00023, "epss_percentile": 0.05642}, "CVE-2023-45166": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2023-45167": {"epss_score": 0.00014, "epss_percentile": 0.01873}, "CVE-2023-45168": {"epss_score": 0.00069, "epss_percentile": 0.21581}, "CVE-2023-45169": {"epss_score": 0.00025, "epss_percentile": 0.06276}, "CVE-2023-45170": {"epss_score": 0.00033, "epss_percentile": 0.09203}, "CVE-2023-45171": {"epss_score": 0.00024, "epss_percentile": 0.05995}, "CVE-2023-45172": {"epss_score": 0.00016, "epss_percentile": 0.02729}, "CVE-2023-45173": {"epss_score": 0.00025, "epss_percentile": 0.06276}, "CVE-2023-45174": {"epss_score": 0.00033, "epss_percentile": 0.09203}, "CVE-2023-45175": {"epss_score": 0.00017, "epss_percentile": 0.03432}, "CVE-2023-45176": {"epss_score": 0.00015, "epss_percentile": 0.023}, "CVE-2023-45177": {"epss_score": 0.00103, "epss_percentile": 0.29086}, "CVE-2023-45178": {"epss_score": 0.00039, "epss_percentile": 0.11481}, "CVE-2023-45181": {"epss_score": 0.00052, "epss_percentile": 0.16588}, "CVE-2023-45182": {"epss_score": 0.00629, "epss_percentile": 0.69683}, "CVE-2023-45184": {"epss_score": 0.07752, "epss_percentile": 0.9166}, "CVE-2023-45185": {"epss_score": 0.01512, "epss_percentile": 0.80783}, "CVE-2023-45186": {"epss_score": 0.00104, "epss_percentile": 0.29243}, "CVE-2023-45187": {"epss_score": 0.00036, "epss_percentile": 0.10543}, "CVE-2023-45188": {"epss_score": 0.00184, "epss_percentile": 0.4037}, "CVE-2023-45189": {"epss_score": 0.00052, "epss_percentile": 0.16366}, "CVE-2023-45190": {"epss_score": 0.0006, "epss_percentile": 0.19021}, "CVE-2023-45191": {"epss_score": 0.0004, "epss_percentile": 0.1196}, "CVE-2023-45192": {"epss_score": 0.00062, "epss_percentile": 0.19782}, "CVE-2023-45193": {"epss_score": 0.00044, "epss_percentile": 0.13457}, "CVE-2023-45194": {"epss_score": 0.0007, "epss_percentile": 0.21706}, "CVE-2023-45195": {"epss_score": 0.00616, "epss_percentile": 0.69329}, "CVE-2023-45196": {"epss_score": 0.00809, "epss_percentile": 0.73704}, "CVE-2023-45197": {"epss_score": 0.00269, "epss_percentile": 0.50178}, "CVE-2023-45198": {"epss_score": 0.00215, "epss_percentile": 0.44057}, "CVE-2023-45199": {"epss_score": 0.09273, "epss_percentile": 0.92478}, "CVE-2023-45201": {"epss_score": 0.00155, "epss_percentile": 0.36851}, "CVE-2023-45202": {"epss_score": 0.00155, "epss_percentile": 0.36851}, "CVE-2023-45203": {"epss_score": 0.00155, "epss_percentile": 0.36851}, "CVE-2023-45204": {"epss_score": 0.00127, "epss_percentile": 0.32845}, "CVE-2023-45205": {"epss_score": 0.0006, "epss_percentile": 0.19218}, "CVE-2023-45206": {"epss_score": 0.00349, "epss_percentile": 0.56877}, "CVE-2023-45207": {"epss_score": 0.00442, "epss_percentile": 0.62752}, "CVE-2023-45208": {"epss_score": 0.01613, "epss_percentile": 0.81338}, "CVE-2023-45209": {"epss_score": 0.00496, "epss_percentile": 0.65137}, "CVE-2023-45210": {"epss_score": 0.0025, "epss_percentile": 0.48147}, "CVE-2023-45213": {"epss_score": 0.00038, "epss_percentile": 0.112}, "CVE-2023-45215": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2023-45217": {"epss_score": 0.00156, "epss_percentile": 0.36933}, "CVE-2023-45219": {"epss_score": 0.00108, "epss_percentile": 0.29863}, "CVE-2023-45220": {"epss_score": 0.00117, "epss_percentile": 0.31265}, "CVE-2023-45221": {"epss_score": 0.00034, "epss_percentile": 0.09458}, "CVE-2023-45222": {"epss_score": 0.00097, "epss_percentile": 0.27623}, "CVE-2023-45223": {"epss_score": 0.00352, "epss_percentile": 0.57123}, "CVE-2023-45225": {"epss_score": 0.00789, "epss_percentile": 0.73349}, "CVE-2023-45226": {"epss_score": 0.00572, "epss_percentile": 0.68025}, "CVE-2023-45227": {"epss_score": 0.00097, "epss_percentile": 0.27623}, "CVE-2023-45228": {"epss_score": 0.00042, "epss_percentile": 0.1249}, "CVE-2023-45229": {"epss_score": 0.00106, "epss_percentile": 0.29427}, "CVE-2023-45230": {"epss_score": 0.00243, "epss_percentile": 0.47421}, "CVE-2023-45231": {"epss_score": 0.00106, "epss_percentile": 0.29427}, "CVE-2023-45232": {"epss_score": 0.00383, "epss_percentile": 0.59088}, "CVE-2023-45233": {"epss_score": 0.00383, "epss_percentile": 0.59088}, "CVE-2023-45234": {"epss_score": 0.00243, "epss_percentile": 0.47421}, "CVE-2023-45235": {"epss_score": 0.00313, "epss_percentile": 0.54061}, "CVE-2023-45236": {"epss_score": 0.00376, "epss_percentile": 0.58665}, "CVE-2023-45237": {"epss_score": 0.00376, "epss_percentile": 0.58665}, "CVE-2023-45239": {"epss_score": 0.35891, "epss_percentile": 0.9694}, "CVE-2023-45240": {"epss_score": 0.00053, "epss_percentile": 0.17022}, "CVE-2023-45241": {"epss_score": 0.00026, "epss_percentile": 0.06459}, "CVE-2023-45242": {"epss_score": 0.00053, "epss_percentile": 0.17022}, "CVE-2023-45243": {"epss_score": 0.00053, "epss_percentile": 0.17022}, "CVE-2023-45244": {"epss_score": 0.00077, "epss_percentile": 0.23373}, "CVE-2023-45245": {"epss_score": 0.00067, "epss_percentile": 0.21125}, "CVE-2023-45246": {"epss_score": 0.00077, "epss_percentile": 0.23373}, "CVE-2023-45247": {"epss_score": 0.00077, "epss_percentile": 0.23373}, "CVE-2023-45248": {"epss_score": 0.00057, "epss_percentile": 0.17972}, "CVE-2023-45249": {"epss_score": 0.93342, "epss_percentile": 0.99798}, "CVE-2023-45252": {"epss_score": 0.00049, "epss_percentile": 0.15603}, "CVE-2023-45253": {"epss_score": 0.00071, "epss_percentile": 0.22066}, "CVE-2023-45256": {"epss_score": 0.00029, "epss_percentile": 0.07612}, "CVE-2023-45267": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-45268": {"epss_score": 0.00092, "epss_percentile": 0.26501}, "CVE-2023-45269": {"epss_score": 0.00048, "epss_percentile": 0.15129}, "CVE-2023-45270": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-45271": {"epss_score": 0.00072, "epss_percentile": 0.22332}, "CVE-2023-45272": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2023-45273": {"epss_score": 0.0016, "epss_percentile": 0.37496}, "CVE-2023-45274": {"epss_score": 0.0016, "epss_percentile": 0.37496}, "CVE-2023-45275": {"epss_score": 0.00221, "epss_percentile": 0.44687}, "CVE-2023-45276": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-45277": {"epss_score": 0.01245, "epss_percentile": 0.78842}, "CVE-2023-45278": {"epss_score": 0.02556, "epss_percentile": 0.85093}, "CVE-2023-45279": {"epss_score": 0.00266, "epss_percentile": 0.49878}, "CVE-2023-45280": {"epss_score": 0.01584, "epss_percentile": 0.81156}, "CVE-2023-45281": {"epss_score": 0.00269, "epss_percentile": 0.50107}, "CVE-2023-45282": {"epss_score": 0.00103, "epss_percentile": 0.2904}, "CVE-2023-45283": {"epss_score": 0.00097, "epss_percentile": 0.27482}, "CVE-2023-45284": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2023-45285": {"epss_score": 0.00055, "epss_percentile": 0.17448}, "CVE-2023-45286": {"epss_score": 0.00221, "epss_percentile": 0.44693}, "CVE-2023-45287": {"epss_score": 0.00185, "epss_percentile": 0.40528}, "CVE-2023-45288": {"epss_score": 0.66635, "epss_percentile": 0.98471}, "CVE-2023-45289": {"epss_score": 0.00454, "epss_percentile": 0.63266}, "CVE-2023-45290": {"epss_score": 0.00362, "epss_percentile": 0.57809}, "CVE-2023-45292": {"epss_score": 0.00084, "epss_percentile": 0.24874}, "CVE-2023-45303": {"epss_score": 0.00594, "epss_percentile": 0.68653}, "CVE-2023-45311": {"epss_score": 0.00426, "epss_percentile": 0.6174}, "CVE-2023-45312": {"epss_score": 0.03323, "epss_percentile": 0.86914}, "CVE-2023-45315": {"epss_score": 0.00059, "epss_percentile": 0.18874}, "CVE-2023-45316": {"epss_score": 0.00262, "epss_percentile": 0.49343}, "CVE-2023-45317": {"epss_score": 0.00109, "epss_percentile": 0.30073}, "CVE-2023-45318": {"epss_score": 0.00607, "epss_percentile": 0.6906}, "CVE-2023-45319": {"epss_score": 0.00423, "epss_percentile": 0.61603}, "CVE-2023-45320": {"epss_score": 0.00122, "epss_percentile": 0.32145}, "CVE-2023-45321": {"epss_score": 0.00044, "epss_percentile": 0.13399}, "CVE-2023-45322": {"epss_score": 0.00076, "epss_percentile": 0.23249}, "CVE-2023-45323": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45325": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45334": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45336": {"epss_score": 0.00085, "epss_percentile": 0.2506}, "CVE-2023-45338": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45340": {"epss_score": 0.00085, "epss_percentile": 0.2506}, "CVE-2023-45341": {"epss_score": 0.00085, "epss_percentile": 0.2506}, "CVE-2023-45342": {"epss_score": 0.00085, "epss_percentile": 0.2506}, "CVE-2023-45343": {"epss_score": 0.00085, "epss_percentile": 0.2506}, "CVE-2023-45344": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45345": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45346": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45347": {"epss_score": 0.00097, "epss_percentile": 0.27527}, "CVE-2023-45348": {"epss_score": 0.00408, "epss_percentile": 0.60639}, "CVE-2023-45349": {"epss_score": 0.00271, "epss_percentile": 0.50283}, "CVE-2023-45350": {"epss_score": 0.00283, "epss_percentile": 0.51395}, "CVE-2023-45351": {"epss_score": 0.008, "epss_percentile": 0.73546}, "CVE-2023-45352": {"epss_score": 0.00493, "epss_percentile": 0.65061}, "CVE-2023-45353": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2023-45354": {"epss_score": 0.01711, "epss_percentile": 0.81883}, "CVE-2023-45355": {"epss_score": 0.008, "epss_percentile": 0.73546}, "CVE-2023-45356": {"epss_score": 0.008, "epss_percentile": 0.73546}, "CVE-2023-45357": {"epss_score": 0.00114, "epss_percentile": 0.30811}, "CVE-2023-45358": {"epss_score": 0.00194, "epss_percentile": 0.41563}, "CVE-2023-45359": {"epss_score": 0.00163, "epss_percentile": 0.37803}, "CVE-2023-45360": {"epss_score": 0.00393, "epss_percentile": 0.59742}, "CVE-2023-45361": {"epss_score": 0.00138, "epss_percentile": 0.34463}, "CVE-2023-45362": {"epss_score": 0.0025, "epss_percentile": 0.48147}, "CVE-2023-45363": {"epss_score": 0.08189, "epss_percentile": 0.9192}, "CVE-2023-45364": {"epss_score": 0.00117, "epss_percentile": 0.3138}, "CVE-2023-45367": {"epss_score": 0.00139, "epss_percentile": 0.34564}, "CVE-2023-45369": {"epss_score": 0.00107, "epss_percentile": 0.29738}, "CVE-2023-45370": {"epss_score": 0.00085, "epss_percentile": 0.2517}, "CVE-2023-45371": {"epss_score": 0.00182, "epss_percentile": 0.40191}, "CVE-2023-45372": {"epss_score": 0.00127, "epss_percentile": 0.32941}, "CVE-2023-45373": {"epss_score": 0.00311, "epss_percentile": 0.5384}, "CVE-2023-45374": {"epss_score": 0.00081, "epss_percentile": 0.24359}, "CVE-2023-45375": {"epss_score": 0.87528, "epss_percentile": 0.99432}, "CVE-2023-45376": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2023-45377": {"epss_score": 0.00081, "epss_percentile": 0.2424}, "CVE-2023-45378": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-45379": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2023-45380": {"epss_score": 0.00114, "epss_percentile": 0.30751}, "CVE-2023-45381": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2023-45382": {"epss_score": 0.0008, "epss_percentile": 0.24011}, "CVE-2023-45383": {"epss_score": 0.0008, "epss_percentile": 0.24011}, "CVE-2023-45384": {"epss_score": 0.00206, "epss_percentile": 0.42781}, "CVE-2023-45385": {"epss_score": 0.00908, "epss_percentile": 0.7528}, "CVE-2023-45386": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2023-45387": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-45391": {"epss_score": 0.00097, "epss_percentile": 0.27516}, "CVE-2023-45393": {"epss_score": 0.00069, "epss_percentile": 0.21632}, "CVE-2023-45394": {"epss_score": 0.00643, "epss_percentile": 0.70045}, "CVE-2023-45396": {"epss_score": 0.00213, "epss_percentile": 0.43892}, "CVE-2023-45463": {"epss_score": 0.00148, "epss_percentile": 0.35927}, "CVE-2023-45464": {"epss_score": 0.00109, "epss_percentile": 0.30029}, "CVE-2023-45465": {"epss_score": 0.01614, "epss_percentile": 0.81345}, "CVE-2023-45466": {"epss_score": 0.01141, "epss_percentile": 0.77967}, "CVE-2023-45467": {"epss_score": 0.01141, "epss_percentile": 0.77967}, "CVE-2023-45468": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-45471": {"epss_score": 0.00308, "epss_percentile": 0.53628}, "CVE-2023-45479": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-45480": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-45481": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-45482": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-45483": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-45484": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-45498": {"epss_score": 0.79462, "epss_percentile": 0.9904}, "CVE-2023-45499": {"epss_score": 0.69486, "epss_percentile": 0.98589}, "CVE-2023-45503": {"epss_score": 0.01414, "epss_percentile": 0.80124}, "CVE-2023-45510": {"epss_score": 0.00063, "epss_percentile": 0.19987}, "CVE-2023-45511": {"epss_score": 0.00023, "epss_percentile": 0.05424}, "CVE-2023-45539": {"epss_score": 0.00034, "epss_percentile": 0.09511}, "CVE-2023-45540": {"epss_score": 0.00171, "epss_percentile": 0.38883}, "CVE-2023-45542": {"epss_score": 0.483, "epss_percentile": 0.97629}, "CVE-2023-45552": {"epss_score": 0.00289, "epss_percentile": 0.52035}, "CVE-2023-45554": {"epss_score": 0.1015, "epss_percentile": 0.92866}, "CVE-2023-45555": {"epss_score": 0.00771, "epss_percentile": 0.73018}, "CVE-2023-45556": {"epss_score": 0.00165, "epss_percentile": 0.38106}, "CVE-2023-45558": {"epss_score": 0.00194, "epss_percentile": 0.41544}, "CVE-2023-45559": {"epss_score": 0.00094, "epss_percentile": 0.26954}, "CVE-2023-45560": {"epss_score": 0.00205, "epss_percentile": 0.42685}, "CVE-2023-45561": {"epss_score": 0.00185, "epss_percentile": 0.40522}, "CVE-2023-45572": {"epss_score": 0.08152, "epss_percentile": 0.91905}, "CVE-2023-45573": {"epss_score": 0.07939, "epss_percentile": 0.91777}, "CVE-2023-45574": {"epss_score": 0.22627, "epss_percentile": 0.95661}, "CVE-2023-45575": {"epss_score": 0.09125, "epss_percentile": 0.92412}, "CVE-2023-45576": {"epss_score": 0.09125, "epss_percentile": 0.92412}, "CVE-2023-45577": {"epss_score": 0.08152, "epss_percentile": 0.91905}, "CVE-2023-45578": {"epss_score": 0.09125, "epss_percentile": 0.92412}, "CVE-2023-45579": {"epss_score": 0.09125, "epss_percentile": 0.92412}, "CVE-2023-45580": {"epss_score": 0.09125, "epss_percentile": 0.92412}, "CVE-2023-45581": {"epss_score": 0.00114, "epss_percentile": 0.30825}, "CVE-2023-45582": {"epss_score": 0.00206, "epss_percentile": 0.42784}, "CVE-2023-45583": {"epss_score": 0.00211, "epss_percentile": 0.4364}, "CVE-2023-45584": {"epss_score": 0.00133, "epss_percentile": 0.33638}, "CVE-2023-45585": {"epss_score": 0.00053, "epss_percentile": 0.16682}, "CVE-2023-45586": {"epss_score": 0.00165, "epss_percentile": 0.3803}, "CVE-2023-45587": {"epss_score": 0.00438, "epss_percentile": 0.62569}, "CVE-2023-45588": {"epss_score": 0.00038, "epss_percentile": 0.11058}, "CVE-2023-45590": {"epss_score": 0.00991, "epss_percentile": 0.76388}, "CVE-2023-45591": {"epss_score": 0.01163, "epss_percentile": 0.78157}, "CVE-2023-45592": {"epss_score": 0.00333, "epss_percentile": 0.55653}, "CVE-2023-45593": {"epss_score": 0.00107, "epss_percentile": 0.29636}, "CVE-2023-45594": {"epss_score": 0.00079, "epss_percentile": 0.23825}, "CVE-2023-45595": {"epss_score": 0.00261, "epss_percentile": 0.49312}, "CVE-2023-45596": {"epss_score": 0.00206, "epss_percentile": 0.42774}, "CVE-2023-45597": {"epss_score": 0.00276, "epss_percentile": 0.50752}, "CVE-2023-45598": {"epss_score": 0.00206, "epss_percentile": 0.42774}, "CVE-2023-45599": {"epss_score": 0.00242, "epss_percentile": 0.47337}, "CVE-2023-45600": {"epss_score": 0.0012, "epss_percentile": 0.31758}, "CVE-2023-45601": {"epss_score": 0.0015, "epss_percentile": 0.36101}, "CVE-2023-45602": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45603": {"epss_score": 0.02163, "epss_percentile": 0.83835}, "CVE-2023-45604": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-45605": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-45606": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-45607": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-45608": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-45609": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-45612": {"epss_score": 4e-05, "epss_percentile": 0.00124}, "CVE-2023-45613": {"epss_score": 3e-05, "epss_percentile": 0.00068}, "CVE-2023-45614": {"epss_score": 0.00873, "epss_percentile": 0.74752}, "CVE-2023-45615": {"epss_score": 0.00873, "epss_percentile": 0.74752}, "CVE-2023-45616": {"epss_score": 0.00873, "epss_percentile": 0.74752}, "CVE-2023-45617": {"epss_score": 0.0053, "epss_percentile": 0.66614}, "CVE-2023-45618": {"epss_score": 0.0053, "epss_percentile": 0.66614}, "CVE-2023-45619": {"epss_score": 0.00692, "epss_percentile": 0.71293}, "CVE-2023-45620": {"epss_score": 0.00141, "epss_percentile": 0.34808}, "CVE-2023-45621": {"epss_score": 0.00164, "epss_percentile": 0.37986}, "CVE-2023-45622": {"epss_score": 0.00164, "epss_percentile": 0.37986}, "CVE-2023-45623": {"epss_score": 0.00141, "epss_percentile": 0.34808}, "CVE-2023-45624": {"epss_score": 0.00141, "epss_percentile": 0.34808}, "CVE-2023-45625": {"epss_score": 0.00073, "epss_percentile": 0.22484}, "CVE-2023-45626": {"epss_score": 0.00043, "epss_percentile": 0.13363}, "CVE-2023-45627": {"epss_score": 0.00102, "epss_percentile": 0.28725}, "CVE-2023-45628": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-45629": {"epss_score": 0.00106, "epss_percentile": 0.29522}, "CVE-2023-45630": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45631": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-45632": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-45633": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-45634": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2023-45635": {"epss_score": 0.00183, "epss_percentile": 0.40285}, "CVE-2023-45636": {"epss_score": 0.00142, "epss_percentile": 0.35024}, "CVE-2023-45637": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-45638": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-45639": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-45640": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-45641": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-45642": {"epss_score": 0.00106, "epss_percentile": 0.29522}, "CVE-2023-45643": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-45644": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2023-45645": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-45646": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2023-45647": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-45648": {"epss_score": 0.00732, "epss_percentile": 0.72195}, "CVE-2023-45649": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2023-45650": {"epss_score": 0.00147, "epss_percentile": 0.35772}, "CVE-2023-45651": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-45652": {"epss_score": 0.00907, "epss_percentile": 0.7526}, "CVE-2023-45653": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-45654": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-45655": {"epss_score": 0.00193, "epss_percentile": 0.4139}, "CVE-2023-45656": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-45657": {"epss_score": 0.12165, "epss_percentile": 0.93588}, "CVE-2023-45658": {"epss_score": 0.00142, "epss_percentile": 0.34968}, "CVE-2023-45659": {"epss_score": 0.00068, "epss_percentile": 0.21212}, "CVE-2023-45660": {"epss_score": 0.0013, "epss_percentile": 0.33334}, "CVE-2023-45661": {"epss_score": 0.00083, "epss_percentile": 0.24824}, "CVE-2023-45662": {"epss_score": 0.00108, "epss_percentile": 0.29818}, "CVE-2023-45663": {"epss_score": 0.00143, "epss_percentile": 0.35107}, "CVE-2023-45664": {"epss_score": 0.00192, "epss_percentile": 0.41309}, "CVE-2023-45666": {"epss_score": 0.00174, "epss_percentile": 0.39179}, "CVE-2023-45667": {"epss_score": 0.0014, "epss_percentile": 0.34727}, "CVE-2023-45669": {"epss_score": 0.00402, "epss_percentile": 0.60307}, "CVE-2023-45670": {"epss_score": 0.0025, "epss_percentile": 0.48149}, "CVE-2023-45671": {"epss_score": 0.26546, "epss_percentile": 0.96155}, "CVE-2023-45672": {"epss_score": 0.02626, "epss_percentile": 0.85267}, "CVE-2023-45673": {"epss_score": 0.02962, "epss_percentile": 0.86073}, "CVE-2023-45674": {"epss_score": 0.00306, "epss_percentile": 0.53449}, "CVE-2023-45675": {"epss_score": 0.00087, "epss_percentile": 0.25563}, "CVE-2023-45676": {"epss_score": 0.0005, "epss_percentile": 0.15723}, "CVE-2023-45677": {"epss_score": 0.0005, "epss_percentile": 0.15935}, "CVE-2023-45678": {"epss_score": 0.00081, "epss_percentile": 0.24353}, "CVE-2023-45679": {"epss_score": 0.0005, "epss_percentile": 0.15723}, "CVE-2023-45680": {"epss_score": 0.00022, "epss_percentile": 0.05032}, "CVE-2023-45681": {"epss_score": 0.00049, "epss_percentile": 0.15507}, "CVE-2023-45682": {"epss_score": 0.00022, "epss_percentile": 0.05272}, "CVE-2023-45683": {"epss_score": 0.00285, "epss_percentile": 0.51642}, "CVE-2023-45684": {"epss_score": 0.0058, "epss_percentile": 0.68241}, "CVE-2023-45685": {"epss_score": 0.00339, "epss_percentile": 0.56174}, "CVE-2023-45686": {"epss_score": 0.0046, "epss_percentile": 0.63521}, "CVE-2023-45687": {"epss_score": 0.00132, "epss_percentile": 0.33573}, "CVE-2023-45688": {"epss_score": 0.00318, "epss_percentile": 0.54396}, "CVE-2023-45689": {"epss_score": 0.00322, "epss_percentile": 0.54857}, "CVE-2023-45690": {"epss_score": 0.00237, "epss_percentile": 0.46661}, "CVE-2023-45696": {"epss_score": 0.00177, "epss_percentile": 0.3962}, "CVE-2023-45698": {"epss_score": 0.00118, "epss_percentile": 0.31415}, "CVE-2023-45700": {"epss_score": 0.00135, "epss_percentile": 0.34035}, "CVE-2023-45701": {"epss_score": 0.00081, "epss_percentile": 0.24369}, "CVE-2023-45702": {"epss_score": 0.00021, "epss_percentile": 0.04877}, "CVE-2023-45703": {"epss_score": 0.0008, "epss_percentile": 0.2408}, "CVE-2023-45705": {"epss_score": 0.00234, "epss_percentile": 0.46092}, "CVE-2023-45706": {"epss_score": 0.00131, "epss_percentile": 0.33376}, "CVE-2023-45707": {"epss_score": 0.00151, "epss_percentile": 0.36229}, "CVE-2023-45715": {"epss_score": 0.00104, "epss_percentile": 0.29193}, "CVE-2023-45716": {"epss_score": 0.00064, "epss_percentile": 0.20155}, "CVE-2023-45718": {"epss_score": 0.00206, "epss_percentile": 0.4295}, "CVE-2023-45720": {"epss_score": 0.00065, "epss_percentile": 0.20487}, "CVE-2023-45721": {"epss_score": 0.00044, "epss_percentile": 0.13375}, "CVE-2023-45722": {"epss_score": 0.00122, "epss_percentile": 0.32066}, "CVE-2023-45723": {"epss_score": 0.00069, "epss_percentile": 0.21621}, "CVE-2023-45724": {"epss_score": 0.00172, "epss_percentile": 0.38906}, "CVE-2023-45725": {"epss_score": 0.00222, "epss_percentile": 0.44792}, "CVE-2023-45727": {"epss_score": 0.22965, "epss_percentile": 0.9571}, "CVE-2023-45733": {"epss_score": 0.00017, "epss_percentile": 0.03136}, "CVE-2023-45734": {"epss_score": 0.00036, "epss_percentile": 0.10319}, "CVE-2023-45735": {"epss_score": 0.00103, "epss_percentile": 0.29065}, "CVE-2023-45736": {"epss_score": 0.00063, "epss_percentile": 0.19936}, "CVE-2023-45737": {"epss_score": 0.00452, "epss_percentile": 0.63196}, "CVE-2023-45740": {"epss_score": 0.00452, "epss_percentile": 0.63196}, "CVE-2023-45741": {"epss_score": 0.00083, "epss_percentile": 0.24816}, "CVE-2023-45742": {"epss_score": 0.00274, "epss_percentile": 0.50507}, "CVE-2023-45743": {"epss_score": 0.00172, "epss_percentile": 0.3899}, "CVE-2023-45744": {"epss_score": 0.00746, "epss_percentile": 0.72537}, "CVE-2023-45745": {"epss_score": 0.00074, "epss_percentile": 0.22744}, "CVE-2023-45746": {"epss_score": 0.00109, "epss_percentile": 0.30063}, "CVE-2023-45747": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-45748": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-45749": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-45750": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-45751": {"epss_score": 0.00483, "epss_percentile": 0.64566}, "CVE-2023-45752": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-45753": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-45754": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2023-45755": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-45756": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-45757": {"epss_score": 0.03819, "epss_percentile": 0.87773}, "CVE-2023-45758": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-45759": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-45760": {"epss_score": 0.0033, "epss_percentile": 0.5548}, "CVE-2023-45761": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-45762": {"epss_score": 0.00337, "epss_percentile": 0.56064}, "CVE-2023-45763": {"epss_score": 0.00084, "epss_percentile": 0.24826}, "CVE-2023-45764": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-45765": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-45766": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-45767": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-45768": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-45769": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-45770": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-45771": {"epss_score": 0.00144, "epss_percentile": 0.35232}, "CVE-2023-45772": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-45773": {"epss_score": 0.00038, "epss_percentile": 0.1132}, "CVE-2023-45774": {"epss_score": 0.00038, "epss_percentile": 0.1132}, "CVE-2023-45775": {"epss_score": 0.00038, "epss_percentile": 0.1132}, "CVE-2023-45776": {"epss_score": 0.00038, "epss_percentile": 0.1132}, "CVE-2023-45777": {"epss_score": 0.00147, "epss_percentile": 0.35722}, "CVE-2023-45779": {"epss_score": 0.00206, "epss_percentile": 0.42771}, "CVE-2023-45780": {"epss_score": 0.00047, "epss_percentile": 0.1464}, "CVE-2023-45781": {"epss_score": 0.00064, "epss_percentile": 0.20286}, "CVE-2023-45793": {"epss_score": 0.00079, "epss_percentile": 0.23967}, "CVE-2023-45794": {"epss_score": 0.00158, "epss_percentile": 0.3719}, "CVE-2023-45797": {"epss_score": 0.00165, "epss_percentile": 0.38034}, "CVE-2023-45798": {"epss_score": 0.00809, "epss_percentile": 0.73709}, "CVE-2023-45799": {"epss_score": 0.00051, "epss_percentile": 0.16194}, "CVE-2023-45800": {"epss_score": 0.00071, "epss_percentile": 0.22164}, "CVE-2023-45801": {"epss_score": 0.00098, "epss_percentile": 0.27669}, "CVE-2023-45802": {"epss_score": 0.02165, "epss_percentile": 0.83844}, "CVE-2023-45803": {"epss_score": 0.00051, "epss_percentile": 0.16166}, "CVE-2023-45805": {"epss_score": 0.0011, "epss_percentile": 0.30106}, "CVE-2023-45806": {"epss_score": 0.03318, "epss_percentile": 0.86906}, "CVE-2023-45807": {"epss_score": 0.00086, "epss_percentile": 0.25378}, "CVE-2023-45808": {"epss_score": 0.00281, "epss_percentile": 0.51148}, "CVE-2023-45809": {"epss_score": 0.00211, "epss_percentile": 0.43676}, "CVE-2023-45810": {"epss_score": 0.00069, "epss_percentile": 0.21459}, "CVE-2023-45811": {"epss_score": 0.00165, "epss_percentile": 0.38125}, "CVE-2023-45812": {"epss_score": 0.0057, "epss_percentile": 0.67959}, "CVE-2023-45813": {"epss_score": 0.00768, "epss_percentile": 0.72975}, "CVE-2023-45814": {"epss_score": 0.00127, "epss_percentile": 0.32863}, "CVE-2023-45815": {"epss_score": 0.01958, "epss_percentile": 0.83048}, "CVE-2023-45816": {"epss_score": 0.00167, "epss_percentile": 0.38319}, "CVE-2023-45818": {"epss_score": 0.01282, "epss_percentile": 0.79155}, "CVE-2023-45819": {"epss_score": 0.0284, "epss_percentile": 0.85804}, "CVE-2023-45820": {"epss_score": 0.0036, "epss_percentile": 0.57675}, "CVE-2023-45821": {"epss_score": 0.00036, "epss_percentile": 0.10165}, "CVE-2023-45822": {"epss_score": 0.00091, "epss_percentile": 0.26382}, "CVE-2023-45823": {"epss_score": 0.00105, "epss_percentile": 0.29361}, "CVE-2023-45824": {"epss_score": 0.0024, "epss_percentile": 0.47226}, "CVE-2023-45825": {"epss_score": 0.00134, "epss_percentile": 0.33789}, "CVE-2023-45826": {"epss_score": 0.1359, "epss_percentile": 0.94004}, "CVE-2023-45827": {"epss_score": 0.08398, "epss_percentile": 0.92032}, "CVE-2023-45828": {"epss_score": 0.08394, "epss_percentile": 0.92028}, "CVE-2023-45829": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-45830": {"epss_score": 0.00147, "epss_percentile": 0.35701}, "CVE-2023-45831": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-45832": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-45833": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-45834": {"epss_score": 0.00366, "epss_percentile": 0.58053}, "CVE-2023-45835": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2023-45836": {"epss_score": 0.00147, "epss_percentile": 0.35772}, "CVE-2023-45837": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-45838": {"epss_score": 0.00122, "epss_percentile": 0.32028}, "CVE-2023-45839": {"epss_score": 0.00089, "epss_percentile": 0.25987}, "CVE-2023-45840": {"epss_score": 0.00089, "epss_percentile": 0.25987}, "CVE-2023-45841": {"epss_score": 0.00089, "epss_percentile": 0.25987}, "CVE-2023-45842": {"epss_score": 0.00089, "epss_percentile": 0.25987}, "CVE-2023-45844": {"epss_score": 0.00117, "epss_percentile": 0.31265}, "CVE-2023-45845": {"epss_score": 0.00041, "epss_percentile": 0.12384}, "CVE-2023-45846": {"epss_score": 0.00056, "epss_percentile": 0.17959}, "CVE-2023-45847": {"epss_score": 0.00129, "epss_percentile": 0.33192}, "CVE-2023-45849": {"epss_score": 0.00343, "epss_percentile": 0.56445}, "CVE-2023-45851": {"epss_score": 0.00108, "epss_percentile": 0.29791}, "CVE-2023-45852": {"epss_score": 0.93587, "epss_percentile": 0.99821}, "CVE-2023-45853": {"epss_score": 0.01396, "epss_percentile": 0.79979}, "CVE-2023-45854": {"epss_score": 0.0027, "epss_percentile": 0.50253}, "CVE-2023-45855": {"epss_score": 0.77635, "epss_percentile": 0.98945}, "CVE-2023-45856": {"epss_score": 0.06593, "epss_percentile": 0.90875}, "CVE-2023-45857": {"epss_score": 0.00132, "epss_percentile": 0.33549}, "CVE-2023-45859": {"epss_score": 0.00201, "epss_percentile": 0.42326}, "CVE-2023-45860": {"epss_score": 0.00459, "epss_percentile": 0.63452}, "CVE-2023-45862": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2023-45863": {"epss_score": 9e-05, "epss_percentile": 0.00739}, "CVE-2023-45864": {"epss_score": 0.00024, "epss_percentile": 0.05991}, "CVE-2023-45866": {"epss_score": 0.32023, "epss_percentile": 0.96667}, "CVE-2023-45867": {"epss_score": 0.00194, "epss_percentile": 0.41583}, "CVE-2023-45868": {"epss_score": 0.00291, "epss_percentile": 0.5215}, "CVE-2023-45869": {"epss_score": 0.00112, "epss_percentile": 0.30441}, "CVE-2023-45871": {"epss_score": 0.00025, "epss_percentile": 0.06244}, "CVE-2023-45872": {"epss_score": 0.00106, "epss_percentile": 0.29399}, "CVE-2023-45873": {"epss_score": 0.00394, "epss_percentile": 0.59791}, "CVE-2023-45874": {"epss_score": 0.00306, "epss_percentile": 0.5343}, "CVE-2023-45875": {"epss_score": 0.00356, "epss_percentile": 0.57328}, "CVE-2023-45878": {"epss_score": 0.92509, "epss_percentile": 0.99722}, "CVE-2023-45879": {"epss_score": 0.00239, "epss_percentile": 0.46905}, "CVE-2023-45880": {"epss_score": 0.0043, "epss_percentile": 0.62004}, "CVE-2023-45881": {"epss_score": 0.00259, "epss_percentile": 0.49096}, "CVE-2023-45883": {"epss_score": 0.00066, "epss_percentile": 0.20823}, "CVE-2023-45884": {"epss_score": 0.00093, "epss_percentile": 0.26735}, "CVE-2023-45885": {"epss_score": 0.0012, "epss_percentile": 0.3171}, "CVE-2023-45886": {"epss_score": 0.00313, "epss_percentile": 0.54047}, "CVE-2023-45887": {"epss_score": 0.01127, "epss_percentile": 0.77822}, "CVE-2023-45889": {"epss_score": 0.00148, "epss_percentile": 0.35854}, "CVE-2023-45892": {"epss_score": 0.01006, "epss_percentile": 0.76549}, "CVE-2023-45893": {"epss_score": 0.01006, "epss_percentile": 0.76549}, "CVE-2023-45894": {"epss_score": 0.03473, "epss_percentile": 0.87204}, "CVE-2023-45896": {"epss_score": 0.00043, "epss_percentile": 0.13002}, "CVE-2023-45897": {"epss_score": 0.00048, "epss_percentile": 0.15099}, "CVE-2023-45898": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2023-45899": {"epss_score": 0.00052, "epss_percentile": 0.16406}, "CVE-2023-45901": {"epss_score": 0.00076, "epss_percentile": 0.23116}, "CVE-2023-45902": {"epss_score": 0.00076, "epss_percentile": 0.23116}, "CVE-2023-45903": {"epss_score": 0.00076, "epss_percentile": 0.23116}, "CVE-2023-45904": {"epss_score": 0.00076, "epss_percentile": 0.23116}, "CVE-2023-45905": {"epss_score": 0.00076, "epss_percentile": 0.23116}, "CVE-2023-45906": {"epss_score": 0.00076, "epss_percentile": 0.23116}, "CVE-2023-45907": {"epss_score": 0.00099, "epss_percentile": 0.28362}, "CVE-2023-45908": {"epss_score": 0.00098, "epss_percentile": 0.27785}, "CVE-2023-45909": {"epss_score": 0.00066, "epss_percentile": 0.20957}, "CVE-2023-45911": {"epss_score": 0.00223, "epss_percentile": 0.44885}, "CVE-2023-45912": {"epss_score": 0.00169, "epss_percentile": 0.3854}, "CVE-2023-45913": {"epss_score": 0.00017, "epss_percentile": 0.03139}, "CVE-2023-45919": {"epss_score": 0.00074, "epss_percentile": 0.22839}, "CVE-2023-45920": {"epss_score": 0.00017, "epss_percentile": 0.03327}, "CVE-2023-45922": {"epss_score": 0.0006, "epss_percentile": 0.19031}, "CVE-2023-45924": {"epss_score": 0.00123, "epss_percentile": 0.32205}, "CVE-2023-45925": {"epss_score": 0.00058, "epss_percentile": 0.18577}, "CVE-2023-45927": {"epss_score": 0.00107, "epss_percentile": 0.29716}, "CVE-2023-45929": {"epss_score": 0.00097, "epss_percentile": 0.27494}, "CVE-2023-45931": {"epss_score": 0.00183, "epss_percentile": 0.40279}, "CVE-2023-45935": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2023-45951": {"epss_score": 0.00196, "epss_percentile": 0.41741}, "CVE-2023-45952": {"epss_score": 0.00107, "epss_percentile": 0.29635}, "CVE-2023-45955": {"epss_score": 0.00084, "epss_percentile": 0.24837}, "CVE-2023-45956": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-45957": {"epss_score": 0.00207, "epss_percentile": 0.43114}, "CVE-2023-45958": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-45966": {"epss_score": 0.00276, "epss_percentile": 0.5074}, "CVE-2023-45984": {"epss_score": 0.0021, "epss_percentile": 0.43481}, "CVE-2023-45985": {"epss_score": 0.00348, "epss_percentile": 0.56828}, "CVE-2023-45990": {"epss_score": 0.01036, "epss_percentile": 0.76909}, "CVE-2023-45992": {"epss_score": 0.00551, "epss_percentile": 0.67354}, "CVE-2023-45996": {"epss_score": 0.02021, "epss_percentile": 0.83296}, "CVE-2023-45998": {"epss_score": 0.00124, "epss_percentile": 0.32448}, "CVE-2023-46001": {"epss_score": 0.00055, "epss_percentile": 0.17605}, "CVE-2023-46003": {"epss_score": 0.00138, "epss_percentile": 0.34444}, "CVE-2023-46004": {"epss_score": 0.00093, "epss_percentile": 0.26661}, "CVE-2023-46005": {"epss_score": 0.0009, "epss_percentile": 0.25991}, "CVE-2023-46006": {"epss_score": 0.0009, "epss_percentile": 0.25991}, "CVE-2023-46007": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-46009": {"epss_score": 0.00057, "epss_percentile": 0.18133}, "CVE-2023-46010": {"epss_score": 0.00275, "epss_percentile": 0.50646}, "CVE-2023-46012": {"epss_score": 0.36472, "epss_percentile": 0.9698}, "CVE-2023-46014": {"epss_score": 0.00106, "epss_percentile": 0.29499}, "CVE-2023-46015": {"epss_score": 0.00127, "epss_percentile": 0.32894}, "CVE-2023-46016": {"epss_score": 0.00127, "epss_percentile": 0.32894}, "CVE-2023-46017": {"epss_score": 0.00075, "epss_percentile": 0.22963}, "CVE-2023-46018": {"epss_score": 0.00075, "epss_percentile": 0.22963}, "CVE-2023-46019": {"epss_score": 0.00127, "epss_percentile": 0.32894}, "CVE-2023-46020": {"epss_score": 0.00127, "epss_percentile": 0.32894}, "CVE-2023-46021": {"epss_score": 0.00075, "epss_percentile": 0.22963}, "CVE-2023-46022": {"epss_score": 0.00457, "epss_percentile": 0.63376}, "CVE-2023-46023": {"epss_score": 0.00121, "epss_percentile": 0.32002}, "CVE-2023-46024": {"epss_score": 0.02421, "epss_percentile": 0.84703}, "CVE-2023-46025": {"epss_score": 0.00129, "epss_percentile": 0.33195}, "CVE-2023-46026": {"epss_score": 0.00144, "epss_percentile": 0.35327}, "CVE-2023-46033": {"epss_score": 0.00093, "epss_percentile": 0.2668}, "CVE-2023-46040": {"epss_score": 0.00221, "epss_percentile": 0.44635}, "CVE-2023-46042": {"epss_score": 0.68243, "epss_percentile": 0.98537}, "CVE-2023-46045": {"epss_score": 0.00037, "epss_percentile": 0.10884}, "CVE-2023-46046": {"epss_score": 0.0009, "epss_percentile": 0.26076}, "CVE-2023-46047": {"epss_score": 0.00037, "epss_percentile": 0.10631}, "CVE-2023-46048": {"epss_score": 0.00046, "epss_percentile": 0.14295}, "CVE-2023-46049": {"epss_score": 0.00191, "epss_percentile": 0.41256}, "CVE-2023-46051": {"epss_score": 0.00021, "epss_percentile": 0.0494}, "CVE-2023-46052": {"epss_score": 0.00055, "epss_percentile": 0.17654}, "CVE-2023-46054": {"epss_score": 0.00109, "epss_percentile": 0.30034}, "CVE-2023-46055": {"epss_score": 0.03479, "epss_percentile": 0.87217}, "CVE-2023-46058": {"epss_score": 0.00188, "epss_percentile": 0.40876}, "CVE-2023-46059": {"epss_score": 0.00137, "epss_percentile": 0.34247}, "CVE-2023-46060": {"epss_score": 0.01438, "epss_percentile": 0.80288}, "CVE-2023-46066": {"epss_score": 0.00111, "epss_percentile": 0.30289}, "CVE-2023-46067": {"epss_score": 0.00147, "epss_percentile": 0.35772}, "CVE-2023-46068": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-46069": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-46070": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-46071": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-46072": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46073": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-46074": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46075": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46076": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46077": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46078": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-46079": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-46080": {"epss_score": 0.00163, "epss_percentile": 0.37788}, "CVE-2023-46081": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46082": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-46083": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-46084": {"epss_score": 0.00211, "epss_percentile": 0.43621}, "CVE-2023-46085": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-46086": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-46087": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-46088": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-46089": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-46090": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46091": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-46092": {"epss_score": 0.00061, "epss_percentile": 0.19251}, "CVE-2023-46093": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-46094": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46095": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-46096": {"epss_score": 0.00065, "epss_percentile": 0.20638}, "CVE-2023-46097": {"epss_score": 0.00101, "epss_percentile": 0.28672}, "CVE-2023-46098": {"epss_score": 0.00188, "epss_percentile": 0.40851}, "CVE-2023-46099": {"epss_score": 0.00101, "epss_percentile": 0.28711}, "CVE-2023-46100": {"epss_score": 0.00034, "epss_percentile": 0.09575}, "CVE-2023-46102": {"epss_score": 0.00101, "epss_percentile": 0.28588}, "CVE-2023-46103": {"epss_score": 0.00012, "epss_percentile": 0.01173}, "CVE-2023-46104": {"epss_score": 0.00512, "epss_percentile": 0.65868}, "CVE-2023-46115": {"epss_score": 0.00059, "epss_percentile": 0.18665}, "CVE-2023-46116": {"epss_score": 0.00867, "epss_percentile": 0.74658}, "CVE-2023-46117": {"epss_score": 0.02946, "epss_percentile": 0.86041}, "CVE-2023-46118": {"epss_score": 0.00199, "epss_percentile": 0.42102}, "CVE-2023-46119": {"epss_score": 0.0057, "epss_percentile": 0.67946}, "CVE-2023-46120": {"epss_score": 0.00738, "epss_percentile": 0.72336}, "CVE-2023-46121": {"epss_score": 0.00095, "epss_percentile": 0.27119}, "CVE-2023-46122": {"epss_score": 0.00029, "epss_percentile": 0.07584}, "CVE-2023-46123": {"epss_score": 0.00444, "epss_percentile": 0.62845}, "CVE-2023-46124": {"epss_score": 0.00097, "epss_percentile": 0.27567}, "CVE-2023-46125": {"epss_score": 0.00179, "epss_percentile": 0.39787}, "CVE-2023-46126": {"epss_score": 0.00142, "epss_percentile": 0.3509}, "CVE-2023-46127": {"epss_score": 0.23895, "epss_percentile": 0.95831}, "CVE-2023-46128": {"epss_score": 0.00209, "epss_percentile": 0.4333}, "CVE-2023-46129": {"epss_score": 0.00121, "epss_percentile": 0.31812}, "CVE-2023-46130": {"epss_score": 0.00194, "epss_percentile": 0.41545}, "CVE-2023-46131": {"epss_score": 0.00544, "epss_percentile": 0.67151}, "CVE-2023-46132": {"epss_score": 0.00179, "epss_percentile": 0.39835}, "CVE-2023-46133": {"epss_score": 0.00182, "epss_percentile": 0.40265}, "CVE-2023-46134": {"epss_score": 0.02129, "epss_percentile": 0.83707}, "CVE-2023-46135": {"epss_score": 0.00168, "epss_percentile": 0.38449}, "CVE-2023-46136": {"epss_score": 0.00511, "epss_percentile": 0.65833}, "CVE-2023-46137": {"epss_score": 0.00645, "epss_percentile": 0.70116}, "CVE-2023-46138": {"epss_score": 0.00041, "epss_percentile": 0.12376}, "CVE-2023-46139": {"epss_score": 0.00023, "epss_percentile": 0.05511}, "CVE-2023-46141": {"epss_score": 0.00811, "epss_percentile": 0.73726}, "CVE-2023-46142": {"epss_score": 0.00258, "epss_percentile": 0.48972}, "CVE-2023-46143": {"epss_score": 0.00244, "epss_percentile": 0.4761}, "CVE-2023-46144": {"epss_score": 0.00046, "epss_percentile": 0.14465}, "CVE-2023-46145": {"epss_score": 0.00219, "epss_percentile": 0.44471}, "CVE-2023-46146": {"epss_score": 0.0039, "epss_percentile": 0.59516}, "CVE-2023-46147": {"epss_score": 0.00178, "epss_percentile": 0.39648}, "CVE-2023-46148": {"epss_score": 0.00409, "epss_percentile": 0.60727}, "CVE-2023-46149": {"epss_score": 0.00314, "epss_percentile": 0.54089}, "CVE-2023-46150": {"epss_score": 0.00123, "epss_percentile": 0.32321}, "CVE-2023-46151": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-46152": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-46153": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46154": {"epss_score": 0.00262, "epss_percentile": 0.49325}, "CVE-2023-46156": {"epss_score": 0.0004, "epss_percentile": 0.12043}, "CVE-2023-46157": {"epss_score": 0.00618, "epss_percentile": 0.69367}, "CVE-2023-46158": {"epss_score": 0.00041, "epss_percentile": 0.12235}, "CVE-2023-46159": {"epss_score": 0.00026, "epss_percentile": 0.06386}, "CVE-2023-46167": {"epss_score": 0.00131, "epss_percentile": 0.33398}, "CVE-2023-46169": {"epss_score": 0.00062, "epss_percentile": 0.19721}, "CVE-2023-46170": {"epss_score": 0.00052, "epss_percentile": 0.16402}, "CVE-2023-46171": {"epss_score": 0.00055, "epss_percentile": 0.17506}, "CVE-2023-46172": {"epss_score": 0.00031, "epss_percentile": 0.08552}, "CVE-2023-46174": {"epss_score": 0.0006, "epss_percentile": 0.19227}, "CVE-2023-46175": {"epss_score": 0.00107, "epss_percentile": 0.29752}, "CVE-2023-46176": {"epss_score": 0.0002, "epss_percentile": 0.04596}, "CVE-2023-46177": {"epss_score": 0.00045, "epss_percentile": 0.13895}, "CVE-2023-46179": {"epss_score": 0.00036, "epss_percentile": 0.10318}, "CVE-2023-46181": {"epss_score": 0.00027, "epss_percentile": 0.07159}, "CVE-2023-46182": {"epss_score": 0.00135, "epss_percentile": 0.34016}, "CVE-2023-46183": {"epss_score": 0.00019, "epss_percentile": 0.04068}, "CVE-2023-46186": {"epss_score": 0.0009, "epss_percentile": 0.26144}, "CVE-2023-46187": {"epss_score": 0.00022, "epss_percentile": 0.05191}, "CVE-2023-46188": {"epss_score": 0.00193, "epss_percentile": 0.41431}, "CVE-2023-46189": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2023-46190": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-46191": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2023-46192": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-46193": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-46194": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46195": {"epss_score": 0.00157, "epss_percentile": 0.37064}, "CVE-2023-46196": {"epss_score": 0.00155, "epss_percentile": 0.36775}, "CVE-2023-46197": {"epss_score": 0.23079, "epss_percentile": 0.95731}, "CVE-2023-46198": {"epss_score": 0.00123, "epss_percentile": 0.32321}, "CVE-2023-46199": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-46200": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-46201": {"epss_score": 0.0007, "epss_percentile": 0.21863}, "CVE-2023-46202": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2023-46203": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-46204": {"epss_score": 0.0034, "epss_percentile": 0.56226}, "CVE-2023-46205": {"epss_score": 0.00131, "epss_percentile": 0.33392}, "CVE-2023-46206": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-46207": {"epss_score": 0.00174, "epss_percentile": 0.39143}, "CVE-2023-46208": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46209": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46210": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-46211": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-46212": {"epss_score": 0.00053, "epss_percentile": 0.167}, "CVE-2023-46213": {"epss_score": 0.00167, "epss_percentile": 0.38402}, "CVE-2023-46214": {"epss_score": 0.87931, "epss_percentile": 0.99451}, "CVE-2023-46215": {"epss_score": 0.00253, "epss_percentile": 0.48426}, "CVE-2023-46216": {"epss_score": 0.01892, "epss_percentile": 0.82736}, "CVE-2023-46217": {"epss_score": 0.03245, "epss_percentile": 0.86742}, "CVE-2023-46218": {"epss_score": 0.00432, "epss_percentile": 0.62131}, "CVE-2023-46219": {"epss_score": 0.00221, "epss_percentile": 0.4464}, "CVE-2023-46220": {"epss_score": 0.01892, "epss_percentile": 0.82736}, "CVE-2023-46221": {"epss_score": 0.01892, "epss_percentile": 0.82736}, "CVE-2023-46222": {"epss_score": 0.01892, "epss_percentile": 0.82736}, "CVE-2023-46223": {"epss_score": 0.03245, "epss_percentile": 0.86742}, "CVE-2023-46224": {"epss_score": 0.03245, "epss_percentile": 0.86742}, "CVE-2023-46225": {"epss_score": 0.02455, "epss_percentile": 0.84797}, "CVE-2023-46226": {"epss_score": 0.05023, "epss_percentile": 0.89403}, "CVE-2023-46227": {"epss_score": 0.00048, "epss_percentile": 0.15224}, "CVE-2023-46228": {"epss_score": 0.00028, "epss_percentile": 0.07539}, "CVE-2023-46229": {"epss_score": 0.00592, "epss_percentile": 0.68612}, "CVE-2023-46230": {"epss_score": 0.00053, "epss_percentile": 0.16851}, "CVE-2023-46231": {"epss_score": 0.00188, "epss_percentile": 0.40886}, "CVE-2023-46232": {"epss_score": 0.00307, "epss_percentile": 0.53485}, "CVE-2023-46233": {"epss_score": 0.01073, "epss_percentile": 0.77292}, "CVE-2023-46234": {"epss_score": 0.00514, "epss_percentile": 0.65945}, "CVE-2023-46235": {"epss_score": 0.00553, "epss_percentile": 0.67429}, "CVE-2023-46236": {"epss_score": 0.00292, "epss_percentile": 0.52233}, "CVE-2023-46237": {"epss_score": 0.00422, "epss_percentile": 0.61576}, "CVE-2023-46238": {"epss_score": 0.0053, "epss_percentile": 0.66627}, "CVE-2023-46239": {"epss_score": 0.0043, "epss_percentile": 0.62032}, "CVE-2023-46240": {"epss_score": 0.00426, "epss_percentile": 0.61766}, "CVE-2023-46241": {"epss_score": 0.00432, "epss_percentile": 0.62104}, "CVE-2023-46242": {"epss_score": 0.03252, "epss_percentile": 0.86753}, "CVE-2023-46243": {"epss_score": 0.07479, "epss_percentile": 0.91494}, "CVE-2023-46244": {"epss_score": 0.01419, "epss_percentile": 0.80161}, "CVE-2023-46245": {"epss_score": 0.0227, "epss_percentile": 0.84206}, "CVE-2023-46246": {"epss_score": 0.00013, "epss_percentile": 0.01512}, "CVE-2023-46247": {"epss_score": 0.00336, "epss_percentile": 0.55996}, "CVE-2023-46248": {"epss_score": 0.03277, "epss_percentile": 0.86806}, "CVE-2023-46249": {"epss_score": 0.00614, "epss_percentile": 0.69276}, "CVE-2023-46250": {"epss_score": 0.00089, "epss_percentile": 0.25839}, "CVE-2023-46251": {"epss_score": 0.00544, "epss_percentile": 0.67134}, "CVE-2023-46252": {"epss_score": 0.00267, "epss_percentile": 0.50008}, "CVE-2023-46253": {"epss_score": 0.04454, "epss_percentile": 0.8871}, "CVE-2023-46254": {"epss_score": 0.00233, "epss_percentile": 0.4603}, "CVE-2023-46255": {"epss_score": 0.00158, "epss_percentile": 0.37201}, "CVE-2023-46256": {"epss_score": 0.00304, "epss_percentile": 0.5326}, "CVE-2023-46257": {"epss_score": 0.01892, "epss_percentile": 0.82736}, "CVE-2023-46258": {"epss_score": 0.01892, "epss_percentile": 0.82736}, "CVE-2023-46259": {"epss_score": 0.01892, "epss_percentile": 0.82736}, "CVE-2023-46260": {"epss_score": 0.01855, "epss_percentile": 0.82567}, "CVE-2023-46261": {"epss_score": 0.01892, "epss_percentile": 0.82736}, "CVE-2023-46262": {"epss_score": 0.37174, "epss_percentile": 0.97025}, "CVE-2023-46263": {"epss_score": 0.78849, "epss_percentile": 0.99007}, "CVE-2023-46264": {"epss_score": 0.65084, "epss_percentile": 0.98403}, "CVE-2023-46265": {"epss_score": 0.00928, "epss_percentile": 0.75574}, "CVE-2023-46266": {"epss_score": 0.00928, "epss_percentile": 0.75583}, "CVE-2023-46270": {"epss_score": 0.00037, "epss_percentile": 0.10802}, "CVE-2023-46271": {"epss_score": 0.00105, "epss_percentile": 0.29382}, "CVE-2023-46272": {"epss_score": 0.00046, "epss_percentile": 0.14306}, "CVE-2023-46277": {"epss_score": 0.0007, "epss_percentile": 0.21762}, "CVE-2023-46278": {"epss_score": 0.00448, "epss_percentile": 0.6301}, "CVE-2023-46279": {"epss_score": 0.0194, "epss_percentile": 0.82976}, "CVE-2023-46280": {"epss_score": 0.00064, "epss_percentile": 0.20179}, "CVE-2023-46281": {"epss_score": 0.00111, "epss_percentile": 0.30249}, "CVE-2023-46282": {"epss_score": 0.00121, "epss_percentile": 0.31923}, "CVE-2023-46283": {"epss_score": 0.00216, "epss_percentile": 0.44195}, "CVE-2023-46284": {"epss_score": 0.00216, "epss_percentile": 0.44195}, "CVE-2023-46285": {"epss_score": 0.00213, "epss_percentile": 0.43921}, "CVE-2023-46287": {"epss_score": 0.00107, "epss_percentile": 0.29729}, "CVE-2023-46288": {"epss_score": 0.00638, "epss_percentile": 0.69912}, "CVE-2023-46289": {"epss_score": 0.00169, "epss_percentile": 0.38559}, "CVE-2023-46290": {"epss_score": 0.00209, "epss_percentile": 0.43335}, "CVE-2023-46294": {"epss_score": 0.00018, "epss_percentile": 0.03542}, "CVE-2023-46295": {"epss_score": 0.01026, "epss_percentile": 0.768}, "CVE-2023-46297": {"epss_score": 0.00066, "epss_percentile": 0.20703}, "CVE-2023-46298": {"epss_score": 0.00417, "epss_percentile": 0.61258}, "CVE-2023-46300": {"epss_score": 0.00154, "epss_percentile": 0.36705}, "CVE-2023-46301": {"epss_score": 0.00154, "epss_percentile": 0.36705}, "CVE-2023-46302": {"epss_score": 0.00212, "epss_percentile": 0.43802}, "CVE-2023-46303": {"epss_score": 0.00591, "epss_percentile": 0.68582}, "CVE-2023-46304": {"epss_score": 0.20756, "epss_percentile": 0.95408}, "CVE-2023-46306": {"epss_score": 0.00147, "epss_percentile": 0.35711}, "CVE-2023-46307": {"epss_score": 0.00488, "epss_percentile": 0.6486}, "CVE-2023-46308": {"epss_score": 0.00116, "epss_percentile": 0.31048}, "CVE-2023-46309": {"epss_score": 0.00093, "epss_percentile": 0.26645}, "CVE-2023-46310": {"epss_score": 0.00237, "epss_percentile": 0.46733}, "CVE-2023-46311": {"epss_score": 0.00065, "epss_percentile": 0.2067}, "CVE-2023-46312": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46313": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46315": {"epss_score": 0.00164, "epss_percentile": 0.37895}, "CVE-2023-46316": {"epss_score": 0.00038, "epss_percentile": 0.1135}, "CVE-2023-46317": {"epss_score": 0.00072, "epss_percentile": 0.22308}, "CVE-2023-46319": {"epss_score": 0.00109, "epss_percentile": 0.29996}, "CVE-2023-46321": {"epss_score": 0.0034, "epss_percentile": 0.56213}, "CVE-2023-46322": {"epss_score": 0.0034, "epss_percentile": 0.56213}, "CVE-2023-46324": {"epss_score": 0.00054, "epss_percentile": 0.17099}, "CVE-2023-46326": {"epss_score": 0.00381, "epss_percentile": 0.59017}, "CVE-2023-46327": {"epss_score": 0.00164, "epss_percentile": 0.37912}, "CVE-2023-46331": {"epss_score": 0.0006, "epss_percentile": 0.19024}, "CVE-2023-46332": {"epss_score": 0.00046, "epss_percentile": 0.14458}, "CVE-2023-46343": {"epss_score": 9e-05, "epss_percentile": 0.00604}, "CVE-2023-46344": {"epss_score": 0.00181, "epss_percentile": 0.40014}, "CVE-2023-46345": {"epss_score": 0.0009, "epss_percentile": 0.26063}, "CVE-2023-46346": {"epss_score": 0.00259, "epss_percentile": 0.49075}, "CVE-2023-46347": {"epss_score": 0.68302, "epss_percentile": 0.98541}, "CVE-2023-46348": {"epss_score": 0.00369, "epss_percentile": 0.58268}, "CVE-2023-46349": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-46350": {"epss_score": 0.00308, "epss_percentile": 0.53587}, "CVE-2023-46351": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2023-46352": {"epss_score": 0.00062, "epss_percentile": 0.19661}, "CVE-2023-46353": {"epss_score": 0.00073, "epss_percentile": 0.2259}, "CVE-2023-46354": {"epss_score": 0.00073, "epss_percentile": 0.22558}, "CVE-2023-46355": {"epss_score": 0.00088, "epss_percentile": 0.25771}, "CVE-2023-46356": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-46357": {"epss_score": 0.00076, "epss_percentile": 0.23281}, "CVE-2023-46358": {"epss_score": 0.00282, "epss_percentile": 0.51252}, "CVE-2023-46359": {"epss_score": 0.93632, "epss_percentile": 0.99826}, "CVE-2023-46360": {"epss_score": 0.55116, "epss_percentile": 0.97961}, "CVE-2023-46361": {"epss_score": 0.00093, "epss_percentile": 0.26708}, "CVE-2023-46362": {"epss_score": 0.00044, "epss_percentile": 0.13396}, "CVE-2023-46363": {"epss_score": 0.00085, "epss_percentile": 0.25124}, "CVE-2023-46369": {"epss_score": 0.00278, "epss_percentile": 0.50859}, "CVE-2023-46370": {"epss_score": 0.57666, "epss_percentile": 0.98077}, "CVE-2023-46371": {"epss_score": 0.00873, "epss_percentile": 0.7475}, "CVE-2023-46373": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-46374": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-46375": {"epss_score": 0.00078, "epss_percentile": 0.23659}, "CVE-2023-46376": {"epss_score": 0.00043, "epss_percentile": 0.13287}, "CVE-2023-46378": {"epss_score": 0.00092, "epss_percentile": 0.26419}, "CVE-2023-46380": {"epss_score": 0.00102, "epss_percentile": 0.28877}, "CVE-2023-46381": {"epss_score": 0.00142, "epss_percentile": 0.35074}, "CVE-2023-46382": {"epss_score": 0.00075, "epss_percentile": 0.23052}, "CVE-2023-46383": {"epss_score": 0.00188, "epss_percentile": 0.40839}, "CVE-2023-46384": {"epss_score": 0.00131, "epss_percentile": 0.33408}, "CVE-2023-46385": {"epss_score": 0.00135, "epss_percentile": 0.33944}, "CVE-2023-46386": {"epss_score": 0.00131, "epss_percentile": 0.33408}, "CVE-2023-46387": {"epss_score": 0.00401, "epss_percentile": 0.60235}, "CVE-2023-46388": {"epss_score": 0.00131, "epss_percentile": 0.33408}, "CVE-2023-46389": {"epss_score": 0.00524, "epss_percentile": 0.6633}, "CVE-2023-46393": {"epss_score": 0.00026, "epss_percentile": 0.06589}, "CVE-2023-46394": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-46396": {"epss_score": 0.00169, "epss_percentile": 0.38625}, "CVE-2023-46400": {"epss_score": 0.001, "epss_percentile": 0.28483}, "CVE-2023-46401": {"epss_score": 0.00195, "epss_percentile": 0.4169}, "CVE-2023-46402": {"epss_score": 0.00101, "epss_percentile": 0.28713}, "CVE-2023-46404": {"epss_score": 0.39599, "epss_percentile": 0.9717}, "CVE-2023-46407": {"epss_score": 0.00015, "epss_percentile": 0.02597}, "CVE-2023-46408": {"epss_score": 0.00326, "epss_percentile": 0.55059}, "CVE-2023-46409": {"epss_score": 0.00326, "epss_percentile": 0.55059}, "CVE-2023-46410": {"epss_score": 0.00326, "epss_percentile": 0.55059}, "CVE-2023-46411": {"epss_score": 0.00326, "epss_percentile": 0.55059}, "CVE-2023-46412": {"epss_score": 0.00326, "epss_percentile": 0.55059}, "CVE-2023-46413": {"epss_score": 0.00326, "epss_percentile": 0.55059}, "CVE-2023-46414": {"epss_score": 0.05045, "epss_percentile": 0.89434}, "CVE-2023-46415": {"epss_score": 0.05045, "epss_percentile": 0.89434}, "CVE-2023-46416": {"epss_score": 0.05045, "epss_percentile": 0.89434}, "CVE-2023-46417": {"epss_score": 0.04816, "epss_percentile": 0.8917}, "CVE-2023-46418": {"epss_score": 0.05045, "epss_percentile": 0.89434}, "CVE-2023-46419": {"epss_score": 0.05045, "epss_percentile": 0.89434}, "CVE-2023-46420": {"epss_score": 0.05045, "epss_percentile": 0.89434}, "CVE-2023-46421": {"epss_score": 0.05045, "epss_percentile": 0.89434}, "CVE-2023-46422": {"epss_score": 0.05045, "epss_percentile": 0.89434}, "CVE-2023-46423": {"epss_score": 0.05045, "epss_percentile": 0.89434}, "CVE-2023-46424": {"epss_score": 0.05045, "epss_percentile": 0.89434}, "CVE-2023-46426": {"epss_score": 0.02723, "epss_percentile": 0.85521}, "CVE-2023-46427": {"epss_score": 0.01617, "epss_percentile": 0.81363}, "CVE-2023-46428": {"epss_score": 0.0017, "epss_percentile": 0.38725}, "CVE-2023-46435": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-46442": {"epss_score": 0.02104, "epss_percentile": 0.83616}, "CVE-2023-46445": {"epss_score": 0.00661, "epss_percentile": 0.70568}, "CVE-2023-46446": {"epss_score": 0.00571, "epss_percentile": 0.67998}, "CVE-2023-46447": {"epss_score": 0.00058, "epss_percentile": 0.18532}, "CVE-2023-46448": {"epss_score": 0.00237, "epss_percentile": 0.46688}, "CVE-2023-46449": {"epss_score": 0.0025, "epss_percentile": 0.48208}, "CVE-2023-46450": {"epss_score": 0.00119, "epss_percentile": 0.31568}, "CVE-2023-46451": {"epss_score": 0.00119, "epss_percentile": 0.31568}, "CVE-2023-46454": {"epss_score": 0.15671, "epss_percentile": 0.94481}, "CVE-2023-46455": {"epss_score": 0.46103, "epss_percentile": 0.97525}, "CVE-2023-46456": {"epss_score": 0.13948, "epss_percentile": 0.94099}, "CVE-2023-46467": {"epss_score": 0.00121, "epss_percentile": 0.31878}, "CVE-2023-46468": {"epss_score": 0.00258, "epss_percentile": 0.48985}, "CVE-2023-46470": {"epss_score": 0.00121, "epss_percentile": 0.31937}, "CVE-2023-46471": {"epss_score": 0.00276, "epss_percentile": 0.50717}, "CVE-2023-46474": {"epss_score": 0.72688, "epss_percentile": 0.98722}, "CVE-2023-46475": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-46478": {"epss_score": 0.02226, "epss_percentile": 0.84072}, "CVE-2023-46480": {"epss_score": 0.01543, "epss_percentile": 0.80955}, "CVE-2023-46482": {"epss_score": 0.01963, "epss_percentile": 0.83072}, "CVE-2023-46483": {"epss_score": 0.00176, "epss_percentile": 0.39467}, "CVE-2023-46484": {"epss_score": 0.04647, "epss_percentile": 0.88962}, "CVE-2023-46485": {"epss_score": 0.04647, "epss_percentile": 0.88962}, "CVE-2023-46490": {"epss_score": 0.00207, "epss_percentile": 0.43135}, "CVE-2023-46491": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-46492": {"epss_score": 0.00236, "epss_percentile": 0.46444}, "CVE-2023-46493": {"epss_score": 0.00083, "epss_percentile": 0.24621}, "CVE-2023-46494": {"epss_score": 0.0008, "epss_percentile": 0.24017}, "CVE-2023-46495": {"epss_score": 0.0008, "epss_percentile": 0.24017}, "CVE-2023-46496": {"epss_score": 0.00464, "epss_percentile": 0.63722}, "CVE-2023-46497": {"epss_score": 0.00052, "epss_percentile": 0.16671}, "CVE-2023-46498": {"epss_score": 0.01278, "epss_percentile": 0.79124}, "CVE-2023-46499": {"epss_score": 0.0008, "epss_percentile": 0.24017}, "CVE-2023-46501": {"epss_score": 0.10907, "epss_percentile": 0.93152}, "CVE-2023-46502": {"epss_score": 0.00824, "epss_percentile": 0.73941}, "CVE-2023-46503": {"epss_score": 0.00302, "epss_percentile": 0.53096}, "CVE-2023-46504": {"epss_score": 0.00432, "epss_percentile": 0.62127}, "CVE-2023-46505": {"epss_score": 0.00086, "epss_percentile": 0.2536}, "CVE-2023-46509": {"epss_score": 0.00629, "epss_percentile": 0.69686}, "CVE-2023-46510": {"epss_score": 0.00121, "epss_percentile": 0.31988}, "CVE-2023-46518": {"epss_score": 0.00359, "epss_percentile": 0.5759}, "CVE-2023-46520": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-46521": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-46522": {"epss_score": 0.00269, "epss_percentile": 0.50176}, "CVE-2023-46523": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-46525": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-46526": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-46527": {"epss_score": 0.00293, "epss_percentile": 0.52317}, "CVE-2023-46534": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-46535": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-46536": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-46537": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-46538": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-46539": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-46540": {"epss_score": 0.00244, "epss_percentile": 0.47559}, "CVE-2023-46541": {"epss_score": 0.00244, "epss_percentile": 0.47559}, "CVE-2023-46542": {"epss_score": 0.00244, "epss_percentile": 0.47559}, "CVE-2023-46543": {"epss_score": 0.00244, "epss_percentile": 0.47559}, "CVE-2023-46544": {"epss_score": 0.00388, "epss_percentile": 0.59343}, "CVE-2023-46545": {"epss_score": 0.00221, "epss_percentile": 0.44644}, "CVE-2023-46546": {"epss_score": 0.00221, "epss_percentile": 0.44644}, "CVE-2023-46547": {"epss_score": 0.00244, "epss_percentile": 0.47559}, "CVE-2023-46548": {"epss_score": 0.00244, "epss_percentile": 0.47559}, "CVE-2023-46549": {"epss_score": 0.00244, "epss_percentile": 0.47559}, "CVE-2023-46550": {"epss_score": 0.0021, "epss_percentile": 0.43481}, "CVE-2023-46551": {"epss_score": 0.00244, "epss_percentile": 0.47559}, "CVE-2023-46552": {"epss_score": 0.00244, "epss_percentile": 0.47571}, "CVE-2023-46553": {"epss_score": 0.00244, "epss_percentile": 0.47571}, "CVE-2023-46554": {"epss_score": 0.00388, "epss_percentile": 0.59343}, "CVE-2023-46555": {"epss_score": 0.0021, "epss_percentile": 0.43481}, "CVE-2023-46556": {"epss_score": 0.0021, "epss_percentile": 0.43481}, "CVE-2023-46557": {"epss_score": 0.0021, "epss_percentile": 0.43481}, "CVE-2023-46558": {"epss_score": 0.0021, "epss_percentile": 0.43481}, "CVE-2023-46559": {"epss_score": 0.00388, "epss_percentile": 0.59354}, "CVE-2023-46560": {"epss_score": 0.0021, "epss_percentile": 0.43491}, "CVE-2023-46562": {"epss_score": 0.00388, "epss_percentile": 0.59354}, "CVE-2023-46563": {"epss_score": 0.0021, "epss_percentile": 0.43491}, "CVE-2023-46564": {"epss_score": 0.00388, "epss_percentile": 0.59354}, "CVE-2023-46565": {"epss_score": 0.00276, "epss_percentile": 0.50768}, "CVE-2023-46566": {"epss_score": 0.00477, "epss_percentile": 0.64302}, "CVE-2023-46569": {"epss_score": 0.00152, "epss_percentile": 0.36411}, "CVE-2023-46570": {"epss_score": 0.00139, "epss_percentile": 0.34551}, "CVE-2023-46574": {"epss_score": 0.94024, "epss_percentile": 0.99888}, "CVE-2023-46575": {"epss_score": 0.0069, "epss_percentile": 0.71238}, "CVE-2023-46580": {"epss_score": 0.00183, "epss_percentile": 0.40282}, "CVE-2023-46581": {"epss_score": 0.00057, "epss_percentile": 0.1819}, "CVE-2023-46582": {"epss_score": 0.00075, "epss_percentile": 0.23047}, "CVE-2023-46583": {"epss_score": 0.00186, "epss_percentile": 0.40648}, "CVE-2023-46584": {"epss_score": 0.00763, "epss_percentile": 0.72853}, "CVE-2023-46586": {"epss_score": 0.00305, "epss_percentile": 0.53379}, "CVE-2023-46587": {"epss_score": 0.00043, "epss_percentile": 0.13069}, "CVE-2023-46589": {"epss_score": 0.56299, "epss_percentile": 0.98018}, "CVE-2023-46590": {"epss_score": 0.00078, "epss_percentile": 0.23651}, "CVE-2023-46595": {"epss_score": 0.00041, "epss_percentile": 0.12341}, "CVE-2023-46596": {"epss_score": 0.00055, "epss_percentile": 0.1737}, "CVE-2023-46601": {"epss_score": 0.00187, "epss_percentile": 0.40742}, "CVE-2023-46602": {"epss_score": 0.00122, "epss_percentile": 0.32123}, "CVE-2023-46603": {"epss_score": 0.00099, "epss_percentile": 0.28395}, "CVE-2023-46604": {"epss_score": 0.94436, "epss_percentile": 0.99985}, "CVE-2023-46605": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-46606": {"epss_score": 0.00163, "epss_percentile": 0.37844}, "CVE-2023-46607": {"epss_score": 0.00186, "epss_percentile": 0.40628}, "CVE-2023-46608": {"epss_score": 0.00163, "epss_percentile": 0.37844}, "CVE-2023-46609": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-46610": {"epss_score": 0.00189, "epss_percentile": 0.40942}, "CVE-2023-46611": {"epss_score": 0.00097, "epss_percentile": 0.27544}, "CVE-2023-46612": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-46613": {"epss_score": 0.0022, "epss_percentile": 0.44549}, "CVE-2023-46614": {"epss_score": 0.00101, "epss_percentile": 0.28697}, "CVE-2023-46615": {"epss_score": 0.05588, "epss_percentile": 0.90027}, "CVE-2023-46616": {"epss_score": 0.00132, "epss_percentile": 0.33602}, "CVE-2023-46617": {"epss_score": 0.00059, "epss_percentile": 0.18739}, "CVE-2023-46618": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-46619": {"epss_score": 0.00053, "epss_percentile": 0.16989}, "CVE-2023-46620": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-46621": {"epss_score": 0.00235, "epss_percentile": 0.46328}, "CVE-2023-46622": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-46623": {"epss_score": 0.00212, "epss_percentile": 0.4382}, "CVE-2023-46624": {"epss_score": 0.00114, "epss_percentile": 0.30766}, "CVE-2023-46625": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-46626": {"epss_score": 0.00235, "epss_percentile": 0.46328}, "CVE-2023-46627": {"epss_score": 0.00235, "epss_percentile": 0.46328}, "CVE-2023-46628": {"epss_score": 0.00096, "epss_percentile": 0.27333}, "CVE-2023-46629": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-46630": {"epss_score": 0.01018, "epss_percentile": 0.76704}, "CVE-2023-46631": {"epss_score": 0.00186, "epss_percentile": 0.40628}, "CVE-2023-46632": {"epss_score": 0.00161, "epss_percentile": 0.37565}, "CVE-2023-46633": {"epss_score": 0.00142, "epss_percentile": 0.35024}, "CVE-2023-46634": {"epss_score": 0.00064, "epss_percentile": 0.20144}, "CVE-2023-46635": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-46636": {"epss_score": 0.00053, "epss_percentile": 0.16989}, "CVE-2023-46637": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-46638": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-46639": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-46640": {"epss_score": 0.0022, "epss_percentile": 0.44549}, "CVE-2023-46641": {"epss_score": 0.0019, "epss_percentile": 0.41118}, "CVE-2023-46642": {"epss_score": 0.00164, "epss_percentile": 0.37901}, "CVE-2023-46643": {"epss_score": 0.00235, "epss_percentile": 0.46328}, "CVE-2023-46644": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-46645": {"epss_score": 0.00531, "epss_percentile": 0.66662}, "CVE-2023-46646": {"epss_score": 0.00286, "epss_percentile": 0.5169}, "CVE-2023-46647": {"epss_score": 0.005, "epss_percentile": 0.65325}, "CVE-2023-46648": {"epss_score": 0.01027, "epss_percentile": 0.76806}, "CVE-2023-46649": {"epss_score": 0.00147, "epss_percentile": 0.35749}, "CVE-2023-46650": {"epss_score": 0.03536, "epss_percentile": 0.87311}, "CVE-2023-46651": {"epss_score": 0.00046, "epss_percentile": 0.14458}, "CVE-2023-46652": {"epss_score": 0.00052, "epss_percentile": 0.16396}, "CVE-2023-46653": {"epss_score": 0.00021, "epss_percentile": 0.04929}, "CVE-2023-46654": {"epss_score": 0.00089, "epss_percentile": 0.25904}, "CVE-2023-46655": {"epss_score": 0.00205, "epss_percentile": 0.42709}, "CVE-2023-46656": {"epss_score": 0.0008, "epss_percentile": 0.24123}, "CVE-2023-46657": {"epss_score": 0.0008, "epss_percentile": 0.24123}, "CVE-2023-46658": {"epss_score": 0.0008, "epss_percentile": 0.24123}, "CVE-2023-46659": {"epss_score": 0.00781, "epss_percentile": 0.73178}, "CVE-2023-46660": {"epss_score": 0.0008, "epss_percentile": 0.24123}, "CVE-2023-46661": {"epss_score": 0.00082, "epss_percentile": 0.24445}, "CVE-2023-46662": {"epss_score": 0.00143, "epss_percentile": 0.35177}, "CVE-2023-46663": {"epss_score": 0.00017, "epss_percentile": 0.03209}, "CVE-2023-46664": {"epss_score": 0.00019, "epss_percentile": 0.04189}, "CVE-2023-46665": {"epss_score": 0.00016, "epss_percentile": 0.0276}, "CVE-2023-46666": {"epss_score": 0.00089, "epss_percentile": 0.25911}, "CVE-2023-46667": {"epss_score": 0.00218, "epss_percentile": 0.4443}, "CVE-2023-46668": {"epss_score": 0.00403, "epss_percentile": 0.60373}, "CVE-2023-46669": {"epss_score": 0.0002, "epss_percentile": 0.04639}, "CVE-2023-46671": {"epss_score": 0.00221, "epss_percentile": 0.44651}, "CVE-2023-46672": {"epss_score": 0.00147, "epss_percentile": 0.35692}, "CVE-2023-46673": {"epss_score": 0.00811, "epss_percentile": 0.73738}, "CVE-2023-46674": {"epss_score": 0.00064, "epss_percentile": 0.20359}, "CVE-2023-46675": {"epss_score": 0.00165, "epss_percentile": 0.38029}, "CVE-2023-46677": {"epss_score": 0.0015, "epss_percentile": 0.36119}, "CVE-2023-46679": {"epss_score": 0.0015, "epss_percentile": 0.36119}, "CVE-2023-46681": {"epss_score": 0.00092, "epss_percentile": 0.26497}, "CVE-2023-46683": {"epss_score": 0.00781, "epss_percentile": 0.73182}, "CVE-2023-46685": {"epss_score": 0.00834, "epss_percentile": 0.74101}, "CVE-2023-46686": {"epss_score": 0.00083, "epss_percentile": 0.24618}, "CVE-2023-46687": {"epss_score": 0.00272, "epss_percentile": 0.50365}, "CVE-2023-46688": {"epss_score": 0.00323, "epss_percentile": 0.54897}, "CVE-2023-46689": {"epss_score": 0.00184, "epss_percentile": 0.40411}, "CVE-2023-46690": {"epss_score": 0.01042, "epss_percentile": 0.76976}, "CVE-2023-46691": {"epss_score": 0.0008, "epss_percentile": 0.24134}, "CVE-2023-46693": {"epss_score": 0.00183, "epss_percentile": 0.40281}, "CVE-2023-46694": {"epss_score": 0.09077, "epss_percentile": 0.92389}, "CVE-2023-46695": {"epss_score": 0.03582, "epss_percentile": 0.87386}, "CVE-2023-46699": {"epss_score": 0.00115, "epss_percentile": 0.30947}, "CVE-2023-46700": {"epss_score": 0.00207, "epss_percentile": 0.43187}, "CVE-2023-46701": {"epss_score": 0.00192, "epss_percentile": 0.41362}, "CVE-2023-46705": {"epss_score": 0.0004, "epss_percentile": 0.11976}, "CVE-2023-46706": {"epss_score": 0.00082, "epss_percentile": 0.24399}, "CVE-2023-46708": {"epss_score": 0.00066, "epss_percentile": 0.20745}, "CVE-2023-46711": {"epss_score": 0.00085, "epss_percentile": 0.25114}, "CVE-2023-46712": {"epss_score": 0.0018, "epss_percentile": 0.39868}, "CVE-2023-46713": {"epss_score": 0.00149, "epss_percentile": 0.35961}, "CVE-2023-46714": {"epss_score": 0.0018, "epss_percentile": 0.39871}, "CVE-2023-46715": {"epss_score": 0.0007, "epss_percentile": 0.21837}, "CVE-2023-46717": {"epss_score": 0.00175, "epss_percentile": 0.39371}, "CVE-2023-46718": {"epss_score": 0.00019, "epss_percentile": 0.04194}, "CVE-2023-46720": {"epss_score": 0.00066, "epss_percentile": 0.20768}, "CVE-2023-46722": {"epss_score": 0.00014, "epss_percentile": 0.01915}, "CVE-2023-46723": {"epss_score": 0.00201, "epss_percentile": 0.42282}, "CVE-2023-46724": {"epss_score": 0.00369, "epss_percentile": 0.58272}, "CVE-2023-46725": {"epss_score": 0.00144, "epss_percentile": 0.35322}, "CVE-2023-46726": {"epss_score": 0.00126, "epss_percentile": 0.3275}, "CVE-2023-46727": {"epss_score": 0.23296, "epss_percentile": 0.9576}, "CVE-2023-46728": {"epss_score": 0.01876, "epss_percentile": 0.82659}, "CVE-2023-46729": {"epss_score": 0.0109, "epss_percentile": 0.77453}, "CVE-2023-46730": {"epss_score": 0.0019, "epss_percentile": 0.41101}, "CVE-2023-46731": {"epss_score": 0.57465, "epss_percentile": 0.98064}, "CVE-2023-46732": {"epss_score": 0.43476, "epss_percentile": 0.97388}, "CVE-2023-46733": {"epss_score": 0.01058, "epss_percentile": 0.77146}, "CVE-2023-46734": {"epss_score": 0.01116, "epss_percentile": 0.77717}, "CVE-2023-46735": {"epss_score": 0.02516, "epss_percentile": 0.84988}, "CVE-2023-46736": {"epss_score": 0.00095, "epss_percentile": 0.2712}, "CVE-2023-46737": {"epss_score": 0.0031, "epss_percentile": 0.53759}, "CVE-2023-46738": {"epss_score": 0.00053, "epss_percentile": 0.17006}, "CVE-2023-46739": {"epss_score": 0.00062, "epss_percentile": 0.19778}, "CVE-2023-46740": {"epss_score": 0.00072, "epss_percentile": 0.22382}, "CVE-2023-46741": {"epss_score": 0.00041, "epss_percentile": 0.12288}, "CVE-2023-46742": {"epss_score": 0.00046, "epss_percentile": 0.14079}, "CVE-2023-46743": {"epss_score": 0.00241, "epss_percentile": 0.47265}, "CVE-2023-46744": {"epss_score": 0.00155, "epss_percentile": 0.3685}, "CVE-2023-46745": {"epss_score": 7e-05, "epss_percentile": 0.00354}, "CVE-2023-46746": {"epss_score": 0.00063, "epss_percentile": 0.19943}, "CVE-2023-46747": {"epss_score": 0.94436, "epss_percentile": 0.99984}, "CVE-2023-46748": {"epss_score": 0.04348, "epss_percentile": 0.8858}, "CVE-2023-46749": {"epss_score": 0.00194, "epss_percentile": 0.4158}, "CVE-2023-46750": {"epss_score": 0.00201, "epss_percentile": 0.42358}, "CVE-2023-46751": {"epss_score": 0.00102, "epss_percentile": 0.28792}, "CVE-2023-46752": {"epss_score": 0.00107, "epss_percentile": 0.29743}, "CVE-2023-46753": {"epss_score": 0.00095, "epss_percentile": 0.27176}, "CVE-2023-46754": {"epss_score": 0.00033, "epss_percentile": 0.09127}, "CVE-2023-46755": {"epss_score": 0.00058, "epss_percentile": 0.18474}, "CVE-2023-46756": {"epss_score": 0.00086, "epss_percentile": 0.25436}, "CVE-2023-46757": {"epss_score": 0.0015, "epss_percentile": 0.36097}, "CVE-2023-46758": {"epss_score": 0.00114, "epss_percentile": 0.30867}, "CVE-2023-46759": {"epss_score": 0.00128, "epss_percentile": 0.33053}, "CVE-2023-46760": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-46761": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-46762": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-46763": {"epss_score": 0.00107, "epss_percentile": 0.29629}, "CVE-2023-46764": {"epss_score": 0.00079, "epss_percentile": 0.23818}, "CVE-2023-46765": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-46766": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-46767": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-46768": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-46769": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-46770": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-46771": {"epss_score": 0.0015, "epss_percentile": 0.36052}, "CVE-2023-46772": {"epss_score": 0.0016, "epss_percentile": 0.37506}, "CVE-2023-46773": {"epss_score": 0.00116, "epss_percentile": 0.31102}, "CVE-2023-46774": {"epss_score": 0.00134, "epss_percentile": 0.3378}, "CVE-2023-46775": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-46776": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-46777": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-46778": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-46779": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-46780": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-46781": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-46782": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-46783": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-46784": {"epss_score": 0.00627, "epss_percentile": 0.69641}, "CVE-2023-46785": {"epss_score": 0.0015, "epss_percentile": 0.36119}, "CVE-2023-46787": {"epss_score": 0.00145, "epss_percentile": 0.35519}, "CVE-2023-46788": {"epss_score": 0.0015, "epss_percentile": 0.36119}, "CVE-2023-46789": {"epss_score": 0.00145, "epss_percentile": 0.35519}, "CVE-2023-46793": {"epss_score": 0.0015, "epss_percentile": 0.36119}, "CVE-2023-46800": {"epss_score": 0.0015, "epss_percentile": 0.36119}, "CVE-2023-46801": {"epss_score": 0.03947, "epss_percentile": 0.87997}, "CVE-2023-46802": {"epss_score": 0.00021, "epss_percentile": 0.04765}, "CVE-2023-46803": {"epss_score": 0.00633, "epss_percentile": 0.69767}, "CVE-2023-46804": {"epss_score": 0.00633, "epss_percentile": 0.69767}, "CVE-2023-46805": {"epss_score": 0.94367, "epss_percentile": 0.99961}, "CVE-2023-46806": {"epss_score": 0.00973, "epss_percentile": 0.76163}, "CVE-2023-46807": {"epss_score": 0.00973, "epss_percentile": 0.76163}, "CVE-2023-46808": {"epss_score": 0.06279, "epss_percentile": 0.90634}, "CVE-2023-46809": {"epss_score": 0.01065, "epss_percentile": 0.77214}, "CVE-2023-46810": {"epss_score": 0.00119, "epss_percentile": 0.31652}, "CVE-2023-46813": {"epss_score": 0.00274, "epss_percentile": 0.50553}, "CVE-2023-46814": {"epss_score": 0.00107, "epss_percentile": 0.29717}, "CVE-2023-46815": {"epss_score": 0.00239, "epss_percentile": 0.46858}, "CVE-2023-46816": {"epss_score": 0.00224, "epss_percentile": 0.44968}, "CVE-2023-46817": {"epss_score": 0.00768, "epss_percentile": 0.72973}, "CVE-2023-46818": {"epss_score": 0.90623, "epss_percentile": 0.99592}, "CVE-2023-46819": {"epss_score": 0.00299, "epss_percentile": 0.52897}, "CVE-2023-46820": {"epss_score": 0.00317, "epss_percentile": 0.54341}, "CVE-2023-46821": {"epss_score": 0.00217, "epss_percentile": 0.4425}, "CVE-2023-46822": {"epss_score": 0.00127, "epss_percentile": 0.32894}, "CVE-2023-46823": {"epss_score": 0.01508, "epss_percentile": 0.80759}, "CVE-2023-46824": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-46835": {"epss_score": 0.00087, "epss_percentile": 0.25535}, "CVE-2023-46836": {"epss_score": 0.00014, "epss_percentile": 0.01757}, "CVE-2023-46837": {"epss_score": 0.00051, "epss_percentile": 0.16329}, "CVE-2023-46838": {"epss_score": 0.00128, "epss_percentile": 0.3306}, "CVE-2023-46839": {"epss_score": 0.00075, "epss_percentile": 0.22911}, "CVE-2023-46840": {"epss_score": 0.00032, "epss_percentile": 0.08865}, "CVE-2023-46841": {"epss_score": 0.00054, "epss_percentile": 0.17154}, "CVE-2023-46842": {"epss_score": 0.01644, "epss_percentile": 0.81521}, "CVE-2023-46845": {"epss_score": 0.01183, "epss_percentile": 0.78327}, "CVE-2023-46846": {"epss_score": 0.09618, "epss_percentile": 0.92626}, "CVE-2023-46847": {"epss_score": 0.44643, "epss_percentile": 0.97447}, "CVE-2023-46848": {"epss_score": 0.10385, "epss_percentile": 0.92968}, "CVE-2023-46849": {"epss_score": 0.00478, "epss_percentile": 0.64392}, "CVE-2023-46850": {"epss_score": 0.03731, "epss_percentile": 0.87644}, "CVE-2023-46851": {"epss_score": 0.00283, "epss_percentile": 0.51379}, "CVE-2023-46852": {"epss_score": 0.00099, "epss_percentile": 0.28359}, "CVE-2023-46853": {"epss_score": 0.00116, "epss_percentile": 0.31169}, "CVE-2023-46854": {"epss_score": 0.00129, "epss_percentile": 0.3322}, "CVE-2023-46857": {"epss_score": 0.00734, "epss_percentile": 0.72237}, "CVE-2023-46858": {"epss_score": 0.00109, "epss_percentile": 0.29907}, "CVE-2023-46862": {"epss_score": 0.00018, "epss_percentile": 0.03612}, "CVE-2023-46863": {"epss_score": 0.00166, "epss_percentile": 0.3818}, "CVE-2023-46864": {"epss_score": 0.00176, "epss_percentile": 0.39468}, "CVE-2023-46865": {"epss_score": 0.68786, "epss_percentile": 0.98563}, "CVE-2023-46866": {"epss_score": 0.00256, "epss_percentile": 0.48815}, "CVE-2023-46867": {"epss_score": 0.00064, "epss_percentile": 0.20288}, "CVE-2023-46870": {"epss_score": 0.00211, "epss_percentile": 0.4362}, "CVE-2023-46871": {"epss_score": 0.00047, "epss_percentile": 0.14697}, "CVE-2023-46886": {"epss_score": 0.00586, "epss_percentile": 0.68458}, "CVE-2023-46887": {"epss_score": 0.00169, "epss_percentile": 0.3855}, "CVE-2023-46889": {"epss_score": 0.00043, "epss_percentile": 0.13174}, "CVE-2023-46892": {"epss_score": 0.00042, "epss_percentile": 0.12596}, "CVE-2023-46894": {"epss_score": 0.0008, "epss_percentile": 0.24158}, "CVE-2023-46906": {"epss_score": 0.00096, "epss_percentile": 0.27278}, "CVE-2023-46911": {"epss_score": 0.00181, "epss_percentile": 0.40112}, "CVE-2023-46914": {"epss_score": 0.01376, "epss_percentile": 0.79836}, "CVE-2023-46916": {"epss_score": 0.00066, "epss_percentile": 0.20871}, "CVE-2023-46918": {"epss_score": 0.001, "epss_percentile": 0.28489}, "CVE-2023-46919": {"epss_score": 0.00025, "epss_percentile": 0.06264}, "CVE-2023-46925": {"epss_score": 0.00282, "epss_percentile": 0.51253}, "CVE-2023-46927": {"epss_score": 0.00079, "epss_percentile": 0.23954}, "CVE-2023-46928": {"epss_score": 0.00079, "epss_percentile": 0.23954}, "CVE-2023-46929": {"epss_score": 0.00263, "epss_percentile": 0.49533}, "CVE-2023-46930": {"epss_score": 0.00083, "epss_percentile": 0.24765}, "CVE-2023-46931": {"epss_score": 0.00045, "epss_percentile": 0.13787}, "CVE-2023-46932": {"epss_score": 0.0013, "epss_percentile": 0.33317}, "CVE-2023-46935": {"epss_score": 0.00169, "epss_percentile": 0.38625}, "CVE-2023-46942": {"epss_score": 0.00096, "epss_percentile": 0.27446}, "CVE-2023-46943": {"epss_score": 0.00086, "epss_percentile": 0.25244}, "CVE-2023-46944": {"epss_score": 0.032, "epss_percentile": 0.86622}, "CVE-2023-46947": {"epss_score": 0.01861, "epss_percentile": 0.82592}, "CVE-2023-46948": {"epss_score": 0.00198, "epss_percentile": 0.42014}, "CVE-2023-46950": {"epss_score": 0.00266, "epss_percentile": 0.49884}, "CVE-2023-46951": {"epss_score": 0.00266, "epss_percentile": 0.49884}, "CVE-2023-46952": {"epss_score": 0.00135, "epss_percentile": 0.34035}, "CVE-2023-46953": {"epss_score": 0.00804, "epss_percentile": 0.73626}, "CVE-2023-46954": {"epss_score": 0.03919, "epss_percentile": 0.8795}, "CVE-2023-46956": {"epss_score": 0.02079, "epss_percentile": 0.83522}, "CVE-2023-46958": {"epss_score": 0.02198, "epss_percentile": 0.83964}, "CVE-2023-46960": {"epss_score": 0.01532, "epss_percentile": 0.80892}, "CVE-2023-46963": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2023-46964": {"epss_score": 0.00145, "epss_percentile": 0.35484}, "CVE-2023-46967": {"epss_score": 0.00108, "epss_percentile": 0.29774}, "CVE-2023-46974": {"epss_score": 0.00811, "epss_percentile": 0.73724}, "CVE-2023-46976": {"epss_score": 0.02985, "epss_percentile": 0.86129}, "CVE-2023-46977": {"epss_score": 0.11134, "epss_percentile": 0.93233}, "CVE-2023-46978": {"epss_score": 0.00144, "epss_percentile": 0.35281}, "CVE-2023-46979": {"epss_score": 0.03236, "epss_percentile": 0.86704}, "CVE-2023-46980": {"epss_score": 0.0749, "epss_percentile": 0.915}, "CVE-2023-46981": {"epss_score": 0.01017, "epss_percentile": 0.76692}, "CVE-2023-46987": {"epss_score": 0.05749, "epss_percentile": 0.90177}, "CVE-2023-46988": {"epss_score": 0.00116, "epss_percentile": 0.31047}, "CVE-2023-46989": {"epss_score": 0.00027, "epss_percentile": 0.06837}, "CVE-2023-46990": {"epss_score": 0.01323, "epss_percentile": 0.7946}, "CVE-2023-46992": {"epss_score": 0.00188, "epss_percentile": 0.40897}, "CVE-2023-46993": {"epss_score": 0.02985, "epss_percentile": 0.86129}, "CVE-2023-46998": {"epss_score": 0.3892, "epss_percentile": 0.97127}, "CVE-2023-47003": {"epss_score": 0.00095, "epss_percentile": 0.2721}, "CVE-2023-47004": {"epss_score": 0.00557, "epss_percentile": 0.67558}, "CVE-2023-47014": {"epss_score": 0.00107, "epss_percentile": 0.29677}, "CVE-2023-47016": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2023-47020": {"epss_score": 0.00081, "epss_percentile": 0.24218}, "CVE-2023-47022": {"epss_score": 0.00121, "epss_percentile": 0.31838}, "CVE-2023-47024": {"epss_score": 0.00167, "epss_percentile": 0.38318}, "CVE-2023-47025": {"epss_score": 0.00048, "epss_percentile": 0.1512}, "CVE-2023-47029": {"epss_score": 0.00368, "epss_percentile": 0.58207}, "CVE-2023-47030": {"epss_score": 0.00334, "epss_percentile": 0.55743}, "CVE-2023-47031": {"epss_score": 0.00145, "epss_percentile": 0.355}, "CVE-2023-47032": {"epss_score": 0.00334, "epss_percentile": 0.55743}, "CVE-2023-47033": {"epss_score": 0.00191, "epss_percentile": 0.41263}, "CVE-2023-47034": {"epss_score": 0.00135, "epss_percentile": 0.34048}, "CVE-2023-47035": {"epss_score": 0.00087, "epss_percentile": 0.25531}, "CVE-2023-47037": {"epss_score": 0.00084, "epss_percentile": 0.24836}, "CVE-2023-47038": {"epss_score": 0.00108, "epss_percentile": 0.29758}, "CVE-2023-47039": {"epss_score": 0.00067, "epss_percentile": 0.21185}, "CVE-2023-47040": {"epss_score": 0.00113, "epss_percentile": 0.30594}, "CVE-2023-47041": {"epss_score": 0.00049, "epss_percentile": 0.15578}, "CVE-2023-47042": {"epss_score": 0.00061, "epss_percentile": 0.19266}, "CVE-2023-47043": {"epss_score": 0.00113, "epss_percentile": 0.30594}, "CVE-2023-47044": {"epss_score": 0.00016, "epss_percentile": 0.02702}, "CVE-2023-47046": {"epss_score": 0.00049, "epss_percentile": 0.15616}, "CVE-2023-47047": {"epss_score": 0.00051, "epss_percentile": 0.1604}, "CVE-2023-47048": {"epss_score": 0.00109, "epss_percentile": 0.29963}, "CVE-2023-47049": {"epss_score": 0.00066, "epss_percentile": 0.20896}, "CVE-2023-47050": {"epss_score": 0.00066, "epss_percentile": 0.20896}, "CVE-2023-47051": {"epss_score": 0.00062, "epss_percentile": 0.19755}, "CVE-2023-47052": {"epss_score": 0.00026, "epss_percentile": 0.06575}, "CVE-2023-47053": {"epss_score": 0.00028, "epss_percentile": 0.07227}, "CVE-2023-47054": {"epss_score": 0.00016, "epss_percentile": 0.02702}, "CVE-2023-47055": {"epss_score": 0.00115, "epss_percentile": 0.31008}, "CVE-2023-47056": {"epss_score": 0.00061, "epss_percentile": 0.19266}, "CVE-2023-47057": {"epss_score": 0.00049, "epss_percentile": 0.15578}, "CVE-2023-47058": {"epss_score": 0.00113, "epss_percentile": 0.30594}, "CVE-2023-47059": {"epss_score": 0.00113, "epss_percentile": 0.30594}, "CVE-2023-47060": {"epss_score": 0.0003, "epss_percentile": 0.08027}, "CVE-2023-47061": {"epss_score": 0.00022, "epss_percentile": 0.05246}, "CVE-2023-47062": {"epss_score": 0.00021, "epss_percentile": 0.04707}, "CVE-2023-47063": {"epss_score": 0.00138, "epss_percentile": 0.34419}, "CVE-2023-47064": {"epss_score": 0.00437, "epss_percentile": 0.62517}, "CVE-2023-47065": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-47066": {"epss_score": 0.00181, "epss_percentile": 0.40014}, "CVE-2023-47067": {"epss_score": 0.00166, "epss_percentile": 0.38187}, "CVE-2023-47068": {"epss_score": 0.00166, "epss_percentile": 0.38187}, "CVE-2023-47069": {"epss_score": 0.00166, "epss_percentile": 0.38187}, "CVE-2023-47070": {"epss_score": 0.00127, "epss_percentile": 0.3282}, "CVE-2023-47071": {"epss_score": 0.00044, "epss_percentile": 0.13612}, "CVE-2023-47072": {"epss_score": 0.0004, "epss_percentile": 0.1199}, "CVE-2023-47073": {"epss_score": 0.00127, "epss_percentile": 0.3282}, "CVE-2023-47074": {"epss_score": 0.00157, "epss_percentile": 0.37091}, "CVE-2023-47075": {"epss_score": 0.00116, "epss_percentile": 0.31066}, "CVE-2023-47076": {"epss_score": 0.00086, "epss_percentile": 0.25332}, "CVE-2023-47077": {"epss_score": 0.00021, "epss_percentile": 0.04847}, "CVE-2023-47078": {"epss_score": 0.00022, "epss_percentile": 0.05015}, "CVE-2023-47079": {"epss_score": 0.00022, "epss_percentile": 0.05015}, "CVE-2023-47080": {"epss_score": 0.00012, "epss_percentile": 0.0129}, "CVE-2023-47081": {"epss_score": 0.00012, "epss_percentile": 0.0129}, "CVE-2023-47090": {"epss_score": 0.00212, "epss_percentile": 0.43818}, "CVE-2023-47091": {"epss_score": 0.00179, "epss_percentile": 0.39849}, "CVE-2023-47093": {"epss_score": 0.00068, "epss_percentile": 0.21338}, "CVE-2023-47094": {"epss_score": 0.00103, "epss_percentile": 0.28927}, "CVE-2023-47095": {"epss_score": 0.00103, "epss_percentile": 0.28927}, "CVE-2023-47096": {"epss_score": 0.00103, "epss_percentile": 0.28927}, "CVE-2023-47097": {"epss_score": 0.00054, "epss_percentile": 0.1733}, "CVE-2023-47098": {"epss_score": 0.00077, "epss_percentile": 0.23302}, "CVE-2023-47099": {"epss_score": 0.00103, "epss_percentile": 0.28927}, "CVE-2023-47101": {"epss_score": 0.00065, "epss_percentile": 0.20607}, "CVE-2023-47102": {"epss_score": 0.00311, "epss_percentile": 0.53811}, "CVE-2023-47104": {"epss_score": 0.00096, "epss_percentile": 0.27419}, "CVE-2023-47105": {"epss_score": 0.19961, "epss_percentile": 0.95267}, "CVE-2023-47106": {"epss_score": 0.00128, "epss_percentile": 0.33065}, "CVE-2023-47107": {"epss_score": 0.00283, "epss_percentile": 0.51365}, "CVE-2023-47108": {"epss_score": 0.04299, "epss_percentile": 0.88512}, "CVE-2023-47109": {"epss_score": 0.00239, "epss_percentile": 0.46878}, "CVE-2023-47110": {"epss_score": 0.00133, "epss_percentile": 0.33727}, "CVE-2023-47111": {"epss_score": 0.00173, "epss_percentile": 0.39112}, "CVE-2023-47112": {"epss_score": 0.00213, "epss_percentile": 0.43911}, "CVE-2023-47113": {"epss_score": 0.00108, "epss_percentile": 0.29854}, "CVE-2023-47114": {"epss_score": 0.0019, "epss_percentile": 0.41086}, "CVE-2023-47115": {"epss_score": 0.02396, "epss_percentile": 0.84618}, "CVE-2023-47116": {"epss_score": 0.00208, "epss_percentile": 0.43295}, "CVE-2023-47117": {"epss_score": 0.65766, "epss_percentile": 0.98438}, "CVE-2023-47118": {"epss_score": 0.00387, "epss_percentile": 0.59287}, "CVE-2023-47119": {"epss_score": 0.1184, "epss_percentile": 0.93491}, "CVE-2023-47120": {"epss_score": 0.003, "epss_percentile": 0.52945}, "CVE-2023-47121": {"epss_score": 0.00398, "epss_percentile": 0.60052}, "CVE-2023-47122": {"epss_score": 0.00091, "epss_percentile": 0.26172}, "CVE-2023-47123": {"epss_score": 0.00723, "epss_percentile": 0.72004}, "CVE-2023-47124": {"epss_score": 0.00227, "epss_percentile": 0.45378}, "CVE-2023-47125": {"epss_score": 0.00341, "epss_percentile": 0.56312}, "CVE-2023-47126": {"epss_score": 0.00213, "epss_percentile": 0.43919}, "CVE-2023-47127": {"epss_score": 0.00181, "epss_percentile": 0.40118}, "CVE-2023-47128": {"epss_score": 0.00228, "epss_percentile": 0.45464}, "CVE-2023-47129": {"epss_score": 0.04856, "epss_percentile": 0.89219}, "CVE-2023-47130": {"epss_score": 0.03255, "epss_percentile": 0.86759}, "CVE-2023-47131": {"epss_score": 0.00218, "epss_percentile": 0.4434}, "CVE-2023-47132": {"epss_score": 0.00297, "epss_percentile": 0.52698}, "CVE-2023-47140": {"epss_score": 0.00053, "epss_percentile": 0.16847}, "CVE-2023-47141": {"epss_score": 0.0004, "epss_percentile": 0.12035}, "CVE-2023-47142": {"epss_score": 0.0004, "epss_percentile": 0.12082}, "CVE-2023-47143": {"epss_score": 0.00103, "epss_percentile": 0.2908}, "CVE-2023-47144": {"epss_score": 0.00151, "epss_percentile": 0.36366}, "CVE-2023-47145": {"epss_score": 0.00015, "epss_percentile": 0.02488}, "CVE-2023-47146": {"epss_score": 0.00046, "epss_percentile": 0.14168}, "CVE-2023-47147": {"epss_score": 0.00053, "epss_percentile": 0.16882}, "CVE-2023-47148": {"epss_score": 0.00056, "epss_percentile": 0.17819}, "CVE-2023-47150": {"epss_score": 0.00089, "epss_percentile": 0.25794}, "CVE-2023-47152": {"epss_score": 0.00068, "epss_percentile": 0.21365}, "CVE-2023-47158": {"epss_score": 0.0004, "epss_percentile": 0.12035}, "CVE-2023-47159": {"epss_score": 0.00096, "epss_percentile": 0.27266}, "CVE-2023-47160": {"epss_score": 0.00358, "epss_percentile": 0.57506}, "CVE-2023-47161": {"epss_score": 0.00058, "epss_percentile": 0.18376}, "CVE-2023-47162": {"epss_score": 0.00151, "epss_percentile": 0.36366}, "CVE-2023-47163": {"epss_score": 0.00076, "epss_percentile": 0.2316}, "CVE-2023-47164": {"epss_score": 0.00266, "epss_percentile": 0.49898}, "CVE-2023-47165": {"epss_score": 0.00044, "epss_percentile": 0.1338}, "CVE-2023-47166": {"epss_score": 0.00173, "epss_percentile": 0.39068}, "CVE-2023-47167": {"epss_score": 0.00781, "epss_percentile": 0.73182}, "CVE-2023-47168": {"epss_score": 0.00191, "epss_percentile": 0.41191}, "CVE-2023-47169": {"epss_score": 0.0002, "epss_percentile": 0.04547}, "CVE-2023-47171": {"epss_score": 0.00309, "epss_percentile": 0.53677}, "CVE-2023-47172": {"epss_score": 0.00056, "epss_percentile": 0.17762}, "CVE-2023-47174": {"epss_score": 0.03232, "epss_percentile": 0.86699}, "CVE-2023-47175": {"epss_score": 0.0011, "epss_percentile": 0.30147}, "CVE-2023-47177": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-47178": {"epss_score": 0.00443, "epss_percentile": 0.62804}, "CVE-2023-47179": {"epss_score": 0.18736, "epss_percentile": 0.95061}, "CVE-2023-47180": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-47181": {"epss_score": 0.00164, "epss_percentile": 0.37901}, "CVE-2023-47182": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-47183": {"epss_score": 0.00304, "epss_percentile": 0.53305}, "CVE-2023-47184": {"epss_score": 0.00095, "epss_percentile": 0.27193}, "CVE-2023-47185": {"epss_score": 0.00137, "epss_percentile": 0.34228}, "CVE-2023-47186": {"epss_score": 0.00169, "epss_percentile": 0.38628}, "CVE-2023-47187": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-47188": {"epss_score": 0.00304, "epss_percentile": 0.53305}, "CVE-2023-47189": {"epss_score": 0.00996, "epss_percentile": 0.76448}, "CVE-2023-47190": {"epss_score": 0.0022, "epss_percentile": 0.44549}, "CVE-2023-47191": {"epss_score": 0.00168, "epss_percentile": 0.38497}, "CVE-2023-47192": {"epss_score": 0.0008, "epss_percentile": 0.24082}, "CVE-2023-47193": {"epss_score": 0.00038, "epss_percentile": 0.11422}, "CVE-2023-47194": {"epss_score": 0.00038, "epss_percentile": 0.11422}, "CVE-2023-47195": {"epss_score": 0.00038, "epss_percentile": 0.11422}, "CVE-2023-47196": {"epss_score": 0.00038, "epss_percentile": 0.11422}, "CVE-2023-47197": {"epss_score": 0.00038, "epss_percentile": 0.11422}, "CVE-2023-47198": {"epss_score": 0.00038, "epss_percentile": 0.11422}, "CVE-2023-47199": {"epss_score": 0.00038, "epss_percentile": 0.11422}, "CVE-2023-47200": {"epss_score": 0.00038, "epss_percentile": 0.11422}, "CVE-2023-47201": {"epss_score": 0.00047, "epss_percentile": 0.1483}, "CVE-2023-47202": {"epss_score": 0.00068, "epss_percentile": 0.21199}, "CVE-2023-47204": {"epss_score": 0.00142, "epss_percentile": 0.35005}, "CVE-2023-47207": {"epss_score": 0.0277, "epss_percentile": 0.85617}, "CVE-2023-47209": {"epss_score": 0.00781, "epss_percentile": 0.73182}, "CVE-2023-47210": {"epss_score": 0.00012, "epss_percentile": 0.01267}, "CVE-2023-47211": {"epss_score": 0.84058, "epss_percentile": 0.99272}, "CVE-2023-47212": {"epss_score": 0.00273, "epss_percentile": 0.50459}, "CVE-2023-47213": {"epss_score": 0.01379, "epss_percentile": 0.79856}, "CVE-2023-47215": {"epss_score": 0.01289, "epss_percentile": 0.79208}, "CVE-2023-47216": {"epss_score": 0.00049, "epss_percentile": 0.1538}, "CVE-2023-47217": {"epss_score": 0.00029, "epss_percentile": 0.07627}, "CVE-2023-47218": {"epss_score": 0.93293, "epss_percentile": 0.99793}, "CVE-2023-47219": {"epss_score": 0.00336, "epss_percentile": 0.55942}, "CVE-2023-47220": {"epss_score": 0.00135, "epss_percentile": 0.34051}, "CVE-2023-47221": {"epss_score": 0.00046, "epss_percentile": 0.14417}, "CVE-2023-47222": {"epss_score": 0.0036, "epss_percentile": 0.57652}, "CVE-2023-47223": {"epss_score": 0.00164, "epss_percentile": 0.37901}, "CVE-2023-47224": {"epss_score": 0.00224, "epss_percentile": 0.44981}, "CVE-2023-47225": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-47226": {"epss_score": 0.00164, "epss_percentile": 0.37901}, "CVE-2023-47227": {"epss_score": 0.00164, "epss_percentile": 0.37901}, "CVE-2023-47228": {"epss_score": 0.00164, "epss_percentile": 0.37901}, "CVE-2023-47229": {"epss_score": 0.0022, "epss_percentile": 0.44549}, "CVE-2023-47230": {"epss_score": 0.00053, "epss_percentile": 0.16989}, "CVE-2023-47231": {"epss_score": 0.0022, "epss_percentile": 0.44549}, "CVE-2023-47232": {"epss_score": 0.00078, "epss_percentile": 0.23782}, "CVE-2023-47233": {"epss_score": 0.0002, "epss_percentile": 0.04589}, "CVE-2023-47234": {"epss_score": 0.00144, "epss_percentile": 0.35313}, "CVE-2023-47235": {"epss_score": 0.00106, "epss_percentile": 0.29494}, "CVE-2023-47236": {"epss_score": 0.0014, "epss_percentile": 0.34695}, "CVE-2023-47237": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-47238": {"epss_score": 0.00105, "epss_percentile": 0.29392}, "CVE-2023-47239": {"epss_score": 0.0009, "epss_percentile": 0.26036}, "CVE-2023-47240": {"epss_score": 0.0009, "epss_percentile": 0.26036}, "CVE-2023-47241": {"epss_score": 0.00163, "epss_percentile": 0.37844}, "CVE-2023-47242": {"epss_score": 0.0009, "epss_percentile": 0.26036}, "CVE-2023-47243": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-47244": {"epss_score": 0.00332, "epss_percentile": 0.5555}, "CVE-2023-47245": {"epss_score": 0.00067, "epss_percentile": 0.21076}, "CVE-2023-47246": {"epss_score": 0.9438, "epss_percentile": 0.99965}, "CVE-2023-47247": {"epss_score": 0.00056, "epss_percentile": 0.17677}, "CVE-2023-47248": {"epss_score": 0.8564, "epss_percentile": 0.99342}, "CVE-2023-47249": {"epss_score": 0.00111, "epss_percentile": 0.30384}, "CVE-2023-47250": {"epss_score": 0.00134, "epss_percentile": 0.339}, "CVE-2023-47251": {"epss_score": 0.00726, "epss_percentile": 0.72074}, "CVE-2023-47252": {"epss_score": 0.00133, "epss_percentile": 0.33629}, "CVE-2023-47253": {"epss_score": 0.93893, "epss_percentile": 0.99864}, "CVE-2023-47254": {"epss_score": 0.03197, "epss_percentile": 0.86613}, "CVE-2023-47256": {"epss_score": 0.00052, "epss_percentile": 0.16632}, "CVE-2023-47257": {"epss_score": 0.04963, "epss_percentile": 0.89339}, "CVE-2023-47258": {"epss_score": 0.00415, "epss_percentile": 0.61113}, "CVE-2023-47259": {"epss_score": 0.00415, "epss_percentile": 0.61113}, "CVE-2023-47260": {"epss_score": 0.00345, "epss_percentile": 0.56601}, "CVE-2023-47261": {"epss_score": 0.04092, "epss_percentile": 0.88242}, "CVE-2023-47262": {"epss_score": 0.00092, "epss_percentile": 0.26473}, "CVE-2023-47263": {"epss_score": 0.00148, "epss_percentile": 0.35848}, "CVE-2023-47264": {"epss_score": 0.00146, "epss_percentile": 0.35636}, "CVE-2023-47265": {"epss_score": 0.00252, "epss_percentile": 0.4834}, "CVE-2023-47267": {"epss_score": 0.00189, "epss_percentile": 0.40991}, "CVE-2023-47271": {"epss_score": 0.00152, "epss_percentile": 0.36468}, "CVE-2023-47272": {"epss_score": 0.0065, "epss_percentile": 0.70271}, "CVE-2023-47279": {"epss_score": 0.0022, "epss_percentile": 0.44566}, "CVE-2023-47282": {"epss_score": 0.00016, "epss_percentile": 0.02702}, "CVE-2023-47283": {"epss_score": 0.00331, "epss_percentile": 0.55502}, "CVE-2023-47294": {"epss_score": 0.00052, "epss_percentile": 0.16552}, "CVE-2023-47295": {"epss_score": 0.0007, "epss_percentile": 0.21982}, "CVE-2023-47297": {"epss_score": 0.00075, "epss_percentile": 0.23043}, "CVE-2023-47298": {"epss_score": 0.00037, "epss_percentile": 0.10725}, "CVE-2023-47304": {"epss_score": 0.00019, "epss_percentile": 0.04059}, "CVE-2023-47307": {"epss_score": 0.00198, "epss_percentile": 0.42043}, "CVE-2023-47308": {"epss_score": 0.00061, "epss_percentile": 0.19504}, "CVE-2023-47309": {"epss_score": 0.00088, "epss_percentile": 0.25779}, "CVE-2023-47310": {"epss_score": 0.00056, "epss_percentile": 0.17688}, "CVE-2023-47311": {"epss_score": 0.00103, "epss_percentile": 0.28903}, "CVE-2023-47312": {"epss_score": 0.0004, "epss_percentile": 0.12172}, "CVE-2023-47313": {"epss_score": 0.00133, "epss_percentile": 0.33717}, "CVE-2023-47314": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2023-47315": {"epss_score": 0.00072, "epss_percentile": 0.22373}, "CVE-2023-47316": {"epss_score": 0.00063, "epss_percentile": 0.19828}, "CVE-2023-47320": {"epss_score": 0.00351, "epss_percentile": 0.5705}, "CVE-2023-47321": {"epss_score": 0.00252, "epss_percentile": 0.48357}, "CVE-2023-47322": {"epss_score": 0.00144, "epss_percentile": 0.35233}, "CVE-2023-47323": {"epss_score": 0.00597, "epss_percentile": 0.68746}, "CVE-2023-47324": {"epss_score": 0.00278, "epss_percentile": 0.50858}, "CVE-2023-47325": {"epss_score": 0.00198, "epss_percentile": 0.41977}, "CVE-2023-47326": {"epss_score": 0.00231, "epss_percentile": 0.45808}, "CVE-2023-47327": {"epss_score": 0.00089, "epss_percentile": 0.25987}, "CVE-2023-47335": {"epss_score": 0.00032, "epss_percentile": 0.09106}, "CVE-2023-47345": {"epss_score": 0.00246, "epss_percentile": 0.47805}, "CVE-2023-47346": {"epss_score": 0.0015, "epss_percentile": 0.36082}, "CVE-2023-47347": {"epss_score": 0.00078, "epss_percentile": 0.236}, "CVE-2023-47350": {"epss_score": 0.00679, "epss_percentile": 0.71012}, "CVE-2023-47352": {"epss_score": 0.00054, "epss_percentile": 0.1713}, "CVE-2023-47353": {"epss_score": 0.00172, "epss_percentile": 0.38946}, "CVE-2023-47354": {"epss_score": 0.00073, "epss_percentile": 0.22586}, "CVE-2023-47355": {"epss_score": 0.00253, "epss_percentile": 0.48478}, "CVE-2023-47356": {"epss_score": 0.00303, "epss_percentile": 0.53219}, "CVE-2023-47359": {"epss_score": 0.00105, "epss_percentile": 0.29254}, "CVE-2023-47360": {"epss_score": 0.00094, "epss_percentile": 0.26798}, "CVE-2023-47363": {"epss_score": 0.00038, "epss_percentile": 0.11286}, "CVE-2023-47364": {"epss_score": 0.00038, "epss_percentile": 0.11286}, "CVE-2023-47365": {"epss_score": 0.00038, "epss_percentile": 0.11286}, "CVE-2023-47366": {"epss_score": 0.00038, "epss_percentile": 0.11286}, "CVE-2023-47367": {"epss_score": 0.00038, "epss_percentile": 0.11286}, "CVE-2023-47368": {"epss_score": 0.00038, "epss_percentile": 0.11286}, "CVE-2023-47369": {"epss_score": 0.00038, "epss_percentile": 0.11286}, "CVE-2023-47370": {"epss_score": 0.00038, "epss_percentile": 0.11286}, "CVE-2023-47372": {"epss_score": 0.00038, "epss_percentile": 0.11286}, "CVE-2023-47373": {"epss_score": 0.00038, "epss_percentile": 0.11286}, "CVE-2023-47379": {"epss_score": 0.00158, "epss_percentile": 0.37142}, "CVE-2023-47380": {"epss_score": 0.00348, "epss_percentile": 0.56808}, "CVE-2023-47384": {"epss_score": 0.00132, "epss_percentile": 0.33587}, "CVE-2023-47390": {"epss_score": 0.00086, "epss_percentile": 0.25351}, "CVE-2023-47392": {"epss_score": 0.00207, "epss_percentile": 0.43207}, "CVE-2023-47393": {"epss_score": 0.00207, "epss_percentile": 0.43207}, "CVE-2023-47397": {"epss_score": 0.00281, "epss_percentile": 0.51114}, "CVE-2023-47415": {"epss_score": 0.20102, "epss_percentile": 0.95287}, "CVE-2023-47417": {"epss_score": 0.00126, "epss_percentile": 0.32657}, "CVE-2023-47418": {"epss_score": 0.04312, "epss_percentile": 0.88532}, "CVE-2023-47422": {"epss_score": 0.00017, "epss_percentile": 0.03149}, "CVE-2023-47430": {"epss_score": 0.00029, "epss_percentile": 0.07776}, "CVE-2023-47435": {"epss_score": 0.00082, "epss_percentile": 0.24482}, "CVE-2023-47437": {"epss_score": 0.00126, "epss_percentile": 0.32742}, "CVE-2023-47438": {"epss_score": 0.00091, "epss_percentile": 0.26221}, "CVE-2023-47440": {"epss_score": 0.00487, "epss_percentile": 0.64822}, "CVE-2023-47444": {"epss_score": 0.07402, "epss_percentile": 0.91453}, "CVE-2023-47445": {"epss_score": 0.00407, "epss_percentile": 0.60581}, "CVE-2023-47446": {"epss_score": 0.00475, "epss_percentile": 0.64202}, "CVE-2023-47452": {"epss_score": 0.00067, "epss_percentile": 0.20986}, "CVE-2023-47453": {"epss_score": 0.0007, "epss_percentile": 0.21686}, "CVE-2023-47454": {"epss_score": 0.0007, "epss_percentile": 0.21686}, "CVE-2023-47455": {"epss_score": 0.00171, "epss_percentile": 0.3877}, "CVE-2023-47456": {"epss_score": 0.00171, "epss_percentile": 0.3877}, "CVE-2023-47458": {"epss_score": 0.00924, "epss_percentile": 0.7552}, "CVE-2023-47459": {"epss_score": 0.0061, "epss_percentile": 0.69149}, "CVE-2023-47460": {"epss_score": 0.10959, "epss_percentile": 0.93177}, "CVE-2023-47462": {"epss_score": 0.03405, "epss_percentile": 0.87075}, "CVE-2023-47463": {"epss_score": 0.04462, "epss_percentile": 0.88726}, "CVE-2023-47464": {"epss_score": 0.70103, "epss_percentile": 0.98616}, "CVE-2023-47465": {"epss_score": 0.00024, "epss_percentile": 0.05969}, "CVE-2023-47466": {"epss_score": 0.00019, "epss_percentile": 0.04157}, "CVE-2023-47467": {"epss_score": 0.00084, "epss_percentile": 0.24902}, "CVE-2023-47470": {"epss_score": 0.01358, "epss_percentile": 0.79731}, "CVE-2023-47471": {"epss_score": 0.00299, "epss_percentile": 0.52875}, "CVE-2023-47473": {"epss_score": 0.00279, "epss_percentile": 0.50936}, "CVE-2023-47480": {"epss_score": 0.00051, "epss_percentile": 0.1626}, "CVE-2023-47488": {"epss_score": 0.0511, "epss_percentile": 0.89509}, "CVE-2023-47489": {"epss_score": 0.0011, "epss_percentile": 0.30226}, "CVE-2023-47503": {"epss_score": 0.01289, "epss_percentile": 0.79214}, "CVE-2023-47504": {"epss_score": 0.07841, "epss_percentile": 0.91711}, "CVE-2023-47505": {"epss_score": 0.04787, "epss_percentile": 0.89144}, "CVE-2023-47506": {"epss_score": 0.00128, "epss_percentile": 0.33046}, "CVE-2023-47507": {"epss_score": 0.00151, "epss_percentile": 0.36186}, "CVE-2023-47508": {"epss_score": 0.00096, "epss_percentile": 0.27354}, "CVE-2023-47509": {"epss_score": 0.00096, "epss_percentile": 0.27354}, "CVE-2023-47510": {"epss_score": 0.00235, "epss_percentile": 0.46328}, "CVE-2023-47511": {"epss_score": 0.00067, "epss_percentile": 0.21076}, "CVE-2023-47512": {"epss_score": 0.00096, "epss_percentile": 0.27354}, "CVE-2023-47513": {"epss_score": 0.00183, "epss_percentile": 0.40285}, "CVE-2023-47514": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47515": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-47516": {"epss_score": 0.00064, "epss_percentile": 0.20144}, "CVE-2023-47517": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47518": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47519": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-47520": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47521": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47522": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47523": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-47524": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47525": {"epss_score": 0.00107, "epss_percentile": 0.29669}, "CVE-2023-47526": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-47527": {"epss_score": 0.00107, "epss_percentile": 0.29669}, "CVE-2023-47528": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-47529": {"epss_score": 0.03423, "epss_percentile": 0.87108}, "CVE-2023-47530": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-47531": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-47532": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47533": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-47534": {"epss_score": 0.00248, "epss_percentile": 0.47999}, "CVE-2023-47536": {"epss_score": 0.0005, "epss_percentile": 0.15934}, "CVE-2023-47537": {"epss_score": 0.00077, "epss_percentile": 0.23381}, "CVE-2023-47539": {"epss_score": 0.00085, "epss_percentile": 0.251}, "CVE-2023-47540": {"epss_score": 0.00137, "epss_percentile": 0.34254}, "CVE-2023-47541": {"epss_score": 0.00132, "epss_percentile": 0.33581}, "CVE-2023-47542": {"epss_score": 0.00158, "epss_percentile": 0.37171}, "CVE-2023-47543": {"epss_score": 0.00072, "epss_percentile": 0.22239}, "CVE-2023-47544": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47545": {"epss_score": 0.00118, "epss_percentile": 0.31481}, "CVE-2023-47546": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-47547": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47548": {"epss_score": 0.00213, "epss_percentile": 0.43838}, "CVE-2023-47549": {"epss_score": 0.00518, "epss_percentile": 0.66116}, "CVE-2023-47550": {"epss_score": 0.00141, "epss_percentile": 0.34928}, "CVE-2023-47551": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-47552": {"epss_score": 0.00106, "epss_percentile": 0.29522}, "CVE-2023-47553": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-47554": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-47556": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-47557": {"epss_score": 0.00163, "epss_percentile": 0.37788}, "CVE-2023-47558": {"epss_score": 0.0014, "epss_percentile": 0.34695}, "CVE-2023-47559": {"epss_score": 0.00077, "epss_percentile": 0.23415}, "CVE-2023-47560": {"epss_score": 0.0049, "epss_percentile": 0.6493}, "CVE-2023-47561": {"epss_score": 0.00104, "epss_percentile": 0.29205}, "CVE-2023-47562": {"epss_score": 0.00362, "epss_percentile": 0.5779}, "CVE-2023-47563": {"epss_score": 0.00492, "epss_percentile": 0.64986}, "CVE-2023-47564": {"epss_score": 0.06904, "epss_percentile": 0.91106}, "CVE-2023-47565": {"epss_score": 0.85967, "epss_percentile": 0.99359}, "CVE-2023-47566": {"epss_score": 0.0011, "epss_percentile": 0.30203}, "CVE-2023-47567": {"epss_score": 0.00093, "epss_percentile": 0.26749}, "CVE-2023-47568": {"epss_score": 0.00087, "epss_percentile": 0.25442}, "CVE-2023-47573": {"epss_score": 0.00212, "epss_percentile": 0.43729}, "CVE-2023-47574": {"epss_score": 0.00224, "epss_percentile": 0.44975}, "CVE-2023-47575": {"epss_score": 0.00251, "epss_percentile": 0.48258}, "CVE-2023-47576": {"epss_score": 0.00584, "epss_percentile": 0.68371}, "CVE-2023-47577": {"epss_score": 0.00189, "epss_percentile": 0.40991}, "CVE-2023-47578": {"epss_score": 0.00207, "epss_percentile": 0.4315}, "CVE-2023-47579": {"epss_score": 0.00209, "epss_percentile": 0.43326}, "CVE-2023-47580": {"epss_score": 0.00062, "epss_percentile": 0.19552}, "CVE-2023-47581": {"epss_score": 0.00062, "epss_percentile": 0.19552}, "CVE-2023-47582": {"epss_score": 0.00062, "epss_percentile": 0.19552}, "CVE-2023-47583": {"epss_score": 0.00046, "epss_percentile": 0.14081}, "CVE-2023-47584": {"epss_score": 0.00062, "epss_percentile": 0.19552}, "CVE-2023-47585": {"epss_score": 0.00062, "epss_percentile": 0.19552}, "CVE-2023-47586": {"epss_score": 0.00057, "epss_percentile": 0.17997}, "CVE-2023-47609": {"epss_score": 0.01413, "epss_percentile": 0.80117}, "CVE-2023-47610": {"epss_score": 0.02777, "epss_percentile": 0.85639}, "CVE-2023-47611": {"epss_score": 0.00028, "epss_percentile": 0.07212}, "CVE-2023-47612": {"epss_score": 0.00044, "epss_percentile": 0.13667}, "CVE-2023-47613": {"epss_score": 0.00051, "epss_percentile": 0.16232}, "CVE-2023-47614": {"epss_score": 0.00023, "epss_percentile": 0.05409}, "CVE-2023-47615": {"epss_score": 0.00024, "epss_percentile": 0.05685}, "CVE-2023-47616": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2023-47617": {"epss_score": 0.00781, "epss_percentile": 0.73182}, "CVE-2023-47618": {"epss_score": 0.0034, "epss_percentile": 0.56273}, "CVE-2023-47619": {"epss_score": 0.00123, "epss_percentile": 0.32254}, "CVE-2023-47620": {"epss_score": 0.00219, "epss_percentile": 0.44509}, "CVE-2023-47621": {"epss_score": 0.00643, "epss_percentile": 0.70045}, "CVE-2023-47622": {"epss_score": 0.00713, "epss_percentile": 0.71804}, "CVE-2023-47623": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-47624": {"epss_score": 0.0012, "epss_percentile": 0.31745}, "CVE-2023-47625": {"epss_score": 0.00081, "epss_percentile": 0.24343}, "CVE-2023-47626": {"epss_score": 0.00713, "epss_percentile": 0.71804}, "CVE-2023-47627": {"epss_score": 0.0026, "epss_percentile": 0.49103}, "CVE-2023-47628": {"epss_score": 0.00118, "epss_percentile": 0.31394}, "CVE-2023-47629": {"epss_score": 0.00169, "epss_percentile": 0.38547}, "CVE-2023-47630": {"epss_score": 0.00562, "epss_percentile": 0.67702}, "CVE-2023-47631": {"epss_score": 0.00297, "epss_percentile": 0.52693}, "CVE-2023-47633": {"epss_score": 0.00833, "epss_percentile": 0.74095}, "CVE-2023-47634": {"epss_score": 0.00287, "epss_percentile": 0.51786}, "CVE-2023-47635": {"epss_score": 0.00105, "epss_percentile": 0.29283}, "CVE-2023-47636": {"epss_score": 5e-05, "epss_percentile": 0.00179}, "CVE-2023-47637": {"epss_score": 0.77126, "epss_percentile": 0.98923}, "CVE-2023-47639": {"epss_score": 0.00071, "epss_percentile": 0.2211}, "CVE-2023-47640": {"epss_score": 0.0005, "epss_percentile": 0.15851}, "CVE-2023-47641": {"epss_score": 0.00219, "epss_percentile": 0.44479}, "CVE-2023-47642": {"epss_score": 0.00382, "epss_percentile": 0.59068}, "CVE-2023-47643": {"epss_score": 0.40094, "epss_percentile": 0.97195}, "CVE-2023-47644": {"epss_score": 0.00106, "epss_percentile": 0.29522}, "CVE-2023-47645": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2023-47646": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-47647": {"epss_score": 0.00193, "epss_percentile": 0.41431}, "CVE-2023-47648": {"epss_score": 0.00199, "epss_percentile": 0.42131}, "CVE-2023-47649": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-47650": {"epss_score": 0.00137, "epss_percentile": 0.3421}, "CVE-2023-47651": {"epss_score": 0.00128, "epss_percentile": 0.33057}, "CVE-2023-47652": {"epss_score": 0.00061, "epss_percentile": 0.19251}, "CVE-2023-47653": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2023-47654": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-47655": {"epss_score": 0.00098, "epss_percentile": 0.27823}, "CVE-2023-47656": {"epss_score": 0.00102, "epss_percentile": 0.28767}, "CVE-2023-47657": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-47658": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-47659": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-47660": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-47661": {"epss_score": 0.00142, "epss_percentile": 0.35024}, "CVE-2023-47662": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-47663": {"epss_score": 0.00183, "epss_percentile": 0.40285}, "CVE-2023-47664": {"epss_score": 0.00196, "epss_percentile": 0.41713}, "CVE-2023-47665": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-47666": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-47667": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-47668": {"epss_score": 0.05471, "epss_percentile": 0.89909}, "CVE-2023-47669": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-47670": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-47671": {"epss_score": 0.00106, "epss_percentile": 0.29522}, "CVE-2023-47672": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-47673": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-47674": {"epss_score": 0.01022, "epss_percentile": 0.76756}, "CVE-2023-47675": {"epss_score": 0.00834, "epss_percentile": 0.74099}, "CVE-2023-47677": {"epss_score": 0.00359, "epss_percentile": 0.57569}, "CVE-2023-47678": {"epss_score": 0.00104, "epss_percentile": 0.29173}, "CVE-2023-47679": {"epss_score": 0.00426, "epss_percentile": 0.61767}, "CVE-2023-47680": {"epss_score": 0.00081, "epss_percentile": 0.24347}, "CVE-2023-47681": {"epss_score": 0.03203, "epss_percentile": 0.86627}, "CVE-2023-47682": {"epss_score": 0.0022, "epss_percentile": 0.44545}, "CVE-2023-47683": {"epss_score": 0.00206, "epss_percentile": 0.43063}, "CVE-2023-47684": {"epss_score": 0.01704, "epss_percentile": 0.81845}, "CVE-2023-47685": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-47686": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2023-47687": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2023-47688": {"epss_score": 0.00155, "epss_percentile": 0.36792}, "CVE-2023-47689": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-47690": {"epss_score": 0.00087, "epss_percentile": 0.25547}, "CVE-2023-47692": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-47693": {"epss_score": 0.00359, "epss_percentile": 0.57598}, "CVE-2023-47694": {"epss_score": 0.00079, "epss_percentile": 0.24}, "CVE-2023-47695": {"epss_score": 0.00096, "epss_percentile": 0.27354}, "CVE-2023-47696": {"epss_score": 0.00096, "epss_percentile": 0.27354}, "CVE-2023-47697": {"epss_score": 0.00096, "epss_percentile": 0.27354}, "CVE-2023-47698": {"epss_score": 0.00224, "epss_percentile": 0.45047}, "CVE-2023-47699": {"epss_score": 0.00151, "epss_percentile": 0.36366}, "CVE-2023-47700": {"epss_score": 0.00036, "epss_percentile": 0.10229}, "CVE-2023-47701": {"epss_score": 0.00121, "epss_percentile": 0.31924}, "CVE-2023-47702": {"epss_score": 0.00055, "epss_percentile": 0.17368}, "CVE-2023-47703": {"epss_score": 0.00048, "epss_percentile": 0.15051}, "CVE-2023-47704": {"epss_score": 0.0006, "epss_percentile": 0.19062}, "CVE-2023-47705": {"epss_score": 0.001, "epss_percentile": 0.28457}, "CVE-2023-47706": {"epss_score": 0.0007, "epss_percentile": 0.21817}, "CVE-2023-47707": {"epss_score": 0.0009, "epss_percentile": 0.2617}, "CVE-2023-47709": {"epss_score": 0.004, "epss_percentile": 0.60166}, "CVE-2023-47710": {"epss_score": 0.0011, "epss_percentile": 0.30159}, "CVE-2023-47711": {"epss_score": 0.00036, "epss_percentile": 0.10311}, "CVE-2023-47712": {"epss_score": 0.0002, "epss_percentile": 0.045}, "CVE-2023-47714": {"epss_score": 0.00071, "epss_percentile": 0.22161}, "CVE-2023-47715": {"epss_score": 0.00024, "epss_percentile": 0.05965}, "CVE-2023-47716": {"epss_score": 0.00019, "epss_percentile": 0.04134}, "CVE-2023-47717": {"epss_score": 0.00038, "epss_percentile": 0.11196}, "CVE-2023-47718": {"epss_score": 0.00042, "epss_percentile": 0.12793}, "CVE-2023-47722": {"epss_score": 0.00021, "epss_percentile": 0.04729}, "CVE-2023-47726": {"epss_score": 0.00101, "epss_percentile": 0.2871}, "CVE-2023-47727": {"epss_score": 0.00045, "epss_percentile": 0.13728}, "CVE-2023-47728": {"epss_score": 0.00088, "epss_percentile": 0.25761}, "CVE-2023-47731": {"epss_score": 0.00058, "epss_percentile": 0.1827}, "CVE-2023-47741": {"epss_score": 0.00037, "epss_percentile": 0.10857}, "CVE-2023-47742": {"epss_score": 0.00045, "epss_percentile": 0.13934}, "CVE-2023-47745": {"epss_score": 0.0001, "epss_percentile": 0.00894}, "CVE-2023-47746": {"epss_score": 0.00047, "epss_percentile": 0.14925}, "CVE-2023-47747": {"epss_score": 0.00041, "epss_percentile": 0.12238}, "CVE-2023-47754": {"epss_score": 0.00125, "epss_percentile": 0.32597}, "CVE-2023-47755": {"epss_score": 0.00081, "epss_percentile": 0.24347}, "CVE-2023-47756": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-47757": {"epss_score": 0.00114, "epss_percentile": 0.30755}, "CVE-2023-47758": {"epss_score": 0.00053, "epss_percentile": 0.1699}, "CVE-2023-47759": {"epss_score": 0.00067, "epss_percentile": 0.21076}, "CVE-2023-47760": {"epss_score": 0.0025, "epss_percentile": 0.48115}, "CVE-2023-47761": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-47762": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-47763": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-47764": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-47765": {"epss_score": 0.0007, "epss_percentile": 0.2193}, "CVE-2023-47766": {"epss_score": 0.00087, "epss_percentile": 0.25547}, "CVE-2023-47767": {"epss_score": 0.00087, "epss_percentile": 0.25547}, "CVE-2023-47768": {"epss_score": 0.00096, "epss_percentile": 0.27354}, "CVE-2023-47769": {"epss_score": 0.00106, "epss_percentile": 0.29507}, "CVE-2023-47770": {"epss_score": 0.00151, "epss_percentile": 0.36312}, "CVE-2023-47771": {"epss_score": 0.00205, "epss_percentile": 0.42747}, "CVE-2023-47772": {"epss_score": 0.0009, "epss_percentile": 0.26036}, "CVE-2023-47773": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-47774": {"epss_score": 0.00044, "epss_percentile": 0.13534}, "CVE-2023-47775": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-47776": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-47777": {"epss_score": 0.00421, "epss_percentile": 0.61489}, "CVE-2023-47778": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-47779": {"epss_score": 0.00238, "epss_percentile": 0.46819}, "CVE-2023-47780": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-47781": {"epss_score": 0.00096, "epss_percentile": 0.27441}, "CVE-2023-47782": {"epss_score": 0.00219, "epss_percentile": 0.44471}, "CVE-2023-47783": {"epss_score": 0.00205, "epss_percentile": 0.42747}, "CVE-2023-47784": {"epss_score": 0.00175, "epss_percentile": 0.39295}, "CVE-2023-47785": {"epss_score": 0.00072, "epss_percentile": 0.22277}, "CVE-2023-47786": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47787": {"epss_score": 0.00074, "epss_percentile": 0.2276}, "CVE-2023-47788": {"epss_score": 0.00109, "epss_percentile": 0.29944}, "CVE-2023-47789": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-47790": {"epss_score": 0.0014, "epss_percentile": 0.34717}, "CVE-2023-47791": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-47792": {"epss_score": 0.0007, "epss_percentile": 0.2193}, "CVE-2023-47793": {"epss_score": 0.0018, "epss_percentile": 0.39879}, "CVE-2023-47795": {"epss_score": 0.00392, "epss_percentile": 0.5965}, "CVE-2023-47797": {"epss_score": 0.00147, "epss_percentile": 0.35644}, "CVE-2023-47798": {"epss_score": 0.00186, "epss_percentile": 0.40634}, "CVE-2023-47799": {"epss_score": 0.00059, "epss_percentile": 0.18904}, "CVE-2023-47800": {"epss_score": 0.03682, "epss_percentile": 0.87561}, "CVE-2023-47801": {"epss_score": 0.00088, "epss_percentile": 0.25712}, "CVE-2023-47802": {"epss_score": 0.00285, "epss_percentile": 0.51658}, "CVE-2023-47803": {"epss_score": 0.00287, "epss_percentile": 0.51828}, "CVE-2023-47804": {"epss_score": 0.03009, "epss_percentile": 0.86194}, "CVE-2023-47805": {"epss_score": 0.00417, "epss_percentile": 0.61221}, "CVE-2023-47806": {"epss_score": 0.00059, "epss_percentile": 0.18739}, "CVE-2023-47807": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-47808": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47809": {"epss_score": 0.00051, "epss_percentile": 0.16045}, "CVE-2023-47810": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47811": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47812": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47813": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47814": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47815": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47816": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47817": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47818": {"epss_score": 0.00572, "epss_percentile": 0.68036}, "CVE-2023-47819": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-47820": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-47821": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47822": {"epss_score": 0.00282, "epss_percentile": 0.51279}, "CVE-2023-47823": {"epss_score": 0.00213, "epss_percentile": 0.4388}, "CVE-2023-47824": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-47825": {"epss_score": 0.0007, "epss_percentile": 0.2193}, "CVE-2023-47826": {"epss_score": 0.00478, "epss_percentile": 0.64374}, "CVE-2023-47827": {"epss_score": 0.00145, "epss_percentile": 0.35439}, "CVE-2023-47828": {"epss_score": 0.00373, "epss_percentile": 0.58528}, "CVE-2023-47829": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-47830": {"epss_score": 0.00203, "epss_percentile": 0.42543}, "CVE-2023-47831": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47832": {"epss_score": 0.00163, "epss_percentile": 0.37844}, "CVE-2023-47833": {"epss_score": 0.00127, "epss_percentile": 0.3285}, "CVE-2023-47834": {"epss_score": 0.00162, "epss_percentile": 0.37667}, "CVE-2023-47835": {"epss_score": 0.0017, "epss_percentile": 0.38731}, "CVE-2023-47836": {"epss_score": 0.00203, "epss_percentile": 0.42543}, "CVE-2023-47837": {"epss_score": 0.00337, "epss_percentile": 0.5601}, "CVE-2023-47838": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-47839": {"epss_score": 0.0017, "epss_percentile": 0.38731}, "CVE-2023-47840": {"epss_score": 0.18826, "epss_percentile": 0.95075}, "CVE-2023-47841": {"epss_score": 0.00163, "epss_percentile": 0.37788}, "CVE-2023-47842": {"epss_score": 0.00457, "epss_percentile": 0.63375}, "CVE-2023-47843": {"epss_score": 0.00155, "epss_percentile": 0.36761}, "CVE-2023-47844": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47845": {"epss_score": 0.0019, "epss_percentile": 0.41052}, "CVE-2023-47846": {"epss_score": 0.00457, "epss_percentile": 0.63375}, "CVE-2023-47847": {"epss_score": 0.0021, "epss_percentile": 0.43443}, "CVE-2023-47848": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47849": {"epss_score": 0.00163, "epss_percentile": 0.37788}, "CVE-2023-47850": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-47851": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-47852": {"epss_score": 0.00122, "epss_percentile": 0.32098}, "CVE-2023-47853": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-47854": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-47855": {"epss_score": 0.00074, "epss_percentile": 0.22744}, "CVE-2023-47856": {"epss_score": 0.0731, "epss_percentile": 0.91399}, "CVE-2023-47857": {"epss_score": 0.00057, "epss_percentile": 0.17986}, "CVE-2023-47858": {"epss_score": 0.0019, "epss_percentile": 0.41072}, "CVE-2023-47859": {"epss_score": 0.00063, "epss_percentile": 0.19813}, "CVE-2023-47861": {"epss_score": 0.00344, "epss_percentile": 0.56489}, "CVE-2023-47862": {"epss_score": 0.00881, "epss_percentile": 0.74872}, "CVE-2023-47865": {"epss_score": 0.00107, "epss_percentile": 0.29634}, "CVE-2023-47867": {"epss_score": 0.00037, "epss_percentile": 0.1074}, "CVE-2023-47868": {"epss_score": 0.00251, "epss_percentile": 0.48268}, "CVE-2023-47869": {"epss_score": 0.00102, "epss_percentile": 0.28754}, "CVE-2023-47870": {"epss_score": 0.00134, "epss_percentile": 0.33812}, "CVE-2023-47871": {"epss_score": 0.0007, "epss_percentile": 0.21778}, "CVE-2023-47872": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-47873": {"epss_score": 0.11235, "epss_percentile": 0.93274}, "CVE-2023-47874": {"epss_score": 0.00086, "epss_percentile": 0.25307}, "CVE-2023-47875": {"epss_score": 0.00123, "epss_percentile": 0.32324}, "CVE-2023-47876": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-47877": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-47882": {"epss_score": 0.00169, "epss_percentile": 0.38599}, "CVE-2023-47883": {"epss_score": 0.01252, "epss_percentile": 0.78911}, "CVE-2023-47889": {"epss_score": 0.00159, "epss_percentile": 0.3738}, "CVE-2023-47890": {"epss_score": 0.00262, "epss_percentile": 0.49392}, "CVE-2023-47990": {"epss_score": 0.0021, "epss_percentile": 0.43599}, "CVE-2023-47992": {"epss_score": 0.00197, "epss_percentile": 0.41946}, "CVE-2023-47993": {"epss_score": 0.00125, "epss_percentile": 0.32614}, "CVE-2023-47994": {"epss_score": 0.00185, "epss_percentile": 0.40478}, "CVE-2023-47995": {"epss_score": 0.0021, "epss_percentile": 0.4349}, "CVE-2023-47996": {"epss_score": 0.00127, "epss_percentile": 0.32792}, "CVE-2023-47997": {"epss_score": 0.00212, "epss_percentile": 0.43792}, "CVE-2023-48003": {"epss_score": 0.00222, "epss_percentile": 0.44724}, "CVE-2023-48010": {"epss_score": 0.00226, "epss_percentile": 0.45274}, "CVE-2023-48011": {"epss_score": 0.0005, "epss_percentile": 0.15691}, "CVE-2023-48013": {"epss_score": 0.0005, "epss_percentile": 0.15691}, "CVE-2023-48014": {"epss_score": 0.00061, "epss_percentile": 0.19417}, "CVE-2023-48016": {"epss_score": 0.00114, "epss_percentile": 0.3088}, "CVE-2023-48017": {"epss_score": 0.00059, "epss_percentile": 0.18756}, "CVE-2023-48020": {"epss_score": 0.00163, "epss_percentile": 0.37861}, "CVE-2023-48021": {"epss_score": 0.00163, "epss_percentile": 0.37861}, "CVE-2023-48022": {"epss_score": 0.91897, "epss_percentile": 0.99676}, "CVE-2023-48023": {"epss_score": 0.89186, "epss_percentile": 0.99514}, "CVE-2023-48024": {"epss_score": 0.00063, "epss_percentile": 0.19987}, "CVE-2023-48025": {"epss_score": 0.00097, "epss_percentile": 0.27494}, "CVE-2023-48028": {"epss_score": 0.00329, "epss_percentile": 0.55308}, "CVE-2023-48029": {"epss_score": 0.0038, "epss_percentile": 0.58913}, "CVE-2023-48031": {"epss_score": 0.00392, "epss_percentile": 0.59655}, "CVE-2023-48034": {"epss_score": 0.00275, "epss_percentile": 0.50684}, "CVE-2023-48039": {"epss_score": 0.00045, "epss_percentile": 0.14015}, "CVE-2023-48042": {"epss_score": 0.00061, "epss_percentile": 0.19319}, "CVE-2023-48049": {"epss_score": 0.01165, "epss_percentile": 0.78174}, "CVE-2023-48050": {"epss_score": 0.02653, "epss_percentile": 0.85348}, "CVE-2023-48051": {"epss_score": 0.0005, "epss_percentile": 0.15825}, "CVE-2023-48052": {"epss_score": 0.00122, "epss_percentile": 0.32135}, "CVE-2023-48053": {"epss_score": 0.00155, "epss_percentile": 0.36803}, "CVE-2023-48054": {"epss_score": 0.0014, "epss_percentile": 0.347}, "CVE-2023-48055": {"epss_score": 0.00174, "epss_percentile": 0.39151}, "CVE-2023-48056": {"epss_score": 0.00194, "epss_percentile": 0.41558}, "CVE-2023-48058": {"epss_score": 0.00076, "epss_percentile": 0.23116}, "CVE-2023-48060": {"epss_score": 0.00076, "epss_percentile": 0.23116}, "CVE-2023-48063": {"epss_score": 0.00051, "epss_percentile": 0.163}, "CVE-2023-48068": {"epss_score": 0.00076, "epss_percentile": 0.23134}, "CVE-2023-48078": {"epss_score": 0.00098, "epss_percentile": 0.27745}, "CVE-2023-48082": {"epss_score": 0.01145, "epss_percentile": 0.77993}, "CVE-2023-48084": {"epss_score": 0.82094, "epss_percentile": 0.99173}, "CVE-2023-48085": {"epss_score": 0.62399, "epss_percentile": 0.98291}, "CVE-2023-48087": {"epss_score": 0.00054, "epss_percentile": 0.17312}, "CVE-2023-48088": {"epss_score": 0.00085, "epss_percentile": 0.25145}, "CVE-2023-48089": {"epss_score": 0.0129, "epss_percentile": 0.7922}, "CVE-2023-48090": {"epss_score": 0.00046, "epss_percentile": 0.14291}, "CVE-2023-48094": {"epss_score": 0.00216, "epss_percentile": 0.44199}, "CVE-2023-48104": {"epss_score": 0.10328, "epss_percentile": 0.92947}, "CVE-2023-48105": {"epss_score": 0.00369, "epss_percentile": 0.58245}, "CVE-2023-48106": {"epss_score": 0.00157, "epss_percentile": 0.37081}, "CVE-2023-48107": {"epss_score": 0.00125, "epss_percentile": 0.32573}, "CVE-2023-48109": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-48110": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-48111": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-48114": {"epss_score": 0.00169, "epss_percentile": 0.38625}, "CVE-2023-48115": {"epss_score": 0.00169, "epss_percentile": 0.38625}, "CVE-2023-48116": {"epss_score": 0.00169, "epss_percentile": 0.38625}, "CVE-2023-48118": {"epss_score": 0.01297, "epss_percentile": 0.79268}, "CVE-2023-48121": {"epss_score": 0.00643, "epss_percentile": 0.70051}, "CVE-2023-48122": {"epss_score": 0.00332, "epss_percentile": 0.55586}, "CVE-2023-48123": {"epss_score": 0.68245, "epss_percentile": 0.98537}, "CVE-2023-48124": {"epss_score": 0.00934, "epss_percentile": 0.75655}, "CVE-2023-48126": {"epss_score": 0.00167, "epss_percentile": 0.38323}, "CVE-2023-48127": {"epss_score": 0.00176, "epss_percentile": 0.39467}, "CVE-2023-48128": {"epss_score": 0.00167, "epss_percentile": 0.38323}, "CVE-2023-48129": {"epss_score": 0.00167, "epss_percentile": 0.38323}, "CVE-2023-48130": {"epss_score": 0.00167, "epss_percentile": 0.38323}, "CVE-2023-48131": {"epss_score": 0.00167, "epss_percentile": 0.38323}, "CVE-2023-48132": {"epss_score": 0.00167, "epss_percentile": 0.38323}, "CVE-2023-48133": {"epss_score": 0.00167, "epss_percentile": 0.38323}, "CVE-2023-48134": {"epss_score": 0.00109, "epss_percentile": 0.29971}, "CVE-2023-48135": {"epss_score": 0.00167, "epss_percentile": 0.38323}, "CVE-2023-48161": {"epss_score": 0.00026, "epss_percentile": 0.06464}, "CVE-2023-48166": {"epss_score": 0.00793, "epss_percentile": 0.73417}, "CVE-2023-48171": {"epss_score": 0.01135, "epss_percentile": 0.77896}, "CVE-2023-48172": {"epss_score": 0.00151, "epss_percentile": 0.36364}, "CVE-2023-48176": {"epss_score": 0.00233, "epss_percentile": 0.45998}, "CVE-2023-48183": {"epss_score": 0.00053, "epss_percentile": 0.1699}, "CVE-2023-48184": {"epss_score": 0.00023, "epss_percentile": 0.05618}, "CVE-2023-48185": {"epss_score": 0.00138, "epss_percentile": 0.34409}, "CVE-2023-48188": {"epss_score": 0.00691, "epss_percentile": 0.71278}, "CVE-2023-48192": {"epss_score": 0.00111, "epss_percentile": 0.30334}, "CVE-2023-48193": {"epss_score": 0.03849, "epss_percentile": 0.87844}, "CVE-2023-48194": {"epss_score": 0.0044, "epss_percentile": 0.62626}, "CVE-2023-48197": {"epss_score": 0.00452, "epss_percentile": 0.63162}, "CVE-2023-48198": {"epss_score": 0.00562, "epss_percentile": 0.67681}, "CVE-2023-48199": {"epss_score": 0.00658, "epss_percentile": 0.70493}, "CVE-2023-48200": {"epss_score": 0.00321, "epss_percentile": 0.54648}, "CVE-2023-48201": {"epss_score": 0.00124, "epss_percentile": 0.32464}, "CVE-2023-48202": {"epss_score": 0.00108, "epss_percentile": 0.29759}, "CVE-2023-48204": {"epss_score": 0.00081, "epss_percentile": 0.24312}, "CVE-2023-48205": {"epss_score": 0.00191, "epss_percentile": 0.4117}, "CVE-2023-48206": {"epss_score": 0.00106, "epss_percentile": 0.29511}, "CVE-2023-48207": {"epss_score": 0.00184, "epss_percentile": 0.40407}, "CVE-2023-48208": {"epss_score": 0.00255, "epss_percentile": 0.48706}, "CVE-2023-48217": {"epss_score": 0.01048, "epss_percentile": 0.77051}, "CVE-2023-48218": {"epss_score": 0.00296, "epss_percentile": 0.52605}, "CVE-2023-48219": {"epss_score": 0.01983, "epss_percentile": 0.83147}, "CVE-2023-48220": {"epss_score": 0.00584, "epss_percentile": 0.68397}, "CVE-2023-48221": {"epss_score": 0.00894, "epss_percentile": 0.75089}, "CVE-2023-48222": {"epss_score": 0.00235, "epss_percentile": 0.46217}, "CVE-2023-48223": {"epss_score": 0.00179, "epss_percentile": 0.39854}, "CVE-2023-48224": {"epss_score": 0.00415, "epss_percentile": 0.6113}, "CVE-2023-48225": {"epss_score": 0.00151, "epss_percentile": 0.36339}, "CVE-2023-48226": {"epss_score": 0.00235, "epss_percentile": 0.46311}, "CVE-2023-48227": {"epss_score": 0.00114, "epss_percentile": 0.30852}, "CVE-2023-48228": {"epss_score": 0.00884, "epss_percentile": 0.74926}, "CVE-2023-48229": {"epss_score": 0.00425, "epss_percentile": 0.61729}, "CVE-2023-48230": {"epss_score": 0.04155, "epss_percentile": 0.88327}, "CVE-2023-48231": {"epss_score": 0.00052, "epss_percentile": 0.16446}, "CVE-2023-48232": {"epss_score": 0.0008, "epss_percentile": 0.24196}, "CVE-2023-48233": {"epss_score": 0.0008, "epss_percentile": 0.24196}, "CVE-2023-48234": {"epss_score": 0.00059, "epss_percentile": 0.18844}, "CVE-2023-48235": {"epss_score": 0.00068, "epss_percentile": 0.2119}, "CVE-2023-48236": {"epss_score": 0.0006, "epss_percentile": 0.18981}, "CVE-2023-48237": {"epss_score": 0.00053, "epss_percentile": 0.16859}, "CVE-2023-48238": {"epss_score": 0.00136, "epss_percentile": 0.34169}, "CVE-2023-48239": {"epss_score": 0.00582, "epss_percentile": 0.68297}, "CVE-2023-48240": {"epss_score": 0.01578, "epss_percentile": 0.81123}, "CVE-2023-48241": {"epss_score": 0.69186, "epss_percentile": 0.98581}, "CVE-2023-48242": {"epss_score": 0.00268, "epss_percentile": 0.50064}, "CVE-2023-48243": {"epss_score": 0.02069, "epss_percentile": 0.83469}, "CVE-2023-48244": {"epss_score": 0.00104, "epss_percentile": 0.29173}, "CVE-2023-48245": {"epss_score": 0.00396, "epss_percentile": 0.59928}, "CVE-2023-48246": {"epss_score": 0.00268, "epss_percentile": 0.50064}, "CVE-2023-48247": {"epss_score": 0.00225, "epss_percentile": 0.45222}, "CVE-2023-48248": {"epss_score": 0.00141, "epss_percentile": 0.34806}, "CVE-2023-48249": {"epss_score": 0.00259, "epss_percentile": 0.49096}, "CVE-2023-48250": {"epss_score": 0.00663, "epss_percentile": 0.70612}, "CVE-2023-48251": {"epss_score": 0.03324, "epss_percentile": 0.86919}, "CVE-2023-48252": {"epss_score": 0.0068, "epss_percentile": 0.71034}, "CVE-2023-48253": {"epss_score": 0.00809, "epss_percentile": 0.73712}, "CVE-2023-48254": {"epss_score": 0.00104, "epss_percentile": 0.29173}, "CVE-2023-48255": {"epss_score": 0.00147, "epss_percentile": 0.35677}, "CVE-2023-48256": {"epss_score": 0.0032, "epss_percentile": 0.54622}, "CVE-2023-48257": {"epss_score": 0.00638, "epss_percentile": 0.69903}, "CVE-2023-48258": {"epss_score": 0.00443, "epss_percentile": 0.62788}, "CVE-2023-48259": {"epss_score": 0.00242, "epss_percentile": 0.47346}, "CVE-2023-48260": {"epss_score": 0.00242, "epss_percentile": 0.47346}, "CVE-2023-48261": {"epss_score": 0.00242, "epss_percentile": 0.47346}, "CVE-2023-48262": {"epss_score": 0.01741, "epss_percentile": 0.8205}, "CVE-2023-48263": {"epss_score": 0.01741, "epss_percentile": 0.8205}, "CVE-2023-48264": {"epss_score": 0.01741, "epss_percentile": 0.8205}, "CVE-2023-48265": {"epss_score": 0.01741, "epss_percentile": 0.8205}, "CVE-2023-48266": {"epss_score": 0.01741, "epss_percentile": 0.8205}, "CVE-2023-48267": {"epss_score": 0.00035, "epss_percentile": 0.10135}, "CVE-2023-48268": {"epss_score": 0.00087, "epss_percentile": 0.25525}, "CVE-2023-48270": {"epss_score": 0.00528, "epss_percentile": 0.66556}, "CVE-2023-48271": {"epss_score": 0.00155, "epss_percentile": 0.36802}, "CVE-2023-48272": {"epss_score": 0.00174, "epss_percentile": 0.39228}, "CVE-2023-48273": {"epss_score": 0.00176, "epss_percentile": 0.39399}, "CVE-2023-48274": {"epss_score": 0.00331, "epss_percentile": 0.55503}, "CVE-2023-48275": {"epss_score": 0.0048, "epss_percentile": 0.6447}, "CVE-2023-48276": {"epss_score": 0.00196, "epss_percentile": 0.41761}, "CVE-2023-48277": {"epss_score": 0.00343, "epss_percentile": 0.56465}, "CVE-2023-48278": {"epss_score": 0.00087, "epss_percentile": 0.25592}, "CVE-2023-48279": {"epss_score": 0.00224, "epss_percentile": 0.44998}, "CVE-2023-48280": {"epss_score": 0.0028, "epss_percentile": 0.50999}, "CVE-2023-48281": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-48282": {"epss_score": 0.00123, "epss_percentile": 0.32324}, "CVE-2023-48283": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-48284": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-48285": {"epss_score": 0.00253, "epss_percentile": 0.48461}, "CVE-2023-48286": {"epss_score": 0.00253, "epss_percentile": 0.4844}, "CVE-2023-48287": {"epss_score": 0.00072, "epss_percentile": 0.22386}, "CVE-2023-48288": {"epss_score": 0.00618, "epss_percentile": 0.69365}, "CVE-2023-48289": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-48290": {"epss_score": 0.00114, "epss_percentile": 0.3081}, "CVE-2023-48291": {"epss_score": 0.00091, "epss_percentile": 0.26198}, "CVE-2023-48292": {"epss_score": 0.00761, "epss_percentile": 0.72824}, "CVE-2023-48293": {"epss_score": 0.00756, "epss_percentile": 0.7273}, "CVE-2023-48294": {"epss_score": 0.00026, "epss_percentile": 0.06577}, "CVE-2023-48295": {"epss_score": 0.00295, "epss_percentile": 0.5248}, "CVE-2023-48296": {"epss_score": 0.00229, "epss_percentile": 0.45593}, "CVE-2023-48297": {"epss_score": 0.00175, "epss_percentile": 0.39343}, "CVE-2023-48298": {"epss_score": 0.00467, "epss_percentile": 0.63827}, "CVE-2023-48299": {"epss_score": 0.00433, "epss_percentile": 0.62199}, "CVE-2023-48300": {"epss_score": 0.00431, "epss_percentile": 0.62043}, "CVE-2023-48301": {"epss_score": 0.00386, "epss_percentile": 0.59281}, "CVE-2023-48302": {"epss_score": 0.00386, "epss_percentile": 0.59281}, "CVE-2023-48303": {"epss_score": 0.00194, "epss_percentile": 0.41564}, "CVE-2023-48304": {"epss_score": 0.00143, "epss_percentile": 0.35209}, "CVE-2023-48305": {"epss_score": 0.00201, "epss_percentile": 0.42333}, "CVE-2023-48306": {"epss_score": 0.005, "epss_percentile": 0.65291}, "CVE-2023-48307": {"epss_score": 0.00183, "epss_percentile": 0.40278}, "CVE-2023-48308": {"epss_score": 0.00269, "epss_percentile": 0.50178}, "CVE-2023-48309": {"epss_score": 0.00295, "epss_percentile": 0.52467}, "CVE-2023-48310": {"epss_score": 0.00284, "epss_percentile": 0.51436}, "CVE-2023-48311": {"epss_score": 0.00246, "epss_percentile": 0.47785}, "CVE-2023-48312": {"epss_score": 0.00065, "epss_percentile": 0.2058}, "CVE-2023-48313": {"epss_score": 0.00572, "epss_percentile": 0.68033}, "CVE-2023-48314": {"epss_score": 0.00131, "epss_percentile": 0.3335}, "CVE-2023-48315": {"epss_score": 0.01095, "epss_percentile": 0.7751}, "CVE-2023-48316": {"epss_score": 0.03173, "epss_percentile": 0.86554}, "CVE-2023-48317": {"epss_score": 0.00163, "epss_percentile": 0.37791}, "CVE-2023-48318": {"epss_score": 0.00109, "epss_percentile": 0.29921}, "CVE-2023-48319": {"epss_score": 0.0022, "epss_percentile": 0.44545}, "CVE-2023-48320": {"epss_score": 0.00165, "epss_percentile": 0.38084}, "CVE-2023-48321": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-48322": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-48323": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-48324": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-48325": {"epss_score": 0.00238, "epss_percentile": 0.46819}, "CVE-2023-48326": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-48327": {"epss_score": 0.00146, "epss_percentile": 0.35588}, "CVE-2023-48328": {"epss_score": 0.00268, "epss_percentile": 0.50042}, "CVE-2023-48329": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-48330": {"epss_score": 0.00123, "epss_percentile": 0.32321}, "CVE-2023-48331": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-48332": {"epss_score": 0.0013, "epss_percentile": 0.33331}, "CVE-2023-48333": {"epss_score": 0.00679, "epss_percentile": 0.71007}, "CVE-2023-48334": {"epss_score": 0.00123, "epss_percentile": 0.32321}, "CVE-2023-48335": {"epss_score": 0.00572, "epss_percentile": 0.68036}, "CVE-2023-48336": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-48339": {"epss_score": 0.00012, "epss_percentile": 0.01263}, "CVE-2023-48340": {"epss_score": 9e-05, "epss_percentile": 0.00683}, "CVE-2023-48341": {"epss_score": 0.00012, "epss_percentile": 0.0118}, "CVE-2023-48342": {"epss_score": 8e-05, "epss_percentile": 0.00528}, "CVE-2023-48343": {"epss_score": 9e-05, "epss_percentile": 0.00683}, "CVE-2023-48344": {"epss_score": 0.00012, "epss_percentile": 0.0118}, "CVE-2023-48345": {"epss_score": 0.00012, "epss_percentile": 0.0118}, "CVE-2023-48346": {"epss_score": 0.00011, "epss_percentile": 0.01086}, "CVE-2023-48347": {"epss_score": 0.00012, "epss_percentile": 0.0118}, "CVE-2023-48348": {"epss_score": 9e-05, "epss_percentile": 0.00683}, "CVE-2023-48349": {"epss_score": 0.00012, "epss_percentile": 0.01295}, "CVE-2023-48350": {"epss_score": 0.00012, "epss_percentile": 0.01295}, "CVE-2023-48351": {"epss_score": 0.00012, "epss_percentile": 0.01295}, "CVE-2023-48352": {"epss_score": 0.00014, "epss_percentile": 0.02039}, "CVE-2023-48353": {"epss_score": 0.0001, "epss_percentile": 0.0091}, "CVE-2023-48354": {"epss_score": 9e-05, "epss_percentile": 0.0062}, "CVE-2023-48355": {"epss_score": 0.0001, "epss_percentile": 0.00798}, "CVE-2023-48356": {"epss_score": 0.0001, "epss_percentile": 0.00798}, "CVE-2023-48357": {"epss_score": 0.0001, "epss_percentile": 0.00798}, "CVE-2023-48358": {"epss_score": 0.0001, "epss_percentile": 0.00798}, "CVE-2023-48359": {"epss_score": 8e-05, "epss_percentile": 0.00483}, "CVE-2023-48360": {"epss_score": 0.00057, "epss_percentile": 0.17986}, "CVE-2023-48361": {"epss_score": 0.00044, "epss_percentile": 0.13615}, "CVE-2023-48362": {"epss_score": 0.0025, "epss_percentile": 0.4812}, "CVE-2023-48363": {"epss_score": 0.00094, "epss_percentile": 0.27042}, "CVE-2023-48364": {"epss_score": 0.00075, "epss_percentile": 0.23073}, "CVE-2023-48365": {"epss_score": 0.56805, "epss_percentile": 0.98037}, "CVE-2023-48366": {"epss_score": 0.00021, "epss_percentile": 0.04747}, "CVE-2023-48368": {"epss_score": 0.00027, "epss_percentile": 0.06927}, "CVE-2023-48369": {"epss_score": 0.00085, "epss_percentile": 0.25053}, "CVE-2023-48371": {"epss_score": 0.0061, "epss_percentile": 0.69145}, "CVE-2023-48372": {"epss_score": 0.00674, "epss_percentile": 0.70876}, "CVE-2023-48373": {"epss_score": 0.00102, "epss_percentile": 0.28763}, "CVE-2023-48374": {"epss_score": 0.00194, "epss_percentile": 0.41516}, "CVE-2023-48375": {"epss_score": 0.00152, "epss_percentile": 0.36498}, "CVE-2023-48376": {"epss_score": 0.00507, "epss_percentile": 0.65656}, "CVE-2023-48378": {"epss_score": 0.00161, "epss_percentile": 0.37542}, "CVE-2023-48379": {"epss_score": 0.00269, "epss_percentile": 0.50113}, "CVE-2023-48380": {"epss_score": 0.00306, "epss_percentile": 0.53407}, "CVE-2023-48381": {"epss_score": 0.00342, "epss_percentile": 0.56349}, "CVE-2023-48382": {"epss_score": 0.00342, "epss_percentile": 0.56349}, "CVE-2023-48383": {"epss_score": 0.00085, "epss_percentile": 0.25119}, "CVE-2023-48384": {"epss_score": 0.00477, "epss_percentile": 0.64337}, "CVE-2023-48387": {"epss_score": 0.01017, "epss_percentile": 0.76691}, "CVE-2023-48388": {"epss_score": 0.00648, "epss_percentile": 0.70216}, "CVE-2023-48389": {"epss_score": 0.00165, "epss_percentile": 0.38049}, "CVE-2023-48390": {"epss_score": 0.00753, "epss_percentile": 0.72675}, "CVE-2023-48392": {"epss_score": 0.00515, "epss_percentile": 0.65976}, "CVE-2023-48393": {"epss_score": 0.00196, "epss_percentile": 0.41812}, "CVE-2023-48394": {"epss_score": 0.00504, "epss_percentile": 0.65486}, "CVE-2023-48395": {"epss_score": 0.00228, "epss_percentile": 0.45525}, "CVE-2023-48396": {"epss_score": 0.00333, "epss_percentile": 0.55621}, "CVE-2023-48397": {"epss_score": 0.00204, "epss_percentile": 0.42641}, "CVE-2023-48398": {"epss_score": 0.00087, "epss_percentile": 0.25477}, "CVE-2023-48399": {"epss_score": 0.00017, "epss_percentile": 0.03098}, "CVE-2023-48401": {"epss_score": 0.00016, "epss_percentile": 0.0275}, "CVE-2023-48402": {"epss_score": 0.00012, "epss_percentile": 0.01165}, "CVE-2023-48403": {"epss_score": 0.00215, "epss_percentile": 0.44108}, "CVE-2023-48404": {"epss_score": 0.00303, "epss_percentile": 0.5321}, "CVE-2023-48405": {"epss_score": 0.00013, "epss_percentile": 0.01431}, "CVE-2023-48406": {"epss_score": 0.00011, "epss_percentile": 0.01028}, "CVE-2023-48407": {"epss_score": 0.00017, "epss_percentile": 0.03272}, "CVE-2023-48408": {"epss_score": 0.00017, "epss_percentile": 0.03098}, "CVE-2023-48409": {"epss_score": 0.00013, "epss_percentile": 0.01455}, "CVE-2023-48410": {"epss_score": 0.00303, "epss_percentile": 0.5321}, "CVE-2023-48411": {"epss_score": 0.00017, "epss_percentile": 0.03098}, "CVE-2023-48412": {"epss_score": 0.00019, "epss_percentile": 0.04204}, "CVE-2023-48413": {"epss_score": 0.00204, "epss_percentile": 0.42641}, "CVE-2023-48414": {"epss_score": 0.0001, "epss_percentile": 0.00821}, "CVE-2023-48415": {"epss_score": 0.00018, "epss_percentile": 0.03915}, "CVE-2023-48416": {"epss_score": 0.01083, "epss_percentile": 0.77393}, "CVE-2023-48417": {"epss_score": 0.00056, "epss_percentile": 0.17793}, "CVE-2023-48418": {"epss_score": 0.00057, "epss_percentile": 0.18096}, "CVE-2023-48419": {"epss_score": 0.00024, "epss_percentile": 0.0597}, "CVE-2023-48420": {"epss_score": 7e-05, "epss_percentile": 0.00462}, "CVE-2023-48421": {"epss_score": 9e-05, "epss_percentile": 0.00691}, "CVE-2023-48422": {"epss_score": 0.00018, "epss_percentile": 0.03915}, "CVE-2023-48423": {"epss_score": 0.00831, "epss_percentile": 0.74045}, "CVE-2023-48424": {"epss_score": 0.00077, "epss_percentile": 0.23462}, "CVE-2023-48425": {"epss_score": 0.00118, "epss_percentile": 0.31504}, "CVE-2023-48426": {"epss_score": 0.00105, "epss_percentile": 0.29356}, "CVE-2023-48427": {"epss_score": 0.00078, "epss_percentile": 0.23737}, "CVE-2023-48428": {"epss_score": 0.00067, "epss_percentile": 0.21063}, "CVE-2023-48429": {"epss_score": 0.00118, "epss_percentile": 0.3152}, "CVE-2023-48430": {"epss_score": 0.00102, "epss_percentile": 0.28739}, "CVE-2023-48431": {"epss_score": 0.0017, "epss_percentile": 0.38651}, "CVE-2023-48432": {"epss_score": 0.00554, "epss_percentile": 0.67438}, "CVE-2023-48433": {"epss_score": 0.0007, "epss_percentile": 0.21985}, "CVE-2023-48434": {"epss_score": 0.00068, "epss_percentile": 0.21404}, "CVE-2023-48440": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48441": {"epss_score": 0.00157, "epss_percentile": 0.37055}, "CVE-2023-48442": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48443": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48444": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48445": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48446": {"epss_score": 0.00391, "epss_percentile": 0.59633}, "CVE-2023-48447": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48448": {"epss_score": 0.00391, "epss_percentile": 0.59633}, "CVE-2023-48449": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48450": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48451": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48452": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48453": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48454": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48455": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48456": {"epss_score": 0.00437, "epss_percentile": 0.62517}, "CVE-2023-48457": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48458": {"epss_score": 0.00437, "epss_percentile": 0.62517}, "CVE-2023-48459": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48460": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48461": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48462": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48463": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48464": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48465": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48466": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48467": {"epss_score": 0.00437, "epss_percentile": 0.62517}, "CVE-2023-48468": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48469": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48470": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48471": {"epss_score": 0.00483, "epss_percentile": 0.64568}, "CVE-2023-48472": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48473": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48474": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48475": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48476": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48477": {"epss_score": 0.00483, "epss_percentile": 0.64568}, "CVE-2023-48478": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48479": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48480": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48481": {"epss_score": 0.00483, "epss_percentile": 0.64568}, "CVE-2023-48482": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48483": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48484": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48485": {"epss_score": 0.00391, "epss_percentile": 0.59633}, "CVE-2023-48486": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48487": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48488": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48489": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48490": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48491": {"epss_score": 0.00437, "epss_percentile": 0.62517}, "CVE-2023-48492": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48493": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48494": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48495": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48496": {"epss_score": 0.00391, "epss_percentile": 0.59633}, "CVE-2023-48497": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48498": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48499": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48500": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48501": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48502": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48503": {"epss_score": 0.00483, "epss_percentile": 0.64568}, "CVE-2023-48504": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48505": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48506": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48507": {"epss_score": 0.00437, "epss_percentile": 0.62517}, "CVE-2023-48508": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48509": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48510": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48511": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48512": {"epss_score": 0.00437, "epss_percentile": 0.62517}, "CVE-2023-48513": {"epss_score": 0.00253, "epss_percentile": 0.48434}, "CVE-2023-48514": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48515": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48516": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48517": {"epss_score": 0.00437, "epss_percentile": 0.62517}, "CVE-2023-48518": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48519": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48520": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48521": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48522": {"epss_score": 0.00437, "epss_percentile": 0.62517}, "CVE-2023-48523": {"epss_score": 0.00286, "epss_percentile": 0.51694}, "CVE-2023-48524": {"epss_score": 0.00229, "epss_percentile": 0.45582}, "CVE-2023-48525": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48526": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48527": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48528": {"epss_score": 0.00391, "epss_percentile": 0.59633}, "CVE-2023-48529": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48530": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48531": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48532": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48533": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48534": {"epss_score": 0.00391, "epss_percentile": 0.59633}, "CVE-2023-48535": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48536": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48537": {"epss_score": 0.00205, "epss_percentile": 0.42697}, "CVE-2023-48538": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48539": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48540": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48541": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48542": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48543": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48544": {"epss_score": 0.0057, "epss_percentile": 0.67957}, "CVE-2023-48545": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48546": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48547": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48548": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48549": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48550": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48551": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48552": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48553": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48554": {"epss_score": 0.0057, "epss_percentile": 0.67957}, "CVE-2023-48555": {"epss_score": 0.00258, "epss_percentile": 0.49022}, "CVE-2023-48556": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48557": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48558": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48559": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48560": {"epss_score": 0.00258, "epss_percentile": 0.49022}, "CVE-2023-48561": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48562": {"epss_score": 0.00258, "epss_percentile": 0.49022}, "CVE-2023-48563": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48564": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48565": {"epss_score": 0.0057, "epss_percentile": 0.67957}, "CVE-2023-48566": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48567": {"epss_score": 0.00516, "epss_percentile": 0.66053}, "CVE-2023-48568": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48569": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48570": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48571": {"epss_score": 0.0057, "epss_percentile": 0.67957}, "CVE-2023-48572": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48573": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48574": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48575": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48576": {"epss_score": 0.00319, "epss_percentile": 0.54494}, "CVE-2023-48577": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48578": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48579": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48580": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48581": {"epss_score": 0.00258, "epss_percentile": 0.49022}, "CVE-2023-48582": {"epss_score": 0.00258, "epss_percentile": 0.49022}, "CVE-2023-48583": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48584": {"epss_score": 0.00258, "epss_percentile": 0.49022}, "CVE-2023-48585": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48586": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48587": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48588": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48589": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48590": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48591": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48592": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48593": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48594": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48595": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48596": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48597": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48598": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48599": {"epss_score": 0.00307, "epss_percentile": 0.53534}, "CVE-2023-48600": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48601": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48602": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48603": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48604": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48605": {"epss_score": 0.00258, "epss_percentile": 0.49022}, "CVE-2023-48606": {"epss_score": 0.00289, "epss_percentile": 0.51994}, "CVE-2023-48607": {"epss_score": 0.00964, "epss_percentile": 0.76033}, "CVE-2023-48608": {"epss_score": 0.00556, "epss_percentile": 0.67517}, "CVE-2023-48609": {"epss_score": 0.01075, "epss_percentile": 0.7732}, "CVE-2023-48610": {"epss_score": 0.00964, "epss_percentile": 0.76033}, "CVE-2023-48611": {"epss_score": 0.00964, "epss_percentile": 0.76033}, "CVE-2023-48612": {"epss_score": 0.01075, "epss_percentile": 0.7732}, "CVE-2023-48613": {"epss_score": 0.01075, "epss_percentile": 0.7732}, "CVE-2023-48614": {"epss_score": 0.01075, "epss_percentile": 0.7732}, "CVE-2023-48615": {"epss_score": 0.00964, "epss_percentile": 0.76033}, "CVE-2023-48616": {"epss_score": 0.01075, "epss_percentile": 0.7732}, "CVE-2023-48617": {"epss_score": 0.01075, "epss_percentile": 0.7732}, "CVE-2023-48618": {"epss_score": 0.00964, "epss_percentile": 0.76033}, "CVE-2023-48619": {"epss_score": 0.01075, "epss_percentile": 0.7732}, "CVE-2023-48620": {"epss_score": 0.01075, "epss_percentile": 0.7732}, "CVE-2023-48621": {"epss_score": 0.01075, "epss_percentile": 0.7732}, "CVE-2023-48622": {"epss_score": 0.01075, "epss_percentile": 0.7732}, "CVE-2023-48623": {"epss_score": 0.00964, "epss_percentile": 0.76033}, "CVE-2023-48624": {"epss_score": 0.00964, "epss_percentile": 0.76033}, "CVE-2023-48625": {"epss_score": 0.00096, "epss_percentile": 0.27368}, "CVE-2023-48626": {"epss_score": 0.00096, "epss_percentile": 0.27368}, "CVE-2023-48627": {"epss_score": 0.00047, "epss_percentile": 0.14592}, "CVE-2023-48628": {"epss_score": 0.00047, "epss_percentile": 0.14592}, "CVE-2023-48629": {"epss_score": 0.00047, "epss_percentile": 0.14592}, "CVE-2023-48630": {"epss_score": 0.00096, "epss_percentile": 0.27368}, "CVE-2023-48631": {"epss_score": 0.00468, "epss_percentile": 0.63911}, "CVE-2023-48632": {"epss_score": 0.00049, "epss_percentile": 0.15578}, "CVE-2023-48633": {"epss_score": 0.00066, "epss_percentile": 0.20825}, "CVE-2023-48634": {"epss_score": 0.00051, "epss_percentile": 0.16268}, "CVE-2023-48635": {"epss_score": 0.00031, "epss_percentile": 0.08691}, "CVE-2023-48636": {"epss_score": 0.00012, "epss_percentile": 0.0129}, "CVE-2023-48637": {"epss_score": 0.0002, "epss_percentile": 0.04496}, "CVE-2023-48638": {"epss_score": 0.00013, "epss_percentile": 0.01708}, "CVE-2023-48639": {"epss_score": 0.00168, "epss_percentile": 0.38456}, "CVE-2023-48641": {"epss_score": 9e-05, "epss_percentile": 0.0061}, "CVE-2023-48642": {"epss_score": 0.00209, "epss_percentile": 0.43334}, "CVE-2023-48643": {"epss_score": 0.09108, "epss_percentile": 0.92403}, "CVE-2023-48644": {"epss_score": 0.00088, "epss_percentile": 0.25679}, "CVE-2023-48645": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2023-48646": {"epss_score": 0.62621, "epss_percentile": 0.983}, "CVE-2023-48648": {"epss_score": 0.00729, "epss_percentile": 0.72132}, "CVE-2023-48649": {"epss_score": 0.01256, "epss_percentile": 0.78939}, "CVE-2023-48650": {"epss_score": 0.01115, "epss_percentile": 0.77709}, "CVE-2023-48651": {"epss_score": 0.00643, "epss_percentile": 0.70047}, "CVE-2023-48652": {"epss_score": 0.00256, "epss_percentile": 0.48792}, "CVE-2023-48653": {"epss_score": 0.00643, "epss_percentile": 0.70047}, "CVE-2023-48654": {"epss_score": 0.00191, "epss_percentile": 0.4121}, "CVE-2023-48655": {"epss_score": 0.00097, "epss_percentile": 0.27615}, "CVE-2023-48656": {"epss_score": 0.00097, "epss_percentile": 0.27615}, "CVE-2023-48657": {"epss_score": 0.00097, "epss_percentile": 0.27615}, "CVE-2023-48658": {"epss_score": 0.00097, "epss_percentile": 0.27615}, "CVE-2023-48659": {"epss_score": 0.00125, "epss_percentile": 0.32531}, "CVE-2023-48660": {"epss_score": 0.00268, "epss_percentile": 0.50071}, "CVE-2023-48661": {"epss_score": 0.00154, "epss_percentile": 0.36714}, "CVE-2023-48662": {"epss_score": 0.00156, "epss_percentile": 0.36898}, "CVE-2023-48663": {"epss_score": 0.00147, "epss_percentile": 0.35798}, "CVE-2023-48664": {"epss_score": 0.00156, "epss_percentile": 0.36898}, "CVE-2023-48665": {"epss_score": 0.00156, "epss_percentile": 0.36898}, "CVE-2023-48667": {"epss_score": 0.00033, "epss_percentile": 0.09362}, "CVE-2023-48668": {"epss_score": 0.00038, "epss_percentile": 0.11423}, "CVE-2023-48670": {"epss_score": 0.0004, "epss_percentile": 0.11925}, "CVE-2023-48671": {"epss_score": 0.00264, "epss_percentile": 0.49682}, "CVE-2023-48674": {"epss_score": 0.00126, "epss_percentile": 0.32626}, "CVE-2023-48676": {"epss_score": 0.00068, "epss_percentile": 0.21379}, "CVE-2023-48677": {"epss_score": 0.00044, "epss_percentile": 0.13679}, "CVE-2023-48678": {"epss_score": 0.0005, "epss_percentile": 0.15895}, "CVE-2023-48679": {"epss_score": 0.00501, "epss_percentile": 0.65346}, "CVE-2023-48680": {"epss_score": 0.00129, "epss_percentile": 0.33188}, "CVE-2023-48681": {"epss_score": 0.00574, "epss_percentile": 0.68096}, "CVE-2023-48682": {"epss_score": 0.00122, "epss_percentile": 0.32057}, "CVE-2023-48683": {"epss_score": 0.00061, "epss_percentile": 0.19262}, "CVE-2023-48684": {"epss_score": 0.00062, "epss_percentile": 0.19777}, "CVE-2023-48685": {"epss_score": 0.00153, "epss_percentile": 0.36555}, "CVE-2023-48687": {"epss_score": 0.00153, "epss_percentile": 0.36555}, "CVE-2023-48689": {"epss_score": 0.00153, "epss_percentile": 0.36555}, "CVE-2023-48691": {"epss_score": 0.01463, "epss_percentile": 0.80442}, "CVE-2023-48692": {"epss_score": 0.04352, "epss_percentile": 0.88585}, "CVE-2023-48693": {"epss_score": 0.00685, "epss_percentile": 0.71153}, "CVE-2023-48694": {"epss_score": 0.03999, "epss_percentile": 0.8809}, "CVE-2023-48695": {"epss_score": 0.00955, "epss_percentile": 0.75916}, "CVE-2023-48696": {"epss_score": 0.00328, "epss_percentile": 0.55159}, "CVE-2023-48697": {"epss_score": 0.02853, "epss_percentile": 0.85833}, "CVE-2023-48698": {"epss_score": 0.01633, "epss_percentile": 0.81461}, "CVE-2023-48699": {"epss_score": 0.00642, "epss_percentile": 0.70025}, "CVE-2023-48700": {"epss_score": 0.00149, "epss_percentile": 0.35933}, "CVE-2023-48701": {"epss_score": 0.00731, "epss_percentile": 0.72169}, "CVE-2023-48702": {"epss_score": 0.00744, "epss_percentile": 0.72514}, "CVE-2023-48703": {"epss_score": 0.00013, "epss_percentile": 0.01557}, "CVE-2023-48704": {"epss_score": 0.00362, "epss_percentile": 0.5778}, "CVE-2023-48705": {"epss_score": 0.00295, "epss_percentile": 0.52514}, "CVE-2023-48706": {"epss_score": 0.00132, "epss_percentile": 0.33525}, "CVE-2023-48707": {"epss_score": 0.00059, "epss_percentile": 0.18911}, "CVE-2023-48708": {"epss_score": 0.00164, "epss_percentile": 0.37958}, "CVE-2023-48709": {"epss_score": 0.03021, "epss_percentile": 0.86225}, "CVE-2023-48710": {"epss_score": 0.00427, "epss_percentile": 0.61879}, "CVE-2023-48711": {"epss_score": 0.00063, "epss_percentile": 0.19914}, "CVE-2023-48712": {"epss_score": 0.00209, "epss_percentile": 0.43413}, "CVE-2023-48713": {"epss_score": 0.00073, "epss_percentile": 0.22611}, "CVE-2023-48714": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2023-48715": {"epss_score": 0.00503, "epss_percentile": 0.65446}, "CVE-2023-48716": {"epss_score": 0.00153, "epss_percentile": 0.36555}, "CVE-2023-48718": {"epss_score": 0.00158, "epss_percentile": 0.37167}, "CVE-2023-48720": {"epss_score": 0.00153, "epss_percentile": 0.36555}, "CVE-2023-48722": {"epss_score": 0.00153, "epss_percentile": 0.36555}, "CVE-2023-48724": {"epss_score": 0.00427, "epss_percentile": 0.61772}, "CVE-2023-48725": {"epss_score": 0.31011, "epss_percentile": 0.96582}, "CVE-2023-48727": {"epss_score": 0.00028, "epss_percentile": 0.07337}, "CVE-2023-48728": {"epss_score": 0.17352, "epss_percentile": 0.94832}, "CVE-2023-48730": {"epss_score": 0.00477, "epss_percentile": 0.64354}, "CVE-2023-48732": {"epss_score": 0.005, "epss_percentile": 0.65324}, "CVE-2023-48733": {"epss_score": 0.00019, "epss_percentile": 0.04279}, "CVE-2023-48736": {"epss_score": 0.00125, "epss_percentile": 0.32549}, "CVE-2023-48737": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-48738": {"epss_score": 0.00154, "epss_percentile": 0.36737}, "CVE-2023-48739": {"epss_score": 0.00194, "epss_percentile": 0.41536}, "CVE-2023-48740": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-48741": {"epss_score": 0.00146, "epss_percentile": 0.35588}, "CVE-2023-48742": {"epss_score": 0.00252, "epss_percentile": 0.48408}, "CVE-2023-48743": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-48744": {"epss_score": 0.00123, "epss_percentile": 0.32324}, "CVE-2023-48745": {"epss_score": 0.00114, "epss_percentile": 0.3081}, "CVE-2023-48746": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-48747": {"epss_score": 0.00703, "epss_percentile": 0.71534}, "CVE-2023-48748": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-48749": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-48750": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2023-48751": {"epss_score": 0.00063, "epss_percentile": 0.19853}, "CVE-2023-48752": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-48753": {"epss_score": 0.00114, "epss_percentile": 0.3081}, "CVE-2023-48754": {"epss_score": 0.00123, "epss_percentile": 0.32324}, "CVE-2023-48755": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-48756": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-48757": {"epss_score": 0.00173, "epss_percentile": 0.39078}, "CVE-2023-48758": {"epss_score": 0.00146, "epss_percentile": 0.35569}, "CVE-2023-48759": {"epss_score": 0.00482, "epss_percentile": 0.64551}, "CVE-2023-48760": {"epss_score": 0.00255, "epss_percentile": 0.48674}, "CVE-2023-48761": {"epss_score": 0.00104, "epss_percentile": 0.292}, "CVE-2023-48762": {"epss_score": 0.00068, "epss_percentile": 0.2141}, "CVE-2023-48763": {"epss_score": 0.00091, "epss_percentile": 0.26265}, "CVE-2023-48764": {"epss_score": 0.00146, "epss_percentile": 0.35588}, "CVE-2023-48765": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-48766": {"epss_score": 0.00082, "epss_percentile": 0.24424}, "CVE-2023-48767": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-48768": {"epss_score": 0.00082, "epss_percentile": 0.24424}, "CVE-2023-48769": {"epss_score": 0.00074, "epss_percentile": 0.2276}, "CVE-2023-48770": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-48771": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-48772": {"epss_score": 0.00059, "epss_percentile": 0.18739}, "CVE-2023-48773": {"epss_score": 0.00059, "epss_percentile": 0.18739}, "CVE-2023-48774": {"epss_score": 0.00157, "epss_percentile": 0.37074}, "CVE-2023-48775": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-48776": {"epss_score": 0.00142, "epss_percentile": 0.35024}, "CVE-2023-48777": {"epss_score": 0.91046, "epss_percentile": 0.99616}, "CVE-2023-48778": {"epss_score": 0.00059, "epss_percentile": 0.18737}, "CVE-2023-48779": {"epss_score": 0.00186, "epss_percentile": 0.40628}, "CVE-2023-48780": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-48781": {"epss_score": 0.00137, "epss_percentile": 0.3421}, "CVE-2023-48782": {"epss_score": 0.05699, "epss_percentile": 0.9013}, "CVE-2023-48783": {"epss_score": 0.00264, "epss_percentile": 0.49571}, "CVE-2023-48784": {"epss_score": 0.00079, "epss_percentile": 0.23993}, "CVE-2023-48785": {"epss_score": 0.0011, "epss_percentile": 0.30079}, "CVE-2023-48786": {"epss_score": 0.0003, "epss_percentile": 0.08299}, "CVE-2023-48788": {"epss_score": 0.9416, "epss_percentile": 0.9991}, "CVE-2023-48789": {"epss_score": 0.00577, "epss_percentile": 0.6815}, "CVE-2023-48790": {"epss_score": 0.00022, "epss_percentile": 0.0519}, "CVE-2023-48791": {"epss_score": 0.02073, "epss_percentile": 0.83492}, "CVE-2023-48792": {"epss_score": 0.08622, "epss_percentile": 0.92158}, "CVE-2023-48793": {"epss_score": 0.08622, "epss_percentile": 0.92158}, "CVE-2023-48795": {"epss_score": 0.57768, "epss_percentile": 0.98082}, "CVE-2023-48796": {"epss_score": 0.00534, "epss_percentile": 0.66796}, "CVE-2023-48799": {"epss_score": 0.00721, "epss_percentile": 0.7198}, "CVE-2023-48800": {"epss_score": 0.00711, "epss_percentile": 0.71733}, "CVE-2023-48801": {"epss_score": 0.0027, "epss_percentile": 0.5021}, "CVE-2023-48802": {"epss_score": 0.00349, "epss_percentile": 0.56898}, "CVE-2023-48803": {"epss_score": 0.00349, "epss_percentile": 0.56898}, "CVE-2023-48804": {"epss_score": 0.00349, "epss_percentile": 0.56898}, "CVE-2023-48805": {"epss_score": 0.00349, "epss_percentile": 0.56898}, "CVE-2023-48806": {"epss_score": 0.00349, "epss_percentile": 0.56898}, "CVE-2023-48807": {"epss_score": 0.00349, "epss_percentile": 0.56898}, "CVE-2023-48808": {"epss_score": 0.00349, "epss_percentile": 0.56898}, "CVE-2023-48810": {"epss_score": 0.00349, "epss_percentile": 0.56898}, "CVE-2023-48811": {"epss_score": 0.00349, "epss_percentile": 0.56898}, "CVE-2023-48812": {"epss_score": 0.00349, "epss_percentile": 0.56898}, "CVE-2023-48813": {"epss_score": 0.00111, "epss_percentile": 0.30402}, "CVE-2023-48815": {"epss_score": 0.00234, "epss_percentile": 0.46151}, "CVE-2023-48823": {"epss_score": 0.00177, "epss_percentile": 0.39601}, "CVE-2023-48824": {"epss_score": 0.00193, "epss_percentile": 0.41494}, "CVE-2023-48825": {"epss_score": 0.00202, "epss_percentile": 0.42394}, "CVE-2023-48826": {"epss_score": 0.00228, "epss_percentile": 0.45544}, "CVE-2023-48827": {"epss_score": 0.00205, "epss_percentile": 0.42678}, "CVE-2023-48828": {"epss_score": 0.00196, "epss_percentile": 0.41818}, "CVE-2023-48830": {"epss_score": 0.00228, "epss_percentile": 0.45544}, "CVE-2023-48831": {"epss_score": 0.00298, "epss_percentile": 0.52818}, "CVE-2023-48833": {"epss_score": 0.00169, "epss_percentile": 0.38615}, "CVE-2023-48834": {"epss_score": 0.00169, "epss_percentile": 0.38615}, "CVE-2023-48835": {"epss_score": 0.00228, "epss_percentile": 0.45544}, "CVE-2023-48836": {"epss_score": 0.00196, "epss_percentile": 0.41818}, "CVE-2023-48837": {"epss_score": 0.00185, "epss_percentile": 0.4053}, "CVE-2023-48838": {"epss_score": 0.00176, "epss_percentile": 0.39467}, "CVE-2023-48839": {"epss_score": 0.00169, "epss_percentile": 0.38625}, "CVE-2023-48840": {"epss_score": 0.00144, "epss_percentile": 0.35236}, "CVE-2023-48841": {"epss_score": 0.00217, "epss_percentile": 0.44328}, "CVE-2023-48842": {"epss_score": 0.27243, "epss_percentile": 0.96224}, "CVE-2023-48848": {"epss_score": 0.0009, "epss_percentile": 0.26094}, "CVE-2023-48849": {"epss_score": 0.02817, "epss_percentile": 0.85737}, "CVE-2023-48858": {"epss_score": 0.00176, "epss_percentile": 0.39491}, "CVE-2023-48859": {"epss_score": 0.00057, "epss_percentile": 0.18028}, "CVE-2023-48860": {"epss_score": 0.00146, "epss_percentile": 0.35633}, "CVE-2023-48861": {"epss_score": 0.00044, "epss_percentile": 0.13374}, "CVE-2023-48863": {"epss_score": 0.00151, "epss_percentile": 0.36304}, "CVE-2023-48864": {"epss_score": 0.00117, "epss_percentile": 0.31201}, "CVE-2023-48865": {"epss_score": 0.00068, "epss_percentile": 0.2129}, "CVE-2023-48866": {"epss_score": 0.00339, "epss_percentile": 0.56202}, "CVE-2023-48880": {"epss_score": 0.00147, "epss_percentile": 0.35652}, "CVE-2023-48881": {"epss_score": 0.00136, "epss_percentile": 0.34171}, "CVE-2023-48882": {"epss_score": 0.00123, "epss_percentile": 0.32317}, "CVE-2023-48886": {"epss_score": 0.0008, "epss_percentile": 0.24139}, "CVE-2023-48887": {"epss_score": 0.00089, "epss_percentile": 0.2587}, "CVE-2023-48893": {"epss_score": 0.00111, "epss_percentile": 0.30402}, "CVE-2023-48894": {"epss_score": 0.00198, "epss_percentile": 0.42062}, "CVE-2023-48901": {"epss_score": 0.00705, "epss_percentile": 0.71585}, "CVE-2023-48902": {"epss_score": 0.00209, "epss_percentile": 0.43309}, "CVE-2023-48903": {"epss_score": 0.00186, "epss_percentile": 0.40681}, "CVE-2023-48906": {"epss_score": 0.00088, "epss_percentile": 0.2572}, "CVE-2023-48909": {"epss_score": 0.00486, "epss_percentile": 0.64742}, "CVE-2023-48910": {"epss_score": 0.00259, "epss_percentile": 0.49039}, "CVE-2023-48912": {"epss_score": 0.00167, "epss_percentile": 0.38318}, "CVE-2023-48913": {"epss_score": 0.00167, "epss_percentile": 0.38318}, "CVE-2023-48914": {"epss_score": 0.00167, "epss_percentile": 0.38318}, "CVE-2023-48925": {"epss_score": 0.0016, "epss_percentile": 0.37491}, "CVE-2023-48926": {"epss_score": 0.00259, "epss_percentile": 0.49037}, "CVE-2023-48928": {"epss_score": 0.00063, "epss_percentile": 0.19874}, "CVE-2023-48929": {"epss_score": 0.00072, "epss_percentile": 0.22407}, "CVE-2023-48930": {"epss_score": 0.00165, "epss_percentile": 0.38102}, "CVE-2023-48940": {"epss_score": 0.00087, "epss_percentile": 0.25534}, "CVE-2023-48945": {"epss_score": 0.0011, "epss_percentile": 0.30236}, "CVE-2023-48946": {"epss_score": 0.00091, "epss_percentile": 0.26204}, "CVE-2023-48947": {"epss_score": 0.00091, "epss_percentile": 0.26204}, "CVE-2023-48948": {"epss_score": 0.00067, "epss_percentile": 0.21025}, "CVE-2023-48949": {"epss_score": 0.00067, "epss_percentile": 0.21025}, "CVE-2023-48950": {"epss_score": 0.00091, "epss_percentile": 0.26204}, "CVE-2023-48951": {"epss_score": 0.00066, "epss_percentile": 0.20675}, "CVE-2023-48952": {"epss_score": 0.00083, "epss_percentile": 0.24717}, "CVE-2023-48957": {"epss_score": 0.00036, "epss_percentile": 0.10434}, "CVE-2023-48958": {"epss_score": 0.00026, "epss_percentile": 0.06676}, "CVE-2023-48963": {"epss_score": 0.00198, "epss_percentile": 0.42043}, "CVE-2023-48964": {"epss_score": 0.00198, "epss_percentile": 0.42043}, "CVE-2023-48965": {"epss_score": 0.00239, "epss_percentile": 0.46882}, "CVE-2023-48966": {"epss_score": 0.00198, "epss_percentile": 0.41977}, "CVE-2023-48967": {"epss_score": 0.00215, "epss_percentile": 0.44036}, "CVE-2023-48974": {"epss_score": 0.06582, "epss_percentile": 0.90862}, "CVE-2023-48978": {"epss_score": 0.00308, "epss_percentile": 0.53596}, "CVE-2023-48985": {"epss_score": 0.00268, "epss_percentile": 0.50088}, "CVE-2023-48986": {"epss_score": 0.00268, "epss_percentile": 0.50088}, "CVE-2023-48987": {"epss_score": 0.00517, "epss_percentile": 0.6606}, "CVE-2023-49000": {"epss_score": 0.00064, "epss_percentile": 0.2035}, "CVE-2023-49001": {"epss_score": 0.00057, "epss_percentile": 0.17981}, "CVE-2023-49002": {"epss_score": 0.00224, "epss_percentile": 0.45018}, "CVE-2023-49003": {"epss_score": 0.00271, "epss_percentile": 0.50329}, "CVE-2023-49004": {"epss_score": 0.01362, "epss_percentile": 0.79761}, "CVE-2023-49006": {"epss_score": 0.00278, "epss_percentile": 0.50848}, "CVE-2023-49007": {"epss_score": 0.0819, "epss_percentile": 0.91921}, "CVE-2023-49028": {"epss_score": 0.00312, "epss_percentile": 0.54006}, "CVE-2023-49029": {"epss_score": 0.00318, "epss_percentile": 0.5446}, "CVE-2023-49030": {"epss_score": 0.00065, "epss_percentile": 0.20443}, "CVE-2023-49031": {"epss_score": 6e-05, "epss_percentile": 0.00294}, "CVE-2023-49032": {"epss_score": 0.02575, "epss_percentile": 0.8514}, "CVE-2023-49034": {"epss_score": 0.0019, "epss_percentile": 0.41081}, "CVE-2023-49038": {"epss_score": 0.0147, "epss_percentile": 0.80498}, "CVE-2023-49040": {"epss_score": 0.02807, "epss_percentile": 0.8571}, "CVE-2023-49042": {"epss_score": 0.01656, "epss_percentile": 0.81599}, "CVE-2023-49043": {"epss_score": 0.32605, "epss_percentile": 0.9671}, "CVE-2023-49044": {"epss_score": 0.01656, "epss_percentile": 0.81599}, "CVE-2023-49046": {"epss_score": 0.01656, "epss_percentile": 0.81599}, "CVE-2023-49047": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2023-49052": {"epss_score": 0.26275, "epss_percentile": 0.96133}, "CVE-2023-49058": {"epss_score": 0.00113, "epss_percentile": 0.30733}, "CVE-2023-49060": {"epss_score": 0.00461, "epss_percentile": 0.63553}, "CVE-2023-49061": {"epss_score": 0.002, "epss_percentile": 0.42218}, "CVE-2023-49062": {"epss_score": 0.00178, "epss_percentile": 0.39699}, "CVE-2023-49068": {"epss_score": 0.0016, "epss_percentile": 0.37444}, "CVE-2023-49069": {"epss_score": 0.00258, "epss_percentile": 0.48962}, "CVE-2023-49070": {"epss_score": 0.9396, "epss_percentile": 0.99875}, "CVE-2023-49073": {"epss_score": 0.00528, "epss_percentile": 0.66556}, "CVE-2023-49074": {"epss_score": 0.05797, "epss_percentile": 0.90218}, "CVE-2023-49075": {"epss_score": 0.00013, "epss_percentile": 0.01432}, "CVE-2023-49076": {"epss_score": 6e-05, "epss_percentile": 0.0024}, "CVE-2023-49077": {"epss_score": 0.00427, "epss_percentile": 0.61777}, "CVE-2023-49078": {"epss_score": 0.00568, "epss_percentile": 0.67898}, "CVE-2023-49079": {"epss_score": 0.00136, "epss_percentile": 0.34198}, "CVE-2023-49080": {"epss_score": 0.00237, "epss_percentile": 0.46665}, "CVE-2023-49081": {"epss_score": 0.00496, "epss_percentile": 0.65167}, "CVE-2023-49082": {"epss_score": 0.00241, "epss_percentile": 0.47237}, "CVE-2023-49083": {"epss_score": 0.01255, "epss_percentile": 0.78926}, "CVE-2023-49084": {"epss_score": 0.88341, "epss_percentile": 0.99467}, "CVE-2023-49085": {"epss_score": 0.91246, "epss_percentile": 0.99629}, "CVE-2023-49086": {"epss_score": 0.00792, "epss_percentile": 0.73411}, "CVE-2023-49087": {"epss_score": 0.00205, "epss_percentile": 0.42687}, "CVE-2023-49088": {"epss_score": 0.00982, "epss_percentile": 0.76286}, "CVE-2023-49089": {"epss_score": 0.00122, "epss_percentile": 0.32036}, "CVE-2023-49090": {"epss_score": 0.00141, "epss_percentile": 0.34948}, "CVE-2023-49091": {"epss_score": 0.00438, "epss_percentile": 0.62547}, "CVE-2023-49092": {"epss_score": 0.00742, "epss_percentile": 0.72451}, "CVE-2023-49093": {"epss_score": 0.0272, "epss_percentile": 0.85517}, "CVE-2023-49094": {"epss_score": 0.00336, "epss_percentile": 0.55914}, "CVE-2023-49095": {"epss_score": 0.00277, "epss_percentile": 0.50785}, "CVE-2023-49096": {"epss_score": 0.01373, "epss_percentile": 0.79819}, "CVE-2023-49097": {"epss_score": 0.00385, "epss_percentile": 0.59211}, "CVE-2023-49098": {"epss_score": 0.00177, "epss_percentile": 0.39567}, "CVE-2023-49099": {"epss_score": 0.00286, "epss_percentile": 0.51755}, "CVE-2023-49100": {"epss_score": 0.00016, "epss_percentile": 0.02648}, "CVE-2023-49101": {"epss_score": 0.00255, "epss_percentile": 0.48683}, "CVE-2023-49102": {"epss_score": 0.01715, "epss_percentile": 0.81896}, "CVE-2023-49103": {"epss_score": 0.94329, "epss_percentile": 0.99949}, "CVE-2023-49104": {"epss_score": 0.00058, "epss_percentile": 0.18282}, "CVE-2023-49105": {"epss_score": 0.89605, "epss_percentile": 0.99533}, "CVE-2023-49106": {"epss_score": 0.00078, "epss_percentile": 0.23575}, "CVE-2023-49107": {"epss_score": 0.00098, "epss_percentile": 0.27705}, "CVE-2023-49108": {"epss_score": 0.00304, "epss_percentile": 0.53262}, "CVE-2023-49109": {"epss_score": 0.05382, "epss_percentile": 0.89811}, "CVE-2023-49110": {"epss_score": 0.00111, "epss_percentile": 0.30346}, "CVE-2023-49111": {"epss_score": 0.00296, "epss_percentile": 0.52599}, "CVE-2023-49112": {"epss_score": 0.00127, "epss_percentile": 0.32803}, "CVE-2023-49113": {"epss_score": 0.00031, "epss_percentile": 0.08624}, "CVE-2023-49114": {"epss_score": 0.00055, "epss_percentile": 0.17574}, "CVE-2023-49115": {"epss_score": 0.00063, "epss_percentile": 0.19912}, "CVE-2023-49117": {"epss_score": 0.002, "epss_percentile": 0.42199}, "CVE-2023-49118": {"epss_score": 0.00032, "epss_percentile": 0.08996}, "CVE-2023-49119": {"epss_score": 0.00492, "epss_percentile": 0.65001}, "CVE-2023-49121": {"epss_score": 0.00163, "epss_percentile": 0.37824}, "CVE-2023-49122": {"epss_score": 0.0015, "epss_percentile": 0.36101}, "CVE-2023-49123": {"epss_score": 0.0015, "epss_percentile": 0.36101}, "CVE-2023-49124": {"epss_score": 0.00166, "epss_percentile": 0.38224}, "CVE-2023-49125": {"epss_score": 0.00031, "epss_percentile": 0.08395}, "CVE-2023-49126": {"epss_score": 0.00166, "epss_percentile": 0.38224}, "CVE-2023-49127": {"epss_score": 0.00166, "epss_percentile": 0.38224}, "CVE-2023-49128": {"epss_score": 0.00127, "epss_percentile": 0.32845}, "CVE-2023-49129": {"epss_score": 0.0015, "epss_percentile": 0.36101}, "CVE-2023-49130": {"epss_score": 0.00127, "epss_percentile": 0.32845}, "CVE-2023-49131": {"epss_score": 0.00127, "epss_percentile": 0.32845}, "CVE-2023-49132": {"epss_score": 0.00138, "epss_percentile": 0.34459}, "CVE-2023-49133": {"epss_score": 0.0052, "epss_percentile": 0.66189}, "CVE-2023-49134": {"epss_score": 0.0052, "epss_percentile": 0.66189}, "CVE-2023-49135": {"epss_score": 0.00048, "epss_percentile": 0.15244}, "CVE-2023-49140": {"epss_score": 0.00573, "epss_percentile": 0.68064}, "CVE-2023-49141": {"epss_score": 0.00062, "epss_percentile": 0.19606}, "CVE-2023-49142": {"epss_score": 0.00055, "epss_percentile": 0.17424}, "CVE-2023-49143": {"epss_score": 0.00573, "epss_percentile": 0.68064}, "CVE-2023-49144": {"epss_score": 0.00054, "epss_percentile": 0.17106}, "CVE-2023-49145": {"epss_score": 0.00293, "epss_percentile": 0.52285}, "CVE-2023-49146": {"epss_score": 0.00094, "epss_percentile": 0.27042}, "CVE-2023-49147": {"epss_score": 0.00061, "epss_percentile": 0.19348}, "CVE-2023-49148": {"epss_score": 0.00059, "epss_percentile": 0.18739}, "CVE-2023-49149": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49150": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49151": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49152": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49153": {"epss_score": 0.00082, "epss_percentile": 0.24424}, "CVE-2023-49154": {"epss_score": 0.00249, "epss_percentile": 0.4801}, "CVE-2023-49155": {"epss_score": 0.00082, "epss_percentile": 0.24422}, "CVE-2023-49156": {"epss_score": 0.00163, "epss_percentile": 0.37788}, "CVE-2023-49157": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-49158": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2023-49159": {"epss_score": 0.00384, "epss_percentile": 0.59166}, "CVE-2023-49160": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49161": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-49162": {"epss_score": 0.00589, "epss_percentile": 0.68518}, "CVE-2023-49163": {"epss_score": 0.00059, "epss_percentile": 0.18737}, "CVE-2023-49164": {"epss_score": 0.00059, "epss_percentile": 0.18737}, "CVE-2023-49165": {"epss_score": 0.00118, "epss_percentile": 0.31481}, "CVE-2023-49166": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-49167": {"epss_score": 0.00198, "epss_percentile": 0.42077}, "CVE-2023-49168": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49169": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49170": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49171": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49172": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49173": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49174": {"epss_score": 0.00118, "epss_percentile": 0.31481}, "CVE-2023-49175": {"epss_score": 0.00118, "epss_percentile": 0.31481}, "CVE-2023-49176": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49177": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49178": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49179": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49180": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-49181": {"epss_score": 0.00118, "epss_percentile": 0.31481}, "CVE-2023-49182": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49183": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49184": {"epss_score": 0.00118, "epss_percentile": 0.31481}, "CVE-2023-49185": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49186": {"epss_score": 0.00138, "epss_percentile": 0.34526}, "CVE-2023-49187": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49188": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-49189": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-49190": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-49191": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-49192": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-49193": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-49194": {"epss_score": 0.00185, "epss_percentile": 0.40465}, "CVE-2023-49195": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-49196": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2023-49197": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2023-49198": {"epss_score": 0.00224, "epss_percentile": 0.45069}, "CVE-2023-49203": {"epss_score": 0.00697, "epss_percentile": 0.7141}, "CVE-2023-49208": {"epss_score": 0.00116, "epss_percentile": 0.3108}, "CVE-2023-49210": {"epss_score": 0.00458, "epss_percentile": 0.63398}, "CVE-2023-49213": {"epss_score": 0.01552, "epss_percentile": 0.80993}, "CVE-2023-49214": {"epss_score": 0.00247, "epss_percentile": 0.47814}, "CVE-2023-49215": {"epss_score": 0.00344, "epss_percentile": 0.56539}, "CVE-2023-49216": {"epss_score": 0.00232, "epss_percentile": 0.45886}, "CVE-2023-49221": {"epss_score": 0.00032, "epss_percentile": 0.08835}, "CVE-2023-49222": {"epss_score": 0.00549, "epss_percentile": 0.67305}, "CVE-2023-49223": {"epss_score": 0.00539, "epss_percentile": 0.66979}, "CVE-2023-49224": {"epss_score": 0.00514, "epss_percentile": 0.65947}, "CVE-2023-49225": {"epss_score": 0.00322, "epss_percentile": 0.54816}, "CVE-2023-49226": {"epss_score": 0.01478, "epss_percentile": 0.80553}, "CVE-2023-49228": {"epss_score": 0.00074, "epss_percentile": 0.22781}, "CVE-2023-49229": {"epss_score": 0.00062, "epss_percentile": 0.19611}, "CVE-2023-49230": {"epss_score": 0.20665, "epss_percentile": 0.95398}, "CVE-2023-49231": {"epss_score": 0.00833, "epss_percentile": 0.74088}, "CVE-2023-49232": {"epss_score": 0.00578, "epss_percentile": 0.68196}, "CVE-2023-49233": {"epss_score": 0.0008, "epss_percentile": 0.24059}, "CVE-2023-49234": {"epss_score": 0.00054, "epss_percentile": 0.1728}, "CVE-2023-49235": {"epss_score": 0.00086, "epss_percentile": 0.2534}, "CVE-2023-49236": {"epss_score": 0.0027, "epss_percentile": 0.50225}, "CVE-2023-49237": {"epss_score": 0.65406, "epss_percentile": 0.98416}, "CVE-2023-49238": {"epss_score": 0.00822, "epss_percentile": 0.73919}, "CVE-2023-49239": {"epss_score": 0.00095, "epss_percentile": 0.27107}, "CVE-2023-49240": {"epss_score": 0.00095, "epss_percentile": 0.27107}, "CVE-2023-49241": {"epss_score": 0.00111, "epss_percentile": 0.30264}, "CVE-2023-49242": {"epss_score": 0.00111, "epss_percentile": 0.30264}, "CVE-2023-49243": {"epss_score": 0.00111, "epss_percentile": 0.30264}, "CVE-2023-49244": {"epss_score": 0.00111, "epss_percentile": 0.30264}, "CVE-2023-49245": {"epss_score": 0.00111, "epss_percentile": 0.30264}, "CVE-2023-49246": {"epss_score": 0.00095, "epss_percentile": 0.27107}, "CVE-2023-49247": {"epss_score": 0.00095, "epss_percentile": 0.27107}, "CVE-2023-49248": {"epss_score": 0.00038, "epss_percentile": 0.11106}, "CVE-2023-49250": {"epss_score": 0.0017, "epss_percentile": 0.38725}, "CVE-2023-49251": {"epss_score": 0.00407, "epss_percentile": 0.60568}, "CVE-2023-49252": {"epss_score": 0.00233, "epss_percentile": 0.46052}, "CVE-2023-49253": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2023-49254": {"epss_score": 0.001, "epss_percentile": 0.28537}, "CVE-2023-49255": {"epss_score": 0.00078, "epss_percentile": 0.23764}, "CVE-2023-49256": {"epss_score": 0.00082, "epss_percentile": 0.24462}, "CVE-2023-49257": {"epss_score": 0.00056, "epss_percentile": 0.17964}, "CVE-2023-49258": {"epss_score": 0.00079, "epss_percentile": 0.23942}, "CVE-2023-49259": {"epss_score": 0.00045, "epss_percentile": 0.13815}, "CVE-2023-49260": {"epss_score": 0.00076, "epss_percentile": 0.23229}, "CVE-2023-49261": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-49262": {"epss_score": 0.00021, "epss_percentile": 0.04716}, "CVE-2023-49269": {"epss_score": 0.00077, "epss_percentile": 0.23546}, "CVE-2023-49270": {"epss_score": 0.002, "epss_percentile": 0.42236}, "CVE-2023-49271": {"epss_score": 0.002, "epss_percentile": 0.42236}, "CVE-2023-49272": {"epss_score": 0.00074, "epss_percentile": 0.22742}, "CVE-2023-49273": {"epss_score": 0.00264, "epss_percentile": 0.49688}, "CVE-2023-49274": {"epss_score": 0.00368, "epss_percentile": 0.5817}, "CVE-2023-49275": {"epss_score": 0.00523, "epss_percentile": 0.66304}, "CVE-2023-49276": {"epss_score": 0.00525, "epss_percentile": 0.66375}, "CVE-2023-49277": {"epss_score": 0.00486, "epss_percentile": 0.6475}, "CVE-2023-49278": {"epss_score": 0.00315, "epss_percentile": 0.54167}, "CVE-2023-49279": {"epss_score": 0.00446, "epss_percentile": 0.6289}, "CVE-2023-49280": {"epss_score": 0.00922, "epss_percentile": 0.7549}, "CVE-2023-49281": {"epss_score": 0.00156, "epss_percentile": 0.36964}, "CVE-2023-49282": {"epss_score": 0.00259, "epss_percentile": 0.49091}, "CVE-2023-49283": {"epss_score": 0.00291, "epss_percentile": 0.52165}, "CVE-2023-49284": {"epss_score": 0.00122, "epss_percentile": 0.32099}, "CVE-2023-49285": {"epss_score": 0.08114, "epss_percentile": 0.91886}, "CVE-2023-49286": {"epss_score": 0.0143, "epss_percentile": 0.80229}, "CVE-2023-49287": {"epss_score": 0.02487, "epss_percentile": 0.8489}, "CVE-2023-49288": {"epss_score": 0.02893, "epss_percentile": 0.85922}, "CVE-2023-49289": {"epss_score": 0.00347, "epss_percentile": 0.56782}, "CVE-2023-49290": {"epss_score": 0.00183, "epss_percentile": 0.403}, "CVE-2023-49291": {"epss_score": 0.01212, "epss_percentile": 0.78557}, "CVE-2023-49292": {"epss_score": 0.00187, "epss_percentile": 0.40726}, "CVE-2023-49293": {"epss_score": 0.00397, "epss_percentile": 0.60047}, "CVE-2023-49294": {"epss_score": 0.13043, "epss_percentile": 0.93854}, "CVE-2023-49295": {"epss_score": 0.0131, "epss_percentile": 0.79365}, "CVE-2023-49296": {"epss_score": 0.00446, "epss_percentile": 0.62902}, "CVE-2023-49297": {"epss_score": 0.00107, "epss_percentile": 0.29733}, "CVE-2023-49298": {"epss_score": 0.00742, "epss_percentile": 0.72459}, "CVE-2023-49299": {"epss_score": 0.00731, "epss_percentile": 0.72165}, "CVE-2023-49312": {"epss_score": 0.00082, "epss_percentile": 0.24415}, "CVE-2023-49313": {"epss_score": 0.05367, "epss_percentile": 0.8979}, "CVE-2023-49314": {"epss_score": 0.21612, "epss_percentile": 0.95539}, "CVE-2023-49316": {"epss_score": 0.00149, "epss_percentile": 0.35987}, "CVE-2023-49321": {"epss_score": 0.00084, "epss_percentile": 0.24932}, "CVE-2023-49322": {"epss_score": 0.00148, "epss_percentile": 0.35848}, "CVE-2023-49328": {"epss_score": 0.01593, "epss_percentile": 0.81226}, "CVE-2023-49329": {"epss_score": 0.00266, "epss_percentile": 0.49881}, "CVE-2023-49330": {"epss_score": 0.00939, "epss_percentile": 0.75718}, "CVE-2023-49331": {"epss_score": 0.00511, "epss_percentile": 0.65816}, "CVE-2023-49332": {"epss_score": 0.00511, "epss_percentile": 0.65816}, "CVE-2023-49333": {"epss_score": 0.00511, "epss_percentile": 0.65816}, "CVE-2023-49334": {"epss_score": 0.00511, "epss_percentile": 0.65816}, "CVE-2023-49335": {"epss_score": 0.00266, "epss_percentile": 0.4987}, "CVE-2023-49337": {"epss_score": 0.00457, "epss_percentile": 0.63369}, "CVE-2023-49338": {"epss_score": 0.00375, "epss_percentile": 0.58604}, "CVE-2023-49339": {"epss_score": 0.00283, "epss_percentile": 0.51406}, "CVE-2023-49340": {"epss_score": 0.00425, "epss_percentile": 0.61725}, "CVE-2023-49341": {"epss_score": 0.00039, "epss_percentile": 0.11862}, "CVE-2023-49342": {"epss_score": 0.00034, "epss_percentile": 0.09466}, "CVE-2023-49343": {"epss_score": 0.00034, "epss_percentile": 0.09466}, "CVE-2023-49344": {"epss_score": 0.00034, "epss_percentile": 0.09466}, "CVE-2023-49345": {"epss_score": 0.00034, "epss_percentile": 0.09466}, "CVE-2023-49346": {"epss_score": 0.00034, "epss_percentile": 0.09466}, "CVE-2023-49347": {"epss_score": 0.00055, "epss_percentile": 0.17642}, "CVE-2023-49351": {"epss_score": 0.00369, "epss_percentile": 0.58235}, "CVE-2023-49355": {"epss_score": 0.00146, "epss_percentile": 0.35593}, "CVE-2023-49356": {"epss_score": 0.00225, "epss_percentile": 0.45221}, "CVE-2023-49363": {"epss_score": 0.0016, "epss_percentile": 0.37491}, "CVE-2023-49367": {"epss_score": 0.00053, "epss_percentile": 0.16965}, "CVE-2023-49371": {"epss_score": 0.84809, "epss_percentile": 0.99305}, "CVE-2023-49372": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49373": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49374": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49375": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49376": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49377": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49378": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49379": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49380": {"epss_score": 0.00281, "epss_percentile": 0.51191}, "CVE-2023-49381": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49382": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49383": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49391": {"epss_score": 0.03125, "epss_percentile": 0.86454}, "CVE-2023-49394": {"epss_score": 0.00197, "epss_percentile": 0.41963}, "CVE-2023-49395": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49396": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49397": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49398": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49402": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-49403": {"epss_score": 0.01591, "epss_percentile": 0.81202}, "CVE-2023-49404": {"epss_score": 0.00158, "epss_percentile": 0.37194}, "CVE-2023-49405": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-49406": {"epss_score": 0.00145, "epss_percentile": 0.35426}, "CVE-2023-49408": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-49409": {"epss_score": 0.00145, "epss_percentile": 0.35426}, "CVE-2023-49410": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-49411": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-49417": {"epss_score": 0.0011, "epss_percentile": 0.30107}, "CVE-2023-49418": {"epss_score": 0.00121, "epss_percentile": 0.31948}, "CVE-2023-49424": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-49425": {"epss_score": 0.00127, "epss_percentile": 0.3284}, "CVE-2023-49426": {"epss_score": 0.00127, "epss_percentile": 0.3284}, "CVE-2023-49427": {"epss_score": 0.01061, "epss_percentile": 0.77174}, "CVE-2023-49428": {"epss_score": 0.01882, "epss_percentile": 0.82696}, "CVE-2023-49429": {"epss_score": 0.01882, "epss_percentile": 0.82696}, "CVE-2023-49430": {"epss_score": 0.00127, "epss_percentile": 0.3284}, "CVE-2023-49431": {"epss_score": 0.01975, "epss_percentile": 0.83118}, "CVE-2023-49432": {"epss_score": 0.00127, "epss_percentile": 0.3284}, "CVE-2023-49433": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-49434": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2023-49435": {"epss_score": 0.04421, "epss_percentile": 0.88669}, "CVE-2023-49436": {"epss_score": 0.04421, "epss_percentile": 0.88669}, "CVE-2023-49437": {"epss_score": 0.01975, "epss_percentile": 0.83118}, "CVE-2023-49438": {"epss_score": 0.00202, "epss_percentile": 0.42416}, "CVE-2023-49440": {"epss_score": 0.00043, "epss_percentile": 0.13095}, "CVE-2023-49441": {"epss_score": 0.00013, "epss_percentile": 0.016}, "CVE-2023-49442": {"epss_score": 0.5552, "epss_percentile": 0.97981}, "CVE-2023-49443": {"epss_score": 0.00072, "epss_percentile": 0.22407}, "CVE-2023-49444": {"epss_score": 0.00073, "epss_percentile": 0.22595}, "CVE-2023-49446": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49447": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49448": {"epss_score": 0.00268, "epss_percentile": 0.50052}, "CVE-2023-49453": {"epss_score": 0.00434, "epss_percentile": 0.62299}, "CVE-2023-49460": {"epss_score": 0.00146, "epss_percentile": 0.35589}, "CVE-2023-49462": {"epss_score": 0.00128, "epss_percentile": 0.33071}, "CVE-2023-49463": {"epss_score": 0.00146, "epss_percentile": 0.35589}, "CVE-2023-49464": {"epss_score": 0.00107, "epss_percentile": 0.29753}, "CVE-2023-49465": {"epss_score": 0.0012, "epss_percentile": 0.31741}, "CVE-2023-49467": {"epss_score": 0.00149, "epss_percentile": 0.35997}, "CVE-2023-49468": {"epss_score": 0.00184, "epss_percentile": 0.40367}, "CVE-2023-49469": {"epss_score": 0.00125, "epss_percentile": 0.32472}, "CVE-2023-49471": {"epss_score": 0.15403, "epss_percentile": 0.94424}, "CVE-2023-49473": {"epss_score": 0.00261, "epss_percentile": 0.49323}, "CVE-2023-49484": {"epss_score": 0.00101, "epss_percentile": 0.28678}, "CVE-2023-49485": {"epss_score": 0.00098, "epss_percentile": 0.27676}, "CVE-2023-49486": {"epss_score": 0.00127, "epss_percentile": 0.3293}, "CVE-2023-49487": {"epss_score": 0.00098, "epss_percentile": 0.27676}, "CVE-2023-49488": {"epss_score": 0.00105, "epss_percentile": 0.29265}, "CVE-2023-49489": {"epss_score": 0.00531, "epss_percentile": 0.66647}, "CVE-2023-49490": {"epss_score": 0.00105, "epss_percentile": 0.29265}, "CVE-2023-49492": {"epss_score": 0.00237, "epss_percentile": 0.46738}, "CVE-2023-49493": {"epss_score": 0.00237, "epss_percentile": 0.46738}, "CVE-2023-49494": {"epss_score": 0.01177, "epss_percentile": 0.78278}, "CVE-2023-49501": {"epss_score": 0.00042, "epss_percentile": 0.12585}, "CVE-2023-49502": {"epss_score": 0.00267, "epss_percentile": 0.50014}, "CVE-2023-49508": {"epss_score": 0.00147, "epss_percentile": 0.35788}, "CVE-2023-49515": {"epss_score": 0.00111, "epss_percentile": 0.3035}, "CVE-2023-49528": {"epss_score": 0.00034, "epss_percentile": 0.09528}, "CVE-2023-49539": {"epss_score": 0.00245, "epss_percentile": 0.47728}, "CVE-2023-49540": {"epss_score": 0.00245, "epss_percentile": 0.47728}, "CVE-2023-49543": {"epss_score": 0.00302, "epss_percentile": 0.5312}, "CVE-2023-49544": {"epss_score": 0.00539, "epss_percentile": 0.66966}, "CVE-2023-49545": {"epss_score": 0.00301, "epss_percentile": 0.53012}, "CVE-2023-49546": {"epss_score": 0.0051, "epss_percentile": 0.65764}, "CVE-2023-49547": {"epss_score": 0.06262, "epss_percentile": 0.90621}, "CVE-2023-49548": {"epss_score": 0.00536, "epss_percentile": 0.66845}, "CVE-2023-49549": {"epss_score": 0.01163, "epss_percentile": 0.78156}, "CVE-2023-49550": {"epss_score": 0.00753, "epss_percentile": 0.7267}, "CVE-2023-49551": {"epss_score": 0.00392, "epss_percentile": 0.59686}, "CVE-2023-49552": {"epss_score": 0.00453, "epss_percentile": 0.63207}, "CVE-2023-49553": {"epss_score": 0.00308, "epss_percentile": 0.53624}, "CVE-2023-49554": {"epss_score": 0.00426, "epss_percentile": 0.61741}, "CVE-2023-49555": {"epss_score": 0.0043, "epss_percentile": 0.62006}, "CVE-2023-49556": {"epss_score": 0.0067, "epss_percentile": 0.70788}, "CVE-2023-49557": {"epss_score": 0.00291, "epss_percentile": 0.52153}, "CVE-2023-49558": {"epss_score": 0.00177, "epss_percentile": 0.3953}, "CVE-2023-49559": {"epss_score": 0.00073, "epss_percentile": 0.22498}, "CVE-2023-49563": {"epss_score": 0.00106, "epss_percentile": 0.29436}, "CVE-2023-49564": {"epss_score": 0.00462, "epss_percentile": 0.63574}, "CVE-2023-49565": {"epss_score": 0.00227, "epss_percentile": 0.45371}, "CVE-2023-49566": {"epss_score": 0.0053, "epss_percentile": 0.66609}, "CVE-2023-49567": {"epss_score": 0.00163, "epss_percentile": 0.37829}, "CVE-2023-49568": {"epss_score": 0.00153, "epss_percentile": 0.36531}, "CVE-2023-49569": {"epss_score": 0.04027, "epss_percentile": 0.88144}, "CVE-2023-49570": {"epss_score": 0.00163, "epss_percentile": 0.37829}, "CVE-2023-49572": {"epss_score": 0.0011, "epss_percentile": 0.30107}, "CVE-2023-49573": {"epss_score": 0.00106, "epss_percentile": 0.29557}, "CVE-2023-49574": {"epss_score": 0.00106, "epss_percentile": 0.29557}, "CVE-2023-49575": {"epss_score": 0.0011, "epss_percentile": 0.30107}, "CVE-2023-49577": {"epss_score": 0.00108, "epss_percentile": 0.29787}, "CVE-2023-49578": {"epss_score": 0.00047, "epss_percentile": 0.14785}, "CVE-2023-49580": {"epss_score": 0.00126, "epss_percentile": 0.3276}, "CVE-2023-49581": {"epss_score": 0.00069, "epss_percentile": 0.21565}, "CVE-2023-49582": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2023-49583": {"epss_score": 0.00457, "epss_percentile": 0.63368}, "CVE-2023-49584": {"epss_score": 0.00144, "epss_percentile": 0.35243}, "CVE-2023-49587": {"epss_score": 0.00112, "epss_percentile": 0.30556}, "CVE-2023-49589": {"epss_score": 0.00247, "epss_percentile": 0.47827}, "CVE-2023-49593": {"epss_score": 0.00312, "epss_percentile": 0.53999}, "CVE-2023-49594": {"epss_score": 0.00103, "epss_percentile": 0.2906}, "CVE-2023-49595": {"epss_score": 0.00528, "epss_percentile": 0.66556}, "CVE-2023-49598": {"epss_score": 0.00492, "epss_percentile": 0.65001}, "CVE-2023-49599": {"epss_score": 0.0029, "epss_percentile": 0.52114}, "CVE-2023-49600": {"epss_score": 0.00198, "epss_percentile": 0.42083}, "CVE-2023-49602": {"epss_score": 0.0007, "epss_percentile": 0.21801}, "CVE-2023-49603": {"epss_score": 0.0002, "epss_percentile": 0.04475}, "CVE-2023-49606": {"epss_score": 0.77508, "epss_percentile": 0.98939}, "CVE-2023-49607": {"epss_score": 0.00111, "epss_percentile": 0.30252}, "CVE-2023-49610": {"epss_score": 0.00028, "epss_percentile": 0.0727}, "CVE-2023-49614": {"epss_score": 0.00057, "epss_percentile": 0.18232}, "CVE-2023-49615": {"epss_score": 0.00025, "epss_percentile": 0.06322}, "CVE-2023-49617": {"epss_score": 0.0032, "epss_percentile": 0.54616}, "CVE-2023-49618": {"epss_score": 0.00025, "epss_percentile": 0.06322}, "CVE-2023-49619": {"epss_score": 0.01305, "epss_percentile": 0.7932}, "CVE-2023-49620": {"epss_score": 0.00333, "epss_percentile": 0.55633}, "CVE-2023-49621": {"epss_score": 0.00151, "epss_percentile": 0.3634}, "CVE-2023-49622": {"epss_score": 0.00069, "epss_percentile": 0.21554}, "CVE-2023-49624": {"epss_score": 0.00069, "epss_percentile": 0.21554}, "CVE-2023-49625": {"epss_score": 0.00072, "epss_percentile": 0.22265}, "CVE-2023-49633": {"epss_score": 0.00069, "epss_percentile": 0.21554}, "CVE-2023-49639": {"epss_score": 0.00069, "epss_percentile": 0.21554}, "CVE-2023-49641": {"epss_score": 0.00038, "epss_percentile": 0.11365}, "CVE-2023-49646": {"epss_score": 0.00022, "epss_percentile": 0.05167}, "CVE-2023-49647": {"epss_score": 0.00029, "epss_percentile": 0.07617}, "CVE-2023-49652": {"epss_score": 0.00036, "epss_percentile": 0.10409}, "CVE-2023-49653": {"epss_score": 0.00046, "epss_percentile": 0.14458}, "CVE-2023-49654": {"epss_score": 0.00069, "epss_percentile": 0.21444}, "CVE-2023-49655": {"epss_score": 0.00068, "epss_percentile": 0.21259}, "CVE-2023-49656": {"epss_score": 0.00035, "epss_percentile": 0.09811}, "CVE-2023-49657": {"epss_score": 0.00399, "epss_percentile": 0.60113}, "CVE-2023-49658": {"epss_score": 0.00072, "epss_percentile": 0.22265}, "CVE-2023-49665": {"epss_score": 0.00069, "epss_percentile": 0.21554}, "CVE-2023-49666": {"epss_score": 0.0009, "epss_percentile": 0.26158}, "CVE-2023-49673": {"epss_score": 0.00074, "epss_percentile": 0.22856}, "CVE-2023-49674": {"epss_score": 0.00036, "epss_percentile": 0.10524}, "CVE-2023-49675": {"epss_score": 0.00071, "epss_percentile": 0.22212}, "CVE-2023-49676": {"epss_score": 0.00061, "epss_percentile": 0.19488}, "CVE-2023-49677": {"epss_score": 0.00145, "epss_percentile": 0.35519}, "CVE-2023-49681": {"epss_score": 0.0015, "epss_percentile": 0.36119}, "CVE-2023-49688": {"epss_score": 0.0015, "epss_percentile": 0.36119}, "CVE-2023-49689": {"epss_score": 0.0015, "epss_percentile": 0.36119}, "CVE-2023-49691": {"epss_score": 0.00119, "epss_percentile": 0.31552}, "CVE-2023-49692": {"epss_score": 0.00135, "epss_percentile": 0.3403}, "CVE-2023-49693": {"epss_score": 0.00716, "epss_percentile": 0.71867}, "CVE-2023-49694": {"epss_score": 0.0009, "epss_percentile": 0.26121}, "CVE-2023-49695": {"epss_score": 0.00173, "epss_percentile": 0.39129}, "CVE-2023-49699": {"epss_score": 0.0006, "epss_percentile": 0.19106}, "CVE-2023-49700": {"epss_score": 0.00089, "epss_percentile": 0.25914}, "CVE-2023-49701": {"epss_score": 0.00145, "epss_percentile": 0.35441}, "CVE-2023-49706": {"epss_score": 0.00142, "epss_percentile": 0.35009}, "CVE-2023-49707": {"epss_score": 0.00731, "epss_percentile": 0.72184}, "CVE-2023-49708": {"epss_score": 0.0092, "epss_percentile": 0.75472}, "CVE-2023-49713": {"epss_score": 0.00573, "epss_percentile": 0.68064}, "CVE-2023-49715": {"epss_score": 0.00691, "epss_percentile": 0.7126}, "CVE-2023-49716": {"epss_score": 0.00083, "epss_percentile": 0.24622}, "CVE-2023-49721": {"epss_score": 0.00017, "epss_percentile": 0.03196}, "CVE-2023-49722": {"epss_score": 0.00072, "epss_percentile": 0.22385}, "CVE-2023-49733": {"epss_score": 0.00481, "epss_percentile": 0.64508}, "CVE-2023-49734": {"epss_score": 0.00183, "epss_percentile": 0.40277}, "CVE-2023-49735": {"epss_score": 0.00856, "epss_percentile": 0.74476}, "CVE-2023-49736": {"epss_score": 0.00647, "epss_percentile": 0.70202}, "CVE-2023-49738": {"epss_score": 0.00775, "epss_percentile": 0.73091}, "CVE-2023-49739": {"epss_score": 0.00191, "epss_percentile": 0.41165}, "CVE-2023-49740": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49741": {"epss_score": 0.00106, "epss_percentile": 0.29507}, "CVE-2023-49742": {"epss_score": 0.01002, "epss_percentile": 0.76507}, "CVE-2023-49743": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-49744": {"epss_score": 0.00112, "epss_percentile": 0.30431}, "CVE-2023-49745": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49746": {"epss_score": 0.00162, "epss_percentile": 0.37624}, "CVE-2023-49747": {"epss_score": 0.00118, "epss_percentile": 0.31481}, "CVE-2023-49748": {"epss_score": 0.00572, "epss_percentile": 0.68036}, "CVE-2023-49749": {"epss_score": 0.00155, "epss_percentile": 0.36794}, "CVE-2023-49750": {"epss_score": 0.00173, "epss_percentile": 0.39088}, "CVE-2023-49751": {"epss_score": 0.00123, "epss_percentile": 0.32329}, "CVE-2023-49752": {"epss_score": 0.00147, "epss_percentile": 0.3569}, "CVE-2023-49753": {"epss_score": 0.01119, "epss_percentile": 0.77752}, "CVE-2023-49754": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-49755": {"epss_score": 0.00142, "epss_percentile": 0.35024}, "CVE-2023-49756": {"epss_score": 0.00282, "epss_percentile": 0.51279}, "CVE-2023-49757": {"epss_score": 0.00142, "epss_percentile": 0.35024}, "CVE-2023-49758": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2023-49759": {"epss_score": 0.00059, "epss_percentile": 0.18737}, "CVE-2023-49760": {"epss_score": 0.00059, "epss_percentile": 0.18739}, "CVE-2023-49761": {"epss_score": 0.00059, "epss_percentile": 0.18739}, "CVE-2023-49762": {"epss_score": 0.00693, "epss_percentile": 0.71319}, "CVE-2023-49763": {"epss_score": 0.00082, "epss_percentile": 0.24422}, "CVE-2023-49764": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-49765": {"epss_score": 0.00144, "epss_percentile": 0.35349}, "CVE-2023-49766": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2023-49767": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-49768": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2023-49769": {"epss_score": 0.00123, "epss_percentile": 0.32329}, "CVE-2023-49770": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-49771": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2023-49772": {"epss_score": 0.00303, "epss_percentile": 0.53214}, "CVE-2023-49773": {"epss_score": 0.00303, "epss_percentile": 0.53214}, "CVE-2023-49774": {"epss_score": 0.00334, "epss_percentile": 0.5569}, "CVE-2023-49775": {"epss_score": 0.00123, "epss_percentile": 0.32327}, "CVE-2023-49776": {"epss_score": 0.00173, "epss_percentile": 0.39088}, "CVE-2023-49777": {"epss_score": 0.00328, "epss_percentile": 0.55185}, "CVE-2023-49778": {"epss_score": 0.00634, "epss_percentile": 0.69789}, "CVE-2023-49779": {"epss_score": 0.01289, "epss_percentile": 0.79208}, "CVE-2023-49780": {"epss_score": 0.0007, "epss_percentile": 0.21815}, "CVE-2023-49781": {"epss_score": 0.01747, "epss_percentile": 0.82077}, "CVE-2023-49782": {"epss_score": 0.00095, "epss_percentile": 0.27189}, "CVE-2023-49783": {"epss_score": 0.00146, "epss_percentile": 0.35534}, "CVE-2023-49785": {"epss_score": 0.93382, "epss_percentile": 0.99802}, "CVE-2023-49786": {"epss_score": 0.00122, "epss_percentile": 0.32113}, "CVE-2023-49788": {"epss_score": 0.00076, "epss_percentile": 0.23125}, "CVE-2023-49790": {"epss_score": 0.00258, "epss_percentile": 0.48986}, "CVE-2023-49791": {"epss_score": 0.00199, "epss_percentile": 0.42181}, "CVE-2023-49792": {"epss_score": 0.00354, "epss_percentile": 0.57221}, "CVE-2023-49793": {"epss_score": 0.01054, "epss_percentile": 0.77109}, "CVE-2023-49794": {"epss_score": 0.0003, "epss_percentile": 0.08033}, "CVE-2023-49795": {"epss_score": 0.00353, "epss_percentile": 0.57195}, "CVE-2023-49796": {"epss_score": 0.00868, "epss_percentile": 0.74682}, "CVE-2023-49797": {"epss_score": 0.00062, "epss_percentile": 0.19653}, "CVE-2023-49798": {"epss_score": 0.00492, "epss_percentile": 0.65012}, "CVE-2023-49799": {"epss_score": 0.01874, "epss_percentile": 0.82647}, "CVE-2023-49800": {"epss_score": 0.01121, "epss_percentile": 0.77776}, "CVE-2023-49801": {"epss_score": 0.00321, "epss_percentile": 0.54738}, "CVE-2023-49802": {"epss_score": 0.00198, "epss_percentile": 0.41999}, "CVE-2023-49803": {"epss_score": 0.00131, "epss_percentile": 0.33481}, "CVE-2023-49804": {"epss_score": 0.00047, "epss_percentile": 0.14623}, "CVE-2023-49805": {"epss_score": 0.00012, "epss_percentile": 0.01182}, "CVE-2023-49807": {"epss_score": 0.00492, "epss_percentile": 0.65001}, "CVE-2023-49809": {"epss_score": 0.00129, "epss_percentile": 0.33192}, "CVE-2023-49810": {"epss_score": 0.00125, "epss_percentile": 0.32506}, "CVE-2023-49812": {"epss_score": 0.00109, "epss_percentile": 0.29951}, "CVE-2023-49813": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49814": {"epss_score": 0.00218, "epss_percentile": 0.44425}, "CVE-2023-49815": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2023-49816": {"epss_score": 0.00077, "epss_percentile": 0.23289}, "CVE-2023-49817": {"epss_score": 0.00235, "epss_percentile": 0.46329}, "CVE-2023-49818": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-49819": {"epss_score": 0.00319, "epss_percentile": 0.54471}, "CVE-2023-49820": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49821": {"epss_score": 0.00059, "epss_percentile": 0.18737}, "CVE-2023-49822": {"epss_score": 0.00572, "epss_percentile": 0.68036}, "CVE-2023-49823": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-49824": {"epss_score": 0.00055, "epss_percentile": 0.17572}, "CVE-2023-49825": {"epss_score": 0.00131, "epss_percentile": 0.33428}, "CVE-2023-49826": {"epss_score": 0.00666, "epss_percentile": 0.70673}, "CVE-2023-49827": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2023-49828": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-49829": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-49830": {"epss_score": 0.00692, "epss_percentile": 0.71305}, "CVE-2023-49831": {"epss_score": 0.00208, "epss_percentile": 0.43282}, "CVE-2023-49832": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2023-49833": {"epss_score": 0.00124, "epss_percentile": 0.32442}, "CVE-2023-49834": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-49835": {"epss_score": 0.0018, "epss_percentile": 0.39879}, "CVE-2023-49836": {"epss_score": 0.00118, "epss_percentile": 0.31481}, "CVE-2023-49837": {"epss_score": 0.00253, "epss_percentile": 0.48478}, "CVE-2023-49838": {"epss_score": 0.00245, "epss_percentile": 0.47724}, "CVE-2023-49839": {"epss_score": 0.00207, "epss_percentile": 0.43113}, "CVE-2023-49840": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-49841": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-49842": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-49843": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-49844": {"epss_score": 0.0007, "epss_percentile": 0.2193}, "CVE-2023-49845": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-49846": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49847": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49848": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-49849": {"epss_score": 0.00152, "epss_percentile": 0.36394}, "CVE-2023-49850": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-49851": {"epss_score": 0.00213, "epss_percentile": 0.4388}, "CVE-2023-49852": {"epss_score": 0.00183, "epss_percentile": 0.40277}, "CVE-2023-49853": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-49854": {"epss_score": 0.00053, "epss_percentile": 0.16989}, "CVE-2023-49855": {"epss_score": 0.00083, "epss_percentile": 0.24752}, "CVE-2023-49856": {"epss_score": 0.00384, "epss_percentile": 0.59125}, "CVE-2023-49857": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-49858": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-49859": {"epss_score": 0.00165, "epss_percentile": 0.38019}, "CVE-2023-49860": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-49861": {"epss_score": 0.00139, "epss_percentile": 0.34581}, "CVE-2023-49862": {"epss_score": 0.00325, "epss_percentile": 0.55017}, "CVE-2023-49863": {"epss_score": 0.00325, "epss_percentile": 0.55017}, "CVE-2023-49864": {"epss_score": 0.00325, "epss_percentile": 0.55017}, "CVE-2023-49867": {"epss_score": 0.0731, "epss_percentile": 0.91399}, "CVE-2023-49874": {"epss_score": 0.0011, "epss_percentile": 0.30116}, "CVE-2023-49877": {"epss_score": 0.00047, "epss_percentile": 0.14785}, "CVE-2023-49878": {"epss_score": 0.00046, "epss_percentile": 0.14344}, "CVE-2023-49880": {"epss_score": 0.00046, "epss_percentile": 0.14437}, "CVE-2023-49881": {"epss_score": 0.00059, "epss_percentile": 0.18673}, "CVE-2023-49883": {"epss_score": 0.00045, "epss_percentile": 0.13786}, "CVE-2023-49886": {"epss_score": 0.00783, "epss_percentile": 0.7322}, "CVE-2023-49897": {"epss_score": 0.37288, "epss_percentile": 0.97033}, "CVE-2023-49898": {"epss_score": 0.01896, "epss_percentile": 0.82752}, "CVE-2023-49906": {"epss_score": 0.00861, "epss_percentile": 0.74558}, "CVE-2023-49907": {"epss_score": 0.00861, "epss_percentile": 0.74558}, "CVE-2023-49908": {"epss_score": 0.00861, "epss_percentile": 0.74558}, "CVE-2023-49909": {"epss_score": 0.00861, "epss_percentile": 0.74558}, "CVE-2023-49910": {"epss_score": 0.00861, "epss_percentile": 0.74558}, "CVE-2023-49911": {"epss_score": 0.00861, "epss_percentile": 0.74558}, "CVE-2023-49912": {"epss_score": 0.00861, "epss_percentile": 0.74558}, "CVE-2023-49913": {"epss_score": 0.00861, "epss_percentile": 0.74558}, "CVE-2023-49914": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2023-49920": {"epss_score": 0.00176, "epss_percentile": 0.39403}, "CVE-2023-49921": {"epss_score": 0.00701, "epss_percentile": 0.71498}, "CVE-2023-49922": {"epss_score": 0.00444, "epss_percentile": 0.62806}, "CVE-2023-49923": {"epss_score": 0.00279, "epss_percentile": 0.50993}, "CVE-2023-49926": {"epss_score": 0.00101, "epss_percentile": 0.28585}, "CVE-2023-49927": {"epss_score": 0.00108, "epss_percentile": 0.29821}, "CVE-2023-49928": {"epss_score": 0.00382, "epss_percentile": 0.59057}, "CVE-2023-49930": {"epss_score": 0.0048, "epss_percentile": 0.64472}, "CVE-2023-49931": {"epss_score": 0.00644, "epss_percentile": 0.70074}, "CVE-2023-49932": {"epss_score": 0.00715, "epss_percentile": 0.71852}, "CVE-2023-49933": {"epss_score": 0.00064, "epss_percentile": 0.20128}, "CVE-2023-49934": {"epss_score": 0.00283, "epss_percentile": 0.51361}, "CVE-2023-49935": {"epss_score": 0.00073, "epss_percentile": 0.22627}, "CVE-2023-49936": {"epss_score": 0.00402, "epss_percentile": 0.60271}, "CVE-2023-49937": {"epss_score": 0.0039, "epss_percentile": 0.59545}, "CVE-2023-49938": {"epss_score": 0.00204, "epss_percentile": 0.42643}, "CVE-2023-49943": {"epss_score": 0.00844, "epss_percentile": 0.7428}, "CVE-2023-49944": {"epss_score": 0.00011, "epss_percentile": 0.01018}, "CVE-2023-49946": {"epss_score": 0.00103, "epss_percentile": 0.29014}, "CVE-2023-49947": {"epss_score": 0.00052, "epss_percentile": 0.16636}, "CVE-2023-49948": {"epss_score": 0.00471, "epss_percentile": 0.64016}, "CVE-2023-49949": {"epss_score": 0.00056, "epss_percentile": 0.17672}, "CVE-2023-49950": {"epss_score": 0.00182, "epss_percentile": 0.40149}, "CVE-2023-49952": {"epss_score": 0.00197, "epss_percentile": 0.41972}, "CVE-2023-49954": {"epss_score": 0.00438, "epss_percentile": 0.62556}, "CVE-2023-49955": {"epss_score": 0.00379, "epss_percentile": 0.58902}, "CVE-2023-49956": {"epss_score": 0.00379, "epss_percentile": 0.58902}, "CVE-2023-49957": {"epss_score": 0.00299, "epss_percentile": 0.5285}, "CVE-2023-49958": {"epss_score": 0.00299, "epss_percentile": 0.5285}, "CVE-2023-49959": {"epss_score": 0.01658, "epss_percentile": 0.81608}, "CVE-2023-49960": {"epss_score": 0.00255, "epss_percentile": 0.4869}, "CVE-2023-49961": {"epss_score": 0.00346, "epss_percentile": 0.56639}, "CVE-2023-49963": {"epss_score": 0.00101, "epss_percentile": 0.28668}, "CVE-2023-49964": {"epss_score": 0.05683, "epss_percentile": 0.90118}, "CVE-2023-49965": {"epss_score": 0.00307, "epss_percentile": 0.53502}, "CVE-2023-49967": {"epss_score": 0.0031, "epss_percentile": 0.53783}, "CVE-2023-49968": {"epss_score": 0.00125, "epss_percentile": 0.32617}, "CVE-2023-49969": {"epss_score": 0.00152, "epss_percentile": 0.36489}, "CVE-2023-49970": {"epss_score": 0.00517, "epss_percentile": 0.66077}, "CVE-2023-49971": {"epss_score": 0.00304, "epss_percentile": 0.53242}, "CVE-2023-49973": {"epss_score": 0.00409, "epss_percentile": 0.60691}, "CVE-2023-49974": {"epss_score": 0.00286, "epss_percentile": 0.51723}, "CVE-2023-49976": {"epss_score": 0.00196, "epss_percentile": 0.41816}, "CVE-2023-49977": {"epss_score": 0.00286, "epss_percentile": 0.51723}, "CVE-2023-49978": {"epss_score": 0.00389, "epss_percentile": 0.59476}, "CVE-2023-49979": {"epss_score": 0.00779, "epss_percentile": 0.73138}, "CVE-2023-49980": {"epss_score": 0.00779, "epss_percentile": 0.73138}, "CVE-2023-49981": {"epss_score": 0.00741, "epss_percentile": 0.72443}, "CVE-2023-49982": {"epss_score": 0.00524, "epss_percentile": 0.66316}, "CVE-2023-49983": {"epss_score": 0.00387, "epss_percentile": 0.59291}, "CVE-2023-49984": {"epss_score": 0.00269, "epss_percentile": 0.5015}, "CVE-2023-49985": {"epss_score": 0.00185, "epss_percentile": 0.4048}, "CVE-2023-49986": {"epss_score": 0.00199, "epss_percentile": 0.42187}, "CVE-2023-49987": {"epss_score": 0.00256, "epss_percentile": 0.48787}, "CVE-2023-49988": {"epss_score": 0.00441, "epss_percentile": 0.62694}, "CVE-2023-49989": {"epss_score": 0.00509, "epss_percentile": 0.65752}, "CVE-2023-49990": {"epss_score": 0.00022, "epss_percentile": 0.05178}, "CVE-2023-49991": {"epss_score": 0.00022, "epss_percentile": 0.05178}, "CVE-2023-49992": {"epss_score": 0.00022, "epss_percentile": 0.05178}, "CVE-2023-49993": {"epss_score": 0.00022, "epss_percentile": 0.05178}, "CVE-2023-49994": {"epss_score": 0.00032, "epss_percentile": 0.09033}, "CVE-2023-49999": {"epss_score": 0.01754, "epss_percentile": 0.82116}, "CVE-2023-4000": {"epss_score": 0.00042, "epss_percentile": 0.12883}, "CVE-2023-4001": {"epss_score": 0.00037, "epss_percentile": 0.10659}, "CVE-2023-4002": {"epss_score": 0.00078, "epss_percentile": 0.23575}, "CVE-2023-4003": {"epss_score": 0.00101, "epss_percentile": 0.28638}, "CVE-2023-4004": {"epss_score": 0.00015, "epss_percentile": 0.02441}, "CVE-2023-4005": {"epss_score": 0.00054, "epss_percentile": 0.17073}, "CVE-2023-4006": {"epss_score": 0.00113, "epss_percentile": 0.30646}, "CVE-2023-4007": {"epss_score": 0.00099, "epss_percentile": 0.27833}, "CVE-2023-4008": {"epss_score": 0.00052, "epss_percentile": 0.16517}, "CVE-2023-4009": {"epss_score": 0.00135, "epss_percentile": 0.33939}, "CVE-2023-4010": {"epss_score": 0.00011, "epss_percentile": 0.01035}, "CVE-2023-4011": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-4012": {"epss_score": 0.0023, "epss_percentile": 0.4567}, "CVE-2023-4013": {"epss_score": 0.00122, "epss_percentile": 0.32027}, "CVE-2023-4015": {"epss_score": 0.00024, "epss_percentile": 0.06031}, "CVE-2023-4016": {"epss_score": 0.00013, "epss_percentile": 0.01668}, "CVE-2023-4017": {"epss_score": 0.01684, "epss_percentile": 0.81742}, "CVE-2023-4018": {"epss_score": 0.00094, "epss_percentile": 0.26988}, "CVE-2023-4019": {"epss_score": 0.0025, "epss_percentile": 0.48208}, "CVE-2023-4020": {"epss_score": 0.00219, "epss_percentile": 0.44497}, "CVE-2023-4021": {"epss_score": 0.00156, "epss_percentile": 0.36914}, "CVE-2023-4022": {"epss_score": 0.00085, "epss_percentile": 0.25169}, "CVE-2023-4023": {"epss_score": 0.00163, "epss_percentile": 0.37772}, "CVE-2023-4024": {"epss_score": 0.00232, "epss_percentile": 0.45962}, "CVE-2023-4025": {"epss_score": 0.00358, "epss_percentile": 0.57525}, "CVE-2023-4027": {"epss_score": 0.00372, "epss_percentile": 0.58453}, "CVE-2023-4028": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2023-4029": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2023-4030": {"epss_score": 0.00072, "epss_percentile": 0.22435}, "CVE-2023-4033": {"epss_score": 0.00204, "epss_percentile": 0.42634}, "CVE-2023-4034": {"epss_score": 0.0008, "epss_percentile": 0.24143}, "CVE-2023-4035": {"epss_score": 0.00119, "epss_percentile": 0.31568}, "CVE-2023-4036": {"epss_score": 0.00111, "epss_percentile": 0.30381}, "CVE-2023-4037": {"epss_score": 0.00045, "epss_percentile": 0.13719}, "CVE-2023-4039": {"epss_score": 0.00181, "epss_percentile": 0.40023}, "CVE-2023-4040": {"epss_score": 0.00118, "epss_percentile": 0.31449}, "CVE-2023-4041": {"epss_score": 0.00035, "epss_percentile": 0.09819}, "CVE-2023-4042": {"epss_score": 0.00027, "epss_percentile": 0.07092}, "CVE-2023-4043": {"epss_score": 0.0015, "epss_percentile": 0.36073}, "CVE-2023-4045": {"epss_score": 0.00325, "epss_percentile": 0.54978}, "CVE-2023-4046": {"epss_score": 0.00272, "epss_percentile": 0.50374}, "CVE-2023-4047": {"epss_score": 0.00519, "epss_percentile": 0.66184}, "CVE-2023-4048": {"epss_score": 0.00459, "epss_percentile": 0.63476}, "CVE-2023-4049": {"epss_score": 0.00296, "epss_percentile": 0.52566}, "CVE-2023-4050": {"epss_score": 0.10116, "epss_percentile": 0.92855}, "CVE-2023-4051": {"epss_score": 0.0014, "epss_percentile": 0.34746}, "CVE-2023-4052": {"epss_score": 0.00179, "epss_percentile": 0.39771}, "CVE-2023-4053": {"epss_score": 0.00145, "epss_percentile": 0.35414}, "CVE-2023-4054": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2023-4055": {"epss_score": 0.00348, "epss_percentile": 0.56828}, "CVE-2023-4056": {"epss_score": 0.00667, "epss_percentile": 0.70708}, "CVE-2023-4057": {"epss_score": 0.00168, "epss_percentile": 0.38448}, "CVE-2023-4058": {"epss_score": 0.00307, "epss_percentile": 0.53486}, "CVE-2023-4059": {"epss_score": 0.00134, "epss_percentile": 0.3376}, "CVE-2023-4060": {"epss_score": 0.00127, "epss_percentile": 0.32888}, "CVE-2023-4061": {"epss_score": 0.00197, "epss_percentile": 0.41876}, "CVE-2023-4063": {"epss_score": 0.0005, "epss_percentile": 0.15716}, "CVE-2023-4065": {"epss_score": 0.0004, "epss_percentile": 0.12146}, "CVE-2023-4066": {"epss_score": 0.00037, "epss_percentile": 0.11}, "CVE-2023-4067": {"epss_score": 0.00505, "epss_percentile": 0.65608}, "CVE-2023-4068": {"epss_score": 0.02683, "epss_percentile": 0.85422}, "CVE-2023-4069": {"epss_score": 0.05307, "epss_percentile": 0.89714}, "CVE-2023-4070": {"epss_score": 0.00151, "epss_percentile": 0.36317}, "CVE-2023-4071": {"epss_score": 0.00496, "epss_percentile": 0.65136}, "CVE-2023-4072": {"epss_score": 0.00424, "epss_percentile": 0.61678}, "CVE-2023-4073": {"epss_score": 0.00702, "epss_percentile": 0.71518}, "CVE-2023-4074": {"epss_score": 0.00437, "epss_percentile": 0.62528}, "CVE-2023-4075": {"epss_score": 0.00593, "epss_percentile": 0.68652}, "CVE-2023-4076": {"epss_score": 0.00781, "epss_percentile": 0.73188}, "CVE-2023-4077": {"epss_score": 0.00156, "epss_percentile": 0.37009}, "CVE-2023-4078": {"epss_score": 0.00156, "epss_percentile": 0.37009}, "CVE-2023-4088": {"epss_score": 0.00026, "epss_percentile": 0.06464}, "CVE-2023-4089": {"epss_score": 0.00087, "epss_percentile": 0.25566}, "CVE-2023-4090": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-4091": {"epss_score": 0.00476, "epss_percentile": 0.64281}, "CVE-2023-4092": {"epss_score": 0.00141, "epss_percentile": 0.34845}, "CVE-2023-4093": {"epss_score": 0.00123, "epss_percentile": 0.32193}, "CVE-2023-4094": {"epss_score": 0.00102, "epss_percentile": 0.28856}, "CVE-2023-4095": {"epss_score": 0.00197, "epss_percentile": 0.41834}, "CVE-2023-4096": {"epss_score": 0.00115, "epss_percentile": 0.30933}, "CVE-2023-4097": {"epss_score": 0.00107, "epss_percentile": 0.29639}, "CVE-2023-4098": {"epss_score": 0.0015, "epss_percentile": 0.36141}, "CVE-2023-4099": {"epss_score": 0.00027, "epss_percentile": 0.06742}, "CVE-2023-4100": {"epss_score": 0.00067, "epss_percentile": 0.21046}, "CVE-2023-4101": {"epss_score": 0.0008, "epss_percentile": 0.24126}, "CVE-2023-4102": {"epss_score": 0.00164, "epss_percentile": 0.3797}, "CVE-2023-4103": {"epss_score": 0.00138, "epss_percentile": 0.34462}, "CVE-2023-4104": {"epss_score": 0.00112, "epss_percentile": 0.30442}, "CVE-2023-4105": {"epss_score": 0.0025, "epss_percentile": 0.48115}, "CVE-2023-4106": {"epss_score": 0.00091, "epss_percentile": 0.26266}, "CVE-2023-4107": {"epss_score": 0.00032, "epss_percentile": 0.08845}, "CVE-2023-4108": {"epss_score": 0.00144, "epss_percentile": 0.35307}, "CVE-2023-4109": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-4110": {"epss_score": 0.07652, "epss_percentile": 0.91604}, "CVE-2023-4111": {"epss_score": 0.08787, "epss_percentile": 0.92255}, "CVE-2023-4112": {"epss_score": 0.08886, "epss_percentile": 0.92301}, "CVE-2023-4113": {"epss_score": 0.08886, "epss_percentile": 0.92301}, "CVE-2023-4114": {"epss_score": 0.07829, "epss_percentile": 0.91703}, "CVE-2023-4115": {"epss_score": 0.10813, "epss_percentile": 0.93119}, "CVE-2023-4116": {"epss_score": 0.14002, "epss_percentile": 0.94112}, "CVE-2023-4117": {"epss_score": 0.00595, "epss_percentile": 0.68686}, "CVE-2023-4118": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-4119": {"epss_score": 0.01321, "epss_percentile": 0.79445}, "CVE-2023-4120": {"epss_score": 0.65547, "epss_percentile": 0.98425}, "CVE-2023-4121": {"epss_score": 0.00024, "epss_percentile": 0.05657}, "CVE-2023-4122": {"epss_score": 0.01451, "epss_percentile": 0.8036}, "CVE-2023-4124": {"epss_score": 0.00132, "epss_percentile": 0.33554}, "CVE-2023-4125": {"epss_score": 0.00252, "epss_percentile": 0.48413}, "CVE-2023-4126": {"epss_score": 0.00078, "epss_percentile": 0.23586}, "CVE-2023-4127": {"epss_score": 0.00152, "epss_percentile": 0.36416}, "CVE-2023-4129": {"epss_score": 0.00095, "epss_percentile": 0.27165}, "CVE-2023-4130": {"epss_score": 9e-05, "epss_percentile": 0.00697}, "CVE-2023-4132": {"epss_score": 0.00016, "epss_percentile": 0.02758}, "CVE-2023-4133": {"epss_score": 0.00011, "epss_percentile": 0.01013}, "CVE-2023-4134": {"epss_score": 0.00015, "epss_percentile": 0.0222}, "CVE-2023-4135": {"epss_score": 0.0002, "epss_percentile": 0.0442}, "CVE-2023-4136": {"epss_score": 0.18052, "epss_percentile": 0.94949}, "CVE-2023-4138": {"epss_score": 0.00059, "epss_percentile": 0.1891}, "CVE-2023-4139": {"epss_score": 0.00436, "epss_percentile": 0.62459}, "CVE-2023-4140": {"epss_score": 0.00057, "epss_percentile": 0.1808}, "CVE-2023-4141": {"epss_score": 0.04214, "epss_percentile": 0.88404}, "CVE-2023-4142": {"epss_score": 0.04448, "epss_percentile": 0.88701}, "CVE-2023-4145": {"epss_score": 7e-05, "epss_percentile": 0.00341}, "CVE-2023-4147": {"epss_score": 0.00161, "epss_percentile": 0.37571}, "CVE-2023-4148": {"epss_score": 0.08051, "epss_percentile": 0.91855}, "CVE-2023-4149": {"epss_score": 0.00324, "epss_percentile": 0.54973}, "CVE-2023-4150": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-4151": {"epss_score": 0.10845, "epss_percentile": 0.93132}, "CVE-2023-4152": {"epss_score": 0.00089, "epss_percentile": 0.25908}, "CVE-2023-4153": {"epss_score": 0.00107, "epss_percentile": 0.29664}, "CVE-2023-4154": {"epss_score": 0.00314, "epss_percentile": 0.54114}, "CVE-2023-4155": {"epss_score": 7e-05, "epss_percentile": 0.00425}, "CVE-2023-4156": {"epss_score": 0.00031, "epss_percentile": 0.0857}, "CVE-2023-4157": {"epss_score": 0.00063, "epss_percentile": 0.20067}, "CVE-2023-4158": {"epss_score": 0.00068, "epss_percentile": 0.21308}, "CVE-2023-4159": {"epss_score": 0.00103, "epss_percentile": 0.28981}, "CVE-2023-4160": {"epss_score": 0.00113, "epss_percentile": 0.30584}, "CVE-2023-4161": {"epss_score": 0.00103, "epss_percentile": 0.28999}, "CVE-2023-4162": {"epss_score": 0.00023, "epss_percentile": 0.05652}, "CVE-2023-4163": {"epss_score": 0.00025, "epss_percentile": 0.06156}, "CVE-2023-4164": {"epss_score": 0.00019, "epss_percentile": 0.04394}, "CVE-2023-4165": {"epss_score": 0.88667, "epss_percentile": 0.99483}, "CVE-2023-4166": {"epss_score": 0.87968, "epss_percentile": 0.99453}, "CVE-2023-4167": {"epss_score": 0.0013, "epss_percentile": 0.3327}, "CVE-2023-4168": {"epss_score": 0.78168, "epss_percentile": 0.98971}, "CVE-2023-4169": {"epss_score": 0.90555, "epss_percentile": 0.99589}, "CVE-2023-4170": {"epss_score": 0.00061, "epss_percentile": 0.1932}, "CVE-2023-4171": {"epss_score": 0.0013, "epss_percentile": 0.3332}, "CVE-2023-4172": {"epss_score": 0.00111, "epss_percentile": 0.30314}, "CVE-2023-4173": {"epss_score": 0.10557, "epss_percentile": 0.93028}, "CVE-2023-4174": {"epss_score": 0.60752, "epss_percentile": 0.98218}, "CVE-2023-4175": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-4176": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4177": {"epss_score": 0.00033, "epss_percentile": 0.09395}, "CVE-2023-4178": {"epss_score": 0.00018, "epss_percentile": 0.03804}, "CVE-2023-4179": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4180": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2023-4181": {"epss_score": 0.00059, "epss_percentile": 0.18632}, "CVE-2023-4182": {"epss_score": 0.00048, "epss_percentile": 0.15271}, "CVE-2023-4183": {"epss_score": 0.00054, "epss_percentile": 0.17043}, "CVE-2023-4184": {"epss_score": 0.00045, "epss_percentile": 0.13702}, "CVE-2023-4185": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4186": {"epss_score": 0.00197, "epss_percentile": 0.41966}, "CVE-2023-4187": {"epss_score": 0.0006, "epss_percentile": 0.19222}, "CVE-2023-4188": {"epss_score": 0.00062, "epss_percentile": 0.19741}, "CVE-2023-4189": {"epss_score": 0.0006, "epss_percentile": 0.19222}, "CVE-2023-4190": {"epss_score": 0.00547, "epss_percentile": 0.67251}, "CVE-2023-4191": {"epss_score": 0.00063, "epss_percentile": 0.1991}, "CVE-2023-4192": {"epss_score": 0.00057, "epss_percentile": 0.1821}, "CVE-2023-4193": {"epss_score": 0.00057, "epss_percentile": 0.1821}, "CVE-2023-4194": {"epss_score": 6e-05, "epss_percentile": 0.00289}, "CVE-2023-4195": {"epss_score": 0.01641, "epss_percentile": 0.81505}, "CVE-2023-4196": {"epss_score": 0.00084, "epss_percentile": 0.24962}, "CVE-2023-4197": {"epss_score": 0.48668, "epss_percentile": 0.97648}, "CVE-2023-4198": {"epss_score": 0.00079, "epss_percentile": 0.23998}, "CVE-2023-4199": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-4200": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4201": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4202": {"epss_score": 0.0016, "epss_percentile": 0.37509}, "CVE-2023-4203": {"epss_score": 0.00866, "epss_percentile": 0.74636}, "CVE-2023-4204": {"epss_score": 0.00195, "epss_percentile": 0.41601}, "CVE-2023-4206": {"epss_score": 0.00069, "epss_percentile": 0.21537}, "CVE-2023-4207": {"epss_score": 0.00028, "epss_percentile": 0.073}, "CVE-2023-4208": {"epss_score": 0.00031, "epss_percentile": 0.08629}, "CVE-2023-4209": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-4211": {"epss_score": 0.00258, "epss_percentile": 0.48964}, "CVE-2023-4212": {"epss_score": 0.00092, "epss_percentile": 0.26587}, "CVE-2023-4213": {"epss_score": 0.00058, "epss_percentile": 0.18462}, "CVE-2023-4214": {"epss_score": 0.00291, "epss_percentile": 0.52184}, "CVE-2023-4215": {"epss_score": 0.00125, "epss_percentile": 0.32583}, "CVE-2023-4216": {"epss_score": 0.00117, "epss_percentile": 0.31378}, "CVE-2023-4217": {"epss_score": 0.00146, "epss_percentile": 0.35606}, "CVE-2023-4218": {"epss_score": 0.00026, "epss_percentile": 0.06725}, "CVE-2023-4219": {"epss_score": 0.0005, "epss_percentile": 0.15711}, "CVE-2023-4220": {"epss_score": 0.93271, "epss_percentile": 0.99792}, "CVE-2023-4221": {"epss_score": 0.01863, "epss_percentile": 0.82597}, "CVE-2023-4222": {"epss_score": 0.01863, "epss_percentile": 0.82597}, "CVE-2023-4223": {"epss_score": 0.02564, "epss_percentile": 0.85112}, "CVE-2023-4224": {"epss_score": 0.02564, "epss_percentile": 0.85112}, "CVE-2023-4225": {"epss_score": 0.02337, "epss_percentile": 0.8442}, "CVE-2023-4226": {"epss_score": 0.23953, "epss_percentile": 0.95837}, "CVE-2023-4227": {"epss_score": 0.00161, "epss_percentile": 0.37606}, "CVE-2023-4228": {"epss_score": 0.00188, "epss_percentile": 0.40895}, "CVE-2023-4229": {"epss_score": 0.0012, "epss_percentile": 0.31807}, "CVE-2023-4230": {"epss_score": 0.00162, "epss_percentile": 0.37664}, "CVE-2023-4231": {"epss_score": 0.00143, "epss_percentile": 0.35105}, "CVE-2023-4232": {"epss_score": 0.00109, "epss_percentile": 0.30004}, "CVE-2023-4233": {"epss_score": 0.00145, "epss_percentile": 0.35436}, "CVE-2023-4234": {"epss_score": 0.00145, "epss_percentile": 0.35436}, "CVE-2023-4235": {"epss_score": 0.00136, "epss_percentile": 0.34085}, "CVE-2023-4236": {"epss_score": 0.00177, "epss_percentile": 0.39515}, "CVE-2023-4237": {"epss_score": 0.00061, "epss_percentile": 0.19277}, "CVE-2023-4238": {"epss_score": 0.21204, "epss_percentile": 0.95476}, "CVE-2023-4239": {"epss_score": 0.0006, "epss_percentile": 0.19183}, "CVE-2023-4241": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-4242": {"epss_score": 0.00086, "epss_percentile": 0.25324}, "CVE-2023-4243": {"epss_score": 0.00531, "epss_percentile": 0.66656}, "CVE-2023-4244": {"epss_score": 0.00018, "epss_percentile": 0.0361}, "CVE-2023-4245": {"epss_score": 0.00117, "epss_percentile": 0.31331}, "CVE-2023-4246": {"epss_score": 0.00319, "epss_percentile": 0.54484}, "CVE-2023-4247": {"epss_score": 0.0008, "epss_percentile": 0.24107}, "CVE-2023-4248": {"epss_score": 0.00088, "epss_percentile": 0.25746}, "CVE-2023-4249": {"epss_score": 0.00538, "epss_percentile": 0.66946}, "CVE-2023-4250": {"epss_score": 0.00257, "epss_percentile": 0.48926}, "CVE-2023-4251": {"epss_score": 0.0014, "epss_percentile": 0.34669}, "CVE-2023-4252": {"epss_score": 0.001, "epss_percentile": 0.28512}, "CVE-2023-4253": {"epss_score": 0.00089, "epss_percentile": 0.2581}, "CVE-2023-4254": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-4255": {"epss_score": 0.00016, "epss_percentile": 0.02633}, "CVE-2023-4256": {"epss_score": 0.00011, "epss_percentile": 0.01111}, "CVE-2023-4257": {"epss_score": 0.00433, "epss_percentile": 0.6218}, "CVE-2023-4258": {"epss_score": 0.00166, "epss_percentile": 0.38229}, "CVE-2023-4259": {"epss_score": 0.00174, "epss_percentile": 0.39199}, "CVE-2023-4260": {"epss_score": 0.0026, "epss_percentile": 0.49186}, "CVE-2023-4263": {"epss_score": 0.00084, "epss_percentile": 0.24941}, "CVE-2023-4264": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2023-4265": {"epss_score": 0.00301, "epss_percentile": 0.52996}, "CVE-2023-4269": {"epss_score": 0.00111, "epss_percentile": 0.30381}, "CVE-2023-4270": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2023-4271": {"epss_score": 0.00113, "epss_percentile": 0.30584}, "CVE-2023-4272": {"epss_score": 0.00263, "epss_percentile": 0.49518}, "CVE-2023-4273": {"epss_score": 0.00065, "epss_percentile": 0.20531}, "CVE-2023-4274": {"epss_score": 0.00517, "epss_percentile": 0.66065}, "CVE-2023-4276": {"epss_score": 0.00092, "epss_percentile": 0.26561}, "CVE-2023-4277": {"epss_score": 0.00067, "epss_percentile": 0.21145}, "CVE-2023-4278": {"epss_score": 0.18992, "epss_percentile": 0.95108}, "CVE-2023-4279": {"epss_score": 0.02057, "epss_percentile": 0.8343}, "CVE-2023-4280": {"epss_score": 0.00073, "epss_percentile": 0.22658}, "CVE-2023-4281": {"epss_score": 0.01525, "epss_percentile": 0.80855}, "CVE-2023-4282": {"epss_score": 0.00068, "epss_percentile": 0.21366}, "CVE-2023-4283": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-4284": {"epss_score": 0.07924, "epss_percentile": 0.91765}, "CVE-2023-4289": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-4290": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-4291": {"epss_score": 0.00716, "epss_percentile": 0.71866}, "CVE-2023-4292": {"epss_score": 0.00068, "epss_percentile": 0.2121}, "CVE-2023-4293": {"epss_score": 0.00196, "epss_percentile": 0.41799}, "CVE-2023-4294": {"epss_score": 0.31928, "epss_percentile": 0.9666}, "CVE-2023-4295": {"epss_score": 0.00146, "epss_percentile": 0.35625}, "CVE-2023-4296": {"epss_score": 0.01046, "epss_percentile": 0.77027}, "CVE-2023-4297": {"epss_score": 0.00277, "epss_percentile": 0.50777}, "CVE-2023-4298": {"epss_score": 0.00239, "epss_percentile": 0.46877}, "CVE-2023-4299": {"epss_score": 0.00018, "epss_percentile": 0.03722}, "CVE-2023-4300": {"epss_score": 0.11127, "epss_percentile": 0.93231}, "CVE-2023-4301": {"epss_score": 0.00171, "epss_percentile": 0.38862}, "CVE-2023-4302": {"epss_score": 0.00176, "epss_percentile": 0.39465}, "CVE-2023-4303": {"epss_score": 0.0021, "epss_percentile": 0.43475}, "CVE-2023-4304": {"epss_score": 0.00149, "epss_percentile": 0.35932}, "CVE-2023-4307": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-4308": {"epss_score": 0.00289, "epss_percentile": 0.52005}, "CVE-2023-4309": {"epss_score": 0.00558, "epss_percentile": 0.67571}, "CVE-2023-4310": {"epss_score": 0.02712, "epss_percentile": 0.85502}, "CVE-2023-4311": {"epss_score": 0.00364, "epss_percentile": 0.57939}, "CVE-2023-4314": {"epss_score": 0.04714, "epss_percentile": 0.89041}, "CVE-2023-4315": {"epss_score": 0.00601, "epss_percentile": 0.68846}, "CVE-2023-4316": {"epss_score": 0.00144, "epss_percentile": 0.35236}, "CVE-2023-4317": {"epss_score": 0.00046, "epss_percentile": 0.14315}, "CVE-2023-4318": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2023-4320": {"epss_score": 0.0005, "epss_percentile": 0.1567}, "CVE-2023-4321": {"epss_score": 0.00383, "epss_percentile": 0.5908}, "CVE-2023-4322": {"epss_score": 0.00237, "epss_percentile": 0.46734}, "CVE-2023-4323": {"epss_score": 0.00085, "epss_percentile": 0.25109}, "CVE-2023-4324": {"epss_score": 0.00085, "epss_percentile": 0.25109}, "CVE-2023-4325": {"epss_score": 0.00085, "epss_percentile": 0.25109}, "CVE-2023-4326": {"epss_score": 0.0006, "epss_percentile": 0.19208}, "CVE-2023-4327": {"epss_score": 0.00021, "epss_percentile": 0.04941}, "CVE-2023-4328": {"epss_score": 0.00021, "epss_percentile": 0.04941}, "CVE-2023-4329": {"epss_score": 0.00085, "epss_percentile": 0.25109}, "CVE-2023-4331": {"epss_score": 0.00037, "epss_percentile": 0.11}, "CVE-2023-4332": {"epss_score": 0.00054, "epss_percentile": 0.17057}, "CVE-2023-4333": {"epss_score": 0.00013, "epss_percentile": 0.01615}, "CVE-2023-4334": {"epss_score": 0.00072, "epss_percentile": 0.22303}, "CVE-2023-4335": {"epss_score": 0.00072, "epss_percentile": 0.22303}, "CVE-2023-4336": {"epss_score": 0.00085, "epss_percentile": 0.25109}, "CVE-2023-4337": {"epss_score": 0.00085, "epss_percentile": 0.25109}, "CVE-2023-4338": {"epss_score": 0.00085, "epss_percentile": 0.25109}, "CVE-2023-4339": {"epss_score": 0.0006, "epss_percentile": 0.19233}, "CVE-2023-4340": {"epss_score": 0.00086, "epss_percentile": 0.25432}, "CVE-2023-4341": {"epss_score": 0.00086, "epss_percentile": 0.25432}, "CVE-2023-4342": {"epss_score": 0.00085, "epss_percentile": 0.25109}, "CVE-2023-4343": {"epss_score": 0.0008, "epss_percentile": 0.24108}, "CVE-2023-4344": {"epss_score": 0.00085, "epss_percentile": 0.25109}, "CVE-2023-4345": {"epss_score": 0.00037, "epss_percentile": 0.10862}, "CVE-2023-4346": {"epss_score": 0.00047, "epss_percentile": 0.1465}, "CVE-2023-4347": {"epss_score": 0.78848, "epss_percentile": 0.99006}, "CVE-2023-4349": {"epss_score": 0.00962, "epss_percentile": 0.75998}, "CVE-2023-4350": {"epss_score": 0.00322, "epss_percentile": 0.54794}, "CVE-2023-4351": {"epss_score": 0.00717, "epss_percentile": 0.71876}, "CVE-2023-4352": {"epss_score": 0.01414, "epss_percentile": 0.8013}, "CVE-2023-4353": {"epss_score": 0.01372, "epss_percentile": 0.79816}, "CVE-2023-4354": {"epss_score": 0.01969, "epss_percentile": 0.83092}, "CVE-2023-4355": {"epss_score": 0.39284, "epss_percentile": 0.97151}, "CVE-2023-4356": {"epss_score": 0.00962, "epss_percentile": 0.75998}, "CVE-2023-4357": {"epss_score": 0.56986, "epss_percentile": 0.98042}, "CVE-2023-4358": {"epss_score": 0.00962, "epss_percentile": 0.75998}, "CVE-2023-4359": {"epss_score": 0.00237, "epss_percentile": 0.46666}, "CVE-2023-4360": {"epss_score": 0.00345, "epss_percentile": 0.56563}, "CVE-2023-4361": {"epss_score": 0.00054, "epss_percentile": 0.17061}, "CVE-2023-4362": {"epss_score": 0.25555, "epss_percentile": 0.9604}, "CVE-2023-4363": {"epss_score": 0.00256, "epss_percentile": 0.48812}, "CVE-2023-4364": {"epss_score": 0.00345, "epss_percentile": 0.56563}, "CVE-2023-4365": {"epss_score": 0.00345, "epss_percentile": 0.56563}, "CVE-2023-4366": {"epss_score": 0.00133, "epss_percentile": 0.33721}, "CVE-2023-4367": {"epss_score": 0.00068, "epss_percentile": 0.2127}, "CVE-2023-4368": {"epss_score": 0.0005, "epss_percentile": 0.15926}, "CVE-2023-4369": {"epss_score": 0.00072, "epss_percentile": 0.22374}, "CVE-2023-4371": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-4372": {"epss_score": 0.01532, "epss_percentile": 0.80895}, "CVE-2023-4373": {"epss_score": 0.00159, "epss_percentile": 0.37355}, "CVE-2023-4374": {"epss_score": 0.00137, "epss_percentile": 0.34323}, "CVE-2023-4376": {"epss_score": 0.00171, "epss_percentile": 0.38784}, "CVE-2023-4378": {"epss_score": 0.00106, "epss_percentile": 0.29429}, "CVE-2023-4379": {"epss_score": 0.00012, "epss_percentile": 0.01354}, "CVE-2023-4380": {"epss_score": 0.00075, "epss_percentile": 0.23013}, "CVE-2023-4381": {"epss_score": 0.00057, "epss_percentile": 0.18172}, "CVE-2023-4382": {"epss_score": 0.00405, "epss_percentile": 0.60462}, "CVE-2023-4383": {"epss_score": 0.0003, "epss_percentile": 0.07988}, "CVE-2023-4384": {"epss_score": 0.0004, "epss_percentile": 0.12082}, "CVE-2023-4385": {"epss_score": 0.00015, "epss_percentile": 0.02249}, "CVE-2023-4386": {"epss_score": 0.04035, "epss_percentile": 0.88156}, "CVE-2023-4387": {"epss_score": 9e-05, "epss_percentile": 0.0071}, "CVE-2023-4388": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-4389": {"epss_score": 0.00017, "epss_percentile": 0.03255}, "CVE-2023-4390": {"epss_score": 0.00171, "epss_percentile": 0.38784}, "CVE-2023-4392": {"epss_score": 0.00052, "epss_percentile": 0.1658}, "CVE-2023-4393": {"epss_score": 0.00297, "epss_percentile": 0.52696}, "CVE-2023-4394": {"epss_score": 0.00013, "epss_percentile": 0.01584}, "CVE-2023-4395": {"epss_score": 0.0011, "epss_percentile": 0.30121}, "CVE-2023-4397": {"epss_score": 0.00041, "epss_percentile": 0.12248}, "CVE-2023-4398": {"epss_score": 0.00193, "epss_percentile": 0.41465}, "CVE-2023-4399": {"epss_score": 0.00035, "epss_percentile": 0.1004}, "CVE-2023-4400": {"epss_score": 0.00084, "epss_percentile": 0.24985}, "CVE-2023-4401": {"epss_score": 0.00425, "epss_percentile": 0.6169}, "CVE-2023-4402": {"epss_score": 0.02874, "epss_percentile": 0.85881}, "CVE-2023-4404": {"epss_score": 0.00241, "epss_percentile": 0.47275}, "CVE-2023-4406": {"epss_score": 0.00081, "epss_percentile": 0.24373}, "CVE-2023-4407": {"epss_score": 0.00058, "epss_percentile": 0.18568}, "CVE-2023-4408": {"epss_score": 0.00271, "epss_percentile": 0.50342}, "CVE-2023-4409": {"epss_score": 0.00079, "epss_percentile": 0.23812}, "CVE-2023-4410": {"epss_score": 0.01108, "epss_percentile": 0.7764}, "CVE-2023-4411": {"epss_score": 0.01108, "epss_percentile": 0.7764}, "CVE-2023-4412": {"epss_score": 0.01108, "epss_percentile": 0.7764}, "CVE-2023-4414": {"epss_score": 0.04922, "epss_percentile": 0.89292}, "CVE-2023-4415": {"epss_score": 0.89966, "epss_percentile": 0.99554}, "CVE-2023-4417": {"epss_score": 0.00216, "epss_percentile": 0.44153}, "CVE-2023-4418": {"epss_score": 0.00113, "epss_percentile": 0.30683}, "CVE-2023-4419": {"epss_score": 0.00732, "epss_percentile": 0.72191}, "CVE-2023-4420": {"epss_score": 0.00066, "epss_percentile": 0.2091}, "CVE-2023-4421": {"epss_score": 0.00244, "epss_percentile": 0.47528}, "CVE-2023-4422": {"epss_score": 0.00128, "epss_percentile": 0.33019}, "CVE-2023-4423": {"epss_score": 0.00317, "epss_percentile": 0.54312}, "CVE-2023-4424": {"epss_score": 0.00135, "epss_percentile": 0.34052}, "CVE-2023-4427": {"epss_score": 0.79336, "epss_percentile": 0.99034}, "CVE-2023-4428": {"epss_score": 0.08919, "epss_percentile": 0.92318}, "CVE-2023-4429": {"epss_score": 0.00369, "epss_percentile": 0.58257}, "CVE-2023-4430": {"epss_score": 0.10778, "epss_percentile": 0.93101}, "CVE-2023-4431": {"epss_score": 0.00152, "epss_percentile": 0.36444}, "CVE-2023-4432": {"epss_score": 0.00287, "epss_percentile": 0.51838}, "CVE-2023-4433": {"epss_score": 0.00198, "epss_percentile": 0.42042}, "CVE-2023-4434": {"epss_score": 0.00032, "epss_percentile": 0.09042}, "CVE-2023-4435": {"epss_score": 0.00104, "epss_percentile": 0.29123}, "CVE-2023-4436": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4437": {"epss_score": 0.00057, "epss_percentile": 0.1821}, "CVE-2023-4438": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4439": {"epss_score": 0.00064, "epss_percentile": 0.20284}, "CVE-2023-4440": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4441": {"epss_score": 0.00045, "epss_percentile": 0.13713}, "CVE-2023-4442": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4443": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4444": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4445": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-4446": {"epss_score": 0.00131, "epss_percentile": 0.33383}, "CVE-2023-4447": {"epss_score": 0.00178, "epss_percentile": 0.39668}, "CVE-2023-4448": {"epss_score": 0.0006, "epss_percentile": 0.19111}, "CVE-2023-4449": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4450": {"epss_score": 0.90234, "epss_percentile": 0.99571}, "CVE-2023-4451": {"epss_score": 0.60612, "epss_percentile": 0.98212}, "CVE-2023-4452": {"epss_score": 0.0006, "epss_percentile": 0.18958}, "CVE-2023-4453": {"epss_score": 3e-05, "epss_percentile": 0.00065}, "CVE-2023-4454": {"epss_score": 0.00151, "epss_percentile": 0.36347}, "CVE-2023-4455": {"epss_score": 0.00119, "epss_percentile": 0.31661}, "CVE-2023-4456": {"epss_score": 0.00065, "epss_percentile": 0.2051}, "CVE-2023-4457": {"epss_score": 0.00256, "epss_percentile": 0.48737}, "CVE-2023-4458": {"epss_score": 0.00118, "epss_percentile": 0.31472}, "CVE-2023-4459": {"epss_score": 0.0001, "epss_percentile": 0.00861}, "CVE-2023-4460": {"epss_score": 0.07298, "epss_percentile": 0.91391}, "CVE-2023-4462": {"epss_score": 0.00446, "epss_percentile": 0.62917}, "CVE-2023-4463": {"epss_score": 0.00096, "epss_percentile": 0.27298}, "CVE-2023-4464": {"epss_score": 0.00964, "epss_percentile": 0.76034}, "CVE-2023-4465": {"epss_score": 0.00108, "epss_percentile": 0.2976}, "CVE-2023-4466": {"epss_score": 0.00102, "epss_percentile": 0.2879}, "CVE-2023-4467": {"epss_score": 0.00026, "epss_percentile": 0.06588}, "CVE-2023-4468": {"epss_score": 0.00064, "epss_percentile": 0.20196}, "CVE-2023-4469": {"epss_score": 0.00356, "epss_percentile": 0.57371}, "CVE-2023-4471": {"epss_score": 0.00556, "epss_percentile": 0.67498}, "CVE-2023-4472": {"epss_score": 0.00116, "epss_percentile": 0.311}, "CVE-2023-4473": {"epss_score": 0.3292, "epss_percentile": 0.96736}, "CVE-2023-4474": {"epss_score": 0.13405, "epss_percentile": 0.93954}, "CVE-2023-4475": {"epss_score": 0.00074, "epss_percentile": 0.22804}, "CVE-2023-4476": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-4478": {"epss_score": 0.00298, "epss_percentile": 0.52806}, "CVE-2023-4479": {"epss_score": 0.00154, "epss_percentile": 0.3675}, "CVE-2023-4480": {"epss_score": 0.00158, "epss_percentile": 0.37194}, "CVE-2023-4481": {"epss_score": 0.00853, "epss_percentile": 0.74424}, "CVE-2023-4482": {"epss_score": 0.00105, "epss_percentile": 0.29268}, "CVE-2023-4485": {"epss_score": 0.00062, "epss_percentile": 0.19712}, "CVE-2023-4486": {"epss_score": 0.00171, "epss_percentile": 0.38886}, "CVE-2023-4487": {"epss_score": 0.00031, "epss_percentile": 0.08678}, "CVE-2023-4488": {"epss_score": 0.00477, "epss_percentile": 0.64332}, "CVE-2023-4489": {"epss_score": 0.00692, "epss_percentile": 0.71286}, "CVE-2023-4490": {"epss_score": 0.47698, "epss_percentile": 0.97597}, "CVE-2023-4491": {"epss_score": 0.00129, "epss_percentile": 0.33114}, "CVE-2023-4492": {"epss_score": 0.00125, "epss_percentile": 0.32472}, "CVE-2023-4493": {"epss_score": 0.00098, "epss_percentile": 0.27809}, "CVE-2023-4494": {"epss_score": 0.00127, "epss_percentile": 0.32916}, "CVE-2023-4495": {"epss_score": 0.00146, "epss_percentile": 0.35536}, "CVE-2023-4496": {"epss_score": 0.00146, "epss_percentile": 0.35536}, "CVE-2023-4497": {"epss_score": 0.00146, "epss_percentile": 0.35536}, "CVE-2023-4498": {"epss_score": 0.00115, "epss_percentile": 0.31012}, "CVE-2023-4499": {"epss_score": 0.00181, "epss_percentile": 0.40037}, "CVE-2023-4500": {"epss_score": 0.00133, "epss_percentile": 0.33697}, "CVE-2023-4501": {"epss_score": 0.00172, "epss_percentile": 0.39017}, "CVE-2023-4502": {"epss_score": 0.00078, "epss_percentile": 0.2377}, "CVE-2023-4503": {"epss_score": 0.00191, "epss_percentile": 0.41174}, "CVE-2023-4504": {"epss_score": 0.00035, "epss_percentile": 0.1012}, "CVE-2023-4505": {"epss_score": 0.00424, "epss_percentile": 0.61677}, "CVE-2023-4506": {"epss_score": 0.00379, "epss_percentile": 0.58849}, "CVE-2023-4507": {"epss_score": 0.01989, "epss_percentile": 0.83172}, "CVE-2023-4508": {"epss_score": 0.00026, "epss_percentile": 0.06532}, "CVE-2023-4509": {"epss_score": 0.00093, "epss_percentile": 0.26641}, "CVE-2023-4511": {"epss_score": 0.00033, "epss_percentile": 0.09183}, "CVE-2023-4512": {"epss_score": 0.00044, "epss_percentile": 0.13649}, "CVE-2023-4513": {"epss_score": 0.00033, "epss_percentile": 0.09183}, "CVE-2023-4514": {"epss_score": 0.00115, "epss_percentile": 0.30921}, "CVE-2023-4515": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2023-4516": {"epss_score": 0.00028, "epss_percentile": 0.07235}, "CVE-2023-4517": {"epss_score": 0.0007, "epss_percentile": 0.21936}, "CVE-2023-4518": {"epss_score": 0.0008, "epss_percentile": 0.24154}, "CVE-2023-4520": {"epss_score": 0.0078, "epss_percentile": 0.73165}, "CVE-2023-4521": {"epss_score": 0.91709, "epss_percentile": 0.99663}, "CVE-2023-4522": {"epss_score": 0.00097, "epss_percentile": 0.27566}, "CVE-2023-4523": {"epss_score": 0.00085, "epss_percentile": 0.25132}, "CVE-2023-4527": {"epss_score": 0.00105, "epss_percentile": 0.29354}, "CVE-2023-4528": {"epss_score": 0.25839, "epss_percentile": 0.96077}, "CVE-2023-4530": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-4531": {"epss_score": 0.00061, "epss_percentile": 0.19515}, "CVE-2023-4532": {"epss_score": 0.00078, "epss_percentile": 0.23752}, "CVE-2023-4534": {"epss_score": 0.00058, "epss_percentile": 0.18461}, "CVE-2023-4535": {"epss_score": 0.00237, "epss_percentile": 0.46659}, "CVE-2023-4536": {"epss_score": 0.00567, "epss_percentile": 0.67857}, "CVE-2023-4537": {"epss_score": 0.00113, "epss_percentile": 0.30683}, "CVE-2023-4538": {"epss_score": 0.00048, "epss_percentile": 0.15136}, "CVE-2023-4539": {"epss_score": 0.00082, "epss_percentile": 0.24462}, "CVE-2023-4540": {"epss_score": 0.00074, "epss_percentile": 0.22761}, "CVE-2023-4541": {"epss_score": 0.00146, "epss_percentile": 0.3558}, "CVE-2023-4542": {"epss_score": 0.92647, "epss_percentile": 0.99733}, "CVE-2023-4543": {"epss_score": 0.00135, "epss_percentile": 0.33965}, "CVE-2023-4544": {"epss_score": 0.00017, "epss_percentile": 0.03395}, "CVE-2023-4545": {"epss_score": 0.00057, "epss_percentile": 0.1821}, "CVE-2023-4546": {"epss_score": 0.0002, "epss_percentile": 0.04513}, "CVE-2023-4547": {"epss_score": 0.16405, "epss_percentile": 0.94647}, "CVE-2023-4548": {"epss_score": 0.01538, "epss_percentile": 0.80932}, "CVE-2023-4549": {"epss_score": 0.01316, "epss_percentile": 0.79409}, "CVE-2023-4550": {"epss_score": 0.00074, "epss_percentile": 0.2275}, "CVE-2023-4551": {"epss_score": 0.00128, "epss_percentile": 0.33009}, "CVE-2023-4552": {"epss_score": 0.00055, "epss_percentile": 0.17439}, "CVE-2023-4553": {"epss_score": 0.0007, "epss_percentile": 0.21866}, "CVE-2023-4554": {"epss_score": 0.00033, "epss_percentile": 0.09411}, "CVE-2023-4555": {"epss_score": 0.00058, "epss_percentile": 0.18461}, "CVE-2023-4556": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4557": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4558": {"epss_score": 0.00057, "epss_percentile": 0.1821}, "CVE-2023-4559": {"epss_score": 0.00055, "epss_percentile": 0.17609}, "CVE-2023-4560": {"epss_score": 0.00185, "epss_percentile": 0.40476}, "CVE-2023-4561": {"epss_score": 0.00145, "epss_percentile": 0.35483}, "CVE-2023-4562": {"epss_score": 0.00232, "epss_percentile": 0.45927}, "CVE-2023-4564": {"epss_score": 0.0005, "epss_percentile": 0.1584}, "CVE-2023-4565": {"epss_score": 0.00068, "epss_percentile": 0.21409}, "CVE-2023-4566": {"epss_score": 0.0008, "epss_percentile": 0.24193}, "CVE-2023-4568": {"epss_score": 0.83198, "epss_percentile": 0.99238}, "CVE-2023-4569": {"epss_score": 0.00013, "epss_percentile": 0.01438}, "CVE-2023-4570": {"epss_score": 0.00113, "epss_percentile": 0.30606}, "CVE-2023-4571": {"epss_score": 0.00096, "epss_percentile": 0.27333}, "CVE-2023-4572": {"epss_score": 0.00328, "epss_percentile": 0.55153}, "CVE-2023-4573": {"epss_score": 0.00189, "epss_percentile": 0.40982}, "CVE-2023-4574": {"epss_score": 0.00145, "epss_percentile": 0.35371}, "CVE-2023-4575": {"epss_score": 0.00189, "epss_percentile": 0.40982}, "CVE-2023-4576": {"epss_score": 0.00248, "epss_percentile": 0.47997}, "CVE-2023-4577": {"epss_score": 0.00102, "epss_percentile": 0.28757}, "CVE-2023-4578": {"epss_score": 0.00151, "epss_percentile": 0.36331}, "CVE-2023-4579": {"epss_score": 0.00167, "epss_percentile": 0.38366}, "CVE-2023-4580": {"epss_score": 0.00082, "epss_percentile": 0.24404}, "CVE-2023-4581": {"epss_score": 0.00169, "epss_percentile": 0.38566}, "CVE-2023-4582": {"epss_score": 0.00641, "epss_percentile": 0.69983}, "CVE-2023-4583": {"epss_score": 0.00146, "epss_percentile": 0.35548}, "CVE-2023-4584": {"epss_score": 0.00275, "epss_percentile": 0.50649}, "CVE-2023-4585": {"epss_score": 0.00191, "epss_percentile": 0.41256}, "CVE-2023-4586": {"epss_score": 0.0013, "epss_percentile": 0.3328}, "CVE-2023-4587": {"epss_score": 0.0001, "epss_percentile": 0.00917}, "CVE-2023-4588": {"epss_score": 0.00144, "epss_percentile": 0.35266}, "CVE-2023-4589": {"epss_score": 0.0011, "epss_percentile": 0.30236}, "CVE-2023-4590": {"epss_score": 0.00411, "epss_percentile": 0.60851}, "CVE-2023-4591": {"epss_score": 0.00088, "epss_percentile": 0.25734}, "CVE-2023-4592": {"epss_score": 0.00052, "epss_percentile": 0.16668}, "CVE-2023-4593": {"epss_score": 0.00034, "epss_percentile": 0.09464}, "CVE-2023-4594": {"epss_score": 0.00078, "epss_percentile": 0.2357}, "CVE-2023-4595": {"epss_score": 0.00084, "epss_percentile": 0.24953}, "CVE-2023-4596": {"epss_score": 0.93072, "epss_percentile": 0.99774}, "CVE-2023-4597": {"epss_score": 0.00226, "epss_percentile": 0.45255}, "CVE-2023-4598": {"epss_score": 0.00165, "epss_percentile": 0.38068}, "CVE-2023-4599": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2023-4600": {"epss_score": 0.00072, "epss_percentile": 0.22361}, "CVE-2023-4601": {"epss_score": 0.00208, "epss_percentile": 0.43228}, "CVE-2023-4602": {"epss_score": 0.0087, "epss_percentile": 0.74696}, "CVE-2023-4603": {"epss_score": 0.0062, "epss_percentile": 0.69437}, "CVE-2023-4604": {"epss_score": 0.01989, "epss_percentile": 0.83172}, "CVE-2023-4605": {"epss_score": 0.0007, "epss_percentile": 0.2181}, "CVE-2023-4606": {"epss_score": 0.00117, "epss_percentile": 0.31288}, "CVE-2023-4607": {"epss_score": 0.00125, "epss_percentile": 0.32508}, "CVE-2023-4608": {"epss_score": 0.00095, "epss_percentile": 0.27229}, "CVE-2023-4611": {"epss_score": 0.00019, "epss_percentile": 0.04369}, "CVE-2023-4612": {"epss_score": 0.00044, "epss_percentile": 0.1363}, "CVE-2023-4613": {"epss_score": 0.03483, "epss_percentile": 0.87224}, "CVE-2023-4614": {"epss_score": 0.03848, "epss_percentile": 0.87844}, "CVE-2023-4615": {"epss_score": 0.00155, "epss_percentile": 0.36842}, "CVE-2023-4616": {"epss_score": 0.00155, "epss_percentile": 0.36842}, "CVE-2023-4617": {"epss_score": 0.00536, "epss_percentile": 0.66863}, "CVE-2023-4620": {"epss_score": 0.01105, "epss_percentile": 0.77603}, "CVE-2023-4622": {"epss_score": 0.0005, "epss_percentile": 0.1598}, "CVE-2023-4623": {"epss_score": 0.00017, "epss_percentile": 0.0311}, "CVE-2023-4624": {"epss_score": 0.00478, "epss_percentile": 0.64399}, "CVE-2023-4625": {"epss_score": 0.00106, "epss_percentile": 0.29428}, "CVE-2023-4626": {"epss_score": 0.00107, "epss_percentile": 0.29688}, "CVE-2023-4627": {"epss_score": 0.00107, "epss_percentile": 0.29688}, "CVE-2023-4628": {"epss_score": 0.00173, "epss_percentile": 0.39137}, "CVE-2023-4629": {"epss_score": 0.00156, "epss_percentile": 0.36999}, "CVE-2023-4630": {"epss_score": 0.00133, "epss_percentile": 0.33714}, "CVE-2023-4631": {"epss_score": 0.01656, "epss_percentile": 0.81598}, "CVE-2023-4632": {"epss_score": 0.0007, "epss_percentile": 0.21766}, "CVE-2023-4634": {"epss_score": 0.92833, "epss_percentile": 0.99753}, "CVE-2023-4635": {"epss_score": 0.01247, "epss_percentile": 0.78861}, "CVE-2023-4636": {"epss_score": 0.03038, "epss_percentile": 0.86266}, "CVE-2023-4637": {"epss_score": 0.00695, "epss_percentile": 0.71364}, "CVE-2023-4639": {"epss_score": 0.04993, "epss_percentile": 0.8937}, "CVE-2023-4640": {"epss_score": 0.00074, "epss_percentile": 0.2275}, "CVE-2023-4641": {"epss_score": 0.00015, "epss_percentile": 0.02551}, "CVE-2023-4642": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2023-4643": {"epss_score": 0.00513, "epss_percentile": 0.65925}, "CVE-2023-4645": {"epss_score": 0.00249, "epss_percentile": 0.48067}, "CVE-2023-4646": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-4647": {"epss_score": 0.00216, "epss_percentile": 0.44171}, "CVE-2023-4648": {"epss_score": 0.00156, "epss_percentile": 0.36914}, "CVE-2023-4649": {"epss_score": 0.00059, "epss_percentile": 0.18909}, "CVE-2023-4650": {"epss_score": 0.00035, "epss_percentile": 0.10154}, "CVE-2023-4651": {"epss_score": 0.00044, "epss_percentile": 0.13648}, "CVE-2023-4652": {"epss_score": 0.00062, "epss_percentile": 0.19787}, "CVE-2023-4653": {"epss_score": 0.00072, "epss_percentile": 0.22414}, "CVE-2023-4654": {"epss_score": 0.00035, "epss_percentile": 0.10132}, "CVE-2023-4655": {"epss_score": 0.00068, "epss_percentile": 0.21191}, "CVE-2023-4658": {"epss_score": 0.0005, "epss_percentile": 0.15949}, "CVE-2023-4659": {"epss_score": 0.00244, "epss_percentile": 0.47602}, "CVE-2023-4661": {"epss_score": 0.0019, "epss_percentile": 0.41099}, "CVE-2023-4662": {"epss_score": 0.00739, "epss_percentile": 0.72389}, "CVE-2023-4663": {"epss_score": 0.00286, "epss_percentile": 0.51755}, "CVE-2023-4664": {"epss_score": 0.00156, "epss_percentile": 0.36951}, "CVE-2023-4665": {"epss_score": 0.00565, "epss_percentile": 0.67784}, "CVE-2023-4666": {"epss_score": 0.75729, "epss_percentile": 0.98862}, "CVE-2023-4667": {"epss_score": 0.00103, "epss_percentile": 0.2898}, "CVE-2023-4668": {"epss_score": 0.00641, "epss_percentile": 0.69993}, "CVE-2023-4669": {"epss_score": 0.00079, "epss_percentile": 0.23889}, "CVE-2023-4670": {"epss_score": 0.00143, "epss_percentile": 0.35105}, "CVE-2023-4671": {"epss_score": 0.0007, "epss_percentile": 0.21667}, "CVE-2023-4672": {"epss_score": 0.00081, "epss_percentile": 0.24373}, "CVE-2023-4673": {"epss_score": 0.00143, "epss_percentile": 0.35105}, "CVE-2023-4674": {"epss_score": 0.00139, "epss_percentile": 0.34591}, "CVE-2023-4675": {"epss_score": 0.00091, "epss_percentile": 0.2625}, "CVE-2023-4676": {"epss_score": 0.00197, "epss_percentile": 0.41858}, "CVE-2023-4677": {"epss_score": 0.00109, "epss_percentile": 0.29916}, "CVE-2023-4678": {"epss_score": 0.0002, "epss_percentile": 0.0466}, "CVE-2023-4679": {"epss_score": 0.00041, "epss_percentile": 0.12446}, "CVE-2023-4680": {"epss_score": 0.01521, "epss_percentile": 0.80828}, "CVE-2023-4681": {"epss_score": 0.00024, "epss_percentile": 0.05862}, "CVE-2023-4682": {"epss_score": 0.00028, "epss_percentile": 0.07269}, "CVE-2023-4683": {"epss_score": 0.00038, "epss_percentile": 0.11167}, "CVE-2023-4685": {"epss_score": 0.00063, "epss_percentile": 0.19824}, "CVE-2023-4686": {"epss_score": 0.00139, "epss_percentile": 0.34569}, "CVE-2023-4687": {"epss_score": 0.00549, "epss_percentile": 0.67295}, "CVE-2023-4688": {"epss_score": 0.00032, "epss_percentile": 0.08952}, "CVE-2023-4689": {"epss_score": 0.00049, "epss_percentile": 0.15502}, "CVE-2023-4690": {"epss_score": 0.00049, "epss_percentile": 0.15502}, "CVE-2023-4691": {"epss_score": 0.00199, "epss_percentile": 0.42156}, "CVE-2023-4692": {"epss_score": 4e-05, "epss_percentile": 0.00147}, "CVE-2023-4693": {"epss_score": 9e-05, "epss_percentile": 0.00716}, "CVE-2023-4694": {"epss_score": 0.00585, "epss_percentile": 0.68405}, "CVE-2023-4695": {"epss_score": 0.0009, "epss_percentile": 0.26064}, "CVE-2023-4696": {"epss_score": 0.01252, "epss_percentile": 0.78912}, "CVE-2023-4697": {"epss_score": 0.00075, "epss_percentile": 0.23052}, "CVE-2023-4698": {"epss_score": 0.01623, "epss_percentile": 0.81403}, "CVE-2023-4699": {"epss_score": 0.00913, "epss_percentile": 0.75379}, "CVE-2023-4700": {"epss_score": 6e-05, "epss_percentile": 0.00306}, "CVE-2023-4702": {"epss_score": 0.0006, "epss_percentile": 0.18984}, "CVE-2023-4703": {"epss_score": 0.0026, "epss_percentile": 0.49243}, "CVE-2023-4704": {"epss_score": 0.00077, "epss_percentile": 0.23415}, "CVE-2023-4706": {"epss_score": 0.00072, "epss_percentile": 0.22389}, "CVE-2023-4707": {"epss_score": 0.00059, "epss_percentile": 0.18831}, "CVE-2023-4708": {"epss_score": 0.03352, "epss_percentile": 0.86966}, "CVE-2023-4709": {"epss_score": 0.00073, "epss_percentile": 0.22596}, "CVE-2023-4710": {"epss_score": 0.00061, "epss_percentile": 0.19292}, "CVE-2023-4711": {"epss_score": 0.0038, "epss_percentile": 0.58944}, "CVE-2023-4712": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-4713": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4714": {"epss_score": 0.91497, "epss_percentile": 0.99648}, "CVE-2023-4716": {"epss_score": 0.00133, "epss_percentile": 0.33645}, "CVE-2023-4718": {"epss_score": 0.00081, "epss_percentile": 0.24269}, "CVE-2023-4719": {"epss_score": 0.01417, "epss_percentile": 0.80149}, "CVE-2023-4720": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2023-4721": {"epss_score": 0.00023, "epss_percentile": 0.05402}, "CVE-2023-4722": {"epss_score": 0.00023, "epss_percentile": 0.05449}, "CVE-2023-4723": {"epss_score": 0.00234, "epss_percentile": 0.46107}, "CVE-2023-4724": {"epss_score": 0.01015, "epss_percentile": 0.76655}, "CVE-2023-4725": {"epss_score": 0.00078, "epss_percentile": 0.2377}, "CVE-2023-4726": {"epss_score": 0.00101, "epss_percentile": 0.28573}, "CVE-2023-4727": {"epss_score": 0.00047, "epss_percentile": 0.14897}, "CVE-2023-4728": {"epss_score": 0.001, "epss_percentile": 0.28516}, "CVE-2023-4729": {"epss_score": 0.00204, "epss_percentile": 0.42613}, "CVE-2023-4730": {"epss_score": 0.00466, "epss_percentile": 0.63804}, "CVE-2023-4731": {"epss_score": 0.00212, "epss_percentile": 0.43782}, "CVE-2023-4732": {"epss_score": 0.00014, "epss_percentile": 0.01883}, "CVE-2023-4733": {"epss_score": 0.00036, "epss_percentile": 0.10211}, "CVE-2023-4734": {"epss_score": 0.00036, "epss_percentile": 0.10616}, "CVE-2023-4735": {"epss_score": 0.00027, "epss_percentile": 0.06883}, "CVE-2023-4736": {"epss_score": 0.0003, "epss_percentile": 0.08238}, "CVE-2023-4737": {"epss_score": 0.00166, "epss_percentile": 0.38144}, "CVE-2023-4738": {"epss_score": 0.00041, "epss_percentile": 0.1229}, "CVE-2023-4739": {"epss_score": 0.00043, "epss_percentile": 0.13212}, "CVE-2023-4740": {"epss_score": 0.00054, "epss_percentile": 0.17105}, "CVE-2023-4741": {"epss_score": 0.00135, "epss_percentile": 0.33976}, "CVE-2023-4742": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4743": {"epss_score": 0.00063, "epss_percentile": 0.20091}, "CVE-2023-4744": {"epss_score": 0.00596, "epss_percentile": 0.68707}, "CVE-2023-4745": {"epss_score": 0.00099, "epss_percentile": 0.28307}, "CVE-2023-4746": {"epss_score": 0.00285, "epss_percentile": 0.51643}, "CVE-2023-4747": {"epss_score": 0.0005, "epss_percentile": 0.15953}, "CVE-2023-4748": {"epss_score": 0.00092, "epss_percentile": 0.26456}, "CVE-2023-4749": {"epss_score": 0.00058, "epss_percentile": 0.18389}, "CVE-2023-4750": {"epss_score": 0.00036, "epss_percentile": 0.10206}, "CVE-2023-4751": {"epss_score": 0.00045, "epss_percentile": 0.13785}, "CVE-2023-4752": {"epss_score": 0.00057, "epss_percentile": 0.18061}, "CVE-2023-4753": {"epss_score": 0.00024, "epss_percentile": 0.05808}, "CVE-2023-4754": {"epss_score": 0.00034, "epss_percentile": 0.09757}, "CVE-2023-4755": {"epss_score": 0.00034, "epss_percentile": 0.09757}, "CVE-2023-4756": {"epss_score": 0.00042, "epss_percentile": 0.12813}, "CVE-2023-4757": {"epss_score": 0.0024, "epss_percentile": 0.47222}, "CVE-2023-4758": {"epss_score": 0.00025, "epss_percentile": 0.06114}, "CVE-2023-4759": {"epss_score": 0.00974, "epss_percentile": 0.76194}, "CVE-2023-4760": {"epss_score": 0.00376, "epss_percentile": 0.58668}, "CVE-2023-4761": {"epss_score": 0.00368, "epss_percentile": 0.58219}, "CVE-2023-4762": {"epss_score": 0.40215, "epss_percentile": 0.97206}, "CVE-2023-4763": {"epss_score": 0.00618, "epss_percentile": 0.69369}, "CVE-2023-4764": {"epss_score": 0.00153, "epss_percentile": 0.36612}, "CVE-2023-4766": {"epss_score": 0.0015, "epss_percentile": 0.36084}, "CVE-2023-4767": {"epss_score": 0.00906, "epss_percentile": 0.75258}, "CVE-2023-4768": {"epss_score": 0.00906, "epss_percentile": 0.75258}, "CVE-2023-4769": {"epss_score": 0.00133, "epss_percentile": 0.33702}, "CVE-2023-4770": {"epss_score": 0.00164, "epss_percentile": 0.37897}, "CVE-2023-4771": {"epss_score": 0.27232, "epss_percentile": 0.96223}, "CVE-2023-4772": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-4773": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-4774": {"epss_score": 0.00225, "epss_percentile": 0.45127}, "CVE-2023-4775": {"epss_score": 0.00101, "epss_percentile": 0.28616}, "CVE-2023-4776": {"epss_score": 0.003, "epss_percentile": 0.52907}, "CVE-2023-4777": {"epss_score": 0.00061, "epss_percentile": 0.1954}, "CVE-2023-4778": {"epss_score": 0.00021, "epss_percentile": 0.0488}, "CVE-2023-4779": {"epss_score": 0.00154, "epss_percentile": 0.36684}, "CVE-2023-4781": {"epss_score": 0.00023, "epss_percentile": 0.05344}, "CVE-2023-4782": {"epss_score": 0.00045, "epss_percentile": 0.13959}, "CVE-2023-4783": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-4785": {"epss_score": 0.00018, "epss_percentile": 0.03907}, "CVE-2023-4792": {"epss_score": 0.00073, "epss_percentile": 0.22633}, "CVE-2023-4795": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-4796": {"epss_score": 0.00233, "epss_percentile": 0.46045}, "CVE-2023-4797": {"epss_score": 0.0056, "epss_percentile": 0.67644}, "CVE-2023-4798": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-4799": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-4800": {"epss_score": 0.09324, "epss_percentile": 0.925}, "CVE-2023-4801": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2023-4802": {"epss_score": 0.0019, "epss_percentile": 0.41104}, "CVE-2023-4803": {"epss_score": 0.0019, "epss_percentile": 0.41104}, "CVE-2023-4804": {"epss_score": 0.00105, "epss_percentile": 0.29263}, "CVE-2023-4805": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-4806": {"epss_score": 0.01895, "epss_percentile": 0.82747}, "CVE-2023-4807": {"epss_score": 0.00767, "epss_percentile": 0.72948}, "CVE-2023-4808": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-4809": {"epss_score": 0.00475, "epss_percentile": 0.64177}, "CVE-2023-4810": {"epss_score": 0.00101, "epss_percentile": 0.2866}, "CVE-2023-4811": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-4812": {"epss_score": 0.0001, "epss_percentile": 0.00848}, "CVE-2023-4813": {"epss_score": 0.00304, "epss_percentile": 0.53257}, "CVE-2023-4814": {"epss_score": 0.00046, "epss_percentile": 0.14375}, "CVE-2023-4815": {"epss_score": 0.0006, "epss_percentile": 0.19204}, "CVE-2023-4816": {"epss_score": 0.00013, "epss_percentile": 0.01568}, "CVE-2023-4817": {"epss_score": 0.00022, "epss_percentile": 0.05143}, "CVE-2023-4818": {"epss_score": 0.001, "epss_percentile": 0.28505}, "CVE-2023-4819": {"epss_score": 0.00166, "epss_percentile": 0.38244}, "CVE-2023-4820": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-4821": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-4822": {"epss_score": 0.00453, "epss_percentile": 0.63228}, "CVE-2023-4823": {"epss_score": 0.00216, "epss_percentile": 0.442}, "CVE-2023-4824": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-4826": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-4827": {"epss_score": 0.06277, "epss_percentile": 0.90633}, "CVE-2023-4828": {"epss_score": 0.00138, "epss_percentile": 0.34521}, "CVE-2023-4829": {"epss_score": 0.00071, "epss_percentile": 0.22071}, "CVE-2023-4830": {"epss_score": 0.00143, "epss_percentile": 0.35105}, "CVE-2023-4831": {"epss_score": 0.00143, "epss_percentile": 0.35105}, "CVE-2023-4832": {"epss_score": 0.0015, "epss_percentile": 0.36084}, "CVE-2023-4833": {"epss_score": 0.00143, "epss_percentile": 0.35105}, "CVE-2023-4834": {"epss_score": 0.00105, "epss_percentile": 0.29382}, "CVE-2023-4835": {"epss_score": 0.00143, "epss_percentile": 0.35105}, "CVE-2023-4836": {"epss_score": 0.00276, "epss_percentile": 0.50702}, "CVE-2023-4837": {"epss_score": 0.00192, "epss_percentile": 0.41337}, "CVE-2023-4838": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-4839": {"epss_score": 0.00156, "epss_percentile": 0.36914}, "CVE-2023-4840": {"epss_score": 0.00142, "epss_percentile": 0.35079}, "CVE-2023-4841": {"epss_score": 0.00095, "epss_percentile": 0.27195}, "CVE-2023-4842": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2023-4843": {"epss_score": 0.00058, "epss_percentile": 0.18304}, "CVE-2023-4844": {"epss_score": 0.00046, "epss_percentile": 0.14091}, "CVE-2023-4845": {"epss_score": 0.00037, "epss_percentile": 0.10967}, "CVE-2023-4846": {"epss_score": 0.00042, "epss_percentile": 0.12494}, "CVE-2023-4847": {"epss_score": 0.0023, "epss_percentile": 0.45665}, "CVE-2023-4848": {"epss_score": 0.00035, "epss_percentile": 0.10135}, "CVE-2023-4849": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4850": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4851": {"epss_score": 0.00044, "epss_percentile": 0.13536}, "CVE-2023-4852": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-4853": {"epss_score": 0.00348, "epss_percentile": 0.56826}, "CVE-2023-4855": {"epss_score": 0.00374, "epss_percentile": 0.58555}, "CVE-2023-4856": {"epss_score": 0.0039, "epss_percentile": 0.595}, "CVE-2023-4857": {"epss_score": 0.00085, "epss_percentile": 0.25116}, "CVE-2023-4858": {"epss_score": 0.00089, "epss_percentile": 0.259}, "CVE-2023-4860": {"epss_score": 0.00348, "epss_percentile": 0.56827}, "CVE-2023-4861": {"epss_score": 0.03718, "epss_percentile": 0.87618}, "CVE-2023-4862": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-4863": {"epss_score": 0.94083, "epss_percentile": 0.99899}, "CVE-2023-4864": {"epss_score": 0.00169, "epss_percentile": 0.38564}, "CVE-2023-4865": {"epss_score": 0.00079, "epss_percentile": 0.2396}, "CVE-2023-4866": {"epss_score": 0.00049, "epss_percentile": 0.1532}, "CVE-2023-4867": {"epss_score": 0.00044, "epss_percentile": 0.13536}, "CVE-2023-4868": {"epss_score": 0.00079, "epss_percentile": 0.23912}, "CVE-2023-4869": {"epss_score": 0.00057, "epss_percentile": 0.18233}, "CVE-2023-4870": {"epss_score": 0.00076, "epss_percentile": 0.23173}, "CVE-2023-4871": {"epss_score": 0.00049, "epss_percentile": 0.1532}, "CVE-2023-4872": {"epss_score": 0.00049, "epss_percentile": 0.1532}, "CVE-2023-4873": {"epss_score": 0.07023, "epss_percentile": 0.91193}, "CVE-2023-4874": {"epss_score": 0.0008, "epss_percentile": 0.24128}, "CVE-2023-4875": {"epss_score": 0.00026, "epss_percentile": 0.06397}, "CVE-2023-4876": {"epss_score": 0.00072, "epss_percentile": 0.22392}, "CVE-2023-4877": {"epss_score": 0.00072, "epss_percentile": 0.22392}, "CVE-2023-4878": {"epss_score": 0.00055, "epss_percentile": 0.17577}, "CVE-2023-4879": {"epss_score": 0.00041, "epss_percentile": 0.12283}, "CVE-2023-4882": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-4883": {"epss_score": 0.00068, "epss_percentile": 0.21303}, "CVE-2023-4884": {"epss_score": 0.00056, "epss_percentile": 0.178}, "CVE-2023-4885": {"epss_score": 0.00066, "epss_percentile": 0.20932}, "CVE-2023-4886": {"epss_score": 0.00088, "epss_percentile": 0.25791}, "CVE-2023-4887": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-4888": {"epss_score": 0.00148, "epss_percentile": 0.35918}, "CVE-2023-4889": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-4890": {"epss_score": 0.00142, "epss_percentile": 0.35079}, "CVE-2023-4891": {"epss_score": 0.00032, "epss_percentile": 0.08952}, "CVE-2023-4892": {"epss_score": 0.00087, "epss_percentile": 0.2553}, "CVE-2023-4893": {"epss_score": 0.00099, "epss_percentile": 0.2839}, "CVE-2023-4895": {"epss_score": 0.00018, "epss_percentile": 0.03897}, "CVE-2023-4896": {"epss_score": 0.00072, "epss_percentile": 0.2224}, "CVE-2023-4897": {"epss_score": 0.00058, "epss_percentile": 0.18395}, "CVE-2023-4898": {"epss_score": 0.00063, "epss_percentile": 0.19807}, "CVE-2023-4899": {"epss_score": 0.00056, "epss_percentile": 0.1769}, "CVE-2023-4900": {"epss_score": 0.00271, "epss_percentile": 0.50311}, "CVE-2023-4901": {"epss_score": 0.00271, "epss_percentile": 0.50311}, "CVE-2023-4902": {"epss_score": 0.00271, "epss_percentile": 0.50311}, "CVE-2023-4903": {"epss_score": 0.00271, "epss_percentile": 0.50311}, "CVE-2023-4904": {"epss_score": 0.00068, "epss_percentile": 0.21191}, "CVE-2023-4905": {"epss_score": 0.00271, "epss_percentile": 0.50311}, "CVE-2023-4906": {"epss_score": 0.0005, "epss_percentile": 0.15857}, "CVE-2023-4907": {"epss_score": 0.00271, "epss_percentile": 0.50311}, "CVE-2023-4908": {"epss_score": 0.00271, "epss_percentile": 0.50311}, "CVE-2023-4909": {"epss_score": 0.00271, "epss_percentile": 0.50311}, "CVE-2023-4910": {"epss_score": 0.00037, "epss_percentile": 0.10762}, "CVE-2023-4911": {"epss_score": 0.69791, "epss_percentile": 0.98603}, "CVE-2023-4912": {"epss_score": 0.0006, "epss_percentile": 0.19209}, "CVE-2023-4913": {"epss_score": 0.00128, "epss_percentile": 0.3304}, "CVE-2023-4914": {"epss_score": 0.00296, "epss_percentile": 0.52533}, "CVE-2023-4915": {"epss_score": 0.00135, "epss_percentile": 0.33967}, "CVE-2023-4916": {"epss_score": 0.00134, "epss_percentile": 0.33838}, "CVE-2023-4917": {"epss_score": 0.00401, "epss_percentile": 0.60261}, "CVE-2023-4918": {"epss_score": 0.00081, "epss_percentile": 0.24351}, "CVE-2023-4919": {"epss_score": 0.00115, "epss_percentile": 0.30947}, "CVE-2023-4920": {"epss_score": 0.00076, "epss_percentile": 0.23162}, "CVE-2023-4921": {"epss_score": 0.00014, "epss_percentile": 0.02083}, "CVE-2023-4922": {"epss_score": 0.26418, "epss_percentile": 0.96145}, "CVE-2023-4923": {"epss_score": 0.00069, "epss_percentile": 0.21518}, "CVE-2023-4924": {"epss_score": 0.00071, "epss_percentile": 0.21998}, "CVE-2023-4925": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-4926": {"epss_score": 0.00069, "epss_percentile": 0.21518}, "CVE-2023-4928": {"epss_score": 0.00126, "epss_percentile": 0.32644}, "CVE-2023-4929": {"epss_score": 0.0004, "epss_percentile": 0.12146}, "CVE-2023-4930": {"epss_score": 0.00096, "epss_percentile": 0.27264}, "CVE-2023-4931": {"epss_score": 0.00043, "epss_percentile": 0.13292}, "CVE-2023-4932": {"epss_score": 0.00106, "epss_percentile": 0.29555}, "CVE-2023-4933": {"epss_score": 0.00167, "epss_percentile": 0.38395}, "CVE-2023-4934": {"epss_score": 0.00073, "epss_percentile": 0.22576}, "CVE-2023-4935": {"epss_score": 0.00071, "epss_percentile": 0.22013}, "CVE-2023-4936": {"epss_score": 0.00047, "epss_percentile": 0.14759}, "CVE-2023-4937": {"epss_score": 0.00071, "epss_percentile": 0.22013}, "CVE-2023-4938": {"epss_score": 0.00073, "epss_percentile": 0.22633}, "CVE-2023-4939": {"epss_score": 0.00248, "epss_percentile": 0.47923}, "CVE-2023-4940": {"epss_score": 0.00071, "epss_percentile": 0.22012}, "CVE-2023-4941": {"epss_score": 0.00103, "epss_percentile": 0.28999}, "CVE-2023-4942": {"epss_score": 0.00097, "epss_percentile": 0.27594}, "CVE-2023-4943": {"epss_score": 0.00103, "epss_percentile": 0.28999}, "CVE-2023-4944": {"epss_score": 0.00101, "epss_percentile": 0.28616}, "CVE-2023-4945": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2023-4947": {"epss_score": 0.00147, "epss_percentile": 0.35663}, "CVE-2023-4948": {"epss_score": 0.00066, "epss_percentile": 0.20874}, "CVE-2023-4949": {"epss_score": 0.00035, "epss_percentile": 0.10041}, "CVE-2023-4950": {"epss_score": 0.00549, "epss_percentile": 0.67295}, "CVE-2023-4951": {"epss_score": 0.00245, "epss_percentile": 0.4766}, "CVE-2023-4956": {"epss_score": 0.00172, "epss_percentile": 0.39017}, "CVE-2023-4957": {"epss_score": 5e-05, "epss_percentile": 0.00227}, "CVE-2023-4958": {"epss_score": 0.00033, "epss_percentile": 0.09139}, "CVE-2023-4959": {"epss_score": 0.00136, "epss_percentile": 0.34083}, "CVE-2023-4960": {"epss_score": 0.00156, "epss_percentile": 0.36975}, "CVE-2023-4961": {"epss_score": 0.00134, "epss_percentile": 0.33911}, "CVE-2023-4962": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2023-4963": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-4964": {"epss_score": 0.00069, "epss_percentile": 0.21478}, "CVE-2023-4965": {"epss_score": 0.00159, "epss_percentile": 0.37394}, "CVE-2023-4966": {"epss_score": 0.94348, "epss_percentile": 0.99954}, "CVE-2023-4967": {"epss_score": 0.00439, "epss_percentile": 0.62595}, "CVE-2023-4968": {"epss_score": 0.00174, "epss_percentile": 0.39214}, "CVE-2023-4969": {"epss_score": 0.00909, "epss_percentile": 0.75314}, "CVE-2023-4970": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-4971": {"epss_score": 0.00251, "epss_percentile": 0.48329}, "CVE-2023-4972": {"epss_score": 0.00212, "epss_percentile": 0.43794}, "CVE-2023-4973": {"epss_score": 0.03546, "epss_percentile": 0.87328}, "CVE-2023-4974": {"epss_score": 0.47951, "epss_percentile": 0.9761}, "CVE-2023-4975": {"epss_score": 0.00117, "epss_percentile": 0.31351}, "CVE-2023-4976": {"epss_score": 0.00238, "epss_percentile": 0.46803}, "CVE-2023-4977": {"epss_score": 0.00059, "epss_percentile": 0.18908}, "CVE-2023-4978": {"epss_score": 6e-05, "epss_percentile": 0.00248}, "CVE-2023-4979": {"epss_score": 0.00051, "epss_percentile": 0.16057}, "CVE-2023-4980": {"epss_score": 0.00051, "epss_percentile": 0.16057}, "CVE-2023-4981": {"epss_score": 0.00052, "epss_percentile": 0.16392}, "CVE-2023-4982": {"epss_score": 6e-05, "epss_percentile": 0.00248}, "CVE-2023-4983": {"epss_score": 0.00158, "epss_percentile": 0.37184}, "CVE-2023-4984": {"epss_score": 0.00175, "epss_percentile": 0.3929}, "CVE-2023-4985": {"epss_score": 0.00079, "epss_percentile": 0.23879}, "CVE-2023-4986": {"epss_score": 0.00038, "epss_percentile": 0.11165}, "CVE-2023-4987": {"epss_score": 0.0008, "epss_percentile": 0.2415}, "CVE-2023-4988": {"epss_score": 0.00152, "epss_percentile": 0.3641}, "CVE-2023-4990": {"epss_score": 0.00197, "epss_percentile": 0.41902}, "CVE-2023-4991": {"epss_score": 0.00171, "epss_percentile": 0.388}, "CVE-2023-4993": {"epss_score": 0.00082, "epss_percentile": 0.24462}, "CVE-2023-4994": {"epss_score": 0.0115, "epss_percentile": 0.78032}, "CVE-2023-4995": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-4996": {"epss_score": 0.00084, "epss_percentile": 0.24998}, "CVE-2023-4997": {"epss_score": 0.00071, "epss_percentile": 0.22021}, "CVE-2023-4999": {"epss_score": 0.00265, "epss_percentile": 0.49826}, "CVE-2023-50000": {"epss_score": 0.00369, "epss_percentile": 0.58235}, "CVE-2023-50001": {"epss_score": 0.00369, "epss_percentile": 0.58235}, "CVE-2023-50002": {"epss_score": 0.00369, "epss_percentile": 0.58235}, "CVE-2023-50007": {"epss_score": 0.0003, "epss_percentile": 0.08159}, "CVE-2023-50008": {"epss_score": 0.00034, "epss_percentile": 0.09521}, "CVE-2023-50009": {"epss_score": 0.0002, "epss_percentile": 0.04469}, "CVE-2023-50010": {"epss_score": 0.00033, "epss_percentile": 0.09207}, "CVE-2023-50011": {"epss_score": 0.03537, "epss_percentile": 0.87312}, "CVE-2023-50015": {"epss_score": 0.00581, "epss_percentile": 0.6828}, "CVE-2023-50017": {"epss_score": 0.00237, "epss_percentile": 0.46725}, "CVE-2023-50019": {"epss_score": 0.00326, "epss_percentile": 0.5505}, "CVE-2023-50020": {"epss_score": 0.00339, "epss_percentile": 0.56166}, "CVE-2023-50026": {"epss_score": 0.00308, "epss_percentile": 0.53587}, "CVE-2023-50027": {"epss_score": 0.00444, "epss_percentile": 0.6285}, "CVE-2023-50028": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2023-50029": {"epss_score": 0.00735, "epss_percentile": 0.7229}, "CVE-2023-50030": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2023-50035": {"epss_score": 0.0007, "epss_percentile": 0.21648}, "CVE-2023-50038": {"epss_score": 0.00074, "epss_percentile": 0.22827}, "CVE-2023-50044": {"epss_score": 0.00106, "epss_percentile": 0.29472}, "CVE-2023-50053": {"epss_score": 0.00648, "epss_percentile": 0.7021}, "CVE-2023-50059": {"epss_score": 0.00189, "epss_percentile": 0.40973}, "CVE-2023-50061": {"epss_score": 0.00094, "epss_percentile": 0.26794}, "CVE-2023-50069": {"epss_score": 0.0059, "epss_percentile": 0.68573}, "CVE-2023-50070": {"epss_score": 0.00244, "epss_percentile": 0.47524}, "CVE-2023-50071": {"epss_score": 0.11072, "epss_percentile": 0.9321}, "CVE-2023-50072": {"epss_score": 0.0411, "epss_percentile": 0.8827}, "CVE-2023-50073": {"epss_score": 0.0012, "epss_percentile": 0.3172}, "CVE-2023-50082": {"epss_score": 0.00076, "epss_percentile": 0.23264}, "CVE-2023-50089": {"epss_score": 0.0395, "epss_percentile": 0.88}, "CVE-2023-50090": {"epss_score": 0.00098, "epss_percentile": 0.2777}, "CVE-2023-50092": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-50093": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2023-50094": {"epss_score": 0.92174, "epss_percentile": 0.99696}, "CVE-2023-50096": {"epss_score": 0.00487, "epss_percentile": 0.64779}, "CVE-2023-50100": {"epss_score": 0.0014, "epss_percentile": 0.34706}, "CVE-2023-50101": {"epss_score": 0.00193, "epss_percentile": 0.41494}, "CVE-2023-50102": {"epss_score": 0.00193, "epss_percentile": 0.41494}, "CVE-2023-50104": {"epss_score": 0.0063, "epss_percentile": 0.69688}, "CVE-2023-50110": {"epss_score": 0.0034, "epss_percentile": 0.56237}, "CVE-2023-50120": {"epss_score": 0.00067, "epss_percentile": 0.21186}, "CVE-2023-50121": {"epss_score": 0.00033, "epss_percentile": 0.09164}, "CVE-2023-50123": {"epss_score": 0.00286, "epss_percentile": 0.51734}, "CVE-2023-50124": {"epss_score": 0.00092, "epss_percentile": 0.26429}, "CVE-2023-50125": {"epss_score": 0.00202, "epss_percentile": 0.42444}, "CVE-2023-50126": {"epss_score": 0.0004, "epss_percentile": 0.11958}, "CVE-2023-50127": {"epss_score": 0.00194, "epss_percentile": 0.41537}, "CVE-2023-50128": {"epss_score": 0.00016, "epss_percentile": 0.02681}, "CVE-2023-50129": {"epss_score": 0.00027, "epss_percentile": 0.06764}, "CVE-2023-50136": {"epss_score": 0.0011, "epss_percentile": 0.30148}, "CVE-2023-50137": {"epss_score": 0.00101, "epss_percentile": 0.28604}, "CVE-2023-50147": {"epss_score": 0.01187, "epss_percentile": 0.78358}, "CVE-2023-50159": {"epss_score": 0.0004, "epss_percentile": 0.12067}, "CVE-2023-50162": {"epss_score": 0.00856, "epss_percentile": 0.74486}, "CVE-2023-50164": {"epss_score": 0.93647, "epss_percentile": 0.9983}, "CVE-2023-50165": {"epss_score": 0.00091, "epss_percentile": 0.26195}, "CVE-2023-50166": {"epss_score": 0.00199, "epss_percentile": 0.42099}, "CVE-2023-50167": {"epss_score": 0.00111, "epss_percentile": 0.3039}, "CVE-2023-50168": {"epss_score": 0.00141, "epss_percentile": 0.34941}, "CVE-2023-50172": {"epss_score": 0.00183, "epss_percentile": 0.40307}, "CVE-2023-50175": {"epss_score": 0.00492, "epss_percentile": 0.65001}, "CVE-2023-50176": {"epss_score": 0.00189, "epss_percentile": 0.40933}, "CVE-2023-50178": {"epss_score": 0.00155, "epss_percentile": 0.36773}, "CVE-2023-50179": {"epss_score": 0.00216, "epss_percentile": 0.44161}, "CVE-2023-50180": {"epss_score": 0.00143, "epss_percentile": 0.35096}, "CVE-2023-50181": {"epss_score": 0.00161, "epss_percentile": 0.37568}, "CVE-2023-50186": {"epss_score": 0.09183, "epss_percentile": 0.92435}, "CVE-2023-50187": {"epss_score": 0.00553, "epss_percentile": 0.67408}, "CVE-2023-50188": {"epss_score": 0.00942, "epss_percentile": 0.75759}, "CVE-2023-50189": {"epss_score": 0.00569, "epss_percentile": 0.6792}, "CVE-2023-50190": {"epss_score": 0.00553, "epss_percentile": 0.67408}, "CVE-2023-50191": {"epss_score": 0.00591, "epss_percentile": 0.68586}, "CVE-2023-50192": {"epss_score": 0.00569, "epss_percentile": 0.6792}, "CVE-2023-50193": {"epss_score": 0.00609, "epss_percentile": 0.691}, "CVE-2023-50194": {"epss_score": 0.00569, "epss_percentile": 0.67936}, "CVE-2023-50195": {"epss_score": 0.00553, "epss_percentile": 0.67408}, "CVE-2023-50196": {"epss_score": 0.0058, "epss_percentile": 0.68239}, "CVE-2023-50197": {"epss_score": 0.00085, "epss_percentile": 0.25125}, "CVE-2023-50198": {"epss_score": 0.02451, "epss_percentile": 0.84787}, "CVE-2023-50199": {"epss_score": 0.00578, "epss_percentile": 0.6819}, "CVE-2023-50200": {"epss_score": 0.02451, "epss_percentile": 0.84787}, "CVE-2023-50201": {"epss_score": 0.02451, "epss_percentile": 0.84787}, "CVE-2023-50202": {"epss_score": 0.02451, "epss_percentile": 0.84787}, "CVE-2023-50203": {"epss_score": 0.02543, "epss_percentile": 0.85056}, "CVE-2023-50204": {"epss_score": 0.02451, "epss_percentile": 0.84787}, "CVE-2023-50205": {"epss_score": 0.01705, "epss_percentile": 0.81853}, "CVE-2023-50206": {"epss_score": 0.01705, "epss_percentile": 0.81853}, "CVE-2023-50207": {"epss_score": 0.01705, "epss_percentile": 0.81853}, "CVE-2023-50208": {"epss_score": 0.04135, "epss_percentile": 0.88306}, "CVE-2023-50209": {"epss_score": 0.04135, "epss_percentile": 0.88306}, "CVE-2023-50210": {"epss_score": 0.0488, "epss_percentile": 0.89247}, "CVE-2023-50211": {"epss_score": 0.0488, "epss_percentile": 0.89247}, "CVE-2023-50212": {"epss_score": 0.0072, "epss_percentile": 0.71958}, "CVE-2023-50213": {"epss_score": 0.01705, "epss_percentile": 0.81853}, "CVE-2023-50214": {"epss_score": 0.02543, "epss_percentile": 0.85056}, "CVE-2023-50215": {"epss_score": 0.02543, "epss_percentile": 0.85056}, "CVE-2023-50216": {"epss_score": 0.02451, "epss_percentile": 0.84787}, "CVE-2023-50217": {"epss_score": 0.02451, "epss_percentile": 0.84787}, "CVE-2023-50218": {"epss_score": 0.48962, "epss_percentile": 0.9766}, "CVE-2023-50219": {"epss_score": 0.0891, "epss_percentile": 0.92312}, "CVE-2023-50220": {"epss_score": 0.07077, "epss_percentile": 0.91234}, "CVE-2023-50221": {"epss_score": 0.03104, "epss_percentile": 0.86415}, "CVE-2023-50222": {"epss_score": 0.03196, "epss_percentile": 0.86612}, "CVE-2023-50223": {"epss_score": 0.53952, "epss_percentile": 0.97904}, "CVE-2023-50224": {"epss_score": 0.02373, "epss_percentile": 0.84533}, "CVE-2023-50225": {"epss_score": 0.00872, "epss_percentile": 0.74735}, "CVE-2023-50226": {"epss_score": 0.00281, "epss_percentile": 0.5114}, "CVE-2023-50227": {"epss_score": 0.02794, "epss_percentile": 0.85676}, "CVE-2023-50228": {"epss_score": 0.00049, "epss_percentile": 0.15465}, "CVE-2023-50229": {"epss_score": 0.03881, "epss_percentile": 0.87896}, "CVE-2023-50230": {"epss_score": 0.03881, "epss_percentile": 0.87896}, "CVE-2023-50231": {"epss_score": 0.14119, "epss_percentile": 0.94137}, "CVE-2023-50232": {"epss_score": 0.02187, "epss_percentile": 0.83924}, "CVE-2023-50233": {"epss_score": 0.03655, "epss_percentile": 0.87513}, "CVE-2023-50234": {"epss_score": 0.00779, "epss_percentile": 0.7315}, "CVE-2023-50235": {"epss_score": 0.00809, "epss_percentile": 0.73706}, "CVE-2023-50236": {"epss_score": 0.00029, "epss_percentile": 0.07928}, "CVE-2023-50239": {"epss_score": 0.101, "epss_percentile": 0.92849}, "CVE-2023-50240": {"epss_score": 0.101, "epss_percentile": 0.92849}, "CVE-2023-50243": {"epss_score": 0.101, "epss_percentile": 0.92849}, "CVE-2023-50244": {"epss_score": 0.101, "epss_percentile": 0.92849}, "CVE-2023-50245": {"epss_score": 0.03324, "epss_percentile": 0.86918}, "CVE-2023-50246": {"epss_score": 0.0026, "epss_percentile": 0.49172}, "CVE-2023-50247": {"epss_score": 0.00562, "epss_percentile": 0.67695}, "CVE-2023-50248": {"epss_score": 0.00189, "epss_percentile": 0.40928}, "CVE-2023-50249": {"epss_score": 0.00171, "epss_percentile": 0.38832}, "CVE-2023-50250": {"epss_score": 0.02167, "epss_percentile": 0.83854}, "CVE-2023-50251": {"epss_score": 0.00265, "epss_percentile": 0.49777}, "CVE-2023-50252": {"epss_score": 0.09385, "epss_percentile": 0.92526}, "CVE-2023-50253": {"epss_score": 0.00082, "epss_percentile": 0.24587}, "CVE-2023-50254": {"epss_score": 0.08848, "epss_percentile": 0.92283}, "CVE-2023-50255": {"epss_score": 0.00427, "epss_percentile": 0.61898}, "CVE-2023-50256": {"epss_score": 0.00045, "epss_percentile": 0.13921}, "CVE-2023-50257": {"epss_score": 0.00197, "epss_percentile": 0.41912}, "CVE-2023-50258": {"epss_score": 0.00455, "epss_percentile": 0.63285}, "CVE-2023-50259": {"epss_score": 0.00309, "epss_percentile": 0.53687}, "CVE-2023-50260": {"epss_score": 0.15215, "epss_percentile": 0.94386}, "CVE-2023-50262": {"epss_score": 0.06147, "epss_percentile": 0.90519}, "CVE-2023-50263": {"epss_score": 0.00449, "epss_percentile": 0.6304}, "CVE-2023-50264": {"epss_score": 0.00344, "epss_percentile": 0.56483}, "CVE-2023-50265": {"epss_score": 0.00216, "epss_percentile": 0.44152}, "CVE-2023-50266": {"epss_score": 0.00114, "epss_percentile": 0.30749}, "CVE-2023-50267": {"epss_score": 0.00136, "epss_percentile": 0.34095}, "CVE-2023-50268": {"epss_score": 0.00103, "epss_percentile": 0.2908}, "CVE-2023-50269": {"epss_score": 0.00949, "epss_percentile": 0.75837}, "CVE-2023-50270": {"epss_score": 0.00799, "epss_percentile": 0.73526}, "CVE-2023-50271": {"epss_score": 0.00274, "epss_percentile": 0.50533}, "CVE-2023-50272": {"epss_score": 0.0003, "epss_percentile": 0.08032}, "CVE-2023-50274": {"epss_score": 0.00309, "epss_percentile": 0.53659}, "CVE-2023-50275": {"epss_score": 0.00142, "epss_percentile": 0.35041}, "CVE-2023-50290": {"epss_score": 0.92984, "epss_percentile": 0.99766}, "CVE-2023-50291": {"epss_score": 0.03093, "epss_percentile": 0.86399}, "CVE-2023-50292": {"epss_score": 0.40159, "epss_percentile": 0.972}, "CVE-2023-50294": {"epss_score": 0.00351, "epss_percentile": 0.57074}, "CVE-2023-50297": {"epss_score": 0.00323, "epss_percentile": 0.54897}, "CVE-2023-50298": {"epss_score": 0.00045, "epss_percentile": 0.13772}, "CVE-2023-50300": {"epss_score": 0.00016, "epss_percentile": 0.02895}, "CVE-2023-50301": {"epss_score": 0.00015, "epss_percentile": 0.02194}, "CVE-2023-50303": {"epss_score": 0.00074, "epss_percentile": 0.22766}, "CVE-2023-50304": {"epss_score": 0.0006, "epss_percentile": 0.19095}, "CVE-2023-50305": {"epss_score": 0.00014, "epss_percentile": 0.02092}, "CVE-2023-50306": {"epss_score": 0.00013, "epss_percentile": 0.01706}, "CVE-2023-50307": {"epss_score": 0.00135, "epss_percentile": 0.34016}, "CVE-2023-50308": {"epss_score": 0.00039, "epss_percentile": 0.11549}, "CVE-2023-50309": {"epss_score": 0.00101, "epss_percentile": 0.28643}, "CVE-2023-50310": {"epss_score": 0.00082, "epss_percentile": 0.24414}, "CVE-2023-50311": {"epss_score": 0.00053, "epss_percentile": 0.1702}, "CVE-2023-50312": {"epss_score": 0.00034, "epss_percentile": 0.09682}, "CVE-2023-50313": {"epss_score": 0.0002, "epss_percentile": 0.04502}, "CVE-2023-50314": {"epss_score": 0.00097, "epss_percentile": 0.2754}, "CVE-2023-50315": {"epss_score": 0.00114, "epss_percentile": 0.30812}, "CVE-2023-50316": {"epss_score": 0.001, "epss_percentile": 0.2846}, "CVE-2023-50324": {"epss_score": 0.00062, "epss_percentile": 0.1978}, "CVE-2023-50326": {"epss_score": 0.0004, "epss_percentile": 0.1196}, "CVE-2023-50327": {"epss_score": 0.00029, "epss_percentile": 0.07972}, "CVE-2023-50328": {"epss_score": 0.00042, "epss_percentile": 0.12662}, "CVE-2023-50330": {"epss_score": 0.0731, "epss_percentile": 0.91399}, "CVE-2023-50332": {"epss_score": 0.00322, "epss_percentile": 0.54787}, "CVE-2023-50333": {"epss_score": 0.00052, "epss_percentile": 0.16364}, "CVE-2023-50339": {"epss_score": 0.00492, "epss_percentile": 0.65001}, "CVE-2023-50341": {"epss_score": 0.00066, "epss_percentile": 0.2089}, "CVE-2023-50342": {"epss_score": 0.00174, "epss_percentile": 0.39216}, "CVE-2023-50343": {"epss_score": 0.00059, "epss_percentile": 0.18921}, "CVE-2023-50344": {"epss_score": 0.00196, "epss_percentile": 0.41757}, "CVE-2023-50345": {"epss_score": 0.00173, "epss_percentile": 0.39054}, "CVE-2023-50346": {"epss_score": 0.00187, "epss_percentile": 0.40696}, "CVE-2023-50347": {"epss_score": 0.00422, "epss_percentile": 0.61538}, "CVE-2023-50348": {"epss_score": 0.00187, "epss_percentile": 0.40696}, "CVE-2023-50349": {"epss_score": 0.00066, "epss_percentile": 0.20744}, "CVE-2023-50350": {"epss_score": 0.00035, "epss_percentile": 0.10129}, "CVE-2023-50351": {"epss_score": 0.00039, "epss_percentile": 0.11581}, "CVE-2023-50355": {"epss_score": 0.00236, "epss_percentile": 0.46406}, "CVE-2023-50356": {"epss_score": 0.00129, "epss_percentile": 0.33186}, "CVE-2023-50357": {"epss_score": 0.00221, "epss_percentile": 0.44688}, "CVE-2023-50358": {"epss_score": 0.02156, "epss_percentile": 0.83811}, "CVE-2023-50359": {"epss_score": 0.00025, "epss_percentile": 0.06151}, "CVE-2023-50360": {"epss_score": 0.00211, "epss_percentile": 0.4362}, "CVE-2023-50361": {"epss_score": 0.00266, "epss_percentile": 0.499}, "CVE-2023-50362": {"epss_score": 0.00266, "epss_percentile": 0.499}, "CVE-2023-50363": {"epss_score": 0.00025, "epss_percentile": 0.06351}, "CVE-2023-50364": {"epss_score": 0.00172, "epss_percentile": 0.38915}, "CVE-2023-50366": {"epss_score": 0.00103, "epss_percentile": 0.29059}, "CVE-2023-50368": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-50369": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-50370": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-50371": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2023-50372": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-50373": {"epss_score": 0.00194, "epss_percentile": 0.41536}, "CVE-2023-50374": {"epss_score": 0.00149, "epss_percentile": 0.35985}, "CVE-2023-50375": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2023-50376": {"epss_score": 0.00128, "epss_percentile": 0.33051}, "CVE-2023-50377": {"epss_score": 0.00107, "epss_percentile": 0.29669}, "CVE-2023-50378": {"epss_score": 0.02055, "epss_percentile": 0.83421}, "CVE-2023-50379": {"epss_score": 0.00894, "epss_percentile": 0.75082}, "CVE-2023-50380": {"epss_score": 0.00137, "epss_percentile": 0.34312}, "CVE-2023-50381": {"epss_score": 0.00464, "epss_percentile": 0.63703}, "CVE-2023-50382": {"epss_score": 0.00666, "epss_percentile": 0.70679}, "CVE-2023-50383": {"epss_score": 0.00666, "epss_percentile": 0.70679}, "CVE-2023-50386": {"epss_score": 0.82427, "epss_percentile": 0.99194}, "CVE-2023-50387": {"epss_score": 0.46133, "epss_percentile": 0.97532}, "CVE-2023-50395": {"epss_score": 0.00998, "epss_percentile": 0.76473}, "CVE-2023-50422": {"epss_score": 0.00538, "epss_percentile": 0.66947}, "CVE-2023-50423": {"epss_score": 0.00458, "epss_percentile": 0.63418}, "CVE-2023-50424": {"epss_score": 0.00458, "epss_percentile": 0.63418}, "CVE-2023-50428": {"epss_score": 0.00032, "epss_percentile": 0.08786}, "CVE-2023-50429": {"epss_score": 0.00066, "epss_percentile": 0.20884}, "CVE-2023-50430": {"epss_score": 0.0001, "epss_percentile": 0.00845}, "CVE-2023-50431": {"epss_score": 0.0001, "epss_percentile": 0.00864}, "CVE-2023-50432": {"epss_score": 0.00202, "epss_percentile": 0.4249}, "CVE-2023-50433": {"epss_score": 0.00568, "epss_percentile": 0.67886}, "CVE-2023-50434": {"epss_score": 0.00206, "epss_percentile": 0.42781}, "CVE-2023-50436": {"epss_score": 0.00106, "epss_percentile": 0.29424}, "CVE-2023-50437": {"epss_score": 0.00336, "epss_percentile": 0.55985}, "CVE-2023-50439": {"epss_score": 0.00359, "epss_percentile": 0.57617}, "CVE-2023-50440": {"epss_score": 0.00116, "epss_percentile": 0.31162}, "CVE-2023-50441": {"epss_score": 0.00143, "epss_percentile": 0.35151}, "CVE-2023-50442": {"epss_score": 0.00069, "epss_percentile": 0.21632}, "CVE-2023-50443": {"epss_score": 0.00182, "epss_percentile": 0.40159}, "CVE-2023-50444": {"epss_score": 0.00352, "epss_percentile": 0.57104}, "CVE-2023-50445": {"epss_score": 0.01923, "epss_percentile": 0.82912}, "CVE-2023-50446": {"epss_score": 0.00067, "epss_percentile": 0.20975}, "CVE-2023-50447": {"epss_score": 0.00557, "epss_percentile": 0.67542}, "CVE-2023-50448": {"epss_score": 0.00696, "epss_percentile": 0.71396}, "CVE-2023-50449": {"epss_score": 0.00123, "epss_percentile": 0.32306}, "CVE-2023-50450": {"epss_score": 0.00016, "epss_percentile": 0.02866}, "CVE-2023-50453": {"epss_score": 0.00259, "epss_percentile": 0.49074}, "CVE-2023-50454": {"epss_score": 0.00112, "epss_percentile": 0.30527}, "CVE-2023-50455": {"epss_score": 0.00168, "epss_percentile": 0.3852}, "CVE-2023-50456": {"epss_score": 0.00127, "epss_percentile": 0.3279}, "CVE-2023-50457": {"epss_score": 0.00134, "epss_percentile": 0.33793}, "CVE-2023-50458": {"epss_score": 0.00026, "epss_percentile": 0.06402}, "CVE-2023-50463": {"epss_score": 0.00091, "epss_percentile": 0.26238}, "CVE-2023-50465": {"epss_score": 0.00125, "epss_percentile": 0.32613}, "CVE-2023-50466": {"epss_score": 0.00338, "epss_percentile": 0.56153}, "CVE-2023-50469": {"epss_score": 0.10112, "epss_percentile": 0.92855}, "CVE-2023-50470": {"epss_score": 0.00207, "epss_percentile": 0.43114}, "CVE-2023-50471": {"epss_score": 0.00243, "epss_percentile": 0.47479}, "CVE-2023-50472": {"epss_score": 0.00104, "epss_percentile": 0.29174}, "CVE-2023-50473": {"epss_score": 0.00113, "epss_percentile": 0.30673}, "CVE-2023-50475": {"epss_score": 0.00176, "epss_percentile": 0.39393}, "CVE-2023-50477": {"epss_score": 0.01074, "epss_percentile": 0.77295}, "CVE-2023-50481": {"epss_score": 0.00105, "epss_percentile": 0.29279}, "CVE-2023-50488": {"epss_score": 0.00509, "epss_percentile": 0.65729}, "CVE-2023-50495": {"epss_score": 0.00051, "epss_percentile": 0.16056}, "CVE-2023-50550": {"epss_score": 0.00421, "epss_percentile": 0.61492}, "CVE-2023-50559": {"epss_score": 0.0003, "epss_percentile": 0.0815}, "CVE-2023-50563": {"epss_score": 0.00108, "epss_percentile": 0.29885}, "CVE-2023-50564": {"epss_score": 0.24881, "epss_percentile": 0.95963}, "CVE-2023-50565": {"epss_score": 0.00196, "epss_percentile": 0.41818}, "CVE-2023-50566": {"epss_score": 0.00183, "epss_percentile": 0.40292}, "CVE-2023-50570": {"epss_score": 0.00027, "epss_percentile": 0.06954}, "CVE-2023-50571": {"epss_score": 0.00673, "epss_percentile": 0.70836}, "CVE-2023-50572": {"epss_score": 0.00021, "epss_percentile": 0.04733}, "CVE-2023-50578": {"epss_score": 0.31687, "epss_percentile": 0.96642}, "CVE-2023-50585": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-50589": {"epss_score": 0.00057, "epss_percentile": 0.17967}, "CVE-2023-50609": {"epss_score": 0.00166, "epss_percentile": 0.38226}, "CVE-2023-50612": {"epss_score": 0.00027, "epss_percentile": 0.06782}, "CVE-2023-50614": {"epss_score": 0.00043, "epss_percentile": 0.13287}, "CVE-2023-50628": {"epss_score": 0.00226, "epss_percentile": 0.45349}, "CVE-2023-50630": {"epss_score": 0.00162, "epss_percentile": 0.37703}, "CVE-2023-50639": {"epss_score": 0.00092, "epss_percentile": 0.26419}, "CVE-2023-50643": {"epss_score": 0.2693, "epss_percentile": 0.96193}, "CVE-2023-50651": {"epss_score": 0.05416, "epss_percentile": 0.89851}, "CVE-2023-50658": {"epss_score": 0.00054, "epss_percentile": 0.17183}, "CVE-2023-50671": {"epss_score": 0.00061, "epss_percentile": 0.1941}, "CVE-2023-50677": {"epss_score": 0.00307, "epss_percentile": 0.53527}, "CVE-2023-50685": {"epss_score": 0.02156, "epss_percentile": 0.83808}, "CVE-2023-50692": {"epss_score": 0.01844, "epss_percentile": 0.82506}, "CVE-2023-50693": {"epss_score": 0.01171, "epss_percentile": 0.78218}, "CVE-2023-50694": {"epss_score": 0.0186, "epss_percentile": 0.82588}, "CVE-2023-50700": {"epss_score": 0.00066, "epss_percentile": 0.20942}, "CVE-2023-50702": {"epss_score": 0.00254, "epss_percentile": 0.48567}, "CVE-2023-50703": {"epss_score": 0.00027, "epss_percentile": 0.06954}, "CVE-2023-50704": {"epss_score": 0.0006, "epss_percentile": 0.18932}, "CVE-2023-50705": {"epss_score": 0.00074, "epss_percentile": 0.22868}, "CVE-2023-50706": {"epss_score": 0.00029, "epss_percentile": 0.07729}, "CVE-2023-50707": {"epss_score": 0.00084, "epss_percentile": 0.24995}, "CVE-2023-50708": {"epss_score": 0.00162, "epss_percentile": 0.37653}, "CVE-2023-50709": {"epss_score": 0.00169, "epss_percentile": 0.38627}, "CVE-2023-50710": {"epss_score": 0.00362, "epss_percentile": 0.57773}, "CVE-2023-50711": {"epss_score": 0.00073, "epss_percentile": 0.22672}, "CVE-2023-50712": {"epss_score": 0.00433, "epss_percentile": 0.62207}, "CVE-2023-50713": {"epss_score": 0.00121, "epss_percentile": 0.31838}, "CVE-2023-50714": {"epss_score": 0.00114, "epss_percentile": 0.30874}, "CVE-2023-50715": {"epss_score": 0.00153, "epss_percentile": 0.36604}, "CVE-2023-50716": {"epss_score": 0.00938, "epss_percentile": 0.75701}, "CVE-2023-50717": {"epss_score": 0.0044, "epss_percentile": 0.62645}, "CVE-2023-50718": {"epss_score": 0.00231, "epss_percentile": 0.45808}, "CVE-2023-50719": {"epss_score": 0.51803, "epss_percentile": 0.97799}, "CVE-2023-50720": {"epss_score": 0.514, "epss_percentile": 0.97777}, "CVE-2023-50721": {"epss_score": 0.43252, "epss_percentile": 0.97378}, "CVE-2023-50722": {"epss_score": 0.03256, "epss_percentile": 0.86764}, "CVE-2023-50723": {"epss_score": 0.05391, "epss_percentile": 0.89824}, "CVE-2023-50724": {"epss_score": 0.00943, "epss_percentile": 0.75771}, "CVE-2023-50725": {"epss_score": 0.00657, "epss_percentile": 0.70469}, "CVE-2023-50726": {"epss_score": 0.00024, "epss_percentile": 0.05962}, "CVE-2023-50727": {"epss_score": 0.00657, "epss_percentile": 0.70469}, "CVE-2023-50728": {"epss_score": 0.00479, "epss_percentile": 0.64435}, "CVE-2023-50729": {"epss_score": 0.0007, "epss_percentile": 0.21827}, "CVE-2023-50730": {"epss_score": 0.00524, "epss_percentile": 0.66353}, "CVE-2023-50731": {"epss_score": 0.00161, "epss_percentile": 0.37532}, "CVE-2023-50732": {"epss_score": 0.01361, "epss_percentile": 0.79753}, "CVE-2023-50733": {"epss_score": 0.00104, "epss_percentile": 0.29194}, "CVE-2023-50734": {"epss_score": 0.00096, "epss_percentile": 0.27269}, "CVE-2023-50735": {"epss_score": 0.00123, "epss_percentile": 0.32293}, "CVE-2023-50736": {"epss_score": 0.00108, "epss_percentile": 0.29794}, "CVE-2023-50737": {"epss_score": 0.00087, "epss_percentile": 0.25496}, "CVE-2023-50738": {"epss_score": 0.00016, "epss_percentile": 0.02828}, "CVE-2023-50739": {"epss_score": 0.00081, "epss_percentile": 0.24268}, "CVE-2023-50740": {"epss_score": 0.00214, "epss_percentile": 0.43988}, "CVE-2023-50743": {"epss_score": 0.00072, "epss_percentile": 0.22265}, "CVE-2023-50752": {"epss_score": 0.00082, "epss_percentile": 0.24484}, "CVE-2023-50753": {"epss_score": 0.00072, "epss_percentile": 0.22265}, "CVE-2023-50760": {"epss_score": 0.00805, "epss_percentile": 0.73631}, "CVE-2023-50761": {"epss_score": 0.00288, "epss_percentile": 0.51948}, "CVE-2023-50762": {"epss_score": 0.00288, "epss_percentile": 0.51948}, "CVE-2023-50763": {"epss_score": 0.00417, "epss_percentile": 0.61243}, "CVE-2023-50764": {"epss_score": 0.00061, "epss_percentile": 0.19483}, "CVE-2023-50765": {"epss_score": 0.00052, "epss_percentile": 0.16396}, "CVE-2023-50766": {"epss_score": 0.00068, "epss_percentile": 0.21395}, "CVE-2023-50767": {"epss_score": 0.00132, "epss_percentile": 0.33516}, "CVE-2023-50768": {"epss_score": 0.00068, "epss_percentile": 0.21395}, "CVE-2023-50769": {"epss_score": 0.00052, "epss_percentile": 0.16396}, "CVE-2023-50770": {"epss_score": 0.00012, "epss_percentile": 0.01258}, "CVE-2023-50771": {"epss_score": 0.00059, "epss_percentile": 0.18833}, "CVE-2023-50772": {"epss_score": 0.00024, "epss_percentile": 0.05791}, "CVE-2023-50773": {"epss_score": 0.00024, "epss_percentile": 0.05791}, "CVE-2023-50774": {"epss_score": 0.00061, "epss_percentile": 0.1954}, "CVE-2023-50775": {"epss_score": 0.00048, "epss_percentile": 0.15228}, "CVE-2023-50776": {"epss_score": 0.00025, "epss_percentile": 0.06119}, "CVE-2023-50777": {"epss_score": 0.00024, "epss_percentile": 0.05673}, "CVE-2023-50778": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2023-50779": {"epss_score": 0.00036, "epss_percentile": 0.10524}, "CVE-2023-50780": {"epss_score": 0.02606, "epss_percentile": 0.85226}, "CVE-2023-50781": {"epss_score": 0.00306, "epss_percentile": 0.53461}, "CVE-2023-50782": {"epss_score": 0.00707, "epss_percentile": 0.71648}, "CVE-2023-50783": {"epss_score": 0.00041, "epss_percentile": 0.1246}, "CVE-2023-50784": {"epss_score": 0.00983, "epss_percentile": 0.76305}, "CVE-2023-50785": {"epss_score": 0.0054, "epss_percentile": 0.67007}, "CVE-2023-50786": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2023-50803": {"epss_score": 0.00209, "epss_percentile": 0.43383}, "CVE-2023-50804": {"epss_score": 0.00098, "epss_percentile": 0.27685}, "CVE-2023-50805": {"epss_score": 0.00295, "epss_percentile": 0.5245}, "CVE-2023-50806": {"epss_score": 0.00101, "epss_percentile": 0.28715}, "CVE-2023-50807": {"epss_score": 0.00295, "epss_percentile": 0.5245}, "CVE-2023-50808": {"epss_score": 0.0053, "epss_percentile": 0.66613}, "CVE-2023-50809": {"epss_score": 0.02924, "epss_percentile": 0.86003}, "CVE-2023-50810": {"epss_score": 0.00023, "epss_percentile": 0.05635}, "CVE-2023-50811": {"epss_score": 0.00049, "epss_percentile": 0.1563}, "CVE-2023-50821": {"epss_score": 0.00051, "epss_percentile": 0.16241}, "CVE-2023-50822": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-50823": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-50824": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-50825": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-50826": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-50827": {"epss_score": 0.00105, "epss_percentile": 0.29286}, "CVE-2023-50828": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-50829": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2023-50830": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2023-50831": {"epss_score": 0.00169, "epss_percentile": 0.38565}, "CVE-2023-50832": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2023-50833": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-50834": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-50835": {"epss_score": 0.00059, "epss_percentile": 0.18737}, "CVE-2023-50836": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-50837": {"epss_score": 0.00291, "epss_percentile": 0.52201}, "CVE-2023-50838": {"epss_score": 0.00291, "epss_percentile": 0.52201}, "CVE-2023-50839": {"epss_score": 0.00308, "epss_percentile": 0.53586}, "CVE-2023-50840": {"epss_score": 0.00308, "epss_percentile": 0.53602}, "CVE-2023-50841": {"epss_score": 0.00308, "epss_percentile": 0.53602}, "CVE-2023-50842": {"epss_score": 0.00308, "epss_percentile": 0.53602}, "CVE-2023-50843": {"epss_score": 0.00291, "epss_percentile": 0.52201}, "CVE-2023-50844": {"epss_score": 0.00291, "epss_percentile": 0.52201}, "CVE-2023-50845": {"epss_score": 0.00291, "epss_percentile": 0.52201}, "CVE-2023-50846": {"epss_score": 0.00291, "epss_percentile": 0.52201}, "CVE-2023-50847": {"epss_score": 0.00291, "epss_percentile": 0.52201}, "CVE-2023-50848": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-50849": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-50850": {"epss_score": 0.0013, "epss_percentile": 0.33331}, "CVE-2023-50851": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-50852": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-50853": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-50854": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-50855": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-50856": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-50857": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-50858": {"epss_score": 0.00055, "epss_percentile": 0.17572}, "CVE-2023-50859": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2023-50860": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2023-50861": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-50862": {"epss_score": 0.00072, "epss_percentile": 0.22265}, "CVE-2023-50863": {"epss_score": 0.00072, "epss_percentile": 0.22265}, "CVE-2023-50864": {"epss_score": 0.00072, "epss_percentile": 0.22265}, "CVE-2023-50865": {"epss_score": 0.00072, "epss_percentile": 0.22265}, "CVE-2023-50866": {"epss_score": 0.00072, "epss_percentile": 0.22265}, "CVE-2023-50867": {"epss_score": 0.00072, "epss_percentile": 0.22265}, "CVE-2023-50868": {"epss_score": 0.14123, "epss_percentile": 0.94139}, "CVE-2023-50870": {"epss_score": 3e-05, "epss_percentile": 0.00113}, "CVE-2023-50871": {"epss_score": 2e-05, "epss_percentile": 0.00054}, "CVE-2023-50872": {"epss_score": 0.00284, "epss_percentile": 0.51476}, "CVE-2023-50873": {"epss_score": 0.00077, "epss_percentile": 0.23287}, "CVE-2023-50874": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-50875": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2023-50876": {"epss_score": 0.00163, "epss_percentile": 0.37788}, "CVE-2023-50877": {"epss_score": 0.00163, "epss_percentile": 0.37788}, "CVE-2023-50878": {"epss_score": 0.00112, "epss_percentile": 0.3043}, "CVE-2023-50879": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-50880": {"epss_score": 0.00273, "epss_percentile": 0.50455}, "CVE-2023-50881": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-50882": {"epss_score": 0.00116, "epss_percentile": 0.31088}, "CVE-2023-50883": {"epss_score": 0.00137, "epss_percentile": 0.34252}, "CVE-2023-50884": {"epss_score": 0.00173, "epss_percentile": 0.39103}, "CVE-2023-50885": {"epss_score": 0.00232, "epss_percentile": 0.45913}, "CVE-2023-50886": {"epss_score": 0.00057, "epss_percentile": 0.18053}, "CVE-2023-50887": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2023-50889": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-50890": {"epss_score": 0.00173, "epss_percentile": 0.39078}, "CVE-2023-50891": {"epss_score": 0.00317, "epss_percentile": 0.54362}, "CVE-2023-50892": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-50893": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-50894": {"epss_score": 0.00375, "epss_percentile": 0.58622}, "CVE-2023-50895": {"epss_score": 0.00294, "epss_percentile": 0.52399}, "CVE-2023-50896": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2023-50897": {"epss_score": 0.00102, "epss_percentile": 0.28739}, "CVE-2023-50898": {"epss_score": 0.00086, "epss_percentile": 0.25307}, "CVE-2023-50899": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2023-50900": {"epss_score": 0.00095, "epss_percentile": 0.27116}, "CVE-2023-50901": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-50902": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-50903": {"epss_score": 0.00218, "epss_percentile": 0.44365}, "CVE-2023-50904": {"epss_score": 0.00249, "epss_percentile": 0.4801}, "CVE-2023-50905": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-50913": {"epss_score": 0.00138, "epss_percentile": 0.34514}, "CVE-2023-50914": {"epss_score": 0.00078, "epss_percentile": 0.23681}, "CVE-2023-50915": {"epss_score": 0.00207, "epss_percentile": 0.43151}, "CVE-2023-50916": {"epss_score": 0.00302, "epss_percentile": 0.53103}, "CVE-2023-50917": {"epss_score": 0.92755, "epss_percentile": 0.99744}, "CVE-2023-50918": {"epss_score": 0.00226, "epss_percentile": 0.45328}, "CVE-2023-50919": {"epss_score": 0.45794, "epss_percentile": 0.97502}, "CVE-2023-50920": {"epss_score": 0.00011, "epss_percentile": 0.00971}, "CVE-2023-50921": {"epss_score": 0.00084, "epss_percentile": 0.24865}, "CVE-2023-50922": {"epss_score": 0.00077, "epss_percentile": 0.23537}, "CVE-2023-50923": {"epss_score": 0.00055, "epss_percentile": 0.17634}, "CVE-2023-50924": {"epss_score": 0.0009, "epss_percentile": 0.26044}, "CVE-2023-50926": {"epss_score": 0.00343, "epss_percentile": 0.56457}, "CVE-2023-50927": {"epss_score": 0.00319, "epss_percentile": 0.54563}, "CVE-2023-50928": {"epss_score": 0.00035, "epss_percentile": 0.09985}, "CVE-2023-50930": {"epss_score": 0.00047, "epss_percentile": 0.14572}, "CVE-2023-50931": {"epss_score": 0.00052, "epss_percentile": 0.16469}, "CVE-2023-50932": {"epss_score": 0.00052, "epss_percentile": 0.16469}, "CVE-2023-50933": {"epss_score": 0.0009, "epss_percentile": 0.26145}, "CVE-2023-50934": {"epss_score": 0.00039, "epss_percentile": 0.11797}, "CVE-2023-50935": {"epss_score": 0.00043, "epss_percentile": 0.13231}, "CVE-2023-50936": {"epss_score": 0.00036, "epss_percentile": 0.10543}, "CVE-2023-50937": {"epss_score": 0.00031, "epss_percentile": 0.08534}, "CVE-2023-50938": {"epss_score": 0.00027, "epss_percentile": 0.0714}, "CVE-2023-50939": {"epss_score": 0.00031, "epss_percentile": 0.08534}, "CVE-2023-50940": {"epss_score": 0.0004, "epss_percentile": 0.11912}, "CVE-2023-50941": {"epss_score": 0.0003, "epss_percentile": 0.08151}, "CVE-2023-50943": {"epss_score": 0.00281, "epss_percentile": 0.51184}, "CVE-2023-50944": {"epss_score": 0.00192, "epss_percentile": 0.41279}, "CVE-2023-50945": {"epss_score": 0.00057, "epss_percentile": 0.18101}, "CVE-2023-50946": {"epss_score": 0.00074, "epss_percentile": 0.22739}, "CVE-2023-50947": {"epss_score": 0.00107, "epss_percentile": 0.29686}, "CVE-2023-50948": {"epss_score": 0.0007, "epss_percentile": 0.21827}, "CVE-2023-50949": {"epss_score": 0.00057, "epss_percentile": 0.1814}, "CVE-2023-50950": {"epss_score": 0.00077, "epss_percentile": 0.23302}, "CVE-2023-50951": {"epss_score": 0.00041, "epss_percentile": 0.12415}, "CVE-2023-50952": {"epss_score": 0.00078, "epss_percentile": 0.23553}, "CVE-2023-50953": {"epss_score": 0.00088, "epss_percentile": 0.25645}, "CVE-2023-50954": {"epss_score": 0.00147, "epss_percentile": 0.35704}, "CVE-2023-50955": {"epss_score": 0.00155, "epss_percentile": 0.36809}, "CVE-2023-50956": {"epss_score": 0.00056, "epss_percentile": 0.17917}, "CVE-2023-50957": {"epss_score": 0.00042, "epss_percentile": 0.12834}, "CVE-2023-50959": {"epss_score": 0.00054, "epss_percentile": 0.17101}, "CVE-2023-50961": {"epss_score": 0.00068, "epss_percentile": 0.21323}, "CVE-2023-50962": {"epss_score": 0.00031, "epss_percentile": 0.08319}, "CVE-2023-50963": {"epss_score": 0.0007, "epss_percentile": 0.21936}, "CVE-2023-50964": {"epss_score": 0.00144, "epss_percentile": 0.35254}, "CVE-2023-50965": {"epss_score": 0.11952, "epss_percentile": 0.93524}, "CVE-2023-50966": {"epss_score": 0.00019, "epss_percentile": 0.04398}, "CVE-2023-50967": {"epss_score": 0.00852, "epss_percentile": 0.74414}, "CVE-2023-50968": {"epss_score": 0.82943, "epss_percentile": 0.99222}, "CVE-2023-50969": {"epss_score": 0.00367, "epss_percentile": 0.58098}, "CVE-2023-50974": {"epss_score": 0.00022, "epss_percentile": 0.05039}, "CVE-2023-50975": {"epss_score": 0.00053, "epss_percentile": 0.16865}, "CVE-2023-50976": {"epss_score": 0.00121, "epss_percentile": 0.31885}, "CVE-2023-50979": {"epss_score": 0.00084, "epss_percentile": 0.24977}, "CVE-2023-50980": {"epss_score": 0.00066, "epss_percentile": 0.20902}, "CVE-2023-50981": {"epss_score": 0.00097, "epss_percentile": 0.27503}, "CVE-2023-50982": {"epss_score": 0.00513, "epss_percentile": 0.65927}, "CVE-2023-50983": {"epss_score": 0.01237, "epss_percentile": 0.78776}, "CVE-2023-50984": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-50985": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-50986": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-50987": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-50988": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-50989": {"epss_score": 0.01237, "epss_percentile": 0.78776}, "CVE-2023-50990": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-50991": {"epss_score": 0.1294, "epss_percentile": 0.93822}, "CVE-2023-50992": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-50993": {"epss_score": 0.00322, "epss_percentile": 0.54798}, "CVE-2023-51006": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-51010": {"epss_score": 0.00067, "epss_percentile": 0.20967}, "CVE-2023-51011": {"epss_score": 0.00294, "epss_percentile": 0.52375}, "CVE-2023-51012": {"epss_score": 0.00294, "epss_percentile": 0.52375}, "CVE-2023-51013": {"epss_score": 0.00294, "epss_percentile": 0.52375}, "CVE-2023-51014": {"epss_score": 0.0031, "epss_percentile": 0.53783}, "CVE-2023-51015": {"epss_score": 0.0031, "epss_percentile": 0.53783}, "CVE-2023-51016": {"epss_score": 0.0031, "epss_percentile": 0.53783}, "CVE-2023-51017": {"epss_score": 0.00294, "epss_percentile": 0.52375}, "CVE-2023-51018": {"epss_score": 0.00405, "epss_percentile": 0.6051}, "CVE-2023-51019": {"epss_score": 0.00294, "epss_percentile": 0.52375}, "CVE-2023-51020": {"epss_score": 0.00384, "epss_percentile": 0.59148}, "CVE-2023-51021": {"epss_score": 0.00294, "epss_percentile": 0.52375}, "CVE-2023-51022": {"epss_score": 0.00294, "epss_percentile": 0.52375}, "CVE-2023-51023": {"epss_score": 0.00294, "epss_percentile": 0.52375}, "CVE-2023-51024": {"epss_score": 0.00294, "epss_percentile": 0.52375}, "CVE-2023-51025": {"epss_score": 0.0031, "epss_percentile": 0.53783}, "CVE-2023-51026": {"epss_score": 0.0031, "epss_percentile": 0.53783}, "CVE-2023-51027": {"epss_score": 0.00294, "epss_percentile": 0.52375}, "CVE-2023-51028": {"epss_score": 0.0031, "epss_percentile": 0.53783}, "CVE-2023-51033": {"epss_score": 0.0031, "epss_percentile": 0.53783}, "CVE-2023-51034": {"epss_score": 0.00319, "epss_percentile": 0.5457}, "CVE-2023-51035": {"epss_score": 0.00174, "epss_percentile": 0.39205}, "CVE-2023-51042": {"epss_score": 0.0002, "epss_percentile": 0.04431}, "CVE-2023-51043": {"epss_score": 0.00011, "epss_percentile": 0.01014}, "CVE-2023-51048": {"epss_score": 0.00282, "epss_percentile": 0.51252}, "CVE-2023-51049": {"epss_score": 0.00282, "epss_percentile": 0.51252}, "CVE-2023-51050": {"epss_score": 0.00282, "epss_percentile": 0.51252}, "CVE-2023-51051": {"epss_score": 0.00282, "epss_percentile": 0.51252}, "CVE-2023-51052": {"epss_score": 0.0012, "epss_percentile": 0.3172}, "CVE-2023-51059": {"epss_score": 0.0042, "epss_percentile": 0.61435}, "CVE-2023-51062": {"epss_score": 0.00182, "epss_percentile": 0.40264}, "CVE-2023-51063": {"epss_score": 0.00149, "epss_percentile": 0.36014}, "CVE-2023-51064": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-51065": {"epss_score": 0.00579, "epss_percentile": 0.68214}, "CVE-2023-51066": {"epss_score": 0.09173, "epss_percentile": 0.92432}, "CVE-2023-51067": {"epss_score": 0.0018, "epss_percentile": 0.3998}, "CVE-2023-51068": {"epss_score": 0.00198, "epss_percentile": 0.42096}, "CVE-2023-51070": {"epss_score": 0.00304, "epss_percentile": 0.53255}, "CVE-2023-51071": {"epss_score": 0.00126, "epss_percentile": 0.3268}, "CVE-2023-51072": {"epss_score": 0.01765, "epss_percentile": 0.82163}, "CVE-2023-51073": {"epss_score": 0.21483, "epss_percentile": 0.95524}, "CVE-2023-51074": {"epss_score": 0.00114, "epss_percentile": 0.30761}, "CVE-2023-51075": {"epss_score": 0.00045, "epss_percentile": 0.13743}, "CVE-2023-51079": {"epss_score": 0.00072, "epss_percentile": 0.22353}, "CVE-2023-51080": {"epss_score": 0.00078, "epss_percentile": 0.236}, "CVE-2023-51084": {"epss_score": 0.00112, "epss_percentile": 0.30554}, "CVE-2023-51090": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-51091": {"epss_score": 0.09163, "epss_percentile": 0.92428}, "CVE-2023-51092": {"epss_score": 0.1616, "epss_percentile": 0.94581}, "CVE-2023-51093": {"epss_score": 0.00121, "epss_percentile": 0.31873}, "CVE-2023-51094": {"epss_score": 0.00218, "epss_percentile": 0.44397}, "CVE-2023-51095": {"epss_score": 0.00322, "epss_percentile": 0.54796}, "CVE-2023-51097": {"epss_score": 0.00322, "epss_percentile": 0.54796}, "CVE-2023-51098": {"epss_score": 0.0265, "epss_percentile": 0.85343}, "CVE-2023-51099": {"epss_score": 0.01882, "epss_percentile": 0.82696}, "CVE-2023-51100": {"epss_score": 0.0265, "epss_percentile": 0.85343}, "CVE-2023-51101": {"epss_score": 0.00172, "epss_percentile": 0.38954}, "CVE-2023-51102": {"epss_score": 0.00172, "epss_percentile": 0.38954}, "CVE-2023-51103": {"epss_score": 0.00069, "epss_percentile": 0.21589}, "CVE-2023-51104": {"epss_score": 0.00066, "epss_percentile": 0.20763}, "CVE-2023-51105": {"epss_score": 0.00066, "epss_percentile": 0.20763}, "CVE-2023-51106": {"epss_score": 0.00059, "epss_percentile": 0.18917}, "CVE-2023-51107": {"epss_score": 0.0007, "epss_percentile": 0.21868}, "CVE-2023-51123": {"epss_score": 0.47899, "epss_percentile": 0.97607}, "CVE-2023-51126": {"epss_score": 0.23232, "epss_percentile": 0.95754}, "CVE-2023-51127": {"epss_score": 0.04078, "epss_percentile": 0.88213}, "CVE-2023-51133": {"epss_score": 0.00289, "epss_percentile": 0.52022}, "CVE-2023-51135": {"epss_score": 0.00289, "epss_percentile": 0.52022}, "CVE-2023-51136": {"epss_score": 0.00289, "epss_percentile": 0.52022}, "CVE-2023-51141": {"epss_score": 0.00228, "epss_percentile": 0.45481}, "CVE-2023-51142": {"epss_score": 0.00212, "epss_percentile": 0.43739}, "CVE-2023-51146": {"epss_score": 0.00111, "epss_percentile": 0.30387}, "CVE-2023-51147": {"epss_score": 0.00111, "epss_percentile": 0.30387}, "CVE-2023-51148": {"epss_score": 0.0013, "epss_percentile": 0.33285}, "CVE-2023-51154": {"epss_score": 0.00091, "epss_percentile": 0.26291}, "CVE-2023-51157": {"epss_score": 0.00575, "epss_percentile": 0.6812}, "CVE-2023-51210": {"epss_score": 0.00822, "epss_percentile": 0.73913}, "CVE-2023-51217": {"epss_score": 0.01462, "epss_percentile": 0.80437}, "CVE-2023-51219": {"epss_score": 0.00917, "epss_percentile": 0.7543}, "CVE-2023-51232": {"epss_score": 0.00708, "epss_percentile": 0.71678}, "CVE-2023-51246": {"epss_score": 0.00196, "epss_percentile": 0.41818}, "CVE-2023-51252": {"epss_score": 0.00165, "epss_percentile": 0.38128}, "CVE-2023-51254": {"epss_score": 0.00463, "epss_percentile": 0.63669}, "CVE-2023-51257": {"epss_score": 0.00029, "epss_percentile": 0.07775}, "CVE-2023-51258": {"epss_score": 0.00033, "epss_percentile": 0.09284}, "CVE-2023-51277": {"epss_score": 0.0029, "epss_percentile": 0.52117}, "CVE-2023-51281": {"epss_score": 0.00233, "epss_percentile": 0.46011}, "CVE-2023-51282": {"epss_score": 0.00205, "epss_percentile": 0.42743}, "CVE-2023-51293": {"epss_score": 0.00351, "epss_percentile": 0.57057}, "CVE-2023-51295": {"epss_score": 0.00062, "epss_percentile": 0.1972}, "CVE-2023-51296": {"epss_score": 0.00228, "epss_percentile": 0.4548}, "CVE-2023-51297": {"epss_score": 0.00397, "epss_percentile": 0.60049}, "CVE-2023-51298": {"epss_score": 0.00265, "epss_percentile": 0.49786}, "CVE-2023-51299": {"epss_score": 0.00159, "epss_percentile": 0.37415}, "CVE-2023-51300": {"epss_score": 0.0017, "epss_percentile": 0.38682}, "CVE-2023-51301": {"epss_score": 0.00488, "epss_percentile": 0.64838}, "CVE-2023-51302": {"epss_score": 0.0028, "epss_percentile": 0.51077}, "CVE-2023-51303": {"epss_score": 0.00093, "epss_percentile": 0.26748}, "CVE-2023-51305": {"epss_score": 0.00134, "epss_percentile": 0.33758}, "CVE-2023-51306": {"epss_score": 0.00101, "epss_percentile": 0.28564}, "CVE-2023-51308": {"epss_score": 0.00159, "epss_percentile": 0.37415}, "CVE-2023-51309": {"epss_score": 0.00316, "epss_percentile": 0.54298}, "CVE-2023-51310": {"epss_score": 0.00316, "epss_percentile": 0.54298}, "CVE-2023-51311": {"epss_score": 0.00262, "epss_percentile": 0.49359}, "CVE-2023-51312": {"epss_score": 0.00172, "epss_percentile": 0.38905}, "CVE-2023-51313": {"epss_score": 0.00256, "epss_percentile": 0.48833}, "CVE-2023-51314": {"epss_score": 0.00351, "epss_percentile": 0.57057}, "CVE-2023-51315": {"epss_score": 0.00172, "epss_percentile": 0.38905}, "CVE-2023-51316": {"epss_score": 0.00351, "epss_percentile": 0.57057}, "CVE-2023-51317": {"epss_score": 0.00159, "epss_percentile": 0.37415}, "CVE-2023-51318": {"epss_score": 0.00172, "epss_percentile": 0.38905}, "CVE-2023-51319": {"epss_score": 0.00283, "epss_percentile": 0.51401}, "CVE-2023-51320": {"epss_score": 0.00364, "epss_percentile": 0.57929}, "CVE-2023-51321": {"epss_score": 0.00148, "epss_percentile": 0.35903}, "CVE-2023-51323": {"epss_score": 0.00148, "epss_percentile": 0.35903}, "CVE-2023-51324": {"epss_score": 0.00166, "epss_percentile": 0.38183}, "CVE-2023-51325": {"epss_score": 0.00117, "epss_percentile": 0.31226}, "CVE-2023-51326": {"epss_score": 0.00129, "epss_percentile": 0.33088}, "CVE-2023-51327": {"epss_score": 0.00132, "epss_percentile": 0.33565}, "CVE-2023-51328": {"epss_score": 0.00159, "epss_percentile": 0.37372}, "CVE-2023-51330": {"epss_score": 0.00172, "epss_percentile": 0.38905}, "CVE-2023-51331": {"epss_score": 0.00102, "epss_percentile": 0.28816}, "CVE-2023-51332": {"epss_score": 0.00244, "epss_percentile": 0.47561}, "CVE-2023-51333": {"epss_score": 0.00226, "epss_percentile": 0.45335}, "CVE-2023-51334": {"epss_score": 0.00264, "epss_percentile": 0.49576}, "CVE-2023-51335": {"epss_score": 0.00125, "epss_percentile": 0.32556}, "CVE-2023-51336": {"epss_score": 0.00226, "epss_percentile": 0.45335}, "CVE-2023-51337": {"epss_score": 0.00101, "epss_percentile": 0.28564}, "CVE-2023-51338": {"epss_score": 0.00208, "epss_percentile": 0.43255}, "CVE-2023-51339": {"epss_score": 0.00192, "epss_percentile": 0.41325}, "CVE-2023-51350": {"epss_score": 0.03611, "epss_percentile": 0.87425}, "CVE-2023-51353": {"epss_score": 0.00198, "epss_percentile": 0.41977}, "CVE-2023-51354": {"epss_score": 0.00147, "epss_percentile": 0.35772}, "CVE-2023-51355": {"epss_score": 0.00253, "epss_percentile": 0.4844}, "CVE-2023-51356": {"epss_score": 0.00219, "epss_percentile": 0.44471}, "CVE-2023-51357": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2023-51358": {"epss_score": 0.00106, "epss_percentile": 0.29522}, "CVE-2023-51359": {"epss_score": 0.00282, "epss_percentile": 0.51279}, "CVE-2023-51360": {"epss_score": 0.00162, "epss_percentile": 0.37691}, "CVE-2023-51361": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2023-51362": {"epss_score": 0.00153, "epss_percentile": 0.36602}, "CVE-2023-51363": {"epss_score": 0.00125, "epss_percentile": 0.32571}, "CVE-2023-51364": {"epss_score": 0.10776, "epss_percentile": 0.931}, "CVE-2023-51365": {"epss_score": 0.12168, "epss_percentile": 0.93589}, "CVE-2023-51366": {"epss_score": 0.00281, "epss_percentile": 0.51185}, "CVE-2023-51367": {"epss_score": 0.0023, "epss_percentile": 0.45705}, "CVE-2023-51368": {"epss_score": 0.00187, "epss_percentile": 0.4076}, "CVE-2023-51369": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-51370": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-51371": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2023-51372": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-51373": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-51374": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2023-51375": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2023-51376": {"epss_score": 0.00174, "epss_percentile": 0.39145}, "CVE-2023-51377": {"epss_score": 0.00206, "epss_percentile": 0.42925}, "CVE-2023-51378": {"epss_score": 0.00112, "epss_percentile": 0.30431}, "CVE-2023-51379": {"epss_score": 0.00138, "epss_percentile": 0.34428}, "CVE-2023-51380": {"epss_score": 0.0017, "epss_percentile": 0.387}, "CVE-2023-51384": {"epss_score": 0.00044, "epss_percentile": 0.13644}, "CVE-2023-51385": {"epss_score": 0.16522, "epss_percentile": 0.94684}, "CVE-2023-51386": {"epss_score": 0.00035, "epss_percentile": 0.10123}, "CVE-2023-51387": {"epss_score": 0.00627, "epss_percentile": 0.69632}, "CVE-2023-51388": {"epss_score": 0.01041, "epss_percentile": 0.76964}, "CVE-2023-51389": {"epss_score": 0.00654, "epss_percentile": 0.70343}, "CVE-2023-51390": {"epss_score": 0.00077, "epss_percentile": 0.23522}, "CVE-2023-51391": {"epss_score": 0.00241, "epss_percentile": 0.47245}, "CVE-2023-51392": {"epss_score": 0.00033, "epss_percentile": 0.0937}, "CVE-2023-51393": {"epss_score": 0.00049, "epss_percentile": 0.15322}, "CVE-2023-51394": {"epss_score": 0.00049, "epss_percentile": 0.15369}, "CVE-2023-51395": {"epss_score": 0.00061, "epss_percentile": 0.19481}, "CVE-2023-51396": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2023-51397": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2023-51398": {"epss_score": 0.00173, "epss_percentile": 0.39078}, "CVE-2023-51399": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2023-51401": {"epss_score": 0.00771, "epss_percentile": 0.7303}, "CVE-2023-51402": {"epss_score": 0.00155, "epss_percentile": 0.36794}, "CVE-2023-51403": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-51404": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-51405": {"epss_score": 0.00158, "epss_percentile": 0.37292}, "CVE-2023-51406": {"epss_score": 0.00693, "epss_percentile": 0.71319}, "CVE-2023-51407": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-51408": {"epss_score": 0.00693, "epss_percentile": 0.71319}, "CVE-2023-51409": {"epss_score": 0.92988, "epss_percentile": 0.99766}, "CVE-2023-51410": {"epss_score": 0.00656, "epss_percentile": 0.70432}, "CVE-2023-51411": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2023-51412": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2023-51413": {"epss_score": 0.00206, "epss_percentile": 0.42925}, "CVE-2023-51414": {"epss_score": 0.00634, "epss_percentile": 0.69789}, "CVE-2023-51415": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2023-51416": {"epss_score": 0.00147, "epss_percentile": 0.35657}, "CVE-2023-51417": {"epss_score": 0.00656, "epss_percentile": 0.70432}, "CVE-2023-51418": {"epss_score": 0.00179, "epss_percentile": 0.39804}, "CVE-2023-51419": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2023-51420": {"epss_score": 0.00147, "epss_percentile": 0.35696}, "CVE-2023-51421": {"epss_score": 0.00656, "epss_percentile": 0.70432}, "CVE-2023-51422": {"epss_score": 0.00747, "epss_percentile": 0.72555}, "CVE-2023-51423": {"epss_score": 0.00147, "epss_percentile": 0.3569}, "CVE-2023-51424": {"epss_score": 0.00245, "epss_percentile": 0.47627}, "CVE-2023-51425": {"epss_score": 0.00107, "epss_percentile": 0.29582}, "CVE-2023-51426": {"epss_score": 0.0003, "epss_percentile": 0.08229}, "CVE-2023-51427": {"epss_score": 0.0003, "epss_percentile": 0.08229}, "CVE-2023-51428": {"epss_score": 0.0003, "epss_percentile": 0.08229}, "CVE-2023-51429": {"epss_score": 0.00063, "epss_percentile": 0.19891}, "CVE-2023-51430": {"epss_score": 0.00063, "epss_percentile": 0.19891}, "CVE-2023-51431": {"epss_score": 0.00058, "epss_percentile": 0.1861}, "CVE-2023-51432": {"epss_score": 0.00077, "epss_percentile": 0.2347}, "CVE-2023-51433": {"epss_score": 0.00122, "epss_percentile": 0.32037}, "CVE-2023-51434": {"epss_score": 0.00037, "epss_percentile": 0.10624}, "CVE-2023-51435": {"epss_score": 0.00046, "epss_percentile": 0.14346}, "CVE-2023-51436": {"epss_score": 0.00357, "epss_percentile": 0.57458}, "CVE-2023-51437": {"epss_score": 0.00095, "epss_percentile": 0.27215}, "CVE-2023-51438": {"epss_score": 0.00449, "epss_percentile": 0.6305}, "CVE-2023-51439": {"epss_score": 0.00038, "epss_percentile": 0.11346}, "CVE-2023-51440": {"epss_score": 0.00483, "epss_percentile": 0.64615}, "CVE-2023-51441": {"epss_score": 0.00046, "epss_percentile": 0.14439}, "CVE-2023-51442": {"epss_score": 0.00292, "epss_percentile": 0.52235}, "CVE-2023-51443": {"epss_score": 0.00509, "epss_percentile": 0.65748}, "CVE-2023-51444": {"epss_score": 0.03808, "epss_percentile": 0.87753}, "CVE-2023-51445": {"epss_score": 0.00721, "epss_percentile": 0.71979}, "CVE-2023-51446": {"epss_score": 0.00568, "epss_percentile": 0.67877}, "CVE-2023-51447": {"epss_score": 0.00487, "epss_percentile": 0.6478}, "CVE-2023-51448": {"epss_score": 0.37545, "epss_percentile": 0.97053}, "CVE-2023-51449": {"epss_score": 0.81353, "epss_percentile": 0.99134}, "CVE-2023-51450": {"epss_score": 0.00578, "epss_percentile": 0.68176}, "CVE-2023-51451": {"epss_score": 0.00283, "epss_percentile": 0.51363}, "CVE-2023-51452": {"epss_score": 0.00063, "epss_percentile": 0.20068}, "CVE-2023-51453": {"epss_score": 0.00063, "epss_percentile": 0.20068}, "CVE-2023-51454": {"epss_score": 0.00086, "epss_percentile": 0.25247}, "CVE-2023-51455": {"epss_score": 0.00089, "epss_percentile": 0.25894}, "CVE-2023-51456": {"epss_score": 0.00089, "epss_percentile": 0.25894}, "CVE-2023-51457": {"epss_score": 0.00152, "epss_percentile": 0.36505}, "CVE-2023-51458": {"epss_score": 0.00152, "epss_percentile": 0.36505}, "CVE-2023-51459": {"epss_score": 0.00152, "epss_percentile": 0.36505}, "CVE-2023-51460": {"epss_score": 0.00152, "epss_percentile": 0.36505}, "CVE-2023-51461": {"epss_score": 0.0017, "epss_percentile": 0.38743}, "CVE-2023-51462": {"epss_score": 0.00305, "epss_percentile": 0.53362}, "CVE-2023-51463": {"epss_score": 0.02314, "epss_percentile": 0.84351}, "CVE-2023-51464": {"epss_score": 0.03347, "epss_percentile": 0.86954}, "CVE-2023-51467": {"epss_score": 0.93996, "epss_percentile": 0.99883}, "CVE-2023-51468": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2023-51469": {"epss_score": 0.00147, "epss_percentile": 0.3569}, "CVE-2023-51470": {"epss_score": 0.00747, "epss_percentile": 0.72555}, "CVE-2023-51471": {"epss_score": 0.00076, "epss_percentile": 0.23123}, "CVE-2023-51472": {"epss_score": 0.00114, "epss_percentile": 0.30812}, "CVE-2023-51473": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2023-51474": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-51475": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2023-51476": {"epss_score": 0.00624, "epss_percentile": 0.69571}, "CVE-2023-51477": {"epss_score": 0.00367, "epss_percentile": 0.58135}, "CVE-2023-51478": {"epss_score": 0.00114, "epss_percentile": 0.30812}, "CVE-2023-51479": {"epss_score": 0.00319, "epss_percentile": 0.54559}, "CVE-2023-51480": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-51481": {"epss_score": 0.00478, "epss_percentile": 0.64393}, "CVE-2023-51482": {"epss_score": 0.0025, "epss_percentile": 0.48115}, "CVE-2023-51483": {"epss_score": 0.00394, "epss_percentile": 0.59785}, "CVE-2023-51484": {"epss_score": 0.0012, "epss_percentile": 0.31725}, "CVE-2023-51485": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-51486": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-51487": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-51488": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2023-51489": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2023-51490": {"epss_score": 0.00693, "epss_percentile": 0.71319}, "CVE-2023-51491": {"epss_score": 0.0004, "epss_percentile": 0.1201}, "CVE-2023-51492": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2023-51493": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2023-51494": {"epss_score": 0.0026, "epss_percentile": 0.49196}, "CVE-2023-51495": {"epss_score": 0.00148, "epss_percentile": 0.35918}, "CVE-2023-51496": {"epss_score": 0.00206, "epss_percentile": 0.42925}, "CVE-2023-51497": {"epss_score": 0.00125, "epss_percentile": 0.32582}, "CVE-2023-51498": {"epss_score": 0.00117, "epss_percentile": 0.31296}, "CVE-2023-51499": {"epss_score": 0.00259, "epss_percentile": 0.49031}, "CVE-2023-51500": {"epss_score": 0.00179, "epss_percentile": 0.39804}, "CVE-2023-51501": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-51502": {"epss_score": 0.00075, "epss_percentile": 0.22932}, "CVE-2023-51503": {"epss_score": 0.00082, "epss_percentile": 0.2458}, "CVE-2023-51504": {"epss_score": 0.01467, "epss_percentile": 0.80474}, "CVE-2023-51505": {"epss_score": 0.00634, "epss_percentile": 0.69789}, "CVE-2023-51506": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-51507": {"epss_score": 0.00206, "epss_percentile": 0.42925}, "CVE-2023-51508": {"epss_score": 0.00693, "epss_percentile": 0.71319}, "CVE-2023-51509": {"epss_score": 0.00087, "epss_percentile": 0.25547}, "CVE-2023-51510": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-51511": {"epss_score": 0.00266, "epss_percentile": 0.4989}, "CVE-2023-51512": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-51513": {"epss_score": 0.00028, "epss_percentile": 0.0725}, "CVE-2023-51514": {"epss_score": 0.00069, "epss_percentile": 0.21485}, "CVE-2023-51515": {"epss_score": 0.00188, "epss_percentile": 0.40909}, "CVE-2023-51516": {"epss_score": 0.00125, "epss_percentile": 0.32582}, "CVE-2023-51517": {"epss_score": 0.0017, "epss_percentile": 0.38689}, "CVE-2023-51518": {"epss_score": 0.00439, "epss_percentile": 0.62596}, "CVE-2023-51519": {"epss_score": 0.00162, "epss_percentile": 0.37624}, "CVE-2023-51520": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-51521": {"epss_score": 0.00048, "epss_percentile": 0.15129}, "CVE-2023-51522": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2023-51523": {"epss_score": 0.00174, "epss_percentile": 0.39145}, "CVE-2023-51524": {"epss_score": 0.00581, "epss_percentile": 0.68262}, "CVE-2023-51525": {"epss_score": 0.0005, "epss_percentile": 0.15731}, "CVE-2023-51526": {"epss_score": 0.00313, "epss_percentile": 0.54072}, "CVE-2023-51527": {"epss_score": 0.00589, "epss_percentile": 0.68518}, "CVE-2023-51528": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2023-51529": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2023-51530": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2023-51531": {"epss_score": 0.00123, "epss_percentile": 0.32321}, "CVE-2023-51532": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-51533": {"epss_score": 0.00069, "epss_percentile": 0.21603}, "CVE-2023-51534": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-51535": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2023-51536": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-51537": {"epss_score": 0.00205, "epss_percentile": 0.42678}, "CVE-2023-51538": {"epss_score": 0.00078, "epss_percentile": 0.23611}, "CVE-2023-51539": {"epss_score": 0.0006, "epss_percentile": 0.18951}, "CVE-2023-51540": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2023-51541": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-51542": {"epss_score": 0.00084, "epss_percentile": 0.24902}, "CVE-2023-51543": {"epss_score": 0.00084, "epss_percentile": 0.24902}, "CVE-2023-51544": {"epss_score": 0.00246, "epss_percentile": 0.47736}, "CVE-2023-51545": {"epss_score": 0.00195, "epss_percentile": 0.41692}, "CVE-2023-51546": {"epss_score": 0.00165, "epss_percentile": 0.38051}, "CVE-2023-51547": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-51548": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-51549": {"epss_score": 0.01504, "epss_percentile": 0.80735}, "CVE-2023-51550": {"epss_score": 0.00342, "epss_percentile": 0.5639}, "CVE-2023-51551": {"epss_score": 0.01635, "epss_percentile": 0.81473}, "CVE-2023-51552": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2023-51553": {"epss_score": 0.00342, "epss_percentile": 0.5639}, "CVE-2023-51554": {"epss_score": 0.00616, "epss_percentile": 0.69321}, "CVE-2023-51555": {"epss_score": 0.00392, "epss_percentile": 0.59653}, "CVE-2023-51556": {"epss_score": 0.01717, "epss_percentile": 0.81915}, "CVE-2023-51557": {"epss_score": 0.01635, "epss_percentile": 0.81473}, "CVE-2023-51558": {"epss_score": 0.00412, "epss_percentile": 0.60913}, "CVE-2023-51559": {"epss_score": 0.00097, "epss_percentile": 0.2752}, "CVE-2023-51560": {"epss_score": 0.0147, "epss_percentile": 0.80495}, "CVE-2023-51561": {"epss_score": 0.00799, "epss_percentile": 0.73521}, "CVE-2023-51562": {"epss_score": 0.00392, "epss_percentile": 0.59653}, "CVE-2023-51563": {"epss_score": 0.00569, "epss_percentile": 0.6792}, "CVE-2023-51564": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-51565": {"epss_score": 0.00569, "epss_percentile": 0.6792}, "CVE-2023-51566": {"epss_score": 0.02147, "epss_percentile": 0.83768}, "CVE-2023-51567": {"epss_score": 0.00208, "epss_percentile": 0.43248}, "CVE-2023-51568": {"epss_score": 0.00215, "epss_percentile": 0.44033}, "CVE-2023-51569": {"epss_score": 0.00553, "epss_percentile": 0.67408}, "CVE-2023-51570": {"epss_score": 0.04618, "epss_percentile": 0.88927}, "CVE-2023-51571": {"epss_score": 0.00551, "epss_percentile": 0.67376}, "CVE-2023-51572": {"epss_score": 0.377, "epss_percentile": 0.97064}, "CVE-2023-51573": {"epss_score": 0.00768, "epss_percentile": 0.72966}, "CVE-2023-51574": {"epss_score": 0.01461, "epss_percentile": 0.80423}, "CVE-2023-51575": {"epss_score": 0.06077, "epss_percentile": 0.90459}, "CVE-2023-51576": {"epss_score": 0.05797, "epss_percentile": 0.90219}, "CVE-2023-51577": {"epss_score": 0.0007, "epss_percentile": 0.21693}, "CVE-2023-51578": {"epss_score": 0.00625, "epss_percentile": 0.69587}, "CVE-2023-51579": {"epss_score": 0.00051, "epss_percentile": 0.16041}, "CVE-2023-51580": {"epss_score": 0.00043, "epss_percentile": 0.13346}, "CVE-2023-51581": {"epss_score": 0.06077, "epss_percentile": 0.90459}, "CVE-2023-51582": {"epss_score": 0.04504, "epss_percentile": 0.88768}, "CVE-2023-51583": {"epss_score": 0.02576, "epss_percentile": 0.85142}, "CVE-2023-51584": {"epss_score": 0.01007, "epss_percentile": 0.76562}, "CVE-2023-51585": {"epss_score": 0.00573, "epss_percentile": 0.68058}, "CVE-2023-51586": {"epss_score": 0.07647, "epss_percentile": 0.916}, "CVE-2023-51587": {"epss_score": 0.08119, "epss_percentile": 0.91889}, "CVE-2023-51588": {"epss_score": 0.00056, "epss_percentile": 0.17851}, "CVE-2023-51589": {"epss_score": 0.0004, "epss_percentile": 0.12008}, "CVE-2023-51590": {"epss_score": 0.03398, "epss_percentile": 0.87064}, "CVE-2023-51591": {"epss_score": 0.00189, "epss_percentile": 0.40961}, "CVE-2023-51592": {"epss_score": 0.00029, "epss_percentile": 0.07971}, "CVE-2023-51593": {"epss_score": 0.02716, "epss_percentile": 0.85509}, "CVE-2023-51594": {"epss_score": 0.00038, "epss_percentile": 0.11278}, "CVE-2023-51595": {"epss_score": 0.36387, "epss_percentile": 0.96973}, "CVE-2023-51596": {"epss_score": 0.02808, "epss_percentile": 0.85712}, "CVE-2023-51597": {"epss_score": 0.00532, "epss_percentile": 0.66693}, "CVE-2023-51598": {"epss_score": 0.00649, "epss_percentile": 0.70225}, "CVE-2023-51599": {"epss_score": 0.02477, "epss_percentile": 0.84866}, "CVE-2023-51600": {"epss_score": 0.00112, "epss_percentile": 0.30503}, "CVE-2023-51601": {"epss_score": 0.00096, "epss_percentile": 0.27333}, "CVE-2023-51602": {"epss_score": 0.00096, "epss_percentile": 0.27333}, "CVE-2023-51603": {"epss_score": 0.02477, "epss_percentile": 0.84866}, "CVE-2023-51604": {"epss_score": 0.00112, "epss_percentile": 0.30503}, "CVE-2023-51605": {"epss_score": 0.00096, "epss_percentile": 0.27286}, "CVE-2023-51606": {"epss_score": 0.00674, "epss_percentile": 0.70873}, "CVE-2023-51607": {"epss_score": 0.00339, "epss_percentile": 0.56194}, "CVE-2023-51608": {"epss_score": 0.00674, "epss_percentile": 0.70873}, "CVE-2023-51609": {"epss_score": 0.00221, "epss_percentile": 0.44701}, "CVE-2023-51610": {"epss_score": 0.00274, "epss_percentile": 0.50558}, "CVE-2023-51611": {"epss_score": 0.00221, "epss_percentile": 0.44701}, "CVE-2023-51612": {"epss_score": 0.00265, "epss_percentile": 0.49778}, "CVE-2023-51613": {"epss_score": 0.01096, "epss_percentile": 0.77517}, "CVE-2023-51614": {"epss_score": 0.01749, "epss_percentile": 0.82091}, "CVE-2023-51615": {"epss_score": 0.01749, "epss_percentile": 0.82091}, "CVE-2023-51616": {"epss_score": 0.01749, "epss_percentile": 0.82091}, "CVE-2023-51617": {"epss_score": 0.01749, "epss_percentile": 0.82091}, "CVE-2023-51618": {"epss_score": 0.01749, "epss_percentile": 0.82091}, "CVE-2023-51619": {"epss_score": 0.01749, "epss_percentile": 0.82091}, "CVE-2023-51620": {"epss_score": 0.01749, "epss_percentile": 0.82091}, "CVE-2023-51621": {"epss_score": 0.01044, "epss_percentile": 0.7701}, "CVE-2023-51622": {"epss_score": 0.01044, "epss_percentile": 0.7701}, "CVE-2023-51623": {"epss_score": 0.01044, "epss_percentile": 0.7701}, "CVE-2023-51624": {"epss_score": 0.0528, "epss_percentile": 0.89688}, "CVE-2023-51625": {"epss_score": 0.00556, "epss_percentile": 0.6751}, "CVE-2023-51626": {"epss_score": 0.0528, "epss_percentile": 0.89688}, "CVE-2023-51627": {"epss_score": 0.01228, "epss_percentile": 0.7871}, "CVE-2023-51628": {"epss_score": 0.01024, "epss_percentile": 0.7678}, "CVE-2023-51629": {"epss_score": 0.00193, "epss_percentile": 0.41408}, "CVE-2023-51630": {"epss_score": 0.00121, "epss_percentile": 0.3188}, "CVE-2023-51631": {"epss_score": 0.01372, "epss_percentile": 0.79815}, "CVE-2023-51633": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2023-51634": {"epss_score": 0.00611, "epss_percentile": 0.69207}, "CVE-2023-51635": {"epss_score": 0.01348, "epss_percentile": 0.79665}, "CVE-2023-51636": {"epss_score": 0.00099, "epss_percentile": 0.28429}, "CVE-2023-51637": {"epss_score": 0.04061, "epss_percentile": 0.88191}, "CVE-2023-51638": {"epss_score": 0.00192, "epss_percentile": 0.41333}, "CVE-2023-51639": {"epss_score": 0.00376, "epss_percentile": 0.58656}, "CVE-2023-51640": {"epss_score": 0.00975, "epss_percentile": 0.76203}, "CVE-2023-51641": {"epss_score": 0.04726, "epss_percentile": 0.89064}, "CVE-2023-51642": {"epss_score": 0.04726, "epss_percentile": 0.89064}, "CVE-2023-51643": {"epss_score": 0.00841, "epss_percentile": 0.74219}, "CVE-2023-51644": {"epss_score": 0.01791, "epss_percentile": 0.82283}, "CVE-2023-51645": {"epss_score": 0.00975, "epss_percentile": 0.76203}, "CVE-2023-51646": {"epss_score": 0.00396, "epss_percentile": 0.59855}, "CVE-2023-51647": {"epss_score": 0.00453, "epss_percentile": 0.63206}, "CVE-2023-51648": {"epss_score": 0.00936, "epss_percentile": 0.75676}, "CVE-2023-51649": {"epss_score": 0.00103, "epss_percentile": 0.28925}, "CVE-2023-51650": {"epss_score": 0.00466, "epss_percentile": 0.63794}, "CVE-2023-51651": {"epss_score": 0.00099, "epss_percentile": 0.28396}, "CVE-2023-51652": {"epss_score": 0.00918, "epss_percentile": 0.75444}, "CVE-2023-51653": {"epss_score": 0.05944, "epss_percentile": 0.90352}, "CVE-2023-51654": {"epss_score": 0.0002, "epss_percentile": 0.04441}, "CVE-2023-51655": {"epss_score": 4e-05, "epss_percentile": 0.00173}, "CVE-2023-51656": {"epss_score": 0.00725, "epss_percentile": 0.72053}, "CVE-2023-51661": {"epss_score": 0.00354, "epss_percentile": 0.57217}, "CVE-2023-51662": {"epss_score": 0.00266, "epss_percentile": 0.49915}, "CVE-2023-51663": {"epss_score": 0.00085, "epss_percentile": 0.25106}, "CVE-2023-51664": {"epss_score": 0.00673, "epss_percentile": 0.70833}, "CVE-2023-51665": {"epss_score": 0.00056, "epss_percentile": 0.17698}, "CVE-2023-51666": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-51667": {"epss_score": 0.00176, "epss_percentile": 0.3938}, "CVE-2023-51668": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-51669": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2023-51670": {"epss_score": 0.00202, "epss_percentile": 0.42395}, "CVE-2023-51671": {"epss_score": 0.00145, "epss_percentile": 0.35502}, "CVE-2023-51672": {"epss_score": 0.00224, "epss_percentile": 0.45044}, "CVE-2023-51673": {"epss_score": 0.00051, "epss_percentile": 0.16103}, "CVE-2023-51674": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2023-51675": {"epss_score": 0.00189, "epss_percentile": 0.4098}, "CVE-2023-51676": {"epss_score": 0.00389, "epss_percentile": 0.59456}, "CVE-2023-51677": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-51678": {"epss_score": 0.00067, "epss_percentile": 0.20993}, "CVE-2023-51679": {"epss_score": 0.00132, "epss_percentile": 0.33515}, "CVE-2023-51680": {"epss_score": 0.00123, "epss_percentile": 0.32269}, "CVE-2023-51681": {"epss_score": 0.00198, "epss_percentile": 0.41999}, "CVE-2023-51682": {"epss_score": 0.00213, "epss_percentile": 0.43838}, "CVE-2023-51683": {"epss_score": 0.00112, "epss_percentile": 0.3043}, "CVE-2023-51684": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2023-51685": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-51687": {"epss_score": 0.00693, "epss_percentile": 0.71319}, "CVE-2023-51688": {"epss_score": 0.00693, "epss_percentile": 0.71319}, "CVE-2023-51689": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-51690": {"epss_score": 0.0005, "epss_percentile": 0.15968}, "CVE-2023-51691": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2023-51692": {"epss_score": 0.00099, "epss_percentile": 0.28367}, "CVE-2023-51693": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-51694": {"epss_score": 0.0005, "epss_percentile": 0.15968}, "CVE-2023-51695": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2023-51696": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2023-51697": {"epss_score": 0.00056, "epss_percentile": 0.17698}, "CVE-2023-51698": {"epss_score": 0.02336, "epss_percentile": 0.84417}, "CVE-2023-51699": {"epss_score": 0.00069, "epss_percentile": 0.21478}, "CVE-2023-51700": {"epss_score": 0.00632, "epss_percentile": 0.69736}, "CVE-2023-51701": {"epss_score": 0.00229, "epss_percentile": 0.45605}, "CVE-2023-51702": {"epss_score": 0.00064, "epss_percentile": 0.20108}, "CVE-2023-51704": {"epss_score": 0.00331, "epss_percentile": 0.55513}, "CVE-2023-51707": {"epss_score": 0.02631, "epss_percentile": 0.85283}, "CVE-2023-51708": {"epss_score": 0.00299, "epss_percentile": 0.52858}, "CVE-2023-51710": {"epss_score": 0.00048, "epss_percentile": 0.15238}, "CVE-2023-51711": {"epss_score": 0.0003, "epss_percentile": 0.08201}, "CVE-2023-51712": {"epss_score": 0.0009, "epss_percentile": 0.26047}, "CVE-2023-51713": {"epss_score": 0.72041, "epss_percentile": 0.98693}, "CVE-2023-51714": {"epss_score": 0.00127, "epss_percentile": 0.3294}, "CVE-2023-51717": {"epss_score": 0.00066, "epss_percentile": 0.2096}, "CVE-2023-51719": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-51720": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-51721": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-51722": {"epss_score": 0.00036, "epss_percentile": 0.10539}, "CVE-2023-51723": {"epss_score": 0.00036, "epss_percentile": 0.10539}, "CVE-2023-51724": {"epss_score": 0.00036, "epss_percentile": 0.10539}, "CVE-2023-51725": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-51726": {"epss_score": 0.00034, "epss_percentile": 0.09787}, "CVE-2023-51727": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-51728": {"epss_score": 0.00036, "epss_percentile": 0.10539}, "CVE-2023-51729": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-51730": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-51731": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-51732": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-51733": {"epss_score": 0.00036, "epss_percentile": 0.10539}, "CVE-2023-51734": {"epss_score": 0.00036, "epss_percentile": 0.10539}, "CVE-2023-51735": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-51736": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-51737": {"epss_score": 0.00034, "epss_percentile": 0.09787}, "CVE-2023-51738": {"epss_score": 0.00034, "epss_percentile": 0.09787}, "CVE-2023-51739": {"epss_score": 0.00036, "epss_percentile": 0.10288}, "CVE-2023-51740": {"epss_score": 0.00041, "epss_percentile": 0.12335}, "CVE-2023-51741": {"epss_score": 0.00046, "epss_percentile": 0.14129}, "CVE-2023-51742": {"epss_score": 0.00204, "epss_percentile": 0.42612}, "CVE-2023-51743": {"epss_score": 0.00204, "epss_percentile": 0.42612}, "CVE-2023-51744": {"epss_score": 0.0004, "epss_percentile": 0.11965}, "CVE-2023-51745": {"epss_score": 0.00048, "epss_percentile": 0.151}, "CVE-2023-51746": {"epss_score": 0.00084, "epss_percentile": 0.24877}, "CVE-2023-51747": {"epss_score": 0.00243, "epss_percentile": 0.47413}, "CVE-2023-51748": {"epss_score": 0.00098, "epss_percentile": 0.2781}, "CVE-2023-51749": {"epss_score": 0.00094, "epss_percentile": 0.26778}, "CVE-2023-51750": {"epss_score": 0.00238, "epss_percentile": 0.46817}, "CVE-2023-51751": {"epss_score": 0.0017, "epss_percentile": 0.38661}, "CVE-2023-51761": {"epss_score": 0.00045, "epss_percentile": 0.13777}, "CVE-2023-51763": {"epss_score": 0.00122, "epss_percentile": 0.32109}, "CVE-2023-51764": {"epss_score": 0.21846, "epss_percentile": 0.95567}, "CVE-2023-51765": {"epss_score": 0.00837, "epss_percentile": 0.74151}, "CVE-2023-51766": {"epss_score": 0.01642, "epss_percentile": 0.81513}, "CVE-2023-51767": {"epss_score": 0.0001, "epss_percentile": 0.00789}, "CVE-2023-51770": {"epss_score": 0.01343, "epss_percentile": 0.79607}, "CVE-2023-51771": {"epss_score": 0.00112, "epss_percentile": 0.30554}, "CVE-2023-51772": {"epss_score": 0.00069, "epss_percentile": 0.21618}, "CVE-2023-51773": {"epss_score": 0.00372, "epss_percentile": 0.58424}, "CVE-2023-51774": {"epss_score": 0.00011, "epss_percentile": 0.01006}, "CVE-2023-51775": {"epss_score": 0.00316, "epss_percentile": 0.54289}, "CVE-2023-51776": {"epss_score": 0.00065, "epss_percentile": 0.2066}, "CVE-2023-51777": {"epss_score": 0.00087, "epss_percentile": 0.25604}, "CVE-2023-51778": {"epss_score": 0.00087, "epss_percentile": 0.25446}, "CVE-2023-51779": {"epss_score": 0.00102, "epss_percentile": 0.28792}, "CVE-2023-51780": {"epss_score": 0.00022, "epss_percentile": 0.05066}, "CVE-2023-51781": {"epss_score": 0.00018, "epss_percentile": 0.03807}, "CVE-2023-51782": {"epss_score": 0.00019, "epss_percentile": 0.04081}, "CVE-2023-51784": {"epss_score": 0.06747, "epss_percentile": 0.90999}, "CVE-2023-51785": {"epss_score": 0.00401, "epss_percentile": 0.60244}, "CVE-2023-51786": {"epss_score": 0.00165, "epss_percentile": 0.38042}, "CVE-2023-51787": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2023-51790": {"epss_score": 0.0033, "epss_percentile": 0.55496}, "CVE-2023-51791": {"epss_score": 0.00029, "epss_percentile": 0.0775}, "CVE-2023-51792": {"epss_score": 0.00016, "epss_percentile": 0.02703}, "CVE-2023-51793": {"epss_score": 0.00034, "epss_percentile": 0.09433}, "CVE-2023-51794": {"epss_score": 0.00086, "epss_percentile": 0.25381}, "CVE-2023-51795": {"epss_score": 0.00059, "epss_percentile": 0.18629}, "CVE-2023-51796": {"epss_score": 0.0002, "epss_percentile": 0.04628}, "CVE-2023-51797": {"epss_score": 0.0003, "epss_percentile": 0.08056}, "CVE-2023-51798": {"epss_score": 0.00045, "epss_percentile": 0.14058}, "CVE-2023-51800": {"epss_score": 0.00298, "epss_percentile": 0.52793}, "CVE-2023-51801": {"epss_score": 0.07578, "epss_percentile": 0.91549}, "CVE-2023-51802": {"epss_score": 0.00357, "epss_percentile": 0.57478}, "CVE-2023-51803": {"epss_score": 0.00049, "epss_percentile": 0.1561}, "CVE-2023-51804": {"epss_score": 0.00163, "epss_percentile": 0.3778}, "CVE-2023-51805": {"epss_score": 0.00105, "epss_percentile": 0.29259}, "CVE-2023-51806": {"epss_score": 0.00104, "epss_percentile": 0.29237}, "CVE-2023-51807": {"epss_score": 0.00183, "epss_percentile": 0.40279}, "CVE-2023-51810": {"epss_score": 0.0481, "epss_percentile": 0.89165}, "CVE-2023-51812": {"epss_score": 0.02618, "epss_percentile": 0.8525}, "CVE-2023-51813": {"epss_score": 0.00166, "epss_percentile": 0.38239}, "CVE-2023-51820": {"epss_score": 0.00202, "epss_percentile": 0.42434}, "CVE-2023-51828": {"epss_score": 0.00813, "epss_percentile": 0.73764}, "CVE-2023-51833": {"epss_score": 0.00621, "epss_percentile": 0.69458}, "CVE-2023-51835": {"epss_score": 0.0123, "epss_percentile": 0.78724}, "CVE-2023-51837": {"epss_score": 0.00085, "epss_percentile": 0.25159}, "CVE-2023-51838": {"epss_score": 0.00047, "epss_percentile": 0.14612}, "CVE-2023-51839": {"epss_score": 0.00107, "epss_percentile": 0.29718}, "CVE-2023-51840": {"epss_score": 0.00242, "epss_percentile": 0.47391}, "CVE-2023-51842": {"epss_score": 0.00192, "epss_percentile": 0.41338}, "CVE-2023-51843": {"epss_score": 0.00102, "epss_percentile": 0.2882}, "CVE-2023-51847": {"epss_score": 0.00546, "epss_percentile": 0.67207}, "CVE-2023-51885": {"epss_score": 0.02948, "epss_percentile": 0.86048}, "CVE-2023-51886": {"epss_score": 0.00672, "epss_percentile": 0.70816}, "CVE-2023-51887": {"epss_score": 0.03179, "epss_percentile": 0.86576}, "CVE-2023-51888": {"epss_score": 0.00672, "epss_percentile": 0.70816}, "CVE-2023-51889": {"epss_score": 0.02948, "epss_percentile": 0.86048}, "CVE-2023-51890": {"epss_score": 0.00445, "epss_percentile": 0.6285}, "CVE-2023-51892": {"epss_score": 0.02872, "epss_percentile": 0.85876}, "CVE-2023-51906": {"epss_score": 0.02872, "epss_percentile": 0.85876}, "CVE-2023-51924": {"epss_score": 0.00535, "epss_percentile": 0.66844}, "CVE-2023-51925": {"epss_score": 0.00275, "epss_percentile": 0.50676}, "CVE-2023-51926": {"epss_score": 0.00253, "epss_percentile": 0.48461}, "CVE-2023-51927": {"epss_score": 0.00133, "epss_percentile": 0.33652}, "CVE-2023-51928": {"epss_score": 0.00535, "epss_percentile": 0.66844}, "CVE-2023-51931": {"epss_score": 0.0009, "epss_percentile": 0.26166}, "CVE-2023-51939": {"epss_score": 0.01272, "epss_percentile": 0.7908}, "CVE-2023-51946": {"epss_score": 0.00116, "epss_percentile": 0.31065}, "CVE-2023-51947": {"epss_score": 0.00339, "epss_percentile": 0.56208}, "CVE-2023-51948": {"epss_score": 0.0018, "epss_percentile": 0.39867}, "CVE-2023-51949": {"epss_score": 0.00089, "epss_percentile": 0.25929}, "CVE-2023-51951": {"epss_score": 0.02604, "epss_percentile": 0.85216}, "CVE-2023-51952": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51953": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51954": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51955": {"epss_score": 0.00227, "epss_percentile": 0.45442}, "CVE-2023-51956": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51957": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51958": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51959": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51960": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51961": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51962": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-51963": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-51964": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51965": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51966": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51967": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-51968": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-51969": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-51970": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2023-51971": {"epss_score": 0.00243, "epss_percentile": 0.47466}, "CVE-2023-51972": {"epss_score": 0.03839, "epss_percentile": 0.87829}, "CVE-2023-51978": {"epss_score": 0.00068, "epss_percentile": 0.21375}, "CVE-2023-51982": {"epss_score": 0.00043, "epss_percentile": 0.13068}, "CVE-2023-51984": {"epss_score": 0.14083, "epss_percentile": 0.94129}, "CVE-2023-51987": {"epss_score": 0.00373, "epss_percentile": 0.58472}, "CVE-2023-52026": {"epss_score": 0.03086, "epss_percentile": 0.86386}, "CVE-2023-52027": {"epss_score": 0.1549, "epss_percentile": 0.94437}, "CVE-2023-52028": {"epss_score": 0.20554, "epss_percentile": 0.95377}, "CVE-2023-52029": {"epss_score": 0.1549, "epss_percentile": 0.94437}, "CVE-2023-52030": {"epss_score": 0.14816, "epss_percentile": 0.94291}, "CVE-2023-52031": {"epss_score": 0.14816, "epss_percentile": 0.94291}, "CVE-2023-52032": {"epss_score": 0.14385, "epss_percentile": 0.94199}, "CVE-2023-52038": {"epss_score": 0.00122, "epss_percentile": 0.32065}, "CVE-2023-52039": {"epss_score": 0.00122, "epss_percentile": 0.32065}, "CVE-2023-52040": {"epss_score": 0.00104, "epss_percentile": 0.29236}, "CVE-2023-52041": {"epss_score": 0.00263, "epss_percentile": 0.49489}, "CVE-2023-52042": {"epss_score": 0.00278, "epss_percentile": 0.5085}, "CVE-2023-52043": {"epss_score": 0.00116, "epss_percentile": 0.31073}, "CVE-2023-52044": {"epss_score": 0.01894, "epss_percentile": 0.82741}, "CVE-2023-52045": {"epss_score": 0.00036, "epss_percentile": 0.10379}, "CVE-2023-52046": {"epss_score": 0.00039, "epss_percentile": 0.11798}, "CVE-2023-52047": {"epss_score": 0.00226, "epss_percentile": 0.4533}, "CVE-2023-52048": {"epss_score": 0.00148, "epss_percentile": 0.35924}, "CVE-2023-52059": {"epss_score": 0.00151, "epss_percentile": 0.36346}, "CVE-2023-52060": {"epss_score": 0.0009, "epss_percentile": 0.26018}, "CVE-2023-52064": {"epss_score": 0.0014, "epss_percentile": 0.34699}, "CVE-2023-52066": {"epss_score": 0.00211, "epss_percentile": 0.43634}, "CVE-2023-52068": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2023-52069": {"epss_score": 0.00075, "epss_percentile": 0.23032}, "CVE-2023-52070": {"epss_score": 0.00105, "epss_percentile": 0.29383}, "CVE-2023-52072": {"epss_score": 0.0015, "epss_percentile": 0.36182}, "CVE-2023-52073": {"epss_score": 0.0015, "epss_percentile": 0.36182}, "CVE-2023-52074": {"epss_score": 0.0015, "epss_percentile": 0.36182}, "CVE-2023-52075": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-52076": {"epss_score": 0.09765, "epss_percentile": 0.92694}, "CVE-2023-52077": {"epss_score": 0.00135, "epss_percentile": 0.34001}, "CVE-2023-52079": {"epss_score": 0.00336, "epss_percentile": 0.56005}, "CVE-2023-52080": {"epss_score": 0.00085, "epss_percentile": 0.25074}, "CVE-2023-52081": {"epss_score": 0.00131, "epss_percentile": 0.33397}, "CVE-2023-52082": {"epss_score": 0.00378, "epss_percentile": 0.58828}, "CVE-2023-52083": {"epss_score": 0.0036, "epss_percentile": 0.57658}, "CVE-2023-52084": {"epss_score": 0.00316, "epss_percentile": 0.54279}, "CVE-2023-52085": {"epss_score": 0.38122, "epss_percentile": 0.97086}, "CVE-2023-52086": {"epss_score": 0.00097, "epss_percentile": 0.27615}, "CVE-2023-52090": {"epss_score": 0.00061, "epss_percentile": 0.19434}, "CVE-2023-52091": {"epss_score": 0.00054, "epss_percentile": 0.1727}, "CVE-2023-52092": {"epss_score": 0.00061, "epss_percentile": 0.19434}, "CVE-2023-52093": {"epss_score": 0.00052, "epss_percentile": 0.16389}, "CVE-2023-52094": {"epss_score": 0.00055, "epss_percentile": 0.17559}, "CVE-2023-52096": {"epss_score": 0.00306, "epss_percentile": 0.53458}, "CVE-2023-52097": {"epss_score": 0.00065, "epss_percentile": 0.20472}, "CVE-2023-52098": {"epss_score": 0.00072, "epss_percentile": 0.2239}, "CVE-2023-52099": {"epss_score": 0.0005, "epss_percentile": 0.15691}, "CVE-2023-52100": {"epss_score": 0.00136, "epss_percentile": 0.34083}, "CVE-2023-52101": {"epss_score": 0.00132, "epss_percentile": 0.33616}, "CVE-2023-52102": {"epss_score": 0.00175, "epss_percentile": 0.39289}, "CVE-2023-52103": {"epss_score": 0.00203, "epss_percentile": 0.42505}, "CVE-2023-52104": {"epss_score": 0.00175, "epss_percentile": 0.39289}, "CVE-2023-52105": {"epss_score": 0.00178, "epss_percentile": 0.39647}, "CVE-2023-52106": {"epss_score": 0.00058, "epss_percentile": 0.18296}, "CVE-2023-52107": {"epss_score": 0.00071, "epss_percentile": 0.22073}, "CVE-2023-52108": {"epss_score": 0.00063, "epss_percentile": 0.20059}, "CVE-2023-52109": {"epss_score": 0.00073, "epss_percentile": 0.22488}, "CVE-2023-52110": {"epss_score": 0.00063, "epss_percentile": 0.20059}, "CVE-2023-52111": {"epss_score": 0.00054, "epss_percentile": 0.17278}, "CVE-2023-52112": {"epss_score": 0.00024, "epss_percentile": 0.05776}, "CVE-2023-52113": {"epss_score": 0.00054, "epss_percentile": 0.17358}, "CVE-2023-52114": {"epss_score": 0.00054, "epss_percentile": 0.17278}, "CVE-2023-52115": {"epss_score": 0.00063, "epss_percentile": 0.20059}, "CVE-2023-52116": {"epss_score": 0.00072, "epss_percentile": 0.22313}, "CVE-2023-52117": {"epss_score": 0.00124, "epss_percentile": 0.32351}, "CVE-2023-52118": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-52119": {"epss_score": 0.00092, "epss_percentile": 0.26502}, "CVE-2023-52120": {"epss_score": 0.00043, "epss_percentile": 0.13167}, "CVE-2023-52121": {"epss_score": 0.00051, "epss_percentile": 0.16103}, "CVE-2023-52122": {"epss_score": 0.0007, "epss_percentile": 0.2193}, "CVE-2023-52123": {"epss_score": 0.00092, "epss_percentile": 0.26501}, "CVE-2023-52124": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-52125": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-52126": {"epss_score": 0.00194, "epss_percentile": 0.41548}, "CVE-2023-52127": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-52128": {"epss_score": 0.00092, "epss_percentile": 0.26502}, "CVE-2023-52129": {"epss_score": 0.00048, "epss_percentile": 0.1498}, "CVE-2023-52130": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-52131": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-52132": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-52133": {"epss_score": 0.00147, "epss_percentile": 0.35701}, "CVE-2023-52134": {"epss_score": 0.00139, "epss_percentile": 0.34604}, "CVE-2023-52135": {"epss_score": 0.00291, "epss_percentile": 0.52201}, "CVE-2023-52136": {"epss_score": 0.0007, "epss_percentile": 0.2193}, "CVE-2023-52137": {"epss_score": 0.00475, "epss_percentile": 0.64173}, "CVE-2023-52138": {"epss_score": 0.01882, "epss_percentile": 0.82695}, "CVE-2023-52139": {"epss_score": 0.00111, "epss_percentile": 0.30345}, "CVE-2023-52142": {"epss_score": 0.00269, "epss_percentile": 0.50112}, "CVE-2023-52143": {"epss_score": 0.00295, "epss_percentile": 0.52511}, "CVE-2023-52144": {"epss_score": 0.00251, "epss_percentile": 0.48305}, "CVE-2023-52145": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-52146": {"epss_score": 0.00148, "epss_percentile": 0.35899}, "CVE-2023-52147": {"epss_score": 0.00422, "epss_percentile": 0.6155}, "CVE-2023-52148": {"epss_score": 0.00148, "epss_percentile": 0.35899}, "CVE-2023-52149": {"epss_score": 0.00051, "epss_percentile": 0.16103}, "CVE-2023-52150": {"epss_score": 0.00105, "epss_percentile": 0.29309}, "CVE-2023-52151": {"epss_score": 0.00148, "epss_percentile": 0.35899}, "CVE-2023-52152": {"epss_score": 0.00132, "epss_percentile": 0.33606}, "CVE-2023-52153": {"epss_score": 0.00366, "epss_percentile": 0.58064}, "CVE-2023-52154": {"epss_score": 0.00068, "epss_percentile": 0.21397}, "CVE-2023-52155": {"epss_score": 0.00399, "epss_percentile": 0.601}, "CVE-2023-52159": {"epss_score": 0.03203, "epss_percentile": 0.86626}, "CVE-2023-52160": {"epss_score": 0.03378, "epss_percentile": 0.87025}, "CVE-2023-52161": {"epss_score": 0.00731, "epss_percentile": 0.72182}, "CVE-2023-52162": {"epss_score": 0.00284, "epss_percentile": 0.515}, "CVE-2023-52163": {"epss_score": 0.15047, "epss_percentile": 0.9435}, "CVE-2023-52164": {"epss_score": 0.00031, "epss_percentile": 0.0863}, "CVE-2023-52168": {"epss_score": 0.00074, "epss_percentile": 0.22846}, "CVE-2023-52169": {"epss_score": 0.00272, "epss_percentile": 0.50393}, "CVE-2023-52173": {"epss_score": 0.00216, "epss_percentile": 0.44197}, "CVE-2023-52174": {"epss_score": 0.00206, "epss_percentile": 0.42781}, "CVE-2023-52175": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-52176": {"epss_score": 0.00144, "epss_percentile": 0.35309}, "CVE-2023-52177": {"epss_score": 0.00125, "epss_percentile": 0.32607}, "CVE-2023-52178": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-52179": {"epss_score": 0.00097, "epss_percentile": 0.27452}, "CVE-2023-52180": {"epss_score": 0.00117, "epss_percentile": 0.31219}, "CVE-2023-52181": {"epss_score": 0.00303, "epss_percentile": 0.53214}, "CVE-2023-52182": {"epss_score": 0.00357, "epss_percentile": 0.57478}, "CVE-2023-52183": {"epss_score": 0.00061, "epss_percentile": 0.19303}, "CVE-2023-52184": {"epss_score": 0.0007, "epss_percentile": 0.2193}, "CVE-2023-52185": {"epss_score": 0.00282, "epss_percentile": 0.51203}, "CVE-2023-52186": {"epss_score": 0.00206, "epss_percentile": 0.42925}, "CVE-2023-52187": {"epss_score": 0.00282, "epss_percentile": 0.51203}, "CVE-2023-52188": {"epss_score": 0.00081, "epss_percentile": 0.24347}, "CVE-2023-52189": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-52190": {"epss_score": 0.00618, "epss_percentile": 0.69365}, "CVE-2023-52191": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-52192": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-52193": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-52194": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-52195": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-52196": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-52197": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-52198": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2023-52199": {"epss_score": 0.00143, "epss_percentile": 0.35175}, "CVE-2023-52200": {"epss_score": 0.00195, "epss_percentile": 0.41692}, "CVE-2023-52201": {"epss_score": 0.00216, "epss_percentile": 0.44224}, "CVE-2023-52202": {"epss_score": 0.00521, "epss_percentile": 0.66223}, "CVE-2023-52203": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2023-52204": {"epss_score": 0.00308, "epss_percentile": 0.53602}, "CVE-2023-52205": {"epss_score": 0.00521, "epss_percentile": 0.66223}, "CVE-2023-52206": {"epss_score": 0.00433, "epss_percentile": 0.62181}, "CVE-2023-52207": {"epss_score": 0.00457, "epss_percentile": 0.63389}, "CVE-2023-52208": {"epss_score": 0.00498, "epss_percentile": 0.65245}, "CVE-2023-52209": {"epss_score": 0.00166, "epss_percentile": 0.38197}, "CVE-2023-52210": {"epss_score": 0.00105, "epss_percentile": 0.29383}, "CVE-2023-52211": {"epss_score": 0.00151, "epss_percentile": 0.36346}, "CVE-2023-52212": {"epss_score": 0.00048, "epss_percentile": 0.14933}, "CVE-2023-52213": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2023-52214": {"epss_score": 0.00428, "epss_percentile": 0.61927}, "CVE-2023-52215": {"epss_score": 0.00308, "epss_percentile": 0.53586}, "CVE-2023-52216": {"epss_score": 0.00147, "epss_percentile": 0.35772}, "CVE-2023-52217": {"epss_score": 0.00117, "epss_percentile": 0.31309}, "CVE-2023-52218": {"epss_score": 0.00634, "epss_percentile": 0.69789}, "CVE-2023-52219": {"epss_score": 0.00632, "epss_percentile": 0.6975}, "CVE-2023-52220": {"epss_score": 0.00123, "epss_percentile": 0.32328}, "CVE-2023-52221": {"epss_score": 0.00313, "epss_percentile": 0.54071}, "CVE-2023-52222": {"epss_score": 0.00199, "epss_percentile": 0.42189}, "CVE-2023-52223": {"epss_score": 0.00106, "epss_percentile": 0.29519}, "CVE-2023-52224": {"epss_score": 0.00188, "epss_percentile": 0.40873}, "CVE-2023-52225": {"epss_score": 0.00634, "epss_percentile": 0.69789}, "CVE-2023-52226": {"epss_score": 0.00147, "epss_percentile": 0.35769}, "CVE-2023-52227": {"epss_score": 0.00109, "epss_percentile": 0.30007}, "CVE-2023-52228": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2023-52229": {"epss_score": 0.00052, "epss_percentile": 0.1657}, "CVE-2023-52230": {"epss_score": 0.00385, "epss_percentile": 0.59218}, "CVE-2023-52231": {"epss_score": 0.00577, "epss_percentile": 0.68154}, "CVE-2023-52232": {"epss_score": 0.00155, "epss_percentile": 0.36793}, "CVE-2023-52233": {"epss_score": 0.00158, "epss_percentile": 0.37199}, "CVE-2023-52234": {"epss_score": 0.00577, "epss_percentile": 0.68154}, "CVE-2023-52235": {"epss_score": 0.0008, "epss_percentile": 0.24037}, "CVE-2023-52236": {"epss_score": 0.00021, "epss_percentile": 0.04786}, "CVE-2023-52237": {"epss_score": 0.00146, "epss_percentile": 0.3554}, "CVE-2023-52238": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2023-52239": {"epss_score": 0.00188, "epss_percentile": 0.4083}, "CVE-2023-52240": {"epss_score": 0.00295, "epss_percentile": 0.52449}, "CVE-2023-52251": {"epss_score": 0.93057, "epss_percentile": 0.99772}, "CVE-2023-52252": {"epss_score": 0.00423, "epss_percentile": 0.61578}, "CVE-2023-52257": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2023-52262": {"epss_score": 0.02032, "epss_percentile": 0.83341}, "CVE-2023-52263": {"epss_score": 0.00074, "epss_percentile": 0.22854}, "CVE-2023-52264": {"epss_score": 0.00101, "epss_percentile": 0.28604}, "CVE-2023-52265": {"epss_score": 0.00092, "epss_percentile": 0.26419}, "CVE-2023-52266": {"epss_score": 0.00068, "epss_percentile": 0.21303}, "CVE-2023-52267": {"epss_score": 0.00068, "epss_percentile": 0.21303}, "CVE-2023-52268": {"epss_score": 0.00497, "epss_percentile": 0.65208}, "CVE-2023-52269": {"epss_score": 0.00068, "epss_percentile": 0.21383}, "CVE-2023-52271": {"epss_score": 0.00024, "epss_percentile": 0.05973}, "CVE-2023-52274": {"epss_score": 0.00239, "epss_percentile": 0.46908}, "CVE-2023-52275": {"epss_score": 0.00059, "epss_percentile": 0.18715}, "CVE-2023-52277": {"epss_score": 0.00037, "epss_percentile": 0.10662}, "CVE-2023-52284": {"epss_score": 0.00046, "epss_percentile": 0.14386}, "CVE-2023-52285": {"epss_score": 0.00062, "epss_percentile": 0.19709}, "CVE-2023-52286": {"epss_score": 0.00282, "epss_percentile": 0.51273}, "CVE-2023-52288": {"epss_score": 0.00627, "epss_percentile": 0.69629}, "CVE-2023-52289": {"epss_score": 0.00451, "epss_percentile": 0.63146}, "CVE-2023-52290": {"epss_score": 0.00445, "epss_percentile": 0.62862}, "CVE-2023-52291": {"epss_score": 0.00431, "epss_percentile": 0.62041}, "CVE-2023-52292": {"epss_score": 0.00101, "epss_percentile": 0.28643}, "CVE-2023-52296": {"epss_score": 0.00052, "epss_percentile": 0.16354}, "CVE-2023-52302": {"epss_score": 0.00122, "epss_percentile": 0.32076}, "CVE-2023-52303": {"epss_score": 0.00113, "epss_percentile": 0.30685}, "CVE-2023-52304": {"epss_score": 0.00156, "epss_percentile": 0.3692}, "CVE-2023-52305": {"epss_score": 0.00097, "epss_percentile": 0.27558}, "CVE-2023-52306": {"epss_score": 0.00097, "epss_percentile": 0.27558}, "CVE-2023-52307": {"epss_score": 0.00131, "epss_percentile": 0.33364}, "CVE-2023-52308": {"epss_score": 0.00097, "epss_percentile": 0.27558}, "CVE-2023-52309": {"epss_score": 0.00131, "epss_percentile": 0.33364}, "CVE-2023-52310": {"epss_score": 0.00256, "epss_percentile": 0.48771}, "CVE-2023-52311": {"epss_score": 0.00256, "epss_percentile": 0.48771}, "CVE-2023-52312": {"epss_score": 0.00113, "epss_percentile": 0.30685}, "CVE-2023-52313": {"epss_score": 0.00097, "epss_percentile": 0.27558}, "CVE-2023-52314": {"epss_score": 0.00256, "epss_percentile": 0.48771}, "CVE-2023-52322": {"epss_score": 0.0012, "epss_percentile": 0.31725}, "CVE-2023-52323": {"epss_score": 0.00074, "epss_percentile": 0.22811}, "CVE-2023-52324": {"epss_score": 0.03859, "epss_percentile": 0.87861}, "CVE-2023-52325": {"epss_score": 0.03114, "epss_percentile": 0.86431}, "CVE-2023-52326": {"epss_score": 0.00582, "epss_percentile": 0.68324}, "CVE-2023-52327": {"epss_score": 0.00582, "epss_percentile": 0.68324}, "CVE-2023-52328": {"epss_score": 0.00582, "epss_percentile": 0.68324}, "CVE-2023-52329": {"epss_score": 0.00467, "epss_percentile": 0.63857}, "CVE-2023-52330": {"epss_score": 0.00758, "epss_percentile": 0.72776}, "CVE-2023-52331": {"epss_score": 0.00203, "epss_percentile": 0.42529}, "CVE-2023-52332": {"epss_score": 0.01847, "epss_percentile": 0.82524}, "CVE-2023-52333": {"epss_score": 0.04514, "epss_percentile": 0.88787}, "CVE-2023-52334": {"epss_score": 0.00936, "epss_percentile": 0.75676}, "CVE-2023-52335": {"epss_score": 0.00318, "epss_percentile": 0.54406}, "CVE-2023-52337": {"epss_score": 0.00091, "epss_percentile": 0.26269}, "CVE-2023-52338": {"epss_score": 0.00114, "epss_percentile": 0.3074}, "CVE-2023-52339": {"epss_score": 0.00401, "epss_percentile": 0.60251}, "CVE-2023-52340": {"epss_score": 0.00061, "epss_percentile": 0.19529}, "CVE-2023-52341": {"epss_score": 0.00302, "epss_percentile": 0.53089}, "CVE-2023-52342": {"epss_score": 0.00353, "epss_percentile": 0.57135}, "CVE-2023-52343": {"epss_score": 0.00202, "epss_percentile": 0.42477}, "CVE-2023-52344": {"epss_score": 0.01028, "epss_percentile": 0.76825}, "CVE-2023-52345": {"epss_score": 9e-05, "epss_percentile": 0.00747}, "CVE-2023-52346": {"epss_score": 9e-05, "epss_percentile": 0.00631}, "CVE-2023-52347": {"epss_score": 0.00016, "epss_percentile": 0.02649}, "CVE-2023-52348": {"epss_score": 0.00011, "epss_percentile": 0.0095}, "CVE-2023-52349": {"epss_score": 0.00012, "epss_percentile": 0.01207}, "CVE-2023-52350": {"epss_score": 9e-05, "epss_percentile": 0.0073}, "CVE-2023-52351": {"epss_score": 0.00015, "epss_percentile": 0.02549}, "CVE-2023-52352": {"epss_score": 0.00021, "epss_percentile": 0.04696}, "CVE-2023-52353": {"epss_score": 0.00052, "epss_percentile": 0.166}, "CVE-2023-52354": {"epss_score": 0.0015, "epss_percentile": 0.36138}, "CVE-2023-52355": {"epss_score": 0.00374, "epss_percentile": 0.58536}, "CVE-2023-52356": {"epss_score": 0.00485, "epss_percentile": 0.64717}, "CVE-2023-52357": {"epss_score": 0.00089, "epss_percentile": 0.25946}, "CVE-2023-52358": {"epss_score": 0.00022, "epss_percentile": 0.05262}, "CVE-2023-52359": {"epss_score": 0.00097, "epss_percentile": 0.27622}, "CVE-2023-52360": {"epss_score": 0.00057, "epss_percentile": 0.18223}, "CVE-2023-52361": {"epss_score": 0.0006, "epss_percentile": 0.1917}, "CVE-2023-52362": {"epss_score": 0.00072, "epss_percentile": 0.22313}, "CVE-2023-52363": {"epss_score": 0.00038, "epss_percentile": 0.11101}, "CVE-2023-52364": {"epss_score": 0.00058, "epss_percentile": 0.1856}, "CVE-2023-52365": {"epss_score": 0.00028, "epss_percentile": 0.07258}, "CVE-2023-52366": {"epss_score": 0.00084, "epss_percentile": 0.24885}, "CVE-2023-52367": {"epss_score": 0.0002, "epss_percentile": 0.04611}, "CVE-2023-52368": {"epss_score": 0.00067, "epss_percentile": 0.2107}, "CVE-2023-52369": {"epss_score": 0.0008, "epss_percentile": 0.24047}, "CVE-2023-52370": {"epss_score": 0.00113, "epss_percentile": 0.30734}, "CVE-2023-52371": {"epss_score": 0.00019, "epss_percentile": 0.04395}, "CVE-2023-52372": {"epss_score": 0.00084, "epss_percentile": 0.24885}, "CVE-2023-52373": {"epss_score": 0.0008, "epss_percentile": 0.24193}, "CVE-2023-52374": {"epss_score": 0.0008, "epss_percentile": 0.24193}, "CVE-2023-52375": {"epss_score": 0.00039, "epss_percentile": 0.1158}, "CVE-2023-52376": {"epss_score": 0.0011, "epss_percentile": 0.3013}, "CVE-2023-52377": {"epss_score": 0.00119, "epss_percentile": 0.31671}, "CVE-2023-52378": {"epss_score": 0.00158, "epss_percentile": 0.3729}, "CVE-2023-52379": {"epss_score": 0.0008, "epss_percentile": 0.24193}, "CVE-2023-52380": {"epss_score": 0.00089, "epss_percentile": 0.25915}, "CVE-2023-52381": {"epss_score": 0.00195, "epss_percentile": 0.41606}, "CVE-2023-52383": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2023-52384": {"epss_score": 0.00024, "epss_percentile": 0.06035}, "CVE-2023-52385": {"epss_score": 0.00019, "epss_percentile": 0.04289}, "CVE-2023-52386": {"epss_score": 0.00086, "epss_percentile": 0.25398}, "CVE-2023-52387": {"epss_score": 0.0011, "epss_percentile": 0.3013}, "CVE-2023-52388": {"epss_score": 0.00062, "epss_percentile": 0.19569}, "CVE-2023-52389": {"epss_score": 0.00143, "epss_percentile": 0.35093}, "CVE-2023-52424": {"epss_score": 0.00214, "epss_percentile": 0.43995}, "CVE-2023-52425": {"epss_score": 0.00971, "epss_percentile": 0.76121}, "CVE-2023-52426": {"epss_score": 0.00018, "epss_percentile": 0.03957}, "CVE-2023-52427": {"epss_score": 0.00064, "epss_percentile": 0.20183}, "CVE-2023-52428": {"epss_score": 0.00078, "epss_percentile": 0.23602}, "CVE-2023-52429": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2023-52430": {"epss_score": 0.01181, "epss_percentile": 0.78311}, "CVE-2023-52431": {"epss_score": 0.00028, "epss_percentile": 0.07493}, "CVE-2023-52432": {"epss_score": 0.0006, "epss_percentile": 0.19002}, "CVE-2023-52433": {"epss_score": 0.00017, "epss_percentile": 0.03219}, "CVE-2023-52434": {"epss_score": 0.00017, "epss_percentile": 0.03244}, "CVE-2023-52435": {"epss_score": 0.00017, "epss_percentile": 0.03188}, "CVE-2023-52436": {"epss_score": 0.00013, "epss_percentile": 0.01694}, "CVE-2023-52438": {"epss_score": 0.00014, "epss_percentile": 0.01969}, "CVE-2023-52439": {"epss_score": 0.00012, "epss_percentile": 0.01162}, "CVE-2023-52440": {"epss_score": 0.00464, "epss_percentile": 0.63727}, "CVE-2023-52441": {"epss_score": 0.00023, "epss_percentile": 0.05476}, "CVE-2023-52442": {"epss_score": 0.00338, "epss_percentile": 0.56155}, "CVE-2023-52443": {"epss_score": 0.00019, "epss_percentile": 0.0421}, "CVE-2023-52444": {"epss_score": 0.00014, "epss_percentile": 0.02102}, "CVE-2023-52445": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2023-52446": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2023-52447": {"epss_score": 0.00013, "epss_percentile": 0.01541}, "CVE-2023-52448": {"epss_score": 9e-05, "epss_percentile": 0.00597}, "CVE-2023-52449": {"epss_score": 0.0002, "epss_percentile": 0.04526}, "CVE-2023-52450": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2023-52451": {"epss_score": 0.00011, "epss_percentile": 0.00983}, "CVE-2023-52452": {"epss_score": 0.00013, "epss_percentile": 0.01511}, "CVE-2023-52453": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2023-52454": {"epss_score": 0.00023, "epss_percentile": 0.05376}, "CVE-2023-52455": {"epss_score": 0.0002, "epss_percentile": 0.04609}, "CVE-2023-52456": {"epss_score": 0.0001, "epss_percentile": 0.00832}, "CVE-2023-52457": {"epss_score": 0.00013, "epss_percentile": 0.01711}, "CVE-2023-52458": {"epss_score": 0.00014, "epss_percentile": 0.01872}, "CVE-2023-52459": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2023-52460": {"epss_score": 0.00017, "epss_percentile": 0.03352}, "CVE-2023-52461": {"epss_score": 0.00044, "epss_percentile": 0.13393}, "CVE-2023-52462": {"epss_score": 0.00021, "epss_percentile": 0.0489}, "CVE-2023-52463": {"epss_score": 9e-05, "epss_percentile": 0.00649}, "CVE-2023-52464": {"epss_score": 0.0001, "epss_percentile": 0.00828}, "CVE-2023-52465": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2023-52467": {"epss_score": 0.00029, "epss_percentile": 0.07829}, "CVE-2023-52468": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2023-52469": {"epss_score": 0.00011, "epss_percentile": 0.00983}, "CVE-2023-52470": {"epss_score": 0.00013, "epss_percentile": 0.01596}, "CVE-2023-52471": {"epss_score": 9e-05, "epss_percentile": 0.006}, "CVE-2023-52472": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2023-52473": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2023-52474": {"epss_score": 0.00016, "epss_percentile": 0.02833}, "CVE-2023-52475": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2023-52476": {"epss_score": 8e-05, "epss_percentile": 0.00571}, "CVE-2023-52477": {"epss_score": 7e-05, "epss_percentile": 0.00375}, "CVE-2023-52478": {"epss_score": 5e-05, "epss_percentile": 0.00236}, "CVE-2023-52479": {"epss_score": 0.00018, "epss_percentile": 0.03943}, "CVE-2023-52480": {"epss_score": 0.0001, "epss_percentile": 0.00827}, "CVE-2023-52481": {"epss_score": 0.00052, "epss_percentile": 0.16609}, "CVE-2023-52482": {"epss_score": 0.00015, "epss_percentile": 0.02219}, "CVE-2023-52483": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2023-52484": {"epss_score": 0.00012, "epss_percentile": 0.01249}, "CVE-2023-52485": {"epss_score": 0.00015, "epss_percentile": 0.02519}, "CVE-2023-52486": {"epss_score": 6e-05, "epss_percentile": 0.00273}, "CVE-2023-52487": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2023-52488": {"epss_score": 0.00013, "epss_percentile": 0.01517}, "CVE-2023-52489": {"epss_score": 6e-05, "epss_percentile": 0.00308}, "CVE-2023-52490": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2023-52491": {"epss_score": 0.00016, "epss_percentile": 0.02833}, "CVE-2023-52492": {"epss_score": 6e-05, "epss_percentile": 0.00315}, "CVE-2023-52493": {"epss_score": 0.0001, "epss_percentile": 0.0075}, "CVE-2023-52494": {"epss_score": 0.00033, "epss_percentile": 0.09372}, "CVE-2023-52495": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2023-52497": {"epss_score": 0.00016, "epss_percentile": 0.02759}, "CVE-2023-52498": {"epss_score": 9e-05, "epss_percentile": 0.00643}, "CVE-2023-52499": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2023-52500": {"epss_score": 0.0001, "epss_percentile": 0.00835}, "CVE-2023-52501": {"epss_score": 0.00054, "epss_percentile": 0.17116}, "CVE-2023-52502": {"epss_score": 6e-05, "epss_percentile": 0.00308}, "CVE-2023-52503": {"epss_score": 0.00029, "epss_percentile": 0.07786}, "CVE-2023-52504": {"epss_score": 8e-05, "epss_percentile": 0.00539}, "CVE-2023-52505": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2023-52506": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2023-52507": {"epss_score": 7e-05, "epss_percentile": 0.00382}, "CVE-2023-52508": {"epss_score": 9e-05, "epss_percentile": 0.00662}, "CVE-2023-52509": {"epss_score": 0.00013, "epss_percentile": 0.01534}, "CVE-2023-52510": {"epss_score": 0.00015, "epss_percentile": 0.0253}, "CVE-2023-52511": {"epss_score": 0.00044, "epss_percentile": 0.1355}, "CVE-2023-52512": {"epss_score": 0.00018, "epss_percentile": 0.03652}, "CVE-2023-52513": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2023-52515": {"epss_score": 0.00022, "epss_percentile": 0.04999}, "CVE-2023-52516": {"epss_score": 0.00015, "epss_percentile": 0.0215}, "CVE-2023-52517": {"epss_score": 0.00012, "epss_percentile": 0.01393}, "CVE-2023-52518": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2023-52519": {"epss_score": 0.00016, "epss_percentile": 0.0267}, "CVE-2023-52520": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2023-52522": {"epss_score": 7e-05, "epss_percentile": 0.00346}, "CVE-2023-52523": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2023-52524": {"epss_score": 0.00011, "epss_percentile": 0.00917}, "CVE-2023-52525": {"epss_score": 0.00012, "epss_percentile": 0.0122}, "CVE-2023-52526": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2023-52527": {"epss_score": 0.00012, "epss_percentile": 0.01177}, "CVE-2023-52528": {"epss_score": 7e-05, "epss_percentile": 0.00375}, "CVE-2023-52529": {"epss_score": 0.00014, "epss_percentile": 0.0186}, "CVE-2023-52530": {"epss_score": 0.00013, "epss_percentile": 0.0171}, "CVE-2023-52531": {"epss_score": 0.00014, "epss_percentile": 0.02032}, "CVE-2023-52532": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2023-52533": {"epss_score": 0.00883, "epss_percentile": 0.74913}, "CVE-2023-52534": {"epss_score": 0.01482, "epss_percentile": 0.80574}, "CVE-2023-52535": {"epss_score": 0.0002, "epss_percentile": 0.04533}, "CVE-2023-52536": {"epss_score": 0.00011, "epss_percentile": 0.01048}, "CVE-2023-52537": {"epss_score": 0.00031, "epss_percentile": 0.08653}, "CVE-2023-52538": {"epss_score": 0.00014, "epss_percentile": 0.02031}, "CVE-2023-52539": {"epss_score": 0.00069, "epss_percentile": 0.21533}, "CVE-2023-52540": {"epss_score": 0.00075, "epss_percentile": 0.23059}, "CVE-2023-52541": {"epss_score": 0.0007, "epss_percentile": 0.21708}, "CVE-2023-52542": {"epss_score": 0.00049, "epss_percentile": 0.15546}, "CVE-2023-52543": {"epss_score": 0.00018, "epss_percentile": 0.03863}, "CVE-2023-52544": {"epss_score": 0.0008, "epss_percentile": 0.24186}, "CVE-2023-52545": {"epss_score": 0.00054, "epss_percentile": 0.1729}, "CVE-2023-52546": {"epss_score": 0.0002, "epss_percentile": 0.04462}, "CVE-2023-52547": {"epss_score": 0.00026, "epss_percentile": 0.06574}, "CVE-2023-52548": {"epss_score": 0.00038, "epss_percentile": 0.11197}, "CVE-2023-52549": {"epss_score": 0.00081, "epss_percentile": 0.24227}, "CVE-2023-52550": {"epss_score": 0.00081, "epss_percentile": 0.24227}, "CVE-2023-52551": {"epss_score": 0.00022, "epss_percentile": 0.05161}, "CVE-2023-52552": {"epss_score": 0.00072, "epss_percentile": 0.22358}, "CVE-2023-52553": {"epss_score": 0.00057, "epss_percentile": 0.17966}, "CVE-2023-52554": {"epss_score": 0.00033, "epss_percentile": 0.09341}, "CVE-2023-52555": {"epss_score": 0.00933, "epss_percentile": 0.75643}, "CVE-2023-52556": {"epss_score": 0.00019, "epss_percentile": 0.04067}, "CVE-2023-52557": {"epss_score": 0.00065, "epss_percentile": 0.2062}, "CVE-2023-52558": {"epss_score": 0.00072, "epss_percentile": 0.22466}, "CVE-2023-52559": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2023-52560": {"epss_score": 8e-05, "epss_percentile": 0.00561}, "CVE-2023-52561": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2023-52562": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2023-52563": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2023-52564": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2023-52565": {"epss_score": 9e-05, "epss_percentile": 0.0071}, "CVE-2023-52566": {"epss_score": 0.00012, "epss_percentile": 0.01144}, "CVE-2023-52567": {"epss_score": 0.00012, "epss_percentile": 0.01177}, "CVE-2023-52568": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2023-52569": {"epss_score": 5e-05, "epss_percentile": 0.00175}, "CVE-2023-52570": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2023-52571": {"epss_score": 0.00018, "epss_percentile": 0.04029}, "CVE-2023-52572": {"epss_score": 0.00013, "epss_percentile": 0.01534}, "CVE-2023-52573": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2023-52574": {"epss_score": 6e-05, "epss_percentile": 0.00319}, "CVE-2023-52576": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2023-52577": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2023-52578": {"epss_score": 9e-05, "epss_percentile": 0.00715}, "CVE-2023-52580": {"epss_score": 8e-05, "epss_percentile": 0.00571}, "CVE-2023-52581": {"epss_score": 9e-05, "epss_percentile": 0.00614}, "CVE-2023-52582": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2023-52583": {"epss_score": 0.00011, "epss_percentile": 0.01034}, "CVE-2023-52584": {"epss_score": 0.00048, "epss_percentile": 0.1499}, "CVE-2023-52585": {"epss_score": 0.00013, "epss_percentile": 0.01566}, "CVE-2023-52586": {"epss_score": 0.0001, "epss_percentile": 0.0088}, "CVE-2023-52587": {"epss_score": 6e-05, "epss_percentile": 0.00319}, "CVE-2023-52588": {"epss_score": 0.00017, "epss_percentile": 0.03167}, "CVE-2023-52589": {"epss_score": 0.00011, "epss_percentile": 0.00984}, "CVE-2023-52590": {"epss_score": 7e-05, "epss_percentile": 0.00432}, "CVE-2023-52591": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2023-52593": {"epss_score": 0.00015, "epss_percentile": 0.02322}, "CVE-2023-52594": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2023-52595": {"epss_score": 0.0001, "epss_percentile": 0.00891}, "CVE-2023-52596": {"epss_score": 0.0001, "epss_percentile": 0.00915}, "CVE-2023-52597": {"epss_score": 0.00022, "epss_percentile": 0.05289}, "CVE-2023-52598": {"epss_score": 7e-05, "epss_percentile": 0.00456}, "CVE-2023-52599": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2023-52600": {"epss_score": 0.00014, "epss_percentile": 0.02077}, "CVE-2023-52601": {"epss_score": 0.00012, "epss_percentile": 0.01319}, "CVE-2023-52602": {"epss_score": 0.00015, "epss_percentile": 0.02466}, "CVE-2023-52603": {"epss_score": 0.00017, "epss_percentile": 0.0317}, "CVE-2023-52604": {"epss_score": 0.00015, "epss_percentile": 0.0213}, "CVE-2023-52606": {"epss_score": 0.00014, "epss_percentile": 0.02016}, "CVE-2023-52607": {"epss_score": 0.00019, "epss_percentile": 0.0418}, "CVE-2023-52608": {"epss_score": 7e-05, "epss_percentile": 0.00438}, "CVE-2023-52609": {"epss_score": 0.00011, "epss_percentile": 0.01034}, "CVE-2023-52610": {"epss_score": 9e-05, "epss_percentile": 0.00629}, "CVE-2023-52611": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2023-52612": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2023-52613": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2023-52614": {"epss_score": 0.00012, "epss_percentile": 0.01226}, "CVE-2023-52615": {"epss_score": 6e-05, "epss_percentile": 0.00246}, "CVE-2023-52616": {"epss_score": 0.00024, "epss_percentile": 0.05738}, "CVE-2023-52617": {"epss_score": 0.0002, "epss_percentile": 0.0454}, "CVE-2023-52618": {"epss_score": 0.00061, "epss_percentile": 0.19289}, "CVE-2023-52619": {"epss_score": 0.00014, "epss_percentile": 0.02016}, "CVE-2023-52620": {"epss_score": 9e-05, "epss_percentile": 0.0073}, "CVE-2023-52621": {"epss_score": 5e-05, "epss_percentile": 0.00213}, "CVE-2023-52622": {"epss_score": 0.00014, "epss_percentile": 0.02016}, "CVE-2023-52623": {"epss_score": 0.00013, "epss_percentile": 0.01665}, "CVE-2023-52624": {"epss_score": 0.00014, "epss_percentile": 0.01898}, "CVE-2023-52625": {"epss_score": 0.0001, "epss_percentile": 0.00846}, "CVE-2023-52626": {"epss_score": 0.00071, "epss_percentile": 0.22225}, "CVE-2023-52627": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2023-52628": {"epss_score": 7e-05, "epss_percentile": 0.00382}, "CVE-2023-52629": {"epss_score": 0.0002, "epss_percentile": 0.04613}, "CVE-2023-52631": {"epss_score": 0.00031, "epss_percentile": 0.0853}, "CVE-2023-52632": {"epss_score": 0.00013, "epss_percentile": 0.01483}, "CVE-2023-52633": {"epss_score": 0.00022, "epss_percentile": 0.04951}, "CVE-2023-52634": {"epss_score": 9e-05, "epss_percentile": 0.0072}, "CVE-2023-52635": {"epss_score": 6e-05, "epss_percentile": 0.00315}, "CVE-2023-52636": {"epss_score": 0.00017, "epss_percentile": 0.03349}, "CVE-2023-52637": {"epss_score": 0.00015, "epss_percentile": 0.02486}, "CVE-2023-52638": {"epss_score": 0.0001, "epss_percentile": 0.00787}, "CVE-2023-52639": {"epss_score": 0.00012, "epss_percentile": 0.01173}, "CVE-2023-52640": {"epss_score": 0.00029, "epss_percentile": 0.07627}, "CVE-2023-52641": {"epss_score": 0.00031, "epss_percentile": 0.0853}, "CVE-2023-52642": {"epss_score": 0.00013, "epss_percentile": 0.01706}, "CVE-2023-52643": {"epss_score": 9e-05, "epss_percentile": 0.00742}, "CVE-2023-52644": {"epss_score": 5e-05, "epss_percentile": 0.00214}, "CVE-2023-52645": {"epss_score": 0.00012, "epss_percentile": 0.01387}, "CVE-2023-52646": {"epss_score": 8e-05, "epss_percentile": 0.0059}, "CVE-2023-52647": {"epss_score": 0.00041, "epss_percentile": 0.12347}, "CVE-2023-52648": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2023-52649": {"epss_score": 0.00022, "epss_percentile": 0.05003}, "CVE-2023-52650": {"epss_score": 0.00011, "epss_percentile": 0.01011}, "CVE-2023-52652": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2023-52653": {"epss_score": 9e-05, "epss_percentile": 0.00657}, "CVE-2023-52654": {"epss_score": 0.00106, "epss_percentile": 0.29468}, "CVE-2023-52655": {"epss_score": 8e-05, "epss_percentile": 0.00582}, "CVE-2023-52656": {"epss_score": 8e-05, "epss_percentile": 0.00466}, "CVE-2023-52657": {"epss_score": 0.00036, "epss_percentile": 0.10605}, "CVE-2023-52658": {"epss_score": 8e-05, "epss_percentile": 0.00571}, "CVE-2023-52659": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2023-52660": {"epss_score": 0.00033, "epss_percentile": 0.09174}, "CVE-2023-52661": {"epss_score": 0.00014, "epss_percentile": 0.02023}, "CVE-2023-52662": {"epss_score": 7e-05, "epss_percentile": 0.0041}, "CVE-2023-52663": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2023-52664": {"epss_score": 0.00026, "epss_percentile": 0.06407}, "CVE-2023-52667": {"epss_score": 0.0013, "epss_percentile": 0.33335}, "CVE-2023-52668": {"epss_score": 0.00012, "epss_percentile": 0.01237}, "CVE-2023-52669": {"epss_score": 0.00013, "epss_percentile": 0.01534}, "CVE-2023-52670": {"epss_score": 0.00011, "epss_percentile": 0.01063}, "CVE-2023-52671": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2023-52672": {"epss_score": 7e-05, "epss_percentile": 0.00432}, "CVE-2023-52673": {"epss_score": 0.0002, "epss_percentile": 0.04536}, "CVE-2023-52674": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2023-52675": {"epss_score": 0.00021, "epss_percentile": 0.04934}, "CVE-2023-52676": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2023-52677": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2023-52678": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2023-52679": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2023-52680": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2023-52681": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2023-52682": {"epss_score": 0.00018, "epss_percentile": 0.03943}, "CVE-2023-52683": {"epss_score": 0.00013, "epss_percentile": 0.01596}, "CVE-2023-52684": {"epss_score": 0.0002, "epss_percentile": 0.04466}, "CVE-2023-52686": {"epss_score": 0.00014, "epss_percentile": 0.01969}, "CVE-2023-52687": {"epss_score": 0.00015, "epss_percentile": 0.02438}, "CVE-2023-52688": {"epss_score": 0.00015, "epss_percentile": 0.0229}, "CVE-2023-52689": {"epss_score": 0.00013, "epss_percentile": 0.01633}, "CVE-2023-52690": {"epss_score": 0.00036, "epss_percentile": 0.10275}, "CVE-2023-52691": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2023-52692": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2023-52693": {"epss_score": 0.0002, "epss_percentile": 0.04526}, "CVE-2023-52694": {"epss_score": 0.00026, "epss_percentile": 0.06446}, "CVE-2023-52695": {"epss_score": 0.00026, "epss_percentile": 0.0654}, "CVE-2023-52696": {"epss_score": 0.00282, "epss_percentile": 0.51267}, "CVE-2023-52697": {"epss_score": 0.00028, "epss_percentile": 0.07522}, "CVE-2023-52698": {"epss_score": 0.00027, "epss_percentile": 0.06878}, "CVE-2023-52699": {"epss_score": 0.00083, "epss_percentile": 0.24805}, "CVE-2023-52700": {"epss_score": 0.00013, "epss_percentile": 0.0151}, "CVE-2023-52701": {"epss_score": 0.00086, "epss_percentile": 0.25284}, "CVE-2023-52702": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2023-52703": {"epss_score": 7e-05, "epss_percentile": 0.00346}, "CVE-2023-52704": {"epss_score": 0.00083, "epss_percentile": 0.24614}, "CVE-2023-52705": {"epss_score": 0.00015, "epss_percentile": 0.0237}, "CVE-2023-52706": {"epss_score": 0.00107, "epss_percentile": 0.29649}, "CVE-2023-52707": {"epss_score": 0.00017, "epss_percentile": 0.03417}, "CVE-2023-52708": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2023-52710": {"epss_score": 0.00048, "epss_percentile": 0.14984}, "CVE-2023-52711": {"epss_score": 8e-05, "epss_percentile": 0.00488}, "CVE-2023-52712": {"epss_score": 8e-05, "epss_percentile": 0.00488}, "CVE-2023-52713": {"epss_score": 0.0003, "epss_percentile": 0.07987}, "CVE-2023-52714": {"epss_score": 0.00087, "epss_percentile": 0.25581}, "CVE-2023-52715": {"epss_score": 0.00094, "epss_percentile": 0.26803}, "CVE-2023-52716": {"epss_score": 0.00072, "epss_percentile": 0.22313}, "CVE-2023-52717": {"epss_score": 0.00085, "epss_percentile": 0.25239}, "CVE-2023-52718": {"epss_score": 0.0004, "epss_percentile": 0.12081}, "CVE-2023-52719": {"epss_score": 0.0006, "epss_percentile": 0.1914}, "CVE-2023-52720": {"epss_score": 0.00019, "epss_percentile": 0.04084}, "CVE-2023-52721": {"epss_score": 0.00053, "epss_percentile": 0.16716}, "CVE-2023-52722": {"epss_score": 0.0006, "epss_percentile": 0.18958}, "CVE-2023-52723": {"epss_score": 0.0008, "epss_percentile": 0.24125}, "CVE-2023-52724": {"epss_score": 0.00198, "epss_percentile": 0.42077}, "CVE-2023-52725": {"epss_score": 0.00097, "epss_percentile": 0.27596}, "CVE-2023-52726": {"epss_score": 0.00098, "epss_percentile": 0.27786}, "CVE-2023-52727": {"epss_score": 0.00176, "epss_percentile": 0.39388}, "CVE-2023-52728": {"epss_score": 0.0005, "epss_percentile": 0.15829}, "CVE-2023-52729": {"epss_score": 0.00018, "epss_percentile": 0.04016}, "CVE-2023-52730": {"epss_score": 7e-05, "epss_percentile": 0.0041}, "CVE-2023-52731": {"epss_score": 0.00125, "epss_percentile": 0.32602}, "CVE-2023-52732": {"epss_score": 0.0001, "epss_percentile": 0.00823}, "CVE-2023-52735": {"epss_score": 0.00048, "epss_percentile": 0.15108}, "CVE-2023-52736": {"epss_score": 0.00019, "epss_percentile": 0.04148}, "CVE-2023-52737": {"epss_score": 8e-05, "epss_percentile": 0.00587}, "CVE-2023-52738": {"epss_score": 0.00303, "epss_percentile": 0.53222}, "CVE-2023-52739": {"epss_score": 0.00018, "epss_percentile": 0.03652}, "CVE-2023-52740": {"epss_score": 0.00072, "epss_percentile": 0.22452}, "CVE-2023-52741": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2023-52742": {"epss_score": 4e-05, "epss_percentile": 0.00164}, "CVE-2023-52743": {"epss_score": 5e-05, "epss_percentile": 0.00183}, "CVE-2023-52744": {"epss_score": 0.00094, "epss_percentile": 0.26766}, "CVE-2023-52745": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2023-52746": {"epss_score": 0.00017, "epss_percentile": 0.03105}, "CVE-2023-52747": {"epss_score": 0.00014, "epss_percentile": 0.01984}, "CVE-2023-52748": {"epss_score": 0.00017, "epss_percentile": 0.03248}, "CVE-2023-52749": {"epss_score": 0.0001, "epss_percentile": 0.00779}, "CVE-2023-52750": {"epss_score": 0.00015, "epss_percentile": 0.0237}, "CVE-2023-52751": {"epss_score": 0.00015, "epss_percentile": 0.0234}, "CVE-2023-52752": {"epss_score": 0.00013, "epss_percentile": 0.01534}, "CVE-2023-52753": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2023-52754": {"epss_score": 0.00017, "epss_percentile": 0.03115}, "CVE-2023-52755": {"epss_score": 0.00677, "epss_percentile": 0.7097}, "CVE-2023-52757": {"epss_score": 0.0001, "epss_percentile": 0.00838}, "CVE-2023-52760": {"epss_score": 0.00016, "epss_percentile": 0.02739}, "CVE-2023-52761": {"epss_score": 0.00115, "epss_percentile": 0.30982}, "CVE-2023-52762": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2023-52763": {"epss_score": 0.00022, "epss_percentile": 0.05146}, "CVE-2023-52764": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2023-52765": {"epss_score": 0.00093, "epss_percentile": 0.26753}, "CVE-2023-52766": {"epss_score": 0.00031, "epss_percentile": 0.08624}, "CVE-2023-52767": {"epss_score": 0.0008, "epss_percentile": 0.24187}, "CVE-2023-52768": {"epss_score": 0.00161, "epss_percentile": 0.37608}, "CVE-2023-52769": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2023-52770": {"epss_score": 0.00121, "epss_percentile": 0.3192}, "CVE-2023-52771": {"epss_score": 9e-05, "epss_percentile": 0.00714}, "CVE-2023-52772": {"epss_score": 0.00026, "epss_percentile": 0.06388}, "CVE-2023-52773": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2023-52774": {"epss_score": 8e-05, "epss_percentile": 0.00545}, "CVE-2023-52775": {"epss_score": 0.00031, "epss_percentile": 0.08409}, "CVE-2023-52776": {"epss_score": 0.00059, "epss_percentile": 0.18779}, "CVE-2023-52777": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2023-52778": {"epss_score": 0.00062, "epss_percentile": 0.19611}, "CVE-2023-52779": {"epss_score": 0.00083, "epss_percentile": 0.24614}, "CVE-2023-52780": {"epss_score": 0.00094, "epss_percentile": 0.26766}, "CVE-2023-52781": {"epss_score": 5e-05, "epss_percentile": 0.00206}, "CVE-2023-52782": {"epss_score": 0.00094, "epss_percentile": 0.26766}, "CVE-2023-52783": {"epss_score": 0.0002, "epss_percentile": 0.04536}, "CVE-2023-52784": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2023-52785": {"epss_score": 0.00094, "epss_percentile": 0.26786}, "CVE-2023-52786": {"epss_score": 0.00015, "epss_percentile": 0.0217}, "CVE-2023-52787": {"epss_score": 0.00018, "epss_percentile": 0.03727}, "CVE-2023-52788": {"epss_score": 0.0002, "epss_percentile": 0.04447}, "CVE-2023-52789": {"epss_score": 0.0001, "epss_percentile": 0.00855}, "CVE-2023-52790": {"epss_score": 0.00083, "epss_percentile": 0.24614}, "CVE-2023-52791": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2023-52792": {"epss_score": 0.00094, "epss_percentile": 0.26766}, "CVE-2023-52794": {"epss_score": 0.00097, "epss_percentile": 0.27522}, "CVE-2023-52795": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2023-52796": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2023-52797": {"epss_score": 0.00113, "epss_percentile": 0.30604}, "CVE-2023-52798": {"epss_score": 0.00055, "epss_percentile": 0.17449}, "CVE-2023-52799": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2023-52800": {"epss_score": 6e-05, "epss_percentile": 0.00309}, "CVE-2023-52801": {"epss_score": 0.00049, "epss_percentile": 0.15575}, "CVE-2023-52803": {"epss_score": 7e-05, "epss_percentile": 0.00366}, "CVE-2023-52804": {"epss_score": 0.00014, "epss_percentile": 0.0185}, "CVE-2023-52805": {"epss_score": 0.00017, "epss_percentile": 0.03338}, "CVE-2023-52806": {"epss_score": 0.00013, "epss_percentile": 0.0155}, "CVE-2023-52807": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2023-52808": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2023-52809": {"epss_score": 7e-05, "epss_percentile": 0.00362}, "CVE-2023-52810": {"epss_score": 0.00017, "epss_percentile": 0.03333}, "CVE-2023-52811": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2023-52812": {"epss_score": 0.00012, "epss_percentile": 0.01195}, "CVE-2023-52813": {"epss_score": 0.00011, "epss_percentile": 0.01018}, "CVE-2023-52814": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2023-52815": {"epss_score": 0.00022, "epss_percentile": 0.05146}, "CVE-2023-52816": {"epss_score": 0.00041, "epss_percentile": 0.12262}, "CVE-2023-52817": {"epss_score": 7e-05, "epss_percentile": 0.00375}, "CVE-2023-52818": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2023-52819": {"epss_score": 0.00017, "epss_percentile": 0.03089}, "CVE-2023-52821": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2023-52825": {"epss_score": 0.00015, "epss_percentile": 0.0215}, "CVE-2023-52826": {"epss_score": 0.00015, "epss_percentile": 0.0237}, "CVE-2023-52827": {"epss_score": 0.00021, "epss_percentile": 0.0481}, "CVE-2023-52828": {"epss_score": 0.00017, "epss_percentile": 0.03171}, "CVE-2023-52829": {"epss_score": 0.00093, "epss_percentile": 0.26753}, "CVE-2023-52831": {"epss_score": 5e-05, "epss_percentile": 0.00178}, "CVE-2023-52832": {"epss_score": 0.00071, "epss_percentile": 0.22043}, "CVE-2023-52833": {"epss_score": 0.00032, "epss_percentile": 0.08751}, "CVE-2023-52834": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2023-52835": {"epss_score": 0.00011, "epss_percentile": 0.01095}, "CVE-2023-52836": {"epss_score": 0.00014, "epss_percentile": 0.0185}, "CVE-2023-52837": {"epss_score": 0.00015, "epss_percentile": 0.0234}, "CVE-2023-52838": {"epss_score": 0.00016, "epss_percentile": 0.02812}, "CVE-2023-52839": {"epss_score": 0.00017, "epss_percentile": 0.03494}, "CVE-2023-52840": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2023-52841": {"epss_score": 0.00014, "epss_percentile": 0.02023}, "CVE-2023-52842": {"epss_score": 0.00018, "epss_percentile": 0.04029}, "CVE-2023-52843": {"epss_score": 9e-05, "epss_percentile": 0.00613}, "CVE-2023-52844": {"epss_score": 8e-05, "epss_percentile": 0.00586}, "CVE-2023-52845": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2023-52846": {"epss_score": 0.00013, "epss_percentile": 0.01534}, "CVE-2023-52847": {"epss_score": 0.0001, "epss_percentile": 0.00766}, "CVE-2023-52848": {"epss_score": 0.00021, "epss_percentile": 0.04859}, "CVE-2023-52849": {"epss_score": 0.00022, "epss_percentile": 0.05146}, "CVE-2023-52850": {"epss_score": 0.00041, "epss_percentile": 0.12347}, "CVE-2023-52851": {"epss_score": 0.00022, "epss_percentile": 0.05003}, "CVE-2023-52852": {"epss_score": 0.00023, "epss_percentile": 0.05447}, "CVE-2023-52853": {"epss_score": 8e-05, "epss_percentile": 0.00538}, "CVE-2023-52854": {"epss_score": 0.00013, "epss_percentile": 0.01534}, "CVE-2023-52855": {"epss_score": 0.00013, "epss_percentile": 0.01594}, "CVE-2023-52856": {"epss_score": 0.00041, "epss_percentile": 0.12428}, "CVE-2023-52857": {"epss_score": 0.00016, "epss_percentile": 0.02934}, "CVE-2023-52858": {"epss_score": 8e-05, "epss_percentile": 0.00586}, "CVE-2023-52859": {"epss_score": 0.00017, "epss_percentile": 0.03417}, "CVE-2023-52860": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2023-52861": {"epss_score": 0.00019, "epss_percentile": 0.0418}, "CVE-2023-52862": {"epss_score": 0.00019, "epss_percentile": 0.04077}, "CVE-2023-52863": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2023-52864": {"epss_score": 0.0001, "epss_percentile": 0.00843}, "CVE-2023-52865": {"epss_score": 9e-05, "epss_percentile": 0.00613}, "CVE-2023-52866": {"epss_score": 0.00034, "epss_percentile": 0.09453}, "CVE-2023-52867": {"epss_score": 0.00025, "epss_percentile": 0.06261}, "CVE-2023-52868": {"epss_score": 0.00025, "epss_percentile": 0.06219}, "CVE-2023-52869": {"epss_score": 0.00015, "epss_percentile": 0.02506}, "CVE-2023-52870": {"epss_score": 0.00013, "epss_percentile": 0.01719}, "CVE-2023-52871": {"epss_score": 0.00032, "epss_percentile": 0.08817}, "CVE-2023-52872": {"epss_score": 0.00026, "epss_percentile": 0.06672}, "CVE-2023-52873": {"epss_score": 0.00026, "epss_percentile": 0.06588}, "CVE-2023-52874": {"epss_score": 0.00077, "epss_percentile": 0.23446}, "CVE-2023-52875": {"epss_score": 0.00016, "epss_percentile": 0.02654}, "CVE-2023-52876": {"epss_score": 0.00049, "epss_percentile": 0.15624}, "CVE-2023-52877": {"epss_score": 0.00016, "epss_percentile": 0.02652}, "CVE-2023-52878": {"epss_score": 0.00016, "epss_percentile": 0.02744}, "CVE-2023-52879": {"epss_score": 0.00026, "epss_percentile": 0.06588}, "CVE-2023-52880": {"epss_score": 0.00012, "epss_percentile": 0.01422}, "CVE-2023-52881": {"epss_score": 0.00012, "epss_percentile": 0.01131}, "CVE-2023-52882": {"epss_score": 0.00068, "epss_percentile": 0.21336}, "CVE-2023-52883": {"epss_score": 0.00089, "epss_percentile": 0.25956}, "CVE-2023-52884": {"epss_score": 7e-05, "epss_percentile": 0.00323}, "CVE-2023-52885": {"epss_score": 0.00022, "epss_percentile": 0.05286}, "CVE-2023-52886": {"epss_score": 0.0005, "epss_percentile": 0.15888}, "CVE-2023-52887": {"epss_score": 4e-05, "epss_percentile": 0.00129}, "CVE-2023-52888": {"epss_score": 9e-05, "epss_percentile": 0.00648}, "CVE-2023-52889": {"epss_score": 0.00014, "epss_percentile": 0.02016}, "CVE-2023-52890": {"epss_score": 0.00062, "epss_percentile": 0.19713}, "CVE-2023-52891": {"epss_score": 0.00116, "epss_percentile": 0.31148}, "CVE-2023-52892": {"epss_score": 0.00183, "epss_percentile": 0.40314}, "CVE-2023-52893": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2023-52894": {"epss_score": 0.00011, "epss_percentile": 0.01058}, "CVE-2023-52895": {"epss_score": 0.00037, "epss_percentile": 0.10658}, "CVE-2023-52896": {"epss_score": 0.00016, "epss_percentile": 0.02735}, "CVE-2023-52897": {"epss_score": 0.00018, "epss_percentile": 0.03657}, "CVE-2023-52898": {"epss_score": 7e-05, "epss_percentile": 0.00342}, "CVE-2023-52899": {"epss_score": 0.00011, "epss_percentile": 0.01058}, "CVE-2023-52900": {"epss_score": 0.00011, "epss_percentile": 0.01058}, "CVE-2023-52901": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2023-52902": {"epss_score": 0.00026, "epss_percentile": 0.06714}, "CVE-2023-52903": {"epss_score": 8e-05, "epss_percentile": 0.00481}, "CVE-2023-52904": {"epss_score": 8e-05, "epss_percentile": 0.00578}, "CVE-2023-52905": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2023-52906": {"epss_score": 0.00022, "epss_percentile": 0.05153}, "CVE-2023-52907": {"epss_score": 0.00012, "epss_percentile": 0.01288}, "CVE-2023-52908": {"epss_score": 0.00022, "epss_percentile": 0.05175}, "CVE-2023-52909": {"epss_score": 0.00022, "epss_percentile": 0.05059}, "CVE-2023-52910": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2023-52911": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2023-52912": {"epss_score": 0.0002, "epss_percentile": 0.04604}, "CVE-2023-52913": {"epss_score": 9e-05, "epss_percentile": 0.00648}, "CVE-2023-52914": {"epss_score": 0.00035, "epss_percentile": 0.09937}, "CVE-2023-52915": {"epss_score": 0.00011, "epss_percentile": 0.01106}, "CVE-2023-52916": {"epss_score": 0.00023, "epss_percentile": 0.05516}, "CVE-2023-52918": {"epss_score": 0.00012, "epss_percentile": 0.01209}, "CVE-2023-52919": {"epss_score": 0.00013, "epss_percentile": 0.01525}, "CVE-2023-52920": {"epss_score": 0.00015, "epss_percentile": 0.02169}, "CVE-2023-52921": {"epss_score": 0.00013, "epss_percentile": 0.01604}, "CVE-2023-52922": {"epss_score": 0.00014, "epss_percentile": 0.01785}, "CVE-2023-52923": {"epss_score": 0.00056, "epss_percentile": 0.17704}, "CVE-2023-52924": {"epss_score": 0.00056, "epss_percentile": 0.17704}, "CVE-2023-52925": {"epss_score": 0.00038, "epss_percentile": 0.11107}, "CVE-2023-52926": {"epss_score": 0.00016, "epss_percentile": 0.02658}, "CVE-2023-52927": {"epss_score": 0.00043, "epss_percentile": 0.1303}, "CVE-2023-52928": {"epss_score": 0.00016, "epss_percentile": 0.0295}, "CVE-2023-52929": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2023-52930": {"epss_score": 0.00076, "epss_percentile": 0.23166}, "CVE-2023-52931": {"epss_score": 0.00026, "epss_percentile": 0.06432}, "CVE-2023-52932": {"epss_score": 0.00017, "epss_percentile": 0.03166}, "CVE-2023-52933": {"epss_score": 0.00034, "epss_percentile": 0.0966}, "CVE-2023-52934": {"epss_score": 0.00017, "epss_percentile": 0.03316}, "CVE-2023-52935": {"epss_score": 0.00023, "epss_percentile": 0.05513}, "CVE-2023-52936": {"epss_score": 0.00017, "epss_percentile": 0.03169}, "CVE-2023-52937": {"epss_score": 0.00029, "epss_percentile": 0.07818}, "CVE-2023-52938": {"epss_score": 0.00024, "epss_percentile": 0.06003}, "CVE-2023-52939": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2023-52940": {"epss_score": 0.00024, "epss_percentile": 0.06003}, "CVE-2023-52941": {"epss_score": 0.00024, "epss_percentile": 0.06003}, "CVE-2023-52942": {"epss_score": 0.00024, "epss_percentile": 0.06003}, "CVE-2023-52943": {"epss_score": 0.00079, "epss_percentile": 0.2385}, "CVE-2023-52944": {"epss_score": 0.00079, "epss_percentile": 0.2385}, "CVE-2023-52946": {"epss_score": 0.02434, "epss_percentile": 0.84733}, "CVE-2023-52947": {"epss_score": 0.00152, "epss_percentile": 0.36408}, "CVE-2023-52948": {"epss_score": 0.00029, "epss_percentile": 0.0776}, "CVE-2023-52949": {"epss_score": 0.00066, "epss_percentile": 0.20761}, "CVE-2023-52950": {"epss_score": 0.00041, "epss_percentile": 0.12379}, "CVE-2023-52952": {"epss_score": 0.00067, "epss_percentile": 0.21124}, "CVE-2023-52953": {"epss_score": 0.0008, "epss_percentile": 0.24051}, "CVE-2023-52954": {"epss_score": 0.0003, "epss_percentile": 0.08182}, "CVE-2023-52955": {"epss_score": 0.00057, "epss_percentile": 0.18175}, "CVE-2023-52968": {"epss_score": 0.00099, "epss_percentile": 0.28312}, "CVE-2023-52969": {"epss_score": 0.00209, "epss_percentile": 0.43409}, "CVE-2023-52970": {"epss_score": 0.00209, "epss_percentile": 0.43409}, "CVE-2023-52971": {"epss_score": 0.0005, "epss_percentile": 0.15968}, "CVE-2023-52972": {"epss_score": 0.00013, "epss_percentile": 0.01536}, "CVE-2023-52973": {"epss_score": 0.00041, "epss_percentile": 0.12368}, "CVE-2023-52974": {"epss_score": 0.00039, "epss_percentile": 0.11427}, "CVE-2023-52975": {"epss_score": 0.00016, "epss_percentile": 0.02752}, "CVE-2023-52976": {"epss_score": 0.00036, "epss_percentile": 0.10616}, "CVE-2023-52977": {"epss_score": 0.0003, "epss_percentile": 0.08253}, "CVE-2023-52978": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2023-52980": {"epss_score": 0.00026, "epss_percentile": 0.06432}, "CVE-2023-52981": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2023-52982": {"epss_score": 0.00024, "epss_percentile": 0.06003}, "CVE-2023-52983": {"epss_score": 0.00055, "epss_percentile": 0.17494}, "CVE-2023-52984": {"epss_score": 0.00021, "epss_percentile": 0.04938}, "CVE-2023-52985": {"epss_score": 0.00024, "epss_percentile": 0.06003}, "CVE-2023-52986": {"epss_score": 0.00031, "epss_percentile": 0.08461}, "CVE-2023-52987": {"epss_score": 0.00029, "epss_percentile": 0.07738}, "CVE-2023-52988": {"epss_score": 0.00021, "epss_percentile": 0.04898}, "CVE-2023-52989": {"epss_score": 0.00023, "epss_percentile": 0.05656}, "CVE-2023-52991": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2023-52992": {"epss_score": 0.00021, "epss_percentile": 0.04767}, "CVE-2023-52993": {"epss_score": 0.00017, "epss_percentile": 0.0321}, "CVE-2023-52994": {"epss_score": 0.00024, "epss_percentile": 0.06003}, "CVE-2023-52995": {"epss_score": 0.00016, "epss_percentile": 0.0295}, "CVE-2023-52996": {"epss_score": 0.00021, "epss_percentile": 0.04767}, "CVE-2023-52997": {"epss_score": 0.00023, "epss_percentile": 0.05656}, "CVE-2023-52998": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2023-52999": {"epss_score": 0.00026, "epss_percentile": 0.0673}, "CVE-2023-53000": {"epss_score": 0.00031, "epss_percentile": 0.08639}, "CVE-2023-53002": {"epss_score": 0.00024, "epss_percentile": 0.06003}, "CVE-2023-53003": {"epss_score": 0.00024, "epss_percentile": 0.05776}, "CVE-2023-53004": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2023-53005": {"epss_score": 0.00021, "epss_percentile": 0.04787}, "CVE-2023-53006": {"epss_score": 0.00021, "epss_percentile": 0.04787}, "CVE-2023-53007": {"epss_score": 0.00021, "epss_percentile": 0.04787}, "CVE-2023-53008": {"epss_score": 0.00024, "epss_percentile": 0.05662}, "CVE-2023-53009": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2023-53010": {"epss_score": 0.00033, "epss_percentile": 0.09184}, "CVE-2023-53011": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2023-53012": {"epss_score": 0.00016, "epss_percentile": 0.0295}, "CVE-2023-53013": {"epss_score": 0.00014, "epss_percentile": 0.02049}, "CVE-2023-53014": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2023-53015": {"epss_score": 0.00023, "epss_percentile": 0.05656}, "CVE-2023-53016": {"epss_score": 0.00013, "epss_percentile": 0.01498}, "CVE-2023-53017": {"epss_score": 0.00024, "epss_percentile": 0.06003}, "CVE-2023-53018": {"epss_score": 0.00024, "epss_percentile": 0.06003}, "CVE-2023-53019": {"epss_score": 0.00024, "epss_percentile": 0.05812}, "CVE-2023-53020": {"epss_score": 0.00017, "epss_percentile": 0.03137}, "CVE-2023-53021": {"epss_score": 0.00043, "epss_percentile": 0.13283}, "CVE-2023-53022": {"epss_score": 0.00013, "epss_percentile": 0.01498}, "CVE-2023-53023": {"epss_score": 0.00029, "epss_percentile": 0.07759}, "CVE-2023-53024": {"epss_score": 0.00075, "epss_percentile": 0.23042}, "CVE-2023-53026": {"epss_score": 0.00018, "epss_percentile": 0.03747}, "CVE-2023-53028": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2023-53029": {"epss_score": 0.00014, "epss_percentile": 0.02049}, "CVE-2023-53030": {"epss_score": 0.00014, "epss_percentile": 0.02049}, "CVE-2023-53031": {"epss_score": 0.00018, "epss_percentile": 0.03888}, "CVE-2023-53032": {"epss_score": 0.00034, "epss_percentile": 0.0966}, "CVE-2023-53033": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2023-53034": {"epss_score": 0.00026, "epss_percentile": 0.06595}, "CVE-2023-53035": {"epss_score": 0.00078, "epss_percentile": 0.23759}, "CVE-2023-53036": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53037": {"epss_score": 0.00017, "epss_percentile": 0.03134}, "CVE-2023-53038": {"epss_score": 0.00014, "epss_percentile": 0.02045}, "CVE-2023-53039": {"epss_score": 0.00018, "epss_percentile": 0.03939}, "CVE-2023-53040": {"epss_score": 0.00014, "epss_percentile": 0.01892}, "CVE-2023-53041": {"epss_score": 0.00014, "epss_percentile": 0.01892}, "CVE-2023-53042": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53043": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53044": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53045": {"epss_score": 0.00013, "epss_percentile": 0.01708}, "CVE-2023-53046": {"epss_score": 0.00011, "epss_percentile": 0.0093}, "CVE-2023-53047": {"epss_score": 0.00013, "epss_percentile": 0.01684}, "CVE-2023-53048": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2023-53049": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2023-53050": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53051": {"epss_score": 0.00017, "epss_percentile": 0.03124}, "CVE-2023-53052": {"epss_score": 0.00021, "epss_percentile": 0.04879}, "CVE-2023-53053": {"epss_score": 0.00025, "epss_percentile": 0.06066}, "CVE-2023-53054": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2023-53055": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2023-53056": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2023-53057": {"epss_score": 0.00014, "epss_percentile": 0.0203}, "CVE-2023-53058": {"epss_score": 0.0003, "epss_percentile": 0.08191}, "CVE-2023-53059": {"epss_score": 0.00048, "epss_percentile": 0.14934}, "CVE-2023-53060": {"epss_score": 0.00013, "epss_percentile": 0.01708}, "CVE-2023-53061": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2023-53062": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53064": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2023-53065": {"epss_score": 0.00017, "epss_percentile": 0.03513}, "CVE-2023-53066": {"epss_score": 0.00023, "epss_percentile": 0.05606}, "CVE-2023-53067": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53068": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53069": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2023-53070": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53071": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53072": {"epss_score": 0.00014, "epss_percentile": 0.0203}, "CVE-2023-53073": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53074": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53075": {"epss_score": 0.00024, "epss_percentile": 0.05744}, "CVE-2023-53077": {"epss_score": 0.00017, "epss_percentile": 0.03513}, "CVE-2023-53078": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53079": {"epss_score": 0.0003, "epss_percentile": 0.08191}, "CVE-2023-53080": {"epss_score": 0.0003, "epss_percentile": 0.08191}, "CVE-2023-53081": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2023-53082": {"epss_score": 0.00014, "epss_percentile": 0.0203}, "CVE-2023-53083": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2023-53084": {"epss_score": 0.00017, "epss_percentile": 0.03513}, "CVE-2023-53085": {"epss_score": 0.00029, "epss_percentile": 0.07847}, "CVE-2023-53086": {"epss_score": 0.00019, "epss_percentile": 0.04093}, "CVE-2023-53087": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2023-53088": {"epss_score": 0.00014, "epss_percentile": 0.0203}, "CVE-2023-53089": {"epss_score": 0.00014, "epss_percentile": 0.02055}, "CVE-2023-53090": {"epss_score": 0.00011, "epss_percentile": 0.01091}, "CVE-2023-53091": {"epss_score": 0.00014, "epss_percentile": 0.02045}, "CVE-2023-53092": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2023-53093": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53094": {"epss_score": 0.00013, "epss_percentile": 0.01684}, "CVE-2023-53095": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53096": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53097": {"epss_score": 0.00017, "epss_percentile": 0.03294}, "CVE-2023-53098": {"epss_score": 0.00025, "epss_percentile": 0.06309}, "CVE-2023-53099": {"epss_score": 0.00013, "epss_percentile": 0.01684}, "CVE-2023-53100": {"epss_score": 0.00017, "epss_percentile": 0.03109}, "CVE-2023-53101": {"epss_score": 0.00017, "epss_percentile": 0.03109}, "CVE-2023-53102": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2023-53103": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2023-53105": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53106": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2023-53107": {"epss_score": 0.00014, "epss_percentile": 0.0203}, "CVE-2023-53108": {"epss_score": 0.00014, "epss_percentile": 0.01892}, "CVE-2023-53109": {"epss_score": 0.00023, "epss_percentile": 0.05606}, "CVE-2023-53110": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2023-53111": {"epss_score": 0.00018, "epss_percentile": 0.03939}, "CVE-2023-53112": {"epss_score": 0.00014, "epss_percentile": 0.0203}, "CVE-2023-53113": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53114": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53115": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53116": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2023-53117": {"epss_score": 0.00014, "epss_percentile": 0.02}, "CVE-2023-53118": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53119": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53120": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53121": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53123": {"epss_score": 0.00022, "epss_percentile": 0.05063}, "CVE-2023-53124": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53125": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53126": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53127": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53128": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53131": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2023-53132": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53133": {"epss_score": 0.00015, "epss_percentile": 0.02478}, "CVE-2023-53134": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53135": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2023-53136": {"epss_score": 0.00018, "epss_percentile": 0.03939}, "CVE-2023-53138": {"epss_score": 0.00018, "epss_percentile": 0.03547}, "CVE-2023-53139": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53140": {"epss_score": 0.00025, "epss_percentile": 0.06217}, "CVE-2023-53141": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53142": {"epss_score": 0.00018, "epss_percentile": 0.03939}, "CVE-2023-53143": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2023-53144": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2023-53145": {"epss_score": 0.00014, "epss_percentile": 0.01886}, "CVE-2023-53146": {"epss_score": 0.00014, "epss_percentile": 0.01801}, "CVE-2023-53147": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53148": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2023-53149": {"epss_score": 0.00017, "epss_percentile": 0.03193}, "CVE-2023-53150": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53151": {"epss_score": 0.00013, "epss_percentile": 0.01537}, "CVE-2023-53152": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53153": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53154": {"epss_score": 0.00018, "epss_percentile": 0.03981}, "CVE-2023-53155": {"epss_score": 0.00043, "epss_percentile": 0.12974}, "CVE-2023-53156": {"epss_score": 0.00032, "epss_percentile": 0.0873}, "CVE-2023-53157": {"epss_score": 0.00307, "epss_percentile": 0.53522}, "CVE-2023-53158": {"epss_score": 0.00014, "epss_percentile": 0.02093}, "CVE-2023-53159": {"epss_score": 0.00046, "epss_percentile": 0.14163}, "CVE-2023-53160": {"epss_score": 0.00039, "epss_percentile": 0.11573}, "CVE-2023-53161": {"epss_score": 0.00036, "epss_percentile": 0.10486}, "CVE-2023-53163": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53164": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53165": {"epss_score": 0.00017, "epss_percentile": 0.034}, "CVE-2023-53166": {"epss_score": 0.00014, "epss_percentile": 0.01767}, "CVE-2023-53167": {"epss_score": 0.00018, "epss_percentile": 0.03834}, "CVE-2023-53168": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53169": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53170": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53171": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53172": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53173": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53174": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53175": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53176": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53177": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53178": {"epss_score": 0.00016, "epss_percentile": 0.02792}, "CVE-2023-53179": {"epss_score": 0.00017, "epss_percentile": 0.03298}, "CVE-2023-53180": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53181": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53182": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53184": {"epss_score": 0.00021, "epss_percentile": 0.04692}, "CVE-2023-53185": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2023-53186": {"epss_score": 0.00013, "epss_percentile": 0.01703}, "CVE-2023-53187": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2023-53188": {"epss_score": 0.00014, "epss_percentile": 0.01824}, "CVE-2023-53189": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53190": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53191": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53192": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2023-53193": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53194": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2023-53195": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53196": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53197": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53198": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53199": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53200": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53201": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53202": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53203": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53204": {"epss_score": 0.00014, "epss_percentile": 0.01824}, "CVE-2023-53205": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2023-53206": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53207": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53208": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53209": {"epss_score": 0.00016, "epss_percentile": 0.02938}, "CVE-2023-53210": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53211": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53213": {"epss_score": 0.00016, "epss_percentile": 0.02824}, "CVE-2023-53214": {"epss_score": 0.00021, "epss_percentile": 0.04794}, "CVE-2023-53215": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2023-53216": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2023-53217": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53218": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2023-53219": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53220": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53221": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53222": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2023-53223": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53224": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53225": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53226": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2023-53228": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53229": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53230": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53231": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53232": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53233": {"epss_score": 0.00014, "epss_percentile": 0.01795}, "CVE-2023-53234": {"epss_score": 0.00023, "epss_percentile": 0.05642}, "CVE-2023-53235": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2023-53236": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53237": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53238": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53239": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53240": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53241": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53242": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53243": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53244": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53245": {"epss_score": 0.00023, "epss_percentile": 0.05642}, "CVE-2023-53246": {"epss_score": 0.00017, "epss_percentile": 0.03422}, "CVE-2023-53247": {"epss_score": 0.00016, "epss_percentile": 0.02938}, "CVE-2023-53248": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53249": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53250": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53251": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53252": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2023-53253": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2023-53254": {"epss_score": 0.00016, "epss_percentile": 0.0296}, "CVE-2023-53255": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53256": {"epss_score": 0.00018, "epss_percentile": 0.03925}, "CVE-2023-53257": {"epss_score": 0.00017, "epss_percentile": 0.03145}, "CVE-2023-53258": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53259": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2023-53260": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53261": {"epss_score": 0.00024, "epss_percentile": 0.058}, "CVE-2023-53262": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2023-53263": {"epss_score": 0.00021, "epss_percentile": 0.04692}, "CVE-2023-53264": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53265": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2023-53266": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53267": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53268": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53269": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53270": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53271": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53272": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2023-53273": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53274": {"epss_score": 0.00023, "epss_percentile": 0.05359}, "CVE-2023-53275": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53276": {"epss_score": 0.00016, "epss_percentile": 0.02686}, "CVE-2023-53277": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53278": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53279": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53280": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53281": {"epss_score": 0.00014, "epss_percentile": 0.01795}, "CVE-2023-53282": {"epss_score": 0.00017, "epss_percentile": 0.03145}, "CVE-2023-53284": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53285": {"epss_score": 0.00016, "epss_percentile": 0.02824}, "CVE-2023-53286": {"epss_score": 0.00018, "epss_percentile": 0.03618}, "CVE-2023-53287": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53288": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53289": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2023-53290": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53291": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53292": {"epss_score": 0.00018, "epss_percentile": 0.03799}, "CVE-2023-53294": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53295": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53296": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53297": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53298": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53299": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2023-53300": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53301": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53302": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53303": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53304": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53305": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2023-53306": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53307": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53308": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53309": {"epss_score": 0.00016, "epss_percentile": 0.02905}, "CVE-2023-53310": {"epss_score": 0.00014, "epss_percentile": 0.01767}, "CVE-2023-53311": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53312": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53313": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2023-53314": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53315": {"epss_score": 0.00021, "epss_percentile": 0.04706}, "CVE-2023-53316": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53317": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53318": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53319": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53320": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2023-53321": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2023-53322": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2023-53323": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53324": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53325": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53326": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53327": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53328": {"epss_score": 0.00021, "epss_percentile": 0.04922}, "CVE-2023-53329": {"epss_score": 0.00015, "epss_percentile": 0.02313}, "CVE-2023-53330": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53331": {"epss_score": 0.00017, "epss_percentile": 0.03298}, "CVE-2023-53332": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53333": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53334": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53335": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53336": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53337": {"epss_score": 0.00016, "epss_percentile": 0.02686}, "CVE-2023-53338": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53339": {"epss_score": 0.00016, "epss_percentile": 0.02938}, "CVE-2023-53340": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2023-53341": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53342": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53343": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53344": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53345": {"epss_score": 0.00014, "epss_percentile": 0.01767}, "CVE-2023-53346": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53347": {"epss_score": 0.00022, "epss_percentile": 0.04985}, "CVE-2023-53348": {"epss_score": 0.00014, "epss_percentile": 0.01767}, "CVE-2023-53349": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53350": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53351": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53352": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53353": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53354": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53355": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53356": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53357": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53358": {"epss_score": 0.00018, "epss_percentile": 0.03596}, "CVE-2023-53359": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53360": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53361": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53362": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53363": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2023-53364": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53365": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53366": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53367": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53368": {"epss_score": 0.00014, "epss_percentile": 0.01824}, "CVE-2023-53369": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53370": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53371": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53372": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53373": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53374": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2023-53375": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53376": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2023-53377": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2023-53378": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53379": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53380": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53381": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53382": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53383": {"epss_score": 0.00016, "epss_percentile": 0.02938}, "CVE-2023-53384": {"epss_score": 0.00017, "epss_percentile": 0.03164}, "CVE-2023-53385": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53386": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53387": {"epss_score": 0.00016, "epss_percentile": 0.02938}, "CVE-2023-53388": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53389": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53390": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53391": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53392": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53393": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53394": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53395": {"epss_score": 0.00017, "epss_percentile": 0.03181}, "CVE-2023-53396": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53397": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53398": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2023-53399": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53400": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53401": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53402": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53403": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53404": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53405": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53406": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53407": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53408": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53409": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53410": {"epss_score": 0.00016, "epss_percentile": 0.02938}, "CVE-2023-53411": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53412": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53413": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53414": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53415": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53416": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53417": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53418": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53419": {"epss_score": 0.00017, "epss_percentile": 0.03422}, "CVE-2023-53420": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2023-53421": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53422": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53423": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53424": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53425": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53426": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2023-53427": {"epss_score": 0.00018, "epss_percentile": 0.0374}, "CVE-2023-53428": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53429": {"epss_score": 0.00018, "epss_percentile": 0.03799}, "CVE-2023-53430": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2023-53431": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53432": {"epss_score": 0.00017, "epss_percentile": 0.03145}, "CVE-2023-53433": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53434": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53435": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53436": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53437": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53438": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2023-53439": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53440": {"epss_score": 0.00018, "epss_percentile": 0.03594}, "CVE-2023-53441": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2023-53442": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53443": {"epss_score": 0.00016, "epss_percentile": 0.0305}, "CVE-2023-53444": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2023-53445": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2023-53446": {"epss_score": 0.00024, "epss_percentile": 0.05803}, "CVE-2023-53447": {"epss_score": 0.00015, "epss_percentile": 0.02313}, "CVE-2023-53448": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53449": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53450": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2023-53451": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53452": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53453": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53454": {"epss_score": 0.00066, "epss_percentile": 0.20751}, "CVE-2023-53455": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53456": {"epss_score": 0.00056, "epss_percentile": 0.17952}, "CVE-2023-53457": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53458": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53459": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53460": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53461": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53462": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53463": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53464": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53465": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53466": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53467": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53468": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53470": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53471": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53472": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53473": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53474": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53475": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53476": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53477": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53478": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53479": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53480": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53481": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53482": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53483": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53484": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53485": {"epss_score": 0.00035, "epss_percentile": 0.10072}, "CVE-2023-53486": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53487": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53488": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53489": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2023-53490": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53491": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53492": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53493": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53494": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53495": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53496": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53497": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53498": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2023-53499": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53500": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53501": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53503": {"epss_score": 0.00027, "epss_percentile": 0.06826}, "CVE-2023-53504": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53505": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53506": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53507": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53508": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53509": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53510": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53511": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53512": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53513": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53514": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53515": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53516": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53517": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53518": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2023-53519": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53520": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53521": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53522": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53523": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53524": {"epss_score": 0.00045, "epss_percentile": 0.13944}, "CVE-2023-53525": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53526": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53527": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53528": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53529": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53530": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53531": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53532": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53533": {"epss_score": 0.00049, "epss_percentile": 0.15362}, "CVE-2023-53534": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53535": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53536": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53537": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53538": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53539": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53540": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53541": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53542": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53543": {"epss_score": 0.00029, "epss_percentile": 0.07591}, "CVE-2023-53544": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53545": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53546": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53547": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53548": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53549": {"epss_score": 0.00027, "epss_percentile": 0.07094}, "CVE-2023-53550": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53551": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53552": {"epss_score": 0.00025, "epss_percentile": 0.06307}, "CVE-2023-53553": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53554": {"epss_score": 0.00045, "epss_percentile": 0.13944}, "CVE-2023-53555": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53556": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53557": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53558": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53559": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53560": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53561": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53562": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53563": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53564": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53565": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53566": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53567": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53568": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53569": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53570": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53571": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53572": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53573": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53574": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53575": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53576": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53577": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53578": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53579": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53580": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53581": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53582": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53583": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53584": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53585": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53586": {"epss_score": 0.00035, "epss_percentile": 0.10072}, "CVE-2023-53587": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2023-53588": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53589": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53590": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53591": {"epss_score": 0.00027, "epss_percentile": 0.06841}, "CVE-2023-53592": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53593": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53594": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53595": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53596": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53597": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53598": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53599": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53600": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53601": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53602": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53603": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53604": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2023-53605": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53606": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53607": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53608": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53609": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53610": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53611": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53612": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53613": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53614": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53615": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53616": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53617": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53618": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53619": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53620": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53621": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53622": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53623": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53624": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53625": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53626": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53627": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53628": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53629": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53630": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53631": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53632": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53633": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53634": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53635": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53636": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53637": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53638": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53639": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2023-53640": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53641": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53642": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53643": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53644": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53645": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53646": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53647": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53648": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2023-53649": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53650": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2023-53651": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53652": {"epss_score": 0.00029, "epss_percentile": 0.07591}, "CVE-2023-53653": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53654": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53655": {"epss_score": 0.00045, "epss_percentile": 0.13944}, "CVE-2023-53656": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53657": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53658": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53659": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53660": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53661": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53662": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53663": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53664": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53665": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53666": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53667": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53668": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53669": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53670": {"epss_score": 0.00097, "epss_percentile": 0.27625}, "CVE-2023-53671": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53672": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53673": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53674": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53675": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53676": {"epss_score": 0.00045, "epss_percentile": 0.13944}, "CVE-2023-53677": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53678": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53679": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53680": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53681": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53682": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53683": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53684": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53685": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53686": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53687": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53688": {"epss_score": 0.00086, "epss_percentile": 0.2535}, "CVE-2023-53689": {"epss_score": 0.00153, "epss_percentile": 0.36567}, "CVE-2023-53690": {"epss_score": 0.01635, "epss_percentile": 0.81473}, "CVE-2023-53691": {"epss_score": 0.00102, "epss_percentile": 0.28817}, "CVE-2023-53692": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53693": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53694": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53695": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53696": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53697": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53698": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53699": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53700": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53702": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53703": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53704": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53705": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53706": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53707": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53708": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53709": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53710": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53711": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53712": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53713": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53714": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53715": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53716": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53717": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53718": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53719": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53720": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53721": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2023-53722": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53723": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53724": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53725": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53726": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53727": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2023-53728": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53729": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53730": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-53731": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2023-53732": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2023-53733": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2023-53734": {"epss_score": 0.00231, "epss_percentile": 0.45821}, "CVE-2023-53735": {"epss_score": 0.00232, "epss_percentile": 0.45959}, "CVE-2023-53736": {"epss_score": 0.00033, "epss_percentile": 0.09393}, "CVE-2023-53737": {"epss_score": 0.00027, "epss_percentile": 0.06856}, "CVE-2023-53738": {"epss_score": 0.00033, "epss_percentile": 0.09393}, "CVE-2023-53739": {"epss_score": 0.00703, "epss_percentile": 0.71539}, "CVE-2023-53740": {"epss_score": 0.00395, "epss_percentile": 0.59845}, "CVE-2023-53741": {"epss_score": 0.00407, "epss_percentile": 0.60586}, "CVE-2023-53742": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53743": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53744": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53745": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53746": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53747": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53748": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53750": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53751": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53752": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53753": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53754": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53755": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53756": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-53757": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53758": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53759": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53760": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53761": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53762": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53763": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53764": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53765": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53766": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53767": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53768": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53769": {"epss_score": 0.00013, "epss_percentile": 0.01683}, "CVE-2023-53770": {"epss_score": 0.00204, "epss_percentile": 0.42668}, "CVE-2023-53771": {"epss_score": 0.01222, "epss_percentile": 0.78654}, "CVE-2023-53772": {"epss_score": 0.0057, "epss_percentile": 0.67956}, "CVE-2023-53773": {"epss_score": 0.00404, "epss_percentile": 0.60409}, "CVE-2023-53774": {"epss_score": 0.0118, "epss_percentile": 0.78297}, "CVE-2023-53775": {"epss_score": 0.00195, "epss_percentile": 0.41651}, "CVE-2023-53776": {"epss_score": 0.00188, "epss_percentile": 0.4084}, "CVE-2023-53777": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53778": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53780": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53781": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53782": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-53783": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53784": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53785": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53786": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-53787": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53788": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53789": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53790": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53791": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53792": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53793": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53794": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53795": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53796": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53797": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53798": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-53799": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53800": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53801": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53802": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53803": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53804": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53806": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53807": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-53808": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-53809": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-53810": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53811": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53812": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53813": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53814": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53815": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53816": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53817": {"epss_score": 0.00117, "epss_percentile": 0.31277}, "CVE-2023-53818": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53819": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53820": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-53821": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53822": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53823": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53824": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-53825": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53826": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53827": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53828": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53829": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53830": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53831": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53832": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53833": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53834": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53836": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53837": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-53838": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53839": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53840": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53841": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53842": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53843": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53844": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53845": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-53846": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53847": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53848": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53849": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53850": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53851": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53852": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53853": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53854": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53855": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53856": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-53857": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53858": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53859": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53860": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53861": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53862": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53863": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-53864": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53865": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53866": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53867": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-53868": {"epss_score": 0.00365, "epss_percentile": 0.57983}, "CVE-2023-53869": {"epss_score": 0.00263, "epss_percentile": 0.49521}, "CVE-2023-53870": {"epss_score": 0.00059, "epss_percentile": 0.18617}, "CVE-2023-53871": {"epss_score": 0.00128, "epss_percentile": 0.33029}, "CVE-2023-53872": {"epss_score": 0.00973, "epss_percentile": 0.76162}, "CVE-2023-53873": {"epss_score": 0.00193, "epss_percentile": 0.41458}, "CVE-2023-53874": {"epss_score": 0.00038, "epss_percentile": 0.11341}, "CVE-2023-53875": {"epss_score": 0.00146, "epss_percentile": 0.35575}, "CVE-2023-53876": {"epss_score": 0.00028, "epss_percentile": 0.07228}, "CVE-2023-53877": {"epss_score": 0.00036, "epss_percentile": 0.10346}, "CVE-2023-53878": {"epss_score": 0.0006, "epss_percentile": 0.19136}, "CVE-2023-53879": {"epss_score": 0.00013, "epss_percentile": 0.01591}, "CVE-2023-53880": {"epss_score": 0.00049, "epss_percentile": 0.15617}, "CVE-2023-53881": {"epss_score": 0.00027, "epss_percentile": 0.06814}, "CVE-2023-53882": {"epss_score": 0.00059, "epss_percentile": 0.18617}, "CVE-2023-53883": {"epss_score": 0.00268, "epss_percentile": 0.50023}, "CVE-2023-53884": {"epss_score": 0.00033, "epss_percentile": 0.09299}, "CVE-2023-53885": {"epss_score": 0.00243, "epss_percentile": 0.47485}, "CVE-2023-53886": {"epss_score": 0.00053, "epss_percentile": 0.16725}, "CVE-2023-53887": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53888": {"epss_score": 0.00522, "epss_percentile": 0.66263}, "CVE-2023-53889": {"epss_score": 0.00264, "epss_percentile": 0.4972}, "CVE-2023-53890": {"epss_score": 0.00029, "epss_percentile": 0.07783}, "CVE-2023-53891": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53892": {"epss_score": 0.00614, "epss_percentile": 0.6927}, "CVE-2023-53893": {"epss_score": 0.00032, "epss_percentile": 0.08794}, "CVE-2023-53894": {"epss_score": 0.00117, "epss_percentile": 0.3138}, "CVE-2023-53895": {"epss_score": 0.00373, "epss_percentile": 0.58502}, "CVE-2023-53896": {"epss_score": 0.00233, "epss_percentile": 0.46049}, "CVE-2023-53897": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53898": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53899": {"epss_score": 0.00114, "epss_percentile": 0.3078}, "CVE-2023-53900": {"epss_score": 0.00032, "epss_percentile": 0.08845}, "CVE-2023-53901": {"epss_score": 0.00023, "epss_percentile": 0.05461}, "CVE-2023-53902": {"epss_score": 0.00653, "epss_percentile": 0.70335}, "CVE-2023-53903": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53904": {"epss_score": 0.00029, "epss_percentile": 0.07783}, "CVE-2023-53905": {"epss_score": 0.00045, "epss_percentile": 0.1379}, "CVE-2023-53906": {"epss_score": 0.00026, "epss_percentile": 0.06625}, "CVE-2023-53907": {"epss_score": 0.00275, "epss_percentile": 0.50662}, "CVE-2023-53908": {"epss_score": 5e-05, "epss_percentile": 0.00207}, "CVE-2023-53909": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53910": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53911": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53912": {"epss_score": 0.00012, "epss_percentile": 0.01245}, "CVE-2023-53913": {"epss_score": 0.00119, "epss_percentile": 0.31642}, "CVE-2023-53914": {"epss_score": 0.00742, "epss_percentile": 0.72461}, "CVE-2023-53915": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53916": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53917": {"epss_score": 0.00027, "epss_percentile": 0.07089}, "CVE-2023-53918": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53919": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53920": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53921": {"epss_score": 0.0033, "epss_percentile": 0.55426}, "CVE-2023-53922": {"epss_score": 0.01283, "epss_percentile": 0.7916}, "CVE-2023-53923": {"epss_score": 0.00111, "epss_percentile": 0.30334}, "CVE-2023-53924": {"epss_score": 0.00265, "epss_percentile": 0.49786}, "CVE-2023-53925": {"epss_score": 0.00033, "epss_percentile": 0.09299}, "CVE-2023-53926": {"epss_score": 0.00219, "epss_percentile": 0.44505}, "CVE-2023-53927": {"epss_score": 0.00028, "epss_percentile": 0.07349}, "CVE-2023-53928": {"epss_score": 0.00029, "epss_percentile": 0.07783}, "CVE-2023-53929": {"epss_score": 0.00045, "epss_percentile": 0.1379}, "CVE-2023-53930": {"epss_score": 0.0004, "epss_percentile": 0.12034}, "CVE-2023-53931": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53932": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53933": {"epss_score": 0.00443, "epss_percentile": 0.62769}, "CVE-2023-53934": {"epss_score": 0.00152, "epss_percentile": 0.36437}, "CVE-2023-53935": {"epss_score": 0.00026, "epss_percentile": 0.06395}, "CVE-2023-53936": {"epss_score": 0.00029, "epss_percentile": 0.07783}, "CVE-2023-53937": {"epss_score": 0.00013, "epss_percentile": 0.01613}, "CVE-2023-53938": {"epss_score": 0.00029, "epss_percentile": 0.07783}, "CVE-2023-53939": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53940": {"epss_score": 0.00022, "epss_percentile": 0.05188}, "CVE-2023-53941": {"epss_score": 0.55344, "epss_percentile": 0.97972}, "CVE-2023-53942": {"epss_score": 0.00131, "epss_percentile": 0.33365}, "CVE-2023-53943": {"epss_score": 0.00034, "epss_percentile": 0.09569}, "CVE-2023-53944": {"epss_score": 0.00236, "epss_percentile": 0.46454}, "CVE-2023-53945": {"epss_score": 0.00311, "epss_percentile": 0.53841}, "CVE-2023-53946": {"epss_score": 0.00015, "epss_percentile": 0.02589}, "CVE-2023-53947": {"epss_score": 0.00013, "epss_percentile": 0.01677}, "CVE-2023-53948": {"epss_score": 0.00324, "epss_percentile": 0.54957}, "CVE-2023-53949": {"epss_score": 0.00013, "epss_percentile": 0.01602}, "CVE-2023-53950": {"epss_score": 0.00053, "epss_percentile": 0.16891}, "CVE-2023-53951": {"epss_score": 0.00045, "epss_percentile": 0.13766}, "CVE-2023-53952": {"epss_score": 0.00518, "epss_percentile": 0.66131}, "CVE-2023-53953": {"epss_score": 0.00026, "epss_percentile": 0.06547}, "CVE-2023-53954": {"epss_score": 0.00013, "epss_percentile": 0.0155}, "CVE-2023-53955": {"epss_score": 0.00127, "epss_percentile": 0.32914}, "CVE-2023-53956": {"epss_score": 0.00201, "epss_percentile": 0.4228}, "CVE-2023-53957": {"epss_score": 0.00052, "epss_percentile": 0.16338}, "CVE-2023-53958": {"epss_score": 0.00039, "epss_percentile": 0.1172}, "CVE-2023-53959": {"epss_score": 0.0022, "epss_percentile": 0.44576}, "CVE-2023-53960": {"epss_score": 0.00104, "epss_percentile": 0.29213}, "CVE-2023-53961": {"epss_score": 0.00019, "epss_percentile": 0.04228}, "CVE-2023-53962": {"epss_score": 0.01063, "epss_percentile": 0.77187}, "CVE-2023-53963": {"epss_score": 0.00535, "epss_percentile": 0.66839}, "CVE-2023-53964": {"epss_score": 0.00129, "epss_percentile": 0.3309}, "CVE-2023-53965": {"epss_score": 0.00018, "epss_percentile": 0.03602}, "CVE-2023-53966": {"epss_score": 0.00091, "epss_percentile": 0.26283}, "CVE-2023-53967": {"epss_score": 0.00174, "epss_percentile": 0.3926}, "CVE-2023-53968": {"epss_score": 0.00242, "epss_percentile": 0.47335}, "CVE-2023-53969": {"epss_score": 0.00174, "epss_percentile": 0.3926}, "CVE-2023-53970": {"epss_score": 0.00233, "epss_percentile": 0.46001}, "CVE-2023-53971": {"epss_score": 0.00045, "epss_percentile": 0.13779}, "CVE-2023-53972": {"epss_score": 0.00062, "epss_percentile": 0.19594}, "CVE-2023-53973": {"epss_score": 0.00021, "epss_percentile": 0.04918}, "CVE-2023-53974": {"epss_score": 0.00066, "epss_percentile": 0.20767}, "CVE-2023-53975": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2023-53976": {"epss_score": 0.00031, "epss_percentile": 0.085}, "CVE-2023-53977": {"epss_score": 0.00029, "epss_percentile": 0.07783}, "CVE-2023-53978": {"epss_score": 0.00029, "epss_percentile": 0.07783}, "CVE-2023-53979": {"epss_score": 0.00061, "epss_percentile": 0.19524}, "CVE-2023-53980": {"epss_score": 0.00298, "epss_percentile": 0.52781}, "CVE-2023-53981": {"epss_score": 0.00382, "epss_percentile": 0.59077}, "CVE-2023-53982": {"epss_score": 0.00062, "epss_percentile": 0.19783}, "CVE-2023-53983": {"epss_score": 0.00097, "epss_percentile": 0.27633}, "CVE-2023-53986": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53987": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53988": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-53989": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-53990": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-53991": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-53992": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53993": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-53994": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53995": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53996": {"epss_score": 0.00013, "epss_percentile": 0.01683}, "CVE-2023-53997": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-53998": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-53999": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54000": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54001": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54002": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54003": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54004": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54005": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54006": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54007": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54008": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54009": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54010": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54011": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54012": {"epss_score": 0.0004, "epss_percentile": 0.11914}, "CVE-2023-54013": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54014": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54015": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54016": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54017": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54018": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54019": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54020": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54021": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54022": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54023": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54024": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54025": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54026": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54027": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54028": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54030": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54031": {"epss_score": 0.00025, "epss_percentile": 0.06257}, "CVE-2023-54032": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54033": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54034": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54035": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54036": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54037": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54038": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54039": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54040": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54041": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54042": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54043": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54044": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54045": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54046": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54047": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54048": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54049": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54050": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54051": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54052": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54053": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54055": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54056": {"epss_score": 0.0004, "epss_percentile": 0.11914}, "CVE-2023-54057": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54058": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54059": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54060": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54062": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54063": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54064": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54065": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54066": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54067": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54068": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54069": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54070": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54071": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54072": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54073": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54074": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54075": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54076": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54077": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54078": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54079": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54080": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54081": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54083": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54084": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54085": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54086": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54087": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54088": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54089": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54090": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54091": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54092": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54093": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54094": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54095": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54096": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54097": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54098": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54099": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54100": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54101": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54102": {"epss_score": 0.0004, "epss_percentile": 0.11914}, "CVE-2023-54104": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54105": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54106": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54107": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54108": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54109": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54110": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54111": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54112": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54113": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54114": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54115": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54116": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54117": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54118": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54119": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54120": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54121": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54122": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54123": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54124": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54125": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54126": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54127": {"epss_score": 0.00031, "epss_percentile": 0.0854}, "CVE-2023-54128": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54129": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54130": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54131": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54132": {"epss_score": 0.00037, "epss_percentile": 0.10686}, "CVE-2023-54133": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54134": {"epss_score": 0.00031, "epss_percentile": 0.0854}, "CVE-2023-54135": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54136": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54137": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54138": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54139": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54140": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54141": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54142": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54143": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54144": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54145": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54146": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54147": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54148": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54149": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54150": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54151": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54152": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54153": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54154": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54155": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54156": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54157": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54158": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54159": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54160": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54162": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54163": {"epss_score": 0.00048, "epss_percentile": 0.15151}, "CVE-2023-54164": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54165": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54166": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54167": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54168": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54169": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54170": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54171": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54172": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54173": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54174": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54175": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54176": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54177": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54178": {"epss_score": 0.00058, "epss_percentile": 0.18382}, "CVE-2023-54179": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54180": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54181": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54182": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54183": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54184": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54185": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54186": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54187": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54188": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54189": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54190": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54191": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54192": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54193": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54194": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54195": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54196": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54197": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54198": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54199": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54200": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54201": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54202": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54203": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54204": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54205": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54206": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54207": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54208": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54209": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54210": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54211": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54213": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54214": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54215": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54216": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54217": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54218": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54219": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54220": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54221": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54222": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54223": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54224": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54225": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54226": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54227": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54228": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54229": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54230": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54231": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54232": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54233": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54234": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54235": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54236": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54237": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54238": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54239": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54240": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54241": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54242": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54243": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54244": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54245": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54246": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54247": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54248": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54249": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54250": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54251": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54252": {"epss_score": 0.00027, "epss_percentile": 0.06781}, "CVE-2023-54253": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54254": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54255": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54257": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54258": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54259": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54260": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54261": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54262": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54263": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54264": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54265": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54266": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54267": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54268": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54269": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54270": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54271": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54272": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54273": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54274": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54275": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54276": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54277": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54278": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54279": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54280": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54281": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54282": {"epss_score": 0.0004, "epss_percentile": 0.11914}, "CVE-2023-54283": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54284": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54285": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54286": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54287": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54288": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54289": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54291": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54292": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54293": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54294": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54295": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54296": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54297": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54298": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54299": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54300": {"epss_score": 0.00043, "epss_percentile": 0.13262}, "CVE-2023-54301": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54302": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54303": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54304": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54305": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54306": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54307": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54308": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54309": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54310": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54311": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54312": {"epss_score": 0.0004, "epss_percentile": 0.11914}, "CVE-2023-54313": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54314": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54315": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54316": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54317": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54318": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2023-54319": {"epss_score": 0.00058, "epss_percentile": 0.18382}, "CVE-2023-54320": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2023-54321": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54322": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54323": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54324": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2023-54325": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2023-54326": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2023-54327": {"epss_score": 0.00285, "epss_percentile": 0.51674}, "CVE-2023-5000": {"epss_score": 0.00202, "epss_percentile": 0.42488}, "CVE-2023-5001": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-5002": {"epss_score": 0.2184, "epss_percentile": 0.95566}, "CVE-2023-5003": {"epss_score": 0.76331, "epss_percentile": 0.98886}, "CVE-2023-5004": {"epss_score": 0.00047, "epss_percentile": 0.14572}, "CVE-2023-5005": {"epss_score": 0.00086, "epss_percentile": 0.25276}, "CVE-2023-5006": {"epss_score": 0.00113, "epss_percentile": 0.30671}, "CVE-2023-5007": {"epss_score": 0.00098, "epss_percentile": 0.27648}, "CVE-2023-5008": {"epss_score": 0.00031, "epss_percentile": 0.08649}, "CVE-2023-5009": {"epss_score": 0.00026, "epss_percentile": 0.06464}, "CVE-2023-5010": {"epss_score": 0.00098, "epss_percentile": 0.27648}, "CVE-2023-5011": {"epss_score": 0.00089, "epss_percentile": 0.25909}, "CVE-2023-5012": {"epss_score": 0.00041, "epss_percentile": 0.12402}, "CVE-2023-5013": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-5014": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2023-5015": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-5016": {"epss_score": 0.00076, "epss_percentile": 0.23154}, "CVE-2023-5017": {"epss_score": 0.00038, "epss_percentile": 0.11397}, "CVE-2023-5018": {"epss_score": 0.00038, "epss_percentile": 0.11397}, "CVE-2023-5019": {"epss_score": 0.00035, "epss_percentile": 0.09815}, "CVE-2023-5020": {"epss_score": 0.00048, "epss_percentile": 0.14973}, "CVE-2023-5021": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-5022": {"epss_score": 0.00102, "epss_percentile": 0.28839}, "CVE-2023-5023": {"epss_score": 0.00035, "epss_percentile": 0.09826}, "CVE-2023-5024": {"epss_score": 0.00093, "epss_percentile": 0.26686}, "CVE-2023-5025": {"epss_score": 0.00099, "epss_percentile": 0.28418}, "CVE-2023-5026": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-5027": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-5028": {"epss_score": 0.00037, "epss_percentile": 0.10859}, "CVE-2023-5029": {"epss_score": 0.00032, "epss_percentile": 0.08811}, "CVE-2023-5030": {"epss_score": 0.00032, "epss_percentile": 0.08811}, "CVE-2023-5031": {"epss_score": 0.00042, "epss_percentile": 0.12915}, "CVE-2023-5032": {"epss_score": 0.00058, "epss_percentile": 0.18475}, "CVE-2023-5033": {"epss_score": 0.00063, "epss_percentile": 0.19993}, "CVE-2023-5034": {"epss_score": 0.00068, "epss_percentile": 0.21203}, "CVE-2023-5035": {"epss_score": 0.00103, "epss_percentile": 0.2897}, "CVE-2023-5036": {"epss_score": 0.00079, "epss_percentile": 0.23911}, "CVE-2023-5037": {"epss_score": 0.00441, "epss_percentile": 0.62689}, "CVE-2023-5038": {"epss_score": 0.00403, "epss_percentile": 0.60351}, "CVE-2023-5041": {"epss_score": 0.00331, "epss_percentile": 0.55542}, "CVE-2023-5042": {"epss_score": 0.00089, "epss_percentile": 0.25794}, "CVE-2023-5043": {"epss_score": 0.04007, "epss_percentile": 0.88103}, "CVE-2023-5044": {"epss_score": 0.08745, "epss_percentile": 0.92238}, "CVE-2023-5045": {"epss_score": 0.0007, "epss_percentile": 0.21667}, "CVE-2023-5046": {"epss_score": 0.0007, "epss_percentile": 0.21667}, "CVE-2023-5047": {"epss_score": 0.00138, "epss_percentile": 0.3451}, "CVE-2023-5048": {"epss_score": 0.00087, "epss_percentile": 0.25485}, "CVE-2023-5049": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-5050": {"epss_score": 0.00156, "epss_percentile": 0.36975}, "CVE-2023-5051": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-5052": {"epss_score": 0.0031, "epss_percentile": 0.53777}, "CVE-2023-5053": {"epss_score": 0.00047, "epss_percentile": 0.14572}, "CVE-2023-5054": {"epss_score": 0.00178, "epss_percentile": 0.39663}, "CVE-2023-5055": {"epss_score": 0.00648, "epss_percentile": 0.70217}, "CVE-2023-5056": {"epss_score": 0.00053, "epss_percentile": 0.16939}, "CVE-2023-5057": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-5058": {"epss_score": 0.00043, "epss_percentile": 0.13352}, "CVE-2023-5059": {"epss_score": 0.0035, "epss_percentile": 0.56968}, "CVE-2023-5060": {"epss_score": 4e-05, "epss_percentile": 0.00172}, "CVE-2023-5061": {"epss_score": 0.00021, "epss_percentile": 0.04943}, "CVE-2023-5062": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2023-5063": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-5068": {"epss_score": 0.00043, "epss_percentile": 0.13183}, "CVE-2023-5070": {"epss_score": 0.13131, "epss_percentile": 0.93881}, "CVE-2023-5071": {"epss_score": 0.00188, "epss_percentile": 0.40911}, "CVE-2023-5072": {"epss_score": 0.00661, "epss_percentile": 0.70572}, "CVE-2023-5073": {"epss_score": 0.00159, "epss_percentile": 0.37372}, "CVE-2023-5074": {"epss_score": 0.91866, "epss_percentile": 0.99674}, "CVE-2023-5075": {"epss_score": 0.00037, "epss_percentile": 0.10933}, "CVE-2023-5076": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2023-5077": {"epss_score": 0.0021, "epss_percentile": 0.43604}, "CVE-2023-5078": {"epss_score": 0.00041, "epss_percentile": 0.12371}, "CVE-2023-5079": {"epss_score": 0.0012, "epss_percentile": 0.31785}, "CVE-2023-5080": {"epss_score": 0.0004, "epss_percentile": 0.11911}, "CVE-2023-5081": {"epss_score": 0.00068, "epss_percentile": 0.21264}, "CVE-2023-5082": {"epss_score": 0.00208, "epss_percentile": 0.43307}, "CVE-2023-5084": {"epss_score": 0.00044, "epss_percentile": 0.1341}, "CVE-2023-5085": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5086": {"epss_score": 0.00181, "epss_percentile": 0.40068}, "CVE-2023-5087": {"epss_score": 0.0017, "epss_percentile": 0.38765}, "CVE-2023-5088": {"epss_score": 0.00014, "epss_percentile": 0.02013}, "CVE-2023-5089": {"epss_score": 0.8, "epss_percentile": 0.99066}, "CVE-2023-5090": {"epss_score": 0.00039, "epss_percentile": 0.11579}, "CVE-2023-5091": {"epss_score": 0.00134, "epss_percentile": 0.33761}, "CVE-2023-5096": {"epss_score": 0.00086, "epss_percentile": 0.25413}, "CVE-2023-5097": {"epss_score": 0.00091, "epss_percentile": 0.26207}, "CVE-2023-5098": {"epss_score": 0.00268, "epss_percentile": 0.50078}, "CVE-2023-5099": {"epss_score": 0.00227, "epss_percentile": 0.45444}, "CVE-2023-5100": {"epss_score": 0.00075, "epss_percentile": 0.23031}, "CVE-2023-5101": {"epss_score": 0.00136, "epss_percentile": 0.34082}, "CVE-2023-5102": {"epss_score": 0.00184, "epss_percentile": 0.40435}, "CVE-2023-5103": {"epss_score": 0.00139, "epss_percentile": 0.34613}, "CVE-2023-5104": {"epss_score": 0.00513, "epss_percentile": 0.65937}, "CVE-2023-5105": {"epss_score": 0.00401, "epss_percentile": 0.60217}, "CVE-2023-5106": {"epss_score": 0.00041, "epss_percentile": 0.12301}, "CVE-2023-5108": {"epss_score": 0.01314, "epss_percentile": 0.79395}, "CVE-2023-5109": {"epss_score": 0.0012, "epss_percentile": 0.3177}, "CVE-2023-5110": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5111": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-5112": {"epss_score": 0.00117, "epss_percentile": 0.31363}, "CVE-2023-5113": {"epss_score": 0.00402, "epss_percentile": 0.60316}, "CVE-2023-5114": {"epss_score": 0.00157, "epss_percentile": 0.37103}, "CVE-2023-5115": {"epss_score": 0.00337, "epss_percentile": 0.56018}, "CVE-2023-5116": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5117": {"epss_score": 0.00036, "epss_percentile": 0.10545}, "CVE-2023-5118": {"epss_score": 0.00205, "epss_percentile": 0.42675}, "CVE-2023-5119": {"epss_score": 0.00085, "epss_percentile": 0.25169}, "CVE-2023-5120": {"epss_score": 0.00206, "epss_percentile": 0.43042}, "CVE-2023-5121": {"epss_score": 0.00156, "epss_percentile": 0.36914}, "CVE-2023-5122": {"epss_score": 0.00195, "epss_percentile": 0.41668}, "CVE-2023-5123": {"epss_score": 0.00535, "epss_percentile": 0.66841}, "CVE-2023-5124": {"epss_score": 0.00126, "epss_percentile": 0.32641}, "CVE-2023-5125": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-5126": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5127": {"epss_score": 0.00323, "epss_percentile": 0.54881}, "CVE-2023-5128": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2023-5130": {"epss_score": 0.00107, "epss_percentile": 0.29637}, "CVE-2023-5131": {"epss_score": 0.00087, "epss_percentile": 0.25562}, "CVE-2023-5132": {"epss_score": 0.01234, "epss_percentile": 0.78755}, "CVE-2023-5133": {"epss_score": 0.00145, "epss_percentile": 0.35422}, "CVE-2023-5134": {"epss_score": 0.00142, "epss_percentile": 0.35088}, "CVE-2023-5135": {"epss_score": 0.00196, "epss_percentile": 0.41775}, "CVE-2023-5136": {"epss_score": 0.0011, "epss_percentile": 0.3017}, "CVE-2023-5137": {"epss_score": 0.00105, "epss_percentile": 0.29397}, "CVE-2023-5138": {"epss_score": 0.00047, "epss_percentile": 0.14577}, "CVE-2023-5139": {"epss_score": 0.00265, "epss_percentile": 0.49771}, "CVE-2023-5140": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-5141": {"epss_score": 0.00372, "epss_percentile": 0.58434}, "CVE-2023-5142": {"epss_score": 0.00315, "epss_percentile": 0.54164}, "CVE-2023-5143": {"epss_score": 0.00446, "epss_percentile": 0.62917}, "CVE-2023-5144": {"epss_score": 0.0281, "epss_percentile": 0.85717}, "CVE-2023-5145": {"epss_score": 0.00318, "epss_percentile": 0.54399}, "CVE-2023-5146": {"epss_score": 0.01608, "epss_percentile": 0.81314}, "CVE-2023-5147": {"epss_score": 0.01055, "epss_percentile": 0.77118}, "CVE-2023-5148": {"epss_score": 0.02697, "epss_percentile": 0.85445}, "CVE-2023-5149": {"epss_score": 0.00538, "epss_percentile": 0.6694}, "CVE-2023-5150": {"epss_score": 0.00363, "epss_percentile": 0.57829}, "CVE-2023-5151": {"epss_score": 0.20381, "epss_percentile": 0.95336}, "CVE-2023-5152": {"epss_score": 0.00417, "epss_percentile": 0.61249}, "CVE-2023-5153": {"epss_score": 0.00425, "epss_percentile": 0.61718}, "CVE-2023-5154": {"epss_score": 0.76909, "epss_percentile": 0.98911}, "CVE-2023-5155": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-5156": {"epss_score": 0.00053, "epss_percentile": 0.16965}, "CVE-2023-5157": {"epss_score": 0.00274, "epss_percentile": 0.50514}, "CVE-2023-5158": {"epss_score": 0.00014, "epss_percentile": 0.01911}, "CVE-2023-5159": {"epss_score": 0.00034, "epss_percentile": 0.09711}, "CVE-2023-5160": {"epss_score": 0.00229, "epss_percentile": 0.45593}, "CVE-2023-5161": {"epss_score": 0.002, "epss_percentile": 0.42274}, "CVE-2023-5162": {"epss_score": 0.00155, "epss_percentile": 0.36862}, "CVE-2023-5163": {"epss_score": 0.00133, "epss_percentile": 0.33645}, "CVE-2023-5164": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-5165": {"epss_score": 0.00015, "epss_percentile": 0.02602}, "CVE-2023-5166": {"epss_score": 0.0018, "epss_percentile": 0.39925}, "CVE-2023-5167": {"epss_score": 0.00119, "epss_percentile": 0.31568}, "CVE-2023-5168": {"epss_score": 0.00256, "epss_percentile": 0.48823}, "CVE-2023-5169": {"epss_score": 0.0024, "epss_percentile": 0.46966}, "CVE-2023-5170": {"epss_score": 0.00233, "epss_percentile": 0.45981}, "CVE-2023-5171": {"epss_score": 0.0026, "epss_percentile": 0.49219}, "CVE-2023-5172": {"epss_score": 0.00322, "epss_percentile": 0.5482}, "CVE-2023-5173": {"epss_score": 0.00237, "epss_percentile": 0.46738}, "CVE-2023-5174": {"epss_score": 0.00367, "epss_percentile": 0.58109}, "CVE-2023-5175": {"epss_score": 0.00365, "epss_percentile": 0.58014}, "CVE-2023-5176": {"epss_score": 0.00704, "epss_percentile": 0.71567}, "CVE-2023-5177": {"epss_score": 0.00148, "epss_percentile": 0.35899}, "CVE-2023-5178": {"epss_score": 0.04072, "epss_percentile": 0.88207}, "CVE-2023-5179": {"epss_score": 0.00092, "epss_percentile": 0.26557}, "CVE-2023-5180": {"epss_score": 0.00038, "epss_percentile": 0.1118}, "CVE-2023-5181": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-5182": {"epss_score": 0.00032, "epss_percentile": 0.08743}, "CVE-2023-5183": {"epss_score": 0.006, "epss_percentile": 0.68829}, "CVE-2023-5184": {"epss_score": 0.00338, "epss_percentile": 0.56159}, "CVE-2023-5185": {"epss_score": 0.01427, "epss_percentile": 0.80208}, "CVE-2023-5186": {"epss_score": 0.01536, "epss_percentile": 0.80917}, "CVE-2023-5187": {"epss_score": 0.00279, "epss_percentile": 0.50956}, "CVE-2023-5188": {"epss_score": 0.00377, "epss_percentile": 0.58743}, "CVE-2023-5189": {"epss_score": 0.00323, "epss_percentile": 0.54918}, "CVE-2023-5190": {"epss_score": 0.00323, "epss_percentile": 0.54916}, "CVE-2023-5192": {"epss_score": 0.00012, "epss_percentile": 0.01358}, "CVE-2023-5193": {"epss_score": 0.00151, "epss_percentile": 0.36221}, "CVE-2023-5194": {"epss_score": 0.00028, "epss_percentile": 0.07259}, "CVE-2023-5195": {"epss_score": 0.0005, "epss_percentile": 0.15865}, "CVE-2023-5196": {"epss_score": 0.00167, "epss_percentile": 0.38306}, "CVE-2023-5197": {"epss_score": 0.00058, "epss_percentile": 0.18457}, "CVE-2023-5198": {"epss_score": 0.00049, "epss_percentile": 0.15469}, "CVE-2023-5199": {"epss_score": 0.04864, "epss_percentile": 0.89224}, "CVE-2023-5200": {"epss_score": 0.00142, "epss_percentile": 0.35079}, "CVE-2023-5201": {"epss_score": 0.07003, "epss_percentile": 0.91175}, "CVE-2023-5203": {"epss_score": 0.09062, "epss_percentile": 0.92384}, "CVE-2023-5204": {"epss_score": 0.34676, "epss_percentile": 0.96867}, "CVE-2023-5205": {"epss_score": 0.00229, "epss_percentile": 0.45606}, "CVE-2023-5207": {"epss_score": 0.00202, "epss_percentile": 0.42469}, "CVE-2023-5209": {"epss_score": 0.00095, "epss_percentile": 0.27085}, "CVE-2023-5210": {"epss_score": 0.00284, "epss_percentile": 0.51493}, "CVE-2023-5211": {"epss_score": 0.00245, "epss_percentile": 0.47673}, "CVE-2023-5212": {"epss_score": 0.00308, "epss_percentile": 0.53585}, "CVE-2023-5214": {"epss_score": 0.00173, "epss_percentile": 0.39091}, "CVE-2023-5215": {"epss_score": 0.00065, "epss_percentile": 0.20618}, "CVE-2023-5217": {"epss_score": 0.03578, "epss_percentile": 0.87381}, "CVE-2023-5218": {"epss_score": 0.00325, "epss_percentile": 0.54994}, "CVE-2023-5221": {"epss_score": 0.00202, "epss_percentile": 0.42433}, "CVE-2023-5222": {"epss_score": 0.89713, "epss_percentile": 0.99538}, "CVE-2023-5223": {"epss_score": 0.00199, "epss_percentile": 0.42134}, "CVE-2023-5226": {"epss_score": 0.00083, "epss_percentile": 0.2461}, "CVE-2023-5227": {"epss_score": 0.00405, "epss_percentile": 0.60487}, "CVE-2023-5228": {"epss_score": 0.01022, "epss_percentile": 0.76758}, "CVE-2023-5229": {"epss_score": 0.00179, "epss_percentile": 0.39838}, "CVE-2023-5230": {"epss_score": 0.00134, "epss_percentile": 0.33871}, "CVE-2023-5231": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5232": {"epss_score": 0.00154, "epss_percentile": 0.36684}, "CVE-2023-5233": {"epss_score": 0.00154, "epss_percentile": 0.36684}, "CVE-2023-5234": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2023-5235": {"epss_score": 0.00645, "epss_percentile": 0.70113}, "CVE-2023-5236": {"epss_score": 0.001, "epss_percentile": 0.28549}, "CVE-2023-5237": {"epss_score": 0.0049, "epss_percentile": 0.64932}, "CVE-2023-5238": {"epss_score": 0.00245, "epss_percentile": 0.47673}, "CVE-2023-5239": {"epss_score": 0.00032, "epss_percentile": 0.09034}, "CVE-2023-5240": {"epss_score": 0.00177, "epss_percentile": 0.39582}, "CVE-2023-5241": {"epss_score": 0.02449, "epss_percentile": 0.84776}, "CVE-2023-5243": {"epss_score": 0.00171, "epss_percentile": 0.38784}, "CVE-2023-5244": {"epss_score": 0.25862, "epss_percentile": 0.96086}, "CVE-2023-5245": {"epss_score": 0.00435, "epss_percentile": 0.6235}, "CVE-2023-5246": {"epss_score": 0.01589, "epss_percentile": 0.81197}, "CVE-2023-5247": {"epss_score": 0.00091, "epss_percentile": 0.26205}, "CVE-2023-5249": {"epss_score": 0.00128, "epss_percentile": 0.33027}, "CVE-2023-5250": {"epss_score": 0.00136, "epss_percentile": 0.34101}, "CVE-2023-5251": {"epss_score": 0.00049, "epss_percentile": 0.15564}, "CVE-2023-5252": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-5253": {"epss_score": 0.00242, "epss_percentile": 0.47394}, "CVE-2023-5254": {"epss_score": 0.00365, "epss_percentile": 0.57992}, "CVE-2023-5255": {"epss_score": 0.00136, "epss_percentile": 0.34188}, "CVE-2023-5256": {"epss_score": 0.01295, "epss_percentile": 0.79249}, "CVE-2023-5257": {"epss_score": 0.00032, "epss_percentile": 0.09075}, "CVE-2023-5258": {"epss_score": 0.00052, "epss_percentile": 0.16623}, "CVE-2023-5259": {"epss_score": 0.0004, "epss_percentile": 0.12174}, "CVE-2023-5260": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2023-5261": {"epss_score": 0.00115, "epss_percentile": 0.30983}, "CVE-2023-5262": {"epss_score": 0.00072, "epss_percentile": 0.22297}, "CVE-2023-5263": {"epss_score": 0.00079, "epss_percentile": 0.23812}, "CVE-2023-5264": {"epss_score": 0.00035, "epss_percentile": 0.09821}, "CVE-2023-5265": {"epss_score": 0.00062, "epss_percentile": 0.19735}, "CVE-2023-5266": {"epss_score": 0.00048, "epss_percentile": 0.15162}, "CVE-2023-5267": {"epss_score": 0.00046, "epss_percentile": 0.14173}, "CVE-2023-5268": {"epss_score": 0.00051, "epss_percentile": 0.16285}, "CVE-2023-5269": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5270": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5271": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5272": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5273": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-5274": {"epss_score": 0.00044, "epss_percentile": 0.13603}, "CVE-2023-5275": {"epss_score": 0.00044, "epss_percentile": 0.13603}, "CVE-2023-5276": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5277": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2023-5278": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-5279": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5280": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5281": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5282": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5283": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5284": {"epss_score": 0.00131, "epss_percentile": 0.33365}, "CVE-2023-5285": {"epss_score": 0.00043, "epss_percentile": 0.13001}, "CVE-2023-5286": {"epss_score": 0.00098, "epss_percentile": 0.27652}, "CVE-2023-5287": {"epss_score": 0.0005, "epss_percentile": 0.15974}, "CVE-2023-5288": {"epss_score": 0.00211, "epss_percentile": 0.43625}, "CVE-2023-5289": {"epss_score": 0.00076, "epss_percentile": 0.23258}, "CVE-2023-5291": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-5292": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2023-5293": {"epss_score": 0.00053, "epss_percentile": 0.16862}, "CVE-2023-5294": {"epss_score": 0.00051, "epss_percentile": 0.16285}, "CVE-2023-5295": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-5296": {"epss_score": 0.0005, "epss_percentile": 0.15877}, "CVE-2023-5297": {"epss_score": 0.0007, "epss_percentile": 0.21817}, "CVE-2023-5298": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-5299": {"epss_score": 0.00192, "epss_percentile": 0.41305}, "CVE-2023-5300": {"epss_score": 0.00043, "epss_percentile": 0.1328}, "CVE-2023-5301": {"epss_score": 0.00594, "epss_percentile": 0.68669}, "CVE-2023-5302": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-5303": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-5304": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-5305": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-5307": {"epss_score": 0.01022, "epss_percentile": 0.76762}, "CVE-2023-5308": {"epss_score": 0.00142, "epss_percentile": 0.35079}, "CVE-2023-5309": {"epss_score": 0.00289, "epss_percentile": 0.52003}, "CVE-2023-5310": {"epss_score": 0.0008, "epss_percentile": 0.24172}, "CVE-2023-5311": {"epss_score": 0.0659, "epss_percentile": 0.90871}, "CVE-2023-5313": {"epss_score": 0.00075, "epss_percentile": 0.22899}, "CVE-2023-5314": {"epss_score": 0.00053, "epss_percentile": 0.16688}, "CVE-2023-5315": {"epss_score": 0.00158, "epss_percentile": 0.37299}, "CVE-2023-5316": {"epss_score": 0.00287, "epss_percentile": 0.51838}, "CVE-2023-5317": {"epss_score": 0.00065, "epss_percentile": 0.20508}, "CVE-2023-5318": {"epss_score": 0.0033, "epss_percentile": 0.55431}, "CVE-2023-5319": {"epss_score": 0.00099, "epss_percentile": 0.27833}, "CVE-2023-5320": {"epss_score": 0.00544, "epss_percentile": 0.67127}, "CVE-2023-5321": {"epss_score": 0.00031, "epss_percentile": 0.08321}, "CVE-2023-5322": {"epss_score": 0.00434, "epss_percentile": 0.62315}, "CVE-2023-5323": {"epss_score": 0.00206, "epss_percentile": 0.43064}, "CVE-2023-5324": {"epss_score": 0.00062, "epss_percentile": 0.19561}, "CVE-2023-5325": {"epss_score": 0.00123, "epss_percentile": 0.32231}, "CVE-2023-5326": {"epss_score": 0.00056, "epss_percentile": 0.17929}, "CVE-2023-5327": {"epss_score": 0.00045, "epss_percentile": 0.13902}, "CVE-2023-5328": {"epss_score": 0.00056, "epss_percentile": 0.17929}, "CVE-2023-5329": {"epss_score": 0.00166, "epss_percentile": 0.38232}, "CVE-2023-5330": {"epss_score": 0.00118, "epss_percentile": 0.31458}, "CVE-2023-5331": {"epss_score": 0.00167, "epss_percentile": 0.38398}, "CVE-2023-5332": {"epss_score": 0.00021, "epss_percentile": 0.04711}, "CVE-2023-5333": {"epss_score": 0.00118, "epss_percentile": 0.31458}, "CVE-2023-5334": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5335": {"epss_score": 0.00078, "epss_percentile": 0.23571}, "CVE-2023-5336": {"epss_score": 0.00153, "epss_percentile": 0.36524}, "CVE-2023-5337": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5338": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-5339": {"epss_score": 0.00073, "epss_percentile": 0.22567}, "CVE-2023-5340": {"epss_score": 0.01033, "epss_percentile": 0.76876}, "CVE-2023-5341": {"epss_score": 0.00036, "epss_percentile": 0.10346}, "CVE-2023-5342": {"epss_score": 5e-05, "epss_percentile": 0.00214}, "CVE-2023-5343": {"epss_score": 0.00086, "epss_percentile": 0.25276}, "CVE-2023-5344": {"epss_score": 0.00057, "epss_percentile": 0.18195}, "CVE-2023-5345": {"epss_score": 0.00025, "epss_percentile": 0.063}, "CVE-2023-5346": {"epss_score": 0.01115, "epss_percentile": 0.77708}, "CVE-2023-5347": {"epss_score": 0.00287, "epss_percentile": 0.51807}, "CVE-2023-5348": {"epss_score": 0.00636, "epss_percentile": 0.69875}, "CVE-2023-5349": {"epss_score": 0.00044, "epss_percentile": 0.1351}, "CVE-2023-5350": {"epss_score": 0.15281, "epss_percentile": 0.94399}, "CVE-2023-5351": {"epss_score": 0.00126, "epss_percentile": 0.32631}, "CVE-2023-5352": {"epss_score": 0.00054, "epss_percentile": 0.17306}, "CVE-2023-5353": {"epss_score": 0.00065, "epss_percentile": 0.20609}, "CVE-2023-5354": {"epss_score": 0.0013, "epss_percentile": 0.33278}, "CVE-2023-5355": {"epss_score": 0.00167, "epss_percentile": 0.38275}, "CVE-2023-5356": {"epss_score": 0.00066, "epss_percentile": 0.2089}, "CVE-2023-5357": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-5358": {"epss_score": 0.0022, "epss_percentile": 0.44587}, "CVE-2023-5359": {"epss_score": 0.02378, "epss_percentile": 0.8456}, "CVE-2023-5360": {"epss_score": 0.93294, "epss_percentile": 0.99794}, "CVE-2023-5362": {"epss_score": 0.0009, "epss_percentile": 0.26131}, "CVE-2023-5363": {"epss_score": 0.04745, "epss_percentile": 0.89088}, "CVE-2023-5365": {"epss_score": 0.00479, "epss_percentile": 0.64431}, "CVE-2023-5366": {"epss_score": 0.0002, "epss_percentile": 0.04515}, "CVE-2023-5367": {"epss_score": 0.00064, "epss_percentile": 0.20316}, "CVE-2023-5368": {"epss_score": 0.00134, "epss_percentile": 0.33907}, "CVE-2023-5369": {"epss_score": 0.00078, "epss_percentile": 0.23753}, "CVE-2023-5370": {"epss_score": 0.00137, "epss_percentile": 0.34244}, "CVE-2023-5371": {"epss_score": 0.0005, "epss_percentile": 0.1595}, "CVE-2023-5372": {"epss_score": 0.10118, "epss_percentile": 0.92856}, "CVE-2023-5373": {"epss_score": 0.00059, "epss_percentile": 0.18834}, "CVE-2023-5374": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5375": {"epss_score": 0.41841, "epss_percentile": 0.97297}, "CVE-2023-5376": {"epss_score": 0.00346, "epss_percentile": 0.56622}, "CVE-2023-5377": {"epss_score": 0.00063, "epss_percentile": 0.20098}, "CVE-2023-5378": {"epss_score": 0.00115, "epss_percentile": 0.30884}, "CVE-2023-5379": {"epss_score": 0.00139, "epss_percentile": 0.34591}, "CVE-2023-5380": {"epss_score": 0.00082, "epss_percentile": 0.2441}, "CVE-2023-5381": {"epss_score": 0.00123, "epss_percentile": 0.32326}, "CVE-2023-5382": {"epss_score": 0.00052, "epss_percentile": 0.16541}, "CVE-2023-5383": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2023-5384": {"epss_score": 0.00414, "epss_percentile": 0.61037}, "CVE-2023-5385": {"epss_score": 0.0009, "epss_percentile": 0.26049}, "CVE-2023-5386": {"epss_score": 0.0009, "epss_percentile": 0.26049}, "CVE-2023-5387": {"epss_score": 0.0009, "epss_percentile": 0.26049}, "CVE-2023-5388": {"epss_score": 0.00166, "epss_percentile": 0.38188}, "CVE-2023-5389": {"epss_score": 0.00134, "epss_percentile": 0.33761}, "CVE-2023-5390": {"epss_score": 0.00155, "epss_percentile": 0.36763}, "CVE-2023-5391": {"epss_score": 0.00351, "epss_percentile": 0.56982}, "CVE-2023-5392": {"epss_score": 0.00109, "epss_percentile": 0.30022}, "CVE-2023-5393": {"epss_score": 0.01151, "epss_percentile": 0.78035}, "CVE-2023-5394": {"epss_score": 0.0085, "epss_percentile": 0.74384}, "CVE-2023-5395": {"epss_score": 0.01205, "epss_percentile": 0.78516}, "CVE-2023-5396": {"epss_score": 0.0085, "epss_percentile": 0.74384}, "CVE-2023-5397": {"epss_score": 0.00319, "epss_percentile": 0.54565}, "CVE-2023-5398": {"epss_score": 0.00046, "epss_percentile": 0.1412}, "CVE-2023-5399": {"epss_score": 0.25057, "epss_percentile": 0.95983}, "CVE-2023-5400": {"epss_score": 0.01625, "epss_percentile": 0.81421}, "CVE-2023-5401": {"epss_score": 0.01625, "epss_percentile": 0.81421}, "CVE-2023-5402": {"epss_score": 0.00275, "epss_percentile": 0.50667}, "CVE-2023-5403": {"epss_score": 0.01007, "epss_percentile": 0.7656}, "CVE-2023-5404": {"epss_score": 0.01007, "epss_percentile": 0.7656}, "CVE-2023-5405": {"epss_score": 0.00084, "epss_percentile": 0.24829}, "CVE-2023-5406": {"epss_score": 0.00614, "epss_percentile": 0.69285}, "CVE-2023-5407": {"epss_score": 0.00061, "epss_percentile": 0.19513}, "CVE-2023-5408": {"epss_score": 0.0052, "epss_percentile": 0.66204}, "CVE-2023-5409": {"epss_score": 0.00238, "epss_percentile": 0.46754}, "CVE-2023-5410": {"epss_score": 0.00026, "epss_percentile": 0.06437}, "CVE-2023-5411": {"epss_score": 0.0009, "epss_percentile": 0.26049}, "CVE-2023-5412": {"epss_score": 0.09758, "epss_percentile": 0.92692}, "CVE-2023-5413": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2023-5414": {"epss_score": 0.02089, "epss_percentile": 0.83563}, "CVE-2023-5415": {"epss_score": 0.0009, "epss_percentile": 0.26049}, "CVE-2023-5416": {"epss_score": 0.0009, "epss_percentile": 0.26049}, "CVE-2023-5417": {"epss_score": 0.0009, "epss_percentile": 0.26049}, "CVE-2023-5419": {"epss_score": 0.00117, "epss_percentile": 0.31374}, "CVE-2023-5421": {"epss_score": 0.00288, "epss_percentile": 0.51923}, "CVE-2023-5422": {"epss_score": 0.00189, "epss_percentile": 0.40942}, "CVE-2023-5423": {"epss_score": 0.00037, "epss_percentile": 0.10769}, "CVE-2023-5424": {"epss_score": 0.02493, "epss_percentile": 0.84901}, "CVE-2023-5425": {"epss_score": 0.00175, "epss_percentile": 0.39279}, "CVE-2023-5426": {"epss_score": 0.00154, "epss_percentile": 0.36734}, "CVE-2023-5427": {"epss_score": 0.00139, "epss_percentile": 0.34652}, "CVE-2023-5428": {"epss_score": 0.00224, "epss_percentile": 0.45042}, "CVE-2023-5429": {"epss_score": 0.00165, "epss_percentile": 0.38068}, "CVE-2023-5430": {"epss_score": 0.00182, "epss_percentile": 0.40252}, "CVE-2023-5431": {"epss_score": 0.00165, "epss_percentile": 0.38068}, "CVE-2023-5432": {"epss_score": 0.00101, "epss_percentile": 0.28616}, "CVE-2023-5433": {"epss_score": 0.00165, "epss_percentile": 0.38068}, "CVE-2023-5434": {"epss_score": 0.00255, "epss_percentile": 0.48736}, "CVE-2023-5435": {"epss_score": 0.003, "epss_percentile": 0.52961}, "CVE-2023-5436": {"epss_score": 0.00255, "epss_percentile": 0.48736}, "CVE-2023-5437": {"epss_score": 0.003, "epss_percentile": 0.52961}, "CVE-2023-5438": {"epss_score": 0.00255, "epss_percentile": 0.48736}, "CVE-2023-5439": {"epss_score": 0.00255, "epss_percentile": 0.48736}, "CVE-2023-5441": {"epss_score": 0.00019, "epss_percentile": 0.04181}, "CVE-2023-5443": {"epss_score": 0.00074, "epss_percentile": 0.2277}, "CVE-2023-5444": {"epss_score": 0.00337, "epss_percentile": 0.56037}, "CVE-2023-5445": {"epss_score": 0.00176, "epss_percentile": 0.39484}, "CVE-2023-5447": {"epss_score": 0.00074, "epss_percentile": 0.22877}, "CVE-2023-5448": {"epss_score": 0.00155, "epss_percentile": 0.3686}, "CVE-2023-5449": {"epss_score": 0.00066, "epss_percentile": 0.20749}, "CVE-2023-5450": {"epss_score": 0.00173, "epss_percentile": 0.39094}, "CVE-2023-5451": {"epss_score": 0.00174, "epss_percentile": 0.39227}, "CVE-2023-5452": {"epss_score": 0.00112, "epss_percentile": 0.30573}, "CVE-2023-5454": {"epss_score": 0.00827, "epss_percentile": 0.73987}, "CVE-2023-5455": {"epss_score": 0.00304, "epss_percentile": 0.53239}, "CVE-2023-5456": {"epss_score": 0.00598, "epss_percentile": 0.68761}, "CVE-2023-5457": {"epss_score": 0.00132, "epss_percentile": 0.3356}, "CVE-2023-5458": {"epss_score": 0.00178, "epss_percentile": 0.39654}, "CVE-2023-5459": {"epss_score": 0.00078, "epss_percentile": 0.23683}, "CVE-2023-5460": {"epss_score": 0.00043, "epss_percentile": 0.13186}, "CVE-2023-5461": {"epss_score": 0.00118, "epss_percentile": 0.31476}, "CVE-2023-5462": {"epss_score": 0.00147, "epss_percentile": 0.35655}, "CVE-2023-5463": {"epss_score": 0.00042, "epss_percentile": 0.12903}, "CVE-2023-5464": {"epss_score": 0.003, "epss_percentile": 0.52961}, "CVE-2023-5465": {"epss_score": 0.00275, "epss_percentile": 0.50673}, "CVE-2023-5466": {"epss_score": 0.00349, "epss_percentile": 0.56913}, "CVE-2023-5467": {"epss_score": 0.00156, "epss_percentile": 0.36975}, "CVE-2023-5468": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5469": {"epss_score": 0.00142, "epss_percentile": 0.35079}, "CVE-2023-5470": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-5471": {"epss_score": 0.001, "epss_percentile": 0.28525}, "CVE-2023-5472": {"epss_score": 0.0112, "epss_percentile": 0.77759}, "CVE-2023-5473": {"epss_score": 0.00413, "epss_percentile": 0.60965}, "CVE-2023-5474": {"epss_score": 0.00787, "epss_percentile": 0.73321}, "CVE-2023-5475": {"epss_score": 0.00044, "epss_percentile": 0.13476}, "CVE-2023-5476": {"epss_score": 0.00997, "epss_percentile": 0.76459}, "CVE-2023-5477": {"epss_score": 0.00035, "epss_percentile": 0.09965}, "CVE-2023-5478": {"epss_score": 0.00203, "epss_percentile": 0.42497}, "CVE-2023-5479": {"epss_score": 0.00051, "epss_percentile": 0.16134}, "CVE-2023-5480": {"epss_score": 0.00226, "epss_percentile": 0.45343}, "CVE-2023-5481": {"epss_score": 0.00267, "epss_percentile": 0.49988}, "CVE-2023-5482": {"epss_score": 0.13863, "epss_percentile": 0.94078}, "CVE-2023-5483": {"epss_score": 0.0011, "epss_percentile": 0.30189}, "CVE-2023-5484": {"epss_score": 0.00156, "epss_percentile": 0.36931}, "CVE-2023-5485": {"epss_score": 0.00054, "epss_percentile": 0.17089}, "CVE-2023-5486": {"epss_score": 0.00267, "epss_percentile": 0.49988}, "CVE-2023-5487": {"epss_score": 0.00034, "epss_percentile": 0.09626}, "CVE-2023-5488": {"epss_score": 0.00047, "epss_percentile": 0.14631}, "CVE-2023-5489": {"epss_score": 0.00064, "epss_percentile": 0.20387}, "CVE-2023-5490": {"epss_score": 0.00637, "epss_percentile": 0.69895}, "CVE-2023-5491": {"epss_score": 0.00083, "epss_percentile": 0.24806}, "CVE-2023-5492": {"epss_score": 0.00045, "epss_percentile": 0.13962}, "CVE-2023-5493": {"epss_score": 0.00637, "epss_percentile": 0.69895}, "CVE-2023-5494": {"epss_score": 0.01484, "epss_percentile": 0.80588}, "CVE-2023-5495": {"epss_score": 0.00187, "epss_percentile": 0.40735}, "CVE-2023-5496": {"epss_score": 0.00279, "epss_percentile": 0.50969}, "CVE-2023-5497": {"epss_score": 0.00134, "epss_percentile": 0.33755}, "CVE-2023-5498": {"epss_score": 0.00135, "epss_percentile": 0.34047}, "CVE-2023-5499": {"epss_score": 0.00264, "epss_percentile": 0.49682}, "CVE-2023-5500": {"epss_score": 0.00309, "epss_percentile": 0.53679}, "CVE-2023-5504": {"epss_score": 0.00527, "epss_percentile": 0.6644}, "CVE-2023-5505": {"epss_score": 0.00563, "epss_percentile": 0.67734}, "CVE-2023-5506": {"epss_score": 0.00064, "epss_percentile": 0.20148}, "CVE-2023-5507": {"epss_score": 0.00134, "epss_percentile": 0.33786}, "CVE-2023-5509": {"epss_score": 0.00052, "epss_percentile": 0.16592}, "CVE-2023-5511": {"epss_score": 0.0011, "epss_percentile": 0.30194}, "CVE-2023-5512": {"epss_score": 0.00386, "epss_percentile": 0.59286}, "CVE-2023-5514": {"epss_score": 0.00288, "epss_percentile": 0.51874}, "CVE-2023-5515": {"epss_score": 0.00264, "epss_percentile": 0.4958}, "CVE-2023-5516": {"epss_score": 0.00264, "epss_percentile": 0.4958}, "CVE-2023-5517": {"epss_score": 0.00143, "epss_percentile": 0.35196}, "CVE-2023-5519": {"epss_score": 0.00153, "epss_percentile": 0.36567}, "CVE-2023-5520": {"epss_score": 0.00013, "epss_percentile": 0.01662}, "CVE-2023-5521": {"epss_score": 0.0057, "epss_percentile": 0.67971}, "CVE-2023-5522": {"epss_score": 0.00085, "epss_percentile": 0.25053}, "CVE-2023-5523": {"epss_score": 0.00548, "epss_percentile": 0.67285}, "CVE-2023-5524": {"epss_score": 0.0085, "epss_percentile": 0.74387}, "CVE-2023-5525": {"epss_score": 0.00067, "epss_percentile": 0.20971}, "CVE-2023-5527": {"epss_score": 0.00527, "epss_percentile": 0.66451}, "CVE-2023-5528": {"epss_score": 0.18507, "epss_percentile": 0.95025}, "CVE-2023-5529": {"epss_score": 0.00058, "epss_percentile": 0.18522}, "CVE-2023-5530": {"epss_score": 0.01481, "epss_percentile": 0.80568}, "CVE-2023-5531": {"epss_score": 0.00069, "epss_percentile": 0.21594}, "CVE-2023-5532": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2023-5533": {"epss_score": 0.00362, "epss_percentile": 0.57752}, "CVE-2023-5534": {"epss_score": 0.0006, "epss_percentile": 0.18966}, "CVE-2023-5535": {"epss_score": 0.00025, "epss_percentile": 0.06116}, "CVE-2023-5536": {"epss_score": 0.00042, "epss_percentile": 0.12725}, "CVE-2023-5537": {"epss_score": 0.0012, "epss_percentile": 0.31732}, "CVE-2023-5538": {"epss_score": 0.11199, "epss_percentile": 0.93262}, "CVE-2023-5539": {"epss_score": 0.01832, "epss_percentile": 0.82455}, "CVE-2023-5540": {"epss_score": 0.01832, "epss_percentile": 0.82455}, "CVE-2023-5541": {"epss_score": 0.00102, "epss_percentile": 0.28876}, "CVE-2023-5542": {"epss_score": 0.00268, "epss_percentile": 0.50097}, "CVE-2023-5543": {"epss_score": 0.00088, "epss_percentile": 0.25662}, "CVE-2023-5544": {"epss_score": 0.0013, "epss_percentile": 0.33298}, "CVE-2023-5545": {"epss_score": 0.00277, "epss_percentile": 0.50807}, "CVE-2023-5546": {"epss_score": 0.01307, "epss_percentile": 0.79337}, "CVE-2023-5547": {"epss_score": 0.00102, "epss_percentile": 0.28876}, "CVE-2023-5548": {"epss_score": 0.00277, "epss_percentile": 0.50807}, "CVE-2023-5549": {"epss_score": 0.00256, "epss_percentile": 0.48779}, "CVE-2023-5550": {"epss_score": 0.01066, "epss_percentile": 0.77219}, "CVE-2023-5551": {"epss_score": 0.00073, "epss_percentile": 0.22528}, "CVE-2023-5552": {"epss_score": 0.00068, "epss_percentile": 0.21208}, "CVE-2023-5553": {"epss_score": 0.00032, "epss_percentile": 0.08836}, "CVE-2023-5554": {"epss_score": 0.00145, "epss_percentile": 0.35486}, "CVE-2023-5555": {"epss_score": 0.00085, "epss_percentile": 0.25101}, "CVE-2023-5556": {"epss_score": 0.27733, "epss_percentile": 0.96277}, "CVE-2023-5557": {"epss_score": 0.00045, "epss_percentile": 0.13945}, "CVE-2023-5558": {"epss_score": 0.03127, "epss_percentile": 0.86459}, "CVE-2023-5559": {"epss_score": 0.45222, "epss_percentile": 0.97477}, "CVE-2023-5560": {"epss_score": 0.00576, "epss_percentile": 0.68141}, "CVE-2023-5561": {"epss_score": 0.64871, "epss_percentile": 0.98396}, "CVE-2023-5562": {"epss_score": 0.00131, "epss_percentile": 0.33425}, "CVE-2023-5563": {"epss_score": 0.00186, "epss_percentile": 0.40677}, "CVE-2023-5564": {"epss_score": 0.00053, "epss_percentile": 0.16942}, "CVE-2023-5565": {"epss_score": 0.00084, "epss_percentile": 0.25008}, "CVE-2023-5566": {"epss_score": 0.00098, "epss_percentile": 0.27763}, "CVE-2023-5567": {"epss_score": 0.00134, "epss_percentile": 0.33786}, "CVE-2023-5568": {"epss_score": 0.06053, "epss_percentile": 0.90436}, "CVE-2023-5570": {"epss_score": 0.00074, "epss_percentile": 0.2277}, "CVE-2023-5571": {"epss_score": 0.00049, "epss_percentile": 0.15322}, "CVE-2023-5572": {"epss_score": 0.00229, "epss_percentile": 0.45597}, "CVE-2023-5573": {"epss_score": 0.00038, "epss_percentile": 0.11112}, "CVE-2023-5574": {"epss_score": 0.00035, "epss_percentile": 0.09849}, "CVE-2023-5575": {"epss_score": 0.00302, "epss_percentile": 0.53166}, "CVE-2023-5576": {"epss_score": 0.00729, "epss_percentile": 0.72123}, "CVE-2023-5577": {"epss_score": 0.00141, "epss_percentile": 0.34908}, "CVE-2023-5578": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2023-5579": {"epss_score": 0.00044, "epss_percentile": 0.13626}, "CVE-2023-5580": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-5581": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-5582": {"epss_score": 0.00095, "epss_percentile": 0.27156}, "CVE-2023-5583": {"epss_score": 0.00521, "epss_percentile": 0.66241}, "CVE-2023-5585": {"epss_score": 0.00045, "epss_percentile": 0.13959}, "CVE-2023-5586": {"epss_score": 0.00034, "epss_percentile": 0.09728}, "CVE-2023-5587": {"epss_score": 0.00115, "epss_percentile": 0.31033}, "CVE-2023-5588": {"epss_score": 0.00528, "epss_percentile": 0.66553}, "CVE-2023-5589": {"epss_score": 0.00133, "epss_percentile": 0.3374}, "CVE-2023-5590": {"epss_score": 0.00114, "epss_percentile": 0.3081}, "CVE-2023-5591": {"epss_score": 0.00138, "epss_percentile": 0.34376}, "CVE-2023-5592": {"epss_score": 0.00144, "epss_percentile": 0.35242}, "CVE-2023-5593": {"epss_score": 0.00065, "epss_percentile": 0.20613}, "CVE-2023-5594": {"epss_score": 0.00102, "epss_percentile": 0.28824}, "CVE-2023-5595": {"epss_score": 0.00032, "epss_percentile": 0.08733}, "CVE-2023-5597": {"epss_score": 0.0023, "epss_percentile": 0.45707}, "CVE-2023-5598": {"epss_score": 0.00184, "epss_percentile": 0.40406}, "CVE-2023-5599": {"epss_score": 0.00471, "epss_percentile": 0.64005}, "CVE-2023-5600": {"epss_score": 0.00036, "epss_percentile": 0.10314}, "CVE-2023-5601": {"epss_score": 0.00806, "epss_percentile": 0.73648}, "CVE-2023-5602": {"epss_score": 0.00104, "epss_percentile": 0.29198}, "CVE-2023-5604": {"epss_score": 0.06992, "epss_percentile": 0.91168}, "CVE-2023-5605": {"epss_score": 0.00089, "epss_percentile": 0.2581}, "CVE-2023-5606": {"epss_score": 0.00101, "epss_percentile": 0.28573}, "CVE-2023-5607": {"epss_score": 0.00515, "epss_percentile": 0.65999}, "CVE-2023-5609": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-5610": {"epss_score": 0.00083, "epss_percentile": 0.24748}, "CVE-2023-5611": {"epss_score": 0.00097, "epss_percentile": 0.27485}, "CVE-2023-5612": {"epss_score": 0.32415, "epss_percentile": 0.96698}, "CVE-2023-5613": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-5614": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-5615": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5616": {"epss_score": 0.00027, "epss_percentile": 0.07109}, "CVE-2023-5617": {"epss_score": 0.00356, "epss_percentile": 0.57352}, "CVE-2023-5618": {"epss_score": 0.00122, "epss_percentile": 0.32157}, "CVE-2023-5620": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-5621": {"epss_score": 0.00155, "epss_percentile": 0.36782}, "CVE-2023-5622": {"epss_score": 0.00056, "epss_percentile": 0.17751}, "CVE-2023-5623": {"epss_score": 0.00057, "epss_percentile": 0.18201}, "CVE-2023-5624": {"epss_score": 0.00086, "epss_percentile": 0.25396}, "CVE-2023-5625": {"epss_score": 0.00075, "epss_percentile": 0.23032}, "CVE-2023-5626": {"epss_score": 0.0005, "epss_percentile": 0.15702}, "CVE-2023-5627": {"epss_score": 0.00077, "epss_percentile": 0.23367}, "CVE-2023-5629": {"epss_score": 0.00175, "epss_percentile": 0.39351}, "CVE-2023-5630": {"epss_score": 0.00097, "epss_percentile": 0.27629}, "CVE-2023-5631": {"epss_score": 0.84504, "epss_percentile": 0.99292}, "CVE-2023-5632": {"epss_score": 0.00091, "epss_percentile": 0.26204}, "CVE-2023-5633": {"epss_score": 0.00015, "epss_percentile": 0.02226}, "CVE-2023-5634": {"epss_score": 0.00114, "epss_percentile": 0.30865}, "CVE-2023-5635": {"epss_score": 0.00272, "epss_percentile": 0.50351}, "CVE-2023-5636": {"epss_score": 0.00509, "epss_percentile": 0.65721}, "CVE-2023-5637": {"epss_score": 0.00235, "epss_percentile": 0.46207}, "CVE-2023-5638": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-5639": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-5640": {"epss_score": 0.00371, "epss_percentile": 0.58418}, "CVE-2023-5641": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-5642": {"epss_score": 0.01021, "epss_percentile": 0.76749}, "CVE-2023-5643": {"epss_score": 0.00146, "epss_percentile": 0.35625}, "CVE-2023-5644": {"epss_score": 0.00117, "epss_percentile": 0.31229}, "CVE-2023-5645": {"epss_score": 0.00224, "epss_percentile": 0.45019}, "CVE-2023-5650": {"epss_score": 0.00021, "epss_percentile": 0.04912}, "CVE-2023-5651": {"epss_score": 0.00041, "epss_percentile": 0.12407}, "CVE-2023-5652": {"epss_score": 0.18471, "epss_percentile": 0.95019}, "CVE-2023-5653": {"epss_score": 0.00576, "epss_percentile": 0.68141}, "CVE-2023-5654": {"epss_score": 0.00092, "epss_percentile": 0.26427}, "CVE-2023-5658": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5659": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5660": {"epss_score": 0.00167, "epss_percentile": 0.38389}, "CVE-2023-5661": {"epss_score": 0.0012, "epss_percentile": 0.3177}, "CVE-2023-5662": {"epss_score": 0.00166, "epss_percentile": 0.38251}, "CVE-2023-5663": {"epss_score": 0.00304, "epss_percentile": 0.5327}, "CVE-2023-5664": {"epss_score": 0.00133, "epss_percentile": 0.33699}, "CVE-2023-5665": {"epss_score": 0.00463, "epss_percentile": 0.6369}, "CVE-2023-5666": {"epss_score": 0.00087, "epss_percentile": 0.25501}, "CVE-2023-5667": {"epss_score": 0.00142, "epss_percentile": 0.35079}, "CVE-2023-5668": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2023-5669": {"epss_score": 0.0014, "epss_percentile": 0.34702}, "CVE-2023-5671": {"epss_score": 0.00188, "epss_percentile": 0.40872}, "CVE-2023-5672": {"epss_score": 0.00314, "epss_percentile": 0.54094}, "CVE-2023-5673": {"epss_score": 0.01385, "epss_percentile": 0.79909}, "CVE-2023-5674": {"epss_score": 0.1104, "epss_percentile": 0.93198}, "CVE-2023-5675": {"epss_score": 0.00099, "epss_percentile": 0.28311}, "CVE-2023-5676": {"epss_score": 0.00039, "epss_percentile": 0.11764}, "CVE-2023-5677": {"epss_score": 0.00074, "epss_percentile": 0.22703}, "CVE-2023-5678": {"epss_score": 0.00638, "epss_percentile": 0.69911}, "CVE-2023-5679": {"epss_score": 0.00143, "epss_percentile": 0.35196}, "CVE-2023-5680": {"epss_score": 0.00105, "epss_percentile": 0.29295}, "CVE-2023-5681": {"epss_score": 0.00126, "epss_percentile": 0.32753}, "CVE-2023-5682": {"epss_score": 0.00134, "epss_percentile": 0.33755}, "CVE-2023-5683": {"epss_score": 0.17851, "epss_percentile": 0.94916}, "CVE-2023-5684": {"epss_score": 0.07942, "epss_percentile": 0.91781}, "CVE-2023-5685": {"epss_score": 0.00474, "epss_percentile": 0.64156}, "CVE-2023-5686": {"epss_score": 0.00084, "epss_percentile": 0.24998}, "CVE-2023-5687": {"epss_score": 0.00134, "epss_percentile": 0.33906}, "CVE-2023-5688": {"epss_score": 0.00187, "epss_percentile": 0.40751}, "CVE-2023-5689": {"epss_score": 0.00187, "epss_percentile": 0.40751}, "CVE-2023-5690": {"epss_score": 0.00429, "epss_percentile": 0.61996}, "CVE-2023-5691": {"epss_score": 0.00181, "epss_percentile": 0.40058}, "CVE-2023-5692": {"epss_score": 0.00655, "epss_percentile": 0.70411}, "CVE-2023-5693": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-5694": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-5695": {"epss_score": 0.00095, "epss_percentile": 0.27156}, "CVE-2023-5696": {"epss_score": 0.00093, "epss_percentile": 0.26711}, "CVE-2023-5697": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-5698": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-5699": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-5700": {"epss_score": 0.00057, "epss_percentile": 0.1821}, "CVE-2023-5701": {"epss_score": 0.00079, "epss_percentile": 0.23969}, "CVE-2023-5702": {"epss_score": 0.29373, "epss_percentile": 0.96436}, "CVE-2023-5703": {"epss_score": 0.00134, "epss_percentile": 0.33911}, "CVE-2023-5704": {"epss_score": 0.00138, "epss_percentile": 0.34527}, "CVE-2023-5705": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2023-5706": {"epss_score": 0.00134, "epss_percentile": 0.33748}, "CVE-2023-5707": {"epss_score": 0.00087, "epss_percentile": 0.25501}, "CVE-2023-5708": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5709": {"epss_score": 0.0024, "epss_percentile": 0.46943}, "CVE-2023-5710": {"epss_score": 0.00197, "epss_percentile": 0.41868}, "CVE-2023-5711": {"epss_score": 0.00197, "epss_percentile": 0.41868}, "CVE-2023-5712": {"epss_score": 0.00197, "epss_percentile": 0.41868}, "CVE-2023-5713": {"epss_score": 0.00281, "epss_percentile": 0.51152}, "CVE-2023-5714": {"epss_score": 0.00197, "epss_percentile": 0.41868}, "CVE-2023-5715": {"epss_score": 0.00268, "epss_percentile": 0.50053}, "CVE-2023-5716": {"epss_score": 0.00886, "epss_percentile": 0.74951}, "CVE-2023-5717": {"epss_score": 0.00249, "epss_percentile": 0.48076}, "CVE-2023-5718": {"epss_score": 0.00065, "epss_percentile": 0.20531}, "CVE-2023-5719": {"epss_score": 0.0009, "epss_percentile": 0.26039}, "CVE-2023-5720": {"epss_score": 0.02423, "epss_percentile": 0.84709}, "CVE-2023-5721": {"epss_score": 0.00284, "epss_percentile": 0.5146}, "CVE-2023-5722": {"epss_score": 0.00166, "epss_percentile": 0.38171}, "CVE-2023-5723": {"epss_score": 0.00218, "epss_percentile": 0.44336}, "CVE-2023-5724": {"epss_score": 0.00765, "epss_percentile": 0.72923}, "CVE-2023-5725": {"epss_score": 0.00382, "epss_percentile": 0.59059}, "CVE-2023-5726": {"epss_score": 0.00173, "epss_percentile": 0.39119}, "CVE-2023-5727": {"epss_score": 0.00162, "epss_percentile": 0.3772}, "CVE-2023-5728": {"epss_score": 0.00483, "epss_percentile": 0.64589}, "CVE-2023-5729": {"epss_score": 0.00159, "epss_percentile": 0.37418}, "CVE-2023-5730": {"epss_score": 0.00451, "epss_percentile": 0.63107}, "CVE-2023-5731": {"epss_score": 0.00398, "epss_percentile": 0.60062}, "CVE-2023-5732": {"epss_score": 0.00294, "epss_percentile": 0.5237}, "CVE-2023-5737": {"epss_score": 0.00067, "epss_percentile": 0.20971}, "CVE-2023-5738": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-5739": {"epss_score": 0.0011, "epss_percentile": 0.30239}, "CVE-2023-5740": {"epss_score": 0.00156, "epss_percentile": 0.36975}, "CVE-2023-5741": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2023-5742": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-5743": {"epss_score": 0.00193, "epss_percentile": 0.41495}, "CVE-2023-5744": {"epss_score": 0.0014, "epss_percentile": 0.34702}, "CVE-2023-5745": {"epss_score": 0.00083, "epss_percentile": 0.24799}, "CVE-2023-5746": {"epss_score": 0.05887, "epss_percentile": 0.90296}, "CVE-2023-5747": {"epss_score": 0.00341, "epss_percentile": 0.56323}, "CVE-2023-5748": {"epss_score": 0.00093, "epss_percentile": 0.26649}, "CVE-2023-5749": {"epss_score": 0.0146, "epss_percentile": 0.80416}, "CVE-2023-5750": {"epss_score": 0.00136, "epss_percentile": 0.34099}, "CVE-2023-5751": {"epss_score": 0.00097, "epss_percentile": 0.27622}, "CVE-2023-5752": {"epss_score": 0.00075, "epss_percentile": 0.22992}, "CVE-2023-5753": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2023-5754": {"epss_score": 0.0008, "epss_percentile": 0.24167}, "CVE-2023-5756": {"epss_score": 0.00049, "epss_percentile": 0.1532}, "CVE-2023-5757": {"epss_score": 0.00093, "epss_percentile": 0.26698}, "CVE-2023-5758": {"epss_score": 0.00297, "epss_percentile": 0.52741}, "CVE-2023-5759": {"epss_score": 0.0026, "epss_percentile": 0.49188}, "CVE-2023-5760": {"epss_score": 0.00098, "epss_percentile": 0.27828}, "CVE-2023-5761": {"epss_score": 0.00506, "epss_percentile": 0.65635}, "CVE-2023-5762": {"epss_score": 0.14237, "epss_percentile": 0.94169}, "CVE-2023-5763": {"epss_score": 0.00154, "epss_percentile": 0.36654}, "CVE-2023-5764": {"epss_score": 0.00071, "epss_percentile": 0.21992}, "CVE-2023-5765": {"epss_score": 0.00086, "epss_percentile": 0.25415}, "CVE-2023-5766": {"epss_score": 0.0054, "epss_percentile": 0.67013}, "CVE-2023-5767": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2023-5768": {"epss_score": 0.0007, "epss_percentile": 0.21657}, "CVE-2023-5769": {"epss_score": 0.001, "epss_percentile": 0.28448}, "CVE-2023-5770": {"epss_score": 0.00217, "epss_percentile": 0.44334}, "CVE-2023-5771": {"epss_score": 0.00152, "epss_percentile": 0.36416}, "CVE-2023-5772": {"epss_score": 0.00125, "epss_percentile": 0.32471}, "CVE-2023-5774": {"epss_score": 0.0009, "epss_percentile": 0.26131}, "CVE-2023-5775": {"epss_score": 0.00162, "epss_percentile": 0.37722}, "CVE-2023-5776": {"epss_score": 0.00111, "epss_percentile": 0.30344}, "CVE-2023-5777": {"epss_score": 0.00132, "epss_percentile": 0.33618}, "CVE-2023-5779": {"epss_score": 0.00095, "epss_percentile": 0.27213}, "CVE-2023-5780": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2023-5781": {"epss_score": 0.00062, "epss_percentile": 0.19681}, "CVE-2023-5782": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-5783": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-5784": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-5785": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-5786": {"epss_score": 0.00103, "epss_percentile": 0.29012}, "CVE-2023-5787": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-5789": {"epss_score": 0.00055, "epss_percentile": 0.17586}, "CVE-2023-5790": {"epss_score": 0.00079, "epss_percentile": 0.23812}, "CVE-2023-5791": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-5792": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-5793": {"epss_score": 0.00064, "epss_percentile": 0.20195}, "CVE-2023-5794": {"epss_score": 0.00048, "epss_percentile": 0.14973}, "CVE-2023-5795": {"epss_score": 0.00079, "epss_percentile": 0.23812}, "CVE-2023-5796": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2023-5797": {"epss_score": 0.00051, "epss_percentile": 0.16243}, "CVE-2023-5798": {"epss_score": 0.0023, "epss_percentile": 0.45712}, "CVE-2023-5799": {"epss_score": 0.00048, "epss_percentile": 0.15106}, "CVE-2023-5800": {"epss_score": 0.00173, "epss_percentile": 0.39134}, "CVE-2023-5801": {"epss_score": 0.00056, "epss_percentile": 0.17665}, "CVE-2023-5802": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2023-5803": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2023-5804": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2023-5805": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-5806": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-5807": {"epss_score": 0.0006, "epss_percentile": 0.18937}, "CVE-2023-5808": {"epss_score": 0.00293, "epss_percentile": 0.52353}, "CVE-2023-5809": {"epss_score": 0.00198, "epss_percentile": 0.4205}, "CVE-2023-5810": {"epss_score": 0.00064, "epss_percentile": 0.20401}, "CVE-2023-5811": {"epss_score": 0.00055, "epss_percentile": 0.17586}, "CVE-2023-5812": {"epss_score": 0.00062, "epss_percentile": 0.19591}, "CVE-2023-5813": {"epss_score": 0.00037, "epss_percentile": 0.10915}, "CVE-2023-5814": {"epss_score": 0.00037, "epss_percentile": 0.10915}, "CVE-2023-5815": {"epss_score": 0.48206, "epss_percentile": 0.97626}, "CVE-2023-5816": {"epss_score": 0.00347, "epss_percentile": 0.56789}, "CVE-2023-5817": {"epss_score": 0.0009, "epss_percentile": 0.26131}, "CVE-2023-5818": {"epss_score": 0.00097, "epss_percentile": 0.27505}, "CVE-2023-5819": {"epss_score": 0.00174, "epss_percentile": 0.39166}, "CVE-2023-5820": {"epss_score": 0.00102, "epss_percentile": 0.28834}, "CVE-2023-5821": {"epss_score": 0.00071, "epss_percentile": 0.22012}, "CVE-2023-5822": {"epss_score": 0.04403, "epss_percentile": 0.88648}, "CVE-2023-5823": {"epss_score": 0.00105, "epss_percentile": 0.29308}, "CVE-2023-5824": {"epss_score": 0.01557, "epss_percentile": 0.8102}, "CVE-2023-5825": {"epss_score": 0.00132, "epss_percentile": 0.33587}, "CVE-2023-5826": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5827": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2023-5828": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2023-5829": {"epss_score": 0.00079, "epss_percentile": 0.23812}, "CVE-2023-5830": {"epss_score": 0.90788, "epss_percentile": 0.996}, "CVE-2023-5831": {"epss_score": 0.00058, "epss_percentile": 0.1858}, "CVE-2023-5832": {"epss_score": 0.00067, "epss_percentile": 0.21068}, "CVE-2023-5833": {"epss_score": 0.00101, "epss_percentile": 0.28569}, "CVE-2023-5834": {"epss_score": 0.00083, "epss_percentile": 0.24814}, "CVE-2023-5835": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2023-5836": {"epss_score": 0.00037, "epss_percentile": 0.10915}, "CVE-2023-5837": {"epss_score": 0.00064, "epss_percentile": 0.20195}, "CVE-2023-5838": {"epss_score": 0.0004, "epss_percentile": 0.12085}, "CVE-2023-5839": {"epss_score": 0.00028, "epss_percentile": 0.07493}, "CVE-2023-5840": {"epss_score": 0.00084, "epss_percentile": 0.24911}, "CVE-2023-5841": {"epss_score": 0.00804, "epss_percentile": 0.73613}, "CVE-2023-5842": {"epss_score": 0.00109, "epss_percentile": 0.29988}, "CVE-2023-5843": {"epss_score": 0.0914, "epss_percentile": 0.92418}, "CVE-2023-5844": {"epss_score": 2e-05, "epss_percentile": 0.00028}, "CVE-2023-5845": {"epss_score": 0.00147, "epss_percentile": 0.35651}, "CVE-2023-5846": {"epss_score": 0.00032, "epss_percentile": 0.09104}, "CVE-2023-5847": {"epss_score": 0.00051, "epss_percentile": 0.16149}, "CVE-2023-5849": {"epss_score": 0.01138, "epss_percentile": 0.77934}, "CVE-2023-5850": {"epss_score": 0.00864, "epss_percentile": 0.746}, "CVE-2023-5851": {"epss_score": 0.00317, "epss_percentile": 0.54328}, "CVE-2023-5852": {"epss_score": 0.00662, "epss_percentile": 0.70602}, "CVE-2023-5853": {"epss_score": 0.00668, "epss_percentile": 0.70736}, "CVE-2023-5854": {"epss_score": 0.00662, "epss_percentile": 0.70602}, "CVE-2023-5855": {"epss_score": 0.00662, "epss_percentile": 0.70602}, "CVE-2023-5856": {"epss_score": 0.00662, "epss_percentile": 0.70602}, "CVE-2023-5857": {"epss_score": 0.01245, "epss_percentile": 0.78841}, "CVE-2023-5858": {"epss_score": 0.00707, "epss_percentile": 0.71651}, "CVE-2023-5859": {"epss_score": 0.00668, "epss_percentile": 0.70736}, "CVE-2023-5860": {"epss_score": 0.05389, "epss_percentile": 0.89824}, "CVE-2023-5861": {"epss_score": 0.00067, "epss_percentile": 0.21185}, "CVE-2023-5862": {"epss_score": 0.00028, "epss_percentile": 0.07543}, "CVE-2023-5863": {"epss_score": 0.05371, "epss_percentile": 0.89794}, "CVE-2023-5864": {"epss_score": 0.00082, "epss_percentile": 0.24569}, "CVE-2023-5865": {"epss_score": 0.0032, "epss_percentile": 0.5462}, "CVE-2023-5866": {"epss_score": 0.00027, "epss_percentile": 0.07119}, "CVE-2023-5867": {"epss_score": 0.00088, "epss_percentile": 0.25723}, "CVE-2023-5868": {"epss_score": 0.02718, "epss_percentile": 0.85513}, "CVE-2023-5869": {"epss_score": 0.01652, "epss_percentile": 0.81572}, "CVE-2023-5870": {"epss_score": 0.00645, "epss_percentile": 0.70125}, "CVE-2023-5871": {"epss_score": 0.00098, "epss_percentile": 0.27829}, "CVE-2023-5873": {"epss_score": 4e-05, "epss_percentile": 0.00128}, "CVE-2023-5874": {"epss_score": 0.00198, "epss_percentile": 0.4205}, "CVE-2023-5875": {"epss_score": 0.00166, "epss_percentile": 0.38233}, "CVE-2023-5876": {"epss_score": 0.00118, "epss_percentile": 0.31458}, "CVE-2023-5877": {"epss_score": 0.00447, "epss_percentile": 0.62939}, "CVE-2023-5878": {"epss_score": 0.01394, "epss_percentile": 0.7997}, "CVE-2023-5879": {"epss_score": 0.00183, "epss_percentile": 0.40317}, "CVE-2023-5880": {"epss_score": 0.00688, "epss_percentile": 0.7121}, "CVE-2023-5881": {"epss_score": 0.00222, "epss_percentile": 0.44728}, "CVE-2023-5882": {"epss_score": 0.00756, "epss_percentile": 0.72728}, "CVE-2023-5884": {"epss_score": 0.00164, "epss_percentile": 0.37902}, "CVE-2023-5885": {"epss_score": 0.00142, "epss_percentile": 0.35084}, "CVE-2023-5886": {"epss_score": 0.00748, "epss_percentile": 0.72584}, "CVE-2023-5889": {"epss_score": 0.00052, "epss_percentile": 0.16467}, "CVE-2023-5890": {"epss_score": 0.00081, "epss_percentile": 0.24298}, "CVE-2023-5891": {"epss_score": 0.00081, "epss_percentile": 0.24298}, "CVE-2023-5892": {"epss_score": 0.00081, "epss_percentile": 0.24298}, "CVE-2023-5893": {"epss_score": 0.0005, "epss_percentile": 0.15702}, "CVE-2023-5894": {"epss_score": 0.0007, "epss_percentile": 0.21936}, "CVE-2023-5895": {"epss_score": 0.0007, "epss_percentile": 0.21936}, "CVE-2023-5896": {"epss_score": 0.00065, "epss_percentile": 0.20439}, "CVE-2023-5897": {"epss_score": 0.00067, "epss_percentile": 0.2097}, "CVE-2023-5898": {"epss_score": 0.0005, "epss_percentile": 0.15702}, "CVE-2023-5899": {"epss_score": 0.0005, "epss_percentile": 0.15702}, "CVE-2023-5900": {"epss_score": 0.00133, "epss_percentile": 0.3372}, "CVE-2023-5901": {"epss_score": 0.00153, "epss_percentile": 0.36532}, "CVE-2023-5902": {"epss_score": 0.00152, "epss_percentile": 0.36427}, "CVE-2023-5903": {"epss_score": 0.00319, "epss_percentile": 0.54548}, "CVE-2023-5904": {"epss_score": 0.00307, "epss_percentile": 0.53516}, "CVE-2023-5905": {"epss_score": 0.0022, "epss_percentile": 0.44571}, "CVE-2023-5906": {"epss_score": 0.00295, "epss_percentile": 0.52511}, "CVE-2023-5907": {"epss_score": 0.0036, "epss_percentile": 0.57687}, "CVE-2023-5908": {"epss_score": 0.00036, "epss_percentile": 0.1027}, "CVE-2023-5909": {"epss_score": 0.00077, "epss_percentile": 0.2337}, "CVE-2023-5910": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2023-5911": {"epss_score": 0.00198, "epss_percentile": 0.4205}, "CVE-2023-5912": {"epss_score": 0.00024, "epss_percentile": 0.05962}, "CVE-2023-5913": {"epss_score": 0.00218, "epss_percentile": 0.444}, "CVE-2023-5914": {"epss_score": 0.74026, "epss_percentile": 0.98783}, "CVE-2023-5915": {"epss_score": 0.00425, "epss_percentile": 0.61694}, "CVE-2023-5916": {"epss_score": 0.00048, "epss_percentile": 0.14978}, "CVE-2023-5917": {"epss_score": 0.00086, "epss_percentile": 0.25385}, "CVE-2023-5918": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2023-5919": {"epss_score": 0.00062, "epss_percentile": 0.19727}, "CVE-2023-5920": {"epss_score": 0.00078, "epss_percentile": 0.23788}, "CVE-2023-5921": {"epss_score": 0.00017, "epss_percentile": 0.03146}, "CVE-2023-5922": {"epss_score": 0.01051, "epss_percentile": 0.77075}, "CVE-2023-5923": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-5924": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-5925": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-5926": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-5927": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-5928": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-5929": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-5930": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2023-5931": {"epss_score": 0.00314, "epss_percentile": 0.54089}, "CVE-2023-5932": {"epss_score": 0.00051, "epss_percentile": 0.16337}, "CVE-2023-5933": {"epss_score": 0.03809, "epss_percentile": 0.87756}, "CVE-2023-5934": {"epss_score": 0.00038, "epss_percentile": 0.11077}, "CVE-2023-5935": {"epss_score": 0.00107, "epss_percentile": 0.29641}, "CVE-2023-5936": {"epss_score": 0.00088, "epss_percentile": 0.25649}, "CVE-2023-5937": {"epss_score": 0.00119, "epss_percentile": 0.31686}, "CVE-2023-5938": {"epss_score": 0.00452, "epss_percentile": 0.63187}, "CVE-2023-5939": {"epss_score": 0.03718, "epss_percentile": 0.87618}, "CVE-2023-5940": {"epss_score": 0.00086, "epss_percentile": 0.25276}, "CVE-2023-5941": {"epss_score": 0.00869, "epss_percentile": 0.74693}, "CVE-2023-5942": {"epss_score": 0.0015, "epss_percentile": 0.36102}, "CVE-2023-5943": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-5944": {"epss_score": 0.00109, "epss_percentile": 0.29974}, "CVE-2023-5945": {"epss_score": 0.00046, "epss_percentile": 0.14431}, "CVE-2023-5946": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-5948": {"epss_score": 0.00039, "epss_percentile": 0.11788}, "CVE-2023-5949": {"epss_score": 0.0032, "epss_percentile": 0.54585}, "CVE-2023-5950": {"epss_score": 0.00063, "epss_percentile": 0.19884}, "CVE-2023-5951": {"epss_score": 0.00284, "epss_percentile": 0.51493}, "CVE-2023-5952": {"epss_score": 0.00672, "epss_percentile": 0.70822}, "CVE-2023-5953": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2023-5954": {"epss_score": 0.00517, "epss_percentile": 0.66069}, "CVE-2023-5955": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-5956": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-5957": {"epss_score": 0.0056, "epss_percentile": 0.67644}, "CVE-2023-5958": {"epss_score": 0.00779, "epss_percentile": 0.7314}, "CVE-2023-5959": {"epss_score": 0.00014, "epss_percentile": 0.01875}, "CVE-2023-5960": {"epss_score": 0.00072, "epss_percentile": 0.22429}, "CVE-2023-5961": {"epss_score": 0.00137, "epss_percentile": 0.34203}, "CVE-2023-5962": {"epss_score": 0.00069, "epss_percentile": 0.21614}, "CVE-2023-5963": {"epss_score": 0.00022, "epss_percentile": 0.05269}, "CVE-2023-5964": {"epss_score": 0.00206, "epss_percentile": 0.42772}, "CVE-2023-5965": {"epss_score": 0.01168, "epss_percentile": 0.78193}, "CVE-2023-5966": {"epss_score": 0.00855, "epss_percentile": 0.74467}, "CVE-2023-5967": {"epss_score": 0.00098, "epss_percentile": 0.27805}, "CVE-2023-5968": {"epss_score": 0.00139, "epss_percentile": 0.34563}, "CVE-2023-5969": {"epss_score": 0.00111, "epss_percentile": 0.30244}, "CVE-2023-5970": {"epss_score": 0.00418, "epss_percentile": 0.61266}, "CVE-2023-5971": {"epss_score": 0.00198, "epss_percentile": 0.4205}, "CVE-2023-5972": {"epss_score": 0.00015, "epss_percentile": 0.02254}, "CVE-2023-5973": {"epss_score": 0.00213, "epss_percentile": 0.4391}, "CVE-2023-5974": {"epss_score": 0.82365, "epss_percentile": 0.9919}, "CVE-2023-5975": {"epss_score": 0.00194, "epss_percentile": 0.41555}, "CVE-2023-5976": {"epss_score": 0.0008, "epss_percentile": 0.24127}, "CVE-2023-5978": {"epss_score": 0.00159, "epss_percentile": 0.37304}, "CVE-2023-5979": {"epss_score": 0.00129, "epss_percentile": 0.33181}, "CVE-2023-5980": {"epss_score": 0.00078, "epss_percentile": 0.2377}, "CVE-2023-5981": {"epss_score": 0.00573, "epss_percentile": 0.68037}, "CVE-2023-5982": {"epss_score": 0.00124, "epss_percentile": 0.32427}, "CVE-2023-5983": {"epss_score": 0.00194, "epss_percentile": 0.41544}, "CVE-2023-5984": {"epss_score": 0.00043, "epss_percentile": 0.13019}, "CVE-2023-5985": {"epss_score": 0.00146, "epss_percentile": 0.35551}, "CVE-2023-5986": {"epss_score": 0.00174, "epss_percentile": 0.39151}, "CVE-2023-5987": {"epss_score": 0.0012, "epss_percentile": 0.31805}, "CVE-2023-5988": {"epss_score": 0.00105, "epss_percentile": 0.29265}, "CVE-2023-5989": {"epss_score": 0.00149, "epss_percentile": 0.36026}, "CVE-2023-5990": {"epss_score": 0.00125, "epss_percentile": 0.32511}, "CVE-2023-5991": {"epss_score": 0.79187, "epss_percentile": 0.99022}, "CVE-2023-5992": {"epss_score": 0.0028, "epss_percentile": 0.51002}, "CVE-2023-5993": {"epss_score": 0.00056, "epss_percentile": 0.17801}, "CVE-2023-5995": {"epss_score": 0.00039, "epss_percentile": 0.11789}, "CVE-2023-5996": {"epss_score": 0.0057, "epss_percentile": 0.67955}, "CVE-2023-5997": {"epss_score": 0.0061, "epss_percentile": 0.69163}, "CVE-2023-5998": {"epss_score": 0.00106, "epss_percentile": 0.29497}, "CVE-2023-6000": {"epss_score": 0.6333, "epss_percentile": 0.98328}, "CVE-2023-6001": {"epss_score": 0.00166, "epss_percentile": 0.38142}, "CVE-2023-6002": {"epss_score": 0.00157, "epss_percentile": 0.37117}, "CVE-2023-6004": {"epss_score": 0.00051, "epss_percentile": 0.16193}, "CVE-2023-6005": {"epss_score": 0.00198, "epss_percentile": 0.4205}, "CVE-2023-6006": {"epss_score": 0.00045, "epss_percentile": 0.13964}, "CVE-2023-6007": {"epss_score": 0.00226, "epss_percentile": 0.45259}, "CVE-2023-6008": {"epss_score": 0.00065, "epss_percentile": 0.20617}, "CVE-2023-6009": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2023-6011": {"epss_score": 0.00169, "epss_percentile": 0.38625}, "CVE-2023-6012": {"epss_score": 0.01121, "epss_percentile": 0.77776}, "CVE-2023-6013": {"epss_score": 0.00241, "epss_percentile": 0.47276}, "CVE-2023-6014": {"epss_score": 0.00875, "epss_percentile": 0.74782}, "CVE-2023-6015": {"epss_score": 0.00767, "epss_percentile": 0.72956}, "CVE-2023-6016": {"epss_score": 0.68243, "epss_percentile": 0.98537}, "CVE-2023-6017": {"epss_score": 0.00194, "epss_percentile": 0.41598}, "CVE-2023-6018": {"epss_score": 0.89568, "epss_percentile": 0.99532}, "CVE-2023-6019": {"epss_score": 0.8828, "epss_percentile": 0.99465}, "CVE-2023-6020": {"epss_score": 0.81449, "epss_percentile": 0.99138}, "CVE-2023-6021": {"epss_score": 0.87317, "epss_percentile": 0.99422}, "CVE-2023-6022": {"epss_score": 0.00238, "epss_percentile": 0.46774}, "CVE-2023-6023": {"epss_score": 0.47939, "epss_percentile": 0.97609}, "CVE-2023-6026": {"epss_score": 0.01091, "epss_percentile": 0.77458}, "CVE-2023-6027": {"epss_score": 0.00178, "epss_percentile": 0.39674}, "CVE-2023-6028": {"epss_score": 0.00151, "epss_percentile": 0.36192}, "CVE-2023-6029": {"epss_score": 0.00095, "epss_percentile": 0.27082}, "CVE-2023-6030": {"epss_score": 0.00047, "epss_percentile": 0.14664}, "CVE-2023-6032": {"epss_score": 0.00138, "epss_percentile": 0.34523}, "CVE-2023-6033": {"epss_score": 0.00952, "epss_percentile": 0.75884}, "CVE-2023-6035": {"epss_score": 0.00358, "epss_percentile": 0.57489}, "CVE-2023-6036": {"epss_score": 0.48959, "epss_percentile": 0.9766}, "CVE-2023-6037": {"epss_score": 0.00089, "epss_percentile": 0.2581}, "CVE-2023-6038": {"epss_score": 0.63282, "epss_percentile": 0.98326}, "CVE-2023-6039": {"epss_score": 0.00019, "epss_percentile": 0.04226}, "CVE-2023-6040": {"epss_score": 0.00018, "epss_percentile": 0.03882}, "CVE-2023-6042": {"epss_score": 0.00384, "epss_percentile": 0.59148}, "CVE-2023-6043": {"epss_score": 6e-05, "epss_percentile": 0.00299}, "CVE-2023-6044": {"epss_score": 0.00038, "epss_percentile": 0.11161}, "CVE-2023-6045": {"epss_score": 0.00026, "epss_percentile": 0.06513}, "CVE-2023-6046": {"epss_score": 0.00078, "epss_percentile": 0.2358}, "CVE-2023-6047": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2023-6048": {"epss_score": 0.00098, "epss_percentile": 0.27754}, "CVE-2023-6049": {"epss_score": 0.01069, "epss_percentile": 0.77251}, "CVE-2023-6050": {"epss_score": 0.00141, "epss_percentile": 0.34828}, "CVE-2023-6051": {"epss_score": 0.00086, "epss_percentile": 0.25345}, "CVE-2023-6052": {"epss_score": 0.00143, "epss_percentile": 0.35165}, "CVE-2023-6053": {"epss_score": 0.00073, "epss_percentile": 0.2256}, "CVE-2023-6054": {"epss_score": 0.00183, "epss_percentile": 0.40319}, "CVE-2023-6055": {"epss_score": 0.00175, "epss_percentile": 0.39277}, "CVE-2023-6056": {"epss_score": 0.0012, "epss_percentile": 0.31764}, "CVE-2023-6057": {"epss_score": 0.00178, "epss_percentile": 0.39648}, "CVE-2023-6058": {"epss_score": 0.00314, "epss_percentile": 0.54114}, "CVE-2023-6062": {"epss_score": 0.00209, "epss_percentile": 0.43376}, "CVE-2023-6063": {"epss_score": 0.9159, "epss_percentile": 0.99655}, "CVE-2023-6064": {"epss_score": 0.00386, "epss_percentile": 0.59265}, "CVE-2023-6065": {"epss_score": 0.40068, "epss_percentile": 0.97194}, "CVE-2023-6066": {"epss_score": 0.00049, "epss_percentile": 0.15416}, "CVE-2023-6067": {"epss_score": 0.00127, "epss_percentile": 0.32811}, "CVE-2023-6068": {"epss_score": 0.00137, "epss_percentile": 0.34256}, "CVE-2023-6069": {"epss_score": 0.0025, "epss_percentile": 0.48138}, "CVE-2023-6070": {"epss_score": 0.00103, "epss_percentile": 0.28987}, "CVE-2023-6071": {"epss_score": 0.00639, "epss_percentile": 0.69931}, "CVE-2023-6072": {"epss_score": 0.00087, "epss_percentile": 0.25448}, "CVE-2023-6073": {"epss_score": 0.00024, "epss_percentile": 0.05888}, "CVE-2023-6074": {"epss_score": 0.00045, "epss_percentile": 0.13713}, "CVE-2023-6075": {"epss_score": 0.00069, "epss_percentile": 0.21428}, "CVE-2023-6076": {"epss_score": 0.00088, "epss_percentile": 0.25733}, "CVE-2023-6077": {"epss_score": 0.00261, "epss_percentile": 0.49305}, "CVE-2023-6078": {"epss_score": 0.00342, "epss_percentile": 0.56389}, "CVE-2023-6080": {"epss_score": 0.00135, "epss_percentile": 0.34043}, "CVE-2023-6081": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2023-6082": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-6084": {"epss_score": 0.00057, "epss_percentile": 0.182}, "CVE-2023-6090": {"epss_score": 0.00185, "epss_percentile": 0.40478}, "CVE-2023-6091": {"epss_score": 0.00457, "epss_percentile": 0.63375}, "CVE-2023-6093": {"epss_score": 0.00069, "epss_percentile": 0.21483}, "CVE-2023-6094": {"epss_score": 0.00094, "epss_percentile": 0.27011}, "CVE-2023-6095": {"epss_score": 0.01016, "epss_percentile": 0.76681}, "CVE-2023-6096": {"epss_score": 0.00022, "epss_percentile": 0.05144}, "CVE-2023-6097": {"epss_score": 0.00139, "epss_percentile": 0.34618}, "CVE-2023-6098": {"epss_score": 0.00055, "epss_percentile": 0.17631}, "CVE-2023-6099": {"epss_score": 0.00066, "epss_percentile": 0.20736}, "CVE-2023-6100": {"epss_score": 0.00076, "epss_percentile": 0.23153}, "CVE-2023-6101": {"epss_score": 0.00084, "epss_percentile": 0.24857}, "CVE-2023-6102": {"epss_score": 0.00085, "epss_percentile": 0.25031}, "CVE-2023-6103": {"epss_score": 0.00068, "epss_percentile": 0.21213}, "CVE-2023-6105": {"epss_score": 0.00084, "epss_percentile": 0.24872}, "CVE-2023-6109": {"epss_score": 0.00204, "epss_percentile": 0.42602}, "CVE-2023-6110": {"epss_score": 0.00182, "epss_percentile": 0.40237}, "CVE-2023-6111": {"epss_score": 0.00019, "epss_percentile": 0.04206}, "CVE-2023-6112": {"epss_score": 0.28141, "epss_percentile": 0.96324}, "CVE-2023-6113": {"epss_score": 0.00412, "epss_percentile": 0.60918}, "CVE-2023-6114": {"epss_score": 0.61257, "epss_percentile": 0.98241}, "CVE-2023-6116": {"epss_score": 0.01016, "epss_percentile": 0.76681}, "CVE-2023-6117": {"epss_score": 0.0014, "epss_percentile": 0.34714}, "CVE-2023-6118": {"epss_score": 0.00105, "epss_percentile": 0.29361}, "CVE-2023-6119": {"epss_score": 0.00029, "epss_percentile": 0.07766}, "CVE-2023-6120": {"epss_score": 0.00125, "epss_percentile": 0.32482}, "CVE-2023-6121": {"epss_score": 0.00252, "epss_percentile": 0.48389}, "CVE-2023-6122": {"epss_score": 0.00237, "epss_percentile": 0.46645}, "CVE-2023-6123": {"epss_score": 0.0051, "epss_percentile": 0.6579}, "CVE-2023-6124": {"epss_score": 0.00178, "epss_percentile": 0.39649}, "CVE-2023-6125": {"epss_score": 0.00114, "epss_percentile": 0.30857}, "CVE-2023-6126": {"epss_score": 0.00142, "epss_percentile": 0.3505}, "CVE-2023-6127": {"epss_score": 0.00175, "epss_percentile": 0.39279}, "CVE-2023-6128": {"epss_score": 0.0016, "epss_percentile": 0.37471}, "CVE-2023-6129": {"epss_score": 0.01716, "epss_percentile": 0.81905}, "CVE-2023-6130": {"epss_score": 0.00221, "epss_percentile": 0.44689}, "CVE-2023-6131": {"epss_score": 0.0017, "epss_percentile": 0.38662}, "CVE-2023-6132": {"epss_score": 0.00039, "epss_percentile": 0.11605}, "CVE-2023-6133": {"epss_score": 0.0019, "epss_percentile": 0.41078}, "CVE-2023-6134": {"epss_score": 0.01902, "epss_percentile": 0.82783}, "CVE-2023-6135": {"epss_score": 0.00152, "epss_percentile": 0.36467}, "CVE-2023-6136": {"epss_score": 0.0047, "epss_percentile": 0.63961}, "CVE-2023-6137": {"epss_score": 0.00123, "epss_percentile": 0.32321}, "CVE-2023-6138": {"epss_score": 0.00162, "epss_percentile": 0.37734}, "CVE-2023-6139": {"epss_score": 0.00219, "epss_percentile": 0.44479}, "CVE-2023-6140": {"epss_score": 0.03888, "epss_percentile": 0.87907}, "CVE-2023-6141": {"epss_score": 0.00255, "epss_percentile": 0.4866}, "CVE-2023-6142": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2023-6143": {"epss_score": 0.00123, "epss_percentile": 0.32289}, "CVE-2023-6144": {"epss_score": 0.0007, "epss_percentile": 0.21834}, "CVE-2023-6145": {"epss_score": 0.00143, "epss_percentile": 0.35105}, "CVE-2023-6146": {"epss_score": 0.0055, "epss_percentile": 0.67342}, "CVE-2023-6147": {"epss_score": 0.0017, "epss_percentile": 0.38738}, "CVE-2023-6148": {"epss_score": 0.00467, "epss_percentile": 0.63856}, "CVE-2023-6149": {"epss_score": 0.00186, "epss_percentile": 0.40617}, "CVE-2023-6150": {"epss_score": 0.00082, "epss_percentile": 0.24565}, "CVE-2023-6151": {"epss_score": 0.00082, "epss_percentile": 0.24565}, "CVE-2023-6152": {"epss_score": 0.00229, "epss_percentile": 0.4559}, "CVE-2023-6153": {"epss_score": 0.00084, "epss_percentile": 0.24924}, "CVE-2023-6154": {"epss_score": 0.00047, "epss_percentile": 0.14775}, "CVE-2023-6155": {"epss_score": 0.00438, "epss_percentile": 0.62539}, "CVE-2023-6156": {"epss_score": 0.00381, "epss_percentile": 0.58993}, "CVE-2023-6157": {"epss_score": 0.00381, "epss_percentile": 0.58993}, "CVE-2023-6158": {"epss_score": 0.00154, "epss_percentile": 0.36652}, "CVE-2023-6159": {"epss_score": 0.00212, "epss_percentile": 0.43738}, "CVE-2023-6160": {"epss_score": 0.01512, "epss_percentile": 0.80781}, "CVE-2023-6161": {"epss_score": 0.0028, "epss_percentile": 0.51069}, "CVE-2023-6163": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-6164": {"epss_score": 0.00126, "epss_percentile": 0.32682}, "CVE-2023-6165": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-6166": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-6173": {"epss_score": 0.00155, "epss_percentile": 0.36759}, "CVE-2023-6174": {"epss_score": 0.00121, "epss_percentile": 0.31946}, "CVE-2023-6175": {"epss_score": 0.00045, "epss_percentile": 0.13991}, "CVE-2023-6176": {"epss_score": 0.0001, "epss_percentile": 0.00783}, "CVE-2023-6178": {"epss_score": 0.00095, "epss_percentile": 0.27132}, "CVE-2023-6179": {"epss_score": 0.00025, "epss_percentile": 0.06214}, "CVE-2023-6180": {"epss_score": 0.00086, "epss_percentile": 0.25338}, "CVE-2023-6181": {"epss_score": 0.0009, "epss_percentile": 0.26052}, "CVE-2023-6184": {"epss_score": 0.29727, "epss_percentile": 0.96468}, "CVE-2023-6185": {"epss_score": 0.01215, "epss_percentile": 0.78582}, "CVE-2023-6186": {"epss_score": 0.01086, "epss_percentile": 0.77422}, "CVE-2023-6187": {"epss_score": 0.19702, "epss_percentile": 0.95229}, "CVE-2023-6188": {"epss_score": 0.00156, "epss_percentile": 0.36957}, "CVE-2023-6189": {"epss_score": 0.00085, "epss_percentile": 0.25189}, "CVE-2023-6190": {"epss_score": 0.00149, "epss_percentile": 0.35979}, "CVE-2023-6191": {"epss_score": 0.00117, "epss_percentile": 0.31287}, "CVE-2023-6193": {"epss_score": 0.00423, "epss_percentile": 0.61632}, "CVE-2023-6194": {"epss_score": 0.0004, "epss_percentile": 0.11925}, "CVE-2023-6195": {"epss_score": 0.0004, "epss_percentile": 0.11903}, "CVE-2023-6196": {"epss_score": 0.00092, "epss_percentile": 0.26561}, "CVE-2023-6197": {"epss_score": 0.00106, "epss_percentile": 0.29438}, "CVE-2023-6198": {"epss_score": 0.00114, "epss_percentile": 0.30863}, "CVE-2023-6199": {"epss_score": 0.13376, "epss_percentile": 0.93946}, "CVE-2023-6200": {"epss_score": 0.00772, "epss_percentile": 0.73042}, "CVE-2023-6201": {"epss_score": 0.00334, "epss_percentile": 0.55713}, "CVE-2023-6202": {"epss_score": 0.00231, "epss_percentile": 0.45858}, "CVE-2023-6203": {"epss_score": 0.00794, "epss_percentile": 0.73437}, "CVE-2023-6204": {"epss_score": 0.00245, "epss_percentile": 0.47625}, "CVE-2023-6205": {"epss_score": 0.00381, "epss_percentile": 0.59021}, "CVE-2023-6206": {"epss_score": 0.00394, "epss_percentile": 0.59756}, "CVE-2023-6207": {"epss_score": 0.0042, "epss_percentile": 0.61413}, "CVE-2023-6208": {"epss_score": 0.00421, "epss_percentile": 0.615}, "CVE-2023-6209": {"epss_score": 0.00348, "epss_percentile": 0.56811}, "CVE-2023-6210": {"epss_score": 0.00183, "epss_percentile": 0.403}, "CVE-2023-6211": {"epss_score": 0.00135, "epss_percentile": 0.34043}, "CVE-2023-6212": {"epss_score": 0.00358, "epss_percentile": 0.57505}, "CVE-2023-6213": {"epss_score": 0.00224, "epss_percentile": 0.45069}, "CVE-2023-6214": {"epss_score": 0.00892, "epss_percentile": 0.7507}, "CVE-2023-6215": {"epss_score": 0.00027, "epss_percentile": 0.06846}, "CVE-2023-6217": {"epss_score": 0.00024, "epss_percentile": 0.05742}, "CVE-2023-6218": {"epss_score": 0.00065, "epss_percentile": 0.20605}, "CVE-2023-6219": {"epss_score": 0.02096, "epss_percentile": 0.83586}, "CVE-2023-6220": {"epss_score": 0.06258, "epss_percentile": 0.90618}, "CVE-2023-6221": {"epss_score": 0.00082, "epss_percentile": 0.24561}, "CVE-2023-6222": {"epss_score": 0.0036, "epss_percentile": 0.57686}, "CVE-2023-6223": {"epss_score": 0.00149, "epss_percentile": 0.35934}, "CVE-2023-6225": {"epss_score": 0.00087, "epss_percentile": 0.25501}, "CVE-2023-6226": {"epss_score": 0.00125, "epss_percentile": 0.32473}, "CVE-2023-6228": {"epss_score": 0.00015, "epss_percentile": 0.02193}, "CVE-2023-6229": {"epss_score": 0.0049, "epss_percentile": 0.64934}, "CVE-2023-6230": {"epss_score": 0.00363, "epss_percentile": 0.57902}, "CVE-2023-6231": {"epss_score": 0.00314, "epss_percentile": 0.54151}, "CVE-2023-6232": {"epss_score": 0.00363, "epss_percentile": 0.57902}, "CVE-2023-6233": {"epss_score": 0.00314, "epss_percentile": 0.54151}, "CVE-2023-6234": {"epss_score": 0.0049, "epss_percentile": 0.64934}, "CVE-2023-6235": {"epss_score": 0.00102, "epss_percentile": 0.28829}, "CVE-2023-6236": {"epss_score": 0.00061, "epss_percentile": 0.19458}, "CVE-2023-6237": {"epss_score": 0.00655, "epss_percentile": 0.70367}, "CVE-2023-6238": {"epss_score": 0.00015, "epss_percentile": 0.02126}, "CVE-2023-6239": {"epss_score": 0.0005, "epss_percentile": 0.15774}, "CVE-2023-6240": {"epss_score": 0.00066, "epss_percentile": 0.20934}, "CVE-2023-6241": {"epss_score": 0.10706, "epss_percentile": 0.93077}, "CVE-2023-6242": {"epss_score": 0.00108, "epss_percentile": 0.29902}, "CVE-2023-6243": {"epss_score": 0.00197, "epss_percentile": 0.41934}, "CVE-2023-6244": {"epss_score": 0.00108, "epss_percentile": 0.29902}, "CVE-2023-6245": {"epss_score": 0.00131, "epss_percentile": 0.33359}, "CVE-2023-6246": {"epss_score": 0.24316, "epss_percentile": 0.95902}, "CVE-2023-6247": {"epss_score": 0.00576, "epss_percentile": 0.68147}, "CVE-2023-6248": {"epss_score": 0.01676, "epss_percentile": 0.81705}, "CVE-2023-6249": {"epss_score": 0.00233, "epss_percentile": 0.4605}, "CVE-2023-6250": {"epss_score": 0.00179, "epss_percentile": 0.39851}, "CVE-2023-6251": {"epss_score": 0.00186, "epss_percentile": 0.40666}, "CVE-2023-6252": {"epss_score": 0.00092, "epss_percentile": 0.26589}, "CVE-2023-6253": {"epss_score": 0.00033, "epss_percentile": 0.09412}, "CVE-2023-6254": {"epss_score": 0.00177, "epss_percentile": 0.39582}, "CVE-2023-6255": {"epss_score": 0.00082, "epss_percentile": 0.24462}, "CVE-2023-6257": {"epss_score": 0.00172, "epss_percentile": 0.39037}, "CVE-2023-6258": {"epss_score": 0.00102, "epss_percentile": 0.28761}, "CVE-2023-6259": {"epss_score": 0.00011, "epss_percentile": 0.01014}, "CVE-2023-6260": {"epss_score": 0.00107, "epss_percentile": 0.29715}, "CVE-2023-6263": {"epss_score": 0.00163, "epss_percentile": 0.37814}, "CVE-2023-6264": {"epss_score": 0.00277, "epss_percentile": 0.50818}, "CVE-2023-6265": {"epss_score": 0.00214, "epss_percentile": 0.43966}, "CVE-2023-6266": {"epss_score": 0.25207, "epss_percentile": 0.95998}, "CVE-2023-6267": {"epss_score": 0.00673, "epss_percentile": 0.70836}, "CVE-2023-6268": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-6269": {"epss_score": 0.00459, "epss_percentile": 0.63455}, "CVE-2023-6270": {"epss_score": 0.00023, "epss_percentile": 0.05513}, "CVE-2023-6271": {"epss_score": 0.00386, "epss_percentile": 0.59265}, "CVE-2023-6272": {"epss_score": 0.00407, "epss_percentile": 0.60607}, "CVE-2023-6273": {"epss_score": 0.00037, "epss_percentile": 0.10624}, "CVE-2023-6274": {"epss_score": 0.00035, "epss_percentile": 0.0983}, "CVE-2023-6275": {"epss_score": 0.49282, "epss_percentile": 0.97677}, "CVE-2023-6276": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2023-6277": {"epss_score": 0.00418, "epss_percentile": 0.61283}, "CVE-2023-6278": {"epss_score": 0.00128, "epss_percentile": 0.33042}, "CVE-2023-6279": {"epss_score": 0.00101, "epss_percentile": 0.28567}, "CVE-2023-6280": {"epss_score": 0.00035, "epss_percentile": 0.09906}, "CVE-2023-6282": {"epss_score": 0.00076, "epss_percentile": 0.23229}, "CVE-2023-6287": {"epss_score": 0.00092, "epss_percentile": 0.26529}, "CVE-2023-6288": {"epss_score": 0.00095, "epss_percentile": 0.27217}, "CVE-2023-6289": {"epss_score": 0.02895, "epss_percentile": 0.85925}, "CVE-2023-6290": {"epss_score": 0.00078, "epss_percentile": 0.2377}, "CVE-2023-6291": {"epss_score": 0.00196, "epss_percentile": 0.41758}, "CVE-2023-6292": {"epss_score": 0.00125, "epss_percentile": 0.32511}, "CVE-2023-6293": {"epss_score": 0.00051, "epss_percentile": 0.16273}, "CVE-2023-6294": {"epss_score": 0.00328, "epss_percentile": 0.55269}, "CVE-2023-6295": {"epss_score": 0.00347, "epss_percentile": 0.56758}, "CVE-2023-6296": {"epss_score": 0.00089, "epss_percentile": 0.25884}, "CVE-2023-6297": {"epss_score": 0.00142, "epss_percentile": 0.35}, "CVE-2023-6298": {"epss_score": 0.00067, "epss_percentile": 0.21019}, "CVE-2023-6299": {"epss_score": 0.00063, "epss_percentile": 0.19883}, "CVE-2023-6300": {"epss_score": 0.00173, "epss_percentile": 0.39047}, "CVE-2023-6301": {"epss_score": 0.00173, "epss_percentile": 0.39047}, "CVE-2023-6302": {"epss_score": 0.00044, "epss_percentile": 0.13423}, "CVE-2023-6303": {"epss_score": 0.00062, "epss_percentile": 0.19617}, "CVE-2023-6304": {"epss_score": 0.0077, "epss_percentile": 0.72999}, "CVE-2023-6305": {"epss_score": 0.00043, "epss_percentile": 0.13214}, "CVE-2023-6306": {"epss_score": 0.00043, "epss_percentile": 0.13214}, "CVE-2023-6307": {"epss_score": 0.00102, "epss_percentile": 0.28726}, "CVE-2023-6308": {"epss_score": 0.00245, "epss_percentile": 0.47656}, "CVE-2023-6309": {"epss_score": 0.01659, "epss_percentile": 0.81611}, "CVE-2023-6310": {"epss_score": 0.0005, "epss_percentile": 0.15771}, "CVE-2023-6311": {"epss_score": 0.00048, "epss_percentile": 0.15224}, "CVE-2023-6312": {"epss_score": 0.0005, "epss_percentile": 0.15771}, "CVE-2023-6313": {"epss_score": 0.00106, "epss_percentile": 0.29488}, "CVE-2023-6314": {"epss_score": 0.00048, "epss_percentile": 0.15225}, "CVE-2023-6315": {"epss_score": 0.00029, "epss_percentile": 0.07701}, "CVE-2023-6316": {"epss_score": 0.08274, "epss_percentile": 0.91962}, "CVE-2023-6317": {"epss_score": 0.00102, "epss_percentile": 0.28741}, "CVE-2023-6318": {"epss_score": 0.00509, "epss_percentile": 0.65755}, "CVE-2023-6319": {"epss_score": 0.0915, "epss_percentile": 0.92422}, "CVE-2023-6320": {"epss_score": 0.00453, "epss_percentile": 0.6322}, "CVE-2023-6321": {"epss_score": 0.00535, "epss_percentile": 0.66828}, "CVE-2023-6322": {"epss_score": 0.00391, "epss_percentile": 0.5963}, "CVE-2023-6323": {"epss_score": 0.00232, "epss_percentile": 0.45961}, "CVE-2023-6324": {"epss_score": 0.00586, "epss_percentile": 0.68452}, "CVE-2023-6325": {"epss_score": 0.00725, "epss_percentile": 0.72044}, "CVE-2023-6326": {"epss_score": 0.00047, "epss_percentile": 0.14495}, "CVE-2023-6327": {"epss_score": 0.00405, "epss_percentile": 0.60506}, "CVE-2023-6329": {"epss_score": 0.92487, "epss_percentile": 0.99719}, "CVE-2023-6333": {"epss_score": 0.00029, "epss_percentile": 0.0767}, "CVE-2023-6334": {"epss_score": 0.00053, "epss_percentile": 0.16874}, "CVE-2023-6335": {"epss_score": 0.00078, "epss_percentile": 0.2359}, "CVE-2023-6336": {"epss_score": 0.00049, "epss_percentile": 0.15557}, "CVE-2023-6337": {"epss_score": 0.00999, "epss_percentile": 0.7648}, "CVE-2023-6338": {"epss_score": 0.00051, "epss_percentile": 0.16108}, "CVE-2023-6339": {"epss_score": 0.00045, "epss_percentile": 0.13933}, "CVE-2023-6340": {"epss_score": 0.00066, "epss_percentile": 0.20861}, "CVE-2023-6341": {"epss_score": 0.00859, "epss_percentile": 0.74521}, "CVE-2023-6342": {"epss_score": 0.00967, "epss_percentile": 0.76072}, "CVE-2023-6343": {"epss_score": 0.01618, "epss_percentile": 0.81376}, "CVE-2023-6344": {"epss_score": 0.01618, "epss_percentile": 0.81376}, "CVE-2023-6345": {"epss_score": 0.01315, "epss_percentile": 0.79399}, "CVE-2023-6346": {"epss_score": 0.0045, "epss_percentile": 0.63088}, "CVE-2023-6347": {"epss_score": 0.00464, "epss_percentile": 0.63739}, "CVE-2023-6348": {"epss_score": 0.00869, "epss_percentile": 0.74684}, "CVE-2023-6349": {"epss_score": 0.00078, "epss_percentile": 0.2366}, "CVE-2023-6350": {"epss_score": 0.01635, "epss_percentile": 0.8147}, "CVE-2023-6351": {"epss_score": 0.00291, "epss_percentile": 0.52189}, "CVE-2023-6352": {"epss_score": 0.00642, "epss_percentile": 0.70035}, "CVE-2023-6353": {"epss_score": 0.01212, "epss_percentile": 0.78557}, "CVE-2023-6354": {"epss_score": 0.01044, "epss_percentile": 0.77002}, "CVE-2023-6355": {"epss_score": 0.00012, "epss_percentile": 0.01266}, "CVE-2023-6356": {"epss_score": 0.00023, "epss_percentile": 0.05343}, "CVE-2023-6357": {"epss_score": 0.00284, "epss_percentile": 0.51452}, "CVE-2023-6359": {"epss_score": 0.00076, "epss_percentile": 0.23087}, "CVE-2023-6360": {"epss_score": 0.88061, "epss_percentile": 0.99456}, "CVE-2023-6361": {"epss_score": 0.00101, "epss_percentile": 0.28628}, "CVE-2023-6362": {"epss_score": 0.00101, "epss_percentile": 0.28628}, "CVE-2023-6363": {"epss_score": 0.00034, "epss_percentile": 0.09622}, "CVE-2023-6364": {"epss_score": 0.00014, "epss_percentile": 0.01934}, "CVE-2023-6365": {"epss_score": 0.00016, "epss_percentile": 0.02781}, "CVE-2023-6366": {"epss_score": 0.00016, "epss_percentile": 0.02781}, "CVE-2023-6367": {"epss_score": 0.00028, "epss_percentile": 0.07488}, "CVE-2023-6368": {"epss_score": 0.00022, "epss_percentile": 0.0503}, "CVE-2023-6369": {"epss_score": 0.00325, "epss_percentile": 0.55003}, "CVE-2023-6371": {"epss_score": 0.00042, "epss_percentile": 0.12588}, "CVE-2023-6373": {"epss_score": 0.00224, "epss_percentile": 0.45074}, "CVE-2023-6374": {"epss_score": 0.00887, "epss_percentile": 0.74967}, "CVE-2023-6375": {"epss_score": 0.00756, "epss_percentile": 0.72735}, "CVE-2023-6376": {"epss_score": 0.00974, "epss_percentile": 0.76176}, "CVE-2023-6377": {"epss_score": 0.00411, "epss_percentile": 0.60898}, "CVE-2023-6378": {"epss_score": 0.00613, "epss_percentile": 0.69247}, "CVE-2023-6379": {"epss_score": 0.18616, "epss_percentile": 0.95043}, "CVE-2023-6380": {"epss_score": 0.43282, "epss_percentile": 0.9738}, "CVE-2023-6381": {"epss_score": 0.00028, "epss_percentile": 0.07378}, "CVE-2023-6382": {"epss_score": 0.00273, "epss_percentile": 0.50461}, "CVE-2023-6383": {"epss_score": 0.00568, "epss_percentile": 0.6788}, "CVE-2023-6384": {"epss_score": 0.00083, "epss_percentile": 0.24632}, "CVE-2023-6385": {"epss_score": 0.00092, "epss_percentile": 0.26496}, "CVE-2023-6386": {"epss_score": 0.00836, "epss_percentile": 0.74139}, "CVE-2023-6387": {"epss_score": 0.03196, "epss_percentile": 0.86612}, "CVE-2023-6388": {"epss_score": 0.00054, "epss_percentile": 0.1725}, "CVE-2023-6389": {"epss_score": 0.52517, "epss_percentile": 0.9783}, "CVE-2023-6390": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-6391": {"epss_score": 0.00096, "epss_percentile": 0.27439}, "CVE-2023-6393": {"epss_score": 0.00154, "epss_percentile": 0.3674}, "CVE-2023-6394": {"epss_score": 0.00373, "epss_percentile": 0.58508}, "CVE-2023-6395": {"epss_score": 0.00413, "epss_percentile": 0.61}, "CVE-2023-6397": {"epss_score": 0.00129, "epss_percentile": 0.3319}, "CVE-2023-6398": {"epss_score": 0.00729, "epss_percentile": 0.72123}, "CVE-2023-6399": {"epss_score": 0.00306, "epss_percentile": 0.53458}, "CVE-2023-6400": {"epss_score": 0.00094, "epss_percentile": 0.27029}, "CVE-2023-6401": {"epss_score": 0.00026, "epss_percentile": 0.06417}, "CVE-2023-6402": {"epss_score": 0.0012, "epss_percentile": 0.31791}, "CVE-2023-6407": {"epss_score": 0.00055, "epss_percentile": 0.1748}, "CVE-2023-6408": {"epss_score": 0.00174, "epss_percentile": 0.39154}, "CVE-2023-6409": {"epss_score": 0.00068, "epss_percentile": 0.21414}, "CVE-2023-6410": {"epss_score": 0.00199, "epss_percentile": 0.42106}, "CVE-2023-6411": {"epss_score": 0.0016, "epss_percentile": 0.37436}, "CVE-2023-6412": {"epss_score": 0.00199, "epss_percentile": 0.42106}, "CVE-2023-6413": {"epss_score": 0.00177, "epss_percentile": 0.3959}, "CVE-2023-6414": {"epss_score": 0.00199, "epss_percentile": 0.42106}, "CVE-2023-6415": {"epss_score": 0.00199, "epss_percentile": 0.42106}, "CVE-2023-6416": {"epss_score": 0.00177, "epss_percentile": 0.3959}, "CVE-2023-6417": {"epss_score": 0.00199, "epss_percentile": 0.42106}, "CVE-2023-6418": {"epss_score": 0.00177, "epss_percentile": 0.3959}, "CVE-2023-6419": {"epss_score": 0.00185, "epss_percentile": 0.40522}, "CVE-2023-6420": {"epss_score": 0.00277, "epss_percentile": 0.50802}, "CVE-2023-6421": {"epss_score": 0.80567, "epss_percentile": 0.99095}, "CVE-2023-6422": {"epss_score": 0.00171, "epss_percentile": 0.38867}, "CVE-2023-6423": {"epss_score": 0.00138, "epss_percentile": 0.34458}, "CVE-2023-6424": {"epss_score": 0.00142, "epss_percentile": 0.35074}, "CVE-2023-6425": {"epss_score": 0.00171, "epss_percentile": 0.38867}, "CVE-2023-6426": {"epss_score": 0.00139, "epss_percentile": 0.34621}, "CVE-2023-6427": {"epss_score": 0.00191, "epss_percentile": 0.41261}, "CVE-2023-6428": {"epss_score": 0.00139, "epss_percentile": 0.34621}, "CVE-2023-6429": {"epss_score": 0.00191, "epss_percentile": 0.41261}, "CVE-2023-6430": {"epss_score": 0.00286, "epss_percentile": 0.51746}, "CVE-2023-6431": {"epss_score": 0.00286, "epss_percentile": 0.51746}, "CVE-2023-6432": {"epss_score": 0.00286, "epss_percentile": 0.51746}, "CVE-2023-6433": {"epss_score": 0.00191, "epss_percentile": 0.41261}, "CVE-2023-6434": {"epss_score": 0.00191, "epss_percentile": 0.41261}, "CVE-2023-6435": {"epss_score": 0.00191, "epss_percentile": 0.41261}, "CVE-2023-6436": {"epss_score": 0.00127, "epss_percentile": 0.32874}, "CVE-2023-6437": {"epss_score": 0.00649, "epss_percentile": 0.70241}, "CVE-2023-6438": {"epss_score": 0.00107, "epss_percentile": 0.29653}, "CVE-2023-6439": {"epss_score": 0.00151, "epss_percentile": 0.36329}, "CVE-2023-6440": {"epss_score": 0.00134, "epss_percentile": 0.33894}, "CVE-2023-6441": {"epss_score": 0.00166, "epss_percentile": 0.38144}, "CVE-2023-6442": {"epss_score": 0.00148, "epss_percentile": 0.35922}, "CVE-2023-6444": {"epss_score": 0.69261, "epss_percentile": 0.98582}, "CVE-2023-6446": {"epss_score": 0.00156, "epss_percentile": 0.36914}, "CVE-2023-6447": {"epss_score": 0.00185, "epss_percentile": 0.4047}, "CVE-2023-6448": {"epss_score": 0.1329, "epss_percentile": 0.93924}, "CVE-2023-6449": {"epss_score": 0.04095, "epss_percentile": 0.88247}, "CVE-2023-6450": {"epss_score": 0.00024, "epss_percentile": 0.05988}, "CVE-2023-6451": {"epss_score": 0.00038, "epss_percentile": 0.11412}, "CVE-2023-6452": {"epss_score": 0.00131, "epss_percentile": 0.33459}, "CVE-2023-6456": {"epss_score": 0.00085, "epss_percentile": 0.25169}, "CVE-2023-6457": {"epss_score": 0.00028, "epss_percentile": 0.07484}, "CVE-2023-6458": {"epss_score": 0.00464, "epss_percentile": 0.63706}, "CVE-2023-6459": {"epss_score": 0.00492, "epss_percentile": 0.64993}, "CVE-2023-6460": {"epss_score": 0.00017, "epss_percentile": 0.03516}, "CVE-2023-6461": {"epss_score": 0.00156, "epss_percentile": 0.36981}, "CVE-2023-6462": {"epss_score": 0.00081, "epss_percentile": 0.24335}, "CVE-2023-6463": {"epss_score": 0.00081, "epss_percentile": 0.24335}, "CVE-2023-6464": {"epss_score": 0.0006, "epss_percentile": 0.19183}, "CVE-2023-6465": {"epss_score": 0.00083, "epss_percentile": 0.24797}, "CVE-2023-6466": {"epss_score": 0.00081, "epss_percentile": 0.24335}, "CVE-2023-6467": {"epss_score": 0.00091, "epss_percentile": 0.26192}, "CVE-2023-6472": {"epss_score": 0.00064, "epss_percentile": 0.20334}, "CVE-2023-6473": {"epss_score": 0.00106, "epss_percentile": 0.29488}, "CVE-2023-6474": {"epss_score": 0.00084, "epss_percentile": 0.24921}, "CVE-2023-6476": {"epss_score": 0.00168, "epss_percentile": 0.38502}, "CVE-2023-6477": {"epss_score": 0.00012, "epss_percentile": 0.01415}, "CVE-2023-6478": {"epss_score": 0.01113, "epss_percentile": 0.77686}, "CVE-2023-6481": {"epss_score": 0.00224, "epss_percentile": 0.44978}, "CVE-2023-6482": {"epss_score": 0.00072, "epss_percentile": 0.22436}, "CVE-2023-6483": {"epss_score": 0.00136, "epss_percentile": 0.34083}, "CVE-2023-6484": {"epss_score": 0.0044, "epss_percentile": 0.62645}, "CVE-2023-6485": {"epss_score": 0.02446, "epss_percentile": 0.8477}, "CVE-2023-6486": {"epss_score": 0.00176, "epss_percentile": 0.39425}, "CVE-2023-6487": {"epss_score": 0.00206, "epss_percentile": 0.42945}, "CVE-2023-6488": {"epss_score": 0.00092, "epss_percentile": 0.26495}, "CVE-2023-6489": {"epss_score": 0.00143, "epss_percentile": 0.35194}, "CVE-2023-6491": {"epss_score": 0.00188, "epss_percentile": 0.40889}, "CVE-2023-6492": {"epss_score": 0.00096, "epss_percentile": 0.27406}, "CVE-2023-6493": {"epss_score": 0.00063, "epss_percentile": 0.19811}, "CVE-2023-6494": {"epss_score": 0.00101, "epss_percentile": 0.28573}, "CVE-2023-6495": {"epss_score": 0.00186, "epss_percentile": 0.40603}, "CVE-2023-6496": {"epss_score": 0.00332, "epss_percentile": 0.55573}, "CVE-2023-6497": {"epss_score": 0.00097, "epss_percentile": 0.27499}, "CVE-2023-6498": {"epss_score": 0.00101, "epss_percentile": 0.28573}, "CVE-2023-6499": {"epss_score": 0.00102, "epss_percentile": 0.28806}, "CVE-2023-6500": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-6501": {"epss_score": 0.00095, "epss_percentile": 0.27109}, "CVE-2023-6502": {"epss_score": 0.00181, "epss_percentile": 0.4012}, "CVE-2023-6503": {"epss_score": 0.0009, "epss_percentile": 0.26143}, "CVE-2023-6504": {"epss_score": 0.00176, "epss_percentile": 0.39424}, "CVE-2023-6505": {"epss_score": 0.7147, "epss_percentile": 0.9867}, "CVE-2023-6506": {"epss_score": 0.00142, "epss_percentile": 0.35026}, "CVE-2023-6507": {"epss_score": 0.00083, "epss_percentile": 0.24643}, "CVE-2023-6508": {"epss_score": 0.00914, "epss_percentile": 0.75384}, "CVE-2023-6509": {"epss_score": 0.01169, "epss_percentile": 0.78197}, "CVE-2023-6510": {"epss_score": 0.01237, "epss_percentile": 0.78778}, "CVE-2023-6511": {"epss_score": 0.00202, "epss_percentile": 0.42407}, "CVE-2023-6512": {"epss_score": 0.00765, "epss_percentile": 0.72912}, "CVE-2023-6514": {"epss_score": 0.00019, "epss_percentile": 0.04379}, "CVE-2023-6515": {"epss_score": 0.00031, "epss_percentile": 0.0832}, "CVE-2023-6516": {"epss_score": 0.00177, "epss_percentile": 0.39612}, "CVE-2023-6517": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2023-6518": {"epss_score": 0.00082, "epss_percentile": 0.24462}, "CVE-2023-6519": {"epss_score": 0.00068, "epss_percentile": 0.21338}, "CVE-2023-6520": {"epss_score": 0.00266, "epss_percentile": 0.49866}, "CVE-2023-6522": {"epss_score": 0.0015, "epss_percentile": 0.36105}, "CVE-2023-6523": {"epss_score": 0.00032, "epss_percentile": 0.08833}, "CVE-2023-6524": {"epss_score": 0.00119, "epss_percentile": 0.31666}, "CVE-2023-6525": {"epss_score": 0.00149, "epss_percentile": 0.35969}, "CVE-2023-6526": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2023-6527": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2023-6528": {"epss_score": 0.15788, "epss_percentile": 0.94509}, "CVE-2023-6529": {"epss_score": 0.00455, "epss_percentile": 0.63304}, "CVE-2023-6530": {"epss_score": 0.00117, "epss_percentile": 0.31235}, "CVE-2023-6531": {"epss_score": 0.00013, "epss_percentile": 0.01584}, "CVE-2023-6532": {"epss_score": 0.00302, "epss_percentile": 0.53119}, "CVE-2023-6533": {"epss_score": 0.0004, "epss_percentile": 0.12099}, "CVE-2023-6534": {"epss_score": 0.00255, "epss_percentile": 0.48662}, "CVE-2023-6535": {"epss_score": 0.00027, "epss_percentile": 0.06824}, "CVE-2023-6536": {"epss_score": 0.00023, "epss_percentile": 0.05343}, "CVE-2023-6538": {"epss_score": 0.05301, "epss_percentile": 0.89707}, "CVE-2023-6540": {"epss_score": 0.00213, "epss_percentile": 0.43918}, "CVE-2023-6541": {"epss_score": 0.00095, "epss_percentile": 0.27159}, "CVE-2023-6542": {"epss_score": 0.00029, "epss_percentile": 0.07659}, "CVE-2023-6544": {"epss_score": 0.0039, "epss_percentile": 0.59553}, "CVE-2023-6545": {"epss_score": 0.00224, "epss_percentile": 0.45025}, "CVE-2023-6546": {"epss_score": 0.00313, "epss_percentile": 0.54047}, "CVE-2023-6547": {"epss_score": 0.00247, "epss_percentile": 0.4789}, "CVE-2023-6548": {"epss_score": 0.06511, "epss_percentile": 0.90811}, "CVE-2023-6549": {"epss_score": 0.77008, "epss_percentile": 0.98916}, "CVE-2023-6551": {"epss_score": 0.00079, "epss_percentile": 0.23987}, "CVE-2023-6552": {"epss_score": 0.00229, "epss_percentile": 0.45612}, "CVE-2023-6553": {"epss_score": 0.93545, "epss_percentile": 0.99816}, "CVE-2023-6554": {"epss_score": 0.00184, "epss_percentile": 0.40369}, "CVE-2023-6555": {"epss_score": 0.00312, "epss_percentile": 0.54004}, "CVE-2023-6556": {"epss_score": 0.00211, "epss_percentile": 0.43712}, "CVE-2023-6557": {"epss_score": 0.00531, "epss_percentile": 0.66645}, "CVE-2023-6558": {"epss_score": 0.03798, "epss_percentile": 0.87738}, "CVE-2023-6559": {"epss_score": 0.06086, "epss_percentile": 0.90465}, "CVE-2023-6560": {"epss_score": 0.0001, "epss_percentile": 0.00878}, "CVE-2023-6561": {"epss_score": 0.00176, "epss_percentile": 0.39458}, "CVE-2023-6562": {"epss_score": 0.00105, "epss_percentile": 0.29361}, "CVE-2023-6563": {"epss_score": 0.00304, "epss_percentile": 0.53268}, "CVE-2023-6564": {"epss_score": 0.0002, "epss_percentile": 0.04587}, "CVE-2023-6565": {"epss_score": 0.00913, "epss_percentile": 0.7538}, "CVE-2023-6566": {"epss_score": 0.00131, "epss_percentile": 0.33344}, "CVE-2023-6567": {"epss_score": 0.8397, "epss_percentile": 0.99267}, "CVE-2023-6568": {"epss_score": 0.22147, "epss_percentile": 0.95601}, "CVE-2023-6569": {"epss_score": 0.00207, "epss_percentile": 0.43158}, "CVE-2023-6570": {"epss_score": 0.00183, "epss_percentile": 0.40324}, "CVE-2023-6571": {"epss_score": 0.00257, "epss_percentile": 0.4887}, "CVE-2023-6572": {"epss_score": 0.01662, "epss_percentile": 0.81632}, "CVE-2023-6573": {"epss_score": 0.00222, "epss_percentile": 0.44776}, "CVE-2023-6574": {"epss_score": 0.00028, "epss_percentile": 0.07336}, "CVE-2023-6575": {"epss_score": 0.0002, "epss_percentile": 0.04531}, "CVE-2023-6576": {"epss_score": 0.00021, "epss_percentile": 0.04798}, "CVE-2023-6577": {"epss_score": 0.00043, "epss_percentile": 0.1313}, "CVE-2023-6578": {"epss_score": 0.00057, "epss_percentile": 0.18184}, "CVE-2023-6579": {"epss_score": 0.00463, "epss_percentile": 0.6367}, "CVE-2023-6580": {"epss_score": 0.00249, "epss_percentile": 0.48033}, "CVE-2023-6581": {"epss_score": 0.00088, "epss_percentile": 0.25774}, "CVE-2023-6582": {"epss_score": 0.00619, "epss_percentile": 0.69427}, "CVE-2023-6583": {"epss_score": 0.01896, "epss_percentile": 0.82753}, "CVE-2023-6584": {"epss_score": 0.00319, "epss_percentile": 0.54556}, "CVE-2023-6585": {"epss_score": 0.00504, "epss_percentile": 0.65525}, "CVE-2023-6588": {"epss_score": 0.00339, "epss_percentile": 0.56167}, "CVE-2023-6591": {"epss_score": 0.00195, "epss_percentile": 0.41667}, "CVE-2023-6592": {"epss_score": 0.00139, "epss_percentile": 0.3456}, "CVE-2023-6593": {"epss_score": 0.00107, "epss_percentile": 0.29646}, "CVE-2023-6594": {"epss_score": 0.00101, "epss_percentile": 0.28573}, "CVE-2023-6595": {"epss_score": 0.00331, "epss_percentile": 0.555}, "CVE-2023-6596": {"epss_score": 0.00076, "epss_percentile": 0.2316}, "CVE-2023-6597": {"epss_score": 0.00071, "epss_percentile": 0.22134}, "CVE-2023-6598": {"epss_score": 0.00108, "epss_percentile": 0.2977}, "CVE-2023-6599": {"epss_score": 0.00236, "epss_percentile": 0.46357}, "CVE-2023-6600": {"epss_score": 0.00183, "epss_percentile": 0.40348}, "CVE-2023-6601": {"epss_score": 0.00164, "epss_percentile": 0.37989}, "CVE-2023-6602": {"epss_score": 0.00367, "epss_percentile": 0.58158}, "CVE-2023-6603": {"epss_score": 0.00414, "epss_percentile": 0.61095}, "CVE-2023-6604": {"epss_score": 0.00435, "epss_percentile": 0.62379}, "CVE-2023-6605": {"epss_score": 0.00169, "epss_percentile": 0.38537}, "CVE-2023-6606": {"epss_score": 9e-05, "epss_percentile": 0.00598}, "CVE-2023-6607": {"epss_score": 0.00059, "epss_percentile": 0.18629}, "CVE-2023-6608": {"epss_score": 0.00044, "epss_percentile": 0.13506}, "CVE-2023-6609": {"epss_score": 0.00042, "epss_percentile": 0.12917}, "CVE-2023-6610": {"epss_score": 0.0001, "epss_percentile": 0.00911}, "CVE-2023-6611": {"epss_score": 0.00044, "epss_percentile": 0.13506}, "CVE-2023-6612": {"epss_score": 0.13811, "epss_percentile": 0.94064}, "CVE-2023-6613": {"epss_score": 0.00057, "epss_percentile": 0.18113}, "CVE-2023-6614": {"epss_score": 0.00032, "epss_percentile": 0.09095}, "CVE-2023-6615": {"epss_score": 0.00091, "epss_percentile": 0.26189}, "CVE-2023-6616": {"epss_score": 0.00073, "epss_percentile": 0.22669}, "CVE-2023-6617": {"epss_score": 0.00055, "epss_percentile": 0.17637}, "CVE-2023-6618": {"epss_score": 0.00076, "epss_percentile": 0.23097}, "CVE-2023-6619": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-6620": {"epss_score": 0.01658, "epss_percentile": 0.8161}, "CVE-2023-6621": {"epss_score": 0.0012, "epss_percentile": 0.31753}, "CVE-2023-6622": {"epss_score": 0.00011, "epss_percentile": 0.01089}, "CVE-2023-6623": {"epss_score": 0.89357, "epss_percentile": 0.99521}, "CVE-2023-6624": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-6625": {"epss_score": 0.00044, "epss_percentile": 0.13366}, "CVE-2023-6626": {"epss_score": 0.00072, "epss_percentile": 0.22393}, "CVE-2023-6627": {"epss_score": 0.00886, "epss_percentile": 0.74951}, "CVE-2023-6629": {"epss_score": 0.00382, "epss_percentile": 0.59058}, "CVE-2023-6630": {"epss_score": 0.00176, "epss_percentile": 0.39424}, "CVE-2023-6631": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2023-6632": {"epss_score": 0.03385, "epss_percentile": 0.87038}, "CVE-2023-6633": {"epss_score": 0.00095, "epss_percentile": 0.27109}, "CVE-2023-6634": {"epss_score": 0.91594, "epss_percentile": 0.99656}, "CVE-2023-6635": {"epss_score": 0.07607, "epss_percentile": 0.91565}, "CVE-2023-6636": {"epss_score": 0.03981, "epss_percentile": 0.88059}, "CVE-2023-6637": {"epss_score": 0.00185, "epss_percentile": 0.40553}, "CVE-2023-6638": {"epss_score": 0.00185, "epss_percentile": 0.40486}, "CVE-2023-6640": {"epss_score": 0.00043, "epss_percentile": 0.12972}, "CVE-2023-6645": {"epss_score": 0.00231, "epss_percentile": 0.45852}, "CVE-2023-6646": {"epss_score": 0.00076, "epss_percentile": 0.23173}, "CVE-2023-6647": {"epss_score": 0.00057, "epss_percentile": 0.182}, "CVE-2023-6648": {"epss_score": 0.00067, "epss_percentile": 0.21047}, "CVE-2023-6649": {"epss_score": 0.00109, "epss_percentile": 0.29979}, "CVE-2023-6650": {"epss_score": 0.00109, "epss_percentile": 0.29979}, "CVE-2023-6651": {"epss_score": 0.00057, "epss_percentile": 0.182}, "CVE-2023-6652": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2023-6653": {"epss_score": 0.00087, "epss_percentile": 0.25469}, "CVE-2023-6654": {"epss_score": 0.02358, "epss_percentile": 0.84488}, "CVE-2023-6655": {"epss_score": 0.26772, "epss_percentile": 0.96179}, "CVE-2023-6656": {"epss_score": 0.00086, "epss_percentile": 0.25435}, "CVE-2023-6657": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2023-6658": {"epss_score": 0.00051, "epss_percentile": 0.16229}, "CVE-2023-6659": {"epss_score": 0.00055, "epss_percentile": 0.17371}, "CVE-2023-6660": {"epss_score": 0.00302, "epss_percentile": 0.53162}, "CVE-2023-6671": {"epss_score": 0.00064, "epss_percentile": 0.20112}, "CVE-2023-6672": {"epss_score": 0.00088, "epss_percentile": 0.25779}, "CVE-2023-6673": {"epss_score": 0.00105, "epss_percentile": 0.29265}, "CVE-2023-6675": {"epss_score": 0.00093, "epss_percentile": 0.26703}, "CVE-2023-6676": {"epss_score": 0.00076, "epss_percentile": 0.23118}, "CVE-2023-6677": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2023-6678": {"epss_score": 0.00082, "epss_percentile": 0.24468}, "CVE-2023-6679": {"epss_score": 0.00013, "epss_percentile": 0.01524}, "CVE-2023-6680": {"epss_score": 0.00026, "epss_percentile": 0.06515}, "CVE-2023-6681": {"epss_score": 0.00047, "epss_percentile": 0.14576}, "CVE-2023-6682": {"epss_score": 0.00093, "epss_percentile": 0.26645}, "CVE-2023-6683": {"epss_score": 0.00073, "epss_percentile": 0.22592}, "CVE-2023-6684": {"epss_score": 0.00193, "epss_percentile": 0.41495}, "CVE-2023-6687": {"epss_score": 0.00401, "epss_percentile": 0.60252}, "CVE-2023-6688": {"epss_score": 0.00093, "epss_percentile": 0.26645}, "CVE-2023-6689": {"epss_score": 0.00056, "epss_percentile": 0.17679}, "CVE-2023-6690": {"epss_score": 0.00088, "epss_percentile": 0.25672}, "CVE-2023-6691": {"epss_score": 0.0015, "epss_percentile": 0.36123}, "CVE-2023-6692": {"epss_score": 0.00152, "epss_percentile": 0.36403}, "CVE-2023-6693": {"epss_score": 0.00027, "epss_percentile": 0.06943}, "CVE-2023-6694": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2023-6695": {"epss_score": 0.00517, "epss_percentile": 0.66084}, "CVE-2023-6696": {"epss_score": 0.00417, "epss_percentile": 0.61238}, "CVE-2023-6697": {"epss_score": 0.48648, "epss_percentile": 0.97647}, "CVE-2023-6699": {"epss_score": 0.03375, "epss_percentile": 0.87015}, "CVE-2023-6700": {"epss_score": 0.24294, "epss_percentile": 0.95901}, "CVE-2023-6701": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2023-6702": {"epss_score": 0.51688, "epss_percentile": 0.97794}, "CVE-2023-6703": {"epss_score": 0.00426, "epss_percentile": 0.61763}, "CVE-2023-6704": {"epss_score": 0.00235, "epss_percentile": 0.4622}, "CVE-2023-6705": {"epss_score": 0.00451, "epss_percentile": 0.63153}, "CVE-2023-6706": {"epss_score": 0.00426, "epss_percentile": 0.61763}, "CVE-2023-6707": {"epss_score": 0.00372, "epss_percentile": 0.58444}, "CVE-2023-6708": {"epss_score": 0.00391, "epss_percentile": 0.59629}, "CVE-2023-6709": {"epss_score": 0.00356, "epss_percentile": 0.57327}, "CVE-2023-6710": {"epss_score": 0.0079, "epss_percentile": 0.73369}, "CVE-2023-6711": {"epss_score": 0.00157, "epss_percentile": 0.37126}, "CVE-2023-6717": {"epss_score": 0.00088, "epss_percentile": 0.25782}, "CVE-2023-6718": {"epss_score": 0.00137, "epss_percentile": 0.3427}, "CVE-2023-6719": {"epss_score": 0.00067, "epss_percentile": 0.21068}, "CVE-2023-6720": {"epss_score": 0.00061, "epss_percentile": 0.19381}, "CVE-2023-6721": {"epss_score": 0.00047, "epss_percentile": 0.14492}, "CVE-2023-6722": {"epss_score": 0.00098, "epss_percentile": 0.2782}, "CVE-2023-6723": {"epss_score": 0.00051, "epss_percentile": 0.1601}, "CVE-2023-6724": {"epss_score": 0.00037, "epss_percentile": 0.10636}, "CVE-2023-6725": {"epss_score": 0.00039, "epss_percentile": 0.11644}, "CVE-2023-6727": {"epss_score": 0.00328, "epss_percentile": 0.55162}, "CVE-2023-6728": {"epss_score": 0.00016, "epss_percentile": 0.02922}, "CVE-2023-6729": {"epss_score": 0.00035, "epss_percentile": 0.10012}, "CVE-2023-6730": {"epss_score": 0.00177, "epss_percentile": 0.3957}, "CVE-2023-6731": {"epss_score": 0.00185, "epss_percentile": 0.40504}, "CVE-2023-6732": {"epss_score": 0.00078, "epss_percentile": 0.23636}, "CVE-2023-6733": {"epss_score": 0.00226, "epss_percentile": 0.45348}, "CVE-2023-6735": {"epss_score": 0.00067, "epss_percentile": 0.21028}, "CVE-2023-6736": {"epss_score": 0.00059, "epss_percentile": 0.18821}, "CVE-2023-6737": {"epss_score": 0.04624, "epss_percentile": 0.88938}, "CVE-2023-6738": {"epss_score": 0.00097, "epss_percentile": 0.27596}, "CVE-2023-6740": {"epss_score": 0.00027, "epss_percentile": 0.07087}, "CVE-2023-6741": {"epss_score": 0.00121, "epss_percentile": 0.31926}, "CVE-2023-6742": {"epss_score": 0.00127, "epss_percentile": 0.32816}, "CVE-2023-6743": {"epss_score": 0.05835, "epss_percentile": 0.90247}, "CVE-2023-6744": {"epss_score": 0.00183, "epss_percentile": 0.40342}, "CVE-2023-6745": {"epss_score": 0.00234, "epss_percentile": 0.46117}, "CVE-2023-6746": {"epss_score": 0.00181, "epss_percentile": 0.4003}, "CVE-2023-6747": {"epss_score": 0.00127, "epss_percentile": 0.32838}, "CVE-2023-6748": {"epss_score": 0.00423, "epss_percentile": 0.61585}, "CVE-2023-6749": {"epss_score": 0.00178, "epss_percentile": 0.39725}, "CVE-2023-6750": {"epss_score": 0.00321, "epss_percentile": 0.54686}, "CVE-2023-6751": {"epss_score": 0.00154, "epss_percentile": 0.36668}, "CVE-2023-6753": {"epss_score": 0.0297, "epss_percentile": 0.86092}, "CVE-2023-6755": {"epss_score": 0.00128, "epss_percentile": 0.33066}, "CVE-2023-6756": {"epss_score": 0.00279, "epss_percentile": 0.5094}, "CVE-2023-6757": {"epss_score": 0.0026, "epss_percentile": 0.49215}, "CVE-2023-6758": {"epss_score": 0.00118, "epss_percentile": 0.3145}, "CVE-2023-6759": {"epss_score": 0.00177, "epss_percentile": 0.39585}, "CVE-2023-6760": {"epss_score": 0.00166, "epss_percentile": 0.38191}, "CVE-2023-6761": {"epss_score": 0.00121, "epss_percentile": 0.31881}, "CVE-2023-6762": {"epss_score": 0.00091, "epss_percentile": 0.26245}, "CVE-2023-6764": {"epss_score": 0.02332, "epss_percentile": 0.84407}, "CVE-2023-6765": {"epss_score": 0.0013, "epss_percentile": 0.33251}, "CVE-2023-6766": {"epss_score": 0.0012, "epss_percentile": 0.31744}, "CVE-2023-6767": {"epss_score": 0.00286, "epss_percentile": 0.51694}, "CVE-2023-6768": {"epss_score": 0.00068, "epss_percentile": 0.21187}, "CVE-2023-6769": {"epss_score": 0.00155, "epss_percentile": 0.36785}, "CVE-2023-6771": {"epss_score": 0.00155, "epss_percentile": 0.36818}, "CVE-2023-6772": {"epss_score": 0.00128, "epss_percentile": 0.33066}, "CVE-2023-6773": {"epss_score": 0.00063, "epss_percentile": 0.19906}, "CVE-2023-6774": {"epss_score": 0.00141, "epss_percentile": 0.34818}, "CVE-2023-6775": {"epss_score": 0.00194, "epss_percentile": 0.41567}, "CVE-2023-6776": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2023-6777": {"epss_score": 0.02631, "epss_percentile": 0.85283}, "CVE-2023-6778": {"epss_score": 0.00195, "epss_percentile": 0.41678}, "CVE-2023-6779": {"epss_score": 0.00608, "epss_percentile": 0.69061}, "CVE-2023-6780": {"epss_score": 0.00234, "epss_percentile": 0.4612}, "CVE-2023-6781": {"epss_score": 0.00151, "epss_percentile": 0.3622}, "CVE-2023-6782": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2023-6783": {"epss_score": 0.00054, "epss_percentile": 0.17287}, "CVE-2023-6784": {"epss_score": 0.00023, "epss_percentile": 0.05654}, "CVE-2023-6785": {"epss_score": 0.00391, "epss_percentile": 0.59582}, "CVE-2023-6786": {"epss_score": 0.00991, "epss_percentile": 0.76385}, "CVE-2023-6787": {"epss_score": 0.00423, "epss_percentile": 0.61625}, "CVE-2023-6788": {"epss_score": 0.00122, "epss_percentile": 0.32086}, "CVE-2023-6789": {"epss_score": 0.00163, "epss_percentile": 0.37823}, "CVE-2023-6790": {"epss_score": 0.00193, "epss_percentile": 0.41434}, "CVE-2023-6791": {"epss_score": 0.00142, "epss_percentile": 0.35045}, "CVE-2023-6792": {"epss_score": 0.002, "epss_percentile": 0.42198}, "CVE-2023-6793": {"epss_score": 0.00079, "epss_percentile": 0.23869}, "CVE-2023-6794": {"epss_score": 0.00087, "epss_percentile": 0.25611}, "CVE-2023-6795": {"epss_score": 0.00115, "epss_percentile": 0.30981}, "CVE-2023-6798": {"epss_score": 0.00082, "epss_percentile": 0.24419}, "CVE-2023-6799": {"epss_score": 0.00477, "epss_percentile": 0.64338}, "CVE-2023-6801": {"epss_score": 0.00079, "epss_percentile": 0.23911}, "CVE-2023-6802": {"epss_score": 0.00039, "epss_percentile": 0.1157}, "CVE-2023-6803": {"epss_score": 0.00095, "epss_percentile": 0.27214}, "CVE-2023-6804": {"epss_score": 0.00077, "epss_percentile": 0.23427}, "CVE-2023-6805": {"epss_score": 0.00275, "epss_percentile": 0.50682}, "CVE-2023-6806": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2023-6807": {"epss_score": 0.00168, "epss_percentile": 0.38433}, "CVE-2023-6808": {"epss_score": 0.00195, "epss_percentile": 0.41667}, "CVE-2023-6809": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2023-6810": {"epss_score": 0.00176, "epss_percentile": 0.39424}, "CVE-2023-6811": {"epss_score": 0.0119, "epss_percentile": 0.78375}, "CVE-2023-6812": {"epss_score": 0.00285, "epss_percentile": 0.51539}, "CVE-2023-6813": {"epss_score": 0.03505, "epss_percentile": 0.87256}, "CVE-2023-6814": {"epss_score": 0.00014, "epss_percentile": 0.0204}, "CVE-2023-6815": {"epss_score": 0.00251, "epss_percentile": 0.48299}, "CVE-2023-6816": {"epss_score": 0.02845, "epss_percentile": 0.85819}, "CVE-2023-6817": {"epss_score": 0.00022, "epss_percentile": 0.05272}, "CVE-2023-6821": {"epss_score": 0.00283, "epss_percentile": 0.51406}, "CVE-2023-6824": {"epss_score": 0.00515, "epss_percentile": 0.65969}, "CVE-2023-6825": {"epss_score": 0.03748, "epss_percentile": 0.8767}, "CVE-2023-6826": {"epss_score": 0.07288, "epss_percentile": 0.91385}, "CVE-2023-6827": {"epss_score": 0.09631, "epss_percentile": 0.92632}, "CVE-2023-6828": {"epss_score": 0.01095, "epss_percentile": 0.775}, "CVE-2023-6830": {"epss_score": 0.00503, "epss_percentile": 0.65484}, "CVE-2023-6831": {"epss_score": 0.78641, "epss_percentile": 0.98995}, "CVE-2023-6832": {"epss_score": 0.00142, "epss_percentile": 0.34962}, "CVE-2023-6833": {"epss_score": 0.00024, "epss_percentile": 0.05846}, "CVE-2023-6835": {"epss_score": 0.00246, "epss_percentile": 0.47755}, "CVE-2023-6836": {"epss_score": 0.0017, "epss_percentile": 0.38744}, "CVE-2023-6837": {"epss_score": 0.00316, "epss_percentile": 0.54283}, "CVE-2023-6838": {"epss_score": 0.00593, "epss_percentile": 0.6863}, "CVE-2023-6839": {"epss_score": 0.00295, "epss_percentile": 0.52453}, "CVE-2023-6840": {"epss_score": 9e-05, "epss_percentile": 0.007}, "CVE-2023-6841": {"epss_score": 0.00613, "epss_percentile": 0.69261}, "CVE-2023-6842": {"epss_score": 0.00137, "epss_percentile": 0.34226}, "CVE-2023-6843": {"epss_score": 0.00076, "epss_percentile": 0.23219}, "CVE-2023-6844": {"epss_score": 0.00202, "epss_percentile": 0.42452}, "CVE-2023-6845": {"epss_score": 0.00279, "epss_percentile": 0.50992}, "CVE-2023-6846": {"epss_score": 0.13313, "epss_percentile": 0.93931}, "CVE-2023-6847": {"epss_score": 0.00156, "epss_percentile": 0.36979}, "CVE-2023-6848": {"epss_score": 0.00967, "epss_percentile": 0.76073}, "CVE-2023-6849": {"epss_score": 0.0019, "epss_percentile": 0.41061}, "CVE-2023-6850": {"epss_score": 0.00227, "epss_percentile": 0.45372}, "CVE-2023-6851": {"epss_score": 0.00239, "epss_percentile": 0.46929}, "CVE-2023-6852": {"epss_score": 0.00169, "epss_percentile": 0.38548}, "CVE-2023-6853": {"epss_score": 0.00169, "epss_percentile": 0.38548}, "CVE-2023-6854": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-6855": {"epss_score": 0.00347, "epss_percentile": 0.56786}, "CVE-2023-6856": {"epss_score": 0.10471, "epss_percentile": 0.92997}, "CVE-2023-6857": {"epss_score": 0.00227, "epss_percentile": 0.45442}, "CVE-2023-6858": {"epss_score": 0.00452, "epss_percentile": 0.632}, "CVE-2023-6859": {"epss_score": 0.00375, "epss_percentile": 0.5863}, "CVE-2023-6860": {"epss_score": 0.00449, "epss_percentile": 0.63057}, "CVE-2023-6861": {"epss_score": 0.00517, "epss_percentile": 0.66092}, "CVE-2023-6862": {"epss_score": 0.00441, "epss_percentile": 0.6269}, "CVE-2023-6863": {"epss_score": 0.00464, "epss_percentile": 0.63739}, "CVE-2023-6864": {"epss_score": 0.00493, "epss_percentile": 0.65033}, "CVE-2023-6865": {"epss_score": 0.00414, "epss_percentile": 0.61021}, "CVE-2023-6866": {"epss_score": 0.01258, "epss_percentile": 0.78953}, "CVE-2023-6867": {"epss_score": 0.00888, "epss_percentile": 0.75}, "CVE-2023-6868": {"epss_score": 0.00128, "epss_percentile": 0.32998}, "CVE-2023-6869": {"epss_score": 0.00183, "epss_percentile": 0.403}, "CVE-2023-6870": {"epss_score": 0.00676, "epss_percentile": 0.70922}, "CVE-2023-6871": {"epss_score": 0.00167, "epss_percentile": 0.38366}, "CVE-2023-6872": {"epss_score": 0.00251, "epss_percentile": 0.48316}, "CVE-2023-6873": {"epss_score": 0.00502, "epss_percentile": 0.65407}, "CVE-2023-6874": {"epss_score": 0.00067, "epss_percentile": 0.21098}, "CVE-2023-6875": {"epss_score": 0.93815, "epss_percentile": 0.99851}, "CVE-2023-6876": {"epss_score": 0.0015, "epss_percentile": 0.36182}, "CVE-2023-6877": {"epss_score": 0.0066, "epss_percentile": 0.70523}, "CVE-2023-6878": {"epss_score": 0.00216, "epss_percentile": 0.44228}, "CVE-2023-6879": {"epss_score": 0.00155, "epss_percentile": 0.36813}, "CVE-2023-6880": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2023-6881": {"epss_score": 0.00323, "epss_percentile": 0.54866}, "CVE-2023-6882": {"epss_score": 0.0165, "epss_percentile": 0.81565}, "CVE-2023-6883": {"epss_score": 0.00102, "epss_percentile": 0.28868}, "CVE-2023-6884": {"epss_score": 0.00169, "epss_percentile": 0.38562}, "CVE-2023-6885": {"epss_score": 0.00057, "epss_percentile": 0.1821}, "CVE-2023-6886": {"epss_score": 0.00057, "epss_percentile": 0.18026}, "CVE-2023-6887": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2023-6888": {"epss_score": 0.00292, "epss_percentile": 0.52235}, "CVE-2023-6889": {"epss_score": 0.00157, "epss_percentile": 0.37065}, "CVE-2023-6890": {"epss_score": 0.00156, "epss_percentile": 0.37016}, "CVE-2023-6891": {"epss_score": 0.00038, "epss_percentile": 0.11206}, "CVE-2023-6892": {"epss_score": 0.00134, "epss_percentile": 0.33786}, "CVE-2023-6893": {"epss_score": 0.88406, "epss_percentile": 0.99471}, "CVE-2023-6894": {"epss_score": 0.00097, "epss_percentile": 0.27634}, "CVE-2023-6895": {"epss_score": 0.92185, "epss_percentile": 0.99697}, "CVE-2023-6896": {"epss_score": 0.00107, "epss_percentile": 0.29744}, "CVE-2023-6897": {"epss_score": 0.00207, "epss_percentile": 0.43179}, "CVE-2023-6898": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-6899": {"epss_score": 0.00058, "epss_percentile": 0.18378}, "CVE-2023-6900": {"epss_score": 0.00059, "epss_percentile": 0.18727}, "CVE-2023-6901": {"epss_score": 0.00638, "epss_percentile": 0.69924}, "CVE-2023-6902": {"epss_score": 0.00079, "epss_percentile": 0.23812}, "CVE-2023-6903": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2023-6904": {"epss_score": 0.00058, "epss_percentile": 0.18518}, "CVE-2023-6905": {"epss_score": 0.00074, "epss_percentile": 0.22734}, "CVE-2023-6906": {"epss_score": 0.00193, "epss_percentile": 0.41398}, "CVE-2023-6907": {"epss_score": 0.00054, "epss_percentile": 0.17099}, "CVE-2023-6908": {"epss_score": 0.00127, "epss_percentile": 0.3282}, "CVE-2023-6909": {"epss_score": 0.86202, "epss_percentile": 0.99372}, "CVE-2023-6910": {"epss_score": 0.00071, "epss_percentile": 0.22234}, "CVE-2023-6911": {"epss_score": 0.00347, "epss_percentile": 0.56743}, "CVE-2023-6912": {"epss_score": 0.00101, "epss_percentile": 0.28617}, "CVE-2023-6913": {"epss_score": 0.00093, "epss_percentile": 0.26712}, "CVE-2023-6915": {"epss_score": 0.00011, "epss_percentile": 0.01059}, "CVE-2023-6916": {"epss_score": 0.00147, "epss_percentile": 0.35777}, "CVE-2023-6917": {"epss_score": 0.00017, "epss_percentile": 0.03312}, "CVE-2023-6918": {"epss_score": 0.00363, "epss_percentile": 0.57869}, "CVE-2023-6919": {"epss_score": 0.00238, "epss_percentile": 0.46815}, "CVE-2023-6921": {"epss_score": 0.00198, "epss_percentile": 0.41983}, "CVE-2023-6922": {"epss_score": 0.00491, "epss_percentile": 0.64954}, "CVE-2023-6923": {"epss_score": 0.02533, "epss_percentile": 0.85033}, "CVE-2023-6924": {"epss_score": 0.00184, "epss_percentile": 0.40457}, "CVE-2023-6925": {"epss_score": 0.02995, "epss_percentile": 0.86154}, "CVE-2023-6926": {"epss_score": 0.00182, "epss_percentile": 0.40252}, "CVE-2023-6927": {"epss_score": 0.00838, "epss_percentile": 0.74174}, "CVE-2023-6928": {"epss_score": 0.00082, "epss_percentile": 0.24445}, "CVE-2023-6929": {"epss_score": 0.00011, "epss_percentile": 0.00952}, "CVE-2023-6930": {"epss_score": 0.00015, "epss_percentile": 0.02342}, "CVE-2023-6931": {"epss_score": 0.00384, "epss_percentile": 0.59167}, "CVE-2023-6932": {"epss_score": 0.00045, "epss_percentile": 0.13932}, "CVE-2023-6933": {"epss_score": 0.92907, "epss_percentile": 0.99759}, "CVE-2023-6934": {"epss_score": 0.00156, "epss_percentile": 0.36975}, "CVE-2023-6935": {"epss_score": 0.00262, "epss_percentile": 0.49401}, "CVE-2023-6936": {"epss_score": 0.00255, "epss_percentile": 0.48643}, "CVE-2023-6937": {"epss_score": 0.00577, "epss_percentile": 0.68156}, "CVE-2023-6938": {"epss_score": 0.00176, "epss_percentile": 0.39472}, "CVE-2023-6939": {"epss_score": 0.00043, "epss_percentile": 0.1321}, "CVE-2023-6940": {"epss_score": 0.00151, "epss_percentile": 0.36232}, "CVE-2023-6941": {"epss_score": 0.00081, "epss_percentile": 0.24385}, "CVE-2023-6942": {"epss_score": 0.00394, "epss_percentile": 0.5979}, "CVE-2023-6943": {"epss_score": 0.0397, "epss_percentile": 0.88036}, "CVE-2023-6944": {"epss_score": 0.00216, "epss_percentile": 0.44142}, "CVE-2023-6945": {"epss_score": 0.00064, "epss_percentile": 0.20334}, "CVE-2023-6946": {"epss_score": 0.00133, "epss_percentile": 0.3371}, "CVE-2023-6947": {"epss_score": 0.02285, "epss_percentile": 0.84266}, "CVE-2023-6948": {"epss_score": 0.00063, "epss_percentile": 0.20068}, "CVE-2023-6949": {"epss_score": 0.00087, "epss_percentile": 0.25476}, "CVE-2023-6950": {"epss_score": 0.00064, "epss_percentile": 0.20282}, "CVE-2023-6951": {"epss_score": 0.00124, "epss_percentile": 0.32446}, "CVE-2023-6953": {"epss_score": 0.00266, "epss_percentile": 0.49844}, "CVE-2023-6954": {"epss_score": 0.00172, "epss_percentile": 0.39009}, "CVE-2023-6955": {"epss_score": 0.00034, "epss_percentile": 0.09715}, "CVE-2023-6956": {"epss_score": 0.01302, "epss_percentile": 0.79296}, "CVE-2023-6957": {"epss_score": 0.00229, "epss_percentile": 0.45587}, "CVE-2023-6958": {"epss_score": 0.0007, "epss_percentile": 0.21648}, "CVE-2023-6959": {"epss_score": 0.00119, "epss_percentile": 0.31582}, "CVE-2023-6960": {"epss_score": 0.00028, "epss_percentile": 0.07569}, "CVE-2023-6961": {"epss_score": 0.01446, "epss_percentile": 0.80327}, "CVE-2023-6962": {"epss_score": 0.00391, "epss_percentile": 0.59582}, "CVE-2023-6963": {"epss_score": 0.00122, "epss_percentile": 0.32098}, "CVE-2023-6964": {"epss_score": 0.00343, "epss_percentile": 0.56425}, "CVE-2023-6965": {"epss_score": 0.00222, "epss_percentile": 0.44757}, "CVE-2023-6966": {"epss_score": 0.00424, "epss_percentile": 0.61654}, "CVE-2023-6967": {"epss_score": 0.00444, "epss_percentile": 0.62837}, "CVE-2023-6968": {"epss_score": 0.00134, "epss_percentile": 0.33893}, "CVE-2023-6969": {"epss_score": 0.00231, "epss_percentile": 0.45797}, "CVE-2023-6970": {"epss_score": 0.00601, "epss_percentile": 0.68846}, "CVE-2023-6971": {"epss_score": 0.09055, "epss_percentile": 0.92381}, "CVE-2023-6972": {"epss_score": 0.03774, "epss_percentile": 0.87706}, "CVE-2023-6974": {"epss_score": 0.02591, "epss_percentile": 0.85182}, "CVE-2023-6975": {"epss_score": 0.01542, "epss_percentile": 0.8095}, "CVE-2023-6976": {"epss_score": 0.00107, "epss_percentile": 0.29639}, "CVE-2023-6977": {"epss_score": 0.84764, "epss_percentile": 0.99304}, "CVE-2023-6978": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2023-6979": {"epss_score": 0.03738, "epss_percentile": 0.87652}, "CVE-2023-6980": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2023-6981": {"epss_score": 0.00346, "epss_percentile": 0.56705}, "CVE-2023-6982": {"epss_score": 0.00193, "epss_percentile": 0.41451}, "CVE-2023-6983": {"epss_score": 0.00199, "epss_percentile": 0.42186}, "CVE-2023-6984": {"epss_score": 0.00063, "epss_percentile": 0.19811}, "CVE-2023-6985": {"epss_score": 0.06064, "epss_percentile": 0.90446}, "CVE-2023-6986": {"epss_score": 0.00125, "epss_percentile": 0.32536}, "CVE-2023-6987": {"epss_score": 0.01045, "epss_percentile": 0.77023}, "CVE-2023-6988": {"epss_score": 0.00215, "epss_percentile": 0.44031}, "CVE-2023-6989": {"epss_score": 0.67335, "epss_percentile": 0.98502}, "CVE-2023-6990": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-6991": {"epss_score": 0.0023, "epss_percentile": 0.45712}, "CVE-2023-6992": {"epss_score": 0.00021, "epss_percentile": 0.04741}, "CVE-2023-6993": {"epss_score": 0.00183, "epss_percentile": 0.40352}, "CVE-2023-6994": {"epss_score": 0.00156, "epss_percentile": 0.36975}, "CVE-2023-6996": {"epss_score": 0.00918, "epss_percentile": 0.75447}, "CVE-2023-6998": {"epss_score": 0.00012, "epss_percentile": 0.01422}, "CVE-2023-6999": {"epss_score": 0.01161, "epss_percentile": 0.7814}, "CVE-2023-7002": {"epss_score": 0.23154, "epss_percentile": 0.95742}, "CVE-2023-7003": {"epss_score": 0.00051, "epss_percentile": 0.16055}, "CVE-2023-7004": {"epss_score": 0.0002, "epss_percentile": 0.04431}, "CVE-2023-7005": {"epss_score": 0.00228, "epss_percentile": 0.45501}, "CVE-2023-7006": {"epss_score": 0.00058, "epss_percentile": 0.18542}, "CVE-2023-7007": {"epss_score": 0.00079, "epss_percentile": 0.2382}, "CVE-2023-7008": {"epss_score": 0.00477, "epss_percentile": 0.6433}, "CVE-2023-7009": {"epss_score": 0.0004, "epss_percentile": 0.12008}, "CVE-2023-7010": {"epss_score": 0.00479, "epss_percentile": 0.64441}, "CVE-2023-7011": {"epss_score": 0.00106, "epss_percentile": 0.29479}, "CVE-2023-7012": {"epss_score": 0.00055, "epss_percentile": 0.17558}, "CVE-2023-7013": {"epss_score": 0.00123, "epss_percentile": 0.32262}, "CVE-2023-7014": {"epss_score": 0.00536, "epss_percentile": 0.66868}, "CVE-2023-7015": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2023-7016": {"epss_score": 0.00144, "epss_percentile": 0.35282}, "CVE-2023-7017": {"epss_score": 0.00108, "epss_percentile": 0.29798}, "CVE-2023-7018": {"epss_score": 0.00203, "epss_percentile": 0.42524}, "CVE-2023-7019": {"epss_score": 0.00095, "epss_percentile": 0.27199}, "CVE-2023-7020": {"epss_score": 0.00055, "epss_percentile": 0.17637}, "CVE-2023-7021": {"epss_score": 0.00055, "epss_percentile": 0.17637}, "CVE-2023-7022": {"epss_score": 0.00061, "epss_percentile": 0.19481}, "CVE-2023-7023": {"epss_score": 0.00055, "epss_percentile": 0.17637}, "CVE-2023-7024": {"epss_score": 0.02901, "epss_percentile": 0.85954}, "CVE-2023-7025": {"epss_score": 0.00043, "epss_percentile": 0.1307}, "CVE-2023-7026": {"epss_score": 0.00131, "epss_percentile": 0.33499}, "CVE-2023-7027": {"epss_score": 0.00429, "epss_percentile": 0.61963}, "CVE-2023-7028": {"epss_score": 0.93604, "epss_percentile": 0.99823}, "CVE-2023-7029": {"epss_score": 0.00213, "epss_percentile": 0.43899}, "CVE-2023-7030": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2023-7031": {"epss_score": 0.00072, "epss_percentile": 0.22362}, "CVE-2023-7032": {"epss_score": 0.00135, "epss_percentile": 0.33982}, "CVE-2023-7033": {"epss_score": 0.00037, "epss_percentile": 0.10677}, "CVE-2023-7035": {"epss_score": 0.00145, "epss_percentile": 0.35372}, "CVE-2023-7036": {"epss_score": 0.0014, "epss_percentile": 0.34737}, "CVE-2023-7037": {"epss_score": 0.00159, "epss_percentile": 0.37337}, "CVE-2023-7038": {"epss_score": 0.00185, "epss_percentile": 0.40463}, "CVE-2023-7039": {"epss_score": 0.0058, "epss_percentile": 0.68243}, "CVE-2023-7040": {"epss_score": 0.00367, "epss_percentile": 0.58141}, "CVE-2023-7041": {"epss_score": 0.00139, "epss_percentile": 0.34657}, "CVE-2023-7042": {"epss_score": 0.00022, "epss_percentile": 0.05025}, "CVE-2023-7043": {"epss_score": 0.00089, "epss_percentile": 0.2585}, "CVE-2023-7044": {"epss_score": 0.00122, "epss_percentile": 0.32038}, "CVE-2023-7045": {"epss_score": 0.00139, "epss_percentile": 0.34634}, "CVE-2023-7046": {"epss_score": 0.00682, "epss_percentile": 0.71072}, "CVE-2023-7047": {"epss_score": 0.0005, "epss_percentile": 0.1583}, "CVE-2023-7048": {"epss_score": 0.00122, "epss_percentile": 0.32151}, "CVE-2023-7049": {"epss_score": 0.00202, "epss_percentile": 0.42433}, "CVE-2023-7050": {"epss_score": 0.00191, "epss_percentile": 0.41206}, "CVE-2023-7051": {"epss_score": 0.00162, "epss_percentile": 0.37625}, "CVE-2023-7052": {"epss_score": 0.00114, "epss_percentile": 0.30781}, "CVE-2023-7053": {"epss_score": 0.0025, "epss_percentile": 0.481}, "CVE-2023-7054": {"epss_score": 0.00143, "epss_percentile": 0.35163}, "CVE-2023-7055": {"epss_score": 0.00082, "epss_percentile": 0.24494}, "CVE-2023-7056": {"epss_score": 0.00101, "epss_percentile": 0.28713}, "CVE-2023-7057": {"epss_score": 0.0011, "epss_percentile": 0.30197}, "CVE-2023-7058": {"epss_score": 0.00222, "epss_percentile": 0.44796}, "CVE-2023-7059": {"epss_score": 0.00185, "epss_percentile": 0.40568}, "CVE-2023-7060": {"epss_score": 0.00197, "epss_percentile": 0.41844}, "CVE-2023-7061": {"epss_score": 0.1579, "epss_percentile": 0.9451}, "CVE-2023-7062": {"epss_score": 0.03293, "epss_percentile": 0.86843}, "CVE-2023-7063": {"epss_score": 0.01381, "epss_percentile": 0.79869}, "CVE-2023-7064": {"epss_score": 0.00802, "epss_percentile": 0.73582}, "CVE-2023-7065": {"epss_score": 0.00045, "epss_percentile": 0.13952}, "CVE-2023-7066": {"epss_score": 0.00235, "epss_percentile": 0.46324}, "CVE-2023-7067": {"epss_score": 0.00108, "epss_percentile": 0.2977}, "CVE-2023-7068": {"epss_score": 0.00257, "epss_percentile": 0.48862}, "CVE-2023-7069": {"epss_score": 0.00079, "epss_percentile": 0.23911}, "CVE-2023-7070": {"epss_score": 0.00164, "epss_percentile": 0.37943}, "CVE-2023-7071": {"epss_score": 0.00182, "epss_percentile": 0.40231}, "CVE-2023-7072": {"epss_score": 0.01009, "epss_percentile": 0.76584}, "CVE-2023-7073": {"epss_score": 0.00243, "epss_percentile": 0.47415}, "CVE-2023-7074": {"epss_score": 0.00137, "epss_percentile": 0.34301}, "CVE-2023-7075": {"epss_score": 0.0012, "epss_percentile": 0.31742}, "CVE-2023-7076": {"epss_score": 0.00148, "epss_percentile": 0.35922}, "CVE-2023-7077": {"epss_score": 0.0075, "epss_percentile": 0.72633}, "CVE-2023-7078": {"epss_score": 0.00046, "epss_percentile": 0.14459}, "CVE-2023-7079": {"epss_score": 0.00062, "epss_percentile": 0.19691}, "CVE-2023-7080": {"epss_score": 0.00037, "epss_percentile": 0.10842}, "CVE-2023-7081": {"epss_score": 0.00072, "epss_percentile": 0.223}, "CVE-2023-7082": {"epss_score": 0.03529, "epss_percentile": 0.87298}, "CVE-2023-7083": {"epss_score": 0.00173, "epss_percentile": 0.39127}, "CVE-2023-7084": {"epss_score": 0.00156, "epss_percentile": 0.36977}, "CVE-2023-7085": {"epss_score": 0.00115, "epss_percentile": 0.30921}, "CVE-2023-7086": {"epss_score": 0.00084, "epss_percentile": 0.24956}, "CVE-2023-7088": {"epss_score": 0.00084, "epss_percentile": 0.24956}, "CVE-2023-7089": {"epss_score": 0.00109, "epss_percentile": 0.30018}, "CVE-2023-7090": {"epss_score": 0.00046, "epss_percentile": 0.14361}, "CVE-2023-7091": {"epss_score": 0.00269, "epss_percentile": 0.50192}, "CVE-2023-7092": {"epss_score": 0.00086, "epss_percentile": 0.25318}, "CVE-2023-7093": {"epss_score": 0.00062, "epss_percentile": 0.19703}, "CVE-2023-7094": {"epss_score": 0.0008, "epss_percentile": 0.24068}, "CVE-2023-7095": {"epss_score": 0.14236, "epss_percentile": 0.94168}, "CVE-2023-7096": {"epss_score": 0.00069, "epss_percentile": 0.21601}, "CVE-2023-7097": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-7098": {"epss_score": 0.00142, "epss_percentile": 0.35016}, "CVE-2023-7099": {"epss_score": 0.00044, "epss_percentile": 0.13536}, "CVE-2023-7100": {"epss_score": 0.00105, "epss_percentile": 0.29255}, "CVE-2023-7101": {"epss_score": 0.84478, "epss_percentile": 0.99291}, "CVE-2023-7102": {"epss_score": 0.09511, "epss_percentile": 0.92578}, "CVE-2023-7103": {"epss_score": 0.00021, "epss_percentile": 0.04716}, "CVE-2023-7104": {"epss_score": 0.00129, "epss_percentile": 0.33145}, "CVE-2023-7105": {"epss_score": 0.00209, "epss_percentile": 0.43346}, "CVE-2023-7106": {"epss_score": 0.00093, "epss_percentile": 0.26622}, "CVE-2023-7107": {"epss_score": 0.00067, "epss_percentile": 0.21176}, "CVE-2023-7108": {"epss_score": 0.00238, "epss_percentile": 0.46838}, "CVE-2023-7109": {"epss_score": 0.00073, "epss_percentile": 0.22652}, "CVE-2023-7110": {"epss_score": 0.00082, "epss_percentile": 0.24405}, "CVE-2023-7111": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2023-7113": {"epss_score": 0.00726, "epss_percentile": 0.72072}, "CVE-2023-7114": {"epss_score": 0.00286, "epss_percentile": 0.51776}, "CVE-2023-7115": {"epss_score": 0.00189, "epss_percentile": 0.40935}, "CVE-2023-7116": {"epss_score": 0.53813, "epss_percentile": 0.97898}, "CVE-2023-7123": {"epss_score": 0.00048, "epss_percentile": 0.14983}, "CVE-2023-7124": {"epss_score": 0.00066, "epss_percentile": 0.20764}, "CVE-2023-7125": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2023-7126": {"epss_score": 0.00123, "epss_percentile": 0.3224}, "CVE-2023-7127": {"epss_score": 0.00113, "epss_percentile": 0.3065}, "CVE-2023-7128": {"epss_score": 0.00113, "epss_percentile": 0.30662}, "CVE-2023-7129": {"epss_score": 0.00113, "epss_percentile": 0.30662}, "CVE-2023-7130": {"epss_score": 0.00065, "epss_percentile": 0.20573}, "CVE-2023-7131": {"epss_score": 0.00123, "epss_percentile": 0.32226}, "CVE-2023-7132": {"epss_score": 0.0015, "epss_percentile": 0.36129}, "CVE-2023-7133": {"epss_score": 0.00145, "epss_percentile": 0.35437}, "CVE-2023-7134": {"epss_score": 0.00107, "epss_percentile": 0.29726}, "CVE-2023-7135": {"epss_score": 0.0013, "epss_percentile": 0.3334}, "CVE-2023-7136": {"epss_score": 0.0013, "epss_percentile": 0.3334}, "CVE-2023-7137": {"epss_score": 0.04556, "epss_percentile": 0.88845}, "CVE-2023-7138": {"epss_score": 0.00123, "epss_percentile": 0.3224}, "CVE-2023-7139": {"epss_score": 0.00107, "epss_percentile": 0.29643}, "CVE-2023-7140": {"epss_score": 0.00107, "epss_percentile": 0.29643}, "CVE-2023-7141": {"epss_score": 0.00103, "epss_percentile": 0.29086}, "CVE-2023-7142": {"epss_score": 0.00107, "epss_percentile": 0.29643}, "CVE-2023-7143": {"epss_score": 0.00103, "epss_percentile": 0.29006}, "CVE-2023-7144": {"epss_score": 0.00111, "epss_percentile": 0.30288}, "CVE-2023-7145": {"epss_score": 0.00111, "epss_percentile": 0.30288}, "CVE-2023-7146": {"epss_score": 0.00111, "epss_percentile": 0.30288}, "CVE-2023-7147": {"epss_score": 0.00165, "epss_percentile": 0.38107}, "CVE-2023-7148": {"epss_score": 0.00117, "epss_percentile": 0.31341}, "CVE-2023-7149": {"epss_score": 0.00128, "epss_percentile": 0.32996}, "CVE-2023-7150": {"epss_score": 0.0013, "epss_percentile": 0.33226}, "CVE-2023-7151": {"epss_score": 0.00257, "epss_percentile": 0.48926}, "CVE-2023-7152": {"epss_score": 0.00089, "epss_percentile": 0.25932}, "CVE-2023-7153": {"epss_score": 0.00082, "epss_percentile": 0.24435}, "CVE-2023-7154": {"epss_score": 0.00171, "epss_percentile": 0.38784}, "CVE-2023-7155": {"epss_score": 0.00123, "epss_percentile": 0.3224}, "CVE-2023-7156": {"epss_score": 0.0009, "epss_percentile": 0.26161}, "CVE-2023-7157": {"epss_score": 0.00123, "epss_percentile": 0.3224}, "CVE-2023-7158": {"epss_score": 0.00245, "epss_percentile": 0.47692}, "CVE-2023-7159": {"epss_score": 0.00111, "epss_percentile": 0.30355}, "CVE-2023-7160": {"epss_score": 0.00095, "epss_percentile": 0.27087}, "CVE-2023-7161": {"epss_score": 0.00131, "epss_percentile": 0.33405}, "CVE-2023-7163": {"epss_score": 0.03444, "epss_percentile": 0.87145}, "CVE-2023-7164": {"epss_score": 0.35384, "epss_percentile": 0.96904}, "CVE-2023-7165": {"epss_score": 0.00649, "epss_percentile": 0.70228}, "CVE-2023-7166": {"epss_score": 0.00128, "epss_percentile": 0.32996}, "CVE-2023-7167": {"epss_score": 0.00257, "epss_percentile": 0.48926}, "CVE-2023-7168": {"epss_score": 0.00055, "epss_percentile": 0.17531}, "CVE-2023-7169": {"epss_score": 8e-05, "epss_percentile": 0.00543}, "CVE-2023-7170": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-7171": {"epss_score": 0.00101, "epss_percentile": 0.28645}, "CVE-2023-7172": {"epss_score": 0.01684, "epss_percentile": 0.81743}, "CVE-2023-7173": {"epss_score": 0.09033, "epss_percentile": 0.92375}, "CVE-2023-7174": {"epss_score": 0.00032, "epss_percentile": 0.08731}, "CVE-2023-7175": {"epss_score": 0.00044, "epss_percentile": 0.13677}, "CVE-2023-7176": {"epss_score": 0.00052, "epss_percentile": 0.16409}, "CVE-2023-7177": {"epss_score": 0.00026, "epss_percentile": 0.06725}, "CVE-2023-7178": {"epss_score": 0.00023, "epss_percentile": 0.05403}, "CVE-2023-7179": {"epss_score": 0.00026, "epss_percentile": 0.06725}, "CVE-2023-7180": {"epss_score": 0.00042, "epss_percentile": 0.12646}, "CVE-2023-7181": {"epss_score": 0.00046, "epss_percentile": 0.14464}, "CVE-2023-7183": {"epss_score": 0.00065, "epss_percentile": 0.20483}, "CVE-2023-7184": {"epss_score": 0.00014, "epss_percentile": 0.0196}, "CVE-2023-7185": {"epss_score": 0.00014, "epss_percentile": 0.0196}, "CVE-2023-7186": {"epss_score": 0.00037, "epss_percentile": 0.10656}, "CVE-2023-7187": {"epss_score": 0.00046, "epss_percentile": 0.14124}, "CVE-2023-7188": {"epss_score": 0.00047, "epss_percentile": 0.14622}, "CVE-2023-7189": {"epss_score": 0.00045, "epss_percentile": 0.13718}, "CVE-2023-7190": {"epss_score": 0.00045, "epss_percentile": 0.13718}, "CVE-2023-7191": {"epss_score": 0.00045, "epss_percentile": 0.13718}, "CVE-2023-7192": {"epss_score": 0.00022, "epss_percentile": 0.05217}, "CVE-2023-7193": {"epss_score": 0.00054, "epss_percentile": 0.17181}, "CVE-2023-7194": {"epss_score": 0.00117, "epss_percentile": 0.31276}, "CVE-2023-7195": {"epss_score": 0.00062, "epss_percentile": 0.19637}, "CVE-2023-7196": {"epss_score": 0.00062, "epss_percentile": 0.19637}, "CVE-2023-7197": {"epss_score": 0.00032, "epss_percentile": 0.08731}, "CVE-2023-7198": {"epss_score": 0.00116, "epss_percentile": 0.31199}, "CVE-2023-7199": {"epss_score": 0.00438, "epss_percentile": 0.62539}, "CVE-2023-7200": {"epss_score": 0.00325, "epss_percentile": 0.54981}, "CVE-2023-7201": {"epss_score": 0.00227, "epss_percentile": 0.45422}, "CVE-2023-7202": {"epss_score": 0.00089, "epss_percentile": 0.25978}, "CVE-2023-7203": {"epss_score": 0.0025, "epss_percentile": 0.48088}, "CVE-2023-7204": {"epss_score": 0.00284, "epss_percentile": 0.51474}, "CVE-2023-7206": {"epss_score": 0.00036, "epss_percentile": 0.10295}, "CVE-2023-7207": {"epss_score": 0.00061, "epss_percentile": 0.19278}, "CVE-2023-7208": {"epss_score": 0.00509, "epss_percentile": 0.65744}, "CVE-2023-7209": {"epss_score": 0.00071, "epss_percentile": 0.22011}, "CVE-2023-7210": {"epss_score": 0.00079, "epss_percentile": 0.23976}, "CVE-2023-7211": {"epss_score": 0.00081, "epss_percentile": 0.24265}, "CVE-2023-7212": {"epss_score": 0.00041, "epss_percentile": 0.12422}, "CVE-2023-7213": {"epss_score": 0.00084, "epss_percentile": 0.24832}, "CVE-2023-7214": {"epss_score": 0.00084, "epss_percentile": 0.24832}, "CVE-2023-7215": {"epss_score": 0.00144, "epss_percentile": 0.35301}, "CVE-2023-7216": {"epss_score": 0.00178, "epss_percentile": 0.3965}, "CVE-2023-7218": {"epss_score": 0.00202, "epss_percentile": 0.42459}, "CVE-2023-7219": {"epss_score": 0.00089, "epss_percentile": 0.25888}, "CVE-2023-7220": {"epss_score": 0.00128, "epss_percentile": 0.32971}, "CVE-2023-7221": {"epss_score": 0.00468, "epss_percentile": 0.63895}, "CVE-2023-7222": {"epss_score": 0.00192, "epss_percentile": 0.41371}, "CVE-2023-7223": {"epss_score": 0.00195, "epss_percentile": 0.41602}, "CVE-2023-7224": {"epss_score": 0.00112, "epss_percentile": 0.30546}, "CVE-2023-7225": {"epss_score": 0.00119, "epss_percentile": 0.31666}, "CVE-2023-7226": {"epss_score": 0.00144, "epss_percentile": 0.3534}, "CVE-2023-7227": {"epss_score": 0.0055, "epss_percentile": 0.67332}, "CVE-2023-7228": {"epss_score": 0.00082, "epss_percentile": 0.24425}, "CVE-2023-7229": {"epss_score": 0.00033, "epss_percentile": 0.09174}, "CVE-2023-7230": {"epss_score": 0.00059, "epss_percentile": 0.18847}, "CVE-2023-7231": {"epss_score": 0.00083, "epss_percentile": 0.24744}, "CVE-2023-7232": {"epss_score": 0.00314, "epss_percentile": 0.54132}, "CVE-2023-7233": {"epss_score": 0.00159, "epss_percentile": 0.37409}, "CVE-2023-7234": {"epss_score": 0.00114, "epss_percentile": 0.30773}, "CVE-2023-7235": {"epss_score": 0.00029, "epss_percentile": 0.07682}, "CVE-2023-7236": {"epss_score": 0.00419, "epss_percentile": 0.61351}, "CVE-2023-7237": {"epss_score": 0.00055, "epss_percentile": 0.17486}, "CVE-2023-7238": {"epss_score": 0.00199, "epss_percentile": 0.42111}, "CVE-2023-7239": {"epss_score": 0.00196, "epss_percentile": 0.41758}, "CVE-2023-7240": {"epss_score": 0.00158, "epss_percentile": 0.37152}, "CVE-2023-7241": {"epss_score": 0.00052, "epss_percentile": 0.1641}, "CVE-2023-7242": {"epss_score": 0.00125, "epss_percentile": 0.32578}, "CVE-2023-7243": {"epss_score": 0.0016, "epss_percentile": 0.37507}, "CVE-2023-7244": {"epss_score": 0.0016, "epss_percentile": 0.37507}, "CVE-2023-7245": {"epss_score": 0.00186, "epss_percentile": 0.40611}, "CVE-2023-7246": {"epss_score": 0.01795, "epss_percentile": 0.82296}, "CVE-2023-7247": {"epss_score": 0.00286, "epss_percentile": 0.51738}, "CVE-2023-7248": {"epss_score": 0.00027, "epss_percentile": 0.06924}, "CVE-2023-7249": {"epss_score": 0.00424, "epss_percentile": 0.61671}, "CVE-2023-7250": {"epss_score": 0.00054, "epss_percentile": 0.17148}, "CVE-2023-7251": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2023-7252": {"epss_score": 0.00328, "epss_percentile": 0.55192}, "CVE-2023-7253": {"epss_score": 0.00172, "epss_percentile": 0.38994}, "CVE-2023-7256": {"epss_score": 0.00014, "epss_percentile": 0.02078}, "CVE-2023-7258": {"epss_score": 0.00124, "epss_percentile": 0.32454}, "CVE-2023-7259": {"epss_score": 0.00097, "epss_percentile": 0.27516}, "CVE-2023-7260": {"epss_score": 0.00194, "epss_percentile": 0.41585}, "CVE-2023-7261": {"epss_score": 0.0004, "epss_percentile": 0.11904}, "CVE-2023-7263": {"epss_score": 0.00091, "epss_percentile": 0.26269}, "CVE-2023-7264": {"epss_score": 0.02393, "epss_percentile": 0.84607}, "CVE-2023-7265": {"epss_score": 0.0003, "epss_percentile": 0.0823}, "CVE-2023-7266": {"epss_score": 0.00112, "epss_percentile": 0.30539}, "CVE-2023-7268": {"epss_score": 0.00178, "epss_percentile": 0.39663}, "CVE-2023-7269": {"epss_score": 0.00084, "epss_percentile": 0.24912}, "CVE-2023-7270": {"epss_score": 0.00054, "epss_percentile": 0.17136}, "CVE-2023-7271": {"epss_score": 0.00061, "epss_percentile": 0.19544}, "CVE-2023-7272": {"epss_score": 0.00566, "epss_percentile": 0.67819}, "CVE-2023-7273": {"epss_score": 0.00042, "epss_percentile": 0.12813}, "CVE-2023-7279": {"epss_score": 0.00089, "epss_percentile": 0.2591}, "CVE-2023-7281": {"epss_score": 0.00152, "epss_percentile": 0.36461}, "CVE-2023-7282": {"epss_score": 0.00235, "epss_percentile": 0.46208}, "CVE-2023-7286": {"epss_score": 0.00773, "epss_percentile": 0.73057}, "CVE-2023-7287": {"epss_score": 0.00158, "epss_percentile": 0.37282}, "CVE-2023-7288": {"epss_score": 0.00155, "epss_percentile": 0.36855}, "CVE-2023-7289": {"epss_score": 0.00133, "epss_percentile": 0.33717}, "CVE-2023-7290": {"epss_score": 0.00177, "epss_percentile": 0.39529}, "CVE-2023-7291": {"epss_score": 0.00344, "epss_percentile": 0.56496}, "CVE-2023-7292": {"epss_score": 0.00188, "epss_percentile": 0.40889}, "CVE-2023-7293": {"epss_score": 0.00177, "epss_percentile": 0.39529}, "CVE-2023-7294": {"epss_score": 0.00181, "epss_percentile": 0.40097}, "CVE-2023-7295": {"epss_score": 0.01474, "epss_percentile": 0.8052}, "CVE-2023-7296": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2023-7297": {"epss_score": 0.00016, "epss_percentile": 0.02649}, "CVE-2023-7298": {"epss_score": 0.00173, "epss_percentile": 0.39087}, "CVE-2023-7299": {"epss_score": 0.00071, "epss_percentile": 0.22102}, "CVE-2023-7300": {"epss_score": 0.00065, "epss_percentile": 0.20594}, "CVE-2023-7303": {"epss_score": 0.00035, "epss_percentile": 0.09891}, "CVE-2023-7304": {"epss_score": 0.03399, "epss_percentile": 0.87066}, "CVE-2023-7305": {"epss_score": 0.00105, "epss_percentile": 0.29301}, "CVE-2023-7306": {"epss_score": 0.00119, "epss_percentile": 0.31612}, "CVE-2023-7307": {"epss_score": 0.00268, "epss_percentile": 0.50065}, "CVE-2023-7308": {"epss_score": 0.00526, "epss_percentile": 0.66433}, "CVE-2023-7309": {"epss_score": 0.01255, "epss_percentile": 0.78924}, "CVE-2023-7311": {"epss_score": 0.00629, "epss_percentile": 0.69684}, "CVE-2023-7312": {"epss_score": 0.00478, "epss_percentile": 0.64386}, "CVE-2023-7313": {"epss_score": 0.00172, "epss_percentile": 0.38996}, "CVE-2023-7314": {"epss_score": 0.00172, "epss_percentile": 0.38996}, "CVE-2023-7315": {"epss_score": 0.00172, "epss_percentile": 0.38996}, "CVE-2023-7316": {"epss_score": 0.0074, "epss_percentile": 0.72399}, "CVE-2023-7317": {"epss_score": 0.00329, "epss_percentile": 0.55379}, "CVE-2023-7318": {"epss_score": 0.0074, "epss_percentile": 0.72399}, "CVE-2023-7319": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2023-7320": {"epss_score": 0.00053, "epss_percentile": 0.16968}, "CVE-2023-7321": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2023-7322": {"epss_score": 0.00293, "epss_percentile": 0.52327}, "CVE-2023-7323": {"epss_score": 0.00503, "epss_percentile": 0.6548}, "CVE-2023-7324": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2023-7325": {"epss_score": 0.00058, "epss_percentile": 0.18398}, "CVE-2023-7326": {"epss_score": 0.00211, "epss_percentile": 0.43713}, "CVE-2023-7327": {"epss_score": 0.00336, "epss_percentile": 0.55946}, "CVE-2023-7328": {"epss_score": 0.00061, "epss_percentile": 0.19534}, "CVE-2023-7329": {"epss_score": 0.00609, "epss_percentile": 0.69099}, "CVE-2023-7330": {"epss_score": 0.00403, "epss_percentile": 0.60369}, "CVE-2023-7331": {"epss_score": 0.00034, "epss_percentile": 0.09525}, "CVE-2023-7332": {"epss_score": 0.00219, "epss_percentile": 0.44487}, "CVE-2023-7333": {"epss_score": 0.00021, "epss_percentile": 0.0491}, "CVE-2024-0001": {"epss_score": 0.01628, "epss_percentile": 0.81435}, "CVE-2024-0002": {"epss_score": 0.00444, "epss_percentile": 0.6283}, "CVE-2024-0003": {"epss_score": 0.00265, "epss_percentile": 0.49827}, "CVE-2024-0004": {"epss_score": 0.00343, "epss_percentile": 0.56441}, "CVE-2024-0005": {"epss_score": 0.00265, "epss_percentile": 0.4978}, "CVE-2024-0006": {"epss_score": 0.00073, "epss_percentile": 0.22672}, "CVE-2024-0007": {"epss_score": 0.00533, "epss_percentile": 0.66715}, "CVE-2024-0008": {"epss_score": 0.00249, "epss_percentile": 0.48066}, "CVE-2024-0009": {"epss_score": 0.00095, "epss_percentile": 0.27123}, "CVE-2024-0010": {"epss_score": 0.03048, "epss_percentile": 0.86286}, "CVE-2024-0011": {"epss_score": 0.00748, "epss_percentile": 0.72577}, "CVE-2024-0012": {"epss_score": 0.943, "epss_percentile": 0.9994}, "CVE-2024-0014": {"epss_score": 0.00088, "epss_percentile": 0.25742}, "CVE-2024-0015": {"epss_score": 0.03014, "epss_percentile": 0.86209}, "CVE-2024-0016": {"epss_score": 0.00189, "epss_percentile": 0.40962}, "CVE-2024-0017": {"epss_score": 3e-05, "epss_percentile": 0.00102}, "CVE-2024-0018": {"epss_score": 0.00025, "epss_percentile": 0.06344}, "CVE-2024-0019": {"epss_score": 0.00027, "epss_percentile": 0.0688}, "CVE-2024-0020": {"epss_score": 0.00021, "epss_percentile": 0.04946}, "CVE-2024-0021": {"epss_score": 0.0002, "epss_percentile": 0.04531}, "CVE-2024-0022": {"epss_score": 0.00029, "epss_percentile": 0.07902}, "CVE-2024-0023": {"epss_score": 0.02837, "epss_percentile": 0.85792}, "CVE-2024-0024": {"epss_score": 0.00032, "epss_percentile": 0.08988}, "CVE-2024-0025": {"epss_score": 0.00033, "epss_percentile": 0.09395}, "CVE-2024-0026": {"epss_score": 0.00048, "epss_percentile": 0.15267}, "CVE-2024-0027": {"epss_score": 0.00046, "epss_percentile": 0.14333}, "CVE-2024-0028": {"epss_score": 8e-05, "epss_percentile": 0.00468}, "CVE-2024-0029": {"epss_score": 0.00093, "epss_percentile": 0.26718}, "CVE-2024-0030": {"epss_score": 0.01513, "epss_percentile": 0.80789}, "CVE-2024-0031": {"epss_score": 0.01368, "epss_percentile": 0.79788}, "CVE-2024-0032": {"epss_score": 0.0002, "epss_percentile": 0.04559}, "CVE-2024-0033": {"epss_score": 0.00063, "epss_percentile": 0.19935}, "CVE-2024-0034": {"epss_score": 4e-05, "epss_percentile": 0.0015}, "CVE-2024-0035": {"epss_score": 0.00028, "epss_percentile": 0.07351}, "CVE-2024-0036": {"epss_score": 4e-05, "epss_percentile": 0.00158}, "CVE-2024-0037": {"epss_score": 0.00018, "epss_percentile": 0.03896}, "CVE-2024-0038": {"epss_score": 0.00026, "epss_percentile": 0.06463}, "CVE-2024-0039": {"epss_score": 0.26245, "epss_percentile": 0.96129}, "CVE-2024-0040": {"epss_score": 0.18373, "epss_percentile": 0.95007}, "CVE-2024-0041": {"epss_score": 0.00022, "epss_percentile": 0.05025}, "CVE-2024-0042": {"epss_score": 8e-05, "epss_percentile": 0.00479}, "CVE-2024-0043": {"epss_score": 0.00036, "epss_percentile": 0.1024}, "CVE-2024-0044": {"epss_score": 0.07841, "epss_percentile": 0.91711}, "CVE-2024-0045": {"epss_score": 0.00096, "epss_percentile": 0.27381}, "CVE-2024-0046": {"epss_score": 3e-05, "epss_percentile": 0.00122}, "CVE-2024-0047": {"epss_score": 0.00039, "epss_percentile": 0.11457}, "CVE-2024-0048": {"epss_score": 0.00021, "epss_percentile": 0.04731}, "CVE-2024-0049": {"epss_score": 0.0004, "epss_percentile": 0.11971}, "CVE-2024-0050": {"epss_score": 0.00021, "epss_percentile": 0.04943}, "CVE-2024-0051": {"epss_score": 0.00082, "epss_percentile": 0.24498}, "CVE-2024-0052": {"epss_score": 0.00023, "epss_percentile": 0.05591}, "CVE-2024-0053": {"epss_score": 0.00023, "epss_percentile": 0.05486}, "CVE-2024-0054": {"epss_score": 0.00069, "epss_percentile": 0.21459}, "CVE-2024-0055": {"epss_score": 0.00069, "epss_percentile": 0.21459}, "CVE-2024-0056": {"epss_score": 0.00383, "epss_percentile": 0.59099}, "CVE-2024-0057": {"epss_score": 0.02349, "epss_percentile": 0.84464}, "CVE-2024-0066": {"epss_score": 0.00073, "epss_percentile": 0.22482}, "CVE-2024-0067": {"epss_score": 0.00165, "epss_percentile": 0.38063}, "CVE-2024-0068": {"epss_score": 0.00064, "epss_percentile": 0.20205}, "CVE-2024-0071": {"epss_score": 0.00054, "epss_percentile": 0.17178}, "CVE-2024-0072": {"epss_score": 0.00024, "epss_percentile": 0.05891}, "CVE-2024-0073": {"epss_score": 0.00035, "epss_percentile": 0.09879}, "CVE-2024-0074": {"epss_score": 0.00033, "epss_percentile": 0.09423}, "CVE-2024-0075": {"epss_score": 0.00031, "epss_percentile": 0.08547}, "CVE-2024-0076": {"epss_score": 0.00024, "epss_percentile": 0.05812}, "CVE-2024-0077": {"epss_score": 0.00033, "epss_percentile": 0.09397}, "CVE-2024-0078": {"epss_score": 0.00027, "epss_percentile": 0.06952}, "CVE-2024-0079": {"epss_score": 0.00032, "epss_percentile": 0.09071}, "CVE-2024-0080": {"epss_score": 0.00024, "epss_percentile": 0.05968}, "CVE-2024-0081": {"epss_score": 0.0009, "epss_percentile": 0.26008}, "CVE-2024-0082": {"epss_score": 0.00057, "epss_percentile": 0.18121}, "CVE-2024-0083": {"epss_score": 0.00267, "epss_percentile": 0.49959}, "CVE-2024-0084": {"epss_score": 0.00198, "epss_percentile": 0.41993}, "CVE-2024-0085": {"epss_score": 0.00099, "epss_percentile": 0.28411}, "CVE-2024-0086": {"epss_score": 0.0006, "epss_percentile": 0.18934}, "CVE-2024-0087": {"epss_score": 0.006, "epss_percentile": 0.68827}, "CVE-2024-0088": {"epss_score": 0.00203, "epss_percentile": 0.42536}, "CVE-2024-0089": {"epss_score": 0.00171, "epss_percentile": 0.38793}, "CVE-2024-0090": {"epss_score": 0.00278, "epss_percentile": 0.5089}, "CVE-2024-0091": {"epss_score": 0.00166, "epss_percentile": 0.38158}, "CVE-2024-0092": {"epss_score": 0.0014, "epss_percentile": 0.34703}, "CVE-2024-0093": {"epss_score": 0.00241, "epss_percentile": 0.47273}, "CVE-2024-0094": {"epss_score": 0.0006, "epss_percentile": 0.18934}, "CVE-2024-0095": {"epss_score": 0.00504, "epss_percentile": 0.6549}, "CVE-2024-0096": {"epss_score": 0.00103, "epss_percentile": 0.29058}, "CVE-2024-0097": {"epss_score": 0.00113, "epss_percentile": 0.30606}, "CVE-2024-0098": {"epss_score": 0.00063, "epss_percentile": 0.20078}, "CVE-2024-0099": {"epss_score": 0.00076, "epss_percentile": 0.23179}, "CVE-2024-0100": {"epss_score": 0.00215, "epss_percentile": 0.44062}, "CVE-2024-0101": {"epss_score": 0.00614, "epss_percentile": 0.69287}, "CVE-2024-0102": {"epss_score": 0.00043, "epss_percentile": 0.13273}, "CVE-2024-0103": {"epss_score": 0.00518, "epss_percentile": 0.66104}, "CVE-2024-0104": {"epss_score": 0.00361, "epss_percentile": 0.57724}, "CVE-2024-0105": {"epss_score": 0.0005, "epss_percentile": 0.15865}, "CVE-2024-0106": {"epss_score": 0.00038, "epss_percentile": 0.1127}, "CVE-2024-0107": {"epss_score": 0.00248, "epss_percentile": 0.47915}, "CVE-2024-0108": {"epss_score": 0.00103, "epss_percentile": 0.29057}, "CVE-2024-0109": {"epss_score": 0.00048, "epss_percentile": 0.14962}, "CVE-2024-0110": {"epss_score": 0.00165, "epss_percentile": 0.38076}, "CVE-2024-0111": {"epss_score": 0.00082, "epss_percentile": 0.24413}, "CVE-2024-0112": {"epss_score": 0.00021, "epss_percentile": 0.04925}, "CVE-2024-0113": {"epss_score": 0.00362, "epss_percentile": 0.57764}, "CVE-2024-0114": {"epss_score": 8e-05, "epss_percentile": 0.00568}, "CVE-2024-0115": {"epss_score": 0.00057, "epss_percentile": 0.18123}, "CVE-2024-0116": {"epss_score": 0.00208, "epss_percentile": 0.43301}, "CVE-2024-0117": {"epss_score": 0.00095, "epss_percentile": 0.27201}, "CVE-2024-0118": {"epss_score": 0.00095, "epss_percentile": 0.27201}, "CVE-2024-0119": {"epss_score": 0.00095, "epss_percentile": 0.27201}, "CVE-2024-0120": {"epss_score": 0.00095, "epss_percentile": 0.27201}, "CVE-2024-0121": {"epss_score": 0.0007, "epss_percentile": 0.21803}, "CVE-2024-0122": {"epss_score": 0.00027, "epss_percentile": 0.06922}, "CVE-2024-0123": {"epss_score": 0.00033, "epss_percentile": 0.09122}, "CVE-2024-0124": {"epss_score": 0.00067, "epss_percentile": 0.20994}, "CVE-2024-0125": {"epss_score": 0.00045, "epss_percentile": 0.13718}, "CVE-2024-0126": {"epss_score": 0.00058, "epss_percentile": 0.18582}, "CVE-2024-0127": {"epss_score": 0.00058, "epss_percentile": 0.18283}, "CVE-2024-0128": {"epss_score": 0.00053, "epss_percentile": 0.16695}, "CVE-2024-0129": {"epss_score": 0.00076, "epss_percentile": 0.23164}, "CVE-2024-0130": {"epss_score": 0.00051, "epss_percentile": 0.16132}, "CVE-2024-0131": {"epss_score": 0.00055, "epss_percentile": 0.17374}, "CVE-2024-0132": {"epss_score": 0.02917, "epss_percentile": 0.85984}, "CVE-2024-0133": {"epss_score": 0.00634, "epss_percentile": 0.69791}, "CVE-2024-0134": {"epss_score": 0.00233, "epss_percentile": 0.46033}, "CVE-2024-0135": {"epss_score": 0.00275, "epss_percentile": 0.50664}, "CVE-2024-0136": {"epss_score": 0.00275, "epss_percentile": 0.50664}, "CVE-2024-0137": {"epss_score": 0.0016, "epss_percentile": 0.37454}, "CVE-2024-0138": {"epss_score": 0.00105, "epss_percentile": 0.29286}, "CVE-2024-0139": {"epss_score": 0.00082, "epss_percentile": 0.24549}, "CVE-2024-0140": {"epss_score": 0.00186, "epss_percentile": 0.40652}, "CVE-2024-0141": {"epss_score": 0.00045, "epss_percentile": 0.13886}, "CVE-2024-0142": {"epss_score": 0.00071, "epss_percentile": 0.22014}, "CVE-2024-0143": {"epss_score": 0.00071, "epss_percentile": 0.22014}, "CVE-2024-0144": {"epss_score": 0.00054, "epss_percentile": 0.17155}, "CVE-2024-0145": {"epss_score": 0.00071, "epss_percentile": 0.21992}, "CVE-2024-0146": {"epss_score": 0.00044, "epss_percentile": 0.13668}, "CVE-2024-0147": {"epss_score": 0.00061, "epss_percentile": 0.19337}, "CVE-2024-0148": {"epss_score": 0.00067, "epss_percentile": 0.2098}, "CVE-2024-0149": {"epss_score": 0.00057, "epss_percentile": 0.18181}, "CVE-2024-0150": {"epss_score": 0.00064, "epss_percentile": 0.20303}, "CVE-2024-0151": {"epss_score": 0.00133, "epss_percentile": 0.33728}, "CVE-2024-0153": {"epss_score": 0.00159, "epss_percentile": 0.3741}, "CVE-2024-0154": {"epss_score": 0.00092, "epss_percentile": 0.26474}, "CVE-2024-0155": {"epss_score": 0.00091, "epss_percentile": 0.26194}, "CVE-2024-0156": {"epss_score": 0.00068, "epss_percentile": 0.21307}, "CVE-2024-0157": {"epss_score": 0.00156, "epss_percentile": 0.36931}, "CVE-2024-0158": {"epss_score": 0.00045, "epss_percentile": 0.13979}, "CVE-2024-0159": {"epss_score": 0.00081, "epss_percentile": 0.24282}, "CVE-2024-0160": {"epss_score": 0.00044, "epss_percentile": 0.13662}, "CVE-2024-0161": {"epss_score": 0.00035, "epss_percentile": 0.10139}, "CVE-2024-0162": {"epss_score": 0.00091, "epss_percentile": 0.26223}, "CVE-2024-0163": {"epss_score": 0.00072, "epss_percentile": 0.22353}, "CVE-2024-0164": {"epss_score": 0.00238, "epss_percentile": 0.46755}, "CVE-2024-0165": {"epss_score": 0.00291, "epss_percentile": 0.52202}, "CVE-2024-0166": {"epss_score": 0.00311, "epss_percentile": 0.53823}, "CVE-2024-0167": {"epss_score": 0.00364, "epss_percentile": 0.57955}, "CVE-2024-0168": {"epss_score": 0.00233, "epss_percentile": 0.46011}, "CVE-2024-0169": {"epss_score": 0.00396, "epss_percentile": 0.5986}, "CVE-2024-0170": {"epss_score": 0.00304, "epss_percentile": 0.53302}, "CVE-2024-0171": {"epss_score": 0.0008, "epss_percentile": 0.24106}, "CVE-2024-0172": {"epss_score": 0.00055, "epss_percentile": 0.17594}, "CVE-2024-0173": {"epss_score": 0.00092, "epss_percentile": 0.26474}, "CVE-2024-0179": {"epss_score": 0.00041, "epss_percentile": 0.1224}, "CVE-2024-0181": {"epss_score": 0.00077, "epss_percentile": 0.23443}, "CVE-2024-0182": {"epss_score": 0.00046, "epss_percentile": 0.14083}, "CVE-2024-0183": {"epss_score": 0.00055, "epss_percentile": 0.17586}, "CVE-2024-0184": {"epss_score": 0.00055, "epss_percentile": 0.17586}, "CVE-2024-0185": {"epss_score": 0.00064, "epss_percentile": 0.20163}, "CVE-2024-0186": {"epss_score": 0.00066, "epss_percentile": 0.20947}, "CVE-2024-0187": {"epss_score": 0.00435, "epss_percentile": 0.62344}, "CVE-2024-0188": {"epss_score": 0.00222, "epss_percentile": 0.44777}, "CVE-2024-0189": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2024-0190": {"epss_score": 0.00174, "epss_percentile": 0.39169}, "CVE-2024-0191": {"epss_score": 0.00252, "epss_percentile": 0.48403}, "CVE-2024-0192": {"epss_score": 0.0016, "epss_percentile": 0.3745}, "CVE-2024-0193": {"epss_score": 0.00058, "epss_percentile": 0.18297}, "CVE-2024-0194": {"epss_score": 0.00195, "epss_percentile": 0.41679}, "CVE-2024-0195": {"epss_score": 0.9205, "epss_percentile": 0.99688}, "CVE-2024-0196": {"epss_score": 0.00229, "epss_percentile": 0.45585}, "CVE-2024-0197": {"epss_score": 0.01517, "epss_percentile": 0.80802}, "CVE-2024-0199": {"epss_score": 8e-05, "epss_percentile": 0.00534}, "CVE-2024-0200": {"epss_score": 0.74112, "epss_percentile": 0.98789}, "CVE-2024-0201": {"epss_score": 0.00045, "epss_percentile": 0.13931}, "CVE-2024-0202": {"epss_score": 0.00183, "epss_percentile": 0.40301}, "CVE-2024-0203": {"epss_score": 0.00106, "epss_percentile": 0.29484}, "CVE-2024-0204": {"epss_score": 0.93048, "epss_percentile": 0.9977}, "CVE-2024-0206": {"epss_score": 0.00091, "epss_percentile": 0.26294}, "CVE-2024-0207": {"epss_score": 0.00063, "epss_percentile": 0.19943}, "CVE-2024-0208": {"epss_score": 0.00031, "epss_percentile": 0.08614}, "CVE-2024-0209": {"epss_score": 0.00042, "epss_percentile": 0.1258}, "CVE-2024-0210": {"epss_score": 0.00074, "epss_percentile": 0.22712}, "CVE-2024-0211": {"epss_score": 0.00052, "epss_percentile": 0.16649}, "CVE-2024-0212": {"epss_score": 0.01264, "epss_percentile": 0.78999}, "CVE-2024-0213": {"epss_score": 0.00089, "epss_percentile": 0.25933}, "CVE-2024-0216": {"epss_score": 0.0013, "epss_percentile": 0.33253}, "CVE-2024-0217": {"epss_score": 0.00013, "epss_percentile": 0.01594}, "CVE-2024-0218": {"epss_score": 0.00174, "epss_percentile": 0.39139}, "CVE-2024-0219": {"epss_score": 0.00694, "epss_percentile": 0.7134}, "CVE-2024-0220": {"epss_score": 0.00205, "epss_percentile": 0.42763}, "CVE-2024-0221": {"epss_score": 0.01159, "epss_percentile": 0.78131}, "CVE-2024-0222": {"epss_score": 0.0056, "epss_percentile": 0.6763}, "CVE-2024-0223": {"epss_score": 0.09619, "epss_percentile": 0.92626}, "CVE-2024-0224": {"epss_score": 0.00565, "epss_percentile": 0.67785}, "CVE-2024-0225": {"epss_score": 0.00811, "epss_percentile": 0.73727}, "CVE-2024-0226": {"epss_score": 0.0006, "epss_percentile": 0.19093}, "CVE-2024-0229": {"epss_score": 0.00295, "epss_percentile": 0.52492}, "CVE-2024-0230": {"epss_score": 0.04606, "epss_percentile": 0.88908}, "CVE-2024-0231": {"epss_score": 0.0023, "epss_percentile": 0.4568}, "CVE-2024-0232": {"epss_score": 0.00018, "epss_percentile": 0.03757}, "CVE-2024-0233": {"epss_score": 0.0028, "epss_percentile": 0.51069}, "CVE-2024-0235": {"epss_score": 0.87324, "epss_percentile": 0.99423}, "CVE-2024-0236": {"epss_score": 0.00474, "epss_percentile": 0.64111}, "CVE-2024-0237": {"epss_score": 0.00288, "epss_percentile": 0.51946}, "CVE-2024-0238": {"epss_score": 0.00727, "epss_percentile": 0.72091}, "CVE-2024-0239": {"epss_score": 0.00337, "epss_percentile": 0.56009}, "CVE-2024-0240": {"epss_score": 0.00032, "epss_percentile": 0.09074}, "CVE-2024-0241": {"epss_score": 0.00376, "epss_percentile": 0.58685}, "CVE-2024-0242": {"epss_score": 0.00099, "epss_percentile": 0.28404}, "CVE-2024-0243": {"epss_score": 0.00073, "epss_percentile": 0.22634}, "CVE-2024-0244": {"epss_score": 0.00447, "epss_percentile": 0.62988}, "CVE-2024-0245": {"epss_score": 0.00022, "epss_percentile": 0.05147}, "CVE-2024-0246": {"epss_score": 0.00067, "epss_percentile": 0.21072}, "CVE-2024-0247": {"epss_score": 0.00045, "epss_percentile": 0.13736}, "CVE-2024-0248": {"epss_score": 0.00231, "epss_percentile": 0.45851}, "CVE-2024-0249": {"epss_score": 0.00055, "epss_percentile": 0.17519}, "CVE-2024-0250": {"epss_score": 0.13033, "epss_percentile": 0.93851}, "CVE-2024-0251": {"epss_score": 0.00323, "epss_percentile": 0.54913}, "CVE-2024-0252": {"epss_score": 0.42872, "epss_percentile": 0.97359}, "CVE-2024-0253": {"epss_score": 0.00663, "epss_percentile": 0.70625}, "CVE-2024-0254": {"epss_score": 0.00227, "epss_percentile": 0.45386}, "CVE-2024-0255": {"epss_score": 0.00165, "epss_percentile": 0.3812}, "CVE-2024-0256": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-0257": {"epss_score": 0.00053, "epss_percentile": 0.16699}, "CVE-2024-0258": {"epss_score": 0.00018, "epss_percentile": 0.03753}, "CVE-2024-0259": {"epss_score": 0.00149, "epss_percentile": 0.35996}, "CVE-2024-0260": {"epss_score": 0.00047, "epss_percentile": 0.14496}, "CVE-2024-0261": {"epss_score": 0.00042, "epss_percentile": 0.12652}, "CVE-2024-0262": {"epss_score": 0.00054, "epss_percentile": 0.17281}, "CVE-2024-0263": {"epss_score": 0.00105, "epss_percentile": 0.29347}, "CVE-2024-0264": {"epss_score": 0.00057, "epss_percentile": 0.18134}, "CVE-2024-0265": {"epss_score": 0.00648, "epss_percentile": 0.70218}, "CVE-2024-0266": {"epss_score": 0.00105, "epss_percentile": 0.29377}, "CVE-2024-0267": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-0268": {"epss_score": 0.00184, "epss_percentile": 0.4037}, "CVE-2024-0269": {"epss_score": 0.00663, "epss_percentile": 0.70625}, "CVE-2024-0270": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2024-0271": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2024-0272": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2024-0273": {"epss_score": 0.00062, "epss_percentile": 0.19735}, "CVE-2024-0274": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2024-0275": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2024-0276": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2024-0277": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2024-0278": {"epss_score": 0.00042, "epss_percentile": 0.12578}, "CVE-2024-0279": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2024-0280": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2024-0281": {"epss_score": 0.00046, "epss_percentile": 0.14455}, "CVE-2024-0282": {"epss_score": 0.00072, "epss_percentile": 0.22379}, "CVE-2024-0283": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2024-0284": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2024-0285": {"epss_score": 0.00025, "epss_percentile": 0.06255}, "CVE-2024-0286": {"epss_score": 0.00151, "epss_percentile": 0.36292}, "CVE-2024-0287": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0288": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0289": {"epss_score": 0.00191, "epss_percentile": 0.41205}, "CVE-2024-0290": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0291": {"epss_score": 0.01499, "epss_percentile": 0.80705}, "CVE-2024-0292": {"epss_score": 0.01513, "epss_percentile": 0.80786}, "CVE-2024-0293": {"epss_score": 0.02748, "epss_percentile": 0.85576}, "CVE-2024-0294": {"epss_score": 0.02071, "epss_percentile": 0.83482}, "CVE-2024-0295": {"epss_score": 0.02071, "epss_percentile": 0.83482}, "CVE-2024-0296": {"epss_score": 0.01535, "epss_percentile": 0.80907}, "CVE-2024-0297": {"epss_score": 0.00897, "epss_percentile": 0.75133}, "CVE-2024-0298": {"epss_score": 0.02071, "epss_percentile": 0.83482}, "CVE-2024-0299": {"epss_score": 0.01535, "epss_percentile": 0.80907}, "CVE-2024-0300": {"epss_score": 0.0093, "epss_percentile": 0.756}, "CVE-2024-0301": {"epss_score": 0.00123, "epss_percentile": 0.3224}, "CVE-2024-0302": {"epss_score": 0.00177, "epss_percentile": 0.39572}, "CVE-2024-0303": {"epss_score": 0.00158, "epss_percentile": 0.37224}, "CVE-2024-0304": {"epss_score": 0.00158, "epss_percentile": 0.37224}, "CVE-2024-0305": {"epss_score": 0.93699, "epss_percentile": 0.99835}, "CVE-2024-0306": {"epss_score": 0.00093, "epss_percentile": 0.26609}, "CVE-2024-0307": {"epss_score": 0.00093, "epss_percentile": 0.26609}, "CVE-2024-0308": {"epss_score": 0.00145, "epss_percentile": 0.3541}, "CVE-2024-0310": {"epss_score": 0.00171, "epss_percentile": 0.38789}, "CVE-2024-0311": {"epss_score": 0.0022, "epss_percentile": 0.44551}, "CVE-2024-0312": {"epss_score": 0.00025, "epss_percentile": 0.06064}, "CVE-2024-0313": {"epss_score": 7e-05, "epss_percentile": 0.00344}, "CVE-2024-0314": {"epss_score": 0.00076, "epss_percentile": 0.23229}, "CVE-2024-0315": {"epss_score": 0.00382, "epss_percentile": 0.59072}, "CVE-2024-0316": {"epss_score": 0.00052, "epss_percentile": 0.16474}, "CVE-2024-0317": {"epss_score": 0.00109, "epss_percentile": 0.29951}, "CVE-2024-0318": {"epss_score": 0.00076, "epss_percentile": 0.23229}, "CVE-2024-0319": {"epss_score": 0.0006, "epss_percentile": 0.19236}, "CVE-2024-0320": {"epss_score": 0.00076, "epss_percentile": 0.23229}, "CVE-2024-0321": {"epss_score": 0.00073, "epss_percentile": 0.22485}, "CVE-2024-0322": {"epss_score": 0.00108, "epss_percentile": 0.29832}, "CVE-2024-0323": {"epss_score": 0.00119, "epss_percentile": 0.31605}, "CVE-2024-0324": {"epss_score": 0.4596, "epss_percentile": 0.97514}, "CVE-2024-0325": {"epss_score": 0.00106, "epss_percentile": 0.29557}, "CVE-2024-0326": {"epss_score": 0.00267, "epss_percentile": 0.49979}, "CVE-2024-0333": {"epss_score": 0.00074, "epss_percentile": 0.22863}, "CVE-2024-0334": {"epss_score": 0.00214, "epss_percentile": 0.43973}, "CVE-2024-0335": {"epss_score": 0.00296, "epss_percentile": 0.52589}, "CVE-2024-0336": {"epss_score": 0.00154, "epss_percentile": 0.36659}, "CVE-2024-0337": {"epss_score": 0.01388, "epss_percentile": 0.79924}, "CVE-2024-0338": {"epss_score": 0.00098, "epss_percentile": 0.27813}, "CVE-2024-0340": {"epss_score": 5e-05, "epss_percentile": 0.0022}, "CVE-2024-0341": {"epss_score": 0.0029, "epss_percentile": 0.52105}, "CVE-2024-0342": {"epss_score": 0.00138, "epss_percentile": 0.34358}, "CVE-2024-0343": {"epss_score": 0.00079, "epss_percentile": 0.23969}, "CVE-2024-0344": {"epss_score": 0.00044, "epss_percentile": 0.13566}, "CVE-2024-0345": {"epss_score": 0.00079, "epss_percentile": 0.23969}, "CVE-2024-0346": {"epss_score": 0.00165, "epss_percentile": 0.38101}, "CVE-2024-0347": {"epss_score": 0.0012, "epss_percentile": 0.31714}, "CVE-2024-0348": {"epss_score": 0.00052, "epss_percentile": 0.1651}, "CVE-2024-0349": {"epss_score": 0.00048, "epss_percentile": 0.14991}, "CVE-2024-0350": {"epss_score": 0.00055, "epss_percentile": 0.17519}, "CVE-2024-0351": {"epss_score": 0.00046, "epss_percentile": 0.14084}, "CVE-2024-0352": {"epss_score": 0.92157, "epss_percentile": 0.99694}, "CVE-2024-0353": {"epss_score": 0.00078, "epss_percentile": 0.23783}, "CVE-2024-0354": {"epss_score": 0.00123, "epss_percentile": 0.32178}, "CVE-2024-0355": {"epss_score": 0.00105, "epss_percentile": 0.29255}, "CVE-2024-0356": {"epss_score": 0.00064, "epss_percentile": 0.20315}, "CVE-2024-0357": {"epss_score": 0.00045, "epss_percentile": 0.13752}, "CVE-2024-0358": {"epss_score": 0.00091, "epss_percentile": 0.26214}, "CVE-2024-0359": {"epss_score": 0.00045, "epss_percentile": 0.13736}, "CVE-2024-0360": {"epss_score": 0.00057, "epss_percentile": 0.1821}, "CVE-2024-0361": {"epss_score": 0.00057, "epss_percentile": 0.1821}, "CVE-2024-0362": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0363": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0364": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0365": {"epss_score": 0.00315, "epss_percentile": 0.54183}, "CVE-2024-0366": {"epss_score": 0.00259, "epss_percentile": 0.4903}, "CVE-2024-0367": {"epss_score": 0.00119, "epss_percentile": 0.31584}, "CVE-2024-0368": {"epss_score": 0.01817, "epss_percentile": 0.82395}, "CVE-2024-0369": {"epss_score": 0.00119, "epss_percentile": 0.31582}, "CVE-2024-0370": {"epss_score": 0.00117, "epss_percentile": 0.31293}, "CVE-2024-0371": {"epss_score": 0.00119, "epss_percentile": 0.31582}, "CVE-2024-0372": {"epss_score": 0.00101, "epss_percentile": 0.28649}, "CVE-2024-0373": {"epss_score": 0.00073, "epss_percentile": 0.22554}, "CVE-2024-0374": {"epss_score": 0.00095, "epss_percentile": 0.2721}, "CVE-2024-0376": {"epss_score": 0.02973, "epss_percentile": 0.86102}, "CVE-2024-0377": {"epss_score": 0.04162, "epss_percentile": 0.88336}, "CVE-2024-0378": {"epss_score": 0.07965, "epss_percentile": 0.91793}, "CVE-2024-0379": {"epss_score": 0.1392, "epss_percentile": 0.94093}, "CVE-2024-0380": {"epss_score": 0.05079, "epss_percentile": 0.8947}, "CVE-2024-0381": {"epss_score": 0.00983, "epss_percentile": 0.76309}, "CVE-2024-0382": {"epss_score": 0.01665, "epss_percentile": 0.81648}, "CVE-2024-0383": {"epss_score": 0.01949, "epss_percentile": 0.83011}, "CVE-2024-0384": {"epss_score": 0.01665, "epss_percentile": 0.81648}, "CVE-2024-0385": {"epss_score": 0.01863, "epss_percentile": 0.82598}, "CVE-2024-0386": {"epss_score": 0.15758, "epss_percentile": 0.94499}, "CVE-2024-0387": {"epss_score": 0.00245, "epss_percentile": 0.47651}, "CVE-2024-0389": {"epss_score": 0.00308, "epss_percentile": 0.53593}, "CVE-2024-0390": {"epss_score": 0.00204, "epss_percentile": 0.42629}, "CVE-2024-0392": {"epss_score": 0.00069, "epss_percentile": 0.21491}, "CVE-2024-0394": {"epss_score": 0.00028, "epss_percentile": 0.07482}, "CVE-2024-0396": {"epss_score": 0.00162, "epss_percentile": 0.37704}, "CVE-2024-0397": {"epss_score": 0.00384, "epss_percentile": 0.59157}, "CVE-2024-0399": {"epss_score": 0.02012, "epss_percentile": 0.83255}, "CVE-2024-0400": {"epss_score": 0.00259, "epss_percentile": 0.49027}, "CVE-2024-0401": {"epss_score": 0.07118, "epss_percentile": 0.91261}, "CVE-2024-0402": {"epss_score": 0.39312, "epss_percentile": 0.97153}, "CVE-2024-0403": {"epss_score": 0.00224, "epss_percentile": 0.45013}, "CVE-2024-0404": {"epss_score": 0.00192, "epss_percentile": 0.41327}, "CVE-2024-0405": {"epss_score": 0.00167, "epss_percentile": 0.38363}, "CVE-2024-0406": {"epss_score": 0.17294, "epss_percentile": 0.94817}, "CVE-2024-0407": {"epss_score": 0.00064, "epss_percentile": 0.20198}, "CVE-2024-0408": {"epss_score": 0.00017, "epss_percentile": 0.03353}, "CVE-2024-0409": {"epss_score": 0.00017, "epss_percentile": 0.03293}, "CVE-2024-0410": {"epss_score": 0.00012, "epss_percentile": 0.01182}, "CVE-2024-0411": {"epss_score": 0.00223, "epss_percentile": 0.44852}, "CVE-2024-0412": {"epss_score": 0.00278, "epss_percentile": 0.50874}, "CVE-2024-0413": {"epss_score": 0.00278, "epss_percentile": 0.50874}, "CVE-2024-0414": {"epss_score": 0.00278, "epss_percentile": 0.50874}, "CVE-2024-0415": {"epss_score": 0.00169, "epss_percentile": 0.38548}, "CVE-2024-0416": {"epss_score": 0.00181, "epss_percentile": 0.40093}, "CVE-2024-0417": {"epss_score": 0.00164, "epss_percentile": 0.3791}, "CVE-2024-0418": {"epss_score": 0.00107, "epss_percentile": 0.29743}, "CVE-2024-0419": {"epss_score": 0.00107, "epss_percentile": 0.29743}, "CVE-2024-0420": {"epss_score": 0.00196, "epss_percentile": 0.41802}, "CVE-2024-0421": {"epss_score": 0.00397, "epss_percentile": 0.60048}, "CVE-2024-0422": {"epss_score": 0.00148, "epss_percentile": 0.35922}, "CVE-2024-0423": {"epss_score": 0.00148, "epss_percentile": 0.35922}, "CVE-2024-0424": {"epss_score": 0.00148, "epss_percentile": 0.35922}, "CVE-2024-0425": {"epss_score": 0.00167, "epss_percentile": 0.38377}, "CVE-2024-0426": {"epss_score": 0.00153, "epss_percentile": 0.36536}, "CVE-2024-0427": {"epss_score": 0.0024, "epss_percentile": 0.47207}, "CVE-2024-0428": {"epss_score": 0.00121, "epss_percentile": 0.3199}, "CVE-2024-0429": {"epss_score": 0.00056, "epss_percentile": 0.17725}, "CVE-2024-0430": {"epss_score": 0.00025, "epss_percentile": 0.06145}, "CVE-2024-0431": {"epss_score": 0.00156, "epss_percentile": 0.3692}, "CVE-2024-0432": {"epss_score": 0.00079, "epss_percentile": 0.23957}, "CVE-2024-0433": {"epss_score": 0.00112, "epss_percentile": 0.30476}, "CVE-2024-0434": {"epss_score": 0.00383, "epss_percentile": 0.59103}, "CVE-2024-0435": {"epss_score": 0.0037, "epss_percentile": 0.58331}, "CVE-2024-0436": {"epss_score": 0.00279, "epss_percentile": 0.50931}, "CVE-2024-0437": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2024-0438": {"epss_score": 0.01714, "epss_percentile": 0.81894}, "CVE-2024-0439": {"epss_score": 0.00216, "epss_percentile": 0.44231}, "CVE-2024-0440": {"epss_score": 0.00195, "epss_percentile": 0.41689}, "CVE-2024-0442": {"epss_score": 0.00177, "epss_percentile": 0.39515}, "CVE-2024-0443": {"epss_score": 0.00013, "epss_percentile": 0.01667}, "CVE-2024-0444": {"epss_score": 0.03928, "epss_percentile": 0.8797}, "CVE-2024-0445": {"epss_score": 0.0023, "epss_percentile": 0.45677}, "CVE-2024-0446": {"epss_score": 0.00123, "epss_percentile": 0.32223}, "CVE-2024-0447": {"epss_score": 0.00119, "epss_percentile": 0.31582}, "CVE-2024-0448": {"epss_score": 0.00206, "epss_percentile": 0.4293}, "CVE-2024-0449": {"epss_score": 0.00288, "epss_percentile": 0.51902}, "CVE-2024-0450": {"epss_score": 0.00137, "epss_percentile": 0.34223}, "CVE-2024-0451": {"epss_score": 0.00376, "epss_percentile": 0.58659}, "CVE-2024-0452": {"epss_score": 0.00209, "epss_percentile": 0.43323}, "CVE-2024-0453": {"epss_score": 0.00153, "epss_percentile": 0.36611}, "CVE-2024-0454": {"epss_score": 0.00011, "epss_percentile": 0.00948}, "CVE-2024-0455": {"epss_score": 0.00131, "epss_percentile": 0.3348}, "CVE-2024-0456": {"epss_score": 0.00102, "epss_percentile": 0.28762}, "CVE-2024-0459": {"epss_score": 0.00073, "epss_percentile": 0.22539}, "CVE-2024-0460": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2024-0461": {"epss_score": 0.00059, "epss_percentile": 0.1883}, "CVE-2024-0462": {"epss_score": 0.0006, "epss_percentile": 0.19114}, "CVE-2024-0463": {"epss_score": 0.0006, "epss_percentile": 0.19114}, "CVE-2024-0464": {"epss_score": 0.00053, "epss_percentile": 0.1684}, "CVE-2024-0465": {"epss_score": 0.00108, "epss_percentile": 0.29857}, "CVE-2024-0466": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2024-0467": {"epss_score": 0.00058, "epss_percentile": 0.18461}, "CVE-2024-0468": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2024-0469": {"epss_score": 0.00054, "epss_percentile": 0.17335}, "CVE-2024-0470": {"epss_score": 0.00054, "epss_percentile": 0.17335}, "CVE-2024-0471": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0472": {"epss_score": 0.00125, "epss_percentile": 0.32559}, "CVE-2024-0473": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0474": {"epss_score": 0.00044, "epss_percentile": 0.13455}, "CVE-2024-0475": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0476": {"epss_score": 0.00055, "epss_percentile": 0.17586}, "CVE-2024-0477": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0478": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0479": {"epss_score": 0.00052, "epss_percentile": 0.16394}, "CVE-2024-0480": {"epss_score": 0.0006, "epss_percentile": 0.1907}, "CVE-2024-0481": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0482": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0483": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0484": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0485": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0486": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2024-0487": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0488": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0489": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0490": {"epss_score": 0.00087, "epss_percentile": 0.25483}, "CVE-2024-0491": {"epss_score": 0.00052, "epss_percentile": 0.16597}, "CVE-2024-0492": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0493": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0494": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0495": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0496": {"epss_score": 0.00057, "epss_percentile": 0.1802}, "CVE-2024-0497": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0498": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0499": {"epss_score": 0.00055, "epss_percentile": 0.17586}, "CVE-2024-0500": {"epss_score": 0.0006, "epss_percentile": 0.19134}, "CVE-2024-0501": {"epss_score": 0.00055, "epss_percentile": 0.17586}, "CVE-2024-0502": {"epss_score": 0.0005, "epss_percentile": 0.15771}, "CVE-2024-0503": {"epss_score": 0.00129, "epss_percentile": 0.33097}, "CVE-2024-0504": {"epss_score": 0.00059, "epss_percentile": 0.18831}, "CVE-2024-0505": {"epss_score": 0.00092, "epss_percentile": 0.26567}, "CVE-2024-0506": {"epss_score": 0.00196, "epss_percentile": 0.41753}, "CVE-2024-0507": {"epss_score": 0.75673, "epss_percentile": 0.9886}, "CVE-2024-0508": {"epss_score": 0.00146, "epss_percentile": 0.35581}, "CVE-2024-0509": {"epss_score": 0.33697, "epss_percentile": 0.96798}, "CVE-2024-0510": {"epss_score": 0.00158, "epss_percentile": 0.37186}, "CVE-2024-0511": {"epss_score": 0.00068, "epss_percentile": 0.21322}, "CVE-2024-0512": {"epss_score": 0.00157, "epss_percentile": 0.37019}, "CVE-2024-0513": {"epss_score": 0.00123, "epss_percentile": 0.32227}, "CVE-2024-0514": {"epss_score": 0.00202, "epss_percentile": 0.42453}, "CVE-2024-0515": {"epss_score": 0.00123, "epss_percentile": 0.32227}, "CVE-2024-0516": {"epss_score": 0.00169, "epss_percentile": 0.38554}, "CVE-2024-0517": {"epss_score": 0.66013, "epss_percentile": 0.98446}, "CVE-2024-0518": {"epss_score": 0.00208, "epss_percentile": 0.43239}, "CVE-2024-0519": {"epss_score": 0.00468, "epss_percentile": 0.63867}, "CVE-2024-0520": {"epss_score": 0.04877, "epss_percentile": 0.89242}, "CVE-2024-0521": {"epss_score": 0.00082, "epss_percentile": 0.24583}, "CVE-2024-0522": {"epss_score": 0.00047, "epss_percentile": 0.14636}, "CVE-2024-0523": {"epss_score": 0.00045, "epss_percentile": 0.13744}, "CVE-2024-0524": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0525": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0526": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0527": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-0528": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0529": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0530": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0531": {"epss_score": 0.00134, "epss_percentile": 0.3387}, "CVE-2024-0532": {"epss_score": 0.00337, "epss_percentile": 0.5606}, "CVE-2024-0533": {"epss_score": 0.00134, "epss_percentile": 0.3387}, "CVE-2024-0534": {"epss_score": 0.00117, "epss_percentile": 0.31242}, "CVE-2024-0535": {"epss_score": 0.00218, "epss_percentile": 0.44371}, "CVE-2024-0536": {"epss_score": 0.00135, "epss_percentile": 0.34021}, "CVE-2024-0537": {"epss_score": 0.00135, "epss_percentile": 0.34021}, "CVE-2024-0538": {"epss_score": 0.00135, "epss_percentile": 0.34021}, "CVE-2024-0539": {"epss_score": 0.00222, "epss_percentile": 0.44769}, "CVE-2024-0540": {"epss_score": 0.00102, "epss_percentile": 0.28722}, "CVE-2024-0541": {"epss_score": 0.00264, "epss_percentile": 0.49552}, "CVE-2024-0542": {"epss_score": 0.00135, "epss_percentile": 0.34021}, "CVE-2024-0543": {"epss_score": 0.00039, "epss_percentile": 0.1145}, "CVE-2024-0545": {"epss_score": 0.00068, "epss_percentile": 0.21378}, "CVE-2024-0546": {"epss_score": 0.36562, "epss_percentile": 0.96987}, "CVE-2024-0547": {"epss_score": 0.00046, "epss_percentile": 0.14468}, "CVE-2024-0548": {"epss_score": 0.00027, "epss_percentile": 0.06837}, "CVE-2024-0549": {"epss_score": 0.00248, "epss_percentile": 0.47959}, "CVE-2024-0550": {"epss_score": 0.00718, "epss_percentile": 0.71934}, "CVE-2024-0551": {"epss_score": 0.00921, "epss_percentile": 0.75476}, "CVE-2024-0552": {"epss_score": 0.00823, "epss_percentile": 0.73929}, "CVE-2024-0553": {"epss_score": 0.01029, "epss_percentile": 0.76828}, "CVE-2024-0554": {"epss_score": 0.00069, "epss_percentile": 0.21615}, "CVE-2024-0555": {"epss_score": 0.00047, "epss_percentile": 0.14759}, "CVE-2024-0556": {"epss_score": 0.00181, "epss_percentile": 0.39994}, "CVE-2024-0557": {"epss_score": 0.00061, "epss_percentile": 0.19322}, "CVE-2024-0558": {"epss_score": 0.00024, "epss_percentile": 0.05989}, "CVE-2024-0559": {"epss_score": 0.00319, "epss_percentile": 0.54534}, "CVE-2024-0560": {"epss_score": 0.00125, "epss_percentile": 0.32584}, "CVE-2024-0561": {"epss_score": 0.00272, "epss_percentile": 0.50376}, "CVE-2024-0562": {"epss_score": 0.00019, "epss_percentile": 0.04237}, "CVE-2024-0563": {"epss_score": 0.00111, "epss_percentile": 0.30245}, "CVE-2024-0564": {"epss_score": 0.00022, "epss_percentile": 0.05056}, "CVE-2024-0565": {"epss_score": 0.00067, "epss_percentile": 0.21054}, "CVE-2024-0566": {"epss_score": 0.01789, "epss_percentile": 0.82274}, "CVE-2024-0567": {"epss_score": 0.01194, "epss_percentile": 0.78414}, "CVE-2024-0568": {"epss_score": 0.00216, "epss_percentile": 0.44237}, "CVE-2024-0569": {"epss_score": 0.00365, "epss_percentile": 0.57969}, "CVE-2024-0570": {"epss_score": 0.00197, "epss_percentile": 0.41825}, "CVE-2024-0571": {"epss_score": 0.00481, "epss_percentile": 0.64482}, "CVE-2024-0572": {"epss_score": 0.00293, "epss_percentile": 0.52326}, "CVE-2024-0573": {"epss_score": 0.0044, "epss_percentile": 0.62612}, "CVE-2024-0574": {"epss_score": 0.00433, "epss_percentile": 0.62195}, "CVE-2024-0575": {"epss_score": 0.0072, "epss_percentile": 0.71962}, "CVE-2024-0576": {"epss_score": 0.00741, "epss_percentile": 0.72436}, "CVE-2024-0577": {"epss_score": 0.00379, "epss_percentile": 0.58852}, "CVE-2024-0578": {"epss_score": 0.00675, "epss_percentile": 0.70898}, "CVE-2024-0579": {"epss_score": 0.00773, "epss_percentile": 0.73058}, "CVE-2024-0580": {"epss_score": 0.00091, "epss_percentile": 0.26216}, "CVE-2024-0581": {"epss_score": 0.00059, "epss_percentile": 0.18631}, "CVE-2024-0582": {"epss_score": 0.00439, "epss_percentile": 0.6261}, "CVE-2024-0585": {"epss_score": 0.00168, "epss_percentile": 0.38433}, "CVE-2024-0586": {"epss_score": 0.00138, "epss_percentile": 0.34527}, "CVE-2024-0587": {"epss_score": 0.0276, "epss_percentile": 0.85597}, "CVE-2024-0588": {"epss_score": 0.09317, "epss_percentile": 0.92498}, "CVE-2024-0589": {"epss_score": 0.00383, "epss_percentile": 0.59095}, "CVE-2024-0590": {"epss_score": 0.24756, "epss_percentile": 0.95952}, "CVE-2024-0591": {"epss_score": 0.01624, "epss_percentile": 0.8141}, "CVE-2024-0592": {"epss_score": 0.00135, "epss_percentile": 0.34048}, "CVE-2024-0593": {"epss_score": 0.11927, "epss_percentile": 0.93518}, "CVE-2024-0594": {"epss_score": 0.00323, "epss_percentile": 0.54903}, "CVE-2024-0595": {"epss_score": 0.00112, "epss_percentile": 0.30446}, "CVE-2024-0596": {"epss_score": 0.00142, "epss_percentile": 0.35051}, "CVE-2024-0597": {"epss_score": 0.00164, "epss_percentile": 0.37889}, "CVE-2024-0598": {"epss_score": 0.00597, "epss_percentile": 0.68752}, "CVE-2024-0599": {"epss_score": 0.00182, "epss_percentile": 0.40198}, "CVE-2024-0601": {"epss_score": 0.00142, "epss_percentile": 0.34986}, "CVE-2024-0602": {"epss_score": 0.00187, "epss_percentile": 0.40744}, "CVE-2024-0603": {"epss_score": 0.00205, "epss_percentile": 0.4273}, "CVE-2024-0604": {"epss_score": 0.00277, "epss_percentile": 0.50812}, "CVE-2024-0605": {"epss_score": 0.00036, "epss_percentile": 0.10306}, "CVE-2024-0606": {"epss_score": 0.0044, "epss_percentile": 0.62639}, "CVE-2024-0607": {"epss_score": 0.00021, "epss_percentile": 0.04869}, "CVE-2024-0608": {"epss_score": 0.0062, "epss_percentile": 0.69444}, "CVE-2024-0609": {"epss_score": 0.01947, "epss_percentile": 0.83007}, "CVE-2024-0610": {"epss_score": 0.00624, "epss_percentile": 0.69566}, "CVE-2024-0611": {"epss_score": 0.00217, "epss_percentile": 0.44335}, "CVE-2024-0612": {"epss_score": 0.00164, "epss_percentile": 0.37889}, "CVE-2024-0613": {"epss_score": 0.00229, "epss_percentile": 0.45654}, "CVE-2024-0614": {"epss_score": 0.00322, "epss_percentile": 0.5475}, "CVE-2024-0615": {"epss_score": 0.00428, "epss_percentile": 0.61943}, "CVE-2024-0616": {"epss_score": 0.00428, "epss_percentile": 0.61943}, "CVE-2024-0617": {"epss_score": 0.00131, "epss_percentile": 0.3338}, "CVE-2024-0618": {"epss_score": 0.00141, "epss_percentile": 0.34812}, "CVE-2024-0619": {"epss_score": 0.00296, "epss_percentile": 0.5258}, "CVE-2024-0620": {"epss_score": 0.00428, "epss_percentile": 0.61943}, "CVE-2024-0621": {"epss_score": 0.00282, "epss_percentile": 0.51223}, "CVE-2024-0622": {"epss_score": 0.00057, "epss_percentile": 0.18121}, "CVE-2024-0623": {"epss_score": 0.04104, "epss_percentile": 0.88263}, "CVE-2024-0624": {"epss_score": 0.0396, "epss_percentile": 0.88012}, "CVE-2024-0625": {"epss_score": 0.00155, "epss_percentile": 0.36782}, "CVE-2024-0626": {"epss_score": 0.00701, "epss_percentile": 0.71502}, "CVE-2024-0627": {"epss_score": 0.00234, "epss_percentile": 0.46117}, "CVE-2024-0628": {"epss_score": 0.00073, "epss_percentile": 0.22496}, "CVE-2024-0629": {"epss_score": 0.00217, "epss_percentile": 0.44329}, "CVE-2024-0630": {"epss_score": 0.00206, "epss_percentile": 0.43042}, "CVE-2024-0631": {"epss_score": 0.00288, "epss_percentile": 0.51946}, "CVE-2024-0632": {"epss_score": 0.004, "epss_percentile": 0.60156}, "CVE-2024-0637": {"epss_score": 0.78712, "epss_percentile": 0.99001}, "CVE-2024-0638": {"epss_score": 0.00063, "epss_percentile": 0.19866}, "CVE-2024-0639": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2024-0640": {"epss_score": 0.00051, "epss_percentile": 0.15991}, "CVE-2024-0641": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2024-0642": {"epss_score": 0.00381, "epss_percentile": 0.59001}, "CVE-2024-0643": {"epss_score": 0.00436, "epss_percentile": 0.6246}, "CVE-2024-0645": {"epss_score": 0.00039, "epss_percentile": 0.11791}, "CVE-2024-0646": {"epss_score": 0.00018, "epss_percentile": 0.03958}, "CVE-2024-0647": {"epss_score": 0.00195, "epss_percentile": 0.41628}, "CVE-2024-0648": {"epss_score": 0.00077, "epss_percentile": 0.23412}, "CVE-2024-0649": {"epss_score": 0.00062, "epss_percentile": 0.19779}, "CVE-2024-0650": {"epss_score": 0.00086, "epss_percentile": 0.25404}, "CVE-2024-0651": {"epss_score": 0.00063, "epss_percentile": 0.19993}, "CVE-2024-0652": {"epss_score": 0.00112, "epss_percentile": 0.30459}, "CVE-2024-0653": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2024-0654": {"epss_score": 0.00037, "epss_percentile": 0.1099}, "CVE-2024-0655": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0656": {"epss_score": 0.00225, "epss_percentile": 0.45227}, "CVE-2024-0657": {"epss_score": 0.00133, "epss_percentile": 0.33697}, "CVE-2024-0658": {"epss_score": 0.00225, "epss_percentile": 0.45227}, "CVE-2024-0659": {"epss_score": 0.00217, "epss_percentile": 0.44248}, "CVE-2024-0660": {"epss_score": 0.00097, "epss_percentile": 0.27532}, "CVE-2024-0662": {"epss_score": 0.00252, "epss_percentile": 0.48365}, "CVE-2024-0664": {"epss_score": 0.00128, "epss_percentile": 0.33023}, "CVE-2024-0665": {"epss_score": 0.00656, "epss_percentile": 0.70443}, "CVE-2024-0667": {"epss_score": 0.00049, "epss_percentile": 0.15369}, "CVE-2024-0668": {"epss_score": 0.00533, "epss_percentile": 0.66768}, "CVE-2024-0669": {"epss_score": 0.0005, "epss_percentile": 0.15779}, "CVE-2024-0670": {"epss_score": 0.00122, "epss_percentile": 0.32146}, "CVE-2024-0671": {"epss_score": 0.00122, "epss_percentile": 0.32058}, "CVE-2024-0672": {"epss_score": 0.00334, "epss_percentile": 0.55714}, "CVE-2024-0673": {"epss_score": 0.00358, "epss_percentile": 0.57536}, "CVE-2024-0674": {"epss_score": 0.00023, "epss_percentile": 0.05347}, "CVE-2024-0675": {"epss_score": 0.00039, "epss_percentile": 0.11628}, "CVE-2024-0676": {"epss_score": 0.00029, "epss_percentile": 0.07835}, "CVE-2024-0677": {"epss_score": 0.0007, "epss_percentile": 0.21983}, "CVE-2024-0678": {"epss_score": 0.00369, "epss_percentile": 0.58227}, "CVE-2024-0679": {"epss_score": 0.07692, "epss_percentile": 0.9163}, "CVE-2024-0680": {"epss_score": 0.00581, "epss_percentile": 0.68271}, "CVE-2024-0681": {"epss_score": 0.00516, "epss_percentile": 0.66029}, "CVE-2024-0682": {"epss_score": 0.00532, "epss_percentile": 0.66674}, "CVE-2024-0683": {"epss_score": 0.24927, "epss_percentile": 0.95967}, "CVE-2024-0684": {"epss_score": 0.00072, "epss_percentile": 0.22377}, "CVE-2024-0685": {"epss_score": 0.00612, "epss_percentile": 0.69234}, "CVE-2024-0687": {"epss_score": 0.00391, "epss_percentile": 0.59582}, "CVE-2024-0688": {"epss_score": 0.0012, "epss_percentile": 0.31705}, "CVE-2024-0689": {"epss_score": 0.00195, "epss_percentile": 0.41629}, "CVE-2024-0690": {"epss_score": 0.00055, "epss_percentile": 0.17411}, "CVE-2024-0691": {"epss_score": 0.00224, "epss_percentile": 0.4506}, "CVE-2024-0692": {"epss_score": 0.85268, "epss_percentile": 0.99326}, "CVE-2024-0693": {"epss_score": 0.00054, "epss_percentile": 0.17274}, "CVE-2024-0695": {"epss_score": 0.0005, "epss_percentile": 0.15835}, "CVE-2024-0696": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2024-0697": {"epss_score": 0.01087, "epss_percentile": 0.77432}, "CVE-2024-0698": {"epss_score": 0.00138, "epss_percentile": 0.34397}, "CVE-2024-0699": {"epss_score": 0.07121, "epss_percentile": 0.91264}, "CVE-2024-0700": {"epss_score": 0.00249, "epss_percentile": 0.48004}, "CVE-2024-0701": {"epss_score": 0.00176, "epss_percentile": 0.39419}, "CVE-2024-0702": {"epss_score": 0.00104, "epss_percentile": 0.29159}, "CVE-2024-0703": {"epss_score": 0.00198, "epss_percentile": 0.42087}, "CVE-2024-0705": {"epss_score": 0.00495, "epss_percentile": 0.65134}, "CVE-2024-0708": {"epss_score": 0.00215, "epss_percentile": 0.44049}, "CVE-2024-0709": {"epss_score": 0.00963, "epss_percentile": 0.76002}, "CVE-2024-0710": {"epss_score": 0.03751, "epss_percentile": 0.87675}, "CVE-2024-0711": {"epss_score": 0.00105, "epss_percentile": 0.29265}, "CVE-2024-0712": {"epss_score": 0.00056, "epss_percentile": 0.17777}, "CVE-2024-0714": {"epss_score": 0.00964, "epss_percentile": 0.7603}, "CVE-2024-0715": {"epss_score": 0.00704, "epss_percentile": 0.71568}, "CVE-2024-0716": {"epss_score": 0.00063, "epss_percentile": 0.19996}, "CVE-2024-0717": {"epss_score": 0.28391, "epss_percentile": 0.96349}, "CVE-2024-0718": {"epss_score": 0.00114, "epss_percentile": 0.3074}, "CVE-2024-0719": {"epss_score": 0.0016, "epss_percentile": 0.37442}, "CVE-2024-0720": {"epss_score": 0.00122, "epss_percentile": 0.32022}, "CVE-2024-0721": {"epss_score": 0.00197, "epss_percentile": 0.41968}, "CVE-2024-0722": {"epss_score": 0.00122, "epss_percentile": 0.32022}, "CVE-2024-0723": {"epss_score": 0.01278, "epss_percentile": 0.79128}, "CVE-2024-0725": {"epss_score": 0.02033, "epss_percentile": 0.83343}, "CVE-2024-0726": {"epss_score": 0.00161, "epss_percentile": 0.37543}, "CVE-2024-0727": {"epss_score": 0.00196, "epss_percentile": 0.41749}, "CVE-2024-0728": {"epss_score": 0.00095, "epss_percentile": 0.27172}, "CVE-2024-0729": {"epss_score": 0.00069, "epss_percentile": 0.21436}, "CVE-2024-0730": {"epss_score": 0.00081, "epss_percentile": 0.24307}, "CVE-2024-0731": {"epss_score": 0.00083, "epss_percentile": 0.24817}, "CVE-2024-0732": {"epss_score": 0.00083, "epss_percentile": 0.24817}, "CVE-2024-0733": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0734": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0735": {"epss_score": 0.00077, "epss_percentile": 0.23407}, "CVE-2024-0736": {"epss_score": 0.00039, "epss_percentile": 0.11528}, "CVE-2024-0737": {"epss_score": 0.01215, "epss_percentile": 0.78589}, "CVE-2024-0738": {"epss_score": 0.00206, "epss_percentile": 0.4305}, "CVE-2024-0739": {"epss_score": 0.00189, "epss_percentile": 0.40935}, "CVE-2024-0740": {"epss_score": 0.12357, "epss_percentile": 0.93648}, "CVE-2024-0741": {"epss_score": 0.40766, "epss_percentile": 0.97237}, "CVE-2024-0742": {"epss_score": 0.01221, "epss_percentile": 0.7865}, "CVE-2024-0743": {"epss_score": 0.0063, "epss_percentile": 0.69707}, "CVE-2024-0744": {"epss_score": 0.00369, "epss_percentile": 0.58251}, "CVE-2024-0745": {"epss_score": 0.00558, "epss_percentile": 0.67579}, "CVE-2024-0746": {"epss_score": 0.00446, "epss_percentile": 0.62916}, "CVE-2024-0747": {"epss_score": 0.00412, "epss_percentile": 0.6094}, "CVE-2024-0748": {"epss_score": 0.00213, "epss_percentile": 0.43907}, "CVE-2024-0749": {"epss_score": 0.00301, "epss_percentile": 0.53049}, "CVE-2024-0750": {"epss_score": 0.0101, "epss_percentile": 0.76592}, "CVE-2024-0751": {"epss_score": 0.00408, "epss_percentile": 0.60639}, "CVE-2024-0752": {"epss_score": 0.00121, "epss_percentile": 0.3182}, "CVE-2024-0753": {"epss_score": 0.00327, "epss_percentile": 0.55098}, "CVE-2024-0754": {"epss_score": 0.00187, "epss_percentile": 0.40774}, "CVE-2024-0755": {"epss_score": 0.00697, "epss_percentile": 0.71412}, "CVE-2024-0756": {"epss_score": 0.00236, "epss_percentile": 0.4638}, "CVE-2024-0757": {"epss_score": 0.59072, "epss_percentile": 0.98148}, "CVE-2024-0758": {"epss_score": 0.01935, "epss_percentile": 0.82958}, "CVE-2024-0759": {"epss_score": 0.00408, "epss_percentile": 0.60622}, "CVE-2024-0760": {"epss_score": 0.1669, "epss_percentile": 0.94715}, "CVE-2024-0761": {"epss_score": 0.00437, "epss_percentile": 0.62529}, "CVE-2024-0762": {"epss_score": 0.00388, "epss_percentile": 0.59344}, "CVE-2024-0763": {"epss_score": 0.00694, "epss_percentile": 0.71339}, "CVE-2024-0765": {"epss_score": 0.00072, "epss_percentile": 0.2236}, "CVE-2024-0766": {"epss_score": 0.00148, "epss_percentile": 0.35909}, "CVE-2024-0767": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2024-0768": {"epss_score": 0.00202, "epss_percentile": 0.42453}, "CVE-2024-0769": {"epss_score": 0.68921, "epss_percentile": 0.98568}, "CVE-2024-0770": {"epss_score": 0.00014, "epss_percentile": 0.01889}, "CVE-2024-0771": {"epss_score": 0.00029, "epss_percentile": 0.07954}, "CVE-2024-0772": {"epss_score": 0.00026, "epss_percentile": 0.06626}, "CVE-2024-0773": {"epss_score": 0.00129, "epss_percentile": 0.33097}, "CVE-2024-0774": {"epss_score": 0.00025, "epss_percentile": 0.06224}, "CVE-2024-0775": {"epss_score": 0.00016, "epss_percentile": 0.02763}, "CVE-2024-0776": {"epss_score": 0.00076, "epss_percentile": 0.23173}, "CVE-2024-0778": {"epss_score": 0.61181, "epss_percentile": 0.98237}, "CVE-2024-0779": {"epss_score": 0.00308, "epss_percentile": 0.5358}, "CVE-2024-0780": {"epss_score": 0.00447, "epss_percentile": 0.62962}, "CVE-2024-0781": {"epss_score": 0.00081, "epss_percentile": 0.24324}, "CVE-2024-0782": {"epss_score": 0.00157, "epss_percentile": 0.37092}, "CVE-2024-0783": {"epss_score": 0.02291, "epss_percentile": 0.84284}, "CVE-2024-0784": {"epss_score": 0.00064, "epss_percentile": 0.20268}, "CVE-2024-0786": {"epss_score": 0.00288, "epss_percentile": 0.51977}, "CVE-2024-0787": {"epss_score": 0.00026, "epss_percentile": 0.06712}, "CVE-2024-0788": {"epss_score": 0.00043, "epss_percentile": 0.1317}, "CVE-2024-0789": {"epss_score": 0.00095, "epss_percentile": 0.27105}, "CVE-2024-0790": {"epss_score": 0.00088, "epss_percentile": 0.25746}, "CVE-2024-0791": {"epss_score": 0.00132, "epss_percentile": 0.33531}, "CVE-2024-0792": {"epss_score": 0.00188, "epss_percentile": 0.40848}, "CVE-2024-0793": {"epss_score": 0.00136, "epss_percentile": 0.34146}, "CVE-2024-0794": {"epss_score": 0.02948, "epss_percentile": 0.86049}, "CVE-2024-0795": {"epss_score": 0.0041, "epss_percentile": 0.60788}, "CVE-2024-0796": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2024-0797": {"epss_score": 0.00134, "epss_percentile": 0.33864}, "CVE-2024-0798": {"epss_score": 0.00166, "epss_percentile": 0.38157}, "CVE-2024-0799": {"epss_score": 0.45936, "epss_percentile": 0.9751}, "CVE-2024-0800": {"epss_score": 0.00261, "epss_percentile": 0.49309}, "CVE-2024-0801": {"epss_score": 0.5403, "epss_percentile": 0.97908}, "CVE-2024-0802": {"epss_score": 0.0036, "epss_percentile": 0.57646}, "CVE-2024-0803": {"epss_score": 0.00425, "epss_percentile": 0.61715}, "CVE-2024-0804": {"epss_score": 0.00113, "epss_percentile": 0.30649}, "CVE-2024-0805": {"epss_score": 0.00134, "epss_percentile": 0.33805}, "CVE-2024-0806": {"epss_score": 0.00329, "epss_percentile": 0.55319}, "CVE-2024-0807": {"epss_score": 0.00253, "epss_percentile": 0.48487}, "CVE-2024-0808": {"epss_score": 0.00344, "epss_percentile": 0.56523}, "CVE-2024-0809": {"epss_score": 0.00041, "epss_percentile": 0.12285}, "CVE-2024-0810": {"epss_score": 0.00073, "epss_percentile": 0.22494}, "CVE-2024-0811": {"epss_score": 0.00256, "epss_percentile": 0.48789}, "CVE-2024-0812": {"epss_score": 0.00329, "epss_percentile": 0.55319}, "CVE-2024-0813": {"epss_score": 0.00076, "epss_percentile": 0.23145}, "CVE-2024-0814": {"epss_score": 0.00129, "epss_percentile": 0.33088}, "CVE-2024-0815": {"epss_score": 0.00089, "epss_percentile": 0.25987}, "CVE-2024-0816": {"epss_score": 0.00085, "epss_percentile": 0.25064}, "CVE-2024-0817": {"epss_score": 0.00208, "epss_percentile": 0.43208}, "CVE-2024-0818": {"epss_score": 0.00329, "epss_percentile": 0.55402}, "CVE-2024-0819": {"epss_score": 0.00086, "epss_percentile": 0.25411}, "CVE-2024-0820": {"epss_score": 0.00231, "epss_percentile": 0.45788}, "CVE-2024-0821": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2024-0822": {"epss_score": 0.00041, "epss_percentile": 0.12263}, "CVE-2024-0823": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-0824": {"epss_score": 0.00105, "epss_percentile": 0.29268}, "CVE-2024-0825": {"epss_score": 0.01021, "epss_percentile": 0.76748}, "CVE-2024-0826": {"epss_score": 0.0028, "epss_percentile": 0.51004}, "CVE-2024-0827": {"epss_score": 0.00102, "epss_percentile": 0.28749}, "CVE-2024-0828": {"epss_score": 0.00108, "epss_percentile": 0.29829}, "CVE-2024-0829": {"epss_score": 0.00132, "epss_percentile": 0.33531}, "CVE-2024-0830": {"epss_score": 0.00125, "epss_percentile": 0.32471}, "CVE-2024-0831": {"epss_score": 0.00156, "epss_percentile": 0.37013}, "CVE-2024-0832": {"epss_score": 0.00674, "epss_percentile": 0.70849}, "CVE-2024-0833": {"epss_score": 0.00121, "epss_percentile": 0.31821}, "CVE-2024-0834": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2024-0835": {"epss_score": 0.00113, "epss_percentile": 0.30725}, "CVE-2024-0836": {"epss_score": 0.00064, "epss_percentile": 0.2015}, "CVE-2024-0837": {"epss_score": 0.00119, "epss_percentile": 0.31584}, "CVE-2024-0838": {"epss_score": 0.00887, "epss_percentile": 0.74964}, "CVE-2024-0839": {"epss_score": 0.00247, "epss_percentile": 0.47863}, "CVE-2024-0840": {"epss_score": 0.00374, "epss_percentile": 0.58558}, "CVE-2024-0841": {"epss_score": 0.00011, "epss_percentile": 0.01108}, "CVE-2024-0842": {"epss_score": 0.00277, "epss_percentile": 0.50834}, "CVE-2024-0844": {"epss_score": 0.00088, "epss_percentile": 0.25758}, "CVE-2024-0845": {"epss_score": 0.00234, "epss_percentile": 0.46156}, "CVE-2024-0847": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2024-0848": {"epss_score": 0.01095, "epss_percentile": 0.775}, "CVE-2024-0849": {"epss_score": 0.00021, "epss_percentile": 0.04736}, "CVE-2024-0851": {"epss_score": 0.0013, "epss_percentile": 0.33303}, "CVE-2024-0852": {"epss_score": 0.01003, "epss_percentile": 0.76515}, "CVE-2024-0853": {"epss_score": 0.00156, "epss_percentile": 0.36912}, "CVE-2024-0854": {"epss_score": 0.00178, "epss_percentile": 0.39717}, "CVE-2024-0855": {"epss_score": 0.00187, "epss_percentile": 0.40755}, "CVE-2024-0856": {"epss_score": 0.00209, "epss_percentile": 0.43333}, "CVE-2024-0857": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2024-0858": {"epss_score": 0.00267, "epss_percentile": 0.49998}, "CVE-2024-0859": {"epss_score": 0.00125, "epss_percentile": 0.32471}, "CVE-2024-0860": {"epss_score": 0.00031, "epss_percentile": 0.08473}, "CVE-2024-0861": {"epss_score": 0.00017, "epss_percentile": 0.03228}, "CVE-2024-0862": {"epss_score": 0.00223, "epss_percentile": 0.44878}, "CVE-2024-0864": {"epss_score": 0.03971, "epss_percentile": 0.88036}, "CVE-2024-0865": {"epss_score": 0.00109, "epss_percentile": 0.30032}, "CVE-2024-0866": {"epss_score": 0.01161, "epss_percentile": 0.78144}, "CVE-2024-0867": {"epss_score": 0.01328, "epss_percentile": 0.79494}, "CVE-2024-0868": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2024-0869": {"epss_score": 0.00394, "epss_percentile": 0.59774}, "CVE-2024-0870": {"epss_score": 0.00217, "epss_percentile": 0.44329}, "CVE-2024-0871": {"epss_score": 0.00193, "epss_percentile": 0.41498}, "CVE-2024-0872": {"epss_score": 0.00249, "epss_percentile": 0.48008}, "CVE-2024-0873": {"epss_score": 0.00255, "epss_percentile": 0.48718}, "CVE-2024-0874": {"epss_score": 0.00129, "epss_percentile": 0.33187}, "CVE-2024-0875": {"epss_score": 0.04566, "epss_percentile": 0.88857}, "CVE-2024-0879": {"epss_score": 0.00028, "epss_percentile": 0.07573}, "CVE-2024-0880": {"epss_score": 0.00226, "epss_percentile": 0.45299}, "CVE-2024-0881": {"epss_score": 0.13073, "epss_percentile": 0.93866}, "CVE-2024-0882": {"epss_score": 0.00259, "epss_percentile": 0.49056}, "CVE-2024-0883": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-0884": {"epss_score": 0.00106, "epss_percentile": 0.29447}, "CVE-2024-0885": {"epss_score": 0.00081, "epss_percentile": 0.24281}, "CVE-2024-0886": {"epss_score": 0.00032, "epss_percentile": 0.09095}, "CVE-2024-0887": {"epss_score": 0.00085, "epss_percentile": 0.2513}, "CVE-2024-0888": {"epss_score": 0.00086, "epss_percentile": 0.25441}, "CVE-2024-0889": {"epss_score": 0.00081, "epss_percentile": 0.24281}, "CVE-2024-0890": {"epss_score": 0.00123, "epss_percentile": 0.3224}, "CVE-2024-0891": {"epss_score": 0.00096, "epss_percentile": 0.27267}, "CVE-2024-0892": {"epss_score": 0.00096, "epss_percentile": 0.27406}, "CVE-2024-0893": {"epss_score": 0.00122, "epss_percentile": 0.32104}, "CVE-2024-0895": {"epss_score": 0.00181, "epss_percentile": 0.40124}, "CVE-2024-0896": {"epss_score": 0.00297, "epss_percentile": 0.52748}, "CVE-2024-0897": {"epss_score": 0.00241, "epss_percentile": 0.47251}, "CVE-2024-0898": {"epss_score": 0.0019, "epss_percentile": 0.41113}, "CVE-2024-0899": {"epss_score": 0.00572, "epss_percentile": 0.68006}, "CVE-2024-0900": {"epss_score": 0.00072, "epss_percentile": 0.22423}, "CVE-2024-0901": {"epss_score": 0.00305, "epss_percentile": 0.53354}, "CVE-2024-0902": {"epss_score": 0.00116, "epss_percentile": 0.31133}, "CVE-2024-0903": {"epss_score": 0.00576, "epss_percentile": 0.68141}, "CVE-2024-0904": {"epss_score": 0.00436, "epss_percentile": 0.62459}, "CVE-2024-0905": {"epss_score": 0.00295, "epss_percentile": 0.52501}, "CVE-2024-0906": {"epss_score": 0.00392, "epss_percentile": 0.59647}, "CVE-2024-0907": {"epss_score": 0.00662, "epss_percentile": 0.70603}, "CVE-2024-0908": {"epss_score": 0.0034, "epss_percentile": 0.5624}, "CVE-2024-0909": {"epss_score": 0.00465, "epss_percentile": 0.63746}, "CVE-2024-0910": {"epss_score": 0.00396, "epss_percentile": 0.59926}, "CVE-2024-0911": {"epss_score": 0.00054, "epss_percentile": 0.17256}, "CVE-2024-0912": {"epss_score": 0.0005, "epss_percentile": 0.15828}, "CVE-2024-0913": {"epss_score": 0.00678, "epss_percentile": 0.70989}, "CVE-2024-0914": {"epss_score": 0.00229, "epss_percentile": 0.4556}, "CVE-2024-0916": {"epss_score": 0.02799, "epss_percentile": 0.85692}, "CVE-2024-0917": {"epss_score": 0.02381, "epss_percentile": 0.84565}, "CVE-2024-0918": {"epss_score": 0.58251, "epss_percentile": 0.98103}, "CVE-2024-0919": {"epss_score": 0.47683, "epss_percentile": 0.97596}, "CVE-2024-0920": {"epss_score": 0.00459, "epss_percentile": 0.63478}, "CVE-2024-0921": {"epss_score": 0.17896, "epss_percentile": 0.94923}, "CVE-2024-0922": {"epss_score": 0.00159, "epss_percentile": 0.37389}, "CVE-2024-0923": {"epss_score": 0.00159, "epss_percentile": 0.37389}, "CVE-2024-0924": {"epss_score": 0.00172, "epss_percentile": 0.38965}, "CVE-2024-0925": {"epss_score": 0.00172, "epss_percentile": 0.38965}, "CVE-2024-0926": {"epss_score": 0.00172, "epss_percentile": 0.38965}, "CVE-2024-0927": {"epss_score": 0.00172, "epss_percentile": 0.38965}, "CVE-2024-0928": {"epss_score": 0.00172, "epss_percentile": 0.38965}, "CVE-2024-0929": {"epss_score": 0.00178, "epss_percentile": 0.39691}, "CVE-2024-0930": {"epss_score": 0.07342, "epss_percentile": 0.91419}, "CVE-2024-0931": {"epss_score": 0.00073, "epss_percentile": 0.22617}, "CVE-2024-0932": {"epss_score": 0.00073, "epss_percentile": 0.22617}, "CVE-2024-0933": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2024-0935": {"epss_score": 0.00095, "epss_percentile": 0.27187}, "CVE-2024-0936": {"epss_score": 0.00081, "epss_percentile": 0.2431}, "CVE-2024-0937": {"epss_score": 0.00081, "epss_percentile": 0.2431}, "CVE-2024-0938": {"epss_score": 0.00062, "epss_percentile": 0.19681}, "CVE-2024-0939": {"epss_score": 0.8887, "epss_percentile": 0.99496}, "CVE-2024-0941": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-0942": {"epss_score": 0.00073, "epss_percentile": 0.22627}, "CVE-2024-0943": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-0944": {"epss_score": 0.01634, "epss_percentile": 0.81467}, "CVE-2024-0945": {"epss_score": 0.00088, "epss_percentile": 0.25657}, "CVE-2024-0946": {"epss_score": 0.00065, "epss_percentile": 0.20441}, "CVE-2024-0947": {"epss_score": 0.00174, "epss_percentile": 0.39221}, "CVE-2024-0948": {"epss_score": 0.001, "epss_percentile": 0.28464}, "CVE-2024-0949": {"epss_score": 0.00027, "epss_percentile": 0.06843}, "CVE-2024-0951": {"epss_score": 0.0009, "epss_percentile": 0.26083}, "CVE-2024-0952": {"epss_score": 0.01715, "epss_percentile": 0.81896}, "CVE-2024-0953": {"epss_score": 0.00136, "epss_percentile": 0.34109}, "CVE-2024-0954": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-0955": {"epss_score": 0.00097, "epss_percentile": 0.27496}, "CVE-2024-0956": {"epss_score": 0.00678, "epss_percentile": 0.70989}, "CVE-2024-0957": {"epss_score": 0.01299, "epss_percentile": 0.79279}, "CVE-2024-0958": {"epss_score": 0.00129, "epss_percentile": 0.33097}, "CVE-2024-0959": {"epss_score": 0.00073, "epss_percentile": 0.22502}, "CVE-2024-0960": {"epss_score": 0.00061, "epss_percentile": 0.19545}, "CVE-2024-0961": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2024-0962": {"epss_score": 0.00127, "epss_percentile": 0.32937}, "CVE-2024-0963": {"epss_score": 0.00165, "epss_percentile": 0.38131}, "CVE-2024-0964": {"epss_score": 0.00109, "epss_percentile": 0.29906}, "CVE-2024-0965": {"epss_score": 0.00256, "epss_percentile": 0.48833}, "CVE-2024-0966": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2024-0967": {"epss_score": 0.00078, "epss_percentile": 0.23798}, "CVE-2024-0969": {"epss_score": 0.00305, "epss_percentile": 0.53376}, "CVE-2024-0970": {"epss_score": 0.00062, "epss_percentile": 0.19569}, "CVE-2024-0971": {"epss_score": 0.00125, "epss_percentile": 0.32564}, "CVE-2024-0972": {"epss_score": 0.00301, "epss_percentile": 0.53064}, "CVE-2024-0973": {"epss_score": 0.00127, "epss_percentile": 0.32894}, "CVE-2024-0974": {"epss_score": 0.00164, "epss_percentile": 0.37992}, "CVE-2024-0975": {"epss_score": 0.00373, "epss_percentile": 0.58519}, "CVE-2024-0976": {"epss_score": 0.01488, "epss_percentile": 0.80615}, "CVE-2024-0977": {"epss_score": 0.00148, "epss_percentile": 0.35859}, "CVE-2024-0978": {"epss_score": 0.00384, "epss_percentile": 0.59135}, "CVE-2024-0979": {"epss_score": 0.03505, "epss_percentile": 0.87256}, "CVE-2024-0980": {"epss_score": 0.00075, "epss_percentile": 0.23015}, "CVE-2024-0981": {"epss_score": 0.00706, "epss_percentile": 0.71616}, "CVE-2024-0983": {"epss_score": 0.0033, "epss_percentile": 0.55465}, "CVE-2024-0984": {"epss_score": 0.0033, "epss_percentile": 0.55465}, "CVE-2024-0985": {"epss_score": 0.0064, "epss_percentile": 0.69969}, "CVE-2024-0986": {"epss_score": 0.8327, "epss_percentile": 0.99241}, "CVE-2024-0987": {"epss_score": 0.00181, "epss_percentile": 0.4008}, "CVE-2024-0988": {"epss_score": 0.00168, "epss_percentile": 0.38472}, "CVE-2024-0989": {"epss_score": 0.00111, "epss_percentile": 0.30316}, "CVE-2024-0990": {"epss_score": 0.00114, "epss_percentile": 0.30849}, "CVE-2024-0991": {"epss_score": 0.00095, "epss_percentile": 0.2709}, "CVE-2024-0992": {"epss_score": 0.00114, "epss_percentile": 0.30849}, "CVE-2024-0993": {"epss_score": 0.00114, "epss_percentile": 0.30849}, "CVE-2024-0994": {"epss_score": 0.00095, "epss_percentile": 0.2709}, "CVE-2024-0995": {"epss_score": 0.00136, "epss_percentile": 0.34094}, "CVE-2024-0996": {"epss_score": 0.00093, "epss_percentile": 0.26651}, "CVE-2024-0997": {"epss_score": 0.00115, "epss_percentile": 0.3098}, "CVE-2024-0998": {"epss_score": 0.00433, "epss_percentile": 0.62198}, "CVE-2024-0999": {"epss_score": 0.0041, "epss_percentile": 0.60801}, "CVE-2024-10000": {"epss_score": 0.00224, "epss_percentile": 0.44974}, "CVE-2024-10001": {"epss_score": 0.00162, "epss_percentile": 0.37622}, "CVE-2024-10002": {"epss_score": 0.00612, "epss_percentile": 0.69237}, "CVE-2024-10003": {"epss_score": 0.0026, "epss_percentile": 0.49161}, "CVE-2024-10004": {"epss_score": 0.0042, "epss_percentile": 0.6144}, "CVE-2024-10005": {"epss_score": 0.00207, "epss_percentile": 0.43179}, "CVE-2024-10006": {"epss_score": 0.00035, "epss_percentile": 0.10115}, "CVE-2024-10007": {"epss_score": 0.00201, "epss_percentile": 0.42334}, "CVE-2024-10008": {"epss_score": 0.15896, "epss_percentile": 0.94527}, "CVE-2024-10009": {"epss_score": 0.00035, "epss_percentile": 0.09896}, "CVE-2024-10010": {"epss_score": 0.00072, "epss_percentile": 0.22462}, "CVE-2024-10011": {"epss_score": 0.00967, "epss_percentile": 0.76071}, "CVE-2024-10012": {"epss_score": 0.00058, "epss_percentile": 0.18585}, "CVE-2024-10013": {"epss_score": 0.0001, "epss_percentile": 0.00768}, "CVE-2024-10014": {"epss_score": 0.00163, "epss_percentile": 0.37856}, "CVE-2024-10015": {"epss_score": 0.14402, "epss_percentile": 0.94205}, "CVE-2024-10016": {"epss_score": 0.00097, "epss_percentile": 0.27581}, "CVE-2024-10017": {"epss_score": 0.00158, "epss_percentile": 0.37195}, "CVE-2024-10018": {"epss_score": 0.00073, "epss_percentile": 0.22565}, "CVE-2024-10019": {"epss_score": 0.0006, "epss_percentile": 0.18977}, "CVE-2024-10020": {"epss_score": 0.00459, "epss_percentile": 0.63481}, "CVE-2024-10021": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-10022": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-10023": {"epss_score": 0.00107, "epss_percentile": 0.29652}, "CVE-2024-10024": {"epss_score": 0.00033, "epss_percentile": 0.09137}, "CVE-2024-10025": {"epss_score": 0.00122, "epss_percentile": 0.32139}, "CVE-2024-10026": {"epss_score": 0.00071, "epss_percentile": 0.22158}, "CVE-2024-10027": {"epss_score": 0.00065, "epss_percentile": 0.20648}, "CVE-2024-10028": {"epss_score": 0.01704, "epss_percentile": 0.81848}, "CVE-2024-10029": {"epss_score": 0.00022, "epss_percentile": 0.05159}, "CVE-2024-10031": {"epss_score": 0.00019, "epss_percentile": 0.04082}, "CVE-2024-10032": {"epss_score": 0.00022, "epss_percentile": 0.05033}, "CVE-2024-10033": {"epss_score": 0.00565, "epss_percentile": 0.67782}, "CVE-2024-10034": {"epss_score": 0.0015, "epss_percentile": 0.36083}, "CVE-2024-10035": {"epss_score": 0.00848, "epss_percentile": 0.74357}, "CVE-2024-10037": {"epss_score": 0.00092, "epss_percentile": 0.26571}, "CVE-2024-10038": {"epss_score": 0.00187, "epss_percentile": 0.40803}, "CVE-2024-10040": {"epss_score": 0.00116, "epss_percentile": 0.31156}, "CVE-2024-10041": {"epss_score": 0.00031, "epss_percentile": 0.08535}, "CVE-2024-10043": {"epss_score": 0.00011, "epss_percentile": 0.0109}, "CVE-2024-10044": {"epss_score": 0.00146, "epss_percentile": 0.35632}, "CVE-2024-10045": {"epss_score": 0.00132, "epss_percentile": 0.33536}, "CVE-2024-10046": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-10047": {"epss_score": 0.00661, "epss_percentile": 0.70578}, "CVE-2024-10048": {"epss_score": 0.01127, "epss_percentile": 0.77823}, "CVE-2024-10049": {"epss_score": 0.01474, "epss_percentile": 0.8052}, "CVE-2024-10050": {"epss_score": 0.0034, "epss_percentile": 0.5628}, "CVE-2024-10051": {"epss_score": 0.00329, "epss_percentile": 0.55395}, "CVE-2024-10054": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-10055": {"epss_score": 0.00266, "epss_percentile": 0.49896}, "CVE-2024-10056": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-10057": {"epss_score": 0.00265, "epss_percentile": 0.49788}, "CVE-2024-10068": {"epss_score": 0.00093, "epss_percentile": 0.26699}, "CVE-2024-10069": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-10070": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-10071": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10072": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-10073": {"epss_score": 0.00042, "epss_percentile": 0.12667}, "CVE-2024-10074": {"epss_score": 0.00039, "epss_percentile": 0.11719}, "CVE-2024-10075": {"epss_score": 0.00081, "epss_percentile": 0.24386}, "CVE-2024-10076": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2024-10078": {"epss_score": 0.00445, "epss_percentile": 0.62852}, "CVE-2024-10079": {"epss_score": 0.00442, "epss_percentile": 0.62723}, "CVE-2024-10080": {"epss_score": 0.00123, "epss_percentile": 0.32336}, "CVE-2024-10081": {"epss_score": 0.65481, "epss_percentile": 0.98421}, "CVE-2024-10082": {"epss_score": 0.00286, "epss_percentile": 0.51778}, "CVE-2024-10083": {"epss_score": 0.00031, "epss_percentile": 0.08638}, "CVE-2024-10084": {"epss_score": 0.00383, "epss_percentile": 0.59091}, "CVE-2024-10086": {"epss_score": 0.01081, "epss_percentile": 0.77371}, "CVE-2024-10087": {"epss_score": 0.00042, "epss_percentile": 0.12797}, "CVE-2024-10088": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2024-10089": {"epss_score": 0.00042, "epss_percentile": 0.12797}, "CVE-2024-10090": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2024-10091": {"epss_score": 0.00141, "epss_percentile": 0.34927}, "CVE-2024-10092": {"epss_score": 0.00097, "epss_percentile": 0.27618}, "CVE-2024-10093": {"epss_score": 0.00084, "epss_percentile": 0.24831}, "CVE-2024-10094": {"epss_score": 0.00392, "epss_percentile": 0.59671}, "CVE-2024-10095": {"epss_score": 0.00343, "epss_percentile": 0.56474}, "CVE-2024-10097": {"epss_score": 0.00304, "epss_percentile": 0.53295}, "CVE-2024-10098": {"epss_score": 0.00073, "epss_percentile": 0.22556}, "CVE-2024-10099": {"epss_score": 0.00106, "epss_percentile": 0.29445}, "CVE-2024-10100": {"epss_score": 0.00377, "epss_percentile": 0.58735}, "CVE-2024-10101": {"epss_score": 0.00234, "epss_percentile": 0.46175}, "CVE-2024-10102": {"epss_score": 0.0007, "epss_percentile": 0.21699}, "CVE-2024-10103": {"epss_score": 0.00105, "epss_percentile": 0.29302}, "CVE-2024-10104": {"epss_score": 0.0007, "epss_percentile": 0.21976}, "CVE-2024-10105": {"epss_score": 0.00053, "epss_percentile": 0.16928}, "CVE-2024-10106": {"epss_score": 0.00134, "epss_percentile": 0.33902}, "CVE-2024-10107": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-10108": {"epss_score": 0.01125, "epss_percentile": 0.77808}, "CVE-2024-10109": {"epss_score": 0.00118, "epss_percentile": 0.31434}, "CVE-2024-10110": {"epss_score": 0.00128, "epss_percentile": 0.33002}, "CVE-2024-10111": {"epss_score": 0.00752, "epss_percentile": 0.72657}, "CVE-2024-10112": {"epss_score": 0.0016, "epss_percentile": 0.37499}, "CVE-2024-10113": {"epss_score": 0.00121, "epss_percentile": 0.31924}, "CVE-2024-10114": {"epss_score": 0.00221, "epss_percentile": 0.44673}, "CVE-2024-10116": {"epss_score": 0.00091, "epss_percentile": 0.2629}, "CVE-2024-10117": {"epss_score": 0.00118, "epss_percentile": 0.31505}, "CVE-2024-10118": {"epss_score": 0.00551, "epss_percentile": 0.67375}, "CVE-2024-10119": {"epss_score": 0.00666, "epss_percentile": 0.70685}, "CVE-2024-10120": {"epss_score": 0.00107, "epss_percentile": 0.29602}, "CVE-2024-10121": {"epss_score": 0.00161, "epss_percentile": 0.37614}, "CVE-2024-10122": {"epss_score": 0.00058, "epss_percentile": 0.18517}, "CVE-2024-10123": {"epss_score": 0.00786, "epss_percentile": 0.73296}, "CVE-2024-10124": {"epss_score": 0.78657, "epss_percentile": 0.98996}, "CVE-2024-10125": {"epss_score": 0.00189, "epss_percentile": 0.40992}, "CVE-2024-10126": {"epss_score": 0.00169, "epss_percentile": 0.38549}, "CVE-2024-10127": {"epss_score": 0.00073, "epss_percentile": 0.22557}, "CVE-2024-10128": {"epss_score": 0.00082, "epss_percentile": 0.24558}, "CVE-2024-10129": {"epss_score": 0.00117, "epss_percentile": 0.31368}, "CVE-2024-10130": {"epss_score": 0.00786, "epss_percentile": 0.73296}, "CVE-2024-10131": {"epss_score": 0.02207, "epss_percentile": 0.84006}, "CVE-2024-10133": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10134": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10135": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10136": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10137": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10138": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10139": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10140": {"epss_score": 0.11594, "epss_percentile": 0.93414}, "CVE-2024-10141": {"epss_score": 0.00146, "epss_percentile": 0.35548}, "CVE-2024-10142": {"epss_score": 0.00122, "epss_percentile": 0.32061}, "CVE-2024-10143": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-10144": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-10145": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-10146": {"epss_score": 0.01023, "epss_percentile": 0.7677}, "CVE-2024-10147": {"epss_score": 0.00224, "epss_percentile": 0.44974}, "CVE-2024-10148": {"epss_score": 0.00243, "epss_percentile": 0.47484}, "CVE-2024-10149": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-10150": {"epss_score": 0.0016, "epss_percentile": 0.37499}, "CVE-2024-10151": {"epss_score": 0.00069, "epss_percentile": 0.21635}, "CVE-2024-10152": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-10153": {"epss_score": 0.00044, "epss_percentile": 0.13437}, "CVE-2024-10154": {"epss_score": 0.00055, "epss_percentile": 0.17648}, "CVE-2024-10155": {"epss_score": 0.002, "epss_percentile": 0.4225}, "CVE-2024-10156": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-10157": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-10158": {"epss_score": 0.0017, "epss_percentile": 0.38681}, "CVE-2024-10159": {"epss_score": 0.00068, "epss_percentile": 0.21257}, "CVE-2024-10160": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10161": {"epss_score": 0.00107, "epss_percentile": 0.29611}, "CVE-2024-10162": {"epss_score": 0.00076, "epss_percentile": 0.23254}, "CVE-2024-10163": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10164": {"epss_score": 0.00141, "epss_percentile": 0.34804}, "CVE-2024-10165": {"epss_score": 0.00061, "epss_percentile": 0.1927}, "CVE-2024-10166": {"epss_score": 0.00044, "epss_percentile": 0.13539}, "CVE-2024-10167": {"epss_score": 0.00061, "epss_percentile": 0.1927}, "CVE-2024-10168": {"epss_score": 0.00283, "epss_percentile": 0.51359}, "CVE-2024-10169": {"epss_score": 0.00055, "epss_percentile": 0.17648}, "CVE-2024-10170": {"epss_score": 0.00076, "epss_percentile": 0.23278}, "CVE-2024-10171": {"epss_score": 0.00054, "epss_percentile": 0.17254}, "CVE-2024-10172": {"epss_score": 0.00083, "epss_percentile": 0.24592}, "CVE-2024-10173": {"epss_score": 0.00103, "epss_percentile": 0.28986}, "CVE-2024-10174": {"epss_score": 0.00319, "epss_percentile": 0.54465}, "CVE-2024-10175": {"epss_score": 0.0019, "epss_percentile": 0.41051}, "CVE-2024-10176": {"epss_score": 0.00169, "epss_percentile": 0.38531}, "CVE-2024-10177": {"epss_score": 0.00079, "epss_percentile": 0.23805}, "CVE-2024-10178": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-10179": {"epss_score": 0.0026, "epss_percentile": 0.49171}, "CVE-2024-10180": {"epss_score": 0.01213, "epss_percentile": 0.78566}, "CVE-2024-10181": {"epss_score": 0.00284, "epss_percentile": 0.51461}, "CVE-2024-10182": {"epss_score": 0.00169, "epss_percentile": 0.3864}, "CVE-2024-10183": {"epss_score": 0.00052, "epss_percentile": 0.16443}, "CVE-2024-10184": {"epss_score": 0.00284, "epss_percentile": 0.51454}, "CVE-2024-10185": {"epss_score": 0.00284, "epss_percentile": 0.51454}, "CVE-2024-10186": {"epss_score": 0.00283, "epss_percentile": 0.51359}, "CVE-2024-10187": {"epss_score": 0.0022, "epss_percentile": 0.44619}, "CVE-2024-10188": {"epss_score": 0.00117, "epss_percentile": 0.31208}, "CVE-2024-10189": {"epss_score": 0.00283, "epss_percentile": 0.51359}, "CVE-2024-10190": {"epss_score": 0.01333, "epss_percentile": 0.79528}, "CVE-2024-10191": {"epss_score": 0.0011, "epss_percentile": 0.30125}, "CVE-2024-10192": {"epss_score": 0.00131, "epss_percentile": 0.33487}, "CVE-2024-10193": {"epss_score": 0.00697, "epss_percentile": 0.71407}, "CVE-2024-10194": {"epss_score": 0.00096, "epss_percentile": 0.27361}, "CVE-2024-10195": {"epss_score": 0.00058, "epss_percentile": 0.18478}, "CVE-2024-10196": {"epss_score": 0.00102, "epss_percentile": 0.28751}, "CVE-2024-10197": {"epss_score": 0.00134, "epss_percentile": 0.33919}, "CVE-2024-10198": {"epss_score": 0.00142, "epss_percentile": 0.3508}, "CVE-2024-10199": {"epss_score": 0.00142, "epss_percentile": 0.3508}, "CVE-2024-10200": {"epss_score": 0.00544, "epss_percentile": 0.67134}, "CVE-2024-10201": {"epss_score": 0.0111, "epss_percentile": 0.77664}, "CVE-2024-10202": {"epss_score": 0.03211, "epss_percentile": 0.86655}, "CVE-2024-10203": {"epss_score": 0.00045, "epss_percentile": 0.13755}, "CVE-2024-10204": {"epss_score": 0.00101, "epss_percentile": 0.2862}, "CVE-2024-10205": {"epss_score": 0.00187, "epss_percentile": 0.40716}, "CVE-2024-10206": {"epss_score": 0.00082, "epss_percentile": 0.2445}, "CVE-2024-10207": {"epss_score": 0.00077, "epss_percentile": 0.23404}, "CVE-2024-10208": {"epss_score": 0.00102, "epss_percentile": 0.28746}, "CVE-2024-10209": {"epss_score": 0.00024, "epss_percentile": 0.05965}, "CVE-2024-10210": {"epss_score": 0.00092, "epss_percentile": 0.26503}, "CVE-2024-10214": {"epss_score": 0.00267, "epss_percentile": 0.49991}, "CVE-2024-10215": {"epss_score": 0.01425, "epss_percentile": 0.80196}, "CVE-2024-10216": {"epss_score": 0.00111, "epss_percentile": 0.303}, "CVE-2024-10217": {"epss_score": 0.00073, "epss_percentile": 0.22594}, "CVE-2024-10218": {"epss_score": 0.00055, "epss_percentile": 0.17516}, "CVE-2024-10219": {"epss_score": 0.00036, "epss_percentile": 0.10614}, "CVE-2024-10220": {"epss_score": 0.27328, "epss_percentile": 0.96237}, "CVE-2024-10222": {"epss_score": 0.00071, "epss_percentile": 0.22043}, "CVE-2024-10223": {"epss_score": 0.00183, "epss_percentile": 0.40359}, "CVE-2024-10224": {"epss_score": 0.00327, "epss_percentile": 0.55149}, "CVE-2024-10225": {"epss_score": 0.00205, "epss_percentile": 0.42764}, "CVE-2024-10226": {"epss_score": 0.00283, "epss_percentile": 0.51359}, "CVE-2024-10227": {"epss_score": 0.00283, "epss_percentile": 0.51359}, "CVE-2024-10228": {"epss_score": 0.00043, "epss_percentile": 0.13019}, "CVE-2024-10229": {"epss_score": 0.0006, "epss_percentile": 0.18978}, "CVE-2024-10230": {"epss_score": 0.00191, "epss_percentile": 0.41211}, "CVE-2024-10231": {"epss_score": 0.00156, "epss_percentile": 0.36954}, "CVE-2024-10232": {"epss_score": 0.00169, "epss_percentile": 0.38531}, "CVE-2024-10233": {"epss_score": 0.00274, "epss_percentile": 0.5056}, "CVE-2024-10234": {"epss_score": 0.00303, "epss_percentile": 0.53195}, "CVE-2024-10237": {"epss_score": 0.00037, "epss_percentile": 0.10793}, "CVE-2024-10238": {"epss_score": 0.00216, "epss_percentile": 0.44195}, "CVE-2024-10239": {"epss_score": 0.00235, "epss_percentile": 0.46202}, "CVE-2024-10240": {"epss_score": 0.00174, "epss_percentile": 0.39202}, "CVE-2024-10241": {"epss_score": 0.00267, "epss_percentile": 0.49991}, "CVE-2024-10244": {"epss_score": 0.00123, "epss_percentile": 0.32291}, "CVE-2024-10245": {"epss_score": 0.30297, "epss_percentile": 0.96525}, "CVE-2024-10247": {"epss_score": 0.00547, "epss_percentile": 0.67251}, "CVE-2024-10250": {"epss_score": 0.00731, "epss_percentile": 0.72174}, "CVE-2024-10251": {"epss_score": 0.00059, "epss_percentile": 0.18707}, "CVE-2024-10252": {"epss_score": 0.00132, "epss_percentile": 0.33567}, "CVE-2024-10253": {"epss_score": 0.00021, "epss_percentile": 0.04815}, "CVE-2024-10254": {"epss_score": 0.00021, "epss_percentile": 0.04815}, "CVE-2024-10256": {"epss_score": 0.00106, "epss_percentile": 0.29541}, "CVE-2024-10260": {"epss_score": 0.00432, "epss_percentile": 0.62159}, "CVE-2024-10261": {"epss_score": 0.00938, "epss_percentile": 0.75707}, "CVE-2024-10262": {"epss_score": 0.00357, "epss_percentile": 0.57469}, "CVE-2024-10263": {"epss_score": 0.01672, "epss_percentile": 0.81678}, "CVE-2024-10264": {"epss_score": 0.00302, "epss_percentile": 0.53127}, "CVE-2024-10265": {"epss_score": 0.01236, "epss_percentile": 0.78769}, "CVE-2024-10266": {"epss_score": 0.00225, "epss_percentile": 0.45082}, "CVE-2024-10267": {"epss_score": 0.00083, "epss_percentile": 0.24761}, "CVE-2024-10268": {"epss_score": 0.0026, "epss_percentile": 0.49171}, "CVE-2024-10269": {"epss_score": 0.00169, "epss_percentile": 0.38531}, "CVE-2024-10270": {"epss_score": 0.00088, "epss_percentile": 0.25653}, "CVE-2024-10272": {"epss_score": 0.00111, "epss_percentile": 0.30257}, "CVE-2024-10273": {"epss_score": 0.0006, "epss_percentile": 0.18989}, "CVE-2024-10274": {"epss_score": 0.00089, "epss_percentile": 0.25957}, "CVE-2024-10275": {"epss_score": 0.00091, "epss_percentile": 0.26391}, "CVE-2024-10276": {"epss_score": 0.00148, "epss_percentile": 0.35804}, "CVE-2024-10277": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10278": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10279": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10280": {"epss_score": 0.00215, "epss_percentile": 0.44052}, "CVE-2024-10281": {"epss_score": 0.0018, "epss_percentile": 0.39934}, "CVE-2024-10282": {"epss_score": 0.0018, "epss_percentile": 0.39934}, "CVE-2024-10283": {"epss_score": 0.0018, "epss_percentile": 0.39934}, "CVE-2024-10284": {"epss_score": 0.00119, "epss_percentile": 0.31686}, "CVE-2024-10285": {"epss_score": 0.01033, "epss_percentile": 0.76882}, "CVE-2024-10286": {"epss_score": 0.00078, "epss_percentile": 0.23731}, "CVE-2024-10287": {"epss_score": 0.00078, "epss_percentile": 0.23731}, "CVE-2024-10288": {"epss_score": 0.00078, "epss_percentile": 0.23731}, "CVE-2024-10289": {"epss_score": 0.00078, "epss_percentile": 0.23731}, "CVE-2024-10290": {"epss_score": 0.00139, "epss_percentile": 0.34634}, "CVE-2024-10291": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10292": {"epss_score": 0.00105, "epss_percentile": 0.29277}, "CVE-2024-10293": {"epss_score": 0.00105, "epss_percentile": 0.29277}, "CVE-2024-10294": {"epss_score": 0.00333, "epss_percentile": 0.55645}, "CVE-2024-10295": {"epss_score": 0.0006, "epss_percentile": 0.19219}, "CVE-2024-10296": {"epss_score": 0.00104, "epss_percentile": 0.29234}, "CVE-2024-10297": {"epss_score": 0.00077, "epss_percentile": 0.23375}, "CVE-2024-10298": {"epss_score": 0.00108, "epss_percentile": 0.29862}, "CVE-2024-10299": {"epss_score": 0.00099, "epss_percentile": 0.28403}, "CVE-2024-10300": {"epss_score": 0.0011, "epss_percentile": 0.30214}, "CVE-2024-10301": {"epss_score": 0.0011, "epss_percentile": 0.30214}, "CVE-2024-10306": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-10307": {"epss_score": 0.00031, "epss_percentile": 0.0846}, "CVE-2024-10308": {"epss_score": 0.00088, "epss_percentile": 0.25647}, "CVE-2024-10309": {"epss_score": 0.00078, "epss_percentile": 0.23761}, "CVE-2024-10310": {"epss_score": 0.00243, "epss_percentile": 0.47484}, "CVE-2024-10311": {"epss_score": 0.00065, "epss_percentile": 0.20581}, "CVE-2024-10312": {"epss_score": 0.0014, "epss_percentile": 0.34716}, "CVE-2024-10313": {"epss_score": 0.00187, "epss_percentile": 0.40736}, "CVE-2024-10314": {"epss_score": 0.00629, "epss_percentile": 0.69679}, "CVE-2024-10315": {"epss_score": 0.001, "epss_percentile": 0.28525}, "CVE-2024-10316": {"epss_score": 0.00187, "epss_percentile": 0.40732}, "CVE-2024-10318": {"epss_score": 0.00426, "epss_percentile": 0.61745}, "CVE-2024-10319": {"epss_score": 0.00383, "epss_percentile": 0.59091}, "CVE-2024-10320": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-10321": {"epss_score": 0.00133, "epss_percentile": 0.33651}, "CVE-2024-10322": {"epss_score": 0.00069, "epss_percentile": 0.21563}, "CVE-2024-10323": {"epss_score": 0.00184, "epss_percentile": 0.40379}, "CVE-2024-10324": {"epss_score": 0.00096, "epss_percentile": 0.27449}, "CVE-2024-10325": {"epss_score": 0.0022, "epss_percentile": 0.44619}, "CVE-2024-10326": {"epss_score": 0.00038, "epss_percentile": 0.11364}, "CVE-2024-10327": {"epss_score": 0.00095, "epss_percentile": 0.27163}, "CVE-2024-10329": {"epss_score": 0.00447, "epss_percentile": 0.62955}, "CVE-2024-10330": {"epss_score": 0.00089, "epss_percentile": 0.25957}, "CVE-2024-10331": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10332": {"epss_score": 0.00189, "epss_percentile": 0.40954}, "CVE-2024-10334": {"epss_score": 0.00028, "epss_percentile": 0.07345}, "CVE-2024-10335": {"epss_score": 0.00076, "epss_percentile": 0.23161}, "CVE-2024-10336": {"epss_score": 0.00063, "epss_percentile": 0.20079}, "CVE-2024-10337": {"epss_score": 0.00064, "epss_percentile": 0.20394}, "CVE-2024-10338": {"epss_score": 0.00064, "epss_percentile": 0.20394}, "CVE-2024-10340": {"epss_score": 0.00139, "epss_percentile": 0.34541}, "CVE-2024-10341": {"epss_score": 0.0016, "epss_percentile": 0.37516}, "CVE-2024-10342": {"epss_score": 0.00121, "epss_percentile": 0.31943}, "CVE-2024-10343": {"epss_score": 0.00121, "epss_percentile": 0.31943}, "CVE-2024-10344": {"epss_score": 0.00629, "epss_percentile": 0.69679}, "CVE-2024-10345": {"epss_score": 0.00526, "epss_percentile": 0.66413}, "CVE-2024-10348": {"epss_score": 0.00099, "epss_percentile": 0.28397}, "CVE-2024-10349": {"epss_score": 0.00051, "epss_percentile": 0.16319}, "CVE-2024-10350": {"epss_score": 0.00101, "epss_percentile": 0.28657}, "CVE-2024-10351": {"epss_score": 0.00438, "epss_percentile": 0.62556}, "CVE-2024-10352": {"epss_score": 0.00293, "epss_percentile": 0.52307}, "CVE-2024-10353": {"epss_score": 0.00096, "epss_percentile": 0.27441}, "CVE-2024-10354": {"epss_score": 0.00089, "epss_percentile": 0.25941}, "CVE-2024-10355": {"epss_score": 0.00456, "epss_percentile": 0.63328}, "CVE-2024-10356": {"epss_score": 0.00139, "epss_percentile": 0.34543}, "CVE-2024-10357": {"epss_score": 0.00103, "epss_percentile": 0.2899}, "CVE-2024-10359": {"epss_score": 0.00096, "epss_percentile": 0.27322}, "CVE-2024-10360": {"epss_score": 0.00294, "epss_percentile": 0.5241}, "CVE-2024-10361": {"epss_score": 0.00337, "epss_percentile": 0.56045}, "CVE-2024-10362": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-10363": {"epss_score": 0.00072, "epss_percentile": 0.22379}, "CVE-2024-10365": {"epss_score": 0.00248, "epss_percentile": 0.47988}, "CVE-2024-10366": {"epss_score": 0.00062, "epss_percentile": 0.19629}, "CVE-2024-10367": {"epss_score": 0.00078, "epss_percentile": 0.23626}, "CVE-2024-10368": {"epss_score": 0.00042, "epss_percentile": 0.12633}, "CVE-2024-10369": {"epss_score": 0.00042, "epss_percentile": 0.12903}, "CVE-2024-10370": {"epss_score": 0.00042, "epss_percentile": 0.12903}, "CVE-2024-10371": {"epss_score": 0.00335, "epss_percentile": 0.5584}, "CVE-2024-10372": {"epss_score": 0.00067, "epss_percentile": 0.21051}, "CVE-2024-10374": {"epss_score": 0.00186, "epss_percentile": 0.40684}, "CVE-2024-10376": {"epss_score": 0.00098, "epss_percentile": 0.27797}, "CVE-2024-10377": {"epss_score": 0.00096, "epss_percentile": 0.27418}, "CVE-2024-10378": {"epss_score": 0.00178, "epss_percentile": 0.39697}, "CVE-2024-10379": {"epss_score": 0.00571, "epss_percentile": 0.67979}, "CVE-2024-10380": {"epss_score": 0.00117, "epss_percentile": 0.31368}, "CVE-2024-10381": {"epss_score": 0.0114, "epss_percentile": 0.77947}, "CVE-2024-10382": {"epss_score": 0.00037, "epss_percentile": 0.10891}, "CVE-2024-10383": {"epss_score": 0.0054, "epss_percentile": 0.6699}, "CVE-2024-10385": {"epss_score": 0.00595, "epss_percentile": 0.6868}, "CVE-2024-10386": {"epss_score": 0.02579, "epss_percentile": 0.8515}, "CVE-2024-10387": {"epss_score": 0.04396, "epss_percentile": 0.8864}, "CVE-2024-10388": {"epss_score": 0.01122, "epss_percentile": 0.77785}, "CVE-2024-10389": {"epss_score": 0.00028, "epss_percentile": 0.07557}, "CVE-2024-10390": {"epss_score": 0.00174, "epss_percentile": 0.39219}, "CVE-2024-10392": {"epss_score": 0.43598, "epss_percentile": 0.97393}, "CVE-2024-10393": {"epss_score": 0.00126, "epss_percentile": 0.32659}, "CVE-2024-10394": {"epss_score": 0.00011, "epss_percentile": 0.01098}, "CVE-2024-10395": {"epss_score": 0.00292, "epss_percentile": 0.52264}, "CVE-2024-10396": {"epss_score": 0.00154, "epss_percentile": 0.36729}, "CVE-2024-10397": {"epss_score": 0.00149, "epss_percentile": 0.35986}, "CVE-2024-10399": {"epss_score": 0.00155, "epss_percentile": 0.36839}, "CVE-2024-10400": {"epss_score": 0.92469, "epss_percentile": 0.99717}, "CVE-2024-10402": {"epss_score": 0.00365, "epss_percentile": 0.57984}, "CVE-2024-10403": {"epss_score": 0.00114, "epss_percentile": 0.30837}, "CVE-2024-10404": {"epss_score": 0.00014, "epss_percentile": 0.0199}, "CVE-2024-10405": {"epss_score": 0.00066, "epss_percentile": 0.20844}, "CVE-2024-10406": {"epss_score": 0.00076, "epss_percentile": 0.23254}, "CVE-2024-10407": {"epss_score": 0.00076, "epss_percentile": 0.23254}, "CVE-2024-10408": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-10409": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-10410": {"epss_score": 0.02603, "epss_percentile": 0.85214}, "CVE-2024-10411": {"epss_score": 0.00076, "epss_percentile": 0.23254}, "CVE-2024-10412": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-10413": {"epss_score": 0.00107, "epss_percentile": 0.29611}, "CVE-2024-10414": {"epss_score": 0.00113, "epss_percentile": 0.30651}, "CVE-2024-10415": {"epss_score": 0.00032, "epss_percentile": 0.09038}, "CVE-2024-10416": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10417": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-10418": {"epss_score": 0.00083, "epss_percentile": 0.24823}, "CVE-2024-10419": {"epss_score": 0.00153, "epss_percentile": 0.36578}, "CVE-2024-10420": {"epss_score": 0.00105, "epss_percentile": 0.29277}, "CVE-2024-10421": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-10422": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-10423": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-10424": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-10425": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-10426": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10427": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-10428": {"epss_score": 0.00932, "epss_percentile": 0.75625}, "CVE-2024-10429": {"epss_score": 0.00932, "epss_percentile": 0.75625}, "CVE-2024-10430": {"epss_score": 0.00061, "epss_percentile": 0.1927}, "CVE-2024-10431": {"epss_score": 0.00061, "epss_percentile": 0.1927}, "CVE-2024-10432": {"epss_score": 0.00092, "epss_percentile": 0.26422}, "CVE-2024-10433": {"epss_score": 0.00152, "epss_percentile": 0.36395}, "CVE-2024-10434": {"epss_score": 0.00185, "epss_percentile": 0.40527}, "CVE-2024-10435": {"epss_score": 0.01195, "epss_percentile": 0.78429}, "CVE-2024-10436": {"epss_score": 0.0087, "epss_percentile": 0.74697}, "CVE-2024-10437": {"epss_score": 0.00223, "epss_percentile": 0.44855}, "CVE-2024-10438": {"epss_score": 0.00091, "epss_percentile": 0.262}, "CVE-2024-10439": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-10440": {"epss_score": 0.00415, "epss_percentile": 0.61147}, "CVE-2024-10441": {"epss_score": 0.00535, "epss_percentile": 0.66825}, "CVE-2024-10442": {"epss_score": 0.009, "epss_percentile": 0.75163}, "CVE-2024-10443": {"epss_score": 0.70846, "epss_percentile": 0.98644}, "CVE-2024-10444": {"epss_score": 0.00046, "epss_percentile": 0.14184}, "CVE-2024-10445": {"epss_score": 0.00055, "epss_percentile": 0.17378}, "CVE-2024-10446": {"epss_score": 0.00076, "epss_percentile": 0.23254}, "CVE-2024-10447": {"epss_score": 0.00076, "epss_percentile": 0.23278}, "CVE-2024-10448": {"epss_score": 0.00325, "epss_percentile": 0.54994}, "CVE-2024-10449": {"epss_score": 0.03317, "epss_percentile": 0.86904}, "CVE-2024-10450": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10451": {"epss_score": 0.00089, "epss_percentile": 0.25939}, "CVE-2024-10452": {"epss_score": 0.00216, "epss_percentile": 0.44208}, "CVE-2024-10453": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-10454": {"epss_score": 0.0015, "epss_percentile": 0.36105}, "CVE-2024-10455": {"epss_score": 0.00154, "epss_percentile": 0.36691}, "CVE-2024-10456": {"epss_score": 0.01355, "epss_percentile": 0.7971}, "CVE-2024-10457": {"epss_score": 0.00077, "epss_percentile": 0.23539}, "CVE-2024-10458": {"epss_score": 0.0042, "epss_percentile": 0.61422}, "CVE-2024-10459": {"epss_score": 0.00654, "epss_percentile": 0.70355}, "CVE-2024-10460": {"epss_score": 0.00386, "epss_percentile": 0.5925}, "CVE-2024-10461": {"epss_score": 0.00736, "epss_percentile": 0.72302}, "CVE-2024-10462": {"epss_score": 0.00462, "epss_percentile": 0.63616}, "CVE-2024-10463": {"epss_score": 0.00468, "epss_percentile": 0.63885}, "CVE-2024-10464": {"epss_score": 0.00482, "epss_percentile": 0.64533}, "CVE-2024-10465": {"epss_score": 0.00462, "epss_percentile": 0.63616}, "CVE-2024-10466": {"epss_score": 0.00669, "epss_percentile": 0.70766}, "CVE-2024-10467": {"epss_score": 0.00665, "epss_percentile": 0.70667}, "CVE-2024-10468": {"epss_score": 0.00271, "epss_percentile": 0.50277}, "CVE-2024-10469": {"epss_score": 0.00063, "epss_percentile": 0.19815}, "CVE-2024-10470": {"epss_score": 0.51115, "epss_percentile": 0.97766}, "CVE-2024-10471": {"epss_score": 0.00053, "epss_percentile": 0.16699}, "CVE-2024-10472": {"epss_score": 0.00065, "epss_percentile": 0.20575}, "CVE-2024-10473": {"epss_score": 0.00112, "epss_percentile": 0.30518}, "CVE-2024-10474": {"epss_score": 0.00297, "epss_percentile": 0.527}, "CVE-2024-10475": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-10476": {"epss_score": 0.0006, "epss_percentile": 0.19214}, "CVE-2024-10477": {"epss_score": 0.00139, "epss_percentile": 0.34557}, "CVE-2024-10478": {"epss_score": 0.00162, "epss_percentile": 0.37645}, "CVE-2024-10479": {"epss_score": 0.0022, "epss_percentile": 0.44565}, "CVE-2024-10480": {"epss_score": 0.0005, "epss_percentile": 0.15725}, "CVE-2024-10481": {"epss_score": 0.00054, "epss_percentile": 0.17173}, "CVE-2024-10482": {"epss_score": 0.00174, "epss_percentile": 0.39223}, "CVE-2024-10483": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-10484": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-10486": {"epss_score": 0.04847, "epss_percentile": 0.8921}, "CVE-2024-10487": {"epss_score": 0.00298, "epss_percentile": 0.52804}, "CVE-2024-10488": {"epss_score": 0.00381, "epss_percentile": 0.5899}, "CVE-2024-10490": {"epss_score": 0.00157, "epss_percentile": 0.37088}, "CVE-2024-10491": {"epss_score": 0.00157, "epss_percentile": 0.37136}, "CVE-2024-10492": {"epss_score": 0.00079, "epss_percentile": 0.23907}, "CVE-2024-10493": {"epss_score": 0.00112, "epss_percentile": 0.30518}, "CVE-2024-10494": {"epss_score": 0.00033, "epss_percentile": 0.09179}, "CVE-2024-10495": {"epss_score": 0.00033, "epss_percentile": 0.09179}, "CVE-2024-10496": {"epss_score": 0.00033, "epss_percentile": 0.09179}, "CVE-2024-10497": {"epss_score": 0.00162, "epss_percentile": 0.37712}, "CVE-2024-10498": {"epss_score": 0.00179, "epss_percentile": 0.3977}, "CVE-2024-10499": {"epss_score": 0.00307, "epss_percentile": 0.53531}, "CVE-2024-10500": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-10501": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-10502": {"epss_score": 0.00134, "epss_percentile": 0.33755}, "CVE-2024-10503": {"epss_score": 0.00127, "epss_percentile": 0.32798}, "CVE-2024-10504": {"epss_score": 0.00056, "epss_percentile": 0.17922}, "CVE-2024-10505": {"epss_score": 0.00091, "epss_percentile": 0.26391}, "CVE-2024-10506": {"epss_score": 0.00045, "epss_percentile": 0.13892}, "CVE-2024-10507": {"epss_score": 0.00055, "epss_percentile": 0.1763}, "CVE-2024-10508": {"epss_score": 0.11887, "epss_percentile": 0.93506}, "CVE-2024-10509": {"epss_score": 0.00085, "epss_percentile": 0.25175}, "CVE-2024-10510": {"epss_score": 0.00062, "epss_percentile": 0.19577}, "CVE-2024-10511": {"epss_score": 0.00232, "epss_percentile": 0.45885}, "CVE-2024-10513": {"epss_score": 0.00248, "epss_percentile": 0.47911}, "CVE-2024-10515": {"epss_score": 0.00104, "epss_percentile": 0.29242}, "CVE-2024-10516": {"epss_score": 0.78038, "epss_percentile": 0.98965}, "CVE-2024-10517": {"epss_score": 0.00082, "epss_percentile": 0.24452}, "CVE-2024-10518": {"epss_score": 0.00082, "epss_percentile": 0.24452}, "CVE-2024-10519": {"epss_score": 0.00797, "epss_percentile": 0.73499}, "CVE-2024-10520": {"epss_score": 0.00305, "epss_percentile": 0.53363}, "CVE-2024-10521": {"epss_score": 0.00129, "epss_percentile": 0.3315}, "CVE-2024-10522": {"epss_score": 0.00542, "epss_percentile": 0.67069}, "CVE-2024-10523": {"epss_score": 0.00043, "epss_percentile": 0.13174}, "CVE-2024-10524": {"epss_score": 0.00436, "epss_percentile": 0.62461}, "CVE-2024-10525": {"epss_score": 0.17507, "epss_percentile": 0.94858}, "CVE-2024-10526": {"epss_score": 0.00016, "epss_percentile": 0.03035}, "CVE-2024-10527": {"epss_score": 0.00099, "epss_percentile": 0.28377}, "CVE-2024-10528": {"epss_score": 0.00099, "epss_percentile": 0.28308}, "CVE-2024-10529": {"epss_score": 0.00272, "epss_percentile": 0.50349}, "CVE-2024-10530": {"epss_score": 0.00231, "epss_percentile": 0.45765}, "CVE-2024-10531": {"epss_score": 0.00221, "epss_percentile": 0.44655}, "CVE-2024-10532": {"epss_score": 0.00066, "epss_percentile": 0.20743}, "CVE-2024-10533": {"epss_score": 0.00312, "epss_percentile": 0.53964}, "CVE-2024-10534": {"epss_score": 0.00159, "epss_percentile": 0.37352}, "CVE-2024-10535": {"epss_score": 0.00417, "epss_percentile": 0.61248}, "CVE-2024-10536": {"epss_score": 0.00102, "epss_percentile": 0.2876}, "CVE-2024-10537": {"epss_score": 0.00082, "epss_percentile": 0.24491}, "CVE-2024-10538": {"epss_score": 0.0019, "epss_percentile": 0.41051}, "CVE-2024-10539": {"epss_score": 0.00071, "epss_percentile": 0.22123}, "CVE-2024-10540": {"epss_score": 0.00235, "epss_percentile": 0.46342}, "CVE-2024-10542": {"epss_score": 0.52472, "epss_percentile": 0.97828}, "CVE-2024-10543": {"epss_score": 0.00234, "epss_percentile": 0.4608}, "CVE-2024-10544": {"epss_score": 0.00206, "epss_percentile": 0.43049}, "CVE-2024-10545": {"epss_score": 0.00212, "epss_percentile": 0.43798}, "CVE-2024-10546": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-10547": {"epss_score": 0.07841, "epss_percentile": 0.91714}, "CVE-2024-10548": {"epss_score": 0.00326, "epss_percentile": 0.55073}, "CVE-2024-10549": {"epss_score": 0.00128, "epss_percentile": 0.33002}, "CVE-2024-10550": {"epss_score": 0.00128, "epss_percentile": 0.33002}, "CVE-2024-10551": {"epss_score": 0.00115, "epss_percentile": 0.30947}, "CVE-2024-10552": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-10553": {"epss_score": 0.03501, "epss_percentile": 0.87246}, "CVE-2024-10554": {"epss_score": 0.00059, "epss_percentile": 0.18724}, "CVE-2024-10555": {"epss_score": 0.00021, "epss_percentile": 0.04823}, "CVE-2024-10556": {"epss_score": 0.00086, "epss_percentile": 0.25365}, "CVE-2024-10557": {"epss_score": 0.00242, "epss_percentile": 0.47366}, "CVE-2024-10558": {"epss_score": 0.00074, "epss_percentile": 0.2276}, "CVE-2024-10559": {"epss_score": 0.00087, "epss_percentile": 0.25506}, "CVE-2024-10560": {"epss_score": 0.00059, "epss_percentile": 0.18724}, "CVE-2024-10561": {"epss_score": 0.00107, "epss_percentile": 0.29641}, "CVE-2024-10562": {"epss_score": 0.00243, "epss_percentile": 0.47417}, "CVE-2024-10563": {"epss_score": 0.00083, "epss_percentile": 0.24795}, "CVE-2024-10565": {"epss_score": 0.00064, "epss_percentile": 0.20387}, "CVE-2024-10566": {"epss_score": 0.00064, "epss_percentile": 0.20387}, "CVE-2024-10567": {"epss_score": 0.00333, "epss_percentile": 0.55657}, "CVE-2024-10568": {"epss_score": 0.00023, "epss_percentile": 0.05603}, "CVE-2024-10569": {"epss_score": 0.00143, "epss_percentile": 0.35144}, "CVE-2024-10570": {"epss_score": 0.00062, "epss_percentile": 0.19703}, "CVE-2024-10571": {"epss_score": 0.85464, "epss_percentile": 0.99334}, "CVE-2024-10572": {"epss_score": 0.00107, "epss_percentile": 0.29665}, "CVE-2024-10573": {"epss_score": 0.00051, "epss_percentile": 0.16165}, "CVE-2024-10574": {"epss_score": 0.00363, "epss_percentile": 0.57863}, "CVE-2024-10575": {"epss_score": 0.00386, "epss_percentile": 0.59275}, "CVE-2024-10576": {"epss_score": 0.00032, "epss_percentile": 0.08861}, "CVE-2024-10577": {"epss_score": 0.00712, "epss_percentile": 0.71758}, "CVE-2024-10578": {"epss_score": 0.52311, "epss_percentile": 0.97819}, "CVE-2024-10579": {"epss_score": 0.00111, "epss_percentile": 0.30354}, "CVE-2024-10580": {"epss_score": 0.0024, "epss_percentile": 0.46967}, "CVE-2024-10581": {"epss_score": 0.0004, "epss_percentile": 0.11873}, "CVE-2024-10582": {"epss_score": 0.001, "epss_percentile": 0.28489}, "CVE-2024-10583": {"epss_score": 0.00025, "epss_percentile": 0.06311}, "CVE-2024-10584": {"epss_score": 0.00049, "epss_percentile": 0.15325}, "CVE-2024-10585": {"epss_score": 0.01091, "epss_percentile": 0.77461}, "CVE-2024-10586": {"epss_score": 0.51527, "epss_percentile": 0.97784}, "CVE-2024-10587": {"epss_score": 0.0172, "epss_percentile": 0.81931}, "CVE-2024-10588": {"epss_score": 0.00378, "epss_percentile": 0.58832}, "CVE-2024-10589": {"epss_score": 0.00265, "epss_percentile": 0.49772}, "CVE-2024-10590": {"epss_score": 0.02906, "epss_percentile": 0.85962}, "CVE-2024-10591": {"epss_score": 0.00176, "epss_percentile": 0.39416}, "CVE-2024-10592": {"epss_score": 0.35017, "epss_percentile": 0.96883}, "CVE-2024-10593": {"epss_score": 0.00164, "epss_percentile": 0.37989}, "CVE-2024-10594": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10595": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-10596": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10597": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-10598": {"epss_score": 0.00121, "epss_percentile": 0.31815}, "CVE-2024-10599": {"epss_score": 0.00101, "epss_percentile": 0.28676}, "CVE-2024-10600": {"epss_score": 0.57572, "epss_percentile": 0.98071}, "CVE-2024-10601": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10602": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10603": {"epss_score": 0.0009, "epss_percentile": 0.26095}, "CVE-2024-10604": {"epss_score": 0.00101, "epss_percentile": 0.28682}, "CVE-2024-10605": {"epss_score": 0.00145, "epss_percentile": 0.35437}, "CVE-2024-10606": {"epss_score": 0.00065, "epss_percentile": 0.20522}, "CVE-2024-10607": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-10608": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-10609": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10610": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-10611": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10612": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10613": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10614": {"epss_score": 0.00241, "epss_percentile": 0.47327}, "CVE-2024-10615": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10616": {"epss_score": 0.00084, "epss_percentile": 0.24959}, "CVE-2024-10617": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10618": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10619": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10620": {"epss_score": 0.0014, "epss_percentile": 0.34735}, "CVE-2024-10621": {"epss_score": 0.00079, "epss_percentile": 0.23805}, "CVE-2024-10623": {"epss_score": 0.00364, "epss_percentile": 0.57955}, "CVE-2024-10624": {"epss_score": 0.00556, "epss_percentile": 0.67532}, "CVE-2024-10625": {"epss_score": 0.40624, "epss_percentile": 0.97227}, "CVE-2024-10626": {"epss_score": 0.24483, "epss_percentile": 0.95925}, "CVE-2024-10627": {"epss_score": 0.08746, "epss_percentile": 0.92239}, "CVE-2024-10628": {"epss_score": 0.00434, "epss_percentile": 0.6231}, "CVE-2024-10629": {"epss_score": 0.5272, "epss_percentile": 0.97837}, "CVE-2024-10630": {"epss_score": 0.00111, "epss_percentile": 0.30395}, "CVE-2024-10631": {"epss_score": 0.00032, "epss_percentile": 0.08855}, "CVE-2024-10632": {"epss_score": 0.00026, "epss_percentile": 0.06556}, "CVE-2024-10633": {"epss_score": 0.01693, "epss_percentile": 0.81794}, "CVE-2024-10634": {"epss_score": 0.00015, "epss_percentile": 0.02301}, "CVE-2024-10635": {"epss_score": 0.00037, "epss_percentile": 0.10981}, "CVE-2024-10636": {"epss_score": 0.00676, "epss_percentile": 0.70919}, "CVE-2024-10637": {"epss_score": 0.00053, "epss_percentile": 0.16821}, "CVE-2024-10638": {"epss_score": 0.00079, "epss_percentile": 0.23985}, "CVE-2024-10639": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-10640": {"epss_score": 0.00471, "epss_percentile": 0.63995}, "CVE-2024-10644": {"epss_score": 0.24656, "epss_percentile": 0.95943}, "CVE-2024-10645": {"epss_score": 0.00453, "epss_percentile": 0.63221}, "CVE-2024-10646": {"epss_score": 0.00843, "epss_percentile": 0.74266}, "CVE-2024-10647": {"epss_score": 0.0122, "epss_percentile": 0.78618}, "CVE-2024-10648": {"epss_score": 0.00221, "epss_percentile": 0.44677}, "CVE-2024-10649": {"epss_score": 0.0009, "epss_percentile": 0.26077}, "CVE-2024-10650": {"epss_score": 0.00227, "epss_percentile": 0.45435}, "CVE-2024-10651": {"epss_score": 0.00092, "epss_percentile": 0.26485}, "CVE-2024-10652": {"epss_score": 0.0016, "epss_percentile": 0.37462}, "CVE-2024-10653": {"epss_score": 0.00425, "epss_percentile": 0.61687}, "CVE-2024-10654": {"epss_score": 0.01709, "epss_percentile": 0.81869}, "CVE-2024-10655": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10656": {"epss_score": 0.00103, "epss_percentile": 0.29069}, "CVE-2024-10657": {"epss_score": 0.00114, "epss_percentile": 0.30823}, "CVE-2024-10658": {"epss_score": 0.00114, "epss_percentile": 0.30823}, "CVE-2024-10659": {"epss_score": 0.00134, "epss_percentile": 0.33755}, "CVE-2024-10660": {"epss_score": 0.49048, "epss_percentile": 0.97664}, "CVE-2024-10661": {"epss_score": 0.00611, "epss_percentile": 0.6918}, "CVE-2024-10662": {"epss_score": 0.00611, "epss_percentile": 0.6918}, "CVE-2024-10663": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-10664": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-10665": {"epss_score": 0.00113, "epss_percentile": 0.30673}, "CVE-2024-10666": {"epss_score": 0.00174, "epss_percentile": 0.39158}, "CVE-2024-10667": {"epss_score": 0.00234, "epss_percentile": 0.4608}, "CVE-2024-10668": {"epss_score": 0.00016, "epss_percentile": 0.02655}, "CVE-2024-10669": {"epss_score": 0.00234, "epss_percentile": 0.4608}, "CVE-2024-10670": {"epss_score": 0.00107, "epss_percentile": 0.29724}, "CVE-2024-10671": {"epss_score": 0.00288, "epss_percentile": 0.51946}, "CVE-2024-10672": {"epss_score": 0.00252, "epss_percentile": 0.48336}, "CVE-2024-10673": {"epss_score": 0.47192, "epss_percentile": 0.97574}, "CVE-2024-10674": {"epss_score": 0.3653, "epss_percentile": 0.96984}, "CVE-2024-10675": {"epss_score": 0.00417, "epss_percentile": 0.61247}, "CVE-2024-10676": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-10677": {"epss_score": 0.00017, "epss_percentile": 0.0342}, "CVE-2024-10678": {"epss_score": 0.0011, "epss_percentile": 0.30195}, "CVE-2024-10679": {"epss_score": 0.00064, "epss_percentile": 0.20387}, "CVE-2024-10680": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2024-10681": {"epss_score": 0.00294, "epss_percentile": 0.52394}, "CVE-2024-10682": {"epss_score": 0.00781, "epss_percentile": 0.73184}, "CVE-2024-10683": {"epss_score": 0.01453, "epss_percentile": 0.80375}, "CVE-2024-10684": {"epss_score": 0.02391, "epss_percentile": 0.84602}, "CVE-2024-10685": {"epss_score": 0.00731, "epss_percentile": 0.72174}, "CVE-2024-10687": {"epss_score": 0.0053, "epss_percentile": 0.6664}, "CVE-2024-10688": {"epss_score": 0.00234, "epss_percentile": 0.4608}, "CVE-2024-10689": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-10690": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-10692": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-10693": {"epss_score": 0.00234, "epss_percentile": 0.4608}, "CVE-2024-10695": {"epss_score": 0.00151, "epss_percentile": 0.3636}, "CVE-2024-10696": {"epss_score": 0.00082, "epss_percentile": 0.24491}, "CVE-2024-10697": {"epss_score": 0.6988, "epss_percentile": 0.98607}, "CVE-2024-10698": {"epss_score": 0.01411, "epss_percentile": 0.80107}, "CVE-2024-10699": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-10700": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10701": {"epss_score": 0.00187, "epss_percentile": 0.40738}, "CVE-2024-10702": {"epss_score": 0.00078, "epss_percentile": 0.2363}, "CVE-2024-10703": {"epss_score": 0.00062, "epss_percentile": 0.19665}, "CVE-2024-10704": {"epss_score": 0.00062, "epss_percentile": 0.19577}, "CVE-2024-10705": {"epss_score": 0.00053, "epss_percentile": 0.16742}, "CVE-2024-10706": {"epss_score": 0.00072, "epss_percentile": 0.22462}, "CVE-2024-10707": {"epss_score": 0.00083, "epss_percentile": 0.24598}, "CVE-2024-10708": {"epss_score": 0.02455, "epss_percentile": 0.84795}, "CVE-2024-10709": {"epss_score": 0.00262, "epss_percentile": 0.4934}, "CVE-2024-10710": {"epss_score": 0.00091, "epss_percentile": 0.26206}, "CVE-2024-10711": {"epss_score": 0.00229, "epss_percentile": 0.45587}, "CVE-2024-10713": {"epss_score": 0.00125, "epss_percentile": 0.32557}, "CVE-2024-10714": {"epss_score": 0.00205, "epss_percentile": 0.42764}, "CVE-2024-10715": {"epss_score": 0.00243, "epss_percentile": 0.47484}, "CVE-2024-10716": {"epss_score": 0.0008, "epss_percentile": 0.24136}, "CVE-2024-10717": {"epss_score": 0.00158, "epss_percentile": 0.37296}, "CVE-2024-10718": {"epss_score": 0.00049, "epss_percentile": 0.15442}, "CVE-2024-10719": {"epss_score": 0.00056, "epss_percentile": 0.17951}, "CVE-2024-10720": {"epss_score": 0.00071, "epss_percentile": 0.22104}, "CVE-2024-10721": {"epss_score": 0.00073, "epss_percentile": 0.22671}, "CVE-2024-10722": {"epss_score": 0.00062, "epss_percentile": 0.19583}, "CVE-2024-10723": {"epss_score": 0.00073, "epss_percentile": 0.22671}, "CVE-2024-10724": {"epss_score": 0.00062, "epss_percentile": 0.19583}, "CVE-2024-10725": {"epss_score": 0.00062, "epss_percentile": 0.19583}, "CVE-2024-10726": {"epss_score": 0.00195, "epss_percentile": 0.41708}, "CVE-2024-10727": {"epss_score": 0.00062, "epss_percentile": 0.19583}, "CVE-2024-10728": {"epss_score": 0.76069, "epss_percentile": 0.98876}, "CVE-2024-10729": {"epss_score": 0.00269, "epss_percentile": 0.50182}, "CVE-2024-10730": {"epss_score": 0.0018, "epss_percentile": 0.39884}, "CVE-2024-10731": {"epss_score": 0.0018, "epss_percentile": 0.39884}, "CVE-2024-10732": {"epss_score": 0.00165, "epss_percentile": 0.38114}, "CVE-2024-10733": {"epss_score": 0.0007, "epss_percentile": 0.21865}, "CVE-2024-10734": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-10735": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-10736": {"epss_score": 0.0007, "epss_percentile": 0.21865}, "CVE-2024-10737": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-10738": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-10739": {"epss_score": 0.0007, "epss_percentile": 0.21865}, "CVE-2024-10740": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-10741": {"epss_score": 0.00131, "epss_percentile": 0.33406}, "CVE-2024-10742": {"epss_score": 0.00115, "epss_percentile": 0.31001}, "CVE-2024-10743": {"epss_score": 0.00183, "epss_percentile": 0.40304}, "CVE-2024-10744": {"epss_score": 0.00199, "epss_percentile": 0.42135}, "CVE-2024-10745": {"epss_score": 0.00199, "epss_percentile": 0.42135}, "CVE-2024-10746": {"epss_score": 0.00183, "epss_percentile": 0.40304}, "CVE-2024-10747": {"epss_score": 0.00183, "epss_percentile": 0.40304}, "CVE-2024-10748": {"epss_score": 0.00078, "epss_percentile": 0.23753}, "CVE-2024-10749": {"epss_score": 0.00189, "epss_percentile": 0.40948}, "CVE-2024-10750": {"epss_score": 0.00225, "epss_percentile": 0.4523}, "CVE-2024-10751": {"epss_score": 0.00098, "epss_percentile": 0.27797}, "CVE-2024-10752": {"epss_score": 0.00131, "epss_percentile": 0.33406}, "CVE-2024-10753": {"epss_score": 0.00131, "epss_percentile": 0.33487}, "CVE-2024-10754": {"epss_score": 0.0018, "epss_percentile": 0.39929}, "CVE-2024-10755": {"epss_score": 0.0018, "epss_percentile": 0.39929}, "CVE-2024-10756": {"epss_score": 0.00236, "epss_percentile": 0.46369}, "CVE-2024-10757": {"epss_score": 0.0018, "epss_percentile": 0.39929}, "CVE-2024-10758": {"epss_score": 0.00097, "epss_percentile": 0.27485}, "CVE-2024-10759": {"epss_score": 0.00134, "epss_percentile": 0.33755}, "CVE-2024-10760": {"epss_score": 0.00117, "epss_percentile": 0.31368}, "CVE-2024-10761": {"epss_score": 0.00272, "epss_percentile": 0.50348}, "CVE-2024-10762": {"epss_score": 0.00081, "epss_percentile": 0.24207}, "CVE-2024-10763": {"epss_score": 0.0058, "epss_percentile": 0.68241}, "CVE-2024-10764": {"epss_score": 0.00154, "epss_percentile": 0.36672}, "CVE-2024-10765": {"epss_score": 0.00154, "epss_percentile": 0.36672}, "CVE-2024-10766": {"epss_score": 0.00167, "epss_percentile": 0.38382}, "CVE-2024-10768": {"epss_score": 0.00143, "epss_percentile": 0.35172}, "CVE-2024-10770": {"epss_score": 0.00234, "epss_percentile": 0.4608}, "CVE-2024-10771": {"epss_score": 0.01618, "epss_percentile": 0.81369}, "CVE-2024-10772": {"epss_score": 0.00168, "epss_percentile": 0.38505}, "CVE-2024-10773": {"epss_score": 0.00369, "epss_percentile": 0.58271}, "CVE-2024-10774": {"epss_score": 0.00315, "epss_percentile": 0.54187}, "CVE-2024-10775": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-10776": {"epss_score": 0.00452, "epss_percentile": 0.63183}, "CVE-2024-10777": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-10778": {"epss_score": 0.0015, "epss_percentile": 0.36058}, "CVE-2024-10779": {"epss_score": 0.0026, "epss_percentile": 0.49197}, "CVE-2024-10780": {"epss_score": 0.00082, "epss_percentile": 0.24491}, "CVE-2024-10781": {"epss_score": 0.05416, "epss_percentile": 0.8985}, "CVE-2024-10782": {"epss_score": 0.0013, "epss_percentile": 0.33285}, "CVE-2024-10783": {"epss_score": 0.23135, "epss_percentile": 0.95738}, "CVE-2024-10784": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-10785": {"epss_score": 0.00108, "epss_percentile": 0.29814}, "CVE-2024-10786": {"epss_score": 0.00268, "epss_percentile": 0.50037}, "CVE-2024-10787": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-10788": {"epss_score": 0.0125, "epss_percentile": 0.7888}, "CVE-2024-10789": {"epss_score": 0.00033, "epss_percentile": 0.09328}, "CVE-2024-10790": {"epss_score": 0.0022, "epss_percentile": 0.44619}, "CVE-2024-10791": {"epss_score": 0.00076, "epss_percentile": 0.2327}, "CVE-2024-10792": {"epss_score": 0.00833, "epss_percentile": 0.74086}, "CVE-2024-10793": {"epss_score": 0.42907, "epss_percentile": 0.97361}, "CVE-2024-10794": {"epss_score": 0.00252, "epss_percentile": 0.484}, "CVE-2024-10795": {"epss_score": 0.00234, "epss_percentile": 0.4608}, "CVE-2024-10796": {"epss_score": 0.00097, "epss_percentile": 0.27463}, "CVE-2024-10797": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-10798": {"epss_score": 0.00062, "epss_percentile": 0.197}, "CVE-2024-10799": {"epss_score": 0.01547, "epss_percentile": 0.80974}, "CVE-2024-10800": {"epss_score": 0.00237, "epss_percentile": 0.46663}, "CVE-2024-10801": {"epss_score": 0.10241, "epss_percentile": 0.92907}, "CVE-2024-10802": {"epss_score": 0.01287, "epss_percentile": 0.79195}, "CVE-2024-10803": {"epss_score": 0.03049, "epss_percentile": 0.86287}, "CVE-2024-10804": {"epss_score": 0.0255, "epss_percentile": 0.85075}, "CVE-2024-10805": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10806": {"epss_score": 0.00113, "epss_percentile": 0.30651}, "CVE-2024-10807": {"epss_score": 0.00113, "epss_percentile": 0.30651}, "CVE-2024-10808": {"epss_score": 0.00036, "epss_percentile": 0.10281}, "CVE-2024-10809": {"epss_score": 0.00036, "epss_percentile": 0.10281}, "CVE-2024-10810": {"epss_score": 0.00035, "epss_percentile": 0.10113}, "CVE-2024-10811": {"epss_score": 0.1564, "epss_percentile": 0.94474}, "CVE-2024-10812": {"epss_score": 0.00314, "epss_percentile": 0.54134}, "CVE-2024-10813": {"epss_score": 0.00542, "epss_percentile": 0.67067}, "CVE-2024-10814": {"epss_score": 0.00265, "epss_percentile": 0.49802}, "CVE-2024-10815": {"epss_score": 0.00077, "epss_percentile": 0.23294}, "CVE-2024-10816": {"epss_score": 0.07801, "epss_percentile": 0.91688}, "CVE-2024-10818": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2024-10819": {"epss_score": 0.00074, "epss_percentile": 0.22882}, "CVE-2024-10820": {"epss_score": 0.16669, "epss_percentile": 0.9471}, "CVE-2024-10821": {"epss_score": 0.00063, "epss_percentile": 0.19805}, "CVE-2024-10824": {"epss_score": 0.00038, "epss_percentile": 0.11305}, "CVE-2024-10825": {"epss_score": 0.01889, "epss_percentile": 0.82724}, "CVE-2024-10826": {"epss_score": 0.0035, "epss_percentile": 0.56955}, "CVE-2024-10827": {"epss_score": 0.00911, "epss_percentile": 0.75324}, "CVE-2024-10828": {"epss_score": 0.25905, "epss_percentile": 0.96092}, "CVE-2024-10829": {"epss_score": 0.00237, "epss_percentile": 0.46664}, "CVE-2024-10830": {"epss_score": 0.00202, "epss_percentile": 0.42439}, "CVE-2024-10831": {"epss_score": 0.00202, "epss_percentile": 0.42439}, "CVE-2024-10832": {"epss_score": 0.0006, "epss_percentile": 0.19065}, "CVE-2024-10833": {"epss_score": 0.00202, "epss_percentile": 0.42439}, "CVE-2024-10834": {"epss_score": 0.001, "epss_percentile": 0.28462}, "CVE-2024-10835": {"epss_score": 0.00903, "epss_percentile": 0.75209}, "CVE-2024-10836": {"epss_score": 0.00986, "epss_percentile": 0.76335}, "CVE-2024-10837": {"epss_score": 0.01453, "epss_percentile": 0.80375}, "CVE-2024-10838": {"epss_score": 0.01078, "epss_percentile": 0.77344}, "CVE-2024-10839": {"epss_score": 0.00086, "epss_percentile": 0.25383}, "CVE-2024-10840": {"epss_score": 0.00162, "epss_percentile": 0.37624}, "CVE-2024-10841": {"epss_score": 0.00143, "epss_percentile": 0.351}, "CVE-2024-10842": {"epss_score": 0.00234, "epss_percentile": 0.46118}, "CVE-2024-10844": {"epss_score": 0.00098, "epss_percentile": 0.27786}, "CVE-2024-10845": {"epss_score": 0.00098, "epss_percentile": 0.27786}, "CVE-2024-10846": {"epss_score": 0.00031, "epss_percentile": 0.08333}, "CVE-2024-10847": {"epss_score": 0.00067, "epss_percentile": 0.21074}, "CVE-2024-10848": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-10849": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-10850": {"epss_score": 0.00712, "epss_percentile": 0.71758}, "CVE-2024-10851": {"epss_score": 0.00919, "epss_percentile": 0.75462}, "CVE-2024-10852": {"epss_score": 0.00149, "epss_percentile": 0.35979}, "CVE-2024-10853": {"epss_score": 0.00117, "epss_percentile": 0.31214}, "CVE-2024-10854": {"epss_score": 0.00184, "epss_percentile": 0.40408}, "CVE-2024-10855": {"epss_score": 0.00189, "epss_percentile": 0.40942}, "CVE-2024-10856": {"epss_score": 0.00083, "epss_percentile": 0.24626}, "CVE-2024-10857": {"epss_score": 0.01852, "epss_percentile": 0.82543}, "CVE-2024-10858": {"epss_score": 0.00077, "epss_percentile": 0.23294}, "CVE-2024-10860": {"epss_score": 0.00117, "epss_percentile": 0.31267}, "CVE-2024-10861": {"epss_score": 0.00393, "epss_percentile": 0.59721}, "CVE-2024-10862": {"epss_score": 0.0036, "epss_percentile": 0.57656}, "CVE-2024-10863": {"epss_score": 0.00109, "epss_percentile": 0.29946}, "CVE-2024-10864": {"epss_score": 0.00052, "epss_percentile": 0.16451}, "CVE-2024-10865": {"epss_score": 0.00052, "epss_percentile": 0.1646}, "CVE-2024-10866": {"epss_score": 0.004, "epss_percentile": 0.60187}, "CVE-2024-10867": {"epss_score": 0.0005, "epss_percentile": 0.15727}, "CVE-2024-10868": {"epss_score": 0.00126, "epss_percentile": 0.32776}, "CVE-2024-10869": {"epss_score": 0.00793, "epss_percentile": 0.7343}, "CVE-2024-10871": {"epss_score": 0.01768, "epss_percentile": 0.8218}, "CVE-2024-10872": {"epss_score": 0.0022, "epss_percentile": 0.44619}, "CVE-2024-10873": {"epss_score": 0.00169, "epss_percentile": 0.38567}, "CVE-2024-10874": {"epss_score": 0.00079, "epss_percentile": 0.23805}, "CVE-2024-10875": {"epss_score": 0.01179, "epss_percentile": 0.78289}, "CVE-2024-10876": {"epss_score": 0.01453, "epss_percentile": 0.80375}, "CVE-2024-10877": {"epss_score": 0.00924, "epss_percentile": 0.75514}, "CVE-2024-10878": {"epss_score": 0.00793, "epss_percentile": 0.7343}, "CVE-2024-10879": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-10880": {"epss_score": 0.00793, "epss_percentile": 0.7343}, "CVE-2024-10881": {"epss_score": 0.00116, "epss_percentile": 0.31132}, "CVE-2024-10882": {"epss_score": 0.03279, "epss_percentile": 0.86809}, "CVE-2024-10883": {"epss_score": 0.01179, "epss_percentile": 0.78289}, "CVE-2024-10884": {"epss_score": 0.01179, "epss_percentile": 0.78289}, "CVE-2024-10885": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-10886": {"epss_score": 0.00079, "epss_percentile": 0.23805}, "CVE-2024-10887": {"epss_score": 0.00185, "epss_percentile": 0.40521}, "CVE-2024-10890": {"epss_score": 0.00924, "epss_percentile": 0.75514}, "CVE-2024-10891": {"epss_score": 0.00145, "epss_percentile": 0.35418}, "CVE-2024-10892": {"epss_score": 0.00042, "epss_percentile": 0.12497}, "CVE-2024-10893": {"epss_score": 0.00079, "epss_percentile": 0.23944}, "CVE-2024-10894": {"epss_score": 0.00074, "epss_percentile": 0.22762}, "CVE-2024-10895": {"epss_score": 0.0019, "epss_percentile": 0.41051}, "CVE-2024-10896": {"epss_score": 0.00112, "epss_percentile": 0.30518}, "CVE-2024-10897": {"epss_score": 0.00205, "epss_percentile": 0.42683}, "CVE-2024-10898": {"epss_score": 0.00201, "epss_percentile": 0.42303}, "CVE-2024-10899": {"epss_score": 0.00733, "epss_percentile": 0.72218}, "CVE-2024-10900": {"epss_score": 0.00185, "epss_percentile": 0.40528}, "CVE-2024-10901": {"epss_score": 0.00881, "epss_percentile": 0.74879}, "CVE-2024-10902": {"epss_score": 0.03092, "epss_percentile": 0.86398}, "CVE-2024-10903": {"epss_score": 0.00137, "epss_percentile": 0.34283}, "CVE-2024-10904": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-10905": {"epss_score": 0.00666, "epss_percentile": 0.70674}, "CVE-2024-10906": {"epss_score": 0.00037, "epss_percentile": 0.10774}, "CVE-2024-10907": {"epss_score": 0.00086, "epss_percentile": 0.25389}, "CVE-2024-10908": {"epss_score": 0.00638, "epss_percentile": 0.69913}, "CVE-2024-10909": {"epss_score": 0.00353, "epss_percentile": 0.57172}, "CVE-2024-10910": {"epss_score": 0.02452, "epss_percentile": 0.84791}, "CVE-2024-10912": {"epss_score": 0.00243, "epss_percentile": 0.4743}, "CVE-2024-10913": {"epss_score": 0.02273, "epss_percentile": 0.8422}, "CVE-2024-10914": {"epss_score": 0.93814, "epss_percentile": 0.9985}, "CVE-2024-10915": {"epss_score": 0.94059, "epss_percentile": 0.99895}, "CVE-2024-10916": {"epss_score": 0.01655, "epss_percentile": 0.8159}, "CVE-2024-10917": {"epss_score": 0.00303, "epss_percentile": 0.53206}, "CVE-2024-10918": {"epss_score": 0.0021, "epss_percentile": 0.435}, "CVE-2024-10919": {"epss_score": 0.05423, "epss_percentile": 0.89864}, "CVE-2024-10920": {"epss_score": 0.00185, "epss_percentile": 0.40482}, "CVE-2024-10921": {"epss_score": 0.00559, "epss_percentile": 0.67606}, "CVE-2024-10923": {"epss_score": 0.00384, "epss_percentile": 0.59132}, "CVE-2024-10924": {"epss_score": 0.93799, "epss_percentile": 0.99848}, "CVE-2024-10925": {"epss_score": 0.0003, "epss_percentile": 0.08216}, "CVE-2024-10926": {"epss_score": 0.00279, "epss_percentile": 0.50936}, "CVE-2024-10927": {"epss_score": 0.00252, "epss_percentile": 0.48371}, "CVE-2024-10928": {"epss_score": 0.00193, "epss_percentile": 0.4139}, "CVE-2024-10929": {"epss_score": 0.00038, "epss_percentile": 0.11331}, "CVE-2024-10930": {"epss_score": 0.00264, "epss_percentile": 0.49679}, "CVE-2024-10932": {"epss_score": 0.04531, "epss_percentile": 0.88812}, "CVE-2024-10933": {"epss_score": 0.00049, "epss_percentile": 0.15321}, "CVE-2024-10934": {"epss_score": 0.00269, "epss_percentile": 0.50126}, "CVE-2024-10935": {"epss_score": 0.00142, "epss_percentile": 0.35006}, "CVE-2024-10936": {"epss_score": 0.29146, "epss_percentile": 0.96421}, "CVE-2024-10937": {"epss_score": 0.00336, "epss_percentile": 0.55919}, "CVE-2024-10939": {"epss_score": 0.00021, "epss_percentile": 0.04823}, "CVE-2024-10940": {"epss_score": 0.00082, "epss_percentile": 0.24472}, "CVE-2024-10941": {"epss_score": 0.00179, "epss_percentile": 0.3983}, "CVE-2024-10942": {"epss_score": 0.01039, "epss_percentile": 0.76945}, "CVE-2024-10943": {"epss_score": 0.00068, "epss_percentile": 0.21227}, "CVE-2024-10944": {"epss_score": 0.00081, "epss_percentile": 0.24386}, "CVE-2024-10945": {"epss_score": 0.00048, "epss_percentile": 0.15222}, "CVE-2024-10946": {"epss_score": 0.00059, "epss_percentile": 0.18675}, "CVE-2024-10947": {"epss_score": 0.00093, "epss_percentile": 0.26672}, "CVE-2024-10948": {"epss_score": 0.00078, "epss_percentile": 0.2379}, "CVE-2024-10950": {"epss_score": 0.01041, "epss_percentile": 0.76966}, "CVE-2024-10952": {"epss_score": 0.02511, "epss_percentile": 0.84953}, "CVE-2024-10953": {"epss_score": 0.00236, "epss_percentile": 0.46375}, "CVE-2024-10954": {"epss_score": 0.01051, "epss_percentile": 0.77078}, "CVE-2024-10955": {"epss_score": 0.00106, "epss_percentile": 0.29475}, "CVE-2024-10956": {"epss_score": 0.00032, "epss_percentile": 0.08963}, "CVE-2024-10957": {"epss_score": 0.03309, "epss_percentile": 0.86884}, "CVE-2024-10958": {"epss_score": 0.49272, "epss_percentile": 0.97677}, "CVE-2024-10959": {"epss_score": 0.02511, "epss_percentile": 0.84953}, "CVE-2024-10960": {"epss_score": 0.00838, "epss_percentile": 0.74178}, "CVE-2024-10961": {"epss_score": 0.01939, "epss_percentile": 0.82975}, "CVE-2024-10962": {"epss_score": 0.0435, "epss_percentile": 0.88584}, "CVE-2024-10963": {"epss_score": 0.00303, "epss_percentile": 0.53212}, "CVE-2024-10964": {"epss_score": 0.0019, "epss_percentile": 0.41098}, "CVE-2024-10965": {"epss_score": 0.00144, "epss_percentile": 0.35263}, "CVE-2024-10966": {"epss_score": 0.01314, "epss_percentile": 0.79387}, "CVE-2024-10967": {"epss_score": 0.00037, "epss_percentile": 0.10656}, "CVE-2024-10968": {"epss_score": 0.00097, "epss_percentile": 0.27594}, "CVE-2024-10969": {"epss_score": 0.00041, "epss_percentile": 0.12357}, "CVE-2024-10970": {"epss_score": 0.00251, "epss_percentile": 0.48308}, "CVE-2024-10971": {"epss_score": 0.00306, "epss_percentile": 0.53399}, "CVE-2024-10972": {"epss_score": 0.00022, "epss_percentile": 0.05151}, "CVE-2024-10973": {"epss_score": 0.00058, "epss_percentile": 0.18413}, "CVE-2024-10975": {"epss_score": 0.00227, "epss_percentile": 0.45372}, "CVE-2024-10976": {"epss_score": 0.01099, "epss_percentile": 0.7755}, "CVE-2024-10977": {"epss_score": 0.00375, "epss_percentile": 0.58599}, "CVE-2024-10978": {"epss_score": 0.00613, "epss_percentile": 0.69252}, "CVE-2024-10979": {"epss_score": 0.07031, "epss_percentile": 0.91198}, "CVE-2024-10980": {"epss_score": 0.00079, "epss_percentile": 0.23865}, "CVE-2024-10986": {"epss_score": 0.00149, "epss_percentile": 0.35935}, "CVE-2024-10987": {"epss_score": 0.00063, "epss_percentile": 0.19935}, "CVE-2024-10988": {"epss_score": 0.00068, "epss_percentile": 0.21419}, "CVE-2024-10989": {"epss_score": 0.00063, "epss_percentile": 0.19935}, "CVE-2024-10990": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10991": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-10993": {"epss_score": 0.0005, "epss_percentile": 0.15743}, "CVE-2024-10994": {"epss_score": 0.00042, "epss_percentile": 0.12928}, "CVE-2024-10995": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-10996": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-10997": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-10998": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-10999": {"epss_score": 0.00061, "epss_percentile": 0.19499}, "CVE-2024-11000": {"epss_score": 0.00061, "epss_percentile": 0.19499}, "CVE-2024-11002": {"epss_score": 0.00204, "epss_percentile": 0.42658}, "CVE-2024-11003": {"epss_score": 0.13464, "epss_percentile": 0.93972}, "CVE-2024-11004": {"epss_score": 0.00382, "epss_percentile": 0.59072}, "CVE-2024-11005": {"epss_score": 0.18664, "epss_percentile": 0.95049}, "CVE-2024-11006": {"epss_score": 0.18664, "epss_percentile": 0.95049}, "CVE-2024-11007": {"epss_score": 0.18664, "epss_percentile": 0.95049}, "CVE-2024-11008": {"epss_score": 0.00328, "epss_percentile": 0.55284}, "CVE-2024-11009": {"epss_score": 0.0037, "epss_percentile": 0.58314}, "CVE-2024-11010": {"epss_score": 0.02134, "epss_percentile": 0.83724}, "CVE-2024-11012": {"epss_score": 0.00353, "epss_percentile": 0.57172}, "CVE-2024-11013": {"epss_score": 0.00057, "epss_percentile": 0.18176}, "CVE-2024-11014": {"epss_score": 0.00033, "epss_percentile": 0.09185}, "CVE-2024-11015": {"epss_score": 0.01292, "epss_percentile": 0.79233}, "CVE-2024-11016": {"epss_score": 0.00423, "epss_percentile": 0.61603}, "CVE-2024-11017": {"epss_score": 0.01524, "epss_percentile": 0.80847}, "CVE-2024-11018": {"epss_score": 0.01946, "epss_percentile": 0.83002}, "CVE-2024-11019": {"epss_score": 0.00246, "epss_percentile": 0.47794}, "CVE-2024-11020": {"epss_score": 0.00122, "epss_percentile": 0.32067}, "CVE-2024-11021": {"epss_score": 0.00104, "epss_percentile": 0.29143}, "CVE-2024-11022": {"epss_score": 0.00222, "epss_percentile": 0.44769}, "CVE-2024-11023": {"epss_score": 0.00107, "epss_percentile": 0.29677}, "CVE-2024-11024": {"epss_score": 0.00273, "epss_percentile": 0.50424}, "CVE-2024-11025": {"epss_score": 0.00062, "epss_percentile": 0.19656}, "CVE-2024-11026": {"epss_score": 0.00243, "epss_percentile": 0.47481}, "CVE-2024-11028": {"epss_score": 0.0162, "epss_percentile": 0.81384}, "CVE-2024-11029": {"epss_score": 0.00045, "epss_percentile": 0.13952}, "CVE-2024-11030": {"epss_score": 0.00054, "epss_percentile": 0.17366}, "CVE-2024-11031": {"epss_score": 0.00054, "epss_percentile": 0.17366}, "CVE-2024-11032": {"epss_score": 0.00519, "epss_percentile": 0.66174}, "CVE-2024-11033": {"epss_score": 0.00058, "epss_percentile": 0.18563}, "CVE-2024-11034": {"epss_score": 0.00613, "epss_percentile": 0.69257}, "CVE-2024-11035": {"epss_score": 0.00025, "epss_percentile": 0.06284}, "CVE-2024-11036": {"epss_score": 0.00929, "epss_percentile": 0.75589}, "CVE-2024-11037": {"epss_score": 0.00103, "epss_percentile": 0.29071}, "CVE-2024-11038": {"epss_score": 0.01146, "epss_percentile": 0.77996}, "CVE-2024-11039": {"epss_score": 0.00498, "epss_percentile": 0.65227}, "CVE-2024-11041": {"epss_score": 0.01184, "epss_percentile": 0.78329}, "CVE-2024-11042": {"epss_score": 0.0086, "epss_percentile": 0.74533}, "CVE-2024-11043": {"epss_score": 0.00109, "epss_percentile": 0.29953}, "CVE-2024-11044": {"epss_score": 0.004, "epss_percentile": 0.60158}, "CVE-2024-11045": {"epss_score": 0.00079, "epss_percentile": 0.23963}, "CVE-2024-11046": {"epss_score": 0.00776, "epss_percentile": 0.731}, "CVE-2024-11047": {"epss_score": 0.00187, "epss_percentile": 0.40766}, "CVE-2024-11048": {"epss_score": 0.00187, "epss_percentile": 0.40766}, "CVE-2024-11049": {"epss_score": 0.00118, "epss_percentile": 0.31393}, "CVE-2024-11050": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-11051": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-11052": {"epss_score": 0.01119, "epss_percentile": 0.77757}, "CVE-2024-11053": {"epss_score": 0.00337, "epss_percentile": 0.56042}, "CVE-2024-11054": {"epss_score": 0.00082, "epss_percentile": 0.24588}, "CVE-2024-11055": {"epss_score": 0.00097, "epss_percentile": 0.27594}, "CVE-2024-11056": {"epss_score": 0.00185, "epss_percentile": 0.40527}, "CVE-2024-11057": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-11058": {"epss_score": 0.00068, "epss_percentile": 0.21257}, "CVE-2024-11059": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-11060": {"epss_score": 0.00062, "epss_percentile": 0.196}, "CVE-2024-11061": {"epss_score": 0.00304, "epss_percentile": 0.53268}, "CVE-2024-11062": {"epss_score": 0.00734, "epss_percentile": 0.72243}, "CVE-2024-11063": {"epss_score": 0.00734, "epss_percentile": 0.72243}, "CVE-2024-11064": {"epss_score": 0.00734, "epss_percentile": 0.72243}, "CVE-2024-11065": {"epss_score": 0.00734, "epss_percentile": 0.72243}, "CVE-2024-11066": {"epss_score": 0.00557, "epss_percentile": 0.67546}, "CVE-2024-11067": {"epss_score": 0.00152, "epss_percentile": 0.36417}, "CVE-2024-11068": {"epss_score": 0.00878, "epss_percentile": 0.74817}, "CVE-2024-11069": {"epss_score": 0.00348, "epss_percentile": 0.56845}, "CVE-2024-11070": {"epss_score": 0.00127, "epss_percentile": 0.32798}, "CVE-2024-11071": {"epss_score": 0.00025, "epss_percentile": 0.06211}, "CVE-2024-11073": {"epss_score": 0.00209, "epss_percentile": 0.43334}, "CVE-2024-11074": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-11075": {"epss_score": 0.00088, "epss_percentile": 0.25679}, "CVE-2024-11076": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-11077": {"epss_score": 0.0007, "epss_percentile": 0.21865}, "CVE-2024-11078": {"epss_score": 0.00172, "epss_percentile": 0.3894}, "CVE-2024-11079": {"epss_score": 0.00061, "epss_percentile": 0.19512}, "CVE-2024-11082": {"epss_score": 0.08323, "epss_percentile": 0.91991}, "CVE-2024-11083": {"epss_score": 0.00439, "epss_percentile": 0.626}, "CVE-2024-11084": {"epss_score": 0.00051, "epss_percentile": 0.1616}, "CVE-2024-11085": {"epss_score": 0.00183, "epss_percentile": 0.40339}, "CVE-2024-11087": {"epss_score": 0.00347, "epss_percentile": 0.56765}, "CVE-2024-11088": {"epss_score": 0.00408, "epss_percentile": 0.60643}, "CVE-2024-11089": {"epss_score": 0.00285, "epss_percentile": 0.51658}, "CVE-2024-11090": {"epss_score": 0.00109, "epss_percentile": 0.29986}, "CVE-2024-11091": {"epss_score": 0.0013, "epss_percentile": 0.33277}, "CVE-2024-11092": {"epss_score": 0.00166, "epss_percentile": 0.38189}, "CVE-2024-11093": {"epss_score": 0.00095, "epss_percentile": 0.27098}, "CVE-2024-11094": {"epss_score": 0.00301, "epss_percentile": 0.53002}, "CVE-2024-11095": {"epss_score": 0.00055, "epss_percentile": 0.17622}, "CVE-2024-11096": {"epss_score": 0.00063, "epss_percentile": 0.19935}, "CVE-2024-11097": {"epss_score": 0.00047, "epss_percentile": 0.14909}, "CVE-2024-11098": {"epss_score": 0.00225, "epss_percentile": 0.45104}, "CVE-2024-11099": {"epss_score": 0.0007, "epss_percentile": 0.21865}, "CVE-2024-11100": {"epss_score": 0.0007, "epss_percentile": 0.21865}, "CVE-2024-11101": {"epss_score": 0.00067, "epss_percentile": 0.20965}, "CVE-2024-11102": {"epss_score": 0.00178, "epss_percentile": 0.39634}, "CVE-2024-11103": {"epss_score": 0.00115, "epss_percentile": 0.30996}, "CVE-2024-11104": {"epss_score": 0.0021, "epss_percentile": 0.4344}, "CVE-2024-11106": {"epss_score": 0.00328, "epss_percentile": 0.55284}, "CVE-2024-11107": {"epss_score": 0.00438, "epss_percentile": 0.62553}, "CVE-2024-11108": {"epss_score": 0.00069, "epss_percentile": 0.21635}, "CVE-2024-11109": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-11110": {"epss_score": 0.00044, "epss_percentile": 0.1353}, "CVE-2024-11111": {"epss_score": 0.00119, "epss_percentile": 0.31595}, "CVE-2024-11112": {"epss_score": 0.0035, "epss_percentile": 0.56948}, "CVE-2024-11113": {"epss_score": 0.0042, "epss_percentile": 0.61437}, "CVE-2024-11114": {"epss_score": 0.004, "epss_percentile": 0.60157}, "CVE-2024-11115": {"epss_score": 0.00376, "epss_percentile": 0.58642}, "CVE-2024-11116": {"epss_score": 0.00092, "epss_percentile": 0.26581}, "CVE-2024-11117": {"epss_score": 0.00032, "epss_percentile": 0.09116}, "CVE-2024-11118": {"epss_score": 0.00236, "epss_percentile": 0.46406}, "CVE-2024-11119": {"epss_score": 0.00184, "epss_percentile": 0.40413}, "CVE-2024-11120": {"epss_score": 0.66138, "epss_percentile": 0.98452}, "CVE-2024-11121": {"epss_score": 0.00098, "epss_percentile": 0.27797}, "CVE-2024-11122": {"epss_score": 0.00167, "epss_percentile": 0.38382}, "CVE-2024-11123": {"epss_score": 0.00148, "epss_percentile": 0.35925}, "CVE-2024-11124": {"epss_score": 0.00092, "epss_percentile": 0.26555}, "CVE-2024-11125": {"epss_score": 0.00257, "epss_percentile": 0.48892}, "CVE-2024-11126": {"epss_score": 0.00108, "epss_percentile": 0.29816}, "CVE-2024-11127": {"epss_score": 0.00105, "epss_percentile": 0.29306}, "CVE-2024-11128": {"epss_score": 0.00032, "epss_percentile": 0.0881}, "CVE-2024-11129": {"epss_score": 0.00017, "epss_percentile": 0.03373}, "CVE-2024-11130": {"epss_score": 0.00154, "epss_percentile": 0.36735}, "CVE-2024-11131": {"epss_score": 0.00541, "epss_percentile": 0.6704}, "CVE-2024-11132": {"epss_score": 0.00066, "epss_percentile": 0.20735}, "CVE-2024-11133": {"epss_score": 0.00455, "epss_percentile": 0.63286}, "CVE-2024-11134": {"epss_score": 0.0012, "epss_percentile": 0.31751}, "CVE-2024-11135": {"epss_score": 0.00484, "epss_percentile": 0.64662}, "CVE-2024-11136": {"epss_score": 0.00165, "epss_percentile": 0.38061}, "CVE-2024-11137": {"epss_score": 0.00076, "epss_percentile": 0.23126}, "CVE-2024-11138": {"epss_score": 0.00171, "epss_percentile": 0.38876}, "CVE-2024-11139": {"epss_score": 0.00039, "epss_percentile": 0.11595}, "CVE-2024-11140": {"epss_score": 0.00026, "epss_percentile": 0.06556}, "CVE-2024-11141": {"epss_score": 0.00018, "epss_percentile": 0.03539}, "CVE-2024-11142": {"epss_score": 0.0002, "epss_percentile": 0.04524}, "CVE-2024-11143": {"epss_score": 0.00094, "epss_percentile": 0.27066}, "CVE-2024-11144": {"epss_score": 0.00313, "epss_percentile": 0.54017}, "CVE-2024-11145": {"epss_score": 0.03532, "epss_percentile": 0.87304}, "CVE-2024-11146": {"epss_score": 0.00117, "epss_percentile": 0.31243}, "CVE-2024-11147": {"epss_score": 0.0012, "epss_percentile": 0.31808}, "CVE-2024-11148": {"epss_score": 0.00229, "epss_percentile": 0.4557}, "CVE-2024-11149": {"epss_score": 0.00036, "epss_percentile": 0.10296}, "CVE-2024-11150": {"epss_score": 0.175, "epss_percentile": 0.94857}, "CVE-2024-11153": {"epss_score": 0.00212, "epss_percentile": 0.43824}, "CVE-2024-11154": {"epss_score": 0.00176, "epss_percentile": 0.39439}, "CVE-2024-11155": {"epss_score": 0.00032, "epss_percentile": 0.08969}, "CVE-2024-11156": {"epss_score": 0.00027, "epss_percentile": 0.06847}, "CVE-2024-11157": {"epss_score": 0.00016, "epss_percentile": 0.02636}, "CVE-2024-11158": {"epss_score": 0.0003, "epss_percentile": 0.08211}, "CVE-2024-11159": {"epss_score": 0.00068, "epss_percentile": 0.21421}, "CVE-2024-11165": {"epss_score": 0.00071, "epss_percentile": 0.22142}, "CVE-2024-11166": {"epss_score": 0.00054, "epss_percentile": 0.17308}, "CVE-2024-11167": {"epss_score": 0.00085, "epss_percentile": 0.2523}, "CVE-2024-11168": {"epss_score": 0.00526, "epss_percentile": 0.66409}, "CVE-2024-11169": {"epss_score": 0.00716, "epss_percentile": 0.7186}, "CVE-2024-11170": {"epss_score": 0.02731, "epss_percentile": 0.8554}, "CVE-2024-11171": {"epss_score": 0.00192, "epss_percentile": 0.4131}, "CVE-2024-11172": {"epss_score": 0.00237, "epss_percentile": 0.46664}, "CVE-2024-11173": {"epss_score": 0.00177, "epss_percentile": 0.39495}, "CVE-2024-11175": {"epss_score": 0.00101, "epss_percentile": 0.28653}, "CVE-2024-11176": {"epss_score": 0.00072, "epss_percentile": 0.22314}, "CVE-2024-11178": {"epss_score": 0.00752, "epss_percentile": 0.72658}, "CVE-2024-11179": {"epss_score": 0.00278, "epss_percentile": 0.50858}, "CVE-2024-11180": {"epss_score": 0.0004, "epss_percentile": 0.11922}, "CVE-2024-11181": {"epss_score": 0.00155, "epss_percentile": 0.36791}, "CVE-2024-11182": {"epss_score": 0.11885, "epss_percentile": 0.93505}, "CVE-2024-11183": {"epss_score": 0.00021, "epss_percentile": 0.04823}, "CVE-2024-11184": {"epss_score": 0.00038, "epss_percentile": 0.11096}, "CVE-2024-11185": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2024-11186": {"epss_score": 0.00064, "epss_percentile": 0.20192}, "CVE-2024-11187": {"epss_score": 0.00666, "epss_percentile": 0.70682}, "CVE-2024-11188": {"epss_score": 0.00492, "epss_percentile": 0.65008}, "CVE-2024-11189": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-11190": {"epss_score": 0.00026, "epss_percentile": 0.06556}, "CVE-2024-11192": {"epss_score": 0.00187, "epss_percentile": 0.40781}, "CVE-2024-11193": {"epss_score": 0.0023, "epss_percentile": 0.45672}, "CVE-2024-11194": {"epss_score": 0.00296, "epss_percentile": 0.52578}, "CVE-2024-11195": {"epss_score": 0.0026, "epss_percentile": 0.49171}, "CVE-2024-11196": {"epss_score": 0.00133, "epss_percentile": 0.33674}, "CVE-2024-11197": {"epss_score": 0.00028, "epss_percentile": 0.07561}, "CVE-2024-11198": {"epss_score": 0.0026, "epss_percentile": 0.49171}, "CVE-2024-11199": {"epss_score": 0.13687, "epss_percentile": 0.94034}, "CVE-2024-11200": {"epss_score": 0.01119, "epss_percentile": 0.77757}, "CVE-2024-11201": {"epss_score": 0.0557, "epss_percentile": 0.90006}, "CVE-2024-11202": {"epss_score": 0.02188, "epss_percentile": 0.83926}, "CVE-2024-11203": {"epss_score": 0.00066, "epss_percentile": 0.20861}, "CVE-2024-11204": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-11205": {"epss_score": 0.00196, "epss_percentile": 0.41798}, "CVE-2024-11206": {"epss_score": 0.00253, "epss_percentile": 0.48491}, "CVE-2024-11207": {"epss_score": 0.00286, "epss_percentile": 0.51736}, "CVE-2024-11208": {"epss_score": 0.00326, "epss_percentile": 0.55084}, "CVE-2024-11209": {"epss_score": 0.00182, "epss_percentile": 0.40225}, "CVE-2024-11210": {"epss_score": 0.00082, "epss_percentile": 0.24511}, "CVE-2024-11211": {"epss_score": 0.00047, "epss_percentile": 0.14646}, "CVE-2024-11212": {"epss_score": 0.00072, "epss_percentile": 0.22433}, "CVE-2024-11213": {"epss_score": 0.00101, "epss_percentile": 0.28657}, "CVE-2024-11214": {"epss_score": 0.00146, "epss_percentile": 0.35585}, "CVE-2024-11215": {"epss_score": 0.0008, "epss_percentile": 0.24182}, "CVE-2024-11216": {"epss_score": 0.00122, "epss_percentile": 0.32072}, "CVE-2024-11217": {"epss_score": 0.00136, "epss_percentile": 0.34197}, "CVE-2024-11218": {"epss_score": 0.00067, "epss_percentile": 0.21015}, "CVE-2024-11219": {"epss_score": 0.00889, "epss_percentile": 0.75019}, "CVE-2024-11220": {"epss_score": 0.00038, "epss_percentile": 0.11282}, "CVE-2024-11221": {"epss_score": 8e-05, "epss_percentile": 0.00499}, "CVE-2024-11223": {"epss_score": 0.00077, "epss_percentile": 0.23307}, "CVE-2024-11224": {"epss_score": 0.0026, "epss_percentile": 0.49171}, "CVE-2024-11225": {"epss_score": 0.00848, "epss_percentile": 0.74355}, "CVE-2024-11226": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-11227": {"epss_score": 0.00145, "epss_percentile": 0.35355}, "CVE-2024-11228": {"epss_score": 0.00141, "epss_percentile": 0.34827}, "CVE-2024-11229": {"epss_score": 0.00159, "epss_percentile": 0.37417}, "CVE-2024-11230": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-11231": {"epss_score": 0.00141, "epss_percentile": 0.34827}, "CVE-2024-11233": {"epss_score": 0.00158, "epss_percentile": 0.37167}, "CVE-2024-11234": {"epss_score": 0.00462, "epss_percentile": 0.63571}, "CVE-2024-11235": {"epss_score": 0.00551, "epss_percentile": 0.67355}, "CVE-2024-11236": {"epss_score": 0.00327, "epss_percentile": 0.55093}, "CVE-2024-11237": {"epss_score": 0.02293, "epss_percentile": 0.84288}, "CVE-2024-11238": {"epss_score": 0.10821, "epss_percentile": 0.93122}, "CVE-2024-11239": {"epss_score": 0.00259, "epss_percentile": 0.49086}, "CVE-2024-11240": {"epss_score": 0.00067, "epss_percentile": 0.21045}, "CVE-2024-11241": {"epss_score": 0.00091, "epss_percentile": 0.26226}, "CVE-2024-11242": {"epss_score": 0.00126, "epss_percentile": 0.32753}, "CVE-2024-11243": {"epss_score": 0.00168, "epss_percentile": 0.38444}, "CVE-2024-11244": {"epss_score": 0.00103, "epss_percentile": 0.29069}, "CVE-2024-11245": {"epss_score": 0.00067, "epss_percentile": 0.21049}, "CVE-2024-11246": {"epss_score": 0.00201, "epss_percentile": 0.42359}, "CVE-2024-11247": {"epss_score": 0.00256, "epss_percentile": 0.48829}, "CVE-2024-11248": {"epss_score": 0.00999, "epss_percentile": 0.76476}, "CVE-2024-11250": {"epss_score": 0.00036, "epss_percentile": 0.10352}, "CVE-2024-11251": {"epss_score": 0.0008, "epss_percentile": 0.24062}, "CVE-2024-11252": {"epss_score": 0.19207, "epss_percentile": 0.95149}, "CVE-2024-11253": {"epss_score": 0.00625, "epss_percentile": 0.69596}, "CVE-2024-11254": {"epss_score": 0.00229, "epss_percentile": 0.45553}, "CVE-2024-11256": {"epss_score": 0.00062, "epss_percentile": 0.19687}, "CVE-2024-11257": {"epss_score": 0.00044, "epss_percentile": 0.13566}, "CVE-2024-11258": {"epss_score": 0.00044, "epss_percentile": 0.13566}, "CVE-2024-11259": {"epss_score": 0.00256, "epss_percentile": 0.48829}, "CVE-2024-11260": {"epss_score": 0.00366, "epss_percentile": 0.58072}, "CVE-2024-11261": {"epss_score": 0.00097, "epss_percentile": 0.27518}, "CVE-2024-11262": {"epss_score": 0.00036, "epss_percentile": 0.10504}, "CVE-2024-11263": {"epss_score": 0.00116, "epss_percentile": 0.31038}, "CVE-2024-11265": {"epss_score": 0.00366, "epss_percentile": 0.58077}, "CVE-2024-11266": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-11267": {"epss_score": 0.00107, "epss_percentile": 0.29625}, "CVE-2024-11268": {"epss_score": 0.00066, "epss_percentile": 0.20866}, "CVE-2024-11269": {"epss_score": 0.00051, "epss_percentile": 0.16211}, "CVE-2024-11270": {"epss_score": 0.03968, "epss_percentile": 0.88033}, "CVE-2024-11271": {"epss_score": 0.00194, "epss_percentile": 0.41534}, "CVE-2024-11272": {"epss_score": 0.00062, "epss_percentile": 0.19665}, "CVE-2024-11273": {"epss_score": 0.00062, "epss_percentile": 0.19665}, "CVE-2024-11274": {"epss_score": 0.00037, "epss_percentile": 0.10926}, "CVE-2024-11275": {"epss_score": 0.00094, "epss_percentile": 0.27027}, "CVE-2024-11276": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11277": {"epss_score": 0.00731, "epss_percentile": 0.72174}, "CVE-2024-11278": {"epss_score": 0.00948, "epss_percentile": 0.7583}, "CVE-2024-11279": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11280": {"epss_score": 0.00347, "epss_percentile": 0.56779}, "CVE-2024-11281": {"epss_score": 0.1132, "epss_percentile": 0.93307}, "CVE-2024-11282": {"epss_score": 0.00658, "epss_percentile": 0.70477}, "CVE-2024-11283": {"epss_score": 0.00375, "epss_percentile": 0.58605}, "CVE-2024-11284": {"epss_score": 0.00558, "epss_percentile": 0.67561}, "CVE-2024-11285": {"epss_score": 0.00558, "epss_percentile": 0.67561}, "CVE-2024-11286": {"epss_score": 0.00773, "epss_percentile": 0.73055}, "CVE-2024-11287": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11289": {"epss_score": 0.01539, "epss_percentile": 0.80937}, "CVE-2024-11290": {"epss_score": 0.00328, "epss_percentile": 0.55284}, "CVE-2024-11291": {"epss_score": 0.00328, "epss_percentile": 0.55284}, "CVE-2024-11292": {"epss_score": 0.00328, "epss_percentile": 0.55284}, "CVE-2024-11293": {"epss_score": 0.00659, "epss_percentile": 0.705}, "CVE-2024-11294": {"epss_score": 0.00328, "epss_percentile": 0.55284}, "CVE-2024-11295": {"epss_score": 0.00356, "epss_percentile": 0.57384}, "CVE-2024-11297": {"epss_score": 0.00396, "epss_percentile": 0.59892}, "CVE-2024-11299": {"epss_score": 0.0014, "epss_percentile": 0.34687}, "CVE-2024-11300": {"epss_score": 0.00072, "epss_percentile": 0.22458}, "CVE-2024-11301": {"epss_score": 0.00039, "epss_percentile": 0.11589}, "CVE-2024-11302": {"epss_score": 0.00022, "epss_percentile": 0.05033}, "CVE-2024-11303": {"epss_score": 0.09955, "epss_percentile": 0.9279}, "CVE-2024-11304": {"epss_score": 0.00159, "epss_percentile": 0.37386}, "CVE-2024-11305": {"epss_score": 0.42255, "epss_percentile": 0.97322}, "CVE-2024-11306": {"epss_score": 0.00086, "epss_percentile": 0.25356}, "CVE-2024-11308": {"epss_score": 0.00043, "epss_percentile": 0.13323}, "CVE-2024-11309": {"epss_score": 0.00234, "epss_percentile": 0.46167}, "CVE-2024-11310": {"epss_score": 0.00234, "epss_percentile": 0.46167}, "CVE-2024-11311": {"epss_score": 0.0516, "epss_percentile": 0.89558}, "CVE-2024-11312": {"epss_score": 0.0516, "epss_percentile": 0.89558}, "CVE-2024-11313": {"epss_score": 0.0516, "epss_percentile": 0.89558}, "CVE-2024-11314": {"epss_score": 0.0516, "epss_percentile": 0.89558}, "CVE-2024-11315": {"epss_score": 0.0516, "epss_percentile": 0.89558}, "CVE-2024-11316": {"epss_score": 0.0024, "epss_percentile": 0.4723}, "CVE-2024-11317": {"epss_score": 0.00144, "epss_percentile": 0.35257}, "CVE-2024-11318": {"epss_score": 0.2148, "epss_percentile": 0.95523}, "CVE-2024-11319": {"epss_score": 0.00292, "epss_percentile": 0.52268}, "CVE-2024-11320": {"epss_score": 0.91812, "epss_percentile": 0.99669}, "CVE-2024-11321": {"epss_score": 0.00071, "epss_percentile": 0.22201}, "CVE-2024-11322": {"epss_score": 0.00445, "epss_percentile": 0.62884}, "CVE-2024-11323": {"epss_score": 0.00137, "epss_percentile": 0.34205}, "CVE-2024-11324": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-11325": {"epss_score": 0.00474, "epss_percentile": 0.64138}, "CVE-2024-11326": {"epss_score": 0.00843, "epss_percentile": 0.74266}, "CVE-2024-11327": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-11328": {"epss_score": 0.01341, "epss_percentile": 0.79587}, "CVE-2024-11329": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11330": {"epss_score": 0.00516, "epss_percentile": 0.6603}, "CVE-2024-11331": {"epss_score": 0.00882, "epss_percentile": 0.74886}, "CVE-2024-11332": {"epss_score": 0.00079, "epss_percentile": 0.23805}, "CVE-2024-11333": {"epss_score": 0.00108, "epss_percentile": 0.29814}, "CVE-2024-11334": {"epss_score": 0.0024, "epss_percentile": 0.47195}, "CVE-2024-11335": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-11336": {"epss_score": 0.00049, "epss_percentile": 0.15346}, "CVE-2024-11337": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11338": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11339": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11341": {"epss_score": 0.00033, "epss_percentile": 0.0933}, "CVE-2024-11342": {"epss_score": 0.0022, "epss_percentile": 0.44596}, "CVE-2024-11343": {"epss_score": 0.0078, "epss_percentile": 0.73159}, "CVE-2024-11344": {"epss_score": 0.00323, "epss_percentile": 0.54889}, "CVE-2024-11345": {"epss_score": 0.00323, "epss_percentile": 0.54889}, "CVE-2024-11346": {"epss_score": 0.00144, "epss_percentile": 0.35332}, "CVE-2024-11347": {"epss_score": 0.00277, "epss_percentile": 0.50819}, "CVE-2024-11348": {"epss_score": 0.00138, "epss_percentile": 0.3435}, "CVE-2024-11349": {"epss_score": 0.09565, "epss_percentile": 0.92603}, "CVE-2024-11350": {"epss_score": 0.00496, "epss_percentile": 0.65147}, "CVE-2024-11351": {"epss_score": 0.00356, "epss_percentile": 0.57384}, "CVE-2024-11352": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11353": {"epss_score": 0.00094, "epss_percentile": 0.27027}, "CVE-2024-11354": {"epss_score": 0.00076, "epss_percentile": 0.23077}, "CVE-2024-11355": {"epss_score": 0.00173, "epss_percentile": 0.3911}, "CVE-2024-11356": {"epss_score": 0.00074, "epss_percentile": 0.22789}, "CVE-2024-11357": {"epss_score": 0.00023, "epss_percentile": 0.05523}, "CVE-2024-11358": {"epss_score": 0.00018, "epss_percentile": 0.0389}, "CVE-2024-11359": {"epss_score": 0.00843, "epss_percentile": 0.74266}, "CVE-2024-11360": {"epss_score": 0.00647, "epss_percentile": 0.70199}, "CVE-2024-11361": {"epss_score": 0.00516, "epss_percentile": 0.6603}, "CVE-2024-11362": {"epss_score": 0.00516, "epss_percentile": 0.6603}, "CVE-2024-11363": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11364": {"epss_score": 0.00017, "epss_percentile": 0.03102}, "CVE-2024-11365": {"epss_score": 0.00598, "epss_percentile": 0.68774}, "CVE-2024-11366": {"epss_score": 0.0072, "epss_percentile": 0.71959}, "CVE-2024-11367": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11368": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11369": {"epss_score": 0.00986, "epss_percentile": 0.76335}, "CVE-2024-11370": {"epss_score": 0.00417, "epss_percentile": 0.61247}, "CVE-2024-11371": {"epss_score": 0.00919, "epss_percentile": 0.75462}, "CVE-2024-11372": {"epss_score": 0.00106, "epss_percentile": 0.2953}, "CVE-2024-11373": {"epss_score": 0.00017, "epss_percentile": 0.0342}, "CVE-2024-11374": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11375": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11376": {"epss_score": 0.00676, "epss_percentile": 0.70919}, "CVE-2024-11377": {"epss_score": 0.01435, "epss_percentile": 0.80269}, "CVE-2024-11378": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11379": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-11380": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11381": {"epss_score": 0.07078, "epss_percentile": 0.91236}, "CVE-2024-11382": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11383": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11384": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-11385": {"epss_score": 0.00083, "epss_percentile": 0.24592}, "CVE-2024-11386": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11387": {"epss_score": 0.05749, "epss_percentile": 0.90176}, "CVE-2024-11388": {"epss_score": 0.08901, "epss_percentile": 0.92307}, "CVE-2024-11390": {"epss_score": 0.00052, "epss_percentile": 0.16669}, "CVE-2024-11391": {"epss_score": 0.01665, "epss_percentile": 0.81646}, "CVE-2024-11392": {"epss_score": 0.30773, "epss_percentile": 0.96567}, "CVE-2024-11393": {"epss_score": 0.46142, "epss_percentile": 0.97533}, "CVE-2024-11394": {"epss_score": 0.30743, "epss_percentile": 0.96565}, "CVE-2024-11395": {"epss_score": 0.0029, "epss_percentile": 0.52096}, "CVE-2024-11396": {"epss_score": 0.47484, "epss_percentile": 0.97589}, "CVE-2024-11398": {"epss_score": 0.01094, "epss_percentile": 0.77496}, "CVE-2024-11400": {"epss_score": 0.01539, "epss_percentile": 0.80939}, "CVE-2024-11401": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2024-11402": {"epss_score": 0.00061, "epss_percentile": 0.19373}, "CVE-2024-11403": {"epss_score": 0.0006, "epss_percentile": 0.19164}, "CVE-2024-11404": {"epss_score": 0.00026, "epss_percentile": 0.0653}, "CVE-2024-11405": {"epss_score": 0.00106, "epss_percentile": 0.29506}, "CVE-2024-11406": {"epss_score": 0.00034, "epss_percentile": 0.09714}, "CVE-2024-11407": {"epss_score": 0.00045, "epss_percentile": 0.14}, "CVE-2024-11408": {"epss_score": 0.00079, "epss_percentile": 0.23805}, "CVE-2024-11409": {"epss_score": 0.00599, "epss_percentile": 0.68795}, "CVE-2024-11410": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11411": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11412": {"epss_score": 0.0453, "epss_percentile": 0.8881}, "CVE-2024-11413": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11414": {"epss_score": 0.00184, "epss_percentile": 0.40396}, "CVE-2024-11415": {"epss_score": 0.00152, "epss_percentile": 0.36404}, "CVE-2024-11416": {"epss_score": 0.00099, "epss_percentile": 0.27861}, "CVE-2024-11417": {"epss_score": 0.00049, "epss_percentile": 0.15345}, "CVE-2024-11418": {"epss_score": 0.00798, "epss_percentile": 0.73506}, "CVE-2024-11419": {"epss_score": 0.00049, "epss_percentile": 0.15346}, "CVE-2024-11420": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-11422": {"epss_score": 0.00031, "epss_percentile": 0.08573}, "CVE-2024-11423": {"epss_score": 0.32204, "epss_percentile": 0.96679}, "CVE-2024-11424": {"epss_score": 0.00091, "epss_percentile": 0.2629}, "CVE-2024-11425": {"epss_score": 0.0073, "epss_percentile": 0.72153}, "CVE-2024-11426": {"epss_score": 0.00091, "epss_percentile": 0.2629}, "CVE-2024-11427": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11428": {"epss_score": 0.06253, "epss_percentile": 0.90616}, "CVE-2024-11429": {"epss_score": 0.00977, "epss_percentile": 0.7622}, "CVE-2024-11430": {"epss_score": 0.00203, "epss_percentile": 0.42577}, "CVE-2024-11431": {"epss_score": 0.00119, "epss_percentile": 0.31662}, "CVE-2024-11432": {"epss_score": 0.07886, "epss_percentile": 0.91743}, "CVE-2024-11433": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11434": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11435": {"epss_score": 0.00347, "epss_percentile": 0.56757}, "CVE-2024-11436": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11437": {"epss_score": 0.00656, "epss_percentile": 0.70441}, "CVE-2024-11438": {"epss_score": 0.00079, "epss_percentile": 0.23805}, "CVE-2024-11439": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-11440": {"epss_score": 0.00091, "epss_percentile": 0.2629}, "CVE-2024-11441": {"epss_score": 0.00047, "epss_percentile": 0.14928}, "CVE-2024-11442": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11443": {"epss_score": 0.00162, "epss_percentile": 0.37626}, "CVE-2024-11444": {"epss_score": 0.00034, "epss_percentile": 0.09794}, "CVE-2024-11445": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11446": {"epss_score": 0.00516, "epss_percentile": 0.6603}, "CVE-2024-11447": {"epss_score": 0.0036, "epss_percentile": 0.57689}, "CVE-2024-11449": {"epss_score": 0.00117, "epss_percentile": 0.31229}, "CVE-2024-11450": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11451": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-11452": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-11453": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-11454": {"epss_score": 0.00078, "epss_percentile": 0.2368}, "CVE-2024-11455": {"epss_score": 0.00141, "epss_percentile": 0.34804}, "CVE-2024-11456": {"epss_score": 0.00561, "epss_percentile": 0.67673}, "CVE-2024-11457": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11458": {"epss_score": 0.00673, "epss_percentile": 0.70844}, "CVE-2024-11459": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-11460": {"epss_score": 0.01337, "epss_percentile": 0.79558}, "CVE-2024-11461": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-11462": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11463": {"epss_score": 0.00397, "epss_percentile": 0.60028}, "CVE-2024-11464": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11465": {"epss_score": 0.03073, "epss_percentile": 0.86353}, "CVE-2024-11466": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-11467": {"epss_score": 0.00045, "epss_percentile": 0.13896}, "CVE-2024-11468": {"epss_score": 0.00029, "epss_percentile": 0.07973}, "CVE-2024-11477": {"epss_score": 0.39505, "epss_percentile": 0.97164}, "CVE-2024-11479": {"epss_score": 0.00272, "epss_percentile": 0.50353}, "CVE-2024-11481": {"epss_score": 0.00311, "epss_percentile": 0.53922}, "CVE-2024-11482": {"epss_score": 0.05211, "epss_percentile": 0.89616}, "CVE-2024-11483": {"epss_score": 0.00089, "epss_percentile": 0.25986}, "CVE-2024-11484": {"epss_score": 0.00117, "epss_percentile": 0.3122}, "CVE-2024-11485": {"epss_score": 0.0006, "epss_percentile": 0.19063}, "CVE-2024-11486": {"epss_score": 0.00091, "epss_percentile": 0.26251}, "CVE-2024-11487": {"epss_score": 0.00038, "epss_percentile": 0.11188}, "CVE-2024-11488": {"epss_score": 0.00168, "epss_percentile": 0.38409}, "CVE-2024-11489": {"epss_score": 0.00258, "epss_percentile": 0.49016}, "CVE-2024-11490": {"epss_score": 0.00168, "epss_percentile": 0.38409}, "CVE-2024-11491": {"epss_score": 0.00118, "epss_percentile": 0.31422}, "CVE-2024-11492": {"epss_score": 0.00127, "epss_percentile": 0.32798}, "CVE-2024-11493": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-11494": {"epss_score": 0.00222, "epss_percentile": 0.44799}, "CVE-2024-11495": {"epss_score": 0.0005, "epss_percentile": 0.15876}, "CVE-2024-11496": {"epss_score": 0.00128, "epss_percentile": 0.33022}, "CVE-2024-11497": {"epss_score": 0.00154, "epss_percentile": 0.36656}, "CVE-2024-11498": {"epss_score": 0.00051, "epss_percentile": 0.16206}, "CVE-2024-11499": {"epss_score": 0.00076, "epss_percentile": 0.23086}, "CVE-2024-11501": {"epss_score": 0.0172, "epss_percentile": 0.81931}, "CVE-2024-11502": {"epss_score": 0.00022, "epss_percentile": 0.05165}, "CVE-2024-11503": {"epss_score": 0.00064, "epss_percentile": 0.20387}, "CVE-2024-11504": {"epss_score": 0.00165, "epss_percentile": 0.38063}, "CVE-2024-11506": {"epss_score": 0.00667, "epss_percentile": 0.70707}, "CVE-2024-11507": {"epss_score": 0.00936, "epss_percentile": 0.75681}, "CVE-2024-11508": {"epss_score": 0.00936, "epss_percentile": 0.75681}, "CVE-2024-11509": {"epss_score": 0.01051, "epss_percentile": 0.77084}, "CVE-2024-11510": {"epss_score": 0.0132, "epss_percentile": 0.79439}, "CVE-2024-11511": {"epss_score": 0.0132, "epss_percentile": 0.79439}, "CVE-2024-11512": {"epss_score": 0.01101, "epss_percentile": 0.77577}, "CVE-2024-11513": {"epss_score": 0.00775, "epss_percentile": 0.73086}, "CVE-2024-11514": {"epss_score": 0.00775, "epss_percentile": 0.73086}, "CVE-2024-11515": {"epss_score": 0.00444, "epss_percentile": 0.62833}, "CVE-2024-11516": {"epss_score": 0.00775, "epss_percentile": 0.73086}, "CVE-2024-11517": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11518": {"epss_score": 0.00775, "epss_percentile": 0.73086}, "CVE-2024-11519": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11520": {"epss_score": 0.00683, "epss_percentile": 0.71106}, "CVE-2024-11521": {"epss_score": 0.00845, "epss_percentile": 0.74316}, "CVE-2024-11522": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11523": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11524": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11525": {"epss_score": 0.00888, "epss_percentile": 0.74998}, "CVE-2024-11526": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11527": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11528": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11529": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11530": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11531": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11532": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11533": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11534": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11535": {"epss_score": 0.00683, "epss_percentile": 0.71106}, "CVE-2024-11536": {"epss_score": 0.00683, "epss_percentile": 0.71106}, "CVE-2024-11537": {"epss_score": 0.00444, "epss_percentile": 0.62833}, "CVE-2024-11538": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11539": {"epss_score": 0.00467, "epss_percentile": 0.63815}, "CVE-2024-11540": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11541": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11542": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11543": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11544": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11545": {"epss_score": 0.00784, "epss_percentile": 0.73231}, "CVE-2024-11546": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11547": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11548": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11549": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11550": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11551": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11552": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11553": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11554": {"epss_score": 0.00683, "epss_percentile": 0.71106}, "CVE-2024-11555": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11556": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11557": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11558": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11559": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11560": {"epss_score": 0.00683, "epss_percentile": 0.71106}, "CVE-2024-11561": {"epss_score": 0.00683, "epss_percentile": 0.71106}, "CVE-2024-11562": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11563": {"epss_score": 0.00683, "epss_percentile": 0.71106}, "CVE-2024-11564": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11565": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11566": {"epss_score": 0.00633, "epss_percentile": 0.69783}, "CVE-2024-11567": {"epss_score": 0.00683, "epss_percentile": 0.71106}, "CVE-2024-11568": {"epss_score": 0.00718, "epss_percentile": 0.71929}, "CVE-2024-11569": {"epss_score": 0.00683, "epss_percentile": 0.71106}, "CVE-2024-11570": {"epss_score": 0.00854, "epss_percentile": 0.74452}, "CVE-2024-11571": {"epss_score": 0.00667, "epss_percentile": 0.70707}, "CVE-2024-11572": {"epss_score": 0.00667, "epss_percentile": 0.70707}, "CVE-2024-11573": {"epss_score": 0.00667, "epss_percentile": 0.70707}, "CVE-2024-11574": {"epss_score": 0.0106, "epss_percentile": 0.77169}, "CVE-2024-11575": {"epss_score": 0.0106, "epss_percentile": 0.77169}, "CVE-2024-11576": {"epss_score": 0.0171, "epss_percentile": 0.81871}, "CVE-2024-11577": {"epss_score": 0.01587, "epss_percentile": 0.81185}, "CVE-2024-11578": {"epss_score": 0.02302, "epss_percentile": 0.84313}, "CVE-2024-11579": {"epss_score": 0.01587, "epss_percentile": 0.81185}, "CVE-2024-11580": {"epss_score": 0.02361, "epss_percentile": 0.84497}, "CVE-2024-11581": {"epss_score": 0.01587, "epss_percentile": 0.81185}, "CVE-2024-11582": {"epss_score": 0.00696, "epss_percentile": 0.71391}, "CVE-2024-11583": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2024-11584": {"epss_score": 0.00025, "epss_percentile": 0.06309}, "CVE-2024-11585": {"epss_score": 0.02232, "epss_percentile": 0.84091}, "CVE-2024-11586": {"epss_score": 0.00019, "epss_percentile": 0.04337}, "CVE-2024-11587": {"epss_score": 0.00808, "epss_percentile": 0.73688}, "CVE-2024-11588": {"epss_score": 0.00061, "epss_percentile": 0.19247}, "CVE-2024-11589": {"epss_score": 0.0005, "epss_percentile": 0.15831}, "CVE-2024-11590": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2024-11591": {"epss_score": 0.00036, "epss_percentile": 0.10339}, "CVE-2024-11592": {"epss_score": 0.00049, "epss_percentile": 0.15362}, "CVE-2024-11595": {"epss_score": 0.00012, "epss_percentile": 0.01348}, "CVE-2024-11596": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2024-11597": {"epss_score": 0.00059, "epss_percentile": 0.18707}, "CVE-2024-11598": {"epss_score": 0.00059, "epss_percentile": 0.18707}, "CVE-2024-11599": {"epss_score": 0.00076, "epss_percentile": 0.23265}, "CVE-2024-11600": {"epss_score": 0.01227, "epss_percentile": 0.78698}, "CVE-2024-11601": {"epss_score": 0.00108, "epss_percentile": 0.298}, "CVE-2024-11602": {"epss_score": 0.00043, "epss_percentile": 0.13241}, "CVE-2024-11603": {"epss_score": 0.00132, "epss_percentile": 0.33568}, "CVE-2024-11605": {"epss_score": 0.00451, "epss_percentile": 0.63132}, "CVE-2024-11606": {"epss_score": 0.00074, "epss_percentile": 0.22725}, "CVE-2024-11607": {"epss_score": 0.00011, "epss_percentile": 0.00956}, "CVE-2024-11608": {"epss_score": 0.00078, "epss_percentile": 0.2368}, "CVE-2024-11609": {"epss_score": 0.00073, "epss_percentile": 0.22576}, "CVE-2024-11610": {"epss_score": 0.0008, "epss_percentile": 0.2408}, "CVE-2024-11611": {"epss_score": 0.0008, "epss_percentile": 0.2408}, "CVE-2024-11612": {"epss_score": 0.00168, "epss_percentile": 0.38435}, "CVE-2024-11613": {"epss_score": 0.78727, "epss_percentile": 0.99001}, "CVE-2024-11614": {"epss_score": 0.00315, "epss_percentile": 0.54202}, "CVE-2024-11615": {"epss_score": 0.01038, "epss_percentile": 0.76933}, "CVE-2024-11616": {"epss_score": 0.00082, "epss_percentile": 0.24411}, "CVE-2024-11617": {"epss_score": 0.00789, "epss_percentile": 0.73353}, "CVE-2024-11618": {"epss_score": 0.00107, "epss_percentile": 0.29725}, "CVE-2024-11619": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-11620": {"epss_score": 0.0009, "epss_percentile": 0.26158}, "CVE-2024-11621": {"epss_score": 0.00057, "epss_percentile": 0.18121}, "CVE-2024-11622": {"epss_score": 0.00031, "epss_percentile": 0.08412}, "CVE-2024-11623": {"epss_score": 0.00174, "epss_percentile": 0.39144}, "CVE-2024-11624": {"epss_score": 0.0001, "epss_percentile": 0.00818}, "CVE-2024-11625": {"epss_score": 0.00066, "epss_percentile": 0.20911}, "CVE-2024-11626": {"epss_score": 0.00079, "epss_percentile": 0.23888}, "CVE-2024-11627": {"epss_score": 0.00089, "epss_percentile": 0.25956}, "CVE-2024-11628": {"epss_score": 0.00216, "epss_percentile": 0.44236}, "CVE-2024-11629": {"epss_score": 0.01319, "epss_percentile": 0.79431}, "CVE-2024-11630": {"epss_score": 0.00046, "epss_percentile": 0.14334}, "CVE-2024-11631": {"epss_score": 0.00032, "epss_percentile": 0.08769}, "CVE-2024-11632": {"epss_score": 0.00032, "epss_percentile": 0.08766}, "CVE-2024-11633": {"epss_score": 0.17932, "epss_percentile": 0.94929}, "CVE-2024-11634": {"epss_score": 0.14509, "epss_percentile": 0.94227}, "CVE-2024-11635": {"epss_score": 0.18602, "epss_percentile": 0.95042}, "CVE-2024-11636": {"epss_score": 0.00021, "epss_percentile": 0.04823}, "CVE-2024-11638": {"epss_score": 0.00194, "epss_percentile": 0.41589}, "CVE-2024-11639": {"epss_score": 0.34292, "epss_percentile": 0.9684}, "CVE-2024-11640": {"epss_score": 0.00134, "epss_percentile": 0.33769}, "CVE-2024-11641": {"epss_score": 0.00137, "epss_percentile": 0.34301}, "CVE-2024-11642": {"epss_score": 0.01414, "epss_percentile": 0.80128}, "CVE-2024-11643": {"epss_score": 0.01455, "epss_percentile": 0.80392}, "CVE-2024-11644": {"epss_score": 0.00023, "epss_percentile": 0.05523}, "CVE-2024-11645": {"epss_score": 0.00021, "epss_percentile": 0.04823}, "CVE-2024-11646": {"epss_score": 0.00057, "epss_percentile": 0.18049}, "CVE-2024-11647": {"epss_score": 0.00046, "epss_percentile": 0.14151}, "CVE-2024-11648": {"epss_score": 0.00046, "epss_percentile": 0.14151}, "CVE-2024-11649": {"epss_score": 0.00034, "epss_percentile": 0.09535}, "CVE-2024-11650": {"epss_score": 0.00078, "epss_percentile": 0.23777}, "CVE-2024-11651": {"epss_score": 0.00801, "epss_percentile": 0.73565}, "CVE-2024-11652": {"epss_score": 0.00248, "epss_percentile": 0.4791}, "CVE-2024-11653": {"epss_score": 0.00974, "epss_percentile": 0.76172}, "CVE-2024-11654": {"epss_score": 0.00739, "epss_percentile": 0.72394}, "CVE-2024-11655": {"epss_score": 0.00519, "epss_percentile": 0.66153}, "CVE-2024-11656": {"epss_score": 0.00519, "epss_percentile": 0.66153}, "CVE-2024-11657": {"epss_score": 0.00545, "epss_percentile": 0.67168}, "CVE-2024-11658": {"epss_score": 0.00519, "epss_percentile": 0.66153}, "CVE-2024-11659": {"epss_score": 0.00793, "epss_percentile": 0.73431}, "CVE-2024-11660": {"epss_score": 0.00073, "epss_percentile": 0.22639}, "CVE-2024-11661": {"epss_score": 0.00044, "epss_percentile": 0.13441}, "CVE-2024-11662": {"epss_score": 0.00093, "epss_percentile": 0.26759}, "CVE-2024-11663": {"epss_score": 0.00052, "epss_percentile": 0.16454}, "CVE-2024-11664": {"epss_score": 0.06529, "epss_percentile": 0.90823}, "CVE-2024-11665": {"epss_score": 0.00321, "epss_percentile": 0.5467}, "CVE-2024-11666": {"epss_score": 0.01344, "epss_percentile": 0.7961}, "CVE-2024-11667": {"epss_score": 0.34189, "epss_percentile": 0.96831}, "CVE-2024-11668": {"epss_score": 8e-05, "epss_percentile": 0.00495}, "CVE-2024-11669": {"epss_score": 0.00014, "epss_percentile": 0.01788}, "CVE-2024-11670": {"epss_score": 0.00023, "epss_percentile": 0.05473}, "CVE-2024-11671": {"epss_score": 0.00082, "epss_percentile": 0.24563}, "CVE-2024-11672": {"epss_score": 0.00107, "epss_percentile": 0.29659}, "CVE-2024-11673": {"epss_score": 0.00167, "epss_percentile": 0.38308}, "CVE-2024-11674": {"epss_score": 0.0013, "epss_percentile": 0.33267}, "CVE-2024-11675": {"epss_score": 0.00101, "epss_percentile": 0.28589}, "CVE-2024-11676": {"epss_score": 0.00104, "epss_percentile": 0.29176}, "CVE-2024-11677": {"epss_score": 0.00099, "epss_percentile": 0.28352}, "CVE-2024-11678": {"epss_score": 0.00073, "epss_percentile": 0.22593}, "CVE-2024-11679": {"epss_score": 0.00025, "epss_percentile": 0.06256}, "CVE-2024-11680": {"epss_score": 0.9349, "epss_percentile": 0.99811}, "CVE-2024-11681": {"epss_score": 0.00944, "epss_percentile": 0.75793}, "CVE-2024-11682": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11683": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11684": {"epss_score": 0.00498, "epss_percentile": 0.65234}, "CVE-2024-11685": {"epss_score": 0.00519, "epss_percentile": 0.66145}, "CVE-2024-11686": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11687": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11688": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11689": {"epss_score": 0.00046, "epss_percentile": 0.14189}, "CVE-2024-11690": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11691": {"epss_score": 0.00207, "epss_percentile": 0.43146}, "CVE-2024-11692": {"epss_score": 0.00087, "epss_percentile": 0.25544}, "CVE-2024-11693": {"epss_score": 0.0029, "epss_percentile": 0.52083}, "CVE-2024-11694": {"epss_score": 0.00102, "epss_percentile": 0.28802}, "CVE-2024-11695": {"epss_score": 0.0013, "epss_percentile": 0.33287}, "CVE-2024-11696": {"epss_score": 0.00045, "epss_percentile": 0.13787}, "CVE-2024-11697": {"epss_score": 0.00053, "epss_percentile": 0.1698}, "CVE-2024-11698": {"epss_score": 0.00226, "epss_percentile": 0.45356}, "CVE-2024-11699": {"epss_score": 0.00069, "epss_percentile": 0.21509}, "CVE-2024-11700": {"epss_score": 0.00196, "epss_percentile": 0.41779}, "CVE-2024-11701": {"epss_score": 0.00187, "epss_percentile": 0.40759}, "CVE-2024-11702": {"epss_score": 0.00243, "epss_percentile": 0.47501}, "CVE-2024-11703": {"epss_score": 0.00064, "epss_percentile": 0.20165}, "CVE-2024-11704": {"epss_score": 0.00217, "epss_percentile": 0.44269}, "CVE-2024-11705": {"epss_score": 0.00189, "epss_percentile": 0.40945}, "CVE-2024-11706": {"epss_score": 0.00171, "epss_percentile": 0.38788}, "CVE-2024-11707": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-11708": {"epss_score": 0.00179, "epss_percentile": 0.39792}, "CVE-2024-11709": {"epss_score": 0.00101, "epss_percentile": 0.28635}, "CVE-2024-11710": {"epss_score": 0.0032, "epss_percentile": 0.54599}, "CVE-2024-11711": {"epss_score": 0.02678, "epss_percentile": 0.85409}, "CVE-2024-11712": {"epss_score": 0.00389, "epss_percentile": 0.59459}, "CVE-2024-11713": {"epss_score": 0.00343, "epss_percentile": 0.56422}, "CVE-2024-11714": {"epss_score": 0.00343, "epss_percentile": 0.56422}, "CVE-2024-11715": {"epss_score": 0.00526, "epss_percentile": 0.66431}, "CVE-2024-11716": {"epss_score": 0.00239, "epss_percentile": 0.46907}, "CVE-2024-11717": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2024-11718": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2024-11719": {"epss_score": 0.00018, "epss_percentile": 0.03539}, "CVE-2024-11720": {"epss_score": 0.00665, "epss_percentile": 0.7067}, "CVE-2024-11721": {"epss_score": 0.00231, "epss_percentile": 0.45845}, "CVE-2024-11722": {"epss_score": 0.00788, "epss_percentile": 0.73339}, "CVE-2024-11723": {"epss_score": 0.00178, "epss_percentile": 0.39637}, "CVE-2024-11724": {"epss_score": 0.00029, "epss_percentile": 0.07758}, "CVE-2024-11725": {"epss_score": 0.00412, "epss_percentile": 0.60943}, "CVE-2024-11726": {"epss_score": 0.00067, "epss_percentile": 0.21016}, "CVE-2024-11727": {"epss_score": 0.00025, "epss_percentile": 0.06369}, "CVE-2024-11728": {"epss_score": 0.59498, "epss_percentile": 0.98167}, "CVE-2024-11729": {"epss_score": 0.00416, "epss_percentile": 0.61162}, "CVE-2024-11730": {"epss_score": 0.00203, "epss_percentile": 0.42577}, "CVE-2024-11731": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-11732": {"epss_score": 0.00225, "epss_percentile": 0.45103}, "CVE-2024-11733": {"epss_score": 0.01929, "epss_percentile": 0.82935}, "CVE-2024-11734": {"epss_score": 0.00048, "epss_percentile": 0.15254}, "CVE-2024-11736": {"epss_score": 0.0002, "epss_percentile": 0.04612}, "CVE-2024-11737": {"epss_score": 0.00275, "epss_percentile": 0.5064}, "CVE-2024-11738": {"epss_score": 0.00391, "epss_percentile": 0.59594}, "CVE-2024-11739": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2024-11740": {"epss_score": 0.03748, "epss_percentile": 0.87668}, "CVE-2024-11741": {"epss_score": 0.00141, "epss_percentile": 0.34936}, "CVE-2024-11742": {"epss_score": 0.00081, "epss_percentile": 0.24209}, "CVE-2024-11743": {"epss_score": 0.00099, "epss_percentile": 0.27834}, "CVE-2024-11744": {"epss_score": 0.00023, "epss_percentile": 0.05421}, "CVE-2024-11745": {"epss_score": 0.0019, "epss_percentile": 0.41094}, "CVE-2024-11746": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-11747": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11748": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-11749": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11750": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11751": {"epss_score": 0.00124, "epss_percentile": 0.32414}, "CVE-2024-11752": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11753": {"epss_score": 0.00133, "epss_percentile": 0.33676}, "CVE-2024-11754": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11755": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11756": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11757": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11758": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11759": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11760": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11761": {"epss_score": 0.00103, "epss_percentile": 0.28932}, "CVE-2024-11763": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11764": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11765": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-11766": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-11767": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-11768": {"epss_score": 0.00179, "epss_percentile": 0.39857}, "CVE-2024-11769": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11770": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11771": {"epss_score": 0.01951, "epss_percentile": 0.83017}, "CVE-2024-11772": {"epss_score": 0.13659, "epss_percentile": 0.94028}, "CVE-2024-11773": {"epss_score": 0.01584, "epss_percentile": 0.81161}, "CVE-2024-11774": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11775": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11776": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11777": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-11778": {"epss_score": 0.00119, "epss_percentile": 0.31548}, "CVE-2024-11779": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-11780": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-11781": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11782": {"epss_score": 0.00079, "epss_percentile": 0.23975}, "CVE-2024-11783": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11784": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11785": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11786": {"epss_score": 0.00119, "epss_percentile": 0.31662}, "CVE-2024-11787": {"epss_score": 0.008, "epss_percentile": 0.7354}, "CVE-2024-11788": {"epss_score": 0.00119, "epss_percentile": 0.31662}, "CVE-2024-11789": {"epss_score": 0.008, "epss_percentile": 0.7354}, "CVE-2024-11790": {"epss_score": 0.008, "epss_percentile": 0.7354}, "CVE-2024-11791": {"epss_score": 0.008, "epss_percentile": 0.7354}, "CVE-2024-11792": {"epss_score": 0.008, "epss_percentile": 0.7354}, "CVE-2024-11793": {"epss_score": 0.00525, "epss_percentile": 0.66368}, "CVE-2024-11794": {"epss_score": 0.00525, "epss_percentile": 0.66368}, "CVE-2024-11795": {"epss_score": 0.008, "epss_percentile": 0.7354}, "CVE-2024-11796": {"epss_score": 0.00525, "epss_percentile": 0.66368}, "CVE-2024-11797": {"epss_score": 0.00525, "epss_percentile": 0.66368}, "CVE-2024-11798": {"epss_score": 0.00657, "epss_percentile": 0.70473}, "CVE-2024-11799": {"epss_score": 0.008, "epss_percentile": 0.7354}, "CVE-2024-11800": {"epss_score": 0.008, "epss_percentile": 0.7354}, "CVE-2024-11801": {"epss_score": 0.00525, "epss_percentile": 0.66368}, "CVE-2024-11802": {"epss_score": 0.008, "epss_percentile": 0.7354}, "CVE-2024-11803": {"epss_score": 0.00525, "epss_percentile": 0.66368}, "CVE-2024-11804": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11805": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11806": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11807": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11808": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11809": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11810": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11811": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11812": {"epss_score": 0.00049, "epss_percentile": 0.15345}, "CVE-2024-11813": {"epss_score": 0.00049, "epss_percentile": 0.15346}, "CVE-2024-11814": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11815": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-11816": {"epss_score": 0.03913, "epss_percentile": 0.87937}, "CVE-2024-11817": {"epss_score": 0.00045, "epss_percentile": 0.13976}, "CVE-2024-11818": {"epss_score": 0.00042, "epss_percentile": 0.12571}, "CVE-2024-11819": {"epss_score": 0.00039, "epss_percentile": 0.11651}, "CVE-2024-11820": {"epss_score": 0.00169, "epss_percentile": 0.38528}, "CVE-2024-11821": {"epss_score": 0.00079, "epss_percentile": 0.23819}, "CVE-2024-11822": {"epss_score": 0.00089, "epss_percentile": 0.25964}, "CVE-2024-11823": {"epss_score": 0.00134, "epss_percentile": 0.33818}, "CVE-2024-11824": {"epss_score": 0.00073, "epss_percentile": 0.22513}, "CVE-2024-11825": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11826": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11827": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11828": {"epss_score": 0.00143, "epss_percentile": 0.35194}, "CVE-2024-11829": {"epss_score": 0.001, "epss_percentile": 0.2844}, "CVE-2024-11830": {"epss_score": 0.00085, "epss_percentile": 0.25092}, "CVE-2024-11831": {"epss_score": 0.01236, "epss_percentile": 0.78774}, "CVE-2024-11832": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-11833": {"epss_score": 0.00283, "epss_percentile": 0.51394}, "CVE-2024-11834": {"epss_score": 0.00283, "epss_percentile": 0.51394}, "CVE-2024-11835": {"epss_score": 0.00191, "epss_percentile": 0.41184}, "CVE-2024-11836": {"epss_score": 0.00099, "epss_percentile": 0.28429}, "CVE-2024-11837": {"epss_score": 0.00233, "epss_percentile": 0.46055}, "CVE-2024-11838": {"epss_score": 0.0023, "epss_percentile": 0.45675}, "CVE-2024-11839": {"epss_score": 0.0013, "epss_percentile": 0.33239}, "CVE-2024-11840": {"epss_score": 0.00205, "epss_percentile": 0.42674}, "CVE-2024-11841": {"epss_score": 0.00069, "epss_percentile": 0.21635}, "CVE-2024-11842": {"epss_score": 0.00015, "epss_percentile": 0.02159}, "CVE-2024-11843": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-11844": {"epss_score": 0.00094, "epss_percentile": 0.27027}, "CVE-2024-11846": {"epss_score": 0.00021, "epss_percentile": 0.04696}, "CVE-2024-11847": {"epss_score": 0.00066, "epss_percentile": 0.20824}, "CVE-2024-11848": {"epss_score": 0.04249, "epss_percentile": 0.88449}, "CVE-2024-11849": {"epss_score": 0.00077, "epss_percentile": 0.23294}, "CVE-2024-11850": {"epss_score": 0.00069, "epss_percentile": 0.21599}, "CVE-2024-11851": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-11852": {"epss_score": 0.00149, "epss_percentile": 0.35964}, "CVE-2024-11853": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-11854": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-11855": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11856": {"epss_score": 0.00255, "epss_percentile": 0.4865}, "CVE-2024-11857": {"epss_score": 0.00027, "epss_percentile": 0.06948}, "CVE-2024-11858": {"epss_score": 0.00092, "epss_percentile": 0.26442}, "CVE-2024-11859": {"epss_score": 0.00039, "epss_percentile": 0.11768}, "CVE-2024-11860": {"epss_score": 0.00152, "epss_percentile": 0.36501}, "CVE-2024-11861": {"epss_score": 0.00278, "epss_percentile": 0.50867}, "CVE-2024-11862": {"epss_score": 0.00026, "epss_percentile": 0.06714}, "CVE-2024-11863": {"epss_score": 0.00141, "epss_percentile": 0.34833}, "CVE-2024-11864": {"epss_score": 0.0024, "epss_percentile": 0.4723}, "CVE-2024-11865": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11866": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11867": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11868": {"epss_score": 0.00589, "epss_percentile": 0.68519}, "CVE-2024-11869": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11870": {"epss_score": 0.00133, "epss_percentile": 0.33674}, "CVE-2024-11871": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11872": {"epss_score": 0.00025, "epss_percentile": 0.06066}, "CVE-2024-11873": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11874": {"epss_score": 0.00124, "epss_percentile": 0.32414}, "CVE-2024-11875": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11876": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11877": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11878": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11880": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-11881": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11882": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11883": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11884": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11885": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11886": {"epss_score": 0.00133, "epss_percentile": 0.33676}, "CVE-2024-11887": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11888": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11889": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11891": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11892": {"epss_score": 0.00169, "epss_percentile": 0.3864}, "CVE-2024-11893": {"epss_score": 0.00039, "epss_percentile": 0.11612}, "CVE-2024-11894": {"epss_score": 0.00034, "epss_percentile": 0.0948}, "CVE-2024-11895": {"epss_score": 0.00161, "epss_percentile": 0.37576}, "CVE-2024-11896": {"epss_score": 0.00034, "epss_percentile": 0.0948}, "CVE-2024-11897": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-11898": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-11899": {"epss_score": 0.00124, "epss_percentile": 0.32414}, "CVE-2024-11900": {"epss_score": 0.00034, "epss_percentile": 0.0948}, "CVE-2024-11901": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11902": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11903": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11904": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-11905": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-11906": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11907": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11910": {"epss_score": 0.00083, "epss_percentile": 0.24726}, "CVE-2024-11911": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-11912": {"epss_score": 0.00954, "epss_percentile": 0.75906}, "CVE-2024-11913": {"epss_score": 0.00071, "epss_percentile": 0.22115}, "CVE-2024-11914": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-11915": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-11916": {"epss_score": 0.00051, "epss_percentile": 0.16165}, "CVE-2024-11917": {"epss_score": 0.00195, "epss_percentile": 0.41675}, "CVE-2024-11918": {"epss_score": 0.00085, "epss_percentile": 0.25096}, "CVE-2024-11919": {"epss_score": 0.00083, "epss_percentile": 0.24733}, "CVE-2024-11920": {"epss_score": 0.00097, "epss_percentile": 0.27502}, "CVE-2024-11921": {"epss_score": 0.01006, "epss_percentile": 0.76554}, "CVE-2024-11922": {"epss_score": 0.00027, "epss_percentile": 0.07114}, "CVE-2024-11923": {"epss_score": 0.00035, "epss_percentile": 0.09898}, "CVE-2024-11924": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2024-11925": {"epss_score": 0.00106, "epss_percentile": 0.29562}, "CVE-2024-11926": {"epss_score": 0.00116, "epss_percentile": 0.31102}, "CVE-2024-11928": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-11929": {"epss_score": 0.00081, "epss_percentile": 0.2436}, "CVE-2024-11930": {"epss_score": 0.00089, "epss_percentile": 0.25877}, "CVE-2024-11931": {"epss_score": 0.0003, "epss_percentile": 0.08252}, "CVE-2024-11933": {"epss_score": 0.01001, "epss_percentile": 0.76499}, "CVE-2024-11934": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11935": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-11936": {"epss_score": 0.00201, "epss_percentile": 0.4233}, "CVE-2024-11937": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2024-11938": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-11939": {"epss_score": 0.01677, "epss_percentile": 0.81712}, "CVE-2024-11940": {"epss_score": 0.00124, "epss_percentile": 0.32414}, "CVE-2024-11941": {"epss_score": 0.00174, "epss_percentile": 0.39159}, "CVE-2024-11942": {"epss_score": 0.00586, "epss_percentile": 0.6844}, "CVE-2024-11943": {"epss_score": 0.00882, "epss_percentile": 0.74886}, "CVE-2024-11944": {"epss_score": 0.00128, "epss_percentile": 0.33067}, "CVE-2024-11945": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-11946": {"epss_score": 0.00021, "epss_percentile": 0.04817}, "CVE-2024-11947": {"epss_score": 0.02218, "epss_percentile": 0.8404}, "CVE-2024-11948": {"epss_score": 0.01162, "epss_percentile": 0.78154}, "CVE-2024-11949": {"epss_score": 0.02218, "epss_percentile": 0.8404}, "CVE-2024-11950": {"epss_score": 0.00259, "epss_percentile": 0.49042}, "CVE-2024-11951": {"epss_score": 0.00364, "epss_percentile": 0.57941}, "CVE-2024-11952": {"epss_score": 0.00897, "epss_percentile": 0.75121}, "CVE-2024-11954": {"epss_score": 0.00088, "epss_percentile": 0.25669}, "CVE-2024-11955": {"epss_score": 0.00153, "epss_percentile": 0.36563}, "CVE-2024-11956": {"epss_score": 3e-05, "epss_percentile": 0.00104}, "CVE-2024-11957": {"epss_score": 0.00021, "epss_percentile": 0.0486}, "CVE-2024-11958": {"epss_score": 0.01102, "epss_percentile": 0.77585}, "CVE-2024-11959": {"epss_score": 0.03705, "epss_percentile": 0.87596}, "CVE-2024-11960": {"epss_score": 0.03705, "epss_percentile": 0.87596}, "CVE-2024-11961": {"epss_score": 0.00092, "epss_percentile": 0.26578}, "CVE-2024-11962": {"epss_score": 0.00054, "epss_percentile": 0.17262}, "CVE-2024-11963": {"epss_score": 0.00039, "epss_percentile": 0.1159}, "CVE-2024-11964": {"epss_score": 0.00023, "epss_percentile": 0.05375}, "CVE-2024-11965": {"epss_score": 0.00023, "epss_percentile": 0.05375}, "CVE-2024-11966": {"epss_score": 0.00023, "epss_percentile": 0.05375}, "CVE-2024-11967": {"epss_score": 0.00022, "epss_percentile": 0.05287}, "CVE-2024-11968": {"epss_score": 0.00017, "epss_percentile": 0.03269}, "CVE-2024-11969": {"epss_score": 0.00028, "epss_percentile": 0.07242}, "CVE-2024-11970": {"epss_score": 0.00021, "epss_percentile": 0.04907}, "CVE-2024-11971": {"epss_score": 0.00091, "epss_percentile": 0.26394}, "CVE-2024-11972": {"epss_score": 0.91677, "epss_percentile": 0.99662}, "CVE-2024-11973": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-11974": {"epss_score": 0.01435, "epss_percentile": 0.80269}, "CVE-2024-11975": {"epss_score": 0.00053, "epss_percentile": 0.16882}, "CVE-2024-11977": {"epss_score": 0.02432, "epss_percentile": 0.84731}, "CVE-2024-11978": {"epss_score": 0.0007, "epss_percentile": 0.21826}, "CVE-2024-11979": {"epss_score": 0.01961, "epss_percentile": 0.83062}, "CVE-2024-11980": {"epss_score": 0.00819, "epss_percentile": 0.73867}, "CVE-2024-11981": {"epss_score": 0.00015, "epss_percentile": 0.02148}, "CVE-2024-11982": {"epss_score": 0.00233, "epss_percentile": 0.46027}, "CVE-2024-11983": {"epss_score": 0.00358, "epss_percentile": 0.57527}, "CVE-2024-11984": {"epss_score": 0.00137, "epss_percentile": 0.34241}, "CVE-2024-11985": {"epss_score": 0.00108, "epss_percentile": 0.29853}, "CVE-2024-11986": {"epss_score": 0.01108, "epss_percentile": 0.77642}, "CVE-2024-11990": {"epss_score": 0.00055, "epss_percentile": 0.17629}, "CVE-2024-11991": {"epss_score": 0.00058, "epss_percentile": 0.18546}, "CVE-2024-11992": {"epss_score": 0.00113, "epss_percentile": 0.30668}, "CVE-2024-11993": {"epss_score": 0.00073, "epss_percentile": 0.22579}, "CVE-2024-11994": {"epss_score": 0.00024, "epss_percentile": 0.05885}, "CVE-2024-11995": {"epss_score": 0.00169, "epss_percentile": 0.38528}, "CVE-2024-11996": {"epss_score": 0.00172, "epss_percentile": 0.3894}, "CVE-2024-11997": {"epss_score": 0.00172, "epss_percentile": 0.3894}, "CVE-2024-11998": {"epss_score": 0.00063, "epss_percentile": 0.19935}, "CVE-2024-11999": {"epss_score": 0.00243, "epss_percentile": 0.47499}, "CVE-2024-12000": {"epss_score": 0.00108, "epss_percentile": 0.29882}, "CVE-2024-12001": {"epss_score": 0.00108, "epss_percentile": 0.29882}, "CVE-2024-12002": {"epss_score": 0.0006, "epss_percentile": 0.19132}, "CVE-2024-12003": {"epss_score": 0.00049, "epss_percentile": 0.15346}, "CVE-2024-12004": {"epss_score": 0.0006, "epss_percentile": 0.19064}, "CVE-2024-12005": {"epss_score": 0.0006, "epss_percentile": 0.19065}, "CVE-2024-12006": {"epss_score": 0.00828, "epss_percentile": 0.74004}, "CVE-2024-12007": {"epss_score": 0.00125, "epss_percentile": 0.32558}, "CVE-2024-12008": {"epss_score": 0.37773, "epss_percentile": 0.97068}, "CVE-2024-12009": {"epss_score": 0.00625, "epss_percentile": 0.69596}, "CVE-2024-12010": {"epss_score": 0.00625, "epss_percentile": 0.69596}, "CVE-2024-12011": {"epss_score": 0.00311, "epss_percentile": 0.53809}, "CVE-2024-12012": {"epss_score": 0.00112, "epss_percentile": 0.30428}, "CVE-2024-12013": {"epss_score": 0.00205, "epss_percentile": 0.42719}, "CVE-2024-12014": {"epss_score": 0.00185, "epss_percentile": 0.40566}, "CVE-2024-12015": {"epss_score": 0.00374, "epss_percentile": 0.58588}, "CVE-2024-12016": {"epss_score": 0.00093, "epss_percentile": 0.26629}, "CVE-2024-12018": {"epss_score": 0.00112, "epss_percentile": 0.3053}, "CVE-2024-12019": {"epss_score": 0.00208, "epss_percentile": 0.43262}, "CVE-2024-12020": {"epss_score": 0.00303, "epss_percentile": 0.53214}, "CVE-2024-12021": {"epss_score": 0.00081, "epss_percentile": 0.24342}, "CVE-2024-12023": {"epss_score": 0.00031, "epss_percentile": 0.08664}, "CVE-2024-12024": {"epss_score": 0.00247, "epss_percentile": 0.4781}, "CVE-2024-12025": {"epss_score": 0.27891, "epss_percentile": 0.96292}, "CVE-2024-12026": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12027": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12028": {"epss_score": 0.00358, "epss_percentile": 0.57506}, "CVE-2024-12029": {"epss_score": 0.44096, "epss_percentile": 0.97419}, "CVE-2024-12030": {"epss_score": 0.00241, "epss_percentile": 0.47247}, "CVE-2024-12031": {"epss_score": 0.00067, "epss_percentile": 0.21016}, "CVE-2024-12032": {"epss_score": 0.00225, "epss_percentile": 0.45103}, "CVE-2024-12033": {"epss_score": 0.00102, "epss_percentile": 0.2876}, "CVE-2024-12034": {"epss_score": 0.00393, "epss_percentile": 0.59748}, "CVE-2024-12035": {"epss_score": 0.01661, "epss_percentile": 0.81626}, "CVE-2024-12036": {"epss_score": 0.00179, "epss_percentile": 0.39838}, "CVE-2024-12037": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-12038": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-12039": {"epss_score": 0.00382, "epss_percentile": 0.59069}, "CVE-2024-12040": {"epss_score": 0.00348, "epss_percentile": 0.5681}, "CVE-2024-12041": {"epss_score": 0.00307, "epss_percentile": 0.53497}, "CVE-2024-12042": {"epss_score": 0.00079, "epss_percentile": 0.23975}, "CVE-2024-12043": {"epss_score": 0.00056, "epss_percentile": 0.17765}, "CVE-2024-12044": {"epss_score": 0.01315, "epss_percentile": 0.79402}, "CVE-2024-12045": {"epss_score": 0.00109, "epss_percentile": 0.30031}, "CVE-2024-12046": {"epss_score": 0.00128, "epss_percentile": 0.32948}, "CVE-2024-12047": {"epss_score": 0.00882, "epss_percentile": 0.74886}, "CVE-2024-12048": {"epss_score": 0.00091, "epss_percentile": 0.26404}, "CVE-2024-12049": {"epss_score": 0.00986, "epss_percentile": 0.76335}, "CVE-2024-12053": {"epss_score": 0.00242, "epss_percentile": 0.47334}, "CVE-2024-12054": {"epss_score": 0.00036, "epss_percentile": 0.1049}, "CVE-2024-12055": {"epss_score": 0.00198, "epss_percentile": 0.4199}, "CVE-2024-12056": {"epss_score": 0.00115, "epss_percentile": 0.31012}, "CVE-2024-12057": {"epss_score": 0.00034, "epss_percentile": 0.09747}, "CVE-2024-12058": {"epss_score": 0.01687, "epss_percentile": 0.81755}, "CVE-2024-12059": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-12060": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-12061": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-12062": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-12063": {"epss_score": 0.00205, "epss_percentile": 0.42764}, "CVE-2024-12065": {"epss_score": 0.00109, "epss_percentile": 0.30062}, "CVE-2024-12066": {"epss_score": 0.03729, "epss_percentile": 0.87637}, "CVE-2024-12067": {"epss_score": 0.00259, "epss_percentile": 0.49085}, "CVE-2024-12068": {"epss_score": 0.00098, "epss_percentile": 0.27702}, "CVE-2024-12069": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2024-12070": {"epss_score": 0.00329, "epss_percentile": 0.55385}, "CVE-2024-12071": {"epss_score": 0.00092, "epss_percentile": 0.26536}, "CVE-2024-12072": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12073": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-12074": {"epss_score": 0.00101, "epss_percentile": 0.28676}, "CVE-2024-12076": {"epss_score": 0.00507, "epss_percentile": 0.65647}, "CVE-2024-12077": {"epss_score": 0.00944, "epss_percentile": 0.75786}, "CVE-2024-12078": {"epss_score": 0.00077, "epss_percentile": 0.23387}, "CVE-2024-12079": {"epss_score": 0.00019, "epss_percentile": 0.04099}, "CVE-2024-12082": {"epss_score": 0.00038, "epss_percentile": 0.11274}, "CVE-2024-12083": {"epss_score": 0.00183, "epss_percentile": 0.40338}, "CVE-2024-12084": {"epss_score": 0.0507, "epss_percentile": 0.89463}, "CVE-2024-12085": {"epss_score": 0.13041, "epss_percentile": 0.93853}, "CVE-2024-12086": {"epss_score": 0.00473, "epss_percentile": 0.64098}, "CVE-2024-12087": {"epss_score": 0.02361, "epss_percentile": 0.84496}, "CVE-2024-12088": {"epss_score": 0.02533, "epss_percentile": 0.85031}, "CVE-2024-12089": {"epss_score": 0.00239, "epss_percentile": 0.46875}, "CVE-2024-12090": {"epss_score": 0.00239, "epss_percentile": 0.46875}, "CVE-2024-12091": {"epss_score": 0.00239, "epss_percentile": 0.46875}, "CVE-2024-12092": {"epss_score": 0.00239, "epss_percentile": 0.46875}, "CVE-2024-12093": {"epss_score": 0.00016, "epss_percentile": 0.02914}, "CVE-2024-12094": {"epss_score": 0.00039, "epss_percentile": 0.11729}, "CVE-2024-12096": {"epss_score": 0.00077, "epss_percentile": 0.23294}, "CVE-2024-12097": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2024-12098": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12099": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-12100": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-12102": {"epss_score": 0.00085, "epss_percentile": 0.25154}, "CVE-2024-12103": {"epss_score": 0.00098, "epss_percentile": 0.27664}, "CVE-2024-12104": {"epss_score": 0.00293, "epss_percentile": 0.52306}, "CVE-2024-12105": {"epss_score": 0.00319, "epss_percentile": 0.54568}, "CVE-2024-12106": {"epss_score": 0.04526, "epss_percentile": 0.88806}, "CVE-2024-12107": {"epss_score": 0.00377, "epss_percentile": 0.58749}, "CVE-2024-12108": {"epss_score": 0.01131, "epss_percentile": 0.77865}, "CVE-2024-12109": {"epss_score": 0.00079, "epss_percentile": 0.23985}, "CVE-2024-12110": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12111": {"epss_score": 0.00163, "epss_percentile": 0.37763}, "CVE-2024-12112": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12113": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12114": {"epss_score": 0.00113, "epss_percentile": 0.30668}, "CVE-2024-12115": {"epss_score": 0.00033, "epss_percentile": 0.0933}, "CVE-2024-12116": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-12117": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-12118": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-12119": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-12120": {"epss_score": 0.00024, "epss_percentile": 0.05887}, "CVE-2024-12121": {"epss_score": 0.00093, "epss_percentile": 0.26665}, "CVE-2024-12122": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12123": {"epss_score": 0.00064, "epss_percentile": 0.20366}, "CVE-2024-12125": {"epss_score": 0.0004, "epss_percentile": 0.1204}, "CVE-2024-12126": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12127": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-12128": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12129": {"epss_score": 0.00176, "epss_percentile": 0.39416}, "CVE-2024-12130": {"epss_score": 0.00027, "epss_percentile": 0.06847}, "CVE-2024-12131": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12132": {"epss_score": 0.00677, "epss_percentile": 0.70967}, "CVE-2024-12133": {"epss_score": 0.00411, "epss_percentile": 0.60876}, "CVE-2024-12136": {"epss_score": 0.0002, "epss_percentile": 0.04465}, "CVE-2024-12137": {"epss_score": 0.00035, "epss_percentile": 0.09854}, "CVE-2024-12138": {"epss_score": 0.00229, "epss_percentile": 0.45592}, "CVE-2024-12140": {"epss_score": 0.00161, "epss_percentile": 0.37524}, "CVE-2024-12142": {"epss_score": 0.00187, "epss_percentile": 0.40743}, "CVE-2024-12143": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2024-12144": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2024-12146": {"epss_score": 0.00091, "epss_percentile": 0.26239}, "CVE-2024-12147": {"epss_score": 0.00215, "epss_percentile": 0.44105}, "CVE-2024-12148": {"epss_score": 0.00094, "epss_percentile": 0.26802}, "CVE-2024-12149": {"epss_score": 0.00101, "epss_percentile": 0.28713}, "CVE-2024-12150": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2024-12151": {"epss_score": 0.00111, "epss_percentile": 0.30356}, "CVE-2024-12152": {"epss_score": 0.0619, "epss_percentile": 0.90547}, "CVE-2024-12153": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12155": {"epss_score": 0.04839, "epss_percentile": 0.89197}, "CVE-2024-12156": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-12157": {"epss_score": 0.22913, "epss_percentile": 0.95705}, "CVE-2024-12158": {"epss_score": 0.00245, "epss_percentile": 0.47695}, "CVE-2024-12159": {"epss_score": 0.00328, "epss_percentile": 0.55284}, "CVE-2024-12160": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-12162": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-12163": {"epss_score": 0.00029, "epss_percentile": 0.07942}, "CVE-2024-12164": {"epss_score": 0.00128, "epss_percentile": 0.32956}, "CVE-2024-12165": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12166": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12167": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12168": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2024-12169": {"epss_score": 0.00093, "epss_percentile": 0.26614}, "CVE-2024-12170": {"epss_score": 0.00033, "epss_percentile": 0.09305}, "CVE-2024-12171": {"epss_score": 0.00208, "epss_percentile": 0.4328}, "CVE-2024-12172": {"epss_score": 0.131, "epss_percentile": 0.93875}, "CVE-2024-12173": {"epss_score": 0.00087, "epss_percentile": 0.25514}, "CVE-2024-12174": {"epss_score": 0.00058, "epss_percentile": 0.18548}, "CVE-2024-12175": {"epss_score": 0.00023, "epss_percentile": 0.05387}, "CVE-2024-12176": {"epss_score": 0.00293, "epss_percentile": 0.52293}, "CVE-2024-12177": {"epss_score": 0.00456, "epss_percentile": 0.6334}, "CVE-2024-12178": {"epss_score": 0.00031, "epss_percentile": 0.08573}, "CVE-2024-12179": {"epss_score": 0.00031, "epss_percentile": 0.08573}, "CVE-2024-12180": {"epss_score": 0.00025, "epss_percentile": 0.06297}, "CVE-2024-12181": {"epss_score": 0.00085, "epss_percentile": 0.25067}, "CVE-2024-12182": {"epss_score": 0.00085, "epss_percentile": 0.25067}, "CVE-2024-12183": {"epss_score": 0.00085, "epss_percentile": 0.25067}, "CVE-2024-12184": {"epss_score": 0.00328, "epss_percentile": 0.5526}, "CVE-2024-12185": {"epss_score": 0.00045, "epss_percentile": 0.1377}, "CVE-2024-12186": {"epss_score": 0.00045, "epss_percentile": 0.1377}, "CVE-2024-12187": {"epss_score": 0.00127, "epss_percentile": 0.32834}, "CVE-2024-12188": {"epss_score": 0.00124, "epss_percentile": 0.32437}, "CVE-2024-12189": {"epss_score": 0.00053, "epss_percentile": 0.16992}, "CVE-2024-12190": {"epss_score": 0.00137, "epss_percentile": 0.34289}, "CVE-2024-12191": {"epss_score": 0.00083, "epss_percentile": 0.24756}, "CVE-2024-12192": {"epss_score": 0.00083, "epss_percentile": 0.24756}, "CVE-2024-12193": {"epss_score": 0.00083, "epss_percentile": 0.24756}, "CVE-2024-12194": {"epss_score": 0.00083, "epss_percentile": 0.24756}, "CVE-2024-12195": {"epss_score": 0.00241, "epss_percentile": 0.47247}, "CVE-2024-12196": {"epss_score": 0.00118, "epss_percentile": 0.31503}, "CVE-2024-12197": {"epss_score": 0.00083, "epss_percentile": 0.24756}, "CVE-2024-12198": {"epss_score": 0.00083, "epss_percentile": 0.24756}, "CVE-2024-12199": {"epss_score": 0.00083, "epss_percentile": 0.24756}, "CVE-2024-12200": {"epss_score": 0.00083, "epss_percentile": 0.24756}, "CVE-2024-12201": {"epss_score": 0.00116, "epss_percentile": 0.31168}, "CVE-2024-12202": {"epss_score": 0.00137, "epss_percentile": 0.34205}, "CVE-2024-12203": {"epss_score": 0.00127, "epss_percentile": 0.32895}, "CVE-2024-12204": {"epss_score": 0.00097, "epss_percentile": 0.27543}, "CVE-2024-12205": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-12206": {"epss_score": 0.00033, "epss_percentile": 0.09328}, "CVE-2024-12207": {"epss_score": 0.0011, "epss_percentile": 0.30118}, "CVE-2024-12209": {"epss_score": 0.84517, "epss_percentile": 0.99293}, "CVE-2024-12210": {"epss_score": 0.00097, "epss_percentile": 0.27631}, "CVE-2024-12211": {"epss_score": 0.00093, "epss_percentile": 0.26745}, "CVE-2024-12212": {"epss_score": 0.00034, "epss_percentile": 0.09669}, "CVE-2024-12213": {"epss_score": 0.00482, "epss_percentile": 0.64555}, "CVE-2024-12214": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12215": {"epss_score": 0.00502, "epss_percentile": 0.6537}, "CVE-2024-12216": {"epss_score": 0.00039, "epss_percentile": 0.11585}, "CVE-2024-12217": {"epss_score": 0.0012, "epss_percentile": 0.31696}, "CVE-2024-12218": {"epss_score": 0.00053, "epss_percentile": 0.16883}, "CVE-2024-12219": {"epss_score": 0.00061, "epss_percentile": 0.19264}, "CVE-2024-12220": {"epss_score": 0.00053, "epss_percentile": 0.16883}, "CVE-2024-12221": {"epss_score": 0.00843, "epss_percentile": 0.74266}, "CVE-2024-12222": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12223": {"epss_score": 0.00091, "epss_percentile": 0.26264}, "CVE-2024-12224": {"epss_score": 0.00039, "epss_percentile": 0.11475}, "CVE-2024-12225": {"epss_score": 0.00042, "epss_percentile": 0.12803}, "CVE-2024-12226": {"epss_score": 0.00118, "epss_percentile": 0.31431}, "CVE-2024-12227": {"epss_score": 0.00031, "epss_percentile": 0.08386}, "CVE-2024-12228": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12229": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12230": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12231": {"epss_score": 0.00136, "epss_percentile": 0.34169}, "CVE-2024-12232": {"epss_score": 0.00098, "epss_percentile": 0.27745}, "CVE-2024-12233": {"epss_score": 0.00074, "epss_percentile": 0.22861}, "CVE-2024-12234": {"epss_score": 0.00035, "epss_percentile": 0.10087}, "CVE-2024-12235": {"epss_score": 0.00072, "epss_percentile": 0.22428}, "CVE-2024-12236": {"epss_score": 0.00014, "epss_percentile": 0.01896}, "CVE-2024-12237": {"epss_score": 0.00137, "epss_percentile": 0.34289}, "CVE-2024-12238": {"epss_score": 0.0037, "epss_percentile": 0.58332}, "CVE-2024-12239": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12240": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-12243": {"epss_score": 0.00526, "epss_percentile": 0.66426}, "CVE-2024-12244": {"epss_score": 0.00026, "epss_percentile": 0.06384}, "CVE-2024-12245": {"epss_score": 0.00483, "epss_percentile": 0.64616}, "CVE-2024-12247": {"epss_score": 0.0006, "epss_percentile": 0.19116}, "CVE-2024-12248": {"epss_score": 0.00877, "epss_percentile": 0.74815}, "CVE-2024-12249": {"epss_score": 0.00101, "epss_percentile": 0.28635}, "CVE-2024-12250": {"epss_score": 0.00328, "epss_percentile": 0.55284}, "CVE-2024-12251": {"epss_score": 0.0003, "epss_percentile": 0.08231}, "CVE-2024-12252": {"epss_score": 0.47167, "epss_percentile": 0.97571}, "CVE-2024-12253": {"epss_score": 0.00229, "epss_percentile": 0.45608}, "CVE-2024-12254": {"epss_score": 0.00345, "epss_percentile": 0.56561}, "CVE-2024-12255": {"epss_score": 0.00139, "epss_percentile": 0.3455}, "CVE-2024-12256": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12257": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12258": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12259": {"epss_score": 0.00228, "epss_percentile": 0.45529}, "CVE-2024-12260": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12261": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12262": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12263": {"epss_score": 0.00029, "epss_percentile": 0.07758}, "CVE-2024-12264": {"epss_score": 0.00374, "epss_percentile": 0.58563}, "CVE-2024-12265": {"epss_score": 0.00155, "epss_percentile": 0.36777}, "CVE-2024-12266": {"epss_score": 0.00368, "epss_percentile": 0.58189}, "CVE-2024-12267": {"epss_score": 0.00661, "epss_percentile": 0.70585}, "CVE-2024-12268": {"epss_score": 0.00025, "epss_percentile": 0.06311}, "CVE-2024-12269": {"epss_score": 0.00423, "epss_percentile": 0.61582}, "CVE-2024-12270": {"epss_score": 0.6849, "epss_percentile": 0.9855}, "CVE-2024-12271": {"epss_score": 0.00143, "epss_percentile": 0.35099}, "CVE-2024-12272": {"epss_score": 0.00844, "epss_percentile": 0.74273}, "CVE-2024-12273": {"epss_score": 0.00034, "epss_percentile": 0.09564}, "CVE-2024-12274": {"epss_score": 0.00067, "epss_percentile": 0.21048}, "CVE-2024-12275": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-12276": {"epss_score": 0.00079, "epss_percentile": 0.23819}, "CVE-2024-12278": {"epss_score": 0.00241, "epss_percentile": 0.47263}, "CVE-2024-12279": {"epss_score": 0.00057, "epss_percentile": 0.18056}, "CVE-2024-12280": {"epss_score": 0.00017, "epss_percentile": 0.03449}, "CVE-2024-12281": {"epss_score": 0.00364, "epss_percentile": 0.57941}, "CVE-2024-12282": {"epss_score": 0.00015, "epss_percentile": 0.02213}, "CVE-2024-12283": {"epss_score": 0.00843, "epss_percentile": 0.74266}, "CVE-2024-12284": {"epss_score": 0.00179, "epss_percentile": 0.39795}, "CVE-2024-12285": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12286": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-12287": {"epss_score": 0.01292, "epss_percentile": 0.79233}, "CVE-2024-12288": {"epss_score": 0.00053, "epss_percentile": 0.16882}, "CVE-2024-12289": {"epss_score": 0.00196, "epss_percentile": 0.41803}, "CVE-2024-12290": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12291": {"epss_score": 0.00049, "epss_percentile": 0.15346}, "CVE-2024-12292": {"epss_score": 0.00019, "epss_percentile": 0.04133}, "CVE-2024-12293": {"epss_score": 0.00061, "epss_percentile": 0.19486}, "CVE-2024-12294": {"epss_score": 0.00366, "epss_percentile": 0.58074}, "CVE-2024-12295": {"epss_score": 0.00131, "epss_percentile": 0.33366}, "CVE-2024-12296": {"epss_score": 0.00176, "epss_percentile": 0.39416}, "CVE-2024-12297": {"epss_score": 0.00258, "epss_percentile": 0.49025}, "CVE-2024-12298": {"epss_score": 0.00038, "epss_percentile": 0.11213}, "CVE-2024-12299": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2024-12300": {"epss_score": 0.00272, "epss_percentile": 0.50419}, "CVE-2024-12301": {"epss_score": 0.00017, "epss_percentile": 0.0342}, "CVE-2024-12302": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-12303": {"epss_score": 0.0002, "epss_percentile": 0.04474}, "CVE-2024-12304": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-12305": {"epss_score": 0.00107, "epss_percentile": 0.29731}, "CVE-2024-12306": {"epss_score": 0.00107, "epss_percentile": 0.29731}, "CVE-2024-12307": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2024-12308": {"epss_score": 0.00083, "epss_percentile": 0.24795}, "CVE-2024-12309": {"epss_score": 0.00134, "epss_percentile": 0.33871}, "CVE-2024-12310": {"epss_score": 0.0003, "epss_percentile": 0.08279}, "CVE-2024-12311": {"epss_score": 0.00068, "epss_percentile": 0.212}, "CVE-2024-12312": {"epss_score": 0.07235, "epss_percentile": 0.9134}, "CVE-2024-12313": {"epss_score": 0.05396, "epss_percentile": 0.89828}, "CVE-2024-12314": {"epss_score": 0.00289, "epss_percentile": 0.52002}, "CVE-2024-12315": {"epss_score": 0.00406, "epss_percentile": 0.60524}, "CVE-2024-12316": {"epss_score": 0.00383, "epss_percentile": 0.59089}, "CVE-2024-12320": {"epss_score": 0.0059, "epss_percentile": 0.68573}, "CVE-2024-12321": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-12322": {"epss_score": 0.00061, "epss_percentile": 0.19486}, "CVE-2024-12323": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-12324": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12325": {"epss_score": 0.01341, "epss_percentile": 0.79587}, "CVE-2024-12326": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2024-12327": {"epss_score": 0.00094, "epss_percentile": 0.27027}, "CVE-2024-12328": {"epss_score": 0.00055, "epss_percentile": 0.17622}, "CVE-2024-12329": {"epss_score": 0.00165, "epss_percentile": 0.38122}, "CVE-2024-12330": {"epss_score": 0.0104, "epss_percentile": 0.76959}, "CVE-2024-12331": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12332": {"epss_score": 0.00252, "epss_percentile": 0.48413}, "CVE-2024-12333": {"epss_score": 0.01426, "epss_percentile": 0.80206}, "CVE-2024-12334": {"epss_score": 0.0084, "epss_percentile": 0.74209}, "CVE-2024-12335": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-12336": {"epss_score": 0.00125, "epss_percentile": 0.32544}, "CVE-2024-12337": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12338": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12339": {"epss_score": 0.00676, "epss_percentile": 0.70919}, "CVE-2024-12340": {"epss_score": 0.00139, "epss_percentile": 0.34543}, "CVE-2024-12341": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12342": {"epss_score": 0.01417, "epss_percentile": 0.80147}, "CVE-2024-12343": {"epss_score": 0.00416, "epss_percentile": 0.61173}, "CVE-2024-12344": {"epss_score": 0.01418, "epss_percentile": 0.80156}, "CVE-2024-12345": {"epss_score": 0.00048, "epss_percentile": 0.15241}, "CVE-2024-12346": {"epss_score": 0.00072, "epss_percentile": 0.2243}, "CVE-2024-12347": {"epss_score": 0.00217, "epss_percentile": 0.44333}, "CVE-2024-12348": {"epss_score": 0.00092, "epss_percentile": 0.26559}, "CVE-2024-12349": {"epss_score": 0.00038, "epss_percentile": 0.1129}, "CVE-2024-12350": {"epss_score": 0.0475, "epss_percentile": 0.89102}, "CVE-2024-12351": {"epss_score": 0.00125, "epss_percentile": 0.32498}, "CVE-2024-12352": {"epss_score": 0.00392, "epss_percentile": 0.59692}, "CVE-2024-12353": {"epss_score": 0.00041, "epss_percentile": 0.12315}, "CVE-2024-12354": {"epss_score": 0.00045, "epss_percentile": 0.13988}, "CVE-2024-12355": {"epss_score": 0.00036, "epss_percentile": 0.10306}, "CVE-2024-12356": {"epss_score": 0.93687, "epss_percentile": 0.99834}, "CVE-2024-12357": {"epss_score": 0.00132, "epss_percentile": 0.33604}, "CVE-2024-12358": {"epss_score": 0.03376, "epss_percentile": 0.8702}, "CVE-2024-12359": {"epss_score": 0.00114, "epss_percentile": 0.30785}, "CVE-2024-12360": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2024-12362": {"epss_score": 0.00252, "epss_percentile": 0.48373}, "CVE-2024-12363": {"epss_score": 0.00021, "epss_percentile": 0.04773}, "CVE-2024-12364": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2024-12365": {"epss_score": 0.13772, "epss_percentile": 0.94055}, "CVE-2024-12366": {"epss_score": 0.01216, "epss_percentile": 0.78593}, "CVE-2024-12367": {"epss_score": 0.00057, "epss_percentile": 0.18089}, "CVE-2024-12368": {"epss_score": 0.00126, "epss_percentile": 0.32726}, "CVE-2024-12369": {"epss_score": 0.0014, "epss_percentile": 0.34731}, "CVE-2024-12370": {"epss_score": 0.00239, "epss_percentile": 0.46924}, "CVE-2024-12371": {"epss_score": 0.00131, "epss_percentile": 0.33361}, "CVE-2024-12372": {"epss_score": 0.01212, "epss_percentile": 0.78563}, "CVE-2024-12373": {"epss_score": 0.00179, "epss_percentile": 0.3977}, "CVE-2024-12374": {"epss_score": 0.00056, "epss_percentile": 0.17762}, "CVE-2024-12375": {"epss_score": 0.00104, "epss_percentile": 0.29237}, "CVE-2024-12376": {"epss_score": 0.00111, "epss_percentile": 0.30257}, "CVE-2024-12378": {"epss_score": 0.00025, "epss_percentile": 0.0604}, "CVE-2024-12379": {"epss_score": 0.00115, "epss_percentile": 0.30998}, "CVE-2024-12380": {"epss_score": 0.00022, "epss_percentile": 0.05308}, "CVE-2024-12381": {"epss_score": 0.00415, "epss_percentile": 0.61133}, "CVE-2024-12382": {"epss_score": 0.00475, "epss_percentile": 0.64193}, "CVE-2024-12383": {"epss_score": 0.0006, "epss_percentile": 0.19065}, "CVE-2024-12384": {"epss_score": 0.00882, "epss_percentile": 0.74886}, "CVE-2024-12385": {"epss_score": 0.00067, "epss_percentile": 0.21083}, "CVE-2024-12386": {"epss_score": 0.00047, "epss_percentile": 0.14663}, "CVE-2024-12387": {"epss_score": 0.00063, "epss_percentile": 0.20048}, "CVE-2024-12388": {"epss_score": 0.00077, "epss_percentile": 0.23416}, "CVE-2024-12389": {"epss_score": 0.02169, "epss_percentile": 0.83866}, "CVE-2024-12390": {"epss_score": 0.02169, "epss_percentile": 0.83866}, "CVE-2024-12391": {"epss_score": 0.00179, "epss_percentile": 0.39801}, "CVE-2024-12392": {"epss_score": 0.00068, "epss_percentile": 0.21271}, "CVE-2024-12393": {"epss_score": 0.00509, "epss_percentile": 0.65746}, "CVE-2024-12394": {"epss_score": 0.00049, "epss_percentile": 0.15345}, "CVE-2024-12395": {"epss_score": 0.01665, "epss_percentile": 0.81646}, "CVE-2024-12397": {"epss_score": 0.00397, "epss_percentile": 0.6002}, "CVE-2024-12398": {"epss_score": 0.00193, "epss_percentile": 0.41392}, "CVE-2024-12399": {"epss_score": 0.00053, "epss_percentile": 0.16971}, "CVE-2024-12400": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-12401": {"epss_score": 0.00424, "epss_percentile": 0.61657}, "CVE-2024-12402": {"epss_score": 0.00374, "epss_percentile": 0.58563}, "CVE-2024-12403": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-12404": {"epss_score": 0.31983, "epss_percentile": 0.96664}, "CVE-2024-12405": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12406": {"epss_score": 0.00203, "epss_percentile": 0.42577}, "CVE-2024-12407": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12408": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12409": {"epss_score": 0.00676, "epss_percentile": 0.70919}, "CVE-2024-12410": {"epss_score": 0.00136, "epss_percentile": 0.34136}, "CVE-2024-12411": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12412": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12413": {"epss_score": 0.00293, "epss_percentile": 0.52293}, "CVE-2024-12414": {"epss_score": 0.00034, "epss_percentile": 0.09794}, "CVE-2024-12415": {"epss_score": 0.01532, "epss_percentile": 0.80895}, "CVE-2024-12416": {"epss_score": 0.01212, "epss_percentile": 0.78563}, "CVE-2024-12417": {"epss_score": 0.01823, "epss_percentile": 0.82418}, "CVE-2024-12419": {"epss_score": 0.01519, "epss_percentile": 0.80817}, "CVE-2024-12420": {"epss_score": 0.01426, "epss_percentile": 0.80206}, "CVE-2024-12421": {"epss_score": 0.01358, "epss_percentile": 0.79733}, "CVE-2024-12422": {"epss_score": 0.00882, "epss_percentile": 0.74886}, "CVE-2024-12423": {"epss_score": 0.00843, "epss_percentile": 0.74266}, "CVE-2024-12425": {"epss_score": 0.00203, "epss_percentile": 0.42566}, "CVE-2024-12426": {"epss_score": 0.00126, "epss_percentile": 0.32637}, "CVE-2024-12427": {"epss_score": 0.00442, "epss_percentile": 0.6274}, "CVE-2024-12428": {"epss_score": 0.01014, "epss_percentile": 0.76649}, "CVE-2024-12429": {"epss_score": 0.0004, "epss_percentile": 0.11907}, "CVE-2024-12430": {"epss_score": 0.00022, "epss_percentile": 0.04978}, "CVE-2024-12431": {"epss_score": 0.00065, "epss_percentile": 0.20505}, "CVE-2024-12432": {"epss_score": 0.00187, "epss_percentile": 0.4078}, "CVE-2024-12433": {"epss_score": 0.02027, "epss_percentile": 0.8332}, "CVE-2024-12434": {"epss_score": 0.00212, "epss_percentile": 0.43824}, "CVE-2024-12435": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-12436": {"epss_score": 0.00016, "epss_percentile": 0.02913}, "CVE-2024-12437": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12438": {"epss_score": 0.01341, "epss_percentile": 0.79587}, "CVE-2024-12439": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12440": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12441": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12442": {"epss_score": 0.00278, "epss_percentile": 0.50867}, "CVE-2024-12443": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-12444": {"epss_score": 0.00078, "epss_percentile": 0.23569}, "CVE-2024-12445": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12446": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12447": {"epss_score": 0.0011, "epss_percentile": 0.30235}, "CVE-2024-12448": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12449": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12450": {"epss_score": 0.00293, "epss_percentile": 0.52294}, "CVE-2024-12451": {"epss_score": 0.00067, "epss_percentile": 0.21074}, "CVE-2024-12452": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-12453": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12454": {"epss_score": 0.00091, "epss_percentile": 0.26408}, "CVE-2024-12457": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12458": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12459": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-12460": {"epss_score": 0.00104, "epss_percentile": 0.29108}, "CVE-2024-12461": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12462": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12463": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-12464": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12465": {"epss_score": 0.00034, "epss_percentile": 0.0948}, "CVE-2024-12466": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-12467": {"epss_score": 0.00756, "epss_percentile": 0.72745}, "CVE-2024-12468": {"epss_score": 0.01236, "epss_percentile": 0.78774}, "CVE-2024-12469": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-12470": {"epss_score": 0.00374, "epss_percentile": 0.58563}, "CVE-2024-12471": {"epss_score": 0.52382, "epss_percentile": 0.97822}, "CVE-2024-12472": {"epss_score": 0.00142, "epss_percentile": 0.35049}, "CVE-2024-12473": {"epss_score": 0.00203, "epss_percentile": 0.42577}, "CVE-2024-12474": {"epss_score": 0.00034, "epss_percentile": 0.0948}, "CVE-2024-12475": {"epss_score": 0.00079, "epss_percentile": 0.23975}, "CVE-2024-12476": {"epss_score": 0.00023, "epss_percentile": 0.05632}, "CVE-2024-12477": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-12478": {"epss_score": 0.00061, "epss_percentile": 0.19346}, "CVE-2024-12479": {"epss_score": 0.0013, "epss_percentile": 0.33336}, "CVE-2024-12480": {"epss_score": 0.00147, "epss_percentile": 0.35794}, "CVE-2024-12481": {"epss_score": 0.0013, "epss_percentile": 0.33336}, "CVE-2024-12482": {"epss_score": 0.00368, "epss_percentile": 0.58167}, "CVE-2024-12483": {"epss_score": 0.00934, "epss_percentile": 0.75646}, "CVE-2024-12484": {"epss_score": 0.00069, "epss_percentile": 0.21528}, "CVE-2024-12485": {"epss_score": 0.00119, "epss_percentile": 0.31599}, "CVE-2024-12486": {"epss_score": 0.00119, "epss_percentile": 0.31599}, "CVE-2024-12487": {"epss_score": 0.00119, "epss_percentile": 0.31599}, "CVE-2024-12488": {"epss_score": 0.00162, "epss_percentile": 0.37641}, "CVE-2024-12489": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2024-12490": {"epss_score": 0.00105, "epss_percentile": 0.2935}, "CVE-2024-12491": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12492": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2024-12493": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-12494": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-12495": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12496": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-12497": {"epss_score": 0.00131, "epss_percentile": 0.33452}, "CVE-2024-12499": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12500": {"epss_score": 0.00282, "epss_percentile": 0.51232}, "CVE-2024-12501": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-12502": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12503": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2024-12504": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-12505": {"epss_score": 0.00124, "epss_percentile": 0.32414}, "CVE-2024-12506": {"epss_score": 0.00124, "epss_percentile": 0.32414}, "CVE-2024-12507": {"epss_score": 0.00111, "epss_percentile": 0.30295}, "CVE-2024-12508": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12509": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12510": {"epss_score": 0.00243, "epss_percentile": 0.47456}, "CVE-2024-12511": {"epss_score": 0.00184, "epss_percentile": 0.40368}, "CVE-2024-12512": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12513": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12514": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12515": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12516": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12517": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12518": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12519": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12520": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12521": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12522": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-12523": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12524": {"epss_score": 0.00104, "epss_percentile": 0.29108}, "CVE-2024-12525": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-12526": {"epss_score": 0.00033, "epss_percentile": 0.0933}, "CVE-2024-12527": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12528": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-12529": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12530": {"epss_score": 0.00025, "epss_percentile": 0.06379}, "CVE-2024-12532": {"epss_score": 0.00139, "epss_percentile": 0.34543}, "CVE-2024-12533": {"epss_score": 0.0002, "epss_percentile": 0.04551}, "CVE-2024-12534": {"epss_score": 0.00154, "epss_percentile": 0.36737}, "CVE-2024-12535": {"epss_score": 0.12453, "epss_percentile": 0.93677}, "CVE-2024-12536": {"epss_score": 0.00085, "epss_percentile": 0.25156}, "CVE-2024-12537": {"epss_score": 0.00739, "epss_percentile": 0.72353}, "CVE-2024-12538": {"epss_score": 0.00139, "epss_percentile": 0.34543}, "CVE-2024-12539": {"epss_score": 0.00207, "epss_percentile": 0.43149}, "CVE-2024-12541": {"epss_score": 0.00034, "epss_percentile": 0.09762}, "CVE-2024-12542": {"epss_score": 0.32492, "epss_percentile": 0.96705}, "CVE-2024-12543": {"epss_score": 0.00038, "epss_percentile": 0.11214}, "CVE-2024-12544": {"epss_score": 0.0092, "epss_percentile": 0.75467}, "CVE-2024-12545": {"epss_score": 0.00042, "epss_percentile": 0.12481}, "CVE-2024-12547": {"epss_score": 0.00164, "epss_percentile": 0.37941}, "CVE-2024-12548": {"epss_score": 0.00034, "epss_percentile": 0.09707}, "CVE-2024-12549": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2024-12550": {"epss_score": 0.00033, "epss_percentile": 0.09392}, "CVE-2024-12551": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2024-12552": {"epss_score": 0.00039, "epss_percentile": 0.11842}, "CVE-2024-12553": {"epss_score": 0.00123, "epss_percentile": 0.32255}, "CVE-2024-12554": {"epss_score": 0.00039, "epss_percentile": 0.11551}, "CVE-2024-12555": {"epss_score": 0.00049, "epss_percentile": 0.15345}, "CVE-2024-12556": {"epss_score": 0.00659, "epss_percentile": 0.70512}, "CVE-2024-12557": {"epss_score": 0.00049, "epss_percentile": 0.15345}, "CVE-2024-12558": {"epss_score": 0.41746, "epss_percentile": 0.97292}, "CVE-2024-12559": {"epss_score": 0.00255, "epss_percentile": 0.48683}, "CVE-2024-12560": {"epss_score": 0.00287, "epss_percentile": 0.51787}, "CVE-2024-12561": {"epss_score": 0.00048, "epss_percentile": 0.14994}, "CVE-2024-12562": {"epss_score": 0.02588, "epss_percentile": 0.85175}, "CVE-2024-12563": {"epss_score": 0.00306, "epss_percentile": 0.53403}, "CVE-2024-12564": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2024-12566": {"epss_score": 0.00072, "epss_percentile": 0.22462}, "CVE-2024-12567": {"epss_score": 0.00072, "epss_percentile": 0.22462}, "CVE-2024-12568": {"epss_score": 0.00072, "epss_percentile": 0.22462}, "CVE-2024-12569": {"epss_score": 0.0003, "epss_percentile": 0.08152}, "CVE-2024-12570": {"epss_score": 0.00038, "epss_percentile": 0.11118}, "CVE-2024-12571": {"epss_score": 0.20422, "epss_percentile": 0.95342}, "CVE-2024-12572": {"epss_score": 0.00049, "epss_percentile": 0.15345}, "CVE-2024-12574": {"epss_score": 0.00161, "epss_percentile": 0.37582}, "CVE-2024-12575": {"epss_score": 0.00069, "epss_percentile": 0.21471}, "CVE-2024-12576": {"epss_score": 0.00031, "epss_percentile": 0.08638}, "CVE-2024-12577": {"epss_score": 0.00033, "epss_percentile": 0.09309}, "CVE-2024-12578": {"epss_score": 0.00328, "epss_percentile": 0.55284}, "CVE-2024-12579": {"epss_score": 0.00346, "epss_percentile": 0.56703}, "CVE-2024-12580": {"epss_score": 0.00072, "epss_percentile": 0.22328}, "CVE-2024-12581": {"epss_score": 0.00043, "epss_percentile": 0.12941}, "CVE-2024-12582": {"epss_score": 0.0021, "epss_percentile": 0.43488}, "CVE-2024-12583": {"epss_score": 0.0428, "epss_percentile": 0.88488}, "CVE-2024-12584": {"epss_score": 0.00287, "epss_percentile": 0.51787}, "CVE-2024-12585": {"epss_score": 0.00025, "epss_percentile": 0.06108}, "CVE-2024-12586": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-12587": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-12588": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-12589": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-12590": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12591": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12592": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12593": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12594": {"epss_score": 0.04924, "epss_percentile": 0.89293}, "CVE-2024-12595": {"epss_score": 0.00021, "epss_percentile": 0.04748}, "CVE-2024-12596": {"epss_score": 0.00101, "epss_percentile": 0.28635}, "CVE-2024-12597": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-12598": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12599": {"epss_score": 0.00139, "epss_percentile": 0.34532}, "CVE-2024-12600": {"epss_score": 0.02212, "epss_percentile": 0.84016}, "CVE-2024-12601": {"epss_score": 0.00692, "epss_percentile": 0.71307}, "CVE-2024-12602": {"epss_score": 0.00048, "epss_percentile": 0.1503}, "CVE-2024-12603": {"epss_score": 0.00361, "epss_percentile": 0.57741}, "CVE-2024-12604": {"epss_score": 0.00051, "epss_percentile": 0.16033}, "CVE-2024-12605": {"epss_score": 0.00033, "epss_percentile": 0.0933}, "CVE-2024-12606": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12607": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-12609": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-12610": {"epss_score": 0.00286, "epss_percentile": 0.51737}, "CVE-2024-12611": {"epss_score": 0.00463, "epss_percentile": 0.6367}, "CVE-2024-12612": {"epss_score": 0.00116, "epss_percentile": 0.31077}, "CVE-2024-12613": {"epss_score": 0.00939, "epss_percentile": 0.75721}, "CVE-2024-12614": {"epss_score": 0.00182, "epss_percentile": 0.40186}, "CVE-2024-12615": {"epss_score": 0.00173, "epss_percentile": 0.39132}, "CVE-2024-12616": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12617": {"epss_score": 0.00097, "epss_percentile": 0.27543}, "CVE-2024-12618": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12619": {"epss_score": 0.00019, "epss_percentile": 0.04275}, "CVE-2024-12620": {"epss_score": 0.00379, "epss_percentile": 0.58843}, "CVE-2024-12621": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12622": {"epss_score": 0.00182, "epss_percentile": 0.40138}, "CVE-2024-12623": {"epss_score": 0.00078, "epss_percentile": 0.23785}, "CVE-2024-12624": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-12626": {"epss_score": 0.02649, "epss_percentile": 0.8534}, "CVE-2024-12627": {"epss_score": 0.01301, "epss_percentile": 0.79292}, "CVE-2024-12628": {"epss_score": 0.00109, "epss_percentile": 0.29997}, "CVE-2024-12629": {"epss_score": 0.00183, "epss_percentile": 0.40338}, "CVE-2024-12633": {"epss_score": 0.00608, "epss_percentile": 0.69063}, "CVE-2024-12634": {"epss_score": 0.0007, "epss_percentile": 0.21671}, "CVE-2024-12635": {"epss_score": 0.00252, "epss_percentile": 0.48413}, "CVE-2024-12636": {"epss_score": 0.00033, "epss_percentile": 0.09328}, "CVE-2024-12637": {"epss_score": 0.00328, "epss_percentile": 0.55284}, "CVE-2024-12638": {"epss_score": 0.00029, "epss_percentile": 0.07935}, "CVE-2024-12641": {"epss_score": 0.2996, "epss_percentile": 0.9649}, "CVE-2024-12642": {"epss_score": 0.00217, "epss_percentile": 0.44282}, "CVE-2024-12643": {"epss_score": 0.00423, "epss_percentile": 0.61596}, "CVE-2024-12644": {"epss_score": 0.00141, "epss_percentile": 0.34939}, "CVE-2024-12645": {"epss_score": 0.00074, "epss_percentile": 0.22777}, "CVE-2024-12646": {"epss_score": 0.00423, "epss_percentile": 0.61596}, "CVE-2024-12647": {"epss_score": 0.00295, "epss_percentile": 0.52455}, "CVE-2024-12648": {"epss_score": 0.00295, "epss_percentile": 0.52455}, "CVE-2024-12649": {"epss_score": 0.00295, "epss_percentile": 0.52455}, "CVE-2024-12650": {"epss_score": 0.00174, "epss_percentile": 0.39166}, "CVE-2024-12651": {"epss_score": 0.00118, "epss_percentile": 0.31431}, "CVE-2024-12652": {"epss_score": 0.00434, "epss_percentile": 0.62315}, "CVE-2024-12653": {"epss_score": 0.00035, "epss_percentile": 0.10051}, "CVE-2024-12654": {"epss_score": 0.00035, "epss_percentile": 0.10051}, "CVE-2024-12655": {"epss_score": 0.00012, "epss_percentile": 0.01323}, "CVE-2024-12656": {"epss_score": 0.00042, "epss_percentile": 0.12742}, "CVE-2024-12657": {"epss_score": 0.00042, "epss_percentile": 0.12742}, "CVE-2024-12658": {"epss_score": 0.00012, "epss_percentile": 0.01323}, "CVE-2024-12659": {"epss_score": 0.00012, "epss_percentile": 0.01323}, "CVE-2024-12660": {"epss_score": 0.00012, "epss_percentile": 0.01323}, "CVE-2024-12661": {"epss_score": 0.00014, "epss_percentile": 0.01955}, "CVE-2024-12662": {"epss_score": 0.00043, "epss_percentile": 0.12964}, "CVE-2024-12663": {"epss_score": 0.00126, "epss_percentile": 0.32689}, "CVE-2024-12664": {"epss_score": 0.00026, "epss_percentile": 0.06719}, "CVE-2024-12665": {"epss_score": 0.00093, "epss_percentile": 0.26751}, "CVE-2024-12666": {"epss_score": 0.00192, "epss_percentile": 0.41337}, "CVE-2024-12667": {"epss_score": 0.00111, "epss_percentile": 0.30387}, "CVE-2024-12668": {"epss_score": 0.00039, "epss_percentile": 0.11432}, "CVE-2024-12669": {"epss_score": 0.00031, "epss_percentile": 0.08573}, "CVE-2024-12670": {"epss_score": 0.00031, "epss_percentile": 0.08573}, "CVE-2024-12671": {"epss_score": 0.00031, "epss_percentile": 0.08573}, "CVE-2024-12672": {"epss_score": 0.00016, "epss_percentile": 0.02636}, "CVE-2024-12673": {"epss_score": 0.00029, "epss_percentile": 0.07907}, "CVE-2024-12677": {"epss_score": 0.00282, "epss_percentile": 0.51283}, "CVE-2024-12678": {"epss_score": 0.0014, "epss_percentile": 0.34801}, "CVE-2024-12679": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-12680": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-12682": {"epss_score": 0.00062, "epss_percentile": 0.19665}, "CVE-2024-12683": {"epss_score": 0.00057, "epss_percentile": 0.18026}, "CVE-2024-12686": {"epss_score": 0.15667, "epss_percentile": 0.94479}, "CVE-2024-12687": {"epss_score": 0.00192, "epss_percentile": 0.41328}, "CVE-2024-12692": {"epss_score": 0.0047, "epss_percentile": 0.63963}, "CVE-2024-12693": {"epss_score": 0.01192, "epss_percentile": 0.78401}, "CVE-2024-12694": {"epss_score": 0.00169, "epss_percentile": 0.38598}, "CVE-2024-12695": {"epss_score": 0.01049, "epss_percentile": 0.7706}, "CVE-2024-12696": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-12697": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12698": {"epss_score": 0.00217, "epss_percentile": 0.44303}, "CVE-2024-12699": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12700": {"epss_score": 0.00245, "epss_percentile": 0.47706}, "CVE-2024-12701": {"epss_score": 0.00944, "epss_percentile": 0.75786}, "CVE-2024-12703": {"epss_score": 0.00368, "epss_percentile": 0.58207}, "CVE-2024-12704": {"epss_score": 0.00231, "epss_percentile": 0.45765}, "CVE-2024-12705": {"epss_score": 0.00346, "epss_percentile": 0.5665}, "CVE-2024-12706": {"epss_score": 0.00024, "epss_percentile": 0.06005}, "CVE-2024-12708": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-12709": {"epss_score": 0.00045, "epss_percentile": 0.13968}, "CVE-2024-12710": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-12711": {"epss_score": 0.00293, "epss_percentile": 0.52293}, "CVE-2024-12712": {"epss_score": 0.003, "epss_percentile": 0.52951}, "CVE-2024-12713": {"epss_score": 0.00328, "epss_percentile": 0.5516}, "CVE-2024-12714": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-12715": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-12716": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-12717": {"epss_score": 0.00021, "epss_percentile": 0.04823}, "CVE-2024-12718": {"epss_score": 0.0013, "epss_percentile": 0.3324}, "CVE-2024-12719": {"epss_score": 0.00086, "epss_percentile": 0.25363}, "CVE-2024-12720": {"epss_score": 0.00114, "epss_percentile": 0.30782}, "CVE-2024-12721": {"epss_score": 0.02708, "epss_percentile": 0.85479}, "CVE-2024-12722": {"epss_score": 0.00022, "epss_percentile": 0.05165}, "CVE-2024-12723": {"epss_score": 0.00077, "epss_percentile": 0.2347}, "CVE-2024-12724": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2024-12725": {"epss_score": 0.00028, "epss_percentile": 0.07558}, "CVE-2024-12726": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2024-12727": {"epss_score": 0.0158, "epss_percentile": 0.81134}, "CVE-2024-12728": {"epss_score": 0.00167, "epss_percentile": 0.38297}, "CVE-2024-12729": {"epss_score": 0.00629, "epss_percentile": 0.69673}, "CVE-2024-12731": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-12732": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2024-12733": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2024-12734": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2024-12735": {"epss_score": 0.00051, "epss_percentile": 0.16211}, "CVE-2024-12736": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-12737": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-12738": {"epss_score": 0.00944, "epss_percentile": 0.75786}, "CVE-2024-12739": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-12740": {"epss_score": 0.00026, "epss_percentile": 0.06531}, "CVE-2024-12741": {"epss_score": 0.01385, "epss_percentile": 0.79902}, "CVE-2024-12742": {"epss_score": 0.00338, "epss_percentile": 0.56159}, "CVE-2024-12743": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-12744": {"epss_score": 0.00388, "epss_percentile": 0.59341}, "CVE-2024-12745": {"epss_score": 0.00151, "epss_percentile": 0.36331}, "CVE-2024-12746": {"epss_score": 0.0034, "epss_percentile": 0.56267}, "CVE-2024-12747": {"epss_score": 0.00022, "epss_percentile": 0.05196}, "CVE-2024-12749": {"epss_score": 0.00025, "epss_percentile": 0.0605}, "CVE-2024-12750": {"epss_score": 0.00017, "epss_percentile": 0.0342}, "CVE-2024-12751": {"epss_score": 0.00064, "epss_percentile": 0.20359}, "CVE-2024-12752": {"epss_score": 0.00064, "epss_percentile": 0.20359}, "CVE-2024-12753": {"epss_score": 0.00018, "epss_percentile": 0.03863}, "CVE-2024-12754": {"epss_score": 0.02982, "epss_percentile": 0.86125}, "CVE-2024-12755": {"epss_score": 0.00105, "epss_percentile": 0.29272}, "CVE-2024-12756": {"epss_score": 0.00074, "epss_percentile": 0.22681}, "CVE-2024-12757": {"epss_score": 0.00478, "epss_percentile": 0.64355}, "CVE-2024-12761": {"epss_score": 0.00109, "epss_percentile": 0.29953}, "CVE-2024-12766": {"epss_score": 0.00098, "epss_percentile": 0.27702}, "CVE-2024-12767": {"epss_score": 0.00028, "epss_percentile": 0.07496}, "CVE-2024-12768": {"epss_score": 0.00033, "epss_percentile": 0.09295}, "CVE-2024-12769": {"epss_score": 0.00059, "epss_percentile": 0.18724}, "CVE-2024-12770": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-12771": {"epss_score": 0.00061, "epss_percentile": 0.19368}, "CVE-2024-12772": {"epss_score": 0.00025, "epss_percentile": 0.0615}, "CVE-2024-12773": {"epss_score": 0.00098, "epss_percentile": 0.27718}, "CVE-2024-12774": {"epss_score": 0.00015, "epss_percentile": 0.02159}, "CVE-2024-12775": {"epss_score": 0.00093, "epss_percentile": 0.26727}, "CVE-2024-12776": {"epss_score": 0.00147, "epss_percentile": 0.35798}, "CVE-2024-12777": {"epss_score": 0.00091, "epss_percentile": 0.26282}, "CVE-2024-12778": {"epss_score": 0.00118, "epss_percentile": 0.31435}, "CVE-2024-12779": {"epss_score": 0.00089, "epss_percentile": 0.25964}, "CVE-2024-12781": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12782": {"epss_score": 0.00133, "epss_percentile": 0.33713}, "CVE-2024-12783": {"epss_score": 0.00098, "epss_percentile": 0.27745}, "CVE-2024-12784": {"epss_score": 0.00119, "epss_percentile": 0.31599}, "CVE-2024-12785": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2024-12786": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2024-12787": {"epss_score": 0.00122, "epss_percentile": 0.32125}, "CVE-2024-12788": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2024-12789": {"epss_score": 0.00365, "epss_percentile": 0.58003}, "CVE-2024-12790": {"epss_score": 0.0009, "epss_percentile": 0.26168}, "CVE-2024-12791": {"epss_score": 0.00128, "epss_percentile": 0.33035}, "CVE-2024-12792": {"epss_score": 0.00128, "epss_percentile": 0.33035}, "CVE-2024-12793": {"epss_score": 0.00148, "epss_percentile": 0.3589}, "CVE-2024-12794": {"epss_score": 0.00125, "epss_percentile": 0.32498}, "CVE-2024-12796": {"epss_score": 0.00043, "epss_percentile": 0.13325}, "CVE-2024-12797": {"epss_score": 0.01684, "epss_percentile": 0.81743}, "CVE-2024-12798": {"epss_score": 0.0029, "epss_percentile": 0.52125}, "CVE-2024-12799": {"epss_score": 0.00127, "epss_percentile": 0.32895}, "CVE-2024-12800": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-12801": {"epss_score": 0.00048, "epss_percentile": 0.14942}, "CVE-2024-12802": {"epss_score": 0.00088, "epss_percentile": 0.25654}, "CVE-2024-12803": {"epss_score": 0.00424, "epss_percentile": 0.61653}, "CVE-2024-12805": {"epss_score": 0.00463, "epss_percentile": 0.63692}, "CVE-2024-12806": {"epss_score": 0.00246, "epss_percentile": 0.47743}, "CVE-2024-12807": {"epss_score": 0.00072, "epss_percentile": 0.22462}, "CVE-2024-12808": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-12809": {"epss_score": 0.00116, "epss_percentile": 0.31134}, "CVE-2024-12810": {"epss_score": 0.00176, "epss_percentile": 0.39469}, "CVE-2024-12811": {"epss_score": 0.00388, "epss_percentile": 0.59364}, "CVE-2024-12812": {"epss_score": 0.00064, "epss_percentile": 0.20188}, "CVE-2024-12813": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-12814": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-12815": {"epss_score": 0.00104, "epss_percentile": 0.29108}, "CVE-2024-12816": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12817": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12818": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-12819": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2024-12820": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-12821": {"epss_score": 0.00135, "epss_percentile": 0.34018}, "CVE-2024-12822": {"epss_score": 0.00638, "epss_percentile": 0.69917}, "CVE-2024-12824": {"epss_score": 0.58714, "epss_percentile": 0.98132}, "CVE-2024-12825": {"epss_score": 0.00116, "epss_percentile": 0.31177}, "CVE-2024-12826": {"epss_score": 0.00201, "epss_percentile": 0.42357}, "CVE-2024-12827": {"epss_score": 0.00184, "epss_percentile": 0.40415}, "CVE-2024-12828": {"epss_score": 0.02328, "epss_percentile": 0.84396}, "CVE-2024-12829": {"epss_score": 0.01956, "epss_percentile": 0.83038}, "CVE-2024-12830": {"epss_score": 0.0308, "epss_percentile": 0.86371}, "CVE-2024-12831": {"epss_score": 0.00019, "epss_percentile": 0.0436}, "CVE-2024-12832": {"epss_score": 0.01559, "epss_percentile": 0.81032}, "CVE-2024-12833": {"epss_score": 0.00071, "epss_percentile": 0.22017}, "CVE-2024-12834": {"epss_score": 0.00084, "epss_percentile": 0.2501}, "CVE-2024-12835": {"epss_score": 0.00084, "epss_percentile": 0.2501}, "CVE-2024-12836": {"epss_score": 0.00084, "epss_percentile": 0.2501}, "CVE-2024-12837": {"epss_score": 0.00038, "epss_percentile": 0.111}, "CVE-2024-12838": {"epss_score": 0.00663, "epss_percentile": 0.70624}, "CVE-2024-12839": {"epss_score": 0.00558, "epss_percentile": 0.67561}, "CVE-2024-12841": {"epss_score": 0.00101, "epss_percentile": 0.28707}, "CVE-2024-12842": {"epss_score": 0.00089, "epss_percentile": 0.25982}, "CVE-2024-12843": {"epss_score": 0.00101, "epss_percentile": 0.28707}, "CVE-2024-12844": {"epss_score": 0.00114, "epss_percentile": 0.30752}, "CVE-2024-12845": {"epss_score": 0.00099, "epss_percentile": 0.27862}, "CVE-2024-12846": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2024-12847": {"epss_score": 0.67076, "epss_percentile": 0.98493}, "CVE-2024-12848": {"epss_score": 0.02944, "epss_percentile": 0.86038}, "CVE-2024-12849": {"epss_score": 0.92386, "epss_percentile": 0.99712}, "CVE-2024-12850": {"epss_score": 0.01228, "epss_percentile": 0.7871}, "CVE-2024-12851": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-12852": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-12853": {"epss_score": 0.03782, "epss_percentile": 0.87721}, "CVE-2024-12854": {"epss_score": 0.04031, "epss_percentile": 0.88151}, "CVE-2024-12855": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12856": {"epss_score": 0.50683, "epss_percentile": 0.97745}, "CVE-2024-12857": {"epss_score": 0.01705, "epss_percentile": 0.81848}, "CVE-2024-12859": {"epss_score": 0.0034, "epss_percentile": 0.56222}, "CVE-2024-12860": {"epss_score": 0.00482, "epss_percentile": 0.64555}, "CVE-2024-12861": {"epss_score": 0.00135, "epss_percentile": 0.33981}, "CVE-2024-12862": {"epss_score": 0.00048, "epss_percentile": 0.15267}, "CVE-2024-12863": {"epss_score": 0.00084, "epss_percentile": 0.24853}, "CVE-2024-12864": {"epss_score": 0.00332, "epss_percentile": 0.55565}, "CVE-2024-12866": {"epss_score": 0.00233, "epss_percentile": 0.46023}, "CVE-2024-12867": {"epss_score": 0.00183, "epss_percentile": 0.40298}, "CVE-2024-12869": {"epss_score": 0.00066, "epss_percentile": 0.20683}, "CVE-2024-12870": {"epss_score": 0.0014, "epss_percentile": 0.34747}, "CVE-2024-12871": {"epss_score": 0.00059, "epss_percentile": 0.18873}, "CVE-2024-12872": {"epss_score": 0.00087, "epss_percentile": 0.25514}, "CVE-2024-12873": {"epss_score": 0.00028, "epss_percentile": 0.07558}, "CVE-2024-12874": {"epss_score": 0.00026, "epss_percentile": 0.06556}, "CVE-2024-12875": {"epss_score": 0.01089, "epss_percentile": 0.77442}, "CVE-2024-12876": {"epss_score": 0.00482, "epss_percentile": 0.64555}, "CVE-2024-12877": {"epss_score": 0.3291, "epss_percentile": 0.96733}, "CVE-2024-12878": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-12879": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-12880": {"epss_score": 0.0007, "epss_percentile": 0.21683}, "CVE-2024-12881": {"epss_score": 0.00246, "epss_percentile": 0.47742}, "CVE-2024-12882": {"epss_score": 0.00116, "epss_percentile": 0.31045}, "CVE-2024-12883": {"epss_score": 0.00033, "epss_percentile": 0.09192}, "CVE-2024-12884": {"epss_score": 0.0004, "epss_percentile": 0.11918}, "CVE-2024-12885": {"epss_score": 0.00381, "epss_percentile": 0.58989}, "CVE-2024-12886": {"epss_score": 0.00123, "epss_percentile": 0.32213}, "CVE-2024-12890": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2024-12891": {"epss_score": 0.00119, "epss_percentile": 0.31599}, "CVE-2024-12892": {"epss_score": 0.00098, "epss_percentile": 0.27745}, "CVE-2024-12893": {"epss_score": 0.00033, "epss_percentile": 0.09288}, "CVE-2024-12894": {"epss_score": 0.00085, "epss_percentile": 0.25047}, "CVE-2024-12895": {"epss_score": 0.00085, "epss_percentile": 0.25047}, "CVE-2024-12896": {"epss_score": 0.00117, "epss_percentile": 0.31302}, "CVE-2024-12897": {"epss_score": 0.00185, "epss_percentile": 0.40575}, "CVE-2024-12898": {"epss_score": 0.00136, "epss_percentile": 0.34163}, "CVE-2024-12899": {"epss_score": 0.00127, "epss_percentile": 0.32834}, "CVE-2024-12900": {"epss_score": 0.0019, "epss_percentile": 0.41062}, "CVE-2024-12901": {"epss_score": 0.0022, "epss_percentile": 0.44594}, "CVE-2024-12902": {"epss_score": 0.00042, "epss_percentile": 0.12482}, "CVE-2024-12903": {"epss_score": 0.00032, "epss_percentile": 0.0879}, "CVE-2024-12905": {"epss_score": 0.01098, "epss_percentile": 0.7754}, "CVE-2024-12907": {"epss_score": 0.0025, "epss_percentile": 0.48255}, "CVE-2024-12908": {"epss_score": 0.00035, "epss_percentile": 0.09967}, "CVE-2024-12909": {"epss_score": 0.00657, "epss_percentile": 0.70461}, "CVE-2024-12910": {"epss_score": 0.00231, "epss_percentile": 0.45765}, "CVE-2024-12911": {"epss_score": 0.00137, "epss_percentile": 0.34224}, "CVE-2024-12912": {"epss_score": 0.00455, "epss_percentile": 0.63306}, "CVE-2024-12913": {"epss_score": 0.00024, "epss_percentile": 0.05976}, "CVE-2024-12914": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2024-12915": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2024-12916": {"epss_score": 0.0012, "epss_percentile": 0.31737}, "CVE-2024-12917": {"epss_score": 0.00177, "epss_percentile": 0.39587}, "CVE-2024-12918": {"epss_score": 0.0012, "epss_percentile": 0.31737}, "CVE-2024-12919": {"epss_score": 0.00673, "epss_percentile": 0.70833}, "CVE-2024-12920": {"epss_score": 0.00172, "epss_percentile": 0.38938}, "CVE-2024-12921": {"epss_score": 0.00089, "epss_percentile": 0.25962}, "CVE-2024-12922": {"epss_score": 0.00396, "epss_percentile": 0.59854}, "CVE-2024-12923": {"epss_score": 0.00133, "epss_percentile": 0.33678}, "CVE-2024-12924": {"epss_score": 0.00059, "epss_percentile": 0.18832}, "CVE-2024-12925": {"epss_score": 0.0004, "epss_percentile": 0.11906}, "CVE-2024-12926": {"epss_score": 0.0013, "epss_percentile": 0.33336}, "CVE-2024-12927": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12928": {"epss_score": 0.00111, "epss_percentile": 0.30285}, "CVE-2024-12929": {"epss_score": 0.00111, "epss_percentile": 0.30285}, "CVE-2024-12930": {"epss_score": 0.00089, "epss_percentile": 0.25966}, "CVE-2024-12931": {"epss_score": 0.00111, "epss_percentile": 0.30285}, "CVE-2024-12932": {"epss_score": 0.00089, "epss_percentile": 0.25966}, "CVE-2024-12933": {"epss_score": 0.00089, "epss_percentile": 0.25966}, "CVE-2024-12934": {"epss_score": 0.00111, "epss_percentile": 0.30285}, "CVE-2024-12935": {"epss_score": 0.00111, "epss_percentile": 0.30285}, "CVE-2024-12936": {"epss_score": 0.00111, "epss_percentile": 0.30285}, "CVE-2024-12937": {"epss_score": 0.00111, "epss_percentile": 0.30285}, "CVE-2024-12938": {"epss_score": 0.00074, "epss_percentile": 0.22827}, "CVE-2024-12939": {"epss_score": 0.00086, "epss_percentile": 0.25439}, "CVE-2024-12940": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12941": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2024-12942": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12943": {"epss_score": 0.00116, "epss_percentile": 0.31129}, "CVE-2024-12944": {"epss_score": 0.00116, "epss_percentile": 0.31129}, "CVE-2024-12945": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12946": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12947": {"epss_score": 0.0013, "epss_percentile": 0.33336}, "CVE-2024-12948": {"epss_score": 0.00137, "epss_percentile": 0.34333}, "CVE-2024-12949": {"epss_score": 0.00125, "epss_percentile": 0.32601}, "CVE-2024-12950": {"epss_score": 0.00089, "epss_percentile": 0.25974}, "CVE-2024-12951": {"epss_score": 0.0007, "epss_percentile": 0.2164}, "CVE-2024-12952": {"epss_score": 0.00066, "epss_percentile": 0.20677}, "CVE-2024-12953": {"epss_score": 0.0007, "epss_percentile": 0.2164}, "CVE-2024-12954": {"epss_score": 0.0007, "epss_percentile": 0.2164}, "CVE-2024-12955": {"epss_score": 0.00157, "epss_percentile": 0.37051}, "CVE-2024-12956": {"epss_score": 0.00195, "epss_percentile": 0.4167}, "CVE-2024-12957": {"epss_score": 0.00042, "epss_percentile": 0.12601}, "CVE-2024-12958": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12959": {"epss_score": 0.00118, "epss_percentile": 0.31425}, "CVE-2024-12960": {"epss_score": 0.00116, "epss_percentile": 0.31129}, "CVE-2024-12961": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12962": {"epss_score": 0.00084, "epss_percentile": 0.2496}, "CVE-2024-12963": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12964": {"epss_score": 0.0012, "epss_percentile": 0.31794}, "CVE-2024-12965": {"epss_score": 0.00116, "epss_percentile": 0.31129}, "CVE-2024-12966": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12967": {"epss_score": 0.00116, "epss_percentile": 0.31129}, "CVE-2024-12968": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12969": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-12970": {"epss_score": 0.01835, "epss_percentile": 0.82466}, "CVE-2024-12971": {"epss_score": 0.70261, "epss_percentile": 0.98625}, "CVE-2024-12972": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2024-12973": {"epss_score": 0.00029, "epss_percentile": 0.07974}, "CVE-2024-12974": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2024-12975": {"epss_score": 0.00041, "epss_percentile": 0.12315}, "CVE-2024-12976": {"epss_score": 0.00139, "epss_percentile": 0.34549}, "CVE-2024-12977": {"epss_score": 0.00119, "epss_percentile": 0.31599}, "CVE-2024-12978": {"epss_score": 0.00084, "epss_percentile": 0.2496}, "CVE-2024-12979": {"epss_score": 0.00112, "epss_percentile": 0.30547}, "CVE-2024-12980": {"epss_score": 0.00112, "epss_percentile": 0.30547}, "CVE-2024-12981": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2024-12982": {"epss_score": 0.00086, "epss_percentile": 0.25413}, "CVE-2024-12983": {"epss_score": 0.0007, "epss_percentile": 0.21933}, "CVE-2024-12984": {"epss_score": 0.00105, "epss_percentile": 0.29258}, "CVE-2024-12985": {"epss_score": 0.00523, "epss_percentile": 0.66299}, "CVE-2024-12986": {"epss_score": 0.53407, "epss_percentile": 0.97875}, "CVE-2024-12987": {"epss_score": 0.81091, "epss_percentile": 0.99119}, "CVE-2024-12988": {"epss_score": 0.00405, "epss_percentile": 0.60504}, "CVE-2024-12989": {"epss_score": 0.00077, "epss_percentile": 0.23402}, "CVE-2024-12990": {"epss_score": 0.00085, "epss_percentile": 0.25221}, "CVE-2024-12991": {"epss_score": 0.0009, "epss_percentile": 0.26135}, "CVE-2024-12992": {"epss_score": 0.00465, "epss_percentile": 0.63758}, "CVE-2024-12993": {"epss_score": 0.00048, "epss_percentile": 0.14964}, "CVE-2024-12994": {"epss_score": 0.00026, "epss_percentile": 0.06622}, "CVE-2024-12995": {"epss_score": 0.00027, "epss_percentile": 0.06844}, "CVE-2024-12998": {"epss_score": 0.00096, "epss_percentile": 0.27299}, "CVE-2024-12999": {"epss_score": 0.00109, "epss_percentile": 0.30058}, "CVE-2024-13000": {"epss_score": 0.00135, "epss_percentile": 0.33988}, "CVE-2024-13001": {"epss_score": 0.00125, "epss_percentile": 0.32601}, "CVE-2024-13002": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2024-13003": {"epss_score": 0.00119, "epss_percentile": 0.31599}, "CVE-2024-13004": {"epss_score": 0.00118, "epss_percentile": 0.31425}, "CVE-2024-13005": {"epss_score": 0.00119, "epss_percentile": 0.31599}, "CVE-2024-13006": {"epss_score": 0.00036, "epss_percentile": 0.10307}, "CVE-2024-13007": {"epss_score": 0.00041, "epss_percentile": 0.12266}, "CVE-2024-13008": {"epss_score": 0.00068, "epss_percentile": 0.21343}, "CVE-2024-13009": {"epss_score": 0.00074, "epss_percentile": 0.22854}, "CVE-2024-13010": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2024-13011": {"epss_score": 0.01908, "epss_percentile": 0.82818}, "CVE-2024-13012": {"epss_score": 0.00085, "epss_percentile": 0.25156}, "CVE-2024-13013": {"epss_score": 0.00024, "epss_percentile": 0.05744}, "CVE-2024-13014": {"epss_score": 0.00126, "epss_percentile": 0.32658}, "CVE-2024-13015": {"epss_score": 0.00083, "epss_percentile": 0.24763}, "CVE-2024-13016": {"epss_score": 0.00126, "epss_percentile": 0.32658}, "CVE-2024-13017": {"epss_score": 0.00083, "epss_percentile": 0.24763}, "CVE-2024-13018": {"epss_score": 0.00083, "epss_percentile": 0.24763}, "CVE-2024-13019": {"epss_score": 0.00089, "epss_percentile": 0.25966}, "CVE-2024-13020": {"epss_score": 0.00125, "epss_percentile": 0.32601}, "CVE-2024-13021": {"epss_score": 0.00028, "epss_percentile": 0.0729}, "CVE-2024-13022": {"epss_score": 0.00222, "epss_percentile": 0.4477}, "CVE-2024-13023": {"epss_score": 0.0009, "epss_percentile": 0.26124}, "CVE-2024-13024": {"epss_score": 0.00044, "epss_percentile": 0.13643}, "CVE-2024-13025": {"epss_score": 0.00068, "epss_percentile": 0.21297}, "CVE-2024-13026": {"epss_score": 0.00029, "epss_percentile": 0.07616}, "CVE-2024-13028": {"epss_score": 0.00142, "epss_percentile": 0.35041}, "CVE-2024-13029": {"epss_score": 0.00483, "epss_percentile": 0.64569}, "CVE-2024-13030": {"epss_score": 0.00482, "epss_percentile": 0.64544}, "CVE-2024-13031": {"epss_score": 0.00109, "epss_percentile": 0.29974}, "CVE-2024-13032": {"epss_score": 0.00041, "epss_percentile": 0.12292}, "CVE-2024-13033": {"epss_score": 0.0009, "epss_percentile": 0.26074}, "CVE-2024-13034": {"epss_score": 0.00108, "epss_percentile": 0.2977}, "CVE-2024-13035": {"epss_score": 0.00125, "epss_percentile": 0.32553}, "CVE-2024-13036": {"epss_score": 0.00073, "epss_percentile": 0.22526}, "CVE-2024-13037": {"epss_score": 0.00135, "epss_percentile": 0.3393}, "CVE-2024-13038": {"epss_score": 0.00038, "epss_percentile": 0.11407}, "CVE-2024-13039": {"epss_score": 0.0004, "epss_percentile": 0.12196}, "CVE-2024-13040": {"epss_score": 0.00237, "epss_percentile": 0.46463}, "CVE-2024-13041": {"epss_score": 0.00033, "epss_percentile": 0.09294}, "CVE-2024-13042": {"epss_score": 0.0003, "epss_percentile": 0.07987}, "CVE-2024-13043": {"epss_score": 0.00031, "epss_percentile": 0.08693}, "CVE-2024-13044": {"epss_score": 0.00061, "epss_percentile": 0.19386}, "CVE-2024-13045": {"epss_score": 0.00056, "epss_percentile": 0.17739}, "CVE-2024-13046": {"epss_score": 0.00061, "epss_percentile": 0.19386}, "CVE-2024-13047": {"epss_score": 0.00061, "epss_percentile": 0.19386}, "CVE-2024-13048": {"epss_score": 0.00061, "epss_percentile": 0.19386}, "CVE-2024-13049": {"epss_score": 0.00061, "epss_percentile": 0.19386}, "CVE-2024-13050": {"epss_score": 0.00056, "epss_percentile": 0.17739}, "CVE-2024-13051": {"epss_score": 0.00056, "epss_percentile": 0.17739}, "CVE-2024-13052": {"epss_score": 0.00085, "epss_percentile": 0.25067}, "CVE-2024-13053": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13054": {"epss_score": 0.01973, "epss_percentile": 0.83112}, "CVE-2024-13055": {"epss_score": 0.00085, "epss_percentile": 0.25067}, "CVE-2024-13056": {"epss_score": 0.00085, "epss_percentile": 0.25067}, "CVE-2024-13057": {"epss_score": 0.00037, "epss_percentile": 0.10792}, "CVE-2024-13058": {"epss_score": 0.00116, "epss_percentile": 0.31166}, "CVE-2024-13059": {"epss_score": 0.02829, "epss_percentile": 0.85773}, "CVE-2024-13060": {"epss_score": 0.00059, "epss_percentile": 0.18836}, "CVE-2024-13061": {"epss_score": 0.02159, "epss_percentile": 0.8382}, "CVE-2024-13062": {"epss_score": 0.00291, "epss_percentile": 0.52178}, "CVE-2024-13063": {"epss_score": 0.00067, "epss_percentile": 0.21127}, "CVE-2024-13064": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2024-13065": {"epss_score": 0.00061, "epss_percentile": 0.19389}, "CVE-2024-13066": {"epss_score": 0.00051, "epss_percentile": 0.16318}, "CVE-2024-13067": {"epss_score": 0.00047, "epss_percentile": 0.14685}, "CVE-2024-13068": {"epss_score": 0.00032, "epss_percentile": 0.09005}, "CVE-2024-13069": {"epss_score": 0.00032, "epss_percentile": 0.08847}, "CVE-2024-13070": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2024-13071": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2024-13072": {"epss_score": 0.00125, "epss_percentile": 0.32558}, "CVE-2024-13073": {"epss_score": 0.00073, "epss_percentile": 0.22641}, "CVE-2024-13074": {"epss_score": 0.00089, "epss_percentile": 0.25966}, "CVE-2024-13075": {"epss_score": 0.00099, "epss_percentile": 0.27862}, "CVE-2024-13076": {"epss_score": 0.00097, "epss_percentile": 0.27625}, "CVE-2024-13077": {"epss_score": 0.00097, "epss_percentile": 0.27625}, "CVE-2024-13078": {"epss_score": 0.00135, "epss_percentile": 0.3393}, "CVE-2024-13079": {"epss_score": 0.00136, "epss_percentile": 0.34163}, "CVE-2024-13080": {"epss_score": 0.00085, "epss_percentile": 0.25156}, "CVE-2024-13081": {"epss_score": 0.00091, "epss_percentile": 0.26265}, "CVE-2024-13082": {"epss_score": 0.00091, "epss_percentile": 0.26265}, "CVE-2024-13083": {"epss_score": 0.00091, "epss_percentile": 0.26265}, "CVE-2024-13084": {"epss_score": 0.00125, "epss_percentile": 0.32553}, "CVE-2024-13085": {"epss_score": 0.0013, "epss_percentile": 0.33291}, "CVE-2024-13086": {"epss_score": 0.00098, "epss_percentile": 0.2781}, "CVE-2024-13087": {"epss_score": 0.00018, "epss_percentile": 0.03607}, "CVE-2024-13088": {"epss_score": 0.00029, "epss_percentile": 0.07832}, "CVE-2024-13089": {"epss_score": 0.0012, "epss_percentile": 0.31692}, "CVE-2024-13090": {"epss_score": 0.00014, "epss_percentile": 0.01769}, "CVE-2024-13091": {"epss_score": 0.08316, "epss_percentile": 0.91989}, "CVE-2024-13092": {"epss_score": 0.00028, "epss_percentile": 0.07212}, "CVE-2024-13093": {"epss_score": 0.00028, "epss_percentile": 0.07212}, "CVE-2024-13094": {"epss_score": 0.00025, "epss_percentile": 0.0605}, "CVE-2024-13095": {"epss_score": 0.00021, "epss_percentile": 0.04816}, "CVE-2024-13096": {"epss_score": 0.00039, "epss_percentile": 0.11697}, "CVE-2024-13097": {"epss_score": 0.00111, "epss_percentile": 0.30365}, "CVE-2024-13098": {"epss_score": 0.00111, "epss_percentile": 0.30365}, "CVE-2024-13099": {"epss_score": 0.00111, "epss_percentile": 0.30365}, "CVE-2024-13100": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-13101": {"epss_score": 0.00021, "epss_percentile": 0.04749}, "CVE-2024-13102": {"epss_score": 0.00143, "epss_percentile": 0.35185}, "CVE-2024-13103": {"epss_score": 0.00122, "epss_percentile": 0.32135}, "CVE-2024-13104": {"epss_score": 0.00143, "epss_percentile": 0.35185}, "CVE-2024-13105": {"epss_score": 0.00143, "epss_percentile": 0.35185}, "CVE-2024-13106": {"epss_score": 0.00143, "epss_percentile": 0.35185}, "CVE-2024-13107": {"epss_score": 0.00143, "epss_percentile": 0.35185}, "CVE-2024-13108": {"epss_score": 0.00143, "epss_percentile": 0.35185}, "CVE-2024-13109": {"epss_score": 0.00106, "epss_percentile": 0.29466}, "CVE-2024-13110": {"epss_score": 0.00105, "epss_percentile": 0.29397}, "CVE-2024-13111": {"epss_score": 0.0032, "epss_percentile": 0.54609}, "CVE-2024-13112": {"epss_score": 0.00077, "epss_percentile": 0.23294}, "CVE-2024-13113": {"epss_score": 0.00093, "epss_percentile": 0.26678}, "CVE-2024-13114": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-13115": {"epss_score": 0.00043, "epss_percentile": 0.13218}, "CVE-2024-13116": {"epss_score": 0.00033, "epss_percentile": 0.09431}, "CVE-2024-13117": {"epss_score": 0.00295, "epss_percentile": 0.52501}, "CVE-2024-13118": {"epss_score": 0.00038, "epss_percentile": 0.11384}, "CVE-2024-13119": {"epss_score": 0.00098, "epss_percentile": 0.27778}, "CVE-2024-13120": {"epss_score": 0.00098, "epss_percentile": 0.27778}, "CVE-2024-13121": {"epss_score": 0.00098, "epss_percentile": 0.27778}, "CVE-2024-13122": {"epss_score": 0.00057, "epss_percentile": 0.18026}, "CVE-2024-13123": {"epss_score": 0.00057, "epss_percentile": 0.18026}, "CVE-2024-13124": {"epss_score": 0.00072, "epss_percentile": 0.2224}, "CVE-2024-13125": {"epss_score": 0.00087, "epss_percentile": 0.25514}, "CVE-2024-13126": {"epss_score": 0.00607, "epss_percentile": 0.69054}, "CVE-2024-13127": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13128": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13129": {"epss_score": 0.00964, "epss_percentile": 0.76034}, "CVE-2024-13130": {"epss_score": 0.00166, "epss_percentile": 0.38153}, "CVE-2024-13132": {"epss_score": 0.00092, "epss_percentile": 0.2643}, "CVE-2024-13133": {"epss_score": 0.00183, "epss_percentile": 0.40343}, "CVE-2024-13134": {"epss_score": 0.00171, "epss_percentile": 0.38813}, "CVE-2024-13135": {"epss_score": 0.00092, "epss_percentile": 0.2643}, "CVE-2024-13136": {"epss_score": 0.00148, "epss_percentile": 0.3589}, "CVE-2024-13137": {"epss_score": 0.00125, "epss_percentile": 0.32583}, "CVE-2024-13138": {"epss_score": 0.00182, "epss_percentile": 0.40188}, "CVE-2024-13139": {"epss_score": 0.00192, "epss_percentile": 0.41329}, "CVE-2024-13140": {"epss_score": 0.00098, "epss_percentile": 0.27757}, "CVE-2024-13141": {"epss_score": 0.00064, "epss_percentile": 0.20327}, "CVE-2024-13142": {"epss_score": 0.00109, "epss_percentile": 0.29974}, "CVE-2024-13143": {"epss_score": 0.00103, "epss_percentile": 0.2904}, "CVE-2024-13144": {"epss_score": 0.00202, "epss_percentile": 0.42487}, "CVE-2024-13145": {"epss_score": 0.00202, "epss_percentile": 0.42487}, "CVE-2024-13146": {"epss_score": 0.00043, "epss_percentile": 0.13223}, "CVE-2024-13147": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2024-13148": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2024-13149": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2024-13150": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2024-13151": {"epss_score": 0.00043, "epss_percentile": 0.13311}, "CVE-2024-13152": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2024-13153": {"epss_score": 0.00079, "epss_percentile": 0.23975}, "CVE-2024-13155": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13156": {"epss_score": 0.00119, "epss_percentile": 0.31561}, "CVE-2024-13157": {"epss_score": 0.00133, "epss_percentile": 0.33676}, "CVE-2024-13158": {"epss_score": 0.392, "epss_percentile": 0.97145}, "CVE-2024-13159": {"epss_score": 0.94138, "epss_percentile": 0.99907}, "CVE-2024-13160": {"epss_score": 0.92818, "epss_percentile": 0.99752}, "CVE-2024-13161": {"epss_score": 0.9131, "epss_percentile": 0.99633}, "CVE-2024-13162": {"epss_score": 0.19718, "epss_percentile": 0.95231}, "CVE-2024-13163": {"epss_score": 0.01264, "epss_percentile": 0.78993}, "CVE-2024-13164": {"epss_score": 0.00153, "epss_percentile": 0.36507}, "CVE-2024-13165": {"epss_score": 0.02218, "epss_percentile": 0.84043}, "CVE-2024-13166": {"epss_score": 0.02218, "epss_percentile": 0.84043}, "CVE-2024-13167": {"epss_score": 0.02218, "epss_percentile": 0.84043}, "CVE-2024-13168": {"epss_score": 0.02218, "epss_percentile": 0.84043}, "CVE-2024-13169": {"epss_score": 0.00153, "epss_percentile": 0.36507}, "CVE-2024-13170": {"epss_score": 0.02218, "epss_percentile": 0.84043}, "CVE-2024-13171": {"epss_score": 0.00122, "epss_percentile": 0.32056}, "CVE-2024-13172": {"epss_score": 0.00038, "epss_percentile": 0.11339}, "CVE-2024-13173": {"epss_score": 0.00146, "epss_percentile": 0.35612}, "CVE-2024-13174": {"epss_score": 0.00045, "epss_percentile": 0.13716}, "CVE-2024-13175": {"epss_score": 0.00015, "epss_percentile": 0.0254}, "CVE-2024-13176": {"epss_score": 0.001, "epss_percentile": 0.28548}, "CVE-2024-13177": {"epss_score": 0.00022, "epss_percentile": 0.05033}, "CVE-2024-13178": {"epss_score": 0.00083, "epss_percentile": 0.24733}, "CVE-2024-13179": {"epss_score": 0.15617, "epss_percentile": 0.9447}, "CVE-2024-13180": {"epss_score": 0.05379, "epss_percentile": 0.89806}, "CVE-2024-13181": {"epss_score": 0.14593, "epss_percentile": 0.94247}, "CVE-2024-13182": {"epss_score": 0.00505, "epss_percentile": 0.65605}, "CVE-2024-13183": {"epss_score": 0.00136, "epss_percentile": 0.34161}, "CVE-2024-13184": {"epss_score": 0.0167, "epss_percentile": 0.81673}, "CVE-2024-13185": {"epss_score": 0.00146, "epss_percentile": 0.35612}, "CVE-2024-13186": {"epss_score": 0.00146, "epss_percentile": 0.35612}, "CVE-2024-13187": {"epss_score": 0.00096, "epss_percentile": 0.27339}, "CVE-2024-13188": {"epss_score": 0.00048, "epss_percentile": 0.15223}, "CVE-2024-13189": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-13190": {"epss_score": 0.00153, "epss_percentile": 0.3658}, "CVE-2024-13191": {"epss_score": 0.00202, "epss_percentile": 0.42487}, "CVE-2024-13192": {"epss_score": 0.001, "epss_percentile": 0.28511}, "CVE-2024-13193": {"epss_score": 0.00107, "epss_percentile": 0.29698}, "CVE-2024-13194": {"epss_score": 0.00142, "epss_percentile": 0.35036}, "CVE-2024-13195": {"epss_score": 0.00202, "epss_percentile": 0.42487}, "CVE-2024-13196": {"epss_score": 0.001, "epss_percentile": 0.28511}, "CVE-2024-13197": {"epss_score": 0.001, "epss_percentile": 0.28511}, "CVE-2024-13198": {"epss_score": 0.00131, "epss_percentile": 0.3342}, "CVE-2024-13199": {"epss_score": 0.00031, "epss_percentile": 0.0845}, "CVE-2024-13200": {"epss_score": 0.00112, "epss_percentile": 0.30545}, "CVE-2024-13201": {"epss_score": 0.00193, "epss_percentile": 0.41407}, "CVE-2024-13202": {"epss_score": 0.00121, "epss_percentile": 0.31944}, "CVE-2024-13203": {"epss_score": 0.00036, "epss_percentile": 0.10243}, "CVE-2024-13204": {"epss_score": 0.00027, "epss_percentile": 0.07138}, "CVE-2024-13205": {"epss_score": 0.00036, "epss_percentile": 0.103}, "CVE-2024-13206": {"epss_score": 0.00029, "epss_percentile": 0.07817}, "CVE-2024-13207": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2024-13208": {"epss_score": 0.00028, "epss_percentile": 0.07308}, "CVE-2024-13209": {"epss_score": 0.00117, "epss_percentile": 0.31263}, "CVE-2024-13210": {"epss_score": 0.00193, "epss_percentile": 0.41407}, "CVE-2024-13211": {"epss_score": 0.00171, "epss_percentile": 0.38813}, "CVE-2024-13212": {"epss_score": 0.00171, "epss_percentile": 0.38813}, "CVE-2024-13213": {"epss_score": 0.00089, "epss_percentile": 0.25966}, "CVE-2024-13215": {"epss_score": 0.00172, "epss_percentile": 0.38977}, "CVE-2024-13216": {"epss_score": 0.00122, "epss_percentile": 0.32134}, "CVE-2024-13217": {"epss_score": 0.0016, "epss_percentile": 0.37465}, "CVE-2024-13218": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-13219": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-13220": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-13221": {"epss_score": 0.00077, "epss_percentile": 0.23294}, "CVE-2024-13222": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-13223": {"epss_score": 0.00077, "epss_percentile": 0.23294}, "CVE-2024-13224": {"epss_score": 0.00077, "epss_percentile": 0.23294}, "CVE-2024-13225": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-13226": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-13227": {"epss_score": 0.00162, "epss_percentile": 0.37659}, "CVE-2024-13228": {"epss_score": 0.00171, "epss_percentile": 0.38768}, "CVE-2024-13229": {"epss_score": 0.00131, "epss_percentile": 0.33459}, "CVE-2024-13230": {"epss_score": 0.00472, "epss_percentile": 0.64052}, "CVE-2024-13231": {"epss_score": 0.00376, "epss_percentile": 0.58652}, "CVE-2024-13232": {"epss_score": 0.00311, "epss_percentile": 0.53823}, "CVE-2024-13234": {"epss_score": 0.00878, "epss_percentile": 0.74833}, "CVE-2024-13235": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-13236": {"epss_score": 0.00252, "epss_percentile": 0.48413}, "CVE-2024-13237": {"epss_score": 0.00135, "epss_percentile": 0.34034}, "CVE-2024-13238": {"epss_score": 0.00135, "epss_percentile": 0.34034}, "CVE-2024-13239": {"epss_score": 0.00204, "epss_percentile": 0.42666}, "CVE-2024-13240": {"epss_score": 0.00152, "epss_percentile": 0.36446}, "CVE-2024-13241": {"epss_score": 0.00144, "epss_percentile": 0.35257}, "CVE-2024-13242": {"epss_score": 0.00178, "epss_percentile": 0.3966}, "CVE-2024-13243": {"epss_score": 0.00098, "epss_percentile": 0.27771}, "CVE-2024-13244": {"epss_score": 0.00061, "epss_percentile": 0.19347}, "CVE-2024-13245": {"epss_score": 0.00135, "epss_percentile": 0.34034}, "CVE-2024-13246": {"epss_score": 0.0012, "epss_percentile": 0.317}, "CVE-2024-13247": {"epss_score": 0.00122, "epss_percentile": 0.32165}, "CVE-2024-13248": {"epss_score": 0.00076, "epss_percentile": 0.23242}, "CVE-2024-13249": {"epss_score": 0.00094, "epss_percentile": 0.26768}, "CVE-2024-13250": {"epss_score": 0.00061, "epss_percentile": 0.19347}, "CVE-2024-13251": {"epss_score": 0.00192, "epss_percentile": 0.41355}, "CVE-2024-13252": {"epss_score": 0.00135, "epss_percentile": 0.34034}, "CVE-2024-13253": {"epss_score": 0.00195, "epss_percentile": 0.41626}, "CVE-2024-13254": {"epss_score": 0.00178, "epss_percentile": 0.3966}, "CVE-2024-13255": {"epss_score": 0.00063, "epss_percentile": 0.19956}, "CVE-2024-13256": {"epss_score": 0.0012, "epss_percentile": 0.317}, "CVE-2024-13257": {"epss_score": 0.0012, "epss_percentile": 0.31804}, "CVE-2024-13258": {"epss_score": 0.00204, "epss_percentile": 0.42666}, "CVE-2024-13259": {"epss_score": 0.00178, "epss_percentile": 0.3966}, "CVE-2024-13260": {"epss_score": 0.00061, "epss_percentile": 0.19347}, "CVE-2024-13261": {"epss_score": 0.00042, "epss_percentile": 0.12806}, "CVE-2024-13262": {"epss_score": 0.00078, "epss_percentile": 0.23575}, "CVE-2024-13263": {"epss_score": 0.00085, "epss_percentile": 0.2518}, "CVE-2024-13264": {"epss_score": 0.00213, "epss_percentile": 0.439}, "CVE-2024-13265": {"epss_score": 0.00156, "epss_percentile": 0.36957}, "CVE-2024-13266": {"epss_score": 0.00116, "epss_percentile": 0.31088}, "CVE-2024-13267": {"epss_score": 0.00156, "epss_percentile": 0.36957}, "CVE-2024-13268": {"epss_score": 0.00087, "epss_percentile": 0.25487}, "CVE-2024-13269": {"epss_score": 0.00131, "epss_percentile": 0.3339}, "CVE-2024-13270": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2024-13271": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2024-13272": {"epss_score": 0.00117, "epss_percentile": 0.3129}, "CVE-2024-13273": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2024-13274": {"epss_score": 0.00096, "epss_percentile": 0.27385}, "CVE-2024-13275": {"epss_score": 0.00179, "epss_percentile": 0.3977}, "CVE-2024-13276": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2024-13277": {"epss_score": 0.00138, "epss_percentile": 0.34514}, "CVE-2024-13278": {"epss_score": 0.00138, "epss_percentile": 0.34514}, "CVE-2024-13279": {"epss_score": 0.00173, "epss_percentile": 0.39043}, "CVE-2024-13280": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-13281": {"epss_score": 0.00138, "epss_percentile": 0.34514}, "CVE-2024-13282": {"epss_score": 0.00116, "epss_percentile": 0.31146}, "CVE-2024-13283": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2024-13284": {"epss_score": 0.00058, "epss_percentile": 0.18265}, "CVE-2024-13285": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2024-13286": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2024-13287": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2024-13288": {"epss_score": 0.00107, "epss_percentile": 0.29655}, "CVE-2024-13289": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2024-13290": {"epss_score": 0.00116, "epss_percentile": 0.31088}, "CVE-2024-13291": {"epss_score": 0.00124, "epss_percentile": 0.32463}, "CVE-2024-13292": {"epss_score": 0.00078, "epss_percentile": 0.23575}, "CVE-2024-13293": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2024-13294": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2024-13295": {"epss_score": 0.0016, "epss_percentile": 0.37487}, "CVE-2024-13296": {"epss_score": 0.0016, "epss_percentile": 0.37487}, "CVE-2024-13297": {"epss_score": 0.00441, "epss_percentile": 0.62679}, "CVE-2024-13298": {"epss_score": 0.00078, "epss_percentile": 0.23575}, "CVE-2024-13299": {"epss_score": 0.00163, "epss_percentile": 0.37762}, "CVE-2024-13300": {"epss_score": 0.00163, "epss_percentile": 0.37762}, "CVE-2024-13301": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2024-13302": {"epss_score": 0.00116, "epss_percentile": 0.31088}, "CVE-2024-13303": {"epss_score": 0.00126, "epss_percentile": 0.32645}, "CVE-2024-13304": {"epss_score": 0.00044, "epss_percentile": 0.13588}, "CVE-2024-13305": {"epss_score": 0.00078, "epss_percentile": 0.23575}, "CVE-2024-13306": {"epss_score": 0.00028, "epss_percentile": 0.07308}, "CVE-2024-13307": {"epss_score": 0.00179, "epss_percentile": 0.39796}, "CVE-2024-13308": {"epss_score": 0.00104, "epss_percentile": 0.29113}, "CVE-2024-13309": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2024-13310": {"epss_score": 0.00151, "epss_percentile": 0.36325}, "CVE-2024-13311": {"epss_score": 0.00112, "epss_percentile": 0.30552}, "CVE-2024-13312": {"epss_score": 0.0012, "epss_percentile": 0.31804}, "CVE-2024-13313": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13314": {"epss_score": 0.00087, "epss_percentile": 0.25514}, "CVE-2024-13315": {"epss_score": 0.00057, "epss_percentile": 0.18006}, "CVE-2024-13316": {"epss_score": 0.00247, "epss_percentile": 0.47865}, "CVE-2024-13317": {"epss_score": 0.00033, "epss_percentile": 0.09328}, "CVE-2024-13318": {"epss_score": 0.00411, "epss_percentile": 0.60873}, "CVE-2024-13319": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-13320": {"epss_score": 0.00245, "epss_percentile": 0.47625}, "CVE-2024-13321": {"epss_score": 0.00229, "epss_percentile": 0.4557}, "CVE-2024-13322": {"epss_score": 0.16565, "epss_percentile": 0.94693}, "CVE-2024-13323": {"epss_score": 0.00079, "epss_percentile": 0.23975}, "CVE-2024-13325": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-13326": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-13327": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-13328": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-13329": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-13330": {"epss_score": 0.00029, "epss_percentile": 0.07935}, "CVE-2024-13331": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-13332": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-13333": {"epss_score": 0.02407, "epss_percentile": 0.84655}, "CVE-2024-13334": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-13335": {"epss_score": 0.00102, "epss_percentile": 0.2876}, "CVE-2024-13336": {"epss_score": 0.0004, "epss_percentile": 0.11873}, "CVE-2024-13337": {"epss_score": 0.00023, "epss_percentile": 0.05411}, "CVE-2024-13338": {"epss_score": 0.00026, "epss_percentile": 0.06413}, "CVE-2024-13339": {"epss_score": 0.00057, "epss_percentile": 0.18002}, "CVE-2024-13340": {"epss_score": 0.00083, "epss_percentile": 0.24726}, "CVE-2024-13341": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-13342": {"epss_score": 0.00273, "epss_percentile": 0.50465}, "CVE-2024-13343": {"epss_score": 0.00176, "epss_percentile": 0.39416}, "CVE-2024-13344": {"epss_score": 0.0008, "epss_percentile": 0.24055}, "CVE-2024-13345": {"epss_score": 0.01497, "epss_percentile": 0.80692}, "CVE-2024-13346": {"epss_score": 0.35443, "epss_percentile": 0.9691}, "CVE-2024-13347": {"epss_score": 0.00094, "epss_percentile": 0.26791}, "CVE-2024-13349": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13350": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13351": {"epss_score": 0.00154, "epss_percentile": 0.36718}, "CVE-2024-13352": {"epss_score": 0.00029, "epss_percentile": 0.07935}, "CVE-2024-13353": {"epss_score": 0.00493, "epss_percentile": 0.6506}, "CVE-2024-13354": {"epss_score": 0.00056, "epss_percentile": 0.17765}, "CVE-2024-13355": {"epss_score": 0.001, "epss_percentile": 0.28441}, "CVE-2024-13356": {"epss_score": 0.00049, "epss_percentile": 0.15458}, "CVE-2024-13357": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13358": {"epss_score": 0.00139, "epss_percentile": 0.34666}, "CVE-2024-13359": {"epss_score": 0.02056, "epss_percentile": 0.83426}, "CVE-2024-13360": {"epss_score": 0.00093, "epss_percentile": 0.26665}, "CVE-2024-13361": {"epss_score": 0.00287, "epss_percentile": 0.51792}, "CVE-2024-13363": {"epss_score": 0.00676, "epss_percentile": 0.70919}, "CVE-2024-13364": {"epss_score": 0.00341, "epss_percentile": 0.56322}, "CVE-2024-13365": {"epss_score": 0.02859, "epss_percentile": 0.85847}, "CVE-2024-13366": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-13367": {"epss_score": 0.00286, "epss_percentile": 0.51738}, "CVE-2024-13368": {"epss_score": 0.00102, "epss_percentile": 0.2876}, "CVE-2024-13369": {"epss_score": 0.00113, "epss_percentile": 0.30656}, "CVE-2024-13370": {"epss_score": 0.00138, "epss_percentile": 0.34509}, "CVE-2024-13371": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2024-13372": {"epss_score": 0.00175, "epss_percentile": 0.39288}, "CVE-2024-13373": {"epss_score": 0.00231, "epss_percentile": 0.45772}, "CVE-2024-13374": {"epss_score": 0.0014, "epss_percentile": 0.34734}, "CVE-2024-13375": {"epss_score": 0.12001, "epss_percentile": 0.93543}, "CVE-2024-13376": {"epss_score": 0.00154, "epss_percentile": 0.36656}, "CVE-2024-13377": {"epss_score": 0.00811, "epss_percentile": 0.73739}, "CVE-2024-13378": {"epss_score": 0.00515, "epss_percentile": 0.66004}, "CVE-2024-13379": {"epss_score": 0.00065, "epss_percentile": 0.20453}, "CVE-2024-13380": {"epss_score": 0.00119, "epss_percentile": 0.31548}, "CVE-2024-13381": {"epss_score": 0.00034, "epss_percentile": 0.09564}, "CVE-2024-13382": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13383": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13384": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13385": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-13386": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-13387": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-13388": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13389": {"epss_score": 0.00056, "epss_percentile": 0.17765}, "CVE-2024-13390": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13391": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-13392": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-13393": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-13394": {"epss_score": 0.00106, "epss_percentile": 0.29465}, "CVE-2024-13395": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13396": {"epss_score": 0.00119, "epss_percentile": 0.31548}, "CVE-2024-13397": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13398": {"epss_score": 0.00093, "epss_percentile": 0.26726}, "CVE-2024-13399": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13400": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13401": {"epss_score": 0.00119, "epss_percentile": 0.31561}, "CVE-2024-13402": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13403": {"epss_score": 0.00185, "epss_percentile": 0.40479}, "CVE-2024-13404": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-13405": {"epss_score": 0.0004, "epss_percentile": 0.11873}, "CVE-2024-13406": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-13407": {"epss_score": 0.00102, "epss_percentile": 0.28893}, "CVE-2024-13408": {"epss_score": 0.00443, "epss_percentile": 0.62769}, "CVE-2024-13409": {"epss_score": 0.00436, "epss_percentile": 0.62452}, "CVE-2024-13410": {"epss_score": 0.01901, "epss_percentile": 0.82777}, "CVE-2024-13411": {"epss_score": 0.00149, "epss_percentile": 0.35961}, "CVE-2024-13412": {"epss_score": 0.00212, "epss_percentile": 0.43794}, "CVE-2024-13413": {"epss_score": 0.00661, "epss_percentile": 0.70581}, "CVE-2024-13415": {"epss_score": 0.00113, "epss_percentile": 0.30668}, "CVE-2024-13416": {"epss_score": 0.00115, "epss_percentile": 0.30948}, "CVE-2024-13417": {"epss_score": 0.00023, "epss_percentile": 0.05607}, "CVE-2024-13418": {"epss_score": 0.00416, "epss_percentile": 0.61182}, "CVE-2024-13419": {"epss_score": 0.00028, "epss_percentile": 0.07515}, "CVE-2024-13420": {"epss_score": 0.0004, "epss_percentile": 0.12182}, "CVE-2024-13421": {"epss_score": 0.00571, "epss_percentile": 0.67974}, "CVE-2024-13422": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-13423": {"epss_score": 0.00224, "epss_percentile": 0.45056}, "CVE-2024-13424": {"epss_score": 0.00122, "epss_percentile": 0.32106}, "CVE-2024-13425": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2024-13426": {"epss_score": 0.00524, "epss_percentile": 0.6634}, "CVE-2024-13427": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2024-13428": {"epss_score": 0.00173, "epss_percentile": 0.39134}, "CVE-2024-13429": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2024-13430": {"epss_score": 0.00098, "epss_percentile": 0.27641}, "CVE-2024-13431": {"epss_score": 0.00756, "epss_percentile": 0.72745}, "CVE-2024-13432": {"epss_score": 0.00049, "epss_percentile": 0.15345}, "CVE-2024-13433": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-13434": {"epss_score": 0.00665, "epss_percentile": 0.7067}, "CVE-2024-13435": {"epss_score": 0.00366, "epss_percentile": 0.58072}, "CVE-2024-13436": {"epss_score": 0.00036, "epss_percentile": 0.10614}, "CVE-2024-13437": {"epss_score": 0.0004, "epss_percentile": 0.11874}, "CVE-2024-13438": {"epss_score": 0.0004, "epss_percentile": 0.11873}, "CVE-2024-13439": {"epss_score": 0.00138, "epss_percentile": 0.34505}, "CVE-2024-13440": {"epss_score": 0.00366, "epss_percentile": 0.58072}, "CVE-2024-13441": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-13442": {"epss_score": 0.00228, "epss_percentile": 0.4551}, "CVE-2024-13443": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13444": {"epss_score": 0.00091, "epss_percentile": 0.26408}, "CVE-2024-13445": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13446": {"epss_score": 0.00482, "epss_percentile": 0.64555}, "CVE-2024-13447": {"epss_score": 0.00145, "epss_percentile": 0.3535}, "CVE-2024-13448": {"epss_score": 0.03204, "epss_percentile": 0.86628}, "CVE-2024-13449": {"epss_score": 0.00099, "epss_percentile": 0.28399}, "CVE-2024-13450": {"epss_score": 0.00338, "epss_percentile": 0.56153}, "CVE-2024-13451": {"epss_score": 0.00068, "epss_percentile": 0.21264}, "CVE-2024-13452": {"epss_score": 0.00081, "epss_percentile": 0.24309}, "CVE-2024-13453": {"epss_score": 0.01811, "epss_percentile": 0.82366}, "CVE-2024-13454": {"epss_score": 0.00013, "epss_percentile": 0.01719}, "CVE-2024-13455": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13456": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13457": {"epss_score": 0.00154, "epss_percentile": 0.3667}, "CVE-2024-13458": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-13459": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13460": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13461": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13462": {"epss_score": 0.00119, "epss_percentile": 0.31548}, "CVE-2024-13463": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13464": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13465": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13466": {"epss_score": 0.00133, "epss_percentile": 0.33676}, "CVE-2024-13467": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-13468": {"epss_score": 0.00216, "epss_percentile": 0.44143}, "CVE-2024-13469": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13470": {"epss_score": 0.00111, "epss_percentile": 0.30401}, "CVE-2024-13471": {"epss_score": 0.01163, "epss_percentile": 0.78158}, "CVE-2024-13472": {"epss_score": 0.02023, "epss_percentile": 0.83307}, "CVE-2024-13473": {"epss_score": 0.00474, "epss_percentile": 0.64143}, "CVE-2024-13474": {"epss_score": 0.00366, "epss_percentile": 0.58072}, "CVE-2024-13475": {"epss_score": 0.00711, "epss_percentile": 0.71733}, "CVE-2024-13476": {"epss_score": 0.00366, "epss_percentile": 0.58072}, "CVE-2024-13477": {"epss_score": 0.00378, "epss_percentile": 0.58808}, "CVE-2024-13478": {"epss_score": 0.19834, "epss_percentile": 0.95248}, "CVE-2024-13479": {"epss_score": 0.03293, "epss_percentile": 0.86841}, "CVE-2024-13480": {"epss_score": 0.00366, "epss_percentile": 0.58072}, "CVE-2024-13481": {"epss_score": 0.11991, "epss_percentile": 0.93539}, "CVE-2024-13482": {"epss_score": 0.00029, "epss_percentile": 0.07656}, "CVE-2024-13483": {"epss_score": 0.03293, "epss_percentile": 0.86841}, "CVE-2024-13484": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2024-13485": {"epss_score": 0.11991, "epss_percentile": 0.93539}, "CVE-2024-13486": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13487": {"epss_score": 0.02023, "epss_percentile": 0.83307}, "CVE-2024-13488": {"epss_score": 0.14545, "epss_percentile": 0.94237}, "CVE-2024-13489": {"epss_score": 0.03293, "epss_percentile": 0.86841}, "CVE-2024-13490": {"epss_score": 0.00366, "epss_percentile": 0.58072}, "CVE-2024-13491": {"epss_score": 0.00366, "epss_percentile": 0.58072}, "CVE-2024-13492": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-13493": {"epss_score": 0.00025, "epss_percentile": 0.0628}, "CVE-2024-13494": {"epss_score": 0.00062, "epss_percentile": 0.19719}, "CVE-2024-13495": {"epss_score": 0.01876, "epss_percentile": 0.82658}, "CVE-2024-13496": {"epss_score": 0.38683, "epss_percentile": 0.97115}, "CVE-2024-13497": {"epss_score": 0.00575, "epss_percentile": 0.68116}, "CVE-2024-13498": {"epss_score": 0.00207, "epss_percentile": 0.4308}, "CVE-2024-13499": {"epss_score": 0.01477, "epss_percentile": 0.80542}, "CVE-2024-13500": {"epss_score": 0.00115, "epss_percentile": 0.31024}, "CVE-2024-13501": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13502": {"epss_score": 0.01257, "epss_percentile": 0.78943}, "CVE-2024-13503": {"epss_score": 0.00407, "epss_percentile": 0.60609}, "CVE-2024-13504": {"epss_score": 0.00712, "epss_percentile": 0.71773}, "CVE-2024-13505": {"epss_score": 0.00131, "epss_percentile": 0.3343}, "CVE-2024-13506": {"epss_score": 0.00119, "epss_percentile": 0.31548}, "CVE-2024-13507": {"epss_score": 0.00098, "epss_percentile": 0.27706}, "CVE-2024-13508": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2024-13509": {"epss_score": 0.00756, "epss_percentile": 0.72745}, "CVE-2024-13510": {"epss_score": 0.00042, "epss_percentile": 0.12599}, "CVE-2024-13511": {"epss_score": 0.00044, "epss_percentile": 0.13678}, "CVE-2024-13512": {"epss_score": 0.00042, "epss_percentile": 0.12606}, "CVE-2024-13513": {"epss_score": 0.00392, "epss_percentile": 0.597}, "CVE-2024-13514": {"epss_score": 0.00098, "epss_percentile": 0.27641}, "CVE-2024-13515": {"epss_score": 0.01031, "epss_percentile": 0.76853}, "CVE-2024-13516": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-13517": {"epss_score": 0.00109, "epss_percentile": 0.30031}, "CVE-2024-13518": {"epss_score": 0.0004, "epss_percentile": 0.11873}, "CVE-2024-13519": {"epss_score": 0.00094, "epss_percentile": 0.26998}, "CVE-2024-13520": {"epss_score": 0.0036, "epss_percentile": 0.5762}, "CVE-2024-13521": {"epss_score": 0.00042, "epss_percentile": 0.12606}, "CVE-2024-13522": {"epss_score": 0.00057, "epss_percentile": 0.18}, "CVE-2024-13523": {"epss_score": 0.00065, "epss_percentile": 0.20465}, "CVE-2024-13524": {"epss_score": 0.00011, "epss_percentile": 0.011}, "CVE-2024-13525": {"epss_score": 0.00183, "epss_percentile": 0.40293}, "CVE-2024-13526": {"epss_score": 0.00037, "epss_percentile": 0.11}, "CVE-2024-13527": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13528": {"epss_score": 0.00143, "epss_percentile": 0.35163}, "CVE-2024-13529": {"epss_score": 0.00136, "epss_percentile": 0.34129}, "CVE-2024-13530": {"epss_score": 0.00143, "epss_percentile": 0.35169}, "CVE-2024-13531": {"epss_score": 0.00366, "epss_percentile": 0.58072}, "CVE-2024-13532": {"epss_score": 0.00452, "epss_percentile": 0.6317}, "CVE-2024-13533": {"epss_score": 0.00452, "epss_percentile": 0.6317}, "CVE-2024-13534": {"epss_score": 0.00366, "epss_percentile": 0.58072}, "CVE-2024-13535": {"epss_score": 0.01127, "epss_percentile": 0.77819}, "CVE-2024-13536": {"epss_score": 0.00402, "epss_percentile": 0.60262}, "CVE-2024-13537": {"epss_score": 0.00373, "epss_percentile": 0.5852}, "CVE-2024-13538": {"epss_score": 0.00832, "epss_percentile": 0.74065}, "CVE-2024-13539": {"epss_score": 0.00375, "epss_percentile": 0.58629}, "CVE-2024-13540": {"epss_score": 0.00344, "epss_percentile": 0.56522}, "CVE-2024-13541": {"epss_score": 0.00143, "epss_percentile": 0.35169}, "CVE-2024-13542": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-13543": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-13544": {"epss_score": 0.00025, "epss_percentile": 0.0628}, "CVE-2024-13545": {"epss_score": 0.04314, "epss_percentile": 0.88536}, "CVE-2024-13546": {"epss_score": 0.0016, "epss_percentile": 0.37465}, "CVE-2024-13547": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13548": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-13549": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13550": {"epss_score": 0.00576, "epss_percentile": 0.68131}, "CVE-2024-13551": {"epss_score": 0.00065, "epss_percentile": 0.20621}, "CVE-2024-13552": {"epss_score": 0.00063, "epss_percentile": 0.2005}, "CVE-2024-13553": {"epss_score": 0.00246, "epss_percentile": 0.47754}, "CVE-2024-13554": {"epss_score": 0.0021, "epss_percentile": 0.43615}, "CVE-2024-13555": {"epss_score": 0.0004, "epss_percentile": 0.11873}, "CVE-2024-13556": {"epss_score": 0.01881, "epss_percentile": 0.82689}, "CVE-2024-13557": {"epss_score": 0.00626, "epss_percentile": 0.69616}, "CVE-2024-13558": {"epss_score": 0.00105, "epss_percentile": 0.29273}, "CVE-2024-13559": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13560": {"epss_score": 0.00041, "epss_percentile": 0.12362}, "CVE-2024-13561": {"epss_score": 0.00133, "epss_percentile": 0.33676}, "CVE-2024-13562": {"epss_score": 0.00665, "epss_percentile": 0.7067}, "CVE-2024-13563": {"epss_score": 0.00107, "epss_percentile": 0.29601}, "CVE-2024-13564": {"epss_score": 0.00095, "epss_percentile": 0.2719}, "CVE-2024-13565": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13566": {"epss_score": 0.00133, "epss_percentile": 0.33676}, "CVE-2024-13567": {"epss_score": 0.0017, "epss_percentile": 0.38653}, "CVE-2024-13568": {"epss_score": 0.00268, "epss_percentile": 0.50085}, "CVE-2024-13569": {"epss_score": 0.00059, "epss_percentile": 0.18664}, "CVE-2024-13570": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-13571": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-13572": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-13573": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13574": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-13575": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13576": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13577": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13578": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13579": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13580": {"epss_score": 0.00045, "epss_percentile": 0.13968}, "CVE-2024-13581": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13582": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13583": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-13584": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-13585": {"epss_score": 0.00025, "epss_percentile": 0.0628}, "CVE-2024-13586": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-13587": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13588": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13589": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13590": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-13591": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13592": {"epss_score": 0.00238, "epss_percentile": 0.46818}, "CVE-2024-13593": {"epss_score": 0.00437, "epss_percentile": 0.62529}, "CVE-2024-13594": {"epss_score": 0.00225, "epss_percentile": 0.45103}, "CVE-2024-13595": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-13596": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-13597": {"epss_score": 0.00089, "epss_percentile": 0.25831}, "CVE-2024-13598": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2024-13599": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-13600": {"epss_score": 0.00279, "epss_percentile": 0.50958}, "CVE-2024-13601": {"epss_score": 0.00113, "epss_percentile": 0.30663}, "CVE-2024-13602": {"epss_score": 0.00074, "epss_percentile": 0.2276}, "CVE-2024-13603": {"epss_score": 0.00063, "epss_percentile": 0.20092}, "CVE-2024-13604": {"epss_score": 0.00145, "epss_percentile": 0.35439}, "CVE-2024-13605": {"epss_score": 0.00033, "epss_percentile": 0.09376}, "CVE-2024-13606": {"epss_score": 0.00268, "epss_percentile": 0.50085}, "CVE-2024-13607": {"epss_score": 0.00104, "epss_percentile": 0.29146}, "CVE-2024-13608": {"epss_score": 0.00036, "epss_percentile": 0.10605}, "CVE-2024-13609": {"epss_score": 0.0017, "epss_percentile": 0.38705}, "CVE-2024-13610": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2024-13611": {"epss_score": 0.00279, "epss_percentile": 0.50958}, "CVE-2024-13612": {"epss_score": 0.00119, "epss_percentile": 0.31673}, "CVE-2024-13613": {"epss_score": 0.00085, "epss_percentile": 0.25117}, "CVE-2024-13614": {"epss_score": 0.00024, "epss_percentile": 0.05671}, "CVE-2024-13615": {"epss_score": 0.00087, "epss_percentile": 0.25514}, "CVE-2024-13616": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13617": {"epss_score": 0.00172, "epss_percentile": 0.39002}, "CVE-2024-13618": {"epss_score": 0.00084, "epss_percentile": 0.24982}, "CVE-2024-13619": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2024-13621": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13622": {"epss_score": 0.00439, "epss_percentile": 0.62596}, "CVE-2024-13623": {"epss_score": 0.00234, "epss_percentile": 0.46111}, "CVE-2024-13624": {"epss_score": 0.0043, "epss_percentile": 0.62007}, "CVE-2024-13625": {"epss_score": 0.00029, "epss_percentile": 0.07935}, "CVE-2024-13626": {"epss_score": 0.00029, "epss_percentile": 0.07935}, "CVE-2024-13627": {"epss_score": 0.00046, "epss_percentile": 0.14283}, "CVE-2024-13628": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-13629": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-13630": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-13631": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-13632": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-13633": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-13634": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-13635": {"epss_score": 0.00128, "epss_percentile": 0.32948}, "CVE-2024-13637": {"epss_score": 0.00064, "epss_percentile": 0.20399}, "CVE-2024-13638": {"epss_score": 0.00177, "epss_percentile": 0.39506}, "CVE-2024-13639": {"epss_score": 0.00153, "epss_percentile": 0.36577}, "CVE-2024-13640": {"epss_score": 0.00177, "epss_percentile": 0.39506}, "CVE-2024-13641": {"epss_score": 0.00177, "epss_percentile": 0.39506}, "CVE-2024-13642": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13643": {"epss_score": 0.00182, "epss_percentile": 0.40216}, "CVE-2024-13644": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13645": {"epss_score": 0.01323, "epss_percentile": 0.79454}, "CVE-2024-13646": {"epss_score": 0.00146, "epss_percentile": 0.35604}, "CVE-2024-13647": {"epss_score": 0.0004, "epss_percentile": 0.11874}, "CVE-2024-13648": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13649": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13650": {"epss_score": 0.00048, "epss_percentile": 0.15069}, "CVE-2024-13651": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2024-13652": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2024-13653": {"epss_score": 0.00176, "epss_percentile": 0.39416}, "CVE-2024-13654": {"epss_score": 0.00146, "epss_percentile": 0.35604}, "CVE-2024-13655": {"epss_score": 0.00128, "epss_percentile": 0.32963}, "CVE-2024-13656": {"epss_score": 0.00146, "epss_percentile": 0.35604}, "CVE-2024-13657": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13658": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13659": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-13660": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13661": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13662": {"epss_score": 0.00119, "epss_percentile": 0.31548}, "CVE-2024-13663": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13664": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13665": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13666": {"epss_score": 0.00118, "epss_percentile": 0.31462}, "CVE-2024-13667": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13668": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-13669": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-13670": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13671": {"epss_score": 0.01289, "epss_percentile": 0.79209}, "CVE-2024-13672": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13673": {"epss_score": 0.00053, "epss_percentile": 0.16844}, "CVE-2024-13674": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13675": {"epss_score": 0.00067, "epss_percentile": 0.21074}, "CVE-2024-13676": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-13677": {"epss_score": 0.00176, "epss_percentile": 0.39416}, "CVE-2024-13678": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-13679": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13680": {"epss_score": 0.00225, "epss_percentile": 0.45103}, "CVE-2024-13681": {"epss_score": 0.0053, "epss_percentile": 0.66619}, "CVE-2024-13682": {"epss_score": 0.00034, "epss_percentile": 0.09518}, "CVE-2024-13683": {"epss_score": 0.00039, "epss_percentile": 0.11734}, "CVE-2024-13684": {"epss_score": 0.0004, "epss_percentile": 0.11918}, "CVE-2024-13685": {"epss_score": 0.00148, "epss_percentile": 0.35831}, "CVE-2024-13686": {"epss_score": 0.00089, "epss_percentile": 0.2596}, "CVE-2024-13687": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2024-13688": {"epss_score": 0.00077, "epss_percentile": 0.23373}, "CVE-2024-13689": {"epss_score": 0.00305, "epss_percentile": 0.53395}, "CVE-2024-13690": {"epss_score": 0.00533, "epss_percentile": 0.66767}, "CVE-2024-13691": {"epss_score": 0.00154, "epss_percentile": 0.36743}, "CVE-2024-13692": {"epss_score": 0.00193, "epss_percentile": 0.41387}, "CVE-2024-13693": {"epss_score": 0.00344, "epss_percentile": 0.56484}, "CVE-2024-13694": {"epss_score": 0.00235, "epss_percentile": 0.46203}, "CVE-2024-13695": {"epss_score": 0.00098, "epss_percentile": 0.27641}, "CVE-2024-13696": {"epss_score": 0.01078, "epss_percentile": 0.77349}, "CVE-2024-13697": {"epss_score": 0.0028, "epss_percentile": 0.51007}, "CVE-2024-13698": {"epss_score": 0.00452, "epss_percentile": 0.63186}, "CVE-2024-13699": {"epss_score": 0.0017, "epss_percentile": 0.38685}, "CVE-2024-13700": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13701": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13702": {"epss_score": 0.00052, "epss_percentile": 0.16641}, "CVE-2024-13703": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2024-13704": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2024-13705": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2024-13706": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2024-13707": {"epss_score": 0.00087, "epss_percentile": 0.25499}, "CVE-2024-13708": {"epss_score": 0.00259, "epss_percentile": 0.49036}, "CVE-2024-13709": {"epss_score": 0.00012, "epss_percentile": 0.01296}, "CVE-2024-13710": {"epss_score": 0.00023, "epss_percentile": 0.05613}, "CVE-2024-13711": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2024-13712": {"epss_score": 0.00255, "epss_percentile": 0.48673}, "CVE-2024-13713": {"epss_score": 0.00115, "epss_percentile": 0.31024}, "CVE-2024-13714": {"epss_score": 0.00743, "epss_percentile": 0.72495}, "CVE-2024-13715": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2024-13716": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2024-13717": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2024-13718": {"epss_score": 0.0004, "epss_percentile": 0.11873}, "CVE-2024-13719": {"epss_score": 0.00158, "epss_percentile": 0.37175}, "CVE-2024-13720": {"epss_score": 0.0108, "epss_percentile": 0.77364}, "CVE-2024-13721": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-13722": {"epss_score": 0.00211, "epss_percentile": 0.43677}, "CVE-2024-13723": {"epss_score": 0.00612, "epss_percentile": 0.69226}, "CVE-2024-13724": {"epss_score": 0.00238, "epss_percentile": 0.46818}, "CVE-2024-13725": {"epss_score": 0.01188, "epss_percentile": 0.78368}, "CVE-2024-13726": {"epss_score": 0.13988, "epss_percentile": 0.9411}, "CVE-2024-13727": {"epss_score": 0.00073, "epss_percentile": 0.22572}, "CVE-2024-13728": {"epss_score": 0.00152, "epss_percentile": 0.36452}, "CVE-2024-13729": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13730": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-13731": {"epss_score": 0.00068, "epss_percentile": 0.21226}, "CVE-2024-13732": {"epss_score": 0.001, "epss_percentile": 0.2844}, "CVE-2024-13733": {"epss_score": 0.00107, "epss_percentile": 0.29601}, "CVE-2024-13734": {"epss_score": 0.001, "epss_percentile": 0.2844}, "CVE-2024-13735": {"epss_score": 0.001, "epss_percentile": 0.2844}, "CVE-2024-13736": {"epss_score": 0.00756, "epss_percentile": 0.72745}, "CVE-2024-13737": {"epss_score": 0.00095, "epss_percentile": 0.27124}, "CVE-2024-13738": {"epss_score": 0.00478, "epss_percentile": 0.64374}, "CVE-2024-13739": {"epss_score": 0.00388, "epss_percentile": 0.59377}, "CVE-2024-13740": {"epss_score": 0.00106, "epss_percentile": 0.29441}, "CVE-2024-13741": {"epss_score": 0.00051, "epss_percentile": 0.16106}, "CVE-2024-13742": {"epss_score": 0.05112, "epss_percentile": 0.89509}, "CVE-2024-13743": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13744": {"epss_score": 0.00793, "epss_percentile": 0.73419}, "CVE-2024-13746": {"epss_score": 0.00283, "epss_percentile": 0.51405}, "CVE-2024-13747": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2024-13748": {"epss_score": 0.00131, "epss_percentile": 0.3343}, "CVE-2024-13749": {"epss_score": 0.00196, "epss_percentile": 0.41747}, "CVE-2024-13750": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-13751": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13752": {"epss_score": 0.00423, "epss_percentile": 0.61583}, "CVE-2024-13753": {"epss_score": 0.00048, "epss_percentile": 0.1501}, "CVE-2024-13757": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-13758": {"epss_score": 0.00045, "epss_percentile": 0.1396}, "CVE-2024-13759": {"epss_score": 0.0002, "epss_percentile": 0.04567}, "CVE-2024-13767": {"epss_score": 0.00612, "epss_percentile": 0.69212}, "CVE-2024-13768": {"epss_score": 0.00054, "epss_percentile": 0.17245}, "CVE-2024-13769": {"epss_score": 0.00061, "epss_percentile": 0.19451}, "CVE-2024-13770": {"epss_score": 0.0166, "epss_percentile": 0.81617}, "CVE-2024-13771": {"epss_score": 0.00157, "epss_percentile": 0.37059}, "CVE-2024-13772": {"epss_score": 0.0009, "epss_percentile": 0.26033}, "CVE-2024-13773": {"epss_score": 0.00315, "epss_percentile": 0.5416}, "CVE-2024-13774": {"epss_score": 0.00045, "epss_percentile": 0.1404}, "CVE-2024-13775": {"epss_score": 0.00116, "epss_percentile": 0.31177}, "CVE-2024-13776": {"epss_score": 0.00079, "epss_percentile": 0.23901}, "CVE-2024-13777": {"epss_score": 0.0166, "epss_percentile": 0.81617}, "CVE-2024-13778": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-13779": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2024-13780": {"epss_score": 0.0016, "epss_percentile": 0.37506}, "CVE-2024-13781": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-13783": {"epss_score": 0.00113, "epss_percentile": 0.30663}, "CVE-2024-13786": {"epss_score": 0.00664, "epss_percentile": 0.70633}, "CVE-2024-13787": {"epss_score": 0.00877, "epss_percentile": 0.74813}, "CVE-2024-13789": {"epss_score": 0.02588, "epss_percentile": 0.85175}, "CVE-2024-13790": {"epss_score": 0.00647, "epss_percentile": 0.70185}, "CVE-2024-13791": {"epss_score": 0.00315, "epss_percentile": 0.5418}, "CVE-2024-13792": {"epss_score": 0.01497, "epss_percentile": 0.80692}, "CVE-2024-13793": {"epss_score": 0.00429, "epss_percentile": 0.61971}, "CVE-2024-13794": {"epss_score": 0.00289, "epss_percentile": 0.52002}, "CVE-2024-13795": {"epss_score": 0.0004, "epss_percentile": 0.11873}, "CVE-2024-13796": {"epss_score": 0.00279, "epss_percentile": 0.50954}, "CVE-2024-13797": {"epss_score": 0.01497, "epss_percentile": 0.80692}, "CVE-2024-13798": {"epss_score": 0.00303, "epss_percentile": 0.53209}, "CVE-2024-13799": {"epss_score": 0.00077, "epss_percentile": 0.23389}, "CVE-2024-13800": {"epss_score": 0.00146, "epss_percentile": 0.35604}, "CVE-2024-13801": {"epss_score": 0.00107, "epss_percentile": 0.29738}, "CVE-2024-13802": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-13803": {"epss_score": 0.00095, "epss_percentile": 0.2719}, "CVE-2024-13804": {"epss_score": 0.00088, "epss_percentile": 0.25712}, "CVE-2024-13805": {"epss_score": 0.00049, "epss_percentile": 0.15643}, "CVE-2024-13806": {"epss_score": 0.00868, "epss_percentile": 0.74674}, "CVE-2024-13807": {"epss_score": 0.0007, "epss_percentile": 0.21646}, "CVE-2024-13808": {"epss_score": 0.00573, "epss_percentile": 0.68038}, "CVE-2024-13809": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-13810": {"epss_score": 0.00107, "epss_percentile": 0.29592}, "CVE-2024-13811": {"epss_score": 0.00139, "epss_percentile": 0.34666}, "CVE-2024-13812": {"epss_score": 0.00341, "epss_percentile": 0.56342}, "CVE-2024-13813": {"epss_score": 0.00103, "epss_percentile": 0.28988}, "CVE-2024-13814": {"epss_score": 0.00326, "epss_percentile": 0.55051}, "CVE-2024-13815": {"epss_score": 0.00868, "epss_percentile": 0.74674}, "CVE-2024-13816": {"epss_score": 0.00133, "epss_percentile": 0.33681}, "CVE-2024-13818": {"epss_score": 0.00082, "epss_percentile": 0.24559}, "CVE-2024-13820": {"epss_score": 0.00118, "epss_percentile": 0.31515}, "CVE-2024-13821": {"epss_score": 0.0021, "epss_percentile": 0.43615}, "CVE-2024-13822": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-13823": {"epss_score": 0.00073, "epss_percentile": 0.22572}, "CVE-2024-13824": {"epss_score": 0.02792, "epss_percentile": 0.8567}, "CVE-2024-13825": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-13826": {"epss_score": 0.00012, "epss_percentile": 0.01306}, "CVE-2024-13827": {"epss_score": 0.00676, "epss_percentile": 0.70919}, "CVE-2024-13828": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2024-13829": {"epss_score": 0.00329, "epss_percentile": 0.5531}, "CVE-2024-13830": {"epss_score": 0.0006, "epss_percentile": 0.19233}, "CVE-2024-13831": {"epss_score": 0.00978, "epss_percentile": 0.76235}, "CVE-2024-13832": {"epss_score": 0.00098, "epss_percentile": 0.27641}, "CVE-2024-13833": {"epss_score": 0.00978, "epss_percentile": 0.76235}, "CVE-2024-13834": {"epss_score": 0.00098, "epss_percentile": 0.27641}, "CVE-2024-13835": {"epss_score": 0.0022, "epss_percentile": 0.4457}, "CVE-2024-13836": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-13838": {"epss_score": 0.00093, "epss_percentile": 0.26708}, "CVE-2024-13839": {"epss_score": 0.00676, "epss_percentile": 0.70919}, "CVE-2024-13841": {"epss_score": 0.00106, "epss_percentile": 0.29441}, "CVE-2024-13842": {"epss_score": 0.00146, "epss_percentile": 0.35618}, "CVE-2024-13843": {"epss_score": 0.00087, "epss_percentile": 0.2562}, "CVE-2024-13844": {"epss_score": 0.00179, "epss_percentile": 0.39788}, "CVE-2024-13845": {"epss_score": 0.00043, "epss_percentile": 0.13009}, "CVE-2024-13846": {"epss_score": 0.00149, "epss_percentile": 0.35952}, "CVE-2024-13848": {"epss_score": 0.00112, "epss_percentile": 0.30565}, "CVE-2024-13849": {"epss_score": 0.00152, "epss_percentile": 0.36424}, "CVE-2024-13850": {"epss_score": 0.00163, "epss_percentile": 0.37775}, "CVE-2024-13851": {"epss_score": 0.00131, "epss_percentile": 0.3343}, "CVE-2024-13852": {"epss_score": 0.00057, "epss_percentile": 0.18005}, "CVE-2024-13853": {"epss_score": 0.00418, "epss_percentile": 0.61344}, "CVE-2024-13854": {"epss_score": 0.00098, "epss_percentile": 0.27641}, "CVE-2024-13855": {"epss_score": 0.00098, "epss_percentile": 0.27641}, "CVE-2024-13856": {"epss_score": 0.00095, "epss_percentile": 0.2712}, "CVE-2024-13857": {"epss_score": 0.00124, "epss_percentile": 0.32352}, "CVE-2024-13858": {"epss_score": 0.00033, "epss_percentile": 0.0914}, "CVE-2024-13859": {"epss_score": 0.00026, "epss_percentile": 0.06592}, "CVE-2024-13860": {"epss_score": 0.00026, "epss_percentile": 0.06592}, "CVE-2024-13861": {"epss_score": 0.00015, "epss_percentile": 0.02128}, "CVE-2024-13862": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-13863": {"epss_score": 0.00069, "epss_percentile": 0.21429}, "CVE-2024-13864": {"epss_score": 0.00029, "epss_percentile": 0.07935}, "CVE-2024-13865": {"epss_score": 0.00073, "epss_percentile": 0.22572}, "CVE-2024-13866": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2024-13867": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2024-13868": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-13869": {"epss_score": 0.10743, "epss_percentile": 0.93089}, "CVE-2024-13870": {"epss_score": 0.00038, "epss_percentile": 0.11199}, "CVE-2024-13871": {"epss_score": 0.0036, "epss_percentile": 0.57656}, "CVE-2024-13872": {"epss_score": 0.00061, "epss_percentile": 0.19279}, "CVE-2024-13873": {"epss_score": 0.00046, "epss_percentile": 0.14289}, "CVE-2024-13874": {"epss_score": 0.00065, "epss_percentile": 0.20608}, "CVE-2024-13875": {"epss_score": 0.00086, "epss_percentile": 0.25431}, "CVE-2024-13876": {"epss_score": 0.00086, "epss_percentile": 0.25431}, "CVE-2024-13877": {"epss_score": 0.00086, "epss_percentile": 0.25431}, "CVE-2024-13878": {"epss_score": 0.00086, "epss_percentile": 0.25431}, "CVE-2024-13879": {"epss_score": 0.00151, "epss_percentile": 0.36334}, "CVE-2024-13880": {"epss_score": 0.00086, "epss_percentile": 0.25431}, "CVE-2024-13881": {"epss_score": 0.00086, "epss_percentile": 0.25431}, "CVE-2024-13882": {"epss_score": 0.00956, "epss_percentile": 0.75925}, "CVE-2024-13883": {"epss_score": 0.00014, "epss_percentile": 0.02088}, "CVE-2024-13884": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-13885": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-13887": {"epss_score": 0.00118, "epss_percentile": 0.31465}, "CVE-2024-13888": {"epss_score": 0.00739, "epss_percentile": 0.72354}, "CVE-2024-13889": {"epss_score": 0.00729, "epss_percentile": 0.72127}, "CVE-2024-13890": {"epss_score": 0.00324, "epss_percentile": 0.54937}, "CVE-2024-13891": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-13892": {"epss_score": 0.00641, "epss_percentile": 0.69985}, "CVE-2024-13893": {"epss_score": 0.00028, "epss_percentile": 0.07483}, "CVE-2024-13894": {"epss_score": 0.00062, "epss_percentile": 0.1955}, "CVE-2024-13895": {"epss_score": 0.00181, "epss_percentile": 0.40062}, "CVE-2024-13896": {"epss_score": 0.00108, "epss_percentile": 0.29785}, "CVE-2024-13897": {"epss_score": 0.03794, "epss_percentile": 0.87734}, "CVE-2024-13898": {"epss_score": 0.00042, "epss_percentile": 0.12496}, "CVE-2024-13899": {"epss_score": 0.01115, "epss_percentile": 0.77716}, "CVE-2024-13900": {"epss_score": 0.00266, "epss_percentile": 0.49879}, "CVE-2024-13901": {"epss_score": 0.00152, "epss_percentile": 0.36424}, "CVE-2024-13902": {"epss_score": 0.00062, "epss_percentile": 0.19574}, "CVE-2024-13903": {"epss_score": 0.00542, "epss_percentile": 0.67084}, "CVE-2024-13904": {"epss_score": 0.0045, "epss_percentile": 0.63101}, "CVE-2024-13905": {"epss_score": 0.00413, "epss_percentile": 0.60992}, "CVE-2024-13906": {"epss_score": 0.00999, "epss_percentile": 0.76484}, "CVE-2024-13907": {"epss_score": 0.00149, "epss_percentile": 0.35959}, "CVE-2024-13908": {"epss_score": 0.00768, "epss_percentile": 0.72962}, "CVE-2024-13909": {"epss_score": 0.00036, "epss_percentile": 0.10219}, "CVE-2024-13910": {"epss_score": 0.03973, "epss_percentile": 0.88044}, "CVE-2024-13911": {"epss_score": 0.00653, "epss_percentile": 0.70328}, "CVE-2024-13913": {"epss_score": 0.00146, "epss_percentile": 0.3556}, "CVE-2024-13914": {"epss_score": 0.00181, "epss_percentile": 0.4008}, "CVE-2024-13915": {"epss_score": 0.00021, "epss_percentile": 0.04884}, "CVE-2024-13916": {"epss_score": 0.00025, "epss_percentile": 0.06108}, "CVE-2024-13917": {"epss_score": 0.00025, "epss_percentile": 0.06108}, "CVE-2024-13918": {"epss_score": 0.0011, "epss_percentile": 0.30196}, "CVE-2024-13919": {"epss_score": 0.00062, "epss_percentile": 0.19675}, "CVE-2024-13920": {"epss_score": 0.00245, "epss_percentile": 0.47641}, "CVE-2024-13921": {"epss_score": 0.01128, "epss_percentile": 0.77832}, "CVE-2024-13922": {"epss_score": 0.00246, "epss_percentile": 0.47748}, "CVE-2024-13923": {"epss_score": 0.00113, "epss_percentile": 0.30659}, "CVE-2024-13924": {"epss_score": 0.00121, "epss_percentile": 0.32012}, "CVE-2024-13925": {"epss_score": 0.00134, "epss_percentile": 0.3377}, "CVE-2024-13926": {"epss_score": 0.00117, "epss_percentile": 0.31209}, "CVE-2024-13928": {"epss_score": 0.00035, "epss_percentile": 0.10009}, "CVE-2024-13929": {"epss_score": 0.00466, "epss_percentile": 0.63792}, "CVE-2024-13930": {"epss_score": 0.00081, "epss_percentile": 0.24319}, "CVE-2024-13931": {"epss_score": 0.00091, "epss_percentile": 0.26281}, "CVE-2024-13933": {"epss_score": 0.00059, "epss_percentile": 0.18928}, "CVE-2024-13939": {"epss_score": 0.00078, "epss_percentile": 0.23631}, "CVE-2024-13940": {"epss_score": 0.00032, "epss_percentile": 0.08962}, "CVE-2024-13941": {"epss_score": 0.00035, "epss_percentile": 0.10057}, "CVE-2024-13943": {"epss_score": 0.00023, "epss_percentile": 0.05391}, "CVE-2024-13944": {"epss_score": 0.00017, "epss_percentile": 0.03194}, "CVE-2024-13945": {"epss_score": 0.00074, "epss_percentile": 0.22769}, "CVE-2024-13946": {"epss_score": 0.00482, "epss_percentile": 0.64541}, "CVE-2024-13947": {"epss_score": 0.00054, "epss_percentile": 0.17212}, "CVE-2024-13948": {"epss_score": 0.00016, "epss_percentile": 0.02852}, "CVE-2024-13949": {"epss_score": 0.00037, "epss_percentile": 0.10623}, "CVE-2024-13950": {"epss_score": 0.00031, "epss_percentile": 0.08536}, "CVE-2024-13951": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2024-13952": {"epss_score": 0.00036, "epss_percentile": 0.10201}, "CVE-2024-13953": {"epss_score": 0.00041, "epss_percentile": 0.12341}, "CVE-2024-13954": {"epss_score": 0.00029, "epss_percentile": 0.07593}, "CVE-2024-13955": {"epss_score": 0.00038, "epss_percentile": 0.11222}, "CVE-2024-13956": {"epss_score": 0.00054, "epss_percentile": 0.17212}, "CVE-2024-13957": {"epss_score": 0.00038, "epss_percentile": 0.11162}, "CVE-2024-13958": {"epss_score": 0.00022, "epss_percentile": 0.0532}, "CVE-2024-13959": {"epss_score": 0.00022, "epss_percentile": 0.04987}, "CVE-2024-13960": {"epss_score": 0.00017, "epss_percentile": 0.03194}, "CVE-2024-13961": {"epss_score": 0.00017, "epss_percentile": 0.03194}, "CVE-2024-13962": {"epss_score": 0.00022, "epss_percentile": 0.04987}, "CVE-2024-13966": {"epss_score": 0.00163, "epss_percentile": 0.37792}, "CVE-2024-13967": {"epss_score": 0.00052, "epss_percentile": 0.16579}, "CVE-2024-13972": {"epss_score": 8e-05, "epss_percentile": 0.00507}, "CVE-2024-13973": {"epss_score": 0.00059, "epss_percentile": 0.18721}, "CVE-2024-13974": {"epss_score": 0.00204, "epss_percentile": 0.42643}, "CVE-2024-13975": {"epss_score": 0.0002, "epss_percentile": 0.04493}, "CVE-2024-13976": {"epss_score": 0.00018, "epss_percentile": 0.0375}, "CVE-2024-13978": {"epss_score": 0.00025, "epss_percentile": 0.06109}, "CVE-2024-13979": {"epss_score": 0.07018, "epss_percentile": 0.91189}, "CVE-2024-13980": {"epss_score": 0.02443, "epss_percentile": 0.84758}, "CVE-2024-13981": {"epss_score": 0.00803, "epss_percentile": 0.73597}, "CVE-2024-13982": {"epss_score": 0.02481, "epss_percentile": 0.84875}, "CVE-2024-13983": {"epss_score": 0.0009, "epss_percentile": 0.25988}, "CVE-2024-13984": {"epss_score": 0.01196, "epss_percentile": 0.78436}, "CVE-2024-13985": {"epss_score": 0.00423, "epss_percentile": 0.61595}, "CVE-2024-13986": {"epss_score": 0.01302, "epss_percentile": 0.79306}, "CVE-2024-13987": {"epss_score": 0.00144, "epss_percentile": 0.35264}, "CVE-2024-13990": {"epss_score": 0.00099, "epss_percentile": 0.28362}, "CVE-2024-13991": {"epss_score": 0.00326, "epss_percentile": 0.55077}, "CVE-2024-13992": {"epss_score": 0.0074, "epss_percentile": 0.72399}, "CVE-2024-13993": {"epss_score": 0.00746, "epss_percentile": 0.72541}, "CVE-2024-13994": {"epss_score": 0.00081, "epss_percentile": 0.24296}, "CVE-2024-13995": {"epss_score": 0.01422, "epss_percentile": 0.80186}, "CVE-2024-13996": {"epss_score": 0.00226, "epss_percentile": 0.45251}, "CVE-2024-13997": {"epss_score": 0.00147, "epss_percentile": 0.35644}, "CVE-2024-13998": {"epss_score": 0.00946, "epss_percentile": 0.75811}, "CVE-2024-13999": {"epss_score": 0.00692, "epss_percentile": 0.71301}, "CVE-2024-14000": {"epss_score": 0.0074, "epss_percentile": 0.72399}, "CVE-2024-14001": {"epss_score": 0.0074, "epss_percentile": 0.72399}, "CVE-2024-14002": {"epss_score": 0.00608, "epss_percentile": 0.69082}, "CVE-2024-14003": {"epss_score": 0.00987, "epss_percentile": 0.76342}, "CVE-2024-14004": {"epss_score": 0.00076, "epss_percentile": 0.23121}, "CVE-2024-14005": {"epss_score": 0.00594, "epss_percentile": 0.68659}, "CVE-2024-14006": {"epss_score": 0.00146, "epss_percentile": 0.35555}, "CVE-2024-14007": {"epss_score": 0.00073, "epss_percentile": 0.22505}, "CVE-2024-14008": {"epss_score": 0.00693, "epss_percentile": 0.71333}, "CVE-2024-14009": {"epss_score": 0.00153, "epss_percentile": 0.36579}, "CVE-2024-14010": {"epss_score": 0.00476, "epss_percentile": 0.64291}, "CVE-2024-14012": {"epss_score": 0.00021, "epss_percentile": 0.04863}, "CVE-2024-14015": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2024-14020": {"epss_score": 0.00049, "epss_percentile": 0.15471}, "CVE-2024-1000": {"epss_score": 0.00129, "epss_percentile": 0.33207}, "CVE-2024-1001": {"epss_score": 0.00111, "epss_percentile": 0.30341}, "CVE-2024-1002": {"epss_score": 0.00115, "epss_percentile": 0.3098}, "CVE-2024-1003": {"epss_score": 0.00095, "epss_percentile": 0.27209}, "CVE-2024-1004": {"epss_score": 0.00082, "epss_percentile": 0.24438}, "CVE-2024-1005": {"epss_score": 0.00071, "epss_percentile": 0.22069}, "CVE-2024-1006": {"epss_score": 0.00045, "epss_percentile": 0.14009}, "CVE-2024-1007": {"epss_score": 0.00062, "epss_percentile": 0.19692}, "CVE-2024-1008": {"epss_score": 0.00075, "epss_percentile": 0.23027}, "CVE-2024-1009": {"epss_score": 0.00081, "epss_percentile": 0.24364}, "CVE-2024-1010": {"epss_score": 0.00155, "epss_percentile": 0.36766}, "CVE-2024-1011": {"epss_score": 0.00163, "epss_percentile": 0.37826}, "CVE-2024-1012": {"epss_score": 0.00073, "epss_percentile": 0.22621}, "CVE-2024-1013": {"epss_score": 0.00058, "epss_percentile": 0.18423}, "CVE-2024-1014": {"epss_score": 0.00072, "epss_percentile": 0.22381}, "CVE-2024-1015": {"epss_score": 0.02098, "epss_percentile": 0.83592}, "CVE-2024-1016": {"epss_score": 0.00027, "epss_percentile": 0.06982}, "CVE-2024-1017": {"epss_score": 0.00036, "epss_percentile": 0.10372}, "CVE-2024-1018": {"epss_score": 0.00055, "epss_percentile": 0.17586}, "CVE-2024-1019": {"epss_score": 0.00226, "epss_percentile": 0.45243}, "CVE-2024-1020": {"epss_score": 0.00129, "epss_percentile": 0.33097}, "CVE-2024-1021": {"epss_score": 0.93217, "epss_percentile": 0.99785}, "CVE-2024-1022": {"epss_score": 0.00077, "epss_percentile": 0.23443}, "CVE-2024-1023": {"epss_score": 0.00227, "epss_percentile": 0.45364}, "CVE-2024-1024": {"epss_score": 0.00064, "epss_percentile": 0.20355}, "CVE-2024-1026": {"epss_score": 0.0005, "epss_percentile": 0.15821}, "CVE-2024-1027": {"epss_score": 0.00057, "epss_percentile": 0.18135}, "CVE-2024-1028": {"epss_score": 0.00042, "epss_percentile": 0.12611}, "CVE-2024-1029": {"epss_score": 0.00069, "epss_percentile": 0.21492}, "CVE-2024-1030": {"epss_score": 0.00058, "epss_percentile": 0.18455}, "CVE-2024-1031": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2024-1032": {"epss_score": 0.00081, "epss_percentile": 0.2431}, "CVE-2024-1033": {"epss_score": 0.00057, "epss_percentile": 0.18008}, "CVE-2024-1034": {"epss_score": 0.00075, "epss_percentile": 0.23007}, "CVE-2024-1035": {"epss_score": 0.00098, "epss_percentile": 0.27746}, "CVE-2024-1036": {"epss_score": 0.00071, "epss_percentile": 0.22232}, "CVE-2024-1037": {"epss_score": 0.00679, "epss_percentile": 0.71011}, "CVE-2024-1038": {"epss_score": 0.01169, "epss_percentile": 0.78199}, "CVE-2024-1039": {"epss_score": 0.00109, "epss_percentile": 0.30024}, "CVE-2024-1040": {"epss_score": 0.0001, "epss_percentile": 0.00777}, "CVE-2024-1041": {"epss_score": 0.00156, "epss_percentile": 0.36941}, "CVE-2024-1042": {"epss_score": 0.00153, "epss_percentile": 0.36509}, "CVE-2024-1043": {"epss_score": 0.00187, "epss_percentile": 0.4078}, "CVE-2024-1044": {"epss_score": 0.00288, "epss_percentile": 0.51946}, "CVE-2024-1046": {"epss_score": 0.00239, "epss_percentile": 0.46906}, "CVE-2024-1047": {"epss_score": 0.00216, "epss_percentile": 0.44204}, "CVE-2024-1048": {"epss_score": 0.0001, "epss_percentile": 0.00833}, "CVE-2024-1049": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-1050": {"epss_score": 0.00073, "epss_percentile": 0.22633}, "CVE-2024-1051": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2024-1052": {"epss_score": 0.00303, "epss_percentile": 0.53225}, "CVE-2024-1053": {"epss_score": 0.00141, "epss_percentile": 0.34949}, "CVE-2024-1054": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-1055": {"epss_score": 0.00237, "epss_percentile": 0.46723}, "CVE-2024-1056": {"epss_score": 0.00248, "epss_percentile": 0.47936}, "CVE-2024-1057": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2024-1058": {"epss_score": 0.00219, "epss_percentile": 0.4453}, "CVE-2024-1059": {"epss_score": 0.00416, "epss_percentile": 0.61184}, "CVE-2024-1060": {"epss_score": 0.00353, "epss_percentile": 0.57169}, "CVE-2024-1061": {"epss_score": 0.84493, "epss_percentile": 0.99292}, "CVE-2024-1062": {"epss_score": 0.00022, "epss_percentile": 0.05279}, "CVE-2024-1063": {"epss_score": 0.00067, "epss_percentile": 0.21087}, "CVE-2024-1064": {"epss_score": 0.00469, "epss_percentile": 0.63947}, "CVE-2024-1065": {"epss_score": 0.00089, "epss_percentile": 0.25821}, "CVE-2024-1066": {"epss_score": 0.00061, "epss_percentile": 0.19541}, "CVE-2024-1067": {"epss_score": 0.00098, "epss_percentile": 0.27793}, "CVE-2024-1068": {"epss_score": 0.00408, "epss_percentile": 0.60644}, "CVE-2024-1069": {"epss_score": 0.02852, "epss_percentile": 0.85831}, "CVE-2024-1070": {"epss_score": 0.00196, "epss_percentile": 0.41753}, "CVE-2024-1071": {"epss_score": 0.92912, "epss_percentile": 0.99759}, "CVE-2024-1072": {"epss_score": 0.00215, "epss_percentile": 0.44093}, "CVE-2024-1073": {"epss_score": 0.00219, "epss_percentile": 0.44488}, "CVE-2024-1074": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2024-1075": {"epss_score": 0.00482, "epss_percentile": 0.6455}, "CVE-2024-1076": {"epss_score": 0.00234, "epss_percentile": 0.46151}, "CVE-2024-1077": {"epss_score": 0.0037, "epss_percentile": 0.58315}, "CVE-2024-1078": {"epss_score": 0.0009, "epss_percentile": 0.26033}, "CVE-2024-1079": {"epss_score": 0.00444, "epss_percentile": 0.62807}, "CVE-2024-1080": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-1081": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-1082": {"epss_score": 0.00461, "epss_percentile": 0.63559}, "CVE-2024-1083": {"epss_score": 0.00193, "epss_percentile": 0.41462}, "CVE-2024-1084": {"epss_score": 0.00096, "epss_percentile": 0.27342}, "CVE-2024-1085": {"epss_score": 0.00026, "epss_percentile": 0.06485}, "CVE-2024-1086": {"epss_score": 0.85612, "epss_percentile": 0.99341}, "CVE-2024-1088": {"epss_score": 0.00418, "epss_percentile": 0.61293}, "CVE-2024-1089": {"epss_score": 0.00237, "epss_percentile": 0.46691}, "CVE-2024-1090": {"epss_score": 0.0031, "epss_percentile": 0.53761}, "CVE-2024-1091": {"epss_score": 0.00237, "epss_percentile": 0.46691}, "CVE-2024-1092": {"epss_score": 0.00119, "epss_percentile": 0.31582}, "CVE-2024-1093": {"epss_score": 0.00433, "epss_percentile": 0.6219}, "CVE-2024-1094": {"epss_score": 0.00241, "epss_percentile": 0.47248}, "CVE-2024-1095": {"epss_score": 0.00546, "epss_percentile": 0.67222}, "CVE-2024-1096": {"epss_score": 0.00013, "epss_percentile": 0.01432}, "CVE-2024-1097": {"epss_score": 0.00174, "epss_percentile": 0.39157}, "CVE-2024-1098": {"epss_score": 0.00133, "epss_percentile": 0.33722}, "CVE-2024-1099": {"epss_score": 0.00122, "epss_percentile": 0.32144}, "CVE-2024-1100": {"epss_score": 0.0019, "epss_percentile": 0.41141}, "CVE-2024-1102": {"epss_score": 0.0015, "epss_percentile": 0.36067}, "CVE-2024-1103": {"epss_score": 0.00122, "epss_percentile": 0.32144}, "CVE-2024-1104": {"epss_score": 0.00057, "epss_percentile": 0.18183}, "CVE-2024-1106": {"epss_score": 0.00349, "epss_percentile": 0.56883}, "CVE-2024-1107": {"epss_score": 0.00026, "epss_percentile": 0.0657}, "CVE-2024-1108": {"epss_score": 0.00111, "epss_percentile": 0.30304}, "CVE-2024-1109": {"epss_score": 0.0024, "epss_percentile": 0.46962}, "CVE-2024-1110": {"epss_score": 0.0015, "epss_percentile": 0.36071}, "CVE-2024-1111": {"epss_score": 0.00122, "epss_percentile": 0.32135}, "CVE-2024-1112": {"epss_score": 0.38848, "epss_percentile": 0.97123}, "CVE-2024-1113": {"epss_score": 0.00079, "epss_percentile": 0.23812}, "CVE-2024-1114": {"epss_score": 0.00025, "epss_percentile": 0.0638}, "CVE-2024-1115": {"epss_score": 0.00476, "epss_percentile": 0.64269}, "CVE-2024-1116": {"epss_score": 0.00078, "epss_percentile": 0.23797}, "CVE-2024-1117": {"epss_score": 0.00083, "epss_percentile": 0.24714}, "CVE-2024-1118": {"epss_score": 0.00428, "epss_percentile": 0.61917}, "CVE-2024-1119": {"epss_score": 0.00268, "epss_percentile": 0.5009}, "CVE-2024-1120": {"epss_score": 0.00249, "epss_percentile": 0.48067}, "CVE-2024-1121": {"epss_score": 0.00391, "epss_percentile": 0.59582}, "CVE-2024-1122": {"epss_score": 0.00184, "epss_percentile": 0.40453}, "CVE-2024-1123": {"epss_score": 0.00135, "epss_percentile": 0.34036}, "CVE-2024-1124": {"epss_score": 0.00066, "epss_percentile": 0.20874}, "CVE-2024-1125": {"epss_score": 0.00056, "epss_percentile": 0.17665}, "CVE-2024-1126": {"epss_score": 0.00206, "epss_percentile": 0.4295}, "CVE-2024-1127": {"epss_score": 0.00241, "epss_percentile": 0.47266}, "CVE-2024-1128": {"epss_score": 0.0015, "epss_percentile": 0.36143}, "CVE-2024-1129": {"epss_score": 0.00271, "epss_percentile": 0.50328}, "CVE-2024-1130": {"epss_score": 0.00447, "epss_percentile": 0.62936}, "CVE-2024-1132": {"epss_score": 0.0024, "epss_percentile": 0.46969}, "CVE-2024-1133": {"epss_score": 0.00207, "epss_percentile": 0.43179}, "CVE-2024-1134": {"epss_score": 0.00202, "epss_percentile": 0.42398}, "CVE-2024-1135": {"epss_score": 0.0004, "epss_percentile": 0.1189}, "CVE-2024-1136": {"epss_score": 0.00389, "epss_percentile": 0.59469}, "CVE-2024-1137": {"epss_score": 0.00059, "epss_percentile": 0.18919}, "CVE-2024-1138": {"epss_score": 0.00092, "epss_percentile": 0.26578}, "CVE-2024-1139": {"epss_score": 0.00206, "epss_percentile": 0.42931}, "CVE-2024-1140": {"epss_score": 0.0002, "epss_percentile": 0.04527}, "CVE-2024-1141": {"epss_score": 0.00027, "epss_percentile": 0.06981}, "CVE-2024-1142": {"epss_score": 0.00468, "epss_percentile": 0.63892}, "CVE-2024-1143": {"epss_score": 0.00281, "epss_percentile": 0.512}, "CVE-2024-1144": {"epss_score": 0.00162, "epss_percentile": 0.37631}, "CVE-2024-1145": {"epss_score": 0.00077, "epss_percentile": 0.23354}, "CVE-2024-1146": {"epss_score": 0.00089, "epss_percentile": 0.25855}, "CVE-2024-1147": {"epss_score": 0.00092, "epss_percentile": 0.26482}, "CVE-2024-1148": {"epss_score": 0.00092, "epss_percentile": 0.26482}, "CVE-2024-1149": {"epss_score": 0.00025, "epss_percentile": 0.06371}, "CVE-2024-1150": {"epss_score": 0.00025, "epss_percentile": 0.06371}, "CVE-2024-1151": {"epss_score": 0.0002, "epss_percentile": 0.04668}, "CVE-2024-1153": {"epss_score": 0.00072, "epss_percentile": 0.22373}, "CVE-2024-1155": {"epss_score": 0.00109, "epss_percentile": 0.29942}, "CVE-2024-1156": {"epss_score": 0.00138, "epss_percentile": 0.34465}, "CVE-2024-1157": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2024-1158": {"epss_score": 0.00156, "epss_percentile": 0.36944}, "CVE-2024-1159": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-1160": {"epss_score": 0.0009, "epss_percentile": 0.26053}, "CVE-2024-1161": {"epss_score": 0.00152, "epss_percentile": 0.36403}, "CVE-2024-1162": {"epss_score": 0.00121, "epss_percentile": 0.3188}, "CVE-2024-1163": {"epss_score": 0.00069, "epss_percentile": 0.21496}, "CVE-2024-1164": {"epss_score": 0.00152, "epss_percentile": 0.36403}, "CVE-2024-1165": {"epss_score": 0.00709, "epss_percentile": 0.71698}, "CVE-2024-1166": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-1167": {"epss_score": 0.00084, "epss_percentile": 0.24869}, "CVE-2024-1168": {"epss_score": 0.00234, "epss_percentile": 0.46117}, "CVE-2024-1169": {"epss_score": 0.00626, "epss_percentile": 0.69603}, "CVE-2024-1170": {"epss_score": 0.00382, "epss_percentile": 0.59078}, "CVE-2024-1171": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-1172": {"epss_score": 0.00172, "epss_percentile": 0.38945}, "CVE-2024-1173": {"epss_score": 0.01069, "epss_percentile": 0.77248}, "CVE-2024-1174": {"epss_score": 0.00035, "epss_percentile": 0.09972}, "CVE-2024-1175": {"epss_score": 0.00218, "epss_percentile": 0.44436}, "CVE-2024-1176": {"epss_score": 0.00261, "epss_percentile": 0.4928}, "CVE-2024-1177": {"epss_score": 0.00169, "epss_percentile": 0.38626}, "CVE-2024-1178": {"epss_score": 0.00163, "epss_percentile": 0.37763}, "CVE-2024-1179": {"epss_score": 0.01817, "epss_percentile": 0.82397}, "CVE-2024-1180": {"epss_score": 0.00944, "epss_percentile": 0.75784}, "CVE-2024-1181": {"epss_score": 0.00155, "epss_percentile": 0.36858}, "CVE-2024-1182": {"epss_score": 0.00058, "epss_percentile": 0.18535}, "CVE-2024-1183": {"epss_score": 0.65669, "epss_percentile": 0.98432}, "CVE-2024-1184": {"epss_score": 0.00032, "epss_percentile": 0.08985}, "CVE-2024-1185": {"epss_score": 0.0002, "epss_percentile": 0.04595}, "CVE-2024-1186": {"epss_score": 0.00021, "epss_percentile": 0.04746}, "CVE-2024-1187": {"epss_score": 0.00019, "epss_percentile": 0.04412}, "CVE-2024-1188": {"epss_score": 0.00019, "epss_percentile": 0.04412}, "CVE-2024-1189": {"epss_score": 0.00029, "epss_percentile": 0.07616}, "CVE-2024-1190": {"epss_score": 0.00022, "epss_percentile": 0.04959}, "CVE-2024-1191": {"epss_score": 0.00136, "epss_percentile": 0.34138}, "CVE-2024-1192": {"epss_score": 0.00143, "epss_percentile": 0.35224}, "CVE-2024-1193": {"epss_score": 0.0002, "epss_percentile": 0.04529}, "CVE-2024-1194": {"epss_score": 0.00031, "epss_percentile": 0.08332}, "CVE-2024-1195": {"epss_score": 0.00012, "epss_percentile": 0.01266}, "CVE-2024-1196": {"epss_score": 0.00095, "epss_percentile": 0.27198}, "CVE-2024-1197": {"epss_score": 0.00048, "epss_percentile": 0.15271}, "CVE-2024-1198": {"epss_score": 0.00069, "epss_percentile": 0.21456}, "CVE-2024-1199": {"epss_score": 0.00043, "epss_percentile": 0.13263}, "CVE-2024-1200": {"epss_score": 0.00096, "epss_percentile": 0.27272}, "CVE-2024-1201": {"epss_score": 0.00032, "epss_percentile": 0.08831}, "CVE-2024-1202": {"epss_score": 0.0007, "epss_percentile": 0.21867}, "CVE-2024-1203": {"epss_score": 0.00505, "epss_percentile": 0.65598}, "CVE-2024-1204": {"epss_score": 0.00224, "epss_percentile": 0.45036}, "CVE-2024-1205": {"epss_score": 0.04715, "epss_percentile": 0.89043}, "CVE-2024-1206": {"epss_score": 0.00646, "epss_percentile": 0.70133}, "CVE-2024-1207": {"epss_score": 0.75579, "epss_percentile": 0.98855}, "CVE-2024-1208": {"epss_score": 0.86678, "epss_percentile": 0.99392}, "CVE-2024-1209": {"epss_score": 0.44186, "epss_percentile": 0.97423}, "CVE-2024-1210": {"epss_score": 0.21047, "epss_percentile": 0.95457}, "CVE-2024-1211": {"epss_score": 0.00023, "epss_percentile": 0.05353}, "CVE-2024-1212": {"epss_score": 0.94346, "epss_percentile": 0.99953}, "CVE-2024-1213": {"epss_score": 0.0008, "epss_percentile": 0.24026}, "CVE-2024-1214": {"epss_score": 0.00102, "epss_percentile": 0.28749}, "CVE-2024-1215": {"epss_score": 0.00133, "epss_percentile": 0.33636}, "CVE-2024-1217": {"epss_score": 0.00064, "epss_percentile": 0.20285}, "CVE-2024-1218": {"epss_score": 0.00153, "epss_percentile": 0.36509}, "CVE-2024-1219": {"epss_score": 0.0012, "epss_percentile": 0.31722}, "CVE-2024-1220": {"epss_score": 0.01252, "epss_percentile": 0.78905}, "CVE-2024-1221": {"epss_score": 0.01938, "epss_percentile": 0.82966}, "CVE-2024-1222": {"epss_score": 0.13479, "epss_percentile": 0.93976}, "CVE-2024-1223": {"epss_score": 0.00512, "epss_percentile": 0.65871}, "CVE-2024-1224": {"epss_score": 0.0001, "epss_percentile": 0.00909}, "CVE-2024-1225": {"epss_score": 0.00135, "epss_percentile": 0.34044}, "CVE-2024-1226": {"epss_score": 0.00118, "epss_percentile": 0.31425}, "CVE-2024-1227": {"epss_score": 0.00034, "epss_percentile": 0.09559}, "CVE-2024-1228": {"epss_score": 0.00126, "epss_percentile": 0.32672}, "CVE-2024-1229": {"epss_score": 0.00655, "epss_percentile": 0.70369}, "CVE-2024-1230": {"epss_score": 0.00115, "epss_percentile": 0.30945}, "CVE-2024-1231": {"epss_score": 0.00085, "epss_percentile": 0.25165}, "CVE-2024-1232": {"epss_score": 0.00182, "epss_percentile": 0.40186}, "CVE-2024-1233": {"epss_score": 0.00177, "epss_percentile": 0.39601}, "CVE-2024-1234": {"epss_score": 0.06413, "epss_percentile": 0.90743}, "CVE-2024-1235": {"epss_score": 0.00249, "epss_percentile": 0.48004}, "CVE-2024-1236": {"epss_score": 0.00196, "epss_percentile": 0.41753}, "CVE-2024-1237": {"epss_score": 0.00196, "epss_percentile": 0.41753}, "CVE-2024-1238": {"epss_score": 0.00271, "epss_percentile": 0.50317}, "CVE-2024-1239": {"epss_score": 0.00207, "epss_percentile": 0.4319}, "CVE-2024-1240": {"epss_score": 0.00226, "epss_percentile": 0.45314}, "CVE-2024-1241": {"epss_score": 0.00025, "epss_percentile": 0.06145}, "CVE-2024-1242": {"epss_score": 0.00321, "epss_percentile": 0.54694}, "CVE-2024-1243": {"epss_score": 0.00288, "epss_percentile": 0.51935}, "CVE-2024-1244": {"epss_score": 0.00254, "epss_percentile": 0.48563}, "CVE-2024-1245": {"epss_score": 0.00554, "epss_percentile": 0.67449}, "CVE-2024-1246": {"epss_score": 0.00425, "epss_percentile": 0.61709}, "CVE-2024-1247": {"epss_score": 0.07015, "epss_percentile": 0.91187}, "CVE-2024-1249": {"epss_score": 0.00131, "epss_percentile": 0.33344}, "CVE-2024-1250": {"epss_score": 0.00015, "epss_percentile": 0.02531}, "CVE-2024-1251": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-1252": {"epss_score": 0.00103, "epss_percentile": 0.28928}, "CVE-2024-1253": {"epss_score": 0.00104, "epss_percentile": 0.29193}, "CVE-2024-1254": {"epss_score": 0.00011, "epss_percentile": 0.01016}, "CVE-2024-1255": {"epss_score": 0.00093, "epss_percentile": 0.26626}, "CVE-2024-1256": {"epss_score": 0.00075, "epss_percentile": 0.2295}, "CVE-2024-1257": {"epss_score": 0.00075, "epss_percentile": 0.22908}, "CVE-2024-1258": {"epss_score": 0.00091, "epss_percentile": 0.26214}, "CVE-2024-1259": {"epss_score": 0.00084, "epss_percentile": 0.24892}, "CVE-2024-1260": {"epss_score": 0.00084, "epss_percentile": 0.24892}, "CVE-2024-1261": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2024-1262": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2024-1263": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2024-1264": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2024-1265": {"epss_score": 0.00057, "epss_percentile": 0.18054}, "CVE-2024-1266": {"epss_score": 0.00077, "epss_percentile": 0.23443}, "CVE-2024-1267": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2024-1268": {"epss_score": 0.00065, "epss_percentile": 0.2059}, "CVE-2024-1269": {"epss_score": 0.00133, "epss_percentile": 0.33739}, "CVE-2024-1272": {"epss_score": 0.00171, "epss_percentile": 0.38804}, "CVE-2024-1273": {"epss_score": 0.00176, "epss_percentile": 0.39376}, "CVE-2024-1274": {"epss_score": 0.00154, "epss_percentile": 0.36658}, "CVE-2024-1275": {"epss_score": 0.002, "epss_percentile": 0.42202}, "CVE-2024-1276": {"epss_score": 0.00206, "epss_percentile": 0.4293}, "CVE-2024-1277": {"epss_score": 0.00196, "epss_percentile": 0.41753}, "CVE-2024-1278": {"epss_score": 0.00134, "epss_percentile": 0.33786}, "CVE-2024-1279": {"epss_score": 0.00369, "epss_percentile": 0.58241}, "CVE-2024-1282": {"epss_score": 0.00188, "epss_percentile": 0.40904}, "CVE-2024-1283": {"epss_score": 0.02167, "epss_percentile": 0.83856}, "CVE-2024-1284": {"epss_score": 0.00737, "epss_percentile": 0.72319}, "CVE-2024-1285": {"epss_score": 0.00197, "epss_percentile": 0.41929}, "CVE-2024-1286": {"epss_score": 0.00238, "epss_percentile": 0.46776}, "CVE-2024-1287": {"epss_score": 0.00767, "epss_percentile": 0.72956}, "CVE-2024-1288": {"epss_score": 0.00132, "epss_percentile": 0.33531}, "CVE-2024-1289": {"epss_score": 0.00199, "epss_percentile": 0.42189}, "CVE-2024-1290": {"epss_score": 0.0043, "epss_percentile": 0.6202}, "CVE-2024-1291": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-1292": {"epss_score": 0.00245, "epss_percentile": 0.47674}, "CVE-2024-1293": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-1294": {"epss_score": 0.00454, "epss_percentile": 0.63263}, "CVE-2024-1295": {"epss_score": 0.01115, "epss_percentile": 0.77715}, "CVE-2024-1296": {"epss_score": 0.00188, "epss_percentile": 0.40848}, "CVE-2024-1297": {"epss_score": 0.01696, "epss_percentile": 0.81811}, "CVE-2024-1298": {"epss_score": 0.00033, "epss_percentile": 0.09124}, "CVE-2024-1299": {"epss_score": 0.00021, "epss_percentile": 0.04704}, "CVE-2024-1300": {"epss_score": 0.00098, "epss_percentile": 0.27699}, "CVE-2024-1301": {"epss_score": 0.13695, "epss_percentile": 0.94037}, "CVE-2024-1302": {"epss_score": 0.00387, "epss_percentile": 0.59309}, "CVE-2024-1303": {"epss_score": 0.00525, "epss_percentile": 0.6639}, "CVE-2024-1304": {"epss_score": 0.00083, "epss_percentile": 0.2473}, "CVE-2024-1305": {"epss_score": 0.08327, "epss_percentile": 0.91992}, "CVE-2024-1306": {"epss_score": 0.00254, "epss_percentile": 0.48556}, "CVE-2024-1307": {"epss_score": 0.00299, "epss_percentile": 0.52878}, "CVE-2024-1308": {"epss_score": 0.00358, "epss_percentile": 0.57504}, "CVE-2024-1309": {"epss_score": 0.00063, "epss_percentile": 0.19982}, "CVE-2024-1310": {"epss_score": 0.00279, "epss_percentile": 0.50943}, "CVE-2024-1311": {"epss_score": 0.09631, "epss_percentile": 0.92632}, "CVE-2024-1312": {"epss_score": 0.00023, "epss_percentile": 0.05346}, "CVE-2024-1313": {"epss_score": 0.00021, "epss_percentile": 0.04911}, "CVE-2024-1315": {"epss_score": 0.00434, "epss_percentile": 0.62295}, "CVE-2024-1316": {"epss_score": 0.00494, "epss_percentile": 0.65083}, "CVE-2024-1317": {"epss_score": 0.00434, "epss_percentile": 0.62296}, "CVE-2024-1318": {"epss_score": 0.00172, "epss_percentile": 0.39009}, "CVE-2024-1319": {"epss_score": 0.00142, "epss_percentile": 0.35042}, "CVE-2024-1320": {"epss_score": 0.00385, "epss_percentile": 0.5922}, "CVE-2024-1321": {"epss_score": 0.00115, "epss_percentile": 0.30959}, "CVE-2024-1322": {"epss_score": 0.00235, "epss_percentile": 0.46324}, "CVE-2024-1323": {"epss_score": 0.00123, "epss_percentile": 0.32237}, "CVE-2024-1324": {"epss_score": 0.00627, "epss_percentile": 0.69625}, "CVE-2024-1325": {"epss_score": 0.00075, "epss_percentile": 0.2305}, "CVE-2024-1326": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2024-1327": {"epss_score": 0.00139, "epss_percentile": 0.34625}, "CVE-2024-1328": {"epss_score": 0.00141, "epss_percentile": 0.34905}, "CVE-2024-1329": {"epss_score": 0.00286, "epss_percentile": 0.51724}, "CVE-2024-1330": {"epss_score": 0.00245, "epss_percentile": 0.47674}, "CVE-2024-1331": {"epss_score": 0.00226, "epss_percentile": 0.45343}, "CVE-2024-1332": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-1333": {"epss_score": 0.00216, "epss_percentile": 0.44191}, "CVE-2024-1334": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2024-1335": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2024-1336": {"epss_score": 0.00147, "epss_percentile": 0.35697}, "CVE-2024-1337": {"epss_score": 0.00119, "epss_percentile": 0.31582}, "CVE-2024-1338": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2024-1339": {"epss_score": 0.00108, "epss_percentile": 0.29844}, "CVE-2024-1340": {"epss_score": 0.00177, "epss_percentile": 0.39608}, "CVE-2024-1341": {"epss_score": 0.00224, "epss_percentile": 0.45024}, "CVE-2024-1343": {"epss_score": 0.00027, "epss_percentile": 0.06957}, "CVE-2024-1344": {"epss_score": 0.00055, "epss_percentile": 0.1738}, "CVE-2024-1345": {"epss_score": 0.00032, "epss_percentile": 0.08864}, "CVE-2024-1346": {"epss_score": 0.00316, "epss_percentile": 0.54273}, "CVE-2024-1347": {"epss_score": 0.00011, "epss_percentile": 0.0111}, "CVE-2024-1348": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-1349": {"epss_score": 0.00561, "epss_percentile": 0.67664}, "CVE-2024-1350": {"epss_score": 0.00159, "epss_percentile": 0.37384}, "CVE-2024-1351": {"epss_score": 0.00249, "epss_percentile": 0.48024}, "CVE-2024-1352": {"epss_score": 0.00278, "epss_percentile": 0.50905}, "CVE-2024-1353": {"epss_score": 0.00073, "epss_percentile": 0.22554}, "CVE-2024-1354": {"epss_score": 0.00303, "epss_percentile": 0.5321}, "CVE-2024-1355": {"epss_score": 0.00468, "epss_percentile": 0.63886}, "CVE-2024-1356": {"epss_score": 0.00129, "epss_percentile": 0.33141}, "CVE-2024-1357": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-1358": {"epss_score": 0.02609, "epss_percentile": 0.85232}, "CVE-2024-1359": {"epss_score": 0.00584, "epss_percentile": 0.68367}, "CVE-2024-1360": {"epss_score": 0.00092, "epss_percentile": 0.26584}, "CVE-2024-1361": {"epss_score": 0.00092, "epss_percentile": 0.26584}, "CVE-2024-1362": {"epss_score": 0.00092, "epss_percentile": 0.26584}, "CVE-2024-1363": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-1364": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2024-1365": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2024-1366": {"epss_score": 0.00321, "epss_percentile": 0.54694}, "CVE-2024-1367": {"epss_score": 0.04404, "epss_percentile": 0.8865}, "CVE-2024-1368": {"epss_score": 0.00212, "epss_percentile": 0.43801}, "CVE-2024-1369": {"epss_score": 0.00584, "epss_percentile": 0.68367}, "CVE-2024-1370": {"epss_score": 0.00206, "epss_percentile": 0.4295}, "CVE-2024-1371": {"epss_score": 0.00097, "epss_percentile": 0.27479}, "CVE-2024-1372": {"epss_score": 0.00486, "epss_percentile": 0.64775}, "CVE-2024-1374": {"epss_score": 0.02798, "epss_percentile": 0.85687}, "CVE-2024-1375": {"epss_score": 0.00178, "epss_percentile": 0.39708}, "CVE-2024-1376": {"epss_score": 0.00122, "epss_percentile": 0.32104}, "CVE-2024-1377": {"epss_score": 0.00243, "epss_percentile": 0.47431}, "CVE-2024-1378": {"epss_score": 0.01134, "epss_percentile": 0.77885}, "CVE-2024-1379": {"epss_score": 0.00969, "epss_percentile": 0.76106}, "CVE-2024-1380": {"epss_score": 0.87505, "epss_percentile": 0.99431}, "CVE-2024-1381": {"epss_score": 0.00354, "epss_percentile": 0.57232}, "CVE-2024-1382": {"epss_score": 0.0124, "epss_percentile": 0.78804}, "CVE-2024-1383": {"epss_score": 0.0179, "epss_percentile": 0.82279}, "CVE-2024-1384": {"epss_score": 0.00172, "epss_percentile": 0.38996}, "CVE-2024-1385": {"epss_score": 0.00075, "epss_percentile": 0.23028}, "CVE-2024-1386": {"epss_score": 0.00172, "epss_percentile": 0.38945}, "CVE-2024-1387": {"epss_score": 0.00285, "epss_percentile": 0.51517}, "CVE-2024-1388": {"epss_score": 0.00155, "epss_percentile": 0.36855}, "CVE-2024-1389": {"epss_score": 0.00221, "epss_percentile": 0.44697}, "CVE-2024-1390": {"epss_score": 0.00222, "epss_percentile": 0.44757}, "CVE-2024-1391": {"epss_score": 0.00297, "epss_percentile": 0.52748}, "CVE-2024-1392": {"epss_score": 0.00279, "epss_percentile": 0.5093}, "CVE-2024-1393": {"epss_score": 0.00297, "epss_percentile": 0.52748}, "CVE-2024-1394": {"epss_score": 0.01021, "epss_percentile": 0.76751}, "CVE-2024-1395": {"epss_score": 0.00093, "epss_percentile": 0.26684}, "CVE-2024-1396": {"epss_score": 0.00155, "epss_percentile": 0.36862}, "CVE-2024-1397": {"epss_score": 0.00215, "epss_percentile": 0.44056}, "CVE-2024-1398": {"epss_score": 0.00172, "epss_percentile": 0.3897}, "CVE-2024-1399": {"epss_score": 0.00152, "epss_percentile": 0.36403}, "CVE-2024-1400": {"epss_score": 0.00066, "epss_percentile": 0.20874}, "CVE-2024-1401": {"epss_score": 0.00108, "epss_percentile": 0.299}, "CVE-2024-1402": {"epss_score": 0.00336, "epss_percentile": 0.56004}, "CVE-2024-1403": {"epss_score": 0.16569, "epss_percentile": 0.94695}, "CVE-2024-1404": {"epss_score": 0.00102, "epss_percentile": 0.28895}, "CVE-2024-1405": {"epss_score": 0.00044, "epss_percentile": 0.13667}, "CVE-2024-1406": {"epss_score": 0.00044, "epss_percentile": 0.13667}, "CVE-2024-1407": {"epss_score": 0.00201, "epss_percentile": 0.42329}, "CVE-2024-1408": {"epss_score": 0.00238, "epss_percentile": 0.46747}, "CVE-2024-1409": {"epss_score": 0.00265, "epss_percentile": 0.49819}, "CVE-2024-1410": {"epss_score": 0.00405, "epss_percentile": 0.605}, "CVE-2024-1411": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-1412": {"epss_score": 0.02533, "epss_percentile": 0.85033}, "CVE-2024-1413": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-1414": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-1415": {"epss_score": 0.00085, "epss_percentile": 0.25152}, "CVE-2024-1416": {"epss_score": 0.00192, "epss_percentile": 0.41361}, "CVE-2024-1417": {"epss_score": 0.00216, "epss_percentile": 0.44144}, "CVE-2024-1418": {"epss_score": 0.00357, "epss_percentile": 0.57468}, "CVE-2024-1419": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-1421": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-1422": {"epss_score": 0.00172, "epss_percentile": 0.38945}, "CVE-2024-1424": {"epss_score": 0.00134, "epss_percentile": 0.33786}, "CVE-2024-1425": {"epss_score": 0.00761, "epss_percentile": 0.72821}, "CVE-2024-1426": {"epss_score": 0.00184, "epss_percentile": 0.40425}, "CVE-2024-1427": {"epss_score": 0.00272, "epss_percentile": 0.5037}, "CVE-2024-1428": {"epss_score": 0.00126, "epss_percentile": 0.32771}, "CVE-2024-1429": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-1430": {"epss_score": 0.00047, "epss_percentile": 0.14496}, "CVE-2024-1431": {"epss_score": 0.00047, "epss_percentile": 0.14496}, "CVE-2024-1432": {"epss_score": 0.0003, "epss_percentile": 0.08258}, "CVE-2024-1433": {"epss_score": 0.00111, "epss_percentile": 0.30337}, "CVE-2024-1434": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2024-1435": {"epss_score": 0.00498, "epss_percentile": 0.65238}, "CVE-2024-1436": {"epss_score": 0.00366, "epss_percentile": 0.58053}, "CVE-2024-1437": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2024-1438": {"epss_score": 0.0032, "epss_percentile": 0.54639}, "CVE-2024-1439": {"epss_score": 0.00052, "epss_percentile": 0.16595}, "CVE-2024-1440": {"epss_score": 0.00039, "epss_percentile": 0.11455}, "CVE-2024-1441": {"epss_score": 0.00061, "epss_percentile": 0.1937}, "CVE-2024-1442": {"epss_score": 0.00206, "epss_percentile": 0.43048}, "CVE-2024-1443": {"epss_score": 0.00031, "epss_percentile": 0.08449}, "CVE-2024-1445": {"epss_score": 0.00188, "epss_percentile": 0.40848}, "CVE-2024-1446": {"epss_score": 0.00121, "epss_percentile": 0.31916}, "CVE-2024-1447": {"epss_score": 0.00172, "epss_percentile": 0.38945}, "CVE-2024-1448": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2024-1449": {"epss_score": 0.00094, "epss_percentile": 0.27062}, "CVE-2024-1450": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2024-1451": {"epss_score": 0.29088, "epss_percentile": 0.96417}, "CVE-2024-1452": {"epss_score": 0.00241, "epss_percentile": 0.47266}, "CVE-2024-1453": {"epss_score": 0.00047, "epss_percentile": 0.14476}, "CVE-2024-1454": {"epss_score": 0.00079, "epss_percentile": 0.23867}, "CVE-2024-1455": {"epss_score": 0.00103, "epss_percentile": 0.29089}, "CVE-2024-1456": {"epss_score": 0.00071, "epss_percentile": 0.22134}, "CVE-2024-1458": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-1459": {"epss_score": 0.06044, "epss_percentile": 0.90432}, "CVE-2024-1460": {"epss_score": 0.00041, "epss_percentile": 0.12441}, "CVE-2024-1461": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-1462": {"epss_score": 0.00391, "epss_percentile": 0.59582}, "CVE-2024-1463": {"epss_score": 0.00239, "epss_percentile": 0.46918}, "CVE-2024-1464": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-1465": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-1466": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-1467": {"epss_score": 0.00132, "epss_percentile": 0.33531}, "CVE-2024-1468": {"epss_score": 0.03612, "epss_percentile": 0.87428}, "CVE-2024-1470": {"epss_score": 0.00013, "epss_percentile": 0.01489}, "CVE-2024-1471": {"epss_score": 0.00133, "epss_percentile": 0.33744}, "CVE-2024-1472": {"epss_score": 0.00225, "epss_percentile": 0.45098}, "CVE-2024-1473": {"epss_score": 0.00169, "epss_percentile": 0.38635}, "CVE-2024-1474": {"epss_score": 0.00068, "epss_percentile": 0.21267}, "CVE-2024-1475": {"epss_score": 0.00225, "epss_percentile": 0.45127}, "CVE-2024-1476": {"epss_score": 0.00304, "epss_percentile": 0.53287}, "CVE-2024-1477": {"epss_score": 0.00079, "epss_percentile": 0.23892}, "CVE-2024-1478": {"epss_score": 0.00251, "epss_percentile": 0.48307}, "CVE-2024-1479": {"epss_score": 0.00302, "epss_percentile": 0.53102}, "CVE-2024-1480": {"epss_score": 0.00113, "epss_percentile": 0.30691}, "CVE-2024-1481": {"epss_score": 0.00352, "epss_percentile": 0.57117}, "CVE-2024-1482": {"epss_score": 0.00082, "epss_percentile": 0.24577}, "CVE-2024-1483": {"epss_score": 0.78605, "epss_percentile": 0.98994}, "CVE-2024-1484": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2024-1485": {"epss_score": 0.01623, "epss_percentile": 0.81404}, "CVE-2024-1486": {"epss_score": 0.0006, "epss_percentile": 0.19066}, "CVE-2024-1487": {"epss_score": 0.00272, "epss_percentile": 0.50376}, "CVE-2024-1488": {"epss_score": 0.00071, "epss_percentile": 0.22179}, "CVE-2024-1489": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2024-1491": {"epss_score": 0.00144, "epss_percentile": 0.35329}, "CVE-2024-1492": {"epss_score": 0.00391, "epss_percentile": 0.59582}, "CVE-2024-1493": {"epss_score": 0.00171, "epss_percentile": 0.38884}, "CVE-2024-1495": {"epss_score": 0.00539, "epss_percentile": 0.66968}, "CVE-2024-1496": {"epss_score": 0.00219, "epss_percentile": 0.44477}, "CVE-2024-1497": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2024-1498": {"epss_score": 0.00228, "epss_percentile": 0.45467}, "CVE-2024-1499": {"epss_score": 0.00284, "epss_percentile": 0.51488}, "CVE-2024-1500": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2024-1501": {"epss_score": 0.00189, "epss_percentile": 0.4098}, "CVE-2024-1502": {"epss_score": 0.00076, "epss_percentile": 0.2322}, "CVE-2024-1503": {"epss_score": 0.00115, "epss_percentile": 0.31028}, "CVE-2024-1504": {"epss_score": 0.00125, "epss_percentile": 0.32471}, "CVE-2024-1505": {"epss_score": 0.00134, "epss_percentile": 0.33919}, "CVE-2024-1506": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-1507": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-1508": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-1509": {"epss_score": 0.00049, "epss_percentile": 0.15302}, "CVE-2024-1510": {"epss_score": 0.00172, "epss_percentile": 0.3897}, "CVE-2024-1511": {"epss_score": 0.00415, "epss_percentile": 0.61119}, "CVE-2024-1512": {"epss_score": 0.93817, "epss_percentile": 0.99851}, "CVE-2024-1514": {"epss_score": 0.00551, "epss_percentile": 0.67376}, "CVE-2024-1516": {"epss_score": 0.00231, "epss_percentile": 0.45801}, "CVE-2024-1519": {"epss_score": 0.0166, "epss_percentile": 0.8162}, "CVE-2024-1520": {"epss_score": 0.11437, "epss_percentile": 0.93361}, "CVE-2024-1521": {"epss_score": 0.00119, "epss_percentile": 0.31596}, "CVE-2024-1522": {"epss_score": 0.00944, "epss_percentile": 0.75792}, "CVE-2024-1523": {"epss_score": 0.00414, "epss_percentile": 0.61092}, "CVE-2024-1525": {"epss_score": 8e-05, "epss_percentile": 0.00555}, "CVE-2024-1526": {"epss_score": 0.00136, "epss_percentile": 0.3416}, "CVE-2024-1527": {"epss_score": 0.00056, "epss_percentile": 0.1792}, "CVE-2024-1528": {"epss_score": 0.0008, "epss_percentile": 0.24015}, "CVE-2024-1529": {"epss_score": 0.0008, "epss_percentile": 0.24015}, "CVE-2024-1530": {"epss_score": 0.00044, "epss_percentile": 0.13465}, "CVE-2024-1531": {"epss_score": 0.00051, "epss_percentile": 0.15984}, "CVE-2024-1532": {"epss_score": 0.00024, "epss_percentile": 0.05804}, "CVE-2024-1533": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-1534": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2024-1535": {"epss_score": 0.00278, "epss_percentile": 0.50879}, "CVE-2024-1536": {"epss_score": 0.00205, "epss_percentile": 0.42762}, "CVE-2024-1537": {"epss_score": 0.00134, "epss_percentile": 0.33786}, "CVE-2024-1538": {"epss_score": 0.04491, "epss_percentile": 0.88757}, "CVE-2024-1539": {"epss_score": 0.00038, "epss_percentile": 0.11315}, "CVE-2024-1540": {"epss_score": 0.00402, "epss_percentile": 0.60291}, "CVE-2024-1541": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2024-1543": {"epss_score": 0.00017, "epss_percentile": 0.03213}, "CVE-2024-1544": {"epss_score": 0.00056, "epss_percentile": 0.17776}, "CVE-2024-1545": {"epss_score": 0.00169, "epss_percentile": 0.38563}, "CVE-2024-1546": {"epss_score": 0.00368, "epss_percentile": 0.58192}, "CVE-2024-1547": {"epss_score": 0.00448, "epss_percentile": 0.63006}, "CVE-2024-1548": {"epss_score": 0.00328, "epss_percentile": 0.55298}, "CVE-2024-1549": {"epss_score": 0.00339, "epss_percentile": 0.56167}, "CVE-2024-1550": {"epss_score": 0.00202, "epss_percentile": 0.42419}, "CVE-2024-1551": {"epss_score": 0.00291, "epss_percentile": 0.52159}, "CVE-2024-1552": {"epss_score": 0.00283, "epss_percentile": 0.51354}, "CVE-2024-1553": {"epss_score": 0.00508, "epss_percentile": 0.65717}, "CVE-2024-1554": {"epss_score": 0.00225, "epss_percentile": 0.45129}, "CVE-2024-1555": {"epss_score": 0.00062, "epss_percentile": 0.19578}, "CVE-2024-1556": {"epss_score": 0.0022, "epss_percentile": 0.4462}, "CVE-2024-1557": {"epss_score": 0.00555, "epss_percentile": 0.67459}, "CVE-2024-1558": {"epss_score": 0.0016, "epss_percentile": 0.37467}, "CVE-2024-1559": {"epss_score": 0.00527, "epss_percentile": 0.66529}, "CVE-2024-1560": {"epss_score": 0.0014, "epss_percentile": 0.34683}, "CVE-2024-1561": {"epss_score": 0.93609, "epss_percentile": 0.99823}, "CVE-2024-1562": {"epss_score": 0.00149, "epss_percentile": 0.35967}, "CVE-2024-1563": {"epss_score": 0.00323, "epss_percentile": 0.54911}, "CVE-2024-1564": {"epss_score": 0.00273, "epss_percentile": 0.50474}, "CVE-2024-1565": {"epss_score": 0.00297, "epss_percentile": 0.52756}, "CVE-2024-1566": {"epss_score": 0.00253, "epss_percentile": 0.48486}, "CVE-2024-1567": {"epss_score": 0.03717, "epss_percentile": 0.87615}, "CVE-2024-1568": {"epss_score": 0.00153, "epss_percentile": 0.36509}, "CVE-2024-1569": {"epss_score": 0.00122, "epss_percentile": 0.32096}, "CVE-2024-1570": {"epss_score": 0.00238, "epss_percentile": 0.46747}, "CVE-2024-1571": {"epss_score": 0.00381, "epss_percentile": 0.58992}, "CVE-2024-1572": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2024-1573": {"epss_score": 0.00243, "epss_percentile": 0.47427}, "CVE-2024-1574": {"epss_score": 0.0014, "epss_percentile": 0.34692}, "CVE-2024-1575": {"epss_score": 0.00262, "epss_percentile": 0.49342}, "CVE-2024-1576": {"epss_score": 0.00135, "epss_percentile": 0.33977}, "CVE-2024-1577": {"epss_score": 0.02294, "epss_percentile": 0.84289}, "CVE-2024-1578": {"epss_score": 0.00132, "epss_percentile": 0.3352}, "CVE-2024-1579": {"epss_score": 0.00206, "epss_percentile": 0.42781}, "CVE-2024-1580": {"epss_score": 0.00275, "epss_percentile": 0.50701}, "CVE-2024-1582": {"epss_score": 0.00138, "epss_percentile": 0.34397}, "CVE-2024-1584": {"epss_score": 0.00212, "epss_percentile": 0.43791}, "CVE-2024-1585": {"epss_score": 0.00172, "epss_percentile": 0.38945}, "CVE-2024-1586": {"epss_score": 0.00175, "epss_percentile": 0.39302}, "CVE-2024-1587": {"epss_score": 0.01071, "epss_percentile": 0.77272}, "CVE-2024-1588": {"epss_score": 0.00079, "epss_percentile": 0.23816}, "CVE-2024-1589": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2024-1590": {"epss_score": 0.00162, "epss_percentile": 0.37636}, "CVE-2024-1591": {"epss_score": 0.00061, "epss_percentile": 0.19301}, "CVE-2024-1592": {"epss_score": 0.00063, "epss_percentile": 0.19811}, "CVE-2024-1593": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2024-1594": {"epss_score": 0.00364, "epss_percentile": 0.57951}, "CVE-2024-1595": {"epss_score": 0.00026, "epss_percentile": 0.06593}, "CVE-2024-1596": {"epss_score": 0.02402, "epss_percentile": 0.84641}, "CVE-2024-1597": {"epss_score": 0.00505, "epss_percentile": 0.65605}, "CVE-2024-1598": {"epss_score": 0.00109, "epss_percentile": 0.29917}, "CVE-2024-1600": {"epss_score": 0.00157, "epss_percentile": 0.37101}, "CVE-2024-1601": {"epss_score": 0.00274, "epss_percentile": 0.50485}, "CVE-2024-1602": {"epss_score": 0.00181, "epss_percentile": 0.40085}, "CVE-2024-1603": {"epss_score": 0.0017, "epss_percentile": 0.38665}, "CVE-2024-1604": {"epss_score": 0.00068, "epss_percentile": 0.21216}, "CVE-2024-1605": {"epss_score": 0.00029, "epss_percentile": 0.07927}, "CVE-2024-1606": {"epss_score": 0.00106, "epss_percentile": 0.29555}, "CVE-2024-1608": {"epss_score": 0.0024, "epss_percentile": 0.46967}, "CVE-2024-1609": {"epss_score": 0.00125, "epss_percentile": 0.32502}, "CVE-2024-1610": {"epss_score": 0.00153, "epss_percentile": 0.36634}, "CVE-2024-1618": {"epss_score": 0.00032, "epss_percentile": 0.09119}, "CVE-2024-1619": {"epss_score": 0.00097, "epss_percentile": 0.2754}, "CVE-2024-1621": {"epss_score": 0.00234, "epss_percentile": 0.46113}, "CVE-2024-1622": {"epss_score": 0.00204, "epss_percentile": 0.42603}, "CVE-2024-1623": {"epss_score": 0.0003, "epss_percentile": 0.08253}, "CVE-2024-1624": {"epss_score": 0.00265, "epss_percentile": 0.49785}, "CVE-2024-1625": {"epss_score": 0.00138, "epss_percentile": 0.34372}, "CVE-2024-1626": {"epss_score": 0.0014, "epss_percentile": 0.34725}, "CVE-2024-1628": {"epss_score": 0.00374, "epss_percentile": 0.58574}, "CVE-2024-1629": {"epss_score": 0.0012, "epss_percentile": 0.31811}, "CVE-2024-1630": {"epss_score": 0.0011, "epss_percentile": 0.30118}, "CVE-2024-1631": {"epss_score": 0.00436, "epss_percentile": 0.62388}, "CVE-2024-1632": {"epss_score": 0.02178, "epss_percentile": 0.83892}, "CVE-2024-1633": {"epss_score": 6e-05, "epss_percentile": 0.0031}, "CVE-2024-1634": {"epss_score": 0.00214, "epss_percentile": 0.43955}, "CVE-2024-1635": {"epss_score": 0.0833, "epss_percentile": 0.91994}, "CVE-2024-1636": {"epss_score": 0.00066, "epss_percentile": 0.20886}, "CVE-2024-1637": {"epss_score": 0.00132, "epss_percentile": 0.33531}, "CVE-2024-1638": {"epss_score": 0.00202, "epss_percentile": 0.42476}, "CVE-2024-1639": {"epss_score": 0.00418, "epss_percentile": 0.61271}, "CVE-2024-1640": {"epss_score": 0.00277, "epss_percentile": 0.50775}, "CVE-2024-1641": {"epss_score": 0.00222, "epss_percentile": 0.44745}, "CVE-2024-1642": {"epss_score": 0.001, "epss_percentile": 0.28525}, "CVE-2024-1643": {"epss_score": 0.00165, "epss_percentile": 0.38037}, "CVE-2024-1644": {"epss_score": 0.00312, "epss_percentile": 0.53965}, "CVE-2024-1645": {"epss_score": 0.00127, "epss_percentile": 0.32879}, "CVE-2024-1646": {"epss_score": 0.00067, "epss_percentile": 0.21173}, "CVE-2024-1647": {"epss_score": 0.00183, "epss_percentile": 0.40329}, "CVE-2024-1648": {"epss_score": 0.00183, "epss_percentile": 0.40329}, "CVE-2024-1649": {"epss_score": 0.00102, "epss_percentile": 0.28868}, "CVE-2024-1650": {"epss_score": 0.00102, "epss_percentile": 0.28868}, "CVE-2024-1651": {"epss_score": 0.77804, "epss_percentile": 0.98955}, "CVE-2024-1652": {"epss_score": 0.00102, "epss_percentile": 0.28868}, "CVE-2024-1653": {"epss_score": 0.00102, "epss_percentile": 0.28868}, "CVE-2024-1654": {"epss_score": 0.09624, "epss_percentile": 0.92628}, "CVE-2024-1655": {"epss_score": 0.1465, "epss_percentile": 0.94257}, "CVE-2024-1656": {"epss_score": 0.00364, "epss_percentile": 0.57926}, "CVE-2024-1657": {"epss_score": 0.00075, "epss_percentile": 0.22966}, "CVE-2024-1658": {"epss_score": 0.00092, "epss_percentile": 0.26419}, "CVE-2024-1659": {"epss_score": 0.00209, "epss_percentile": 0.43313}, "CVE-2024-1660": {"epss_score": 0.00223, "epss_percentile": 0.44862}, "CVE-2024-1661": {"epss_score": 0.00048, "epss_percentile": 0.15222}, "CVE-2024-1662": {"epss_score": 0.00153, "epss_percentile": 0.36575}, "CVE-2024-1663": {"epss_score": 0.00051, "epss_percentile": 0.16337}, "CVE-2024-1664": {"epss_score": 0.0034, "epss_percentile": 0.56256}, "CVE-2024-1666": {"epss_score": 0.00143, "epss_percentile": 0.3517}, "CVE-2024-1668": {"epss_score": 0.00545, "epss_percentile": 0.67166}, "CVE-2024-1669": {"epss_score": 0.00164, "epss_percentile": 0.37942}, "CVE-2024-1670": {"epss_score": 0.00309, "epss_percentile": 0.53702}, "CVE-2024-1671": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2024-1672": {"epss_score": 0.00046, "epss_percentile": 0.1414}, "CVE-2024-1673": {"epss_score": 0.00365, "epss_percentile": 0.57987}, "CVE-2024-1674": {"epss_score": 0.00013, "epss_percentile": 0.0168}, "CVE-2024-1675": {"epss_score": 0.00065, "epss_percentile": 0.20473}, "CVE-2024-1676": {"epss_score": 0.00186, "epss_percentile": 0.40626}, "CVE-2024-1677": {"epss_score": 0.00215, "epss_percentile": 0.44028}, "CVE-2024-1678": {"epss_score": 0.0023, "epss_percentile": 0.4574}, "CVE-2024-1679": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-1680": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-1681": {"epss_score": 0.00149, "epss_percentile": 0.36037}, "CVE-2024-1682": {"epss_score": 0.00049, "epss_percentile": 0.15565}, "CVE-2024-1683": {"epss_score": 0.00026, "epss_percentile": 0.06731}, "CVE-2024-1684": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-1685": {"epss_score": 0.00766, "epss_percentile": 0.7293}, "CVE-2024-1686": {"epss_score": 0.00372, "epss_percentile": 0.58447}, "CVE-2024-1687": {"epss_score": 0.00275, "epss_percentile": 0.50634}, "CVE-2024-1688": {"epss_score": 0.00965, "epss_percentile": 0.76044}, "CVE-2024-1689": {"epss_score": 0.00247, "epss_percentile": 0.47886}, "CVE-2024-1690": {"epss_score": 0.00207, "epss_percentile": 0.43179}, "CVE-2024-1691": {"epss_score": 0.009, "epss_percentile": 0.7516}, "CVE-2024-1692": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-1693": {"epss_score": 0.00199, "epss_percentile": 0.421}, "CVE-2024-1694": {"epss_score": 7e-05, "epss_percentile": 0.00323}, "CVE-2024-1695": {"epss_score": 0.00043, "epss_percentile": 0.1295}, "CVE-2024-1696": {"epss_score": 0.00075, "epss_percentile": 0.229}, "CVE-2024-1697": {"epss_score": 0.00138, "epss_percentile": 0.34347}, "CVE-2024-1698": {"epss_score": 0.9384, "epss_percentile": 0.99854}, "CVE-2024-1700": {"epss_score": 0.00134, "epss_percentile": 0.33791}, "CVE-2024-1701": {"epss_score": 0.00191, "epss_percentile": 0.41203}, "CVE-2024-1702": {"epss_score": 0.00103, "epss_percentile": 0.28928}, "CVE-2024-1703": {"epss_score": 0.00235, "epss_percentile": 0.46219}, "CVE-2024-1704": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2024-1705": {"epss_score": 0.00089, "epss_percentile": 0.25795}, "CVE-2024-1706": {"epss_score": 0.00105, "epss_percentile": 0.2938}, "CVE-2024-1707": {"epss_score": 0.00202, "epss_percentile": 0.42424}, "CVE-2024-1708": {"epss_score": 0.52122, "epss_percentile": 0.97808}, "CVE-2024-1709": {"epss_score": 0.94322, "epss_percentile": 0.99947}, "CVE-2024-1710": {"epss_score": 0.00315, "epss_percentile": 0.54172}, "CVE-2024-1711": {"epss_score": 0.00852, "epss_percentile": 0.74419}, "CVE-2024-1712": {"epss_score": 0.00114, "epss_percentile": 0.30799}, "CVE-2024-1713": {"epss_score": 0.00071, "epss_percentile": 0.2208}, "CVE-2024-1714": {"epss_score": 0.00076, "epss_percentile": 0.23135}, "CVE-2024-1716": {"epss_score": 0.00132, "epss_percentile": 0.33531}, "CVE-2024-1717": {"epss_score": 0.00341, "epss_percentile": 0.56337}, "CVE-2024-1718": {"epss_score": 0.0009, "epss_percentile": 0.26001}, "CVE-2024-1719": {"epss_score": 0.00112, "epss_percentile": 0.3046}, "CVE-2024-1720": {"epss_score": 0.01977, "epss_percentile": 0.83124}, "CVE-2024-1721": {"epss_score": 0.00048, "epss_percentile": 0.15114}, "CVE-2024-1722": {"epss_score": 0.00407, "epss_percentile": 0.60607}, "CVE-2024-1723": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2024-1724": {"epss_score": 0.00026, "epss_percentile": 0.06479}, "CVE-2024-1725": {"epss_score": 0.00142, "epss_percentile": 0.34982}, "CVE-2024-1726": {"epss_score": 0.00034, "epss_percentile": 0.09745}, "CVE-2024-1727": {"epss_score": 0.00115, "epss_percentile": 0.30981}, "CVE-2024-1728": {"epss_score": 0.81897, "epss_percentile": 0.99164}, "CVE-2024-1729": {"epss_score": 0.00082, "epss_percentile": 0.24473}, "CVE-2024-1730": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-1731": {"epss_score": 0.00951, "epss_percentile": 0.75864}, "CVE-2024-1732": {"epss_score": 0.00197, "epss_percentile": 0.41857}, "CVE-2024-1733": {"epss_score": 0.00221, "epss_percentile": 0.44661}, "CVE-2024-1735": {"epss_score": 0.00146, "epss_percentile": 0.35552}, "CVE-2024-1736": {"epss_score": 0.00575, "epss_percentile": 0.68098}, "CVE-2024-1737": {"epss_score": 0.00169, "epss_percentile": 0.38629}, "CVE-2024-1738": {"epss_score": 0.00228, "epss_percentile": 0.45468}, "CVE-2024-1739": {"epss_score": 0.00179, "epss_percentile": 0.39752}, "CVE-2024-1740": {"epss_score": 0.00178, "epss_percentile": 0.39712}, "CVE-2024-1741": {"epss_score": 0.00241, "epss_percentile": 0.47319}, "CVE-2024-1742": {"epss_score": 0.00136, "epss_percentile": 0.34084}, "CVE-2024-1743": {"epss_score": 0.00105, "epss_percentile": 0.29266}, "CVE-2024-1744": {"epss_score": 0.00048, "epss_percentile": 0.14991}, "CVE-2024-1745": {"epss_score": 0.00144, "epss_percentile": 0.35319}, "CVE-2024-1746": {"epss_score": 0.00273, "epss_percentile": 0.50448}, "CVE-2024-1747": {"epss_score": 0.00167, "epss_percentile": 0.38383}, "CVE-2024-1748": {"epss_score": 0.00069, "epss_percentile": 0.21612}, "CVE-2024-1749": {"epss_score": 0.00096, "epss_percentile": 0.27338}, "CVE-2024-1750": {"epss_score": 0.00038, "epss_percentile": 0.11117}, "CVE-2024-1751": {"epss_score": 0.00687, "epss_percentile": 0.71176}, "CVE-2024-1752": {"epss_score": 0.00292, "epss_percentile": 0.52285}, "CVE-2024-1753": {"epss_score": 0.00064, "epss_percentile": 0.20164}, "CVE-2024-1754": {"epss_score": 0.00228, "epss_percentile": 0.45504}, "CVE-2024-1755": {"epss_score": 0.00267, "epss_percentile": 0.49998}, "CVE-2024-1756": {"epss_score": 0.00082, "epss_percentile": 0.24586}, "CVE-2024-1758": {"epss_score": 0.00337, "epss_percentile": 0.56016}, "CVE-2024-1759": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-1760": {"epss_score": 0.00102, "epss_percentile": 0.28874}, "CVE-2024-1761": {"epss_score": 0.00168, "epss_percentile": 0.38433}, "CVE-2024-1762": {"epss_score": 0.01435, "epss_percentile": 0.80273}, "CVE-2024-1763": {"epss_score": 0.00202, "epss_percentile": 0.42462}, "CVE-2024-1764": {"epss_score": 0.00093, "epss_percentile": 0.26602}, "CVE-2024-1765": {"epss_score": 0.04721, "epss_percentile": 0.89048}, "CVE-2024-1766": {"epss_score": 0.0047, "epss_percentile": 0.63959}, "CVE-2024-1767": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-1768": {"epss_score": 0.00256, "epss_percentile": 0.48772}, "CVE-2024-1769": {"epss_score": 0.00208, "epss_percentile": 0.43256}, "CVE-2024-1770": {"epss_score": 0.00885, "epss_percentile": 0.74939}, "CVE-2024-1771": {"epss_score": 0.00084, "epss_percentile": 0.24921}, "CVE-2024-1772": {"epss_score": 0.00742, "epss_percentile": 0.72455}, "CVE-2024-1773": {"epss_score": 0.00485, "epss_percentile": 0.6471}, "CVE-2024-1774": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2024-1775": {"epss_score": 0.00221, "epss_percentile": 0.4466}, "CVE-2024-1776": {"epss_score": 0.00347, "epss_percentile": 0.56764}, "CVE-2024-1777": {"epss_score": 0.00068, "epss_percentile": 0.21322}, "CVE-2024-1778": {"epss_score": 0.00174, "epss_percentile": 0.39259}, "CVE-2024-1779": {"epss_score": 0.00174, "epss_percentile": 0.39259}, "CVE-2024-1780": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2024-1781": {"epss_score": 0.15679, "epss_percentile": 0.94484}, "CVE-2024-1782": {"epss_score": 0.01184, "epss_percentile": 0.78332}, "CVE-2024-1783": {"epss_score": 0.00418, "epss_percentile": 0.61347}, "CVE-2024-1784": {"epss_score": 0.0005, "epss_percentile": 0.15838}, "CVE-2024-1785": {"epss_score": 0.00166, "epss_percentile": 0.38166}, "CVE-2024-1786": {"epss_score": 0.00626, "epss_percentile": 0.69598}, "CVE-2024-1787": {"epss_score": 0.00764, "epss_percentile": 0.72893}, "CVE-2024-1789": {"epss_score": 0.00531, "epss_percentile": 0.66664}, "CVE-2024-1790": {"epss_score": 0.00771, "epss_percentile": 0.73015}, "CVE-2024-1791": {"epss_score": 0.00195, "epss_percentile": 0.41623}, "CVE-2024-1792": {"epss_score": 0.00689, "epss_percentile": 0.7123}, "CVE-2024-1793": {"epss_score": 0.00642, "epss_percentile": 0.70037}, "CVE-2024-1794": {"epss_score": 0.02252, "epss_percentile": 0.84161}, "CVE-2024-1795": {"epss_score": 0.00311, "epss_percentile": 0.53817}, "CVE-2024-1796": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-1797": {"epss_score": 0.00505, "epss_percentile": 0.65598}, "CVE-2024-1798": {"epss_score": 0.00826, "epss_percentile": 0.73961}, "CVE-2024-1799": {"epss_score": 0.00244, "epss_percentile": 0.47564}, "CVE-2024-1800": {"epss_score": 0.76351, "epss_percentile": 0.98887}, "CVE-2024-1801": {"epss_score": 0.00018, "epss_percentile": 0.03891}, "CVE-2024-1802": {"epss_score": 0.00083, "epss_percentile": 0.24742}, "CVE-2024-1803": {"epss_score": 0.00117, "epss_percentile": 0.31375}, "CVE-2024-1804": {"epss_score": 0.00188, "epss_percentile": 0.40889}, "CVE-2024-1805": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-1806": {"epss_score": 0.0026, "epss_percentile": 0.49162}, "CVE-2024-1807": {"epss_score": 0.0015, "epss_percentile": 0.36072}, "CVE-2024-1808": {"epss_score": 0.00168, "epss_percentile": 0.3842}, "CVE-2024-1809": {"epss_score": 0.00153, "epss_percentile": 0.36509}, "CVE-2024-1810": {"epss_score": 0.0071, "epss_percentile": 0.71709}, "CVE-2024-1811": {"epss_score": 0.00128, "epss_percentile": 0.33058}, "CVE-2024-1812": {"epss_score": 0.00631, "epss_percentile": 0.69713}, "CVE-2024-1813": {"epss_score": 0.07996, "epss_percentile": 0.91813}, "CVE-2024-1814": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-1815": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-1816": {"epss_score": 0.00085, "epss_percentile": 0.25219}, "CVE-2024-1817": {"epss_score": 0.00061, "epss_percentile": 0.19261}, "CVE-2024-1818": {"epss_score": 0.00054, "epss_percentile": 0.17093}, "CVE-2024-1819": {"epss_score": 0.00054, "epss_percentile": 0.17093}, "CVE-2024-1820": {"epss_score": 0.00044, "epss_percentile": 0.13455}, "CVE-2024-1821": {"epss_score": 0.00022, "epss_percentile": 0.0527}, "CVE-2024-1822": {"epss_score": 0.00052, "epss_percentile": 0.16577}, "CVE-2024-1823": {"epss_score": 0.00117, "epss_percentile": 0.31376}, "CVE-2024-1824": {"epss_score": 0.00044, "epss_percentile": 0.13455}, "CVE-2024-1825": {"epss_score": 0.00078, "epss_percentile": 0.23614}, "CVE-2024-1826": {"epss_score": 0.00044, "epss_percentile": 0.13455}, "CVE-2024-1827": {"epss_score": 0.00044, "epss_percentile": 0.13455}, "CVE-2024-1828": {"epss_score": 0.00087, "epss_percentile": 0.25493}, "CVE-2024-1829": {"epss_score": 0.00087, "epss_percentile": 0.25493}, "CVE-2024-1830": {"epss_score": 0.00088, "epss_percentile": 0.25784}, "CVE-2024-1831": {"epss_score": 0.00051, "epss_percentile": 0.16049}, "CVE-2024-1832": {"epss_score": 0.00083, "epss_percentile": 0.24594}, "CVE-2024-1833": {"epss_score": 0.00127, "epss_percentile": 0.32816}, "CVE-2024-1834": {"epss_score": 0.00157, "epss_percentile": 0.37092}, "CVE-2024-1839": {"epss_score": 0.00843, "epss_percentile": 0.74254}, "CVE-2024-1840": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-1841": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-1842": {"epss_score": 0.00214, "epss_percentile": 0.43973}, "CVE-2024-1843": {"epss_score": 0.00222, "epss_percentile": 0.44757}, "CVE-2024-1844": {"epss_score": 0.0008, "epss_percentile": 0.24057}, "CVE-2024-1845": {"epss_score": 0.00263, "epss_percentile": 0.49548}, "CVE-2024-1846": {"epss_score": 0.0038, "epss_percentile": 0.5895}, "CVE-2024-1847": {"epss_score": 0.00118, "epss_percentile": 0.31393}, "CVE-2024-1848": {"epss_score": 0.00076, "epss_percentile": 0.23149}, "CVE-2024-1849": {"epss_score": 0.00366, "epss_percentile": 0.58067}, "CVE-2024-1850": {"epss_score": 0.00128, "epss_percentile": 0.33005}, "CVE-2024-1851": {"epss_score": 0.00049, "epss_percentile": 0.15417}, "CVE-2024-1852": {"epss_score": 0.01547, "epss_percentile": 0.80972}, "CVE-2024-1853": {"epss_score": 0.00025, "epss_percentile": 0.06323}, "CVE-2024-1854": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-1855": {"epss_score": 0.00457, "epss_percentile": 0.63381}, "CVE-2024-1856": {"epss_score": 0.00148, "epss_percentile": 0.35919}, "CVE-2024-1857": {"epss_score": 0.00189, "epss_percentile": 0.40948}, "CVE-2024-1858": {"epss_score": 0.00208, "epss_percentile": 0.43288}, "CVE-2024-1859": {"epss_score": 0.00738, "epss_percentile": 0.72346}, "CVE-2024-1860": {"epss_score": 0.00199, "epss_percentile": 0.42158}, "CVE-2024-1861": {"epss_score": 0.00117, "epss_percentile": 0.31293}, "CVE-2024-1862": {"epss_score": 0.00201, "epss_percentile": 0.42331}, "CVE-2024-1863": {"epss_score": 0.06129, "epss_percentile": 0.905}, "CVE-2024-1867": {"epss_score": 0.00075, "epss_percentile": 0.22938}, "CVE-2024-1868": {"epss_score": 0.00075, "epss_percentile": 0.22938}, "CVE-2024-1869": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2024-1870": {"epss_score": 0.00073, "epss_percentile": 0.22633}, "CVE-2024-1871": {"epss_score": 0.00078, "epss_percentile": 0.23573}, "CVE-2024-1872": {"epss_score": 0.0113, "epss_percentile": 0.77848}, "CVE-2024-1873": {"epss_score": 0.00157, "epss_percentile": 0.37064}, "CVE-2024-1874": {"epss_score": 0.57549, "epss_percentile": 0.9807}, "CVE-2024-1875": {"epss_score": 0.00128, "epss_percentile": 0.3296}, "CVE-2024-1876": {"epss_score": 0.0004, "epss_percentile": 0.12011}, "CVE-2024-1877": {"epss_score": 0.00034, "epss_percentile": 0.09731}, "CVE-2024-1878": {"epss_score": 0.00046, "epss_percentile": 0.14469}, "CVE-2024-1879": {"epss_score": 0.00403, "epss_percentile": 0.60365}, "CVE-2024-1880": {"epss_score": 0.00185, "epss_percentile": 0.40513}, "CVE-2024-1881": {"epss_score": 0.00828, "epss_percentile": 0.74003}, "CVE-2024-1882": {"epss_score": 0.07994, "epss_percentile": 0.91811}, "CVE-2024-1883": {"epss_score": 0.41961, "epss_percentile": 0.97303}, "CVE-2024-1884": {"epss_score": 0.37148, "epss_percentile": 0.97022}, "CVE-2024-1885": {"epss_score": 0.01608, "epss_percentile": 0.81311}, "CVE-2024-1886": {"epss_score": 0.00421, "epss_percentile": 0.61507}, "CVE-2024-1887": {"epss_score": 0.00145, "epss_percentile": 0.3536}, "CVE-2024-1888": {"epss_score": 0.00109, "epss_percentile": 0.3003}, "CVE-2024-1889": {"epss_score": 0.0011, "epss_percentile": 0.30205}, "CVE-2024-1890": {"epss_score": 0.00119, "epss_percentile": 0.3164}, "CVE-2024-1891": {"epss_score": 0.00214, "epss_percentile": 0.43987}, "CVE-2024-1892": {"epss_score": 0.00058, "epss_percentile": 0.18449}, "CVE-2024-1893": {"epss_score": 0.00418, "epss_percentile": 0.61345}, "CVE-2024-1894": {"epss_score": 0.00172, "epss_percentile": 0.38945}, "CVE-2024-1895": {"epss_score": 0.00802, "epss_percentile": 0.73582}, "CVE-2024-1896": {"epss_score": 0.00696, "epss_percentile": 0.71396}, "CVE-2024-1897": {"epss_score": 0.01128, "epss_percentile": 0.77829}, "CVE-2024-1898": {"epss_score": 0.00089, "epss_percentile": 0.25963}, "CVE-2024-1899": {"epss_score": 0.00067, "epss_percentile": 0.21137}, "CVE-2024-1900": {"epss_score": 0.0008, "epss_percentile": 0.2413}, "CVE-2024-1901": {"epss_score": 0.00117, "epss_percentile": 0.31322}, "CVE-2024-1902": {"epss_score": 0.00152, "epss_percentile": 0.36468}, "CVE-2024-1904": {"epss_score": 0.0029, "epss_percentile": 0.52097}, "CVE-2024-1905": {"epss_score": 0.00199, "epss_percentile": 0.42142}, "CVE-2024-1906": {"epss_score": 0.00097, "epss_percentile": 0.27505}, "CVE-2024-1907": {"epss_score": 0.00097, "epss_percentile": 0.27505}, "CVE-2024-1908": {"epss_score": 0.0016, "epss_percentile": 0.37423}, "CVE-2024-1909": {"epss_score": 0.00097, "epss_percentile": 0.27505}, "CVE-2024-1910": {"epss_score": 0.00097, "epss_percentile": 0.27505}, "CVE-2024-1912": {"epss_score": 0.00097, "epss_percentile": 0.27505}, "CVE-2024-1913": {"epss_score": 0.00529, "epss_percentile": 0.66582}, "CVE-2024-1914": {"epss_score": 0.00527, "epss_percentile": 0.66533}, "CVE-2024-1915": {"epss_score": 0.00425, "epss_percentile": 0.61715}, "CVE-2024-1916": {"epss_score": 0.00425, "epss_percentile": 0.61715}, "CVE-2024-1917": {"epss_score": 0.00425, "epss_percentile": 0.61715}, "CVE-2024-1918": {"epss_score": 0.00024, "epss_percentile": 0.05724}, "CVE-2024-1919": {"epss_score": 0.00138, "epss_percentile": 0.34401}, "CVE-2024-1920": {"epss_score": 0.0019, "epss_percentile": 0.41061}, "CVE-2024-1921": {"epss_score": 0.00122, "epss_percentile": 0.32129}, "CVE-2024-1922": {"epss_score": 0.00182, "epss_percentile": 0.40198}, "CVE-2024-1923": {"epss_score": 0.00115, "epss_percentile": 0.30894}, "CVE-2024-1924": {"epss_score": 0.00056, "epss_percentile": 0.17912}, "CVE-2024-1925": {"epss_score": 0.00066, "epss_percentile": 0.20852}, "CVE-2024-1926": {"epss_score": 0.00086, "epss_percentile": 0.25295}, "CVE-2024-1927": {"epss_score": 0.00221, "epss_percentile": 0.44649}, "CVE-2024-1928": {"epss_score": 0.0007, "epss_percentile": 0.21753}, "CVE-2024-1929": {"epss_score": 0.00097, "epss_percentile": 0.27466}, "CVE-2024-1930": {"epss_score": 0.00052, "epss_percentile": 0.16375}, "CVE-2024-1931": {"epss_score": 0.06753, "epss_percentile": 0.91004}, "CVE-2024-1932": {"epss_score": 0.00094, "epss_percentile": 0.26761}, "CVE-2024-1933": {"epss_score": 0.00038, "epss_percentile": 0.11229}, "CVE-2024-1934": {"epss_score": 0.00581, "epss_percentile": 0.68269}, "CVE-2024-1935": {"epss_score": 0.02901, "epss_percentile": 0.85954}, "CVE-2024-1936": {"epss_score": 0.00365, "epss_percentile": 0.5796}, "CVE-2024-1937": {"epss_score": 0.00164, "epss_percentile": 0.37871}, "CVE-2024-1938": {"epss_score": 0.00314, "epss_percentile": 0.54142}, "CVE-2024-1939": {"epss_score": 0.29663, "epss_percentile": 0.96465}, "CVE-2024-1940": {"epss_score": 0.00106, "epss_percentile": 0.29414}, "CVE-2024-1941": {"epss_score": 0.00081, "epss_percentile": 0.24234}, "CVE-2024-1942": {"epss_score": 0.00226, "epss_percentile": 0.45246}, "CVE-2024-1943": {"epss_score": 0.00096, "epss_percentile": 0.27374}, "CVE-2024-1945": {"epss_score": 0.00173, "epss_percentile": 0.39109}, "CVE-2024-1946": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-1947": {"epss_score": 0.00264, "epss_percentile": 0.49728}, "CVE-2024-1948": {"epss_score": 0.00214, "epss_percentile": 0.43973}, "CVE-2024-1949": {"epss_score": 0.00266, "epss_percentile": 0.49873}, "CVE-2024-1950": {"epss_score": 0.01298, "epss_percentile": 0.79276}, "CVE-2024-1951": {"epss_score": 0.00877, "epss_percentile": 0.74807}, "CVE-2024-1952": {"epss_score": 0.00263, "epss_percentile": 0.49471}, "CVE-2024-1953": {"epss_score": 0.00132, "epss_percentile": 0.33557}, "CVE-2024-1954": {"epss_score": 0.00095, "epss_percentile": 0.2714}, "CVE-2024-1955": {"epss_score": 0.00135, "epss_percentile": 0.34033}, "CVE-2024-1956": {"epss_score": 0.00627, "epss_percentile": 0.69639}, "CVE-2024-1957": {"epss_score": 0.00165, "epss_percentile": 0.38077}, "CVE-2024-1958": {"epss_score": 0.00969, "epss_percentile": 0.76098}, "CVE-2024-1959": {"epss_score": 0.00188, "epss_percentile": 0.40848}, "CVE-2024-1960": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2024-1961": {"epss_score": 0.04966, "epss_percentile": 0.89344}, "CVE-2024-1962": {"epss_score": 0.00651, "epss_percentile": 0.70297}, "CVE-2024-1963": {"epss_score": 0.00539, "epss_percentile": 0.66968}, "CVE-2024-1965": {"epss_score": 0.00046, "epss_percentile": 0.14173}, "CVE-2024-1968": {"epss_score": 0.0019, "epss_percentile": 0.41103}, "CVE-2024-1969": {"epss_score": 0.00186, "epss_percentile": 0.40587}, "CVE-2024-1970": {"epss_score": 0.00211, "epss_percentile": 0.43676}, "CVE-2024-1971": {"epss_score": 0.00053, "epss_percentile": 0.16993}, "CVE-2024-1972": {"epss_score": 0.00138, "epss_percentile": 0.34401}, "CVE-2024-1973": {"epss_score": 0.00145, "epss_percentile": 0.35497}, "CVE-2024-1974": {"epss_score": 0.02609, "epss_percentile": 0.85232}, "CVE-2024-1975": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-1976": {"epss_score": 0.00063, "epss_percentile": 0.19811}, "CVE-2024-1977": {"epss_score": 0.00402, "epss_percentile": 0.60276}, "CVE-2024-1978": {"epss_score": 0.00074, "epss_percentile": 0.22844}, "CVE-2024-1979": {"epss_score": 0.00069, "epss_percentile": 0.21606}, "CVE-2024-1981": {"epss_score": 0.01784, "epss_percentile": 0.82252}, "CVE-2024-1982": {"epss_score": 0.00169, "epss_percentile": 0.38635}, "CVE-2024-1983": {"epss_score": 0.00155, "epss_percentile": 0.36842}, "CVE-2024-1984": {"epss_score": 0.0026, "epss_percentile": 0.49107}, "CVE-2024-1985": {"epss_score": 0.03287, "epss_percentile": 0.86829}, "CVE-2024-1986": {"epss_score": 0.05759, "epss_percentile": 0.90182}, "CVE-2024-1987": {"epss_score": 0.00148, "epss_percentile": 0.35859}, "CVE-2024-1988": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-1989": {"epss_score": 0.00141, "epss_percentile": 0.34923}, "CVE-2024-1990": {"epss_score": 0.00721, "epss_percentile": 0.71984}, "CVE-2024-1991": {"epss_score": 0.00301, "epss_percentile": 0.53024}, "CVE-2024-1993": {"epss_score": 0.00172, "epss_percentile": 0.38945}, "CVE-2024-1994": {"epss_score": 0.00072, "epss_percentile": 0.22361}, "CVE-2024-1995": {"epss_score": 0.00184, "epss_percentile": 0.4041}, "CVE-2024-1996": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-1997": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-1999": {"epss_score": 0.00249, "epss_percentile": 0.48004}, "CVE-2024-20001": {"epss_score": 0.00033, "epss_percentile": 0.09195}, "CVE-2024-20002": {"epss_score": 0.00032, "epss_percentile": 0.0875}, "CVE-2024-20003": {"epss_score": 0.01403, "epss_percentile": 0.80029}, "CVE-2024-20004": {"epss_score": 0.01468, "epss_percentile": 0.80477}, "CVE-2024-20005": {"epss_score": 3e-05, "epss_percentile": 0.00089}, "CVE-2024-20006": {"epss_score": 0.0005, "epss_percentile": 0.15758}, "CVE-2024-20007": {"epss_score": 0.0161, "epss_percentile": 0.8132}, "CVE-2024-20009": {"epss_score": 0.0394, "epss_percentile": 0.87989}, "CVE-2024-20010": {"epss_score": 0.00017, "epss_percentile": 0.03165}, "CVE-2024-20011": {"epss_score": 0.06148, "epss_percentile": 0.9052}, "CVE-2024-20012": {"epss_score": 0.00016, "epss_percentile": 0.02875}, "CVE-2024-20013": {"epss_score": 0.00032, "epss_percentile": 0.0875}, "CVE-2024-20015": {"epss_score": 0.00011, "epss_percentile": 0.01028}, "CVE-2024-20016": {"epss_score": 0.00016, "epss_percentile": 0.0266}, "CVE-2024-20017": {"epss_score": 0.72779, "epss_percentile": 0.98725}, "CVE-2024-20018": {"epss_score": 0.00739, "epss_percentile": 0.72355}, "CVE-2024-20019": {"epss_score": 0.0108, "epss_percentile": 0.7736}, "CVE-2024-20020": {"epss_score": 0.00018, "epss_percentile": 0.03808}, "CVE-2024-20021": {"epss_score": 0.00031, "epss_percentile": 0.08432}, "CVE-2024-20022": {"epss_score": 0.00025, "epss_percentile": 0.06378}, "CVE-2024-20023": {"epss_score": 0.00016, "epss_percentile": 0.02778}, "CVE-2024-20024": {"epss_score": 0.00017, "epss_percentile": 0.03278}, "CVE-2024-20025": {"epss_score": 0.00016, "epss_percentile": 0.02778}, "CVE-2024-20026": {"epss_score": 0.0001, "epss_percentile": 0.00907}, "CVE-2024-20027": {"epss_score": 0.00013, "epss_percentile": 0.01473}, "CVE-2024-20028": {"epss_score": 0.00059, "epss_percentile": 0.18629}, "CVE-2024-20029": {"epss_score": 0.00017, "epss_percentile": 0.03351}, "CVE-2024-20030": {"epss_score": 0.00011, "epss_percentile": 0.01075}, "CVE-2024-20031": {"epss_score": 0.00016, "epss_percentile": 0.02925}, "CVE-2024-20032": {"epss_score": 4e-05, "epss_percentile": 0.00142}, "CVE-2024-20033": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2024-20034": {"epss_score": 0.00094, "epss_percentile": 0.27013}, "CVE-2024-20036": {"epss_score": 3e-05, "epss_percentile": 0.00115}, "CVE-2024-20037": {"epss_score": 0.00038, "epss_percentile": 0.11135}, "CVE-2024-20038": {"epss_score": 0.00027, "epss_percentile": 0.06762}, "CVE-2024-20039": {"epss_score": 0.05435, "epss_percentile": 0.89881}, "CVE-2024-20040": {"epss_score": 0.00926, "epss_percentile": 0.75547}, "CVE-2024-20041": {"epss_score": 0.00049, "epss_percentile": 0.15622}, "CVE-2024-20042": {"epss_score": 0.00041, "epss_percentile": 0.1239}, "CVE-2024-20043": {"epss_score": 0.00041, "epss_percentile": 0.1239}, "CVE-2024-20044": {"epss_score": 0.00041, "epss_percentile": 0.1239}, "CVE-2024-20045": {"epss_score": 0.00012, "epss_percentile": 0.01283}, "CVE-2024-20046": {"epss_score": 0.00105, "epss_percentile": 0.29292}, "CVE-2024-20047": {"epss_score": 0.00138, "epss_percentile": 0.34344}, "CVE-2024-20048": {"epss_score": 0.00024, "epss_percentile": 0.05885}, "CVE-2024-20049": {"epss_score": 0.00013, "epss_percentile": 0.01447}, "CVE-2024-20050": {"epss_score": 0.00013, "epss_percentile": 0.01447}, "CVE-2024-20051": {"epss_score": 0.00013, "epss_percentile": 0.01656}, "CVE-2024-20052": {"epss_score": 0.00011, "epss_percentile": 0.00989}, "CVE-2024-20053": {"epss_score": 0.00022, "epss_percentile": 0.0499}, "CVE-2024-20054": {"epss_score": 0.00066, "epss_percentile": 0.20901}, "CVE-2024-20055": {"epss_score": 0.00021, "epss_percentile": 0.049}, "CVE-2024-20056": {"epss_score": 0.0001, "epss_percentile": 0.00895}, "CVE-2024-20057": {"epss_score": 0.00038, "epss_percentile": 0.11208}, "CVE-2024-20058": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2024-20059": {"epss_score": 0.00011, "epss_percentile": 0.01008}, "CVE-2024-20060": {"epss_score": 0.00017, "epss_percentile": 0.03215}, "CVE-2024-20064": {"epss_score": 0.00017, "epss_percentile": 0.03106}, "CVE-2024-20065": {"epss_score": 0.00047, "epss_percentile": 0.14891}, "CVE-2024-20066": {"epss_score": 0.03098, "epss_percentile": 0.86406}, "CVE-2024-20067": {"epss_score": 0.03495, "epss_percentile": 0.87236}, "CVE-2024-20068": {"epss_score": 0.02305, "epss_percentile": 0.84322}, "CVE-2024-20069": {"epss_score": 0.01014, "epss_percentile": 0.76646}, "CVE-2024-20070": {"epss_score": 0.00461, "epss_percentile": 0.6354}, "CVE-2024-20071": {"epss_score": 0.00059, "epss_percentile": 0.18653}, "CVE-2024-20072": {"epss_score": 0.00221, "epss_percentile": 0.44708}, "CVE-2024-20073": {"epss_score": 0.00221, "epss_percentile": 0.44708}, "CVE-2024-20074": {"epss_score": 0.00127, "epss_percentile": 0.32883}, "CVE-2024-20075": {"epss_score": 0.00037, "epss_percentile": 0.10999}, "CVE-2024-20076": {"epss_score": 0.02697, "epss_percentile": 0.85446}, "CVE-2024-20077": {"epss_score": 0.02697, "epss_percentile": 0.85446}, "CVE-2024-20078": {"epss_score": 0.00213, "epss_percentile": 0.43939}, "CVE-2024-20079": {"epss_score": 0.00035, "epss_percentile": 0.10039}, "CVE-2024-20080": {"epss_score": 0.0236, "epss_percentile": 0.84495}, "CVE-2024-20081": {"epss_score": 0.00056, "epss_percentile": 0.17956}, "CVE-2024-20082": {"epss_score": 0.12001, "epss_percentile": 0.93543}, "CVE-2024-20083": {"epss_score": 0.00257, "epss_percentile": 0.4885}, "CVE-2024-20084": {"epss_score": 0.00033, "epss_percentile": 0.0919}, "CVE-2024-20085": {"epss_score": 0.00033, "epss_percentile": 0.0919}, "CVE-2024-20086": {"epss_score": 0.00017, "epss_percentile": 0.03375}, "CVE-2024-20087": {"epss_score": 0.00017, "epss_percentile": 0.03375}, "CVE-2024-20088": {"epss_score": 0.00032, "epss_percentile": 0.08739}, "CVE-2024-20089": {"epss_score": 0.02291, "epss_percentile": 0.84283}, "CVE-2024-20090": {"epss_score": 0.00037, "epss_percentile": 0.10999}, "CVE-2024-20091": {"epss_score": 0.00033, "epss_percentile": 0.0919}, "CVE-2024-20092": {"epss_score": 0.00056, "epss_percentile": 0.17758}, "CVE-2024-20093": {"epss_score": 0.00026, "epss_percentile": 0.06566}, "CVE-2024-20094": {"epss_score": 0.06414, "epss_percentile": 0.90744}, "CVE-2024-20095": {"epss_score": 0.00026, "epss_percentile": 0.06566}, "CVE-2024-20096": {"epss_score": 0.00026, "epss_percentile": 0.06566}, "CVE-2024-20097": {"epss_score": 0.00026, "epss_percentile": 0.06566}, "CVE-2024-20098": {"epss_score": 0.00037, "epss_percentile": 0.10999}, "CVE-2024-20099": {"epss_score": 0.00037, "epss_percentile": 0.10999}, "CVE-2024-20100": {"epss_score": 0.01788, "epss_percentile": 0.82264}, "CVE-2024-20101": {"epss_score": 0.01788, "epss_percentile": 0.82264}, "CVE-2024-20102": {"epss_score": 0.00339, "epss_percentile": 0.56176}, "CVE-2024-20103": {"epss_score": 0.03419, "epss_percentile": 0.87099}, "CVE-2024-20104": {"epss_score": 0.00048, "epss_percentile": 0.15071}, "CVE-2024-20105": {"epss_score": 0.00049, "epss_percentile": 0.15628}, "CVE-2024-20106": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2024-20107": {"epss_score": 0.00049, "epss_percentile": 0.15358}, "CVE-2024-20108": {"epss_score": 0.00028, "epss_percentile": 0.07263}, "CVE-2024-20109": {"epss_score": 0.0002, "epss_percentile": 0.04438}, "CVE-2024-20110": {"epss_score": 0.0002, "epss_percentile": 0.04438}, "CVE-2024-20111": {"epss_score": 0.00019, "epss_percentile": 0.04176}, "CVE-2024-20112": {"epss_score": 0.00024, "epss_percentile": 0.05801}, "CVE-2024-20113": {"epss_score": 0.0002, "epss_percentile": 0.04438}, "CVE-2024-20114": {"epss_score": 0.0002, "epss_percentile": 0.04438}, "CVE-2024-20115": {"epss_score": 0.00019, "epss_percentile": 0.04176}, "CVE-2024-20116": {"epss_score": 0.0004, "epss_percentile": 0.11868}, "CVE-2024-20117": {"epss_score": 0.00025, "epss_percentile": 0.06097}, "CVE-2024-20118": {"epss_score": 0.0002, "epss_percentile": 0.04438}, "CVE-2024-20119": {"epss_score": 0.00019, "epss_percentile": 0.04176}, "CVE-2024-20120": {"epss_score": 0.00019, "epss_percentile": 0.04176}, "CVE-2024-20121": {"epss_score": 0.0002, "epss_percentile": 0.04438}, "CVE-2024-20122": {"epss_score": 0.00035, "epss_percentile": 0.09807}, "CVE-2024-20123": {"epss_score": 0.00035, "epss_percentile": 0.09807}, "CVE-2024-20124": {"epss_score": 0.00035, "epss_percentile": 0.09807}, "CVE-2024-20125": {"epss_score": 0.0001, "epss_percentile": 0.00879}, "CVE-2024-20127": {"epss_score": 0.00223, "epss_percentile": 0.44892}, "CVE-2024-20128": {"epss_score": 0.00223, "epss_percentile": 0.44892}, "CVE-2024-20129": {"epss_score": 0.00223, "epss_percentile": 0.44892}, "CVE-2024-20130": {"epss_score": 0.00011, "epss_percentile": 0.00949}, "CVE-2024-20131": {"epss_score": 0.00051, "epss_percentile": 0.16035}, "CVE-2024-20132": {"epss_score": 0.00046, "epss_percentile": 0.14302}, "CVE-2024-20133": {"epss_score": 0.00051, "epss_percentile": 0.16035}, "CVE-2024-20134": {"epss_score": 0.0001, "epss_percentile": 0.00906}, "CVE-2024-20135": {"epss_score": 0.0001, "epss_percentile": 0.00855}, "CVE-2024-20136": {"epss_score": 0.00042, "epss_percentile": 0.12614}, "CVE-2024-20137": {"epss_score": 0.0479, "epss_percentile": 0.89149}, "CVE-2024-20138": {"epss_score": 0.00143, "epss_percentile": 0.35207}, "CVE-2024-20139": {"epss_score": 0.00024, "epss_percentile": 0.05978}, "CVE-2024-20140": {"epss_score": 0.0001, "epss_percentile": 0.00829}, "CVE-2024-20141": {"epss_score": 0.00016, "epss_percentile": 0.02728}, "CVE-2024-20142": {"epss_score": 0.00016, "epss_percentile": 0.02728}, "CVE-2024-20143": {"epss_score": 0.00016, "epss_percentile": 0.02728}, "CVE-2024-20144": {"epss_score": 0.00016, "epss_percentile": 0.02728}, "CVE-2024-20145": {"epss_score": 0.00016, "epss_percentile": 0.02728}, "CVE-2024-20146": {"epss_score": 0.00021, "epss_percentile": 0.04809}, "CVE-2024-20147": {"epss_score": 0.00054, "epss_percentile": 0.17042}, "CVE-2024-20148": {"epss_score": 0.00107, "epss_percentile": 0.29725}, "CVE-2024-20149": {"epss_score": 0.01026, "epss_percentile": 0.76801}, "CVE-2024-20150": {"epss_score": 0.02011, "epss_percentile": 0.8325}, "CVE-2024-20151": {"epss_score": 0.00044, "epss_percentile": 0.13479}, "CVE-2024-20152": {"epss_score": 4e-05, "epss_percentile": 0.00166}, "CVE-2024-20153": {"epss_score": 0.00355, "epss_percentile": 0.57269}, "CVE-2024-20154": {"epss_score": 0.01861, "epss_percentile": 0.8259}, "CVE-2024-20251": {"epss_score": 0.00072, "epss_percentile": 0.22321}, "CVE-2024-20252": {"epss_score": 0.07358, "epss_percentile": 0.9143}, "CVE-2024-20253": {"epss_score": 0.02929, "epss_percentile": 0.86013}, "CVE-2024-20254": {"epss_score": 0.0516, "epss_percentile": 0.89556}, "CVE-2024-20255": {"epss_score": 0.00759, "epss_percentile": 0.72793}, "CVE-2024-20256": {"epss_score": 0.00125, "epss_percentile": 0.3248}, "CVE-2024-20257": {"epss_score": 0.00125, "epss_percentile": 0.3248}, "CVE-2024-20258": {"epss_score": 0.00176, "epss_percentile": 0.39474}, "CVE-2024-20259": {"epss_score": 0.00502, "epss_percentile": 0.6542}, "CVE-2024-20260": {"epss_score": 0.00369, "epss_percentile": 0.58243}, "CVE-2024-20261": {"epss_score": 0.00192, "epss_percentile": 0.4128}, "CVE-2024-20262": {"epss_score": 0.00029, "epss_percentile": 0.07784}, "CVE-2024-20263": {"epss_score": 0.00019, "epss_percentile": 0.04178}, "CVE-2024-20264": {"epss_score": 0.00077, "epss_percentile": 0.233}, "CVE-2024-20265": {"epss_score": 0.00016, "epss_percentile": 0.02657}, "CVE-2024-20266": {"epss_score": 0.00094, "epss_percentile": 0.26762}, "CVE-2024-20267": {"epss_score": 0.00689, "epss_percentile": 0.7122}, "CVE-2024-20268": {"epss_score": 0.01093, "epss_percentile": 0.77478}, "CVE-2024-20269": {"epss_score": 0.00079, "epss_percentile": 0.23919}, "CVE-2024-20270": {"epss_score": 0.00072, "epss_percentile": 0.22321}, "CVE-2024-20271": {"epss_score": 0.00416, "epss_percentile": 0.61188}, "CVE-2024-20272": {"epss_score": 0.00356, "epss_percentile": 0.57337}, "CVE-2024-20273": {"epss_score": 0.00297, "epss_percentile": 0.52705}, "CVE-2024-20274": {"epss_score": 0.0018, "epss_percentile": 0.39917}, "CVE-2024-20275": {"epss_score": 0.00137, "epss_percentile": 0.34324}, "CVE-2024-20276": {"epss_score": 0.00136, "epss_percentile": 0.34153}, "CVE-2024-20277": {"epss_score": 0.00175, "epss_percentile": 0.39373}, "CVE-2024-20278": {"epss_score": 0.00128, "epss_percentile": 0.32996}, "CVE-2024-20279": {"epss_score": 0.00271, "epss_percentile": 0.50304}, "CVE-2024-20280": {"epss_score": 0.00076, "epss_percentile": 0.23274}, "CVE-2024-20281": {"epss_score": 0.01524, "epss_percentile": 0.80849}, "CVE-2024-20282": {"epss_score": 0.00052, "epss_percentile": 0.16464}, "CVE-2024-20283": {"epss_score": 0.00224, "epss_percentile": 0.45024}, "CVE-2024-20284": {"epss_score": 0.00083, "epss_percentile": 0.24761}, "CVE-2024-20285": {"epss_score": 0.00075, "epss_percentile": 0.23072}, "CVE-2024-20286": {"epss_score": 0.00075, "epss_percentile": 0.23072}, "CVE-2024-20287": {"epss_score": 0.00078, "epss_percentile": 0.23786}, "CVE-2024-20289": {"epss_score": 0.0007, "epss_percentile": 0.21809}, "CVE-2024-20290": {"epss_score": 0.10345, "epss_percentile": 0.9295}, "CVE-2024-20291": {"epss_score": 0.12176, "epss_percentile": 0.93592}, "CVE-2024-20292": {"epss_score": 0.00018, "epss_percentile": 0.03614}, "CVE-2024-20293": {"epss_score": 0.00089, "epss_percentile": 0.2595}, "CVE-2024-20294": {"epss_score": 0.00056, "epss_percentile": 0.17685}, "CVE-2024-20295": {"epss_score": 0.00451, "epss_percentile": 0.63149}, "CVE-2024-20296": {"epss_score": 0.00155, "epss_percentile": 0.3683}, "CVE-2024-20297": {"epss_score": 0.00336, "epss_percentile": 0.55954}, "CVE-2024-20298": {"epss_score": 0.00077, "epss_percentile": 0.233}, "CVE-2024-20299": {"epss_score": 0.00336, "epss_percentile": 0.55954}, "CVE-2024-20300": {"epss_score": 0.00079, "epss_percentile": 0.23919}, "CVE-2024-20301": {"epss_score": 0.00011, "epss_percentile": 0.01056}, "CVE-2024-20302": {"epss_score": 0.00121, "epss_percentile": 0.31957}, "CVE-2024-20303": {"epss_score": 0.00077, "epss_percentile": 0.2345}, "CVE-2024-20304": {"epss_score": 0.00724, "epss_percentile": 0.72041}, "CVE-2024-20305": {"epss_score": 0.00078, "epss_percentile": 0.23576}, "CVE-2024-20306": {"epss_score": 0.00024, "epss_percentile": 0.0598}, "CVE-2024-20307": {"epss_score": 0.01495, "epss_percentile": 0.80679}, "CVE-2024-20308": {"epss_score": 0.00905, "epss_percentile": 0.75231}, "CVE-2024-20309": {"epss_score": 0.00036, "epss_percentile": 0.10496}, "CVE-2024-20310": {"epss_score": 0.00162, "epss_percentile": 0.37753}, "CVE-2024-20311": {"epss_score": 0.01065, "epss_percentile": 0.77213}, "CVE-2024-20312": {"epss_score": 0.00045, "epss_percentile": 0.13759}, "CVE-2024-20313": {"epss_score": 0.00059, "epss_percentile": 0.18918}, "CVE-2024-20314": {"epss_score": 0.01065, "epss_percentile": 0.77213}, "CVE-2024-20315": {"epss_score": 0.00047, "epss_percentile": 0.1487}, "CVE-2024-20316": {"epss_score": 0.00263, "epss_percentile": 0.49514}, "CVE-2024-20317": {"epss_score": 0.00195, "epss_percentile": 0.41629}, "CVE-2024-20318": {"epss_score": 0.0004, "epss_percentile": 0.11926}, "CVE-2024-20319": {"epss_score": 0.00019, "epss_percentile": 0.0416}, "CVE-2024-20320": {"epss_score": 0.00065, "epss_percentile": 0.20524}, "CVE-2024-20321": {"epss_score": 0.00599, "epss_percentile": 0.68786}, "CVE-2024-20322": {"epss_score": 0.00127, "epss_percentile": 0.32847}, "CVE-2024-20323": {"epss_score": 0.00503, "epss_percentile": 0.6546}, "CVE-2024-20324": {"epss_score": 0.00073, "epss_percentile": 0.22485}, "CVE-2024-20325": {"epss_score": 0.00072, "epss_percentile": 0.22301}, "CVE-2024-20326": {"epss_score": 0.00429, "epss_percentile": 0.61983}, "CVE-2024-20327": {"epss_score": 0.00059, "epss_percentile": 0.18911}, "CVE-2024-20328": {"epss_score": 0.00256, "epss_percentile": 0.48773}, "CVE-2024-20329": {"epss_score": 0.02025, "epss_percentile": 0.83315}, "CVE-2024-20330": {"epss_score": 0.00193, "epss_percentile": 0.4149}, "CVE-2024-20331": {"epss_score": 0.00951, "epss_percentile": 0.75867}, "CVE-2024-20332": {"epss_score": 0.00074, "epss_percentile": 0.22771}, "CVE-2024-20333": {"epss_score": 0.00165, "epss_percentile": 0.38137}, "CVE-2024-20334": {"epss_score": 0.00048, "epss_percentile": 0.15237}, "CVE-2024-20335": {"epss_score": 0.00135, "epss_percentile": 0.34024}, "CVE-2024-20336": {"epss_score": 0.00133, "epss_percentile": 0.33705}, "CVE-2024-20337": {"epss_score": 0.04953, "epss_percentile": 0.89326}, "CVE-2024-20338": {"epss_score": 0.00114, "epss_percentile": 0.3082}, "CVE-2024-20339": {"epss_score": 0.01248, "epss_percentile": 0.78864}, "CVE-2024-20340": {"epss_score": 0.00158, "epss_percentile": 0.37187}, "CVE-2024-20341": {"epss_score": 0.00229, "epss_percentile": 0.45635}, "CVE-2024-20342": {"epss_score": 0.00037, "epss_percentile": 0.1098}, "CVE-2024-20343": {"epss_score": 0.00085, "epss_percentile": 0.25126}, "CVE-2024-20344": {"epss_score": 0.00307, "epss_percentile": 0.5347}, "CVE-2024-20345": {"epss_score": 0.00312, "epss_percentile": 0.53942}, "CVE-2024-20346": {"epss_score": 0.00104, "epss_percentile": 0.29195}, "CVE-2024-20347": {"epss_score": 0.00164, "epss_percentile": 0.37953}, "CVE-2024-20348": {"epss_score": 0.00645, "epss_percentile": 0.70102}, "CVE-2024-20350": {"epss_score": 0.02389, "epss_percentile": 0.84592}, "CVE-2024-20351": {"epss_score": 0.00833, "epss_percentile": 0.74091}, "CVE-2024-20352": {"epss_score": 0.00268, "epss_percentile": 0.5004}, "CVE-2024-20353": {"epss_score": 0.19536, "epss_percentile": 0.95202}, "CVE-2024-20354": {"epss_score": 0.0004, "epss_percentile": 0.12103}, "CVE-2024-20355": {"epss_score": 0.00726, "epss_percentile": 0.72078}, "CVE-2024-20356": {"epss_score": 0.33574, "epss_percentile": 0.96784}, "CVE-2024-20357": {"epss_score": 0.00737, "epss_percentile": 0.7232}, "CVE-2024-20358": {"epss_score": 0.00026, "epss_percentile": 0.06427}, "CVE-2024-20359": {"epss_score": 0.00179, "epss_percentile": 0.39818}, "CVE-2024-20360": {"epss_score": 0.03292, "epss_percentile": 0.86838}, "CVE-2024-20361": {"epss_score": 0.00145, "epss_percentile": 0.35459}, "CVE-2024-20362": {"epss_score": 0.00249, "epss_percentile": 0.48068}, "CVE-2024-20363": {"epss_score": 0.00143, "epss_percentile": 0.35167}, "CVE-2024-20364": {"epss_score": 0.00042, "epss_percentile": 0.1275}, "CVE-2024-20365": {"epss_score": 0.00174, "epss_percentile": 0.39162}, "CVE-2024-20366": {"epss_score": 0.0015, "epss_percentile": 0.36149}, "CVE-2024-20367": {"epss_score": 0.0016, "epss_percentile": 0.3745}, "CVE-2024-20368": {"epss_score": 0.00177, "epss_percentile": 0.39514}, "CVE-2024-20369": {"epss_score": 0.00221, "epss_percentile": 0.44678}, "CVE-2024-20370": {"epss_score": 0.00016, "epss_percentile": 0.02806}, "CVE-2024-20371": {"epss_score": 0.00225, "epss_percentile": 0.45083}, "CVE-2024-20372": {"epss_score": 0.00125, "epss_percentile": 0.32534}, "CVE-2024-20373": {"epss_score": 0.00622, "epss_percentile": 0.69508}, "CVE-2024-20374": {"epss_score": 0.00071, "epss_percentile": 0.22116}, "CVE-2024-20375": {"epss_score": 0.00964, "epss_percentile": 0.76029}, "CVE-2024-20376": {"epss_score": 0.00471, "epss_percentile": 0.64007}, "CVE-2024-20377": {"epss_score": 0.00136, "epss_percentile": 0.34156}, "CVE-2024-20378": {"epss_score": 0.00797, "epss_percentile": 0.73496}, "CVE-2024-20379": {"epss_score": 0.00287, "epss_percentile": 0.51832}, "CVE-2024-20380": {"epss_score": 0.005, "epss_percentile": 0.65298}, "CVE-2024-20381": {"epss_score": 0.01623, "epss_percentile": 0.81403}, "CVE-2024-20382": {"epss_score": 0.00113, "epss_percentile": 0.30703}, "CVE-2024-20383": {"epss_score": 0.00095, "epss_percentile": 0.27196}, "CVE-2024-20384": {"epss_score": 0.00127, "epss_percentile": 0.32882}, "CVE-2024-20385": {"epss_score": 0.00156, "epss_percentile": 0.36971}, "CVE-2024-20386": {"epss_score": 0.00062, "epss_percentile": 0.19677}, "CVE-2024-20387": {"epss_score": 0.00252, "epss_percentile": 0.48336}, "CVE-2024-20388": {"epss_score": 0.00542, "epss_percentile": 0.67087}, "CVE-2024-20389": {"epss_score": 0.0014, "epss_percentile": 0.34774}, "CVE-2024-20390": {"epss_score": 0.00217, "epss_percentile": 0.44246}, "CVE-2024-20391": {"epss_score": 0.00272, "epss_percentile": 0.50352}, "CVE-2024-20392": {"epss_score": 0.00308, "epss_percentile": 0.53633}, "CVE-2024-20393": {"epss_score": 0.01316, "epss_percentile": 0.7941}, "CVE-2024-20394": {"epss_score": 0.00186, "epss_percentile": 0.40601}, "CVE-2024-20395": {"epss_score": 0.00206, "epss_percentile": 0.42941}, "CVE-2024-20396": {"epss_score": 0.00887, "epss_percentile": 0.74991}, "CVE-2024-20397": {"epss_score": 0.00078, "epss_percentile": 0.23618}, "CVE-2024-20398": {"epss_score": 0.00294, "epss_percentile": 0.52414}, "CVE-2024-20399": {"epss_score": 0.00782, "epss_percentile": 0.73207}, "CVE-2024-20400": {"epss_score": 0.00887, "epss_percentile": 0.74971}, "CVE-2024-20401": {"epss_score": 0.11827, "epss_percentile": 0.93488}, "CVE-2024-20402": {"epss_score": 0.00842, "epss_percentile": 0.74244}, "CVE-2024-20403": {"epss_score": 0.0008, "epss_percentile": 0.2413}, "CVE-2024-20404": {"epss_score": 0.83806, "epss_percentile": 0.99262}, "CVE-2024-20405": {"epss_score": 0.0086, "epss_percentile": 0.74528}, "CVE-2024-20406": {"epss_score": 0.0014, "epss_percentile": 0.34725}, "CVE-2024-20407": {"epss_score": 0.00198, "epss_percentile": 0.42012}, "CVE-2024-20408": {"epss_score": 0.00392, "epss_percentile": 0.59676}, "CVE-2024-20409": {"epss_score": 0.00118, "epss_percentile": 0.31478}, "CVE-2024-20410": {"epss_score": 0.0024, "epss_percentile": 0.46963}, "CVE-2024-20411": {"epss_score": 0.00038, "epss_percentile": 0.11181}, "CVE-2024-20412": {"epss_score": 0.0012, "epss_percentile": 0.31708}, "CVE-2024-20413": {"epss_score": 0.00038, "epss_percentile": 0.11323}, "CVE-2024-20414": {"epss_score": 0.00322, "epss_percentile": 0.54792}, "CVE-2024-20415": {"epss_score": 0.00114, "epss_percentile": 0.30861}, "CVE-2024-20416": {"epss_score": 0.00562, "epss_percentile": 0.67706}, "CVE-2024-20417": {"epss_score": 0.0015, "epss_percentile": 0.36182}, "CVE-2024-20418": {"epss_score": 0.03006, "epss_percentile": 0.86183}, "CVE-2024-20419": {"epss_score": 0.91421, "epss_percentile": 0.99642}, "CVE-2024-20420": {"epss_score": 0.00245, "epss_percentile": 0.47726}, "CVE-2024-20421": {"epss_score": 0.00274, "epss_percentile": 0.50483}, "CVE-2024-20424": {"epss_score": 0.01175, "epss_percentile": 0.78261}, "CVE-2024-20426": {"epss_score": 0.00571, "epss_percentile": 0.67972}, "CVE-2024-20429": {"epss_score": 0.00077, "epss_percentile": 0.2344}, "CVE-2024-20430": {"epss_score": 0.00089, "epss_percentile": 0.25948}, "CVE-2024-20431": {"epss_score": 0.00146, "epss_percentile": 0.35533}, "CVE-2024-20432": {"epss_score": 0.04694, "epss_percentile": 0.89016}, "CVE-2024-20433": {"epss_score": 0.00892, "epss_percentile": 0.75067}, "CVE-2024-20434": {"epss_score": 0.00082, "epss_percentile": 0.24397}, "CVE-2024-20435": {"epss_score": 0.00134, "epss_percentile": 0.33829}, "CVE-2024-20436": {"epss_score": 0.02311, "epss_percentile": 0.84337}, "CVE-2024-20437": {"epss_score": 0.0186, "epss_percentile": 0.82586}, "CVE-2024-20438": {"epss_score": 0.00106, "epss_percentile": 0.29401}, "CVE-2024-20439": {"epss_score": 0.84281, "epss_percentile": 0.99281}, "CVE-2024-20440": {"epss_score": 0.74277, "epss_percentile": 0.98794}, "CVE-2024-20441": {"epss_score": 0.00197, "epss_percentile": 0.4196}, "CVE-2024-20442": {"epss_score": 0.00242, "epss_percentile": 0.474}, "CVE-2024-20443": {"epss_score": 0.00192, "epss_percentile": 0.41365}, "CVE-2024-20444": {"epss_score": 0.00403, "epss_percentile": 0.60386}, "CVE-2024-20445": {"epss_score": 0.00661, "epss_percentile": 0.70581}, "CVE-2024-20446": {"epss_score": 0.00405, "epss_percentile": 0.60478}, "CVE-2024-20448": {"epss_score": 0.00136, "epss_percentile": 0.34093}, "CVE-2024-20449": {"epss_score": 0.09459, "epss_percentile": 0.92557}, "CVE-2024-20450": {"epss_score": 0.21544, "epss_percentile": 0.95531}, "CVE-2024-20451": {"epss_score": 0.01681, "epss_percentile": 0.81729}, "CVE-2024-20454": {"epss_score": 0.21544, "epss_percentile": 0.95531}, "CVE-2024-20455": {"epss_score": 0.00699, "epss_percentile": 0.71445}, "CVE-2024-20456": {"epss_score": 9e-05, "epss_percentile": 0.00697}, "CVE-2024-20457": {"epss_score": 0.00423, "epss_percentile": 0.61614}, "CVE-2024-20458": {"epss_score": 0.00669, "epss_percentile": 0.70768}, "CVE-2024-20459": {"epss_score": 0.00172, "epss_percentile": 0.38995}, "CVE-2024-20460": {"epss_score": 0.00146, "epss_percentile": 0.35568}, "CVE-2024-20461": {"epss_score": 0.00085, "epss_percentile": 0.25056}, "CVE-2024-20462": {"epss_score": 0.00091, "epss_percentile": 0.26384}, "CVE-2024-20463": {"epss_score": 0.00739, "epss_percentile": 0.72351}, "CVE-2024-20464": {"epss_score": 0.00465, "epss_percentile": 0.63753}, "CVE-2024-20465": {"epss_score": 0.00243, "epss_percentile": 0.47496}, "CVE-2024-20466": {"epss_score": 0.00141, "epss_percentile": 0.34897}, "CVE-2024-20467": {"epss_score": 0.21241, "epss_percentile": 0.95483}, "CVE-2024-20469": {"epss_score": 0.00098, "epss_percentile": 0.27791}, "CVE-2024-20470": {"epss_score": 0.00501, "epss_percentile": 0.65335}, "CVE-2024-20471": {"epss_score": 0.00276, "epss_percentile": 0.50757}, "CVE-2024-20472": {"epss_score": 0.00237, "epss_percentile": 0.46667}, "CVE-2024-20473": {"epss_score": 0.00245, "epss_percentile": 0.47669}, "CVE-2024-20474": {"epss_score": 0.00605, "epss_percentile": 0.68988}, "CVE-2024-20475": {"epss_score": 0.00252, "epss_percentile": 0.48336}, "CVE-2024-20476": {"epss_score": 0.00047, "epss_percentile": 0.14793}, "CVE-2024-20477": {"epss_score": 0.00458, "epss_percentile": 0.63433}, "CVE-2024-20478": {"epss_score": 0.0022, "epss_percentile": 0.44583}, "CVE-2024-20479": {"epss_score": 0.00125, "epss_percentile": 0.3248}, "CVE-2024-20480": {"epss_score": 0.00434, "epss_percentile": 0.6229}, "CVE-2024-20481": {"epss_score": 0.11122, "epss_percentile": 0.93229}, "CVE-2024-20482": {"epss_score": 0.00276, "epss_percentile": 0.50723}, "CVE-2024-20483": {"epss_score": 0.00707, "epss_percentile": 0.71642}, "CVE-2024-20484": {"epss_score": 0.00913, "epss_percentile": 0.75374}, "CVE-2024-20485": {"epss_score": 0.00031, "epss_percentile": 0.08668}, "CVE-2024-20486": {"epss_score": 0.00326, "epss_percentile": 0.55068}, "CVE-2024-20487": {"epss_score": 0.00187, "epss_percentile": 0.40732}, "CVE-2024-20488": {"epss_score": 0.00422, "epss_percentile": 0.6157}, "CVE-2024-20489": {"epss_score": 0.00096, "epss_percentile": 0.27264}, "CVE-2024-20490": {"epss_score": 0.00323, "epss_percentile": 0.54911}, "CVE-2024-20491": {"epss_score": 0.00323, "epss_percentile": 0.54911}, "CVE-2024-20492": {"epss_score": 0.0016, "epss_percentile": 0.37482}, "CVE-2024-20493": {"epss_score": 0.0012, "epss_percentile": 0.31755}, "CVE-2024-20494": {"epss_score": 0.00441, "epss_percentile": 0.62692}, "CVE-2024-20495": {"epss_score": 0.00332, "epss_percentile": 0.55576}, "CVE-2024-20496": {"epss_score": 0.00056, "epss_percentile": 0.17885}, "CVE-2024-20497": {"epss_score": 0.002, "epss_percentile": 0.42266}, "CVE-2024-20498": {"epss_score": 0.00466, "epss_percentile": 0.63793}, "CVE-2024-20499": {"epss_score": 0.00466, "epss_percentile": 0.63793}, "CVE-2024-20500": {"epss_score": 0.00363, "epss_percentile": 0.57833}, "CVE-2024-20501": {"epss_score": 0.00466, "epss_percentile": 0.63793}, "CVE-2024-20502": {"epss_score": 0.00348, "epss_percentile": 0.56832}, "CVE-2024-20503": {"epss_score": 0.00053, "epss_percentile": 0.16911}, "CVE-2024-20504": {"epss_score": 0.00142, "epss_percentile": 0.34961}, "CVE-2024-20505": {"epss_score": 0.00686, "epss_percentile": 0.71157}, "CVE-2024-20506": {"epss_score": 0.00036, "epss_percentile": 0.10609}, "CVE-2024-20507": {"epss_score": 0.00314, "epss_percentile": 0.5416}, "CVE-2024-20508": {"epss_score": 0.00026, "epss_percentile": 0.06532}, "CVE-2024-20509": {"epss_score": 0.00261, "epss_percentile": 0.49267}, "CVE-2024-20510": {"epss_score": 0.00035, "epss_percentile": 0.09917}, "CVE-2024-20511": {"epss_score": 0.00329, "epss_percentile": 0.55407}, "CVE-2024-20512": {"epss_score": 0.00384, "epss_percentile": 0.5914}, "CVE-2024-20513": {"epss_score": 0.00298, "epss_percentile": 0.5282}, "CVE-2024-20514": {"epss_score": 0.00216, "epss_percentile": 0.44206}, "CVE-2024-20515": {"epss_score": 0.00146, "epss_percentile": 0.35558}, "CVE-2024-20516": {"epss_score": 0.00283, "epss_percentile": 0.51398}, "CVE-2024-20517": {"epss_score": 0.00283, "epss_percentile": 0.51398}, "CVE-2024-20518": {"epss_score": 0.00249, "epss_percentile": 0.48056}, "CVE-2024-20519": {"epss_score": 0.00249, "epss_percentile": 0.48056}, "CVE-2024-20520": {"epss_score": 0.00249, "epss_percentile": 0.48056}, "CVE-2024-20521": {"epss_score": 0.00249, "epss_percentile": 0.48056}, "CVE-2024-20522": {"epss_score": 0.00088, "epss_percentile": 0.25771}, "CVE-2024-20523": {"epss_score": 0.00283, "epss_percentile": 0.51398}, "CVE-2024-20524": {"epss_score": 0.00283, "epss_percentile": 0.51398}, "CVE-2024-20525": {"epss_score": 0.00303, "epss_percentile": 0.53173}, "CVE-2024-20526": {"epss_score": 0.00621, "epss_percentile": 0.69492}, "CVE-2024-20527": {"epss_score": 0.00347, "epss_percentile": 0.56763}, "CVE-2024-20528": {"epss_score": 0.01265, "epss_percentile": 0.79006}, "CVE-2024-20529": {"epss_score": 0.00347, "epss_percentile": 0.56763}, "CVE-2024-20530": {"epss_score": 0.00303, "epss_percentile": 0.53173}, "CVE-2024-20531": {"epss_score": 0.00279, "epss_percentile": 0.50971}, "CVE-2024-20532": {"epss_score": 0.00347, "epss_percentile": 0.56763}, "CVE-2024-20533": {"epss_score": 0.00129, "epss_percentile": 0.33122}, "CVE-2024-20534": {"epss_score": 0.00129, "epss_percentile": 0.33122}, "CVE-2024-20536": {"epss_score": 0.01864, "epss_percentile": 0.826}, "CVE-2024-20537": {"epss_score": 0.00084, "epss_percentile": 0.24877}, "CVE-2024-20538": {"epss_score": 0.00223, "epss_percentile": 0.44856}, "CVE-2024-20539": {"epss_score": 0.0012, "epss_percentile": 0.3174}, "CVE-2024-20540": {"epss_score": 0.00283, "epss_percentile": 0.51355}, "CVE-2024-20652": {"epss_score": 0.03082, "epss_percentile": 0.86375}, "CVE-2024-20653": {"epss_score": 0.0292, "epss_percentile": 0.8599}, "CVE-2024-20654": {"epss_score": 0.02145, "epss_percentile": 0.83763}, "CVE-2024-20655": {"epss_score": 0.00416, "epss_percentile": 0.61193}, "CVE-2024-20656": {"epss_score": 0.57016, "epss_percentile": 0.98045}, "CVE-2024-20657": {"epss_score": 0.00269, "epss_percentile": 0.50175}, "CVE-2024-20658": {"epss_score": 0.00251, "epss_percentile": 0.48328}, "CVE-2024-20659": {"epss_score": 0.00757, "epss_percentile": 0.72748}, "CVE-2024-20660": {"epss_score": 0.03672, "epss_percentile": 0.87546}, "CVE-2024-20661": {"epss_score": 0.06652, "epss_percentile": 0.90916}, "CVE-2024-20662": {"epss_score": 0.00817, "epss_percentile": 0.73843}, "CVE-2024-20663": {"epss_score": 0.03672, "epss_percentile": 0.87546}, "CVE-2024-20664": {"epss_score": 0.04684, "epss_percentile": 0.89005}, "CVE-2024-20665": {"epss_score": 0.0052, "epss_percentile": 0.66189}, "CVE-2024-20666": {"epss_score": 0.11627, "epss_percentile": 0.93424}, "CVE-2024-20667": {"epss_score": 0.00314, "epss_percentile": 0.54155}, "CVE-2024-20669": {"epss_score": 0.00098, "epss_percentile": 0.27792}, "CVE-2024-20670": {"epss_score": 0.05117, "epss_percentile": 0.89514}, "CVE-2024-20671": {"epss_score": 0.00267, "epss_percentile": 0.49984}, "CVE-2024-20672": {"epss_score": 0.00934, "epss_percentile": 0.75648}, "CVE-2024-20673": {"epss_score": 0.00408, "epss_percentile": 0.60674}, "CVE-2024-20674": {"epss_score": 0.15936, "epss_percentile": 0.9454}, "CVE-2024-20675": {"epss_score": 0.00134, "epss_percentile": 0.3385}, "CVE-2024-20676": {"epss_score": 0.00166, "epss_percentile": 0.382}, "CVE-2024-20677": {"epss_score": 0.00392, "epss_percentile": 0.59677}, "CVE-2024-20678": {"epss_score": 0.07084, "epss_percentile": 0.9124}, "CVE-2024-20679": {"epss_score": 0.00534, "epss_percentile": 0.66788}, "CVE-2024-20680": {"epss_score": 0.0339, "epss_percentile": 0.87048}, "CVE-2024-20681": {"epss_score": 0.00254, "epss_percentile": 0.48543}, "CVE-2024-20682": {"epss_score": 0.00254, "epss_percentile": 0.48543}, "CVE-2024-20683": {"epss_score": 0.04037, "epss_percentile": 0.88159}, "CVE-2024-20684": {"epss_score": 0.00164, "epss_percentile": 0.37975}, "CVE-2024-20685": {"epss_score": 0.00778, "epss_percentile": 0.73132}, "CVE-2024-20686": {"epss_score": 0.00103, "epss_percentile": 0.29079}, "CVE-2024-20687": {"epss_score": 0.04932, "epss_percentile": 0.89299}, "CVE-2024-20688": {"epss_score": 0.00636, "epss_percentile": 0.69872}, "CVE-2024-20689": {"epss_score": 0.00636, "epss_percentile": 0.69872}, "CVE-2024-20690": {"epss_score": 0.00345, "epss_percentile": 0.56575}, "CVE-2024-20691": {"epss_score": 0.00127, "epss_percentile": 0.32941}, "CVE-2024-20692": {"epss_score": 0.0107, "epss_percentile": 0.77253}, "CVE-2024-20693": {"epss_score": 0.008, "epss_percentile": 0.73533}, "CVE-2024-20694": {"epss_score": 0.00521, "epss_percentile": 0.66233}, "CVE-2024-20695": {"epss_score": 0.00123, "epss_percentile": 0.32176}, "CVE-2024-20696": {"epss_score": 0.07152, "epss_percentile": 0.91288}, "CVE-2024-20697": {"epss_score": 0.49429, "epss_percentile": 0.97686}, "CVE-2024-20698": {"epss_score": 0.17174, "epss_percentile": 0.94792}, "CVE-2024-20699": {"epss_score": 0.00231, "epss_percentile": 0.45769}, "CVE-2024-20700": {"epss_score": 0.00863, "epss_percentile": 0.74593}, "CVE-2024-20701": {"epss_score": 0.03034, "epss_percentile": 0.86258}, "CVE-2024-20709": {"epss_score": 0.00222, "epss_percentile": 0.44824}, "CVE-2024-20710": {"epss_score": 0.00045, "epss_percentile": 0.1379}, "CVE-2024-20711": {"epss_score": 0.00057, "epss_percentile": 0.17972}, "CVE-2024-20712": {"epss_score": 0.0005, "epss_percentile": 0.15831}, "CVE-2024-20713": {"epss_score": 0.0005, "epss_percentile": 0.15831}, "CVE-2024-20714": {"epss_score": 0.00051, "epss_percentile": 0.16047}, "CVE-2024-20715": {"epss_score": 0.00051, "epss_percentile": 0.16047}, "CVE-2024-20716": {"epss_score": 0.00265, "epss_percentile": 0.49821}, "CVE-2024-20717": {"epss_score": 0.00936, "epss_percentile": 0.75679}, "CVE-2024-20718": {"epss_score": 0.0012, "epss_percentile": 0.3174}, "CVE-2024-20719": {"epss_score": 0.01149, "epss_percentile": 0.78022}, "CVE-2024-20720": {"epss_score": 0.08445, "epss_percentile": 0.92054}, "CVE-2024-20721": {"epss_score": 0.00674, "epss_percentile": 0.70846}, "CVE-2024-20722": {"epss_score": 0.00016, "epss_percentile": 0.0278}, "CVE-2024-20723": {"epss_score": 0.00182, "epss_percentile": 0.40234}, "CVE-2024-20724": {"epss_score": 0.00024, "epss_percentile": 0.05824}, "CVE-2024-20725": {"epss_score": 0.00024, "epss_percentile": 0.05824}, "CVE-2024-20726": {"epss_score": 0.0102, "epss_percentile": 0.76737}, "CVE-2024-20727": {"epss_score": 0.0102, "epss_percentile": 0.76737}, "CVE-2024-20728": {"epss_score": 0.0102, "epss_percentile": 0.76737}, "CVE-2024-20729": {"epss_score": 0.01509, "epss_percentile": 0.80767}, "CVE-2024-20730": {"epss_score": 0.00753, "epss_percentile": 0.72674}, "CVE-2024-20731": {"epss_score": 0.01065, "epss_percentile": 0.77204}, "CVE-2024-20733": {"epss_score": 0.00387, "epss_percentile": 0.59333}, "CVE-2024-20734": {"epss_score": 0.00078, "epss_percentile": 0.23791}, "CVE-2024-20735": {"epss_score": 0.00083, "epss_percentile": 0.24716}, "CVE-2024-20736": {"epss_score": 0.00083, "epss_percentile": 0.24716}, "CVE-2024-20737": {"epss_score": 0.00033, "epss_percentile": 0.0925}, "CVE-2024-20738": {"epss_score": 0.00207, "epss_percentile": 0.43085}, "CVE-2024-20739": {"epss_score": 0.00177, "epss_percentile": 0.39528}, "CVE-2024-20740": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2024-20741": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2024-20742": {"epss_score": 0.00194, "epss_percentile": 0.41532}, "CVE-2024-20743": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2024-20744": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2024-20745": {"epss_score": 0.0012, "epss_percentile": 0.31733}, "CVE-2024-20746": {"epss_score": 0.00203, "epss_percentile": 0.42568}, "CVE-2024-20747": {"epss_score": 0.00061, "epss_percentile": 0.19422}, "CVE-2024-20748": {"epss_score": 0.00083, "epss_percentile": 0.24716}, "CVE-2024-20749": {"epss_score": 0.00083, "epss_percentile": 0.24716}, "CVE-2024-20750": {"epss_score": 0.00155, "epss_percentile": 0.36834}, "CVE-2024-20752": {"epss_score": 0.02331, "epss_percentile": 0.84406}, "CVE-2024-20753": {"epss_score": 0.00263, "epss_percentile": 0.49532}, "CVE-2024-20754": {"epss_score": 0.00136, "epss_percentile": 0.34199}, "CVE-2024-20755": {"epss_score": 0.01901, "epss_percentile": 0.82779}, "CVE-2024-20756": {"epss_score": 0.02373, "epss_percentile": 0.84532}, "CVE-2024-20757": {"epss_score": 0.00028, "epss_percentile": 0.0757}, "CVE-2024-20758": {"epss_score": 0.02201, "epss_percentile": 0.83981}, "CVE-2024-20759": {"epss_score": 0.01627, "epss_percentile": 0.81433}, "CVE-2024-20760": {"epss_score": 0.01529, "epss_percentile": 0.80879}, "CVE-2024-20761": {"epss_score": 0.00136, "epss_percentile": 0.34178}, "CVE-2024-20762": {"epss_score": 0.00037, "epss_percentile": 0.10861}, "CVE-2024-20763": {"epss_score": 0.00037, "epss_percentile": 0.10861}, "CVE-2024-20764": {"epss_score": 0.00037, "epss_percentile": 0.10861}, "CVE-2024-20765": {"epss_score": 0.0014, "epss_percentile": 0.34718}, "CVE-2024-20766": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2024-20767": {"epss_score": 0.9415, "epss_percentile": 0.99909}, "CVE-2024-20768": {"epss_score": 0.01529, "epss_percentile": 0.80879}, "CVE-2024-20769": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-20770": {"epss_score": 0.00033, "epss_percentile": 0.0925}, "CVE-2024-20771": {"epss_score": 0.00021, "epss_percentile": 0.04918}, "CVE-2024-20772": {"epss_score": 0.00206, "epss_percentile": 0.42941}, "CVE-2024-20778": {"epss_score": 0.0145, "epss_percentile": 0.8035}, "CVE-2024-20779": {"epss_score": 0.0145, "epss_percentile": 0.8035}, "CVE-2024-20780": {"epss_score": 0.01957, "epss_percentile": 0.83045}, "CVE-2024-20781": {"epss_score": 0.00248, "epss_percentile": 0.47909}, "CVE-2024-20782": {"epss_score": 0.00201, "epss_percentile": 0.42347}, "CVE-2024-20783": {"epss_score": 0.00248, "epss_percentile": 0.47909}, "CVE-2024-20784": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-20785": {"epss_score": 0.00248, "epss_percentile": 0.47909}, "CVE-2024-20787": {"epss_score": 0.00039, "epss_percentile": 0.1144}, "CVE-2024-20789": {"epss_score": 0.00122, "epss_percentile": 0.3204}, "CVE-2024-20790": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-20791": {"epss_score": 0.00119, "epss_percentile": 0.31644}, "CVE-2024-20792": {"epss_score": 0.00138, "epss_percentile": 0.34508}, "CVE-2024-20793": {"epss_score": 0.00031, "epss_percentile": 0.08693}, "CVE-2024-20794": {"epss_score": 0.00109, "epss_percentile": 0.29912}, "CVE-2024-20795": {"epss_score": 0.00168, "epss_percentile": 0.38479}, "CVE-2024-20796": {"epss_score": 0.00033, "epss_percentile": 0.0925}, "CVE-2024-20797": {"epss_score": 0.00162, "epss_percentile": 0.37687}, "CVE-2024-20798": {"epss_score": 0.00033, "epss_percentile": 0.0925}, "CVE-2024-20799": {"epss_score": 0.02193, "epss_percentile": 0.83943}, "CVE-2024-20800": {"epss_score": 0.05614, "epss_percentile": 0.90051}, "CVE-2024-20802": {"epss_score": 0.00065, "epss_percentile": 0.20614}, "CVE-2024-20803": {"epss_score": 0.00093, "epss_percentile": 0.26704}, "CVE-2024-20804": {"epss_score": 0.00096, "epss_percentile": 0.27403}, "CVE-2024-20805": {"epss_score": 0.00069, "epss_percentile": 0.21625}, "CVE-2024-20806": {"epss_score": 0.00048, "epss_percentile": 0.15141}, "CVE-2024-20807": {"epss_score": 0.00063, "epss_percentile": 0.19865}, "CVE-2024-20808": {"epss_score": 0.00036, "epss_percentile": 0.10304}, "CVE-2024-20809": {"epss_score": 0.00036, "epss_percentile": 0.10304}, "CVE-2024-20810": {"epss_score": 0.00066, "epss_percentile": 0.20808}, "CVE-2024-20811": {"epss_score": 0.0004, "epss_percentile": 0.12064}, "CVE-2024-20812": {"epss_score": 0.00064, "epss_percentile": 0.20189}, "CVE-2024-20813": {"epss_score": 0.00153, "epss_percentile": 0.36556}, "CVE-2024-20814": {"epss_score": 0.00053, "epss_percentile": 0.16693}, "CVE-2024-20815": {"epss_score": 0.00152, "epss_percentile": 0.36395}, "CVE-2024-20816": {"epss_score": 0.00086, "epss_percentile": 0.25299}, "CVE-2024-20817": {"epss_score": 0.00076, "epss_percentile": 0.23266}, "CVE-2024-20818": {"epss_score": 0.00076, "epss_percentile": 0.23266}, "CVE-2024-20819": {"epss_score": 0.00076, "epss_percentile": 0.23266}, "CVE-2024-20820": {"epss_score": 0.00036, "epss_percentile": 0.103}, "CVE-2024-20821": {"epss_score": 0.00042, "epss_percentile": 0.12883}, "CVE-2024-20822": {"epss_score": 0.00049, "epss_percentile": 0.15374}, "CVE-2024-20823": {"epss_score": 0.00049, "epss_percentile": 0.15374}, "CVE-2024-20824": {"epss_score": 0.00049, "epss_percentile": 0.15374}, "CVE-2024-20825": {"epss_score": 0.00049, "epss_percentile": 0.15374}, "CVE-2024-20826": {"epss_score": 0.00048, "epss_percentile": 0.15141}, "CVE-2024-20827": {"epss_score": 0.00085, "epss_percentile": 0.25114}, "CVE-2024-20828": {"epss_score": 0.00096, "epss_percentile": 0.27292}, "CVE-2024-20829": {"epss_score": 0.00129, "epss_percentile": 0.33209}, "CVE-2024-20830": {"epss_score": 0.00086, "epss_percentile": 0.25282}, "CVE-2024-20831": {"epss_score": 0.00072, "epss_percentile": 0.22322}, "CVE-2024-20832": {"epss_score": 0.00078, "epss_percentile": 0.23671}, "CVE-2024-20833": {"epss_score": 0.00041, "epss_percentile": 0.12418}, "CVE-2024-20834": {"epss_score": 0.00088, "epss_percentile": 0.2577}, "CVE-2024-20835": {"epss_score": 0.00062, "epss_percentile": 0.19788}, "CVE-2024-20836": {"epss_score": 0.00095, "epss_percentile": 0.27188}, "CVE-2024-20837": {"epss_score": 0.00086, "epss_percentile": 0.25282}, "CVE-2024-20838": {"epss_score": 0.0002, "epss_percentile": 0.04538}, "CVE-2024-20839": {"epss_score": 0.00075, "epss_percentile": 0.22996}, "CVE-2024-20840": {"epss_score": 0.00037, "epss_percentile": 0.10816}, "CVE-2024-20841": {"epss_score": 0.00023, "epss_percentile": 0.05335}, "CVE-2024-20842": {"epss_score": 0.00045, "epss_percentile": 0.13783}, "CVE-2024-20843": {"epss_score": 0.00058, "epss_percentile": 0.18374}, "CVE-2024-20844": {"epss_score": 0.00103, "epss_percentile": 0.2909}, "CVE-2024-20845": {"epss_score": 0.00119, "epss_percentile": 0.31543}, "CVE-2024-20846": {"epss_score": 0.00083, "epss_percentile": 0.24754}, "CVE-2024-20847": {"epss_score": 0.00098, "epss_percentile": 0.27818}, "CVE-2024-20848": {"epss_score": 0.00058, "epss_percentile": 0.18435}, "CVE-2024-20849": {"epss_score": 0.00095, "epss_percentile": 0.2713}, "CVE-2024-20850": {"epss_score": 0.00094, "epss_percentile": 0.26972}, "CVE-2024-20851": {"epss_score": 0.00045, "epss_percentile": 0.13888}, "CVE-2024-20852": {"epss_score": 0.00078, "epss_percentile": 0.23778}, "CVE-2024-20853": {"epss_score": 0.00053, "epss_percentile": 0.1689}, "CVE-2024-20854": {"epss_score": 0.001, "epss_percentile": 0.28433}, "CVE-2024-20855": {"epss_score": 0.00223, "epss_percentile": 0.44966}, "CVE-2024-20856": {"epss_score": 0.00208, "epss_percentile": 0.43242}, "CVE-2024-20857": {"epss_score": 0.0009, "epss_percentile": 0.25993}, "CVE-2024-20858": {"epss_score": 0.0009, "epss_percentile": 0.25993}, "CVE-2024-20859": {"epss_score": 0.00084, "epss_percentile": 0.24983}, "CVE-2024-20860": {"epss_score": 0.00077, "epss_percentile": 0.23408}, "CVE-2024-20861": {"epss_score": 0.00068, "epss_percentile": 0.21241}, "CVE-2024-20862": {"epss_score": 0.00041, "epss_percentile": 0.12252}, "CVE-2024-20863": {"epss_score": 0.00064, "epss_percentile": 0.20206}, "CVE-2024-20864": {"epss_score": 0.00104, "epss_percentile": 0.29222}, "CVE-2024-20865": {"epss_score": 0.00065, "epss_percentile": 0.20558}, "CVE-2024-20866": {"epss_score": 0.00044, "epss_percentile": 0.13589}, "CVE-2024-20867": {"epss_score": 0.00105, "epss_percentile": 0.29372}, "CVE-2024-20868": {"epss_score": 0.00051, "epss_percentile": 0.16293}, "CVE-2024-20869": {"epss_score": 0.00018, "epss_percentile": 0.03873}, "CVE-2024-20870": {"epss_score": 0.00104, "epss_percentile": 0.29131}, "CVE-2024-20871": {"epss_score": 0.00033, "epss_percentile": 0.09293}, "CVE-2024-20872": {"epss_score": 0.00089, "epss_percentile": 0.25892}, "CVE-2024-20873": {"epss_score": 0.0007, "epss_percentile": 0.21863}, "CVE-2024-20874": {"epss_score": 0.00111, "epss_percentile": 0.30262}, "CVE-2024-20875": {"epss_score": 0.00157, "epss_percentile": 0.37122}, "CVE-2024-20876": {"epss_score": 0.00118, "epss_percentile": 0.31397}, "CVE-2024-20877": {"epss_score": 0.00175, "epss_percentile": 0.39347}, "CVE-2024-20878": {"epss_score": 0.00175, "epss_percentile": 0.39347}, "CVE-2024-20879": {"epss_score": 0.00108, "epss_percentile": 0.29893}, "CVE-2024-20880": {"epss_score": 0.00333, "epss_percentile": 0.5564}, "CVE-2024-20881": {"epss_score": 0.00083, "epss_percentile": 0.24598}, "CVE-2024-20882": {"epss_score": 0.00309, "epss_percentile": 0.53662}, "CVE-2024-20883": {"epss_score": 0.00163, "epss_percentile": 0.3776}, "CVE-2024-20884": {"epss_score": 0.00171, "epss_percentile": 0.3881}, "CVE-2024-20885": {"epss_score": 0.00153, "epss_percentile": 0.36572}, "CVE-2024-20886": {"epss_score": 0.00112, "epss_percentile": 0.30528}, "CVE-2024-20887": {"epss_score": 0.00112, "epss_percentile": 0.30528}, "CVE-2024-20888": {"epss_score": 0.00046, "epss_percentile": 0.14164}, "CVE-2024-20889": {"epss_score": 0.00083, "epss_percentile": 0.24806}, "CVE-2024-20890": {"epss_score": 0.00059, "epss_percentile": 0.18756}, "CVE-2024-20891": {"epss_score": 0.00043, "epss_percentile": 0.13081}, "CVE-2024-20892": {"epss_score": 0.00027, "epss_percentile": 0.06832}, "CVE-2024-20893": {"epss_score": 0.00032, "epss_percentile": 0.091}, "CVE-2024-20894": {"epss_score": 0.0002, "epss_percentile": 0.04635}, "CVE-2024-20895": {"epss_score": 0.00014, "epss_percentile": 0.01996}, "CVE-2024-20896": {"epss_score": 0.00043, "epss_percentile": 0.13273}, "CVE-2024-20897": {"epss_score": 0.00099, "epss_percentile": 0.28339}, "CVE-2024-20898": {"epss_score": 0.00099, "epss_percentile": 0.28339}, "CVE-2024-20899": {"epss_score": 0.00099, "epss_percentile": 0.28339}, "CVE-2024-20900": {"epss_score": 0.00102, "epss_percentile": 0.28811}, "CVE-2024-20901": {"epss_score": 0.00078, "epss_percentile": 0.23564}, "CVE-2024-20903": {"epss_score": 0.0019, "epss_percentile": 0.41087}, "CVE-2024-20904": {"epss_score": 0.00221, "epss_percentile": 0.44696}, "CVE-2024-20905": {"epss_score": 0.00072, "epss_percentile": 0.22238}, "CVE-2024-20906": {"epss_score": 0.00198, "epss_percentile": 0.4209}, "CVE-2024-20907": {"epss_score": 0.00207, "epss_percentile": 0.43168}, "CVE-2024-20908": {"epss_score": 0.00248, "epss_percentile": 0.47997}, "CVE-2024-20909": {"epss_score": 0.00218, "epss_percentile": 0.44398}, "CVE-2024-20910": {"epss_score": 0.00289, "epss_percentile": 0.52035}, "CVE-2024-20911": {"epss_score": 0.00178, "epss_percentile": 0.39725}, "CVE-2024-20912": {"epss_score": 0.00182, "epss_percentile": 0.40274}, "CVE-2024-20913": {"epss_score": 0.00215, "epss_percentile": 0.44123}, "CVE-2024-20914": {"epss_score": 0.001, "epss_percentile": 0.28481}, "CVE-2024-20915": {"epss_score": 0.00088, "epss_percentile": 0.25676}, "CVE-2024-20916": {"epss_score": 0.00192, "epss_percentile": 0.41283}, "CVE-2024-20917": {"epss_score": 0.00122, "epss_percentile": 0.3202}, "CVE-2024-20918": {"epss_score": 0.00238, "epss_percentile": 0.4684}, "CVE-2024-20919": {"epss_score": 0.0017, "epss_percentile": 0.38686}, "CVE-2024-20920": {"epss_score": 0.00158, "epss_percentile": 0.37288}, "CVE-2024-20921": {"epss_score": 0.00187, "epss_percentile": 0.40773}, "CVE-2024-20922": {"epss_score": 0.00056, "epss_percentile": 0.17721}, "CVE-2024-20923": {"epss_score": 0.00352, "epss_percentile": 0.57126}, "CVE-2024-20924": {"epss_score": 0.00622, "epss_percentile": 0.69494}, "CVE-2024-20925": {"epss_score": 0.00218, "epss_percentile": 0.44339}, "CVE-2024-20926": {"epss_score": 0.00211, "epss_percentile": 0.43705}, "CVE-2024-20927": {"epss_score": 0.00234, "epss_percentile": 0.46169}, "CVE-2024-20928": {"epss_score": 0.00393, "epss_percentile": 0.59731}, "CVE-2024-20929": {"epss_score": 0.00317, "epss_percentile": 0.54349}, "CVE-2024-20930": {"epss_score": 0.00221, "epss_percentile": 0.44677}, "CVE-2024-20931": {"epss_score": 0.87628, "epss_percentile": 0.99436}, "CVE-2024-20932": {"epss_score": 0.00126, "epss_percentile": 0.32729}, "CVE-2024-20933": {"epss_score": 0.00209, "epss_percentile": 0.434}, "CVE-2024-20934": {"epss_score": 0.00333, "epss_percentile": 0.55628}, "CVE-2024-20935": {"epss_score": 0.00271, "epss_percentile": 0.50305}, "CVE-2024-20936": {"epss_score": 0.00471, "epss_percentile": 0.64008}, "CVE-2024-20937": {"epss_score": 0.00355, "epss_percentile": 0.57269}, "CVE-2024-20938": {"epss_score": 0.00463, "epss_percentile": 0.63673}, "CVE-2024-20939": {"epss_score": 0.00091, "epss_percentile": 0.26379}, "CVE-2024-20940": {"epss_score": 0.00338, "epss_percentile": 0.56158}, "CVE-2024-20941": {"epss_score": 0.00295, "epss_percentile": 0.52454}, "CVE-2024-20942": {"epss_score": 0.00338, "epss_percentile": 0.56158}, "CVE-2024-20943": {"epss_score": 0.00205, "epss_percentile": 0.4267}, "CVE-2024-20944": {"epss_score": 0.00313, "epss_percentile": 0.54042}, "CVE-2024-20945": {"epss_score": 0.0004, "epss_percentile": 0.12048}, "CVE-2024-20946": {"epss_score": 0.00056, "epss_percentile": 0.17711}, "CVE-2024-20947": {"epss_score": 0.00234, "epss_percentile": 0.46193}, "CVE-2024-20948": {"epss_score": 0.00291, "epss_percentile": 0.52202}, "CVE-2024-20949": {"epss_score": 0.00225, "epss_percentile": 0.45235}, "CVE-2024-20950": {"epss_score": 0.00271, "epss_percentile": 0.50305}, "CVE-2024-20951": {"epss_score": 0.00317, "epss_percentile": 0.54349}, "CVE-2024-20952": {"epss_score": 0.00324, "epss_percentile": 0.54952}, "CVE-2024-20953": {"epss_score": 0.69038, "epss_percentile": 0.98575}, "CVE-2024-20954": {"epss_score": 0.00303, "epss_percentile": 0.53169}, "CVE-2024-20955": {"epss_score": 0.00508, "epss_percentile": 0.65683}, "CVE-2024-20956": {"epss_score": 0.00136, "epss_percentile": 0.34144}, "CVE-2024-20957": {"epss_score": 0.00114, "epss_percentile": 0.30762}, "CVE-2024-20958": {"epss_score": 0.00234, "epss_percentile": 0.46193}, "CVE-2024-20959": {"epss_score": 0.00059, "epss_percentile": 0.1864}, "CVE-2024-20960": {"epss_score": 0.00278, "epss_percentile": 0.50867}, "CVE-2024-20961": {"epss_score": 0.00347, "epss_percentile": 0.56753}, "CVE-2024-20962": {"epss_score": 0.00325, "epss_percentile": 0.54996}, "CVE-2024-20963": {"epss_score": 0.00297, "epss_percentile": 0.52685}, "CVE-2024-20964": {"epss_score": 0.00325, "epss_percentile": 0.54996}, "CVE-2024-20965": {"epss_score": 0.0038, "epss_percentile": 0.58973}, "CVE-2024-20966": {"epss_score": 0.00218, "epss_percentile": 0.44342}, "CVE-2024-20967": {"epss_score": 0.00062, "epss_percentile": 0.19696}, "CVE-2024-20968": {"epss_score": 0.00063, "epss_percentile": 0.20096}, "CVE-2024-20969": {"epss_score": 0.00133, "epss_percentile": 0.33623}, "CVE-2024-20970": {"epss_score": 0.00253, "epss_percentile": 0.48455}, "CVE-2024-20971": {"epss_score": 0.00163, "epss_percentile": 0.37861}, "CVE-2024-20972": {"epss_score": 0.00218, "epss_percentile": 0.44342}, "CVE-2024-20973": {"epss_score": 0.00209, "epss_percentile": 0.43364}, "CVE-2024-20974": {"epss_score": 0.00054, "epss_percentile": 0.17299}, "CVE-2024-20975": {"epss_score": 0.00307, "epss_percentile": 0.53493}, "CVE-2024-20976": {"epss_score": 0.00218, "epss_percentile": 0.44342}, "CVE-2024-20977": {"epss_score": 0.00244, "epss_percentile": 0.4758}, "CVE-2024-20978": {"epss_score": 0.00218, "epss_percentile": 0.44342}, "CVE-2024-20979": {"epss_score": 0.00246, "epss_percentile": 0.47753}, "CVE-2024-20980": {"epss_score": 0.00234, "epss_percentile": 0.46193}, "CVE-2024-20981": {"epss_score": 0.00163, "epss_percentile": 0.37861}, "CVE-2024-20982": {"epss_score": 0.00186, "epss_percentile": 0.40641}, "CVE-2024-20983": {"epss_score": 0.00107, "epss_percentile": 0.29633}, "CVE-2024-20984": {"epss_score": 0.00186, "epss_percentile": 0.40605}, "CVE-2024-20985": {"epss_score": 0.00471, "epss_percentile": 0.64003}, "CVE-2024-20986": {"epss_score": 0.00403, "epss_percentile": 0.60365}, "CVE-2024-20987": {"epss_score": 0.00282, "epss_percentile": 0.51223}, "CVE-2024-20989": {"epss_score": 0.00303, "epss_percentile": 0.53227}, "CVE-2024-20990": {"epss_score": 0.00638, "epss_percentile": 0.6991}, "CVE-2024-20991": {"epss_score": 0.0035, "epss_percentile": 0.5692}, "CVE-2024-20992": {"epss_score": 0.00285, "epss_percentile": 0.5167}, "CVE-2024-20993": {"epss_score": 0.00151, "epss_percentile": 0.36323}, "CVE-2024-20994": {"epss_score": 0.00411, "epss_percentile": 0.60848}, "CVE-2024-20995": {"epss_score": 0.00109, "epss_percentile": 0.29949}, "CVE-2024-20996": {"epss_score": 0.00119, "epss_percentile": 0.31534}, "CVE-2024-20997": {"epss_score": 0.01195, "epss_percentile": 0.78425}, "CVE-2024-20998": {"epss_score": 0.0015, "epss_percentile": 0.36079}, "CVE-2024-20999": {"epss_score": 0.00085, "epss_percentile": 0.25101}, "CVE-2024-21000": {"epss_score": 0.00186, "epss_percentile": 0.40634}, "CVE-2024-21001": {"epss_score": 0.0036, "epss_percentile": 0.57666}, "CVE-2024-21002": {"epss_score": 0.00051, "epss_percentile": 0.16323}, "CVE-2024-21003": {"epss_score": 0.00205, "epss_percentile": 0.42698}, "CVE-2024-21004": {"epss_score": 0.00043, "epss_percentile": 0.13227}, "CVE-2024-21005": {"epss_score": 0.00157, "epss_percentile": 0.37028}, "CVE-2024-21006": {"epss_score": 0.83994, "epss_percentile": 0.99268}, "CVE-2024-21007": {"epss_score": 0.00785, "epss_percentile": 0.7325}, "CVE-2024-21008": {"epss_score": 0.0013, "epss_percentile": 0.33286}, "CVE-2024-21009": {"epss_score": 0.00157, "epss_percentile": 0.37105}, "CVE-2024-21010": {"epss_score": 0.01044, "epss_percentile": 0.77003}, "CVE-2024-21011": {"epss_score": 0.00312, "epss_percentile": 0.53992}, "CVE-2024-21012": {"epss_score": 0.00146, "epss_percentile": 0.35582}, "CVE-2024-21013": {"epss_score": 0.00174, "epss_percentile": 0.39198}, "CVE-2024-21014": {"epss_score": 0.01234, "epss_percentile": 0.78758}, "CVE-2024-21015": {"epss_score": 0.00153, "epss_percentile": 0.36631}, "CVE-2024-21016": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21017": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21018": {"epss_score": 0.00463, "epss_percentile": 0.63673}, "CVE-2024-21019": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21020": {"epss_score": 0.00333, "epss_percentile": 0.55628}, "CVE-2024-21021": {"epss_score": 0.00641, "epss_percentile": 0.70014}, "CVE-2024-21022": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21023": {"epss_score": 0.00641, "epss_percentile": 0.70014}, "CVE-2024-21024": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21025": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21026": {"epss_score": 0.00185, "epss_percentile": 0.40475}, "CVE-2024-21027": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2024-21028": {"epss_score": 0.00837, "epss_percentile": 0.74159}, "CVE-2024-21029": {"epss_score": 0.00431, "epss_percentile": 0.62049}, "CVE-2024-21030": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21031": {"epss_score": 0.00463, "epss_percentile": 0.63673}, "CVE-2024-21032": {"epss_score": 0.00333, "epss_percentile": 0.55628}, "CVE-2024-21033": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21034": {"epss_score": 0.00354, "epss_percentile": 0.57241}, "CVE-2024-21035": {"epss_score": 0.00463, "epss_percentile": 0.63673}, "CVE-2024-21036": {"epss_score": 0.00641, "epss_percentile": 0.70014}, "CVE-2024-21037": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21038": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21039": {"epss_score": 0.00463, "epss_percentile": 0.63673}, "CVE-2024-21040": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21041": {"epss_score": 0.00641, "epss_percentile": 0.70014}, "CVE-2024-21042": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21043": {"epss_score": 0.00254, "epss_percentile": 0.48625}, "CVE-2024-21044": {"epss_score": 0.00254, "epss_percentile": 0.48625}, "CVE-2024-21045": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21046": {"epss_score": 0.00641, "epss_percentile": 0.70014}, "CVE-2024-21047": {"epss_score": 0.00246, "epss_percentile": 0.47762}, "CVE-2024-21048": {"epss_score": 0.00492, "epss_percentile": 0.64993}, "CVE-2024-21049": {"epss_score": 0.00102, "epss_percentile": 0.28829}, "CVE-2024-21050": {"epss_score": 0.00133, "epss_percentile": 0.33665}, "CVE-2024-21051": {"epss_score": 0.00088, "epss_percentile": 0.25703}, "CVE-2024-21052": {"epss_score": 0.00086, "epss_percentile": 0.25369}, "CVE-2024-21053": {"epss_score": 0.00099, "epss_percentile": 0.28378}, "CVE-2024-21054": {"epss_score": 0.0015, "epss_percentile": 0.36079}, "CVE-2024-21055": {"epss_score": 0.00088, "epss_percentile": 0.25703}, "CVE-2024-21056": {"epss_score": 0.00154, "epss_percentile": 0.36745}, "CVE-2024-21057": {"epss_score": 0.00117, "epss_percentile": 0.31287}, "CVE-2024-21058": {"epss_score": 0.00237, "epss_percentile": 0.46643}, "CVE-2024-21059": {"epss_score": 0.00176, "epss_percentile": 0.39468}, "CVE-2024-21060": {"epss_score": 0.00115, "epss_percentile": 0.31015}, "CVE-2024-21061": {"epss_score": 0.00154, "epss_percentile": 0.36745}, "CVE-2024-21062": {"epss_score": 0.00212, "epss_percentile": 0.4373}, "CVE-2024-21063": {"epss_score": 0.0012, "epss_percentile": 0.31771}, "CVE-2024-21064": {"epss_score": 0.00215, "epss_percentile": 0.44123}, "CVE-2024-21065": {"epss_score": 0.00463, "epss_percentile": 0.63673}, "CVE-2024-21066": {"epss_score": 0.00239, "epss_percentile": 0.46892}, "CVE-2024-21067": {"epss_score": 0.00194, "epss_percentile": 0.41575}, "CVE-2024-21068": {"epss_score": 0.00497, "epss_percentile": 0.65191}, "CVE-2024-21069": {"epss_score": 0.00246, "epss_percentile": 0.47762}, "CVE-2024-21070": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21071": {"epss_score": 0.00395, "epss_percentile": 0.59803}, "CVE-2024-21072": {"epss_score": 0.0033, "epss_percentile": 0.55423}, "CVE-2024-21073": {"epss_score": 0.00665, "epss_percentile": 0.70668}, "CVE-2024-21074": {"epss_score": 0.00953, "epss_percentile": 0.75889}, "CVE-2024-21075": {"epss_score": 0.02103, "epss_percentile": 0.83615}, "CVE-2024-21076": {"epss_score": 0.00579, "epss_percentile": 0.68211}, "CVE-2024-21077": {"epss_score": 0.0051, "epss_percentile": 0.65758}, "CVE-2024-21078": {"epss_score": 0.0051, "epss_percentile": 0.65758}, "CVE-2024-21079": {"epss_score": 0.00274, "epss_percentile": 0.50564}, "CVE-2024-21080": {"epss_score": 0.00566, "epss_percentile": 0.67812}, "CVE-2024-21081": {"epss_score": 0.00257, "epss_percentile": 0.48873}, "CVE-2024-21082": {"epss_score": 0.00738, "epss_percentile": 0.72347}, "CVE-2024-21083": {"epss_score": 0.0041, "epss_percentile": 0.6082}, "CVE-2024-21084": {"epss_score": 0.00296, "epss_percentile": 0.52628}, "CVE-2024-21085": {"epss_score": 0.001, "epss_percentile": 0.28479}, "CVE-2024-21086": {"epss_score": 0.00257, "epss_percentile": 0.48873}, "CVE-2024-21087": {"epss_score": 0.00135, "epss_percentile": 0.34022}, "CVE-2024-21088": {"epss_score": 0.00159, "epss_percentile": 0.37339}, "CVE-2024-21089": {"epss_score": 0.00738, "epss_percentile": 0.7235}, "CVE-2024-21090": {"epss_score": 0.00269, "epss_percentile": 0.50157}, "CVE-2024-21091": {"epss_score": 0.00494, "epss_percentile": 0.65072}, "CVE-2024-21092": {"epss_score": 0.01171, "epss_percentile": 0.78215}, "CVE-2024-21093": {"epss_score": 0.00566, "epss_percentile": 0.67812}, "CVE-2024-21094": {"epss_score": 0.00417, "epss_percentile": 0.61239}, "CVE-2024-21095": {"epss_score": 0.00218, "epss_percentile": 0.44388}, "CVE-2024-21096": {"epss_score": 0.00121, "epss_percentile": 0.31934}, "CVE-2024-21097": {"epss_score": 0.00379, "epss_percentile": 0.58896}, "CVE-2024-21098": {"epss_score": 0.00077, "epss_percentile": 0.23454}, "CVE-2024-21099": {"epss_score": 0.00271, "epss_percentile": 0.50336}, "CVE-2024-21100": {"epss_score": 0.00257, "epss_percentile": 0.48873}, "CVE-2024-21101": {"epss_score": 0.00131, "epss_percentile": 0.3335}, "CVE-2024-21102": {"epss_score": 0.00201, "epss_percentile": 0.42283}, "CVE-2024-21103": {"epss_score": 0.002, "epss_percentile": 0.42208}, "CVE-2024-21104": {"epss_score": 0.00215, "epss_percentile": 0.44031}, "CVE-2024-21105": {"epss_score": 0.00118, "epss_percentile": 0.31392}, "CVE-2024-21106": {"epss_score": 0.00119, "epss_percentile": 0.31614}, "CVE-2024-21107": {"epss_score": 0.00137, "epss_percentile": 0.34219}, "CVE-2024-21108": {"epss_score": 0.00153, "epss_percentile": 0.36592}, "CVE-2024-21109": {"epss_score": 0.00392, "epss_percentile": 0.59667}, "CVE-2024-21110": {"epss_score": 0.00181, "epss_percentile": 0.40103}, "CVE-2024-21111": {"epss_score": 0.09561, "epss_percentile": 0.926}, "CVE-2024-21112": {"epss_score": 0.00128, "epss_percentile": 0.33027}, "CVE-2024-21113": {"epss_score": 0.00128, "epss_percentile": 0.33027}, "CVE-2024-21114": {"epss_score": 0.0014, "epss_percentile": 0.3479}, "CVE-2024-21115": {"epss_score": 0.0024, "epss_percentile": 0.46958}, "CVE-2024-21116": {"epss_score": 0.002, "epss_percentile": 0.42208}, "CVE-2024-21117": {"epss_score": 0.00128, "epss_percentile": 0.32999}, "CVE-2024-21118": {"epss_score": 0.00075, "epss_percentile": 0.23016}, "CVE-2024-21119": {"epss_score": 0.00094, "epss_percentile": 0.26766}, "CVE-2024-21120": {"epss_score": 0.00075, "epss_percentile": 0.23016}, "CVE-2024-21121": {"epss_score": 0.00156, "epss_percentile": 0.36981}, "CVE-2024-21122": {"epss_score": 0.00198, "epss_percentile": 0.41982}, "CVE-2024-21123": {"epss_score": 0.00068, "epss_percentile": 0.21394}, "CVE-2024-21125": {"epss_score": 0.00138, "epss_percentile": 0.34382}, "CVE-2024-21126": {"epss_score": 0.00192, "epss_percentile": 0.41363}, "CVE-2024-21127": {"epss_score": 0.00179, "epss_percentile": 0.39811}, "CVE-2024-21128": {"epss_score": 0.0025, "epss_percentile": 0.48149}, "CVE-2024-21129": {"epss_score": 0.00138, "epss_percentile": 0.34382}, "CVE-2024-21130": {"epss_score": 0.00179, "epss_percentile": 0.39811}, "CVE-2024-21131": {"epss_score": 0.00442, "epss_percentile": 0.62742}, "CVE-2024-21132": {"epss_score": 0.00258, "epss_percentile": 0.49008}, "CVE-2024-21133": {"epss_score": 0.00469, "epss_percentile": 0.63932}, "CVE-2024-21134": {"epss_score": 0.00111, "epss_percentile": 0.30393}, "CVE-2024-21135": {"epss_score": 0.0025, "epss_percentile": 0.48099}, "CVE-2024-21136": {"epss_score": 0.42062, "epss_percentile": 0.9731}, "CVE-2024-21137": {"epss_score": 0.00142, "epss_percentile": 0.34979}, "CVE-2024-21138": {"epss_score": 0.00307, "epss_percentile": 0.53487}, "CVE-2024-21139": {"epss_score": 0.00282, "epss_percentile": 0.51223}, "CVE-2024-21140": {"epss_score": 0.00523, "epss_percentile": 0.66303}, "CVE-2024-21141": {"epss_score": 0.0025, "epss_percentile": 0.48255}, "CVE-2024-21142": {"epss_score": 0.00186, "epss_percentile": 0.4064}, "CVE-2024-21143": {"epss_score": 0.00274, "epss_percentile": 0.50554}, "CVE-2024-21144": {"epss_score": 0.00048, "epss_percentile": 0.15053}, "CVE-2024-21145": {"epss_score": 0.00414, "epss_percentile": 0.61097}, "CVE-2024-21146": {"epss_score": 0.00831, "epss_percentile": 0.74055}, "CVE-2024-21147": {"epss_score": 0.00664, "epss_percentile": 0.70631}, "CVE-2024-21148": {"epss_score": 0.00139, "epss_percentile": 0.34586}, "CVE-2024-21149": {"epss_score": 0.01084, "epss_percentile": 0.77398}, "CVE-2024-21150": {"epss_score": 0.00261, "epss_percentile": 0.49266}, "CVE-2024-21151": {"epss_score": 0.00029, "epss_percentile": 0.07604}, "CVE-2024-21152": {"epss_score": 0.00702, "epss_percentile": 0.71524}, "CVE-2024-21153": {"epss_score": 0.00831, "epss_percentile": 0.74055}, "CVE-2024-21154": {"epss_score": 0.00529, "epss_percentile": 0.66579}, "CVE-2024-21155": {"epss_score": 0.00341, "epss_percentile": 0.5632}, "CVE-2024-21157": {"epss_score": 0.0025, "epss_percentile": 0.48099}, "CVE-2024-21158": {"epss_score": 0.00215, "epss_percentile": 0.44123}, "CVE-2024-21159": {"epss_score": 0.00255, "epss_percentile": 0.48633}, "CVE-2024-21160": {"epss_score": 0.0025, "epss_percentile": 0.48099}, "CVE-2024-21161": {"epss_score": 0.0006, "epss_percentile": 0.19014}, "CVE-2024-21162": {"epss_score": 0.00208, "epss_percentile": 0.4327}, "CVE-2024-21163": {"epss_score": 0.00166, "epss_percentile": 0.38167}, "CVE-2024-21164": {"epss_score": 0.00083, "epss_percentile": 0.24627}, "CVE-2024-21165": {"epss_score": 0.00138, "epss_percentile": 0.34382}, "CVE-2024-21166": {"epss_score": 0.00344, "epss_percentile": 0.56476}, "CVE-2024-21167": {"epss_score": 0.00952, "epss_percentile": 0.75875}, "CVE-2024-21168": {"epss_score": 0.00417, "epss_percentile": 0.61232}, "CVE-2024-21169": {"epss_score": 0.00223, "epss_percentile": 0.44867}, "CVE-2024-21170": {"epss_score": 0.0013, "epss_percentile": 0.33286}, "CVE-2024-21171": {"epss_score": 0.00278, "epss_percentile": 0.50866}, "CVE-2024-21172": {"epss_score": 0.02995, "epss_percentile": 0.86153}, "CVE-2024-21173": {"epss_score": 0.00179, "epss_percentile": 0.39811}, "CVE-2024-21174": {"epss_score": 0.00231, "epss_percentile": 0.45785}, "CVE-2024-21175": {"epss_score": 0.00437, "epss_percentile": 0.62497}, "CVE-2024-21176": {"epss_score": 0.00767, "epss_percentile": 0.72955}, "CVE-2024-21177": {"epss_score": 0.00422, "epss_percentile": 0.61559}, "CVE-2024-21178": {"epss_score": 0.0097, "epss_percentile": 0.76115}, "CVE-2024-21179": {"epss_score": 0.00335, "epss_percentile": 0.55851}, "CVE-2024-21180": {"epss_score": 0.00654, "epss_percentile": 0.70341}, "CVE-2024-21181": {"epss_score": 0.01707, "epss_percentile": 0.81858}, "CVE-2024-21182": {"epss_score": 0.87667, "epss_percentile": 0.99437}, "CVE-2024-21183": {"epss_score": 0.0075, "epss_percentile": 0.72619}, "CVE-2024-21184": {"epss_score": 0.01078, "epss_percentile": 0.77346}, "CVE-2024-21185": {"epss_score": 0.00949, "epss_percentile": 0.75838}, "CVE-2024-21188": {"epss_score": 0.01134, "epss_percentile": 0.77886}, "CVE-2024-21190": {"epss_score": 0.00369, "epss_percentile": 0.5826}, "CVE-2024-21191": {"epss_score": 0.00419, "epss_percentile": 0.61389}, "CVE-2024-21192": {"epss_score": 0.00159, "epss_percentile": 0.37388}, "CVE-2024-21193": {"epss_score": 0.00138, "epss_percentile": 0.34382}, "CVE-2024-21194": {"epss_score": 0.00119, "epss_percentile": 0.31534}, "CVE-2024-21195": {"epss_score": 0.00109, "epss_percentile": 0.30035}, "CVE-2024-21196": {"epss_score": 0.0024, "epss_percentile": 0.47234}, "CVE-2024-21197": {"epss_score": 0.00138, "epss_percentile": 0.34382}, "CVE-2024-21198": {"epss_score": 0.00138, "epss_percentile": 0.34382}, "CVE-2024-21199": {"epss_score": 0.0016, "epss_percentile": 0.3751}, "CVE-2024-21200": {"epss_score": 0.00119, "epss_percentile": 0.31685}, "CVE-2024-21201": {"epss_score": 0.0016, "epss_percentile": 0.3751}, "CVE-2024-21202": {"epss_score": 0.00362, "epss_percentile": 0.57755}, "CVE-2024-21203": {"epss_score": 0.00138, "epss_percentile": 0.3444}, "CVE-2024-21204": {"epss_score": 0.00136, "epss_percentile": 0.34167}, "CVE-2024-21205": {"epss_score": 0.00583, "epss_percentile": 0.68353}, "CVE-2024-21206": {"epss_score": 0.00364, "epss_percentile": 0.57907}, "CVE-2024-21207": {"epss_score": 0.00166, "epss_percentile": 0.38147}, "CVE-2024-21208": {"epss_score": 0.00054, "epss_percentile": 0.17302}, "CVE-2024-21209": {"epss_score": 0.00121, "epss_percentile": 0.31992}, "CVE-2024-21210": {"epss_score": 0.00144, "epss_percentile": 0.35229}, "CVE-2024-21211": {"epss_score": 0.00225, "epss_percentile": 0.45237}, "CVE-2024-21212": {"epss_score": 0.0016, "epss_percentile": 0.3751}, "CVE-2024-21213": {"epss_score": 0.0004, "epss_percentile": 0.12115}, "CVE-2024-21214": {"epss_score": 0.01613, "epss_percentile": 0.81339}, "CVE-2024-21215": {"epss_score": 0.00234, "epss_percentile": 0.46175}, "CVE-2024-21216": {"epss_score": 0.02364, "epss_percentile": 0.84509}, "CVE-2024-21217": {"epss_score": 0.00096, "epss_percentile": 0.27414}, "CVE-2024-21218": {"epss_score": 0.00138, "epss_percentile": 0.3444}, "CVE-2024-21219": {"epss_score": 0.00138, "epss_percentile": 0.3444}, "CVE-2024-21230": {"epss_score": 0.0024, "epss_percentile": 0.47234}, "CVE-2024-21231": {"epss_score": 0.0017, "epss_percentile": 0.38733}, "CVE-2024-21232": {"epss_score": 0.00063, "epss_percentile": 0.20087}, "CVE-2024-21233": {"epss_score": 0.0031, "epss_percentile": 0.53773}, "CVE-2024-21234": {"epss_score": 0.0038, "epss_percentile": 0.58961}, "CVE-2024-21235": {"epss_score": 0.00126, "epss_percentile": 0.32661}, "CVE-2024-21236": {"epss_score": 0.00179, "epss_percentile": 0.39829}, "CVE-2024-21237": {"epss_score": 0.00075, "epss_percentile": 0.22904}, "CVE-2024-21238": {"epss_score": 0.0028, "epss_percentile": 0.51}, "CVE-2024-21239": {"epss_score": 0.00472, "epss_percentile": 0.64059}, "CVE-2024-21241": {"epss_score": 0.00138, "epss_percentile": 0.34382}, "CVE-2024-21242": {"epss_score": 0.00138, "epss_percentile": 0.34355}, "CVE-2024-21243": {"epss_score": 0.00121, "epss_percentile": 0.31992}, "CVE-2024-21244": {"epss_score": 0.00121, "epss_percentile": 0.31992}, "CVE-2024-21245": {"epss_score": 0.00064, "epss_percentile": 0.20172}, "CVE-2024-21246": {"epss_score": 0.00486, "epss_percentile": 0.64751}, "CVE-2024-21247": {"epss_score": 0.00133, "epss_percentile": 0.33646}, "CVE-2024-21248": {"epss_score": 0.00019, "epss_percentile": 0.04058}, "CVE-2024-21249": {"epss_score": 0.00326, "epss_percentile": 0.55081}, "CVE-2024-21250": {"epss_score": 0.01236, "epss_percentile": 0.78773}, "CVE-2024-21251": {"epss_score": 0.00263, "epss_percentile": 0.49502}, "CVE-2024-21252": {"epss_score": 0.01236, "epss_percentile": 0.78773}, "CVE-2024-21253": {"epss_score": 0.00028, "epss_percentile": 0.07306}, "CVE-2024-21254": {"epss_score": 0.01078, "epss_percentile": 0.77342}, "CVE-2024-21255": {"epss_score": 0.00677, "epss_percentile": 0.70967}, "CVE-2024-21257": {"epss_score": 0.00202, "epss_percentile": 0.4241}, "CVE-2024-21258": {"epss_score": 0.00286, "epss_percentile": 0.51738}, "CVE-2024-21259": {"epss_score": 0.00052, "epss_percentile": 0.16582}, "CVE-2024-21260": {"epss_score": 0.00285, "epss_percentile": 0.51658}, "CVE-2024-21261": {"epss_score": 0.00252, "epss_percentile": 0.48399}, "CVE-2024-21262": {"epss_score": 0.0019, "epss_percentile": 0.41053}, "CVE-2024-21263": {"epss_score": 0.00039, "epss_percentile": 0.11435}, "CVE-2024-21264": {"epss_score": 0.00465, "epss_percentile": 0.63775}, "CVE-2024-21265": {"epss_score": 0.01343, "epss_percentile": 0.79605}, "CVE-2024-21266": {"epss_score": 0.00993, "epss_percentile": 0.76406}, "CVE-2024-21267": {"epss_score": 0.00993, "epss_percentile": 0.76406}, "CVE-2024-21268": {"epss_score": 0.00993, "epss_percentile": 0.76406}, "CVE-2024-21269": {"epss_score": 0.00993, "epss_percentile": 0.76406}, "CVE-2024-21270": {"epss_score": 0.00993, "epss_percentile": 0.76406}, "CVE-2024-21271": {"epss_score": 0.00993, "epss_percentile": 0.76406}, "CVE-2024-21272": {"epss_score": 0.00786, "epss_percentile": 0.73298}, "CVE-2024-21273": {"epss_score": 0.00043, "epss_percentile": 0.13321}, "CVE-2024-21274": {"epss_score": 0.00264, "epss_percentile": 0.49741}, "CVE-2024-21275": {"epss_score": 0.00913, "epss_percentile": 0.75378}, "CVE-2024-21276": {"epss_score": 0.00913, "epss_percentile": 0.75378}, "CVE-2024-21277": {"epss_score": 0.00913, "epss_percentile": 0.75378}, "CVE-2024-21278": {"epss_score": 0.00714, "epss_percentile": 0.71819}, "CVE-2024-21279": {"epss_score": 0.00669, "epss_percentile": 0.70755}, "CVE-2024-21280": {"epss_score": 0.00913, "epss_percentile": 0.75378}, "CVE-2024-21281": {"epss_score": 0.00149, "epss_percentile": 0.35932}, "CVE-2024-21282": {"epss_score": 0.00669, "epss_percentile": 0.70755}, "CVE-2024-21283": {"epss_score": 0.00975, "epss_percentile": 0.76196}, "CVE-2024-21284": {"epss_score": 0.00915, "epss_percentile": 0.75411}, "CVE-2024-21285": {"epss_score": 0.00915, "epss_percentile": 0.75411}, "CVE-2024-21286": {"epss_score": 0.00343, "epss_percentile": 0.56425}, "CVE-2024-21287": {"epss_score": 0.69826, "epss_percentile": 0.98606}, "CVE-2024-21302": {"epss_score": 0.00989, "epss_percentile": 0.76363}, "CVE-2024-21303": {"epss_score": 0.03005, "epss_percentile": 0.86181}, "CVE-2024-21304": {"epss_score": 0.00071, "epss_percentile": 0.22038}, "CVE-2024-21305": {"epss_score": 0.00326, "epss_percentile": 0.5505}, "CVE-2024-21306": {"epss_score": 0.28084, "epss_percentile": 0.96308}, "CVE-2024-21307": {"epss_score": 0.00152, "epss_percentile": 0.3649}, "CVE-2024-21308": {"epss_score": 0.03034, "epss_percentile": 0.86258}, "CVE-2024-21309": {"epss_score": 0.0029, "epss_percentile": 0.52107}, "CVE-2024-21310": {"epss_score": 0.04666, "epss_percentile": 0.8898}, "CVE-2024-21311": {"epss_score": 0.00367, "epss_percentile": 0.58117}, "CVE-2024-21312": {"epss_score": 0.05333, "epss_percentile": 0.89741}, "CVE-2024-21313": {"epss_score": 0.00125, "epss_percentile": 0.32503}, "CVE-2024-21314": {"epss_score": 0.04684, "epss_percentile": 0.89005}, "CVE-2024-21315": {"epss_score": 0.00274, "epss_percentile": 0.50506}, "CVE-2024-21316": {"epss_score": 0.00115, "epss_percentile": 0.30956}, "CVE-2024-21317": {"epss_score": 0.03034, "epss_percentile": 0.86258}, "CVE-2024-21318": {"epss_score": 0.1312, "epss_percentile": 0.93879}, "CVE-2024-21319": {"epss_score": 0.00322, "epss_percentile": 0.54796}, "CVE-2024-21320": {"epss_score": 0.22251, "epss_percentile": 0.95615}, "CVE-2024-21322": {"epss_score": 0.00692, "epss_percentile": 0.71287}, "CVE-2024-21323": {"epss_score": 0.10269, "epss_percentile": 0.92921}, "CVE-2024-21324": {"epss_score": 0.0713, "epss_percentile": 0.91269}, "CVE-2024-21325": {"epss_score": 0.00612, "epss_percentile": 0.69225}, "CVE-2024-21326": {"epss_score": 0.00764, "epss_percentile": 0.72904}, "CVE-2024-21327": {"epss_score": 0.00612, "epss_percentile": 0.6923}, "CVE-2024-21328": {"epss_score": 0.00612, "epss_percentile": 0.6923}, "CVE-2024-21329": {"epss_score": 0.00674, "epss_percentile": 0.70849}, "CVE-2024-21330": {"epss_score": 0.00166, "epss_percentile": 0.38234}, "CVE-2024-21331": {"epss_score": 0.03034, "epss_percentile": 0.86258}, "CVE-2024-21332": {"epss_score": 0.03005, "epss_percentile": 0.86181}, "CVE-2024-21333": {"epss_score": 0.02234, "epss_percentile": 0.84098}, "CVE-2024-21334": {"epss_score": 0.06138, "epss_percentile": 0.90511}, "CVE-2024-21335": {"epss_score": 0.02234, "epss_percentile": 0.84098}, "CVE-2024-21336": {"epss_score": 0.00334, "epss_percentile": 0.55737}, "CVE-2024-21337": {"epss_score": 0.00893, "epss_percentile": 0.75075}, "CVE-2024-21338": {"epss_score": 0.78301, "epss_percentile": 0.98979}, "CVE-2024-21339": {"epss_score": 0.00112, "epss_percentile": 0.30478}, "CVE-2024-21340": {"epss_score": 0.00131, "epss_percentile": 0.33478}, "CVE-2024-21341": {"epss_score": 0.00332, "epss_percentile": 0.5559}, "CVE-2024-21342": {"epss_score": 0.06358, "epss_percentile": 0.90696}, "CVE-2024-21343": {"epss_score": 0.01145, "epss_percentile": 0.77994}, "CVE-2024-21344": {"epss_score": 0.00758, "epss_percentile": 0.72771}, "CVE-2024-21345": {"epss_score": 0.20045, "epss_percentile": 0.9528}, "CVE-2024-21346": {"epss_score": 0.03491, "epss_percentile": 0.87231}, "CVE-2024-21347": {"epss_score": 0.01081, "epss_percentile": 0.77378}, "CVE-2024-21348": {"epss_score": 0.04885, "epss_percentile": 0.89253}, "CVE-2024-21349": {"epss_score": 0.01901, "epss_percentile": 0.82775}, "CVE-2024-21350": {"epss_score": 0.0061, "epss_percentile": 0.69148}, "CVE-2024-21351": {"epss_score": 0.0953, "epss_percentile": 0.92588}, "CVE-2024-21352": {"epss_score": 0.0227, "epss_percentile": 0.84207}, "CVE-2024-21353": {"epss_score": 0.01901, "epss_percentile": 0.82775}, "CVE-2024-21354": {"epss_score": 0.00254, "epss_percentile": 0.48543}, "CVE-2024-21355": {"epss_score": 0.0009, "epss_percentile": 0.26126}, "CVE-2024-21356": {"epss_score": 0.0533, "epss_percentile": 0.89738}, "CVE-2024-21357": {"epss_score": 0.17273, "epss_percentile": 0.94814}, "CVE-2024-21358": {"epss_score": 0.0192, "epss_percentile": 0.82893}, "CVE-2024-21359": {"epss_score": 0.01901, "epss_percentile": 0.82775}, "CVE-2024-21360": {"epss_score": 0.0192, "epss_percentile": 0.82893}, "CVE-2024-21361": {"epss_score": 0.01901, "epss_percentile": 0.82775}, "CVE-2024-21362": {"epss_score": 0.00116, "epss_percentile": 0.31106}, "CVE-2024-21363": {"epss_score": 0.00381, "epss_percentile": 0.59005}, "CVE-2024-21364": {"epss_score": 0.00285, "epss_percentile": 0.51528}, "CVE-2024-21365": {"epss_score": 0.0192, "epss_percentile": 0.82893}, "CVE-2024-21366": {"epss_score": 0.0192, "epss_percentile": 0.82893}, "CVE-2024-21367": {"epss_score": 0.01901, "epss_percentile": 0.82775}, "CVE-2024-21368": {"epss_score": 0.01901, "epss_percentile": 0.82775}, "CVE-2024-21369": {"epss_score": 0.00852, "epss_percentile": 0.74421}, "CVE-2024-21370": {"epss_score": 0.0192, "epss_percentile": 0.82893}, "CVE-2024-21371": {"epss_score": 0.00905, "epss_percentile": 0.75243}, "CVE-2024-21372": {"epss_score": 0.0153, "epss_percentile": 0.80884}, "CVE-2024-21373": {"epss_score": 0.02234, "epss_percentile": 0.84098}, "CVE-2024-21374": {"epss_score": 0.01479, "epss_percentile": 0.8056}, "CVE-2024-21375": {"epss_score": 0.0192, "epss_percentile": 0.82893}, "CVE-2024-21376": {"epss_score": 0.00275, "epss_percentile": 0.50661}, "CVE-2024-21377": {"epss_score": 0.00177, "epss_percentile": 0.39613}, "CVE-2024-21378": {"epss_score": 0.15554, "epss_percentile": 0.94458}, "CVE-2024-21379": {"epss_score": 0.00461, "epss_percentile": 0.63548}, "CVE-2024-21380": {"epss_score": 0.00513, "epss_percentile": 0.65907}, "CVE-2024-21381": {"epss_score": 0.0062, "epss_percentile": 0.69452}, "CVE-2024-21382": {"epss_score": 0.00957, "epss_percentile": 0.75935}, "CVE-2024-21383": {"epss_score": 0.00187, "epss_percentile": 0.40759}, "CVE-2024-21384": {"epss_score": 0.00525, "epss_percentile": 0.66376}, "CVE-2024-21385": {"epss_score": 0.00427, "epss_percentile": 0.61904}, "CVE-2024-21386": {"epss_score": 0.01655, "epss_percentile": 0.8159}, "CVE-2024-21387": {"epss_score": 0.04212, "epss_percentile": 0.88401}, "CVE-2024-21388": {"epss_score": 0.1936, "epss_percentile": 0.95168}, "CVE-2024-21389": {"epss_score": 0.00193, "epss_percentile": 0.41459}, "CVE-2024-21390": {"epss_score": 0.01093, "epss_percentile": 0.77479}, "CVE-2024-21391": {"epss_score": 0.0227, "epss_percentile": 0.84207}, "CVE-2024-21392": {"epss_score": 0.00554, "epss_percentile": 0.67449}, "CVE-2024-21393": {"epss_score": 0.00193, "epss_percentile": 0.41459}, "CVE-2024-21394": {"epss_score": 0.0021, "epss_percentile": 0.43501}, "CVE-2024-21395": {"epss_score": 0.00202, "epss_percentile": 0.42462}, "CVE-2024-21396": {"epss_score": 0.0021, "epss_percentile": 0.43501}, "CVE-2024-21397": {"epss_score": 0.00267, "epss_percentile": 0.5001}, "CVE-2024-21398": {"epss_score": 0.02257, "epss_percentile": 0.84174}, "CVE-2024-21399": {"epss_score": 0.00315, "epss_percentile": 0.54165}, "CVE-2024-21400": {"epss_score": 0.01051, "epss_percentile": 0.77079}, "CVE-2024-21401": {"epss_score": 0.02229, "epss_percentile": 0.84081}, "CVE-2024-21402": {"epss_score": 0.00453, "epss_percentile": 0.63239}, "CVE-2024-21403": {"epss_score": 0.01035, "epss_percentile": 0.76899}, "CVE-2024-21404": {"epss_score": 0.02163, "epss_percentile": 0.83833}, "CVE-2024-21405": {"epss_score": 0.00084, "epss_percentile": 0.25013}, "CVE-2024-21406": {"epss_score": 0.01257, "epss_percentile": 0.78943}, "CVE-2024-21407": {"epss_score": 0.06337, "epss_percentile": 0.90679}, "CVE-2024-21408": {"epss_score": 0.01814, "epss_percentile": 0.82378}, "CVE-2024-21409": {"epss_score": 0.54695, "epss_percentile": 0.97939}, "CVE-2024-21410": {"epss_score": 0.02475, "epss_percentile": 0.84859}, "CVE-2024-21411": {"epss_score": 0.03953, "epss_percentile": 0.88002}, "CVE-2024-21412": {"epss_score": 0.9377, "epss_percentile": 0.99842}, "CVE-2024-21413": {"epss_score": 0.93385, "epss_percentile": 0.99802}, "CVE-2024-21414": {"epss_score": 0.03034, "epss_percentile": 0.86258}, "CVE-2024-21415": {"epss_score": 0.03005, "epss_percentile": 0.86181}, "CVE-2024-21416": {"epss_score": 0.03075, "epss_percentile": 0.86358}, "CVE-2024-21417": {"epss_score": 0.01652, "epss_percentile": 0.81572}, "CVE-2024-21418": {"epss_score": 0.00574, "epss_percentile": 0.6808}, "CVE-2024-21419": {"epss_score": 0.00367, "epss_percentile": 0.58165}, "CVE-2024-21420": {"epss_score": 0.01502, "epss_percentile": 0.80724}, "CVE-2024-21421": {"epss_score": 0.0742, "epss_percentile": 0.91465}, "CVE-2024-21423": {"epss_score": 0.01386, "epss_percentile": 0.79911}, "CVE-2024-21424": {"epss_score": 0.00936, "epss_percentile": 0.75682}, "CVE-2024-21425": {"epss_score": 0.03034, "epss_percentile": 0.86258}, "CVE-2024-21426": {"epss_score": 0.00908, "epss_percentile": 0.7528}, "CVE-2024-21427": {"epss_score": 0.01825, "epss_percentile": 0.82431}, "CVE-2024-21428": {"epss_score": 0.02402, "epss_percentile": 0.84643}, "CVE-2024-21429": {"epss_score": 0.00233, "epss_percentile": 0.46038}, "CVE-2024-21430": {"epss_score": 0.00152, "epss_percentile": 0.36494}, "CVE-2024-21431": {"epss_score": 0.00401, "epss_percentile": 0.60208}, "CVE-2024-21432": {"epss_score": 0.00395, "epss_percentile": 0.59806}, "CVE-2024-21433": {"epss_score": 0.00833, "epss_percentile": 0.74087}, "CVE-2024-21434": {"epss_score": 0.00423, "epss_percentile": 0.61599}, "CVE-2024-21435": {"epss_score": 0.01298, "epss_percentile": 0.79276}, "CVE-2024-21436": {"epss_score": 0.00258, "epss_percentile": 0.48995}, "CVE-2024-21437": {"epss_score": 0.03014, "epss_percentile": 0.86206}, "CVE-2024-21438": {"epss_score": 0.03412, "epss_percentile": 0.87084}, "CVE-2024-21439": {"epss_score": 0.00066, "epss_percentile": 0.20912}, "CVE-2024-21440": {"epss_score": 0.01429, "epss_percentile": 0.80226}, "CVE-2024-21441": {"epss_score": 0.01171, "epss_percentile": 0.78217}, "CVE-2024-21442": {"epss_score": 0.0043, "epss_percentile": 0.62029}, "CVE-2024-21443": {"epss_score": 0.00453, "epss_percentile": 0.63209}, "CVE-2024-21444": {"epss_score": 0.00531, "epss_percentile": 0.66663}, "CVE-2024-21445": {"epss_score": 0.00072, "epss_percentile": 0.22392}, "CVE-2024-21446": {"epss_score": 0.00078, "epss_percentile": 0.23597}, "CVE-2024-21447": {"epss_score": 0.19625, "epss_percentile": 0.95216}, "CVE-2024-21448": {"epss_score": 0.00316, "epss_percentile": 0.54214}, "CVE-2024-21449": {"epss_score": 0.03034, "epss_percentile": 0.86258}, "CVE-2024-21450": {"epss_score": 0.01583, "epss_percentile": 0.8115}, "CVE-2024-21451": {"epss_score": 0.01056, "epss_percentile": 0.77127}, "CVE-2024-21452": {"epss_score": 0.00072, "epss_percentile": 0.22421}, "CVE-2024-21453": {"epss_score": 0.00124, "epss_percentile": 0.32457}, "CVE-2024-21454": {"epss_score": 0.00123, "epss_percentile": 0.32301}, "CVE-2024-21455": {"epss_score": 0.00152, "epss_percentile": 0.36406}, "CVE-2024-21456": {"epss_score": 0.00203, "epss_percentile": 0.42528}, "CVE-2024-21457": {"epss_score": 0.00151, "epss_percentile": 0.36322}, "CVE-2024-21458": {"epss_score": 0.00151, "epss_percentile": 0.36322}, "CVE-2024-21459": {"epss_score": 0.00142, "epss_percentile": 0.35025}, "CVE-2024-21460": {"epss_score": 0.001, "epss_percentile": 0.28499}, "CVE-2024-21461": {"epss_score": 0.00145, "epss_percentile": 0.35506}, "CVE-2024-21462": {"epss_score": 0.00082, "epss_percentile": 0.24435}, "CVE-2024-21463": {"epss_score": 0.00084, "epss_percentile": 0.24861}, "CVE-2024-21464": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-21465": {"epss_score": 0.00133, "epss_percentile": 0.3364}, "CVE-2024-21466": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-21467": {"epss_score": 0.00145, "epss_percentile": 0.35352}, "CVE-2024-21468": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2024-21469": {"epss_score": 0.00124, "epss_percentile": 0.32383}, "CVE-2024-21470": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2024-21471": {"epss_score": 0.00112, "epss_percentile": 0.30499}, "CVE-2024-21472": {"epss_score": 0.0006, "epss_percentile": 0.19168}, "CVE-2024-21473": {"epss_score": 0.00144, "epss_percentile": 0.35298}, "CVE-2024-21474": {"epss_score": 0.00082, "epss_percentile": 0.24573}, "CVE-2024-21475": {"epss_score": 0.00112, "epss_percentile": 0.30499}, "CVE-2024-21476": {"epss_score": 0.00112, "epss_percentile": 0.30499}, "CVE-2024-21477": {"epss_score": 0.00294, "epss_percentile": 0.52403}, "CVE-2024-21478": {"epss_score": 0.00086, "epss_percentile": 0.25247}, "CVE-2024-21479": {"epss_score": 0.00229, "epss_percentile": 0.45647}, "CVE-2024-21480": {"epss_score": 0.00133, "epss_percentile": 0.33698}, "CVE-2024-21481": {"epss_score": 0.00199, "epss_percentile": 0.4212}, "CVE-2024-21482": {"epss_score": 0.00018, "epss_percentile": 0.03649}, "CVE-2024-21483": {"epss_score": 0.00084, "epss_percentile": 0.2483}, "CVE-2024-21484": {"epss_score": 0.00177, "epss_percentile": 0.39517}, "CVE-2024-21485": {"epss_score": 0.00493, "epss_percentile": 0.65039}, "CVE-2024-21488": {"epss_score": 0.01689, "epss_percentile": 0.81766}, "CVE-2024-21489": {"epss_score": 0.00159, "epss_percentile": 0.37338}, "CVE-2024-21490": {"epss_score": 0.01669, "epss_percentile": 0.81664}, "CVE-2024-21491": {"epss_score": 0.00025, "epss_percentile": 0.06302}, "CVE-2024-21492": {"epss_score": 0.01212, "epss_percentile": 0.78556}, "CVE-2024-21493": {"epss_score": 0.00042, "epss_percentile": 0.12646}, "CVE-2024-21494": {"epss_score": 0.00027, "epss_percentile": 0.06786}, "CVE-2024-21495": {"epss_score": 0.00126, "epss_percentile": 0.32688}, "CVE-2024-21496": {"epss_score": 0.00137, "epss_percentile": 0.34212}, "CVE-2024-21497": {"epss_score": 0.00097, "epss_percentile": 0.27551}, "CVE-2024-21498": {"epss_score": 0.00085, "epss_percentile": 0.2507}, "CVE-2024-21499": {"epss_score": 0.00026, "epss_percentile": 0.06455}, "CVE-2024-21500": {"epss_score": 0.00048, "epss_percentile": 0.15149}, "CVE-2024-21501": {"epss_score": 0.01341, "epss_percentile": 0.79583}, "CVE-2024-21502": {"epss_score": 0.0009, "epss_percentile": 0.26001}, "CVE-2024-21503": {"epss_score": 0.0006, "epss_percentile": 0.1907}, "CVE-2024-21504": {"epss_score": 0.00091, "epss_percentile": 0.2639}, "CVE-2024-21505": {"epss_score": 0.00062, "epss_percentile": 0.19553}, "CVE-2024-21507": {"epss_score": 0.00322, "epss_percentile": 0.54788}, "CVE-2024-21508": {"epss_score": 0.55588, "epss_percentile": 0.97986}, "CVE-2024-21509": {"epss_score": 0.00585, "epss_percentile": 0.68403}, "CVE-2024-21510": {"epss_score": 0.00183, "epss_percentile": 0.4029}, "CVE-2024-21511": {"epss_score": 0.00127, "epss_percentile": 0.32848}, "CVE-2024-21512": {"epss_score": 0.68341, "epss_percentile": 0.98542}, "CVE-2024-21513": {"epss_score": 0.10171, "epss_percentile": 0.92874}, "CVE-2024-21514": {"epss_score": 0.46489, "epss_percentile": 0.97548}, "CVE-2024-21515": {"epss_score": 0.00305, "epss_percentile": 0.53369}, "CVE-2024-21516": {"epss_score": 0.00305, "epss_percentile": 0.53369}, "CVE-2024-21517": {"epss_score": 0.0025, "epss_percentile": 0.48121}, "CVE-2024-21518": {"epss_score": 0.0218, "epss_percentile": 0.83897}, "CVE-2024-21519": {"epss_score": 0.00277, "epss_percentile": 0.50832}, "CVE-2024-21520": {"epss_score": 0.16271, "epss_percentile": 0.94607}, "CVE-2024-21521": {"epss_score": 0.00222, "epss_percentile": 0.44732}, "CVE-2024-21522": {"epss_score": 0.00291, "epss_percentile": 0.52196}, "CVE-2024-21523": {"epss_score": 0.00216, "epss_percentile": 0.44221}, "CVE-2024-21524": {"epss_score": 0.00211, "epss_percentile": 0.43643}, "CVE-2024-21525": {"epss_score": 0.001, "epss_percentile": 0.28521}, "CVE-2024-21526": {"epss_score": 0.00071, "epss_percentile": 0.22179}, "CVE-2024-21527": {"epss_score": 0.00122, "epss_percentile": 0.32088}, "CVE-2024-21528": {"epss_score": 0.00048, "epss_percentile": 0.15144}, "CVE-2024-21529": {"epss_score": 0.00073, "epss_percentile": 0.2267}, "CVE-2024-21530": {"epss_score": 0.00029, "epss_percentile": 0.07617}, "CVE-2024-21531": {"epss_score": 0.0007, "epss_percentile": 0.21943}, "CVE-2024-21532": {"epss_score": 0.00249, "epss_percentile": 0.48022}, "CVE-2024-21533": {"epss_score": 0.00037, "epss_percentile": 0.10923}, "CVE-2024-21534": {"epss_score": 0.91835, "epss_percentile": 0.99671}, "CVE-2024-21535": {"epss_score": 0.00145, "epss_percentile": 0.35352}, "CVE-2024-21536": {"epss_score": 0.00269, "epss_percentile": 0.50187}, "CVE-2024-21537": {"epss_score": 0.00367, "epss_percentile": 0.58114}, "CVE-2024-21538": {"epss_score": 0.00067, "epss_percentile": 0.21094}, "CVE-2024-21539": {"epss_score": 0.00213, "epss_percentile": 0.43928}, "CVE-2024-21541": {"epss_score": 0.00234, "epss_percentile": 0.46173}, "CVE-2024-21542": {"epss_score": 0.03175, "epss_percentile": 0.86567}, "CVE-2024-21543": {"epss_score": 0.00105, "epss_percentile": 0.29365}, "CVE-2024-21544": {"epss_score": 0.00058, "epss_percentile": 0.18515}, "CVE-2024-21545": {"epss_score": 0.00109, "epss_percentile": 0.2991}, "CVE-2024-21546": {"epss_score": 0.00382, "epss_percentile": 0.59059}, "CVE-2024-21547": {"epss_score": 0.00191, "epss_percentile": 0.41186}, "CVE-2024-21548": {"epss_score": 0.00123, "epss_percentile": 0.32185}, "CVE-2024-21549": {"epss_score": 0.00065, "epss_percentile": 0.20651}, "CVE-2024-21550": {"epss_score": 0.00125, "epss_percentile": 0.32603}, "CVE-2024-21552": {"epss_score": 0.00224, "epss_percentile": 0.45026}, "CVE-2024-21571": {"epss_score": 0.00171, "epss_percentile": 0.38782}, "CVE-2024-21574": {"epss_score": 0.01189, "epss_percentile": 0.78372}, "CVE-2024-21575": {"epss_score": 0.0044, "epss_percentile": 0.62632}, "CVE-2024-21576": {"epss_score": 0.0024, "epss_percentile": 0.46954}, "CVE-2024-21577": {"epss_score": 0.0024, "epss_percentile": 0.46954}, "CVE-2024-21583": {"epss_score": 0.00181, "epss_percentile": 0.40099}, "CVE-2024-21584": {"epss_score": 0.00725, "epss_percentile": 0.72063}, "CVE-2024-21585": {"epss_score": 0.0015, "epss_percentile": 0.36178}, "CVE-2024-21586": {"epss_score": 0.00212, "epss_percentile": 0.43753}, "CVE-2024-21587": {"epss_score": 0.00051, "epss_percentile": 0.1623}, "CVE-2024-21589": {"epss_score": 0.00178, "epss_percentile": 0.39638}, "CVE-2024-21590": {"epss_score": 0.0004, "epss_percentile": 0.12188}, "CVE-2024-21591": {"epss_score": 0.23476, "epss_percentile": 0.95783}, "CVE-2024-21593": {"epss_score": 0.00031, "epss_percentile": 0.08474}, "CVE-2024-21594": {"epss_score": 0.00023, "epss_percentile": 0.05357}, "CVE-2024-21595": {"epss_score": 0.00112, "epss_percentile": 0.30485}, "CVE-2024-21596": {"epss_score": 0.00075, "epss_percentile": 0.2292}, "CVE-2024-21597": {"epss_score": 0.00035, "epss_percentile": 0.09918}, "CVE-2024-21598": {"epss_score": 0.00112, "epss_percentile": 0.30485}, "CVE-2024-21599": {"epss_score": 0.00051, "epss_percentile": 0.1628}, "CVE-2024-21600": {"epss_score": 0.00041, "epss_percentile": 0.12408}, "CVE-2024-21601": {"epss_score": 0.00234, "epss_percentile": 0.46084}, "CVE-2024-21602": {"epss_score": 0.00187, "epss_percentile": 0.40796}, "CVE-2024-21603": {"epss_score": 0.00073, "epss_percentile": 0.22644}, "CVE-2024-21604": {"epss_score": 0.00285, "epss_percentile": 0.51685}, "CVE-2024-21605": {"epss_score": 0.0006, "epss_percentile": 0.18968}, "CVE-2024-21606": {"epss_score": 0.00304, "epss_percentile": 0.53285}, "CVE-2024-21607": {"epss_score": 0.0004, "epss_percentile": 0.11867}, "CVE-2024-21609": {"epss_score": 0.00064, "epss_percentile": 0.20349}, "CVE-2024-21610": {"epss_score": 0.00065, "epss_percentile": 0.20603}, "CVE-2024-21611": {"epss_score": 0.00242, "epss_percentile": 0.47366}, "CVE-2024-21612": {"epss_score": 0.00187, "epss_percentile": 0.40729}, "CVE-2024-21613": {"epss_score": 0.00047, "epss_percentile": 0.14888}, "CVE-2024-21614": {"epss_score": 0.00502, "epss_percentile": 0.65403}, "CVE-2024-21615": {"epss_score": 0.00035, "epss_percentile": 0.09814}, "CVE-2024-21616": {"epss_score": 0.00206, "epss_percentile": 0.42933}, "CVE-2024-21617": {"epss_score": 0.00043, "epss_percentile": 0.13308}, "CVE-2024-21618": {"epss_score": 0.00124, "epss_percentile": 0.32428}, "CVE-2024-21619": {"epss_score": 0.00249, "epss_percentile": 0.48014}, "CVE-2024-21620": {"epss_score": 0.0048, "epss_percentile": 0.64473}, "CVE-2024-21622": {"epss_score": 0.00103, "epss_percentile": 0.28898}, "CVE-2024-21623": {"epss_score": 0.0132, "epss_percentile": 0.79438}, "CVE-2024-21624": {"epss_score": 0.00262, "epss_percentile": 0.49348}, "CVE-2024-21625": {"epss_score": 0.00886, "epss_percentile": 0.74953}, "CVE-2024-21626": {"epss_score": 0.04099, "epss_percentile": 0.88256}, "CVE-2024-21627": {"epss_score": 0.00727, "epss_percentile": 0.72094}, "CVE-2024-21628": {"epss_score": 0.00293, "epss_percentile": 0.52343}, "CVE-2024-21629": {"epss_score": 0.00635, "epss_percentile": 0.69817}, "CVE-2024-21630": {"epss_score": 0.00109, "epss_percentile": 0.29999}, "CVE-2024-21631": {"epss_score": 0.00401, "epss_percentile": 0.60231}, "CVE-2024-21632": {"epss_score": 0.00239, "epss_percentile": 0.46905}, "CVE-2024-21633": {"epss_score": 0.73456, "epss_percentile": 0.98757}, "CVE-2024-21634": {"epss_score": 0.0033, "epss_percentile": 0.55417}, "CVE-2024-21635": {"epss_score": 0.00038, "epss_percentile": 0.1113}, "CVE-2024-21636": {"epss_score": 0.00501, "epss_percentile": 0.6535}, "CVE-2024-21637": {"epss_score": 0.00125, "epss_percentile": 0.32574}, "CVE-2024-21638": {"epss_score": 0.03548, "epss_percentile": 0.87333}, "CVE-2024-21639": {"epss_score": 0.00211, "epss_percentile": 0.43715}, "CVE-2024-21640": {"epss_score": 0.00246, "epss_percentile": 0.47785}, "CVE-2024-21641": {"epss_score": 0.35777, "epss_percentile": 0.96934}, "CVE-2024-21642": {"epss_score": 0.00311, "epss_percentile": 0.53817}, "CVE-2024-21643": {"epss_score": 0.0063, "epss_percentile": 0.69695}, "CVE-2024-21644": {"epss_score": 0.8764, "epss_percentile": 0.99436}, "CVE-2024-21645": {"epss_score": 0.73493, "epss_percentile": 0.98758}, "CVE-2024-21646": {"epss_score": 0.01597, "epss_percentile": 0.81243}, "CVE-2024-21647": {"epss_score": 0.01983, "epss_percentile": 0.83149}, "CVE-2024-21648": {"epss_score": 0.0034, "epss_percentile": 0.56272}, "CVE-2024-21649": {"epss_score": 0.0481, "epss_percentile": 0.89164}, "CVE-2024-21650": {"epss_score": 0.92865, "epss_percentile": 0.99756}, "CVE-2024-21651": {"epss_score": 0.00379, "epss_percentile": 0.58902}, "CVE-2024-21652": {"epss_score": 0.00066, "epss_percentile": 0.20708}, "CVE-2024-21653": {"epss_score": 0.00226, "epss_percentile": 0.45356}, "CVE-2024-21654": {"epss_score": 0.00129, "epss_percentile": 0.33219}, "CVE-2024-21655": {"epss_score": 0.00092, "epss_percentile": 0.26587}, "CVE-2024-21658": {"epss_score": 0.00212, "epss_percentile": 0.4381}, "CVE-2024-21661": {"epss_score": 0.02181, "epss_percentile": 0.83903}, "CVE-2024-21662": {"epss_score": 0.00139, "epss_percentile": 0.34543}, "CVE-2024-21663": {"epss_score": 0.01336, "epss_percentile": 0.79557}, "CVE-2024-21664": {"epss_score": 0.00128, "epss_percentile": 0.33026}, "CVE-2024-21665": {"epss_score": 6e-05, "epss_percentile": 0.00269}, "CVE-2024-21666": {"epss_score": 5e-05, "epss_percentile": 0.00202}, "CVE-2024-21667": {"epss_score": 0.00011, "epss_percentile": 0.00974}, "CVE-2024-21668": {"epss_score": 0.00333, "epss_percentile": 0.55645}, "CVE-2024-21669": {"epss_score": 0.00136, "epss_percentile": 0.34091}, "CVE-2024-21670": {"epss_score": 0.0012, "epss_percentile": 0.31756}, "CVE-2024-21671": {"epss_score": 0.0022, "epss_percentile": 0.44587}, "CVE-2024-21672": {"epss_score": 0.04274, "epss_percentile": 0.88481}, "CVE-2024-21673": {"epss_score": 0.04905, "epss_percentile": 0.89276}, "CVE-2024-21674": {"epss_score": 0.01305, "epss_percentile": 0.79329}, "CVE-2024-21677": {"epss_score": 0.01959, "epss_percentile": 0.8305}, "CVE-2024-21678": {"epss_score": 0.01538, "epss_percentile": 0.80931}, "CVE-2024-21682": {"epss_score": 0.00307, "epss_percentile": 0.53522}, "CVE-2024-21683": {"epss_score": 0.94054, "epss_percentile": 0.99893}, "CVE-2024-21684": {"epss_score": 0.00666, "epss_percentile": 0.70678}, "CVE-2024-21685": {"epss_score": 0.00984, "epss_percentile": 0.76316}, "CVE-2024-21686": {"epss_score": 0.02884, "epss_percentile": 0.85908}, "CVE-2024-21687": {"epss_score": 0.01063, "epss_percentile": 0.77192}, "CVE-2024-21689": {"epss_score": 0.37686, "epss_percentile": 0.97064}, "CVE-2024-21690": {"epss_score": 0.00754, "epss_percentile": 0.72699}, "CVE-2024-21697": {"epss_score": 0.02211, "epss_percentile": 0.84014}, "CVE-2024-21703": {"epss_score": 0.00031, "epss_percentile": 0.08551}, "CVE-2024-21722": {"epss_score": 5e-05, "epss_percentile": 0.00188}, "CVE-2024-21723": {"epss_score": 5e-05, "epss_percentile": 0.00198}, "CVE-2024-21724": {"epss_score": 0.00036, "epss_percentile": 0.10269}, "CVE-2024-21725": {"epss_score": 0.01231, "epss_percentile": 0.78733}, "CVE-2024-21726": {"epss_score": 0.00264, "epss_percentile": 0.49573}, "CVE-2024-21727": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2024-21728": {"epss_score": 0.00071, "epss_percentile": 0.22226}, "CVE-2024-21729": {"epss_score": 0.00028, "epss_percentile": 0.07223}, "CVE-2024-21730": {"epss_score": 0.00038, "epss_percentile": 0.11108}, "CVE-2024-21731": {"epss_score": 0.00038, "epss_percentile": 0.11108}, "CVE-2024-21732": {"epss_score": 0.00118, "epss_percentile": 0.31411}, "CVE-2024-21733": {"epss_score": 0.67964, "epss_percentile": 0.98527}, "CVE-2024-21734": {"epss_score": 0.00154, "epss_percentile": 0.36673}, "CVE-2024-21735": {"epss_score": 0.00147, "epss_percentile": 0.35652}, "CVE-2024-21736": {"epss_score": 0.0006, "epss_percentile": 0.19154}, "CVE-2024-21737": {"epss_score": 0.00222, "epss_percentile": 0.44714}, "CVE-2024-21738": {"epss_score": 0.00198, "epss_percentile": 0.42085}, "CVE-2024-21739": {"epss_score": 0.00123, "epss_percentile": 0.3221}, "CVE-2024-21740": {"epss_score": 0.00057, "epss_percentile": 0.18235}, "CVE-2024-21741": {"epss_score": 0.00152, "epss_percentile": 0.3641}, "CVE-2024-21742": {"epss_score": 0.00658, "epss_percentile": 0.70488}, "CVE-2024-21743": {"epss_score": 0.00103, "epss_percentile": 0.29083}, "CVE-2024-21744": {"epss_score": 0.00169, "epss_percentile": 0.38617}, "CVE-2024-21745": {"epss_score": 0.00152, "epss_percentile": 0.36372}, "CVE-2024-21746": {"epss_score": 0.00108, "epss_percentile": 0.29873}, "CVE-2024-21747": {"epss_score": 0.00242, "epss_percentile": 0.47354}, "CVE-2024-21748": {"epss_score": 0.0008, "epss_percentile": 0.2412}, "CVE-2024-21749": {"epss_score": 0.00122, "epss_percentile": 0.32018}, "CVE-2024-21750": {"epss_score": 0.0011, "epss_percentile": 0.30102}, "CVE-2024-21751": {"epss_score": 0.00158, "epss_percentile": 0.37285}, "CVE-2024-21752": {"epss_score": 0.00071, "epss_percentile": 0.22184}, "CVE-2024-21753": {"epss_score": 0.00469, "epss_percentile": 0.63949}, "CVE-2024-21754": {"epss_score": 0.05708, "epss_percentile": 0.90138}, "CVE-2024-21755": {"epss_score": 0.01045, "epss_percentile": 0.77015}, "CVE-2024-21756": {"epss_score": 0.01045, "epss_percentile": 0.77015}, "CVE-2024-21757": {"epss_score": 0.00141, "epss_percentile": 0.34899}, "CVE-2024-21758": {"epss_score": 0.00028, "epss_percentile": 0.07529}, "CVE-2024-21759": {"epss_score": 0.0022, "epss_percentile": 0.4459}, "CVE-2024-21760": {"epss_score": 0.0021, "epss_percentile": 0.43446}, "CVE-2024-21761": {"epss_score": 0.00239, "epss_percentile": 0.469}, "CVE-2024-21762": {"epss_score": 0.9291, "epss_percentile": 0.99759}, "CVE-2024-21763": {"epss_score": 0.00362, "epss_percentile": 0.57769}, "CVE-2024-21764": {"epss_score": 0.00082, "epss_percentile": 0.24445}, "CVE-2024-21765": {"epss_score": 0.00027, "epss_percentile": 0.06926}, "CVE-2024-21766": {"epss_score": 0.00028, "epss_percentile": 0.07285}, "CVE-2024-21767": {"epss_score": 0.00038, "epss_percentile": 0.11059}, "CVE-2024-21769": {"epss_score": 0.00056, "epss_percentile": 0.17776}, "CVE-2024-21771": {"epss_score": 0.00267, "epss_percentile": 0.49996}, "CVE-2024-21772": {"epss_score": 0.00087, "epss_percentile": 0.25632}, "CVE-2024-21773": {"epss_score": 0.00179, "epss_percentile": 0.3982}, "CVE-2024-21774": {"epss_score": 0.00082, "epss_percentile": 0.2454}, "CVE-2024-21775": {"epss_score": 0.00624, "epss_percentile": 0.69563}, "CVE-2024-21777": {"epss_score": 0.00113, "epss_percentile": 0.30681}, "CVE-2024-21778": {"epss_score": 0.00528, "epss_percentile": 0.66556}, "CVE-2024-21780": {"epss_score": 0.01145, "epss_percentile": 0.77993}, "CVE-2024-21781": {"epss_score": 0.00043, "epss_percentile": 0.1314}, "CVE-2024-21782": {"epss_score": 0.00069, "epss_percentile": 0.21481}, "CVE-2024-21783": {"epss_score": 0.00124, "epss_percentile": 0.32375}, "CVE-2024-21784": {"epss_score": 0.00064, "epss_percentile": 0.20156}, "CVE-2024-21785": {"epss_score": 0.01002, "epss_percentile": 0.76503}, "CVE-2024-21786": {"epss_score": 0.00314, "epss_percentile": 0.5408}, "CVE-2024-21787": {"epss_score": 0.00014, "epss_percentile": 0.02051}, "CVE-2024-21788": {"epss_score": 0.00083, "epss_percentile": 0.24768}, "CVE-2024-21789": {"epss_score": 0.00267, "epss_percentile": 0.49996}, "CVE-2024-21791": {"epss_score": 0.03, "epss_percentile": 0.86164}, "CVE-2024-21792": {"epss_score": 0.00047, "epss_percentile": 0.14892}, "CVE-2024-21793": {"epss_score": 0.8492, "epss_percentile": 0.99311}, "CVE-2024-21794": {"epss_score": 0.00029, "epss_percentile": 0.07692}, "CVE-2024-21795": {"epss_score": 0.00889, "epss_percentile": 0.75022}, "CVE-2024-21796": {"epss_score": 0.00021, "epss_percentile": 0.04765}, "CVE-2024-21797": {"epss_score": 0.0274, "epss_percentile": 0.85559}, "CVE-2024-21798": {"epss_score": 0.00388, "epss_percentile": 0.59396}, "CVE-2024-21799": {"epss_score": 0.00059, "epss_percentile": 0.18844}, "CVE-2024-21801": {"epss_score": 0.00018, "epss_percentile": 0.03824}, "CVE-2024-21802": {"epss_score": 0.00629, "epss_percentile": 0.69673}, "CVE-2024-21803": {"epss_score": 0.00036, "epss_percentile": 0.10164}, "CVE-2024-21805": {"epss_score": 0.00116, "epss_percentile": 0.31038}, "CVE-2024-21806": {"epss_score": 0.00047, "epss_percentile": 0.14701}, "CVE-2024-21807": {"epss_score": 0.00104, "epss_percentile": 0.29211}, "CVE-2024-21808": {"epss_score": 0.00124, "epss_percentile": 0.32375}, "CVE-2024-21809": {"epss_score": 0.00138, "epss_percentile": 0.34355}, "CVE-2024-21810": {"epss_score": 0.00125, "epss_percentile": 0.32513}, "CVE-2024-21812": {"epss_score": 0.00318, "epss_percentile": 0.54447}, "CVE-2024-21813": {"epss_score": 0.0002, "epss_percentile": 0.04427}, "CVE-2024-21814": {"epss_score": 0.00162, "epss_percentile": 0.37621}, "CVE-2024-21815": {"epss_score": 0.00098, "epss_percentile": 0.27719}, "CVE-2024-21816": {"epss_score": 0.00047, "epss_percentile": 0.14913}, "CVE-2024-21818": {"epss_score": 0.00079, "epss_percentile": 0.23871}, "CVE-2024-21820": {"epss_score": 0.00012, "epss_percentile": 0.01337}, "CVE-2024-21821": {"epss_score": 0.00098, "epss_percentile": 0.27697}, "CVE-2024-21823": {"epss_score": 0.00058, "epss_percentile": 0.18376}, "CVE-2024-21824": {"epss_score": 0.00048, "epss_percentile": 0.15106}, "CVE-2024-21825": {"epss_score": 0.00253, "epss_percentile": 0.48469}, "CVE-2024-21826": {"epss_score": 0.00062, "epss_percentile": 0.19552}, "CVE-2024-21827": {"epss_score": 0.00153, "epss_percentile": 0.36509}, "CVE-2024-21828": {"epss_score": 0.00088, "epss_percentile": 0.2571}, "CVE-2024-21829": {"epss_score": 0.00064, "epss_percentile": 0.2031}, "CVE-2024-21830": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-21831": {"epss_score": 0.00654, "epss_percentile": 0.70346}, "CVE-2024-21832": {"epss_score": 0.0014, "epss_percentile": 0.34668}, "CVE-2024-21833": {"epss_score": 0.00147, "epss_percentile": 0.35691}, "CVE-2024-21834": {"epss_score": 0.00079, "epss_percentile": 0.23965}, "CVE-2024-21835": {"epss_score": 0.00114, "epss_percentile": 0.30738}, "CVE-2024-21836": {"epss_score": 0.00197, "epss_percentile": 0.41957}, "CVE-2024-21837": {"epss_score": 0.00209, "epss_percentile": 0.43373}, "CVE-2024-21838": {"epss_score": 0.0032, "epss_percentile": 0.5462}, "CVE-2024-21840": {"epss_score": 0.00032, "epss_percentile": 0.08853}, "CVE-2024-21841": {"epss_score": 0.00079, "epss_percentile": 0.23871}, "CVE-2024-21843": {"epss_score": 0.00079, "epss_percentile": 0.23871}, "CVE-2024-21844": {"epss_score": 0.00056, "epss_percentile": 0.17847}, "CVE-2024-21845": {"epss_score": 0.00032, "epss_percentile": 0.0883}, "CVE-2024-21846": {"epss_score": 0.00097, "epss_percentile": 0.27457}, "CVE-2024-21848": {"epss_score": 0.0023, "epss_percentile": 0.45718}, "CVE-2024-21849": {"epss_score": 0.00308, "epss_percentile": 0.53582}, "CVE-2024-21850": {"epss_score": 0.00075, "epss_percentile": 0.22986}, "CVE-2024-21851": {"epss_score": 0.00032, "epss_percentile": 0.0883}, "CVE-2024-21852": {"epss_score": 0.01151, "epss_percentile": 0.7804}, "CVE-2024-21853": {"epss_score": 0.00027, "epss_percentile": 0.06808}, "CVE-2024-21855": {"epss_score": 0.00304, "epss_percentile": 0.53243}, "CVE-2024-21857": {"epss_score": 0.00046, "epss_percentile": 0.1411}, "CVE-2024-21859": {"epss_score": 0.00027, "epss_percentile": 0.06807}, "CVE-2024-21860": {"epss_score": 0.00044, "epss_percentile": 0.13553}, "CVE-2024-21861": {"epss_score": 0.00154, "epss_percentile": 0.36668}, "CVE-2024-21862": {"epss_score": 0.00209, "epss_percentile": 0.43373}, "CVE-2024-21863": {"epss_score": 0.00024, "epss_percentile": 0.05804}, "CVE-2024-21864": {"epss_score": 0.00291, "epss_percentile": 0.52177}, "CVE-2024-21865": {"epss_score": 0.00033, "epss_percentile": 0.0915}, "CVE-2024-21866": {"epss_score": 0.00074, "epss_percentile": 0.2287}, "CVE-2024-21869": {"epss_score": 0.00028, "epss_percentile": 0.07214}, "CVE-2024-21870": {"epss_score": 0.00146, "epss_percentile": 0.35572}, "CVE-2024-21871": {"epss_score": 0.00058, "epss_percentile": 0.18473}, "CVE-2024-21872": {"epss_score": 0.00039, "epss_percentile": 0.11698}, "CVE-2024-21875": {"epss_score": 0.00026, "epss_percentile": 0.06454}, "CVE-2024-21876": {"epss_score": 0.00364, "epss_percentile": 0.57926}, "CVE-2024-21877": {"epss_score": 0.00213, "epss_percentile": 0.43877}, "CVE-2024-21878": {"epss_score": 0.00341, "epss_percentile": 0.56288}, "CVE-2024-21879": {"epss_score": 0.03104, "epss_percentile": 0.86414}, "CVE-2024-21880": {"epss_score": 0.01231, "epss_percentile": 0.78735}, "CVE-2024-21881": {"epss_score": 0.00041, "epss_percentile": 0.12403}, "CVE-2024-21885": {"epss_score": 0.00239, "epss_percentile": 0.46879}, "CVE-2024-21886": {"epss_score": 0.00239, "epss_percentile": 0.46879}, "CVE-2024-21887": {"epss_score": 0.94412, "epss_percentile": 0.99976}, "CVE-2024-21888": {"epss_score": 0.64004, "epss_percentile": 0.98358}, "CVE-2024-21890": {"epss_score": 0.01045, "epss_percentile": 0.77017}, "CVE-2024-21891": {"epss_score": 0.0017, "epss_percentile": 0.38717}, "CVE-2024-21892": {"epss_score": 0.00248, "epss_percentile": 0.47959}, "CVE-2024-21893": {"epss_score": 0.94319, "epss_percentile": 0.99946}, "CVE-2024-21894": {"epss_score": 0.11025, "epss_percentile": 0.93194}, "CVE-2024-21896": {"epss_score": 0.01194, "epss_percentile": 0.78412}, "CVE-2024-21897": {"epss_score": 0.00723, "epss_percentile": 0.72011}, "CVE-2024-21898": {"epss_score": 0.01465, "epss_percentile": 0.8046}, "CVE-2024-21899": {"epss_score": 0.10587, "epss_percentile": 0.93036}, "CVE-2024-21900": {"epss_score": 0.08842, "epss_percentile": 0.92281}, "CVE-2024-21901": {"epss_score": 0.05105, "epss_percentile": 0.89505}, "CVE-2024-21902": {"epss_score": 0.00482, "epss_percentile": 0.64546}, "CVE-2024-21903": {"epss_score": 0.00213, "epss_percentile": 0.43851}, "CVE-2024-21904": {"epss_score": 0.00376, "epss_percentile": 0.58661}, "CVE-2024-21905": {"epss_score": 0.00183, "epss_percentile": 0.40338}, "CVE-2024-21906": {"epss_score": 0.00213, "epss_percentile": 0.43851}, "CVE-2024-21907": {"epss_score": 0.02918, "epss_percentile": 0.85985}, "CVE-2024-21908": {"epss_score": 0.00365, "epss_percentile": 0.57961}, "CVE-2024-21909": {"epss_score": 0.00274, "epss_percentile": 0.50579}, "CVE-2024-21910": {"epss_score": 0.01211, "epss_percentile": 0.78556}, "CVE-2024-21911": {"epss_score": 0.01596, "epss_percentile": 0.81242}, "CVE-2024-21912": {"epss_score": 0.00025, "epss_percentile": 0.06038}, "CVE-2024-21913": {"epss_score": 0.00039, "epss_percentile": 0.11769}, "CVE-2024-21914": {"epss_score": 0.00071, "epss_percentile": 0.22124}, "CVE-2024-21915": {"epss_score": 0.00431, "epss_percentile": 0.62063}, "CVE-2024-21916": {"epss_score": 0.00443, "epss_percentile": 0.62757}, "CVE-2024-21917": {"epss_score": 0.00205, "epss_percentile": 0.42713}, "CVE-2024-21918": {"epss_score": 0.00044, "epss_percentile": 0.13493}, "CVE-2024-21919": {"epss_score": 0.00044, "epss_percentile": 0.13493}, "CVE-2024-21920": {"epss_score": 0.0004, "epss_percentile": 0.11943}, "CVE-2024-21922": {"epss_score": 0.00016, "epss_percentile": 0.02805}, "CVE-2024-21923": {"epss_score": 0.00015, "epss_percentile": 0.0223}, "CVE-2024-21924": {"epss_score": 0.00039, "epss_percentile": 0.11665}, "CVE-2024-21925": {"epss_score": 0.00039, "epss_percentile": 0.11665}, "CVE-2024-21927": {"epss_score": 0.00039, "epss_percentile": 0.11633}, "CVE-2024-21935": {"epss_score": 0.00029, "epss_percentile": 0.0778}, "CVE-2024-21937": {"epss_score": 0.00074, "epss_percentile": 0.22695}, "CVE-2024-21938": {"epss_score": 0.00074, "epss_percentile": 0.22695}, "CVE-2024-21939": {"epss_score": 0.00074, "epss_percentile": 0.22695}, "CVE-2024-21945": {"epss_score": 0.00074, "epss_percentile": 0.22695}, "CVE-2024-21946": {"epss_score": 0.00074, "epss_percentile": 0.22695}, "CVE-2024-21947": {"epss_score": 0.00022, "epss_percentile": 0.05192}, "CVE-2024-21949": {"epss_score": 0.00081, "epss_percentile": 0.24322}, "CVE-2024-21957": {"epss_score": 0.00054, "epss_percentile": 0.17273}, "CVE-2024-21958": {"epss_score": 0.00054, "epss_percentile": 0.17273}, "CVE-2024-21960": {"epss_score": 0.00013, "epss_percentile": 0.01521}, "CVE-2024-21966": {"epss_score": 0.00024, "epss_percentile": 0.05746}, "CVE-2024-21970": {"epss_score": 0.00021, "epss_percentile": 0.04724}, "CVE-2024-21971": {"epss_score": 0.00029, "epss_percentile": 0.07665}, "CVE-2024-21972": {"epss_score": 0.00039, "epss_percentile": 0.11667}, "CVE-2024-21974": {"epss_score": 0.00049, "epss_percentile": 0.15545}, "CVE-2024-21975": {"epss_score": 0.00049, "epss_percentile": 0.15545}, "CVE-2024-21976": {"epss_score": 0.00036, "epss_percentile": 0.10519}, "CVE-2024-21977": {"epss_score": 0.00019, "epss_percentile": 0.04116}, "CVE-2024-21978": {"epss_score": 0.01654, "epss_percentile": 0.81587}, "CVE-2024-21979": {"epss_score": 0.00039, "epss_percentile": 0.11667}, "CVE-2024-21980": {"epss_score": 0.02331, "epss_percentile": 0.84402}, "CVE-2024-21981": {"epss_score": 0.00051, "epss_percentile": 0.16071}, "CVE-2024-21982": {"epss_score": 0.00366, "epss_percentile": 0.58073}, "CVE-2024-21983": {"epss_score": 0.00219, "epss_percentile": 0.4444}, "CVE-2024-21984": {"epss_score": 0.00218, "epss_percentile": 0.44431}, "CVE-2024-21985": {"epss_score": 0.00168, "epss_percentile": 0.38453}, "CVE-2024-21987": {"epss_score": 0.00112, "epss_percentile": 0.30577}, "CVE-2024-21988": {"epss_score": 0.00061, "epss_percentile": 0.19247}, "CVE-2024-21989": {"epss_score": 0.00185, "epss_percentile": 0.40546}, "CVE-2024-21990": {"epss_score": 0.00203, "epss_percentile": 0.42495}, "CVE-2024-21993": {"epss_score": 0.00137, "epss_percentile": 0.34258}, "CVE-2024-21994": {"epss_score": 0.00249, "epss_percentile": 0.48059}, "CVE-2024-22002": {"epss_score": 0.02369, "epss_percentile": 0.84523}, "CVE-2024-22004": {"epss_score": 0.0007, "epss_percentile": 0.21692}, "CVE-2024-22005": {"epss_score": 5e-05, "epss_percentile": 0.0022}, "CVE-2024-22006": {"epss_score": 0.00083, "epss_percentile": 0.24824}, "CVE-2024-22007": {"epss_score": 0.00029, "epss_percentile": 0.07753}, "CVE-2024-22008": {"epss_score": 0.00019, "epss_percentile": 0.04202}, "CVE-2024-22009": {"epss_score": 0.00024, "epss_percentile": 0.05793}, "CVE-2024-22010": {"epss_score": 0.0003, "epss_percentile": 0.08211}, "CVE-2024-22011": {"epss_score": 0.00503, "epss_percentile": 0.65447}, "CVE-2024-22012": {"epss_score": 0.00016, "epss_percentile": 0.02796}, "CVE-2024-22013": {"epss_score": 0.00168, "epss_percentile": 0.38453}, "CVE-2024-22014": {"epss_score": 0.00395, "epss_percentile": 0.59831}, "CVE-2024-22015": {"epss_score": 0.00067, "epss_percentile": 0.20979}, "CVE-2024-22016": {"epss_score": 0.00047, "epss_percentile": 0.14494}, "CVE-2024-22017": {"epss_score": 0.00637, "epss_percentile": 0.69887}, "CVE-2024-22018": {"epss_score": 0.00212, "epss_percentile": 0.43727}, "CVE-2024-22019": {"epss_score": 0.00196, "epss_percentile": 0.41739}, "CVE-2024-22020": {"epss_score": 0.00145, "epss_percentile": 0.35513}, "CVE-2024-22021": {"epss_score": 0.00334, "epss_percentile": 0.55713}, "CVE-2024-22022": {"epss_score": 0.00638, "epss_percentile": 0.69923}, "CVE-2024-22023": {"epss_score": 0.00433, "epss_percentile": 0.62188}, "CVE-2024-22024": {"epss_score": 0.94249, "epss_percentile": 0.99926}, "CVE-2024-22025": {"epss_score": 0.00404, "epss_percentile": 0.60427}, "CVE-2024-22026": {"epss_score": 0.0024, "epss_percentile": 0.47228}, "CVE-2024-22027": {"epss_score": 0.0051, "epss_percentile": 0.658}, "CVE-2024-22028": {"epss_score": 0.00044, "epss_percentile": 0.13505}, "CVE-2024-22029": {"epss_score": 0.00014, "epss_percentile": 0.01999}, "CVE-2024-22030": {"epss_score": 0.00068, "epss_percentile": 0.21379}, "CVE-2024-22032": {"epss_score": 0.00047, "epss_percentile": 0.14659}, "CVE-2024-22033": {"epss_score": 0.00157, "epss_percentile": 0.37116}, "CVE-2024-22034": {"epss_score": 0.00021, "epss_percentile": 0.048}, "CVE-2024-22036": {"epss_score": 0.00111, "epss_percentile": 0.30404}, "CVE-2024-22037": {"epss_score": 0.00021, "epss_percentile": 0.04795}, "CVE-2024-22038": {"epss_score": 0.00025, "epss_percentile": 0.0626}, "CVE-2024-22039": {"epss_score": 0.08463, "epss_percentile": 0.92066}, "CVE-2024-22040": {"epss_score": 0.00328, "epss_percentile": 0.55166}, "CVE-2024-22041": {"epss_score": 0.00203, "epss_percentile": 0.42575}, "CVE-2024-22042": {"epss_score": 0.00065, "epss_percentile": 0.2046}, "CVE-2024-22043": {"epss_score": 0.0004, "epss_percentile": 0.11965}, "CVE-2024-22044": {"epss_score": 0.00297, "epss_percentile": 0.52759}, "CVE-2024-22045": {"epss_score": 0.00333, "epss_percentile": 0.55646}, "CVE-2024-22047": {"epss_score": 0.00968, "epss_percentile": 0.76079}, "CVE-2024-22048": {"epss_score": 0.01592, "epss_percentile": 0.81224}, "CVE-2024-22049": {"epss_score": 0.01151, "epss_percentile": 0.7804}, "CVE-2024-22050": {"epss_score": 0.00382, "epss_percentile": 0.59075}, "CVE-2024-22051": {"epss_score": 0.07131, "epss_percentile": 0.9127}, "CVE-2024-22052": {"epss_score": 0.02798, "epss_percentile": 0.85687}, "CVE-2024-22053": {"epss_score": 0.05078, "epss_percentile": 0.89469}, "CVE-2024-22054": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2024-22058": {"epss_score": 0.00161, "epss_percentile": 0.37559}, "CVE-2024-22059": {"epss_score": 0.05812, "epss_percentile": 0.90227}, "CVE-2024-22060": {"epss_score": 0.04748, "epss_percentile": 0.891}, "CVE-2024-22061": {"epss_score": 0.09189, "epss_percentile": 0.92439}, "CVE-2024-22062": {"epss_score": 0.00038, "epss_percentile": 0.11108}, "CVE-2024-22063": {"epss_score": 0.00291, "epss_percentile": 0.52177}, "CVE-2024-22064": {"epss_score": 0.00284, "epss_percentile": 0.51495}, "CVE-2024-22065": {"epss_score": 0.00238, "epss_percentile": 0.4674}, "CVE-2024-22066": {"epss_score": 0.00317, "epss_percentile": 0.54353}, "CVE-2024-22067": {"epss_score": 0.00155, "epss_percentile": 0.36759}, "CVE-2024-22068": {"epss_score": 0.00038, "epss_percentile": 0.11121}, "CVE-2024-22069": {"epss_score": 0.00133, "epss_percentile": 0.33624}, "CVE-2024-22074": {"epss_score": 0.01013, "epss_percentile": 0.76631}, "CVE-2024-22075": {"epss_score": 0.00128, "epss_percentile": 0.33042}, "CVE-2024-22076": {"epss_score": 0.03925, "epss_percentile": 0.87963}, "CVE-2024-22077": {"epss_score": 0.00195, "epss_percentile": 0.41709}, "CVE-2024-22078": {"epss_score": 0.00244, "epss_percentile": 0.47612}, "CVE-2024-22079": {"epss_score": 0.00675, "epss_percentile": 0.70913}, "CVE-2024-22080": {"epss_score": 0.00513, "epss_percentile": 0.65904}, "CVE-2024-22081": {"epss_score": 0.00513, "epss_percentile": 0.65904}, "CVE-2024-22082": {"epss_score": 0.00311, "epss_percentile": 0.53816}, "CVE-2024-22083": {"epss_score": 0.00128, "epss_percentile": 0.32946}, "CVE-2024-22084": {"epss_score": 0.00126, "epss_percentile": 0.32769}, "CVE-2024-22085": {"epss_score": 0.00057, "epss_percentile": 0.18199}, "CVE-2024-22086": {"epss_score": 0.05833, "epss_percentile": 0.90244}, "CVE-2024-22087": {"epss_score": 0.04827, "epss_percentile": 0.89186}, "CVE-2024-22088": {"epss_score": 0.00222, "epss_percentile": 0.44721}, "CVE-2024-22091": {"epss_score": 0.00138, "epss_percentile": 0.345}, "CVE-2024-22092": {"epss_score": 0.00169, "epss_percentile": 0.38616}, "CVE-2024-22093": {"epss_score": 0.00323, "epss_percentile": 0.54862}, "CVE-2024-22095": {"epss_score": 0.00096, "epss_percentile": 0.27263}, "CVE-2024-22096": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2024-22097": {"epss_score": 0.00259, "epss_percentile": 0.4906}, "CVE-2024-22098": {"epss_score": 0.00131, "epss_percentile": 0.33501}, "CVE-2024-22099": {"epss_score": 0.00061, "epss_percentile": 0.19376}, "CVE-2024-22100": {"epss_score": 0.0004, "epss_percentile": 0.12105}, "CVE-2024-22102": {"epss_score": 0.00119, "epss_percentile": 0.31559}, "CVE-2024-22103": {"epss_score": 0.00087, "epss_percentile": 0.25446}, "CVE-2024-22104": {"epss_score": 0.00118, "epss_percentile": 0.31393}, "CVE-2024-22105": {"epss_score": 0.00119, "epss_percentile": 0.31559}, "CVE-2024-22106": {"epss_score": 0.00061, "epss_percentile": 0.19502}, "CVE-2024-22107": {"epss_score": 0.013, "epss_percentile": 0.79289}, "CVE-2024-22108": {"epss_score": 0.00229, "epss_percentile": 0.45661}, "CVE-2024-22113": {"epss_score": 0.00397, "epss_percentile": 0.60019}, "CVE-2024-22114": {"epss_score": 0.00176, "epss_percentile": 0.39386}, "CVE-2024-22116": {"epss_score": 0.00534, "epss_percentile": 0.66785}, "CVE-2024-22117": {"epss_score": 0.00057, "epss_percentile": 0.1807}, "CVE-2024-22119": {"epss_score": 0.00312, "epss_percentile": 0.53952}, "CVE-2024-22120": {"epss_score": 0.93259, "epss_percentile": 0.9979}, "CVE-2024-22121": {"epss_score": 0.00031, "epss_percentile": 0.08459}, "CVE-2024-22122": {"epss_score": 0.0047, "epss_percentile": 0.63993}, "CVE-2024-22123": {"epss_score": 0.00335, "epss_percentile": 0.55809}, "CVE-2024-22124": {"epss_score": 0.00051, "epss_percentile": 0.16053}, "CVE-2024-22125": {"epss_score": 0.00406, "epss_percentile": 0.60514}, "CVE-2024-22126": {"epss_score": 0.003, "epss_percentile": 0.52912}, "CVE-2024-22127": {"epss_score": 0.01543, "epss_percentile": 0.80955}, "CVE-2024-22128": {"epss_score": 0.00523, "epss_percentile": 0.66297}, "CVE-2024-22129": {"epss_score": 0.0038, "epss_percentile": 0.58935}, "CVE-2024-22130": {"epss_score": 0.0038, "epss_percentile": 0.58935}, "CVE-2024-22131": {"epss_score": 0.04461, "epss_percentile": 0.88724}, "CVE-2024-22132": {"epss_score": 0.00306, "epss_percentile": 0.53428}, "CVE-2024-22133": {"epss_score": 0.00362, "epss_percentile": 0.57764}, "CVE-2024-22134": {"epss_score": 0.00146, "epss_percentile": 0.35634}, "CVE-2024-22135": {"epss_score": 0.00229, "epss_percentile": 0.45568}, "CVE-2024-22136": {"epss_score": 0.00065, "epss_percentile": 0.20495}, "CVE-2024-22137": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-22138": {"epss_score": 0.004, "epss_percentile": 0.60154}, "CVE-2024-22139": {"epss_score": 0.00102, "epss_percentile": 0.28835}, "CVE-2024-22140": {"epss_score": 0.00126, "epss_percentile": 0.32724}, "CVE-2024-22141": {"epss_score": 0.00233, "epss_percentile": 0.46056}, "CVE-2024-22142": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2024-22143": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2024-22144": {"epss_score": 0.00934, "epss_percentile": 0.75649}, "CVE-2024-22145": {"epss_score": 0.1782, "epss_percentile": 0.94912}, "CVE-2024-22146": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-22147": {"epss_score": 0.00148, "epss_percentile": 0.35847}, "CVE-2024-22148": {"epss_score": 0.00087, "epss_percentile": 0.25547}, "CVE-2024-22149": {"epss_score": 0.00354, "epss_percentile": 0.57229}, "CVE-2024-22150": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-22151": {"epss_score": 0.0024, "epss_percentile": 0.47183}, "CVE-2024-22152": {"epss_score": 0.00218, "epss_percentile": 0.44425}, "CVE-2024-22153": {"epss_score": 0.00068, "epss_percentile": 0.2131}, "CVE-2024-22154": {"epss_score": 0.00386, "epss_percentile": 0.59265}, "CVE-2024-22155": {"epss_score": 0.00227, "epss_percentile": 0.45441}, "CVE-2024-22156": {"epss_score": 0.00119, "epss_percentile": 0.31671}, "CVE-2024-22157": {"epss_score": 0.00682, "epss_percentile": 0.71076}, "CVE-2024-22158": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-22159": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-22160": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-22161": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2024-22162": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-22163": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-22164": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2024-22165": {"epss_score": 0.00288, "epss_percentile": 0.51948}, "CVE-2024-22167": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2024-22168": {"epss_score": 0.00263, "epss_percentile": 0.49541}, "CVE-2024-22169": {"epss_score": 0.00103, "epss_percentile": 0.2907}, "CVE-2024-22170": {"epss_score": 0.0024, "epss_percentile": 0.47203}, "CVE-2024-22177": {"epss_score": 0.00064, "epss_percentile": 0.20173}, "CVE-2024-22178": {"epss_score": 0.00151, "epss_percentile": 0.36232}, "CVE-2024-22179": {"epss_score": 0.00098, "epss_percentile": 0.27725}, "CVE-2024-22180": {"epss_score": 0.00075, "epss_percentile": 0.22946}, "CVE-2024-22181": {"epss_score": 0.00076, "epss_percentile": 0.23279}, "CVE-2024-22182": {"epss_score": 0.00516, "epss_percentile": 0.66056}, "CVE-2024-22184": {"epss_score": 0.00082, "epss_percentile": 0.24555}, "CVE-2024-22185": {"epss_score": 0.00031, "epss_percentile": 0.08644}, "CVE-2024-22186": {"epss_score": 0.00185, "epss_percentile": 0.40518}, "CVE-2024-22187": {"epss_score": 0.0086, "epss_percentile": 0.74534}, "CVE-2024-22188": {"epss_score": 0.00687, "epss_percentile": 0.71181}, "CVE-2024-22189": {"epss_score": 0.00066, "epss_percentile": 0.20802}, "CVE-2024-22190": {"epss_score": 0.00308, "epss_percentile": 0.53586}, "CVE-2024-22191": {"epss_score": 0.0096, "epss_percentile": 0.75969}, "CVE-2024-22192": {"epss_score": 0.0018, "epss_percentile": 0.39886}, "CVE-2024-22193": {"epss_score": 0.00197, "epss_percentile": 0.41835}, "CVE-2024-22194": {"epss_score": 0.00027, "epss_percentile": 0.0695}, "CVE-2024-22195": {"epss_score": 0.00111, "epss_percentile": 0.30363}, "CVE-2024-22196": {"epss_score": 0.00675, "epss_percentile": 0.70908}, "CVE-2024-22197": {"epss_score": 0.04239, "epss_percentile": 0.88431}, "CVE-2024-22198": {"epss_score": 0.16491, "epss_percentile": 0.94679}, "CVE-2024-22199": {"epss_score": 0.01784, "epss_percentile": 0.82251}, "CVE-2024-22200": {"epss_score": 0.00181, "epss_percentile": 0.40015}, "CVE-2024-22201": {"epss_score": 0.00448, "epss_percentile": 0.63009}, "CVE-2024-22202": {"epss_score": 0.00218, "epss_percentile": 0.44366}, "CVE-2024-22203": {"epss_score": 0.00441, "epss_percentile": 0.62653}, "CVE-2024-22204": {"epss_score": 0.00147, "epss_percentile": 0.35695}, "CVE-2024-22205": {"epss_score": 0.00297, "epss_percentile": 0.52705}, "CVE-2024-22206": {"epss_score": 0.00264, "epss_percentile": 0.4958}, "CVE-2024-22207": {"epss_score": 0.16258, "epss_percentile": 0.94605}, "CVE-2024-22208": {"epss_score": 0.00907, "epss_percentile": 0.75262}, "CVE-2024-22209": {"epss_score": 0.00078, "epss_percentile": 0.23762}, "CVE-2024-22211": {"epss_score": 0.00616, "epss_percentile": 0.6932}, "CVE-2024-22212": {"epss_score": 0.01151, "epss_percentile": 0.78042}, "CVE-2024-22213": {"epss_score": 0.00369, "epss_percentile": 0.58236}, "CVE-2024-22216": {"epss_score": 0.00401, "epss_percentile": 0.60256}, "CVE-2024-22217": {"epss_score": 0.00551, "epss_percentile": 0.67356}, "CVE-2024-22218": {"epss_score": 0.05535, "epss_percentile": 0.8997}, "CVE-2024-22219": {"epss_score": 0.04111, "epss_percentile": 0.88273}, "CVE-2024-22220": {"epss_score": 0.00276, "epss_percentile": 0.50721}, "CVE-2024-22221": {"epss_score": 0.00207, "epss_percentile": 0.4314}, "CVE-2024-22222": {"epss_score": 0.0019, "epss_percentile": 0.41126}, "CVE-2024-22223": {"epss_score": 0.00175, "epss_percentile": 0.39315}, "CVE-2024-22224": {"epss_score": 0.00218, "epss_percentile": 0.44428}, "CVE-2024-22225": {"epss_score": 0.00209, "epss_percentile": 0.43375}, "CVE-2024-22226": {"epss_score": 0.00333, "epss_percentile": 0.55625}, "CVE-2024-22227": {"epss_score": 0.00304, "epss_percentile": 0.53302}, "CVE-2024-22228": {"epss_score": 0.00304, "epss_percentile": 0.53302}, "CVE-2024-22229": {"epss_score": 0.00155, "epss_percentile": 0.36824}, "CVE-2024-22230": {"epss_score": 0.00439, "epss_percentile": 0.62607}, "CVE-2024-22231": {"epss_score": 0.00498, "epss_percentile": 0.65238}, "CVE-2024-22232": {"epss_score": 0.00439, "epss_percentile": 0.62598}, "CVE-2024-22233": {"epss_score": 0.01141, "epss_percentile": 0.77954}, "CVE-2024-22234": {"epss_score": 0.01227, "epss_percentile": 0.78704}, "CVE-2024-22235": {"epss_score": 0.00045, "epss_percentile": 0.13826}, "CVE-2024-22236": {"epss_score": 0.00095, "epss_percentile": 0.27137}, "CVE-2024-22237": {"epss_score": 0.00124, "epss_percentile": 0.32434}, "CVE-2024-22238": {"epss_score": 0.01667, "epss_percentile": 0.81655}, "CVE-2024-22239": {"epss_score": 0.00072, "epss_percentile": 0.22397}, "CVE-2024-22240": {"epss_score": 0.00544, "epss_percentile": 0.67145}, "CVE-2024-22241": {"epss_score": 0.03551, "epss_percentile": 0.87341}, "CVE-2024-22243": {"epss_score": 0.558, "epss_percentile": 0.97997}, "CVE-2024-22244": {"epss_score": 0.00348, "epss_percentile": 0.56795}, "CVE-2024-22245": {"epss_score": 0.00698, "epss_percentile": 0.71429}, "CVE-2024-22246": {"epss_score": 0.00493, "epss_percentile": 0.65065}, "CVE-2024-22247": {"epss_score": 0.00066, "epss_percentile": 0.20868}, "CVE-2024-22248": {"epss_score": 0.00165, "epss_percentile": 0.38042}, "CVE-2024-22250": {"epss_score": 0.00109, "epss_percentile": 0.29916}, "CVE-2024-22251": {"epss_score": 0.00062, "epss_percentile": 0.19789}, "CVE-2024-22252": {"epss_score": 0.00352, "epss_percentile": 0.57105}, "CVE-2024-22253": {"epss_score": 0.00079, "epss_percentile": 0.23857}, "CVE-2024-22254": {"epss_score": 0.0041, "epss_percentile": 0.60811}, "CVE-2024-22255": {"epss_score": 0.04347, "epss_percentile": 0.88579}, "CVE-2024-22256": {"epss_score": 0.00419, "epss_percentile": 0.61356}, "CVE-2024-22257": {"epss_score": 0.00264, "epss_percentile": 0.49581}, "CVE-2024-22258": {"epss_score": 0.00121, "epss_percentile": 0.32015}, "CVE-2024-22259": {"epss_score": 0.55006, "epss_percentile": 0.97956}, "CVE-2024-22260": {"epss_score": 0.00267, "epss_percentile": 0.49994}, "CVE-2024-22261": {"epss_score": 0.00369, "epss_percentile": 0.58253}, "CVE-2024-22262": {"epss_score": 0.09827, "epss_percentile": 0.92722}, "CVE-2024-22263": {"epss_score": 0.77749, "epss_percentile": 0.98951}, "CVE-2024-22264": {"epss_score": 0.00319, "epss_percentile": 0.54532}, "CVE-2024-22266": {"epss_score": 0.00255, "epss_percentile": 0.48725}, "CVE-2024-22267": {"epss_score": 0.00125, "epss_percentile": 0.32572}, "CVE-2024-22268": {"epss_score": 0.00089, "epss_percentile": 0.25805}, "CVE-2024-22269": {"epss_score": 0.00077, "epss_percentile": 0.23533}, "CVE-2024-22270": {"epss_score": 0.00077, "epss_percentile": 0.23533}, "CVE-2024-22271": {"epss_score": 0.00291, "epss_percentile": 0.52154}, "CVE-2024-22272": {"epss_score": 0.00102, "epss_percentile": 0.28835}, "CVE-2024-22273": {"epss_score": 0.00302, "epss_percentile": 0.5315}, "CVE-2024-22274": {"epss_score": 0.65683, "epss_percentile": 0.98432}, "CVE-2024-22275": {"epss_score": 0.11298, "epss_percentile": 0.93297}, "CVE-2024-22276": {"epss_score": 0.00125, "epss_percentile": 0.32542}, "CVE-2024-22277": {"epss_score": 0.00146, "epss_percentile": 0.35624}, "CVE-2024-22278": {"epss_score": 0.00175, "epss_percentile": 0.39269}, "CVE-2024-22279": {"epss_score": 0.00533, "epss_percentile": 0.66773}, "CVE-2024-22280": {"epss_score": 0.01906, "epss_percentile": 0.82809}, "CVE-2024-22281": {"epss_score": 0.00357, "epss_percentile": 0.57465}, "CVE-2024-22282": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-22283": {"epss_score": 0.00156, "epss_percentile": 0.36991}, "CVE-2024-22284": {"epss_score": 0.0062, "epss_percentile": 0.69457}, "CVE-2024-22285": {"epss_score": 0.00056, "epss_percentile": 0.17825}, "CVE-2024-22286": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-22287": {"epss_score": 0.00066, "epss_percentile": 0.20761}, "CVE-2024-22288": {"epss_score": 0.00199, "epss_percentile": 0.42109}, "CVE-2024-22289": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-22290": {"epss_score": 0.00065, "epss_percentile": 0.20566}, "CVE-2024-22291": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2024-22292": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2024-22293": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-22294": {"epss_score": 0.00282, "epss_percentile": 0.51203}, "CVE-2024-22295": {"epss_score": 0.00051, "epss_percentile": 0.16045}, "CVE-2024-22296": {"epss_score": 0.00377, "epss_percentile": 0.58735}, "CVE-2024-22297": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2024-22298": {"epss_score": 0.00516, "epss_percentile": 0.66047}, "CVE-2024-22299": {"epss_score": 0.00258, "epss_percentile": 0.48992}, "CVE-2024-22300": {"epss_score": 0.002, "epss_percentile": 0.42231}, "CVE-2024-22301": {"epss_score": 0.00211, "epss_percentile": 0.43644}, "CVE-2024-22302": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-22303": {"epss_score": 0.00144, "epss_percentile": 0.35279}, "CVE-2024-22304": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2024-22305": {"epss_score": 0.001, "epss_percentile": 0.2845}, "CVE-2024-22306": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2024-22307": {"epss_score": 0.00091, "epss_percentile": 0.26188}, "CVE-2024-22308": {"epss_score": 0.00097, "epss_percentile": 0.27461}, "CVE-2024-22309": {"epss_score": 0.00297, "epss_percentile": 0.52773}, "CVE-2024-22310": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2024-22311": {"epss_score": 0.00215, "epss_percentile": 0.44107}, "CVE-2024-22312": {"epss_score": 0.00017, "epss_percentile": 0.03189}, "CVE-2024-22313": {"epss_score": 0.0002, "epss_percentile": 0.04481}, "CVE-2024-22314": {"epss_score": 0.00025, "epss_percentile": 0.06097}, "CVE-2024-22315": {"epss_score": 0.00015, "epss_percentile": 0.02212}, "CVE-2024-22316": {"epss_score": 0.00085, "epss_percentile": 0.25126}, "CVE-2024-22317": {"epss_score": 0.00121, "epss_percentile": 0.31884}, "CVE-2024-22318": {"epss_score": 0.00139, "epss_percentile": 0.34583}, "CVE-2024-22319": {"epss_score": 0.9041, "epss_percentile": 0.99582}, "CVE-2024-22320": {"epss_score": 0.92262, "epss_percentile": 0.99703}, "CVE-2024-22326": {"epss_score": 0.00066, "epss_percentile": 0.2077}, "CVE-2024-22328": {"epss_score": 0.00058, "epss_percentile": 0.18481}, "CVE-2024-22329": {"epss_score": 0.00036, "epss_percentile": 0.10449}, "CVE-2024-22330": {"epss_score": 0.00031, "epss_percentile": 0.08454}, "CVE-2024-22331": {"epss_score": 0.00026, "epss_percentile": 0.06401}, "CVE-2024-22332": {"epss_score": 0.00056, "epss_percentile": 0.17886}, "CVE-2024-22333": {"epss_score": 0.00048, "epss_percentile": 0.15146}, "CVE-2024-22334": {"epss_score": 0.00029, "epss_percentile": 0.07946}, "CVE-2024-22335": {"epss_score": 0.00029, "epss_percentile": 0.07772}, "CVE-2024-22336": {"epss_score": 0.00029, "epss_percentile": 0.07772}, "CVE-2024-22337": {"epss_score": 0.00022, "epss_percentile": 0.0526}, "CVE-2024-22338": {"epss_score": 0.00052, "epss_percentile": 0.16597}, "CVE-2024-22339": {"epss_score": 0.00082, "epss_percentile": 0.2447}, "CVE-2024-22340": {"epss_score": 0.00082, "epss_percentile": 0.24425}, "CVE-2024-22341": {"epss_score": 0.00027, "epss_percentile": 0.06934}, "CVE-2024-22343": {"epss_score": 0.00033, "epss_percentile": 0.0937}, "CVE-2024-22344": {"epss_score": 0.00059, "epss_percentile": 0.18857}, "CVE-2024-22345": {"epss_score": 0.00067, "epss_percentile": 0.21126}, "CVE-2024-22346": {"epss_score": 0.00037, "epss_percentile": 0.10989}, "CVE-2024-22347": {"epss_score": 0.00046, "epss_percentile": 0.14186}, "CVE-2024-22348": {"epss_score": 0.00096, "epss_percentile": 0.27289}, "CVE-2024-22349": {"epss_score": 0.0006, "epss_percentile": 0.18962}, "CVE-2024-22351": {"epss_score": 0.00047, "epss_percentile": 0.14639}, "CVE-2024-22352": {"epss_score": 0.00066, "epss_percentile": 0.20764}, "CVE-2024-22353": {"epss_score": 0.00019, "epss_percentile": 0.04081}, "CVE-2024-22354": {"epss_score": 0.00019, "epss_percentile": 0.04059}, "CVE-2024-22355": {"epss_score": 0.00062, "epss_percentile": 0.19596}, "CVE-2024-22356": {"epss_score": 0.00059, "epss_percentile": 0.18619}, "CVE-2024-22357": {"epss_score": 0.00184, "epss_percentile": 0.40381}, "CVE-2024-22358": {"epss_score": 0.00066, "epss_percentile": 0.20752}, "CVE-2024-22359": {"epss_score": 0.0017, "epss_percentile": 0.38665}, "CVE-2024-22360": {"epss_score": 0.00074, "epss_percentile": 0.22722}, "CVE-2024-22361": {"epss_score": 0.00036, "epss_percentile": 0.10526}, "CVE-2024-22362": {"epss_score": 0.00103, "epss_percentile": 0.29068}, "CVE-2024-22363": {"epss_score": 0.00103, "epss_percentile": 0.29075}, "CVE-2024-22365": {"epss_score": 0.00084, "epss_percentile": 0.24859}, "CVE-2024-22366": {"epss_score": 0.00083, "epss_percentile": 0.24816}, "CVE-2024-22368": {"epss_score": 0.00068, "epss_percentile": 0.21426}, "CVE-2024-22369": {"epss_score": 0.0475, "epss_percentile": 0.89102}, "CVE-2024-22370": {"epss_score": 0.29955, "epss_percentile": 0.96489}, "CVE-2024-22371": {"epss_score": 0.00581, "epss_percentile": 0.68283}, "CVE-2024-22372": {"epss_score": 0.00173, "epss_percentile": 0.39129}, "CVE-2024-22373": {"epss_score": 0.00202, "epss_percentile": 0.42422}, "CVE-2024-22374": {"epss_score": 9e-05, "epss_percentile": 0.00666}, "CVE-2024-22376": {"epss_score": 0.00056, "epss_percentile": 0.17776}, "CVE-2024-22377": {"epss_score": 0.0037, "epss_percentile": 0.58316}, "CVE-2024-22378": {"epss_score": 0.00038, "epss_percentile": 0.11309}, "CVE-2024-22379": {"epss_score": 0.00079, "epss_percentile": 0.23871}, "CVE-2024-22380": {"epss_score": 0.00033, "epss_percentile": 0.0937}, "CVE-2024-22382": {"epss_score": 0.00092, "epss_percentile": 0.26505}, "CVE-2024-22383": {"epss_score": 0.00038, "epss_percentile": 0.11275}, "CVE-2024-22384": {"epss_score": 0.00079, "epss_percentile": 0.23991}, "CVE-2024-22385": {"epss_score": 0.00044, "epss_percentile": 0.13505}, "CVE-2024-22386": {"epss_score": 0.00015, "epss_percentile": 0.02478}, "CVE-2024-22387": {"epss_score": 0.00117, "epss_percentile": 0.31376}, "CVE-2024-22388": {"epss_score": 0.00041, "epss_percentile": 0.12371}, "CVE-2024-22389": {"epss_score": 0.00238, "epss_percentile": 0.46766}, "CVE-2024-22390": {"epss_score": 0.00066, "epss_percentile": 0.20931}, "CVE-2024-22391": {"epss_score": 0.00178, "epss_percentile": 0.39716}, "CVE-2024-22393": {"epss_score": 0.26701, "epss_percentile": 0.96168}, "CVE-2024-22394": {"epss_score": 0.00863, "epss_percentile": 0.74593}, "CVE-2024-22395": {"epss_score": 0.00434, "epss_percentile": 0.62301}, "CVE-2024-22396": {"epss_score": 0.01218, "epss_percentile": 0.78607}, "CVE-2024-22397": {"epss_score": 0.00199, "epss_percentile": 0.4214}, "CVE-2024-22398": {"epss_score": 0.00192, "epss_percentile": 0.41307}, "CVE-2024-22399": {"epss_score": 0.74626, "epss_percentile": 0.98811}, "CVE-2024-22400": {"epss_score": 0.00268, "epss_percentile": 0.50071}, "CVE-2024-22401": {"epss_score": 0.00244, "epss_percentile": 0.47596}, "CVE-2024-22402": {"epss_score": 0.00243, "epss_percentile": 0.47476}, "CVE-2024-22403": {"epss_score": 0.00212, "epss_percentile": 0.43756}, "CVE-2024-22404": {"epss_score": 0.00446, "epss_percentile": 0.62925}, "CVE-2024-22405": {"epss_score": 0.00047, "epss_percentile": 0.14581}, "CVE-2024-22406": {"epss_score": 0.0022, "epss_percentile": 0.44556}, "CVE-2024-22407": {"epss_score": 0.00108, "epss_percentile": 0.29858}, "CVE-2024-22408": {"epss_score": 0.00186, "epss_percentile": 0.40611}, "CVE-2024-22409": {"epss_score": 0.00297, "epss_percentile": 0.52708}, "CVE-2024-22410": {"epss_score": 0.00046, "epss_percentile": 0.14398}, "CVE-2024-22411": {"epss_score": 0.04486, "epss_percentile": 0.88749}, "CVE-2024-22412": {"epss_score": 0.00105, "epss_percentile": 0.29258}, "CVE-2024-22414": {"epss_score": 0.002, "epss_percentile": 0.42207}, "CVE-2024-22415": {"epss_score": 0.00167, "epss_percentile": 0.38295}, "CVE-2024-22416": {"epss_score": 0.05898, "epss_percentile": 0.90306}, "CVE-2024-22417": {"epss_score": 0.00358, "epss_percentile": 0.57485}, "CVE-2024-22418": {"epss_score": 0.00236, "epss_percentile": 0.46408}, "CVE-2024-22419": {"epss_score": 0.00412, "epss_percentile": 0.60922}, "CVE-2024-22420": {"epss_score": 0.00448, "epss_percentile": 0.63019}, "CVE-2024-22421": {"epss_score": 0.00138, "epss_percentile": 0.34455}, "CVE-2024-22422": {"epss_score": 0.01963, "epss_percentile": 0.83072}, "CVE-2024-22423": {"epss_score": 0.02032, "epss_percentile": 0.83337}, "CVE-2024-22424": {"epss_score": 0.00064, "epss_percentile": 0.20432}, "CVE-2024-22425": {"epss_score": 0.00477, "epss_percentile": 0.64353}, "CVE-2024-22426": {"epss_score": 0.01131, "epss_percentile": 0.77854}, "CVE-2024-22428": {"epss_score": 0.00046, "epss_percentile": 0.141}, "CVE-2024-22429": {"epss_score": 0.00056, "epss_percentile": 0.17817}, "CVE-2024-22430": {"epss_score": 0.00017, "epss_percentile": 0.03492}, "CVE-2024-22432": {"epss_score": 0.00058, "epss_percentile": 0.18375}, "CVE-2024-22433": {"epss_score": 0.00224, "epss_percentile": 0.44975}, "CVE-2024-22435": {"epss_score": 0.00216, "epss_percentile": 0.44197}, "CVE-2024-22436": {"epss_score": 0.00144, "epss_percentile": 0.35236}, "CVE-2024-22437": {"epss_score": 0.00059, "epss_percentile": 0.18622}, "CVE-2024-22438": {"epss_score": 0.00087, "epss_percentile": 0.25483}, "CVE-2024-22439": {"epss_score": 0.00091, "epss_percentile": 0.26188}, "CVE-2024-22440": {"epss_score": 0.0019, "epss_percentile": 0.41096}, "CVE-2024-22441": {"epss_score": 0.00164, "epss_percentile": 0.37902}, "CVE-2024-22442": {"epss_score": 0.00494, "epss_percentile": 0.65083}, "CVE-2024-22443": {"epss_score": 0.00795, "epss_percentile": 0.73467}, "CVE-2024-22444": {"epss_score": 0.00384, "epss_percentile": 0.59133}, "CVE-2024-22445": {"epss_score": 0.00186, "epss_percentile": 0.40681}, "CVE-2024-22448": {"epss_score": 0.00041, "epss_percentile": 0.12198}, "CVE-2024-22449": {"epss_score": 0.00031, "epss_percentile": 0.08695}, "CVE-2024-22450": {"epss_score": 0.00102, "epss_percentile": 0.28717}, "CVE-2024-22452": {"epss_score": 0.00102, "epss_percentile": 0.28819}, "CVE-2024-22453": {"epss_score": 0.00027, "epss_percentile": 0.06744}, "CVE-2024-22454": {"epss_score": 0.01099, "epss_percentile": 0.7755}, "CVE-2024-22455": {"epss_score": 0.00051, "epss_percentile": 0.16315}, "CVE-2024-22457": {"epss_score": 0.00873, "epss_percentile": 0.74744}, "CVE-2024-22458": {"epss_score": 0.00089, "epss_percentile": 0.25797}, "CVE-2024-22459": {"epss_score": 0.00214, "epss_percentile": 0.44022}, "CVE-2024-22460": {"epss_score": 0.01203, "epss_percentile": 0.785}, "CVE-2024-22461": {"epss_score": 0.00628, "epss_percentile": 0.69654}, "CVE-2024-22463": {"epss_score": 0.00114, "epss_percentile": 0.30742}, "CVE-2024-22464": {"epss_score": 0.001, "epss_percentile": 0.28432}, "CVE-2024-22472": {"epss_score": 0.07626, "epss_percentile": 0.9158}, "CVE-2024-22473": {"epss_score": 0.00067, "epss_percentile": 0.20967}, "CVE-2024-22475": {"epss_score": 0.00399, "epss_percentile": 0.60092}, "CVE-2024-22476": {"epss_score": 0.69, "epss_percentile": 0.98573}, "CVE-2024-22477": {"epss_score": 0.00141, "epss_percentile": 0.34824}, "CVE-2024-22490": {"epss_score": 0.00098, "epss_percentile": 0.27711}, "CVE-2024-22491": {"epss_score": 0.00091, "epss_percentile": 0.26387}, "CVE-2024-22492": {"epss_score": 0.00109, "epss_percentile": 0.29929}, "CVE-2024-22493": {"epss_score": 0.0011, "epss_percentile": 0.30199}, "CVE-2024-22494": {"epss_score": 0.00054, "epss_percentile": 0.1733}, "CVE-2024-22496": {"epss_score": 0.00107, "epss_percentile": 0.29666}, "CVE-2024-22497": {"epss_score": 0.00107, "epss_percentile": 0.29666}, "CVE-2024-22513": {"epss_score": 0.00235, "epss_percentile": 0.46339}, "CVE-2024-22514": {"epss_score": 0.1558, "epss_percentile": 0.94464}, "CVE-2024-22515": {"epss_score": 0.10168, "epss_percentile": 0.92874}, "CVE-2024-22519": {"epss_score": 0.00062, "epss_percentile": 0.19608}, "CVE-2024-22520": {"epss_score": 0.00062, "epss_percentile": 0.19608}, "CVE-2024-22523": {"epss_score": 0.00145, "epss_percentile": 0.3552}, "CVE-2024-22524": {"epss_score": 0.00101, "epss_percentile": 0.28598}, "CVE-2024-22525": {"epss_score": 0.00137, "epss_percentile": 0.34208}, "CVE-2024-22526": {"epss_score": 0.01307, "epss_percentile": 0.79343}, "CVE-2024-22529": {"epss_score": 0.03546, "epss_percentile": 0.87329}, "CVE-2024-22532": {"epss_score": 0.05561, "epss_percentile": 0.89995}, "CVE-2024-22533": {"epss_score": 0.00659, "epss_percentile": 0.7051}, "CVE-2024-22543": {"epss_score": 0.00085, "epss_percentile": 0.25134}, "CVE-2024-22544": {"epss_score": 0.02137, "epss_percentile": 0.83731}, "CVE-2024-22545": {"epss_score": 0.00107, "epss_percentile": 0.29741}, "CVE-2024-22546": {"epss_score": 0.00211, "epss_percentile": 0.43664}, "CVE-2024-22547": {"epss_score": 0.0007, "epss_percentile": 0.21838}, "CVE-2024-22548": {"epss_score": 0.00093, "epss_percentile": 0.26687}, "CVE-2024-22549": {"epss_score": 0.00077, "epss_percentile": 0.23545}, "CVE-2024-22550": {"epss_score": 0.0009, "epss_percentile": 0.26168}, "CVE-2024-22551": {"epss_score": 0.00093, "epss_percentile": 0.26694}, "CVE-2024-22559": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2024-22562": {"epss_score": 0.00075, "epss_percentile": 0.2289}, "CVE-2024-22563": {"epss_score": 0.00083, "epss_percentile": 0.24619}, "CVE-2024-22567": {"epss_score": 0.01286, "epss_percentile": 0.79181}, "CVE-2024-22568": {"epss_score": 0.00078, "epss_percentile": 0.23659}, "CVE-2024-22569": {"epss_score": 0.00109, "epss_percentile": 0.29955}, "CVE-2024-22570": {"epss_score": 0.00078, "epss_percentile": 0.23744}, "CVE-2024-22588": {"epss_score": 0.00041, "epss_percentile": 0.12324}, "CVE-2024-22590": {"epss_score": 0.00221, "epss_percentile": 0.44692}, "CVE-2024-22591": {"epss_score": 0.00078, "epss_percentile": 0.23659}, "CVE-2024-22592": {"epss_score": 0.00076, "epss_percentile": 0.23116}, "CVE-2024-22593": {"epss_score": 0.00076, "epss_percentile": 0.23116}, "CVE-2024-22601": {"epss_score": 0.00082, "epss_percentile": 0.24576}, "CVE-2024-22603": {"epss_score": 0.00082, "epss_percentile": 0.24576}, "CVE-2024-22611": {"epss_score": 5e-05, "epss_percentile": 0.0018}, "CVE-2024-22625": {"epss_score": 0.00075, "epss_percentile": 0.23017}, "CVE-2024-22626": {"epss_score": 0.00101, "epss_percentile": 0.28581}, "CVE-2024-22627": {"epss_score": 0.00131, "epss_percentile": 0.33361}, "CVE-2024-22628": {"epss_score": 0.00097, "epss_percentile": 0.27575}, "CVE-2024-22632": {"epss_score": 0.04212, "epss_percentile": 0.88402}, "CVE-2024-22633": {"epss_score": 0.04212, "epss_percentile": 0.88402}, "CVE-2024-22635": {"epss_score": 0.00207, "epss_percentile": 0.43178}, "CVE-2024-22636": {"epss_score": 0.04769, "epss_percentile": 0.89125}, "CVE-2024-22637": {"epss_score": 0.00207, "epss_percentile": 0.43178}, "CVE-2024-22638": {"epss_score": 0.04175, "epss_percentile": 0.88352}, "CVE-2024-22639": {"epss_score": 0.00207, "epss_percentile": 0.43178}, "CVE-2024-22640": {"epss_score": 0.0129, "epss_percentile": 0.79217}, "CVE-2024-22641": {"epss_score": 0.09669, "epss_percentile": 0.92647}, "CVE-2024-22643": {"epss_score": 0.00119, "epss_percentile": 0.31597}, "CVE-2024-22646": {"epss_score": 0.00348, "epss_percentile": 0.56851}, "CVE-2024-22647": {"epss_score": 0.00168, "epss_percentile": 0.38478}, "CVE-2024-22648": {"epss_score": 0.00136, "epss_percentile": 0.34117}, "CVE-2024-22651": {"epss_score": 0.69533, "epss_percentile": 0.98592}, "CVE-2024-22653": {"epss_score": 0.00041, "epss_percentile": 0.12417}, "CVE-2024-22654": {"epss_score": 0.00031, "epss_percentile": 0.08529}, "CVE-2024-22660": {"epss_score": 0.01244, "epss_percentile": 0.78836}, "CVE-2024-22662": {"epss_score": 0.01244, "epss_percentile": 0.78836}, "CVE-2024-22663": {"epss_score": 0.04762, "epss_percentile": 0.89119}, "CVE-2024-22667": {"epss_score": 0.00139, "epss_percentile": 0.34556}, "CVE-2024-22699": {"epss_score": 0.00202, "epss_percentile": 0.4244}, "CVE-2024-22705": {"epss_score": 0.00019, "epss_percentile": 0.04254}, "CVE-2024-22714": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2024-22715": {"epss_score": 0.00159, "epss_percentile": 0.37387}, "CVE-2024-22717": {"epss_score": 0.00128, "epss_percentile": 0.33042}, "CVE-2024-22718": {"epss_score": 0.00147, "epss_percentile": 0.35798}, "CVE-2024-22719": {"epss_score": 0.00064, "epss_percentile": 0.20289}, "CVE-2024-22720": {"epss_score": 0.00036, "epss_percentile": 0.10615}, "CVE-2024-22721": {"epss_score": 0.00053, "epss_percentile": 0.1697}, "CVE-2024-22722": {"epss_score": 0.00079, "epss_percentile": 0.23816}, "CVE-2024-22723": {"epss_score": 0.00215, "epss_percentile": 0.4408}, "CVE-2024-22724": {"epss_score": 0.00016, "epss_percentile": 0.02913}, "CVE-2024-22725": {"epss_score": 0.00597, "epss_percentile": 0.68745}, "CVE-2024-22727": {"epss_score": 0.00267, "epss_percentile": 0.49954}, "CVE-2024-22729": {"epss_score": 0.91174, "epss_percentile": 0.99625}, "CVE-2024-22733": {"epss_score": 0.00973, "epss_percentile": 0.76156}, "CVE-2024-22734": {"epss_score": 0.02091, "epss_percentile": 0.8357}, "CVE-2024-22749": {"epss_score": 0.00123, "epss_percentile": 0.32205}, "CVE-2024-22751": {"epss_score": 0.04382, "epss_percentile": 0.88626}, "CVE-2024-22752": {"epss_score": 0.00404, "epss_percentile": 0.60435}, "CVE-2024-22768": {"epss_score": 0.00362, "epss_percentile": 0.57782}, "CVE-2024-22769": {"epss_score": 0.00285, "epss_percentile": 0.51661}, "CVE-2024-22770": {"epss_score": 0.00285, "epss_percentile": 0.51661}, "CVE-2024-22771": {"epss_score": 0.00285, "epss_percentile": 0.51661}, "CVE-2024-22772": {"epss_score": 0.00285, "epss_percentile": 0.51661}, "CVE-2024-22773": {"epss_score": 0.00098, "epss_percentile": 0.27824}, "CVE-2024-22774": {"epss_score": 0.03581, "epss_percentile": 0.87385}, "CVE-2024-22776": {"epss_score": 0.00095, "epss_percentile": 0.27189}, "CVE-2024-22778": {"epss_score": 0.00503, "epss_percentile": 0.65455}, "CVE-2024-22779": {"epss_score": 0.14326, "epss_percentile": 0.94187}, "CVE-2024-22780": {"epss_score": 0.00322, "epss_percentile": 0.54859}, "CVE-2024-22795": {"epss_score": 0.00112, "epss_percentile": 0.30478}, "CVE-2024-22807": {"epss_score": 0.00107, "epss_percentile": 0.29606}, "CVE-2024-22808": {"epss_score": 0.00151, "epss_percentile": 0.36255}, "CVE-2024-22809": {"epss_score": 0.00097, "epss_percentile": 0.27465}, "CVE-2024-22811": {"epss_score": 0.00171, "epss_percentile": 0.38893}, "CVE-2024-22813": {"epss_score": 0.00084, "epss_percentile": 0.24828}, "CVE-2024-22815": {"epss_score": 0.00072, "epss_percentile": 0.22272}, "CVE-2024-22817": {"epss_score": 0.00111, "epss_percentile": 0.30332}, "CVE-2024-22818": {"epss_score": 0.00111, "epss_percentile": 0.30332}, "CVE-2024-22819": {"epss_score": 0.00085, "epss_percentile": 0.25113}, "CVE-2024-22824": {"epss_score": 0.03561, "epss_percentile": 0.87354}, "CVE-2024-22830": {"epss_score": 0.00071, "epss_percentile": 0.22057}, "CVE-2024-22836": {"epss_score": 0.32659, "epss_percentile": 0.96716}, "CVE-2024-22851": {"epss_score": 0.00194, "epss_percentile": 0.41547}, "CVE-2024-22852": {"epss_score": 0.04382, "epss_percentile": 0.88626}, "CVE-2024-22853": {"epss_score": 0.85351, "epss_percentile": 0.9933}, "CVE-2024-22854": {"epss_score": 0.00149, "epss_percentile": 0.35961}, "CVE-2024-22855": {"epss_score": 0.00169, "epss_percentile": 0.3857}, "CVE-2024-22856": {"epss_score": 0.00091, "epss_percentile": 0.26266}, "CVE-2024-22857": {"epss_score": 0.02414, "epss_percentile": 0.84679}, "CVE-2024-22859": {"epss_score": 0.01218, "epss_percentile": 0.78602}, "CVE-2024-22860": {"epss_score": 0.03707, "epss_percentile": 0.87599}, "CVE-2024-22861": {"epss_score": 0.00037, "epss_percentile": 0.10916}, "CVE-2024-22862": {"epss_score": 0.02487, "epss_percentile": 0.84892}, "CVE-2024-22871": {"epss_score": 0.00595, "epss_percentile": 0.68679}, "CVE-2024-22873": {"epss_score": 0.00189, "epss_percentile": 0.41002}, "CVE-2024-22876": {"epss_score": 0.00241, "epss_percentile": 0.47247}, "CVE-2024-22877": {"epss_score": 0.00193, "epss_percentile": 0.41494}, "CVE-2024-22880": {"epss_score": 0.00067, "epss_percentile": 0.2105}, "CVE-2024-22889": {"epss_score": 0.00474, "epss_percentile": 0.64139}, "CVE-2024-22891": {"epss_score": 0.32168, "epss_percentile": 0.96675}, "CVE-2024-22892": {"epss_score": 0.00129, "epss_percentile": 0.33179}, "CVE-2024-22893": {"epss_score": 0.00245, "epss_percentile": 0.47668}, "CVE-2024-22894": {"epss_score": 0.03315, "epss_percentile": 0.869}, "CVE-2024-22895": {"epss_score": 0.00184, "epss_percentile": 0.40399}, "CVE-2024-22899": {"epss_score": 0.21203, "epss_percentile": 0.95476}, "CVE-2024-22900": {"epss_score": 0.03859, "epss_percentile": 0.87862}, "CVE-2024-22901": {"epss_score": 0.00109, "epss_percentile": 0.29942}, "CVE-2024-22902": {"epss_score": 0.00156, "epss_percentile": 0.36981}, "CVE-2024-22903": {"epss_score": 0.03859, "epss_percentile": 0.87862}, "CVE-2024-22905": {"epss_score": 0.04103, "epss_percentile": 0.88262}, "CVE-2024-22910": {"epss_score": 0.00366, "epss_percentile": 0.58092}, "CVE-2024-22911": {"epss_score": 0.00098, "epss_percentile": 0.27679}, "CVE-2024-22912": {"epss_score": 0.00068, "epss_percentile": 0.21188}, "CVE-2024-22913": {"epss_score": 0.00088, "epss_percentile": 0.25751}, "CVE-2024-22914": {"epss_score": 0.00052, "epss_percentile": 0.16616}, "CVE-2024-22915": {"epss_score": 0.00109, "epss_percentile": 0.30037}, "CVE-2024-22916": {"epss_score": 0.01035, "epss_percentile": 0.76901}, "CVE-2024-22917": {"epss_score": 0.00982, "epss_percentile": 0.76287}, "CVE-2024-22919": {"epss_score": 0.00098, "epss_percentile": 0.27679}, "CVE-2024-22920": {"epss_score": 0.0007, "epss_percentile": 0.21638}, "CVE-2024-22922": {"epss_score": 0.00896, "epss_percentile": 0.75114}, "CVE-2024-22923": {"epss_score": 0.00137, "epss_percentile": 0.34267}, "CVE-2024-22927": {"epss_score": 0.03185, "epss_percentile": 0.86588}, "CVE-2024-22936": {"epss_score": 0.00265, "epss_percentile": 0.49818}, "CVE-2024-22938": {"epss_score": 0.00032, "epss_percentile": 0.08832}, "CVE-2024-22939": {"epss_score": 0.02362, "epss_percentile": 0.84501}, "CVE-2024-22942": {"epss_score": 0.0313, "epss_percentile": 0.86465}, "CVE-2024-22949": {"epss_score": 0.00113, "epss_percentile": 0.30611}, "CVE-2024-22955": {"epss_score": 0.00073, "epss_percentile": 0.22577}, "CVE-2024-22956": {"epss_score": 0.00096, "epss_percentile": 0.27395}, "CVE-2024-22957": {"epss_score": 0.00053, "epss_percentile": 0.16673}, "CVE-2024-22983": {"epss_score": 0.0067, "epss_percentile": 0.70783}, "CVE-2024-22988": {"epss_score": 0.00113, "epss_percentile": 0.3066}, "CVE-2024-23031": {"epss_score": 0.00075, "epss_percentile": 0.23042}, "CVE-2024-23032": {"epss_score": 0.00224, "epss_percentile": 0.44969}, "CVE-2024-23033": {"epss_score": 0.00224, "epss_percentile": 0.44969}, "CVE-2024-23034": {"epss_score": 0.00224, "epss_percentile": 0.44969}, "CVE-2024-23049": {"epss_score": 0.03752, "epss_percentile": 0.87676}, "CVE-2024-23052": {"epss_score": 0.76819, "epss_percentile": 0.98907}, "CVE-2024-23054": {"epss_score": 0.03909, "epss_percentile": 0.87932}, "CVE-2024-23055": {"epss_score": 0.0063, "epss_percentile": 0.69703}, "CVE-2024-23057": {"epss_score": 0.0313, "epss_percentile": 0.86465}, "CVE-2024-23058": {"epss_score": 0.0313, "epss_percentile": 0.86465}, "CVE-2024-23059": {"epss_score": 0.02304, "epss_percentile": 0.8432}, "CVE-2024-23060": {"epss_score": 0.02304, "epss_percentile": 0.8432}, "CVE-2024-23061": {"epss_score": 0.02304, "epss_percentile": 0.8432}, "CVE-2024-23076": {"epss_score": 0.00271, "epss_percentile": 0.50344}, "CVE-2024-23077": {"epss_score": 0.00253, "epss_percentile": 0.48461}, "CVE-2024-23078": {"epss_score": 0.00128, "epss_percentile": 0.33023}, "CVE-2024-23079": {"epss_score": 0.00026, "epss_percentile": 0.06556}, "CVE-2024-23080": {"epss_score": 0.00158, "epss_percentile": 0.37223}, "CVE-2024-23081": {"epss_score": 0.00026, "epss_percentile": 0.06623}, "CVE-2024-23082": {"epss_score": 0.00057, "epss_percentile": 0.18166}, "CVE-2024-23083": {"epss_score": 0.00326, "epss_percentile": 0.55055}, "CVE-2024-23084": {"epss_score": 0.00079, "epss_percentile": 0.23914}, "CVE-2024-23085": {"epss_score": 0.00092, "epss_percentile": 0.2658}, "CVE-2024-23086": {"epss_score": 0.00146, "epss_percentile": 0.35541}, "CVE-2024-23091": {"epss_score": 0.00135, "epss_percentile": 0.34022}, "CVE-2024-23094": {"epss_score": 0.00071, "epss_percentile": 0.22054}, "CVE-2024-23105": {"epss_score": 0.00084, "epss_percentile": 0.24867}, "CVE-2024-23106": {"epss_score": 0.00132, "epss_percentile": 0.33618}, "CVE-2024-23107": {"epss_score": 0.00176, "epss_percentile": 0.39443}, "CVE-2024-23108": {"epss_score": 0.91825, "epss_percentile": 0.9967}, "CVE-2024-23109": {"epss_score": 0.05934, "epss_percentile": 0.90339}, "CVE-2024-23110": {"epss_score": 0.00151, "epss_percentile": 0.36345}, "CVE-2024-23111": {"epss_score": 0.00167, "epss_percentile": 0.3833}, "CVE-2024-23112": {"epss_score": 0.00056, "epss_percentile": 0.17896}, "CVE-2024-23113": {"epss_score": 0.51233, "epss_percentile": 0.97771}, "CVE-2024-23114": {"epss_score": 0.01109, "epss_percentile": 0.77643}, "CVE-2024-23115": {"epss_score": 0.786, "epss_percentile": 0.98993}, "CVE-2024-23116": {"epss_score": 0.86031, "epss_percentile": 0.99363}, "CVE-2024-23117": {"epss_score": 0.87385, "epss_percentile": 0.99427}, "CVE-2024-23118": {"epss_score": 0.87385, "epss_percentile": 0.99427}, "CVE-2024-23119": {"epss_score": 0.29577, "epss_percentile": 0.96458}, "CVE-2024-23120": {"epss_score": 0.00319, "epss_percentile": 0.54469}, "CVE-2024-23121": {"epss_score": 0.00429, "epss_percentile": 0.61996}, "CVE-2024-23122": {"epss_score": 0.00371, "epss_percentile": 0.58387}, "CVE-2024-23123": {"epss_score": 0.00371, "epss_percentile": 0.58387}, "CVE-2024-23124": {"epss_score": 0.00362, "epss_percentile": 0.57781}, "CVE-2024-23125": {"epss_score": 0.00054, "epss_percentile": 0.17198}, "CVE-2024-23126": {"epss_score": 0.00107, "epss_percentile": 0.29614}, "CVE-2024-23127": {"epss_score": 0.00273, "epss_percentile": 0.50469}, "CVE-2024-23128": {"epss_score": 0.00273, "epss_percentile": 0.50469}, "CVE-2024-23129": {"epss_score": 0.00234, "epss_percentile": 0.46198}, "CVE-2024-23130": {"epss_score": 0.00316, "epss_percentile": 0.54284}, "CVE-2024-23131": {"epss_score": 0.00316, "epss_percentile": 0.54284}, "CVE-2024-23132": {"epss_score": 0.00261, "epss_percentile": 0.49295}, "CVE-2024-23133": {"epss_score": 0.00093, "epss_percentile": 0.26734}, "CVE-2024-23134": {"epss_score": 0.00347, "epss_percentile": 0.56785}, "CVE-2024-23135": {"epss_score": 0.00685, "epss_percentile": 0.71147}, "CVE-2024-23136": {"epss_score": 0.00319, "epss_percentile": 0.54569}, "CVE-2024-23137": {"epss_score": 0.02174, "epss_percentile": 0.83879}, "CVE-2024-23138": {"epss_score": 0.00235, "epss_percentile": 0.46329}, "CVE-2024-23139": {"epss_score": 0.00069, "epss_percentile": 0.21613}, "CVE-2024-23140": {"epss_score": 0.00502, "epss_percentile": 0.65376}, "CVE-2024-23141": {"epss_score": 0.00434, "epss_percentile": 0.623}, "CVE-2024-23142": {"epss_score": 0.00436, "epss_percentile": 0.62465}, "CVE-2024-23143": {"epss_score": 0.0037, "epss_percentile": 0.58284}, "CVE-2024-23144": {"epss_score": 0.00434, "epss_percentile": 0.623}, "CVE-2024-23145": {"epss_score": 0.00434, "epss_percentile": 0.623}, "CVE-2024-23146": {"epss_score": 0.0037, "epss_percentile": 0.58284}, "CVE-2024-23147": {"epss_score": 0.0037, "epss_percentile": 0.58284}, "CVE-2024-23148": {"epss_score": 0.00434, "epss_percentile": 0.623}, "CVE-2024-23149": {"epss_score": 0.00567, "epss_percentile": 0.67847}, "CVE-2024-23150": {"epss_score": 0.00118, "epss_percentile": 0.31402}, "CVE-2024-23151": {"epss_score": 0.00434, "epss_percentile": 0.623}, "CVE-2024-23152": {"epss_score": 0.00587, "epss_percentile": 0.68466}, "CVE-2024-23153": {"epss_score": 0.00567, "epss_percentile": 0.6786}, "CVE-2024-23154": {"epss_score": 0.00609, "epss_percentile": 0.6913}, "CVE-2024-23155": {"epss_score": 0.00195, "epss_percentile": 0.41709}, "CVE-2024-23156": {"epss_score": 0.00609, "epss_percentile": 0.6913}, "CVE-2024-23157": {"epss_score": 0.00609, "epss_percentile": 0.6913}, "CVE-2024-23158": {"epss_score": 0.00718, "epss_percentile": 0.71936}, "CVE-2024-23159": {"epss_score": 0.00804, "epss_percentile": 0.73626}, "CVE-2024-23168": {"epss_score": 0.0037, "epss_percentile": 0.58286}, "CVE-2024-23169": {"epss_score": 0.00206, "epss_percentile": 0.43072}, "CVE-2024-23170": {"epss_score": 0.00175, "epss_percentile": 0.39288}, "CVE-2024-23171": {"epss_score": 0.00417, "epss_percentile": 0.61237}, "CVE-2024-23172": {"epss_score": 0.00617, "epss_percentile": 0.6934}, "CVE-2024-23173": {"epss_score": 0.00386, "epss_percentile": 0.59249}, "CVE-2024-23174": {"epss_score": 0.00401, "epss_percentile": 0.60245}, "CVE-2024-23177": {"epss_score": 0.00386, "epss_percentile": 0.59249}, "CVE-2024-23178": {"epss_score": 0.00348, "epss_percentile": 0.56802}, "CVE-2024-23179": {"epss_score": 0.00359, "epss_percentile": 0.57594}, "CVE-2024-23180": {"epss_score": 0.022, "epss_percentile": 0.83974}, "CVE-2024-23181": {"epss_score": 0.00584, "epss_percentile": 0.68395}, "CVE-2024-23182": {"epss_score": 0.03807, "epss_percentile": 0.87752}, "CVE-2024-23183": {"epss_score": 0.00283, "epss_percentile": 0.51361}, "CVE-2024-23184": {"epss_score": 0.00149, "epss_percentile": 0.35968}, "CVE-2024-23185": {"epss_score": 0.00153, "epss_percentile": 0.36573}, "CVE-2024-23186": {"epss_score": 0.00447, "epss_percentile": 0.62966}, "CVE-2024-23187": {"epss_score": 0.0047, "epss_percentile": 0.6399}, "CVE-2024-23188": {"epss_score": 0.00105, "epss_percentile": 0.29285}, "CVE-2024-23189": {"epss_score": 0.00107, "epss_percentile": 0.29591}, "CVE-2024-23190": {"epss_score": 0.001, "epss_percentile": 0.28434}, "CVE-2024-23191": {"epss_score": 0.001, "epss_percentile": 0.28434}, "CVE-2024-23192": {"epss_score": 0.00107, "epss_percentile": 0.29591}, "CVE-2024-23193": {"epss_score": 0.00146, "epss_percentile": 0.35556}, "CVE-2024-23194": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2024-23196": {"epss_score": 0.00016, "epss_percentile": 0.02781}, "CVE-2024-23198": {"epss_score": 0.00057, "epss_percentile": 0.17989}, "CVE-2024-23201": {"epss_score": 0.00021, "epss_percentile": 0.04948}, "CVE-2024-23203": {"epss_score": 0.00176, "epss_percentile": 0.39468}, "CVE-2024-23204": {"epss_score": 0.00162, "epss_percentile": 0.37688}, "CVE-2024-23205": {"epss_score": 0.00041, "epss_percentile": 0.12429}, "CVE-2024-23206": {"epss_score": 0.00516, "epss_percentile": 0.66054}, "CVE-2024-23207": {"epss_score": 0.00028, "epss_percentile": 0.07277}, "CVE-2024-23208": {"epss_score": 0.02953, "epss_percentile": 0.86058}, "CVE-2024-23209": {"epss_score": 0.00417, "epss_percentile": 0.6124}, "CVE-2024-23210": {"epss_score": 0.00025, "epss_percentile": 0.06161}, "CVE-2024-23211": {"epss_score": 0.00023, "epss_percentile": 0.05638}, "CVE-2024-23212": {"epss_score": 0.0004, "epss_percentile": 0.11988}, "CVE-2024-23213": {"epss_score": 0.00394, "epss_percentile": 0.59762}, "CVE-2024-23214": {"epss_score": 0.00334, "epss_percentile": 0.55732}, "CVE-2024-23215": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2024-23216": {"epss_score": 9e-05, "epss_percentile": 0.00618}, "CVE-2024-23217": {"epss_score": 0.00012, "epss_percentile": 0.01131}, "CVE-2024-23218": {"epss_score": 0.00175, "epss_percentile": 0.39363}, "CVE-2024-23219": {"epss_score": 0.00086, "epss_percentile": 0.25309}, "CVE-2024-23220": {"epss_score": 0.00063, "epss_percentile": 0.19921}, "CVE-2024-23222": {"epss_score": 0.00191, "epss_percentile": 0.41182}, "CVE-2024-23223": {"epss_score": 0.0002, "epss_percentile": 0.04583}, "CVE-2024-23224": {"epss_score": 0.00028, "epss_percentile": 0.07307}, "CVE-2024-23225": {"epss_score": 0.00104, "epss_percentile": 0.29135}, "CVE-2024-23226": {"epss_score": 0.0088, "epss_percentile": 0.74858}, "CVE-2024-23227": {"epss_score": 0.00024, "epss_percentile": 0.05811}, "CVE-2024-23228": {"epss_score": 0.00131, "epss_percentile": 0.334}, "CVE-2024-23229": {"epss_score": 0.00026, "epss_percentile": 0.06619}, "CVE-2024-23230": {"epss_score": 0.00019, "epss_percentile": 0.04259}, "CVE-2024-23231": {"epss_score": 0.00025, "epss_percentile": 0.06111}, "CVE-2024-23232": {"epss_score": 0.00065, "epss_percentile": 0.20536}, "CVE-2024-23233": {"epss_score": 0.00044, "epss_percentile": 0.13445}, "CVE-2024-23234": {"epss_score": 0.00016, "epss_percentile": 0.02859}, "CVE-2024-23235": {"epss_score": 0.00068, "epss_percentile": 0.21415}, "CVE-2024-23236": {"epss_score": 0.0004, "epss_percentile": 0.11983}, "CVE-2024-23237": {"epss_score": 0.00049, "epss_percentile": 0.15295}, "CVE-2024-23238": {"epss_score": 0.00039, "epss_percentile": 0.1158}, "CVE-2024-23239": {"epss_score": 0.00064, "epss_percentile": 0.20185}, "CVE-2024-23240": {"epss_score": 0.0009, "epss_percentile": 0.26172}, "CVE-2024-23241": {"epss_score": 0.0009, "epss_percentile": 0.26147}, "CVE-2024-23242": {"epss_score": 0.00055, "epss_percentile": 0.17549}, "CVE-2024-23243": {"epss_score": 0.00534, "epss_percentile": 0.66797}, "CVE-2024-23244": {"epss_score": 0.00012, "epss_percentile": 0.0116}, "CVE-2024-23245": {"epss_score": 0.00061, "epss_percentile": 0.1928}, "CVE-2024-23246": {"epss_score": 0.00066, "epss_percentile": 0.2085}, "CVE-2024-23247": {"epss_score": 0.00094, "epss_percentile": 0.27011}, "CVE-2024-23248": {"epss_score": 0.00118, "epss_percentile": 0.31391}, "CVE-2024-23249": {"epss_score": 0.00049, "epss_percentile": 0.15448}, "CVE-2024-23250": {"epss_score": 0.00013, "epss_percentile": 0.01665}, "CVE-2024-23251": {"epss_score": 0.00047, "epss_percentile": 0.14659}, "CVE-2024-23253": {"epss_score": 0.00119, "epss_percentile": 0.31574}, "CVE-2024-23254": {"epss_score": 0.00468, "epss_percentile": 0.63866}, "CVE-2024-23255": {"epss_score": 0.00142, "epss_percentile": 0.34959}, "CVE-2024-23256": {"epss_score": 0.00107, "epss_percentile": 0.29752}, "CVE-2024-23257": {"epss_score": 0.00025, "epss_percentile": 0.06163}, "CVE-2024-23258": {"epss_score": 0.00065, "epss_percentile": 0.20472}, "CVE-2024-23259": {"epss_score": 0.00122, "epss_percentile": 0.32092}, "CVE-2024-23260": {"epss_score": 0.0006, "epss_percentile": 0.19072}, "CVE-2024-23261": {"epss_score": 0.00143, "epss_percentile": 0.35144}, "CVE-2024-23262": {"epss_score": 0.00087, "epss_percentile": 0.25566}, "CVE-2024-23263": {"epss_score": 0.00364, "epss_percentile": 0.57929}, "CVE-2024-23264": {"epss_score": 0.00083, "epss_percentile": 0.24709}, "CVE-2024-23265": {"epss_score": 0.00132, "epss_percentile": 0.3359}, "CVE-2024-23266": {"epss_score": 0.00014, "epss_percentile": 0.01763}, "CVE-2024-23267": {"epss_score": 0.0001, "epss_percentile": 0.00825}, "CVE-2024-23268": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2024-23269": {"epss_score": 0.00015, "epss_percentile": 0.02426}, "CVE-2024-23270": {"epss_score": 0.00041, "epss_percentile": 0.12218}, "CVE-2024-23271": {"epss_score": 0.00065, "epss_percentile": 0.20474}, "CVE-2024-23272": {"epss_score": 0.00021, "epss_percentile": 0.04906}, "CVE-2024-23273": {"epss_score": 0.00147, "epss_percentile": 0.35647}, "CVE-2024-23274": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2024-23275": {"epss_score": 0.00016, "epss_percentile": 0.0281}, "CVE-2024-23276": {"epss_score": 0.0004, "epss_percentile": 0.11987}, "CVE-2024-23277": {"epss_score": 0.00339, "epss_percentile": 0.56173}, "CVE-2024-23278": {"epss_score": 0.00071, "epss_percentile": 0.22012}, "CVE-2024-23279": {"epss_score": 0.00056, "epss_percentile": 0.17781}, "CVE-2024-23280": {"epss_score": 0.0053, "epss_percentile": 0.66618}, "CVE-2024-23281": {"epss_score": 0.00062, "epss_percentile": 0.19801}, "CVE-2024-23282": {"epss_score": 0.00014, "epss_percentile": 0.01793}, "CVE-2024-23283": {"epss_score": 0.00022, "epss_percentile": 0.05036}, "CVE-2024-23284": {"epss_score": 0.0052, "epss_percentile": 0.66189}, "CVE-2024-23285": {"epss_score": 0.00055, "epss_percentile": 0.17404}, "CVE-2024-23286": {"epss_score": 0.01032, "epss_percentile": 0.76862}, "CVE-2024-23287": {"epss_score": 0.0014, "epss_percentile": 0.3475}, "CVE-2024-23288": {"epss_score": 0.00036, "epss_percentile": 0.10202}, "CVE-2024-23289": {"epss_score": 0.00038, "epss_percentile": 0.11123}, "CVE-2024-23290": {"epss_score": 0.00028, "epss_percentile": 0.07274}, "CVE-2024-23291": {"epss_score": 0.00201, "epss_percentile": 0.42278}, "CVE-2024-23292": {"epss_score": 0.00084, "epss_percentile": 0.24954}, "CVE-2024-23293": {"epss_score": 0.00141, "epss_percentile": 0.34871}, "CVE-2024-23294": {"epss_score": 0.00246, "epss_percentile": 0.47805}, "CVE-2024-23295": {"epss_score": 0.0007, "epss_percentile": 0.21653}, "CVE-2024-23296": {"epss_score": 0.00082, "epss_percentile": 0.24575}, "CVE-2024-23297": {"epss_score": 0.00073, "epss_percentile": 0.22635}, "CVE-2024-23298": {"epss_score": 0.03685, "epss_percentile": 0.87567}, "CVE-2024-23299": {"epss_score": 0.00041, "epss_percentile": 0.1232}, "CVE-2024-23300": {"epss_score": 0.00108, "epss_percentile": 0.29774}, "CVE-2024-23301": {"epss_score": 0.00084, "epss_percentile": 0.24955}, "CVE-2024-23302": {"epss_score": 0.00574, "epss_percentile": 0.68073}, "CVE-2024-23304": {"epss_score": 0.00832, "epss_percentile": 0.74077}, "CVE-2024-23305": {"epss_score": 0.00602, "epss_percentile": 0.6889}, "CVE-2024-23306": {"epss_score": 0.00156, "epss_percentile": 0.36949}, "CVE-2024-23307": {"epss_score": 0.00101, "epss_percentile": 0.28693}, "CVE-2024-23308": {"epss_score": 0.00362, "epss_percentile": 0.57769}, "CVE-2024-23309": {"epss_score": 0.00053, "epss_percentile": 0.16938}, "CVE-2024-23310": {"epss_score": 0.00365, "epss_percentile": 0.57994}, "CVE-2024-23312": {"epss_score": 0.00119, "epss_percentile": 0.31592}, "CVE-2024-23313": {"epss_score": 0.00821, "epss_percentile": 0.73908}, "CVE-2024-23314": {"epss_score": 0.00267, "epss_percentile": 0.49996}, "CVE-2024-23315": {"epss_score": 0.00339, "epss_percentile": 0.56193}, "CVE-2024-23316": {"epss_score": 0.00785, "epss_percentile": 0.73262}, "CVE-2024-23317": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2024-23319": {"epss_score": 0.0009, "epss_percentile": 0.26082}, "CVE-2024-23320": {"epss_score": 0.00736, "epss_percentile": 0.72308}, "CVE-2024-23321": {"epss_score": 0.00153, "epss_percentile": 0.3655}, "CVE-2024-23322": {"epss_score": 0.0006, "epss_percentile": 0.19011}, "CVE-2024-23323": {"epss_score": 0.00011, "epss_percentile": 0.01082}, "CVE-2024-23324": {"epss_score": 0.00021, "epss_percentile": 0.04809}, "CVE-2024-23325": {"epss_score": 0.00042, "epss_percentile": 0.12614}, "CVE-2024-23326": {"epss_score": 0.00082, "epss_percentile": 0.24468}, "CVE-2024-23327": {"epss_score": 0.00144, "epss_percentile": 0.3533}, "CVE-2024-23328": {"epss_score": 0.00698, "epss_percentile": 0.71414}, "CVE-2024-23329": {"epss_score": 0.00345, "epss_percentile": 0.56568}, "CVE-2024-23330": {"epss_score": 0.00119, "epss_percentile": 0.31638}, "CVE-2024-23331": {"epss_score": 0.00366, "epss_percentile": 0.58089}, "CVE-2024-23332": {"epss_score": 0.00036, "epss_percentile": 0.10454}, "CVE-2024-23333": {"epss_score": 0.02802, "epss_percentile": 0.85698}, "CVE-2024-23334": {"epss_score": 0.93524, "epss_percentile": 0.99815}, "CVE-2024-23335": {"epss_score": 0.00197, "epss_percentile": 0.4196}, "CVE-2024-23336": {"epss_score": 0.0011, "epss_percentile": 0.3021}, "CVE-2024-23337": {"epss_score": 0.00091, "epss_percentile": 0.26174}, "CVE-2024-23339": {"epss_score": 0.09783, "epss_percentile": 0.927}, "CVE-2024-23340": {"epss_score": 0.00246, "epss_percentile": 0.47784}, "CVE-2024-23341": {"epss_score": 0.00495, "epss_percentile": 0.65128}, "CVE-2024-23342": {"epss_score": 0.00622, "epss_percentile": 0.69502}, "CVE-2024-23344": {"epss_score": 0.00129, "epss_percentile": 0.33216}, "CVE-2024-23345": {"epss_score": 0.00412, "epss_percentile": 0.60956}, "CVE-2024-23346": {"epss_score": 0.41597, "epss_percentile": 0.97285}, "CVE-2024-23347": {"epss_score": 0.00234, "epss_percentile": 0.46112}, "CVE-2024-23348": {"epss_score": 0.00921, "epss_percentile": 0.75477}, "CVE-2024-23349": {"epss_score": 0.03719, "epss_percentile": 0.87618}, "CVE-2024-23350": {"epss_score": 0.00101, "epss_percentile": 0.28566}, "CVE-2024-23351": {"epss_score": 0.00083, "epss_percentile": 0.24784}, "CVE-2024-23352": {"epss_score": 0.00231, "epss_percentile": 0.4585}, "CVE-2024-23353": {"epss_score": 0.003, "epss_percentile": 0.52921}, "CVE-2024-23354": {"epss_score": 0.00134, "epss_percentile": 0.33764}, "CVE-2024-23355": {"epss_score": 0.00207, "epss_percentile": 0.43118}, "CVE-2024-23356": {"epss_score": 0.00152, "epss_percentile": 0.3646}, "CVE-2024-23357": {"epss_score": 0.00148, "epss_percentile": 0.35819}, "CVE-2024-23358": {"epss_score": 0.00228, "epss_percentile": 0.45473}, "CVE-2024-23359": {"epss_score": 0.00133, "epss_percentile": 0.33721}, "CVE-2024-23360": {"epss_score": 0.00094, "epss_percentile": 0.2701}, "CVE-2024-23362": {"epss_score": 0.0012, "epss_percentile": 0.31749}, "CVE-2024-23363": {"epss_score": 0.00228, "epss_percentile": 0.45473}, "CVE-2024-23364": {"epss_score": 0.00228, "epss_percentile": 0.45473}, "CVE-2024-23365": {"epss_score": 0.00102, "epss_percentile": 0.28772}, "CVE-2024-23366": {"epss_score": 0.00032, "epss_percentile": 0.08825}, "CVE-2024-23368": {"epss_score": 0.00111, "epss_percentile": 0.30352}, "CVE-2024-23369": {"epss_score": 0.00061, "epss_percentile": 0.19298}, "CVE-2024-23370": {"epss_score": 0.00045, "epss_percentile": 0.13768}, "CVE-2024-23372": {"epss_score": 0.00145, "epss_percentile": 0.35506}, "CVE-2024-23373": {"epss_score": 0.00181, "epss_percentile": 0.40055}, "CVE-2024-23374": {"epss_score": 0.00045, "epss_percentile": 0.13768}, "CVE-2024-23375": {"epss_score": 0.00045, "epss_percentile": 0.13768}, "CVE-2024-23376": {"epss_score": 0.00045, "epss_percentile": 0.13768}, "CVE-2024-23377": {"epss_score": 0.00105, "epss_percentile": 0.2932}, "CVE-2024-23378": {"epss_score": 0.00045, "epss_percentile": 0.13768}, "CVE-2024-23379": {"epss_score": 0.00045, "epss_percentile": 0.13768}, "CVE-2024-23380": {"epss_score": 0.00182, "epss_percentile": 0.40231}, "CVE-2024-23381": {"epss_score": 0.00152, "epss_percentile": 0.3646}, "CVE-2024-23382": {"epss_score": 0.00152, "epss_percentile": 0.3646}, "CVE-2024-23383": {"epss_score": 0.00152, "epss_percentile": 0.3646}, "CVE-2024-23384": {"epss_score": 0.00146, "epss_percentile": 0.35624}, "CVE-2024-23385": {"epss_score": 0.00182, "epss_percentile": 0.40252}, "CVE-2024-23386": {"epss_score": 0.00109, "epss_percentile": 0.30004}, "CVE-2024-23387": {"epss_score": 0.00101, "epss_percentile": 0.28626}, "CVE-2024-23388": {"epss_score": 0.00356, "epss_percentile": 0.57371}, "CVE-2024-23439": {"epss_score": 0.00025, "epss_percentile": 0.06164}, "CVE-2024-23440": {"epss_score": 0.00025, "epss_percentile": 0.06164}, "CVE-2024-23441": {"epss_score": 0.00025, "epss_percentile": 0.0606}, "CVE-2024-23442": {"epss_score": 0.00408, "epss_percentile": 0.6064}, "CVE-2024-23443": {"epss_score": 0.02217, "epss_percentile": 0.84038}, "CVE-2024-23444": {"epss_score": 0.01217, "epss_percentile": 0.78599}, "CVE-2024-23445": {"epss_score": 0.0027, "epss_percentile": 0.50209}, "CVE-2024-23446": {"epss_score": 0.00217, "epss_percentile": 0.44253}, "CVE-2024-23447": {"epss_score": 0.00116, "epss_percentile": 0.31195}, "CVE-2024-23448": {"epss_score": 0.00243, "epss_percentile": 0.47428}, "CVE-2024-23449": {"epss_score": 0.00047, "epss_percentile": 0.14756}, "CVE-2024-23450": {"epss_score": 0.00586, "epss_percentile": 0.68458}, "CVE-2024-23451": {"epss_score": 0.00175, "epss_percentile": 0.39374}, "CVE-2024-23452": {"epss_score": 0.00315, "epss_percentile": 0.54161}, "CVE-2024-23453": {"epss_score": 0.00046, "epss_percentile": 0.14168}, "CVE-2024-23454": {"epss_score": 0.00038, "epss_percentile": 0.11158}, "CVE-2024-23456": {"epss_score": 0.00043, "epss_percentile": 0.13096}, "CVE-2024-23457": {"epss_score": 0.00064, "epss_percentile": 0.20329}, "CVE-2024-23458": {"epss_score": 0.0004, "epss_percentile": 0.12157}, "CVE-2024-23459": {"epss_score": 0.00074, "epss_percentile": 0.2268}, "CVE-2024-23460": {"epss_score": 0.00027, "epss_percentile": 0.06822}, "CVE-2024-23461": {"epss_score": 0.0005, "epss_percentile": 0.15976}, "CVE-2024-23462": {"epss_score": 0.00046, "epss_percentile": 0.14266}, "CVE-2024-23463": {"epss_score": 0.00071, "epss_percentile": 0.22066}, "CVE-2024-23464": {"epss_score": 0.0009, "epss_percentile": 0.26084}, "CVE-2024-23465": {"epss_score": 0.00034, "epss_percentile": 0.09478}, "CVE-2024-23466": {"epss_score": 0.03178, "epss_percentile": 0.86574}, "CVE-2024-23467": {"epss_score": 0.03391, "epss_percentile": 0.8705}, "CVE-2024-23468": {"epss_score": 0.00636, "epss_percentile": 0.69876}, "CVE-2024-23469": {"epss_score": 0.10513, "epss_percentile": 0.93015}, "CVE-2024-23470": {"epss_score": 0.01989, "epss_percentile": 0.8317}, "CVE-2024-23471": {"epss_score": 0.01592, "epss_percentile": 0.81223}, "CVE-2024-23472": {"epss_score": 0.07457, "epss_percentile": 0.91482}, "CVE-2024-23473": {"epss_score": 0.00135, "epss_percentile": 0.33972}, "CVE-2024-23474": {"epss_score": 0.00065, "epss_percentile": 0.20585}, "CVE-2024-23475": {"epss_score": 0.00244, "epss_percentile": 0.47599}, "CVE-2024-23476": {"epss_score": 0.01937, "epss_percentile": 0.82964}, "CVE-2024-23477": {"epss_score": 0.01406, "epss_percentile": 0.80053}, "CVE-2024-23478": {"epss_score": 0.61859, "epss_percentile": 0.98264}, "CVE-2024-23479": {"epss_score": 0.01299, "epss_percentile": 0.79279}, "CVE-2024-23480": {"epss_score": 0.00031, "epss_percentile": 0.08411}, "CVE-2024-23482": {"epss_score": 0.00032, "epss_percentile": 0.0904}, "CVE-2024-23483": {"epss_score": 0.00537, "epss_percentile": 0.66894}, "CVE-2024-23485": {"epss_score": 0.00052, "epss_percentile": 0.16539}, "CVE-2024-23486": {"epss_score": 0.00631, "epss_percentile": 0.69712}, "CVE-2024-23487": {"epss_score": 0.00097, "epss_percentile": 0.27497}, "CVE-2024-23488": {"epss_score": 0.00197, "epss_percentile": 0.41827}, "CVE-2024-23489": {"epss_score": 0.00087, "epss_percentile": 0.25632}, "CVE-2024-23491": {"epss_score": 0.00061, "epss_percentile": 0.19266}, "CVE-2024-23492": {"epss_score": 0.00042, "epss_percentile": 0.12483}, "CVE-2024-23493": {"epss_score": 0.00158, "epss_percentile": 0.37146}, "CVE-2024-23494": {"epss_score": 0.01185, "epss_percentile": 0.78342}, "CVE-2024-23495": {"epss_score": 0.00045, "epss_percentile": 0.13781}, "CVE-2024-23496": {"epss_score": 0.00197, "epss_percentile": 0.41957}, "CVE-2024-23497": {"epss_score": 0.0025, "epss_percentile": 0.48127}, "CVE-2024-23499": {"epss_score": 0.00167, "epss_percentile": 0.384}, "CVE-2024-23500": {"epss_score": 0.0069, "epss_percentile": 0.71247}, "CVE-2024-23501": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2024-23502": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2024-23503": {"epss_score": 0.00092, "epss_percentile": 0.26439}, "CVE-2024-23504": {"epss_score": 0.00373, "epss_percentile": 0.58528}, "CVE-2024-23505": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2024-23506": {"epss_score": 0.00276, "epss_percentile": 0.50714}, "CVE-2024-23507": {"epss_score": 0.00159, "epss_percentile": 0.37323}, "CVE-2024-23508": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-23510": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2024-23511": {"epss_score": 0.00139, "epss_percentile": 0.34582}, "CVE-2024-23512": {"epss_score": 0.00389, "epss_percentile": 0.59455}, "CVE-2024-23513": {"epss_score": 0.00541, "epss_percentile": 0.67045}, "CVE-2024-23514": {"epss_score": 0.00087, "epss_percentile": 0.2546}, "CVE-2024-23515": {"epss_score": 0.00106, "epss_percentile": 0.29435}, "CVE-2024-23516": {"epss_score": 0.00087, "epss_percentile": 0.2546}, "CVE-2024-23517": {"epss_score": 0.00102, "epss_percentile": 0.28858}, "CVE-2024-23518": {"epss_score": 0.00173, "epss_percentile": 0.3908}, "CVE-2024-23519": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2024-23520": {"epss_score": 0.00134, "epss_percentile": 0.33864}, "CVE-2024-23521": {"epss_score": 0.00111, "epss_percentile": 0.30392}, "CVE-2024-23522": {"epss_score": 0.00307, "epss_percentile": 0.53469}, "CVE-2024-23523": {"epss_score": 0.00276, "epss_percentile": 0.50714}, "CVE-2024-23524": {"epss_score": 0.00231, "epss_percentile": 0.4585}, "CVE-2024-23525": {"epss_score": 0.0029, "epss_percentile": 0.52135}, "CVE-2024-23526": {"epss_score": 0.02878, "epss_percentile": 0.85888}, "CVE-2024-23527": {"epss_score": 0.02461, "epss_percentile": 0.84825}, "CVE-2024-23528": {"epss_score": 0.02878, "epss_percentile": 0.85888}, "CVE-2024-23529": {"epss_score": 0.02878, "epss_percentile": 0.85888}, "CVE-2024-23530": {"epss_score": 0.01343, "epss_percentile": 0.79602}, "CVE-2024-23531": {"epss_score": 0.04466, "epss_percentile": 0.8873}, "CVE-2024-23532": {"epss_score": 0.20807, "epss_percentile": 0.95416}, "CVE-2024-23533": {"epss_score": 0.01796, "epss_percentile": 0.82305}, "CVE-2024-23534": {"epss_score": 0.01811, "epss_percentile": 0.8237}, "CVE-2024-23535": {"epss_score": 0.48209, "epss_percentile": 0.97627}, "CVE-2024-23537": {"epss_score": 0.00073, "epss_percentile": 0.22624}, "CVE-2024-23538": {"epss_score": 0.00192, "epss_percentile": 0.41334}, "CVE-2024-23539": {"epss_score": 0.0052, "epss_percentile": 0.66198}, "CVE-2024-23540": {"epss_score": 0.00384, "epss_percentile": 0.59168}, "CVE-2024-23550": {"epss_score": 0.00054, "epss_percentile": 0.17277}, "CVE-2024-23551": {"epss_score": 0.00048, "epss_percentile": 0.15272}, "CVE-2024-23553": {"epss_score": 0.0031, "epss_percentile": 0.53732}, "CVE-2024-23554": {"epss_score": 0.00236, "epss_percentile": 0.46444}, "CVE-2024-23556": {"epss_score": 0.00127, "epss_percentile": 0.32787}, "CVE-2024-23557": {"epss_score": 0.00382, "epss_percentile": 0.59068}, "CVE-2024-23558": {"epss_score": 0.00122, "epss_percentile": 0.32064}, "CVE-2024-23559": {"epss_score": 0.00412, "epss_percentile": 0.60929}, "CVE-2024-23560": {"epss_score": 0.00128, "epss_percentile": 0.32983}, "CVE-2024-23561": {"epss_score": 0.00382, "epss_percentile": 0.59068}, "CVE-2024-23562": {"epss_score": 0.00857, "epss_percentile": 0.74488}, "CVE-2024-23563": {"epss_score": 0.00024, "epss_percentile": 0.05684}, "CVE-2024-23576": {"epss_score": 0.00168, "epss_percentile": 0.38418}, "CVE-2024-23579": {"epss_score": 0.00134, "epss_percentile": 0.33844}, "CVE-2024-23580": {"epss_score": 0.00133, "epss_percentile": 0.33693}, "CVE-2024-23583": {"epss_score": 0.00035, "epss_percentile": 0.10074}, "CVE-2024-23584": {"epss_score": 0.00031, "epss_percentile": 0.08547}, "CVE-2024-23586": {"epss_score": 0.00278, "epss_percentile": 0.50869}, "CVE-2024-23588": {"epss_score": 0.00127, "epss_percentile": 0.32799}, "CVE-2024-23589": {"epss_score": 0.00011, "epss_percentile": 0.01051}, "CVE-2024-23590": {"epss_score": 0.00311, "epss_percentile": 0.53865}, "CVE-2024-23591": {"epss_score": 0.00034, "epss_percentile": 0.09743}, "CVE-2024-23592": {"epss_score": 0.0001, "epss_percentile": 0.00749}, "CVE-2024-23593": {"epss_score": 0.00046, "epss_percentile": 0.14334}, "CVE-2024-23594": {"epss_score": 0.00035, "epss_percentile": 0.10124}, "CVE-2024-23597": {"epss_score": 0.00152, "epss_percentile": 0.36428}, "CVE-2024-23599": {"epss_score": 0.0003, "epss_percentile": 0.08013}, "CVE-2024-23600": {"epss_score": 0.00382, "epss_percentile": 0.59056}, "CVE-2024-23601": {"epss_score": 0.01203, "epss_percentile": 0.78495}, "CVE-2024-23603": {"epss_score": 0.0029, "epss_percentile": 0.52128}, "CVE-2024-23604": {"epss_score": 0.00248, "epss_percentile": 0.47992}, "CVE-2024-23605": {"epss_score": 0.00197, "epss_percentile": 0.41957}, "CVE-2024-23606": {"epss_score": 0.00251, "epss_percentile": 0.48296}, "CVE-2024-23607": {"epss_score": 0.00168, "epss_percentile": 0.38501}, "CVE-2024-23608": {"epss_score": 0.01442, "epss_percentile": 0.80307}, "CVE-2024-23609": {"epss_score": 0.00394, "epss_percentile": 0.59757}, "CVE-2024-23610": {"epss_score": 0.01442, "epss_percentile": 0.80307}, "CVE-2024-23611": {"epss_score": 0.01066, "epss_percentile": 0.77217}, "CVE-2024-23612": {"epss_score": 0.00394, "epss_percentile": 0.59757}, "CVE-2024-23613": {"epss_score": 0.07652, "epss_percentile": 0.91605}, "CVE-2024-23614": {"epss_score": 0.0213, "epss_percentile": 0.83709}, "CVE-2024-23615": {"epss_score": 0.06296, "epss_percentile": 0.90652}, "CVE-2024-23616": {"epss_score": 0.06296, "epss_percentile": 0.90652}, "CVE-2024-23617": {"epss_score": 0.02375, "epss_percentile": 0.84539}, "CVE-2024-23618": {"epss_score": 0.00274, "epss_percentile": 0.50556}, "CVE-2024-23619": {"epss_score": 0.00945, "epss_percentile": 0.75802}, "CVE-2024-23620": {"epss_score": 0.00025, "epss_percentile": 0.06057}, "CVE-2024-23621": {"epss_score": 0.00941, "epss_percentile": 0.75758}, "CVE-2024-23622": {"epss_score": 0.00946, "epss_percentile": 0.75805}, "CVE-2024-23624": {"epss_score": 0.10009, "epss_percentile": 0.92816}, "CVE-2024-23625": {"epss_score": 0.10009, "epss_percentile": 0.92816}, "CVE-2024-23626": {"epss_score": 0.01166, "epss_percentile": 0.78182}, "CVE-2024-23627": {"epss_score": 0.01166, "epss_percentile": 0.78182}, "CVE-2024-23628": {"epss_score": 0.00137, "epss_percentile": 0.3424}, "CVE-2024-23629": {"epss_score": 0.00057, "epss_percentile": 0.18078}, "CVE-2024-23630": {"epss_score": 0.00117, "epss_percentile": 0.31283}, "CVE-2024-23633": {"epss_score": 0.00111, "epss_percentile": 0.30307}, "CVE-2024-23634": {"epss_score": 0.00879, "epss_percentile": 0.74837}, "CVE-2024-23635": {"epss_score": 0.00156, "epss_percentile": 0.36891}, "CVE-2024-23636": {"epss_score": 0.00717, "epss_percentile": 0.71873}, "CVE-2024-23637": {"epss_score": 0.00025, "epss_percentile": 0.06247}, "CVE-2024-23638": {"epss_score": 0.14256, "epss_percentile": 0.94174}, "CVE-2024-23639": {"epss_score": 0.00031, "epss_percentile": 0.08612}, "CVE-2024-23640": {"epss_score": 0.00416, "epss_percentile": 0.61216}, "CVE-2024-23641": {"epss_score": 0.00263, "epss_percentile": 0.49533}, "CVE-2024-23642": {"epss_score": 0.00401, "epss_percentile": 0.60211}, "CVE-2024-23643": {"epss_score": 0.00409, "epss_percentile": 0.60756}, "CVE-2024-23644": {"epss_score": 0.00507, "epss_percentile": 0.65657}, "CVE-2024-23645": {"epss_score": 0.00583, "epss_percentile": 0.68351}, "CVE-2024-23646": {"epss_score": 0.00135, "epss_percentile": 0.34037}, "CVE-2024-23647": {"epss_score": 0.00055, "epss_percentile": 0.17614}, "CVE-2024-23648": {"epss_score": 0.00014, "epss_percentile": 0.01918}, "CVE-2024-23649": {"epss_score": 0.00283, "epss_percentile": 0.51348}, "CVE-2024-23650": {"epss_score": 0.00081, "epss_percentile": 0.24263}, "CVE-2024-23651": {"epss_score": 0.00461, "epss_percentile": 0.63569}, "CVE-2024-23652": {"epss_score": 0.03842, "epss_percentile": 0.87833}, "CVE-2024-23653": {"epss_score": 0.08854, "epss_percentile": 0.92286}, "CVE-2024-23654": {"epss_score": 0.00127, "epss_percentile": 0.32804}, "CVE-2024-23655": {"epss_score": 0.00233, "epss_percentile": 0.46041}, "CVE-2024-23656": {"epss_score": 0.00182, "epss_percentile": 0.40251}, "CVE-2024-23657": {"epss_score": 0.01617, "epss_percentile": 0.81367}, "CVE-2024-23658": {"epss_score": 0.00011, "epss_percentile": 0.0108}, "CVE-2024-23659": {"epss_score": 0.00878, "epss_percentile": 0.74833}, "CVE-2024-23660": {"epss_score": 0.00146, "epss_percentile": 0.35556}, "CVE-2024-23662": {"epss_score": 0.00367, "epss_percentile": 0.58108}, "CVE-2024-23663": {"epss_score": 0.00697, "epss_percentile": 0.71402}, "CVE-2024-23664": {"epss_score": 0.00334, "epss_percentile": 0.55685}, "CVE-2024-23665": {"epss_score": 0.00273, "epss_percentile": 0.50428}, "CVE-2024-23666": {"epss_score": 0.07648, "epss_percentile": 0.91602}, "CVE-2024-23667": {"epss_score": 0.00202, "epss_percentile": 0.4243}, "CVE-2024-23668": {"epss_score": 0.00512, "epss_percentile": 0.65854}, "CVE-2024-23669": {"epss_score": 0.00268, "epss_percentile": 0.50072}, "CVE-2024-23670": {"epss_score": 0.00202, "epss_percentile": 0.4243}, "CVE-2024-23671": {"epss_score": 0.00827, "epss_percentile": 0.7398}, "CVE-2024-23672": {"epss_score": 0.00577, "epss_percentile": 0.6817}, "CVE-2024-23673": {"epss_score": 0.00194, "epss_percentile": 0.41554}, "CVE-2024-23674": {"epss_score": 0.00044, "epss_percentile": 0.13445}, "CVE-2024-23675": {"epss_score": 0.0009, "epss_percentile": 0.26142}, "CVE-2024-23676": {"epss_score": 0.00203, "epss_percentile": 0.42565}, "CVE-2024-23677": {"epss_score": 0.00299, "epss_percentile": 0.52875}, "CVE-2024-23678": {"epss_score": 0.0011, "epss_percentile": 0.30222}, "CVE-2024-23679": {"epss_score": 0.01219, "epss_percentile": 0.78613}, "CVE-2024-23680": {"epss_score": 0.00095, "epss_percentile": 0.27089}, "CVE-2024-23681": {"epss_score": 0.00237, "epss_percentile": 0.46718}, "CVE-2024-23682": {"epss_score": 0.00215, "epss_percentile": 0.4404}, "CVE-2024-23683": {"epss_score": 0.0012, "epss_percentile": 0.31809}, "CVE-2024-23684": {"epss_score": 0.01774, "epss_percentile": 0.82209}, "CVE-2024-23685": {"epss_score": 0.00389, "epss_percentile": 0.59497}, "CVE-2024-23686": {"epss_score": 0.00529, "epss_percentile": 0.66595}, "CVE-2024-23687": {"epss_score": 0.00577, "epss_percentile": 0.68157}, "CVE-2024-23688": {"epss_score": 0.00416, "epss_percentile": 0.61182}, "CVE-2024-23689": {"epss_score": 0.00965, "epss_percentile": 0.76047}, "CVE-2024-23690": {"epss_score": 0.00617, "epss_percentile": 0.69342}, "CVE-2024-23692": {"epss_score": 0.94297, "epss_percentile": 0.99939}, "CVE-2024-23695": {"epss_score": 0.00029, "epss_percentile": 0.07898}, "CVE-2024-23696": {"epss_score": 0.00031, "epss_percentile": 0.08656}, "CVE-2024-23697": {"epss_score": 0.0003, "epss_percentile": 0.08215}, "CVE-2024-23698": {"epss_score": 0.00029, "epss_percentile": 0.07898}, "CVE-2024-23704": {"epss_score": 5e-05, "epss_percentile": 0.00192}, "CVE-2024-23705": {"epss_score": 0.00056, "epss_percentile": 0.17675}, "CVE-2024-23706": {"epss_score": 4e-05, "epss_percentile": 0.00126}, "CVE-2024-23707": {"epss_score": 3e-05, "epss_percentile": 0.00121}, "CVE-2024-23708": {"epss_score": 0.00101, "epss_percentile": 0.2867}, "CVE-2024-23709": {"epss_score": 0.04353, "epss_percentile": 0.88589}, "CVE-2024-23710": {"epss_score": 0.00033, "epss_percentile": 0.09395}, "CVE-2024-23711": {"epss_score": 0.00045, "epss_percentile": 0.13984}, "CVE-2024-23712": {"epss_score": 0.00048, "epss_percentile": 0.15267}, "CVE-2024-23713": {"epss_score": 0.00025, "epss_percentile": 0.06106}, "CVE-2024-23715": {"epss_score": 0.00066, "epss_percentile": 0.20818}, "CVE-2024-23716": {"epss_score": 0.00044, "epss_percentile": 0.13384}, "CVE-2024-23717": {"epss_score": 0.00236, "epss_percentile": 0.46379}, "CVE-2024-23721": {"epss_score": 0.01523, "epss_percentile": 0.80844}, "CVE-2024-23722": {"epss_score": 0.00672, "epss_percentile": 0.70821}, "CVE-2024-23724": {"epss_score": 0.38762, "epss_percentile": 0.97119}, "CVE-2024-23725": {"epss_score": 0.00163, "epss_percentile": 0.37769}, "CVE-2024-23726": {"epss_score": 0.00703, "epss_percentile": 0.71546}, "CVE-2024-23727": {"epss_score": 0.0116, "epss_percentile": 0.78134}, "CVE-2024-23729": {"epss_score": 0.00417, "epss_percentile": 0.61254}, "CVE-2024-23730": {"epss_score": 0.00243, "epss_percentile": 0.47475}, "CVE-2024-23731": {"epss_score": 0.00131, "epss_percentile": 0.33445}, "CVE-2024-23732": {"epss_score": 0.00055, "epss_percentile": 0.17521}, "CVE-2024-23733": {"epss_score": 0.09167, "epss_percentile": 0.92429}, "CVE-2024-23734": {"epss_score": 0.00169, "epss_percentile": 0.38568}, "CVE-2024-23735": {"epss_score": 0.00643, "epss_percentile": 0.70058}, "CVE-2024-23736": {"epss_score": 0.00265, "epss_percentile": 0.49775}, "CVE-2024-23737": {"epss_score": 0.00186, "epss_percentile": 0.40648}, "CVE-2024-23738": {"epss_score": 0.10122, "epss_percentile": 0.92859}, "CVE-2024-23739": {"epss_score": 0.30367, "epss_percentile": 0.96534}, "CVE-2024-23740": {"epss_score": 0.19038, "epss_percentile": 0.95117}, "CVE-2024-23741": {"epss_score": 0.19848, "epss_percentile": 0.9525}, "CVE-2024-23742": {"epss_score": 0.16278, "epss_percentile": 0.94609}, "CVE-2024-23743": {"epss_score": 0.00137, "epss_percentile": 0.34339}, "CVE-2024-23744": {"epss_score": 0.00049, "epss_percentile": 0.15504}, "CVE-2024-23745": {"epss_score": 0.02349, "epss_percentile": 0.84464}, "CVE-2024-23746": {"epss_score": 0.00626, "epss_percentile": 0.69618}, "CVE-2024-23747": {"epss_score": 0.00752, "epss_percentile": 0.72659}, "CVE-2024-23749": {"epss_score": 0.00262, "epss_percentile": 0.49404}, "CVE-2024-23750": {"epss_score": 0.00527, "epss_percentile": 0.66465}, "CVE-2024-23751": {"epss_score": 0.00276, "epss_percentile": 0.50701}, "CVE-2024-23752": {"epss_score": 0.00685, "epss_percentile": 0.71132}, "CVE-2024-23755": {"epss_score": 0.0167, "epss_percentile": 0.81668}, "CVE-2024-23756": {"epss_score": 0.00216, "epss_percentile": 0.44185}, "CVE-2024-23758": {"epss_score": 0.00207, "epss_percentile": 0.43139}, "CVE-2024-23759": {"epss_score": 0.64419, "epss_percentile": 0.98378}, "CVE-2024-23760": {"epss_score": 0.00059, "epss_percentile": 0.18644}, "CVE-2024-23761": {"epss_score": 0.00093, "epss_percentile": 0.26656}, "CVE-2024-23762": {"epss_score": 0.00035, "epss_percentile": 0.09924}, "CVE-2024-23763": {"epss_score": 0.00094, "epss_percentile": 0.26794}, "CVE-2024-23764": {"epss_score": 0.00031, "epss_percentile": 0.08688}, "CVE-2024-23765": {"epss_score": 0.00045, "epss_percentile": 0.13682}, "CVE-2024-23766": {"epss_score": 0.00277, "epss_percentile": 0.50835}, "CVE-2024-23767": {"epss_score": 0.00232, "epss_percentile": 0.45891}, "CVE-2024-23768": {"epss_score": 0.00483, "epss_percentile": 0.64575}, "CVE-2024-23769": {"epss_score": 0.00053, "epss_percentile": 0.16842}, "CVE-2024-23770": {"epss_score": 0.00027, "epss_percentile": 0.07107}, "CVE-2024-23771": {"epss_score": 0.00209, "epss_percentile": 0.43424}, "CVE-2024-23772": {"epss_score": 0.00173, "epss_percentile": 0.39116}, "CVE-2024-23773": {"epss_score": 0.00333, "epss_percentile": 0.55678}, "CVE-2024-23774": {"epss_score": 0.00518, "epss_percentile": 0.66092}, "CVE-2024-23775": {"epss_score": 0.00291, "epss_percentile": 0.52145}, "CVE-2024-23782": {"epss_score": 0.00383, "epss_percentile": 0.59095}, "CVE-2024-23783": {"epss_score": 0.00238, "epss_percentile": 0.46785}, "CVE-2024-23784": {"epss_score": 0.0016, "epss_percentile": 0.37474}, "CVE-2024-23785": {"epss_score": 0.00115, "epss_percentile": 0.30977}, "CVE-2024-23786": {"epss_score": 0.02544, "epss_percentile": 0.8506}, "CVE-2024-23787": {"epss_score": 0.00805, "epss_percentile": 0.73644}, "CVE-2024-23788": {"epss_score": 0.00309, "epss_percentile": 0.53704}, "CVE-2024-23789": {"epss_score": 0.00726, "epss_percentile": 0.72081}, "CVE-2024-23790": {"epss_score": 0.0019, "epss_percentile": 0.41097}, "CVE-2024-23791": {"epss_score": 0.00144, "epss_percentile": 0.35307}, "CVE-2024-23792": {"epss_score": 0.00102, "epss_percentile": 0.28743}, "CVE-2024-23793": {"epss_score": 0.00243, "epss_percentile": 0.47457}, "CVE-2024-23794": {"epss_score": 0.00146, "epss_percentile": 0.35553}, "CVE-2024-23795": {"epss_score": 0.00073, "epss_percentile": 0.22511}, "CVE-2024-23796": {"epss_score": 0.00089, "epss_percentile": 0.25975}, "CVE-2024-23797": {"epss_score": 0.00089, "epss_percentile": 0.25975}, "CVE-2024-23798": {"epss_score": 0.00089, "epss_percentile": 0.25975}, "CVE-2024-23799": {"epss_score": 0.0004, "epss_percentile": 0.11965}, "CVE-2024-23800": {"epss_score": 0.0004, "epss_percentile": 0.11965}, "CVE-2024-23801": {"epss_score": 0.0004, "epss_percentile": 0.11965}, "CVE-2024-23802": {"epss_score": 0.00095, "epss_percentile": 0.2718}, "CVE-2024-23803": {"epss_score": 0.00095, "epss_percentile": 0.27161}, "CVE-2024-23804": {"epss_score": 0.00089, "epss_percentile": 0.25975}, "CVE-2024-23805": {"epss_score": 0.00308, "epss_percentile": 0.53582}, "CVE-2024-23806": {"epss_score": 0.00051, "epss_percentile": 0.15994}, "CVE-2024-23807": {"epss_score": 0.00401, "epss_percentile": 0.60251}, "CVE-2024-23808": {"epss_score": 0.00092, "epss_percentile": 0.26582}, "CVE-2024-23809": {"epss_score": 0.00259, "epss_percentile": 0.4906}, "CVE-2024-23810": {"epss_score": 0.00759, "epss_percentile": 0.72786}, "CVE-2024-23811": {"epss_score": 0.01549, "epss_percentile": 0.80982}, "CVE-2024-23812": {"epss_score": 0.00709, "epss_percentile": 0.71686}, "CVE-2024-23813": {"epss_score": 0.00144, "epss_percentile": 0.35286}, "CVE-2024-23814": {"epss_score": 0.0024, "epss_percentile": 0.47231}, "CVE-2024-23815": {"epss_score": 0.00047, "epss_percentile": 0.14689}, "CVE-2024-23816": {"epss_score": 0.01914, "epss_percentile": 0.82849}, "CVE-2024-23817": {"epss_score": 0.00609, "epss_percentile": 0.69099}, "CVE-2024-23818": {"epss_score": 0.00452, "epss_percentile": 0.63193}, "CVE-2024-23819": {"epss_score": 0.00401, "epss_percentile": 0.60211}, "CVE-2024-23820": {"epss_score": 0.00069, "epss_percentile": 0.21542}, "CVE-2024-23821": {"epss_score": 0.00462, "epss_percentile": 0.63583}, "CVE-2024-23822": {"epss_score": 0.00304, "epss_percentile": 0.53258}, "CVE-2024-23823": {"epss_score": 0.00197, "epss_percentile": 0.41832}, "CVE-2024-23824": {"epss_score": 0.00085, "epss_percentile": 0.2519}, "CVE-2024-23825": {"epss_score": 0.00398, "epss_percentile": 0.60078}, "CVE-2024-23826": {"epss_score": 0.0012, "epss_percentile": 0.31791}, "CVE-2024-23827": {"epss_score": 0.02965, "epss_percentile": 0.8608}, "CVE-2024-23828": {"epss_score": 0.01379, "epss_percentile": 0.79857}, "CVE-2024-23829": {"epss_score": 0.0038, "epss_percentile": 0.58968}, "CVE-2024-23830": {"epss_score": 0.0133, "epss_percentile": 0.79509}, "CVE-2024-23831": {"epss_score": 0.0023, "epss_percentile": 0.45691}, "CVE-2024-23832": {"epss_score": 0.01624, "epss_percentile": 0.81415}, "CVE-2024-23833": {"epss_score": 0.01124, "epss_percentile": 0.77801}, "CVE-2024-23834": {"epss_score": 0.00392, "epss_percentile": 0.59671}, "CVE-2024-23835": {"epss_score": 0.00256, "epss_percentile": 0.48796}, "CVE-2024-23836": {"epss_score": 0.00847, "epss_percentile": 0.74347}, "CVE-2024-23837": {"epss_score": 0.00269, "epss_percentile": 0.50108}, "CVE-2024-23838": {"epss_score": 0.0013, "epss_percentile": 0.33319}, "CVE-2024-23839": {"epss_score": 0.00213, "epss_percentile": 0.43833}, "CVE-2024-23840": {"epss_score": 0.00063, "epss_percentile": 0.19987}, "CVE-2024-23841": {"epss_score": 0.00496, "epss_percentile": 0.65153}, "CVE-2024-23842": {"epss_score": 0.00285, "epss_percentile": 0.51661}, "CVE-2024-23843": {"epss_score": 0.0007, "epss_percentile": 0.21836}, "CVE-2024-23847": {"epss_score": 0.00092, "epss_percentile": 0.26412}, "CVE-2024-23848": {"epss_score": 0.0001, "epss_percentile": 0.00757}, "CVE-2024-23849": {"epss_score": 0.00025, "epss_percentile": 0.06145}, "CVE-2024-23850": {"epss_score": 0.00014, "epss_percentile": 0.01898}, "CVE-2024-23851": {"epss_score": 0.00018, "epss_percentile": 0.03929}, "CVE-2024-23855": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23856": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23857": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23858": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23859": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23860": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23861": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23862": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23863": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23864": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23865": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23866": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23867": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23868": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23869": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23870": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23871": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23872": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23873": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23874": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23875": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23876": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23877": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23878": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23879": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23880": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23881": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23882": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23883": {"epss_score": 0.0007, "epss_percentile": 0.21679}, "CVE-2024-23884": {"epss_score": 0.0007, "epss_percentile": 0.21679}, "CVE-2024-23885": {"epss_score": 0.0007, "epss_percentile": 0.21679}, "CVE-2024-23886": {"epss_score": 0.0007, "epss_percentile": 0.21679}, "CVE-2024-23887": {"epss_score": 0.0007, "epss_percentile": 0.21679}, "CVE-2024-23888": {"epss_score": 0.0007, "epss_percentile": 0.21679}, "CVE-2024-23889": {"epss_score": 0.0007, "epss_percentile": 0.21679}, "CVE-2024-23890": {"epss_score": 0.0007, "epss_percentile": 0.21679}, "CVE-2024-23891": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23892": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23893": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23894": {"epss_score": 0.00051, "epss_percentile": 0.16204}, "CVE-2024-23895": {"epss_score": 0.00051, "epss_percentile": 0.15987}, "CVE-2024-23896": {"epss_score": 0.00051, "epss_percentile": 0.15987}, "CVE-2024-23897": {"epss_score": 0.94466, "epss_percentile": 0.99995}, "CVE-2024-23898": {"epss_score": 0.36607, "epss_percentile": 0.9699}, "CVE-2024-23899": {"epss_score": 0.00494, "epss_percentile": 0.65086}, "CVE-2024-23900": {"epss_score": 0.00058, "epss_percentile": 0.18578}, "CVE-2024-23901": {"epss_score": 0.00088, "epss_percentile": 0.25775}, "CVE-2024-23902": {"epss_score": 0.00048, "epss_percentile": 0.15228}, "CVE-2024-23903": {"epss_score": 0.0008, "epss_percentile": 0.24123}, "CVE-2024-23904": {"epss_score": 0.00133, "epss_percentile": 0.33743}, "CVE-2024-23905": {"epss_score": 0.00182, "epss_percentile": 0.40139}, "CVE-2024-23906": {"epss_score": 0.00206, "epss_percentile": 0.4294}, "CVE-2024-23907": {"epss_score": 0.00087, "epss_percentile": 0.25632}, "CVE-2024-23908": {"epss_score": 0.00071, "epss_percentile": 0.22211}, "CVE-2024-23909": {"epss_score": 0.00087, "epss_percentile": 0.25632}, "CVE-2024-23910": {"epss_score": 0.00209, "epss_percentile": 0.43382}, "CVE-2024-23911": {"epss_score": 0.00216, "epss_percentile": 0.44229}, "CVE-2024-23912": {"epss_score": 0.00024, "epss_percentile": 0.05845}, "CVE-2024-23913": {"epss_score": 0.00024, "epss_percentile": 0.05964}, "CVE-2024-23914": {"epss_score": 0.00031, "epss_percentile": 0.08535}, "CVE-2024-23915": {"epss_score": 0.00119, "epss_percentile": 0.31609}, "CVE-2024-23916": {"epss_score": 0.00119, "epss_percentile": 0.31609}, "CVE-2024-23917": {"epss_score": 0.94417, "epss_percentile": 0.99977}, "CVE-2024-23918": {"epss_score": 0.0006, "epss_percentile": 0.19031}, "CVE-2024-23919": {"epss_score": 0.0009, "epss_percentile": 0.26}, "CVE-2024-23920": {"epss_score": 0.00094, "epss_percentile": 0.26993}, "CVE-2024-23921": {"epss_score": 0.00084, "epss_percentile": 0.24827}, "CVE-2024-23922": {"epss_score": 0.00719, "epss_percentile": 0.71954}, "CVE-2024-23923": {"epss_score": 0.00864, "epss_percentile": 0.74597}, "CVE-2024-23924": {"epss_score": 0.02377, "epss_percentile": 0.84553}, "CVE-2024-23928": {"epss_score": 0.00129, "epss_percentile": 0.33149}, "CVE-2024-23929": {"epss_score": 0.00041, "epss_percentile": 0.12251}, "CVE-2024-23930": {"epss_score": 0.00169, "epss_percentile": 0.38647}, "CVE-2024-23933": {"epss_score": 0.0212, "epss_percentile": 0.83672}, "CVE-2024-23934": {"epss_score": 0.01485, "epss_percentile": 0.80594}, "CVE-2024-23935": {"epss_score": 0.00674, "epss_percentile": 0.70846}, "CVE-2024-23937": {"epss_score": 0.00111, "epss_percentile": 0.30339}, "CVE-2024-23938": {"epss_score": 0.00908, "epss_percentile": 0.75279}, "CVE-2024-23940": {"epss_score": 0.00062, "epss_percentile": 0.19601}, "CVE-2024-23941": {"epss_score": 0.00202, "epss_percentile": 0.4242}, "CVE-2024-23942": {"epss_score": 0.00015, "epss_percentile": 0.02508}, "CVE-2024-23943": {"epss_score": 0.00146, "epss_percentile": 0.35575}, "CVE-2024-23944": {"epss_score": 0.00028, "epss_percentile": 0.07259}, "CVE-2024-23945": {"epss_score": 0.07646, "epss_percentile": 0.91599}, "CVE-2024-23946": {"epss_score": 0.02712, "epss_percentile": 0.85499}, "CVE-2024-23947": {"epss_score": 0.00233, "epss_percentile": 0.46036}, "CVE-2024-23948": {"epss_score": 0.00236, "epss_percentile": 0.46453}, "CVE-2024-23949": {"epss_score": 0.0021, "epss_percentile": 0.43454}, "CVE-2024-23950": {"epss_score": 0.0021, "epss_percentile": 0.43454}, "CVE-2024-23951": {"epss_score": 0.0021, "epss_percentile": 0.43454}, "CVE-2024-23952": {"epss_score": 0.01378, "epss_percentile": 0.7985}, "CVE-2024-23953": {"epss_score": 0.01643, "epss_percentile": 0.81519}, "CVE-2024-23957": {"epss_score": 0.0224, "epss_percentile": 0.84111}, "CVE-2024-23958": {"epss_score": 0.00023, "epss_percentile": 0.05375}, "CVE-2024-23959": {"epss_score": 0.00413, "epss_percentile": 0.61013}, "CVE-2024-23960": {"epss_score": 8e-05, "epss_percentile": 0.00552}, "CVE-2024-23961": {"epss_score": 0.01234, "epss_percentile": 0.78753}, "CVE-2024-23962": {"epss_score": 0.0065, "epss_percentile": 0.7027}, "CVE-2024-23963": {"epss_score": 0.00114, "epss_percentile": 0.30775}, "CVE-2024-23967": {"epss_score": 0.00438, "epss_percentile": 0.62548}, "CVE-2024-23968": {"epss_score": 0.0011, "epss_percentile": 0.30225}, "CVE-2024-23969": {"epss_score": 0.0011, "epss_percentile": 0.30225}, "CVE-2024-23970": {"epss_score": 0.00133, "epss_percentile": 0.33656}, "CVE-2024-23971": {"epss_score": 0.00067, "epss_percentile": 0.21064}, "CVE-2024-23972": {"epss_score": 0.02468, "epss_percentile": 0.84839}, "CVE-2024-23973": {"epss_score": 0.00206, "epss_percentile": 0.42936}, "CVE-2024-23974": {"epss_score": 0.00052, "epss_percentile": 0.16671}, "CVE-2024-23975": {"epss_score": 0.01185, "epss_percentile": 0.78342}, "CVE-2024-23976": {"epss_score": 0.00016, "epss_percentile": 0.02809}, "CVE-2024-23978": {"epss_score": 0.00364, "epss_percentile": 0.57911}, "CVE-2024-23979": {"epss_score": 0.00203, "epss_percentile": 0.42525}, "CVE-2024-23980": {"epss_score": 0.00096, "epss_percentile": 0.27263}, "CVE-2024-23981": {"epss_score": 0.00243, "epss_percentile": 0.47501}, "CVE-2024-23982": {"epss_score": 0.00308, "epss_percentile": 0.53582}, "CVE-2024-23983": {"epss_score": 0.00083, "epss_percentile": 0.24601}, "CVE-2024-23984": {"epss_score": 0.00024, "epss_percentile": 0.06023}, "CVE-2024-23985": {"epss_score": 0.32811, "epss_percentile": 0.96729}, "CVE-2024-23995": {"epss_score": 0.01466, "epss_percentile": 0.80467}, "CVE-2024-23997": {"epss_score": 0.04862, "epss_percentile": 0.89222}, "CVE-2024-23998": {"epss_score": 0.12202, "epss_percentile": 0.93601}, "CVE-2024-24000": {"epss_score": 0.00164, "epss_percentile": 0.3791}, "CVE-2024-24001": {"epss_score": 0.00059, "epss_percentile": 0.18705}, "CVE-2024-24002": {"epss_score": 0.00127, "epss_percentile": 0.32793}, "CVE-2024-24003": {"epss_score": 0.001, "epss_percentile": 0.28513}, "CVE-2024-24004": {"epss_score": 0.00118, "epss_percentile": 0.31477}, "CVE-2024-24013": {"epss_score": 0.00086, "epss_percentile": 0.25374}, "CVE-2024-24014": {"epss_score": 0.00091, "epss_percentile": 0.26175}, "CVE-2024-24015": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2024-24017": {"epss_score": 0.00064, "epss_percentile": 0.20177}, "CVE-2024-24018": {"epss_score": 0.00076, "epss_percentile": 0.23281}, "CVE-2024-24019": {"epss_score": 0.00072, "epss_percentile": 0.223}, "CVE-2024-24021": {"epss_score": 0.00086, "epss_percentile": 0.25374}, "CVE-2024-24023": {"epss_score": 0.00069, "epss_percentile": 0.21587}, "CVE-2024-24024": {"epss_score": 0.00103, "epss_percentile": 0.29045}, "CVE-2024-24025": {"epss_score": 0.00103, "epss_percentile": 0.29045}, "CVE-2024-24026": {"epss_score": 0.00099, "epss_percentile": 0.28387}, "CVE-2024-24027": {"epss_score": 0.00133, "epss_percentile": 0.33661}, "CVE-2024-24028": {"epss_score": 0.00062, "epss_percentile": 0.19584}, "CVE-2024-24029": {"epss_score": 0.00061, "epss_percentile": 0.19501}, "CVE-2024-24034": {"epss_score": 0.00276, "epss_percentile": 0.50724}, "CVE-2024-24035": {"epss_score": 0.00228, "epss_percentile": 0.45519}, "CVE-2024-24041": {"epss_score": 0.00162, "epss_percentile": 0.37701}, "CVE-2024-24042": {"epss_score": 0.02588, "epss_percentile": 0.85172}, "CVE-2024-24043": {"epss_score": 0.00049, "epss_percentile": 0.15424}, "CVE-2024-24050": {"epss_score": 0.00076, "epss_percentile": 0.23239}, "CVE-2024-24051": {"epss_score": 0.00046, "epss_percentile": 0.14298}, "CVE-2024-24059": {"epss_score": 0.00131, "epss_percentile": 0.33419}, "CVE-2024-24060": {"epss_score": 0.00101, "epss_percentile": 0.28678}, "CVE-2024-24061": {"epss_score": 0.00077, "epss_percentile": 0.23545}, "CVE-2024-24062": {"epss_score": 0.00096, "epss_percentile": 0.2742}, "CVE-2024-24091": {"epss_score": 0.01222, "epss_percentile": 0.78659}, "CVE-2024-24092": {"epss_score": 0.00071, "epss_percentile": 0.22014}, "CVE-2024-24093": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2024-24095": {"epss_score": 0.00083, "epss_percentile": 0.24599}, "CVE-2024-24096": {"epss_score": 0.00039, "epss_percentile": 0.11591}, "CVE-2024-24097": {"epss_score": 0.00184, "epss_percentile": 0.40422}, "CVE-2024-24098": {"epss_score": 0.00054, "epss_percentile": 0.17098}, "CVE-2024-24099": {"epss_score": 0.00061, "epss_percentile": 0.19245}, "CVE-2024-24100": {"epss_score": 0.00057, "epss_percentile": 0.18125}, "CVE-2024-24101": {"epss_score": 0.0011, "epss_percentile": 0.30221}, "CVE-2024-24105": {"epss_score": 0.00075, "epss_percentile": 0.23047}, "CVE-2024-24110": {"epss_score": 0.00362, "epss_percentile": 0.57809}, "CVE-2024-24112": {"epss_score": 0.81133, "epss_percentile": 0.99123}, "CVE-2024-24113": {"epss_score": 0.00095, "epss_percentile": 0.27213}, "CVE-2024-24115": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-24116": {"epss_score": 0.88872, "epss_percentile": 0.99497}, "CVE-2024-24117": {"epss_score": 0.00419, "epss_percentile": 0.61367}, "CVE-2024-24122": {"epss_score": 0.01053, "epss_percentile": 0.77102}, "CVE-2024-24130": {"epss_score": 0.00091, "epss_percentile": 0.26277}, "CVE-2024-24131": {"epss_score": 0.07723, "epss_percentile": 0.91646}, "CVE-2024-24133": {"epss_score": 0.00224, "epss_percentile": 0.45011}, "CVE-2024-24134": {"epss_score": 0.0088, "epss_percentile": 0.74855}, "CVE-2024-24135": {"epss_score": 0.00747, "epss_percentile": 0.72574}, "CVE-2024-24136": {"epss_score": 0.00587, "epss_percentile": 0.68485}, "CVE-2024-24139": {"epss_score": 0.07497, "epss_percentile": 0.91503}, "CVE-2024-24140": {"epss_score": 0.02824, "epss_percentile": 0.85754}, "CVE-2024-24141": {"epss_score": 0.09352, "epss_percentile": 0.92512}, "CVE-2024-24142": {"epss_score": 0.07537, "epss_percentile": 0.91524}, "CVE-2024-24146": {"epss_score": 0.00174, "epss_percentile": 0.39201}, "CVE-2024-24147": {"epss_score": 0.00174, "epss_percentile": 0.39201}, "CVE-2024-24148": {"epss_score": 0.00344, "epss_percentile": 0.56494}, "CVE-2024-24149": {"epss_score": 0.00136, "epss_percentile": 0.34188}, "CVE-2024-24150": {"epss_score": 0.00175, "epss_percentile": 0.39362}, "CVE-2024-24155": {"epss_score": 0.00596, "epss_percentile": 0.68733}, "CVE-2024-24156": {"epss_score": 0.00329, "epss_percentile": 0.55305}, "CVE-2024-24157": {"epss_score": 0.00934, "epss_percentile": 0.75648}, "CVE-2024-24160": {"epss_score": 0.00139, "epss_percentile": 0.34549}, "CVE-2024-24161": {"epss_score": 0.00119, "epss_percentile": 0.31554}, "CVE-2024-24186": {"epss_score": 0.01081, "epss_percentile": 0.77374}, "CVE-2024-24188": {"epss_score": 0.01049, "epss_percentile": 0.77065}, "CVE-2024-24189": {"epss_score": 0.00496, "epss_percentile": 0.65146}, "CVE-2024-24192": {"epss_score": 0.00199, "epss_percentile": 0.42169}, "CVE-2024-24194": {"epss_score": 0.00256, "epss_percentile": 0.48797}, "CVE-2024-24195": {"epss_score": 0.00237, "epss_percentile": 0.46729}, "CVE-2024-24198": {"epss_score": 0.00082, "epss_percentile": 0.24442}, "CVE-2024-24199": {"epss_score": 0.00083, "epss_percentile": 0.24721}, "CVE-2024-24202": {"epss_score": 0.00115, "epss_percentile": 0.30945}, "CVE-2024-24213": {"epss_score": 0.00965, "epss_percentile": 0.76045}, "CVE-2024-24215": {"epss_score": 0.00115, "epss_percentile": 0.3099}, "CVE-2024-24216": {"epss_score": 0.04885, "epss_percentile": 0.89254}, "CVE-2024-24230": {"epss_score": 0.0159, "epss_percentile": 0.812}, "CVE-2024-24245": {"epss_score": 0.0014, "epss_percentile": 0.34777}, "CVE-2024-24246": {"epss_score": 0.00074, "epss_percentile": 0.22773}, "CVE-2024-24254": {"epss_score": 0.00037, "epss_percentile": 0.10917}, "CVE-2024-24255": {"epss_score": 0.00041, "epss_percentile": 0.12199}, "CVE-2024-24256": {"epss_score": 0.00021, "epss_percentile": 0.04718}, "CVE-2024-24257": {"epss_score": 0.00278, "epss_percentile": 0.50888}, "CVE-2024-24258": {"epss_score": 0.00269, "epss_percentile": 0.50115}, "CVE-2024-24259": {"epss_score": 0.00187, "epss_percentile": 0.40708}, "CVE-2024-24260": {"epss_score": 0.00142, "epss_percentile": 0.35048}, "CVE-2024-24262": {"epss_score": 0.00186, "epss_percentile": 0.40639}, "CVE-2024-24263": {"epss_score": 0.00142, "epss_percentile": 0.35048}, "CVE-2024-24265": {"epss_score": 0.00291, "epss_percentile": 0.52144}, "CVE-2024-24266": {"epss_score": 0.00291, "epss_percentile": 0.52144}, "CVE-2024-24267": {"epss_score": 0.00381, "epss_percentile": 0.59022}, "CVE-2024-24272": {"epss_score": 0.00071, "epss_percentile": 0.22207}, "CVE-2024-24275": {"epss_score": 0.00824, "epss_percentile": 0.73936}, "CVE-2024-24276": {"epss_score": 0.0034, "epss_percentile": 0.56254}, "CVE-2024-24278": {"epss_score": 0.00108, "epss_percentile": 0.29797}, "CVE-2024-24279": {"epss_score": 0.00053, "epss_percentile": 0.16692}, "CVE-2024-24291": {"epss_score": 0.00125, "epss_percentile": 0.32485}, "CVE-2024-24292": {"epss_score": 0.00371, "epss_percentile": 0.58389}, "CVE-2024-24293": {"epss_score": 0.00161, "epss_percentile": 0.37586}, "CVE-2024-24294": {"epss_score": 0.00199, "epss_percentile": 0.42119}, "CVE-2024-24300": {"epss_score": 0.00159, "epss_percentile": 0.37322}, "CVE-2024-24301": {"epss_score": 0.03085, "epss_percentile": 0.86383}, "CVE-2024-24302": {"epss_score": 0.01591, "epss_percentile": 0.8122}, "CVE-2024-24303": {"epss_score": 0.00293, "epss_percentile": 0.52306}, "CVE-2024-24304": {"epss_score": 0.00121, "epss_percentile": 0.31891}, "CVE-2024-24307": {"epss_score": 0.00076, "epss_percentile": 0.2324}, "CVE-2024-24308": {"epss_score": 0.00293, "epss_percentile": 0.52306}, "CVE-2024-24309": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2024-24310": {"epss_score": 0.00072, "epss_percentile": 0.22313}, "CVE-2024-24311": {"epss_score": 0.00117, "epss_percentile": 0.31373}, "CVE-2024-24312": {"epss_score": 0.00111, "epss_percentile": 0.30333}, "CVE-2024-24313": {"epss_score": 0.0022, "epss_percentile": 0.44629}, "CVE-2024-24320": {"epss_score": 0.03472, "epss_percentile": 0.872}, "CVE-2024-24321": {"epss_score": 0.02155, "epss_percentile": 0.83805}, "CVE-2024-24323": {"epss_score": 0.00758, "epss_percentile": 0.72782}, "CVE-2024-24324": {"epss_score": 0.001, "epss_percentile": 0.28522}, "CVE-2024-24325": {"epss_score": 0.02742, "epss_percentile": 0.85564}, "CVE-2024-24326": {"epss_score": 0.01454, "epss_percentile": 0.80381}, "CVE-2024-24327": {"epss_score": 0.01454, "epss_percentile": 0.80381}, "CVE-2024-24328": {"epss_score": 0.84416, "epss_percentile": 0.99289}, "CVE-2024-24329": {"epss_score": 0.83293, "epss_percentile": 0.99243}, "CVE-2024-24330": {"epss_score": 0.02052, "epss_percentile": 0.83413}, "CVE-2024-24331": {"epss_score": 0.01579, "epss_percentile": 0.8113}, "CVE-2024-24332": {"epss_score": 0.03546, "epss_percentile": 0.87329}, "CVE-2024-24333": {"epss_score": 0.02742, "epss_percentile": 0.85564}, "CVE-2024-24334": {"epss_score": 0.00062, "epss_percentile": 0.19579}, "CVE-2024-24335": {"epss_score": 0.00062, "epss_percentile": 0.19572}, "CVE-2024-24336": {"epss_score": 0.00138, "epss_percentile": 0.34515}, "CVE-2024-24337": {"epss_score": 0.02286, "epss_percentile": 0.84268}, "CVE-2024-24350": {"epss_score": 0.01871, "epss_percentile": 0.82636}, "CVE-2024-24375": {"epss_score": 0.00069, "epss_percentile": 0.21556}, "CVE-2024-24377": {"epss_score": 0.00515, "epss_percentile": 0.65968}, "CVE-2024-24386": {"epss_score": 0.0104, "epss_percentile": 0.76955}, "CVE-2024-24388": {"epss_score": 0.00053, "epss_percentile": 0.16833}, "CVE-2024-24389": {"epss_score": 0.00181, "epss_percentile": 0.40112}, "CVE-2024-24393": {"epss_score": 0.03063, "epss_percentile": 0.8632}, "CVE-2024-24396": {"epss_score": 0.01363, "epss_percentile": 0.79768}, "CVE-2024-24397": {"epss_score": 0.00935, "epss_percentile": 0.75675}, "CVE-2024-24398": {"epss_score": 0.2551, "epss_percentile": 0.96036}, "CVE-2024-24399": {"epss_score": 0.01742, "epss_percentile": 0.82053}, "CVE-2024-24401": {"epss_score": 0.5482, "epss_percentile": 0.97947}, "CVE-2024-24402": {"epss_score": 0.24894, "epss_percentile": 0.95963}, "CVE-2024-24407": {"epss_score": 0.00137, "epss_percentile": 0.34237}, "CVE-2024-24409": {"epss_score": 0.02716, "epss_percentile": 0.85509}, "CVE-2024-24416": {"epss_score": 0.00293, "epss_percentile": 0.52342}, "CVE-2024-24417": {"epss_score": 0.00293, "epss_percentile": 0.52342}, "CVE-2024-24418": {"epss_score": 0.00293, "epss_percentile": 0.52342}, "CVE-2024-24419": {"epss_score": 0.00293, "epss_percentile": 0.52342}, "CVE-2024-24420": {"epss_score": 0.00109, "epss_percentile": 0.29945}, "CVE-2024-24421": {"epss_score": 0.00331, "epss_percentile": 0.55541}, "CVE-2024-24422": {"epss_score": 0.00293, "epss_percentile": 0.52342}, "CVE-2024-24423": {"epss_score": 0.00293, "epss_percentile": 0.52342}, "CVE-2024-24424": {"epss_score": 0.00254, "epss_percentile": 0.4856}, "CVE-2024-24425": {"epss_score": 0.00448, "epss_percentile": 0.63011}, "CVE-2024-24426": {"epss_score": 0.00444, "epss_percentile": 0.62841}, "CVE-2024-24427": {"epss_score": 0.00084, "epss_percentile": 0.24908}, "CVE-2024-24428": {"epss_score": 0.00109, "epss_percentile": 0.29945}, "CVE-2024-24429": {"epss_score": 0.00099, "epss_percentile": 0.28414}, "CVE-2024-24430": {"epss_score": 0.00099, "epss_percentile": 0.28414}, "CVE-2024-24431": {"epss_score": 0.00394, "epss_percentile": 0.59783}, "CVE-2024-24432": {"epss_score": 0.00035, "epss_percentile": 0.09861}, "CVE-2024-24442": {"epss_score": 0.0023, "epss_percentile": 0.45736}, "CVE-2024-24443": {"epss_score": 0.002, "epss_percentile": 0.42268}, "CVE-2024-24444": {"epss_score": 0.00254, "epss_percentile": 0.4856}, "CVE-2024-24445": {"epss_score": 0.00165, "epss_percentile": 0.38119}, "CVE-2024-24446": {"epss_score": 0.00475, "epss_percentile": 0.64249}, "CVE-2024-24447": {"epss_score": 0.00259, "epss_percentile": 0.49068}, "CVE-2024-24449": {"epss_score": 0.00219, "epss_percentile": 0.44503}, "CVE-2024-24450": {"epss_score": 0.09209, "epss_percentile": 0.92449}, "CVE-2024-24451": {"epss_score": 0.02283, "epss_percentile": 0.84259}, "CVE-2024-24452": {"epss_score": 0.00089, "epss_percentile": 0.25887}, "CVE-2024-24453": {"epss_score": 0.00089, "epss_percentile": 0.25887}, "CVE-2024-24454": {"epss_score": 0.00089, "epss_percentile": 0.25887}, "CVE-2024-24455": {"epss_score": 0.00089, "epss_percentile": 0.25887}, "CVE-2024-24456": {"epss_score": 0.00146, "epss_percentile": 0.3554}, "CVE-2024-24457": {"epss_score": 0.00089, "epss_percentile": 0.25887}, "CVE-2024-24458": {"epss_score": 0.00089, "epss_percentile": 0.25887}, "CVE-2024-24459": {"epss_score": 0.00089, "epss_percentile": 0.25887}, "CVE-2024-24468": {"epss_score": 0.01613, "epss_percentile": 0.8134}, "CVE-2024-24469": {"epss_score": 0.01702, "epss_percentile": 0.81839}, "CVE-2024-24470": {"epss_score": 0.00777, "epss_percentile": 0.7312}, "CVE-2024-24474": {"epss_score": 0.00602, "epss_percentile": 0.68866}, "CVE-2024-24476": {"epss_score": 0.02282, "epss_percentile": 0.84256}, "CVE-2024-24478": {"epss_score": 0.00277, "epss_percentile": 0.50833}, "CVE-2024-24479": {"epss_score": 0.00289, "epss_percentile": 0.5205}, "CVE-2024-24482": {"epss_score": 0.0062, "epss_percentile": 0.69437}, "CVE-2024-24485": {"epss_score": 0.00348, "epss_percentile": 0.56832}, "CVE-2024-24486": {"epss_score": 0.00796, "epss_percentile": 0.73485}, "CVE-2024-24487": {"epss_score": 0.00635, "epss_percentile": 0.69826}, "CVE-2024-24488": {"epss_score": 0.00026, "epss_percentile": 0.06534}, "CVE-2024-24494": {"epss_score": 0.33585, "epss_percentile": 0.96785}, "CVE-2024-24495": {"epss_score": 0.00489, "epss_percentile": 0.64867}, "CVE-2024-24496": {"epss_score": 0.30868, "epss_percentile": 0.96573}, "CVE-2024-24506": {"epss_score": 0.00366, "epss_percentile": 0.58067}, "CVE-2024-24507": {"epss_score": 0.00374, "epss_percentile": 0.58541}, "CVE-2024-24510": {"epss_score": 0.01099, "epss_percentile": 0.77549}, "CVE-2024-24511": {"epss_score": 0.00231, "epss_percentile": 0.4586}, "CVE-2024-24512": {"epss_score": 0.00231, "epss_percentile": 0.4586}, "CVE-2024-24520": {"epss_score": 0.00153, "epss_percentile": 0.36533}, "CVE-2024-24524": {"epss_score": 0.01408, "epss_percentile": 0.80064}, "CVE-2024-24525": {"epss_score": 0.00999, "epss_percentile": 0.76481}, "CVE-2024-24539": {"epss_score": 0.00047, "epss_percentile": 0.14874}, "CVE-2024-24543": {"epss_score": 0.01107, "epss_percentile": 0.77625}, "CVE-2024-24548": {"epss_score": 0.00178, "epss_percentile": 0.39679}, "CVE-2024-24549": {"epss_score": 0.52453, "epss_percentile": 0.97827}, "CVE-2024-24550": {"epss_score": 0.00144, "epss_percentile": 0.35319}, "CVE-2024-24551": {"epss_score": 0.00219, "epss_percentile": 0.44442}, "CVE-2024-24552": {"epss_score": 0.0002, "epss_percentile": 0.04425}, "CVE-2024-24553": {"epss_score": 0.00056, "epss_percentile": 0.17684}, "CVE-2024-24554": {"epss_score": 0.00117, "epss_percentile": 0.31351}, "CVE-2024-24556": {"epss_score": 0.00618, "epss_percentile": 0.69377}, "CVE-2024-24557": {"epss_score": 0.0007, "epss_percentile": 0.21765}, "CVE-2024-24558": {"epss_score": 0.00496, "epss_percentile": 0.65153}, "CVE-2024-24559": {"epss_score": 0.00188, "epss_percentile": 0.40844}, "CVE-2024-24560": {"epss_score": 0.00644, "epss_percentile": 0.70088}, "CVE-2024-24561": {"epss_score": 0.0119, "epss_percentile": 0.78382}, "CVE-2024-24562": {"epss_score": 0.00122, "epss_percentile": 0.32095}, "CVE-2024-24563": {"epss_score": 0.00176, "epss_percentile": 0.39436}, "CVE-2024-24564": {"epss_score": 0.00475, "epss_percentile": 0.64199}, "CVE-2024-24565": {"epss_score": 0.85571, "epss_percentile": 0.9934}, "CVE-2024-24566": {"epss_score": 0.00139, "epss_percentile": 0.34626}, "CVE-2024-24567": {"epss_score": 0.00194, "epss_percentile": 0.4159}, "CVE-2024-24568": {"epss_score": 0.00074, "epss_percentile": 0.22857}, "CVE-2024-24569": {"epss_score": 0.00233, "epss_percentile": 0.45983}, "CVE-2024-24570": {"epss_score": 0.01027, "epss_percentile": 0.76807}, "CVE-2024-24571": {"epss_score": 0.00362, "epss_percentile": 0.57812}, "CVE-2024-24572": {"epss_score": 0.0029, "epss_percentile": 0.52137}, "CVE-2024-24573": {"epss_score": 0.00395, "epss_percentile": 0.5984}, "CVE-2024-24574": {"epss_score": 0.02404, "epss_percentile": 0.84645}, "CVE-2024-24575": {"epss_score": 0.0135, "epss_percentile": 0.79677}, "CVE-2024-24576": {"epss_score": 0.80474, "epss_percentile": 0.9909}, "CVE-2024-24577": {"epss_score": 0.00277, "epss_percentile": 0.50823}, "CVE-2024-24578": {"epss_score": 0.63562, "epss_percentile": 0.98338}, "CVE-2024-24579": {"epss_score": 0.00055, "epss_percentile": 0.17606}, "CVE-2024-24580": {"epss_score": 0.00131, "epss_percentile": 0.33358}, "CVE-2024-24581": {"epss_score": 0.001, "epss_percentile": 0.28449}, "CVE-2024-24582": {"epss_score": 0.00029, "epss_percentile": 0.07651}, "CVE-2024-24583": {"epss_score": 0.00289, "epss_percentile": 0.52053}, "CVE-2024-24584": {"epss_score": 0.00202, "epss_percentile": 0.42418}, "CVE-2024-24590": {"epss_score": 0.79626, "epss_percentile": 0.9905}, "CVE-2024-24591": {"epss_score": 0.00452, "epss_percentile": 0.63188}, "CVE-2024-24592": {"epss_score": 0.00887, "epss_percentile": 0.74964}, "CVE-2024-24593": {"epss_score": 0.0042, "epss_percentile": 0.61424}, "CVE-2024-24594": {"epss_score": 0.00059, "epss_percentile": 0.18627}, "CVE-2024-24595": {"epss_score": 0.00024, "epss_percentile": 0.0567}, "CVE-2024-24621": {"epss_score": 0.0005, "epss_percentile": 0.15859}, "CVE-2024-24622": {"epss_score": 0.01477, "epss_percentile": 0.80543}, "CVE-2024-24623": {"epss_score": 0.04469, "epss_percentile": 0.88732}, "CVE-2024-24680": {"epss_score": 0.00985, "epss_percentile": 0.76326}, "CVE-2024-24681": {"epss_score": 0.00156, "epss_percentile": 0.37008}, "CVE-2024-24683": {"epss_score": 0.00453, "epss_percentile": 0.6321}, "CVE-2024-24684": {"epss_score": 0.21925, "epss_percentile": 0.95573}, "CVE-2024-24685": {"epss_score": 0.06624, "epss_percentile": 0.90898}, "CVE-2024-24686": {"epss_score": 0.08999, "epss_percentile": 0.92358}, "CVE-2024-24690": {"epss_score": 0.00075, "epss_percentile": 0.22883}, "CVE-2024-24691": {"epss_score": 0.00467, "epss_percentile": 0.63847}, "CVE-2024-24692": {"epss_score": 0.00054, "epss_percentile": 0.17339}, "CVE-2024-24693": {"epss_score": 0.00052, "epss_percentile": 0.16405}, "CVE-2024-24694": {"epss_score": 0.00034, "epss_percentile": 0.09553}, "CVE-2024-24695": {"epss_score": 0.00219, "epss_percentile": 0.44521}, "CVE-2024-24696": {"epss_score": 0.00219, "epss_percentile": 0.44521}, "CVE-2024-24697": {"epss_score": 0.0007, "epss_percentile": 0.21783}, "CVE-2024-24698": {"epss_score": 0.00117, "epss_percentile": 0.31229}, "CVE-2024-24699": {"epss_score": 0.00216, "epss_percentile": 0.44153}, "CVE-2024-24700": {"epss_score": 0.00144, "epss_percentile": 0.35232}, "CVE-2024-24701": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2024-24702": {"epss_score": 0.00108, "epss_percentile": 0.29886}, "CVE-2024-24703": {"epss_score": 0.00465, "epss_percentile": 0.63755}, "CVE-2024-24704": {"epss_score": 0.00119, "epss_percentile": 0.31659}, "CVE-2024-24705": {"epss_score": 0.00074, "epss_percentile": 0.22802}, "CVE-2024-24706": {"epss_score": 0.00142, "epss_percentile": 0.3497}, "CVE-2024-24707": {"epss_score": 0.00421, "epss_percentile": 0.61527}, "CVE-2024-24708": {"epss_score": 0.00141, "epss_percentile": 0.34927}, "CVE-2024-24710": {"epss_score": 0.00064, "epss_percentile": 0.20316}, "CVE-2024-24711": {"epss_score": 0.0014, "epss_percentile": 0.34697}, "CVE-2024-24712": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2024-24713": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2024-24714": {"epss_score": 0.00612, "epss_percentile": 0.69218}, "CVE-2024-24715": {"epss_score": 0.00196, "epss_percentile": 0.41747}, "CVE-2024-24716": {"epss_score": 0.00081, "epss_percentile": 0.24341}, "CVE-2024-24717": {"epss_score": 0.00053, "epss_percentile": 0.16927}, "CVE-2024-24718": {"epss_score": 0.00128, "epss_percentile": 0.32972}, "CVE-2024-24719": {"epss_score": 0.00128, "epss_percentile": 0.32972}, "CVE-2024-24720": {"epss_score": 0.00163, "epss_percentile": 0.37782}, "CVE-2024-24721": {"epss_score": 0.00206, "epss_percentile": 0.42921}, "CVE-2024-24722": {"epss_score": 0.0021, "epss_percentile": 0.4347}, "CVE-2024-24724": {"epss_score": 0.39236, "epss_percentile": 0.97148}, "CVE-2024-24725": {"epss_score": 0.79081, "epss_percentile": 0.99019}, "CVE-2024-24731": {"epss_score": 0.00147, "epss_percentile": 0.3568}, "CVE-2024-24736": {"epss_score": 0.00239, "epss_percentile": 0.46859}, "CVE-2024-24739": {"epss_score": 0.00109, "epss_percentile": 0.3002}, "CVE-2024-24740": {"epss_score": 0.00188, "epss_percentile": 0.40895}, "CVE-2024-24741": {"epss_score": 0.00153, "epss_percentile": 0.3663}, "CVE-2024-24742": {"epss_score": 0.00222, "epss_percentile": 0.44786}, "CVE-2024-24743": {"epss_score": 0.00312, "epss_percentile": 0.5394}, "CVE-2024-24746": {"epss_score": 0.00091, "epss_percentile": 0.26212}, "CVE-2024-24747": {"epss_score": 0.17306, "epss_percentile": 0.94819}, "CVE-2024-24748": {"epss_score": 0.00109, "epss_percentile": 0.29913}, "CVE-2024-24749": {"epss_score": 0.00295, "epss_percentile": 0.5247}, "CVE-2024-24750": {"epss_score": 0.00315, "epss_percentile": 0.54198}, "CVE-2024-24751": {"epss_score": 0.00243, "epss_percentile": 0.4747}, "CVE-2024-24752": {"epss_score": 0.00141, "epss_percentile": 0.3487}, "CVE-2024-24753": {"epss_score": 0.00191, "epss_percentile": 0.41166}, "CVE-2024-24754": {"epss_score": 0.00227, "epss_percentile": 0.45384}, "CVE-2024-24755": {"epss_score": 0.00194, "epss_percentile": 0.41519}, "CVE-2024-24756": {"epss_score": 0.00261, "epss_percentile": 0.49283}, "CVE-2024-24757": {"epss_score": 0.00099, "epss_percentile": 0.28406}, "CVE-2024-24758": {"epss_score": 0.00205, "epss_percentile": 0.42723}, "CVE-2024-24759": {"epss_score": 0.79449, "epss_percentile": 0.99038}, "CVE-2024-24760": {"epss_score": 0.03132, "epss_percentile": 0.86475}, "CVE-2024-24761": {"epss_score": 0.00205, "epss_percentile": 0.42715}, "CVE-2024-24762": {"epss_score": 0.02486, "epss_percentile": 0.84886}, "CVE-2024-24763": {"epss_score": 0.26411, "epss_percentile": 0.96144}, "CVE-2024-24764": {"epss_score": 0.00102, "epss_percentile": 0.28748}, "CVE-2024-24765": {"epss_score": 0.00461, "epss_percentile": 0.63568}, "CVE-2024-24766": {"epss_score": 0.00357, "epss_percentile": 0.57434}, "CVE-2024-24767": {"epss_score": 0.00726, "epss_percentile": 0.72066}, "CVE-2024-24768": {"epss_score": 0.00048, "epss_percentile": 0.15012}, "CVE-2024-24770": {"epss_score": 0.00198, "epss_percentile": 0.42031}, "CVE-2024-24771": {"epss_score": 0.00098, "epss_percentile": 0.27634}, "CVE-2024-24772": {"epss_score": 0.00751, "epss_percentile": 0.72637}, "CVE-2024-24773": {"epss_score": 0.00144, "epss_percentile": 0.3531}, "CVE-2024-24774": {"epss_score": 0.0025, "epss_percentile": 0.48106}, "CVE-2024-24775": {"epss_score": 0.00362, "epss_percentile": 0.57769}, "CVE-2024-24776": {"epss_score": 0.00162, "epss_percentile": 0.37732}, "CVE-2024-24777": {"epss_score": 0.13644, "epss_percentile": 0.9402}, "CVE-2024-24778": {"epss_score": 0.00145, "epss_percentile": 0.35374}, "CVE-2024-24779": {"epss_score": 0.00174, "epss_percentile": 0.3916}, "CVE-2024-24780": {"epss_score": 0.00558, "epss_percentile": 0.67571}, "CVE-2024-24781": {"epss_score": 0.00476, "epss_percentile": 0.64254}, "CVE-2024-24782": {"epss_score": 0.00033, "epss_percentile": 0.09189}, "CVE-2024-24783": {"epss_score": 0.00445, "epss_percentile": 0.62858}, "CVE-2024-24784": {"epss_score": 0.01498, "epss_percentile": 0.80697}, "CVE-2024-24785": {"epss_score": 0.00273, "epss_percentile": 0.50453}, "CVE-2024-24786": {"epss_score": 0.00231, "epss_percentile": 0.45835}, "CVE-2024-24787": {"epss_score": 0.02135, "epss_percentile": 0.83726}, "CVE-2024-24788": {"epss_score": 0.00128, "epss_percentile": 0.32963}, "CVE-2024-24789": {"epss_score": 7e-05, "epss_percentile": 0.00388}, "CVE-2024-24790": {"epss_score": 0.00085, "epss_percentile": 0.25088}, "CVE-2024-24791": {"epss_score": 0.00635, "epss_percentile": 0.6982}, "CVE-2024-24792": {"epss_score": 0.00162, "epss_percentile": 0.37638}, "CVE-2024-24793": {"epss_score": 0.00333, "epss_percentile": 0.55653}, "CVE-2024-24794": {"epss_score": 0.00333, "epss_percentile": 0.55653}, "CVE-2024-24795": {"epss_score": 0.01219, "epss_percentile": 0.78614}, "CVE-2024-24796": {"epss_score": 0.00428, "epss_percentile": 0.61931}, "CVE-2024-24797": {"epss_score": 0.00433, "epss_percentile": 0.62197}, "CVE-2024-24798": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2024-24799": {"epss_score": 0.00616, "epss_percentile": 0.69323}, "CVE-2024-24800": {"epss_score": 0.002, "epss_percentile": 0.42231}, "CVE-2024-24801": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-24802": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2024-24803": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-24804": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-24805": {"epss_score": 0.00128, "epss_percentile": 0.32972}, "CVE-2024-24806": {"epss_score": 0.00148, "epss_percentile": 0.35873}, "CVE-2024-24807": {"epss_score": 0.00837, "epss_percentile": 0.74158}, "CVE-2024-24808": {"epss_score": 0.01813, "epss_percentile": 0.82375}, "CVE-2024-24809": {"epss_score": 0.89894, "epss_percentile": 0.99548}, "CVE-2024-24810": {"epss_score": 0.00049, "epss_percentile": 0.15484}, "CVE-2024-24811": {"epss_score": 0.00847, "epss_percentile": 0.74351}, "CVE-2024-24812": {"epss_score": 0.00445, "epss_percentile": 0.62872}, "CVE-2024-24813": {"epss_score": 0.00388, "epss_percentile": 0.59378}, "CVE-2024-24814": {"epss_score": 0.00211, "epss_percentile": 0.43639}, "CVE-2024-24815": {"epss_score": 0.00117, "epss_percentile": 0.31201}, "CVE-2024-24816": {"epss_score": 0.21584, "epss_percentile": 0.95536}, "CVE-2024-24817": {"epss_score": 0.00229, "epss_percentile": 0.45593}, "CVE-2024-24818": {"epss_score": 0.00127, "epss_percentile": 0.32871}, "CVE-2024-24819": {"epss_score": 0.00035, "epss_percentile": 0.10039}, "CVE-2024-24820": {"epss_score": 0.00069, "epss_percentile": 0.21633}, "CVE-2024-24821": {"epss_score": 0.00088, "epss_percentile": 0.25741}, "CVE-2024-24822": {"epss_score": 3e-05, "epss_percentile": 0.00064}, "CVE-2024-24823": {"epss_score": 0.00129, "epss_percentile": 0.33192}, "CVE-2024-24824": {"epss_score": 0.03005, "epss_percentile": 0.86182}, "CVE-2024-24825": {"epss_score": 0.00121, "epss_percentile": 0.3196}, "CVE-2024-24826": {"epss_score": 0.00042, "epss_percentile": 0.12493}, "CVE-2024-24827": {"epss_score": 0.00063, "epss_percentile": 0.1985}, "CVE-2024-24828": {"epss_score": 0.00107, "epss_percentile": 0.29683}, "CVE-2024-24829": {"epss_score": 0.00099, "epss_percentile": 0.27846}, "CVE-2024-24830": {"epss_score": 0.00121, "epss_percentile": 0.31835}, "CVE-2024-24831": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2024-24832": {"epss_score": 0.00136, "epss_percentile": 0.34132}, "CVE-2024-24833": {"epss_score": 0.00471, "epss_percentile": 0.63998}, "CVE-2024-24834": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2024-24835": {"epss_score": 0.00058, "epss_percentile": 0.18401}, "CVE-2024-24836": {"epss_score": 0.00071, "epss_percentile": 0.22144}, "CVE-2024-24837": {"epss_score": 0.00074, "epss_percentile": 0.22733}, "CVE-2024-24838": {"epss_score": 0.00143, "epss_percentile": 0.35193}, "CVE-2024-24839": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-24840": {"epss_score": 0.00077, "epss_percentile": 0.23437}, "CVE-2024-24841": {"epss_score": 0.00098, "epss_percentile": 0.27772}, "CVE-2024-24842": {"epss_score": 0.00406, "epss_percentile": 0.60516}, "CVE-2024-24843": {"epss_score": 0.001, "epss_percentile": 0.28461}, "CVE-2024-24844": {"epss_score": 0.00153, "epss_percentile": 0.3655}, "CVE-2024-24845": {"epss_score": 0.00148, "epss_percentile": 0.35899}, "CVE-2024-24846": {"epss_score": 0.00182, "epss_percentile": 0.40227}, "CVE-2024-24847": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2024-24848": {"epss_score": 0.00182, "epss_percentile": 0.40227}, "CVE-2024-24849": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2024-24850": {"epss_score": 0.00151, "epss_percentile": 0.36346}, "CVE-2024-24851": {"epss_score": 0.00612, "epss_percentile": 0.6923}, "CVE-2024-24852": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-24853": {"epss_score": 0.00019, "epss_percentile": 0.04296}, "CVE-2024-24855": {"epss_score": 0.00012, "epss_percentile": 0.01257}, "CVE-2024-24856": {"epss_score": 0.0003, "epss_percentile": 0.08146}, "CVE-2024-24857": {"epss_score": 0.00027, "epss_percentile": 0.06884}, "CVE-2024-24858": {"epss_score": 0.00017, "epss_percentile": 0.03246}, "CVE-2024-24859": {"epss_score": 8e-05, "epss_percentile": 0.00567}, "CVE-2024-24860": {"epss_score": 7e-05, "epss_percentile": 0.00441}, "CVE-2024-24861": {"epss_score": 0.00026, "epss_percentile": 0.06407}, "CVE-2024-24864": {"epss_score": 0.00014, "epss_percentile": 0.02053}, "CVE-2024-24865": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-24866": {"epss_score": 0.00177, "epss_percentile": 0.39628}, "CVE-2024-24867": {"epss_score": 0.00282, "epss_percentile": 0.51203}, "CVE-2024-24868": {"epss_score": 0.00284, "epss_percentile": 0.51453}, "CVE-2024-24869": {"epss_score": 0.01842, "epss_percentile": 0.825}, "CVE-2024-24870": {"epss_score": 0.0013, "epss_percentile": 0.33321}, "CVE-2024-24871": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2024-24872": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2024-24873": {"epss_score": 0.0021, "epss_percentile": 0.43456}, "CVE-2024-24874": {"epss_score": 0.00159, "epss_percentile": 0.37375}, "CVE-2024-24875": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2024-24876": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2024-24877": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-24878": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-24879": {"epss_score": 0.00162, "epss_percentile": 0.37684}, "CVE-2024-24880": {"epss_score": 0.00071, "epss_percentile": 0.22144}, "CVE-2024-24881": {"epss_score": 0.00125, "epss_percentile": 0.32545}, "CVE-2024-24882": {"epss_score": 0.00665, "epss_percentile": 0.70656}, "CVE-2024-24883": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-24884": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2024-24885": {"epss_score": 0.00055, "epss_percentile": 0.17549}, "CVE-2024-24886": {"epss_score": 0.00047, "epss_percentile": 0.14583}, "CVE-2024-24887": {"epss_score": 0.00051, "epss_percentile": 0.161}, "CVE-2024-24888": {"epss_score": 0.00322, "epss_percentile": 0.54827}, "CVE-2024-24889": {"epss_score": 0.00099, "epss_percentile": 0.28345}, "CVE-2024-24890": {"epss_score": 0.00086, "epss_percentile": 0.25417}, "CVE-2024-24891": {"epss_score": 0.00024, "epss_percentile": 0.06034}, "CVE-2024-24892": {"epss_score": 0.00238, "epss_percentile": 0.46773}, "CVE-2024-24897": {"epss_score": 0.00394, "epss_percentile": 0.5978}, "CVE-2024-24898": {"epss_score": 0.00053, "epss_percentile": 0.16863}, "CVE-2024-24899": {"epss_score": 0.00312, "epss_percentile": 0.53948}, "CVE-2024-24900": {"epss_score": 0.00111, "epss_percentile": 0.3034}, "CVE-2024-24901": {"epss_score": 0.00035, "epss_percentile": 0.09821}, "CVE-2024-24902": {"epss_score": 0.00025, "epss_percentile": 0.06246}, "CVE-2024-24903": {"epss_score": 0.00082, "epss_percentile": 0.24483}, "CVE-2024-24904": {"epss_score": 0.00082, "epss_percentile": 0.24585}, "CVE-2024-24905": {"epss_score": 0.00082, "epss_percentile": 0.24585}, "CVE-2024-24906": {"epss_score": 0.00082, "epss_percentile": 0.24585}, "CVE-2024-24907": {"epss_score": 0.00082, "epss_percentile": 0.24585}, "CVE-2024-24908": {"epss_score": 0.01378, "epss_percentile": 0.79846}, "CVE-2024-24910": {"epss_score": 0.00084, "epss_percentile": 0.24852}, "CVE-2024-24911": {"epss_score": 0.00172, "epss_percentile": 0.38913}, "CVE-2024-24912": {"epss_score": 0.0005, "epss_percentile": 0.15875}, "CVE-2024-24914": {"epss_score": 0.00229, "epss_percentile": 0.45597}, "CVE-2024-24915": {"epss_score": 0.00021, "epss_percentile": 0.04713}, "CVE-2024-24916": {"epss_score": 0.00027, "epss_percentile": 0.06815}, "CVE-2024-24919": {"epss_score": 0.94342, "epss_percentile": 0.99952}, "CVE-2024-24920": {"epss_score": 0.00095, "epss_percentile": 0.27161}, "CVE-2024-24921": {"epss_score": 0.0009, "epss_percentile": 0.26162}, "CVE-2024-24922": {"epss_score": 0.00073, "epss_percentile": 0.22511}, "CVE-2024-24923": {"epss_score": 0.00124, "epss_percentile": 0.32445}, "CVE-2024-24924": {"epss_score": 0.00073, "epss_percentile": 0.22511}, "CVE-2024-24925": {"epss_score": 0.00095, "epss_percentile": 0.27161}, "CVE-2024-24926": {"epss_score": 0.40117, "epss_percentile": 0.97197}, "CVE-2024-24927": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-24928": {"epss_score": 0.00065, "epss_percentile": 0.20647}, "CVE-2024-24929": {"epss_score": 0.00096, "epss_percentile": 0.27256}, "CVE-2024-24930": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-24931": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-24932": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-24933": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-24934": {"epss_score": 0.01199, "epss_percentile": 0.78464}, "CVE-2024-24935": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2024-24936": {"epss_score": 2e-05, "epss_percentile": 0.00026}, "CVE-2024-24937": {"epss_score": 0.41089, "epss_percentile": 0.97253}, "CVE-2024-24938": {"epss_score": 0.00014, "epss_percentile": 0.0196}, "CVE-2024-24939": {"epss_score": 3e-05, "epss_percentile": 0.00065}, "CVE-2024-24940": {"epss_score": 2e-05, "epss_percentile": 0.00036}, "CVE-2024-24941": {"epss_score": 7e-05, "epss_percentile": 0.00368}, "CVE-2024-24942": {"epss_score": 0.00069, "epss_percentile": 0.21603}, "CVE-2024-24943": {"epss_score": 1e-05, "epss_percentile": 0.00012}, "CVE-2024-24945": {"epss_score": 0.00162, "epss_percentile": 0.37701}, "CVE-2024-24946": {"epss_score": 0.00469, "epss_percentile": 0.63921}, "CVE-2024-24947": {"epss_score": 0.00514, "epss_percentile": 0.6596}, "CVE-2024-24954": {"epss_score": 0.00226, "epss_percentile": 0.45257}, "CVE-2024-24955": {"epss_score": 0.00295, "epss_percentile": 0.52483}, "CVE-2024-24956": {"epss_score": 0.00295, "epss_percentile": 0.52483}, "CVE-2024-24957": {"epss_score": 0.00226, "epss_percentile": 0.45257}, "CVE-2024-24958": {"epss_score": 0.00226, "epss_percentile": 0.45257}, "CVE-2024-24959": {"epss_score": 0.00295, "epss_percentile": 0.52483}, "CVE-2024-24962": {"epss_score": 0.00515, "epss_percentile": 0.65984}, "CVE-2024-24963": {"epss_score": 0.00672, "epss_percentile": 0.70827}, "CVE-2024-24964": {"epss_score": 0.00238, "epss_percentile": 0.46788}, "CVE-2024-24966": {"epss_score": 0.00263, "epss_percentile": 0.495}, "CVE-2024-24968": {"epss_score": 0.00042, "epss_percentile": 0.1289}, "CVE-2024-24970": {"epss_score": 0.0005, "epss_percentile": 0.15958}, "CVE-2024-24972": {"epss_score": 0.00285, "epss_percentile": 0.51649}, "CVE-2024-24973": {"epss_score": 0.0005, "epss_percentile": 0.15828}, "CVE-2024-24974": {"epss_score": 0.11092, "epss_percentile": 0.93217}, "CVE-2024-24975": {"epss_score": 0.00118, "epss_percentile": 0.31458}, "CVE-2024-24976": {"epss_score": 0.0015, "epss_percentile": 0.36175}, "CVE-2024-24977": {"epss_score": 0.00349, "epss_percentile": 0.56858}, "CVE-2024-24978": {"epss_score": 0.0069, "epss_percentile": 0.71258}, "CVE-2024-24980": {"epss_score": 0.00055, "epss_percentile": 0.17635}, "CVE-2024-24981": {"epss_score": 0.00096, "epss_percentile": 0.27263}, "CVE-2024-24983": {"epss_score": 0.00183, "epss_percentile": 0.40289}, "CVE-2024-24984": {"epss_score": 0.00046, "epss_percentile": 0.14141}, "CVE-2024-24985": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2024-24986": {"epss_score": 0.00178, "epss_percentile": 0.39745}, "CVE-2024-24988": {"epss_score": 0.00345, "epss_percentile": 0.566}, "CVE-2024-24989": {"epss_score": 0.00646, "epss_percentile": 0.70139}, "CVE-2024-24990": {"epss_score": 0.00182, "epss_percentile": 0.40189}, "CVE-2024-24991": {"epss_score": 0.03745, "epss_percentile": 0.8766}, "CVE-2024-24992": {"epss_score": 0.59826, "epss_percentile": 0.98183}, "CVE-2024-24993": {"epss_score": 0.01922, "epss_percentile": 0.82908}, "CVE-2024-24994": {"epss_score": 0.48209, "epss_percentile": 0.97627}, "CVE-2024-24995": {"epss_score": 0.03671, "epss_percentile": 0.87539}, "CVE-2024-24996": {"epss_score": 0.41199, "epss_percentile": 0.97258}, "CVE-2024-24997": {"epss_score": 0.03623, "epss_percentile": 0.87445}, "CVE-2024-24998": {"epss_score": 0.04892, "epss_percentile": 0.89266}, "CVE-2024-24999": {"epss_score": 0.09016, "epss_percentile": 0.92367}, "CVE-2024-25000": {"epss_score": 0.04892, "epss_percentile": 0.89266}, "CVE-2024-25002": {"epss_score": 0.00323, "epss_percentile": 0.54864}, "CVE-2024-25003": {"epss_score": 0.00554, "epss_percentile": 0.67438}, "CVE-2024-25004": {"epss_score": 0.00453, "epss_percentile": 0.63235}, "CVE-2024-25006": {"epss_score": 0.00297, "epss_percentile": 0.52759}, "CVE-2024-25007": {"epss_score": 0.00054, "epss_percentile": 0.17188}, "CVE-2024-25008": {"epss_score": 0.0005, "epss_percentile": 0.15762}, "CVE-2024-25009": {"epss_score": 0.00097, "epss_percentile": 0.27597}, "CVE-2024-25010": {"epss_score": 0.00048, "epss_percentile": 0.15126}, "CVE-2024-25011": {"epss_score": 0.00045, "epss_percentile": 0.13778}, "CVE-2024-25015": {"epss_score": 0.00078, "epss_percentile": 0.23655}, "CVE-2024-25016": {"epss_score": 0.00094, "epss_percentile": 0.26952}, "CVE-2024-25019": {"epss_score": 0.00076, "epss_percentile": 0.23212}, "CVE-2024-25020": {"epss_score": 0.00076, "epss_percentile": 0.23212}, "CVE-2024-25021": {"epss_score": 0.00105, "epss_percentile": 0.2929}, "CVE-2024-25023": {"epss_score": 0.00018, "epss_percentile": 0.0361}, "CVE-2024-25024": {"epss_score": 0.00023, "epss_percentile": 0.05444}, "CVE-2024-25026": {"epss_score": 0.00019, "epss_percentile": 0.04162}, "CVE-2024-25027": {"epss_score": 0.00019, "epss_percentile": 0.04289}, "CVE-2024-25029": {"epss_score": 0.00463, "epss_percentile": 0.63691}, "CVE-2024-25030": {"epss_score": 0.00024, "epss_percentile": 0.05893}, "CVE-2024-25031": {"epss_score": 0.00054, "epss_percentile": 0.17304}, "CVE-2024-25034": {"epss_score": 0.00109, "epss_percentile": 0.29996}, "CVE-2024-25035": {"epss_score": 0.00095, "epss_percentile": 0.27117}, "CVE-2024-25036": {"epss_score": 0.00049, "epss_percentile": 0.15452}, "CVE-2024-25037": {"epss_score": 0.00064, "epss_percentile": 0.2017}, "CVE-2024-25041": {"epss_score": 0.00069, "epss_percentile": 0.21473}, "CVE-2024-25042": {"epss_score": 0.00072, "epss_percentile": 0.22327}, "CVE-2024-25046": {"epss_score": 0.00074, "epss_percentile": 0.22762}, "CVE-2024-25047": {"epss_score": 0.00057, "epss_percentile": 0.18078}, "CVE-2024-25048": {"epss_score": 0.00614, "epss_percentile": 0.69271}, "CVE-2024-25050": {"epss_score": 0.00071, "epss_percentile": 0.21988}, "CVE-2024-25051": {"epss_score": 0.00041, "epss_percentile": 0.12289}, "CVE-2024-25052": {"epss_score": 0.00036, "epss_percentile": 0.10397}, "CVE-2024-25053": {"epss_score": 0.00078, "epss_percentile": 0.23601}, "CVE-2024-25062": {"epss_score": 0.00129, "epss_percentile": 0.33164}, "CVE-2024-25063": {"epss_score": 0.00211, "epss_percentile": 0.43688}, "CVE-2024-25064": {"epss_score": 0.00181, "epss_percentile": 0.40116}, "CVE-2024-25065": {"epss_score": 0.01054, "epss_percentile": 0.77106}, "CVE-2024-25066": {"epss_score": 0.00042, "epss_percentile": 0.12879}, "CVE-2024-25073": {"epss_score": 0.00898, "epss_percentile": 0.75149}, "CVE-2024-25074": {"epss_score": 0.00772, "epss_percentile": 0.73037}, "CVE-2024-25075": {"epss_score": 0.00059, "epss_percentile": 0.18911}, "CVE-2024-25076": {"epss_score": 0.00422, "epss_percentile": 0.61542}, "CVE-2024-25077": {"epss_score": 0.00335, "epss_percentile": 0.55832}, "CVE-2024-25078": {"epss_score": 0.00112, "epss_percentile": 0.30436}, "CVE-2024-25079": {"epss_score": 0.00112, "epss_percentile": 0.30436}, "CVE-2024-25080": {"epss_score": 0.0007, "epss_percentile": 0.21838}, "CVE-2024-25081": {"epss_score": 0.00039, "epss_percentile": 0.11799}, "CVE-2024-25082": {"epss_score": 0.00913, "epss_percentile": 0.7538}, "CVE-2024-25083": {"epss_score": 0.00051, "epss_percentile": 0.15988}, "CVE-2024-25086": {"epss_score": 0.00092, "epss_percentile": 0.26412}, "CVE-2024-25087": {"epss_score": 0.00119, "epss_percentile": 0.31559}, "CVE-2024-25088": {"epss_score": 0.00065, "epss_percentile": 0.2066}, "CVE-2024-25089": {"epss_score": 0.05359, "epss_percentile": 0.89782}, "CVE-2024-25090": {"epss_score": 0.00678, "epss_percentile": 0.71}, "CVE-2024-25091": {"epss_score": 0.00094, "epss_percentile": 0.26954}, "CVE-2024-25092": {"epss_score": 0.70046, "epss_percentile": 0.98613}, "CVE-2024-25093": {"epss_score": 0.00115, "epss_percentile": 0.31018}, "CVE-2024-25094": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-25095": {"epss_score": 0.00595, "epss_percentile": 0.68692}, "CVE-2024-25096": {"epss_score": 0.01237, "epss_percentile": 0.78777}, "CVE-2024-25097": {"epss_score": 0.00163, "epss_percentile": 0.37791}, "CVE-2024-25098": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-25099": {"epss_score": 0.00163, "epss_percentile": 0.37791}, "CVE-2024-25100": {"epss_score": 0.00632, "epss_percentile": 0.69741}, "CVE-2024-25101": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2024-25102": {"epss_score": 0.00014, "epss_percentile": 0.02092}, "CVE-2024-25103": {"epss_score": 0.00021, "epss_percentile": 0.04885}, "CVE-2024-25106": {"epss_score": 0.00072, "epss_percentile": 0.22344}, "CVE-2024-25107": {"epss_score": 0.00218, "epss_percentile": 0.44426}, "CVE-2024-25108": {"epss_score": 0.00084, "epss_percentile": 0.24894}, "CVE-2024-25109": {"epss_score": 0.0029, "epss_percentile": 0.52134}, "CVE-2024-25110": {"epss_score": 0.01024, "epss_percentile": 0.76777}, "CVE-2024-25111": {"epss_score": 0.03932, "epss_percentile": 0.87975}, "CVE-2024-25112": {"epss_score": 0.00016, "epss_percentile": 0.02654}, "CVE-2024-25114": {"epss_score": 0.00229, "epss_percentile": 0.45593}, "CVE-2024-25115": {"epss_score": 0.02019, "epss_percentile": 0.83288}, "CVE-2024-25116": {"epss_score": 0.00128, "epss_percentile": 0.33006}, "CVE-2024-25117": {"epss_score": 0.00175, "epss_percentile": 0.39274}, "CVE-2024-25118": {"epss_score": 0.00388, "epss_percentile": 0.59398}, "CVE-2024-25119": {"epss_score": 0.00222, "epss_percentile": 0.44842}, "CVE-2024-25120": {"epss_score": 0.00188, "epss_percentile": 0.4089}, "CVE-2024-25121": {"epss_score": 0.00229, "epss_percentile": 0.4559}, "CVE-2024-25122": {"epss_score": 0.00099, "epss_percentile": 0.27863}, "CVE-2024-25123": {"epss_score": 0.00166, "epss_percentile": 0.38256}, "CVE-2024-25124": {"epss_score": 0.00387, "epss_percentile": 0.59289}, "CVE-2024-25125": {"epss_score": 0.0574, "epss_percentile": 0.90168}, "CVE-2024-25126": {"epss_score": 0.00332, "epss_percentile": 0.55603}, "CVE-2024-25128": {"epss_score": 0.0096, "epss_percentile": 0.75964}, "CVE-2024-25129": {"epss_score": 0.00117, "epss_percentile": 0.3134}, "CVE-2024-25130": {"epss_score": 0.00191, "epss_percentile": 0.41262}, "CVE-2024-25131": {"epss_score": 0.00516, "epss_percentile": 0.66034}, "CVE-2024-25132": {"epss_score": 0.00133, "epss_percentile": 0.33724}, "CVE-2024-25133": {"epss_score": 0.00248, "epss_percentile": 0.47924}, "CVE-2024-25136": {"epss_score": 0.00222, "epss_percentile": 0.44775}, "CVE-2024-25137": {"epss_score": 0.00116, "epss_percentile": 0.31123}, "CVE-2024-25138": {"epss_score": 0.00143, "epss_percentile": 0.35113}, "CVE-2024-25139": {"epss_score": 0.00165, "epss_percentile": 0.38034}, "CVE-2024-25140": {"epss_score": 0.00223, "epss_percentile": 0.44873}, "CVE-2024-25141": {"epss_score": 0.00097, "epss_percentile": 0.27566}, "CVE-2024-25142": {"epss_score": 0.00102, "epss_percentile": 0.28819}, "CVE-2024-25143": {"epss_score": 0.00745, "epss_percentile": 0.72515}, "CVE-2024-25144": {"epss_score": 0.00318, "epss_percentile": 0.54396}, "CVE-2024-25145": {"epss_score": 0.00152, "epss_percentile": 0.36494}, "CVE-2024-25146": {"epss_score": 0.00332, "epss_percentile": 0.5555}, "CVE-2024-25147": {"epss_score": 0.00192, "epss_percentile": 0.41285}, "CVE-2024-25148": {"epss_score": 0.00371, "epss_percentile": 0.58356}, "CVE-2024-25149": {"epss_score": 0.00259, "epss_percentile": 0.49045}, "CVE-2024-25150": {"epss_score": 0.00237, "epss_percentile": 0.46685}, "CVE-2024-25151": {"epss_score": 0.00364, "epss_percentile": 0.57934}, "CVE-2024-25152": {"epss_score": 0.00152, "epss_percentile": 0.36494}, "CVE-2024-25153": {"epss_score": 0.8211, "epss_percentile": 0.99175}, "CVE-2024-25154": {"epss_score": 0.00293, "epss_percentile": 0.52328}, "CVE-2024-25155": {"epss_score": 0.01044, "epss_percentile": 0.77008}, "CVE-2024-25156": {"epss_score": 0.00254, "epss_percentile": 0.4854}, "CVE-2024-25157": {"epss_score": 0.00126, "epss_percentile": 0.32647}, "CVE-2024-25164": {"epss_score": 0.00309, "epss_percentile": 0.53688}, "CVE-2024-25165": {"epss_score": 0.00119, "epss_percentile": 0.31637}, "CVE-2024-25166": {"epss_score": 0.0022, "epss_percentile": 0.44555}, "CVE-2024-25167": {"epss_score": 0.00477, "epss_percentile": 0.64332}, "CVE-2024-25168": {"epss_score": 0.01655, "epss_percentile": 0.81589}, "CVE-2024-25169": {"epss_score": 0.00804, "epss_percentile": 0.73613}, "CVE-2024-25170": {"epss_score": 0.01371, "epss_percentile": 0.79808}, "CVE-2024-25175": {"epss_score": 0.00215, "epss_percentile": 0.44099}, "CVE-2024-25176": {"epss_score": 0.00083, "epss_percentile": 0.24595}, "CVE-2024-25177": {"epss_score": 0.0024, "epss_percentile": 0.46969}, "CVE-2024-25178": {"epss_score": 0.00083, "epss_percentile": 0.24595}, "CVE-2024-25180": {"epss_score": 0.00428, "epss_percentile": 0.61918}, "CVE-2024-25181": {"epss_score": 0.00044, "epss_percentile": 0.13644}, "CVE-2024-25182": {"epss_score": 0.00056, "epss_percentile": 0.17735}, "CVE-2024-25183": {"epss_score": 0.00378, "epss_percentile": 0.58837}, "CVE-2024-25187": {"epss_score": 0.00862, "epss_percentile": 0.7458}, "CVE-2024-25189": {"epss_score": 0.00083, "epss_percentile": 0.24712}, "CVE-2024-25190": {"epss_score": 0.00044, "epss_percentile": 0.13428}, "CVE-2024-25191": {"epss_score": 0.00072, "epss_percentile": 0.22456}, "CVE-2024-25196": {"epss_score": 0.00058, "epss_percentile": 0.18527}, "CVE-2024-25197": {"epss_score": 0.00166, "epss_percentile": 0.38231}, "CVE-2024-25198": {"epss_score": 0.00074, "epss_percentile": 0.22857}, "CVE-2024-25199": {"epss_score": 0.00071, "epss_percentile": 0.22039}, "CVE-2024-25200": {"epss_score": 0.0058, "epss_percentile": 0.68257}, "CVE-2024-25201": {"epss_score": 0.00464, "epss_percentile": 0.63701}, "CVE-2024-25202": {"epss_score": 0.04945, "epss_percentile": 0.89313}, "CVE-2024-25207": {"epss_score": 0.00134, "epss_percentile": 0.33867}, "CVE-2024-25208": {"epss_score": 0.00103, "epss_percentile": 0.28959}, "CVE-2024-25209": {"epss_score": 0.00108, "epss_percentile": 0.29823}, "CVE-2024-25210": {"epss_score": 0.00108, "epss_percentile": 0.29823}, "CVE-2024-25211": {"epss_score": 0.00108, "epss_percentile": 0.29823}, "CVE-2024-25212": {"epss_score": 0.00106, "epss_percentile": 0.29492}, "CVE-2024-25213": {"epss_score": 0.00075, "epss_percentile": 0.23017}, "CVE-2024-25214": {"epss_score": 0.00049, "epss_percentile": 0.15633}, "CVE-2024-25215": {"epss_score": 0.00112, "epss_percentile": 0.30524}, "CVE-2024-25216": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2024-25217": {"epss_score": 0.0015, "epss_percentile": 0.36141}, "CVE-2024-25218": {"epss_score": 0.00121, "epss_percentile": 0.31994}, "CVE-2024-25219": {"epss_score": 0.00197, "epss_percentile": 0.41934}, "CVE-2024-25220": {"epss_score": 0.00108, "epss_percentile": 0.29823}, "CVE-2024-25221": {"epss_score": 0.00258, "epss_percentile": 0.48978}, "CVE-2024-25222": {"epss_score": 0.00112, "epss_percentile": 0.30524}, "CVE-2024-25223": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2024-25224": {"epss_score": 0.00121, "epss_percentile": 0.31994}, "CVE-2024-25225": {"epss_score": 0.00159, "epss_percentile": 0.37337}, "CVE-2024-25226": {"epss_score": 0.0013, "epss_percentile": 0.33276}, "CVE-2024-25227": {"epss_score": 0.00888, "epss_percentile": 0.74999}, "CVE-2024-25228": {"epss_score": 0.43665, "epss_percentile": 0.97398}, "CVE-2024-25239": {"epss_score": 0.00112, "epss_percentile": 0.30524}, "CVE-2024-25247": {"epss_score": 0.00145, "epss_percentile": 0.35432}, "CVE-2024-25248": {"epss_score": 0.0014, "epss_percentile": 0.34686}, "CVE-2024-25249": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2024-25250": {"epss_score": 0.0016, "epss_percentile": 0.37491}, "CVE-2024-25251": {"epss_score": 0.00066, "epss_percentile": 0.2091}, "CVE-2024-25253": {"epss_score": 0.00154, "epss_percentile": 0.36734}, "CVE-2024-25254": {"epss_score": 0.00164, "epss_percentile": 0.37946}, "CVE-2024-25255": {"epss_score": 0.01224, "epss_percentile": 0.78672}, "CVE-2024-25260": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-25262": {"epss_score": 0.0015, "epss_percentile": 0.36129}, "CVE-2024-25269": {"epss_score": 0.00059, "epss_percentile": 0.18624}, "CVE-2024-25270": {"epss_score": 0.00154, "epss_percentile": 0.3674}, "CVE-2024-25274": {"epss_score": 0.00243, "epss_percentile": 0.47432}, "CVE-2024-25288": {"epss_score": 0.00226, "epss_percentile": 0.45274}, "CVE-2024-25290": {"epss_score": 0.0086, "epss_percentile": 0.74529}, "CVE-2024-25291": {"epss_score": 0.11811, "epss_percentile": 0.93483}, "CVE-2024-25292": {"epss_score": 0.08802, "epss_percentile": 0.9226}, "CVE-2024-25293": {"epss_score": 0.14907, "epss_percentile": 0.94319}, "CVE-2024-25294": {"epss_score": 0.01199, "epss_percentile": 0.78458}, "CVE-2024-25297": {"epss_score": 0.00079, "epss_percentile": 0.2382}, "CVE-2024-25298": {"epss_score": 0.00228, "epss_percentile": 0.45514}, "CVE-2024-25300": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2024-25301": {"epss_score": 0.03375, "epss_percentile": 0.87018}, "CVE-2024-25302": {"epss_score": 0.00134, "epss_percentile": 0.33875}, "CVE-2024-25304": {"epss_score": 0.00134, "epss_percentile": 0.33908}, "CVE-2024-25305": {"epss_score": 0.00051, "epss_percentile": 0.16246}, "CVE-2024-25306": {"epss_score": 0.00134, "epss_percentile": 0.33908}, "CVE-2024-25307": {"epss_score": 0.00134, "epss_percentile": 0.33875}, "CVE-2024-25308": {"epss_score": 0.00176, "epss_percentile": 0.39403}, "CVE-2024-25309": {"epss_score": 0.00134, "epss_percentile": 0.33908}, "CVE-2024-25310": {"epss_score": 0.00134, "epss_percentile": 0.33908}, "CVE-2024-25312": {"epss_score": 0.00134, "epss_percentile": 0.33908}, "CVE-2024-25313": {"epss_score": 0.00029, "epss_percentile": 0.0759}, "CVE-2024-25314": {"epss_score": 0.00134, "epss_percentile": 0.33875}, "CVE-2024-25315": {"epss_score": 0.00134, "epss_percentile": 0.33875}, "CVE-2024-25316": {"epss_score": 0.00134, "epss_percentile": 0.33875}, "CVE-2024-25318": {"epss_score": 0.00134, "epss_percentile": 0.33875}, "CVE-2024-25320": {"epss_score": 0.00134, "epss_percentile": 0.33875}, "CVE-2024-25325": {"epss_score": 0.00064, "epss_percentile": 0.2029}, "CVE-2024-25327": {"epss_score": 0.00095, "epss_percentile": 0.2723}, "CVE-2024-25331": {"epss_score": 0.02531, "epss_percentile": 0.85026}, "CVE-2024-25343": {"epss_score": 0.00119, "epss_percentile": 0.31558}, "CVE-2024-25344": {"epss_score": 0.002, "epss_percentile": 0.42251}, "CVE-2024-25350": {"epss_score": 0.00106, "epss_percentile": 0.29535}, "CVE-2024-25351": {"epss_score": 0.00084, "epss_percentile": 0.24835}, "CVE-2024-25354": {"epss_score": 0.00151, "epss_percentile": 0.36255}, "CVE-2024-25355": {"epss_score": 0.00188, "epss_percentile": 0.40846}, "CVE-2024-25359": {"epss_score": 0.00096, "epss_percentile": 0.27347}, "CVE-2024-25360": {"epss_score": 0.00084, "epss_percentile": 0.2493}, "CVE-2024-25366": {"epss_score": 0.00714, "epss_percentile": 0.71806}, "CVE-2024-25369": {"epss_score": 0.00071, "epss_percentile": 0.22149}, "CVE-2024-25371": {"epss_score": 0.00196, "epss_percentile": 0.41787}, "CVE-2024-25373": {"epss_score": 0.00051, "epss_percentile": 0.16033}, "CVE-2024-25376": {"epss_score": 0.00121, "epss_percentile": 0.31819}, "CVE-2024-25381": {"epss_score": 0.00092, "epss_percentile": 0.26511}, "CVE-2024-25385": {"epss_score": 0.00019, "epss_percentile": 0.04392}, "CVE-2024-25386": {"epss_score": 0.1031, "epss_percentile": 0.92938}, "CVE-2024-25388": {"epss_score": 0.00038, "epss_percentile": 0.11326}, "CVE-2024-25389": {"epss_score": 0.00201, "epss_percentile": 0.42352}, "CVE-2024-25390": {"epss_score": 0.00038, "epss_percentile": 0.11326}, "CVE-2024-25391": {"epss_score": 0.00038, "epss_percentile": 0.11326}, "CVE-2024-25392": {"epss_score": 0.00035, "epss_percentile": 0.09808}, "CVE-2024-25393": {"epss_score": 0.00262, "epss_percentile": 0.49384}, "CVE-2024-25394": {"epss_score": 0.00111, "epss_percentile": 0.30336}, "CVE-2024-25395": {"epss_score": 0.00262, "epss_percentile": 0.49394}, "CVE-2024-25398": {"epss_score": 0.00127, "epss_percentile": 0.328}, "CVE-2024-25399": {"epss_score": 0.00245, "epss_percentile": 0.47669}, "CVE-2024-25400": {"epss_score": 0.00492, "epss_percentile": 0.65018}, "CVE-2024-25407": {"epss_score": 0.00173, "epss_percentile": 0.39118}, "CVE-2024-25410": {"epss_score": 0.00424, "epss_percentile": 0.61651}, "CVE-2024-25411": {"epss_score": 0.15483, "epss_percentile": 0.94436}, "CVE-2024-25412": {"epss_score": 0.26695, "epss_percentile": 0.96167}, "CVE-2024-25413": {"epss_score": 0.00105, "epss_percentile": 0.29373}, "CVE-2024-25414": {"epss_score": 0.035, "epss_percentile": 0.87244}, "CVE-2024-25415": {"epss_score": 0.06333, "epss_percentile": 0.90675}, "CVE-2024-25417": {"epss_score": 0.00082, "epss_percentile": 0.24576}, "CVE-2024-25418": {"epss_score": 0.00154, "epss_percentile": 0.36755}, "CVE-2024-25419": {"epss_score": 0.00202, "epss_percentile": 0.4244}, "CVE-2024-25420": {"epss_score": 0.01769, "epss_percentile": 0.82185}, "CVE-2024-25421": {"epss_score": 0.02557, "epss_percentile": 0.85097}, "CVE-2024-25422": {"epss_score": 0.01454, "epss_percentile": 0.80382}, "CVE-2024-25423": {"epss_score": 0.00382, "epss_percentile": 0.59042}, "CVE-2024-25428": {"epss_score": 0.00983, "epss_percentile": 0.76307}, "CVE-2024-25431": {"epss_score": 0.01115, "epss_percentile": 0.77707}, "CVE-2024-25434": {"epss_score": 0.00155, "epss_percentile": 0.36849}, "CVE-2024-25435": {"epss_score": 0.0017, "epss_percentile": 0.38714}, "CVE-2024-25436": {"epss_score": 0.00308, "epss_percentile": 0.53642}, "CVE-2024-25438": {"epss_score": 0.00308, "epss_percentile": 0.53642}, "CVE-2024-25442": {"epss_score": 0.00233, "epss_percentile": 0.46052}, "CVE-2024-25443": {"epss_score": 0.0014, "epss_percentile": 0.34754}, "CVE-2024-25445": {"epss_score": 0.00074, "epss_percentile": 0.22871}, "CVE-2024-25446": {"epss_score": 0.00082, "epss_percentile": 0.24506}, "CVE-2024-25447": {"epss_score": 0.0011, "epss_percentile": 0.30126}, "CVE-2024-25448": {"epss_score": 0.0011, "epss_percentile": 0.30126}, "CVE-2024-25450": {"epss_score": 0.0007, "epss_percentile": 0.21659}, "CVE-2024-25451": {"epss_score": 0.00071, "epss_percentile": 0.21996}, "CVE-2024-25452": {"epss_score": 0.0002, "epss_percentile": 0.0444}, "CVE-2024-25453": {"epss_score": 0.0002, "epss_percentile": 0.0444}, "CVE-2024-25454": {"epss_score": 0.0002, "epss_percentile": 0.0444}, "CVE-2024-25458": {"epss_score": 0.0026, "epss_percentile": 0.49152}, "CVE-2024-25461": {"epss_score": 0.00117, "epss_percentile": 0.31299}, "CVE-2024-25466": {"epss_score": 0.00908, "epss_percentile": 0.75278}, "CVE-2024-25468": {"epss_score": 0.00618, "epss_percentile": 0.69379}, "CVE-2024-25469": {"epss_score": 0.00045, "epss_percentile": 0.14013}, "CVE-2024-25501": {"epss_score": 0.01049, "epss_percentile": 0.7706}, "CVE-2024-25502": {"epss_score": 0.09984, "epss_percentile": 0.92804}, "CVE-2024-25503": {"epss_score": 0.0063, "epss_percentile": 0.69696}, "CVE-2024-25506": {"epss_score": 0.00583, "epss_percentile": 0.68355}, "CVE-2024-25507": {"epss_score": 0.00111, "epss_percentile": 0.30241}, "CVE-2024-25508": {"epss_score": 0.0016, "epss_percentile": 0.37491}, "CVE-2024-25509": {"epss_score": 0.00111, "epss_percentile": 0.30241}, "CVE-2024-25510": {"epss_score": 0.0016, "epss_percentile": 0.37491}, "CVE-2024-25511": {"epss_score": 0.00111, "epss_percentile": 0.30241}, "CVE-2024-25512": {"epss_score": 0.00158, "epss_percentile": 0.37179}, "CVE-2024-25513": {"epss_score": 0.00074, "epss_percentile": 0.22826}, "CVE-2024-25514": {"epss_score": 0.00109, "epss_percentile": 0.29953}, "CVE-2024-25515": {"epss_score": 0.00062, "epss_percentile": 0.19641}, "CVE-2024-25517": {"epss_score": 0.00072, "epss_percentile": 0.223}, "CVE-2024-25518": {"epss_score": 0.00049, "epss_percentile": 0.1565}, "CVE-2024-25519": {"epss_score": 0.00072, "epss_percentile": 0.223}, "CVE-2024-25520": {"epss_score": 0.00075, "epss_percentile": 0.23044}, "CVE-2024-25521": {"epss_score": 0.00052, "epss_percentile": 0.16512}, "CVE-2024-25522": {"epss_score": 0.00049, "epss_percentile": 0.1565}, "CVE-2024-25523": {"epss_score": 0.00075, "epss_percentile": 0.23044}, "CVE-2024-25524": {"epss_score": 0.00049, "epss_percentile": 0.1565}, "CVE-2024-25525": {"epss_score": 0.00069, "epss_percentile": 0.21587}, "CVE-2024-25526": {"epss_score": 0.00075, "epss_percentile": 0.23044}, "CVE-2024-25527": {"epss_score": 0.00091, "epss_percentile": 0.26289}, "CVE-2024-25528": {"epss_score": 0.00056, "epss_percentile": 0.17793}, "CVE-2024-25529": {"epss_score": 0.00408, "epss_percentile": 0.60656}, "CVE-2024-25530": {"epss_score": 0.00132, "epss_percentile": 0.33607}, "CVE-2024-25531": {"epss_score": 0.00132, "epss_percentile": 0.33607}, "CVE-2024-25532": {"epss_score": 0.00122, "epss_percentile": 0.32035}, "CVE-2024-25533": {"epss_score": 0.00217, "epss_percentile": 0.44319}, "CVE-2024-25545": {"epss_score": 0.00046, "epss_percentile": 0.14132}, "CVE-2024-25551": {"epss_score": 0.00093, "epss_percentile": 0.26605}, "CVE-2024-25552": {"epss_score": 0.00028, "epss_percentile": 0.07576}, "CVE-2024-25559": {"epss_score": 0.00255, "epss_percentile": 0.48647}, "CVE-2024-25560": {"epss_score": 0.00362, "epss_percentile": 0.57769}, "CVE-2024-25561": {"epss_score": 0.00148, "epss_percentile": 0.35926}, "CVE-2024-25562": {"epss_score": 0.00144, "epss_percentile": 0.35238}, "CVE-2024-25563": {"epss_score": 0.00084, "epss_percentile": 0.25019}, "CVE-2024-25565": {"epss_score": 0.0003, "epss_percentile": 0.08058}, "CVE-2024-25566": {"epss_score": 0.00247, "epss_percentile": 0.47812}, "CVE-2024-25567": {"epss_score": 0.00149, "epss_percentile": 0.36035}, "CVE-2024-25568": {"epss_score": 0.00397, "epss_percentile": 0.6003}, "CVE-2024-25569": {"epss_score": 0.00137, "epss_percentile": 0.34208}, "CVE-2024-25571": {"epss_score": 0.00034, "epss_percentile": 0.0976}, "CVE-2024-25572": {"epss_score": 0.00191, "epss_percentile": 0.41268}, "CVE-2024-25573": {"epss_score": 0.00062, "epss_percentile": 0.19559}, "CVE-2024-25574": {"epss_score": 0.01887, "epss_percentile": 0.82715}, "CVE-2024-25575": {"epss_score": 0.02741, "epss_percentile": 0.85561}, "CVE-2024-25576": {"epss_score": 0.00147, "epss_percentile": 0.35685}, "CVE-2024-25578": {"epss_score": 0.00085, "epss_percentile": 0.25135}, "CVE-2024-25579": {"epss_score": 0.00152, "epss_percentile": 0.36449}, "CVE-2024-25580": {"epss_score": 0.00073, "epss_percentile": 0.22664}, "CVE-2024-25581": {"epss_score": 0.00014, "epss_percentile": 0.01964}, "CVE-2024-25582": {"epss_score": 0.00181, "epss_percentile": 0.40018}, "CVE-2024-25583": {"epss_score": 9e-05, "epss_percentile": 0.00623}, "CVE-2024-25584": {"epss_score": 0.00095, "epss_percentile": 0.27115}, "CVE-2024-25590": {"epss_score": 0.00126, "epss_percentile": 0.32746}, "CVE-2024-25591": {"epss_score": 0.00282, "epss_percentile": 0.51203}, "CVE-2024-25592": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2024-25593": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-25594": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-25595": {"epss_score": 0.00106, "epss_percentile": 0.29565}, "CVE-2024-25596": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2024-25597": {"epss_score": 0.00098, "epss_percentile": 0.27652}, "CVE-2024-25598": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-25599": {"epss_score": 0.00253, "epss_percentile": 0.48494}, "CVE-2024-25600": {"epss_score": 0.93936, "epss_percentile": 0.9987}, "CVE-2024-25601": {"epss_score": 0.00152, "epss_percentile": 0.36494}, "CVE-2024-25602": {"epss_score": 0.00152, "epss_percentile": 0.36494}, "CVE-2024-25603": {"epss_score": 0.00199, "epss_percentile": 0.42171}, "CVE-2024-25604": {"epss_score": 0.00183, "epss_percentile": 0.40328}, "CVE-2024-25605": {"epss_score": 0.00243, "epss_percentile": 0.47486}, "CVE-2024-25606": {"epss_score": 0.00135, "epss_percentile": 0.34041}, "CVE-2024-25607": {"epss_score": 0.00131, "epss_percentile": 0.335}, "CVE-2024-25608": {"epss_score": 0.15402, "epss_percentile": 0.94424}, "CVE-2024-25609": {"epss_score": 0.00509, "epss_percentile": 0.65753}, "CVE-2024-25610": {"epss_score": 0.00139, "epss_percentile": 0.34568}, "CVE-2024-25611": {"epss_score": 0.00129, "epss_percentile": 0.33141}, "CVE-2024-25612": {"epss_score": 0.00129, "epss_percentile": 0.33141}, "CVE-2024-25613": {"epss_score": 0.00129, "epss_percentile": 0.33141}, "CVE-2024-25614": {"epss_score": 0.00133, "epss_percentile": 0.33682}, "CVE-2024-25615": {"epss_score": 0.00051, "epss_percentile": 0.16299}, "CVE-2024-25616": {"epss_score": 0.00084, "epss_percentile": 0.2493}, "CVE-2024-25617": {"epss_score": 0.01124, "epss_percentile": 0.77799}, "CVE-2024-25618": {"epss_score": 0.0038, "epss_percentile": 0.58926}, "CVE-2024-25619": {"epss_score": 0.00362, "epss_percentile": 0.57783}, "CVE-2024-25620": {"epss_score": 0.00168, "epss_percentile": 0.38406}, "CVE-2024-25621": {"epss_score": 4e-05, "epss_percentile": 0.00153}, "CVE-2024-25622": {"epss_score": 0.00625, "epss_percentile": 0.69594}, "CVE-2024-25623": {"epss_score": 0.00168, "epss_percentile": 0.38445}, "CVE-2024-25624": {"epss_score": 0.00928, "epss_percentile": 0.75576}, "CVE-2024-25625": {"epss_score": 0.0002, "epss_percentile": 0.04537}, "CVE-2024-25626": {"epss_score": 0.01379, "epss_percentile": 0.79857}, "CVE-2024-25627": {"epss_score": 0.00464, "epss_percentile": 0.63723}, "CVE-2024-25628": {"epss_score": 0.00194, "epss_percentile": 0.41533}, "CVE-2024-25629": {"epss_score": 0.00035, "epss_percentile": 0.09919}, "CVE-2024-25630": {"epss_score": 0.00051, "epss_percentile": 0.16061}, "CVE-2024-25631": {"epss_score": 0.00051, "epss_percentile": 0.16061}, "CVE-2024-25632": {"epss_score": 0.00249, "epss_percentile": 0.48023}, "CVE-2024-25633": {"epss_score": 0.00463, "epss_percentile": 0.63671}, "CVE-2024-25634": {"epss_score": 0.00137, "epss_percentile": 0.34234}, "CVE-2024-25635": {"epss_score": 0.00647, "epss_percentile": 0.70152}, "CVE-2024-25636": {"epss_score": 0.00214, "epss_percentile": 0.43969}, "CVE-2024-25637": {"epss_score": 0.00821, "epss_percentile": 0.73894}, "CVE-2024-25638": {"epss_score": 0.00188, "epss_percentile": 0.40903}, "CVE-2024-25639": {"epss_score": 0.00406, "epss_percentile": 0.60544}, "CVE-2024-25640": {"epss_score": 0.00519, "epss_percentile": 0.66168}, "CVE-2024-25641": {"epss_score": 0.88576, "epss_percentile": 0.99478}, "CVE-2024-25642": {"epss_score": 0.0032, "epss_percentile": 0.54619}, "CVE-2024-25643": {"epss_score": 0.00153, "epss_percentile": 0.3663}, "CVE-2024-25644": {"epss_score": 0.00287, "epss_percentile": 0.51791}, "CVE-2024-25645": {"epss_score": 0.00287, "epss_percentile": 0.51791}, "CVE-2024-25646": {"epss_score": 0.00096, "epss_percentile": 0.27409}, "CVE-2024-25647": {"epss_score": 0.00027, "epss_percentile": 0.06853}, "CVE-2024-25648": {"epss_score": 0.02037, "epss_percentile": 0.83354}, "CVE-2024-25649": {"epss_score": 0.0001, "epss_percentile": 0.00894}, "CVE-2024-25650": {"epss_score": 0.00043, "epss_percentile": 0.13287}, "CVE-2024-25651": {"epss_score": 0.00288, "epss_percentile": 0.51928}, "CVE-2024-25652": {"epss_score": 0.00227, "epss_percentile": 0.45384}, "CVE-2024-25653": {"epss_score": 0.00069, "epss_percentile": 0.21474}, "CVE-2024-25654": {"epss_score": 0.00028, "epss_percentile": 0.07567}, "CVE-2024-25655": {"epss_score": 0.0009, "epss_percentile": 0.26006}, "CVE-2024-25656": {"epss_score": 0.00085, "epss_percentile": 0.2516}, "CVE-2024-25657": {"epss_score": 0.00084, "epss_percentile": 0.24977}, "CVE-2024-25658": {"epss_score": 0.00119, "epss_percentile": 0.31638}, "CVE-2024-25659": {"epss_score": 0.00491, "epss_percentile": 0.64954}, "CVE-2024-25660": {"epss_score": 0.00567, "epss_percentile": 0.67842}, "CVE-2024-25661": {"epss_score": 0.00032, "epss_percentile": 0.09092}, "CVE-2024-25662": {"epss_score": 0.00378, "epss_percentile": 0.58834}, "CVE-2024-25673": {"epss_score": 0.00878, "epss_percentile": 0.74816}, "CVE-2024-25674": {"epss_score": 0.00108, "epss_percentile": 0.2988}, "CVE-2024-25675": {"epss_score": 0.00108, "epss_percentile": 0.2988}, "CVE-2024-25676": {"epss_score": 0.00141, "epss_percentile": 0.34916}, "CVE-2024-25677": {"epss_score": 0.00084, "epss_percentile": 0.24855}, "CVE-2024-25678": {"epss_score": 0.00081, "epss_percentile": 0.24353}, "CVE-2024-25679": {"epss_score": 0.00031, "epss_percentile": 0.087}, "CVE-2024-25690": {"epss_score": 0.0024, "epss_percentile": 0.47216}, "CVE-2024-25691": {"epss_score": 0.00383, "epss_percentile": 0.59102}, "CVE-2024-25692": {"epss_score": 0.00281, "epss_percentile": 0.51187}, "CVE-2024-25693": {"epss_score": 0.15249, "epss_percentile": 0.94391}, "CVE-2024-25694": {"epss_score": 0.00221, "epss_percentile": 0.44713}, "CVE-2024-25695": {"epss_score": 0.00228, "epss_percentile": 0.45476}, "CVE-2024-25696": {"epss_score": 0.00181, "epss_percentile": 0.40116}, "CVE-2024-25697": {"epss_score": 0.00271, "epss_percentile": 0.50289}, "CVE-2024-25698": {"epss_score": 0.00412, "epss_percentile": 0.60944}, "CVE-2024-25699": {"epss_score": 0.01891, "epss_percentile": 0.82732}, "CVE-2024-25700": {"epss_score": 0.00111, "epss_percentile": 0.30282}, "CVE-2024-25701": {"epss_score": 0.00292, "epss_percentile": 0.5223}, "CVE-2024-25702": {"epss_score": 0.00221, "epss_percentile": 0.44713}, "CVE-2024-25705": {"epss_score": 0.00209, "epss_percentile": 0.43317}, "CVE-2024-25706": {"epss_score": 0.00419, "epss_percentile": 0.61355}, "CVE-2024-25707": {"epss_score": 0.00308, "epss_percentile": 0.53637}, "CVE-2024-25708": {"epss_score": 0.00195, "epss_percentile": 0.41623}, "CVE-2024-25709": {"epss_score": 0.00098, "epss_percentile": 0.27782}, "CVE-2024-25710": {"epss_score": 0.00018, "epss_percentile": 0.03889}, "CVE-2024-25711": {"epss_score": 0.04082, "epss_percentile": 0.8822}, "CVE-2024-25712": {"epss_score": 0.00237, "epss_percentile": 0.46653}, "CVE-2024-25713": {"epss_score": 0.03059, "epss_percentile": 0.86306}, "CVE-2024-25714": {"epss_score": 0.00162, "epss_percentile": 0.37685}, "CVE-2024-25715": {"epss_score": 0.00064, "epss_percentile": 0.20155}, "CVE-2024-25718": {"epss_score": 0.00114, "epss_percentile": 0.30839}, "CVE-2024-25722": {"epss_score": 0.0008, "epss_percentile": 0.24132}, "CVE-2024-25723": {"epss_score": 0.89644, "epss_percentile": 0.99536}, "CVE-2024-25724": {"epss_score": 0.00336, "epss_percentile": 0.56004}, "CVE-2024-25728": {"epss_score": 0.00196, "epss_percentile": 0.41743}, "CVE-2024-25729": {"epss_score": 0.00053, "epss_percentile": 0.16952}, "CVE-2024-25730": {"epss_score": 0.0017, "epss_percentile": 0.38712}, "CVE-2024-25731": {"epss_score": 0.04413, "epss_percentile": 0.88663}, "CVE-2024-25734": {"epss_score": 0.0307, "epss_percentile": 0.86345}, "CVE-2024-25735": {"epss_score": 0.90779, "epss_percentile": 0.99599}, "CVE-2024-25736": {"epss_score": 0.06948, "epss_percentile": 0.91135}, "CVE-2024-25737": {"epss_score": 0.0028, "epss_percentile": 0.51015}, "CVE-2024-25738": {"epss_score": 0.01716, "epss_percentile": 0.81907}, "CVE-2024-25739": {"epss_score": 7e-05, "epss_percentile": 0.00406}, "CVE-2024-25740": {"epss_score": 0.00012, "epss_percentile": 0.01116}, "CVE-2024-25741": {"epss_score": 7e-05, "epss_percentile": 0.00434}, "CVE-2024-25742": {"epss_score": 0.00045, "epss_percentile": 0.13811}, "CVE-2024-25743": {"epss_score": 0.00128, "epss_percentile": 0.32958}, "CVE-2024-25744": {"epss_score": 0.00048, "epss_percentile": 0.15107}, "CVE-2024-25746": {"epss_score": 0.00981, "epss_percentile": 0.76276}, "CVE-2024-25748": {"epss_score": 0.00981, "epss_percentile": 0.76276}, "CVE-2024-25751": {"epss_score": 0.04571, "epss_percentile": 0.88862}, "CVE-2024-25753": {"epss_score": 0.00969, "epss_percentile": 0.76103}, "CVE-2024-25756": {"epss_score": 0.00981, "epss_percentile": 0.76279}, "CVE-2024-25763": {"epss_score": 0.00141, "epss_percentile": 0.34815}, "CVE-2024-25767": {"epss_score": 0.0015, "epss_percentile": 0.36057}, "CVE-2024-25768": {"epss_score": 0.00078, "epss_percentile": 0.23638}, "CVE-2024-25770": {"epss_score": 0.00107, "epss_percentile": 0.29736}, "CVE-2024-25801": {"epss_score": 0.00092, "epss_percentile": 0.26419}, "CVE-2024-25802": {"epss_score": 0.0014, "epss_percentile": 0.34692}, "CVE-2024-25807": {"epss_score": 0.0025, "epss_percentile": 0.48089}, "CVE-2024-25808": {"epss_score": 0.01073, "epss_percentile": 0.77284}, "CVE-2024-25811": {"epss_score": 0.00149, "epss_percentile": 0.36036}, "CVE-2024-25812": {"epss_score": 0.0003, "epss_percentile": 0.08079}, "CVE-2024-25814": {"epss_score": 0.0003, "epss_percentile": 0.08079}, "CVE-2024-25817": {"epss_score": 0.0008, "epss_percentile": 0.24135}, "CVE-2024-25825": {"epss_score": 0.00252, "epss_percentile": 0.4837}, "CVE-2024-25828": {"epss_score": 0.0014, "epss_percentile": 0.34728}, "CVE-2024-25830": {"epss_score": 0.35846, "epss_percentile": 0.96938}, "CVE-2024-25831": {"epss_score": 0.00121, "epss_percentile": 0.31959}, "CVE-2024-25832": {"epss_score": 0.19119, "epss_percentile": 0.95132}, "CVE-2024-25833": {"epss_score": 0.00152, "epss_percentile": 0.36456}, "CVE-2024-25837": {"epss_score": 0.00155, "epss_percentile": 0.36846}, "CVE-2024-25839": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2024-25840": {"epss_score": 0.00438, "epss_percentile": 0.62544}, "CVE-2024-25841": {"epss_score": 0.00085, "epss_percentile": 0.25124}, "CVE-2024-25842": {"epss_score": 0.00087, "epss_percentile": 0.25443}, "CVE-2024-25843": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2024-25844": {"epss_score": 0.00087, "epss_percentile": 0.25443}, "CVE-2024-25845": {"epss_score": 0.00083, "epss_percentile": 0.24599}, "CVE-2024-25846": {"epss_score": 0.0015, "epss_percentile": 0.36181}, "CVE-2024-25847": {"epss_score": 0.00054, "epss_percentile": 0.17222}, "CVE-2024-25848": {"epss_score": 0.00035, "epss_percentile": 0.10014}, "CVE-2024-25849": {"epss_score": 0.00083, "epss_percentile": 0.24599}, "CVE-2024-25850": {"epss_score": 0.10453, "epss_percentile": 0.92991}, "CVE-2024-25851": {"epss_score": 0.00384, "epss_percentile": 0.59129}, "CVE-2024-25852": {"epss_score": 0.93172, "epss_percentile": 0.99781}, "CVE-2024-25854": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2024-25858": {"epss_score": 0.00069, "epss_percentile": 0.21613}, "CVE-2024-25859": {"epss_score": 0.00257, "epss_percentile": 0.4891}, "CVE-2024-25864": {"epss_score": 0.0086, "epss_percentile": 0.74528}, "CVE-2024-25865": {"epss_score": 0.00394, "epss_percentile": 0.59789}, "CVE-2024-25866": {"epss_score": 0.00563, "epss_percentile": 0.67715}, "CVE-2024-25867": {"epss_score": 0.00126, "epss_percentile": 0.32672}, "CVE-2024-25868": {"epss_score": 0.00197, "epss_percentile": 0.41962}, "CVE-2024-25869": {"epss_score": 0.56013, "epss_percentile": 0.98005}, "CVE-2024-25873": {"epss_score": 0.00113, "epss_percentile": 0.30688}, "CVE-2024-25874": {"epss_score": 0.00077, "epss_percentile": 0.23545}, "CVE-2024-25875": {"epss_score": 0.00083, "epss_percentile": 0.24721}, "CVE-2024-25876": {"epss_score": 0.00137, "epss_percentile": 0.34302}, "CVE-2024-25883": {"epss_score": 0.00131, "epss_percentile": 0.3339}, "CVE-2024-25885": {"epss_score": 0.0012, "epss_percentile": 0.31716}, "CVE-2024-25891": {"epss_score": 0.00264, "epss_percentile": 0.49697}, "CVE-2024-25892": {"epss_score": 0.0028, "epss_percentile": 0.51079}, "CVE-2024-25893": {"epss_score": 0.00268, "epss_percentile": 0.50058}, "CVE-2024-25894": {"epss_score": 0.0028, "epss_percentile": 0.51079}, "CVE-2024-25895": {"epss_score": 0.0014, "epss_percentile": 0.34747}, "CVE-2024-25896": {"epss_score": 0.0019, "epss_percentile": 0.41066}, "CVE-2024-25897": {"epss_score": 0.0892, "epss_percentile": 0.9232}, "CVE-2024-25898": {"epss_score": 0.00093, "epss_percentile": 0.26639}, "CVE-2024-25902": {"epss_score": 0.0041, "epss_percentile": 0.60795}, "CVE-2024-25903": {"epss_score": 0.00282, "epss_percentile": 0.51203}, "CVE-2024-25904": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2024-25905": {"epss_score": 0.00048, "epss_percentile": 0.15129}, "CVE-2024-25906": {"epss_score": 0.00099, "epss_percentile": 0.28403}, "CVE-2024-25907": {"epss_score": 0.00092, "epss_percentile": 0.26536}, "CVE-2024-25908": {"epss_score": 0.00134, "epss_percentile": 0.33864}, "CVE-2024-25909": {"epss_score": 0.00725, "epss_percentile": 0.72052}, "CVE-2024-25910": {"epss_score": 0.00292, "epss_percentile": 0.52241}, "CVE-2024-25911": {"epss_score": 0.00224, "epss_percentile": 0.45044}, "CVE-2024-25912": {"epss_score": 0.00763, "epss_percentile": 0.72886}, "CVE-2024-25913": {"epss_score": 0.00771, "epss_percentile": 0.73021}, "CVE-2024-25914": {"epss_score": 0.0007, "epss_percentile": 0.21926}, "CVE-2024-25915": {"epss_score": 0.00153, "epss_percentile": 0.36513}, "CVE-2024-25916": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-25917": {"epss_score": 0.00343, "epss_percentile": 0.56431}, "CVE-2024-25918": {"epss_score": 0.00716, "epss_percentile": 0.71865}, "CVE-2024-25919": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-25920": {"epss_score": 0.00163, "epss_percentile": 0.37776}, "CVE-2024-25921": {"epss_score": 0.00071, "epss_percentile": 0.22206}, "CVE-2024-25922": {"epss_score": 0.00092, "epss_percentile": 0.26536}, "CVE-2024-25923": {"epss_score": 0.00326, "epss_percentile": 0.55079}, "CVE-2024-25924": {"epss_score": 0.0033, "epss_percentile": 0.55449}, "CVE-2024-25925": {"epss_score": 0.00724, "epss_percentile": 0.72041}, "CVE-2024-25926": {"epss_score": 0.00144, "epss_percentile": 0.35232}, "CVE-2024-25927": {"epss_score": 0.00223, "epss_percentile": 0.44868}, "CVE-2024-25928": {"epss_score": 0.00121, "epss_percentile": 0.32015}, "CVE-2024-25929": {"epss_score": 0.00179, "epss_percentile": 0.39853}, "CVE-2024-25930": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2024-25931": {"epss_score": 0.00168, "epss_percentile": 0.3852}, "CVE-2024-25932": {"epss_score": 0.00168, "epss_percentile": 0.3852}, "CVE-2024-25933": {"epss_score": 0.00282, "epss_percentile": 0.51203}, "CVE-2024-25934": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-25935": {"epss_score": 0.00276, "epss_percentile": 0.50725}, "CVE-2024-25936": {"epss_score": 0.00092, "epss_percentile": 0.26565}, "CVE-2024-25937": {"epss_score": 0.01185, "epss_percentile": 0.78342}, "CVE-2024-25938": {"epss_score": 0.02741, "epss_percentile": 0.85561}, "CVE-2024-25939": {"epss_score": 0.00061, "epss_percentile": 0.1937}, "CVE-2024-25940": {"epss_score": 0.00229, "epss_percentile": 0.45591}, "CVE-2024-25941": {"epss_score": 0.00093, "epss_percentile": 0.26694}, "CVE-2024-25942": {"epss_score": 0.00033, "epss_percentile": 0.09424}, "CVE-2024-25943": {"epss_score": 0.02398, "epss_percentile": 0.84622}, "CVE-2024-25944": {"epss_score": 0.00397, "epss_percentile": 0.6004}, "CVE-2024-25946": {"epss_score": 0.00422, "epss_percentile": 0.61567}, "CVE-2024-25947": {"epss_score": 0.00042, "epss_percentile": 0.12896}, "CVE-2024-25948": {"epss_score": 0.00042, "epss_percentile": 0.12896}, "CVE-2024-25949": {"epss_score": 0.02331, "epss_percentile": 0.84401}, "CVE-2024-25951": {"epss_score": 0.0071, "epss_percentile": 0.71721}, "CVE-2024-25952": {"epss_score": 0.00095, "epss_percentile": 0.2711}, "CVE-2024-25953": {"epss_score": 0.00095, "epss_percentile": 0.2711}, "CVE-2024-25954": {"epss_score": 0.0064, "epss_percentile": 0.69961}, "CVE-2024-25955": {"epss_score": 0.00422, "epss_percentile": 0.61567}, "CVE-2024-25956": {"epss_score": 0.00044, "epss_percentile": 0.13644}, "CVE-2024-25957": {"epss_score": 0.00062, "epss_percentile": 0.19585}, "CVE-2024-25958": {"epss_score": 0.00035, "epss_percentile": 0.09878}, "CVE-2024-25959": {"epss_score": 0.00083, "epss_percentile": 0.24632}, "CVE-2024-25960": {"epss_score": 0.0004, "epss_percentile": 0.12004}, "CVE-2024-25961": {"epss_score": 0.00056, "epss_percentile": 0.17779}, "CVE-2024-25962": {"epss_score": 0.00276, "epss_percentile": 0.50738}, "CVE-2024-25963": {"epss_score": 0.00175, "epss_percentile": 0.39308}, "CVE-2024-25964": {"epss_score": 0.00439, "epss_percentile": 0.62604}, "CVE-2024-25965": {"epss_score": 0.00069, "epss_percentile": 0.21559}, "CVE-2024-25966": {"epss_score": 0.00513, "epss_percentile": 0.65907}, "CVE-2024-25967": {"epss_score": 0.00089, "epss_percentile": 0.25821}, "CVE-2024-25968": {"epss_score": 0.00206, "epss_percentile": 0.42944}, "CVE-2024-25969": {"epss_score": 0.00069, "epss_percentile": 0.21616}, "CVE-2024-25970": {"epss_score": 0.0026, "epss_percentile": 0.49184}, "CVE-2024-25971": {"epss_score": 0.00049, "epss_percentile": 0.15634}, "CVE-2024-25972": {"epss_score": 0.00055, "epss_percentile": 0.17503}, "CVE-2024-25973": {"epss_score": 0.0026, "epss_percentile": 0.49184}, "CVE-2024-25974": {"epss_score": 0.00167, "epss_percentile": 0.38336}, "CVE-2024-25975": {"epss_score": 0.00149, "epss_percentile": 0.35992}, "CVE-2024-25976": {"epss_score": 0.00475, "epss_percentile": 0.64193}, "CVE-2024-25977": {"epss_score": 0.00223, "epss_percentile": 0.44849}, "CVE-2024-25978": {"epss_score": 0.00214, "epss_percentile": 0.43951}, "CVE-2024-25979": {"epss_score": 0.00125, "epss_percentile": 0.3247}, "CVE-2024-25980": {"epss_score": 0.00128, "epss_percentile": 0.32957}, "CVE-2024-25981": {"epss_score": 0.00158, "epss_percentile": 0.37296}, "CVE-2024-25982": {"epss_score": 0.00214, "epss_percentile": 0.44002}, "CVE-2024-25983": {"epss_score": 0.00136, "epss_percentile": 0.3411}, "CVE-2024-25984": {"epss_score": 0.00034, "epss_percentile": 0.09691}, "CVE-2024-25985": {"epss_score": 0.00021, "epss_percentile": 0.04921}, "CVE-2024-25986": {"epss_score": 0.0004, "epss_percentile": 0.1192}, "CVE-2024-25987": {"epss_score": 0.00013, "epss_percentile": 0.01723}, "CVE-2024-25988": {"epss_score": 0.0064, "epss_percentile": 0.6997}, "CVE-2024-25989": {"epss_score": 0.00025, "epss_percentile": 0.06098}, "CVE-2024-25990": {"epss_score": 0.00015, "epss_percentile": 0.02192}, "CVE-2024-25991": {"epss_score": 0.00029, "epss_percentile": 0.07771}, "CVE-2024-25992": {"epss_score": 0.00049, "epss_percentile": 0.15542}, "CVE-2024-25993": {"epss_score": 0.00036, "epss_percentile": 0.10455}, "CVE-2024-25994": {"epss_score": 0.00235, "epss_percentile": 0.4632}, "CVE-2024-25995": {"epss_score": 0.02369, "epss_percentile": 0.84522}, "CVE-2024-25996": {"epss_score": 0.00619, "epss_percentile": 0.69398}, "CVE-2024-25997": {"epss_score": 0.00145, "epss_percentile": 0.3552}, "CVE-2024-25998": {"epss_score": 0.00508, "epss_percentile": 0.65705}, "CVE-2024-25999": {"epss_score": 0.00061, "epss_percentile": 0.1939}, "CVE-2024-26000": {"epss_score": 0.00178, "epss_percentile": 0.39744}, "CVE-2024-26001": {"epss_score": 0.00727, "epss_percentile": 0.72091}, "CVE-2024-26002": {"epss_score": 0.00072, "epss_percentile": 0.22251}, "CVE-2024-26003": {"epss_score": 0.00574, "epss_percentile": 0.68073}, "CVE-2024-26004": {"epss_score": 0.0062, "epss_percentile": 0.69448}, "CVE-2024-26005": {"epss_score": 0.00212, "epss_percentile": 0.43789}, "CVE-2024-26006": {"epss_score": 0.00547, "epss_percentile": 0.67244}, "CVE-2024-26007": {"epss_score": 0.00251, "epss_percentile": 0.48314}, "CVE-2024-26008": {"epss_score": 0.00056, "epss_percentile": 0.17928}, "CVE-2024-26009": {"epss_score": 0.00095, "epss_percentile": 0.27131}, "CVE-2024-26010": {"epss_score": 0.00232, "epss_percentile": 0.45903}, "CVE-2024-26011": {"epss_score": 0.00069, "epss_percentile": 0.21469}, "CVE-2024-26012": {"epss_score": 0.00178, "epss_percentile": 0.39656}, "CVE-2024-26013": {"epss_score": 0.00066, "epss_percentile": 0.2068}, "CVE-2024-26015": {"epss_score": 0.00047, "epss_percentile": 0.14777}, "CVE-2024-26016": {"epss_score": 0.00182, "epss_percentile": 0.40273}, "CVE-2024-26017": {"epss_score": 0.00037, "epss_percentile": 0.10647}, "CVE-2024-26018": {"epss_score": 0.00189, "epss_percentile": 0.40954}, "CVE-2024-26019": {"epss_score": 0.00361, "epss_percentile": 0.57704}, "CVE-2024-26020": {"epss_score": 0.03111, "epss_percentile": 0.86425}, "CVE-2024-26021": {"epss_score": 0.00032, "epss_percentile": 0.08857}, "CVE-2024-26022": {"epss_score": 0.00196, "epss_percentile": 0.41821}, "CVE-2024-26023": {"epss_score": 0.00164, "epss_percentile": 0.37902}, "CVE-2024-26024": {"epss_score": 0.0022, "epss_percentile": 0.44565}, "CVE-2024-26025": {"epss_score": 0.00083, "epss_percentile": 0.24607}, "CVE-2024-26026": {"epss_score": 0.87925, "epss_percentile": 0.99449}, "CVE-2024-26027": {"epss_score": 0.00154, "epss_percentile": 0.36668}, "CVE-2024-26028": {"epss_score": 0.01469, "epss_percentile": 0.80483}, "CVE-2024-26029": {"epss_score": 0.00069, "epss_percentile": 0.21624}, "CVE-2024-26030": {"epss_score": 0.01469, "epss_percentile": 0.80483}, "CVE-2024-26031": {"epss_score": 0.01469, "epss_percentile": 0.80483}, "CVE-2024-26032": {"epss_score": 0.04606, "epss_percentile": 0.88908}, "CVE-2024-26033": {"epss_score": 0.01311, "epss_percentile": 0.79374}, "CVE-2024-26034": {"epss_score": 0.01311, "epss_percentile": 0.79374}, "CVE-2024-26035": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26036": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-26037": {"epss_score": 0.00791, "epss_percentile": 0.73392}, "CVE-2024-26038": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26039": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-26040": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26041": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26042": {"epss_score": 0.04082, "epss_percentile": 0.8822}, "CVE-2024-26043": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26044": {"epss_score": 0.04082, "epss_percentile": 0.8822}, "CVE-2024-26045": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26046": {"epss_score": 0.0145, "epss_percentile": 0.8035}, "CVE-2024-26047": {"epss_score": 0.0145, "epss_percentile": 0.8035}, "CVE-2024-26049": {"epss_score": 0.00887, "epss_percentile": 0.74993}, "CVE-2024-26050": {"epss_score": 0.00777, "epss_percentile": 0.73121}, "CVE-2024-26051": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26052": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26053": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26054": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26055": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26056": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26057": {"epss_score": 0.01479, "epss_percentile": 0.80559}, "CVE-2024-26058": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26059": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26060": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26061": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26062": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26063": {"epss_score": 0.00263, "epss_percentile": 0.49503}, "CVE-2024-26064": {"epss_score": 0.04082, "epss_percentile": 0.8822}, "CVE-2024-26065": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26066": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-26067": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26068": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-26069": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26070": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26071": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26072": {"epss_score": 0.01108, "epss_percentile": 0.77632}, "CVE-2024-26073": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26074": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-26075": {"epss_score": 0.00791, "epss_percentile": 0.73392}, "CVE-2024-26076": {"epss_score": 0.0145, "epss_percentile": 0.8035}, "CVE-2024-26077": {"epss_score": 0.00791, "epss_percentile": 0.73392}, "CVE-2024-26078": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-26079": {"epss_score": 0.0145, "epss_percentile": 0.8035}, "CVE-2024-26080": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26081": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26082": {"epss_score": 0.00898, "epss_percentile": 0.75148}, "CVE-2024-26083": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26084": {"epss_score": 0.0145, "epss_percentile": 0.8035}, "CVE-2024-26085": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-26086": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26087": {"epss_score": 0.0145, "epss_percentile": 0.8035}, "CVE-2024-26088": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-26089": {"epss_score": 0.00937, "epss_percentile": 0.75698}, "CVE-2024-26090": {"epss_score": 0.00937, "epss_percentile": 0.75698}, "CVE-2024-26091": {"epss_score": 0.00937, "epss_percentile": 0.75698}, "CVE-2024-26092": {"epss_score": 0.00735, "epss_percentile": 0.72292}, "CVE-2024-26093": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26094": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26095": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26096": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26097": {"epss_score": 0.0145, "epss_percentile": 0.8035}, "CVE-2024-26098": {"epss_score": 0.0145, "epss_percentile": 0.8035}, "CVE-2024-26101": {"epss_score": 0.01096, "epss_percentile": 0.77516}, "CVE-2024-26102": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26103": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26104": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26105": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26106": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26107": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26110": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26111": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26113": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26114": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26115": {"epss_score": 0.01479, "epss_percentile": 0.80559}, "CVE-2024-26116": {"epss_score": 0.01108, "epss_percentile": 0.77632}, "CVE-2024-26117": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26118": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26119": {"epss_score": 0.0035, "epss_percentile": 0.56954}, "CVE-2024-26120": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26121": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26122": {"epss_score": 0.0145, "epss_percentile": 0.8035}, "CVE-2024-26123": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-26124": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26125": {"epss_score": 0.01156, "epss_percentile": 0.78097}, "CVE-2024-26126": {"epss_score": 0.00051, "epss_percentile": 0.1602}, "CVE-2024-26127": {"epss_score": 0.00067, "epss_percentile": 0.21123}, "CVE-2024-26128": {"epss_score": 0.01754, "epss_percentile": 0.82117}, "CVE-2024-26129": {"epss_score": 0.00392, "epss_percentile": 0.59684}, "CVE-2024-26130": {"epss_score": 0.00341, "epss_percentile": 0.56314}, "CVE-2024-26131": {"epss_score": 0.0003, "epss_percentile": 0.08082}, "CVE-2024-26132": {"epss_score": 0.00157, "epss_percentile": 0.3714}, "CVE-2024-26133": {"epss_score": 0.00068, "epss_percentile": 0.21212}, "CVE-2024-26134": {"epss_score": 0.00809, "epss_percentile": 0.73712}, "CVE-2024-26135": {"epss_score": 0.01036, "epss_percentile": 0.7691}, "CVE-2024-26136": {"epss_score": 0.00271, "epss_percentile": 0.50283}, "CVE-2024-26138": {"epss_score": 0.0024, "epss_percentile": 0.46965}, "CVE-2024-26139": {"epss_score": 0.00158, "epss_percentile": 0.37296}, "CVE-2024-26140": {"epss_score": 0.00166, "epss_percentile": 0.38198}, "CVE-2024-26141": {"epss_score": 0.00294, "epss_percentile": 0.52421}, "CVE-2024-26142": {"epss_score": 0.02644, "epss_percentile": 0.85319}, "CVE-2024-26143": {"epss_score": 0.01535, "epss_percentile": 0.80909}, "CVE-2024-26144": {"epss_score": 0.02313, "epss_percentile": 0.84346}, "CVE-2024-26145": {"epss_score": 0.00158, "epss_percentile": 0.37146}, "CVE-2024-26146": {"epss_score": 0.00572, "epss_percentile": 0.68035}, "CVE-2024-26147": {"epss_score": 0.00217, "epss_percentile": 0.44248}, "CVE-2024-26148": {"epss_score": 0.00317, "epss_percentile": 0.54344}, "CVE-2024-26149": {"epss_score": 0.00542, "epss_percentile": 0.67083}, "CVE-2024-26150": {"epss_score": 0.00385, "epss_percentile": 0.59211}, "CVE-2024-26151": {"epss_score": 0.0082, "epss_percentile": 0.73891}, "CVE-2024-26152": {"epss_score": 0.01335, "epss_percentile": 0.7955}, "CVE-2024-26153": {"epss_score": 0.00039, "epss_percentile": 0.11604}, "CVE-2024-26154": {"epss_score": 0.00079, "epss_percentile": 0.2392}, "CVE-2024-26155": {"epss_score": 0.00072, "epss_percentile": 0.22371}, "CVE-2024-26156": {"epss_score": 0.00079, "epss_percentile": 0.2392}, "CVE-2024-26157": {"epss_score": 0.00086, "epss_percentile": 0.25426}, "CVE-2024-26158": {"epss_score": 0.10112, "epss_percentile": 0.92854}, "CVE-2024-26159": {"epss_score": 0.0163, "epss_percentile": 0.81443}, "CVE-2024-26160": {"epss_score": 0.30044, "epss_percentile": 0.965}, "CVE-2024-26161": {"epss_score": 0.01471, "epss_percentile": 0.80507}, "CVE-2024-26162": {"epss_score": 0.02249, "epss_percentile": 0.84141}, "CVE-2024-26163": {"epss_score": 0.00703, "epss_percentile": 0.71543}, "CVE-2024-26164": {"epss_score": 0.04714, "epss_percentile": 0.89041}, "CVE-2024-26165": {"epss_score": 0.02459, "epss_percentile": 0.84817}, "CVE-2024-26166": {"epss_score": 0.01471, "epss_percentile": 0.80507}, "CVE-2024-26167": {"epss_score": 0.00783, "epss_percentile": 0.73213}, "CVE-2024-26168": {"epss_score": 0.0023, "epss_percentile": 0.45696}, "CVE-2024-26169": {"epss_score": 0.34581, "epss_percentile": 0.96858}, "CVE-2024-26170": {"epss_score": 0.01957, "epss_percentile": 0.83046}, "CVE-2024-26171": {"epss_score": 0.00266, "epss_percentile": 0.49875}, "CVE-2024-26172": {"epss_score": 0.00247, "epss_percentile": 0.47837}, "CVE-2024-26173": {"epss_score": 0.00276, "epss_percentile": 0.5071}, "CVE-2024-26174": {"epss_score": 0.00346, "epss_percentile": 0.56649}, "CVE-2024-26175": {"epss_score": 0.00251, "epss_percentile": 0.48328}, "CVE-2024-26176": {"epss_score": 0.00141, "epss_percentile": 0.34915}, "CVE-2024-26177": {"epss_score": 0.00565, "epss_percentile": 0.6779}, "CVE-2024-26178": {"epss_score": 0.00141, "epss_percentile": 0.34915}, "CVE-2024-26179": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-26180": {"epss_score": 0.00636, "epss_percentile": 0.69872}, "CVE-2024-26181": {"epss_score": 0.00312, "epss_percentile": 0.53936}, "CVE-2024-26182": {"epss_score": 0.02152, "epss_percentile": 0.83792}, "CVE-2024-26183": {"epss_score": 0.14061, "epss_percentile": 0.94126}, "CVE-2024-26184": {"epss_score": 0.01096, "epss_percentile": 0.7752}, "CVE-2024-26185": {"epss_score": 0.16791, "epss_percentile": 0.94733}, "CVE-2024-26186": {"epss_score": 0.05165, "epss_percentile": 0.89564}, "CVE-2024-26188": {"epss_score": 0.02461, "epss_percentile": 0.84824}, "CVE-2024-26189": {"epss_score": 0.00898, "epss_percentile": 0.75142}, "CVE-2024-26190": {"epss_score": 0.00623, "epss_percentile": 0.69541}, "CVE-2024-26191": {"epss_score": 0.05165, "epss_percentile": 0.89564}, "CVE-2024-26192": {"epss_score": 0.0019, "epss_percentile": 0.41128}, "CVE-2024-26193": {"epss_score": 0.00608, "epss_percentile": 0.69068}, "CVE-2024-26194": {"epss_score": 0.00119, "epss_percentile": 0.31612}, "CVE-2024-26195": {"epss_score": 0.06406, "epss_percentile": 0.90732}, "CVE-2024-26196": {"epss_score": 0.01225, "epss_percentile": 0.78682}, "CVE-2024-26197": {"epss_score": 0.05531, "epss_percentile": 0.89966}, "CVE-2024-26198": {"epss_score": 0.04686, "epss_percentile": 0.89007}, "CVE-2024-26199": {"epss_score": 0.00222, "epss_percentile": 0.44783}, "CVE-2024-26200": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-26201": {"epss_score": 0.00486, "epss_percentile": 0.64744}, "CVE-2024-26202": {"epss_score": 0.06406, "epss_percentile": 0.90732}, "CVE-2024-26203": {"epss_score": 0.00485, "epss_percentile": 0.64738}, "CVE-2024-26204": {"epss_score": 0.01777, "epss_percentile": 0.82223}, "CVE-2024-26205": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-26207": {"epss_score": 0.00465, "epss_percentile": 0.63771}, "CVE-2024-26208": {"epss_score": 0.03817, "epss_percentile": 0.87769}, "CVE-2024-26209": {"epss_score": 0.15216, "epss_percentile": 0.94387}, "CVE-2024-26210": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-26211": {"epss_score": 0.06806, "epss_percentile": 0.91039}, "CVE-2024-26212": {"epss_score": 0.53952, "epss_percentile": 0.97904}, "CVE-2024-26213": {"epss_score": 0.00463, "epss_percentile": 0.63683}, "CVE-2024-26214": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-26215": {"epss_score": 0.07584, "epss_percentile": 0.91555}, "CVE-2024-26216": {"epss_score": 0.00664, "epss_percentile": 0.7065}, "CVE-2024-26217": {"epss_score": 0.00644, "epss_percentile": 0.70069}, "CVE-2024-26218": {"epss_score": 0.24582, "epss_percentile": 0.95935}, "CVE-2024-26219": {"epss_score": 0.1498, "epss_percentile": 0.94337}, "CVE-2024-26220": {"epss_score": 0.01015, "epss_percentile": 0.76658}, "CVE-2024-26221": {"epss_score": 0.0269, "epss_percentile": 0.85436}, "CVE-2024-26222": {"epss_score": 0.03609, "epss_percentile": 0.87423}, "CVE-2024-26223": {"epss_score": 0.03609, "epss_percentile": 0.87423}, "CVE-2024-26224": {"epss_score": 0.03609, "epss_percentile": 0.87423}, "CVE-2024-26226": {"epss_score": 0.08211, "epss_percentile": 0.91931}, "CVE-2024-26227": {"epss_score": 0.02712, "epss_percentile": 0.85501}, "CVE-2024-26228": {"epss_score": 0.0031, "epss_percentile": 0.53779}, "CVE-2024-26229": {"epss_score": 0.83166, "epss_percentile": 0.99235}, "CVE-2024-26230": {"epss_score": 0.51267, "epss_percentile": 0.97772}, "CVE-2024-26231": {"epss_score": 0.02712, "epss_percentile": 0.85501}, "CVE-2024-26232": {"epss_score": 0.00743, "epss_percentile": 0.72474}, "CVE-2024-26233": {"epss_score": 0.03609, "epss_percentile": 0.87423}, "CVE-2024-26234": {"epss_score": 0.02705, "epss_percentile": 0.85466}, "CVE-2024-26235": {"epss_score": 0.01222, "epss_percentile": 0.78657}, "CVE-2024-26236": {"epss_score": 0.00284, "epss_percentile": 0.515}, "CVE-2024-26237": {"epss_score": 0.00628, "epss_percentile": 0.69666}, "CVE-2024-26238": {"epss_score": 0.00599, "epss_percentile": 0.68803}, "CVE-2024-26239": {"epss_score": 0.00463, "epss_percentile": 0.63683}, "CVE-2024-26240": {"epss_score": 0.00506, "epss_percentile": 0.65624}, "CVE-2024-26241": {"epss_score": 0.00628, "epss_percentile": 0.69666}, "CVE-2024-26242": {"epss_score": 0.00284, "epss_percentile": 0.515}, "CVE-2024-26243": {"epss_score": 0.00264, "epss_percentile": 0.497}, "CVE-2024-26244": {"epss_score": 0.03201, "epss_percentile": 0.86624}, "CVE-2024-26245": {"epss_score": 0.00628, "epss_percentile": 0.69666}, "CVE-2024-26246": {"epss_score": 0.00293, "epss_percentile": 0.52339}, "CVE-2024-26247": {"epss_score": 0.00565, "epss_percentile": 0.67792}, "CVE-2024-26248": {"epss_score": 0.04291, "epss_percentile": 0.88502}, "CVE-2024-26250": {"epss_score": 0.00247, "epss_percentile": 0.47812}, "CVE-2024-26251": {"epss_score": 0.00393, "epss_percentile": 0.59745}, "CVE-2024-26252": {"epss_score": 0.0023, "epss_percentile": 0.45696}, "CVE-2024-26253": {"epss_score": 0.00337, "epss_percentile": 0.56009}, "CVE-2024-26254": {"epss_score": 0.0653, "epss_percentile": 0.90824}, "CVE-2024-26255": {"epss_score": 0.00681, "epss_percentile": 0.71046}, "CVE-2024-26256": {"epss_score": 0.40557, "epss_percentile": 0.97223}, "CVE-2024-26257": {"epss_score": 0.00515, "epss_percentile": 0.65996}, "CVE-2024-26258": {"epss_score": 0.00218, "epss_percentile": 0.44388}, "CVE-2024-26260": {"epss_score": 0.02746, "epss_percentile": 0.85574}, "CVE-2024-26261": {"epss_score": 0.00253, "epss_percentile": 0.48477}, "CVE-2024-26262": {"epss_score": 0.00585, "epss_percentile": 0.68402}, "CVE-2024-26263": {"epss_score": 0.00066, "epss_percentile": 0.20856}, "CVE-2024-26264": {"epss_score": 0.00483, "epss_percentile": 0.64622}, "CVE-2024-26265": {"epss_score": 0.00688, "epss_percentile": 0.7119}, "CVE-2024-26266": {"epss_score": 0.00199, "epss_percentile": 0.42171}, "CVE-2024-26267": {"epss_score": 0.00148, "epss_percentile": 0.35896}, "CVE-2024-26268": {"epss_score": 0.00173, "epss_percentile": 0.39115}, "CVE-2024-26269": {"epss_score": 0.00141, "epss_percentile": 0.3493}, "CVE-2024-26270": {"epss_score": 0.00239, "epss_percentile": 0.46915}, "CVE-2024-26271": {"epss_score": 0.01486, "epss_percentile": 0.80606}, "CVE-2024-26272": {"epss_score": 0.04226, "epss_percentile": 0.88416}, "CVE-2024-26273": {"epss_score": 0.01486, "epss_percentile": 0.80606}, "CVE-2024-26275": {"epss_score": 0.00206, "epss_percentile": 0.43055}, "CVE-2024-26276": {"epss_score": 0.00077, "epss_percentile": 0.23318}, "CVE-2024-26277": {"epss_score": 0.00055, "epss_percentile": 0.17425}, "CVE-2024-26278": {"epss_score": 0.00012, "epss_percentile": 0.01263}, "CVE-2024-26279": {"epss_score": 0.00028, "epss_percentile": 0.07223}, "CVE-2024-26280": {"epss_score": 0.00226, "epss_percentile": 0.45356}, "CVE-2024-26281": {"epss_score": 0.0027, "epss_percentile": 0.50231}, "CVE-2024-26282": {"epss_score": 0.00405, "epss_percentile": 0.60465}, "CVE-2024-26283": {"epss_score": 0.00127, "epss_percentile": 0.32924}, "CVE-2024-26284": {"epss_score": 0.00651, "epss_percentile": 0.70289}, "CVE-2024-26288": {"epss_score": 0.00115, "epss_percentile": 0.30884}, "CVE-2024-26289": {"epss_score": 0.00191, "epss_percentile": 0.41164}, "CVE-2024-26290": {"epss_score": 0.00226, "epss_percentile": 0.4531}, "CVE-2024-26291": {"epss_score": 0.00058, "epss_percentile": 0.18613}, "CVE-2024-26292": {"epss_score": 0.0013, "epss_percentile": 0.33292}, "CVE-2024-26293": {"epss_score": 0.00057, "epss_percentile": 0.18111}, "CVE-2024-26294": {"epss_score": 0.00283, "epss_percentile": 0.514}, "CVE-2024-26295": {"epss_score": 0.00157, "epss_percentile": 0.37056}, "CVE-2024-26296": {"epss_score": 0.00157, "epss_percentile": 0.37056}, "CVE-2024-26297": {"epss_score": 0.00157, "epss_percentile": 0.37056}, "CVE-2024-26298": {"epss_score": 0.00283, "epss_percentile": 0.514}, "CVE-2024-26299": {"epss_score": 0.00041, "epss_percentile": 0.12369}, "CVE-2024-26300": {"epss_score": 0.00041, "epss_percentile": 0.12369}, "CVE-2024-26301": {"epss_score": 0.00155, "epss_percentile": 0.36823}, "CVE-2024-26302": {"epss_score": 0.00253, "epss_percentile": 0.48479}, "CVE-2024-26303": {"epss_score": 0.00091, "epss_percentile": 0.26405}, "CVE-2024-26304": {"epss_score": 0.73237, "epss_percentile": 0.98742}, "CVE-2024-26305": {"epss_score": 0.16449, "epss_percentile": 0.94662}, "CVE-2024-26306": {"epss_score": 0.00631, "epss_percentile": 0.69713}, "CVE-2024-26307": {"epss_score": 0.00029, "epss_percentile": 0.07734}, "CVE-2024-26308": {"epss_score": 0.00448, "epss_percentile": 0.63004}, "CVE-2024-26309": {"epss_score": 0.00103, "epss_percentile": 0.28969}, "CVE-2024-26310": {"epss_score": 0.00153, "epss_percentile": 0.36623}, "CVE-2024-26311": {"epss_score": 0.00139, "epss_percentile": 0.3454}, "CVE-2024-26312": {"epss_score": 0.00324, "epss_percentile": 0.54972}, "CVE-2024-26313": {"epss_score": 0.00268, "epss_percentile": 0.50084}, "CVE-2024-26314": {"epss_score": 0.00065, "epss_percentile": 0.2066}, "CVE-2024-26317": {"epss_score": 0.0006, "epss_percentile": 0.19177}, "CVE-2024-26318": {"epss_score": 0.0009, "epss_percentile": 0.26055}, "CVE-2024-26327": {"epss_score": 0.00117, "epss_percentile": 0.31311}, "CVE-2024-26328": {"epss_score": 0.00035, "epss_percentile": 0.09936}, "CVE-2024-26329": {"epss_score": 0.0004, "epss_percentile": 0.1187}, "CVE-2024-26330": {"epss_score": 0.00281, "epss_percentile": 0.51131}, "CVE-2024-26331": {"epss_score": 0.67864, "epss_percentile": 0.98523}, "CVE-2024-26333": {"epss_score": 0.00033, "epss_percentile": 0.09241}, "CVE-2024-26334": {"epss_score": 0.00033, "epss_percentile": 0.09241}, "CVE-2024-26335": {"epss_score": 0.00136, "epss_percentile": 0.34096}, "CVE-2024-26337": {"epss_score": 0.00103, "epss_percentile": 0.29016}, "CVE-2024-26339": {"epss_score": 0.00157, "epss_percentile": 0.3713}, "CVE-2024-26342": {"epss_score": 0.00601, "epss_percentile": 0.68851}, "CVE-2024-26349": {"epss_score": 0.00039, "epss_percentile": 0.1145}, "CVE-2024-26350": {"epss_score": 0.0007, "epss_percentile": 0.21688}, "CVE-2024-26351": {"epss_score": 0.00034, "epss_percentile": 0.09704}, "CVE-2024-26352": {"epss_score": 0.0007, "epss_percentile": 0.21688}, "CVE-2024-26362": {"epss_score": 0.00188, "epss_percentile": 0.40918}, "CVE-2024-26367": {"epss_score": 0.01145, "epss_percentile": 0.77992}, "CVE-2024-26369": {"epss_score": 0.00144, "epss_percentile": 0.35293}, "CVE-2024-26445": {"epss_score": 0.00103, "epss_percentile": 0.28921}, "CVE-2024-26450": {"epss_score": 0.00455, "epss_percentile": 0.63296}, "CVE-2024-26454": {"epss_score": 0.00084, "epss_percentile": 0.24896}, "CVE-2024-26455": {"epss_score": 0.00068, "epss_percentile": 0.21303}, "CVE-2024-26458": {"epss_score": 0.00206, "epss_percentile": 0.43049}, "CVE-2024-26461": {"epss_score": 0.00081, "epss_percentile": 0.24388}, "CVE-2024-26462": {"epss_score": 0.00024, "epss_percentile": 0.05979}, "CVE-2024-26465": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2024-26466": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2024-26467": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2024-26468": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2024-26469": {"epss_score": 0.00357, "epss_percentile": 0.57457}, "CVE-2024-26470": {"epss_score": 0.00114, "epss_percentile": 0.30815}, "CVE-2024-26471": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2024-26472": {"epss_score": 0.00203, "epss_percentile": 0.4253}, "CVE-2024-26473": {"epss_score": 0.00307, "epss_percentile": 0.53469}, "CVE-2024-26475": {"epss_score": 0.00057, "epss_percentile": 0.18057}, "CVE-2024-26476": {"epss_score": 0.00045, "epss_percentile": 0.13777}, "CVE-2024-26481": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2024-26482": {"epss_score": 0.00035, "epss_percentile": 0.09997}, "CVE-2024-26483": {"epss_score": 0.00157, "epss_percentile": 0.37129}, "CVE-2024-26484": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2024-26489": {"epss_score": 0.00108, "epss_percentile": 0.29893}, "CVE-2024-26490": {"epss_score": 0.00128, "epss_percentile": 0.33025}, "CVE-2024-26491": {"epss_score": 0.00137, "epss_percentile": 0.34302}, "CVE-2024-26492": {"epss_score": 0.00332, "epss_percentile": 0.55568}, "CVE-2024-26495": {"epss_score": 0.0025, "epss_percentile": 0.48089}, "CVE-2024-26503": {"epss_score": 0.02162, "epss_percentile": 0.83832}, "CVE-2024-26504": {"epss_score": 0.00159, "epss_percentile": 0.37414}, "CVE-2024-26507": {"epss_score": 0.0007, "epss_percentile": 0.21775}, "CVE-2024-26517": {"epss_score": 0.00362, "epss_percentile": 0.57751}, "CVE-2024-26519": {"epss_score": 0.00833, "epss_percentile": 0.74085}, "CVE-2024-26520": {"epss_score": 0.00082, "epss_percentile": 0.24482}, "CVE-2024-26521": {"epss_score": 0.01931, "epss_percentile": 0.8294}, "CVE-2024-26529": {"epss_score": 0.00605, "epss_percentile": 0.68982}, "CVE-2024-26540": {"epss_score": 0.00131, "epss_percentile": 0.33375}, "CVE-2024-26542": {"epss_score": 0.00142, "epss_percentile": 0.35045}, "CVE-2024-26548": {"epss_score": 0.02859, "epss_percentile": 0.85847}, "CVE-2024-26557": {"epss_score": 0.00088, "epss_percentile": 0.2573}, "CVE-2024-26559": {"epss_score": 0.00108, "epss_percentile": 0.29833}, "CVE-2024-26566": {"epss_score": 0.00262, "epss_percentile": 0.49396}, "CVE-2024-26574": {"epss_score": 0.00084, "epss_percentile": 0.24849}, "CVE-2024-26577": {"epss_score": 0.00059, "epss_percentile": 0.18627}, "CVE-2024-26578": {"epss_score": 0.0038, "epss_percentile": 0.58929}, "CVE-2024-26579": {"epss_score": 0.00309, "epss_percentile": 0.53659}, "CVE-2024-26580": {"epss_score": 0.00306, "epss_percentile": 0.534}, "CVE-2024-26581": {"epss_score": 0.0023, "epss_percentile": 0.45719}, "CVE-2024-26582": {"epss_score": 0.00017, "epss_percentile": 0.03373}, "CVE-2024-26583": {"epss_score": 0.00025, "epss_percentile": 0.0634}, "CVE-2024-26584": {"epss_score": 0.00033, "epss_percentile": 0.0916}, "CVE-2024-26585": {"epss_score": 0.00034, "epss_percentile": 0.09544}, "CVE-2024-26586": {"epss_score": 0.0001, "epss_percentile": 0.00769}, "CVE-2024-26587": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26588": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2024-26589": {"epss_score": 0.00021, "epss_percentile": 0.04824}, "CVE-2024-26590": {"epss_score": 0.00023, "epss_percentile": 0.05443}, "CVE-2024-26591": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2024-26592": {"epss_score": 0.00039, "epss_percentile": 0.1143}, "CVE-2024-26593": {"epss_score": 0.0001, "epss_percentile": 0.00748}, "CVE-2024-26594": {"epss_score": 0.00832, "epss_percentile": 0.74063}, "CVE-2024-26595": {"epss_score": 9e-05, "epss_percentile": 0.00699}, "CVE-2024-26596": {"epss_score": 0.00016, "epss_percentile": 0.0303}, "CVE-2024-26597": {"epss_score": 0.00012, "epss_percentile": 0.01183}, "CVE-2024-26598": {"epss_score": 0.00014, "epss_percentile": 0.01969}, "CVE-2024-26599": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2024-26600": {"epss_score": 0.00013, "epss_percentile": 0.01603}, "CVE-2024-26601": {"epss_score": 0.00013, "epss_percentile": 0.01517}, "CVE-2024-26602": {"epss_score": 0.00011, "epss_percentile": 0.00959}, "CVE-2024-26603": {"epss_score": 7e-05, "epss_percentile": 0.00371}, "CVE-2024-26604": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26605": {"epss_score": 0.00013, "epss_percentile": 0.01483}, "CVE-2024-26606": {"epss_score": 0.0002, "epss_percentile": 0.04422}, "CVE-2024-26607": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-26608": {"epss_score": 0.00038, "epss_percentile": 0.11402}, "CVE-2024-26610": {"epss_score": 0.00013, "epss_percentile": 0.01439}, "CVE-2024-26611": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-26612": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26614": {"epss_score": 6e-05, "epss_percentile": 0.00251}, "CVE-2024-26615": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26616": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2024-26617": {"epss_score": 0.00033, "epss_percentile": 0.09248}, "CVE-2024-26618": {"epss_score": 0.00018, "epss_percentile": 0.03632}, "CVE-2024-26619": {"epss_score": 0.00086, "epss_percentile": 0.25284}, "CVE-2024-26620": {"epss_score": 0.00061, "epss_percentile": 0.19369}, "CVE-2024-26621": {"epss_score": 0.00022, "epss_percentile": 0.05196}, "CVE-2024-26622": {"epss_score": 0.00013, "epss_percentile": 0.01434}, "CVE-2024-26623": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26625": {"epss_score": 0.00011, "epss_percentile": 0.00983}, "CVE-2024-26626": {"epss_score": 0.00016, "epss_percentile": 0.02913}, "CVE-2024-26627": {"epss_score": 0.00024, "epss_percentile": 0.05738}, "CVE-2024-26629": {"epss_score": 8e-05, "epss_percentile": 0.00545}, "CVE-2024-26630": {"epss_score": 0.00011, "epss_percentile": 0.00997}, "CVE-2024-26631": {"epss_score": 8e-05, "epss_percentile": 0.00516}, "CVE-2024-26632": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26633": {"epss_score": 0.00018, "epss_percentile": 0.04017}, "CVE-2024-26634": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-26635": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26636": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26637": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2024-26638": {"epss_score": 8e-05, "epss_percentile": 0.00522}, "CVE-2024-26640": {"epss_score": 0.00012, "epss_percentile": 0.01235}, "CVE-2024-26641": {"epss_score": 0.00015, "epss_percentile": 0.02286}, "CVE-2024-26642": {"epss_score": 0.00011, "epss_percentile": 0.01092}, "CVE-2024-26643": {"epss_score": 0.0001, "epss_percentile": 0.00872}, "CVE-2024-26644": {"epss_score": 7e-05, "epss_percentile": 0.00375}, "CVE-2024-26645": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26646": {"epss_score": 0.00011, "epss_percentile": 0.00928}, "CVE-2024-26647": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-26648": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-26649": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-26651": {"epss_score": 0.00024, "epss_percentile": 0.05734}, "CVE-2024-26652": {"epss_score": 0.00027, "epss_percentile": 0.0675}, "CVE-2024-26653": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2024-26654": {"epss_score": 0.00013, "epss_percentile": 0.01694}, "CVE-2024-26655": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-26656": {"epss_score": 0.00011, "epss_percentile": 0.01043}, "CVE-2024-26657": {"epss_score": 0.0001, "epss_percentile": 0.00856}, "CVE-2024-26658": {"epss_score": 0.00029, "epss_percentile": 0.07657}, "CVE-2024-26659": {"epss_score": 0.0001, "epss_percentile": 0.00882}, "CVE-2024-26660": {"epss_score": 0.00015, "epss_percentile": 0.02584}, "CVE-2024-26661": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-26662": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-26663": {"epss_score": 0.00013, "epss_percentile": 0.01596}, "CVE-2024-26664": {"epss_score": 9e-05, "epss_percentile": 0.0071}, "CVE-2024-26665": {"epss_score": 7e-05, "epss_percentile": 0.00348}, "CVE-2024-26666": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-26667": {"epss_score": 0.00024, "epss_percentile": 0.05675}, "CVE-2024-26668": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2024-26669": {"epss_score": 9e-05, "epss_percentile": 0.0071}, "CVE-2024-26670": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2024-26671": {"epss_score": 9e-05, "epss_percentile": 0.00744}, "CVE-2024-26672": {"epss_score": 0.0001, "epss_percentile": 0.00751}, "CVE-2024-26673": {"epss_score": 0.00011, "epss_percentile": 0.00995}, "CVE-2024-26674": {"epss_score": 0.00018, "epss_percentile": 0.04029}, "CVE-2024-26675": {"epss_score": 0.0001, "epss_percentile": 0.00807}, "CVE-2024-26676": {"epss_score": 0.00022, "epss_percentile": 0.04951}, "CVE-2024-26677": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26678": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-26679": {"epss_score": 0.00015, "epss_percentile": 0.02601}, "CVE-2024-26680": {"epss_score": 0.00017, "epss_percentile": 0.035}, "CVE-2024-26681": {"epss_score": 0.00024, "epss_percentile": 0.05675}, "CVE-2024-26682": {"epss_score": 0.0003, "epss_percentile": 0.08143}, "CVE-2024-26683": {"epss_score": 0.0003, "epss_percentile": 0.08143}, "CVE-2024-26684": {"epss_score": 0.00021, "epss_percentile": 0.04789}, "CVE-2024-26685": {"epss_score": 0.0001, "epss_percentile": 0.00788}, "CVE-2024-26686": {"epss_score": 0.0001, "epss_percentile": 0.00814}, "CVE-2024-26687": {"epss_score": 0.00012, "epss_percentile": 0.0133}, "CVE-2024-26688": {"epss_score": 0.00013, "epss_percentile": 0.01654}, "CVE-2024-26689": {"epss_score": 0.00012, "epss_percentile": 0.01226}, "CVE-2024-26690": {"epss_score": 0.001, "epss_percentile": 0.28446}, "CVE-2024-26691": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2024-26692": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-26693": {"epss_score": 9e-05, "epss_percentile": 0.00703}, "CVE-2024-26694": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-26695": {"epss_score": 0.00022, "epss_percentile": 0.05043}, "CVE-2024-26696": {"epss_score": 0.00011, "epss_percentile": 0.01034}, "CVE-2024-26697": {"epss_score": 7e-05, "epss_percentile": 0.00436}, "CVE-2024-26698": {"epss_score": 0.0001, "epss_percentile": 0.0075}, "CVE-2024-26699": {"epss_score": 0.00039, "epss_percentile": 0.11631}, "CVE-2024-26700": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-26702": {"epss_score": 7e-05, "epss_percentile": 0.00366}, "CVE-2024-26703": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-26704": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2024-26705": {"epss_score": 0.00012, "epss_percentile": 0.01116}, "CVE-2024-26706": {"epss_score": 0.00056, "epss_percentile": 0.17848}, "CVE-2024-26707": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2024-26708": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2024-26709": {"epss_score": 0.00037, "epss_percentile": 0.10794}, "CVE-2024-26710": {"epss_score": 0.00019, "epss_percentile": 0.04226}, "CVE-2024-26711": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26712": {"epss_score": 6e-05, "epss_percentile": 0.00315}, "CVE-2024-26714": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-26715": {"epss_score": 0.00022, "epss_percentile": 0.0527}, "CVE-2024-26716": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26717": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2024-26718": {"epss_score": 0.00011, "epss_percentile": 0.0103}, "CVE-2024-26719": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2024-26721": {"epss_score": 0.0001, "epss_percentile": 0.00894}, "CVE-2024-26722": {"epss_score": 9e-05, "epss_percentile": 0.00622}, "CVE-2024-26723": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2024-26724": {"epss_score": 0.00043, "epss_percentile": 0.12949}, "CVE-2024-26725": {"epss_score": 8e-05, "epss_percentile": 0.00505}, "CVE-2024-26726": {"epss_score": 5e-05, "epss_percentile": 0.00181}, "CVE-2024-26727": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2024-26728": {"epss_score": 0.00083, "epss_percentile": 0.24614}, "CVE-2024-26729": {"epss_score": 0.00083, "epss_percentile": 0.24614}, "CVE-2024-26730": {"epss_score": 0.00097, "epss_percentile": 0.27522}, "CVE-2024-26731": {"epss_score": 0.00026, "epss_percentile": 0.06442}, "CVE-2024-26732": {"epss_score": 0.00032, "epss_percentile": 0.0899}, "CVE-2024-26733": {"epss_score": 8e-05, "epss_percentile": 0.00566}, "CVE-2024-26734": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-26735": {"epss_score": 0.00028, "epss_percentile": 0.07293}, "CVE-2024-26736": {"epss_score": 0.00015, "epss_percentile": 0.0243}, "CVE-2024-26737": {"epss_score": 9e-05, "epss_percentile": 0.00742}, "CVE-2024-26738": {"epss_score": 0.00068, "epss_percentile": 0.21289}, "CVE-2024-26739": {"epss_score": 0.00012, "epss_percentile": 0.01328}, "CVE-2024-26740": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2024-26741": {"epss_score": 0.00054, "epss_percentile": 0.17258}, "CVE-2024-26742": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2024-26743": {"epss_score": 3e-05, "epss_percentile": 0.00071}, "CVE-2024-26744": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26745": {"epss_score": 0.00016, "epss_percentile": 0.02753}, "CVE-2024-26746": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26747": {"epss_score": 7e-05, "epss_percentile": 0.00466}, "CVE-2024-26748": {"epss_score": 0.00015, "epss_percentile": 0.0253}, "CVE-2024-26749": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2024-26750": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2024-26751": {"epss_score": 9e-05, "epss_percentile": 0.00613}, "CVE-2024-26752": {"epss_score": 7e-05, "epss_percentile": 0.00436}, "CVE-2024-26753": {"epss_score": 0.00015, "epss_percentile": 0.02413}, "CVE-2024-26754": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2024-26755": {"epss_score": 0.00156, "epss_percentile": 0.36957}, "CVE-2024-26756": {"epss_score": 0.00022, "epss_percentile": 0.05285}, "CVE-2024-26757": {"epss_score": 9e-05, "epss_percentile": 0.0072}, "CVE-2024-26758": {"epss_score": 8e-05, "epss_percentile": 0.0051}, "CVE-2024-26759": {"epss_score": 8e-05, "epss_percentile": 0.00561}, "CVE-2024-26760": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26761": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-26762": {"epss_score": 0.00012, "epss_percentile": 0.01181}, "CVE-2024-26763": {"epss_score": 0.00014, "epss_percentile": 0.0202}, "CVE-2024-26764": {"epss_score": 9e-05, "epss_percentile": 0.00633}, "CVE-2024-26765": {"epss_score": 0.00094, "epss_percentile": 0.26766}, "CVE-2024-26766": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26767": {"epss_score": 8e-05, "epss_percentile": 0.0054}, "CVE-2024-26768": {"epss_score": 0.00046, "epss_percentile": 0.14419}, "CVE-2024-26769": {"epss_score": 0.00014, "epss_percentile": 0.01916}, "CVE-2024-26770": {"epss_score": 0.00094, "epss_percentile": 0.26766}, "CVE-2024-26771": {"epss_score": 0.00019, "epss_percentile": 0.04249}, "CVE-2024-26772": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26773": {"epss_score": 0.00011, "epss_percentile": 0.00979}, "CVE-2024-26774": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2024-26775": {"epss_score": 7e-05, "epss_percentile": 0.00412}, "CVE-2024-26776": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2024-26777": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26778": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26779": {"epss_score": 6e-05, "epss_percentile": 0.00273}, "CVE-2024-26780": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2024-26781": {"epss_score": 0.00011, "epss_percentile": 0.01055}, "CVE-2024-26782": {"epss_score": 0.00013, "epss_percentile": 0.01534}, "CVE-2024-26783": {"epss_score": 0.00013, "epss_percentile": 0.01623}, "CVE-2024-26784": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-26785": {"epss_score": 8e-05, "epss_percentile": 0.00568}, "CVE-2024-26786": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-26787": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2024-26788": {"epss_score": 0.00012, "epss_percentile": 0.01177}, "CVE-2024-26789": {"epss_score": 0.00015, "epss_percentile": 0.02537}, "CVE-2024-26790": {"epss_score": 5e-05, "epss_percentile": 0.00236}, "CVE-2024-26791": {"epss_score": 7e-05, "epss_percentile": 0.00463}, "CVE-2024-26792": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2024-26793": {"epss_score": 0.00014, "epss_percentile": 0.0185}, "CVE-2024-26795": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2024-26796": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-26797": {"epss_score": 0.00036, "epss_percentile": 0.10554}, "CVE-2024-26798": {"epss_score": 0.0004, "epss_percentile": 0.11915}, "CVE-2024-26799": {"epss_score": 0.00018, "epss_percentile": 0.03685}, "CVE-2024-26800": {"epss_score": 0.00019, "epss_percentile": 0.04054}, "CVE-2024-26801": {"epss_score": 0.00011, "epss_percentile": 0.01064}, "CVE-2024-26802": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2024-26803": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2024-26804": {"epss_score": 0.00346, "epss_percentile": 0.5662}, "CVE-2024-26805": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26806": {"epss_score": 0.00013, "epss_percentile": 0.01633}, "CVE-2024-26807": {"epss_score": 0.00015, "epss_percentile": 0.02544}, "CVE-2024-26808": {"epss_score": 8e-05, "epss_percentile": 0.00505}, "CVE-2024-26809": {"epss_score": 0.00014, "epss_percentile": 0.02119}, "CVE-2024-26810": {"epss_score": 7e-05, "epss_percentile": 0.00353}, "CVE-2024-26811": {"epss_score": 9e-05, "epss_percentile": 0.00689}, "CVE-2024-26812": {"epss_score": 0.00014, "epss_percentile": 0.02016}, "CVE-2024-26813": {"epss_score": 0.0002, "epss_percentile": 0.04526}, "CVE-2024-26814": {"epss_score": 0.00021, "epss_percentile": 0.04789}, "CVE-2024-26815": {"epss_score": 0.00022, "epss_percentile": 0.04951}, "CVE-2024-26816": {"epss_score": 0.00013, "epss_percentile": 0.01531}, "CVE-2024-26817": {"epss_score": 0.00146, "epss_percentile": 0.35537}, "CVE-2024-26818": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-26820": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26822": {"epss_score": 0.00012, "epss_percentile": 0.01148}, "CVE-2024-26823": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-26824": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26825": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26826": {"epss_score": 0.00039, "epss_percentile": 0.11535}, "CVE-2024-26828": {"epss_score": 0.00018, "epss_percentile": 0.03829}, "CVE-2024-26829": {"epss_score": 0.00012, "epss_percentile": 0.01288}, "CVE-2024-26830": {"epss_score": 0.00012, "epss_percentile": 0.01414}, "CVE-2024-26831": {"epss_score": 9e-05, "epss_percentile": 0.00657}, "CVE-2024-26832": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26833": {"epss_score": 7e-05, "epss_percentile": 0.0041}, "CVE-2024-26834": {"epss_score": 0.00026, "epss_percentile": 0.0653}, "CVE-2024-26835": {"epss_score": 0.00011, "epss_percentile": 0.00995}, "CVE-2024-26836": {"epss_score": 0.00012, "epss_percentile": 0.01243}, "CVE-2024-26837": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2024-26838": {"epss_score": 0.00016, "epss_percentile": 0.02847}, "CVE-2024-26839": {"epss_score": 0.00011, "epss_percentile": 0.01027}, "CVE-2024-26840": {"epss_score": 0.00016, "epss_percentile": 0.02873}, "CVE-2024-26841": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-26842": {"epss_score": 0.00015, "epss_percentile": 0.0234}, "CVE-2024-26843": {"epss_score": 6e-05, "epss_percentile": 0.0032}, "CVE-2024-26844": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-26845": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26846": {"epss_score": 6e-05, "epss_percentile": 0.00309}, "CVE-2024-26847": {"epss_score": 0.00047, "epss_percentile": 0.14857}, "CVE-2024-26849": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26850": {"epss_score": 0.00019, "epss_percentile": 0.04185}, "CVE-2024-26851": {"epss_score": 7e-05, "epss_percentile": 0.00436}, "CVE-2024-26852": {"epss_score": 0.00012, "epss_percentile": 0.01263}, "CVE-2024-26853": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2024-26854": {"epss_score": 0.00044, "epss_percentile": 0.13592}, "CVE-2024-26855": {"epss_score": 6e-05, "epss_percentile": 0.00319}, "CVE-2024-26856": {"epss_score": 0.0002, "epss_percentile": 0.04657}, "CVE-2024-26857": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-26858": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-26859": {"epss_score": 5e-05, "epss_percentile": 0.00223}, "CVE-2024-26860": {"epss_score": 0.00016, "epss_percentile": 0.02847}, "CVE-2024-26861": {"epss_score": 6e-05, "epss_percentile": 0.00314}, "CVE-2024-26862": {"epss_score": 7e-05, "epss_percentile": 0.00434}, "CVE-2024-26863": {"epss_score": 7e-05, "epss_percentile": 0.00428}, "CVE-2024-26864": {"epss_score": 0.00032, "epss_percentile": 0.09011}, "CVE-2024-26865": {"epss_score": 0.0002, "epss_percentile": 0.04657}, "CVE-2024-26866": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-26867": {"epss_score": 0.00018, "epss_percentile": 0.03706}, "CVE-2024-26868": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2024-26869": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-26870": {"epss_score": 0.00012, "epss_percentile": 0.01337}, "CVE-2024-26871": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-26872": {"epss_score": 0.00012, "epss_percentile": 0.01345}, "CVE-2024-26873": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2024-26874": {"epss_score": 9e-05, "epss_percentile": 0.00594}, "CVE-2024-26875": {"epss_score": 0.0001, "epss_percentile": 0.00857}, "CVE-2024-26876": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-26877": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2024-26878": {"epss_score": 6e-05, "epss_percentile": 0.00256}, "CVE-2024-26879": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2024-26880": {"epss_score": 0.00026, "epss_percentile": 0.06404}, "CVE-2024-26881": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2024-26882": {"epss_score": 0.00033, "epss_percentile": 0.0921}, "CVE-2024-26883": {"epss_score": 0.00014, "epss_percentile": 0.02054}, "CVE-2024-26884": {"epss_score": 0.00011, "epss_percentile": 0.01115}, "CVE-2024-26885": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2024-26886": {"epss_score": 0.00017, "epss_percentile": 0.03116}, "CVE-2024-26887": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-26888": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-26889": {"epss_score": 0.00011, "epss_percentile": 0.00992}, "CVE-2024-26890": {"epss_score": 0.00059, "epss_percentile": 0.18868}, "CVE-2024-26891": {"epss_score": 8e-05, "epss_percentile": 0.00545}, "CVE-2024-26892": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-26893": {"epss_score": 0.00011, "epss_percentile": 0.01038}, "CVE-2024-26894": {"epss_score": 6e-05, "epss_percentile": 0.00322}, "CVE-2024-26895": {"epss_score": 0.00015, "epss_percentile": 0.0253}, "CVE-2024-26896": {"epss_score": 9e-05, "epss_percentile": 0.00742}, "CVE-2024-26897": {"epss_score": 5e-05, "epss_percentile": 0.002}, "CVE-2024-26898": {"epss_score": 0.00014, "epss_percentile": 0.01884}, "CVE-2024-26899": {"epss_score": 0.00024, "epss_percentile": 0.05966}, "CVE-2024-26900": {"epss_score": 0.0001, "epss_percentile": 0.00755}, "CVE-2024-26901": {"epss_score": 0.0003, "epss_percentile": 0.08227}, "CVE-2024-26902": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-26903": {"epss_score": 0.00011, "epss_percentile": 0.00973}, "CVE-2024-26906": {"epss_score": 7e-05, "epss_percentile": 0.00346}, "CVE-2024-26907": {"epss_score": 6e-05, "epss_percentile": 0.00244}, "CVE-2024-26909": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2024-26910": {"epss_score": 9e-05, "epss_percentile": 0.00696}, "CVE-2024-26911": {"epss_score": 0.00016, "epss_percentile": 0.0285}, "CVE-2024-26912": {"epss_score": 0.00017, "epss_percentile": 0.03202}, "CVE-2024-26913": {"epss_score": 0.00013, "epss_percentile": 0.01616}, "CVE-2024-26914": {"epss_score": 0.00037, "epss_percentile": 0.10661}, "CVE-2024-26915": {"epss_score": 0.00012, "epss_percentile": 0.01133}, "CVE-2024-26916": {"epss_score": 0.00012, "epss_percentile": 0.01387}, "CVE-2024-26917": {"epss_score": 0.00011, "epss_percentile": 0.01047}, "CVE-2024-26918": {"epss_score": 0.00037, "epss_percentile": 0.10663}, "CVE-2024-26919": {"epss_score": 0.00012, "epss_percentile": 0.01183}, "CVE-2024-26920": {"epss_score": 0.00011, "epss_percentile": 0.01043}, "CVE-2024-26921": {"epss_score": 0.00057, "epss_percentile": 0.18178}, "CVE-2024-26922": {"epss_score": 0.00016, "epss_percentile": 0.03052}, "CVE-2024-26923": {"epss_score": 8e-05, "epss_percentile": 0.00506}, "CVE-2024-26924": {"epss_score": 0.00173, "epss_percentile": 0.39043}, "CVE-2024-26925": {"epss_score": 0.00011, "epss_percentile": 0.01041}, "CVE-2024-26926": {"epss_score": 0.00123, "epss_percentile": 0.32266}, "CVE-2024-26927": {"epss_score": 0.00063, "epss_percentile": 0.20061}, "CVE-2024-26928": {"epss_score": 0.00017, "epss_percentile": 0.0323}, "CVE-2024-26930": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-26931": {"epss_score": 7e-05, "epss_percentile": 0.00428}, "CVE-2024-26932": {"epss_score": 0.00018, "epss_percentile": 0.03628}, "CVE-2024-26933": {"epss_score": 0.00014, "epss_percentile": 0.01818}, "CVE-2024-26934": {"epss_score": 9e-05, "epss_percentile": 0.00665}, "CVE-2024-26935": {"epss_score": 7e-05, "epss_percentile": 0.00362}, "CVE-2024-26936": {"epss_score": 0.00024, "epss_percentile": 0.05892}, "CVE-2024-26937": {"epss_score": 0.00022, "epss_percentile": 0.04974}, "CVE-2024-26938": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2024-26939": {"epss_score": 0.00012, "epss_percentile": 0.01195}, "CVE-2024-26940": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2024-26941": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-26942": {"epss_score": 0.00014, "epss_percentile": 0.01883}, "CVE-2024-26943": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2024-26944": {"epss_score": 0.00011, "epss_percentile": 0.01061}, "CVE-2024-26945": {"epss_score": 0.00011, "epss_percentile": 0.01059}, "CVE-2024-26946": {"epss_score": 5e-05, "epss_percentile": 0.00189}, "CVE-2024-26947": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-26948": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2024-26949": {"epss_score": 0.0001, "epss_percentile": 0.00809}, "CVE-2024-26950": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2024-26951": {"epss_score": 0.00018, "epss_percentile": 0.03833}, "CVE-2024-26952": {"epss_score": 0.00031, "epss_percentile": 0.08455}, "CVE-2024-26953": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-26954": {"epss_score": 7e-05, "epss_percentile": 0.0034}, "CVE-2024-26955": {"epss_score": 0.00017, "epss_percentile": 0.03208}, "CVE-2024-26956": {"epss_score": 0.00013, "epss_percentile": 0.0159}, "CVE-2024-26957": {"epss_score": 0.00017, "epss_percentile": 0.03338}, "CVE-2024-26958": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2024-26959": {"epss_score": 0.00019, "epss_percentile": 0.04185}, "CVE-2024-26960": {"epss_score": 5e-05, "epss_percentile": 0.00236}, "CVE-2024-26961": {"epss_score": 0.00011, "epss_percentile": 0.01095}, "CVE-2024-26962": {"epss_score": 8e-05, "epss_percentile": 0.00491}, "CVE-2024-26963": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2024-26964": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2024-26965": {"epss_score": 0.00017, "epss_percentile": 0.03208}, "CVE-2024-26966": {"epss_score": 7e-05, "epss_percentile": 0.00412}, "CVE-2024-26967": {"epss_score": 0.00018, "epss_percentile": 0.03621}, "CVE-2024-26968": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-26969": {"epss_score": 0.00013, "epss_percentile": 0.01493}, "CVE-2024-26970": {"epss_score": 8e-05, "epss_percentile": 0.00533}, "CVE-2024-26971": {"epss_score": 0.00021, "epss_percentile": 0.04793}, "CVE-2024-26973": {"epss_score": 7e-05, "epss_percentile": 0.00428}, "CVE-2024-26974": {"epss_score": 0.00037, "epss_percentile": 0.10891}, "CVE-2024-26975": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-26976": {"epss_score": 5e-05, "epss_percentile": 0.00213}, "CVE-2024-26977": {"epss_score": 8e-05, "epss_percentile": 0.0059}, "CVE-2024-26978": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2024-26980": {"epss_score": 0.00017, "epss_percentile": 0.03188}, "CVE-2024-26981": {"epss_score": 0.00015, "epss_percentile": 0.02215}, "CVE-2024-26982": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2024-26983": {"epss_score": 9e-05, "epss_percentile": 0.00683}, "CVE-2024-26984": {"epss_score": 0.00015, "epss_percentile": 0.02387}, "CVE-2024-26985": {"epss_score": 0.00015, "epss_percentile": 0.02552}, "CVE-2024-26986": {"epss_score": 0.00012, "epss_percentile": 0.01236}, "CVE-2024-26987": {"epss_score": 0.00017, "epss_percentile": 0.03123}, "CVE-2024-26988": {"epss_score": 0.00011, "epss_percentile": 0.01007}, "CVE-2024-26989": {"epss_score": 0.00014, "epss_percentile": 0.01969}, "CVE-2024-26990": {"epss_score": 0.00011, "epss_percentile": 0.01079}, "CVE-2024-26991": {"epss_score": 0.00015, "epss_percentile": 0.02552}, "CVE-2024-26992": {"epss_score": 4e-05, "epss_percentile": 0.00163}, "CVE-2024-26993": {"epss_score": 0.00013, "epss_percentile": 0.01648}, "CVE-2024-26994": {"epss_score": 0.00022, "epss_percentile": 0.05029}, "CVE-2024-26995": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2024-26996": {"epss_score": 0.00011, "epss_percentile": 0.01081}, "CVE-2024-26997": {"epss_score": 0.00023, "epss_percentile": 0.0564}, "CVE-2024-26998": {"epss_score": 0.00012, "epss_percentile": 0.01257}, "CVE-2024-26999": {"epss_score": 0.00015, "epss_percentile": 0.02597}, "CVE-2024-27000": {"epss_score": 0.00014, "epss_percentile": 0.01999}, "CVE-2024-27001": {"epss_score": 0.00022, "epss_percentile": 0.05239}, "CVE-2024-27002": {"epss_score": 0.0001, "epss_percentile": 0.00797}, "CVE-2024-27003": {"epss_score": 0.00017, "epss_percentile": 0.03123}, "CVE-2024-27004": {"epss_score": 0.00015, "epss_percentile": 0.02599}, "CVE-2024-27005": {"epss_score": 5e-05, "epss_percentile": 0.00232}, "CVE-2024-27006": {"epss_score": 0.00032, "epss_percentile": 0.09004}, "CVE-2024-27007": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-27008": {"epss_score": 0.00012, "epss_percentile": 0.01255}, "CVE-2024-27009": {"epss_score": 0.00016, "epss_percentile": 0.02921}, "CVE-2024-27010": {"epss_score": 7e-05, "epss_percentile": 0.00346}, "CVE-2024-27011": {"epss_score": 7e-05, "epss_percentile": 0.00331}, "CVE-2024-27012": {"epss_score": 8e-05, "epss_percentile": 0.00585}, "CVE-2024-27013": {"epss_score": 0.00016, "epss_percentile": 0.02614}, "CVE-2024-27014": {"epss_score": 0.0001, "epss_percentile": 0.00797}, "CVE-2024-27015": {"epss_score": 0.00021, "epss_percentile": 0.04789}, "CVE-2024-27016": {"epss_score": 9e-05, "epss_percentile": 0.00705}, "CVE-2024-27017": {"epss_score": 0.00011, "epss_percentile": 0.01011}, "CVE-2024-27018": {"epss_score": 0.00011, "epss_percentile": 0.01081}, "CVE-2024-27019": {"epss_score": 5e-05, "epss_percentile": 0.00186}, "CVE-2024-27020": {"epss_score": 0.00011, "epss_percentile": 0.01108}, "CVE-2024-27021": {"epss_score": 0.00012, "epss_percentile": 0.01393}, "CVE-2024-27022": {"epss_score": 0.0001, "epss_percentile": 0.00873}, "CVE-2024-27023": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-27024": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2024-27025": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-27026": {"epss_score": 0.00011, "epss_percentile": 0.01037}, "CVE-2024-27027": {"epss_score": 0.00041, "epss_percentile": 0.12347}, "CVE-2024-27028": {"epss_score": 0.00144, "epss_percentile": 0.35228}, "CVE-2024-27029": {"epss_score": 0.00011, "epss_percentile": 0.00997}, "CVE-2024-27030": {"epss_score": 9e-05, "epss_percentile": 0.00689}, "CVE-2024-27031": {"epss_score": 0.00032, "epss_percentile": 0.0882}, "CVE-2024-27032": {"epss_score": 0.00022, "epss_percentile": 0.04949}, "CVE-2024-27033": {"epss_score": 0.00041, "epss_percentile": 0.12347}, "CVE-2024-27034": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2024-27035": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2024-27036": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2024-27037": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2024-27038": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-27039": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2024-27040": {"epss_score": 0.00094, "epss_percentile": 0.26766}, "CVE-2024-27041": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-27042": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-27043": {"epss_score": 0.00011, "epss_percentile": 0.01115}, "CVE-2024-27044": {"epss_score": 0.00011, "epss_percentile": 0.01047}, "CVE-2024-27045": {"epss_score": 0.00015, "epss_percentile": 0.0253}, "CVE-2024-27046": {"epss_score": 0.00011, "epss_percentile": 0.01011}, "CVE-2024-27047": {"epss_score": 7e-05, "epss_percentile": 0.00375}, "CVE-2024-27048": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-27049": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2024-27050": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2024-27051": {"epss_score": 7e-05, "epss_percentile": 0.00375}, "CVE-2024-27052": {"epss_score": 0.00011, "epss_percentile": 0.01093}, "CVE-2024-27053": {"epss_score": 0.00125, "epss_percentile": 0.32606}, "CVE-2024-27054": {"epss_score": 8e-05, "epss_percentile": 0.0059}, "CVE-2024-27056": {"epss_score": 0.00018, "epss_percentile": 0.03632}, "CVE-2024-27057": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-27058": {"epss_score": 0.00048, "epss_percentile": 0.15162}, "CVE-2024-27059": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-27060": {"epss_score": 0.00021, "epss_percentile": 0.04859}, "CVE-2024-27061": {"epss_score": 0.00022, "epss_percentile": 0.05003}, "CVE-2024-27062": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2024-27063": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-27064": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-27065": {"epss_score": 0.00011, "epss_percentile": 0.00996}, "CVE-2024-27066": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-27067": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-27068": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-27069": {"epss_score": 0.00027, "epss_percentile": 0.07092}, "CVE-2024-27070": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2024-27071": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-27072": {"epss_score": 5e-05, "epss_percentile": 0.00236}, "CVE-2024-27073": {"epss_score": 0.00011, "epss_percentile": 0.01027}, "CVE-2024-27074": {"epss_score": 0.00011, "epss_percentile": 0.00992}, "CVE-2024-27075": {"epss_score": 0.00014, "epss_percentile": 0.02054}, "CVE-2024-27076": {"epss_score": 0.00011, "epss_percentile": 0.01027}, "CVE-2024-27077": {"epss_score": 0.00013, "epss_percentile": 0.01493}, "CVE-2024-27078": {"epss_score": 0.00011, "epss_percentile": 0.00992}, "CVE-2024-27079": {"epss_score": 8e-05, "epss_percentile": 0.0052}, "CVE-2024-27080": {"epss_score": 0.00015, "epss_percentile": 0.0222}, "CVE-2024-27081": {"epss_score": 0.05348, "epss_percentile": 0.89771}, "CVE-2024-27082": {"epss_score": 0.00296, "epss_percentile": 0.52588}, "CVE-2024-27083": {"epss_score": 0.00629, "epss_percentile": 0.69677}, "CVE-2024-27085": {"epss_score": 0.00089, "epss_percentile": 0.25804}, "CVE-2024-27086": {"epss_score": 0.00053, "epss_percentile": 0.16676}, "CVE-2024-27087": {"epss_score": 0.00781, "epss_percentile": 0.73177}, "CVE-2024-27088": {"epss_score": 0.01846, "epss_percentile": 0.82515}, "CVE-2024-27090": {"epss_score": 0.00278, "epss_percentile": 0.50897}, "CVE-2024-27091": {"epss_score": 0.00697, "epss_percentile": 0.714}, "CVE-2024-27092": {"epss_score": 0.00238, "epss_percentile": 0.46772}, "CVE-2024-27093": {"epss_score": 0.00332, "epss_percentile": 0.55555}, "CVE-2024-27094": {"epss_score": 0.00564, "epss_percentile": 0.67745}, "CVE-2024-27095": {"epss_score": 0.0028, "epss_percentile": 0.51064}, "CVE-2024-27096": {"epss_score": 0.00398, "epss_percentile": 0.60073}, "CVE-2024-27097": {"epss_score": 0.00341, "epss_percentile": 0.56315}, "CVE-2024-27098": {"epss_score": 0.00223, "epss_percentile": 0.44857}, "CVE-2024-27099": {"epss_score": 0.01498, "epss_percentile": 0.80696}, "CVE-2024-27100": {"epss_score": 0.00089, "epss_percentile": 0.25804}, "CVE-2024-27101": {"epss_score": 0.00107, "epss_percentile": 0.29617}, "CVE-2024-27102": {"epss_score": 0.00444, "epss_percentile": 0.62815}, "CVE-2024-27103": {"epss_score": 0.00494, "epss_percentile": 0.65094}, "CVE-2024-27104": {"epss_score": 0.00373, "epss_percentile": 0.58494}, "CVE-2024-27105": {"epss_score": 0.00056, "epss_percentile": 0.17695}, "CVE-2024-27106": {"epss_score": 0.00054, "epss_percentile": 0.17131}, "CVE-2024-27107": {"epss_score": 0.00148, "epss_percentile": 0.35828}, "CVE-2024-27108": {"epss_score": 0.00177, "epss_percentile": 0.39506}, "CVE-2024-27109": {"epss_score": 0.0008, "epss_percentile": 0.24109}, "CVE-2024-27110": {"epss_score": 0.00115, "epss_percentile": 0.30995}, "CVE-2024-27112": {"epss_score": 0.00159, "epss_percentile": 0.37406}, "CVE-2024-27113": {"epss_score": 0.00121, "epss_percentile": 0.31939}, "CVE-2024-27114": {"epss_score": 0.01346, "epss_percentile": 0.79642}, "CVE-2024-27115": {"epss_score": 0.77121, "epss_percentile": 0.98922}, "CVE-2024-27120": {"epss_score": 0.01082, "epss_percentile": 0.7738}, "CVE-2024-27121": {"epss_score": 0.00784, "epss_percentile": 0.73242}, "CVE-2024-27122": {"epss_score": 0.00645, "epss_percentile": 0.70107}, "CVE-2024-27124": {"epss_score": 0.00355, "epss_percentile": 0.57295}, "CVE-2024-27125": {"epss_score": 0.00472, "epss_percentile": 0.64071}, "CVE-2024-27126": {"epss_score": 0.00645, "epss_percentile": 0.70107}, "CVE-2024-27127": {"epss_score": 0.00366, "epss_percentile": 0.58059}, "CVE-2024-27128": {"epss_score": 0.00317, "epss_percentile": 0.5434}, "CVE-2024-27129": {"epss_score": 0.00317, "epss_percentile": 0.5434}, "CVE-2024-27130": {"epss_score": 0.80996, "epss_percentile": 0.99115}, "CVE-2024-27132": {"epss_score": 0.00255, "epss_percentile": 0.48721}, "CVE-2024-27133": {"epss_score": 0.00197, "epss_percentile": 0.41845}, "CVE-2024-27134": {"epss_score": 0.00029, "epss_percentile": 0.07603}, "CVE-2024-27135": {"epss_score": 0.00088, "epss_percentile": 0.25784}, "CVE-2024-27136": {"epss_score": 0.32325, "epss_percentile": 0.9669}, "CVE-2024-27137": {"epss_score": 0.00052, "epss_percentile": 0.16516}, "CVE-2024-27138": {"epss_score": 0.00265, "epss_percentile": 0.49841}, "CVE-2024-27139": {"epss_score": 0.00561, "epss_percentile": 0.67669}, "CVE-2024-27140": {"epss_score": 0.03014, "epss_percentile": 0.8621}, "CVE-2024-27141": {"epss_score": 0.00102, "epss_percentile": 0.28745}, "CVE-2024-27142": {"epss_score": 0.00075, "epss_percentile": 0.22961}, "CVE-2024-27143": {"epss_score": 0.0019, "epss_percentile": 0.41123}, "CVE-2024-27144": {"epss_score": 0.01602, "epss_percentile": 0.81271}, "CVE-2024-27145": {"epss_score": 0.00346, "epss_percentile": 0.5663}, "CVE-2024-27146": {"epss_score": 0.00071, "epss_percentile": 0.2207}, "CVE-2024-27147": {"epss_score": 0.00079, "epss_percentile": 0.23862}, "CVE-2024-27148": {"epss_score": 0.0007, "epss_percentile": 0.21942}, "CVE-2024-27149": {"epss_score": 0.0007, "epss_percentile": 0.21942}, "CVE-2024-27150": {"epss_score": 0.0007, "epss_percentile": 0.21942}, "CVE-2024-27151": {"epss_score": 0.00572, "epss_percentile": 0.68033}, "CVE-2024-27152": {"epss_score": 0.0007, "epss_percentile": 0.21942}, "CVE-2024-27153": {"epss_score": 0.0007, "epss_percentile": 0.21942}, "CVE-2024-27154": {"epss_score": 0.00076, "epss_percentile": 0.23168}, "CVE-2024-27155": {"epss_score": 0.00084, "epss_percentile": 0.24931}, "CVE-2024-27156": {"epss_score": 0.00215, "epss_percentile": 0.44121}, "CVE-2024-27157": {"epss_score": 0.00215, "epss_percentile": 0.44121}, "CVE-2024-27158": {"epss_score": 0.00038, "epss_percentile": 0.11073}, "CVE-2024-27159": {"epss_score": 0.00039, "epss_percentile": 0.11614}, "CVE-2024-27160": {"epss_score": 0.00072, "epss_percentile": 0.22322}, "CVE-2024-27161": {"epss_score": 0.00062, "epss_percentile": 0.19609}, "CVE-2024-27162": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-27163": {"epss_score": 0.00094, "epss_percentile": 0.2696}, "CVE-2024-27164": {"epss_score": 0.00072, "epss_percentile": 0.22322}, "CVE-2024-27165": {"epss_score": 0.00066, "epss_percentile": 0.20767}, "CVE-2024-27166": {"epss_score": 0.00032, "epss_percentile": 0.09102}, "CVE-2024-27167": {"epss_score": 0.00069, "epss_percentile": 0.21552}, "CVE-2024-27168": {"epss_score": 0.00028, "epss_percentile": 0.07317}, "CVE-2024-27169": {"epss_score": 0.00029, "epss_percentile": 0.07767}, "CVE-2024-27170": {"epss_score": 0.00069, "epss_percentile": 0.21552}, "CVE-2024-27171": {"epss_score": 0.01695, "epss_percentile": 0.81806}, "CVE-2024-27172": {"epss_score": 0.30575, "epss_percentile": 0.96552}, "CVE-2024-27173": {"epss_score": 0.45418, "epss_percentile": 0.97487}, "CVE-2024-27174": {"epss_score": 0.06245, "epss_percentile": 0.90603}, "CVE-2024-27175": {"epss_score": 0.00197, "epss_percentile": 0.41836}, "CVE-2024-27176": {"epss_score": 0.05937, "epss_percentile": 0.90345}, "CVE-2024-27177": {"epss_score": 0.05937, "epss_percentile": 0.90345}, "CVE-2024-27178": {"epss_score": 0.05937, "epss_percentile": 0.90345}, "CVE-2024-27179": {"epss_score": 0.0003, "epss_percentile": 0.08303}, "CVE-2024-27180": {"epss_score": 0.0001, "epss_percentile": 0.0082}, "CVE-2024-27181": {"epss_score": 0.00336, "epss_percentile": 0.55984}, "CVE-2024-27182": {"epss_score": 0.0023, "epss_percentile": 0.4572}, "CVE-2024-27183": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2024-27184": {"epss_score": 0.00015, "epss_percentile": 0.02588}, "CVE-2024-27185": {"epss_score": 0.0001, "epss_percentile": 0.0082}, "CVE-2024-27186": {"epss_score": 0.00051, "epss_percentile": 0.16174}, "CVE-2024-27187": {"epss_score": 6e-05, "epss_percentile": 0.00288}, "CVE-2024-27188": {"epss_score": 0.00124, "epss_percentile": 0.32425}, "CVE-2024-27189": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-27190": {"epss_score": 0.00504, "epss_percentile": 0.65487}, "CVE-2024-27191": {"epss_score": 0.01009, "epss_percentile": 0.76581}, "CVE-2024-27192": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-27193": {"epss_score": 0.00091, "epss_percentile": 0.26188}, "CVE-2024-27194": {"epss_score": 0.00051, "epss_percentile": 0.16264}, "CVE-2024-27195": {"epss_score": 0.00062, "epss_percentile": 0.19597}, "CVE-2024-27196": {"epss_score": 0.00077, "epss_percentile": 0.2331}, "CVE-2024-27197": {"epss_score": 0.00052, "epss_percentile": 0.16575}, "CVE-2024-27198": {"epss_score": 0.94579, "epss_percentile": 1.0}, "CVE-2024-27199": {"epss_score": 0.94489, "epss_percentile": 0.99999}, "CVE-2024-27200": {"epss_score": 0.00034, "epss_percentile": 0.09671}, "CVE-2024-27201": {"epss_score": 0.00151, "epss_percentile": 0.36232}, "CVE-2024-27202": {"epss_score": 0.00482, "epss_percentile": 0.64548}, "CVE-2024-27204": {"epss_score": 0.00015, "epss_percentile": 0.02513}, "CVE-2024-27205": {"epss_score": 0.00016, "epss_percentile": 0.02635}, "CVE-2024-27206": {"epss_score": 0.00358, "epss_percentile": 0.57511}, "CVE-2024-27207": {"epss_score": 0.00025, "epss_percentile": 0.06276}, "CVE-2024-27208": {"epss_score": 0.00015, "epss_percentile": 0.02513}, "CVE-2024-27209": {"epss_score": 0.00019, "epss_percentile": 0.04144}, "CVE-2024-27210": {"epss_score": 0.00014, "epss_percentile": 0.019}, "CVE-2024-27211": {"epss_score": 0.00016, "epss_percentile": 0.02987}, "CVE-2024-27212": {"epss_score": 0.00016, "epss_percentile": 0.02796}, "CVE-2024-27213": {"epss_score": 0.00366, "epss_percentile": 0.5805}, "CVE-2024-27217": {"epss_score": 0.00107, "epss_percentile": 0.29584}, "CVE-2024-27218": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2024-27219": {"epss_score": 0.00015, "epss_percentile": 0.02513}, "CVE-2024-27220": {"epss_score": 0.00015, "epss_percentile": 0.02513}, "CVE-2024-27221": {"epss_score": 0.00016, "epss_percentile": 0.02796}, "CVE-2024-27222": {"epss_score": 0.00012, "epss_percentile": 0.0126}, "CVE-2024-27223": {"epss_score": 0.00305, "epss_percentile": 0.53392}, "CVE-2024-27224": {"epss_score": 0.00014, "epss_percentile": 0.019}, "CVE-2024-27225": {"epss_score": 0.00018, "epss_percentile": 0.03682}, "CVE-2024-27226": {"epss_score": 0.00015, "epss_percentile": 0.02513}, "CVE-2024-27227": {"epss_score": 0.0007, "epss_percentile": 0.21761}, "CVE-2024-27228": {"epss_score": 0.03317, "epss_percentile": 0.86904}, "CVE-2024-27229": {"epss_score": 0.01487, "epss_percentile": 0.80609}, "CVE-2024-27230": {"epss_score": 0.00019, "epss_percentile": 0.04149}, "CVE-2024-27231": {"epss_score": 0.00021, "epss_percentile": 0.04702}, "CVE-2024-27232": {"epss_score": 0.00014, "epss_percentile": 0.02042}, "CVE-2024-27233": {"epss_score": 4e-05, "epss_percentile": 0.00138}, "CVE-2024-27234": {"epss_score": 0.00021, "epss_percentile": 0.04702}, "CVE-2024-27235": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2024-27236": {"epss_score": 0.00017, "epss_percentile": 0.03267}, "CVE-2024-27237": {"epss_score": 0.00022, "epss_percentile": 0.05266}, "CVE-2024-27238": {"epss_score": 0.00135, "epss_percentile": 0.34046}, "CVE-2024-27239": {"epss_score": 0.00045, "epss_percentile": 0.13967}, "CVE-2024-27240": {"epss_score": 0.00127, "epss_percentile": 0.32818}, "CVE-2024-27241": {"epss_score": 0.00132, "epss_percentile": 0.33596}, "CVE-2024-27242": {"epss_score": 0.00072, "epss_percentile": 0.22294}, "CVE-2024-27243": {"epss_score": 0.00804, "epss_percentile": 0.73624}, "CVE-2024-27244": {"epss_score": 0.00133, "epss_percentile": 0.33628}, "CVE-2024-27245": {"epss_score": 0.00083, "epss_percentile": 0.24707}, "CVE-2024-27246": {"epss_score": 0.00045, "epss_percentile": 0.13967}, "CVE-2024-27247": {"epss_score": 0.00017, "epss_percentile": 0.03234}, "CVE-2024-27254": {"epss_score": 0.0005, "epss_percentile": 0.15667}, "CVE-2024-27255": {"epss_score": 0.00031, "epss_percentile": 0.08534}, "CVE-2024-27256": {"epss_score": 0.00058, "epss_percentile": 0.18434}, "CVE-2024-27257": {"epss_score": 0.00091, "epss_percentile": 0.26224}, "CVE-2024-27260": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2024-27261": {"epss_score": 0.00033, "epss_percentile": 0.09323}, "CVE-2024-27263": {"epss_score": 0.0004, "epss_percentile": 0.11905}, "CVE-2024-27264": {"epss_score": 0.00043, "epss_percentile": 0.13274}, "CVE-2024-27265": {"epss_score": 0.00036, "epss_percentile": 0.10525}, "CVE-2024-27266": {"epss_score": 0.00026, "epss_percentile": 0.06715}, "CVE-2024-27267": {"epss_score": 0.00022, "epss_percentile": 0.05045}, "CVE-2024-27268": {"epss_score": 0.00171, "epss_percentile": 0.38894}, "CVE-2024-27269": {"epss_score": 0.0007, "epss_percentile": 0.21674}, "CVE-2024-27270": {"epss_score": 0.00061, "epss_percentile": 0.19246}, "CVE-2024-27273": {"epss_score": 0.00024, "epss_percentile": 0.05992}, "CVE-2024-27275": {"epss_score": 0.00047, "epss_percentile": 0.14571}, "CVE-2024-27277": {"epss_score": 0.00029, "epss_percentile": 0.07692}, "CVE-2024-27278": {"epss_score": 0.01289, "epss_percentile": 0.79208}, "CVE-2024-27279": {"epss_score": 0.01239, "epss_percentile": 0.78797}, "CVE-2024-27280": {"epss_score": 0.0706, "epss_percentile": 0.91219}, "CVE-2024-27281": {"epss_score": 0.0269, "epss_percentile": 0.85436}, "CVE-2024-27282": {"epss_score": 0.00678, "epss_percentile": 0.70983}, "CVE-2024-27283": {"epss_score": 0.00383, "epss_percentile": 0.59095}, "CVE-2024-27284": {"epss_score": 0.0037, "epss_percentile": 0.58282}, "CVE-2024-27285": {"epss_score": 0.02474, "epss_percentile": 0.84854}, "CVE-2024-27286": {"epss_score": 0.00061, "epss_percentile": 0.19328}, "CVE-2024-27287": {"epss_score": 0.00149, "epss_percentile": 0.35965}, "CVE-2024-27288": {"epss_score": 0.00453, "epss_percentile": 0.63215}, "CVE-2024-27289": {"epss_score": 0.00591, "epss_percentile": 0.6858}, "CVE-2024-27290": {"epss_score": 0.00205, "epss_percentile": 0.42758}, "CVE-2024-27291": {"epss_score": 0.00157, "epss_percentile": 0.37056}, "CVE-2024-27292": {"epss_score": 0.93755, "epss_percentile": 0.9984}, "CVE-2024-27294": {"epss_score": 0.00122, "epss_percentile": 0.32121}, "CVE-2024-27295": {"epss_score": 0.00675, "epss_percentile": 0.70895}, "CVE-2024-27296": {"epss_score": 0.00334, "epss_percentile": 0.55729}, "CVE-2024-27297": {"epss_score": 0.0006, "epss_percentile": 0.19171}, "CVE-2024-27298": {"epss_score": 0.00313, "epss_percentile": 0.54063}, "CVE-2024-27299": {"epss_score": 0.01867, "epss_percentile": 0.82619}, "CVE-2024-27300": {"epss_score": 0.00603, "epss_percentile": 0.68928}, "CVE-2024-27301": {"epss_score": 0.00103, "epss_percentile": 0.29007}, "CVE-2024-27302": {"epss_score": 0.00247, "epss_percentile": 0.47893}, "CVE-2024-27303": {"epss_score": 0.00215, "epss_percentile": 0.44094}, "CVE-2024-27304": {"epss_score": 0.02175, "epss_percentile": 0.83881}, "CVE-2024-27305": {"epss_score": 0.0054, "epss_percentile": 0.67018}, "CVE-2024-27306": {"epss_score": 0.00749, "epss_percentile": 0.72598}, "CVE-2024-27307": {"epss_score": 0.02062, "epss_percentile": 0.83447}, "CVE-2024-27308": {"epss_score": 0.00717, "epss_percentile": 0.71881}, "CVE-2024-27309": {"epss_score": 0.00288, "epss_percentile": 0.51949}, "CVE-2024-27310": {"epss_score": 0.05791, "epss_percentile": 0.90213}, "CVE-2024-27311": {"epss_score": 0.00332, "epss_percentile": 0.55601}, "CVE-2024-27312": {"epss_score": 0.00306, "epss_percentile": 0.53401}, "CVE-2024-27313": {"epss_score": 0.00958, "epss_percentile": 0.75943}, "CVE-2024-27314": {"epss_score": 0.03382, "epss_percentile": 0.87033}, "CVE-2024-27315": {"epss_score": 0.00131, "epss_percentile": 0.33349}, "CVE-2024-27316": {"epss_score": 0.89118, "epss_percentile": 0.99509}, "CVE-2024-27317": {"epss_score": 0.0107, "epss_percentile": 0.77256}, "CVE-2024-27318": {"epss_score": 0.00161, "epss_percentile": 0.37537}, "CVE-2024-27319": {"epss_score": 0.00063, "epss_percentile": 0.20069}, "CVE-2024-27320": {"epss_score": 0.00066, "epss_percentile": 0.20851}, "CVE-2024-27321": {"epss_score": 0.00066, "epss_percentile": 0.20851}, "CVE-2024-27322": {"epss_score": 0.06989, "epss_percentile": 0.91165}, "CVE-2024-27323": {"epss_score": 0.02314, "epss_percentile": 0.84351}, "CVE-2024-27324": {"epss_score": 0.00188, "epss_percentile": 0.4086}, "CVE-2024-27325": {"epss_score": 0.00188, "epss_percentile": 0.4086}, "CVE-2024-27326": {"epss_score": 0.00188, "epss_percentile": 0.4086}, "CVE-2024-27327": {"epss_score": 0.00704, "epss_percentile": 0.71561}, "CVE-2024-27328": {"epss_score": 0.00188, "epss_percentile": 0.4086}, "CVE-2024-27329": {"epss_score": 0.00188, "epss_percentile": 0.4086}, "CVE-2024-27330": {"epss_score": 0.00181, "epss_percentile": 0.40121}, "CVE-2024-27331": {"epss_score": 0.00181, "epss_percentile": 0.40121}, "CVE-2024-27332": {"epss_score": 0.00181, "epss_percentile": 0.40121}, "CVE-2024-27333": {"epss_score": 0.00197, "epss_percentile": 0.4197}, "CVE-2024-27334": {"epss_score": 0.00197, "epss_percentile": 0.4197}, "CVE-2024-27335": {"epss_score": 0.00717, "epss_percentile": 0.71915}, "CVE-2024-27336": {"epss_score": 0.00221, "epss_percentile": 0.44701}, "CVE-2024-27337": {"epss_score": 0.01033, "epss_percentile": 0.76873}, "CVE-2024-27338": {"epss_score": 0.0063, "epss_percentile": 0.69692}, "CVE-2024-27339": {"epss_score": 0.00991, "epss_percentile": 0.76386}, "CVE-2024-27340": {"epss_score": 0.01049, "epss_percentile": 0.77064}, "CVE-2024-27341": {"epss_score": 0.01049, "epss_percentile": 0.77064}, "CVE-2024-27342": {"epss_score": 0.00717, "epss_percentile": 0.71915}, "CVE-2024-27343": {"epss_score": 0.00197, "epss_percentile": 0.4197}, "CVE-2024-27344": {"epss_score": 0.00717, "epss_percentile": 0.71915}, "CVE-2024-27345": {"epss_score": 0.00214, "epss_percentile": 0.43962}, "CVE-2024-27346": {"epss_score": 0.00221, "epss_percentile": 0.44701}, "CVE-2024-27347": {"epss_score": 0.00481, "epss_percentile": 0.64518}, "CVE-2024-27348": {"epss_score": 0.94344, "epss_percentile": 0.99953}, "CVE-2024-27349": {"epss_score": 0.00444, "epss_percentile": 0.62836}, "CVE-2024-27350": {"epss_score": 0.0005, "epss_percentile": 0.15742}, "CVE-2024-27351": {"epss_score": 0.01855, "epss_percentile": 0.82567}, "CVE-2024-27353": {"epss_score": 0.00125, "epss_percentile": 0.32604}, "CVE-2024-27354": {"epss_score": 0.00125, "epss_percentile": 0.32566}, "CVE-2024-27355": {"epss_score": 0.0015, "epss_percentile": 0.36137}, "CVE-2024-27356": {"epss_score": 0.22294, "epss_percentile": 0.95619}, "CVE-2024-27357": {"epss_score": 0.00026, "epss_percentile": 0.06628}, "CVE-2024-27358": {"epss_score": 0.00025, "epss_percentile": 0.06289}, "CVE-2024-27359": {"epss_score": 0.00071, "epss_percentile": 0.22179}, "CVE-2024-27360": {"epss_score": 0.00194, "epss_percentile": 0.41533}, "CVE-2024-27361": {"epss_score": 0.00074, "epss_percentile": 0.2288}, "CVE-2024-27362": {"epss_score": 0.00315, "epss_percentile": 0.54165}, "CVE-2024-27363": {"epss_score": 0.00078, "epss_percentile": 0.23572}, "CVE-2024-27364": {"epss_score": 0.00036, "epss_percentile": 0.10165}, "CVE-2024-27365": {"epss_score": 0.00019, "epss_percentile": 0.04205}, "CVE-2024-27366": {"epss_score": 0.00035, "epss_percentile": 0.09878}, "CVE-2024-27367": {"epss_score": 0.00035, "epss_percentile": 0.09878}, "CVE-2024-27368": {"epss_score": 0.00043, "epss_percentile": 0.12962}, "CVE-2024-27370": {"epss_score": 0.00056, "epss_percentile": 0.17702}, "CVE-2024-27371": {"epss_score": 0.00056, "epss_percentile": 0.17702}, "CVE-2024-27372": {"epss_score": 0.00056, "epss_percentile": 0.17702}, "CVE-2024-27373": {"epss_score": 0.00056, "epss_percentile": 0.17702}, "CVE-2024-27374": {"epss_score": 0.00056, "epss_percentile": 0.17702}, "CVE-2024-27375": {"epss_score": 0.00056, "epss_percentile": 0.17702}, "CVE-2024-27376": {"epss_score": 0.00056, "epss_percentile": 0.17702}, "CVE-2024-27377": {"epss_score": 0.00056, "epss_percentile": 0.17702}, "CVE-2024-27378": {"epss_score": 0.00055, "epss_percentile": 0.17479}, "CVE-2024-27379": {"epss_score": 0.00056, "epss_percentile": 0.17702}, "CVE-2024-27380": {"epss_score": 0.00062, "epss_percentile": 0.19781}, "CVE-2024-27381": {"epss_score": 0.00062, "epss_percentile": 0.19781}, "CVE-2024-27382": {"epss_score": 0.00055, "epss_percentile": 0.17479}, "CVE-2024-27383": {"epss_score": 0.00043, "epss_percentile": 0.13306}, "CVE-2024-27385": {"epss_score": 0.00107, "epss_percentile": 0.29714}, "CVE-2024-27386": {"epss_score": 0.00107, "epss_percentile": 0.29714}, "CVE-2024-27387": {"epss_score": 0.00036, "epss_percentile": 0.10438}, "CVE-2024-27388": {"epss_score": 8e-05, "epss_percentile": 0.00499}, "CVE-2024-27389": {"epss_score": 0.00011, "epss_percentile": 0.01038}, "CVE-2024-27390": {"epss_score": 8e-05, "epss_percentile": 0.0059}, "CVE-2024-27391": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2024-27392": {"epss_score": 0.00043, "epss_percentile": 0.12949}, "CVE-2024-27393": {"epss_score": 7e-05, "epss_percentile": 0.0041}, "CVE-2024-27394": {"epss_score": 0.00023, "epss_percentile": 0.05467}, "CVE-2024-27395": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2024-27396": {"epss_score": 0.00017, "epss_percentile": 0.03338}, "CVE-2024-27397": {"epss_score": 0.00034, "epss_percentile": 0.098}, "CVE-2024-27398": {"epss_score": 0.01405, "epss_percentile": 0.80046}, "CVE-2024-27399": {"epss_score": 0.00081, "epss_percentile": 0.24339}, "CVE-2024-27400": {"epss_score": 7e-05, "epss_percentile": 0.00396}, "CVE-2024-27401": {"epss_score": 0.00092, "epss_percentile": 0.26579}, "CVE-2024-27402": {"epss_score": 0.00017, "epss_percentile": 0.03517}, "CVE-2024-27403": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2024-27404": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-27405": {"epss_score": 0.00148, "epss_percentile": 0.35826}, "CVE-2024-27406": {"epss_score": 0.00045, "epss_percentile": 0.13907}, "CVE-2024-27407": {"epss_score": 0.00017, "epss_percentile": 0.03176}, "CVE-2024-27408": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-27409": {"epss_score": 0.00021, "epss_percentile": 0.04859}, "CVE-2024-27410": {"epss_score": 0.00012, "epss_percentile": 0.01339}, "CVE-2024-27411": {"epss_score": 0.00033, "epss_percentile": 0.09148}, "CVE-2024-27412": {"epss_score": 0.0002, "epss_percentile": 0.04604}, "CVE-2024-27413": {"epss_score": 0.00016, "epss_percentile": 0.02654}, "CVE-2024-27414": {"epss_score": 0.00012, "epss_percentile": 0.01422}, "CVE-2024-27415": {"epss_score": 3e-05, "epss_percentile": 0.00093}, "CVE-2024-27416": {"epss_score": 0.0002, "epss_percentile": 0.04604}, "CVE-2024-27417": {"epss_score": 0.00012, "epss_percentile": 0.01358}, "CVE-2024-27418": {"epss_score": 0.00019, "epss_percentile": 0.04212}, "CVE-2024-27419": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2024-27431": {"epss_score": 0.00015, "epss_percentile": 0.02506}, "CVE-2024-27432": {"epss_score": 0.0003, "epss_percentile": 0.08296}, "CVE-2024-27433": {"epss_score": 0.00029, "epss_percentile": 0.07771}, "CVE-2024-27434": {"epss_score": 0.00015, "epss_percentile": 0.02388}, "CVE-2024-27435": {"epss_score": 0.00023, "epss_percentile": 0.05328}, "CVE-2024-27436": {"epss_score": 0.00097, "epss_percentile": 0.27456}, "CVE-2024-27437": {"epss_score": 0.00013, "epss_percentile": 0.01596}, "CVE-2024-27438": {"epss_score": 0.03445, "epss_percentile": 0.87146}, "CVE-2024-27439": {"epss_score": 0.00434, "epss_percentile": 0.62321}, "CVE-2024-27440": {"epss_score": 0.0011, "epss_percentile": 0.30178}, "CVE-2024-27442": {"epss_score": 0.00038, "epss_percentile": 0.11076}, "CVE-2024-27443": {"epss_score": 0.34676, "epss_percentile": 0.96867}, "CVE-2024-27444": {"epss_score": 0.00125, "epss_percentile": 0.32616}, "CVE-2024-27447": {"epss_score": 0.00199, "epss_percentile": 0.42101}, "CVE-2024-27448": {"epss_score": 0.14084, "epss_percentile": 0.94129}, "CVE-2024-27453": {"epss_score": 0.00291, "epss_percentile": 0.52158}, "CVE-2024-27454": {"epss_score": 0.00104, "epss_percentile": 0.29145}, "CVE-2024-27455": {"epss_score": 0.00095, "epss_percentile": 0.27133}, "CVE-2024-27456": {"epss_score": 0.0013, "epss_percentile": 0.33246}, "CVE-2024-27457": {"epss_score": 0.0003, "epss_percentile": 0.08173}, "CVE-2024-27458": {"epss_score": 0.00046, "epss_percentile": 0.14113}, "CVE-2024-27459": {"epss_score": 0.05418, "epss_percentile": 0.89853}, "CVE-2024-27460": {"epss_score": 0.027, "epss_percentile": 0.8545}, "CVE-2024-27461": {"epss_score": 0.00079, "epss_percentile": 0.23865}, "CVE-2024-27474": {"epss_score": 0.00365, "epss_percentile": 0.57972}, "CVE-2024-27476": {"epss_score": 0.00211, "epss_percentile": 0.43667}, "CVE-2024-27477": {"epss_score": 0.00237, "epss_percentile": 0.46724}, "CVE-2024-27480": {"epss_score": 0.00056, "epss_percentile": 0.17735}, "CVE-2024-27488": {"epss_score": 0.00444, "epss_percentile": 0.62849}, "CVE-2024-27489": {"epss_score": 0.0013, "epss_percentile": 0.33303}, "CVE-2024-27497": {"epss_score": 0.8066, "epss_percentile": 0.99099}, "CVE-2024-27499": {"epss_score": 0.00048, "epss_percentile": 0.15233}, "CVE-2024-27507": {"epss_score": 0.00096, "epss_percentile": 0.27326}, "CVE-2024-27508": {"epss_score": 0.00105, "epss_percentile": 0.29302}, "CVE-2024-27515": {"epss_score": 0.00074, "epss_percentile": 0.22732}, "CVE-2024-27516": {"epss_score": 0.02455, "epss_percentile": 0.84794}, "CVE-2024-27517": {"epss_score": 0.00822, "epss_percentile": 0.73919}, "CVE-2024-27518": {"epss_score": 0.02716, "epss_percentile": 0.85507}, "CVE-2024-27521": {"epss_score": 0.01772, "epss_percentile": 0.82203}, "CVE-2024-27524": {"epss_score": 0.01123, "epss_percentile": 0.77787}, "CVE-2024-27525": {"epss_score": 0.00707, "epss_percentile": 0.71657}, "CVE-2024-27527": {"epss_score": 0.00259, "epss_percentile": 0.49081}, "CVE-2024-27528": {"epss_score": 0.00097, "epss_percentile": 0.27467}, "CVE-2024-27529": {"epss_score": 0.00131, "epss_percentile": 0.33473}, "CVE-2024-27530": {"epss_score": 0.00092, "epss_percentile": 0.26559}, "CVE-2024-27532": {"epss_score": 0.00104, "epss_percentile": 0.29202}, "CVE-2024-27558": {"epss_score": 0.00122, "epss_percentile": 0.32105}, "CVE-2024-27559": {"epss_score": 0.00066, "epss_percentile": 0.2093}, "CVE-2024-27561": {"epss_score": 0.00193, "epss_percentile": 0.41496}, "CVE-2024-27563": {"epss_score": 0.00145, "epss_percentile": 0.35394}, "CVE-2024-27564": {"epss_score": 0.91405, "epss_percentile": 0.9964}, "CVE-2024-27565": {"epss_score": 0.00288, "epss_percentile": 0.51884}, "CVE-2024-27567": {"epss_score": 0.00116, "epss_percentile": 0.31132}, "CVE-2024-27568": {"epss_score": 0.00067, "epss_percentile": 0.21103}, "CVE-2024-27569": {"epss_score": 0.00067, "epss_percentile": 0.21103}, "CVE-2024-27570": {"epss_score": 0.00185, "epss_percentile": 0.40505}, "CVE-2024-27571": {"epss_score": 0.00141, "epss_percentile": 0.34942}, "CVE-2024-27572": {"epss_score": 0.00141, "epss_percentile": 0.34942}, "CVE-2024-27574": {"epss_score": 0.00253, "epss_percentile": 0.48495}, "CVE-2024-27575": {"epss_score": 0.00184, "epss_percentile": 0.40436}, "CVE-2024-27592": {"epss_score": 0.00038, "epss_percentile": 0.11346}, "CVE-2024-27593": {"epss_score": 0.00215, "epss_percentile": 0.44055}, "CVE-2024-27602": {"epss_score": 0.00191, "epss_percentile": 0.41207}, "CVE-2024-27604": {"epss_score": 0.00246, "epss_percentile": 0.4779}, "CVE-2024-27605": {"epss_score": 0.00153, "epss_percentile": 0.36534}, "CVE-2024-27609": {"epss_score": 0.00064, "epss_percentile": 0.20317}, "CVE-2024-27612": {"epss_score": 0.00697, "epss_percentile": 0.71406}, "CVE-2024-27613": {"epss_score": 0.00076, "epss_percentile": 0.23119}, "CVE-2024-27619": {"epss_score": 0.00615, "epss_percentile": 0.69296}, "CVE-2024-27620": {"epss_score": 0.05328, "epss_percentile": 0.89737}, "CVE-2024-27622": {"epss_score": 0.03072, "epss_percentile": 0.8635}, "CVE-2024-27623": {"epss_score": 0.00061, "epss_percentile": 0.19517}, "CVE-2024-27625": {"epss_score": 0.00081, "epss_percentile": 0.24273}, "CVE-2024-27626": {"epss_score": 0.00107, "epss_percentile": 0.29666}, "CVE-2024-27627": {"epss_score": 0.00051, "epss_percentile": 0.16314}, "CVE-2024-27628": {"epss_score": 0.01455, "epss_percentile": 0.80391}, "CVE-2024-27629": {"epss_score": 0.00139, "epss_percentile": 0.34661}, "CVE-2024-27630": {"epss_score": 0.00835, "epss_percentile": 0.74119}, "CVE-2024-27631": {"epss_score": 0.00344, "epss_percentile": 0.56506}, "CVE-2024-27632": {"epss_score": 0.021, "epss_percentile": 0.83597}, "CVE-2024-27655": {"epss_score": 0.02626, "epss_percentile": 0.85265}, "CVE-2024-27656": {"epss_score": 0.02626, "epss_percentile": 0.85265}, "CVE-2024-27657": {"epss_score": 0.02626, "epss_percentile": 0.85265}, "CVE-2024-27658": {"epss_score": 0.00039, "epss_percentile": 0.11473}, "CVE-2024-27659": {"epss_score": 0.0005, "epss_percentile": 0.15978}, "CVE-2024-27660": {"epss_score": 0.00059, "epss_percentile": 0.18708}, "CVE-2024-27661": {"epss_score": 0.0005, "epss_percentile": 0.15978}, "CVE-2024-27662": {"epss_score": 0.0005, "epss_percentile": 0.15978}, "CVE-2024-27665": {"epss_score": 0.00244, "epss_percentile": 0.47515}, "CVE-2024-27668": {"epss_score": 0.0019, "epss_percentile": 0.41066}, "CVE-2024-27674": {"epss_score": 0.00176, "epss_percentile": 0.39393}, "CVE-2024-27680": {"epss_score": 0.00133, "epss_percentile": 0.33733}, "CVE-2024-27683": {"epss_score": 0.00488, "epss_percentile": 0.64829}, "CVE-2024-27684": {"epss_score": 0.00038, "epss_percentile": 0.11167}, "CVE-2024-27685": {"epss_score": 0.00029, "epss_percentile": 0.07859}, "CVE-2024-27689": {"epss_score": 0.00159, "epss_percentile": 0.37387}, "CVE-2024-27694": {"epss_score": 0.00075, "epss_percentile": 0.23033}, "CVE-2024-27703": {"epss_score": 0.00432, "epss_percentile": 0.6213}, "CVE-2024-27705": {"epss_score": 0.00114, "epss_percentile": 0.30806}, "CVE-2024-27706": {"epss_score": 0.00225, "epss_percentile": 0.45141}, "CVE-2024-27707": {"epss_score": 0.00047, "epss_percentile": 0.14767}, "CVE-2024-27708": {"epss_score": 0.00157, "epss_percentile": 0.37075}, "CVE-2024-27709": {"epss_score": 0.00989, "epss_percentile": 0.76366}, "CVE-2024-27710": {"epss_score": 0.00833, "epss_percentile": 0.7408}, "CVE-2024-27711": {"epss_score": 0.00658, "epss_percentile": 0.70486}, "CVE-2024-27712": {"epss_score": 0.00833, "epss_percentile": 0.7408}, "CVE-2024-27713": {"epss_score": 0.00803, "epss_percentile": 0.73598}, "CVE-2024-27715": {"epss_score": 0.00159, "epss_percentile": 0.3734}, "CVE-2024-27716": {"epss_score": 0.0023, "epss_percentile": 0.4568}, "CVE-2024-27717": {"epss_score": 0.00126, "epss_percentile": 0.32753}, "CVE-2024-27718": {"epss_score": 0.06313, "epss_percentile": 0.90666}, "CVE-2024-27719": {"epss_score": 0.00112, "epss_percentile": 0.30522}, "CVE-2024-27728": {"epss_score": 0.00233, "epss_percentile": 0.46032}, "CVE-2024-27729": {"epss_score": 0.00218, "epss_percentile": 0.44395}, "CVE-2024-27730": {"epss_score": 0.05586, "epss_percentile": 0.90025}, "CVE-2024-27731": {"epss_score": 0.00227, "epss_percentile": 0.45446}, "CVE-2024-27733": {"epss_score": 0.00028, "epss_percentile": 0.07531}, "CVE-2024-27734": {"epss_score": 0.00101, "epss_percentile": 0.28585}, "CVE-2024-27743": {"epss_score": 0.02623, "epss_percentile": 0.85259}, "CVE-2024-27744": {"epss_score": 0.03521, "epss_percentile": 0.87287}, "CVE-2024-27746": {"epss_score": 0.00742, "epss_percentile": 0.72462}, "CVE-2024-27747": {"epss_score": 0.15022, "epss_percentile": 0.94346}, "CVE-2024-27752": {"epss_score": 0.00424, "epss_percentile": 0.61663}, "CVE-2024-27756": {"epss_score": 0.00113, "epss_percentile": 0.30705}, "CVE-2024-27757": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2024-27758": {"epss_score": 0.03141, "epss_percentile": 0.86487}, "CVE-2024-27763": {"epss_score": 0.00145, "epss_percentile": 0.35382}, "CVE-2024-27764": {"epss_score": 0.01783, "epss_percentile": 0.82246}, "CVE-2024-27765": {"epss_score": 0.00343, "epss_percentile": 0.56474}, "CVE-2024-27766": {"epss_score": 0.24551, "epss_percentile": 0.95932}, "CVE-2024-27767": {"epss_score": 0.00044, "epss_percentile": 0.1363}, "CVE-2024-27768": {"epss_score": 0.00149, "epss_percentile": 0.35979}, "CVE-2024-27769": {"epss_score": 0.00098, "epss_percentile": 0.27784}, "CVE-2024-27770": {"epss_score": 0.00149, "epss_percentile": 0.35993}, "CVE-2024-27771": {"epss_score": 0.00162, "epss_percentile": 0.37701}, "CVE-2024-27772": {"epss_score": 0.00695, "epss_percentile": 0.71369}, "CVE-2024-27773": {"epss_score": 0.00082, "epss_percentile": 0.24588}, "CVE-2024-27774": {"epss_score": 0.00067, "epss_percentile": 0.21105}, "CVE-2024-27775": {"epss_score": 0.00132, "epss_percentile": 0.33579}, "CVE-2024-27776": {"epss_score": 0.00572, "epss_percentile": 0.68004}, "CVE-2024-27778": {"epss_score": 0.00324, "epss_percentile": 0.54948}, "CVE-2024-27779": {"epss_score": 0.00098, "epss_percentile": 0.27814}, "CVE-2024-27780": {"epss_score": 0.00056, "epss_percentile": 0.17851}, "CVE-2024-27781": {"epss_score": 0.00274, "epss_percentile": 0.50532}, "CVE-2024-27782": {"epss_score": 0.00739, "epss_percentile": 0.72391}, "CVE-2024-27783": {"epss_score": 0.01062, "epss_percentile": 0.77185}, "CVE-2024-27784": {"epss_score": 0.00592, "epss_percentile": 0.68623}, "CVE-2024-27785": {"epss_score": 0.00639, "epss_percentile": 0.69945}, "CVE-2024-27789": {"epss_score": 0.00083, "epss_percentile": 0.24723}, "CVE-2024-27790": {"epss_score": 0.00388, "epss_percentile": 0.59352}, "CVE-2024-27791": {"epss_score": 0.00024, "epss_percentile": 0.06027}, "CVE-2024-27792": {"epss_score": 0.00095, "epss_percentile": 0.27094}, "CVE-2024-27793": {"epss_score": 0.00442, "epss_percentile": 0.6272}, "CVE-2024-27794": {"epss_score": 0.00681, "epss_percentile": 0.71043}, "CVE-2024-27795": {"epss_score": 0.00112, "epss_percentile": 0.30503}, "CVE-2024-27796": {"epss_score": 0.00031, "epss_percentile": 0.08339}, "CVE-2024-27798": {"epss_score": 0.00035, "epss_percentile": 0.09921}, "CVE-2024-27799": {"epss_score": 0.00037, "epss_percentile": 0.10773}, "CVE-2024-27800": {"epss_score": 0.00103, "epss_percentile": 0.2906}, "CVE-2024-27801": {"epss_score": 0.00096, "epss_percentile": 0.27447}, "CVE-2024-27802": {"epss_score": 0.00049, "epss_percentile": 0.15507}, "CVE-2024-27803": {"epss_score": 0.00034, "epss_percentile": 0.09755}, "CVE-2024-27804": {"epss_score": 0.04709, "epss_percentile": 0.89036}, "CVE-2024-27805": {"epss_score": 0.00037, "epss_percentile": 0.10735}, "CVE-2024-27806": {"epss_score": 0.00037, "epss_percentile": 0.10735}, "CVE-2024-27807": {"epss_score": 0.001, "epss_percentile": 0.28523}, "CVE-2024-27808": {"epss_score": 0.01092, "epss_percentile": 0.77463}, "CVE-2024-27809": {"epss_score": 0.0004, "epss_percentile": 0.11909}, "CVE-2024-27810": {"epss_score": 0.00107, "epss_percentile": 0.29583}, "CVE-2024-27811": {"epss_score": 0.00159, "epss_percentile": 0.3738}, "CVE-2024-27812": {"epss_score": 0.00259, "epss_percentile": 0.49088}, "CVE-2024-27813": {"epss_score": 0.00065, "epss_percentile": 0.20531}, "CVE-2024-27814": {"epss_score": 0.00108, "epss_percentile": 0.29862}, "CVE-2024-27815": {"epss_score": 0.24302, "epss_percentile": 0.95901}, "CVE-2024-27816": {"epss_score": 0.00043, "epss_percentile": 0.12954}, "CVE-2024-27817": {"epss_score": 0.00125, "epss_percentile": 0.32475}, "CVE-2024-27818": {"epss_score": 0.00063, "epss_percentile": 0.19837}, "CVE-2024-27819": {"epss_score": 0.00102, "epss_percentile": 0.28827}, "CVE-2024-27820": {"epss_score": 0.01181, "epss_percentile": 0.7831}, "CVE-2024-27821": {"epss_score": 0.04095, "epss_percentile": 0.88248}, "CVE-2024-27822": {"epss_score": 0.00088, "epss_percentile": 0.25713}, "CVE-2024-27823": {"epss_score": 0.00266, "epss_percentile": 0.49942}, "CVE-2024-27824": {"epss_score": 0.00061, "epss_percentile": 0.19503}, "CVE-2024-27825": {"epss_score": 0.0003, "epss_percentile": 0.0821}, "CVE-2024-27826": {"epss_score": 0.0007, "epss_percentile": 0.21713}, "CVE-2024-27827": {"epss_score": 0.00096, "epss_percentile": 0.27337}, "CVE-2024-27828": {"epss_score": 0.00077, "epss_percentile": 0.23321}, "CVE-2024-27829": {"epss_score": 0.00368, "epss_percentile": 0.58193}, "CVE-2024-27830": {"epss_score": 0.0111, "epss_percentile": 0.77655}, "CVE-2024-27831": {"epss_score": 0.00075, "epss_percentile": 0.2299}, "CVE-2024-27832": {"epss_score": 0.00196, "epss_percentile": 0.41821}, "CVE-2024-27833": {"epss_score": 0.01652, "epss_percentile": 0.81577}, "CVE-2024-27834": {"epss_score": 7e-05, "epss_percentile": 0.00361}, "CVE-2024-27835": {"epss_score": 0.00149, "epss_percentile": 0.35941}, "CVE-2024-27836": {"epss_score": 0.00169, "epss_percentile": 0.38644}, "CVE-2024-27837": {"epss_score": 0.0012, "epss_percentile": 0.31734}, "CVE-2024-27838": {"epss_score": 0.01221, "epss_percentile": 0.78645}, "CVE-2024-27839": {"epss_score": 0.00098, "epss_percentile": 0.27822}, "CVE-2024-27840": {"epss_score": 0.0002, "epss_percentile": 0.04515}, "CVE-2024-27841": {"epss_score": 0.00167, "epss_percentile": 0.3832}, "CVE-2024-27842": {"epss_score": 0.00244, "epss_percentile": 0.47564}, "CVE-2024-27843": {"epss_score": 0.00073, "epss_percentile": 0.22542}, "CVE-2024-27844": {"epss_score": 0.00148, "epss_percentile": 0.35847}, "CVE-2024-27845": {"epss_score": 0.001, "epss_percentile": 0.2849}, "CVE-2024-27847": {"epss_score": 0.00014, "epss_percentile": 0.01993}, "CVE-2024-27848": {"epss_score": 0.0009, "epss_percentile": 0.25992}, "CVE-2024-27849": {"epss_score": 0.00178, "epss_percentile": 0.39711}, "CVE-2024-27850": {"epss_score": 0.00673, "epss_percentile": 0.70837}, "CVE-2024-27851": {"epss_score": 0.01181, "epss_percentile": 0.7831}, "CVE-2024-27852": {"epss_score": 0.00264, "epss_percentile": 0.49573}, "CVE-2024-27853": {"epss_score": 0.00013, "epss_percentile": 0.01499}, "CVE-2024-27855": {"epss_score": 0.00352, "epss_percentile": 0.57125}, "CVE-2024-27856": {"epss_score": 0.00062, "epss_percentile": 0.19707}, "CVE-2024-27857": {"epss_score": 0.01584, "epss_percentile": 0.81161}, "CVE-2024-27858": {"epss_score": 0.00031, "epss_percentile": 0.08551}, "CVE-2024-27859": {"epss_score": 0.00294, "epss_percentile": 0.5244}, "CVE-2024-27860": {"epss_score": 0.00051, "epss_percentile": 0.16142}, "CVE-2024-27861": {"epss_score": 0.00049, "epss_percentile": 0.15293}, "CVE-2024-27862": {"epss_score": 0.0014, "epss_percentile": 0.3471}, "CVE-2024-27863": {"epss_score": 0.00028, "epss_percentile": 0.07512}, "CVE-2024-27867": {"epss_score": 0.00064, "epss_percentile": 0.20131}, "CVE-2024-27869": {"epss_score": 0.00134, "epss_percentile": 0.33901}, "CVE-2024-27871": {"epss_score": 0.00029, "epss_percentile": 0.07907}, "CVE-2024-27872": {"epss_score": 0.00061, "epss_percentile": 0.19542}, "CVE-2024-27873": {"epss_score": 0.00019, "epss_percentile": 0.0435}, "CVE-2024-27874": {"epss_score": 0.00189, "epss_percentile": 0.40937}, "CVE-2024-27875": {"epss_score": 0.00047, "epss_percentile": 0.14908}, "CVE-2024-27876": {"epss_score": 0.00039, "epss_percentile": 0.11627}, "CVE-2024-27877": {"epss_score": 0.00027, "epss_percentile": 0.06831}, "CVE-2024-27878": {"epss_score": 0.00273, "epss_percentile": 0.50431}, "CVE-2024-27879": {"epss_score": 0.00164, "epss_percentile": 0.37953}, "CVE-2024-27880": {"epss_score": 0.00018, "epss_percentile": 0.04016}, "CVE-2024-27881": {"epss_score": 0.00275, "epss_percentile": 0.50666}, "CVE-2024-27882": {"epss_score": 0.00023, "epss_percentile": 0.05327}, "CVE-2024-27883": {"epss_score": 0.00018, "epss_percentile": 0.03879}, "CVE-2024-27884": {"epss_score": 0.00029, "epss_percentile": 0.07698}, "CVE-2024-27885": {"epss_score": 0.00038, "epss_percentile": 0.1141}, "CVE-2024-27886": {"epss_score": 0.00036, "epss_percentile": 0.10163}, "CVE-2024-27887": {"epss_score": 0.0004, "epss_percentile": 0.11881}, "CVE-2024-27888": {"epss_score": 0.00025, "epss_percentile": 0.06249}, "CVE-2024-27889": {"epss_score": 0.00204, "epss_percentile": 0.42608}, "CVE-2024-27894": {"epss_score": 0.00314, "epss_percentile": 0.54154}, "CVE-2024-27895": {"epss_score": 0.00069, "epss_percentile": 0.21533}, "CVE-2024-27896": {"epss_score": 0.00057, "epss_percentile": 0.18226}, "CVE-2024-27897": {"epss_score": 0.00081, "epss_percentile": 0.24227}, "CVE-2024-27898": {"epss_score": 0.0022, "epss_percentile": 0.44617}, "CVE-2024-27899": {"epss_score": 0.0012, "epss_percentile": 0.31724}, "CVE-2024-27900": {"epss_score": 0.00121, "epss_percentile": 0.31922}, "CVE-2024-27901": {"epss_score": 0.00219, "epss_percentile": 0.44513}, "CVE-2024-27902": {"epss_score": 0.00597, "epss_percentile": 0.6875}, "CVE-2024-27903": {"epss_score": 0.06993, "epss_percentile": 0.91169}, "CVE-2024-27905": {"epss_score": 0.03016, "epss_percentile": 0.86214}, "CVE-2024-27906": {"epss_score": 0.00051, "epss_percentile": 0.16151}, "CVE-2024-27907": {"epss_score": 0.00142, "epss_percentile": 0.35016}, "CVE-2024-27908": {"epss_score": 0.00053, "epss_percentile": 0.17037}, "CVE-2024-27909": {"epss_score": 0.00049, "epss_percentile": 0.1532}, "CVE-2024-27910": {"epss_score": 0.00059, "epss_percentile": 0.18848}, "CVE-2024-27911": {"epss_score": 0.0014, "epss_percentile": 0.34694}, "CVE-2024-27912": {"epss_score": 0.00069, "epss_percentile": 0.21441}, "CVE-2024-27913": {"epss_score": 0.00078, "epss_percentile": 0.23647}, "CVE-2024-27914": {"epss_score": 0.02658, "epss_percentile": 0.85361}, "CVE-2024-27915": {"epss_score": 0.00155, "epss_percentile": 0.36797}, "CVE-2024-27916": {"epss_score": 0.00177, "epss_percentile": 0.3962}, "CVE-2024-27917": {"epss_score": 0.00116, "epss_percentile": 0.31167}, "CVE-2024-27918": {"epss_score": 0.00224, "epss_percentile": 0.45023}, "CVE-2024-27919": {"epss_score": 0.19053, "epss_percentile": 0.95118}, "CVE-2024-27920": {"epss_score": 0.00412, "epss_percentile": 0.60919}, "CVE-2024-27921": {"epss_score": 0.06073, "epss_percentile": 0.90454}, "CVE-2024-27922": {"epss_score": 0.00539, "epss_percentile": 0.66976}, "CVE-2024-27923": {"epss_score": 0.07188, "epss_percentile": 0.91309}, "CVE-2024-27926": {"epss_score": 0.01003, "epss_percentile": 0.76518}, "CVE-2024-27927": {"epss_score": 0.01054, "epss_percentile": 0.7711}, "CVE-2024-27929": {"epss_score": 0.00074, "epss_percentile": 0.22769}, "CVE-2024-27930": {"epss_score": 0.00657, "epss_percentile": 0.70459}, "CVE-2024-27931": {"epss_score": 0.00226, "epss_percentile": 0.45272}, "CVE-2024-27932": {"epss_score": 0.00609, "epss_percentile": 0.69134}, "CVE-2024-27933": {"epss_score": 0.00016, "epss_percentile": 0.0294}, "CVE-2024-27934": {"epss_score": 0.00275, "epss_percentile": 0.50655}, "CVE-2024-27935": {"epss_score": 0.00303, "epss_percentile": 0.53185}, "CVE-2024-27936": {"epss_score": 0.0044, "epss_percentile": 0.62625}, "CVE-2024-27937": {"epss_score": 0.00767, "epss_percentile": 0.72952}, "CVE-2024-27938": {"epss_score": 0.00633, "epss_percentile": 0.69754}, "CVE-2024-27939": {"epss_score": 0.0104, "epss_percentile": 0.7696}, "CVE-2024-27940": {"epss_score": 0.01303, "epss_percentile": 0.7931}, "CVE-2024-27941": {"epss_score": 0.01749, "epss_percentile": 0.82087}, "CVE-2024-27942": {"epss_score": 0.00428, "epss_percentile": 0.61929}, "CVE-2024-27943": {"epss_score": 0.02608, "epss_percentile": 0.8523}, "CVE-2024-27944": {"epss_score": 0.02408, "epss_percentile": 0.84657}, "CVE-2024-27945": {"epss_score": 0.02408, "epss_percentile": 0.84657}, "CVE-2024-27946": {"epss_score": 0.0035, "epss_percentile": 0.56918}, "CVE-2024-27947": {"epss_score": 0.00412, "epss_percentile": 0.60929}, "CVE-2024-27948": {"epss_score": 0.00078, "epss_percentile": 0.23733}, "CVE-2024-27949": {"epss_score": 0.00106, "epss_percentile": 0.29473}, "CVE-2024-27950": {"epss_score": 0.00153, "epss_percentile": 0.36513}, "CVE-2024-27951": {"epss_score": 0.00525, "epss_percentile": 0.66373}, "CVE-2024-27952": {"epss_score": 0.00269, "epss_percentile": 0.50181}, "CVE-2024-27953": {"epss_score": 0.00107, "epss_percentile": 0.2975}, "CVE-2024-27954": {"epss_score": 0.92972, "epss_percentile": 0.99764}, "CVE-2024-27955": {"epss_score": 0.00441, "epss_percentile": 0.62658}, "CVE-2024-27956": {"epss_score": 0.93586, "epss_percentile": 0.99821}, "CVE-2024-27957": {"epss_score": 0.00514, "epss_percentile": 0.65941}, "CVE-2024-27958": {"epss_score": 0.00153, "epss_percentile": 0.36543}, "CVE-2024-27959": {"epss_score": 0.0011, "epss_percentile": 0.30102}, "CVE-2024-27960": {"epss_score": 0.00083, "epss_percentile": 0.24792}, "CVE-2024-27961": {"epss_score": 0.00071, "epss_percentile": 0.22206}, "CVE-2024-27962": {"epss_score": 0.00196, "epss_percentile": 0.41801}, "CVE-2024-27963": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-27964": {"epss_score": 0.00772, "epss_percentile": 0.73033}, "CVE-2024-27965": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2024-27966": {"epss_score": 0.00124, "epss_percentile": 0.32425}, "CVE-2024-27967": {"epss_score": 0.00155, "epss_percentile": 0.36792}, "CVE-2024-27968": {"epss_score": 0.00154, "epss_percentile": 0.36752}, "CVE-2024-27969": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-27970": {"epss_score": 0.00172, "epss_percentile": 0.39005}, "CVE-2024-27971": {"epss_score": 0.50377, "epss_percentile": 0.97734}, "CVE-2024-27972": {"epss_score": 0.48975, "epss_percentile": 0.9766}, "CVE-2024-27974": {"epss_score": 0.00239, "epss_percentile": 0.46897}, "CVE-2024-27975": {"epss_score": 0.027, "epss_percentile": 0.85452}, "CVE-2024-27976": {"epss_score": 0.04892, "epss_percentile": 0.89266}, "CVE-2024-27977": {"epss_score": 0.03014, "epss_percentile": 0.86206}, "CVE-2024-27978": {"epss_score": 0.01759, "epss_percentile": 0.82142}, "CVE-2024-27980": {"epss_score": 0.00272, "epss_percentile": 0.50354}, "CVE-2024-27981": {"epss_score": 0.00707, "epss_percentile": 0.71644}, "CVE-2024-27982": {"epss_score": 0.00391, "epss_percentile": 0.59578}, "CVE-2024-27983": {"epss_score": 0.72669, "epss_percentile": 0.98721}, "CVE-2024-27984": {"epss_score": 0.0138, "epss_percentile": 0.79865}, "CVE-2024-27985": {"epss_score": 0.00444, "epss_percentile": 0.62813}, "CVE-2024-27986": {"epss_score": 0.00058, "epss_percentile": 0.18472}, "CVE-2024-27987": {"epss_score": 0.00077, "epss_percentile": 0.2331}, "CVE-2024-27988": {"epss_score": 0.00185, "epss_percentile": 0.4048}, "CVE-2024-27989": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-27990": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-27991": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-27992": {"epss_score": 0.00236, "epss_percentile": 0.46446}, "CVE-2024-27993": {"epss_score": 0.00188, "epss_percentile": 0.40901}, "CVE-2024-27994": {"epss_score": 0.00332, "epss_percentile": 0.55572}, "CVE-2024-27995": {"epss_score": 0.00111, "epss_percentile": 0.30289}, "CVE-2024-27996": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2024-27997": {"epss_score": 0.00059, "epss_percentile": 0.18704}, "CVE-2024-27998": {"epss_score": 0.00117, "epss_percentile": 0.31379}, "CVE-2024-27999": {"epss_score": 0.00157, "epss_percentile": 0.37082}, "CVE-2024-28000": {"epss_score": 0.88847, "epss_percentile": 0.99494}, "CVE-2024-28001": {"epss_score": 0.00144, "epss_percentile": 0.35232}, "CVE-2024-28002": {"epss_score": 0.00144, "epss_percentile": 0.35232}, "CVE-2024-28003": {"epss_score": 0.0019, "epss_percentile": 0.41118}, "CVE-2024-28004": {"epss_score": 0.00105, "epss_percentile": 0.29326}, "CVE-2024-28005": {"epss_score": 0.00407, "epss_percentile": 0.60589}, "CVE-2024-28006": {"epss_score": 0.00303, "epss_percentile": 0.5322}, "CVE-2024-28007": {"epss_score": 0.00429, "epss_percentile": 0.62}, "CVE-2024-28008": {"epss_score": 0.00425, "epss_percentile": 0.61719}, "CVE-2024-28009": {"epss_score": 0.00429, "epss_percentile": 0.62}, "CVE-2024-28010": {"epss_score": 0.00401, "epss_percentile": 0.60256}, "CVE-2024-28011": {"epss_score": 0.00425, "epss_percentile": 0.61719}, "CVE-2024-28012": {"epss_score": 0.00429, "epss_percentile": 0.62}, "CVE-2024-28013": {"epss_score": 0.00277, "epss_percentile": 0.5079}, "CVE-2024-28014": {"epss_score": 0.00596, "epss_percentile": 0.68706}, "CVE-2024-28015": {"epss_score": 0.00794, "epss_percentile": 0.73438}, "CVE-2024-28016": {"epss_score": 0.00135, "epss_percentile": 0.33967}, "CVE-2024-28020": {"epss_score": 0.00242, "epss_percentile": 0.47392}, "CVE-2024-28021": {"epss_score": 0.00182, "epss_percentile": 0.4024}, "CVE-2024-28022": {"epss_score": 0.00117, "epss_percentile": 0.31217}, "CVE-2024-28023": {"epss_score": 0.00016, "epss_percentile": 0.02923}, "CVE-2024-28024": {"epss_score": 0.0002, "epss_percentile": 0.04434}, "CVE-2024-28025": {"epss_score": 0.0014, "epss_percentile": 0.3472}, "CVE-2024-28026": {"epss_score": 0.00173, "epss_percentile": 0.39087}, "CVE-2024-28027": {"epss_score": 0.0014, "epss_percentile": 0.3472}, "CVE-2024-28028": {"epss_score": 0.00057, "epss_percentile": 0.18167}, "CVE-2024-28029": {"epss_score": 0.00023, "epss_percentile": 0.05508}, "CVE-2024-28030": {"epss_score": 0.00042, "epss_percentile": 0.12561}, "CVE-2024-28033": {"epss_score": 0.00561, "epss_percentile": 0.67678}, "CVE-2024-28034": {"epss_score": 0.00176, "epss_percentile": 0.39467}, "CVE-2024-28036": {"epss_score": 0.00019, "epss_percentile": 0.04272}, "CVE-2024-28038": {"epss_score": 0.0028, "epss_percentile": 0.51099}, "CVE-2024-28039": {"epss_score": 0.00122, "epss_percentile": 0.32025}, "CVE-2024-28040": {"epss_score": 0.01185, "epss_percentile": 0.78342}, "CVE-2024-28041": {"epss_score": 0.00095, "epss_percentile": 0.27181}, "CVE-2024-28042": {"epss_score": 0.00135, "epss_percentile": 0.33972}, "CVE-2024-28044": {"epss_score": 0.00067, "epss_percentile": 0.21053}, "CVE-2024-28045": {"epss_score": 0.00145, "epss_percentile": 0.35351}, "CVE-2024-28046": {"epss_score": 0.00154, "epss_percentile": 0.36668}, "CVE-2024-28047": {"epss_score": 0.0003, "epss_percentile": 0.08248}, "CVE-2024-28048": {"epss_score": 0.00852, "epss_percentile": 0.74423}, "CVE-2024-28049": {"epss_score": 0.00054, "epss_percentile": 0.17153}, "CVE-2024-28050": {"epss_score": 0.00104, "epss_percentile": 0.29213}, "CVE-2024-28051": {"epss_score": 0.00049, "epss_percentile": 0.1538}, "CVE-2024-28052": {"epss_score": 0.00227, "epss_percentile": 0.45435}, "CVE-2024-28053": {"epss_score": 0.00056, "epss_percentile": 0.17831}, "CVE-2024-28054": {"epss_score": 0.00262, "epss_percentile": 0.49387}, "CVE-2024-28056": {"epss_score": 0.00614, "epss_percentile": 0.69265}, "CVE-2024-28058": {"epss_score": 0.00172, "epss_percentile": 0.38908}, "CVE-2024-28060": {"epss_score": 0.00121, "epss_percentile": 0.31917}, "CVE-2024-28061": {"epss_score": 0.00072, "epss_percentile": 0.22453}, "CVE-2024-28063": {"epss_score": 0.00218, "epss_percentile": 0.44353}, "CVE-2024-28064": {"epss_score": 0.01559, "epss_percentile": 0.81035}, "CVE-2024-28065": {"epss_score": 0.00045, "epss_percentile": 0.13719}, "CVE-2024-28066": {"epss_score": 0.00045, "epss_percentile": 0.14003}, "CVE-2024-28067": {"epss_score": 0.00553, "epss_percentile": 0.67405}, "CVE-2024-28068": {"epss_score": 0.00221, "epss_percentile": 0.44642}, "CVE-2024-28069": {"epss_score": 0.00526, "epss_percentile": 0.6643}, "CVE-2024-28070": {"epss_score": 0.00301, "epss_percentile": 0.52999}, "CVE-2024-28072": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2024-28073": {"epss_score": 0.00301, "epss_percentile": 0.53045}, "CVE-2024-28074": {"epss_score": 0.00105, "epss_percentile": 0.29396}, "CVE-2024-28075": {"epss_score": 0.73557, "epss_percentile": 0.98761}, "CVE-2024-28076": {"epss_score": 0.00027, "epss_percentile": 0.0678}, "CVE-2024-28077": {"epss_score": 0.00165, "epss_percentile": 0.38139}, "CVE-2024-28084": {"epss_score": 0.00183, "epss_percentile": 0.40364}, "CVE-2024-28085": {"epss_score": 0.12741, "epss_percentile": 0.93763}, "CVE-2024-28087": {"epss_score": 0.00067, "epss_percentile": 0.21023}, "CVE-2024-28088": {"epss_score": 0.1069, "epss_percentile": 0.93071}, "CVE-2024-28089": {"epss_score": 0.0004, "epss_percentile": 0.11927}, "CVE-2024-28090": {"epss_score": 0.0052, "epss_percentile": 0.6621}, "CVE-2024-28091": {"epss_score": 0.00128, "epss_percentile": 0.32969}, "CVE-2024-28092": {"epss_score": 0.00069, "epss_percentile": 0.21561}, "CVE-2024-28093": {"epss_score": 0.00106, "epss_percentile": 0.29414}, "CVE-2024-28094": {"epss_score": 0.00086, "epss_percentile": 0.2536}, "CVE-2024-28095": {"epss_score": 0.00115, "epss_percentile": 0.30989}, "CVE-2024-28096": {"epss_score": 0.00115, "epss_percentile": 0.30989}, "CVE-2024-28097": {"epss_score": 0.00115, "epss_percentile": 0.30989}, "CVE-2024-28098": {"epss_score": 0.00177, "epss_percentile": 0.39541}, "CVE-2024-28099": {"epss_score": 0.00106, "epss_percentile": 0.2954}, "CVE-2024-28100": {"epss_score": 0.00284, "epss_percentile": 0.51487}, "CVE-2024-28101": {"epss_score": 0.00293, "epss_percentile": 0.52342}, "CVE-2024-28102": {"epss_score": 0.00195, "epss_percentile": 0.41671}, "CVE-2024-28103": {"epss_score": 0.00832, "epss_percentile": 0.74071}, "CVE-2024-28105": {"epss_score": 0.04074, "epss_percentile": 0.88209}, "CVE-2024-28106": {"epss_score": 0.00157, "epss_percentile": 0.37077}, "CVE-2024-28107": {"epss_score": 0.00611, "epss_percentile": 0.69188}, "CVE-2024-28108": {"epss_score": 0.00628, "epss_percentile": 0.69666}, "CVE-2024-28109": {"epss_score": 0.02236, "epss_percentile": 0.84101}, "CVE-2024-28110": {"epss_score": 0.00137, "epss_percentile": 0.34223}, "CVE-2024-28111": {"epss_score": 0.00575, "epss_percentile": 0.68115}, "CVE-2024-28112": {"epss_score": 0.00318, "epss_percentile": 0.5443}, "CVE-2024-28113": {"epss_score": 0.00126, "epss_percentile": 0.32646}, "CVE-2024-28114": {"epss_score": 0.00532, "epss_percentile": 0.66675}, "CVE-2024-28115": {"epss_score": 0.00042, "epss_percentile": 0.12912}, "CVE-2024-28116": {"epss_score": 0.56968, "epss_percentile": 0.98042}, "CVE-2024-28117": {"epss_score": 0.0063, "epss_percentile": 0.69698}, "CVE-2024-28118": {"epss_score": 0.00601, "epss_percentile": 0.68844}, "CVE-2024-28119": {"epss_score": 0.01828, "epss_percentile": 0.8244}, "CVE-2024-28120": {"epss_score": 0.00219, "epss_percentile": 0.44487}, "CVE-2024-28121": {"epss_score": 0.01404, "epss_percentile": 0.80036}, "CVE-2024-28122": {"epss_score": 0.0015, "epss_percentile": 0.36139}, "CVE-2024-28123": {"epss_score": 0.00312, "epss_percentile": 0.53944}, "CVE-2024-28125": {"epss_score": 0.0051, "epss_percentile": 0.65797}, "CVE-2024-28126": {"epss_score": 0.00189, "epss_percentile": 0.40954}, "CVE-2024-28127": {"epss_score": 0.00029, "epss_percentile": 0.07651}, "CVE-2024-28128": {"epss_score": 0.00266, "epss_percentile": 0.49898}, "CVE-2024-28130": {"epss_score": 0.00117, "epss_percentile": 0.31364}, "CVE-2024-28131": {"epss_score": 0.0006, "epss_percentile": 0.19107}, "CVE-2024-28132": {"epss_score": 0.00052, "epss_percentile": 0.1636}, "CVE-2024-28133": {"epss_score": 0.00083, "epss_percentile": 0.24596}, "CVE-2024-28134": {"epss_score": 0.0066, "epss_percentile": 0.70535}, "CVE-2024-28135": {"epss_score": 0.00985, "epss_percentile": 0.76326}, "CVE-2024-28136": {"epss_score": 0.00271, "epss_percentile": 0.50314}, "CVE-2024-28137": {"epss_score": 0.00067, "epss_percentile": 0.21052}, "CVE-2024-28138": {"epss_score": 0.00958, "epss_percentile": 0.75947}, "CVE-2024-28139": {"epss_score": 0.00464, "epss_percentile": 0.6373}, "CVE-2024-28140": {"epss_score": 0.00054, "epss_percentile": 0.173}, "CVE-2024-28141": {"epss_score": 0.00053, "epss_percentile": 0.1694}, "CVE-2024-28142": {"epss_score": 0.00098, "epss_percentile": 0.27789}, "CVE-2024-28143": {"epss_score": 0.00038, "epss_percentile": 0.11405}, "CVE-2024-28144": {"epss_score": 0.00033, "epss_percentile": 0.09336}, "CVE-2024-28145": {"epss_score": 0.00283, "epss_percentile": 0.51355}, "CVE-2024-28146": {"epss_score": 0.00038, "epss_percentile": 0.11405}, "CVE-2024-28147": {"epss_score": 0.0035, "epss_percentile": 0.56922}, "CVE-2024-28148": {"epss_score": 0.0006, "epss_percentile": 0.19082}, "CVE-2024-28149": {"epss_score": 0.00133, "epss_percentile": 0.33714}, "CVE-2024-28150": {"epss_score": 0.00176, "epss_percentile": 0.39431}, "CVE-2024-28151": {"epss_score": 0.00209, "epss_percentile": 0.43395}, "CVE-2024-28152": {"epss_score": 0.00033, "epss_percentile": 0.09192}, "CVE-2024-28153": {"epss_score": 0.01117, "epss_percentile": 0.77723}, "CVE-2024-28154": {"epss_score": 0.00133, "epss_percentile": 0.33629}, "CVE-2024-28155": {"epss_score": 0.00052, "epss_percentile": 0.16396}, "CVE-2024-28156": {"epss_score": 0.4462, "epss_percentile": 0.97446}, "CVE-2024-28157": {"epss_score": 0.02504, "epss_percentile": 0.84934}, "CVE-2024-28158": {"epss_score": 0.0006, "epss_percentile": 0.19073}, "CVE-2024-28159": {"epss_score": 0.00074, "epss_percentile": 0.22681}, "CVE-2024-28160": {"epss_score": 0.00463, "epss_percentile": 0.63661}, "CVE-2024-28161": {"epss_score": 0.00011, "epss_percentile": 0.00991}, "CVE-2024-28162": {"epss_score": 0.00047, "epss_percentile": 0.14859}, "CVE-2024-28163": {"epss_score": 0.00287, "epss_percentile": 0.51791}, "CVE-2024-28164": {"epss_score": 0.00511, "epss_percentile": 0.65839}, "CVE-2024-28165": {"epss_score": 0.00485, "epss_percentile": 0.64721}, "CVE-2024-28166": {"epss_score": 0.00506, "epss_percentile": 0.6564}, "CVE-2024-28167": {"epss_score": 0.00077, "epss_percentile": 0.23535}, "CVE-2024-28168": {"epss_score": 0.00208, "epss_percentile": 0.4325}, "CVE-2024-28169": {"epss_score": 0.00027, "epss_percentile": 0.0712}, "CVE-2024-28170": {"epss_score": 0.00104, "epss_percentile": 0.29161}, "CVE-2024-28171": {"epss_score": 0.00122, "epss_percentile": 0.32106}, "CVE-2024-28172": {"epss_score": 0.00112, "epss_percentile": 0.30458}, "CVE-2024-28173": {"epss_score": 8e-05, "epss_percentile": 0.00592}, "CVE-2024-28174": {"epss_score": 7e-05, "epss_percentile": 0.00465}, "CVE-2024-28175": {"epss_score": 0.00476, "epss_percentile": 0.64292}, "CVE-2024-28176": {"epss_score": 0.00422, "epss_percentile": 0.6156}, "CVE-2024-28179": {"epss_score": 0.00353, "epss_percentile": 0.57151}, "CVE-2024-28180": {"epss_score": 0.03644, "epss_percentile": 0.87497}, "CVE-2024-28181": {"epss_score": 0.01007, "epss_percentile": 0.76558}, "CVE-2024-28182": {"epss_score": 0.24971, "epss_percentile": 0.95973}, "CVE-2024-28183": {"epss_score": 0.00043, "epss_percentile": 0.13072}, "CVE-2024-28184": {"epss_score": 0.00123, "epss_percentile": 0.3218}, "CVE-2024-28185": {"epss_score": 0.63357, "epss_percentile": 0.98329}, "CVE-2024-28186": {"epss_score": 0.0022, "epss_percentile": 0.44626}, "CVE-2024-28187": {"epss_score": 0.00334, "epss_percentile": 0.55689}, "CVE-2024-28188": {"epss_score": 0.00137, "epss_percentile": 0.34327}, "CVE-2024-28189": {"epss_score": 0.55707, "epss_percentile": 0.9799}, "CVE-2024-28190": {"epss_score": 0.01402, "epss_percentile": 0.80027}, "CVE-2024-28191": {"epss_score": 0.00961, "epss_percentile": 0.75979}, "CVE-2024-28192": {"epss_score": 0.00144, "epss_percentile": 0.35313}, "CVE-2024-28193": {"epss_score": 0.00523, "epss_percentile": 0.66289}, "CVE-2024-28194": {"epss_score": 0.0022, "epss_percentile": 0.44614}, "CVE-2024-28195": {"epss_score": 0.00637, "epss_percentile": 0.69888}, "CVE-2024-28196": {"epss_score": 0.00209, "epss_percentile": 0.43331}, "CVE-2024-28197": {"epss_score": 0.00096, "epss_percentile": 0.27292}, "CVE-2024-28198": {"epss_score": 0.00106, "epss_percentile": 0.29539}, "CVE-2024-28199": {"epss_score": 0.01182, "epss_percentile": 0.78314}, "CVE-2024-28200": {"epss_score": 0.28221, "epss_percentile": 0.96333}, "CVE-2024-28211": {"epss_score": 0.0218, "epss_percentile": 0.83898}, "CVE-2024-28212": {"epss_score": 0.07045, "epss_percentile": 0.91208}, "CVE-2024-28213": {"epss_score": 0.07048, "epss_percentile": 0.91211}, "CVE-2024-28214": {"epss_score": 0.00456, "epss_percentile": 0.63335}, "CVE-2024-28215": {"epss_score": 0.00329, "epss_percentile": 0.55407}, "CVE-2024-28216": {"epss_score": 0.00264, "epss_percentile": 0.49688}, "CVE-2024-28219": {"epss_score": 0.00284, "epss_percentile": 0.51454}, "CVE-2024-28222": {"epss_score": 0.01211, "epss_percentile": 0.78553}, "CVE-2024-28224": {"epss_score": 0.00158, "epss_percentile": 0.37283}, "CVE-2024-28226": {"epss_score": 0.01729, "epss_percentile": 0.81981}, "CVE-2024-28228": {"epss_score": 9e-05, "epss_percentile": 0.00624}, "CVE-2024-28229": {"epss_score": 5e-05, "epss_percentile": 0.00234}, "CVE-2024-28230": {"epss_score": 5e-05, "epss_percentile": 0.00234}, "CVE-2024-28231": {"epss_score": 0.00577, "epss_percentile": 0.68152}, "CVE-2024-28232": {"epss_score": 0.00262, "epss_percentile": 0.4934}, "CVE-2024-28233": {"epss_score": 0.00144, "epss_percentile": 0.35311}, "CVE-2024-28234": {"epss_score": 0.00701, "epss_percentile": 0.71494}, "CVE-2024-28235": {"epss_score": 0.00414, "epss_percentile": 0.61096}, "CVE-2024-28236": {"epss_score": 0.0018, "epss_percentile": 0.39875}, "CVE-2024-28237": {"epss_score": 0.00372, "epss_percentile": 0.58458}, "CVE-2024-28238": {"epss_score": 0.00088, "epss_percentile": 0.25705}, "CVE-2024-28239": {"epss_score": 0.00229, "epss_percentile": 0.45639}, "CVE-2024-28240": {"epss_score": 0.00054, "epss_percentile": 0.17252}, "CVE-2024-28241": {"epss_score": 0.00058, "epss_percentile": 0.18303}, "CVE-2024-28242": {"epss_score": 0.00114, "epss_percentile": 0.30774}, "CVE-2024-28243": {"epss_score": 0.00248, "epss_percentile": 0.47956}, "CVE-2024-28244": {"epss_score": 0.00179, "epss_percentile": 0.39821}, "CVE-2024-28245": {"epss_score": 0.00049, "epss_percentile": 0.15289}, "CVE-2024-28246": {"epss_score": 0.00056, "epss_percentile": 0.17964}, "CVE-2024-28247": {"epss_score": 0.05577, "epss_percentile": 0.90013}, "CVE-2024-28248": {"epss_score": 0.00755, "epss_percentile": 0.72714}, "CVE-2024-28249": {"epss_score": 0.00199, "epss_percentile": 0.42111}, "CVE-2024-28250": {"epss_score": 0.00051, "epss_percentile": 0.1625}, "CVE-2024-28251": {"epss_score": 0.00177, "epss_percentile": 0.39513}, "CVE-2024-28252": {"epss_score": 0.00126, "epss_percentile": 0.32733}, "CVE-2024-28253": {"epss_score": 0.9256, "epss_percentile": 0.99727}, "CVE-2024-28254": {"epss_score": 0.55852, "epss_percentile": 0.98}, "CVE-2024-28255": {"epss_score": 0.93995, "epss_percentile": 0.99882}, "CVE-2024-28265": {"epss_score": 0.00193, "epss_percentile": 0.4145}, "CVE-2024-28269": {"epss_score": 0.0234, "epss_percentile": 0.84428}, "CVE-2024-28270": {"epss_score": 0.00066, "epss_percentile": 0.20926}, "CVE-2024-28275": {"epss_score": 0.00079, "epss_percentile": 0.23896}, "CVE-2024-28276": {"epss_score": 0.00476, "epss_percentile": 0.64261}, "CVE-2024-28277": {"epss_score": 0.00707, "epss_percentile": 0.71647}, "CVE-2024-28279": {"epss_score": 0.00137, "epss_percentile": 0.34207}, "CVE-2024-28283": {"epss_score": 0.00527, "epss_percentile": 0.66531}, "CVE-2024-28285": {"epss_score": 0.00213, "epss_percentile": 0.43924}, "CVE-2024-28286": {"epss_score": 0.0009, "epss_percentile": 0.26159}, "CVE-2024-28287": {"epss_score": 0.00146, "epss_percentile": 0.35582}, "CVE-2024-28288": {"epss_score": 0.0008, "epss_percentile": 0.24063}, "CVE-2024-28294": {"epss_score": 0.00107, "epss_percentile": 0.2961}, "CVE-2024-28297": {"epss_score": 0.00136, "epss_percentile": 0.34154}, "CVE-2024-28298": {"epss_score": 0.00073, "epss_percentile": 0.2267}, "CVE-2024-28303": {"epss_score": 0.00072, "epss_percentile": 0.223}, "CVE-2024-28318": {"epss_score": 0.00144, "epss_percentile": 0.35262}, "CVE-2024-28319": {"epss_score": 0.00023, "epss_percentile": 0.05631}, "CVE-2024-28320": {"epss_score": 0.00146, "epss_percentile": 0.35585}, "CVE-2024-28322": {"epss_score": 0.00136, "epss_percentile": 0.34084}, "CVE-2024-28323": {"epss_score": 0.00112, "epss_percentile": 0.30442}, "CVE-2024-28325": {"epss_score": 0.00064, "epss_percentile": 0.20164}, "CVE-2024-28326": {"epss_score": 0.00101, "epss_percentile": 0.28668}, "CVE-2024-28327": {"epss_score": 0.00039, "epss_percentile": 0.11651}, "CVE-2024-28328": {"epss_score": 0.00036, "epss_percentile": 0.10607}, "CVE-2024-28335": {"epss_score": 0.00227, "epss_percentile": 0.45438}, "CVE-2024-28338": {"epss_score": 0.00016, "epss_percentile": 0.02658}, "CVE-2024-28339": {"epss_score": 0.00085, "epss_percentile": 0.25133}, "CVE-2024-28340": {"epss_score": 0.00247, "epss_percentile": 0.47833}, "CVE-2024-28344": {"epss_score": 0.00043, "epss_percentile": 0.13266}, "CVE-2024-28345": {"epss_score": 0.00095, "epss_percentile": 0.27099}, "CVE-2024-28353": {"epss_score": 0.04891, "epss_percentile": 0.89261}, "CVE-2024-28354": {"epss_score": 0.01185, "epss_percentile": 0.78343}, "CVE-2024-28383": {"epss_score": 0.00322, "epss_percentile": 0.54796}, "CVE-2024-28386": {"epss_score": 0.01824, "epss_percentile": 0.82426}, "CVE-2024-28387": {"epss_score": 0.00046, "epss_percentile": 0.14159}, "CVE-2024-28388": {"epss_score": 0.00293, "epss_percentile": 0.52306}, "CVE-2024-28389": {"epss_score": 0.00308, "epss_percentile": 0.53587}, "CVE-2024-28390": {"epss_score": 0.00423, "epss_percentile": 0.61604}, "CVE-2024-28391": {"epss_score": 0.00278, "epss_percentile": 0.50885}, "CVE-2024-28392": {"epss_score": 0.00293, "epss_percentile": 0.52306}, "CVE-2024-28393": {"epss_score": 0.00293, "epss_percentile": 0.52306}, "CVE-2024-28394": {"epss_score": 0.01973, "epss_percentile": 0.83112}, "CVE-2024-28395": {"epss_score": 0.00293, "epss_percentile": 0.52306}, "CVE-2024-28396": {"epss_score": 0.00425, "epss_percentile": 0.61694}, "CVE-2024-28397": {"epss_score": 0.67682, "epss_percentile": 0.98518}, "CVE-2024-28401": {"epss_score": 0.00095, "epss_percentile": 0.27173}, "CVE-2024-28402": {"epss_score": 0.00112, "epss_percentile": 0.30515}, "CVE-2024-28403": {"epss_score": 0.001, "epss_percentile": 0.28511}, "CVE-2024-28404": {"epss_score": 0.00054, "epss_percentile": 0.1715}, "CVE-2024-28405": {"epss_score": 0.0019, "epss_percentile": 0.41054}, "CVE-2024-28417": {"epss_score": 0.0008, "epss_percentile": 0.24127}, "CVE-2024-28418": {"epss_score": 0.00141, "epss_percentile": 0.3491}, "CVE-2024-28421": {"epss_score": 0.00671, "epss_percentile": 0.70805}, "CVE-2024-28423": {"epss_score": 0.00115, "epss_percentile": 0.30945}, "CVE-2024-28424": {"epss_score": 0.00106, "epss_percentile": 0.29562}, "CVE-2024-28425": {"epss_score": 0.00101, "epss_percentile": 0.28597}, "CVE-2024-28429": {"epss_score": 0.00063, "epss_percentile": 0.1986}, "CVE-2024-28430": {"epss_score": 0.00087, "epss_percentile": 0.25525}, "CVE-2024-28431": {"epss_score": 0.00175, "epss_percentile": 0.39323}, "CVE-2024-28432": {"epss_score": 0.00175, "epss_percentile": 0.39323}, "CVE-2024-28434": {"epss_score": 0.00123, "epss_percentile": 0.32234}, "CVE-2024-28435": {"epss_score": 0.00149, "epss_percentile": 0.35995}, "CVE-2024-28436": {"epss_score": 0.00347, "epss_percentile": 0.56761}, "CVE-2024-28441": {"epss_score": 0.0201, "epss_percentile": 0.83246}, "CVE-2024-28442": {"epss_score": 0.00249, "epss_percentile": 0.48024}, "CVE-2024-28446": {"epss_score": 0.00042, "epss_percentile": 0.12629}, "CVE-2024-28447": {"epss_score": 0.00042, "epss_percentile": 0.12619}, "CVE-2024-28456": {"epss_score": 0.00653, "epss_percentile": 0.70333}, "CVE-2024-28458": {"epss_score": 0.00211, "epss_percentile": 0.43645}, "CVE-2024-28515": {"epss_score": 0.12966, "epss_percentile": 0.93831}, "CVE-2024-28519": {"epss_score": 0.00078, "epss_percentile": 0.23682}, "CVE-2024-28520": {"epss_score": 0.00059, "epss_percentile": 0.18809}, "CVE-2024-28521": {"epss_score": 0.00063, "epss_percentile": 0.19806}, "CVE-2024-28535": {"epss_score": 0.00243, "epss_percentile": 0.47478}, "CVE-2024-28537": {"epss_score": 0.00172, "epss_percentile": 0.38954}, "CVE-2024-28545": {"epss_score": 0.04358, "epss_percentile": 0.88592}, "CVE-2024-28547": {"epss_score": 0.00061, "epss_percentile": 0.19437}, "CVE-2024-28550": {"epss_score": 0.00108, "epss_percentile": 0.29777}, "CVE-2024-28551": {"epss_score": 0.00403, "epss_percentile": 0.60373}, "CVE-2024-28553": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2024-28556": {"epss_score": 0.04386, "epss_percentile": 0.88632}, "CVE-2024-28557": {"epss_score": 0.04262, "epss_percentile": 0.88464}, "CVE-2024-28558": {"epss_score": 0.01812, "epss_percentile": 0.82373}, "CVE-2024-28559": {"epss_score": 0.00582, "epss_percentile": 0.68322}, "CVE-2024-28560": {"epss_score": 0.00578, "epss_percentile": 0.68187}, "CVE-2024-28562": {"epss_score": 0.00346, "epss_percentile": 0.56709}, "CVE-2024-28563": {"epss_score": 0.00059, "epss_percentile": 0.18846}, "CVE-2024-28564": {"epss_score": 0.00043, "epss_percentile": 0.1336}, "CVE-2024-28565": {"epss_score": 0.00044, "epss_percentile": 0.1337}, "CVE-2024-28566": {"epss_score": 0.00056, "epss_percentile": 0.17728}, "CVE-2024-28567": {"epss_score": 0.0004, "epss_percentile": 0.12105}, "CVE-2024-28568": {"epss_score": 0.00031, "epss_percentile": 0.08467}, "CVE-2024-28569": {"epss_score": 0.00056, "epss_percentile": 0.17741}, "CVE-2024-28570": {"epss_score": 0.0004, "epss_percentile": 0.12121}, "CVE-2024-28571": {"epss_score": 0.0004, "epss_percentile": 0.12121}, "CVE-2024-28572": {"epss_score": 0.00031, "epss_percentile": 0.08467}, "CVE-2024-28573": {"epss_score": 0.00042, "epss_percentile": 0.12892}, "CVE-2024-28574": {"epss_score": 0.00032, "epss_percentile": 0.09098}, "CVE-2024-28575": {"epss_score": 0.00032, "epss_percentile": 0.09098}, "CVE-2024-28576": {"epss_score": 0.00042, "epss_percentile": 0.12899}, "CVE-2024-28577": {"epss_score": 0.00027, "epss_percentile": 0.06784}, "CVE-2024-28578": {"epss_score": 0.00067, "epss_percentile": 0.21156}, "CVE-2024-28579": {"epss_score": 0.00032, "epss_percentile": 0.09098}, "CVE-2024-28580": {"epss_score": 0.0007, "epss_percentile": 0.21931}, "CVE-2024-28581": {"epss_score": 0.00054, "epss_percentile": 0.17149}, "CVE-2024-28582": {"epss_score": 0.00056, "epss_percentile": 0.17728}, "CVE-2024-28583": {"epss_score": 0.00137, "epss_percentile": 0.34203}, "CVE-2024-28584": {"epss_score": 0.00033, "epss_percentile": 0.09123}, "CVE-2024-28589": {"epss_score": 0.00118, "epss_percentile": 0.31453}, "CVE-2024-28593": {"epss_score": 0.00109, "epss_percentile": 0.29915}, "CVE-2024-28595": {"epss_score": 0.01328, "epss_percentile": 0.795}, "CVE-2024-28607": {"epss_score": 0.00015, "epss_percentile": 0.02477}, "CVE-2024-28613": {"epss_score": 0.00308, "epss_percentile": 0.53587}, "CVE-2024-28623": {"epss_score": 0.00859, "epss_percentile": 0.74522}, "CVE-2024-28627": {"epss_score": 0.00086, "epss_percentile": 0.25353}, "CVE-2024-28635": {"epss_score": 0.00093, "epss_percentile": 0.26759}, "CVE-2024-28639": {"epss_score": 0.03453, "epss_percentile": 0.87167}, "CVE-2024-28640": {"epss_score": 0.00496, "epss_percentile": 0.65162}, "CVE-2024-28662": {"epss_score": 0.00646, "epss_percentile": 0.70136}, "CVE-2024-28665": {"epss_score": 0.0025, "epss_percentile": 0.48122}, "CVE-2024-28666": {"epss_score": 0.00102, "epss_percentile": 0.28823}, "CVE-2024-28667": {"epss_score": 0.00142, "epss_percentile": 0.34963}, "CVE-2024-28668": {"epss_score": 0.00155, "epss_percentile": 0.36793}, "CVE-2024-28669": {"epss_score": 0.00086, "epss_percentile": 0.25403}, "CVE-2024-28670": {"epss_score": 0.00117, "epss_percentile": 0.3124}, "CVE-2024-28671": {"epss_score": 0.005, "epss_percentile": 0.6533}, "CVE-2024-28672": {"epss_score": 0.00116, "epss_percentile": 0.31124}, "CVE-2024-28673": {"epss_score": 0.00219, "epss_percentile": 0.44472}, "CVE-2024-28675": {"epss_score": 0.00257, "epss_percentile": 0.48924}, "CVE-2024-28676": {"epss_score": 0.00263, "epss_percentile": 0.49519}, "CVE-2024-28677": {"epss_score": 0.00128, "epss_percentile": 0.33012}, "CVE-2024-28678": {"epss_score": 0.00123, "epss_percentile": 0.3218}, "CVE-2024-28679": {"epss_score": 0.00248, "epss_percentile": 0.47996}, "CVE-2024-28680": {"epss_score": 0.00248, "epss_percentile": 0.47996}, "CVE-2024-28681": {"epss_score": 0.00117, "epss_percentile": 0.3124}, "CVE-2024-28682": {"epss_score": 0.00123, "epss_percentile": 0.3218}, "CVE-2024-28683": {"epss_score": 0.00248, "epss_percentile": 0.47996}, "CVE-2024-28684": {"epss_score": 0.00246, "epss_percentile": 0.47778}, "CVE-2024-28698": {"epss_score": 0.08908, "epss_percentile": 0.92311}, "CVE-2024-28699": {"epss_score": 0.00162, "epss_percentile": 0.37669}, "CVE-2024-28709": {"epss_score": 0.00845, "epss_percentile": 0.74284}, "CVE-2024-28710": {"epss_score": 0.00466, "epss_percentile": 0.63807}, "CVE-2024-28713": {"epss_score": 0.00962, "epss_percentile": 0.75991}, "CVE-2024-28714": {"epss_score": 0.00219, "epss_percentile": 0.44468}, "CVE-2024-28715": {"epss_score": 0.11144, "epss_percentile": 0.93238}, "CVE-2024-28716": {"epss_score": 0.0217, "epss_percentile": 0.83869}, "CVE-2024-28717": {"epss_score": 0.03014, "epss_percentile": 0.86208}, "CVE-2024-28718": {"epss_score": 0.0063, "epss_percentile": 0.69698}, "CVE-2024-28722": {"epss_score": 0.02013, "epss_percentile": 0.83259}, "CVE-2024-28725": {"epss_score": 0.00171, "epss_percentile": 0.38797}, "CVE-2024-28726": {"epss_score": 0.04657, "epss_percentile": 0.88974}, "CVE-2024-28728": {"epss_score": 0.002, "epss_percentile": 0.42236}, "CVE-2024-28729": {"epss_score": 0.00487, "epss_percentile": 0.64826}, "CVE-2024-28730": {"epss_score": 0.00104, "epss_percentile": 0.29175}, "CVE-2024-28731": {"epss_score": 0.00241, "epss_percentile": 0.4732}, "CVE-2024-28732": {"epss_score": 0.01664, "epss_percentile": 0.81641}, "CVE-2024-28734": {"epss_score": 0.10931, "epss_percentile": 0.93162}, "CVE-2024-28735": {"epss_score": 0.00068, "epss_percentile": 0.21423}, "CVE-2024-28736": {"epss_score": 0.01672, "epss_percentile": 0.81679}, "CVE-2024-28739": {"epss_score": 0.23004, "epss_percentile": 0.95716}, "CVE-2024-28740": {"epss_score": 0.05641, "epss_percentile": 0.90076}, "CVE-2024-28741": {"epss_score": 0.86438, "epss_percentile": 0.99382}, "CVE-2024-28744": {"epss_score": 0.00048, "epss_percentile": 0.15172}, "CVE-2024-28745": {"epss_score": 0.00022, "epss_percentile": 0.05305}, "CVE-2024-28746": {"epss_score": 0.00098, "epss_percentile": 0.27649}, "CVE-2024-28747": {"epss_score": 0.01974, "epss_percentile": 0.83113}, "CVE-2024-28748": {"epss_score": 0.00835, "epss_percentile": 0.74123}, "CVE-2024-28749": {"epss_score": 0.01197, "epss_percentile": 0.78447}, "CVE-2024-28750": {"epss_score": 0.01197, "epss_percentile": 0.78447}, "CVE-2024-28751": {"epss_score": 0.00729, "epss_percentile": 0.72118}, "CVE-2024-28752": {"epss_score": 0.0059, "epss_percentile": 0.68574}, "CVE-2024-28753": {"epss_score": 0.00059, "epss_percentile": 0.18751}, "CVE-2024-28754": {"epss_score": 0.00361, "epss_percentile": 0.57694}, "CVE-2024-28755": {"epss_score": 0.00127, "epss_percentile": 0.3289}, "CVE-2024-28756": {"epss_score": 0.00061, "epss_percentile": 0.19486}, "CVE-2024-28757": {"epss_score": 0.00885, "epss_percentile": 0.74934}, "CVE-2024-28759": {"epss_score": 0.00138, "epss_percentile": 0.34363}, "CVE-2024-28760": {"epss_score": 0.00136, "epss_percentile": 0.34105}, "CVE-2024-28761": {"epss_score": 0.00172, "epss_percentile": 0.38907}, "CVE-2024-28762": {"epss_score": 0.00217, "epss_percentile": 0.44304}, "CVE-2024-28764": {"epss_score": 0.00069, "epss_percentile": 0.21543}, "CVE-2024-28766": {"epss_score": 0.00155, "epss_percentile": 0.36763}, "CVE-2024-28767": {"epss_score": 0.00099, "epss_percentile": 0.28306}, "CVE-2024-28770": {"epss_score": 0.00052, "epss_percentile": 0.16492}, "CVE-2024-28771": {"epss_score": 0.00055, "epss_percentile": 0.17464}, "CVE-2024-28772": {"epss_score": 0.0026, "epss_percentile": 0.491}, "CVE-2024-28775": {"epss_score": 0.00109, "epss_percentile": 0.29948}, "CVE-2024-28776": {"epss_score": 0.00055, "epss_percentile": 0.17447}, "CVE-2024-28777": {"epss_score": 0.01202, "epss_percentile": 0.78486}, "CVE-2024-28778": {"epss_score": 0.00077, "epss_percentile": 0.23471}, "CVE-2024-28780": {"epss_score": 0.00046, "epss_percentile": 0.14186}, "CVE-2024-28781": {"epss_score": 0.0028, "epss_percentile": 0.51097}, "CVE-2024-28782": {"epss_score": 0.00041, "epss_percentile": 0.1238}, "CVE-2024-28784": {"epss_score": 0.00216, "epss_percentile": 0.44199}, "CVE-2024-28786": {"epss_score": 0.00027, "epss_percentile": 0.0685}, "CVE-2024-28787": {"epss_score": 0.00107, "epss_percentile": 0.29612}, "CVE-2024-28793": {"epss_score": 0.00198, "epss_percentile": 0.42009}, "CVE-2024-28794": {"epss_score": 0.00271, "epss_percentile": 0.50344}, "CVE-2024-28795": {"epss_score": 0.00147, "epss_percentile": 0.35746}, "CVE-2024-28796": {"epss_score": 0.00141, "epss_percentile": 0.3482}, "CVE-2024-28797": {"epss_score": 0.00271, "epss_percentile": 0.50344}, "CVE-2024-28798": {"epss_score": 0.00387, "epss_percentile": 0.59305}, "CVE-2024-28799": {"epss_score": 0.00136, "epss_percentile": 0.34089}, "CVE-2024-28803": {"epss_score": 0.00149, "epss_percentile": 0.35956}, "CVE-2024-28804": {"epss_score": 0.00178, "epss_percentile": 0.39656}, "CVE-2024-28805": {"epss_score": 0.00304, "epss_percentile": 0.53268}, "CVE-2024-28806": {"epss_score": 0.0048, "epss_percentile": 0.64451}, "CVE-2024-28807": {"epss_score": 0.00015, "epss_percentile": 0.02429}, "CVE-2024-28808": {"epss_score": 0.00071, "epss_percentile": 0.22121}, "CVE-2024-28809": {"epss_score": 0.00023, "epss_percentile": 0.05329}, "CVE-2024-28810": {"epss_score": 0.00042, "epss_percentile": 0.12751}, "CVE-2024-28811": {"epss_score": 0.0027, "epss_percentile": 0.50236}, "CVE-2024-28812": {"epss_score": 0.00057, "epss_percentile": 0.18079}, "CVE-2024-28813": {"epss_score": 0.0003, "epss_percentile": 0.08015}, "CVE-2024-28815": {"epss_score": 0.00335, "epss_percentile": 0.55864}, "CVE-2024-28816": {"epss_score": 0.0007, "epss_percentile": 0.21654}, "CVE-2024-28818": {"epss_score": 0.00327, "epss_percentile": 0.55124}, "CVE-2024-28820": {"epss_score": 0.00216, "epss_percentile": 0.44233}, "CVE-2024-28823": {"epss_score": 0.0009, "epss_percentile": 0.26055}, "CVE-2024-28824": {"epss_score": 0.00092, "epss_percentile": 0.26572}, "CVE-2024-28825": {"epss_score": 0.00193, "epss_percentile": 0.41495}, "CVE-2024-28826": {"epss_score": 0.00581, "epss_percentile": 0.68269}, "CVE-2024-28827": {"epss_score": 0.00085, "epss_percentile": 0.25148}, "CVE-2024-28828": {"epss_score": 0.01037, "epss_percentile": 0.76922}, "CVE-2024-28829": {"epss_score": 0.00076, "epss_percentile": 0.23165}, "CVE-2024-28830": {"epss_score": 0.00283, "epss_percentile": 0.51375}, "CVE-2024-28831": {"epss_score": 0.00959, "epss_percentile": 0.75959}, "CVE-2024-28832": {"epss_score": 0.00645, "epss_percentile": 0.701}, "CVE-2024-28833": {"epss_score": 0.00331, "epss_percentile": 0.55529}, "CVE-2024-28834": {"epss_score": 0.01705, "epss_percentile": 0.81848}, "CVE-2024-28835": {"epss_score": 0.00014, "epss_percentile": 0.02084}, "CVE-2024-28836": {"epss_score": 0.00113, "epss_percentile": 0.30598}, "CVE-2024-28847": {"epss_score": 0.19291, "epss_percentile": 0.95161}, "CVE-2024-28848": {"epss_score": 0.76241, "epss_percentile": 0.98884}, "CVE-2024-28849": {"epss_score": 0.00677, "epss_percentile": 0.70964}, "CVE-2024-28850": {"epss_score": 0.00025, "epss_percentile": 0.06269}, "CVE-2024-28851": {"epss_score": 0.00042, "epss_percentile": 0.12615}, "CVE-2024-28852": {"epss_score": 0.00769, "epss_percentile": 0.72993}, "CVE-2024-28853": {"epss_score": 0.00489, "epss_percentile": 0.64895}, "CVE-2024-28854": {"epss_score": 0.00136, "epss_percentile": 0.34091}, "CVE-2024-28855": {"epss_score": 0.01545, "epss_percentile": 0.80962}, "CVE-2024-28859": {"epss_score": 0.03962, "epss_percentile": 0.88015}, "CVE-2024-28860": {"epss_score": 0.0003, "epss_percentile": 0.08023}, "CVE-2024-28861": {"epss_score": 0.07445, "epss_percentile": 0.91476}, "CVE-2024-28862": {"epss_score": 0.00047, "epss_percentile": 0.14873}, "CVE-2024-28863": {"epss_score": 0.0045, "epss_percentile": 0.63086}, "CVE-2024-28864": {"epss_score": 0.00663, "epss_percentile": 0.70615}, "CVE-2024-28865": {"epss_score": 0.00079, "epss_percentile": 0.23869}, "CVE-2024-28866": {"epss_score": 0.00989, "epss_percentile": 0.7636}, "CVE-2024-28867": {"epss_score": 0.00171, "epss_percentile": 0.38813}, "CVE-2024-28868": {"epss_score": 0.00229, "epss_percentile": 0.45589}, "CVE-2024-28869": {"epss_score": 0.00753, "epss_percentile": 0.72678}, "CVE-2024-28870": {"epss_score": 0.00462, "epss_percentile": 0.63573}, "CVE-2024-28871": {"epss_score": 0.00188, "epss_percentile": 0.40915}, "CVE-2024-28872": {"epss_score": 0.0026, "epss_percentile": 0.49101}, "CVE-2024-28875": {"epss_score": 0.00268, "epss_percentile": 0.50045}, "CVE-2024-28876": {"epss_score": 0.00267, "epss_percentile": 0.49969}, "CVE-2024-28877": {"epss_score": 0.00563, "epss_percentile": 0.6773}, "CVE-2024-28878": {"epss_score": 0.0009, "epss_percentile": 0.26159}, "CVE-2024-28880": {"epss_score": 0.00097, "epss_percentile": 0.27571}, "CVE-2024-28881": {"epss_score": 0.00034, "epss_percentile": 0.09472}, "CVE-2024-28882": {"epss_score": 0.00318, "epss_percentile": 0.54409}, "CVE-2024-28883": {"epss_score": 0.00051, "epss_percentile": 0.1601}, "CVE-2024-28885": {"epss_score": 0.00087, "epss_percentile": 0.25609}, "CVE-2024-28886": {"epss_score": 0.00338, "epss_percentile": 0.56115}, "CVE-2024-28887": {"epss_score": 0.00112, "epss_percentile": 0.30458}, "CVE-2024-28888": {"epss_score": 0.03334, "epss_percentile": 0.86931}, "CVE-2024-28889": {"epss_score": 0.00308, "epss_percentile": 0.53582}, "CVE-2024-28890": {"epss_score": 0.00838, "epss_percentile": 0.74183}, "CVE-2024-28891": {"epss_score": 0.01185, "epss_percentile": 0.78342}, "CVE-2024-28892": {"epss_score": 0.0073, "epss_percentile": 0.72141}, "CVE-2024-28893": {"epss_score": 0.00076, "epss_percentile": 0.23095}, "CVE-2024-28894": {"epss_score": 0.00126, "epss_percentile": 0.32663}, "CVE-2024-28895": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2024-28896": {"epss_score": 0.0031, "epss_percentile": 0.53746}, "CVE-2024-28897": {"epss_score": 0.00127, "epss_percentile": 0.32849}, "CVE-2024-28898": {"epss_score": 0.00955, "epss_percentile": 0.75913}, "CVE-2024-28899": {"epss_score": 0.00586, "epss_percentile": 0.68437}, "CVE-2024-28900": {"epss_score": 0.00342, "epss_percentile": 0.56387}, "CVE-2024-28901": {"epss_score": 0.00345, "epss_percentile": 0.56585}, "CVE-2024-28902": {"epss_score": 0.00322, "epss_percentile": 0.54804}, "CVE-2024-28903": {"epss_score": 0.0018, "epss_percentile": 0.39983}, "CVE-2024-28904": {"epss_score": 0.00666, "epss_percentile": 0.70685}, "CVE-2024-28905": {"epss_score": 0.00672, "epss_percentile": 0.7081}, "CVE-2024-28906": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-28907": {"epss_score": 0.00524, "epss_percentile": 0.66316}, "CVE-2024-28908": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-28909": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-28910": {"epss_score": 0.03446, "epss_percentile": 0.87149}, "CVE-2024-28911": {"epss_score": 0.02234, "epss_percentile": 0.84098}, "CVE-2024-28912": {"epss_score": 0.02234, "epss_percentile": 0.84098}, "CVE-2024-28913": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-28914": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-28915": {"epss_score": 0.03005, "epss_percentile": 0.86181}, "CVE-2024-28916": {"epss_score": 0.00704, "epss_percentile": 0.71568}, "CVE-2024-28917": {"epss_score": 0.00138, "epss_percentile": 0.34505}, "CVE-2024-28919": {"epss_score": 0.00097, "epss_percentile": 0.27547}, "CVE-2024-28920": {"epss_score": 0.00368, "epss_percentile": 0.58182}, "CVE-2024-28921": {"epss_score": 0.00098, "epss_percentile": 0.27792}, "CVE-2024-28922": {"epss_score": 0.0015, "epss_percentile": 0.36151}, "CVE-2024-28923": {"epss_score": 0.00237, "epss_percentile": 0.46713}, "CVE-2024-28924": {"epss_score": 0.0008, "epss_percentile": 0.24185}, "CVE-2024-28925": {"epss_score": 0.00636, "epss_percentile": 0.69872}, "CVE-2024-28926": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-28927": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-28928": {"epss_score": 0.02257, "epss_percentile": 0.84174}, "CVE-2024-28929": {"epss_score": 0.02382, "epss_percentile": 0.84569}, "CVE-2024-28930": {"epss_score": 0.01767, "epss_percentile": 0.82178}, "CVE-2024-28931": {"epss_score": 0.01767, "epss_percentile": 0.82178}, "CVE-2024-28932": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-28933": {"epss_score": 0.01767, "epss_percentile": 0.82178}, "CVE-2024-28934": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-28935": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-28936": {"epss_score": 0.01767, "epss_percentile": 0.82178}, "CVE-2024-28937": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-28938": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-28939": {"epss_score": 0.01308, "epss_percentile": 0.79349}, "CVE-2024-28940": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-28941": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-28942": {"epss_score": 0.02382, "epss_percentile": 0.84568}, "CVE-2024-28943": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-28944": {"epss_score": 0.02618, "epss_percentile": 0.85251}, "CVE-2024-28945": {"epss_score": 0.01782, "epss_percentile": 0.82245}, "CVE-2024-28947": {"epss_score": 0.00088, "epss_percentile": 0.25755}, "CVE-2024-28948": {"epss_score": 0.00064, "epss_percentile": 0.20193}, "CVE-2024-28949": {"epss_score": 0.00118, "epss_percentile": 0.31458}, "CVE-2024-28950": {"epss_score": 0.00037, "epss_percentile": 0.10647}, "CVE-2024-28951": {"epss_score": 0.00095, "epss_percentile": 0.27175}, "CVE-2024-28952": {"epss_score": 0.00068, "epss_percentile": 0.21224}, "CVE-2024-28953": {"epss_score": 0.00051, "epss_percentile": 0.16145}, "CVE-2024-28954": {"epss_score": 0.00013, "epss_percentile": 0.01699}, "CVE-2024-28955": {"epss_score": 0.00435, "epss_percentile": 0.62351}, "CVE-2024-28956": {"epss_score": 0.00021, "epss_percentile": 0.04739}, "CVE-2024-28957": {"epss_score": 0.00408, "epss_percentile": 0.60675}, "CVE-2024-28960": {"epss_score": 0.00138, "epss_percentile": 0.34378}, "CVE-2024-28961": {"epss_score": 0.00074, "epss_percentile": 0.22844}, "CVE-2024-28962": {"epss_score": 0.00219, "epss_percentile": 0.44483}, "CVE-2024-28963": {"epss_score": 0.00056, "epss_percentile": 0.17955}, "CVE-2024-28964": {"epss_score": 0.00154, "epss_percentile": 0.36756}, "CVE-2024-28965": {"epss_score": 0.01405, "epss_percentile": 0.80042}, "CVE-2024-28966": {"epss_score": 0.01405, "epss_percentile": 0.80042}, "CVE-2024-28967": {"epss_score": 0.01405, "epss_percentile": 0.80042}, "CVE-2024-28968": {"epss_score": 0.01405, "epss_percentile": 0.80042}, "CVE-2024-28969": {"epss_score": 0.01219, "epss_percentile": 0.78609}, "CVE-2024-28970": {"epss_score": 0.00046, "epss_percentile": 0.14329}, "CVE-2024-28971": {"epss_score": 0.00228, "epss_percentile": 0.45482}, "CVE-2024-28972": {"epss_score": 0.00188, "epss_percentile": 0.40897}, "CVE-2024-28973": {"epss_score": 0.00341, "epss_percentile": 0.56348}, "CVE-2024-28974": {"epss_score": 0.00187, "epss_percentile": 0.40794}, "CVE-2024-28976": {"epss_score": 0.00059, "epss_percentile": 0.18913}, "CVE-2024-28977": {"epss_score": 0.00076, "epss_percentile": 0.2317}, "CVE-2024-28978": {"epss_score": 0.00302, "epss_percentile": 0.53083}, "CVE-2024-28979": {"epss_score": 0.00198, "epss_percentile": 0.4201}, "CVE-2024-28980": {"epss_score": 0.00117, "epss_percentile": 0.31204}, "CVE-2024-28981": {"epss_score": 0.001, "epss_percentile": 0.28454}, "CVE-2024-28982": {"epss_score": 0.003, "epss_percentile": 0.52923}, "CVE-2024-28983": {"epss_score": 0.00455, "epss_percentile": 0.63313}, "CVE-2024-28984": {"epss_score": 0.00419, "epss_percentile": 0.61357}, "CVE-2024-28986": {"epss_score": 0.81538, "epss_percentile": 0.99143}, "CVE-2024-28987": {"epss_score": 0.9429, "epss_percentile": 0.99936}, "CVE-2024-28988": {"epss_score": 0.04828, "epss_percentile": 0.89188}, "CVE-2024-28989": {"epss_score": 0.00062, "epss_percentile": 0.19687}, "CVE-2024-28990": {"epss_score": 0.0002, "epss_percentile": 0.04669}, "CVE-2024-28991": {"epss_score": 0.25222, "epss_percentile": 0.96}, "CVE-2024-28992": {"epss_score": 0.00459, "epss_percentile": 0.63464}, "CVE-2024-28993": {"epss_score": 0.00636, "epss_percentile": 0.69876}, "CVE-2024-28995": {"epss_score": 0.94354, "epss_percentile": 0.99956}, "CVE-2024-28996": {"epss_score": 0.00644, "epss_percentile": 0.7009}, "CVE-2024-28999": {"epss_score": 0.06475, "epss_percentile": 0.90782}, "CVE-2024-29000": {"epss_score": 0.00126, "epss_percentile": 0.32688}, "CVE-2024-29001": {"epss_score": 0.00059, "epss_percentile": 0.18622}, "CVE-2024-29003": {"epss_score": 0.00068, "epss_percentile": 0.21261}, "CVE-2024-29004": {"epss_score": 0.00071, "epss_percentile": 0.22121}, "CVE-2024-29006": {"epss_score": 0.00073, "epss_percentile": 0.22542}, "CVE-2024-29007": {"epss_score": 0.00101, "epss_percentile": 0.28644}, "CVE-2024-29008": {"epss_score": 0.00135, "epss_percentile": 0.33939}, "CVE-2024-29009": {"epss_score": 0.00296, "epss_percentile": 0.52553}, "CVE-2024-29010": {"epss_score": 0.00087, "epss_percentile": 0.25535}, "CVE-2024-29011": {"epss_score": 0.00047, "epss_percentile": 0.14641}, "CVE-2024-29012": {"epss_score": 0.02246, "epss_percentile": 0.84132}, "CVE-2024-29013": {"epss_score": 0.01338, "epss_percentile": 0.79566}, "CVE-2024-29014": {"epss_score": 0.01172, "epss_percentile": 0.78234}, "CVE-2024-29015": {"epss_score": 0.00112, "epss_percentile": 0.30458}, "CVE-2024-29018": {"epss_score": 0.00222, "epss_percentile": 0.44717}, "CVE-2024-29019": {"epss_score": 0.00055, "epss_percentile": 0.17428}, "CVE-2024-29020": {"epss_score": 0.00154, "epss_percentile": 0.36679}, "CVE-2024-29021": {"epss_score": 0.01631, "epss_percentile": 0.81454}, "CVE-2024-29022": {"epss_score": 0.00115, "epss_percentile": 0.30953}, "CVE-2024-29023": {"epss_score": 0.00109, "epss_percentile": 0.29949}, "CVE-2024-29024": {"epss_score": 0.00092, "epss_percentile": 0.26602}, "CVE-2024-29025": {"epss_score": 0.00261, "epss_percentile": 0.49247}, "CVE-2024-29026": {"epss_score": 0.00142, "epss_percentile": 0.35021}, "CVE-2024-29027": {"epss_score": 0.01895, "epss_percentile": 0.82745}, "CVE-2024-29028": {"epss_score": 0.06339, "epss_percentile": 0.90681}, "CVE-2024-29029": {"epss_score": 0.02628, "epss_percentile": 0.85271}, "CVE-2024-29030": {"epss_score": 0.05747, "epss_percentile": 0.90175}, "CVE-2024-29031": {"epss_score": 0.0119, "epss_percentile": 0.78381}, "CVE-2024-29032": {"epss_score": 0.00061, "epss_percentile": 0.19506}, "CVE-2024-29033": {"epss_score": 0.00276, "epss_percentile": 0.50719}, "CVE-2024-29034": {"epss_score": 0.00075, "epss_percentile": 0.22911}, "CVE-2024-29035": {"epss_score": 0.00209, "epss_percentile": 0.4332}, "CVE-2024-29036": {"epss_score": 0.00396, "epss_percentile": 0.59902}, "CVE-2024-29037": {"epss_score": 0.0029, "epss_percentile": 0.52095}, "CVE-2024-29038": {"epss_score": 0.00151, "epss_percentile": 0.36252}, "CVE-2024-29039": {"epss_score": 0.01779, "epss_percentile": 0.8223}, "CVE-2024-29040": {"epss_score": 0.00066, "epss_percentile": 0.20692}, "CVE-2024-29041": {"epss_score": 0.00114, "epss_percentile": 0.30772}, "CVE-2024-29042": {"epss_score": 0.00763, "epss_percentile": 0.7285}, "CVE-2024-29043": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-29044": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-29045": {"epss_score": 0.0169, "epss_percentile": 0.81773}, "CVE-2024-29046": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-29047": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-29048": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-29049": {"epss_score": 0.00533, "epss_percentile": 0.6675}, "CVE-2024-29050": {"epss_score": 0.25402, "epss_percentile": 0.96025}, "CVE-2024-29052": {"epss_score": 0.00981, "epss_percentile": 0.76282}, "CVE-2024-29053": {"epss_score": 0.06629, "epss_percentile": 0.90902}, "CVE-2024-29054": {"epss_score": 0.03387, "epss_percentile": 0.87043}, "CVE-2024-29055": {"epss_score": 0.0538, "epss_percentile": 0.89809}, "CVE-2024-29056": {"epss_score": 0.01412, "epss_percentile": 0.80114}, "CVE-2024-29057": {"epss_score": 0.00971, "epss_percentile": 0.7612}, "CVE-2024-29059": {"epss_score": 0.93848, "epss_percentile": 0.99857}, "CVE-2024-29060": {"epss_score": 0.0026, "epss_percentile": 0.49188}, "CVE-2024-29061": {"epss_score": 0.0046, "epss_percentile": 0.63514}, "CVE-2024-29062": {"epss_score": 0.00288, "epss_percentile": 0.51918}, "CVE-2024-29063": {"epss_score": 0.01217, "epss_percentile": 0.78601}, "CVE-2024-29064": {"epss_score": 0.00428, "epss_percentile": 0.61959}, "CVE-2024-29066": {"epss_score": 0.01157, "epss_percentile": 0.78112}, "CVE-2024-29068": {"epss_score": 0.00019, "epss_percentile": 0.04131}, "CVE-2024-29069": {"epss_score": 0.00035, "epss_percentile": 0.1007}, "CVE-2024-29070": {"epss_score": 0.0016, "epss_percentile": 0.37457}, "CVE-2024-29071": {"epss_score": 0.0006, "epss_percentile": 0.18985}, "CVE-2024-29072": {"epss_score": 0.00065, "epss_percentile": 0.20566}, "CVE-2024-29073": {"epss_score": 0.04122, "epss_percentile": 0.88284}, "CVE-2024-29074": {"epss_score": 0.001, "epss_percentile": 0.28449}, "CVE-2024-29075": {"epss_score": 0.00042, "epss_percentile": 0.12598}, "CVE-2024-29076": {"epss_score": 0.00017, "epss_percentile": 0.03322}, "CVE-2024-29077": {"epss_score": 0.00084, "epss_percentile": 0.25018}, "CVE-2024-29078": {"epss_score": 0.0021, "epss_percentile": 0.43485}, "CVE-2024-29079": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2024-29080": {"epss_score": 0.0005, "epss_percentile": 0.15958}, "CVE-2024-29082": {"epss_score": 0.00087, "epss_percentile": 0.25579}, "CVE-2024-29083": {"epss_score": 0.00017, "epss_percentile": 0.0345}, "CVE-2024-29085": {"epss_score": 0.00045, "epss_percentile": 0.13709}, "CVE-2024-29086": {"epss_score": 0.00094, "epss_percentile": 0.26788}, "CVE-2024-29089": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-29090": {"epss_score": 0.00565, "epss_percentile": 0.67797}, "CVE-2024-29091": {"epss_score": 0.00071, "epss_percentile": 0.22206}, "CVE-2024-29092": {"epss_score": 0.00115, "epss_percentile": 0.31018}, "CVE-2024-29093": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2024-29094": {"epss_score": 0.00128, "epss_percentile": 0.33059}, "CVE-2024-29095": {"epss_score": 0.00059, "epss_percentile": 0.18704}, "CVE-2024-29096": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-29097": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-29098": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-29099": {"epss_score": 0.00098, "epss_percentile": 0.27652}, "CVE-2024-29100": {"epss_score": 0.00117, "epss_percentile": 0.3121}, "CVE-2024-29101": {"epss_score": 0.00191, "epss_percentile": 0.41261}, "CVE-2024-29102": {"epss_score": 0.00078, "epss_percentile": 0.23659}, "CVE-2024-29103": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-29104": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-29105": {"epss_score": 0.00059, "epss_percentile": 0.18704}, "CVE-2024-29106": {"epss_score": 0.0006, "epss_percentile": 0.18967}, "CVE-2024-29107": {"epss_score": 0.00085, "epss_percentile": 0.25031}, "CVE-2024-29108": {"epss_score": 0.00063, "epss_percentile": 0.19832}, "CVE-2024-29109": {"epss_score": 0.00069, "epss_percentile": 0.21561}, "CVE-2024-29110": {"epss_score": 0.00176, "epss_percentile": 0.39441}, "CVE-2024-29111": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-29112": {"epss_score": 0.00067, "epss_percentile": 0.21076}, "CVE-2024-29113": {"epss_score": 0.00134, "epss_percentile": 0.33828}, "CVE-2024-29114": {"epss_score": 0.00081, "epss_percentile": 0.24347}, "CVE-2024-29115": {"epss_score": 0.00081, "epss_percentile": 0.24347}, "CVE-2024-29116": {"epss_score": 0.00071, "epss_percentile": 0.22206}, "CVE-2024-29117": {"epss_score": 0.00126, "epss_percentile": 0.32697}, "CVE-2024-29118": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-29119": {"epss_score": 0.0008, "epss_percentile": 0.24021}, "CVE-2024-29120": {"epss_score": 0.0008, "epss_percentile": 0.24037}, "CVE-2024-29121": {"epss_score": 0.00078, "epss_percentile": 0.23659}, "CVE-2024-29122": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-29123": {"epss_score": 0.00173, "epss_percentile": 0.39076}, "CVE-2024-29124": {"epss_score": 0.00068, "epss_percentile": 0.21363}, "CVE-2024-29125": {"epss_score": 0.00099, "epss_percentile": 0.28407}, "CVE-2024-29126": {"epss_score": 0.00071, "epss_percentile": 0.22206}, "CVE-2024-29127": {"epss_score": 0.00126, "epss_percentile": 0.32697}, "CVE-2024-29128": {"epss_score": 0.00074, "epss_percentile": 0.22804}, "CVE-2024-29129": {"epss_score": 0.00103, "epss_percentile": 0.29099}, "CVE-2024-29130": {"epss_score": 0.00162, "epss_percentile": 0.37684}, "CVE-2024-29131": {"epss_score": 0.00203, "epss_percentile": 0.42508}, "CVE-2024-29133": {"epss_score": 0.0068, "epss_percentile": 0.71033}, "CVE-2024-29134": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2024-29135": {"epss_score": 0.00475, "epss_percentile": 0.64184}, "CVE-2024-29136": {"epss_score": 0.00391, "epss_percentile": 0.59573}, "CVE-2024-29137": {"epss_score": 0.00095, "epss_percentile": 0.27184}, "CVE-2024-29138": {"epss_score": 0.0007, "epss_percentile": 0.21796}, "CVE-2024-29139": {"epss_score": 0.00097, "epss_percentile": 0.27528}, "CVE-2024-29140": {"epss_score": 0.00062, "epss_percentile": 0.19628}, "CVE-2024-29141": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-29142": {"epss_score": 0.00097, "epss_percentile": 0.27528}, "CVE-2024-29143": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-29146": {"epss_score": 0.0009, "epss_percentile": 0.26161}, "CVE-2024-29149": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2024-29150": {"epss_score": 0.00127, "epss_percentile": 0.32814}, "CVE-2024-29151": {"epss_score": 0.00048, "epss_percentile": 0.14994}, "CVE-2024-29152": {"epss_score": 0.00664, "epss_percentile": 0.70636}, "CVE-2024-29153": {"epss_score": 0.00653, "epss_percentile": 0.70338}, "CVE-2024-29154": {"epss_score": 0.00081, "epss_percentile": 0.24372}, "CVE-2024-29155": {"epss_score": 0.00087, "epss_percentile": 0.25499}, "CVE-2024-29156": {"epss_score": 0.0017, "epss_percentile": 0.38689}, "CVE-2024-29157": {"epss_score": 0.00154, "epss_percentile": 0.36749}, "CVE-2024-29158": {"epss_score": 0.00071, "epss_percentile": 0.21986}, "CVE-2024-29159": {"epss_score": 0.00421, "epss_percentile": 0.61486}, "CVE-2024-29160": {"epss_score": 0.00076, "epss_percentile": 0.23273}, "CVE-2024-29161": {"epss_score": 0.00403, "epss_percentile": 0.60388}, "CVE-2024-29162": {"epss_score": 0.00076, "epss_percentile": 0.23273}, "CVE-2024-29163": {"epss_score": 0.00076, "epss_percentile": 0.23273}, "CVE-2024-29164": {"epss_score": 0.00154, "epss_percentile": 0.36749}, "CVE-2024-29165": {"epss_score": 0.00076, "epss_percentile": 0.23273}, "CVE-2024-29166": {"epss_score": 0.00055, "epss_percentile": 0.17378}, "CVE-2024-29167": {"epss_score": 0.00447, "epss_percentile": 0.62982}, "CVE-2024-29168": {"epss_score": 0.02486, "epss_percentile": 0.84885}, "CVE-2024-29169": {"epss_score": 0.02105, "epss_percentile": 0.83624}, "CVE-2024-29170": {"epss_score": 0.00314, "epss_percentile": 0.54119}, "CVE-2024-29171": {"epss_score": 0.00022, "epss_percentile": 0.05262}, "CVE-2024-29172": {"epss_score": 0.00048, "epss_percentile": 0.15006}, "CVE-2024-29173": {"epss_score": 0.0028, "epss_percentile": 0.51022}, "CVE-2024-29174": {"epss_score": 0.00139, "epss_percentile": 0.34559}, "CVE-2024-29175": {"epss_score": 0.00288, "epss_percentile": 0.51977}, "CVE-2024-29176": {"epss_score": 0.00598, "epss_percentile": 0.68775}, "CVE-2024-29177": {"epss_score": 0.00283, "epss_percentile": 0.51375}, "CVE-2024-29178": {"epss_score": 0.12018, "epss_percentile": 0.93549}, "CVE-2024-29179": {"epss_score": 0.00292, "epss_percentile": 0.52231}, "CVE-2024-29180": {"epss_score": 0.02533, "epss_percentile": 0.8503}, "CVE-2024-29181": {"epss_score": 0.00433, "epss_percentile": 0.62172}, "CVE-2024-29182": {"epss_score": 0.00181, "epss_percentile": 0.40112}, "CVE-2024-29183": {"epss_score": 0.00074, "epss_percentile": 0.22775}, "CVE-2024-29184": {"epss_score": 0.00434, "epss_percentile": 0.62309}, "CVE-2024-29185": {"epss_score": 0.00637, "epss_percentile": 0.69884}, "CVE-2024-29186": {"epss_score": 0.00089, "epss_percentile": 0.25925}, "CVE-2024-29187": {"epss_score": 0.00044, "epss_percentile": 0.13626}, "CVE-2024-29188": {"epss_score": 0.00029, "epss_percentile": 0.07657}, "CVE-2024-29189": {"epss_score": 0.00118, "epss_percentile": 0.31416}, "CVE-2024-29190": {"epss_score": 0.00314, "epss_percentile": 0.54106}, "CVE-2024-29191": {"epss_score": 0.00139, "epss_percentile": 0.34537}, "CVE-2024-29192": {"epss_score": 0.00103, "epss_percentile": 0.29078}, "CVE-2024-29193": {"epss_score": 0.00127, "epss_percentile": 0.32886}, "CVE-2024-29194": {"epss_score": 0.00069, "epss_percentile": 0.21429}, "CVE-2024-29195": {"epss_score": 0.05785, "epss_percentile": 0.90206}, "CVE-2024-29196": {"epss_score": 0.00463, "epss_percentile": 0.63697}, "CVE-2024-29197": {"epss_score": 2e-05, "epss_percentile": 0.00021}, "CVE-2024-29198": {"epss_score": 0.05147, "epss_percentile": 0.89545}, "CVE-2024-29199": {"epss_score": 0.00127, "epss_percentile": 0.32789}, "CVE-2024-29200": {"epss_score": 0.00237, "epss_percentile": 0.46694}, "CVE-2024-29201": {"epss_score": 0.68519, "epss_percentile": 0.98552}, "CVE-2024-29202": {"epss_score": 0.81154, "epss_percentile": 0.99124}, "CVE-2024-29203": {"epss_score": 0.01231, "epss_percentile": 0.78734}, "CVE-2024-29204": {"epss_score": 0.06767, "epss_percentile": 0.91012}, "CVE-2024-29205": {"epss_score": 0.02709, "epss_percentile": 0.85481}, "CVE-2024-29206": {"epss_score": 0.00062, "epss_percentile": 0.19642}, "CVE-2024-29207": {"epss_score": 0.00075, "epss_percentile": 0.22961}, "CVE-2024-29208": {"epss_score": 0.00081, "epss_percentile": 0.24307}, "CVE-2024-29209": {"epss_score": 0.00281, "epss_percentile": 0.51198}, "CVE-2024-29210": {"epss_score": 0.00045, "epss_percentile": 0.1377}, "CVE-2024-29211": {"epss_score": 0.00183, "epss_percentile": 0.40306}, "CVE-2024-29212": {"epss_score": 0.2794, "epss_percentile": 0.96297}, "CVE-2024-29213": {"epss_score": 0.00455, "epss_percentile": 0.63303}, "CVE-2024-29214": {"epss_score": 0.00029, "epss_percentile": 0.07651}, "CVE-2024-29215": {"epss_score": 0.00188, "epss_percentile": 0.40839}, "CVE-2024-29216": {"epss_score": 0.00027, "epss_percentile": 0.06826}, "CVE-2024-29217": {"epss_score": 0.00284, "epss_percentile": 0.51426}, "CVE-2024-29218": {"epss_score": 0.0065, "epss_percentile": 0.70262}, "CVE-2024-29219": {"epss_score": 0.00245, "epss_percentile": 0.47663}, "CVE-2024-29220": {"epss_score": 0.0031, "epss_percentile": 0.53755}, "CVE-2024-29221": {"epss_score": 0.00062, "epss_percentile": 0.19738}, "CVE-2024-29222": {"epss_score": 0.00034, "epss_percentile": 0.0974}, "CVE-2024-29223": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-29224": {"epss_score": 0.01194, "epss_percentile": 0.78423}, "CVE-2024-29225": {"epss_score": 0.00054, "epss_percentile": 0.17222}, "CVE-2024-29227": {"epss_score": 0.00249, "epss_percentile": 0.48046}, "CVE-2024-29228": {"epss_score": 0.00192, "epss_percentile": 0.41332}, "CVE-2024-29229": {"epss_score": 0.00192, "epss_percentile": 0.41332}, "CVE-2024-29230": {"epss_score": 0.00253, "epss_percentile": 0.48451}, "CVE-2024-29231": {"epss_score": 0.00371, "epss_percentile": 0.58355}, "CVE-2024-29232": {"epss_score": 0.00249, "epss_percentile": 0.48046}, "CVE-2024-29233": {"epss_score": 0.00249, "epss_percentile": 0.48046}, "CVE-2024-29234": {"epss_score": 0.00249, "epss_percentile": 0.48046}, "CVE-2024-29235": {"epss_score": 0.00249, "epss_percentile": 0.48046}, "CVE-2024-29236": {"epss_score": 0.00253, "epss_percentile": 0.48451}, "CVE-2024-29237": {"epss_score": 0.00249, "epss_percentile": 0.48046}, "CVE-2024-29238": {"epss_score": 0.00249, "epss_percentile": 0.48046}, "CVE-2024-29239": {"epss_score": 0.00253, "epss_percentile": 0.48451}, "CVE-2024-29240": {"epss_score": 0.00416, "epss_percentile": 0.61184}, "CVE-2024-29241": {"epss_score": 0.01383, "epss_percentile": 0.79891}, "CVE-2024-29243": {"epss_score": 0.00235, "epss_percentile": 0.46323}, "CVE-2024-29244": {"epss_score": 0.0012, "epss_percentile": 0.31707}, "CVE-2024-29269": {"epss_score": 0.93613, "epss_percentile": 0.99824}, "CVE-2024-29271": {"epss_score": 0.0013, "epss_percentile": 0.33315}, "CVE-2024-29272": {"epss_score": 0.89261, "epss_percentile": 0.99518}, "CVE-2024-29273": {"epss_score": 0.00091, "epss_percentile": 0.26251}, "CVE-2024-29275": {"epss_score": 0.61802, "epss_percentile": 0.98262}, "CVE-2024-29276": {"epss_score": 0.12893, "epss_percentile": 0.93814}, "CVE-2024-29278": {"epss_score": 0.00114, "epss_percentile": 0.30861}, "CVE-2024-29291": {"epss_score": 0.05734, "epss_percentile": 0.90163}, "CVE-2024-29292": {"epss_score": 0.00779, "epss_percentile": 0.73142}, "CVE-2024-29296": {"epss_score": 0.10281, "epss_percentile": 0.92925}, "CVE-2024-29301": {"epss_score": 0.00069, "epss_percentile": 0.21546}, "CVE-2024-29302": {"epss_score": 0.00097, "epss_percentile": 0.27576}, "CVE-2024-29303": {"epss_score": 0.00112, "epss_percentile": 0.3054}, "CVE-2024-29309": {"epss_score": 0.02956, "epss_percentile": 0.86061}, "CVE-2024-29316": {"epss_score": 0.0007, "epss_percentile": 0.21673}, "CVE-2024-29318": {"epss_score": 0.00169, "epss_percentile": 0.3857}, "CVE-2024-29319": {"epss_score": 0.00103, "epss_percentile": 0.28933}, "CVE-2024-29320": {"epss_score": 0.00138, "epss_percentile": 0.34444}, "CVE-2024-29338": {"epss_score": 0.00076, "epss_percentile": 0.23283}, "CVE-2024-29366": {"epss_score": 0.00275, "epss_percentile": 0.50633}, "CVE-2024-29368": {"epss_score": 0.00124, "epss_percentile": 0.32356}, "CVE-2024-29370": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2024-29371": {"epss_score": 0.00033, "epss_percentile": 0.09319}, "CVE-2024-29374": {"epss_score": 0.003, "epss_percentile": 0.52951}, "CVE-2024-29375": {"epss_score": 0.10226, "epss_percentile": 0.92902}, "CVE-2024-29376": {"epss_score": 0.00114, "epss_percentile": 0.30804}, "CVE-2024-29384": {"epss_score": 0.00268, "epss_percentile": 0.50055}, "CVE-2024-29385": {"epss_score": 0.05112, "epss_percentile": 0.89512}, "CVE-2024-29386": {"epss_score": 0.00082, "epss_percentile": 0.24531}, "CVE-2024-29387": {"epss_score": 0.02815, "epss_percentile": 0.85731}, "CVE-2024-29390": {"epss_score": 0.00056, "epss_percentile": 0.17806}, "CVE-2024-29392": {"epss_score": 0.00119, "epss_percentile": 0.31683}, "CVE-2024-29399": {"epss_score": 0.06167, "epss_percentile": 0.90528}, "CVE-2024-29400": {"epss_score": 0.00094, "epss_percentile": 0.2696}, "CVE-2024-29401": {"epss_score": 0.0019, "epss_percentile": 0.41087}, "CVE-2024-29402": {"epss_score": 0.00064, "epss_percentile": 0.20267}, "CVE-2024-29404": {"epss_score": 0.04327, "epss_percentile": 0.88555}, "CVE-2024-29409": {"epss_score": 0.00163, "epss_percentile": 0.37804}, "CVE-2024-29413": {"epss_score": 0.00224, "epss_percentile": 0.4497}, "CVE-2024-29415": {"epss_score": 0.03814, "epss_percentile": 0.87765}, "CVE-2024-29417": {"epss_score": 0.00049, "epss_percentile": 0.15604}, "CVE-2024-29419": {"epss_score": 0.00103, "epss_percentile": 0.29096}, "CVE-2024-29421": {"epss_score": 0.00068, "epss_percentile": 0.21221}, "CVE-2024-29432": {"epss_score": 0.0016, "epss_percentile": 0.37491}, "CVE-2024-29433": {"epss_score": 0.00126, "epss_percentile": 0.32624}, "CVE-2024-29434": {"epss_score": 0.0067, "epss_percentile": 0.70784}, "CVE-2024-29435": {"epss_score": 0.00135, "epss_percentile": 0.33998}, "CVE-2024-29460": {"epss_score": 0.00112, "epss_percentile": 0.30494}, "CVE-2024-29461": {"epss_score": 0.00554, "epss_percentile": 0.67441}, "CVE-2024-29466": {"epss_score": 0.00843, "epss_percentile": 0.74259}, "CVE-2024-29469": {"epss_score": 0.00473, "epss_percentile": 0.641}, "CVE-2024-29470": {"epss_score": 0.00473, "epss_percentile": 0.641}, "CVE-2024-29471": {"epss_score": 0.00092, "epss_percentile": 0.26419}, "CVE-2024-29472": {"epss_score": 0.00092, "epss_percentile": 0.26419}, "CVE-2024-29473": {"epss_score": 0.00405, "epss_percentile": 0.60465}, "CVE-2024-29474": {"epss_score": 0.0075, "epss_percentile": 0.72615}, "CVE-2024-29477": {"epss_score": 0.00143, "epss_percentile": 0.35212}, "CVE-2024-29489": {"epss_score": 0.00043, "epss_percentile": 0.13325}, "CVE-2024-29499": {"epss_score": 0.00064, "epss_percentile": 0.2042}, "CVE-2024-29500": {"epss_score": 0.00421, "epss_percentile": 0.61499}, "CVE-2024-29502": {"epss_score": 0.00183, "epss_percentile": 0.40357}, "CVE-2024-29504": {"epss_score": 0.00461, "epss_percentile": 0.6356}, "CVE-2024-29506": {"epss_score": 0.00111, "epss_percentile": 0.3035}, "CVE-2024-29507": {"epss_score": 0.00115, "epss_percentile": 0.31023}, "CVE-2024-29508": {"epss_score": 0.00034, "epss_percentile": 0.09796}, "CVE-2024-29509": {"epss_score": 0.0215, "epss_percentile": 0.83779}, "CVE-2024-29510": {"epss_score": 0.06906, "epss_percentile": 0.9111}, "CVE-2024-29511": {"epss_score": 0.00781, "epss_percentile": 0.7318}, "CVE-2024-29513": {"epss_score": 0.00073, "epss_percentile": 0.22615}, "CVE-2024-29514": {"epss_score": 0.02011, "epss_percentile": 0.8325}, "CVE-2024-29515": {"epss_score": 0.01507, "epss_percentile": 0.80753}, "CVE-2024-29640": {"epss_score": 0.02418, "epss_percentile": 0.84695}, "CVE-2024-29643": {"epss_score": 0.00115, "epss_percentile": 0.31016}, "CVE-2024-29644": {"epss_score": 0.00699, "epss_percentile": 0.71451}, "CVE-2024-29645": {"epss_score": 0.00044, "epss_percentile": 0.13513}, "CVE-2024-29646": {"epss_score": 0.0094, "epss_percentile": 0.7573}, "CVE-2024-29650": {"epss_score": 0.02175, "epss_percentile": 0.83883}, "CVE-2024-29651": {"epss_score": 0.02788, "epss_percentile": 0.8566}, "CVE-2024-29660": {"epss_score": 0.00036, "epss_percentile": 0.10512}, "CVE-2024-29661": {"epss_score": 0.00242, "epss_percentile": 0.47397}, "CVE-2024-29666": {"epss_score": 0.00321, "epss_percentile": 0.54646}, "CVE-2024-29667": {"epss_score": 0.00543, "epss_percentile": 0.67103}, "CVE-2024-29671": {"epss_score": 0.21221, "epss_percentile": 0.95479}, "CVE-2024-29672": {"epss_score": 0.05637, "epss_percentile": 0.90072}, "CVE-2024-29684": {"epss_score": 0.03025, "epss_percentile": 0.86239}, "CVE-2024-29686": {"epss_score": 0.03458, "epss_percentile": 0.87177}, "CVE-2024-29720": {"epss_score": 0.00016, "epss_percentile": 0.02956}, "CVE-2024-29723": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2024-29724": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2024-29725": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2024-29726": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2024-29727": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2024-29728": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2024-29729": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2024-29730": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2024-29731": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2024-29732": {"epss_score": 0.00138, "epss_percentile": 0.34441}, "CVE-2024-29733": {"epss_score": 0.00103, "epss_percentile": 0.29066}, "CVE-2024-29734": {"epss_score": 0.0006, "epss_percentile": 0.19107}, "CVE-2024-29735": {"epss_score": 0.00289, "epss_percentile": 0.52075}, "CVE-2024-29736": {"epss_score": 0.00351, "epss_percentile": 0.57047}, "CVE-2024-29737": {"epss_score": 0.00811, "epss_percentile": 0.73732}, "CVE-2024-29738": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2024-29739": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2024-29740": {"epss_score": 0.00015, "epss_percentile": 0.02513}, "CVE-2024-29741": {"epss_score": 3e-05, "epss_percentile": 0.00104}, "CVE-2024-29742": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2024-29743": {"epss_score": 0.00016, "epss_percentile": 0.02987}, "CVE-2024-29744": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2024-29745": {"epss_score": 0.00205, "epss_percentile": 0.42672}, "CVE-2024-29746": {"epss_score": 0.00011, "epss_percentile": 0.01093}, "CVE-2024-29747": {"epss_score": 0.00021, "epss_percentile": 0.04702}, "CVE-2024-29748": {"epss_score": 0.00382, "epss_percentile": 0.59053}, "CVE-2024-29749": {"epss_score": 0.00015, "epss_percentile": 0.02513}, "CVE-2024-29750": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2024-29751": {"epss_score": 0.00017, "epss_percentile": 0.0309}, "CVE-2024-29752": {"epss_score": 0.00016, "epss_percentile": 0.02796}, "CVE-2024-29753": {"epss_score": 0.00016, "epss_percentile": 0.02987}, "CVE-2024-29754": {"epss_score": 0.00021, "epss_percentile": 0.04735}, "CVE-2024-29755": {"epss_score": 0.0001, "epss_percentile": 0.00911}, "CVE-2024-29756": {"epss_score": 0.00061, "epss_percentile": 0.1928}, "CVE-2024-29757": {"epss_score": 3e-05, "epss_percentile": 0.00098}, "CVE-2024-29758": {"epss_score": 0.00157, "epss_percentile": 0.37082}, "CVE-2024-29759": {"epss_score": 0.00196, "epss_percentile": 0.41801}, "CVE-2024-29760": {"epss_score": 0.00269, "epss_percentile": 0.50181}, "CVE-2024-29761": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29762": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29763": {"epss_score": 0.00269, "epss_percentile": 0.50181}, "CVE-2024-29764": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29765": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29766": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29767": {"epss_score": 0.00197, "epss_percentile": 0.4189}, "CVE-2024-29768": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-29769": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29770": {"epss_score": 0.00274, "epss_percentile": 0.50565}, "CVE-2024-29771": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29772": {"epss_score": 0.00197, "epss_percentile": 0.41947}, "CVE-2024-29773": {"epss_score": 0.00105, "epss_percentile": 0.29301}, "CVE-2024-29774": {"epss_score": 0.00314, "epss_percentile": 0.5409}, "CVE-2024-29775": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29776": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2024-29777": {"epss_score": 0.00265, "epss_percentile": 0.49816}, "CVE-2024-29778": {"epss_score": 0.00036, "epss_percentile": 0.10365}, "CVE-2024-29779": {"epss_score": 0.00027, "epss_percentile": 0.06829}, "CVE-2024-29780": {"epss_score": 0.0003, "epss_percentile": 0.08294}, "CVE-2024-29781": {"epss_score": 0.00489, "epss_percentile": 0.64912}, "CVE-2024-29782": {"epss_score": 0.00022, "epss_percentile": 0.04958}, "CVE-2024-29783": {"epss_score": 0.00021, "epss_percentile": 0.04811}, "CVE-2024-29784": {"epss_score": 0.00029, "epss_percentile": 0.07586}, "CVE-2024-29785": {"epss_score": 0.0003, "epss_percentile": 0.08294}, "CVE-2024-29786": {"epss_score": 0.00989, "epss_percentile": 0.76359}, "CVE-2024-29787": {"epss_score": 0.00031, "epss_percentile": 0.08656}, "CVE-2024-29788": {"epss_score": 0.00194, "epss_percentile": 0.4157}, "CVE-2024-29789": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29790": {"epss_score": 0.00269, "epss_percentile": 0.50181}, "CVE-2024-29791": {"epss_score": 0.00274, "epss_percentile": 0.50565}, "CVE-2024-29792": {"epss_score": 0.00348, "epss_percentile": 0.56803}, "CVE-2024-29793": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-29794": {"epss_score": 0.00218, "epss_percentile": 0.44343}, "CVE-2024-29795": {"epss_score": 0.00194, "epss_percentile": 0.4157}, "CVE-2024-29796": {"epss_score": 0.00194, "epss_percentile": 0.4157}, "CVE-2024-29797": {"epss_score": 0.00194, "epss_percentile": 0.4157}, "CVE-2024-29798": {"epss_score": 0.00194, "epss_percentile": 0.4157}, "CVE-2024-29799": {"epss_score": 0.00194, "epss_percentile": 0.4157}, "CVE-2024-29800": {"epss_score": 0.00895, "epss_percentile": 0.75092}, "CVE-2024-29801": {"epss_score": 0.00194, "epss_percentile": 0.4157}, "CVE-2024-29802": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29803": {"epss_score": 0.00194, "epss_percentile": 0.4157}, "CVE-2024-29804": {"epss_score": 0.00169, "epss_percentile": 0.38617}, "CVE-2024-29805": {"epss_score": 0.00156, "epss_percentile": 0.36942}, "CVE-2024-29806": {"epss_score": 0.00211, "epss_percentile": 0.43707}, "CVE-2024-29807": {"epss_score": 0.00178, "epss_percentile": 0.39667}, "CVE-2024-29808": {"epss_score": 0.00084, "epss_percentile": 0.25008}, "CVE-2024-29809": {"epss_score": 0.00084, "epss_percentile": 0.25008}, "CVE-2024-29810": {"epss_score": 0.00084, "epss_percentile": 0.25008}, "CVE-2024-29811": {"epss_score": 0.00178, "epss_percentile": 0.39667}, "CVE-2024-29812": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-29813": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-29814": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29815": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-29816": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-29817": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29818": {"epss_score": 0.00187, "epss_percentile": 0.40699}, "CVE-2024-29819": {"epss_score": 0.00124, "epss_percentile": 0.32425}, "CVE-2024-29820": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29821": {"epss_score": 0.00595, "epss_percentile": 0.68679}, "CVE-2024-29822": {"epss_score": 0.00593, "epss_percentile": 0.68645}, "CVE-2024-29823": {"epss_score": 0.03087, "epss_percentile": 0.86388}, "CVE-2024-29824": {"epss_score": 0.94089, "epss_percentile": 0.999}, "CVE-2024-29825": {"epss_score": 0.03087, "epss_percentile": 0.86388}, "CVE-2024-29826": {"epss_score": 0.03087, "epss_percentile": 0.86388}, "CVE-2024-29827": {"epss_score": 0.00593, "epss_percentile": 0.68645}, "CVE-2024-29828": {"epss_score": 0.00186, "epss_percentile": 0.40679}, "CVE-2024-29829": {"epss_score": 0.00186, "epss_percentile": 0.40679}, "CVE-2024-29830": {"epss_score": 0.00186, "epss_percentile": 0.40679}, "CVE-2024-29831": {"epss_score": 0.00344, "epss_percentile": 0.5648}, "CVE-2024-29832": {"epss_score": 0.00132, "epss_percentile": 0.33572}, "CVE-2024-29833": {"epss_score": 0.00051, "epss_percentile": 0.16023}, "CVE-2024-29834": {"epss_score": 0.00166, "epss_percentile": 0.38194}, "CVE-2024-29836": {"epss_score": 0.00227, "epss_percentile": 0.45461}, "CVE-2024-29837": {"epss_score": 0.00199, "epss_percentile": 0.4211}, "CVE-2024-29838": {"epss_score": 0.00168, "epss_percentile": 0.38495}, "CVE-2024-29839": {"epss_score": 0.00167, "epss_percentile": 0.3831}, "CVE-2024-29840": {"epss_score": 0.00167, "epss_percentile": 0.3831}, "CVE-2024-29841": {"epss_score": 0.00167, "epss_percentile": 0.3831}, "CVE-2024-29842": {"epss_score": 0.00167, "epss_percentile": 0.3831}, "CVE-2024-29843": {"epss_score": 0.00146, "epss_percentile": 0.35539}, "CVE-2024-29844": {"epss_score": 0.00089, "epss_percentile": 0.25977}, "CVE-2024-29846": {"epss_score": 0.00186, "epss_percentile": 0.40679}, "CVE-2024-29847": {"epss_score": 0.6389, "epss_percentile": 0.98354}, "CVE-2024-29848": {"epss_score": 0.30731, "epss_percentile": 0.96564}, "CVE-2024-29849": {"epss_score": 0.53623, "epss_percentile": 0.97886}, "CVE-2024-29850": {"epss_score": 0.00756, "epss_percentile": 0.72734}, "CVE-2024-29851": {"epss_score": 0.00397, "epss_percentile": 0.59963}, "CVE-2024-29852": {"epss_score": 0.00321, "epss_percentile": 0.54689}, "CVE-2024-29853": {"epss_score": 0.00034, "epss_percentile": 0.09716}, "CVE-2024-29855": {"epss_score": 0.19462, "epss_percentile": 0.95188}, "CVE-2024-29857": {"epss_score": 0.00337, "epss_percentile": 0.56022}, "CVE-2024-29858": {"epss_score": 0.00095, "epss_percentile": 0.27141}, "CVE-2024-29859": {"epss_score": 0.00087, "epss_percentile": 0.25526}, "CVE-2024-29862": {"epss_score": 0.00102, "epss_percentile": 0.28896}, "CVE-2024-29863": {"epss_score": 0.02717, "epss_percentile": 0.85511}, "CVE-2024-29864": {"epss_score": 0.00494, "epss_percentile": 0.65072}, "CVE-2024-29865": {"epss_score": 0.00511, "epss_percentile": 0.65823}, "CVE-2024-29866": {"epss_score": 0.00115, "epss_percentile": 0.30991}, "CVE-2024-29868": {"epss_score": 0.74201, "epss_percentile": 0.98792}, "CVE-2024-29869": {"epss_score": 0.00092, "epss_percentile": 0.2651}, "CVE-2024-29870": {"epss_score": 0.00801, "epss_percentile": 0.73569}, "CVE-2024-29871": {"epss_score": 0.00777, "epss_percentile": 0.7312}, "CVE-2024-29872": {"epss_score": 0.00777, "epss_percentile": 0.7312}, "CVE-2024-29873": {"epss_score": 0.00777, "epss_percentile": 0.7312}, "CVE-2024-29874": {"epss_score": 0.00777, "epss_percentile": 0.7312}, "CVE-2024-29875": {"epss_score": 0.00777, "epss_percentile": 0.7312}, "CVE-2024-29876": {"epss_score": 0.00763, "epss_percentile": 0.72853}, "CVE-2024-29877": {"epss_score": 0.00079, "epss_percentile": 0.23915}, "CVE-2024-29878": {"epss_score": 0.00092, "epss_percentile": 0.2648}, "CVE-2024-29879": {"epss_score": 0.00079, "epss_percentile": 0.23915}, "CVE-2024-29880": {"epss_score": 2e-05, "epss_percentile": 0.00043}, "CVE-2024-29881": {"epss_score": 0.03986, "epss_percentile": 0.88065}, "CVE-2024-29882": {"epss_score": 0.03404, "epss_percentile": 0.87073}, "CVE-2024-29883": {"epss_score": 0.00266, "epss_percentile": 0.49883}, "CVE-2024-29885": {"epss_score": 0.00543, "epss_percentile": 0.67091}, "CVE-2024-29886": {"epss_score": 0.00082, "epss_percentile": 0.24551}, "CVE-2024-29887": {"epss_score": 0.00041, "epss_percentile": 0.12414}, "CVE-2024-29888": {"epss_score": 0.00543, "epss_percentile": 0.67088}, "CVE-2024-29889": {"epss_score": 0.55536, "epss_percentile": 0.97982}, "CVE-2024-29890": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-29891": {"epss_score": 0.00832, "epss_percentile": 0.74065}, "CVE-2024-29892": {"epss_score": 0.00171, "epss_percentile": 0.38885}, "CVE-2024-29893": {"epss_score": 0.00606, "epss_percentile": 0.69023}, "CVE-2024-29894": {"epss_score": 0.00162, "epss_percentile": 0.37736}, "CVE-2024-29895": {"epss_score": 0.93261, "epss_percentile": 0.9979}, "CVE-2024-29896": {"epss_score": 0.00726, "epss_percentile": 0.72077}, "CVE-2024-29897": {"epss_score": 0.00061, "epss_percentile": 0.19253}, "CVE-2024-29898": {"epss_score": 0.00061, "epss_percentile": 0.19253}, "CVE-2024-29900": {"epss_score": 0.00293, "epss_percentile": 0.52327}, "CVE-2024-29901": {"epss_score": 0.00351, "epss_percentile": 0.57074}, "CVE-2024-29902": {"epss_score": 0.0021, "epss_percentile": 0.43433}, "CVE-2024-29903": {"epss_score": 0.00381, "epss_percentile": 0.58982}, "CVE-2024-29904": {"epss_score": 0.00569, "epss_percentile": 0.67924}, "CVE-2024-29905": {"epss_score": 0.00076, "epss_percentile": 0.23168}, "CVE-2024-29906": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-29907": {"epss_score": 0.00144, "epss_percentile": 0.35232}, "CVE-2024-29908": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-29909": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29910": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-29911": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-29912": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29913": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-29914": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29915": {"epss_score": 0.00348, "epss_percentile": 0.56803}, "CVE-2024-29916": {"epss_score": 0.00074, "epss_percentile": 0.2274}, "CVE-2024-29917": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-29918": {"epss_score": 0.00294, "epss_percentile": 0.52389}, "CVE-2024-29919": {"epss_score": 0.00321, "epss_percentile": 0.54648}, "CVE-2024-29920": {"epss_score": 0.00126, "epss_percentile": 0.32686}, "CVE-2024-29921": {"epss_score": 0.00122, "epss_percentile": 0.32084}, "CVE-2024-29922": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-29923": {"epss_score": 0.00269, "epss_percentile": 0.50181}, "CVE-2024-29924": {"epss_score": 0.00215, "epss_percentile": 0.44107}, "CVE-2024-29925": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-29926": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-29927": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-29928": {"epss_score": 0.00315, "epss_percentile": 0.5417}, "CVE-2024-29929": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-29930": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-29931": {"epss_score": 0.10475, "epss_percentile": 0.92999}, "CVE-2024-29932": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-29933": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-29934": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-29935": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2024-29936": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-29937": {"epss_score": 0.06857, "epss_percentile": 0.91079}, "CVE-2024-29941": {"epss_score": 0.00064, "epss_percentile": 0.20135}, "CVE-2024-29943": {"epss_score": 0.51074, "epss_percentile": 0.97763}, "CVE-2024-29944": {"epss_score": 0.0116, "epss_percentile": 0.78132}, "CVE-2024-29945": {"epss_score": 0.00148, "epss_percentile": 0.35902}, "CVE-2024-29946": {"epss_score": 0.00417, "epss_percentile": 0.61259}, "CVE-2024-29947": {"epss_score": 0.00028, "epss_percentile": 0.07559}, "CVE-2024-29948": {"epss_score": 0.00053, "epss_percentile": 0.16693}, "CVE-2024-29949": {"epss_score": 0.00152, "epss_percentile": 0.36498}, "CVE-2024-29950": {"epss_score": 0.00175, "epss_percentile": 0.39286}, "CVE-2024-29951": {"epss_score": 0.00067, "epss_percentile": 0.21159}, "CVE-2024-29952": {"epss_score": 0.00062, "epss_percentile": 0.19695}, "CVE-2024-29953": {"epss_score": 0.00366, "epss_percentile": 0.58076}, "CVE-2024-29954": {"epss_score": 0.00054, "epss_percentile": 0.17345}, "CVE-2024-29955": {"epss_score": 0.00106, "epss_percentile": 0.29472}, "CVE-2024-29956": {"epss_score": 0.00146, "epss_percentile": 0.35617}, "CVE-2024-29957": {"epss_score": 0.00286, "epss_percentile": 0.51742}, "CVE-2024-29958": {"epss_score": 0.00286, "epss_percentile": 0.51742}, "CVE-2024-29959": {"epss_score": 0.00333, "epss_percentile": 0.55637}, "CVE-2024-29960": {"epss_score": 0.00124, "epss_percentile": 0.32412}, "CVE-2024-29961": {"epss_score": 0.01239, "epss_percentile": 0.78798}, "CVE-2024-29962": {"epss_score": 0.00091, "epss_percentile": 0.26281}, "CVE-2024-29963": {"epss_score": 0.00079, "epss_percentile": 0.23819}, "CVE-2024-29964": {"epss_score": 0.00224, "epss_percentile": 0.44976}, "CVE-2024-29965": {"epss_score": 0.00234, "epss_percentile": 0.46104}, "CVE-2024-29966": {"epss_score": 0.00395, "epss_percentile": 0.59842}, "CVE-2024-29967": {"epss_score": 0.00084, "epss_percentile": 0.24878}, "CVE-2024-29968": {"epss_score": 0.00294, "epss_percentile": 0.52385}, "CVE-2024-29969": {"epss_score": 0.0017, "epss_percentile": 0.38747}, "CVE-2024-29970": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2024-29971": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2024-29972": {"epss_score": 0.92597, "epss_percentile": 0.9973}, "CVE-2024-29973": {"epss_score": 0.94082, "epss_percentile": 0.99899}, "CVE-2024-29974": {"epss_score": 0.47597, "epss_percentile": 0.97593}, "CVE-2024-29975": {"epss_score": 0.00267, "epss_percentile": 0.50007}, "CVE-2024-29976": {"epss_score": 0.05363, "epss_percentile": 0.89785}, "CVE-2024-29977": {"epss_score": 0.00155, "epss_percentile": 0.36878}, "CVE-2024-29978": {"epss_score": 0.00176, "epss_percentile": 0.39406}, "CVE-2024-29979": {"epss_score": 0.00071, "epss_percentile": 0.22217}, "CVE-2024-29980": {"epss_score": 0.00071, "epss_percentile": 0.22217}, "CVE-2024-29981": {"epss_score": 0.00577, "epss_percentile": 0.6816}, "CVE-2024-29982": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-29983": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-29984": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-29985": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-29986": {"epss_score": 0.00204, "epss_percentile": 0.42669}, "CVE-2024-29987": {"epss_score": 0.00263, "epss_percentile": 0.49473}, "CVE-2024-29988": {"epss_score": 0.66838, "epss_percentile": 0.98483}, "CVE-2024-29989": {"epss_score": 0.0051, "epss_percentile": 0.65794}, "CVE-2024-29990": {"epss_score": 0.08805, "epss_percentile": 0.92262}, "CVE-2024-29991": {"epss_score": 0.00268, "epss_percentile": 0.50095}, "CVE-2024-29992": {"epss_score": 0.008, "epss_percentile": 0.73558}, "CVE-2024-29993": {"epss_score": 0.03695, "epss_percentile": 0.87584}, "CVE-2024-29994": {"epss_score": 0.00397, "epss_percentile": 0.60017}, "CVE-2024-29995": {"epss_score": 0.06141, "epss_percentile": 0.90513}, "CVE-2024-29996": {"epss_score": 0.03014, "epss_percentile": 0.86206}, "CVE-2024-29997": {"epss_score": 0.00261, "epss_percentile": 0.49299}, "CVE-2024-29998": {"epss_score": 0.00248, "epss_percentile": 0.47928}, "CVE-2024-29999": {"epss_score": 0.00261, "epss_percentile": 0.49299}, "CVE-2024-2000": {"epss_score": 0.003, "epss_percentile": 0.52907}, "CVE-2024-2001": {"epss_score": 0.00088, "epss_percentile": 0.2567}, "CVE-2024-2002": {"epss_score": 0.00106, "epss_percentile": 0.29551}, "CVE-2024-2003": {"epss_score": 0.00084, "epss_percentile": 0.25012}, "CVE-2024-2004": {"epss_score": 0.00838, "epss_percentile": 0.74183}, "CVE-2024-2005": {"epss_score": 0.00073, "epss_percentile": 0.22647}, "CVE-2024-2006": {"epss_score": 0.01907, "epss_percentile": 0.82812}, "CVE-2024-2007": {"epss_score": 0.00088, "epss_percentile": 0.25713}, "CVE-2024-2008": {"epss_score": 0.0086, "epss_percentile": 0.74545}, "CVE-2024-2009": {"epss_score": 0.00087, "epss_percentile": 0.25551}, "CVE-2024-2010": {"epss_score": 0.00122, "epss_percentile": 0.32155}, "CVE-2024-2011": {"epss_score": 0.00592, "epss_percentile": 0.68626}, "CVE-2024-2012": {"epss_score": 0.00306, "epss_percentile": 0.5346}, "CVE-2024-2013": {"epss_score": 0.00104, "epss_percentile": 0.2917}, "CVE-2024-2014": {"epss_score": 0.00336, "epss_percentile": 0.55918}, "CVE-2024-2015": {"epss_score": 0.00138, "epss_percentile": 0.34374}, "CVE-2024-2016": {"epss_score": 0.00179, "epss_percentile": 0.39833}, "CVE-2024-2017": {"epss_score": 0.00238, "epss_percentile": 0.46755}, "CVE-2024-2018": {"epss_score": 0.00404, "epss_percentile": 0.6043}, "CVE-2024-2019": {"epss_score": 0.00951, "epss_percentile": 0.75871}, "CVE-2024-2020": {"epss_score": 0.01914, "epss_percentile": 0.82845}, "CVE-2024-2021": {"epss_score": 0.00098, "epss_percentile": 0.27663}, "CVE-2024-2022": {"epss_score": 0.83936, "epss_percentile": 0.99266}, "CVE-2024-2023": {"epss_score": 0.01369, "epss_percentile": 0.79793}, "CVE-2024-2024": {"epss_score": 0.22546, "epss_percentile": 0.9565}, "CVE-2024-2025": {"epss_score": 0.00836, "epss_percentile": 0.74145}, "CVE-2024-2026": {"epss_score": 0.00184, "epss_percentile": 0.40425}, "CVE-2024-2027": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-2028": {"epss_score": 0.00243, "epss_percentile": 0.47419}, "CVE-2024-2029": {"epss_score": 0.01829, "epss_percentile": 0.82441}, "CVE-2024-2030": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2024-2031": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-2032": {"epss_score": 0.00044, "epss_percentile": 0.1341}, "CVE-2024-2033": {"epss_score": 0.00243, "epss_percentile": 0.47452}, "CVE-2024-2035": {"epss_score": 0.00052, "epss_percentile": 0.16635}, "CVE-2024-2036": {"epss_score": 0.00341, "epss_percentile": 0.56337}, "CVE-2024-2038": {"epss_score": 0.00633, "epss_percentile": 0.6976}, "CVE-2024-2039": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-2040": {"epss_score": 0.00091, "epss_percentile": 0.26215}, "CVE-2024-2042": {"epss_score": 0.00228, "epss_percentile": 0.45463}, "CVE-2024-2043": {"epss_score": 0.00454, "epss_percentile": 0.63263}, "CVE-2024-2044": {"epss_score": 0.809, "epss_percentile": 0.99111}, "CVE-2024-2045": {"epss_score": 0.00109, "epss_percentile": 0.30028}, "CVE-2024-2047": {"epss_score": 0.01624, "epss_percentile": 0.81416}, "CVE-2024-2048": {"epss_score": 0.00187, "epss_percentile": 0.407}, "CVE-2024-2049": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2024-2050": {"epss_score": 0.00097, "epss_percentile": 0.27463}, "CVE-2024-2051": {"epss_score": 0.00269, "epss_percentile": 0.50105}, "CVE-2024-2052": {"epss_score": 0.00085, "epss_percentile": 0.25052}, "CVE-2024-2053": {"epss_score": 0.20661, "epss_percentile": 0.95396}, "CVE-2024-2054": {"epss_score": 0.85077, "epss_percentile": 0.99316}, "CVE-2024-2055": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2024-2056": {"epss_score": 0.05427, "epss_percentile": 0.89869}, "CVE-2024-2057": {"epss_score": 0.00046, "epss_percentile": 0.14078}, "CVE-2024-2058": {"epss_score": 0.00054, "epss_percentile": 0.17093}, "CVE-2024-2059": {"epss_score": 0.00054, "epss_percentile": 0.17093}, "CVE-2024-2060": {"epss_score": 0.00039, "epss_percentile": 0.1156}, "CVE-2024-2061": {"epss_score": 0.00039, "epss_percentile": 0.1156}, "CVE-2024-2062": {"epss_score": 0.00039, "epss_percentile": 0.1156}, "CVE-2024-2063": {"epss_score": 0.00057, "epss_percentile": 0.18054}, "CVE-2024-2064": {"epss_score": 0.00078, "epss_percentile": 0.23577}, "CVE-2024-2065": {"epss_score": 0.00098, "epss_percentile": 0.27652}, "CVE-2024-2066": {"epss_score": 0.00045, "epss_percentile": 0.13915}, "CVE-2024-2067": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2024-2068": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2024-2069": {"epss_score": 0.00036, "epss_percentile": 0.10345}, "CVE-2024-2070": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2024-2071": {"epss_score": 0.00098, "epss_percentile": 0.27652}, "CVE-2024-2072": {"epss_score": 0.00098, "epss_percentile": 0.27652}, "CVE-2024-2073": {"epss_score": 0.00072, "epss_percentile": 0.22342}, "CVE-2024-2074": {"epss_score": 0.00431, "epss_percentile": 0.62039}, "CVE-2024-2075": {"epss_score": 0.00085, "epss_percentile": 0.2513}, "CVE-2024-2076": {"epss_score": 0.00106, "epss_percentile": 0.2949}, "CVE-2024-2077": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-2078": {"epss_score": 0.00078, "epss_percentile": 0.23617}, "CVE-2024-2079": {"epss_score": 0.00134, "epss_percentile": 0.33786}, "CVE-2024-2080": {"epss_score": 0.00221, "epss_percentile": 0.44644}, "CVE-2024-2081": {"epss_score": 0.00396, "epss_percentile": 0.59886}, "CVE-2024-2082": {"epss_score": 0.01255, "epss_percentile": 0.78928}, "CVE-2024-2083": {"epss_score": 0.00819, "epss_percentile": 0.73864}, "CVE-2024-2084": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-2085": {"epss_score": 0.00134, "epss_percentile": 0.33786}, "CVE-2024-2086": {"epss_score": 0.00718, "epss_percentile": 0.71922}, "CVE-2024-2087": {"epss_score": 0.01684, "epss_percentile": 0.81742}, "CVE-2024-2088": {"epss_score": 0.00434, "epss_percentile": 0.62316}, "CVE-2024-2089": {"epss_score": 0.00234, "epss_percentile": 0.46117}, "CVE-2024-2090": {"epss_score": 0.00241, "epss_percentile": 0.47331}, "CVE-2024-2091": {"epss_score": 0.00195, "epss_percentile": 0.41667}, "CVE-2024-2092": {"epss_score": 0.00323, "epss_percentile": 0.5492}, "CVE-2024-2093": {"epss_score": 0.01135, "epss_percentile": 0.7791}, "CVE-2024-2097": {"epss_score": 0.00281, "epss_percentile": 0.51135}, "CVE-2024-2098": {"epss_score": 0.01745, "epss_percentile": 0.82065}, "CVE-2024-2101": {"epss_score": 0.00665, "epss_percentile": 0.70673}, "CVE-2024-2102": {"epss_score": 0.00222, "epss_percentile": 0.44729}, "CVE-2024-2103": {"epss_score": 0.00078, "epss_percentile": 0.23655}, "CVE-2024-2104": {"epss_score": 0.00033, "epss_percentile": 0.0918}, "CVE-2024-2105": {"epss_score": 0.0003, "epss_percentile": 0.08146}, "CVE-2024-2106": {"epss_score": 0.0188, "epss_percentile": 0.82675}, "CVE-2024-2107": {"epss_score": 0.01331, "epss_percentile": 0.79518}, "CVE-2024-2108": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-2109": {"epss_score": 0.004, "epss_percentile": 0.60189}, "CVE-2024-2110": {"epss_score": 0.00102, "epss_percentile": 0.28749}, "CVE-2024-2111": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2024-2112": {"epss_score": 0.00966, "epss_percentile": 0.76052}, "CVE-2024-2113": {"epss_score": 0.00186, "epss_percentile": 0.40639}, "CVE-2024-2115": {"epss_score": 0.0027, "epss_percentile": 0.50271}, "CVE-2024-2116": {"epss_score": 0.01497, "epss_percentile": 0.80686}, "CVE-2024-2117": {"epss_score": 0.00204, "epss_percentile": 0.4266}, "CVE-2024-2118": {"epss_score": 0.00146, "epss_percentile": 0.35631}, "CVE-2024-2119": {"epss_score": 0.01998, "epss_percentile": 0.83209}, "CVE-2024-2120": {"epss_score": 0.00181, "epss_percentile": 0.40085}, "CVE-2024-2121": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2024-2122": {"epss_score": 0.05097, "epss_percentile": 0.89495}, "CVE-2024-2123": {"epss_score": 0.4129, "epss_percentile": 0.97264}, "CVE-2024-2124": {"epss_score": 0.00228, "epss_percentile": 0.45463}, "CVE-2024-2125": {"epss_score": 0.00371, "epss_percentile": 0.58417}, "CVE-2024-2126": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-2127": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-2128": {"epss_score": 0.00104, "epss_percentile": 0.29235}, "CVE-2024-2129": {"epss_score": 0.00148, "epss_percentile": 0.35859}, "CVE-2024-2130": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-2131": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-2132": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-2133": {"epss_score": 0.00054, "epss_percentile": 0.17247}, "CVE-2024-2134": {"epss_score": 0.00054, "epss_percentile": 0.17202}, "CVE-2024-2135": {"epss_score": 0.00095, "epss_percentile": 0.27137}, "CVE-2024-2136": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2137": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-2138": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-2139": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2140": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-2141": {"epss_score": 0.00138, "epss_percentile": 0.34502}, "CVE-2024-2142": {"epss_score": 0.00126, "epss_percentile": 0.32771}, "CVE-2024-2143": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-2144": {"epss_score": 0.00126, "epss_percentile": 0.32771}, "CVE-2024-2145": {"epss_score": 0.0012, "epss_percentile": 0.31761}, "CVE-2024-2146": {"epss_score": 0.00168, "epss_percentile": 0.38494}, "CVE-2024-2147": {"epss_score": 0.00048, "epss_percentile": 0.15184}, "CVE-2024-2148": {"epss_score": 0.00107, "epss_percentile": 0.29673}, "CVE-2024-2149": {"epss_score": 0.00071, "epss_percentile": 0.22219}, "CVE-2024-2150": {"epss_score": 0.00054, "epss_percentile": 0.17294}, "CVE-2024-2151": {"epss_score": 0.00117, "epss_percentile": 0.31241}, "CVE-2024-2152": {"epss_score": 0.00081, "epss_percentile": 0.24313}, "CVE-2024-2153": {"epss_score": 0.00082, "epss_percentile": 0.24515}, "CVE-2024-2154": {"epss_score": 0.00068, "epss_percentile": 0.21311}, "CVE-2024-2155": {"epss_score": 0.00067, "epss_percentile": 0.21172}, "CVE-2024-2156": {"epss_score": 0.00034, "epss_percentile": 0.09731}, "CVE-2024-2159": {"epss_score": 0.0019, "epss_percentile": 0.41128}, "CVE-2024-2161": {"epss_score": 0.00568, "epss_percentile": 0.67907}, "CVE-2024-2162": {"epss_score": 0.00717, "epss_percentile": 0.71877}, "CVE-2024-2163": {"epss_score": 0.00235, "epss_percentile": 0.4624}, "CVE-2024-2165": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-2166": {"epss_score": 0.00604, "epss_percentile": 0.68964}, "CVE-2024-2168": {"epss_score": 0.00049, "epss_percentile": 0.15467}, "CVE-2024-2169": {"epss_score": 0.01173, "epss_percentile": 0.7824}, "CVE-2024-2170": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2024-2171": {"epss_score": 0.00071, "epss_percentile": 0.22184}, "CVE-2024-2172": {"epss_score": 0.01015, "epss_percentile": 0.76665}, "CVE-2024-2173": {"epss_score": 0.00072, "epss_percentile": 0.22431}, "CVE-2024-2174": {"epss_score": 0.00098, "epss_percentile": 0.27677}, "CVE-2024-2175": {"epss_score": 0.00053, "epss_percentile": 0.16934}, "CVE-2024-2176": {"epss_score": 0.0046, "epss_percentile": 0.63502}, "CVE-2024-2177": {"epss_score": 0.00141, "epss_percentile": 0.34917}, "CVE-2024-2178": {"epss_score": 0.00368, "epss_percentile": 0.58166}, "CVE-2024-2179": {"epss_score": 0.00123, "epss_percentile": 0.32184}, "CVE-2024-2180": {"epss_score": 0.00042, "epss_percentile": 0.12936}, "CVE-2024-2181": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-2182": {"epss_score": 0.00421, "epss_percentile": 0.61531}, "CVE-2024-2183": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-2184": {"epss_score": 0.00172, "epss_percentile": 0.39014}, "CVE-2024-2185": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-2186": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-2187": {"epss_score": 0.00214, "epss_percentile": 0.43973}, "CVE-2024-2188": {"epss_score": 0.02071, "epss_percentile": 0.83483}, "CVE-2024-2189": {"epss_score": 0.00301, "epss_percentile": 0.53001}, "CVE-2024-2191": {"epss_score": 0.00182, "epss_percentile": 0.40193}, "CVE-2024-2193": {"epss_score": 0.01203, "epss_percentile": 0.78496}, "CVE-2024-2194": {"epss_score": 0.35394, "epss_percentile": 0.96904}, "CVE-2024-2195": {"epss_score": 0.08378, "epss_percentile": 0.92017}, "CVE-2024-2196": {"epss_score": 0.00736, "epss_percentile": 0.72305}, "CVE-2024-2197": {"epss_score": 0.00025, "epss_percentile": 0.06058}, "CVE-2024-2198": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2024-2199": {"epss_score": 0.00133, "epss_percentile": 0.33722}, "CVE-2024-2200": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2024-2201": {"epss_score": 0.00032, "epss_percentile": 0.08845}, "CVE-2024-2202": {"epss_score": 0.00126, "epss_percentile": 0.32771}, "CVE-2024-2203": {"epss_score": 0.00463, "epss_percentile": 0.63686}, "CVE-2024-2204": {"epss_score": 0.00029, "epss_percentile": 0.07635}, "CVE-2024-2206": {"epss_score": 0.00131, "epss_percentile": 0.33397}, "CVE-2024-2207": {"epss_score": 0.00046, "epss_percentile": 0.14324}, "CVE-2024-2208": {"epss_score": 0.00055, "epss_percentile": 0.17457}, "CVE-2024-2209": {"epss_score": 0.00058, "epss_percentile": 0.18608}, "CVE-2024-2210": {"epss_score": 0.00157, "epss_percentile": 0.37079}, "CVE-2024-2211": {"epss_score": 0.00084, "epss_percentile": 0.2495}, "CVE-2024-2212": {"epss_score": 0.00125, "epss_percentile": 0.32496}, "CVE-2024-2213": {"epss_score": 0.00017, "epss_percentile": 0.03214}, "CVE-2024-2214": {"epss_score": 0.00081, "epss_percentile": 0.24332}, "CVE-2024-2215": {"epss_score": 0.00043, "epss_percentile": 0.12973}, "CVE-2024-2216": {"epss_score": 0.00114, "epss_percentile": 0.30747}, "CVE-2024-2217": {"epss_score": 0.00202, "epss_percentile": 0.42409}, "CVE-2024-2218": {"epss_score": 0.00144, "epss_percentile": 0.35327}, "CVE-2024-2220": {"epss_score": 0.00276, "epss_percentile": 0.50715}, "CVE-2024-2221": {"epss_score": 0.25531, "epss_percentile": 0.96038}, "CVE-2024-2222": {"epss_score": 0.00222, "epss_percentile": 0.44757}, "CVE-2024-2223": {"epss_score": 0.00496, "epss_percentile": 0.65135}, "CVE-2024-2224": {"epss_score": 0.00647, "epss_percentile": 0.70197}, "CVE-2024-2226": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2227": {"epss_score": 0.00609, "epss_percentile": 0.69092}, "CVE-2024-2228": {"epss_score": 0.00209, "epss_percentile": 0.43404}, "CVE-2024-2229": {"epss_score": 0.0004, "epss_percentile": 0.12181}, "CVE-2024-2231": {"epss_score": 0.00418, "epss_percentile": 0.61271}, "CVE-2024-2232": {"epss_score": 0.0035, "epss_percentile": 0.56971}, "CVE-2024-2233": {"epss_score": 0.0009, "epss_percentile": 0.26147}, "CVE-2024-2234": {"epss_score": 0.00155, "epss_percentile": 0.36841}, "CVE-2024-2235": {"epss_score": 0.0009, "epss_percentile": 0.26147}, "CVE-2024-2236": {"epss_score": 0.00222, "epss_percentile": 0.44723}, "CVE-2024-2237": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-2238": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-2239": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-2240": {"epss_score": 0.00314, "epss_percentile": 0.54118}, "CVE-2024-2241": {"epss_score": 0.00141, "epss_percentile": 0.34919}, "CVE-2024-2242": {"epss_score": 0.56285, "epss_percentile": 0.98017}, "CVE-2024-2243": {"epss_score": 0.00079, "epss_percentile": 0.23828}, "CVE-2024-2244": {"epss_score": 0.0017, "epss_percentile": 0.38668}, "CVE-2024-2245": {"epss_score": 0.00198, "epss_percentile": 0.42088}, "CVE-2024-2247": {"epss_score": 0.02607, "epss_percentile": 0.85227}, "CVE-2024-2248": {"epss_score": 0.0071, "epss_percentile": 0.71717}, "CVE-2024-2249": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-2250": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2024-2252": {"epss_score": 0.00173, "epss_percentile": 0.39098}, "CVE-2024-2253": {"epss_score": 0.00235, "epss_percentile": 0.4624}, "CVE-2024-2254": {"epss_score": 0.00112, "epss_percentile": 0.30424}, "CVE-2024-2255": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2024-2256": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2024-2257": {"epss_score": 0.03633, "epss_percentile": 0.87476}, "CVE-2024-2258": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-2259": {"epss_score": 0.00733, "epss_percentile": 0.7221}, "CVE-2024-2260": {"epss_score": 0.00083, "epss_percentile": 0.24643}, "CVE-2024-2261": {"epss_score": 0.00243, "epss_percentile": 0.47452}, "CVE-2024-2262": {"epss_score": 0.00167, "epss_percentile": 0.38291}, "CVE-2024-2263": {"epss_score": 0.00089, "epss_percentile": 0.2581}, "CVE-2024-2264": {"epss_score": 0.00048, "epss_percentile": 0.14975}, "CVE-2024-2265": {"epss_score": 0.00134, "epss_percentile": 0.33835}, "CVE-2024-2266": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2024-2267": {"epss_score": 0.00114, "epss_percentile": 0.30807}, "CVE-2024-2268": {"epss_score": 0.00058, "epss_percentile": 0.18574}, "CVE-2024-2269": {"epss_score": 0.00049, "epss_percentile": 0.15499}, "CVE-2024-2270": {"epss_score": 0.00076, "epss_percentile": 0.23131}, "CVE-2024-2271": {"epss_score": 0.00049, "epss_percentile": 0.15499}, "CVE-2024-2272": {"epss_score": 0.00049, "epss_percentile": 0.15499}, "CVE-2024-2273": {"epss_score": 0.00193, "epss_percentile": 0.41498}, "CVE-2024-2274": {"epss_score": 0.00096, "epss_percentile": 0.27338}, "CVE-2024-2275": {"epss_score": 0.00057, "epss_percentile": 0.18054}, "CVE-2024-2276": {"epss_score": 0.00096, "epss_percentile": 0.27338}, "CVE-2024-2277": {"epss_score": 0.00084, "epss_percentile": 0.24954}, "CVE-2024-2278": {"epss_score": 0.00139, "epss_percentile": 0.34616}, "CVE-2024-2279": {"epss_score": 0.00667, "epss_percentile": 0.70712}, "CVE-2024-2280": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2024-2281": {"epss_score": 0.00076, "epss_percentile": 0.23256}, "CVE-2024-2282": {"epss_score": 0.00053, "epss_percentile": 0.16993}, "CVE-2024-2283": {"epss_score": 0.00046, "epss_percentile": 0.14469}, "CVE-2024-2284": {"epss_score": 0.00101, "epss_percentile": 0.28712}, "CVE-2024-2285": {"epss_score": 0.00078, "epss_percentile": 0.23573}, "CVE-2024-2286": {"epss_score": 0.00173, "epss_percentile": 0.39098}, "CVE-2024-2287": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-2288": {"epss_score": 0.00266, "epss_percentile": 0.49946}, "CVE-2024-2289": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-2290": {"epss_score": 0.01104, "epss_percentile": 0.77595}, "CVE-2024-2291": {"epss_score": 0.00089, "epss_percentile": 0.25953}, "CVE-2024-2292": {"epss_score": 0.00047, "epss_percentile": 0.14818}, "CVE-2024-2293": {"epss_score": 0.00284, "epss_percentile": 0.51488}, "CVE-2024-2294": {"epss_score": 0.00496, "epss_percentile": 0.65156}, "CVE-2024-2295": {"epss_score": 0.00235, "epss_percentile": 0.4624}, "CVE-2024-2296": {"epss_score": 0.00133, "epss_percentile": 0.33697}, "CVE-2024-2297": {"epss_score": 0.00187, "epss_percentile": 0.40734}, "CVE-2024-2298": {"epss_score": 0.00066, "epss_percentile": 0.20874}, "CVE-2024-2299": {"epss_score": 0.00206, "epss_percentile": 0.42919}, "CVE-2024-2300": {"epss_score": 0.00066, "epss_percentile": 0.20944}, "CVE-2024-2301": {"epss_score": 0.00171, "epss_percentile": 0.38814}, "CVE-2024-2302": {"epss_score": 0.00982, "epss_percentile": 0.7629}, "CVE-2024-2303": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2024-2304": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-2305": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-2306": {"epss_score": 0.00148, "epss_percentile": 0.35843}, "CVE-2024-2307": {"epss_score": 8e-05, "epss_percentile": 0.00564}, "CVE-2024-2308": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-2309": {"epss_score": 0.00186, "epss_percentile": 0.40633}, "CVE-2024-2310": {"epss_score": 0.00139, "epss_percentile": 0.34663}, "CVE-2024-2311": {"epss_score": 0.00534, "epss_percentile": 0.66787}, "CVE-2024-2312": {"epss_score": 0.00029, "epss_percentile": 0.07739}, "CVE-2024-2313": {"epss_score": 0.00018, "epss_percentile": 0.03606}, "CVE-2024-2314": {"epss_score": 0.00027, "epss_percentile": 0.06903}, "CVE-2024-2315": {"epss_score": 0.00078, "epss_percentile": 0.23555}, "CVE-2024-2316": {"epss_score": 0.00073, "epss_percentile": 0.22638}, "CVE-2024-2317": {"epss_score": 0.00043, "epss_percentile": 0.13005}, "CVE-2024-2318": {"epss_score": 0.00327, "epss_percentile": 0.55145}, "CVE-2024-2319": {"epss_score": 0.0009, "epss_percentile": 0.26055}, "CVE-2024-2321": {"epss_score": 0.00131, "epss_percentile": 0.33408}, "CVE-2024-2322": {"epss_score": 0.0015, "epss_percentile": 0.36052}, "CVE-2024-2324": {"epss_score": 0.0009, "epss_percentile": 0.26167}, "CVE-2024-2325": {"epss_score": 0.02533, "epss_percentile": 0.85033}, "CVE-2024-2326": {"epss_score": 0.00063, "epss_percentile": 0.19811}, "CVE-2024-2327": {"epss_score": 0.00173, "epss_percentile": 0.39098}, "CVE-2024-2328": {"epss_score": 0.00206, "epss_percentile": 0.4293}, "CVE-2024-2329": {"epss_score": 0.00098, "epss_percentile": 0.27663}, "CVE-2024-2330": {"epss_score": 0.93057, "epss_percentile": 0.99771}, "CVE-2024-2331": {"epss_score": 0.00103, "epss_percentile": 0.29053}, "CVE-2024-2332": {"epss_score": 0.00079, "epss_percentile": 0.23937}, "CVE-2024-2333": {"epss_score": 0.00043, "epss_percentile": 0.13123}, "CVE-2024-2334": {"epss_score": 0.00222, "epss_percentile": 0.4481}, "CVE-2024-2335": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-2336": {"epss_score": 0.00211, "epss_percentile": 0.43686}, "CVE-2024-2337": {"epss_score": 0.00162, "epss_percentile": 0.37636}, "CVE-2024-2338": {"epss_score": 0.00047, "epss_percentile": 0.14828}, "CVE-2024-2339": {"epss_score": 0.00051, "epss_percentile": 0.16113}, "CVE-2024-2340": {"epss_score": 0.56658, "epss_percentile": 0.98032}, "CVE-2024-2341": {"epss_score": 0.00539, "epss_percentile": 0.66969}, "CVE-2024-2342": {"epss_score": 0.00463, "epss_percentile": 0.63634}, "CVE-2024-2343": {"epss_score": 0.00275, "epss_percentile": 0.50646}, "CVE-2024-2344": {"epss_score": 0.00875, "epss_percentile": 0.74777}, "CVE-2024-2345": {"epss_score": 0.0022, "epss_percentile": 0.44604}, "CVE-2024-2346": {"epss_score": 0.001, "epss_percentile": 0.28533}, "CVE-2024-2347": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2348": {"epss_score": 0.00206, "epss_percentile": 0.4293}, "CVE-2024-2349": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-2350": {"epss_score": 0.00225, "epss_percentile": 0.45095}, "CVE-2024-2351": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2024-2352": {"epss_score": 0.01477, "epss_percentile": 0.80543}, "CVE-2024-2353": {"epss_score": 0.1232, "epss_percentile": 0.9364}, "CVE-2024-2354": {"epss_score": 0.00062, "epss_percentile": 0.19668}, "CVE-2024-2355": {"epss_score": 0.00083, "epss_percentile": 0.24758}, "CVE-2024-2357": {"epss_score": 0.00396, "epss_percentile": 0.59854}, "CVE-2024-2358": {"epss_score": 0.06239, "epss_percentile": 0.90592}, "CVE-2024-2359": {"epss_score": 0.00268, "epss_percentile": 0.50093}, "CVE-2024-2360": {"epss_score": 0.09712, "epss_percentile": 0.92673}, "CVE-2024-2361": {"epss_score": 0.00353, "epss_percentile": 0.57142}, "CVE-2024-2362": {"epss_score": 0.01907, "epss_percentile": 0.82813}, "CVE-2024-2363": {"epss_score": 0.00052, "epss_percentile": 0.16638}, "CVE-2024-2364": {"epss_score": 0.00025, "epss_percentile": 0.06367}, "CVE-2024-2365": {"epss_score": 0.00026, "epss_percentile": 0.06411}, "CVE-2024-2366": {"epss_score": 0.02287, "epss_percentile": 0.84269}, "CVE-2024-2368": {"epss_score": 0.00115, "epss_percentile": 0.31028}, "CVE-2024-2369": {"epss_score": 0.00346, "epss_percentile": 0.56732}, "CVE-2024-2371": {"epss_score": 0.00072, "epss_percentile": 0.22311}, "CVE-2024-2375": {"epss_score": 0.00093, "epss_percentile": 0.26758}, "CVE-2024-2376": {"epss_score": 0.00435, "epss_percentile": 0.62347}, "CVE-2024-2377": {"epss_score": 0.00073, "epss_percentile": 0.22654}, "CVE-2024-2378": {"epss_score": 0.00088, "epss_percentile": 0.25706}, "CVE-2024-2379": {"epss_score": 0.00205, "epss_percentile": 0.42728}, "CVE-2024-2380": {"epss_score": 0.008, "epss_percentile": 0.73532}, "CVE-2024-2381": {"epss_score": 0.12823, "epss_percentile": 0.93786}, "CVE-2024-2382": {"epss_score": 0.00105, "epss_percentile": 0.29351}, "CVE-2024-2383": {"epss_score": 0.00078, "epss_percentile": 0.23606}, "CVE-2024-2384": {"epss_score": 0.00074, "epss_percentile": 0.22866}, "CVE-2024-2385": {"epss_score": 0.00309, "epss_percentile": 0.5365}, "CVE-2024-2386": {"epss_score": 0.00538, "epss_percentile": 0.66931}, "CVE-2024-2387": {"epss_score": 0.36582, "epss_percentile": 0.96989}, "CVE-2024-2389": {"epss_score": 0.94314, "epss_percentile": 0.99945}, "CVE-2024-2390": {"epss_score": 0.0007, "epss_percentile": 0.21705}, "CVE-2024-2391": {"epss_score": 0.00111, "epss_percentile": 0.30349}, "CVE-2024-2392": {"epss_score": 0.00138, "epss_percentile": 0.34527}, "CVE-2024-2393": {"epss_score": 0.00105, "epss_percentile": 0.29306}, "CVE-2024-2394": {"epss_score": 0.00122, "epss_percentile": 0.32129}, "CVE-2024-2395": {"epss_score": 0.00059, "epss_percentile": 0.18717}, "CVE-2024-2397": {"epss_score": 0.00023, "epss_percentile": 0.05348}, "CVE-2024-2398": {"epss_score": 0.01962, "epss_percentile": 0.83065}, "CVE-2024-2399": {"epss_score": 0.00096, "epss_percentile": 0.27251}, "CVE-2024-2400": {"epss_score": 0.0017, "epss_percentile": 0.3871}, "CVE-2024-2401": {"epss_score": 0.00181, "epss_percentile": 0.40058}, "CVE-2024-2402": {"epss_score": 0.00125, "epss_percentile": 0.32605}, "CVE-2024-2403": {"epss_score": 0.00187, "epss_percentile": 0.40763}, "CVE-2024-2404": {"epss_score": 0.00273, "epss_percentile": 0.50448}, "CVE-2024-2405": {"epss_score": 0.00183, "epss_percentile": 0.40357}, "CVE-2024-2406": {"epss_score": 0.00111, "epss_percentile": 0.30388}, "CVE-2024-2408": {"epss_score": 0.00255, "epss_percentile": 0.48687}, "CVE-2024-2409": {"epss_score": 0.00341, "epss_percentile": 0.56325}, "CVE-2024-2410": {"epss_score": 0.0005, "epss_percentile": 0.15709}, "CVE-2024-2411": {"epss_score": 0.04131, "epss_percentile": 0.88299}, "CVE-2024-2412": {"epss_score": 0.00206, "epss_percentile": 0.42771}, "CVE-2024-2413": {"epss_score": 0.02903, "epss_percentile": 0.85959}, "CVE-2024-2414": {"epss_score": 0.00114, "epss_percentile": 0.30803}, "CVE-2024-2415": {"epss_score": 0.00178, "epss_percentile": 0.39653}, "CVE-2024-2416": {"epss_score": 0.0012, "epss_percentile": 0.31712}, "CVE-2024-2417": {"epss_score": 0.00534, "epss_percentile": 0.6679}, "CVE-2024-2418": {"epss_score": 0.00221, "epss_percentile": 0.44649}, "CVE-2024-2419": {"epss_score": 0.00069, "epss_percentile": 0.21494}, "CVE-2024-2420": {"epss_score": 0.00065, "epss_percentile": 0.20603}, "CVE-2024-2421": {"epss_score": 0.00271, "epss_percentile": 0.50342}, "CVE-2024-2422": {"epss_score": 0.00391, "epss_percentile": 0.5962}, "CVE-2024-2423": {"epss_score": 0.00172, "epss_percentile": 0.38945}, "CVE-2024-2424": {"epss_score": 0.001, "epss_percentile": 0.28467}, "CVE-2024-2425": {"epss_score": 0.0025, "epss_percentile": 0.4809}, "CVE-2024-2426": {"epss_score": 0.0025, "epss_percentile": 0.4809}, "CVE-2024-2427": {"epss_score": 0.00225, "epss_percentile": 0.45083}, "CVE-2024-2428": {"epss_score": 0.00134, "epss_percentile": 0.33928}, "CVE-2024-2429": {"epss_score": 0.00139, "epss_percentile": 0.34619}, "CVE-2024-2430": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-2431": {"epss_score": 0.00047, "epss_percentile": 0.14855}, "CVE-2024-2432": {"epss_score": 0.00391, "epss_percentile": 0.59577}, "CVE-2024-2433": {"epss_score": 0.00036, "epss_percentile": 0.10618}, "CVE-2024-2434": {"epss_score": 0.04756, "epss_percentile": 0.89114}, "CVE-2024-2435": {"epss_score": 0.00102, "epss_percentile": 0.28751}, "CVE-2024-2436": {"epss_score": 0.00172, "epss_percentile": 0.38945}, "CVE-2024-2439": {"epss_score": 0.00217, "epss_percentile": 0.44242}, "CVE-2024-2440": {"epss_score": 0.00142, "epss_percentile": 0.34971}, "CVE-2024-2441": {"epss_score": 0.00582, "epss_percentile": 0.68291}, "CVE-2024-2442": {"epss_score": 0.00181, "epss_percentile": 0.4011}, "CVE-2024-2443": {"epss_score": 0.00266, "epss_percentile": 0.49901}, "CVE-2024-2444": {"epss_score": 0.00204, "epss_percentile": 0.4261}, "CVE-2024-2445": {"epss_score": 0.00435, "epss_percentile": 0.62365}, "CVE-2024-2446": {"epss_score": 0.00132, "epss_percentile": 0.33557}, "CVE-2024-2447": {"epss_score": 0.00145, "epss_percentile": 0.35371}, "CVE-2024-2448": {"epss_score": 0.22711, "epss_percentile": 0.95672}, "CVE-2024-2449": {"epss_score": 0.06397, "epss_percentile": 0.90724}, "CVE-2024-2450": {"epss_score": 0.00261, "epss_percentile": 0.49283}, "CVE-2024-2451": {"epss_score": 0.00019, "epss_percentile": 0.04363}, "CVE-2024-2452": {"epss_score": 0.00141, "epss_percentile": 0.34803}, "CVE-2024-2453": {"epss_score": 0.00091, "epss_percentile": 0.26266}, "CVE-2024-2454": {"epss_score": 0.08875, "epss_percentile": 0.92297}, "CVE-2024-2455": {"epss_score": 0.00176, "epss_percentile": 0.39476}, "CVE-2024-2456": {"epss_score": 0.00162, "epss_percentile": 0.3762}, "CVE-2024-2457": {"epss_score": 0.00148, "epss_percentile": 0.35839}, "CVE-2024-2458": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-2459": {"epss_score": 0.00073, "epss_percentile": 0.22578}, "CVE-2024-2460": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-2461": {"epss_score": 0.002, "epss_percentile": 0.42226}, "CVE-2024-2462": {"epss_score": 0.00107, "epss_percentile": 0.29691}, "CVE-2024-2463": {"epss_score": 0.00212, "epss_percentile": 0.43774}, "CVE-2024-2464": {"epss_score": 0.00197, "epss_percentile": 0.41955}, "CVE-2024-2465": {"epss_score": 0.0008, "epss_percentile": 0.24132}, "CVE-2024-2466": {"epss_score": 0.00149, "epss_percentile": 0.36006}, "CVE-2024-2467": {"epss_score": 0.00068, "epss_percentile": 0.21214}, "CVE-2024-2468": {"epss_score": 0.00086, "epss_percentile": 0.25352}, "CVE-2024-2469": {"epss_score": 0.00899, "epss_percentile": 0.75154}, "CVE-2024-2470": {"epss_score": 0.00442, "epss_percentile": 0.62713}, "CVE-2024-2471": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-2472": {"epss_score": 0.01764, "epss_percentile": 0.82159}, "CVE-2024-2473": {"epss_score": 0.08033, "epss_percentile": 0.91844}, "CVE-2024-2474": {"epss_score": 0.00082, "epss_percentile": 0.24526}, "CVE-2024-2475": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2024-2476": {"epss_score": 0.00185, "epss_percentile": 0.40504}, "CVE-2024-2477": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-2478": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-2479": {"epss_score": 0.00069, "epss_percentile": 0.21456}, "CVE-2024-2480": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-2481": {"epss_score": 0.00047, "epss_percentile": 0.14797}, "CVE-2024-2482": {"epss_score": 0.00128, "epss_percentile": 0.32985}, "CVE-2024-2483": {"epss_score": 0.00057, "epss_percentile": 0.18086}, "CVE-2024-2484": {"epss_score": 0.00225, "epss_percentile": 0.45221}, "CVE-2024-2485": {"epss_score": 0.00223, "epss_percentile": 0.44945}, "CVE-2024-2486": {"epss_score": 0.00593, "epss_percentile": 0.6865}, "CVE-2024-2487": {"epss_score": 0.00257, "epss_percentile": 0.48873}, "CVE-2024-2488": {"epss_score": 0.00257, "epss_percentile": 0.48873}, "CVE-2024-2489": {"epss_score": 0.00224, "epss_percentile": 0.45007}, "CVE-2024-2490": {"epss_score": 0.00322, "epss_percentile": 0.54797}, "CVE-2024-2491": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-2492": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-2493": {"epss_score": 0.00057, "epss_percentile": 0.17969}, "CVE-2024-2494": {"epss_score": 0.00028, "epss_percentile": 0.07324}, "CVE-2024-2495": {"epss_score": 0.00037, "epss_percentile": 0.11005}, "CVE-2024-2496": {"epss_score": 0.00059, "epss_percentile": 0.18712}, "CVE-2024-2497": {"epss_score": 0.0006, "epss_percentile": 0.18964}, "CVE-2024-2499": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2500": {"epss_score": 0.00289, "epss_percentile": 0.52048}, "CVE-2024-2501": {"epss_score": 0.0172, "epss_percentile": 0.81928}, "CVE-2024-2502": {"epss_score": 0.00122, "epss_percentile": 0.32102}, "CVE-2024-2503": {"epss_score": 0.00196, "epss_percentile": 0.41753}, "CVE-2024-2504": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2024-2505": {"epss_score": 0.00719, "epss_percentile": 0.7195}, "CVE-2024-2506": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-2507": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-2508": {"epss_score": 0.00223, "epss_percentile": 0.44942}, "CVE-2024-2509": {"epss_score": 0.00213, "epss_percentile": 0.43916}, "CVE-2024-2511": {"epss_score": 0.04697, "epss_percentile": 0.89021}, "CVE-2024-2513": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-2514": {"epss_score": 0.00044, "epss_percentile": 0.13455}, "CVE-2024-2515": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2024-2516": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-2517": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-2518": {"epss_score": 0.00068, "epss_percentile": 0.21408}, "CVE-2024-2519": {"epss_score": 0.00075, "epss_percentile": 0.22908}, "CVE-2024-2520": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2024-2521": {"epss_score": 0.00075, "epss_percentile": 0.22908}, "CVE-2024-2522": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2024-2523": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2024-2524": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2024-2525": {"epss_score": 0.00075, "epss_percentile": 0.22908}, "CVE-2024-2526": {"epss_score": 0.00098, "epss_percentile": 0.27652}, "CVE-2024-2527": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-2528": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-2529": {"epss_score": 0.00077, "epss_percentile": 0.23421}, "CVE-2024-2530": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2024-2531": {"epss_score": 0.00043, "epss_percentile": 0.13021}, "CVE-2024-2532": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2024-2533": {"epss_score": 0.00072, "epss_percentile": 0.22384}, "CVE-2024-2534": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-2535": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2024-2536": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-2537": {"epss_score": 0.00064, "epss_percentile": 0.20329}, "CVE-2024-2538": {"epss_score": 0.00053, "epss_percentile": 0.17038}, "CVE-2024-2539": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2541": {"epss_score": 0.00867, "epss_percentile": 0.74655}, "CVE-2024-2542": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-2543": {"epss_score": 0.00319, "epss_percentile": 0.54465}, "CVE-2024-2544": {"epss_score": 0.00121, "epss_percentile": 0.31955}, "CVE-2024-2546": {"epss_score": 0.00144, "epss_percentile": 0.35325}, "CVE-2024-2547": {"epss_score": 0.00237, "epss_percentile": 0.46662}, "CVE-2024-2548": {"epss_score": 0.00461, "epss_percentile": 0.63552}, "CVE-2024-2550": {"epss_score": 0.00277, "epss_percentile": 0.50834}, "CVE-2024-2551": {"epss_score": 0.0031, "epss_percentile": 0.53767}, "CVE-2024-2552": {"epss_score": 0.00023, "epss_percentile": 0.05368}, "CVE-2024-2553": {"epss_score": 0.00292, "epss_percentile": 0.52252}, "CVE-2024-2554": {"epss_score": 0.00072, "epss_percentile": 0.22342}, "CVE-2024-2555": {"epss_score": 0.00057, "epss_percentile": 0.18128}, "CVE-2024-2556": {"epss_score": 0.00056, "epss_percentile": 0.17693}, "CVE-2024-2557": {"epss_score": 0.00302, "epss_percentile": 0.53087}, "CVE-2024-2558": {"epss_score": 0.00189, "epss_percentile": 0.40996}, "CVE-2024-2559": {"epss_score": 0.00062, "epss_percentile": 0.19668}, "CVE-2024-2560": {"epss_score": 0.0018, "epss_percentile": 0.39975}, "CVE-2024-2561": {"epss_score": 0.19529, "epss_percentile": 0.95201}, "CVE-2024-2562": {"epss_score": 0.00048, "epss_percentile": 0.15162}, "CVE-2024-2563": {"epss_score": 0.00078, "epss_percentile": 0.23615}, "CVE-2024-2564": {"epss_score": 0.0007, "epss_percentile": 0.21835}, "CVE-2024-2565": {"epss_score": 0.00072, "epss_percentile": 0.22297}, "CVE-2024-2566": {"epss_score": 0.00048, "epss_percentile": 0.14975}, "CVE-2024-2567": {"epss_score": 0.00025, "epss_percentile": 0.06054}, "CVE-2024-2568": {"epss_score": 0.0017, "epss_percentile": 0.38762}, "CVE-2024-2569": {"epss_score": 0.00133, "epss_percentile": 0.33728}, "CVE-2024-2570": {"epss_score": 0.0015, "epss_percentile": 0.3614}, "CVE-2024-2571": {"epss_score": 0.0015, "epss_percentile": 0.3614}, "CVE-2024-2572": {"epss_score": 0.00111, "epss_percentile": 0.30247}, "CVE-2024-2573": {"epss_score": 0.00111, "epss_percentile": 0.30247}, "CVE-2024-2574": {"epss_score": 0.00045, "epss_percentile": 0.13985}, "CVE-2024-2575": {"epss_score": 0.00039, "epss_percentile": 0.11451}, "CVE-2024-2576": {"epss_score": 0.00039, "epss_percentile": 0.11451}, "CVE-2024-2577": {"epss_score": 0.00045, "epss_percentile": 0.13985}, "CVE-2024-2578": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2024-2579": {"epss_score": 0.00123, "epss_percentile": 0.32265}, "CVE-2024-2580": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-2581": {"epss_score": 0.00607, "epss_percentile": 0.69051}, "CVE-2024-2583": {"epss_score": 0.0017, "epss_percentile": 0.38688}, "CVE-2024-2584": {"epss_score": 0.00047, "epss_percentile": 0.1491}, "CVE-2024-2585": {"epss_score": 0.00048, "epss_percentile": 0.1508}, "CVE-2024-2586": {"epss_score": 0.00047, "epss_percentile": 0.1491}, "CVE-2024-2587": {"epss_score": 0.00048, "epss_percentile": 0.1508}, "CVE-2024-2588": {"epss_score": 0.00048, "epss_percentile": 0.1508}, "CVE-2024-2589": {"epss_score": 0.00048, "epss_percentile": 0.1508}, "CVE-2024-2590": {"epss_score": 0.00048, "epss_percentile": 0.1508}, "CVE-2024-2591": {"epss_score": 0.00048, "epss_percentile": 0.1508}, "CVE-2024-2592": {"epss_score": 0.00048, "epss_percentile": 0.1508}, "CVE-2024-2593": {"epss_score": 0.00035, "epss_percentile": 0.09873}, "CVE-2024-2594": {"epss_score": 0.00035, "epss_percentile": 0.09847}, "CVE-2024-2595": {"epss_score": 0.00035, "epss_percentile": 0.09847}, "CVE-2024-2596": {"epss_score": 0.00035, "epss_percentile": 0.09847}, "CVE-2024-2597": {"epss_score": 0.00035, "epss_percentile": 0.09847}, "CVE-2024-2598": {"epss_score": 0.00035, "epss_percentile": 0.09847}, "CVE-2024-2599": {"epss_score": 0.0011, "epss_percentile": 0.30098}, "CVE-2024-2602": {"epss_score": 0.04095, "epss_percentile": 0.88247}, "CVE-2024-2603": {"epss_score": 0.00176, "epss_percentile": 0.3946}, "CVE-2024-2604": {"epss_score": 0.00058, "epss_percentile": 0.18429}, "CVE-2024-2605": {"epss_score": 0.0032, "epss_percentile": 0.5461}, "CVE-2024-2606": {"epss_score": 0.00198, "epss_percentile": 0.41993}, "CVE-2024-2607": {"epss_score": 0.01339, "epss_percentile": 0.79572}, "CVE-2024-2608": {"epss_score": 0.0016, "epss_percentile": 0.37436}, "CVE-2024-2609": {"epss_score": 0.01026, "epss_percentile": 0.76798}, "CVE-2024-2610": {"epss_score": 0.00162, "epss_percentile": 0.37735}, "CVE-2024-2611": {"epss_score": 0.00238, "epss_percentile": 0.46793}, "CVE-2024-2612": {"epss_score": 0.01049, "epss_percentile": 0.77058}, "CVE-2024-2613": {"epss_score": 0.0013, "epss_percentile": 0.33253}, "CVE-2024-2614": {"epss_score": 0.01325, "epss_percentile": 0.7947}, "CVE-2024-2615": {"epss_score": 0.00207, "epss_percentile": 0.4308}, "CVE-2024-2616": {"epss_score": 0.00038, "epss_percentile": 0.11273}, "CVE-2024-2617": {"epss_score": 0.00018, "epss_percentile": 0.04014}, "CVE-2024-2618": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-2619": {"epss_score": 0.0017, "epss_percentile": 0.38716}, "CVE-2024-2620": {"epss_score": 0.00131, "epss_percentile": 0.33361}, "CVE-2024-2621": {"epss_score": 0.13272, "epss_percentile": 0.93919}, "CVE-2024-2622": {"epss_score": 0.0003, "epss_percentile": 0.08244}, "CVE-2024-2623": {"epss_score": 0.00206, "epss_percentile": 0.4293}, "CVE-2024-2624": {"epss_score": 0.09562, "epss_percentile": 0.926}, "CVE-2024-2625": {"epss_score": 0.00556, "epss_percentile": 0.67514}, "CVE-2024-2626": {"epss_score": 0.00094, "epss_percentile": 0.26779}, "CVE-2024-2627": {"epss_score": 0.00421, "epss_percentile": 0.61466}, "CVE-2024-2628": {"epss_score": 0.00165, "epss_percentile": 0.3806}, "CVE-2024-2629": {"epss_score": 0.00193, "epss_percentile": 0.41453}, "CVE-2024-2630": {"epss_score": 0.00123, "epss_percentile": 0.32206}, "CVE-2024-2631": {"epss_score": 0.00166, "epss_percentile": 0.38165}, "CVE-2024-2632": {"epss_score": 0.00078, "epss_percentile": 0.23746}, "CVE-2024-2633": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2024-2634": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2024-2635": {"epss_score": 0.00057, "epss_percentile": 0.18022}, "CVE-2024-2636": {"epss_score": 0.0009, "epss_percentile": 0.26152}, "CVE-2024-2637": {"epss_score": 0.00044, "epss_percentile": 0.13503}, "CVE-2024-2639": {"epss_score": 0.00067, "epss_percentile": 0.21115}, "CVE-2024-2640": {"epss_score": 0.00377, "epss_percentile": 0.58761}, "CVE-2024-2641": {"epss_score": 0.00059, "epss_percentile": 0.18649}, "CVE-2024-2642": {"epss_score": 0.00429, "epss_percentile": 0.61971}, "CVE-2024-2643": {"epss_score": 0.00051, "epss_percentile": 0.16337}, "CVE-2024-2644": {"epss_score": 0.0006, "epss_percentile": 0.19114}, "CVE-2024-2645": {"epss_score": 0.00104, "epss_percentile": 0.29234}, "CVE-2024-2646": {"epss_score": 0.0006, "epss_percentile": 0.19114}, "CVE-2024-2647": {"epss_score": 0.0006, "epss_percentile": 0.19104}, "CVE-2024-2648": {"epss_score": 0.00104, "epss_percentile": 0.29234}, "CVE-2024-2649": {"epss_score": 0.0006, "epss_percentile": 0.19114}, "CVE-2024-2650": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-2651": {"epss_score": 0.07611, "epss_percentile": 0.91567}, "CVE-2024-2653": {"epss_score": 0.03936, "epss_percentile": 0.87983}, "CVE-2024-2654": {"epss_score": 0.01859, "epss_percentile": 0.82583}, "CVE-2024-2655": {"epss_score": 0.00272, "epss_percentile": 0.50397}, "CVE-2024-2656": {"epss_score": 0.00109, "epss_percentile": 0.30045}, "CVE-2024-2657": {"epss_score": 0.00288, "epss_percentile": 0.51871}, "CVE-2024-2658": {"epss_score": 0.00054, "epss_percentile": 0.17117}, "CVE-2024-2659": {"epss_score": 0.0043, "epss_percentile": 0.62005}, "CVE-2024-2660": {"epss_score": 0.00156, "epss_percentile": 0.36903}, "CVE-2024-2661": {"epss_score": 0.00523, "epss_percentile": 0.66295}, "CVE-2024-2662": {"epss_score": 0.02913, "epss_percentile": 0.85974}, "CVE-2024-2663": {"epss_score": 0.00289, "epss_percentile": 0.52021}, "CVE-2024-2664": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-2665": {"epss_score": 0.00311, "epss_percentile": 0.53843}, "CVE-2024-2666": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-2667": {"epss_score": 0.90137, "epss_percentile": 0.99564}, "CVE-2024-2668": {"epss_score": 0.00046, "epss_percentile": 0.14091}, "CVE-2024-2669": {"epss_score": 0.00046, "epss_percentile": 0.14091}, "CVE-2024-2670": {"epss_score": 0.00046, "epss_percentile": 0.14091}, "CVE-2024-2671": {"epss_score": 0.00048, "epss_percentile": 0.15035}, "CVE-2024-2672": {"epss_score": 0.00054, "epss_percentile": 0.17072}, "CVE-2024-2673": {"epss_score": 0.00027, "epss_percentile": 0.06782}, "CVE-2024-2674": {"epss_score": 0.00046, "epss_percentile": 0.14091}, "CVE-2024-2675": {"epss_score": 0.00046, "epss_percentile": 0.14091}, "CVE-2024-2676": {"epss_score": 0.00016, "epss_percentile": 0.0274}, "CVE-2024-2677": {"epss_score": 0.00048, "epss_percentile": 0.15035}, "CVE-2024-2678": {"epss_score": 0.00048, "epss_percentile": 0.15035}, "CVE-2024-2679": {"epss_score": 0.0008, "epss_percentile": 0.24031}, "CVE-2024-2680": {"epss_score": 0.0012, "epss_percentile": 0.31761}, "CVE-2024-2681": {"epss_score": 0.0012, "epss_percentile": 0.31761}, "CVE-2024-2682": {"epss_score": 0.00157, "epss_percentile": 0.37092}, "CVE-2024-2683": {"epss_score": 0.0012, "epss_percentile": 0.31761}, "CVE-2024-2684": {"epss_score": 0.0012, "epss_percentile": 0.31761}, "CVE-2024-2685": {"epss_score": 0.00072, "epss_percentile": 0.22384}, "CVE-2024-2686": {"epss_score": 0.00122, "epss_percentile": 0.32068}, "CVE-2024-2687": {"epss_score": 0.00046, "epss_percentile": 0.14091}, "CVE-2024-2688": {"epss_score": 0.00114, "epss_percentile": 0.30783}, "CVE-2024-2689": {"epss_score": 0.00069, "epss_percentile": 0.21629}, "CVE-2024-2690": {"epss_score": 0.0014, "epss_percentile": 0.34703}, "CVE-2024-2691": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-2692": {"epss_score": 0.00297, "epss_percentile": 0.52704}, "CVE-2024-2693": {"epss_score": 0.00834, "epss_percentile": 0.74107}, "CVE-2024-2694": {"epss_score": 0.01853, "epss_percentile": 0.82547}, "CVE-2024-2695": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-2696": {"epss_score": 0.00108, "epss_percentile": 0.299}, "CVE-2024-2697": {"epss_score": 0.00429, "epss_percentile": 0.61992}, "CVE-2024-2698": {"epss_score": 0.00612, "epss_percentile": 0.69238}, "CVE-2024-2700": {"epss_score": 0.00037, "epss_percentile": 0.10802}, "CVE-2024-2702": {"epss_score": 0.00223, "epss_percentile": 0.44942}, "CVE-2024-2703": {"epss_score": 0.0104, "epss_percentile": 0.76955}, "CVE-2024-2704": {"epss_score": 0.00989, "epss_percentile": 0.76365}, "CVE-2024-2705": {"epss_score": 0.00865, "epss_percentile": 0.74624}, "CVE-2024-2706": {"epss_score": 0.007, "epss_percentile": 0.7146}, "CVE-2024-2707": {"epss_score": 0.01904, "epss_percentile": 0.8279}, "CVE-2024-2708": {"epss_score": 0.00441, "epss_percentile": 0.62687}, "CVE-2024-2709": {"epss_score": 0.00362, "epss_percentile": 0.57814}, "CVE-2024-2710": {"epss_score": 0.00432, "epss_percentile": 0.62109}, "CVE-2024-2711": {"epss_score": 0.00432, "epss_percentile": 0.62109}, "CVE-2024-2712": {"epss_score": 0.0007, "epss_percentile": 0.21814}, "CVE-2024-2713": {"epss_score": 0.00026, "epss_percentile": 0.0668}, "CVE-2024-2714": {"epss_score": 0.00046, "epss_percentile": 0.14091}, "CVE-2024-2715": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2024-2716": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2024-2717": {"epss_score": 0.00188, "epss_percentile": 0.40858}, "CVE-2024-2718": {"epss_score": 0.00149, "epss_percentile": 0.35987}, "CVE-2024-2719": {"epss_score": 0.00188, "epss_percentile": 0.40858}, "CVE-2024-2720": {"epss_score": 0.00131, "epss_percentile": 0.33449}, "CVE-2024-2721": {"epss_score": 0.00103, "epss_percentile": 0.28898}, "CVE-2024-2722": {"epss_score": 0.00129, "epss_percentile": 0.33085}, "CVE-2024-2723": {"epss_score": 0.00049, "epss_percentile": 0.15573}, "CVE-2024-2724": {"epss_score": 0.00049, "epss_percentile": 0.15573}, "CVE-2024-2725": {"epss_score": 0.00071, "epss_percentile": 0.22208}, "CVE-2024-2726": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2024-2727": {"epss_score": 0.0009, "epss_percentile": 0.26118}, "CVE-2024-2728": {"epss_score": 0.00032, "epss_percentile": 0.08971}, "CVE-2024-2729": {"epss_score": 0.00247, "epss_percentile": 0.47884}, "CVE-2024-2730": {"epss_score": 0.00316, "epss_percentile": 0.54292}, "CVE-2024-2731": {"epss_score": 0.00155, "epss_percentile": 0.3681}, "CVE-2024-2732": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2733": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-2734": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-2735": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-2736": {"epss_score": 0.00214, "epss_percentile": 0.43973}, "CVE-2024-2738": {"epss_score": 0.015, "epss_percentile": 0.80711}, "CVE-2024-2739": {"epss_score": 0.00312, "epss_percentile": 0.53953}, "CVE-2024-2740": {"epss_score": 0.00069, "epss_percentile": 0.21521}, "CVE-2024-2741": {"epss_score": 0.0005, "epss_percentile": 0.15901}, "CVE-2024-2742": {"epss_score": 0.00021, "epss_percentile": 0.0493}, "CVE-2024-2743": {"epss_score": 0.00029, "epss_percentile": 0.0774}, "CVE-2024-2744": {"epss_score": 0.00434, "epss_percentile": 0.62303}, "CVE-2024-2745": {"epss_score": 0.0008, "epss_percentile": 0.24039}, "CVE-2024-2746": {"epss_score": 0.00163, "epss_percentile": 0.37812}, "CVE-2024-2747": {"epss_score": 0.00146, "epss_percentile": 0.35609}, "CVE-2024-2748": {"epss_score": 0.00251, "epss_percentile": 0.4826}, "CVE-2024-2749": {"epss_score": 0.00077, "epss_percentile": 0.23388}, "CVE-2024-2750": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-2751": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2752": {"epss_score": 0.00164, "epss_percentile": 0.37889}, "CVE-2024-2753": {"epss_score": 0.00247, "epss_percentile": 0.47816}, "CVE-2024-2754": {"epss_score": 0.00064, "epss_percentile": 0.20431}, "CVE-2024-2756": {"epss_score": 0.07745, "epss_percentile": 0.91655}, "CVE-2024-2757": {"epss_score": 0.00625, "epss_percentile": 0.69591}, "CVE-2024-2758": {"epss_score": 0.00358, "epss_percentile": 0.57518}, "CVE-2024-2759": {"epss_score": 0.00148, "epss_percentile": 0.3588}, "CVE-2024-2760": {"epss_score": 0.00018, "epss_percentile": 0.03678}, "CVE-2024-2761": {"epss_score": 0.00322, "epss_percentile": 0.54801}, "CVE-2024-2762": {"epss_score": 0.00306, "epss_percentile": 0.53465}, "CVE-2024-2763": {"epss_score": 0.00836, "epss_percentile": 0.74129}, "CVE-2024-2764": {"epss_score": 0.00727, "epss_percentile": 0.72093}, "CVE-2024-2765": {"epss_score": 0.00286, "epss_percentile": 0.51769}, "CVE-2024-2766": {"epss_score": 0.0007, "epss_percentile": 0.21814}, "CVE-2024-2767": {"epss_score": 0.0007, "epss_percentile": 0.21814}, "CVE-2024-2768": {"epss_score": 0.0007, "epss_percentile": 0.21814}, "CVE-2024-2769": {"epss_score": 0.00122, "epss_percentile": 0.32061}, "CVE-2024-2770": {"epss_score": 0.00074, "epss_percentile": 0.22712}, "CVE-2024-2771": {"epss_score": 0.2943, "epss_percentile": 0.96441}, "CVE-2024-2772": {"epss_score": 0.00263, "epss_percentile": 0.49408}, "CVE-2024-2773": {"epss_score": 0.00218, "epss_percentile": 0.44415}, "CVE-2024-2774": {"epss_score": 0.0007, "epss_percentile": 0.21814}, "CVE-2024-2775": {"epss_score": 0.00197, "epss_percentile": 0.41968}, "CVE-2024-2776": {"epss_score": 0.0007, "epss_percentile": 0.21814}, "CVE-2024-2777": {"epss_score": 0.00042, "epss_percentile": 0.12741}, "CVE-2024-2778": {"epss_score": 0.00204, "epss_percentile": 0.42667}, "CVE-2024-2779": {"epss_score": 0.00131, "epss_percentile": 0.33449}, "CVE-2024-2780": {"epss_score": 0.00131, "epss_percentile": 0.33449}, "CVE-2024-2781": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2782": {"epss_score": 0.10632, "epss_percentile": 0.93054}, "CVE-2024-2783": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-2784": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-2785": {"epss_score": 0.00361, "epss_percentile": 0.57745}, "CVE-2024-2786": {"epss_score": 0.00254, "epss_percentile": 0.4852}, "CVE-2024-2787": {"epss_score": 0.00192, "epss_percentile": 0.41359}, "CVE-2024-2788": {"epss_score": 0.00162, "epss_percentile": 0.37689}, "CVE-2024-2789": {"epss_score": 0.00188, "epss_percentile": 0.40883}, "CVE-2024-2790": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-2791": {"epss_score": 0.00193, "epss_percentile": 0.41498}, "CVE-2024-2792": {"epss_score": 0.00428, "epss_percentile": 0.61939}, "CVE-2024-2793": {"epss_score": 0.0678, "epss_percentile": 0.91023}, "CVE-2024-2794": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-2795": {"epss_score": 0.00644, "epss_percentile": 0.7008}, "CVE-2024-2796": {"epss_score": 0.00378, "epss_percentile": 0.58829}, "CVE-2024-2797": {"epss_score": 0.00182, "epss_percentile": 0.40221}, "CVE-2024-2798": {"epss_score": 0.00191, "epss_percentile": 0.41204}, "CVE-2024-2799": {"epss_score": 0.00122, "epss_percentile": 0.32038}, "CVE-2024-2800": {"epss_score": 0.00408, "epss_percentile": 0.60642}, "CVE-2024-2801": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-2803": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2804": {"epss_score": 0.0065, "epss_percentile": 0.70272}, "CVE-2024-2805": {"epss_score": 0.01044, "epss_percentile": 0.77002}, "CVE-2024-2806": {"epss_score": 0.00354, "epss_percentile": 0.57207}, "CVE-2024-2807": {"epss_score": 0.00359, "epss_percentile": 0.57595}, "CVE-2024-2808": {"epss_score": 0.00588, "epss_percentile": 0.6851}, "CVE-2024-2809": {"epss_score": 0.00723, "epss_percentile": 0.7202}, "CVE-2024-2810": {"epss_score": 0.00533, "epss_percentile": 0.66767}, "CVE-2024-2811": {"epss_score": 0.00325, "epss_percentile": 0.55019}, "CVE-2024-2812": {"epss_score": 0.04645, "epss_percentile": 0.88958}, "CVE-2024-2813": {"epss_score": 0.00533, "epss_percentile": 0.66767}, "CVE-2024-2814": {"epss_score": 0.00325, "epss_percentile": 0.55019}, "CVE-2024-2815": {"epss_score": 0.00533, "epss_percentile": 0.66767}, "CVE-2024-2816": {"epss_score": 0.00107, "epss_percentile": 0.29731}, "CVE-2024-2817": {"epss_score": 0.00107, "epss_percentile": 0.29731}, "CVE-2024-2818": {"epss_score": 0.00025, "epss_percentile": 0.06242}, "CVE-2024-2819": {"epss_score": 0.00233, "epss_percentile": 0.46028}, "CVE-2024-2820": {"epss_score": 0.00055, "epss_percentile": 0.17644}, "CVE-2024-2821": {"epss_score": 0.00046, "epss_percentile": 0.14082}, "CVE-2024-2822": {"epss_score": 0.00055, "epss_percentile": 0.17427}, "CVE-2024-2823": {"epss_score": 0.00055, "epss_percentile": 0.17427}, "CVE-2024-2824": {"epss_score": 0.00096, "epss_percentile": 0.27382}, "CVE-2024-2825": {"epss_score": 0.00094, "epss_percentile": 0.27069}, "CVE-2024-2826": {"epss_score": 0.0005, "epss_percentile": 0.15732}, "CVE-2024-2827": {"epss_score": 0.00032, "epss_percentile": 0.08832}, "CVE-2024-2828": {"epss_score": 0.00057, "epss_percentile": 0.1817}, "CVE-2024-2829": {"epss_score": 0.03496, "epss_percentile": 0.87238}, "CVE-2024-2830": {"epss_score": 0.00196, "epss_percentile": 0.41753}, "CVE-2024-2831": {"epss_score": 0.00348, "epss_percentile": 0.5683}, "CVE-2024-2832": {"epss_score": 0.00098, "epss_percentile": 0.27652}, "CVE-2024-2833": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2024-2834": {"epss_score": 0.00102, "epss_percentile": 0.2882}, "CVE-2024-2835": {"epss_score": 0.00331, "epss_percentile": 0.55504}, "CVE-2024-2836": {"epss_score": 0.00284, "epss_percentile": 0.51433}, "CVE-2024-2837": {"epss_score": 0.0034, "epss_percentile": 0.56256}, "CVE-2024-2838": {"epss_score": 0.00183, "epss_percentile": 0.40342}, "CVE-2024-2839": {"epss_score": 0.00193, "epss_percentile": 0.41498}, "CVE-2024-2840": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2841": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-2842": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2843": {"epss_score": 0.00134, "epss_percentile": 0.338}, "CVE-2024-2844": {"epss_score": 0.00086, "epss_percentile": 0.25286}, "CVE-2024-2845": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-2846": {"epss_score": 0.00442, "epss_percentile": 0.62701}, "CVE-2024-2847": {"epss_score": 0.00138, "epss_percentile": 0.34464}, "CVE-2024-2848": {"epss_score": 0.00332, "epss_percentile": 0.55599}, "CVE-2024-2849": {"epss_score": 0.00079, "epss_percentile": 0.23812}, "CVE-2024-2850": {"epss_score": 0.00362, "epss_percentile": 0.57814}, "CVE-2024-2851": {"epss_score": 0.0141, "epss_percentile": 0.80083}, "CVE-2024-2852": {"epss_score": 0.00134, "epss_percentile": 0.33781}, "CVE-2024-2853": {"epss_score": 0.0141, "epss_percentile": 0.80083}, "CVE-2024-2854": {"epss_score": 0.01532, "epss_percentile": 0.80893}, "CVE-2024-2855": {"epss_score": 0.00134, "epss_percentile": 0.33781}, "CVE-2024-2856": {"epss_score": 0.00327, "epss_percentile": 0.55106}, "CVE-2024-2857": {"epss_score": 0.0034, "epss_percentile": 0.56212}, "CVE-2024-2858": {"epss_score": 0.00037, "epss_percentile": 0.10634}, "CVE-2024-2859": {"epss_score": 0.0214, "epss_percentile": 0.83748}, "CVE-2024-2860": {"epss_score": 0.00078, "epss_percentile": 0.23576}, "CVE-2024-2861": {"epss_score": 0.00589, "epss_percentile": 0.68532}, "CVE-2024-2862": {"epss_score": 0.83275, "epss_percentile": 0.99241}, "CVE-2024-2863": {"epss_score": 0.71004, "epss_percentile": 0.9865}, "CVE-2024-2864": {"epss_score": 0.00077, "epss_percentile": 0.2331}, "CVE-2024-2865": {"epss_score": 0.00094, "epss_percentile": 0.26794}, "CVE-2024-2867": {"epss_score": 0.00236, "epss_percentile": 0.46451}, "CVE-2024-2868": {"epss_score": 0.00256, "epss_percentile": 0.488}, "CVE-2024-2869": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-2870": {"epss_score": 0.00284, "epss_percentile": 0.51493}, "CVE-2024-2871": {"epss_score": 0.00292, "epss_percentile": 0.52227}, "CVE-2024-2872": {"epss_score": 0.00164, "epss_percentile": 0.37869}, "CVE-2024-2873": {"epss_score": 0.00349, "epss_percentile": 0.56857}, "CVE-2024-2874": {"epss_score": 0.00116, "epss_percentile": 0.31155}, "CVE-2024-2876": {"epss_score": 0.9128, "epss_percentile": 0.99631}, "CVE-2024-2877": {"epss_score": 0.00057, "epss_percentile": 0.18012}, "CVE-2024-2878": {"epss_score": 0.03208, "epss_percentile": 0.86641}, "CVE-2024-2879": {"epss_score": 0.93243, "epss_percentile": 0.99787}, "CVE-2024-2880": {"epss_score": 0.00053, "epss_percentile": 0.16698}, "CVE-2024-2881": {"epss_score": 0.003, "epss_percentile": 0.52991}, "CVE-2024-2882": {"epss_score": 0.0057, "epss_percentile": 0.67967}, "CVE-2024-2883": {"epss_score": 0.00143, "epss_percentile": 0.35192}, "CVE-2024-2884": {"epss_score": 0.00131, "epss_percentile": 0.33451}, "CVE-2024-2885": {"epss_score": 0.00155, "epss_percentile": 0.36877}, "CVE-2024-2886": {"epss_score": 0.00502, "epss_percentile": 0.65373}, "CVE-2024-2887": {"epss_score": 0.04743, "epss_percentile": 0.89082}, "CVE-2024-2888": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2024-2889": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-2890": {"epss_score": 0.00351, "epss_percentile": 0.57012}, "CVE-2024-2891": {"epss_score": 0.00801, "epss_percentile": 0.73574}, "CVE-2024-2892": {"epss_score": 0.00212, "epss_percentile": 0.43809}, "CVE-2024-2893": {"epss_score": 0.00262, "epss_percentile": 0.49331}, "CVE-2024-2894": {"epss_score": 0.00801, "epss_percentile": 0.73574}, "CVE-2024-2895": {"epss_score": 0.00861, "epss_percentile": 0.74547}, "CVE-2024-2896": {"epss_score": 0.0062, "epss_percentile": 0.69438}, "CVE-2024-2897": {"epss_score": 0.04439, "epss_percentile": 0.88691}, "CVE-2024-2898": {"epss_score": 0.00861, "epss_percentile": 0.74547}, "CVE-2024-2899": {"epss_score": 0.00801, "epss_percentile": 0.73574}, "CVE-2024-2900": {"epss_score": 0.00948, "epss_percentile": 0.75828}, "CVE-2024-2901": {"epss_score": 0.00801, "epss_percentile": 0.73574}, "CVE-2024-2902": {"epss_score": 0.00684, "epss_percentile": 0.7111}, "CVE-2024-2903": {"epss_score": 0.01012, "epss_percentile": 0.76625}, "CVE-2024-2904": {"epss_score": 0.00125, "epss_percentile": 0.32512}, "CVE-2024-2905": {"epss_score": 0.00021, "epss_percentile": 0.04916}, "CVE-2024-2906": {"epss_score": 0.00208, "epss_percentile": 0.43306}, "CVE-2024-2907": {"epss_score": 0.00343, "epss_percentile": 0.56434}, "CVE-2024-2908": {"epss_score": 0.02486, "epss_percentile": 0.84888}, "CVE-2024-2909": {"epss_score": 0.04138, "epss_percentile": 0.88308}, "CVE-2024-2910": {"epss_score": 0.01842, "epss_percentile": 0.82498}, "CVE-2024-2911": {"epss_score": 0.00111, "epss_percentile": 0.30396}, "CVE-2024-2912": {"epss_score": 0.07494, "epss_percentile": 0.91501}, "CVE-2024-2913": {"epss_score": 0.00114, "epss_percentile": 0.30745}, "CVE-2024-2914": {"epss_score": 0.01327, "epss_percentile": 0.79487}, "CVE-2024-2915": {"epss_score": 0.0025, "epss_percentile": 0.48252}, "CVE-2024-2916": {"epss_score": 0.00029, "epss_percentile": 0.07974}, "CVE-2024-2917": {"epss_score": 0.00233, "epss_percentile": 0.46053}, "CVE-2024-2918": {"epss_score": 0.00137, "epss_percentile": 0.34332}, "CVE-2024-2919": {"epss_score": 0.00184, "epss_percentile": 0.40425}, "CVE-2024-2920": {"epss_score": 0.00392, "epss_percentile": 0.59647}, "CVE-2024-2921": {"epss_score": 0.00471, "epss_percentile": 0.64016}, "CVE-2024-2922": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-2923": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-2924": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-2925": {"epss_score": 0.00206, "epss_percentile": 0.4293}, "CVE-2024-2926": {"epss_score": 0.00452, "epss_percentile": 0.6316}, "CVE-2024-2927": {"epss_score": 0.00048, "epss_percentile": 0.14976}, "CVE-2024-2928": {"epss_score": 0.90799, "epss_percentile": 0.99601}, "CVE-2024-2929": {"epss_score": 0.00043, "epss_percentile": 0.13017}, "CVE-2024-2930": {"epss_score": 0.00341, "epss_percentile": 0.5629}, "CVE-2024-2931": {"epss_score": 0.0027, "epss_percentile": 0.50197}, "CVE-2024-2932": {"epss_score": 0.0011, "epss_percentile": 0.30199}, "CVE-2024-2933": {"epss_score": 0.00361, "epss_percentile": 0.57745}, "CVE-2024-2934": {"epss_score": 0.00074, "epss_percentile": 0.22763}, "CVE-2024-2935": {"epss_score": 0.00093, "epss_percentile": 0.26608}, "CVE-2024-2936": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-2937": {"epss_score": 0.00152, "epss_percentile": 0.36408}, "CVE-2024-2938": {"epss_score": 0.0008, "epss_percentile": 0.2403}, "CVE-2024-2939": {"epss_score": 0.00131, "epss_percentile": 0.33449}, "CVE-2024-2940": {"epss_score": 0.00188, "epss_percentile": 0.40858}, "CVE-2024-2941": {"epss_score": 0.0008, "epss_percentile": 0.24063}, "CVE-2024-2942": {"epss_score": 0.0007, "epss_percentile": 0.21814}, "CVE-2024-2943": {"epss_score": 0.0005, "epss_percentile": 0.1567}, "CVE-2024-2944": {"epss_score": 0.00044, "epss_percentile": 0.13626}, "CVE-2024-2945": {"epss_score": 0.0007, "epss_percentile": 0.21814}, "CVE-2024-2946": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-2947": {"epss_score": 0.00038, "epss_percentile": 0.11297}, "CVE-2024-2948": {"epss_score": 0.00225, "epss_percentile": 0.45149}, "CVE-2024-2949": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-2950": {"epss_score": 0.00183, "epss_percentile": 0.40348}, "CVE-2024-2951": {"epss_score": 0.00102, "epss_percentile": 0.28858}, "CVE-2024-2952": {"epss_score": 0.0145, "epss_percentile": 0.80354}, "CVE-2024-2953": {"epss_score": 0.00334, "epss_percentile": 0.55739}, "CVE-2024-2954": {"epss_score": 0.00441, "epss_percentile": 0.62695}, "CVE-2024-2955": {"epss_score": 0.00087, "epss_percentile": 0.256}, "CVE-2024-2956": {"epss_score": 0.00158, "epss_percentile": 0.37142}, "CVE-2024-2958": {"epss_score": 0.00288, "epss_percentile": 0.51902}, "CVE-2024-2959": {"epss_score": 0.00105, "epss_percentile": 0.29287}, "CVE-2024-2960": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2024-2961": {"epss_score": 0.9286, "epss_percentile": 0.99755}, "CVE-2024-2962": {"epss_score": 0.00226, "epss_percentile": 0.45273}, "CVE-2024-2963": {"epss_score": 0.00164, "epss_percentile": 0.37889}, "CVE-2024-2964": {"epss_score": 0.00107, "epss_percentile": 0.29688}, "CVE-2024-2965": {"epss_score": 0.00038, "epss_percentile": 0.11234}, "CVE-2024-2966": {"epss_score": 0.00642, "epss_percentile": 0.70043}, "CVE-2024-2967": {"epss_score": 0.00288, "epss_percentile": 0.51902}, "CVE-2024-2968": {"epss_score": 0.00164, "epss_percentile": 0.37889}, "CVE-2024-2969": {"epss_score": 0.00131, "epss_percentile": 0.33343}, "CVE-2024-2970": {"epss_score": 0.00102, "epss_percentile": 0.28749}, "CVE-2024-2971": {"epss_score": 0.0003, "epss_percentile": 0.08194}, "CVE-2024-2972": {"epss_score": 0.00093, "epss_percentile": 0.26713}, "CVE-2024-2973": {"epss_score": 0.00018, "epss_percentile": 0.03915}, "CVE-2024-2974": {"epss_score": 0.00392, "epss_percentile": 0.59647}, "CVE-2024-2975": {"epss_score": 0.00406, "epss_percentile": 0.60558}, "CVE-2024-2976": {"epss_score": 0.01003, "epss_percentile": 0.76513}, "CVE-2024-2977": {"epss_score": 0.00522, "epss_percentile": 0.66271}, "CVE-2024-2978": {"epss_score": 0.00801, "epss_percentile": 0.73574}, "CVE-2024-2979": {"epss_score": 0.00801, "epss_percentile": 0.73574}, "CVE-2024-2980": {"epss_score": 0.01185, "epss_percentile": 0.7834}, "CVE-2024-2981": {"epss_score": 0.01185, "epss_percentile": 0.7834}, "CVE-2024-2982": {"epss_score": 0.0289, "epss_percentile": 0.85917}, "CVE-2024-2983": {"epss_score": 0.00684, "epss_percentile": 0.7111}, "CVE-2024-2984": {"epss_score": 0.00684, "epss_percentile": 0.7111}, "CVE-2024-2985": {"epss_score": 0.01012, "epss_percentile": 0.76625}, "CVE-2024-2986": {"epss_score": 0.00801, "epss_percentile": 0.73574}, "CVE-2024-2987": {"epss_score": 0.00723, "epss_percentile": 0.72019}, "CVE-2024-2988": {"epss_score": 0.00533, "epss_percentile": 0.66767}, "CVE-2024-2989": {"epss_score": 0.00354, "epss_percentile": 0.57207}, "CVE-2024-2990": {"epss_score": 0.00354, "epss_percentile": 0.57207}, "CVE-2024-2991": {"epss_score": 0.04587, "epss_percentile": 0.88887}, "CVE-2024-2992": {"epss_score": 0.00861, "epss_percentile": 0.74547}, "CVE-2024-2993": {"epss_score": 0.00325, "epss_percentile": 0.55019}, "CVE-2024-2994": {"epss_score": 0.00533, "epss_percentile": 0.66767}, "CVE-2024-2995": {"epss_score": 0.00031, "epss_percentile": 0.08538}, "CVE-2024-2996": {"epss_score": 0.0011, "epss_percentile": 0.3015}, "CVE-2024-2997": {"epss_score": 0.03268, "epss_percentile": 0.86787}, "CVE-2024-2998": {"epss_score": 0.00082, "epss_percentile": 0.24509}, "CVE-2024-2999": {"epss_score": 0.0006, "epss_percentile": 0.19012}, "CVE-2024-30000": {"epss_score": 0.00261, "epss_percentile": 0.49299}, "CVE-2024-30001": {"epss_score": 0.00261, "epss_percentile": 0.49299}, "CVE-2024-30002": {"epss_score": 0.00248, "epss_percentile": 0.47928}, "CVE-2024-30003": {"epss_score": 0.00261, "epss_percentile": 0.49299}, "CVE-2024-30004": {"epss_score": 0.00396, "epss_percentile": 0.59896}, "CVE-2024-30005": {"epss_score": 0.00261, "epss_percentile": 0.49299}, "CVE-2024-30006": {"epss_score": 0.05419, "epss_percentile": 0.89854}, "CVE-2024-30007": {"epss_score": 0.01245, "epss_percentile": 0.78841}, "CVE-2024-30008": {"epss_score": 0.00262, "epss_percentile": 0.49365}, "CVE-2024-30009": {"epss_score": 0.0478, "epss_percentile": 0.89136}, "CVE-2024-30010": {"epss_score": 0.10401, "epss_percentile": 0.92976}, "CVE-2024-30011": {"epss_score": 0.0226, "epss_percentile": 0.84186}, "CVE-2024-30012": {"epss_score": 0.00261, "epss_percentile": 0.49299}, "CVE-2024-30013": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-30014": {"epss_score": 0.01759, "epss_percentile": 0.8214}, "CVE-2024-30015": {"epss_score": 0.01759, "epss_percentile": 0.8214}, "CVE-2024-30016": {"epss_score": 0.0019, "epss_percentile": 0.41121}, "CVE-2024-30017": {"epss_score": 0.09341, "epss_percentile": 0.92508}, "CVE-2024-30018": {"epss_score": 0.00533, "epss_percentile": 0.66774}, "CVE-2024-30019": {"epss_score": 0.01018, "epss_percentile": 0.76708}, "CVE-2024-30020": {"epss_score": 0.04313, "epss_percentile": 0.88535}, "CVE-2024-30021": {"epss_score": 0.00482, "epss_percentile": 0.64537}, "CVE-2024-30022": {"epss_score": 0.01776, "epss_percentile": 0.82222}, "CVE-2024-30023": {"epss_score": 0.01776, "epss_percentile": 0.82222}, "CVE-2024-30024": {"epss_score": 0.01776, "epss_percentile": 0.82222}, "CVE-2024-30025": {"epss_score": 0.03014, "epss_percentile": 0.86206}, "CVE-2024-30027": {"epss_score": 0.00344, "epss_percentile": 0.56504}, "CVE-2024-30028": {"epss_score": 0.00347, "epss_percentile": 0.56794}, "CVE-2024-30029": {"epss_score": 0.01759, "epss_percentile": 0.8214}, "CVE-2024-30030": {"epss_score": 0.00589, "epss_percentile": 0.6852}, "CVE-2024-30031": {"epss_score": 0.00146, "epss_percentile": 0.35547}, "CVE-2024-30032": {"epss_score": 0.02626, "epss_percentile": 0.85268}, "CVE-2024-30033": {"epss_score": 0.00727, "epss_percentile": 0.72083}, "CVE-2024-30034": {"epss_score": 0.0307, "epss_percentile": 0.86344}, "CVE-2024-30035": {"epss_score": 0.02626, "epss_percentile": 0.85268}, "CVE-2024-30036": {"epss_score": 0.0717, "epss_percentile": 0.91297}, "CVE-2024-30037": {"epss_score": 0.02531, "epss_percentile": 0.85024}, "CVE-2024-30038": {"epss_score": 0.07888, "epss_percentile": 0.91745}, "CVE-2024-30039": {"epss_score": 0.00351, "epss_percentile": 0.57055}, "CVE-2024-30040": {"epss_score": 0.23487, "epss_percentile": 0.95784}, "CVE-2024-30041": {"epss_score": 0.02451, "epss_percentile": 0.84784}, "CVE-2024-30042": {"epss_score": 0.00257, "epss_percentile": 0.48874}, "CVE-2024-30043": {"epss_score": 0.54146, "epss_percentile": 0.97913}, "CVE-2024-30044": {"epss_score": 0.47823, "epss_percentile": 0.97603}, "CVE-2024-30045": {"epss_score": 0.00354, "epss_percentile": 0.57231}, "CVE-2024-30046": {"epss_score": 0.0018, "epss_percentile": 0.39883}, "CVE-2024-30047": {"epss_score": 0.00674, "epss_percentile": 0.70847}, "CVE-2024-30048": {"epss_score": 0.00674, "epss_percentile": 0.70847}, "CVE-2024-30049": {"epss_score": 0.0064, "epss_percentile": 0.69974}, "CVE-2024-30050": {"epss_score": 0.09191, "epss_percentile": 0.92441}, "CVE-2024-30051": {"epss_score": 0.53879, "epss_percentile": 0.97901}, "CVE-2024-30052": {"epss_score": 0.01605, "epss_percentile": 0.81289}, "CVE-2024-30053": {"epss_score": 0.01435, "epss_percentile": 0.80272}, "CVE-2024-30054": {"epss_score": 0.12217, "epss_percentile": 0.93603}, "CVE-2024-30055": {"epss_score": 0.01537, "epss_percentile": 0.80922}, "CVE-2024-30056": {"epss_score": 0.09715, "epss_percentile": 0.92674}, "CVE-2024-30057": {"epss_score": 0.00599, "epss_percentile": 0.68808}, "CVE-2024-30058": {"epss_score": 0.00306, "epss_percentile": 0.53404}, "CVE-2024-30059": {"epss_score": 0.00164, "epss_percentile": 0.3788}, "CVE-2024-30060": {"epss_score": 0.01303, "epss_percentile": 0.79306}, "CVE-2024-30061": {"epss_score": 0.05032, "epss_percentile": 0.89416}, "CVE-2024-30062": {"epss_score": 0.00972, "epss_percentile": 0.76132}, "CVE-2024-30063": {"epss_score": 0.00318, "epss_percentile": 0.54436}, "CVE-2024-30064": {"epss_score": 0.00489, "epss_percentile": 0.64877}, "CVE-2024-30065": {"epss_score": 0.00126, "epss_percentile": 0.32744}, "CVE-2024-30066": {"epss_score": 0.00284, "epss_percentile": 0.51417}, "CVE-2024-30067": {"epss_score": 0.00828, "epss_percentile": 0.74005}, "CVE-2024-30068": {"epss_score": 0.00311, "epss_percentile": 0.53824}, "CVE-2024-30069": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2024-30070": {"epss_score": 0.03961, "epss_percentile": 0.88013}, "CVE-2024-30071": {"epss_score": 0.00297, "epss_percentile": 0.52756}, "CVE-2024-30072": {"epss_score": 0.0033, "epss_percentile": 0.55451}, "CVE-2024-30073": {"epss_score": 0.00457, "epss_percentile": 0.63375}, "CVE-2024-30074": {"epss_score": 0.00745, "epss_percentile": 0.7253}, "CVE-2024-30075": {"epss_score": 0.00738, "epss_percentile": 0.72337}, "CVE-2024-30076": {"epss_score": 0.00691, "epss_percentile": 0.7126}, "CVE-2024-30077": {"epss_score": 0.05619, "epss_percentile": 0.90058}, "CVE-2024-30078": {"epss_score": 0.22468, "epss_percentile": 0.95638}, "CVE-2024-30079": {"epss_score": 0.00852, "epss_percentile": 0.74417}, "CVE-2024-30080": {"epss_score": 0.14536, "epss_percentile": 0.94235}, "CVE-2024-30081": {"epss_score": 0.17933, "epss_percentile": 0.94929}, "CVE-2024-30082": {"epss_score": 0.00232, "epss_percentile": 0.45925}, "CVE-2024-30083": {"epss_score": 0.08611, "epss_percentile": 0.92151}, "CVE-2024-30084": {"epss_score": 0.00905, "epss_percentile": 0.75243}, "CVE-2024-30085": {"epss_score": 0.48596, "epss_percentile": 0.97644}, "CVE-2024-30086": {"epss_score": 0.00479, "epss_percentile": 0.64415}, "CVE-2024-30087": {"epss_score": 0.01912, "epss_percentile": 0.82832}, "CVE-2024-30088": {"epss_score": 0.88973, "epss_percentile": 0.99502}, "CVE-2024-30089": {"epss_score": 0.02295, "epss_percentile": 0.84293}, "CVE-2024-30090": {"epss_score": 0.20925, "epss_percentile": 0.95443}, "CVE-2024-30091": {"epss_score": 0.03525, "epss_percentile": 0.87294}, "CVE-2024-30092": {"epss_score": 0.0038, "epss_percentile": 0.58929}, "CVE-2024-30093": {"epss_score": 0.00677, "epss_percentile": 0.70958}, "CVE-2024-30094": {"epss_score": 0.00962, "epss_percentile": 0.7599}, "CVE-2024-30095": {"epss_score": 0.00972, "epss_percentile": 0.76132}, "CVE-2024-30096": {"epss_score": 0.00432, "epss_percentile": 0.62129}, "CVE-2024-30097": {"epss_score": 0.04065, "epss_percentile": 0.88197}, "CVE-2024-30098": {"epss_score": 0.03746, "epss_percentile": 0.87662}, "CVE-2024-30099": {"epss_score": 0.00076, "epss_percentile": 0.23169}, "CVE-2024-30100": {"epss_score": 0.00529, "epss_percentile": 0.66581}, "CVE-2024-30101": {"epss_score": 0.01138, "epss_percentile": 0.77929}, "CVE-2024-30102": {"epss_score": 0.01827, "epss_percentile": 0.82439}, "CVE-2024-30103": {"epss_score": 0.14962, "epss_percentile": 0.94334}, "CVE-2024-30104": {"epss_score": 0.00583, "epss_percentile": 0.68333}, "CVE-2024-30105": {"epss_score": 0.01793, "epss_percentile": 0.8229}, "CVE-2024-30106": {"epss_score": 0.00364, "epss_percentile": 0.57926}, "CVE-2024-30107": {"epss_score": 0.00263, "epss_percentile": 0.49544}, "CVE-2024-30109": {"epss_score": 0.00353, "epss_percentile": 0.5714}, "CVE-2024-30110": {"epss_score": 0.00377, "epss_percentile": 0.5869}, "CVE-2024-30111": {"epss_score": 0.00395, "epss_percentile": 0.59848}, "CVE-2024-30112": {"epss_score": 0.00864, "epss_percentile": 0.746}, "CVE-2024-30113": {"epss_score": 0.00046, "epss_percentile": 0.14433}, "CVE-2024-30114": {"epss_score": 0.00041, "epss_percentile": 0.12399}, "CVE-2024-30115": {"epss_score": 0.0003, "epss_percentile": 0.08273}, "CVE-2024-30117": {"epss_score": 0.00075, "epss_percentile": 0.22996}, "CVE-2024-30118": {"epss_score": 0.00381, "epss_percentile": 0.59017}, "CVE-2024-30119": {"epss_score": 0.00035, "epss_percentile": 0.09927}, "CVE-2024-30120": {"epss_score": 0.00032, "epss_percentile": 0.08764}, "CVE-2024-30122": {"epss_score": 0.0016, "epss_percentile": 0.37428}, "CVE-2024-30124": {"epss_score": 0.00045, "epss_percentile": 0.13682}, "CVE-2024-30125": {"epss_score": 0.00088, "epss_percentile": 0.2579}, "CVE-2024-30126": {"epss_score": 0.00547, "epss_percentile": 0.67258}, "CVE-2024-30127": {"epss_score": 0.00019, "epss_percentile": 0.04096}, "CVE-2024-30128": {"epss_score": 0.00406, "epss_percentile": 0.60527}, "CVE-2024-30129": {"epss_score": 0.00111, "epss_percentile": 0.30324}, "CVE-2024-30130": {"epss_score": 0.00313, "epss_percentile": 0.54061}, "CVE-2024-30132": {"epss_score": 0.00367, "epss_percentile": 0.58108}, "CVE-2024-30133": {"epss_score": 0.00234, "epss_percentile": 0.46115}, "CVE-2024-30134": {"epss_score": 0.00159, "epss_percentile": 0.37408}, "CVE-2024-30135": {"epss_score": 0.00389, "epss_percentile": 0.59406}, "CVE-2024-30140": {"epss_score": 0.00144, "epss_percentile": 0.35316}, "CVE-2024-30141": {"epss_score": 0.00132, "epss_percentile": 0.3354}, "CVE-2024-30142": {"epss_score": 0.00032, "epss_percentile": 0.08816}, "CVE-2024-30143": {"epss_score": 0.00162, "epss_percentile": 0.3769}, "CVE-2024-30145": {"epss_score": 0.0004, "epss_percentile": 0.11987}, "CVE-2024-30146": {"epss_score": 0.00028, "epss_percentile": 0.07275}, "CVE-2024-30147": {"epss_score": 0.00047, "epss_percentile": 0.14633}, "CVE-2024-30148": {"epss_score": 0.00048, "epss_percentile": 0.15277}, "CVE-2024-30149": {"epss_score": 0.00053, "epss_percentile": 0.17008}, "CVE-2024-30150": {"epss_score": 0.00107, "epss_percentile": 0.29617}, "CVE-2024-30152": {"epss_score": 0.00022, "epss_percentile": 0.05063}, "CVE-2024-30154": {"epss_score": 0.0004, "epss_percentile": 0.12108}, "CVE-2024-30155": {"epss_score": 0.00037, "epss_percentile": 0.1079}, "CVE-2024-30156": {"epss_score": 0.00071, "epss_percentile": 0.22144}, "CVE-2024-30157": {"epss_score": 0.00346, "epss_percentile": 0.56629}, "CVE-2024-30158": {"epss_score": 0.00357, "epss_percentile": 0.57474}, "CVE-2024-30159": {"epss_score": 0.00474, "epss_percentile": 0.64159}, "CVE-2024-30160": {"epss_score": 0.00474, "epss_percentile": 0.64159}, "CVE-2024-30161": {"epss_score": 0.0008, "epss_percentile": 0.24195}, "CVE-2024-30162": {"epss_score": 0.00511, "epss_percentile": 0.65833}, "CVE-2024-30163": {"epss_score": 0.46372, "epss_percentile": 0.97543}, "CVE-2024-30164": {"epss_score": 0.00054, "epss_percentile": 0.17132}, "CVE-2024-30165": {"epss_score": 0.00149, "epss_percentile": 0.35957}, "CVE-2024-30166": {"epss_score": 0.00348, "epss_percentile": 0.56817}, "CVE-2024-30170": {"epss_score": 0.00433, "epss_percentile": 0.62174}, "CVE-2024-30171": {"epss_score": 0.001, "epss_percentile": 0.28545}, "CVE-2024-30172": {"epss_score": 0.00136, "epss_percentile": 0.34173}, "CVE-2024-30176": {"epss_score": 0.00258, "epss_percentile": 0.48949}, "CVE-2024-30177": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-30178": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-30179": {"epss_score": 0.00188, "epss_percentile": 0.4088}, "CVE-2024-30180": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-30181": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-30182": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-30183": {"epss_score": 0.00197, "epss_percentile": 0.41947}, "CVE-2024-30184": {"epss_score": 0.00197, "epss_percentile": 0.41947}, "CVE-2024-30185": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-30186": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-30187": {"epss_score": 0.00062, "epss_percentile": 0.19754}, "CVE-2024-30188": {"epss_score": 0.88243, "epss_percentile": 0.99463}, "CVE-2024-30189": {"epss_score": 0.00091, "epss_percentile": 0.26188}, "CVE-2024-30190": {"epss_score": 0.00067, "epss_percentile": 0.21102}, "CVE-2024-30191": {"epss_score": 0.00086, "epss_percentile": 0.25297}, "CVE-2024-30192": {"epss_score": 0.00133, "epss_percentile": 0.33646}, "CVE-2024-30193": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-30194": {"epss_score": 0.11985, "epss_percentile": 0.93536}, "CVE-2024-30195": {"epss_score": 0.00195, "epss_percentile": 0.41652}, "CVE-2024-30196": {"epss_score": 0.00144, "epss_percentile": 0.35232}, "CVE-2024-30197": {"epss_score": 0.00186, "epss_percentile": 0.40594}, "CVE-2024-30198": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2024-30199": {"epss_score": 0.00321, "epss_percentile": 0.54648}, "CVE-2024-30200": {"epss_score": 0.00211, "epss_percentile": 0.43707}, "CVE-2024-30201": {"epss_score": 0.00354, "epss_percentile": 0.57229}, "CVE-2024-30202": {"epss_score": 0.00049, "epss_percentile": 0.15574}, "CVE-2024-30203": {"epss_score": 0.00027, "epss_percentile": 0.06928}, "CVE-2024-30204": {"epss_score": 0.00017, "epss_percentile": 0.03296}, "CVE-2024-30205": {"epss_score": 0.0003, "epss_percentile": 0.0816}, "CVE-2024-30206": {"epss_score": 0.00804, "epss_percentile": 0.73609}, "CVE-2024-30207": {"epss_score": 0.01902, "epss_percentile": 0.82782}, "CVE-2024-30208": {"epss_score": 0.00045, "epss_percentile": 0.13701}, "CVE-2024-30209": {"epss_score": 0.00072, "epss_percentile": 0.22249}, "CVE-2024-30210": {"epss_score": 0.00142, "epss_percentile": 0.35011}, "CVE-2024-30211": {"epss_score": 0.00022, "epss_percentile": 0.05225}, "CVE-2024-30212": {"epss_score": 0.00251, "epss_percentile": 0.48258}, "CVE-2024-30213": {"epss_score": 0.0667, "epss_percentile": 0.90933}, "CVE-2024-30214": {"epss_score": 0.00148, "epss_percentile": 0.35872}, "CVE-2024-30215": {"epss_score": 0.00148, "epss_percentile": 0.3583}, "CVE-2024-30216": {"epss_score": 0.0007, "epss_percentile": 0.21824}, "CVE-2024-30217": {"epss_score": 0.0007, "epss_percentile": 0.21824}, "CVE-2024-30218": {"epss_score": 0.00167, "epss_percentile": 0.38401}, "CVE-2024-30219": {"epss_score": 0.00054, "epss_percentile": 0.17149}, "CVE-2024-30220": {"epss_score": 0.00158, "epss_percentile": 0.37167}, "CVE-2024-30221": {"epss_score": 0.00507, "epss_percentile": 0.6566}, "CVE-2024-30222": {"epss_score": 0.01089, "epss_percentile": 0.7744}, "CVE-2024-30223": {"epss_score": 0.01133, "epss_percentile": 0.77882}, "CVE-2024-30224": {"epss_score": 0.00949, "epss_percentile": 0.75837}, "CVE-2024-30225": {"epss_score": 0.00634, "epss_percentile": 0.69789}, "CVE-2024-30226": {"epss_score": 0.1182, "epss_percentile": 0.93486}, "CVE-2024-30227": {"epss_score": 0.00168, "epss_percentile": 0.38475}, "CVE-2024-30228": {"epss_score": 0.00632, "epss_percentile": 0.6975}, "CVE-2024-30229": {"epss_score": 0.00613, "epss_percentile": 0.69254}, "CVE-2024-30230": {"epss_score": 0.00247, "epss_percentile": 0.47851}, "CVE-2024-30231": {"epss_score": 0.00819, "epss_percentile": 0.73869}, "CVE-2024-30232": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-30233": {"epss_score": 0.00577, "epss_percentile": 0.68154}, "CVE-2024-30234": {"epss_score": 0.00368, "epss_percentile": 0.58192}, "CVE-2024-30235": {"epss_score": 0.00428, "epss_percentile": 0.61927}, "CVE-2024-30236": {"epss_score": 0.00498, "epss_percentile": 0.65214}, "CVE-2024-30237": {"epss_score": 0.0037, "epss_percentile": 0.58287}, "CVE-2024-30238": {"epss_score": 0.00498, "epss_percentile": 0.65214}, "CVE-2024-30239": {"epss_score": 0.00261, "epss_percentile": 0.49249}, "CVE-2024-30240": {"epss_score": 0.00349, "epss_percentile": 0.5686}, "CVE-2024-30241": {"epss_score": 0.03541, "epss_percentile": 0.87319}, "CVE-2024-30242": {"epss_score": 0.00281, "epss_percentile": 0.51131}, "CVE-2024-30243": {"epss_score": 0.00428, "epss_percentile": 0.61954}, "CVE-2024-30244": {"epss_score": 0.00271, "epss_percentile": 0.50299}, "CVE-2024-30245": {"epss_score": 0.00198, "epss_percentile": 0.42092}, "CVE-2024-30246": {"epss_score": 0.00067, "epss_percentile": 0.21095}, "CVE-2024-30247": {"epss_score": 0.01339, "epss_percentile": 0.79574}, "CVE-2024-30248": {"epss_score": 0.00098, "epss_percentile": 0.27648}, "CVE-2024-30249": {"epss_score": 0.00144, "epss_percentile": 0.35236}, "CVE-2024-30250": {"epss_score": 0.00222, "epss_percentile": 0.44809}, "CVE-2024-30251": {"epss_score": 0.00359, "epss_percentile": 0.57608}, "CVE-2024-30252": {"epss_score": 0.0006, "epss_percentile": 0.19104}, "CVE-2024-30253": {"epss_score": 0.00142, "epss_percentile": 0.35048}, "CVE-2024-30254": {"epss_score": 0.00061, "epss_percentile": 0.19489}, "CVE-2024-30255": {"epss_score": 0.88805, "epss_percentile": 0.99491}, "CVE-2024-30256": {"epss_score": 0.00234, "epss_percentile": 0.4616}, "CVE-2024-30257": {"epss_score": 0.00136, "epss_percentile": 0.34201}, "CVE-2024-30258": {"epss_score": 0.01297, "epss_percentile": 0.7927}, "CVE-2024-30259": {"epss_score": 0.01101, "epss_percentile": 0.77575}, "CVE-2024-30260": {"epss_score": 0.00188, "epss_percentile": 0.40875}, "CVE-2024-30261": {"epss_score": 0.00092, "epss_percentile": 0.26581}, "CVE-2024-30262": {"epss_score": 0.00212, "epss_percentile": 0.43821}, "CVE-2024-30263": {"epss_score": 0.00073, "epss_percentile": 0.22616}, "CVE-2024-30264": {"epss_score": 0.00132, "epss_percentile": 0.33585}, "CVE-2024-30265": {"epss_score": 0.00236, "epss_percentile": 0.46371}, "CVE-2024-30266": {"epss_score": 0.0002, "epss_percentile": 0.04535}, "CVE-2024-30268": {"epss_score": 0.00201, "epss_percentile": 0.42277}, "CVE-2024-30269": {"epss_score": 0.92096, "epss_percentile": 0.99691}, "CVE-2024-30270": {"epss_score": 0.4944, "epss_percentile": 0.97686}, "CVE-2024-30271": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-30272": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-30273": {"epss_score": 0.00196, "epss_percentile": 0.41784}, "CVE-2024-30274": {"epss_score": 0.00186, "epss_percentile": 0.40629}, "CVE-2024-30275": {"epss_score": 0.00208, "epss_percentile": 0.4322}, "CVE-2024-30276": {"epss_score": 0.00046, "epss_percentile": 0.14318}, "CVE-2024-30278": {"epss_score": 0.00038, "epss_percentile": 0.11367}, "CVE-2024-30279": {"epss_score": 0.0138, "epss_percentile": 0.79861}, "CVE-2024-30280": {"epss_score": 0.01796, "epss_percentile": 0.82307}, "CVE-2024-30281": {"epss_score": 0.00029, "epss_percentile": 0.07768}, "CVE-2024-30282": {"epss_score": 0.00124, "epss_percentile": 0.32378}, "CVE-2024-30283": {"epss_score": 0.00033, "epss_percentile": 0.09151}, "CVE-2024-30284": {"epss_score": 0.0084, "epss_percentile": 0.7421}, "CVE-2024-30285": {"epss_score": 0.00131, "epss_percentile": 0.33376}, "CVE-2024-30286": {"epss_score": 0.00033, "epss_percentile": 0.09151}, "CVE-2024-30287": {"epss_score": 0.00033, "epss_percentile": 0.09151}, "CVE-2024-30288": {"epss_score": 0.00281, "epss_percentile": 0.51192}, "CVE-2024-30289": {"epss_score": 0.00281, "epss_percentile": 0.51192}, "CVE-2024-30290": {"epss_score": 0.00229, "epss_percentile": 0.45584}, "CVE-2024-30291": {"epss_score": 0.00201, "epss_percentile": 0.42347}, "CVE-2024-30292": {"epss_score": 0.00201, "epss_percentile": 0.42347}, "CVE-2024-30293": {"epss_score": 0.00152, "epss_percentile": 0.36495}, "CVE-2024-30294": {"epss_score": 0.00152, "epss_percentile": 0.36495}, "CVE-2024-30295": {"epss_score": 0.00229, "epss_percentile": 0.45584}, "CVE-2024-30296": {"epss_score": 0.00229, "epss_percentile": 0.45584}, "CVE-2024-30297": {"epss_score": 0.00229, "epss_percentile": 0.45584}, "CVE-2024-30298": {"epss_score": 0.00043, "epss_percentile": 0.12968}, "CVE-2024-30299": {"epss_score": 0.0083, "epss_percentile": 0.74017}, "CVE-2024-30300": {"epss_score": 0.0088, "epss_percentile": 0.74857}, "CVE-2024-30301": {"epss_score": 0.00157, "epss_percentile": 0.3703}, "CVE-2024-30302": {"epss_score": 0.0003, "epss_percentile": 0.08229}, "CVE-2024-30303": {"epss_score": 0.00157, "epss_percentile": 0.3703}, "CVE-2024-30304": {"epss_score": 0.00157, "epss_percentile": 0.3703}, "CVE-2024-30305": {"epss_score": 0.00157, "epss_percentile": 0.3703}, "CVE-2024-30306": {"epss_score": 0.00183, "epss_percentile": 0.40365}, "CVE-2024-30307": {"epss_score": 0.00343, "epss_percentile": 0.56458}, "CVE-2024-30308": {"epss_score": 0.00051, "epss_percentile": 0.16164}, "CVE-2024-30309": {"epss_score": 0.00051, "epss_percentile": 0.16164}, "CVE-2024-30310": {"epss_score": 0.00716, "epss_percentile": 0.71867}, "CVE-2024-30311": {"epss_score": 0.00043, "epss_percentile": 0.1333}, "CVE-2024-30312": {"epss_score": 0.00035, "epss_percentile": 0.09922}, "CVE-2024-30314": {"epss_score": 0.00303, "epss_percentile": 0.53191}, "CVE-2024-30321": {"epss_score": 0.00261, "epss_percentile": 0.49272}, "CVE-2024-30322": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30323": {"epss_score": 0.01427, "epss_percentile": 0.80211}, "CVE-2024-30324": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30325": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30326": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30327": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30328": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30329": {"epss_score": 0.00494, "epss_percentile": 0.65085}, "CVE-2024-30330": {"epss_score": 0.01949, "epss_percentile": 0.83011}, "CVE-2024-30331": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30332": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30333": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30334": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30335": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2024-30336": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30337": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30338": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30339": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30340": {"epss_score": 0.00314, "epss_percentile": 0.5414}, "CVE-2024-30341": {"epss_score": 0.01249, "epss_percentile": 0.78872}, "CVE-2024-30342": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30343": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30344": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30345": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30346": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30347": {"epss_score": 0.00313, "epss_percentile": 0.54036}, "CVE-2024-30348": {"epss_score": 0.01623, "epss_percentile": 0.81402}, "CVE-2024-30349": {"epss_score": 0.01623, "epss_percentile": 0.81402}, "CVE-2024-30350": {"epss_score": 0.00314, "epss_percentile": 0.5414}, "CVE-2024-30351": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30352": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30353": {"epss_score": 0.01427, "epss_percentile": 0.80211}, "CVE-2024-30354": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30355": {"epss_score": 0.01427, "epss_percentile": 0.80211}, "CVE-2024-30356": {"epss_score": 0.00314, "epss_percentile": 0.5414}, "CVE-2024-30357": {"epss_score": 0.0123, "epss_percentile": 0.78727}, "CVE-2024-30358": {"epss_score": 0.01926, "epss_percentile": 0.82926}, "CVE-2024-30359": {"epss_score": 0.01427, "epss_percentile": 0.80211}, "CVE-2024-30360": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30361": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30362": {"epss_score": 0.02525, "epss_percentile": 0.85011}, "CVE-2024-30363": {"epss_score": 0.00324, "epss_percentile": 0.54961}, "CVE-2024-30364": {"epss_score": 0.00358, "epss_percentile": 0.57522}, "CVE-2024-30365": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30366": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30367": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30368": {"epss_score": 0.05255, "epss_percentile": 0.89667}, "CVE-2024-30369": {"epss_score": 0.00046, "epss_percentile": 0.14432}, "CVE-2024-30370": {"epss_score": 0.00492, "epss_percentile": 0.65006}, "CVE-2024-30371": {"epss_score": 0.02223, "epss_percentile": 0.84063}, "CVE-2024-30372": {"epss_score": 0.0537, "epss_percentile": 0.89793}, "CVE-2024-30373": {"epss_score": 0.00717, "epss_percentile": 0.71915}, "CVE-2024-30374": {"epss_score": 0.00457, "epss_percentile": 0.63394}, "CVE-2024-30375": {"epss_score": 0.00566, "epss_percentile": 0.67831}, "CVE-2024-30376": {"epss_score": 0.00021, "epss_percentile": 0.04784}, "CVE-2024-30377": {"epss_score": 0.00073, "epss_percentile": 0.22541}, "CVE-2024-30378": {"epss_score": 0.00051, "epss_percentile": 0.16266}, "CVE-2024-30380": {"epss_score": 0.00102, "epss_percentile": 0.28756}, "CVE-2024-30381": {"epss_score": 0.00028, "epss_percentile": 0.07562}, "CVE-2024-30382": {"epss_score": 0.00493, "epss_percentile": 0.6504}, "CVE-2024-30384": {"epss_score": 0.00048, "epss_percentile": 0.14962}, "CVE-2024-30386": {"epss_score": 0.00078, "epss_percentile": 0.23777}, "CVE-2024-30387": {"epss_score": 0.00068, "epss_percentile": 0.2135}, "CVE-2024-30388": {"epss_score": 0.00031, "epss_percentile": 0.08474}, "CVE-2024-30389": {"epss_score": 0.00162, "epss_percentile": 0.37701}, "CVE-2024-30390": {"epss_score": 0.00076, "epss_percentile": 0.23261}, "CVE-2024-30391": {"epss_score": 0.00115, "epss_percentile": 0.30883}, "CVE-2024-30392": {"epss_score": 0.00104, "epss_percentile": 0.29158}, "CVE-2024-30394": {"epss_score": 0.00247, "epss_percentile": 0.47854}, "CVE-2024-30395": {"epss_score": 0.00136, "epss_percentile": 0.34162}, "CVE-2024-30397": {"epss_score": 0.00255, "epss_percentile": 0.48628}, "CVE-2024-30398": {"epss_score": 0.00197, "epss_percentile": 0.41909}, "CVE-2024-30401": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2024-30402": {"epss_score": 0.00174, "epss_percentile": 0.39154}, "CVE-2024-30403": {"epss_score": 0.00076, "epss_percentile": 0.23081}, "CVE-2024-30405": {"epss_score": 0.00145, "epss_percentile": 0.35415}, "CVE-2024-30406": {"epss_score": 0.00018, "epss_percentile": 0.03745}, "CVE-2024-30407": {"epss_score": 0.00191, "epss_percentile": 0.41185}, "CVE-2024-30409": {"epss_score": 0.00088, "epss_percentile": 0.25741}, "CVE-2024-30410": {"epss_score": 0.00257, "epss_percentile": 0.48922}, "CVE-2024-30413": {"epss_score": 0.00072, "epss_percentile": 0.22313}, "CVE-2024-30414": {"epss_score": 0.00694, "epss_percentile": 0.7134}, "CVE-2024-30415": {"epss_score": 0.00069, "epss_percentile": 0.21508}, "CVE-2024-30416": {"epss_score": 0.00084, "epss_percentile": 0.24885}, "CVE-2024-30417": {"epss_score": 0.0019, "epss_percentile": 0.41091}, "CVE-2024-30418": {"epss_score": 0.00072, "epss_percentile": 0.22313}, "CVE-2024-30419": {"epss_score": 0.00973, "epss_percentile": 0.76162}, "CVE-2024-30420": {"epss_score": 0.0028, "epss_percentile": 0.51022}, "CVE-2024-30421": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-30422": {"epss_score": 0.00179, "epss_percentile": 0.39766}, "CVE-2024-30423": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2024-30424": {"epss_score": 0.00119, "epss_percentile": 0.31594}, "CVE-2024-30425": {"epss_score": 0.00126, "epss_percentile": 0.32686}, "CVE-2024-30426": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2024-30427": {"epss_score": 0.00315, "epss_percentile": 0.5417}, "CVE-2024-30428": {"epss_score": 0.00196, "epss_percentile": 0.41801}, "CVE-2024-30429": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-30430": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2024-30431": {"epss_score": 0.00128, "epss_percentile": 0.33059}, "CVE-2024-30432": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-30433": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-30434": {"epss_score": 0.00062, "epss_percentile": 0.19628}, "CVE-2024-30435": {"epss_score": 0.00117, "epss_percentile": 0.31379}, "CVE-2024-30436": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-30437": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-30438": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-30439": {"epss_score": 0.00099, "epss_percentile": 0.28407}, "CVE-2024-30440": {"epss_score": 0.00062, "epss_percentile": 0.19628}, "CVE-2024-30441": {"epss_score": 0.00092, "epss_percentile": 0.26549}, "CVE-2024-30442": {"epss_score": 0.00063, "epss_percentile": 0.19832}, "CVE-2024-30443": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-30444": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-30445": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-30446": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-30447": {"epss_score": 0.00144, "epss_percentile": 0.35232}, "CVE-2024-30448": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-30449": {"epss_score": 0.00157, "epss_percentile": 0.37082}, "CVE-2024-30450": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-30451": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-30452": {"epss_score": 0.0015, "epss_percentile": 0.36104}, "CVE-2024-30453": {"epss_score": 0.00226, "epss_percentile": 0.45239}, "CVE-2024-30454": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2024-30455": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-30456": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2024-30457": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2024-30458": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2024-30459": {"epss_score": 0.00133, "epss_percentile": 0.33736}, "CVE-2024-30460": {"epss_score": 0.00125, "epss_percentile": 0.32512}, "CVE-2024-30461": {"epss_score": 0.00138, "epss_percentile": 0.34364}, "CVE-2024-30462": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2024-30463": {"epss_score": 0.00176, "epss_percentile": 0.39399}, "CVE-2024-30464": {"epss_score": 0.00158, "epss_percentile": 0.37285}, "CVE-2024-30465": {"epss_score": 0.00299, "epss_percentile": 0.52906}, "CVE-2024-30466": {"epss_score": 0.00158, "epss_percentile": 0.37285}, "CVE-2024-30467": {"epss_score": 0.00396, "epss_percentile": 0.59862}, "CVE-2024-30468": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-30469": {"epss_score": 0.00289, "epss_percentile": 0.5202}, "CVE-2024-30470": {"epss_score": 0.00298, "epss_percentile": 0.5282}, "CVE-2024-30471": {"epss_score": 0.01052, "epss_percentile": 0.77091}, "CVE-2024-30472": {"epss_score": 0.01729, "epss_percentile": 0.81983}, "CVE-2024-30473": {"epss_score": 0.00154, "epss_percentile": 0.36703}, "CVE-2024-30477": {"epss_score": 0.00562, "epss_percentile": 0.67707}, "CVE-2024-30478": {"epss_score": 0.00365, "epss_percentile": 0.57974}, "CVE-2024-30479": {"epss_score": 0.00132, "epss_percentile": 0.33612}, "CVE-2024-30480": {"epss_score": 0.00097, "epss_percentile": 0.27594}, "CVE-2024-30481": {"epss_score": 0.00093, "epss_percentile": 0.26741}, "CVE-2024-30482": {"epss_score": 0.00168, "epss_percentile": 0.3852}, "CVE-2024-30483": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2024-30484": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-30485": {"epss_score": 0.53456, "epss_percentile": 0.97877}, "CVE-2024-30486": {"epss_score": 0.00588, "epss_percentile": 0.6849}, "CVE-2024-30487": {"epss_score": 0.00224, "epss_percentile": 0.45012}, "CVE-2024-30488": {"epss_score": 0.00386, "epss_percentile": 0.59244}, "CVE-2024-30489": {"epss_score": 0.00152, "epss_percentile": 0.36465}, "CVE-2024-30490": {"epss_score": 0.00587, "epss_percentile": 0.68481}, "CVE-2024-30491": {"epss_score": 0.55211, "epss_percentile": 0.97966}, "CVE-2024-30492": {"epss_score": 0.00471, "epss_percentile": 0.63999}, "CVE-2024-30493": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-30494": {"epss_score": 0.00246, "epss_percentile": 0.47804}, "CVE-2024-30495": {"epss_score": 0.00365, "epss_percentile": 0.57974}, "CVE-2024-30496": {"epss_score": 0.00386, "epss_percentile": 0.59244}, "CVE-2024-30497": {"epss_score": 0.00386, "epss_percentile": 0.59244}, "CVE-2024-30498": {"epss_score": 0.00303, "epss_percentile": 0.53183}, "CVE-2024-30499": {"epss_score": 0.00386, "epss_percentile": 0.59244}, "CVE-2024-30500": {"epss_score": 0.00772, "epss_percentile": 0.73033}, "CVE-2024-30501": {"epss_score": 0.00584, "epss_percentile": 0.68383}, "CVE-2024-30502": {"epss_score": 0.00587, "epss_percentile": 0.68481}, "CVE-2024-30503": {"epss_score": 0.00253, "epss_percentile": 0.48494}, "CVE-2024-30504": {"epss_score": 0.00556, "epss_percentile": 0.67516}, "CVE-2024-30505": {"epss_score": 0.00105, "epss_percentile": 0.29381}, "CVE-2024-30506": {"epss_score": 0.00332, "epss_percentile": 0.55572}, "CVE-2024-30507": {"epss_score": 0.00114, "epss_percentile": 0.308}, "CVE-2024-30508": {"epss_score": 0.00243, "epss_percentile": 0.47512}, "CVE-2024-30509": {"epss_score": 0.01045, "epss_percentile": 0.77017}, "CVE-2024-30510": {"epss_score": 0.0091, "epss_percentile": 0.7532}, "CVE-2024-30511": {"epss_score": 0.00326, "epss_percentile": 0.55079}, "CVE-2024-30512": {"epss_score": 0.00639, "epss_percentile": 0.69953}, "CVE-2024-30513": {"epss_score": 0.00165, "epss_percentile": 0.38122}, "CVE-2024-30514": {"epss_score": 0.00326, "epss_percentile": 0.55079}, "CVE-2024-30515": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-30516": {"epss_score": 0.00101, "epss_percentile": 0.28691}, "CVE-2024-30517": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-30518": {"epss_score": 0.0016, "epss_percentile": 0.37423}, "CVE-2024-30519": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2024-30520": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2024-30521": {"epss_score": 0.00115, "epss_percentile": 0.30979}, "CVE-2024-30522": {"epss_score": 0.00102, "epss_percentile": 0.2883}, "CVE-2024-30523": {"epss_score": 0.00156, "epss_percentile": 0.36914}, "CVE-2024-30524": {"epss_score": 0.00081, "epss_percentile": 0.24347}, "CVE-2024-30525": {"epss_score": 0.00126, "epss_percentile": 0.32751}, "CVE-2024-30526": {"epss_score": 0.0007, "epss_percentile": 0.21758}, "CVE-2024-30527": {"epss_score": 0.00512, "epss_percentile": 0.65866}, "CVE-2024-30528": {"epss_score": 0.00077, "epss_percentile": 0.23538}, "CVE-2024-30529": {"epss_score": 0.00656, "epss_percentile": 0.70453}, "CVE-2024-30530": {"epss_score": 0.00081, "epss_percentile": 0.24347}, "CVE-2024-30531": {"epss_score": 0.00172, "epss_percentile": 0.39005}, "CVE-2024-30532": {"epss_score": 0.00164, "epss_percentile": 0.37909}, "CVE-2024-30533": {"epss_score": 0.00117, "epss_percentile": 0.31329}, "CVE-2024-30534": {"epss_score": 0.00188, "epss_percentile": 0.40837}, "CVE-2024-30535": {"epss_score": 0.00274, "epss_percentile": 0.5051}, "CVE-2024-30536": {"epss_score": 0.00077, "epss_percentile": 0.23521}, "CVE-2024-30537": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-30538": {"epss_score": 0.00472, "epss_percentile": 0.64057}, "CVE-2024-30539": {"epss_score": 0.00472, "epss_percentile": 0.64057}, "CVE-2024-30540": {"epss_score": 0.00162, "epss_percentile": 0.37667}, "CVE-2024-30541": {"epss_score": 0.00077, "epss_percentile": 0.23521}, "CVE-2024-30542": {"epss_score": 0.00682, "epss_percentile": 0.71076}, "CVE-2024-30543": {"epss_score": 0.0007, "epss_percentile": 0.21656}, "CVE-2024-30544": {"epss_score": 0.0026, "epss_percentile": 0.49196}, "CVE-2024-30545": {"epss_score": 0.00089, "epss_percentile": 0.25867}, "CVE-2024-30546": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-30547": {"epss_score": 0.00138, "epss_percentile": 0.34364}, "CVE-2024-30548": {"epss_score": 0.00062, "epss_percentile": 0.19628}, "CVE-2024-30549": {"epss_score": 0.00061, "epss_percentile": 0.19286}, "CVE-2024-30550": {"epss_score": 0.00115, "epss_percentile": 0.31018}, "CVE-2024-30551": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-30552": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-30553": {"epss_score": 0.00062, "epss_percentile": 0.19628}, "CVE-2024-30554": {"epss_score": 0.00059, "epss_percentile": 0.18704}, "CVE-2024-30555": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-30556": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-30557": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-30558": {"epss_score": 0.00117, "epss_percentile": 0.31379}, "CVE-2024-30559": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-30560": {"epss_score": 0.00112, "epss_percentile": 0.30494}, "CVE-2024-30561": {"epss_score": 0.00152, "epss_percentile": 0.36396}, "CVE-2024-30564": {"epss_score": 0.02969, "epss_percentile": 0.86092}, "CVE-2024-30565": {"epss_score": 0.02572, "epss_percentile": 0.85133}, "CVE-2024-30567": {"epss_score": 0.02699, "epss_percentile": 0.85449}, "CVE-2024-30568": {"epss_score": 0.90809, "epss_percentile": 0.99602}, "CVE-2024-30569": {"epss_score": 0.21139, "epss_percentile": 0.95469}, "CVE-2024-30570": {"epss_score": 0.12265, "epss_percentile": 0.93616}, "CVE-2024-30571": {"epss_score": 0.22016, "epss_percentile": 0.95584}, "CVE-2024-30572": {"epss_score": 0.00991, "epss_percentile": 0.76389}, "CVE-2024-30583": {"epss_score": 0.00172, "epss_percentile": 0.39037}, "CVE-2024-30584": {"epss_score": 0.00253, "epss_percentile": 0.48416}, "CVE-2024-30585": {"epss_score": 0.00123, "epss_percentile": 0.32231}, "CVE-2024-30586": {"epss_score": 0.00123, "epss_percentile": 0.32231}, "CVE-2024-30587": {"epss_score": 0.00318, "epss_percentile": 0.54404}, "CVE-2024-30588": {"epss_score": 0.00217, "epss_percentile": 0.4424}, "CVE-2024-30589": {"epss_score": 0.00369, "epss_percentile": 0.58235}, "CVE-2024-30590": {"epss_score": 0.00123, "epss_percentile": 0.32231}, "CVE-2024-30591": {"epss_score": 0.00175, "epss_percentile": 0.39327}, "CVE-2024-30592": {"epss_score": 0.00123, "epss_percentile": 0.32189}, "CVE-2024-30593": {"epss_score": 0.00369, "epss_percentile": 0.58235}, "CVE-2024-30594": {"epss_score": 0.00123, "epss_percentile": 0.32231}, "CVE-2024-30595": {"epss_score": 0.00369, "epss_percentile": 0.58235}, "CVE-2024-30596": {"epss_score": 0.00258, "epss_percentile": 0.48994}, "CVE-2024-30597": {"epss_score": 0.00123, "epss_percentile": 0.32231}, "CVE-2024-30598": {"epss_score": 0.00123, "epss_percentile": 0.32231}, "CVE-2024-30599": {"epss_score": 0.00334, "epss_percentile": 0.55718}, "CVE-2024-30600": {"epss_score": 0.00151, "epss_percentile": 0.36252}, "CVE-2024-30601": {"epss_score": 0.00164, "epss_percentile": 0.37952}, "CVE-2024-30602": {"epss_score": 0.00369, "epss_percentile": 0.58235}, "CVE-2024-30603": {"epss_score": 0.00069, "epss_percentile": 0.21498}, "CVE-2024-30604": {"epss_score": 0.00145, "epss_percentile": 0.35423}, "CVE-2024-30606": {"epss_score": 0.0012, "epss_percentile": 0.31738}, "CVE-2024-30607": {"epss_score": 0.00112, "epss_percentile": 0.30427}, "CVE-2024-30612": {"epss_score": 0.0023, "epss_percentile": 0.45743}, "CVE-2024-30613": {"epss_score": 0.00231, "epss_percentile": 0.45813}, "CVE-2024-30614": {"epss_score": 0.00145, "epss_percentile": 0.35409}, "CVE-2024-30616": {"epss_score": 0.00142, "epss_percentile": 0.34957}, "CVE-2024-30617": {"epss_score": 0.00119, "epss_percentile": 0.31578}, "CVE-2024-30618": {"epss_score": 0.00104, "epss_percentile": 0.29158}, "CVE-2024-30619": {"epss_score": 0.00156, "epss_percentile": 0.3698}, "CVE-2024-30620": {"epss_score": 0.00235, "epss_percentile": 0.46323}, "CVE-2024-30621": {"epss_score": 0.00172, "epss_percentile": 0.38991}, "CVE-2024-30622": {"epss_score": 0.00336, "epss_percentile": 0.55934}, "CVE-2024-30623": {"epss_score": 0.00123, "epss_percentile": 0.32231}, "CVE-2024-30624": {"epss_score": 0.00175, "epss_percentile": 0.39327}, "CVE-2024-30625": {"epss_score": 0.00175, "epss_percentile": 0.39345}, "CVE-2024-30626": {"epss_score": 0.00175, "epss_percentile": 0.39345}, "CVE-2024-30627": {"epss_score": 0.00334, "epss_percentile": 0.55718}, "CVE-2024-30628": {"epss_score": 0.00369, "epss_percentile": 0.58235}, "CVE-2024-30629": {"epss_score": 0.00123, "epss_percentile": 0.32244}, "CVE-2024-30630": {"epss_score": 0.00369, "epss_percentile": 0.58235}, "CVE-2024-30631": {"epss_score": 0.00231, "epss_percentile": 0.45813}, "CVE-2024-30632": {"epss_score": 0.00123, "epss_percentile": 0.32231}, "CVE-2024-30633": {"epss_score": 0.00123, "epss_percentile": 0.32231}, "CVE-2024-30634": {"epss_score": 0.00159, "epss_percentile": 0.37302}, "CVE-2024-30635": {"epss_score": 0.00369, "epss_percentile": 0.58235}, "CVE-2024-30636": {"epss_score": 0.00123, "epss_percentile": 0.32231}, "CVE-2024-30637": {"epss_score": 0.01143, "epss_percentile": 0.77983}, "CVE-2024-30638": {"epss_score": 0.00231, "epss_percentile": 0.45813}, "CVE-2024-30639": {"epss_score": 0.0007, "epss_percentile": 0.21939}, "CVE-2024-30645": {"epss_score": 0.00241, "epss_percentile": 0.47293}, "CVE-2024-30656": {"epss_score": 0.00105, "epss_percentile": 0.29314}, "CVE-2024-30799": {"epss_score": 0.00936, "epss_percentile": 0.75691}, "CVE-2024-30800": {"epss_score": 0.00032, "epss_percentile": 0.09102}, "CVE-2024-30801": {"epss_score": 0.00164, "epss_percentile": 0.37999}, "CVE-2024-30802": {"epss_score": 0.00369, "epss_percentile": 0.58255}, "CVE-2024-30804": {"epss_score": 0.00143, "epss_percentile": 0.35176}, "CVE-2024-30806": {"epss_score": 0.00146, "epss_percentile": 0.35601}, "CVE-2024-30807": {"epss_score": 0.00079, "epss_percentile": 0.23991}, "CVE-2024-30808": {"epss_score": 0.00038, "epss_percentile": 0.11335}, "CVE-2024-30809": {"epss_score": 0.00079, "epss_percentile": 0.23991}, "CVE-2024-30840": {"epss_score": 0.0004, "epss_percentile": 0.11921}, "CVE-2024-30845": {"epss_score": 0.00339, "epss_percentile": 0.56173}, "CVE-2024-30848": {"epss_score": 0.00142, "epss_percentile": 0.35012}, "CVE-2024-30849": {"epss_score": 0.03578, "epss_percentile": 0.87381}, "CVE-2024-30850": {"epss_score": 0.80454, "epss_percentile": 0.99089}, "CVE-2024-30851": {"epss_score": 0.69172, "epss_percentile": 0.9858}, "CVE-2024-30855": {"epss_score": 0.00014, "epss_percentile": 0.01773}, "CVE-2024-30858": {"epss_score": 0.00134, "epss_percentile": 0.33875}, "CVE-2024-30859": {"epss_score": 0.00075, "epss_percentile": 0.2305}, "CVE-2024-30860": {"epss_score": 0.00077, "epss_percentile": 0.23299}, "CVE-2024-30861": {"epss_score": 0.00066, "epss_percentile": 0.20964}, "CVE-2024-30862": {"epss_score": 0.00176, "epss_percentile": 0.39403}, "CVE-2024-30863": {"epss_score": 0.00048, "epss_percentile": 0.15268}, "CVE-2024-30864": {"epss_score": 0.00037, "epss_percentile": 0.10888}, "CVE-2024-30865": {"epss_score": 0.00069, "epss_percentile": 0.21587}, "CVE-2024-30866": {"epss_score": 0.00056, "epss_percentile": 0.17877}, "CVE-2024-30867": {"epss_score": 0.00076, "epss_percentile": 0.23281}, "CVE-2024-30868": {"epss_score": 0.00072, "epss_percentile": 0.223}, "CVE-2024-30870": {"epss_score": 0.00072, "epss_percentile": 0.22313}, "CVE-2024-30871": {"epss_score": 0.00211, "epss_percentile": 0.43639}, "CVE-2024-30872": {"epss_score": 0.00024, "epss_percentile": 0.0577}, "CVE-2024-30875": {"epss_score": 0.1678, "epss_percentile": 0.94731}, "CVE-2024-30878": {"epss_score": 0.00114, "epss_percentile": 0.30871}, "CVE-2024-30879": {"epss_score": 0.0007, "epss_percentile": 0.21742}, "CVE-2024-30880": {"epss_score": 0.00065, "epss_percentile": 0.20605}, "CVE-2024-30883": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2024-30884": {"epss_score": 0.00372, "epss_percentile": 0.58445}, "CVE-2024-30885": {"epss_score": 0.00262, "epss_percentile": 0.49387}, "CVE-2024-30886": {"epss_score": 0.00085, "epss_percentile": 0.25145}, "CVE-2024-30889": {"epss_score": 0.00488, "epss_percentile": 0.64859}, "CVE-2024-30890": {"epss_score": 0.00074, "epss_percentile": 0.22733}, "CVE-2024-30891": {"epss_score": 0.00362, "epss_percentile": 0.57808}, "CVE-2024-30896": {"epss_score": 0.21146, "epss_percentile": 0.95469}, "CVE-2024-30915": {"epss_score": 0.00097, "epss_percentile": 0.27518}, "CVE-2024-30916": {"epss_score": 0.00048, "epss_percentile": 0.14964}, "CVE-2024-30917": {"epss_score": 0.00051, "epss_percentile": 0.16144}, "CVE-2024-30920": {"epss_score": 0.00589, "epss_percentile": 0.68533}, "CVE-2024-30921": {"epss_score": 0.00578, "epss_percentile": 0.68189}, "CVE-2024-30922": {"epss_score": 0.03495, "epss_percentile": 0.87237}, "CVE-2024-30923": {"epss_score": 0.03495, "epss_percentile": 0.87237}, "CVE-2024-30924": {"epss_score": 0.00147, "epss_percentile": 0.35706}, "CVE-2024-30925": {"epss_score": 0.00257, "epss_percentile": 0.48881}, "CVE-2024-30926": {"epss_score": 0.00332, "epss_percentile": 0.55597}, "CVE-2024-30927": {"epss_score": 0.00257, "epss_percentile": 0.48866}, "CVE-2024-30928": {"epss_score": 0.00243, "epss_percentile": 0.47418}, "CVE-2024-30929": {"epss_score": 0.0041, "epss_percentile": 0.60796}, "CVE-2024-30931": {"epss_score": 0.00173, "epss_percentile": 0.39072}, "CVE-2024-30938": {"epss_score": 0.00589, "epss_percentile": 0.68512}, "CVE-2024-30939": {"epss_score": 0.00093, "epss_percentile": 0.26623}, "CVE-2024-30946": {"epss_score": 0.00096, "epss_percentile": 0.27293}, "CVE-2024-30949": {"epss_score": 0.00408, "epss_percentile": 0.60627}, "CVE-2024-30950": {"epss_score": 0.00133, "epss_percentile": 0.3364}, "CVE-2024-30951": {"epss_score": 0.0019, "epss_percentile": 0.41141}, "CVE-2024-30952": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2024-30953": {"epss_score": 0.0019, "epss_percentile": 0.41141}, "CVE-2024-30961": {"epss_score": 0.00169, "epss_percentile": 0.3864}, "CVE-2024-30962": {"epss_score": 0.0015, "epss_percentile": 0.36137}, "CVE-2024-30963": {"epss_score": 0.0011, "epss_percentile": 0.30178}, "CVE-2024-30964": {"epss_score": 0.00097, "epss_percentile": 0.27453}, "CVE-2024-30965": {"epss_score": 0.00212, "epss_percentile": 0.43725}, "CVE-2024-30973": {"epss_score": 0.00764, "epss_percentile": 0.72899}, "CVE-2024-30974": {"epss_score": 0.00067, "epss_percentile": 0.21013}, "CVE-2024-30977": {"epss_score": 0.00034, "epss_percentile": 0.09608}, "CVE-2024-30979": {"epss_score": 0.00971, "epss_percentile": 0.7613}, "CVE-2024-30980": {"epss_score": 0.00158, "epss_percentile": 0.37179}, "CVE-2024-30981": {"epss_score": 0.00107, "epss_percentile": 0.29745}, "CVE-2024-30982": {"epss_score": 0.00145, "epss_percentile": 0.35432}, "CVE-2024-30983": {"epss_score": 0.00091, "epss_percentile": 0.26241}, "CVE-2024-30985": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2024-30986": {"epss_score": 0.00152, "epss_percentile": 0.36485}, "CVE-2024-30987": {"epss_score": 0.00152, "epss_percentile": 0.36485}, "CVE-2024-30988": {"epss_score": 0.00152, "epss_percentile": 0.36485}, "CVE-2024-30989": {"epss_score": 0.00224, "epss_percentile": 0.45069}, "CVE-2024-30990": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2024-30998": {"epss_score": 0.09853, "epss_percentile": 0.92735}, "CVE-2024-31002": {"epss_score": 0.08234, "epss_percentile": 0.91942}, "CVE-2024-31003": {"epss_score": 0.08951, "epss_percentile": 0.92335}, "CVE-2024-31004": {"epss_score": 0.07408, "epss_percentile": 0.91456}, "CVE-2024-31005": {"epss_score": 0.096, "epss_percentile": 0.92616}, "CVE-2024-31007": {"epss_score": 0.00075, "epss_percentile": 0.23052}, "CVE-2024-31008": {"epss_score": 0.00175, "epss_percentile": 0.39301}, "CVE-2024-31009": {"epss_score": 0.001, "epss_percentile": 0.2856}, "CVE-2024-31010": {"epss_score": 0.00108, "epss_percentile": 0.29779}, "CVE-2024-31011": {"epss_score": 0.04093, "epss_percentile": 0.88243}, "CVE-2024-31012": {"epss_score": 0.03885, "epss_percentile": 0.87903}, "CVE-2024-31013": {"epss_score": 0.00561, "epss_percentile": 0.67676}, "CVE-2024-31022": {"epss_score": 0.01668, "epss_percentile": 0.81662}, "CVE-2024-31025": {"epss_score": 0.00053, "epss_percentile": 0.17037}, "CVE-2024-31029": {"epss_score": 0.00357, "epss_percentile": 0.57469}, "CVE-2024-31030": {"epss_score": 0.00782, "epss_percentile": 0.7321}, "CVE-2024-31031": {"epss_score": 0.00091, "epss_percentile": 0.26186}, "CVE-2024-31032": {"epss_score": 0.05456, "epss_percentile": 0.89896}, "CVE-2024-31033": {"epss_score": 0.00143, "epss_percentile": 0.35215}, "CVE-2024-31036": {"epss_score": 0.00083, "epss_percentile": 0.2474}, "CVE-2024-31040": {"epss_score": 0.00328, "epss_percentile": 0.55254}, "CVE-2024-31041": {"epss_score": 0.00141, "epss_percentile": 0.34837}, "CVE-2024-31047": {"epss_score": 0.00016, "epss_percentile": 0.02694}, "CVE-2024-31061": {"epss_score": 0.00322, "epss_percentile": 0.54859}, "CVE-2024-31062": {"epss_score": 0.01566, "epss_percentile": 0.81067}, "CVE-2024-31063": {"epss_score": 0.00565, "epss_percentile": 0.67807}, "CVE-2024-31064": {"epss_score": 0.0049, "epss_percentile": 0.64932}, "CVE-2024-31065": {"epss_score": 0.00322, "epss_percentile": 0.54859}, "CVE-2024-31068": {"epss_score": 0.00041, "epss_percentile": 0.12423}, "CVE-2024-31069": {"epss_score": 0.00091, "epss_percentile": 0.26278}, "CVE-2024-31070": {"epss_score": 0.02066, "epss_percentile": 0.8346}, "CVE-2024-31071": {"epss_score": 0.00052, "epss_percentile": 0.16629}, "CVE-2024-31073": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2024-31074": {"epss_score": 0.00333, "epss_percentile": 0.55675}, "CVE-2024-31076": {"epss_score": 0.0001, "epss_percentile": 0.00802}, "CVE-2024-31077": {"epss_score": 0.34496, "epss_percentile": 0.96849}, "CVE-2024-31078": {"epss_score": 0.00079, "epss_percentile": 0.23965}, "CVE-2024-31079": {"epss_score": 0.00483, "epss_percentile": 0.64613}, "CVE-2024-31080": {"epss_score": 0.00123, "epss_percentile": 0.32254}, "CVE-2024-31081": {"epss_score": 0.00113, "epss_percentile": 0.30692}, "CVE-2024-31082": {"epss_score": 0.00033, "epss_percentile": 0.09345}, "CVE-2024-31083": {"epss_score": 0.00101, "epss_percentile": 0.28681}, "CVE-2024-31084": {"epss_score": 0.00062, "epss_percentile": 0.19737}, "CVE-2024-31085": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-31086": {"epss_score": 0.00089, "epss_percentile": 0.25867}, "CVE-2024-31087": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-31088": {"epss_score": 0.00131, "epss_percentile": 0.33489}, "CVE-2024-31089": {"epss_score": 0.00062, "epss_percentile": 0.19628}, "CVE-2024-31090": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-31091": {"epss_score": 0.00089, "epss_percentile": 0.25814}, "CVE-2024-31092": {"epss_score": 0.00097, "epss_percentile": 0.27528}, "CVE-2024-31093": {"epss_score": 0.00144, "epss_percentile": 0.35267}, "CVE-2024-31094": {"epss_score": 0.00331, "epss_percentile": 0.5554}, "CVE-2024-31095": {"epss_score": 0.00237, "epss_percentile": 0.46714}, "CVE-2024-31096": {"epss_score": 0.00077, "epss_percentile": 0.23521}, "CVE-2024-31097": {"epss_score": 0.00097, "epss_percentile": 0.27528}, "CVE-2024-31098": {"epss_score": 0.00439, "epss_percentile": 0.62586}, "CVE-2024-31099": {"epss_score": 0.0016, "epss_percentile": 0.37495}, "CVE-2024-31100": {"epss_score": 0.00056, "epss_percentile": 0.17756}, "CVE-2024-31101": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-31102": {"epss_score": 0.00062, "epss_percentile": 0.19628}, "CVE-2024-31103": {"epss_score": 0.00092, "epss_percentile": 0.26549}, "CVE-2024-31104": {"epss_score": 0.00097, "epss_percentile": 0.27535}, "CVE-2024-31105": {"epss_score": 0.00136, "epss_percentile": 0.3406}, "CVE-2024-31106": {"epss_score": 0.00117, "epss_percentile": 0.31379}, "CVE-2024-31107": {"epss_score": 0.00117, "epss_percentile": 0.31379}, "CVE-2024-31108": {"epss_score": 0.00089, "epss_percentile": 0.25853}, "CVE-2024-31109": {"epss_score": 0.0013, "epss_percentile": 0.33313}, "CVE-2024-31110": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-31111": {"epss_score": 0.00432, "epss_percentile": 0.62122}, "CVE-2024-31112": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-31113": {"epss_score": 0.00345, "epss_percentile": 0.56586}, "CVE-2024-31114": {"epss_score": 0.4866, "epss_percentile": 0.97647}, "CVE-2024-31115": {"epss_score": 0.00448, "epss_percentile": 0.62996}, "CVE-2024-31116": {"epss_score": 0.00206, "epss_percentile": 0.42935}, "CVE-2024-31117": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-31120": {"epss_score": 0.00113, "epss_percentile": 0.30681}, "CVE-2024-31121": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-31122": {"epss_score": 0.00089, "epss_percentile": 0.25814}, "CVE-2024-31123": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-31127": {"epss_score": 9e-05, "epss_percentile": 0.00745}, "CVE-2024-31134": {"epss_score": 7e-05, "epss_percentile": 0.00339}, "CVE-2024-31135": {"epss_score": 0.00199, "epss_percentile": 0.42103}, "CVE-2024-31136": {"epss_score": 5e-05, "epss_percentile": 0.00195}, "CVE-2024-31137": {"epss_score": 0.00435, "epss_percentile": 0.62346}, "CVE-2024-31138": {"epss_score": 0.91198, "epss_percentile": 0.99627}, "CVE-2024-31139": {"epss_score": 5e-05, "epss_percentile": 0.00209}, "CVE-2024-31140": {"epss_score": 0.00014, "epss_percentile": 0.0177}, "CVE-2024-31141": {"epss_score": 0.00101, "epss_percentile": 0.28701}, "CVE-2024-31142": {"epss_score": 0.04321, "epss_percentile": 0.88544}, "CVE-2024-31143": {"epss_score": 0.00191, "epss_percentile": 0.41257}, "CVE-2024-31144": {"epss_score": 0.00035, "epss_percentile": 0.10138}, "CVE-2024-31145": {"epss_score": 0.00045, "epss_percentile": 0.13789}, "CVE-2024-31146": {"epss_score": 0.00045, "epss_percentile": 0.13789}, "CVE-2024-31150": {"epss_score": 0.00017, "epss_percentile": 0.03252}, "CVE-2024-31151": {"epss_score": 0.00318, "epss_percentile": 0.54399}, "CVE-2024-31152": {"epss_score": 0.09646, "epss_percentile": 0.92638}, "CVE-2024-31153": {"epss_score": 0.00023, "epss_percentile": 0.05651}, "CVE-2024-31154": {"epss_score": 0.00037, "epss_percentile": 0.10652}, "CVE-2024-31155": {"epss_score": 0.00025, "epss_percentile": 0.06322}, "CVE-2024-31156": {"epss_score": 0.00947, "epss_percentile": 0.75817}, "CVE-2024-31157": {"epss_score": 0.0003, "epss_percentile": 0.08248}, "CVE-2024-31158": {"epss_score": 0.00037, "epss_percentile": 0.10652}, "CVE-2024-31159": {"epss_score": 0.00215, "epss_percentile": 0.44087}, "CVE-2024-31160": {"epss_score": 0.00215, "epss_percentile": 0.44087}, "CVE-2024-31161": {"epss_score": 0.01051, "epss_percentile": 0.77077}, "CVE-2024-31162": {"epss_score": 0.01409, "epss_percentile": 0.80074}, "CVE-2024-31163": {"epss_score": 0.02633, "epss_percentile": 0.85287}, "CVE-2024-31164": {"epss_score": 0.00119, "epss_percentile": 0.31609}, "CVE-2024-31165": {"epss_score": 0.00119, "epss_percentile": 0.31609}, "CVE-2024-31166": {"epss_score": 0.00113, "epss_percentile": 0.30679}, "CVE-2024-31167": {"epss_score": 0.00119, "epss_percentile": 0.31609}, "CVE-2024-31168": {"epss_score": 0.00113, "epss_percentile": 0.30679}, "CVE-2024-31169": {"epss_score": 0.00113, "epss_percentile": 0.30679}, "CVE-2024-31170": {"epss_score": 0.00113, "epss_percentile": 0.30679}, "CVE-2024-31171": {"epss_score": 0.00113, "epss_percentile": 0.30679}, "CVE-2024-31172": {"epss_score": 0.00113, "epss_percentile": 0.30679}, "CVE-2024-31173": {"epss_score": 0.00113, "epss_percentile": 0.30679}, "CVE-2024-31174": {"epss_score": 0.00113, "epss_percentile": 0.30679}, "CVE-2024-31175": {"epss_score": 0.00119, "epss_percentile": 0.31609}, "CVE-2024-31176": {"epss_score": 0.00186, "epss_percentile": 0.40673}, "CVE-2024-31177": {"epss_score": 0.00186, "epss_percentile": 0.40673}, "CVE-2024-31178": {"epss_score": 0.00209, "epss_percentile": 0.4337}, "CVE-2024-31179": {"epss_score": 0.00186, "epss_percentile": 0.40673}, "CVE-2024-31180": {"epss_score": 0.00209, "epss_percentile": 0.4337}, "CVE-2024-31181": {"epss_score": 0.00186, "epss_percentile": 0.40673}, "CVE-2024-31182": {"epss_score": 0.00196, "epss_percentile": 0.41788}, "CVE-2024-31183": {"epss_score": 0.00186, "epss_percentile": 0.40673}, "CVE-2024-31184": {"epss_score": 0.00186, "epss_percentile": 0.40673}, "CVE-2024-31185": {"epss_score": 0.00196, "epss_percentile": 0.41788}, "CVE-2024-31186": {"epss_score": 0.00186, "epss_percentile": 0.40673}, "CVE-2024-31187": {"epss_score": 0.00186, "epss_percentile": 0.40673}, "CVE-2024-31188": {"epss_score": 0.00186, "epss_percentile": 0.40673}, "CVE-2024-31189": {"epss_score": 0.00186, "epss_percentile": 0.40673}, "CVE-2024-31190": {"epss_score": 0.00177, "epss_percentile": 0.39608}, "CVE-2024-31191": {"epss_score": 0.00177, "epss_percentile": 0.39608}, "CVE-2024-31192": {"epss_score": 0.00177, "epss_percentile": 0.39608}, "CVE-2024-31193": {"epss_score": 0.00177, "epss_percentile": 0.39608}, "CVE-2024-31194": {"epss_score": 0.00177, "epss_percentile": 0.39608}, "CVE-2024-31195": {"epss_score": 0.00186, "epss_percentile": 0.40673}, "CVE-2024-31196": {"epss_score": 0.00196, "epss_percentile": 0.41788}, "CVE-2024-31197": {"epss_score": 0.00192, "epss_percentile": 0.41314}, "CVE-2024-31198": {"epss_score": 0.00258, "epss_percentile": 0.49007}, "CVE-2024-31199": {"epss_score": 0.00223, "epss_percentile": 0.44963}, "CVE-2024-31200": {"epss_score": 0.00081, "epss_percentile": 0.24313}, "CVE-2024-31201": {"epss_score": 0.00037, "epss_percentile": 0.1098}, "CVE-2024-31202": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-31203": {"epss_score": 0.00053, "epss_percentile": 0.17009}, "CVE-2024-31204": {"epss_score": 0.04568, "epss_percentile": 0.8886}, "CVE-2024-31205": {"epss_score": 0.00082, "epss_percentile": 0.24397}, "CVE-2024-31206": {"epss_score": 0.00055, "epss_percentile": 0.17463}, "CVE-2024-31207": {"epss_score": 0.00139, "epss_percentile": 0.34665}, "CVE-2024-31208": {"epss_score": 0.02302, "epss_percentile": 0.84314}, "CVE-2024-31209": {"epss_score": 0.00019, "epss_percentile": 0.04072}, "CVE-2024-31210": {"epss_score": 0.00916, "epss_percentile": 0.75415}, "CVE-2024-31211": {"epss_score": 0.44881, "epss_percentile": 0.97458}, "CVE-2024-31212": {"epss_score": 0.00317, "epss_percentile": 0.54349}, "CVE-2024-31213": {"epss_score": 0.00225, "epss_percentile": 0.4514}, "CVE-2024-31214": {"epss_score": 0.17635, "epss_percentile": 0.94881}, "CVE-2024-31215": {"epss_score": 0.00105, "epss_percentile": 0.29345}, "CVE-2024-31216": {"epss_score": 0.00153, "epss_percentile": 0.36574}, "CVE-2024-31217": {"epss_score": 0.01796, "epss_percentile": 0.82305}, "CVE-2024-31218": {"epss_score": 0.00378, "epss_percentile": 0.58779}, "CVE-2024-31219": {"epss_score": 0.00194, "epss_percentile": 0.41529}, "CVE-2024-31220": {"epss_score": 0.00182, "epss_percentile": 0.40148}, "CVE-2024-31221": {"epss_score": 0.00087, "epss_percentile": 0.25593}, "CVE-2024-31223": {"epss_score": 0.06586, "epss_percentile": 0.90867}, "CVE-2024-31224": {"epss_score": 0.05825, "epss_percentile": 0.90238}, "CVE-2024-31225": {"epss_score": 0.01624, "epss_percentile": 0.81405}, "CVE-2024-31226": {"epss_score": 0.00097, "epss_percentile": 0.27507}, "CVE-2024-31227": {"epss_score": 0.00205, "epss_percentile": 0.42717}, "CVE-2024-31228": {"epss_score": 0.00714, "epss_percentile": 0.7182}, "CVE-2024-31229": {"epss_score": 0.00149, "epss_percentile": 0.35985}, "CVE-2024-31230": {"epss_score": 0.00192, "epss_percentile": 0.41347}, "CVE-2024-31231": {"epss_score": 0.01661, "epss_percentile": 0.81622}, "CVE-2024-31232": {"epss_score": 0.01047, "epss_percentile": 0.77037}, "CVE-2024-31233": {"epss_score": 0.00166, "epss_percentile": 0.3825}, "CVE-2024-31234": {"epss_score": 0.00166, "epss_percentile": 0.3825}, "CVE-2024-31235": {"epss_score": 0.00073, "epss_percentile": 0.2254}, "CVE-2024-31236": {"epss_score": 0.00139, "epss_percentile": 0.34605}, "CVE-2024-31237": {"epss_score": 0.0046, "epss_percentile": 0.63533}, "CVE-2024-31238": {"epss_score": 0.00056, "epss_percentile": 0.1766}, "CVE-2024-31239": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2024-31240": {"epss_score": 0.00309, "epss_percentile": 0.53721}, "CVE-2024-31241": {"epss_score": 0.00201, "epss_percentile": 0.42276}, "CVE-2024-31242": {"epss_score": 0.00166, "epss_percentile": 0.38141}, "CVE-2024-31243": {"epss_score": 0.0027, "epss_percentile": 0.5024}, "CVE-2024-31244": {"epss_score": 0.00353, "epss_percentile": 0.57191}, "CVE-2024-31245": {"epss_score": 0.00987, "epss_percentile": 0.76346}, "CVE-2024-31246": {"epss_score": 0.00392, "epss_percentile": 0.5967}, "CVE-2024-31247": {"epss_score": 0.00693, "epss_percentile": 0.71319}, "CVE-2024-31248": {"epss_score": 0.00525, "epss_percentile": 0.6637}, "CVE-2024-31249": {"epss_score": 0.00757, "epss_percentile": 0.72752}, "CVE-2024-31250": {"epss_score": 0.00073, "epss_percentile": 0.2254}, "CVE-2024-31251": {"epss_score": 0.00054, "epss_percentile": 0.17199}, "CVE-2024-31252": {"epss_score": 0.00412, "epss_percentile": 0.60942}, "CVE-2024-31253": {"epss_score": 0.00332, "epss_percentile": 0.5557}, "CVE-2024-31254": {"epss_score": 0.00962, "epss_percentile": 0.75991}, "CVE-2024-31255": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-31256": {"epss_score": 0.00152, "epss_percentile": 0.36396}, "CVE-2024-31257": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-31258": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-31259": {"epss_score": 0.01689, "epss_percentile": 0.81771}, "CVE-2024-31260": {"epss_score": 0.00206, "epss_percentile": 0.42935}, "CVE-2024-31261": {"epss_score": 0.00377, "epss_percentile": 0.58735}, "CVE-2024-31262": {"epss_score": 0.00048, "epss_percentile": 0.15129}, "CVE-2024-31263": {"epss_score": 0.00053, "epss_percentile": 0.16695}, "CVE-2024-31264": {"epss_score": 0.0009, "epss_percentile": 0.26169}, "CVE-2024-31265": {"epss_score": 0.00047, "epss_percentile": 0.14908}, "CVE-2024-31266": {"epss_score": 0.00502, "epss_percentile": 0.65415}, "CVE-2024-31267": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-31268": {"epss_score": 0.00126, "epss_percentile": 0.32774}, "CVE-2024-31269": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2024-31270": {"epss_score": 0.00197, "epss_percentile": 0.41932}, "CVE-2024-31271": {"epss_score": 0.00073, "epss_percentile": 0.2254}, "CVE-2024-31272": {"epss_score": 0.00062, "epss_percentile": 0.19597}, "CVE-2024-31273": {"epss_score": 0.0029, "epss_percentile": 0.52142}, "CVE-2024-31274": {"epss_score": 0.00186, "epss_percentile": 0.40612}, "CVE-2024-31275": {"epss_score": 0.00458, "epss_percentile": 0.63434}, "CVE-2024-31276": {"epss_score": 0.00516, "epss_percentile": 0.66047}, "CVE-2024-31277": {"epss_score": 0.00527, "epss_percentile": 0.66464}, "CVE-2024-31278": {"epss_score": 0.00707, "epss_percentile": 0.71649}, "CVE-2024-31279": {"epss_score": 0.00053, "epss_percentile": 0.16695}, "CVE-2024-31280": {"epss_score": 0.00437, "epss_percentile": 0.62489}, "CVE-2024-31281": {"epss_score": 0.00455, "epss_percentile": 0.63313}, "CVE-2024-31282": {"epss_score": 0.00213, "epss_percentile": 0.43838}, "CVE-2024-31283": {"epss_score": 0.00634, "epss_percentile": 0.69804}, "CVE-2024-31284": {"epss_score": 0.00205, "epss_percentile": 0.42727}, "CVE-2024-31285": {"epss_score": 0.00142, "epss_percentile": 0.35085}, "CVE-2024-31286": {"epss_score": 0.00799, "epss_percentile": 0.73528}, "CVE-2024-31287": {"epss_score": 0.0099, "epss_percentile": 0.76379}, "CVE-2024-31288": {"epss_score": 0.00129, "epss_percentile": 0.33162}, "CVE-2024-31289": {"epss_score": 0.0007, "epss_percentile": 0.21758}, "CVE-2024-31290": {"epss_score": 0.0054, "epss_percentile": 0.67013}, "CVE-2024-31291": {"epss_score": 0.00085, "epss_percentile": 0.25114}, "CVE-2024-31292": {"epss_score": 0.00304, "epss_percentile": 0.5327}, "CVE-2024-31293": {"epss_score": 0.00077, "epss_percentile": 0.23378}, "CVE-2024-31294": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-31295": {"epss_score": 0.00092, "epss_percentile": 0.26438}, "CVE-2024-31296": {"epss_score": 0.00077, "epss_percentile": 0.23322}, "CVE-2024-31297": {"epss_score": 0.00266, "epss_percentile": 0.49868}, "CVE-2024-31298": {"epss_score": 0.00693, "epss_percentile": 0.71319}, "CVE-2024-31299": {"epss_score": 0.00259, "epss_percentile": 0.49046}, "CVE-2024-31300": {"epss_score": 0.01832, "epss_percentile": 0.82452}, "CVE-2024-31301": {"epss_score": 0.00056, "epss_percentile": 0.1766}, "CVE-2024-31302": {"epss_score": 0.00326, "epss_percentile": 0.55079}, "CVE-2024-31303": {"epss_score": 0.00073, "epss_percentile": 0.2254}, "CVE-2024-31304": {"epss_score": 0.00525, "epss_percentile": 0.66382}, "CVE-2024-31305": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2024-31306": {"epss_score": 0.00139, "epss_percentile": 0.34605}, "CVE-2024-31307": {"epss_score": 0.00104, "epss_percentile": 0.292}, "CVE-2024-31308": {"epss_score": 0.0023, "epss_percentile": 0.45671}, "CVE-2024-31309": {"epss_score": 0.02832, "epss_percentile": 0.85778}, "CVE-2024-31310": {"epss_score": 0.00038, "epss_percentile": 0.1132}, "CVE-2024-31311": {"epss_score": 0.0005, "epss_percentile": 0.15967}, "CVE-2024-31312": {"epss_score": 0.00047, "epss_percentile": 0.1477}, "CVE-2024-31313": {"epss_score": 0.00045, "epss_percentile": 0.13984}, "CVE-2024-31314": {"epss_score": 0.00066, "epss_percentile": 0.20732}, "CVE-2024-31315": {"epss_score": 0.00025, "epss_percentile": 0.06137}, "CVE-2024-31316": {"epss_score": 0.00052, "epss_percentile": 0.16444}, "CVE-2024-31317": {"epss_score": 0.07032, "epss_percentile": 0.912}, "CVE-2024-31318": {"epss_score": 0.00045, "epss_percentile": 0.13984}, "CVE-2024-31319": {"epss_score": 0.00045, "epss_percentile": 0.13751}, "CVE-2024-31320": {"epss_score": 0.00681, "epss_percentile": 0.71055}, "CVE-2024-31322": {"epss_score": 0.00038, "epss_percentile": 0.11129}, "CVE-2024-31323": {"epss_score": 0.00039, "epss_percentile": 0.11527}, "CVE-2024-31324": {"epss_score": 7e-05, "epss_percentile": 0.00401}, "CVE-2024-31325": {"epss_score": 0.00045, "epss_percentile": 0.13984}, "CVE-2024-31326": {"epss_score": 0.00115, "epss_percentile": 0.30981}, "CVE-2024-31327": {"epss_score": 0.00028, "epss_percentile": 0.07512}, "CVE-2024-31331": {"epss_score": 0.00052, "epss_percentile": 0.16444}, "CVE-2024-31332": {"epss_score": 8e-05, "epss_percentile": 0.00548}, "CVE-2024-31333": {"epss_score": 0.00056, "epss_percentile": 0.17918}, "CVE-2024-31334": {"epss_score": 0.00034, "epss_percentile": 0.09622}, "CVE-2024-31335": {"epss_score": 0.00029, "epss_percentile": 0.07898}, "CVE-2024-31336": {"epss_score": 0.00034, "epss_percentile": 0.09468}, "CVE-2024-31337": {"epss_score": 0.00035, "epss_percentile": 0.09926}, "CVE-2024-31339": {"epss_score": 0.00037, "epss_percentile": 0.10968}, "CVE-2024-31340": {"epss_score": 0.00381, "epss_percentile": 0.59001}, "CVE-2024-31341": {"epss_score": 0.00117, "epss_percentile": 0.31348}, "CVE-2024-31342": {"epss_score": 0.00515, "epss_percentile": 0.65969}, "CVE-2024-31343": {"epss_score": 0.01151, "epss_percentile": 0.78041}, "CVE-2024-31344": {"epss_score": 0.00059, "epss_percentile": 0.18704}, "CVE-2024-31345": {"epss_score": 0.0104, "epss_percentile": 0.76955}, "CVE-2024-31346": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-31347": {"epss_score": 0.00113, "epss_percentile": 0.306}, "CVE-2024-31348": {"epss_score": 0.00118, "epss_percentile": 0.3139}, "CVE-2024-31349": {"epss_score": 0.00085, "epss_percentile": 0.25031}, "CVE-2024-31350": {"epss_score": 0.0024, "epss_percentile": 0.47195}, "CVE-2024-31351": {"epss_score": 0.53621, "epss_percentile": 0.97885}, "CVE-2024-31352": {"epss_score": 0.00362, "epss_percentile": 0.57794}, "CVE-2024-31353": {"epss_score": 0.004, "epss_percentile": 0.60154}, "CVE-2024-31354": {"epss_score": 0.0007, "epss_percentile": 0.21758}, "CVE-2024-31355": {"epss_score": 0.00332, "epss_percentile": 0.55571}, "CVE-2024-31356": {"epss_score": 0.00314, "epss_percentile": 0.54116}, "CVE-2024-31357": {"epss_score": 0.00118, "epss_percentile": 0.3139}, "CVE-2024-31358": {"epss_score": 0.0048, "epss_percentile": 0.64474}, "CVE-2024-31359": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-31360": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2024-31361": {"epss_score": 0.00118, "epss_percentile": 0.31475}, "CVE-2024-31362": {"epss_score": 0.00074, "epss_percentile": 0.22757}, "CVE-2024-31363": {"epss_score": 0.00133, "epss_percentile": 0.33669}, "CVE-2024-31364": {"epss_score": 0.00077, "epss_percentile": 0.23284}, "CVE-2024-31365": {"epss_score": 0.00197, "epss_percentile": 0.4189}, "CVE-2024-31366": {"epss_score": 0.00145, "epss_percentile": 0.35502}, "CVE-2024-31367": {"epss_score": 0.00465, "epss_percentile": 0.63742}, "CVE-2024-31368": {"epss_score": 0.00139, "epss_percentile": 0.34549}, "CVE-2024-31369": {"epss_score": 0.00163, "epss_percentile": 0.37778}, "CVE-2024-31370": {"epss_score": 0.00238, "epss_percentile": 0.46822}, "CVE-2024-31371": {"epss_score": 0.0007, "epss_percentile": 0.21758}, "CVE-2024-31372": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2024-31373": {"epss_score": 0.00128, "epss_percentile": 0.32973}, "CVE-2024-31374": {"epss_score": 0.00238, "epss_percentile": 0.46805}, "CVE-2024-31375": {"epss_score": 0.00051, "epss_percentile": 0.16213}, "CVE-2024-31376": {"epss_score": 0.00177, "epss_percentile": 0.39574}, "CVE-2024-31377": {"epss_score": 0.025, "epss_percentile": 0.84916}, "CVE-2024-31378": {"epss_score": 0.00123, "epss_percentile": 0.32321}, "CVE-2024-31379": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31380": {"epss_score": 0.00097, "epss_percentile": 0.27566}, "CVE-2024-31381": {"epss_score": 0.00177, "epss_percentile": 0.39574}, "CVE-2024-31382": {"epss_score": 0.00187, "epss_percentile": 0.40751}, "CVE-2024-31383": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31384": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31385": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31386": {"epss_score": 0.00468, "epss_percentile": 0.63886}, "CVE-2024-31387": {"epss_score": 0.00129, "epss_percentile": 0.33171}, "CVE-2024-31388": {"epss_score": 0.00177, "epss_percentile": 0.39574}, "CVE-2024-31389": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-31390": {"epss_score": 0.00108, "epss_percentile": 0.29782}, "CVE-2024-31391": {"epss_score": 0.00044, "epss_percentile": 0.1362}, "CVE-2024-31392": {"epss_score": 0.00475, "epss_percentile": 0.6419}, "CVE-2024-31393": {"epss_score": 0.00136, "epss_percentile": 0.34112}, "CVE-2024-31394": {"epss_score": 0.01283, "epss_percentile": 0.79159}, "CVE-2024-31395": {"epss_score": 0.00936, "epss_percentile": 0.75682}, "CVE-2024-31396": {"epss_score": 0.00751, "epss_percentile": 0.72649}, "CVE-2024-31397": {"epss_score": 0.00136, "epss_percentile": 0.34121}, "CVE-2024-31398": {"epss_score": 0.00494, "epss_percentile": 0.6508}, "CVE-2024-31399": {"epss_score": 0.00245, "epss_percentile": 0.47723}, "CVE-2024-31400": {"epss_score": 0.00482, "epss_percentile": 0.64539}, "CVE-2024-31401": {"epss_score": 0.03461, "epss_percentile": 0.87182}, "CVE-2024-31402": {"epss_score": 0.00372, "epss_percentile": 0.58452}, "CVE-2024-31403": {"epss_score": 0.00477, "epss_percentile": 0.64339}, "CVE-2024-31404": {"epss_score": 0.00494, "epss_percentile": 0.6508}, "CVE-2024-31406": {"epss_score": 0.00048, "epss_percentile": 0.14932}, "CVE-2024-31407": {"epss_score": 0.00024, "epss_percentile": 0.05747}, "CVE-2024-31408": {"epss_score": 0.00148, "epss_percentile": 0.35821}, "CVE-2024-31409": {"epss_score": 0.00246, "epss_percentile": 0.47737}, "CVE-2024-31410": {"epss_score": 0.00119, "epss_percentile": 0.31537}, "CVE-2024-31411": {"epss_score": 0.01796, "epss_percentile": 0.82306}, "CVE-2024-31412": {"epss_score": 0.00077, "epss_percentile": 0.23355}, "CVE-2024-31413": {"epss_score": 0.00086, "epss_percentile": 0.25325}, "CVE-2024-31414": {"epss_score": 0.00509, "epss_percentile": 0.65755}, "CVE-2024-31415": {"epss_score": 0.00046, "epss_percentile": 0.14333}, "CVE-2024-31416": {"epss_score": 0.00139, "epss_percentile": 0.34595}, "CVE-2024-31419": {"epss_score": 0.00226, "epss_percentile": 0.45285}, "CVE-2024-31420": {"epss_score": 0.00102, "epss_percentile": 0.28838}, "CVE-2024-31421": {"epss_score": 0.00207, "epss_percentile": 0.43084}, "CVE-2024-31422": {"epss_score": 0.00177, "epss_percentile": 0.39574}, "CVE-2024-31423": {"epss_score": 0.0024, "epss_percentile": 0.47195}, "CVE-2024-31424": {"epss_score": 0.00363, "epss_percentile": 0.57891}, "CVE-2024-31425": {"epss_score": 0.00128, "epss_percentile": 0.32973}, "CVE-2024-31426": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31427": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31428": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31429": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2024-31430": {"epss_score": 0.00166, "epss_percentile": 0.38246}, "CVE-2024-31431": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31432": {"epss_score": 0.00192, "epss_percentile": 0.41347}, "CVE-2024-31433": {"epss_score": 0.00177, "epss_percentile": 0.39574}, "CVE-2024-31434": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-31441": {"epss_score": 0.00662, "epss_percentile": 0.70591}, "CVE-2024-31442": {"epss_score": 0.00182, "epss_percentile": 0.40251}, "CVE-2024-31443": {"epss_score": 0.00644, "epss_percentile": 0.70089}, "CVE-2024-31444": {"epss_score": 0.09401, "epss_percentile": 0.92531}, "CVE-2024-31445": {"epss_score": 0.52192, "epss_percentile": 0.97812}, "CVE-2024-31446": {"epss_score": 0.00151, "epss_percentile": 0.3629}, "CVE-2024-31447": {"epss_score": 0.00164, "epss_percentile": 0.38003}, "CVE-2024-31448": {"epss_score": 0.00829, "epss_percentile": 0.74012}, "CVE-2024-31449": {"epss_score": 0.58371, "epss_percentile": 0.98113}, "CVE-2024-31450": {"epss_score": 0.00097, "epss_percentile": 0.27452}, "CVE-2024-31451": {"epss_score": 0.00335, "epss_percentile": 0.55812}, "CVE-2024-31452": {"epss_score": 0.00117, "epss_percentile": 0.31377}, "CVE-2024-31453": {"epss_score": 0.00106, "epss_percentile": 0.29529}, "CVE-2024-31454": {"epss_score": 0.00109, "epss_percentile": 0.29925}, "CVE-2024-31455": {"epss_score": 0.00343, "epss_percentile": 0.56456}, "CVE-2024-31456": {"epss_score": 0.00582, "epss_percentile": 0.68312}, "CVE-2024-31457": {"epss_score": 0.00313, "epss_percentile": 0.54045}, "CVE-2024-31458": {"epss_score": 0.06015, "epss_percentile": 0.90412}, "CVE-2024-31459": {"epss_score": 0.03103, "epss_percentile": 0.86412}, "CVE-2024-31460": {"epss_score": 0.01835, "epss_percentile": 0.82466}, "CVE-2024-31461": {"epss_score": 0.00407, "epss_percentile": 0.6062}, "CVE-2024-31462": {"epss_score": 0.00245, "epss_percentile": 0.47637}, "CVE-2024-31463": {"epss_score": 0.00038, "epss_percentile": 0.11419}, "CVE-2024-31464": {"epss_score": 0.00202, "epss_percentile": 0.42396}, "CVE-2024-31465": {"epss_score": 0.3531, "epss_percentile": 0.96899}, "CVE-2024-31466": {"epss_score": 0.01615, "epss_percentile": 0.8135}, "CVE-2024-31467": {"epss_score": 0.01615, "epss_percentile": 0.8135}, "CVE-2024-31468": {"epss_score": 0.01615, "epss_percentile": 0.8135}, "CVE-2024-31469": {"epss_score": 0.03096, "epss_percentile": 0.86404}, "CVE-2024-31470": {"epss_score": 0.07363, "epss_percentile": 0.91433}, "CVE-2024-31471": {"epss_score": 0.02054, "epss_percentile": 0.83418}, "CVE-2024-31472": {"epss_score": 0.0108, "epss_percentile": 0.77364}, "CVE-2024-31473": {"epss_score": 0.0142, "epss_percentile": 0.80168}, "CVE-2024-31474": {"epss_score": 0.01582, "epss_percentile": 0.81143}, "CVE-2024-31475": {"epss_score": 0.01582, "epss_percentile": 0.81143}, "CVE-2024-31476": {"epss_score": 0.00665, "epss_percentile": 0.70653}, "CVE-2024-31477": {"epss_score": 0.00701, "epss_percentile": 0.71503}, "CVE-2024-31478": {"epss_score": 0.00212, "epss_percentile": 0.43747}, "CVE-2024-31479": {"epss_score": 0.00242, "epss_percentile": 0.47408}, "CVE-2024-31480": {"epss_score": 0.00242, "epss_percentile": 0.47408}, "CVE-2024-31481": {"epss_score": 0.00242, "epss_percentile": 0.47408}, "CVE-2024-31482": {"epss_score": 0.00242, "epss_percentile": 0.47408}, "CVE-2024-31483": {"epss_score": 0.00109, "epss_percentile": 0.29958}, "CVE-2024-31484": {"epss_score": 0.00064, "epss_percentile": 0.20322}, "CVE-2024-31485": {"epss_score": 0.00633, "epss_percentile": 0.69785}, "CVE-2024-31486": {"epss_score": 0.0008, "epss_percentile": 0.24199}, "CVE-2024-31487": {"epss_score": 0.00528, "epss_percentile": 0.66554}, "CVE-2024-31488": {"epss_score": 0.00476, "epss_percentile": 0.64278}, "CVE-2024-31489": {"epss_score": 0.00138, "epss_percentile": 0.34456}, "CVE-2024-31490": {"epss_score": 0.00381, "epss_percentile": 0.59017}, "CVE-2024-31491": {"epss_score": 0.01134, "epss_percentile": 0.77894}, "CVE-2024-31492": {"epss_score": 0.00109, "epss_percentile": 0.29932}, "CVE-2024-31493": {"epss_score": 0.00465, "epss_percentile": 0.63772}, "CVE-2024-31495": {"epss_score": 0.00269, "epss_percentile": 0.50182}, "CVE-2024-31496": {"epss_score": 0.00065, "epss_percentile": 0.20547}, "CVE-2024-31497": {"epss_score": 0.19221, "epss_percentile": 0.95151}, "CVE-2024-31498": {"epss_score": 0.00071, "epss_percentile": 0.22021}, "CVE-2024-31502": {"epss_score": 0.00238, "epss_percentile": 0.46824}, "CVE-2024-31503": {"epss_score": 0.00057, "epss_percentile": 0.18131}, "CVE-2024-31504": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-31506": {"epss_score": 0.00065, "epss_percentile": 0.20572}, "CVE-2024-31507": {"epss_score": 0.00053, "epss_percentile": 0.16717}, "CVE-2024-31510": {"epss_score": 0.01287, "epss_percentile": 0.79193}, "CVE-2024-31525": {"epss_score": 0.00147, "epss_percentile": 0.35695}, "CVE-2024-31544": {"epss_score": 0.00128, "epss_percentile": 0.33011}, "CVE-2024-31545": {"epss_score": 0.00068, "epss_percentile": 0.21361}, "CVE-2024-31546": {"epss_score": 0.00112, "epss_percentile": 0.30524}, "CVE-2024-31547": {"epss_score": 0.00107, "epss_percentile": 0.29722}, "CVE-2024-31551": {"epss_score": 0.00554, "epss_percentile": 0.67433}, "CVE-2024-31552": {"epss_score": 0.00099, "epss_percentile": 0.28353}, "CVE-2024-31556": {"epss_score": 0.00114, "epss_percentile": 0.30741}, "CVE-2024-31570": {"epss_score": 0.0022, "epss_percentile": 0.4458}, "CVE-2024-31573": {"epss_score": 0.00035, "epss_percentile": 0.09945}, "CVE-2024-31574": {"epss_score": 0.00047, "epss_percentile": 0.14649}, "CVE-2024-31578": {"epss_score": 0.00351, "epss_percentile": 0.57036}, "CVE-2024-31580": {"epss_score": 0.00024, "epss_percentile": 0.05806}, "CVE-2024-31581": {"epss_score": 0.00217, "epss_percentile": 0.44249}, "CVE-2024-31582": {"epss_score": 0.00022, "epss_percentile": 0.05252}, "CVE-2024-31583": {"epss_score": 0.00049, "epss_percentile": 0.1556}, "CVE-2024-31584": {"epss_score": 0.00081, "epss_percentile": 0.24208}, "CVE-2024-31585": {"epss_score": 0.00019, "epss_percentile": 0.04249}, "CVE-2024-31586": {"epss_score": 0.00268, "epss_percentile": 0.50087}, "CVE-2024-31587": {"epss_score": 0.00092, "epss_percentile": 0.26484}, "CVE-2024-31601": {"epss_score": 0.00216, "epss_percentile": 0.44146}, "CVE-2024-31609": {"epss_score": 0.00068, "epss_percentile": 0.2139}, "CVE-2024-31610": {"epss_score": 0.00199, "epss_percentile": 0.42174}, "CVE-2024-31611": {"epss_score": 0.00228, "epss_percentile": 0.4548}, "CVE-2024-31612": {"epss_score": 0.00163, "epss_percentile": 0.37827}, "CVE-2024-31613": {"epss_score": 0.00117, "epss_percentile": 0.31264}, "CVE-2024-31615": {"epss_score": 0.00103, "epss_percentile": 0.29045}, "CVE-2024-31616": {"epss_score": 0.00127, "epss_percentile": 0.32842}, "CVE-2024-31617": {"epss_score": 0.00141, "epss_percentile": 0.34945}, "CVE-2024-31621": {"epss_score": 0.80162, "epss_percentile": 0.99073}, "CVE-2024-31634": {"epss_score": 0.0013, "epss_percentile": 0.33239}, "CVE-2024-31636": {"epss_score": 0.00076, "epss_percentile": 0.23094}, "CVE-2024-31648": {"epss_score": 0.00117, "epss_percentile": 0.31299}, "CVE-2024-31649": {"epss_score": 0.00121, "epss_percentile": 0.31994}, "CVE-2024-31650": {"epss_score": 0.0015, "epss_percentile": 0.36055}, "CVE-2024-31651": {"epss_score": 0.0013, "epss_percentile": 0.33276}, "CVE-2024-31652": {"epss_score": 0.0013, "epss_percentile": 0.33276}, "CVE-2024-31666": {"epss_score": 0.27139, "epss_percentile": 0.96211}, "CVE-2024-31668": {"epss_score": 0.00143, "epss_percentile": 0.35165}, "CVE-2024-31669": {"epss_score": 0.00196, "epss_percentile": 0.41787}, "CVE-2024-31670": {"epss_score": 0.00166, "epss_percentile": 0.38164}, "CVE-2024-31673": {"epss_score": 0.00408, "epss_percentile": 0.60682}, "CVE-2024-31678": {"epss_score": 0.00104, "epss_percentile": 0.29219}, "CVE-2024-31680": {"epss_score": 0.00102, "epss_percentile": 0.28753}, "CVE-2024-31682": {"epss_score": 0.00146, "epss_percentile": 0.3554}, "CVE-2024-31684": {"epss_score": 0.00047, "epss_percentile": 0.14806}, "CVE-2024-31695": {"epss_score": 0.00067, "epss_percentile": 0.21012}, "CVE-2024-31705": {"epss_score": 0.0304, "epss_percentile": 0.86271}, "CVE-2024-31714": {"epss_score": 0.00406, "epss_percentile": 0.60518}, "CVE-2024-31741": {"epss_score": 0.00171, "epss_percentile": 0.38798}, "CVE-2024-31744": {"epss_score": 0.00026, "epss_percentile": 0.06594}, "CVE-2024-31747": {"epss_score": 0.00043, "epss_percentile": 0.13228}, "CVE-2024-31750": {"epss_score": 0.93636, "epss_percentile": 0.99827}, "CVE-2024-31755": {"epss_score": 0.02326, "epss_percentile": 0.8439}, "CVE-2024-31756": {"epss_score": 0.00108, "epss_percentile": 0.29884}, "CVE-2024-31757": {"epss_score": 0.00108, "epss_percentile": 0.29884}, "CVE-2024-31759": {"epss_score": 0.00179, "epss_percentile": 0.39848}, "CVE-2024-31760": {"epss_score": 0.00049, "epss_percentile": 0.15464}, "CVE-2024-31771": {"epss_score": 0.02956, "epss_percentile": 0.86062}, "CVE-2024-31777": {"epss_score": 0.30388, "epss_percentile": 0.96535}, "CVE-2024-31783": {"epss_score": 0.00098, "epss_percentile": 0.27711}, "CVE-2024-31784": {"epss_score": 0.00062, "epss_percentile": 0.19788}, "CVE-2024-31798": {"epss_score": 0.00077, "epss_percentile": 0.23367}, "CVE-2024-31799": {"epss_score": 0.00038, "epss_percentile": 0.11216}, "CVE-2024-31800": {"epss_score": 0.00019, "epss_percentile": 0.04337}, "CVE-2024-31801": {"epss_score": 0.01213, "epss_percentile": 0.78569}, "CVE-2024-31802": {"epss_score": 0.00035, "epss_percentile": 0.09918}, "CVE-2024-31803": {"epss_score": 0.05726, "epss_percentile": 0.90155}, "CVE-2024-31804": {"epss_score": 0.00106, "epss_percentile": 0.29538}, "CVE-2024-31805": {"epss_score": 0.00064, "epss_percentile": 0.20154}, "CVE-2024-31806": {"epss_score": 0.00042, "epss_percentile": 0.12899}, "CVE-2024-31807": {"epss_score": 0.03412, "epss_percentile": 0.87087}, "CVE-2024-31808": {"epss_score": 0.00843, "epss_percentile": 0.74267}, "CVE-2024-31809": {"epss_score": 0.01482, "epss_percentile": 0.8058}, "CVE-2024-31810": {"epss_score": 0.00588, "epss_percentile": 0.68487}, "CVE-2024-31811": {"epss_score": 0.01483, "epss_percentile": 0.80584}, "CVE-2024-31812": {"epss_score": 0.00076, "epss_percentile": 0.23111}, "CVE-2024-31813": {"epss_score": 0.00048, "epss_percentile": 0.14947}, "CVE-2024-31814": {"epss_score": 0.00049, "epss_percentile": 0.15354}, "CVE-2024-31815": {"epss_score": 0.00096, "epss_percentile": 0.27302}, "CVE-2024-31816": {"epss_score": 0.00109, "epss_percentile": 0.29918}, "CVE-2024-31817": {"epss_score": 0.10353, "epss_percentile": 0.92956}, "CVE-2024-31818": {"epss_score": 0.09585, "epss_percentile": 0.92609}, "CVE-2024-31819": {"epss_score": 0.80423, "epss_percentile": 0.99087}, "CVE-2024-31820": {"epss_score": 0.07397, "epss_percentile": 0.91451}, "CVE-2024-31821": {"epss_score": 0.01949, "epss_percentile": 0.83012}, "CVE-2024-31822": {"epss_score": 0.06184, "epss_percentile": 0.9054}, "CVE-2024-31823": {"epss_score": 0.06188, "epss_percentile": 0.90545}, "CVE-2024-31828": {"epss_score": 0.00222, "epss_percentile": 0.44727}, "CVE-2024-31835": {"epss_score": 0.23148, "epss_percentile": 0.9574}, "CVE-2024-31837": {"epss_score": 0.00029, "epss_percentile": 0.07908}, "CVE-2024-31839": {"epss_score": 0.80189, "epss_percentile": 0.99075}, "CVE-2024-31840": {"epss_score": 0.00153, "epss_percentile": 0.36542}, "CVE-2024-31841": {"epss_score": 0.00303, "epss_percentile": 0.53215}, "CVE-2024-31842": {"epss_score": 0.00203, "epss_percentile": 0.42553}, "CVE-2024-31843": {"epss_score": 0.00137, "epss_percentile": 0.34249}, "CVE-2024-31844": {"epss_score": 0.00144, "epss_percentile": 0.3527}, "CVE-2024-31845": {"epss_score": 0.00184, "epss_percentile": 0.40438}, "CVE-2024-31846": {"epss_score": 0.00174, "epss_percentile": 0.39197}, "CVE-2024-31847": {"epss_score": 0.00472, "epss_percentile": 0.64069}, "CVE-2024-31848": {"epss_score": 0.93601, "epss_percentile": 0.99822}, "CVE-2024-31849": {"epss_score": 0.90996, "epss_percentile": 0.99614}, "CVE-2024-31850": {"epss_score": 0.88754, "epss_percentile": 0.99488}, "CVE-2024-31851": {"epss_score": 0.86369, "epss_percentile": 0.99379}, "CVE-2024-31852": {"epss_score": 0.00103, "epss_percentile": 0.28898}, "CVE-2024-31853": {"epss_score": 0.00027, "epss_percentile": 0.06768}, "CVE-2024-31854": {"epss_score": 0.00027, "epss_percentile": 0.06768}, "CVE-2024-31856": {"epss_score": 0.00257, "epss_percentile": 0.48841}, "CVE-2024-31857": {"epss_score": 0.00388, "epss_percentile": 0.59346}, "CVE-2024-31858": {"epss_score": 0.00033, "epss_percentile": 0.09244}, "CVE-2024-31859": {"epss_score": 0.00109, "epss_percentile": 0.29984}, "CVE-2024-31860": {"epss_score": 0.00547, "epss_percentile": 0.67264}, "CVE-2024-31862": {"epss_score": 0.00215, "epss_percentile": 0.44035}, "CVE-2024-31863": {"epss_score": 0.00142, "epss_percentile": 0.34969}, "CVE-2024-31864": {"epss_score": 0.00625, "epss_percentile": 0.6959}, "CVE-2024-31865": {"epss_score": 0.00631, "epss_percentile": 0.6971}, "CVE-2024-31866": {"epss_score": 0.0114, "epss_percentile": 0.77948}, "CVE-2024-31867": {"epss_score": 0.01236, "epss_percentile": 0.78774}, "CVE-2024-31868": {"epss_score": 0.01134, "epss_percentile": 0.7789}, "CVE-2024-31869": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2024-31870": {"epss_score": 0.00058, "epss_percentile": 0.18356}, "CVE-2024-31871": {"epss_score": 0.00147, "epss_percentile": 0.3575}, "CVE-2024-31872": {"epss_score": 0.00113, "epss_percentile": 0.30606}, "CVE-2024-31873": {"epss_score": 0.00115, "epss_percentile": 0.3096}, "CVE-2024-31874": {"epss_score": 0.00031, "epss_percentile": 0.08667}, "CVE-2024-31878": {"epss_score": 0.00108, "epss_percentile": 0.29839}, "CVE-2024-31879": {"epss_score": 0.00754, "epss_percentile": 0.72693}, "CVE-2024-31880": {"epss_score": 0.00255, "epss_percentile": 0.48685}, "CVE-2024-31881": {"epss_score": 0.00324, "epss_percentile": 0.5496}, "CVE-2024-31882": {"epss_score": 0.00203, "epss_percentile": 0.42552}, "CVE-2024-31883": {"epss_score": 0.00189, "epss_percentile": 0.40963}, "CVE-2024-31887": {"epss_score": 0.00092, "epss_percentile": 0.2645}, "CVE-2024-31889": {"epss_score": 0.00206, "epss_percentile": 0.43066}, "CVE-2024-31890": {"epss_score": 0.00044, "epss_percentile": 0.13439}, "CVE-2024-31891": {"epss_score": 0.00024, "epss_percentile": 0.05739}, "CVE-2024-31892": {"epss_score": 0.00204, "epss_percentile": 0.42627}, "CVE-2024-31893": {"epss_score": 0.00107, "epss_percentile": 0.29697}, "CVE-2024-31894": {"epss_score": 0.00089, "epss_percentile": 0.25959}, "CVE-2024-31895": {"epss_score": 0.00127, "epss_percentile": 0.32914}, "CVE-2024-31896": {"epss_score": 0.00027, "epss_percentile": 0.07137}, "CVE-2024-31897": {"epss_score": 0.00124, "epss_percentile": 0.32441}, "CVE-2024-31898": {"epss_score": 0.00026, "epss_percentile": 0.06614}, "CVE-2024-31899": {"epss_score": 0.00037, "epss_percentile": 0.10671}, "CVE-2024-31902": {"epss_score": 0.00136, "epss_percentile": 0.34112}, "CVE-2024-31903": {"epss_score": 0.17076, "epss_percentile": 0.9477}, "CVE-2024-31904": {"epss_score": 0.00138, "epss_percentile": 0.34502}, "CVE-2024-31905": {"epss_score": 0.00019, "epss_percentile": 0.04076}, "CVE-2024-31906": {"epss_score": 0.00055, "epss_percentile": 0.176}, "CVE-2024-31907": {"epss_score": 0.00206, "epss_percentile": 0.43066}, "CVE-2024-31908": {"epss_score": 0.00206, "epss_percentile": 0.43066}, "CVE-2024-31912": {"epss_score": 0.00132, "epss_percentile": 0.33545}, "CVE-2024-31913": {"epss_score": 0.00111, "epss_percentile": 0.30343}, "CVE-2024-31914": {"epss_score": 0.00192, "epss_percentile": 0.41321}, "CVE-2024-31916": {"epss_score": 0.00036, "epss_percentile": 0.10241}, "CVE-2024-31919": {"epss_score": 0.00135, "epss_percentile": 0.33943}, "CVE-2024-31920": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31921": {"epss_score": 0.00177, "epss_percentile": 0.39574}, "CVE-2024-31922": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31923": {"epss_score": 0.00226, "epss_percentile": 0.4525}, "CVE-2024-31924": {"epss_score": 0.00142, "epss_percentile": 0.34971}, "CVE-2024-31925": {"epss_score": 0.00118, "epss_percentile": 0.31475}, "CVE-2024-31926": {"epss_score": 0.00165, "epss_percentile": 0.38029}, "CVE-2024-31927": {"epss_score": 0.00118, "epss_percentile": 0.31475}, "CVE-2024-31928": {"epss_score": 0.00173, "epss_percentile": 0.39084}, "CVE-2024-31929": {"epss_score": 0.00124, "epss_percentile": 0.32425}, "CVE-2024-31930": {"epss_score": 0.00124, "epss_percentile": 0.32425}, "CVE-2024-31931": {"epss_score": 0.00136, "epss_percentile": 0.341}, "CVE-2024-31932": {"epss_score": 0.00116, "epss_percentile": 0.31153}, "CVE-2024-31933": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-31934": {"epss_score": 0.00204, "epss_percentile": 0.42646}, "CVE-2024-31935": {"epss_score": 0.00153, "epss_percentile": 0.3651}, "CVE-2024-31936": {"epss_score": 0.00101, "epss_percentile": 0.28581}, "CVE-2024-31937": {"epss_score": 0.00118, "epss_percentile": 0.31475}, "CVE-2024-31938": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31939": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31940": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-31941": {"epss_score": 0.00093, "epss_percentile": 0.26716}, "CVE-2024-31942": {"epss_score": 0.0018, "epss_percentile": 0.39905}, "CVE-2024-31943": {"epss_score": 0.00147, "epss_percentile": 0.35657}, "CVE-2024-31944": {"epss_score": 0.00177, "epss_percentile": 0.39574}, "CVE-2024-31946": {"epss_score": 0.0006, "epss_percentile": 0.18963}, "CVE-2024-31947": {"epss_score": 0.01745, "epss_percentile": 0.82068}, "CVE-2024-31948": {"epss_score": 0.00078, "epss_percentile": 0.23682}, "CVE-2024-31949": {"epss_score": 0.0004, "epss_percentile": 0.12035}, "CVE-2024-31950": {"epss_score": 0.00322, "epss_percentile": 0.54824}, "CVE-2024-31951": {"epss_score": 0.00088, "epss_percentile": 0.25749}, "CVE-2024-31952": {"epss_score": 0.00147, "epss_percentile": 0.35778}, "CVE-2024-31953": {"epss_score": 0.00283, "epss_percentile": 0.5136}, "CVE-2024-31954": {"epss_score": 0.00137, "epss_percentile": 0.34271}, "CVE-2024-31955": {"epss_score": 0.00012, "epss_percentile": 0.0127}, "CVE-2024-31956": {"epss_score": 0.00325, "epss_percentile": 0.54991}, "CVE-2024-31957": {"epss_score": 0.00286, "epss_percentile": 0.51687}, "CVE-2024-31958": {"epss_score": 0.00056, "epss_percentile": 0.17928}, "CVE-2024-31959": {"epss_score": 0.00118, "epss_percentile": 0.31413}, "CVE-2024-31960": {"epss_score": 0.00199, "epss_percentile": 0.42184}, "CVE-2024-31961": {"epss_score": 0.00729, "epss_percentile": 0.7213}, "CVE-2024-31963": {"epss_score": 0.00053, "epss_percentile": 0.16968}, "CVE-2024-31964": {"epss_score": 0.00026, "epss_percentile": 0.06574}, "CVE-2024-31965": {"epss_score": 0.00039, "epss_percentile": 0.11482}, "CVE-2024-31966": {"epss_score": 0.00036, "epss_percentile": 0.10505}, "CVE-2024-31967": {"epss_score": 0.00134, "epss_percentile": 0.33841}, "CVE-2024-31970": {"epss_score": 0.00145, "epss_percentile": 0.35382}, "CVE-2024-31971": {"epss_score": 0.00086, "epss_percentile": 0.25429}, "CVE-2024-31972": {"epss_score": 0.00072, "epss_percentile": 0.2247}, "CVE-2024-31973": {"epss_score": 0.00077, "epss_percentile": 0.23447}, "CVE-2024-31974": {"epss_score": 0.0214, "epss_percentile": 0.83746}, "CVE-2024-31975": {"epss_score": 0.00026, "epss_percentile": 0.06381}, "CVE-2024-31976": {"epss_score": 0.00453, "epss_percentile": 0.63208}, "CVE-2024-31977": {"epss_score": 0.00858, "epss_percentile": 0.74509}, "CVE-2024-31978": {"epss_score": 0.00324, "epss_percentile": 0.5497}, "CVE-2024-31979": {"epss_score": 0.00711, "epss_percentile": 0.71733}, "CVE-2024-31980": {"epss_score": 0.0015, "epss_percentile": 0.3609}, "CVE-2024-31981": {"epss_score": 0.33683, "epss_percentile": 0.96798}, "CVE-2024-31982": {"epss_score": 0.94247, "epss_percentile": 0.99924}, "CVE-2024-31983": {"epss_score": 0.36263, "epss_percentile": 0.96965}, "CVE-2024-31984": {"epss_score": 0.66038, "epss_percentile": 0.98448}, "CVE-2024-31985": {"epss_score": 0.00336, "epss_percentile": 0.56006}, "CVE-2024-31986": {"epss_score": 0.1081, "epss_percentile": 0.93112}, "CVE-2024-31987": {"epss_score": 0.33683, "epss_percentile": 0.96798}, "CVE-2024-31988": {"epss_score": 0.10842, "epss_percentile": 0.9313}, "CVE-2024-31989": {"epss_score": 0.09093, "epss_percentile": 0.92399}, "CVE-2024-31990": {"epss_score": 0.00113, "epss_percentile": 0.30689}, "CVE-2024-31991": {"epss_score": 0.00042, "epss_percentile": 0.12726}, "CVE-2024-31992": {"epss_score": 0.00148, "epss_percentile": 0.3589}, "CVE-2024-31993": {"epss_score": 0.00054, "epss_percentile": 0.17053}, "CVE-2024-31994": {"epss_score": 0.00049, "epss_percentile": 0.1548}, "CVE-2024-31995": {"epss_score": 0.00152, "epss_percentile": 0.36453}, "CVE-2024-31996": {"epss_score": 0.18375, "epss_percentile": 0.95007}, "CVE-2024-31997": {"epss_score": 0.60246, "epss_percentile": 0.98201}, "CVE-2024-31998": {"epss_score": 0.00247, "epss_percentile": 0.47892}, "CVE-2024-31999": {"epss_score": 0.00273, "epss_percentile": 0.50463}, "CVE-2024-32000": {"epss_score": 0.00063, "epss_percentile": 0.20067}, "CVE-2024-32001": {"epss_score": 0.00142, "epss_percentile": 0.34979}, "CVE-2024-32002": {"epss_score": 0.79594, "epss_percentile": 0.99047}, "CVE-2024-32003": {"epss_score": 0.00094, "epss_percentile": 0.26793}, "CVE-2024-32004": {"epss_score": 0.02631, "epss_percentile": 0.85281}, "CVE-2024-32005": {"epss_score": 0.00065, "epss_percentile": 0.20668}, "CVE-2024-32006": {"epss_score": 0.00047, "epss_percentile": 0.14659}, "CVE-2024-32007": {"epss_score": 0.00226, "epss_percentile": 0.45274}, "CVE-2024-32008": {"epss_score": 0.00015, "epss_percentile": 0.02197}, "CVE-2024-32009": {"epss_score": 0.00013, "epss_percentile": 0.01474}, "CVE-2024-32010": {"epss_score": 0.00015, "epss_percentile": 0.02541}, "CVE-2024-32011": {"epss_score": 0.00082, "epss_percentile": 0.24556}, "CVE-2024-32014": {"epss_score": 0.00015, "epss_percentile": 0.0241}, "CVE-2024-32017": {"epss_score": 0.01624, "epss_percentile": 0.81405}, "CVE-2024-32018": {"epss_score": 0.02203, "epss_percentile": 0.83994}, "CVE-2024-32019": {"epss_score": 0.00485, "epss_percentile": 0.64722}, "CVE-2024-32020": {"epss_score": 0.00094, "epss_percentile": 0.26994}, "CVE-2024-32021": {"epss_score": 0.00013, "epss_percentile": 0.01562}, "CVE-2024-32022": {"epss_score": 0.0307, "epss_percentile": 0.86345}, "CVE-2024-32023": {"epss_score": 0.00171, "epss_percentile": 0.38883}, "CVE-2024-32024": {"epss_score": 0.00306, "epss_percentile": 0.53465}, "CVE-2024-32025": {"epss_score": 0.02993, "epss_percentile": 0.86148}, "CVE-2024-32026": {"epss_score": 0.0307, "epss_percentile": 0.86345}, "CVE-2024-32027": {"epss_score": 0.0307, "epss_percentile": 0.86345}, "CVE-2024-32028": {"epss_score": 0.00042, "epss_percentile": 0.12479}, "CVE-2024-32030": {"epss_score": 0.81722, "epss_percentile": 0.99153}, "CVE-2024-32034": {"epss_score": 0.00418, "epss_percentile": 0.61281}, "CVE-2024-32035": {"epss_score": 0.00202, "epss_percentile": 0.42419}, "CVE-2024-32036": {"epss_score": 0.0041, "epss_percentile": 0.60837}, "CVE-2024-32037": {"epss_score": 0.00186, "epss_percentile": 0.40609}, "CVE-2024-32038": {"epss_score": 0.00596, "epss_percentile": 0.68706}, "CVE-2024-32039": {"epss_score": 0.01351, "epss_percentile": 0.79681}, "CVE-2024-32040": {"epss_score": 0.01351, "epss_percentile": 0.79681}, "CVE-2024-32041": {"epss_score": 0.00592, "epss_percentile": 0.68607}, "CVE-2024-32042": {"epss_score": 0.00176, "epss_percentile": 0.39402}, "CVE-2024-32044": {"epss_score": 0.00054, "epss_percentile": 0.17358}, "CVE-2024-32045": {"epss_score": 0.00265, "epss_percentile": 0.4979}, "CVE-2024-32046": {"epss_score": 0.00097, "epss_percentile": 0.27507}, "CVE-2024-32047": {"epss_score": 0.00211, "epss_percentile": 0.43624}, "CVE-2024-32048": {"epss_score": 0.00113, "epss_percentile": 0.30704}, "CVE-2024-32049": {"epss_score": 0.00433, "epss_percentile": 0.62175}, "CVE-2024-32051": {"epss_score": 0.00052, "epss_percentile": 0.16567}, "CVE-2024-32053": {"epss_score": 0.00206, "epss_percentile": 0.42921}, "CVE-2024-32055": {"epss_score": 0.00158, "epss_percentile": 0.3717}, "CVE-2024-32056": {"epss_score": 0.00135, "epss_percentile": 0.34017}, "CVE-2024-32057": {"epss_score": 0.00121, "epss_percentile": 0.31817}, "CVE-2024-32058": {"epss_score": 0.00121, "epss_percentile": 0.31813}, "CVE-2024-32059": {"epss_score": 0.00166, "epss_percentile": 0.3817}, "CVE-2024-32060": {"epss_score": 0.00166, "epss_percentile": 0.3817}, "CVE-2024-32061": {"epss_score": 0.00166, "epss_percentile": 0.3817}, "CVE-2024-32062": {"epss_score": 0.00127, "epss_percentile": 0.32805}, "CVE-2024-32063": {"epss_score": 0.00127, "epss_percentile": 0.32805}, "CVE-2024-32064": {"epss_score": 0.00166, "epss_percentile": 0.3817}, "CVE-2024-32065": {"epss_score": 0.00166, "epss_percentile": 0.3817}, "CVE-2024-32066": {"epss_score": 0.00206, "epss_percentile": 0.43055}, "CVE-2024-32077": {"epss_score": 0.03417, "epss_percentile": 0.87094}, "CVE-2024-32078": {"epss_score": 0.00105, "epss_percentile": 0.29288}, "CVE-2024-32079": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-32080": {"epss_score": 0.00118, "epss_percentile": 0.31475}, "CVE-2024-32081": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-32082": {"epss_score": 0.00154, "epss_percentile": 0.36752}, "CVE-2024-32083": {"epss_score": 0.00129, "epss_percentile": 0.33084}, "CVE-2024-32084": {"epss_score": 0.00129, "epss_percentile": 0.33181}, "CVE-2024-32085": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-32086": {"epss_score": 0.00618, "epss_percentile": 0.69365}, "CVE-2024-32087": {"epss_score": 0.00338, "epss_percentile": 0.56162}, "CVE-2024-32088": {"epss_score": 0.00129, "epss_percentile": 0.33181}, "CVE-2024-32089": {"epss_score": 0.00129, "epss_percentile": 0.33181}, "CVE-2024-32090": {"epss_score": 0.00129, "epss_percentile": 0.33181}, "CVE-2024-32091": {"epss_score": 0.00135, "epss_percentile": 0.34026}, "CVE-2024-32092": {"epss_score": 0.00093, "epss_percentile": 0.26716}, "CVE-2024-32093": {"epss_score": 0.00093, "epss_percentile": 0.26716}, "CVE-2024-32094": {"epss_score": 0.00129, "epss_percentile": 0.3319}, "CVE-2024-32095": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32096": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-32097": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-32098": {"epss_score": 0.0037, "epss_percentile": 0.58287}, "CVE-2024-32099": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32100": {"epss_score": 0.006, "epss_percentile": 0.68831}, "CVE-2024-32101": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32102": {"epss_score": 0.0014, "epss_percentile": 0.34669}, "CVE-2024-32103": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-32104": {"epss_score": 0.15133, "epss_percentile": 0.9437}, "CVE-2024-32105": {"epss_score": 0.00102, "epss_percentile": 0.28858}, "CVE-2024-32106": {"epss_score": 0.00224, "epss_percentile": 0.44998}, "CVE-2024-32107": {"epss_score": 0.00147, "epss_percentile": 0.35657}, "CVE-2024-32108": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32109": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32111": {"epss_score": 0.00406, "epss_percentile": 0.60546}, "CVE-2024-32112": {"epss_score": 0.0014, "epss_percentile": 0.34669}, "CVE-2024-32113": {"epss_score": 0.93963, "epss_percentile": 0.99875}, "CVE-2024-32114": {"epss_score": 0.01908, "epss_percentile": 0.82817}, "CVE-2024-32115": {"epss_score": 0.00532, "epss_percentile": 0.66711}, "CVE-2024-32116": {"epss_score": 0.00144, "epss_percentile": 0.35326}, "CVE-2024-32117": {"epss_score": 0.00321, "epss_percentile": 0.54684}, "CVE-2024-32118": {"epss_score": 0.00087, "epss_percentile": 0.25576}, "CVE-2024-32119": {"epss_score": 0.00021, "epss_percentile": 0.0478}, "CVE-2024-32122": {"epss_score": 0.00024, "epss_percentile": 0.06011}, "CVE-2024-32123": {"epss_score": 0.00055, "epss_percentile": 0.17629}, "CVE-2024-32124": {"epss_score": 0.00033, "epss_percentile": 0.09342}, "CVE-2024-32125": {"epss_score": 0.00327, "epss_percentile": 0.55149}, "CVE-2024-32126": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-32127": {"epss_score": 0.00386, "epss_percentile": 0.59234}, "CVE-2024-32128": {"epss_score": 0.00232, "epss_percentile": 0.45895}, "CVE-2024-32129": {"epss_score": 0.00324, "epss_percentile": 0.54943}, "CVE-2024-32130": {"epss_score": 0.00152, "epss_percentile": 0.36425}, "CVE-2024-32131": {"epss_score": 0.00484, "epss_percentile": 0.64639}, "CVE-2024-32132": {"epss_score": 0.00314, "epss_percentile": 0.54116}, "CVE-2024-32133": {"epss_score": 0.00193, "epss_percentile": 0.41484}, "CVE-2024-32134": {"epss_score": 0.00237, "epss_percentile": 0.46658}, "CVE-2024-32135": {"epss_score": 0.00259, "epss_percentile": 0.49059}, "CVE-2024-32136": {"epss_score": 0.32811, "epss_percentile": 0.9673}, "CVE-2024-32137": {"epss_score": 0.00349, "epss_percentile": 0.5686}, "CVE-2024-32138": {"epss_score": 0.00182, "epss_percentile": 0.40227}, "CVE-2024-32139": {"epss_score": 0.07302, "epss_percentile": 0.91393}, "CVE-2024-32140": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-32141": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32142": {"epss_score": 0.00097, "epss_percentile": 0.27513}, "CVE-2024-32143": {"epss_score": 0.00546, "epss_percentile": 0.67224}, "CVE-2024-32144": {"epss_score": 0.00067, "epss_percentile": 0.20982}, "CVE-2024-32145": {"epss_score": 0.00211, "epss_percentile": 0.43707}, "CVE-2024-32146": {"epss_score": 0.00351, "epss_percentile": 0.57048}, "CVE-2024-32147": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-32148": {"epss_score": 0.00109, "epss_percentile": 0.30007}, "CVE-2024-32149": {"epss_score": 0.00232, "epss_percentile": 0.45912}, "CVE-2024-32151": {"epss_score": 0.00176, "epss_percentile": 0.39406}, "CVE-2024-32152": {"epss_score": 0.002, "epss_percentile": 0.42227}, "CVE-2024-32161": {"epss_score": 0.00153, "epss_percentile": 0.36533}, "CVE-2024-32162": {"epss_score": 0.001, "epss_percentile": 0.28541}, "CVE-2024-32163": {"epss_score": 0.00069, "epss_percentile": 0.21606}, "CVE-2024-32166": {"epss_score": 0.00163, "epss_percentile": 0.3786}, "CVE-2024-32167": {"epss_score": 0.00152, "epss_percentile": 0.36504}, "CVE-2024-32206": {"epss_score": 0.00225, "epss_percentile": 0.45131}, "CVE-2024-32210": {"epss_score": 0.0017, "epss_percentile": 0.38723}, "CVE-2024-32211": {"epss_score": 0.0007, "epss_percentile": 0.21939}, "CVE-2024-32212": {"epss_score": 0.00163, "epss_percentile": 0.37835}, "CVE-2024-32213": {"epss_score": 0.00175, "epss_percentile": 0.3931}, "CVE-2024-32228": {"epss_score": 0.00365, "epss_percentile": 0.5801}, "CVE-2024-32229": {"epss_score": 0.00224, "epss_percentile": 0.45043}, "CVE-2024-32230": {"epss_score": 0.00162, "epss_percentile": 0.37666}, "CVE-2024-32231": {"epss_score": 0.04079, "epss_percentile": 0.88215}, "CVE-2024-32236": {"epss_score": 0.00052, "epss_percentile": 0.16518}, "CVE-2024-32238": {"epss_score": 0.90863, "epss_percentile": 0.99605}, "CVE-2024-32254": {"epss_score": 0.00235, "epss_percentile": 0.46331}, "CVE-2024-32256": {"epss_score": 0.00167, "epss_percentile": 0.38305}, "CVE-2024-32258": {"epss_score": 0.50146, "epss_percentile": 0.97722}, "CVE-2024-32268": {"epss_score": 0.00266, "epss_percentile": 0.49887}, "CVE-2024-32269": {"epss_score": 0.00549, "epss_percentile": 0.67302}, "CVE-2024-32281": {"epss_score": 0.03416, "epss_percentile": 0.87093}, "CVE-2024-32282": {"epss_score": 0.00458, "epss_percentile": 0.63432}, "CVE-2024-32283": {"epss_score": 0.00342, "epss_percentile": 0.56376}, "CVE-2024-32285": {"epss_score": 0.00123, "epss_percentile": 0.32189}, "CVE-2024-32286": {"epss_score": 0.00334, "epss_percentile": 0.55696}, "CVE-2024-32287": {"epss_score": 0.0011, "epss_percentile": 0.30085}, "CVE-2024-32288": {"epss_score": 0.00149, "epss_percentile": 0.35934}, "CVE-2024-32290": {"epss_score": 0.00123, "epss_percentile": 0.32193}, "CVE-2024-32291": {"epss_score": 0.00148, "epss_percentile": 0.35899}, "CVE-2024-32292": {"epss_score": 0.01036, "epss_percentile": 0.7691}, "CVE-2024-32293": {"epss_score": 0.05852, "epss_percentile": 0.90263}, "CVE-2024-32299": {"epss_score": 0.00258, "epss_percentile": 0.49013}, "CVE-2024-32301": {"epss_score": 0.00282, "epss_percentile": 0.5126}, "CVE-2024-32302": {"epss_score": 0.0016, "epss_percentile": 0.37481}, "CVE-2024-32303": {"epss_score": 0.00132, "epss_percentile": 0.33549}, "CVE-2024-32305": {"epss_score": 0.00264, "epss_percentile": 0.49749}, "CVE-2024-32306": {"epss_score": 0.00084, "epss_percentile": 0.24889}, "CVE-2024-32307": {"epss_score": 0.00236, "epss_percentile": 0.46361}, "CVE-2024-32310": {"epss_score": 0.00164, "epss_percentile": 0.37952}, "CVE-2024-32311": {"epss_score": 0.0007, "epss_percentile": 0.21939}, "CVE-2024-32312": {"epss_score": 0.0007, "epss_percentile": 0.21939}, "CVE-2024-32313": {"epss_score": 0.0007, "epss_percentile": 0.21939}, "CVE-2024-32314": {"epss_score": 0.00498, "epss_percentile": 0.65233}, "CVE-2024-32315": {"epss_score": 0.00115, "epss_percentile": 0.3103}, "CVE-2024-32316": {"epss_score": 0.00084, "epss_percentile": 0.24889}, "CVE-2024-32317": {"epss_score": 0.00253, "epss_percentile": 0.48445}, "CVE-2024-32318": {"epss_score": 0.00264, "epss_percentile": 0.49726}, "CVE-2024-32320": {"epss_score": 0.00142, "epss_percentile": 0.34954}, "CVE-2024-32323": {"epss_score": 0.00039, "epss_percentile": 0.11464}, "CVE-2024-32324": {"epss_score": 0.00043, "epss_percentile": 0.13226}, "CVE-2024-32325": {"epss_score": 0.00113, "epss_percentile": 0.30665}, "CVE-2024-32326": {"epss_score": 0.00167, "epss_percentile": 0.38296}, "CVE-2024-32327": {"epss_score": 0.00113, "epss_percentile": 0.3068}, "CVE-2024-32332": {"epss_score": 0.00182, "epss_percentile": 0.402}, "CVE-2024-32333": {"epss_score": 0.00091, "epss_percentile": 0.2638}, "CVE-2024-32334": {"epss_score": 0.00119, "epss_percentile": 0.3158}, "CVE-2024-32335": {"epss_score": 0.00165, "epss_percentile": 0.38041}, "CVE-2024-32337": {"epss_score": 0.0013, "epss_percentile": 0.33276}, "CVE-2024-32338": {"epss_score": 0.00197, "epss_percentile": 0.41934}, "CVE-2024-32339": {"epss_score": 0.0019, "epss_percentile": 0.41141}, "CVE-2024-32340": {"epss_score": 0.0015, "epss_percentile": 0.36055}, "CVE-2024-32341": {"epss_score": 0.00178, "epss_percentile": 0.39674}, "CVE-2024-32342": {"epss_score": 0.0013, "epss_percentile": 0.33276}, "CVE-2024-32343": {"epss_score": 0.00197, "epss_percentile": 0.41934}, "CVE-2024-32344": {"epss_score": 0.00103, "epss_percentile": 0.29062}, "CVE-2024-32345": {"epss_score": 0.0013, "epss_percentile": 0.33276}, "CVE-2024-32349": {"epss_score": 0.00923, "epss_percentile": 0.75497}, "CVE-2024-32350": {"epss_score": 0.04621, "epss_percentile": 0.88932}, "CVE-2024-32351": {"epss_score": 0.04621, "epss_percentile": 0.88932}, "CVE-2024-32352": {"epss_score": 0.04621, "epss_percentile": 0.88932}, "CVE-2024-32353": {"epss_score": 0.04607, "epss_percentile": 0.8891}, "CVE-2024-32354": {"epss_score": 0.00583, "epss_percentile": 0.68327}, "CVE-2024-32355": {"epss_score": 0.00844, "epss_percentile": 0.74281}, "CVE-2024-32358": {"epss_score": 0.00898, "epss_percentile": 0.7515}, "CVE-2024-32359": {"epss_score": 0.00052, "epss_percentile": 0.16492}, "CVE-2024-32368": {"epss_score": 0.00139, "epss_percentile": 0.34608}, "CVE-2024-32369": {"epss_score": 0.01994, "epss_percentile": 0.83187}, "CVE-2024-32370": {"epss_score": 0.03485, "epss_percentile": 0.87226}, "CVE-2024-32371": {"epss_score": 0.00727, "epss_percentile": 0.72085}, "CVE-2024-32384": {"epss_score": 0.00014, "epss_percentile": 0.01873}, "CVE-2024-32388": {"epss_score": 0.00043, "epss_percentile": 0.12957}, "CVE-2024-32391": {"epss_score": 0.00339, "epss_percentile": 0.56203}, "CVE-2024-32392": {"epss_score": 0.00218, "epss_percentile": 0.44407}, "CVE-2024-32394": {"epss_score": 0.0639, "epss_percentile": 0.90718}, "CVE-2024-32399": {"epss_score": 0.85263, "epss_percentile": 0.99326}, "CVE-2024-32404": {"epss_score": 0.00806, "epss_percentile": 0.7365}, "CVE-2024-32405": {"epss_score": 0.00122, "epss_percentile": 0.32102}, "CVE-2024-32406": {"epss_score": 0.04019, "epss_percentile": 0.88126}, "CVE-2024-32407": {"epss_score": 0.01672, "epss_percentile": 0.81679}, "CVE-2024-32409": {"epss_score": 0.02113, "epss_percentile": 0.8365}, "CVE-2024-32418": {"epss_score": 0.03886, "epss_percentile": 0.87904}, "CVE-2024-32428": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2024-32429": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2024-32430": {"epss_score": 0.00306, "epss_percentile": 0.53453}, "CVE-2024-32431": {"epss_score": 0.00417, "epss_percentile": 0.61221}, "CVE-2024-32432": {"epss_score": 0.00062, "epss_percentile": 0.19672}, "CVE-2024-32433": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32434": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32435": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32436": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32437": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32438": {"epss_score": 0.00136, "epss_percentile": 0.342}, "CVE-2024-32439": {"epss_score": 0.00136, "epss_percentile": 0.342}, "CVE-2024-32440": {"epss_score": 0.00136, "epss_percentile": 0.342}, "CVE-2024-32441": {"epss_score": 0.00137, "epss_percentile": 0.34209}, "CVE-2024-32442": {"epss_score": 0.00136, "epss_percentile": 0.342}, "CVE-2024-32443": {"epss_score": 0.00171, "epss_percentile": 0.38847}, "CVE-2024-32444": {"epss_score": 0.00072, "epss_percentile": 0.2235}, "CVE-2024-32445": {"epss_score": 0.00098, "epss_percentile": 0.27823}, "CVE-2024-32446": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-32447": {"epss_score": 0.00129, "epss_percentile": 0.33181}, "CVE-2024-32448": {"epss_score": 0.00129, "epss_percentile": 0.33181}, "CVE-2024-32449": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-32450": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32451": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-32452": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-32453": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2024-32454": {"epss_score": 0.00149, "epss_percentile": 0.35985}, "CVE-2024-32455": {"epss_score": 0.00114, "epss_percentile": 0.30852}, "CVE-2024-32456": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-32457": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-32458": {"epss_score": 0.01466, "epss_percentile": 0.80463}, "CVE-2024-32459": {"epss_score": 0.10192, "epss_percentile": 0.92887}, "CVE-2024-32460": {"epss_score": 0.01351, "epss_percentile": 0.79681}, "CVE-2024-32461": {"epss_score": 0.00108, "epss_percentile": 0.29886}, "CVE-2024-32462": {"epss_score": 0.00207, "epss_percentile": 0.43204}, "CVE-2024-32463": {"epss_score": 0.00179, "epss_percentile": 0.39834}, "CVE-2024-32464": {"epss_score": 0.0028, "epss_percentile": 0.51064}, "CVE-2024-32465": {"epss_score": 0.00168, "epss_percentile": 0.38443}, "CVE-2024-32466": {"epss_score": 0.00167, "epss_percentile": 0.38272}, "CVE-2024-32467": {"epss_score": 0.00059, "epss_percentile": 0.18928}, "CVE-2024-32468": {"epss_score": 0.00088, "epss_percentile": 0.25699}, "CVE-2024-32469": {"epss_score": 0.00485, "epss_percentile": 0.64716}, "CVE-2024-32470": {"epss_score": 0.00301, "epss_percentile": 0.53014}, "CVE-2024-32472": {"epss_score": 0.0024, "epss_percentile": 0.47231}, "CVE-2024-32473": {"epss_score": 0.00095, "epss_percentile": 0.27102}, "CVE-2024-32474": {"epss_score": 0.00733, "epss_percentile": 0.72207}, "CVE-2024-32475": {"epss_score": 0.0014, "epss_percentile": 0.34693}, "CVE-2024-32476": {"epss_score": 0.00416, "epss_percentile": 0.61173}, "CVE-2024-32477": {"epss_score": 0.00198, "epss_percentile": 0.42059}, "CVE-2024-32478": {"epss_score": 0.00045, "epss_percentile": 0.13961}, "CVE-2024-32479": {"epss_score": 0.00681, "epss_percentile": 0.71052}, "CVE-2024-32480": {"epss_score": 0.00384, "epss_percentile": 0.59135}, "CVE-2024-32481": {"epss_score": 0.01172, "epss_percentile": 0.7823}, "CVE-2024-32482": {"epss_score": 0.00023, "epss_percentile": 0.05439}, "CVE-2024-32483": {"epss_score": 0.00152, "epss_percentile": 0.36428}, "CVE-2024-32484": {"epss_score": 0.05963, "epss_percentile": 0.90367}, "CVE-2024-32485": {"epss_score": 0.00025, "epss_percentile": 0.0612}, "CVE-2024-32487": {"epss_score": 0.00357, "epss_percentile": 0.57466}, "CVE-2024-32488": {"epss_score": 0.00035, "epss_percentile": 0.09878}, "CVE-2024-32489": {"epss_score": 0.00166, "epss_percentile": 0.38194}, "CVE-2024-32491": {"epss_score": 0.00585, "epss_percentile": 0.68416}, "CVE-2024-32492": {"epss_score": 0.00498, "epss_percentile": 0.65228}, "CVE-2024-32493": {"epss_score": 0.00608, "epss_percentile": 0.69085}, "CVE-2024-32498": {"epss_score": 0.00158, "epss_percentile": 0.37153}, "CVE-2024-32499": {"epss_score": 0.00147, "epss_percentile": 0.35783}, "CVE-2024-32501": {"epss_score": 0.05629, "epss_percentile": 0.90067}, "CVE-2024-32502": {"epss_score": 0.00122, "epss_percentile": 0.32137}, "CVE-2024-32503": {"epss_score": 0.00166, "epss_percentile": 0.38243}, "CVE-2024-32504": {"epss_score": 0.00248, "epss_percentile": 0.47987}, "CVE-2024-32505": {"epss_score": 0.00139, "epss_percentile": 0.34621}, "CVE-2024-32506": {"epss_score": 0.00227, "epss_percentile": 0.4546}, "CVE-2024-32507": {"epss_score": 0.00573, "epss_percentile": 0.68056}, "CVE-2024-32508": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-32509": {"epss_score": 0.00127, "epss_percentile": 0.32818}, "CVE-2024-32510": {"epss_score": 0.00197, "epss_percentile": 0.4189}, "CVE-2024-32511": {"epss_score": 0.00885, "epss_percentile": 0.74942}, "CVE-2024-32512": {"epss_score": 0.0029, "epss_percentile": 0.52123}, "CVE-2024-32513": {"epss_score": 0.00326, "epss_percentile": 0.55079}, "CVE-2024-32514": {"epss_score": 0.00656, "epss_percentile": 0.70432}, "CVE-2024-32515": {"epss_score": 0.00107, "epss_percentile": 0.29661}, "CVE-2024-32516": {"epss_score": 0.00145, "epss_percentile": 0.35502}, "CVE-2024-32517": {"epss_score": 0.00148, "epss_percentile": 0.35909}, "CVE-2024-32518": {"epss_score": 0.00176, "epss_percentile": 0.39399}, "CVE-2024-32519": {"epss_score": 0.00148, "epss_percentile": 0.35909}, "CVE-2024-32520": {"epss_score": 0.00134, "epss_percentile": 0.33864}, "CVE-2024-32521": {"epss_score": 0.00674, "epss_percentile": 0.70848}, "CVE-2024-32522": {"epss_score": 0.00134, "epss_percentile": 0.33864}, "CVE-2024-32523": {"epss_score": 0.35497, "epss_percentile": 0.96916}, "CVE-2024-32524": {"epss_score": 0.0013, "epss_percentile": 0.33245}, "CVE-2024-32525": {"epss_score": 0.00148, "epss_percentile": 0.35909}, "CVE-2024-32526": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-32527": {"epss_score": 0.00127, "epss_percentile": 0.32918}, "CVE-2024-32528": {"epss_score": 0.00248, "epss_percentile": 0.47985}, "CVE-2024-32529": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-32530": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-32531": {"epss_score": 0.00186, "epss_percentile": 0.40583}, "CVE-2024-32532": {"epss_score": 0.00162, "epss_percentile": 0.37742}, "CVE-2024-32533": {"epss_score": 0.00178, "epss_percentile": 0.39719}, "CVE-2024-32534": {"epss_score": 0.00133, "epss_percentile": 0.33715}, "CVE-2024-32535": {"epss_score": 0.00186, "epss_percentile": 0.40583}, "CVE-2024-32536": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-32538": {"epss_score": 0.00124, "epss_percentile": 0.32393}, "CVE-2024-32539": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-32540": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-32541": {"epss_score": 0.0017, "epss_percentile": 0.38676}, "CVE-2024-32542": {"epss_score": 0.0017, "epss_percentile": 0.38676}, "CVE-2024-32543": {"epss_score": 0.00195, "epss_percentile": 0.41652}, "CVE-2024-32544": {"epss_score": 0.00195, "epss_percentile": 0.41652}, "CVE-2024-32545": {"epss_score": 0.0017, "epss_percentile": 0.38676}, "CVE-2024-32546": {"epss_score": 0.0017, "epss_percentile": 0.38676}, "CVE-2024-32547": {"epss_score": 0.0017, "epss_percentile": 0.38676}, "CVE-2024-32548": {"epss_score": 0.00124, "epss_percentile": 0.32425}, "CVE-2024-32549": {"epss_score": 0.00234, "epss_percentile": 0.46166}, "CVE-2024-32550": {"epss_score": 0.00124, "epss_percentile": 0.32393}, "CVE-2024-32551": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2024-32552": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-32553": {"epss_score": 0.00202, "epss_percentile": 0.42404}, "CVE-2024-32554": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-32555": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-32556": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-32557": {"epss_score": 0.0012, "epss_percentile": 0.31731}, "CVE-2024-32558": {"epss_score": 0.00236, "epss_percentile": 0.46446}, "CVE-2024-32559": {"epss_score": 0.00305, "epss_percentile": 0.53368}, "CVE-2024-32560": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-32561": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-32562": {"epss_score": 0.00283, "epss_percentile": 0.51352}, "CVE-2024-32563": {"epss_score": 0.00274, "epss_percentile": 0.50565}, "CVE-2024-32564": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-32565": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-32566": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-32567": {"epss_score": 0.00232, "epss_percentile": 0.45912}, "CVE-2024-32568": {"epss_score": 0.01124, "epss_percentile": 0.77796}, "CVE-2024-32569": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-32570": {"epss_score": 0.00186, "epss_percentile": 0.40583}, "CVE-2024-32571": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-32572": {"epss_score": 0.00139, "epss_percentile": 0.34621}, "CVE-2024-32573": {"epss_score": 0.0015, "epss_percentile": 0.36104}, "CVE-2024-32574": {"epss_score": 0.00305, "epss_percentile": 0.53368}, "CVE-2024-32575": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-32576": {"epss_score": 0.00139, "epss_percentile": 0.34621}, "CVE-2024-32577": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-32578": {"epss_score": 0.01365, "epss_percentile": 0.79775}, "CVE-2024-32579": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-32580": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-32581": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-32582": {"epss_score": 0.00186, "epss_percentile": 0.40583}, "CVE-2024-32583": {"epss_score": 0.00149, "epss_percentile": 0.3599}, "CVE-2024-32584": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2024-32585": {"epss_score": 0.0017, "epss_percentile": 0.38676}, "CVE-2024-32586": {"epss_score": 0.00152, "epss_percentile": 0.36425}, "CVE-2024-32587": {"epss_score": 0.00186, "epss_percentile": 0.40583}, "CVE-2024-32588": {"epss_score": 0.01135, "epss_percentile": 0.77906}, "CVE-2024-32589": {"epss_score": 0.001, "epss_percentile": 0.28481}, "CVE-2024-32590": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-32591": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-32592": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-32593": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2024-32594": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-32595": {"epss_score": 0.00274, "epss_percentile": 0.50565}, "CVE-2024-32596": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-32597": {"epss_score": 0.00107, "epss_percentile": 0.29669}, "CVE-2024-32598": {"epss_score": 0.00118, "epss_percentile": 0.31481}, "CVE-2024-32599": {"epss_score": 0.0072, "epss_percentile": 0.71962}, "CVE-2024-32600": {"epss_score": 0.00692, "epss_percentile": 0.71301}, "CVE-2024-32601": {"epss_score": 0.00289, "epss_percentile": 0.5202}, "CVE-2024-32602": {"epss_score": 0.00431, "epss_percentile": 0.6206}, "CVE-2024-32603": {"epss_score": 0.00235, "epss_percentile": 0.46202}, "CVE-2024-32604": {"epss_score": 0.00077, "epss_percentile": 0.23522}, "CVE-2024-32605": {"epss_score": 0.00425, "epss_percentile": 0.61713}, "CVE-2024-32606": {"epss_score": 0.00065, "epss_percentile": 0.20515}, "CVE-2024-32607": {"epss_score": 0.00065, "epss_percentile": 0.20553}, "CVE-2024-32608": {"epss_score": 0.00634, "epss_percentile": 0.6979}, "CVE-2024-32609": {"epss_score": 0.00132, "epss_percentile": 0.33551}, "CVE-2024-32610": {"epss_score": 0.00052, "epss_percentile": 0.16369}, "CVE-2024-32611": {"epss_score": 0.00352, "epss_percentile": 0.57097}, "CVE-2024-32612": {"epss_score": 0.00074, "epss_percentile": 0.22682}, "CVE-2024-32613": {"epss_score": 0.00074, "epss_percentile": 0.22682}, "CVE-2024-32614": {"epss_score": 0.00392, "epss_percentile": 0.5967}, "CVE-2024-32615": {"epss_score": 0.00512, "epss_percentile": 0.65861}, "CVE-2024-32616": {"epss_score": 0.00077, "epss_percentile": 0.23468}, "CVE-2024-32617": {"epss_score": 0.00391, "epss_percentile": 0.59613}, "CVE-2024-32618": {"epss_score": 0.00095, "epss_percentile": 0.27174}, "CVE-2024-32619": {"epss_score": 0.00088, "epss_percentile": 0.25664}, "CVE-2024-32620": {"epss_score": 0.00071, "epss_percentile": 0.22173}, "CVE-2024-32621": {"epss_score": 0.00512, "epss_percentile": 0.65861}, "CVE-2024-32622": {"epss_score": 0.00278, "epss_percentile": 0.50905}, "CVE-2024-32623": {"epss_score": 0.00507, "epss_percentile": 0.65648}, "CVE-2024-32624": {"epss_score": 0.00403, "epss_percentile": 0.60379}, "CVE-2024-32625": {"epss_score": 0.00275, "epss_percentile": 0.50665}, "CVE-2024-32631": {"epss_score": 0.00346, "epss_percentile": 0.56634}, "CVE-2024-32632": {"epss_score": 0.00167, "epss_percentile": 0.38398}, "CVE-2024-32633": {"epss_score": 0.00135, "epss_percentile": 0.33937}, "CVE-2024-32634": {"epss_score": 0.00195, "epss_percentile": 0.41671}, "CVE-2024-32635": {"epss_score": 0.00092, "epss_percentile": 0.26586}, "CVE-2024-32636": {"epss_score": 0.00092, "epss_percentile": 0.26586}, "CVE-2024-32637": {"epss_score": 0.0004, "epss_percentile": 0.11917}, "CVE-2024-32638": {"epss_score": 0.00266, "epss_percentile": 0.49866}, "CVE-2024-32639": {"epss_score": 0.00119, "epss_percentile": 0.31676}, "CVE-2024-32640": {"epss_score": 0.93577, "epss_percentile": 0.9982}, "CVE-2024-32641": {"epss_score": 0.00691, "epss_percentile": 0.7127}, "CVE-2024-32642": {"epss_score": 0.00021, "epss_percentile": 0.04917}, "CVE-2024-32643": {"epss_score": 0.00045, "epss_percentile": 0.13945}, "CVE-2024-32644": {"epss_score": 0.0062, "epss_percentile": 0.69443}, "CVE-2024-32645": {"epss_score": 0.00589, "epss_percentile": 0.68537}, "CVE-2024-32646": {"epss_score": 0.00589, "epss_percentile": 0.68537}, "CVE-2024-32647": {"epss_score": 0.00505, "epss_percentile": 0.65554}, "CVE-2024-32648": {"epss_score": 0.00257, "epss_percentile": 0.4887}, "CVE-2024-32649": {"epss_score": 0.00685, "epss_percentile": 0.71133}, "CVE-2024-32650": {"epss_score": 0.0004, "epss_percentile": 0.12026}, "CVE-2024-32651": {"epss_score": 0.92464, "epss_percentile": 0.99716}, "CVE-2024-32652": {"epss_score": 0.00522, "epss_percentile": 0.66275}, "CVE-2024-32653": {"epss_score": 0.00068, "epss_percentile": 0.2142}, "CVE-2024-32655": {"epss_score": 0.02066, "epss_percentile": 0.83457}, "CVE-2024-32656": {"epss_score": 0.00068, "epss_percentile": 0.21311}, "CVE-2024-32657": {"epss_score": 0.00627, "epss_percentile": 0.69626}, "CVE-2024-32658": {"epss_score": 0.01726, "epss_percentile": 0.81958}, "CVE-2024-32659": {"epss_score": 0.00398, "epss_percentile": 0.60082}, "CVE-2024-32660": {"epss_score": 0.00415, "epss_percentile": 0.61159}, "CVE-2024-32661": {"epss_score": 0.0053, "epss_percentile": 0.66608}, "CVE-2024-32662": {"epss_score": 0.00331, "epss_percentile": 0.55524}, "CVE-2024-32663": {"epss_score": 0.00276, "epss_percentile": 0.50715}, "CVE-2024-32664": {"epss_score": 0.00326, "epss_percentile": 0.55039}, "CVE-2024-32666": {"epss_score": 0.00129, "epss_percentile": 0.33168}, "CVE-2024-32667": {"epss_score": 0.00096, "epss_percentile": 0.27277}, "CVE-2024-32668": {"epss_score": 0.00083, "epss_percentile": 0.24602}, "CVE-2024-32669": {"epss_score": 0.0023, "epss_percentile": 0.45718}, "CVE-2024-32670": {"epss_score": 0.00147, "epss_percentile": 0.35789}, "CVE-2024-32671": {"epss_score": 0.00207, "epss_percentile": 0.432}, "CVE-2024-32672": {"epss_score": 0.0068, "epss_percentile": 0.71035}, "CVE-2024-32673": {"epss_score": 0.00045, "epss_percentile": 0.13935}, "CVE-2024-32674": {"epss_score": 0.0025, "epss_percentile": 0.48135}, "CVE-2024-32675": {"epss_score": 0.00061, "epss_percentile": 0.19254}, "CVE-2024-32676": {"epss_score": 0.00246, "epss_percentile": 0.47758}, "CVE-2024-32677": {"epss_score": 0.00061, "epss_percentile": 0.19254}, "CVE-2024-32678": {"epss_score": 0.00084, "epss_percentile": 0.24897}, "CVE-2024-32679": {"epss_score": 0.00076, "epss_percentile": 0.23152}, "CVE-2024-32680": {"epss_score": 0.0248, "epss_percentile": 0.84871}, "CVE-2024-32681": {"epss_score": 0.00289, "epss_percentile": 0.52043}, "CVE-2024-32682": {"epss_score": 0.00267, "epss_percentile": 0.49985}, "CVE-2024-32683": {"epss_score": 0.0027, "epss_percentile": 0.50273}, "CVE-2024-32684": {"epss_score": 0.00159, "epss_percentile": 0.37384}, "CVE-2024-32685": {"epss_score": 0.00141, "epss_percentile": 0.34868}, "CVE-2024-32686": {"epss_score": 0.00366, "epss_percentile": 0.58053}, "CVE-2024-32687": {"epss_score": 0.00231, "epss_percentile": 0.45777}, "CVE-2024-32688": {"epss_score": 0.00338, "epss_percentile": 0.56145}, "CVE-2024-32689": {"epss_score": 0.00148, "epss_percentile": 0.35909}, "CVE-2024-32690": {"epss_score": 0.00124, "epss_percentile": 0.32425}, "CVE-2024-32691": {"epss_score": 0.00275, "epss_percentile": 0.50662}, "CVE-2024-32692": {"epss_score": 0.00292, "epss_percentile": 0.52273}, "CVE-2024-32693": {"epss_score": 0.00141, "epss_percentile": 0.34913}, "CVE-2024-32694": {"epss_score": 0.00305, "epss_percentile": 0.53368}, "CVE-2024-32695": {"epss_score": 0.0017, "epss_percentile": 0.38676}, "CVE-2024-32696": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-32697": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-32698": {"epss_score": 0.00126, "epss_percentile": 0.32686}, "CVE-2024-32699": {"epss_score": 0.00077, "epss_percentile": 0.23521}, "CVE-2024-32700": {"epss_score": 0.61692, "epss_percentile": 0.98259}, "CVE-2024-32701": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-32702": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-32703": {"epss_score": 0.00284, "epss_percentile": 0.5142}, "CVE-2024-32704": {"epss_score": 0.00208, "epss_percentile": 0.43242}, "CVE-2024-32705": {"epss_score": 0.00402, "epss_percentile": 0.60295}, "CVE-2024-32706": {"epss_score": 0.00143, "epss_percentile": 0.35193}, "CVE-2024-32707": {"epss_score": 0.00062, "epss_percentile": 0.19628}, "CVE-2024-32708": {"epss_score": 0.00115, "epss_percentile": 0.30925}, "CVE-2024-32709": {"epss_score": 0.89505, "epss_percentile": 0.9953}, "CVE-2024-32710": {"epss_score": 0.00166, "epss_percentile": 0.3825}, "CVE-2024-32711": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-32712": {"epss_score": 0.0028, "epss_percentile": 0.51038}, "CVE-2024-32713": {"epss_score": 0.00067, "epss_percentile": 0.2116}, "CVE-2024-32714": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-32715": {"epss_score": 0.00103, "epss_percentile": 0.28983}, "CVE-2024-32716": {"epss_score": 0.00175, "epss_percentile": 0.39269}, "CVE-2024-32717": {"epss_score": 0.00446, "epss_percentile": 0.62905}, "CVE-2024-32718": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2024-32719": {"epss_score": 0.00205, "epss_percentile": 0.42711}, "CVE-2024-32720": {"epss_score": 0.0022, "epss_percentile": 0.44595}, "CVE-2024-32721": {"epss_score": 0.00286, "epss_percentile": 0.51746}, "CVE-2024-32722": {"epss_score": 0.00062, "epss_percentile": 0.19628}, "CVE-2024-32723": {"epss_score": 0.00062, "epss_percentile": 0.19628}, "CVE-2024-32724": {"epss_score": 0.00264, "epss_percentile": 0.49701}, "CVE-2024-32725": {"epss_score": 0.00133, "epss_percentile": 0.33736}, "CVE-2024-32726": {"epss_score": 0.00484, "epss_percentile": 0.64646}, "CVE-2024-32727": {"epss_score": 0.00133, "epss_percentile": 0.33736}, "CVE-2024-32728": {"epss_score": 0.00076, "epss_percentile": 0.23213}, "CVE-2024-32730": {"epss_score": 0.00115, "epss_percentile": 0.30962}, "CVE-2024-32731": {"epss_score": 0.00065, "epss_percentile": 0.20539}, "CVE-2024-32732": {"epss_score": 0.00111, "epss_percentile": 0.30324}, "CVE-2024-32733": {"epss_score": 0.00117, "epss_percentile": 0.31304}, "CVE-2024-32735": {"epss_score": 0.74678, "epss_percentile": 0.98812}, "CVE-2024-32736": {"epss_score": 0.61869, "epss_percentile": 0.98265}, "CVE-2024-32737": {"epss_score": 0.37786, "epss_percentile": 0.97069}, "CVE-2024-32738": {"epss_score": 0.499, "epss_percentile": 0.9771}, "CVE-2024-32739": {"epss_score": 0.61869, "epss_percentile": 0.98265}, "CVE-2024-32740": {"epss_score": 0.00857, "epss_percentile": 0.74493}, "CVE-2024-32741": {"epss_score": 0.00739, "epss_percentile": 0.72391}, "CVE-2024-32742": {"epss_score": 0.00136, "epss_percentile": 0.34148}, "CVE-2024-32743": {"epss_score": 0.00094, "epss_percentile": 0.26958}, "CVE-2024-32744": {"epss_score": 0.00121, "epss_percentile": 0.31994}, "CVE-2024-32745": {"epss_score": 0.00063, "epss_percentile": 0.19995}, "CVE-2024-32746": {"epss_score": 0.00073, "epss_percentile": 0.22607}, "CVE-2024-32752": {"epss_score": 0.00212, "epss_percentile": 0.43732}, "CVE-2024-32753": {"epss_score": 0.00657, "epss_percentile": 0.70462}, "CVE-2024-32754": {"epss_score": 0.00054, "epss_percentile": 0.1729}, "CVE-2024-32755": {"epss_score": 0.00129, "epss_percentile": 0.33165}, "CVE-2024-32756": {"epss_score": 0.00089, "epss_percentile": 0.25984}, "CVE-2024-32757": {"epss_score": 0.00115, "epss_percentile": 0.30978}, "CVE-2024-32758": {"epss_score": 0.00124, "epss_percentile": 0.32357}, "CVE-2024-32759": {"epss_score": 0.00135, "epss_percentile": 0.34003}, "CVE-2024-32760": {"epss_score": 0.00483, "epss_percentile": 0.64613}, "CVE-2024-32761": {"epss_score": 0.00263, "epss_percentile": 0.49409}, "CVE-2024-32762": {"epss_score": 0.00606, "epss_percentile": 0.69016}, "CVE-2024-32763": {"epss_score": 0.0066, "epss_percentile": 0.7054}, "CVE-2024-32764": {"epss_score": 0.00191, "epss_percentile": 0.4117}, "CVE-2024-32765": {"epss_score": 0.00032, "epss_percentile": 0.09094}, "CVE-2024-32766": {"epss_score": 0.01986, "epss_percentile": 0.8316}, "CVE-2024-32767": {"epss_score": 0.00116, "epss_percentile": 0.31094}, "CVE-2024-32768": {"epss_score": 0.00116, "epss_percentile": 0.31094}, "CVE-2024-32769": {"epss_score": 0.00116, "epss_percentile": 0.31094}, "CVE-2024-32770": {"epss_score": 0.00116, "epss_percentile": 0.31094}, "CVE-2024-32771": {"epss_score": 0.00083, "epss_percentile": 0.24757}, "CVE-2024-32772": {"epss_score": 0.00179, "epss_percentile": 0.39781}, "CVE-2024-32773": {"epss_score": 0.00076, "epss_percentile": 0.23213}, "CVE-2024-32774": {"epss_score": 0.00369, "epss_percentile": 0.5824}, "CVE-2024-32775": {"epss_score": 0.00082, "epss_percentile": 0.24538}, "CVE-2024-32776": {"epss_score": 0.00195, "epss_percentile": 0.41686}, "CVE-2024-32777": {"epss_score": 0.00482, "epss_percentile": 0.64551}, "CVE-2024-32778": {"epss_score": 0.00164, "epss_percentile": 0.37917}, "CVE-2024-32779": {"epss_score": 0.00242, "epss_percentile": 0.47397}, "CVE-2024-32780": {"epss_score": 0.00348, "epss_percentile": 0.56818}, "CVE-2024-32781": {"epss_score": 0.00348, "epss_percentile": 0.56818}, "CVE-2024-32782": {"epss_score": 0.03747, "epss_percentile": 0.87665}, "CVE-2024-32783": {"epss_score": 0.00113, "epss_percentile": 0.306}, "CVE-2024-32784": {"epss_score": 0.00133, "epss_percentile": 0.33736}, "CVE-2024-32785": {"epss_score": 0.00126, "epss_percentile": 0.32754}, "CVE-2024-32786": {"epss_score": 0.00141, "epss_percentile": 0.3482}, "CVE-2024-32787": {"epss_score": 0.00113, "epss_percentile": 0.306}, "CVE-2024-32788": {"epss_score": 0.00175, "epss_percentile": 0.39269}, "CVE-2024-32789": {"epss_score": 0.00062, "epss_percentile": 0.19597}, "CVE-2024-32790": {"epss_score": 0.00274, "epss_percentile": 0.50546}, "CVE-2024-32791": {"epss_score": 0.00085, "epss_percentile": 0.25031}, "CVE-2024-32792": {"epss_score": 0.00119, "epss_percentile": 0.31556}, "CVE-2024-32793": {"epss_score": 0.00104, "epss_percentile": 0.29242}, "CVE-2024-32794": {"epss_score": 0.0006, "epss_percentile": 0.19136}, "CVE-2024-32795": {"epss_score": 0.0007, "epss_percentile": 0.21758}, "CVE-2024-32796": {"epss_score": 0.00163, "epss_percentile": 0.3781}, "CVE-2024-32797": {"epss_score": 0.00081, "epss_percentile": 0.24341}, "CVE-2024-32798": {"epss_score": 0.0024, "epss_percentile": 0.47183}, "CVE-2024-32799": {"epss_score": 0.0026, "epss_percentile": 0.49196}, "CVE-2024-32800": {"epss_score": 0.00253, "epss_percentile": 0.48486}, "CVE-2024-32801": {"epss_score": 0.00062, "epss_percentile": 0.19628}, "CVE-2024-32802": {"epss_score": 0.00206, "epss_percentile": 0.42925}, "CVE-2024-32803": {"epss_score": 0.00066, "epss_percentile": 0.20732}, "CVE-2024-32804": {"epss_score": 0.00109, "epss_percentile": 0.29944}, "CVE-2024-32805": {"epss_score": 0.00096, "epss_percentile": 0.27377}, "CVE-2024-32806": {"epss_score": 0.0007, "epss_percentile": 0.21758}, "CVE-2024-32807": {"epss_score": 0.00498, "epss_percentile": 0.65245}, "CVE-2024-32808": {"epss_score": 0.00043, "epss_percentile": 0.13173}, "CVE-2024-32809": {"epss_score": 0.01584, "epss_percentile": 0.81155}, "CVE-2024-32810": {"epss_score": 0.00077, "epss_percentile": 0.23352}, "CVE-2024-32811": {"epss_score": 0.00274, "epss_percentile": 0.50513}, "CVE-2024-32812": {"epss_score": 0.00099, "epss_percentile": 0.28394}, "CVE-2024-32813": {"epss_score": 0.00242, "epss_percentile": 0.47397}, "CVE-2024-32814": {"epss_score": 0.00133, "epss_percentile": 0.33736}, "CVE-2024-32815": {"epss_score": 0.00068, "epss_percentile": 0.21363}, "CVE-2024-32816": {"epss_score": 0.0053, "epss_percentile": 0.66635}, "CVE-2024-32817": {"epss_score": 0.00092, "epss_percentile": 0.26571}, "CVE-2024-32818": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-32819": {"epss_score": 0.00078, "epss_percentile": 0.23736}, "CVE-2024-32820": {"epss_score": 0.00133, "epss_percentile": 0.33736}, "CVE-2024-32821": {"epss_score": 0.00109, "epss_percentile": 0.29944}, "CVE-2024-32822": {"epss_score": 0.00148, "epss_percentile": 0.35909}, "CVE-2024-32823": {"epss_score": 0.00049, "epss_percentile": 0.15561}, "CVE-2024-32824": {"epss_score": 0.00158, "epss_percentile": 0.37285}, "CVE-2024-32825": {"epss_score": 0.00295, "epss_percentile": 0.52511}, "CVE-2024-32826": {"epss_score": 0.00159, "epss_percentile": 0.37384}, "CVE-2024-32827": {"epss_score": 0.00113, "epss_percentile": 0.3063}, "CVE-2024-32828": {"epss_score": 0.00134, "epss_percentile": 0.33864}, "CVE-2024-32829": {"epss_score": 0.00231, "epss_percentile": 0.45777}, "CVE-2024-32830": {"epss_score": 0.01314, "epss_percentile": 0.79396}, "CVE-2024-32831": {"epss_score": 0.00089, "epss_percentile": 0.2583}, "CVE-2024-32832": {"epss_score": 0.00281, "epss_percentile": 0.51198}, "CVE-2024-32833": {"epss_score": 0.00068, "epss_percentile": 0.21363}, "CVE-2024-32834": {"epss_score": 0.00062, "epss_percentile": 0.19628}, "CVE-2024-32835": {"epss_score": 0.00112, "epss_percentile": 0.30574}, "CVE-2024-32836": {"epss_score": 0.00392, "epss_percentile": 0.59693}, "CVE-2024-32838": {"epss_score": 0.00133, "epss_percentile": 0.33691}, "CVE-2024-32839": {"epss_score": 0.05183, "epss_percentile": 0.89585}, "CVE-2024-32840": {"epss_score": 0.50062, "epss_percentile": 0.97718}, "CVE-2024-32841": {"epss_score": 0.05183, "epss_percentile": 0.89585}, "CVE-2024-32842": {"epss_score": 0.0847, "epss_percentile": 0.92069}, "CVE-2024-32843": {"epss_score": 0.0847, "epss_percentile": 0.92069}, "CVE-2024-32844": {"epss_score": 0.05183, "epss_percentile": 0.89585}, "CVE-2024-32845": {"epss_score": 0.32185, "epss_percentile": 0.96677}, "CVE-2024-32846": {"epss_score": 0.0847, "epss_percentile": 0.92069}, "CVE-2024-32847": {"epss_score": 0.05183, "epss_percentile": 0.89585}, "CVE-2024-32848": {"epss_score": 0.42092, "epss_percentile": 0.97312}, "CVE-2024-32849": {"epss_score": 0.00126, "epss_percentile": 0.32729}, "CVE-2024-32850": {"epss_score": 0.02256, "epss_percentile": 0.8417}, "CVE-2024-32852": {"epss_score": 0.00233, "epss_percentile": 0.46063}, "CVE-2024-32853": {"epss_score": 0.00088, "epss_percentile": 0.2575}, "CVE-2024-32854": {"epss_score": 0.00074, "epss_percentile": 0.22837}, "CVE-2024-32855": {"epss_score": 0.0006, "epss_percentile": 0.19197}, "CVE-2024-32856": {"epss_score": 0.00034, "epss_percentile": 0.09598}, "CVE-2024-32857": {"epss_score": 0.00102, "epss_percentile": 0.28893}, "CVE-2024-32858": {"epss_score": 0.00044, "epss_percentile": 0.13671}, "CVE-2024-32859": {"epss_score": 0.00044, "epss_percentile": 0.13671}, "CVE-2024-32860": {"epss_score": 0.00044, "epss_percentile": 0.13671}, "CVE-2024-32861": {"epss_score": 0.00068, "epss_percentile": 0.21324}, "CVE-2024-32862": {"epss_score": 0.00268, "epss_percentile": 0.50023}, "CVE-2024-32863": {"epss_score": 0.00415, "epss_percentile": 0.6115}, "CVE-2024-32864": {"epss_score": 0.0021, "epss_percentile": 0.43445}, "CVE-2024-32865": {"epss_score": 0.00181, "epss_percentile": 0.39993}, "CVE-2024-32866": {"epss_score": 0.00142, "epss_percentile": 0.3498}, "CVE-2024-32867": {"epss_score": 0.00625, "epss_percentile": 0.69588}, "CVE-2024-32868": {"epss_score": 0.00141, "epss_percentile": 0.34941}, "CVE-2024-32869": {"epss_score": 0.01329, "epss_percentile": 0.79505}, "CVE-2024-32870": {"epss_score": 0.17512, "epss_percentile": 0.94859}, "CVE-2024-32871": {"epss_score": 8e-05, "epss_percentile": 0.0056}, "CVE-2024-32872": {"epss_score": 0.00068, "epss_percentile": 0.21383}, "CVE-2024-32873": {"epss_score": 0.00174, "epss_percentile": 0.39193}, "CVE-2024-32874": {"epss_score": 0.00129, "epss_percentile": 0.33119}, "CVE-2024-32875": {"epss_score": 0.00211, "epss_percentile": 0.43621}, "CVE-2024-32876": {"epss_score": 0.00047, "epss_percentile": 0.14695}, "CVE-2024-32877": {"epss_score": 0.03086, "epss_percentile": 0.86385}, "CVE-2024-32878": {"epss_score": 0.00205, "epss_percentile": 0.42761}, "CVE-2024-32879": {"epss_score": 0.00189, "epss_percentile": 0.40994}, "CVE-2024-32880": {"epss_score": 0.03976, "epss_percentile": 0.88048}, "CVE-2024-32881": {"epss_score": 0.00114, "epss_percentile": 0.30835}, "CVE-2024-32882": {"epss_score": 0.00083, "epss_percentile": 0.24695}, "CVE-2024-32883": {"epss_score": 0.00039, "epss_percentile": 0.11584}, "CVE-2024-32884": {"epss_score": 0.00066, "epss_percentile": 0.20937}, "CVE-2024-32886": {"epss_score": 0.001, "epss_percentile": 0.285}, "CVE-2024-32887": {"epss_score": 0.00279, "epss_percentile": 0.50937}, "CVE-2024-32888": {"epss_score": 0.00479, "epss_percentile": 0.6444}, "CVE-2024-32890": {"epss_score": 0.00155, "epss_percentile": 0.36811}, "CVE-2024-32891": {"epss_score": 0.00022, "epss_percentile": 0.04998}, "CVE-2024-32892": {"epss_score": 0.00028, "epss_percentile": 0.07327}, "CVE-2024-32893": {"epss_score": 0.00092, "epss_percentile": 0.26437}, "CVE-2024-32894": {"epss_score": 0.00664, "epss_percentile": 0.70641}, "CVE-2024-32895": {"epss_score": 0.00068, "epss_percentile": 0.21405}, "CVE-2024-32896": {"epss_score": 0.00132, "epss_percentile": 0.33513}, "CVE-2024-32897": {"epss_score": 0.00191, "epss_percentile": 0.41144}, "CVE-2024-32898": {"epss_score": 0.00036, "epss_percentile": 0.10365}, "CVE-2024-32899": {"epss_score": 0.00026, "epss_percentile": 0.06463}, "CVE-2024-32900": {"epss_score": 0.00057, "epss_percentile": 0.18009}, "CVE-2024-32901": {"epss_score": 0.00026, "epss_percentile": 0.06414}, "CVE-2024-32902": {"epss_score": 0.00084, "epss_percentile": 0.24835}, "CVE-2024-32903": {"epss_score": 0.00022, "epss_percentile": 0.0499}, "CVE-2024-32904": {"epss_score": 0.00036, "epss_percentile": 0.10365}, "CVE-2024-32905": {"epss_score": 0.04361, "epss_percentile": 0.88596}, "CVE-2024-32906": {"epss_score": 0.00047, "epss_percentile": 0.14756}, "CVE-2024-32907": {"epss_score": 0.00047, "epss_percentile": 0.14641}, "CVE-2024-32908": {"epss_score": 5e-05, "epss_percentile": 0.0023}, "CVE-2024-32909": {"epss_score": 0.00098, "epss_percentile": 0.27816}, "CVE-2024-32910": {"epss_score": 0.00041, "epss_percentile": 0.12395}, "CVE-2024-32911": {"epss_score": 0.019, "epss_percentile": 0.8277}, "CVE-2024-32912": {"epss_score": 0.0005, "epss_percentile": 0.15929}, "CVE-2024-32913": {"epss_score": 0.03344, "epss_percentile": 0.86949}, "CVE-2024-32914": {"epss_score": 0.00042, "epss_percentile": 0.12911}, "CVE-2024-32915": {"epss_score": 0.00118, "epss_percentile": 0.31446}, "CVE-2024-32916": {"epss_score": 0.00034, "epss_percentile": 0.0953}, "CVE-2024-32917": {"epss_score": 0.00044, "epss_percentile": 0.13436}, "CVE-2024-32918": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2024-32919": {"epss_score": 0.0004, "epss_percentile": 0.1192}, "CVE-2024-32920": {"epss_score": 0.00056, "epss_percentile": 0.17868}, "CVE-2024-32921": {"epss_score": 0.00039, "epss_percentile": 0.11702}, "CVE-2024-32922": {"epss_score": 0.00052, "epss_percentile": 0.16406}, "CVE-2024-32923": {"epss_score": 0.01267, "epss_percentile": 0.79022}, "CVE-2024-32924": {"epss_score": 0.04858, "epss_percentile": 0.8922}, "CVE-2024-32925": {"epss_score": 0.01914, "epss_percentile": 0.8285}, "CVE-2024-32926": {"epss_score": 0.00041, "epss_percentile": 0.12395}, "CVE-2024-32927": {"epss_score": 0.00031, "epss_percentile": 0.08566}, "CVE-2024-32928": {"epss_score": 0.00083, "epss_percentile": 0.24594}, "CVE-2024-32929": {"epss_score": 0.00207, "epss_percentile": 0.43164}, "CVE-2024-32930": {"epss_score": 0.00041, "epss_percentile": 0.12395}, "CVE-2024-32931": {"epss_score": 0.00527, "epss_percentile": 0.6647}, "CVE-2024-32932": {"epss_score": 0.00118, "epss_percentile": 0.31398}, "CVE-2024-32936": {"epss_score": 0.00024, "epss_percentile": 0.05884}, "CVE-2024-32937": {"epss_score": 0.06084, "epss_percentile": 0.90464}, "CVE-2024-32938": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-32939": {"epss_score": 0.00206, "epss_percentile": 0.43045}, "CVE-2024-32940": {"epss_score": 0.00191, "epss_percentile": 0.41143}, "CVE-2024-32941": {"epss_score": 0.0003, "epss_percentile": 0.0809}, "CVE-2024-32942": {"epss_score": 0.00018, "epss_percentile": 0.03848}, "CVE-2024-32943": {"epss_score": 0.00288, "epss_percentile": 0.51935}, "CVE-2024-32944": {"epss_score": 0.0004, "epss_percentile": 0.12076}, "CVE-2024-32945": {"epss_score": 0.00334, "epss_percentile": 0.55715}, "CVE-2024-32946": {"epss_score": 0.00146, "epss_percentile": 0.35604}, "CVE-2024-32947": {"epss_score": 0.0007, "epss_percentile": 0.21758}, "CVE-2024-32948": {"epss_score": 0.00143, "epss_percentile": 0.35185}, "CVE-2024-32950": {"epss_score": 0.00152, "epss_percentile": 0.36396}, "CVE-2024-32951": {"epss_score": 0.00055, "epss_percentile": 0.17469}, "CVE-2024-32952": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-32953": {"epss_score": 0.0053, "epss_percentile": 0.66635}, "CVE-2024-32954": {"epss_score": 0.00218, "epss_percentile": 0.44425}, "CVE-2024-32955": {"epss_score": 0.00078, "epss_percentile": 0.23736}, "CVE-2024-32956": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-32957": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2024-32958": {"epss_score": 0.00062, "epss_percentile": 0.19597}, "CVE-2024-32959": {"epss_score": 0.0046, "epss_percentile": 0.63518}, "CVE-2024-32960": {"epss_score": 0.00422, "epss_percentile": 0.61569}, "CVE-2024-32961": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2024-32962": {"epss_score": 0.12728, "epss_percentile": 0.93759}, "CVE-2024-32963": {"epss_score": 0.00388, "epss_percentile": 0.59386}, "CVE-2024-32964": {"epss_score": 0.52422, "epss_percentile": 0.97825}, "CVE-2024-32965": {"epss_score": 0.00163, "epss_percentile": 0.37772}, "CVE-2024-32966": {"epss_score": 0.0007, "epss_percentile": 0.21982}, "CVE-2024-32967": {"epss_score": 0.00386, "epss_percentile": 0.59264}, "CVE-2024-32969": {"epss_score": 0.00197, "epss_percentile": 0.41859}, "CVE-2024-32970": {"epss_score": 0.00384, "epss_percentile": 0.59131}, "CVE-2024-32971": {"epss_score": 0.00213, "epss_percentile": 0.4384}, "CVE-2024-32972": {"epss_score": 0.0059, "epss_percentile": 0.68564}, "CVE-2024-32973": {"epss_score": 0.00051, "epss_percentile": 0.16106}, "CVE-2024-32974": {"epss_score": 0.00028, "epss_percentile": 0.07532}, "CVE-2024-32975": {"epss_score": 0.00028, "epss_percentile": 0.07492}, "CVE-2024-32976": {"epss_score": 0.00028, "epss_percentile": 0.07492}, "CVE-2024-32977": {"epss_score": 0.0012, "epss_percentile": 0.31758}, "CVE-2024-32978": {"epss_score": 0.00132, "epss_percentile": 0.33584}, "CVE-2024-32979": {"epss_score": 0.00201, "epss_percentile": 0.4235}, "CVE-2024-32980": {"epss_score": 0.00246, "epss_percentile": 0.47806}, "CVE-2024-32981": {"epss_score": 0.0105, "epss_percentile": 0.77072}, "CVE-2024-32982": {"epss_score": 0.00308, "epss_percentile": 0.53596}, "CVE-2024-32983": {"epss_score": 0.0028, "epss_percentile": 0.51037}, "CVE-2024-32984": {"epss_score": 0.00159, "epss_percentile": 0.37393}, "CVE-2024-32985": {"epss_score": 0.00273, "epss_percentile": 0.50477}, "CVE-2024-32986": {"epss_score": 0.00163, "epss_percentile": 0.37862}, "CVE-2024-32987": {"epss_score": 0.05555, "epss_percentile": 0.89988}, "CVE-2024-32988": {"epss_score": 0.00317, "epss_percentile": 0.54334}, "CVE-2024-32989": {"epss_score": 0.00055, "epss_percentile": 0.17437}, "CVE-2024-32990": {"epss_score": 0.00105, "epss_percentile": 0.293}, "CVE-2024-32991": {"epss_score": 0.00225, "epss_percentile": 0.45161}, "CVE-2024-32992": {"epss_score": 0.00156, "epss_percentile": 0.36932}, "CVE-2024-32993": {"epss_score": 0.0002, "epss_percentile": 0.04629}, "CVE-2024-32995": {"epss_score": 0.00043, "epss_percentile": 0.13073}, "CVE-2024-32996": {"epss_score": 0.00044, "epss_percentile": 0.13397}, "CVE-2024-32997": {"epss_score": 0.00034, "epss_percentile": 0.0978}, "CVE-2024-32998": {"epss_score": 0.00029, "epss_percentile": 0.07763}, "CVE-2024-32999": {"epss_score": 0.0003, "epss_percentile": 0.08291}, "CVE-2024-33000": {"epss_score": 0.00061, "epss_percentile": 0.19253}, "CVE-2024-33001": {"epss_score": 0.00418, "epss_percentile": 0.61291}, "CVE-2024-33002": {"epss_score": 0.00182, "epss_percentile": 0.40155}, "CVE-2024-33003": {"epss_score": 0.00747, "epss_percentile": 0.72566}, "CVE-2024-33004": {"epss_score": 0.00061, "epss_percentile": 0.19472}, "CVE-2024-33005": {"epss_score": 0.00085, "epss_percentile": 0.25192}, "CVE-2024-33006": {"epss_score": 0.00534, "epss_percentile": 0.66782}, "CVE-2024-33007": {"epss_score": 0.00137, "epss_percentile": 0.34322}, "CVE-2024-33008": {"epss_score": 0.00096, "epss_percentile": 0.27315}, "CVE-2024-33009": {"epss_score": 0.00084, "epss_percentile": 0.24865}, "CVE-2024-33010": {"epss_score": 0.00399, "epss_percentile": 0.60135}, "CVE-2024-33011": {"epss_score": 0.00522, "epss_percentile": 0.66254}, "CVE-2024-33012": {"epss_score": 0.00399, "epss_percentile": 0.60135}, "CVE-2024-33013": {"epss_score": 0.00407, "epss_percentile": 0.60595}, "CVE-2024-33014": {"epss_score": 0.00399, "epss_percentile": 0.60135}, "CVE-2024-33015": {"epss_score": 0.00522, "epss_percentile": 0.66254}, "CVE-2024-33016": {"epss_score": 0.00085, "epss_percentile": 0.25136}, "CVE-2024-33018": {"epss_score": 0.00986, "epss_percentile": 0.76332}, "CVE-2024-33019": {"epss_score": 0.00522, "epss_percentile": 0.66254}, "CVE-2024-33020": {"epss_score": 0.00407, "epss_percentile": 0.60595}, "CVE-2024-33021": {"epss_score": 0.00152, "epss_percentile": 0.3646}, "CVE-2024-33022": {"epss_score": 0.00199, "epss_percentile": 0.42136}, "CVE-2024-33023": {"epss_score": 0.00152, "epss_percentile": 0.3646}, "CVE-2024-33024": {"epss_score": 0.00527, "epss_percentile": 0.66442}, "CVE-2024-33025": {"epss_score": 0.00399, "epss_percentile": 0.60135}, "CVE-2024-33026": {"epss_score": 0.00399, "epss_percentile": 0.60135}, "CVE-2024-33027": {"epss_score": 0.00169, "epss_percentile": 0.38534}, "CVE-2024-33028": {"epss_score": 0.00199, "epss_percentile": 0.42136}, "CVE-2024-33029": {"epss_score": 0.00105, "epss_percentile": 0.2932}, "CVE-2024-33030": {"epss_score": 0.00124, "epss_percentile": 0.32456}, "CVE-2024-33031": {"epss_score": 0.00109, "epss_percentile": 0.30004}, "CVE-2024-33032": {"epss_score": 0.00109, "epss_percentile": 0.30004}, "CVE-2024-33033": {"epss_score": 0.00097, "epss_percentile": 0.27552}, "CVE-2024-33034": {"epss_score": 0.00152, "epss_percentile": 0.3646}, "CVE-2024-33035": {"epss_score": 0.00102, "epss_percentile": 0.28772}, "CVE-2024-33036": {"epss_score": 0.00019, "epss_percentile": 0.0419}, "CVE-2024-33037": {"epss_score": 0.00027, "epss_percentile": 0.06751}, "CVE-2024-33038": {"epss_score": 0.00106, "epss_percentile": 0.29467}, "CVE-2024-33039": {"epss_score": 0.00029, "epss_percentile": 0.07937}, "CVE-2024-33040": {"epss_score": 0.0002, "epss_percentile": 0.04547}, "CVE-2024-33041": {"epss_score": 0.00027, "epss_percentile": 0.06836}, "CVE-2024-33042": {"epss_score": 0.00139, "epss_percentile": 0.34533}, "CVE-2024-33043": {"epss_score": 0.00107, "epss_percentile": 0.29645}, "CVE-2024-33044": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-33045": {"epss_score": 0.00106, "epss_percentile": 0.29467}, "CVE-2024-33047": {"epss_score": 0.00082, "epss_percentile": 0.24448}, "CVE-2024-33048": {"epss_score": 0.00292, "epss_percentile": 0.52248}, "CVE-2024-33049": {"epss_score": 0.00216, "epss_percentile": 0.44231}, "CVE-2024-33050": {"epss_score": 0.00292, "epss_percentile": 0.52248}, "CVE-2024-33051": {"epss_score": 0.00214, "epss_percentile": 0.43976}, "CVE-2024-33052": {"epss_score": 0.00106, "epss_percentile": 0.29467}, "CVE-2024-33053": {"epss_score": 0.00029, "epss_percentile": 0.07937}, "CVE-2024-33054": {"epss_score": 0.00393, "epss_percentile": 0.59732}, "CVE-2024-33055": {"epss_score": 0.00027, "epss_percentile": 0.06836}, "CVE-2024-33056": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-33057": {"epss_score": 0.00292, "epss_percentile": 0.52248}, "CVE-2024-33058": {"epss_score": 0.00015, "epss_percentile": 0.0239}, "CVE-2024-33059": {"epss_score": 0.00027, "epss_percentile": 0.06836}, "CVE-2024-33060": {"epss_score": 0.00195, "epss_percentile": 0.41675}, "CVE-2024-33061": {"epss_score": 0.00032, "epss_percentile": 0.08825}, "CVE-2024-33063": {"epss_score": 0.00244, "epss_percentile": 0.47552}, "CVE-2024-33064": {"epss_score": 0.00089, "epss_percentile": 0.25968}, "CVE-2024-33065": {"epss_score": 0.00061, "epss_percentile": 0.19298}, "CVE-2024-33066": {"epss_score": 0.00247, "epss_percentile": 0.47843}, "CVE-2024-33067": {"epss_score": 0.00032, "epss_percentile": 0.08825}, "CVE-2024-33068": {"epss_score": 0.00736, "epss_percentile": 0.72307}, "CVE-2024-33069": {"epss_score": 0.00169, "epss_percentile": 0.38545}, "CVE-2024-33070": {"epss_score": 0.00222, "epss_percentile": 0.44802}, "CVE-2024-33071": {"epss_score": 0.00222, "epss_percentile": 0.44802}, "CVE-2024-33073": {"epss_score": 0.00089, "epss_percentile": 0.25968}, "CVE-2024-33078": {"epss_score": 0.01339, "epss_percentile": 0.79573}, "CVE-2024-33101": {"epss_score": 0.00706, "epss_percentile": 0.71622}, "CVE-2024-33102": {"epss_score": 0.00921, "epss_percentile": 0.75483}, "CVE-2024-33103": {"epss_score": 0.00132, "epss_percentile": 0.33547}, "CVE-2024-33109": {"epss_score": 0.00192, "epss_percentile": 0.41352}, "CVE-2024-33110": {"epss_score": 0.00123, "epss_percentile": 0.32331}, "CVE-2024-33111": {"epss_score": 0.00976, "epss_percentile": 0.76205}, "CVE-2024-33112": {"epss_score": 0.01731, "epss_percentile": 0.81993}, "CVE-2024-33113": {"epss_score": 0.52857, "epss_percentile": 0.97844}, "CVE-2024-33117": {"epss_score": 0.00103, "epss_percentile": 0.2907}, "CVE-2024-33118": {"epss_score": 0.00176, "epss_percentile": 0.39458}, "CVE-2024-33120": {"epss_score": 0.00268, "epss_percentile": 0.50085}, "CVE-2024-33121": {"epss_score": 0.00101, "epss_percentile": 0.28566}, "CVE-2024-33122": {"epss_score": 0.00101, "epss_percentile": 0.28566}, "CVE-2024-33124": {"epss_score": 0.0016, "epss_percentile": 0.37491}, "CVE-2024-33139": {"epss_score": 0.00153, "epss_percentile": 0.36603}, "CVE-2024-33144": {"epss_score": 0.0016, "epss_percentile": 0.37501}, "CVE-2024-33146": {"epss_score": 0.00153, "epss_percentile": 0.36603}, "CVE-2024-33147": {"epss_score": 0.0016, "epss_percentile": 0.37501}, "CVE-2024-33148": {"epss_score": 0.001, "epss_percentile": 0.28558}, "CVE-2024-33149": {"epss_score": 0.0016, "epss_percentile": 0.37491}, "CVE-2024-33153": {"epss_score": 0.0016, "epss_percentile": 0.37491}, "CVE-2024-33155": {"epss_score": 0.0016, "epss_percentile": 0.37491}, "CVE-2024-33161": {"epss_score": 0.00068, "epss_percentile": 0.21248}, "CVE-2024-33164": {"epss_score": 0.00158, "epss_percentile": 0.37179}, "CVE-2024-33180": {"epss_score": 0.00448, "epss_percentile": 0.63015}, "CVE-2024-33181": {"epss_score": 0.00224, "epss_percentile": 0.45002}, "CVE-2024-33182": {"epss_score": 0.00318, "epss_percentile": 0.54432}, "CVE-2024-33209": {"epss_score": 0.04691, "epss_percentile": 0.89012}, "CVE-2024-33210": {"epss_score": 0.02165, "epss_percentile": 0.83843}, "CVE-2024-33211": {"epss_score": 0.00082, "epss_percentile": 0.24569}, "CVE-2024-33212": {"epss_score": 0.00062, "epss_percentile": 0.1977}, "CVE-2024-33213": {"epss_score": 0.0004, "epss_percentile": 0.11951}, "CVE-2024-33214": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2024-33215": {"epss_score": 0.00131, "epss_percentile": 0.33495}, "CVE-2024-33217": {"epss_score": 0.00114, "epss_percentile": 0.30774}, "CVE-2024-33218": {"epss_score": 0.00176, "epss_percentile": 0.39404}, "CVE-2024-33219": {"epss_score": 0.00162, "epss_percentile": 0.37629}, "CVE-2024-33220": {"epss_score": 0.0058, "epss_percentile": 0.68257}, "CVE-2024-33221": {"epss_score": 0.00162, "epss_percentile": 0.37629}, "CVE-2024-33222": {"epss_score": 0.0017, "epss_percentile": 0.38679}, "CVE-2024-33223": {"epss_score": 0.00431, "epss_percentile": 0.62087}, "CVE-2024-33224": {"epss_score": 0.00144, "epss_percentile": 0.35314}, "CVE-2024-33225": {"epss_score": 0.00226, "epss_percentile": 0.45285}, "CVE-2024-33226": {"epss_score": 0.00228, "epss_percentile": 0.45471}, "CVE-2024-33227": {"epss_score": 0.00446, "epss_percentile": 0.6293}, "CVE-2024-33228": {"epss_score": 0.00226, "epss_percentile": 0.45273}, "CVE-2024-33231": {"epss_score": 0.02655, "epss_percentile": 0.85354}, "CVE-2024-33247": {"epss_score": 0.00145, "epss_percentile": 0.35359}, "CVE-2024-33250": {"epss_score": 0.00579, "epss_percentile": 0.68214}, "CVE-2024-33253": {"epss_score": 0.00147, "epss_percentile": 0.35676}, "CVE-2024-33255": {"epss_score": 0.00032, "epss_percentile": 0.09117}, "CVE-2024-33258": {"epss_score": 0.00056, "epss_percentile": 0.17671}, "CVE-2024-33259": {"epss_score": 0.00032, "epss_percentile": 0.09117}, "CVE-2024-33260": {"epss_score": 0.00064, "epss_percentile": 0.20137}, "CVE-2024-33263": {"epss_score": 9e-05, "epss_percentile": 0.00635}, "CVE-2024-33266": {"epss_score": 0.0006, "epss_percentile": 0.19208}, "CVE-2024-33267": {"epss_score": 0.0012, "epss_percentile": 0.3172}, "CVE-2024-33268": {"epss_score": 0.0012, "epss_percentile": 0.3172}, "CVE-2024-33269": {"epss_score": 0.0012, "epss_percentile": 0.3172}, "CVE-2024-33270": {"epss_score": 0.00289, "epss_percentile": 0.52027}, "CVE-2024-33271": {"epss_score": 0.00228, "epss_percentile": 0.45524}, "CVE-2024-33272": {"epss_score": 0.00043, "epss_percentile": 0.13002}, "CVE-2024-33273": {"epss_score": 0.00582, "epss_percentile": 0.68304}, "CVE-2024-33274": {"epss_score": 0.00664, "epss_percentile": 0.70633}, "CVE-2024-33275": {"epss_score": 0.00454, "epss_percentile": 0.63262}, "CVE-2024-33276": {"epss_score": 0.01014, "epss_percentile": 0.76647}, "CVE-2024-33278": {"epss_score": 0.08088, "epss_percentile": 0.91875}, "CVE-2024-33292": {"epss_score": 0.00118, "epss_percentile": 0.31513}, "CVE-2024-33294": {"epss_score": 0.00953, "epss_percentile": 0.75893}, "CVE-2024-33297": {"epss_score": 0.00391, "epss_percentile": 0.59595}, "CVE-2024-33298": {"epss_score": 0.00152, "epss_percentile": 0.36378}, "CVE-2024-33299": {"epss_score": 0.00391, "epss_percentile": 0.59595}, "CVE-2024-33300": {"epss_score": 0.00178, "epss_percentile": 0.39654}, "CVE-2024-33302": {"epss_score": 0.00043, "epss_percentile": 0.12975}, "CVE-2024-33303": {"epss_score": 0.00231, "epss_percentile": 0.45858}, "CVE-2024-33304": {"epss_score": 0.00098, "epss_percentile": 0.27711}, "CVE-2024-33305": {"epss_score": 0.00096, "epss_percentile": 0.27289}, "CVE-2024-33306": {"epss_score": 0.00108, "epss_percentile": 0.29831}, "CVE-2024-33307": {"epss_score": 0.00119, "epss_percentile": 0.31683}, "CVE-2024-33308": {"epss_score": 0.0028, "epss_percentile": 0.51096}, "CVE-2024-33309": {"epss_score": 0.00289, "epss_percentile": 0.52027}, "CVE-2024-33326": {"epss_score": 0.097, "epss_percentile": 0.92667}, "CVE-2024-33327": {"epss_score": 0.00198, "epss_percentile": 0.42015}, "CVE-2024-33328": {"epss_score": 0.00558, "epss_percentile": 0.67581}, "CVE-2024-33329": {"epss_score": 0.00078, "epss_percentile": 0.23664}, "CVE-2024-33332": {"epss_score": 0.00153, "epss_percentile": 0.36563}, "CVE-2024-33335": {"epss_score": 0.01708, "epss_percentile": 0.81867}, "CVE-2024-33338": {"epss_score": 0.01328, "epss_percentile": 0.79499}, "CVE-2024-33342": {"epss_score": 0.00396, "epss_percentile": 0.59865}, "CVE-2024-33343": {"epss_score": 0.07874, "epss_percentile": 0.91737}, "CVE-2024-33344": {"epss_score": 0.05381, "epss_percentile": 0.8981}, "CVE-2024-33345": {"epss_score": 0.00453, "epss_percentile": 0.63205}, "CVE-2024-33350": {"epss_score": 0.06591, "epss_percentile": 0.90872}, "CVE-2024-33365": {"epss_score": 0.04939, "epss_percentile": 0.89305}, "CVE-2024-33368": {"epss_score": 0.01324, "epss_percentile": 0.79466}, "CVE-2024-33369": {"epss_score": 0.06508, "epss_percentile": 0.90809}, "CVE-2024-33371": {"epss_score": 0.00381, "epss_percentile": 0.59003}, "CVE-2024-33373": {"epss_score": 0.00046, "epss_percentile": 0.14126}, "CVE-2024-33374": {"epss_score": 0.00162, "epss_percentile": 0.37736}, "CVE-2024-33375": {"epss_score": 0.00158, "epss_percentile": 0.37147}, "CVE-2024-33377": {"epss_score": 0.00112, "epss_percentile": 0.30423}, "CVE-2024-33382": {"epss_score": 0.0019, "epss_percentile": 0.41075}, "CVE-2024-33383": {"epss_score": 0.00266, "epss_percentile": 0.49917}, "CVE-2024-33393": {"epss_score": 0.00096, "epss_percentile": 0.27252}, "CVE-2024-33394": {"epss_score": 0.00044, "epss_percentile": 0.1343}, "CVE-2024-33396": {"epss_score": 0.00031, "epss_percentile": 0.08328}, "CVE-2024-33398": {"epss_score": 0.00224, "epss_percentile": 0.45022}, "CVE-2024-33401": {"epss_score": 0.00096, "epss_percentile": 0.2733}, "CVE-2024-33402": {"epss_score": 0.00219, "epss_percentile": 0.44483}, "CVE-2024-33403": {"epss_score": 0.00175, "epss_percentile": 0.39365}, "CVE-2024-33404": {"epss_score": 0.00111, "epss_percentile": 0.3025}, "CVE-2024-33405": {"epss_score": 0.00121, "epss_percentile": 0.32012}, "CVE-2024-33406": {"epss_score": 0.00121, "epss_percentile": 0.32012}, "CVE-2024-33407": {"epss_score": 0.00068, "epss_percentile": 0.21231}, "CVE-2024-33408": {"epss_score": 0.00194, "epss_percentile": 0.4154}, "CVE-2024-33409": {"epss_score": 0.00194, "epss_percentile": 0.4154}, "CVE-2024-33410": {"epss_score": 0.00194, "epss_percentile": 0.4154}, "CVE-2024-33411": {"epss_score": 0.00194, "epss_percentile": 0.4154}, "CVE-2024-33423": {"epss_score": 0.00231, "epss_percentile": 0.45858}, "CVE-2024-33424": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2024-33428": {"epss_score": 0.05245, "epss_percentile": 0.89658}, "CVE-2024-33429": {"epss_score": 0.01545, "epss_percentile": 0.80965}, "CVE-2024-33430": {"epss_score": 0.03421, "epss_percentile": 0.87101}, "CVE-2024-33431": {"epss_score": 0.01328, "epss_percentile": 0.79495}, "CVE-2024-33433": {"epss_score": 0.00434, "epss_percentile": 0.62306}, "CVE-2024-33434": {"epss_score": 0.05611, "epss_percentile": 0.90047}, "CVE-2024-33435": {"epss_score": 0.03255, "epss_percentile": 0.8676}, "CVE-2024-33436": {"epss_score": 0.00365, "epss_percentile": 0.57985}, "CVE-2024-33437": {"epss_score": 0.0027, "epss_percentile": 0.50273}, "CVE-2024-33438": {"epss_score": 0.00151, "epss_percentile": 0.36358}, "CVE-2024-33439": {"epss_score": 0.01197, "epss_percentile": 0.78447}, "CVE-2024-33442": {"epss_score": 0.01696, "epss_percentile": 0.81812}, "CVE-2024-33443": {"epss_score": 0.01322, "epss_percentile": 0.79449}, "CVE-2024-33444": {"epss_score": 0.00971, "epss_percentile": 0.76128}, "CVE-2024-33445": {"epss_score": 0.05518, "epss_percentile": 0.89953}, "CVE-2024-33449": {"epss_score": 0.04184, "epss_percentile": 0.88359}, "CVE-2024-33450": {"epss_score": 0.00263, "epss_percentile": 0.4951}, "CVE-2024-33452": {"epss_score": 0.00321, "epss_percentile": 0.54671}, "CVE-2024-33453": {"epss_score": 0.12794, "epss_percentile": 0.93775}, "CVE-2024-33454": {"epss_score": 0.01265, "epss_percentile": 0.79008}, "CVE-2024-33465": {"epss_score": 0.00074, "epss_percentile": 0.22686}, "CVE-2024-33469": {"epss_score": 0.00091, "epss_percentile": 0.26202}, "CVE-2024-33470": {"epss_score": 0.00054, "epss_percentile": 0.17041}, "CVE-2024-33471": {"epss_score": 0.00055, "epss_percentile": 0.17491}, "CVE-2024-33485": {"epss_score": 0.00382, "epss_percentile": 0.5906}, "CVE-2024-33489": {"epss_score": 0.0016, "epss_percentile": 0.37435}, "CVE-2024-33490": {"epss_score": 0.00177, "epss_percentile": 0.39537}, "CVE-2024-33491": {"epss_score": 0.00231, "epss_percentile": 0.45839}, "CVE-2024-33492": {"epss_score": 0.00177, "epss_percentile": 0.39537}, "CVE-2024-33493": {"epss_score": 0.00177, "epss_percentile": 0.39537}, "CVE-2024-33494": {"epss_score": 0.0029, "epss_percentile": 0.52079}, "CVE-2024-33495": {"epss_score": 0.00493, "epss_percentile": 0.65038}, "CVE-2024-33496": {"epss_score": 0.0008, "epss_percentile": 0.24096}, "CVE-2024-33497": {"epss_score": 0.00045, "epss_percentile": 0.13701}, "CVE-2024-33498": {"epss_score": 0.00527, "epss_percentile": 0.6652}, "CVE-2024-33499": {"epss_score": 0.00177, "epss_percentile": 0.39614}, "CVE-2024-33500": {"epss_score": 0.00194, "epss_percentile": 0.41588}, "CVE-2024-33501": {"epss_score": 0.00033, "epss_percentile": 0.09204}, "CVE-2024-33502": {"epss_score": 0.00427, "epss_percentile": 0.61825}, "CVE-2024-33503": {"epss_score": 0.00026, "epss_percentile": 0.06421}, "CVE-2024-33504": {"epss_score": 0.00064, "epss_percentile": 0.20174}, "CVE-2024-33505": {"epss_score": 0.00198, "epss_percentile": 0.42052}, "CVE-2024-33506": {"epss_score": 0.00224, "epss_percentile": 0.45061}, "CVE-2024-33507": {"epss_score": 0.00186, "epss_percentile": 0.40586}, "CVE-2024-33508": {"epss_score": 0.01163, "epss_percentile": 0.78161}, "CVE-2024-33509": {"epss_score": 0.002, "epss_percentile": 0.42272}, "CVE-2024-33510": {"epss_score": 0.00399, "epss_percentile": 0.60109}, "CVE-2024-33511": {"epss_score": 0.22847, "epss_percentile": 0.95699}, "CVE-2024-33512": {"epss_score": 0.22838, "epss_percentile": 0.95696}, "CVE-2024-33513": {"epss_score": 0.0012, "epss_percentile": 0.31702}, "CVE-2024-33514": {"epss_score": 0.00085, "epss_percentile": 0.25069}, "CVE-2024-33515": {"epss_score": 0.00074, "epss_percentile": 0.22776}, "CVE-2024-33516": {"epss_score": 0.00074, "epss_percentile": 0.22776}, "CVE-2024-33517": {"epss_score": 0.00074, "epss_percentile": 0.22776}, "CVE-2024-33518": {"epss_score": 0.00082, "epss_percentile": 0.2459}, "CVE-2024-33519": {"epss_score": 0.00672, "epss_percentile": 0.70815}, "CVE-2024-33522": {"epss_score": 0.00054, "epss_percentile": 0.17217}, "CVE-2024-33525": {"epss_score": 0.00063, "epss_percentile": 0.19891}, "CVE-2024-33526": {"epss_score": 0.00133, "epss_percentile": 0.33694}, "CVE-2024-33527": {"epss_score": 0.00043, "epss_percentile": 0.13359}, "CVE-2024-33528": {"epss_score": 0.0012, "epss_percentile": 0.31795}, "CVE-2024-33529": {"epss_score": 0.01155, "epss_percentile": 0.78075}, "CVE-2024-33530": {"epss_score": 0.00125, "epss_percentile": 0.32483}, "CVE-2024-33531": {"epss_score": 0.00079, "epss_percentile": 0.239}, "CVE-2024-33533": {"epss_score": 0.00223, "epss_percentile": 0.44847}, "CVE-2024-33535": {"epss_score": 0.00473, "epss_percentile": 0.64079}, "CVE-2024-33536": {"epss_score": 0.00173, "epss_percentile": 0.39131}, "CVE-2024-33537": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33538": {"epss_score": 0.00326, "epss_percentile": 0.55079}, "CVE-2024-33539": {"epss_score": 0.00293, "epss_percentile": 0.52302}, "CVE-2024-33540": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33541": {"epss_score": 0.01204, "epss_percentile": 0.78501}, "CVE-2024-33542": {"epss_score": 0.00129, "epss_percentile": 0.33159}, "CVE-2024-33543": {"epss_score": 0.00326, "epss_percentile": 0.55056}, "CVE-2024-33544": {"epss_score": 0.00315, "epss_percentile": 0.54191}, "CVE-2024-33545": {"epss_score": 0.0026, "epss_percentile": 0.49196}, "CVE-2024-33546": {"epss_score": 0.00153, "epss_percentile": 0.36566}, "CVE-2024-33547": {"epss_score": 0.00426, "epss_percentile": 0.6175}, "CVE-2024-33548": {"epss_score": 0.00197, "epss_percentile": 0.4189}, "CVE-2024-33549": {"epss_score": 0.006, "epss_percentile": 0.68821}, "CVE-2024-33550": {"epss_score": 0.00576, "epss_percentile": 0.6814}, "CVE-2024-33551": {"epss_score": 0.00587, "epss_percentile": 0.68481}, "CVE-2024-33552": {"epss_score": 0.00687, "epss_percentile": 0.71184}, "CVE-2024-33553": {"epss_score": 0.00692, "epss_percentile": 0.71301}, "CVE-2024-33554": {"epss_score": 0.00348, "epss_percentile": 0.56803}, "CVE-2024-33555": {"epss_score": 0.00332, "epss_percentile": 0.55589}, "CVE-2024-33556": {"epss_score": 0.00844, "epss_percentile": 0.74273}, "CVE-2024-33557": {"epss_score": 0.01662, "epss_percentile": 0.81633}, "CVE-2024-33558": {"epss_score": 0.00459, "epss_percentile": 0.63478}, "CVE-2024-33559": {"epss_score": 0.05816, "epss_percentile": 0.9023}, "CVE-2024-33560": {"epss_score": 0.01661, "epss_percentile": 0.81622}, "CVE-2024-33561": {"epss_score": 0.00492, "epss_percentile": 0.6499}, "CVE-2024-33562": {"epss_score": 0.00321, "epss_percentile": 0.54648}, "CVE-2024-33563": {"epss_score": 0.00522, "epss_percentile": 0.66256}, "CVE-2024-33564": {"epss_score": 0.0024, "epss_percentile": 0.47195}, "CVE-2024-33565": {"epss_score": 0.00259, "epss_percentile": 0.49084}, "CVE-2024-33566": {"epss_score": 0.01205, "epss_percentile": 0.78514}, "CVE-2024-33567": {"epss_score": 0.01012, "epss_percentile": 0.76626}, "CVE-2024-33568": {"epss_score": 0.00739, "epss_percentile": 0.72356}, "CVE-2024-33569": {"epss_score": 0.00189, "epss_percentile": 0.40964}, "CVE-2024-33570": {"epss_score": 0.00337, "epss_percentile": 0.56043}, "CVE-2024-33571": {"epss_score": 0.00274, "epss_percentile": 0.50565}, "CVE-2024-33572": {"epss_score": 0.00212, "epss_percentile": 0.43794}, "CVE-2024-33573": {"epss_score": 0.00109, "epss_percentile": 0.29944}, "CVE-2024-33574": {"epss_score": 0.00109, "epss_percentile": 0.29944}, "CVE-2024-33575": {"epss_score": 0.05404, "epss_percentile": 0.89836}, "CVE-2024-33576": {"epss_score": 0.00515, "epss_percentile": 0.65969}, "CVE-2024-33577": {"epss_score": 0.00139, "epss_percentile": 0.34635}, "CVE-2024-33578": {"epss_score": 0.00023, "epss_percentile": 0.05518}, "CVE-2024-33579": {"epss_score": 0.00018, "epss_percentile": 0.03714}, "CVE-2024-33580": {"epss_score": 0.00018, "epss_percentile": 0.03714}, "CVE-2024-33581": {"epss_score": 0.00023, "epss_percentile": 0.05518}, "CVE-2024-33582": {"epss_score": 0.00018, "epss_percentile": 0.03714}, "CVE-2024-33583": {"epss_score": 0.00113, "epss_percentile": 0.30615}, "CVE-2024-33584": {"epss_score": 0.00324, "epss_percentile": 0.54943}, "CVE-2024-33585": {"epss_score": 0.00134, "epss_percentile": 0.33864}, "CVE-2024-33586": {"epss_score": 0.00158, "epss_percentile": 0.37198}, "CVE-2024-33587": {"epss_score": 0.00151, "epss_percentile": 0.36346}, "CVE-2024-33588": {"epss_score": 0.00097, "epss_percentile": 0.27513}, "CVE-2024-33589": {"epss_score": 0.00459, "epss_percentile": 0.63478}, "CVE-2024-33590": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-33591": {"epss_score": 0.0037, "epss_percentile": 0.58309}, "CVE-2024-33592": {"epss_score": 0.00131, "epss_percentile": 0.33399}, "CVE-2024-33593": {"epss_score": 0.00134, "epss_percentile": 0.33864}, "CVE-2024-33594": {"epss_score": 0.00483, "epss_percentile": 0.64612}, "CVE-2024-33595": {"epss_score": 0.00491, "epss_percentile": 0.64967}, "CVE-2024-33596": {"epss_score": 0.00176, "epss_percentile": 0.39399}, "CVE-2024-33597": {"epss_score": 0.00258, "epss_percentile": 0.48948}, "CVE-2024-33598": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-33599": {"epss_score": 0.00563, "epss_percentile": 0.67709}, "CVE-2024-33600": {"epss_score": 0.00203, "epss_percentile": 0.42512}, "CVE-2024-33601": {"epss_score": 0.00094, "epss_percentile": 0.2679}, "CVE-2024-33602": {"epss_score": 0.00331, "epss_percentile": 0.55537}, "CVE-2024-33603": {"epss_score": 0.12123, "epss_percentile": 0.93572}, "CVE-2024-33604": {"epss_score": 0.00524, "epss_percentile": 0.66363}, "CVE-2024-33605": {"epss_score": 0.51432, "epss_percentile": 0.97778}, "CVE-2024-33606": {"epss_score": 0.00365, "epss_percentile": 0.58007}, "CVE-2024-33607": {"epss_score": 0.00011, "epss_percentile": 0.01044}, "CVE-2024-33608": {"epss_score": 0.00308, "epss_percentile": 0.53582}, "CVE-2024-33610": {"epss_score": 0.59525, "epss_percentile": 0.98168}, "CVE-2024-33611": {"epss_score": 0.00103, "epss_percentile": 0.29089}, "CVE-2024-33612": {"epss_score": 0.00179, "epss_percentile": 0.39831}, "CVE-2024-33615": {"epss_score": 0.00618, "epss_percentile": 0.69378}, "CVE-2024-33616": {"epss_score": 0.00169, "epss_percentile": 0.38535}, "CVE-2024-33617": {"epss_score": 0.00333, "epss_percentile": 0.55675}, "CVE-2024-33619": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-33620": {"epss_score": 0.00306, "epss_percentile": 0.53447}, "CVE-2024-33621": {"epss_score": 0.0001, "epss_percentile": 0.00807}, "CVE-2024-33622": {"epss_score": 0.00143, "epss_percentile": 0.35176}, "CVE-2024-33623": {"epss_score": 0.04265, "epss_percentile": 0.88469}, "CVE-2024-33624": {"epss_score": 0.00046, "epss_percentile": 0.1432}, "CVE-2024-33625": {"epss_score": 0.00035, "epss_percentile": 0.09923}, "CVE-2024-33626": {"epss_score": 0.00249, "epss_percentile": 0.48024}, "CVE-2024-33627": {"epss_score": 0.00149, "epss_percentile": 0.35985}, "CVE-2024-33628": {"epss_score": 0.01085, "epss_percentile": 0.77408}, "CVE-2024-33629": {"epss_score": 0.00135, "epss_percentile": 0.33982}, "CVE-2024-33630": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33631": {"epss_score": 0.00384, "epss_percentile": 0.5917}, "CVE-2024-33632": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-33633": {"epss_score": 0.00185, "epss_percentile": 0.40468}, "CVE-2024-33634": {"epss_score": 0.00204, "epss_percentile": 0.42638}, "CVE-2024-33635": {"epss_score": 0.00308, "epss_percentile": 0.53607}, "CVE-2024-33636": {"epss_score": 0.0019, "epss_percentile": 0.41118}, "CVE-2024-33637": {"epss_score": 0.00727, "epss_percentile": 0.72085}, "CVE-2024-33638": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-33639": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2024-33640": {"epss_score": 0.00185, "epss_percentile": 0.4048}, "CVE-2024-33641": {"epss_score": 0.00236, "epss_percentile": 0.46361}, "CVE-2024-33642": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-33643": {"epss_score": 0.00129, "epss_percentile": 0.33084}, "CVE-2024-33644": {"epss_score": 0.20684, "epss_percentile": 0.95401}, "CVE-2024-33645": {"epss_score": 0.00202, "epss_percentile": 0.4242}, "CVE-2024-33646": {"epss_score": 0.00155, "epss_percentile": 0.36808}, "CVE-2024-33647": {"epss_score": 0.00137, "epss_percentile": 0.34251}, "CVE-2024-33648": {"epss_score": 0.00194, "epss_percentile": 0.4157}, "CVE-2024-33649": {"epss_score": 0.00194, "epss_percentile": 0.4157}, "CVE-2024-33650": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-33651": {"epss_score": 0.00123, "epss_percentile": 0.32321}, "CVE-2024-33652": {"epss_score": 0.00182, "epss_percentile": 0.40228}, "CVE-2024-33653": {"epss_score": 0.00231, "epss_percentile": 0.45839}, "CVE-2024-33654": {"epss_score": 0.00177, "epss_percentile": 0.39537}, "CVE-2024-33655": {"epss_score": 0.03922, "epss_percentile": 0.87955}, "CVE-2024-33656": {"epss_score": 0.0001, "epss_percentile": 0.00771}, "CVE-2024-33657": {"epss_score": 0.00078, "epss_percentile": 0.23655}, "CVE-2024-33658": {"epss_score": 0.00168, "epss_percentile": 0.38497}, "CVE-2024-33659": {"epss_score": 0.00021, "epss_percentile": 0.04902}, "CVE-2024-33660": {"epss_score": 0.0011, "epss_percentile": 0.30099}, "CVE-2024-33661": {"epss_score": 0.00124, "epss_percentile": 0.32428}, "CVE-2024-33662": {"epss_score": 0.00089, "epss_percentile": 0.25898}, "CVE-2024-33663": {"epss_score": 0.00684, "epss_percentile": 0.71112}, "CVE-2024-33664": {"epss_score": 0.00194, "epss_percentile": 0.41529}, "CVE-2024-33665": {"epss_score": 0.00221, "epss_percentile": 0.44712}, "CVE-2024-33666": {"epss_score": 0.00214, "epss_percentile": 0.44007}, "CVE-2024-33667": {"epss_score": 0.00779, "epss_percentile": 0.73138}, "CVE-2024-33668": {"epss_score": 0.00332, "epss_percentile": 0.5559}, "CVE-2024-33669": {"epss_score": 0.00159, "epss_percentile": 0.37421}, "CVE-2024-33670": {"epss_score": 0.0046, "epss_percentile": 0.63499}, "CVE-2024-33671": {"epss_score": 0.00101, "epss_percentile": 0.286}, "CVE-2024-33672": {"epss_score": 0.00042, "epss_percentile": 0.1249}, "CVE-2024-33673": {"epss_score": 0.00071, "epss_percentile": 0.22031}, "CVE-2024-33677": {"epss_score": 0.00147, "epss_percentile": 0.35657}, "CVE-2024-33678": {"epss_score": 0.00147, "epss_percentile": 0.35657}, "CVE-2024-33679": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-33680": {"epss_score": 0.00117, "epss_percentile": 0.31259}, "CVE-2024-33681": {"epss_score": 0.00144, "epss_percentile": 0.35267}, "CVE-2024-33682": {"epss_score": 0.00789, "epss_percentile": 0.73353}, "CVE-2024-33683": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-33684": {"epss_score": 0.00119, "epss_percentile": 0.31652}, "CVE-2024-33686": {"epss_score": 0.00248, "epss_percentile": 0.47975}, "CVE-2024-33687": {"epss_score": 0.00212, "epss_percentile": 0.43793}, "CVE-2024-33688": {"epss_score": 0.00134, "epss_percentile": 0.33896}, "CVE-2024-33689": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-33690": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-33691": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-33692": {"epss_score": 0.00124, "epss_percentile": 0.32425}, "CVE-2024-33693": {"epss_score": 0.00124, "epss_percentile": 0.32425}, "CVE-2024-33694": {"epss_score": 0.00124, "epss_percentile": 0.32425}, "CVE-2024-33695": {"epss_score": 0.00129, "epss_percentile": 0.33084}, "CVE-2024-33696": {"epss_score": 0.00129, "epss_percentile": 0.33084}, "CVE-2024-33697": {"epss_score": 0.00129, "epss_percentile": 0.33084}, "CVE-2024-33698": {"epss_score": 0.03139, "epss_percentile": 0.86484}, "CVE-2024-33699": {"epss_score": 0.0719, "epss_percentile": 0.9131}, "CVE-2024-33700": {"epss_score": 0.00315, "epss_percentile": 0.54193}, "CVE-2024-33748": {"epss_score": 0.00151, "epss_percentile": 0.36229}, "CVE-2024-33749": {"epss_score": 0.00125, "epss_percentile": 0.32528}, "CVE-2024-33752": {"epss_score": 0.85785, "epss_percentile": 0.99348}, "CVE-2024-33753": {"epss_score": 0.00207, "epss_percentile": 0.43207}, "CVE-2024-33763": {"epss_score": 0.00096, "epss_percentile": 0.27327}, "CVE-2024-33764": {"epss_score": 0.00041, "epss_percentile": 0.1228}, "CVE-2024-33766": {"epss_score": 0.00099, "epss_percentile": 0.28361}, "CVE-2024-33767": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-33768": {"epss_score": 0.00167, "epss_percentile": 0.38354}, "CVE-2024-33771": {"epss_score": 0.00454, "epss_percentile": 0.63261}, "CVE-2024-33772": {"epss_score": 0.00497, "epss_percentile": 0.65205}, "CVE-2024-33773": {"epss_score": 0.0041, "epss_percentile": 0.60794}, "CVE-2024-33774": {"epss_score": 0.00742, "epss_percentile": 0.72452}, "CVE-2024-33775": {"epss_score": 0.03376, "epss_percentile": 0.8702}, "CVE-2024-33780": {"epss_score": 0.00168, "epss_percentile": 0.3841}, "CVE-2024-33781": {"epss_score": 0.00198, "epss_percentile": 0.42043}, "CVE-2024-33782": {"epss_score": 0.00198, "epss_percentile": 0.42043}, "CVE-2024-33783": {"epss_score": 0.00168, "epss_percentile": 0.3841}, "CVE-2024-33786": {"epss_score": 0.00482, "epss_percentile": 0.6453}, "CVE-2024-33787": {"epss_score": 0.00069, "epss_percentile": 0.21433}, "CVE-2024-33788": {"epss_score": 0.02597, "epss_percentile": 0.85201}, "CVE-2024-33789": {"epss_score": 0.09806, "epss_percentile": 0.92709}, "CVE-2024-33791": {"epss_score": 0.00251, "epss_percentile": 0.483}, "CVE-2024-33792": {"epss_score": 0.00921, "epss_percentile": 0.75476}, "CVE-2024-33793": {"epss_score": 0.00119, "epss_percentile": 0.31567}, "CVE-2024-33799": {"epss_score": 0.00258, "epss_percentile": 0.48964}, "CVE-2024-33800": {"epss_score": 0.00258, "epss_percentile": 0.48964}, "CVE-2024-33801": {"epss_score": 0.00258, "epss_percentile": 0.48964}, "CVE-2024-33802": {"epss_score": 0.00216, "epss_percentile": 0.4415}, "CVE-2024-33803": {"epss_score": 0.00199, "epss_percentile": 0.42138}, "CVE-2024-33804": {"epss_score": 0.00124, "epss_percentile": 0.32356}, "CVE-2024-33805": {"epss_score": 0.00258, "epss_percentile": 0.48964}, "CVE-2024-33806": {"epss_score": 0.00258, "epss_percentile": 0.48964}, "CVE-2024-33807": {"epss_score": 0.00209, "epss_percentile": 0.43395}, "CVE-2024-33808": {"epss_score": 0.00285, "epss_percentile": 0.51525}, "CVE-2024-33809": {"epss_score": 0.00188, "epss_percentile": 0.40847}, "CVE-2024-33818": {"epss_score": 0.00283, "epss_percentile": 0.5135}, "CVE-2024-33819": {"epss_score": 0.00353, "epss_percentile": 0.5718}, "CVE-2024-33820": {"epss_score": 0.00155, "epss_percentile": 0.36793}, "CVE-2024-33829": {"epss_score": 0.0015, "epss_percentile": 0.36047}, "CVE-2024-33830": {"epss_score": 0.00237, "epss_percentile": 0.46722}, "CVE-2024-33831": {"epss_score": 0.00303, "epss_percentile": 0.53178}, "CVE-2024-33832": {"epss_score": 0.03512, "epss_percentile": 0.87268}, "CVE-2024-33835": {"epss_score": 0.0028, "epss_percentile": 0.51073}, "CVE-2024-33836": {"epss_score": 0.00434, "epss_percentile": 0.62291}, "CVE-2024-33844": {"epss_score": 0.00373, "epss_percentile": 0.58524}, "CVE-2024-33847": {"epss_score": 0.00032, "epss_percentile": 0.09045}, "CVE-2024-33848": {"epss_score": 0.00129, "epss_percentile": 0.33168}, "CVE-2024-33849": {"epss_score": 0.00066, "epss_percentile": 0.20849}, "CVE-2024-33850": {"epss_score": 0.0029, "epss_percentile": 0.52099}, "CVE-2024-33851": {"epss_score": 0.00091, "epss_percentile": 0.26227}, "CVE-2024-33852": {"epss_score": 0.00089, "epss_percentile": 0.25921}, "CVE-2024-33853": {"epss_score": 0.0009, "epss_percentile": 0.26011}, "CVE-2024-33854": {"epss_score": 0.00089, "epss_percentile": 0.25921}, "CVE-2024-33856": {"epss_score": 0.00368, "epss_percentile": 0.5817}, "CVE-2024-33857": {"epss_score": 0.00206, "epss_percentile": 0.43059}, "CVE-2024-33858": {"epss_score": 0.00222, "epss_percentile": 0.44747}, "CVE-2024-33859": {"epss_score": 0.00514, "epss_percentile": 0.6594}, "CVE-2024-33860": {"epss_score": 0.00228, "epss_percentile": 0.45483}, "CVE-2024-33862": {"epss_score": 0.00493, "epss_percentile": 0.65064}, "CVE-2024-33863": {"epss_score": 0.00457, "epss_percentile": 0.6337}, "CVE-2024-33864": {"epss_score": 0.00123, "epss_percentile": 0.32224}, "CVE-2024-33865": {"epss_score": 0.00319, "epss_percentile": 0.54553}, "CVE-2024-33866": {"epss_score": 0.00347, "epss_percentile": 0.56743}, "CVE-2024-33867": {"epss_score": 0.00098, "epss_percentile": 0.27729}, "CVE-2024-33868": {"epss_score": 0.00391, "epss_percentile": 0.5959}, "CVE-2024-33869": {"epss_score": 0.00014, "epss_percentile": 0.02062}, "CVE-2024-33870": {"epss_score": 0.00079, "epss_percentile": 0.23874}, "CVE-2024-33871": {"epss_score": 0.00703, "epss_percentile": 0.71539}, "CVE-2024-33872": {"epss_score": 0.00145, "epss_percentile": 0.35372}, "CVE-2024-33873": {"epss_score": 0.00491, "epss_percentile": 0.6496}, "CVE-2024-33874": {"epss_score": 0.00472, "epss_percentile": 0.64065}, "CVE-2024-33875": {"epss_score": 0.00064, "epss_percentile": 0.20107}, "CVE-2024-33876": {"epss_score": 0.00076, "epss_percentile": 0.23216}, "CVE-2024-33877": {"epss_score": 0.00507, "epss_percentile": 0.65648}, "CVE-2024-33879": {"epss_score": 0.00275, "epss_percentile": 0.50668}, "CVE-2024-33880": {"epss_score": 0.00155, "epss_percentile": 0.36836}, "CVE-2024-33881": {"epss_score": 0.00252, "epss_percentile": 0.48345}, "CVE-2024-33883": {"epss_score": 0.01263, "epss_percentile": 0.78991}, "CVE-2024-33891": {"epss_score": 0.00887, "epss_percentile": 0.74967}, "CVE-2024-33892": {"epss_score": 0.00233, "epss_percentile": 0.45979}, "CVE-2024-33893": {"epss_score": 0.01642, "epss_percentile": 0.81507}, "CVE-2024-33894": {"epss_score": 0.00792, "epss_percentile": 0.73409}, "CVE-2024-33895": {"epss_score": 0.00386, "epss_percentile": 0.59248}, "CVE-2024-33896": {"epss_score": 0.14798, "epss_percentile": 0.94287}, "CVE-2024-33897": {"epss_score": 0.00534, "epss_percentile": 0.66797}, "CVE-2024-33898": {"epss_score": 0.0029, "epss_percentile": 0.52133}, "CVE-2024-33899": {"epss_score": 0.01033, "epss_percentile": 0.7687}, "CVE-2024-33900": {"epss_score": 0.00127, "epss_percentile": 0.32827}, "CVE-2024-33901": {"epss_score": 0.21786, "epss_percentile": 0.9556}, "CVE-2024-33903": {"epss_score": 0.00075, "epss_percentile": 0.22982}, "CVE-2024-33904": {"epss_score": 0.00076, "epss_percentile": 0.23142}, "CVE-2024-33905": {"epss_score": 0.0006, "epss_percentile": 0.19074}, "CVE-2024-33907": {"epss_score": 0.00324, "epss_percentile": 0.54943}, "CVE-2024-33908": {"epss_score": 0.00176, "epss_percentile": 0.39399}, "CVE-2024-33910": {"epss_score": 0.00324, "epss_percentile": 0.54943}, "CVE-2024-33911": {"epss_score": 0.05975, "epss_percentile": 0.90375}, "CVE-2024-33912": {"epss_score": 0.00335, "epss_percentile": 0.55857}, "CVE-2024-33913": {"epss_score": 0.0015, "epss_percentile": 0.36106}, "CVE-2024-33914": {"epss_score": 0.00228, "epss_percentile": 0.45472}, "CVE-2024-33915": {"epss_score": 0.00064, "epss_percentile": 0.20316}, "CVE-2024-33916": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-33917": {"epss_score": 0.00147, "epss_percentile": 0.35698}, "CVE-2024-33918": {"epss_score": 0.00082, "epss_percentile": 0.24446}, "CVE-2024-33919": {"epss_score": 0.00055, "epss_percentile": 0.17469}, "CVE-2024-33920": {"epss_score": 0.00076, "epss_percentile": 0.23152}, "CVE-2024-33921": {"epss_score": 0.00138, "epss_percentile": 0.34431}, "CVE-2024-33922": {"epss_score": 0.00366, "epss_percentile": 0.58053}, "CVE-2024-33923": {"epss_score": 0.00066, "epss_percentile": 0.20679}, "CVE-2024-33924": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-33925": {"epss_score": 0.00071, "epss_percentile": 0.22052}, "CVE-2024-33926": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-33927": {"epss_score": 0.00084, "epss_percentile": 0.25007}, "CVE-2024-33928": {"epss_score": 0.00175, "epss_percentile": 0.39332}, "CVE-2024-33929": {"epss_score": 0.00076, "epss_percentile": 0.23152}, "CVE-2024-33930": {"epss_score": 0.00289, "epss_percentile": 0.5202}, "CVE-2024-33931": {"epss_score": 0.00061, "epss_percentile": 0.19254}, "CVE-2024-33932": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33933": {"epss_score": 0.00077, "epss_percentile": 0.23519}, "CVE-2024-33934": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33935": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33936": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-33937": {"epss_score": 0.00123, "epss_percentile": 0.32325}, "CVE-2024-33938": {"epss_score": 0.00132, "epss_percentile": 0.33545}, "CVE-2024-33939": {"epss_score": 0.02581, "epss_percentile": 0.85154}, "CVE-2024-33940": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-33941": {"epss_score": 0.00155, "epss_percentile": 0.36766}, "CVE-2024-33942": {"epss_score": 0.00173, "epss_percentile": 0.3908}, "CVE-2024-33943": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-33944": {"epss_score": 0.00127, "epss_percentile": 0.32818}, "CVE-2024-33945": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-33946": {"epss_score": 0.00084, "epss_percentile": 0.24991}, "CVE-2024-33947": {"epss_score": 0.00091, "epss_percentile": 0.26188}, "CVE-2024-33948": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33949": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33950": {"epss_score": 0.00187, "epss_percentile": 0.40699}, "CVE-2024-33951": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33952": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33953": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33954": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33955": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-33956": {"epss_score": 0.00183, "epss_percentile": 0.40329}, "CVE-2024-33957": {"epss_score": 0.00247, "epss_percentile": 0.4782}, "CVE-2024-33958": {"epss_score": 0.00237, "epss_percentile": 0.46725}, "CVE-2024-33959": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2024-33960": {"epss_score": 0.00188, "epss_percentile": 0.40829}, "CVE-2024-33961": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2024-33962": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2024-33963": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2024-33964": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2024-33965": {"epss_score": 0.00175, "epss_percentile": 0.39275}, "CVE-2024-33966": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2024-33967": {"epss_score": 0.00175, "epss_percentile": 0.39275}, "CVE-2024-33968": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2024-33969": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2024-33970": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2024-33971": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2024-33972": {"epss_score": 0.00175, "epss_percentile": 0.39275}, "CVE-2024-33973": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2024-33974": {"epss_score": 0.0018, "epss_percentile": 0.39988}, "CVE-2024-33975": {"epss_score": 0.00285, "epss_percentile": 0.51639}, "CVE-2024-33976": {"epss_score": 0.00285, "epss_percentile": 0.51639}, "CVE-2024-33977": {"epss_score": 0.00174, "epss_percentile": 0.39227}, "CVE-2024-33978": {"epss_score": 0.00237, "epss_percentile": 0.46688}, "CVE-2024-33979": {"epss_score": 0.00237, "epss_percentile": 0.46688}, "CVE-2024-33980": {"epss_score": 0.00237, "epss_percentile": 0.46688}, "CVE-2024-33981": {"epss_score": 0.00237, "epss_percentile": 0.46688}, "CVE-2024-33982": {"epss_score": 0.00094, "epss_percentile": 0.27074}, "CVE-2024-33983": {"epss_score": 0.00094, "epss_percentile": 0.27074}, "CVE-2024-33984": {"epss_score": 0.00094, "epss_percentile": 0.27074}, "CVE-2024-33985": {"epss_score": 0.00094, "epss_percentile": 0.27074}, "CVE-2024-33986": {"epss_score": 0.00094, "epss_percentile": 0.27074}, "CVE-2024-33987": {"epss_score": 0.00094, "epss_percentile": 0.27074}, "CVE-2024-33988": {"epss_score": 0.00094, "epss_percentile": 0.27074}, "CVE-2024-33989": {"epss_score": 0.00286, "epss_percentile": 0.51769}, "CVE-2024-33990": {"epss_score": 0.00286, "epss_percentile": 0.51769}, "CVE-2024-33991": {"epss_score": 0.00174, "epss_percentile": 0.39227}, "CVE-2024-33992": {"epss_score": 0.00174, "epss_percentile": 0.39227}, "CVE-2024-33993": {"epss_score": 0.00174, "epss_percentile": 0.39227}, "CVE-2024-33994": {"epss_score": 0.00174, "epss_percentile": 0.39227}, "CVE-2024-33996": {"epss_score": 0.00182, "epss_percentile": 0.40238}, "CVE-2024-33997": {"epss_score": 0.01346, "epss_percentile": 0.79643}, "CVE-2024-33998": {"epss_score": 0.01074, "epss_percentile": 0.77299}, "CVE-2024-33999": {"epss_score": 0.00619, "epss_percentile": 0.69432}, "CVE-2024-34000": {"epss_score": 0.00377, "epss_percentile": 0.58747}, "CVE-2024-34001": {"epss_score": 0.00353, "epss_percentile": 0.572}, "CVE-2024-34002": {"epss_score": 0.00514, "epss_percentile": 0.6594}, "CVE-2024-34003": {"epss_score": 0.00194, "epss_percentile": 0.41562}, "CVE-2024-34004": {"epss_score": 0.00349, "epss_percentile": 0.569}, "CVE-2024-34005": {"epss_score": 0.00671, "epss_percentile": 0.7079}, "CVE-2024-34006": {"epss_score": 0.00464, "epss_percentile": 0.63734}, "CVE-2024-34007": {"epss_score": 0.00527, "epss_percentile": 0.66453}, "CVE-2024-34008": {"epss_score": 0.00395, "epss_percentile": 0.59845}, "CVE-2024-34009": {"epss_score": 0.00105, "epss_percentile": 0.29381}, "CVE-2024-34010": {"epss_score": 0.00058, "epss_percentile": 0.18402}, "CVE-2024-34011": {"epss_score": 0.00046, "epss_percentile": 0.1427}, "CVE-2024-34012": {"epss_score": 0.00078, "epss_percentile": 0.23757}, "CVE-2024-34013": {"epss_score": 0.00245, "epss_percentile": 0.47645}, "CVE-2024-34014": {"epss_score": 0.00106, "epss_percentile": 0.2941}, "CVE-2024-34015": {"epss_score": 0.00081, "epss_percentile": 0.24354}, "CVE-2024-34016": {"epss_score": 0.00036, "epss_percentile": 0.10257}, "CVE-2024-34017": {"epss_score": 0.00101, "epss_percentile": 0.286}, "CVE-2024-34018": {"epss_score": 0.00113, "epss_percentile": 0.30683}, "CVE-2024-34019": {"epss_score": 0.00101, "epss_percentile": 0.286}, "CVE-2024-34020": {"epss_score": 0.00063, "epss_percentile": 0.19904}, "CVE-2024-34021": {"epss_score": 0.00076, "epss_percentile": 0.2326}, "CVE-2024-34022": {"epss_score": 0.00039, "epss_percentile": 0.1169}, "CVE-2024-34023": {"epss_score": 0.00075, "epss_percentile": 0.22909}, "CVE-2024-34024": {"epss_score": 0.00634, "epss_percentile": 0.69797}, "CVE-2024-34025": {"epss_score": 0.00028, "epss_percentile": 0.0749}, "CVE-2024-34026": {"epss_score": 0.06602, "epss_percentile": 0.90879}, "CVE-2024-34027": {"epss_score": 0.00023, "epss_percentile": 0.056}, "CVE-2024-34028": {"epss_score": 0.00059, "epss_percentile": 0.18876}, "CVE-2024-34029": {"epss_score": 0.00422, "epss_percentile": 0.61565}, "CVE-2024-34030": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-34031": {"epss_score": 0.00058, "epss_percentile": 0.18426}, "CVE-2024-34032": {"epss_score": 0.00782, "epss_percentile": 0.73208}, "CVE-2024-34033": {"epss_score": 0.00203, "epss_percentile": 0.42581}, "CVE-2024-34034": {"epss_score": 0.00022, "epss_percentile": 0.0524}, "CVE-2024-34035": {"epss_score": 0.00022, "epss_percentile": 0.0524}, "CVE-2024-34036": {"epss_score": 0.00021, "epss_percentile": 0.04938}, "CVE-2024-34043": {"epss_score": 0.00066, "epss_percentile": 0.20705}, "CVE-2024-34044": {"epss_score": 0.00104, "epss_percentile": 0.29233}, "CVE-2024-34045": {"epss_score": 0.00151, "epss_percentile": 0.36255}, "CVE-2024-34046": {"epss_score": 0.00197, "epss_percentile": 0.41958}, "CVE-2024-34047": {"epss_score": 0.00196, "epss_percentile": 0.41729}, "CVE-2024-34048": {"epss_score": 0.00283, "epss_percentile": 0.51346}, "CVE-2024-34049": {"epss_score": 0.00139, "epss_percentile": 0.34614}, "CVE-2024-34050": {"epss_score": 0.00182, "epss_percentile": 0.40195}, "CVE-2024-34051": {"epss_score": 0.01258, "epss_percentile": 0.78957}, "CVE-2024-34055": {"epss_score": 0.00571, "epss_percentile": 0.67973}, "CVE-2024-34057": {"epss_score": 0.00119, "epss_percentile": 0.31643}, "CVE-2024-34058": {"epss_score": 0.00268, "epss_percentile": 0.50068}, "CVE-2024-34060": {"epss_score": 0.02437, "epss_percentile": 0.84743}, "CVE-2024-34061": {"epss_score": 0.22365, "epss_percentile": 0.95626}, "CVE-2024-34062": {"epss_score": 0.00081, "epss_percentile": 0.24256}, "CVE-2024-34063": {"epss_score": 0.00022, "epss_percentile": 0.05259}, "CVE-2024-34064": {"epss_score": 0.01147, "epss_percentile": 0.78005}, "CVE-2024-34065": {"epss_score": 0.00796, "epss_percentile": 0.73488}, "CVE-2024-34066": {"epss_score": 0.00338, "epss_percentile": 0.5614}, "CVE-2024-34067": {"epss_score": 0.00529, "epss_percentile": 0.66598}, "CVE-2024-34068": {"epss_score": 0.00237, "epss_percentile": 0.46662}, "CVE-2024-34069": {"epss_score": 0.41935, "epss_percentile": 0.97302}, "CVE-2024-34070": {"epss_score": 0.00882, "epss_percentile": 0.7489}, "CVE-2024-34071": {"epss_score": 0.00523, "epss_percentile": 0.66298}, "CVE-2024-34072": {"epss_score": 0.00593, "epss_percentile": 0.68636}, "CVE-2024-34073": {"epss_score": 0.00397, "epss_percentile": 0.60048}, "CVE-2024-34074": {"epss_score": 0.00272, "epss_percentile": 0.50413}, "CVE-2024-34075": {"epss_score": 6e-05, "epss_percentile": 0.00299}, "CVE-2024-34077": {"epss_score": 0.00225, "epss_percentile": 0.45126}, "CVE-2024-34078": {"epss_score": 0.00151, "epss_percentile": 0.36326}, "CVE-2024-34079": {"epss_score": 0.00056, "epss_percentile": 0.17727}, "CVE-2024-34080": {"epss_score": 0.00288, "epss_percentile": 0.51887}, "CVE-2024-34081": {"epss_score": 0.00229, "epss_percentile": 0.45641}, "CVE-2024-34082": {"epss_score": 0.00211, "epss_percentile": 0.43665}, "CVE-2024-34083": {"epss_score": 0.00069, "epss_percentile": 0.2162}, "CVE-2024-34084": {"epss_score": 0.00149, "epss_percentile": 0.36018}, "CVE-2024-34085": {"epss_score": 0.00185, "epss_percentile": 0.40567}, "CVE-2024-34086": {"epss_score": 0.00157, "epss_percentile": 0.37077}, "CVE-2024-34087": {"epss_score": 0.00633, "epss_percentile": 0.6977}, "CVE-2024-34088": {"epss_score": 0.00062, "epss_percentile": 0.196}, "CVE-2024-34089": {"epss_score": 0.00233, "epss_percentile": 0.46055}, "CVE-2024-34090": {"epss_score": 0.0069, "epss_percentile": 0.7125}, "CVE-2024-34091": {"epss_score": 0.00233, "epss_percentile": 0.46055}, "CVE-2024-34092": {"epss_score": 0.00146, "epss_percentile": 0.35547}, "CVE-2024-34093": {"epss_score": 0.002, "epss_percentile": 0.42262}, "CVE-2024-34094": {"epss_score": 0.00258, "epss_percentile": 0.49011}, "CVE-2024-34095": {"epss_score": 0.00247, "epss_percentile": 0.47905}, "CVE-2024-34096": {"epss_score": 0.00247, "epss_percentile": 0.47905}, "CVE-2024-34097": {"epss_score": 0.00293, "epss_percentile": 0.52319}, "CVE-2024-34098": {"epss_score": 0.00203, "epss_percentile": 0.42491}, "CVE-2024-34099": {"epss_score": 0.00286, "epss_percentile": 0.51698}, "CVE-2024-34100": {"epss_score": 0.0109, "epss_percentile": 0.77454}, "CVE-2024-34101": {"epss_score": 0.00033, "epss_percentile": 0.093}, "CVE-2024-34102": {"epss_score": 0.94101, "epss_percentile": 0.99903}, "CVE-2024-34103": {"epss_score": 0.00998, "epss_percentile": 0.76472}, "CVE-2024-34104": {"epss_score": 0.00335, "epss_percentile": 0.5584}, "CVE-2024-34105": {"epss_score": 0.01074, "epss_percentile": 0.77298}, "CVE-2024-34106": {"epss_score": 0.00355, "epss_percentile": 0.57291}, "CVE-2024-34107": {"epss_score": 0.00396, "epss_percentile": 0.59902}, "CVE-2024-34108": {"epss_score": 0.02363, "epss_percentile": 0.84506}, "CVE-2024-34109": {"epss_score": 0.02363, "epss_percentile": 0.84506}, "CVE-2024-34110": {"epss_score": 0.03175, "epss_percentile": 0.86568}, "CVE-2024-34111": {"epss_score": 0.00412, "epss_percentile": 0.60943}, "CVE-2024-34112": {"epss_score": 0.06743, "epss_percentile": 0.90998}, "CVE-2024-34113": {"epss_score": 0.00025, "epss_percentile": 0.06063}, "CVE-2024-34115": {"epss_score": 0.00201, "epss_percentile": 0.42347}, "CVE-2024-34116": {"epss_score": 0.00031, "epss_percentile": 0.08398}, "CVE-2024-34117": {"epss_score": 0.00122, "epss_percentile": 0.3204}, "CVE-2024-34118": {"epss_score": 0.00056, "epss_percentile": 0.17659}, "CVE-2024-34119": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-34120": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-34121": {"epss_score": 0.00192, "epss_percentile": 0.41291}, "CVE-2024-34122": {"epss_score": 0.00266, "epss_percentile": 0.49945}, "CVE-2024-34123": {"epss_score": 0.00219, "epss_percentile": 0.44505}, "CVE-2024-34124": {"epss_score": 0.00109, "epss_percentile": 0.29973}, "CVE-2024-34125": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-34126": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-34127": {"epss_score": 0.00022, "epss_percentile": 0.05062}, "CVE-2024-34128": {"epss_score": 0.02063, "epss_percentile": 0.83449}, "CVE-2024-34129": {"epss_score": 0.00057, "epss_percentile": 0.18007}, "CVE-2024-34130": {"epss_score": 0.00042, "epss_percentile": 0.12832}, "CVE-2024-34133": {"epss_score": 0.00103, "epss_percentile": 0.29055}, "CVE-2024-34134": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-34135": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-34136": {"epss_score": 0.00061, "epss_percentile": 0.19442}, "CVE-2024-34137": {"epss_score": 0.00061, "epss_percentile": 0.19442}, "CVE-2024-34138": {"epss_score": 0.00061, "epss_percentile": 0.19442}, "CVE-2024-34139": {"epss_score": 0.00193, "epss_percentile": 0.41395}, "CVE-2024-34140": {"epss_score": 0.0004, "epss_percentile": 0.1218}, "CVE-2024-34141": {"epss_score": 0.01626, "epss_percentile": 0.81426}, "CVE-2024-34142": {"epss_score": 0.01626, "epss_percentile": 0.81426}, "CVE-2024-34144": {"epss_score": 0.50053, "epss_percentile": 0.97716}, "CVE-2024-34145": {"epss_score": 0.0006, "epss_percentile": 0.19174}, "CVE-2024-34146": {"epss_score": 0.0007, "epss_percentile": 0.21667}, "CVE-2024-34147": {"epss_score": 0.00076, "epss_percentile": 0.23146}, "CVE-2024-34148": {"epss_score": 0.00305, "epss_percentile": 0.53375}, "CVE-2024-34149": {"epss_score": 0.0014, "epss_percentile": 0.34783}, "CVE-2024-34152": {"epss_score": 0.00278, "epss_percentile": 0.50846}, "CVE-2024-34153": {"epss_score": 0.00146, "epss_percentile": 0.35558}, "CVE-2024-34155": {"epss_score": 0.00075, "epss_percentile": 0.23026}, "CVE-2024-34156": {"epss_score": 0.00306, "epss_percentile": 0.53428}, "CVE-2024-34158": {"epss_score": 0.00147, "epss_percentile": 0.35705}, "CVE-2024-34161": {"epss_score": 0.00938, "epss_percentile": 0.7571}, "CVE-2024-34162": {"epss_score": 0.00154, "epss_percentile": 0.36658}, "CVE-2024-34163": {"epss_score": 0.00092, "epss_percentile": 0.26459}, "CVE-2024-34164": {"epss_score": 0.00037, "epss_percentile": 0.10647}, "CVE-2024-34165": {"epss_score": 0.00196, "epss_percentile": 0.41811}, "CVE-2024-34166": {"epss_score": 0.04676, "epss_percentile": 0.88996}, "CVE-2024-34167": {"epss_score": 0.00245, "epss_percentile": 0.47625}, "CVE-2024-34170": {"epss_score": 0.00096, "epss_percentile": 0.27261}, "CVE-2024-34171": {"epss_score": 0.00257, "epss_percentile": 0.48888}, "CVE-2024-34191": {"epss_score": 0.00447, "epss_percentile": 0.62982}, "CVE-2024-34193": {"epss_score": 0.00558, "epss_percentile": 0.676}, "CVE-2024-34195": {"epss_score": 0.00247, "epss_percentile": 0.47892}, "CVE-2024-34196": {"epss_score": 0.00125, "epss_percentile": 0.3251}, "CVE-2024-34198": {"epss_score": 0.00235, "epss_percentile": 0.46207}, "CVE-2024-34199": {"epss_score": 0.01916, "epss_percentile": 0.82859}, "CVE-2024-34200": {"epss_score": 0.00301, "epss_percentile": 0.5307}, "CVE-2024-34201": {"epss_score": 0.0041, "epss_percentile": 0.60819}, "CVE-2024-34202": {"epss_score": 0.00442, "epss_percentile": 0.62701}, "CVE-2024-34203": {"epss_score": 0.00405, "epss_percentile": 0.60461}, "CVE-2024-34204": {"epss_score": 0.05983, "epss_percentile": 0.90381}, "CVE-2024-34205": {"epss_score": 0.04641, "epss_percentile": 0.88953}, "CVE-2024-34206": {"epss_score": 0.01571, "epss_percentile": 0.81093}, "CVE-2024-34207": {"epss_score": 0.00278, "epss_percentile": 0.50882}, "CVE-2024-34209": {"epss_score": 0.00463, "epss_percentile": 0.63668}, "CVE-2024-34210": {"epss_score": 0.04667, "epss_percentile": 0.88982}, "CVE-2024-34211": {"epss_score": 0.00228, "epss_percentile": 0.45473}, "CVE-2024-34212": {"epss_score": 0.0041, "epss_percentile": 0.60819}, "CVE-2024-34213": {"epss_score": 0.00463, "epss_percentile": 0.63668}, "CVE-2024-34215": {"epss_score": 0.0032, "epss_percentile": 0.54578}, "CVE-2024-34217": {"epss_score": 0.00451, "epss_percentile": 0.63124}, "CVE-2024-34218": {"epss_score": 0.00435, "epss_percentile": 0.62373}, "CVE-2024-34219": {"epss_score": 0.00368, "epss_percentile": 0.58197}, "CVE-2024-34220": {"epss_score": 0.00422, "epss_percentile": 0.61551}, "CVE-2024-34221": {"epss_score": 0.00228, "epss_percentile": 0.45492}, "CVE-2024-34222": {"epss_score": 0.00059, "epss_percentile": 0.18669}, "CVE-2024-34223": {"epss_score": 0.00187, "epss_percentile": 0.40803}, "CVE-2024-34224": {"epss_score": 0.0115, "epss_percentile": 0.78026}, "CVE-2024-34225": {"epss_score": 0.00458, "epss_percentile": 0.63425}, "CVE-2024-34226": {"epss_score": 0.00257, "epss_percentile": 0.48881}, "CVE-2024-34230": {"epss_score": 0.00378, "epss_percentile": 0.58834}, "CVE-2024-34231": {"epss_score": 0.00248, "epss_percentile": 0.47921}, "CVE-2024-34235": {"epss_score": 0.00094, "epss_percentile": 0.27012}, "CVE-2024-34240": {"epss_score": 0.00331, "epss_percentile": 0.55504}, "CVE-2024-34241": {"epss_score": 0.01054, "epss_percentile": 0.77107}, "CVE-2024-34243": {"epss_score": 0.00286, "epss_percentile": 0.51746}, "CVE-2024-34244": {"epss_score": 0.0056, "epss_percentile": 0.67653}, "CVE-2024-34245": {"epss_score": 0.00432, "epss_percentile": 0.62133}, "CVE-2024-34246": {"epss_score": 0.00551, "epss_percentile": 0.67351}, "CVE-2024-34249": {"epss_score": 0.00931, "epss_percentile": 0.75607}, "CVE-2024-34250": {"epss_score": 0.00109, "epss_percentile": 0.30036}, "CVE-2024-34251": {"epss_score": 0.00332, "epss_percentile": 0.55612}, "CVE-2024-34252": {"epss_score": 0.00528, "epss_percentile": 0.6657}, "CVE-2024-34255": {"epss_score": 0.00327, "epss_percentile": 0.55128}, "CVE-2024-34256": {"epss_score": 0.00369, "epss_percentile": 0.5823}, "CVE-2024-34257": {"epss_score": 0.88714, "epss_percentile": 0.99486}, "CVE-2024-34273": {"epss_score": 0.00087, "epss_percentile": 0.25527}, "CVE-2024-34274": {"epss_score": 0.00109, "epss_percentile": 0.29952}, "CVE-2024-34308": {"epss_score": 0.00105, "epss_percentile": 0.29352}, "CVE-2024-34310": {"epss_score": 0.00498, "epss_percentile": 0.65229}, "CVE-2024-34312": {"epss_score": 0.01308, "epss_percentile": 0.79348}, "CVE-2024-34313": {"epss_score": 0.24702, "epss_percentile": 0.95947}, "CVE-2024-34314": {"epss_score": 0.00159, "epss_percentile": 0.37362}, "CVE-2024-34315": {"epss_score": 0.00353, "epss_percentile": 0.57149}, "CVE-2024-34327": {"epss_score": 0.00037, "epss_percentile": 0.10655}, "CVE-2024-34328": {"epss_score": 0.00037, "epss_percentile": 0.11038}, "CVE-2024-34329": {"epss_score": 0.10119, "epss_percentile": 0.92857}, "CVE-2024-34331": {"epss_score": 0.00395, "epss_percentile": 0.59846}, "CVE-2024-34332": {"epss_score": 0.00035, "epss_percentile": 0.10058}, "CVE-2024-34334": {"epss_score": 0.00056, "epss_percentile": 0.17823}, "CVE-2024-34335": {"epss_score": 0.0013, "epss_percentile": 0.3329}, "CVE-2024-34336": {"epss_score": 0.00121, "epss_percentile": 0.32}, "CVE-2024-34338": {"epss_score": 0.02548, "epss_percentile": 0.85067}, "CVE-2024-34340": {"epss_score": 0.00878, "epss_percentile": 0.74824}, "CVE-2024-34341": {"epss_score": 0.00406, "epss_percentile": 0.60559}, "CVE-2024-34342": {"epss_score": 0.05029, "epss_percentile": 0.89413}, "CVE-2024-34343": {"epss_score": 0.0017, "epss_percentile": 0.38701}, "CVE-2024-34344": {"epss_score": 0.01315, "epss_percentile": 0.79404}, "CVE-2024-34345": {"epss_score": 0.00079, "epss_percentile": 0.23993}, "CVE-2024-34346": {"epss_score": 0.00103, "epss_percentile": 0.2905}, "CVE-2024-34347": {"epss_score": 0.00124, "epss_percentile": 0.32378}, "CVE-2024-34349": {"epss_score": 0.00068, "epss_percentile": 0.21383}, "CVE-2024-34350": {"epss_score": 0.00635, "epss_percentile": 0.69822}, "CVE-2024-34351": {"epss_score": 0.9232, "epss_percentile": 0.99706}, "CVE-2024-34352": {"epss_score": 0.0244, "epss_percentile": 0.84752}, "CVE-2024-34353": {"epss_score": 0.00047, "epss_percentile": 0.14778}, "CVE-2024-34354": {"epss_score": 0.00186, "epss_percentile": 0.4066}, "CVE-2024-34355": {"epss_score": 0.00615, "epss_percentile": 0.69311}, "CVE-2024-34356": {"epss_score": 0.00634, "epss_percentile": 0.69795}, "CVE-2024-34357": {"epss_score": 0.00634, "epss_percentile": 0.69795}, "CVE-2024-34358": {"epss_score": 0.0005, "epss_percentile": 0.15902}, "CVE-2024-34359": {"epss_score": 0.5917, "epss_percentile": 0.98153}, "CVE-2024-34360": {"epss_score": 0.00094, "epss_percentile": 0.27038}, "CVE-2024-34361": {"epss_score": 0.58179, "epss_percentile": 0.98101}, "CVE-2024-34362": {"epss_score": 0.00021, "epss_percentile": 0.04754}, "CVE-2024-34363": {"epss_score": 0.00028, "epss_percentile": 0.07492}, "CVE-2024-34364": {"epss_score": 0.00023, "epss_percentile": 0.05458}, "CVE-2024-34365": {"epss_score": 0.00386, "epss_percentile": 0.59271}, "CVE-2024-34366": {"epss_score": 0.00118, "epss_percentile": 0.31475}, "CVE-2024-34367": {"epss_score": 0.00136, "epss_percentile": 0.3406}, "CVE-2024-34368": {"epss_score": 0.00366, "epss_percentile": 0.58053}, "CVE-2024-34369": {"epss_score": 0.00186, "epss_percentile": 0.40583}, "CVE-2024-34370": {"epss_score": 0.06952, "epss_percentile": 0.91142}, "CVE-2024-34371": {"epss_score": 0.00148, "epss_percentile": 0.35909}, "CVE-2024-34372": {"epss_score": 0.00289, "epss_percentile": 0.5202}, "CVE-2024-34373": {"epss_score": 0.0012, "epss_percentile": 0.31731}, "CVE-2024-34374": {"epss_score": 0.00163, "epss_percentile": 0.37842}, "CVE-2024-34375": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-34376": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-34377": {"epss_score": 0.00231, "epss_percentile": 0.45777}, "CVE-2024-34378": {"epss_score": 0.00108, "epss_percentile": 0.29827}, "CVE-2024-34379": {"epss_score": 0.00129, "epss_percentile": 0.3319}, "CVE-2024-34380": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-34381": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-34382": {"epss_score": 0.00366, "epss_percentile": 0.58053}, "CVE-2024-34383": {"epss_score": 0.00101, "epss_percentile": 0.28591}, "CVE-2024-34384": {"epss_score": 0.00805, "epss_percentile": 0.73638}, "CVE-2024-34385": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-34386": {"epss_score": 0.00225, "epss_percentile": 0.45231}, "CVE-2024-34387": {"epss_score": 0.00134, "epss_percentile": 0.33864}, "CVE-2024-34388": {"epss_score": 0.00649, "epss_percentile": 0.70228}, "CVE-2024-34389": {"epss_score": 0.00148, "epss_percentile": 0.35909}, "CVE-2024-34390": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-34391": {"epss_score": 0.03183, "epss_percentile": 0.86584}, "CVE-2024-34392": {"epss_score": 0.03183, "epss_percentile": 0.86584}, "CVE-2024-34393": {"epss_score": 0.0326, "epss_percentile": 0.8677}, "CVE-2024-34394": {"epss_score": 0.0326, "epss_percentile": 0.8677}, "CVE-2024-34397": {"epss_score": 0.0019, "epss_percentile": 0.41077}, "CVE-2024-34398": {"epss_score": 0.00055, "epss_percentile": 0.17461}, "CVE-2024-34399": {"epss_score": 0.01376, "epss_percentile": 0.79836}, "CVE-2024-34400": {"epss_score": 0.00166, "epss_percentile": 0.38141}, "CVE-2024-34401": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2024-34402": {"epss_score": 0.00459, "epss_percentile": 0.63477}, "CVE-2024-34403": {"epss_score": 0.00352, "epss_percentile": 0.57125}, "CVE-2024-34404": {"epss_score": 0.00036, "epss_percentile": 0.10257}, "CVE-2024-34405": {"epss_score": 0.00237, "epss_percentile": 0.46691}, "CVE-2024-34406": {"epss_score": 0.00153, "epss_percentile": 0.36523}, "CVE-2024-34408": {"epss_score": 0.00071, "epss_percentile": 0.22078}, "CVE-2024-34411": {"epss_score": 0.0076, "epss_percentile": 0.72815}, "CVE-2024-34412": {"epss_score": 0.00224, "epss_percentile": 0.45042}, "CVE-2024-34413": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-34414": {"epss_score": 0.00313, "epss_percentile": 0.54075}, "CVE-2024-34415": {"epss_score": 0.00197, "epss_percentile": 0.41947}, "CVE-2024-34416": {"epss_score": 0.0053, "epss_percentile": 0.66629}, "CVE-2024-34417": {"epss_score": 0.00187, "epss_percentile": 0.40699}, "CVE-2024-34418": {"epss_score": 0.00187, "epss_percentile": 0.40699}, "CVE-2024-34419": {"epss_score": 0.00279, "epss_percentile": 0.50964}, "CVE-2024-34420": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-34421": {"epss_score": 0.00197, "epss_percentile": 0.41947}, "CVE-2024-34422": {"epss_score": 0.00279, "epss_percentile": 0.50964}, "CVE-2024-34423": {"epss_score": 0.00279, "epss_percentile": 0.50964}, "CVE-2024-34424": {"epss_score": 0.00279, "epss_percentile": 0.50964}, "CVE-2024-34425": {"epss_score": 0.00277, "epss_percentile": 0.50825}, "CVE-2024-34426": {"epss_score": 0.00279, "epss_percentile": 0.50964}, "CVE-2024-34427": {"epss_score": 0.00121, "epss_percentile": 0.31874}, "CVE-2024-34428": {"epss_score": 0.00279, "epss_percentile": 0.50964}, "CVE-2024-34429": {"epss_score": 0.00279, "epss_percentile": 0.50964}, "CVE-2024-34430": {"epss_score": 0.00279, "epss_percentile": 0.50964}, "CVE-2024-34431": {"epss_score": 0.00295, "epss_percentile": 0.52453}, "CVE-2024-34432": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-34433": {"epss_score": 0.00417, "epss_percentile": 0.61221}, "CVE-2024-34434": {"epss_score": 0.00171, "epss_percentile": 0.38863}, "CVE-2024-34435": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-34436": {"epss_score": 0.00181, "epss_percentile": 0.40013}, "CVE-2024-34437": {"epss_score": 0.00135, "epss_percentile": 0.33964}, "CVE-2024-34439": {"epss_score": 0.00121, "epss_percentile": 0.31875}, "CVE-2024-34440": {"epss_score": 0.00737, "epss_percentile": 0.72328}, "CVE-2024-34441": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2024-34442": {"epss_score": 0.00117, "epss_percentile": 0.31296}, "CVE-2024-34443": {"epss_score": 0.00167, "epss_percentile": 0.38382}, "CVE-2024-34444": {"epss_score": 0.00665, "epss_percentile": 0.70664}, "CVE-2024-34445": {"epss_score": 0.00163, "epss_percentile": 0.37791}, "CVE-2024-34446": {"epss_score": 0.00169, "epss_percentile": 0.38632}, "CVE-2024-34447": {"epss_score": 0.00227, "epss_percentile": 0.45377}, "CVE-2024-34448": {"epss_score": 0.0017, "epss_percentile": 0.38713}, "CVE-2024-34449": {"epss_score": 0.00193, "epss_percentile": 0.41399}, "CVE-2024-34451": {"epss_score": 0.0069, "epss_percentile": 0.71258}, "CVE-2024-34452": {"epss_score": 0.00392, "epss_percentile": 0.59676}, "CVE-2024-34453": {"epss_score": 0.00184, "epss_percentile": 0.40386}, "CVE-2024-34454": {"epss_score": 0.00139, "epss_percentile": 0.34552}, "CVE-2024-34455": {"epss_score": 0.0019, "epss_percentile": 0.411}, "CVE-2024-34457": {"epss_score": 0.002, "epss_percentile": 0.42264}, "CVE-2024-34458": {"epss_score": 0.0057, "epss_percentile": 0.67941}, "CVE-2024-34459": {"epss_score": 0.00847, "epss_percentile": 0.74346}, "CVE-2024-34460": {"epss_score": 0.00043, "epss_percentile": 0.13294}, "CVE-2024-34461": {"epss_score": 0.00134, "epss_percentile": 0.33837}, "CVE-2024-34462": {"epss_score": 0.00104, "epss_percentile": 0.29101}, "CVE-2024-34463": {"epss_score": 0.02273, "epss_percentile": 0.84221}, "CVE-2024-34467": {"epss_score": 0.00054, "epss_percentile": 0.17066}, "CVE-2024-34468": {"epss_score": 0.0047, "epss_percentile": 0.63963}, "CVE-2024-34469": {"epss_score": 0.01169, "epss_percentile": 0.78199}, "CVE-2024-34470": {"epss_score": 0.9293, "epss_percentile": 0.99761}, "CVE-2024-34471": {"epss_score": 0.01695, "epss_percentile": 0.81806}, "CVE-2024-34472": {"epss_score": 0.02316, "epss_percentile": 0.84356}, "CVE-2024-34473": {"epss_score": 0.00069, "epss_percentile": 0.21459}, "CVE-2024-34474": {"epss_score": 0.00165, "epss_percentile": 0.38101}, "CVE-2024-34475": {"epss_score": 0.00207, "epss_percentile": 0.43141}, "CVE-2024-34476": {"epss_score": 0.00082, "epss_percentile": 0.24569}, "CVE-2024-34477": {"epss_score": 0.00186, "epss_percentile": 0.40691}, "CVE-2024-34478": {"epss_score": 0.00082, "epss_percentile": 0.24403}, "CVE-2024-34479": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2024-34480": {"epss_score": 0.00255, "epss_percentile": 0.48654}, "CVE-2024-34481": {"epss_score": 0.00169, "epss_percentile": 0.38626}, "CVE-2024-34483": {"epss_score": 0.00547, "epss_percentile": 0.67231}, "CVE-2024-34484": {"epss_score": 0.00475, "epss_percentile": 0.64197}, "CVE-2024-34486": {"epss_score": 0.00173, "epss_percentile": 0.39118}, "CVE-2024-34487": {"epss_score": 0.00547, "epss_percentile": 0.67231}, "CVE-2024-34488": {"epss_score": 0.00547, "epss_percentile": 0.67231}, "CVE-2024-34489": {"epss_score": 0.00547, "epss_percentile": 0.67231}, "CVE-2024-34490": {"epss_score": 0.0002, "epss_percentile": 0.04485}, "CVE-2024-34500": {"epss_score": 0.00299, "epss_percentile": 0.52883}, "CVE-2024-34502": {"epss_score": 0.00159, "epss_percentile": 0.37343}, "CVE-2024-34506": {"epss_score": 0.00171, "epss_percentile": 0.38821}, "CVE-2024-34507": {"epss_score": 0.00442, "epss_percentile": 0.62709}, "CVE-2024-34508": {"epss_score": 0.00058, "epss_percentile": 0.18273}, "CVE-2024-34509": {"epss_score": 0.00113, "epss_percentile": 0.30649}, "CVE-2024-34510": {"epss_score": 0.00092, "epss_percentile": 0.266}, "CVE-2024-34515": {"epss_score": 0.00151, "epss_percentile": 0.36322}, "CVE-2024-34517": {"epss_score": 0.00207, "epss_percentile": 0.43126}, "CVE-2024-34519": {"epss_score": 0.00026, "epss_percentile": 0.06582}, "CVE-2024-34520": {"epss_score": 0.00127, "epss_percentile": 0.32792}, "CVE-2024-34521": {"epss_score": 0.00089, "epss_percentile": 0.25854}, "CVE-2024-34523": {"epss_score": 0.00173, "epss_percentile": 0.39104}, "CVE-2024-34524": {"epss_score": 0.00059, "epss_percentile": 0.18778}, "CVE-2024-34525": {"epss_score": 0.00026, "epss_percentile": 0.06666}, "CVE-2024-34527": {"epss_score": 0.00109, "epss_percentile": 0.29971}, "CVE-2024-34528": {"epss_score": 0.00029, "epss_percentile": 0.07941}, "CVE-2024-34529": {"epss_score": 0.00098, "epss_percentile": 0.27636}, "CVE-2024-34532": {"epss_score": 0.00589, "epss_percentile": 0.68512}, "CVE-2024-34533": {"epss_score": 0.00255, "epss_percentile": 0.48706}, "CVE-2024-34534": {"epss_score": 0.00255, "epss_percentile": 0.48706}, "CVE-2024-34535": {"epss_score": 0.00053, "epss_percentile": 0.16858}, "CVE-2024-34537": {"epss_score": 0.00249, "epss_percentile": 0.48025}, "CVE-2024-34538": {"epss_score": 0.00094, "epss_percentile": 0.2696}, "CVE-2024-34539": {"epss_score": 0.00523, "epss_percentile": 0.66311}, "CVE-2024-34542": {"epss_score": 0.00064, "epss_percentile": 0.20258}, "CVE-2024-34543": {"epss_score": 0.00143, "epss_percentile": 0.35094}, "CVE-2024-34544": {"epss_score": 0.01417, "epss_percentile": 0.80145}, "CVE-2024-34545": {"epss_score": 0.00128, "epss_percentile": 0.3301}, "CVE-2024-34546": {"epss_score": 0.00229, "epss_percentile": 0.45652}, "CVE-2024-34547": {"epss_score": 0.00287, "epss_percentile": 0.5183}, "CVE-2024-34548": {"epss_score": 0.00329, "epss_percentile": 0.55409}, "CVE-2024-34549": {"epss_score": 0.00317, "epss_percentile": 0.54341}, "CVE-2024-34550": {"epss_score": 0.00317, "epss_percentile": 0.54341}, "CVE-2024-34551": {"epss_score": 0.00645, "epss_percentile": 0.70109}, "CVE-2024-34552": {"epss_score": 0.00645, "epss_percentile": 0.70121}, "CVE-2024-34553": {"epss_score": 0.00308, "epss_percentile": 0.5357}, "CVE-2024-34554": {"epss_score": 0.00645, "epss_percentile": 0.70121}, "CVE-2024-34555": {"epss_score": 0.07909, "epss_percentile": 0.91756}, "CVE-2024-34556": {"epss_score": 0.00317, "epss_percentile": 0.54341}, "CVE-2024-34557": {"epss_score": 0.00121, "epss_percentile": 0.31833}, "CVE-2024-34558": {"epss_score": 0.00225, "epss_percentile": 0.45142}, "CVE-2024-34559": {"epss_score": 0.00729, "epss_percentile": 0.72128}, "CVE-2024-34560": {"epss_score": 0.00218, "epss_percentile": 0.44418}, "CVE-2024-34561": {"epss_score": 0.00218, "epss_percentile": 0.44418}, "CVE-2024-34562": {"epss_score": 0.00287, "epss_percentile": 0.5183}, "CVE-2024-34563": {"epss_score": 0.00313, "epss_percentile": 0.54075}, "CVE-2024-34564": {"epss_score": 0.00313, "epss_percentile": 0.54075}, "CVE-2024-34565": {"epss_score": 0.00218, "epss_percentile": 0.44418}, "CVE-2024-34566": {"epss_score": 0.00287, "epss_percentile": 0.5183}, "CVE-2024-34567": {"epss_score": 0.00249, "epss_percentile": 0.48085}, "CVE-2024-34568": {"epss_score": 0.00171, "epss_percentile": 0.38831}, "CVE-2024-34569": {"epss_score": 0.00313, "epss_percentile": 0.54075}, "CVE-2024-34570": {"epss_score": 0.00225, "epss_percentile": 0.45142}, "CVE-2024-34571": {"epss_score": 0.00313, "epss_percentile": 0.54075}, "CVE-2024-34572": {"epss_score": 0.00242, "epss_percentile": 0.47341}, "CVE-2024-34573": {"epss_score": 0.00178, "epss_percentile": 0.39736}, "CVE-2024-34574": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2024-34575": {"epss_score": 0.00333, "epss_percentile": 0.55665}, "CVE-2024-34577": {"epss_score": 0.00718, "epss_percentile": 0.7193}, "CVE-2024-34579": {"epss_score": 0.00125, "epss_percentile": 0.32563}, "CVE-2024-34580": {"epss_score": 0.00019, "epss_percentile": 0.04132}, "CVE-2024-34581": {"epss_score": 0.00097, "epss_percentile": 0.27499}, "CVE-2024-34582": {"epss_score": 0.00166, "epss_percentile": 0.38255}, "CVE-2024-34583": {"epss_score": 0.00114, "epss_percentile": 0.30844}, "CVE-2024-34585": {"epss_score": 0.00079, "epss_percentile": 0.23898}, "CVE-2024-34586": {"epss_score": 0.00078, "epss_percentile": 0.23776}, "CVE-2024-34587": {"epss_score": 0.01014, "epss_percentile": 0.76649}, "CVE-2024-34588": {"epss_score": 0.01059, "epss_percentile": 0.7715}, "CVE-2024-34589": {"epss_score": 0.01059, "epss_percentile": 0.7715}, "CVE-2024-34590": {"epss_score": 0.00555, "epss_percentile": 0.67463}, "CVE-2024-34591": {"epss_score": 0.00555, "epss_percentile": 0.67463}, "CVE-2024-34592": {"epss_score": 0.00555, "epss_percentile": 0.67463}, "CVE-2024-34593": {"epss_score": 0.01449, "epss_percentile": 0.80338}, "CVE-2024-34594": {"epss_score": 0.00099, "epss_percentile": 0.28369}, "CVE-2024-34595": {"epss_score": 0.00079, "epss_percentile": 0.23898}, "CVE-2024-34596": {"epss_score": 0.00267, "epss_percentile": 0.49974}, "CVE-2024-34597": {"epss_score": 0.00059, "epss_percentile": 0.1871}, "CVE-2024-34598": {"epss_score": 0.00024, "epss_percentile": 0.05963}, "CVE-2024-34599": {"epss_score": 0.00094, "epss_percentile": 0.26966}, "CVE-2024-34600": {"epss_score": 0.00099, "epss_percentile": 0.27861}, "CVE-2024-34601": {"epss_score": 0.00105, "epss_percentile": 0.29282}, "CVE-2024-34602": {"epss_score": 0.001, "epss_percentile": 0.28524}, "CVE-2024-34603": {"epss_score": 0.00099, "epss_percentile": 0.28339}, "CVE-2024-34604": {"epss_score": 0.00016, "epss_percentile": 0.02755}, "CVE-2024-34605": {"epss_score": 0.00016, "epss_percentile": 0.02755}, "CVE-2024-34606": {"epss_score": 0.00016, "epss_percentile": 0.02755}, "CVE-2024-34607": {"epss_score": 0.00016, "epss_percentile": 0.02755}, "CVE-2024-34608": {"epss_score": 0.00016, "epss_percentile": 0.02755}, "CVE-2024-34609": {"epss_score": 0.00016, "epss_percentile": 0.02755}, "CVE-2024-34610": {"epss_score": 0.00085, "epss_percentile": 0.25158}, "CVE-2024-34611": {"epss_score": 0.00066, "epss_percentile": 0.2075}, "CVE-2024-34612": {"epss_score": 0.00154, "epss_percentile": 0.36655}, "CVE-2024-34613": {"epss_score": 0.00116, "epss_percentile": 0.31077}, "CVE-2024-34614": {"epss_score": 0.00154, "epss_percentile": 0.36655}, "CVE-2024-34615": {"epss_score": 0.00145, "epss_percentile": 0.35427}, "CVE-2024-34616": {"epss_score": 0.00116, "epss_percentile": 0.31077}, "CVE-2024-34617": {"epss_score": 0.00099, "epss_percentile": 0.284}, "CVE-2024-34618": {"epss_score": 0.00134, "epss_percentile": 0.3379}, "CVE-2024-34619": {"epss_score": 0.01544, "epss_percentile": 0.80958}, "CVE-2024-34620": {"epss_score": 0.00114, "epss_percentile": 0.30803}, "CVE-2024-34621": {"epss_score": 0.00119, "epss_percentile": 0.31604}, "CVE-2024-34622": {"epss_score": 0.00118, "epss_percentile": 0.31402}, "CVE-2024-34623": {"epss_score": 0.00118, "epss_percentile": 0.31402}, "CVE-2024-34624": {"epss_score": 0.00184, "epss_percentile": 0.40444}, "CVE-2024-34625": {"epss_score": 0.00184, "epss_percentile": 0.40444}, "CVE-2024-34626": {"epss_score": 0.00184, "epss_percentile": 0.40444}, "CVE-2024-34627": {"epss_score": 0.0021, "epss_percentile": 0.43494}, "CVE-2024-34628": {"epss_score": 0.00184, "epss_percentile": 0.40444}, "CVE-2024-34629": {"epss_score": 0.00184, "epss_percentile": 0.40444}, "CVE-2024-34630": {"epss_score": 0.00184, "epss_percentile": 0.40444}, "CVE-2024-34631": {"epss_score": 0.00184, "epss_percentile": 0.40444}, "CVE-2024-34632": {"epss_score": 0.00231, "epss_percentile": 0.45856}, "CVE-2024-34633": {"epss_score": 0.00231, "epss_percentile": 0.45856}, "CVE-2024-34634": {"epss_score": 0.00231, "epss_percentile": 0.45856}, "CVE-2024-34635": {"epss_score": 0.00231, "epss_percentile": 0.45856}, "CVE-2024-34636": {"epss_score": 0.00116, "epss_percentile": 0.31077}, "CVE-2024-34637": {"epss_score": 0.0001, "epss_percentile": 0.00788}, "CVE-2024-34638": {"epss_score": 0.00046, "epss_percentile": 0.14147}, "CVE-2024-34639": {"epss_score": 0.00023, "epss_percentile": 0.05351}, "CVE-2024-34640": {"epss_score": 9e-05, "epss_percentile": 0.00607}, "CVE-2024-34641": {"epss_score": 0.00038, "epss_percentile": 0.11324}, "CVE-2024-34642": {"epss_score": 0.00063, "epss_percentile": 0.19804}, "CVE-2024-34643": {"epss_score": 0.0004, "epss_percentile": 0.12047}, "CVE-2024-34644": {"epss_score": 0.00074, "epss_percentile": 0.22727}, "CVE-2024-34645": {"epss_score": 0.00092, "epss_percentile": 0.26522}, "CVE-2024-34646": {"epss_score": 0.00074, "epss_percentile": 0.22876}, "CVE-2024-34647": {"epss_score": 0.00073, "epss_percentile": 0.22536}, "CVE-2024-34648": {"epss_score": 0.00053, "epss_percentile": 0.16859}, "CVE-2024-34649": {"epss_score": 0.00147, "epss_percentile": 0.35677}, "CVE-2024-34650": {"epss_score": 0.00084, "epss_percentile": 0.24931}, "CVE-2024-34651": {"epss_score": 0.00066, "epss_percentile": 0.20819}, "CVE-2024-34652": {"epss_score": 0.00084, "epss_percentile": 0.24931}, "CVE-2024-34653": {"epss_score": 0.0017, "epss_percentile": 0.38742}, "CVE-2024-34654": {"epss_score": 0.00065, "epss_percentile": 0.20614}, "CVE-2024-34655": {"epss_score": 0.00065, "epss_percentile": 0.20614}, "CVE-2024-34656": {"epss_score": 0.00084, "epss_percentile": 0.24959}, "CVE-2024-34657": {"epss_score": 0.02206, "epss_percentile": 0.84002}, "CVE-2024-34658": {"epss_score": 0.00014, "epss_percentile": 0.01896}, "CVE-2024-34659": {"epss_score": 0.00331, "epss_percentile": 0.55545}, "CVE-2024-34660": {"epss_score": 0.00071, "epss_percentile": 0.22127}, "CVE-2024-34661": {"epss_score": 0.00294, "epss_percentile": 0.52396}, "CVE-2024-34662": {"epss_score": 0.00062, "epss_percentile": 0.19765}, "CVE-2024-34663": {"epss_score": 0.00037, "epss_percentile": 0.11038}, "CVE-2024-34664": {"epss_score": 0.00014, "epss_percentile": 0.01747}, "CVE-2024-34665": {"epss_score": 0.03822, "epss_percentile": 0.87786}, "CVE-2024-34666": {"epss_score": 0.03822, "epss_percentile": 0.87786}, "CVE-2024-34667": {"epss_score": 0.03822, "epss_percentile": 0.87786}, "CVE-2024-34668": {"epss_score": 0.03822, "epss_percentile": 0.87786}, "CVE-2024-34669": {"epss_score": 0.03822, "epss_percentile": 0.87786}, "CVE-2024-34670": {"epss_score": 0.0004, "epss_percentile": 0.12193}, "CVE-2024-34671": {"epss_score": 0.00074, "epss_percentile": 0.22727}, "CVE-2024-34672": {"epss_score": 0.00044, "epss_percentile": 0.13367}, "CVE-2024-34673": {"epss_score": 0.00049, "epss_percentile": 0.15587}, "CVE-2024-34674": {"epss_score": 0.00158, "epss_percentile": 0.37185}, "CVE-2024-34675": {"epss_score": 0.0015, "epss_percentile": 0.36178}, "CVE-2024-34676": {"epss_score": 0.00165, "epss_percentile": 0.38126}, "CVE-2024-34677": {"epss_score": 0.00111, "epss_percentile": 0.30316}, "CVE-2024-34678": {"epss_score": 0.00138, "epss_percentile": 0.34502}, "CVE-2024-34679": {"epss_score": 0.00064, "epss_percentile": 0.20402}, "CVE-2024-34680": {"epss_score": 0.00085, "epss_percentile": 0.25158}, "CVE-2024-34681": {"epss_score": 0.00067, "epss_percentile": 0.21126}, "CVE-2024-34682": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-34683": {"epss_score": 0.00244, "epss_percentile": 0.47595}, "CVE-2024-34684": {"epss_score": 0.00112, "epss_percentile": 0.30539}, "CVE-2024-34685": {"epss_score": 0.00642, "epss_percentile": 0.70033}, "CVE-2024-34686": {"epss_score": 0.00481, "epss_percentile": 0.64501}, "CVE-2024-34687": {"epss_score": 0.0013, "epss_percentile": 0.33327}, "CVE-2024-34688": {"epss_score": 0.00546, "epss_percentile": 0.67205}, "CVE-2024-34689": {"epss_score": 0.00278, "epss_percentile": 0.50889}, "CVE-2024-34690": {"epss_score": 0.00329, "epss_percentile": 0.55391}, "CVE-2024-34691": {"epss_score": 0.00192, "epss_percentile": 0.41283}, "CVE-2024-34692": {"epss_score": 0.00388, "epss_percentile": 0.59364}, "CVE-2024-34693": {"epss_score": 0.12369, "epss_percentile": 0.93652}, "CVE-2024-34694": {"epss_score": 0.00069, "epss_percentile": 0.2162}, "CVE-2024-34695": {"epss_score": 0.00392, "epss_percentile": 0.59686}, "CVE-2024-34696": {"epss_score": 0.00418, "epss_percentile": 0.6128}, "CVE-2024-34697": {"epss_score": 0.00645, "epss_percentile": 0.701}, "CVE-2024-34698": {"epss_score": 0.00788, "epss_percentile": 0.73331}, "CVE-2024-34699": {"epss_score": 0.00276, "epss_percentile": 0.50706}, "CVE-2024-34701": {"epss_score": 0.00375, "epss_percentile": 0.58601}, "CVE-2024-34702": {"epss_score": 0.00487, "epss_percentile": 0.64817}, "CVE-2024-34703": {"epss_score": 0.00201, "epss_percentile": 0.42331}, "CVE-2024-34704": {"epss_score": 0.00304, "epss_percentile": 0.53304}, "CVE-2024-34706": {"epss_score": 0.00126, "epss_percentile": 0.32749}, "CVE-2024-34707": {"epss_score": 0.00266, "epss_percentile": 0.49887}, "CVE-2024-34708": {"epss_score": 0.00343, "epss_percentile": 0.56435}, "CVE-2024-34709": {"epss_score": 0.00226, "epss_percentile": 0.45297}, "CVE-2024-34710": {"epss_score": 0.00301, "epss_percentile": 0.53082}, "CVE-2024-34711": {"epss_score": 0.00081, "epss_percentile": 0.24365}, "CVE-2024-34712": {"epss_score": 0.00233, "epss_percentile": 0.46064}, "CVE-2024-34713": {"epss_score": 0.0027, "epss_percentile": 0.5025}, "CVE-2024-34714": {"epss_score": 0.00304, "epss_percentile": 0.53243}, "CVE-2024-34715": {"epss_score": 0.00103, "epss_percentile": 0.29044}, "CVE-2024-34716": {"epss_score": 0.36665, "epss_percentile": 0.96993}, "CVE-2024-34717": {"epss_score": 0.00403, "epss_percentile": 0.6032}, "CVE-2024-34719": {"epss_score": 7e-05, "epss_percentile": 0.00386}, "CVE-2024-34720": {"epss_score": 0.00038, "epss_percentile": 0.1132}, "CVE-2024-34721": {"epss_score": 0.00029, "epss_percentile": 0.07902}, "CVE-2024-34722": {"epss_score": 0.00149, "epss_percentile": 0.35944}, "CVE-2024-34723": {"epss_score": 0.00027, "epss_percentile": 0.06853}, "CVE-2024-34724": {"epss_score": 0.00017, "epss_percentile": 0.03199}, "CVE-2024-34725": {"epss_score": 0.00017, "epss_percentile": 0.03225}, "CVE-2024-34726": {"epss_score": 0.00029, "epss_percentile": 0.07898}, "CVE-2024-34727": {"epss_score": 0.00415, "epss_percentile": 0.61115}, "CVE-2024-34729": {"epss_score": 0.00064, "epss_percentile": 0.20351}, "CVE-2024-34730": {"epss_score": 0.00014, "epss_percentile": 0.01863}, "CVE-2024-34731": {"epss_score": 0.00021, "epss_percentile": 0.04884}, "CVE-2024-34732": {"epss_score": 0.00024, "epss_percentile": 0.06032}, "CVE-2024-34733": {"epss_score": 0.0003, "epss_percentile": 0.08193}, "CVE-2024-34734": {"epss_score": 0.00068, "epss_percentile": 0.21296}, "CVE-2024-34736": {"epss_score": 0.00054, "epss_percentile": 0.17214}, "CVE-2024-34737": {"epss_score": 0.00055, "epss_percentile": 0.17463}, "CVE-2024-34738": {"epss_score": 0.0005, "epss_percentile": 0.15967}, "CVE-2024-34739": {"epss_score": 0.00555, "epss_percentile": 0.67496}, "CVE-2024-34740": {"epss_score": 0.00128, "epss_percentile": 0.33069}, "CVE-2024-34741": {"epss_score": 0.00365, "epss_percentile": 0.57978}, "CVE-2024-34742": {"epss_score": 0.00066, "epss_percentile": 0.20732}, "CVE-2024-34743": {"epss_score": 0.00045, "epss_percentile": 0.13984}, "CVE-2024-34747": {"epss_score": 0.00052, "epss_percentile": 0.16479}, "CVE-2024-34748": {"epss_score": 0.00034, "epss_percentile": 0.0953}, "CVE-2024-34749": {"epss_score": 0.00404, "epss_percentile": 0.6041}, "CVE-2024-34750": {"epss_score": 0.17245, "epss_percentile": 0.94805}, "CVE-2024-34751": {"epss_score": 0.00162, "epss_percentile": 0.37719}, "CVE-2024-34752": {"epss_score": 0.00562, "epss_percentile": 0.67705}, "CVE-2024-34753": {"epss_score": 0.00111, "epss_percentile": 0.30251}, "CVE-2024-34754": {"epss_score": 0.00274, "epss_percentile": 0.50513}, "CVE-2024-34755": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-34756": {"epss_score": 0.00129, "epss_percentile": 0.33172}, "CVE-2024-34757": {"epss_score": 0.00287, "epss_percentile": 0.5183}, "CVE-2024-34758": {"epss_score": 0.00373, "epss_percentile": 0.58528}, "CVE-2024-34759": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-34760": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-34761": {"epss_score": 0.00611, "epss_percentile": 0.69177}, "CVE-2024-34762": {"epss_score": 0.00645, "epss_percentile": 0.70121}, "CVE-2024-34763": {"epss_score": 0.00294, "epss_percentile": 0.52384}, "CVE-2024-34764": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-34765": {"epss_score": 0.00169, "epss_percentile": 0.3863}, "CVE-2024-34766": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-34767": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-34768": {"epss_score": 0.00206, "epss_percentile": 0.42925}, "CVE-2024-34769": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-34770": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-34771": {"epss_score": 0.00209, "epss_percentile": 0.43364}, "CVE-2024-34772": {"epss_score": 0.00177, "epss_percentile": 0.39537}, "CVE-2024-34773": {"epss_score": 0.00295, "epss_percentile": 0.52456}, "CVE-2024-34776": {"epss_score": 0.00042, "epss_percentile": 0.12484}, "CVE-2024-34777": {"epss_score": 0.0008, "epss_percentile": 0.24112}, "CVE-2024-34779": {"epss_score": 0.50062, "epss_percentile": 0.97718}, "CVE-2024-34780": {"epss_score": 0.05183, "epss_percentile": 0.89585}, "CVE-2024-34781": {"epss_score": 0.63705, "epss_percentile": 0.98346}, "CVE-2024-34782": {"epss_score": 0.05183, "epss_percentile": 0.89585}, "CVE-2024-34783": {"epss_score": 0.50062, "epss_percentile": 0.97718}, "CVE-2024-34784": {"epss_score": 0.05183, "epss_percentile": 0.89585}, "CVE-2024-34785": {"epss_score": 0.32185, "epss_percentile": 0.96677}, "CVE-2024-34786": {"epss_score": 0.00131, "epss_percentile": 0.33479}, "CVE-2024-34787": {"epss_score": 0.11898, "epss_percentile": 0.93509}, "CVE-2024-34788": {"epss_score": 0.08158, "epss_percentile": 0.91908}, "CVE-2024-34789": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-34790": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-34791": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-34792": {"epss_score": 0.01232, "epss_percentile": 0.78742}, "CVE-2024-34793": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-34794": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-34795": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-34796": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-34797": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-34798": {"epss_score": 0.00274, "epss_percentile": 0.50513}, "CVE-2024-34799": {"epss_score": 0.00146, "epss_percentile": 0.35544}, "CVE-2024-34800": {"epss_score": 0.0016, "epss_percentile": 0.37438}, "CVE-2024-34801": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-34802": {"epss_score": 0.0026, "epss_percentile": 0.49196}, "CVE-2024-34803": {"epss_score": 0.00113, "epss_percentile": 0.306}, "CVE-2024-34804": {"epss_score": 0.00145, "epss_percentile": 0.35502}, "CVE-2024-34805": {"epss_score": 0.0017, "epss_percentile": 0.3866}, "CVE-2024-34806": {"epss_score": 0.00129, "epss_percentile": 0.33172}, "CVE-2024-34807": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-34808": {"epss_score": 0.00395, "epss_percentile": 0.59832}, "CVE-2024-34809": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-34811": {"epss_score": 0.00164, "epss_percentile": 0.37999}, "CVE-2024-34812": {"epss_score": 0.00335, "epss_percentile": 0.55897}, "CVE-2024-34813": {"epss_score": 0.00206, "epss_percentile": 0.42925}, "CVE-2024-34814": {"epss_score": 0.00123, "epss_percentile": 0.32257}, "CVE-2024-34815": {"epss_score": 0.00152, "epss_percentile": 0.36471}, "CVE-2024-34816": {"epss_score": 0.00145, "epss_percentile": 0.35358}, "CVE-2024-34817": {"epss_score": 0.00162, "epss_percentile": 0.37681}, "CVE-2024-34818": {"epss_score": 0.00128, "epss_percentile": 0.3303}, "CVE-2024-34819": {"epss_score": 0.00117, "epss_percentile": 0.31296}, "CVE-2024-34820": {"epss_score": 0.00093, "epss_percentile": 0.26728}, "CVE-2024-34821": {"epss_score": 0.00111, "epss_percentile": 0.30392}, "CVE-2024-34822": {"epss_score": 0.00117, "epss_percentile": 0.31296}, "CVE-2024-34823": {"epss_score": 0.00121, "epss_percentile": 0.32006}, "CVE-2024-34824": {"epss_score": 0.00117, "epss_percentile": 0.31309}, "CVE-2024-34825": {"epss_score": 0.00121, "epss_percentile": 0.31874}, "CVE-2024-34826": {"epss_score": 0.00118, "epss_percentile": 0.31482}, "CVE-2024-34827": {"epss_score": 0.00129, "epss_percentile": 0.3319}, "CVE-2024-34828": {"epss_score": 0.00121, "epss_percentile": 0.32017}, "CVE-2024-34831": {"epss_score": 0.01468, "epss_percentile": 0.80481}, "CVE-2024-34832": {"epss_score": 0.10621, "epss_percentile": 0.93052}, "CVE-2024-34833": {"epss_score": 0.42053, "epss_percentile": 0.97307}, "CVE-2024-34852": {"epss_score": 0.02223, "epss_percentile": 0.84064}, "CVE-2024-34854": {"epss_score": 0.00768, "epss_percentile": 0.72968}, "CVE-2024-34882": {"epss_score": 0.00107, "epss_percentile": 0.29719}, "CVE-2024-34883": {"epss_score": 0.00103, "epss_percentile": 0.29056}, "CVE-2024-34885": {"epss_score": 0.00072, "epss_percentile": 0.22403}, "CVE-2024-34887": {"epss_score": 0.00107, "epss_percentile": 0.29719}, "CVE-2024-34891": {"epss_score": 0.00041, "epss_percentile": 0.12324}, "CVE-2024-34896": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2024-34897": {"epss_score": 0.00249, "epss_percentile": 0.48068}, "CVE-2024-34899": {"epss_score": 0.00117, "epss_percentile": 0.31261}, "CVE-2024-34905": {"epss_score": 0.00406, "epss_percentile": 0.60518}, "CVE-2024-34906": {"epss_score": 0.00167, "epss_percentile": 0.38365}, "CVE-2024-34909": {"epss_score": 0.00332, "epss_percentile": 0.55596}, "CVE-2024-34913": {"epss_score": 0.00309, "epss_percentile": 0.53656}, "CVE-2024-34914": {"epss_score": 0.00085, "epss_percentile": 0.2509}, "CVE-2024-34919": {"epss_score": 0.00201, "epss_percentile": 0.42286}, "CVE-2024-34921": {"epss_score": 0.01781, "epss_percentile": 0.82239}, "CVE-2024-34923": {"epss_score": 0.00322, "epss_percentile": 0.54798}, "CVE-2024-34927": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2024-34928": {"epss_score": 0.00076, "epss_percentile": 0.23236}, "CVE-2024-34929": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2024-34930": {"epss_score": 0.00051, "epss_percentile": 0.16329}, "CVE-2024-34931": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2024-34932": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2024-34933": {"epss_score": 0.00076, "epss_percentile": 0.23248}, "CVE-2024-34934": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2024-34935": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2024-34936": {"epss_score": 0.00084, "epss_percentile": 0.24901}, "CVE-2024-34942": {"epss_score": 0.00523, "epss_percentile": 0.66313}, "CVE-2024-34943": {"epss_score": 0.00394, "epss_percentile": 0.59785}, "CVE-2024-34944": {"epss_score": 0.0025, "epss_percentile": 0.48123}, "CVE-2024-34945": {"epss_score": 0.00394, "epss_percentile": 0.59785}, "CVE-2024-34946": {"epss_score": 0.00374, "epss_percentile": 0.58548}, "CVE-2024-34947": {"epss_score": 0.0023, "epss_percentile": 0.45763}, "CVE-2024-34948": {"epss_score": 0.00364, "epss_percentile": 0.5795}, "CVE-2024-34949": {"epss_score": 0.00173, "epss_percentile": 0.39048}, "CVE-2024-34950": {"epss_score": 0.11912, "epss_percentile": 0.93513}, "CVE-2024-34952": {"epss_score": 0.00075, "epss_percentile": 0.23063}, "CVE-2024-34953": {"epss_score": 0.00512, "epss_percentile": 0.65866}, "CVE-2024-34954": {"epss_score": 0.00507, "epss_percentile": 0.65678}, "CVE-2024-34955": {"epss_score": 0.00106, "epss_percentile": 0.29407}, "CVE-2024-34957": {"epss_score": 0.00439, "epss_percentile": 0.62585}, "CVE-2024-34958": {"epss_score": 0.02794, "epss_percentile": 0.85674}, "CVE-2024-34959": {"epss_score": 0.00153, "epss_percentile": 0.36525}, "CVE-2024-34974": {"epss_score": 0.00148, "epss_percentile": 0.35882}, "CVE-2024-34982": {"epss_score": 0.8022, "epss_percentile": 0.99077}, "CVE-2024-34987": {"epss_score": 0.00035, "epss_percentile": 0.09982}, "CVE-2024-34988": {"epss_score": 0.0019, "epss_percentile": 0.41141}, "CVE-2024-34989": {"epss_score": 0.00122, "epss_percentile": 0.32035}, "CVE-2024-34990": {"epss_score": 0.00396, "epss_percentile": 0.59859}, "CVE-2024-34991": {"epss_score": 0.0027, "epss_percentile": 0.50258}, "CVE-2024-34992": {"epss_score": 0.00191, "epss_percentile": 0.41164}, "CVE-2024-34993": {"epss_score": 0.0012, "epss_percentile": 0.31805}, "CVE-2024-34994": {"epss_score": 0.00218, "epss_percentile": 0.44373}, "CVE-2024-34995": {"epss_score": 0.00097, "epss_percentile": 0.27484}, "CVE-2024-34997": {"epss_score": 0.00484, "epss_percentile": 0.64658}, "CVE-2024-35009": {"epss_score": 0.00458, "epss_percentile": 0.63419}, "CVE-2024-35010": {"epss_score": 0.00458, "epss_percentile": 0.63419}, "CVE-2024-35011": {"epss_score": 0.00361, "epss_percentile": 0.5771}, "CVE-2024-35012": {"epss_score": 0.00214, "epss_percentile": 0.43948}, "CVE-2024-35039": {"epss_score": 0.00191, "epss_percentile": 0.41255}, "CVE-2024-35048": {"epss_score": 0.00141, "epss_percentile": 0.34933}, "CVE-2024-35049": {"epss_score": 0.00287, "epss_percentile": 0.51789}, "CVE-2024-35050": {"epss_score": 0.0024, "epss_percentile": 0.47183}, "CVE-2024-35056": {"epss_score": 0.00149, "epss_percentile": 0.36025}, "CVE-2024-35057": {"epss_score": 0.00048, "epss_percentile": 0.15132}, "CVE-2024-35058": {"epss_score": 0.00107, "epss_percentile": 0.29733}, "CVE-2024-35059": {"epss_score": 0.0007, "epss_percentile": 0.21956}, "CVE-2024-35060": {"epss_score": 0.00077, "epss_percentile": 0.23445}, "CVE-2024-35061": {"epss_score": 0.01474, "epss_percentile": 0.80517}, "CVE-2024-35079": {"epss_score": 0.00377, "epss_percentile": 0.58695}, "CVE-2024-35080": {"epss_score": 0.00377, "epss_percentile": 0.58695}, "CVE-2024-35081": {"epss_score": 0.00278, "epss_percentile": 0.50894}, "CVE-2024-35082": {"epss_score": 0.00076, "epss_percentile": 0.23248}, "CVE-2024-35083": {"epss_score": 0.00159, "epss_percentile": 0.37392}, "CVE-2024-35084": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2024-35085": {"epss_score": 0.00129, "epss_percentile": 0.33149}, "CVE-2024-35086": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2024-35090": {"epss_score": 0.00152, "epss_percentile": 0.36447}, "CVE-2024-35091": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2024-35099": {"epss_score": 0.00303, "epss_percentile": 0.53196}, "CVE-2024-35102": {"epss_score": 0.02806, "epss_percentile": 0.85707}, "CVE-2024-35106": {"epss_score": 0.00443, "epss_percentile": 0.62792}, "CVE-2024-35108": {"epss_score": 0.00154, "epss_percentile": 0.36662}, "CVE-2024-35109": {"epss_score": 0.00069, "epss_percentile": 0.21443}, "CVE-2024-35110": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2024-35111": {"epss_score": 0.00125, "epss_percentile": 0.32584}, "CVE-2024-35112": {"epss_score": 0.00108, "epss_percentile": 0.29758}, "CVE-2024-35113": {"epss_score": 0.00159, "epss_percentile": 0.37324}, "CVE-2024-35114": {"epss_score": 0.00089, "epss_percentile": 0.25912}, "CVE-2024-35116": {"epss_score": 0.0015, "epss_percentile": 0.36174}, "CVE-2024-35117": {"epss_score": 0.00052, "epss_percentile": 0.16563}, "CVE-2024-35118": {"epss_score": 0.00039, "epss_percentile": 0.11593}, "CVE-2024-35119": {"epss_score": 0.00096, "epss_percentile": 0.27369}, "CVE-2024-35122": {"epss_score": 0.00015, "epss_percentile": 0.02245}, "CVE-2024-35124": {"epss_score": 0.00086, "epss_percentile": 0.25297}, "CVE-2024-35133": {"epss_score": 0.01584, "epss_percentile": 0.81159}, "CVE-2024-35134": {"epss_score": 0.00089, "epss_percentile": 0.25932}, "CVE-2024-35136": {"epss_score": 0.00177, "epss_percentile": 0.39566}, "CVE-2024-35137": {"epss_score": 0.00028, "epss_percentile": 0.07286}, "CVE-2024-35138": {"epss_score": 0.00018, "epss_percentile": 0.03753}, "CVE-2024-35139": {"epss_score": 0.00021, "epss_percentile": 0.0475}, "CVE-2024-35140": {"epss_score": 0.0003, "epss_percentile": 0.08167}, "CVE-2024-35141": {"epss_score": 0.00031, "epss_percentile": 0.08614}, "CVE-2024-35142": {"epss_score": 0.00035, "epss_percentile": 0.09822}, "CVE-2024-35143": {"epss_score": 0.00085, "epss_percentile": 0.25226}, "CVE-2024-35144": {"epss_score": 0.00095, "epss_percentile": 0.27117}, "CVE-2024-35145": {"epss_score": 0.00304, "epss_percentile": 0.53299}, "CVE-2024-35146": {"epss_score": 0.00437, "epss_percentile": 0.62537}, "CVE-2024-35148": {"epss_score": 0.00087, "epss_percentile": 0.25551}, "CVE-2024-35150": {"epss_score": 0.00099, "epss_percentile": 0.28415}, "CVE-2024-35151": {"epss_score": 0.00095, "epss_percentile": 0.27238}, "CVE-2024-35152": {"epss_score": 0.00115, "epss_percentile": 0.30937}, "CVE-2024-35153": {"epss_score": 0.00309, "epss_percentile": 0.53647}, "CVE-2024-35154": {"epss_score": 0.00275, "epss_percentile": 0.50663}, "CVE-2024-35155": {"epss_score": 0.00113, "epss_percentile": 0.30715}, "CVE-2024-35156": {"epss_score": 0.00096, "epss_percentile": 0.27323}, "CVE-2024-35160": {"epss_score": 0.00025, "epss_percentile": 0.06096}, "CVE-2024-35161": {"epss_score": 0.00209, "epss_percentile": 0.434}, "CVE-2024-35162": {"epss_score": 0.00963, "epss_percentile": 0.76021}, "CVE-2024-35164": {"epss_score": 0.00035, "epss_percentile": 0.09898}, "CVE-2024-35165": {"epss_score": 0.00335, "epss_percentile": 0.55897}, "CVE-2024-35166": {"epss_score": 0.00304, "epss_percentile": 0.53287}, "CVE-2024-35167": {"epss_score": 0.00163, "epss_percentile": 0.37791}, "CVE-2024-35168": {"epss_score": 0.0017, "epss_percentile": 0.38689}, "CVE-2024-35169": {"epss_score": 0.00187, "epss_percentile": 0.40699}, "CVE-2024-35170": {"epss_score": 0.00279, "epss_percentile": 0.50964}, "CVE-2024-35171": {"epss_score": 0.00317, "epss_percentile": 0.54341}, "CVE-2024-35172": {"epss_score": 0.00175, "epss_percentile": 0.39363}, "CVE-2024-35174": {"epss_score": 0.00155, "epss_percentile": 0.36799}, "CVE-2024-35175": {"epss_score": 0.00084, "epss_percentile": 0.24883}, "CVE-2024-35176": {"epss_score": 0.06902, "epss_percentile": 0.91104}, "CVE-2024-35177": {"epss_score": 0.00034, "epss_percentile": 0.0974}, "CVE-2024-35178": {"epss_score": 0.00983, "epss_percentile": 0.763}, "CVE-2024-35179": {"epss_score": 0.00087, "epss_percentile": 0.25528}, "CVE-2024-35180": {"epss_score": 0.00422, "epss_percentile": 0.61561}, "CVE-2024-35181": {"epss_score": 0.00148, "epss_percentile": 0.35844}, "CVE-2024-35182": {"epss_score": 0.0011, "epss_percentile": 0.30118}, "CVE-2024-35183": {"epss_score": 0.00054, "epss_percentile": 0.17252}, "CVE-2024-35184": {"epss_score": 0.00564, "epss_percentile": 0.67753}, "CVE-2024-35185": {"epss_score": 0.00066, "epss_percentile": 0.20696}, "CVE-2024-35186": {"epss_score": 0.00434, "epss_percentile": 0.62299}, "CVE-2024-35187": {"epss_score": 0.00081, "epss_percentile": 0.24308}, "CVE-2024-35189": {"epss_score": 0.00328, "epss_percentile": 0.55286}, "CVE-2024-35190": {"epss_score": 0.00466, "epss_percentile": 0.6381}, "CVE-2024-35191": {"epss_score": 0.00218, "epss_percentile": 0.4436}, "CVE-2024-35192": {"epss_score": 0.00067, "epss_percentile": 0.2098}, "CVE-2024-35194": {"epss_score": 0.00265, "epss_percentile": 0.49826}, "CVE-2024-35195": {"epss_score": 0.00044, "epss_percentile": 0.13647}, "CVE-2024-35196": {"epss_score": 0.00094, "epss_percentile": 0.27036}, "CVE-2024-35197": {"epss_score": 0.00044, "epss_percentile": 0.13452}, "CVE-2024-35198": {"epss_score": 0.00177, "epss_percentile": 0.39525}, "CVE-2024-35199": {"epss_score": 0.00094, "epss_percentile": 0.26799}, "CVE-2024-35200": {"epss_score": 0.00433, "epss_percentile": 0.62281}, "CVE-2024-35201": {"epss_score": 0.00069, "epss_percentile": 0.21482}, "CVE-2024-35202": {"epss_score": 0.02464, "epss_percentile": 0.84831}, "CVE-2024-35203": {"epss_score": 0.00048, "epss_percentile": 0.15008}, "CVE-2024-35204": {"epss_score": 0.00024, "epss_percentile": 0.05739}, "CVE-2024-35205": {"epss_score": 0.01327, "epss_percentile": 0.79492}, "CVE-2024-35206": {"epss_score": 0.0033, "epss_percentile": 0.55452}, "CVE-2024-35207": {"epss_score": 0.00328, "epss_percentile": 0.55153}, "CVE-2024-35208": {"epss_score": 0.001, "epss_percentile": 0.28487}, "CVE-2024-35209": {"epss_score": 0.00388, "epss_percentile": 0.59355}, "CVE-2024-35210": {"epss_score": 0.00182, "epss_percentile": 0.4015}, "CVE-2024-35211": {"epss_score": 0.00198, "epss_percentile": 0.4206}, "CVE-2024-35212": {"epss_score": 0.00392, "epss_percentile": 0.59692}, "CVE-2024-35213": {"epss_score": 0.0058, "epss_percentile": 0.68238}, "CVE-2024-35214": {"epss_score": 0.00068, "epss_percentile": 0.21363}, "CVE-2024-35215": {"epss_score": 0.00059, "epss_percentile": 0.18649}, "CVE-2024-35218": {"epss_score": 0.00705, "epss_percentile": 0.71602}, "CVE-2024-35219": {"epss_score": 0.39262, "epss_percentile": 0.9715}, "CVE-2024-35220": {"epss_score": 0.00351, "epss_percentile": 0.57038}, "CVE-2024-35221": {"epss_score": 0.00081, "epss_percentile": 0.24239}, "CVE-2024-35222": {"epss_score": 0.00037, "epss_percentile": 0.10908}, "CVE-2024-35223": {"epss_score": 0.00436, "epss_percentile": 0.62485}, "CVE-2024-35224": {"epss_score": 0.00024, "epss_percentile": 0.05737}, "CVE-2024-35225": {"epss_score": 0.01085, "epss_percentile": 0.77407}, "CVE-2024-35226": {"epss_score": 0.00129, "epss_percentile": 0.3309}, "CVE-2024-35227": {"epss_score": 0.00237, "epss_percentile": 0.46656}, "CVE-2024-35228": {"epss_score": 0.0016, "epss_percentile": 0.37456}, "CVE-2024-35229": {"epss_score": 0.00102, "epss_percentile": 0.28897}, "CVE-2024-35230": {"epss_score": 0.00178, "epss_percentile": 0.39702}, "CVE-2024-35231": {"epss_score": 0.00171, "epss_percentile": 0.38868}, "CVE-2024-35232": {"epss_score": 0.001, "epss_percentile": 0.28458}, "CVE-2024-35234": {"epss_score": 0.00174, "epss_percentile": 0.39219}, "CVE-2024-35235": {"epss_score": 0.03102, "epss_percentile": 0.86412}, "CVE-2024-35236": {"epss_score": 0.01425, "epss_percentile": 0.80196}, "CVE-2024-35237": {"epss_score": 0.00126, "epss_percentile": 0.3274}, "CVE-2024-35238": {"epss_score": 0.0036, "epss_percentile": 0.5763}, "CVE-2024-35239": {"epss_score": 0.00568, "epss_percentile": 0.67901}, "CVE-2024-35240": {"epss_score": 0.00268, "epss_percentile": 0.50067}, "CVE-2024-35241": {"epss_score": 0.00467, "epss_percentile": 0.6385}, "CVE-2024-35242": {"epss_score": 0.25212, "epss_percentile": 0.95999}, "CVE-2024-35244": {"epss_score": 0.00104, "epss_percentile": 0.29244}, "CVE-2024-35245": {"epss_score": 0.00032, "epss_percentile": 0.09118}, "CVE-2024-35246": {"epss_score": 0.00288, "epss_percentile": 0.51935}, "CVE-2024-35247": {"epss_score": 0.0003, "epss_percentile": 0.08082}, "CVE-2024-35248": {"epss_score": 0.01701, "epss_percentile": 0.81836}, "CVE-2024-35249": {"epss_score": 0.20144, "epss_percentile": 0.95292}, "CVE-2024-35250": {"epss_score": 0.63511, "epss_percentile": 0.98336}, "CVE-2024-35252": {"epss_score": 0.05402, "epss_percentile": 0.89833}, "CVE-2024-35253": {"epss_score": 0.00712, "epss_percentile": 0.71759}, "CVE-2024-35254": {"epss_score": 0.008, "epss_percentile": 0.73541}, "CVE-2024-35255": {"epss_score": 0.00221, "epss_percentile": 0.44662}, "CVE-2024-35256": {"epss_score": 0.04025, "epss_percentile": 0.8814}, "CVE-2024-35260": {"epss_score": 0.0526, "epss_percentile": 0.89669}, "CVE-2024-35261": {"epss_score": 0.0039, "epss_percentile": 0.59538}, "CVE-2024-35263": {"epss_score": 0.05562, "epss_percentile": 0.89996}, "CVE-2024-35264": {"epss_score": 0.04361, "epss_percentile": 0.88595}, "CVE-2024-35265": {"epss_score": 0.00287, "epss_percentile": 0.5182}, "CVE-2024-35266": {"epss_score": 0.00363, "epss_percentile": 0.57899}, "CVE-2024-35267": {"epss_score": 0.00363, "epss_percentile": 0.57899}, "CVE-2024-35270": {"epss_score": 0.00476, "epss_percentile": 0.64253}, "CVE-2024-35271": {"epss_score": 0.04065, "epss_percentile": 0.88197}, "CVE-2024-35272": {"epss_score": 0.04065, "epss_percentile": 0.88197}, "CVE-2024-35273": {"epss_score": 0.00155, "epss_percentile": 0.36847}, "CVE-2024-35274": {"epss_score": 0.00059, "epss_percentile": 0.18723}, "CVE-2024-35275": {"epss_score": 0.00202, "epss_percentile": 0.42416}, "CVE-2024-35276": {"epss_score": 0.00083, "epss_percentile": 0.24633}, "CVE-2024-35277": {"epss_score": 0.00053, "epss_percentile": 0.16822}, "CVE-2024-35278": {"epss_score": 0.00215, "epss_percentile": 0.44043}, "CVE-2024-35279": {"epss_score": 0.00229, "epss_percentile": 0.45662}, "CVE-2024-35280": {"epss_score": 0.00196, "epss_percentile": 0.41797}, "CVE-2024-35281": {"epss_score": 0.00015, "epss_percentile": 0.02301}, "CVE-2024-35282": {"epss_score": 0.00089, "epss_percentile": 0.25968}, "CVE-2024-35283": {"epss_score": 0.0074, "epss_percentile": 0.72401}, "CVE-2024-35284": {"epss_score": 0.00879, "epss_percentile": 0.74848}, "CVE-2024-35285": {"epss_score": 0.03118, "epss_percentile": 0.86438}, "CVE-2024-35286": {"epss_score": 0.57551, "epss_percentile": 0.9807}, "CVE-2024-35287": {"epss_score": 0.00067, "epss_percentile": 0.21066}, "CVE-2024-35288": {"epss_score": 0.00188, "epss_percentile": 0.409}, "CVE-2024-35291": {"epss_score": 0.00166, "epss_percentile": 0.38248}, "CVE-2024-35292": {"epss_score": 0.00162, "epss_percentile": 0.37649}, "CVE-2024-35293": {"epss_score": 0.0191, "epss_percentile": 0.82823}, "CVE-2024-35294": {"epss_score": 0.00246, "epss_percentile": 0.47747}, "CVE-2024-35295": {"epss_score": 0.00026, "epss_percentile": 0.06519}, "CVE-2024-35296": {"epss_score": 0.00123, "epss_percentile": 0.32237}, "CVE-2024-35297": {"epss_score": 0.00187, "epss_percentile": 0.40695}, "CVE-2024-35298": {"epss_score": 0.00103, "epss_percentile": 0.28983}, "CVE-2024-35299": {"epss_score": 7e-05, "epss_percentile": 0.00368}, "CVE-2024-35300": {"epss_score": 0.00237, "epss_percentile": 0.4673}, "CVE-2024-35301": {"epss_score": 0.00022, "epss_percentile": 0.05003}, "CVE-2024-35302": {"epss_score": 0.33658, "epss_percentile": 0.96794}, "CVE-2024-35303": {"epss_score": 0.00136, "epss_percentile": 0.34057}, "CVE-2024-35304": {"epss_score": 0.01795, "epss_percentile": 0.82296}, "CVE-2024-35305": {"epss_score": 0.00393, "epss_percentile": 0.5974}, "CVE-2024-35306": {"epss_score": 0.00494, "epss_percentile": 0.65077}, "CVE-2024-35307": {"epss_score": 0.15349, "epss_percentile": 0.94414}, "CVE-2024-35308": {"epss_score": 0.00751, "epss_percentile": 0.72649}, "CVE-2024-35311": {"epss_score": 0.00063, "epss_percentile": 0.20064}, "CVE-2024-35312": {"epss_score": 0.00038, "epss_percentile": 0.11231}, "CVE-2024-35313": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-35314": {"epss_score": 0.02861, "epss_percentile": 0.85852}, "CVE-2024-35315": {"epss_score": 0.00973, "epss_percentile": 0.76163}, "CVE-2024-35321": {"epss_score": 0.00029, "epss_percentile": 0.07975}, "CVE-2024-35322": {"epss_score": 0.0003, "epss_percentile": 0.08079}, "CVE-2024-35324": {"epss_score": 0.00411, "epss_percentile": 0.60869}, "CVE-2024-35333": {"epss_score": 0.00265, "epss_percentile": 0.49811}, "CVE-2024-35338": {"epss_score": 0.0033, "epss_percentile": 0.55462}, "CVE-2024-35339": {"epss_score": 0.0439, "epss_percentile": 0.88634}, "CVE-2024-35340": {"epss_score": 0.02381, "epss_percentile": 0.84564}, "CVE-2024-35341": {"epss_score": 0.00446, "epss_percentile": 0.62896}, "CVE-2024-35342": {"epss_score": 0.00146, "epss_percentile": 0.35629}, "CVE-2024-35343": {"epss_score": 0.00473, "epss_percentile": 0.64084}, "CVE-2024-35344": {"epss_score": 0.00351, "epss_percentile": 0.57011}, "CVE-2024-35345": {"epss_score": 0.00286, "epss_percentile": 0.51746}, "CVE-2024-35349": {"epss_score": 0.0066, "epss_percentile": 0.70536}, "CVE-2024-35350": {"epss_score": 0.0019, "epss_percentile": 0.41058}, "CVE-2024-35351": {"epss_score": 0.00329, "epss_percentile": 0.55393}, "CVE-2024-35352": {"epss_score": 0.00528, "epss_percentile": 0.66575}, "CVE-2024-35353": {"epss_score": 0.00501, "epss_percentile": 0.65332}, "CVE-2024-35354": {"epss_score": 0.00287, "epss_percentile": 0.51847}, "CVE-2024-35355": {"epss_score": 0.00287, "epss_percentile": 0.51847}, "CVE-2024-35356": {"epss_score": 0.00177, "epss_percentile": 0.39547}, "CVE-2024-35357": {"epss_score": 0.00119, "epss_percentile": 0.31638}, "CVE-2024-35358": {"epss_score": 0.00121, "epss_percentile": 0.3196}, "CVE-2024-35359": {"epss_score": 0.00158, "epss_percentile": 0.37158}, "CVE-2024-35361": {"epss_score": 0.00079, "epss_percentile": 0.23995}, "CVE-2024-35362": {"epss_score": 0.00111, "epss_percentile": 0.30344}, "CVE-2024-35365": {"epss_score": 0.0024, "epss_percentile": 0.4696}, "CVE-2024-35366": {"epss_score": 0.00224, "epss_percentile": 0.45037}, "CVE-2024-35367": {"epss_score": 0.00141, "epss_percentile": 0.34901}, "CVE-2024-35368": {"epss_score": 0.00191, "epss_percentile": 0.41196}, "CVE-2024-35369": {"epss_score": 0.00025, "epss_percentile": 0.06284}, "CVE-2024-35371": {"epss_score": 0.001, "epss_percentile": 0.28509}, "CVE-2024-35373": {"epss_score": 0.04127, "epss_percentile": 0.8829}, "CVE-2024-35374": {"epss_score": 0.06216, "epss_percentile": 0.90574}, "CVE-2024-35375": {"epss_score": 0.00193, "epss_percentile": 0.41387}, "CVE-2024-35384": {"epss_score": 0.0139, "epss_percentile": 0.79938}, "CVE-2024-35385": {"epss_score": 0.00892, "epss_percentile": 0.75056}, "CVE-2024-35386": {"epss_score": 0.02092, "epss_percentile": 0.83573}, "CVE-2024-35387": {"epss_score": 0.09962, "epss_percentile": 0.92795}, "CVE-2024-35388": {"epss_score": 0.03133, "epss_percentile": 0.86476}, "CVE-2024-35395": {"epss_score": 0.00145, "epss_percentile": 0.35383}, "CVE-2024-35396": {"epss_score": 0.00172, "epss_percentile": 0.38913}, "CVE-2024-35397": {"epss_score": 0.0057, "epss_percentile": 0.67949}, "CVE-2024-35398": {"epss_score": 0.00199, "epss_percentile": 0.42119}, "CVE-2024-35399": {"epss_score": 0.00096, "epss_percentile": 0.27447}, "CVE-2024-35400": {"epss_score": 0.00043, "epss_percentile": 0.12941}, "CVE-2024-35401": {"epss_score": 0.00296, "epss_percentile": 0.52534}, "CVE-2024-35403": {"epss_score": 0.0003, "epss_percentile": 0.08063}, "CVE-2024-35409": {"epss_score": 0.0018, "epss_percentile": 0.39988}, "CVE-2024-35410": {"epss_score": 0.00142, "epss_percentile": 0.35089}, "CVE-2024-35418": {"epss_score": 0.00122, "epss_percentile": 0.32111}, "CVE-2024-35419": {"epss_score": 0.00109, "epss_percentile": 0.29922}, "CVE-2024-35420": {"epss_score": 0.00122, "epss_percentile": 0.32111}, "CVE-2024-35421": {"epss_score": 0.00083, "epss_percentile": 0.24702}, "CVE-2024-35422": {"epss_score": 0.00138, "epss_percentile": 0.3453}, "CVE-2024-35423": {"epss_score": 0.00197, "epss_percentile": 0.41899}, "CVE-2024-35424": {"epss_score": 0.00108, "epss_percentile": 0.29873}, "CVE-2024-35425": {"epss_score": 0.00083, "epss_percentile": 0.24702}, "CVE-2024-35426": {"epss_score": 0.00563, "epss_percentile": 0.67711}, "CVE-2024-35427": {"epss_score": 0.00093, "epss_percentile": 0.26656}, "CVE-2024-35428": {"epss_score": 0.00786, "epss_percentile": 0.73265}, "CVE-2024-35429": {"epss_score": 0.00351, "epss_percentile": 0.57075}, "CVE-2024-35430": {"epss_score": 0.00092, "epss_percentile": 0.26509}, "CVE-2024-35431": {"epss_score": 0.01673, "epss_percentile": 0.81686}, "CVE-2024-35432": {"epss_score": 0.00231, "epss_percentile": 0.4581}, "CVE-2024-35433": {"epss_score": 0.00129, "epss_percentile": 0.33213}, "CVE-2024-35434": {"epss_score": 0.00132, "epss_percentile": 0.33523}, "CVE-2024-35451": {"epss_score": 0.00028, "epss_percentile": 0.07309}, "CVE-2024-35468": {"epss_score": 0.0022, "epss_percentile": 0.4457}, "CVE-2024-35469": {"epss_score": 0.00727, "epss_percentile": 0.7209}, "CVE-2024-35474": {"epss_score": 0.00276, "epss_percentile": 0.50762}, "CVE-2024-35475": {"epss_score": 0.00177, "epss_percentile": 0.39516}, "CVE-2024-35492": {"epss_score": 0.00094, "epss_percentile": 0.26761}, "CVE-2024-35495": {"epss_score": 0.00053, "epss_percentile": 0.17006}, "CVE-2024-35498": {"epss_score": 0.00026, "epss_percentile": 0.06582}, "CVE-2024-35504": {"epss_score": 0.00441, "epss_percentile": 0.62668}, "CVE-2024-35510": {"epss_score": 0.00226, "epss_percentile": 0.45266}, "CVE-2024-35511": {"epss_score": 0.00049, "epss_percentile": 0.15356}, "CVE-2024-35512": {"epss_score": 0.00135, "epss_percentile": 0.33939}, "CVE-2024-35515": {"epss_score": 0.00335, "epss_percentile": 0.55805}, "CVE-2024-35517": {"epss_score": 0.10542, "epss_percentile": 0.93023}, "CVE-2024-35518": {"epss_score": 0.0014, "epss_percentile": 0.34721}, "CVE-2024-35519": {"epss_score": 0.00129, "epss_percentile": 0.33085}, "CVE-2024-35520": {"epss_score": 0.03876, "epss_percentile": 0.87889}, "CVE-2024-35522": {"epss_score": 0.00401, "epss_percentile": 0.60252}, "CVE-2024-35526": {"epss_score": 0.00023, "epss_percentile": 0.05504}, "CVE-2024-35527": {"epss_score": 0.00127, "epss_percentile": 0.32828}, "CVE-2024-35532": {"epss_score": 0.00171, "epss_percentile": 0.38818}, "CVE-2024-35537": {"epss_score": 0.0008, "epss_percentile": 0.24061}, "CVE-2024-35538": {"epss_score": 0.00717, "epss_percentile": 0.7189}, "CVE-2024-35539": {"epss_score": 0.03005, "epss_percentile": 0.86181}, "CVE-2024-35540": {"epss_score": 0.0496, "epss_percentile": 0.89333}, "CVE-2024-35545": {"epss_score": 0.00192, "epss_percentile": 0.41369}, "CVE-2024-35548": {"epss_score": 0.00103, "epss_percentile": 0.28922}, "CVE-2024-35550": {"epss_score": 0.001, "epss_percentile": 0.28477}, "CVE-2024-35551": {"epss_score": 0.00137, "epss_percentile": 0.34271}, "CVE-2024-35552": {"epss_score": 0.00316, "epss_percentile": 0.54242}, "CVE-2024-35553": {"epss_score": 0.00139, "epss_percentile": 0.34638}, "CVE-2024-35554": {"epss_score": 0.00252, "epss_percentile": 0.4841}, "CVE-2024-35555": {"epss_score": 0.00135, "epss_percentile": 0.34039}, "CVE-2024-35556": {"epss_score": 0.00282, "epss_percentile": 0.51254}, "CVE-2024-35557": {"epss_score": 0.00135, "epss_percentile": 0.34039}, "CVE-2024-35558": {"epss_score": 0.0029, "epss_percentile": 0.52143}, "CVE-2024-35559": {"epss_score": 0.00282, "epss_percentile": 0.51254}, "CVE-2024-35560": {"epss_score": 0.00191, "epss_percentile": 0.41197}, "CVE-2024-35561": {"epss_score": 0.00229, "epss_percentile": 0.45598}, "CVE-2024-35563": {"epss_score": 0.00205, "epss_percentile": 0.42756}, "CVE-2024-35570": {"epss_score": 0.01585, "epss_percentile": 0.81165}, "CVE-2024-35571": {"epss_score": 0.00585, "epss_percentile": 0.6843}, "CVE-2024-35576": {"epss_score": 0.00124, "epss_percentile": 0.32396}, "CVE-2024-35578": {"epss_score": 0.00279, "epss_percentile": 0.50927}, "CVE-2024-35579": {"epss_score": 0.00309, "epss_percentile": 0.5372}, "CVE-2024-35580": {"epss_score": 0.00585, "epss_percentile": 0.6843}, "CVE-2024-35581": {"epss_score": 0.00465, "epss_percentile": 0.63745}, "CVE-2024-35582": {"epss_score": 0.00507, "epss_percentile": 0.65646}, "CVE-2024-35583": {"epss_score": 0.00181, "epss_percentile": 0.40086}, "CVE-2024-35584": {"epss_score": 0.82738, "epss_percentile": 0.99211}, "CVE-2024-35591": {"epss_score": 0.00726, "epss_percentile": 0.7207}, "CVE-2024-35592": {"epss_score": 0.0028, "epss_percentile": 0.5101}, "CVE-2024-35593": {"epss_score": 0.00081, "epss_percentile": 0.24235}, "CVE-2024-35595": {"epss_score": 0.00304, "epss_percentile": 0.53239}, "CVE-2024-35618": {"epss_score": 0.00154, "epss_percentile": 0.36747}, "CVE-2024-35621": {"epss_score": 0.0018, "epss_percentile": 0.39873}, "CVE-2024-35627": {"epss_score": 0.02934, "epss_percentile": 0.86022}, "CVE-2024-35628": {"epss_score": 0.00162, "epss_percentile": 0.37694}, "CVE-2024-35629": {"epss_score": 0.03476, "epss_percentile": 0.87208}, "CVE-2024-35630": {"epss_score": 0.00291, "epss_percentile": 0.5215}, "CVE-2024-35631": {"epss_score": 0.0017, "epss_percentile": 0.38739}, "CVE-2024-35632": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-35633": {"epss_score": 0.00212, "epss_percentile": 0.43743}, "CVE-2024-35634": {"epss_score": 0.00586, "epss_percentile": 0.6845}, "CVE-2024-35635": {"epss_score": 0.00212, "epss_percentile": 0.43743}, "CVE-2024-35636": {"epss_score": 0.00182, "epss_percentile": 0.40218}, "CVE-2024-35637": {"epss_score": 0.00124, "epss_percentile": 0.32354}, "CVE-2024-35638": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-35639": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-35640": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-35641": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-35642": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-35643": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-35645": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-35646": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-35647": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-35649": {"epss_score": 0.00257, "epss_percentile": 0.48854}, "CVE-2024-35650": {"epss_score": 0.0038, "epss_percentile": 0.58924}, "CVE-2024-35651": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35652": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2024-35653": {"epss_score": 0.00156, "epss_percentile": 0.36959}, "CVE-2024-35654": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35655": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-35656": {"epss_score": 0.00213, "epss_percentile": 0.43888}, "CVE-2024-35657": {"epss_score": 0.00089, "epss_percentile": 0.25831}, "CVE-2024-35658": {"epss_score": 0.00326, "epss_percentile": 0.55052}, "CVE-2024-35659": {"epss_score": 0.00073, "epss_percentile": 0.22569}, "CVE-2024-35660": {"epss_score": 0.00188, "epss_percentile": 0.40837}, "CVE-2024-35661": {"epss_score": 0.0026, "epss_percentile": 0.49196}, "CVE-2024-35662": {"epss_score": 0.00158, "epss_percentile": 0.37285}, "CVE-2024-35663": {"epss_score": 0.00107, "epss_percentile": 0.29661}, "CVE-2024-35664": {"epss_score": 0.00118, "epss_percentile": 0.31429}, "CVE-2024-35665": {"epss_score": 0.00176, "epss_percentile": 0.39399}, "CVE-2024-35666": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-35667": {"epss_score": 0.00176, "epss_percentile": 0.39399}, "CVE-2024-35668": {"epss_score": 0.00167, "epss_percentile": 0.38362}, "CVE-2024-35669": {"epss_score": 0.00412, "epss_percentile": 0.60942}, "CVE-2024-35670": {"epss_score": 0.00278, "epss_percentile": 0.50903}, "CVE-2024-35671": {"epss_score": 0.0019, "epss_percentile": 0.41118}, "CVE-2024-35672": {"epss_score": 0.00647, "epss_percentile": 0.70181}, "CVE-2024-35673": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-35674": {"epss_score": 0.00377, "epss_percentile": 0.58735}, "CVE-2024-35675": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35676": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35677": {"epss_score": 0.00645, "epss_percentile": 0.70109}, "CVE-2024-35678": {"epss_score": 0.00402, "epss_percentile": 0.60283}, "CVE-2024-35679": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-35680": {"epss_score": 0.00168, "epss_percentile": 0.3848}, "CVE-2024-35681": {"epss_score": 0.00156, "epss_percentile": 0.36959}, "CVE-2024-35682": {"epss_score": 0.00274, "epss_percentile": 0.50513}, "CVE-2024-35683": {"epss_score": 0.00129, "epss_percentile": 0.33195}, "CVE-2024-35684": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-35685": {"epss_score": 0.00206, "epss_percentile": 0.42925}, "CVE-2024-35686": {"epss_score": 0.00074, "epss_percentile": 0.2273}, "CVE-2024-35687": {"epss_score": 0.00232, "epss_percentile": 0.45888}, "CVE-2024-35688": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-35689": {"epss_score": 0.00094, "epss_percentile": 0.26788}, "CVE-2024-35691": {"epss_score": 0.00485, "epss_percentile": 0.6471}, "CVE-2024-35692": {"epss_score": 0.00139, "epss_percentile": 0.34573}, "CVE-2024-35693": {"epss_score": 0.07872, "epss_percentile": 0.91736}, "CVE-2024-35694": {"epss_score": 0.06473, "epss_percentile": 0.90779}, "CVE-2024-35695": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35696": {"epss_score": 0.00213, "epss_percentile": 0.43888}, "CVE-2024-35697": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2024-35698": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-35699": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35700": {"epss_score": 0.00205, "epss_percentile": 0.42724}, "CVE-2024-35701": {"epss_score": 0.00156, "epss_percentile": 0.36959}, "CVE-2024-35702": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-35703": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-35704": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35705": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35706": {"epss_score": 0.00167, "epss_percentile": 0.38362}, "CVE-2024-35707": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35708": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35709": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-35710": {"epss_score": 0.00274, "epss_percentile": 0.50513}, "CVE-2024-35711": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35712": {"epss_score": 0.00586, "epss_percentile": 0.6845}, "CVE-2024-35713": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-35714": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35715": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35716": {"epss_score": 0.00457, "epss_percentile": 0.63391}, "CVE-2024-35717": {"epss_score": 0.00377, "epss_percentile": 0.58735}, "CVE-2024-35718": {"epss_score": 0.00167, "epss_percentile": 0.38362}, "CVE-2024-35719": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35720": {"epss_score": 0.00377, "epss_percentile": 0.58735}, "CVE-2024-35721": {"epss_score": 0.00377, "epss_percentile": 0.58735}, "CVE-2024-35722": {"epss_score": 0.00377, "epss_percentile": 0.58735}, "CVE-2024-35723": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-35724": {"epss_score": 0.0022, "epss_percentile": 0.44544}, "CVE-2024-35725": {"epss_score": 0.00493, "epss_percentile": 0.65031}, "CVE-2024-35726": {"epss_score": 0.00377, "epss_percentile": 0.58735}, "CVE-2024-35727": {"epss_score": 0.00287, "epss_percentile": 0.51827}, "CVE-2024-35728": {"epss_score": 0.00168, "epss_percentile": 0.3848}, "CVE-2024-35729": {"epss_score": 0.00303, "epss_percentile": 0.53172}, "CVE-2024-35730": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2024-35731": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35732": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-35733": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2024-35734": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-35735": {"epss_score": 0.00472, "epss_percentile": 0.64057}, "CVE-2024-35736": {"epss_score": 0.00518, "epss_percentile": 0.6613}, "CVE-2024-35737": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2024-35738": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35739": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35740": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35741": {"epss_score": 0.00118, "epss_percentile": 0.31468}, "CVE-2024-35742": {"epss_score": 0.00096, "epss_percentile": 0.27257}, "CVE-2024-35743": {"epss_score": 0.00167, "epss_percentile": 0.3835}, "CVE-2024-35744": {"epss_score": 0.00167, "epss_percentile": 0.3835}, "CVE-2024-35745": {"epss_score": 0.0084, "epss_percentile": 0.742}, "CVE-2024-35746": {"epss_score": 0.00754, "epss_percentile": 0.72701}, "CVE-2024-35747": {"epss_score": 0.00061, "epss_percentile": 0.1946}, "CVE-2024-35748": {"epss_score": 0.00174, "epss_percentile": 0.39258}, "CVE-2024-35749": {"epss_score": 0.00031, "epss_percentile": 0.08657}, "CVE-2024-35750": {"epss_score": 0.00402, "epss_percentile": 0.60283}, "CVE-2024-35751": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-35752": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-35753": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35754": {"epss_score": 0.00784, "epss_percentile": 0.73243}, "CVE-2024-35755": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35756": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-35757": {"epss_score": 0.00158, "epss_percentile": 0.37157}, "CVE-2024-35758": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-35759": {"epss_score": 0.00158, "epss_percentile": 0.37157}, "CVE-2024-35760": {"epss_score": 0.00283, "epss_percentile": 0.51412}, "CVE-2024-35761": {"epss_score": 0.00294, "epss_percentile": 0.52419}, "CVE-2024-35762": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-35763": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-35764": {"epss_score": 0.00294, "epss_percentile": 0.52419}, "CVE-2024-35765": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-35766": {"epss_score": 0.00407, "epss_percentile": 0.6058}, "CVE-2024-35767": {"epss_score": 0.00403, "epss_percentile": 0.60345}, "CVE-2024-35768": {"epss_score": 0.00283, "epss_percentile": 0.51412}, "CVE-2024-35769": {"epss_score": 0.0022, "epss_percentile": 0.44546}, "CVE-2024-35770": {"epss_score": 0.00142, "epss_percentile": 0.35075}, "CVE-2024-35771": {"epss_score": 0.00312, "epss_percentile": 0.5401}, "CVE-2024-35772": {"epss_score": 0.00312, "epss_percentile": 0.5401}, "CVE-2024-35773": {"epss_score": 0.00303, "epss_percentile": 0.5321}, "CVE-2024-35774": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-35775": {"epss_score": 0.002, "epss_percentile": 0.42273}, "CVE-2024-35776": {"epss_score": 0.01446, "epss_percentile": 0.80327}, "CVE-2024-35777": {"epss_score": 0.00265, "epss_percentile": 0.49827}, "CVE-2024-35778": {"epss_score": 0.00805, "epss_percentile": 0.73638}, "CVE-2024-35779": {"epss_score": 0.00294, "epss_percentile": 0.52419}, "CVE-2024-35780": {"epss_score": 0.00939, "epss_percentile": 0.75717}, "CVE-2024-35781": {"epss_score": 0.00784, "epss_percentile": 0.73243}, "CVE-2024-35782": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-35783": {"epss_score": 0.00175, "epss_percentile": 0.39324}, "CVE-2024-35784": {"epss_score": 0.00026, "epss_percentile": 0.064}, "CVE-2024-35785": {"epss_score": 0.00069, "epss_percentile": 0.21479}, "CVE-2024-35786": {"epss_score": 0.00026, "epss_percentile": 0.064}, "CVE-2024-35787": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-35789": {"epss_score": 0.00048, "epss_percentile": 0.1507}, "CVE-2024-35790": {"epss_score": 0.00024, "epss_percentile": 0.05742}, "CVE-2024-35791": {"epss_score": 0.00028, "epss_percentile": 0.07241}, "CVE-2024-35792": {"epss_score": 0.001, "epss_percentile": 0.28544}, "CVE-2024-35793": {"epss_score": 0.00026, "epss_percentile": 0.064}, "CVE-2024-35794": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-35795": {"epss_score": 8e-05, "epss_percentile": 0.00563}, "CVE-2024-35796": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2024-35797": {"epss_score": 0.00023, "epss_percentile": 0.05628}, "CVE-2024-35798": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-35799": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-35800": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2024-35801": {"epss_score": 0.00017, "epss_percentile": 0.03306}, "CVE-2024-35803": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2024-35804": {"epss_score": 0.00019, "epss_percentile": 0.04186}, "CVE-2024-35805": {"epss_score": 7e-05, "epss_percentile": 0.00351}, "CVE-2024-35806": {"epss_score": 0.0001, "epss_percentile": 0.00837}, "CVE-2024-35807": {"epss_score": 7e-05, "epss_percentile": 0.00428}, "CVE-2024-35808": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-35809": {"epss_score": 6e-05, "epss_percentile": 0.00256}, "CVE-2024-35810": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-35811": {"epss_score": 8e-05, "epss_percentile": 0.00582}, "CVE-2024-35813": {"epss_score": 0.00013, "epss_percentile": 0.01594}, "CVE-2024-35814": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-35815": {"epss_score": 9e-05, "epss_percentile": 0.00613}, "CVE-2024-35816": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-35817": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2024-35818": {"epss_score": 0.00015, "epss_percentile": 0.0215}, "CVE-2024-35819": {"epss_score": 0.00015, "epss_percentile": 0.02532}, "CVE-2024-35821": {"epss_score": 0.00115, "epss_percentile": 0.30948}, "CVE-2024-35822": {"epss_score": 0.00023, "epss_percentile": 0.05622}, "CVE-2024-35823": {"epss_score": 0.00271, "epss_percentile": 0.50307}, "CVE-2024-35824": {"epss_score": 0.00016, "epss_percentile": 0.02927}, "CVE-2024-35825": {"epss_score": 0.00024, "epss_percentile": 0.05778}, "CVE-2024-35826": {"epss_score": 0.00023, "epss_percentile": 0.05654}, "CVE-2024-35827": {"epss_score": 0.0002, "epss_percentile": 0.04533}, "CVE-2024-35828": {"epss_score": 0.0002, "epss_percentile": 0.04467}, "CVE-2024-35829": {"epss_score": 0.00021, "epss_percentile": 0.04832}, "CVE-2024-35830": {"epss_score": 0.0002, "epss_percentile": 0.04514}, "CVE-2024-35831": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2024-35832": {"epss_score": 0.00064, "epss_percentile": 0.20362}, "CVE-2024-35833": {"epss_score": 0.00025, "epss_percentile": 0.06148}, "CVE-2024-35834": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2024-35835": {"epss_score": 0.00158, "epss_percentile": 0.3717}, "CVE-2024-35836": {"epss_score": 0.00031, "epss_percentile": 0.08452}, "CVE-2024-35837": {"epss_score": 0.00026, "epss_percentile": 0.06588}, "CVE-2024-35838": {"epss_score": 0.00015, "epss_percentile": 0.02289}, "CVE-2024-35839": {"epss_score": 0.00015, "epss_percentile": 0.02388}, "CVE-2024-35840": {"epss_score": 0.00017, "epss_percentile": 0.03233}, "CVE-2024-35841": {"epss_score": 0.00028, "epss_percentile": 0.07332}, "CVE-2024-35842": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-35843": {"epss_score": 0.00016, "epss_percentile": 0.028}, "CVE-2024-35844": {"epss_score": 0.00021, "epss_percentile": 0.04893}, "CVE-2024-35845": {"epss_score": 0.00269, "epss_percentile": 0.50165}, "CVE-2024-35846": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-35847": {"epss_score": 0.00021, "epss_percentile": 0.04904}, "CVE-2024-35848": {"epss_score": 0.00017, "epss_percentile": 0.03331}, "CVE-2024-35849": {"epss_score": 0.00014, "epss_percentile": 0.02096}, "CVE-2024-35850": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-35851": {"epss_score": 0.00034, "epss_percentile": 0.09706}, "CVE-2024-35852": {"epss_score": 0.00028, "epss_percentile": 0.07439}, "CVE-2024-35853": {"epss_score": 0.00188, "epss_percentile": 0.40902}, "CVE-2024-35854": {"epss_score": 0.00194, "epss_percentile": 0.41563}, "CVE-2024-35855": {"epss_score": 0.00021, "epss_percentile": 0.04731}, "CVE-2024-35856": {"epss_score": 0.00069, "epss_percentile": 0.2159}, "CVE-2024-35857": {"epss_score": 0.00061, "epss_percentile": 0.19261}, "CVE-2024-35858": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2024-35859": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-35860": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-35861": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-35862": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-35863": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-35864": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-35865": {"epss_score": 0.0001, "epss_percentile": 0.00915}, "CVE-2024-35866": {"epss_score": 0.00013, "epss_percentile": 0.01513}, "CVE-2024-35867": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2024-35868": {"epss_score": 0.00015, "epss_percentile": 0.0234}, "CVE-2024-35869": {"epss_score": 0.00015, "epss_percentile": 0.02336}, "CVE-2024-35870": {"epss_score": 8e-05, "epss_percentile": 0.00548}, "CVE-2024-35871": {"epss_score": 0.00034, "epss_percentile": 0.09756}, "CVE-2024-35872": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2024-35873": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-35874": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-35875": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-35877": {"epss_score": 7e-05, "epss_percentile": 0.00436}, "CVE-2024-35878": {"epss_score": 0.00041, "epss_percentile": 0.12369}, "CVE-2024-35879": {"epss_score": 0.00014, "epss_percentile": 0.02023}, "CVE-2024-35880": {"epss_score": 0.00143, "epss_percentile": 0.35097}, "CVE-2024-35882": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-35883": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-35884": {"epss_score": 0.00014, "epss_percentile": 0.01909}, "CVE-2024-35885": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2024-35886": {"epss_score": 5e-05, "epss_percentile": 0.00211}, "CVE-2024-35887": {"epss_score": 0.00015, "epss_percentile": 0.0234}, "CVE-2024-35888": {"epss_score": 7e-05, "epss_percentile": 0.00362}, "CVE-2024-35889": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-35890": {"epss_score": 0.00029, "epss_percentile": 0.07944}, "CVE-2024-35891": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-35892": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-35893": {"epss_score": 0.00013, "epss_percentile": 0.01661}, "CVE-2024-35894": {"epss_score": 0.00037, "epss_percentile": 0.10765}, "CVE-2024-35895": {"epss_score": 0.0001, "epss_percentile": 0.00788}, "CVE-2024-35896": {"epss_score": 0.00012, "epss_percentile": 0.01137}, "CVE-2024-35897": {"epss_score": 0.00012, "epss_percentile": 0.01339}, "CVE-2024-35898": {"epss_score": 0.0001, "epss_percentile": 0.00765}, "CVE-2024-35899": {"epss_score": 9e-05, "epss_percentile": 0.00657}, "CVE-2024-35900": {"epss_score": 0.00016, "epss_percentile": 0.02654}, "CVE-2024-35901": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2024-35902": {"epss_score": 0.0002, "epss_percentile": 0.04604}, "CVE-2024-35903": {"epss_score": 0.00019, "epss_percentile": 0.04289}, "CVE-2024-35904": {"epss_score": 0.00017, "epss_percentile": 0.03101}, "CVE-2024-35905": {"epss_score": 0.00023, "epss_percentile": 0.05627}, "CVE-2024-35907": {"epss_score": 0.00029, "epss_percentile": 0.07758}, "CVE-2024-35908": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2024-35909": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-35910": {"epss_score": 0.0002, "epss_percentile": 0.04685}, "CVE-2024-35911": {"epss_score": 0.00032, "epss_percentile": 0.09118}, "CVE-2024-35912": {"epss_score": 0.00017, "epss_percentile": 0.03315}, "CVE-2024-35913": {"epss_score": 0.0004, "epss_percentile": 0.12179}, "CVE-2024-35914": {"epss_score": 0.00014, "epss_percentile": 0.01979}, "CVE-2024-35915": {"epss_score": 0.00024, "epss_percentile": 0.05778}, "CVE-2024-35916": {"epss_score": 0.00131, "epss_percentile": 0.33418}, "CVE-2024-35917": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-35919": {"epss_score": 0.00015, "epss_percentile": 0.0234}, "CVE-2024-35920": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-35921": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2024-35922": {"epss_score": 0.0002, "epss_percentile": 0.04604}, "CVE-2024-35924": {"epss_score": 0.00019, "epss_percentile": 0.04289}, "CVE-2024-35925": {"epss_score": 0.00013, "epss_percentile": 0.01661}, "CVE-2024-35926": {"epss_score": 0.00031, "epss_percentile": 0.08452}, "CVE-2024-35927": {"epss_score": 8e-05, "epss_percentile": 0.00559}, "CVE-2024-35929": {"epss_score": 6e-05, "epss_percentile": 0.00301}, "CVE-2024-35930": {"epss_score": 0.00013, "epss_percentile": 0.01614}, "CVE-2024-35931": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-35932": {"epss_score": 0.00027, "epss_percentile": 0.07121}, "CVE-2024-35933": {"epss_score": 0.00016, "epss_percentile": 0.02654}, "CVE-2024-35934": {"epss_score": 0.00015, "epss_percentile": 0.02506}, "CVE-2024-35935": {"epss_score": 0.00012, "epss_percentile": 0.01335}, "CVE-2024-35936": {"epss_score": 0.00016, "epss_percentile": 0.02654}, "CVE-2024-35937": {"epss_score": 0.00017, "epss_percentile": 0.03123}, "CVE-2024-35938": {"epss_score": 0.00017, "epss_percentile": 0.03233}, "CVE-2024-35939": {"epss_score": 0.00017, "epss_percentile": 0.03146}, "CVE-2024-35940": {"epss_score": 0.0002, "epss_percentile": 0.04639}, "CVE-2024-35942": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-35943": {"epss_score": 0.00024, "epss_percentile": 0.05854}, "CVE-2024-35944": {"epss_score": 0.00013, "epss_percentile": 0.01661}, "CVE-2024-35945": {"epss_score": 0.00019, "epss_percentile": 0.04289}, "CVE-2024-35946": {"epss_score": 0.00016, "epss_percentile": 0.02927}, "CVE-2024-35947": {"epss_score": 0.00019, "epss_percentile": 0.04258}, "CVE-2024-35948": {"epss_score": 0.00028, "epss_percentile": 0.07444}, "CVE-2024-35949": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-35950": {"epss_score": 8e-05, "epss_percentile": 0.00484}, "CVE-2024-35951": {"epss_score": 9e-05, "epss_percentile": 0.00699}, "CVE-2024-35952": {"epss_score": 8e-05, "epss_percentile": 0.00563}, "CVE-2024-35953": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-35954": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-35955": {"epss_score": 0.00268, "epss_percentile": 0.50063}, "CVE-2024-35956": {"epss_score": 0.00015, "epss_percentile": 0.02552}, "CVE-2024-35957": {"epss_score": 0.00016, "epss_percentile": 0.02907}, "CVE-2024-35958": {"epss_score": 0.0003, "epss_percentile": 0.08024}, "CVE-2024-35959": {"epss_score": 8e-05, "epss_percentile": 0.00571}, "CVE-2024-35960": {"epss_score": 0.01748, "epss_percentile": 0.82083}, "CVE-2024-35961": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-35962": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2024-35963": {"epss_score": 9e-05, "epss_percentile": 0.0071}, "CVE-2024-35964": {"epss_score": 9e-05, "epss_percentile": 0.00595}, "CVE-2024-35965": {"epss_score": 7e-05, "epss_percentile": 0.00431}, "CVE-2024-35966": {"epss_score": 7e-05, "epss_percentile": 0.00378}, "CVE-2024-35967": {"epss_score": 7e-05, "epss_percentile": 0.00431}, "CVE-2024-35968": {"epss_score": 6e-05, "epss_percentile": 0.00302}, "CVE-2024-35969": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-35970": {"epss_score": 0.00072, "epss_percentile": 0.22387}, "CVE-2024-35971": {"epss_score": 0.0002, "epss_percentile": 0.04483}, "CVE-2024-35972": {"epss_score": 9e-05, "epss_percentile": 0.00657}, "CVE-2024-35973": {"epss_score": 8e-05, "epss_percentile": 0.00525}, "CVE-2024-35974": {"epss_score": 0.00018, "epss_percentile": 0.03931}, "CVE-2024-35975": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-35976": {"epss_score": 0.00012, "epss_percentile": 0.01172}, "CVE-2024-35977": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-35978": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2024-35979": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2024-35980": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-35981": {"epss_score": 0.00026, "epss_percentile": 0.06456}, "CVE-2024-35982": {"epss_score": 3e-05, "epss_percentile": 0.0012}, "CVE-2024-35983": {"epss_score": 0.00014, "epss_percentile": 0.01844}, "CVE-2024-35984": {"epss_score": 0.00011, "epss_percentile": 0.01047}, "CVE-2024-35985": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-35986": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2024-35987": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-35988": {"epss_score": 0.00026, "epss_percentile": 0.06588}, "CVE-2024-35989": {"epss_score": 0.00016, "epss_percentile": 0.02652}, "CVE-2024-35990": {"epss_score": 0.0002, "epss_percentile": 0.04633}, "CVE-2024-35991": {"epss_score": 0.00013, "epss_percentile": 0.01488}, "CVE-2024-35992": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2024-35993": {"epss_score": 0.00064, "epss_percentile": 0.20367}, "CVE-2024-35994": {"epss_score": 0.00018, "epss_percentile": 0.03754}, "CVE-2024-35995": {"epss_score": 0.00016, "epss_percentile": 0.03035}, "CVE-2024-35996": {"epss_score": 0.00037, "epss_percentile": 0.10683}, "CVE-2024-35997": {"epss_score": 0.0001, "epss_percentile": 0.00894}, "CVE-2024-35998": {"epss_score": 0.00026, "epss_percentile": 0.064}, "CVE-2024-35999": {"epss_score": 0.00026, "epss_percentile": 0.064}, "CVE-2024-36000": {"epss_score": 8e-05, "epss_percentile": 0.00539}, "CVE-2024-36001": {"epss_score": 0.00032, "epss_percentile": 0.09071}, "CVE-2024-36002": {"epss_score": 0.00018, "epss_percentile": 0.03857}, "CVE-2024-36003": {"epss_score": 0.00013, "epss_percentile": 0.01488}, "CVE-2024-36004": {"epss_score": 0.00012, "epss_percentile": 0.01339}, "CVE-2024-36005": {"epss_score": 0.00013, "epss_percentile": 0.01572}, "CVE-2024-36006": {"epss_score": 0.00012, "epss_percentile": 0.01422}, "CVE-2024-36007": {"epss_score": 0.00012, "epss_percentile": 0.01131}, "CVE-2024-36008": {"epss_score": 0.00015, "epss_percentile": 0.02506}, "CVE-2024-36009": {"epss_score": 0.00015, "epss_percentile": 0.02331}, "CVE-2024-36010": {"epss_score": 0.00018, "epss_percentile": 0.03857}, "CVE-2024-36011": {"epss_score": 0.00019, "epss_percentile": 0.04289}, "CVE-2024-36012": {"epss_score": 0.00027, "epss_percentile": 0.07121}, "CVE-2024-36013": {"epss_score": 0.00084, "epss_percentile": 0.2483}, "CVE-2024-36014": {"epss_score": 0.00027, "epss_percentile": 0.06939}, "CVE-2024-36015": {"epss_score": 0.0002, "epss_percentile": 0.04429}, "CVE-2024-36016": {"epss_score": 0.00017, "epss_percentile": 0.03226}, "CVE-2024-36017": {"epss_score": 0.00021, "epss_percentile": 0.04781}, "CVE-2024-36018": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2024-36019": {"epss_score": 0.0002, "epss_percentile": 0.04477}, "CVE-2024-36020": {"epss_score": 0.00013, "epss_percentile": 0.01661}, "CVE-2024-36021": {"epss_score": 0.00019, "epss_percentile": 0.04289}, "CVE-2024-36023": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-36024": {"epss_score": 0.00055, "epss_percentile": 0.17383}, "CVE-2024-36025": {"epss_score": 0.0002, "epss_percentile": 0.04519}, "CVE-2024-36026": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-36027": {"epss_score": 0.00017, "epss_percentile": 0.03323}, "CVE-2024-36028": {"epss_score": 0.00012, "epss_percentile": 0.01249}, "CVE-2024-36029": {"epss_score": 0.00011, "epss_percentile": 0.01017}, "CVE-2024-36030": {"epss_score": 0.00017, "epss_percentile": 0.03483}, "CVE-2024-36031": {"epss_score": 0.00035, "epss_percentile": 0.09876}, "CVE-2024-36032": {"epss_score": 0.00014, "epss_percentile": 0.01886}, "CVE-2024-36033": {"epss_score": 0.00017, "epss_percentile": 0.03251}, "CVE-2024-36034": {"epss_score": 0.00684, "epss_percentile": 0.71119}, "CVE-2024-36035": {"epss_score": 0.00684, "epss_percentile": 0.71119}, "CVE-2024-36036": {"epss_score": 0.00107, "epss_percentile": 0.29618}, "CVE-2024-36037": {"epss_score": 0.00108, "epss_percentile": 0.29777}, "CVE-2024-36038": {"epss_score": 0.00133, "epss_percentile": 0.33672}, "CVE-2024-36039": {"epss_score": 0.00092, "epss_percentile": 0.26569}, "CVE-2024-36041": {"epss_score": 0.00096, "epss_percentile": 0.27345}, "CVE-2024-36042": {"epss_score": 0.00282, "epss_percentile": 0.51212}, "CVE-2024-36043": {"epss_score": 0.00218, "epss_percentile": 0.44353}, "CVE-2024-36046": {"epss_score": 0.00156, "epss_percentile": 0.3699}, "CVE-2024-36047": {"epss_score": 0.00193, "epss_percentile": 0.41429}, "CVE-2024-36048": {"epss_score": 0.00483, "epss_percentile": 0.64617}, "CVE-2024-36049": {"epss_score": 0.00074, "epss_percentile": 0.22879}, "CVE-2024-36050": {"epss_score": 0.00178, "epss_percentile": 0.39681}, "CVE-2024-36052": {"epss_score": 0.00122, "epss_percentile": 0.32057}, "CVE-2024-36053": {"epss_score": 0.01117, "epss_percentile": 0.77739}, "CVE-2024-36054": {"epss_score": 0.00084, "epss_percentile": 0.2494}, "CVE-2024-36055": {"epss_score": 0.0005, "epss_percentile": 0.15717}, "CVE-2024-36056": {"epss_score": 0.00148, "epss_percentile": 0.35896}, "CVE-2024-36059": {"epss_score": 0.00835, "epss_percentile": 0.7412}, "CVE-2024-36060": {"epss_score": 0.00268, "epss_percentile": 0.50038}, "CVE-2024-36061": {"epss_score": 0.00726, "epss_percentile": 0.72081}, "CVE-2024-36062": {"epss_score": 0.00024, "epss_percentile": 0.05865}, "CVE-2024-36063": {"epss_score": 0.00085, "epss_percentile": 0.25038}, "CVE-2024-36064": {"epss_score": 0.00053, "epss_percentile": 0.16838}, "CVE-2024-36066": {"epss_score": 0.00293, "epss_percentile": 0.52296}, "CVE-2024-36068": {"epss_score": 0.0049, "epss_percentile": 0.64928}, "CVE-2024-36070": {"epss_score": 0.0021, "epss_percentile": 0.43493}, "CVE-2024-36071": {"epss_score": 0.00102, "epss_percentile": 0.28735}, "CVE-2024-36072": {"epss_score": 0.05927, "epss_percentile": 0.90333}, "CVE-2024-36073": {"epss_score": 0.03127, "epss_percentile": 0.86458}, "CVE-2024-36074": {"epss_score": 0.03814, "epss_percentile": 0.87764}, "CVE-2024-36075": {"epss_score": 0.01129, "epss_percentile": 0.7784}, "CVE-2024-36076": {"epss_score": 0.00403, "epss_percentile": 0.6033}, "CVE-2024-36077": {"epss_score": 0.0107, "epss_percentile": 0.77255}, "CVE-2024-36078": {"epss_score": 0.00091, "epss_percentile": 0.2625}, "CVE-2024-36079": {"epss_score": 0.006, "epss_percentile": 0.68831}, "CVE-2024-36080": {"epss_score": 0.00109, "epss_percentile": 0.29993}, "CVE-2024-36081": {"epss_score": 0.00156, "epss_percentile": 0.36993}, "CVE-2024-36082": {"epss_score": 0.00819, "epss_percentile": 0.73863}, "CVE-2024-36103": {"epss_score": 0.00258, "epss_percentile": 0.48989}, "CVE-2024-36104": {"epss_score": 0.93391, "epss_percentile": 0.99803}, "CVE-2024-36105": {"epss_score": 0.00265, "epss_percentile": 0.49774}, "CVE-2024-36106": {"epss_score": 0.0064, "epss_percentile": 0.6997}, "CVE-2024-36107": {"epss_score": 0.00143, "epss_percentile": 0.35188}, "CVE-2024-36108": {"epss_score": 0.00068, "epss_percentile": 0.21295}, "CVE-2024-36109": {"epss_score": 0.00204, "epss_percentile": 0.42608}, "CVE-2024-36110": {"epss_score": 0.00249, "epss_percentile": 0.48086}, "CVE-2024-36111": {"epss_score": 0.61088, "epss_percentile": 0.98234}, "CVE-2024-36112": {"epss_score": 0.0015, "epss_percentile": 0.36102}, "CVE-2024-36113": {"epss_score": 0.00084, "epss_percentile": 0.24964}, "CVE-2024-36114": {"epss_score": 0.0012, "epss_percentile": 0.3179}, "CVE-2024-36115": {"epss_score": 0.03068, "epss_percentile": 0.86342}, "CVE-2024-36116": {"epss_score": 0.28478, "epss_percentile": 0.96362}, "CVE-2024-36117": {"epss_score": 0.73777, "epss_percentile": 0.98772}, "CVE-2024-36118": {"epss_score": 0.0025, "epss_percentile": 0.48213}, "CVE-2024-36119": {"epss_score": 0.00021, "epss_percentile": 0.04736}, "CVE-2024-36120": {"epss_score": 0.00292, "epss_percentile": 0.52262}, "CVE-2024-36121": {"epss_score": 0.00404, "epss_percentile": 0.60413}, "CVE-2024-36122": {"epss_score": 0.00137, "epss_percentile": 0.34284}, "CVE-2024-36123": {"epss_score": 0.0044, "epss_percentile": 0.62649}, "CVE-2024-36124": {"epss_score": 0.00237, "epss_percentile": 0.46661}, "CVE-2024-36127": {"epss_score": 0.00206, "epss_percentile": 0.42766}, "CVE-2024-36128": {"epss_score": 0.00461, "epss_percentile": 0.63543}, "CVE-2024-36129": {"epss_score": 0.0212, "epss_percentile": 0.83673}, "CVE-2024-36130": {"epss_score": 0.02228, "epss_percentile": 0.84074}, "CVE-2024-36131": {"epss_score": 0.03126, "epss_percentile": 0.86455}, "CVE-2024-36132": {"epss_score": 0.01027, "epss_percentile": 0.76802}, "CVE-2024-36136": {"epss_score": 0.04105, "epss_percentile": 0.88266}, "CVE-2024-36137": {"epss_score": 0.0008, "epss_percentile": 0.24053}, "CVE-2024-36138": {"epss_score": 0.00192, "epss_percentile": 0.41305}, "CVE-2024-36140": {"epss_score": 0.00203, "epss_percentile": 0.4256}, "CVE-2024-36141": {"epss_score": 0.01108, "epss_percentile": 0.77632}, "CVE-2024-36142": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36143": {"epss_score": 0.01195, "epss_percentile": 0.78431}, "CVE-2024-36144": {"epss_score": 0.00791, "epss_percentile": 0.73392}, "CVE-2024-36146": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36147": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36148": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36149": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36150": {"epss_score": 0.01195, "epss_percentile": 0.78431}, "CVE-2024-36151": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36152": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36153": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36154": {"epss_score": 0.01108, "epss_percentile": 0.77632}, "CVE-2024-36155": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36156": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36157": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36158": {"epss_score": 0.01108, "epss_percentile": 0.77632}, "CVE-2024-36159": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36160": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36161": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36162": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36163": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36164": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36165": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36166": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36167": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36168": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36169": {"epss_score": 0.01195, "epss_percentile": 0.78431}, "CVE-2024-36170": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36171": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36172": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36173": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36174": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36175": {"epss_score": 0.01195, "epss_percentile": 0.78431}, "CVE-2024-36176": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36177": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36178": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36179": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36180": {"epss_score": 0.01072, "epss_percentile": 0.77276}, "CVE-2024-36181": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36182": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36183": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36184": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36185": {"epss_score": 0.01072, "epss_percentile": 0.77276}, "CVE-2024-36186": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36187": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36188": {"epss_score": 0.00791, "epss_percentile": 0.73392}, "CVE-2024-36189": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36190": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36191": {"epss_score": 0.01195, "epss_percentile": 0.78431}, "CVE-2024-36192": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36193": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36194": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36195": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36196": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36197": {"epss_score": 0.01267, "epss_percentile": 0.79016}, "CVE-2024-36198": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36199": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36200": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36201": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36202": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36203": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36204": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36205": {"epss_score": 0.00974, "epss_percentile": 0.76191}, "CVE-2024-36206": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36207": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36208": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36209": {"epss_score": 0.01318, "epss_percentile": 0.79429}, "CVE-2024-36210": {"epss_score": 0.01479, "epss_percentile": 0.80559}, "CVE-2024-36211": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36212": {"epss_score": 0.00883, "epss_percentile": 0.74911}, "CVE-2024-36213": {"epss_score": 0.01072, "epss_percentile": 0.77276}, "CVE-2024-36214": {"epss_score": 0.01615, "epss_percentile": 0.81354}, "CVE-2024-36215": {"epss_score": 0.01957, "epss_percentile": 0.83045}, "CVE-2024-36216": {"epss_score": 0.0244, "epss_percentile": 0.84753}, "CVE-2024-36217": {"epss_score": 0.0145, "epss_percentile": 0.80353}, "CVE-2024-36218": {"epss_score": 0.0145, "epss_percentile": 0.80353}, "CVE-2024-36219": {"epss_score": 0.0145, "epss_percentile": 0.80353}, "CVE-2024-36220": {"epss_score": 0.03605, "epss_percentile": 0.87416}, "CVE-2024-36221": {"epss_score": 0.0145, "epss_percentile": 0.80353}, "CVE-2024-36222": {"epss_score": 0.02687, "epss_percentile": 0.8543}, "CVE-2024-36224": {"epss_score": 0.0145, "epss_percentile": 0.80353}, "CVE-2024-36225": {"epss_score": 0.01957, "epss_percentile": 0.83045}, "CVE-2024-36226": {"epss_score": 0.00326, "epss_percentile": 0.55089}, "CVE-2024-36227": {"epss_score": 0.01957, "epss_percentile": 0.83045}, "CVE-2024-36228": {"epss_score": 0.0244, "epss_percentile": 0.84753}, "CVE-2024-36229": {"epss_score": 0.01957, "epss_percentile": 0.83045}, "CVE-2024-36230": {"epss_score": 0.05067, "epss_percentile": 0.89458}, "CVE-2024-36231": {"epss_score": 0.10804, "epss_percentile": 0.93108}, "CVE-2024-36232": {"epss_score": 0.0145, "epss_percentile": 0.80353}, "CVE-2024-36233": {"epss_score": 0.0145, "epss_percentile": 0.80353}, "CVE-2024-36234": {"epss_score": 0.0145, "epss_percentile": 0.80353}, "CVE-2024-36235": {"epss_score": 0.05067, "epss_percentile": 0.89458}, "CVE-2024-36236": {"epss_score": 0.01626, "epss_percentile": 0.81426}, "CVE-2024-36238": {"epss_score": 0.0145, "epss_percentile": 0.80353}, "CVE-2024-36239": {"epss_score": 0.01957, "epss_percentile": 0.83045}, "CVE-2024-36241": {"epss_score": 0.00278, "epss_percentile": 0.50846}, "CVE-2024-36242": {"epss_score": 0.00077, "epss_percentile": 0.23521}, "CVE-2024-36243": {"epss_score": 0.01959, "epss_percentile": 0.83054}, "CVE-2024-36244": {"epss_score": 0.00013, "epss_percentile": 0.01623}, "CVE-2024-36245": {"epss_score": 0.00047, "epss_percentile": 0.14664}, "CVE-2024-36246": {"epss_score": 0.0027, "epss_percentile": 0.50264}, "CVE-2024-36247": {"epss_score": 0.00121, "epss_percentile": 0.31936}, "CVE-2024-36248": {"epss_score": 0.00104, "epss_percentile": 0.29244}, "CVE-2024-36249": {"epss_score": 0.00123, "epss_percentile": 0.32231}, "CVE-2024-36250": {"epss_score": 0.00263, "epss_percentile": 0.49515}, "CVE-2024-36251": {"epss_score": 0.00307, "epss_percentile": 0.53566}, "CVE-2024-36252": {"epss_score": 0.00065, "epss_percentile": 0.2066}, "CVE-2024-36253": {"epss_score": 0.00112, "epss_percentile": 0.30435}, "CVE-2024-36254": {"epss_score": 0.00121, "epss_percentile": 0.31961}, "CVE-2024-36255": {"epss_score": 0.00162, "epss_percentile": 0.37727}, "CVE-2024-36257": {"epss_score": 0.00155, "epss_percentile": 0.36801}, "CVE-2024-36258": {"epss_score": 0.02587, "epss_percentile": 0.85171}, "CVE-2024-36259": {"epss_score": 0.00144, "epss_percentile": 0.35242}, "CVE-2024-36260": {"epss_score": 0.01959, "epss_percentile": 0.83054}, "CVE-2024-36261": {"epss_score": 0.00121, "epss_percentile": 0.31936}, "CVE-2024-36262": {"epss_score": 0.00021, "epss_percentile": 0.04747}, "CVE-2024-36263": {"epss_score": 0.00809, "epss_percentile": 0.73711}, "CVE-2024-36264": {"epss_score": 0.00224, "epss_percentile": 0.45015}, "CVE-2024-36265": {"epss_score": 0.00369, "epss_percentile": 0.58247}, "CVE-2024-36266": {"epss_score": 0.00019, "epss_percentile": 0.04138}, "CVE-2024-36267": {"epss_score": 0.00276, "epss_percentile": 0.5076}, "CVE-2024-36268": {"epss_score": 0.04746, "epss_percentile": 0.89098}, "CVE-2024-36270": {"epss_score": 0.0001, "epss_percentile": 0.0076}, "CVE-2024-36272": {"epss_score": 0.00477, "epss_percentile": 0.64348}, "CVE-2024-36274": {"epss_score": 0.00043, "epss_percentile": 0.13205}, "CVE-2024-36275": {"epss_score": 0.00046, "epss_percentile": 0.1436}, "CVE-2024-36276": {"epss_score": 0.00057, "epss_percentile": 0.1816}, "CVE-2024-36277": {"epss_score": 0.00062, "epss_percentile": 0.19678}, "CVE-2024-36278": {"epss_score": 0.00047, "epss_percentile": 0.14629}, "CVE-2024-36279": {"epss_score": 0.0009, "epss_percentile": 0.26144}, "CVE-2024-36280": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-36281": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-36282": {"epss_score": 0.00083, "epss_percentile": 0.24715}, "CVE-2024-36283": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-36284": {"epss_score": 0.00051, "epss_percentile": 0.16015}, "CVE-2024-36285": {"epss_score": 0.00018, "epss_percentile": 0.03942}, "CVE-2024-36286": {"epss_score": 0.0001, "epss_percentile": 0.00802}, "CVE-2024-36287": {"epss_score": 0.00036, "epss_percentile": 0.10327}, "CVE-2024-36288": {"epss_score": 8e-05, "epss_percentile": 0.00518}, "CVE-2024-36289": {"epss_score": 0.00117, "epss_percentile": 0.31277}, "CVE-2024-36290": {"epss_score": 0.00684, "epss_percentile": 0.7112}, "CVE-2024-36291": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-36292": {"epss_score": 0.00024, "epss_percentile": 0.05897}, "CVE-2024-36293": {"epss_score": 0.00042, "epss_percentile": 0.12621}, "CVE-2024-36294": {"epss_score": 0.00053, "epss_percentile": 0.16703}, "CVE-2024-36295": {"epss_score": 0.0274, "epss_percentile": 0.85559}, "CVE-2024-36302": {"epss_score": 0.00056, "epss_percentile": 0.1791}, "CVE-2024-36303": {"epss_score": 0.001, "epss_percentile": 0.28509}, "CVE-2024-36304": {"epss_score": 0.00063, "epss_percentile": 0.19998}, "CVE-2024-36305": {"epss_score": 0.00149, "epss_percentile": 0.35962}, "CVE-2024-36306": {"epss_score": 0.00103, "epss_percentile": 0.29061}, "CVE-2024-36307": {"epss_score": 0.00075, "epss_percentile": 0.22952}, "CVE-2024-36321": {"epss_score": 0.00014, "epss_percentile": 0.01887}, "CVE-2024-36326": {"epss_score": 0.00021, "epss_percentile": 0.04726}, "CVE-2024-36328": {"epss_score": 0.00026, "epss_percentile": 0.06417}, "CVE-2024-36331": {"epss_score": 0.00015, "epss_percentile": 0.02432}, "CVE-2024-36336": {"epss_score": 0.00024, "epss_percentile": 0.0602}, "CVE-2024-36337": {"epss_score": 0.00024, "epss_percentile": 0.0602}, "CVE-2024-36339": {"epss_score": 0.00014, "epss_percentile": 0.01853}, "CVE-2024-36340": {"epss_score": 0.00012, "epss_percentile": 0.01302}, "CVE-2024-36342": {"epss_score": 0.00039, "epss_percentile": 0.11437}, "CVE-2024-36346": {"epss_score": 0.00034, "epss_percentile": 0.09566}, "CVE-2024-36347": {"epss_score": 7e-05, "epss_percentile": 0.00453}, "CVE-2024-36348": {"epss_score": 0.00015, "epss_percentile": 0.02592}, "CVE-2024-36349": {"epss_score": 0.00015, "epss_percentile": 0.02592}, "CVE-2024-36350": {"epss_score": 0.00017, "epss_percentile": 0.03492}, "CVE-2024-36352": {"epss_score": 0.00032, "epss_percentile": 0.08816}, "CVE-2024-36353": {"epss_score": 0.00039, "epss_percentile": 0.11627}, "CVE-2024-36354": {"epss_score": 0.00019, "epss_percentile": 0.04388}, "CVE-2024-36357": {"epss_score": 0.00018, "epss_percentile": 0.03827}, "CVE-2024-36358": {"epss_score": 0.00096, "epss_percentile": 0.2739}, "CVE-2024-36359": {"epss_score": 0.00223, "epss_percentile": 0.44902}, "CVE-2024-36360": {"epss_score": 0.02494, "epss_percentile": 0.84904}, "CVE-2024-36361": {"epss_score": 0.00273, "epss_percentile": 0.50457}, "CVE-2024-36362": {"epss_score": 9e-05, "epss_percentile": 0.00627}, "CVE-2024-36363": {"epss_score": 0.42435, "epss_percentile": 0.97332}, "CVE-2024-36364": {"epss_score": 6e-05, "epss_percentile": 0.0024}, "CVE-2024-36365": {"epss_score": 9e-05, "epss_percentile": 0.00717}, "CVE-2024-36366": {"epss_score": 0.25613, "epss_percentile": 0.9605}, "CVE-2024-36367": {"epss_score": 0.13032, "epss_percentile": 0.93851}, "CVE-2024-36368": {"epss_score": 0.0066, "epss_percentile": 0.7053}, "CVE-2024-36369": {"epss_score": 0.42435, "epss_percentile": 0.97332}, "CVE-2024-36370": {"epss_score": 0.32105, "epss_percentile": 0.96672}, "CVE-2024-36371": {"epss_score": 0.4089, "epss_percentile": 0.97243}, "CVE-2024-36372": {"epss_score": 0.13032, "epss_percentile": 0.93851}, "CVE-2024-36373": {"epss_score": 0.37478, "epss_percentile": 0.9705}, "CVE-2024-36374": {"epss_score": 0.27628, "epss_percentile": 0.96266}, "CVE-2024-36375": {"epss_score": 0.0001, "epss_percentile": 0.00808}, "CVE-2024-36376": {"epss_score": 4e-05, "epss_percentile": 0.00151}, "CVE-2024-36377": {"epss_score": 4e-05, "epss_percentile": 0.00151}, "CVE-2024-36378": {"epss_score": 9e-05, "epss_percentile": 0.00665}, "CVE-2024-36383": {"epss_score": 0.00212, "epss_percentile": 0.4378}, "CVE-2024-36384": {"epss_score": 0.00218, "epss_percentile": 0.44353}, "CVE-2024-36387": {"epss_score": 0.00152, "epss_percentile": 0.36443}, "CVE-2024-36388": {"epss_score": 0.00201, "epss_percentile": 0.42344}, "CVE-2024-36389": {"epss_score": 0.00073, "epss_percentile": 0.22667}, "CVE-2024-36390": {"epss_score": 0.00115, "epss_percentile": 0.31019}, "CVE-2024-36391": {"epss_score": 0.00045, "epss_percentile": 0.1396}, "CVE-2024-36392": {"epss_score": 0.00212, "epss_percentile": 0.43728}, "CVE-2024-36393": {"epss_score": 0.00255, "epss_percentile": 0.48675}, "CVE-2024-36394": {"epss_score": 0.0015, "epss_percentile": 0.36183}, "CVE-2024-36395": {"epss_score": 0.00166, "epss_percentile": 0.38248}, "CVE-2024-36396": {"epss_score": 0.00181, "epss_percentile": 0.40116}, "CVE-2024-36397": {"epss_score": 0.0015, "epss_percentile": 0.36141}, "CVE-2024-36398": {"epss_score": 0.00137, "epss_percentile": 0.34264}, "CVE-2024-36399": {"epss_score": 0.00178, "epss_percentile": 0.39696}, "CVE-2024-36400": {"epss_score": 0.00333, "epss_percentile": 0.55649}, "CVE-2024-36401": {"epss_score": 0.94425, "epss_percentile": 0.9998}, "CVE-2024-36402": {"epss_score": 0.00136, "epss_percentile": 0.34109}, "CVE-2024-36403": {"epss_score": 0.00442, "epss_percentile": 0.6274}, "CVE-2024-36404": {"epss_score": 0.90268, "epss_percentile": 0.99573}, "CVE-2024-36405": {"epss_score": 0.00453, "epss_percentile": 0.63205}, "CVE-2024-36406": {"epss_score": 0.00213, "epss_percentile": 0.43834}, "CVE-2024-36407": {"epss_score": 0.0021, "epss_percentile": 0.43485}, "CVE-2024-36408": {"epss_score": 0.00237, "epss_percentile": 0.46647}, "CVE-2024-36409": {"epss_score": 0.00237, "epss_percentile": 0.46647}, "CVE-2024-36410": {"epss_score": 0.00065, "epss_percentile": 0.20654}, "CVE-2024-36411": {"epss_score": 0.00237, "epss_percentile": 0.46647}, "CVE-2024-36412": {"epss_score": 0.93636, "epss_percentile": 0.99827}, "CVE-2024-36413": {"epss_score": 0.00456, "epss_percentile": 0.63346}, "CVE-2024-36414": {"epss_score": 0.00261, "epss_percentile": 0.49289}, "CVE-2024-36415": {"epss_score": 0.05844, "epss_percentile": 0.90254}, "CVE-2024-36416": {"epss_score": 0.44701, "epss_percentile": 0.9745}, "CVE-2024-36417": {"epss_score": 0.00793, "epss_percentile": 0.73424}, "CVE-2024-36418": {"epss_score": 0.06213, "epss_percentile": 0.90572}, "CVE-2024-36419": {"epss_score": 0.00269, "epss_percentile": 0.50169}, "CVE-2024-36420": {"epss_score": 0.00259, "epss_percentile": 0.49037}, "CVE-2024-36421": {"epss_score": 0.02567, "epss_percentile": 0.85118}, "CVE-2024-36422": {"epss_score": 0.00238, "epss_percentile": 0.46764}, "CVE-2024-36423": {"epss_score": 0.0032, "epss_percentile": 0.54586}, "CVE-2024-36424": {"epss_score": 0.00728, "epss_percentile": 0.72108}, "CVE-2024-36426": {"epss_score": 0.00133, "epss_percentile": 0.33666}, "CVE-2024-36427": {"epss_score": 0.00549, "epss_percentile": 0.67304}, "CVE-2024-36428": {"epss_score": 0.77103, "epss_percentile": 0.98921}, "CVE-2024-36432": {"epss_score": 0.00045, "epss_percentile": 0.13807}, "CVE-2024-36433": {"epss_score": 0.00045, "epss_percentile": 0.13807}, "CVE-2024-36434": {"epss_score": 0.00045, "epss_percentile": 0.13807}, "CVE-2024-36435": {"epss_score": 0.1287, "epss_percentile": 0.93806}, "CVE-2024-36437": {"epss_score": 0.00094, "epss_percentile": 0.2698}, "CVE-2024-36438": {"epss_score": 0.00027, "epss_percentile": 0.06947}, "CVE-2024-36439": {"epss_score": 0.00638, "epss_percentile": 0.69911}, "CVE-2024-36440": {"epss_score": 0.00037, "epss_percentile": 0.10904}, "CVE-2024-36441": {"epss_score": 0.00065, "epss_percentile": 0.20544}, "CVE-2024-36442": {"epss_score": 0.00122, "epss_percentile": 0.32087}, "CVE-2024-36443": {"epss_score": 0.00334, "epss_percentile": 0.55719}, "CVE-2024-36444": {"epss_score": 0.00088, "epss_percentile": 0.25745}, "CVE-2024-36445": {"epss_score": 0.00613, "epss_percentile": 0.69249}, "CVE-2024-36446": {"epss_score": 0.00235, "epss_percentile": 0.46342}, "CVE-2024-36448": {"epss_score": 0.00117, "epss_percentile": 0.31336}, "CVE-2024-36450": {"epss_score": 0.0024, "epss_percentile": 0.4694}, "CVE-2024-36451": {"epss_score": 0.00149, "epss_percentile": 0.3601}, "CVE-2024-36452": {"epss_score": 0.00146, "epss_percentile": 0.35594}, "CVE-2024-36453": {"epss_score": 0.00298, "epss_percentile": 0.52819}, "CVE-2024-36454": {"epss_score": 0.00109, "epss_percentile": 0.30005}, "CVE-2024-36455": {"epss_score": 0.0113, "epss_percentile": 0.7785}, "CVE-2024-36456": {"epss_score": 0.01313, "epss_percentile": 0.79384}, "CVE-2024-36457": {"epss_score": 0.00028, "epss_percentile": 0.07277}, "CVE-2024-36458": {"epss_score": 0.00066, "epss_percentile": 0.20876}, "CVE-2024-36459": {"epss_score": 0.00322, "epss_percentile": 0.54818}, "CVE-2024-36460": {"epss_score": 0.00407, "epss_percentile": 0.60592}, "CVE-2024-36461": {"epss_score": 0.00605, "epss_percentile": 0.68983}, "CVE-2024-36462": {"epss_score": 0.00196, "epss_percentile": 0.41773}, "CVE-2024-36463": {"epss_score": 0.00378, "epss_percentile": 0.58792}, "CVE-2024-36464": {"epss_score": 0.00041, "epss_percentile": 0.1237}, "CVE-2024-36465": {"epss_score": 0.00164, "epss_percentile": 0.37868}, "CVE-2024-36466": {"epss_score": 0.00194, "epss_percentile": 0.41549}, "CVE-2024-36467": {"epss_score": 0.00241, "epss_percentile": 0.47268}, "CVE-2024-36468": {"epss_score": 0.00241, "epss_percentile": 0.47277}, "CVE-2024-36469": {"epss_score": 0.00047, "epss_percentile": 0.14481}, "CVE-2024-36470": {"epss_score": 3e-05, "epss_percentile": 0.00089}, "CVE-2024-36471": {"epss_score": 0.0031, "epss_percentile": 0.53743}, "CVE-2024-36472": {"epss_score": 0.00129, "epss_percentile": 0.33096}, "CVE-2024-36473": {"epss_score": 0.00082, "epss_percentile": 0.24515}, "CVE-2024-36474": {"epss_score": 0.00042, "epss_percentile": 0.12892}, "CVE-2024-36475": {"epss_score": 0.00507, "epss_percentile": 0.65658}, "CVE-2024-36476": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-36477": {"epss_score": 0.00027, "epss_percentile": 0.07121}, "CVE-2024-36478": {"epss_score": 0.00012, "epss_percentile": 0.01338}, "CVE-2024-36479": {"epss_score": 0.00017, "epss_percentile": 0.03101}, "CVE-2024-36480": {"epss_score": 0.00152, "epss_percentile": 0.3641}, "CVE-2024-36481": {"epss_score": 0.00019, "epss_percentile": 0.04289}, "CVE-2024-36482": {"epss_score": 0.00107, "epss_percentile": 0.29652}, "CVE-2024-36484": {"epss_score": 0.00013, "epss_percentile": 0.01552}, "CVE-2024-36485": {"epss_score": 0.00261, "epss_percentile": 0.49252}, "CVE-2024-36486": {"epss_score": 0.00057, "epss_percentile": 0.18167}, "CVE-2024-36488": {"epss_score": 0.00063, "epss_percentile": 0.19922}, "CVE-2024-36489": {"epss_score": 0.0001, "epss_percentile": 0.00893}, "CVE-2024-36491": {"epss_score": 0.013, "epss_percentile": 0.79285}, "CVE-2024-36492": {"epss_score": 0.00207, "epss_percentile": 0.43179}, "CVE-2024-36493": {"epss_score": 0.0136, "epss_percentile": 0.79746}, "CVE-2024-36494": {"epss_score": 0.00098, "epss_percentile": 0.27789}, "CVE-2024-36495": {"epss_score": 0.00043, "epss_percentile": 0.13282}, "CVE-2024-36496": {"epss_score": 0.00271, "epss_percentile": 0.50287}, "CVE-2024-36497": {"epss_score": 0.00141, "epss_percentile": 0.34919}, "CVE-2024-36498": {"epss_score": 0.00098, "epss_percentile": 0.27789}, "CVE-2024-36499": {"epss_score": 0.00055, "epss_percentile": 0.17422}, "CVE-2024-36500": {"epss_score": 0.00069, "epss_percentile": 0.21622}, "CVE-2024-36501": {"epss_score": 0.00051, "epss_percentile": 0.16248}, "CVE-2024-36502": {"epss_score": 0.0005, "epss_percentile": 0.15664}, "CVE-2024-36503": {"epss_score": 0.00058, "epss_percentile": 0.18274}, "CVE-2024-36504": {"epss_score": 0.00244, "epss_percentile": 0.47555}, "CVE-2024-36505": {"epss_score": 0.00019, "epss_percentile": 0.04411}, "CVE-2024-36506": {"epss_score": 0.00117, "epss_percentile": 0.31215}, "CVE-2024-36507": {"epss_score": 0.00068, "epss_percentile": 0.21404}, "CVE-2024-36508": {"epss_score": 0.0012, "epss_percentile": 0.31791}, "CVE-2024-36509": {"epss_score": 0.00048, "epss_percentile": 0.15133}, "CVE-2024-36510": {"epss_score": 0.00174, "epss_percentile": 0.39178}, "CVE-2024-36511": {"epss_score": 0.003, "epss_percentile": 0.5296}, "CVE-2024-36512": {"epss_score": 0.00394, "epss_percentile": 0.5975}, "CVE-2024-36513": {"epss_score": 0.00161, "epss_percentile": 0.3759}, "CVE-2024-36514": {"epss_score": 0.00504, "epss_percentile": 0.65544}, "CVE-2024-36515": {"epss_score": 0.00504, "epss_percentile": 0.65544}, "CVE-2024-36516": {"epss_score": 0.00504, "epss_percentile": 0.65544}, "CVE-2024-36517": {"epss_score": 0.0032, "epss_percentile": 0.54587}, "CVE-2024-36518": {"epss_score": 0.00728, "epss_percentile": 0.72114}, "CVE-2024-36522": {"epss_score": 0.08266, "epss_percentile": 0.91958}, "CVE-2024-36523": {"epss_score": 0.00117, "epss_percentile": 0.31205}, "CVE-2024-36526": {"epss_score": 0.00322, "epss_percentile": 0.54794}, "CVE-2024-36527": {"epss_score": 0.88773, "epss_percentile": 0.99489}, "CVE-2024-36528": {"epss_score": 0.00373, "epss_percentile": 0.58479}, "CVE-2024-36531": {"epss_score": 0.00141, "epss_percentile": 0.34841}, "CVE-2024-36532": {"epss_score": 0.00125, "epss_percentile": 0.32504}, "CVE-2024-36533": {"epss_score": 0.00253, "epss_percentile": 0.48416}, "CVE-2024-36534": {"epss_score": 0.00136, "epss_percentile": 0.34126}, "CVE-2024-36535": {"epss_score": 0.00342, "epss_percentile": 0.56358}, "CVE-2024-36536": {"epss_score": 0.00359, "epss_percentile": 0.57602}, "CVE-2024-36537": {"epss_score": 0.00166, "epss_percentile": 0.38232}, "CVE-2024-36538": {"epss_score": 0.00132, "epss_percentile": 0.33595}, "CVE-2024-36539": {"epss_score": 0.13977, "epss_percentile": 0.94105}, "CVE-2024-36540": {"epss_score": 0.00342, "epss_percentile": 0.56358}, "CVE-2024-36541": {"epss_score": 0.00288, "epss_percentile": 0.51979}, "CVE-2024-36542": {"epss_score": 0.00097, "epss_percentile": 0.2753}, "CVE-2024-36543": {"epss_score": 0.00124, "epss_percentile": 0.32387}, "CVE-2024-36547": {"epss_score": 0.00158, "epss_percentile": 0.37258}, "CVE-2024-36548": {"epss_score": 0.00166, "epss_percentile": 0.38143}, "CVE-2024-36549": {"epss_score": 0.00183, "epss_percentile": 0.40308}, "CVE-2024-36550": {"epss_score": 0.00174, "epss_percentile": 0.3916}, "CVE-2024-36553": {"epss_score": 0.00088, "epss_percentile": 0.25726}, "CVE-2024-36554": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2024-36555": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-36556": {"epss_score": 0.00138, "epss_percentile": 0.34514}, "CVE-2024-36557": {"epss_score": 0.0006, "epss_percentile": 0.19214}, "CVE-2024-36558": {"epss_score": 0.00056, "epss_percentile": 0.17891}, "CVE-2024-36568": {"epss_score": 0.00159, "epss_percentile": 0.37379}, "CVE-2024-36569": {"epss_score": 0.00247, "epss_percentile": 0.47907}, "CVE-2024-36572": {"epss_score": 0.00375, "epss_percentile": 0.58625}, "CVE-2024-36573": {"epss_score": 0.00225, "epss_percentile": 0.45227}, "CVE-2024-36574": {"epss_score": 0.00167, "epss_percentile": 0.38307}, "CVE-2024-36575": {"epss_score": 0.00244, "epss_percentile": 0.47554}, "CVE-2024-36577": {"epss_score": 0.00175, "epss_percentile": 0.39339}, "CVE-2024-36578": {"epss_score": 0.00061, "epss_percentile": 0.19544}, "CVE-2024-36580": {"epss_score": 0.00124, "epss_percentile": 0.32384}, "CVE-2024-36581": {"epss_score": 0.00068, "epss_percentile": 0.21336}, "CVE-2024-36582": {"epss_score": 0.00193, "epss_percentile": 0.41383}, "CVE-2024-36583": {"epss_score": 0.00237, "epss_percentile": 0.46656}, "CVE-2024-36586": {"epss_score": 0.0004, "epss_percentile": 0.12001}, "CVE-2024-36587": {"epss_score": 0.0007, "epss_percentile": 0.21694}, "CVE-2024-36588": {"epss_score": 0.00269, "epss_percentile": 0.50117}, "CVE-2024-36589": {"epss_score": 0.00104, "epss_percentile": 0.29225}, "CVE-2024-36597": {"epss_score": 0.86189, "epss_percentile": 0.99371}, "CVE-2024-36598": {"epss_score": 0.002, "epss_percentile": 0.42229}, "CVE-2024-36599": {"epss_score": 0.00166, "epss_percentile": 0.38248}, "CVE-2024-36600": {"epss_score": 0.00113, "epss_percentile": 0.30633}, "CVE-2024-36604": {"epss_score": 0.04904, "epss_percentile": 0.89275}, "CVE-2024-36611": {"epss_score": 0.00126, "epss_percentile": 0.32738}, "CVE-2024-36612": {"epss_score": 0.00139, "epss_percentile": 0.34597}, "CVE-2024-36613": {"epss_score": 0.00045, "epss_percentile": 0.13731}, "CVE-2024-36615": {"epss_score": 0.0007, "epss_percentile": 0.21657}, "CVE-2024-36616": {"epss_score": 0.00073, "epss_percentile": 0.22665}, "CVE-2024-36617": {"epss_score": 0.00018, "epss_percentile": 0.03746}, "CVE-2024-36618": {"epss_score": 0.00033, "epss_percentile": 0.09154}, "CVE-2024-36619": {"epss_score": 0.00036, "epss_percentile": 0.10299}, "CVE-2024-36620": {"epss_score": 0.0006, "epss_percentile": 0.19209}, "CVE-2024-36621": {"epss_score": 0.00055, "epss_percentile": 0.1765}, "CVE-2024-36622": {"epss_score": 0.0061, "epss_percentile": 0.69149}, "CVE-2024-36623": {"epss_score": 0.00054, "epss_percentile": 0.17305}, "CVE-2024-36624": {"epss_score": 0.00075, "epss_percentile": 0.23048}, "CVE-2024-36625": {"epss_score": 0.00069, "epss_percentile": 0.21593}, "CVE-2024-36626": {"epss_score": 0.00053, "epss_percentile": 0.16712}, "CVE-2024-36647": {"epss_score": 0.00775, "epss_percentile": 0.73079}, "CVE-2024-36650": {"epss_score": 0.00304, "epss_percentile": 0.53274}, "CVE-2024-36656": {"epss_score": 0.01056, "epss_percentile": 0.77129}, "CVE-2024-36667": {"epss_score": 0.00161, "epss_percentile": 0.3753}, "CVE-2024-36668": {"epss_score": 0.00182, "epss_percentile": 0.40182}, "CVE-2024-36669": {"epss_score": 0.00176, "epss_percentile": 0.39483}, "CVE-2024-36670": {"epss_score": 0.00188, "epss_percentile": 0.40907}, "CVE-2024-36671": {"epss_score": 0.00093, "epss_percentile": 0.26671}, "CVE-2024-36673": {"epss_score": 0.001, "epss_percentile": 0.28543}, "CVE-2024-36674": {"epss_score": 0.00148, "epss_percentile": 0.35927}, "CVE-2024-36675": {"epss_score": 0.44282, "epss_percentile": 0.97428}, "CVE-2024-36676": {"epss_score": 0.00229, "epss_percentile": 0.45552}, "CVE-2024-36677": {"epss_score": 0.00421, "epss_percentile": 0.61508}, "CVE-2024-36678": {"epss_score": 0.00277, "epss_percentile": 0.50824}, "CVE-2024-36679": {"epss_score": 0.00125, "epss_percentile": 0.3255}, "CVE-2024-36680": {"epss_score": 0.00259, "epss_percentile": 0.49086}, "CVE-2024-36681": {"epss_score": 0.00044, "epss_percentile": 0.13526}, "CVE-2024-36682": {"epss_score": 0.00284, "epss_percentile": 0.5146}, "CVE-2024-36683": {"epss_score": 0.00735, "epss_percentile": 0.72297}, "CVE-2024-36684": {"epss_score": 0.00808, "epss_percentile": 0.73692}, "CVE-2024-36691": {"epss_score": 0.0006, "epss_percentile": 0.19214}, "CVE-2024-36694": {"epss_score": 0.00383, "epss_percentile": 0.59079}, "CVE-2024-36697": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2024-36702": {"epss_score": 0.00121, "epss_percentile": 0.32015}, "CVE-2024-36728": {"epss_score": 0.0514, "epss_percentile": 0.89537}, "CVE-2024-36729": {"epss_score": 0.00136, "epss_percentile": 0.34192}, "CVE-2024-36730": {"epss_score": 0.00221, "epss_percentile": 0.44692}, "CVE-2024-36732": {"epss_score": 0.00221, "epss_percentile": 0.44692}, "CVE-2024-36734": {"epss_score": 0.00163, "epss_percentile": 0.37781}, "CVE-2024-36735": {"epss_score": 0.00156, "epss_percentile": 0.36889}, "CVE-2024-36736": {"epss_score": 0.00149, "epss_percentile": 0.35983}, "CVE-2024-36737": {"epss_score": 0.00221, "epss_percentile": 0.44692}, "CVE-2024-36740": {"epss_score": 0.00219, "epss_percentile": 0.44503}, "CVE-2024-36742": {"epss_score": 0.00165, "epss_percentile": 0.38139}, "CVE-2024-36743": {"epss_score": 0.00361, "epss_percentile": 0.57708}, "CVE-2024-36745": {"epss_score": 0.00165, "epss_percentile": 0.38139}, "CVE-2024-36751": {"epss_score": 0.00061, "epss_percentile": 0.19503}, "CVE-2024-36755": {"epss_score": 0.00128, "epss_percentile": 0.32983}, "CVE-2024-36760": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-36761": {"epss_score": 0.00207, "epss_percentile": 0.432}, "CVE-2024-36773": {"epss_score": 0.0008, "epss_percentile": 0.24137}, "CVE-2024-36774": {"epss_score": 0.00042, "epss_percentile": 0.12562}, "CVE-2024-36775": {"epss_score": 0.00087, "epss_percentile": 0.25533}, "CVE-2024-36779": {"epss_score": 0.00098, "epss_percentile": 0.278}, "CVE-2024-36782": {"epss_score": 0.00488, "epss_percentile": 0.64838}, "CVE-2024-36783": {"epss_score": 0.00315, "epss_percentile": 0.54172}, "CVE-2024-36787": {"epss_score": 0.00021, "epss_percentile": 0.04891}, "CVE-2024-36788": {"epss_score": 0.00088, "epss_percentile": 0.25714}, "CVE-2024-36789": {"epss_score": 0.00096, "epss_percentile": 0.27335}, "CVE-2024-36790": {"epss_score": 0.00049, "epss_percentile": 0.15423}, "CVE-2024-36792": {"epss_score": 0.00106, "epss_percentile": 0.29438}, "CVE-2024-36795": {"epss_score": 0.00115, "epss_percentile": 0.30992}, "CVE-2024-36800": {"epss_score": 0.00104, "epss_percentile": 0.29111}, "CVE-2024-36801": {"epss_score": 0.00351, "epss_percentile": 0.5701}, "CVE-2024-36814": {"epss_score": 0.00274, "epss_percentile": 0.50538}, "CVE-2024-36819": {"epss_score": 0.00217, "epss_percentile": 0.44257}, "CVE-2024-36821": {"epss_score": 0.13083, "epss_percentile": 0.93869}, "CVE-2024-36823": {"epss_score": 0.11858, "epss_percentile": 0.93497}, "CVE-2024-36827": {"epss_score": 0.00067, "epss_percentile": 0.20992}, "CVE-2024-36829": {"epss_score": 0.00171, "epss_percentile": 0.38804}, "CVE-2024-36831": {"epss_score": 0.00185, "epss_percentile": 0.40471}, "CVE-2024-36832": {"epss_score": 0.00144, "epss_percentile": 0.35255}, "CVE-2024-36837": {"epss_score": 0.92213, "epss_percentile": 0.99701}, "CVE-2024-36840": {"epss_score": 0.09812, "epss_percentile": 0.92713}, "CVE-2024-36842": {"epss_score": 0.00213, "epss_percentile": 0.43932}, "CVE-2024-36843": {"epss_score": 0.00446, "epss_percentile": 0.62921}, "CVE-2024-36844": {"epss_score": 0.00338, "epss_percentile": 0.56137}, "CVE-2024-36845": {"epss_score": 0.00152, "epss_percentile": 0.36407}, "CVE-2024-36856": {"epss_score": 0.00945, "epss_percentile": 0.75799}, "CVE-2024-36857": {"epss_score": 0.55135, "epss_percentile": 0.97962}, "CVE-2024-36858": {"epss_score": 0.70738, "epss_percentile": 0.98641}, "CVE-2024-36877": {"epss_score": 0.03437, "epss_percentile": 0.87135}, "CVE-2024-36880": {"epss_score": 0.0002, "epss_percentile": 0.04547}, "CVE-2024-36881": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-36882": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-36883": {"epss_score": 0.00071, "epss_percentile": 0.22212}, "CVE-2024-36884": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-36886": {"epss_score": 0.00935, "epss_percentile": 0.75663}, "CVE-2024-36887": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-36888": {"epss_score": 0.00011, "epss_percentile": 0.00933}, "CVE-2024-36889": {"epss_score": 0.0001, "epss_percentile": 0.0076}, "CVE-2024-36890": {"epss_score": 0.00012, "epss_percentile": 0.01236}, "CVE-2024-36891": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-36892": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-36893": {"epss_score": 9e-05, "epss_percentile": 0.00699}, "CVE-2024-36894": {"epss_score": 0.00014, "epss_percentile": 0.01864}, "CVE-2024-36895": {"epss_score": 0.00021, "epss_percentile": 0.04901}, "CVE-2024-36896": {"epss_score": 0.00073, "epss_percentile": 0.22506}, "CVE-2024-36897": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2024-36898": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-36899": {"epss_score": 7e-05, "epss_percentile": 0.00441}, "CVE-2024-36900": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-36901": {"epss_score": 0.0001, "epss_percentile": 0.00861}, "CVE-2024-36902": {"epss_score": 0.0001, "epss_percentile": 0.00755}, "CVE-2024-36903": {"epss_score": 0.00018, "epss_percentile": 0.03632}, "CVE-2024-36904": {"epss_score": 0.00528, "epss_percentile": 0.66569}, "CVE-2024-36905": {"epss_score": 0.00056, "epss_percentile": 0.17869}, "CVE-2024-36906": {"epss_score": 0.00038, "epss_percentile": 0.11402}, "CVE-2024-36908": {"epss_score": 9e-05, "epss_percentile": 0.0072}, "CVE-2024-36909": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2024-36910": {"epss_score": 9e-05, "epss_percentile": 0.00668}, "CVE-2024-36911": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2024-36912": {"epss_score": 0.00057, "epss_percentile": 0.18189}, "CVE-2024-36913": {"epss_score": 0.00046, "epss_percentile": 0.14109}, "CVE-2024-36914": {"epss_score": 0.00016, "epss_percentile": 0.02748}, "CVE-2024-36915": {"epss_score": 9e-05, "epss_percentile": 0.00706}, "CVE-2024-36916": {"epss_score": 0.00176, "epss_percentile": 0.39413}, "CVE-2024-36917": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-36918": {"epss_score": 0.00019, "epss_percentile": 0.04185}, "CVE-2024-36919": {"epss_score": 0.00084, "epss_percentile": 0.24863}, "CVE-2024-36920": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-36921": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-36922": {"epss_score": 8e-05, "epss_percentile": 0.00571}, "CVE-2024-36924": {"epss_score": 0.00012, "epss_percentile": 0.01249}, "CVE-2024-36925": {"epss_score": 0.00035, "epss_percentile": 0.09941}, "CVE-2024-36926": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-36927": {"epss_score": 0.00014, "epss_percentile": 0.01852}, "CVE-2024-36928": {"epss_score": 8e-05, "epss_percentile": 0.00559}, "CVE-2024-36929": {"epss_score": 0.00054, "epss_percentile": 0.17311}, "CVE-2024-36930": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-36931": {"epss_score": 0.00054, "epss_percentile": 0.17116}, "CVE-2024-36932": {"epss_score": 0.00035, "epss_percentile": 0.09937}, "CVE-2024-36933": {"epss_score": 0.00067, "epss_percentile": 0.21031}, "CVE-2024-36934": {"epss_score": 0.00073, "epss_percentile": 0.22479}, "CVE-2024-36935": {"epss_score": 0.00017, "epss_percentile": 0.03483}, "CVE-2024-36936": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-36937": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2024-36938": {"epss_score": 0.0001, "epss_percentile": 0.00893}, "CVE-2024-36939": {"epss_score": 0.00017, "epss_percentile": 0.03122}, "CVE-2024-36940": {"epss_score": 0.0002, "epss_percentile": 0.04429}, "CVE-2024-36941": {"epss_score": 0.00022, "epss_percentile": 0.05134}, "CVE-2024-36943": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-36944": {"epss_score": 0.00023, "epss_percentile": 0.05328}, "CVE-2024-36945": {"epss_score": 0.00022, "epss_percentile": 0.0517}, "CVE-2024-36946": {"epss_score": 0.00123, "epss_percentile": 0.32292}, "CVE-2024-36947": {"epss_score": 0.00064, "epss_percentile": 0.20184}, "CVE-2024-36948": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-36949": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-36950": {"epss_score": 0.00016, "epss_percentile": 0.02655}, "CVE-2024-36951": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-36952": {"epss_score": 0.00017, "epss_percentile": 0.03233}, "CVE-2024-36953": {"epss_score": 0.00013, "epss_percentile": 0.01721}, "CVE-2024-36954": {"epss_score": 0.00018, "epss_percentile": 0.03611}, "CVE-2024-36955": {"epss_score": 0.00033, "epss_percentile": 0.09394}, "CVE-2024-36956": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-36957": {"epss_score": 0.0003, "epss_percentile": 0.08082}, "CVE-2024-36958": {"epss_score": 0.00032, "epss_percentile": 0.08763}, "CVE-2024-36959": {"epss_score": 0.00027, "epss_percentile": 0.06939}, "CVE-2024-36960": {"epss_score": 0.00012, "epss_percentile": 0.01348}, "CVE-2024-36961": {"epss_score": 0.00024, "epss_percentile": 0.05884}, "CVE-2024-36962": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-36963": {"epss_score": 0.00022, "epss_percentile": 0.05027}, "CVE-2024-36964": {"epss_score": 0.00015, "epss_percentile": 0.02586}, "CVE-2024-36965": {"epss_score": 0.00022, "epss_percentile": 0.05228}, "CVE-2024-36966": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2024-36967": {"epss_score": 0.00022, "epss_percentile": 0.05162}, "CVE-2024-36968": {"epss_score": 0.00018, "epss_percentile": 0.03941}, "CVE-2024-36969": {"epss_score": 0.00022, "epss_percentile": 0.05228}, "CVE-2024-36970": {"epss_score": 0.0002, "epss_percentile": 0.04678}, "CVE-2024-36971": {"epss_score": 0.00443, "epss_percentile": 0.628}, "CVE-2024-36972": {"epss_score": 0.00096, "epss_percentile": 0.27345}, "CVE-2024-36973": {"epss_score": 0.00027, "epss_percentile": 0.06778}, "CVE-2024-36974": {"epss_score": 0.00026, "epss_percentile": 0.06677}, "CVE-2024-36975": {"epss_score": 0.00022, "epss_percentile": 0.05228}, "CVE-2024-36976": {"epss_score": 0.00024, "epss_percentile": 0.05884}, "CVE-2024-36977": {"epss_score": 0.00034, "epss_percentile": 0.09706}, "CVE-2024-36978": {"epss_score": 0.0003, "epss_percentile": 0.08094}, "CVE-2024-36979": {"epss_score": 0.00017, "epss_percentile": 0.03417}, "CVE-2024-36980": {"epss_score": 0.00405, "epss_percentile": 0.60487}, "CVE-2024-36981": {"epss_score": 0.0023, "epss_percentile": 0.45689}, "CVE-2024-36982": {"epss_score": 0.00451, "epss_percentile": 0.63133}, "CVE-2024-36983": {"epss_score": 0.01891, "epss_percentile": 0.82731}, "CVE-2024-36984": {"epss_score": 0.03457, "epss_percentile": 0.87175}, "CVE-2024-36985": {"epss_score": 0.24927, "epss_percentile": 0.95966}, "CVE-2024-36986": {"epss_score": 0.00312, "epss_percentile": 0.54007}, "CVE-2024-36987": {"epss_score": 0.00599, "epss_percentile": 0.68807}, "CVE-2024-36989": {"epss_score": 0.00279, "epss_percentile": 0.50938}, "CVE-2024-36990": {"epss_score": 0.01135, "epss_percentile": 0.77908}, "CVE-2024-36991": {"epss_score": 0.93517, "epss_percentile": 0.99813}, "CVE-2024-36992": {"epss_score": 0.00611, "epss_percentile": 0.69205}, "CVE-2024-36993": {"epss_score": 0.01369, "epss_percentile": 0.79793}, "CVE-2024-36994": {"epss_score": 0.01598, "epss_percentile": 0.81247}, "CVE-2024-36995": {"epss_score": 0.00246, "epss_percentile": 0.47748}, "CVE-2024-36996": {"epss_score": 0.00551, "epss_percentile": 0.67351}, "CVE-2024-36997": {"epss_score": 0.01014, "epss_percentile": 0.7665}, "CVE-2024-36999": {"epss_score": 0.00609, "epss_percentile": 0.6913}, "CVE-2024-37000": {"epss_score": 0.00153, "epss_percentile": 0.36528}, "CVE-2024-37001": {"epss_score": 0.00167, "epss_percentile": 0.38392}, "CVE-2024-37002": {"epss_score": 0.00204, "epss_percentile": 0.42632}, "CVE-2024-37003": {"epss_score": 0.00118, "epss_percentile": 0.31402}, "CVE-2024-37004": {"epss_score": 0.00206, "epss_percentile": 0.4295}, "CVE-2024-37005": {"epss_score": 0.00567, "epss_percentile": 0.67847}, "CVE-2024-37006": {"epss_score": 0.00215, "epss_percentile": 0.44031}, "CVE-2024-37007": {"epss_score": 0.00948, "epss_percentile": 0.75827}, "CVE-2024-37008": {"epss_score": 0.00546, "epss_percentile": 0.67216}, "CVE-2024-37014": {"epss_score": 0.06497, "epss_percentile": 0.908}, "CVE-2024-37015": {"epss_score": 0.003, "epss_percentile": 0.52958}, "CVE-2024-37016": {"epss_score": 0.00021, "epss_percentile": 0.04936}, "CVE-2024-37017": {"epss_score": 0.00146, "epss_percentile": 0.35545}, "CVE-2024-37018": {"epss_score": 0.00324, "epss_percentile": 0.54962}, "CVE-2024-37019": {"epss_score": 0.00445, "epss_percentile": 0.62853}, "CVE-2024-37020": {"epss_score": 0.00021, "epss_percentile": 0.04716}, "CVE-2024-37021": {"epss_score": 0.00017, "epss_percentile": 0.03101}, "CVE-2024-37022": {"epss_score": 0.00138, "epss_percentile": 0.34458}, "CVE-2024-37023": {"epss_score": 0.0069, "epss_percentile": 0.71245}, "CVE-2024-37024": {"epss_score": 0.00037, "epss_percentile": 0.10647}, "CVE-2024-37025": {"epss_score": 0.00048, "epss_percentile": 0.15075}, "CVE-2024-37026": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-37027": {"epss_score": 0.00069, "epss_percentile": 0.21532}, "CVE-2024-37028": {"epss_score": 0.00251, "epss_percentile": 0.48283}, "CVE-2024-37029": {"epss_score": 0.00169, "epss_percentile": 0.38544}, "CVE-2024-37030": {"epss_score": 0.02092, "epss_percentile": 0.83573}, "CVE-2024-37031": {"epss_score": 0.00301, "epss_percentile": 0.53013}, "CVE-2024-37032": {"epss_score": 0.9368, "epss_percentile": 0.99833}, "CVE-2024-37034": {"epss_score": 0.00183, "epss_percentile": 0.40292}, "CVE-2024-37036": {"epss_score": 0.00102, "epss_percentile": 0.2884}, "CVE-2024-37037": {"epss_score": 0.01177, "epss_percentile": 0.7828}, "CVE-2024-37038": {"epss_score": 0.00395, "epss_percentile": 0.59835}, "CVE-2024-37039": {"epss_score": 0.00535, "epss_percentile": 0.66832}, "CVE-2024-37040": {"epss_score": 0.00214, "epss_percentile": 0.44012}, "CVE-2024-37041": {"epss_score": 0.01447, "epss_percentile": 0.80331}, "CVE-2024-37042": {"epss_score": 0.00337, "epss_percentile": 0.56037}, "CVE-2024-37043": {"epss_score": 0.00114, "epss_percentile": 0.30807}, "CVE-2024-37044": {"epss_score": 0.01447, "epss_percentile": 0.80331}, "CVE-2024-37045": {"epss_score": 0.0035, "epss_percentile": 0.56954}, "CVE-2024-37046": {"epss_score": 0.00156, "epss_percentile": 0.36955}, "CVE-2024-37047": {"epss_score": 0.01973, "epss_percentile": 0.83111}, "CVE-2024-37048": {"epss_score": 0.0035, "epss_percentile": 0.56954}, "CVE-2024-37049": {"epss_score": 0.01381, "epss_percentile": 0.79871}, "CVE-2024-37050": {"epss_score": 0.01381, "epss_percentile": 0.79871}, "CVE-2024-37051": {"epss_score": 0.06318, "epss_percentile": 0.90668}, "CVE-2024-37052": {"epss_score": 0.0057, "epss_percentile": 0.6795}, "CVE-2024-37053": {"epss_score": 0.00519, "epss_percentile": 0.66182}, "CVE-2024-37054": {"epss_score": 0.00211, "epss_percentile": 0.43688}, "CVE-2024-37055": {"epss_score": 0.00519, "epss_percentile": 0.66182}, "CVE-2024-37056": {"epss_score": 0.00522, "epss_percentile": 0.6625}, "CVE-2024-37057": {"epss_score": 0.00519, "epss_percentile": 0.66182}, "CVE-2024-37058": {"epss_score": 0.00522, "epss_percentile": 0.6625}, "CVE-2024-37059": {"epss_score": 0.0057, "epss_percentile": 0.6795}, "CVE-2024-37060": {"epss_score": 0.00393, "epss_percentile": 0.59716}, "CVE-2024-37061": {"epss_score": 0.07356, "epss_percentile": 0.91429}, "CVE-2024-37062": {"epss_score": 0.00185, "epss_percentile": 0.40568}, "CVE-2024-37063": {"epss_score": 0.0019, "epss_percentile": 0.41102}, "CVE-2024-37064": {"epss_score": 0.00187, "epss_percentile": 0.40782}, "CVE-2024-37065": {"epss_score": 0.00142, "epss_percentile": 0.34994}, "CVE-2024-37066": {"epss_score": 0.01332, "epss_percentile": 0.79523}, "CVE-2024-37068": {"epss_score": 0.00039, "epss_percentile": 0.11613}, "CVE-2024-37070": {"epss_score": 0.00127, "epss_percentile": 0.32937}, "CVE-2024-37071": {"epss_score": 0.0017, "epss_percentile": 0.38718}, "CVE-2024-37077": {"epss_score": 0.01959, "epss_percentile": 0.83054}, "CVE-2024-37078": {"epss_score": 0.00021, "epss_percentile": 0.0481}, "CVE-2024-37079": {"epss_score": 0.53779, "epss_percentile": 0.97897}, "CVE-2024-37080": {"epss_score": 0.49771, "epss_percentile": 0.97706}, "CVE-2024-37081": {"epss_score": 0.49727, "epss_percentile": 0.97703}, "CVE-2024-37082": {"epss_score": 0.00052, "epss_percentile": 0.1659}, "CVE-2024-37084": {"epss_score": 0.83304, "epss_percentile": 0.99244}, "CVE-2024-37085": {"epss_score": 0.71917, "epss_percentile": 0.98686}, "CVE-2024-37086": {"epss_score": 0.0008, "epss_percentile": 0.24063}, "CVE-2024-37087": {"epss_score": 0.00637, "epss_percentile": 0.69881}, "CVE-2024-37089": {"epss_score": 0.00971, "epss_percentile": 0.76119}, "CVE-2024-37090": {"epss_score": 0.00323, "epss_percentile": 0.54909}, "CVE-2024-37091": {"epss_score": 0.08111, "epss_percentile": 0.91885}, "CVE-2024-37092": {"epss_score": 0.01085, "epss_percentile": 0.77408}, "CVE-2024-37093": {"epss_score": 0.00042, "epss_percentile": 0.1257}, "CVE-2024-37094": {"epss_score": 0.00365, "epss_percentile": 0.57971}, "CVE-2024-37095": {"epss_score": 0.00175, "epss_percentile": 0.39264}, "CVE-2024-37096": {"epss_score": 0.00145, "epss_percentile": 0.35526}, "CVE-2024-37097": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2024-37098": {"epss_score": 0.00232, "epss_percentile": 0.45969}, "CVE-2024-37099": {"epss_score": 0.00186, "epss_percentile": 0.40616}, "CVE-2024-37100": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37101": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37102": {"epss_score": 0.0004, "epss_percentile": 0.12134}, "CVE-2024-37103": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37104": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37106": {"epss_score": 0.00287, "epss_percentile": 0.51814}, "CVE-2024-37107": {"epss_score": 0.00237, "epss_percentile": 0.46728}, "CVE-2024-37108": {"epss_score": 0.00278, "epss_percentile": 0.50855}, "CVE-2024-37109": {"epss_score": 0.01106, "epss_percentile": 0.77617}, "CVE-2024-37110": {"epss_score": 0.01117, "epss_percentile": 0.77734}, "CVE-2024-37111": {"epss_score": 0.00355, "epss_percentile": 0.57291}, "CVE-2024-37112": {"epss_score": 0.00962, "epss_percentile": 0.75982}, "CVE-2024-37113": {"epss_score": 0.01584, "epss_percentile": 0.81155}, "CVE-2024-37114": {"epss_score": 0.00257, "epss_percentile": 0.48854}, "CVE-2024-37115": {"epss_score": 0.00455, "epss_percentile": 0.633}, "CVE-2024-37116": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37117": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-37118": {"epss_score": 0.00094, "epss_percentile": 0.26788}, "CVE-2024-37119": {"epss_score": 0.00317, "epss_percentile": 0.54337}, "CVE-2024-37120": {"epss_score": 0.00116, "epss_percentile": 0.31184}, "CVE-2024-37121": {"epss_score": 0.00116, "epss_percentile": 0.31184}, "CVE-2024-37122": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-37123": {"epss_score": 0.00135, "epss_percentile": 0.34048}, "CVE-2024-37124": {"epss_score": 0.00191, "epss_percentile": 0.41272}, "CVE-2024-37125": {"epss_score": 0.0054, "epss_percentile": 0.66998}, "CVE-2024-37126": {"epss_score": 0.00071, "epss_percentile": 0.21998}, "CVE-2024-37127": {"epss_score": 0.00102, "epss_percentile": 0.28893}, "CVE-2024-37129": {"epss_score": 0.00058, "epss_percentile": 0.18527}, "CVE-2024-37130": {"epss_score": 0.00101, "epss_percentile": 0.286}, "CVE-2024-37131": {"epss_score": 0.04411, "epss_percentile": 0.8866}, "CVE-2024-37132": {"epss_score": 0.0005, "epss_percentile": 0.15931}, "CVE-2024-37133": {"epss_score": 0.00071, "epss_percentile": 0.21998}, "CVE-2024-37134": {"epss_score": 0.00073, "epss_percentile": 0.22563}, "CVE-2024-37135": {"epss_score": 0.0006, "epss_percentile": 0.19053}, "CVE-2024-37136": {"epss_score": 0.0022, "epss_percentile": 0.44558}, "CVE-2024-37137": {"epss_score": 0.00018, "epss_percentile": 0.03862}, "CVE-2024-37138": {"epss_score": 0.00225, "epss_percentile": 0.45136}, "CVE-2024-37139": {"epss_score": 0.01238, "epss_percentile": 0.78794}, "CVE-2024-37140": {"epss_score": 0.07285, "epss_percentile": 0.91383}, "CVE-2024-37141": {"epss_score": 0.00282, "epss_percentile": 0.51239}, "CVE-2024-37142": {"epss_score": 0.00102, "epss_percentile": 0.28893}, "CVE-2024-37143": {"epss_score": 0.03067, "epss_percentile": 0.86339}, "CVE-2024-37144": {"epss_score": 0.00037, "epss_percentile": 0.10971}, "CVE-2024-37145": {"epss_score": 0.00407, "epss_percentile": 0.60593}, "CVE-2024-37146": {"epss_score": 0.0032, "epss_percentile": 0.54586}, "CVE-2024-37147": {"epss_score": 0.13049, "epss_percentile": 0.93858}, "CVE-2024-37148": {"epss_score": 0.01015, "epss_percentile": 0.76666}, "CVE-2024-37149": {"epss_score": 0.00925, "epss_percentile": 0.75534}, "CVE-2024-37150": {"epss_score": 0.00297, "epss_percentile": 0.52742}, "CVE-2024-37151": {"epss_score": 0.00491, "epss_percentile": 0.64944}, "CVE-2024-37152": {"epss_score": 0.73405, "epss_percentile": 0.98751}, "CVE-2024-37153": {"epss_score": 0.00485, "epss_percentile": 0.64719}, "CVE-2024-37154": {"epss_score": 0.00256, "epss_percentile": 0.48814}, "CVE-2024-37155": {"epss_score": 0.00143, "epss_percentile": 0.35177}, "CVE-2024-37156": {"epss_score": 0.0087, "epss_percentile": 0.74708}, "CVE-2024-37157": {"epss_score": 0.00097, "epss_percentile": 0.27565}, "CVE-2024-37158": {"epss_score": 0.0009, "epss_percentile": 0.26057}, "CVE-2024-37159": {"epss_score": 0.00101, "epss_percentile": 0.28692}, "CVE-2024-37160": {"epss_score": 0.00836, "epss_percentile": 0.74142}, "CVE-2024-37161": {"epss_score": 0.00441, "epss_percentile": 0.62691}, "CVE-2024-37162": {"epss_score": 0.00321, "epss_percentile": 0.54642}, "CVE-2024-37163": {"epss_score": 0.00204, "epss_percentile": 0.42648}, "CVE-2024-37164": {"epss_score": 0.00284, "epss_percentile": 0.51417}, "CVE-2024-37165": {"epss_score": 0.00993, "epss_percentile": 0.76409}, "CVE-2024-37166": {"epss_score": 0.00213, "epss_percentile": 0.43848}, "CVE-2024-37167": {"epss_score": 0.00269, "epss_percentile": 0.50156}, "CVE-2024-37168": {"epss_score": 0.00283, "epss_percentile": 0.5141}, "CVE-2024-37169": {"epss_score": 0.00478, "epss_percentile": 0.64399}, "CVE-2024-37171": {"epss_score": 0.00278, "epss_percentile": 0.50846}, "CVE-2024-37172": {"epss_score": 0.00209, "epss_percentile": 0.43398}, "CVE-2024-37173": {"epss_score": 0.0042, "epss_percentile": 0.61445}, "CVE-2024-37174": {"epss_score": 0.0059, "epss_percentile": 0.68575}, "CVE-2024-37175": {"epss_score": 0.00297, "epss_percentile": 0.52707}, "CVE-2024-37176": {"epss_score": 0.00099, "epss_percentile": 0.27834}, "CVE-2024-37177": {"epss_score": 0.00185, "epss_percentile": 0.40466}, "CVE-2024-37178": {"epss_score": 0.00227, "epss_percentile": 0.45373}, "CVE-2024-37179": {"epss_score": 0.00507, "epss_percentile": 0.65678}, "CVE-2024-37180": {"epss_score": 0.00108, "epss_percentile": 0.2984}, "CVE-2024-37181": {"epss_score": 0.00068, "epss_percentile": 0.21282}, "CVE-2024-37182": {"epss_score": 0.00332, "epss_percentile": 0.55606}, "CVE-2024-37183": {"epss_score": 0.00135, "epss_percentile": 0.33934}, "CVE-2024-37184": {"epss_score": 0.00477, "epss_percentile": 0.64348}, "CVE-2024-37185": {"epss_score": 0.01959, "epss_percentile": 0.83054}, "CVE-2024-37186": {"epss_score": 0.02029, "epss_percentile": 0.83328}, "CVE-2024-37187": {"epss_score": 0.00075, "epss_percentile": 0.22903}, "CVE-2024-37198": {"epss_score": 0.0013, "epss_percentile": 0.3326}, "CVE-2024-37199": {"epss_score": 0.00167, "epss_percentile": 0.38362}, "CVE-2024-37201": {"epss_score": 0.00132, "epss_percentile": 0.33527}, "CVE-2024-37202": {"epss_score": 0.00154, "epss_percentile": 0.36725}, "CVE-2024-37203": {"epss_score": 0.00132, "epss_percentile": 0.33527}, "CVE-2024-37204": {"epss_score": 0.00187, "epss_percentile": 0.4072}, "CVE-2024-37205": {"epss_score": 0.0024, "epss_percentile": 0.4721}, "CVE-2024-37206": {"epss_score": 0.00167, "epss_percentile": 0.38362}, "CVE-2024-37207": {"epss_score": 0.00105, "epss_percentile": 0.29316}, "CVE-2024-37208": {"epss_score": 0.00144, "epss_percentile": 0.35339}, "CVE-2024-37209": {"epss_score": 0.00207, "epss_percentile": 0.43121}, "CVE-2024-37211": {"epss_score": 0.00167, "epss_percentile": 0.38362}, "CVE-2024-37212": {"epss_score": 0.00242, "epss_percentile": 0.47367}, "CVE-2024-37213": {"epss_score": 0.00235, "epss_percentile": 0.46209}, "CVE-2024-37214": {"epss_score": 0.00086, "epss_percentile": 0.2537}, "CVE-2024-37215": {"epss_score": 0.00093, "epss_percentile": 0.26758}, "CVE-2024-37216": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37217": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37218": {"epss_score": 0.00132, "epss_percentile": 0.33527}, "CVE-2024-37219": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37220": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-37221": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37222": {"epss_score": 0.00213, "epss_percentile": 0.43888}, "CVE-2024-37223": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37224": {"epss_score": 0.01939, "epss_percentile": 0.82972}, "CVE-2024-37225": {"epss_score": 0.00634, "epss_percentile": 0.69797}, "CVE-2024-37226": {"epss_score": 0.00209, "epss_percentile": 0.43327}, "CVE-2024-37227": {"epss_score": 0.0013, "epss_percentile": 0.3326}, "CVE-2024-37228": {"epss_score": 0.00848, "epss_percentile": 0.74359}, "CVE-2024-37229": {"epss_score": 0.00098, "epss_percentile": 0.27815}, "CVE-2024-37230": {"epss_score": 0.0013, "epss_percentile": 0.3326}, "CVE-2024-37231": {"epss_score": 0.00141, "epss_percentile": 0.34938}, "CVE-2024-37232": {"epss_score": 0.00629, "epss_percentile": 0.69683}, "CVE-2024-37233": {"epss_score": 0.00123, "epss_percentile": 0.32203}, "CVE-2024-37234": {"epss_score": 0.00157, "epss_percentile": 0.37062}, "CVE-2024-37235": {"epss_score": 0.0004, "epss_percentile": 0.12112}, "CVE-2024-37236": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37237": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37238": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37239": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-37240": {"epss_score": 0.0004, "epss_percentile": 0.12112}, "CVE-2024-37241": {"epss_score": 0.0004, "epss_percentile": 0.12134}, "CVE-2024-37242": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37243": {"epss_score": 0.0004, "epss_percentile": 0.12134}, "CVE-2024-37244": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-37245": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-37246": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37247": {"epss_score": 0.0012, "epss_percentile": 0.31764}, "CVE-2024-37248": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-37249": {"epss_score": 0.00096, "epss_percentile": 0.27385}, "CVE-2024-37250": {"epss_score": 0.00124, "epss_percentile": 0.32444}, "CVE-2024-37251": {"epss_score": 0.00074, "epss_percentile": 0.22812}, "CVE-2024-37252": {"epss_score": 0.00134, "epss_percentile": 0.33763}, "CVE-2024-37253": {"epss_score": 0.00181, "epss_percentile": 0.40028}, "CVE-2024-37254": {"epss_score": 0.00145, "epss_percentile": 0.35526}, "CVE-2024-37255": {"epss_score": 0.00171, "epss_percentile": 0.38785}, "CVE-2024-37256": {"epss_score": 0.00189, "epss_percentile": 0.40967}, "CVE-2024-37257": {"epss_score": 0.00213, "epss_percentile": 0.43888}, "CVE-2024-37258": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-37259": {"epss_score": 0.00213, "epss_percentile": 0.43888}, "CVE-2024-37260": {"epss_score": 0.00425, "epss_percentile": 0.61698}, "CVE-2024-37261": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-37262": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-37263": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37264": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-37265": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37266": {"epss_score": 0.0101, "epss_percentile": 0.76602}, "CVE-2024-37267": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2024-37268": {"epss_score": 0.0141, "epss_percentile": 0.80083}, "CVE-2024-37269": {"epss_score": 0.00209, "epss_percentile": 0.43327}, "CVE-2024-37270": {"epss_score": 0.00229, "epss_percentile": 0.4557}, "CVE-2024-37271": {"epss_score": 0.00148, "epss_percentile": 0.3591}, "CVE-2024-37272": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37273": {"epss_score": 0.01095, "epss_percentile": 0.77504}, "CVE-2024-37274": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37275": {"epss_score": 0.00213, "epss_percentile": 0.43888}, "CVE-2024-37276": {"epss_score": 0.00156, "epss_percentile": 0.36963}, "CVE-2024-37277": {"epss_score": 0.00483, "epss_percentile": 0.64573}, "CVE-2024-37278": {"epss_score": 0.00093, "epss_percentile": 0.26758}, "CVE-2024-37279": {"epss_score": 0.00124, "epss_percentile": 0.32401}, "CVE-2024-37280": {"epss_score": 0.00335, "epss_percentile": 0.55892}, "CVE-2024-37281": {"epss_score": 0.00389, "epss_percentile": 0.59455}, "CVE-2024-37282": {"epss_score": 0.00129, "epss_percentile": 0.33151}, "CVE-2024-37283": {"epss_score": 0.00372, "epss_percentile": 0.58447}, "CVE-2024-37284": {"epss_score": 0.00029, "epss_percentile": 0.07752}, "CVE-2024-37285": {"epss_score": 0.00435, "epss_percentile": 0.62344}, "CVE-2024-37286": {"epss_score": 0.00434, "epss_percentile": 0.62307}, "CVE-2024-37287": {"epss_score": 0.0085, "epss_percentile": 0.74388}, "CVE-2024-37288": {"epss_score": 0.01554, "epss_percentile": 0.81004}, "CVE-2024-37289": {"epss_score": 0.00124, "epss_percentile": 0.32427}, "CVE-2024-37293": {"epss_score": 0.00152, "epss_percentile": 0.36417}, "CVE-2024-37294": {"epss_score": 0.00085, "epss_percentile": 0.25073}, "CVE-2024-37295": {"epss_score": 0.00127, "epss_percentile": 0.32794}, "CVE-2024-37296": {"epss_score": 0.00278, "epss_percentile": 0.50924}, "CVE-2024-37297": {"epss_score": 0.01143, "epss_percentile": 0.77979}, "CVE-2024-37298": {"epss_score": 0.00267, "epss_percentile": 0.49954}, "CVE-2024-37299": {"epss_score": 0.00612, "epss_percentile": 0.69236}, "CVE-2024-37300": {"epss_score": 0.00209, "epss_percentile": 0.43322}, "CVE-2024-37301": {"epss_score": 0.07802, "epss_percentile": 0.91689}, "CVE-2024-37302": {"epss_score": 0.00634, "epss_percentile": 0.69793}, "CVE-2024-37303": {"epss_score": 0.00147, "epss_percentile": 0.35691}, "CVE-2024-37304": {"epss_score": 0.00498, "epss_percentile": 0.65224}, "CVE-2024-37305": {"epss_score": 0.00111, "epss_percentile": 0.30343}, "CVE-2024-37306": {"epss_score": 0.00267, "epss_percentile": 0.50005}, "CVE-2024-37307": {"epss_score": 0.00041, "epss_percentile": 0.12405}, "CVE-2024-37308": {"epss_score": 0.0462, "epss_percentile": 0.88931}, "CVE-2024-37309": {"epss_score": 0.0025, "epss_percentile": 0.48108}, "CVE-2024-37310": {"epss_score": 0.01916, "epss_percentile": 0.82857}, "CVE-2024-37311": {"epss_score": 0.00092, "epss_percentile": 0.26462}, "CVE-2024-37312": {"epss_score": 0.00467, "epss_percentile": 0.63865}, "CVE-2024-37313": {"epss_score": 0.00179, "epss_percentile": 0.39857}, "CVE-2024-37314": {"epss_score": 0.00143, "epss_percentile": 0.35109}, "CVE-2024-37315": {"epss_score": 0.00301, "epss_percentile": 0.5307}, "CVE-2024-37316": {"epss_score": 0.00426, "epss_percentile": 0.61743}, "CVE-2024-37317": {"epss_score": 0.00135, "epss_percentile": 0.33983}, "CVE-2024-37318": {"epss_score": 0.04065, "epss_percentile": 0.88197}, "CVE-2024-37319": {"epss_score": 0.04065, "epss_percentile": 0.88197}, "CVE-2024-37320": {"epss_score": 0.03005, "epss_percentile": 0.86181}, "CVE-2024-37321": {"epss_score": 0.03005, "epss_percentile": 0.86181}, "CVE-2024-37322": {"epss_score": 0.03034, "epss_percentile": 0.86258}, "CVE-2024-37323": {"epss_score": 0.02426, "epss_percentile": 0.84716}, "CVE-2024-37324": {"epss_score": 0.04025, "epss_percentile": 0.8814}, "CVE-2024-37325": {"epss_score": 0.01773, "epss_percentile": 0.82205}, "CVE-2024-37326": {"epss_score": 0.04065, "epss_percentile": 0.88197}, "CVE-2024-37327": {"epss_score": 0.04065, "epss_percentile": 0.88197}, "CVE-2024-37328": {"epss_score": 0.03005, "epss_percentile": 0.86181}, "CVE-2024-37329": {"epss_score": 0.03005, "epss_percentile": 0.86181}, "CVE-2024-37330": {"epss_score": 0.03005, "epss_percentile": 0.86181}, "CVE-2024-37331": {"epss_score": 0.03034, "epss_percentile": 0.86258}, "CVE-2024-37332": {"epss_score": 0.04065, "epss_percentile": 0.88197}, "CVE-2024-37333": {"epss_score": 0.04025, "epss_percentile": 0.8814}, "CVE-2024-37334": {"epss_score": 0.0332, "epss_percentile": 0.86908}, "CVE-2024-37335": {"epss_score": 0.05165, "epss_percentile": 0.89564}, "CVE-2024-37336": {"epss_score": 0.03259, "epss_percentile": 0.86769}, "CVE-2024-37337": {"epss_score": 0.0165, "epss_percentile": 0.81561}, "CVE-2024-37338": {"epss_score": 0.05165, "epss_percentile": 0.89564}, "CVE-2024-37339": {"epss_score": 0.05165, "epss_percentile": 0.89564}, "CVE-2024-37340": {"epss_score": 0.05165, "epss_percentile": 0.89564}, "CVE-2024-37341": {"epss_score": 0.0433, "epss_percentile": 0.88558}, "CVE-2024-37342": {"epss_score": 0.01683, "epss_percentile": 0.81737}, "CVE-2024-37343": {"epss_score": 0.00621, "epss_percentile": 0.6948}, "CVE-2024-37344": {"epss_score": 0.00186, "epss_percentile": 0.40636}, "CVE-2024-37345": {"epss_score": 0.00296, "epss_percentile": 0.5257}, "CVE-2024-37346": {"epss_score": 0.00129, "epss_percentile": 0.33131}, "CVE-2024-37347": {"epss_score": 0.00282, "epss_percentile": 0.51261}, "CVE-2024-37348": {"epss_score": 0.00273, "epss_percentile": 0.50439}, "CVE-2024-37349": {"epss_score": 0.00282, "epss_percentile": 0.51261}, "CVE-2024-37350": {"epss_score": 0.00536, "epss_percentile": 0.6687}, "CVE-2024-37351": {"epss_score": 0.00273, "epss_percentile": 0.50439}, "CVE-2024-37352": {"epss_score": 0.00282, "epss_percentile": 0.51261}, "CVE-2024-37354": {"epss_score": 0.00026, "epss_percentile": 0.06537}, "CVE-2024-37355": {"epss_score": 0.00028, "epss_percentile": 0.07345}, "CVE-2024-37356": {"epss_score": 0.00018, "epss_percentile": 0.03684}, "CVE-2024-37357": {"epss_score": 0.00684, "epss_percentile": 0.71124}, "CVE-2024-37358": {"epss_score": 0.03036, "epss_percentile": 0.86262}, "CVE-2024-37359": {"epss_score": 0.00116, "epss_percentile": 0.31112}, "CVE-2024-37360": {"epss_score": 0.00069, "epss_percentile": 0.21512}, "CVE-2024-37361": {"epss_score": 0.00226, "epss_percentile": 0.45354}, "CVE-2024-37362": {"epss_score": 0.00095, "epss_percentile": 0.27152}, "CVE-2024-37363": {"epss_score": 0.00088, "epss_percentile": 0.25664}, "CVE-2024-37364": {"epss_score": 0.00084, "epss_percentile": 0.24895}, "CVE-2024-37365": {"epss_score": 0.00036, "epss_percentile": 0.10387}, "CVE-2024-37367": {"epss_score": 0.00087, "epss_percentile": 0.25562}, "CVE-2024-37368": {"epss_score": 0.00146, "epss_percentile": 0.35641}, "CVE-2024-37369": {"epss_score": 8e-05, "epss_percentile": 0.00485}, "CVE-2024-37370": {"epss_score": 0.00415, "epss_percentile": 0.61122}, "CVE-2024-37371": {"epss_score": 0.02606, "epss_percentile": 0.85224}, "CVE-2024-37372": {"epss_score": 0.00049, "epss_percentile": 0.15432}, "CVE-2024-37373": {"epss_score": 0.06822, "epss_percentile": 0.91048}, "CVE-2024-37376": {"epss_score": 0.0952, "epss_percentile": 0.92584}, "CVE-2024-37377": {"epss_score": 0.01059, "epss_percentile": 0.7715}, "CVE-2024-37380": {"epss_score": 0.00093, "epss_percentile": 0.26644}, "CVE-2024-37381": {"epss_score": 0.00186, "epss_percentile": 0.40679}, "CVE-2024-37382": {"epss_score": 0.00207, "epss_percentile": 0.43084}, "CVE-2024-37383": {"epss_score": 0.66361, "epss_percentile": 0.98461}, "CVE-2024-37384": {"epss_score": 0.00334, "epss_percentile": 0.55738}, "CVE-2024-37385": {"epss_score": 0.01085, "epss_percentile": 0.77402}, "CVE-2024-37386": {"epss_score": 0.00044, "epss_percentile": 0.13485}, "CVE-2024-37387": {"epss_score": 0.00046, "epss_percentile": 0.14298}, "CVE-2024-37388": {"epss_score": 0.00117, "epss_percentile": 0.31339}, "CVE-2024-37389": {"epss_score": 0.00947, "epss_percentile": 0.75825}, "CVE-2024-37391": {"epss_score": 0.00087, "epss_percentile": 0.25463}, "CVE-2024-37392": {"epss_score": 0.00122, "epss_percentile": 0.32155}, "CVE-2024-37393": {"epss_score": 0.82327, "epss_percentile": 0.99188}, "CVE-2024-37394": {"epss_score": 0.00242, "epss_percentile": 0.47364}, "CVE-2024-37395": {"epss_score": 0.00182, "epss_percentile": 0.40153}, "CVE-2024-37396": {"epss_score": 0.00242, "epss_percentile": 0.47364}, "CVE-2024-37397": {"epss_score": 0.22334, "epss_percentile": 0.95624}, "CVE-2024-37398": {"epss_score": 0.00285, "epss_percentile": 0.51677}, "CVE-2024-37399": {"epss_score": 0.35462, "epss_percentile": 0.96912}, "CVE-2024-37400": {"epss_score": 0.03539, "epss_percentile": 0.87315}, "CVE-2024-37401": {"epss_score": 0.04661, "epss_percentile": 0.88977}, "CVE-2024-37403": {"epss_score": 0.00134, "epss_percentile": 0.33901}, "CVE-2024-37404": {"epss_score": 0.87194, "epss_percentile": 0.99418}, "CVE-2024-37405": {"epss_score": 0.00333, "epss_percentile": 0.55677}, "CVE-2024-37406": {"epss_score": 0.00286, "epss_percentile": 0.51737}, "CVE-2024-37407": {"epss_score": 0.00372, "epss_percentile": 0.58421}, "CVE-2024-37408": {"epss_score": 0.00059, "epss_percentile": 0.18841}, "CVE-2024-37409": {"epss_score": 0.00067, "epss_percentile": 0.21095}, "CVE-2024-37410": {"epss_score": 0.00925, "epss_percentile": 0.75532}, "CVE-2024-37411": {"epss_score": 0.00228, "epss_percentile": 0.45515}, "CVE-2024-37412": {"epss_score": 0.00064, "epss_percentile": 0.20378}, "CVE-2024-37413": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37414": {"epss_score": 0.00093, "epss_percentile": 0.26758}, "CVE-2024-37415": {"epss_score": 0.00123, "epss_percentile": 0.32266}, "CVE-2024-37416": {"epss_score": 0.00373, "epss_percentile": 0.58524}, "CVE-2024-37417": {"epss_score": 0.00064, "epss_percentile": 0.20378}, "CVE-2024-37418": {"epss_score": 0.01585, "epss_percentile": 0.81165}, "CVE-2024-37419": {"epss_score": 0.0039, "epss_percentile": 0.59534}, "CVE-2024-37420": {"epss_score": 0.01158, "epss_percentile": 0.78121}, "CVE-2024-37421": {"epss_score": 0.0004, "epss_percentile": 0.12134}, "CVE-2024-37422": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37423": {"epss_score": 0.00383, "epss_percentile": 0.59084}, "CVE-2024-37424": {"epss_score": 0.01265, "epss_percentile": 0.79003}, "CVE-2024-37425": {"epss_score": 0.00095, "epss_percentile": 0.27158}, "CVE-2024-37426": {"epss_score": 0.00064, "epss_percentile": 0.2038}, "CVE-2024-37427": {"epss_score": 0.00123, "epss_percentile": 0.32189}, "CVE-2024-37428": {"epss_score": 0.00199, "epss_percentile": 0.42117}, "CVE-2024-37429": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-37430": {"epss_score": 0.00144, "epss_percentile": 0.35331}, "CVE-2024-37431": {"epss_score": 0.0004, "epss_percentile": 0.12112}, "CVE-2024-37432": {"epss_score": 0.00167, "epss_percentile": 0.38362}, "CVE-2024-37433": {"epss_score": 0.00167, "epss_percentile": 0.38362}, "CVE-2024-37434": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-37435": {"epss_score": 0.0004, "epss_percentile": 0.12112}, "CVE-2024-37436": {"epss_score": 0.0017, "epss_percentile": 0.38739}, "CVE-2024-37437": {"epss_score": 0.00365, "epss_percentile": 0.57995}, "CVE-2024-37438": {"epss_score": 0.0004, "epss_percentile": 0.12089}, "CVE-2024-37439": {"epss_score": 0.00105, "epss_percentile": 0.29316}, "CVE-2024-37440": {"epss_score": 0.00175, "epss_percentile": 0.39264}, "CVE-2024-37441": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37442": {"epss_score": 0.00143, "epss_percentile": 0.35092}, "CVE-2024-37443": {"epss_score": 0.00132, "epss_percentile": 0.33527}, "CVE-2024-37444": {"epss_score": 0.00317, "epss_percentile": 0.54337}, "CVE-2024-37445": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37446": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-37447": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-37448": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37449": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-37450": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37451": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37452": {"epss_score": 0.0004, "epss_percentile": 0.12134}, "CVE-2024-37453": {"epss_score": 0.00316, "epss_percentile": 0.54279}, "CVE-2024-37454": {"epss_score": 0.01608, "epss_percentile": 0.8131}, "CVE-2024-37455": {"epss_score": 0.0046, "epss_percentile": 0.63518}, "CVE-2024-37456": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-37457": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-37458": {"epss_score": 0.0004, "epss_percentile": 0.12112}, "CVE-2024-37459": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-37460": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37461": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-37462": {"epss_score": 0.01662, "epss_percentile": 0.81633}, "CVE-2024-37463": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2024-37464": {"epss_score": 0.00514, "epss_percentile": 0.65956}, "CVE-2024-37465": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37466": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37467": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37468": {"epss_score": 0.00156, "epss_percentile": 0.36963}, "CVE-2024-37469": {"epss_score": 0.00058, "epss_percentile": 0.18265}, "CVE-2024-37470": {"epss_score": 0.00602, "epss_percentile": 0.68873}, "CVE-2024-37471": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2024-37472": {"epss_score": 0.00213, "epss_percentile": 0.43888}, "CVE-2024-37473": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37474": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37475": {"epss_score": 0.00209, "epss_percentile": 0.43327}, "CVE-2024-37476": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37477": {"epss_score": 0.00179, "epss_percentile": 0.39801}, "CVE-2024-37478": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37479": {"epss_score": 0.01048, "epss_percentile": 0.77048}, "CVE-2024-37480": {"epss_score": 0.00199, "epss_percentile": 0.42117}, "CVE-2024-37481": {"epss_score": 0.00163, "epss_percentile": 0.37784}, "CVE-2024-37482": {"epss_score": 0.00204, "epss_percentile": 0.42637}, "CVE-2024-37483": {"epss_score": 0.00118, "epss_percentile": 0.31501}, "CVE-2024-37484": {"epss_score": 0.00366, "epss_percentile": 0.58061}, "CVE-2024-37485": {"epss_score": 0.00167, "epss_percentile": 0.38362}, "CVE-2024-37486": {"epss_score": 0.00433, "epss_percentile": 0.62202}, "CVE-2024-37487": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-37488": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37489": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37490": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37491": {"epss_score": 0.0004, "epss_percentile": 0.12112}, "CVE-2024-37492": {"epss_score": 0.0012, "epss_percentile": 0.31764}, "CVE-2024-37493": {"epss_score": 0.0004, "epss_percentile": 0.12112}, "CVE-2024-37494": {"epss_score": 0.01269, "epss_percentile": 0.79036}, "CVE-2024-37495": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37497": {"epss_score": 0.00272, "epss_percentile": 0.50398}, "CVE-2024-37498": {"epss_score": 0.0024, "epss_percentile": 0.4721}, "CVE-2024-37499": {"epss_score": 0.00689, "epss_percentile": 0.71223}, "CVE-2024-37500": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37501": {"epss_score": 0.01998, "epss_percentile": 0.8321}, "CVE-2024-37502": {"epss_score": 0.00354, "epss_percentile": 0.57204}, "CVE-2024-37503": {"epss_score": 0.0004, "epss_percentile": 0.12112}, "CVE-2024-37504": {"epss_score": 0.0024, "epss_percentile": 0.4721}, "CVE-2024-37505": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-37506": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-37507": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37508": {"epss_score": 0.00041, "epss_percentile": 0.12329}, "CVE-2024-37509": {"epss_score": 0.00167, "epss_percentile": 0.38362}, "CVE-2024-37510": {"epss_score": 0.00173, "epss_percentile": 0.39113}, "CVE-2024-37511": {"epss_score": 0.0004, "epss_percentile": 0.12112}, "CVE-2024-37512": {"epss_score": 0.00257, "epss_percentile": 0.48854}, "CVE-2024-37513": {"epss_score": 0.0123, "epss_percentile": 0.7872}, "CVE-2024-37514": {"epss_score": 0.00199, "epss_percentile": 0.42117}, "CVE-2024-37515": {"epss_score": 0.00156, "epss_percentile": 0.36909}, "CVE-2024-37516": {"epss_score": 0.00119, "epss_percentile": 0.31586}, "CVE-2024-37517": {"epss_score": 0.00249, "epss_percentile": 0.48058}, "CVE-2024-37518": {"epss_score": 0.0004, "epss_percentile": 0.12112}, "CVE-2024-37519": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37520": {"epss_score": 0.01235, "epss_percentile": 0.78766}, "CVE-2024-37521": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37522": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-37523": {"epss_score": 0.00102, "epss_percentile": 0.28747}, "CVE-2024-37524": {"epss_score": 0.00036, "epss_percentile": 0.10621}, "CVE-2024-37526": {"epss_score": 0.00044, "epss_percentile": 0.13493}, "CVE-2024-37527": {"epss_score": 0.00071, "epss_percentile": 0.22037}, "CVE-2024-37528": {"epss_score": 0.00209, "epss_percentile": 0.43346}, "CVE-2024-37529": {"epss_score": 0.00077, "epss_percentile": 0.23376}, "CVE-2024-37532": {"epss_score": 0.00103, "epss_percentile": 0.29011}, "CVE-2024-37533": {"epss_score": 0.00053, "epss_percentile": 0.16978}, "CVE-2024-37535": {"epss_score": 0.00016, "epss_percentile": 0.02924}, "CVE-2024-37536": {"epss_score": 0.00102, "epss_percentile": 0.28747}, "CVE-2024-37537": {"epss_score": 0.00093, "epss_percentile": 0.26758}, "CVE-2024-37538": {"epss_score": 0.00093, "epss_percentile": 0.26758}, "CVE-2024-37539": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37540": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37541": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-37542": {"epss_score": 0.0006, "epss_percentile": 0.18983}, "CVE-2024-37543": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37544": {"epss_score": 0.00182, "epss_percentile": 0.40267}, "CVE-2024-37545": {"epss_score": 0.00093, "epss_percentile": 0.26758}, "CVE-2024-37546": {"epss_score": 0.0012, "epss_percentile": 0.3171}, "CVE-2024-37547": {"epss_score": 0.00246, "epss_percentile": 0.47808}, "CVE-2024-37548": {"epss_score": 0.00093, "epss_percentile": 0.26758}, "CVE-2024-37549": {"epss_score": 0.00148, "epss_percentile": 0.3591}, "CVE-2024-37550": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-37551": {"epss_score": 0.00093, "epss_percentile": 0.26758}, "CVE-2024-37552": {"epss_score": 0.0013, "epss_percentile": 0.333}, "CVE-2024-37553": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37554": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-37555": {"epss_score": 0.0066, "epss_percentile": 0.70537}, "CVE-2024-37556": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-37557": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-37558": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-37559": {"epss_score": 0.00213, "epss_percentile": 0.43888}, "CVE-2024-37560": {"epss_score": 0.0046, "epss_percentile": 0.63518}, "CVE-2024-37561": {"epss_score": 0.00161, "epss_percentile": 0.37525}, "CVE-2024-37562": {"epss_score": 0.00161, "epss_percentile": 0.37525}, "CVE-2024-37563": {"epss_score": 0.00121, "epss_percentile": 0.31995}, "CVE-2024-37564": {"epss_score": 0.00581, "epss_percentile": 0.68278}, "CVE-2024-37565": {"epss_score": 0.00119, "epss_percentile": 0.31541}, "CVE-2024-37566": {"epss_score": 0.00136, "epss_percentile": 0.3419}, "CVE-2024-37567": {"epss_score": 0.00116, "epss_percentile": 0.31092}, "CVE-2024-37568": {"epss_score": 0.00127, "epss_percentile": 0.32884}, "CVE-2024-37569": {"epss_score": 0.03591, "epss_percentile": 0.874}, "CVE-2024-37570": {"epss_score": 0.00414, "epss_percentile": 0.61039}, "CVE-2024-37571": {"epss_score": 0.00106, "epss_percentile": 0.29574}, "CVE-2024-37573": {"epss_score": 0.0006, "epss_percentile": 0.19104}, "CVE-2024-37574": {"epss_score": 0.00124, "epss_percentile": 0.32455}, "CVE-2024-37575": {"epss_score": 0.00124, "epss_percentile": 0.32459}, "CVE-2024-37600": {"epss_score": 0.00105, "epss_percentile": 0.29385}, "CVE-2024-37601": {"epss_score": 0.00089, "epss_percentile": 0.2596}, "CVE-2024-37602": {"epss_score": 0.0009, "epss_percentile": 0.26013}, "CVE-2024-37603": {"epss_score": 0.00089, "epss_percentile": 0.2596}, "CVE-2024-37605": {"epss_score": 0.0006, "epss_percentile": 0.19195}, "CVE-2024-37606": {"epss_score": 0.00037, "epss_percentile": 0.10929}, "CVE-2024-37607": {"epss_score": 0.00063, "epss_percentile": 0.19832}, "CVE-2024-37619": {"epss_score": 0.00125, "epss_percentile": 0.32615}, "CVE-2024-37620": {"epss_score": 0.00193, "epss_percentile": 0.41449}, "CVE-2024-37621": {"epss_score": 0.00155, "epss_percentile": 0.36788}, "CVE-2024-37622": {"epss_score": 0.00851, "epss_percentile": 0.74404}, "CVE-2024-37623": {"epss_score": 0.0081, "epss_percentile": 0.73719}, "CVE-2024-37624": {"epss_score": 0.00165, "epss_percentile": 0.38135}, "CVE-2024-37625": {"epss_score": 0.00117, "epss_percentile": 0.3131}, "CVE-2024-37626": {"epss_score": 0.02277, "epss_percentile": 0.8423}, "CVE-2024-37629": {"epss_score": 0.00439, "epss_percentile": 0.6259}, "CVE-2024-37630": {"epss_score": 0.00504, "epss_percentile": 0.65527}, "CVE-2024-37631": {"epss_score": 0.0011, "epss_percentile": 0.30173}, "CVE-2024-37632": {"epss_score": 0.00669, "epss_percentile": 0.70764}, "CVE-2024-37633": {"epss_score": 0.00272, "epss_percentile": 0.50373}, "CVE-2024-37634": {"epss_score": 0.00232, "epss_percentile": 0.45909}, "CVE-2024-37635": {"epss_score": 0.01965, "epss_percentile": 0.83081}, "CVE-2024-37637": {"epss_score": 0.00289, "epss_percentile": 0.52047}, "CVE-2024-37639": {"epss_score": 0.00137, "epss_percentile": 0.34312}, "CVE-2024-37640": {"epss_score": 0.00135, "epss_percentile": 0.34026}, "CVE-2024-37641": {"epss_score": 0.00246, "epss_percentile": 0.47804}, "CVE-2024-37642": {"epss_score": 0.02069, "epss_percentile": 0.83467}, "CVE-2024-37643": {"epss_score": 0.00246, "epss_percentile": 0.47804}, "CVE-2024-37644": {"epss_score": 0.00133, "epss_percentile": 0.33681}, "CVE-2024-37645": {"epss_score": 0.00246, "epss_percentile": 0.47804}, "CVE-2024-37649": {"epss_score": 0.00049, "epss_percentile": 0.15301}, "CVE-2024-37654": {"epss_score": 0.0013, "epss_percentile": 0.33228}, "CVE-2024-37656": {"epss_score": 0.00104, "epss_percentile": 0.29219}, "CVE-2024-37657": {"epss_score": 0.00051, "epss_percentile": 0.16191}, "CVE-2024-37658": {"epss_score": 0.00051, "epss_percentile": 0.16191}, "CVE-2024-37661": {"epss_score": 0.00062, "epss_percentile": 0.19695}, "CVE-2024-37662": {"epss_score": 0.00069, "epss_percentile": 0.21479}, "CVE-2024-37663": {"epss_score": 0.00063, "epss_percentile": 0.19803}, "CVE-2024-37664": {"epss_score": 0.0005, "epss_percentile": 0.15886}, "CVE-2024-37665": {"epss_score": 0.00156, "epss_percentile": 0.3692}, "CVE-2024-37671": {"epss_score": 0.00548, "epss_percentile": 0.67279}, "CVE-2024-37672": {"epss_score": 0.00548, "epss_percentile": 0.67279}, "CVE-2024-37673": {"epss_score": 0.00548, "epss_percentile": 0.67279}, "CVE-2024-37674": {"epss_score": 0.02462, "epss_percentile": 0.84827}, "CVE-2024-37675": {"epss_score": 0.00548, "epss_percentile": 0.67279}, "CVE-2024-37676": {"epss_score": 0.00074, "epss_percentile": 0.22825}, "CVE-2024-37677": {"epss_score": 0.00185, "epss_percentile": 0.40553}, "CVE-2024-37678": {"epss_score": 0.00847, "epss_percentile": 0.7435}, "CVE-2024-37679": {"epss_score": 0.00372, "epss_percentile": 0.5846}, "CVE-2024-37680": {"epss_score": 0.00093, "epss_percentile": 0.26682}, "CVE-2024-37681": {"epss_score": 0.00519, "epss_percentile": 0.6615}, "CVE-2024-37699": {"epss_score": 0.00135, "epss_percentile": 0.33977}, "CVE-2024-37726": {"epss_score": 0.07913, "epss_percentile": 0.9176}, "CVE-2024-37728": {"epss_score": 0.10368, "epss_percentile": 0.92961}, "CVE-2024-37732": {"epss_score": 0.13951, "epss_percentile": 0.941}, "CVE-2024-37734": {"epss_score": 0.03709, "epss_percentile": 0.87602}, "CVE-2024-37741": {"epss_score": 0.00355, "epss_percentile": 0.5728}, "CVE-2024-37742": {"epss_score": 0.00471, "epss_percentile": 0.64004}, "CVE-2024-37743": {"epss_score": 0.00334, "epss_percentile": 0.55743}, "CVE-2024-37758": {"epss_score": 0.00073, "epss_percentile": 0.22651}, "CVE-2024-37759": {"epss_score": 0.80674, "epss_percentile": 0.991}, "CVE-2024-37762": {"epss_score": 0.28046, "epss_percentile": 0.96303}, "CVE-2024-37763": {"epss_score": 0.10123, "epss_percentile": 0.92859}, "CVE-2024-37764": {"epss_score": 0.07136, "epss_percentile": 0.91274}, "CVE-2024-37765": {"epss_score": 0.11056, "epss_percentile": 0.93204}, "CVE-2024-37767": {"epss_score": 0.00271, "epss_percentile": 0.5029}, "CVE-2024-37768": {"epss_score": 0.00119, "epss_percentile": 0.31676}, "CVE-2024-37769": {"epss_score": 0.00106, "epss_percentile": 0.29479}, "CVE-2024-37770": {"epss_score": 0.11022, "epss_percentile": 0.93193}, "CVE-2024-37773": {"epss_score": 0.00136, "epss_percentile": 0.34133}, "CVE-2024-37774": {"epss_score": 0.0005, "epss_percentile": 0.15938}, "CVE-2024-37775": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2024-37776": {"epss_score": 0.00095, "epss_percentile": 0.27216}, "CVE-2024-37777": {"epss_score": 0.00472, "epss_percentile": 0.64033}, "CVE-2024-37779": {"epss_score": 0.03406, "epss_percentile": 0.87076}, "CVE-2024-37782": {"epss_score": 0.00074, "epss_percentile": 0.22831}, "CVE-2024-37783": {"epss_score": 0.00124, "epss_percentile": 0.3236}, "CVE-2024-37791": {"epss_score": 0.02692, "epss_percentile": 0.85438}, "CVE-2024-37794": {"epss_score": 0.0019, "epss_percentile": 0.411}, "CVE-2024-37795": {"epss_score": 0.00144, "epss_percentile": 0.35291}, "CVE-2024-37798": {"epss_score": 0.00243, "epss_percentile": 0.47455}, "CVE-2024-37799": {"epss_score": 0.00098, "epss_percentile": 0.27815}, "CVE-2024-37800": {"epss_score": 0.00181, "epss_percentile": 0.40083}, "CVE-2024-37802": {"epss_score": 0.0007, "epss_percentile": 0.21783}, "CVE-2024-37803": {"epss_score": 0.00169, "epss_percentile": 0.3857}, "CVE-2024-37816": {"epss_score": 0.0002, "epss_percentile": 0.04539}, "CVE-2024-37818": {"epss_score": 0.00157, "epss_percentile": 0.3708}, "CVE-2024-37820": {"epss_score": 0.00115, "epss_percentile": 0.30994}, "CVE-2024-37821": {"epss_score": 0.00234, "epss_percentile": 0.46121}, "CVE-2024-37825": {"epss_score": 0.00294, "epss_percentile": 0.524}, "CVE-2024-37826": {"epss_score": 0.00235, "epss_percentile": 0.46225}, "CVE-2024-37828": {"epss_score": 0.00116, "epss_percentile": 0.31094}, "CVE-2024-37829": {"epss_score": 0.00271, "epss_percentile": 0.50339}, "CVE-2024-37830": {"epss_score": 0.00157, "epss_percentile": 0.37065}, "CVE-2024-37831": {"epss_score": 0.00156, "epss_percentile": 0.36971}, "CVE-2024-37840": {"epss_score": 0.00502, "epss_percentile": 0.65414}, "CVE-2024-37843": {"epss_score": 0.89433, "epss_percentile": 0.99526}, "CVE-2024-37844": {"epss_score": 0.00121, "epss_percentile": 0.31953}, "CVE-2024-37845": {"epss_score": 0.02032, "epss_percentile": 0.83336}, "CVE-2024-37846": {"epss_score": 0.00123, "epss_percentile": 0.32257}, "CVE-2024-37847": {"epss_score": 0.00428, "epss_percentile": 0.61947}, "CVE-2024-37848": {"epss_score": 0.00053, "epss_percentile": 0.1688}, "CVE-2024-37849": {"epss_score": 0.00206, "epss_percentile": 0.42772}, "CVE-2024-37855": {"epss_score": 0.00999, "epss_percentile": 0.76475}, "CVE-2024-37856": {"epss_score": 0.00196, "epss_percentile": 0.41798}, "CVE-2024-37857": {"epss_score": 0.00884, "epss_percentile": 0.7493}, "CVE-2024-37858": {"epss_score": 0.00887, "epss_percentile": 0.74965}, "CVE-2024-37859": {"epss_score": 0.0027, "epss_percentile": 0.50231}, "CVE-2024-37860": {"epss_score": 0.00102, "epss_percentile": 0.28783}, "CVE-2024-37861": {"epss_score": 0.00337, "epss_percentile": 0.56028}, "CVE-2024-37862": {"epss_score": 0.00084, "epss_percentile": 0.24978}, "CVE-2024-37863": {"epss_score": 0.00261, "epss_percentile": 0.49256}, "CVE-2024-37865": {"epss_score": 0.00216, "epss_percentile": 0.44174}, "CVE-2024-37868": {"epss_score": 0.08147, "epss_percentile": 0.91902}, "CVE-2024-37869": {"epss_score": 0.08147, "epss_percentile": 0.91902}, "CVE-2024-37870": {"epss_score": 0.001, "epss_percentile": 0.28543}, "CVE-2024-37871": {"epss_score": 0.00137, "epss_percentile": 0.34226}, "CVE-2024-37872": {"epss_score": 0.00115, "epss_percentile": 0.3097}, "CVE-2024-37873": {"epss_score": 0.00239, "epss_percentile": 0.46855}, "CVE-2024-37877": {"epss_score": 0.0007, "epss_percentile": 0.21673}, "CVE-2024-37878": {"epss_score": 0.00436, "epss_percentile": 0.62461}, "CVE-2024-37879": {"epss_score": 0.00128, "epss_percentile": 0.33017}, "CVE-2024-37880": {"epss_score": 0.00141, "epss_percentile": 0.34934}, "CVE-2024-37881": {"epss_score": 0.04143, "epss_percentile": 0.88312}, "CVE-2024-37882": {"epss_score": 0.00319, "epss_percentile": 0.54534}, "CVE-2024-37883": {"epss_score": 0.00144, "epss_percentile": 0.35279}, "CVE-2024-37884": {"epss_score": 0.00155, "epss_percentile": 0.36778}, "CVE-2024-37885": {"epss_score": 0.00126, "epss_percentile": 0.32732}, "CVE-2024-37886": {"epss_score": 0.00591, "epss_percentile": 0.68584}, "CVE-2024-37887": {"epss_score": 0.00526, "epss_percentile": 0.66431}, "CVE-2024-37888": {"epss_score": 0.20643, "epss_percentile": 0.95394}, "CVE-2024-37889": {"epss_score": 0.10928, "epss_percentile": 0.93161}, "CVE-2024-37890": {"epss_score": 0.00541, "epss_percentile": 0.67025}, "CVE-2024-37891": {"epss_score": 0.00188, "epss_percentile": 0.40896}, "CVE-2024-37893": {"epss_score": 0.00028, "epss_percentile": 0.07347}, "CVE-2024-37894": {"epss_score": 0.01307, "epss_percentile": 0.79342}, "CVE-2024-37895": {"epss_score": 0.00662, "epss_percentile": 0.70596}, "CVE-2024-37896": {"epss_score": 0.00075, "epss_percentile": 0.22917}, "CVE-2024-37897": {"epss_score": 0.00171, "epss_percentile": 0.38858}, "CVE-2024-37898": {"epss_score": 0.00174, "epss_percentile": 0.39176}, "CVE-2024-37899": {"epss_score": 0.17518, "epss_percentile": 0.94859}, "CVE-2024-37900": {"epss_score": 0.05326, "epss_percentile": 0.89735}, "CVE-2024-37901": {"epss_score": 0.09745, "epss_percentile": 0.92688}, "CVE-2024-37902": {"epss_score": 0.00288, "epss_percentile": 0.51913}, "CVE-2024-37903": {"epss_score": 0.00845, "epss_percentile": 0.7429}, "CVE-2024-37904": {"epss_score": 0.0014, "epss_percentile": 0.34783}, "CVE-2024-37905": {"epss_score": 0.03685, "epss_percentile": 0.87568}, "CVE-2024-37906": {"epss_score": 0.00915, "epss_percentile": 0.75407}, "CVE-2024-37917": {"epss_score": 0.00207, "epss_percentile": 0.4312}, "CVE-2024-37918": {"epss_score": 0.0017, "epss_percentile": 0.3866}, "CVE-2024-37919": {"epss_score": 0.00118, "epss_percentile": 0.31452}, "CVE-2024-37920": {"epss_score": 0.0028, "epss_percentile": 0.51069}, "CVE-2024-37921": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-37922": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-37923": {"epss_score": 0.00137, "epss_percentile": 0.34239}, "CVE-2024-37924": {"epss_score": 0.00422, "epss_percentile": 0.6155}, "CVE-2024-37925": {"epss_score": 0.0004, "epss_percentile": 0.1208}, "CVE-2024-37926": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-37927": {"epss_score": 0.00711, "epss_percentile": 0.7174}, "CVE-2024-37928": {"epss_score": 0.00648, "epss_percentile": 0.70214}, "CVE-2024-37929": {"epss_score": 0.00108, "epss_percentile": 0.29877}, "CVE-2024-37930": {"epss_score": 0.00707, "epss_percentile": 0.71662}, "CVE-2024-37931": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37932": {"epss_score": 0.0042, "epss_percentile": 0.61427}, "CVE-2024-37933": {"epss_score": 0.00354, "epss_percentile": 0.57209}, "CVE-2024-37934": {"epss_score": 0.01082, "epss_percentile": 0.77383}, "CVE-2024-37935": {"epss_score": 0.0103, "epss_percentile": 0.76847}, "CVE-2024-37936": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-37937": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-37938": {"epss_score": 0.00199, "epss_percentile": 0.42168}, "CVE-2024-37939": {"epss_score": 0.00199, "epss_percentile": 0.42168}, "CVE-2024-37940": {"epss_score": 0.00214, "epss_percentile": 0.43966}, "CVE-2024-37941": {"epss_score": 0.00226, "epss_percentile": 0.45238}, "CVE-2024-37942": {"epss_score": 0.00335, "epss_percentile": 0.55817}, "CVE-2024-37943": {"epss_score": 0.00169, "epss_percentile": 0.38642}, "CVE-2024-37944": {"epss_score": 0.0017, "epss_percentile": 0.38688}, "CVE-2024-37945": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2024-37946": {"epss_score": 0.00118, "epss_percentile": 0.31452}, "CVE-2024-37947": {"epss_score": 0.00208, "epss_percentile": 0.43297}, "CVE-2024-37948": {"epss_score": 0.0017, "epss_percentile": 0.3866}, "CVE-2024-37949": {"epss_score": 0.00185, "epss_percentile": 0.40567}, "CVE-2024-37950": {"epss_score": 0.00118, "epss_percentile": 0.31452}, "CVE-2024-37951": {"epss_score": 0.0017, "epss_percentile": 0.3866}, "CVE-2024-37952": {"epss_score": 0.00364, "epss_percentile": 0.57941}, "CVE-2024-37953": {"epss_score": 0.00236, "epss_percentile": 0.46419}, "CVE-2024-37954": {"epss_score": 0.00182, "epss_percentile": 0.40196}, "CVE-2024-37955": {"epss_score": 0.00155, "epss_percentile": 0.36841}, "CVE-2024-37956": {"epss_score": 0.00279, "epss_percentile": 0.50979}, "CVE-2024-37957": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2024-37958": {"epss_score": 0.00117, "epss_percentile": 0.31303}, "CVE-2024-37959": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2024-37960": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-37961": {"epss_score": 0.00092, "epss_percentile": 0.26462}, "CVE-2024-37962": {"epss_score": 0.00181, "epss_percentile": 0.40021}, "CVE-2024-37965": {"epss_score": 0.06098, "epss_percentile": 0.90479}, "CVE-2024-37966": {"epss_score": 0.0444, "epss_percentile": 0.88692}, "CVE-2024-37968": {"epss_score": 0.08056, "epss_percentile": 0.91857}, "CVE-2024-37969": {"epss_score": 0.01198, "epss_percentile": 0.78455}, "CVE-2024-37970": {"epss_score": 0.01186, "epss_percentile": 0.78351}, "CVE-2024-37971": {"epss_score": 0.01198, "epss_percentile": 0.78455}, "CVE-2024-37972": {"epss_score": 0.02163, "epss_percentile": 0.83834}, "CVE-2024-37973": {"epss_score": 0.00925, "epss_percentile": 0.75535}, "CVE-2024-37974": {"epss_score": 0.01871, "epss_percentile": 0.82637}, "CVE-2024-37975": {"epss_score": 0.0189, "epss_percentile": 0.82727}, "CVE-2024-37976": {"epss_score": 0.00856, "epss_percentile": 0.74477}, "CVE-2024-37977": {"epss_score": 0.02185, "epss_percentile": 0.83917}, "CVE-2024-37978": {"epss_score": 0.02163, "epss_percentile": 0.83834}, "CVE-2024-37979": {"epss_score": 0.00184, "epss_percentile": 0.40437}, "CVE-2024-37980": {"epss_score": 0.0433, "epss_percentile": 0.88558}, "CVE-2024-37981": {"epss_score": 0.0189, "epss_percentile": 0.82727}, "CVE-2024-37982": {"epss_score": 0.00184, "epss_percentile": 0.40437}, "CVE-2024-37983": {"epss_score": 0.00235, "epss_percentile": 0.46225}, "CVE-2024-37984": {"epss_score": 0.01229, "epss_percentile": 0.78714}, "CVE-2024-37985": {"epss_score": 0.00762, "epss_percentile": 0.72843}, "CVE-2024-37986": {"epss_score": 0.01871, "epss_percentile": 0.82637}, "CVE-2024-37987": {"epss_score": 0.02682, "epss_percentile": 0.85418}, "CVE-2024-37988": {"epss_score": 0.01725, "epss_percentile": 0.81956}, "CVE-2024-37989": {"epss_score": 0.01725, "epss_percentile": 0.81956}, "CVE-2024-37990": {"epss_score": 0.00218, "epss_percentile": 0.44437}, "CVE-2024-37991": {"epss_score": 0.00279, "epss_percentile": 0.50989}, "CVE-2024-37992": {"epss_score": 0.0024, "epss_percentile": 0.46947}, "CVE-2024-37993": {"epss_score": 0.00188, "epss_percentile": 0.40905}, "CVE-2024-37994": {"epss_score": 0.00257, "epss_percentile": 0.4887}, "CVE-2024-37995": {"epss_score": 0.00113, "epss_percentile": 0.30581}, "CVE-2024-37996": {"epss_score": 0.00071, "epss_percentile": 0.22126}, "CVE-2024-37997": {"epss_score": 0.00098, "epss_percentile": 0.27684}, "CVE-2024-37998": {"epss_score": 0.0027, "epss_percentile": 0.50209}, "CVE-2024-37999": {"epss_score": 0.00051, "epss_percentile": 0.16119}, "CVE-2024-38002": {"epss_score": 0.03194, "epss_percentile": 0.86607}, "CVE-2024-38010": {"epss_score": 0.01725, "epss_percentile": 0.81956}, "CVE-2024-38011": {"epss_score": 0.01266, "epss_percentile": 0.79011}, "CVE-2024-38013": {"epss_score": 0.00131, "epss_percentile": 0.33356}, "CVE-2024-38014": {"epss_score": 0.12828, "epss_percentile": 0.93796}, "CVE-2024-38015": {"epss_score": 0.07672, "epss_percentile": 0.91616}, "CVE-2024-38016": {"epss_score": 0.01114, "epss_percentile": 0.77693}, "CVE-2024-38017": {"epss_score": 0.00448, "epss_percentile": 0.63005}, "CVE-2024-38018": {"epss_score": 0.51349, "epss_percentile": 0.97775}, "CVE-2024-38019": {"epss_score": 0.03875, "epss_percentile": 0.87886}, "CVE-2024-38020": {"epss_score": 0.00321, "epss_percentile": 0.54737}, "CVE-2024-38021": {"epss_score": 0.16124, "epss_percentile": 0.94576}, "CVE-2024-38022": {"epss_score": 0.0071, "epss_percentile": 0.71719}, "CVE-2024-38023": {"epss_score": 0.1437, "epss_percentile": 0.94196}, "CVE-2024-38024": {"epss_score": 0.17151, "epss_percentile": 0.94783}, "CVE-2024-38025": {"epss_score": 0.06518, "epss_percentile": 0.90815}, "CVE-2024-38027": {"epss_score": 0.00277, "epss_percentile": 0.50836}, "CVE-2024-38028": {"epss_score": 0.04945, "epss_percentile": 0.89312}, "CVE-2024-38029": {"epss_score": 0.03582, "epss_percentile": 0.87386}, "CVE-2024-38030": {"epss_score": 0.70293, "epss_percentile": 0.98626}, "CVE-2024-38031": {"epss_score": 0.07584, "epss_percentile": 0.91555}, "CVE-2024-38032": {"epss_score": 0.00869, "epss_percentile": 0.74685}, "CVE-2024-38033": {"epss_score": 0.01621, "epss_percentile": 0.8139}, "CVE-2024-38034": {"epss_score": 0.01334, "epss_percentile": 0.79535}, "CVE-2024-38036": {"epss_score": 0.02602, "epss_percentile": 0.85211}, "CVE-2024-38037": {"epss_score": 0.00599, "epss_percentile": 0.68802}, "CVE-2024-38038": {"epss_score": 0.00383, "epss_percentile": 0.59102}, "CVE-2024-38039": {"epss_score": 0.0061, "epss_percentile": 0.69164}, "CVE-2024-38040": {"epss_score": 0.00285, "epss_percentile": 0.51683}, "CVE-2024-38041": {"epss_score": 0.21795, "epss_percentile": 0.95562}, "CVE-2024-38043": {"epss_score": 0.0069, "epss_percentile": 0.71238}, "CVE-2024-38044": {"epss_score": 0.06501, "epss_percentile": 0.90802}, "CVE-2024-38045": {"epss_score": 0.03161, "epss_percentile": 0.86531}, "CVE-2024-38046": {"epss_score": 0.00712, "epss_percentile": 0.71775}, "CVE-2024-38047": {"epss_score": 0.00499, "epss_percentile": 0.65259}, "CVE-2024-38048": {"epss_score": 0.00203, "epss_percentile": 0.42546}, "CVE-2024-38049": {"epss_score": 0.0034, "epss_percentile": 0.56228}, "CVE-2024-38050": {"epss_score": 0.00727, "epss_percentile": 0.72101}, "CVE-2024-38051": {"epss_score": 0.01744, "epss_percentile": 0.82064}, "CVE-2024-38052": {"epss_score": 0.03212, "epss_percentile": 0.86656}, "CVE-2024-38053": {"epss_score": 0.00801, "epss_percentile": 0.73563}, "CVE-2024-38054": {"epss_score": 0.3278, "epss_percentile": 0.96724}, "CVE-2024-38055": {"epss_score": 0.00378, "epss_percentile": 0.58837}, "CVE-2024-38056": {"epss_score": 0.00244, "epss_percentile": 0.47586}, "CVE-2024-38057": {"epss_score": 0.00628, "epss_percentile": 0.69666}, "CVE-2024-38058": {"epss_score": 0.0039, "epss_percentile": 0.5952}, "CVE-2024-38059": {"epss_score": 0.08964, "epss_percentile": 0.92339}, "CVE-2024-38060": {"epss_score": 0.11773, "epss_percentile": 0.9347}, "CVE-2024-38061": {"epss_score": 0.03075, "epss_percentile": 0.86356}, "CVE-2024-38062": {"epss_score": 0.05049, "epss_percentile": 0.89438}, "CVE-2024-38063": {"epss_score": 0.90059, "epss_percentile": 0.99559}, "CVE-2024-38064": {"epss_score": 0.14538, "epss_percentile": 0.94236}, "CVE-2024-38065": {"epss_score": 0.00514, "epss_percentile": 0.65943}, "CVE-2024-38066": {"epss_score": 0.00332, "epss_percentile": 0.55566}, "CVE-2024-38067": {"epss_score": 0.09955, "epss_percentile": 0.92792}, "CVE-2024-38068": {"epss_score": 0.07584, "epss_percentile": 0.91555}, "CVE-2024-38069": {"epss_score": 0.00228, "epss_percentile": 0.45532}, "CVE-2024-38070": {"epss_score": 0.008, "epss_percentile": 0.73559}, "CVE-2024-38071": {"epss_score": 0.50156, "epss_percentile": 0.97723}, "CVE-2024-38072": {"epss_score": 0.13564, "epss_percentile": 0.93998}, "CVE-2024-38073": {"epss_score": 0.05022, "epss_percentile": 0.89402}, "CVE-2024-38074": {"epss_score": 0.09261, "epss_percentile": 0.92469}, "CVE-2024-38076": {"epss_score": 0.08727, "epss_percentile": 0.9223}, "CVE-2024-38077": {"epss_score": 0.87069, "epss_percentile": 0.99413}, "CVE-2024-38078": {"epss_score": 0.00768, "epss_percentile": 0.72976}, "CVE-2024-38079": {"epss_score": 0.00743, "epss_percentile": 0.725}, "CVE-2024-38080": {"epss_score": 0.19713, "epss_percentile": 0.9523}, "CVE-2024-38081": {"epss_score": 0.008, "epss_percentile": 0.73549}, "CVE-2024-38082": {"epss_score": 0.0025, "epss_percentile": 0.4821}, "CVE-2024-38083": {"epss_score": 0.00502, "epss_percentile": 0.65406}, "CVE-2024-38084": {"epss_score": 0.00417, "epss_percentile": 0.61222}, "CVE-2024-38085": {"epss_score": 0.09179, "epss_percentile": 0.92434}, "CVE-2024-38086": {"epss_score": 0.01139, "epss_percentile": 0.77938}, "CVE-2024-38087": {"epss_score": 0.0718, "epss_percentile": 0.91302}, "CVE-2024-38088": {"epss_score": 0.05419, "epss_percentile": 0.89854}, "CVE-2024-38089": {"epss_score": 0.01647, "epss_percentile": 0.81539}, "CVE-2024-38091": {"epss_score": 0.15701, "epss_percentile": 0.94486}, "CVE-2024-38092": {"epss_score": 0.0981, "epss_percentile": 0.92712}, "CVE-2024-38093": {"epss_score": 0.00502, "epss_percentile": 0.65406}, "CVE-2024-38094": {"epss_score": 0.69593, "epss_percentile": 0.98593}, "CVE-2024-38095": {"epss_score": 0.02007, "epss_percentile": 0.83236}, "CVE-2024-38097": {"epss_score": 0.0051, "epss_percentile": 0.65794}, "CVE-2024-38098": {"epss_score": 0.00555, "epss_percentile": 0.67462}, "CVE-2024-38099": {"epss_score": 0.01843, "epss_percentile": 0.82503}, "CVE-2024-38100": {"epss_score": 0.30726, "epss_percentile": 0.96563}, "CVE-2024-38101": {"epss_score": 0.00469, "epss_percentile": 0.63922}, "CVE-2024-38102": {"epss_score": 0.00625, "epss_percentile": 0.69578}, "CVE-2024-38103": {"epss_score": 0.00973, "epss_percentile": 0.76157}, "CVE-2024-38104": {"epss_score": 0.09131, "epss_percentile": 0.92415}, "CVE-2024-38105": {"epss_score": 0.00604, "epss_percentile": 0.68941}, "CVE-2024-38106": {"epss_score": 0.00651, "epss_percentile": 0.70283}, "CVE-2024-38107": {"epss_score": 0.02757, "epss_percentile": 0.85593}, "CVE-2024-38108": {"epss_score": 0.01147, "epss_percentile": 0.78009}, "CVE-2024-38109": {"epss_score": 0.03935, "epss_percentile": 0.8798}, "CVE-2024-38112": {"epss_score": 0.92823, "epss_percentile": 0.99753}, "CVE-2024-38114": {"epss_score": 0.08063, "epss_percentile": 0.91862}, "CVE-2024-38115": {"epss_score": 0.08063, "epss_percentile": 0.91862}, "CVE-2024-38116": {"epss_score": 0.11979, "epss_percentile": 0.93532}, "CVE-2024-38117": {"epss_score": 0.00628, "epss_percentile": 0.69666}, "CVE-2024-38118": {"epss_score": 0.00335, "epss_percentile": 0.558}, "CVE-2024-38119": {"epss_score": 0.00414, "epss_percentile": 0.61036}, "CVE-2024-38120": {"epss_score": 0.06256, "epss_percentile": 0.90617}, "CVE-2024-38121": {"epss_score": 0.08063, "epss_percentile": 0.91862}, "CVE-2024-38122": {"epss_score": 0.00516, "epss_percentile": 0.66059}, "CVE-2024-38123": {"epss_score": 0.00312, "epss_percentile": 0.53955}, "CVE-2024-38124": {"epss_score": 0.00421, "epss_percentile": 0.61495}, "CVE-2024-38125": {"epss_score": 0.09427, "epss_percentile": 0.92541}, "CVE-2024-38126": {"epss_score": 0.12279, "epss_percentile": 0.93621}, "CVE-2024-38127": {"epss_score": 0.08077, "epss_percentile": 0.91869}, "CVE-2024-38128": {"epss_score": 0.04783, "epss_percentile": 0.89137}, "CVE-2024-38129": {"epss_score": 0.01907, "epss_percentile": 0.8281}, "CVE-2024-38130": {"epss_score": 0.05934, "epss_percentile": 0.90339}, "CVE-2024-38131": {"epss_score": 0.01485, "epss_percentile": 0.80599}, "CVE-2024-38132": {"epss_score": 0.11171, "epss_percentile": 0.93252}, "CVE-2024-38133": {"epss_score": 0.00329, "epss_percentile": 0.55308}, "CVE-2024-38134": {"epss_score": 0.00623, "epss_percentile": 0.69538}, "CVE-2024-38135": {"epss_score": 0.00628, "epss_percentile": 0.69666}, "CVE-2024-38136": {"epss_score": 0.00194, "epss_percentile": 0.41584}, "CVE-2024-38137": {"epss_score": 0.00194, "epss_percentile": 0.41584}, "CVE-2024-38138": {"epss_score": 0.04057, "epss_percentile": 0.88186}, "CVE-2024-38139": {"epss_score": 0.01141, "epss_percentile": 0.77956}, "CVE-2024-38140": {"epss_score": 0.05323, "epss_percentile": 0.89731}, "CVE-2024-38141": {"epss_score": 0.06806, "epss_percentile": 0.91039}, "CVE-2024-38142": {"epss_score": 0.00226, "epss_percentile": 0.45356}, "CVE-2024-38143": {"epss_score": 0.0386, "epss_percentile": 0.87865}, "CVE-2024-38144": {"epss_score": 0.82351, "epss_percentile": 0.99189}, "CVE-2024-38145": {"epss_score": 0.17315, "epss_percentile": 0.94821}, "CVE-2024-38146": {"epss_score": 0.17315, "epss_percentile": 0.94821}, "CVE-2024-38147": {"epss_score": 0.05171, "epss_percentile": 0.8957}, "CVE-2024-38148": {"epss_score": 0.59743, "epss_percentile": 0.98178}, "CVE-2024-38149": {"epss_score": 0.09955, "epss_percentile": 0.92792}, "CVE-2024-38150": {"epss_score": 0.06806, "epss_percentile": 0.91039}, "CVE-2024-38151": {"epss_score": 0.00259, "epss_percentile": 0.49033}, "CVE-2024-38152": {"epss_score": 0.00962, "epss_percentile": 0.7599}, "CVE-2024-38153": {"epss_score": 0.00138, "epss_percentile": 0.34383}, "CVE-2024-38154": {"epss_score": 0.08063, "epss_percentile": 0.91862}, "CVE-2024-38155": {"epss_score": 0.00134, "epss_percentile": 0.33866}, "CVE-2024-38156": {"epss_score": 0.00486, "epss_percentile": 0.64752}, "CVE-2024-38157": {"epss_score": 0.0035, "epss_percentile": 0.56963}, "CVE-2024-38158": {"epss_score": 0.0026, "epss_percentile": 0.49189}, "CVE-2024-38159": {"epss_score": 0.02986, "epss_percentile": 0.86133}, "CVE-2024-38160": {"epss_score": 0.02676, "epss_percentile": 0.85402}, "CVE-2024-38161": {"epss_score": 0.00351, "epss_percentile": 0.57035}, "CVE-2024-38162": {"epss_score": 0.00666, "epss_percentile": 0.70685}, "CVE-2024-38163": {"epss_score": 0.00808, "epss_percentile": 0.73696}, "CVE-2024-38164": {"epss_score": 0.05379, "epss_percentile": 0.89809}, "CVE-2024-38165": {"epss_score": 0.00228, "epss_percentile": 0.45523}, "CVE-2024-38166": {"epss_score": 0.00596, "epss_percentile": 0.68707}, "CVE-2024-38167": {"epss_score": 0.01803, "epss_percentile": 0.82342}, "CVE-2024-38168": {"epss_score": 0.02913, "epss_percentile": 0.85976}, "CVE-2024-38169": {"epss_score": 0.0052, "epss_percentile": 0.66186}, "CVE-2024-38170": {"epss_score": 0.00592, "epss_percentile": 0.68613}, "CVE-2024-38171": {"epss_score": 0.00468, "epss_percentile": 0.63886}, "CVE-2024-38172": {"epss_score": 0.00699, "epss_percentile": 0.71446}, "CVE-2024-38173": {"epss_score": 0.00366, "epss_percentile": 0.58077}, "CVE-2024-38175": {"epss_score": 0.04604, "epss_percentile": 0.88907}, "CVE-2024-38176": {"epss_score": 0.03243, "epss_percentile": 0.86736}, "CVE-2024-38177": {"epss_score": 0.00758, "epss_percentile": 0.72773}, "CVE-2024-38178": {"epss_score": 0.24715, "epss_percentile": 0.95948}, "CVE-2024-38179": {"epss_score": 0.00368, "epss_percentile": 0.58216}, "CVE-2024-38180": {"epss_score": 0.06536, "epss_percentile": 0.90828}, "CVE-2024-38182": {"epss_score": 0.01779, "epss_percentile": 0.8223}, "CVE-2024-38183": {"epss_score": 0.02962, "epss_percentile": 0.86074}, "CVE-2024-38184": {"epss_score": 0.00333, "epss_percentile": 0.55652}, "CVE-2024-38185": {"epss_score": 0.00266, "epss_percentile": 0.49874}, "CVE-2024-38186": {"epss_score": 0.00225, "epss_percentile": 0.45106}, "CVE-2024-38187": {"epss_score": 0.00376, "epss_percentile": 0.58663}, "CVE-2024-38188": {"epss_score": 0.00345, "epss_percentile": 0.56551}, "CVE-2024-38189": {"epss_score": 0.54672, "epss_percentile": 0.97938}, "CVE-2024-38190": {"epss_score": 0.01294, "epss_percentile": 0.79248}, "CVE-2024-38191": {"epss_score": 0.00284, "epss_percentile": 0.515}, "CVE-2024-38193": {"epss_score": 0.69792, "epss_percentile": 0.98603}, "CVE-2024-38194": {"epss_score": 0.00911, "epss_percentile": 0.75354}, "CVE-2024-38195": {"epss_score": 0.00487, "epss_percentile": 0.64824}, "CVE-2024-38196": {"epss_score": 0.09375, "epss_percentile": 0.92521}, "CVE-2024-38197": {"epss_score": 0.06628, "epss_percentile": 0.90901}, "CVE-2024-38198": {"epss_score": 0.02517, "epss_percentile": 0.8499}, "CVE-2024-38199": {"epss_score": 0.04788, "epss_percentile": 0.89148}, "CVE-2024-38200": {"epss_score": 0.53583, "epss_percentile": 0.97883}, "CVE-2024-38201": {"epss_score": 0.00759, "epss_percentile": 0.72793}, "CVE-2024-38202": {"epss_score": 0.0233, "epss_percentile": 0.844}, "CVE-2024-38203": {"epss_score": 0.00098, "epss_percentile": 0.27688}, "CVE-2024-38204": {"epss_score": 0.05982, "epss_percentile": 0.9038}, "CVE-2024-38206": {"epss_score": 0.02336, "epss_percentile": 0.84416}, "CVE-2024-38207": {"epss_score": 0.00223, "epss_percentile": 0.44848}, "CVE-2024-38208": {"epss_score": 0.00494, "epss_percentile": 0.65068}, "CVE-2024-38209": {"epss_score": 0.00881, "epss_percentile": 0.74876}, "CVE-2024-38210": {"epss_score": 0.01043, "epss_percentile": 0.76994}, "CVE-2024-38211": {"epss_score": 0.00308, "epss_percentile": 0.53595}, "CVE-2024-38212": {"epss_score": 0.03084, "epss_percentile": 0.8638}, "CVE-2024-38213": {"epss_score": 0.59323, "epss_percentile": 0.9816}, "CVE-2024-38214": {"epss_score": 0.00341, "epss_percentile": 0.56341}, "CVE-2024-38215": {"epss_score": 0.00727, "epss_percentile": 0.72101}, "CVE-2024-38216": {"epss_score": 0.01568, "epss_percentile": 0.8108}, "CVE-2024-38217": {"epss_score": 0.13571, "epss_percentile": 0.93999}, "CVE-2024-38218": {"epss_score": 0.00533, "epss_percentile": 0.66711}, "CVE-2024-38219": {"epss_score": 0.00203, "epss_percentile": 0.42504}, "CVE-2024-38220": {"epss_score": 0.01044, "epss_percentile": 0.77006}, "CVE-2024-38221": {"epss_score": 0.00406, "epss_percentile": 0.60527}, "CVE-2024-38222": {"epss_score": 0.02429, "epss_percentile": 0.84721}, "CVE-2024-38223": {"epss_score": 0.00147, "epss_percentile": 0.35775}, "CVE-2024-38225": {"epss_score": 0.07677, "epss_percentile": 0.9162}, "CVE-2024-38226": {"epss_score": 0.01432, "epss_percentile": 0.80252}, "CVE-2024-38227": {"epss_score": 0.00247, "epss_percentile": 0.47817}, "CVE-2024-38228": {"epss_score": 0.00247, "epss_percentile": 0.47817}, "CVE-2024-38229": {"epss_score": 0.00923, "epss_percentile": 0.75496}, "CVE-2024-38230": {"epss_score": 0.07074, "epss_percentile": 0.91232}, "CVE-2024-38231": {"epss_score": 0.019, "epss_percentile": 0.82768}, "CVE-2024-38232": {"epss_score": 0.13518, "epss_percentile": 0.93987}, "CVE-2024-38233": {"epss_score": 0.13518, "epss_percentile": 0.93987}, "CVE-2024-38234": {"epss_score": 0.00417, "epss_percentile": 0.61241}, "CVE-2024-38235": {"epss_score": 0.00162, "epss_percentile": 0.37658}, "CVE-2024-38236": {"epss_score": 0.09955, "epss_percentile": 0.92792}, "CVE-2024-38237": {"epss_score": 0.0423, "epss_percentile": 0.88421}, "CVE-2024-38238": {"epss_score": 0.00592, "epss_percentile": 0.68605}, "CVE-2024-38239": {"epss_score": 0.05143, "epss_percentile": 0.89539}, "CVE-2024-38240": {"epss_score": 0.03075, "epss_percentile": 0.86358}, "CVE-2024-38241": {"epss_score": 0.0502, "epss_percentile": 0.894}, "CVE-2024-38242": {"epss_score": 0.05541, "epss_percentile": 0.89979}, "CVE-2024-38243": {"epss_score": 0.00441, "epss_percentile": 0.62686}, "CVE-2024-38244": {"epss_score": 0.02879, "epss_percentile": 0.85893}, "CVE-2024-38245": {"epss_score": 0.00826, "epss_percentile": 0.73963}, "CVE-2024-38246": {"epss_score": 0.00369, "epss_percentile": 0.58242}, "CVE-2024-38247": {"epss_score": 0.00496, "epss_percentile": 0.6517}, "CVE-2024-38248": {"epss_score": 0.00369, "epss_percentile": 0.58242}, "CVE-2024-38249": {"epss_score": 0.00813, "epss_percentile": 0.73759}, "CVE-2024-38250": {"epss_score": 0.00353, "epss_percentile": 0.57192}, "CVE-2024-38252": {"epss_score": 0.00661, "epss_percentile": 0.70587}, "CVE-2024-38253": {"epss_score": 0.00661, "epss_percentile": 0.70587}, "CVE-2024-38254": {"epss_score": 0.00269, "epss_percentile": 0.50149}, "CVE-2024-38255": {"epss_score": 0.02197, "epss_percentile": 0.8396}, "CVE-2024-38256": {"epss_score": 0.00269, "epss_percentile": 0.50149}, "CVE-2024-38257": {"epss_score": 0.05422, "epss_percentile": 0.89864}, "CVE-2024-38258": {"epss_score": 0.00826, "epss_percentile": 0.73959}, "CVE-2024-38259": {"epss_score": 0.03365, "epss_percentile": 0.87001}, "CVE-2024-38260": {"epss_score": 0.05024, "epss_percentile": 0.89406}, "CVE-2024-38261": {"epss_score": 0.01208, "epss_percentile": 0.78536}, "CVE-2024-38262": {"epss_score": 0.00383, "epss_percentile": 0.59121}, "CVE-2024-38263": {"epss_score": 0.00206, "epss_percentile": 0.4306}, "CVE-2024-38264": {"epss_score": 0.0022, "epss_percentile": 0.44584}, "CVE-2024-38265": {"epss_score": 0.05229, "epss_percentile": 0.89637}, "CVE-2024-38266": {"epss_score": 0.00182, "epss_percentile": 0.40248}, "CVE-2024-38267": {"epss_score": 0.00182, "epss_percentile": 0.40248}, "CVE-2024-38268": {"epss_score": 0.00182, "epss_percentile": 0.40248}, "CVE-2024-38269": {"epss_score": 0.00182, "epss_percentile": 0.40248}, "CVE-2024-38270": {"epss_score": 0.00127, "epss_percentile": 0.32833}, "CVE-2024-38271": {"epss_score": 0.00087, "epss_percentile": 0.25622}, "CVE-2024-38272": {"epss_score": 0.00012, "epss_percentile": 0.01417}, "CVE-2024-38273": {"epss_score": 0.00199, "epss_percentile": 0.42187}, "CVE-2024-38274": {"epss_score": 0.00762, "epss_percentile": 0.72848}, "CVE-2024-38275": {"epss_score": 0.00759, "epss_percentile": 0.72786}, "CVE-2024-38276": {"epss_score": 0.00205, "epss_percentile": 0.42716}, "CVE-2024-38277": {"epss_score": 0.00186, "epss_percentile": 0.40604}, "CVE-2024-38278": {"epss_score": 0.00093, "epss_percentile": 0.26737}, "CVE-2024-38279": {"epss_score": 0.00026, "epss_percentile": 0.06481}, "CVE-2024-38280": {"epss_score": 0.00087, "epss_percentile": 0.25452}, "CVE-2024-38281": {"epss_score": 0.00199, "epss_percentile": 0.4218}, "CVE-2024-38282": {"epss_score": 0.00087, "epss_percentile": 0.25506}, "CVE-2024-38283": {"epss_score": 0.0005, "epss_percentile": 0.15653}, "CVE-2024-38284": {"epss_score": 0.00183, "epss_percentile": 0.40365}, "CVE-2024-38285": {"epss_score": 0.0011, "epss_percentile": 0.30169}, "CVE-2024-38286": {"epss_score": 0.00545, "epss_percentile": 0.67162}, "CVE-2024-38287": {"epss_score": 0.01136, "epss_percentile": 0.77917}, "CVE-2024-38288": {"epss_score": 0.68544, "epss_percentile": 0.98553}, "CVE-2024-38289": {"epss_score": 0.84253, "epss_percentile": 0.99281}, "CVE-2024-38290": {"epss_score": 0.00121, "epss_percentile": 0.3195}, "CVE-2024-38291": {"epss_score": 0.00133, "epss_percentile": 0.33725}, "CVE-2024-38292": {"epss_score": 0.00331, "epss_percentile": 0.55511}, "CVE-2024-38293": {"epss_score": 0.02926, "epss_percentile": 0.86006}, "CVE-2024-38294": {"epss_score": 0.07073, "epss_percentile": 0.9123}, "CVE-2024-38295": {"epss_score": 0.06761, "epss_percentile": 0.91008}, "CVE-2024-38296": {"epss_score": 0.0002, "epss_percentile": 0.04428}, "CVE-2024-38301": {"epss_score": 0.00186, "epss_percentile": 0.4066}, "CVE-2024-38302": {"epss_score": 0.00069, "epss_percentile": 0.2161}, "CVE-2024-38303": {"epss_score": 0.00026, "epss_percentile": 0.0654}, "CVE-2024-38304": {"epss_score": 0.00082, "epss_percentile": 0.24566}, "CVE-2024-38305": {"epss_score": 0.00098, "epss_percentile": 0.27724}, "CVE-2024-38306": {"epss_score": 0.00024, "epss_percentile": 0.05884}, "CVE-2024-38307": {"epss_score": 0.00134, "epss_percentile": 0.3392}, "CVE-2024-38308": {"epss_score": 0.00105, "epss_percentile": 0.29284}, "CVE-2024-38309": {"epss_score": 0.00015, "epss_percentile": 0.02516}, "CVE-2024-38310": {"epss_score": 0.00021, "epss_percentile": 0.04819}, "CVE-2024-38311": {"epss_score": 0.00745, "epss_percentile": 0.72531}, "CVE-2024-38312": {"epss_score": 0.00382, "epss_percentile": 0.59063}, "CVE-2024-38313": {"epss_score": 0.003, "epss_percentile": 0.52939}, "CVE-2024-38314": {"epss_score": 0.00079, "epss_percentile": 0.23901}, "CVE-2024-38315": {"epss_score": 0.00036, "epss_percentile": 0.10553}, "CVE-2024-38316": {"epss_score": 0.00164, "epss_percentile": 0.37874}, "CVE-2024-38317": {"epss_score": 0.00096, "epss_percentile": 0.27292}, "CVE-2024-38318": {"epss_score": 0.00055, "epss_percentile": 0.1758}, "CVE-2024-38319": {"epss_score": 0.00314, "epss_percentile": 0.54094}, "CVE-2024-38320": {"epss_score": 0.00032, "epss_percentile": 0.08739}, "CVE-2024-38321": {"epss_score": 0.00077, "epss_percentile": 0.23467}, "CVE-2024-38322": {"epss_score": 0.00121, "epss_percentile": 0.31916}, "CVE-2024-38324": {"epss_score": 0.00042, "epss_percentile": 0.12568}, "CVE-2024-38325": {"epss_score": 0.00047, "epss_percentile": 0.14628}, "CVE-2024-38327": {"epss_score": 0.00027, "epss_percentile": 0.07096}, "CVE-2024-38329": {"epss_score": 0.00016, "epss_percentile": 0.02758}, "CVE-2024-38330": {"epss_score": 0.00073, "epss_percentile": 0.22561}, "CVE-2024-38335": {"epss_score": 0.00021, "epss_percentile": 0.04801}, "CVE-2024-38337": {"epss_score": 0.00112, "epss_percentile": 0.30578}, "CVE-2024-38341": {"epss_score": 0.00015, "epss_percentile": 0.0254}, "CVE-2024-38344": {"epss_score": 0.00156, "epss_percentile": 0.36999}, "CVE-2024-38345": {"epss_score": 0.0017, "epss_percentile": 0.38736}, "CVE-2024-38346": {"epss_score": 0.05028, "epss_percentile": 0.8941}, "CVE-2024-38347": {"epss_score": 0.00132, "epss_percentile": 0.33615}, "CVE-2024-38348": {"epss_score": 0.00106, "epss_percentile": 0.295}, "CVE-2024-38351": {"epss_score": 0.00144, "epss_percentile": 0.35228}, "CVE-2024-38353": {"epss_score": 0.05317, "epss_percentile": 0.89723}, "CVE-2024-38354": {"epss_score": 0.00965, "epss_percentile": 0.76045}, "CVE-2024-38355": {"epss_score": 0.00136, "epss_percentile": 0.34102}, "CVE-2024-38356": {"epss_score": 0.01065, "epss_percentile": 0.77209}, "CVE-2024-38357": {"epss_score": 0.01485, "epss_percentile": 0.80599}, "CVE-2024-38358": {"epss_score": 0.00142, "epss_percentile": 0.34998}, "CVE-2024-38359": {"epss_score": 0.00183, "epss_percentile": 0.40341}, "CVE-2024-38360": {"epss_score": 0.00362, "epss_percentile": 0.57754}, "CVE-2024-38361": {"epss_score": 0.0019, "epss_percentile": 0.41071}, "CVE-2024-38363": {"epss_score": 0.02371, "epss_percentile": 0.84525}, "CVE-2024-38364": {"epss_score": 0.00112, "epss_percentile": 0.30455}, "CVE-2024-38365": {"epss_score": 0.00427, "epss_percentile": 0.61903}, "CVE-2024-38366": {"epss_score": 0.58458, "epss_percentile": 0.98118}, "CVE-2024-38367": {"epss_score": 0.04993, "epss_percentile": 0.89369}, "CVE-2024-38368": {"epss_score": 0.01932, "epss_percentile": 0.82944}, "CVE-2024-38369": {"epss_score": 0.00767, "epss_percentile": 0.72958}, "CVE-2024-38370": {"epss_score": 0.00489, "epss_percentile": 0.64914}, "CVE-2024-38371": {"epss_score": 0.00727, "epss_percentile": 0.72089}, "CVE-2024-38372": {"epss_score": 0.00355, "epss_percentile": 0.57291}, "CVE-2024-38373": {"epss_score": 0.00646, "epss_percentile": 0.70139}, "CVE-2024-38374": {"epss_score": 0.00083, "epss_percentile": 0.2476}, "CVE-2024-38375": {"epss_score": 0.00125, "epss_percentile": 0.32513}, "CVE-2024-38379": {"epss_score": 0.01347, "epss_percentile": 0.79651}, "CVE-2024-38380": {"epss_score": 0.00087, "epss_percentile": 0.256}, "CVE-2024-38381": {"epss_score": 0.00011, "epss_percentile": 0.0111}, "CVE-2024-38382": {"epss_score": 0.00085, "epss_percentile": 0.25175}, "CVE-2024-38383": {"epss_score": 0.00089, "epss_percentile": 0.25982}, "CVE-2024-38384": {"epss_score": 0.00031, "epss_percentile": 0.0869}, "CVE-2024-38385": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2024-38386": {"epss_score": 0.00067, "epss_percentile": 0.2104}, "CVE-2024-38387": {"epss_score": 0.00109, "epss_percentile": 0.29985}, "CVE-2024-38388": {"epss_score": 0.00033, "epss_percentile": 0.09324}, "CVE-2024-38389": {"epss_score": 0.00017, "epss_percentile": 0.03218}, "CVE-2024-38390": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-38392": {"epss_score": 0.00201, "epss_percentile": 0.42285}, "CVE-2024-38394": {"epss_score": 0.00034, "epss_percentile": 0.09548}, "CVE-2024-38395": {"epss_score": 0.09237, "epss_percentile": 0.92461}, "CVE-2024-38396": {"epss_score": 0.10304, "epss_percentile": 0.92935}, "CVE-2024-38397": {"epss_score": 0.00222, "epss_percentile": 0.44802}, "CVE-2024-38399": {"epss_score": 0.00079, "epss_percentile": 0.23806}, "CVE-2024-38401": {"epss_score": 0.00082, "epss_percentile": 0.24448}, "CVE-2024-38402": {"epss_score": 0.00489, "epss_percentile": 0.64913}, "CVE-2024-38403": {"epss_score": 0.00488, "epss_percentile": 0.6485}, "CVE-2024-38404": {"epss_score": 0.00161, "epss_percentile": 0.37524}, "CVE-2024-38405": {"epss_score": 0.00381, "epss_percentile": 0.58995}, "CVE-2024-38406": {"epss_score": 0.00118, "epss_percentile": 0.31417}, "CVE-2024-38407": {"epss_score": 0.00118, "epss_percentile": 0.31417}, "CVE-2024-38408": {"epss_score": 0.0047, "epss_percentile": 0.63979}, "CVE-2024-38409": {"epss_score": 0.00152, "epss_percentile": 0.3646}, "CVE-2024-38410": {"epss_score": 0.00152, "epss_percentile": 0.3646}, "CVE-2024-38411": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-38412": {"epss_score": 0.00033, "epss_percentile": 0.09281}, "CVE-2024-38413": {"epss_score": 0.00033, "epss_percentile": 0.09281}, "CVE-2024-38414": {"epss_score": 0.00032, "epss_percentile": 0.08825}, "CVE-2024-38415": {"epss_score": 0.00182, "epss_percentile": 0.40147}, "CVE-2024-38416": {"epss_score": 0.00032, "epss_percentile": 0.08825}, "CVE-2024-38417": {"epss_score": 0.00032, "epss_percentile": 0.08825}, "CVE-2024-38418": {"epss_score": 0.0002, "epss_percentile": 0.04621}, "CVE-2024-38419": {"epss_score": 0.00152, "epss_percentile": 0.3646}, "CVE-2024-38420": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-38421": {"epss_score": 0.00182, "epss_percentile": 0.40147}, "CVE-2024-38422": {"epss_score": 0.00182, "epss_percentile": 0.40147}, "CVE-2024-38423": {"epss_score": 0.00182, "epss_percentile": 0.40147}, "CVE-2024-38424": {"epss_score": 0.00182, "epss_percentile": 0.40147}, "CVE-2024-38425": {"epss_score": 0.00045, "epss_percentile": 0.13911}, "CVE-2024-38426": {"epss_score": 0.00087, "epss_percentile": 0.25534}, "CVE-2024-38427": {"epss_score": 0.00197, "epss_percentile": 0.41929}, "CVE-2024-38428": {"epss_score": 0.00197, "epss_percentile": 0.41876}, "CVE-2024-38429": {"epss_score": 0.00204, "epss_percentile": 0.42602}, "CVE-2024-38430": {"epss_score": 0.00278, "epss_percentile": 0.5088}, "CVE-2024-38431": {"epss_score": 0.00296, "epss_percentile": 0.52533}, "CVE-2024-38432": {"epss_score": 0.00114, "epss_percentile": 0.30791}, "CVE-2024-38433": {"epss_score": 6e-05, "epss_percentile": 0.00287}, "CVE-2024-38434": {"epss_score": 0.00052, "epss_percentile": 0.16482}, "CVE-2024-38435": {"epss_score": 0.00106, "epss_percentile": 0.29425}, "CVE-2024-38436": {"epss_score": 0.0015, "epss_percentile": 0.36141}, "CVE-2024-38437": {"epss_score": 0.003, "epss_percentile": 0.52925}, "CVE-2024-38438": {"epss_score": 0.00256, "epss_percentile": 0.48831}, "CVE-2024-38439": {"epss_score": 0.00631, "epss_percentile": 0.69717}, "CVE-2024-38440": {"epss_score": 0.0066, "epss_percentile": 0.70539}, "CVE-2024-38441": {"epss_score": 0.00855, "epss_percentile": 0.74471}, "CVE-2024-38443": {"epss_score": 0.00045, "epss_percentile": 0.13935}, "CVE-2024-38446": {"epss_score": 0.00268, "epss_percentile": 0.50101}, "CVE-2024-38447": {"epss_score": 0.00366, "epss_percentile": 0.5806}, "CVE-2024-38448": {"epss_score": 0.00243, "epss_percentile": 0.47424}, "CVE-2024-38449": {"epss_score": 0.00238, "epss_percentile": 0.46786}, "CVE-2024-38453": {"epss_score": 0.00091, "epss_percentile": 0.26216}, "CVE-2024-38454": {"epss_score": 0.0016, "epss_percentile": 0.37475}, "CVE-2024-38456": {"epss_score": 0.00062, "epss_percentile": 0.19598}, "CVE-2024-38457": {"epss_score": 0.06564, "epss_percentile": 0.9085}, "CVE-2024-38458": {"epss_score": 0.00208, "epss_percentile": 0.43302}, "CVE-2024-38459": {"epss_score": 0.00081, "epss_percentile": 0.2422}, "CVE-2024-38460": {"epss_score": 0.00184, "epss_percentile": 0.40376}, "CVE-2024-38461": {"epss_score": 0.00127, "epss_percentile": 0.32784}, "CVE-2024-38462": {"epss_score": 0.00137, "epss_percentile": 0.3434}, "CVE-2024-38465": {"epss_score": 0.00123, "epss_percentile": 0.32176}, "CVE-2024-38466": {"epss_score": 0.00152, "epss_percentile": 0.3641}, "CVE-2024-38467": {"epss_score": 0.00171, "epss_percentile": 0.38804}, "CVE-2024-38468": {"epss_score": 0.00198, "epss_percentile": 0.42094}, "CVE-2024-38469": {"epss_score": 0.00342, "epss_percentile": 0.56387}, "CVE-2024-38470": {"epss_score": 0.00643, "epss_percentile": 0.70058}, "CVE-2024-38471": {"epss_score": 0.00092, "epss_percentile": 0.26546}, "CVE-2024-38472": {"epss_score": 0.90493, "epss_percentile": 0.99587}, "CVE-2024-38473": {"epss_score": 0.88261, "epss_percentile": 0.99464}, "CVE-2024-38474": {"epss_score": 0.0059, "epss_percentile": 0.68555}, "CVE-2024-38475": {"epss_score": 0.93858, "epss_percentile": 0.99859}, "CVE-2024-38476": {"epss_score": 0.03452, "epss_percentile": 0.87166}, "CVE-2024-38477": {"epss_score": 0.01148, "epss_percentile": 0.78012}, "CVE-2024-38479": {"epss_score": 0.00778, "epss_percentile": 0.73137}, "CVE-2024-38480": {"epss_score": 0.00061, "epss_percentile": 0.19424}, "CVE-2024-38481": {"epss_score": 0.00042, "epss_percentile": 0.12896}, "CVE-2024-38482": {"epss_score": 0.00469, "epss_percentile": 0.63941}, "CVE-2024-38483": {"epss_score": 0.00039, "epss_percentile": 0.11593}, "CVE-2024-38485": {"epss_score": 0.00081, "epss_percentile": 0.24378}, "CVE-2024-38486": {"epss_score": 0.00848, "epss_percentile": 0.74367}, "CVE-2024-38488": {"epss_score": 0.001, "epss_percentile": 0.2848}, "CVE-2024-38489": {"epss_score": 0.00041, "epss_percentile": 0.12262}, "CVE-2024-38490": {"epss_score": 0.00042, "epss_percentile": 0.12896}, "CVE-2024-38491": {"epss_score": 0.00094, "epss_percentile": 0.26973}, "CVE-2024-38492": {"epss_score": 0.01567, "epss_percentile": 0.81074}, "CVE-2024-38493": {"epss_score": 0.00089, "epss_percentile": 0.25962}, "CVE-2024-38494": {"epss_score": 0.00558, "epss_percentile": 0.67582}, "CVE-2024-38495": {"epss_score": 0.00052, "epss_percentile": 0.16375}, "CVE-2024-38496": {"epss_score": 0.0005, "epss_percentile": 0.15731}, "CVE-2024-38499": {"epss_score": 0.00045, "epss_percentile": 0.13735}, "CVE-2024-38501": {"epss_score": 0.0036, "epss_percentile": 0.5763}, "CVE-2024-38502": {"epss_score": 0.00582, "epss_percentile": 0.68312}, "CVE-2024-38503": {"epss_score": 0.04381, "epss_percentile": 0.88625}, "CVE-2024-38504": {"epss_score": 7e-05, "epss_percentile": 0.00401}, "CVE-2024-38505": {"epss_score": 7e-05, "epss_percentile": 0.00352}, "CVE-2024-38506": {"epss_score": 0.00017, "epss_percentile": 0.0345}, "CVE-2024-38507": {"epss_score": 0.00219, "epss_percentile": 0.44521}, "CVE-2024-38508": {"epss_score": 0.00504, "epss_percentile": 0.65546}, "CVE-2024-38509": {"epss_score": 0.00392, "epss_percentile": 0.59643}, "CVE-2024-38510": {"epss_score": 0.00519, "epss_percentile": 0.66143}, "CVE-2024-38511": {"epss_score": 0.00477, "epss_percentile": 0.64302}, "CVE-2024-38512": {"epss_score": 0.00504, "epss_percentile": 0.65546}, "CVE-2024-38513": {"epss_score": 0.00437, "epss_percentile": 0.62503}, "CVE-2024-38514": {"epss_score": 0.72561, "epss_percentile": 0.98716}, "CVE-2024-38516": {"epss_score": 0.00293, "epss_percentile": 0.52329}, "CVE-2024-38517": {"epss_score": 0.00088, "epss_percentile": 0.25781}, "CVE-2024-38518": {"epss_score": 0.00092, "epss_percentile": 0.26515}, "CVE-2024-38519": {"epss_score": 0.00045, "epss_percentile": 0.13818}, "CVE-2024-38520": {"epss_score": 0.00056, "epss_percentile": 0.17804}, "CVE-2024-38521": {"epss_score": 0.00288, "epss_percentile": 0.51977}, "CVE-2024-38522": {"epss_score": 0.00078, "epss_percentile": 0.23787}, "CVE-2024-38523": {"epss_score": 0.00126, "epss_percentile": 0.32697}, "CVE-2024-38524": {"epss_score": 0.00063, "epss_percentile": 0.19994}, "CVE-2024-38525": {"epss_score": 0.00127, "epss_percentile": 0.32787}, "CVE-2024-38526": {"epss_score": 0.82064, "epss_percentile": 0.99171}, "CVE-2024-38527": {"epss_score": 0.00178, "epss_percentile": 0.39725}, "CVE-2024-38528": {"epss_score": 0.00165, "epss_percentile": 0.38126}, "CVE-2024-38529": {"epss_score": 0.07612, "epss_percentile": 0.91567}, "CVE-2024-38530": {"epss_score": 0.00762, "epss_percentile": 0.72842}, "CVE-2024-38531": {"epss_score": 0.00022, "epss_percentile": 0.05217}, "CVE-2024-38532": {"epss_score": 0.00162, "epss_percentile": 0.37721}, "CVE-2024-38533": {"epss_score": 0.0033, "epss_percentile": 0.55453}, "CVE-2024-38534": {"epss_score": 0.00827, "epss_percentile": 0.73977}, "CVE-2024-38535": {"epss_score": 0.01059, "epss_percentile": 0.77149}, "CVE-2024-38536": {"epss_score": 0.00766, "epss_percentile": 0.72934}, "CVE-2024-38537": {"epss_score": 0.22233, "epss_percentile": 0.95612}, "CVE-2024-38538": {"epss_score": 7e-05, "epss_percentile": 0.00463}, "CVE-2024-38539": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-38540": {"epss_score": 8e-05, "epss_percentile": 0.00593}, "CVE-2024-38541": {"epss_score": 0.00097, "epss_percentile": 0.27612}, "CVE-2024-38542": {"epss_score": 0.00018, "epss_percentile": 0.04029}, "CVE-2024-38543": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2024-38544": {"epss_score": 0.00012, "epss_percentile": 0.01128}, "CVE-2024-38545": {"epss_score": 0.00013, "epss_percentile": 0.01534}, "CVE-2024-38546": {"epss_score": 0.00018, "epss_percentile": 0.03616}, "CVE-2024-38547": {"epss_score": 0.0001, "epss_percentile": 0.00826}, "CVE-2024-38548": {"epss_score": 0.00018, "epss_percentile": 0.03616}, "CVE-2024-38549": {"epss_score": 0.00016, "epss_percentile": 0.02861}, "CVE-2024-38550": {"epss_score": 0.00024, "epss_percentile": 0.05692}, "CVE-2024-38551": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-38552": {"epss_score": 0.00013, "epss_percentile": 0.01694}, "CVE-2024-38553": {"epss_score": 7e-05, "epss_percentile": 0.00443}, "CVE-2024-38554": {"epss_score": 0.0002, "epss_percentile": 0.04447}, "CVE-2024-38555": {"epss_score": 0.00013, "epss_percentile": 0.01513}, "CVE-2024-38556": {"epss_score": 0.00031, "epss_percentile": 0.08409}, "CVE-2024-38557": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-38558": {"epss_score": 0.00011, "epss_percentile": 0.01049}, "CVE-2024-38559": {"epss_score": 9e-05, "epss_percentile": 0.00617}, "CVE-2024-38560": {"epss_score": 7e-05, "epss_percentile": 0.00456}, "CVE-2024-38561": {"epss_score": 0.00051, "epss_percentile": 0.16033}, "CVE-2024-38562": {"epss_score": 0.00016, "epss_percentile": 0.0279}, "CVE-2024-38563": {"epss_score": 0.00015, "epss_percentile": 0.02425}, "CVE-2024-38564": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-38565": {"epss_score": 0.00034, "epss_percentile": 0.09658}, "CVE-2024-38566": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-38567": {"epss_score": 0.00011, "epss_percentile": 0.00955}, "CVE-2024-38568": {"epss_score": 0.00038, "epss_percentile": 0.11205}, "CVE-2024-38569": {"epss_score": 0.00038, "epss_percentile": 0.11205}, "CVE-2024-38570": {"epss_score": 0.00012, "epss_percentile": 0.01223}, "CVE-2024-38571": {"epss_score": 8e-05, "epss_percentile": 0.0059}, "CVE-2024-38572": {"epss_score": 0.00036, "epss_percentile": 0.10305}, "CVE-2024-38573": {"epss_score": 0.0004, "epss_percentile": 0.12195}, "CVE-2024-38574": {"epss_score": 0.00026, "epss_percentile": 0.06456}, "CVE-2024-38575": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2024-38576": {"epss_score": 0.00119, "epss_percentile": 0.31678}, "CVE-2024-38577": {"epss_score": 0.00012, "epss_percentile": 0.01328}, "CVE-2024-38578": {"epss_score": 0.00015, "epss_percentile": 0.0213}, "CVE-2024-38579": {"epss_score": 0.0001, "epss_percentile": 0.00807}, "CVE-2024-38580": {"epss_score": 0.00016, "epss_percentile": 0.02777}, "CVE-2024-38581": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-38582": {"epss_score": 0.00108, "epss_percentile": 0.29835}, "CVE-2024-38583": {"epss_score": 0.00011, "epss_percentile": 0.00983}, "CVE-2024-38584": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-38585": {"epss_score": 0.00064, "epss_percentile": 0.20105}, "CVE-2024-38586": {"epss_score": 0.00012, "epss_percentile": 0.01231}, "CVE-2024-38587": {"epss_score": 0.00172, "epss_percentile": 0.38978}, "CVE-2024-38588": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2024-38589": {"epss_score": 8e-05, "epss_percentile": 0.00567}, "CVE-2024-38590": {"epss_score": 0.0001, "epss_percentile": 0.0076}, "CVE-2024-38591": {"epss_score": 5e-05, "epss_percentile": 0.00236}, "CVE-2024-38592": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-38593": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-38594": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-38595": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-38596": {"epss_score": 0.00014, "epss_percentile": 0.01866}, "CVE-2024-38597": {"epss_score": 0.00014, "epss_percentile": 0.01754}, "CVE-2024-38598": {"epss_score": 0.00015, "epss_percentile": 0.02341}, "CVE-2024-38599": {"epss_score": 0.00012, "epss_percentile": 0.01348}, "CVE-2024-38600": {"epss_score": 0.00014, "epss_percentile": 0.02102}, "CVE-2024-38601": {"epss_score": 0.00014, "epss_percentile": 0.01866}, "CVE-2024-38602": {"epss_score": 0.00018, "epss_percentile": 0.03941}, "CVE-2024-38603": {"epss_score": 0.00035, "epss_percentile": 0.09826}, "CVE-2024-38604": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-38605": {"epss_score": 0.00178, "epss_percentile": 0.39738}, "CVE-2024-38606": {"epss_score": 0.00017, "epss_percentile": 0.03146}, "CVE-2024-38607": {"epss_score": 0.00018, "epss_percentile": 0.0367}, "CVE-2024-38608": {"epss_score": 0.00013, "epss_percentile": 0.01633}, "CVE-2024-38609": {"epss_score": 0.00026, "epss_percentile": 0.06657}, "CVE-2024-38610": {"epss_score": 0.00035, "epss_percentile": 0.1014}, "CVE-2024-38611": {"epss_score": 0.00019, "epss_percentile": 0.0427}, "CVE-2024-38612": {"epss_score": 0.00165, "epss_percentile": 0.38062}, "CVE-2024-38613": {"epss_score": 0.00021, "epss_percentile": 0.0483}, "CVE-2024-38614": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-38615": {"epss_score": 0.00017, "epss_percentile": 0.03122}, "CVE-2024-38616": {"epss_score": 0.00242, "epss_percentile": 0.47381}, "CVE-2024-38617": {"epss_score": 0.00047, "epss_percentile": 0.14663}, "CVE-2024-38618": {"epss_score": 0.00091, "epss_percentile": 0.26252}, "CVE-2024-38619": {"epss_score": 0.00018, "epss_percentile": 0.03684}, "CVE-2024-38620": {"epss_score": 0.00047, "epss_percentile": 0.14873}, "CVE-2024-38621": {"epss_score": 0.00013, "epss_percentile": 0.01675}, "CVE-2024-38622": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-38623": {"epss_score": 0.00248, "epss_percentile": 0.47977}, "CVE-2024-38624": {"epss_score": 0.00034, "epss_percentile": 0.09706}, "CVE-2024-38625": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-38626": {"epss_score": 0.00048, "epss_percentile": 0.15001}, "CVE-2024-38627": {"epss_score": 0.0002, "epss_percentile": 0.04429}, "CVE-2024-38628": {"epss_score": 0.00015, "epss_percentile": 0.02295}, "CVE-2024-38629": {"epss_score": 0.00029, "epss_percentile": 0.07771}, "CVE-2024-38630": {"epss_score": 0.00023, "epss_percentile": 0.05516}, "CVE-2024-38631": {"epss_score": 0.00032, "epss_percentile": 0.09071}, "CVE-2024-38632": {"epss_score": 0.00013, "epss_percentile": 0.01472}, "CVE-2024-38633": {"epss_score": 0.00018, "epss_percentile": 0.0367}, "CVE-2024-38634": {"epss_score": 0.00021, "epss_percentile": 0.0483}, "CVE-2024-38635": {"epss_score": 0.00021, "epss_percentile": 0.04695}, "CVE-2024-38636": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-38637": {"epss_score": 0.00027, "epss_percentile": 0.06939}, "CVE-2024-38638": {"epss_score": 0.00151, "epss_percentile": 0.36224}, "CVE-2024-38640": {"epss_score": 0.00765, "epss_percentile": 0.72929}, "CVE-2024-38641": {"epss_score": 0.00323, "epss_percentile": 0.54866}, "CVE-2024-38642": {"epss_score": 0.00057, "epss_percentile": 0.18196}, "CVE-2024-38643": {"epss_score": 0.01914, "epss_percentile": 0.82846}, "CVE-2024-38644": {"epss_score": 0.02048, "epss_percentile": 0.83391}, "CVE-2024-38645": {"epss_score": 0.00203, "epss_percentile": 0.42559}, "CVE-2024-38646": {"epss_score": 0.00041, "epss_percentile": 0.12225}, "CVE-2024-38647": {"epss_score": 0.0022, "epss_percentile": 0.44629}, "CVE-2024-38648": {"epss_score": 0.00036, "epss_percentile": 0.10243}, "CVE-2024-38649": {"epss_score": 0.05755, "epss_percentile": 0.9018}, "CVE-2024-38650": {"epss_score": 0.00171, "epss_percentile": 0.38887}, "CVE-2024-38651": {"epss_score": 0.03054, "epss_percentile": 0.86294}, "CVE-2024-38652": {"epss_score": 0.12441, "epss_percentile": 0.93672}, "CVE-2024-38653": {"epss_score": 0.89594, "epss_percentile": 0.99533}, "CVE-2024-38654": {"epss_score": 0.00057, "epss_percentile": 0.18227}, "CVE-2024-38655": {"epss_score": 0.17203, "epss_percentile": 0.94799}, "CVE-2024-38656": {"epss_score": 0.13426, "epss_percentile": 0.9396}, "CVE-2024-38657": {"epss_score": 0.0019, "epss_percentile": 0.41134}, "CVE-2024-38658": {"epss_score": 0.00017, "epss_percentile": 0.03218}, "CVE-2024-38659": {"epss_score": 0.00019, "epss_percentile": 0.04114}, "CVE-2024-38660": {"epss_score": 0.00077, "epss_percentile": 0.23416}, "CVE-2024-38661": {"epss_score": 0.00018, "epss_percentile": 0.03808}, "CVE-2024-38662": {"epss_score": 0.00036, "epss_percentile": 0.10487}, "CVE-2024-38663": {"epss_score": 0.00017, "epss_percentile": 0.03169}, "CVE-2024-38664": {"epss_score": 0.0002, "epss_percentile": 0.04563}, "CVE-2024-38665": {"epss_score": 0.00071, "epss_percentile": 0.22035}, "CVE-2024-38666": {"epss_score": 0.01751, "epss_percentile": 0.82099}, "CVE-2024-38667": {"epss_score": 0.00034, "epss_percentile": 0.09621}, "CVE-2024-38668": {"epss_score": 0.00094, "epss_percentile": 0.26983}, "CVE-2024-38669": {"epss_score": 0.00128, "epss_percentile": 0.32985}, "CVE-2024-38670": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-38671": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-38672": {"epss_score": 0.00165, "epss_percentile": 0.38081}, "CVE-2024-38673": {"epss_score": 0.001, "epss_percentile": 0.28531}, "CVE-2024-38674": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2024-38675": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-38676": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-38677": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-38678": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-38679": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-38680": {"epss_score": 0.001, "epss_percentile": 0.28531}, "CVE-2024-38681": {"epss_score": 0.00084, "epss_percentile": 0.24938}, "CVE-2024-38682": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-38683": {"epss_score": 0.00165, "epss_percentile": 0.38081}, "CVE-2024-38684": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-38685": {"epss_score": 0.00064, "epss_percentile": 0.20283}, "CVE-2024-38686": {"epss_score": 0.00092, "epss_percentile": 0.26479}, "CVE-2024-38687": {"epss_score": 0.00092, "epss_percentile": 0.26498}, "CVE-2024-38689": {"epss_score": 0.00078, "epss_percentile": 0.23612}, "CVE-2024-38690": {"epss_score": 0.00209, "epss_percentile": 0.43327}, "CVE-2024-38691": {"epss_score": 0.00073, "epss_percentile": 0.22655}, "CVE-2024-38692": {"epss_score": 0.05316, "epss_percentile": 0.89722}, "CVE-2024-38693": {"epss_score": 0.00556, "epss_percentile": 0.67516}, "CVE-2024-38694": {"epss_score": 0.00185, "epss_percentile": 0.40545}, "CVE-2024-38695": {"epss_score": 0.00187, "epss_percentile": 0.4072}, "CVE-2024-38696": {"epss_score": 0.00305, "epss_percentile": 0.53334}, "CVE-2024-38697": {"epss_score": 0.0017, "epss_percentile": 0.3866}, "CVE-2024-38698": {"epss_score": 0.0017, "epss_percentile": 0.3866}, "CVE-2024-38699": {"epss_score": 0.0103, "epss_percentile": 0.76847}, "CVE-2024-38700": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2024-38701": {"epss_score": 0.00059, "epss_percentile": 0.18783}, "CVE-2024-38702": {"epss_score": 0.00179, "epss_percentile": 0.39771}, "CVE-2024-38703": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-38704": {"epss_score": 0.01204, "epss_percentile": 0.78501}, "CVE-2024-38705": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-38706": {"epss_score": 0.01235, "epss_percentile": 0.78766}, "CVE-2024-38707": {"epss_score": 0.0017, "epss_percentile": 0.38677}, "CVE-2024-38708": {"epss_score": 0.00518, "epss_percentile": 0.6613}, "CVE-2024-38709": {"epss_score": 0.00784, "epss_percentile": 0.73243}, "CVE-2024-38710": {"epss_score": 0.00116, "epss_percentile": 0.31184}, "CVE-2024-38711": {"epss_score": 0.00373, "epss_percentile": 0.58524}, "CVE-2024-38712": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-38713": {"epss_score": 0.0017, "epss_percentile": 0.38749}, "CVE-2024-38714": {"epss_score": 0.00187, "epss_percentile": 0.4072}, "CVE-2024-38715": {"epss_score": 0.01627, "epss_percentile": 0.8143}, "CVE-2024-38716": {"epss_score": 0.01708, "epss_percentile": 0.81864}, "CVE-2024-38717": {"epss_score": 0.01231, "epss_percentile": 0.78733}, "CVE-2024-38718": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-38719": {"epss_score": 0.00187, "epss_percentile": 0.4072}, "CVE-2024-38720": {"epss_score": 0.0017, "epss_percentile": 0.3866}, "CVE-2024-38721": {"epss_score": 0.0027, "epss_percentile": 0.50193}, "CVE-2024-38722": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-38723": {"epss_score": 0.00144, "epss_percentile": 0.35339}, "CVE-2024-38724": {"epss_score": 0.00194, "epss_percentile": 0.41524}, "CVE-2024-38725": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-38726": {"epss_score": 0.0015, "epss_percentile": 0.36074}, "CVE-2024-38727": {"epss_score": 0.00187, "epss_percentile": 0.4072}, "CVE-2024-38728": {"epss_score": 0.00274, "epss_percentile": 0.50519}, "CVE-2024-38729": {"epss_score": 0.0004, "epss_percentile": 0.12088}, "CVE-2024-38730": {"epss_score": 0.00144, "epss_percentile": 0.35339}, "CVE-2024-38731": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-38732": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-38733": {"epss_score": 0.00105, "epss_percentile": 0.29316}, "CVE-2024-38734": {"epss_score": 0.01224, "epss_percentile": 0.78677}, "CVE-2024-38735": {"epss_score": 0.02152, "epss_percentile": 0.83793}, "CVE-2024-38736": {"epss_score": 0.00951, "epss_percentile": 0.75869}, "CVE-2024-38737": {"epss_score": 0.00137, "epss_percentile": 0.34322}, "CVE-2024-38738": {"epss_score": 0.00118, "epss_percentile": 0.31452}, "CVE-2024-38739": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-38740": {"epss_score": 0.00105, "epss_percentile": 0.29316}, "CVE-2024-38741": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-38742": {"epss_score": 0.00422, "epss_percentile": 0.6155}, "CVE-2024-38743": {"epss_score": 0.00201, "epss_percentile": 0.42335}, "CVE-2024-38744": {"epss_score": 0.00188, "epss_percentile": 0.40915}, "CVE-2024-38745": {"epss_score": 0.00275, "epss_percentile": 0.50677}, "CVE-2024-38746": {"epss_score": 0.00792, "epss_percentile": 0.73413}, "CVE-2024-38747": {"epss_score": 0.00915, "epss_percentile": 0.75395}, "CVE-2024-38748": {"epss_score": 0.00464, "epss_percentile": 0.63731}, "CVE-2024-38749": {"epss_score": 0.00798, "epss_percentile": 0.73517}, "CVE-2024-38750": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-38751": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-38752": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2024-38753": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-38754": {"epss_score": 0.0004, "epss_percentile": 0.12112}, "CVE-2024-38755": {"epss_score": 0.05598, "epss_percentile": 0.90035}, "CVE-2024-38756": {"epss_score": 0.00443, "epss_percentile": 0.6279}, "CVE-2024-38757": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-38758": {"epss_score": 0.00144, "epss_percentile": 0.35339}, "CVE-2024-38759": {"epss_score": 0.00385, "epss_percentile": 0.59212}, "CVE-2024-38760": {"epss_score": 0.00422, "epss_percentile": 0.6155}, "CVE-2024-38761": {"epss_score": 0.00975, "epss_percentile": 0.762}, "CVE-2024-38762": {"epss_score": 0.00064, "epss_percentile": 0.20362}, "CVE-2024-38763": {"epss_score": 0.00064, "epss_percentile": 0.20378}, "CVE-2024-38764": {"epss_score": 0.00105, "epss_percentile": 0.29367}, "CVE-2024-38765": {"epss_score": 0.00105, "epss_percentile": 0.29367}, "CVE-2024-38766": {"epss_score": 0.00105, "epss_percentile": 0.29367}, "CVE-2024-38767": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-38768": {"epss_score": 0.01593, "epss_percentile": 0.81226}, "CVE-2024-38769": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-38770": {"epss_score": 0.00136, "epss_percentile": 0.34171}, "CVE-2024-38771": {"epss_score": 0.00124, "epss_percentile": 0.32451}, "CVE-2024-38772": {"epss_score": 0.01627, "epss_percentile": 0.8143}, "CVE-2024-38773": {"epss_score": 0.00288, "epss_percentile": 0.51951}, "CVE-2024-38774": {"epss_score": 0.0009, "epss_percentile": 0.2616}, "CVE-2024-38775": {"epss_score": 0.00219, "epss_percentile": 0.44502}, "CVE-2024-38776": {"epss_score": 0.00184, "epss_percentile": 0.40429}, "CVE-2024-38777": {"epss_score": 0.00379, "epss_percentile": 0.5888}, "CVE-2024-38778": {"epss_score": 0.00064, "epss_percentile": 0.20378}, "CVE-2024-38780": {"epss_score": 0.00014, "epss_percentile": 0.01866}, "CVE-2024-38781": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-38782": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-38783": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-38784": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-38785": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-38786": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-38787": {"epss_score": 0.01494, "epss_percentile": 0.80648}, "CVE-2024-38788": {"epss_score": 0.03323, "epss_percentile": 0.86915}, "CVE-2024-38789": {"epss_score": 0.00065, "epss_percentile": 0.20649}, "CVE-2024-38790": {"epss_score": 0.00064, "epss_percentile": 0.2038}, "CVE-2024-38791": {"epss_score": 0.0046, "epss_percentile": 0.63513}, "CVE-2024-38792": {"epss_score": 0.00234, "epss_percentile": 0.46106}, "CVE-2024-38793": {"epss_score": 0.40289, "epss_percentile": 0.97211}, "CVE-2024-38794": {"epss_score": 0.00209, "epss_percentile": 0.43327}, "CVE-2024-38795": {"epss_score": 0.00433, "epss_percentile": 0.62182}, "CVE-2024-38796": {"epss_score": 0.00049, "epss_percentile": 0.1565}, "CVE-2024-38797": {"epss_score": 0.00036, "epss_percentile": 0.10621}, "CVE-2024-38798": {"epss_score": 0.00024, "epss_percentile": 0.05672}, "CVE-2024-38805": {"epss_score": 0.00029, "epss_percentile": 0.07618}, "CVE-2024-38806": {"epss_score": 0.00031, "epss_percentile": 0.08333}, "CVE-2024-38807": {"epss_score": 0.00028, "epss_percentile": 0.07505}, "CVE-2024-38808": {"epss_score": 0.00809, "epss_percentile": 0.73711}, "CVE-2024-38809": {"epss_score": 0.00107, "epss_percentile": 0.29609}, "CVE-2024-38810": {"epss_score": 0.00672, "epss_percentile": 0.70809}, "CVE-2024-38811": {"epss_score": 0.00094, "epss_percentile": 0.26993}, "CVE-2024-38812": {"epss_score": 0.79504, "epss_percentile": 0.99042}, "CVE-2024-38813": {"epss_score": 0.29526, "epss_percentile": 0.9645}, "CVE-2024-38814": {"epss_score": 0.26077, "epss_percentile": 0.96108}, "CVE-2024-38815": {"epss_score": 0.00356, "epss_percentile": 0.57386}, "CVE-2024-38816": {"epss_score": 0.93866, "epss_percentile": 0.9986}, "CVE-2024-38817": {"epss_score": 0.00065, "epss_percentile": 0.20444}, "CVE-2024-38818": {"epss_score": 0.00101, "epss_percentile": 0.28571}, "CVE-2024-38819": {"epss_score": 0.71765, "epss_percentile": 0.98679}, "CVE-2024-38820": {"epss_score": 0.00832, "epss_percentile": 0.74064}, "CVE-2024-38821": {"epss_score": 0.10078, "epss_percentile": 0.92841}, "CVE-2024-38822": {"epss_score": 0.00049, "epss_percentile": 0.15315}, "CVE-2024-38823": {"epss_score": 0.00049, "epss_percentile": 0.15315}, "CVE-2024-38824": {"epss_score": 0.00122, "epss_percentile": 0.32062}, "CVE-2024-38825": {"epss_score": 0.00042, "epss_percentile": 0.12813}, "CVE-2024-38826": {"epss_score": 0.00123, "epss_percentile": 0.32213}, "CVE-2024-38827": {"epss_score": 0.00307, "epss_percentile": 0.53534}, "CVE-2024-38828": {"epss_score": 0.00058, "epss_percentile": 0.18383}, "CVE-2024-38829": {"epss_score": 0.00102, "epss_percentile": 0.28876}, "CVE-2024-38830": {"epss_score": 0.00067, "epss_percentile": 0.21032}, "CVE-2024-38831": {"epss_score": 0.00114, "epss_percentile": 0.30868}, "CVE-2024-38832": {"epss_score": 0.00251, "epss_percentile": 0.48269}, "CVE-2024-38833": {"epss_score": 0.00167, "epss_percentile": 0.38274}, "CVE-2024-38834": {"epss_score": 0.00366, "epss_percentile": 0.58089}, "CVE-2024-38856": {"epss_score": 0.94375, "epss_percentile": 0.99962}, "CVE-2024-38857": {"epss_score": 0.00778, "epss_percentile": 0.73128}, "CVE-2024-38858": {"epss_score": 0.00905, "epss_percentile": 0.75233}, "CVE-2024-38859": {"epss_score": 0.01334, "epss_percentile": 0.79542}, "CVE-2024-38860": {"epss_score": 0.00892, "epss_percentile": 0.75062}, "CVE-2024-38861": {"epss_score": 0.00222, "epss_percentile": 0.44803}, "CVE-2024-38862": {"epss_score": 0.00153, "epss_percentile": 0.36547}, "CVE-2024-38863": {"epss_score": 0.00196, "epss_percentile": 0.41759}, "CVE-2024-38864": {"epss_score": 0.00024, "epss_percentile": 0.05775}, "CVE-2024-38865": {"epss_score": 0.00246, "epss_percentile": 0.47738}, "CVE-2024-38866": {"epss_score": 0.00062, "epss_percentile": 0.19736}, "CVE-2024-38867": {"epss_score": 0.00105, "epss_percentile": 0.29251}, "CVE-2024-38868": {"epss_score": 0.00134, "epss_percentile": 0.33912}, "CVE-2024-38869": {"epss_score": 0.00032, "epss_percentile": 0.09097}, "CVE-2024-38870": {"epss_score": 0.00063, "epss_percentile": 0.19826}, "CVE-2024-38871": {"epss_score": 0.00738, "epss_percentile": 0.72339}, "CVE-2024-38872": {"epss_score": 0.00738, "epss_percentile": 0.72339}, "CVE-2024-38873": {"epss_score": 0.00156, "epss_percentile": 0.37}, "CVE-2024-38874": {"epss_score": 0.00412, "epss_percentile": 0.60913}, "CVE-2024-38875": {"epss_score": 0.0033, "epss_percentile": 0.55434}, "CVE-2024-38876": {"epss_score": 0.00164, "epss_percentile": 0.37943}, "CVE-2024-38877": {"epss_score": 0.00068, "epss_percentile": 0.21396}, "CVE-2024-38878": {"epss_score": 0.08948, "epss_percentile": 0.92333}, "CVE-2024-38879": {"epss_score": 0.01313, "epss_percentile": 0.79383}, "CVE-2024-38881": {"epss_score": 0.00259, "epss_percentile": 0.49087}, "CVE-2024-38882": {"epss_score": 0.06596, "epss_percentile": 0.90876}, "CVE-2024-38883": {"epss_score": 0.00172, "epss_percentile": 0.38997}, "CVE-2024-38884": {"epss_score": 0.00021, "epss_percentile": 0.04802}, "CVE-2024-38885": {"epss_score": 0.00178, "epss_percentile": 0.3967}, "CVE-2024-38886": {"epss_score": 0.00862, "epss_percentile": 0.74577}, "CVE-2024-38887": {"epss_score": 0.04237, "epss_percentile": 0.8843}, "CVE-2024-38888": {"epss_score": 0.00038, "epss_percentile": 0.11397}, "CVE-2024-38889": {"epss_score": 0.00331, "epss_percentile": 0.55515}, "CVE-2024-38890": {"epss_score": 0.0002, "epss_percentile": 0.04502}, "CVE-2024-38891": {"epss_score": 0.00079, "epss_percentile": 0.23889}, "CVE-2024-38892": {"epss_score": 0.0011, "epss_percentile": 0.30209}, "CVE-2024-38894": {"epss_score": 0.02096, "epss_percentile": 0.83588}, "CVE-2024-38895": {"epss_score": 0.00143, "epss_percentile": 0.35112}, "CVE-2024-38896": {"epss_score": 0.04467, "epss_percentile": 0.8873}, "CVE-2024-38897": {"epss_score": 0.00314, "epss_percentile": 0.54127}, "CVE-2024-38902": {"epss_score": 0.0033, "epss_percentile": 0.55462}, "CVE-2024-38903": {"epss_score": 0.00264, "epss_percentile": 0.49711}, "CVE-2024-38909": {"epss_score": 0.00255, "epss_percentile": 0.48635}, "CVE-2024-38910": {"epss_score": 0.00254, "epss_percentile": 0.48623}, "CVE-2024-38920": {"epss_score": 0.00254, "epss_percentile": 0.48623}, "CVE-2024-38921": {"epss_score": 0.00254, "epss_percentile": 0.48549}, "CVE-2024-38922": {"epss_score": 0.0025, "epss_percentile": 0.48139}, "CVE-2024-38923": {"epss_score": 0.00195, "epss_percentile": 0.41681}, "CVE-2024-38924": {"epss_score": 0.00195, "epss_percentile": 0.41681}, "CVE-2024-38925": {"epss_score": 0.00254, "epss_percentile": 0.48549}, "CVE-2024-38926": {"epss_score": 0.00254, "epss_percentile": 0.48549}, "CVE-2024-38927": {"epss_score": 0.00254, "epss_percentile": 0.48549}, "CVE-2024-38944": {"epss_score": 0.10037, "epss_percentile": 0.92824}, "CVE-2024-38949": {"epss_score": 0.00101, "epss_percentile": 0.28576}, "CVE-2024-38950": {"epss_score": 0.00203, "epss_percentile": 0.42511}, "CVE-2024-38951": {"epss_score": 0.00178, "epss_percentile": 0.39705}, "CVE-2024-38952": {"epss_score": 0.0044, "epss_percentile": 0.62628}, "CVE-2024-38953": {"epss_score": 0.00155, "epss_percentile": 0.36785}, "CVE-2024-38959": {"epss_score": 0.009, "epss_percentile": 0.75165}, "CVE-2024-38963": {"epss_score": 0.01146, "epss_percentile": 0.77995}, "CVE-2024-38970": {"epss_score": 0.00216, "epss_percentile": 0.44186}, "CVE-2024-38971": {"epss_score": 0.00242, "epss_percentile": 0.47342}, "CVE-2024-38972": {"epss_score": 0.00308, "epss_percentile": 0.53597}, "CVE-2024-38983": {"epss_score": 0.00158, "epss_percentile": 0.37162}, "CVE-2024-38984": {"epss_score": 0.00179, "epss_percentile": 0.39797}, "CVE-2024-38985": {"epss_score": 0.00402, "epss_percentile": 0.60301}, "CVE-2024-38986": {"epss_score": 0.00326, "epss_percentile": 0.55047}, "CVE-2024-38987": {"epss_score": 0.0027, "epss_percentile": 0.50242}, "CVE-2024-38988": {"epss_score": 0.0013, "epss_percentile": 0.3328}, "CVE-2024-38989": {"epss_score": 0.00181, "epss_percentile": 0.40104}, "CVE-2024-38990": {"epss_score": 0.00174, "epss_percentile": 0.3914}, "CVE-2024-38991": {"epss_score": 0.00283, "epss_percentile": 0.51348}, "CVE-2024-38992": {"epss_score": 0.00283, "epss_percentile": 0.51348}, "CVE-2024-38993": {"epss_score": 0.00478, "epss_percentile": 0.64378}, "CVE-2024-38994": {"epss_score": 0.00296, "epss_percentile": 0.52581}, "CVE-2024-38996": {"epss_score": 0.00558, "epss_percentile": 0.67581}, "CVE-2024-38997": {"epss_score": 0.00536, "epss_percentile": 0.66857}, "CVE-2024-38999": {"epss_score": 0.00283, "epss_percentile": 0.51375}, "CVE-2024-39000": {"epss_score": 0.00377, "epss_percentile": 0.58732}, "CVE-2024-39001": {"epss_score": 0.00264, "epss_percentile": 0.49723}, "CVE-2024-39002": {"epss_score": 0.00117, "epss_percentile": 0.31288}, "CVE-2024-39003": {"epss_score": 0.0008, "epss_percentile": 0.24027}, "CVE-2024-39008": {"epss_score": 0.00214, "epss_percentile": 0.43976}, "CVE-2024-39010": {"epss_score": 0.00442, "epss_percentile": 0.62726}, "CVE-2024-39011": {"epss_score": 0.00442, "epss_percentile": 0.62726}, "CVE-2024-39012": {"epss_score": 0.00158, "epss_percentile": 0.37162}, "CVE-2024-39013": {"epss_score": 0.00132, "epss_percentile": 0.33523}, "CVE-2024-39014": {"epss_score": 0.00464, "epss_percentile": 0.63729}, "CVE-2024-39015": {"epss_score": 0.00478, "epss_percentile": 0.64378}, "CVE-2024-39016": {"epss_score": 0.00442, "epss_percentile": 0.62726}, "CVE-2024-39017": {"epss_score": 0.00478, "epss_percentile": 0.64378}, "CVE-2024-39018": {"epss_score": 0.00349, "epss_percentile": 0.56894}, "CVE-2024-39019": {"epss_score": 0.00132, "epss_percentile": 0.33598}, "CVE-2024-39020": {"epss_score": 0.00095, "epss_percentile": 0.27232}, "CVE-2024-39021": {"epss_score": 0.00123, "epss_percentile": 0.32336}, "CVE-2024-39022": {"epss_score": 0.00152, "epss_percentile": 0.36463}, "CVE-2024-39023": {"epss_score": 0.00152, "epss_percentile": 0.36463}, "CVE-2024-39025": {"epss_score": 0.00159, "epss_percentile": 0.37333}, "CVE-2024-39027": {"epss_score": 0.00107, "epss_percentile": 0.2959}, "CVE-2024-39028": {"epss_score": 0.02656, "epss_percentile": 0.85358}, "CVE-2024-39031": {"epss_score": 0.06742, "epss_percentile": 0.90996}, "CVE-2024-39033": {"epss_score": 0.00146, "epss_percentile": 0.35612}, "CVE-2024-39036": {"epss_score": 0.0048, "epss_percentile": 0.64463}, "CVE-2024-39037": {"epss_score": 0.00041, "epss_percentile": 0.12402}, "CVE-2024-39063": {"epss_score": 0.00235, "epss_percentile": 0.46211}, "CVE-2024-39069": {"epss_score": 0.03366, "epss_percentile": 0.87004}, "CVE-2024-39071": {"epss_score": 0.00154, "epss_percentile": 0.36719}, "CVE-2024-39072": {"epss_score": 0.00177, "epss_percentile": 0.39547}, "CVE-2024-39081": {"epss_score": 0.02114, "epss_percentile": 0.83655}, "CVE-2024-39090": {"epss_score": 0.03081, "epss_percentile": 0.86374}, "CVE-2024-39091": {"epss_score": 0.00542, "epss_percentile": 0.67069}, "CVE-2024-39094": {"epss_score": 0.00261, "epss_percentile": 0.49301}, "CVE-2024-39097": {"epss_score": 0.00315, "epss_percentile": 0.54188}, "CVE-2024-39118": {"epss_score": 0.00111, "epss_percentile": 0.30287}, "CVE-2024-39119": {"epss_score": 0.00172, "epss_percentile": 0.38928}, "CVE-2024-39123": {"epss_score": 0.27116, "epss_percentile": 0.96209}, "CVE-2024-39124": {"epss_score": 0.00729, "epss_percentile": 0.72133}, "CVE-2024-39125": {"epss_score": 0.00729, "epss_percentile": 0.72133}, "CVE-2024-39126": {"epss_score": 0.00927, "epss_percentile": 0.75569}, "CVE-2024-39129": {"epss_score": 0.00225, "epss_percentile": 0.45134}, "CVE-2024-39130": {"epss_score": 0.00266, "epss_percentile": 0.49895}, "CVE-2024-39132": {"epss_score": 0.00127, "epss_percentile": 0.32851}, "CVE-2024-39133": {"epss_score": 0.00212, "epss_percentile": 0.43799}, "CVE-2024-39134": {"epss_score": 0.00322, "epss_percentile": 0.54857}, "CVE-2024-39143": {"epss_score": 0.00377, "epss_percentile": 0.58713}, "CVE-2024-39148": {"epss_score": 0.0016, "epss_percentile": 0.37481}, "CVE-2024-39150": {"epss_score": 0.00171, "epss_percentile": 0.38804}, "CVE-2024-39153": {"epss_score": 0.00061, "epss_percentile": 0.1944}, "CVE-2024-39154": {"epss_score": 0.0014, "epss_percentile": 0.34717}, "CVE-2024-39155": {"epss_score": 0.00097, "epss_percentile": 0.27456}, "CVE-2024-39156": {"epss_score": 0.00085, "epss_percentile": 0.25063}, "CVE-2024-39157": {"epss_score": 0.00085, "epss_percentile": 0.25063}, "CVE-2024-39158": {"epss_score": 0.00152, "epss_percentile": 0.36463}, "CVE-2024-39162": {"epss_score": 0.00077, "epss_percentile": 0.23435}, "CVE-2024-39163": {"epss_score": 0.00121, "epss_percentile": 0.31918}, "CVE-2024-39165": {"epss_score": 0.07211, "epss_percentile": 0.91328}, "CVE-2024-39171": {"epss_score": 0.00958, "epss_percentile": 0.75941}, "CVE-2024-39173": {"epss_score": 0.02884, "epss_percentile": 0.85909}, "CVE-2024-39174": {"epss_score": 0.00155, "epss_percentile": 0.36785}, "CVE-2024-39178": {"epss_score": 0.00227, "epss_percentile": 0.45452}, "CVE-2024-39181": {"epss_score": 0.00226, "epss_percentile": 0.45274}, "CVE-2024-39182": {"epss_score": 0.00171, "epss_percentile": 0.38804}, "CVE-2024-39202": {"epss_score": 0.0263, "epss_percentile": 0.85278}, "CVE-2024-39203": {"epss_score": 0.08283, "epss_percentile": 0.91968}, "CVE-2024-39205": {"epss_score": 0.80864, "epss_percentile": 0.99111}, "CVE-2024-39206": {"epss_score": 0.00119, "epss_percentile": 0.31553}, "CVE-2024-39207": {"epss_score": 0.00092, "epss_percentile": 0.26521}, "CVE-2024-39208": {"epss_score": 0.00112, "epss_percentile": 0.30575}, "CVE-2024-39209": {"epss_score": 0.00342, "epss_percentile": 0.56357}, "CVE-2024-39210": {"epss_score": 0.07672, "epss_percentile": 0.91616}, "CVE-2024-39211": {"epss_score": 0.0348, "epss_percentile": 0.87218}, "CVE-2024-39219": {"epss_score": 0.00206, "epss_percentile": 0.43075}, "CVE-2024-39220": {"epss_score": 0.00068, "epss_percentile": 0.21293}, "CVE-2024-39223": {"epss_score": 0.00048, "epss_percentile": 0.15161}, "CVE-2024-39225": {"epss_score": 0.32463, "epss_percentile": 0.96702}, "CVE-2024-39226": {"epss_score": 0.1364, "epss_percentile": 0.94019}, "CVE-2024-39227": {"epss_score": 0.01089, "epss_percentile": 0.77445}, "CVE-2024-39228": {"epss_score": 0.00191, "epss_percentile": 0.41272}, "CVE-2024-39229": {"epss_score": 0.00092, "epss_percentile": 0.26458}, "CVE-2024-39236": {"epss_score": 0.01813, "epss_percentile": 0.82376}, "CVE-2024-39241": {"epss_score": 0.00166, "epss_percentile": 0.38248}, "CVE-2024-39242": {"epss_score": 0.00175, "epss_percentile": 0.39306}, "CVE-2024-39243": {"epss_score": 0.00191, "epss_percentile": 0.41272}, "CVE-2024-39248": {"epss_score": 0.01537, "epss_percentile": 0.80924}, "CVE-2024-39249": {"epss_score": 0.00161, "epss_percentile": 0.37565}, "CVE-2024-39250": {"epss_score": 0.875, "epss_percentile": 0.99431}, "CVE-2024-39251": {"epss_score": 0.00144, "epss_percentile": 0.35265}, "CVE-2024-39271": {"epss_score": 0.00033, "epss_percentile": 0.09421}, "CVE-2024-39272": {"epss_score": 0.00347, "epss_percentile": 0.5676}, "CVE-2024-39273": {"epss_score": 0.00087, "epss_percentile": 0.25538}, "CVE-2024-39274": {"epss_score": 0.00211, "epss_percentile": 0.43702}, "CVE-2024-39275": {"epss_score": 0.00089, "epss_percentile": 0.25985}, "CVE-2024-39276": {"epss_score": 0.00012, "epss_percentile": 0.01166}, "CVE-2024-39277": {"epss_score": 0.00084, "epss_percentile": 0.24838}, "CVE-2024-39278": {"epss_score": 0.00118, "epss_percentile": 0.31443}, "CVE-2024-39279": {"epss_score": 0.00035, "epss_percentile": 0.10139}, "CVE-2024-39280": {"epss_score": 0.01751, "epss_percentile": 0.82099}, "CVE-2024-39281": {"epss_score": 0.00078, "epss_percentile": 0.23618}, "CVE-2024-39282": {"epss_score": 0.00036, "epss_percentile": 0.10219}, "CVE-2024-39283": {"epss_score": 0.0011, "epss_percentile": 0.30197}, "CVE-2024-39284": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-39285": {"epss_score": 0.00048, "epss_percentile": 0.15234}, "CVE-2024-39286": {"epss_score": 0.00027, "epss_percentile": 0.06773}, "CVE-2024-39287": {"epss_score": 0.00544, "epss_percentile": 0.6713}, "CVE-2024-39288": {"epss_score": 0.00684, "epss_percentile": 0.71124}, "CVE-2024-39289": {"epss_score": 0.0002, "epss_percentile": 0.04637}, "CVE-2024-39290": {"epss_score": 0.00043, "epss_percentile": 0.13087}, "CVE-2024-39291": {"epss_score": 0.00034, "epss_percentile": 0.0947}, "CVE-2024-39292": {"epss_score": 0.00018, "epss_percentile": 0.04047}, "CVE-2024-39293": {"epss_score": 0.00024, "epss_percentile": 0.05884}, "CVE-2024-39294": {"epss_score": 0.00477, "epss_percentile": 0.64348}, "CVE-2024-39296": {"epss_score": 0.00026, "epss_percentile": 0.064}, "CVE-2024-39298": {"epss_score": 0.00041, "epss_percentile": 0.12438}, "CVE-2024-39299": {"epss_score": 0.00477, "epss_percentile": 0.64348}, "CVE-2024-39300": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2024-39301": {"epss_score": 0.0002, "epss_percentile": 0.04428}, "CVE-2024-39302": {"epss_score": 0.00145, "epss_percentile": 0.35438}, "CVE-2024-39303": {"epss_score": 0.00436, "epss_percentile": 0.6246}, "CVE-2024-39304": {"epss_score": 0.03458, "epss_percentile": 0.87176}, "CVE-2024-39305": {"epss_score": 0.00046, "epss_percentile": 0.14392}, "CVE-2024-39307": {"epss_score": 0.00089, "epss_percentile": 0.258}, "CVE-2024-39308": {"epss_score": 0.02464, "epss_percentile": 0.84831}, "CVE-2024-39309": {"epss_score": 0.04812, "epss_percentile": 0.89168}, "CVE-2024-39310": {"epss_score": 0.0045, "epss_percentile": 0.63086}, "CVE-2024-39311": {"epss_score": 0.00046, "epss_percentile": 0.14085}, "CVE-2024-39312": {"epss_score": 0.00305, "epss_percentile": 0.53347}, "CVE-2024-39313": {"epss_score": 0.00518, "epss_percentile": 0.66104}, "CVE-2024-39314": {"epss_score": 0.00091, "epss_percentile": 0.26245}, "CVE-2024-39315": {"epss_score": 0.00434, "epss_percentile": 0.62307}, "CVE-2024-39316": {"epss_score": 0.00833, "epss_percentile": 0.74082}, "CVE-2024-39317": {"epss_score": 0.00329, "epss_percentile": 0.55385}, "CVE-2024-39318": {"epss_score": 0.00099, "epss_percentile": 0.28317}, "CVE-2024-39319": {"epss_score": 0.00561, "epss_percentile": 0.6768}, "CVE-2024-39320": {"epss_score": 0.0087, "epss_percentile": 0.74706}, "CVE-2024-39321": {"epss_score": 0.00177, "epss_percentile": 0.39496}, "CVE-2024-39322": {"epss_score": 0.00122, "epss_percentile": 0.3203}, "CVE-2024-39323": {"epss_score": 0.00105, "epss_percentile": 0.29346}, "CVE-2024-39324": {"epss_score": 0.00141, "epss_percentile": 0.3495}, "CVE-2024-39325": {"epss_score": 0.00667, "epss_percentile": 0.70713}, "CVE-2024-39326": {"epss_score": 0.00073, "epss_percentile": 0.22607}, "CVE-2024-39327": {"epss_score": 0.00162, "epss_percentile": 0.37712}, "CVE-2024-39328": {"epss_score": 0.00082, "epss_percentile": 0.24436}, "CVE-2024-39329": {"epss_score": 0.00165, "epss_percentile": 0.38103}, "CVE-2024-39330": {"epss_score": 0.00186, "epss_percentile": 0.40665}, "CVE-2024-39331": {"epss_score": 0.00406, "epss_percentile": 0.60529}, "CVE-2024-39332": {"epss_score": 0.01878, "epss_percentile": 0.82669}, "CVE-2024-39334": {"epss_score": 0.0012, "epss_percentile": 0.31735}, "CVE-2024-39335": {"epss_score": 0.00052, "epss_percentile": 0.16382}, "CVE-2024-39337": {"epss_score": 0.0008, "epss_percentile": 0.24038}, "CVE-2024-39338": {"epss_score": 0.02141, "epss_percentile": 0.83751}, "CVE-2024-39339": {"epss_score": 0.00263, "epss_percentile": 0.49542}, "CVE-2024-39340": {"epss_score": 0.00369, "epss_percentile": 0.58268}, "CVE-2024-39341": {"epss_score": 0.00095, "epss_percentile": 0.27112}, "CVE-2024-39342": {"epss_score": 0.00079, "epss_percentile": 0.23877}, "CVE-2024-39343": {"epss_score": 0.00326, "epss_percentile": 0.55041}, "CVE-2024-39344": {"epss_score": 0.00163, "epss_percentile": 0.3778}, "CVE-2024-39345": {"epss_score": 0.00114, "epss_percentile": 0.30752}, "CVE-2024-39347": {"epss_score": 0.00391, "epss_percentile": 0.59561}, "CVE-2024-39348": {"epss_score": 0.00617, "epss_percentile": 0.69353}, "CVE-2024-39349": {"epss_score": 0.08144, "epss_percentile": 0.91901}, "CVE-2024-39350": {"epss_score": 0.00064, "epss_percentile": 0.2038}, "CVE-2024-39351": {"epss_score": 0.00765, "epss_percentile": 0.7291}, "CVE-2024-39352": {"epss_score": 0.00074, "epss_percentile": 0.22724}, "CVE-2024-39353": {"epss_score": 0.00283, "epss_percentile": 0.51375}, "CVE-2024-39354": {"epss_score": 0.00238, "epss_percentile": 0.46767}, "CVE-2024-39355": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2024-39356": {"epss_score": 0.00043, "epss_percentile": 0.13274}, "CVE-2024-39357": {"epss_score": 0.0136, "epss_percentile": 0.79746}, "CVE-2024-39358": {"epss_score": 0.00477, "epss_percentile": 0.64348}, "CVE-2024-39359": {"epss_score": 0.0136, "epss_percentile": 0.79746}, "CVE-2024-39360": {"epss_score": 0.01297, "epss_percentile": 0.79269}, "CVE-2024-39361": {"epss_score": 0.00119, "epss_percentile": 0.31653}, "CVE-2024-39363": {"epss_score": 0.00724, "epss_percentile": 0.72034}, "CVE-2024-39364": {"epss_score": 0.00062, "epss_percentile": 0.19663}, "CVE-2024-39365": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-39367": {"epss_score": 0.01297, "epss_percentile": 0.79269}, "CVE-2024-39368": {"epss_score": 0.00083, "epss_percentile": 0.24619}, "CVE-2024-39370": {"epss_score": 0.01337, "epss_percentile": 0.79562}, "CVE-2024-39371": {"epss_score": 0.00038, "epss_percentile": 0.11289}, "CVE-2024-39372": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-39373": {"epss_score": 0.00496, "epss_percentile": 0.65136}, "CVE-2024-39374": {"epss_score": 0.00205, "epss_percentile": 0.42741}, "CVE-2024-39375": {"epss_score": 0.00026, "epss_percentile": 0.0673}, "CVE-2024-39376": {"epss_score": 0.00155, "epss_percentile": 0.36823}, "CVE-2024-39377": {"epss_score": 0.00192, "epss_percentile": 0.41291}, "CVE-2024-39378": {"epss_score": 0.00104, "epss_percentile": 0.29142}, "CVE-2024-39379": {"epss_score": 0.00038, "epss_percentile": 0.11152}, "CVE-2024-39380": {"epss_score": 0.00236, "epss_percentile": 0.46386}, "CVE-2024-39381": {"epss_score": 0.00192, "epss_percentile": 0.41291}, "CVE-2024-39382": {"epss_score": 0.00039, "epss_percentile": 0.1144}, "CVE-2024-39383": {"epss_score": 0.01538, "epss_percentile": 0.80934}, "CVE-2024-39384": {"epss_score": 0.00192, "epss_percentile": 0.41291}, "CVE-2024-39385": {"epss_score": 0.0003, "epss_percentile": 0.08032}, "CVE-2024-39386": {"epss_score": 0.00109, "epss_percentile": 0.29973}, "CVE-2024-39387": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-39388": {"epss_score": 0.00064, "epss_percentile": 0.20296}, "CVE-2024-39389": {"epss_score": 0.00127, "epss_percentile": 0.3285}, "CVE-2024-39390": {"epss_score": 0.00103, "epss_percentile": 0.29055}, "CVE-2024-39391": {"epss_score": 0.00103, "epss_percentile": 0.29055}, "CVE-2024-39392": {"epss_score": 0.00418, "epss_percentile": 0.61344}, "CVE-2024-39393": {"epss_score": 0.00135, "epss_percentile": 0.34004}, "CVE-2024-39394": {"epss_score": 0.00103, "epss_percentile": 0.29055}, "CVE-2024-39395": {"epss_score": 0.00061, "epss_percentile": 0.19442}, "CVE-2024-39396": {"epss_score": 0.00049, "epss_percentile": 0.15371}, "CVE-2024-39397": {"epss_score": 0.10412, "epss_percentile": 0.92978}, "CVE-2024-39398": {"epss_score": 0.00153, "epss_percentile": 0.3662}, "CVE-2024-39399": {"epss_score": 0.00759, "epss_percentile": 0.72785}, "CVE-2024-39400": {"epss_score": 0.00959, "epss_percentile": 0.75959}, "CVE-2024-39401": {"epss_score": 0.01756, "epss_percentile": 0.8213}, "CVE-2024-39402": {"epss_score": 0.01756, "epss_percentile": 0.8213}, "CVE-2024-39403": {"epss_score": 0.01365, "epss_percentile": 0.79778}, "CVE-2024-39404": {"epss_score": 0.00132, "epss_percentile": 0.33535}, "CVE-2024-39405": {"epss_score": 0.00126, "epss_percentile": 0.32743}, "CVE-2024-39406": {"epss_score": 0.00533, "epss_percentile": 0.66716}, "CVE-2024-39407": {"epss_score": 0.00132, "epss_percentile": 0.33535}, "CVE-2024-39408": {"epss_score": 0.00213, "epss_percentile": 0.4394}, "CVE-2024-39409": {"epss_score": 0.00213, "epss_percentile": 0.4394}, "CVE-2024-39410": {"epss_score": 0.00213, "epss_percentile": 0.4394}, "CVE-2024-39411": {"epss_score": 0.00166, "epss_percentile": 0.38182}, "CVE-2024-39412": {"epss_score": 0.00145, "epss_percentile": 0.35513}, "CVE-2024-39413": {"epss_score": 0.00166, "epss_percentile": 0.38182}, "CVE-2024-39414": {"epss_score": 0.00173, "epss_percentile": 0.39106}, "CVE-2024-39415": {"epss_score": 0.00166, "epss_percentile": 0.38182}, "CVE-2024-39416": {"epss_score": 0.00173, "epss_percentile": 0.39106}, "CVE-2024-39417": {"epss_score": 0.00166, "epss_percentile": 0.38182}, "CVE-2024-39418": {"epss_score": 0.00178, "epss_percentile": 0.39654}, "CVE-2024-39419": {"epss_score": 0.00126, "epss_percentile": 0.32743}, "CVE-2024-39420": {"epss_score": 0.01154, "epss_percentile": 0.78068}, "CVE-2024-39422": {"epss_score": 0.01538, "epss_percentile": 0.80934}, "CVE-2024-39423": {"epss_score": 0.0138, "epss_percentile": 0.79861}, "CVE-2024-39424": {"epss_score": 0.01538, "epss_percentile": 0.80934}, "CVE-2024-39425": {"epss_score": 0.00076, "epss_percentile": 0.23135}, "CVE-2024-39426": {"epss_score": 0.01796, "epss_percentile": 0.82307}, "CVE-2024-39427": {"epss_score": 0.00018, "epss_percentile": 0.03613}, "CVE-2024-39428": {"epss_score": 0.00018, "epss_percentile": 0.03935}, "CVE-2024-39429": {"epss_score": 0.00025, "epss_percentile": 0.06286}, "CVE-2024-39430": {"epss_score": 0.00025, "epss_percentile": 0.06286}, "CVE-2024-39431": {"epss_score": 0.01072, "epss_percentile": 0.7728}, "CVE-2024-39432": {"epss_score": 0.01072, "epss_percentile": 0.7728}, "CVE-2024-39433": {"epss_score": 0.00026, "epss_percentile": 0.06416}, "CVE-2024-39434": {"epss_score": 0.00032, "epss_percentile": 0.09005}, "CVE-2024-39435": {"epss_score": 0.00023, "epss_percentile": 0.05381}, "CVE-2024-39436": {"epss_score": 0.00027, "epss_percentile": 0.07091}, "CVE-2024-39437": {"epss_score": 0.00027, "epss_percentile": 0.07091}, "CVE-2024-39438": {"epss_score": 0.00027, "epss_percentile": 0.07091}, "CVE-2024-39439": {"epss_score": 0.00026, "epss_percentile": 0.06416}, "CVE-2024-39440": {"epss_score": 0.00033, "epss_percentile": 0.09167}, "CVE-2024-39441": {"epss_score": 8e-05, "epss_percentile": 0.00479}, "CVE-2024-39442": {"epss_score": 0.00018, "epss_percentile": 0.038}, "CVE-2024-39457": {"epss_score": 0.00832, "epss_percentile": 0.74073}, "CVE-2024-39458": {"epss_score": 0.00206, "epss_percentile": 0.4294}, "CVE-2024-39459": {"epss_score": 0.00162, "epss_percentile": 0.3763}, "CVE-2024-39460": {"epss_score": 0.00209, "epss_percentile": 0.43367}, "CVE-2024-39461": {"epss_score": 0.00033, "epss_percentile": 0.09146}, "CVE-2024-39462": {"epss_score": 0.00106, "epss_percentile": 0.295}, "CVE-2024-39463": {"epss_score": 0.00023, "epss_percentile": 0.05627}, "CVE-2024-39464": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-39465": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-39466": {"epss_score": 0.00034, "epss_percentile": 0.09706}, "CVE-2024-39467": {"epss_score": 0.00022, "epss_percentile": 0.0525}, "CVE-2024-39468": {"epss_score": 0.00015, "epss_percentile": 0.02197}, "CVE-2024-39469": {"epss_score": 0.00038, "epss_percentile": 0.11423}, "CVE-2024-39470": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-39471": {"epss_score": 0.00012, "epss_percentile": 0.01275}, "CVE-2024-39472": {"epss_score": 0.00015, "epss_percentile": 0.02581}, "CVE-2024-39473": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-39474": {"epss_score": 0.00022, "epss_percentile": 0.05225}, "CVE-2024-39475": {"epss_score": 0.00017, "epss_percentile": 0.03122}, "CVE-2024-39476": {"epss_score": 0.00013, "epss_percentile": 0.01564}, "CVE-2024-39477": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-39478": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-39479": {"epss_score": 0.00034, "epss_percentile": 0.09728}, "CVE-2024-39480": {"epss_score": 0.00022, "epss_percentile": 0.05261}, "CVE-2024-39481": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-39482": {"epss_score": 0.00032, "epss_percentile": 0.09045}, "CVE-2024-39483": {"epss_score": 0.00028, "epss_percentile": 0.07332}, "CVE-2024-39484": {"epss_score": 0.00032, "epss_percentile": 0.09045}, "CVE-2024-39485": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-39486": {"epss_score": 0.00023, "epss_percentile": 0.05516}, "CVE-2024-39487": {"epss_score": 0.00013, "epss_percentile": 0.01675}, "CVE-2024-39488": {"epss_score": 0.00017, "epss_percentile": 0.03122}, "CVE-2024-39489": {"epss_score": 0.00017, "epss_percentile": 0.03058}, "CVE-2024-39490": {"epss_score": 0.00068, "epss_percentile": 0.212}, "CVE-2024-39491": {"epss_score": 0.00028, "epss_percentile": 0.07332}, "CVE-2024-39492": {"epss_score": 0.00032, "epss_percentile": 0.08999}, "CVE-2024-39493": {"epss_score": 0.00028, "epss_percentile": 0.07522}, "CVE-2024-39494": {"epss_score": 0.00011, "epss_percentile": 0.00983}, "CVE-2024-39495": {"epss_score": 0.00016, "epss_percentile": 0.02869}, "CVE-2024-39496": {"epss_score": 0.00016, "epss_percentile": 0.02748}, "CVE-2024-39497": {"epss_score": 4e-05, "epss_percentile": 0.00129}, "CVE-2024-39498": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-39499": {"epss_score": 7e-05, "epss_percentile": 0.0037}, "CVE-2024-39500": {"epss_score": 4e-05, "epss_percentile": 0.00133}, "CVE-2024-39502": {"epss_score": 0.00012, "epss_percentile": 0.01328}, "CVE-2024-39503": {"epss_score": 0.00011, "epss_percentile": 0.01005}, "CVE-2024-39504": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-39505": {"epss_score": 0.00017, "epss_percentile": 0.03231}, "CVE-2024-39506": {"epss_score": 0.00011, "epss_percentile": 0.00955}, "CVE-2024-39507": {"epss_score": 0.0001, "epss_percentile": 0.0076}, "CVE-2024-39508": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2024-39509": {"epss_score": 5e-05, "epss_percentile": 0.00195}, "CVE-2024-39510": {"epss_score": 0.00016, "epss_percentile": 0.02748}, "CVE-2024-39511": {"epss_score": 0.00052, "epss_percentile": 0.16443}, "CVE-2024-39512": {"epss_score": 0.00155, "epss_percentile": 0.36799}, "CVE-2024-39513": {"epss_score": 0.00051, "epss_percentile": 0.16245}, "CVE-2024-39514": {"epss_score": 0.00149, "epss_percentile": 0.36044}, "CVE-2024-39515": {"epss_score": 0.00152, "epss_percentile": 0.36437}, "CVE-2024-39516": {"epss_score": 0.00087, "epss_percentile": 0.25563}, "CVE-2024-39517": {"epss_score": 0.00149, "epss_percentile": 0.36044}, "CVE-2024-39518": {"epss_score": 0.00427, "epss_percentile": 0.6187}, "CVE-2024-39519": {"epss_score": 0.00242, "epss_percentile": 0.47373}, "CVE-2024-39520": {"epss_score": 0.00178, "epss_percentile": 0.39678}, "CVE-2024-39521": {"epss_score": 0.00178, "epss_percentile": 0.39678}, "CVE-2024-39522": {"epss_score": 0.00178, "epss_percentile": 0.39678}, "CVE-2024-39523": {"epss_score": 0.00178, "epss_percentile": 0.39678}, "CVE-2024-39524": {"epss_score": 0.00178, "epss_percentile": 0.39678}, "CVE-2024-39525": {"epss_score": 0.00152, "epss_percentile": 0.36437}, "CVE-2024-39526": {"epss_score": 0.00033, "epss_percentile": 0.09157}, "CVE-2024-39527": {"epss_score": 0.00018, "epss_percentile": 0.03525}, "CVE-2024-39528": {"epss_score": 0.00407, "epss_percentile": 0.60574}, "CVE-2024-39529": {"epss_score": 0.00391, "epss_percentile": 0.59591}, "CVE-2024-39530": {"epss_score": 0.00395, "epss_percentile": 0.59809}, "CVE-2024-39531": {"epss_score": 0.00254, "epss_percentile": 0.48545}, "CVE-2024-39532": {"epss_score": 0.00042, "epss_percentile": 0.12884}, "CVE-2024-39533": {"epss_score": 0.00153, "epss_percentile": 0.36524}, "CVE-2024-39534": {"epss_score": 0.00012, "epss_percentile": 0.01356}, "CVE-2024-39535": {"epss_score": 0.00057, "epss_percentile": 0.18052}, "CVE-2024-39536": {"epss_score": 0.00058, "epss_percentile": 0.18575}, "CVE-2024-39537": {"epss_score": 0.00107, "epss_percentile": 0.29753}, "CVE-2024-39538": {"epss_score": 0.00056, "epss_percentile": 0.17885}, "CVE-2024-39539": {"epss_score": 0.00148, "epss_percentile": 0.35888}, "CVE-2024-39540": {"epss_score": 0.00395, "epss_percentile": 0.59809}, "CVE-2024-39541": {"epss_score": 0.00057, "epss_percentile": 0.18052}, "CVE-2024-39542": {"epss_score": 0.00324, "epss_percentile": 0.54942}, "CVE-2024-39543": {"epss_score": 0.00056, "epss_percentile": 0.17885}, "CVE-2024-39544": {"epss_score": 0.00016, "epss_percentile": 0.02889}, "CVE-2024-39545": {"epss_score": 0.00157, "epss_percentile": 0.37124}, "CVE-2024-39546": {"epss_score": 0.0008, "epss_percentile": 0.24197}, "CVE-2024-39547": {"epss_score": 0.00016, "epss_percentile": 0.03027}, "CVE-2024-39548": {"epss_score": 0.00157, "epss_percentile": 0.37124}, "CVE-2024-39549": {"epss_score": 0.00295, "epss_percentile": 0.52484}, "CVE-2024-39550": {"epss_score": 0.00148, "epss_percentile": 0.35888}, "CVE-2024-39551": {"epss_score": 0.00243, "epss_percentile": 0.47417}, "CVE-2024-39552": {"epss_score": 0.0062, "epss_percentile": 0.69441}, "CVE-2024-39553": {"epss_score": 0.00081, "epss_percentile": 0.2431}, "CVE-2024-39554": {"epss_score": 0.0042, "epss_percentile": 0.61449}, "CVE-2024-39555": {"epss_score": 0.01594, "epss_percentile": 0.81229}, "CVE-2024-39556": {"epss_score": 0.00053, "epss_percentile": 0.16674}, "CVE-2024-39557": {"epss_score": 0.00175, "epss_percentile": 0.39289}, "CVE-2024-39558": {"epss_score": 0.00188, "epss_percentile": 0.40859}, "CVE-2024-39559": {"epss_score": 0.0042, "epss_percentile": 0.6144}, "CVE-2024-39560": {"epss_score": 0.0006, "epss_percentile": 0.19115}, "CVE-2024-39561": {"epss_score": 0.00118, "epss_percentile": 0.31406}, "CVE-2024-39562": {"epss_score": 0.00403, "epss_percentile": 0.60351}, "CVE-2024-39563": {"epss_score": 0.00311, "epss_percentile": 0.53929}, "CVE-2024-39564": {"epss_score": 0.00196, "epss_percentile": 0.41787}, "CVE-2024-39565": {"epss_score": 0.00226, "epss_percentile": 0.45346}, "CVE-2024-39567": {"epss_score": 0.00232, "epss_percentile": 0.45896}, "CVE-2024-39568": {"epss_score": 0.0033, "epss_percentile": 0.55488}, "CVE-2024-39569": {"epss_score": 0.02116, "epss_percentile": 0.83663}, "CVE-2024-39570": {"epss_score": 0.02591, "epss_percentile": 0.85182}, "CVE-2024-39571": {"epss_score": 0.01548, "epss_percentile": 0.80976}, "CVE-2024-39573": {"epss_score": 0.02523, "epss_percentile": 0.85007}, "CVE-2024-39574": {"epss_score": 0.00037, "epss_percentile": 0.10779}, "CVE-2024-39576": {"epss_score": 0.00081, "epss_percentile": 0.24255}, "CVE-2024-39577": {"epss_score": 0.00386, "epss_percentile": 0.59275}, "CVE-2024-39578": {"epss_score": 0.0012, "epss_percentile": 0.31795}, "CVE-2024-39579": {"epss_score": 0.00086, "epss_percentile": 0.25285}, "CVE-2024-39580": {"epss_score": 0.0005, "epss_percentile": 0.1586}, "CVE-2024-39581": {"epss_score": 0.00271, "epss_percentile": 0.50314}, "CVE-2024-39582": {"epss_score": 0.00052, "epss_percentile": 0.16437}, "CVE-2024-39583": {"epss_score": 0.00294, "epss_percentile": 0.52404}, "CVE-2024-39584": {"epss_score": 8e-05, "epss_percentile": 0.00542}, "CVE-2024-39585": {"epss_score": 0.00097, "epss_percentile": 0.27462}, "CVE-2024-39586": {"epss_score": 0.00042, "epss_percentile": 0.12922}, "CVE-2024-39589": {"epss_score": 0.00171, "epss_percentile": 0.388}, "CVE-2024-39590": {"epss_score": 0.00171, "epss_percentile": 0.388}, "CVE-2024-39591": {"epss_score": 0.00411, "epss_percentile": 0.60903}, "CVE-2024-39592": {"epss_score": 0.00359, "epss_percentile": 0.57592}, "CVE-2024-39593": {"epss_score": 0.00268, "epss_percentile": 0.50084}, "CVE-2024-39594": {"epss_score": 0.00166, "epss_percentile": 0.38248}, "CVE-2024-39595": {"epss_score": 0.00155, "epss_percentile": 0.36846}, "CVE-2024-39596": {"epss_score": 0.0011, "epss_percentile": 0.30108}, "CVE-2024-39597": {"epss_score": 0.00234, "epss_percentile": 0.46176}, "CVE-2024-39598": {"epss_score": 0.00334, "epss_percentile": 0.55711}, "CVE-2024-39599": {"epss_score": 0.00034, "epss_percentile": 0.09656}, "CVE-2024-39600": {"epss_score": 0.0009, "epss_percentile": 0.26133}, "CVE-2024-39601": {"epss_score": 0.0031, "epss_percentile": 0.53749}, "CVE-2024-39602": {"epss_score": 0.01227, "epss_percentile": 0.78702}, "CVE-2024-39603": {"epss_score": 0.0136, "epss_percentile": 0.79746}, "CVE-2024-39604": {"epss_score": 0.00886, "epss_percentile": 0.74949}, "CVE-2024-39605": {"epss_score": 0.01968, "epss_percentile": 0.83087}, "CVE-2024-39606": {"epss_score": 0.00024, "epss_percentile": 0.05968}, "CVE-2024-39607": {"epss_score": 0.00193, "epss_percentile": 0.414}, "CVE-2024-39608": {"epss_score": 0.00128, "epss_percentile": 0.33056}, "CVE-2024-39609": {"epss_score": 0.0008, "epss_percentile": 0.24019}, "CVE-2024-39610": {"epss_score": 0.00162, "epss_percentile": 0.37622}, "CVE-2024-39612": {"epss_score": 0.00085, "epss_percentile": 0.25175}, "CVE-2024-39613": {"epss_score": 0.0073, "epss_percentile": 0.7214}, "CVE-2024-39614": {"epss_score": 0.06838, "epss_percentile": 0.9106}, "CVE-2024-39619": {"epss_score": 0.02157, "epss_percentile": 0.83815}, "CVE-2024-39620": {"epss_score": 0.00336, "epss_percentile": 0.55913}, "CVE-2024-39621": {"epss_score": 0.0112, "epss_percentile": 0.77765}, "CVE-2024-39622": {"epss_score": 0.00327, "epss_percentile": 0.55136}, "CVE-2024-39623": {"epss_score": 0.00074, "epss_percentile": 0.22723}, "CVE-2024-39624": {"epss_score": 0.02159, "epss_percentile": 0.83818}, "CVE-2024-39625": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-39626": {"epss_score": 0.00158, "epss_percentile": 0.37157}, "CVE-2024-39627": {"epss_score": 0.00277, "epss_percentile": 0.50801}, "CVE-2024-39628": {"epss_score": 0.0013, "epss_percentile": 0.33332}, "CVE-2024-39629": {"epss_score": 0.00158, "epss_percentile": 0.37157}, "CVE-2024-39630": {"epss_score": 0.00163, "epss_percentile": 0.37812}, "CVE-2024-39631": {"epss_score": 0.00442, "epss_percentile": 0.62754}, "CVE-2024-39633": {"epss_score": 0.00258, "epss_percentile": 0.49001}, "CVE-2024-39634": {"epss_score": 0.00329, "epss_percentile": 0.55384}, "CVE-2024-39635": {"epss_score": 0.00225, "epss_percentile": 0.45091}, "CVE-2024-39636": {"epss_score": 0.01303, "epss_percentile": 0.79309}, "CVE-2024-39637": {"epss_score": 0.00171, "epss_percentile": 0.38863}, "CVE-2024-39638": {"epss_score": 0.00433, "epss_percentile": 0.62201}, "CVE-2024-39639": {"epss_score": 0.00103, "epss_percentile": 0.29061}, "CVE-2024-39640": {"epss_score": 0.00127, "epss_percentile": 0.32932}, "CVE-2024-39641": {"epss_score": 0.00154, "epss_percentile": 0.36748}, "CVE-2024-39642": {"epss_score": 0.00093, "epss_percentile": 0.26641}, "CVE-2024-39643": {"epss_score": 0.00343, "epss_percentile": 0.56435}, "CVE-2024-39644": {"epss_score": 0.00251, "epss_percentile": 0.48317}, "CVE-2024-39645": {"epss_score": 0.00111, "epss_percentile": 0.30394}, "CVE-2024-39646": {"epss_score": 0.06273, "epss_percentile": 0.9063}, "CVE-2024-39647": {"epss_score": 0.00335, "epss_percentile": 0.55797}, "CVE-2024-39648": {"epss_score": 0.00208, "epss_percentile": 0.43297}, "CVE-2024-39649": {"epss_score": 0.00279, "epss_percentile": 0.50979}, "CVE-2024-39650": {"epss_score": 0.0011, "epss_percentile": 0.30176}, "CVE-2024-39651": {"epss_score": 0.00549, "epss_percentile": 0.67294}, "CVE-2024-39652": {"epss_score": 0.00305, "epss_percentile": 0.53334}, "CVE-2024-39653": {"epss_score": 0.00587, "epss_percentile": 0.68481}, "CVE-2024-39654": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-39655": {"epss_score": 0.0017, "epss_percentile": 0.3866}, "CVE-2024-39656": {"epss_score": 0.00236, "epss_percentile": 0.46419}, "CVE-2024-39657": {"epss_score": 0.00141, "epss_percentile": 0.34924}, "CVE-2024-39658": {"epss_score": 0.00556, "epss_percentile": 0.67516}, "CVE-2024-39659": {"epss_score": 0.00216, "epss_percentile": 0.4422}, "CVE-2024-39660": {"epss_score": 0.00129, "epss_percentile": 0.33145}, "CVE-2024-39661": {"epss_score": 0.0017, "epss_percentile": 0.3866}, "CVE-2024-39662": {"epss_score": 0.00216, "epss_percentile": 0.4422}, "CVE-2024-39663": {"epss_score": 0.0017, "epss_percentile": 0.38739}, "CVE-2024-39664": {"epss_score": 0.00148, "epss_percentile": 0.35885}, "CVE-2024-39665": {"epss_score": 0.00217, "epss_percentile": 0.44296}, "CVE-2024-39666": {"epss_score": 0.0008, "epss_percentile": 0.24096}, "CVE-2024-39667": {"epss_score": 0.0011, "epss_percentile": 0.30167}, "CVE-2024-39668": {"epss_score": 0.00199, "epss_percentile": 0.42117}, "CVE-2024-39669": {"epss_score": 0.00097, "epss_percentile": 0.27533}, "CVE-2024-39670": {"epss_score": 0.00061, "epss_percentile": 0.19544}, "CVE-2024-39671": {"epss_score": 0.00085, "epss_percentile": 0.25095}, "CVE-2024-39672": {"epss_score": 0.00112, "epss_percentile": 0.30425}, "CVE-2024-39673": {"epss_score": 0.00101, "epss_percentile": 0.2863}, "CVE-2024-39674": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2024-39675": {"epss_score": 0.00086, "epss_percentile": 0.25349}, "CVE-2024-39676": {"epss_score": 0.0027, "epss_percentile": 0.502}, "CVE-2024-39677": {"epss_score": 0.00548, "epss_percentile": 0.67273}, "CVE-2024-39678": {"epss_score": 0.00457, "epss_percentile": 0.63367}, "CVE-2024-39679": {"epss_score": 0.00457, "epss_percentile": 0.63367}, "CVE-2024-39680": {"epss_score": 0.00324, "epss_percentile": 0.54976}, "CVE-2024-39681": {"epss_score": 0.00324, "epss_percentile": 0.54976}, "CVE-2024-39682": {"epss_score": 0.01465, "epss_percentile": 0.80457}, "CVE-2024-39683": {"epss_score": 0.00608, "epss_percentile": 0.69077}, "CVE-2024-39684": {"epss_score": 0.00159, "epss_percentile": 0.37317}, "CVE-2024-39685": {"epss_score": 0.00239, "epss_percentile": 0.4692}, "CVE-2024-39686": {"epss_score": 0.00313, "epss_percentile": 0.54036}, "CVE-2024-39687": {"epss_score": 0.00078, "epss_percentile": 0.2363}, "CVE-2024-39688": {"epss_score": 0.00289, "epss_percentile": 0.52}, "CVE-2024-39689": {"epss_score": 0.21233, "epss_percentile": 0.95482}, "CVE-2024-39690": {"epss_score": 0.00127, "epss_percentile": 0.32938}, "CVE-2024-39691": {"epss_score": 0.00089, "epss_percentile": 0.25978}, "CVE-2024-39693": {"epss_score": 0.00514, "epss_percentile": 0.65952}, "CVE-2024-39694": {"epss_score": 0.00141, "epss_percentile": 0.34865}, "CVE-2024-39695": {"epss_score": 0.00296, "epss_percentile": 0.52604}, "CVE-2024-39696": {"epss_score": 0.00441, "epss_percentile": 0.62656}, "CVE-2024-39697": {"epss_score": 0.00149, "epss_percentile": 0.35996}, "CVE-2024-39698": {"epss_score": 0.00431, "epss_percentile": 0.62094}, "CVE-2024-39699": {"epss_score": 0.00087, "epss_percentile": 0.25445}, "CVE-2024-39700": {"epss_score": 0.03919, "epss_percentile": 0.8795}, "CVE-2024-39701": {"epss_score": 0.00106, "epss_percentile": 0.29496}, "CVE-2024-39702": {"epss_score": 0.00597, "epss_percentile": 0.68745}, "CVE-2024-39703": {"epss_score": 0.00345, "epss_percentile": 0.56578}, "CVE-2024-39704": {"epss_score": 0.03813, "epss_percentile": 0.87763}, "CVE-2024-39705": {"epss_score": 0.10792, "epss_percentile": 0.93104}, "CVE-2024-39707": {"epss_score": 0.00056, "epss_percentile": 0.17849}, "CVE-2024-39708": {"epss_score": 0.00041, "epss_percentile": 0.1232}, "CVE-2024-39709": {"epss_score": 0.0016, "epss_percentile": 0.37439}, "CVE-2024-39710": {"epss_score": 0.19104, "epss_percentile": 0.9513}, "CVE-2024-39711": {"epss_score": 0.19104, "epss_percentile": 0.9513}, "CVE-2024-39712": {"epss_score": 0.19104, "epss_percentile": 0.9513}, "CVE-2024-39713": {"epss_score": 0.8928, "epss_percentile": 0.99518}, "CVE-2024-39714": {"epss_score": 0.07021, "epss_percentile": 0.91192}, "CVE-2024-39715": {"epss_score": 0.06782, "epss_percentile": 0.91024}, "CVE-2024-39717": {"epss_score": 0.05181, "epss_percentile": 0.8958}, "CVE-2024-39718": {"epss_score": 0.00457, "epss_percentile": 0.63364}, "CVE-2024-39719": {"epss_score": 0.07868, "epss_percentile": 0.9173}, "CVE-2024-39720": {"epss_score": 0.00213, "epss_percentile": 0.43917}, "CVE-2024-39721": {"epss_score": 0.0016, "epss_percentile": 0.37517}, "CVE-2024-39722": {"epss_score": 0.11799, "epss_percentile": 0.9348}, "CVE-2024-39723": {"epss_score": 0.00054, "epss_percentile": 0.17267}, "CVE-2024-39725": {"epss_score": 0.00082, "epss_percentile": 0.24411}, "CVE-2024-39726": {"epss_score": 0.00064, "epss_percentile": 0.20159}, "CVE-2024-39727": {"epss_score": 0.00088, "epss_percentile": 0.25765}, "CVE-2024-39728": {"epss_score": 0.00308, "epss_percentile": 0.53625}, "CVE-2024-39729": {"epss_score": 0.0008, "epss_percentile": 0.24157}, "CVE-2024-39730": {"epss_score": 0.00028, "epss_percentile": 0.07513}, "CVE-2024-39731": {"epss_score": 0.00064, "epss_percentile": 0.20283}, "CVE-2024-39732": {"epss_score": 0.00047, "epss_percentile": 0.14832}, "CVE-2024-39733": {"epss_score": 0.00032, "epss_percentile": 0.09103}, "CVE-2024-39734": {"epss_score": 0.00066, "epss_percentile": 0.20856}, "CVE-2024-39735": {"epss_score": 0.00423, "epss_percentile": 0.61618}, "CVE-2024-39736": {"epss_score": 0.00168, "epss_percentile": 0.38448}, "CVE-2024-39737": {"epss_score": 0.00078, "epss_percentile": 0.2365}, "CVE-2024-39739": {"epss_score": 0.00077, "epss_percentile": 0.23465}, "CVE-2024-39740": {"epss_score": 0.00147, "epss_percentile": 0.35704}, "CVE-2024-39741": {"epss_score": 0.00104, "epss_percentile": 0.29176}, "CVE-2024-39742": {"epss_score": 0.00034, "epss_percentile": 0.09531}, "CVE-2024-39743": {"epss_score": 0.00225, "epss_percentile": 0.45104}, "CVE-2024-39744": {"epss_score": 0.00071, "epss_percentile": 0.22037}, "CVE-2024-39745": {"epss_score": 0.00044, "epss_percentile": 0.13604}, "CVE-2024-39746": {"epss_score": 0.00024, "epss_percentile": 0.0569}, "CVE-2024-39747": {"epss_score": 0.0006, "epss_percentile": 0.19078}, "CVE-2024-39750": {"epss_score": 0.01022, "epss_percentile": 0.76758}, "CVE-2024-39751": {"epss_score": 0.0012, "epss_percentile": 0.31811}, "CVE-2024-39752": {"epss_score": 0.00027, "epss_percentile": 0.07096}, "CVE-2024-39753": {"epss_score": 0.05029, "epss_percentile": 0.89411}, "CVE-2024-39754": {"epss_score": 0.00272, "epss_percentile": 0.50389}, "CVE-2024-39755": {"epss_score": 0.00082, "epss_percentile": 0.24571}, "CVE-2024-39756": {"epss_score": 0.00477, "epss_percentile": 0.64348}, "CVE-2024-39757": {"epss_score": 0.0136, "epss_percentile": 0.79746}, "CVE-2024-39758": {"epss_score": 0.00018, "epss_percentile": 0.03561}, "CVE-2024-39759": {"epss_score": 0.02404, "epss_percentile": 0.84647}, "CVE-2024-39760": {"epss_score": 0.02404, "epss_percentile": 0.84647}, "CVE-2024-39761": {"epss_score": 0.02404, "epss_percentile": 0.84647}, "CVE-2024-39762": {"epss_score": 0.01422, "epss_percentile": 0.80178}, "CVE-2024-39763": {"epss_score": 0.01422, "epss_percentile": 0.80178}, "CVE-2024-39764": {"epss_score": 0.01422, "epss_percentile": 0.80178}, "CVE-2024-39765": {"epss_score": 0.01422, "epss_percentile": 0.80178}, "CVE-2024-39766": {"epss_score": 0.00129, "epss_percentile": 0.33169}, "CVE-2024-39767": {"epss_score": 0.00129, "epss_percentile": 0.33165}, "CVE-2024-39768": {"epss_score": 0.0025, "epss_percentile": 0.48247}, "CVE-2024-39769": {"epss_score": 0.0025, "epss_percentile": 0.48247}, "CVE-2024-39770": {"epss_score": 0.0025, "epss_percentile": 0.48247}, "CVE-2024-39771": {"epss_score": 0.00146, "epss_percentile": 0.35636}, "CVE-2024-39772": {"epss_score": 0.00262, "epss_percentile": 0.49386}, "CVE-2024-39773": {"epss_score": 0.00084, "epss_percentile": 0.24877}, "CVE-2024-39774": {"epss_score": 0.00477, "epss_percentile": 0.64348}, "CVE-2024-39775": {"epss_score": 0.0029, "epss_percentile": 0.5211}, "CVE-2024-39776": {"epss_score": 0.00155, "epss_percentile": 0.36777}, "CVE-2024-39777": {"epss_score": 0.00273, "epss_percentile": 0.50437}, "CVE-2024-39778": {"epss_score": 0.00572, "epss_percentile": 0.68033}, "CVE-2024-39779": {"epss_score": 0.00024, "epss_percentile": 0.05671}, "CVE-2024-39780": {"epss_score": 0.00322, "epss_percentile": 0.54746}, "CVE-2024-39781": {"epss_score": 0.01175, "epss_percentile": 0.78259}, "CVE-2024-39782": {"epss_score": 0.01175, "epss_percentile": 0.78259}, "CVE-2024-39783": {"epss_score": 0.01175, "epss_percentile": 0.78259}, "CVE-2024-39784": {"epss_score": 0.01422, "epss_percentile": 0.80178}, "CVE-2024-39785": {"epss_score": 0.01422, "epss_percentile": 0.80178}, "CVE-2024-39786": {"epss_score": 0.00536, "epss_percentile": 0.66861}, "CVE-2024-39787": {"epss_score": 0.00536, "epss_percentile": 0.66861}, "CVE-2024-39788": {"epss_score": 0.01417, "epss_percentile": 0.80154}, "CVE-2024-39789": {"epss_score": 0.01417, "epss_percentile": 0.80154}, "CVE-2024-39790": {"epss_score": 0.01417, "epss_percentile": 0.80154}, "CVE-2024-39791": {"epss_score": 0.06038, "epss_percentile": 0.90426}, "CVE-2024-39792": {"epss_score": 0.00839, "epss_percentile": 0.74186}, "CVE-2024-39793": {"epss_score": 0.01417, "epss_percentile": 0.80154}, "CVE-2024-39794": {"epss_score": 0.01417, "epss_percentile": 0.80154}, "CVE-2024-39795": {"epss_score": 0.01417, "epss_percentile": 0.80154}, "CVE-2024-39797": {"epss_score": 0.00027, "epss_percentile": 0.0674}, "CVE-2024-39798": {"epss_score": 0.02048, "epss_percentile": 0.83392}, "CVE-2024-39799": {"epss_score": 0.02048, "epss_percentile": 0.83392}, "CVE-2024-39800": {"epss_score": 0.02048, "epss_percentile": 0.83392}, "CVE-2024-39801": {"epss_score": 0.0025, "epss_percentile": 0.48247}, "CVE-2024-39802": {"epss_score": 0.0025, "epss_percentile": 0.48247}, "CVE-2024-39803": {"epss_score": 0.0025, "epss_percentile": 0.48247}, "CVE-2024-39804": {"epss_score": 0.00059, "epss_percentile": 0.18646}, "CVE-2024-39805": {"epss_score": 0.00012, "epss_percentile": 0.01225}, "CVE-2024-39806": {"epss_score": 0.00044, "epss_percentile": 0.13367}, "CVE-2024-39807": {"epss_score": 0.00444, "epss_percentile": 0.62844}, "CVE-2024-39808": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2024-39809": {"epss_score": 0.00799, "epss_percentile": 0.73523}, "CVE-2024-39810": {"epss_score": 0.0028, "epss_percentile": 0.51076}, "CVE-2024-39811": {"epss_score": 0.00056, "epss_percentile": 0.17879}, "CVE-2024-39813": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-39815": {"epss_score": 0.00784, "epss_percentile": 0.73237}, "CVE-2024-39816": {"epss_score": 0.00087, "epss_percentile": 0.25601}, "CVE-2024-39817": {"epss_score": 0.00543, "epss_percentile": 0.67105}, "CVE-2024-39818": {"epss_score": 0.00774, "epss_percentile": 0.73073}, "CVE-2024-39819": {"epss_score": 0.00137, "epss_percentile": 0.34311}, "CVE-2024-39820": {"epss_score": 0.00078, "epss_percentile": 0.23576}, "CVE-2024-39821": {"epss_score": 0.00096, "epss_percentile": 0.27247}, "CVE-2024-39822": {"epss_score": 0.00813, "epss_percentile": 0.73762}, "CVE-2024-39823": {"epss_score": 0.0028, "epss_percentile": 0.51022}, "CVE-2024-39824": {"epss_score": 0.0028, "epss_percentile": 0.51022}, "CVE-2024-39825": {"epss_score": 0.01304, "epss_percentile": 0.79319}, "CVE-2024-39826": {"epss_score": 0.00213, "epss_percentile": 0.43941}, "CVE-2024-39827": {"epss_score": 0.00067, "epss_percentile": 0.21046}, "CVE-2024-39828": {"epss_score": 0.00114, "epss_percentile": 0.30774}, "CVE-2024-39830": {"epss_score": 0.00336, "epss_percentile": 0.55926}, "CVE-2024-39831": {"epss_score": 0.00031, "epss_percentile": 0.08496}, "CVE-2024-39832": {"epss_score": 0.00262, "epss_percentile": 0.4936}, "CVE-2024-39833": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2024-39835": {"epss_score": 0.00018, "epss_percentile": 0.03656}, "CVE-2024-39836": {"epss_score": 0.00386, "epss_percentile": 0.59269}, "CVE-2024-39837": {"epss_score": 0.00297, "epss_percentile": 0.52743}, "CVE-2024-39838": {"epss_score": 0.00228, "epss_percentile": 0.45516}, "CVE-2024-39839": {"epss_score": 0.00217, "epss_percentile": 0.44309}, "CVE-2024-39840": {"epss_score": 0.00151, "epss_percentile": 0.36324}, "CVE-2024-39841": {"epss_score": 0.00134, "epss_percentile": 0.33791}, "CVE-2024-39842": {"epss_score": 0.01173, "epss_percentile": 0.78239}, "CVE-2024-39843": {"epss_score": 0.00141, "epss_percentile": 0.34923}, "CVE-2024-39844": {"epss_score": 0.38877, "epss_percentile": 0.97125}, "CVE-2024-39846": {"epss_score": 0.00032, "epss_percentile": 0.09032}, "CVE-2024-39848": {"epss_score": 0.00067, "epss_percentile": 0.20972}, "CVE-2024-39853": {"epss_score": 0.0015, "epss_percentile": 0.36092}, "CVE-2024-39863": {"epss_score": 0.00323, "epss_percentile": 0.54865}, "CVE-2024-39864": {"epss_score": 0.05372, "epss_percentile": 0.89795}, "CVE-2024-39865": {"epss_score": 0.10551, "epss_percentile": 0.93025}, "CVE-2024-39866": {"epss_score": 0.00241, "epss_percentile": 0.47241}, "CVE-2024-39867": {"epss_score": 0.00386, "epss_percentile": 0.59245}, "CVE-2024-39868": {"epss_score": 0.00386, "epss_percentile": 0.59245}, "CVE-2024-39869": {"epss_score": 0.00483, "epss_percentile": 0.64557}, "CVE-2024-39870": {"epss_score": 0.0024, "epss_percentile": 0.46965}, "CVE-2024-39871": {"epss_score": 0.00172, "epss_percentile": 0.38997}, "CVE-2024-39872": {"epss_score": 0.00624, "epss_percentile": 0.69574}, "CVE-2024-39873": {"epss_score": 0.00447, "epss_percentile": 0.62976}, "CVE-2024-39874": {"epss_score": 0.00447, "epss_percentile": 0.62976}, "CVE-2024-39875": {"epss_score": 0.00326, "epss_percentile": 0.55037}, "CVE-2024-39876": {"epss_score": 0.00577, "epss_percentile": 0.68162}, "CVE-2024-39877": {"epss_score": 0.00096, "epss_percentile": 0.27257}, "CVE-2024-39878": {"epss_score": 5e-05, "epss_percentile": 0.002}, "CVE-2024-39879": {"epss_score": 5e-05, "epss_percentile": 0.002}, "CVE-2024-39880": {"epss_score": 0.00566, "epss_percentile": 0.67819}, "CVE-2024-39881": {"epss_score": 0.00529, "epss_percentile": 0.66599}, "CVE-2024-39882": {"epss_score": 0.00556, "epss_percentile": 0.6752}, "CVE-2024-39883": {"epss_score": 0.00556, "epss_percentile": 0.6752}, "CVE-2024-39884": {"epss_score": 0.00267, "epss_percentile": 0.49972}, "CVE-2024-39886": {"epss_score": 0.00159, "epss_percentile": 0.37305}, "CVE-2024-39887": {"epss_score": 0.53758, "epss_percentile": 0.97896}, "CVE-2024-39888": {"epss_score": 0.00254, "epss_percentile": 0.48518}, "CVE-2024-39890": {"epss_score": 0.00299, "epss_percentile": 0.5289}, "CVE-2024-39891": {"epss_score": 0.23189, "epss_percentile": 0.95748}, "CVE-2024-39894": {"epss_score": 0.02949, "epss_percentile": 0.8605}, "CVE-2024-39895": {"epss_score": 0.0112, "epss_percentile": 0.7776}, "CVE-2024-39896": {"epss_score": 0.00692, "epss_percentile": 0.71285}, "CVE-2024-39897": {"epss_score": 0.00361, "epss_percentile": 0.57722}, "CVE-2024-39899": {"epss_score": 0.00106, "epss_percentile": 0.29402}, "CVE-2024-39900": {"epss_score": 0.002, "epss_percentile": 0.42203}, "CVE-2024-39901": {"epss_score": 0.00237, "epss_percentile": 0.46732}, "CVE-2024-39902": {"epss_score": 0.00106, "epss_percentile": 0.2942}, "CVE-2024-39903": {"epss_score": 0.45768, "epss_percentile": 0.97501}, "CVE-2024-39904": {"epss_score": 0.00297, "epss_percentile": 0.52707}, "CVE-2024-39905": {"epss_score": 0.00292, "epss_percentile": 0.5223}, "CVE-2024-39906": {"epss_score": 0.00922, "epss_percentile": 0.75494}, "CVE-2024-39907": {"epss_score": 0.84705, "epss_percentile": 0.99302}, "CVE-2024-39908": {"epss_score": 0.07262, "epss_percentile": 0.91357}, "CVE-2024-39909": {"epss_score": 0.00145, "epss_percentile": 0.35498}, "CVE-2024-39910": {"epss_score": 0.00465, "epss_percentile": 0.63761}, "CVE-2024-39911": {"epss_score": 0.68287, "epss_percentile": 0.9854}, "CVE-2024-39912": {"epss_score": 0.00228, "epss_percentile": 0.45476}, "CVE-2024-39914": {"epss_score": 0.93559, "epss_percentile": 0.99818}, "CVE-2024-39915": {"epss_score": 0.00209, "epss_percentile": 0.43331}, "CVE-2024-39916": {"epss_score": 0.0046, "epss_percentile": 0.63526}, "CVE-2024-39917": {"epss_score": 0.00143, "epss_percentile": 0.35113}, "CVE-2024-39918": {"epss_score": 0.00167, "epss_percentile": 0.38302}, "CVE-2024-39919": {"epss_score": 0.0009, "epss_percentile": 0.26076}, "CVE-2024-39920": {"epss_score": 0.00076, "epss_percentile": 0.23283}, "CVE-2024-39921": {"epss_score": 0.00297, "epss_percentile": 0.52701}, "CVE-2024-39922": {"epss_score": 0.00077, "epss_percentile": 0.23284}, "CVE-2024-39923": {"epss_score": 0.00048, "epss_percentile": 0.15008}, "CVE-2024-39924": {"epss_score": 0.00173, "epss_percentile": 0.39081}, "CVE-2024-39925": {"epss_score": 0.00192, "epss_percentile": 0.41319}, "CVE-2024-39926": {"epss_score": 0.00148, "epss_percentile": 0.35924}, "CVE-2024-39927": {"epss_score": 0.00625, "epss_percentile": 0.69595}, "CVE-2024-39928": {"epss_score": 0.00116, "epss_percentile": 0.31089}, "CVE-2024-39929": {"epss_score": 0.58026, "epss_percentile": 0.98096}, "CVE-2024-39930": {"epss_score": 0.11879, "epss_percentile": 0.93502}, "CVE-2024-39931": {"epss_score": 0.09509, "epss_percentile": 0.92577}, "CVE-2024-39932": {"epss_score": 0.02822, "epss_percentile": 0.85748}, "CVE-2024-39933": {"epss_score": 0.003, "epss_percentile": 0.52919}, "CVE-2024-39934": {"epss_score": 0.00075, "epss_percentile": 0.22889}, "CVE-2024-39935": {"epss_score": 0.01334, "epss_percentile": 0.79538}, "CVE-2024-39936": {"epss_score": 0.00189, "epss_percentile": 0.40951}, "CVE-2024-39937": {"epss_score": 0.00559, "epss_percentile": 0.67621}, "CVE-2024-39943": {"epss_score": 0.78344, "epss_percentile": 0.98982}, "CVE-2024-39944": {"epss_score": 0.00402, "epss_percentile": 0.60296}, "CVE-2024-39945": {"epss_score": 0.00231, "epss_percentile": 0.45768}, "CVE-2024-39946": {"epss_score": 0.00179, "epss_percentile": 0.39789}, "CVE-2024-39947": {"epss_score": 0.00467, "epss_percentile": 0.63861}, "CVE-2024-39948": {"epss_score": 0.00524, "epss_percentile": 0.66317}, "CVE-2024-39949": {"epss_score": 0.00525, "epss_percentile": 0.66384}, "CVE-2024-39950": {"epss_score": 0.00257, "epss_percentile": 0.48859}, "CVE-2024-39954": {"epss_score": 0.00077, "epss_percentile": 0.23524}, "CVE-2024-39962": {"epss_score": 0.07868, "epss_percentile": 0.91733}, "CVE-2024-39963": {"epss_score": 0.01251, "epss_percentile": 0.78892}, "CVE-2024-39967": {"epss_score": 0.00097, "epss_percentile": 0.27615}, "CVE-2024-3000": {"epss_score": 0.00115, "epss_percentile": 0.31023}, "CVE-2024-3001": {"epss_score": 0.00107, "epss_percentile": 0.29652}, "CVE-2024-3002": {"epss_score": 0.00074, "epss_percentile": 0.22763}, "CVE-2024-3003": {"epss_score": 0.001, "epss_percentile": 0.28546}, "CVE-2024-3004": {"epss_score": 0.00142, "epss_percentile": 0.34994}, "CVE-2024-3005": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-3006": {"epss_score": 0.0045, "epss_percentile": 0.6308}, "CVE-2024-3007": {"epss_score": 0.0045, "epss_percentile": 0.6308}, "CVE-2024-3008": {"epss_score": 0.0045, "epss_percentile": 0.6308}, "CVE-2024-3009": {"epss_score": 0.05908, "epss_percentile": 0.90315}, "CVE-2024-3010": {"epss_score": 0.0055, "epss_percentile": 0.67346}, "CVE-2024-3011": {"epss_score": 0.00417, "epss_percentile": 0.61253}, "CVE-2024-3012": {"epss_score": 0.00417, "epss_percentile": 0.61253}, "CVE-2024-3013": {"epss_score": 0.02587, "epss_percentile": 0.85171}, "CVE-2024-3014": {"epss_score": 0.0008, "epss_percentile": 0.24063}, "CVE-2024-3015": {"epss_score": 0.0008, "epss_percentile": 0.24063}, "CVE-2024-3016": {"epss_score": 0.00495, "epss_percentile": 0.65122}, "CVE-2024-3017": {"epss_score": 0.0008, "epss_percentile": 0.24014}, "CVE-2024-3018": {"epss_score": 0.01086, "epss_percentile": 0.77417}, "CVE-2024-3019": {"epss_score": 0.00445, "epss_percentile": 0.62861}, "CVE-2024-3020": {"epss_score": 0.01175, "epss_percentile": 0.7826}, "CVE-2024-3021": {"epss_score": 0.00473, "epss_percentile": 0.64073}, "CVE-2024-3022": {"epss_score": 0.08314, "epss_percentile": 0.91987}, "CVE-2024-3023": {"epss_score": 0.00305, "epss_percentile": 0.53346}, "CVE-2024-3024": {"epss_score": 0.0008, "epss_percentile": 0.24128}, "CVE-2024-3025": {"epss_score": 0.0023, "epss_percentile": 0.45685}, "CVE-2024-3026": {"epss_score": 0.00318, "epss_percentile": 0.5446}, "CVE-2024-3027": {"epss_score": 0.00115, "epss_percentile": 0.30954}, "CVE-2024-3028": {"epss_score": 0.00194, "epss_percentile": 0.41581}, "CVE-2024-3029": {"epss_score": 0.00206, "epss_percentile": 0.42928}, "CVE-2024-3030": {"epss_score": 0.00144, "epss_percentile": 0.3532}, "CVE-2024-3031": {"epss_score": 0.00288, "epss_percentile": 0.51871}, "CVE-2024-3032": {"epss_score": 0.02477, "epss_percentile": 0.84865}, "CVE-2024-3033": {"epss_score": 0.00145, "epss_percentile": 0.35373}, "CVE-2024-3034": {"epss_score": 0.00563, "epss_percentile": 0.67734}, "CVE-2024-3035": {"epss_score": 0.00044, "epss_percentile": 0.13495}, "CVE-2024-3036": {"epss_score": 0.00114, "epss_percentile": 0.30864}, "CVE-2024-3037": {"epss_score": 0.00117, "epss_percentile": 0.31263}, "CVE-2024-3039": {"epss_score": 0.00042, "epss_percentile": 0.12805}, "CVE-2024-3040": {"epss_score": 0.00053, "epss_percentile": 0.17007}, "CVE-2024-3041": {"epss_score": 0.00052, "epss_percentile": 0.16591}, "CVE-2024-3042": {"epss_score": 0.00118, "epss_percentile": 0.31416}, "CVE-2024-3043": {"epss_score": 0.00131, "epss_percentile": 0.33492}, "CVE-2024-3044": {"epss_score": 0.02355, "epss_percentile": 0.84482}, "CVE-2024-3045": {"epss_score": 0.02266, "epss_percentile": 0.84199}, "CVE-2024-3046": {"epss_score": 0.00176, "epss_percentile": 0.39442}, "CVE-2024-3047": {"epss_score": 0.00454, "epss_percentile": 0.63241}, "CVE-2024-3048": {"epss_score": 0.0017, "epss_percentile": 0.38722}, "CVE-2024-3049": {"epss_score": 0.01032, "epss_percentile": 0.76864}, "CVE-2024-3050": {"epss_score": 0.00756, "epss_percentile": 0.72731}, "CVE-2024-3051": {"epss_score": 0.00127, "epss_percentile": 0.32884}, "CVE-2024-3052": {"epss_score": 0.00188, "epss_percentile": 0.40846}, "CVE-2024-3053": {"epss_score": 0.00127, "epss_percentile": 0.3291}, "CVE-2024-3054": {"epss_score": 0.20504, "epss_percentile": 0.95357}, "CVE-2024-3055": {"epss_score": 0.00418, "epss_percentile": 0.61345}, "CVE-2024-3056": {"epss_score": 0.00466, "epss_percentile": 0.63795}, "CVE-2024-3057": {"epss_score": 0.0025, "epss_percentile": 0.48251}, "CVE-2024-3058": {"epss_score": 0.00197, "epss_percentile": 0.41858}, "CVE-2024-3059": {"epss_score": 0.00151, "epss_percentile": 0.36321}, "CVE-2024-3060": {"epss_score": 0.00181, "epss_percentile": 0.40098}, "CVE-2024-3061": {"epss_score": 0.00847, "epss_percentile": 0.74346}, "CVE-2024-3062": {"epss_score": 0.00051, "epss_percentile": 0.16337}, "CVE-2024-3063": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-3064": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-3065": {"epss_score": 0.00288, "epss_percentile": 0.51871}, "CVE-2024-3066": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-3067": {"epss_score": 0.00854, "epss_percentile": 0.74448}, "CVE-2024-3068": {"epss_score": 0.005, "epss_percentile": 0.65323}, "CVE-2024-3070": {"epss_score": 0.02638, "epss_percentile": 0.85297}, "CVE-2024-3071": {"epss_score": 0.00187, "epss_percentile": 0.40805}, "CVE-2024-3072": {"epss_score": 0.00119, "epss_percentile": 0.31582}, "CVE-2024-3073": {"epss_score": 0.00313, "epss_percentile": 0.5406}, "CVE-2024-3074": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-3075": {"epss_score": 0.00536, "epss_percentile": 0.66844}, "CVE-2024-3076": {"epss_score": 0.00145, "epss_percentile": 0.3546}, "CVE-2024-3077": {"epss_score": 0.00193, "epss_percentile": 0.41461}, "CVE-2024-3078": {"epss_score": 0.00219, "epss_percentile": 0.44483}, "CVE-2024-3079": {"epss_score": 0.03547, "epss_percentile": 0.8733}, "CVE-2024-3080": {"epss_score": 0.57883, "epss_percentile": 0.9809}, "CVE-2024-3081": {"epss_score": 0.00073, "epss_percentile": 0.22569}, "CVE-2024-3082": {"epss_score": 0.00066, "epss_percentile": 0.2074}, "CVE-2024-3083": {"epss_score": 0.01324, "epss_percentile": 0.79461}, "CVE-2024-3084": {"epss_score": 0.00102, "epss_percentile": 0.28754}, "CVE-2024-3085": {"epss_score": 0.00052, "epss_percentile": 0.16394}, "CVE-2024-3086": {"epss_score": 0.00088, "epss_percentile": 0.25677}, "CVE-2024-3087": {"epss_score": 0.00052, "epss_percentile": 0.16394}, "CVE-2024-3088": {"epss_score": 0.00049, "epss_percentile": 0.15471}, "CVE-2024-3089": {"epss_score": 0.0017, "epss_percentile": 0.38715}, "CVE-2024-3090": {"epss_score": 0.00091, "epss_percentile": 0.26381}, "CVE-2024-3091": {"epss_score": 0.00106, "epss_percentile": 0.29541}, "CVE-2024-3092": {"epss_score": 0.00667, "epss_percentile": 0.70712}, "CVE-2024-3094": {"epss_score": 0.85995, "epss_percentile": 0.99361}, "CVE-2024-3095": {"epss_score": 0.00163, "epss_percentile": 0.37773}, "CVE-2024-3096": {"epss_score": 0.01069, "epss_percentile": 0.77249}, "CVE-2024-3097": {"epss_score": 0.27418, "epss_percentile": 0.96244}, "CVE-2024-3098": {"epss_score": 0.00188, "epss_percentile": 0.40907}, "CVE-2024-3099": {"epss_score": 0.00063, "epss_percentile": 0.1986}, "CVE-2024-3100": {"epss_score": 0.00076, "epss_percentile": 0.23213}, "CVE-2024-3101": {"epss_score": 0.00107, "epss_percentile": 0.29583}, "CVE-2024-3102": {"epss_score": 0.0017, "epss_percentile": 0.38723}, "CVE-2024-3104": {"epss_score": 0.06578, "epss_percentile": 0.90859}, "CVE-2024-3105": {"epss_score": 0.57854, "epss_percentile": 0.98086}, "CVE-2024-3107": {"epss_score": 0.00427, "epss_percentile": 0.61885}, "CVE-2024-3108": {"epss_score": 0.0003, "epss_percentile": 0.08236}, "CVE-2024-3109": {"epss_score": 0.00054, "epss_percentile": 0.17273}, "CVE-2024-3110": {"epss_score": 0.00216, "epss_percentile": 0.44198}, "CVE-2024-3111": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-3112": {"epss_score": 0.0019, "epss_percentile": 0.411}, "CVE-2024-3113": {"epss_score": 0.00167, "epss_percentile": 0.38377}, "CVE-2024-3114": {"epss_score": 0.0015, "epss_percentile": 0.36098}, "CVE-2024-3115": {"epss_score": 0.00134, "epss_percentile": 0.33837}, "CVE-2024-3116": {"epss_score": 0.90682, "epss_percentile": 0.99595}, "CVE-2024-3117": {"epss_score": 0.00025, "epss_percentile": 0.06252}, "CVE-2024-3118": {"epss_score": 0.00043, "epss_percentile": 0.13021}, "CVE-2024-3119": {"epss_score": 0.01895, "epss_percentile": 0.82748}, "CVE-2024-3120": {"epss_score": 0.01895, "epss_percentile": 0.82748}, "CVE-2024-3121": {"epss_score": 0.0015, "epss_percentile": 0.36075}, "CVE-2024-3122": {"epss_score": 0.00107, "epss_percentile": 0.29685}, "CVE-2024-3123": {"epss_score": 0.0056, "epss_percentile": 0.67646}, "CVE-2024-3124": {"epss_score": 0.00023, "epss_percentile": 0.05502}, "CVE-2024-3125": {"epss_score": 0.00054, "epss_percentile": 0.17247}, "CVE-2024-3126": {"epss_score": 0.01496, "epss_percentile": 0.80681}, "CVE-2024-3127": {"epss_score": 0.0003, "epss_percentile": 0.08264}, "CVE-2024-3128": {"epss_score": 0.00023, "epss_percentile": 0.05502}, "CVE-2024-3129": {"epss_score": 0.00079, "epss_percentile": 0.23856}, "CVE-2024-3130": {"epss_score": 0.0002, "epss_percentile": 0.04594}, "CVE-2024-3131": {"epss_score": 0.00061, "epss_percentile": 0.19421}, "CVE-2024-3134": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-3135": {"epss_score": 0.00112, "epss_percentile": 0.30557}, "CVE-2024-3136": {"epss_score": 0.45313, "epss_percentile": 0.97482}, "CVE-2024-3137": {"epss_score": 0.00137, "epss_percentile": 0.34326}, "CVE-2024-3138": {"epss_score": 0.00165, "epss_percentile": 0.3805}, "CVE-2024-3139": {"epss_score": 0.00076, "epss_percentile": 0.23106}, "CVE-2024-3140": {"epss_score": 0.00167, "epss_percentile": 0.38364}, "CVE-2024-3141": {"epss_score": 0.00193, "epss_percentile": 0.41399}, "CVE-2024-3142": {"epss_score": 0.00199, "epss_percentile": 0.42158}, "CVE-2024-3143": {"epss_score": 0.00118, "epss_percentile": 0.31483}, "CVE-2024-3144": {"epss_score": 0.00097, "epss_percentile": 0.27462}, "CVE-2024-3145": {"epss_score": 0.00097, "epss_percentile": 0.27462}, "CVE-2024-3146": {"epss_score": 0.00116, "epss_percentile": 0.31189}, "CVE-2024-3147": {"epss_score": 0.00097, "epss_percentile": 0.27462}, "CVE-2024-3148": {"epss_score": 0.00288, "epss_percentile": 0.51938}, "CVE-2024-3149": {"epss_score": 0.00132, "epss_percentile": 0.33602}, "CVE-2024-3150": {"epss_score": 0.00552, "epss_percentile": 0.67403}, "CVE-2024-3151": {"epss_score": 0.00111, "epss_percentile": 0.30395}, "CVE-2024-3152": {"epss_score": 0.00133, "epss_percentile": 0.3365}, "CVE-2024-3153": {"epss_score": 0.00106, "epss_percentile": 0.29433}, "CVE-2024-3154": {"epss_score": 0.00491, "epss_percentile": 0.6496}, "CVE-2024-3155": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-3156": {"epss_score": 0.01387, "epss_percentile": 0.79919}, "CVE-2024-3157": {"epss_score": 0.00703, "epss_percentile": 0.71545}, "CVE-2024-3158": {"epss_score": 0.00944, "epss_percentile": 0.75791}, "CVE-2024-3159": {"epss_score": 0.06301, "epss_percentile": 0.90657}, "CVE-2024-3160": {"epss_score": 0.0011, "epss_percentile": 0.30202}, "CVE-2024-3161": {"epss_score": 0.00224, "epss_percentile": 0.44971}, "CVE-2024-3162": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-3163": {"epss_score": 0.00171, "epss_percentile": 0.38872}, "CVE-2024-3164": {"epss_score": 0.00233, "epss_percentile": 0.46025}, "CVE-2024-3165": {"epss_score": 0.00164, "epss_percentile": 0.37905}, "CVE-2024-3166": {"epss_score": 0.00287, "epss_percentile": 0.51816}, "CVE-2024-3167": {"epss_score": 0.00195, "epss_percentile": 0.41667}, "CVE-2024-3168": {"epss_score": 0.01295, "epss_percentile": 0.79249}, "CVE-2024-3169": {"epss_score": 0.00697, "epss_percentile": 0.71404}, "CVE-2024-3170": {"epss_score": 0.00738, "epss_percentile": 0.7234}, "CVE-2024-3171": {"epss_score": 0.01085, "epss_percentile": 0.77401}, "CVE-2024-3172": {"epss_score": 0.0077, "epss_percentile": 0.72998}, "CVE-2024-3173": {"epss_score": 0.00504, "epss_percentile": 0.65548}, "CVE-2024-3174": {"epss_score": 0.00701, "epss_percentile": 0.71499}, "CVE-2024-3175": {"epss_score": 0.00457, "epss_percentile": 0.63378}, "CVE-2024-3176": {"epss_score": 0.00697, "epss_percentile": 0.71404}, "CVE-2024-3177": {"epss_score": 0.06395, "epss_percentile": 0.90722}, "CVE-2024-3178": {"epss_score": 0.00104, "epss_percentile": 0.2921}, "CVE-2024-3179": {"epss_score": 0.00104, "epss_percentile": 0.2921}, "CVE-2024-3180": {"epss_score": 0.00104, "epss_percentile": 0.2921}, "CVE-2024-3181": {"epss_score": 0.00104, "epss_percentile": 0.2921}, "CVE-2024-3182": {"epss_score": 0.00124, "epss_percentile": 0.32351}, "CVE-2024-3183": {"epss_score": 0.21232, "epss_percentile": 0.95482}, "CVE-2024-3184": {"epss_score": 0.0043, "epss_percentile": 0.6201}, "CVE-2024-3185": {"epss_score": 0.0003, "epss_percentile": 0.08295}, "CVE-2024-3186": {"epss_score": 0.00679, "epss_percentile": 0.71006}, "CVE-2024-3187": {"epss_score": 0.04265, "epss_percentile": 0.88468}, "CVE-2024-3188": {"epss_score": 0.00193, "epss_percentile": 0.41389}, "CVE-2024-3189": {"epss_score": 0.00163, "epss_percentile": 0.37771}, "CVE-2024-3190": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-3191": {"epss_score": 0.03287, "epss_percentile": 0.86829}, "CVE-2024-3192": {"epss_score": 0.00167, "epss_percentile": 0.3838}, "CVE-2024-3193": {"epss_score": 0.02213, "epss_percentile": 0.84023}, "CVE-2024-3194": {"epss_score": 0.00158, "epss_percentile": 0.37221}, "CVE-2024-3195": {"epss_score": 0.00151, "epss_percentile": 0.3629}, "CVE-2024-3196": {"epss_score": 0.00375, "epss_percentile": 0.58606}, "CVE-2024-3197": {"epss_score": 0.00243, "epss_percentile": 0.47419}, "CVE-2024-3198": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-3199": {"epss_score": 0.00284, "epss_percentile": 0.51488}, "CVE-2024-3200": {"epss_score": 0.01029, "epss_percentile": 0.76829}, "CVE-2024-3201": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-3202": {"epss_score": 0.00335, "epss_percentile": 0.55835}, "CVE-2024-3203": {"epss_score": 0.00312, "epss_percentile": 0.53945}, "CVE-2024-3204": {"epss_score": 0.00312, "epss_percentile": 0.53945}, "CVE-2024-3206": {"epss_score": 0.00237, "epss_percentile": 0.46659}, "CVE-2024-3207": {"epss_score": 0.00152, "epss_percentile": 0.36448}, "CVE-2024-3208": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-3209": {"epss_score": 0.00271, "epss_percentile": 0.50276}, "CVE-2024-3210": {"epss_score": 0.00397, "epss_percentile": 0.59962}, "CVE-2024-3211": {"epss_score": 0.00311, "epss_percentile": 0.53817}, "CVE-2024-3213": {"epss_score": 0.00332, "epss_percentile": 0.5557}, "CVE-2024-3214": {"epss_score": 0.0184, "epss_percentile": 0.8249}, "CVE-2024-3215": {"epss_score": 0.00188, "epss_percentile": 0.40901}, "CVE-2024-3216": {"epss_score": 0.00221, "epss_percentile": 0.44661}, "CVE-2024-3217": {"epss_score": 0.47228, "epss_percentile": 0.97577}, "CVE-2024-3218": {"epss_score": 0.0007, "epss_percentile": 0.21754}, "CVE-2024-3219": {"epss_score": 0.00062, "epss_percentile": 0.19565}, "CVE-2024-3220": {"epss_score": 0.00259, "epss_percentile": 0.49071}, "CVE-2024-3221": {"epss_score": 0.00101, "epss_percentile": 0.28696}, "CVE-2024-3222": {"epss_score": 0.00101, "epss_percentile": 0.28696}, "CVE-2024-3223": {"epss_score": 0.00096, "epss_percentile": 0.27418}, "CVE-2024-3224": {"epss_score": 0.00134, "epss_percentile": 0.33755}, "CVE-2024-3225": {"epss_score": 0.00117, "epss_percentile": 0.31368}, "CVE-2024-3226": {"epss_score": 0.00093, "epss_percentile": 0.26609}, "CVE-2024-3227": {"epss_score": 0.00151, "epss_percentile": 0.3629}, "CVE-2024-3228": {"epss_score": 0.0061, "epss_percentile": 0.69158}, "CVE-2024-3229": {"epss_score": 0.08746, "epss_percentile": 0.92238}, "CVE-2024-3230": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-3231": {"epss_score": 0.01685, "epss_percentile": 0.81748}, "CVE-2024-3232": {"epss_score": 0.01943, "epss_percentile": 0.82993}, "CVE-2024-3233": {"epss_score": 0.00187, "epss_percentile": 0.40805}, "CVE-2024-3234": {"epss_score": 0.69547, "epss_percentile": 0.98593}, "CVE-2024-3235": {"epss_score": 0.0081, "epss_percentile": 0.7372}, "CVE-2024-3236": {"epss_score": 0.00219, "epss_percentile": 0.44518}, "CVE-2024-3237": {"epss_score": 0.00048, "epss_percentile": 0.14999}, "CVE-2024-3238": {"epss_score": 0.00754, "epss_percentile": 0.72703}, "CVE-2024-3239": {"epss_score": 0.00249, "epss_percentile": 0.48073}, "CVE-2024-3240": {"epss_score": 0.00704, "epss_percentile": 0.71568}, "CVE-2024-3241": {"epss_score": 0.00326, "epss_percentile": 0.55054}, "CVE-2024-3242": {"epss_score": 0.06631, "epss_percentile": 0.90903}, "CVE-2024-3243": {"epss_score": 0.00132, "epss_percentile": 0.33531}, "CVE-2024-3244": {"epss_score": 0.00488, "epss_percentile": 0.64832}, "CVE-2024-3245": {"epss_score": 0.00114, "epss_percentile": 0.30783}, "CVE-2024-3246": {"epss_score": 0.0025, "epss_percentile": 0.48095}, "CVE-2024-3247": {"epss_score": 0.00023, "epss_percentile": 0.05443}, "CVE-2024-3248": {"epss_score": 0.00074, "epss_percentile": 0.22812}, "CVE-2024-3249": {"epss_score": 0.00209, "epss_percentile": 0.43323}, "CVE-2024-3250": {"epss_score": 0.00053, "epss_percentile": 0.16966}, "CVE-2024-3251": {"epss_score": 0.00101, "epss_percentile": 0.28696}, "CVE-2024-3252": {"epss_score": 0.00114, "epss_percentile": 0.30823}, "CVE-2024-3253": {"epss_score": 0.00105, "epss_percentile": 0.29283}, "CVE-2024-3254": {"epss_score": 0.00126, "epss_percentile": 0.32644}, "CVE-2024-3255": {"epss_score": 0.0006, "epss_percentile": 0.19082}, "CVE-2024-3256": {"epss_score": 0.00122, "epss_percentile": 0.32029}, "CVE-2024-3257": {"epss_score": 0.00122, "epss_percentile": 0.32029}, "CVE-2024-3258": {"epss_score": 0.00122, "epss_percentile": 0.32029}, "CVE-2024-3259": {"epss_score": 0.00111, "epss_percentile": 0.30253}, "CVE-2024-3261": {"epss_score": 0.00204, "epss_percentile": 0.4261}, "CVE-2024-3262": {"epss_score": 0.00016, "epss_percentile": 0.03053}, "CVE-2024-3263": {"epss_score": 0.00304, "epss_percentile": 0.5326}, "CVE-2024-3264": {"epss_score": 0.00089, "epss_percentile": 0.25876}, "CVE-2024-3265": {"epss_score": 0.00113, "epss_percentile": 0.30615}, "CVE-2024-3266": {"epss_score": 0.00183, "epss_percentile": 0.40342}, "CVE-2024-3267": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-3268": {"epss_score": 0.00336, "epss_percentile": 0.55935}, "CVE-2024-3269": {"epss_score": 0.00136, "epss_percentile": 0.34179}, "CVE-2024-3270": {"epss_score": 0.00058, "epss_percentile": 0.18367}, "CVE-2024-3271": {"epss_score": 0.0227, "epss_percentile": 0.84205}, "CVE-2024-3272": {"epss_score": 0.94168, "epss_percentile": 0.99911}, "CVE-2024-3273": {"epss_score": 0.94425, "epss_percentile": 0.9998}, "CVE-2024-3274": {"epss_score": 0.57871, "epss_percentile": 0.98088}, "CVE-2024-3275": {"epss_score": 0.00243, "epss_percentile": 0.47452}, "CVE-2024-3276": {"epss_score": 0.00223, "epss_percentile": 0.44862}, "CVE-2024-3277": {"epss_score": 0.00188, "epss_percentile": 0.40889}, "CVE-2024-3279": {"epss_score": 0.00261, "epss_percentile": 0.49286}, "CVE-2024-3280": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-3281": {"epss_score": 0.00047, "epss_percentile": 0.14628}, "CVE-2024-3282": {"epss_score": 0.0012, "epss_percentile": 0.31796}, "CVE-2024-3283": {"epss_score": 0.00176, "epss_percentile": 0.3949}, "CVE-2024-3285": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-3286": {"epss_score": 0.00662, "epss_percentile": 0.70595}, "CVE-2024-3287": {"epss_score": 0.00585, "epss_percentile": 0.68401}, "CVE-2024-3288": {"epss_score": 0.00607, "epss_percentile": 0.69041}, "CVE-2024-3289": {"epss_score": 0.00104, "epss_percentile": 0.29135}, "CVE-2024-3290": {"epss_score": 0.00086, "epss_percentile": 0.25386}, "CVE-2024-3291": {"epss_score": 0.00041, "epss_percentile": 0.12458}, "CVE-2024-3292": {"epss_score": 0.00043, "epss_percentile": 0.13264}, "CVE-2024-3293": {"epss_score": 0.26613, "epss_percentile": 0.96162}, "CVE-2024-3295": {"epss_score": 0.00751, "epss_percentile": 0.72641}, "CVE-2024-3296": {"epss_score": 0.00079, "epss_percentile": 0.23989}, "CVE-2024-3297": {"epss_score": 0.00085, "epss_percentile": 0.25038}, "CVE-2024-3298": {"epss_score": 0.00073, "epss_percentile": 0.22534}, "CVE-2024-3299": {"epss_score": 0.00123, "epss_percentile": 0.32305}, "CVE-2024-3300": {"epss_score": 0.39776, "epss_percentile": 0.9718}, "CVE-2024-3301": {"epss_score": 0.08576, "epss_percentile": 0.9213}, "CVE-2024-3302": {"epss_score": 0.00107, "epss_percentile": 0.29591}, "CVE-2024-3303": {"epss_score": 0.00376, "epss_percentile": 0.58676}, "CVE-2024-3305": {"epss_score": 0.00056, "epss_percentile": 0.17702}, "CVE-2024-3306": {"epss_score": 0.00051, "epss_percentile": 0.16324}, "CVE-2024-3307": {"epss_score": 0.00206, "epss_percentile": 0.42931}, "CVE-2024-3308": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-3309": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-3311": {"epss_score": 0.00281, "epss_percentile": 0.51141}, "CVE-2024-3312": {"epss_score": 0.0081, "epss_percentile": 0.7372}, "CVE-2024-3313": {"epss_score": 0.00099, "epss_percentile": 0.28379}, "CVE-2024-3314": {"epss_score": 0.00152, "epss_percentile": 0.36454}, "CVE-2024-3315": {"epss_score": 0.00114, "epss_percentile": 0.30823}, "CVE-2024-3316": {"epss_score": 0.00112, "epss_percentile": 0.30492}, "CVE-2024-3317": {"epss_score": 0.0006, "epss_percentile": 0.19032}, "CVE-2024-3318": {"epss_score": 0.00216, "epss_percentile": 0.44136}, "CVE-2024-3319": {"epss_score": 0.03831, "epss_percentile": 0.87807}, "CVE-2024-3320": {"epss_score": 0.00137, "epss_percentile": 0.3426}, "CVE-2024-3321": {"epss_score": 0.00119, "epss_percentile": 0.31596}, "CVE-2024-3322": {"epss_score": 0.00794, "epss_percentile": 0.73458}, "CVE-2024-3323": {"epss_score": 0.00078, "epss_percentile": 0.23651}, "CVE-2024-3325": {"epss_score": 0.00582, "epss_percentile": 0.68292}, "CVE-2024-3330": {"epss_score": 0.00327, "epss_percentile": 0.55134}, "CVE-2024-3331": {"epss_score": 0.00124, "epss_percentile": 0.32357}, "CVE-2024-3332": {"epss_score": 0.00228, "epss_percentile": 0.45484}, "CVE-2024-3333": {"epss_score": 0.00243, "epss_percentile": 0.47431}, "CVE-2024-3334": {"epss_score": 0.00031, "epss_percentile": 0.0863}, "CVE-2024-3337": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-3338": {"epss_score": 0.00243, "epss_percentile": 0.47419}, "CVE-2024-3340": {"epss_score": 0.0025, "epss_percentile": 0.48253}, "CVE-2024-3341": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2024-3342": {"epss_score": 0.00311, "epss_percentile": 0.53817}, "CVE-2024-3343": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-3344": {"epss_score": 0.00125, "epss_percentile": 0.32554}, "CVE-2024-3345": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-3346": {"epss_score": 0.00619, "epss_percentile": 0.69402}, "CVE-2024-3347": {"epss_score": 0.00133, "epss_percentile": 0.3374}, "CVE-2024-3348": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-3349": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-3350": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-3351": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-3352": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-3353": {"epss_score": 0.00049, "epss_percentile": 0.15471}, "CVE-2024-3354": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-3355": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-3356": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-3357": {"epss_score": 0.00091, "epss_percentile": 0.26394}, "CVE-2024-3358": {"epss_score": 0.0016, "epss_percentile": 0.37469}, "CVE-2024-3359": {"epss_score": 0.00135, "epss_percentile": 0.3401}, "CVE-2024-3360": {"epss_score": 0.00135, "epss_percentile": 0.3401}, "CVE-2024-3361": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-3362": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-3363": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-3364": {"epss_score": 0.00091, "epss_percentile": 0.26394}, "CVE-2024-3365": {"epss_score": 0.00091, "epss_percentile": 0.26394}, "CVE-2024-3366": {"epss_score": 0.00107, "epss_percentile": 0.29737}, "CVE-2024-3367": {"epss_score": 0.00101, "epss_percentile": 0.28569}, "CVE-2024-3368": {"epss_score": 0.0046, "epss_percentile": 0.63526}, "CVE-2024-3369": {"epss_score": 0.00064, "epss_percentile": 0.20393}, "CVE-2024-3370": {"epss_score": 0.00071, "epss_percentile": 0.22141}, "CVE-2024-3371": {"epss_score": 0.00096, "epss_percentile": 0.27263}, "CVE-2024-3372": {"epss_score": 0.00378, "epss_percentile": 0.58795}, "CVE-2024-3373": {"epss_score": 0.001, "epss_percentile": 0.28494}, "CVE-2024-3374": {"epss_score": 0.00614, "epss_percentile": 0.6927}, "CVE-2024-3375": {"epss_score": 0.00225, "epss_percentile": 0.4515}, "CVE-2024-3376": {"epss_score": 0.00208, "epss_percentile": 0.43268}, "CVE-2024-3377": {"epss_score": 0.00111, "epss_percentile": 0.30269}, "CVE-2024-3378": {"epss_score": 0.03566, "epss_percentile": 0.87366}, "CVE-2024-3379": {"epss_score": 0.00129, "epss_percentile": 0.33146}, "CVE-2024-3382": {"epss_score": 0.00374, "epss_percentile": 0.58534}, "CVE-2024-3383": {"epss_score": 0.00249, "epss_percentile": 0.48052}, "CVE-2024-3384": {"epss_score": 0.00729, "epss_percentile": 0.72134}, "CVE-2024-3385": {"epss_score": 0.02657, "epss_percentile": 0.85359}, "CVE-2024-3386": {"epss_score": 0.00237, "epss_percentile": 0.46465}, "CVE-2024-3387": {"epss_score": 0.00022, "epss_percentile": 0.05307}, "CVE-2024-3388": {"epss_score": 0.0014, "epss_percentile": 0.34776}, "CVE-2024-3393": {"epss_score": 0.66594, "epss_percentile": 0.9847}, "CVE-2024-3400": {"epss_score": 0.94297, "epss_percentile": 0.99939}, "CVE-2024-3402": {"epss_score": 0.00197, "epss_percentile": 0.41844}, "CVE-2024-3403": {"epss_score": 0.02345, "epss_percentile": 0.84448}, "CVE-2024-3404": {"epss_score": 0.00055, "epss_percentile": 0.17503}, "CVE-2024-3405": {"epss_score": 0.00183, "epss_percentile": 0.4029}, "CVE-2024-3406": {"epss_score": 0.00303, "epss_percentile": 0.53223}, "CVE-2024-3407": {"epss_score": 0.00066, "epss_percentile": 0.2088}, "CVE-2024-3408": {"epss_score": 0.83522, "epss_percentile": 0.99252}, "CVE-2024-3410": {"epss_score": 0.00182, "epss_percentile": 0.40216}, "CVE-2024-3411": {"epss_score": 0.00227, "epss_percentile": 0.45402}, "CVE-2024-3412": {"epss_score": 0.08965, "epss_percentile": 0.9234}, "CVE-2024-3413": {"epss_score": 0.00135, "epss_percentile": 0.3401}, "CVE-2024-3414": {"epss_score": 0.00061, "epss_percentile": 0.19535}, "CVE-2024-3415": {"epss_score": 0.00061, "epss_percentile": 0.19535}, "CVE-2024-3416": {"epss_score": 0.0014, "epss_percentile": 0.34715}, "CVE-2024-3417": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-3418": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-3419": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-3420": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-3421": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-3422": {"epss_score": 0.00099, "epss_percentile": 0.28427}, "CVE-2024-3423": {"epss_score": 0.00053, "epss_percentile": 0.1684}, "CVE-2024-3424": {"epss_score": 0.00098, "epss_percentile": 0.27663}, "CVE-2024-3425": {"epss_score": 0.00045, "epss_percentile": 0.13989}, "CVE-2024-3426": {"epss_score": 0.00157, "epss_percentile": 0.37092}, "CVE-2024-3427": {"epss_score": 0.0016, "epss_percentile": 0.37469}, "CVE-2024-3428": {"epss_score": 0.0009, "epss_percentile": 0.26022}, "CVE-2024-3429": {"epss_score": 0.00212, "epss_percentile": 0.43775}, "CVE-2024-3430": {"epss_score": 0.00027, "epss_percentile": 0.06987}, "CVE-2024-3431": {"epss_score": 0.00072, "epss_percentile": 0.22456}, "CVE-2024-3432": {"epss_score": 0.00053, "epss_percentile": 0.1684}, "CVE-2024-3433": {"epss_score": 0.00073, "epss_percentile": 0.22669}, "CVE-2024-3434": {"epss_score": 0.00036, "epss_percentile": 0.10251}, "CVE-2024-3435": {"epss_score": 0.00449, "epss_percentile": 0.63049}, "CVE-2024-3436": {"epss_score": 0.00046, "epss_percentile": 0.14435}, "CVE-2024-3437": {"epss_score": 0.00173, "epss_percentile": 0.39083}, "CVE-2024-3438": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-3439": {"epss_score": 0.00053, "epss_percentile": 0.16749}, "CVE-2024-3440": {"epss_score": 0.00054, "epss_percentile": 0.17298}, "CVE-2024-3441": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-3442": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-3443": {"epss_score": 0.00091, "epss_percentile": 0.26394}, "CVE-2024-3444": {"epss_score": 0.00054, "epss_percentile": 0.17285}, "CVE-2024-3445": {"epss_score": 0.00057, "epss_percentile": 0.1821}, "CVE-2024-3446": {"epss_score": 0.00139, "epss_percentile": 0.34627}, "CVE-2024-3447": {"epss_score": 0.00015, "epss_percentile": 0.02389}, "CVE-2024-3448": {"epss_score": 0.00194, "epss_percentile": 0.41525}, "CVE-2024-3454": {"epss_score": 0.00106, "epss_percentile": 0.2948}, "CVE-2024-3455": {"epss_score": 0.00053, "epss_percentile": 0.1684}, "CVE-2024-3456": {"epss_score": 0.00039, "epss_percentile": 0.11624}, "CVE-2024-3457": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-3458": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-3459": {"epss_score": 0.00084, "epss_percentile": 0.24969}, "CVE-2024-3460": {"epss_score": 0.00054, "epss_percentile": 0.17043}, "CVE-2024-3461": {"epss_score": 0.00011, "epss_percentile": 0.01082}, "CVE-2024-3462": {"epss_score": 0.00087, "epss_percentile": 0.2545}, "CVE-2024-3463": {"epss_score": 0.00096, "epss_percentile": 0.2734}, "CVE-2024-3464": {"epss_score": 0.00055, "epss_percentile": 0.17637}, "CVE-2024-3465": {"epss_score": 0.00055, "epss_percentile": 0.17637}, "CVE-2024-3466": {"epss_score": 0.00055, "epss_percentile": 0.17637}, "CVE-2024-3467": {"epss_score": 0.00139, "epss_percentile": 0.34636}, "CVE-2024-3468": {"epss_score": 0.00397, "epss_percentile": 0.60041}, "CVE-2024-3469": {"epss_score": 0.13807, "epss_percentile": 0.94061}, "CVE-2024-3470": {"epss_score": 0.00042, "epss_percentile": 0.12906}, "CVE-2024-3471": {"epss_score": 0.00106, "epss_percentile": 0.29457}, "CVE-2024-3472": {"epss_score": 0.00064, "epss_percentile": 0.20326}, "CVE-2024-3473": {"epss_score": 0.02533, "epss_percentile": 0.85033}, "CVE-2024-3474": {"epss_score": 0.00324, "epss_percentile": 0.5496}, "CVE-2024-3475": {"epss_score": 0.00146, "epss_percentile": 0.35567}, "CVE-2024-3476": {"epss_score": 0.00413, "epss_percentile": 0.6099}, "CVE-2024-3477": {"epss_score": 0.00124, "epss_percentile": 0.3238}, "CVE-2024-3478": {"epss_score": 0.00073, "epss_percentile": 0.22626}, "CVE-2024-3479": {"epss_score": 0.00065, "epss_percentile": 0.2054}, "CVE-2024-3480": {"epss_score": 0.00065, "epss_percentile": 0.2054}, "CVE-2024-3481": {"epss_score": 0.00137, "epss_percentile": 0.34251}, "CVE-2024-3482": {"epss_score": 0.00253, "epss_percentile": 0.48459}, "CVE-2024-3483": {"epss_score": 0.0024, "epss_percentile": 0.47214}, "CVE-2024-3484": {"epss_score": 0.00382, "epss_percentile": 0.5907}, "CVE-2024-3485": {"epss_score": 0.00252, "epss_percentile": 0.48344}, "CVE-2024-3486": {"epss_score": 0.0305, "epss_percentile": 0.8629}, "CVE-2024-3487": {"epss_score": 0.00088, "epss_percentile": 0.25714}, "CVE-2024-3488": {"epss_score": 0.00154, "epss_percentile": 0.36743}, "CVE-2024-3489": {"epss_score": 0.00803, "epss_percentile": 0.73605}, "CVE-2024-3490": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-3491": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-3492": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-3493": {"epss_score": 0.00056, "epss_percentile": 0.17712}, "CVE-2024-3494": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-3495": {"epss_score": 0.93458, "epss_percentile": 0.99809}, "CVE-2024-3496": {"epss_score": 0.00071, "epss_percentile": 0.22181}, "CVE-2024-3497": {"epss_score": 0.00191, "epss_percentile": 0.41143}, "CVE-2024-3498": {"epss_score": 0.00105, "epss_percentile": 0.29356}, "CVE-2024-3499": {"epss_score": 0.0166, "epss_percentile": 0.8162}, "CVE-2024-3500": {"epss_score": 0.01017, "epss_percentile": 0.76698}, "CVE-2024-3501": {"epss_score": 0.00164, "epss_percentile": 0.37969}, "CVE-2024-3502": {"epss_score": 0.00169, "epss_percentile": 0.38608}, "CVE-2024-3504": {"epss_score": 0.00137, "epss_percentile": 0.3434}, "CVE-2024-3505": {"epss_score": 0.00461, "epss_percentile": 0.63565}, "CVE-2024-3506": {"epss_score": 0.0009, "epss_percentile": 0.261}, "CVE-2024-3507": {"epss_score": 0.00192, "epss_percentile": 0.41303}, "CVE-2024-3508": {"epss_score": 0.00085, "epss_percentile": 0.25052}, "CVE-2024-3509": {"epss_score": 0.00024, "epss_percentile": 0.05679}, "CVE-2024-3511": {"epss_score": 0.00027, "epss_percentile": 0.06982}, "CVE-2024-3513": {"epss_score": 0.00218, "epss_percentile": 0.44439}, "CVE-2024-3515": {"epss_score": 0.00199, "epss_percentile": 0.42114}, "CVE-2024-3516": {"epss_score": 0.00455, "epss_percentile": 0.63313}, "CVE-2024-3517": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-3518": {"epss_score": 0.01134, "epss_percentile": 0.77888}, "CVE-2024-3519": {"epss_score": 0.01989, "epss_percentile": 0.83172}, "CVE-2024-3520": {"epss_score": 0.00187, "epss_percentile": 0.40805}, "CVE-2024-3521": {"epss_score": 0.00083, "epss_percentile": 0.24815}, "CVE-2024-3522": {"epss_score": 0.00126, "epss_percentile": 0.32669}, "CVE-2024-3523": {"epss_score": 0.00126, "epss_percentile": 0.32669}, "CVE-2024-3524": {"epss_score": 0.00164, "epss_percentile": 0.37975}, "CVE-2024-3525": {"epss_score": 0.00074, "epss_percentile": 0.22732}, "CVE-2024-3526": {"epss_score": 0.00296, "epss_percentile": 0.52538}, "CVE-2024-3528": {"epss_score": 0.00386, "epss_percentile": 0.5928}, "CVE-2024-3529": {"epss_score": 0.00131, "epss_percentile": 0.33449}, "CVE-2024-3530": {"epss_score": 0.00386, "epss_percentile": 0.5928}, "CVE-2024-3531": {"epss_score": 0.00218, "epss_percentile": 0.44415}, "CVE-2024-3532": {"epss_score": 0.00218, "epss_percentile": 0.44415}, "CVE-2024-3533": {"epss_score": 0.00218, "epss_percentile": 0.44415}, "CVE-2024-3534": {"epss_score": 0.00126, "epss_percentile": 0.3266}, "CVE-2024-3535": {"epss_score": 0.00126, "epss_percentile": 0.3266}, "CVE-2024-3536": {"epss_score": 0.00292, "epss_percentile": 0.52279}, "CVE-2024-3537": {"epss_score": 0.00221, "epss_percentile": 0.44649}, "CVE-2024-3538": {"epss_score": 0.00221, "epss_percentile": 0.44649}, "CVE-2024-3539": {"epss_score": 0.00292, "epss_percentile": 0.52279}, "CVE-2024-3540": {"epss_score": 0.00292, "epss_percentile": 0.52279}, "CVE-2024-3541": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-3542": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-3543": {"epss_score": 0.00131, "epss_percentile": 0.33369}, "CVE-2024-3544": {"epss_score": 0.00242, "epss_percentile": 0.47398}, "CVE-2024-3545": {"epss_score": 0.00151, "epss_percentile": 0.3631}, "CVE-2024-3546": {"epss_score": 0.00307, "epss_percentile": 0.53492}, "CVE-2024-3547": {"epss_score": 0.01149, "epss_percentile": 0.78023}, "CVE-2024-3548": {"epss_score": 0.00246, "epss_percentile": 0.4778}, "CVE-2024-3549": {"epss_score": 0.00634, "epss_percentile": 0.69791}, "CVE-2024-3550": {"epss_score": 0.00254, "epss_percentile": 0.4852}, "CVE-2024-3551": {"epss_score": 0.01143, "epss_percentile": 0.77983}, "CVE-2024-3552": {"epss_score": 0.93576, "epss_percentile": 0.9982}, "CVE-2024-3553": {"epss_score": 0.00298, "epss_percentile": 0.52782}, "CVE-2024-3554": {"epss_score": 0.00265, "epss_percentile": 0.49764}, "CVE-2024-3555": {"epss_score": 0.00737, "epss_percentile": 0.72328}, "CVE-2024-3557": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-3558": {"epss_score": 0.00894, "epss_percentile": 0.75083}, "CVE-2024-3559": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-3560": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-3561": {"epss_score": 0.00975, "epss_percentile": 0.76195}, "CVE-2024-3562": {"epss_score": 0.0113, "epss_percentile": 0.77851}, "CVE-2024-3563": {"epss_score": 0.00298, "epss_percentile": 0.52797}, "CVE-2024-3564": {"epss_score": 0.00706, "epss_percentile": 0.71606}, "CVE-2024-3565": {"epss_score": 0.00361, "epss_percentile": 0.57745}, "CVE-2024-3566": {"epss_score": 0.05349, "epss_percentile": 0.89772}, "CVE-2024-3567": {"epss_score": 0.00085, "epss_percentile": 0.251}, "CVE-2024-3568": {"epss_score": 0.25494, "epss_percentile": 0.96034}, "CVE-2024-3569": {"epss_score": 0.00144, "epss_percentile": 0.35236}, "CVE-2024-3570": {"epss_score": 0.00089, "epss_percentile": 0.25945}, "CVE-2024-3571": {"epss_score": 0.01741, "epss_percentile": 0.82045}, "CVE-2024-3572": {"epss_score": 0.00157, "epss_percentile": 0.37127}, "CVE-2024-3573": {"epss_score": 0.0026, "epss_percentile": 0.49165}, "CVE-2024-3574": {"epss_score": 0.00121, "epss_percentile": 0.31989}, "CVE-2024-3575": {"epss_score": 0.00188, "epss_percentile": 0.40843}, "CVE-2024-3576": {"epss_score": 0.00096, "epss_percentile": 0.27443}, "CVE-2024-3579": {"epss_score": 0.00388, "epss_percentile": 0.59395}, "CVE-2024-3580": {"epss_score": 0.00177, "epss_percentile": 0.39521}, "CVE-2024-3581": {"epss_score": 0.00227, "epss_percentile": 0.45428}, "CVE-2024-3582": {"epss_score": 0.00098, "epss_percentile": 0.27664}, "CVE-2024-3583": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-3584": {"epss_score": 0.00388, "epss_percentile": 0.59376}, "CVE-2024-3585": {"epss_score": 0.00932, "epss_percentile": 0.75625}, "CVE-2024-3587": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-3588": {"epss_score": 0.00289, "epss_percentile": 0.5204}, "CVE-2024-3590": {"epss_score": 0.00233, "epss_percentile": 0.46062}, "CVE-2024-3591": {"epss_score": 0.00411, "epss_percentile": 0.6088}, "CVE-2024-3592": {"epss_score": 0.00572, "epss_percentile": 0.68025}, "CVE-2024-3593": {"epss_score": 0.00083, "epss_percentile": 0.24766}, "CVE-2024-3594": {"epss_score": 0.01296, "epss_percentile": 0.79257}, "CVE-2024-3595": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-3596": {"epss_score": 0.23847, "epss_percentile": 0.95822}, "CVE-2024-3597": {"epss_score": 0.00269, "epss_percentile": 0.5019}, "CVE-2024-3598": {"epss_score": 0.00184, "epss_percentile": 0.40425}, "CVE-2024-3599": {"epss_score": 0.00159, "epss_percentile": 0.37345}, "CVE-2024-3600": {"epss_score": 0.00836, "epss_percentile": 0.74147}, "CVE-2024-3601": {"epss_score": 0.00531, "epss_percentile": 0.66645}, "CVE-2024-3602": {"epss_score": 0.00188, "epss_percentile": 0.40889}, "CVE-2024-3603": {"epss_score": 0.00337, "epss_percentile": 0.56023}, "CVE-2024-3604": {"epss_score": 0.00692, "epss_percentile": 0.71305}, "CVE-2024-3605": {"epss_score": 0.42845, "epss_percentile": 0.97358}, "CVE-2024-3606": {"epss_score": 0.00187, "epss_percentile": 0.40805}, "CVE-2024-3607": {"epss_score": 0.00204, "epss_percentile": 0.42621}, "CVE-2024-3608": {"epss_score": 0.00351, "epss_percentile": 0.57073}, "CVE-2024-3609": {"epss_score": 0.00219, "epss_percentile": 0.44535}, "CVE-2024-3610": {"epss_score": 0.00335, "epss_percentile": 0.55843}, "CVE-2024-3611": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-3612": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2024-3613": {"epss_score": 0.0007, "epss_percentile": 0.2174}, "CVE-2024-3614": {"epss_score": 0.00091, "epss_percentile": 0.2624}, "CVE-2024-3615": {"epss_score": 0.01095, "epss_percentile": 0.775}, "CVE-2024-3616": {"epss_score": 0.00119, "epss_percentile": 0.3159}, "CVE-2024-3617": {"epss_score": 0.00093, "epss_percentile": 0.26711}, "CVE-2024-3618": {"epss_score": 0.00093, "epss_percentile": 0.26711}, "CVE-2024-3619": {"epss_score": 0.00077, "epss_percentile": 0.2343}, "CVE-2024-3620": {"epss_score": 0.00082, "epss_percentile": 0.245}, "CVE-2024-3621": {"epss_score": 0.00079, "epss_percentile": 0.23961}, "CVE-2024-3622": {"epss_score": 0.00118, "epss_percentile": 0.31442}, "CVE-2024-3623": {"epss_score": 0.00091, "epss_percentile": 0.26411}, "CVE-2024-3624": {"epss_score": 0.00037, "epss_percentile": 0.10958}, "CVE-2024-3625": {"epss_score": 0.00037, "epss_percentile": 0.10958}, "CVE-2024-3626": {"epss_score": 0.00376, "epss_percentile": 0.58659}, "CVE-2024-3627": {"epss_score": 0.00136, "epss_percentile": 0.34104}, "CVE-2024-3628": {"epss_score": 0.00217, "epss_percentile": 0.44242}, "CVE-2024-3629": {"epss_score": 0.00195, "epss_percentile": 0.41678}, "CVE-2024-3630": {"epss_score": 0.00459, "epss_percentile": 0.63465}, "CVE-2024-3631": {"epss_score": 0.0028, "epss_percentile": 0.51089}, "CVE-2024-3632": {"epss_score": 0.00163, "epss_percentile": 0.37836}, "CVE-2024-3633": {"epss_score": 0.00202, "epss_percentile": 0.42398}, "CVE-2024-3634": {"epss_score": 0.0017, "epss_percentile": 0.38722}, "CVE-2024-3635": {"epss_score": 0.00171, "epss_percentile": 0.38784}, "CVE-2024-3636": {"epss_score": 0.00388, "epss_percentile": 0.59368}, "CVE-2024-3637": {"epss_score": 0.0034, "epss_percentile": 0.56256}, "CVE-2024-3638": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-3639": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-3640": {"epss_score": 0.00434, "epss_percentile": 0.62321}, "CVE-2024-3641": {"epss_score": 0.00538, "epss_percentile": 0.66942}, "CVE-2024-3642": {"epss_score": 0.00199, "epss_percentile": 0.42155}, "CVE-2024-3643": {"epss_score": 0.00433, "epss_percentile": 0.62205}, "CVE-2024-3644": {"epss_score": 0.00164, "epss_percentile": 0.37891}, "CVE-2024-3645": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-3646": {"epss_score": 0.00474, "epss_percentile": 0.64137}, "CVE-2024-3647": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-3648": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-3649": {"epss_score": 0.00249, "epss_percentile": 0.4806}, "CVE-2024-3650": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-3651": {"epss_score": 0.0067, "epss_percentile": 0.7078}, "CVE-2024-3652": {"epss_score": 0.00023, "epss_percentile": 0.05493}, "CVE-2024-3653": {"epss_score": 0.06505, "epss_percentile": 0.90806}, "CVE-2024-3654": {"epss_score": 0.00131, "epss_percentile": 0.33377}, "CVE-2024-3655": {"epss_score": 0.00122, "epss_percentile": 0.32139}, "CVE-2024-3656": {"epss_score": 0.89489, "epss_percentile": 0.99529}, "CVE-2024-3657": {"epss_score": 0.00596, "epss_percentile": 0.68713}, "CVE-2024-3659": {"epss_score": 0.00441, "epss_percentile": 0.62655}, "CVE-2024-3660": {"epss_score": 0.00256, "epss_percentile": 0.48837}, "CVE-2024-3661": {"epss_score": 0.02479, "epss_percentile": 0.84869}, "CVE-2024-3662": {"epss_score": 0.00064, "epss_percentile": 0.20256}, "CVE-2024-3663": {"epss_score": 0.00188, "epss_percentile": 0.40889}, "CVE-2024-3664": {"epss_score": 0.00069, "epss_percentile": 0.21633}, "CVE-2024-3665": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2024-3666": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-3667": {"epss_score": 0.00165, "epss_percentile": 0.38122}, "CVE-2024-3668": {"epss_score": 0.0018, "epss_percentile": 0.39909}, "CVE-2024-3669": {"epss_score": 0.0036, "epss_percentile": 0.57623}, "CVE-2024-3670": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-3671": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-3672": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-3673": {"epss_score": 0.9074, "epss_percentile": 0.99598}, "CVE-2024-3674": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-3675": {"epss_score": 0.00254, "epss_percentile": 0.4852}, "CVE-2024-3676": {"epss_score": 0.00423, "epss_percentile": 0.61605}, "CVE-2024-3677": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-3678": {"epss_score": 0.00437, "epss_percentile": 0.62522}, "CVE-2024-3679": {"epss_score": 0.00867, "epss_percentile": 0.74655}, "CVE-2024-3680": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-3681": {"epss_score": 0.01268, "epss_percentile": 0.79033}, "CVE-2024-3682": {"epss_score": 0.00406, "epss_percentile": 0.60546}, "CVE-2024-3684": {"epss_score": 0.00714, "epss_percentile": 0.71816}, "CVE-2024-3685": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2024-3686": {"epss_score": 0.00146, "epss_percentile": 0.35628}, "CVE-2024-3687": {"epss_score": 0.00075, "epss_percentile": 0.2295}, "CVE-2024-3688": {"epss_score": 0.00052, "epss_percentile": 0.1647}, "CVE-2024-3689": {"epss_score": 0.00306, "epss_percentile": 0.53408}, "CVE-2024-3690": {"epss_score": 0.0352, "epss_percentile": 0.87284}, "CVE-2024-3691": {"epss_score": 0.00088, "epss_percentile": 0.25673}, "CVE-2024-3692": {"epss_score": 0.00177, "epss_percentile": 0.39521}, "CVE-2024-3695": {"epss_score": 0.00099, "epss_percentile": 0.27837}, "CVE-2024-3696": {"epss_score": 0.00093, "epss_percentile": 0.26622}, "CVE-2024-3697": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2024-3698": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2024-3699": {"epss_score": 0.00126, "epss_percentile": 0.32672}, "CVE-2024-3700": {"epss_score": 0.00114, "epss_percentile": 0.30737}, "CVE-2024-3701": {"epss_score": 0.00484, "epss_percentile": 0.64665}, "CVE-2024-3703": {"epss_score": 0.00272, "epss_percentile": 0.50378}, "CVE-2024-3704": {"epss_score": 0.00198, "epss_percentile": 0.41987}, "CVE-2024-3705": {"epss_score": 0.00684, "epss_percentile": 0.71116}, "CVE-2024-3706": {"epss_score": 0.00182, "epss_percentile": 0.40182}, "CVE-2024-3707": {"epss_score": 0.00232, "epss_percentile": 0.45876}, "CVE-2024-3710": {"epss_score": 0.0044, "epss_percentile": 0.62633}, "CVE-2024-3711": {"epss_score": 0.00209, "epss_percentile": 0.43323}, "CVE-2024-3714": {"epss_score": 0.00239, "epss_percentile": 0.46876}, "CVE-2024-3715": {"epss_score": 0.02565, "epss_percentile": 0.85116}, "CVE-2024-3716": {"epss_score": 0.00059, "epss_percentile": 0.18713}, "CVE-2024-3717": {"epss_score": 0.00703, "epss_percentile": 0.71527}, "CVE-2024-3718": {"epss_score": 0.00452, "epss_percentile": 0.6316}, "CVE-2024-3719": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2024-3720": {"epss_score": 0.00018, "epss_percentile": 0.03671}, "CVE-2024-3721": {"epss_score": 0.80177, "epss_percentile": 0.99074}, "CVE-2024-3722": {"epss_score": 0.00153, "epss_percentile": 0.36509}, "CVE-2024-3723": {"epss_score": 0.00827, "epss_percentile": 0.7399}, "CVE-2024-3724": {"epss_score": 0.00274, "epss_percentile": 0.5049}, "CVE-2024-3725": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-3726": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-3727": {"epss_score": 0.00559, "epss_percentile": 0.67614}, "CVE-2024-3728": {"epss_score": 0.00274, "epss_percentile": 0.5049}, "CVE-2024-3729": {"epss_score": 0.00551, "epss_percentile": 0.67363}, "CVE-2024-3730": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-3731": {"epss_score": 0.01095, "epss_percentile": 0.775}, "CVE-2024-3732": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-3733": {"epss_score": 0.00392, "epss_percentile": 0.59647}, "CVE-2024-3734": {"epss_score": 0.02011, "epss_percentile": 0.83252}, "CVE-2024-3735": {"epss_score": 0.00136, "epss_percentile": 0.34058}, "CVE-2024-3736": {"epss_score": 0.00047, "epss_percentile": 0.14926}, "CVE-2024-3737": {"epss_score": 0.00081, "epss_percentile": 0.24269}, "CVE-2024-3738": {"epss_score": 0.00062, "epss_percentile": 0.19752}, "CVE-2024-3739": {"epss_score": 0.01122, "epss_percentile": 0.77779}, "CVE-2024-3740": {"epss_score": 0.00069, "epss_percentile": 0.21604}, "CVE-2024-3741": {"epss_score": 0.00028, "epss_percentile": 0.07542}, "CVE-2024-3742": {"epss_score": 0.10226, "epss_percentile": 0.92901}, "CVE-2024-3743": {"epss_score": 0.00228, "epss_percentile": 0.45535}, "CVE-2024-3744": {"epss_score": 0.0003, "epss_percentile": 0.07985}, "CVE-2024-3745": {"epss_score": 0.00012, "epss_percentile": 0.01235}, "CVE-2024-3746": {"epss_score": 0.00061, "epss_percentile": 0.19468}, "CVE-2024-3747": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-3748": {"epss_score": 0.00306, "epss_percentile": 0.53405}, "CVE-2024-3749": {"epss_score": 0.00549, "epss_percentile": 0.67316}, "CVE-2024-3750": {"epss_score": 0.00331, "epss_percentile": 0.55514}, "CVE-2024-3751": {"epss_score": 0.00356, "epss_percentile": 0.57367}, "CVE-2024-3752": {"epss_score": 0.00299, "epss_percentile": 0.52838}, "CVE-2024-3753": {"epss_score": 0.00981, "epss_percentile": 0.76282}, "CVE-2024-3754": {"epss_score": 0.00284, "epss_percentile": 0.51422}, "CVE-2024-3755": {"epss_score": 0.00273, "epss_percentile": 0.50448}, "CVE-2024-3756": {"epss_score": 0.00453, "epss_percentile": 0.63214}, "CVE-2024-3757": {"epss_score": 0.00079, "epss_percentile": 0.23965}, "CVE-2024-3758": {"epss_score": 0.00118, "epss_percentile": 0.31409}, "CVE-2024-3759": {"epss_score": 0.00172, "epss_percentile": 0.38963}, "CVE-2024-3760": {"epss_score": 0.00175, "epss_percentile": 0.39278}, "CVE-2024-3761": {"epss_score": 0.00228, "epss_percentile": 0.45505}, "CVE-2024-3762": {"epss_score": 0.00061, "epss_percentile": 0.19322}, "CVE-2024-3763": {"epss_score": 0.00064, "epss_percentile": 0.20212}, "CVE-2024-3764": {"epss_score": 0.00038, "epss_percentile": 0.11414}, "CVE-2024-3765": {"epss_score": 0.00222, "epss_percentile": 0.44732}, "CVE-2024-3766": {"epss_score": 0.00057, "epss_percentile": 0.18125}, "CVE-2024-3767": {"epss_score": 0.00078, "epss_percentile": 0.23782}, "CVE-2024-3768": {"epss_score": 0.00065, "epss_percentile": 0.20457}, "CVE-2024-3769": {"epss_score": 0.00098, "epss_percentile": 0.27642}, "CVE-2024-3770": {"epss_score": 0.00053, "epss_percentile": 0.1684}, "CVE-2024-3771": {"epss_score": 0.00073, "epss_percentile": 0.22483}, "CVE-2024-3772": {"epss_score": 0.0028, "epss_percentile": 0.511}, "CVE-2024-3774": {"epss_score": 0.00074, "epss_percentile": 0.22873}, "CVE-2024-3775": {"epss_score": 0.00093, "epss_percentile": 0.26699}, "CVE-2024-3776": {"epss_score": 0.00206, "epss_percentile": 0.42767}, "CVE-2024-3777": {"epss_score": 0.00531, "epss_percentile": 0.66667}, "CVE-2024-3778": {"epss_score": 0.00304, "epss_percentile": 0.53257}, "CVE-2024-3779": {"epss_score": 0.00119, "epss_percentile": 0.31647}, "CVE-2024-3780": {"epss_score": 0.00073, "epss_percentile": 0.22577}, "CVE-2024-3781": {"epss_score": 0.00329, "epss_percentile": 0.554}, "CVE-2024-3782": {"epss_score": 0.00159, "epss_percentile": 0.37339}, "CVE-2024-3783": {"epss_score": 0.00206, "epss_percentile": 0.42933}, "CVE-2024-3784": {"epss_score": 0.00481, "epss_percentile": 0.64485}, "CVE-2024-3785": {"epss_score": 0.00481, "epss_percentile": 0.64485}, "CVE-2024-3786": {"epss_score": 0.00481, "epss_percentile": 0.64485}, "CVE-2024-3787": {"epss_score": 0.0156, "epss_percentile": 0.8104}, "CVE-2024-3788": {"epss_score": 0.00925, "epss_percentile": 0.75532}, "CVE-2024-3789": {"epss_score": 0.00465, "epss_percentile": 0.63743}, "CVE-2024-3790": {"epss_score": 0.00097, "epss_percentile": 0.27535}, "CVE-2024-3791": {"epss_score": 0.00193, "epss_percentile": 0.41439}, "CVE-2024-3792": {"epss_score": 0.00478, "epss_percentile": 0.64384}, "CVE-2024-3793": {"epss_score": 0.00193, "epss_percentile": 0.41439}, "CVE-2024-3794": {"epss_score": 0.00193, "epss_percentile": 0.41439}, "CVE-2024-3795": {"epss_score": 0.00193, "epss_percentile": 0.41439}, "CVE-2024-3796": {"epss_score": 0.00116, "epss_percentile": 0.31067}, "CVE-2024-3797": {"epss_score": 0.00136, "epss_percentile": 0.34199}, "CVE-2024-3798": {"epss_score": 0.00338, "epss_percentile": 0.56132}, "CVE-2024-3799": {"epss_score": 0.01381, "epss_percentile": 0.79866}, "CVE-2024-3800": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2024-3801": {"epss_score": 0.00528, "epss_percentile": 0.66572}, "CVE-2024-3803": {"epss_score": 0.00164, "epss_percentile": 0.37996}, "CVE-2024-3804": {"epss_score": 0.00164, "epss_percentile": 0.37996}, "CVE-2024-3806": {"epss_score": 0.56483, "epss_percentile": 0.98025}, "CVE-2024-3807": {"epss_score": 0.06384, "epss_percentile": 0.90715}, "CVE-2024-3808": {"epss_score": 0.00409, "epss_percentile": 0.60727}, "CVE-2024-3809": {"epss_score": 0.0033, "epss_percentile": 0.55451}, "CVE-2024-3810": {"epss_score": 0.00451, "epss_percentile": 0.63141}, "CVE-2024-3811": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-3812": {"epss_score": 0.0034, "epss_percentile": 0.56279}, "CVE-2024-3813": {"epss_score": 0.00667, "epss_percentile": 0.70716}, "CVE-2024-3814": {"epss_score": 0.00246, "epss_percentile": 0.4775}, "CVE-2024-3815": {"epss_score": 0.00246, "epss_percentile": 0.4775}, "CVE-2024-3816": {"epss_score": 0.00308, "epss_percentile": 0.53618}, "CVE-2024-3817": {"epss_score": 0.01134, "epss_percentile": 0.77886}, "CVE-2024-3818": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-3819": {"epss_score": 0.00239, "epss_percentile": 0.46907}, "CVE-2024-3820": {"epss_score": 0.02143, "epss_percentile": 0.83756}, "CVE-2024-3821": {"epss_score": 0.0032, "epss_percentile": 0.54611}, "CVE-2024-3822": {"epss_score": 0.00374, "epss_percentile": 0.58546}, "CVE-2024-3823": {"epss_score": 0.00072, "epss_percentile": 0.2243}, "CVE-2024-3824": {"epss_score": 0.00129, "epss_percentile": 0.33124}, "CVE-2024-3825": {"epss_score": 0.00127, "epss_percentile": 0.32845}, "CVE-2024-3826": {"epss_score": 0.00136, "epss_percentile": 0.34159}, "CVE-2024-3827": {"epss_score": 0.0044, "epss_percentile": 0.62632}, "CVE-2024-3828": {"epss_score": 0.00139, "epss_percentile": 0.34545}, "CVE-2024-3829": {"epss_score": 0.00299, "epss_percentile": 0.52883}, "CVE-2024-3831": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-3832": {"epss_score": 0.03078, "epss_percentile": 0.86366}, "CVE-2024-3833": {"epss_score": 0.02973, "epss_percentile": 0.86101}, "CVE-2024-3834": {"epss_score": 0.00563, "epss_percentile": 0.67733}, "CVE-2024-3837": {"epss_score": 0.00316, "epss_percentile": 0.54224}, "CVE-2024-3838": {"epss_score": 0.00137, "epss_percentile": 0.34281}, "CVE-2024-3839": {"epss_score": 0.00125, "epss_percentile": 0.32512}, "CVE-2024-3840": {"epss_score": 0.0012, "epss_percentile": 0.31707}, "CVE-2024-3841": {"epss_score": 0.00338, "epss_percentile": 0.56146}, "CVE-2024-3843": {"epss_score": 0.00831, "epss_percentile": 0.74052}, "CVE-2024-3844": {"epss_score": 0.00897, "epss_percentile": 0.75131}, "CVE-2024-3845": {"epss_score": 0.00281, "epss_percentile": 0.51192}, "CVE-2024-3846": {"epss_score": 0.00974, "epss_percentile": 0.76175}, "CVE-2024-3847": {"epss_score": 0.00201, "epss_percentile": 0.42338}, "CVE-2024-3848": {"epss_score": 0.73811, "epss_percentile": 0.98773}, "CVE-2024-3849": {"epss_score": 0.00537, "epss_percentile": 0.66903}, "CVE-2024-3850": {"epss_score": 0.09335, "epss_percentile": 0.92504}, "CVE-2024-3851": {"epss_score": 0.00267, "epss_percentile": 0.50001}, "CVE-2024-3852": {"epss_score": 0.00978, "epss_percentile": 0.76244}, "CVE-2024-3853": {"epss_score": 0.00092, "epss_percentile": 0.26508}, "CVE-2024-3854": {"epss_score": 0.00947, "epss_percentile": 0.75822}, "CVE-2024-3855": {"epss_score": 0.00214, "epss_percentile": 0.44009}, "CVE-2024-3856": {"epss_score": 0.00685, "epss_percentile": 0.71142}, "CVE-2024-3857": {"epss_score": 0.00136, "epss_percentile": 0.34118}, "CVE-2024-3858": {"epss_score": 0.00304, "epss_percentile": 0.53241}, "CVE-2024-3859": {"epss_score": 0.01492, "epss_percentile": 0.80637}, "CVE-2024-3860": {"epss_score": 0.00039, "epss_percentile": 0.11538}, "CVE-2024-3861": {"epss_score": 0.00119, "epss_percentile": 0.31628}, "CVE-2024-3862": {"epss_score": 0.00138, "epss_percentile": 0.34504}, "CVE-2024-3863": {"epss_score": 0.00338, "epss_percentile": 0.5616}, "CVE-2024-3864": {"epss_score": 0.01067, "epss_percentile": 0.77227}, "CVE-2024-3865": {"epss_score": 0.00278, "epss_percentile": 0.5088}, "CVE-2024-3866": {"epss_score": 0.00962, "epss_percentile": 0.75988}, "CVE-2024-3867": {"epss_score": 0.18575, "epss_percentile": 0.95035}, "CVE-2024-3868": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-3869": {"epss_score": 0.00278, "epss_percentile": 0.50878}, "CVE-2024-3870": {"epss_score": 0.00982, "epss_percentile": 0.7629}, "CVE-2024-3871": {"epss_score": 0.02873, "epss_percentile": 0.85878}, "CVE-2024-3872": {"epss_score": 0.00448, "epss_percentile": 0.62992}, "CVE-2024-3873": {"epss_score": 0.00043, "epss_percentile": 0.13174}, "CVE-2024-3874": {"epss_score": 0.00379, "epss_percentile": 0.58901}, "CVE-2024-3875": {"epss_score": 0.01008, "epss_percentile": 0.76573}, "CVE-2024-3876": {"epss_score": 0.00591, "epss_percentile": 0.68587}, "CVE-2024-3877": {"epss_score": 0.00571, "epss_percentile": 0.67976}, "CVE-2024-3878": {"epss_score": 0.00694, "epss_percentile": 0.71342}, "CVE-2024-3879": {"epss_score": 0.00254, "epss_percentile": 0.48562}, "CVE-2024-3880": {"epss_score": 0.01613, "epss_percentile": 0.8134}, "CVE-2024-3881": {"epss_score": 0.00345, "epss_percentile": 0.56594}, "CVE-2024-3882": {"epss_score": 0.00345, "epss_percentile": 0.56594}, "CVE-2024-3883": {"epss_score": 0.00184, "epss_percentile": 0.40425}, "CVE-2024-3884": {"epss_score": 0.00323, "epss_percentile": 0.54878}, "CVE-2024-3885": {"epss_score": 0.00214, "epss_percentile": 0.43973}, "CVE-2024-3886": {"epss_score": 0.00715, "epss_percentile": 0.71852}, "CVE-2024-3887": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-3888": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-3889": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-3890": {"epss_score": 0.00186, "epss_percentile": 0.40653}, "CVE-2024-3891": {"epss_score": 0.0025, "epss_percentile": 0.48253}, "CVE-2024-3892": {"epss_score": 0.00031, "epss_percentile": 0.0838}, "CVE-2024-3893": {"epss_score": 0.00081, "epss_percentile": 0.24284}, "CVE-2024-3894": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-3895": {"epss_score": 0.00276, "epss_percentile": 0.50716}, "CVE-2024-3896": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-3897": {"epss_score": 0.00489, "epss_percentile": 0.64915}, "CVE-2024-3899": {"epss_score": 0.00171, "epss_percentile": 0.38784}, "CVE-2024-3900": {"epss_score": 0.00032, "epss_percentile": 0.08735}, "CVE-2024-3901": {"epss_score": 0.00069, "epss_percentile": 0.21556}, "CVE-2024-3903": {"epss_score": 0.0015, "epss_percentile": 0.36073}, "CVE-2024-3904": {"epss_score": 0.00059, "epss_percentile": 0.18674}, "CVE-2024-3905": {"epss_score": 0.00987, "epss_percentile": 0.76348}, "CVE-2024-3906": {"epss_score": 0.00609, "epss_percentile": 0.69126}, "CVE-2024-3907": {"epss_score": 0.00591, "epss_percentile": 0.68587}, "CVE-2024-3908": {"epss_score": 0.04343, "epss_percentile": 0.88573}, "CVE-2024-3909": {"epss_score": 0.00254, "epss_percentile": 0.48562}, "CVE-2024-3910": {"epss_score": 0.0056, "epss_percentile": 0.67641}, "CVE-2024-3911": {"epss_score": 0.00113, "epss_percentile": 0.307}, "CVE-2024-3912": {"epss_score": 0.03459, "epss_percentile": 0.87178}, "CVE-2024-3913": {"epss_score": 0.002, "epss_percentile": 0.42203}, "CVE-2024-3914": {"epss_score": 0.00337, "epss_percentile": 0.56041}, "CVE-2024-3915": {"epss_score": 0.00217, "epss_percentile": 0.44329}, "CVE-2024-3916": {"epss_score": 0.00268, "epss_percentile": 0.50057}, "CVE-2024-3917": {"epss_score": 0.00244, "epss_percentile": 0.47601}, "CVE-2024-3918": {"epss_score": 0.0017, "epss_percentile": 0.38722}, "CVE-2024-3919": {"epss_score": 0.00298, "epss_percentile": 0.52824}, "CVE-2024-3920": {"epss_score": 0.00179, "epss_percentile": 0.39803}, "CVE-2024-3921": {"epss_score": 0.00164, "epss_percentile": 0.37891}, "CVE-2024-3922": {"epss_score": 0.89443, "epss_percentile": 0.99527}, "CVE-2024-3923": {"epss_score": 0.00297, "epss_percentile": 0.52748}, "CVE-2024-3924": {"epss_score": 0.00369, "epss_percentile": 0.58258}, "CVE-2024-3925": {"epss_score": 0.00405, "epss_percentile": 0.60459}, "CVE-2024-3926": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-3927": {"epss_score": 0.00512, "epss_percentile": 0.65859}, "CVE-2024-3928": {"epss_score": 0.00047, "epss_percentile": 0.14849}, "CVE-2024-3929": {"epss_score": 0.00109, "epss_percentile": 0.29939}, "CVE-2024-3930": {"epss_score": 0.0011, "epss_percentile": 0.30101}, "CVE-2024-3931": {"epss_score": 0.00096, "epss_percentile": 0.27451}, "CVE-2024-3932": {"epss_score": 0.00049, "epss_percentile": 0.15495}, "CVE-2024-3933": {"epss_score": 0.00067, "epss_percentile": 0.21065}, "CVE-2024-3934": {"epss_score": 0.01172, "epss_percentile": 0.78225}, "CVE-2024-3935": {"epss_score": 0.00385, "epss_percentile": 0.59216}, "CVE-2024-3936": {"epss_score": 0.00132, "epss_percentile": 0.33531}, "CVE-2024-3937": {"epss_score": 0.0017, "epss_percentile": 0.38722}, "CVE-2024-3938": {"epss_score": 0.00701, "epss_percentile": 0.71503}, "CVE-2024-3939": {"epss_score": 0.00641, "epss_percentile": 0.69978}, "CVE-2024-3940": {"epss_score": 0.00285, "epss_percentile": 0.51673}, "CVE-2024-3941": {"epss_score": 0.00065, "epss_percentile": 0.20672}, "CVE-2024-3942": {"epss_score": 0.00082, "epss_percentile": 0.24418}, "CVE-2024-3943": {"epss_score": 0.00178, "epss_percentile": 0.39688}, "CVE-2024-3944": {"epss_score": 0.00137, "epss_percentile": 0.34226}, "CVE-2024-3945": {"epss_score": 0.00178, "epss_percentile": 0.39688}, "CVE-2024-3946": {"epss_score": 0.00286, "epss_percentile": 0.51767}, "CVE-2024-3947": {"epss_score": 0.00178, "epss_percentile": 0.39688}, "CVE-2024-3948": {"epss_score": 0.00264, "epss_percentile": 0.4968}, "CVE-2024-3951": {"epss_score": 0.00088, "epss_percentile": 0.25763}, "CVE-2024-3952": {"epss_score": 0.00133, "epss_percentile": 0.33665}, "CVE-2024-3954": {"epss_score": 0.01726, "epss_percentile": 0.81964}, "CVE-2024-3955": {"epss_score": 0.00354, "epss_percentile": 0.57243}, "CVE-2024-3956": {"epss_score": 0.00196, "epss_percentile": 0.41811}, "CVE-2024-3957": {"epss_score": 0.00655, "epss_percentile": 0.7041}, "CVE-2024-3958": {"epss_score": 0.00066, "epss_percentile": 0.20943}, "CVE-2024-3959": {"epss_score": 0.00043, "epss_percentile": 0.13324}, "CVE-2024-3961": {"epss_score": 0.00296, "epss_percentile": 0.5258}, "CVE-2024-3962": {"epss_score": 0.10498, "epss_percentile": 0.93009}, "CVE-2024-3963": {"epss_score": 0.00244, "epss_percentile": 0.47569}, "CVE-2024-3964": {"epss_score": 0.00219, "epss_percentile": 0.44509}, "CVE-2024-3965": {"epss_score": 0.00289, "epss_percentile": 0.52052}, "CVE-2024-3966": {"epss_score": 0.00513, "epss_percentile": 0.65918}, "CVE-2024-3967": {"epss_score": 0.01178, "epss_percentile": 0.78283}, "CVE-2024-3968": {"epss_score": 0.00813, "epss_percentile": 0.73761}, "CVE-2024-3969": {"epss_score": 0.0155, "epss_percentile": 0.80984}, "CVE-2024-3970": {"epss_score": 0.00087, "epss_percentile": 0.25552}, "CVE-2024-3971": {"epss_score": 0.00131, "epss_percentile": 0.33375}, "CVE-2024-3972": {"epss_score": 0.00058, "epss_percentile": 0.1857}, "CVE-2024-3973": {"epss_score": 0.0017, "epss_percentile": 0.38722}, "CVE-2024-3974": {"epss_score": 0.00204, "epss_percentile": 0.42626}, "CVE-2024-3976": {"epss_score": 0.00036, "epss_percentile": 0.10391}, "CVE-2024-3977": {"epss_score": 0.00195, "epss_percentile": 0.41685}, "CVE-2024-3978": {"epss_score": 0.0047, "epss_percentile": 0.63993}, "CVE-2024-3979": {"epss_score": 0.00023, "epss_percentile": 0.0561}, "CVE-2024-3980": {"epss_score": 0.00481, "epss_percentile": 0.64487}, "CVE-2024-3982": {"epss_score": 0.00052, "epss_percentile": 0.16599}, "CVE-2024-3983": {"epss_score": 0.00242, "epss_percentile": 0.47379}, "CVE-2024-3984": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-3985": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-3986": {"epss_score": 0.00237, "epss_percentile": 0.46663}, "CVE-2024-3987": {"epss_score": 0.00338, "epss_percentile": 0.56151}, "CVE-2024-3988": {"epss_score": 0.00126, "epss_percentile": 0.32771}, "CVE-2024-3989": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-3990": {"epss_score": 0.00219, "epss_percentile": 0.44477}, "CVE-2024-3991": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-3992": {"epss_score": 0.00436, "epss_percentile": 0.62468}, "CVE-2024-3993": {"epss_score": 0.00151, "epss_percentile": 0.36291}, "CVE-2024-3994": {"epss_score": 0.00272, "epss_percentile": 0.50397}, "CVE-2024-3995": {"epss_score": 0.00065, "epss_percentile": 0.20568}, "CVE-2024-3996": {"epss_score": 0.00048, "epss_percentile": 0.15095}, "CVE-2024-3997": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-3998": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2024-3999": {"epss_score": 0.00306, "epss_percentile": 0.53423}, "CVE-2024-40034": {"epss_score": 0.00417, "epss_percentile": 0.6123}, "CVE-2024-40035": {"epss_score": 0.00102, "epss_percentile": 0.28753}, "CVE-2024-40036": {"epss_score": 0.00436, "epss_percentile": 0.62465}, "CVE-2024-40037": {"epss_score": 0.00319, "epss_percentile": 0.54498}, "CVE-2024-40038": {"epss_score": 0.00102, "epss_percentile": 0.28753}, "CVE-2024-40039": {"epss_score": 0.00319, "epss_percentile": 0.54498}, "CVE-2024-40051": {"epss_score": 0.00264, "epss_percentile": 0.49703}, "CVE-2024-40060": {"epss_score": 0.00097, "epss_percentile": 0.27516}, "CVE-2024-40068": {"epss_score": 0.00038, "epss_percentile": 0.11181}, "CVE-2024-40069": {"epss_score": 0.00041, "epss_percentile": 0.12329}, "CVE-2024-40070": {"epss_score": 0.00042, "epss_percentile": 0.12908}, "CVE-2024-40071": {"epss_score": 0.00626, "epss_percentile": 0.69612}, "CVE-2024-40072": {"epss_score": 0.0008, "epss_percentile": 0.24117}, "CVE-2024-40073": {"epss_score": 0.0008, "epss_percentile": 0.24117}, "CVE-2024-40074": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2024-40075": {"epss_score": 0.0009, "epss_percentile": 0.26024}, "CVE-2024-40083": {"epss_score": 0.05477, "epss_percentile": 0.89916}, "CVE-2024-40084": {"epss_score": 0.03044, "epss_percentile": 0.8628}, "CVE-2024-40085": {"epss_score": 0.05477, "epss_percentile": 0.89916}, "CVE-2024-40086": {"epss_score": 0.05477, "epss_percentile": 0.89916}, "CVE-2024-40087": {"epss_score": 0.00737, "epss_percentile": 0.72326}, "CVE-2024-40088": {"epss_score": 0.00722, "epss_percentile": 0.71993}, "CVE-2024-40089": {"epss_score": 0.0362, "epss_percentile": 0.87441}, "CVE-2024-40090": {"epss_score": 0.00128, "epss_percentile": 0.33048}, "CVE-2024-40091": {"epss_score": 0.00216, "epss_percentile": 0.44129}, "CVE-2024-40094": {"epss_score": 0.1753, "epss_percentile": 0.94862}, "CVE-2024-40096": {"epss_score": 0.00054, "epss_percentile": 0.17305}, "CVE-2024-40101": {"epss_score": 0.0115, "epss_percentile": 0.78033}, "CVE-2024-40110": {"epss_score": 0.3221, "epss_percentile": 0.9668}, "CVE-2024-40111": {"epss_score": 0.03456, "epss_percentile": 0.87173}, "CVE-2024-40112": {"epss_score": 0.00025, "epss_percentile": 0.06205}, "CVE-2024-40113": {"epss_score": 0.00051, "epss_percentile": 0.16241}, "CVE-2024-40114": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2024-40116": {"epss_score": 0.00091, "epss_percentile": 0.26215}, "CVE-2024-40117": {"epss_score": 0.00152, "epss_percentile": 0.36467}, "CVE-2024-40119": {"epss_score": 0.05012, "epss_percentile": 0.89391}, "CVE-2024-40120": {"epss_score": 0.00038, "epss_percentile": 0.11058}, "CVE-2024-40124": {"epss_score": 0.00041, "epss_percentile": 0.12329}, "CVE-2024-40125": {"epss_score": 0.00259, "epss_percentile": 0.49074}, "CVE-2024-40129": {"epss_score": 0.00418, "epss_percentile": 0.61267}, "CVE-2024-40130": {"epss_score": 0.00438, "epss_percentile": 0.62558}, "CVE-2024-40137": {"epss_score": 0.0048, "epss_percentile": 0.6445}, "CVE-2024-40239": {"epss_score": 0.00099, "epss_percentile": 0.28417}, "CVE-2024-40240": {"epss_score": 0.00105, "epss_percentile": 0.2939}, "CVE-2024-40317": {"epss_score": 0.00036, "epss_percentile": 0.10617}, "CVE-2024-40318": {"epss_score": 0.10397, "epss_percentile": 0.92974}, "CVE-2024-40322": {"epss_score": 0.00057, "epss_percentile": 0.18014}, "CVE-2024-40324": {"epss_score": 0.12402, "epss_percentile": 0.93659}, "CVE-2024-40328": {"epss_score": 0.002, "epss_percentile": 0.42229}, "CVE-2024-40329": {"epss_score": 0.00319, "epss_percentile": 0.54498}, "CVE-2024-40331": {"epss_score": 0.00133, "epss_percentile": 0.33666}, "CVE-2024-40332": {"epss_score": 0.00067, "epss_percentile": 0.21144}, "CVE-2024-40333": {"epss_score": 0.00436, "epss_percentile": 0.62465}, "CVE-2024-40334": {"epss_score": 0.00319, "epss_percentile": 0.54498}, "CVE-2024-40336": {"epss_score": 0.00098, "epss_percentile": 0.27711}, "CVE-2024-40347": {"epss_score": 0.00171, "epss_percentile": 0.38815}, "CVE-2024-40348": {"epss_score": 0.92526, "epss_percentile": 0.99724}, "CVE-2024-40392": {"epss_score": 0.00271, "epss_percentile": 0.50309}, "CVE-2024-40393": {"epss_score": 0.00277, "epss_percentile": 0.50824}, "CVE-2024-40394": {"epss_score": 0.00311, "epss_percentile": 0.53928}, "CVE-2024-40395": {"epss_score": 0.00244, "epss_percentile": 0.47607}, "CVE-2024-40400": {"epss_score": 0.0186, "epss_percentile": 0.82587}, "CVE-2024-40402": {"epss_score": 0.00031, "epss_percentile": 0.08579}, "CVE-2024-40404": {"epss_score": 0.00632, "epss_percentile": 0.69747}, "CVE-2024-40405": {"epss_score": 0.00632, "epss_percentile": 0.69747}, "CVE-2024-40407": {"epss_score": 0.00615, "epss_percentile": 0.69295}, "CVE-2024-40408": {"epss_score": 0.00298, "epss_percentile": 0.52787}, "CVE-2024-40410": {"epss_score": 0.0039, "epss_percentile": 0.595}, "CVE-2024-40412": {"epss_score": 0.00211, "epss_percentile": 0.43633}, "CVE-2024-40414": {"epss_score": 0.00223, "epss_percentile": 0.44895}, "CVE-2024-40415": {"epss_score": 0.00223, "epss_percentile": 0.44895}, "CVE-2024-40416": {"epss_score": 0.0017, "epss_percentile": 0.38712}, "CVE-2024-40417": {"epss_score": 0.00137, "epss_percentile": 0.34245}, "CVE-2024-40422": {"epss_score": 0.92895, "epss_percentile": 0.99757}, "CVE-2024-40425": {"epss_score": 0.04991, "epss_percentile": 0.89367}, "CVE-2024-40427": {"epss_score": 0.00043, "epss_percentile": 0.12954}, "CVE-2024-40431": {"epss_score": 0.18501, "epss_percentile": 0.95024}, "CVE-2024-40432": {"epss_score": 0.00166, "epss_percentile": 0.38156}, "CVE-2024-40433": {"epss_score": 0.00159, "epss_percentile": 0.37319}, "CVE-2024-40441": {"epss_score": 0.0063, "epss_percentile": 0.69698}, "CVE-2024-40442": {"epss_score": 0.00526, "epss_percentile": 0.66435}, "CVE-2024-40443": {"epss_score": 0.06212, "epss_percentile": 0.9057}, "CVE-2024-40445": {"epss_score": 0.00028, "epss_percentile": 0.07296}, "CVE-2024-40446": {"epss_score": 0.00067, "epss_percentile": 0.21098}, "CVE-2024-40453": {"epss_score": 0.01962, "epss_percentile": 0.83064}, "CVE-2024-40455": {"epss_score": 0.00132, "epss_percentile": 0.33576}, "CVE-2024-40456": {"epss_score": 0.00255, "epss_percentile": 0.48654}, "CVE-2024-40457": {"epss_score": 0.01845, "epss_percentile": 0.82509}, "CVE-2024-40458": {"epss_score": 0.00028, "epss_percentile": 0.07299}, "CVE-2024-40459": {"epss_score": 0.00018, "epss_percentile": 0.04037}, "CVE-2024-40460": {"epss_score": 0.00018, "epss_percentile": 0.04037}, "CVE-2024-40461": {"epss_score": 0.00018, "epss_percentile": 0.04037}, "CVE-2024-40462": {"epss_score": 0.00018, "epss_percentile": 0.04037}, "CVE-2024-40464": {"epss_score": 0.00751, "epss_percentile": 0.72645}, "CVE-2024-40465": {"epss_score": 0.01096, "epss_percentile": 0.77522}, "CVE-2024-40472": {"epss_score": 0.00157, "epss_percentile": 0.3712}, "CVE-2024-40473": {"epss_score": 0.00417, "epss_percentile": 0.6123}, "CVE-2024-40474": {"epss_score": 0.00191, "epss_percentile": 0.41265}, "CVE-2024-40475": {"epss_score": 0.00176, "epss_percentile": 0.39411}, "CVE-2024-40476": {"epss_score": 0.00184, "epss_percentile": 0.40451}, "CVE-2024-40477": {"epss_score": 0.00282, "epss_percentile": 0.51252}, "CVE-2024-40478": {"epss_score": 0.00417, "epss_percentile": 0.6123}, "CVE-2024-40479": {"epss_score": 0.00165, "epss_percentile": 0.38127}, "CVE-2024-40480": {"epss_score": 0.00897, "epss_percentile": 0.75136}, "CVE-2024-40481": {"epss_score": 0.00306, "epss_percentile": 0.53396}, "CVE-2024-40482": {"epss_score": 0.00408, "epss_percentile": 0.60622}, "CVE-2024-40484": {"epss_score": 0.00453, "epss_percentile": 0.63217}, "CVE-2024-40486": {"epss_score": 0.00142, "epss_percentile": 0.35073}, "CVE-2024-40487": {"epss_score": 0.02082, "epss_percentile": 0.83537}, "CVE-2024-40488": {"epss_score": 0.00423, "epss_percentile": 0.61631}, "CVE-2024-40490": {"epss_score": 0.00232, "epss_percentile": 0.45889}, "CVE-2024-40492": {"epss_score": 0.08372, "epss_percentile": 0.92015}, "CVE-2024-40493": {"epss_score": 0.01162, "epss_percentile": 0.7815}, "CVE-2024-40494": {"epss_score": 0.0153, "epss_percentile": 0.80886}, "CVE-2024-40495": {"epss_score": 0.00218, "epss_percentile": 0.44419}, "CVE-2024-40498": {"epss_score": 0.11783, "epss_percentile": 0.93473}, "CVE-2024-40500": {"epss_score": 0.0154, "epss_percentile": 0.80942}, "CVE-2024-40502": {"epss_score": 0.03598, "epss_percentile": 0.87408}, "CVE-2024-40503": {"epss_score": 0.0091, "epss_percentile": 0.75318}, "CVE-2024-40505": {"epss_score": 0.00602, "epss_percentile": 0.68884}, "CVE-2024-40506": {"epss_score": 0.04631, "epss_percentile": 0.88945}, "CVE-2024-40507": {"epss_score": 0.05875, "epss_percentile": 0.90283}, "CVE-2024-40508": {"epss_score": 0.05875, "epss_percentile": 0.90283}, "CVE-2024-40509": {"epss_score": 0.05875, "epss_percentile": 0.90283}, "CVE-2024-40510": {"epss_score": 0.06977, "epss_percentile": 0.91157}, "CVE-2024-40511": {"epss_score": 0.10748, "epss_percentile": 0.93092}, "CVE-2024-40512": {"epss_score": 0.13345, "epss_percentile": 0.93938}, "CVE-2024-40513": {"epss_score": 0.00261, "epss_percentile": 0.49254}, "CVE-2024-40514": {"epss_score": 0.00057, "epss_percentile": 0.1808}, "CVE-2024-40515": {"epss_score": 0.06573, "epss_percentile": 0.90856}, "CVE-2024-40516": {"epss_score": 0.03071, "epss_percentile": 0.86347}, "CVE-2024-40518": {"epss_score": 0.01582, "epss_percentile": 0.81143}, "CVE-2024-40519": {"epss_score": 0.06368, "epss_percentile": 0.90703}, "CVE-2024-40520": {"epss_score": 0.02681, "epss_percentile": 0.85416}, "CVE-2024-40521": {"epss_score": 0.00338, "epss_percentile": 0.5613}, "CVE-2024-40522": {"epss_score": 0.06399, "epss_percentile": 0.90726}, "CVE-2024-40524": {"epss_score": 0.0206, "epss_percentile": 0.83441}, "CVE-2024-40530": {"epss_score": 0.00106, "epss_percentile": 0.29444}, "CVE-2024-40531": {"epss_score": 0.0025, "epss_percentile": 0.48104}, "CVE-2024-40535": {"epss_score": 0.00448, "epss_percentile": 0.63015}, "CVE-2024-40536": {"epss_score": 0.00214, "epss_percentile": 0.43997}, "CVE-2024-40539": {"epss_score": 0.00052, "epss_percentile": 0.16476}, "CVE-2024-40540": {"epss_score": 0.00052, "epss_percentile": 0.16476}, "CVE-2024-40541": {"epss_score": 0.00052, "epss_percentile": 0.16476}, "CVE-2024-40542": {"epss_score": 0.00053, "epss_percentile": 0.16734}, "CVE-2024-40543": {"epss_score": 0.00242, "epss_percentile": 0.47401}, "CVE-2024-40544": {"epss_score": 0.00259, "epss_percentile": 0.49072}, "CVE-2024-40545": {"epss_score": 0.00179, "epss_percentile": 0.39748}, "CVE-2024-40546": {"epss_score": 0.00324, "epss_percentile": 0.54967}, "CVE-2024-40547": {"epss_score": 0.00184, "epss_percentile": 0.40454}, "CVE-2024-40548": {"epss_score": 0.00318, "epss_percentile": 0.54436}, "CVE-2024-40549": {"epss_score": 0.00307, "epss_percentile": 0.53516}, "CVE-2024-40550": {"epss_score": 0.00619, "epss_percentile": 0.69393}, "CVE-2024-40551": {"epss_score": 0.00228, "epss_percentile": 0.45523}, "CVE-2024-40552": {"epss_score": 0.00459, "epss_percentile": 0.63454}, "CVE-2024-40553": {"epss_score": 0.00087, "epss_percentile": 0.25443}, "CVE-2024-40554": {"epss_score": 0.00159, "epss_percentile": 0.37345}, "CVE-2024-40555": {"epss_score": 0.00114, "epss_percentile": 0.30835}, "CVE-2024-40560": {"epss_score": 0.00071, "epss_percentile": 0.22086}, "CVE-2024-40568": {"epss_score": 0.01529, "epss_percentile": 0.80876}, "CVE-2024-40570": {"epss_score": 0.00054, "epss_percentile": 0.17269}, "CVE-2024-40575": {"epss_score": 0.00053, "epss_percentile": 0.16676}, "CVE-2024-40576": {"epss_score": 0.00834, "epss_percentile": 0.74106}, "CVE-2024-40579": {"epss_score": 0.00233, "epss_percentile": 0.46019}, "CVE-2024-40582": {"epss_score": 0.00105, "epss_percentile": 0.29297}, "CVE-2024-40583": {"epss_score": 0.00259, "epss_percentile": 0.49095}, "CVE-2024-40584": {"epss_score": 0.00396, "epss_percentile": 0.59903}, "CVE-2024-40585": {"epss_score": 0.00083, "epss_percentile": 0.2464}, "CVE-2024-40586": {"epss_score": 0.00025, "epss_percentile": 0.06334}, "CVE-2024-40587": {"epss_score": 0.00236, "epss_percentile": 0.46371}, "CVE-2024-40588": {"epss_score": 0.00014, "epss_percentile": 0.02102}, "CVE-2024-40590": {"epss_score": 0.00197, "epss_percentile": 0.41861}, "CVE-2024-40591": {"epss_score": 0.00176, "epss_percentile": 0.39482}, "CVE-2024-40592": {"epss_score": 0.00025, "epss_percentile": 0.06294}, "CVE-2024-40593": {"epss_score": 0.0001, "epss_percentile": 0.0077}, "CVE-2024-40594": {"epss_score": 0.00015, "epss_percentile": 0.02429}, "CVE-2024-40595": {"epss_score": 8e-05, "epss_percentile": 0.0055}, "CVE-2024-40596": {"epss_score": 0.00145, "epss_percentile": 0.35393}, "CVE-2024-40597": {"epss_score": 0.00382, "epss_percentile": 0.59039}, "CVE-2024-40598": {"epss_score": 0.00145, "epss_percentile": 0.35393}, "CVE-2024-40599": {"epss_score": 0.00126, "epss_percentile": 0.32695}, "CVE-2024-40600": {"epss_score": 0.00126, "epss_percentile": 0.32695}, "CVE-2024-40601": {"epss_score": 0.00065, "epss_percentile": 0.2053}, "CVE-2024-40602": {"epss_score": 0.00126, "epss_percentile": 0.32695}, "CVE-2024-40603": {"epss_score": 0.00058, "epss_percentile": 0.18367}, "CVE-2024-40604": {"epss_score": 0.00096, "epss_percentile": 0.2732}, "CVE-2024-40605": {"epss_score": 0.00096, "epss_percentile": 0.2732}, "CVE-2024-40614": {"epss_score": 0.00146, "epss_percentile": 0.35536}, "CVE-2024-40617": {"epss_score": 0.16987, "epss_percentile": 0.94757}, "CVE-2024-40618": {"epss_score": 0.00144, "epss_percentile": 0.3524}, "CVE-2024-40619": {"epss_score": 0.00198, "epss_percentile": 0.42077}, "CVE-2024-40620": {"epss_score": 0.00083, "epss_percentile": 0.2471}, "CVE-2024-40624": {"epss_score": 0.00227, "epss_percentile": 0.45424}, "CVE-2024-40625": {"epss_score": 0.00041, "epss_percentile": 0.12236}, "CVE-2024-40626": {"epss_score": 0.00169, "epss_percentile": 0.38607}, "CVE-2024-40627": {"epss_score": 0.00207, "epss_percentile": 0.43114}, "CVE-2024-40628": {"epss_score": 0.00748, "epss_percentile": 0.72585}, "CVE-2024-40629": {"epss_score": 0.09362, "epss_percentile": 0.92516}, "CVE-2024-40630": {"epss_score": 0.00257, "epss_percentile": 0.48848}, "CVE-2024-40631": {"epss_score": 0.00434, "epss_percentile": 0.6229}, "CVE-2024-40632": {"epss_score": 0.00086, "epss_percentile": 0.25289}, "CVE-2024-40633": {"epss_score": 0.00239, "epss_percentile": 0.46923}, "CVE-2024-40634": {"epss_score": 0.035, "epss_percentile": 0.87246}, "CVE-2024-40635": {"epss_score": 0.00013, "epss_percentile": 0.01696}, "CVE-2024-40636": {"epss_score": 0.00064, "epss_percentile": 0.20397}, "CVE-2024-40637": {"epss_score": 0.00124, "epss_percentile": 0.32449}, "CVE-2024-40638": {"epss_score": 0.003, "epss_percentile": 0.52924}, "CVE-2024-40640": {"epss_score": 0.001, "epss_percentile": 0.28454}, "CVE-2024-40641": {"epss_score": 0.00048, "epss_percentile": 0.1514}, "CVE-2024-40642": {"epss_score": 0.00917, "epss_percentile": 0.75424}, "CVE-2024-40643": {"epss_score": 0.0041, "epss_percentile": 0.60811}, "CVE-2024-40644": {"epss_score": 0.00028, "epss_percentile": 0.07339}, "CVE-2024-40645": {"epss_score": 0.00299, "epss_percentile": 0.52849}, "CVE-2024-40647": {"epss_score": 0.00031, "epss_percentile": 0.08414}, "CVE-2024-40648": {"epss_score": 0.00066, "epss_percentile": 0.20733}, "CVE-2024-40649": {"epss_score": 0.00037, "epss_percentile": 0.1091}, "CVE-2024-40650": {"epss_score": 6e-05, "epss_percentile": 0.00272}, "CVE-2024-40651": {"epss_score": 0.00032, "epss_percentile": 0.09024}, "CVE-2024-40652": {"epss_score": 0.00048, "epss_percentile": 0.14987}, "CVE-2024-40653": {"epss_score": 0.00014, "epss_percentile": 0.01831}, "CVE-2024-40654": {"epss_score": 6e-05, "epss_percentile": 0.00295}, "CVE-2024-40655": {"epss_score": 5e-05, "epss_percentile": 0.00221}, "CVE-2024-40656": {"epss_score": 0.00055, "epss_percentile": 0.176}, "CVE-2024-40657": {"epss_score": 0.00045, "epss_percentile": 0.13984}, "CVE-2024-40658": {"epss_score": 0.00067, "epss_percentile": 0.21074}, "CVE-2024-40659": {"epss_score": 0.00037, "epss_percentile": 0.10665}, "CVE-2024-40660": {"epss_score": 0.00106, "epss_percentile": 0.2941}, "CVE-2024-40661": {"epss_score": 0.00052, "epss_percentile": 0.16671}, "CVE-2024-40662": {"epss_score": 0.00055, "epss_percentile": 0.17561}, "CVE-2024-40664": {"epss_score": 0.00182, "epss_percentile": 0.40234}, "CVE-2024-40669": {"epss_score": 0.00036, "epss_percentile": 0.10211}, "CVE-2024-40670": {"epss_score": 0.00032, "epss_percentile": 0.09024}, "CVE-2024-40671": {"epss_score": 0.00056, "epss_percentile": 0.17703}, "CVE-2024-40672": {"epss_score": 6e-05, "epss_percentile": 0.00255}, "CVE-2024-40673": {"epss_score": 0.01055, "epss_percentile": 0.77119}, "CVE-2024-40674": {"epss_score": 0.0008, "epss_percentile": 0.24132}, "CVE-2024-40675": {"epss_score": 0.00074, "epss_percentile": 0.22738}, "CVE-2024-40676": {"epss_score": 0.0013, "epss_percentile": 0.33341}, "CVE-2024-40677": {"epss_score": 6e-05, "epss_percentile": 0.00305}, "CVE-2024-40679": {"epss_score": 0.00075, "epss_percentile": 0.22966}, "CVE-2024-40680": {"epss_score": 0.00059, "epss_percentile": 0.1882}, "CVE-2024-40681": {"epss_score": 0.00025, "epss_percentile": 0.06141}, "CVE-2024-40682": {"epss_score": 0.00022, "epss_percentile": 0.05032}, "CVE-2024-40686": {"epss_score": 0.00023, "epss_percentile": 0.0533}, "CVE-2024-40689": {"epss_score": 0.00248, "epss_percentile": 0.47989}, "CVE-2024-40690": {"epss_score": 0.00237, "epss_percentile": 0.4666}, "CVE-2024-40691": {"epss_score": 0.00135, "epss_percentile": 0.33941}, "CVE-2024-40693": {"epss_score": 0.00109, "epss_percentile": 0.29996}, "CVE-2024-40695": {"epss_score": 0.00128, "epss_percentile": 0.33034}, "CVE-2024-40696": {"epss_score": 0.0005, "epss_percentile": 0.15858}, "CVE-2024-40697": {"epss_score": 0.00144, "epss_percentile": 0.3526}, "CVE-2024-40700": {"epss_score": 0.00308, "epss_percentile": 0.53616}, "CVE-2024-40702": {"epss_score": 0.0007, "epss_percentile": 0.2194}, "CVE-2024-40703": {"epss_score": 0.00023, "epss_percentile": 0.05475}, "CVE-2024-40704": {"epss_score": 0.00059, "epss_percentile": 0.18713}, "CVE-2024-40705": {"epss_score": 0.0009, "epss_percentile": 0.2617}, "CVE-2024-40706": {"epss_score": 0.00103, "epss_percentile": 0.29015}, "CVE-2024-40709": {"epss_score": 0.00083, "epss_percentile": 0.24813}, "CVE-2024-40710": {"epss_score": 0.0878, "epss_percentile": 0.92252}, "CVE-2024-40711": {"epss_score": 0.66734, "epss_percentile": 0.98477}, "CVE-2024-40712": {"epss_score": 0.00327, "epss_percentile": 0.55142}, "CVE-2024-40713": {"epss_score": 0.0003, "epss_percentile": 0.08234}, "CVE-2024-40714": {"epss_score": 0.00441, "epss_percentile": 0.62655}, "CVE-2024-40715": {"epss_score": 0.00108, "epss_percentile": 0.29823}, "CVE-2024-40717": {"epss_score": 0.00527, "epss_percentile": 0.66523}, "CVE-2024-40718": {"epss_score": 0.00202, "epss_percentile": 0.42478}, "CVE-2024-40719": {"epss_score": 0.00123, "epss_percentile": 0.32268}, "CVE-2024-40720": {"epss_score": 0.038, "epss_percentile": 0.87742}, "CVE-2024-40721": {"epss_score": 0.02284, "epss_percentile": 0.84263}, "CVE-2024-40722": {"epss_score": 0.0142, "epss_percentile": 0.8017}, "CVE-2024-40723": {"epss_score": 0.0142, "epss_percentile": 0.8017}, "CVE-2024-40724": {"epss_score": 0.00115, "epss_percentile": 0.31015}, "CVE-2024-40725": {"epss_score": 0.26567, "epss_percentile": 0.96158}, "CVE-2024-40726": {"epss_score": 0.00182, "epss_percentile": 0.40191}, "CVE-2024-40727": {"epss_score": 0.00409, "epss_percentile": 0.60696}, "CVE-2024-40728": {"epss_score": 0.00221, "epss_percentile": 0.44704}, "CVE-2024-40729": {"epss_score": 0.00282, "epss_percentile": 0.51262}, "CVE-2024-40730": {"epss_score": 0.00398, "epss_percentile": 0.60075}, "CVE-2024-40731": {"epss_score": 0.00313, "epss_percentile": 0.54016}, "CVE-2024-40732": {"epss_score": 0.00282, "epss_percentile": 0.51262}, "CVE-2024-40733": {"epss_score": 0.00398, "epss_percentile": 0.60075}, "CVE-2024-40734": {"epss_score": 0.00398, "epss_percentile": 0.60075}, "CVE-2024-40735": {"epss_score": 0.00313, "epss_percentile": 0.54016}, "CVE-2024-40736": {"epss_score": 0.00313, "epss_percentile": 0.54016}, "CVE-2024-40737": {"epss_score": 0.00313, "epss_percentile": 0.54016}, "CVE-2024-40738": {"epss_score": 0.00221, "epss_percentile": 0.44704}, "CVE-2024-40739": {"epss_score": 0.00142, "epss_percentile": 0.35034}, "CVE-2024-40740": {"epss_score": 0.00092, "epss_percentile": 0.26519}, "CVE-2024-40741": {"epss_score": 0.00101, "epss_percentile": 0.28583}, "CVE-2024-40742": {"epss_score": 0.00181, "epss_percentile": 0.40089}, "CVE-2024-40743": {"epss_score": 0.00056, "epss_percentile": 0.17664}, "CVE-2024-40744": {"epss_score": 0.00485, "epss_percentile": 0.64736}, "CVE-2024-40745": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2024-40746": {"epss_score": 0.00105, "epss_percentile": 0.29344}, "CVE-2024-40747": {"epss_score": 0.00013, "epss_percentile": 0.01482}, "CVE-2024-40748": {"epss_score": 6e-05, "epss_percentile": 0.003}, "CVE-2024-40749": {"epss_score": 4e-05, "epss_percentile": 0.00153}, "CVE-2024-40750": {"epss_score": 0.00039, "epss_percentile": 0.11582}, "CVE-2024-40754": {"epss_score": 0.00206, "epss_percentile": 0.4277}, "CVE-2024-40761": {"epss_score": 0.00595, "epss_percentile": 0.68685}, "CVE-2024-40762": {"epss_score": 0.0014, "epss_percentile": 0.34765}, "CVE-2024-40763": {"epss_score": 0.0033, "epss_percentile": 0.55487}, "CVE-2024-40764": {"epss_score": 0.06412, "epss_percentile": 0.90742}, "CVE-2024-40765": {"epss_score": 0.00338, "epss_percentile": 0.56155}, "CVE-2024-40766": {"epss_score": 0.04021, "epss_percentile": 0.88133}, "CVE-2024-40767": {"epss_score": 0.00835, "epss_percentile": 0.74126}, "CVE-2024-40770": {"epss_score": 0.00066, "epss_percentile": 0.20853}, "CVE-2024-40771": {"epss_score": 0.00062, "epss_percentile": 0.19777}, "CVE-2024-40774": {"epss_score": 0.00013, "epss_percentile": 0.01609}, "CVE-2024-40775": {"epss_score": 0.00023, "epss_percentile": 0.05333}, "CVE-2024-40776": {"epss_score": 0.00441, "epss_percentile": 0.62683}, "CVE-2024-40777": {"epss_score": 0.00397, "epss_percentile": 0.60018}, "CVE-2024-40778": {"epss_score": 0.00023, "epss_percentile": 0.05641}, "CVE-2024-40779": {"epss_score": 0.00027, "epss_percentile": 0.07076}, "CVE-2024-40780": {"epss_score": 0.00087, "epss_percentile": 0.25539}, "CVE-2024-40781": {"epss_score": 0.00021, "epss_percentile": 0.04702}, "CVE-2024-40782": {"epss_score": 0.00445, "epss_percentile": 0.62881}, "CVE-2024-40783": {"epss_score": 9e-05, "epss_percentile": 0.00655}, "CVE-2024-40784": {"epss_score": 0.00018, "epss_percentile": 0.03678}, "CVE-2024-40785": {"epss_score": 0.00355, "epss_percentile": 0.57317}, "CVE-2024-40786": {"epss_score": 0.00207, "epss_percentile": 0.43201}, "CVE-2024-40787": {"epss_score": 0.00019, "epss_percentile": 0.04246}, "CVE-2024-40788": {"epss_score": 0.00029, "epss_percentile": 0.07842}, "CVE-2024-40789": {"epss_score": 0.00683, "epss_percentile": 0.71095}, "CVE-2024-40790": {"epss_score": 0.00048, "epss_percentile": 0.15076}, "CVE-2024-40791": {"epss_score": 0.00019, "epss_percentile": 0.04139}, "CVE-2024-40792": {"epss_score": 0.00115, "epss_percentile": 0.30904}, "CVE-2024-40793": {"epss_score": 0.00017, "epss_percentile": 0.0341}, "CVE-2024-40794": {"epss_score": 0.00526, "epss_percentile": 0.66404}, "CVE-2024-40795": {"epss_score": 0.00025, "epss_percentile": 0.06333}, "CVE-2024-40796": {"epss_score": 0.0027, "epss_percentile": 0.50206}, "CVE-2024-40797": {"epss_score": 0.00126, "epss_percentile": 0.32699}, "CVE-2024-40798": {"epss_score": 0.00025, "epss_percentile": 0.06333}, "CVE-2024-40799": {"epss_score": 0.00031, "epss_percentile": 0.08639}, "CVE-2024-40800": {"epss_score": 0.00027, "epss_percentile": 0.06875}, "CVE-2024-40801": {"epss_score": 0.00024, "epss_percentile": 0.0586}, "CVE-2024-40802": {"epss_score": 0.0002, "epss_percentile": 0.04423}, "CVE-2024-40803": {"epss_score": 0.00257, "epss_percentile": 0.4891}, "CVE-2024-40804": {"epss_score": 0.00123, "epss_percentile": 0.32177}, "CVE-2024-40805": {"epss_score": 0.00013, "epss_percentile": 0.01571}, "CVE-2024-40806": {"epss_score": 0.00042, "epss_percentile": 0.12569}, "CVE-2024-40807": {"epss_score": 0.00033, "epss_percentile": 0.09369}, "CVE-2024-40809": {"epss_score": 0.00024, "epss_percentile": 0.05749}, "CVE-2024-40810": {"epss_score": 0.00114, "epss_percentile": 0.30838}, "CVE-2024-40811": {"epss_score": 0.00065, "epss_percentile": 0.20567}, "CVE-2024-40812": {"epss_score": 0.00019, "epss_percentile": 0.04282}, "CVE-2024-40813": {"epss_score": 0.001, "epss_percentile": 0.28526}, "CVE-2024-40814": {"epss_score": 0.00029, "epss_percentile": 0.07613}, "CVE-2024-40815": {"epss_score": 0.064, "epss_percentile": 0.90727}, "CVE-2024-40816": {"epss_score": 0.00029, "epss_percentile": 0.07905}, "CVE-2024-40817": {"epss_score": 0.00537, "epss_percentile": 0.66893}, "CVE-2024-40818": {"epss_score": 0.00159, "epss_percentile": 0.37408}, "CVE-2024-40821": {"epss_score": 0.00038, "epss_percentile": 0.11418}, "CVE-2024-40822": {"epss_score": 0.00132, "epss_percentile": 0.33528}, "CVE-2024-40823": {"epss_score": 0.00041, "epss_percentile": 0.12427}, "CVE-2024-40824": {"epss_score": 0.00013, "epss_percentile": 0.01482}, "CVE-2024-40825": {"epss_score": 0.0002, "epss_percentile": 0.04471}, "CVE-2024-40826": {"epss_score": 0.00032, "epss_percentile": 0.09021}, "CVE-2024-40827": {"epss_score": 0.00028, "epss_percentile": 0.07509}, "CVE-2024-40828": {"epss_score": 0.00039, "epss_percentile": 0.11584}, "CVE-2024-40829": {"epss_score": 0.00317, "epss_percentile": 0.54346}, "CVE-2024-40830": {"epss_score": 0.00052, "epss_percentile": 0.16353}, "CVE-2024-40831": {"epss_score": 0.00038, "epss_percentile": 0.11304}, "CVE-2024-40832": {"epss_score": 0.00144, "epss_percentile": 0.35249}, "CVE-2024-40833": {"epss_score": 0.00041, "epss_percentile": 0.12221}, "CVE-2024-40834": {"epss_score": 0.00015, "epss_percentile": 0.02165}, "CVE-2024-40835": {"epss_score": 0.00052, "epss_percentile": 0.16478}, "CVE-2024-40836": {"epss_score": 0.0015, "epss_percentile": 0.36183}, "CVE-2024-40837": {"epss_score": 0.00036, "epss_percentile": 0.1051}, "CVE-2024-40838": {"epss_score": 0.0005, "epss_percentile": 0.15678}, "CVE-2024-40839": {"epss_score": 0.00047, "epss_percentile": 0.14913}, "CVE-2024-40840": {"epss_score": 0.00048, "epss_percentile": 0.15109}, "CVE-2024-40841": {"epss_score": 0.00038, "epss_percentile": 0.11417}, "CVE-2024-40842": {"epss_score": 0.00035, "epss_percentile": 0.10129}, "CVE-2024-40843": {"epss_score": 0.00041, "epss_percentile": 0.12475}, "CVE-2024-40844": {"epss_score": 0.00017, "epss_percentile": 0.03355}, "CVE-2024-40845": {"epss_score": 0.00052, "epss_percentile": 0.16497}, "CVE-2024-40846": {"epss_score": 0.00054, "epss_percentile": 0.1715}, "CVE-2024-40847": {"epss_score": 0.00018, "epss_percentile": 0.03758}, "CVE-2024-40848": {"epss_score": 0.00142, "epss_percentile": 0.34988}, "CVE-2024-40850": {"epss_score": 0.0002, "epss_percentile": 0.04688}, "CVE-2024-40851": {"epss_score": 0.00094, "epss_percentile": 0.27006}, "CVE-2024-40852": {"epss_score": 0.00138, "epss_percentile": 0.3443}, "CVE-2024-40853": {"epss_score": 0.00173, "epss_percentile": 0.39104}, "CVE-2024-40854": {"epss_score": 0.00175, "epss_percentile": 0.39342}, "CVE-2024-40855": {"epss_score": 0.00032, "epss_percentile": 0.0901}, "CVE-2024-40856": {"epss_score": 0.00135, "epss_percentile": 0.34004}, "CVE-2024-40857": {"epss_score": 0.00111, "epss_percentile": 0.30396}, "CVE-2024-40859": {"epss_score": 0.00024, "epss_percentile": 0.05777}, "CVE-2024-40860": {"epss_score": 0.00031, "epss_percentile": 0.08571}, "CVE-2024-40861": {"epss_score": 0.00044, "epss_percentile": 0.13441}, "CVE-2024-40862": {"epss_score": 0.00162, "epss_percentile": 0.37639}, "CVE-2024-40863": {"epss_score": 0.00048, "epss_percentile": 0.15076}, "CVE-2024-40864": {"epss_score": 0.00092, "epss_percentile": 0.26521}, "CVE-2024-40865": {"epss_score": 0.00282, "epss_percentile": 0.51235}, "CVE-2024-40866": {"epss_score": 0.00109, "epss_percentile": 0.29998}, "CVE-2024-40867": {"epss_score": 0.00609, "epss_percentile": 0.69087}, "CVE-2024-40872": {"epss_score": 0.00155, "epss_percentile": 0.36801}, "CVE-2024-40873": {"epss_score": 0.00386, "epss_percentile": 0.59249}, "CVE-2024-40875": {"epss_score": 0.00178, "epss_percentile": 0.39709}, "CVE-2024-40883": {"epss_score": 0.00228, "epss_percentile": 0.45531}, "CVE-2024-40884": {"epss_score": 0.00098, "epss_percentile": 0.27801}, "CVE-2024-40885": {"epss_score": 0.0006, "epss_percentile": 0.18982}, "CVE-2024-40886": {"epss_score": 0.00183, "epss_percentile": 0.40361}, "CVE-2024-40887": {"epss_score": 0.00025, "epss_percentile": 0.06295}, "CVE-2024-40890": {"epss_score": 0.16901, "epss_percentile": 0.94745}, "CVE-2024-40891": {"epss_score": 0.39299, "epss_percentile": 0.97153}, "CVE-2024-40892": {"epss_score": 0.07093, "epss_percentile": 0.91245}, "CVE-2024-40893": {"epss_score": 0.01517, "epss_percentile": 0.8081}, "CVE-2024-40895": {"epss_score": 0.01303, "epss_percentile": 0.79308}, "CVE-2024-40896": {"epss_score": 0.00553, "epss_percentile": 0.67425}, "CVE-2024-40897": {"epss_score": 0.00055, "epss_percentile": 0.17602}, "CVE-2024-40898": {"epss_score": 0.00472, "epss_percentile": 0.64029}, "CVE-2024-40899": {"epss_score": 0.00015, "epss_percentile": 0.02165}, "CVE-2024-40900": {"epss_score": 0.00015, "epss_percentile": 0.02165}, "CVE-2024-40901": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2024-40902": {"epss_score": 0.00015, "epss_percentile": 0.0213}, "CVE-2024-40903": {"epss_score": 0.00012, "epss_percentile": 0.01195}, "CVE-2024-40904": {"epss_score": 0.0001, "epss_percentile": 0.00807}, "CVE-2024-40905": {"epss_score": 0.0001, "epss_percentile": 0.00826}, "CVE-2024-40906": {"epss_score": 0.00013, "epss_percentile": 0.01487}, "CVE-2024-40907": {"epss_score": 0.00017, "epss_percentile": 0.03202}, "CVE-2024-40908": {"epss_score": 0.00016, "epss_percentile": 0.0262}, "CVE-2024-40909": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-40910": {"epss_score": 0.00031, "epss_percentile": 0.08462}, "CVE-2024-40911": {"epss_score": 9e-05, "epss_percentile": 0.00649}, "CVE-2024-40912": {"epss_score": 8e-05, "epss_percentile": 0.0049}, "CVE-2024-40913": {"epss_score": 0.00015, "epss_percentile": 0.02165}, "CVE-2024-40914": {"epss_score": 0.0001, "epss_percentile": 0.0076}, "CVE-2024-40915": {"epss_score": 0.00011, "epss_percentile": 0.01028}, "CVE-2024-40916": {"epss_score": 0.00017, "epss_percentile": 0.03231}, "CVE-2024-40917": {"epss_score": 0.00035, "epss_percentile": 0.09941}, "CVE-2024-40918": {"epss_score": 0.0004, "epss_percentile": 0.11908}, "CVE-2024-40919": {"epss_score": 0.00012, "epss_percentile": 0.01309}, "CVE-2024-40920": {"epss_score": 0.00012, "epss_percentile": 0.01195}, "CVE-2024-40921": {"epss_score": 0.00012, "epss_percentile": 0.01309}, "CVE-2024-40922": {"epss_score": 0.00017, "epss_percentile": 0.0327}, "CVE-2024-40923": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-40924": {"epss_score": 0.00012, "epss_percentile": 0.01309}, "CVE-2024-40925": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-40926": {"epss_score": 0.00014, "epss_percentile": 0.02101}, "CVE-2024-40927": {"epss_score": 0.00012, "epss_percentile": 0.01226}, "CVE-2024-40928": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2024-40929": {"epss_score": 7e-05, "epss_percentile": 0.00349}, "CVE-2024-40930": {"epss_score": 0.00019, "epss_percentile": 0.04353}, "CVE-2024-40931": {"epss_score": 0.0001, "epss_percentile": 0.00764}, "CVE-2024-40932": {"epss_score": 0.00016, "epss_percentile": 0.02826}, "CVE-2024-40933": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-40934": {"epss_score": 0.00017, "epss_percentile": 0.03188}, "CVE-2024-40935": {"epss_score": 0.00014, "epss_percentile": 0.01898}, "CVE-2024-40936": {"epss_score": 0.0001, "epss_percentile": 0.00915}, "CVE-2024-40937": {"epss_score": 0.0001, "epss_percentile": 0.0076}, "CVE-2024-40938": {"epss_score": 0.00021, "epss_percentile": 0.04757}, "CVE-2024-40939": {"epss_score": 0.00012, "epss_percentile": 0.01195}, "CVE-2024-40940": {"epss_score": 0.00015, "epss_percentile": 0.02165}, "CVE-2024-40941": {"epss_score": 0.0001, "epss_percentile": 0.00807}, "CVE-2024-40942": {"epss_score": 0.00016, "epss_percentile": 0.02826}, "CVE-2024-40943": {"epss_score": 8e-05, "epss_percentile": 0.00567}, "CVE-2024-40944": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-40945": {"epss_score": 0.00013, "epss_percentile": 0.01654}, "CVE-2024-40947": {"epss_score": 0.00018, "epss_percentile": 0.03616}, "CVE-2024-40948": {"epss_score": 0.00023, "epss_percentile": 0.05338}, "CVE-2024-40949": {"epss_score": 0.00041, "epss_percentile": 0.12375}, "CVE-2024-40950": {"epss_score": 0.00083, "epss_percentile": 0.24614}, "CVE-2024-40951": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-40952": {"epss_score": 0.00035, "epss_percentile": 0.09941}, "CVE-2024-40953": {"epss_score": 8e-05, "epss_percentile": 0.00488}, "CVE-2024-40954": {"epss_score": 0.00012, "epss_percentile": 0.01231}, "CVE-2024-40955": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-40956": {"epss_score": 0.00012, "epss_percentile": 0.01226}, "CVE-2024-40957": {"epss_score": 0.0001, "epss_percentile": 0.0076}, "CVE-2024-40958": {"epss_score": 0.00011, "epss_percentile": 0.01087}, "CVE-2024-40959": {"epss_score": 0.0001, "epss_percentile": 0.00807}, "CVE-2024-40960": {"epss_score": 0.0001, "epss_percentile": 0.00807}, "CVE-2024-40961": {"epss_score": 9e-05, "epss_percentile": 0.00707}, "CVE-2024-40962": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-40963": {"epss_score": 0.00017, "epss_percentile": 0.03231}, "CVE-2024-40964": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-40965": {"epss_score": 7e-05, "epss_percentile": 0.00336}, "CVE-2024-40966": {"epss_score": 0.00023, "epss_percentile": 0.05338}, "CVE-2024-40967": {"epss_score": 8e-05, "epss_percentile": 0.00472}, "CVE-2024-40968": {"epss_score": 0.00016, "epss_percentile": 0.02861}, "CVE-2024-40969": {"epss_score": 0.00014, "epss_percentile": 0.01929}, "CVE-2024-40970": {"epss_score": 0.00018, "epss_percentile": 0.03616}, "CVE-2024-40971": {"epss_score": 0.00015, "epss_percentile": 0.02468}, "CVE-2024-40972": {"epss_score": 9e-05, "epss_percentile": 0.00639}, "CVE-2024-40973": {"epss_score": 0.00016, "epss_percentile": 0.02934}, "CVE-2024-40974": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2024-40975": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-40976": {"epss_score": 0.00014, "epss_percentile": 0.01846}, "CVE-2024-40977": {"epss_score": 0.00016, "epss_percentile": 0.02693}, "CVE-2024-40978": {"epss_score": 7e-05, "epss_percentile": 0.00364}, "CVE-2024-40979": {"epss_score": 0.00017, "epss_percentile": 0.03202}, "CVE-2024-40980": {"epss_score": 8e-05, "epss_percentile": 0.00502}, "CVE-2024-40981": {"epss_score": 3e-05, "epss_percentile": 0.00095}, "CVE-2024-40983": {"epss_score": 0.0001, "epss_percentile": 0.00764}, "CVE-2024-40984": {"epss_score": 0.00018, "epss_percentile": 0.03684}, "CVE-2024-40985": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-40986": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-40987": {"epss_score": 0.00029, "epss_percentile": 0.07845}, "CVE-2024-40988": {"epss_score": 0.00019, "epss_percentile": 0.0427}, "CVE-2024-40989": {"epss_score": 0.00023, "epss_percentile": 0.05491}, "CVE-2024-40990": {"epss_score": 0.00032, "epss_percentile": 0.09045}, "CVE-2024-40991": {"epss_score": 0.00037, "epss_percentile": 0.10631}, "CVE-2024-40992": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-40993": {"epss_score": 0.00028, "epss_percentile": 0.07583}, "CVE-2024-40994": {"epss_score": 0.00023, "epss_percentile": 0.056}, "CVE-2024-40995": {"epss_score": 9e-05, "epss_percentile": 0.00732}, "CVE-2024-40996": {"epss_score": 0.00027, "epss_percentile": 0.06778}, "CVE-2024-40997": {"epss_score": 0.00016, "epss_percentile": 0.02886}, "CVE-2024-40998": {"epss_score": 0.00018, "epss_percentile": 0.03658}, "CVE-2024-40999": {"epss_score": 0.00018, "epss_percentile": 0.03857}, "CVE-2024-41000": {"epss_score": 0.00029, "epss_percentile": 0.07815}, "CVE-2024-41001": {"epss_score": 0.0002, "epss_percentile": 0.04599}, "CVE-2024-41002": {"epss_score": 0.00027, "epss_percentile": 0.06935}, "CVE-2024-41003": {"epss_score": 0.00024, "epss_percentile": 0.05994}, "CVE-2024-41004": {"epss_score": 0.00019, "epss_percentile": 0.04168}, "CVE-2024-41005": {"epss_score": 0.00014, "epss_percentile": 0.01761}, "CVE-2024-41006": {"epss_score": 0.00029, "epss_percentile": 0.07845}, "CVE-2024-41007": {"epss_score": 0.0002, "epss_percentile": 0.0443}, "CVE-2024-41008": {"epss_score": 0.00018, "epss_percentile": 0.03857}, "CVE-2024-41009": {"epss_score": 0.00028, "epss_percentile": 0.07538}, "CVE-2024-41010": {"epss_score": 0.00099, "epss_percentile": 0.28353}, "CVE-2024-41011": {"epss_score": 0.00022, "epss_percentile": 0.05261}, "CVE-2024-41012": {"epss_score": 0.00013, "epss_percentile": 0.01675}, "CVE-2024-41013": {"epss_score": 0.00014, "epss_percentile": 0.01982}, "CVE-2024-41014": {"epss_score": 0.00014, "epss_percentile": 0.02012}, "CVE-2024-41015": {"epss_score": 0.00018, "epss_percentile": 0.03624}, "CVE-2024-41016": {"epss_score": 0.00018, "epss_percentile": 0.03624}, "CVE-2024-41017": {"epss_score": 0.00018, "epss_percentile": 0.03624}, "CVE-2024-41018": {"epss_score": 0.00016, "epss_percentile": 0.02927}, "CVE-2024-41019": {"epss_score": 0.00013, "epss_percentile": 0.01547}, "CVE-2024-41020": {"epss_score": 0.00015, "epss_percentile": 0.02341}, "CVE-2024-41021": {"epss_score": 0.00028, "epss_percentile": 0.07261}, "CVE-2024-41022": {"epss_score": 0.00019, "epss_percentile": 0.04333}, "CVE-2024-41023": {"epss_score": 0.0001, "epss_percentile": 0.00784}, "CVE-2024-41025": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-41026": {"epss_score": 0.00083, "epss_percentile": 0.24614}, "CVE-2024-41027": {"epss_score": 7e-05, "epss_percentile": 0.00439}, "CVE-2024-41028": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2024-41029": {"epss_score": 0.00013, "epss_percentile": 0.01565}, "CVE-2024-41030": {"epss_score": 0.00018, "epss_percentile": 0.03931}, "CVE-2024-41031": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-41032": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-41033": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-41034": {"epss_score": 0.00011, "epss_percentile": 0.00955}, "CVE-2024-41035": {"epss_score": 0.00011, "epss_percentile": 0.00955}, "CVE-2024-41036": {"epss_score": 0.00023, "epss_percentile": 0.05425}, "CVE-2024-41037": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-41038": {"epss_score": 0.00011, "epss_percentile": 0.00965}, "CVE-2024-41039": {"epss_score": 0.00015, "epss_percentile": 0.0234}, "CVE-2024-41040": {"epss_score": 0.00013, "epss_percentile": 0.01513}, "CVE-2024-41041": {"epss_score": 0.0001, "epss_percentile": 0.00826}, "CVE-2024-41042": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2024-41043": {"epss_score": 0.00041, "epss_percentile": 0.12447}, "CVE-2024-41044": {"epss_score": 0.0001, "epss_percentile": 0.00793}, "CVE-2024-41045": {"epss_score": 0.00014, "epss_percentile": 0.0201}, "CVE-2024-41046": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2024-41047": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2024-41048": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2024-41049": {"epss_score": 0.00012, "epss_percentile": 0.01328}, "CVE-2024-41050": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2024-41051": {"epss_score": 0.00019, "epss_percentile": 0.04124}, "CVE-2024-41052": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-41053": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-41054": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-41055": {"epss_score": 0.00011, "epss_percentile": 0.00977}, "CVE-2024-41056": {"epss_score": 0.00011, "epss_percentile": 0.00981}, "CVE-2024-41057": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-41058": {"epss_score": 0.00015, "epss_percentile": 0.0234}, "CVE-2024-41059": {"epss_score": 7e-05, "epss_percentile": 0.00355}, "CVE-2024-41060": {"epss_score": 6e-05, "epss_percentile": 0.00314}, "CVE-2024-41061": {"epss_score": 0.00022, "epss_percentile": 0.05168}, "CVE-2024-41062": {"epss_score": 0.00015, "epss_percentile": 0.02462}, "CVE-2024-41063": {"epss_score": 0.00014, "epss_percentile": 0.01849}, "CVE-2024-41064": {"epss_score": 0.00017, "epss_percentile": 0.03096}, "CVE-2024-41065": {"epss_score": 0.00017, "epss_percentile": 0.03096}, "CVE-2024-41066": {"epss_score": 0.00015, "epss_percentile": 0.02395}, "CVE-2024-41067": {"epss_score": 0.00028, "epss_percentile": 0.07576}, "CVE-2024-41068": {"epss_score": 0.00018, "epss_percentile": 0.03624}, "CVE-2024-41069": {"epss_score": 0.00024, "epss_percentile": 0.05963}, "CVE-2024-41070": {"epss_score": 0.0002, "epss_percentile": 0.0467}, "CVE-2024-41072": {"epss_score": 0.00027, "epss_percentile": 0.0689}, "CVE-2024-41073": {"epss_score": 0.00021, "epss_percentile": 0.04697}, "CVE-2024-41074": {"epss_score": 0.00034, "epss_percentile": 0.09728}, "CVE-2024-41075": {"epss_score": 0.00033, "epss_percentile": 0.0943}, "CVE-2024-41076": {"epss_score": 0.00015, "epss_percentile": 0.02395}, "CVE-2024-41077": {"epss_score": 0.00017, "epss_percentile": 0.03397}, "CVE-2024-41078": {"epss_score": 0.00017, "epss_percentile": 0.0333}, "CVE-2024-41079": {"epss_score": 0.00015, "epss_percentile": 0.02462}, "CVE-2024-41080": {"epss_score": 0.00012, "epss_percentile": 0.01207}, "CVE-2024-41081": {"epss_score": 0.00019, "epss_percentile": 0.04333}, "CVE-2024-41082": {"epss_score": 0.00014, "epss_percentile": 0.01987}, "CVE-2024-41083": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-41084": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-41085": {"epss_score": 9e-05, "epss_percentile": 0.0072}, "CVE-2024-41086": {"epss_score": 0.0001, "epss_percentile": 0.00916}, "CVE-2024-41087": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2024-41088": {"epss_score": 0.00018, "epss_percentile": 0.03931}, "CVE-2024-41089": {"epss_score": 7e-05, "epss_percentile": 0.00353}, "CVE-2024-41090": {"epss_score": 0.00015, "epss_percentile": 0.02246}, "CVE-2024-41091": {"epss_score": 0.00013, "epss_percentile": 0.01675}, "CVE-2024-41092": {"epss_score": 0.00015, "epss_percentile": 0.0243}, "CVE-2024-41093": {"epss_score": 7e-05, "epss_percentile": 0.00342}, "CVE-2024-41094": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-41095": {"epss_score": 7e-05, "epss_percentile": 0.00353}, "CVE-2024-41096": {"epss_score": 0.00012, "epss_percentile": 0.01195}, "CVE-2024-41097": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-41098": {"epss_score": 0.0001, "epss_percentile": 0.00755}, "CVE-2024-41107": {"epss_score": 0.93066, "epss_percentile": 0.99773}, "CVE-2024-41108": {"epss_score": 0.00408, "epss_percentile": 0.60623}, "CVE-2024-41109": {"epss_score": 0.0005, "epss_percentile": 0.15851}, "CVE-2024-41110": {"epss_score": 0.02908, "epss_percentile": 0.85967}, "CVE-2024-41111": {"epss_score": 0.00227, "epss_percentile": 0.45426}, "CVE-2024-41112": {"epss_score": 0.01559, "epss_percentile": 0.81034}, "CVE-2024-41113": {"epss_score": 0.01559, "epss_percentile": 0.81034}, "CVE-2024-41114": {"epss_score": 0.01307, "epss_percentile": 0.79339}, "CVE-2024-41115": {"epss_score": 0.01121, "epss_percentile": 0.77776}, "CVE-2024-41116": {"epss_score": 0.0196, "epss_percentile": 0.83059}, "CVE-2024-41117": {"epss_score": 0.02335, "epss_percentile": 0.84414}, "CVE-2024-41118": {"epss_score": 0.00214, "epss_percentile": 0.43958}, "CVE-2024-41119": {"epss_score": 0.01559, "epss_percentile": 0.81034}, "CVE-2024-41120": {"epss_score": 0.00199, "epss_percentile": 0.42121}, "CVE-2024-41121": {"epss_score": 0.00451, "epss_percentile": 0.63114}, "CVE-2024-41122": {"epss_score": 0.00314, "epss_percentile": 0.5412}, "CVE-2024-41123": {"epss_score": 0.00232, "epss_percentile": 0.45958}, "CVE-2024-41124": {"epss_score": 0.00027, "epss_percentile": 0.06876}, "CVE-2024-41125": {"epss_score": 0.00086, "epss_percentile": 0.25368}, "CVE-2024-41126": {"epss_score": 0.00086, "epss_percentile": 0.25368}, "CVE-2024-41127": {"epss_score": 0.01082, "epss_percentile": 0.7738}, "CVE-2024-41128": {"epss_score": 0.00411, "epss_percentile": 0.60862}, "CVE-2024-41129": {"epss_score": 0.00044, "epss_percentile": 0.13546}, "CVE-2024-41130": {"epss_score": 0.00098, "epss_percentile": 0.27802}, "CVE-2024-41131": {"epss_score": 0.00523, "epss_percentile": 0.66293}, "CVE-2024-41132": {"epss_score": 0.00639, "epss_percentile": 0.69952}, "CVE-2024-41133": {"epss_score": 0.0073, "epss_percentile": 0.72152}, "CVE-2024-41134": {"epss_score": 0.0073, "epss_percentile": 0.72152}, "CVE-2024-41135": {"epss_score": 0.0073, "epss_percentile": 0.72152}, "CVE-2024-41136": {"epss_score": 0.00327, "epss_percentile": 0.55092}, "CVE-2024-41138": {"epss_score": 0.00058, "epss_percentile": 0.18356}, "CVE-2024-41139": {"epss_score": 0.00107, "epss_percentile": 0.29735}, "CVE-2024-41140": {"epss_score": 0.00111, "epss_percentile": 0.30393}, "CVE-2024-41141": {"epss_score": 0.0027, "epss_percentile": 0.50196}, "CVE-2024-41143": {"epss_score": 0.00076, "epss_percentile": 0.2314}, "CVE-2024-41144": {"epss_score": 0.00092, "epss_percentile": 0.26457}, "CVE-2024-41145": {"epss_score": 0.0005, "epss_percentile": 0.15671}, "CVE-2024-41146": {"epss_score": 0.00056, "epss_percentile": 0.17853}, "CVE-2024-41147": {"epss_score": 0.00228, "epss_percentile": 0.45469}, "CVE-2024-41148": {"epss_score": 0.00018, "epss_percentile": 0.03861}, "CVE-2024-41149": {"epss_score": 0.00037, "epss_percentile": 0.1066}, "CVE-2024-41150": {"epss_score": 0.00377, "epss_percentile": 0.58755}, "CVE-2024-41151": {"epss_score": 0.00558, "epss_percentile": 0.67573}, "CVE-2024-41153": {"epss_score": 0.00152, "epss_percentile": 0.36485}, "CVE-2024-41156": {"epss_score": 0.00128, "epss_percentile": 0.33015}, "CVE-2024-41157": {"epss_score": 0.00069, "epss_percentile": 0.21516}, "CVE-2024-41159": {"epss_score": 0.00015, "epss_percentile": 0.02428}, "CVE-2024-41160": {"epss_score": 0.00047, "epss_percentile": 0.14912}, "CVE-2024-41161": {"epss_score": 0.00134, "epss_percentile": 0.33771}, "CVE-2024-41162": {"epss_score": 0.00142, "epss_percentile": 0.35044}, "CVE-2024-41163": {"epss_score": 0.60281, "epss_percentile": 0.98202}, "CVE-2024-41164": {"epss_score": 0.00666, "epss_percentile": 0.70697}, "CVE-2024-41165": {"epss_score": 0.00059, "epss_percentile": 0.18646}, "CVE-2024-41166": {"epss_score": 0.00032, "epss_percentile": 0.09115}, "CVE-2024-41167": {"epss_score": 0.00076, "epss_percentile": 0.23108}, "CVE-2024-41168": {"epss_score": 0.00043, "epss_percentile": 0.13205}, "CVE-2024-41169": {"epss_score": 0.0004, "epss_percentile": 0.11877}, "CVE-2024-41170": {"epss_score": 0.00087, "epss_percentile": 0.25549}, "CVE-2024-41171": {"epss_score": 0.00042, "epss_percentile": 0.12627}, "CVE-2024-41172": {"epss_score": 0.00889, "epss_percentile": 0.75021}, "CVE-2024-41173": {"epss_score": 7e-05, "epss_percentile": 0.00378}, "CVE-2024-41174": {"epss_score": 0.00066, "epss_percentile": 0.20897}, "CVE-2024-41175": {"epss_score": 0.00128, "epss_percentile": 0.33007}, "CVE-2024-41176": {"epss_score": 0.00096, "epss_percentile": 0.27373}, "CVE-2024-41177": {"epss_score": 0.00131, "epss_percentile": 0.33496}, "CVE-2024-41178": {"epss_score": 0.00289, "epss_percentile": 0.52073}, "CVE-2024-41183": {"epss_score": 0.00097, "epss_percentile": 0.27455}, "CVE-2024-41184": {"epss_score": 0.00209, "epss_percentile": 0.43392}, "CVE-2024-41195": {"epss_score": 0.00027, "epss_percentile": 0.06769}, "CVE-2024-41196": {"epss_score": 0.00038, "epss_percentile": 0.11416}, "CVE-2024-41197": {"epss_score": 0.00027, "epss_percentile": 0.06769}, "CVE-2024-41198": {"epss_score": 0.00027, "epss_percentile": 0.06769}, "CVE-2024-41199": {"epss_score": 0.00024, "epss_percentile": 0.06014}, "CVE-2024-41200": {"epss_score": 0.001, "epss_percentile": 0.285}, "CVE-2024-41206": {"epss_score": 0.00257, "epss_percentile": 0.48921}, "CVE-2024-41209": {"epss_score": 0.00916, "epss_percentile": 0.75423}, "CVE-2024-41217": {"epss_score": 0.00303, "epss_percentile": 0.5323}, "CVE-2024-41226": {"epss_score": 0.00334, "epss_percentile": 0.55731}, "CVE-2024-41228": {"epss_score": 0.00119, "epss_percentile": 0.31575}, "CVE-2024-41236": {"epss_score": 0.0007, "epss_percentile": 0.21657}, "CVE-2024-41237": {"epss_score": 0.00122, "epss_percentile": 0.32035}, "CVE-2024-41238": {"epss_score": 0.00104, "epss_percentile": 0.29201}, "CVE-2024-41239": {"epss_score": 0.00166, "epss_percentile": 0.38166}, "CVE-2024-41240": {"epss_score": 0.00174, "epss_percentile": 0.39222}, "CVE-2024-41241": {"epss_score": 0.00172, "epss_percentile": 0.38902}, "CVE-2024-41242": {"epss_score": 0.00222, "epss_percentile": 0.44787}, "CVE-2024-41243": {"epss_score": 0.00226, "epss_percentile": 0.45342}, "CVE-2024-41244": {"epss_score": 0.00236, "epss_percentile": 0.46436}, "CVE-2024-41245": {"epss_score": 0.00237, "epss_percentile": 0.46722}, "CVE-2024-41246": {"epss_score": 0.00303, "epss_percentile": 0.5317}, "CVE-2024-41247": {"epss_score": 0.00432, "epss_percentile": 0.62098}, "CVE-2024-41248": {"epss_score": 0.00247, "epss_percentile": 0.47886}, "CVE-2024-41249": {"epss_score": 0.00317, "epss_percentile": 0.54363}, "CVE-2024-41250": {"epss_score": 0.00225, "epss_percentile": 0.45226}, "CVE-2024-41251": {"epss_score": 0.00286, "epss_percentile": 0.51751}, "CVE-2024-41252": {"epss_score": 0.0056, "epss_percentile": 0.67645}, "CVE-2024-41253": {"epss_score": 0.00061, "epss_percentile": 0.19434}, "CVE-2024-41254": {"epss_score": 0.0006, "epss_percentile": 0.19109}, "CVE-2024-41255": {"epss_score": 0.00041, "epss_percentile": 0.12336}, "CVE-2024-41256": {"epss_score": 0.00121, "epss_percentile": 0.31842}, "CVE-2024-41258": {"epss_score": 0.0006, "epss_percentile": 0.19109}, "CVE-2024-41259": {"epss_score": 0.00188, "epss_percentile": 0.40917}, "CVE-2024-41260": {"epss_score": 0.00168, "epss_percentile": 0.38407}, "CVE-2024-41262": {"epss_score": 0.00069, "epss_percentile": 0.21493}, "CVE-2024-41264": {"epss_score": 0.00073, "epss_percentile": 0.22578}, "CVE-2024-41265": {"epss_score": 0.0013, "epss_percentile": 0.33267}, "CVE-2024-41270": {"epss_score": 0.00087, "epss_percentile": 0.25577}, "CVE-2024-41276": {"epss_score": 0.10456, "epss_percentile": 0.92991}, "CVE-2024-41281": {"epss_score": 0.00063, "epss_percentile": 0.20063}, "CVE-2024-41285": {"epss_score": 0.00574, "epss_percentile": 0.68085}, "CVE-2024-41290": {"epss_score": 0.0139, "epss_percentile": 0.79937}, "CVE-2024-41304": {"epss_score": 0.00128, "epss_percentile": 0.33037}, "CVE-2024-41305": {"epss_score": 0.00086, "epss_percentile": 0.25301}, "CVE-2024-41308": {"epss_score": 0.00138, "epss_percentile": 0.34399}, "CVE-2024-41309": {"epss_score": 0.00138, "epss_percentile": 0.34399}, "CVE-2024-41310": {"epss_score": 0.00621, "epss_percentile": 0.69484}, "CVE-2024-41311": {"epss_score": 0.00125, "epss_percentile": 0.32468}, "CVE-2024-41314": {"epss_score": 0.00234, "epss_percentile": 0.46158}, "CVE-2024-41315": {"epss_score": 0.00234, "epss_percentile": 0.46158}, "CVE-2024-41316": {"epss_score": 0.0235, "epss_percentile": 0.84467}, "CVE-2024-41317": {"epss_score": 0.0061, "epss_percentile": 0.69163}, "CVE-2024-41318": {"epss_score": 0.0235, "epss_percentile": 0.84467}, "CVE-2024-41319": {"epss_score": 0.50527, "epss_percentile": 0.9774}, "CVE-2024-41320": {"epss_score": 0.00617, "epss_percentile": 0.69352}, "CVE-2024-41332": {"epss_score": 0.00064, "epss_percentile": 0.20398}, "CVE-2024-41333": {"epss_score": 0.00158, "epss_percentile": 0.37287}, "CVE-2024-41334": {"epss_score": 0.00154, "epss_percentile": 0.36669}, "CVE-2024-41335": {"epss_score": 0.00131, "epss_percentile": 0.33416}, "CVE-2024-41336": {"epss_score": 0.00116, "epss_percentile": 0.31112}, "CVE-2024-41338": {"epss_score": 0.00117, "epss_percentile": 0.31216}, "CVE-2024-41339": {"epss_score": 0.00301, "epss_percentile": 0.5301}, "CVE-2024-41340": {"epss_score": 0.00038, "epss_percentile": 0.11404}, "CVE-2024-41344": {"epss_score": 0.0014, "epss_percentile": 0.34785}, "CVE-2024-41345": {"epss_score": 0.00225, "epss_percentile": 0.45105}, "CVE-2024-41346": {"epss_score": 0.00225, "epss_percentile": 0.45105}, "CVE-2024-41347": {"epss_score": 0.00241, "epss_percentile": 0.47248}, "CVE-2024-41348": {"epss_score": 0.00342, "epss_percentile": 0.56399}, "CVE-2024-41349": {"epss_score": 0.00342, "epss_percentile": 0.56399}, "CVE-2024-41350": {"epss_score": 0.00368, "epss_percentile": 0.58191}, "CVE-2024-41351": {"epss_score": 0.0035, "epss_percentile": 0.56966}, "CVE-2024-41353": {"epss_score": 0.00283, "epss_percentile": 0.5139}, "CVE-2024-41354": {"epss_score": 0.00283, "epss_percentile": 0.5139}, "CVE-2024-41355": {"epss_score": 0.00232, "epss_percentile": 0.45904}, "CVE-2024-41356": {"epss_score": 0.00531, "epss_percentile": 0.66648}, "CVE-2024-41357": {"epss_score": 0.02192, "epss_percentile": 0.8394}, "CVE-2024-41358": {"epss_score": 0.01851, "epss_percentile": 0.82541}, "CVE-2024-41361": {"epss_score": 0.0922, "epss_percentile": 0.92455}, "CVE-2024-41364": {"epss_score": 0.0922, "epss_percentile": 0.92455}, "CVE-2024-41366": {"epss_score": 0.0922, "epss_percentile": 0.92455}, "CVE-2024-41367": {"epss_score": 0.0922, "epss_percentile": 0.92455}, "CVE-2024-41368": {"epss_score": 0.05009, "epss_percentile": 0.89389}, "CVE-2024-41369": {"epss_score": 0.05009, "epss_percentile": 0.89389}, "CVE-2024-41370": {"epss_score": 0.00139, "epss_percentile": 0.34553}, "CVE-2024-41371": {"epss_score": 0.00266, "epss_percentile": 0.49885}, "CVE-2024-41372": {"epss_score": 0.00139, "epss_percentile": 0.34553}, "CVE-2024-41373": {"epss_score": 0.00213, "epss_percentile": 0.43897}, "CVE-2024-41374": {"epss_score": 0.00246, "epss_percentile": 0.47792}, "CVE-2024-41375": {"epss_score": 0.00246, "epss_percentile": 0.47792}, "CVE-2024-41376": {"epss_score": 0.02869, "epss_percentile": 0.85869}, "CVE-2024-41380": {"epss_score": 0.01293, "epss_percentile": 0.79238}, "CVE-2024-41381": {"epss_score": 0.0119, "epss_percentile": 0.78379}, "CVE-2024-41432": {"epss_score": 0.00099, "epss_percentile": 0.2842}, "CVE-2024-41433": {"epss_score": 0.00097, "epss_percentile": 0.27514}, "CVE-2024-41434": {"epss_score": 0.001, "epss_percentile": 0.28486}, "CVE-2024-41435": {"epss_score": 0.00144, "epss_percentile": 0.35227}, "CVE-2024-41436": {"epss_score": 0.002, "epss_percentile": 0.42225}, "CVE-2024-41437": {"epss_score": 0.00133, "epss_percentile": 0.33686}, "CVE-2024-41438": {"epss_score": 0.00075, "epss_percentile": 0.22889}, "CVE-2024-41439": {"epss_score": 0.00082, "epss_percentile": 0.24527}, "CVE-2024-41440": {"epss_score": 0.0012, "epss_percentile": 0.31784}, "CVE-2024-41443": {"epss_score": 0.00082, "epss_percentile": 0.24527}, "CVE-2024-41444": {"epss_score": 0.00092, "epss_percentile": 0.26566}, "CVE-2024-41445": {"epss_score": 0.00263, "epss_percentile": 0.49542}, "CVE-2024-41446": {"epss_score": 0.00055, "epss_percentile": 0.17419}, "CVE-2024-41447": {"epss_score": 0.00041, "epss_percentile": 0.12329}, "CVE-2024-41453": {"epss_score": 0.00245, "epss_percentile": 0.4767}, "CVE-2024-41454": {"epss_score": 0.00593, "epss_percentile": 0.68643}, "CVE-2024-41459": {"epss_score": 0.00488, "epss_percentile": 0.64836}, "CVE-2024-41460": {"epss_score": 0.00325, "epss_percentile": 0.55031}, "CVE-2024-41461": {"epss_score": 0.00487, "epss_percentile": 0.64828}, "CVE-2024-41462": {"epss_score": 0.0022, "epss_percentile": 0.44567}, "CVE-2024-41463": {"epss_score": 0.0022, "epss_percentile": 0.4458}, "CVE-2024-41464": {"epss_score": 0.00325, "epss_percentile": 0.55031}, "CVE-2024-41465": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-41466": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-41468": {"epss_score": 0.81506, "epss_percentile": 0.99141}, "CVE-2024-41473": {"epss_score": 0.87984, "epss_percentile": 0.99453}, "CVE-2024-41475": {"epss_score": 0.00235, "epss_percentile": 0.46211}, "CVE-2024-41476": {"epss_score": 0.00296, "epss_percentile": 0.52566}, "CVE-2024-41481": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2024-41482": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2024-41492": {"epss_score": 0.00192, "epss_percentile": 0.41349}, "CVE-2024-41502": {"epss_score": 0.00107, "epss_percentile": 0.29647}, "CVE-2024-41503": {"epss_score": 0.00036, "epss_percentile": 0.10231}, "CVE-2024-41504": {"epss_score": 0.00036, "epss_percentile": 0.10604}, "CVE-2024-41505": {"epss_score": 0.00036, "epss_percentile": 0.10231}, "CVE-2024-41511": {"epss_score": 0.00159, "epss_percentile": 0.37361}, "CVE-2024-41512": {"epss_score": 0.01362, "epss_percentile": 0.79758}, "CVE-2024-41513": {"epss_score": 0.00242, "epss_percentile": 0.4737}, "CVE-2024-41514": {"epss_score": 0.00242, "epss_percentile": 0.4737}, "CVE-2024-41515": {"epss_score": 0.00182, "epss_percentile": 0.40247}, "CVE-2024-41516": {"epss_score": 0.00242, "epss_percentile": 0.4737}, "CVE-2024-41517": {"epss_score": 0.00276, "epss_percentile": 0.50707}, "CVE-2024-41518": {"epss_score": 0.00264, "epss_percentile": 0.4974}, "CVE-2024-41519": {"epss_score": 0.00225, "epss_percentile": 0.45131}, "CVE-2024-41550": {"epss_score": 0.00241, "epss_percentile": 0.47285}, "CVE-2024-41551": {"epss_score": 0.00172, "epss_percentile": 0.38977}, "CVE-2024-41564": {"epss_score": 0.00115, "epss_percentile": 0.3095}, "CVE-2024-41565": {"epss_score": 0.00124, "epss_percentile": 0.32339}, "CVE-2024-41570": {"epss_score": 0.75211, "epss_percentile": 0.98834}, "CVE-2024-41572": {"epss_score": 0.00152, "epss_percentile": 0.36407}, "CVE-2024-41577": {"epss_score": 0.00133, "epss_percentile": 0.33724}, "CVE-2024-41579": {"epss_score": 0.00469, "epss_percentile": 0.63917}, "CVE-2024-41583": {"epss_score": 0.0015, "epss_percentile": 0.36075}, "CVE-2024-41584": {"epss_score": 0.0015, "epss_percentile": 0.36075}, "CVE-2024-41585": {"epss_score": 0.00137, "epss_percentile": 0.34249}, "CVE-2024-41586": {"epss_score": 0.01994, "epss_percentile": 0.8319}, "CVE-2024-41587": {"epss_score": 0.00167, "epss_percentile": 0.38316}, "CVE-2024-41588": {"epss_score": 0.00098, "epss_percentile": 0.27671}, "CVE-2024-41589": {"epss_score": 0.00083, "epss_percentile": 0.24766}, "CVE-2024-41590": {"epss_score": 0.00138, "epss_percentile": 0.34344}, "CVE-2024-41591": {"epss_score": 0.00379, "epss_percentile": 0.58895}, "CVE-2024-41592": {"epss_score": 0.01788, "epss_percentile": 0.82266}, "CVE-2024-41593": {"epss_score": 0.13201, "epss_percentile": 0.939}, "CVE-2024-41594": {"epss_score": 0.00092, "epss_percentile": 0.26528}, "CVE-2024-41595": {"epss_score": 0.00787, "epss_percentile": 0.73312}, "CVE-2024-41596": {"epss_score": 0.00076, "epss_percentile": 0.23215}, "CVE-2024-41597": {"epss_score": 0.00272, "epss_percentile": 0.5035}, "CVE-2024-41599": {"epss_score": 0.004, "epss_percentile": 0.60185}, "CVE-2024-41600": {"epss_score": 0.00121, "epss_percentile": 0.31917}, "CVE-2024-41601": {"epss_score": 0.00151, "epss_percentile": 0.36256}, "CVE-2024-41602": {"epss_score": 0.0062, "epss_percentile": 0.69458}, "CVE-2024-41603": {"epss_score": 0.00152, "epss_percentile": 0.36464}, "CVE-2024-41605": {"epss_score": 0.00036, "epss_percentile": 0.10322}, "CVE-2024-41610": {"epss_score": 0.00723, "epss_percentile": 0.72026}, "CVE-2024-41611": {"epss_score": 0.00692, "epss_percentile": 0.71306}, "CVE-2024-41613": {"epss_score": 0.00088, "epss_percentile": 0.25748}, "CVE-2024-41614": {"epss_score": 0.00048, "epss_percentile": 0.15272}, "CVE-2024-41616": {"epss_score": 0.00462, "epss_percentile": 0.63613}, "CVE-2024-41617": {"epss_score": 0.0139, "epss_percentile": 0.79947}, "CVE-2024-41618": {"epss_score": 0.00104, "epss_percentile": 0.29208}, "CVE-2024-41622": {"epss_score": 0.00813, "epss_percentile": 0.73755}, "CVE-2024-41623": {"epss_score": 0.00692, "epss_percentile": 0.71296}, "CVE-2024-41624": {"epss_score": 0.006, "epss_percentile": 0.68815}, "CVE-2024-41628": {"epss_score": 0.91404, "epss_percentile": 0.9964}, "CVE-2024-41629": {"epss_score": 7e-05, "epss_percentile": 0.00397}, "CVE-2024-41630": {"epss_score": 0.04402, "epss_percentile": 0.88647}, "CVE-2024-41631": {"epss_score": 0.00773, "epss_percentile": 0.73052}, "CVE-2024-41637": {"epss_score": 0.00126, "epss_percentile": 0.32696}, "CVE-2024-41640": {"epss_score": 0.01005, "epss_percentile": 0.76542}, "CVE-2024-41643": {"epss_score": 0.00064, "epss_percentile": 0.20171}, "CVE-2024-41644": {"epss_score": 0.00383, "epss_percentile": 0.59082}, "CVE-2024-41645": {"epss_score": 0.00383, "epss_percentile": 0.59082}, "CVE-2024-41646": {"epss_score": 0.00383, "epss_percentile": 0.59082}, "CVE-2024-41647": {"epss_score": 0.00383, "epss_percentile": 0.59082}, "CVE-2024-41648": {"epss_score": 0.00254, "epss_percentile": 0.48624}, "CVE-2024-41649": {"epss_score": 0.00383, "epss_percentile": 0.59082}, "CVE-2024-41650": {"epss_score": 0.00254, "epss_percentile": 0.48624}, "CVE-2024-41651": {"epss_score": 0.32325, "epss_percentile": 0.96689}, "CVE-2024-41655": {"epss_score": 0.00111, "epss_percentile": 0.30372}, "CVE-2024-41656": {"epss_score": 0.03125, "epss_percentile": 0.86455}, "CVE-2024-41657": {"epss_score": 0.0095, "epss_percentile": 0.75861}, "CVE-2024-41658": {"epss_score": 0.00228, "epss_percentile": 0.4554}, "CVE-2024-41659": {"epss_score": 0.00141, "epss_percentile": 0.34954}, "CVE-2024-41660": {"epss_score": 0.00108, "epss_percentile": 0.2988}, "CVE-2024-41662": {"epss_score": 0.12236, "epss_percentile": 0.93609}, "CVE-2024-41663": {"epss_score": 0.00095, "epss_percentile": 0.2709}, "CVE-2024-41664": {"epss_score": 0.00099, "epss_percentile": 0.28342}, "CVE-2024-41665": {"epss_score": 0.0044, "epss_percentile": 0.62639}, "CVE-2024-41666": {"epss_score": 0.00105, "epss_percentile": 0.29297}, "CVE-2024-41667": {"epss_score": 0.73465, "epss_percentile": 0.98757}, "CVE-2024-41668": {"epss_score": 0.00112, "epss_percentile": 0.30544}, "CVE-2024-41670": {"epss_score": 0.00293, "epss_percentile": 0.52296}, "CVE-2024-41671": {"epss_score": 0.00098, "epss_percentile": 0.27803}, "CVE-2024-41672": {"epss_score": 0.00633, "epss_percentile": 0.69755}, "CVE-2024-41673": {"epss_score": 0.00306, "epss_percentile": 0.53462}, "CVE-2024-41674": {"epss_score": 0.0035, "epss_percentile": 0.5694}, "CVE-2024-41675": {"epss_score": 0.00796, "epss_percentile": 0.73488}, "CVE-2024-41676": {"epss_score": 0.00669, "epss_percentile": 0.70757}, "CVE-2024-41677": {"epss_score": 0.00609, "epss_percentile": 0.69127}, "CVE-2024-41678": {"epss_score": 0.00779, "epss_percentile": 0.73147}, "CVE-2024-41679": {"epss_score": 0.00507, "epss_percentile": 0.65677}, "CVE-2024-41681": {"epss_score": 0.00201, "epss_percentile": 0.42276}, "CVE-2024-41682": {"epss_score": 0.00991, "epss_percentile": 0.76386}, "CVE-2024-41683": {"epss_score": 0.00407, "epss_percentile": 0.60576}, "CVE-2024-41684": {"epss_score": 0.00112, "epss_percentile": 0.30451}, "CVE-2024-41685": {"epss_score": 0.00233, "epss_percentile": 0.46042}, "CVE-2024-41686": {"epss_score": 0.00043, "epss_percentile": 0.1334}, "CVE-2024-41687": {"epss_score": 0.00141, "epss_percentile": 0.34802}, "CVE-2024-41688": {"epss_score": 0.0005, "epss_percentile": 0.15874}, "CVE-2024-41689": {"epss_score": 0.00012, "epss_percentile": 0.01166}, "CVE-2024-41690": {"epss_score": 0.00058, "epss_percentile": 0.18576}, "CVE-2024-41691": {"epss_score": 0.00058, "epss_percentile": 0.18576}, "CVE-2024-41692": {"epss_score": 0.00056, "epss_percentile": 0.17715}, "CVE-2024-41693": {"epss_score": 0.00388, "epss_percentile": 0.59395}, "CVE-2024-41694": {"epss_score": 0.00274, "epss_percentile": 0.50535}, "CVE-2024-41695": {"epss_score": 0.0065, "epss_percentile": 0.70252}, "CVE-2024-41696": {"epss_score": 0.00421, "epss_percentile": 0.61508}, "CVE-2024-41697": {"epss_score": 0.0019, "epss_percentile": 0.41141}, "CVE-2024-41698": {"epss_score": 0.00172, "epss_percentile": 0.39019}, "CVE-2024-41699": {"epss_score": 0.00131, "epss_percentile": 0.33351}, "CVE-2024-41700": {"epss_score": 0.00194, "epss_percentile": 0.41544}, "CVE-2024-41701": {"epss_score": 0.00342, "epss_percentile": 0.56356}, "CVE-2024-41702": {"epss_score": 0.00188, "epss_percentile": 0.40829}, "CVE-2024-41703": {"epss_score": 0.00137, "epss_percentile": 0.34218}, "CVE-2024-41704": {"epss_score": 0.00284, "epss_percentile": 0.51416}, "CVE-2024-41705": {"epss_score": 0.00382, "epss_percentile": 0.59055}, "CVE-2024-41706": {"epss_score": 0.00309, "epss_percentile": 0.53698}, "CVE-2024-41707": {"epss_score": 0.00343, "epss_percentile": 0.56433}, "CVE-2024-41708": {"epss_score": 0.00079, "epss_percentile": 0.23958}, "CVE-2024-41709": {"epss_score": 0.00341, "epss_percentile": 0.56319}, "CVE-2024-41710": {"epss_score": 0.21138, "epss_percentile": 0.95469}, "CVE-2024-41711": {"epss_score": 0.0018, "epss_percentile": 0.39985}, "CVE-2024-41712": {"epss_score": 0.00161, "epss_percentile": 0.37522}, "CVE-2024-41713": {"epss_score": 0.93912, "epss_percentile": 0.99867}, "CVE-2024-41714": {"epss_score": 0.01498, "epss_percentile": 0.80704}, "CVE-2024-41715": {"epss_score": 0.00042, "epss_percentile": 0.12608}, "CVE-2024-41716": {"epss_score": 0.00335, "epss_percentile": 0.55852}, "CVE-2024-41717": {"epss_score": 0.0061, "epss_percentile": 0.69147}, "CVE-2024-41719": {"epss_score": 0.00181, "epss_percentile": 0.40021}, "CVE-2024-41720": {"epss_score": 0.00179, "epss_percentile": 0.39796}, "CVE-2024-41721": {"epss_score": 0.09075, "epss_percentile": 0.92388}, "CVE-2024-41722": {"epss_score": 0.00045, "epss_percentile": 0.13829}, "CVE-2024-41723": {"epss_score": 0.00468, "epss_percentile": 0.6388}, "CVE-2024-41724": {"epss_score": 0.00117, "epss_percentile": 0.31228}, "CVE-2024-41725": {"epss_score": 0.00114, "epss_percentile": 0.30743}, "CVE-2024-41726": {"epss_score": 0.00571, "epss_percentile": 0.67989}, "CVE-2024-41727": {"epss_score": 0.00493, "epss_percentile": 0.65032}, "CVE-2024-41728": {"epss_score": 0.00063, "epss_percentile": 0.20001}, "CVE-2024-41729": {"epss_score": 0.00076, "epss_percentile": 0.23276}, "CVE-2024-41730": {"epss_score": 0.20382, "epss_percentile": 0.95336}, "CVE-2024-41731": {"epss_score": 0.00506, "epss_percentile": 0.6564}, "CVE-2024-41732": {"epss_score": 0.00152, "epss_percentile": 0.3644}, "CVE-2024-41733": {"epss_score": 0.0053, "epss_percentile": 0.66634}, "CVE-2024-41734": {"epss_score": 0.00364, "epss_percentile": 0.57912}, "CVE-2024-41735": {"epss_score": 0.00801, "epss_percentile": 0.73571}, "CVE-2024-41736": {"epss_score": 0.00366, "epss_percentile": 0.58091}, "CVE-2024-41737": {"epss_score": 0.00364, "epss_percentile": 0.57912}, "CVE-2024-41738": {"epss_score": 0.00083, "epss_percentile": 0.24643}, "CVE-2024-41739": {"epss_score": 0.00147, "epss_percentile": 0.35746}, "CVE-2024-41741": {"epss_score": 0.00089, "epss_percentile": 0.25798}, "CVE-2024-41742": {"epss_score": 0.00037, "epss_percentile": 0.10837}, "CVE-2024-41743": {"epss_score": 0.00037, "epss_percentile": 0.10837}, "CVE-2024-41744": {"epss_score": 0.00079, "epss_percentile": 0.23906}, "CVE-2024-41745": {"epss_score": 0.00281, "epss_percentile": 0.51181}, "CVE-2024-41746": {"epss_score": 0.00209, "epss_percentile": 0.43311}, "CVE-2024-41750": {"epss_score": 0.00011, "epss_percentile": 0.01083}, "CVE-2024-41751": {"epss_score": 0.00011, "epss_percentile": 0.01083}, "CVE-2024-41752": {"epss_score": 0.00041, "epss_percentile": 0.12341}, "CVE-2024-41753": {"epss_score": 0.00075, "epss_percentile": 0.22905}, "CVE-2024-41757": {"epss_score": 0.00032, "epss_percentile": 0.08787}, "CVE-2024-41760": {"epss_score": 0.00071, "epss_percentile": 0.22185}, "CVE-2024-41761": {"epss_score": 0.00051, "epss_percentile": 0.16334}, "CVE-2024-41762": {"epss_score": 0.00114, "epss_percentile": 0.3079}, "CVE-2024-41763": {"epss_score": 0.00057, "epss_percentile": 0.18091}, "CVE-2024-41765": {"epss_score": 0.00117, "epss_percentile": 0.31213}, "CVE-2024-41766": {"epss_score": 0.00221, "epss_percentile": 0.44694}, "CVE-2024-41767": {"epss_score": 0.00116, "epss_percentile": 0.31146}, "CVE-2024-41768": {"epss_score": 0.00157, "epss_percentile": 0.37128}, "CVE-2024-41770": {"epss_score": 0.00143, "epss_percentile": 0.35111}, "CVE-2024-41771": {"epss_score": 0.00143, "epss_percentile": 0.35111}, "CVE-2024-41773": {"epss_score": 0.00069, "epss_percentile": 0.21517}, "CVE-2024-41774": {"epss_score": 0.001, "epss_percentile": 0.28482}, "CVE-2024-41775": {"epss_score": 0.00046, "epss_percentile": 0.14186}, "CVE-2024-41776": {"epss_score": 0.00035, "epss_percentile": 0.09993}, "CVE-2024-41777": {"epss_score": 0.00081, "epss_percentile": 0.24229}, "CVE-2024-41778": {"epss_score": 0.00058, "epss_percentile": 0.18513}, "CVE-2024-41779": {"epss_score": 0.00028, "epss_percentile": 0.07289}, "CVE-2024-41780": {"epss_score": 0.00032, "epss_percentile": 0.08805}, "CVE-2024-41781": {"epss_score": 0.00049, "epss_percentile": 0.15547}, "CVE-2024-41783": {"epss_score": 0.00221, "epss_percentile": 0.44696}, "CVE-2024-41784": {"epss_score": 0.00086, "epss_percentile": 0.25299}, "CVE-2024-41785": {"epss_score": 0.00233, "epss_percentile": 0.46051}, "CVE-2024-41787": {"epss_score": 0.00203, "epss_percentile": 0.42546}, "CVE-2024-41788": {"epss_score": 0.00381, "epss_percentile": 0.5903}, "CVE-2024-41789": {"epss_score": 0.00381, "epss_percentile": 0.5903}, "CVE-2024-41790": {"epss_score": 0.00381, "epss_percentile": 0.5903}, "CVE-2024-41791": {"epss_score": 0.00063, "epss_percentile": 0.20058}, "CVE-2024-41792": {"epss_score": 0.00252, "epss_percentile": 0.48339}, "CVE-2024-41793": {"epss_score": 0.00053, "epss_percentile": 0.16825}, "CVE-2024-41794": {"epss_score": 0.00116, "epss_percentile": 0.31155}, "CVE-2024-41795": {"epss_score": 0.00043, "epss_percentile": 0.13312}, "CVE-2024-41796": {"epss_score": 0.00138, "epss_percentile": 0.34459}, "CVE-2024-41797": {"epss_score": 0.00106, "epss_percentile": 0.29559}, "CVE-2024-41798": {"epss_score": 0.00025, "epss_percentile": 0.06163}, "CVE-2024-41799": {"epss_score": 0.07024, "epss_percentile": 0.91194}, "CVE-2024-41800": {"epss_score": 0.00338, "epss_percentile": 0.5613}, "CVE-2024-41801": {"epss_score": 0.00337, "epss_percentile": 0.56051}, "CVE-2024-41802": {"epss_score": 0.00683, "epss_percentile": 0.71088}, "CVE-2024-41803": {"epss_score": 0.0053, "epss_percentile": 0.66616}, "CVE-2024-41804": {"epss_score": 0.00538, "epss_percentile": 0.66926}, "CVE-2024-41805": {"epss_score": 0.00523, "epss_percentile": 0.66291}, "CVE-2024-41806": {"epss_score": 0.00137, "epss_percentile": 0.34327}, "CVE-2024-41808": {"epss_score": 0.01327, "epss_percentile": 0.7949}, "CVE-2024-41809": {"epss_score": 0.0037, "epss_percentile": 0.58341}, "CVE-2024-41810": {"epss_score": 0.68165, "epss_percentile": 0.98534}, "CVE-2024-41811": {"epss_score": 0.00145, "epss_percentile": 0.35381}, "CVE-2024-41812": {"epss_score": 0.00329, "epss_percentile": 0.55391}, "CVE-2024-41813": {"epss_score": 0.00329, "epss_percentile": 0.55391}, "CVE-2024-41815": {"epss_score": 0.00301, "epss_percentile": 0.53044}, "CVE-2024-41816": {"epss_score": 0.02504, "epss_percentile": 0.84933}, "CVE-2024-41817": {"epss_score": 0.19061, "epss_percentile": 0.95119}, "CVE-2024-41818": {"epss_score": 0.00685, "epss_percentile": 0.71138}, "CVE-2024-41819": {"epss_score": 0.02012, "epss_percentile": 0.83252}, "CVE-2024-41820": {"epss_score": 0.00137, "epss_percentile": 0.34245}, "CVE-2024-41824": {"epss_score": 0.00014, "epss_percentile": 0.01936}, "CVE-2024-41825": {"epss_score": 0.37478, "epss_percentile": 0.9705}, "CVE-2024-41826": {"epss_score": 0.00273, "epss_percentile": 0.50451}, "CVE-2024-41827": {"epss_score": 0.00011, "epss_percentile": 0.00956}, "CVE-2024-41828": {"epss_score": 7e-05, "epss_percentile": 0.00385}, "CVE-2024-41829": {"epss_score": 4e-05, "epss_percentile": 0.00165}, "CVE-2024-41830": {"epss_score": 0.0102, "epss_percentile": 0.76741}, "CVE-2024-41831": {"epss_score": 0.01538, "epss_percentile": 0.80934}, "CVE-2024-41832": {"epss_score": 0.00073, "epss_percentile": 0.2259}, "CVE-2024-41833": {"epss_score": 0.00104, "epss_percentile": 0.29106}, "CVE-2024-41834": {"epss_score": 0.00104, "epss_percentile": 0.29106}, "CVE-2024-41835": {"epss_score": 0.00073, "epss_percentile": 0.2259}, "CVE-2024-41836": {"epss_score": 0.00113, "epss_percentile": 0.30637}, "CVE-2024-41839": {"epss_score": 0.00113, "epss_percentile": 0.30703}, "CVE-2024-41840": {"epss_score": 0.00193, "epss_percentile": 0.41395}, "CVE-2024-41841": {"epss_score": 0.00754, "epss_percentile": 0.727}, "CVE-2024-41842": {"epss_score": 0.00717, "epss_percentile": 0.71884}, "CVE-2024-41843": {"epss_score": 0.01102, "epss_percentile": 0.77584}, "CVE-2024-41844": {"epss_score": 0.01102, "epss_percentile": 0.77584}, "CVE-2024-41845": {"epss_score": 0.01102, "epss_percentile": 0.77584}, "CVE-2024-41846": {"epss_score": 0.00754, "epss_percentile": 0.727}, "CVE-2024-41847": {"epss_score": 0.01102, "epss_percentile": 0.77584}, "CVE-2024-41848": {"epss_score": 0.01102, "epss_percentile": 0.77584}, "CVE-2024-41849": {"epss_score": 0.00209, "epss_percentile": 0.43404}, "CVE-2024-41850": {"epss_score": 0.00237, "epss_percentile": 0.46706}, "CVE-2024-41851": {"epss_score": 0.00193, "epss_percentile": 0.41395}, "CVE-2024-41852": {"epss_score": 0.00237, "epss_percentile": 0.46706}, "CVE-2024-41853": {"epss_score": 0.00237, "epss_percentile": 0.46706}, "CVE-2024-41854": {"epss_score": 0.0003, "epss_percentile": 0.08025}, "CVE-2024-41856": {"epss_score": 0.00088, "epss_percentile": 0.25747}, "CVE-2024-41857": {"epss_score": 0.00192, "epss_percentile": 0.41291}, "CVE-2024-41858": {"epss_score": 0.00201, "epss_percentile": 0.42347}, "CVE-2024-41859": {"epss_score": 0.00192, "epss_percentile": 0.41291}, "CVE-2024-41860": {"epss_score": 0.0004, "epss_percentile": 0.1218}, "CVE-2024-41861": {"epss_score": 0.0004, "epss_percentile": 0.1218}, "CVE-2024-41862": {"epss_score": 0.0004, "epss_percentile": 0.1218}, "CVE-2024-41863": {"epss_score": 0.0004, "epss_percentile": 0.1218}, "CVE-2024-41864": {"epss_score": 0.00201, "epss_percentile": 0.42347}, "CVE-2024-41865": {"epss_score": 0.00185, "epss_percentile": 0.40476}, "CVE-2024-41866": {"epss_score": 0.00113, "epss_percentile": 0.30637}, "CVE-2024-41867": {"epss_score": 0.00041, "epss_percentile": 0.12378}, "CVE-2024-41868": {"epss_score": 0.00028, "epss_percentile": 0.07569}, "CVE-2024-41869": {"epss_score": 0.00876, "epss_percentile": 0.74795}, "CVE-2024-41870": {"epss_score": 0.00039, "epss_percentile": 0.1144}, "CVE-2024-41871": {"epss_score": 0.00039, "epss_percentile": 0.1144}, "CVE-2024-41872": {"epss_score": 0.00039, "epss_percentile": 0.1144}, "CVE-2024-41873": {"epss_score": 0.00039, "epss_percentile": 0.1144}, "CVE-2024-41874": {"epss_score": 0.23755, "epss_percentile": 0.95813}, "CVE-2024-41875": {"epss_score": 0.01072, "epss_percentile": 0.77276}, "CVE-2024-41876": {"epss_score": 0.01072, "epss_percentile": 0.77276}, "CVE-2024-41877": {"epss_score": 0.01072, "epss_percentile": 0.77276}, "CVE-2024-41878": {"epss_score": 0.01322, "epss_percentile": 0.79452}, "CVE-2024-41879": {"epss_score": 0.01405, "epss_percentile": 0.80041}, "CVE-2024-41880": {"epss_score": 0.00155, "epss_percentile": 0.36836}, "CVE-2024-41881": {"epss_score": 0.00459, "epss_percentile": 0.63472}, "CVE-2024-41882": {"epss_score": 0.00475, "epss_percentile": 0.6425}, "CVE-2024-41883": {"epss_score": 0.00568, "epss_percentile": 0.67881}, "CVE-2024-41884": {"epss_score": 0.00568, "epss_percentile": 0.67881}, "CVE-2024-41885": {"epss_score": 0.00074, "epss_percentile": 0.22865}, "CVE-2024-41886": {"epss_score": 0.00661, "epss_percentile": 0.70585}, "CVE-2024-41887": {"epss_score": 0.00867, "epss_percentile": 0.74657}, "CVE-2024-41888": {"epss_score": 0.01354, "epss_percentile": 0.79703}, "CVE-2024-41889": {"epss_score": 0.01334, "epss_percentile": 0.79535}, "CVE-2024-41890": {"epss_score": 0.00616, "epss_percentile": 0.69329}, "CVE-2024-41902": {"epss_score": 0.00085, "epss_percentile": 0.25161}, "CVE-2024-41903": {"epss_score": 0.0036, "epss_percentile": 0.5769}, "CVE-2024-41904": {"epss_score": 0.00594, "epss_percentile": 0.68657}, "CVE-2024-41905": {"epss_score": 0.0041, "epss_percentile": 0.60816}, "CVE-2024-41906": {"epss_score": 0.00355, "epss_percentile": 0.5728}, "CVE-2024-41907": {"epss_score": 0.00414, "epss_percentile": 0.61015}, "CVE-2024-41908": {"epss_score": 0.00189, "epss_percentile": 0.40991}, "CVE-2024-41909": {"epss_score": 0.00478, "epss_percentile": 0.64409}, "CVE-2024-41910": {"epss_score": 0.00807, "epss_percentile": 0.73677}, "CVE-2024-41911": {"epss_score": 0.0083, "epss_percentile": 0.74023}, "CVE-2024-41912": {"epss_score": 0.01468, "epss_percentile": 0.80476}, "CVE-2024-41913": {"epss_score": 0.02052, "epss_percentile": 0.83412}, "CVE-2024-41914": {"epss_score": 0.00148, "epss_percentile": 0.35925}, "CVE-2024-41915": {"epss_score": 0.00774, "epss_percentile": 0.73068}, "CVE-2024-41916": {"epss_score": 0.00418, "epss_percentile": 0.6128}, "CVE-2024-41917": {"epss_score": 0.00019, "epss_percentile": 0.04326}, "CVE-2024-41918": {"epss_score": 0.00114, "epss_percentile": 0.30802}, "CVE-2024-41921": {"epss_score": 0.00018, "epss_percentile": 0.03861}, "CVE-2024-41922": {"epss_score": 0.03929, "epss_percentile": 0.87971}, "CVE-2024-41924": {"epss_score": 0.0015, "epss_percentile": 0.36138}, "CVE-2024-41925": {"epss_score": 0.00061, "epss_percentile": 0.19309}, "CVE-2024-41926": {"epss_score": 0.00162, "epss_percentile": 0.37691}, "CVE-2024-41927": {"epss_score": 0.00025, "epss_percentile": 0.06278}, "CVE-2024-41928": {"epss_score": 0.00034, "epss_percentile": 0.09648}, "CVE-2024-41929": {"epss_score": 0.00887, "epss_percentile": 0.74964}, "CVE-2024-41930": {"epss_score": 0.00189, "epss_percentile": 0.40954}, "CVE-2024-41931": {"epss_score": 0.00042, "epss_percentile": 0.12608}, "CVE-2024-41932": {"epss_score": 0.00035, "epss_percentile": 0.09975}, "CVE-2024-41934": {"epss_score": 0.0002, "epss_percentile": 0.04536}, "CVE-2024-41935": {"epss_score": 0.00031, "epss_percentile": 0.08647}, "CVE-2024-41936": {"epss_score": 0.00189, "epss_percentile": 0.40944}, "CVE-2024-41937": {"epss_score": 0.00353, "epss_percentile": 0.57184}, "CVE-2024-41938": {"epss_score": 0.00157, "epss_percentile": 0.3711}, "CVE-2024-41939": {"epss_score": 0.0008, "epss_percentile": 0.24168}, "CVE-2024-41940": {"epss_score": 0.00548, "epss_percentile": 0.67274}, "CVE-2024-41941": {"epss_score": 0.00053, "epss_percentile": 0.16943}, "CVE-2024-41942": {"epss_score": 0.00134, "epss_percentile": 0.33876}, "CVE-2024-41943": {"epss_score": 0.00311, "epss_percentile": 0.5382}, "CVE-2024-41944": {"epss_score": 0.00208, "epss_percentile": 0.43269}, "CVE-2024-41945": {"epss_score": 0.00125, "epss_percentile": 0.32491}, "CVE-2024-41946": {"epss_score": 0.00661, "epss_percentile": 0.70565}, "CVE-2024-41947": {"epss_score": 0.10018, "epss_percentile": 0.92818}, "CVE-2024-41948": {"epss_score": 0.00159, "epss_percentile": 0.37402}, "CVE-2024-41949": {"epss_score": 0.00109, "epss_percentile": 0.29977}, "CVE-2024-41950": {"epss_score": 0.01568, "epss_percentile": 0.81078}, "CVE-2024-41951": {"epss_score": 0.0006, "epss_percentile": 0.19082}, "CVE-2024-41952": {"epss_score": 0.00909, "epss_percentile": 0.75295}, "CVE-2024-41953": {"epss_score": 0.02604, "epss_percentile": 0.85216}, "CVE-2024-41954": {"epss_score": 0.00097, "epss_percentile": 0.27538}, "CVE-2024-41955": {"epss_score": 0.14051, "epss_percentile": 0.94121}, "CVE-2024-41956": {"epss_score": 0.00399, "epss_percentile": 0.60111}, "CVE-2024-41957": {"epss_score": 0.001, "epss_percentile": 0.28476}, "CVE-2024-41958": {"epss_score": 0.30308, "epss_percentile": 0.96527}, "CVE-2024-41959": {"epss_score": 0.00846, "epss_percentile": 0.74318}, "CVE-2024-41960": {"epss_score": 0.0043, "epss_percentile": 0.6201}, "CVE-2024-41961": {"epss_score": 0.00209, "epss_percentile": 0.43308}, "CVE-2024-41962": {"epss_score": 0.00212, "epss_percentile": 0.43783}, "CVE-2024-41964": {"epss_score": 0.00379, "epss_percentile": 0.5886}, "CVE-2024-41965": {"epss_score": 0.00093, "epss_percentile": 0.26673}, "CVE-2024-41967": {"epss_score": 0.01057, "epss_percentile": 0.77129}, "CVE-2024-41968": {"epss_score": 0.00662, "epss_percentile": 0.70589}, "CVE-2024-41969": {"epss_score": 0.01213, "epss_percentile": 0.78568}, "CVE-2024-41970": {"epss_score": 0.00171, "epss_percentile": 0.38792}, "CVE-2024-41971": {"epss_score": 0.028, "epss_percentile": 0.85694}, "CVE-2024-41972": {"epss_score": 0.00194, "epss_percentile": 0.41523}, "CVE-2024-41973": {"epss_score": 0.028, "epss_percentile": 0.85694}, "CVE-2024-41974": {"epss_score": 0.00894, "epss_percentile": 0.7509}, "CVE-2024-41975": {"epss_score": 0.00094, "epss_percentile": 0.27075}, "CVE-2024-41976": {"epss_score": 0.01274, "epss_percentile": 0.79091}, "CVE-2024-41977": {"epss_score": 0.01236, "epss_percentile": 0.78771}, "CVE-2024-41978": {"epss_score": 0.00337, "epss_percentile": 0.56036}, "CVE-2024-41979": {"epss_score": 0.00015, "epss_percentile": 0.02237}, "CVE-2024-41980": {"epss_score": 8e-05, "epss_percentile": 0.0049}, "CVE-2024-41981": {"epss_score": 0.00045, "epss_percentile": 0.13709}, "CVE-2024-41982": {"epss_score": 5e-05, "epss_percentile": 0.00217}, "CVE-2024-41983": {"epss_score": 0.00016, "epss_percentile": 0.02694}, "CVE-2024-41984": {"epss_score": 0.00012, "epss_percentile": 0.01255}, "CVE-2024-41985": {"epss_score": 0.00015, "epss_percentile": 0.02518}, "CVE-2024-41986": {"epss_score": 6e-05, "epss_percentile": 0.00316}, "CVE-2024-41987": {"epss_score": 0.00119, "epss_percentile": 0.3163}, "CVE-2024-41988": {"epss_score": 0.00176, "epss_percentile": 0.39419}, "CVE-2024-41989": {"epss_score": 0.01386, "epss_percentile": 0.79913}, "CVE-2024-41990": {"epss_score": 0.01326, "epss_percentile": 0.79483}, "CVE-2024-41991": {"epss_score": 0.0091, "epss_percentile": 0.75322}, "CVE-2024-41992": {"epss_score": 0.22565, "epss_percentile": 0.95651}, "CVE-2024-41995": {"epss_score": 0.00118, "epss_percentile": 0.3146}, "CVE-2024-41996": {"epss_score": 0.00589, "epss_percentile": 0.68536}, "CVE-2024-41997": {"epss_score": 0.00122, "epss_percentile": 0.32089}, "CVE-2024-41999": {"epss_score": 0.00124, "epss_percentile": 0.32363}, "CVE-2024-42000": {"epss_score": 0.00091, "epss_percentile": 0.26199}, "CVE-2024-42001": {"epss_score": 0.00169, "epss_percentile": 0.38552}, "CVE-2024-42004": {"epss_score": 0.00058, "epss_percentile": 0.18356}, "CVE-2024-42005": {"epss_score": 0.00328, "epss_percentile": 0.55295}, "CVE-2024-42006": {"epss_score": 0.00549, "epss_percentile": 0.67304}, "CVE-2024-42007": {"epss_score": 0.00738, "epss_percentile": 0.72338}, "CVE-2024-42008": {"epss_score": 0.58573, "epss_percentile": 0.98124}, "CVE-2024-42009": {"epss_score": 0.90439, "epss_percentile": 0.99583}, "CVE-2024-42010": {"epss_score": 0.17254, "epss_percentile": 0.9481}, "CVE-2024-42011": {"epss_score": 0.00527, "epss_percentile": 0.66464}, "CVE-2024-42012": {"epss_score": 0.00022, "epss_percentile": 0.05306}, "CVE-2024-42013": {"epss_score": 0.00024, "epss_percentile": 0.05805}, "CVE-2024-42017": {"epss_score": 0.00115, "epss_percentile": 0.30928}, "CVE-2024-42018": {"epss_score": 0.00282, "epss_percentile": 0.51237}, "CVE-2024-42019": {"epss_score": 0.0043, "epss_percentile": 0.62015}, "CVE-2024-42020": {"epss_score": 0.00692, "epss_percentile": 0.71286}, "CVE-2024-42021": {"epss_score": 0.00153, "epss_percentile": 0.36544}, "CVE-2024-42022": {"epss_score": 0.00136, "epss_percentile": 0.34094}, "CVE-2024-42023": {"epss_score": 0.00266, "epss_percentile": 0.49876}, "CVE-2024-42024": {"epss_score": 0.04116, "epss_percentile": 0.88277}, "CVE-2024-42025": {"epss_score": 0.00377, "epss_percentile": 0.58753}, "CVE-2024-42027": {"epss_score": 0.00104, "epss_percentile": 0.29121}, "CVE-2024-42028": {"epss_score": 0.00034, "epss_percentile": 0.09525}, "CVE-2024-42029": {"epss_score": 0.00124, "epss_percentile": 0.32379}, "CVE-2024-42030": {"epss_score": 0.00061, "epss_percentile": 0.19253}, "CVE-2024-42031": {"epss_score": 0.00179, "epss_percentile": 0.39751}, "CVE-2024-42032": {"epss_score": 0.00064, "epss_percentile": 0.20157}, "CVE-2024-42033": {"epss_score": 0.00022, "epss_percentile": 0.05318}, "CVE-2024-42034": {"epss_score": 0.00027, "epss_percentile": 0.06805}, "CVE-2024-42035": {"epss_score": 0.00053, "epss_percentile": 0.16843}, "CVE-2024-42036": {"epss_score": 0.00133, "epss_percentile": 0.33657}, "CVE-2024-42037": {"epss_score": 0.0007, "epss_percentile": 0.21672}, "CVE-2024-42038": {"epss_score": 0.0005, "epss_percentile": 0.15872}, "CVE-2024-42039": {"epss_score": 0.00125, "epss_percentile": 0.32589}, "CVE-2024-42040": {"epss_score": 0.00062, "epss_percentile": 0.19599}, "CVE-2024-42041": {"epss_score": 0.00226, "epss_percentile": 0.45283}, "CVE-2024-42048": {"epss_score": 0.00052, "epss_percentile": 0.16455}, "CVE-2024-42049": {"epss_score": 0.04322, "epss_percentile": 0.88548}, "CVE-2024-42050": {"epss_score": 0.00037, "epss_percentile": 0.10778}, "CVE-2024-42051": {"epss_score": 0.00037, "epss_percentile": 0.10778}, "CVE-2024-42052": {"epss_score": 0.00033, "epss_percentile": 0.0913}, "CVE-2024-42053": {"epss_score": 0.00037, "epss_percentile": 0.10778}, "CVE-2024-42054": {"epss_score": 0.00121, "epss_percentile": 0.31832}, "CVE-2024-42055": {"epss_score": 0.00127, "epss_percentile": 0.32942}, "CVE-2024-42056": {"epss_score": 0.00324, "epss_percentile": 0.54925}, "CVE-2024-42057": {"epss_score": 0.02883, "epss_percentile": 0.85906}, "CVE-2024-42058": {"epss_score": 0.00265, "epss_percentile": 0.49781}, "CVE-2024-42059": {"epss_score": 0.00561, "epss_percentile": 0.67668}, "CVE-2024-42060": {"epss_score": 0.00561, "epss_percentile": 0.67668}, "CVE-2024-42061": {"epss_score": 0.00675, "epss_percentile": 0.70905}, "CVE-2024-42062": {"epss_score": 0.00161, "epss_percentile": 0.37522}, "CVE-2024-42063": {"epss_score": 0.00031, "epss_percentile": 0.08415}, "CVE-2024-42064": {"epss_score": 0.00015, "epss_percentile": 0.02596}, "CVE-2024-42065": {"epss_score": 0.00015, "epss_percentile": 0.02596}, "CVE-2024-42066": {"epss_score": 0.00015, "epss_percentile": 0.02596}, "CVE-2024-42067": {"epss_score": 0.00018, "epss_percentile": 0.03596}, "CVE-2024-42068": {"epss_score": 0.00012, "epss_percentile": 0.01254}, "CVE-2024-42069": {"epss_score": 0.00023, "epss_percentile": 0.05484}, "CVE-2024-42070": {"epss_score": 0.00012, "epss_percentile": 0.01291}, "CVE-2024-42071": {"epss_score": 8e-05, "epss_percentile": 0.00476}, "CVE-2024-42072": {"epss_score": 0.00024, "epss_percentile": 0.05847}, "CVE-2024-42073": {"epss_score": 0.00018, "epss_percentile": 0.03628}, "CVE-2024-42074": {"epss_score": 0.00018, "epss_percentile": 0.03596}, "CVE-2024-42075": {"epss_score": 0.00015, "epss_percentile": 0.02515}, "CVE-2024-42076": {"epss_score": 0.00015, "epss_percentile": 0.02161}, "CVE-2024-42077": {"epss_score": 0.00012, "epss_percentile": 0.01254}, "CVE-2024-42078": {"epss_score": 0.00015, "epss_percentile": 0.02596}, "CVE-2024-42079": {"epss_score": 0.00014, "epss_percentile": 0.01863}, "CVE-2024-42080": {"epss_score": 0.00012, "epss_percentile": 0.01232}, "CVE-2024-42081": {"epss_score": 0.00032, "epss_percentile": 0.08862}, "CVE-2024-42082": {"epss_score": 0.00012, "epss_percentile": 0.01254}, "CVE-2024-42083": {"epss_score": 0.00015, "epss_percentile": 0.02596}, "CVE-2024-42084": {"epss_score": 0.0002, "epss_percentile": 0.04474}, "CVE-2024-42085": {"epss_score": 0.00017, "epss_percentile": 0.03395}, "CVE-2024-42086": {"epss_score": 0.00027, "epss_percentile": 0.06772}, "CVE-2024-42087": {"epss_score": 0.00012, "epss_percentile": 0.01318}, "CVE-2024-42088": {"epss_score": 0.00026, "epss_percentile": 0.06482}, "CVE-2024-42089": {"epss_score": 0.0002, "epss_percentile": 0.04604}, "CVE-2024-42090": {"epss_score": 0.0001, "epss_percentile": 0.00894}, "CVE-2024-42091": {"epss_score": 0.00018, "epss_percentile": 0.03857}, "CVE-2024-42092": {"epss_score": 0.00021, "epss_percentile": 0.04904}, "CVE-2024-42093": {"epss_score": 0.00025, "epss_percentile": 0.06294}, "CVE-2024-42094": {"epss_score": 0.00012, "epss_percentile": 0.01346}, "CVE-2024-42095": {"epss_score": 0.00026, "epss_percentile": 0.06539}, "CVE-2024-42096": {"epss_score": 0.00012, "epss_percentile": 0.01318}, "CVE-2024-42097": {"epss_score": 0.00019, "epss_percentile": 0.04062}, "CVE-2024-42098": {"epss_score": 0.00014, "epss_percentile": 0.01933}, "CVE-2024-42099": {"epss_score": 0.00041, "epss_percentile": 0.12447}, "CVE-2024-42100": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-42101": {"epss_score": 0.0001, "epss_percentile": 0.00802}, "CVE-2024-42102": {"epss_score": 0.0001, "epss_percentile": 0.00802}, "CVE-2024-42103": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2024-42104": {"epss_score": 0.0001, "epss_percentile": 0.00815}, "CVE-2024-42105": {"epss_score": 0.00012, "epss_percentile": 0.01347}, "CVE-2024-42106": {"epss_score": 0.0001, "epss_percentile": 0.00802}, "CVE-2024-42107": {"epss_score": 7e-05, "epss_percentile": 0.00432}, "CVE-2024-42108": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-42109": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2024-42110": {"epss_score": 0.00016, "epss_percentile": 0.02615}, "CVE-2024-42111": {"epss_score": 0.00015, "epss_percentile": 0.0225}, "CVE-2024-42112": {"epss_score": 0.00018, "epss_percentile": 0.03628}, "CVE-2024-42113": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-42114": {"epss_score": 9e-05, "epss_percentile": 0.00699}, "CVE-2024-42115": {"epss_score": 0.00015, "epss_percentile": 0.02245}, "CVE-2024-42117": {"epss_score": 0.00018, "epss_percentile": 0.03628}, "CVE-2024-42118": {"epss_score": 0.00018, "epss_percentile": 0.03628}, "CVE-2024-42119": {"epss_score": 0.00011, "epss_percentile": 0.00983}, "CVE-2024-42120": {"epss_score": 0.00011, "epss_percentile": 0.01074}, "CVE-2024-42121": {"epss_score": 0.00015, "epss_percentile": 0.02219}, "CVE-2024-42122": {"epss_score": 0.00015, "epss_percentile": 0.02411}, "CVE-2024-42123": {"epss_score": 8e-05, "epss_percentile": 0.00531}, "CVE-2024-42124": {"epss_score": 9e-05, "epss_percentile": 0.00705}, "CVE-2024-42125": {"epss_score": 0.00012, "epss_percentile": 0.01181}, "CVE-2024-42126": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2024-42127": {"epss_score": 0.00016, "epss_percentile": 0.02638}, "CVE-2024-42128": {"epss_score": 0.00026, "epss_percentile": 0.06456}, "CVE-2024-42129": {"epss_score": 0.00016, "epss_percentile": 0.02908}, "CVE-2024-42130": {"epss_score": 8e-05, "epss_percentile": 0.00501}, "CVE-2024-42131": {"epss_score": 8e-05, "epss_percentile": 0.00523}, "CVE-2024-42132": {"epss_score": 0.00018, "epss_percentile": 0.0384}, "CVE-2024-42133": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-42134": {"epss_score": 9e-05, "epss_percentile": 0.00604}, "CVE-2024-42135": {"epss_score": 0.0001, "epss_percentile": 0.00785}, "CVE-2024-42136": {"epss_score": 0.00014, "epss_percentile": 0.01849}, "CVE-2024-42137": {"epss_score": 0.0001, "epss_percentile": 0.0076}, "CVE-2024-42138": {"epss_score": 0.00013, "epss_percentile": 0.01509}, "CVE-2024-42139": {"epss_score": 9e-05, "epss_percentile": 0.0072}, "CVE-2024-42140": {"epss_score": 0.00014, "epss_percentile": 0.01932}, "CVE-2024-42141": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-42142": {"epss_score": 0.00011, "epss_percentile": 0.00981}, "CVE-2024-42144": {"epss_score": 0.00017, "epss_percentile": 0.03053}, "CVE-2024-42145": {"epss_score": 9e-05, "epss_percentile": 0.0068}, "CVE-2024-42146": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-42147": {"epss_score": 0.00017, "epss_percentile": 0.03334}, "CVE-2024-42148": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2024-42149": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-42150": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-42151": {"epss_score": 0.00015, "epss_percentile": 0.02596}, "CVE-2024-42152": {"epss_score": 0.00017, "epss_percentile": 0.03375}, "CVE-2024-42153": {"epss_score": 0.00013, "epss_percentile": 0.0149}, "CVE-2024-42154": {"epss_score": 0.00028, "epss_percentile": 0.07338}, "CVE-2024-42155": {"epss_score": 0.00015, "epss_percentile": 0.02366}, "CVE-2024-42156": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2024-42157": {"epss_score": 0.00011, "epss_percentile": 0.00993}, "CVE-2024-42158": {"epss_score": 0.00016, "epss_percentile": 0.02939}, "CVE-2024-42159": {"epss_score": 0.00021, "epss_percentile": 0.04902}, "CVE-2024-42160": {"epss_score": 0.00016, "epss_percentile": 0.02941}, "CVE-2024-42161": {"epss_score": 0.00027, "epss_percentile": 0.06919}, "CVE-2024-42162": {"epss_score": 0.00024, "epss_percentile": 0.05847}, "CVE-2024-42163": {"epss_score": 0.00082, "epss_percentile": 0.24587}, "CVE-2024-42164": {"epss_score": 0.00107, "epss_percentile": 0.2974}, "CVE-2024-42165": {"epss_score": 0.00124, "epss_percentile": 0.32421}, "CVE-2024-42166": {"epss_score": 0.00249, "epss_percentile": 0.4805}, "CVE-2024-42167": {"epss_score": 0.00249, "epss_percentile": 0.4805}, "CVE-2024-42168": {"epss_score": 0.00171, "epss_percentile": 0.38853}, "CVE-2024-42169": {"epss_score": 0.00113, "epss_percentile": 0.30595}, "CVE-2024-42170": {"epss_score": 0.00087, "epss_percentile": 0.25494}, "CVE-2024-42171": {"epss_score": 0.00074, "epss_percentile": 0.22793}, "CVE-2024-42172": {"epss_score": 0.00208, "epss_percentile": 0.43266}, "CVE-2024-42173": {"epss_score": 0.00074, "epss_percentile": 0.22793}, "CVE-2024-42174": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-42175": {"epss_score": 0.00117, "epss_percentile": 0.31236}, "CVE-2024-42176": {"epss_score": 0.00066, "epss_percentile": 0.20824}, "CVE-2024-42177": {"epss_score": 0.0003, "epss_percentile": 0.08018}, "CVE-2024-42178": {"epss_score": 0.00114, "epss_percentile": 0.30836}, "CVE-2024-42179": {"epss_score": 0.00097, "epss_percentile": 0.27456}, "CVE-2024-42180": {"epss_score": 0.00259, "epss_percentile": 0.49027}, "CVE-2024-42181": {"epss_score": 0.00064, "epss_percentile": 0.2011}, "CVE-2024-42182": {"epss_score": 0.0002, "epss_percentile": 0.04566}, "CVE-2024-42183": {"epss_score": 0.00011, "epss_percentile": 0.01076}, "CVE-2024-42184": {"epss_score": 0.00023, "epss_percentile": 0.05604}, "CVE-2024-42185": {"epss_score": 0.00024, "epss_percentile": 0.05804}, "CVE-2024-42186": {"epss_score": 0.00014, "epss_percentile": 0.01771}, "CVE-2024-42187": {"epss_score": 0.00017, "epss_percentile": 0.03119}, "CVE-2024-42188": {"epss_score": 0.00243, "epss_percentile": 0.47413}, "CVE-2024-42189": {"epss_score": 0.00064, "epss_percentile": 0.20146}, "CVE-2024-42190": {"epss_score": 0.00032, "epss_percentile": 0.08861}, "CVE-2024-42191": {"epss_score": 0.00032, "epss_percentile": 0.08861}, "CVE-2024-42192": {"epss_score": 0.00017, "epss_percentile": 0.03255}, "CVE-2024-42193": {"epss_score": 0.00042, "epss_percentile": 0.12884}, "CVE-2024-42194": {"epss_score": 0.00061, "epss_percentile": 0.19369}, "CVE-2024-42195": {"epss_score": 0.00239, "epss_percentile": 0.46875}, "CVE-2024-42196": {"epss_score": 0.00031, "epss_percentile": 0.08515}, "CVE-2024-42197": {"epss_score": 0.00013, "epss_percentile": 0.01517}, "CVE-2024-42200": {"epss_score": 0.00041, "epss_percentile": 0.12399}, "CVE-2024-42207": {"epss_score": 0.00149, "epss_percentile": 0.35978}, "CVE-2024-42208": {"epss_score": 0.00054, "epss_percentile": 0.17056}, "CVE-2024-42209": {"epss_score": 0.00029, "epss_percentile": 0.07829}, "CVE-2024-42212": {"epss_score": 0.00032, "epss_percentile": 0.08778}, "CVE-2024-42213": {"epss_score": 0.00051, "epss_percentile": 0.16043}, "CVE-2024-42218": {"epss_score": 0.00015, "epss_percentile": 0.023}, "CVE-2024-42219": {"epss_score": 0.00116, "epss_percentile": 0.31077}, "CVE-2024-42220": {"epss_score": 0.00059, "epss_percentile": 0.18646}, "CVE-2024-42222": {"epss_score": 0.00524, "epss_percentile": 0.66326}, "CVE-2024-42223": {"epss_score": 0.00025, "epss_percentile": 0.06155}, "CVE-2024-42224": {"epss_score": 0.00035, "epss_percentile": 0.09877}, "CVE-2024-42225": {"epss_score": 0.00031, "epss_percentile": 0.08506}, "CVE-2024-42227": {"epss_score": 0.00015, "epss_percentile": 0.02596}, "CVE-2024-42228": {"epss_score": 0.00015, "epss_percentile": 0.02271}, "CVE-2024-42229": {"epss_score": 0.0001, "epss_percentile": 0.00803}, "CVE-2024-42230": {"epss_score": 0.00015, "epss_percentile": 0.02166}, "CVE-2024-42231": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-42232": {"epss_score": 0.00016, "epss_percentile": 0.02896}, "CVE-2024-42233": {"epss_score": 0.00029, "epss_percentile": 0.07911}, "CVE-2024-42234": {"epss_score": 0.00031, "epss_percentile": 0.08452}, "CVE-2024-42235": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-42236": {"epss_score": 0.00016, "epss_percentile": 0.02896}, "CVE-2024-42237": {"epss_score": 9e-05, "epss_percentile": 0.00644}, "CVE-2024-42238": {"epss_score": 0.00019, "epss_percentile": 0.04361}, "CVE-2024-42239": {"epss_score": 0.00026, "epss_percentile": 0.064}, "CVE-2024-42240": {"epss_score": 7e-05, "epss_percentile": 0.00324}, "CVE-2024-42241": {"epss_score": 0.00019, "epss_percentile": 0.04289}, "CVE-2024-42242": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-42243": {"epss_score": 0.00016, "epss_percentile": 0.02927}, "CVE-2024-42244": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2024-42245": {"epss_score": 0.00026, "epss_percentile": 0.06537}, "CVE-2024-42246": {"epss_score": 0.00011, "epss_percentile": 0.01041}, "CVE-2024-42247": {"epss_score": 0.00019, "epss_percentile": 0.04111}, "CVE-2024-42248": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-42249": {"epss_score": 0.00045, "epss_percentile": 0.13912}, "CVE-2024-42250": {"epss_score": 0.00037, "epss_percentile": 0.10969}, "CVE-2024-42251": {"epss_score": 9e-05, "epss_percentile": 0.00723}, "CVE-2024-42252": {"epss_score": 7e-05, "epss_percentile": 0.0039}, "CVE-2024-42253": {"epss_score": 0.00014, "epss_percentile": 0.01901}, "CVE-2024-42254": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-42255": {"epss_score": 0.00031, "epss_percentile": 0.08477}, "CVE-2024-42256": {"epss_score": 0.00094, "epss_percentile": 0.26953}, "CVE-2024-42257": {"epss_score": 0.00034, "epss_percentile": 0.0945}, "CVE-2024-42258": {"epss_score": 0.00021, "epss_percentile": 0.04869}, "CVE-2024-42259": {"epss_score": 0.0002, "epss_percentile": 0.04635}, "CVE-2024-42260": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2024-42261": {"epss_score": 0.0001, "epss_percentile": 0.00834}, "CVE-2024-42262": {"epss_score": 0.00017, "epss_percentile": 0.03202}, "CVE-2024-42263": {"epss_score": 0.0001, "epss_percentile": 0.00817}, "CVE-2024-42264": {"epss_score": 0.0001, "epss_percentile": 0.00873}, "CVE-2024-42265": {"epss_score": 0.00013, "epss_percentile": 0.01624}, "CVE-2024-42266": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2024-42267": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2024-42268": {"epss_score": 7e-05, "epss_percentile": 0.00412}, "CVE-2024-42269": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2024-42270": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2024-42271": {"epss_score": 0.00012, "epss_percentile": 0.01193}, "CVE-2024-42272": {"epss_score": 0.00013, "epss_percentile": 0.01654}, "CVE-2024-42273": {"epss_score": 0.00018, "epss_percentile": 0.03931}, "CVE-2024-42274": {"epss_score": 7e-05, "epss_percentile": 0.00341}, "CVE-2024-42275": {"epss_score": 0.00035, "epss_percentile": 0.09937}, "CVE-2024-42276": {"epss_score": 0.00014, "epss_percentile": 0.02016}, "CVE-2024-42277": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2024-42278": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-42279": {"epss_score": 0.00018, "epss_percentile": 0.03794}, "CVE-2024-42280": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2024-42281": {"epss_score": 0.00014, "epss_percentile": 0.02016}, "CVE-2024-42282": {"epss_score": 0.00018, "epss_percentile": 0.03706}, "CVE-2024-42283": {"epss_score": 0.00014, "epss_percentile": 0.02016}, "CVE-2024-42284": {"epss_score": 0.00011, "epss_percentile": 0.00988}, "CVE-2024-42285": {"epss_score": 0.00012, "epss_percentile": 0.01171}, "CVE-2024-42286": {"epss_score": 0.00013, "epss_percentile": 0.01583}, "CVE-2024-42287": {"epss_score": 0.00014, "epss_percentile": 0.02016}, "CVE-2024-42288": {"epss_score": 0.00011, "epss_percentile": 0.01082}, "CVE-2024-42289": {"epss_score": 0.00013, "epss_percentile": 0.01583}, "CVE-2024-42290": {"epss_score": 0.00022, "epss_percentile": 0.04981}, "CVE-2024-42291": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2024-42292": {"epss_score": 0.0001, "epss_percentile": 0.00836}, "CVE-2024-42293": {"epss_score": 0.00035, "epss_percentile": 0.09937}, "CVE-2024-42294": {"epss_score": 7e-05, "epss_percentile": 0.00394}, "CVE-2024-42295": {"epss_score": 0.00014, "epss_percentile": 0.02016}, "CVE-2024-42296": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2024-42297": {"epss_score": 0.00013, "epss_percentile": 0.01583}, "CVE-2024-42298": {"epss_score": 0.00011, "epss_percentile": 0.00941}, "CVE-2024-42299": {"epss_score": 0.00013, "epss_percentile": 0.01572}, "CVE-2024-42300": {"epss_score": 0.00024, "epss_percentile": 0.05884}, "CVE-2024-42301": {"epss_score": 0.00022, "epss_percentile": 0.05218}, "CVE-2024-42302": {"epss_score": 0.00021, "epss_percentile": 0.04944}, "CVE-2024-42303": {"epss_score": 0.00019, "epss_percentile": 0.04289}, "CVE-2024-42304": {"epss_score": 0.00028, "epss_percentile": 0.07367}, "CVE-2024-42305": {"epss_score": 0.00019, "epss_percentile": 0.04221}, "CVE-2024-42306": {"epss_score": 0.00028, "epss_percentile": 0.07367}, "CVE-2024-42307": {"epss_score": 0.00017, "epss_percentile": 0.03101}, "CVE-2024-42309": {"epss_score": 0.00026, "epss_percentile": 0.0648}, "CVE-2024-42310": {"epss_score": 0.00028, "epss_percentile": 0.07367}, "CVE-2024-42311": {"epss_score": 0.00026, "epss_percentile": 0.06436}, "CVE-2024-42312": {"epss_score": 0.00026, "epss_percentile": 0.06617}, "CVE-2024-42313": {"epss_score": 0.00022, "epss_percentile": 0.05251}, "CVE-2024-42314": {"epss_score": 0.00027, "epss_percentile": 0.06778}, "CVE-2024-42315": {"epss_score": 0.0001, "epss_percentile": 0.00751}, "CVE-2024-42316": {"epss_score": 0.0002, "epss_percentile": 0.04423}, "CVE-2024-42317": {"epss_score": 0.00065, "epss_percentile": 0.20507}, "CVE-2024-42318": {"epss_score": 6e-05, "epss_percentile": 0.00243}, "CVE-2024-42319": {"epss_score": 0.00028, "epss_percentile": 0.07557}, "CVE-2024-42320": {"epss_score": 0.00033, "epss_percentile": 0.0943}, "CVE-2024-42321": {"epss_score": 0.00019, "epss_percentile": 0.04388}, "CVE-2024-42322": {"epss_score": 0.00018, "epss_percentile": 0.03826}, "CVE-2024-42323": {"epss_score": 0.69984, "epss_percentile": 0.98611}, "CVE-2024-42325": {"epss_score": 0.00038, "epss_percentile": 0.11394}, "CVE-2024-42326": {"epss_score": 0.00073, "epss_percentile": 0.22585}, "CVE-2024-42327": {"epss_score": 0.8982, "epss_percentile": 0.99543}, "CVE-2024-42328": {"epss_score": 0.00068, "epss_percentile": 0.21262}, "CVE-2024-42329": {"epss_score": 0.00037, "epss_percentile": 0.1098}, "CVE-2024-42330": {"epss_score": 0.00141, "epss_percentile": 0.34914}, "CVE-2024-42331": {"epss_score": 0.00025, "epss_percentile": 0.06146}, "CVE-2024-42332": {"epss_score": 0.00354, "epss_percentile": 0.57218}, "CVE-2024-42333": {"epss_score": 0.00081, "epss_percentile": 0.2421}, "CVE-2024-42335": {"epss_score": 0.00149, "epss_percentile": 0.36042}, "CVE-2024-42336": {"epss_score": 0.00234, "epss_percentile": 0.46166}, "CVE-2024-42337": {"epss_score": 0.00112, "epss_percentile": 0.30454}, "CVE-2024-42338": {"epss_score": 0.00107, "epss_percentile": 0.29604}, "CVE-2024-42339": {"epss_score": 0.00107, "epss_percentile": 0.29604}, "CVE-2024-42340": {"epss_score": 0.00079, "epss_percentile": 0.23945}, "CVE-2024-42341": {"epss_score": 0.00097, "epss_percentile": 0.27551}, "CVE-2024-42342": {"epss_score": 0.00123, "epss_percentile": 0.3221}, "CVE-2024-42343": {"epss_score": 0.0012, "epss_percentile": 0.3172}, "CVE-2024-42344": {"epss_score": 0.00068, "epss_percentile": 0.21402}, "CVE-2024-42345": {"epss_score": 0.00231, "epss_percentile": 0.45847}, "CVE-2024-42346": {"epss_score": 0.07854, "epss_percentile": 0.91721}, "CVE-2024-42347": {"epss_score": 0.00766, "epss_percentile": 0.72934}, "CVE-2024-42348": {"epss_score": 0.01198, "epss_percentile": 0.78455}, "CVE-2024-42349": {"epss_score": 0.00427, "epss_percentile": 0.61906}, "CVE-2024-42350": {"epss_score": 0.00132, "epss_percentile": 0.3354}, "CVE-2024-42351": {"epss_score": 0.00279, "epss_percentile": 0.50982}, "CVE-2024-42352": {"epss_score": 0.00135, "epss_percentile": 0.34053}, "CVE-2024-42353": {"epss_score": 0.00242, "epss_percentile": 0.47409}, "CVE-2024-42354": {"epss_score": 0.00424, "epss_percentile": 0.61669}, "CVE-2024-42355": {"epss_score": 0.01052, "epss_percentile": 0.77095}, "CVE-2024-42356": {"epss_score": 0.00429, "epss_percentile": 0.61989}, "CVE-2024-42357": {"epss_score": 0.00704, "epss_percentile": 0.71572}, "CVE-2024-42358": {"epss_score": 0.00315, "epss_percentile": 0.54173}, "CVE-2024-42360": {"epss_score": 0.01618, "epss_percentile": 0.81372}, "CVE-2024-42361": {"epss_score": 0.00177, "epss_percentile": 0.3955}, "CVE-2024-42362": {"epss_score": 0.00354, "epss_percentile": 0.57203}, "CVE-2024-42363": {"epss_score": 0.03833, "epss_percentile": 0.87812}, "CVE-2024-42364": {"epss_score": 0.00097, "epss_percentile": 0.27503}, "CVE-2024-42365": {"epss_score": 0.49709, "epss_percentile": 0.97701}, "CVE-2024-42366": {"epss_score": 0.02679, "epss_percentile": 0.85412}, "CVE-2024-42367": {"epss_score": 0.00352, "epss_percentile": 0.57101}, "CVE-2024-42368": {"epss_score": 0.00041, "epss_percentile": 0.12238}, "CVE-2024-42369": {"epss_score": 0.00205, "epss_percentile": 0.427}, "CVE-2024-42370": {"epss_score": 0.01283, "epss_percentile": 0.79158}, "CVE-2024-42371": {"epss_score": 0.00063, "epss_percentile": 0.19829}, "CVE-2024-42372": {"epss_score": 0.00088, "epss_percentile": 0.25663}, "CVE-2024-42373": {"epss_score": 0.00124, "epss_percentile": 0.32452}, "CVE-2024-42374": {"epss_score": 0.00841, "epss_percentile": 0.7423}, "CVE-2024-42375": {"epss_score": 0.00506, "epss_percentile": 0.6564}, "CVE-2024-42376": {"epss_score": 0.00348, "epss_percentile": 0.56848}, "CVE-2024-42377": {"epss_score": 0.00188, "epss_percentile": 0.40882}, "CVE-2024-42378": {"epss_score": 0.00122, "epss_percentile": 0.32155}, "CVE-2024-42380": {"epss_score": 0.00081, "epss_percentile": 0.24256}, "CVE-2024-42381": {"epss_score": 0.00502, "epss_percentile": 0.6542}, "CVE-2024-42383": {"epss_score": 0.00167, "epss_percentile": 0.38393}, "CVE-2024-42384": {"epss_score": 0.00216, "epss_percentile": 0.44174}, "CVE-2024-42385": {"epss_score": 0.00034, "epss_percentile": 0.09759}, "CVE-2024-42386": {"epss_score": 0.00291, "epss_percentile": 0.52157}, "CVE-2024-42387": {"epss_score": 0.00239, "epss_percentile": 0.46923}, "CVE-2024-42388": {"epss_score": 0.00239, "epss_percentile": 0.46923}, "CVE-2024-42389": {"epss_score": 0.00239, "epss_percentile": 0.46923}, "CVE-2024-42390": {"epss_score": 0.00239, "epss_percentile": 0.46923}, "CVE-2024-42391": {"epss_score": 0.00239, "epss_percentile": 0.46923}, "CVE-2024-42392": {"epss_score": 0.00081, "epss_percentile": 0.24312}, "CVE-2024-42393": {"epss_score": 0.00473, "epss_percentile": 0.64109}, "CVE-2024-42394": {"epss_score": 0.00309, "epss_percentile": 0.53699}, "CVE-2024-42395": {"epss_score": 0.00266, "epss_percentile": 0.49886}, "CVE-2024-42396": {"epss_score": 0.00099, "epss_percentile": 0.28428}, "CVE-2024-42397": {"epss_score": 0.00133, "epss_percentile": 0.33702}, "CVE-2024-42398": {"epss_score": 0.00163, "epss_percentile": 0.37804}, "CVE-2024-42399": {"epss_score": 0.00163, "epss_percentile": 0.37804}, "CVE-2024-42400": {"epss_score": 0.00139, "epss_percentile": 0.34646}, "CVE-2024-42404": {"epss_score": 0.00434, "epss_percentile": 0.62287}, "CVE-2024-42405": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-42406": {"epss_score": 0.00207, "epss_percentile": 0.43162}, "CVE-2024-42407": {"epss_score": 0.00135, "epss_percentile": 0.33981}, "CVE-2024-42408": {"epss_score": 0.008, "epss_percentile": 0.73557}, "CVE-2024-42410": {"epss_score": 0.00031, "epss_percentile": 0.08638}, "CVE-2024-42411": {"epss_score": 0.00275, "epss_percentile": 0.50645}, "CVE-2024-42412": {"epss_score": 0.00691, "epss_percentile": 0.71261}, "CVE-2024-42415": {"epss_score": 0.00035, "epss_percentile": 0.10116}, "CVE-2024-42416": {"epss_score": 0.00739, "epss_percentile": 0.72389}, "CVE-2024-42417": {"epss_score": 0.06542, "epss_percentile": 0.90835}, "CVE-2024-42418": {"epss_score": 0.00142, "epss_percentile": 0.35072}, "CVE-2024-42419": {"epss_score": 0.00018, "epss_percentile": 0.03848}, "CVE-2024-42420": {"epss_score": 0.00886, "epss_percentile": 0.74952}, "CVE-2024-42422": {"epss_score": 0.00495, "epss_percentile": 0.6513}, "CVE-2024-42423": {"epss_score": 0.0002, "epss_percentile": 0.04534}, "CVE-2024-42424": {"epss_score": 0.00039, "epss_percentile": 0.11861}, "CVE-2024-42425": {"epss_score": 0.00106, "epss_percentile": 0.29508}, "CVE-2024-42426": {"epss_score": 0.00242, "epss_percentile": 0.47395}, "CVE-2024-42427": {"epss_score": 0.00974, "epss_percentile": 0.76192}, "CVE-2024-42434": {"epss_score": 0.0028, "epss_percentile": 0.51022}, "CVE-2024-42435": {"epss_score": 0.00364, "epss_percentile": 0.57946}, "CVE-2024-42436": {"epss_score": 0.00671, "epss_percentile": 0.70801}, "CVE-2024-42437": {"epss_score": 0.00616, "epss_percentile": 0.69331}, "CVE-2024-42438": {"epss_score": 0.00705, "epss_percentile": 0.7158}, "CVE-2024-42439": {"epss_score": 0.00102, "epss_percentile": 0.28755}, "CVE-2024-42440": {"epss_score": 0.00077, "epss_percentile": 0.23451}, "CVE-2024-42441": {"epss_score": 0.001, "epss_percentile": 0.28539}, "CVE-2024-42442": {"epss_score": 0.00259, "epss_percentile": 0.4909}, "CVE-2024-42444": {"epss_score": 0.00024, "epss_percentile": 0.059}, "CVE-2024-42446": {"epss_score": 0.00012, "epss_percentile": 0.01227}, "CVE-2024-42447": {"epss_score": 0.00425, "epss_percentile": 0.6171}, "CVE-2024-42448": {"epss_score": 0.37453, "epss_percentile": 0.97048}, "CVE-2024-42449": {"epss_score": 0.00142, "epss_percentile": 0.34966}, "CVE-2024-42450": {"epss_score": 0.00276, "epss_percentile": 0.50764}, "CVE-2024-42451": {"epss_score": 0.00056, "epss_percentile": 0.17961}, "CVE-2024-42452": {"epss_score": 0.00141, "epss_percentile": 0.34948}, "CVE-2024-42453": {"epss_score": 0.00099, "epss_percentile": 0.28395}, "CVE-2024-42455": {"epss_score": 0.00133, "epss_percentile": 0.33701}, "CVE-2024-42456": {"epss_score": 0.0007, "epss_percentile": 0.21942}, "CVE-2024-42457": {"epss_score": 0.00087, "epss_percentile": 0.25526}, "CVE-2024-42458": {"epss_score": 0.00278, "epss_percentile": 0.50917}, "CVE-2024-42459": {"epss_score": 0.00131, "epss_percentile": 0.3346}, "CVE-2024-42460": {"epss_score": 0.00241, "epss_percentile": 0.4727}, "CVE-2024-42461": {"epss_score": 0.02898, "epss_percentile": 0.85937}, "CVE-2024-42462": {"epss_score": 0.00135, "epss_percentile": 0.33931}, "CVE-2024-42463": {"epss_score": 0.00112, "epss_percentile": 0.30474}, "CVE-2024-42464": {"epss_score": 0.00065, "epss_percentile": 0.20648}, "CVE-2024-42465": {"epss_score": 0.00362, "epss_percentile": 0.57813}, "CVE-2024-42466": {"epss_score": 0.00407, "epss_percentile": 0.60613}, "CVE-2024-42467": {"epss_score": 0.01768, "epss_percentile": 0.82181}, "CVE-2024-42468": {"epss_score": 0.01555, "epss_percentile": 0.81005}, "CVE-2024-42469": {"epss_score": 0.13819, "epss_percentile": 0.94067}, "CVE-2024-42470": {"epss_score": 0.00588, "epss_percentile": 0.68495}, "CVE-2024-42471": {"epss_score": 0.0583, "epss_percentile": 0.9024}, "CVE-2024-42472": {"epss_score": 0.06062, "epss_percentile": 0.90444}, "CVE-2024-42473": {"epss_score": 0.00067, "epss_percentile": 0.21024}, "CVE-2024-42474": {"epss_score": 0.01748, "epss_percentile": 0.82081}, "CVE-2024-42475": {"epss_score": 0.00038, "epss_percentile": 0.11188}, "CVE-2024-42476": {"epss_score": 0.00146, "epss_percentile": 0.35594}, "CVE-2024-42477": {"epss_score": 0.00271, "epss_percentile": 0.50291}, "CVE-2024-42478": {"epss_score": 0.00491, "epss_percentile": 0.64949}, "CVE-2024-42479": {"epss_score": 0.05864, "epss_percentile": 0.90273}, "CVE-2024-42480": {"epss_score": 0.00425, "epss_percentile": 0.61706}, "CVE-2024-42481": {"epss_score": 0.00638, "epss_percentile": 0.69924}, "CVE-2024-42482": {"epss_score": 0.00849, "epss_percentile": 0.74373}, "CVE-2024-42483": {"epss_score": 0.00045, "epss_percentile": 0.13904}, "CVE-2024-42484": {"epss_score": 0.00082, "epss_percentile": 0.24575}, "CVE-2024-42485": {"epss_score": 0.00738, "epss_percentile": 0.72335}, "CVE-2024-42486": {"epss_score": 0.00301, "epss_percentile": 0.53003}, "CVE-2024-42487": {"epss_score": 0.01788, "epss_percentile": 0.82265}, "CVE-2024-42488": {"epss_score": 0.00024, "epss_percentile": 0.0585}, "CVE-2024-42489": {"epss_score": 0.45402, "epss_percentile": 0.97486}, "CVE-2024-42490": {"epss_score": 0.01251, "epss_percentile": 0.78897}, "CVE-2024-42491": {"epss_score": 0.01464, "epss_percentile": 0.80451}, "CVE-2024-42492": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-42493": {"epss_score": 0.00519, "epss_percentile": 0.66167}, "CVE-2024-42494": {"epss_score": 0.00107, "epss_percentile": 0.29728}, "CVE-2024-42495": {"epss_score": 0.00055, "epss_percentile": 0.17589}, "CVE-2024-42496": {"epss_score": 0.00107, "epss_percentile": 0.29721}, "CVE-2024-42497": {"epss_score": 0.00092, "epss_percentile": 0.26497}, "CVE-2024-42499": {"epss_score": 0.00172, "epss_percentile": 0.38902}, "CVE-2024-42500": {"epss_score": 0.00109, "epss_percentile": 0.2992}, "CVE-2024-42501": {"epss_score": 0.00107, "epss_percentile": 0.29749}, "CVE-2024-42502": {"epss_score": 0.00175, "epss_percentile": 0.39273}, "CVE-2024-42503": {"epss_score": 0.00073, "epss_percentile": 0.22629}, "CVE-2024-42504": {"epss_score": 0.00086, "epss_percentile": 0.2528}, "CVE-2024-42505": {"epss_score": 0.01337, "epss_percentile": 0.79561}, "CVE-2024-42506": {"epss_score": 0.01595, "epss_percentile": 0.81237}, "CVE-2024-42507": {"epss_score": 0.01595, "epss_percentile": 0.81237}, "CVE-2024-42508": {"epss_score": 0.00036, "epss_percentile": 0.10558}, "CVE-2024-42509": {"epss_score": 0.01492, "epss_percentile": 0.80635}, "CVE-2024-42512": {"epss_score": 0.00084, "epss_percentile": 0.24926}, "CVE-2024-42513": {"epss_score": 0.00034, "epss_percentile": 0.09732}, "CVE-2024-42514": {"epss_score": 0.003, "epss_percentile": 0.52956}, "CVE-2024-42515": {"epss_score": 0.00112, "epss_percentile": 0.30443}, "CVE-2024-42516": {"epss_score": 0.0024, "epss_percentile": 0.47212}, "CVE-2024-42520": {"epss_score": 0.00526, "epss_percentile": 0.66425}, "CVE-2024-42523": {"epss_score": 0.00091, "epss_percentile": 0.26222}, "CVE-2024-42531": {"epss_score": 0.00166, "epss_percentile": 0.3817}, "CVE-2024-42533": {"epss_score": 0.00541, "epss_percentile": 0.67053}, "CVE-2024-42543": {"epss_score": 0.0181, "epss_percentile": 0.82363}, "CVE-2024-42545": {"epss_score": 0.02155, "epss_percentile": 0.83806}, "CVE-2024-42546": {"epss_score": 0.00526, "epss_percentile": 0.66425}, "CVE-2024-42547": {"epss_score": 0.00526, "epss_percentile": 0.66425}, "CVE-2024-42550": {"epss_score": 0.00267, "epss_percentile": 0.49984}, "CVE-2024-42552": {"epss_score": 0.00194, "epss_percentile": 0.41598}, "CVE-2024-42553": {"epss_score": 0.0025, "epss_percentile": 0.4825}, "CVE-2024-42554": {"epss_score": 0.00218, "epss_percentile": 0.44394}, "CVE-2024-42555": {"epss_score": 0.00258, "epss_percentile": 0.48978}, "CVE-2024-42556": {"epss_score": 0.00118, "epss_percentile": 0.31441}, "CVE-2024-42557": {"epss_score": 0.00157, "epss_percentile": 0.37028}, "CVE-2024-42558": {"epss_score": 0.00118, "epss_percentile": 0.31441}, "CVE-2024-42559": {"epss_score": 0.00147, "epss_percentile": 0.35724}, "CVE-2024-42560": {"epss_score": 0.00307, "epss_percentile": 0.53469}, "CVE-2024-42561": {"epss_score": 0.04519, "epss_percentile": 0.88796}, "CVE-2024-42562": {"epss_score": 0.00188, "epss_percentile": 0.40829}, "CVE-2024-42563": {"epss_score": 0.00268, "epss_percentile": 0.50085}, "CVE-2024-42564": {"epss_score": 0.00137, "epss_percentile": 0.34221}, "CVE-2024-42565": {"epss_score": 0.00197, "epss_percentile": 0.41911}, "CVE-2024-42566": {"epss_score": 0.00188, "epss_percentile": 0.40838}, "CVE-2024-42567": {"epss_score": 0.00188, "epss_percentile": 0.40829}, "CVE-2024-42568": {"epss_score": 0.00188, "epss_percentile": 0.40829}, "CVE-2024-42569": {"epss_score": 0.00197, "epss_percentile": 0.41911}, "CVE-2024-42570": {"epss_score": 0.00197, "epss_percentile": 0.41911}, "CVE-2024-42571": {"epss_score": 0.00197, "epss_percentile": 0.41911}, "CVE-2024-42572": {"epss_score": 0.00197, "epss_percentile": 0.41911}, "CVE-2024-42573": {"epss_score": 0.00197, "epss_percentile": 0.41911}, "CVE-2024-42574": {"epss_score": 0.00188, "epss_percentile": 0.40829}, "CVE-2024-42575": {"epss_score": 0.00188, "epss_percentile": 0.40829}, "CVE-2024-42576": {"epss_score": 0.0025, "epss_percentile": 0.4825}, "CVE-2024-42577": {"epss_score": 0.00216, "epss_percentile": 0.44147}, "CVE-2024-42578": {"epss_score": 0.00251, "epss_percentile": 0.4826}, "CVE-2024-42579": {"epss_score": 0.00227, "epss_percentile": 0.45375}, "CVE-2024-42580": {"epss_score": 0.00166, "epss_percentile": 0.38231}, "CVE-2024-42581": {"epss_score": 0.00227, "epss_percentile": 0.45375}, "CVE-2024-42582": {"epss_score": 0.00227, "epss_percentile": 0.45375}, "CVE-2024-42583": {"epss_score": 0.00227, "epss_percentile": 0.45375}, "CVE-2024-42584": {"epss_score": 0.0025, "epss_percentile": 0.4825}, "CVE-2024-42585": {"epss_score": 0.00247, "epss_percentile": 0.47818}, "CVE-2024-42586": {"epss_score": 0.00254, "epss_percentile": 0.4854}, "CVE-2024-42598": {"epss_score": 0.00106, "epss_percentile": 0.2948}, "CVE-2024-42599": {"epss_score": 0.0042, "epss_percentile": 0.61416}, "CVE-2024-42603": {"epss_score": 0.00156, "epss_percentile": 0.36911}, "CVE-2024-42604": {"epss_score": 0.00235, "epss_percentile": 0.46211}, "CVE-2024-42605": {"epss_score": 0.00117, "epss_percentile": 0.31207}, "CVE-2024-42606": {"epss_score": 0.00164, "epss_percentile": 0.37887}, "CVE-2024-42607": {"epss_score": 0.00235, "epss_percentile": 0.46211}, "CVE-2024-42608": {"epss_score": 0.00235, "epss_percentile": 0.46211}, "CVE-2024-42609": {"epss_score": 0.00117, "epss_percentile": 0.31207}, "CVE-2024-42610": {"epss_score": 0.00235, "epss_percentile": 0.46211}, "CVE-2024-42611": {"epss_score": 0.00173, "epss_percentile": 0.39062}, "CVE-2024-42612": {"epss_score": 0.00178, "epss_percentile": 0.39676}, "CVE-2024-42613": {"epss_score": 0.00173, "epss_percentile": 0.39062}, "CVE-2024-42616": {"epss_score": 0.00173, "epss_percentile": 0.39062}, "CVE-2024-42617": {"epss_score": 0.00173, "epss_percentile": 0.39062}, "CVE-2024-42618": {"epss_score": 0.00173, "epss_percentile": 0.39062}, "CVE-2024-42619": {"epss_score": 0.00178, "epss_percentile": 0.39676}, "CVE-2024-42621": {"epss_score": 0.00173, "epss_percentile": 0.39062}, "CVE-2024-42623": {"epss_score": 0.00235, "epss_percentile": 0.46211}, "CVE-2024-42624": {"epss_score": 0.00235, "epss_percentile": 0.46211}, "CVE-2024-42625": {"epss_score": 0.00205, "epss_percentile": 0.42713}, "CVE-2024-42626": {"epss_score": 0.00216, "epss_percentile": 0.44147}, "CVE-2024-42627": {"epss_score": 0.00216, "epss_percentile": 0.44147}, "CVE-2024-42628": {"epss_score": 0.00293, "epss_percentile": 0.52329}, "CVE-2024-42629": {"epss_score": 0.00278, "epss_percentile": 0.50924}, "CVE-2024-42630": {"epss_score": 0.00319, "epss_percentile": 0.54498}, "CVE-2024-42631": {"epss_score": 0.00129, "epss_percentile": 0.33143}, "CVE-2024-42632": {"epss_score": 0.00129, "epss_percentile": 0.33143}, "CVE-2024-42633": {"epss_score": 0.03339, "epss_percentile": 0.86939}, "CVE-2024-42634": {"epss_score": 0.03205, "epss_percentile": 0.8663}, "CVE-2024-42636": {"epss_score": 0.00067, "epss_percentile": 0.21145}, "CVE-2024-42637": {"epss_score": 0.00158, "epss_percentile": 0.37147}, "CVE-2024-42638": {"epss_score": 0.00158, "epss_percentile": 0.37147}, "CVE-2024-42639": {"epss_score": 0.00158, "epss_percentile": 0.37147}, "CVE-2024-42640": {"epss_score": 0.85075, "epss_percentile": 0.99315}, "CVE-2024-42642": {"epss_score": 0.0351, "epss_percentile": 0.87265}, "CVE-2024-42643": {"epss_score": 0.00327, "epss_percentile": 0.55128}, "CVE-2024-42644": {"epss_score": 0.00029, "epss_percentile": 0.07613}, "CVE-2024-42645": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2024-42646": {"epss_score": 0.00139, "epss_percentile": 0.34598}, "CVE-2024-42648": {"epss_score": 0.00065, "epss_percentile": 0.2058}, "CVE-2024-42649": {"epss_score": 0.00089, "epss_percentile": 0.25802}, "CVE-2024-42650": {"epss_score": 0.00131, "epss_percentile": 0.33494}, "CVE-2024-42651": {"epss_score": 0.00131, "epss_percentile": 0.33494}, "CVE-2024-42655": {"epss_score": 0.00053, "epss_percentile": 0.17005}, "CVE-2024-42657": {"epss_score": 0.02091, "epss_percentile": 0.83571}, "CVE-2024-42658": {"epss_score": 0.14387, "epss_percentile": 0.942}, "CVE-2024-42662": {"epss_score": 0.00221, "epss_percentile": 0.44706}, "CVE-2024-42671": {"epss_score": 0.00066, "epss_percentile": 0.20884}, "CVE-2024-42676": {"epss_score": 0.03819, "epss_percentile": 0.87773}, "CVE-2024-42677": {"epss_score": 0.00059, "epss_percentile": 0.18801}, "CVE-2024-42678": {"epss_score": 0.00216, "epss_percentile": 0.4422}, "CVE-2024-42679": {"epss_score": 0.00069, "epss_percentile": 0.21435}, "CVE-2024-42680": {"epss_score": 0.00071, "epss_percentile": 0.22211}, "CVE-2024-42681": {"epss_score": 0.01847, "epss_percentile": 0.82521}, "CVE-2024-42697": {"epss_score": 0.00321, "epss_percentile": 0.54688}, "CVE-2024-42698": {"epss_score": 0.00114, "epss_percentile": 0.30736}, "CVE-2024-42699": {"epss_score": 0.00209, "epss_percentile": 0.43365}, "CVE-2024-42718": {"epss_score": 0.00059, "epss_percentile": 0.18648}, "CVE-2024-42733": {"epss_score": 0.0188, "epss_percentile": 0.82674}, "CVE-2024-42736": {"epss_score": 0.00961, "epss_percentile": 0.75975}, "CVE-2024-42737": {"epss_score": 0.07019, "epss_percentile": 0.91191}, "CVE-2024-42738": {"epss_score": 0.05425, "epss_percentile": 0.89867}, "CVE-2024-42739": {"epss_score": 0.05425, "epss_percentile": 0.89867}, "CVE-2024-42740": {"epss_score": 0.00458, "epss_percentile": 0.63424}, "CVE-2024-42741": {"epss_score": 0.04115, "epss_percentile": 0.88276}, "CVE-2024-42742": {"epss_score": 0.05403, "epss_percentile": 0.89834}, "CVE-2024-42743": {"epss_score": 0.05403, "epss_percentile": 0.89834}, "CVE-2024-42744": {"epss_score": 0.04994, "epss_percentile": 0.89371}, "CVE-2024-42745": {"epss_score": 0.06473, "epss_percentile": 0.9078}, "CVE-2024-42747": {"epss_score": 0.02019, "epss_percentile": 0.83291}, "CVE-2024-42748": {"epss_score": 0.06473, "epss_percentile": 0.9078}, "CVE-2024-42749": {"epss_score": 0.00054, "epss_percentile": 0.1718}, "CVE-2024-42756": {"epss_score": 0.01247, "epss_percentile": 0.78861}, "CVE-2024-42757": {"epss_score": 0.03788, "epss_percentile": 0.87728}, "CVE-2024-42758": {"epss_score": 0.01887, "epss_percentile": 0.82718}, "CVE-2024-42759": {"epss_score": 0.00268, "epss_percentile": 0.50096}, "CVE-2024-42760": {"epss_score": 0.00078, "epss_percentile": 0.23688}, "CVE-2024-42761": {"epss_score": 0.00269, "epss_percentile": 0.50185}, "CVE-2024-42762": {"epss_score": 0.00251, "epss_percentile": 0.48332}, "CVE-2024-42763": {"epss_score": 0.00251, "epss_percentile": 0.48332}, "CVE-2024-42764": {"epss_score": 0.00096, "epss_percentile": 0.2741}, "CVE-2024-42765": {"epss_score": 0.00028, "epss_percentile": 0.07221}, "CVE-2024-42766": {"epss_score": 0.00066, "epss_percentile": 0.20746}, "CVE-2024-42767": {"epss_score": 0.00093, "epss_percentile": 0.26661}, "CVE-2024-42768": {"epss_score": 0.00096, "epss_percentile": 0.27443}, "CVE-2024-42769": {"epss_score": 0.00269, "epss_percentile": 0.50185}, "CVE-2024-42770": {"epss_score": 0.00384, "epss_percentile": 0.59151}, "CVE-2024-42771": {"epss_score": 0.00188, "epss_percentile": 0.40833}, "CVE-2024-42772": {"epss_score": 0.00247, "epss_percentile": 0.47829}, "CVE-2024-42773": {"epss_score": 0.00237, "epss_percentile": 0.46651}, "CVE-2024-42774": {"epss_score": 0.00228, "epss_percentile": 0.45503}, "CVE-2024-42775": {"epss_score": 0.00237, "epss_percentile": 0.46651}, "CVE-2024-42776": {"epss_score": 0.00077, "epss_percentile": 0.23319}, "CVE-2024-42777": {"epss_score": 0.0017, "epss_percentile": 0.38716}, "CVE-2024-42778": {"epss_score": 0.00231, "epss_percentile": 0.45835}, "CVE-2024-42779": {"epss_score": 0.00231, "epss_percentile": 0.45835}, "CVE-2024-42780": {"epss_score": 0.00231, "epss_percentile": 0.45835}, "CVE-2024-42781": {"epss_score": 0.00038, "epss_percentile": 0.11121}, "CVE-2024-42782": {"epss_score": 0.00098, "epss_percentile": 0.27698}, "CVE-2024-42783": {"epss_score": 0.00121, "epss_percentile": 0.31818}, "CVE-2024-42784": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2024-42785": {"epss_score": 0.00098, "epss_percentile": 0.27698}, "CVE-2024-42786": {"epss_score": 0.00138, "epss_percentile": 0.34462}, "CVE-2024-42787": {"epss_score": 0.00283, "epss_percentile": 0.51385}, "CVE-2024-42788": {"epss_score": 0.00269, "epss_percentile": 0.50185}, "CVE-2024-42789": {"epss_score": 0.00345, "epss_percentile": 0.56599}, "CVE-2024-42790": {"epss_score": 0.00231, "epss_percentile": 0.45794}, "CVE-2024-42791": {"epss_score": 0.00141, "epss_percentile": 0.34844}, "CVE-2024-42792": {"epss_score": 0.00088, "epss_percentile": 0.25787}, "CVE-2024-42793": {"epss_score": 0.00088, "epss_percentile": 0.25695}, "CVE-2024-42794": {"epss_score": 0.00048, "epss_percentile": 0.15127}, "CVE-2024-42795": {"epss_score": 0.00039, "epss_percentile": 0.11467}, "CVE-2024-42796": {"epss_score": 0.00058, "epss_percentile": 0.18568}, "CVE-2024-42797": {"epss_score": 0.00314, "epss_percentile": 0.54091}, "CVE-2024-42798": {"epss_score": 0.00061, "epss_percentile": 0.19519}, "CVE-2024-42812": {"epss_score": 0.33502, "epss_percentile": 0.96779}, "CVE-2024-42813": {"epss_score": 0.00295, "epss_percentile": 0.52504}, "CVE-2024-42815": {"epss_score": 0.00401, "epss_percentile": 0.60242}, "CVE-2024-42816": {"epss_score": 0.00133, "epss_percentile": 0.33712}, "CVE-2024-42818": {"epss_score": 0.00133, "epss_percentile": 0.33712}, "CVE-2024-42831": {"epss_score": 0.01485, "epss_percentile": 0.80598}, "CVE-2024-42834": {"epss_score": 0.0168, "epss_percentile": 0.81724}, "CVE-2024-42835": {"epss_score": 0.12634, "epss_percentile": 0.93735}, "CVE-2024-42843": {"epss_score": 0.00067, "epss_percentile": 0.21021}, "CVE-2024-42844": {"epss_score": 0.00073, "epss_percentile": 0.22477}, "CVE-2024-42845": {"epss_score": 0.60859, "epss_percentile": 0.98224}, "CVE-2024-42849": {"epss_score": 0.11348, "epss_percentile": 0.93319}, "CVE-2024-42850": {"epss_score": 0.49775, "epss_percentile": 0.97706}, "CVE-2024-42851": {"epss_score": 0.00096, "epss_percentile": 0.27293}, "CVE-2024-42852": {"epss_score": 0.02014, "epss_percentile": 0.83269}, "CVE-2024-42861": {"epss_score": 0.31904, "epss_percentile": 0.96658}, "CVE-2024-42885": {"epss_score": 0.00094, "epss_percentile": 0.26775}, "CVE-2024-42898": {"epss_score": 0.05341, "epss_percentile": 0.89762}, "CVE-2024-42900": {"epss_score": 0.0009, "epss_percentile": 0.26055}, "CVE-2024-42901": {"epss_score": 0.00119, "epss_percentile": 0.31554}, "CVE-2024-42902": {"epss_score": 0.00158, "epss_percentile": 0.37225}, "CVE-2024-42903": {"epss_score": 0.00311, "epss_percentile": 0.53841}, "CVE-2024-42904": {"epss_score": 0.00144, "epss_percentile": 0.35293}, "CVE-2024-42905": {"epss_score": 0.03528, "epss_percentile": 0.87296}, "CVE-2024-42906": {"epss_score": 0.00094, "epss_percentile": 0.27042}, "CVE-2024-42911": {"epss_score": 0.00229, "epss_percentile": 0.45639}, "CVE-2024-42912": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2024-42913": {"epss_score": 0.0017, "epss_percentile": 0.38724}, "CVE-2024-42914": {"epss_score": 0.00149, "epss_percentile": 0.35956}, "CVE-2024-42915": {"epss_score": 0.00062, "epss_percentile": 0.19575}, "CVE-2024-42918": {"epss_score": 0.00159, "epss_percentile": 0.37372}, "CVE-2024-42919": {"epss_score": 0.07786, "epss_percentile": 0.91681}, "CVE-2024-42922": {"epss_score": 0.03115, "epss_percentile": 0.86432}, "CVE-2024-42930": {"epss_score": 0.00134, "epss_percentile": 0.33921}, "CVE-2024-42934": {"epss_score": 0.00014, "epss_percentile": 0.01961}, "CVE-2024-42936": {"epss_score": 0.02073, "epss_percentile": 0.83492}, "CVE-2024-42939": {"epss_score": 0.00184, "epss_percentile": 0.40422}, "CVE-2024-42940": {"epss_score": 0.00141, "epss_percentile": 0.34952}, "CVE-2024-42941": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2024-42942": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2024-42943": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2024-42944": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2024-42945": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2024-42946": {"epss_score": 0.00084, "epss_percentile": 0.24848}, "CVE-2024-42947": {"epss_score": 0.00387, "epss_percentile": 0.59309}, "CVE-2024-42948": {"epss_score": 0.04916, "epss_percentile": 0.89285}, "CVE-2024-42949": {"epss_score": 0.00154, "epss_percentile": 0.36734}, "CVE-2024-42950": {"epss_score": 0.00154, "epss_percentile": 0.36734}, "CVE-2024-42951": {"epss_score": 0.00154, "epss_percentile": 0.36734}, "CVE-2024-42952": {"epss_score": 0.00154, "epss_percentile": 0.36734}, "CVE-2024-42953": {"epss_score": 0.00154, "epss_percentile": 0.36734}, "CVE-2024-42954": {"epss_score": 0.00202, "epss_percentile": 0.42417}, "CVE-2024-42955": {"epss_score": 0.00154, "epss_percentile": 0.36734}, "CVE-2024-42966": {"epss_score": 0.00185, "epss_percentile": 0.4052}, "CVE-2024-42967": {"epss_score": 0.00185, "epss_percentile": 0.4052}, "CVE-2024-42968": {"epss_score": 0.00154, "epss_percentile": 0.36734}, "CVE-2024-42969": {"epss_score": 0.00154, "epss_percentile": 0.36734}, "CVE-2024-42973": {"epss_score": 0.00154, "epss_percentile": 0.36734}, "CVE-2024-42974": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-42976": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-42977": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-42978": {"epss_score": 0.00491, "epss_percentile": 0.64953}, "CVE-2024-42979": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-42980": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-42981": {"epss_score": 0.00406, "epss_percentile": 0.60518}, "CVE-2024-42982": {"epss_score": 0.0022, "epss_percentile": 0.44567}, "CVE-2024-42983": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-42984": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-42985": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-42986": {"epss_score": 0.0031, "epss_percentile": 0.53797}, "CVE-2024-42987": {"epss_score": 0.06608, "epss_percentile": 0.90884}, "CVE-2024-42988": {"epss_score": 0.00166, "epss_percentile": 0.38161}, "CVE-2024-42991": {"epss_score": 0.0159, "epss_percentile": 0.81201}, "CVE-2024-42994": {"epss_score": 0.00125, "epss_percentile": 0.32586}, "CVE-2024-42995": {"epss_score": 0.00132, "epss_percentile": 0.33505}, "CVE-2024-43005": {"epss_score": 0.00244, "epss_percentile": 0.47523}, "CVE-2024-43006": {"epss_score": 0.00155, "epss_percentile": 0.36846}, "CVE-2024-43009": {"epss_score": 0.00265, "epss_percentile": 0.49798}, "CVE-2024-43011": {"epss_score": 0.00433, "epss_percentile": 0.62201}, "CVE-2024-43018": {"epss_score": 0.00024, "epss_percentile": 0.05803}, "CVE-2024-43022": {"epss_score": 0.00258, "epss_percentile": 0.48973}, "CVE-2024-43024": {"epss_score": 0.00346, "epss_percentile": 0.56649}, "CVE-2024-43025": {"epss_score": 0.00265, "epss_percentile": 0.49829}, "CVE-2024-43027": {"epss_score": 0.00514, "epss_percentile": 0.65954}, "CVE-2024-43031": {"epss_score": 0.00051, "epss_percentile": 0.16036}, "CVE-2024-43032": {"epss_score": 0.00011, "epss_percentile": 0.01107}, "CVE-2024-43033": {"epss_score": 0.01109, "epss_percentile": 0.77644}, "CVE-2024-43040": {"epss_score": 0.00107, "epss_percentile": 0.29747}, "CVE-2024-43042": {"epss_score": 0.00206, "epss_percentile": 0.42999}, "CVE-2024-43044": {"epss_score": 0.52142, "epss_percentile": 0.97811}, "CVE-2024-43045": {"epss_score": 0.00567, "epss_percentile": 0.67858}, "CVE-2024-43046": {"epss_score": 0.00023, "epss_percentile": 0.05391}, "CVE-2024-43047": {"epss_score": 0.02338, "epss_percentile": 0.84424}, "CVE-2024-43048": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-43049": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-43050": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-43051": {"epss_score": 0.00022, "epss_percentile": 0.05167}, "CVE-2024-43052": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-43053": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-43055": {"epss_score": 0.00029, "epss_percentile": 0.0773}, "CVE-2024-43056": {"epss_score": 0.00027, "epss_percentile": 0.0711}, "CVE-2024-43057": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-43058": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2024-43059": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-43060": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-43061": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-43062": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-43063": {"epss_score": 0.00032, "epss_percentile": 0.08825}, "CVE-2024-43064": {"epss_score": 0.00018, "epss_percentile": 0.03704}, "CVE-2024-43065": {"epss_score": 0.00023, "epss_percentile": 0.05391}, "CVE-2024-43066": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2024-43067": {"epss_score": 0.0002, "epss_percentile": 0.04476}, "CVE-2024-43077": {"epss_score": 0.00011, "epss_percentile": 0.01079}, "CVE-2024-43080": {"epss_score": 0.00093, "epss_percentile": 0.26657}, "CVE-2024-43081": {"epss_score": 8e-05, "epss_percentile": 0.0053}, "CVE-2024-43082": {"epss_score": 0.0005, "epss_percentile": 0.15728}, "CVE-2024-43083": {"epss_score": 0.00089, "epss_percentile": 0.25947}, "CVE-2024-43084": {"epss_score": 0.00047, "epss_percentile": 0.14794}, "CVE-2024-43085": {"epss_score": 0.00056, "epss_percentile": 0.17829}, "CVE-2024-43086": {"epss_score": 0.00042, "epss_percentile": 0.12909}, "CVE-2024-43087": {"epss_score": 0.00066, "epss_percentile": 0.20699}, "CVE-2024-43088": {"epss_score": 0.00407, "epss_percentile": 0.6059}, "CVE-2024-43089": {"epss_score": 0.00056, "epss_percentile": 0.17829}, "CVE-2024-43090": {"epss_score": 0.00381, "epss_percentile": 0.59006}, "CVE-2024-43091": {"epss_score": 0.04331, "epss_percentile": 0.88559}, "CVE-2024-43093": {"epss_score": 0.00115, "epss_percentile": 0.31014}, "CVE-2024-43095": {"epss_score": 0.00015, "epss_percentile": 0.02336}, "CVE-2024-43096": {"epss_score": 0.00058, "epss_percentile": 0.1858}, "CVE-2024-43097": {"epss_score": 0.00081, "epss_percentile": 0.24271}, "CVE-2024-43098": {"epss_score": 0.00035, "epss_percentile": 0.09904}, "CVE-2024-43099": {"epss_score": 0.00095, "epss_percentile": 0.2708}, "CVE-2024-43101": {"epss_score": 0.00017, "epss_percentile": 0.032}, "CVE-2024-43102": {"epss_score": 0.01416, "epss_percentile": 0.80142}, "CVE-2024-43105": {"epss_score": 0.00154, "epss_percentile": 0.36699}, "CVE-2024-43106": {"epss_score": 0.00059, "epss_percentile": 0.18646}, "CVE-2024-43107": {"epss_score": 0.0008, "epss_percentile": 0.24025}, "CVE-2024-43108": {"epss_score": 0.00044, "epss_percentile": 0.13442}, "CVE-2024-43110": {"epss_score": 0.01984, "epss_percentile": 0.8315}, "CVE-2024-43111": {"epss_score": 0.00876, "epss_percentile": 0.74785}, "CVE-2024-43112": {"epss_score": 0.01348, "epss_percentile": 0.79661}, "CVE-2024-43113": {"epss_score": 0.01035, "epss_percentile": 0.76895}, "CVE-2024-43114": {"epss_score": 6e-05, "epss_percentile": 0.00307}, "CVE-2024-43115": {"epss_score": 0.00086, "epss_percentile": 0.25345}, "CVE-2024-43116": {"epss_score": 0.0013, "epss_percentile": 0.3326}, "CVE-2024-43117": {"epss_score": 0.0013, "epss_percentile": 0.3326}, "CVE-2024-43118": {"epss_score": 0.00241, "epss_percentile": 0.47243}, "CVE-2024-43119": {"epss_score": 0.00121, "epss_percentile": 0.31937}, "CVE-2024-43120": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-43121": {"epss_score": 0.0036, "epss_percentile": 0.57682}, "CVE-2024-43122": {"epss_score": 0.00322, "epss_percentile": 0.54785}, "CVE-2024-43123": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2024-43124": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2024-43125": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2024-43126": {"epss_score": 0.00414, "epss_percentile": 0.61104}, "CVE-2024-43127": {"epss_score": 0.00414, "epss_percentile": 0.61104}, "CVE-2024-43128": {"epss_score": 0.00236, "epss_percentile": 0.46377}, "CVE-2024-43129": {"epss_score": 0.01235, "epss_percentile": 0.78766}, "CVE-2024-43130": {"epss_score": 0.00176, "epss_percentile": 0.39376}, "CVE-2024-43131": {"epss_score": 0.00555, "epss_percentile": 0.67496}, "CVE-2024-43132": {"epss_score": 0.00639, "epss_percentile": 0.69944}, "CVE-2024-43133": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-43134": {"epss_score": 0.00145, "epss_percentile": 0.35526}, "CVE-2024-43135": {"epss_score": 0.01662, "epss_percentile": 0.81633}, "CVE-2024-43136": {"epss_score": 0.00371, "epss_percentile": 0.58362}, "CVE-2024-43137": {"epss_score": 0.00161, "epss_percentile": 0.37525}, "CVE-2024-43138": {"epss_score": 0.00673, "epss_percentile": 0.70838}, "CVE-2024-43139": {"epss_score": 0.00252, "epss_percentile": 0.48389}, "CVE-2024-43140": {"epss_score": 0.00908, "epss_percentile": 0.75286}, "CVE-2024-43141": {"epss_score": 0.00627, "epss_percentile": 0.69627}, "CVE-2024-43142": {"epss_score": 0.00249, "epss_percentile": 0.48058}, "CVE-2024-43143": {"epss_score": 0.00105, "epss_percentile": 0.29316}, "CVE-2024-43144": {"epss_score": 0.00587, "epss_percentile": 0.68481}, "CVE-2024-43145": {"epss_score": 0.00518, "epss_percentile": 0.6613}, "CVE-2024-43146": {"epss_score": 0.00085, "epss_percentile": 0.25223}, "CVE-2024-43147": {"epss_score": 0.00252, "epss_percentile": 0.48389}, "CVE-2024-43148": {"epss_score": 0.00169, "epss_percentile": 0.38548}, "CVE-2024-43149": {"epss_score": 0.00252, "epss_percentile": 0.48389}, "CVE-2024-43150": {"epss_score": 0.00231, "epss_percentile": 0.45806}, "CVE-2024-43151": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-43152": {"epss_score": 0.00158, "epss_percentile": 0.37157}, "CVE-2024-43153": {"epss_score": 0.00308, "epss_percentile": 0.53606}, "CVE-2024-43154": {"epss_score": 0.00187, "epss_percentile": 0.4072}, "CVE-2024-43155": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2024-43156": {"epss_score": 0.00247, "epss_percentile": 0.47904}, "CVE-2024-43157": {"epss_score": 0.00187, "epss_percentile": 0.4072}, "CVE-2024-43158": {"epss_score": 0.00759, "epss_percentile": 0.72792}, "CVE-2024-43159": {"epss_score": 0.00234, "epss_percentile": 0.46106}, "CVE-2024-43160": {"epss_score": 0.83713, "epss_percentile": 0.9926}, "CVE-2024-43161": {"epss_score": 0.00191, "epss_percentile": 0.41194}, "CVE-2024-43162": {"epss_score": 0.00315, "epss_percentile": 0.54185}, "CVE-2024-43163": {"epss_score": 0.00181, "epss_percentile": 0.4005}, "CVE-2024-43164": {"epss_score": 0.00251, "epss_percentile": 0.48299}, "CVE-2024-43165": {"epss_score": 0.00656, "epss_percentile": 0.70437}, "CVE-2024-43166": {"epss_score": 0.00119, "epss_percentile": 0.31627}, "CVE-2024-43167": {"epss_score": 0.00026, "epss_percentile": 0.06456}, "CVE-2024-43168": {"epss_score": 0.00093, "epss_percentile": 0.2662}, "CVE-2024-43169": {"epss_score": 0.00033, "epss_percentile": 0.0918}, "CVE-2024-43173": {"epss_score": 0.00092, "epss_percentile": 0.2659}, "CVE-2024-43176": {"epss_score": 0.00073, "epss_percentile": 0.2264}, "CVE-2024-43177": {"epss_score": 0.00073, "epss_percentile": 0.22487}, "CVE-2024-43180": {"epss_score": 0.00049, "epss_percentile": 0.1534}, "CVE-2024-43184": {"epss_score": 0.00153, "epss_percentile": 0.36629}, "CVE-2024-43186": {"epss_score": 0.00038, "epss_percentile": 0.11324}, "CVE-2024-43187": {"epss_score": 0.00057, "epss_percentile": 0.18091}, "CVE-2024-43188": {"epss_score": 0.00085, "epss_percentile": 0.25173}, "CVE-2024-43189": {"epss_score": 0.00048, "epss_percentile": 0.15187}, "CVE-2024-43190": {"epss_score": 0.00029, "epss_percentile": 0.07865}, "CVE-2024-43191": {"epss_score": 0.00168, "epss_percentile": 0.38458}, "CVE-2024-43192": {"epss_score": 0.0002, "epss_percentile": 0.04661}, "CVE-2024-43196": {"epss_score": 0.00079, "epss_percentile": 0.23838}, "CVE-2024-43199": {"epss_score": 0.00353, "epss_percentile": 0.57177}, "CVE-2024-43201": {"epss_score": 0.00094, "epss_percentile": 0.27002}, "CVE-2024-43202": {"epss_score": 0.03817, "epss_percentile": 0.8777}, "CVE-2024-43204": {"epss_score": 0.00243, "epss_percentile": 0.4747}, "CVE-2024-43207": {"epss_score": 0.00505, "epss_percentile": 0.65585}, "CVE-2024-43208": {"epss_score": 0.00187, "epss_percentile": 0.4072}, "CVE-2024-43209": {"epss_score": 0.00122, "epss_percentile": 0.32172}, "CVE-2024-43210": {"epss_score": 0.00274, "epss_percentile": 0.50576}, "CVE-2024-43211": {"epss_score": 0.00183, "epss_percentile": 0.4032}, "CVE-2024-43212": {"epss_score": 0.00231, "epss_percentile": 0.4582}, "CVE-2024-43213": {"epss_score": 0.00612, "epss_percentile": 0.69214}, "CVE-2024-43214": {"epss_score": 0.00178, "epss_percentile": 0.39723}, "CVE-2024-43215": {"epss_score": 0.00187, "epss_percentile": 0.4072}, "CVE-2024-43216": {"epss_score": 0.00251, "epss_percentile": 0.48299}, "CVE-2024-43217": {"epss_score": 0.00451, "epss_percentile": 0.63122}, "CVE-2024-43218": {"epss_score": 0.00251, "epss_percentile": 0.48299}, "CVE-2024-43219": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-43220": {"epss_score": 0.00442, "epss_percentile": 0.62754}, "CVE-2024-43221": {"epss_score": 0.00702, "epss_percentile": 0.71515}, "CVE-2024-43222": {"epss_score": 0.00385, "epss_percentile": 0.59196}, "CVE-2024-43223": {"epss_score": 0.00289, "epss_percentile": 0.52043}, "CVE-2024-43224": {"epss_score": 0.00251, "epss_percentile": 0.48299}, "CVE-2024-43225": {"epss_score": 0.0023, "epss_percentile": 0.4569}, "CVE-2024-43226": {"epss_score": 0.00251, "epss_percentile": 0.48299}, "CVE-2024-43227": {"epss_score": 0.00251, "epss_percentile": 0.48299}, "CVE-2024-43229": {"epss_score": 0.00145, "epss_percentile": 0.35526}, "CVE-2024-43230": {"epss_score": 0.00382, "epss_percentile": 0.59074}, "CVE-2024-43231": {"epss_score": 0.00251, "epss_percentile": 0.48317}, "CVE-2024-43232": {"epss_score": 0.00767, "epss_percentile": 0.72951}, "CVE-2024-43233": {"epss_score": 0.00612, "epss_percentile": 0.69214}, "CVE-2024-43234": {"epss_score": 0.00369, "epss_percentile": 0.58271}, "CVE-2024-43235": {"epss_score": 0.00261, "epss_percentile": 0.49324}, "CVE-2024-43236": {"epss_score": 0.00242, "epss_percentile": 0.47397}, "CVE-2024-43237": {"epss_score": 0.00311, "epss_percentile": 0.53811}, "CVE-2024-43238": {"epss_score": 0.00213, "epss_percentile": 0.43888}, "CVE-2024-43239": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2024-43240": {"epss_score": 0.00208, "epss_percentile": 0.43281}, "CVE-2024-43241": {"epss_score": 0.0017, "epss_percentile": 0.38739}, "CVE-2024-43242": {"epss_score": 0.00559, "epss_percentile": 0.67605}, "CVE-2024-43243": {"epss_score": 0.00459, "epss_percentile": 0.63472}, "CVE-2024-43244": {"epss_score": 0.0017, "epss_percentile": 0.38739}, "CVE-2024-43245": {"epss_score": 0.00354, "epss_percentile": 0.57208}, "CVE-2024-43246": {"epss_score": 0.00156, "epss_percentile": 0.36909}, "CVE-2024-43247": {"epss_score": 0.00409, "epss_percentile": 0.60727}, "CVE-2024-43248": {"epss_score": 0.00249, "epss_percentile": 0.48072}, "CVE-2024-43249": {"epss_score": 0.01879, "epss_percentile": 0.82673}, "CVE-2024-43250": {"epss_score": 0.00126, "epss_percentile": 0.32664}, "CVE-2024-43251": {"epss_score": 0.00375, "epss_percentile": 0.58593}, "CVE-2024-43252": {"epss_score": 0.00664, "epss_percentile": 0.70634}, "CVE-2024-43253": {"epss_score": 0.00459, "epss_percentile": 0.63458}, "CVE-2024-43254": {"epss_score": 0.00357, "epss_percentile": 0.57438}, "CVE-2024-43255": {"epss_score": 0.0009, "epss_percentile": 0.26059}, "CVE-2024-43256": {"epss_score": 0.0023, "epss_percentile": 0.45742}, "CVE-2024-43257": {"epss_score": 0.00375, "epss_percentile": 0.58593}, "CVE-2024-43258": {"epss_score": 0.00382, "epss_percentile": 0.59074}, "CVE-2024-43259": {"epss_score": 0.00382, "epss_percentile": 0.59074}, "CVE-2024-43260": {"epss_score": 0.00171, "epss_percentile": 0.38869}, "CVE-2024-43261": {"epss_score": 0.01838, "epss_percentile": 0.82485}, "CVE-2024-43262": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43263": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43264": {"epss_score": 0.00382, "epss_percentile": 0.59074}, "CVE-2024-43265": {"epss_score": 0.00115, "epss_percentile": 0.3093}, "CVE-2024-43266": {"epss_score": 0.0005, "epss_percentile": 0.15825}, "CVE-2024-43267": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43268": {"epss_score": 0.00171, "epss_percentile": 0.38869}, "CVE-2024-43269": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-43270": {"epss_score": 0.00201, "epss_percentile": 0.42335}, "CVE-2024-43271": {"epss_score": 0.0118, "epss_percentile": 0.78297}, "CVE-2024-43272": {"epss_score": 0.00245, "epss_percentile": 0.47707}, "CVE-2024-43273": {"epss_score": 0.00136, "epss_percentile": 0.341}, "CVE-2024-43274": {"epss_score": 0.00243, "epss_percentile": 0.47416}, "CVE-2024-43275": {"epss_score": 0.00222, "epss_percentile": 0.44745}, "CVE-2024-43276": {"epss_score": 0.00213, "epss_percentile": 0.43888}, "CVE-2024-43277": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-43278": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43279": {"epss_score": 0.0028, "epss_percentile": 0.51069}, "CVE-2024-43280": {"epss_score": 0.00178, "epss_percentile": 0.39723}, "CVE-2024-43281": {"epss_score": 0.01023, "epss_percentile": 0.76767}, "CVE-2024-43282": {"epss_score": 0.0038, "epss_percentile": 0.58943}, "CVE-2024-43283": {"epss_score": 0.00382, "epss_percentile": 0.59074}, "CVE-2024-43284": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43285": {"epss_score": 0.0009, "epss_percentile": 0.26032}, "CVE-2024-43286": {"epss_score": 0.00085, "epss_percentile": 0.25122}, "CVE-2024-43287": {"epss_score": 0.0013, "epss_percentile": 0.3326}, "CVE-2024-43288": {"epss_score": 0.00092, "epss_percentile": 0.26435}, "CVE-2024-43289": {"epss_score": 0.0072, "epss_percentile": 0.71954}, "CVE-2024-43290": {"epss_score": 0.00172, "epss_percentile": 0.39033}, "CVE-2024-43291": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-43292": {"epss_score": 0.00093, "epss_percentile": 0.26758}, "CVE-2024-43293": {"epss_score": 0.00289, "epss_percentile": 0.52043}, "CVE-2024-43294": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43295": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-43296": {"epss_score": 0.00289, "epss_percentile": 0.52043}, "CVE-2024-43297": {"epss_score": 0.00262, "epss_percentile": 0.49344}, "CVE-2024-43298": {"epss_score": 0.00262, "epss_percentile": 0.49344}, "CVE-2024-43299": {"epss_score": 0.00089, "epss_percentile": 0.25831}, "CVE-2024-43300": {"epss_score": 0.00078, "epss_percentile": 0.2377}, "CVE-2024-43301": {"epss_score": 0.00082, "epss_percentile": 0.24539}, "CVE-2024-43302": {"epss_score": 0.00249, "epss_percentile": 0.48058}, "CVE-2024-43303": {"epss_score": 0.00217, "epss_percentile": 0.4428}, "CVE-2024-43304": {"epss_score": 0.00213, "epss_percentile": 0.43888}, "CVE-2024-43305": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43306": {"epss_score": 0.00217, "epss_percentile": 0.4428}, "CVE-2024-43307": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43308": {"epss_score": 0.00155, "epss_percentile": 0.36841}, "CVE-2024-43309": {"epss_score": 0.00155, "epss_percentile": 0.36841}, "CVE-2024-43310": {"epss_score": 0.00389, "epss_percentile": 0.59473}, "CVE-2024-43311": {"epss_score": 0.00215, "epss_percentile": 0.44084}, "CVE-2024-43312": {"epss_score": 0.00273, "epss_percentile": 0.50446}, "CVE-2024-43313": {"epss_score": 0.00232, "epss_percentile": 0.45888}, "CVE-2024-43314": {"epss_score": 0.00249, "epss_percentile": 0.48058}, "CVE-2024-43315": {"epss_score": 0.00332, "epss_percentile": 0.55566}, "CVE-2024-43316": {"epss_score": 0.00086, "epss_percentile": 0.25321}, "CVE-2024-43317": {"epss_score": 0.0016, "epss_percentile": 0.37503}, "CVE-2024-43318": {"epss_score": 0.0017, "epss_percentile": 0.38688}, "CVE-2024-43319": {"epss_score": 0.00188, "epss_percentile": 0.40873}, "CVE-2024-43320": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43321": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43322": {"epss_score": 0.00053, "epss_percentile": 0.16722}, "CVE-2024-43323": {"epss_score": 0.00343, "epss_percentile": 0.56421}, "CVE-2024-43324": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-43325": {"epss_score": 0.0013, "epss_percentile": 0.3326}, "CVE-2024-43326": {"epss_score": 0.00081, "epss_percentile": 0.24341}, "CVE-2024-43327": {"epss_score": 0.00275, "epss_percentile": 0.5066}, "CVE-2024-43328": {"epss_score": 0.01181, "epss_percentile": 0.7831}, "CVE-2024-43329": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-43330": {"epss_score": 0.00153, "epss_percentile": 0.36562}, "CVE-2024-43331": {"epss_score": 0.00544, "epss_percentile": 0.6714}, "CVE-2024-43332": {"epss_score": 0.00283, "epss_percentile": 0.51413}, "CVE-2024-43333": {"epss_score": 0.00122, "epss_percentile": 0.32099}, "CVE-2024-43334": {"epss_score": 0.00024, "epss_percentile": 0.05979}, "CVE-2024-43335": {"epss_score": 0.00155, "epss_percentile": 0.36841}, "CVE-2024-43336": {"epss_score": 0.00134, "epss_percentile": 0.338}, "CVE-2024-43337": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-43338": {"epss_score": 0.00159, "epss_percentile": 0.37359}, "CVE-2024-43339": {"epss_score": 0.00083, "epss_percentile": 0.24724}, "CVE-2024-43340": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-43341": {"epss_score": 0.00247, "epss_percentile": 0.47889}, "CVE-2024-43342": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-43343": {"epss_score": 0.00289, "epss_percentile": 0.52043}, "CVE-2024-43344": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43345": {"epss_score": 0.00705, "epss_percentile": 0.71586}, "CVE-2024-43346": {"epss_score": 0.00143, "epss_percentile": 0.35142}, "CVE-2024-43347": {"epss_score": 0.00108, "epss_percentile": 0.29898}, "CVE-2024-43348": {"epss_score": 0.00217, "epss_percentile": 0.4428}, "CVE-2024-43349": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43350": {"epss_score": 0.00104, "epss_percentile": 0.29147}, "CVE-2024-43351": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43352": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43353": {"epss_score": 0.00156, "epss_percentile": 0.3693}, "CVE-2024-43354": {"epss_score": 0.00559, "epss_percentile": 0.67605}, "CVE-2024-43355": {"epss_score": 0.00289, "epss_percentile": 0.52043}, "CVE-2024-43356": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-43357": {"epss_score": 0.00822, "epss_percentile": 0.73914}, "CVE-2024-43358": {"epss_score": 0.00977, "epss_percentile": 0.76231}, "CVE-2024-43359": {"epss_score": 0.00193, "epss_percentile": 0.4138}, "CVE-2024-43360": {"epss_score": 0.62094, "epss_percentile": 0.98277}, "CVE-2024-43362": {"epss_score": 0.04159, "epss_percentile": 0.88332}, "CVE-2024-43363": {"epss_score": 0.73099, "epss_percentile": 0.98736}, "CVE-2024-43364": {"epss_score": 0.03529, "epss_percentile": 0.87299}, "CVE-2024-43365": {"epss_score": 0.03529, "epss_percentile": 0.87299}, "CVE-2024-43366": {"epss_score": 0.00194, "epss_percentile": 0.41588}, "CVE-2024-43367": {"epss_score": 0.00222, "epss_percentile": 0.44806}, "CVE-2024-43368": {"epss_score": 0.00392, "epss_percentile": 0.59652}, "CVE-2024-43369": {"epss_score": 0.00177, "epss_percentile": 0.39548}, "CVE-2024-43370": {"epss_score": 0.00268, "epss_percentile": 0.50079}, "CVE-2024-43371": {"epss_score": 0.00233, "epss_percentile": 0.46037}, "CVE-2024-43373": {"epss_score": 0.00209, "epss_percentile": 0.43402}, "CVE-2024-43374": {"epss_score": 0.00095, "epss_percentile": 0.27227}, "CVE-2024-43376": {"epss_score": 0.00364, "epss_percentile": 0.57926}, "CVE-2024-43377": {"epss_score": 0.00306, "epss_percentile": 0.53408}, "CVE-2024-43378": {"epss_score": 0.0008, "epss_percentile": 0.24199}, "CVE-2024-43379": {"epss_score": 0.00304, "epss_percentile": 0.53246}, "CVE-2024-43380": {"epss_score": 0.00183, "epss_percentile": 0.40315}, "CVE-2024-43381": {"epss_score": 0.00694, "epss_percentile": 0.71358}, "CVE-2024-43382": {"epss_score": 0.00213, "epss_percentile": 0.43945}, "CVE-2024-43383": {"epss_score": 0.0354, "epss_percentile": 0.87317}, "CVE-2024-43385": {"epss_score": 0.01823, "epss_percentile": 0.82417}, "CVE-2024-43386": {"epss_score": 0.01823, "epss_percentile": 0.82417}, "CVE-2024-43387": {"epss_score": 0.00529, "epss_percentile": 0.66605}, "CVE-2024-43388": {"epss_score": 0.00401, "epss_percentile": 0.60254}, "CVE-2024-43389": {"epss_score": 0.00504, "epss_percentile": 0.65485}, "CVE-2024-43390": {"epss_score": 0.00504, "epss_percentile": 0.65485}, "CVE-2024-43391": {"epss_score": 0.00891, "epss_percentile": 0.75055}, "CVE-2024-43392": {"epss_score": 0.00891, "epss_percentile": 0.75055}, "CVE-2024-43393": {"epss_score": 0.00891, "epss_percentile": 0.75055}, "CVE-2024-43394": {"epss_score": 0.00122, "epss_percentile": 0.32065}, "CVE-2024-43395": {"epss_score": 0.00035, "epss_percentile": 0.10144}, "CVE-2024-43396": {"epss_score": 0.00682, "epss_percentile": 0.71065}, "CVE-2024-43397": {"epss_score": 0.00098, "epss_percentile": 0.27805}, "CVE-2024-43398": {"epss_score": 0.01135, "epss_percentile": 0.77914}, "CVE-2024-43399": {"epss_score": 0.00413, "epss_percentile": 0.60957}, "CVE-2024-43400": {"epss_score": 0.05688, "epss_percentile": 0.9012}, "CVE-2024-43401": {"epss_score": 0.0146, "epss_percentile": 0.80414}, "CVE-2024-43402": {"epss_score": 0.00377, "epss_percentile": 0.587}, "CVE-2024-43403": {"epss_score": 0.00065, "epss_percentile": 0.20577}, "CVE-2024-43404": {"epss_score": 0.0324, "epss_percentile": 0.86727}, "CVE-2024-43405": {"epss_score": 0.04553, "epss_percentile": 0.88842}, "CVE-2024-43406": {"epss_score": 0.01433, "epss_percentile": 0.80257}, "CVE-2024-43407": {"epss_score": 0.01371, "epss_percentile": 0.79804}, "CVE-2024-43408": {"epss_score": 0.00136, "epss_percentile": 0.34154}, "CVE-2024-43409": {"epss_score": 0.00335, "epss_percentile": 0.55799}, "CVE-2024-43410": {"epss_score": 0.00582, "epss_percentile": 0.68311}, "CVE-2024-43411": {"epss_score": 0.00045, "epss_percentile": 0.13912}, "CVE-2024-43412": {"epss_score": 0.00614, "epss_percentile": 0.69274}, "CVE-2024-43413": {"epss_score": 0.00412, "epss_percentile": 0.60921}, "CVE-2024-43414": {"epss_score": 0.00187, "epss_percentile": 0.40794}, "CVE-2024-43415": {"epss_score": 0.00238, "epss_percentile": 0.46744}, "CVE-2024-43416": {"epss_score": 0.19538, "epss_percentile": 0.95202}, "CVE-2024-43417": {"epss_score": 0.0112, "epss_percentile": 0.77762}, "CVE-2024-43418": {"epss_score": 0.01352, "epss_percentile": 0.79683}, "CVE-2024-43420": {"epss_score": 0.00018, "epss_percentile": 0.04038}, "CVE-2024-43423": {"epss_score": 0.00096, "epss_percentile": 0.27378}, "CVE-2024-43424": {"epss_score": 0.00886, "epss_percentile": 0.74952}, "CVE-2024-43425": {"epss_score": 0.89792, "epss_percentile": 0.99542}, "CVE-2024-43426": {"epss_score": 0.00672, "epss_percentile": 0.70812}, "CVE-2024-43427": {"epss_score": 0.00356, "epss_percentile": 0.57388}, "CVE-2024-43428": {"epss_score": 0.00041, "epss_percentile": 0.12331}, "CVE-2024-43429": {"epss_score": 0.00166, "epss_percentile": 0.38271}, "CVE-2024-43430": {"epss_score": 0.00328, "epss_percentile": 0.55164}, "CVE-2024-43431": {"epss_score": 0.00226, "epss_percentile": 0.45306}, "CVE-2024-43432": {"epss_score": 0.00189, "epss_percentile": 0.40972}, "CVE-2024-43433": {"epss_score": 0.00328, "epss_percentile": 0.55164}, "CVE-2024-43434": {"epss_score": 0.00282, "epss_percentile": 0.51282}, "CVE-2024-43435": {"epss_score": 0.00405, "epss_percentile": 0.60459}, "CVE-2024-43436": {"epss_score": 0.00365, "epss_percentile": 0.57995}, "CVE-2024-43437": {"epss_score": 0.00868, "epss_percentile": 0.74664}, "CVE-2024-43438": {"epss_score": 0.00225, "epss_percentile": 0.45127}, "CVE-2024-43439": {"epss_score": 0.00953, "epss_percentile": 0.75888}, "CVE-2024-43440": {"epss_score": 0.00261, "epss_percentile": 0.49306}, "CVE-2024-43441": {"epss_score": 0.70462, "epss_percentile": 0.98633}, "CVE-2024-43442": {"epss_score": 0.00057, "epss_percentile": 0.18003}, "CVE-2024-43443": {"epss_score": 0.00106, "epss_percentile": 0.29508}, "CVE-2024-43444": {"epss_score": 0.00145, "epss_percentile": 0.35375}, "CVE-2024-43445": {"epss_score": 0.00083, "epss_percentile": 0.24745}, "CVE-2024-43446": {"epss_score": 0.00061, "epss_percentile": 0.19289}, "CVE-2024-43447": {"epss_score": 0.01529, "epss_percentile": 0.80876}, "CVE-2024-43449": {"epss_score": 0.00245, "epss_percentile": 0.4763}, "CVE-2024-43450": {"epss_score": 0.01196, "epss_percentile": 0.78439}, "CVE-2024-43451": {"epss_score": 0.90313, "epss_percentile": 0.99576}, "CVE-2024-43452": {"epss_score": 0.0482, "epss_percentile": 0.89177}, "CVE-2024-43453": {"epss_score": 0.03945, "epss_percentile": 0.87995}, "CVE-2024-43454": {"epss_score": 0.28478, "epss_percentile": 0.96361}, "CVE-2024-43455": {"epss_score": 0.06098, "epss_percentile": 0.90479}, "CVE-2024-43456": {"epss_score": 0.0035, "epss_percentile": 0.56937}, "CVE-2024-43457": {"epss_score": 0.03821, "epss_percentile": 0.87782}, "CVE-2024-43458": {"epss_score": 0.0276, "epss_percentile": 0.85598}, "CVE-2024-43459": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-43460": {"epss_score": 0.02538, "epss_percentile": 0.85041}, "CVE-2024-43461": {"epss_score": 0.15745, "epss_percentile": 0.94497}, "CVE-2024-43462": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-43463": {"epss_score": 0.01088, "epss_percentile": 0.77434}, "CVE-2024-43464": {"epss_score": 0.67072, "epss_percentile": 0.98493}, "CVE-2024-43465": {"epss_score": 0.00864, "epss_percentile": 0.74603}, "CVE-2024-43466": {"epss_score": 0.0219, "epss_percentile": 0.83931}, "CVE-2024-43467": {"epss_score": 0.00381, "epss_percentile": 0.58989}, "CVE-2024-43468": {"epss_score": 0.69379, "epss_percentile": 0.98585}, "CVE-2024-43469": {"epss_score": 0.00667, "epss_percentile": 0.70713}, "CVE-2024-43470": {"epss_score": 0.00841, "epss_percentile": 0.7422}, "CVE-2024-43472": {"epss_score": 0.00523, "epss_percentile": 0.66309}, "CVE-2024-43474": {"epss_score": 0.08352, "epss_percentile": 0.92005}, "CVE-2024-43475": {"epss_score": 0.10765, "epss_percentile": 0.93097}, "CVE-2024-43476": {"epss_score": 0.0059, "epss_percentile": 0.68568}, "CVE-2024-43477": {"epss_score": 0.07964, "epss_percentile": 0.91793}, "CVE-2024-43479": {"epss_score": 0.00681, "epss_percentile": 0.71044}, "CVE-2024-43480": {"epss_score": 0.00266, "epss_percentile": 0.49882}, "CVE-2024-43481": {"epss_score": 0.03877, "epss_percentile": 0.8789}, "CVE-2024-43482": {"epss_score": 0.04932, "epss_percentile": 0.89298}, "CVE-2024-43483": {"epss_score": 0.00738, "epss_percentile": 0.7234}, "CVE-2024-43484": {"epss_score": 0.0121, "epss_percentile": 0.7855}, "CVE-2024-43485": {"epss_score": 0.00738, "epss_percentile": 0.7234}, "CVE-2024-43487": {"epss_score": 0.05082, "epss_percentile": 0.89473}, "CVE-2024-43488": {"epss_score": 0.02383, "epss_percentile": 0.84571}, "CVE-2024-43489": {"epss_score": 0.00438, "epss_percentile": 0.6257}, "CVE-2024-43491": {"epss_score": 0.20136, "epss_percentile": 0.95291}, "CVE-2024-43492": {"epss_score": 0.00843, "epss_percentile": 0.74256}, "CVE-2024-43495": {"epss_score": 0.01824, "epss_percentile": 0.82423}, "CVE-2024-43496": {"epss_score": 0.00456, "epss_percentile": 0.63338}, "CVE-2024-43497": {"epss_score": 0.00649, "epss_percentile": 0.70233}, "CVE-2024-43498": {"epss_score": 0.01276, "epss_percentile": 0.79108}, "CVE-2024-43499": {"epss_score": 0.00768, "epss_percentile": 0.72966}, "CVE-2024-43500": {"epss_score": 0.00171, "epss_percentile": 0.38791}, "CVE-2024-43501": {"epss_score": 0.00677, "epss_percentile": 0.70952}, "CVE-2024-43502": {"epss_score": 0.08688, "epss_percentile": 0.92204}, "CVE-2024-43503": {"epss_score": 0.00723, "epss_percentile": 0.7201}, "CVE-2024-43504": {"epss_score": 0.12877, "epss_percentile": 0.9381}, "CVE-2024-43505": {"epss_score": 0.0097, "epss_percentile": 0.76118}, "CVE-2024-43506": {"epss_score": 0.09955, "epss_percentile": 0.92792}, "CVE-2024-43508": {"epss_score": 0.00228, "epss_percentile": 0.45502}, "CVE-2024-43509": {"epss_score": 0.00599, "epss_percentile": 0.68796}, "CVE-2024-43511": {"epss_score": 0.00199, "epss_percentile": 0.42188}, "CVE-2024-43512": {"epss_score": 0.03423, "epss_percentile": 0.87107}, "CVE-2024-43513": {"epss_score": 0.00329, "epss_percentile": 0.55302}, "CVE-2024-43514": {"epss_score": 0.00599, "epss_percentile": 0.68796}, "CVE-2024-43515": {"epss_score": 0.03216, "epss_percentile": 0.86662}, "CVE-2024-43516": {"epss_score": 0.00463, "epss_percentile": 0.63683}, "CVE-2024-43517": {"epss_score": 0.0772, "epss_percentile": 0.91643}, "CVE-2024-43518": {"epss_score": 0.06103, "epss_percentile": 0.90483}, "CVE-2024-43519": {"epss_score": 0.06792, "epss_percentile": 0.91029}, "CVE-2024-43520": {"epss_score": 0.00449, "epss_percentile": 0.63037}, "CVE-2024-43521": {"epss_score": 0.07902, "epss_percentile": 0.91755}, "CVE-2024-43522": {"epss_score": 0.00441, "epss_percentile": 0.62688}, "CVE-2024-43523": {"epss_score": 0.00431, "epss_percentile": 0.62039}, "CVE-2024-43524": {"epss_score": 0.00474, "epss_percentile": 0.6411}, "CVE-2024-43525": {"epss_score": 0.00431, "epss_percentile": 0.62039}, "CVE-2024-43526": {"epss_score": 0.00431, "epss_percentile": 0.62039}, "CVE-2024-43527": {"epss_score": 0.00599, "epss_percentile": 0.68796}, "CVE-2024-43528": {"epss_score": 0.00463, "epss_percentile": 0.63683}, "CVE-2024-43529": {"epss_score": 0.01279, "epss_percentile": 0.79135}, "CVE-2024-43530": {"epss_score": 0.00623, "epss_percentile": 0.69538}, "CVE-2024-43532": {"epss_score": 0.60497, "epss_percentile": 0.98209}, "CVE-2024-43533": {"epss_score": 0.03945, "epss_percentile": 0.87995}, "CVE-2024-43534": {"epss_score": 0.00579, "epss_percentile": 0.68212}, "CVE-2024-43535": {"epss_score": 0.00489, "epss_percentile": 0.6491}, "CVE-2024-43536": {"epss_score": 0.00326, "epss_percentile": 0.55047}, "CVE-2024-43537": {"epss_score": 0.00261, "epss_percentile": 0.49268}, "CVE-2024-43538": {"epss_score": 0.00255, "epss_percentile": 0.48731}, "CVE-2024-43540": {"epss_score": 0.00255, "epss_percentile": 0.48731}, "CVE-2024-43541": {"epss_score": 0.09955, "epss_percentile": 0.92792}, "CVE-2024-43542": {"epss_score": 0.00255, "epss_percentile": 0.48731}, "CVE-2024-43543": {"epss_score": 0.00326, "epss_percentile": 0.55047}, "CVE-2024-43544": {"epss_score": 0.09955, "epss_percentile": 0.92792}, "CVE-2024-43545": {"epss_score": 0.09955, "epss_percentile": 0.92792}, "CVE-2024-43546": {"epss_score": 0.00427, "epss_percentile": 0.6187}, "CVE-2024-43547": {"epss_score": 0.00181, "epss_percentile": 0.40094}, "CVE-2024-43549": {"epss_score": 0.03084, "epss_percentile": 0.8638}, "CVE-2024-43550": {"epss_score": 0.01346, "epss_percentile": 0.79646}, "CVE-2024-43551": {"epss_score": 0.00524, "epss_percentile": 0.66316}, "CVE-2024-43552": {"epss_score": 0.00991, "epss_percentile": 0.76389}, "CVE-2024-43553": {"epss_score": 0.00441, "epss_percentile": 0.62688}, "CVE-2024-43554": {"epss_score": 0.00243, "epss_percentile": 0.47498}, "CVE-2024-43555": {"epss_score": 0.00201, "epss_percentile": 0.42305}, "CVE-2024-43556": {"epss_score": 0.00599, "epss_percentile": 0.68796}, "CVE-2024-43557": {"epss_score": 0.00255, "epss_percentile": 0.48731}, "CVE-2024-43558": {"epss_score": 0.00255, "epss_percentile": 0.48731}, "CVE-2024-43559": {"epss_score": 0.00401, "epss_percentile": 0.60201}, "CVE-2024-43560": {"epss_score": 0.03722, "epss_percentile": 0.87624}, "CVE-2024-43561": {"epss_score": 0.00255, "epss_percentile": 0.48731}, "CVE-2024-43562": {"epss_score": 0.08546, "epss_percentile": 0.92117}, "CVE-2024-43563": {"epss_score": 0.00271, "epss_percentile": 0.50312}, "CVE-2024-43564": {"epss_score": 0.03084, "epss_percentile": 0.8638}, "CVE-2024-43565": {"epss_score": 0.08546, "epss_percentile": 0.92117}, "CVE-2024-43566": {"epss_score": 0.05679, "epss_percentile": 0.90115}, "CVE-2024-43567": {"epss_score": 0.06574, "epss_percentile": 0.90857}, "CVE-2024-43570": {"epss_score": 0.00204, "epss_percentile": 0.42666}, "CVE-2024-43571": {"epss_score": 0.00361, "epss_percentile": 0.57729}, "CVE-2024-43572": {"epss_score": 0.41427, "epss_percentile": 0.97273}, "CVE-2024-43573": {"epss_score": 0.18555, "epss_percentile": 0.95032}, "CVE-2024-43574": {"epss_score": 0.00832, "epss_percentile": 0.74057}, "CVE-2024-43575": {"epss_score": 0.06574, "epss_percentile": 0.90857}, "CVE-2024-43576": {"epss_score": 0.01179, "epss_percentile": 0.78293}, "CVE-2024-43577": {"epss_score": 0.00231, "epss_percentile": 0.45767}, "CVE-2024-43578": {"epss_score": 0.05324, "epss_percentile": 0.89732}, "CVE-2024-43579": {"epss_score": 0.05324, "epss_percentile": 0.89732}, "CVE-2024-43580": {"epss_score": 0.00298, "epss_percentile": 0.52828}, "CVE-2024-43581": {"epss_score": 0.03718, "epss_percentile": 0.87617}, "CVE-2024-43582": {"epss_score": 0.24861, "epss_percentile": 0.9596}, "CVE-2024-43583": {"epss_score": 0.05482, "epss_percentile": 0.8992}, "CVE-2024-43584": {"epss_score": 0.00581, "epss_percentile": 0.68264}, "CVE-2024-43585": {"epss_score": 0.00215, "epss_percentile": 0.44096}, "CVE-2024-43587": {"epss_score": 0.00942, "epss_percentile": 0.75764}, "CVE-2024-43589": {"epss_score": 0.03084, "epss_percentile": 0.8638}, "CVE-2024-43590": {"epss_score": 0.00634, "epss_percentile": 0.69792}, "CVE-2024-43591": {"epss_score": 0.00278, "epss_percentile": 0.50894}, "CVE-2024-43592": {"epss_score": 0.04743, "epss_percentile": 0.89083}, "CVE-2024-43593": {"epss_score": 0.04743, "epss_percentile": 0.89083}, "CVE-2024-43594": {"epss_score": 0.0034, "epss_percentile": 0.56263}, "CVE-2024-43595": {"epss_score": 0.00531, "epss_percentile": 0.66669}, "CVE-2024-43596": {"epss_score": 0.00997, "epss_percentile": 0.76459}, "CVE-2024-43598": {"epss_score": 0.01648, "epss_percentile": 0.81555}, "CVE-2024-43599": {"epss_score": 0.03945, "epss_percentile": 0.87995}, "CVE-2024-43600": {"epss_score": 0.00585, "epss_percentile": 0.684}, "CVE-2024-43601": {"epss_score": 0.00406, "epss_percentile": 0.60543}, "CVE-2024-43602": {"epss_score": 0.00527, "epss_percentile": 0.66441}, "CVE-2024-43603": {"epss_score": 0.00124, "epss_percentile": 0.32435}, "CVE-2024-43604": {"epss_score": 0.00693, "epss_percentile": 0.71323}, "CVE-2024-43607": {"epss_score": 0.03945, "epss_percentile": 0.87995}, "CVE-2024-43608": {"epss_score": 0.03945, "epss_percentile": 0.87995}, "CVE-2024-43609": {"epss_score": 0.10547, "epss_percentile": 0.93025}, "CVE-2024-43610": {"epss_score": 0.03687, "epss_percentile": 0.87571}, "CVE-2024-43611": {"epss_score": 0.04743, "epss_percentile": 0.89083}, "CVE-2024-43612": {"epss_score": 0.00287, "epss_percentile": 0.5181}, "CVE-2024-43613": {"epss_score": 0.00555, "epss_percentile": 0.67469}, "CVE-2024-43614": {"epss_score": 0.00363, "epss_percentile": 0.57848}, "CVE-2024-43615": {"epss_score": 0.06592, "epss_percentile": 0.90873}, "CVE-2024-43616": {"epss_score": 0.00915, "epss_percentile": 0.75409}, "CVE-2024-43620": {"epss_score": 0.02901, "epss_percentile": 0.85955}, "CVE-2024-43621": {"epss_score": 0.03209, "epss_percentile": 0.86646}, "CVE-2024-43622": {"epss_score": 0.02901, "epss_percentile": 0.85955}, "CVE-2024-43623": {"epss_score": 0.05243, "epss_percentile": 0.89654}, "CVE-2024-43624": {"epss_score": 0.03454, "epss_percentile": 0.87171}, "CVE-2024-43625": {"epss_score": 0.00379, "epss_percentile": 0.58881}, "CVE-2024-43626": {"epss_score": 0.00208, "epss_percentile": 0.43257}, "CVE-2024-43627": {"epss_score": 0.02901, "epss_percentile": 0.85955}, "CVE-2024-43628": {"epss_score": 0.03117, "epss_percentile": 0.86437}, "CVE-2024-43629": {"epss_score": 0.02612, "epss_percentile": 0.85239}, "CVE-2024-43630": {"epss_score": 0.03879, "epss_percentile": 0.87894}, "CVE-2024-43631": {"epss_score": 0.00133, "epss_percentile": 0.33696}, "CVE-2024-43633": {"epss_score": 0.00076, "epss_percentile": 0.23165}, "CVE-2024-43634": {"epss_score": 0.00245, "epss_percentile": 0.4763}, "CVE-2024-43635": {"epss_score": 0.03117, "epss_percentile": 0.86437}, "CVE-2024-43636": {"epss_score": 0.00328, "epss_percentile": 0.55159}, "CVE-2024-43637": {"epss_score": 0.00218, "epss_percentile": 0.4442}, "CVE-2024-43638": {"epss_score": 0.00245, "epss_percentile": 0.4763}, "CVE-2024-43639": {"epss_score": 0.02846, "epss_percentile": 0.85821}, "CVE-2024-43640": {"epss_score": 0.00328, "epss_percentile": 0.55159}, "CVE-2024-43641": {"epss_score": 0.0082, "epss_percentile": 0.73893}, "CVE-2024-43642": {"epss_score": 0.36108, "epss_percentile": 0.96956}, "CVE-2024-43643": {"epss_score": 0.00245, "epss_percentile": 0.4763}, "CVE-2024-43644": {"epss_score": 0.00253, "epss_percentile": 0.48482}, "CVE-2024-43645": {"epss_score": 0.00143, "epss_percentile": 0.35218}, "CVE-2024-43646": {"epss_score": 0.00133, "epss_percentile": 0.33696}, "CVE-2024-43647": {"epss_score": 0.00731, "epss_percentile": 0.72179}, "CVE-2024-43648": {"epss_score": 0.01783, "epss_percentile": 0.82248}, "CVE-2024-43649": {"epss_score": 0.01083, "epss_percentile": 0.77393}, "CVE-2024-43650": {"epss_score": 0.04664, "epss_percentile": 0.88978}, "CVE-2024-43651": {"epss_score": 0.04729, "epss_percentile": 0.89068}, "CVE-2024-43652": {"epss_score": 0.03743, "epss_percentile": 0.87659}, "CVE-2024-43653": {"epss_score": 0.0288, "epss_percentile": 0.85897}, "CVE-2024-43654": {"epss_score": 0.0288, "epss_percentile": 0.85897}, "CVE-2024-43655": {"epss_score": 0.02202, "epss_percentile": 0.83982}, "CVE-2024-43656": {"epss_score": 0.01754, "epss_percentile": 0.82119}, "CVE-2024-43657": {"epss_score": 0.01754, "epss_percentile": 0.82119}, "CVE-2024-43658": {"epss_score": 0.00433, "epss_percentile": 0.62223}, "CVE-2024-43659": {"epss_score": 0.00101, "epss_percentile": 0.28595}, "CVE-2024-43660": {"epss_score": 0.00184, "epss_percentile": 0.40423}, "CVE-2024-43661": {"epss_score": 0.002, "epss_percentile": 0.42225}, "CVE-2024-43662": {"epss_score": 0.00138, "epss_percentile": 0.34348}, "CVE-2024-43663": {"epss_score": 0.01421, "epss_percentile": 0.80174}, "CVE-2024-43683": {"epss_score": 0.00156, "epss_percentile": 0.37001}, "CVE-2024-43684": {"epss_score": 0.00161, "epss_percentile": 0.37558}, "CVE-2024-43685": {"epss_score": 0.00429, "epss_percentile": 0.62}, "CVE-2024-43686": {"epss_score": 0.12419, "epss_percentile": 0.93664}, "CVE-2024-43687": {"epss_score": 0.00888, "epss_percentile": 0.74999}, "CVE-2024-43688": {"epss_score": 0.00048, "epss_percentile": 0.15013}, "CVE-2024-43689": {"epss_score": 0.00685, "epss_percentile": 0.71133}, "CVE-2024-43690": {"epss_score": 0.02296, "epss_percentile": 0.84295}, "CVE-2024-43692": {"epss_score": 0.0011, "epss_percentile": 0.30214}, "CVE-2024-43693": {"epss_score": 0.01055, "epss_percentile": 0.77113}, "CVE-2024-43694": {"epss_score": 0.00109, "epss_percentile": 0.30063}, "CVE-2024-43696": {"epss_score": 0.00043, "epss_percentile": 0.13346}, "CVE-2024-43697": {"epss_score": 0.00044, "epss_percentile": 0.13471}, "CVE-2024-43698": {"epss_score": 0.00141, "epss_percentile": 0.34832}, "CVE-2024-43699": {"epss_score": 0.0038, "epss_percentile": 0.58945}, "CVE-2024-43700": {"epss_score": 0.00048, "epss_percentile": 0.14986}, "CVE-2024-43701": {"epss_score": 0.00038, "epss_percentile": 0.11165}, "CVE-2024-43702": {"epss_score": 0.00093, "epss_percentile": 0.26633}, "CVE-2024-43703": {"epss_score": 0.00122, "epss_percentile": 0.32141}, "CVE-2024-43704": {"epss_score": 0.00042, "epss_percentile": 0.12919}, "CVE-2024-43705": {"epss_score": 0.00033, "epss_percentile": 0.09326}, "CVE-2024-43706": {"epss_score": 0.00066, "epss_percentile": 0.20937}, "CVE-2024-43707": {"epss_score": 0.00162, "epss_percentile": 0.37645}, "CVE-2024-43708": {"epss_score": 0.00257, "epss_percentile": 0.48895}, "CVE-2024-43709": {"epss_score": 0.00518, "epss_percentile": 0.66105}, "CVE-2024-43710": {"epss_score": 0.00088, "epss_percentile": 0.25691}, "CVE-2024-43712": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43713": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43714": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43715": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43716": {"epss_score": 0.00141, "epss_percentile": 0.34814}, "CVE-2024-43717": {"epss_score": 0.00141, "epss_percentile": 0.34814}, "CVE-2024-43718": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43719": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43720": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43721": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43722": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43723": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43724": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43725": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43726": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43727": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43728": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43729": {"epss_score": 0.00149, "epss_percentile": 0.35967}, "CVE-2024-43730": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43731": {"epss_score": 0.00149, "epss_percentile": 0.35967}, "CVE-2024-43732": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43733": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43734": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43735": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43736": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43737": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43738": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43739": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43740": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43742": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43743": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43744": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43745": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43746": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43747": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43748": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43749": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43750": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43751": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43752": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-43754": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-43755": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2024-43756": {"epss_score": 0.00236, "epss_percentile": 0.46386}, "CVE-2024-43758": {"epss_score": 0.00214, "epss_percentile": 0.43995}, "CVE-2024-43759": {"epss_score": 0.00151, "epss_percentile": 0.36257}, "CVE-2024-43760": {"epss_score": 0.00203, "epss_percentile": 0.42494}, "CVE-2024-43762": {"epss_score": 0.00032, "epss_percentile": 0.09074}, "CVE-2024-43763": {"epss_score": 0.00032, "epss_percentile": 0.08768}, "CVE-2024-43764": {"epss_score": 0.00011, "epss_percentile": 0.01079}, "CVE-2024-43765": {"epss_score": 9e-05, "epss_percentile": 0.00701}, "CVE-2024-43767": {"epss_score": 0.00147, "epss_percentile": 0.35784}, "CVE-2024-43768": {"epss_score": 0.00057, "epss_percentile": 0.18213}, "CVE-2024-43769": {"epss_score": 0.00015, "epss_percentile": 0.02317}, "CVE-2024-43770": {"epss_score": 0.00015, "epss_percentile": 0.02467}, "CVE-2024-43771": {"epss_score": 0.00023, "epss_percentile": 0.05501}, "CVE-2024-43772": {"epss_score": 0.00337, "epss_percentile": 0.56012}, "CVE-2024-43773": {"epss_score": 0.00337, "epss_percentile": 0.56012}, "CVE-2024-43774": {"epss_score": 0.00337, "epss_percentile": 0.56031}, "CVE-2024-43775": {"epss_score": 0.00337, "epss_percentile": 0.56031}, "CVE-2024-43776": {"epss_score": 0.00337, "epss_percentile": 0.56031}, "CVE-2024-43778": {"epss_score": 0.03233, "epss_percentile": 0.867}, "CVE-2024-43779": {"epss_score": 0.00078, "epss_percentile": 0.23674}, "CVE-2024-43780": {"epss_score": 0.00213, "epss_percentile": 0.43846}, "CVE-2024-43781": {"epss_score": 0.00041, "epss_percentile": 0.12398}, "CVE-2024-43782": {"epss_score": 0.00466, "epss_percentile": 0.638}, "CVE-2024-43783": {"epss_score": 0.00625, "epss_percentile": 0.6958}, "CVE-2024-43784": {"epss_score": 0.00027, "epss_percentile": 0.07153}, "CVE-2024-43785": {"epss_score": 0.00024, "epss_percentile": 0.05807}, "CVE-2024-43787": {"epss_score": 0.0006, "epss_percentile": 0.19201}, "CVE-2024-43788": {"epss_score": 0.00973, "epss_percentile": 0.76145}, "CVE-2024-43789": {"epss_score": 0.00151, "epss_percentile": 0.36309}, "CVE-2024-43790": {"epss_score": 0.0006, "epss_percentile": 0.18987}, "CVE-2024-43791": {"epss_score": 0.00044, "epss_percentile": 0.13591}, "CVE-2024-43792": {"epss_score": 0.00335, "epss_percentile": 0.55863}, "CVE-2024-43793": {"epss_score": 0.00088, "epss_percentile": 0.25723}, "CVE-2024-43794": {"epss_score": 0.00097, "epss_percentile": 0.27551}, "CVE-2024-43795": {"epss_score": 0.0113, "epss_percentile": 0.77847}, "CVE-2024-43796": {"epss_score": 0.00088, "epss_percentile": 0.25713}, "CVE-2024-43797": {"epss_score": 0.00287, "epss_percentile": 0.51829}, "CVE-2024-43798": {"epss_score": 0.00032, "epss_percentile": 0.08986}, "CVE-2024-43799": {"epss_score": 0.00118, "epss_percentile": 0.31518}, "CVE-2024-43800": {"epss_score": 0.00678, "epss_percentile": 0.7099}, "CVE-2024-43801": {"epss_score": 0.00128, "epss_percentile": 0.32957}, "CVE-2024-43802": {"epss_score": 0.00057, "epss_percentile": 0.18131}, "CVE-2024-43803": {"epss_score": 0.00099, "epss_percentile": 0.28368}, "CVE-2024-43804": {"epss_score": 0.01634, "epss_percentile": 0.81464}, "CVE-2024-43805": {"epss_score": 0.00315, "epss_percentile": 0.54206}, "CVE-2024-43806": {"epss_score": 0.00083, "epss_percentile": 0.24734}, "CVE-2024-43807": {"epss_score": 0.24974, "epss_percentile": 0.95973}, "CVE-2024-43808": {"epss_score": 0.02041, "epss_percentile": 0.83371}, "CVE-2024-43809": {"epss_score": 0.00219, "epss_percentile": 0.44469}, "CVE-2024-43810": {"epss_score": 0.29203, "epss_percentile": 0.96425}, "CVE-2024-43812": {"epss_score": 0.00041, "epss_percentile": 0.1246}, "CVE-2024-43813": {"epss_score": 0.00215, "epss_percentile": 0.44119}, "CVE-2024-43814": {"epss_score": 0.00053, "epss_percentile": 0.16846}, "CVE-2024-43815": {"epss_score": 0.00017, "epss_percentile": 0.03483}, "CVE-2024-43816": {"epss_score": 8e-05, "epss_percentile": 0.00591}, "CVE-2024-43817": {"epss_score": 8e-05, "epss_percentile": 0.00503}, "CVE-2024-43818": {"epss_score": 0.00011, "epss_percentile": 0.00981}, "CVE-2024-43819": {"epss_score": 0.00011, "epss_percentile": 0.01048}, "CVE-2024-43820": {"epss_score": 9e-05, "epss_percentile": 0.006}, "CVE-2024-43821": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-43822": {"epss_score": 0.00035, "epss_percentile": 0.09977}, "CVE-2024-43823": {"epss_score": 0.00011, "epss_percentile": 0.00981}, "CVE-2024-43824": {"epss_score": 9e-05, "epss_percentile": 0.0072}, "CVE-2024-43825": {"epss_score": 0.00015, "epss_percentile": 0.0234}, "CVE-2024-43826": {"epss_score": 0.0001, "epss_percentile": 0.00834}, "CVE-2024-43827": {"epss_score": 0.00037, "epss_percentile": 0.10794}, "CVE-2024-43828": {"epss_score": 7e-05, "epss_percentile": 0.0034}, "CVE-2024-43829": {"epss_score": 0.00014, "epss_percentile": 0.01998}, "CVE-2024-43830": {"epss_score": 0.00012, "epss_percentile": 0.01325}, "CVE-2024-43831": {"epss_score": 0.00018, "epss_percentile": 0.03632}, "CVE-2024-43832": {"epss_score": 9e-05, "epss_percentile": 0.00699}, "CVE-2024-43833": {"epss_score": 0.00018, "epss_percentile": 0.03931}, "CVE-2024-43834": {"epss_score": 0.00014, "epss_percentile": 0.02083}, "CVE-2024-43835": {"epss_score": 0.0001, "epss_percentile": 0.00815}, "CVE-2024-43836": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-43837": {"epss_score": 0.00033, "epss_percentile": 0.0943}, "CVE-2024-43838": {"epss_score": 0.00048, "epss_percentile": 0.15001}, "CVE-2024-43839": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2024-43840": {"epss_score": 0.0003, "epss_percentile": 0.08203}, "CVE-2024-43841": {"epss_score": 0.0004, "epss_percentile": 0.11904}, "CVE-2024-43842": {"epss_score": 0.00023, "epss_percentile": 0.05516}, "CVE-2024-43843": {"epss_score": 0.00051, "epss_percentile": 0.1618}, "CVE-2024-43844": {"epss_score": 0.00031, "epss_percentile": 0.08477}, "CVE-2024-43845": {"epss_score": 0.00023, "epss_percentile": 0.05379}, "CVE-2024-43846": {"epss_score": 0.00026, "epss_percentile": 0.0648}, "CVE-2024-43847": {"epss_score": 0.00091, "epss_percentile": 0.26401}, "CVE-2024-43848": {"epss_score": 0.00048, "epss_percentile": 0.15001}, "CVE-2024-43849": {"epss_score": 0.00033, "epss_percentile": 0.09289}, "CVE-2024-43850": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-43851": {"epss_score": 0.00048, "epss_percentile": 0.15159}, "CVE-2024-43852": {"epss_score": 0.00026, "epss_percentile": 0.06482}, "CVE-2024-43853": {"epss_score": 0.00019, "epss_percentile": 0.04132}, "CVE-2024-43854": {"epss_score": 0.00023, "epss_percentile": 0.05429}, "CVE-2024-43855": {"epss_score": 0.00015, "epss_percentile": 0.02462}, "CVE-2024-43856": {"epss_score": 0.00032, "epss_percentile": 0.08821}, "CVE-2024-43857": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2024-43858": {"epss_score": 0.00022, "epss_percentile": 0.05218}, "CVE-2024-43859": {"epss_score": 0.00038, "epss_percentile": 0.11289}, "CVE-2024-43860": {"epss_score": 0.00029, "epss_percentile": 0.07949}, "CVE-2024-43861": {"epss_score": 0.00018, "epss_percentile": 0.03611}, "CVE-2024-43862": {"epss_score": 0.00037, "epss_percentile": 0.10817}, "CVE-2024-43863": {"epss_score": 0.00019, "epss_percentile": 0.04167}, "CVE-2024-43864": {"epss_score": 0.00016, "epss_percentile": 0.02886}, "CVE-2024-43865": {"epss_score": 0.00018, "epss_percentile": 0.03857}, "CVE-2024-43866": {"epss_score": 0.00015, "epss_percentile": 0.02441}, "CVE-2024-43867": {"epss_score": 0.00024, "epss_percentile": 0.05793}, "CVE-2024-43868": {"epss_score": 0.00021, "epss_percentile": 0.04874}, "CVE-2024-43869": {"epss_score": 0.00013, "epss_percentile": 0.01547}, "CVE-2024-43870": {"epss_score": 0.00013, "epss_percentile": 0.01547}, "CVE-2024-43871": {"epss_score": 0.00019, "epss_percentile": 0.0427}, "CVE-2024-43872": {"epss_score": 0.00013, "epss_percentile": 0.01608}, "CVE-2024-43873": {"epss_score": 0.00023, "epss_percentile": 0.05627}, "CVE-2024-43874": {"epss_score": 0.00048, "epss_percentile": 0.15001}, "CVE-2024-43875": {"epss_score": 0.00013, "epss_percentile": 0.01572}, "CVE-2024-43876": {"epss_score": 0.0002, "epss_percentile": 0.04534}, "CVE-2024-43877": {"epss_score": 0.00015, "epss_percentile": 0.02412}, "CVE-2024-43878": {"epss_score": 0.00078, "epss_percentile": 0.23619}, "CVE-2024-43879": {"epss_score": 0.00026, "epss_percentile": 0.06487}, "CVE-2024-43880": {"epss_score": 0.00018, "epss_percentile": 0.03611}, "CVE-2024-43881": {"epss_score": 0.00018, "epss_percentile": 0.03932}, "CVE-2024-43882": {"epss_score": 0.0002, "epss_percentile": 0.04618}, "CVE-2024-43883": {"epss_score": 0.00018, "epss_percentile": 0.0375}, "CVE-2024-43884": {"epss_score": 0.00019, "epss_percentile": 0.04212}, "CVE-2024-43886": {"epss_score": 9e-05, "epss_percentile": 0.00604}, "CVE-2024-43887": {"epss_score": 0.0001, "epss_percentile": 0.00916}, "CVE-2024-43888": {"epss_score": 0.00014, "epss_percentile": 0.0201}, "CVE-2024-43889": {"epss_score": 0.00012, "epss_percentile": 0.0133}, "CVE-2024-43890": {"epss_score": 0.00013, "epss_percentile": 0.01596}, "CVE-2024-43891": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-43892": {"epss_score": 9e-05, "epss_percentile": 0.00679}, "CVE-2024-43893": {"epss_score": 0.00012, "epss_percentile": 0.01269}, "CVE-2024-43894": {"epss_score": 0.00013, "epss_percentile": 0.01596}, "CVE-2024-43896": {"epss_score": 0.00017, "epss_percentile": 0.03266}, "CVE-2024-43897": {"epss_score": 0.00014, "epss_percentile": 0.02113}, "CVE-2024-43899": {"epss_score": 0.00015, "epss_percentile": 0.02596}, "CVE-2024-43900": {"epss_score": 0.00021, "epss_percentile": 0.04902}, "CVE-2024-43901": {"epss_score": 0.00015, "epss_percentile": 0.02596}, "CVE-2024-43902": {"epss_score": 0.00014, "epss_percentile": 0.01933}, "CVE-2024-43904": {"epss_score": 0.00015, "epss_percentile": 0.02127}, "CVE-2024-43905": {"epss_score": 0.00034, "epss_percentile": 0.09775}, "CVE-2024-43906": {"epss_score": 0.00018, "epss_percentile": 0.03596}, "CVE-2024-43907": {"epss_score": 0.0002, "epss_percentile": 0.04676}, "CVE-2024-43908": {"epss_score": 0.00022, "epss_percentile": 0.05058}, "CVE-2024-43909": {"epss_score": 0.00024, "epss_percentile": 0.05841}, "CVE-2024-43910": {"epss_score": 0.00024, "epss_percentile": 0.06025}, "CVE-2024-43911": {"epss_score": 0.00017, "epss_percentile": 0.03414}, "CVE-2024-43912": {"epss_score": 0.00026, "epss_percentile": 0.06552}, "CVE-2024-43913": {"epss_score": 0.00014, "epss_percentile": 0.01853}, "CVE-2024-43914": {"epss_score": 0.00022, "epss_percentile": 0.05058}, "CVE-2024-43915": {"epss_score": 0.00075, "epss_percentile": 0.23045}, "CVE-2024-43916": {"epss_score": 0.00117, "epss_percentile": 0.3123}, "CVE-2024-43917": {"epss_score": 0.88274, "epss_percentile": 0.99465}, "CVE-2024-43918": {"epss_score": 0.4238, "epss_percentile": 0.97329}, "CVE-2024-43919": {"epss_score": 0.85728, "epss_percentile": 0.99345}, "CVE-2024-43920": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-43921": {"epss_score": 0.00407, "epss_percentile": 0.6058}, "CVE-2024-43922": {"epss_score": 0.00477, "epss_percentile": 0.64336}, "CVE-2024-43923": {"epss_score": 0.00464, "epss_percentile": 0.63731}, "CVE-2024-43924": {"epss_score": 0.00266, "epss_percentile": 0.49869}, "CVE-2024-43925": {"epss_score": 0.00331, "epss_percentile": 0.55526}, "CVE-2024-43926": {"epss_score": 0.00407, "epss_percentile": 0.6058}, "CVE-2024-43927": {"epss_score": 0.0004, "epss_percentile": 0.1208}, "CVE-2024-43928": {"epss_score": 0.00321, "epss_percentile": 0.54734}, "CVE-2024-43929": {"epss_score": 0.00381, "epss_percentile": 0.58981}, "CVE-2024-43930": {"epss_score": 0.00186, "epss_percentile": 0.40635}, "CVE-2024-43931": {"epss_score": 0.0088, "epss_percentile": 0.74858}, "CVE-2024-43932": {"epss_score": 0.00347, "epss_percentile": 0.56784}, "CVE-2024-43933": {"epss_score": 0.00179, "epss_percentile": 0.39751}, "CVE-2024-43934": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-43935": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-43936": {"epss_score": 0.00231, "epss_percentile": 0.45806}, "CVE-2024-43937": {"epss_score": 0.00103, "epss_percentile": 0.29016}, "CVE-2024-43938": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-43939": {"epss_score": 0.00148, "epss_percentile": 0.35918}, "CVE-2024-43940": {"epss_score": 0.00148, "epss_percentile": 0.35918}, "CVE-2024-43941": {"epss_score": 0.00455, "epss_percentile": 0.6331}, "CVE-2024-43942": {"epss_score": 0.00456, "epss_percentile": 0.63319}, "CVE-2024-43943": {"epss_score": 0.00618, "epss_percentile": 0.69385}, "CVE-2024-43944": {"epss_score": 0.0044, "epss_percentile": 0.62618}, "CVE-2024-43945": {"epss_score": 0.00169, "epss_percentile": 0.38634}, "CVE-2024-43946": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-43947": {"epss_score": 0.00212, "epss_percentile": 0.43753}, "CVE-2024-43948": {"epss_score": 0.00407, "epss_percentile": 0.6058}, "CVE-2024-43949": {"epss_score": 0.00222, "epss_percentile": 0.44774}, "CVE-2024-43950": {"epss_score": 0.0026, "epss_percentile": 0.49183}, "CVE-2024-43951": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-43952": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-43953": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-43954": {"epss_score": 0.00187, "epss_percentile": 0.40697}, "CVE-2024-43955": {"epss_score": 0.01131, "epss_percentile": 0.77855}, "CVE-2024-43956": {"epss_score": 0.00324, "epss_percentile": 0.54926}, "CVE-2024-43957": {"epss_score": 0.01235, "epss_percentile": 0.78766}, "CVE-2024-43958": {"epss_score": 0.00247, "epss_percentile": 0.47904}, "CVE-2024-43959": {"epss_score": 0.00305, "epss_percentile": 0.53368}, "CVE-2024-43960": {"epss_score": 0.00158, "epss_percentile": 0.37157}, "CVE-2024-43961": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-43962": {"epss_score": 0.00209, "epss_percentile": 0.43329}, "CVE-2024-43963": {"epss_score": 0.00407, "epss_percentile": 0.6058}, "CVE-2024-43964": {"epss_score": 0.0023, "epss_percentile": 0.4569}, "CVE-2024-43965": {"epss_score": 0.0359, "epss_percentile": 0.87398}, "CVE-2024-43966": {"epss_score": 0.00201, "epss_percentile": 0.42323}, "CVE-2024-43967": {"epss_score": 0.00085, "epss_percentile": 0.25169}, "CVE-2024-43968": {"epss_score": 0.00289, "epss_percentile": 0.52043}, "CVE-2024-43969": {"epss_score": 0.00405, "epss_percentile": 0.60498}, "CVE-2024-43970": {"epss_score": 0.00182, "epss_percentile": 0.40227}, "CVE-2024-43971": {"epss_score": 0.06059, "epss_percentile": 0.90441}, "CVE-2024-43972": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2024-43973": {"epss_score": 0.00371, "epss_percentile": 0.58362}, "CVE-2024-43974": {"epss_score": 0.00247, "epss_percentile": 0.47889}, "CVE-2024-43975": {"epss_score": 0.00182, "epss_percentile": 0.40227}, "CVE-2024-43976": {"epss_score": 0.00385, "epss_percentile": 0.5923}, "CVE-2024-43977": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-43978": {"epss_score": 0.00497, "epss_percentile": 0.65203}, "CVE-2024-43979": {"epss_score": 0.00247, "epss_percentile": 0.47889}, "CVE-2024-43980": {"epss_score": 0.00213, "epss_percentile": 0.4389}, "CVE-2024-43981": {"epss_score": 0.00289, "epss_percentile": 0.52043}, "CVE-2024-43982": {"epss_score": 0.00629, "epss_percentile": 0.69683}, "CVE-2024-43983": {"epss_score": 0.00217, "epss_percentile": 0.44243}, "CVE-2024-43984": {"epss_score": 0.00364, "epss_percentile": 0.57938}, "CVE-2024-43985": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2024-43986": {"epss_score": 0.00158, "epss_percentile": 0.37157}, "CVE-2024-43987": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-43988": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-43989": {"epss_score": 0.00274, "epss_percentile": 0.50576}, "CVE-2024-43990": {"epss_score": 0.00311, "epss_percentile": 0.53811}, "CVE-2024-43991": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-43992": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-43993": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-43994": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-43995": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-43996": {"epss_score": 0.00156, "epss_percentile": 0.36919}, "CVE-2024-43997": {"epss_score": 0.00108, "epss_percentile": 0.29863}, "CVE-2024-43998": {"epss_score": 0.24336, "epss_percentile": 0.95907}, "CVE-2024-43999": {"epss_score": 0.00158, "epss_percentile": 0.37157}, "CVE-2024-44000": {"epss_score": 0.92779, "epss_percentile": 0.99747}, "CVE-2024-44001": {"epss_score": 0.00294, "epss_percentile": 0.52419}, "CVE-2024-44002": {"epss_score": 0.00407, "epss_percentile": 0.6058}, "CVE-2024-44003": {"epss_score": 0.00226, "epss_percentile": 0.45343}, "CVE-2024-44004": {"epss_score": 0.00223, "epss_percentile": 0.44868}, "CVE-2024-44005": {"epss_score": 0.00294, "epss_percentile": 0.52419}, "CVE-2024-44006": {"epss_score": 0.0037, "epss_percentile": 0.58314}, "CVE-2024-44007": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2024-44008": {"epss_score": 0.0028, "epss_percentile": 0.51006}, "CVE-2024-44009": {"epss_score": 0.00299, "epss_percentile": 0.52905}, "CVE-2024-44010": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-44011": {"epss_score": 0.00545, "epss_percentile": 0.67164}, "CVE-2024-44012": {"epss_score": 0.00545, "epss_percentile": 0.67164}, "CVE-2024-44013": {"epss_score": 0.0084, "epss_percentile": 0.74204}, "CVE-2024-44014": {"epss_score": 0.00461, "epss_percentile": 0.63565}, "CVE-2024-44015": {"epss_score": 0.00545, "epss_percentile": 0.67164}, "CVE-2024-44016": {"epss_score": 0.00499, "epss_percentile": 0.65252}, "CVE-2024-44017": {"epss_score": 0.00499, "epss_percentile": 0.65252}, "CVE-2024-44018": {"epss_score": 0.00545, "epss_percentile": 0.67164}, "CVE-2024-44019": {"epss_score": 0.00421, "epss_percentile": 0.61512}, "CVE-2024-44020": {"epss_score": 0.00306, "epss_percentile": 0.53406}, "CVE-2024-44021": {"epss_score": 0.00324, "epss_percentile": 0.54972}, "CVE-2024-44022": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-44023": {"epss_score": 0.00574, "epss_percentile": 0.68095}, "CVE-2024-44024": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-44025": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-44026": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-44027": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-44028": {"epss_score": 0.00084, "epss_percentile": 0.24875}, "CVE-2024-44029": {"epss_score": 0.00125, "epss_percentile": 0.32592}, "CVE-2024-44030": {"epss_score": 0.00538, "epss_percentile": 0.6694}, "CVE-2024-44031": {"epss_score": 0.00471, "epss_percentile": 0.64008}, "CVE-2024-44032": {"epss_score": 0.00146, "epss_percentile": 0.35618}, "CVE-2024-44033": {"epss_score": 0.00146, "epss_percentile": 0.35618}, "CVE-2024-44034": {"epss_score": 0.00499, "epss_percentile": 0.65252}, "CVE-2024-44035": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-44036": {"epss_score": 0.00087, "epss_percentile": 0.25595}, "CVE-2024-44037": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-44038": {"epss_score": 0.00586, "epss_percentile": 0.68441}, "CVE-2024-44039": {"epss_score": 0.00111, "epss_percentile": 0.30351}, "CVE-2024-44040": {"epss_score": 0.00087, "epss_percentile": 0.25595}, "CVE-2024-44041": {"epss_score": 0.00086, "epss_percentile": 0.25293}, "CVE-2024-44042": {"epss_score": 0.00109, "epss_percentile": 0.30007}, "CVE-2024-44043": {"epss_score": 0.00086, "epss_percentile": 0.25293}, "CVE-2024-44044": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2024-44045": {"epss_score": 0.00109, "epss_percentile": 0.30007}, "CVE-2024-44046": {"epss_score": 0.00086, "epss_percentile": 0.25293}, "CVE-2024-44047": {"epss_score": 0.0017, "epss_percentile": 0.38713}, "CVE-2024-44048": {"epss_score": 0.00578, "epss_percentile": 0.68202}, "CVE-2024-44049": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-44050": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-44051": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-44052": {"epss_score": 0.00356, "epss_percentile": 0.57329}, "CVE-2024-44053": {"epss_score": 0.00157, "epss_percentile": 0.37055}, "CVE-2024-44054": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-44055": {"epss_score": 0.00082, "epss_percentile": 0.24583}, "CVE-2024-44056": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-44057": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-44058": {"epss_score": 0.00114, "epss_percentile": 0.30847}, "CVE-2024-44059": {"epss_score": 0.00114, "epss_percentile": 0.30847}, "CVE-2024-44060": {"epss_score": 0.00122, "epss_percentile": 0.32147}, "CVE-2024-44061": {"epss_score": 0.00181, "epss_percentile": 0.40105}, "CVE-2024-44062": {"epss_score": 0.00115, "epss_percentile": 0.30936}, "CVE-2024-44063": {"epss_score": 0.00115, "epss_percentile": 0.30936}, "CVE-2024-44064": {"epss_score": 0.0017, "epss_percentile": 0.38648}, "CVE-2024-44065": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2024-44067": {"epss_score": 0.00046, "epss_percentile": 0.14191}, "CVE-2024-44068": {"epss_score": 0.00663, "epss_percentile": 0.70615}, "CVE-2024-44069": {"epss_score": 0.00111, "epss_percentile": 0.30247}, "CVE-2024-44070": {"epss_score": 0.00129, "epss_percentile": 0.33214}, "CVE-2024-44072": {"epss_score": 0.00145, "epss_percentile": 0.35442}, "CVE-2024-44073": {"epss_score": 0.00062, "epss_percentile": 0.1963}, "CVE-2024-44076": {"epss_score": 0.00547, "epss_percentile": 0.67254}, "CVE-2024-44080": {"epss_score": 0.00114, "epss_percentile": 0.30806}, "CVE-2024-44081": {"epss_score": 0.0024, "epss_percentile": 0.46965}, "CVE-2024-44082": {"epss_score": 0.00087, "epss_percentile": 0.25589}, "CVE-2024-44083": {"epss_score": 0.08778, "epss_percentile": 0.92251}, "CVE-2024-44085": {"epss_score": 0.00491, "epss_percentile": 0.64956}, "CVE-2024-44087": {"epss_score": 0.1712, "epss_percentile": 0.94779}, "CVE-2024-44088": {"epss_score": 0.00152, "epss_percentile": 0.36372}, "CVE-2024-44092": {"epss_score": 0.00029, "epss_percentile": 0.07779}, "CVE-2024-44093": {"epss_score": 0.00044, "epss_percentile": 0.13448}, "CVE-2024-44094": {"epss_score": 0.0002, "epss_percentile": 0.04676}, "CVE-2024-44095": {"epss_score": 0.00038, "epss_percentile": 0.11057}, "CVE-2024-44096": {"epss_score": 0.00024, "epss_percentile": 0.05745}, "CVE-2024-44097": {"epss_score": 0.00076, "epss_percentile": 0.23159}, "CVE-2024-44098": {"epss_score": 0.00018, "epss_percentile": 0.03869}, "CVE-2024-44099": {"epss_score": 5e-05, "epss_percentile": 0.00212}, "CVE-2024-44100": {"epss_score": 0.00096, "epss_percentile": 0.27255}, "CVE-2024-44101": {"epss_score": 0.0127, "epss_percentile": 0.79048}, "CVE-2024-44102": {"epss_score": 0.07714, "epss_percentile": 0.91639}, "CVE-2024-44103": {"epss_score": 0.00417, "epss_percentile": 0.61248}, "CVE-2024-44104": {"epss_score": 0.0042, "epss_percentile": 0.61455}, "CVE-2024-44105": {"epss_score": 0.00196, "epss_percentile": 0.41739}, "CVE-2024-44106": {"epss_score": 0.00566, "epss_percentile": 0.67829}, "CVE-2024-44107": {"epss_score": 0.00382, "epss_percentile": 0.59071}, "CVE-2024-44112": {"epss_score": 0.00094, "epss_percentile": 0.26994}, "CVE-2024-44113": {"epss_score": 0.00088, "epss_percentile": 0.25642}, "CVE-2024-44114": {"epss_score": 0.00063, "epss_percentile": 0.20001}, "CVE-2024-44115": {"epss_score": 0.00087, "epss_percentile": 0.25491}, "CVE-2024-44116": {"epss_score": 0.00087, "epss_percentile": 0.25491}, "CVE-2024-44117": {"epss_score": 0.00068, "epss_percentile": 0.21343}, "CVE-2024-44120": {"epss_score": 0.00447, "epss_percentile": 0.62985}, "CVE-2024-44121": {"epss_score": 0.00107, "epss_percentile": 0.29604}, "CVE-2024-44122": {"epss_score": 0.00031, "epss_percentile": 0.08714}, "CVE-2024-44123": {"epss_score": 0.00031, "epss_percentile": 0.08331}, "CVE-2024-44124": {"epss_score": 0.00013, "epss_percentile": 0.01587}, "CVE-2024-44125": {"epss_score": 0.00031, "epss_percentile": 0.08328}, "CVE-2024-44126": {"epss_score": 0.00022, "epss_percentile": 0.05187}, "CVE-2024-44127": {"epss_score": 0.001, "epss_percentile": 0.2849}, "CVE-2024-44128": {"epss_score": 0.00013, "epss_percentile": 0.01681}, "CVE-2024-44129": {"epss_score": 0.00032, "epss_percentile": 0.08789}, "CVE-2024-44130": {"epss_score": 0.0006, "epss_percentile": 0.18985}, "CVE-2024-44131": {"epss_score": 0.00092, "epss_percentile": 0.26424}, "CVE-2024-44132": {"epss_score": 0.0013, "epss_percentile": 0.33332}, "CVE-2024-44133": {"epss_score": 0.00038, "epss_percentile": 0.11233}, "CVE-2024-44134": {"epss_score": 0.00055, "epss_percentile": 0.17453}, "CVE-2024-44135": {"epss_score": 0.00019, "epss_percentile": 0.04393}, "CVE-2024-44136": {"epss_score": 0.00157, "epss_percentile": 0.37037}, "CVE-2024-44137": {"epss_score": 0.00041, "epss_percentile": 0.1226}, "CVE-2024-44139": {"epss_score": 0.00051, "epss_percentile": 0.16178}, "CVE-2024-44141": {"epss_score": 0.00195, "epss_percentile": 0.41673}, "CVE-2024-44142": {"epss_score": 0.00023, "epss_percentile": 0.05417}, "CVE-2024-44144": {"epss_score": 0.00019, "epss_percentile": 0.04419}, "CVE-2024-44145": {"epss_score": 0.00026, "epss_percentile": 0.06405}, "CVE-2024-44146": {"epss_score": 0.00193, "epss_percentile": 0.41428}, "CVE-2024-44147": {"epss_score": 0.00045, "epss_percentile": 0.13962}, "CVE-2024-44148": {"epss_score": 0.0012, "epss_percentile": 0.31806}, "CVE-2024-44149": {"epss_score": 0.0009, "epss_percentile": 0.25995}, "CVE-2024-44151": {"epss_score": 0.00039, "epss_percentile": 0.11624}, "CVE-2024-44152": {"epss_score": 0.00134, "epss_percentile": 0.33826}, "CVE-2024-44153": {"epss_score": 0.00023, "epss_percentile": 0.05465}, "CVE-2024-44154": {"epss_score": 0.00032, "epss_percentile": 0.08798}, "CVE-2024-44155": {"epss_score": 0.00141, "epss_percentile": 0.34862}, "CVE-2024-44156": {"epss_score": 0.00013, "epss_percentile": 0.0167}, "CVE-2024-44157": {"epss_score": 0.00076, "epss_percentile": 0.23174}, "CVE-2024-44158": {"epss_score": 0.00022, "epss_percentile": 0.05245}, "CVE-2024-44159": {"epss_score": 0.00016, "epss_percentile": 0.03042}, "CVE-2024-44160": {"epss_score": 0.00022, "epss_percentile": 0.05021}, "CVE-2024-44161": {"epss_score": 0.00017, "epss_percentile": 0.03112}, "CVE-2024-44162": {"epss_score": 0.00068, "epss_percentile": 0.2122}, "CVE-2024-44163": {"epss_score": 0.00017, "epss_percentile": 0.03404}, "CVE-2024-44164": {"epss_score": 0.00014, "epss_percentile": 0.02088}, "CVE-2024-44165": {"epss_score": 0.00357, "epss_percentile": 0.5748}, "CVE-2024-44166": {"epss_score": 0.00033, "epss_percentile": 0.09209}, "CVE-2024-44167": {"epss_score": 0.00173, "epss_percentile": 0.39053}, "CVE-2024-44168": {"epss_score": 0.00024, "epss_percentile": 0.0596}, "CVE-2024-44169": {"epss_score": 0.00084, "epss_percentile": 0.25}, "CVE-2024-44170": {"epss_score": 0.00033, "epss_percentile": 0.09209}, "CVE-2024-44171": {"epss_score": 0.00062, "epss_percentile": 0.19728}, "CVE-2024-44172": {"epss_score": 0.00047, "epss_percentile": 0.14898}, "CVE-2024-44174": {"epss_score": 0.00105, "epss_percentile": 0.29308}, "CVE-2024-44175": {"epss_score": 0.00153, "epss_percentile": 0.36526}, "CVE-2024-44176": {"epss_score": 0.00321, "epss_percentile": 0.54682}, "CVE-2024-44177": {"epss_score": 0.00033, "epss_percentile": 0.09209}, "CVE-2024-44178": {"epss_score": 0.00076, "epss_percentile": 0.23141}, "CVE-2024-44179": {"epss_score": 0.00102, "epss_percentile": 0.28826}, "CVE-2024-44180": {"epss_score": 0.00094, "epss_percentile": 0.27006}, "CVE-2024-44181": {"epss_score": 0.00033, "epss_percentile": 0.09209}, "CVE-2024-44182": {"epss_score": 0.00033, "epss_percentile": 0.09209}, "CVE-2024-44183": {"epss_score": 0.00039, "epss_percentile": 0.11765}, "CVE-2024-44184": {"epss_score": 0.00024, "epss_percentile": 0.05805}, "CVE-2024-44185": {"epss_score": 0.00038, "epss_percentile": 0.11315}, "CVE-2024-44186": {"epss_score": 0.00088, "epss_percentile": 0.25785}, "CVE-2024-44187": {"epss_score": 0.0048, "epss_percentile": 0.64467}, "CVE-2024-44188": {"epss_score": 0.00074, "epss_percentile": 0.22681}, "CVE-2024-44189": {"epss_score": 0.00264, "epss_percentile": 0.49702}, "CVE-2024-44190": {"epss_score": 0.0004, "epss_percentile": 0.11943}, "CVE-2024-44191": {"epss_score": 0.00038, "epss_percentile": 0.11315}, "CVE-2024-44192": {"epss_score": 0.00188, "epss_percentile": 0.40912}, "CVE-2024-44193": {"epss_score": 0.02798, "epss_percentile": 0.85689}, "CVE-2024-44194": {"epss_score": 0.00018, "epss_percentile": 0.03758}, "CVE-2024-44195": {"epss_score": 0.0021, "epss_percentile": 0.43439}, "CVE-2024-44196": {"epss_score": 0.00042, "epss_percentile": 0.12805}, "CVE-2024-44197": {"epss_score": 0.00031, "epss_percentile": 0.08331}, "CVE-2024-44198": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2024-44199": {"epss_score": 0.00041, "epss_percentile": 0.12364}, "CVE-2024-44200": {"epss_score": 0.00103, "epss_percentile": 0.29058}, "CVE-2024-44201": {"epss_score": 0.00075, "epss_percentile": 0.23041}, "CVE-2024-44202": {"epss_score": 0.00246, "epss_percentile": 0.47733}, "CVE-2024-44203": {"epss_score": 0.00157, "epss_percentile": 0.37025}, "CVE-2024-44204": {"epss_score": 0.01296, "epss_percentile": 0.79257}, "CVE-2024-44205": {"epss_score": 0.00058, "epss_percentile": 0.18581}, "CVE-2024-44206": {"epss_score": 0.00448, "epss_percentile": 0.63005}, "CVE-2024-44207": {"epss_score": 0.06546, "epss_percentile": 0.90839}, "CVE-2024-44208": {"epss_score": 0.00046, "epss_percentile": 0.14123}, "CVE-2024-44211": {"epss_score": 0.00088, "epss_percentile": 0.25764}, "CVE-2024-44212": {"epss_score": 0.00157, "epss_percentile": 0.37116}, "CVE-2024-44213": {"epss_score": 0.00098, "epss_percentile": 0.27696}, "CVE-2024-44215": {"epss_score": 0.00015, "epss_percentile": 0.02282}, "CVE-2024-44216": {"epss_score": 0.00053, "epss_percentile": 0.16996}, "CVE-2024-44217": {"epss_score": 0.00329, "epss_percentile": 0.55405}, "CVE-2024-44218": {"epss_score": 0.00017, "epss_percentile": 0.0333}, "CVE-2024-44220": {"epss_score": 0.00104, "epss_percentile": 0.2919}, "CVE-2024-44222": {"epss_score": 0.00036, "epss_percentile": 0.10546}, "CVE-2024-44223": {"epss_score": 0.00089, "epss_percentile": 0.25948}, "CVE-2024-44224": {"epss_score": 0.00041, "epss_percentile": 0.12359}, "CVE-2024-44225": {"epss_score": 0.00059, "epss_percentile": 0.18879}, "CVE-2024-44227": {"epss_score": 0.0018, "epss_percentile": 0.39893}, "CVE-2024-44228": {"epss_score": 0.00133, "epss_percentile": 0.33661}, "CVE-2024-44229": {"epss_score": 0.00162, "epss_percentile": 0.37737}, "CVE-2024-44231": {"epss_score": 0.00051, "epss_percentile": 0.16174}, "CVE-2024-44232": {"epss_score": 0.00143, "epss_percentile": 0.35178}, "CVE-2024-44233": {"epss_score": 0.00143, "epss_percentile": 0.35178}, "CVE-2024-44234": {"epss_score": 0.00143, "epss_percentile": 0.35178}, "CVE-2024-44235": {"epss_score": 0.00063, "epss_percentile": 0.19873}, "CVE-2024-44236": {"epss_score": 0.02475, "epss_percentile": 0.84857}, "CVE-2024-44237": {"epss_score": 0.00143, "epss_percentile": 0.35199}, "CVE-2024-44239": {"epss_score": 0.00015, "epss_percentile": 0.02593}, "CVE-2024-44240": {"epss_score": 0.001, "epss_percentile": 0.28445}, "CVE-2024-44241": {"epss_score": 0.00436, "epss_percentile": 0.62385}, "CVE-2024-44242": {"epss_score": 0.00436, "epss_percentile": 0.62385}, "CVE-2024-44243": {"epss_score": 0.00247, "epss_percentile": 0.47812}, "CVE-2024-44244": {"epss_score": 0.00335, "epss_percentile": 0.55855}, "CVE-2024-44245": {"epss_score": 0.00037, "epss_percentile": 0.10772}, "CVE-2024-44246": {"epss_score": 0.00223, "epss_percentile": 0.4496}, "CVE-2024-44247": {"epss_score": 0.0003, "epss_percentile": 0.08186}, "CVE-2024-44248": {"epss_score": 0.00276, "epss_percentile": 0.50746}, "CVE-2024-44251": {"epss_score": 0.00051, "epss_percentile": 0.16178}, "CVE-2024-44252": {"epss_score": 0.00018, "epss_percentile": 0.0354}, "CVE-2024-44253": {"epss_score": 0.00025, "epss_percentile": 0.06379}, "CVE-2024-44254": {"epss_score": 0.00021, "epss_percentile": 0.04906}, "CVE-2024-44255": {"epss_score": 0.00033, "epss_percentile": 0.0928}, "CVE-2024-44256": {"epss_score": 0.00062, "epss_percentile": 0.19552}, "CVE-2024-44257": {"epss_score": 0.00053, "epss_percentile": 0.16996}, "CVE-2024-44258": {"epss_score": 0.01677, "epss_percentile": 0.81716}, "CVE-2024-44259": {"epss_score": 0.00235, "epss_percentile": 0.46241}, "CVE-2024-44260": {"epss_score": 0.00043, "epss_percentile": 0.13269}, "CVE-2024-44261": {"epss_score": 0.00035, "epss_percentile": 0.09986}, "CVE-2024-44262": {"epss_score": 0.00089, "epss_percentile": 0.25912}, "CVE-2024-44263": {"epss_score": 0.00031, "epss_percentile": 0.08462}, "CVE-2024-44264": {"epss_score": 0.00058, "epss_percentile": 0.18465}, "CVE-2024-44265": {"epss_score": 0.00089, "epss_percentile": 0.25812}, "CVE-2024-44267": {"epss_score": 0.00051, "epss_percentile": 0.16116}, "CVE-2024-44269": {"epss_score": 0.00019, "epss_percentile": 0.04363}, "CVE-2024-44270": {"epss_score": 0.00157, "epss_percentile": 0.3714}, "CVE-2024-44271": {"epss_score": 0.00021, "epss_percentile": 0.0478}, "CVE-2024-44273": {"epss_score": 0.00028, "epss_percentile": 0.07288}, "CVE-2024-44274": {"epss_score": 0.00085, "epss_percentile": 0.25163}, "CVE-2024-44275": {"epss_score": 0.00072, "epss_percentile": 0.22411}, "CVE-2024-44276": {"epss_score": 0.00047, "epss_percentile": 0.14889}, "CVE-2024-44277": {"epss_score": 0.00035, "epss_percentile": 0.09849}, "CVE-2024-44278": {"epss_score": 0.00031, "epss_percentile": 0.0859}, "CVE-2024-44279": {"epss_score": 0.00125, "epss_percentile": 0.32575}, "CVE-2024-44280": {"epss_score": 0.00063, "epss_percentile": 0.19914}, "CVE-2024-44281": {"epss_score": 0.00047, "epss_percentile": 0.14801}, "CVE-2024-44282": {"epss_score": 0.00127, "epss_percentile": 0.32899}, "CVE-2024-44283": {"epss_score": 0.00163, "epss_percentile": 0.37833}, "CVE-2024-44284": {"epss_score": 0.00109, "epss_percentile": 0.29957}, "CVE-2024-44285": {"epss_score": 0.00722, "epss_percentile": 0.71996}, "CVE-2024-44287": {"epss_score": 0.0005, "epss_percentile": 0.15834}, "CVE-2024-44289": {"epss_score": 0.00164, "epss_percentile": 0.37881}, "CVE-2024-44290": {"epss_score": 0.00082, "epss_percentile": 0.24506}, "CVE-2024-44291": {"epss_score": 0.00047, "epss_percentile": 0.14844}, "CVE-2024-44292": {"epss_score": 0.00066, "epss_percentile": 0.20854}, "CVE-2024-44293": {"epss_score": 0.00059, "epss_percentile": 0.18853}, "CVE-2024-44294": {"epss_score": 0.00129, "epss_percentile": 0.33121}, "CVE-2024-44295": {"epss_score": 0.00063, "epss_percentile": 0.19914}, "CVE-2024-44296": {"epss_score": 0.00489, "epss_percentile": 0.64902}, "CVE-2024-44297": {"epss_score": 0.00396, "epss_percentile": 0.5989}, "CVE-2024-44298": {"epss_score": 0.00063, "epss_percentile": 0.19918}, "CVE-2024-44299": {"epss_score": 0.00382, "epss_percentile": 0.59068}, "CVE-2024-44300": {"epss_score": 0.00047, "epss_percentile": 0.14577}, "CVE-2024-44301": {"epss_score": 0.00055, "epss_percentile": 0.17564}, "CVE-2024-44302": {"epss_score": 0.00037, "epss_percentile": 0.10762}, "CVE-2024-44305": {"epss_score": 0.00026, "epss_percentile": 0.06452}, "CVE-2024-44306": {"epss_score": 0.00195, "epss_percentile": 0.41655}, "CVE-2024-44307": {"epss_score": 0.00195, "epss_percentile": 0.41655}, "CVE-2024-44308": {"epss_score": 0.00935, "epss_percentile": 0.75669}, "CVE-2024-44309": {"epss_score": 0.00591, "epss_percentile": 0.68599}, "CVE-2024-44313": {"epss_score": 0.01756, "epss_percentile": 0.82131}, "CVE-2024-44314": {"epss_score": 0.00075, "epss_percentile": 0.2299}, "CVE-2024-44331": {"epss_score": 0.00531, "epss_percentile": 0.66648}, "CVE-2024-44333": {"epss_score": 0.00828, "epss_percentile": 0.74001}, "CVE-2024-44334": {"epss_score": 0.0142, "epss_percentile": 0.80167}, "CVE-2024-44335": {"epss_score": 0.00828, "epss_percentile": 0.74001}, "CVE-2024-44336": {"epss_score": 0.00111, "epss_percentile": 0.30324}, "CVE-2024-44337": {"epss_score": 0.04042, "epss_percentile": 0.88167}, "CVE-2024-44340": {"epss_score": 0.00897, "epss_percentile": 0.75128}, "CVE-2024-44341": {"epss_score": 0.02934, "epss_percentile": 0.86021}, "CVE-2024-44342": {"epss_score": 0.00982, "epss_percentile": 0.76292}, "CVE-2024-44349": {"epss_score": 0.7164, "epss_percentile": 0.98675}, "CVE-2024-44373": {"epss_score": 0.00677, "epss_percentile": 0.70961}, "CVE-2024-44375": {"epss_score": 0.00211, "epss_percentile": 0.43712}, "CVE-2024-44381": {"epss_score": 0.01686, "epss_percentile": 0.81754}, "CVE-2024-44382": {"epss_score": 0.00469, "epss_percentile": 0.63919}, "CVE-2024-44383": {"epss_score": 0.00073, "epss_percentile": 0.22622}, "CVE-2024-44386": {"epss_score": 0.00108, "epss_percentile": 0.29842}, "CVE-2024-44387": {"epss_score": 0.00077, "epss_percentile": 0.234}, "CVE-2024-44390": {"epss_score": 0.00078, "epss_percentile": 0.23638}, "CVE-2024-44400": {"epss_score": 0.39883, "epss_percentile": 0.97185}, "CVE-2024-44401": {"epss_score": 0.01795, "epss_percentile": 0.82294}, "CVE-2024-44402": {"epss_score": 0.01795, "epss_percentile": 0.82294}, "CVE-2024-44408": {"epss_score": 0.00249, "epss_percentile": 0.48084}, "CVE-2024-44410": {"epss_score": 0.00914, "epss_percentile": 0.75389}, "CVE-2024-44411": {"epss_score": 0.00724, "epss_percentile": 0.72042}, "CVE-2024-44413": {"epss_score": 0.00618, "epss_percentile": 0.69367}, "CVE-2024-44414": {"epss_score": 0.01429, "epss_percentile": 0.80225}, "CVE-2024-44415": {"epss_score": 0.00193, "epss_percentile": 0.41386}, "CVE-2024-44430": {"epss_score": 0.00142, "epss_percentile": 0.35075}, "CVE-2024-44439": {"epss_score": 0.00939, "epss_percentile": 0.75726}, "CVE-2024-44449": {"epss_score": 0.00083, "epss_percentile": 0.24783}, "CVE-2024-44450": {"epss_score": 0.01522, "epss_percentile": 0.80833}, "CVE-2024-44459": {"epss_score": 0.00133, "epss_percentile": 0.33685}, "CVE-2024-44460": {"epss_score": 0.00132, "epss_percentile": 0.33532}, "CVE-2024-44466": {"epss_score": 0.38954, "epss_percentile": 0.9713}, "CVE-2024-44540": {"epss_score": 0.0006, "epss_percentile": 0.19107}, "CVE-2024-44541": {"epss_score": 0.02158, "epss_percentile": 0.83816}, "CVE-2024-44542": {"epss_score": 0.22759, "epss_percentile": 0.95678}, "CVE-2024-44546": {"epss_score": 0.00094, "epss_percentile": 0.26992}, "CVE-2024-44549": {"epss_score": 0.00083, "epss_percentile": 0.24713}, "CVE-2024-44550": {"epss_score": 0.00164, "epss_percentile": 0.37946}, "CVE-2024-44551": {"epss_score": 0.00164, "epss_percentile": 0.37946}, "CVE-2024-44552": {"epss_score": 0.00087, "epss_percentile": 0.25566}, "CVE-2024-44553": {"epss_score": 0.00164, "epss_percentile": 0.37946}, "CVE-2024-44555": {"epss_score": 0.00164, "epss_percentile": 0.37946}, "CVE-2024-44556": {"epss_score": 0.00083, "epss_percentile": 0.24713}, "CVE-2024-44557": {"epss_score": 0.00164, "epss_percentile": 0.37968}, "CVE-2024-44558": {"epss_score": 0.00164, "epss_percentile": 0.37946}, "CVE-2024-44563": {"epss_score": 0.00164, "epss_percentile": 0.37968}, "CVE-2024-44565": {"epss_score": 0.00164, "epss_percentile": 0.37968}, "CVE-2024-44570": {"epss_score": 0.00119, "epss_percentile": 0.31648}, "CVE-2024-44571": {"epss_score": 0.0008, "epss_percentile": 0.24059}, "CVE-2024-44572": {"epss_score": 0.00923, "epss_percentile": 0.75497}, "CVE-2024-44573": {"epss_score": 0.0013, "epss_percentile": 0.33242}, "CVE-2024-44574": {"epss_score": 0.00923, "epss_percentile": 0.75497}, "CVE-2024-44575": {"epss_score": 0.00101, "epss_percentile": 0.28661}, "CVE-2024-44577": {"epss_score": 0.01088, "epss_percentile": 0.7744}, "CVE-2024-44587": {"epss_score": 0.00076, "epss_percentile": 0.23125}, "CVE-2024-44589": {"epss_score": 0.00146, "epss_percentile": 0.35628}, "CVE-2024-44598": {"epss_score": 0.0007, "epss_percentile": 0.21953}, "CVE-2024-44599": {"epss_score": 0.00046, "epss_percentile": 0.14399}, "CVE-2024-44610": {"epss_score": 0.01261, "epss_percentile": 0.78977}, "CVE-2024-44623": {"epss_score": 0.32617, "epss_percentile": 0.96713}, "CVE-2024-44625": {"epss_score": 0.6597, "epss_percentile": 0.98445}, "CVE-2024-44630": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44632": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44633": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44635": {"epss_score": 0.00044, "epss_percentile": 0.13482}, "CVE-2024-44636": {"epss_score": 0.00045, "epss_percentile": 0.13825}, "CVE-2024-44639": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44640": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44641": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44644": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44647": {"epss_score": 0.00044, "epss_percentile": 0.13482}, "CVE-2024-44648": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44651": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44652": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44653": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44654": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44655": {"epss_score": 0.00044, "epss_percentile": 0.13482}, "CVE-2024-44657": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44658": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44659": {"epss_score": 0.00047, "epss_percentile": 0.14818}, "CVE-2024-44660": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44661": {"epss_score": 0.00044, "epss_percentile": 0.13482}, "CVE-2024-44662": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44663": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44664": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-44667": {"epss_score": 0.00198, "epss_percentile": 0.41989}, "CVE-2024-44674": {"epss_score": 0.00123, "epss_percentile": 0.32296}, "CVE-2024-44676": {"epss_score": 0.00669, "epss_percentile": 0.7075}, "CVE-2024-44677": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2024-44678": {"epss_score": 0.00411, "epss_percentile": 0.60888}, "CVE-2024-44682": {"epss_score": 0.00126, "epss_percentile": 0.32657}, "CVE-2024-44683": {"epss_score": 0.00129, "epss_percentile": 0.33095}, "CVE-2024-44684": {"epss_score": 0.00122, "epss_percentile": 0.32155}, "CVE-2024-44685": {"epss_score": 0.001, "epss_percentile": 0.28558}, "CVE-2024-44716": {"epss_score": 0.00286, "epss_percentile": 0.51724}, "CVE-2024-44717": {"epss_score": 0.00286, "epss_percentile": 0.51724}, "CVE-2024-44720": {"epss_score": 0.00435, "epss_percentile": 0.62327}, "CVE-2024-44721": {"epss_score": 0.00258, "epss_percentile": 0.48968}, "CVE-2024-44724": {"epss_score": 0.00091, "epss_percentile": 0.26288}, "CVE-2024-44725": {"epss_score": 0.00079, "epss_percentile": 0.23864}, "CVE-2024-44727": {"epss_score": 0.00253, "epss_percentile": 0.48417}, "CVE-2024-44728": {"epss_score": 0.00308, "epss_percentile": 0.536}, "CVE-2024-44729": {"epss_score": 0.00135, "epss_percentile": 0.34012}, "CVE-2024-44730": {"epss_score": 0.00069, "epss_percentile": 0.21447}, "CVE-2024-44731": {"epss_score": 0.00527, "epss_percentile": 0.66532}, "CVE-2024-44734": {"epss_score": 0.00255, "epss_percentile": 0.48733}, "CVE-2024-44739": {"epss_score": 0.00076, "epss_percentile": 0.23125}, "CVE-2024-44744": {"epss_score": 0.00199, "epss_percentile": 0.42184}, "CVE-2024-44754": {"epss_score": 0.00056, "epss_percentile": 0.17912}, "CVE-2024-44756": {"epss_score": 0.00138, "epss_percentile": 0.34439}, "CVE-2024-44757": {"epss_score": 0.00215, "epss_percentile": 0.44085}, "CVE-2024-44758": {"epss_score": 0.0037, "epss_percentile": 0.58334}, "CVE-2024-44759": {"epss_score": 0.00205, "epss_percentile": 0.42685}, "CVE-2024-44760": {"epss_score": 0.00115, "epss_percentile": 0.31035}, "CVE-2024-44761": {"epss_score": 0.00772, "epss_percentile": 0.73032}, "CVE-2024-44762": {"epss_score": 0.11579, "epss_percentile": 0.93409}, "CVE-2024-44765": {"epss_score": 0.0167, "epss_percentile": 0.81672}, "CVE-2024-44771": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2024-44775": {"epss_score": 0.00149, "epss_percentile": 0.35994}, "CVE-2024-44776": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-44777": {"epss_score": 0.00748, "epss_percentile": 0.72581}, "CVE-2024-44778": {"epss_score": 0.00748, "epss_percentile": 0.72581}, "CVE-2024-44779": {"epss_score": 0.01661, "epss_percentile": 0.81624}, "CVE-2024-44786": {"epss_score": 0.00109, "epss_percentile": 0.30044}, "CVE-2024-44793": {"epss_score": 0.00132, "epss_percentile": 0.33613}, "CVE-2024-44794": {"epss_score": 0.00173, "epss_percentile": 0.39106}, "CVE-2024-44795": {"epss_score": 0.00144, "epss_percentile": 0.35293}, "CVE-2024-44796": {"epss_score": 0.00156, "epss_percentile": 0.36894}, "CVE-2024-44797": {"epss_score": 0.00145, "epss_percentile": 0.35358}, "CVE-2024-44798": {"epss_score": 0.00124, "epss_percentile": 0.32376}, "CVE-2024-44807": {"epss_score": 0.00413, "epss_percentile": 0.61011}, "CVE-2024-44808": {"epss_score": 0.01334, "epss_percentile": 0.79542}, "CVE-2024-44809": {"epss_score": 0.0068, "epss_percentile": 0.71027}, "CVE-2024-44812": {"epss_score": 0.14652, "epss_percentile": 0.94258}, "CVE-2024-44815": {"epss_score": 0.06487, "epss_percentile": 0.90792}, "CVE-2024-44817": {"epss_score": 0.01469, "epss_percentile": 0.80488}, "CVE-2024-44818": {"epss_score": 0.0018, "epss_percentile": 0.39915}, "CVE-2024-44819": {"epss_score": 0.00249, "epss_percentile": 0.4808}, "CVE-2024-44820": {"epss_score": 0.00679, "epss_percentile": 0.71023}, "CVE-2024-44821": {"epss_score": 0.00162, "epss_percentile": 0.3766}, "CVE-2024-44825": {"epss_score": 0.01822, "epss_percentile": 0.82414}, "CVE-2024-44837": {"epss_score": 0.00114, "epss_percentile": 0.30853}, "CVE-2024-44838": {"epss_score": 0.00083, "epss_percentile": 0.24783}, "CVE-2024-44839": {"epss_score": 0.00083, "epss_percentile": 0.24783}, "CVE-2024-44843": {"epss_score": 0.00059, "epss_percentile": 0.18803}, "CVE-2024-44844": {"epss_score": 0.0255, "epss_percentile": 0.85073}, "CVE-2024-44845": {"epss_score": 0.0255, "epss_percentile": 0.85073}, "CVE-2024-44849": {"epss_score": 0.91441, "epss_percentile": 0.99643}, "CVE-2024-44851": {"epss_score": 0.00065, "epss_percentile": 0.20557}, "CVE-2024-44852": {"epss_score": 0.00254, "epss_percentile": 0.48549}, "CVE-2024-44853": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2024-44854": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2024-44855": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2024-44856": {"epss_score": 0.00212, "epss_percentile": 0.43773}, "CVE-2024-44859": {"epss_score": 0.00128, "epss_percentile": 0.32958}, "CVE-2024-44860": {"epss_score": 0.00178, "epss_percentile": 0.39698}, "CVE-2024-44866": {"epss_score": 0.00173, "epss_percentile": 0.39082}, "CVE-2024-44867": {"epss_score": 0.15142, "epss_percentile": 0.94372}, "CVE-2024-44871": {"epss_score": 0.11976, "epss_percentile": 0.93531}, "CVE-2024-44872": {"epss_score": 0.00133, "epss_percentile": 0.33746}, "CVE-2024-44893": {"epss_score": 0.00153, "epss_percentile": 0.36579}, "CVE-2024-44902": {"epss_score": 0.81675, "epss_percentile": 0.99151}, "CVE-2024-44903": {"epss_score": 0.00073, "epss_percentile": 0.22543}, "CVE-2024-44905": {"epss_score": 0.00038, "epss_percentile": 0.11418}, "CVE-2024-44906": {"epss_score": 0.00042, "epss_percentile": 0.12833}, "CVE-2024-44910": {"epss_score": 0.00139, "epss_percentile": 0.34652}, "CVE-2024-44911": {"epss_score": 0.00094, "epss_percentile": 0.26992}, "CVE-2024-44912": {"epss_score": 0.00139, "epss_percentile": 0.34652}, "CVE-2024-44913": {"epss_score": 0.00039, "epss_percentile": 0.11798}, "CVE-2024-44914": {"epss_score": 0.00043, "epss_percentile": 0.1314}, "CVE-2024-44915": {"epss_score": 0.00043, "epss_percentile": 0.1314}, "CVE-2024-44916": {"epss_score": 0.00935, "epss_percentile": 0.75664}, "CVE-2024-44918": {"epss_score": 0.00111, "epss_percentile": 0.30255}, "CVE-2024-44919": {"epss_score": 0.00157, "epss_percentile": 0.37138}, "CVE-2024-44920": {"epss_score": 0.0021, "epss_percentile": 0.436}, "CVE-2024-44921": {"epss_score": 0.00429, "epss_percentile": 0.61974}, "CVE-2024-44930": {"epss_score": 0.0038, "epss_percentile": 0.58933}, "CVE-2024-44931": {"epss_score": 0.0001, "epss_percentile": 0.00865}, "CVE-2024-44932": {"epss_score": 0.00022, "epss_percentile": 0.05138}, "CVE-2024-44933": {"epss_score": 0.00031, "epss_percentile": 0.08452}, "CVE-2024-44934": {"epss_score": 0.00023, "epss_percentile": 0.05627}, "CVE-2024-44935": {"epss_score": 0.00024, "epss_percentile": 0.05793}, "CVE-2024-44936": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-44937": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-44938": {"epss_score": 0.00015, "epss_percentile": 0.02274}, "CVE-2024-44939": {"epss_score": 0.00017, "epss_percentile": 0.03232}, "CVE-2024-44940": {"epss_score": 0.00018, "epss_percentile": 0.0367}, "CVE-2024-44941": {"epss_score": 0.00031, "epss_percentile": 0.08685}, "CVE-2024-44942": {"epss_score": 0.00026, "epss_percentile": 0.06673}, "CVE-2024-44943": {"epss_score": 0.00018, "epss_percentile": 0.03857}, "CVE-2024-44944": {"epss_score": 0.00017, "epss_percentile": 0.03406}, "CVE-2024-44945": {"epss_score": 0.00032, "epss_percentile": 0.09071}, "CVE-2024-44946": {"epss_score": 0.00231, "epss_percentile": 0.4583}, "CVE-2024-44947": {"epss_score": 0.00538, "epss_percentile": 0.66935}, "CVE-2024-44948": {"epss_score": 0.00013, "epss_percentile": 0.01583}, "CVE-2024-44949": {"epss_score": 0.0002, "epss_percentile": 0.04617}, "CVE-2024-44950": {"epss_score": 0.00015, "epss_percentile": 0.02581}, "CVE-2024-44951": {"epss_score": 0.00018, "epss_percentile": 0.03631}, "CVE-2024-44953": {"epss_score": 0.00039, "epss_percentile": 0.11709}, "CVE-2024-44954": {"epss_score": 0.00017, "epss_percentile": 0.0327}, "CVE-2024-44956": {"epss_score": 0.0002, "epss_percentile": 0.045}, "CVE-2024-44957": {"epss_score": 0.00014, "epss_percentile": 0.01824}, "CVE-2024-44958": {"epss_score": 0.00017, "epss_percentile": 0.03097}, "CVE-2024-44959": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-44960": {"epss_score": 0.00024, "epss_percentile": 0.05743}, "CVE-2024-44961": {"epss_score": 0.00015, "epss_percentile": 0.02302}, "CVE-2024-44962": {"epss_score": 0.00015, "epss_percentile": 0.02302}, "CVE-2024-44963": {"epss_score": 0.00015, "epss_percentile": 0.02302}, "CVE-2024-44964": {"epss_score": 0.00022, "epss_percentile": 0.05138}, "CVE-2024-44965": {"epss_score": 0.00026, "epss_percentile": 0.06487}, "CVE-2024-44966": {"epss_score": 0.00026, "epss_percentile": 0.06588}, "CVE-2024-44967": {"epss_score": 0.00033, "epss_percentile": 0.09378}, "CVE-2024-44968": {"epss_score": 0.00024, "epss_percentile": 0.05793}, "CVE-2024-44969": {"epss_score": 0.00013, "epss_percentile": 0.01599}, "CVE-2024-44970": {"epss_score": 0.00015, "epss_percentile": 0.02462}, "CVE-2024-44971": {"epss_score": 0.00017, "epss_percentile": 0.03058}, "CVE-2024-44973": {"epss_score": 0.00031, "epss_percentile": 0.08563}, "CVE-2024-44974": {"epss_score": 9e-05, "epss_percentile": 0.00733}, "CVE-2024-44975": {"epss_score": 0.0001, "epss_percentile": 0.00834}, "CVE-2024-44976": {"epss_score": 0.00026, "epss_percentile": 0.0654}, "CVE-2024-44977": {"epss_score": 0.00013, "epss_percentile": 0.01653}, "CVE-2024-44978": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2024-44979": {"epss_score": 0.00011, "epss_percentile": 0.00976}, "CVE-2024-44980": {"epss_score": 0.00026, "epss_percentile": 0.0654}, "CVE-2024-44981": {"epss_score": 0.00026, "epss_percentile": 0.0654}, "CVE-2024-44982": {"epss_score": 0.0001, "epss_percentile": 0.00891}, "CVE-2024-44983": {"epss_score": 7e-05, "epss_percentile": 0.00427}, "CVE-2024-44984": {"epss_score": 0.0001, "epss_percentile": 0.00789}, "CVE-2024-44985": {"epss_score": 0.00011, "epss_percentile": 0.01081}, "CVE-2024-44986": {"epss_score": 0.00023, "epss_percentile": 0.056}, "CVE-2024-44987": {"epss_score": 0.0002, "epss_percentile": 0.04429}, "CVE-2024-44988": {"epss_score": 0.00019, "epss_percentile": 0.04326}, "CVE-2024-44989": {"epss_score": 0.00017, "epss_percentile": 0.03122}, "CVE-2024-44990": {"epss_score": 0.00018, "epss_percentile": 0.03826}, "CVE-2024-44991": {"epss_score": 0.00062, "epss_percentile": 0.19582}, "CVE-2024-44992": {"epss_score": 0.00048, "epss_percentile": 0.15001}, "CVE-2024-44993": {"epss_score": 0.00027, "epss_percentile": 0.0692}, "CVE-2024-44994": {"epss_score": 0.00015, "epss_percentile": 0.02549}, "CVE-2024-44995": {"epss_score": 0.00014, "epss_percentile": 0.01866}, "CVE-2024-44996": {"epss_score": 8e-05, "epss_percentile": 0.00521}, "CVE-2024-44997": {"epss_score": 0.00023, "epss_percentile": 0.05516}, "CVE-2024-44998": {"epss_score": 0.00018, "epss_percentile": 0.0375}, "CVE-2024-44999": {"epss_score": 0.00013, "epss_percentile": 0.01675}, "CVE-2024-45000": {"epss_score": 0.00022, "epss_percentile": 0.05225}, "CVE-2024-45001": {"epss_score": 0.00019, "epss_percentile": 0.04141}, "CVE-2024-45002": {"epss_score": 0.00024, "epss_percentile": 0.05858}, "CVE-2024-45003": {"epss_score": 0.00015, "epss_percentile": 0.02341}, "CVE-2024-45004": {"epss_score": 0.00018, "epss_percentile": 0.04051}, "CVE-2024-45005": {"epss_score": 8e-05, "epss_percentile": 0.00497}, "CVE-2024-45006": {"epss_score": 0.00018, "epss_percentile": 0.0367}, "CVE-2024-45007": {"epss_score": 0.00017, "epss_percentile": 0.03431}, "CVE-2024-45008": {"epss_score": 0.00018, "epss_percentile": 0.03624}, "CVE-2024-45009": {"epss_score": 0.00018, "epss_percentile": 0.03719}, "CVE-2024-45010": {"epss_score": 0.00023, "epss_percentile": 0.05609}, "CVE-2024-45011": {"epss_score": 0.00018, "epss_percentile": 0.03719}, "CVE-2024-45012": {"epss_score": 0.00017, "epss_percentile": 0.03319}, "CVE-2024-45013": {"epss_score": 0.00016, "epss_percentile": 0.02799}, "CVE-2024-45014": {"epss_score": 0.00033, "epss_percentile": 0.09239}, "CVE-2024-45015": {"epss_score": 0.00017, "epss_percentile": 0.03319}, "CVE-2024-45016": {"epss_score": 0.00024, "epss_percentile": 0.05894}, "CVE-2024-45017": {"epss_score": 4e-05, "epss_percentile": 0.0013}, "CVE-2024-45018": {"epss_score": 0.00021, "epss_percentile": 0.04825}, "CVE-2024-45019": {"epss_score": 0.00018, "epss_percentile": 0.03861}, "CVE-2024-45020": {"epss_score": 0.00023, "epss_percentile": 0.05485}, "CVE-2024-45021": {"epss_score": 0.00024, "epss_percentile": 0.05989}, "CVE-2024-45022": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2024-45023": {"epss_score": 0.00022, "epss_percentile": 0.05243}, "CVE-2024-45024": {"epss_score": 0.00026, "epss_percentile": 0.06441}, "CVE-2024-45025": {"epss_score": 0.00019, "epss_percentile": 0.0426}, "CVE-2024-45026": {"epss_score": 0.00026, "epss_percentile": 0.06531}, "CVE-2024-45027": {"epss_score": 0.00035, "epss_percentile": 0.10011}, "CVE-2024-45028": {"epss_score": 0.00024, "epss_percentile": 0.05976}, "CVE-2024-45029": {"epss_score": 0.00021, "epss_percentile": 0.04905}, "CVE-2024-45030": {"epss_score": 0.00018, "epss_percentile": 0.03978}, "CVE-2024-45031": {"epss_score": 0.009, "epss_percentile": 0.75158}, "CVE-2024-45032": {"epss_score": 0.01688, "epss_percentile": 0.81762}, "CVE-2024-45033": {"epss_score": 0.00207, "epss_percentile": 0.43142}, "CVE-2024-45034": {"epss_score": 0.02304, "epss_percentile": 0.8432}, "CVE-2024-45036": {"epss_score": 0.00116, "epss_percentile": 0.31079}, "CVE-2024-45037": {"epss_score": 0.00301, "epss_percentile": 0.53009}, "CVE-2024-45038": {"epss_score": 0.00484, "epss_percentile": 0.64644}, "CVE-2024-45039": {"epss_score": 0.0005, "epss_percentile": 0.15863}, "CVE-2024-45040": {"epss_score": 0.00118, "epss_percentile": 0.3151}, "CVE-2024-45041": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2024-45042": {"epss_score": 0.00075, "epss_percentile": 0.23074}, "CVE-2024-45043": {"epss_score": 0.00443, "epss_percentile": 0.62761}, "CVE-2024-45044": {"epss_score": 0.00228, "epss_percentile": 0.45465}, "CVE-2024-45045": {"epss_score": 0.00361, "epss_percentile": 0.57704}, "CVE-2024-45046": {"epss_score": 0.00245, "epss_percentile": 0.47666}, "CVE-2024-45047": {"epss_score": 0.00266, "epss_percentile": 0.49947}, "CVE-2024-45048": {"epss_score": 0.00149, "epss_percentile": 0.3598}, "CVE-2024-45049": {"epss_score": 0.0036, "epss_percentile": 0.57623}, "CVE-2024-45050": {"epss_score": 0.00052, "epss_percentile": 0.1644}, "CVE-2024-45051": {"epss_score": 0.00084, "epss_percentile": 0.24973}, "CVE-2024-45052": {"epss_score": 0.00262, "epss_percentile": 0.49349}, "CVE-2024-45053": {"epss_score": 0.01968, "epss_percentile": 0.83087}, "CVE-2024-45054": {"epss_score": 0.00058, "epss_percentile": 0.1837}, "CVE-2024-45056": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2024-45057": {"epss_score": 0.00308, "epss_percentile": 0.53628}, "CVE-2024-45058": {"epss_score": 0.19409, "epss_percentile": 0.95177}, "CVE-2024-45059": {"epss_score": 0.00105, "epss_percentile": 0.29399}, "CVE-2024-45060": {"epss_score": 0.00576, "epss_percentile": 0.68124}, "CVE-2024-45061": {"epss_score": 0.00197, "epss_percentile": 0.41869}, "CVE-2024-45062": {"epss_score": 0.00046, "epss_percentile": 0.14393}, "CVE-2024-45063": {"epss_score": 0.05194, "epss_percentile": 0.89599}, "CVE-2024-45064": {"epss_score": 0.00216, "epss_percentile": 0.44148}, "CVE-2024-45066": {"epss_score": 0.01055, "epss_percentile": 0.77113}, "CVE-2024-45067": {"epss_score": 0.00013, "epss_percentile": 0.01699}, "CVE-2024-45068": {"epss_score": 0.00142, "epss_percentile": 0.35009}, "CVE-2024-45070": {"epss_score": 0.00031, "epss_percentile": 0.08515}, "CVE-2024-45071": {"epss_score": 0.00197, "epss_percentile": 0.41903}, "CVE-2024-45072": {"epss_score": 0.00026, "epss_percentile": 0.06535}, "CVE-2024-45073": {"epss_score": 0.00157, "epss_percentile": 0.37103}, "CVE-2024-45074": {"epss_score": 0.00175, "epss_percentile": 0.39283}, "CVE-2024-45075": {"epss_score": 0.00114, "epss_percentile": 0.30764}, "CVE-2024-45076": {"epss_score": 0.00141, "epss_percentile": 0.34902}, "CVE-2024-45077": {"epss_score": 0.00111, "epss_percentile": 0.30258}, "CVE-2024-45081": {"epss_score": 0.00069, "epss_percentile": 0.2151}, "CVE-2024-45082": {"epss_score": 0.00026, "epss_percentile": 0.06425}, "CVE-2024-45084": {"epss_score": 0.00112, "epss_percentile": 0.30428}, "CVE-2024-45085": {"epss_score": 0.0015, "epss_percentile": 0.36086}, "CVE-2024-45086": {"epss_score": 0.00025, "epss_percentile": 0.06166}, "CVE-2024-45087": {"epss_score": 0.00101, "epss_percentile": 0.2857}, "CVE-2024-45088": {"epss_score": 0.00197, "epss_percentile": 0.4186}, "CVE-2024-45089": {"epss_score": 0.00068, "epss_percentile": 0.21354}, "CVE-2024-45091": {"epss_score": 9e-05, "epss_percentile": 0.00651}, "CVE-2024-45094": {"epss_score": 0.00018, "epss_percentile": 0.03872}, "CVE-2024-45096": {"epss_score": 0.00105, "epss_percentile": 0.2928}, "CVE-2024-45097": {"epss_score": 0.00024, "epss_percentile": 0.06032}, "CVE-2024-45098": {"epss_score": 0.00031, "epss_percentile": 0.08631}, "CVE-2024-45099": {"epss_score": 0.00149, "epss_percentile": 0.36041}, "CVE-2024-45100": {"epss_score": 0.00105, "epss_percentile": 0.29394}, "CVE-2024-45101": {"epss_score": 0.00101, "epss_percentile": 0.28714}, "CVE-2024-45102": {"epss_score": 0.00053, "epss_percentile": 0.16832}, "CVE-2024-45103": {"epss_score": 0.00164, "epss_percentile": 0.37879}, "CVE-2024-45104": {"epss_score": 0.00128, "epss_percentile": 0.33}, "CVE-2024-45105": {"epss_score": 0.00059, "epss_percentile": 0.18647}, "CVE-2024-45106": {"epss_score": 0.00229, "epss_percentile": 0.45561}, "CVE-2024-45107": {"epss_score": 0.00035, "epss_percentile": 0.10059}, "CVE-2024-45108": {"epss_score": 0.00203, "epss_percentile": 0.42494}, "CVE-2024-45109": {"epss_score": 0.00203, "epss_percentile": 0.42494}, "CVE-2024-45111": {"epss_score": 0.00039, "epss_percentile": 0.11838}, "CVE-2024-45112": {"epss_score": 0.00415, "epss_percentile": 0.61139}, "CVE-2024-45113": {"epss_score": 0.00594, "epss_percentile": 0.6867}, "CVE-2024-45114": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2024-45115": {"epss_score": 0.00643, "epss_percentile": 0.70045}, "CVE-2024-45116": {"epss_score": 0.01578, "epss_percentile": 0.81123}, "CVE-2024-45117": {"epss_score": 0.00223, "epss_percentile": 0.44939}, "CVE-2024-45118": {"epss_score": 0.00086, "epss_percentile": 0.25395}, "CVE-2024-45119": {"epss_score": 0.00299, "epss_percentile": 0.52902}, "CVE-2024-45120": {"epss_score": 0.00074, "epss_percentile": 0.22791}, "CVE-2024-45121": {"epss_score": 0.00086, "epss_percentile": 0.25395}, "CVE-2024-45122": {"epss_score": 0.00103, "epss_percentile": 0.28925}, "CVE-2024-45123": {"epss_score": 0.01073, "epss_percentile": 0.77286}, "CVE-2024-45124": {"epss_score": 0.00098, "epss_percentile": 0.27712}, "CVE-2024-45125": {"epss_score": 0.00068, "epss_percentile": 0.21405}, "CVE-2024-45127": {"epss_score": 0.00718, "epss_percentile": 0.71938}, "CVE-2024-45128": {"epss_score": 0.00044, "epss_percentile": 0.13573}, "CVE-2024-45129": {"epss_score": 0.00083, "epss_percentile": 0.24607}, "CVE-2024-45130": {"epss_score": 0.00083, "epss_percentile": 0.24607}, "CVE-2024-45131": {"epss_score": 0.00114, "epss_percentile": 0.30753}, "CVE-2024-45132": {"epss_score": 0.00113, "epss_percentile": 0.30698}, "CVE-2024-45133": {"epss_score": 0.00093, "epss_percentile": 0.2666}, "CVE-2024-45134": {"epss_score": 0.00104, "epss_percentile": 0.29111}, "CVE-2024-45135": {"epss_score": 0.00144, "epss_percentile": 0.35232}, "CVE-2024-45136": {"epss_score": 0.00076, "epss_percentile": 0.23082}, "CVE-2024-45137": {"epss_score": 0.00076, "epss_percentile": 0.23082}, "CVE-2024-45138": {"epss_score": 0.00181, "epss_percentile": 0.40096}, "CVE-2024-45139": {"epss_score": 0.00147, "epss_percentile": 0.35687}, "CVE-2024-45140": {"epss_score": 0.00162, "epss_percentile": 0.37699}, "CVE-2024-45141": {"epss_score": 0.00162, "epss_percentile": 0.37699}, "CVE-2024-45142": {"epss_score": 0.00162, "epss_percentile": 0.37699}, "CVE-2024-45143": {"epss_score": 0.00147, "epss_percentile": 0.35687}, "CVE-2024-45144": {"epss_score": 0.00162, "epss_percentile": 0.37699}, "CVE-2024-45145": {"epss_score": 0.00041, "epss_percentile": 0.12378}, "CVE-2024-45146": {"epss_score": 0.00181, "epss_percentile": 0.40096}, "CVE-2024-45147": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-45148": {"epss_score": 0.00102, "epss_percentile": 0.28804}, "CVE-2024-45149": {"epss_score": 0.0012, "epss_percentile": 0.31714}, "CVE-2024-45150": {"epss_score": 0.00162, "epss_percentile": 0.37699}, "CVE-2024-45152": {"epss_score": 0.00162, "epss_percentile": 0.37699}, "CVE-2024-45153": {"epss_score": 0.01008, "epss_percentile": 0.76573}, "CVE-2024-45155": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-45156": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-45157": {"epss_score": 0.00038, "epss_percentile": 0.11265}, "CVE-2024-45158": {"epss_score": 0.00502, "epss_percentile": 0.65409}, "CVE-2024-45159": {"epss_score": 0.0044, "epss_percentile": 0.62619}, "CVE-2024-45160": {"epss_score": 0.00087, "epss_percentile": 0.25552}, "CVE-2024-45161": {"epss_score": 0.00021, "epss_percentile": 0.04846}, "CVE-2024-45162": {"epss_score": 0.00064, "epss_percentile": 0.20262}, "CVE-2024-45163": {"epss_score": 0.00108, "epss_percentile": 0.29883}, "CVE-2024-45164": {"epss_score": 0.00167, "epss_percentile": 0.3839}, "CVE-2024-45165": {"epss_score": 0.00017, "epss_percentile": 0.0321}, "CVE-2024-45166": {"epss_score": 0.03614, "epss_percentile": 0.87429}, "CVE-2024-45167": {"epss_score": 0.02978, "epss_percentile": 0.86112}, "CVE-2024-45168": {"epss_score": 0.00173, "epss_percentile": 0.39096}, "CVE-2024-45169": {"epss_score": 0.01894, "epss_percentile": 0.8274}, "CVE-2024-45170": {"epss_score": 0.00413, "epss_percentile": 0.6096}, "CVE-2024-45171": {"epss_score": 0.00441, "epss_percentile": 0.62678}, "CVE-2024-45172": {"epss_score": 0.00386, "epss_percentile": 0.59257}, "CVE-2024-45173": {"epss_score": 0.00288, "epss_percentile": 0.51874}, "CVE-2024-45174": {"epss_score": 0.00772, "epss_percentile": 0.73031}, "CVE-2024-45175": {"epss_score": 0.00639, "epss_percentile": 0.69943}, "CVE-2024-45176": {"epss_score": 0.00285, "epss_percentile": 0.51642}, "CVE-2024-45177": {"epss_score": 0.00944, "epss_percentile": 0.75783}, "CVE-2024-45178": {"epss_score": 0.01609, "epss_percentile": 0.81315}, "CVE-2024-45179": {"epss_score": 0.00638, "epss_percentile": 0.69914}, "CVE-2024-45180": {"epss_score": 0.00492, "epss_percentile": 0.65001}, "CVE-2024-45181": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2024-45182": {"epss_score": 0.00099, "epss_percentile": 0.28419}, "CVE-2024-45183": {"epss_score": 0.00034, "epss_percentile": 0.09764}, "CVE-2024-45184": {"epss_score": 0.00096, "epss_percentile": 0.27376}, "CVE-2024-45185": {"epss_score": 0.0007, "epss_percentile": 0.21833}, "CVE-2024-45186": {"epss_score": 0.00115, "epss_percentile": 0.30959}, "CVE-2024-45187": {"epss_score": 0.00061, "epss_percentile": 0.19478}, "CVE-2024-45188": {"epss_score": 0.00118, "epss_percentile": 0.31471}, "CVE-2024-45189": {"epss_score": 0.00108, "epss_percentile": 0.29892}, "CVE-2024-45190": {"epss_score": 0.00118, "epss_percentile": 0.31471}, "CVE-2024-45191": {"epss_score": 0.00169, "epss_percentile": 0.38558}, "CVE-2024-45192": {"epss_score": 0.00194, "epss_percentile": 0.41559}, "CVE-2024-45193": {"epss_score": 0.00059, "epss_percentile": 0.18715}, "CVE-2024-45194": {"epss_score": 0.00075, "epss_percentile": 0.22987}, "CVE-2024-45195": {"epss_score": 0.94148, "epss_percentile": 0.99908}, "CVE-2024-45198": {"epss_score": 0.00274, "epss_percentile": 0.50533}, "CVE-2024-45199": {"epss_score": 0.00274, "epss_percentile": 0.50533}, "CVE-2024-45200": {"epss_score": 0.05302, "epss_percentile": 0.89708}, "CVE-2024-45201": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2024-45203": {"epss_score": 0.00103, "epss_percentile": 0.28983}, "CVE-2024-45204": {"epss_score": 0.00071, "epss_percentile": 0.22118}, "CVE-2024-45205": {"epss_score": 0.00031, "epss_percentile": 0.08409}, "CVE-2024-45206": {"epss_score": 0.00072, "epss_percentile": 0.22411}, "CVE-2024-45207": {"epss_score": 0.00035, "epss_percentile": 0.09882}, "CVE-2024-45208": {"epss_score": 0.00674, "epss_percentile": 0.70853}, "CVE-2024-45216": {"epss_score": 0.9408, "epss_percentile": 0.99898}, "CVE-2024-45217": {"epss_score": 0.00166, "epss_percentile": 0.38239}, "CVE-2024-45219": {"epss_score": 0.00421, "epss_percentile": 0.6153}, "CVE-2024-45229": {"epss_score": 0.00182, "epss_percentile": 0.40269}, "CVE-2024-45230": {"epss_score": 0.02721, "epss_percentile": 0.85518}, "CVE-2024-45231": {"epss_score": 0.00173, "epss_percentile": 0.39069}, "CVE-2024-45232": {"epss_score": 0.00162, "epss_percentile": 0.37686}, "CVE-2024-45233": {"epss_score": 0.00186, "epss_percentile": 0.40587}, "CVE-2024-45234": {"epss_score": 0.00062, "epss_percentile": 0.19595}, "CVE-2024-45235": {"epss_score": 0.00502, "epss_percentile": 0.65369}, "CVE-2024-45236": {"epss_score": 0.00188, "epss_percentile": 0.40885}, "CVE-2024-45237": {"epss_score": 0.00198, "epss_percentile": 0.4201}, "CVE-2024-45238": {"epss_score": 0.00643, "epss_percentile": 0.70046}, "CVE-2024-45239": {"epss_score": 0.00219, "epss_percentile": 0.44524}, "CVE-2024-45240": {"epss_score": 0.00047, "epss_percentile": 0.14899}, "CVE-2024-45241": {"epss_score": 0.8886, "epss_percentile": 0.99495}, "CVE-2024-45242": {"epss_score": 0.00089, "epss_percentile": 0.25903}, "CVE-2024-45244": {"epss_score": 0.00508, "epss_percentile": 0.65715}, "CVE-2024-45245": {"epss_score": 0.00047, "epss_percentile": 0.14912}, "CVE-2024-45246": {"epss_score": 0.00039, "epss_percentile": 0.11634}, "CVE-2024-45247": {"epss_score": 0.00088, "epss_percentile": 0.25663}, "CVE-2024-45248": {"epss_score": 0.00194, "epss_percentile": 0.41585}, "CVE-2024-45249": {"epss_score": 0.00076, "epss_percentile": 0.2311}, "CVE-2024-45250": {"epss_score": 0.00095, "epss_percentile": 0.2723}, "CVE-2024-45251": {"epss_score": 0.0052, "epss_percentile": 0.6619}, "CVE-2024-45252": {"epss_score": 0.00433, "epss_percentile": 0.62202}, "CVE-2024-45253": {"epss_score": 0.003, "epss_percentile": 0.52909}, "CVE-2024-45254": {"epss_score": 0.00205, "epss_percentile": 0.42685}, "CVE-2024-45256": {"epss_score": 0.44329, "epss_percentile": 0.9743}, "CVE-2024-45258": {"epss_score": 0.00104, "epss_percentile": 0.29226}, "CVE-2024-45259": {"epss_score": 0.00027, "epss_percentile": 0.07117}, "CVE-2024-45260": {"epss_score": 0.03553, "epss_percentile": 0.87346}, "CVE-2024-45261": {"epss_score": 0.00018, "epss_percentile": 0.03939}, "CVE-2024-45262": {"epss_score": 0.00097, "epss_percentile": 0.27574}, "CVE-2024-45263": {"epss_score": 0.00059, "epss_percentile": 0.1873}, "CVE-2024-45264": {"epss_score": 0.07055, "epss_percentile": 0.91217}, "CVE-2024-45265": {"epss_score": 0.13739, "epss_percentile": 0.94046}, "CVE-2024-45269": {"epss_score": 0.00245, "epss_percentile": 0.47677}, "CVE-2024-45270": {"epss_score": 0.00149, "epss_percentile": 0.35983}, "CVE-2024-45271": {"epss_score": 0.00097, "epss_percentile": 0.27519}, "CVE-2024-45272": {"epss_score": 0.01016, "epss_percentile": 0.7667}, "CVE-2024-45273": {"epss_score": 0.00059, "epss_percentile": 0.18681}, "CVE-2024-45274": {"epss_score": 0.03503, "epss_percentile": 0.87252}, "CVE-2024-45275": {"epss_score": 0.01833, "epss_percentile": 0.82459}, "CVE-2024-45276": {"epss_score": 0.00505, "epss_percentile": 0.65601}, "CVE-2024-45277": {"epss_score": 0.00322, "epss_percentile": 0.5475}, "CVE-2024-45278": {"epss_score": 0.00452, "epss_percentile": 0.63196}, "CVE-2024-45279": {"epss_score": 0.00159, "epss_percentile": 0.37392}, "CVE-2024-45280": {"epss_score": 0.00083, "epss_percentile": 0.24593}, "CVE-2024-45281": {"epss_score": 0.00032, "epss_percentile": 0.08836}, "CVE-2024-45282": {"epss_score": 0.00265, "epss_percentile": 0.49809}, "CVE-2024-45283": {"epss_score": 0.00027, "epss_percentile": 0.06812}, "CVE-2024-45284": {"epss_score": 0.00075, "epss_percentile": 0.22986}, "CVE-2024-45285": {"epss_score": 0.00057, "epss_percentile": 0.18142}, "CVE-2024-45286": {"epss_score": 0.00089, "epss_percentile": 0.25854}, "CVE-2024-45287": {"epss_score": 0.00389, "epss_percentile": 0.59404}, "CVE-2024-45288": {"epss_score": 0.0004, "epss_percentile": 0.12145}, "CVE-2024-45289": {"epss_score": 0.00218, "epss_percentile": 0.4437}, "CVE-2024-45290": {"epss_score": 0.00224, "epss_percentile": 0.45038}, "CVE-2024-45291": {"epss_score": 0.00656, "epss_percentile": 0.70453}, "CVE-2024-45292": {"epss_score": 0.01018, "epss_percentile": 0.76706}, "CVE-2024-45293": {"epss_score": 0.65316, "epss_percentile": 0.98413}, "CVE-2024-45294": {"epss_score": 0.00066, "epss_percentile": 0.20676}, "CVE-2024-45296": {"epss_score": 0.00064, "epss_percentile": 0.20298}, "CVE-2024-45297": {"epss_score": 0.00344, "epss_percentile": 0.56494}, "CVE-2024-45298": {"epss_score": 0.00048, "epss_percentile": 0.14942}, "CVE-2024-45299": {"epss_score": 0.00191, "epss_percentile": 0.41273}, "CVE-2024-45300": {"epss_score": 0.00046, "epss_percentile": 0.14416}, "CVE-2024-45301": {"epss_score": 0.00031, "epss_percentile": 0.08564}, "CVE-2024-45302": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2024-45303": {"epss_score": 0.0059, "epss_percentile": 0.68575}, "CVE-2024-45304": {"epss_score": 0.00433, "epss_percentile": 0.62226}, "CVE-2024-45305": {"epss_score": 0.00024, "epss_percentile": 0.06015}, "CVE-2024-45306": {"epss_score": 0.0005, "epss_percentile": 0.15851}, "CVE-2024-45307": {"epss_score": 0.00388, "epss_percentile": 0.59358}, "CVE-2024-45308": {"epss_score": 0.00144, "epss_percentile": 0.35256}, "CVE-2024-45309": {"epss_score": 0.87249, "epss_percentile": 0.9942}, "CVE-2024-45310": {"epss_score": 0.00145, "epss_percentile": 0.35526}, "CVE-2024-45311": {"epss_score": 0.00576, "epss_percentile": 0.68147}, "CVE-2024-45312": {"epss_score": 0.00769, "epss_percentile": 0.7298}, "CVE-2024-45313": {"epss_score": 0.00241, "epss_percentile": 0.47259}, "CVE-2024-45314": {"epss_score": 0.00099, "epss_percentile": 0.27843}, "CVE-2024-45315": {"epss_score": 0.00041, "epss_percentile": 0.12427}, "CVE-2024-45316": {"epss_score": 0.00064, "epss_percentile": 0.20291}, "CVE-2024-45317": {"epss_score": 0.00205, "epss_percentile": 0.4268}, "CVE-2024-45318": {"epss_score": 0.00731, "epss_percentile": 0.72178}, "CVE-2024-45319": {"epss_score": 0.00059, "epss_percentile": 0.18658}, "CVE-2024-45320": {"epss_score": 0.00042, "epss_percentile": 0.12476}, "CVE-2024-45321": {"epss_score": 0.00383, "epss_percentile": 0.59112}, "CVE-2024-45323": {"epss_score": 0.00144, "epss_percentile": 0.35332}, "CVE-2024-45324": {"epss_score": 0.00098, "epss_percentile": 0.27793}, "CVE-2024-45325": {"epss_score": 0.00024, "epss_percentile": 0.05662}, "CVE-2024-45326": {"epss_score": 0.00098, "epss_percentile": 0.27811}, "CVE-2024-45327": {"epss_score": 0.00484, "epss_percentile": 0.64643}, "CVE-2024-45328": {"epss_score": 0.00028, "epss_percentile": 0.07345}, "CVE-2024-45329": {"epss_score": 0.00041, "epss_percentile": 0.12333}, "CVE-2024-45330": {"epss_score": 0.00214, "epss_percentile": 0.43959}, "CVE-2024-45331": {"epss_score": 0.00024, "epss_percentile": 0.0581}, "CVE-2024-45332": {"epss_score": 0.0002, "epss_percentile": 0.04499}, "CVE-2024-45333": {"epss_score": 0.00022, "epss_percentile": 0.05244}, "CVE-2024-45334": {"epss_score": 0.00091, "epss_percentile": 0.26174}, "CVE-2024-45335": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2024-45336": {"epss_score": 0.00078, "epss_percentile": 0.23771}, "CVE-2024-45337": {"epss_score": 0.42906, "epss_percentile": 0.9736}, "CVE-2024-45338": {"epss_score": 0.00157, "epss_percentile": 0.37066}, "CVE-2024-45339": {"epss_score": 0.00027, "epss_percentile": 0.06813}, "CVE-2024-45340": {"epss_score": 0.00142, "epss_percentile": 0.35037}, "CVE-2024-45341": {"epss_score": 0.00048, "epss_percentile": 0.15158}, "CVE-2024-45346": {"epss_score": 0.00095, "epss_percentile": 0.27225}, "CVE-2024-45347": {"epss_score": 0.00045, "epss_percentile": 0.13707}, "CVE-2024-45348": {"epss_score": 0.00225, "epss_percentile": 0.4514}, "CVE-2024-45351": {"epss_score": 0.00033, "epss_percentile": 0.0929}, "CVE-2024-45352": {"epss_score": 0.00017, "epss_percentile": 0.03172}, "CVE-2024-45353": {"epss_score": 0.00025, "epss_percentile": 0.06114}, "CVE-2024-45354": {"epss_score": 0.00044, "epss_percentile": 0.13441}, "CVE-2024-45355": {"epss_score": 0.00023, "epss_percentile": 0.05621}, "CVE-2024-45356": {"epss_score": 0.00023, "epss_percentile": 0.05612}, "CVE-2024-45361": {"epss_score": 0.0003, "epss_percentile": 0.08312}, "CVE-2024-45366": {"epss_score": 0.00189, "epss_percentile": 0.40954}, "CVE-2024-45367": {"epss_score": 0.00099, "epss_percentile": 0.28346}, "CVE-2024-45368": {"epss_score": 0.00107, "epss_percentile": 0.29669}, "CVE-2024-45369": {"epss_score": 0.00111, "epss_percentile": 0.30286}, "CVE-2024-45370": {"epss_score": 0.00029, "epss_percentile": 0.07778}, "CVE-2024-45371": {"epss_score": 0.00018, "epss_percentile": 0.03561}, "CVE-2024-45372": {"epss_score": 0.00095, "epss_percentile": 0.27116}, "CVE-2024-45373": {"epss_score": 0.00091, "epss_percentile": 0.2641}, "CVE-2024-45374": {"epss_score": 0.00101, "epss_percentile": 0.28702}, "CVE-2024-45382": {"epss_score": 0.00043, "epss_percentile": 0.13346}, "CVE-2024-45383": {"epss_score": 0.08504, "epss_percentile": 0.92087}, "CVE-2024-45384": {"epss_score": 0.00216, "epss_percentile": 0.44162}, "CVE-2024-45385": {"epss_score": 0.00134, "epss_percentile": 0.33795}, "CVE-2024-45386": {"epss_score": 0.00158, "epss_percentile": 0.37293}, "CVE-2024-45387": {"epss_score": 0.33476, "epss_percentile": 0.96776}, "CVE-2024-45388": {"epss_score": 0.93585, "epss_percentile": 0.99821}, "CVE-2024-45389": {"epss_score": 0.00897, "epss_percentile": 0.75133}, "CVE-2024-45390": {"epss_score": 0.00311, "epss_percentile": 0.53866}, "CVE-2024-45391": {"epss_score": 0.00186, "epss_percentile": 0.40694}, "CVE-2024-45392": {"epss_score": 0.00094, "epss_percentile": 0.27063}, "CVE-2024-45393": {"epss_score": 0.00233, "epss_percentile": 0.46062}, "CVE-2024-45394": {"epss_score": 0.00027, "epss_percentile": 0.0691}, "CVE-2024-45395": {"epss_score": 0.00219, "epss_percentile": 0.44448}, "CVE-2024-45396": {"epss_score": 0.0101, "epss_percentile": 0.76603}, "CVE-2024-45397": {"epss_score": 0.00485, "epss_percentile": 0.64728}, "CVE-2024-45398": {"epss_score": 0.00156, "epss_percentile": 0.36888}, "CVE-2024-45399": {"epss_score": 0.00809, "epss_percentile": 0.73701}, "CVE-2024-45400": {"epss_score": 0.0059, "epss_percentile": 0.68575}, "CVE-2024-45401": {"epss_score": 0.00116, "epss_percentile": 0.3114}, "CVE-2024-45402": {"epss_score": 0.00512, "epss_percentile": 0.65872}, "CVE-2024-45403": {"epss_score": 0.0033, "epss_percentile": 0.5548}, "CVE-2024-45404": {"epss_score": 0.00125, "epss_percentile": 0.32495}, "CVE-2024-45405": {"epss_score": 0.00045, "epss_percentile": 0.13791}, "CVE-2024-45406": {"epss_score": 0.00224, "epss_percentile": 0.45053}, "CVE-2024-45407": {"epss_score": 0.0027, "epss_percentile": 0.50213}, "CVE-2024-45408": {"epss_score": 0.00165, "epss_percentile": 0.38132}, "CVE-2024-45409": {"epss_score": 0.4139, "epss_percentile": 0.97271}, "CVE-2024-45410": {"epss_score": 0.13949, "epss_percentile": 0.94099}, "CVE-2024-45411": {"epss_score": 0.00156, "epss_percentile": 0.37016}, "CVE-2024-45412": {"epss_score": 0.00938, "epss_percentile": 0.75701}, "CVE-2024-45413": {"epss_score": 0.00127, "epss_percentile": 0.32865}, "CVE-2024-45414": {"epss_score": 0.00251, "epss_percentile": 0.48286}, "CVE-2024-45415": {"epss_score": 0.00205, "epss_percentile": 0.42722}, "CVE-2024-45416": {"epss_score": 0.00113, "epss_percentile": 0.3064}, "CVE-2024-45417": {"epss_score": 0.00047, "epss_percentile": 0.14853}, "CVE-2024-45418": {"epss_score": 0.004, "epss_percentile": 0.60169}, "CVE-2024-45419": {"epss_score": 0.00393, "epss_percentile": 0.59728}, "CVE-2024-45420": {"epss_score": 0.00203, "epss_percentile": 0.42548}, "CVE-2024-45421": {"epss_score": 0.00694, "epss_percentile": 0.71359}, "CVE-2024-45422": {"epss_score": 0.00197, "epss_percentile": 0.41962}, "CVE-2024-45424": {"epss_score": 0.00287, "epss_percentile": 0.51788}, "CVE-2024-45425": {"epss_score": 0.00141, "epss_percentile": 0.34865}, "CVE-2024-45426": {"epss_score": 0.00106, "epss_percentile": 0.2947}, "CVE-2024-45429": {"epss_score": 0.00396, "epss_percentile": 0.59928}, "CVE-2024-45431": {"epss_score": 0.00097, "epss_percentile": 0.27545}, "CVE-2024-45432": {"epss_score": 0.00045, "epss_percentile": 0.13725}, "CVE-2024-45433": {"epss_score": 0.00015, "epss_percentile": 0.02292}, "CVE-2024-45434": {"epss_score": 0.00783, "epss_percentile": 0.73219}, "CVE-2024-45435": {"epss_score": 0.00132, "epss_percentile": 0.33539}, "CVE-2024-45436": {"epss_score": 0.23594, "epss_percentile": 0.95795}, "CVE-2024-45438": {"epss_score": 0.0037, "epss_percentile": 0.58277}, "CVE-2024-45440": {"epss_score": 0.82704, "epss_percentile": 0.99209}, "CVE-2024-45441": {"epss_score": 0.00098, "epss_percentile": 0.27662}, "CVE-2024-45442": {"epss_score": 0.00051, "epss_percentile": 0.16138}, "CVE-2024-45443": {"epss_score": 0.00303, "epss_percentile": 0.53203}, "CVE-2024-45444": {"epss_score": 0.00046, "epss_percentile": 0.14427}, "CVE-2024-45445": {"epss_score": 0.00037, "epss_percentile": 0.10651}, "CVE-2024-45446": {"epss_score": 0.00044, "epss_percentile": 0.13574}, "CVE-2024-45447": {"epss_score": 0.00046, "epss_percentile": 0.14427}, "CVE-2024-45448": {"epss_score": 0.00026, "epss_percentile": 0.06572}, "CVE-2024-45449": {"epss_score": 0.00037, "epss_percentile": 0.10658}, "CVE-2024-45450": {"epss_score": 0.00114, "epss_percentile": 0.30837}, "CVE-2024-45451": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-45452": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-45453": {"epss_score": 0.00042, "epss_percentile": 0.12747}, "CVE-2024-45454": {"epss_score": 0.00202, "epss_percentile": 0.42471}, "CVE-2024-45455": {"epss_score": 0.00078, "epss_percentile": 0.2377}, "CVE-2024-45456": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-45457": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-45458": {"epss_score": 0.00202, "epss_percentile": 0.42471}, "CVE-2024-45459": {"epss_score": 0.00202, "epss_percentile": 0.42471}, "CVE-2024-45460": {"epss_score": 0.00078, "epss_percentile": 0.2377}, "CVE-2024-45461": {"epss_score": 0.00105, "epss_percentile": 0.29279}, "CVE-2024-45462": {"epss_score": 0.00142, "epss_percentile": 0.35008}, "CVE-2024-45463": {"epss_score": 0.00108, "epss_percentile": 0.29838}, "CVE-2024-45464": {"epss_score": 0.002, "epss_percentile": 0.42206}, "CVE-2024-45465": {"epss_score": 0.002, "epss_percentile": 0.42206}, "CVE-2024-45466": {"epss_score": 0.002, "epss_percentile": 0.42206}, "CVE-2024-45467": {"epss_score": 0.00145, "epss_percentile": 0.35444}, "CVE-2024-45468": {"epss_score": 0.00145, "epss_percentile": 0.35444}, "CVE-2024-45469": {"epss_score": 0.00153, "epss_percentile": 0.36519}, "CVE-2024-45470": {"epss_score": 0.00153, "epss_percentile": 0.36519}, "CVE-2024-45471": {"epss_score": 0.00153, "epss_percentile": 0.36519}, "CVE-2024-45472": {"epss_score": 0.00145, "epss_percentile": 0.35444}, "CVE-2024-45473": {"epss_score": 0.00145, "epss_percentile": 0.35444}, "CVE-2024-45474": {"epss_score": 0.00145, "epss_percentile": 0.35444}, "CVE-2024-45475": {"epss_score": 0.00145, "epss_percentile": 0.35444}, "CVE-2024-45476": {"epss_score": 0.00051, "epss_percentile": 0.16188}, "CVE-2024-45477": {"epss_score": 0.01255, "epss_percentile": 0.78929}, "CVE-2024-45478": {"epss_score": 0.00419, "epss_percentile": 0.61365}, "CVE-2024-45479": {"epss_score": 0.00281, "epss_percentile": 0.51129}, "CVE-2024-45480": {"epss_score": 0.00098, "epss_percentile": 0.2781}, "CVE-2024-45481": {"epss_score": 0.00025, "epss_percentile": 0.0635}, "CVE-2024-45482": {"epss_score": 0.00025, "epss_percentile": 0.0635}, "CVE-2024-45483": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2024-45484": {"epss_score": 0.0004, "epss_percentile": 0.11995}, "CVE-2024-45488": {"epss_score": 0.85795, "epss_percentile": 0.99349}, "CVE-2024-45489": {"epss_score": 0.01622, "epss_percentile": 0.81397}, "CVE-2024-45490": {"epss_score": 0.00306, "epss_percentile": 0.5346}, "CVE-2024-45491": {"epss_score": 0.00384, "epss_percentile": 0.59154}, "CVE-2024-45492": {"epss_score": 0.00587, "epss_percentile": 0.68483}, "CVE-2024-45493": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-45494": {"epss_score": 0.00216, "epss_percentile": 0.4416}, "CVE-2024-45495": {"epss_score": 0.00048, "epss_percentile": 0.15032}, "CVE-2024-45496": {"epss_score": 0.00123, "epss_percentile": 0.32325}, "CVE-2024-45497": {"epss_score": 0.00581, "epss_percentile": 0.68274}, "CVE-2024-45498": {"epss_score": 0.01527, "epss_percentile": 0.8087}, "CVE-2024-45504": {"epss_score": 0.00057, "epss_percentile": 0.18095}, "CVE-2024-45505": {"epss_score": 0.03167, "epss_percentile": 0.86541}, "CVE-2024-45506": {"epss_score": 0.0048, "epss_percentile": 0.64463}, "CVE-2024-45507": {"epss_score": 0.90476, "epss_percentile": 0.99584}, "CVE-2024-45508": {"epss_score": 0.00181, "epss_percentile": 0.40126}, "CVE-2024-45509": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2024-45510": {"epss_score": 0.00307, "epss_percentile": 0.5356}, "CVE-2024-45511": {"epss_score": 0.00193, "epss_percentile": 0.41405}, "CVE-2024-45512": {"epss_score": 0.00146, "epss_percentile": 0.35617}, "CVE-2024-45513": {"epss_score": 0.00096, "epss_percentile": 0.27399}, "CVE-2024-45514": {"epss_score": 0.00113, "epss_percentile": 0.30635}, "CVE-2024-45515": {"epss_score": 0.00102, "epss_percentile": 0.2877}, "CVE-2024-45516": {"epss_score": 0.00115, "epss_percentile": 0.30933}, "CVE-2024-45517": {"epss_score": 0.00155, "epss_percentile": 0.36769}, "CVE-2024-45518": {"epss_score": 0.20518, "epss_percentile": 0.95363}, "CVE-2024-45519": {"epss_score": 0.9414, "epss_percentile": 0.99908}, "CVE-2024-45520": {"epss_score": 0.00309, "epss_percentile": 0.53649}, "CVE-2024-45522": {"epss_score": 0.00067, "epss_percentile": 0.20976}, "CVE-2024-45523": {"epss_score": 0.00259, "epss_percentile": 0.49056}, "CVE-2024-45526": {"epss_score": 0.00341, "epss_percentile": 0.56294}, "CVE-2024-45527": {"epss_score": 0.00092, "epss_percentile": 0.26535}, "CVE-2024-45528": {"epss_score": 0.00114, "epss_percentile": 0.30853}, "CVE-2024-45537": {"epss_score": 0.00238, "epss_percentile": 0.46766}, "CVE-2024-45538": {"epss_score": 0.00068, "epss_percentile": 0.21262}, "CVE-2024-45539": {"epss_score": 0.00151, "epss_percentile": 0.36345}, "CVE-2024-45540": {"epss_score": 0.00029, "epss_percentile": 0.07774}, "CVE-2024-45541": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-45542": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-45543": {"epss_score": 0.00029, "epss_percentile": 0.07774}, "CVE-2024-45544": {"epss_score": 0.00029, "epss_percentile": 0.07774}, "CVE-2024-45546": {"epss_score": 0.00023, "epss_percentile": 0.05518}, "CVE-2024-45547": {"epss_score": 0.00023, "epss_percentile": 0.05518}, "CVE-2024-45548": {"epss_score": 0.00023, "epss_percentile": 0.05518}, "CVE-2024-45549": {"epss_score": 0.00023, "epss_percentile": 0.05436}, "CVE-2024-45550": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-45551": {"epss_score": 0.00022, "epss_percentile": 0.05005}, "CVE-2024-45552": {"epss_score": 0.00082, "epss_percentile": 0.2455}, "CVE-2024-45553": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-45554": {"epss_score": 0.00012, "epss_percentile": 0.01359}, "CVE-2024-45555": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-45556": {"epss_score": 0.00019, "epss_percentile": 0.04354}, "CVE-2024-45557": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2024-45558": {"epss_score": 0.00189, "epss_percentile": 0.40943}, "CVE-2024-45559": {"epss_score": 0.00033, "epss_percentile": 0.09186}, "CVE-2024-45560": {"epss_score": 0.0002, "epss_percentile": 0.04621}, "CVE-2024-45561": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-45562": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-45563": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-45564": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-45565": {"epss_score": 0.00011, "epss_percentile": 0.00985}, "CVE-2024-45566": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-45567": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-45568": {"epss_score": 0.00017, "epss_percentile": 0.0315}, "CVE-2024-45569": {"epss_score": 0.00249, "epss_percentile": 0.48074}, "CVE-2024-45570": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-45571": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-45573": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-45574": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-45575": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-45576": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-45577": {"epss_score": 0.00027, "epss_percentile": 0.07157}, "CVE-2024-45578": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-45579": {"epss_score": 0.00027, "epss_percentile": 0.07157}, "CVE-2024-45580": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-45581": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2024-45582": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-45583": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-45584": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-45586": {"epss_score": 0.00553, "epss_percentile": 0.67413}, "CVE-2024-45587": {"epss_score": 0.00517, "epss_percentile": 0.66066}, "CVE-2024-45588": {"epss_score": 0.00116, "epss_percentile": 0.31048}, "CVE-2024-45589": {"epss_score": 0.07775, "epss_percentile": 0.91675}, "CVE-2024-45590": {"epss_score": 0.02072, "epss_percentile": 0.83489}, "CVE-2024-45591": {"epss_score": 0.82065, "epss_percentile": 0.99171}, "CVE-2024-45592": {"epss_score": 0.00263, "epss_percentile": 0.49478}, "CVE-2024-45593": {"epss_score": 0.00428, "epss_percentile": 0.61941}, "CVE-2024-45594": {"epss_score": 0.00211, "epss_percentile": 0.43666}, "CVE-2024-45595": {"epss_score": 0.01209, "epss_percentile": 0.78545}, "CVE-2024-45596": {"epss_score": 0.00555, "epss_percentile": 0.67475}, "CVE-2024-45597": {"epss_score": 0.00759, "epss_percentile": 0.72785}, "CVE-2024-45598": {"epss_score": 0.00335, "epss_percentile": 0.55858}, "CVE-2024-45599": {"epss_score": 0.00015, "epss_percentile": 0.02287}, "CVE-2024-45600": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-45601": {"epss_score": 0.00128, "epss_percentile": 0.3307}, "CVE-2024-45604": {"epss_score": 0.00551, "epss_percentile": 0.67359}, "CVE-2024-45605": {"epss_score": 0.00411, "epss_percentile": 0.60869}, "CVE-2024-45606": {"epss_score": 0.00344, "epss_percentile": 0.56488}, "CVE-2024-45607": {"epss_score": 0.01729, "epss_percentile": 0.81982}, "CVE-2024-45608": {"epss_score": 0.00614, "epss_percentile": 0.69268}, "CVE-2024-45609": {"epss_score": 0.0112, "epss_percentile": 0.77762}, "CVE-2024-45610": {"epss_score": 0.0112, "epss_percentile": 0.77762}, "CVE-2024-45611": {"epss_score": 0.0029, "epss_percentile": 0.52097}, "CVE-2024-45612": {"epss_score": 0.00719, "epss_percentile": 0.71939}, "CVE-2024-45613": {"epss_score": 0.00219, "epss_percentile": 0.44517}, "CVE-2024-45614": {"epss_score": 0.00592, "epss_percentile": 0.68611}, "CVE-2024-45615": {"epss_score": 0.00073, "epss_percentile": 0.22504}, "CVE-2024-45616": {"epss_score": 0.00073, "epss_percentile": 0.22504}, "CVE-2024-45617": {"epss_score": 0.00116, "epss_percentile": 0.31069}, "CVE-2024-45618": {"epss_score": 0.00093, "epss_percentile": 0.26698}, "CVE-2024-45619": {"epss_score": 0.0007, "epss_percentile": 0.21984}, "CVE-2024-45620": {"epss_score": 0.0007, "epss_percentile": 0.21984}, "CVE-2024-45621": {"epss_score": 0.00116, "epss_percentile": 0.31106}, "CVE-2024-45622": {"epss_score": 0.51511, "epss_percentile": 0.97783}, "CVE-2024-45623": {"epss_score": 0.00871, "epss_percentile": 0.7472}, "CVE-2024-45624": {"epss_score": 0.00124, "epss_percentile": 0.32338}, "CVE-2024-45625": {"epss_score": 0.00185, "epss_percentile": 0.40462}, "CVE-2024-45626": {"epss_score": 0.00568, "epss_percentile": 0.67903}, "CVE-2024-45627": {"epss_score": 0.00076, "epss_percentile": 0.23099}, "CVE-2024-45638": {"epss_score": 0.00016, "epss_percentile": 0.0278}, "CVE-2024-45640": {"epss_score": 0.00095, "epss_percentile": 0.27117}, "CVE-2024-45641": {"epss_score": 0.0002, "epss_percentile": 0.04619}, "CVE-2024-45642": {"epss_score": 0.00065, "epss_percentile": 0.20546}, "CVE-2024-45643": {"epss_score": 0.00046, "epss_percentile": 0.14186}, "CVE-2024-45644": {"epss_score": 0.00087, "epss_percentile": 0.25615}, "CVE-2024-45647": {"epss_score": 0.00075, "epss_percentile": 0.23028}, "CVE-2024-45650": {"epss_score": 0.00115, "epss_percentile": 0.30994}, "CVE-2024-45651": {"epss_score": 0.00042, "epss_percentile": 0.12712}, "CVE-2024-45652": {"epss_score": 0.0023, "epss_percentile": 0.45764}, "CVE-2024-45653": {"epss_score": 0.00193, "epss_percentile": 0.41452}, "CVE-2024-45654": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2024-45655": {"epss_score": 0.00011, "epss_percentile": 0.00975}, "CVE-2024-45656": {"epss_score": 0.00113, "epss_percentile": 0.30676}, "CVE-2024-45657": {"epss_score": 0.00012, "epss_percentile": 0.01255}, "CVE-2024-45658": {"epss_score": 0.00075, "epss_percentile": 0.22981}, "CVE-2024-45659": {"epss_score": 0.00082, "epss_percentile": 0.24465}, "CVE-2024-45662": {"epss_score": 0.00121, "epss_percentile": 0.31813}, "CVE-2024-45663": {"epss_score": 0.00044, "epss_percentile": 0.13417}, "CVE-2024-45669": {"epss_score": 0.00142, "epss_percentile": 0.34956}, "CVE-2024-45670": {"epss_score": 0.00035, "epss_percentile": 0.09892}, "CVE-2024-45671": {"epss_score": 0.00018, "epss_percentile": 0.04039}, "CVE-2024-45672": {"epss_score": 0.00019, "epss_percentile": 0.04258}, "CVE-2024-45673": {"epss_score": 0.00021, "epss_percentile": 0.04712}, "CVE-2024-45674": {"epss_score": 0.00024, "epss_percentile": 0.05771}, "CVE-2024-45675": {"epss_score": 0.00016, "epss_percentile": 0.02894}, "CVE-2024-45676": {"epss_score": 0.00042, "epss_percentile": 0.12789}, "CVE-2024-45678": {"epss_score": 0.00106, "epss_percentile": 0.29446}, "CVE-2024-45679": {"epss_score": 0.00066, "epss_percentile": 0.20886}, "CVE-2024-45682": {"epss_score": 0.00437, "epss_percentile": 0.62501}, "CVE-2024-45687": {"epss_score": 0.00123, "epss_percentile": 0.32309}, "CVE-2024-45689": {"epss_score": 0.00093, "epss_percentile": 0.26636}, "CVE-2024-45690": {"epss_score": 0.00268, "epss_percentile": 0.50098}, "CVE-2024-45691": {"epss_score": 0.00285, "epss_percentile": 0.51637}, "CVE-2024-45692": {"epss_score": 0.00046, "epss_percentile": 0.14177}, "CVE-2024-45693": {"epss_score": 0.00118, "epss_percentile": 0.31448}, "CVE-2024-45694": {"epss_score": 0.01913, "epss_percentile": 0.82842}, "CVE-2024-45695": {"epss_score": 0.02459, "epss_percentile": 0.84816}, "CVE-2024-45696": {"epss_score": 0.00214, "epss_percentile": 0.43978}, "CVE-2024-45697": {"epss_score": 0.01666, "epss_percentile": 0.81652}, "CVE-2024-45698": {"epss_score": 0.01838, "epss_percentile": 0.82484}, "CVE-2024-45699": {"epss_score": 0.00057, "epss_percentile": 0.18168}, "CVE-2024-45700": {"epss_score": 0.00047, "epss_percentile": 0.1493}, "CVE-2024-45709": {"epss_score": 0.0018, "epss_percentile": 0.39975}, "CVE-2024-45710": {"epss_score": 0.00107, "epss_percentile": 0.29748}, "CVE-2024-45711": {"epss_score": 0.09001, "epss_percentile": 0.92359}, "CVE-2024-45712": {"epss_score": 0.0004, "epss_percentile": 0.12022}, "CVE-2024-45713": {"epss_score": 0.00074, "epss_percentile": 0.22782}, "CVE-2024-45714": {"epss_score": 0.00276, "epss_percentile": 0.50759}, "CVE-2024-45715": {"epss_score": 0.00063, "epss_percentile": 0.19873}, "CVE-2024-45717": {"epss_score": 0.00247, "epss_percentile": 0.47847}, "CVE-2024-45718": {"epss_score": 0.00028, "epss_percentile": 0.07291}, "CVE-2024-45719": {"epss_score": 0.00066, "epss_percentile": 0.20911}, "CVE-2024-45720": {"epss_score": 0.00051, "epss_percentile": 0.16176}, "CVE-2024-45721": {"epss_score": 0.0263, "epss_percentile": 0.85277}, "CVE-2024-45722": {"epss_score": 0.0014, "epss_percentile": 0.34792}, "CVE-2024-45723": {"epss_score": 0.00058, "epss_percentile": 0.18516}, "CVE-2024-45731": {"epss_score": 0.00578, "epss_percentile": 0.68181}, "CVE-2024-45732": {"epss_score": 0.00209, "epss_percentile": 0.43314}, "CVE-2024-45733": {"epss_score": 0.05221, "epss_percentile": 0.89626}, "CVE-2024-45734": {"epss_score": 0.0007, "epss_percentile": 0.21931}, "CVE-2024-45735": {"epss_score": 0.0007, "epss_percentile": 0.21931}, "CVE-2024-45736": {"epss_score": 0.00194, "epss_percentile": 0.41554}, "CVE-2024-45737": {"epss_score": 0.00027, "epss_percentile": 0.06931}, "CVE-2024-45738": {"epss_score": 0.00072, "epss_percentile": 0.22425}, "CVE-2024-45739": {"epss_score": 0.00075, "epss_percentile": 0.22992}, "CVE-2024-45740": {"epss_score": 0.00579, "epss_percentile": 0.68232}, "CVE-2024-45741": {"epss_score": 0.02972, "epss_percentile": 0.86098}, "CVE-2024-45744": {"epss_score": 0.00033, "epss_percentile": 0.09251}, "CVE-2024-45745": {"epss_score": 0.00076, "epss_percentile": 0.23276}, "CVE-2024-45746": {"epss_score": 0.06757, "epss_percentile": 0.91007}, "CVE-2024-45750": {"epss_score": 0.05486, "epss_percentile": 0.89923}, "CVE-2024-45751": {"epss_score": 0.00311, "epss_percentile": 0.53821}, "CVE-2024-45752": {"epss_score": 0.00021, "epss_percentile": 0.04776}, "CVE-2024-45753": {"epss_score": 0.00055, "epss_percentile": 0.17484}, "CVE-2024-45754": {"epss_score": 0.00128, "epss_percentile": 0.32974}, "CVE-2024-45755": {"epss_score": 0.00076, "epss_percentile": 0.2309}, "CVE-2024-45756": {"epss_score": 0.00066, "epss_percentile": 0.20858}, "CVE-2024-45757": {"epss_score": 0.00134, "epss_percentile": 0.33842}, "CVE-2024-45758": {"epss_score": 0.00129, "epss_percentile": 0.3321}, "CVE-2024-45759": {"epss_score": 0.00061, "epss_percentile": 0.19336}, "CVE-2024-45760": {"epss_score": 0.0011, "epss_percentile": 0.30104}, "CVE-2024-45761": {"epss_score": 0.00154, "epss_percentile": 0.36731}, "CVE-2024-45763": {"epss_score": 0.00357, "epss_percentile": 0.5745}, "CVE-2024-45764": {"epss_score": 0.00075, "epss_percentile": 0.22955}, "CVE-2024-45765": {"epss_score": 0.00357, "epss_percentile": 0.5745}, "CVE-2024-45766": {"epss_score": 0.00663, "epss_percentile": 0.70623}, "CVE-2024-45767": {"epss_score": 0.0048, "epss_percentile": 0.64455}, "CVE-2024-45769": {"epss_score": 0.00024, "epss_percentile": 0.05991}, "CVE-2024-45770": {"epss_score": 0.00025, "epss_percentile": 0.06113}, "CVE-2024-45771": {"epss_score": 0.00118, "epss_percentile": 0.31513}, "CVE-2024-45772": {"epss_score": 0.00034, "epss_percentile": 0.09774}, "CVE-2024-45773": {"epss_score": 0.00368, "epss_percentile": 0.58171}, "CVE-2024-45774": {"epss_score": 0.00072, "epss_percentile": 0.22308}, "CVE-2024-45775": {"epss_score": 0.00048, "epss_percentile": 0.15101}, "CVE-2024-45776": {"epss_score": 0.00072, "epss_percentile": 0.22308}, "CVE-2024-45777": {"epss_score": 0.00039, "epss_percentile": 0.11655}, "CVE-2024-45778": {"epss_score": 0.00021, "epss_percentile": 0.04872}, "CVE-2024-45779": {"epss_score": 0.00106, "epss_percentile": 0.29563}, "CVE-2024-45780": {"epss_score": 0.00039, "epss_percentile": 0.11655}, "CVE-2024-45781": {"epss_score": 0.00072, "epss_percentile": 0.22308}, "CVE-2024-45782": {"epss_score": 0.00036, "epss_percentile": 0.10204}, "CVE-2024-45783": {"epss_score": 0.00056, "epss_percentile": 0.17761}, "CVE-2024-45784": {"epss_score": 0.00688, "epss_percentile": 0.71203}, "CVE-2024-45785": {"epss_score": 0.00201, "epss_percentile": 0.42303}, "CVE-2024-45786": {"epss_score": 0.00105, "epss_percentile": 0.29252}, "CVE-2024-45787": {"epss_score": 0.00107, "epss_percentile": 0.29667}, "CVE-2024-45788": {"epss_score": 0.00493, "epss_percentile": 0.65064}, "CVE-2024-45789": {"epss_score": 0.00045, "epss_percentile": 0.13703}, "CVE-2024-45790": {"epss_score": 0.00614, "epss_percentile": 0.69281}, "CVE-2024-45791": {"epss_score": 0.00239, "epss_percentile": 0.46884}, "CVE-2024-45792": {"epss_score": 0.00377, "epss_percentile": 0.58774}, "CVE-2024-45793": {"epss_score": 0.00079, "epss_percentile": 0.23988}, "CVE-2024-45794": {"epss_score": 0.00197, "epss_percentile": 0.41836}, "CVE-2024-45795": {"epss_score": 0.00882, "epss_percentile": 0.74892}, "CVE-2024-45796": {"epss_score": 0.0026, "epss_percentile": 0.49189}, "CVE-2024-45797": {"epss_score": 0.00465, "epss_percentile": 0.63765}, "CVE-2024-45798": {"epss_score": 0.00235, "epss_percentile": 0.46228}, "CVE-2024-45799": {"epss_score": 0.00087, "epss_percentile": 0.25484}, "CVE-2024-45800": {"epss_score": 0.00103, "epss_percentile": 0.28959}, "CVE-2024-45801": {"epss_score": 0.00062, "epss_percentile": 0.19702}, "CVE-2024-45802": {"epss_score": 0.01247, "epss_percentile": 0.78862}, "CVE-2024-45803": {"epss_score": 0.00315, "epss_percentile": 0.54162}, "CVE-2024-45805": {"epss_score": 0.00094, "epss_percentile": 0.26768}, "CVE-2024-45806": {"epss_score": 0.00166, "epss_percentile": 0.382}, "CVE-2024-45807": {"epss_score": 0.00079, "epss_percentile": 0.23801}, "CVE-2024-45808": {"epss_score": 0.00041, "epss_percentile": 0.12314}, "CVE-2024-45809": {"epss_score": 0.00129, "epss_percentile": 0.33159}, "CVE-2024-45810": {"epss_score": 0.0003, "epss_percentile": 0.08179}, "CVE-2024-45811": {"epss_score": 0.00014, "epss_percentile": 0.02038}, "CVE-2024-45812": {"epss_score": 0.00188, "epss_percentile": 0.4091}, "CVE-2024-45813": {"epss_score": 0.00048, "epss_percentile": 0.14979}, "CVE-2024-45815": {"epss_score": 0.00185, "epss_percentile": 0.40519}, "CVE-2024-45816": {"epss_score": 0.00125, "epss_percentile": 0.32554}, "CVE-2024-45817": {"epss_score": 0.00185, "epss_percentile": 0.40482}, "CVE-2024-45818": {"epss_score": 0.00169, "epss_percentile": 0.38534}, "CVE-2024-45819": {"epss_score": 0.00027, "epss_percentile": 0.0678}, "CVE-2024-45823": {"epss_score": 0.00053, "epss_percentile": 0.16889}, "CVE-2024-45824": {"epss_score": 0.01102, "epss_percentile": 0.77586}, "CVE-2024-45825": {"epss_score": 0.00152, "epss_percentile": 0.3638}, "CVE-2024-45826": {"epss_score": 0.0551, "epss_percentile": 0.89945}, "CVE-2024-45827": {"epss_score": 0.00253, "epss_percentile": 0.48425}, "CVE-2024-45828": {"epss_score": 0.00045, "epss_percentile": 0.13735}, "CVE-2024-45829": {"epss_score": 0.00451, "epss_percentile": 0.63133}, "CVE-2024-45832": {"epss_score": 0.00055, "epss_percentile": 0.17478}, "CVE-2024-45833": {"epss_score": 0.00166, "epss_percentile": 0.38245}, "CVE-2024-45835": {"epss_score": 0.00268, "epss_percentile": 0.50083}, "CVE-2024-45836": {"epss_score": 0.00122, "epss_percentile": 0.32155}, "CVE-2024-45837": {"epss_score": 0.00079, "epss_percentile": 0.2391}, "CVE-2024-45838": {"epss_score": 0.00025, "epss_percentile": 0.06166}, "CVE-2024-45841": {"epss_score": 0.00069, "epss_percentile": 0.21519}, "CVE-2024-45842": {"epss_score": 0.0098, "epss_percentile": 0.76275}, "CVE-2024-45843": {"epss_score": 0.00204, "epss_percentile": 0.4265}, "CVE-2024-45844": {"epss_score": 0.00053, "epss_percentile": 0.16718}, "CVE-2024-45846": {"epss_score": 0.00469, "epss_percentile": 0.63914}, "CVE-2024-45847": {"epss_score": 0.00323, "epss_percentile": 0.54875}, "CVE-2024-45848": {"epss_score": 0.00323, "epss_percentile": 0.54875}, "CVE-2024-45849": {"epss_score": 0.00409, "epss_percentile": 0.60738}, "CVE-2024-45850": {"epss_score": 0.00409, "epss_percentile": 0.60738}, "CVE-2024-45851": {"epss_score": 0.00409, "epss_percentile": 0.60738}, "CVE-2024-45852": {"epss_score": 0.00181, "epss_percentile": 0.40071}, "CVE-2024-45853": {"epss_score": 0.00181, "epss_percentile": 0.40071}, "CVE-2024-45854": {"epss_score": 0.00165, "epss_percentile": 0.3814}, "CVE-2024-45855": {"epss_score": 0.00165, "epss_percentile": 0.3814}, "CVE-2024-45856": {"epss_score": 0.00116, "epss_percentile": 0.31169}, "CVE-2024-45857": {"epss_score": 0.0005, "epss_percentile": 0.15742}, "CVE-2024-45858": {"epss_score": 0.00079, "epss_percentile": 0.23849}, "CVE-2024-45861": {"epss_score": 0.00193, "epss_percentile": 0.41487}, "CVE-2024-45862": {"epss_score": 0.00075, "epss_percentile": 0.23002}, "CVE-2024-45863": {"epss_score": 0.00307, "epss_percentile": 0.53489}, "CVE-2024-45870": {"epss_score": 0.00268, "epss_percentile": 0.50079}, "CVE-2024-45871": {"epss_score": 0.00059, "epss_percentile": 0.18678}, "CVE-2024-45872": {"epss_score": 0.00072, "epss_percentile": 0.22407}, "CVE-2024-45873": {"epss_score": 0.00451, "epss_percentile": 0.63149}, "CVE-2024-45874": {"epss_score": 0.00345, "epss_percentile": 0.56592}, "CVE-2024-45875": {"epss_score": 0.00108, "epss_percentile": 0.29795}, "CVE-2024-45876": {"epss_score": 0.0009, "epss_percentile": 0.26014}, "CVE-2024-45877": {"epss_score": 0.00101, "epss_percentile": 0.28651}, "CVE-2024-45878": {"epss_score": 0.00169, "epss_percentile": 0.38625}, "CVE-2024-45879": {"epss_score": 0.00169, "epss_percentile": 0.38533}, "CVE-2024-45880": {"epss_score": 0.00176, "epss_percentile": 0.39385}, "CVE-2024-45882": {"epss_score": 0.00579, "epss_percentile": 0.68225}, "CVE-2024-45884": {"epss_score": 0.00601, "epss_percentile": 0.68846}, "CVE-2024-45885": {"epss_score": 0.00601, "epss_percentile": 0.68846}, "CVE-2024-45887": {"epss_score": 0.00601, "epss_percentile": 0.68846}, "CVE-2024-45888": {"epss_score": 0.00579, "epss_percentile": 0.68225}, "CVE-2024-45889": {"epss_score": 0.00601, "epss_percentile": 0.68846}, "CVE-2024-45890": {"epss_score": 0.00572, "epss_percentile": 0.68022}, "CVE-2024-45891": {"epss_score": 0.00572, "epss_percentile": 0.68022}, "CVE-2024-45893": {"epss_score": 0.00311, "epss_percentile": 0.53931}, "CVE-2024-45894": {"epss_score": 0.00117, "epss_percentile": 0.31297}, "CVE-2024-45918": {"epss_score": 0.00163, "epss_percentile": 0.37777}, "CVE-2024-45919": {"epss_score": 0.00094, "epss_percentile": 0.26968}, "CVE-2024-45920": {"epss_score": 0.00099, "epss_percentile": 0.28382}, "CVE-2024-45932": {"epss_score": 0.00039, "epss_percentile": 0.11605}, "CVE-2024-45933": {"epss_score": 0.00146, "epss_percentile": 0.35566}, "CVE-2024-45944": {"epss_score": 0.00495, "epss_percentile": 0.65132}, "CVE-2024-45955": {"epss_score": 0.00044, "epss_percentile": 0.13677}, "CVE-2024-45960": {"epss_score": 0.00128, "epss_percentile": 0.33051}, "CVE-2024-45962": {"epss_score": 0.0027, "epss_percentile": 0.50203}, "CVE-2024-45964": {"epss_score": 0.00063, "epss_percentile": 0.19826}, "CVE-2024-45965": {"epss_score": 0.0033, "epss_percentile": 0.55478}, "CVE-2024-45967": {"epss_score": 0.00209, "epss_percentile": 0.43371}, "CVE-2024-45969": {"epss_score": 0.00313, "epss_percentile": 0.54059}, "CVE-2024-45970": {"epss_score": 0.00347, "epss_percentile": 0.56757}, "CVE-2024-45971": {"epss_score": 0.0033, "epss_percentile": 0.55461}, "CVE-2024-45979": {"epss_score": 0.00109, "epss_percentile": 0.29967}, "CVE-2024-45980": {"epss_score": 0.00118, "epss_percentile": 0.31519}, "CVE-2024-45981": {"epss_score": 0.00153, "epss_percentile": 0.36521}, "CVE-2024-45982": {"epss_score": 0.00118, "epss_percentile": 0.31519}, "CVE-2024-45983": {"epss_score": 0.00131, "epss_percentile": 0.33397}, "CVE-2024-45984": {"epss_score": 0.00136, "epss_percentile": 0.34165}, "CVE-2024-45985": {"epss_score": 0.00136, "epss_percentile": 0.34165}, "CVE-2024-45986": {"epss_score": 0.00163, "epss_percentile": 0.37768}, "CVE-2024-45987": {"epss_score": 0.00132, "epss_percentile": 0.33577}, "CVE-2024-45989": {"epss_score": 0.00018, "epss_percentile": 0.03826}, "CVE-2024-45993": {"epss_score": 0.00122, "epss_percentile": 0.3214}, "CVE-2024-45999": {"epss_score": 0.00048, "epss_percentile": 0.14937}, "CVE-2024-46040": {"epss_score": 0.0005, "epss_percentile": 0.15958}, "CVE-2024-46041": {"epss_score": 0.00013, "epss_percentile": 0.01438}, "CVE-2024-46044": {"epss_score": 0.00106, "epss_percentile": 0.2943}, "CVE-2024-46045": {"epss_score": 0.00342, "epss_percentile": 0.56375}, "CVE-2024-46046": {"epss_score": 0.00447, "epss_percentile": 0.62944}, "CVE-2024-46047": {"epss_score": 0.00091, "epss_percentile": 0.26248}, "CVE-2024-46048": {"epss_score": 0.57593, "epss_percentile": 0.98073}, "CVE-2024-46049": {"epss_score": 0.00119, "epss_percentile": 0.31533}, "CVE-2024-46054": {"epss_score": 0.00072, "epss_percentile": 0.22316}, "CVE-2024-46055": {"epss_score": 0.00052, "epss_percentile": 0.1639}, "CVE-2024-46060": {"epss_score": 0.00022, "epss_percentile": 0.05156}, "CVE-2024-46062": {"epss_score": 0.00022, "epss_percentile": 0.05156}, "CVE-2024-46073": {"epss_score": 0.00131, "epss_percentile": 0.33483}, "CVE-2024-46076": {"epss_score": 0.00295, "epss_percentile": 0.52497}, "CVE-2024-46077": {"epss_score": 0.00057, "epss_percentile": 0.18011}, "CVE-2024-46078": {"epss_score": 0.00188, "epss_percentile": 0.40851}, "CVE-2024-46079": {"epss_score": 0.00076, "epss_percentile": 0.23099}, "CVE-2024-46080": {"epss_score": 0.01325, "epss_percentile": 0.79473}, "CVE-2024-46081": {"epss_score": 0.0009, "epss_percentile": 0.26143}, "CVE-2024-46082": {"epss_score": 0.00171, "epss_percentile": 0.38816}, "CVE-2024-46083": {"epss_score": 0.00208, "epss_percentile": 0.43241}, "CVE-2024-46084": {"epss_score": 0.01325, "epss_percentile": 0.79473}, "CVE-2024-46085": {"epss_score": 0.00087, "epss_percentile": 0.25562}, "CVE-2024-46086": {"epss_score": 0.00134, "epss_percentile": 0.33868}, "CVE-2024-46088": {"epss_score": 0.00218, "epss_percentile": 0.44348}, "CVE-2024-46089": {"epss_score": 0.00768, "epss_percentile": 0.72978}, "CVE-2024-46097": {"epss_score": 0.00094, "epss_percentile": 0.27033}, "CVE-2024-46101": {"epss_score": 0.00145, "epss_percentile": 0.35438}, "CVE-2024-46103": {"epss_score": 0.0009, "epss_percentile": 0.25991}, "CVE-2024-46209": {"epss_score": 0.00126, "epss_percentile": 0.3272}, "CVE-2024-46210": {"epss_score": 0.00293, "epss_percentile": 0.52333}, "CVE-2024-46212": {"epss_score": 0.0056, "epss_percentile": 0.67637}, "CVE-2024-46213": {"epss_score": 0.01873, "epss_percentile": 0.82642}, "CVE-2024-46215": {"epss_score": 0.00227, "epss_percentile": 0.45392}, "CVE-2024-46226": {"epss_score": 0.00066, "epss_percentile": 0.20754}, "CVE-2024-46236": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2024-46237": {"epss_score": 0.00111, "epss_percentile": 0.30298}, "CVE-2024-46238": {"epss_score": 0.00096, "epss_percentile": 0.27282}, "CVE-2024-46239": {"epss_score": 0.00108, "epss_percentile": 0.29891}, "CVE-2024-46240": {"epss_score": 0.00124, "epss_percentile": 0.32445}, "CVE-2024-46241": {"epss_score": 0.00088, "epss_percentile": 0.25725}, "CVE-2024-46242": {"epss_score": 0.00061, "epss_percentile": 0.19492}, "CVE-2024-46256": {"epss_score": 0.57539, "epss_percentile": 0.98069}, "CVE-2024-46257": {"epss_score": 0.01017, "epss_percentile": 0.76693}, "CVE-2024-46258": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2024-46259": {"epss_score": 0.00078, "epss_percentile": 0.23657}, "CVE-2024-46261": {"epss_score": 0.00229, "epss_percentile": 0.45604}, "CVE-2024-46263": {"epss_score": 0.00078, "epss_percentile": 0.23657}, "CVE-2024-46264": {"epss_score": 0.00078, "epss_percentile": 0.23657}, "CVE-2024-46267": {"epss_score": 0.00078, "epss_percentile": 0.23657}, "CVE-2024-46274": {"epss_score": 0.00088, "epss_percentile": 0.25728}, "CVE-2024-46276": {"epss_score": 0.00078, "epss_percentile": 0.23657}, "CVE-2024-46278": {"epss_score": 0.00763, "epss_percentile": 0.72885}, "CVE-2024-46280": {"epss_score": 0.00039, "epss_percentile": 0.11548}, "CVE-2024-46292": {"epss_score": 0.00576, "epss_percentile": 0.68128}, "CVE-2024-46293": {"epss_score": 0.00227, "epss_percentile": 0.45453}, "CVE-2024-46300": {"epss_score": 0.00061, "epss_percentile": 0.19297}, "CVE-2024-46304": {"epss_score": 0.00648, "epss_percentile": 0.7021}, "CVE-2024-46307": {"epss_score": 0.0031, "epss_percentile": 0.53772}, "CVE-2024-46310": {"epss_score": 0.77517, "epss_percentile": 0.98939}, "CVE-2024-46313": {"epss_score": 0.02738, "epss_percentile": 0.85553}, "CVE-2024-46316": {"epss_score": 0.00222, "epss_percentile": 0.44766}, "CVE-2024-46325": {"epss_score": 0.00076, "epss_percentile": 0.23165}, "CVE-2024-46326": {"epss_score": 0.00118, "epss_percentile": 0.31392}, "CVE-2024-46327": {"epss_score": 0.00087, "epss_percentile": 0.25564}, "CVE-2024-46328": {"epss_score": 0.00045, "epss_percentile": 0.13785}, "CVE-2024-46329": {"epss_score": 0.00083, "epss_percentile": 0.24641}, "CVE-2024-46330": {"epss_score": 0.00131, "epss_percentile": 0.33414}, "CVE-2024-46331": {"epss_score": 0.00089, "epss_percentile": 0.25885}, "CVE-2024-46333": {"epss_score": 0.00153, "epss_percentile": 0.36551}, "CVE-2024-46334": {"epss_score": 0.00044, "epss_percentile": 0.13482}, "CVE-2024-46335": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2024-46336": {"epss_score": 0.00044, "epss_percentile": 0.13482}, "CVE-2024-46340": {"epss_score": 0.00128, "epss_percentile": 0.33067}, "CVE-2024-46341": {"epss_score": 0.00051, "epss_percentile": 0.16302}, "CVE-2024-46362": {"epss_score": 0.00118, "epss_percentile": 0.31449}, "CVE-2024-46366": {"epss_score": 0.00413, "epss_percentile": 0.60999}, "CVE-2024-46367": {"epss_score": 0.00254, "epss_percentile": 0.48558}, "CVE-2024-46372": {"epss_score": 0.00148, "epss_percentile": 0.35915}, "CVE-2024-46373": {"epss_score": 0.00276, "epss_percentile": 0.50773}, "CVE-2024-46374": {"epss_score": 0.00242, "epss_percentile": 0.47363}, "CVE-2024-46375": {"epss_score": 0.00725, "epss_percentile": 0.72061}, "CVE-2024-46376": {"epss_score": 0.00725, "epss_percentile": 0.72061}, "CVE-2024-46377": {"epss_score": 0.17527, "epss_percentile": 0.94861}, "CVE-2024-46382": {"epss_score": 0.00086, "epss_percentile": 0.25396}, "CVE-2024-46383": {"epss_score": 0.00769, "epss_percentile": 0.72991}, "CVE-2024-46394": {"epss_score": 0.00118, "epss_percentile": 0.31464}, "CVE-2024-46409": {"epss_score": 0.00094, "epss_percentile": 0.26806}, "CVE-2024-46410": {"epss_score": 0.00199, "epss_percentile": 0.42158}, "CVE-2024-46412": {"epss_score": 0.00072, "epss_percentile": 0.223}, "CVE-2024-46413": {"epss_score": 0.00032, "epss_percentile": 0.08852}, "CVE-2024-46419": {"epss_score": 0.00127, "epss_percentile": 0.32788}, "CVE-2024-46424": {"epss_score": 0.00476, "epss_percentile": 0.64283}, "CVE-2024-46429": {"epss_score": 0.00159, "epss_percentile": 0.37393}, "CVE-2024-46430": {"epss_score": 0.00031, "epss_percentile": 0.0865}, "CVE-2024-46431": {"epss_score": 0.00035, "epss_percentile": 0.10072}, "CVE-2024-46432": {"epss_score": 0.00084, "epss_percentile": 0.2501}, "CVE-2024-46433": {"epss_score": 0.00561, "epss_percentile": 0.67667}, "CVE-2024-46434": {"epss_score": 0.00347, "epss_percentile": 0.56771}, "CVE-2024-46435": {"epss_score": 0.00234, "epss_percentile": 0.46077}, "CVE-2024-46436": {"epss_score": 0.00217, "epss_percentile": 0.4429}, "CVE-2024-46437": {"epss_score": 0.00515, "epss_percentile": 0.65972}, "CVE-2024-46441": {"epss_score": 0.00206, "epss_percentile": 0.4277}, "CVE-2024-46442": {"epss_score": 0.00253, "epss_percentile": 0.48472}, "CVE-2024-46446": {"epss_score": 0.00098, "epss_percentile": 0.27742}, "CVE-2024-46450": {"epss_score": 0.00099, "epss_percentile": 0.2842}, "CVE-2024-46451": {"epss_score": 0.11639, "epss_percentile": 0.93426}, "CVE-2024-46452": {"epss_score": 0.00025, "epss_percentile": 0.06273}, "CVE-2024-46453": {"epss_score": 0.00122, "epss_percentile": 0.32155}, "CVE-2024-46455": {"epss_score": 0.00106, "epss_percentile": 0.29443}, "CVE-2024-46461": {"epss_score": 0.0026, "epss_percentile": 0.491}, "CVE-2024-46462": {"epss_score": 0.00106, "epss_percentile": 0.29525}, "CVE-2024-46463": {"epss_score": 0.00106, "epss_percentile": 0.29525}, "CVE-2024-46464": {"epss_score": 0.00029, "epss_percentile": 0.07757}, "CVE-2024-46465": {"epss_score": 0.00102, "epss_percentile": 0.28798}, "CVE-2024-46466": {"epss_score": 0.00106, "epss_percentile": 0.29525}, "CVE-2024-46467": {"epss_score": 0.00106, "epss_percentile": 0.29525}, "CVE-2024-46468": {"epss_score": 0.00304, "epss_percentile": 0.53258}, "CVE-2024-46470": {"epss_score": 0.00102, "epss_percentile": 0.28832}, "CVE-2024-46471": {"epss_score": 0.00182, "epss_percentile": 0.40243}, "CVE-2024-46472": {"epss_score": 0.00043, "epss_percentile": 0.12955}, "CVE-2024-46475": {"epss_score": 0.00039, "epss_percentile": 0.11627}, "CVE-2024-46478": {"epss_score": 0.00254, "epss_percentile": 0.48563}, "CVE-2024-46479": {"epss_score": 0.00879, "epss_percentile": 0.74847}, "CVE-2024-46480": {"epss_score": 0.00243, "epss_percentile": 0.47455}, "CVE-2024-46481": {"epss_score": 0.00095, "epss_percentile": 0.27183}, "CVE-2024-46482": {"epss_score": 0.00126, "epss_percentile": 0.32657}, "CVE-2024-46483": {"epss_score": 0.10725, "epss_percentile": 0.93084}, "CVE-2024-46484": {"epss_score": 0.00471, "epss_percentile": 0.63998}, "CVE-2024-46485": {"epss_score": 0.00055, "epss_percentile": 0.17621}, "CVE-2024-46486": {"epss_score": 0.02427, "epss_percentile": 0.84719}, "CVE-2024-46488": {"epss_score": 0.00135, "epss_percentile": 0.3404}, "CVE-2024-46489": {"epss_score": 0.02602, "epss_percentile": 0.8521}, "CVE-2024-46494": {"epss_score": 0.00046, "epss_percentile": 0.14115}, "CVE-2024-46505": {"epss_score": 0.00097, "epss_percentile": 0.27469}, "CVE-2024-46506": {"epss_score": 0.80759, "epss_percentile": 0.99103}, "CVE-2024-46510": {"epss_score": 0.00067, "epss_percentile": 0.21133}, "CVE-2024-46511": {"epss_score": 0.00502, "epss_percentile": 0.65405}, "CVE-2024-46528": {"epss_score": 0.01075, "epss_percentile": 0.77313}, "CVE-2024-46531": {"epss_score": 0.00019, "epss_percentile": 0.04172}, "CVE-2024-46532": {"epss_score": 0.04015, "epss_percentile": 0.88121}, "CVE-2024-46535": {"epss_score": 0.00374, "epss_percentile": 0.58573}, "CVE-2024-46538": {"epss_score": 0.74502, "epss_percentile": 0.98804}, "CVE-2024-46539": {"epss_score": 0.00085, "epss_percentile": 0.25088}, "CVE-2024-46540": {"epss_score": 0.00438, "epss_percentile": 0.62548}, "CVE-2024-46542": {"epss_score": 0.00168, "epss_percentile": 0.38498}, "CVE-2024-46544": {"epss_score": 0.00029, "epss_percentile": 0.07695}, "CVE-2024-46546": {"epss_score": 0.00111, "epss_percentile": 0.30375}, "CVE-2024-46547": {"epss_score": 0.00179, "epss_percentile": 0.39834}, "CVE-2024-46548": {"epss_score": 0.00078, "epss_percentile": 0.23687}, "CVE-2024-46549": {"epss_score": 0.00053, "epss_percentile": 0.16873}, "CVE-2024-46550": {"epss_score": 0.0022, "epss_percentile": 0.44567}, "CVE-2024-46551": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46552": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46553": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46554": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46555": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46556": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46557": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46558": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46559": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46560": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46561": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46564": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46565": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46566": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46567": {"epss_score": 0.00259, "epss_percentile": 0.49055}, "CVE-2024-46568": {"epss_score": 0.00173, "epss_percentile": 0.39067}, "CVE-2024-46571": {"epss_score": 0.00299, "epss_percentile": 0.52844}, "CVE-2024-46580": {"epss_score": 0.00299, "epss_percentile": 0.52844}, "CVE-2024-46581": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2024-46582": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2024-46583": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2024-46584": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2024-46585": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2024-46586": {"epss_score": 0.00299, "epss_percentile": 0.52844}, "CVE-2024-46588": {"epss_score": 0.00299, "epss_percentile": 0.52844}, "CVE-2024-46589": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2024-46590": {"epss_score": 0.00314, "epss_percentile": 0.54109}, "CVE-2024-46591": {"epss_score": 0.00314, "epss_percentile": 0.54109}, "CVE-2024-46592": {"epss_score": 0.00314, "epss_percentile": 0.54109}, "CVE-2024-46593": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2024-46594": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2024-46595": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2024-46596": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2024-46597": {"epss_score": 0.00352, "epss_percentile": 0.5709}, "CVE-2024-46598": {"epss_score": 0.00299, "epss_percentile": 0.52844}, "CVE-2024-46600": {"epss_score": 0.00035, "epss_percentile": 0.1006}, "CVE-2024-46601": {"epss_score": 0.00245, "epss_percentile": 0.47658}, "CVE-2024-46602": {"epss_score": 0.00152, "epss_percentile": 0.36432}, "CVE-2024-46603": {"epss_score": 0.00152, "epss_percentile": 0.36432}, "CVE-2024-46605": {"epss_score": 0.00073, "epss_percentile": 0.22639}, "CVE-2024-46606": {"epss_score": 0.00294, "epss_percentile": 0.52406}, "CVE-2024-46607": {"epss_score": 0.0006, "epss_percentile": 0.19111}, "CVE-2024-46609": {"epss_score": 0.00207, "epss_percentile": 0.43093}, "CVE-2024-46610": {"epss_score": 0.00056, "epss_percentile": 0.1774}, "CVE-2024-46612": {"epss_score": 0.00105, "epss_percentile": 0.29318}, "CVE-2024-46613": {"epss_score": 0.00346, "epss_percentile": 0.56734}, "CVE-2024-46622": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-46624": {"epss_score": 0.00066, "epss_percentile": 0.20766}, "CVE-2024-46625": {"epss_score": 0.0044, "epss_percentile": 0.62629}, "CVE-2024-46626": {"epss_score": 0.00135, "epss_percentile": 0.34}, "CVE-2024-46627": {"epss_score": 0.91036, "epss_percentile": 0.99615}, "CVE-2024-46628": {"epss_score": 0.24498, "epss_percentile": 0.95927}, "CVE-2024-46632": {"epss_score": 0.00296, "epss_percentile": 0.5259}, "CVE-2024-46635": {"epss_score": 0.00768, "epss_percentile": 0.72976}, "CVE-2024-46639": {"epss_score": 0.00036, "epss_percentile": 0.10407}, "CVE-2024-46640": {"epss_score": 0.02144, "epss_percentile": 0.8376}, "CVE-2024-46644": {"epss_score": 0.0031, "epss_percentile": 0.53754}, "CVE-2024-46645": {"epss_score": 0.00384, "epss_percentile": 0.59168}, "CVE-2024-46646": {"epss_score": 0.00359, "epss_percentile": 0.5755}, "CVE-2024-46647": {"epss_score": 0.00469, "epss_percentile": 0.63921}, "CVE-2024-46648": {"epss_score": 0.00502, "epss_percentile": 0.65391}, "CVE-2024-46649": {"epss_score": 0.0056, "epss_percentile": 0.67639}, "CVE-2024-46652": {"epss_score": 0.00171, "epss_percentile": 0.38856}, "CVE-2024-46654": {"epss_score": 0.00083, "epss_percentile": 0.2474}, "CVE-2024-46655": {"epss_score": 0.00344, "epss_percentile": 0.5648}, "CVE-2024-46657": {"epss_score": 0.00035, "epss_percentile": 0.09909}, "CVE-2024-46658": {"epss_score": 0.44975, "epss_percentile": 0.97464}, "CVE-2024-46662": {"epss_score": 0.00193, "epss_percentile": 0.41429}, "CVE-2024-46663": {"epss_score": 0.00035, "epss_percentile": 0.10047}, "CVE-2024-46664": {"epss_score": 0.0022, "epss_percentile": 0.44555}, "CVE-2024-46665": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-46666": {"epss_score": 0.00159, "epss_percentile": 0.37328}, "CVE-2024-46667": {"epss_score": 0.0024, "epss_percentile": 0.4723}, "CVE-2024-46668": {"epss_score": 0.00314, "epss_percentile": 0.54153}, "CVE-2024-46669": {"epss_score": 0.00244, "epss_percentile": 0.47555}, "CVE-2024-46670": {"epss_score": 0.00199, "epss_percentile": 0.42103}, "CVE-2024-46671": {"epss_score": 0.00062, "epss_percentile": 0.19674}, "CVE-2024-46672": {"epss_score": 0.00019, "epss_percentile": 0.04061}, "CVE-2024-46673": {"epss_score": 0.00012, "epss_percentile": 0.01418}, "CVE-2024-46674": {"epss_score": 0.00014, "epss_percentile": 0.01759}, "CVE-2024-46675": {"epss_score": 0.00011, "epss_percentile": 0.01085}, "CVE-2024-46676": {"epss_score": 0.00012, "epss_percentile": 0.01353}, "CVE-2024-46677": {"epss_score": 0.00012, "epss_percentile": 0.01353}, "CVE-2024-46678": {"epss_score": 7e-05, "epss_percentile": 0.00455}, "CVE-2024-46679": {"epss_score": 0.00013, "epss_percentile": 0.01675}, "CVE-2024-46680": {"epss_score": 0.00013, "epss_percentile": 0.01617}, "CVE-2024-46681": {"epss_score": 8e-05, "epss_percentile": 0.00557}, "CVE-2024-46682": {"epss_score": 0.00018, "epss_percentile": 0.03797}, "CVE-2024-46683": {"epss_score": 0.00019, "epss_percentile": 0.04129}, "CVE-2024-46684": {"epss_score": 0.00019, "epss_percentile": 0.04129}, "CVE-2024-46685": {"epss_score": 0.00024, "epss_percentile": 0.05976}, "CVE-2024-46686": {"epss_score": 0.00025, "epss_percentile": 0.06306}, "CVE-2024-46687": {"epss_score": 0.00036, "epss_percentile": 0.10487}, "CVE-2024-46688": {"epss_score": 0.00051, "epss_percentile": 0.16143}, "CVE-2024-46689": {"epss_score": 0.00024, "epss_percentile": 0.05907}, "CVE-2024-46690": {"epss_score": 0.00039, "epss_percentile": 0.1162}, "CVE-2024-46691": {"epss_score": 0.00019, "epss_percentile": 0.04293}, "CVE-2024-46692": {"epss_score": 0.00016, "epss_percentile": 0.02798}, "CVE-2024-46693": {"epss_score": 0.0002, "epss_percentile": 0.04673}, "CVE-2024-46694": {"epss_score": 0.00023, "epss_percentile": 0.05609}, "CVE-2024-46695": {"epss_score": 3e-05, "epss_percentile": 0.00073}, "CVE-2024-46696": {"epss_score": 0.00054, "epss_percentile": 0.17261}, "CVE-2024-46697": {"epss_score": 0.00016, "epss_percentile": 0.0289}, "CVE-2024-46698": {"epss_score": 0.00019, "epss_percentile": 0.04352}, "CVE-2024-46699": {"epss_score": 0.00053, "epss_percentile": 0.16741}, "CVE-2024-46701": {"epss_score": 9e-05, "epss_percentile": 0.00734}, "CVE-2024-46702": {"epss_score": 0.0002, "epss_percentile": 0.04461}, "CVE-2024-46703": {"epss_score": 0.0002, "epss_percentile": 0.04594}, "CVE-2024-46704": {"epss_score": 0.00053, "epss_percentile": 0.16945}, "CVE-2024-46705": {"epss_score": 0.00018, "epss_percentile": 0.03655}, "CVE-2024-46706": {"epss_score": 0.0002, "epss_percentile": 0.04673}, "CVE-2024-46707": {"epss_score": 0.00019, "epss_percentile": 0.0433}, "CVE-2024-46708": {"epss_score": 0.0006, "epss_percentile": 0.18969}, "CVE-2024-46709": {"epss_score": 0.0002, "epss_percentile": 0.04673}, "CVE-2024-46710": {"epss_score": 0.00021, "epss_percentile": 0.0476}, "CVE-2024-46711": {"epss_score": 0.00023, "epss_percentile": 0.05609}, "CVE-2024-46712": {"epss_score": 0.00033, "epss_percentile": 0.09239}, "CVE-2024-46713": {"epss_score": 0.00016, "epss_percentile": 0.02962}, "CVE-2024-46714": {"epss_score": 0.00021, "epss_percentile": 0.04705}, "CVE-2024-46715": {"epss_score": 0.00021, "epss_percentile": 0.04921}, "CVE-2024-46716": {"epss_score": 0.00023, "epss_percentile": 0.05428}, "CVE-2024-46717": {"epss_score": 0.00023, "epss_percentile": 0.05469}, "CVE-2024-46718": {"epss_score": 0.00033, "epss_percentile": 0.09239}, "CVE-2024-46719": {"epss_score": 0.00021, "epss_percentile": 0.04705}, "CVE-2024-46720": {"epss_score": 0.0004, "epss_percentile": 0.11986}, "CVE-2024-46721": {"epss_score": 0.00023, "epss_percentile": 0.0551}, "CVE-2024-46722": {"epss_score": 0.00014, "epss_percentile": 0.02032}, "CVE-2024-46723": {"epss_score": 0.00014, "epss_percentile": 0.02032}, "CVE-2024-46724": {"epss_score": 0.00013, "epss_percentile": 0.01673}, "CVE-2024-46725": {"epss_score": 0.00026, "epss_percentile": 0.0648}, "CVE-2024-46726": {"epss_score": 0.00023, "epss_percentile": 0.0551}, "CVE-2024-46727": {"epss_score": 0.00018, "epss_percentile": 0.03655}, "CVE-2024-46728": {"epss_score": 0.00027, "epss_percentile": 0.06855}, "CVE-2024-46729": {"epss_score": 0.00027, "epss_percentile": 0.07136}, "CVE-2024-46730": {"epss_score": 0.00015, "epss_percentile": 0.02272}, "CVE-2024-46731": {"epss_score": 0.00013, "epss_percentile": 0.01673}, "CVE-2024-46732": {"epss_score": 0.00016, "epss_percentile": 0.02963}, "CVE-2024-46733": {"epss_score": 0.00024, "epss_percentile": 0.05856}, "CVE-2024-46734": {"epss_score": 9e-05, "epss_percentile": 0.00731}, "CVE-2024-46735": {"epss_score": 0.00013, "epss_percentile": 0.0152}, "CVE-2024-46736": {"epss_score": 0.00015, "epss_percentile": 0.02548}, "CVE-2024-46737": {"epss_score": 0.00012, "epss_percentile": 0.01353}, "CVE-2024-46738": {"epss_score": 0.00014, "epss_percentile": 0.01759}, "CVE-2024-46739": {"epss_score": 0.00012, "epss_percentile": 0.01353}, "CVE-2024-46740": {"epss_score": 0.00015, "epss_percentile": 0.02193}, "CVE-2024-46741": {"epss_score": 0.0004, "epss_percentile": 0.12012}, "CVE-2024-46742": {"epss_score": 0.00013, "epss_percentile": 0.01598}, "CVE-2024-46743": {"epss_score": 8e-05, "epss_percentile": 0.00514}, "CVE-2024-46744": {"epss_score": 0.00013, "epss_percentile": 0.01478}, "CVE-2024-46745": {"epss_score": 0.00011, "epss_percentile": 0.00991}, "CVE-2024-46746": {"epss_score": 0.00011, "epss_percentile": 0.01049}, "CVE-2024-46747": {"epss_score": 8e-05, "epss_percentile": 0.00514}, "CVE-2024-46748": {"epss_score": 0.00128, "epss_percentile": 0.33021}, "CVE-2024-46749": {"epss_score": 0.0001, "epss_percentile": 0.00886}, "CVE-2024-46750": {"epss_score": 9e-05, "epss_percentile": 0.00643}, "CVE-2024-46751": {"epss_score": 0.00015, "epss_percentile": 0.0254}, "CVE-2024-46752": {"epss_score": 9e-05, "epss_percentile": 0.00615}, "CVE-2024-46753": {"epss_score": 7e-05, "epss_percentile": 0.0035}, "CVE-2024-46754": {"epss_score": 0.00011, "epss_percentile": 0.00942}, "CVE-2024-46755": {"epss_score": 0.00011, "epss_percentile": 0.01085}, "CVE-2024-46759": {"epss_score": 0.00012, "epss_percentile": 0.01418}, "CVE-2024-46760": {"epss_score": 0.00044, "epss_percentile": 0.13527}, "CVE-2024-46761": {"epss_score": 0.00011, "epss_percentile": 0.01085}, "CVE-2024-46762": {"epss_score": 0.00018, "epss_percentile": 0.0393}, "CVE-2024-46763": {"epss_score": 7e-05, "epss_percentile": 0.00405}, "CVE-2024-46764": {"epss_score": 0.00133, "epss_percentile": 0.33643}, "CVE-2024-46765": {"epss_score": 0.00012, "epss_percentile": 0.01228}, "CVE-2024-46766": {"epss_score": 0.00015, "epss_percentile": 0.02412}, "CVE-2024-46767": {"epss_score": 0.00011, "epss_percentile": 0.01054}, "CVE-2024-46768": {"epss_score": 0.00022, "epss_percentile": 0.05282}, "CVE-2024-46769": {"epss_score": 0.00128, "epss_percentile": 0.33021}, "CVE-2024-46770": {"epss_score": 0.0001, "epss_percentile": 0.00765}, "CVE-2024-46771": {"epss_score": 8e-05, "epss_percentile": 0.00479}, "CVE-2024-46772": {"epss_score": 0.00016, "epss_percentile": 0.02703}, "CVE-2024-46773": {"epss_score": 0.00018, "epss_percentile": 0.03729}, "CVE-2024-46774": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2024-46775": {"epss_score": 0.0001, "epss_percentile": 0.00796}, "CVE-2024-46776": {"epss_score": 0.0001, "epss_percentile": 0.00886}, "CVE-2024-46777": {"epss_score": 0.00015, "epss_percentile": 0.02212}, "CVE-2024-46778": {"epss_score": 0.00018, "epss_percentile": 0.03655}, "CVE-2024-46779": {"epss_score": 0.00039, "epss_percentile": 0.11463}, "CVE-2024-46780": {"epss_score": 0.00015, "epss_percentile": 0.02226}, "CVE-2024-46781": {"epss_score": 0.00014, "epss_percentile": 0.01761}, "CVE-2024-46782": {"epss_score": 0.00022, "epss_percentile": 0.05136}, "CVE-2024-46783": {"epss_score": 0.00016, "epss_percentile": 0.02829}, "CVE-2024-46784": {"epss_score": 0.00013, "epss_percentile": 0.0168}, "CVE-2024-46785": {"epss_score": 0.00023, "epss_percentile": 0.05328}, "CVE-2024-46786": {"epss_score": 0.00016, "epss_percentile": 0.02827}, "CVE-2024-46787": {"epss_score": 0.00017, "epss_percentile": 0.03275}, "CVE-2024-46788": {"epss_score": 0.0002, "epss_percentile": 0.04631}, "CVE-2024-46789": {"epss_score": 0.00081, "epss_percentile": 0.24301}, "CVE-2024-46790": {"epss_score": 0.00081, "epss_percentile": 0.24301}, "CVE-2024-46791": {"epss_score": 0.00012, "epss_percentile": 0.01252}, "CVE-2024-46792": {"epss_score": 0.00034, "epss_percentile": 0.09661}, "CVE-2024-46793": {"epss_score": 0.0002, "epss_percentile": 0.04618}, "CVE-2024-46794": {"epss_score": 0.0003, "epss_percentile": 0.0799}, "CVE-2024-46795": {"epss_score": 0.00016, "epss_percentile": 0.0281}, "CVE-2024-46796": {"epss_score": 0.00024, "epss_percentile": 0.06013}, "CVE-2024-46797": {"epss_score": 0.00027, "epss_percentile": 0.07004}, "CVE-2024-46798": {"epss_score": 0.00026, "epss_percentile": 0.06481}, "CVE-2024-46799": {"epss_score": 0.00021, "epss_percentile": 0.04895}, "CVE-2024-46800": {"epss_score": 0.00014, "epss_percentile": 0.01824}, "CVE-2024-46801": {"epss_score": 0.00021, "epss_percentile": 0.04895}, "CVE-2024-46802": {"epss_score": 0.00011, "epss_percentile": 0.01066}, "CVE-2024-46803": {"epss_score": 0.00021, "epss_percentile": 0.04948}, "CVE-2024-46804": {"epss_score": 0.00012, "epss_percentile": 0.01159}, "CVE-2024-46805": {"epss_score": 7e-05, "epss_percentile": 0.0036}, "CVE-2024-46806": {"epss_score": 0.00011, "epss_percentile": 0.00999}, "CVE-2024-46807": {"epss_score": 7e-05, "epss_percentile": 0.0036}, "CVE-2024-46808": {"epss_score": 0.0001, "epss_percentile": 0.00796}, "CVE-2024-46809": {"epss_score": 7e-05, "epss_percentile": 0.00333}, "CVE-2024-46810": {"epss_score": 7e-05, "epss_percentile": 0.0036}, "CVE-2024-46811": {"epss_score": 0.00015, "epss_percentile": 0.02199}, "CVE-2024-46812": {"epss_score": 0.0001, "epss_percentile": 0.00805}, "CVE-2024-46813": {"epss_score": 0.00015, "epss_percentile": 0.02439}, "CVE-2024-46814": {"epss_score": 0.00013, "epss_percentile": 0.01631}, "CVE-2024-46815": {"epss_score": 0.00011, "epss_percentile": 0.0102}, "CVE-2024-46816": {"epss_score": 0.00017, "epss_percentile": 0.03165}, "CVE-2024-46817": {"epss_score": 8e-05, "epss_percentile": 0.00475}, "CVE-2024-46818": {"epss_score": 0.00013, "epss_percentile": 0.01457}, "CVE-2024-46819": {"epss_score": 7e-05, "epss_percentile": 0.00397}, "CVE-2024-46820": {"epss_score": 0.00017, "epss_percentile": 0.03501}, "CVE-2024-46821": {"epss_score": 0.00011, "epss_percentile": 0.01056}, "CVE-2024-46822": {"epss_score": 8e-05, "epss_percentile": 0.00554}, "CVE-2024-46823": {"epss_score": 0.00014, "epss_percentile": 0.01913}, "CVE-2024-46824": {"epss_score": 9e-05, "epss_percentile": 0.00684}, "CVE-2024-46825": {"epss_score": 0.00013, "epss_percentile": 0.01601}, "CVE-2024-46826": {"epss_score": 9e-05, "epss_percentile": 0.00659}, "CVE-2024-46827": {"epss_score": 0.00044, "epss_percentile": 0.1344}, "CVE-2024-46828": {"epss_score": 0.00014, "epss_percentile": 0.01965}, "CVE-2024-46829": {"epss_score": 6e-05, "epss_percentile": 0.0032}, "CVE-2024-46830": {"epss_score": 0.00016, "epss_percentile": 0.02784}, "CVE-2024-46831": {"epss_score": 0.00016, "epss_percentile": 0.02827}, "CVE-2024-46832": {"epss_score": 8e-05, "epss_percentile": 0.00544}, "CVE-2024-46833": {"epss_score": 0.00014, "epss_percentile": 0.01869}, "CVE-2024-46834": {"epss_score": 0.0001, "epss_percentile": 0.00796}, "CVE-2024-46835": {"epss_score": 9e-05, "epss_percentile": 0.00643}, "CVE-2024-46836": {"epss_score": 0.00015, "epss_percentile": 0.02199}, "CVE-2024-46837": {"epss_score": 0.00019, "epss_percentile": 0.04188}, "CVE-2024-46838": {"epss_score": 0.00048, "epss_percentile": 0.15122}, "CVE-2024-46840": {"epss_score": 7e-05, "epss_percentile": 0.00382}, "CVE-2024-46841": {"epss_score": 7e-05, "epss_percentile": 0.00333}, "CVE-2024-46842": {"epss_score": 8e-05, "epss_percentile": 0.00549}, "CVE-2024-46843": {"epss_score": 0.0001, "epss_percentile": 0.00886}, "CVE-2024-46844": {"epss_score": 0.00011, "epss_percentile": 0.01033}, "CVE-2024-46845": {"epss_score": 0.00016, "epss_percentile": 0.02827}, "CVE-2024-46846": {"epss_score": 0.00021, "epss_percentile": 0.0476}, "CVE-2024-46847": {"epss_score": 0.0002, "epss_percentile": 0.04616}, "CVE-2024-46848": {"epss_score": 0.00021, "epss_percentile": 0.0476}, "CVE-2024-46849": {"epss_score": 0.00017, "epss_percentile": 0.03299}, "CVE-2024-46850": {"epss_score": 0.00019, "epss_percentile": 0.04352}, "CVE-2024-46851": {"epss_score": 0.00025, "epss_percentile": 0.0624}, "CVE-2024-46852": {"epss_score": 5e-05, "epss_percentile": 0.00201}, "CVE-2024-46853": {"epss_score": 0.00021, "epss_percentile": 0.04846}, "CVE-2024-46854": {"epss_score": 0.00015, "epss_percentile": 0.02294}, "CVE-2024-46855": {"epss_score": 0.00033, "epss_percentile": 0.09175}, "CVE-2024-46856": {"epss_score": 0.00033, "epss_percentile": 0.09331}, "CVE-2024-46857": {"epss_score": 0.00023, "epss_percentile": 0.05335}, "CVE-2024-46858": {"epss_score": 0.00023, "epss_percentile": 0.05592}, "CVE-2024-46859": {"epss_score": 0.00019, "epss_percentile": 0.0411}, "CVE-2024-46860": {"epss_score": 0.00046, "epss_percentile": 0.14386}, "CVE-2024-46861": {"epss_score": 0.00019, "epss_percentile": 0.04146}, "CVE-2024-46862": {"epss_score": 0.00033, "epss_percentile": 0.09331}, "CVE-2024-46863": {"epss_score": 0.0003, "epss_percentile": 0.0828}, "CVE-2024-46864": {"epss_score": 0.00017, "epss_percentile": 0.03319}, "CVE-2024-46865": {"epss_score": 0.00013, "epss_percentile": 0.01558}, "CVE-2024-46866": {"epss_score": 0.00015, "epss_percentile": 0.02365}, "CVE-2024-46867": {"epss_score": 0.0004, "epss_percentile": 0.11863}, "CVE-2024-46868": {"epss_score": 0.0004, "epss_percentile": 0.11863}, "CVE-2024-46869": {"epss_score": 0.0002, "epss_percentile": 0.04673}, "CVE-2024-46870": {"epss_score": 0.00014, "epss_percentile": 0.01859}, "CVE-2024-46871": {"epss_score": 0.00017, "epss_percentile": 0.03329}, "CVE-2024-46872": {"epss_score": 0.00119, "epss_percentile": 0.31684}, "CVE-2024-46873": {"epss_score": 0.00171, "epss_percentile": 0.38774}, "CVE-2024-46874": {"epss_score": 0.00113, "epss_percentile": 0.30583}, "CVE-2024-46881": {"epss_score": 0.00047, "epss_percentile": 0.14669}, "CVE-2024-46886": {"epss_score": 0.00093, "epss_percentile": 0.26658}, "CVE-2024-46887": {"epss_score": 0.00183, "epss_percentile": 0.40321}, "CVE-2024-46888": {"epss_score": 0.15048, "epss_percentile": 0.9435}, "CVE-2024-46889": {"epss_score": 0.00305, "epss_percentile": 0.53319}, "CVE-2024-46890": {"epss_score": 0.02364, "epss_percentile": 0.8451}, "CVE-2024-46891": {"epss_score": 0.01072, "epss_percentile": 0.77273}, "CVE-2024-46892": {"epss_score": 0.00145, "epss_percentile": 0.35499}, "CVE-2024-46894": {"epss_score": 0.00176, "epss_percentile": 0.39409}, "CVE-2024-46895": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2024-46896": {"epss_score": 0.00036, "epss_percentile": 0.10219}, "CVE-2024-46897": {"epss_score": 0.00209, "epss_percentile": 0.43346}, "CVE-2024-46898": {"epss_score": 0.00932, "epss_percentile": 0.75623}, "CVE-2024-46899": {"epss_score": 0.0005, "epss_percentile": 0.15881}, "CVE-2024-46901": {"epss_score": 0.125, "epss_percentile": 0.93694}, "CVE-2024-46902": {"epss_score": 0.0029, "epss_percentile": 0.52082}, "CVE-2024-46903": {"epss_score": 0.00553, "epss_percentile": 0.67411}, "CVE-2024-46905": {"epss_score": 0.01481, "epss_percentile": 0.80567}, "CVE-2024-46906": {"epss_score": 0.17534, "epss_percentile": 0.94862}, "CVE-2024-46907": {"epss_score": 0.01064, "epss_percentile": 0.77197}, "CVE-2024-46908": {"epss_score": 0.01274, "epss_percentile": 0.7909}, "CVE-2024-46909": {"epss_score": 0.32725, "epss_percentile": 0.96719}, "CVE-2024-46910": {"epss_score": 0.00209, "epss_percentile": 0.43425}, "CVE-2024-46911": {"epss_score": 0.00059, "epss_percentile": 0.1893}, "CVE-2024-46916": {"epss_score": 0.00082, "epss_percentile": 0.24533}, "CVE-2024-46917": {"epss_score": 0.00042, "epss_percentile": 0.12586}, "CVE-2024-46918": {"epss_score": 0.00077, "epss_percentile": 0.23303}, "CVE-2024-46919": {"epss_score": 0.00154, "epss_percentile": 0.36679}, "CVE-2024-46920": {"epss_score": 0.00147, "epss_percentile": 0.35658}, "CVE-2024-46921": {"epss_score": 0.00113, "epss_percentile": 0.30719}, "CVE-2024-46922": {"epss_score": 0.00239, "epss_percentile": 0.46916}, "CVE-2024-46923": {"epss_score": 0.00205, "epss_percentile": 0.4275}, "CVE-2024-46933": {"epss_score": 0.00108, "epss_percentile": 0.29853}, "CVE-2024-46934": {"epss_score": 0.00084, "epss_percentile": 0.2491}, "CVE-2024-46935": {"epss_score": 0.00077, "epss_percentile": 0.23288}, "CVE-2024-46936": {"epss_score": 0.00101, "epss_percentile": 0.28631}, "CVE-2024-46937": {"epss_score": 0.0036, "epss_percentile": 0.57675}, "CVE-2024-46938": {"epss_score": 0.93306, "epss_percentile": 0.99795}, "CVE-2024-46939": {"epss_score": 0.00035, "epss_percentile": 0.09944}, "CVE-2024-46941": {"epss_score": 0.00021, "epss_percentile": 0.04884}, "CVE-2024-46942": {"epss_score": 0.00223, "epss_percentile": 0.44891}, "CVE-2024-46943": {"epss_score": 0.00268, "epss_percentile": 0.50082}, "CVE-2024-46946": {"epss_score": 0.00487, "epss_percentile": 0.64827}, "CVE-2024-46947": {"epss_score": 0.00143, "epss_percentile": 0.35182}, "CVE-2024-46948": {"epss_score": 0.0038, "epss_percentile": 0.58952}, "CVE-2024-46951": {"epss_score": 0.00102, "epss_percentile": 0.28751}, "CVE-2024-46952": {"epss_score": 0.00048, "epss_percentile": 0.15126}, "CVE-2024-46953": {"epss_score": 0.00086, "epss_percentile": 0.25429}, "CVE-2024-46954": {"epss_score": 0.0007, "epss_percentile": 0.21684}, "CVE-2024-46955": {"epss_score": 0.00047, "epss_percentile": 0.1489}, "CVE-2024-46956": {"epss_score": 0.0024, "epss_percentile": 0.47229}, "CVE-2024-46957": {"epss_score": 0.00103, "epss_percentile": 0.28984}, "CVE-2024-46958": {"epss_score": 0.00148, "epss_percentile": 0.35885}, "CVE-2024-46959": {"epss_score": 0.00087, "epss_percentile": 0.25502}, "CVE-2024-46960": {"epss_score": 0.00074, "epss_percentile": 0.22858}, "CVE-2024-46961": {"epss_score": 0.00126, "epss_percentile": 0.32754}, "CVE-2024-46962": {"epss_score": 0.00135, "epss_percentile": 0.33966}, "CVE-2024-46963": {"epss_score": 0.00147, "epss_percentile": 0.35647}, "CVE-2024-46964": {"epss_score": 0.00176, "epss_percentile": 0.39443}, "CVE-2024-46965": {"epss_score": 0.00133, "epss_percentile": 0.33712}, "CVE-2024-46966": {"epss_score": 0.00147, "epss_percentile": 0.35647}, "CVE-2024-46970": {"epss_score": 9e-05, "epss_percentile": 0.00634}, "CVE-2024-46971": {"epss_score": 0.00031, "epss_percentile": 0.08433}, "CVE-2024-46972": {"epss_score": 0.00046, "epss_percentile": 0.14467}, "CVE-2024-46973": {"epss_score": 0.00033, "epss_percentile": 0.09244}, "CVE-2024-46974": {"epss_score": 0.00028, "epss_percentile": 0.07345}, "CVE-2024-46975": {"epss_score": 0.00022, "epss_percentile": 0.05225}, "CVE-2024-46976": {"epss_score": 0.00075, "epss_percentile": 0.2301}, "CVE-2024-46977": {"epss_score": 0.00902, "epss_percentile": 0.75189}, "CVE-2024-46978": {"epss_score": 0.00875, "epss_percentile": 0.74778}, "CVE-2024-46979": {"epss_score": 0.00201, "epss_percentile": 0.42389}, "CVE-2024-46980": {"epss_score": 0.00134, "epss_percentile": 0.33775}, "CVE-2024-46981": {"epss_score": 0.64798, "epss_percentile": 0.98392}, "CVE-2024-46982": {"epss_score": 0.4612, "epss_percentile": 0.9753}, "CVE-2024-46983": {"epss_score": 0.00129, "epss_percentile": 0.33178}, "CVE-2024-46984": {"epss_score": 0.00343, "epss_percentile": 0.56464}, "CVE-2024-46985": {"epss_score": 0.00209, "epss_percentile": 0.43394}, "CVE-2024-46986": {"epss_score": 0.92152, "epss_percentile": 0.99693}, "CVE-2024-46987": {"epss_score": 0.00088, "epss_percentile": 0.2569}, "CVE-2024-46988": {"epss_score": 0.00217, "epss_percentile": 0.44314}, "CVE-2024-46989": {"epss_score": 0.0013, "epss_percentile": 0.33318}, "CVE-2024-46990": {"epss_score": 0.00125, "epss_percentile": 0.32599}, "CVE-2024-46992": {"epss_score": 0.00011, "epss_percentile": 0.00933}, "CVE-2024-46993": {"epss_score": 0.00017, "epss_percentile": 0.03481}, "CVE-2024-46994": {"epss_score": 0.00668, "epss_percentile": 0.70723}, "CVE-2024-46995": {"epss_score": 0.00642, "epss_percentile": 0.70033}, "CVE-2024-46996": {"epss_score": 0.007, "epss_percentile": 0.71462}, "CVE-2024-46997": {"epss_score": 0.14855, "epss_percentile": 0.94302}, "CVE-2024-46998": {"epss_score": 0.00786, "epss_percentile": 0.73271}, "CVE-2024-46999": {"epss_score": 0.00251, "epss_percentile": 0.48315}, "CVE-2024-47000": {"epss_score": 0.00183, "epss_percentile": 0.4036}, "CVE-2024-47001": {"epss_score": 0.00326, "epss_percentile": 0.55065}, "CVE-2024-47002": {"epss_score": 0.00199, "epss_percentile": 0.42172}, "CVE-2024-47003": {"epss_score": 0.00662, "epss_percentile": 0.70592}, "CVE-2024-47005": {"epss_score": 0.00375, "epss_percentile": 0.58623}, "CVE-2024-47006": {"epss_score": 0.00024, "epss_percentile": 0.05731}, "CVE-2024-47007": {"epss_score": 0.03842, "epss_percentile": 0.87832}, "CVE-2024-47008": {"epss_score": 0.431, "epss_percentile": 0.97369}, "CVE-2024-47009": {"epss_score": 0.00373, "epss_percentile": 0.58522}, "CVE-2024-47010": {"epss_score": 0.01159, "epss_percentile": 0.78127}, "CVE-2024-47011": {"epss_score": 0.3998, "epss_percentile": 0.97189}, "CVE-2024-47012": {"epss_score": 0.00022, "epss_percentile": 0.05018}, "CVE-2024-47013": {"epss_score": 0.00029, "epss_percentile": 0.0794}, "CVE-2024-47014": {"epss_score": 0.00141, "epss_percentile": 0.34922}, "CVE-2024-47015": {"epss_score": 0.0005, "epss_percentile": 0.15855}, "CVE-2024-47016": {"epss_score": 0.00029, "epss_percentile": 0.0794}, "CVE-2024-47017": {"epss_score": 0.00037, "epss_percentile": 0.10778}, "CVE-2024-47018": {"epss_score": 0.00065, "epss_percentile": 0.20626}, "CVE-2024-47019": {"epss_score": 0.0005, "epss_percentile": 0.15855}, "CVE-2024-47020": {"epss_score": 0.00124, "epss_percentile": 0.324}, "CVE-2024-47021": {"epss_score": 0.00486, "epss_percentile": 0.6477}, "CVE-2024-47022": {"epss_score": 0.00124, "epss_percentile": 0.324}, "CVE-2024-47023": {"epss_score": 0.0196, "epss_percentile": 0.83057}, "CVE-2024-47024": {"epss_score": 0.00035, "epss_percentile": 0.09812}, "CVE-2024-47025": {"epss_score": 0.00054, "epss_percentile": 0.17347}, "CVE-2024-47026": {"epss_score": 0.00055, "epss_percentile": 0.17615}, "CVE-2024-47027": {"epss_score": 0.00023, "epss_percentile": 0.05651}, "CVE-2024-47028": {"epss_score": 0.00037, "epss_percentile": 0.10889}, "CVE-2024-47029": {"epss_score": 0.00055, "epss_percentile": 0.17615}, "CVE-2024-47030": {"epss_score": 0.00102, "epss_percentile": 0.28784}, "CVE-2024-47031": {"epss_score": 0.00097, "epss_percentile": 0.27464}, "CVE-2024-47032": {"epss_score": 0.0001, "epss_percentile": 0.0082}, "CVE-2024-47033": {"epss_score": 0.00035, "epss_percentile": 0.10015}, "CVE-2024-47034": {"epss_score": 0.00055, "epss_percentile": 0.17615}, "CVE-2024-47035": {"epss_score": 0.00047, "epss_percentile": 0.14637}, "CVE-2024-47038": {"epss_score": 0.00071, "epss_percentile": 0.22044}, "CVE-2024-47039": {"epss_score": 0.00067, "epss_percentile": 0.20997}, "CVE-2024-47040": {"epss_score": 0.00096, "epss_percentile": 0.27351}, "CVE-2024-47041": {"epss_score": 0.00045, "epss_percentile": 0.13929}, "CVE-2024-47043": {"epss_score": 0.00138, "epss_percentile": 0.34372}, "CVE-2024-47044": {"epss_score": 0.00167, "epss_percentile": 0.38273}, "CVE-2024-47045": {"epss_score": 0.0004, "epss_percentile": 0.11916}, "CVE-2024-47046": {"epss_score": 0.00126, "epss_percentile": 0.3275}, "CVE-2024-47047": {"epss_score": 0.00302, "epss_percentile": 0.53109}, "CVE-2024-47048": {"epss_score": 0.00078, "epss_percentile": 0.23775}, "CVE-2024-47049": {"epss_score": 0.00234, "epss_percentile": 0.46194}, "CVE-2024-47050": {"epss_score": 0.00642, "epss_percentile": 0.70033}, "CVE-2024-47051": {"epss_score": 0.00738, "epss_percentile": 0.72334}, "CVE-2024-47053": {"epss_score": 0.00144, "epss_percentile": 0.35245}, "CVE-2024-47055": {"epss_score": 0.00047, "epss_percentile": 0.14862}, "CVE-2024-47056": {"epss_score": 0.00017, "epss_percentile": 0.03414}, "CVE-2024-47057": {"epss_score": 0.00055, "epss_percentile": 0.17593}, "CVE-2024-47058": {"epss_score": 0.00186, "epss_percentile": 0.40642}, "CVE-2024-47059": {"epss_score": 0.00311, "epss_percentile": 0.53827}, "CVE-2024-47060": {"epss_score": 0.00181, "epss_percentile": 0.40059}, "CVE-2024-47061": {"epss_score": 0.00099, "epss_percentile": 0.2838}, "CVE-2024-47062": {"epss_score": 0.84655, "epss_percentile": 0.99299}, "CVE-2024-47063": {"epss_score": 0.00543, "epss_percentile": 0.67112}, "CVE-2024-47064": {"epss_score": 0.00691, "epss_percentile": 0.71261}, "CVE-2024-47065": {"epss_score": 0.0002, "epss_percentile": 0.04492}, "CVE-2024-47066": {"epss_score": 0.06151, "epss_percentile": 0.90521}, "CVE-2024-47067": {"epss_score": 0.00127, "epss_percentile": 0.32843}, "CVE-2024-47068": {"epss_score": 0.01368, "epss_percentile": 0.79786}, "CVE-2024-47069": {"epss_score": 0.00643, "epss_percentile": 0.70055}, "CVE-2024-47070": {"epss_score": 0.00083, "epss_percentile": 0.24618}, "CVE-2024-47071": {"epss_score": 0.00098, "epss_percentile": 0.27812}, "CVE-2024-47072": {"epss_score": 0.00354, "epss_percentile": 0.57247}, "CVE-2024-47073": {"epss_score": 0.49743, "epss_percentile": 0.97704}, "CVE-2024-47074": {"epss_score": 0.00732, "epss_percentile": 0.722}, "CVE-2024-47075": {"epss_score": 0.00977, "epss_percentile": 0.7623}, "CVE-2024-47076": {"epss_score": 0.73875, "epss_percentile": 0.98775}, "CVE-2024-47077": {"epss_score": 0.00281, "epss_percentile": 0.51128}, "CVE-2024-47078": {"epss_score": 0.00038, "epss_percentile": 0.11304}, "CVE-2024-47079": {"epss_score": 0.00176, "epss_percentile": 0.39383}, "CVE-2024-47080": {"epss_score": 0.00327, "epss_percentile": 0.55112}, "CVE-2024-47081": {"epss_score": 0.00103, "epss_percentile": 0.28961}, "CVE-2024-47082": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2024-47083": {"epss_score": 0.02093, "epss_percentile": 0.83575}, "CVE-2024-47084": {"epss_score": 0.00102, "epss_percentile": 0.2872}, "CVE-2024-47085": {"epss_score": 0.00107, "epss_percentile": 0.29667}, "CVE-2024-47086": {"epss_score": 0.00096, "epss_percentile": 0.27358}, "CVE-2024-47087": {"epss_score": 0.0014, "epss_percentile": 0.34725}, "CVE-2024-47088": {"epss_score": 0.01193, "epss_percentile": 0.78411}, "CVE-2024-47089": {"epss_score": 0.00092, "epss_percentile": 0.26487}, "CVE-2024-47090": {"epss_score": 0.00036, "epss_percentile": 0.10492}, "CVE-2024-47092": {"epss_score": 0.00152, "epss_percentile": 0.36435}, "CVE-2024-47093": {"epss_score": 0.00201, "epss_percentile": 0.42323}, "CVE-2024-47094": {"epss_score": 0.00054, "epss_percentile": 0.17108}, "CVE-2024-47095": {"epss_score": 0.00664, "epss_percentile": 0.70646}, "CVE-2024-47100": {"epss_score": 0.00054, "epss_percentile": 0.17335}, "CVE-2024-47102": {"epss_score": 0.00016, "epss_percentile": 0.02824}, "CVE-2024-47103": {"epss_score": 0.00048, "epss_percentile": 0.15218}, "CVE-2024-47104": {"epss_score": 0.0007, "epss_percentile": 0.21664}, "CVE-2024-47106": {"epss_score": 0.00087, "epss_percentile": 0.25445}, "CVE-2024-47107": {"epss_score": 0.00055, "epss_percentile": 0.17485}, "CVE-2024-47109": {"epss_score": 0.00081, "epss_percentile": 0.24326}, "CVE-2024-47113": {"epss_score": 0.00114, "epss_percentile": 0.30805}, "CVE-2024-47115": {"epss_score": 0.00044, "epss_percentile": 0.13489}, "CVE-2024-47116": {"epss_score": 0.00044, "epss_percentile": 0.13456}, "CVE-2024-47117": {"epss_score": 0.00144, "epss_percentile": 0.35296}, "CVE-2024-47118": {"epss_score": 0.00054, "epss_percentile": 0.17081}, "CVE-2024-47119": {"epss_score": 0.00045, "epss_percentile": 0.13945}, "CVE-2024-47120": {"epss_score": 0.00021, "epss_percentile": 0.0472}, "CVE-2024-47121": {"epss_score": 0.00075, "epss_percentile": 0.22903}, "CVE-2024-47122": {"epss_score": 0.001, "epss_percentile": 0.2847}, "CVE-2024-47123": {"epss_score": 0.00054, "epss_percentile": 0.1734}, "CVE-2024-47124": {"epss_score": 0.00026, "epss_percentile": 0.06562}, "CVE-2024-47125": {"epss_score": 0.00068, "epss_percentile": 0.2135}, "CVE-2024-47126": {"epss_score": 0.0006, "epss_percentile": 0.19013}, "CVE-2024-47127": {"epss_score": 0.00056, "epss_percentile": 0.17781}, "CVE-2024-47128": {"epss_score": 0.00053, "epss_percentile": 0.16846}, "CVE-2024-47129": {"epss_score": 0.00056, "epss_percentile": 0.17742}, "CVE-2024-47130": {"epss_score": 0.00131, "epss_percentile": 0.33379}, "CVE-2024-47131": {"epss_score": 0.00182, "epss_percentile": 0.40198}, "CVE-2024-47133": {"epss_score": 0.0035, "epss_percentile": 0.5695}, "CVE-2024-47134": {"epss_score": 0.0017, "epss_percentile": 0.38674}, "CVE-2024-47135": {"epss_score": 0.00156, "epss_percentile": 0.3697}, "CVE-2024-47136": {"epss_score": 0.00222, "epss_percentile": 0.44775}, "CVE-2024-47137": {"epss_score": 0.00071, "epss_percentile": 0.22182}, "CVE-2024-47138": {"epss_score": 0.00443, "epss_percentile": 0.62793}, "CVE-2024-47139": {"epss_score": 0.0056, "epss_percentile": 0.67629}, "CVE-2024-47140": {"epss_score": 0.00197, "epss_percentile": 0.41869}, "CVE-2024-47141": {"epss_score": 0.00019, "epss_percentile": 0.04378}, "CVE-2024-47142": {"epss_score": 0.00043, "epss_percentile": 0.13174}, "CVE-2024-47143": {"epss_score": 0.00029, "epss_percentile": 0.07691}, "CVE-2024-47145": {"epss_score": 0.00204, "epss_percentile": 0.4265}, "CVE-2024-47146": {"epss_score": 0.00069, "epss_percentile": 0.21476}, "CVE-2024-47148": {"epss_score": 0.00034, "epss_percentile": 0.09451}, "CVE-2024-47149": {"epss_score": 0.00038, "epss_percentile": 0.11058}, "CVE-2024-47150": {"epss_score": 0.00043, "epss_percentile": 0.13057}, "CVE-2024-47151": {"epss_score": 0.00029, "epss_percentile": 0.07645}, "CVE-2024-47153": {"epss_score": 0.00043, "epss_percentile": 0.13057}, "CVE-2024-47154": {"epss_score": 0.00043, "epss_percentile": 0.13057}, "CVE-2024-47155": {"epss_score": 0.00043, "epss_percentile": 0.13057}, "CVE-2024-47156": {"epss_score": 0.00043, "epss_percentile": 0.13057}, "CVE-2024-47157": {"epss_score": 0.00025, "epss_percentile": 0.06332}, "CVE-2024-47158": {"epss_score": 0.00125, "epss_percentile": 0.32509}, "CVE-2024-47159": {"epss_score": 5e-05, "epss_percentile": 0.00175}, "CVE-2024-47160": {"epss_score": 3e-05, "epss_percentile": 0.00101}, "CVE-2024-47161": {"epss_score": 4e-05, "epss_percentile": 0.00143}, "CVE-2024-47162": {"epss_score": 4e-05, "epss_percentile": 0.00124}, "CVE-2024-47164": {"epss_score": 0.00149, "epss_percentile": 0.35958}, "CVE-2024-47165": {"epss_score": 0.00124, "epss_percentile": 0.32343}, "CVE-2024-47166": {"epss_score": 0.0018, "epss_percentile": 0.39966}, "CVE-2024-47167": {"epss_score": 0.00174, "epss_percentile": 0.39155}, "CVE-2024-47168": {"epss_score": 0.00117, "epss_percentile": 0.31211}, "CVE-2024-47169": {"epss_score": 0.00848, "epss_percentile": 0.74362}, "CVE-2024-47170": {"epss_score": 0.00568, "epss_percentile": 0.67892}, "CVE-2024-47171": {"epss_score": 0.00369, "epss_percentile": 0.58264}, "CVE-2024-47172": {"epss_score": 0.00243, "epss_percentile": 0.47413}, "CVE-2024-47173": {"epss_score": 0.00077, "epss_percentile": 0.23521}, "CVE-2024-47174": {"epss_score": 0.00071, "epss_percentile": 0.22173}, "CVE-2024-47175": {"epss_score": 0.31529, "epss_percentile": 0.96625}, "CVE-2024-47176": {"epss_score": 0.87593, "epss_percentile": 0.99434}, "CVE-2024-47178": {"epss_score": 0.00132, "epss_percentile": 0.33617}, "CVE-2024-47179": {"epss_score": 0.00254, "epss_percentile": 0.48538}, "CVE-2024-47180": {"epss_score": 0.02958, "epss_percentile": 0.86066}, "CVE-2024-47181": {"epss_score": 0.0007, "epss_percentile": 0.21649}, "CVE-2024-47182": {"epss_score": 0.00146, "epss_percentile": 0.35627}, "CVE-2024-47183": {"epss_score": 0.00282, "epss_percentile": 0.51282}, "CVE-2024-47184": {"epss_score": 0.01046, "epss_percentile": 0.77029}, "CVE-2024-47186": {"epss_score": 0.00803, "epss_percentile": 0.73596}, "CVE-2024-47187": {"epss_score": 0.00059, "epss_percentile": 0.18711}, "CVE-2024-47188": {"epss_score": 0.0012, "epss_percentile": 0.31717}, "CVE-2024-47189": {"epss_score": 0.00658, "epss_percentile": 0.70491}, "CVE-2024-47190": {"epss_score": 0.00123, "epss_percentile": 0.32308}, "CVE-2024-47191": {"epss_score": 0.00042, "epss_percentile": 0.129}, "CVE-2024-47192": {"epss_score": 0.00023, "epss_percentile": 0.05453}, "CVE-2024-47193": {"epss_score": 0.00133, "epss_percentile": 0.33633}, "CVE-2024-47194": {"epss_score": 0.00043, "epss_percentile": 0.13363}, "CVE-2024-47195": {"epss_score": 0.00043, "epss_percentile": 0.13363}, "CVE-2024-47196": {"epss_score": 0.0007, "epss_percentile": 0.21823}, "CVE-2024-47197": {"epss_score": 0.00071, "epss_percentile": 0.2205}, "CVE-2024-47208": {"epss_score": 0.00417, "epss_percentile": 0.61244}, "CVE-2024-47210": {"epss_score": 0.00151, "epss_percentile": 0.36193}, "CVE-2024-47211": {"epss_score": 0.00184, "epss_percentile": 0.40417}, "CVE-2024-47212": {"epss_score": 0.00102, "epss_percentile": 0.28797}, "CVE-2024-47213": {"epss_score": 0.00102, "epss_percentile": 0.28797}, "CVE-2024-47214": {"epss_score": 0.00102, "epss_percentile": 0.28797}, "CVE-2024-47215": {"epss_score": 0.00102, "epss_percentile": 0.28797}, "CVE-2024-47217": {"epss_score": 0.00101, "epss_percentile": 0.28654}, "CVE-2024-47218": {"epss_score": 0.00034, "epss_percentile": 0.09572}, "CVE-2024-47219": {"epss_score": 0.00697, "epss_percentile": 0.71399}, "CVE-2024-47220": {"epss_score": 0.00079, "epss_percentile": 0.23987}, "CVE-2024-47221": {"epss_score": 0.00103, "epss_percentile": 0.28983}, "CVE-2024-47222": {"epss_score": 0.00133, "epss_percentile": 0.33704}, "CVE-2024-47223": {"epss_score": 0.00384, "epss_percentile": 0.59141}, "CVE-2024-47224": {"epss_score": 0.00502, "epss_percentile": 0.65412}, "CVE-2024-47226": {"epss_score": 0.00066, "epss_percentile": 0.20945}, "CVE-2024-47227": {"epss_score": 0.00501, "epss_percentile": 0.6535}, "CVE-2024-47238": {"epss_score": 0.00028, "epss_percentile": 0.07276}, "CVE-2024-47239": {"epss_score": 0.00242, "epss_percentile": 0.47395}, "CVE-2024-47240": {"epss_score": 0.00079, "epss_percentile": 0.23955}, "CVE-2024-47241": {"epss_score": 0.00068, "epss_percentile": 0.21371}, "CVE-2024-47248": {"epss_score": 0.00037, "epss_percentile": 0.10729}, "CVE-2024-47249": {"epss_score": 0.00021, "epss_percentile": 0.04784}, "CVE-2024-47250": {"epss_score": 0.00025, "epss_percentile": 0.06222}, "CVE-2024-47252": {"epss_score": 0.00112, "epss_percentile": 0.30553}, "CVE-2024-47253": {"epss_score": 0.04641, "epss_percentile": 0.88952}, "CVE-2024-47254": {"epss_score": 0.00159, "epss_percentile": 0.3736}, "CVE-2024-47255": {"epss_score": 0.00022, "epss_percentile": 0.05308}, "CVE-2024-47256": {"epss_score": 0.00033, "epss_percentile": 0.09392}, "CVE-2024-47257": {"epss_score": 0.00068, "epss_percentile": 0.21218}, "CVE-2024-47258": {"epss_score": 0.00029, "epss_percentile": 0.07614}, "CVE-2024-47259": {"epss_score": 0.00334, "epss_percentile": 0.55718}, "CVE-2024-47260": {"epss_score": 0.00128, "epss_percentile": 0.3305}, "CVE-2024-47261": {"epss_score": 0.00117, "epss_percentile": 0.31381}, "CVE-2024-47262": {"epss_score": 0.00152, "epss_percentile": 0.3637}, "CVE-2024-47264": {"epss_score": 0.00379, "epss_percentile": 0.58898}, "CVE-2024-47265": {"epss_score": 0.00093, "epss_percentile": 0.26654}, "CVE-2024-47266": {"epss_score": 0.0009, "epss_percentile": 0.26064}, "CVE-2024-47290": {"epss_score": 0.00059, "epss_percentile": 0.18913}, "CVE-2024-47291": {"epss_score": 0.00037, "epss_percentile": 0.10736}, "CVE-2024-47292": {"epss_score": 0.00126, "epss_percentile": 0.32772}, "CVE-2024-47293": {"epss_score": 0.00068, "epss_percentile": 0.21389}, "CVE-2024-47294": {"epss_score": 0.0009, "epss_percentile": 0.2608}, "CVE-2024-47295": {"epss_score": 0.00939, "epss_percentile": 0.75717}, "CVE-2024-47297": {"epss_score": 0.0016, "epss_percentile": 0.37433}, "CVE-2024-47298": {"epss_score": 0.00109, "epss_percentile": 0.30061}, "CVE-2024-47299": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-47300": {"epss_score": 0.00125, "epss_percentile": 0.32592}, "CVE-2024-47301": {"epss_score": 0.0016, "epss_percentile": 0.37433}, "CVE-2024-47302": {"epss_score": 0.00421, "epss_percentile": 0.61512}, "CVE-2024-47303": {"epss_score": 0.00081, "epss_percentile": 0.24298}, "CVE-2024-47304": {"epss_score": 0.00349, "epss_percentile": 0.56853}, "CVE-2024-47305": {"epss_score": 0.002, "epss_percentile": 0.42255}, "CVE-2024-47306": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47307": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47308": {"epss_score": 0.40912, "epss_percentile": 0.97243}, "CVE-2024-47309": {"epss_score": 0.00331, "epss_percentile": 0.55541}, "CVE-2024-47310": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47311": {"epss_score": 0.00465, "epss_percentile": 0.63771}, "CVE-2024-47312": {"epss_score": 0.00332, "epss_percentile": 0.55571}, "CVE-2024-47313": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-47314": {"epss_score": 0.00718, "epss_percentile": 0.7192}, "CVE-2024-47315": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-47316": {"epss_score": 0.00069, "epss_percentile": 0.21611}, "CVE-2024-47317": {"epss_score": 0.00504, "epss_percentile": 0.65487}, "CVE-2024-47318": {"epss_score": 0.00414, "epss_percentile": 0.6104}, "CVE-2024-47319": {"epss_score": 0.00349, "epss_percentile": 0.56913}, "CVE-2024-47320": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47321": {"epss_score": 0.00304, "epss_percentile": 0.53271}, "CVE-2024-47322": {"epss_score": 0.00115, "epss_percentile": 0.309}, "CVE-2024-47323": {"epss_score": 0.005, "epss_percentile": 0.65304}, "CVE-2024-47324": {"epss_score": 0.0052, "epss_percentile": 0.66193}, "CVE-2024-47325": {"epss_score": 0.00618, "epss_percentile": 0.69385}, "CVE-2024-47326": {"epss_score": 0.0016, "epss_percentile": 0.37433}, "CVE-2024-47327": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47328": {"epss_score": 0.00471, "epss_percentile": 0.64002}, "CVE-2024-47329": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47330": {"epss_score": 0.00301, "epss_percentile": 0.53049}, "CVE-2024-47331": {"epss_score": 0.00177, "epss_percentile": 0.39595}, "CVE-2024-47332": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47333": {"epss_score": 0.00125, "epss_percentile": 0.32592}, "CVE-2024-47334": {"epss_score": 0.00225, "epss_percentile": 0.45231}, "CVE-2024-47335": {"epss_score": 0.00343, "epss_percentile": 0.56437}, "CVE-2024-47336": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-47337": {"epss_score": 0.00133, "epss_percentile": 0.33736}, "CVE-2024-47338": {"epss_score": 0.00352, "epss_percentile": 0.57085}, "CVE-2024-47339": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47340": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47341": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47342": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47343": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47344": {"epss_score": 0.00311, "epss_percentile": 0.53811}, "CVE-2024-47345": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-47346": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47347": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47348": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47349": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47350": {"epss_score": 0.00191, "epss_percentile": 0.4121}, "CVE-2024-47351": {"epss_score": 0.00732, "epss_percentile": 0.72187}, "CVE-2024-47352": {"epss_score": 0.00125, "epss_percentile": 0.32592}, "CVE-2024-47353": {"epss_score": 0.00202, "epss_percentile": 0.42475}, "CVE-2024-47354": {"epss_score": 0.00178, "epss_percentile": 0.39723}, "CVE-2024-47355": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47356": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-47357": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47358": {"epss_score": 0.00586, "epss_percentile": 0.68441}, "CVE-2024-47359": {"epss_score": 0.0043, "epss_percentile": 0.62023}, "CVE-2024-47360": {"epss_score": 0.00157, "epss_percentile": 0.37055}, "CVE-2024-47361": {"epss_score": 0.00485, "epss_percentile": 0.64712}, "CVE-2024-47362": {"epss_score": 0.00595, "epss_percentile": 0.68689}, "CVE-2024-47363": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47364": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47365": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47366": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47367": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47368": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47369": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47370": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47371": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-47372": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-47373": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47374": {"epss_score": 0.19283, "epss_percentile": 0.9516}, "CVE-2024-47375": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47376": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-47377": {"epss_score": 0.00069, "epss_percentile": 0.21495}, "CVE-2024-47378": {"epss_score": 0.00202, "epss_percentile": 0.42471}, "CVE-2024-47379": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47380": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47381": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-47382": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47383": {"epss_score": 0.00078, "epss_percentile": 0.2377}, "CVE-2024-47384": {"epss_score": 0.00123, "epss_percentile": 0.32253}, "CVE-2024-47385": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47386": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47387": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-47388": {"epss_score": 0.0016, "epss_percentile": 0.37433}, "CVE-2024-47389": {"epss_score": 0.00202, "epss_percentile": 0.42471}, "CVE-2024-47390": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47391": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47392": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47393": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47394": {"epss_score": 0.0016, "epss_percentile": 0.37433}, "CVE-2024-47395": {"epss_score": 0.00115, "epss_percentile": 0.309}, "CVE-2024-47396": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47397": {"epss_score": 0.00138, "epss_percentile": 0.34444}, "CVE-2024-47398": {"epss_score": 0.00035, "epss_percentile": 0.10036}, "CVE-2024-47401": {"epss_score": 0.00182, "epss_percentile": 0.40184}, "CVE-2024-47402": {"epss_score": 0.00066, "epss_percentile": 0.20892}, "CVE-2024-47404": {"epss_score": 0.00071, "epss_percentile": 0.22182}, "CVE-2024-47406": {"epss_score": 0.00389, "epss_percentile": 0.5945}, "CVE-2024-47407": {"epss_score": 0.30021, "epss_percentile": 0.96497}, "CVE-2024-47408": {"epss_score": 0.00039, "epss_percentile": 0.11552}, "CVE-2024-47410": {"epss_score": 0.00147, "epss_percentile": 0.35687}, "CVE-2024-47411": {"epss_score": 0.00162, "epss_percentile": 0.37699}, "CVE-2024-47412": {"epss_score": 0.00181, "epss_percentile": 0.40096}, "CVE-2024-47413": {"epss_score": 0.00181, "epss_percentile": 0.40096}, "CVE-2024-47414": {"epss_score": 0.00181, "epss_percentile": 0.40096}, "CVE-2024-47415": {"epss_score": 0.00181, "epss_percentile": 0.40096}, "CVE-2024-47416": {"epss_score": 0.00162, "epss_percentile": 0.37699}, "CVE-2024-47417": {"epss_score": 0.00147, "epss_percentile": 0.35687}, "CVE-2024-47418": {"epss_score": 0.00181, "epss_percentile": 0.40096}, "CVE-2024-47419": {"epss_score": 0.00039, "epss_percentile": 0.1144}, "CVE-2024-47420": {"epss_score": 0.00039, "epss_percentile": 0.1144}, "CVE-2024-47421": {"epss_score": 0.00117, "epss_percentile": 0.31304}, "CVE-2024-47422": {"epss_score": 0.00084, "epss_percentile": 0.24958}, "CVE-2024-47423": {"epss_score": 0.00139, "epss_percentile": 0.34665}, "CVE-2024-47424": {"epss_score": 0.00162, "epss_percentile": 0.37699}, "CVE-2024-47425": {"epss_score": 0.00162, "epss_percentile": 0.37699}, "CVE-2024-47426": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-47427": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-47428": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-47429": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-47430": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-47431": {"epss_score": 0.00173, "epss_percentile": 0.39046}, "CVE-2024-47432": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-47433": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-47434": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-47435": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-47436": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-47437": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-47438": {"epss_score": 0.00159, "epss_percentile": 0.37341}, "CVE-2024-47439": {"epss_score": 0.00113, "epss_percentile": 0.30637}, "CVE-2024-47440": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-47441": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2024-47442": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2024-47443": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2024-47444": {"epss_score": 0.0003, "epss_percentile": 0.08144}, "CVE-2024-47445": {"epss_score": 0.0003, "epss_percentile": 0.08144}, "CVE-2024-47446": {"epss_score": 0.0003, "epss_percentile": 0.08144}, "CVE-2024-47449": {"epss_score": 0.00023, "epss_percentile": 0.0545}, "CVE-2024-47450": {"epss_score": 0.00173, "epss_percentile": 0.39046}, "CVE-2024-47451": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-47452": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-47453": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-47454": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-47455": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-47456": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2024-47457": {"epss_score": 0.00116, "epss_percentile": 0.3113}, "CVE-2024-47458": {"epss_score": 0.00116, "epss_percentile": 0.3113}, "CVE-2024-47459": {"epss_score": 0.00113, "epss_percentile": 0.30637}, "CVE-2024-47460": {"epss_score": 0.01668, "epss_percentile": 0.81663}, "CVE-2024-47461": {"epss_score": 0.00203, "epss_percentile": 0.4253}, "CVE-2024-47462": {"epss_score": 0.01033, "epss_percentile": 0.76877}, "CVE-2024-47463": {"epss_score": 0.01033, "epss_percentile": 0.76877}, "CVE-2024-47464": {"epss_score": 0.00078, "epss_percentile": 0.23796}, "CVE-2024-47475": {"epss_score": 0.00055, "epss_percentile": 0.17428}, "CVE-2024-47476": {"epss_score": 0.0003, "epss_percentile": 0.07988}, "CVE-2024-47480": {"epss_score": 0.00045, "epss_percentile": 0.13768}, "CVE-2024-47481": {"epss_score": 0.00194, "epss_percentile": 0.41574}, "CVE-2024-47483": {"epss_score": 0.00105, "epss_percentile": 0.29281}, "CVE-2024-47484": {"epss_score": 0.01291, "epss_percentile": 0.79229}, "CVE-2024-47485": {"epss_score": 0.00594, "epss_percentile": 0.68672}, "CVE-2024-47486": {"epss_score": 0.00663, "epss_percentile": 0.70621}, "CVE-2024-47487": {"epss_score": 0.00451, "epss_percentile": 0.63148}, "CVE-2024-47489": {"epss_score": 0.00073, "epss_percentile": 0.22562}, "CVE-2024-47490": {"epss_score": 0.00099, "epss_percentile": 0.28397}, "CVE-2024-47491": {"epss_score": 0.00157, "epss_percentile": 0.37096}, "CVE-2024-47493": {"epss_score": 0.00031, "epss_percentile": 0.08336}, "CVE-2024-47494": {"epss_score": 0.00098, "epss_percentile": 0.27722}, "CVE-2024-47495": {"epss_score": 5e-05, "epss_percentile": 0.00199}, "CVE-2024-47496": {"epss_score": 0.00053, "epss_percentile": 0.16753}, "CVE-2024-47497": {"epss_score": 0.00157, "epss_percentile": 0.37124}, "CVE-2024-47498": {"epss_score": 0.00057, "epss_percentile": 0.18052}, "CVE-2024-47499": {"epss_score": 0.00254, "epss_percentile": 0.48545}, "CVE-2024-47501": {"epss_score": 0.00054, "epss_percentile": 0.17295}, "CVE-2024-47502": {"epss_score": 0.00254, "epss_percentile": 0.48545}, "CVE-2024-47503": {"epss_score": 0.00043, "epss_percentile": 0.13139}, "CVE-2024-47504": {"epss_score": 0.00158, "epss_percentile": 0.37259}, "CVE-2024-47505": {"epss_score": 0.0013, "epss_percentile": 0.33324}, "CVE-2024-47506": {"epss_score": 0.00106, "epss_percentile": 0.29533}, "CVE-2024-47507": {"epss_score": 0.00174, "epss_percentile": 0.39205}, "CVE-2024-47508": {"epss_score": 0.0013, "epss_percentile": 0.33324}, "CVE-2024-47509": {"epss_score": 0.0013, "epss_percentile": 0.33324}, "CVE-2024-47515": {"epss_score": 0.00225, "epss_percentile": 0.45137}, "CVE-2024-47516": {"epss_score": 0.01325, "epss_percentile": 0.79476}, "CVE-2024-47517": {"epss_score": 0.00091, "epss_percentile": 0.26278}, "CVE-2024-47518": {"epss_score": 0.00136, "epss_percentile": 0.34197}, "CVE-2024-47519": {"epss_score": 0.00119, "epss_percentile": 0.31664}, "CVE-2024-47520": {"epss_score": 0.00166, "epss_percentile": 0.38271}, "CVE-2024-47522": {"epss_score": 0.00617, "epss_percentile": 0.69349}, "CVE-2024-47523": {"epss_score": 0.0028, "epss_percentile": 0.51011}, "CVE-2024-47524": {"epss_score": 0.00035, "epss_percentile": 0.10133}, "CVE-2024-47525": {"epss_score": 0.06404, "epss_percentile": 0.90731}, "CVE-2024-47526": {"epss_score": 0.00137, "epss_percentile": 0.34305}, "CVE-2024-47527": {"epss_score": 0.0028, "epss_percentile": 0.51011}, "CVE-2024-47528": {"epss_score": 0.00287, "epss_percentile": 0.51862}, "CVE-2024-47529": {"epss_score": 0.00893, "epss_percentile": 0.75074}, "CVE-2024-47530": {"epss_score": 0.00091, "epss_percentile": 0.26284}, "CVE-2024-47531": {"epss_score": 0.00053, "epss_percentile": 0.16848}, "CVE-2024-47532": {"epss_score": 0.00645, "epss_percentile": 0.70102}, "CVE-2024-47533": {"epss_score": 0.68594, "epss_percentile": 0.98556}, "CVE-2024-47534": {"epss_score": 0.0025, "epss_percentile": 0.48252}, "CVE-2024-47535": {"epss_score": 0.00198, "epss_percentile": 0.42064}, "CVE-2024-47536": {"epss_score": 0.00803, "epss_percentile": 0.73605}, "CVE-2024-47537": {"epss_score": 0.0035, "epss_percentile": 0.56917}, "CVE-2024-47538": {"epss_score": 0.0037, "epss_percentile": 0.5828}, "CVE-2024-47539": {"epss_score": 0.0035, "epss_percentile": 0.56917}, "CVE-2024-47540": {"epss_score": 0.01227, "epss_percentile": 0.78698}, "CVE-2024-47541": {"epss_score": 0.0043, "epss_percentile": 0.62002}, "CVE-2024-47542": {"epss_score": 0.00316, "epss_percentile": 0.54288}, "CVE-2024-47543": {"epss_score": 0.00397, "epss_percentile": 0.59968}, "CVE-2024-47544": {"epss_score": 0.00292, "epss_percentile": 0.52258}, "CVE-2024-47545": {"epss_score": 0.00292, "epss_percentile": 0.52258}, "CVE-2024-47546": {"epss_score": 0.00292, "epss_percentile": 0.52258}, "CVE-2024-47547": {"epss_score": 0.00151, "epss_percentile": 0.36254}, "CVE-2024-47549": {"epss_score": 0.00414, "epss_percentile": 0.611}, "CVE-2024-47550": {"epss_score": 0.00013, "epss_percentile": 0.01699}, "CVE-2024-47552": {"epss_score": 0.00127, "epss_percentile": 0.3288}, "CVE-2024-47553": {"epss_score": 0.02814, "epss_percentile": 0.85726}, "CVE-2024-47554": {"epss_score": 0.00173, "epss_percentile": 0.39054}, "CVE-2024-47555": {"epss_score": 0.00095, "epss_percentile": 0.27238}, "CVE-2024-47556": {"epss_score": 0.00722, "epss_percentile": 0.72}, "CVE-2024-47557": {"epss_score": 0.00722, "epss_percentile": 0.72}, "CVE-2024-47558": {"epss_score": 0.00374, "epss_percentile": 0.5856}, "CVE-2024-47559": {"epss_score": 0.00374, "epss_percentile": 0.5856}, "CVE-2024-47560": {"epss_score": 0.00048, "epss_percentile": 0.15278}, "CVE-2024-47561": {"epss_score": 0.00543, "epss_percentile": 0.67093}, "CVE-2024-47562": {"epss_score": 0.00107, "epss_percentile": 0.29579}, "CVE-2024-47563": {"epss_score": 0.00222, "epss_percentile": 0.44718}, "CVE-2024-47565": {"epss_score": 0.00123, "epss_percentile": 0.32234}, "CVE-2024-47566": {"epss_score": 0.00119, "epss_percentile": 0.31599}, "CVE-2024-47569": {"epss_score": 0.00025, "epss_percentile": 0.06044}, "CVE-2024-47570": {"epss_score": 0.00058, "epss_percentile": 0.18457}, "CVE-2024-47571": {"epss_score": 0.00488, "epss_percentile": 0.64861}, "CVE-2024-47572": {"epss_score": 0.00209, "epss_percentile": 0.43425}, "CVE-2024-47573": {"epss_score": 0.00059, "epss_percentile": 0.18861}, "CVE-2024-47574": {"epss_score": 0.00025, "epss_percentile": 0.06164}, "CVE-2024-47575": {"epss_score": 0.93846, "epss_percentile": 0.99857}, "CVE-2024-47576": {"epss_score": 0.00026, "epss_percentile": 0.06718}, "CVE-2024-47577": {"epss_score": 0.00065, "epss_percentile": 0.20594}, "CVE-2024-47578": {"epss_score": 0.00168, "epss_percentile": 0.38452}, "CVE-2024-47579": {"epss_score": 0.00138, "epss_percentile": 0.344}, "CVE-2024-47580": {"epss_score": 0.00138, "epss_percentile": 0.344}, "CVE-2024-47581": {"epss_score": 0.00083, "epss_percentile": 0.2481}, "CVE-2024-47582": {"epss_score": 0.0013, "epss_percentile": 0.33303}, "CVE-2024-47585": {"epss_score": 0.0008, "epss_percentile": 0.24009}, "CVE-2024-47586": {"epss_score": 0.002, "epss_percentile": 0.42264}, "CVE-2024-47587": {"epss_score": 0.00078, "epss_percentile": 0.23624}, "CVE-2024-47588": {"epss_score": 0.00035, "epss_percentile": 0.09978}, "CVE-2024-47590": {"epss_score": 0.00494, "epss_percentile": 0.65068}, "CVE-2024-47592": {"epss_score": 0.00133, "epss_percentile": 0.3363}, "CVE-2024-47593": {"epss_score": 0.00162, "epss_percentile": 0.37702}, "CVE-2024-47594": {"epss_score": 0.00452, "epss_percentile": 0.63196}, "CVE-2024-47595": {"epss_score": 0.00088, "epss_percentile": 0.25689}, "CVE-2024-47596": {"epss_score": 0.00397, "epss_percentile": 0.59968}, "CVE-2024-47597": {"epss_score": 0.0035, "epss_percentile": 0.56917}, "CVE-2024-47598": {"epss_score": 0.0035, "epss_percentile": 0.56917}, "CVE-2024-47599": {"epss_score": 0.00227, "epss_percentile": 0.45443}, "CVE-2024-47600": {"epss_score": 0.00411, "epss_percentile": 0.60902}, "CVE-2024-47601": {"epss_score": 0.00215, "epss_percentile": 0.44072}, "CVE-2024-47602": {"epss_score": 0.00292, "epss_percentile": 0.52258}, "CVE-2024-47603": {"epss_score": 0.00233, "epss_percentile": 0.46054}, "CVE-2024-47604": {"epss_score": 0.00373, "epss_percentile": 0.58466}, "CVE-2024-47605": {"epss_score": 0.02294, "epss_percentile": 0.8429}, "CVE-2024-47606": {"epss_score": 0.00593, "epss_percentile": 0.68631}, "CVE-2024-47607": {"epss_score": 0.0037, "epss_percentile": 0.5828}, "CVE-2024-47608": {"epss_score": 0.00568, "epss_percentile": 0.67889}, "CVE-2024-47609": {"epss_score": 0.00241, "epss_percentile": 0.47327}, "CVE-2024-47610": {"epss_score": 0.0047, "epss_percentile": 0.63962}, "CVE-2024-47611": {"epss_score": 0.00285, "epss_percentile": 0.51544}, "CVE-2024-47612": {"epss_score": 0.00099, "epss_percentile": 0.28373}, "CVE-2024-47613": {"epss_score": 0.00235, "epss_percentile": 0.46199}, "CVE-2024-47614": {"epss_score": 0.00325, "epss_percentile": 0.55013}, "CVE-2024-47615": {"epss_score": 0.0037, "epss_percentile": 0.5828}, "CVE-2024-47616": {"epss_score": 0.0005, "epss_percentile": 0.1595}, "CVE-2024-47617": {"epss_score": 0.0055, "epss_percentile": 0.6733}, "CVE-2024-47618": {"epss_score": 0.01194, "epss_percentile": 0.78411}, "CVE-2024-47619": {"epss_score": 0.00124, "epss_percentile": 0.32339}, "CVE-2024-47621": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47622": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47623": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-47624": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-47625": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47626": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47627": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47628": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47629": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47630": {"epss_score": 0.00114, "epss_percentile": 0.30847}, "CVE-2024-47631": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47632": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-47633": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47634": {"epss_score": 0.00196, "epss_percentile": 0.41799}, "CVE-2024-47635": {"epss_score": 0.00089, "epss_percentile": 0.25831}, "CVE-2024-47636": {"epss_score": 0.00625, "epss_percentile": 0.69592}, "CVE-2024-47637": {"epss_score": 0.01291, "epss_percentile": 0.79225}, "CVE-2024-47638": {"epss_score": 0.00202, "epss_percentile": 0.42471}, "CVE-2024-47639": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47640": {"epss_score": 0.00399, "epss_percentile": 0.60119}, "CVE-2024-47641": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-47642": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47643": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-47644": {"epss_score": 0.00084, "epss_percentile": 0.24875}, "CVE-2024-47645": {"epss_score": 0.00587, "epss_percentile": 0.68487}, "CVE-2024-47646": {"epss_score": 0.00178, "epss_percentile": 0.39723}, "CVE-2024-47647": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-47648": {"epss_score": 0.00131, "epss_percentile": 0.33473}, "CVE-2024-47649": {"epss_score": 0.00497, "epss_percentile": 0.65196}, "CVE-2024-47650": {"epss_score": 0.00125, "epss_percentile": 0.32505}, "CVE-2024-47651": {"epss_score": 0.00107, "epss_percentile": 0.29667}, "CVE-2024-47652": {"epss_score": 0.00547, "epss_percentile": 0.67229}, "CVE-2024-47653": {"epss_score": 0.00104, "epss_percentile": 0.29232}, "CVE-2024-47654": {"epss_score": 0.0062, "epss_percentile": 0.69448}, "CVE-2024-47655": {"epss_score": 0.02034, "epss_percentile": 0.83345}, "CVE-2024-47656": {"epss_score": 0.00574, "epss_percentile": 0.68088}, "CVE-2024-47657": {"epss_score": 0.00094, "epss_percentile": 0.26957}, "CVE-2024-47658": {"epss_score": 0.00019, "epss_percentile": 0.04146}, "CVE-2024-47659": {"epss_score": 0.00385, "epss_percentile": 0.59203}, "CVE-2024-47660": {"epss_score": 0.00011, "epss_percentile": 0.01102}, "CVE-2024-47661": {"epss_score": 0.0003, "epss_percentile": 0.0828}, "CVE-2024-47662": {"epss_score": 0.00018, "epss_percentile": 0.03655}, "CVE-2024-47663": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-47664": {"epss_score": 0.00019, "epss_percentile": 0.04146}, "CVE-2024-47665": {"epss_score": 0.00012, "epss_percentile": 0.01335}, "CVE-2024-47666": {"epss_score": 0.00016, "epss_percentile": 0.02921}, "CVE-2024-47667": {"epss_score": 0.00012, "epss_percentile": 0.01209}, "CVE-2024-47668": {"epss_score": 9e-05, "epss_percentile": 0.00706}, "CVE-2024-47669": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-47670": {"epss_score": 0.0002, "epss_percentile": 0.04583}, "CVE-2024-47671": {"epss_score": 0.00013, "epss_percentile": 0.01537}, "CVE-2024-47673": {"epss_score": 0.00012, "epss_percentile": 0.01335}, "CVE-2024-47674": {"epss_score": 0.00013, "epss_percentile": 0.01448}, "CVE-2024-47675": {"epss_score": 0.00013, "epss_percentile": 0.01689}, "CVE-2024-47676": {"epss_score": 0.00017, "epss_percentile": 0.03176}, "CVE-2024-47677": {"epss_score": 0.00013, "epss_percentile": 0.0157}, "CVE-2024-47678": {"epss_score": 7e-05, "epss_percentile": 0.00383}, "CVE-2024-47679": {"epss_score": 6e-05, "epss_percentile": 0.0028}, "CVE-2024-47680": {"epss_score": 0.0002, "epss_percentile": 0.04548}, "CVE-2024-47681": {"epss_score": 9e-05, "epss_percentile": 0.00744}, "CVE-2024-47682": {"epss_score": 0.00014, "epss_percentile": 0.02025}, "CVE-2024-47683": {"epss_score": 8e-05, "epss_percentile": 0.00544}, "CVE-2024-47684": {"epss_score": 7e-05, "epss_percentile": 0.00465}, "CVE-2024-47685": {"epss_score": 0.00077, "epss_percentile": 0.23377}, "CVE-2024-47686": {"epss_score": 9e-05, "epss_percentile": 0.00654}, "CVE-2024-47687": {"epss_score": 9e-05, "epss_percentile": 0.00736}, "CVE-2024-47688": {"epss_score": 0.00011, "epss_percentile": 0.01069}, "CVE-2024-47689": {"epss_score": 0.00026, "epss_percentile": 0.06415}, "CVE-2024-47690": {"epss_score": 7e-05, "epss_percentile": 0.00459}, "CVE-2024-47691": {"epss_score": 0.00013, "epss_percentile": 0.01689}, "CVE-2024-47692": {"epss_score": 0.00074, "epss_percentile": 0.22871}, "CVE-2024-47693": {"epss_score": 0.00025, "epss_percentile": 0.0629}, "CVE-2024-47694": {"epss_score": 0.00011, "epss_percentile": 0.01038}, "CVE-2024-47695": {"epss_score": 0.00013, "epss_percentile": 0.01622}, "CVE-2024-47696": {"epss_score": 0.00012, "epss_percentile": 0.0123}, "CVE-2024-47697": {"epss_score": 0.00012, "epss_percentile": 0.0123}, "CVE-2024-47698": {"epss_score": 0.00012, "epss_percentile": 0.0123}, "CVE-2024-47699": {"epss_score": 7e-05, "epss_percentile": 0.00465}, "CVE-2024-47700": {"epss_score": 9e-05, "epss_percentile": 0.00744}, "CVE-2024-47701": {"epss_score": 0.00021, "epss_percentile": 0.04947}, "CVE-2024-47702": {"epss_score": 0.0002, "epss_percentile": 0.04673}, "CVE-2024-47703": {"epss_score": 0.0002, "epss_percentile": 0.04673}, "CVE-2024-47704": {"epss_score": 0.00024, "epss_percentile": 0.05797}, "CVE-2024-47705": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-47706": {"epss_score": 0.00013, "epss_percentile": 0.01661}, "CVE-2024-47707": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-47708": {"epss_score": 0.00051, "epss_percentile": 0.16031}, "CVE-2024-47709": {"epss_score": 0.00013, "epss_percentile": 0.01697}, "CVE-2024-47710": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-47711": {"epss_score": 0.00025, "epss_percentile": 0.06372}, "CVE-2024-47712": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-47713": {"epss_score": 0.00013, "epss_percentile": 0.01697}, "CVE-2024-47714": {"epss_score": 0.0002, "epss_percentile": 0.04616}, "CVE-2024-47715": {"epss_score": 0.00017, "epss_percentile": 0.03319}, "CVE-2024-47716": {"epss_score": 0.0002, "epss_percentile": 0.04673}, "CVE-2024-47717": {"epss_score": 0.00035, "epss_percentile": 0.10011}, "CVE-2024-47718": {"epss_score": 0.00022, "epss_percentile": 0.05136}, "CVE-2024-47719": {"epss_score": 0.00024, "epss_percentile": 0.06013}, "CVE-2024-47720": {"epss_score": 0.00013, "epss_percentile": 0.0168}, "CVE-2024-47721": {"epss_score": 0.0007, "epss_percentile": 0.21744}, "CVE-2024-47723": {"epss_score": 7e-05, "epss_percentile": 0.00371}, "CVE-2024-47724": {"epss_score": 0.00022, "epss_percentile": 0.05282}, "CVE-2024-47726": {"epss_score": 0.00154, "epss_percentile": 0.36742}, "CVE-2024-47727": {"epss_score": 0.00013, "epss_percentile": 0.01622}, "CVE-2024-47728": {"epss_score": 7e-05, "epss_percentile": 0.00459}, "CVE-2024-47729": {"epss_score": 0.0002, "epss_percentile": 0.046}, "CVE-2024-47730": {"epss_score": 0.00012, "epss_percentile": 0.01282}, "CVE-2024-47731": {"epss_score": 7e-05, "epss_percentile": 0.00459}, "CVE-2024-47732": {"epss_score": 0.00013, "epss_percentile": 0.0157}, "CVE-2024-47733": {"epss_score": 0.00013, "epss_percentile": 0.01601}, "CVE-2024-47734": {"epss_score": 7e-05, "epss_percentile": 0.00383}, "CVE-2024-47735": {"epss_score": 6e-05, "epss_percentile": 0.00289}, "CVE-2024-47736": {"epss_score": 7e-05, "epss_percentile": 0.00455}, "CVE-2024-47737": {"epss_score": 7e-05, "epss_percentile": 0.00465}, "CVE-2024-47738": {"epss_score": 9e-05, "epss_percentile": 0.00663}, "CVE-2024-47739": {"epss_score": 8e-05, "epss_percentile": 0.00479}, "CVE-2024-47740": {"epss_score": 4e-05, "epss_percentile": 0.00126}, "CVE-2024-47741": {"epss_score": 0.00012, "epss_percentile": 0.01423}, "CVE-2024-47742": {"epss_score": 0.00013, "epss_percentile": 0.01542}, "CVE-2024-47743": {"epss_score": 9e-05, "epss_percentile": 0.0064}, "CVE-2024-47744": {"epss_score": 7e-05, "epss_percentile": 0.00455}, "CVE-2024-47745": {"epss_score": 2e-05, "epss_percentile": 0.00051}, "CVE-2024-47746": {"epss_score": 0.00027, "epss_percentile": 0.07004}, "CVE-2024-47747": {"epss_score": 0.00022, "epss_percentile": 0.05136}, "CVE-2024-47748": {"epss_score": 6e-05, "epss_percentile": 0.00251}, "CVE-2024-47749": {"epss_score": 0.00013, "epss_percentile": 0.01697}, "CVE-2024-47750": {"epss_score": 0.00024, "epss_percentile": 0.05857}, "CVE-2024-47751": {"epss_score": 0.00029, "epss_percentile": 0.07683}, "CVE-2024-47752": {"epss_score": 0.0002, "epss_percentile": 0.04673}, "CVE-2024-47753": {"epss_score": 0.00024, "epss_percentile": 0.05839}, "CVE-2024-47754": {"epss_score": 0.00024, "epss_percentile": 0.05839}, "CVE-2024-47756": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-47757": {"epss_score": 0.00014, "epss_percentile": 0.01755}, "CVE-2024-47758": {"epss_score": 0.00448, "epss_percentile": 0.63005}, "CVE-2024-47759": {"epss_score": 0.00501, "epss_percentile": 0.65344}, "CVE-2024-47760": {"epss_score": 0.00214, "epss_percentile": 0.43965}, "CVE-2024-47761": {"epss_score": 0.0024, "epss_percentile": 0.47213}, "CVE-2024-47762": {"epss_score": 0.00138, "epss_percentile": 0.34521}, "CVE-2024-47763": {"epss_score": 7e-05, "epss_percentile": 0.00406}, "CVE-2024-47764": {"epss_score": 0.00085, "epss_percentile": 0.25055}, "CVE-2024-47765": {"epss_score": 0.01303, "epss_percentile": 0.79312}, "CVE-2024-47766": {"epss_score": 0.00114, "epss_percentile": 0.30874}, "CVE-2024-47767": {"epss_score": 0.0025, "epss_percentile": 0.48243}, "CVE-2024-47768": {"epss_score": 0.00314, "epss_percentile": 0.54121}, "CVE-2024-47769": {"epss_score": 0.0096, "epss_percentile": 0.75964}, "CVE-2024-47770": {"epss_score": 0.00087, "epss_percentile": 0.25504}, "CVE-2024-47771": {"epss_score": 0.00145, "epss_percentile": 0.35453}, "CVE-2024-47772": {"epss_score": 0.00535, "epss_percentile": 0.66803}, "CVE-2024-47773": {"epss_score": 0.07854, "epss_percentile": 0.91721}, "CVE-2024-47774": {"epss_score": 0.00237, "epss_percentile": 0.46668}, "CVE-2024-47775": {"epss_score": 0.00355, "epss_percentile": 0.57293}, "CVE-2024-47776": {"epss_score": 0.00355, "epss_percentile": 0.57293}, "CVE-2024-47777": {"epss_score": 0.00379, "epss_percentile": 0.58891}, "CVE-2024-47778": {"epss_score": 0.0043, "epss_percentile": 0.62032}, "CVE-2024-47779": {"epss_score": 0.00157, "epss_percentile": 0.37105}, "CVE-2024-47780": {"epss_score": 0.00193, "epss_percentile": 0.41434}, "CVE-2024-47781": {"epss_score": 0.00597, "epss_percentile": 0.68754}, "CVE-2024-47782": {"epss_score": 0.00312, "epss_percentile": 0.5396}, "CVE-2024-47783": {"epss_score": 0.00061, "epss_percentile": 0.19484}, "CVE-2024-47784": {"epss_score": 0.00015, "epss_percentile": 0.02388}, "CVE-2024-47789": {"epss_score": 0.00255, "epss_percentile": 0.48724}, "CVE-2024-47790": {"epss_score": 0.0051, "epss_percentile": 0.65809}, "CVE-2024-47791": {"epss_score": 0.00138, "epss_percentile": 0.34372}, "CVE-2024-47793": {"epss_score": 0.00696, "epss_percentile": 0.7139}, "CVE-2024-47794": {"epss_score": 0.00015, "epss_percentile": 0.02253}, "CVE-2024-47795": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2024-47796": {"epss_score": 0.00063, "epss_percentile": 0.20085}, "CVE-2024-47797": {"epss_score": 0.00071, "epss_percentile": 0.22182}, "CVE-2024-47799": {"epss_score": 0.00063, "epss_percentile": 0.19816}, "CVE-2024-47800": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2024-47801": {"epss_score": 0.00805, "epss_percentile": 0.73641}, "CVE-2024-47803": {"epss_score": 0.00464, "epss_percentile": 0.63724}, "CVE-2024-47804": {"epss_score": 0.00261, "epss_percentile": 0.49251}, "CVE-2024-47805": {"epss_score": 0.00178, "epss_percentile": 0.39664}, "CVE-2024-47806": {"epss_score": 0.0018, "epss_percentile": 0.39865}, "CVE-2024-47807": {"epss_score": 0.00235, "epss_percentile": 0.46216}, "CVE-2024-47808": {"epss_score": 0.00081, "epss_percentile": 0.2433}, "CVE-2024-47809": {"epss_score": 0.00025, "epss_percentile": 0.06211}, "CVE-2024-47810": {"epss_score": 0.0029, "epss_percentile": 0.52125}, "CVE-2024-47812": {"epss_score": 0.00106, "epss_percentile": 0.29448}, "CVE-2024-47813": {"epss_score": 0.00014, "epss_percentile": 0.01994}, "CVE-2024-47814": {"epss_score": 0.00069, "epss_percentile": 0.21602}, "CVE-2024-47815": {"epss_score": 0.00083, "epss_percentile": 0.24797}, "CVE-2024-47816": {"epss_score": 0.00106, "epss_percentile": 0.29469}, "CVE-2024-47817": {"epss_score": 0.00104, "epss_percentile": 0.29152}, "CVE-2024-47818": {"epss_score": 0.00268, "epss_percentile": 0.50036}, "CVE-2024-47819": {"epss_score": 0.0049, "epss_percentile": 0.64933}, "CVE-2024-47820": {"epss_score": 0.00066, "epss_percentile": 0.20747}, "CVE-2024-47821": {"epss_score": 0.0165, "epss_percentile": 0.81566}, "CVE-2024-47822": {"epss_score": 0.00063, "epss_percentile": 0.19888}, "CVE-2024-47823": {"epss_score": 0.00348, "epss_percentile": 0.5685}, "CVE-2024-47824": {"epss_score": 0.00387, "epss_percentile": 0.59317}, "CVE-2024-47825": {"epss_score": 0.00211, "epss_percentile": 0.43673}, "CVE-2024-47826": {"epss_score": 0.00375, "epss_percentile": 0.58616}, "CVE-2024-47827": {"epss_score": 0.00199, "epss_percentile": 0.42172}, "CVE-2024-47828": {"epss_score": 0.00843, "epss_percentile": 0.74269}, "CVE-2024-47829": {"epss_score": 0.00055, "epss_percentile": 0.1747}, "CVE-2024-47830": {"epss_score": 0.00527, "epss_percentile": 0.66451}, "CVE-2024-47831": {"epss_score": 0.00462, "epss_percentile": 0.63618}, "CVE-2024-47832": {"epss_score": 0.00078, "epss_percentile": 0.23663}, "CVE-2024-47833": {"epss_score": 0.00081, "epss_percentile": 0.24369}, "CVE-2024-47834": {"epss_score": 0.00379, "epss_percentile": 0.58891}, "CVE-2024-47835": {"epss_score": 0.00247, "epss_percentile": 0.47826}, "CVE-2024-47836": {"epss_score": 0.021, "epss_percentile": 0.83601}, "CVE-2024-47840": {"epss_score": 0.00486, "epss_percentile": 0.64757}, "CVE-2024-47841": {"epss_score": 0.261, "epss_percentile": 0.9611}, "CVE-2024-47845": {"epss_score": 0.00292, "epss_percentile": 0.52274}, "CVE-2024-47846": {"epss_score": 0.00395, "epss_percentile": 0.59834}, "CVE-2024-47847": {"epss_score": 0.00783, "epss_percentile": 0.73221}, "CVE-2024-47848": {"epss_score": 0.00512, "epss_percentile": 0.65857}, "CVE-2024-47849": {"epss_score": 0.00379, "epss_percentile": 0.58878}, "CVE-2024-47850": {"epss_score": 0.0012, "epss_percentile": 0.31782}, "CVE-2024-47853": {"epss_score": 0.0008, "epss_percentile": 0.24029}, "CVE-2024-47854": {"epss_score": 0.03056, "epss_percentile": 0.86301}, "CVE-2024-47855": {"epss_score": 0.04347, "epss_percentile": 0.88577}, "CVE-2024-47856": {"epss_score": 0.00155, "epss_percentile": 0.36839}, "CVE-2024-47857": {"epss_score": 0.00177, "epss_percentile": 0.3952}, "CVE-2024-47863": {"epss_score": 0.00473, "epss_percentile": 0.64108}, "CVE-2024-47864": {"epss_score": 0.00101, "epss_percentile": 0.28696}, "CVE-2024-47865": {"epss_score": 0.00219, "epss_percentile": 0.44478}, "CVE-2024-47866": {"epss_score": 0.0019, "epss_percentile": 0.41075}, "CVE-2024-47867": {"epss_score": 0.00222, "epss_percentile": 0.44719}, "CVE-2024-47868": {"epss_score": 0.00148, "epss_percentile": 0.35864}, "CVE-2024-47869": {"epss_score": 0.00117, "epss_percentile": 0.31211}, "CVE-2024-47870": {"epss_score": 0.00141, "epss_percentile": 0.34905}, "CVE-2024-47871": {"epss_score": 0.00061, "epss_percentile": 0.19357}, "CVE-2024-47872": {"epss_score": 0.00184, "epss_percentile": 0.40416}, "CVE-2024-47873": {"epss_score": 0.00065, "epss_percentile": 0.20611}, "CVE-2024-47874": {"epss_score": 0.00092, "epss_percentile": 0.26485}, "CVE-2024-47875": {"epss_score": 0.00515, "epss_percentile": 0.66006}, "CVE-2024-47876": {"epss_score": 0.00305, "epss_percentile": 0.53341}, "CVE-2024-47877": {"epss_score": 0.00597, "epss_percentile": 0.68747}, "CVE-2024-47878": {"epss_score": 0.0012, "epss_percentile": 0.31718}, "CVE-2024-47879": {"epss_score": 0.00102, "epss_percentile": 0.2872}, "CVE-2024-47880": {"epss_score": 0.00115, "epss_percentile": 0.30949}, "CVE-2024-47881": {"epss_score": 0.0032, "epss_percentile": 0.54584}, "CVE-2024-47882": {"epss_score": 0.00132, "epss_percentile": 0.3356}, "CVE-2024-47883": {"epss_score": 0.04496, "epss_percentile": 0.88762}, "CVE-2024-47884": {"epss_score": 0.0003, "epss_percentile": 0.08065}, "CVE-2024-47885": {"epss_score": 0.00905, "epss_percentile": 0.7524}, "CVE-2024-47887": {"epss_score": 0.00201, "epss_percentile": 0.42284}, "CVE-2024-47888": {"epss_score": 0.0035, "epss_percentile": 0.56962}, "CVE-2024-47889": {"epss_score": 0.00233, "epss_percentile": 0.4606}, "CVE-2024-47891": {"epss_score": 0.00046, "epss_percentile": 0.14467}, "CVE-2024-47892": {"epss_score": 0.00073, "epss_percentile": 0.22608}, "CVE-2024-47893": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2024-47894": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2024-47895": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2024-47896": {"epss_score": 0.00033, "epss_percentile": 0.09247}, "CVE-2024-47897": {"epss_score": 0.0023, "epss_percentile": 0.45675}, "CVE-2024-47898": {"epss_score": 0.00033, "epss_percentile": 0.09244}, "CVE-2024-47899": {"epss_score": 0.00033, "epss_percentile": 0.09244}, "CVE-2024-47900": {"epss_score": 0.00033, "epss_percentile": 0.09244}, "CVE-2024-47901": {"epss_score": 0.02512, "epss_percentile": 0.84976}, "CVE-2024-47902": {"epss_score": 0.00308, "epss_percentile": 0.53617}, "CVE-2024-47903": {"epss_score": 0.00356, "epss_percentile": 0.57331}, "CVE-2024-47904": {"epss_score": 0.00057, "epss_percentile": 0.18008}, "CVE-2024-47905": {"epss_score": 0.01618, "epss_percentile": 0.81373}, "CVE-2024-47906": {"epss_score": 0.00285, "epss_percentile": 0.51636}, "CVE-2024-47907": {"epss_score": 0.03905, "epss_percentile": 0.87925}, "CVE-2024-47908": {"epss_score": 0.13547, "epss_percentile": 0.93992}, "CVE-2024-47909": {"epss_score": 0.01618, "epss_percentile": 0.81373}, "CVE-2024-47910": {"epss_score": 0.00076, "epss_percentile": 0.23215}, "CVE-2024-47911": {"epss_score": 0.00097, "epss_percentile": 0.27464}, "CVE-2024-47912": {"epss_score": 0.00616, "epss_percentile": 0.69324}, "CVE-2024-47913": {"epss_score": 0.00505, "epss_percentile": 0.65597}, "CVE-2024-47914": {"epss_score": 0.00099, "epss_percentile": 0.27856}, "CVE-2024-47915": {"epss_score": 0.00194, "epss_percentile": 0.41544}, "CVE-2024-47916": {"epss_score": 0.003, "epss_percentile": 0.52909}, "CVE-2024-47917": {"epss_score": 0.00143, "epss_percentile": 0.35165}, "CVE-2024-47918": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2024-47919": {"epss_score": 0.02208, "epss_percentile": 0.84007}, "CVE-2024-47920": {"epss_score": 0.00143, "epss_percentile": 0.35165}, "CVE-2024-47921": {"epss_score": 0.00022, "epss_percentile": 0.05259}, "CVE-2024-47922": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2024-47923": {"epss_score": 0.00107, "epss_percentile": 0.29641}, "CVE-2024-47924": {"epss_score": 0.00143, "epss_percentile": 0.35165}, "CVE-2024-47925": {"epss_score": 0.00143, "epss_percentile": 0.35165}, "CVE-2024-47926": {"epss_score": 0.00123, "epss_percentile": 0.32291}, "CVE-2024-47934": {"epss_score": 0.0026, "epss_percentile": 0.49175}, "CVE-2024-47935": {"epss_score": 0.00012, "epss_percentile": 0.01204}, "CVE-2024-47939": {"epss_score": 0.00181, "epss_percentile": 0.40103}, "CVE-2024-47940": {"epss_score": 0.00129, "epss_percentile": 0.33182}, "CVE-2024-47941": {"epss_score": 0.00129, "epss_percentile": 0.33182}, "CVE-2024-47942": {"epss_score": 0.00066, "epss_percentile": 0.20908}, "CVE-2024-47943": {"epss_score": 0.00153, "epss_percentile": 0.36542}, "CVE-2024-47944": {"epss_score": 0.00104, "epss_percentile": 0.29128}, "CVE-2024-47945": {"epss_score": 0.00304, "epss_percentile": 0.53266}, "CVE-2024-47946": {"epss_score": 0.01005, "epss_percentile": 0.76537}, "CVE-2024-47947": {"epss_score": 0.00098, "epss_percentile": 0.27789}, "CVE-2024-47948": {"epss_score": 5e-05, "epss_percentile": 0.00184}, "CVE-2024-47949": {"epss_score": 0.00446, "epss_percentile": 0.62892}, "CVE-2024-47950": {"epss_score": 0.0006, "epss_percentile": 0.1921}, "CVE-2024-47951": {"epss_score": 0.0017, "epss_percentile": 0.3869}, "CVE-2024-47962": {"epss_score": 0.02003, "epss_percentile": 0.83225}, "CVE-2024-47963": {"epss_score": 0.00099, "epss_percentile": 0.28355}, "CVE-2024-47964": {"epss_score": 0.00128, "epss_percentile": 0.32964}, "CVE-2024-47965": {"epss_score": 0.00099, "epss_percentile": 0.28355}, "CVE-2024-47966": {"epss_score": 0.00074, "epss_percentile": 0.22792}, "CVE-2024-47967": {"epss_score": 0.00066, "epss_percentile": 0.20931}, "CVE-2024-47968": {"epss_score": 0.00054, "epss_percentile": 0.17309}, "CVE-2024-47969": {"epss_score": 0.0007, "epss_percentile": 0.21805}, "CVE-2024-47971": {"epss_score": 0.00069, "epss_percentile": 0.21506}, "CVE-2024-47972": {"epss_score": 0.00073, "epss_percentile": 0.2253}, "CVE-2024-47973": {"epss_score": 0.00076, "epss_percentile": 0.23216}, "CVE-2024-47974": {"epss_score": 0.00039, "epss_percentile": 0.11595}, "CVE-2024-47975": {"epss_score": 0.00067, "epss_percentile": 0.21068}, "CVE-2024-47976": {"epss_score": 0.00078, "epss_percentile": 0.2358}, "CVE-2024-47977": {"epss_score": 0.00623, "epss_percentile": 0.69554}, "CVE-2024-47978": {"epss_score": 0.00039, "epss_percentile": 0.11712}, "CVE-2024-47984": {"epss_score": 0.00087, "epss_percentile": 0.25504}, "CVE-2024-48007": {"epss_score": 0.00108, "epss_percentile": 0.29885}, "CVE-2024-48008": {"epss_score": 0.00208, "epss_percentile": 0.43294}, "CVE-2024-48010": {"epss_score": 0.00203, "epss_percentile": 0.42582}, "CVE-2024-48011": {"epss_score": 0.00426, "epss_percentile": 0.61745}, "CVE-2024-48013": {"epss_score": 0.00417, "epss_percentile": 0.61224}, "CVE-2024-48014": {"epss_score": 0.00081, "epss_percentile": 0.24353}, "CVE-2024-48015": {"epss_score": 0.00028, "epss_percentile": 0.0735}, "CVE-2024-48016": {"epss_score": 0.00109, "epss_percentile": 0.2993}, "CVE-2024-48017": {"epss_score": 0.00192, "epss_percentile": 0.41282}, "CVE-2024-48019": {"epss_score": 0.01208, "epss_percentile": 0.7853}, "CVE-2024-48020": {"epss_score": 0.00177, "epss_percentile": 0.39567}, "CVE-2024-48021": {"epss_score": 0.00206, "epss_percentile": 0.43038}, "CVE-2024-48022": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-48023": {"epss_score": 0.00115, "epss_percentile": 0.309}, "CVE-2024-48024": {"epss_score": 0.00473, "epss_percentile": 0.64074}, "CVE-2024-48025": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2024-48026": {"epss_score": 0.00401, "epss_percentile": 0.6025}, "CVE-2024-48027": {"epss_score": 0.00934, "epss_percentile": 0.75656}, "CVE-2024-48028": {"epss_score": 0.00516, "epss_percentile": 0.66055}, "CVE-2024-48029": {"epss_score": 0.04128, "epss_percentile": 0.88293}, "CVE-2024-48030": {"epss_score": 0.00564, "epss_percentile": 0.67772}, "CVE-2024-48031": {"epss_score": 0.00127, "epss_percentile": 0.32815}, "CVE-2024-48032": {"epss_score": 0.00115, "epss_percentile": 0.309}, "CVE-2024-48033": {"epss_score": 0.00306, "epss_percentile": 0.53432}, "CVE-2024-48034": {"epss_score": 0.00792, "epss_percentile": 0.73405}, "CVE-2024-48035": {"epss_score": 0.00716, "epss_percentile": 0.71865}, "CVE-2024-48036": {"epss_score": 0.00081, "epss_percentile": 0.24298}, "CVE-2024-48037": {"epss_score": 0.00097, "epss_percentile": 0.27535}, "CVE-2024-48038": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-48039": {"epss_score": 0.00338, "epss_percentile": 0.56156}, "CVE-2024-48040": {"epss_score": 0.00284, "epss_percentile": 0.51494}, "CVE-2024-48041": {"epss_score": 0.00236, "epss_percentile": 0.46459}, "CVE-2024-48042": {"epss_score": 0.01441, "epss_percentile": 0.80303}, "CVE-2024-48043": {"epss_score": 0.00272, "epss_percentile": 0.50414}, "CVE-2024-48044": {"epss_score": 0.00244, "epss_percentile": 0.47595}, "CVE-2024-48045": {"epss_score": 0.0037, "epss_percentile": 0.58314}, "CVE-2024-48046": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-48047": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-48048": {"epss_score": 0.00084, "epss_percentile": 0.24875}, "CVE-2024-48049": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-48050": {"epss_score": 0.00138, "epss_percentile": 0.34468}, "CVE-2024-48052": {"epss_score": 0.00092, "epss_percentile": 0.26547}, "CVE-2024-48057": {"epss_score": 0.00072, "epss_percentile": 0.22401}, "CVE-2024-48059": {"epss_score": 0.00133, "epss_percentile": 0.33712}, "CVE-2024-48061": {"epss_score": 0.0775, "epss_percentile": 0.91658}, "CVE-2024-48063": {"epss_score": 0.15462, "epss_percentile": 0.94432}, "CVE-2024-48068": {"epss_score": 0.00374, "epss_percentile": 0.58544}, "CVE-2024-48069": {"epss_score": 0.00115, "epss_percentile": 0.30934}, "CVE-2024-48070": {"epss_score": 0.00592, "epss_percentile": 0.68621}, "CVE-2024-48071": {"epss_score": 0.00824, "epss_percentile": 0.73938}, "CVE-2024-48072": {"epss_score": 0.00282, "epss_percentile": 0.51252}, "CVE-2024-48073": {"epss_score": 0.00788, "epss_percentile": 0.73339}, "CVE-2024-48074": {"epss_score": 0.00114, "epss_percentile": 0.30761}, "CVE-2024-48075": {"epss_score": 0.01034, "epss_percentile": 0.76885}, "CVE-2024-48080": {"epss_score": 0.00305, "epss_percentile": 0.53384}, "CVE-2024-48091": {"epss_score": 0.00032, "epss_percentile": 0.08955}, "CVE-2024-48093": {"epss_score": 0.03267, "epss_percentile": 0.86785}, "CVE-2024-48107": {"epss_score": 0.00124, "epss_percentile": 0.3239}, "CVE-2024-48112": {"epss_score": 0.01776, "epss_percentile": 0.82219}, "CVE-2024-48119": {"epss_score": 0.00159, "epss_percentile": 0.37365}, "CVE-2024-48120": {"epss_score": 0.00903, "epss_percentile": 0.75201}, "CVE-2024-48121": {"epss_score": 0.00069, "epss_percentile": 0.21621}, "CVE-2024-48122": {"epss_score": 0.00036, "epss_percentile": 0.10545}, "CVE-2024-48123": {"epss_score": 0.00041, "epss_percentile": 0.12197}, "CVE-2024-48125": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2024-48126": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-48138": {"epss_score": 0.02144, "epss_percentile": 0.8376}, "CVE-2024-48139": {"epss_score": 0.00045, "epss_percentile": 0.13784}, "CVE-2024-48140": {"epss_score": 0.00133, "epss_percentile": 0.33654}, "CVE-2024-48141": {"epss_score": 0.00133, "epss_percentile": 0.33654}, "CVE-2024-48142": {"epss_score": 0.00133, "epss_percentile": 0.33654}, "CVE-2024-48143": {"epss_score": 0.00108, "epss_percentile": 0.29763}, "CVE-2024-48144": {"epss_score": 0.00139, "epss_percentile": 0.34585}, "CVE-2024-48145": {"epss_score": 0.00139, "epss_percentile": 0.34585}, "CVE-2024-48150": {"epss_score": 0.00633, "epss_percentile": 0.69762}, "CVE-2024-48153": {"epss_score": 0.00086, "epss_percentile": 0.25346}, "CVE-2024-48168": {"epss_score": 0.00193, "epss_percentile": 0.414}, "CVE-2024-48170": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2024-48176": {"epss_score": 0.00268, "epss_percentile": 0.50035}, "CVE-2024-48177": {"epss_score": 0.00203, "epss_percentile": 0.42506}, "CVE-2024-48178": {"epss_score": 0.00087, "epss_percentile": 0.25544}, "CVE-2024-48180": {"epss_score": 0.00363, "epss_percentile": 0.57832}, "CVE-2024-48191": {"epss_score": 0.00065, "epss_percentile": 0.2045}, "CVE-2024-48192": {"epss_score": 0.00127, "epss_percentile": 0.32811}, "CVE-2024-48195": {"epss_score": 0.00114, "epss_percentile": 0.30734}, "CVE-2024-48196": {"epss_score": 0.00391, "epss_percentile": 0.5957}, "CVE-2024-48197": {"epss_score": 0.00774, "epss_percentile": 0.73069}, "CVE-2024-48200": {"epss_score": 0.00054, "epss_percentile": 0.17302}, "CVE-2024-48202": {"epss_score": 0.00226, "epss_percentile": 0.45264}, "CVE-2024-48204": {"epss_score": 0.00742, "epss_percentile": 0.72454}, "CVE-2024-48206": {"epss_score": 0.00123, "epss_percentile": 0.32196}, "CVE-2024-48208": {"epss_score": 0.37159, "epss_percentile": 0.97024}, "CVE-2024-48213": {"epss_score": 0.00129, "epss_percentile": 0.33206}, "CVE-2024-48214": {"epss_score": 0.00078, "epss_percentile": 0.23662}, "CVE-2024-48217": {"epss_score": 0.01065, "epss_percentile": 0.77205}, "CVE-2024-48218": {"epss_score": 0.00138, "epss_percentile": 0.34528}, "CVE-2024-48222": {"epss_score": 0.00138, "epss_percentile": 0.34528}, "CVE-2024-48223": {"epss_score": 0.00138, "epss_percentile": 0.34528}, "CVE-2024-48224": {"epss_score": 0.00135, "epss_percentile": 0.34038}, "CVE-2024-48225": {"epss_score": 0.00132, "epss_percentile": 0.33559}, "CVE-2024-48226": {"epss_score": 0.00098, "epss_percentile": 0.27726}, "CVE-2024-48227": {"epss_score": 0.00088, "epss_percentile": 0.25736}, "CVE-2024-48228": {"epss_score": 0.00124, "epss_percentile": 0.32387}, "CVE-2024-48229": {"epss_score": 0.00098, "epss_percentile": 0.27726}, "CVE-2024-48230": {"epss_score": 0.00129, "epss_percentile": 0.33119}, "CVE-2024-48231": {"epss_score": 0.00105, "epss_percentile": 0.29337}, "CVE-2024-48232": {"epss_score": 0.00079, "epss_percentile": 0.23819}, "CVE-2024-48233": {"epss_score": 0.00079, "epss_percentile": 0.23972}, "CVE-2024-48234": {"epss_score": 0.00081, "epss_percentile": 0.24374}, "CVE-2024-48235": {"epss_score": 0.0034, "epss_percentile": 0.56285}, "CVE-2024-48236": {"epss_score": 0.0034, "epss_percentile": 0.56285}, "CVE-2024-48237": {"epss_score": 0.00113, "epss_percentile": 0.30705}, "CVE-2024-48238": {"epss_score": 0.00052, "epss_percentile": 0.16499}, "CVE-2024-48239": {"epss_score": 0.00083, "epss_percentile": 0.24799}, "CVE-2024-48241": {"epss_score": 0.00059, "epss_percentile": 0.18618}, "CVE-2024-48245": {"epss_score": 0.01008, "epss_percentile": 0.76569}, "CVE-2024-48246": {"epss_score": 0.00055, "epss_percentile": 0.17637}, "CVE-2024-48248": {"epss_score": 0.93973, "epss_percentile": 0.99877}, "CVE-2024-48249": {"epss_score": 0.00069, "epss_percentile": 0.21445}, "CVE-2024-48251": {"epss_score": 0.00056, "epss_percentile": 0.17668}, "CVE-2024-48253": {"epss_score": 0.00074, "epss_percentile": 0.22735}, "CVE-2024-48255": {"epss_score": 0.0007, "epss_percentile": 0.21865}, "CVE-2024-48257": {"epss_score": 0.00111, "epss_percentile": 0.30243}, "CVE-2024-48259": {"epss_score": 0.00065, "epss_percentile": 0.20602}, "CVE-2024-48270": {"epss_score": 0.00132, "epss_percentile": 0.3357}, "CVE-2024-48271": {"epss_score": 0.00024, "epss_percentile": 0.0579}, "CVE-2024-48272": {"epss_score": 0.0013, "epss_percentile": 0.33308}, "CVE-2024-48278": {"epss_score": 0.00171, "epss_percentile": 0.38793}, "CVE-2024-48279": {"epss_score": 0.00763, "epss_percentile": 0.72854}, "CVE-2024-48280": {"epss_score": 0.00716, "epss_percentile": 0.71854}, "CVE-2024-48282": {"epss_score": 0.01169, "epss_percentile": 0.78202}, "CVE-2024-48283": {"epss_score": 0.00083, "epss_percentile": 0.24599}, "CVE-2024-48284": {"epss_score": 0.00127, "epss_percentile": 0.32829}, "CVE-2024-48286": {"epss_score": 0.00412, "epss_percentile": 0.60953}, "CVE-2024-48288": {"epss_score": 0.002, "epss_percentile": 0.42268}, "CVE-2024-48289": {"epss_score": 0.00147, "epss_percentile": 0.35687}, "CVE-2024-48290": {"epss_score": 0.00018, "epss_percentile": 0.0388}, "CVE-2024-48291": {"epss_score": 0.00067, "epss_percentile": 0.20965}, "CVE-2024-48292": {"epss_score": 0.00158, "epss_percentile": 0.37151}, "CVE-2024-48293": {"epss_score": 0.00145, "epss_percentile": 0.35434}, "CVE-2024-48294": {"epss_score": 0.0007, "epss_percentile": 0.21818}, "CVE-2024-48307": {"epss_score": 0.92209, "epss_percentile": 0.997}, "CVE-2024-48310": {"epss_score": 0.00205, "epss_percentile": 0.42726}, "CVE-2024-48311": {"epss_score": 0.00095, "epss_percentile": 0.27141}, "CVE-2024-48312": {"epss_score": 0.00096, "epss_percentile": 0.2739}, "CVE-2024-48322": {"epss_score": 0.10523, "epss_percentile": 0.93019}, "CVE-2024-48325": {"epss_score": 0.09712, "epss_percentile": 0.92673}, "CVE-2024-48336": {"epss_score": 0.14339, "epss_percentile": 0.94191}, "CVE-2024-48341": {"epss_score": 0.00033, "epss_percentile": 0.09247}, "CVE-2024-48343": {"epss_score": 0.00066, "epss_percentile": 0.20736}, "CVE-2024-48346": {"epss_score": 0.00214, "epss_percentile": 0.4397}, "CVE-2024-48352": {"epss_score": 0.00338, "epss_percentile": 0.56124}, "CVE-2024-48353": {"epss_score": 0.00802, "epss_percentile": 0.73591}, "CVE-2024-48356": {"epss_score": 0.00214, "epss_percentile": 0.4402}, "CVE-2024-48357": {"epss_score": 0.0009, "epss_percentile": 0.25991}, "CVE-2024-48359": {"epss_score": 0.3193, "epss_percentile": 0.9666}, "CVE-2024-48360": {"epss_score": 0.90276, "epss_percentile": 0.99574}, "CVE-2024-48392": {"epss_score": 0.00332, "epss_percentile": 0.5557}, "CVE-2024-48394": {"epss_score": 0.00031, "epss_percentile": 0.08433}, "CVE-2024-48396": {"epss_score": 0.00171, "epss_percentile": 0.38815}, "CVE-2024-48406": {"epss_score": 0.00141, "epss_percentile": 0.34817}, "CVE-2024-48410": {"epss_score": 0.00463, "epss_percentile": 0.63669}, "CVE-2024-48411": {"epss_score": 0.00104, "epss_percentile": 0.29166}, "CVE-2024-48415": {"epss_score": 0.0044, "epss_percentile": 0.62645}, "CVE-2024-48416": {"epss_score": 0.0008, "epss_percentile": 0.24194}, "CVE-2024-48417": {"epss_score": 0.00054, "epss_percentile": 0.17357}, "CVE-2024-48418": {"epss_score": 0.00054, "epss_percentile": 0.17089}, "CVE-2024-48419": {"epss_score": 0.11344, "epss_percentile": 0.93317}, "CVE-2024-48420": {"epss_score": 0.00092, "epss_percentile": 0.26487}, "CVE-2024-48423": {"epss_score": 0.00045, "epss_percentile": 0.14}, "CVE-2024-48424": {"epss_score": 0.00032, "epss_percentile": 0.08832}, "CVE-2024-48425": {"epss_score": 0.00075, "epss_percentile": 0.23059}, "CVE-2024-48426": {"epss_score": 0.00038, "epss_percentile": 0.11314}, "CVE-2024-48427": {"epss_score": 0.13386, "epss_percentile": 0.93949}, "CVE-2024-48428": {"epss_score": 0.00131, "epss_percentile": 0.33409}, "CVE-2024-48440": {"epss_score": 0.00304, "epss_percentile": 0.53244}, "CVE-2024-48441": {"epss_score": 0.00213, "epss_percentile": 0.43943}, "CVE-2024-48442": {"epss_score": 0.00057, "epss_percentile": 0.18129}, "CVE-2024-48445": {"epss_score": 0.03154, "epss_percentile": 0.86511}, "CVE-2024-48448": {"epss_score": 0.00089, "epss_percentile": 0.2585}, "CVE-2024-48450": {"epss_score": 0.0009, "epss_percentile": 0.26011}, "CVE-2024-48453": {"epss_score": 0.01216, "epss_percentile": 0.78593}, "CVE-2024-48454": {"epss_score": 0.01975, "epss_percentile": 0.83118}, "CVE-2024-48455": {"epss_score": 0.52418, "epss_percentile": 0.97825}, "CVE-2024-48456": {"epss_score": 0.75112, "epss_percentile": 0.98831}, "CVE-2024-48457": {"epss_score": 0.64368, "epss_percentile": 0.98375}, "CVE-2024-48459": {"epss_score": 0.00089, "epss_percentile": 0.25883}, "CVE-2024-48460": {"epss_score": 0.00092, "epss_percentile": 0.26591}, "CVE-2024-48461": {"epss_score": 0.00305, "epss_percentile": 0.53369}, "CVE-2024-48463": {"epss_score": 0.00261, "epss_percentile": 0.49254}, "CVE-2024-48465": {"epss_score": 0.00134, "epss_percentile": 0.33822}, "CVE-2024-48509": {"epss_score": 0.00165, "epss_percentile": 0.38031}, "CVE-2024-48510": {"epss_score": 0.01249, "epss_percentile": 0.78874}, "CVE-2024-48514": {"epss_score": 0.00132, "epss_percentile": 0.33598}, "CVE-2024-48530": {"epss_score": 0.00268, "epss_percentile": 0.50078}, "CVE-2024-48531": {"epss_score": 0.00199, "epss_percentile": 0.42109}, "CVE-2024-48533": {"epss_score": 0.00105, "epss_percentile": 0.29319}, "CVE-2024-48534": {"epss_score": 0.00199, "epss_percentile": 0.42109}, "CVE-2024-48535": {"epss_score": 0.00124, "epss_percentile": 0.32448}, "CVE-2024-48536": {"epss_score": 0.00133, "epss_percentile": 0.33654}, "CVE-2024-48538": {"epss_score": 0.00273, "epss_percentile": 0.50425}, "CVE-2024-48539": {"epss_score": 0.00164, "epss_percentile": 0.37937}, "CVE-2024-48540": {"epss_score": 0.00097, "epss_percentile": 0.2748}, "CVE-2024-48541": {"epss_score": 0.00065, "epss_percentile": 0.20588}, "CVE-2024-48542": {"epss_score": 0.00065, "epss_percentile": 0.20588}, "CVE-2024-48544": {"epss_score": 0.00042, "epss_percentile": 0.12911}, "CVE-2024-48545": {"epss_score": 0.00065, "epss_percentile": 0.20588}, "CVE-2024-48546": {"epss_score": 0.00042, "epss_percentile": 0.12911}, "CVE-2024-48547": {"epss_score": 0.00042, "epss_percentile": 0.12911}, "CVE-2024-48548": {"epss_score": 0.00042, "epss_percentile": 0.12911}, "CVE-2024-48569": {"epss_score": 0.02258, "epss_percentile": 0.84177}, "CVE-2024-48570": {"epss_score": 0.00084, "epss_percentile": 0.24993}, "CVE-2024-48572": {"epss_score": 0.00085, "epss_percentile": 0.25045}, "CVE-2024-48573": {"epss_score": 0.00176, "epss_percentile": 0.39417}, "CVE-2024-48579": {"epss_score": 0.01376, "epss_percentile": 0.79836}, "CVE-2024-48580": {"epss_score": 0.01376, "epss_percentile": 0.79836}, "CVE-2024-48581": {"epss_score": 0.02144, "epss_percentile": 0.8376}, "CVE-2024-48589": {"epss_score": 0.04805, "epss_percentile": 0.89161}, "CVE-2024-48590": {"epss_score": 0.02197, "epss_percentile": 0.8396}, "CVE-2024-48591": {"epss_score": 0.00177, "epss_percentile": 0.39622}, "CVE-2024-48594": {"epss_score": 0.7198, "epss_percentile": 0.98691}, "CVE-2024-48597": {"epss_score": 0.00194, "epss_percentile": 0.41587}, "CVE-2024-48605": {"epss_score": 0.0423, "epss_percentile": 0.8842}, "CVE-2024-48615": {"epss_score": 0.0013, "epss_percentile": 0.3331}, "CVE-2024-48622": {"epss_score": 0.00447, "epss_percentile": 0.62943}, "CVE-2024-48623": {"epss_score": 0.00164, "epss_percentile": 0.37998}, "CVE-2024-48624": {"epss_score": 0.00164, "epss_percentile": 0.37998}, "CVE-2024-48629": {"epss_score": 0.00779, "epss_percentile": 0.73146}, "CVE-2024-48630": {"epss_score": 0.0024, "epss_percentile": 0.46959}, "CVE-2024-48631": {"epss_score": 0.00606, "epss_percentile": 0.69014}, "CVE-2024-48632": {"epss_score": 0.00186, "epss_percentile": 0.40655}, "CVE-2024-48633": {"epss_score": 0.00186, "epss_percentile": 0.40655}, "CVE-2024-48634": {"epss_score": 0.00173, "epss_percentile": 0.39085}, "CVE-2024-48635": {"epss_score": 0.00779, "epss_percentile": 0.73146}, "CVE-2024-48636": {"epss_score": 0.00779, "epss_percentile": 0.73146}, "CVE-2024-48637": {"epss_score": 0.00779, "epss_percentile": 0.73146}, "CVE-2024-48638": {"epss_score": 0.00779, "epss_percentile": 0.73146}, "CVE-2024-48644": {"epss_score": 0.01488, "epss_percentile": 0.80618}, "CVE-2024-48645": {"epss_score": 0.00196, "epss_percentile": 0.41804}, "CVE-2024-48646": {"epss_score": 0.00101, "epss_percentile": 0.28705}, "CVE-2024-48647": {"epss_score": 0.00464, "epss_percentile": 0.63715}, "CVE-2024-48648": {"epss_score": 0.00094, "epss_percentile": 0.27008}, "CVE-2024-48651": {"epss_score": 0.30593, "epss_percentile": 0.96554}, "CVE-2024-48652": {"epss_score": 0.28806, "epss_percentile": 0.96386}, "CVE-2024-48654": {"epss_score": 0.0046, "epss_percentile": 0.63519}, "CVE-2024-48655": {"epss_score": 0.04194, "epss_percentile": 0.8838}, "CVE-2024-48656": {"epss_score": 0.0018, "epss_percentile": 0.3993}, "CVE-2024-48657": {"epss_score": 0.00243, "epss_percentile": 0.47499}, "CVE-2024-48659": {"epss_score": 0.04541, "epss_percentile": 0.88828}, "CVE-2024-48662": {"epss_score": 0.00103, "epss_percentile": 0.29093}, "CVE-2024-48694": {"epss_score": 0.01757, "epss_percentile": 0.82132}, "CVE-2024-48700": {"epss_score": 0.00121, "epss_percentile": 0.31828}, "CVE-2024-48702": {"epss_score": 0.00032, "epss_percentile": 0.08858}, "CVE-2024-48703": {"epss_score": 0.00101, "epss_percentile": 0.28675}, "CVE-2024-48704": {"epss_score": 0.00035, "epss_percentile": 0.09898}, "CVE-2024-48705": {"epss_score": 0.13341, "epss_percentile": 0.93936}, "CVE-2024-48706": {"epss_score": 0.00161, "epss_percentile": 0.37613}, "CVE-2024-48707": {"epss_score": 0.00161, "epss_percentile": 0.37613}, "CVE-2024-48708": {"epss_score": 0.00161, "epss_percentile": 0.37613}, "CVE-2024-48709": {"epss_score": 0.00178, "epss_percentile": 0.39674}, "CVE-2024-48710": {"epss_score": 0.00086, "epss_percentile": 0.254}, "CVE-2024-48712": {"epss_score": 0.00086, "epss_percentile": 0.254}, "CVE-2024-48713": {"epss_score": 0.00086, "epss_percentile": 0.254}, "CVE-2024-48714": {"epss_score": 0.00086, "epss_percentile": 0.254}, "CVE-2024-48729": {"epss_score": 0.00049, "epss_percentile": 0.15469}, "CVE-2024-48730": {"epss_score": 0.00107, "epss_percentile": 0.2958}, "CVE-2024-48733": {"epss_score": 0.12487, "epss_percentile": 0.93688}, "CVE-2024-48734": {"epss_score": 0.03293, "epss_percentile": 0.8684}, "CVE-2024-48735": {"epss_score": 0.02815, "epss_percentile": 0.85731}, "CVE-2024-48743": {"epss_score": 0.01531, "epss_percentile": 0.80889}, "CVE-2024-48744": {"epss_score": 0.00493, "epss_percentile": 0.65036}, "CVE-2024-48746": {"epss_score": 0.05611, "epss_percentile": 0.90047}, "CVE-2024-48747": {"epss_score": 0.00607, "epss_percentile": 0.6903}, "CVE-2024-48758": {"epss_score": 0.00474, "epss_percentile": 0.64139}, "CVE-2024-48760": {"epss_score": 0.04397, "epss_percentile": 0.88641}, "CVE-2024-48761": {"epss_score": 0.00394, "epss_percentile": 0.59758}, "CVE-2024-48766": {"epss_score": 0.77983, "epss_percentile": 0.98963}, "CVE-2024-48768": {"epss_score": 0.00131, "epss_percentile": 0.33386}, "CVE-2024-48769": {"epss_score": 0.00143, "epss_percentile": 0.35185}, "CVE-2024-48770": {"epss_score": 0.00147, "epss_percentile": 0.35783}, "CVE-2024-48771": {"epss_score": 0.00118, "epss_percentile": 0.31455}, "CVE-2024-48772": {"epss_score": 0.0015, "epss_percentile": 0.36142}, "CVE-2024-48773": {"epss_score": 0.00131, "epss_percentile": 0.33386}, "CVE-2024-48774": {"epss_score": 0.00131, "epss_percentile": 0.33386}, "CVE-2024-48775": {"epss_score": 0.00131, "epss_percentile": 0.33386}, "CVE-2024-48776": {"epss_score": 0.00131, "epss_percentile": 0.33386}, "CVE-2024-48777": {"epss_score": 0.00131, "epss_percentile": 0.33386}, "CVE-2024-48778": {"epss_score": 0.00143, "epss_percentile": 0.35185}, "CVE-2024-48779": {"epss_score": 0.01483, "epss_percentile": 0.80583}, "CVE-2024-48781": {"epss_score": 0.02071, "epss_percentile": 0.83481}, "CVE-2024-48782": {"epss_score": 0.01483, "epss_percentile": 0.80583}, "CVE-2024-48783": {"epss_score": 0.00127, "epss_percentile": 0.32896}, "CVE-2024-48784": {"epss_score": 0.00636, "epss_percentile": 0.69865}, "CVE-2024-48786": {"epss_score": 0.00129, "epss_percentile": 0.33148}, "CVE-2024-48787": {"epss_score": 0.00129, "epss_percentile": 0.33148}, "CVE-2024-48788": {"epss_score": 0.0006, "epss_percentile": 0.19021}, "CVE-2024-48789": {"epss_score": 0.00354, "epss_percentile": 0.57242}, "CVE-2024-48790": {"epss_score": 0.01272, "epss_percentile": 0.79081}, "CVE-2024-48791": {"epss_score": 0.00363, "epss_percentile": 0.57892}, "CVE-2024-48792": {"epss_score": 0.00475, "epss_percentile": 0.64178}, "CVE-2024-48793": {"epss_score": 0.00939, "epss_percentile": 0.75725}, "CVE-2024-48795": {"epss_score": 0.01272, "epss_percentile": 0.79081}, "CVE-2024-48796": {"epss_score": 0.00115, "epss_percentile": 0.30985}, "CVE-2024-48797": {"epss_score": 0.00115, "epss_percentile": 0.30985}, "CVE-2024-48798": {"epss_score": 0.00115, "epss_percentile": 0.30985}, "CVE-2024-48799": {"epss_score": 0.00115, "epss_percentile": 0.30985}, "CVE-2024-48806": {"epss_score": 0.00074, "epss_percentile": 0.22838}, "CVE-2024-48807": {"epss_score": 0.00351, "epss_percentile": 0.57037}, "CVE-2024-48809": {"epss_score": 0.0155, "epss_percentile": 0.80986}, "CVE-2024-48813": {"epss_score": 0.01377, "epss_percentile": 0.79842}, "CVE-2024-48814": {"epss_score": 0.0017, "epss_percentile": 0.38732}, "CVE-2024-48818": {"epss_score": 0.00678, "epss_percentile": 0.70984}, "CVE-2024-48821": {"epss_score": 0.0018, "epss_percentile": 0.39915}, "CVE-2024-48822": {"epss_score": 0.00945, "epss_percentile": 0.75802}, "CVE-2024-48823": {"epss_score": 0.01098, "epss_percentile": 0.77541}, "CVE-2024-48824": {"epss_score": 0.0022, "epss_percentile": 0.44629}, "CVE-2024-48825": {"epss_score": 0.02021, "epss_percentile": 0.83295}, "CVE-2024-48826": {"epss_score": 0.02021, "epss_percentile": 0.83295}, "CVE-2024-48827": {"epss_score": 0.06631, "epss_percentile": 0.90904}, "CVE-2024-48828": {"epss_score": 0.00032, "epss_percentile": 0.09001}, "CVE-2024-48829": {"epss_score": 0.0003, "epss_percentile": 0.08305}, "CVE-2024-48830": {"epss_score": 0.00073, "epss_percentile": 0.22475}, "CVE-2024-48831": {"epss_score": 0.00055, "epss_percentile": 0.17627}, "CVE-2024-48837": {"epss_score": 0.00062, "epss_percentile": 0.19715}, "CVE-2024-48838": {"epss_score": 0.00058, "epss_percentile": 0.18374}, "CVE-2024-48839": {"epss_score": 0.01946, "epss_percentile": 0.83001}, "CVE-2024-48840": {"epss_score": 0.02184, "epss_percentile": 0.83913}, "CVE-2024-48841": {"epss_score": 0.04776, "epss_percentile": 0.89131}, "CVE-2024-48842": {"epss_score": 0.00025, "epss_percentile": 0.0633}, "CVE-2024-48843": {"epss_score": 0.00231, "epss_percentile": 0.45849}, "CVE-2024-48844": {"epss_score": 0.00845, "epss_percentile": 0.74317}, "CVE-2024-48845": {"epss_score": 0.02755, "epss_percentile": 0.85591}, "CVE-2024-48846": {"epss_score": 0.00123, "epss_percentile": 0.32212}, "CVE-2024-48847": {"epss_score": 0.00092, "epss_percentile": 0.26545}, "CVE-2024-48848": {"epss_score": 0.00058, "epss_percentile": 0.18422}, "CVE-2024-48849": {"epss_score": 0.00187, "epss_percentile": 0.40762}, "CVE-2024-48850": {"epss_score": 0.00057, "epss_percentile": 0.18161}, "CVE-2024-48851": {"epss_score": 0.00304, "epss_percentile": 0.53288}, "CVE-2024-48852": {"epss_score": 0.01824, "epss_percentile": 0.82429}, "CVE-2024-48853": {"epss_score": 0.00048, "epss_percentile": 0.15108}, "CVE-2024-48854": {"epss_score": 0.00284, "epss_percentile": 0.51494}, "CVE-2024-48855": {"epss_score": 0.00284, "epss_percentile": 0.51494}, "CVE-2024-48856": {"epss_score": 0.01215, "epss_percentile": 0.78583}, "CVE-2024-48857": {"epss_score": 0.00251, "epss_percentile": 0.48305}, "CVE-2024-48858": {"epss_score": 0.00186, "epss_percentile": 0.40662}, "CVE-2024-48859": {"epss_score": 0.00207, "epss_percentile": 0.43196}, "CVE-2024-48860": {"epss_score": 0.01552, "epss_percentile": 0.80992}, "CVE-2024-48861": {"epss_score": 0.00262, "epss_percentile": 0.49332}, "CVE-2024-48862": {"epss_score": 0.01149, "epss_percentile": 0.78017}, "CVE-2024-48863": {"epss_score": 0.00903, "epss_percentile": 0.75208}, "CVE-2024-48864": {"epss_score": 0.00116, "epss_percentile": 0.31141}, "CVE-2024-48865": {"epss_score": 0.00042, "epss_percentile": 0.12916}, "CVE-2024-48866": {"epss_score": 0.00119, "epss_percentile": 0.31579}, "CVE-2024-48867": {"epss_score": 0.0012, "epss_percentile": 0.31724}, "CVE-2024-48868": {"epss_score": 0.0012, "epss_percentile": 0.31724}, "CVE-2024-48869": {"epss_score": 0.00011, "epss_percentile": 0.01021}, "CVE-2024-48870": {"epss_score": 0.00344, "epss_percentile": 0.56495}, "CVE-2024-48871": {"epss_score": 0.007, "epss_percentile": 0.71462}, "CVE-2024-48872": {"epss_score": 0.00094, "epss_percentile": 0.26785}, "CVE-2024-48873": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-48874": {"epss_score": 0.00173, "epss_percentile": 0.39075}, "CVE-2024-48875": {"epss_score": 0.00023, "epss_percentile": 0.05507}, "CVE-2024-48876": {"epss_score": 0.00028, "epss_percentile": 0.07235}, "CVE-2024-48877": {"epss_score": 0.00045, "epss_percentile": 0.13742}, "CVE-2024-48878": {"epss_score": 0.00255, "epss_percentile": 0.4865}, "CVE-2024-48881": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2024-48882": {"epss_score": 0.00058, "epss_percentile": 0.18528}, "CVE-2024-48883": {"epss_score": 0.00072, "epss_percentile": 0.22309}, "CVE-2024-48884": {"epss_score": 0.00569, "epss_percentile": 0.67912}, "CVE-2024-48885": {"epss_score": 0.00077, "epss_percentile": 0.23413}, "CVE-2024-48886": {"epss_score": 0.00154, "epss_percentile": 0.36676}, "CVE-2024-48887": {"epss_score": 0.00151, "epss_percentile": 0.36184}, "CVE-2024-48889": {"epss_score": 0.00753, "epss_percentile": 0.72675}, "CVE-2024-48890": {"epss_score": 0.00919, "epss_percentile": 0.75453}, "CVE-2024-48891": {"epss_score": 0.00046, "epss_percentile": 0.1419}, "CVE-2024-48892": {"epss_score": 0.00045, "epss_percentile": 0.13809}, "CVE-2024-48893": {"epss_score": 0.00191, "epss_percentile": 0.41148}, "CVE-2024-48894": {"epss_score": 0.00034, "epss_percentile": 0.09793}, "CVE-2024-48895": {"epss_score": 0.01069, "epss_percentile": 0.77245}, "CVE-2024-48896": {"epss_score": 0.00174, "epss_percentile": 0.39224}, "CVE-2024-48897": {"epss_score": 0.00175, "epss_percentile": 0.39358}, "CVE-2024-48898": {"epss_score": 0.00175, "epss_percentile": 0.39358}, "CVE-2024-48899": {"epss_score": 0.00142, "epss_percentile": 0.34997}, "CVE-2024-48900": {"epss_score": 0.00195, "epss_percentile": 0.416}, "CVE-2024-48901": {"epss_score": 0.00175, "epss_percentile": 0.39358}, "CVE-2024-48902": {"epss_score": 3e-05, "epss_percentile": 0.00116}, "CVE-2024-48903": {"epss_score": 0.00086, "epss_percentile": 0.25427}, "CVE-2024-48904": {"epss_score": 0.13301, "epss_percentile": 0.93926}, "CVE-2024-48905": {"epss_score": 0.00076, "epss_percentile": 0.23257}, "CVE-2024-48906": {"epss_score": 0.00037, "epss_percentile": 0.10777}, "CVE-2024-48907": {"epss_score": 0.00069, "epss_percentile": 0.21597}, "CVE-2024-48908": {"epss_score": 0.00025, "epss_percentile": 0.06288}, "CVE-2024-48909": {"epss_score": 0.00084, "epss_percentile": 0.24874}, "CVE-2024-48910": {"epss_score": 0.02086, "epss_percentile": 0.83552}, "CVE-2024-48911": {"epss_score": 0.00186, "epss_percentile": 0.40668}, "CVE-2024-48912": {"epss_score": 0.00431, "epss_percentile": 0.62089}, "CVE-2024-48913": {"epss_score": 0.00132, "epss_percentile": 0.33546}, "CVE-2024-48914": {"epss_score": 0.92383, "epss_percentile": 0.99712}, "CVE-2024-48915": {"epss_score": 0.00066, "epss_percentile": 0.20878}, "CVE-2024-48916": {"epss_score": 0.00051, "epss_percentile": 0.16213}, "CVE-2024-48917": {"epss_score": 0.00291, "epss_percentile": 0.52179}, "CVE-2024-48918": {"epss_score": 0.00096, "epss_percentile": 0.27306}, "CVE-2024-48919": {"epss_score": 0.00231, "epss_percentile": 0.45788}, "CVE-2024-48920": {"epss_score": 0.00226, "epss_percentile": 0.45259}, "CVE-2024-48921": {"epss_score": 0.00325, "epss_percentile": 0.55012}, "CVE-2024-48924": {"epss_score": 0.0006, "epss_percentile": 0.19158}, "CVE-2024-48925": {"epss_score": 0.00274, "epss_percentile": 0.50534}, "CVE-2024-48926": {"epss_score": 0.00375, "epss_percentile": 0.58634}, "CVE-2024-48927": {"epss_score": 0.00769, "epss_percentile": 0.7299}, "CVE-2024-48929": {"epss_score": 0.00372, "epss_percentile": 0.5844}, "CVE-2024-48930": {"epss_score": 0.00175, "epss_percentile": 0.39364}, "CVE-2024-48931": {"epss_score": 0.00281, "epss_percentile": 0.51121}, "CVE-2024-48932": {"epss_score": 0.00535, "epss_percentile": 0.6683}, "CVE-2024-48933": {"epss_score": 0.00118, "epss_percentile": 0.31502}, "CVE-2024-48936": {"epss_score": 0.00085, "epss_percentile": 0.25072}, "CVE-2024-48937": {"epss_score": 0.00865, "epss_percentile": 0.7462}, "CVE-2024-48938": {"epss_score": 0.00699, "epss_percentile": 0.71433}, "CVE-2024-48939": {"epss_score": 0.00225, "epss_percentile": 0.45137}, "CVE-2024-48941": {"epss_score": 0.00139, "epss_percentile": 0.34571}, "CVE-2024-48942": {"epss_score": 0.00335, "epss_percentile": 0.55815}, "CVE-2024-48944": {"epss_score": 0.00118, "epss_percentile": 0.31501}, "CVE-2024-48948": {"epss_score": 0.00157, "epss_percentile": 0.37102}, "CVE-2024-48949": {"epss_score": 0.00114, "epss_percentile": 0.30867}, "CVE-2024-48950": {"epss_score": 0.00078, "epss_percentile": 0.23689}, "CVE-2024-48951": {"epss_score": 0.00068, "epss_percentile": 0.214}, "CVE-2024-48952": {"epss_score": 0.0011, "epss_percentile": 0.30172}, "CVE-2024-48953": {"epss_score": 0.00183, "epss_percentile": 0.4028}, "CVE-2024-48954": {"epss_score": 0.01822, "epss_percentile": 0.82415}, "CVE-2024-48955": {"epss_score": 0.08867, "epss_percentile": 0.92293}, "CVE-2024-48956": {"epss_score": 0.01641, "epss_percentile": 0.81505}, "CVE-2024-48957": {"epss_score": 0.0009, "epss_percentile": 0.26057}, "CVE-2024-48958": {"epss_score": 0.00059, "epss_percentile": 0.1885}, "CVE-2024-48962": {"epss_score": 0.0024, "epss_percentile": 0.47227}, "CVE-2024-48963": {"epss_score": 0.0013, "epss_percentile": 0.33271}, "CVE-2024-48964": {"epss_score": 0.00072, "epss_percentile": 0.2236}, "CVE-2024-48966": {"epss_score": 0.00184, "epss_percentile": 0.40438}, "CVE-2024-48967": {"epss_score": 0.00206, "epss_percentile": 0.42781}, "CVE-2024-48970": {"epss_score": 0.00065, "epss_percentile": 0.20588}, "CVE-2024-48971": {"epss_score": 0.00065, "epss_percentile": 0.20588}, "CVE-2024-48973": {"epss_score": 0.00065, "epss_percentile": 0.20588}, "CVE-2024-48974": {"epss_score": 0.00056, "epss_percentile": 0.17925}, "CVE-2024-48981": {"epss_score": 0.00295, "epss_percentile": 0.52444}, "CVE-2024-48982": {"epss_score": 0.00571, "epss_percentile": 0.67992}, "CVE-2024-48983": {"epss_score": 0.00582, "epss_percentile": 0.68294}, "CVE-2024-48984": {"epss_score": 0.0046, "epss_percentile": 0.63531}, "CVE-2024-48985": {"epss_score": 0.00295, "epss_percentile": 0.52444}, "CVE-2024-48986": {"epss_score": 0.00415, "epss_percentile": 0.61114}, "CVE-2024-48987": {"epss_score": 0.02031, "epss_percentile": 0.83334}, "CVE-2024-48988": {"epss_score": 0.00071, "epss_percentile": 0.21993}, "CVE-2024-48989": {"epss_score": 0.0035, "epss_percentile": 0.56969}, "CVE-2024-48990": {"epss_score": 0.15824, "epss_percentile": 0.94515}, "CVE-2024-48991": {"epss_score": 0.0025, "epss_percentile": 0.48241}, "CVE-2024-48992": {"epss_score": 0.01102, "epss_percentile": 0.77588}, "CVE-2024-48993": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-48994": {"epss_score": 0.0298, "epss_percentile": 0.86121}, "CVE-2024-48995": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-48996": {"epss_score": 0.02216, "epss_percentile": 0.84035}, "CVE-2024-48997": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-48998": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-48999": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49000": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49001": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49002": {"epss_score": 0.05325, "epss_percentile": 0.89733}, "CVE-2024-49003": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49004": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49005": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49006": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49007": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49008": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49009": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49010": {"epss_score": 0.05325, "epss_percentile": 0.89733}, "CVE-2024-49011": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49012": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49013": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49014": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49015": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49016": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49017": {"epss_score": 0.03993, "epss_percentile": 0.88081}, "CVE-2024-49018": {"epss_score": 0.06243, "epss_percentile": 0.90598}, "CVE-2024-49019": {"epss_score": 0.05515, "epss_percentile": 0.89949}, "CVE-2024-49021": {"epss_score": 0.00886, "epss_percentile": 0.74954}, "CVE-2024-49023": {"epss_score": 0.00995, "epss_percentile": 0.76433}, "CVE-2024-49025": {"epss_score": 0.0022, "epss_percentile": 0.44557}, "CVE-2024-49026": {"epss_score": 0.00255, "epss_percentile": 0.48643}, "CVE-2024-49027": {"epss_score": 0.00714, "epss_percentile": 0.71809}, "CVE-2024-49028": {"epss_score": 0.00714, "epss_percentile": 0.71809}, "CVE-2024-49029": {"epss_score": 0.00817, "epss_percentile": 0.7384}, "CVE-2024-49030": {"epss_score": 0.00714, "epss_percentile": 0.71809}, "CVE-2024-49031": {"epss_score": 0.00792, "epss_percentile": 0.73398}, "CVE-2024-49032": {"epss_score": 0.00792, "epss_percentile": 0.73398}, "CVE-2024-49033": {"epss_score": 0.04293, "epss_percentile": 0.88504}, "CVE-2024-49035": {"epss_score": 0.06163, "epss_percentile": 0.90527}, "CVE-2024-49038": {"epss_score": 0.00231, "epss_percentile": 0.45773}, "CVE-2024-49039": {"epss_score": 0.58341, "epss_percentile": 0.98111}, "CVE-2024-49040": {"epss_score": 0.05393, "epss_percentile": 0.89825}, "CVE-2024-49041": {"epss_score": 0.00867, "epss_percentile": 0.74659}, "CVE-2024-49042": {"epss_score": 0.01027, "epss_percentile": 0.76803}, "CVE-2024-49043": {"epss_score": 0.00449, "epss_percentile": 0.63049}, "CVE-2024-49044": {"epss_score": 0.00132, "epss_percentile": 0.33561}, "CVE-2024-49046": {"epss_score": 0.00237, "epss_percentile": 0.46733}, "CVE-2024-49048": {"epss_score": 0.005, "epss_percentile": 0.65294}, "CVE-2024-49049": {"epss_score": 0.0042, "epss_percentile": 0.61438}, "CVE-2024-49050": {"epss_score": 0.02963, "epss_percentile": 0.86074}, "CVE-2024-49051": {"epss_score": 0.00593, "epss_percentile": 0.68648}, "CVE-2024-49052": {"epss_score": 0.0202, "epss_percentile": 0.83293}, "CVE-2024-49053": {"epss_score": 0.00126, "epss_percentile": 0.32778}, "CVE-2024-49054": {"epss_score": 0.00145, "epss_percentile": 0.35445}, "CVE-2024-49056": {"epss_score": 0.02193, "epss_percentile": 0.83945}, "CVE-2024-49057": {"epss_score": 0.05784, "epss_percentile": 0.90205}, "CVE-2024-49059": {"epss_score": 0.00178, "epss_percentile": 0.39686}, "CVE-2024-49060": {"epss_score": 0.01024, "epss_percentile": 0.76777}, "CVE-2024-49062": {"epss_score": 0.05312, "epss_percentile": 0.89718}, "CVE-2024-49063": {"epss_score": 0.00408, "epss_percentile": 0.60679}, "CVE-2024-49064": {"epss_score": 0.01153, "epss_percentile": 0.7806}, "CVE-2024-49065": {"epss_score": 0.00451, "epss_percentile": 0.63156}, "CVE-2024-49068": {"epss_score": 0.07073, "epss_percentile": 0.91231}, "CVE-2024-49069": {"epss_score": 0.00616, "epss_percentile": 0.69317}, "CVE-2024-49070": {"epss_score": 0.00093, "epss_percentile": 0.26754}, "CVE-2024-49071": {"epss_score": 0.01012, "epss_percentile": 0.76618}, "CVE-2024-49072": {"epss_score": 0.00299, "epss_percentile": 0.52879}, "CVE-2024-49073": {"epss_score": 0.00635, "epss_percentile": 0.69815}, "CVE-2024-49074": {"epss_score": 0.00299, "epss_percentile": 0.52879}, "CVE-2024-49075": {"epss_score": 0.0578, "epss_percentile": 0.902}, "CVE-2024-49076": {"epss_score": 0.00274, "epss_percentile": 0.50575}, "CVE-2024-49077": {"epss_score": 0.00734, "epss_percentile": 0.72245}, "CVE-2024-49078": {"epss_score": 0.00734, "epss_percentile": 0.72245}, "CVE-2024-49079": {"epss_score": 0.00835, "epss_percentile": 0.74114}, "CVE-2024-49080": {"epss_score": 0.06192, "epss_percentile": 0.9055}, "CVE-2024-49081": {"epss_score": 0.00626, "epss_percentile": 0.69617}, "CVE-2024-49082": {"epss_score": 0.00225, "epss_percentile": 0.45149}, "CVE-2024-49083": {"epss_score": 0.00619, "epss_percentile": 0.69429}, "CVE-2024-49084": {"epss_score": 0.00136, "epss_percentile": 0.34131}, "CVE-2024-49085": {"epss_score": 0.05182, "epss_percentile": 0.89581}, "CVE-2024-49086": {"epss_score": 0.05182, "epss_percentile": 0.89581}, "CVE-2024-49087": {"epss_score": 0.00781, "epss_percentile": 0.73191}, "CVE-2024-49088": {"epss_score": 0.00511, "epss_percentile": 0.65845}, "CVE-2024-49089": {"epss_score": 0.08134, "epss_percentile": 0.91896}, "CVE-2024-49090": {"epss_score": 0.00511, "epss_percentile": 0.65845}, "CVE-2024-49091": {"epss_score": 0.01605, "epss_percentile": 0.81286}, "CVE-2024-49092": {"epss_score": 0.00566, "epss_percentile": 0.67828}, "CVE-2024-49093": {"epss_score": 0.00603, "epss_percentile": 0.68907}, "CVE-2024-49094": {"epss_score": 0.00573, "epss_percentile": 0.68042}, "CVE-2024-49095": {"epss_score": 0.00126, "epss_percentile": 0.32741}, "CVE-2024-49096": {"epss_score": 0.16729, "epss_percentile": 0.94723}, "CVE-2024-49097": {"epss_score": 0.00126, "epss_percentile": 0.32741}, "CVE-2024-49098": {"epss_score": 0.00409, "epss_percentile": 0.60692}, "CVE-2024-49099": {"epss_score": 0.00409, "epss_percentile": 0.60692}, "CVE-2024-49101": {"epss_score": 0.00573, "epss_percentile": 0.68042}, "CVE-2024-49102": {"epss_score": 0.05182, "epss_percentile": 0.89581}, "CVE-2024-49103": {"epss_score": 0.00444, "epss_percentile": 0.62825}, "CVE-2024-49104": {"epss_score": 0.05182, "epss_percentile": 0.89581}, "CVE-2024-49105": {"epss_score": 0.01554, "epss_percentile": 0.81001}, "CVE-2024-49106": {"epss_score": 0.00385, "epss_percentile": 0.5919}, "CVE-2024-49107": {"epss_score": 0.00873, "epss_percentile": 0.74747}, "CVE-2024-49108": {"epss_score": 0.00385, "epss_percentile": 0.5919}, "CVE-2024-49109": {"epss_score": 0.00573, "epss_percentile": 0.68042}, "CVE-2024-49110": {"epss_score": 0.00462, "epss_percentile": 0.63572}, "CVE-2024-49111": {"epss_score": 0.00467, "epss_percentile": 0.63828}, "CVE-2024-49112": {"epss_score": 0.87774, "epss_percentile": 0.99442}, "CVE-2024-49113": {"epss_score": 0.85465, "epss_percentile": 0.99334}, "CVE-2024-49114": {"epss_score": 0.00274, "epss_percentile": 0.50558}, "CVE-2024-49115": {"epss_score": 0.00605, "epss_percentile": 0.68986}, "CVE-2024-49116": {"epss_score": 0.01113, "epss_percentile": 0.77692}, "CVE-2024-49117": {"epss_score": 0.00378, "epss_percentile": 0.58827}, "CVE-2024-49118": {"epss_score": 0.00447, "epss_percentile": 0.62958}, "CVE-2024-49119": {"epss_score": 0.00461, "epss_percentile": 0.6357}, "CVE-2024-49120": {"epss_score": 0.0034, "epss_percentile": 0.56233}, "CVE-2024-49121": {"epss_score": 0.18964, "epss_percentile": 0.95103}, "CVE-2024-49122": {"epss_score": 0.00728, "epss_percentile": 0.72116}, "CVE-2024-49123": {"epss_score": 0.00467, "epss_percentile": 0.63819}, "CVE-2024-49124": {"epss_score": 0.00351, "epss_percentile": 0.57076}, "CVE-2024-49125": {"epss_score": 0.02089, "epss_percentile": 0.83562}, "CVE-2024-49126": {"epss_score": 0.00605, "epss_percentile": 0.68986}, "CVE-2024-49127": {"epss_score": 0.00605, "epss_percentile": 0.68986}, "CVE-2024-49128": {"epss_score": 0.00385, "epss_percentile": 0.5919}, "CVE-2024-49129": {"epss_score": 0.00393, "epss_percentile": 0.59718}, "CVE-2024-49132": {"epss_score": 0.00605, "epss_percentile": 0.68986}, "CVE-2024-49138": {"epss_score": 0.88705, "epss_percentile": 0.99485}, "CVE-2024-49142": {"epss_score": 0.00538, "epss_percentile": 0.66926}, "CVE-2024-49147": {"epss_score": 0.01154, "epss_percentile": 0.78064}, "CVE-2024-49193": {"epss_score": 0.00065, "epss_percentile": 0.20509}, "CVE-2024-49194": {"epss_score": 0.00314, "epss_percentile": 0.54106}, "CVE-2024-49195": {"epss_score": 0.00735, "epss_percentile": 0.72291}, "CVE-2024-49196": {"epss_score": 0.00113, "epss_percentile": 0.30602}, "CVE-2024-49197": {"epss_score": 0.00042, "epss_percentile": 0.12614}, "CVE-2024-49200": {"epss_score": 0.00092, "epss_percentile": 0.26548}, "CVE-2024-49201": {"epss_score": 0.00119, "epss_percentile": 0.31576}, "CVE-2024-49202": {"epss_score": 0.00148, "epss_percentile": 0.3584}, "CVE-2024-49203": {"epss_score": 0.00115, "epss_percentile": 0.30935}, "CVE-2024-49208": {"epss_score": 0.00072, "epss_percentile": 0.2243}, "CVE-2024-49209": {"epss_score": 0.00058, "epss_percentile": 0.18381}, "CVE-2024-49210": {"epss_score": 0.00247, "epss_percentile": 0.4786}, "CVE-2024-49211": {"epss_score": 0.00247, "epss_percentile": 0.4786}, "CVE-2024-49214": {"epss_score": 0.00137, "epss_percentile": 0.34312}, "CVE-2024-49216": {"epss_score": 0.00716, "epss_percentile": 0.71858}, "CVE-2024-49217": {"epss_score": 0.00223, "epss_percentile": 0.44944}, "CVE-2024-49218": {"epss_score": 0.00439, "epss_percentile": 0.62585}, "CVE-2024-49219": {"epss_score": 0.00188, "epss_percentile": 0.40909}, "CVE-2024-49220": {"epss_score": 0.00103, "epss_percentile": 0.29006}, "CVE-2024-49221": {"epss_score": 0.00122, "epss_percentile": 0.32052}, "CVE-2024-49222": {"epss_score": 0.00384, "epss_percentile": 0.59161}, "CVE-2024-49223": {"epss_score": 0.00122, "epss_percentile": 0.32052}, "CVE-2024-49224": {"epss_score": 0.00247, "epss_percentile": 0.47904}, "CVE-2024-49225": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-49226": {"epss_score": 0.00611, "epss_percentile": 0.69189}, "CVE-2024-49227": {"epss_score": 0.00611, "epss_percentile": 0.69189}, "CVE-2024-49228": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-49229": {"epss_score": 0.00103, "epss_percentile": 0.29006}, "CVE-2024-49230": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-49231": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-49232": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-49233": {"epss_score": 0.00222, "epss_percentile": 0.44774}, "CVE-2024-49234": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-49235": {"epss_score": 0.00618, "epss_percentile": 0.69365}, "CVE-2024-49236": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-49237": {"epss_score": 0.00103, "epss_percentile": 0.29006}, "CVE-2024-49238": {"epss_score": 0.00182, "epss_percentile": 0.40227}, "CVE-2024-49239": {"epss_score": 0.00182, "epss_percentile": 0.40227}, "CVE-2024-49240": {"epss_score": 0.00154, "epss_percentile": 0.36704}, "CVE-2024-49241": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-49242": {"epss_score": 0.00716, "epss_percentile": 0.71858}, "CVE-2024-49243": {"epss_score": 0.01819, "epss_percentile": 0.82406}, "CVE-2024-49244": {"epss_score": 0.00202, "epss_percentile": 0.42408}, "CVE-2024-49245": {"epss_score": 0.00881, "epss_percentile": 0.74873}, "CVE-2024-49246": {"epss_score": 0.00202, "epss_percentile": 0.42397}, "CVE-2024-49247": {"epss_score": 0.00208, "epss_percentile": 0.43253}, "CVE-2024-49248": {"epss_score": 0.002, "epss_percentile": 0.42231}, "CVE-2024-49249": {"epss_score": 0.00188, "epss_percentile": 0.40835}, "CVE-2024-49250": {"epss_score": 0.002, "epss_percentile": 0.42255}, "CVE-2024-49251": {"epss_score": 0.02882, "epss_percentile": 0.85901}, "CVE-2024-49252": {"epss_score": 0.00443, "epss_percentile": 0.6279}, "CVE-2024-49253": {"epss_score": 0.0042, "epss_percentile": 0.61427}, "CVE-2024-49254": {"epss_score": 0.00518, "epss_percentile": 0.66116}, "CVE-2024-49255": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-49256": {"epss_score": 0.00244, "epss_percentile": 0.47595}, "CVE-2024-49257": {"epss_score": 0.00606, "epss_percentile": 0.69019}, "CVE-2024-49258": {"epss_score": 0.01159, "epss_percentile": 0.78125}, "CVE-2024-49259": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-49260": {"epss_score": 0.00879, "epss_percentile": 0.74842}, "CVE-2024-49261": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-49262": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-49263": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-49264": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-49265": {"epss_score": 0.00155, "epss_percentile": 0.36876}, "CVE-2024-49266": {"epss_score": 0.00118, "epss_percentile": 0.31475}, "CVE-2024-49267": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-49268": {"epss_score": 0.00167, "epss_percentile": 0.38283}, "CVE-2024-49270": {"epss_score": 0.00242, "epss_percentile": 0.47404}, "CVE-2024-49271": {"epss_score": 0.02059, "epss_percentile": 0.83435}, "CVE-2024-49272": {"epss_score": 0.002, "epss_percentile": 0.42255}, "CVE-2024-49273": {"epss_score": 0.0018, "epss_percentile": 0.39866}, "CVE-2024-49274": {"epss_score": 0.00144, "epss_percentile": 0.35335}, "CVE-2024-49275": {"epss_score": 0.002, "epss_percentile": 0.42255}, "CVE-2024-49276": {"epss_score": 0.00186, "epss_percentile": 0.40583}, "CVE-2024-49277": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-49278": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-49279": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-49280": {"epss_score": 0.0017, "epss_percentile": 0.38698}, "CVE-2024-49281": {"epss_score": 0.0012, "epss_percentile": 0.31731}, "CVE-2024-49282": {"epss_score": 0.00118, "epss_percentile": 0.31475}, "CVE-2024-49283": {"epss_score": 0.00236, "epss_percentile": 0.46446}, "CVE-2024-49284": {"epss_score": 0.00311, "epss_percentile": 0.53811}, "CVE-2024-49285": {"epss_score": 0.00587, "epss_percentile": 0.68487}, "CVE-2024-49286": {"epss_score": 0.00518, "epss_percentile": 0.66127}, "CVE-2024-49287": {"epss_score": 0.00655, "epss_percentile": 0.70368}, "CVE-2024-49288": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2024-49289": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2024-49290": {"epss_score": 0.00398, "epss_percentile": 0.6007}, "CVE-2024-49291": {"epss_score": 0.00606, "epss_percentile": 0.69019}, "CVE-2024-49292": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-49293": {"epss_score": 0.00162, "epss_percentile": 0.37727}, "CVE-2024-49294": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-49295": {"epss_score": 0.00161, "epss_percentile": 0.37525}, "CVE-2024-49296": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2024-49297": {"epss_score": 0.00332, "epss_percentile": 0.55571}, "CVE-2024-49298": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2024-49299": {"epss_score": 0.00225, "epss_percentile": 0.45231}, "CVE-2024-49300": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2024-49301": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2024-49302": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2024-49303": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2024-49304": {"epss_score": 0.00131, "epss_percentile": 0.3348}, "CVE-2024-49305": {"epss_score": 0.00238, "epss_percentile": 0.46803}, "CVE-2024-49306": {"epss_score": 0.00193, "epss_percentile": 0.41491}, "CVE-2024-49307": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2024-49308": {"epss_score": 0.00231, "epss_percentile": 0.45766}, "CVE-2024-49309": {"epss_score": 0.00252, "epss_percentile": 0.48377}, "CVE-2024-49310": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-49311": {"epss_score": 0.00211, "epss_percentile": 0.43695}, "CVE-2024-49312": {"epss_score": 0.00342, "epss_percentile": 0.56356}, "CVE-2024-49313": {"epss_score": 0.00124, "epss_percentile": 0.32393}, "CVE-2024-49314": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2024-49315": {"epss_score": 0.00211, "epss_percentile": 0.43647}, "CVE-2024-49316": {"epss_score": 0.00242, "epss_percentile": 0.47393}, "CVE-2024-49317": {"epss_score": 0.03424, "epss_percentile": 0.8711}, "CVE-2024-49318": {"epss_score": 0.00474, "epss_percentile": 0.64155}, "CVE-2024-49319": {"epss_score": 0.00231, "epss_percentile": 0.45784}, "CVE-2024-49320": {"epss_score": 0.00106, "epss_percentile": 0.29476}, "CVE-2024-49321": {"epss_score": 0.0017, "epss_percentile": 0.38742}, "CVE-2024-49322": {"epss_score": 0.00206, "epss_percentile": 0.42766}, "CVE-2024-49323": {"epss_score": 0.00113, "epss_percentile": 0.30583}, "CVE-2024-49324": {"epss_score": 0.00426, "epss_percentile": 0.61739}, "CVE-2024-49325": {"epss_score": 0.00533, "epss_percentile": 0.66769}, "CVE-2024-49326": {"epss_score": 0.00426, "epss_percentile": 0.61739}, "CVE-2024-49327": {"epss_score": 0.00394, "epss_percentile": 0.59762}, "CVE-2024-49328": {"epss_score": 0.48064, "epss_percentile": 0.97617}, "CVE-2024-49329": {"epss_score": 0.00592, "epss_percentile": 0.68618}, "CVE-2024-49330": {"epss_score": 0.00394, "epss_percentile": 0.59762}, "CVE-2024-49331": {"epss_score": 0.00466, "epss_percentile": 0.63786}, "CVE-2024-49332": {"epss_score": 0.00381, "epss_percentile": 0.58988}, "CVE-2024-49333": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2024-49334": {"epss_score": 0.00113, "epss_percentile": 0.30583}, "CVE-2024-49335": {"epss_score": 0.0014, "epss_percentile": 0.34724}, "CVE-2024-49336": {"epss_score": 0.00077, "epss_percentile": 0.23468}, "CVE-2024-49337": {"epss_score": 0.00066, "epss_percentile": 0.20893}, "CVE-2024-49338": {"epss_score": 0.00086, "epss_percentile": 0.25314}, "CVE-2024-49339": {"epss_score": 0.00044, "epss_percentile": 0.13456}, "CVE-2024-49340": {"epss_score": 0.00075, "epss_percentile": 0.2297}, "CVE-2024-49342": {"epss_score": 0.00046, "epss_percentile": 0.14094}, "CVE-2024-49343": {"epss_score": 0.00023, "epss_percentile": 0.0548}, "CVE-2024-49344": {"epss_score": 0.00073, "epss_percentile": 0.22603}, "CVE-2024-49348": {"epss_score": 0.00092, "epss_percentile": 0.26569}, "CVE-2024-49349": {"epss_score": 0.00044, "epss_percentile": 0.13456}, "CVE-2024-49350": {"epss_score": 0.00072, "epss_percentile": 0.22364}, "CVE-2024-49351": {"epss_score": 0.00015, "epss_percentile": 0.02535}, "CVE-2024-49352": {"epss_score": 0.00589, "epss_percentile": 0.68531}, "CVE-2024-49353": {"epss_score": 0.00027, "epss_percentile": 0.06805}, "CVE-2024-49354": {"epss_score": 0.00184, "epss_percentile": 0.40422}, "CVE-2024-49355": {"epss_score": 0.00077, "epss_percentile": 0.23378}, "CVE-2024-49357": {"epss_score": 0.02309, "epss_percentile": 0.84331}, "CVE-2024-49358": {"epss_score": 0.00236, "epss_percentile": 0.46392}, "CVE-2024-49359": {"epss_score": 0.008, "epss_percentile": 0.73537}, "CVE-2024-49360": {"epss_score": 0.00165, "epss_percentile": 0.38046}, "CVE-2024-49361": {"epss_score": 0.00316, "epss_percentile": 0.54242}, "CVE-2024-49362": {"epss_score": 0.01896, "epss_percentile": 0.82755}, "CVE-2024-49363": {"epss_score": 0.00065, "epss_percentile": 0.20528}, "CVE-2024-49364": {"epss_score": 0.00058, "epss_percentile": 0.18613}, "CVE-2024-49365": {"epss_score": 0.00033, "epss_percentile": 0.09231}, "CVE-2024-49366": {"epss_score": 0.00681, "epss_percentile": 0.71058}, "CVE-2024-49367": {"epss_score": 0.00427, "epss_percentile": 0.61824}, "CVE-2024-49368": {"epss_score": 0.67525, "epss_percentile": 0.98511}, "CVE-2024-49369": {"epss_score": 0.20458, "epss_percentile": 0.95348}, "CVE-2024-49370": {"epss_score": 0.00012, "epss_percentile": 0.01254}, "CVE-2024-49373": {"epss_score": 0.00418, "epss_percentile": 0.61324}, "CVE-2024-49375": {"epss_score": 0.01158, "epss_percentile": 0.78118}, "CVE-2024-49376": {"epss_score": 0.00274, "epss_percentile": 0.5052}, "CVE-2024-49377": {"epss_score": 0.00247, "epss_percentile": 0.47843}, "CVE-2024-49378": {"epss_score": 0.00295, "epss_percentile": 0.52454}, "CVE-2024-49379": {"epss_score": 0.04843, "epss_percentile": 0.89204}, "CVE-2024-49380": {"epss_score": 0.66632, "epss_percentile": 0.98471}, "CVE-2024-49381": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2024-49382": {"epss_score": 0.00116, "epss_percentile": 0.31176}, "CVE-2024-49383": {"epss_score": 0.00116, "epss_percentile": 0.31176}, "CVE-2024-49384": {"epss_score": 0.00116, "epss_percentile": 0.31176}, "CVE-2024-49385": {"epss_score": 0.00019, "epss_percentile": 0.04138}, "CVE-2024-49386": {"epss_score": 0.00119, "epss_percentile": 0.31566}, "CVE-2024-49387": {"epss_score": 0.00155, "epss_percentile": 0.36783}, "CVE-2024-49388": {"epss_score": 0.0027, "epss_percentile": 0.50234}, "CVE-2024-49389": {"epss_score": 0.00038, "epss_percentile": 0.11216}, "CVE-2024-49390": {"epss_score": 0.00063, "epss_percentile": 0.1988}, "CVE-2024-49391": {"epss_score": 0.00063, "epss_percentile": 0.1988}, "CVE-2024-49392": {"epss_score": 0.00236, "epss_percentile": 0.46384}, "CVE-2024-49393": {"epss_score": 0.00061, "epss_percentile": 0.19381}, "CVE-2024-49394": {"epss_score": 0.00082, "epss_percentile": 0.24494}, "CVE-2024-49395": {"epss_score": 0.00108, "epss_percentile": 0.29834}, "CVE-2024-49396": {"epss_score": 0.00217, "epss_percentile": 0.44331}, "CVE-2024-49397": {"epss_score": 0.00043, "epss_percentile": 0.1331}, "CVE-2024-49398": {"epss_score": 0.00158, "epss_percentile": 0.37198}, "CVE-2024-49399": {"epss_score": 0.0016, "epss_percentile": 0.37466}, "CVE-2024-49400": {"epss_score": 0.00224, "epss_percentile": 0.45004}, "CVE-2024-49401": {"epss_score": 0.00071, "epss_percentile": 0.22122}, "CVE-2024-49402": {"epss_score": 0.00123, "epss_percentile": 0.32262}, "CVE-2024-49403": {"epss_score": 0.00158, "epss_percentile": 0.37185}, "CVE-2024-49404": {"epss_score": 0.00123, "epss_percentile": 0.32271}, "CVE-2024-49405": {"epss_score": 0.0016, "epss_percentile": 0.37453}, "CVE-2024-49406": {"epss_score": 0.00038, "epss_percentile": 0.11404}, "CVE-2024-49407": {"epss_score": 0.00158, "epss_percentile": 0.37185}, "CVE-2024-49408": {"epss_score": 0.00087, "epss_percentile": 0.25572}, "CVE-2024-49409": {"epss_score": 0.00087, "epss_percentile": 0.25572}, "CVE-2024-49410": {"epss_score": 0.00037, "epss_percentile": 0.10784}, "CVE-2024-49411": {"epss_score": 0.00057, "epss_percentile": 0.18205}, "CVE-2024-49412": {"epss_score": 0.00035, "epss_percentile": 0.09879}, "CVE-2024-49413": {"epss_score": 0.0005, "epss_percentile": 0.15737}, "CVE-2024-49414": {"epss_score": 0.00052, "epss_percentile": 0.1635}, "CVE-2024-49415": {"epss_score": 0.00934, "epss_percentile": 0.75649}, "CVE-2024-49416": {"epss_score": 0.00033, "epss_percentile": 0.09123}, "CVE-2024-49417": {"epss_score": 0.00021, "epss_percentile": 0.04778}, "CVE-2024-49418": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2024-49419": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2024-49420": {"epss_score": 0.00265, "epss_percentile": 0.49824}, "CVE-2024-49421": {"epss_score": 0.00121, "epss_percentile": 0.32003}, "CVE-2024-49422": {"epss_score": 0.00047, "epss_percentile": 0.14647}, "CVE-2024-49501": {"epss_score": 0.00049, "epss_percentile": 0.15628}, "CVE-2024-49502": {"epss_score": 0.00037, "epss_percentile": 0.10888}, "CVE-2024-49503": {"epss_score": 0.00037, "epss_percentile": 0.10888}, "CVE-2024-49504": {"epss_score": 0.00067, "epss_percentile": 0.21064}, "CVE-2024-49505": {"epss_score": 0.00308, "epss_percentile": 0.53577}, "CVE-2024-49506": {"epss_score": 0.00085, "epss_percentile": 0.25041}, "CVE-2024-49507": {"epss_score": 0.00173, "epss_percentile": 0.39046}, "CVE-2024-49508": {"epss_score": 0.00173, "epss_percentile": 0.39046}, "CVE-2024-49509": {"epss_score": 0.00173, "epss_percentile": 0.39046}, "CVE-2024-49510": {"epss_score": 0.00023, "epss_percentile": 0.05474}, "CVE-2024-49511": {"epss_score": 0.00022, "epss_percentile": 0.05062}, "CVE-2024-49512": {"epss_score": 0.00023, "epss_percentile": 0.05474}, "CVE-2024-49513": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-49514": {"epss_score": 0.00148, "epss_percentile": 0.35879}, "CVE-2024-49515": {"epss_score": 0.00134, "epss_percentile": 0.339}, "CVE-2024-49516": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-49517": {"epss_score": 0.00173, "epss_percentile": 0.39046}, "CVE-2024-49518": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-49519": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-49520": {"epss_score": 0.0014, "epss_percentile": 0.34764}, "CVE-2024-49521": {"epss_score": 0.00316, "epss_percentile": 0.54244}, "CVE-2024-49522": {"epss_score": 0.00141, "epss_percentile": 0.34917}, "CVE-2024-49523": {"epss_score": 0.01644, "epss_percentile": 0.8152}, "CVE-2024-49524": {"epss_score": 0.06107, "epss_percentile": 0.90485}, "CVE-2024-49525": {"epss_score": 0.00173, "epss_percentile": 0.39046}, "CVE-2024-49526": {"epss_score": 0.00291, "epss_percentile": 0.52198}, "CVE-2024-49527": {"epss_score": 0.00047, "epss_percentile": 0.145}, "CVE-2024-49528": {"epss_score": 0.00261, "epss_percentile": 0.49262}, "CVE-2024-49529": {"epss_score": 0.00022, "epss_percentile": 0.05316}, "CVE-2024-49530": {"epss_score": 0.0005, "epss_percentile": 0.15977}, "CVE-2024-49531": {"epss_score": 0.00037, "epss_percentile": 0.10668}, "CVE-2024-49532": {"epss_score": 0.00078, "epss_percentile": 0.23648}, "CVE-2024-49533": {"epss_score": 0.00078, "epss_percentile": 0.23648}, "CVE-2024-49534": {"epss_score": 0.00068, "epss_percentile": 0.21285}, "CVE-2024-49535": {"epss_score": 0.00043, "epss_percentile": 0.13057}, "CVE-2024-49536": {"epss_score": 0.00047, "epss_percentile": 0.145}, "CVE-2024-49537": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-49538": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-49541": {"epss_score": 0.00108, "epss_percentile": 0.29848}, "CVE-2024-49543": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-49544": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-49545": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-49546": {"epss_score": 0.0009, "epss_percentile": 0.26043}, "CVE-2024-49547": {"epss_score": 0.0009, "epss_percentile": 0.26043}, "CVE-2024-49548": {"epss_score": 0.0009, "epss_percentile": 0.26043}, "CVE-2024-49549": {"epss_score": 0.0009, "epss_percentile": 0.26043}, "CVE-2024-49550": {"epss_score": 0.00226, "epss_percentile": 0.45256}, "CVE-2024-49551": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-49552": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-49553": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-49554": {"epss_score": 0.00037, "epss_percentile": 0.10668}, "CVE-2024-49557": {"epss_score": 0.00238, "epss_percentile": 0.46755}, "CVE-2024-49558": {"epss_score": 0.00058, "epss_percentile": 0.18508}, "CVE-2024-49559": {"epss_score": 0.00183, "epss_percentile": 0.40296}, "CVE-2024-49560": {"epss_score": 0.00223, "epss_percentile": 0.44866}, "CVE-2024-49561": {"epss_score": 0.00023, "epss_percentile": 0.05439}, "CVE-2024-49563": {"epss_score": 0.00046, "epss_percentile": 0.14365}, "CVE-2024-49564": {"epss_score": 0.00046, "epss_percentile": 0.14365}, "CVE-2024-49565": {"epss_score": 0.00046, "epss_percentile": 0.14365}, "CVE-2024-49568": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-49569": {"epss_score": 0.00051, "epss_percentile": 0.16129}, "CVE-2024-49570": {"epss_score": 0.00031, "epss_percentile": 0.0847}, "CVE-2024-49571": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-49572": {"epss_score": 0.0004, "epss_percentile": 0.11959}, "CVE-2024-49573": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-49574": {"epss_score": 0.00188, "epss_percentile": 0.40808}, "CVE-2024-49576": {"epss_score": 0.00332, "epss_percentile": 0.55551}, "CVE-2024-49579": {"epss_score": 0.00177, "epss_percentile": 0.39525}, "CVE-2024-49580": {"epss_score": 5e-05, "epss_percentile": 0.00208}, "CVE-2024-49581": {"epss_score": 0.00169, "epss_percentile": 0.38542}, "CVE-2024-49587": {"epss_score": 0.0006, "epss_percentile": 0.1909}, "CVE-2024-49588": {"epss_score": 0.00028, "epss_percentile": 0.07364}, "CVE-2024-49589": {"epss_score": 0.00141, "epss_percentile": 0.34925}, "CVE-2024-49592": {"epss_score": 0.00037, "epss_percentile": 0.10926}, "CVE-2024-49593": {"epss_score": 0.00683, "epss_percentile": 0.71089}, "CVE-2024-49595": {"epss_score": 7e-05, "epss_percentile": 0.00453}, "CVE-2024-49596": {"epss_score": 0.0008, "epss_percentile": 0.24031}, "CVE-2024-49597": {"epss_score": 9e-05, "epss_percentile": 0.00681}, "CVE-2024-49600": {"epss_score": 0.00027, "epss_percentile": 0.06904}, "CVE-2024-49601": {"epss_score": 0.01966, "epss_percentile": 0.83081}, "CVE-2024-49602": {"epss_score": 0.00188, "epss_percentile": 0.40826}, "CVE-2024-49603": {"epss_score": 0.00105, "epss_percentile": 0.29354}, "CVE-2024-49604": {"epss_score": 0.00205, "epss_percentile": 0.42762}, "CVE-2024-49605": {"epss_score": 0.0014, "epss_percentile": 0.34724}, "CVE-2024-49606": {"epss_score": 0.00104, "epss_percentile": 0.29183}, "CVE-2024-49607": {"epss_score": 0.18689, "epss_percentile": 0.95053}, "CVE-2024-49608": {"epss_score": 0.00113, "epss_percentile": 0.30662}, "CVE-2024-49609": {"epss_score": 0.00411, "epss_percentile": 0.60899}, "CVE-2024-49610": {"epss_score": 0.00426, "epss_percentile": 0.61739}, "CVE-2024-49611": {"epss_score": 0.00465, "epss_percentile": 0.6377}, "CVE-2024-49612": {"epss_score": 0.00486, "epss_percentile": 0.64753}, "CVE-2024-49613": {"epss_score": 0.00486, "epss_percentile": 0.64753}, "CVE-2024-49614": {"epss_score": 0.00303, "epss_percentile": 0.53205}, "CVE-2024-49615": {"epss_score": 0.00097, "epss_percentile": 0.27498}, "CVE-2024-49616": {"epss_score": 0.00358, "epss_percentile": 0.57507}, "CVE-2024-49617": {"epss_score": 0.00097, "epss_percentile": 0.27498}, "CVE-2024-49618": {"epss_score": 0.00327, "epss_percentile": 0.55149}, "CVE-2024-49619": {"epss_score": 0.00303, "epss_percentile": 0.53205}, "CVE-2024-49620": {"epss_score": 0.00358, "epss_percentile": 0.57507}, "CVE-2024-49621": {"epss_score": 0.00063, "epss_percentile": 0.19881}, "CVE-2024-49622": {"epss_score": 0.00063, "epss_percentile": 0.19881}, "CVE-2024-49623": {"epss_score": 0.00196, "epss_percentile": 0.41816}, "CVE-2024-49624": {"epss_score": 0.0045, "epss_percentile": 0.63076}, "CVE-2024-49625": {"epss_score": 0.00625, "epss_percentile": 0.69592}, "CVE-2024-49626": {"epss_score": 0.0045, "epss_percentile": 0.63076}, "CVE-2024-49627": {"epss_score": 0.00272, "epss_percentile": 0.50373}, "CVE-2024-49628": {"epss_score": 0.00286, "epss_percentile": 0.51717}, "CVE-2024-49629": {"epss_score": 0.00153, "epss_percentile": 0.36568}, "CVE-2024-49630": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-49631": {"epss_score": 0.00105, "epss_percentile": 0.29334}, "CVE-2024-49632": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49633": {"epss_score": 0.00071, "epss_percentile": 0.22027}, "CVE-2024-49634": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49635": {"epss_score": 0.00103, "epss_percentile": 0.28969}, "CVE-2024-49636": {"epss_score": 0.00103, "epss_percentile": 0.28969}, "CVE-2024-49637": {"epss_score": 0.00093, "epss_percentile": 0.26676}, "CVE-2024-49638": {"epss_score": 0.00088, "epss_percentile": 0.25793}, "CVE-2024-49639": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49640": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49641": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49642": {"epss_score": 0.00255, "epss_percentile": 0.48685}, "CVE-2024-49643": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49644": {"epss_score": 0.00126, "epss_percentile": 0.32685}, "CVE-2024-49645": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49646": {"epss_score": 0.00263, "epss_percentile": 0.49475}, "CVE-2024-49647": {"epss_score": 0.00238, "epss_percentile": 0.46753}, "CVE-2024-49648": {"epss_score": 0.00263, "epss_percentile": 0.49475}, "CVE-2024-49649": {"epss_score": 0.00897, "epss_percentile": 0.75134}, "CVE-2024-49650": {"epss_score": 0.00263, "epss_percentile": 0.49475}, "CVE-2024-49651": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49652": {"epss_score": 0.00466, "epss_percentile": 0.63786}, "CVE-2024-49653": {"epss_score": 0.52776, "epss_percentile": 0.9784}, "CVE-2024-49654": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49655": {"epss_score": 0.00245, "epss_percentile": 0.4768}, "CVE-2024-49656": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49657": {"epss_score": 0.00155, "epss_percentile": 0.3678}, "CVE-2024-49658": {"epss_score": 0.00394, "epss_percentile": 0.59776}, "CVE-2024-49659": {"epss_score": 0.00153, "epss_percentile": 0.36517}, "CVE-2024-49660": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49661": {"epss_score": 0.00228, "epss_percentile": 0.45469}, "CVE-2024-49662": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49663": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49664": {"epss_score": 0.00163, "epss_percentile": 0.37851}, "CVE-2024-49665": {"epss_score": 0.0016, "epss_percentile": 0.37496}, "CVE-2024-49666": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2024-49667": {"epss_score": 0.00177, "epss_percentile": 0.39576}, "CVE-2024-49668": {"epss_score": 0.52762, "epss_percentile": 0.97839}, "CVE-2024-49669": {"epss_score": 0.00361, "epss_percentile": 0.57691}, "CVE-2024-49670": {"epss_score": 0.00179, "epss_percentile": 0.39767}, "CVE-2024-49671": {"epss_score": 0.00361, "epss_percentile": 0.57691}, "CVE-2024-49672": {"epss_score": 0.00131, "epss_percentile": 0.33349}, "CVE-2024-49673": {"epss_score": 0.00172, "epss_percentile": 0.38934}, "CVE-2024-49674": {"epss_score": 0.00221, "epss_percentile": 0.44663}, "CVE-2024-49675": {"epss_score": 0.00183, "epss_percentile": 0.40294}, "CVE-2024-49676": {"epss_score": 0.00074, "epss_percentile": 0.22815}, "CVE-2024-49677": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-49678": {"epss_score": 0.00299, "epss_percentile": 0.52892}, "CVE-2024-49679": {"epss_score": 0.00105, "epss_percentile": 0.29319}, "CVE-2024-49680": {"epss_score": 0.0017, "epss_percentile": 0.3867}, "CVE-2024-49681": {"epss_score": 0.44799, "epss_percentile": 0.97453}, "CVE-2024-49682": {"epss_score": 0.00199, "epss_percentile": 0.42098}, "CVE-2024-49683": {"epss_score": 0.0027, "epss_percentile": 0.50214}, "CVE-2024-49684": {"epss_score": 0.00607, "epss_percentile": 0.69047}, "CVE-2024-49685": {"epss_score": 0.00144, "epss_percentile": 0.35335}, "CVE-2024-49686": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-49687": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-49688": {"epss_score": 0.00384, "epss_percentile": 0.59161}, "CVE-2024-49689": {"epss_score": 0.00136, "epss_percentile": 0.341}, "CVE-2024-49690": {"epss_score": 0.01959, "epss_percentile": 0.83051}, "CVE-2024-49691": {"epss_score": 0.00352, "epss_percentile": 0.57095}, "CVE-2024-49692": {"epss_score": 0.00153, "epss_percentile": 0.36517}, "CVE-2024-49693": {"epss_score": 0.00167, "epss_percentile": 0.38316}, "CVE-2024-49694": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2024-49695": {"epss_score": 0.00167, "epss_percentile": 0.38316}, "CVE-2024-49696": {"epss_score": 0.00114, "epss_percentile": 0.30776}, "CVE-2024-49697": {"epss_score": 0.0017, "epss_percentile": 0.3867}, "CVE-2024-49698": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-49699": {"epss_score": 0.06603, "epss_percentile": 0.9088}, "CVE-2024-49700": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2024-49701": {"epss_score": 0.0114, "epss_percentile": 0.7795}, "CVE-2024-49702": {"epss_score": 0.00153, "epss_percentile": 0.36517}, "CVE-2024-49703": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-49704": {"epss_score": 0.00022, "epss_percentile": 0.04998}, "CVE-2024-49705": {"epss_score": 0.00031, "epss_percentile": 0.08549}, "CVE-2024-49706": {"epss_score": 0.00041, "epss_percentile": 0.12461}, "CVE-2024-49707": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2024-49708": {"epss_score": 0.00042, "epss_percentile": 0.12797}, "CVE-2024-49709": {"epss_score": 0.00037, "epss_percentile": 0.10841}, "CVE-2024-49714": {"epss_score": 0.0001, "epss_percentile": 0.00764}, "CVE-2024-49720": {"epss_score": 8e-05, "epss_percentile": 0.00476}, "CVE-2024-49722": {"epss_score": 7e-05, "epss_percentile": 0.00433}, "CVE-2024-49724": {"epss_score": 6e-05, "epss_percentile": 0.00293}, "CVE-2024-49728": {"epss_score": 5e-05, "epss_percentile": 0.00231}, "CVE-2024-49730": {"epss_score": 6e-05, "epss_percentile": 0.00312}, "CVE-2024-49731": {"epss_score": 6e-05, "epss_percentile": 0.00253}, "CVE-2024-49732": {"epss_score": 8e-05, "epss_percentile": 0.00517}, "CVE-2024-49733": {"epss_score": 0.00018, "epss_percentile": 0.03825}, "CVE-2024-49734": {"epss_score": 0.00131, "epss_percentile": 0.33501}, "CVE-2024-49735": {"epss_score": 8e-05, "epss_percentile": 0.00517}, "CVE-2024-49736": {"epss_score": 4e-05, "epss_percentile": 0.00165}, "CVE-2024-49737": {"epss_score": 0.00014, "epss_percentile": 0.01863}, "CVE-2024-49738": {"epss_score": 0.0001, "epss_percentile": 0.0082}, "CVE-2024-49739": {"epss_score": 6e-05, "epss_percentile": 0.00247}, "CVE-2024-49740": {"epss_score": 0.00012, "epss_percentile": 0.01155}, "CVE-2024-49742": {"epss_score": 9e-05, "epss_percentile": 0.00701}, "CVE-2024-49744": {"epss_score": 0.0001, "epss_percentile": 0.00804}, "CVE-2024-49745": {"epss_score": 0.0001, "epss_percentile": 0.0082}, "CVE-2024-49747": {"epss_score": 0.00477, "epss_percentile": 0.64306}, "CVE-2024-49748": {"epss_score": 0.00246, "epss_percentile": 0.47791}, "CVE-2024-49749": {"epss_score": 0.00166, "epss_percentile": 0.38243}, "CVE-2024-49750": {"epss_score": 0.00099, "epss_percentile": 0.28369}, "CVE-2024-49751": {"epss_score": 0.0015, "epss_percentile": 0.36085}, "CVE-2024-49753": {"epss_score": 0.00148, "epss_percentile": 0.35856}, "CVE-2024-49754": {"epss_score": 0.08585, "epss_percentile": 0.92135}, "CVE-2024-49755": {"epss_score": 0.00102, "epss_percentile": 0.2887}, "CVE-2024-49756": {"epss_score": 0.0008, "epss_percentile": 0.24148}, "CVE-2024-49757": {"epss_score": 0.0872, "epss_percentile": 0.92226}, "CVE-2024-49758": {"epss_score": 0.00061, "epss_percentile": 0.19306}, "CVE-2024-49759": {"epss_score": 0.00387, "epss_percentile": 0.59298}, "CVE-2024-49760": {"epss_score": 0.00319, "epss_percentile": 0.54571}, "CVE-2024-49761": {"epss_score": 0.01217, "epss_percentile": 0.78599}, "CVE-2024-49762": {"epss_score": 0.00027, "epss_percentile": 0.06836}, "CVE-2024-49763": {"epss_score": 0.00158, "epss_percentile": 0.37151}, "CVE-2024-49764": {"epss_score": 0.00665, "epss_percentile": 0.70653}, "CVE-2024-49765": {"epss_score": 0.00191, "epss_percentile": 0.41146}, "CVE-2024-49766": {"epss_score": 0.00786, "epss_percentile": 0.73272}, "CVE-2024-49767": {"epss_score": 0.01183, "epss_percentile": 0.78325}, "CVE-2024-49768": {"epss_score": 0.00422, "epss_percentile": 0.61535}, "CVE-2024-49769": {"epss_score": 0.01182, "epss_percentile": 0.78319}, "CVE-2024-49770": {"epss_score": 0.00093, "epss_percentile": 0.26656}, "CVE-2024-49771": {"epss_score": 0.00225, "epss_percentile": 0.45145}, "CVE-2024-49772": {"epss_score": 0.00121, "epss_percentile": 0.31956}, "CVE-2024-49773": {"epss_score": 0.00107, "epss_percentile": 0.29589}, "CVE-2024-49774": {"epss_score": 0.00029, "epss_percentile": 0.0795}, "CVE-2024-49775": {"epss_score": 0.00962, "epss_percentile": 0.75999}, "CVE-2024-49776": {"epss_score": 0.00079, "epss_percentile": 0.23857}, "CVE-2024-49777": {"epss_score": 0.00163, "epss_percentile": 0.37765}, "CVE-2024-49778": {"epss_score": 0.00163, "epss_percentile": 0.37765}, "CVE-2024-49779": {"epss_score": 0.00067, "epss_percentile": 0.21104}, "CVE-2024-49780": {"epss_score": 0.0006, "epss_percentile": 0.19242}, "CVE-2024-49781": {"epss_score": 0.00299, "epss_percentile": 0.52842}, "CVE-2024-49782": {"epss_score": 0.00136, "epss_percentile": 0.34153}, "CVE-2024-49783": {"epss_score": 0.0003, "epss_percentile": 0.08012}, "CVE-2024-49784": {"epss_score": 0.00011, "epss_percentile": 0.01052}, "CVE-2024-49785": {"epss_score": 0.00156, "epss_percentile": 0.36886}, "CVE-2024-49790": {"epss_score": 0.00049, "epss_percentile": 0.15434}, "CVE-2024-49791": {"epss_score": 0.00106, "epss_percentile": 0.29478}, "CVE-2024-49792": {"epss_score": 0.00106, "epss_percentile": 0.29478}, "CVE-2024-49793": {"epss_score": 0.00106, "epss_percentile": 0.29478}, "CVE-2024-49794": {"epss_score": 0.00041, "epss_percentile": 0.12242}, "CVE-2024-49795": {"epss_score": 0.00041, "epss_percentile": 0.12242}, "CVE-2024-49796": {"epss_score": 0.00048, "epss_percentile": 0.14988}, "CVE-2024-49797": {"epss_score": 0.00036, "epss_percentile": 0.10406}, "CVE-2024-49798": {"epss_score": 0.00076, "epss_percentile": 0.23238}, "CVE-2024-49800": {"epss_score": 0.00079, "epss_percentile": 0.23966}, "CVE-2024-49803": {"epss_score": 0.00177, "epss_percentile": 0.3954}, "CVE-2024-49804": {"epss_score": 0.00012, "epss_percentile": 0.01292}, "CVE-2024-49805": {"epss_score": 0.00037, "epss_percentile": 0.10905}, "CVE-2024-49806": {"epss_score": 0.00037, "epss_percentile": 0.10905}, "CVE-2024-49807": {"epss_score": 0.00053, "epss_percentile": 0.16823}, "CVE-2024-49808": {"epss_score": 0.00042, "epss_percentile": 0.12712}, "CVE-2024-49814": {"epss_score": 0.00011, "epss_percentile": 0.00972}, "CVE-2024-49816": {"epss_score": 0.00111, "epss_percentile": 0.30405}, "CVE-2024-49817": {"epss_score": 0.00051, "epss_percentile": 0.16248}, "CVE-2024-49818": {"epss_score": 0.0011, "epss_percentile": 0.30168}, "CVE-2024-49819": {"epss_score": 0.00033, "epss_percentile": 0.09432}, "CVE-2024-49820": {"epss_score": 0.00059, "epss_percentile": 0.18914}, "CVE-2024-49822": {"epss_score": 0.0006, "epss_percentile": 0.19172}, "CVE-2024-49823": {"epss_score": 0.00104, "epss_percentile": 0.29149}, "CVE-2024-49824": {"epss_score": 0.00134, "epss_percentile": 0.33796}, "CVE-2024-49825": {"epss_score": 0.00049, "epss_percentile": 0.15489}, "CVE-2024-49827": {"epss_score": 0.00051, "epss_percentile": 0.16126}, "CVE-2024-49828": {"epss_score": 0.0007, "epss_percentile": 0.21837}, "CVE-2024-49829": {"epss_score": 0.00017, "epss_percentile": 0.0315}, "CVE-2024-49830": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-49832": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-49833": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-49834": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-49835": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-49836": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-49837": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-49838": {"epss_score": 0.00132, "epss_percentile": 0.3357}, "CVE-2024-49839": {"epss_score": 0.00193, "epss_percentile": 0.41422}, "CVE-2024-49840": {"epss_score": 0.00023, "epss_percentile": 0.05518}, "CVE-2024-49841": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2024-49842": {"epss_score": 0.00017, "epss_percentile": 0.03192}, "CVE-2024-49843": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-49844": {"epss_score": 0.00027, "epss_percentile": 0.07157}, "CVE-2024-49845": {"epss_score": 0.00027, "epss_percentile": 0.07157}, "CVE-2024-49846": {"epss_score": 0.00052, "epss_percentile": 0.16364}, "CVE-2024-49847": {"epss_score": 0.00054, "epss_percentile": 0.17195}, "CVE-2024-49848": {"epss_score": 0.00016, "epss_percentile": 0.02783}, "CVE-2024-49849": {"epss_score": 0.00113, "epss_percentile": 0.30597}, "CVE-2024-49850": {"epss_score": 0.00013, "epss_percentile": 0.0168}, "CVE-2024-49851": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-49852": {"epss_score": 0.00024, "epss_percentile": 0.05857}, "CVE-2024-49853": {"epss_score": 0.00033, "epss_percentile": 0.092}, "CVE-2024-49854": {"epss_score": 0.00024, "epss_percentile": 0.05857}, "CVE-2024-49855": {"epss_score": 0.00024, "epss_percentile": 0.05857}, "CVE-2024-49856": {"epss_score": 8e-05, "epss_percentile": 0.00566}, "CVE-2024-49857": {"epss_score": 0.00033, "epss_percentile": 0.09331}, "CVE-2024-49858": {"epss_score": 0.00014, "epss_percentile": 0.0204}, "CVE-2024-49859": {"epss_score": 0.00011, "epss_percentile": 0.01102}, "CVE-2024-49860": {"epss_score": 0.00014, "epss_percentile": 0.01755}, "CVE-2024-49861": {"epss_score": 0.00019, "epss_percentile": 0.04061}, "CVE-2024-49862": {"epss_score": 0.00021, "epss_percentile": 0.04808}, "CVE-2024-49863": {"epss_score": 9e-05, "epss_percentile": 0.00638}, "CVE-2024-49864": {"epss_score": 8e-05, "epss_percentile": 0.00493}, "CVE-2024-49865": {"epss_score": 0.00029, "epss_percentile": 0.07767}, "CVE-2024-49866": {"epss_score": 6e-05, "epss_percentile": 0.00279}, "CVE-2024-49867": {"epss_score": 7e-05, "epss_percentile": 0.00386}, "CVE-2024-49868": {"epss_score": 7e-05, "epss_percentile": 0.00437}, "CVE-2024-49869": {"epss_score": 0.00027, "epss_percentile": 0.06762}, "CVE-2024-49870": {"epss_score": 9e-05, "epss_percentile": 0.00607}, "CVE-2024-49871": {"epss_score": 8e-05, "epss_percentile": 0.005}, "CVE-2024-49872": {"epss_score": 0.00077, "epss_percentile": 0.23318}, "CVE-2024-49873": {"epss_score": 0.00099, "epss_percentile": 0.2835}, "CVE-2024-49874": {"epss_score": 0.00018, "epss_percentile": 0.0405}, "CVE-2024-49875": {"epss_score": 7e-05, "epss_percentile": 0.00403}, "CVE-2024-49876": {"epss_score": 0.00093, "epss_percentile": 0.26606}, "CVE-2024-49877": {"epss_score": 7e-05, "epss_percentile": 0.00465}, "CVE-2024-49878": {"epss_score": 0.00015, "epss_percentile": 0.02225}, "CVE-2024-49879": {"epss_score": 8e-05, "epss_percentile": 0.00522}, "CVE-2024-49880": {"epss_score": 0.00093, "epss_percentile": 0.26606}, "CVE-2024-49881": {"epss_score": 8e-05, "epss_percentile": 0.00479}, "CVE-2024-49882": {"epss_score": 0.00013, "epss_percentile": 0.01711}, "CVE-2024-49883": {"epss_score": 0.00012, "epss_percentile": 0.0123}, "CVE-2024-49884": {"epss_score": 0.00012, "epss_percentile": 0.01395}, "CVE-2024-49885": {"epss_score": 0.00013, "epss_percentile": 0.01617}, "CVE-2024-49886": {"epss_score": 7e-05, "epss_percentile": 0.00459}, "CVE-2024-49887": {"epss_score": 0.00055, "epss_percentile": 0.17482}, "CVE-2024-49888": {"epss_score": 9e-05, "epss_percentile": 0.0062}, "CVE-2024-49889": {"epss_score": 0.00011, "epss_percentile": 0.01033}, "CVE-2024-49890": {"epss_score": 7e-05, "epss_percentile": 0.00382}, "CVE-2024-49891": {"epss_score": 7e-05, "epss_percentile": 0.0036}, "CVE-2024-49892": {"epss_score": 7e-05, "epss_percentile": 0.00382}, "CVE-2024-49893": {"epss_score": 9e-05, "epss_percentile": 0.00693}, "CVE-2024-49894": {"epss_score": 0.00011, "epss_percentile": 0.01001}, "CVE-2024-49895": {"epss_score": 0.00012, "epss_percentile": 0.01154}, "CVE-2024-49896": {"epss_score": 7e-05, "epss_percentile": 0.00363}, "CVE-2024-49897": {"epss_score": 7e-05, "epss_percentile": 0.0036}, "CVE-2024-49898": {"epss_score": 7e-05, "epss_percentile": 0.0036}, "CVE-2024-49899": {"epss_score": 8e-05, "epss_percentile": 0.00557}, "CVE-2024-49900": {"epss_score": 7e-05, "epss_percentile": 0.00426}, "CVE-2024-49901": {"epss_score": 0.00011, "epss_percentile": 0.00929}, "CVE-2024-49902": {"epss_score": 7e-05, "epss_percentile": 0.00363}, "CVE-2024-49903": {"epss_score": 0.0001, "epss_percentile": 0.00799}, "CVE-2024-49904": {"epss_score": 0.00012, "epss_percentile": 0.01293}, "CVE-2024-49905": {"epss_score": 8e-05, "epss_percentile": 0.00524}, "CVE-2024-49906": {"epss_score": 0.0001, "epss_percentile": 0.00769}, "CVE-2024-49907": {"epss_score": 7e-05, "epss_percentile": 0.00437}, "CVE-2024-49908": {"epss_score": 9e-05, "epss_percentile": 0.00693}, "CVE-2024-49909": {"epss_score": 7e-05, "epss_percentile": 0.0036}, "CVE-2024-49910": {"epss_score": 9e-05, "epss_percentile": 0.00693}, "CVE-2024-49911": {"epss_score": 7e-05, "epss_percentile": 0.0036}, "CVE-2024-49912": {"epss_score": 9e-05, "epss_percentile": 0.00747}, "CVE-2024-49913": {"epss_score": 7e-05, "epss_percentile": 0.00437}, "CVE-2024-49914": {"epss_score": 0.0001, "epss_percentile": 0.00804}, "CVE-2024-49915": {"epss_score": 8e-05, "epss_percentile": 0.00524}, "CVE-2024-49916": {"epss_score": 9e-05, "epss_percentile": 0.00693}, "CVE-2024-49917": {"epss_score": 7e-05, "epss_percentile": 0.0036}, "CVE-2024-49918": {"epss_score": 0.00011, "epss_percentile": 0.00999}, "CVE-2024-49919": {"epss_score": 0.00011, "epss_percentile": 0.00999}, "CVE-2024-49920": {"epss_score": 9e-05, "epss_percentile": 0.00715}, "CVE-2024-49921": {"epss_score": 9e-05, "epss_percentile": 0.00715}, "CVE-2024-49922": {"epss_score": 0.00011, "epss_percentile": 0.00929}, "CVE-2024-49923": {"epss_score": 0.00011, "epss_percentile": 0.00929}, "CVE-2024-49924": {"epss_score": 0.0001, "epss_percentile": 0.0083}, "CVE-2024-49925": {"epss_score": 8e-05, "epss_percentile": 0.00515}, "CVE-2024-49926": {"epss_score": 0.00012, "epss_percentile": 0.01293}, "CVE-2024-49927": {"epss_score": 7e-05, "epss_percentile": 0.0041}, "CVE-2024-49928": {"epss_score": 0.00052, "epss_percentile": 0.16536}, "CVE-2024-49929": {"epss_score": 7e-05, "epss_percentile": 0.0036}, "CVE-2024-49930": {"epss_score": 0.00011, "epss_percentile": 0.01033}, "CVE-2024-49931": {"epss_score": 0.00017, "epss_percentile": 0.03249}, "CVE-2024-49932": {"epss_score": 9e-05, "epss_percentile": 0.00718}, "CVE-2024-49933": {"epss_score": 7e-05, "epss_percentile": 0.00382}, "CVE-2024-49934": {"epss_score": 0.00017, "epss_percentile": 0.03199}, "CVE-2024-49935": {"epss_score": 0.00017, "epss_percentile": 0.03356}, "CVE-2024-49936": {"epss_score": 0.00011, "epss_percentile": 0.01033}, "CVE-2024-49937": {"epss_score": 8e-05, "epss_percentile": 0.00585}, "CVE-2024-49938": {"epss_score": 8e-05, "epss_percentile": 0.00519}, "CVE-2024-49939": {"epss_score": 7e-05, "epss_percentile": 0.0036}, "CVE-2024-49940": {"epss_score": 8e-05, "epss_percentile": 0.00486}, "CVE-2024-49941": {"epss_score": 0.0002, "epss_percentile": 0.046}, "CVE-2024-49942": {"epss_score": 0.00065, "epss_percentile": 0.20505}, "CVE-2024-49943": {"epss_score": 0.00044, "epss_percentile": 0.13645}, "CVE-2024-49944": {"epss_score": 8e-05, "epss_percentile": 0.00504}, "CVE-2024-49945": {"epss_score": 0.0001, "epss_percentile": 0.00805}, "CVE-2024-49946": {"epss_score": 7e-05, "epss_percentile": 0.00459}, "CVE-2024-49947": {"epss_score": 0.00014, "epss_percentile": 0.02043}, "CVE-2024-49948": {"epss_score": 8e-05, "epss_percentile": 0.00504}, "CVE-2024-49949": {"epss_score": 8e-05, "epss_percentile": 0.0048}, "CVE-2024-49950": {"epss_score": 0.0001, "epss_percentile": 0.00876}, "CVE-2024-49951": {"epss_score": 9e-05, "epss_percentile": 0.00617}, "CVE-2024-49952": {"epss_score": 8e-05, "epss_percentile": 0.00504}, "CVE-2024-49953": {"epss_score": 0.00011, "epss_percentile": 0.00993}, "CVE-2024-49954": {"epss_score": 9e-05, "epss_percentile": 0.00666}, "CVE-2024-49955": {"epss_score": 0.00011, "epss_percentile": 0.01}, "CVE-2024-49956": {"epss_score": 0.00099, "epss_percentile": 0.2835}, "CVE-2024-49957": {"epss_score": 8e-05, "epss_percentile": 0.00504}, "CVE-2024-49958": {"epss_score": 7e-05, "epss_percentile": 0.00465}, "CVE-2024-49959": {"epss_score": 7e-05, "epss_percentile": 0.00465}, "CVE-2024-49960": {"epss_score": 0.00011, "epss_percentile": 0.00926}, "CVE-2024-49961": {"epss_score": 9e-05, "epss_percentile": 0.0064}, "CVE-2024-49962": {"epss_score": 7e-05, "epss_percentile": 0.00363}, "CVE-2024-49963": {"epss_score": 0.0001, "epss_percentile": 0.0081}, "CVE-2024-49964": {"epss_score": 0.00044, "epss_percentile": 0.13492}, "CVE-2024-49965": {"epss_score": 6e-05, "epss_percentile": 0.0028}, "CVE-2024-49966": {"epss_score": 0.00012, "epss_percentile": 0.0123}, "CVE-2024-49968": {"epss_score": 9e-05, "epss_percentile": 0.00693}, "CVE-2024-49969": {"epss_score": 0.00011, "epss_percentile": 0.01033}, "CVE-2024-49970": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2024-49971": {"epss_score": 9e-05, "epss_percentile": 0.00693}, "CVE-2024-49972": {"epss_score": 8e-05, "epss_percentile": 0.00486}, "CVE-2024-49973": {"epss_score": 8e-05, "epss_percentile": 0.00479}, "CVE-2024-49974": {"epss_score": 0.00012, "epss_percentile": 0.01331}, "CVE-2024-49975": {"epss_score": 9e-05, "epss_percentile": 0.00614}, "CVE-2024-49976": {"epss_score": 0.0001, "epss_percentile": 0.0088}, "CVE-2024-49977": {"epss_score": 0.0001, "epss_percentile": 0.00898}, "CVE-2024-49978": {"epss_score": 7e-05, "epss_percentile": 0.00459}, "CVE-2024-49979": {"epss_score": 0.00029, "epss_percentile": 0.07655}, "CVE-2024-49980": {"epss_score": 7e-05, "epss_percentile": 0.00455}, "CVE-2024-49981": {"epss_score": 9e-05, "epss_percentile": 0.00711}, "CVE-2024-49982": {"epss_score": 0.00012, "epss_percentile": 0.0123}, "CVE-2024-49983": {"epss_score": 0.00012, "epss_percentile": 0.01282}, "CVE-2024-49984": {"epss_score": 0.00045, "epss_percentile": 0.13829}, "CVE-2024-49985": {"epss_score": 6e-05, "epss_percentile": 0.00289}, "CVE-2024-49986": {"epss_score": 9e-05, "epss_percentile": 0.00746}, "CVE-2024-49987": {"epss_score": 9e-05, "epss_percentile": 0.0062}, "CVE-2024-49988": {"epss_score": 0.0001, "epss_percentile": 0.00874}, "CVE-2024-49989": {"epss_score": 9e-05, "epss_percentile": 0.0074}, "CVE-2024-49990": {"epss_score": 0.00025, "epss_percentile": 0.06288}, "CVE-2024-49991": {"epss_score": 9e-05, "epss_percentile": 0.00623}, "CVE-2024-49992": {"epss_score": 0.00015, "epss_percentile": 0.02434}, "CVE-2024-49994": {"epss_score": 0.00014, "epss_percentile": 0.0183}, "CVE-2024-49996": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2024-49997": {"epss_score": 0.00078, "epss_percentile": 0.23799}, "CVE-2024-49998": {"epss_score": 8e-05, "epss_percentile": 0.00473}, "CVE-2024-49999": {"epss_score": 0.00011, "epss_percentile": 0.0102}, "CVE-2024-4000": {"epss_score": 0.00309, "epss_percentile": 0.53701}, "CVE-2024-4001": {"epss_score": 0.00268, "epss_percentile": 0.5004}, "CVE-2024-4002": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-4003": {"epss_score": 0.00272, "epss_percentile": 0.50397}, "CVE-2024-4004": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-4005": {"epss_score": 0.00208, "epss_percentile": 0.43258}, "CVE-2024-4006": {"epss_score": 0.0005, "epss_percentile": 0.15956}, "CVE-2024-4007": {"epss_score": 0.09529, "epss_percentile": 0.92587}, "CVE-2024-4008": {"epss_score": 0.00238, "epss_percentile": 0.4684}, "CVE-2024-4009": {"epss_score": 0.0015, "epss_percentile": 0.36174}, "CVE-2024-4010": {"epss_score": 0.00698, "epss_percentile": 0.71418}, "CVE-2024-4011": {"epss_score": 0.0006, "epss_percentile": 0.19214}, "CVE-2024-4013": {"epss_score": 0.00175, "epss_percentile": 0.3935}, "CVE-2024-4014": {"epss_score": 0.00168, "epss_percentile": 0.38517}, "CVE-2024-4017": {"epss_score": 0.00075, "epss_percentile": 0.23002}, "CVE-2024-4018": {"epss_score": 0.00076, "epss_percentile": 0.23275}, "CVE-2024-4019": {"epss_score": 0.00012, "epss_percentile": 0.0134}, "CVE-2024-4020": {"epss_score": 0.00217, "epss_percentile": 0.44254}, "CVE-2024-4021": {"epss_score": 0.00128, "epss_percentile": 0.32985}, "CVE-2024-4022": {"epss_score": 0.00128, "epss_percentile": 0.32985}, "CVE-2024-4023": {"epss_score": 0.00184, "epss_percentile": 0.40434}, "CVE-2024-4024": {"epss_score": 0.03769, "epss_percentile": 0.87699}, "CVE-2024-4025": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-4026": {"epss_score": 0.00169, "epss_percentile": 0.38625}, "CVE-2024-4028": {"epss_score": 0.00188, "epss_percentile": 0.40852}, "CVE-2024-4029": {"epss_score": 0.00014, "epss_percentile": 0.01795}, "CVE-2024-4030": {"epss_score": 0.00025, "epss_percentile": 0.06162}, "CVE-2024-4031": {"epss_score": 0.00024, "epss_percentile": 0.05977}, "CVE-2024-4032": {"epss_score": 0.01127, "epss_percentile": 0.77821}, "CVE-2024-4033": {"epss_score": 0.09208, "epss_percentile": 0.92448}, "CVE-2024-4034": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2024-4035": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-4036": {"epss_score": 0.00317, "epss_percentile": 0.54326}, "CVE-2024-4037": {"epss_score": 0.00947, "epss_percentile": 0.75824}, "CVE-2024-4038": {"epss_score": 0.01081, "epss_percentile": 0.77375}, "CVE-2024-4039": {"epss_score": 0.01297, "epss_percentile": 0.7927}, "CVE-2024-4040": {"epss_score": 0.94426, "epss_percentile": 0.99981}, "CVE-2024-4041": {"epss_score": 0.04104, "epss_percentile": 0.88262}, "CVE-2024-4042": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-4043": {"epss_score": 0.00361, "epss_percentile": 0.57745}, "CVE-2024-4044": {"epss_score": 0.2007, "epss_percentile": 0.95284}, "CVE-2024-4045": {"epss_score": 0.00176, "epss_percentile": 0.39476}, "CVE-2024-4046": {"epss_score": 0.00044, "epss_percentile": 0.13642}, "CVE-2024-4056": {"epss_score": 0.00356, "epss_percentile": 0.57336}, "CVE-2024-4057": {"epss_score": 0.00244, "epss_percentile": 0.47601}, "CVE-2024-4058": {"epss_score": 0.07275, "epss_percentile": 0.91379}, "CVE-2024-4059": {"epss_score": 0.00123, "epss_percentile": 0.3226}, "CVE-2024-4060": {"epss_score": 0.00147, "epss_percentile": 0.35676}, "CVE-2024-4061": {"epss_score": 0.00352, "epss_percentile": 0.57133}, "CVE-2024-4062": {"epss_score": 0.00074, "epss_percentile": 0.22862}, "CVE-2024-4063": {"epss_score": 0.00074, "epss_percentile": 0.22862}, "CVE-2024-4064": {"epss_score": 0.00825, "epss_percentile": 0.73946}, "CVE-2024-4065": {"epss_score": 0.00578, "epss_percentile": 0.6818}, "CVE-2024-4066": {"epss_score": 0.00872, "epss_percentile": 0.7473}, "CVE-2024-4067": {"epss_score": 0.00126, "epss_percentile": 0.3273}, "CVE-2024-4068": {"epss_score": 0.00225, "epss_percentile": 0.451}, "CVE-2024-4069": {"epss_score": 0.00055, "epss_percentile": 0.17371}, "CVE-2024-4070": {"epss_score": 0.00055, "epss_percentile": 0.17371}, "CVE-2024-4071": {"epss_score": 0.00055, "epss_percentile": 0.17582}, "CVE-2024-4072": {"epss_score": 0.00082, "epss_percentile": 0.24512}, "CVE-2024-4073": {"epss_score": 0.00082, "epss_percentile": 0.24512}, "CVE-2024-4074": {"epss_score": 0.00107, "epss_percentile": 0.29744}, "CVE-2024-4075": {"epss_score": 0.00107, "epss_percentile": 0.29744}, "CVE-2024-4076": {"epss_score": 0.00066, "epss_percentile": 0.20675}, "CVE-2024-4077": {"epss_score": 0.00186, "epss_percentile": 0.40583}, "CVE-2024-4078": {"epss_score": 0.09758, "epss_percentile": 0.92692}, "CVE-2024-4079": {"epss_score": 0.00261, "epss_percentile": 0.49308}, "CVE-2024-4080": {"epss_score": 0.00175, "epss_percentile": 0.39279}, "CVE-2024-4081": {"epss_score": 0.00175, "epss_percentile": 0.39279}, "CVE-2024-4082": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2024-4083": {"epss_score": 0.00104, "epss_percentile": 0.29192}, "CVE-2024-4084": {"epss_score": 0.00078, "epss_percentile": 0.23687}, "CVE-2024-4085": {"epss_score": 0.00154, "epss_percentile": 0.36726}, "CVE-2024-4086": {"epss_score": 0.00111, "epss_percentile": 0.30258}, "CVE-2024-4087": {"epss_score": 0.00361, "epss_percentile": 0.57745}, "CVE-2024-4088": {"epss_score": 0.00122, "epss_percentile": 0.32104}, "CVE-2024-4089": {"epss_score": 0.00059, "epss_percentile": 0.18861}, "CVE-2024-4090": {"epss_score": 0.00284, "epss_percentile": 0.51433}, "CVE-2024-4091": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-4092": {"epss_score": 0.00211, "epss_percentile": 0.43618}, "CVE-2024-4093": {"epss_score": 0.00062, "epss_percentile": 0.19681}, "CVE-2024-4094": {"epss_score": 0.0038, "epss_percentile": 0.5895}, "CVE-2024-4095": {"epss_score": 0.00234, "epss_percentile": 0.46156}, "CVE-2024-4096": {"epss_score": 0.00171, "epss_percentile": 0.38824}, "CVE-2024-4097": {"epss_score": 0.0214, "epss_percentile": 0.83747}, "CVE-2024-4098": {"epss_score": 0.00696, "epss_percentile": 0.71394}, "CVE-2024-4099": {"epss_score": 0.00058, "epss_percentile": 0.18272}, "CVE-2024-4100": {"epss_score": 0.00194, "epss_percentile": 0.41521}, "CVE-2024-4102": {"epss_score": 0.00263, "epss_percentile": 0.49485}, "CVE-2024-4103": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2024-4104": {"epss_score": 0.01488, "epss_percentile": 0.80615}, "CVE-2024-4105": {"epss_score": 0.00172, "epss_percentile": 0.38973}, "CVE-2024-4106": {"epss_score": 0.00091, "epss_percentile": 0.26199}, "CVE-2024-4107": {"epss_score": 0.00184, "epss_percentile": 0.4045}, "CVE-2024-4111": {"epss_score": 0.00317, "epss_percentile": 0.54343}, "CVE-2024-4112": {"epss_score": 0.00317, "epss_percentile": 0.54343}, "CVE-2024-4113": {"epss_score": 0.00317, "epss_percentile": 0.54343}, "CVE-2024-4114": {"epss_score": 0.00147, "epss_percentile": 0.35712}, "CVE-2024-4115": {"epss_score": 0.00148, "epss_percentile": 0.35901}, "CVE-2024-4116": {"epss_score": 0.00243, "epss_percentile": 0.47508}, "CVE-2024-4117": {"epss_score": 0.0026, "epss_percentile": 0.49219}, "CVE-2024-4118": {"epss_score": 0.00136, "epss_percentile": 0.34164}, "CVE-2024-4119": {"epss_score": 0.00243, "epss_percentile": 0.47508}, "CVE-2024-4120": {"epss_score": 0.00224, "epss_percentile": 0.45007}, "CVE-2024-4121": {"epss_score": 0.00224, "epss_percentile": 0.45007}, "CVE-2024-4122": {"epss_score": 0.00224, "epss_percentile": 0.45007}, "CVE-2024-4123": {"epss_score": 0.00136, "epss_percentile": 0.34164}, "CVE-2024-4124": {"epss_score": 0.0016, "epss_percentile": 0.37478}, "CVE-2024-4125": {"epss_score": 0.0077, "epss_percentile": 0.73005}, "CVE-2024-4126": {"epss_score": 0.0077, "epss_percentile": 0.73005}, "CVE-2024-4127": {"epss_score": 0.0052, "epss_percentile": 0.66193}, "CVE-2024-4128": {"epss_score": 0.00067, "epss_percentile": 0.21183}, "CVE-2024-4129": {"epss_score": 0.00109, "epss_percentile": 0.3006}, "CVE-2024-4130": {"epss_score": 0.00065, "epss_percentile": 0.20537}, "CVE-2024-4131": {"epss_score": 0.00065, "epss_percentile": 0.20537}, "CVE-2024-4132": {"epss_score": 0.0005, "epss_percentile": 0.15714}, "CVE-2024-4133": {"epss_score": 0.00252, "epss_percentile": 0.48406}, "CVE-2024-4135": {"epss_score": 0.0098, "epss_percentile": 0.76266}, "CVE-2024-4138": {"epss_score": 0.00156, "epss_percentile": 0.36941}, "CVE-2024-4139": {"epss_score": 0.00156, "epss_percentile": 0.36941}, "CVE-2024-4140": {"epss_score": 0.00374, "epss_percentile": 0.58546}, "CVE-2024-4141": {"epss_score": 0.0003, "epss_percentile": 0.08194}, "CVE-2024-4142": {"epss_score": 0.00795, "epss_percentile": 0.73464}, "CVE-2024-4143": {"epss_score": 0.00212, "epss_percentile": 0.43791}, "CVE-2024-4144": {"epss_score": 0.01719, "epss_percentile": 0.81928}, "CVE-2024-4145": {"epss_score": 0.00493, "epss_percentile": 0.65051}, "CVE-2024-4146": {"epss_score": 0.00149, "epss_percentile": 0.3604}, "CVE-2024-4148": {"epss_score": 0.00096, "epss_percentile": 0.27287}, "CVE-2024-4149": {"epss_score": 0.00186, "epss_percentile": 0.40633}, "CVE-2024-4150": {"epss_score": 0.01641, "epss_percentile": 0.81503}, "CVE-2024-4151": {"epss_score": 0.00129, "epss_percentile": 0.33159}, "CVE-2024-4154": {"epss_score": 0.00138, "epss_percentile": 0.34431}, "CVE-2024-4156": {"epss_score": 0.00304, "epss_percentile": 0.53287}, "CVE-2024-4157": {"epss_score": 0.00446, "epss_percentile": 0.62921}, "CVE-2024-4158": {"epss_score": 0.00162, "epss_percentile": 0.3762}, "CVE-2024-4159": {"epss_score": 0.00357, "epss_percentile": 0.57451}, "CVE-2024-4160": {"epss_score": 0.00285, "epss_percentile": 0.51544}, "CVE-2024-4161": {"epss_score": 0.00204, "epss_percentile": 0.42617}, "CVE-2024-4162": {"epss_score": 0.00065, "epss_percentile": 0.20479}, "CVE-2024-4163": {"epss_score": 0.00082, "epss_percentile": 0.24409}, "CVE-2024-4164": {"epss_score": 0.00409, "epss_percentile": 0.60761}, "CVE-2024-4165": {"epss_score": 0.00499, "epss_percentile": 0.65249}, "CVE-2024-4166": {"epss_score": 0.01021, "epss_percentile": 0.76753}, "CVE-2024-4167": {"epss_score": 0.00571, "epss_percentile": 0.67976}, "CVE-2024-4168": {"epss_score": 0.00571, "epss_percentile": 0.67976}, "CVE-2024-4169": {"epss_score": 0.00804, "epss_percentile": 0.73617}, "CVE-2024-4170": {"epss_score": 0.00832, "epss_percentile": 0.74076}, "CVE-2024-4171": {"epss_score": 0.00499, "epss_percentile": 0.65249}, "CVE-2024-4172": {"epss_score": 0.00134, "epss_percentile": 0.33838}, "CVE-2024-4173": {"epss_score": 0.00203, "epss_percentile": 0.42557}, "CVE-2024-4174": {"epss_score": 0.0021, "epss_percentile": 0.43611}, "CVE-2024-4175": {"epss_score": 0.00207, "epss_percentile": 0.43207}, "CVE-2024-4176": {"epss_score": 0.00137, "epss_percentile": 0.34238}, "CVE-2024-4177": {"epss_score": 0.00198, "epss_percentile": 0.42094}, "CVE-2024-4180": {"epss_score": 0.32944, "epss_percentile": 0.96737}, "CVE-2024-4181": {"epss_score": 0.01633, "epss_percentile": 0.81459}, "CVE-2024-4182": {"epss_score": 0.00193, "epss_percentile": 0.41492}, "CVE-2024-4183": {"epss_score": 0.00174, "epss_percentile": 0.39199}, "CVE-2024-4184": {"epss_score": 0.00099, "epss_percentile": 0.28386}, "CVE-2024-4185": {"epss_score": 0.00243, "epss_percentile": 0.4741}, "CVE-2024-4186": {"epss_score": 0.00524, "epss_percentile": 0.66322}, "CVE-2024-4187": {"epss_score": 0.00832, "epss_percentile": 0.74073}, "CVE-2024-4188": {"epss_score": 0.00082, "epss_percentile": 0.24471}, "CVE-2024-4189": {"epss_score": 0.00099, "epss_percentile": 0.28386}, "CVE-2024-4190": {"epss_score": 0.00189, "epss_percentile": 0.40944}, "CVE-2024-4192": {"epss_score": 0.00097, "epss_percentile": 0.27573}, "CVE-2024-4193": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-4194": {"epss_score": 0.00947, "epss_percentile": 0.75824}, "CVE-2024-4195": {"epss_score": 0.00139, "epss_percentile": 0.34568}, "CVE-2024-4196": {"epss_score": 0.00823, "epss_percentile": 0.73921}, "CVE-2024-4197": {"epss_score": 0.00553, "epss_percentile": 0.67412}, "CVE-2024-4198": {"epss_score": 0.00138, "epss_percentile": 0.34466}, "CVE-2024-4199": {"epss_score": 0.00111, "epss_percentile": 0.30318}, "CVE-2024-4200": {"epss_score": 0.00039, "epss_percentile": 0.11574}, "CVE-2024-4201": {"epss_score": 0.01469, "epss_percentile": 0.80489}, "CVE-2024-4202": {"epss_score": 0.00071, "epss_percentile": 0.2205}, "CVE-2024-4203": {"epss_score": 0.00255, "epss_percentile": 0.487}, "CVE-2024-4204": {"epss_score": 0.00188, "epss_percentile": 0.4085}, "CVE-2024-4205": {"epss_score": 0.00376, "epss_percentile": 0.58659}, "CVE-2024-4207": {"epss_score": 0.00715, "epss_percentile": 0.71835}, "CVE-2024-4208": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-4209": {"epss_score": 0.00284, "epss_percentile": 0.51488}, "CVE-2024-4210": {"epss_score": 0.00178, "epss_percentile": 0.39682}, "CVE-2024-4211": {"epss_score": 0.00118, "epss_percentile": 0.31403}, "CVE-2024-4212": {"epss_score": 0.00761, "epss_percentile": 0.72828}, "CVE-2024-4213": {"epss_score": 0.00532, "epss_percentile": 0.66674}, "CVE-2024-4214": {"epss_score": 0.00189, "epss_percentile": 0.41004}, "CVE-2024-4215": {"epss_score": 0.00029, "epss_percentile": 0.07936}, "CVE-2024-4216": {"epss_score": 0.0021, "epss_percentile": 0.43613}, "CVE-2024-4217": {"epss_score": 0.00134, "epss_percentile": 0.33928}, "CVE-2024-4218": {"epss_score": 0.00352, "epss_percentile": 0.57129}, "CVE-2024-4219": {"epss_score": 0.00123, "epss_percentile": 0.32224}, "CVE-2024-4220": {"epss_score": 0.00147, "epss_percentile": 0.35788}, "CVE-2024-4222": {"epss_score": 0.00579, "epss_percentile": 0.68231}, "CVE-2024-4223": {"epss_score": 0.02228, "epss_percentile": 0.84074}, "CVE-2024-4224": {"epss_score": 0.00196, "epss_percentile": 0.4174}, "CVE-2024-4225": {"epss_score": 0.00073, "epss_percentile": 0.22653}, "CVE-2024-4226": {"epss_score": 0.00094, "epss_percentile": 0.26995}, "CVE-2024-4227": {"epss_score": 0.00092, "epss_percentile": 0.26567}, "CVE-2024-4228": {"epss_score": 0.00267, "epss_percentile": 0.49976}, "CVE-2024-4229": {"epss_score": 0.00086, "epss_percentile": 0.25246}, "CVE-2024-4230": {"epss_score": 0.00108, "epss_percentile": 0.29878}, "CVE-2024-4231": {"epss_score": 0.03711, "epss_percentile": 0.87608}, "CVE-2024-4232": {"epss_score": 0.01689, "epss_percentile": 0.81772}, "CVE-2024-4233": {"epss_score": 0.00148, "epss_percentile": 0.35919}, "CVE-2024-4234": {"epss_score": 0.00115, "epss_percentile": 0.30996}, "CVE-2024-4235": {"epss_score": 0.00099, "epss_percentile": 0.28411}, "CVE-2024-4236": {"epss_score": 0.00339, "epss_percentile": 0.56167}, "CVE-2024-4237": {"epss_score": 0.00577, "epss_percentile": 0.6817}, "CVE-2024-4238": {"epss_score": 0.00611, "epss_percentile": 0.69177}, "CVE-2024-4239": {"epss_score": 0.00254, "epss_percentile": 0.48562}, "CVE-2024-4240": {"epss_score": 0.00254, "epss_percentile": 0.48562}, "CVE-2024-4241": {"epss_score": 0.00358, "epss_percentile": 0.57488}, "CVE-2024-4242": {"epss_score": 0.00586, "epss_percentile": 0.68446}, "CVE-2024-4243": {"epss_score": 0.00586, "epss_percentile": 0.68446}, "CVE-2024-4244": {"epss_score": 0.00358, "epss_percentile": 0.57488}, "CVE-2024-4245": {"epss_score": 0.00135, "epss_percentile": 0.34021}, "CVE-2024-4246": {"epss_score": 0.00222, "epss_percentile": 0.44769}, "CVE-2024-4247": {"epss_score": 0.00317, "epss_percentile": 0.54343}, "CVE-2024-4248": {"epss_score": 0.00147, "epss_percentile": 0.35712}, "CVE-2024-4249": {"epss_score": 0.00135, "epss_percentile": 0.34021}, "CVE-2024-4250": {"epss_score": 0.00147, "epss_percentile": 0.35712}, "CVE-2024-4251": {"epss_score": 0.00241, "epss_percentile": 0.4733}, "CVE-2024-4252": {"epss_score": 0.00317, "epss_percentile": 0.54343}, "CVE-2024-4253": {"epss_score": 0.019, "epss_percentile": 0.82772}, "CVE-2024-4254": {"epss_score": 0.00565, "epss_percentile": 0.6779}, "CVE-2024-4255": {"epss_score": 0.00186, "epss_percentile": 0.40662}, "CVE-2024-4256": {"epss_score": 0.0007, "epss_percentile": 0.21709}, "CVE-2024-4257": {"epss_score": 0.92538, "epss_percentile": 0.99724}, "CVE-2024-4258": {"epss_score": 0.01291, "epss_percentile": 0.79228}, "CVE-2024-4259": {"epss_score": 0.00116, "epss_percentile": 0.31191}, "CVE-2024-4260": {"epss_score": 0.00723, "epss_percentile": 0.72018}, "CVE-2024-4261": {"epss_score": 0.00594, "epss_percentile": 0.68655}, "CVE-2024-4262": {"epss_score": 0.00755, "epss_percentile": 0.72716}, "CVE-2024-4263": {"epss_score": 0.00062, "epss_percentile": 0.19598}, "CVE-2024-4264": {"epss_score": 0.06167, "epss_percentile": 0.90528}, "CVE-2024-4265": {"epss_score": 0.002, "epss_percentile": 0.42231}, "CVE-2024-4266": {"epss_score": 0.01362, "epss_percentile": 0.79759}, "CVE-2024-4267": {"epss_score": 0.0172, "epss_percentile": 0.81932}, "CVE-2024-4268": {"epss_score": 0.00267, "epss_percentile": 0.50018}, "CVE-2024-4269": {"epss_score": 0.00173, "epss_percentile": 0.39053}, "CVE-2024-4270": {"epss_score": 0.00355, "epss_percentile": 0.5727}, "CVE-2024-4271": {"epss_score": 0.00219, "epss_percentile": 0.44518}, "CVE-2024-4272": {"epss_score": 0.00256, "epss_percentile": 0.48787}, "CVE-2024-4273": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-4274": {"epss_score": 0.00192, "epss_percentile": 0.41322}, "CVE-2024-4275": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-4277": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-4278": {"epss_score": 0.0003, "epss_percentile": 0.08287}, "CVE-2024-4279": {"epss_score": 0.00218, "epss_percentile": 0.4437}, "CVE-2024-4280": {"epss_score": 0.00197, "epss_percentile": 0.41857}, "CVE-2024-4281": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-4282": {"epss_score": 0.00105, "epss_percentile": 0.29338}, "CVE-2024-4283": {"epss_score": 0.00026, "epss_percentile": 0.06596}, "CVE-2024-4284": {"epss_score": 0.00136, "epss_percentile": 0.34121}, "CVE-2024-4286": {"epss_score": 0.00103, "epss_percentile": 0.29088}, "CVE-2024-4287": {"epss_score": 0.00214, "epss_percentile": 0.43998}, "CVE-2024-4288": {"epss_score": 0.00273, "epss_percentile": 0.50461}, "CVE-2024-4289": {"epss_score": 0.00292, "epss_percentile": 0.52285}, "CVE-2024-4290": {"epss_score": 0.00155, "epss_percentile": 0.36842}, "CVE-2024-4291": {"epss_score": 0.00317, "epss_percentile": 0.54343}, "CVE-2024-4292": {"epss_score": 0.00036, "epss_percentile": 0.10216}, "CVE-2024-4293": {"epss_score": 0.00116, "epss_percentile": 0.31044}, "CVE-2024-4294": {"epss_score": 0.00059, "epss_percentile": 0.18636}, "CVE-2024-4295": {"epss_score": 0.93132, "epss_percentile": 0.99778}, "CVE-2024-4296": {"epss_score": 0.00057, "epss_percentile": 0.18233}, "CVE-2024-4297": {"epss_score": 0.00131, "epss_percentile": 0.3337}, "CVE-2024-4298": {"epss_score": 0.02199, "epss_percentile": 0.83973}, "CVE-2024-4299": {"epss_score": 0.01681, "epss_percentile": 0.81729}, "CVE-2024-4300": {"epss_score": 0.00351, "epss_percentile": 0.57008}, "CVE-2024-4301": {"epss_score": 0.00832, "epss_percentile": 0.74069}, "CVE-2024-4302": {"epss_score": 0.00169, "epss_percentile": 0.38547}, "CVE-2024-4303": {"epss_score": 0.00249, "epss_percentile": 0.48073}, "CVE-2024-4304": {"epss_score": 0.00221, "epss_percentile": 0.44696}, "CVE-2024-4305": {"epss_score": 0.00207, "epss_percentile": 0.43205}, "CVE-2024-4306": {"epss_score": 0.0017, "epss_percentile": 0.38725}, "CVE-2024-4307": {"epss_score": 0.00123, "epss_percentile": 0.32289}, "CVE-2024-4308": {"epss_score": 0.00123, "epss_percentile": 0.32289}, "CVE-2024-4309": {"epss_score": 0.00123, "epss_percentile": 0.32289}, "CVE-2024-4310": {"epss_score": 0.00082, "epss_percentile": 0.24483}, "CVE-2024-4311": {"epss_score": 0.00053, "epss_percentile": 0.16944}, "CVE-2024-4312": {"epss_score": 0.00105, "epss_percentile": 0.29287}, "CVE-2024-4313": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-4314": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2024-4315": {"epss_score": 0.01172, "epss_percentile": 0.78233}, "CVE-2024-4316": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-4317": {"epss_score": 0.00211, "epss_percentile": 0.43619}, "CVE-2024-4318": {"epss_score": 0.00645, "epss_percentile": 0.70103}, "CVE-2024-4319": {"epss_score": 0.01339, "epss_percentile": 0.7957}, "CVE-2024-4320": {"epss_score": 0.62289, "epss_percentile": 0.98287}, "CVE-2024-4321": {"epss_score": 0.00284, "epss_percentile": 0.51485}, "CVE-2024-4322": {"epss_score": 0.12775, "epss_percentile": 0.9377}, "CVE-2024-4323": {"epss_score": 0.84314, "epss_percentile": 0.99284}, "CVE-2024-4324": {"epss_score": 0.00309, "epss_percentile": 0.53701}, "CVE-2024-4325": {"epss_score": 0.4767, "epss_percentile": 0.97596}, "CVE-2024-4326": {"epss_score": 0.01133, "epss_percentile": 0.7788}, "CVE-2024-4327": {"epss_score": 0.00202, "epss_percentile": 0.42397}, "CVE-2024-4328": {"epss_score": 0.00052, "epss_percentile": 0.16631}, "CVE-2024-4329": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-4330": {"epss_score": 0.00167, "epss_percentile": 0.38388}, "CVE-2024-4331": {"epss_score": 0.00826, "epss_percentile": 0.73963}, "CVE-2024-4332": {"epss_score": 0.00282, "epss_percentile": 0.51203}, "CVE-2024-4333": {"epss_score": 0.00157, "epss_percentile": 0.37083}, "CVE-2024-4334": {"epss_score": 0.00162, "epss_percentile": 0.37719}, "CVE-2024-4335": {"epss_score": 0.00172, "epss_percentile": 0.38945}, "CVE-2024-4336": {"epss_score": 0.00168, "epss_percentile": 0.38465}, "CVE-2024-4337": {"epss_score": 0.00168, "epss_percentile": 0.38465}, "CVE-2024-4339": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-4340": {"epss_score": 0.17039, "epss_percentile": 0.94763}, "CVE-2024-4341": {"epss_score": 0.00054, "epss_percentile": 0.17339}, "CVE-2024-4342": {"epss_score": 0.00455, "epss_percentile": 0.63283}, "CVE-2024-4343": {"epss_score": 0.00837, "epss_percentile": 0.74158}, "CVE-2024-4344": {"epss_score": 0.00167, "epss_percentile": 0.38376}, "CVE-2024-4345": {"epss_score": 0.14962, "epss_percentile": 0.94334}, "CVE-2024-4346": {"epss_score": 0.28605, "epss_percentile": 0.96371}, "CVE-2024-4347": {"epss_score": 0.05499, "epss_percentile": 0.89936}, "CVE-2024-4348": {"epss_score": 0.13138, "epss_percentile": 0.93883}, "CVE-2024-4349": {"epss_score": 0.00279, "epss_percentile": 0.5098}, "CVE-2024-4350": {"epss_score": 0.01032, "epss_percentile": 0.76858}, "CVE-2024-4351": {"epss_score": 0.2525, "epss_percentile": 0.96003}, "CVE-2024-4352": {"epss_score": 0.23339, "epss_percentile": 0.95768}, "CVE-2024-4353": {"epss_score": 0.00333, "epss_percentile": 0.55661}, "CVE-2024-4354": {"epss_score": 0.00835, "epss_percentile": 0.74124}, "CVE-2024-4355": {"epss_score": 0.00325, "epss_percentile": 0.55004}, "CVE-2024-4356": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-4357": {"epss_score": 0.01919, "epss_percentile": 0.82887}, "CVE-2024-4358": {"epss_score": 0.94344, "epss_percentile": 0.99952}, "CVE-2024-4359": {"epss_score": 0.01027, "epss_percentile": 0.76809}, "CVE-2024-4360": {"epss_score": 0.00235, "epss_percentile": 0.46203}, "CVE-2024-4361": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-4362": {"epss_score": 0.00503, "epss_percentile": 0.65457}, "CVE-2024-4363": {"epss_score": 0.00575, "epss_percentile": 0.68102}, "CVE-2024-4364": {"epss_score": 0.00225, "epss_percentile": 0.45095}, "CVE-2024-4365": {"epss_score": 0.00176, "epss_percentile": 0.39476}, "CVE-2024-4366": {"epss_score": 0.00152, "epss_percentile": 0.36403}, "CVE-2024-4367": {"epss_score": 0.31542, "epss_percentile": 0.96626}, "CVE-2024-4368": {"epss_score": 0.00332, "epss_percentile": 0.55562}, "CVE-2024-4369": {"epss_score": 0.00046, "epss_percentile": 0.14166}, "CVE-2024-4370": {"epss_score": 0.00705, "epss_percentile": 0.71587}, "CVE-2024-4371": {"epss_score": 0.0519, "epss_percentile": 0.89595}, "CVE-2024-4372": {"epss_score": 0.0038, "epss_percentile": 0.5895}, "CVE-2024-4373": {"epss_score": 0.00521, "epss_percentile": 0.66248}, "CVE-2024-4374": {"epss_score": 0.00356, "epss_percentile": 0.57386}, "CVE-2024-4375": {"epss_score": 0.0022, "epss_percentile": 0.44538}, "CVE-2024-4376": {"epss_score": 0.00361, "epss_percentile": 0.57714}, "CVE-2024-4377": {"epss_score": 0.00502, "epss_percentile": 0.65373}, "CVE-2024-4378": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-4379": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-4381": {"epss_score": 0.00164, "epss_percentile": 0.37891}, "CVE-2024-4382": {"epss_score": 0.00199, "epss_percentile": 0.4212}, "CVE-2024-4383": {"epss_score": 0.00249, "epss_percentile": 0.48004}, "CVE-2024-4384": {"epss_score": 0.00179, "epss_percentile": 0.39803}, "CVE-2024-4385": {"epss_score": 0.00305, "epss_percentile": 0.53361}, "CVE-2024-4386": {"epss_score": 0.00215, "epss_percentile": 0.44057}, "CVE-2024-4388": {"epss_score": 0.00581, "epss_percentile": 0.68265}, "CVE-2024-4389": {"epss_score": 0.1599, "epss_percentile": 0.9455}, "CVE-2024-4390": {"epss_score": 0.00392, "epss_percentile": 0.59699}, "CVE-2024-4391": {"epss_score": 0.00361, "epss_percentile": 0.57745}, "CVE-2024-4392": {"epss_score": 0.00434, "epss_percentile": 0.62281}, "CVE-2024-4393": {"epss_score": 0.00124, "epss_percentile": 0.32454}, "CVE-2024-4395": {"epss_score": 0.00097, "epss_percentile": 0.27581}, "CVE-2024-4397": {"epss_score": 0.14893, "epss_percentile": 0.94314}, "CVE-2024-4398": {"epss_score": 0.00228, "epss_percentile": 0.45512}, "CVE-2024-4399": {"epss_score": 0.30057, "epss_percentile": 0.96501}, "CVE-2024-4400": {"epss_score": 0.00235, "epss_percentile": 0.4624}, "CVE-2024-4401": {"epss_score": 0.00279, "epss_percentile": 0.50997}, "CVE-2024-4403": {"epss_score": 0.00055, "epss_percentile": 0.17536}, "CVE-2024-4404": {"epss_score": 0.00475, "epss_percentile": 0.64191}, "CVE-2024-4405": {"epss_score": 0.01954, "epss_percentile": 0.83031}, "CVE-2024-4406": {"epss_score": 0.68428, "epss_percentile": 0.98548}, "CVE-2024-4409": {"epss_score": 0.00115, "epss_percentile": 0.31028}, "CVE-2024-4410": {"epss_score": 0.00164, "epss_percentile": 0.37893}, "CVE-2024-4411": {"epss_score": 0.00229, "epss_percentile": 0.45634}, "CVE-2024-4413": {"epss_score": 0.05338, "epss_percentile": 0.89745}, "CVE-2024-4417": {"epss_score": 0.00198, "epss_percentile": 0.42003}, "CVE-2024-4418": {"epss_score": 0.00527, "epss_percentile": 0.66438}, "CVE-2024-4419": {"epss_score": 0.00288, "epss_percentile": 0.51871}, "CVE-2024-4420": {"epss_score": 0.0007, "epss_percentile": 0.21639}, "CVE-2024-4422": {"epss_score": 0.00248, "epss_percentile": 0.47949}, "CVE-2024-4423": {"epss_score": 0.00166, "epss_percentile": 0.38271}, "CVE-2024-4424": {"epss_score": 0.0032, "epss_percentile": 0.54599}, "CVE-2024-4425": {"epss_score": 0.00147, "epss_percentile": 0.35688}, "CVE-2024-4426": {"epss_score": 0.00179, "epss_percentile": 0.39781}, "CVE-2024-4427": {"epss_score": 0.00189, "epss_percentile": 0.40971}, "CVE-2024-4428": {"epss_score": 0.0012, "epss_percentile": 0.3169}, "CVE-2024-4429": {"epss_score": 0.00192, "epss_percentile": 0.41366}, "CVE-2024-4430": {"epss_score": 0.00273, "epss_percentile": 0.50431}, "CVE-2024-4431": {"epss_score": 0.00695, "epss_percentile": 0.71368}, "CVE-2024-4432": {"epss_score": 0.00255, "epss_percentile": 0.48698}, "CVE-2024-4433": {"epss_score": 0.00123, "epss_percentile": 0.32273}, "CVE-2024-4434": {"epss_score": 0.7709, "epss_percentile": 0.98921}, "CVE-2024-4435": {"epss_score": 0.00274, "epss_percentile": 0.50487}, "CVE-2024-4436": {"epss_score": 0.00078, "epss_percentile": 0.23625}, "CVE-2024-4437": {"epss_score": 0.00078, "epss_percentile": 0.23625}, "CVE-2024-4438": {"epss_score": 0.00085, "epss_percentile": 0.25036}, "CVE-2024-4439": {"epss_score": 0.91482, "epss_percentile": 0.99647}, "CVE-2024-4440": {"epss_score": 0.00651, "epss_percentile": 0.70291}, "CVE-2024-4441": {"epss_score": 0.00656, "epss_percentile": 0.70452}, "CVE-2024-4442": {"epss_score": 0.33702, "epss_percentile": 0.96799}, "CVE-2024-4443": {"epss_score": 0.93987, "epss_percentile": 0.9988}, "CVE-2024-4444": {"epss_score": 0.01405, "epss_percentile": 0.80045}, "CVE-2024-4445": {"epss_score": 0.00182, "epss_percentile": 0.40199}, "CVE-2024-4446": {"epss_score": 0.00177, "epss_percentile": 0.39564}, "CVE-2024-4447": {"epss_score": 0.0011, "epss_percentile": 0.30181}, "CVE-2024-4448": {"epss_score": 0.00646, "epss_percentile": 0.70134}, "CVE-2024-4449": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-4450": {"epss_score": 0.00113, "epss_percentile": 0.30659}, "CVE-2024-4451": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-4452": {"epss_score": 0.00234, "epss_percentile": 0.46117}, "CVE-2024-4453": {"epss_score": 0.03612, "epss_percentile": 0.87426}, "CVE-2024-4454": {"epss_score": 0.0013, "epss_percentile": 0.33236}, "CVE-2024-4455": {"epss_score": 0.07954, "epss_percentile": 0.91786}, "CVE-2024-4456": {"epss_score": 0.00256, "epss_percentile": 0.48818}, "CVE-2024-4458": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-4459": {"epss_score": 0.0022, "epss_percentile": 0.44538}, "CVE-2024-4461": {"epss_score": 0.00026, "epss_percentile": 0.06626}, "CVE-2024-4462": {"epss_score": 0.00288, "epss_percentile": 0.51871}, "CVE-2024-4463": {"epss_score": 0.00112, "epss_percentile": 0.30561}, "CVE-2024-4464": {"epss_score": 0.002, "epss_percentile": 0.42256}, "CVE-2024-4465": {"epss_score": 0.00134, "epss_percentile": 0.33765}, "CVE-2024-4466": {"epss_score": 0.00066, "epss_percentile": 0.208}, "CVE-2024-4467": {"epss_score": 0.00057, "epss_percentile": 0.1807}, "CVE-2024-4468": {"epss_score": 0.00571, "epss_percentile": 0.6798}, "CVE-2024-4469": {"epss_score": 0.00687, "epss_percentile": 0.71185}, "CVE-2024-4470": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-4471": {"epss_score": 0.00641, "epss_percentile": 0.69985}, "CVE-2024-4472": {"epss_score": 0.00023, "epss_percentile": 0.05424}, "CVE-2024-4473": {"epss_score": 0.00395, "epss_percentile": 0.598}, "CVE-2024-4474": {"epss_score": 0.02765, "epss_percentile": 0.85609}, "CVE-2024-4475": {"epss_score": 0.00065, "epss_percentile": 0.20638}, "CVE-2024-4477": {"epss_score": 0.0022, "epss_percentile": 0.44597}, "CVE-2024-4478": {"epss_score": 0.00361, "epss_percentile": 0.57745}, "CVE-2024-4479": {"epss_score": 0.00251, "epss_percentile": 0.48281}, "CVE-2024-4480": {"epss_score": 0.00098, "epss_percentile": 0.27745}, "CVE-2024-4481": {"epss_score": 0.00196, "epss_percentile": 0.41726}, "CVE-2024-4482": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-4483": {"epss_score": 0.00219, "epss_percentile": 0.44518}, "CVE-2024-4484": {"epss_score": 0.03483, "epss_percentile": 0.87223}, "CVE-2024-4485": {"epss_score": 0.00193, "epss_percentile": 0.41404}, "CVE-2024-4486": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-4487": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2024-4488": {"epss_score": 0.00272, "epss_percentile": 0.5037}, "CVE-2024-4489": {"epss_score": 0.00272, "epss_percentile": 0.5037}, "CVE-2024-4490": {"epss_score": 0.00239, "epss_percentile": 0.46913}, "CVE-2024-4491": {"epss_score": 0.00193, "epss_percentile": 0.41423}, "CVE-2024-4492": {"epss_score": 0.00189, "epss_percentile": 0.40997}, "CVE-2024-4493": {"epss_score": 0.00384, "epss_percentile": 0.59134}, "CVE-2024-4494": {"epss_score": 0.00384, "epss_percentile": 0.59134}, "CVE-2024-4495": {"epss_score": 0.00464, "epss_percentile": 0.63724}, "CVE-2024-4496": {"epss_score": 0.00412, "epss_percentile": 0.60925}, "CVE-2024-4497": {"epss_score": 0.00464, "epss_percentile": 0.63724}, "CVE-2024-4498": {"epss_score": 0.00195, "epss_percentile": 0.41634}, "CVE-2024-4499": {"epss_score": 0.00095, "epss_percentile": 0.27102}, "CVE-2024-4500": {"epss_score": 0.00079, "epss_percentile": 0.23812}, "CVE-2024-4501": {"epss_score": 0.00334, "epss_percentile": 0.55736}, "CVE-2024-4502": {"epss_score": 0.00307, "epss_percentile": 0.5353}, "CVE-2024-4503": {"epss_score": 0.00334, "epss_percentile": 0.55736}, "CVE-2024-4504": {"epss_score": 0.00307, "epss_percentile": 0.5353}, "CVE-2024-4505": {"epss_score": 0.00334, "epss_percentile": 0.55736}, "CVE-2024-4506": {"epss_score": 0.00186, "epss_percentile": 0.40662}, "CVE-2024-4507": {"epss_score": 0.00186, "epss_percentile": 0.40662}, "CVE-2024-4508": {"epss_score": 0.00357, "epss_percentile": 0.57404}, "CVE-2024-4509": {"epss_score": 0.00323, "epss_percentile": 0.54882}, "CVE-2024-4510": {"epss_score": 0.00323, "epss_percentile": 0.54882}, "CVE-2024-4511": {"epss_score": 0.00058, "epss_percentile": 0.18473}, "CVE-2024-4512": {"epss_score": 0.0016, "epss_percentile": 0.37469}, "CVE-2024-4513": {"epss_score": 0.00078, "epss_percentile": 0.23784}, "CVE-2024-4514": {"epss_score": 0.00118, "epss_percentile": 0.31423}, "CVE-2024-4515": {"epss_score": 0.00078, "epss_percentile": 0.23784}, "CVE-2024-4516": {"epss_score": 0.00075, "epss_percentile": 0.22908}, "CVE-2024-4517": {"epss_score": 0.00078, "epss_percentile": 0.23784}, "CVE-2024-4518": {"epss_score": 0.00072, "epss_percentile": 0.22384}, "CVE-2024-4519": {"epss_score": 0.00075, "epss_percentile": 0.22908}, "CVE-2024-4520": {"epss_score": 0.00157, "epss_percentile": 0.3708}, "CVE-2024-4521": {"epss_score": 0.00118, "epss_percentile": 0.31423}, "CVE-2024-4522": {"epss_score": 0.00118, "epss_percentile": 0.31423}, "CVE-2024-4523": {"epss_score": 0.00118, "epss_percentile": 0.31423}, "CVE-2024-4524": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2024-4525": {"epss_score": 0.00075, "epss_percentile": 0.22908}, "CVE-2024-4526": {"epss_score": 0.00069, "epss_percentile": 0.21455}, "CVE-2024-4527": {"epss_score": 0.00075, "epss_percentile": 0.22908}, "CVE-2024-4528": {"epss_score": 0.00093, "epss_percentile": 0.26688}, "CVE-2024-4529": {"epss_score": 0.00108, "epss_percentile": 0.29874}, "CVE-2024-4530": {"epss_score": 0.00113, "epss_percentile": 0.30723}, "CVE-2024-4531": {"epss_score": 0.00172, "epss_percentile": 0.38928}, "CVE-2024-4532": {"epss_score": 0.00093, "epss_percentile": 0.26686}, "CVE-2024-4533": {"epss_score": 0.0024, "epss_percentile": 0.47224}, "CVE-2024-4534": {"epss_score": 0.00217, "epss_percentile": 0.4432}, "CVE-2024-4535": {"epss_score": 0.00197, "epss_percentile": 0.41838}, "CVE-2024-4536": {"epss_score": 0.00041, "epss_percentile": 0.12281}, "CVE-2024-4537": {"epss_score": 0.00132, "epss_percentile": 0.33582}, "CVE-2024-4538": {"epss_score": 0.00226, "epss_percentile": 0.453}, "CVE-2024-4539": {"epss_score": 0.00147, "epss_percentile": 0.35673}, "CVE-2024-4540": {"epss_score": 0.00516, "epss_percentile": 0.66012}, "CVE-2024-4541": {"epss_score": 0.00115, "epss_percentile": 0.31028}, "CVE-2024-4543": {"epss_score": 0.00092, "epss_percentile": 0.26584}, "CVE-2024-4544": {"epss_score": 0.00185, "epss_percentile": 0.40483}, "CVE-2024-4545": {"epss_score": 0.00078, "epss_percentile": 0.23637}, "CVE-2024-4546": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-4547": {"epss_score": 0.01655, "epss_percentile": 0.81588}, "CVE-2024-4548": {"epss_score": 0.50396, "epss_percentile": 0.97735}, "CVE-2024-4549": {"epss_score": 0.00126, "epss_percentile": 0.32772}, "CVE-2024-4550": {"epss_score": 0.00025, "epss_percentile": 0.06154}, "CVE-2024-4551": {"epss_score": 0.00475, "epss_percentile": 0.64193}, "CVE-2024-4552": {"epss_score": 0.00293, "epss_percentile": 0.52309}, "CVE-2024-4553": {"epss_score": 0.00393, "epss_percentile": 0.5974}, "CVE-2024-4554": {"epss_score": 0.0028, "epss_percentile": 0.5109}, "CVE-2024-4555": {"epss_score": 0.002, "epss_percentile": 0.4221}, "CVE-2024-4556": {"epss_score": 0.00072, "epss_percentile": 0.22319}, "CVE-2024-4557": {"epss_score": 0.00178, "epss_percentile": 0.39682}, "CVE-2024-4558": {"epss_score": 0.02579, "epss_percentile": 0.85148}, "CVE-2024-4559": {"epss_score": 0.00355, "epss_percentile": 0.57284}, "CVE-2024-4560": {"epss_score": 0.17889, "epss_percentile": 0.94923}, "CVE-2024-4561": {"epss_score": 0.00368, "epss_percentile": 0.58179}, "CVE-2024-4562": {"epss_score": 0.00042, "epss_percentile": 0.12908}, "CVE-2024-4563": {"epss_score": 0.00056, "epss_percentile": 0.17684}, "CVE-2024-4564": {"epss_score": 0.00402, "epss_percentile": 0.60276}, "CVE-2024-4565": {"epss_score": 0.00248, "epss_percentile": 0.47918}, "CVE-2024-4566": {"epss_score": 0.00285, "epss_percentile": 0.51659}, "CVE-2024-4567": {"epss_score": 0.00352, "epss_percentile": 0.57078}, "CVE-2024-4568": {"epss_score": 0.0004, "epss_percentile": 0.12154}, "CVE-2024-4569": {"epss_score": 0.00172, "epss_percentile": 0.3897}, "CVE-2024-4570": {"epss_score": 0.0021, "epss_percentile": 0.43453}, "CVE-2024-4574": {"epss_score": 0.00421, "epss_percentile": 0.6149}, "CVE-2024-4575": {"epss_score": 0.00263, "epss_percentile": 0.49408}, "CVE-2024-4576": {"epss_score": 0.00768, "epss_percentile": 0.72974}, "CVE-2024-4577": {"epss_score": 0.94374, "epss_percentile": 0.99962}, "CVE-2024-4578": {"epss_score": 0.00089, "epss_percentile": 0.2584}, "CVE-2024-4580": {"epss_score": 0.00299, "epss_percentile": 0.52842}, "CVE-2024-4581": {"epss_score": 0.00327, "epss_percentile": 0.55105}, "CVE-2024-4582": {"epss_score": 0.00688, "epss_percentile": 0.71203}, "CVE-2024-4583": {"epss_score": 0.00208, "epss_percentile": 0.43303}, "CVE-2024-4584": {"epss_score": 0.00163, "epss_percentile": 0.37782}, "CVE-2024-4585": {"epss_score": 0.00098, "epss_percentile": 0.27721}, "CVE-2024-4586": {"epss_score": 0.00112, "epss_percentile": 0.30563}, "CVE-2024-4587": {"epss_score": 0.00103, "epss_percentile": 0.29075}, "CVE-2024-4588": {"epss_score": 0.00103, "epss_percentile": 0.29075}, "CVE-2024-4589": {"epss_score": 0.00103, "epss_percentile": 0.29075}, "CVE-2024-4590": {"epss_score": 0.00109, "epss_percentile": 0.29912}, "CVE-2024-4591": {"epss_score": 0.00098, "epss_percentile": 0.27721}, "CVE-2024-4592": {"epss_score": 0.00098, "epss_percentile": 0.27721}, "CVE-2024-4593": {"epss_score": 0.00098, "epss_percentile": 0.27721}, "CVE-2024-4594": {"epss_score": 0.00097, "epss_percentile": 0.27462}, "CVE-2024-4595": {"epss_score": 0.00117, "epss_percentile": 0.31368}, "CVE-2024-4596": {"epss_score": 0.00255, "epss_percentile": 0.48636}, "CVE-2024-4597": {"epss_score": 0.00021, "epss_percentile": 0.04781}, "CVE-2024-4598": {"epss_score": 0.00067, "epss_percentile": 0.21065}, "CVE-2024-4599": {"epss_score": 0.00697, "epss_percentile": 0.7141}, "CVE-2024-4600": {"epss_score": 0.00056, "epss_percentile": 0.17877}, "CVE-2024-4601": {"epss_score": 0.0007, "epss_percentile": 0.21649}, "CVE-2024-4602": {"epss_score": 0.00165, "epss_percentile": 0.38078}, "CVE-2024-4603": {"epss_score": 0.00092, "epss_percentile": 0.26412}, "CVE-2024-4604": {"epss_score": 0.00321, "epss_percentile": 0.54681}, "CVE-2024-4605": {"epss_score": 0.20126, "epss_percentile": 0.9529}, "CVE-2024-4606": {"epss_score": 0.0026, "epss_percentile": 0.49227}, "CVE-2024-4607": {"epss_score": 0.00166, "epss_percentile": 0.38243}, "CVE-2024-4608": {"epss_score": 0.00225, "epss_percentile": 0.45095}, "CVE-2024-4609": {"epss_score": 0.00079, "epss_percentile": 0.23988}, "CVE-2024-4610": {"epss_score": 0.00482, "epss_percentile": 0.64536}, "CVE-2024-4611": {"epss_score": 0.02321, "epss_percentile": 0.84369}, "CVE-2024-4612": {"epss_score": 0.00019, "epss_percentile": 0.04297}, "CVE-2024-4615": {"epss_score": 0.01052, "epss_percentile": 0.77092}, "CVE-2024-4616": {"epss_score": 0.00696, "epss_percentile": 0.71389}, "CVE-2024-4617": {"epss_score": 0.00273, "epss_percentile": 0.50461}, "CVE-2024-4618": {"epss_score": 0.00265, "epss_percentile": 0.4977}, "CVE-2024-4619": {"epss_score": 0.00518, "epss_percentile": 0.66123}, "CVE-2024-4620": {"epss_score": 0.72422, "epss_percentile": 0.98708}, "CVE-2024-4621": {"epss_score": 0.00091, "epss_percentile": 0.26196}, "CVE-2024-4622": {"epss_score": 0.00467, "epss_percentile": 0.63832}, "CVE-2024-4623": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-4624": {"epss_score": 0.00414, "epss_percentile": 0.61025}, "CVE-2024-4626": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-4627": {"epss_score": 0.00098, "epss_percentile": 0.2768}, "CVE-2024-4629": {"epss_score": 0.00807, "epss_percentile": 0.73676}, "CVE-2024-4630": {"epss_score": 0.00148, "epss_percentile": 0.3587}, "CVE-2024-4632": {"epss_score": 0.00176, "epss_percentile": 0.39476}, "CVE-2024-4633": {"epss_score": 0.00091, "epss_percentile": 0.26227}, "CVE-2024-4634": {"epss_score": 0.00273, "epss_percentile": 0.50461}, "CVE-2024-4635": {"epss_score": 0.00273, "epss_percentile": 0.50461}, "CVE-2024-4636": {"epss_score": 0.0038, "epss_percentile": 0.58961}, "CVE-2024-4637": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-4638": {"epss_score": 0.01097, "epss_percentile": 0.77531}, "CVE-2024-4639": {"epss_score": 0.01552, "epss_percentile": 0.80994}, "CVE-2024-4640": {"epss_score": 0.00725, "epss_percentile": 0.72057}, "CVE-2024-4641": {"epss_score": 0.00482, "epss_percentile": 0.64525}, "CVE-2024-4643": {"epss_score": 0.00326, "epss_percentile": 0.55046}, "CVE-2024-4644": {"epss_score": 0.00094, "epss_percentile": 0.26797}, "CVE-2024-4645": {"epss_score": 0.00094, "epss_percentile": 0.26797}, "CVE-2024-4646": {"epss_score": 0.00248, "epss_percentile": 0.47958}, "CVE-2024-4647": {"epss_score": 0.00289, "epss_percentile": 0.51999}, "CVE-2024-4648": {"epss_score": 0.00098, "epss_percentile": 0.27807}, "CVE-2024-4649": {"epss_score": 0.00138, "epss_percentile": 0.34384}, "CVE-2024-4650": {"epss_score": 0.00138, "epss_percentile": 0.34384}, "CVE-2024-4651": {"epss_score": 0.00118, "epss_percentile": 0.31423}, "CVE-2024-4652": {"epss_score": 0.00118, "epss_percentile": 0.31423}, "CVE-2024-4653": {"epss_score": 0.00054, "epss_percentile": 0.17109}, "CVE-2024-4654": {"epss_score": 0.00078, "epss_percentile": 0.23782}, "CVE-2024-4655": {"epss_score": 0.0011, "epss_percentile": 0.30104}, "CVE-2024-4656": {"epss_score": 0.00414, "epss_percentile": 0.61036}, "CVE-2024-4657": {"epss_score": 0.00194, "epss_percentile": 0.41541}, "CVE-2024-4658": {"epss_score": 0.00096, "epss_percentile": 0.27306}, "CVE-2024-4660": {"epss_score": 0.00045, "epss_percentile": 0.13904}, "CVE-2024-4661": {"epss_score": 0.00133, "epss_percentile": 0.33738}, "CVE-2024-4662": {"epss_score": 0.07903, "epss_percentile": 0.91755}, "CVE-2024-4663": {"epss_score": 0.00408, "epss_percentile": 0.60624}, "CVE-2024-4664": {"epss_score": 0.00108, "epss_percentile": 0.299}, "CVE-2024-4665": {"epss_score": 0.00035, "epss_percentile": 0.09908}, "CVE-2024-4666": {"epss_score": 0.00261, "epss_percentile": 0.49261}, "CVE-2024-4667": {"epss_score": 0.00391, "epss_percentile": 0.59629}, "CVE-2024-4668": {"epss_score": 0.00361, "epss_percentile": 0.57714}, "CVE-2024-4669": {"epss_score": 0.00361, "epss_percentile": 0.57714}, "CVE-2024-4670": {"epss_score": 0.01538, "epss_percentile": 0.80935}, "CVE-2024-4671": {"epss_score": 0.00198, "epss_percentile": 0.42009}, "CVE-2024-4672": {"epss_score": 0.00279, "epss_percentile": 0.50946}, "CVE-2024-4673": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4674": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4675": {"epss_score": 0.00279, "epss_percentile": 0.50946}, "CVE-2024-4676": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4677": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4678": {"epss_score": 0.00279, "epss_percentile": 0.50946}, "CVE-2024-4679": {"epss_score": 0.00068, "epss_percentile": 0.21355}, "CVE-2024-4680": {"epss_score": 0.00073, "epss_percentile": 0.22662}, "CVE-2024-4681": {"epss_score": 0.00259, "epss_percentile": 0.49046}, "CVE-2024-4682": {"epss_score": 0.00279, "epss_percentile": 0.50946}, "CVE-2024-4683": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4684": {"epss_score": 0.00279, "epss_percentile": 0.50946}, "CVE-2024-4685": {"epss_score": 0.00386, "epss_percentile": 0.5928}, "CVE-2024-4686": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4687": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4688": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4689": {"epss_score": 0.00121, "epss_percentile": 0.32006}, "CVE-2024-4690": {"epss_score": 0.00084, "epss_percentile": 0.24924}, "CVE-2024-4692": {"epss_score": 0.00118, "epss_percentile": 0.31403}, "CVE-2024-4693": {"epss_score": 0.00034, "epss_percentile": 0.0952}, "CVE-2024-4695": {"epss_score": 0.00522, "epss_percentile": 0.66261}, "CVE-2024-4696": {"epss_score": 0.00393, "epss_percentile": 0.59719}, "CVE-2024-4697": {"epss_score": 0.00361, "epss_percentile": 0.57745}, "CVE-2024-4698": {"epss_score": 0.00587, "epss_percentile": 0.68479}, "CVE-2024-4699": {"epss_score": 0.02469, "epss_percentile": 0.84843}, "CVE-2024-4700": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-4701": {"epss_score": 0.16726, "epss_percentile": 0.94722}, "CVE-2024-4702": {"epss_score": 0.00309, "epss_percentile": 0.53701}, "CVE-2024-4703": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-4704": {"epss_score": 0.0065, "epss_percentile": 0.70273}, "CVE-2024-4705": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-4706": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-4707": {"epss_score": 0.00225, "epss_percentile": 0.45095}, "CVE-2024-4708": {"epss_score": 0.00257, "epss_percentile": 0.48925}, "CVE-2024-4709": {"epss_score": 0.00253, "epss_percentile": 0.48459}, "CVE-2024-4710": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-4711": {"epss_score": 0.00123, "epss_percentile": 0.32237}, "CVE-2024-4712": {"epss_score": 0.00389, "epss_percentile": 0.59493}, "CVE-2024-4713": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4714": {"epss_score": 0.00126, "epss_percentile": 0.32667}, "CVE-2024-4715": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4716": {"epss_score": 0.00279, "epss_percentile": 0.50946}, "CVE-2024-4717": {"epss_score": 0.00386, "epss_percentile": 0.5928}, "CVE-2024-4718": {"epss_score": 0.00279, "epss_percentile": 0.50946}, "CVE-2024-4719": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4720": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4721": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4722": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4723": {"epss_score": 0.00116, "epss_percentile": 0.31096}, "CVE-2024-4724": {"epss_score": 0.00116, "epss_percentile": 0.31096}, "CVE-2024-4725": {"epss_score": 0.00116, "epss_percentile": 0.31096}, "CVE-2024-4726": {"epss_score": 0.0017, "epss_percentile": 0.38703}, "CVE-2024-4727": {"epss_score": 0.0017, "epss_percentile": 0.38703}, "CVE-2024-4728": {"epss_score": 0.0017, "epss_percentile": 0.38703}, "CVE-2024-4729": {"epss_score": 0.00296, "epss_percentile": 0.52538}, "CVE-2024-4730": {"epss_score": 0.00296, "epss_percentile": 0.52538}, "CVE-2024-4731": {"epss_score": 0.00296, "epss_percentile": 0.52538}, "CVE-2024-4732": {"epss_score": 0.00296, "epss_percentile": 0.52538}, "CVE-2024-4733": {"epss_score": 0.0191, "epss_percentile": 0.82823}, "CVE-2024-4734": {"epss_score": 0.00158, "epss_percentile": 0.3717}, "CVE-2024-4735": {"epss_score": 0.00288, "epss_percentile": 0.51944}, "CVE-2024-4736": {"epss_score": 0.00279, "epss_percentile": 0.50946}, "CVE-2024-4737": {"epss_score": 0.00128, "epss_percentile": 0.32994}, "CVE-2024-4738": {"epss_score": 0.0017, "epss_percentile": 0.38703}, "CVE-2024-4739": {"epss_score": 0.00367, "epss_percentile": 0.58108}, "CVE-2024-4740": {"epss_score": 0.00302, "epss_percentile": 0.53134}, "CVE-2024-4741": {"epss_score": 0.00238, "epss_percentile": 0.46813}, "CVE-2024-4742": {"epss_score": 0.0061, "epss_percentile": 0.69146}, "CVE-2024-4743": {"epss_score": 0.00372, "epss_percentile": 0.58425}, "CVE-2024-4744": {"epss_score": 0.00097, "epss_percentile": 0.27598}, "CVE-2024-4745": {"epss_score": 0.00101, "epss_percentile": 0.28616}, "CVE-2024-4746": {"epss_score": 0.00076, "epss_percentile": 0.23161}, "CVE-2024-4747": {"epss_score": 0.00197, "epss_percentile": 0.41912}, "CVE-2024-4748": {"epss_score": 0.00319, "epss_percentile": 0.54466}, "CVE-2024-4749": {"epss_score": 0.00176, "epss_percentile": 0.3946}, "CVE-2024-4750": {"epss_score": 0.00311, "epss_percentile": 0.53935}, "CVE-2024-4751": {"epss_score": 0.00295, "epss_percentile": 0.52468}, "CVE-2024-4752": {"epss_score": 0.0011, "epss_percentile": 0.30185}, "CVE-2024-4753": {"epss_score": 0.00127, "epss_percentile": 0.32801}, "CVE-2024-4754": {"epss_score": 0.00155, "epss_percentile": 0.36846}, "CVE-2024-4755": {"epss_score": 0.00154, "epss_percentile": 0.36713}, "CVE-2024-4756": {"epss_score": 0.00228, "epss_percentile": 0.45513}, "CVE-2024-4757": {"epss_score": 0.00389, "epss_percentile": 0.59457}, "CVE-2024-4758": {"epss_score": 0.00113, "epss_percentile": 0.30723}, "CVE-2024-4759": {"epss_score": 0.00092, "epss_percentile": 0.26486}, "CVE-2024-4760": {"epss_score": 0.00196, "epss_percentile": 0.41773}, "CVE-2024-4761": {"epss_score": 0.0318, "epss_percentile": 0.86577}, "CVE-2024-4762": {"epss_score": 0.00079, "epss_percentile": 0.23891}, "CVE-2024-4763": {"epss_score": 0.0007, "epss_percentile": 0.2188}, "CVE-2024-4764": {"epss_score": 0.00539, "epss_percentile": 0.66966}, "CVE-2024-4765": {"epss_score": 0.00154, "epss_percentile": 0.36645}, "CVE-2024-4766": {"epss_score": 0.00333, "epss_percentile": 0.55683}, "CVE-2024-4767": {"epss_score": 0.00803, "epss_percentile": 0.73602}, "CVE-2024-4768": {"epss_score": 0.00706, "epss_percentile": 0.71638}, "CVE-2024-4769": {"epss_score": 0.00638, "epss_percentile": 0.69909}, "CVE-2024-4770": {"epss_score": 0.00427, "epss_percentile": 0.61916}, "CVE-2024-4771": {"epss_score": 0.00624, "epss_percentile": 0.69564}, "CVE-2024-4772": {"epss_score": 0.00058, "epss_percentile": 0.18562}, "CVE-2024-4773": {"epss_score": 0.00299, "epss_percentile": 0.52868}, "CVE-2024-4774": {"epss_score": 0.00037, "epss_percentile": 0.10858}, "CVE-2024-4775": {"epss_score": 0.00065, "epss_percentile": 0.20535}, "CVE-2024-4776": {"epss_score": 0.00607, "epss_percentile": 0.69053}, "CVE-2024-4777": {"epss_score": 0.00706, "epss_percentile": 0.71612}, "CVE-2024-4778": {"epss_score": 0.00415, "epss_percentile": 0.61154}, "CVE-2024-4779": {"epss_score": 0.00634, "epss_percentile": 0.69791}, "CVE-2024-4780": {"epss_score": 0.00456, "epss_percentile": 0.63348}, "CVE-2024-4781": {"epss_score": 0.00071, "epss_percentile": 0.2219}, "CVE-2024-4782": {"epss_score": 0.00033, "epss_percentile": 0.09311}, "CVE-2024-4783": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-4784": {"epss_score": 0.00018, "epss_percentile": 0.0357}, "CVE-2024-4785": {"epss_score": 0.00218, "epss_percentile": 0.44373}, "CVE-2024-4786": {"epss_score": 0.0006, "epss_percentile": 0.19151}, "CVE-2024-4787": {"epss_score": 0.00578, "epss_percentile": 0.68196}, "CVE-2024-4788": {"epss_score": 0.00117, "epss_percentile": 0.31375}, "CVE-2024-4789": {"epss_score": 0.00165, "epss_percentile": 0.38024}, "CVE-2024-4790": {"epss_score": 0.0066, "epss_percentile": 0.70527}, "CVE-2024-4791": {"epss_score": 0.00197, "epss_percentile": 0.4193}, "CVE-2024-4792": {"epss_score": 0.00099, "epss_percentile": 0.27836}, "CVE-2024-4793": {"epss_score": 0.00096, "epss_percentile": 0.27408}, "CVE-2024-4794": {"epss_score": 0.00096, "epss_percentile": 0.27408}, "CVE-2024-4795": {"epss_score": 0.00112, "epss_percentile": 0.30492}, "CVE-2024-4796": {"epss_score": 0.00112, "epss_percentile": 0.30492}, "CVE-2024-4797": {"epss_score": 0.00386, "epss_percentile": 0.5928}, "CVE-2024-4798": {"epss_score": 0.00136, "epss_percentile": 0.34058}, "CVE-2024-4799": {"epss_score": 0.00221, "epss_percentile": 0.44649}, "CVE-2024-4800": {"epss_score": 0.00112, "epss_percentile": 0.30492}, "CVE-2024-4801": {"epss_score": 0.00292, "epss_percentile": 0.52279}, "CVE-2024-4802": {"epss_score": 0.00292, "epss_percentile": 0.52279}, "CVE-2024-4803": {"epss_score": 0.00292, "epss_percentile": 0.52279}, "CVE-2024-4804": {"epss_score": 0.00292, "epss_percentile": 0.52279}, "CVE-2024-4805": {"epss_score": 0.00292, "epss_percentile": 0.52279}, "CVE-2024-4806": {"epss_score": 0.00221, "epss_percentile": 0.44649}, "CVE-2024-4807": {"epss_score": 0.00292, "epss_percentile": 0.52279}, "CVE-2024-4808": {"epss_score": 0.00292, "epss_percentile": 0.52279}, "CVE-2024-4809": {"epss_score": 0.00274, "epss_percentile": 0.50577}, "CVE-2024-4811": {"epss_score": 0.00254, "epss_percentile": 0.48575}, "CVE-2024-4812": {"epss_score": 0.00108, "epss_percentile": 0.29799}, "CVE-2024-4813": {"epss_score": 0.01815, "epss_percentile": 0.82386}, "CVE-2024-4814": {"epss_score": 0.01815, "epss_percentile": 0.82386}, "CVE-2024-4815": {"epss_score": 0.01815, "epss_percentile": 0.82386}, "CVE-2024-4816": {"epss_score": 0.01815, "epss_percentile": 0.82386}, "CVE-2024-4817": {"epss_score": 0.00211, "epss_percentile": 0.43672}, "CVE-2024-4818": {"epss_score": 0.00309, "epss_percentile": 0.53645}, "CVE-2024-4819": {"epss_score": 0.00134, "epss_percentile": 0.3384}, "CVE-2024-4820": {"epss_score": 0.00202, "epss_percentile": 0.42432}, "CVE-2024-4821": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-4822": {"epss_score": 0.00166, "epss_percentile": 0.38238}, "CVE-2024-4823": {"epss_score": 0.00348, "epss_percentile": 0.5685}, "CVE-2024-4824": {"epss_score": 0.01836, "epss_percentile": 0.8247}, "CVE-2024-4825": {"epss_score": 0.00104, "epss_percentile": 0.29212}, "CVE-2024-4826": {"epss_score": 0.00175, "epss_percentile": 0.39299}, "CVE-2024-4835": {"epss_score": 0.09809, "epss_percentile": 0.92711}, "CVE-2024-4836": {"epss_score": 0.4491, "epss_percentile": 0.9746}, "CVE-2024-4837": {"epss_score": 0.00174, "epss_percentile": 0.39197}, "CVE-2024-4838": {"epss_score": 0.02902, "epss_percentile": 0.85956}, "CVE-2024-4839": {"epss_score": 0.00033, "epss_percentile": 0.09401}, "CVE-2024-4840": {"epss_score": 0.00016, "epss_percentile": 0.0267}, "CVE-2024-4841": {"epss_score": 0.09339, "epss_percentile": 0.92506}, "CVE-2024-4843": {"epss_score": 0.00226, "epss_percentile": 0.45352}, "CVE-2024-4844": {"epss_score": 0.00714, "epss_percentile": 0.71825}, "CVE-2024-4845": {"epss_score": 0.01186, "epss_percentile": 0.78346}, "CVE-2024-4846": {"epss_score": 0.00092, "epss_percentile": 0.26429}, "CVE-2024-4847": {"epss_score": 0.00443, "epss_percentile": 0.62756}, "CVE-2024-4849": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-4851": {"epss_score": 0.00142, "epss_percentile": 0.35038}, "CVE-2024-4853": {"epss_score": 0.00056, "epss_percentile": 0.17794}, "CVE-2024-4854": {"epss_score": 0.00608, "epss_percentile": 0.69061}, "CVE-2024-4855": {"epss_score": 0.00023, "epss_percentile": 0.05368}, "CVE-2024-4856": {"epss_score": 0.01742, "epss_percentile": 0.82055}, "CVE-2024-4857": {"epss_score": 0.01061, "epss_percentile": 0.77176}, "CVE-2024-4858": {"epss_score": 0.00195, "epss_percentile": 0.41636}, "CVE-2024-4859": {"epss_score": 0.00083, "epss_percentile": 0.24604}, "CVE-2024-4860": {"epss_score": 0.00247, "epss_percentile": 0.47832}, "CVE-2024-4862": {"epss_score": 0.01043, "epss_percentile": 0.76996}, "CVE-2024-4863": {"epss_score": 0.00346, "epss_percentile": 0.56675}, "CVE-2024-4865": {"epss_score": 0.00249, "epss_percentile": 0.48025}, "CVE-2024-4866": {"epss_score": 0.0048, "epss_percentile": 0.64453}, "CVE-2024-4868": {"epss_score": 0.00428, "epss_percentile": 0.6193}, "CVE-2024-4869": {"epss_score": 0.02784, "epss_percentile": 0.85654}, "CVE-2024-4870": {"epss_score": 0.00218, "epss_percentile": 0.44423}, "CVE-2024-4871": {"epss_score": 0.01738, "epss_percentile": 0.82021}, "CVE-2024-4872": {"epss_score": 0.00368, "epss_percentile": 0.58185}, "CVE-2024-4873": {"epss_score": 0.00122, "epss_percentile": 0.32104}, "CVE-2024-4874": {"epss_score": 0.0009, "epss_percentile": 0.25998}, "CVE-2024-4875": {"epss_score": 0.03836, "epss_percentile": 0.87824}, "CVE-2024-4876": {"epss_score": 0.00272, "epss_percentile": 0.5037}, "CVE-2024-4877": {"epss_score": 0.00155, "epss_percentile": 0.36808}, "CVE-2024-4879": {"epss_score": 0.94349, "epss_percentile": 0.99954}, "CVE-2024-4881": {"epss_score": 0.00311, "epss_percentile": 0.53821}, "CVE-2024-4882": {"epss_score": 0.00228, "epss_percentile": 0.45547}, "CVE-2024-4883": {"epss_score": 0.88557, "epss_percentile": 0.99477}, "CVE-2024-4884": {"epss_score": 0.58443, "epss_percentile": 0.98117}, "CVE-2024-4885": {"epss_score": 0.9426, "epss_percentile": 0.99929}, "CVE-2024-4886": {"epss_score": 0.00158, "epss_percentile": 0.37259}, "CVE-2024-4887": {"epss_score": 0.18109, "epss_percentile": 0.94958}, "CVE-2024-4888": {"epss_score": 0.0006, "epss_percentile": 0.18954}, "CVE-2024-4889": {"epss_score": 0.00163, "epss_percentile": 0.37836}, "CVE-2024-4890": {"epss_score": 0.00092, "epss_percentile": 0.265}, "CVE-2024-4891": {"epss_score": 0.00309, "epss_percentile": 0.53686}, "CVE-2024-4892": {"epss_score": 0.0041, "epss_percentile": 0.60793}, "CVE-2024-4893": {"epss_score": 0.00591, "epss_percentile": 0.68582}, "CVE-2024-4894": {"epss_score": 0.00171, "epss_percentile": 0.38896}, "CVE-2024-4895": {"epss_score": 0.02566, "epss_percentile": 0.85117}, "CVE-2024-4896": {"epss_score": 0.00361, "epss_percentile": 0.57745}, "CVE-2024-4897": {"epss_score": 0.01096, "epss_percentile": 0.77517}, "CVE-2024-4898": {"epss_score": 0.88481, "epss_percentile": 0.99474}, "CVE-2024-4899": {"epss_score": 0.00206, "epss_percentile": 0.43075}, "CVE-2024-4900": {"epss_score": 0.00177, "epss_percentile": 0.39588}, "CVE-2024-4901": {"epss_score": 0.04794, "epss_percentile": 0.89153}, "CVE-2024-4902": {"epss_score": 0.0118, "epss_percentile": 0.783}, "CVE-2024-4903": {"epss_score": 0.00028, "epss_percentile": 0.07257}, "CVE-2024-4904": {"epss_score": 0.00441, "epss_percentile": 0.62673}, "CVE-2024-4905": {"epss_score": 0.00155, "epss_percentile": 0.36784}, "CVE-2024-4906": {"epss_score": 0.00157, "epss_percentile": 0.37023}, "CVE-2024-4907": {"epss_score": 0.00157, "epss_percentile": 0.37023}, "CVE-2024-4908": {"epss_score": 0.00157, "epss_percentile": 0.37023}, "CVE-2024-4909": {"epss_score": 0.00157, "epss_percentile": 0.37023}, "CVE-2024-4910": {"epss_score": 0.00157, "epss_percentile": 0.37023}, "CVE-2024-4911": {"epss_score": 0.00157, "epss_percentile": 0.37023}, "CVE-2024-4912": {"epss_score": 0.00194, "epss_percentile": 0.41535}, "CVE-2024-4913": {"epss_score": 0.00194, "epss_percentile": 0.41535}, "CVE-2024-4914": {"epss_score": 0.00096, "epss_percentile": 0.27418}, "CVE-2024-4915": {"epss_score": 0.00098, "epss_percentile": 0.27797}, "CVE-2024-4916": {"epss_score": 0.00178, "epss_percentile": 0.39697}, "CVE-2024-4917": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-4918": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-4919": {"epss_score": 0.00178, "epss_percentile": 0.39697}, "CVE-2024-4920": {"epss_score": 0.00367, "epss_percentile": 0.58115}, "CVE-2024-4921": {"epss_score": 0.00367, "epss_percentile": 0.58135}, "CVE-2024-4922": {"epss_score": 0.00297, "epss_percentile": 0.52744}, "CVE-2024-4923": {"epss_score": 0.0011, "epss_percentile": 0.30183}, "CVE-2024-4924": {"epss_score": 0.00597, "epss_percentile": 0.68753}, "CVE-2024-4925": {"epss_score": 0.00081, "epss_percentile": 0.24333}, "CVE-2024-4926": {"epss_score": 0.00081, "epss_percentile": 0.24333}, "CVE-2024-4927": {"epss_score": 0.00224, "epss_percentile": 0.44978}, "CVE-2024-4928": {"epss_score": 0.00088, "epss_percentile": 0.25688}, "CVE-2024-4929": {"epss_score": 0.00142, "epss_percentile": 0.35009}, "CVE-2024-4930": {"epss_score": 0.0016, "epss_percentile": 0.37486}, "CVE-2024-4931": {"epss_score": 0.00088, "epss_percentile": 0.25688}, "CVE-2024-4932": {"epss_score": 0.0016, "epss_percentile": 0.37486}, "CVE-2024-4933": {"epss_score": 0.00111, "epss_percentile": 0.30279}, "CVE-2024-4934": {"epss_score": 0.00094, "epss_percentile": 0.26983}, "CVE-2024-4936": {"epss_score": 0.15983, "epss_percentile": 0.94548}, "CVE-2024-4939": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-4940": {"epss_score": 0.07236, "epss_percentile": 0.91342}, "CVE-2024-4941": {"epss_score": 0.00765, "epss_percentile": 0.72909}, "CVE-2024-4942": {"epss_score": 0.00186, "epss_percentile": 0.40603}, "CVE-2024-4943": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-4944": {"epss_score": 0.002, "epss_percentile": 0.42272}, "CVE-2024-4945": {"epss_score": 0.00252, "epss_percentile": 0.4835}, "CVE-2024-4946": {"epss_score": 0.00399, "epss_percentile": 0.60145}, "CVE-2024-4947": {"epss_score": 0.00832, "epss_percentile": 0.74074}, "CVE-2024-4948": {"epss_score": 0.00188, "epss_percentile": 0.40845}, "CVE-2024-4949": {"epss_score": 0.0033, "epss_percentile": 0.55416}, "CVE-2024-4950": {"epss_score": 0.00099, "epss_percentile": 0.28428}, "CVE-2024-4956": {"epss_score": 0.94028, "epss_percentile": 0.99889}, "CVE-2024-4957": {"epss_score": 0.00118, "epss_percentile": 0.31452}, "CVE-2024-4958": {"epss_score": 0.00721, "epss_percentile": 0.71971}, "CVE-2024-4959": {"epss_score": 0.0015, "epss_percentile": 0.36149}, "CVE-2024-4960": {"epss_score": 0.0126, "epss_percentile": 0.78973}, "CVE-2024-4961": {"epss_score": 0.01141, "epss_percentile": 0.77962}, "CVE-2024-4962": {"epss_score": 0.01201, "epss_percentile": 0.78481}, "CVE-2024-4963": {"epss_score": 0.01621, "epss_percentile": 0.81389}, "CVE-2024-4964": {"epss_score": 0.01325, "epss_percentile": 0.79471}, "CVE-2024-4965": {"epss_score": 0.03071, "epss_percentile": 0.86349}, "CVE-2024-4966": {"epss_score": 0.00298, "epss_percentile": 0.52824}, "CVE-2024-4967": {"epss_score": 0.00282, "epss_percentile": 0.51234}, "CVE-2024-4968": {"epss_score": 0.00279, "epss_percentile": 0.50986}, "CVE-2024-4969": {"epss_score": 0.00258, "epss_percentile": 0.48953}, "CVE-2024-4970": {"epss_score": 0.00323, "epss_percentile": 0.54881}, "CVE-2024-4971": {"epss_score": 0.00627, "epss_percentile": 0.69641}, "CVE-2024-4972": {"epss_score": 0.00191, "epss_percentile": 0.4117}, "CVE-2024-4973": {"epss_score": 0.00108, "epss_percentile": 0.29765}, "CVE-2024-4974": {"epss_score": 0.00094, "epss_percentile": 0.26797}, "CVE-2024-4975": {"epss_score": 0.00094, "epss_percentile": 0.26797}, "CVE-2024-4976": {"epss_score": 0.00078, "epss_percentile": 0.23648}, "CVE-2024-4977": {"epss_score": 0.00447, "epss_percentile": 0.62956}, "CVE-2024-4978": {"epss_score": 0.14148, "epss_percentile": 0.94145}, "CVE-2024-4980": {"epss_score": 0.00361, "epss_percentile": 0.57714}, "CVE-2024-4981": {"epss_score": 0.00063, "epss_percentile": 0.19843}, "CVE-2024-4982": {"epss_score": 0.00107, "epss_percentile": 0.29723}, "CVE-2024-4983": {"epss_score": 0.0042, "epss_percentile": 0.61402}, "CVE-2024-4984": {"epss_score": 0.00474, "epss_percentile": 0.64148}, "CVE-2024-4985": {"epss_score": 0.00445, "epss_percentile": 0.62881}, "CVE-2024-4988": {"epss_score": 0.00258, "epss_percentile": 0.49014}, "CVE-2024-4990": {"epss_score": 0.00286, "epss_percentile": 0.51747}, "CVE-2024-4991": {"epss_score": 0.01398, "epss_percentile": 0.7999}, "CVE-2024-4992": {"epss_score": 0.01398, "epss_percentile": 0.7999}, "CVE-2024-4993": {"epss_score": 0.00103, "epss_percentile": 0.28968}, "CVE-2024-4994": {"epss_score": 0.00048, "epss_percentile": 0.15175}, "CVE-2024-4995": {"epss_score": 0.00261, "epss_percentile": 0.49256}, "CVE-2024-4996": {"epss_score": 0.00218, "epss_percentile": 0.44429}, "CVE-2024-4997": {"epss_score": 0.00627, "epss_percentile": 0.69625}, "CVE-2024-4999": {"epss_score": 0.02998, "epss_percentile": 0.86157}, "CVE-2024-50000": {"epss_score": 7e-05, "epss_percentile": 0.00459}, "CVE-2024-50001": {"epss_score": 8e-05, "epss_percentile": 0.00485}, "CVE-2024-50002": {"epss_score": 9e-05, "epss_percentile": 0.00666}, "CVE-2024-50003": {"epss_score": 0.00015, "epss_percentile": 0.0229}, "CVE-2024-50004": {"epss_score": 0.00019, "epss_percentile": 0.04146}, "CVE-2024-50005": {"epss_score": 0.00026, "epss_percentile": 0.06419}, "CVE-2024-50006": {"epss_score": 0.0001, "epss_percentile": 0.00767}, "CVE-2024-50007": {"epss_score": 0.0002, "epss_percentile": 0.04491}, "CVE-2024-50008": {"epss_score": 0.00012, "epss_percentile": 0.01349}, "CVE-2024-50009": {"epss_score": 0.00015, "epss_percentile": 0.02169}, "CVE-2024-50010": {"epss_score": 0.00011, "epss_percentile": 0.01102}, "CVE-2024-50011": {"epss_score": 0.00011, "epss_percentile": 0.01074}, "CVE-2024-50012": {"epss_score": 0.00016, "epss_percentile": 0.02963}, "CVE-2024-50013": {"epss_score": 0.00014, "epss_percentile": 0.02027}, "CVE-2024-50014": {"epss_score": 0.00031, "epss_percentile": 0.0859}, "CVE-2024-50015": {"epss_score": 0.00016, "epss_percentile": 0.0286}, "CVE-2024-50017": {"epss_score": 0.00017, "epss_percentile": 0.03274}, "CVE-2024-50019": {"epss_score": 8e-05, "epss_percentile": 0.00574}, "CVE-2024-50020": {"epss_score": 8e-05, "epss_percentile": 0.00563}, "CVE-2024-50021": {"epss_score": 0.0001, "epss_percentile": 0.00811}, "CVE-2024-50022": {"epss_score": 9e-05, "epss_percentile": 0.00663}, "CVE-2024-50023": {"epss_score": 0.0001, "epss_percentile": 0.00915}, "CVE-2024-50024": {"epss_score": 7e-05, "epss_percentile": 0.00396}, "CVE-2024-50025": {"epss_score": 0.0001, "epss_percentile": 0.00811}, "CVE-2024-50026": {"epss_score": 9e-05, "epss_percentile": 0.00663}, "CVE-2024-50027": {"epss_score": 0.0001, "epss_percentile": 0.00884}, "CVE-2024-50028": {"epss_score": 0.0001, "epss_percentile": 0.00819}, "CVE-2024-50029": {"epss_score": 0.00012, "epss_percentile": 0.01423}, "CVE-2024-50030": {"epss_score": 0.00012, "epss_percentile": 0.01184}, "CVE-2024-50031": {"epss_score": 0.00011, "epss_percentile": 0.01036}, "CVE-2024-50033": {"epss_score": 7e-05, "epss_percentile": 0.00407}, "CVE-2024-50034": {"epss_score": 0.00011, "epss_percentile": 0.01038}, "CVE-2024-50035": {"epss_score": 7e-05, "epss_percentile": 0.00335}, "CVE-2024-50036": {"epss_score": 0.0002, "epss_percentile": 0.04636}, "CVE-2024-50037": {"epss_score": 0.00019, "epss_percentile": 0.04293}, "CVE-2024-50038": {"epss_score": 0.00012, "epss_percentile": 0.01418}, "CVE-2024-50039": {"epss_score": 0.00013, "epss_percentile": 0.01495}, "CVE-2024-50040": {"epss_score": 0.00013, "epss_percentile": 0.01495}, "CVE-2024-50041": {"epss_score": 0.00015, "epss_percentile": 0.02222}, "CVE-2024-50042": {"epss_score": 0.00018, "epss_percentile": 0.03934}, "CVE-2024-50043": {"epss_score": 0.00025, "epss_percentile": 0.06372}, "CVE-2024-50044": {"epss_score": 0.0001, "epss_percentile": 0.00848}, "CVE-2024-50045": {"epss_score": 0.00013, "epss_percentile": 0.01495}, "CVE-2024-50046": {"epss_score": 0.00012, "epss_percentile": 0.01252}, "CVE-2024-50047": {"epss_score": 0.00019, "epss_percentile": 0.04096}, "CVE-2024-50048": {"epss_score": 0.00029, "epss_percentile": 0.07605}, "CVE-2024-50049": {"epss_score": 0.00011, "epss_percentile": 0.01015}, "CVE-2024-50050": {"epss_score": 0.02602, "epss_percentile": 0.85209}, "CVE-2024-50051": {"epss_score": 0.00048, "epss_percentile": 0.15111}, "CVE-2024-50052": {"epss_score": 0.00256, "epss_percentile": 0.48741}, "CVE-2024-50053": {"epss_score": 0.00212, "epss_percentile": 0.43745}, "CVE-2024-50054": {"epss_score": 0.00121, "epss_percentile": 0.31983}, "CVE-2024-50055": {"epss_score": 0.00021, "epss_percentile": 0.04758}, "CVE-2024-50056": {"epss_score": 0.00031, "epss_percentile": 0.08666}, "CVE-2024-50057": {"epss_score": 0.00016, "epss_percentile": 0.02623}, "CVE-2024-50058": {"epss_score": 0.00012, "epss_percentile": 0.01209}, "CVE-2024-50059": {"epss_score": 0.0002, "epss_percentile": 0.04583}, "CVE-2024-50060": {"epss_score": 0.00017, "epss_percentile": 0.03405}, "CVE-2024-50061": {"epss_score": 0.00021, "epss_percentile": 0.04695}, "CVE-2024-50062": {"epss_score": 0.00015, "epss_percentile": 0.0229}, "CVE-2024-50063": {"epss_score": 5e-05, "epss_percentile": 0.00196}, "CVE-2024-50064": {"epss_score": 0.0002, "epss_percentile": 0.04616}, "CVE-2024-50065": {"epss_score": 0.0002, "epss_percentile": 0.04631}, "CVE-2024-50066": {"epss_score": 0.00018, "epss_percentile": 0.03798}, "CVE-2024-50067": {"epss_score": 0.00033, "epss_percentile": 0.09333}, "CVE-2024-50068": {"epss_score": 0.00019, "epss_percentile": 0.04273}, "CVE-2024-50069": {"epss_score": 0.00021, "epss_percentile": 0.0476}, "CVE-2024-50070": {"epss_score": 0.00017, "epss_percentile": 0.03319}, "CVE-2024-50071": {"epss_score": 0.00072, "epss_percentile": 0.22378}, "CVE-2024-50072": {"epss_score": 0.00023, "epss_percentile": 0.05404}, "CVE-2024-50073": {"epss_score": 0.00016, "epss_percentile": 0.02771}, "CVE-2024-50074": {"epss_score": 0.00022, "epss_percentile": 0.05136}, "CVE-2024-50075": {"epss_score": 0.00022, "epss_percentile": 0.05131}, "CVE-2024-50076": {"epss_score": 0.00072, "epss_percentile": 0.22438}, "CVE-2024-50077": {"epss_score": 0.00021, "epss_percentile": 0.04728}, "CVE-2024-50078": {"epss_score": 0.00021, "epss_percentile": 0.04728}, "CVE-2024-50079": {"epss_score": 0.00019, "epss_percentile": 0.04352}, "CVE-2024-50080": {"epss_score": 0.00017, "epss_percentile": 0.03319}, "CVE-2024-50081": {"epss_score": 0.00019, "epss_percentile": 0.04352}, "CVE-2024-50082": {"epss_score": 0.00014, "epss_percentile": 0.01912}, "CVE-2024-50083": {"epss_score": 0.001, "epss_percentile": 0.28504}, "CVE-2024-50084": {"epss_score": 0.00021, "epss_percentile": 0.04808}, "CVE-2024-50085": {"epss_score": 0.00013, "epss_percentile": 0.01721}, "CVE-2024-50086": {"epss_score": 0.00017, "epss_percentile": 0.03329}, "CVE-2024-50087": {"epss_score": 0.00017, "epss_percentile": 0.03328}, "CVE-2024-50088": {"epss_score": 0.00029, "epss_percentile": 0.07765}, "CVE-2024-50090": {"epss_score": 0.0001, "epss_percentile": 0.00783}, "CVE-2024-50091": {"epss_score": 0.00025, "epss_percentile": 0.06304}, "CVE-2024-50092": {"epss_score": 0.00026, "epss_percentile": 0.0655}, "CVE-2024-50093": {"epss_score": 9e-05, "epss_percentile": 0.00658}, "CVE-2024-50094": {"epss_score": 0.00028, "epss_percentile": 0.0723}, "CVE-2024-50095": {"epss_score": 7e-05, "epss_percentile": 0.00333}, "CVE-2024-50096": {"epss_score": 7e-05, "epss_percentile": 0.00408}, "CVE-2024-50097": {"epss_score": 0.00027, "epss_percentile": 0.07097}, "CVE-2024-50098": {"epss_score": 0.0001, "epss_percentile": 0.00754}, "CVE-2024-50099": {"epss_score": 8e-05, "epss_percentile": 0.00498}, "CVE-2024-50100": {"epss_score": 0.00012, "epss_percentile": 0.01203}, "CVE-2024-50101": {"epss_score": 7e-05, "epss_percentile": 0.00459}, "CVE-2024-50102": {"epss_score": 0.00017, "epss_percentile": 0.03203}, "CVE-2024-50103": {"epss_score": 7e-05, "epss_percentile": 0.00405}, "CVE-2024-50104": {"epss_score": 0.00019, "epss_percentile": 0.04188}, "CVE-2024-50105": {"epss_score": 0.00028, "epss_percentile": 0.0723}, "CVE-2024-50106": {"epss_score": 0.00013, "epss_percentile": 0.01479}, "CVE-2024-50107": {"epss_score": 0.00018, "epss_percentile": 0.03797}, "CVE-2024-50108": {"epss_score": 0.0001, "epss_percentile": 0.0091}, "CVE-2024-50109": {"epss_score": 0.00012, "epss_percentile": 0.01392}, "CVE-2024-50110": {"epss_score": 9e-05, "epss_percentile": 0.00722}, "CVE-2024-50111": {"epss_score": 0.0001, "epss_percentile": 0.00879}, "CVE-2024-50112": {"epss_score": 0.00019, "epss_percentile": 0.04417}, "CVE-2024-50113": {"epss_score": 0.00044, "epss_percentile": 0.13492}, "CVE-2024-50114": {"epss_score": 0.00045, "epss_percentile": 0.14014}, "CVE-2024-50115": {"epss_score": 0.00014, "epss_percentile": 0.01917}, "CVE-2024-50116": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-50117": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-50118": {"epss_score": 0.00069, "epss_percentile": 0.21565}, "CVE-2024-50119": {"epss_score": 0.00069, "epss_percentile": 0.21565}, "CVE-2024-50120": {"epss_score": 0.00035, "epss_percentile": 0.10011}, "CVE-2024-50121": {"epss_score": 0.00018, "epss_percentile": 0.03741}, "CVE-2024-50122": {"epss_score": 0.00033, "epss_percentile": 0.09331}, "CVE-2024-50123": {"epss_score": 0.00071, "epss_percentile": 0.22115}, "CVE-2024-50124": {"epss_score": 0.00024, "epss_percentile": 0.06013}, "CVE-2024-50125": {"epss_score": 0.00019, "epss_percentile": 0.0411}, "CVE-2024-50126": {"epss_score": 0.00024, "epss_percentile": 0.05975}, "CVE-2024-50127": {"epss_score": 0.00022, "epss_percentile": 0.05136}, "CVE-2024-50128": {"epss_score": 0.00015, "epss_percentile": 0.02514}, "CVE-2024-50129": {"epss_score": 0.00028, "epss_percentile": 0.07238}, "CVE-2024-50130": {"epss_score": 0.00029, "epss_percentile": 0.07846}, "CVE-2024-50131": {"epss_score": 0.00022, "epss_percentile": 0.05136}, "CVE-2024-50132": {"epss_score": 0.00051, "epss_percentile": 0.15986}, "CVE-2024-50133": {"epss_score": 0.00051, "epss_percentile": 0.16312}, "CVE-2024-50134": {"epss_score": 0.00013, "epss_percentile": 0.01448}, "CVE-2024-50135": {"epss_score": 0.00016, "epss_percentile": 0.02798}, "CVE-2024-50136": {"epss_score": 0.00017, "epss_percentile": 0.03451}, "CVE-2024-50137": {"epss_score": 0.0002, "epss_percentile": 0.04673}, "CVE-2024-50138": {"epss_score": 0.00021, "epss_percentile": 0.0476}, "CVE-2024-50139": {"epss_score": 0.00011, "epss_percentile": 0.01069}, "CVE-2024-50140": {"epss_score": 9e-05, "epss_percentile": 0.00744}, "CVE-2024-50141": {"epss_score": 7e-05, "epss_percentile": 0.00459}, "CVE-2024-50142": {"epss_score": 7e-05, "epss_percentile": 0.00406}, "CVE-2024-50143": {"epss_score": 0.00013, "epss_percentile": 0.01723}, "CVE-2024-50144": {"epss_score": 0.00018, "epss_percentile": 0.03797}, "CVE-2024-50145": {"epss_score": 0.00011, "epss_percentile": 0.01094}, "CVE-2024-50146": {"epss_score": 0.0001, "epss_percentile": 0.00765}, "CVE-2024-50147": {"epss_score": 0.00011, "epss_percentile": 0.01094}, "CVE-2024-50148": {"epss_score": 7e-05, "epss_percentile": 0.00382}, "CVE-2024-50149": {"epss_score": 0.00034, "epss_percentile": 0.09555}, "CVE-2024-50150": {"epss_score": 0.00022, "epss_percentile": 0.05136}, "CVE-2024-50151": {"epss_score": 0.00022, "epss_percentile": 0.05136}, "CVE-2024-50152": {"epss_score": 0.00017, "epss_percentile": 0.0321}, "CVE-2024-50153": {"epss_score": 9e-05, "epss_percentile": 0.00737}, "CVE-2024-50154": {"epss_score": 0.00022, "epss_percentile": 0.05288}, "CVE-2024-50155": {"epss_score": 0.00024, "epss_percentile": 0.05966}, "CVE-2024-50156": {"epss_score": 0.00013, "epss_percentile": 0.01656}, "CVE-2024-50157": {"epss_score": 0.00017, "epss_percentile": 0.03275}, "CVE-2024-50158": {"epss_score": 0.00033, "epss_percentile": 0.09299}, "CVE-2024-50159": {"epss_score": 0.00054, "epss_percentile": 0.17094}, "CVE-2024-50160": {"epss_score": 0.00013, "epss_percentile": 0.01656}, "CVE-2024-50161": {"epss_score": 0.00068, "epss_percentile": 0.21345}, "CVE-2024-50162": {"epss_score": 0.00013, "epss_percentile": 0.01656}, "CVE-2024-50163": {"epss_score": 0.00013, "epss_percentile": 0.01656}, "CVE-2024-50164": {"epss_score": 0.00013, "epss_percentile": 0.01615}, "CVE-2024-50165": {"epss_score": 0.00037, "epss_percentile": 0.10891}, "CVE-2024-50166": {"epss_score": 0.00017, "epss_percentile": 0.03319}, "CVE-2024-50167": {"epss_score": 0.00014, "epss_percentile": 0.01761}, "CVE-2024-50168": {"epss_score": 0.00012, "epss_percentile": 0.01419}, "CVE-2024-50169": {"epss_score": 0.0002, "epss_percentile": 0.04631}, "CVE-2024-50170": {"epss_score": 0.00035, "epss_percentile": 0.09823}, "CVE-2024-50171": {"epss_score": 0.00012, "epss_percentile": 0.01419}, "CVE-2024-50172": {"epss_score": 0.00029, "epss_percentile": 0.07776}, "CVE-2024-50173": {"epss_score": 0.0002, "epss_percentile": 0.04548}, "CVE-2024-50174": {"epss_score": 0.00016, "epss_percentile": 0.02626}, "CVE-2024-50175": {"epss_score": 0.00011, "epss_percentile": 0.01054}, "CVE-2024-50176": {"epss_score": 8e-05, "epss_percentile": 0.00496}, "CVE-2024-50177": {"epss_score": 0.0001, "epss_percentile": 0.00785}, "CVE-2024-50178": {"epss_score": 0.00011, "epss_percentile": 0.01093}, "CVE-2024-50179": {"epss_score": 7e-05, "epss_percentile": 0.00465}, "CVE-2024-50180": {"epss_score": 0.00013, "epss_percentile": 0.0158}, "CVE-2024-50182": {"epss_score": 7e-05, "epss_percentile": 0.00445}, "CVE-2024-50183": {"epss_score": 0.0001, "epss_percentile": 0.00756}, "CVE-2024-50184": {"epss_score": 8e-05, "epss_percentile": 0.00522}, "CVE-2024-50185": {"epss_score": 7e-05, "epss_percentile": 0.00405}, "CVE-2024-50186": {"epss_score": 0.00013, "epss_percentile": 0.01606}, "CVE-2024-50187": {"epss_score": 0.00011, "epss_percentile": 0.01052}, "CVE-2024-50188": {"epss_score": 0.00019, "epss_percentile": 0.04276}, "CVE-2024-50189": {"epss_score": 0.00019, "epss_percentile": 0.04206}, "CVE-2024-50190": {"epss_score": 0.0002, "epss_percentile": 0.0454}, "CVE-2024-50191": {"epss_score": 0.00019, "epss_percentile": 0.04091}, "CVE-2024-50192": {"epss_score": 0.00013, "epss_percentile": 0.01597}, "CVE-2024-50193": {"epss_score": 0.00012, "epss_percentile": 0.01242}, "CVE-2024-50194": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-50195": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-50196": {"epss_score": 0.00012, "epss_percentile": 0.01316}, "CVE-2024-50197": {"epss_score": 0.00022, "epss_percentile": 0.04992}, "CVE-2024-50198": {"epss_score": 0.00013, "epss_percentile": 0.01525}, "CVE-2024-50199": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-50200": {"epss_score": 0.00017, "epss_percentile": 0.03405}, "CVE-2024-50201": {"epss_score": 0.00013, "epss_percentile": 0.01525}, "CVE-2024-50202": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-50203": {"epss_score": 0.0003, "epss_percentile": 0.08084}, "CVE-2024-50204": {"epss_score": 0.00033, "epss_percentile": 0.09239}, "CVE-2024-50205": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2024-50206": {"epss_score": 0.00038, "epss_percentile": 0.11396}, "CVE-2024-50207": {"epss_score": 0.00013, "epss_percentile": 0.01722}, "CVE-2024-50208": {"epss_score": 0.0002, "epss_percentile": 0.04598}, "CVE-2024-50209": {"epss_score": 0.00023, "epss_percentile": 0.05469}, "CVE-2024-50210": {"epss_score": 0.00011, "epss_percentile": 0.00969}, "CVE-2024-50211": {"epss_score": 0.00016, "epss_percentile": 0.02641}, "CVE-2024-50212": {"epss_score": 0.00099, "epss_percentile": 0.2835}, "CVE-2024-50213": {"epss_score": 0.00039, "epss_percentile": 0.11583}, "CVE-2024-50214": {"epss_score": 0.00028, "epss_percentile": 0.07363}, "CVE-2024-50215": {"epss_score": 0.00012, "epss_percentile": 0.01205}, "CVE-2024-50216": {"epss_score": 0.00027, "epss_percentile": 0.07097}, "CVE-2024-50217": {"epss_score": 0.00025, "epss_percentile": 0.06258}, "CVE-2024-50218": {"epss_score": 0.00011, "epss_percentile": 0.01085}, "CVE-2024-50220": {"epss_score": 9e-05, "epss_percentile": 0.0063}, "CVE-2024-50221": {"epss_score": 0.00031, "epss_percentile": 0.08685}, "CVE-2024-50222": {"epss_score": 0.00029, "epss_percentile": 0.07615}, "CVE-2024-50223": {"epss_score": 9e-05, "epss_percentile": 0.00744}, "CVE-2024-50224": {"epss_score": 0.00013, "epss_percentile": 0.01678}, "CVE-2024-50225": {"epss_score": 0.00011, "epss_percentile": 0.00942}, "CVE-2024-50226": {"epss_score": 0.00013, "epss_percentile": 0.01689}, "CVE-2024-50227": {"epss_score": 0.00038, "epss_percentile": 0.11364}, "CVE-2024-50229": {"epss_score": 0.0001, "epss_percentile": 0.00768}, "CVE-2024-50230": {"epss_score": 0.00014, "epss_percentile": 0.01759}, "CVE-2024-50231": {"epss_score": 0.00011, "epss_percentile": 0.01037}, "CVE-2024-50232": {"epss_score": 9e-05, "epss_percentile": 0.00738}, "CVE-2024-50233": {"epss_score": 0.00012, "epss_percentile": 0.01353}, "CVE-2024-50234": {"epss_score": 0.0001, "epss_percentile": 0.00787}, "CVE-2024-50235": {"epss_score": 0.00012, "epss_percentile": 0.01205}, "CVE-2024-50236": {"epss_score": 0.00012, "epss_percentile": 0.01324}, "CVE-2024-50237": {"epss_score": 0.00012, "epss_percentile": 0.01353}, "CVE-2024-50238": {"epss_score": 0.00033, "epss_percentile": 0.09239}, "CVE-2024-50239": {"epss_score": 0.00051, "epss_percentile": 0.15986}, "CVE-2024-50240": {"epss_score": 0.0005, "epss_percentile": 0.15871}, "CVE-2024-50241": {"epss_score": 0.00013, "epss_percentile": 0.01656}, "CVE-2024-50242": {"epss_score": 0.00016, "epss_percentile": 0.02729}, "CVE-2024-50243": {"epss_score": 0.00021, "epss_percentile": 0.04921}, "CVE-2024-50244": {"epss_score": 0.00016, "epss_percentile": 0.02657}, "CVE-2024-50245": {"epss_score": 0.00016, "epss_percentile": 0.02657}, "CVE-2024-50246": {"epss_score": 0.00022, "epss_percentile": 0.0525}, "CVE-2024-50247": {"epss_score": 0.00028, "epss_percentile": 0.07305}, "CVE-2024-50248": {"epss_score": 0.00016, "epss_percentile": 0.02749}, "CVE-2024-50249": {"epss_score": 0.00018, "epss_percentile": 0.03719}, "CVE-2024-50250": {"epss_score": 0.0002, "epss_percentile": 0.04528}, "CVE-2024-50251": {"epss_score": 0.00304, "epss_percentile": 0.53272}, "CVE-2024-50252": {"epss_score": 0.00023, "epss_percentile": 0.055}, "CVE-2024-50253": {"epss_score": 0.00033, "epss_percentile": 0.09239}, "CVE-2024-50254": {"epss_score": 0.00033, "epss_percentile": 0.09148}, "CVE-2024-50255": {"epss_score": 0.00023, "epss_percentile": 0.05609}, "CVE-2024-50256": {"epss_score": 0.00024, "epss_percentile": 0.05866}, "CVE-2024-50257": {"epss_score": 0.00038, "epss_percentile": 0.11412}, "CVE-2024-50258": {"epss_score": 0.00013, "epss_percentile": 0.0168}, "CVE-2024-50259": {"epss_score": 0.00017, "epss_percentile": 0.03245}, "CVE-2024-50260": {"epss_score": 0.00051, "epss_percentile": 0.16031}, "CVE-2024-50261": {"epss_score": 0.00022, "epss_percentile": 0.05283}, "CVE-2024-50262": {"epss_score": 0.00027, "epss_percentile": 0.06834}, "CVE-2024-50263": {"epss_score": 0.00035, "epss_percentile": 0.09939}, "CVE-2024-50264": {"epss_score": 0.00039, "epss_percentile": 0.11642}, "CVE-2024-50265": {"epss_score": 0.00015, "epss_percentile": 0.02432}, "CVE-2024-50266": {"epss_score": 0.00028, "epss_percentile": 0.0723}, "CVE-2024-50267": {"epss_score": 0.00014, "epss_percentile": 0.01759}, "CVE-2024-50268": {"epss_score": 8e-05, "epss_percentile": 0.00534}, "CVE-2024-50269": {"epss_score": 0.00014, "epss_percentile": 0.01759}, "CVE-2024-50270": {"epss_score": 0.00011, "epss_percentile": 0.00942}, "CVE-2024-50271": {"epss_score": 0.00013, "epss_percentile": 0.0152}, "CVE-2024-50272": {"epss_score": 5e-05, "epss_percentile": 0.00229}, "CVE-2024-50273": {"epss_score": 0.00012, "epss_percentile": 0.01353}, "CVE-2024-50274": {"epss_score": 0.00013, "epss_percentile": 0.01453}, "CVE-2024-50275": {"epss_score": 0.0001, "epss_percentile": 0.00881}, "CVE-2024-50276": {"epss_score": 0.00012, "epss_percentile": 0.01205}, "CVE-2024-50277": {"epss_score": 0.0001, "epss_percentile": 0.00796}, "CVE-2024-50278": {"epss_score": 0.00017, "epss_percentile": 0.03195}, "CVE-2024-50279": {"epss_score": 0.00017, "epss_percentile": 0.03195}, "CVE-2024-50280": {"epss_score": 0.00022, "epss_percentile": 0.05026}, "CVE-2024-50281": {"epss_score": 0.00033, "epss_percentile": 0.09239}, "CVE-2024-50282": {"epss_score": 0.00016, "epss_percentile": 0.02729}, "CVE-2024-50283": {"epss_score": 0.00017, "epss_percentile": 0.0331}, "CVE-2024-50284": {"epss_score": 0.00022, "epss_percentile": 0.05244}, "CVE-2024-50285": {"epss_score": 0.00027, "epss_percentile": 0.06813}, "CVE-2024-50286": {"epss_score": 0.00021, "epss_percentile": 0.049}, "CVE-2024-50287": {"epss_score": 0.00022, "epss_percentile": 0.05305}, "CVE-2024-50288": {"epss_score": 0.00016, "epss_percentile": 0.02799}, "CVE-2024-50289": {"epss_score": 0.00018, "epss_percentile": 0.03603}, "CVE-2024-50290": {"epss_score": 0.00021, "epss_percentile": 0.04929}, "CVE-2024-50291": {"epss_score": 0.00025, "epss_percentile": 0.06068}, "CVE-2024-50292": {"epss_score": 0.00021, "epss_percentile": 0.04811}, "CVE-2024-50293": {"epss_score": 0.00057, "epss_percentile": 0.18149}, "CVE-2024-50294": {"epss_score": 0.00013, "epss_percentile": 0.01646}, "CVE-2024-50295": {"epss_score": 0.0002, "epss_percentile": 0.04563}, "CVE-2024-50296": {"epss_score": 0.00022, "epss_percentile": 0.05305}, "CVE-2024-50297": {"epss_score": 0.00015, "epss_percentile": 0.02299}, "CVE-2024-50298": {"epss_score": 0.0002, "epss_percentile": 0.04631}, "CVE-2024-50299": {"epss_score": 0.00022, "epss_percentile": 0.05266}, "CVE-2024-50300": {"epss_score": 0.0005, "epss_percentile": 0.15871}, "CVE-2024-50301": {"epss_score": 0.00058, "epss_percentile": 0.18387}, "CVE-2024-50302": {"epss_score": 0.01318, "epss_percentile": 0.7943}, "CVE-2024-50303": {"epss_score": 0.00012, "epss_percentile": 0.01392}, "CVE-2024-50304": {"epss_score": 0.0002, "epss_percentile": 0.0447}, "CVE-2024-50305": {"epss_score": 0.00318, "epss_percentile": 0.54403}, "CVE-2024-50306": {"epss_score": 0.00684, "epss_percentile": 0.71121}, "CVE-2024-50307": {"epss_score": 0.00015, "epss_percentile": 0.02535}, "CVE-2024-50310": {"epss_score": 0.00413, "epss_percentile": 0.61001}, "CVE-2024-50311": {"epss_score": 0.00329, "epss_percentile": 0.55322}, "CVE-2024-50312": {"epss_score": 0.00194, "epss_percentile": 0.41546}, "CVE-2024-50313": {"epss_score": 0.00561, "epss_percentile": 0.67662}, "CVE-2024-50317": {"epss_score": 0.06025, "epss_percentile": 0.90419}, "CVE-2024-50318": {"epss_score": 0.06025, "epss_percentile": 0.90419}, "CVE-2024-50319": {"epss_score": 0.06007, "epss_percentile": 0.90398}, "CVE-2024-50320": {"epss_score": 0.25877, "epss_percentile": 0.96089}, "CVE-2024-50321": {"epss_score": 0.06007, "epss_percentile": 0.90398}, "CVE-2024-50322": {"epss_score": 0.14369, "epss_percentile": 0.94195}, "CVE-2024-50323": {"epss_score": 0.00319, "epss_percentile": 0.54533}, "CVE-2024-50324": {"epss_score": 0.84593, "epss_percentile": 0.99296}, "CVE-2024-50326": {"epss_score": 0.60895, "epss_percentile": 0.98225}, "CVE-2024-50327": {"epss_score": 0.09051, "epss_percentile": 0.9238}, "CVE-2024-50328": {"epss_score": 0.15948, "epss_percentile": 0.94541}, "CVE-2024-50329": {"epss_score": 0.19624, "epss_percentile": 0.95216}, "CVE-2024-50330": {"epss_score": 0.16933, "epss_percentile": 0.94749}, "CVE-2024-50331": {"epss_score": 0.03127, "epss_percentile": 0.86458}, "CVE-2024-50332": {"epss_score": 0.0009, "epss_percentile": 0.25999}, "CVE-2024-50333": {"epss_score": 0.00082, "epss_percentile": 0.24405}, "CVE-2024-50334": {"epss_score": 0.07703, "epss_percentile": 0.91635}, "CVE-2024-50335": {"epss_score": 0.00593, "epss_percentile": 0.68644}, "CVE-2024-50336": {"epss_score": 0.00647, "epss_percentile": 0.70181}, "CVE-2024-50338": {"epss_score": 0.00142, "epss_percentile": 0.35046}, "CVE-2024-50339": {"epss_score": 0.00602, "epss_percentile": 0.68884}, "CVE-2024-50340": {"epss_score": 0.86797, "epss_percentile": 0.99397}, "CVE-2024-50341": {"epss_score": 0.00132, "epss_percentile": 0.33614}, "CVE-2024-50342": {"epss_score": 0.00053, "epss_percentile": 0.16904}, "CVE-2024-50343": {"epss_score": 0.00151, "epss_percentile": 0.36223}, "CVE-2024-50344": {"epss_score": 0.00244, "epss_percentile": 0.47581}, "CVE-2024-50345": {"epss_score": 0.0029, "epss_percentile": 0.52121}, "CVE-2024-50346": {"epss_score": 0.00646, "epss_percentile": 0.70141}, "CVE-2024-50347": {"epss_score": 0.0005, "epss_percentile": 0.15878}, "CVE-2024-50348": {"epss_score": 0.00435, "epss_percentile": 0.62376}, "CVE-2024-50349": {"epss_score": 0.00386, "epss_percentile": 0.59271}, "CVE-2024-50350": {"epss_score": 0.0069, "epss_percentile": 0.71259}, "CVE-2024-50351": {"epss_score": 0.00788, "epss_percentile": 0.73323}, "CVE-2024-50352": {"epss_score": 0.09994, "epss_percentile": 0.92808}, "CVE-2024-50353": {"epss_score": 0.00302, "epss_percentile": 0.53134}, "CVE-2024-50354": {"epss_score": 0.00096, "epss_percentile": 0.27246}, "CVE-2024-50355": {"epss_score": 0.00073, "epss_percentile": 0.22605}, "CVE-2024-50356": {"epss_score": 0.00034, "epss_percentile": 0.09584}, "CVE-2024-50357": {"epss_score": 0.00144, "epss_percentile": 0.35319}, "CVE-2024-50358": {"epss_score": 0.00053, "epss_percentile": 0.16845}, "CVE-2024-50359": {"epss_score": 0.00055, "epss_percentile": 0.17499}, "CVE-2024-50360": {"epss_score": 0.00055, "epss_percentile": 0.17499}, "CVE-2024-50361": {"epss_score": 0.00055, "epss_percentile": 0.17499}, "CVE-2024-50362": {"epss_score": 0.00055, "epss_percentile": 0.17499}, "CVE-2024-50363": {"epss_score": 0.00055, "epss_percentile": 0.17499}, "CVE-2024-50364": {"epss_score": 0.00055, "epss_percentile": 0.17499}, "CVE-2024-50365": {"epss_score": 0.00055, "epss_percentile": 0.17499}, "CVE-2024-50366": {"epss_score": 0.00055, "epss_percentile": 0.17499}, "CVE-2024-50367": {"epss_score": 0.00055, "epss_percentile": 0.17499}, "CVE-2024-50368": {"epss_score": 0.00066, "epss_percentile": 0.20821}, "CVE-2024-50369": {"epss_score": 0.00066, "epss_percentile": 0.20821}, "CVE-2024-50370": {"epss_score": 0.00753, "epss_percentile": 0.72683}, "CVE-2024-50371": {"epss_score": 0.00753, "epss_percentile": 0.72683}, "CVE-2024-50372": {"epss_score": 0.00753, "epss_percentile": 0.72683}, "CVE-2024-50373": {"epss_score": 0.00753, "epss_percentile": 0.72683}, "CVE-2024-50374": {"epss_score": 0.00753, "epss_percentile": 0.72683}, "CVE-2024-50375": {"epss_score": 0.00685, "epss_percentile": 0.71141}, "CVE-2024-50376": {"epss_score": 0.00044, "epss_percentile": 0.13411}, "CVE-2024-50377": {"epss_score": 0.0003, "epss_percentile": 0.0818}, "CVE-2024-50378": {"epss_score": 0.00171, "epss_percentile": 0.38886}, "CVE-2024-50379": {"epss_score": 0.88429, "epss_percentile": 0.99472}, "CVE-2024-50380": {"epss_score": 0.00207, "epss_percentile": 0.43189}, "CVE-2024-50381": {"epss_score": 0.00227, "epss_percentile": 0.45377}, "CVE-2024-50382": {"epss_score": 0.00106, "epss_percentile": 0.29499}, "CVE-2024-50383": {"epss_score": 0.00106, "epss_percentile": 0.29434}, "CVE-2024-50384": {"epss_score": 0.00108, "epss_percentile": 0.29785}, "CVE-2024-50385": {"epss_score": 0.00108, "epss_percentile": 0.29785}, "CVE-2024-50386": {"epss_score": 0.00641, "epss_percentile": 0.69997}, "CVE-2024-50387": {"epss_score": 0.19907, "epss_percentile": 0.95257}, "CVE-2024-50388": {"epss_score": 0.04282, "epss_percentile": 0.88491}, "CVE-2024-50389": {"epss_score": 0.01019, "epss_percentile": 0.7672}, "CVE-2024-50390": {"epss_score": 0.00414, "epss_percentile": 0.61097}, "CVE-2024-50393": {"epss_score": 0.00711, "epss_percentile": 0.71739}, "CVE-2024-50394": {"epss_score": 0.00121, "epss_percentile": 0.31821}, "CVE-2024-50395": {"epss_score": 0.06418, "epss_percentile": 0.90747}, "CVE-2024-50396": {"epss_score": 0.00502, "epss_percentile": 0.6538}, "CVE-2024-50397": {"epss_score": 0.00522, "epss_percentile": 0.66256}, "CVE-2024-50398": {"epss_score": 0.0035, "epss_percentile": 0.56943}, "CVE-2024-50399": {"epss_score": 0.0035, "epss_percentile": 0.56943}, "CVE-2024-50400": {"epss_score": 0.0035, "epss_percentile": 0.56943}, "CVE-2024-50401": {"epss_score": 0.0035, "epss_percentile": 0.56943}, "CVE-2024-50402": {"epss_score": 0.00171, "epss_percentile": 0.38769}, "CVE-2024-50403": {"epss_score": 0.00171, "epss_percentile": 0.38769}, "CVE-2024-50404": {"epss_score": 0.41838, "epss_percentile": 0.97296}, "CVE-2024-50405": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2024-50406": {"epss_score": 0.00064, "epss_percentile": 0.20351}, "CVE-2024-50407": {"epss_score": 0.00294, "epss_percentile": 0.52393}, "CVE-2024-50408": {"epss_score": 0.0087, "epss_percentile": 0.74696}, "CVE-2024-50409": {"epss_score": 0.0016, "epss_percentile": 0.37496}, "CVE-2024-50410": {"epss_score": 0.0016, "epss_percentile": 0.37496}, "CVE-2024-50411": {"epss_score": 0.00163, "epss_percentile": 0.37757}, "CVE-2024-50412": {"epss_score": 0.00166, "epss_percentile": 0.38145}, "CVE-2024-50413": {"epss_score": 0.00158, "epss_percentile": 0.37144}, "CVE-2024-50414": {"epss_score": 0.00158, "epss_percentile": 0.37144}, "CVE-2024-50415": {"epss_score": 0.00122, "epss_percentile": 0.3207}, "CVE-2024-50416": {"epss_score": 0.0053, "epss_percentile": 0.66634}, "CVE-2024-50417": {"epss_score": 0.00331, "epss_percentile": 0.55526}, "CVE-2024-50418": {"epss_score": 0.00175, "epss_percentile": 0.39335}, "CVE-2024-50419": {"epss_score": 0.00337, "epss_percentile": 0.56028}, "CVE-2024-50420": {"epss_score": 0.01232, "epss_percentile": 0.78739}, "CVE-2024-50421": {"epss_score": 0.00071, "epss_percentile": 0.22075}, "CVE-2024-50422": {"epss_score": 0.00072, "epss_percentile": 0.22453}, "CVE-2024-50423": {"epss_score": 0.00043, "epss_percentile": 0.13275}, "CVE-2024-50424": {"epss_score": 0.0015, "epss_percentile": 0.36119}, "CVE-2024-50425": {"epss_score": 0.00375, "epss_percentile": 0.58593}, "CVE-2024-50426": {"epss_score": 0.0018, "epss_percentile": 0.39869}, "CVE-2024-50427": {"epss_score": 0.64562, "epss_percentile": 0.98383}, "CVE-2024-50428": {"epss_score": 0.00231, "epss_percentile": 0.4585}, "CVE-2024-50429": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2024-50430": {"epss_score": 0.0012, "epss_percentile": 0.31701}, "CVE-2024-50431": {"epss_score": 0.00078, "epss_percentile": 0.2376}, "CVE-2024-50432": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2024-50433": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50434": {"epss_score": 0.01819, "epss_percentile": 0.82406}, "CVE-2024-50435": {"epss_score": 0.01819, "epss_percentile": 0.82406}, "CVE-2024-50436": {"epss_score": 0.01819, "epss_percentile": 0.82406}, "CVE-2024-50437": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50438": {"epss_score": 0.00199, "epss_percentile": 0.42097}, "CVE-2024-50439": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50440": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50441": {"epss_score": 0.00185, "epss_percentile": 0.40551}, "CVE-2024-50442": {"epss_score": 0.00133, "epss_percentile": 0.3374}, "CVE-2024-50443": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50445": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50446": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50447": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50448": {"epss_score": 0.00199, "epss_percentile": 0.42097}, "CVE-2024-50449": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50450": {"epss_score": 0.45999, "epss_percentile": 0.97516}, "CVE-2024-50451": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50453": {"epss_score": 0.00801, "epss_percentile": 0.73575}, "CVE-2024-50454": {"epss_score": 0.00175, "epss_percentile": 0.3932}, "CVE-2024-50455": {"epss_score": 0.00278, "epss_percentile": 0.50853}, "CVE-2024-50456": {"epss_score": 0.00207, "epss_percentile": 0.43182}, "CVE-2024-50457": {"epss_score": 0.02333, "epss_percentile": 0.8441}, "CVE-2024-50458": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50459": {"epss_score": 0.00535, "epss_percentile": 0.66839}, "CVE-2024-50460": {"epss_score": 0.00077, "epss_percentile": 0.23379}, "CVE-2024-50461": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50462": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2024-50463": {"epss_score": 0.00129, "epss_percentile": 0.33115}, "CVE-2024-50464": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2024-50465": {"epss_score": 0.00189, "epss_percentile": 0.40998}, "CVE-2024-50466": {"epss_score": 0.002, "epss_percentile": 0.42255}, "CVE-2024-50467": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2024-50468": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2024-50469": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2024-50470": {"epss_score": 0.00112, "epss_percentile": 0.30518}, "CVE-2024-50471": {"epss_score": 0.00112, "epss_percentile": 0.30518}, "CVE-2024-50472": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50473": {"epss_score": 0.55504, "epss_percentile": 0.9798}, "CVE-2024-50475": {"epss_score": 0.26183, "epss_percentile": 0.9612}, "CVE-2024-50476": {"epss_score": 0.19757, "epss_percentile": 0.95238}, "CVE-2024-50477": {"epss_score": 0.82532, "epss_percentile": 0.99199}, "CVE-2024-50478": {"epss_score": 0.34608, "epss_percentile": 0.96861}, "CVE-2024-50479": {"epss_score": 0.00296, "epss_percentile": 0.52534}, "CVE-2024-50480": {"epss_score": 0.00716, "epss_percentile": 0.71865}, "CVE-2024-50481": {"epss_score": 0.00206, "epss_percentile": 0.42944}, "CVE-2024-50482": {"epss_score": 0.49113, "epss_percentile": 0.97668}, "CVE-2024-50483": {"epss_score": 0.58218, "epss_percentile": 0.98103}, "CVE-2024-50484": {"epss_score": 0.01171, "epss_percentile": 0.78222}, "CVE-2024-50485": {"epss_score": 0.17365, "epss_percentile": 0.94834}, "CVE-2024-50486": {"epss_score": 0.00111, "epss_percentile": 0.30369}, "CVE-2024-50487": {"epss_score": 0.00188, "epss_percentile": 0.40862}, "CVE-2024-50488": {"epss_score": 0.32253, "epss_percentile": 0.96682}, "CVE-2024-50489": {"epss_score": 0.00338, "epss_percentile": 0.56127}, "CVE-2024-50490": {"epss_score": 0.45936, "epss_percentile": 0.9751}, "CVE-2024-50491": {"epss_score": 0.25761, "epss_percentile": 0.96066}, "CVE-2024-50492": {"epss_score": 0.43885, "epss_percentile": 0.97406}, "CVE-2024-50493": {"epss_score": 0.49113, "epss_percentile": 0.97668}, "CVE-2024-50494": {"epss_score": 0.00716, "epss_percentile": 0.71858}, "CVE-2024-50495": {"epss_score": 0.0097, "epss_percentile": 0.7611}, "CVE-2024-50496": {"epss_score": 0.0097, "epss_percentile": 0.7611}, "CVE-2024-50497": {"epss_score": 0.01525, "epss_percentile": 0.80854}, "CVE-2024-50498": {"epss_score": 0.91619, "epss_percentile": 0.99659}, "CVE-2024-50500": {"epss_score": 0.00131, "epss_percentile": 0.33496}, "CVE-2024-50501": {"epss_score": 0.00112, "epss_percentile": 0.30518}, "CVE-2024-50502": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-50503": {"epss_score": 0.00028, "epss_percentile": 0.07489}, "CVE-2024-50504": {"epss_score": 0.00256, "epss_percentile": 0.48795}, "CVE-2024-50506": {"epss_score": 0.00188, "epss_percentile": 0.40909}, "CVE-2024-50507": {"epss_score": 0.16046, "epss_percentile": 0.94564}, "CVE-2024-50508": {"epss_score": 0.16377, "epss_percentile": 0.9464}, "CVE-2024-50509": {"epss_score": 0.20374, "epss_percentile": 0.95335}, "CVE-2024-50510": {"epss_score": 0.25476, "epss_percentile": 0.96031}, "CVE-2024-50511": {"epss_score": 0.00656, "epss_percentile": 0.70432}, "CVE-2024-50512": {"epss_score": 0.00398, "epss_percentile": 0.6008}, "CVE-2024-50513": {"epss_score": 0.00099, "epss_percentile": 0.28361}, "CVE-2024-50514": {"epss_score": 0.00097, "epss_percentile": 0.2758}, "CVE-2024-50515": {"epss_score": 0.00097, "epss_percentile": 0.2758}, "CVE-2024-50516": {"epss_score": 0.00099, "epss_percentile": 0.28361}, "CVE-2024-50517": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50518": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50519": {"epss_score": 0.00142, "epss_percentile": 0.35043}, "CVE-2024-50520": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50521": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50522": {"epss_score": 0.00142, "epss_percentile": 0.35043}, "CVE-2024-50523": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2024-50524": {"epss_score": 0.00224, "epss_percentile": 0.45042}, "CVE-2024-50525": {"epss_score": 0.0091, "epss_percentile": 0.7532}, "CVE-2024-50526": {"epss_score": 0.01273, "epss_percentile": 0.79086}, "CVE-2024-50527": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2024-50528": {"epss_score": 0.00618, "epss_percentile": 0.69365}, "CVE-2024-50529": {"epss_score": 0.00656, "epss_percentile": 0.70432}, "CVE-2024-50530": {"epss_score": 0.00656, "epss_percentile": 0.70432}, "CVE-2024-50531": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2024-50532": {"epss_score": 0.00142, "epss_percentile": 0.35043}, "CVE-2024-50533": {"epss_score": 0.00104, "epss_percentile": 0.29165}, "CVE-2024-50534": {"epss_score": 0.00104, "epss_percentile": 0.29165}, "CVE-2024-50535": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50536": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50537": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50538": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50539": {"epss_score": 0.00224, "epss_percentile": 0.45042}, "CVE-2024-50540": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50541": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50542": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-50543": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50544": {"epss_score": 0.00261, "epss_percentile": 0.49249}, "CVE-2024-50545": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50546": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-50547": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50548": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50549": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50550": {"epss_score": 0.00899, "epss_percentile": 0.75157}, "CVE-2024-50551": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50552": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50553": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-50554": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-50556": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-50557": {"epss_score": 0.00747, "epss_percentile": 0.72565}, "CVE-2024-50558": {"epss_score": 0.00119, "epss_percentile": 0.31653}, "CVE-2024-50559": {"epss_score": 0.00145, "epss_percentile": 0.35486}, "CVE-2024-50560": {"epss_score": 0.00373, "epss_percentile": 0.58523}, "CVE-2024-50561": {"epss_score": 0.00612, "epss_percentile": 0.69228}, "CVE-2024-50562": {"epss_score": 0.0026, "epss_percentile": 0.49164}, "CVE-2024-50563": {"epss_score": 0.00309, "epss_percentile": 0.53644}, "CVE-2024-50564": {"epss_score": 0.00058, "epss_percentile": 0.18474}, "CVE-2024-50565": {"epss_score": 0.00061, "epss_percentile": 0.19425}, "CVE-2024-50566": {"epss_score": 0.00644, "epss_percentile": 0.70068}, "CVE-2024-50567": {"epss_score": 0.00412, "epss_percentile": 0.60932}, "CVE-2024-50568": {"epss_score": 0.00013, "epss_percentile": 0.01664}, "CVE-2024-50569": {"epss_score": 0.0031, "epss_percentile": 0.53771}, "CVE-2024-50570": {"epss_score": 0.00014, "epss_percentile": 0.02041}, "CVE-2024-50571": {"epss_score": 0.00087, "epss_percentile": 0.2562}, "CVE-2024-50572": {"epss_score": 0.01051, "epss_percentile": 0.77076}, "CVE-2024-50573": {"epss_score": 4e-05, "epss_percentile": 0.00157}, "CVE-2024-50574": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2024-50575": {"epss_score": 0.05952, "epss_percentile": 0.90357}, "CVE-2024-50576": {"epss_score": 0.17155, "epss_percentile": 0.94785}, "CVE-2024-50577": {"epss_score": 0.12876, "epss_percentile": 0.93809}, "CVE-2024-50578": {"epss_score": 0.17155, "epss_percentile": 0.94785}, "CVE-2024-50579": {"epss_score": 0.05952, "epss_percentile": 0.90357}, "CVE-2024-50580": {"epss_score": 0.18994, "epss_percentile": 0.95109}, "CVE-2024-50581": {"epss_score": 0.17155, "epss_percentile": 0.94785}, "CVE-2024-50582": {"epss_score": 0.17155, "epss_percentile": 0.94785}, "CVE-2024-50583": {"epss_score": 0.001, "epss_percentile": 0.28461}, "CVE-2024-50584": {"epss_score": 0.00061, "epss_percentile": 0.19422}, "CVE-2024-50585": {"epss_score": 0.00123, "epss_percentile": 0.32335}, "CVE-2024-50588": {"epss_score": 0.00211, "epss_percentile": 0.43677}, "CVE-2024-50589": {"epss_score": 0.00275, "epss_percentile": 0.50664}, "CVE-2024-50590": {"epss_score": 0.00066, "epss_percentile": 0.20709}, "CVE-2024-50591": {"epss_score": 0.00315, "epss_percentile": 0.54167}, "CVE-2024-50592": {"epss_score": 0.00097, "epss_percentile": 0.27548}, "CVE-2024-50593": {"epss_score": 0.00087, "epss_percentile": 0.25528}, "CVE-2024-50594": {"epss_score": 0.00108, "epss_percentile": 0.29785}, "CVE-2024-50595": {"epss_score": 0.00108, "epss_percentile": 0.29785}, "CVE-2024-50596": {"epss_score": 0.00108, "epss_percentile": 0.29785}, "CVE-2024-50597": {"epss_score": 0.00108, "epss_percentile": 0.29785}, "CVE-2024-50599": {"epss_score": 0.15317, "epss_percentile": 0.94407}, "CVE-2024-50600": {"epss_score": 0.00205, "epss_percentile": 0.4275}, "CVE-2024-50601": {"epss_score": 0.00122, "epss_percentile": 0.32155}, "CVE-2024-50602": {"epss_score": 0.0013, "epss_percentile": 0.3329}, "CVE-2024-50603": {"epss_score": 0.94352, "epss_percentile": 0.99955}, "CVE-2024-50608": {"epss_score": 0.00483, "epss_percentile": 0.64614}, "CVE-2024-50609": {"epss_score": 0.00483, "epss_percentile": 0.64614}, "CVE-2024-50610": {"epss_score": 0.00039, "epss_percentile": 0.11662}, "CVE-2024-50611": {"epss_score": 0.00092, "epss_percentile": 0.26531}, "CVE-2024-50612": {"epss_score": 0.00021, "epss_percentile": 0.04841}, "CVE-2024-50613": {"epss_score": 0.00025, "epss_percentile": 0.06299}, "CVE-2024-50614": {"epss_score": 0.00063, "epss_percentile": 0.19914}, "CVE-2024-50615": {"epss_score": 0.00063, "epss_percentile": 0.19807}, "CVE-2024-50616": {"epss_score": 0.00126, "epss_percentile": 0.32708}, "CVE-2024-50623": {"epss_score": 0.93914, "epss_percentile": 0.99868}, "CVE-2024-50624": {"epss_score": 0.00025, "epss_percentile": 0.06291}, "CVE-2024-50625": {"epss_score": 0.0007, "epss_percentile": 0.2167}, "CVE-2024-50626": {"epss_score": 0.00105, "epss_percentile": 0.29353}, "CVE-2024-50627": {"epss_score": 0.00148, "epss_percentile": 0.35891}, "CVE-2024-50628": {"epss_score": 0.00184, "epss_percentile": 0.40427}, "CVE-2024-50629": {"epss_score": 0.00122, "epss_percentile": 0.32071}, "CVE-2024-50630": {"epss_score": 0.00687, "epss_percentile": 0.71187}, "CVE-2024-50631": {"epss_score": 0.00442, "epss_percentile": 0.62734}, "CVE-2024-50633": {"epss_score": 0.06448, "epss_percentile": 0.90763}, "CVE-2024-50634": {"epss_score": 0.00152, "epss_percentile": 0.36486}, "CVE-2024-50636": {"epss_score": 0.02777, "epss_percentile": 0.85639}, "CVE-2024-50637": {"epss_score": 0.00591, "epss_percentile": 0.68599}, "CVE-2024-50640": {"epss_score": 0.00117, "epss_percentile": 0.31247}, "CVE-2024-50641": {"epss_score": 0.00117, "epss_percentile": 0.31247}, "CVE-2024-50644": {"epss_score": 0.00156, "epss_percentile": 0.36937}, "CVE-2024-50645": {"epss_score": 0.00156, "epss_percentile": 0.36937}, "CVE-2024-50647": {"epss_score": 0.00062, "epss_percentile": 0.19732}, "CVE-2024-50648": {"epss_score": 0.0106, "epss_percentile": 0.7717}, "CVE-2024-50649": {"epss_score": 0.02057, "epss_percentile": 0.83431}, "CVE-2024-50650": {"epss_score": 0.0045, "epss_percentile": 0.63093}, "CVE-2024-50651": {"epss_score": 0.00226, "epss_percentile": 0.45272}, "CVE-2024-50652": {"epss_score": 0.00087, "epss_percentile": 0.2555}, "CVE-2024-50653": {"epss_score": 0.0011, "epss_percentile": 0.30145}, "CVE-2024-50654": {"epss_score": 0.00205, "epss_percentile": 0.42723}, "CVE-2024-50655": {"epss_score": 0.00323, "epss_percentile": 0.5487}, "CVE-2024-50656": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-50657": {"epss_score": 0.02386, "epss_percentile": 0.8458}, "CVE-2024-50658": {"epss_score": 0.01216, "epss_percentile": 0.78593}, "CVE-2024-50659": {"epss_score": 0.00083, "epss_percentile": 0.24783}, "CVE-2024-50660": {"epss_score": 0.01374, "epss_percentile": 0.79824}, "CVE-2024-50664": {"epss_score": 0.00029, "epss_percentile": 0.07611}, "CVE-2024-50665": {"epss_score": 0.00027, "epss_percentile": 0.06941}, "CVE-2024-50667": {"epss_score": 0.00593, "epss_percentile": 0.68636}, "CVE-2024-50671": {"epss_score": 0.00057, "epss_percentile": 0.18085}, "CVE-2024-50672": {"epss_score": 0.00091, "epss_percentile": 0.26278}, "CVE-2024-50677": {"epss_score": 0.01185, "epss_percentile": 0.78338}, "CVE-2024-50684": {"epss_score": 0.00108, "epss_percentile": 0.2978}, "CVE-2024-50685": {"epss_score": 0.00116, "epss_percentile": 0.31092}, "CVE-2024-50686": {"epss_score": 0.00116, "epss_percentile": 0.31092}, "CVE-2024-50687": {"epss_score": 0.00116, "epss_percentile": 0.31092}, "CVE-2024-50688": {"epss_score": 0.00156, "epss_percentile": 0.3699}, "CVE-2024-50689": {"epss_score": 0.00116, "epss_percentile": 0.31092}, "CVE-2024-50690": {"epss_score": 0.00098, "epss_percentile": 0.27764}, "CVE-2024-50691": {"epss_score": 0.00046, "epss_percentile": 0.14456}, "CVE-2024-50692": {"epss_score": 0.00063, "epss_percentile": 0.19859}, "CVE-2024-50693": {"epss_score": 0.00116, "epss_percentile": 0.31092}, "CVE-2024-50694": {"epss_score": 0.00197, "epss_percentile": 0.4183}, "CVE-2024-50695": {"epss_score": 0.00254, "epss_percentile": 0.48533}, "CVE-2024-50696": {"epss_score": 0.0006, "epss_percentile": 0.18983}, "CVE-2024-50697": {"epss_score": 0.00148, "epss_percentile": 0.35861}, "CVE-2024-50698": {"epss_score": 0.00225, "epss_percentile": 0.45091}, "CVE-2024-50699": {"epss_score": 0.00065, "epss_percentile": 0.20637}, "CVE-2024-50701": {"epss_score": 0.00113, "epss_percentile": 0.3068}, "CVE-2024-50702": {"epss_score": 0.00126, "epss_percentile": 0.32624}, "CVE-2024-50703": {"epss_score": 0.00189, "epss_percentile": 0.40986}, "CVE-2024-50704": {"epss_score": 0.00326, "epss_percentile": 0.55036}, "CVE-2024-50705": {"epss_score": 0.00045, "epss_percentile": 0.1372}, "CVE-2024-50706": {"epss_score": 0.00176, "epss_percentile": 0.39459}, "CVE-2024-50707": {"epss_score": 0.00815, "epss_percentile": 0.73792}, "CVE-2024-50713": {"epss_score": 0.00139, "epss_percentile": 0.3461}, "CVE-2024-50714": {"epss_score": 0.00119, "epss_percentile": 0.31615}, "CVE-2024-50715": {"epss_score": 0.02106, "epss_percentile": 0.83631}, "CVE-2024-50716": {"epss_score": 0.00799, "epss_percentile": 0.73526}, "CVE-2024-50717": {"epss_score": 0.01082, "epss_percentile": 0.77386}, "CVE-2024-50724": {"epss_score": 0.00163, "epss_percentile": 0.37777}, "CVE-2024-50766": {"epss_score": 0.00374, "epss_percentile": 0.5854}, "CVE-2024-50800": {"epss_score": 0.00183, "epss_percentile": 0.40281}, "CVE-2024-50801": {"epss_score": 0.00058, "epss_percentile": 0.18602}, "CVE-2024-50802": {"epss_score": 0.00058, "epss_percentile": 0.18602}, "CVE-2024-50803": {"epss_score": 0.00752, "epss_percentile": 0.72665}, "CVE-2024-50804": {"epss_score": 0.02817, "epss_percentile": 0.85736}, "CVE-2024-50807": {"epss_score": 0.00078, "epss_percentile": 0.23569}, "CVE-2024-50808": {"epss_score": 0.00217, "epss_percentile": 0.44328}, "CVE-2024-50809": {"epss_score": 0.00238, "epss_percentile": 0.46831}, "CVE-2024-50810": {"epss_score": 0.00316, "epss_percentile": 0.54236}, "CVE-2024-50811": {"epss_score": 0.00307, "epss_percentile": 0.53563}, "CVE-2024-50823": {"epss_score": 0.00099, "epss_percentile": 0.28368}, "CVE-2024-50824": {"epss_score": 0.00092, "epss_percentile": 0.26443}, "CVE-2024-50825": {"epss_score": 0.00106, "epss_percentile": 0.29433}, "CVE-2024-50826": {"epss_score": 0.00106, "epss_percentile": 0.29433}, "CVE-2024-50827": {"epss_score": 0.00144, "epss_percentile": 0.35245}, "CVE-2024-50828": {"epss_score": 0.00144, "epss_percentile": 0.35245}, "CVE-2024-50829": {"epss_score": 0.00106, "epss_percentile": 0.29433}, "CVE-2024-50830": {"epss_score": 0.00106, "epss_percentile": 0.29433}, "CVE-2024-50831": {"epss_score": 0.00151, "epss_percentile": 0.3629}, "CVE-2024-50832": {"epss_score": 0.00067, "epss_percentile": 0.21183}, "CVE-2024-50833": {"epss_score": 0.00073, "epss_percentile": 0.22564}, "CVE-2024-50834": {"epss_score": 0.0006, "epss_percentile": 0.19156}, "CVE-2024-50835": {"epss_score": 0.00043, "epss_percentile": 0.13013}, "CVE-2024-50836": {"epss_score": 0.00093, "epss_percentile": 0.26734}, "CVE-2024-50837": {"epss_score": 0.00143, "epss_percentile": 0.35093}, "CVE-2024-50838": {"epss_score": 0.0024, "epss_percentile": 0.46954}, "CVE-2024-50839": {"epss_score": 0.00393, "epss_percentile": 0.59719}, "CVE-2024-50840": {"epss_score": 0.01351, "epss_percentile": 0.79677}, "CVE-2024-50841": {"epss_score": 0.00357, "epss_percentile": 0.5748}, "CVE-2024-50842": {"epss_score": 0.00467, "epss_percentile": 0.63844}, "CVE-2024-50843": {"epss_score": 0.0038, "epss_percentile": 0.58947}, "CVE-2024-50848": {"epss_score": 0.09103, "epss_percentile": 0.92401}, "CVE-2024-50849": {"epss_score": 0.00534, "epss_percentile": 0.66778}, "CVE-2024-50852": {"epss_score": 0.03944, "epss_percentile": 0.87992}, "CVE-2024-50853": {"epss_score": 0.03944, "epss_percentile": 0.87992}, "CVE-2024-50854": {"epss_score": 0.0033, "epss_percentile": 0.55485}, "CVE-2024-50857": {"epss_score": 0.00074, "epss_percentile": 0.22812}, "CVE-2024-50858": {"epss_score": 0.00137, "epss_percentile": 0.3432}, "CVE-2024-50859": {"epss_score": 0.00373, "epss_percentile": 0.58467}, "CVE-2024-50861": {"epss_score": 0.00394, "epss_percentile": 0.59752}, "CVE-2024-50919": {"epss_score": 0.00309, "epss_percentile": 0.5372}, "CVE-2024-50920": {"epss_score": 0.00029, "epss_percentile": 0.07971}, "CVE-2024-50921": {"epss_score": 0.0003, "epss_percentile": 0.08296}, "CVE-2024-50924": {"epss_score": 0.00029, "epss_percentile": 0.07691}, "CVE-2024-50928": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2024-50929": {"epss_score": 0.00034, "epss_percentile": 0.0957}, "CVE-2024-50930": {"epss_score": 0.00064, "epss_percentile": 0.20103}, "CVE-2024-50931": {"epss_score": 0.00054, "epss_percentile": 0.17102}, "CVE-2024-50942": {"epss_score": 0.0008, "epss_percentile": 0.24173}, "CVE-2024-50944": {"epss_score": 0.01628, "epss_percentile": 0.81437}, "CVE-2024-50945": {"epss_score": 0.01999, "epss_percentile": 0.83211}, "CVE-2024-50947": {"epss_score": 0.00196, "epss_percentile": 0.41787}, "CVE-2024-50948": {"epss_score": 0.00213, "epss_percentile": 0.43852}, "CVE-2024-50953": {"epss_score": 0.00196, "epss_percentile": 0.41787}, "CVE-2024-50954": {"epss_score": 0.003, "epss_percentile": 0.52991}, "CVE-2024-50955": {"epss_score": 0.00045, "epss_percentile": 0.13759}, "CVE-2024-50956": {"epss_score": 0.00131, "epss_percentile": 0.33372}, "CVE-2024-50960": {"epss_score": 0.01283, "epss_percentile": 0.79164}, "CVE-2024-50965": {"epss_score": 0.00074, "epss_percentile": 0.22732}, "CVE-2024-50966": {"epss_score": 0.00302, "epss_percentile": 0.53125}, "CVE-2024-50967": {"epss_score": 0.37152, "epss_percentile": 0.97023}, "CVE-2024-50968": {"epss_score": 0.0886, "epss_percentile": 0.92288}, "CVE-2024-50969": {"epss_score": 0.00518, "epss_percentile": 0.66135}, "CVE-2024-50970": {"epss_score": 0.00226, "epss_percentile": 0.45269}, "CVE-2024-50971": {"epss_score": 0.03585, "epss_percentile": 0.87392}, "CVE-2024-50972": {"epss_score": 0.03585, "epss_percentile": 0.87392}, "CVE-2024-50983": {"epss_score": 0.00157, "epss_percentile": 0.37065}, "CVE-2024-50986": {"epss_score": 0.08295, "epss_percentile": 0.91975}, "CVE-2024-50989": {"epss_score": 0.00117, "epss_percentile": 0.31291}, "CVE-2024-50990": {"epss_score": 0.00258, "epss_percentile": 0.4899}, "CVE-2024-50991": {"epss_score": 0.00132, "epss_percentile": 0.336}, "CVE-2024-50993": {"epss_score": 0.00785, "epss_percentile": 0.73256}, "CVE-2024-50994": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-50995": {"epss_score": 0.00238, "epss_percentile": 0.46808}, "CVE-2024-50996": {"epss_score": 0.00238, "epss_percentile": 0.46808}, "CVE-2024-50997": {"epss_score": 0.00238, "epss_percentile": 0.46808}, "CVE-2024-50998": {"epss_score": 0.00238, "epss_percentile": 0.46808}, "CVE-2024-50999": {"epss_score": 0.00349, "epss_percentile": 0.56901}, "CVE-2024-51000": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51001": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51002": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51003": {"epss_score": 0.00238, "epss_percentile": 0.46808}, "CVE-2024-51004": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51005": {"epss_score": 0.00524, "epss_percentile": 0.66335}, "CVE-2024-51006": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51007": {"epss_score": 0.00238, "epss_percentile": 0.46808}, "CVE-2024-51008": {"epss_score": 0.00524, "epss_percentile": 0.66335}, "CVE-2024-51009": {"epss_score": 0.00785, "epss_percentile": 0.73256}, "CVE-2024-51010": {"epss_score": 0.00524, "epss_percentile": 0.66335}, "CVE-2024-51011": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51012": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51013": {"epss_score": 0.00238, "epss_percentile": 0.46808}, "CVE-2024-51014": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51015": {"epss_score": 0.00322, "epss_percentile": 0.54783}, "CVE-2024-51016": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51017": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51018": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51019": {"epss_score": 0.00238, "epss_percentile": 0.46808}, "CVE-2024-51020": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51021": {"epss_score": 0.00314, "epss_percentile": 0.54123}, "CVE-2024-51022": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-51023": {"epss_score": 0.00059, "epss_percentile": 0.1875}, "CVE-2024-51024": {"epss_score": 0.00071, "epss_percentile": 0.22128}, "CVE-2024-51026": {"epss_score": 0.0073, "epss_percentile": 0.72155}, "CVE-2024-51027": {"epss_score": 0.00197, "epss_percentile": 0.41899}, "CVE-2024-51030": {"epss_score": 0.05778, "epss_percentile": 0.90198}, "CVE-2024-51031": {"epss_score": 0.00731, "epss_percentile": 0.72169}, "CVE-2024-51032": {"epss_score": 0.00731, "epss_percentile": 0.72169}, "CVE-2024-51037": {"epss_score": 0.00298, "epss_percentile": 0.52791}, "CVE-2024-51051": {"epss_score": 0.00187, "epss_percentile": 0.40795}, "CVE-2024-51053": {"epss_score": 0.00244, "epss_percentile": 0.47579}, "CVE-2024-51054": {"epss_score": 0.00137, "epss_percentile": 0.34341}, "CVE-2024-51055": {"epss_score": 0.01003, "epss_percentile": 0.76517}, "CVE-2024-51058": {"epss_score": 0.0003, "epss_percentile": 0.08265}, "CVE-2024-51060": {"epss_score": 0.00086, "epss_percentile": 0.2528}, "CVE-2024-51063": {"epss_score": 0.00124, "epss_percentile": 0.32346}, "CVE-2024-51064": {"epss_score": 0.00129, "epss_percentile": 0.33188}, "CVE-2024-51065": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2024-51066": {"epss_score": 0.00167, "epss_percentile": 0.38387}, "CVE-2024-51072": {"epss_score": 0.00028, "epss_percentile": 0.07244}, "CVE-2024-51073": {"epss_score": 0.0004, "epss_percentile": 0.12147}, "CVE-2024-51074": {"epss_score": 0.00056, "epss_percentile": 0.17759}, "CVE-2024-51075": {"epss_score": 0.00383, "epss_percentile": 0.59095}, "CVE-2024-51076": {"epss_score": 0.00383, "epss_percentile": 0.59095}, "CVE-2024-51091": {"epss_score": 0.00038, "epss_percentile": 0.11422}, "CVE-2024-51093": {"epss_score": 0.00226, "epss_percentile": 0.45282}, "CVE-2024-51094": {"epss_score": 0.0037, "epss_percentile": 0.58279}, "CVE-2024-51099": {"epss_score": 0.00059, "epss_percentile": 0.18916}, "CVE-2024-51101": {"epss_score": 0.00056, "epss_percentile": 0.17755}, "CVE-2024-51102": {"epss_score": 0.00023, "epss_percentile": 0.05353}, "CVE-2024-51103": {"epss_score": 0.00041, "epss_percentile": 0.12372}, "CVE-2024-51106": {"epss_score": 0.00017, "epss_percentile": 0.03401}, "CVE-2024-51107": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-51108": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2024-51111": {"epss_score": 0.00117, "epss_percentile": 0.31279}, "CVE-2024-51112": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-51114": {"epss_score": 0.00348, "epss_percentile": 0.56812}, "CVE-2024-51115": {"epss_score": 0.03318, "epss_percentile": 0.86905}, "CVE-2024-51116": {"epss_score": 0.00165, "epss_percentile": 0.38035}, "CVE-2024-51122": {"epss_score": 0.00117, "epss_percentile": 0.31294}, "CVE-2024-51123": {"epss_score": 0.00116, "epss_percentile": 0.31141}, "CVE-2024-51127": {"epss_score": 0.00781, "epss_percentile": 0.73185}, "CVE-2024-51132": {"epss_score": 0.06005, "epss_percentile": 0.90395}, "CVE-2024-51135": {"epss_score": 0.00667, "epss_percentile": 0.70712}, "CVE-2024-51136": {"epss_score": 0.0098, "epss_percentile": 0.76271}, "CVE-2024-51138": {"epss_score": 0.00934, "epss_percentile": 0.75652}, "CVE-2024-51139": {"epss_score": 0.00725, "epss_percentile": 0.72049}, "CVE-2024-51141": {"epss_score": 0.00127, "epss_percentile": 0.32836}, "CVE-2024-51142": {"epss_score": 0.00373, "epss_percentile": 0.58512}, "CVE-2024-51144": {"epss_score": 0.01174, "epss_percentile": 0.7825}, "CVE-2024-51151": {"epss_score": 0.39086, "epss_percentile": 0.97137}, "CVE-2024-51152": {"epss_score": 0.01926, "epss_percentile": 0.82926}, "CVE-2024-51156": {"epss_score": 0.00301, "epss_percentile": 0.53072}, "CVE-2024-51157": {"epss_score": 0.00208, "epss_percentile": 0.43241}, "CVE-2024-51162": {"epss_score": 0.01653, "epss_percentile": 0.81581}, "CVE-2024-51163": {"epss_score": 0.00112, "epss_percentile": 0.30488}, "CVE-2024-51164": {"epss_score": 0.01166, "epss_percentile": 0.78179}, "CVE-2024-51165": {"epss_score": 0.00167, "epss_percentile": 0.38396}, "CVE-2024-51175": {"epss_score": 0.00073, "epss_percentile": 0.22597}, "CVE-2024-51179": {"epss_score": 0.13328, "epss_percentile": 0.93934}, "CVE-2024-51180": {"epss_score": 0.0027, "epss_percentile": 0.50199}, "CVE-2024-51181": {"epss_score": 0.0027, "epss_percentile": 0.50199}, "CVE-2024-51182": {"epss_score": 0.0009, "epss_percentile": 0.26012}, "CVE-2024-51186": {"epss_score": 0.00959, "epss_percentile": 0.7595}, "CVE-2024-51187": {"epss_score": 0.00084, "epss_percentile": 0.24903}, "CVE-2024-51188": {"epss_score": 0.0008, "epss_percentile": 0.24081}, "CVE-2024-51189": {"epss_score": 0.0008, "epss_percentile": 0.24081}, "CVE-2024-51190": {"epss_score": 0.0008, "epss_percentile": 0.24081}, "CVE-2024-51208": {"epss_score": 0.00097, "epss_percentile": 0.27616}, "CVE-2024-51209": {"epss_score": 0.00114, "epss_percentile": 0.30853}, "CVE-2024-51210": {"epss_score": 0.00143, "epss_percentile": 0.35212}, "CVE-2024-51211": {"epss_score": 0.03031, "epss_percentile": 0.86248}, "CVE-2024-51213": {"epss_score": 0.00321, "epss_percentile": 0.54688}, "CVE-2024-51228": {"epss_score": 0.55156, "epss_percentile": 0.97963}, "CVE-2024-51229": {"epss_score": 0.01734, "epss_percentile": 0.82004}, "CVE-2024-51240": {"epss_score": 0.00046, "epss_percentile": 0.14303}, "CVE-2024-51242": {"epss_score": 0.00161, "epss_percentile": 0.37578}, "CVE-2024-51243": {"epss_score": 0.05623, "epss_percentile": 0.90063}, "CVE-2024-51244": {"epss_score": 0.00194, "epss_percentile": 0.41531}, "CVE-2024-51245": {"epss_score": 0.00194, "epss_percentile": 0.41531}, "CVE-2024-51246": {"epss_score": 0.00061, "epss_percentile": 0.19317}, "CVE-2024-51247": {"epss_score": 0.00194, "epss_percentile": 0.41531}, "CVE-2024-51248": {"epss_score": 0.00194, "epss_percentile": 0.41531}, "CVE-2024-51249": {"epss_score": 0.00061, "epss_percentile": 0.19317}, "CVE-2024-51251": {"epss_score": 0.00061, "epss_percentile": 0.19317}, "CVE-2024-51252": {"epss_score": 0.00277, "epss_percentile": 0.50778}, "CVE-2024-51253": {"epss_score": 0.00061, "epss_percentile": 0.19317}, "CVE-2024-51254": {"epss_score": 0.00094, "epss_percentile": 0.27028}, "CVE-2024-51255": {"epss_score": 0.00204, "epss_percentile": 0.42623}, "CVE-2024-51257": {"epss_score": 0.0015, "epss_percentile": 0.36128}, "CVE-2024-51258": {"epss_score": 0.00237, "epss_percentile": 0.46732}, "CVE-2024-51259": {"epss_score": 0.0015, "epss_percentile": 0.36113}, "CVE-2024-51260": {"epss_score": 0.00237, "epss_percentile": 0.46719}, "CVE-2024-51296": {"epss_score": 0.00175, "epss_percentile": 0.39282}, "CVE-2024-51298": {"epss_score": 0.00175, "epss_percentile": 0.39267}, "CVE-2024-51299": {"epss_score": 0.00175, "epss_percentile": 0.39282}, "CVE-2024-51300": {"epss_score": 0.00175, "epss_percentile": 0.39282}, "CVE-2024-51301": {"epss_score": 0.00175, "epss_percentile": 0.39282}, "CVE-2024-51304": {"epss_score": 0.00237, "epss_percentile": 0.46732}, "CVE-2024-51317": {"epss_score": 0.00163, "epss_percentile": 0.37778}, "CVE-2024-51319": {"epss_score": 0.00323, "epss_percentile": 0.54889}, "CVE-2024-51320": {"epss_score": 0.00187, "epss_percentile": 0.40798}, "CVE-2024-51321": {"epss_score": 0.00103, "epss_percentile": 0.28933}, "CVE-2024-51322": {"epss_score": 0.00187, "epss_percentile": 0.40798}, "CVE-2024-51324": {"epss_score": 0.0004, "epss_percentile": 0.12074}, "CVE-2024-51326": {"epss_score": 0.00368, "epss_percentile": 0.58175}, "CVE-2024-51327": {"epss_score": 0.0003, "epss_percentile": 0.08213}, "CVE-2024-51328": {"epss_score": 0.00171, "epss_percentile": 0.38817}, "CVE-2024-51329": {"epss_score": 0.00159, "epss_percentile": 0.37412}, "CVE-2024-51330": {"epss_score": 0.00134, "epss_percentile": 0.33893}, "CVE-2024-51337": {"epss_score": 0.00297, "epss_percentile": 0.52687}, "CVE-2024-51358": {"epss_score": 0.3231, "epss_percentile": 0.96688}, "CVE-2024-51360": {"epss_score": 0.01122, "epss_percentile": 0.77777}, "CVE-2024-51362": {"epss_score": 0.00038, "epss_percentile": 0.11201}, "CVE-2024-51363": {"epss_score": 0.00462, "epss_percentile": 0.63619}, "CVE-2024-51364": {"epss_score": 0.00258, "epss_percentile": 0.49007}, "CVE-2024-51366": {"epss_score": 0.00203, "epss_percentile": 0.42491}, "CVE-2024-51367": {"epss_score": 0.00209, "epss_percentile": 0.43315}, "CVE-2024-51376": {"epss_score": 0.00589, "epss_percentile": 0.68514}, "CVE-2024-51377": {"epss_score": 0.00255, "epss_percentile": 0.48626}, "CVE-2024-51378": {"epss_score": 0.93851, "epss_percentile": 0.99858}, "CVE-2024-51379": {"epss_score": 0.00101, "epss_percentile": 0.28593}, "CVE-2024-51380": {"epss_score": 0.001, "epss_percentile": 0.28478}, "CVE-2024-51381": {"epss_score": 0.00074, "epss_percentile": 0.22743}, "CVE-2024-51382": {"epss_score": 0.00074, "epss_percentile": 0.22743}, "CVE-2024-51392": {"epss_score": 0.00159, "epss_percentile": 0.37363}, "CVE-2024-51398": {"epss_score": 0.00091, "epss_percentile": 0.2628}, "CVE-2024-51399": {"epss_score": 0.0009, "epss_percentile": 0.26133}, "CVE-2024-51406": {"epss_score": 0.00041, "epss_percentile": 0.12264}, "CVE-2024-51407": {"epss_score": 0.00043, "epss_percentile": 0.13223}, "CVE-2024-51408": {"epss_score": 0.0015, "epss_percentile": 0.3618}, "CVE-2024-51409": {"epss_score": 0.01349, "epss_percentile": 0.79668}, "CVE-2024-51417": {"epss_score": 0.00119, "epss_percentile": 0.3162}, "CVE-2024-51419": {"epss_score": 0.00628, "epss_percentile": 0.69658}, "CVE-2024-51423": {"epss_score": 0.00128, "epss_percentile": 0.33008}, "CVE-2024-51424": {"epss_score": 0.01695, "epss_percentile": 0.81805}, "CVE-2024-51425": {"epss_score": 0.01257, "epss_percentile": 0.78946}, "CVE-2024-51426": {"epss_score": 0.01257, "epss_percentile": 0.78946}, "CVE-2024-51427": {"epss_score": 0.01615, "epss_percentile": 0.81348}, "CVE-2024-51428": {"epss_score": 0.00072, "epss_percentile": 0.22375}, "CVE-2024-51430": {"epss_score": 0.03056, "epss_percentile": 0.86301}, "CVE-2024-51431": {"epss_score": 0.00176, "epss_percentile": 0.39375}, "CVE-2024-51432": {"epss_score": 0.00134, "epss_percentile": 0.33746}, "CVE-2024-51434": {"epss_score": 0.00349, "epss_percentile": 0.56913}, "CVE-2024-51440": {"epss_score": 0.00025, "epss_percentile": 0.06204}, "CVE-2024-51442": {"epss_score": 0.32184, "epss_percentile": 0.96676}, "CVE-2024-51444": {"epss_score": 0.00082, "epss_percentile": 0.24412}, "CVE-2024-51445": {"epss_score": 0.00046, "epss_percentile": 0.14432}, "CVE-2024-51446": {"epss_score": 0.00027, "epss_percentile": 0.06984}, "CVE-2024-51447": {"epss_score": 0.00045, "epss_percentile": 0.13985}, "CVE-2024-51448": {"epss_score": 0.00015, "epss_percentile": 0.02231}, "CVE-2024-51450": {"epss_score": 0.002, "epss_percentile": 0.42225}, "CVE-2024-51453": {"epss_score": 0.00054, "epss_percentile": 0.17084}, "CVE-2024-51456": {"epss_score": 0.00046, "epss_percentile": 0.14175}, "CVE-2024-51457": {"epss_score": 0.00055, "epss_percentile": 0.17485}, "CVE-2024-51459": {"epss_score": 0.00014, "epss_percentile": 0.02119}, "CVE-2024-51460": {"epss_score": 0.00112, "epss_percentile": 0.30418}, "CVE-2024-51461": {"epss_score": 0.0008, "epss_percentile": 0.24078}, "CVE-2024-51462": {"epss_score": 0.00062, "epss_percentile": 0.19655}, "CVE-2024-51463": {"epss_score": 0.00652, "epss_percentile": 0.70308}, "CVE-2024-51464": {"epss_score": 0.00893, "epss_percentile": 0.75078}, "CVE-2024-51465": {"epss_score": 0.00253, "epss_percentile": 0.48427}, "CVE-2024-51466": {"epss_score": 0.00197, "epss_percentile": 0.41825}, "CVE-2024-51470": {"epss_score": 0.00115, "epss_percentile": 0.30921}, "CVE-2024-51471": {"epss_score": 0.00078, "epss_percentile": 0.23675}, "CVE-2024-51472": {"epss_score": 0.00106, "epss_percentile": 0.29501}, "CVE-2024-51473": {"epss_score": 0.0007, "epss_percentile": 0.21837}, "CVE-2024-51475": {"epss_score": 0.00024, "epss_percentile": 0.05676}, "CVE-2024-51476": {"epss_score": 0.00093, "epss_percentile": 0.26698}, "CVE-2024-51477": {"epss_score": 0.00063, "epss_percentile": 0.19894}, "CVE-2024-51478": {"epss_score": 0.00115, "epss_percentile": 0.31018}, "CVE-2024-51479": {"epss_score": 0.80348, "epss_percentile": 0.99082}, "CVE-2024-51480": {"epss_score": 0.00055, "epss_percentile": 0.17546}, "CVE-2024-51481": {"epss_score": 0.00058, "epss_percentile": 0.18401}, "CVE-2024-51482": {"epss_score": 0.5703, "epss_percentile": 0.98046}, "CVE-2024-51483": {"epss_score": 0.32774, "epss_percentile": 0.96723}, "CVE-2024-51484": {"epss_score": 0.00181, "epss_percentile": 0.4006}, "CVE-2024-51485": {"epss_score": 0.00181, "epss_percentile": 0.4006}, "CVE-2024-51486": {"epss_score": 0.00089, "epss_percentile": 0.25958}, "CVE-2024-51487": {"epss_score": 0.00181, "epss_percentile": 0.4006}, "CVE-2024-51488": {"epss_score": 0.00111, "epss_percentile": 0.30308}, "CVE-2024-51489": {"epss_score": 0.00193, "epss_percentile": 0.41388}, "CVE-2024-51490": {"epss_score": 0.00146, "epss_percentile": 0.35614}, "CVE-2024-51491": {"epss_score": 0.00028, "epss_percentile": 0.07285}, "CVE-2024-51492": {"epss_score": 0.00233, "epss_percentile": 0.46057}, "CVE-2024-51493": {"epss_score": 0.00075, "epss_percentile": 0.23073}, "CVE-2024-51494": {"epss_score": 0.00635, "epss_percentile": 0.69822}, "CVE-2024-51495": {"epss_score": 0.00667, "epss_percentile": 0.70714}, "CVE-2024-51496": {"epss_score": 0.0084, "epss_percentile": 0.74205}, "CVE-2024-51497": {"epss_score": 0.00667, "epss_percentile": 0.70714}, "CVE-2024-51498": {"epss_score": 0.00166, "epss_percentile": 0.38201}, "CVE-2024-51499": {"epss_score": 0.01677, "epss_percentile": 0.81715}, "CVE-2024-51500": {"epss_score": 0.0009, "epss_percentile": 0.26008}, "CVE-2024-51501": {"epss_score": 0.00105, "epss_percentile": 0.29281}, "CVE-2024-51502": {"epss_score": 0.00224, "epss_percentile": 0.45012}, "CVE-2024-51503": {"epss_score": 0.00749, "epss_percentile": 0.72597}, "CVE-2024-51504": {"epss_score": 0.00044, "epss_percentile": 0.13395}, "CVE-2024-51505": {"epss_score": 0.00126, "epss_percentile": 0.32668}, "CVE-2024-51506": {"epss_score": 0.00106, "epss_percentile": 0.29437}, "CVE-2024-51507": {"epss_score": 0.00101, "epss_percentile": 0.28585}, "CVE-2024-51508": {"epss_score": 0.00144, "epss_percentile": 0.35251}, "CVE-2024-51509": {"epss_score": 0.00144, "epss_percentile": 0.35251}, "CVE-2024-51510": {"epss_score": 0.00046, "epss_percentile": 0.14129}, "CVE-2024-51511": {"epss_score": 0.00063, "epss_percentile": 0.20094}, "CVE-2024-51512": {"epss_score": 0.00063, "epss_percentile": 0.20094}, "CVE-2024-51513": {"epss_score": 0.00052, "epss_percentile": 0.16365}, "CVE-2024-51514": {"epss_score": 0.00027, "epss_percentile": 0.0683}, "CVE-2024-51515": {"epss_score": 0.00046, "epss_percentile": 0.14295}, "CVE-2024-51516": {"epss_score": 0.00056, "epss_percentile": 0.17833}, "CVE-2024-51517": {"epss_score": 0.00057, "epss_percentile": 0.18044}, "CVE-2024-51518": {"epss_score": 0.00096, "epss_percentile": 0.27339}, "CVE-2024-51519": {"epss_score": 0.00071, "epss_percentile": 0.22129}, "CVE-2024-51520": {"epss_score": 0.00063, "epss_percentile": 0.20094}, "CVE-2024-51521": {"epss_score": 0.00042, "epss_percentile": 0.12633}, "CVE-2024-51522": {"epss_score": 0.0006, "epss_percentile": 0.19222}, "CVE-2024-51523": {"epss_score": 0.0014, "epss_percentile": 0.34774}, "CVE-2024-51524": {"epss_score": 0.0006, "epss_percentile": 0.19224}, "CVE-2024-51525": {"epss_score": 0.00057, "epss_percentile": 0.18057}, "CVE-2024-51526": {"epss_score": 0.00017, "epss_percentile": 0.03441}, "CVE-2024-51527": {"epss_score": 0.00061, "epss_percentile": 0.19328}, "CVE-2024-51528": {"epss_score": 0.00058, "epss_percentile": 0.18417}, "CVE-2024-51529": {"epss_score": 0.00059, "epss_percentile": 0.18913}, "CVE-2024-51530": {"epss_score": 0.00045, "epss_percentile": 0.13825}, "CVE-2024-51532": {"epss_score": 0.0014, "epss_percentile": 0.34796}, "CVE-2024-51534": {"epss_score": 0.00055, "epss_percentile": 0.1756}, "CVE-2024-51539": {"epss_score": 0.00077, "epss_percentile": 0.23534}, "CVE-2024-51540": {"epss_score": 0.00154, "epss_percentile": 0.36723}, "CVE-2024-51541": {"epss_score": 0.00166, "epss_percentile": 0.38198}, "CVE-2024-51542": {"epss_score": 0.00178, "epss_percentile": 0.3966}, "CVE-2024-51543": {"epss_score": 0.00178, "epss_percentile": 0.3966}, "CVE-2024-51544": {"epss_score": 0.00222, "epss_percentile": 0.44728}, "CVE-2024-51545": {"epss_score": 0.00234, "epss_percentile": 0.46163}, "CVE-2024-51546": {"epss_score": 0.03091, "epss_percentile": 0.86396}, "CVE-2024-51547": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-51548": {"epss_score": 0.0024, "epss_percentile": 0.47207}, "CVE-2024-51549": {"epss_score": 0.00333, "epss_percentile": 0.55623}, "CVE-2024-51550": {"epss_score": 0.02389, "epss_percentile": 0.84593}, "CVE-2024-51551": {"epss_score": 0.00234, "epss_percentile": 0.46163}, "CVE-2024-51552": {"epss_score": 0.00054, "epss_percentile": 0.17212}, "CVE-2024-51553": {"epss_score": 0.00044, "epss_percentile": 0.13657}, "CVE-2024-51554": {"epss_score": 0.00293, "epss_percentile": 0.52289}, "CVE-2024-51555": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-51556": {"epss_score": 0.00083, "epss_percentile": 0.2461}, "CVE-2024-51557": {"epss_score": 0.01232, "epss_percentile": 0.7874}, "CVE-2024-51558": {"epss_score": 0.01174, "epss_percentile": 0.78249}, "CVE-2024-51559": {"epss_score": 0.00394, "epss_percentile": 0.59789}, "CVE-2024-51560": {"epss_score": 0.00188, "epss_percentile": 0.40864}, "CVE-2024-51561": {"epss_score": 0.00075, "epss_percentile": 0.22927}, "CVE-2024-51562": {"epss_score": 0.00083, "epss_percentile": 0.2464}, "CVE-2024-51563": {"epss_score": 0.00064, "epss_percentile": 0.20315}, "CVE-2024-51564": {"epss_score": 0.00166, "epss_percentile": 0.3823}, "CVE-2024-51565": {"epss_score": 0.00083, "epss_percentile": 0.2464}, "CVE-2024-51566": {"epss_score": 0.00083, "epss_percentile": 0.2464}, "CVE-2024-51567": {"epss_score": 0.9431, "epss_percentile": 0.99944}, "CVE-2024-51568": {"epss_score": 0.92503, "epss_percentile": 0.99721}, "CVE-2024-51569": {"epss_score": 0.0012, "epss_percentile": 0.31694}, "CVE-2024-51570": {"epss_score": 0.00238, "epss_percentile": 0.46822}, "CVE-2024-51571": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2024-51572": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2024-51573": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2024-51574": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2024-51575": {"epss_score": 0.00113, "epss_percentile": 0.30592}, "CVE-2024-51576": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51577": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51578": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51579": {"epss_score": 0.00238, "epss_percentile": 0.46822}, "CVE-2024-51580": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51581": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51582": {"epss_score": 0.0123, "epss_percentile": 0.7872}, "CVE-2024-51583": {"epss_score": 0.00094, "epss_percentile": 0.27008}, "CVE-2024-51584": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51585": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51586": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51587": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51588": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51589": {"epss_score": 0.00417, "epss_percentile": 0.61228}, "CVE-2024-51590": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51591": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51592": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51593": {"epss_score": 0.00108, "epss_percentile": 0.29862}, "CVE-2024-51594": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51595": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51596": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51597": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51598": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51599": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51601": {"epss_score": 0.00224, "epss_percentile": 0.45042}, "CVE-2024-51602": {"epss_score": 0.00238, "epss_percentile": 0.46822}, "CVE-2024-51603": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51604": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51605": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51606": {"epss_score": 0.00108, "epss_percentile": 0.29848}, "CVE-2024-51607": {"epss_score": 0.00224, "epss_percentile": 0.45042}, "CVE-2024-51608": {"epss_score": 0.00108, "epss_percentile": 0.29848}, "CVE-2024-51609": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51610": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-51611": {"epss_score": 0.00226, "epss_percentile": 0.45345}, "CVE-2024-51612": {"epss_score": 0.00238, "epss_percentile": 0.46768}, "CVE-2024-51613": {"epss_score": 0.00238, "epss_percentile": 0.46768}, "CVE-2024-51614": {"epss_score": 0.00226, "epss_percentile": 0.45345}, "CVE-2024-51615": {"epss_score": 0.00333, "epss_percentile": 0.55642}, "CVE-2024-51616": {"epss_score": 0.00226, "epss_percentile": 0.45345}, "CVE-2024-51617": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-51618": {"epss_score": 0.00226, "epss_percentile": 0.45345}, "CVE-2024-51619": {"epss_score": 0.00238, "epss_percentile": 0.46822}, "CVE-2024-51620": {"epss_score": 0.00224, "epss_percentile": 0.45042}, "CVE-2024-51621": {"epss_score": 0.00238, "epss_percentile": 0.46822}, "CVE-2024-51622": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-51623": {"epss_score": 0.00224, "epss_percentile": 0.45042}, "CVE-2024-51624": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2024-51625": {"epss_score": 0.00238, "epss_percentile": 0.46822}, "CVE-2024-51626": {"epss_score": 0.00797, "epss_percentile": 0.73497}, "CVE-2024-51627": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-51628": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-51629": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-51630": {"epss_score": 0.00122, "epss_percentile": 0.32034}, "CVE-2024-51631": {"epss_score": 0.00108, "epss_percentile": 0.29859}, "CVE-2024-51632": {"epss_score": 0.00104, "epss_percentile": 0.29165}, "CVE-2024-51633": {"epss_score": 0.00104, "epss_percentile": 0.29165}, "CVE-2024-51634": {"epss_score": 0.00104, "epss_percentile": 0.29165}, "CVE-2024-51635": {"epss_score": 0.00104, "epss_percentile": 0.29165}, "CVE-2024-51636": {"epss_score": 0.00104, "epss_percentile": 0.29165}, "CVE-2024-51637": {"epss_score": 0.00104, "epss_percentile": 0.29165}, "CVE-2024-51638": {"epss_score": 0.00104, "epss_percentile": 0.29165}, "CVE-2024-51639": {"epss_score": 0.00104, "epss_percentile": 0.29165}, "CVE-2024-51640": {"epss_score": 0.00104, "epss_percentile": 0.29165}, "CVE-2024-51641": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51642": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51643": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51644": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51645": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51646": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-51647": {"epss_score": 0.00122, "epss_percentile": 0.32034}, "CVE-2024-51648": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51649": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51650": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51651": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2024-51652": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51653": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51654": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51655": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51656": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51657": {"epss_score": 0.00087, "epss_percentile": 0.25586}, "CVE-2024-51658": {"epss_score": 0.00122, "epss_percentile": 0.32034}, "CVE-2024-51659": {"epss_score": 0.00122, "epss_percentile": 0.32034}, "CVE-2024-51660": {"epss_score": 0.0018, "epss_percentile": 0.39879}, "CVE-2024-51661": {"epss_score": 0.01469, "epss_percentile": 0.80491}, "CVE-2024-51662": {"epss_score": 0.00153, "epss_percentile": 0.36517}, "CVE-2024-51663": {"epss_score": 0.00114, "epss_percentile": 0.30776}, "CVE-2024-51664": {"epss_score": 0.00114, "epss_percentile": 0.30776}, "CVE-2024-51665": {"epss_score": 0.29302, "epss_percentile": 0.96431}, "CVE-2024-51666": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2024-51667": {"epss_score": 0.00102, "epss_percentile": 0.28777}, "CVE-2024-51668": {"epss_score": 0.00114, "epss_percentile": 0.30776}, "CVE-2024-51669": {"epss_score": 0.002, "epss_percentile": 0.42255}, "CVE-2024-51670": {"epss_score": 0.00116, "epss_percentile": 0.31103}, "CVE-2024-51671": {"epss_score": 0.00191, "epss_percentile": 0.41206}, "CVE-2024-51672": {"epss_score": 0.00556, "epss_percentile": 0.67516}, "CVE-2024-51673": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-51674": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-51675": {"epss_score": 0.00153, "epss_percentile": 0.36517}, "CVE-2024-51676": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51677": {"epss_score": 0.00207, "epss_percentile": 0.43184}, "CVE-2024-51678": {"epss_score": 0.00207, "epss_percentile": 0.43184}, "CVE-2024-51679": {"epss_score": 0.00119, "epss_percentile": 0.31672}, "CVE-2024-51680": {"epss_score": 0.00207, "epss_percentile": 0.43184}, "CVE-2024-51681": {"epss_score": 0.00207, "epss_percentile": 0.43184}, "CVE-2024-51682": {"epss_score": 0.00207, "epss_percentile": 0.43184}, "CVE-2024-51683": {"epss_score": 0.00207, "epss_percentile": 0.43184}, "CVE-2024-51684": {"epss_score": 0.00122, "epss_percentile": 0.32034}, "CVE-2024-51685": {"epss_score": 0.00155, "epss_percentile": 0.36772}, "CVE-2024-51686": {"epss_score": 0.00127, "epss_percentile": 0.32832}, "CVE-2024-51687": {"epss_score": 0.00122, "epss_percentile": 0.32034}, "CVE-2024-51688": {"epss_score": 0.00122, "epss_percentile": 0.32034}, "CVE-2024-51689": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51690": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51691": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51692": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51693": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51694": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51695": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51696": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51697": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51698": {"epss_score": 0.00175, "epss_percentile": 0.39314}, "CVE-2024-51699": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51700": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-51701": {"epss_score": 0.00175, "epss_percentile": 0.39314}, "CVE-2024-51702": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51703": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51704": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51705": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51706": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51707": {"epss_score": 0.00175, "epss_percentile": 0.39314}, "CVE-2024-51708": {"epss_score": 0.00175, "epss_percentile": 0.39314}, "CVE-2024-51709": {"epss_score": 0.00175, "epss_percentile": 0.39314}, "CVE-2024-51710": {"epss_score": 0.00175, "epss_percentile": 0.39314}, "CVE-2024-51711": {"epss_score": 0.00175, "epss_percentile": 0.39314}, "CVE-2024-51712": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51713": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51714": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51715": {"epss_score": 0.00254, "epss_percentile": 0.48509}, "CVE-2024-51716": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51717": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51718": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51719": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51720": {"epss_score": 0.00169, "epss_percentile": 0.38542}, "CVE-2024-51721": {"epss_score": 0.00041, "epss_percentile": 0.12264}, "CVE-2024-51722": {"epss_score": 0.00053, "epss_percentile": 0.16962}, "CVE-2024-51723": {"epss_score": 0.00183, "epss_percentile": 0.40329}, "CVE-2024-51727": {"epss_score": 0.00115, "epss_percentile": 0.30988}, "CVE-2024-51729": {"epss_score": 0.00044, "epss_percentile": 0.13535}, "CVE-2024-51734": {"epss_score": 0.00129, "epss_percentile": 0.33185}, "CVE-2024-51735": {"epss_score": 0.00211, "epss_percentile": 0.43696}, "CVE-2024-51736": {"epss_score": 0.006, "epss_percentile": 0.68812}, "CVE-2024-51737": {"epss_score": 0.00121, "epss_percentile": 0.31812}, "CVE-2024-51738": {"epss_score": 0.00237, "epss_percentile": 0.46739}, "CVE-2024-51739": {"epss_score": 0.26771, "epss_percentile": 0.96178}, "CVE-2024-51740": {"epss_score": 0.00128, "epss_percentile": 0.33065}, "CVE-2024-51741": {"epss_score": 0.00045, "epss_percentile": 0.1401}, "CVE-2024-51743": {"epss_score": 0.0383, "epss_percentile": 0.87801}, "CVE-2024-51744": {"epss_score": 0.00044, "epss_percentile": 0.136}, "CVE-2024-51745": {"epss_score": 0.00221, "epss_percentile": 0.44645}, "CVE-2024-51746": {"epss_score": 0.00059, "epss_percentile": 0.18696}, "CVE-2024-51747": {"epss_score": 0.01468, "epss_percentile": 0.80479}, "CVE-2024-51748": {"epss_score": 0.00447, "epss_percentile": 0.62941}, "CVE-2024-51749": {"epss_score": 0.00098, "epss_percentile": 0.27796}, "CVE-2024-51750": {"epss_score": 0.00087, "epss_percentile": 0.25604}, "CVE-2024-51751": {"epss_score": 0.00265, "epss_percentile": 0.49805}, "CVE-2024-51752": {"epss_score": 0.00134, "epss_percentile": 0.33865}, "CVE-2024-51753": {"epss_score": 0.00064, "epss_percentile": 0.20148}, "CVE-2024-51754": {"epss_score": 0.00099, "epss_percentile": 0.28402}, "CVE-2024-51755": {"epss_score": 0.00112, "epss_percentile": 0.30566}, "CVE-2024-51756": {"epss_score": 0.00434, "epss_percentile": 0.6229}, "CVE-2024-51757": {"epss_score": 0.00637, "epss_percentile": 0.69882}, "CVE-2024-51758": {"epss_score": 0.00077, "epss_percentile": 0.23369}, "CVE-2024-51759": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51760": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51761": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51762": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51763": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51764": {"epss_score": 0.00096, "epss_percentile": 0.27325}, "CVE-2024-51765": {"epss_score": 0.00096, "epss_percentile": 0.27325}, "CVE-2024-51766": {"epss_score": 0.00044, "epss_percentile": 0.1351}, "CVE-2024-51767": {"epss_score": 0.00058, "epss_percentile": 0.18365}, "CVE-2024-51768": {"epss_score": 0.00065, "epss_percentile": 0.20456}, "CVE-2024-51769": {"epss_score": 0.00044, "epss_percentile": 0.13492}, "CVE-2024-51770": {"epss_score": 0.00044, "epss_percentile": 0.13492}, "CVE-2024-51771": {"epss_score": 0.00685, "epss_percentile": 0.7114}, "CVE-2024-51772": {"epss_score": 0.00128, "epss_percentile": 0.32952}, "CVE-2024-51773": {"epss_score": 0.00082, "epss_percentile": 0.2442}, "CVE-2024-51774": {"epss_score": 0.02936, "epss_percentile": 0.86026}, "CVE-2024-51775": {"epss_score": 0.00039, "epss_percentile": 0.11798}, "CVE-2024-51776": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51778": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51779": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51780": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51781": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51782": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51783": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51784": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-51785": {"epss_score": 0.00126, "epss_percentile": 0.32683}, "CVE-2024-51786": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-51787": {"epss_score": 0.00153, "epss_percentile": 0.36517}, "CVE-2024-51788": {"epss_score": 0.56189, "epss_percentile": 0.98011}, "CVE-2024-51789": {"epss_score": 0.00426, "epss_percentile": 0.61739}, "CVE-2024-51790": {"epss_score": 0.00426, "epss_percentile": 0.61739}, "CVE-2024-51791": {"epss_score": 0.00592, "epss_percentile": 0.68618}, "CVE-2024-51792": {"epss_score": 0.00426, "epss_percentile": 0.61739}, "CVE-2024-51793": {"epss_score": 0.45044, "epss_percentile": 0.97469}, "CVE-2024-51794": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51795": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51796": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51797": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51798": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51799": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-51800": {"epss_score": 0.00073, "epss_percentile": 0.22588}, "CVE-2024-51801": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-51802": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51803": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51804": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51805": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51806": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51807": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51808": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51809": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51810": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51811": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51812": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51813": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51814": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51815": {"epss_score": 0.00477, "epss_percentile": 0.643}, "CVE-2024-51816": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51817": {"epss_score": 0.00203, "epss_percentile": 0.42543}, "CVE-2024-51818": {"epss_score": 0.17692, "epss_percentile": 0.9489}, "CVE-2024-51819": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51820": {"epss_score": 0.00178, "epss_percentile": 0.39704}, "CVE-2024-51821": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51822": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51823": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51824": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51825": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51826": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51827": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51828": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51829": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51830": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51831": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51832": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51833": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51834": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51835": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51836": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51837": {"epss_score": 0.00178, "epss_percentile": 0.39704}, "CVE-2024-51838": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51839": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51840": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51841": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51842": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51843": {"epss_score": 0.00178, "epss_percentile": 0.39704}, "CVE-2024-51844": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51845": {"epss_score": 0.00207, "epss_percentile": 0.43124}, "CVE-2024-51846": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51847": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51848": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51849": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51850": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51851": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51852": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51853": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51854": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51855": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51856": {"epss_score": 0.0028, "epss_percentile": 0.5102}, "CVE-2024-51857": {"epss_score": 0.0028, "epss_percentile": 0.5102}, "CVE-2024-51858": {"epss_score": 0.0028, "epss_percentile": 0.5102}, "CVE-2024-51859": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51860": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51861": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51862": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51863": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51864": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51865": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51866": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51867": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51868": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51869": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51870": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51871": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51872": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51873": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51874": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51875": {"epss_score": 0.00239, "epss_percentile": 0.46883}, "CVE-2024-51876": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51877": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51878": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51879": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51880": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51881": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51882": {"epss_score": 0.00178, "epss_percentile": 0.39704}, "CVE-2024-51883": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51884": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51885": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51886": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51887": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51888": {"epss_score": 0.00153, "epss_percentile": 0.36634}, "CVE-2024-51889": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51890": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51891": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51892": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51893": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51894": {"epss_score": 0.00289, "epss_percentile": 0.52071}, "CVE-2024-51895": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51896": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51897": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51898": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51899": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-51900": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-51901": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51902": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51903": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51904": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-51905": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51906": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51907": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51908": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-51909": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-51910": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-51911": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-51912": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51913": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51914": {"epss_score": 0.00142, "epss_percentile": 0.35061}, "CVE-2024-51916": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51917": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51918": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51919": {"epss_score": 0.00346, "epss_percentile": 0.56623}, "CVE-2024-51920": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51921": {"epss_score": 0.00194, "epss_percentile": 0.41515}, "CVE-2024-51922": {"epss_score": 0.00105, "epss_percentile": 0.2928}, "CVE-2024-51923": {"epss_score": 0.00193, "epss_percentile": 0.41486}, "CVE-2024-51924": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51925": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51926": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51927": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51928": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51929": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51930": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51931": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51932": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51933": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51934": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51935": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51936": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51937": {"epss_score": 0.00263, "epss_percentile": 0.49493}, "CVE-2024-51938": {"epss_score": 0.00241, "epss_percentile": 0.47241}, "CVE-2024-51939": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-51940": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-51941": {"epss_score": 0.00763, "epss_percentile": 0.72879}, "CVE-2024-51942": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51944": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51945": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51946": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51947": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51948": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51949": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51950": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51951": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51952": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51953": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51954": {"epss_score": 0.00096, "epss_percentile": 0.27354}, "CVE-2024-51956": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51957": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51958": {"epss_score": 0.00106, "epss_percentile": 0.29493}, "CVE-2024-51959": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51960": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51961": {"epss_score": 0.00081, "epss_percentile": 0.24359}, "CVE-2024-51962": {"epss_score": 0.00174, "epss_percentile": 0.39153}, "CVE-2024-51963": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-51966": {"epss_score": 0.00106, "epss_percentile": 0.29493}, "CVE-2024-51977": {"epss_score": 0.39511, "epss_percentile": 0.97164}, "CVE-2024-51978": {"epss_score": 0.48343, "epss_percentile": 0.97631}, "CVE-2024-51979": {"epss_score": 0.003, "epss_percentile": 0.52935}, "CVE-2024-51980": {"epss_score": 0.0018, "epss_percentile": 0.39988}, "CVE-2024-51981": {"epss_score": 0.00296, "epss_percentile": 0.52628}, "CVE-2024-51982": {"epss_score": 0.00395, "epss_percentile": 0.59849}, "CVE-2024-51983": {"epss_score": 0.00666, "epss_percentile": 0.70674}, "CVE-2024-51984": {"epss_score": 0.00069, "epss_percentile": 0.21471}, "CVE-2024-51987": {"epss_score": 0.00106, "epss_percentile": 0.29415}, "CVE-2024-51988": {"epss_score": 0.00133, "epss_percentile": 0.3363}, "CVE-2024-51989": {"epss_score": 0.00066, "epss_percentile": 0.20928}, "CVE-2024-51990": {"epss_score": 0.00127, "epss_percentile": 0.32808}, "CVE-2024-51991": {"epss_score": 0.00048, "epss_percentile": 0.15001}, "CVE-2024-51992": {"epss_score": 0.0008, "epss_percentile": 0.24023}, "CVE-2024-51993": {"epss_score": 0.00019, "epss_percentile": 0.04063}, "CVE-2024-51994": {"epss_score": 0.00349, "epss_percentile": 0.56892}, "CVE-2024-51995": {"epss_score": 0.00106, "epss_percentile": 0.29407}, "CVE-2024-51996": {"epss_score": 0.00044, "epss_percentile": 0.1341}, "CVE-2024-51997": {"epss_score": 0.00168, "epss_percentile": 0.38455}, "CVE-2024-51998": {"epss_score": 0.00137, "epss_percentile": 0.3434}, "CVE-2024-52000": {"epss_score": 0.00742, "epss_percentile": 0.72452}, "CVE-2024-52001": {"epss_score": 0.00364, "epss_percentile": 0.57926}, "CVE-2024-52002": {"epss_score": 0.05478, "epss_percentile": 0.89916}, "CVE-2024-52003": {"epss_score": 0.00216, "epss_percentile": 0.44145}, "CVE-2024-52004": {"epss_score": 0.05007, "epss_percentile": 0.89386}, "CVE-2024-52005": {"epss_score": 0.00243, "epss_percentile": 0.47419}, "CVE-2024-52006": {"epss_score": 0.00472, "epss_percentile": 0.64066}, "CVE-2024-52007": {"epss_score": 0.00239, "epss_percentile": 0.46883}, "CVE-2024-52008": {"epss_score": 0.00075, "epss_percentile": 0.22901}, "CVE-2024-52009": {"epss_score": 0.00482, "epss_percentile": 0.64537}, "CVE-2024-52010": {"epss_score": 0.00664, "epss_percentile": 0.7065}, "CVE-2024-52012": {"epss_score": 0.02978, "epss_percentile": 0.86112}, "CVE-2024-52013": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-52014": {"epss_score": 0.00238, "epss_percentile": 0.46808}, "CVE-2024-52015": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-52016": {"epss_score": 0.00311, "epss_percentile": 0.53933}, "CVE-2024-52017": {"epss_score": 0.00282, "epss_percentile": 0.51271}, "CVE-2024-52018": {"epss_score": 0.00398, "epss_percentile": 0.60073}, "CVE-2024-52019": {"epss_score": 0.00284, "epss_percentile": 0.51476}, "CVE-2024-52020": {"epss_score": 0.00271, "epss_percentile": 0.50275}, "CVE-2024-52021": {"epss_score": 0.00271, "epss_percentile": 0.50275}, "CVE-2024-52022": {"epss_score": 0.00271, "epss_percentile": 0.50275}, "CVE-2024-52023": {"epss_score": 0.00183, "epss_percentile": 0.40345}, "CVE-2024-52024": {"epss_score": 0.00193, "epss_percentile": 0.41382}, "CVE-2024-52025": {"epss_score": 0.00183, "epss_percentile": 0.40345}, "CVE-2024-52026": {"epss_score": 0.00183, "epss_percentile": 0.40345}, "CVE-2024-52028": {"epss_score": 0.00193, "epss_percentile": 0.41382}, "CVE-2024-52029": {"epss_score": 0.00183, "epss_percentile": 0.40345}, "CVE-2024-52030": {"epss_score": 0.00216, "epss_percentile": 0.4417}, "CVE-2024-52032": {"epss_score": 0.00269, "epss_percentile": 0.50165}, "CVE-2024-52033": {"epss_score": 0.00267, "epss_percentile": 0.4998}, "CVE-2024-52034": {"epss_score": 0.00631, "epss_percentile": 0.69724}, "CVE-2024-52035": {"epss_score": 0.00037, "epss_percentile": 0.10918}, "CVE-2024-52043": {"epss_score": 0.00248, "epss_percentile": 0.47917}, "CVE-2024-52046": {"epss_score": 0.37672, "epss_percentile": 0.97063}, "CVE-2024-52047": {"epss_score": 0.0051, "epss_percentile": 0.65801}, "CVE-2024-52048": {"epss_score": 0.0004, "epss_percentile": 0.12136}, "CVE-2024-52049": {"epss_score": 0.0004, "epss_percentile": 0.12136}, "CVE-2024-52050": {"epss_score": 0.00047, "epss_percentile": 0.14891}, "CVE-2024-52051": {"epss_score": 0.00023, "epss_percentile": 0.05625}, "CVE-2024-52052": {"epss_score": 0.02107, "epss_percentile": 0.83634}, "CVE-2024-52053": {"epss_score": 0.0028, "epss_percentile": 0.51066}, "CVE-2024-52054": {"epss_score": 0.00163, "epss_percentile": 0.37765}, "CVE-2024-52055": {"epss_score": 0.00078, "epss_percentile": 0.2376}, "CVE-2024-52056": {"epss_score": 0.00167, "epss_percentile": 0.38339}, "CVE-2024-52057": {"epss_score": 0.003, "epss_percentile": 0.5296}, "CVE-2024-52058": {"epss_score": 0.00468, "epss_percentile": 0.63873}, "CVE-2024-52059": {"epss_score": 0.0004, "epss_percentile": 0.11863}, "CVE-2024-52060": {"epss_score": 0.00139, "epss_percentile": 0.34635}, "CVE-2024-52061": {"epss_score": 0.00311, "epss_percentile": 0.53827}, "CVE-2024-52062": {"epss_score": 0.0003, "epss_percentile": 0.08054}, "CVE-2024-52063": {"epss_score": 0.0015, "epss_percentile": 0.36153}, "CVE-2024-52064": {"epss_score": 0.00028, "epss_percentile": 0.07484}, "CVE-2024-52065": {"epss_score": 0.00028, "epss_percentile": 0.07484}, "CVE-2024-52066": {"epss_score": 0.00094, "epss_percentile": 0.27047}, "CVE-2024-52067": {"epss_score": 0.00027, "epss_percentile": 0.06936}, "CVE-2024-52268": {"epss_score": 0.00543, "epss_percentile": 0.67114}, "CVE-2024-52269": {"epss_score": 0.00089, "epss_percentile": 0.25798}, "CVE-2024-52270": {"epss_score": 0.00053, "epss_percentile": 0.169}, "CVE-2024-52271": {"epss_score": 0.00053, "epss_percentile": 0.16954}, "CVE-2024-52272": {"epss_score": 0.0023, "epss_percentile": 0.45675}, "CVE-2024-52273": {"epss_score": 0.0023, "epss_percentile": 0.45675}, "CVE-2024-52274": {"epss_score": 0.0023, "epss_percentile": 0.45675}, "CVE-2024-52275": {"epss_score": 0.00254, "epss_percentile": 0.48514}, "CVE-2024-52276": {"epss_score": 0.00145, "epss_percentile": 0.35377}, "CVE-2024-52277": {"epss_score": 0.0005, "epss_percentile": 0.15707}, "CVE-2024-52279": {"epss_score": 0.00234, "epss_percentile": 0.46159}, "CVE-2024-52280": {"epss_score": 0.00134, "epss_percentile": 0.3392}, "CVE-2024-52281": {"epss_score": 0.00021, "epss_percentile": 0.04834}, "CVE-2024-52282": {"epss_score": 0.00041, "epss_percentile": 0.12421}, "CVE-2024-52283": {"epss_score": 0.00066, "epss_percentile": 0.20686}, "CVE-2024-52284": {"epss_score": 0.00019, "epss_percentile": 0.04324}, "CVE-2024-52285": {"epss_score": 0.00054, "epss_percentile": 0.17144}, "CVE-2024-52286": {"epss_score": 0.00166, "epss_percentile": 0.38147}, "CVE-2024-52287": {"epss_score": 0.00177, "epss_percentile": 0.39597}, "CVE-2024-52288": {"epss_score": 0.00038, "epss_percentile": 0.11288}, "CVE-2024-52289": {"epss_score": 0.00304, "epss_percentile": 0.53298}, "CVE-2024-52290": {"epss_score": 0.00031, "epss_percentile": 0.08395}, "CVE-2024-52291": {"epss_score": 0.00094, "epss_percentile": 0.26956}, "CVE-2024-52292": {"epss_score": 0.00315, "epss_percentile": 0.54181}, "CVE-2024-52293": {"epss_score": 0.11456, "epss_percentile": 0.93367}, "CVE-2024-52294": {"epss_score": 0.00135, "epss_percentile": 0.33936}, "CVE-2024-52295": {"epss_score": 0.0051, "epss_percentile": 0.65793}, "CVE-2024-52296": {"epss_score": 0.00127, "epss_percentile": 0.32883}, "CVE-2024-52297": {"epss_score": 0.00443, "epss_percentile": 0.62758}, "CVE-2024-52298": {"epss_score": 0.00339, "epss_percentile": 0.56208}, "CVE-2024-52299": {"epss_score": 0.00162, "epss_percentile": 0.37668}, "CVE-2024-52300": {"epss_score": 0.00652, "epss_percentile": 0.70309}, "CVE-2024-52301": {"epss_score": 0.38051, "epss_percentile": 0.97083}, "CVE-2024-52302": {"epss_score": 0.02975, "epss_percentile": 0.86104}, "CVE-2024-52303": {"epss_score": 0.00395, "epss_percentile": 0.59837}, "CVE-2024-52304": {"epss_score": 0.00456, "epss_percentile": 0.63329}, "CVE-2024-52305": {"epss_score": 0.00101, "epss_percentile": 0.28716}, "CVE-2024-52306": {"epss_score": 0.03713, "epss_percentile": 0.8761}, "CVE-2024-52307": {"epss_score": 0.00183, "epss_percentile": 0.4034}, "CVE-2024-52308": {"epss_score": 0.05956, "epss_percentile": 0.90362}, "CVE-2024-52309": {"epss_score": 0.0006, "epss_percentile": 0.19068}, "CVE-2024-52311": {"epss_score": 0.00202, "epss_percentile": 0.42416}, "CVE-2024-52312": {"epss_score": 0.00115, "epss_percentile": 0.30942}, "CVE-2024-52313": {"epss_score": 0.00232, "epss_percentile": 0.4594}, "CVE-2024-52314": {"epss_score": 0.00184, "epss_percentile": 0.40417}, "CVE-2024-52316": {"epss_score": 0.01846, "epss_percentile": 0.82513}, "CVE-2024-52317": {"epss_score": 0.1665, "epss_percentile": 0.94708}, "CVE-2024-52318": {"epss_score": 0.12001, "epss_percentile": 0.93544}, "CVE-2024-52319": {"epss_score": 0.00044, "epss_percentile": 0.13535}, "CVE-2024-52320": {"epss_score": 0.01765, "epss_percentile": 0.82164}, "CVE-2024-52321": {"epss_score": 0.00127, "epss_percentile": 0.3278}, "CVE-2024-52322": {"epss_score": 0.00113, "epss_percentile": 0.30603}, "CVE-2024-52323": {"epss_score": 0.00438, "epss_percentile": 0.62571}, "CVE-2024-52324": {"epss_score": 0.00177, "epss_percentile": 0.39565}, "CVE-2024-52325": {"epss_score": 0.01685, "epss_percentile": 0.81747}, "CVE-2024-52327": {"epss_score": 0.00133, "epss_percentile": 0.33691}, "CVE-2024-52328": {"epss_score": 0.00037, "epss_percentile": 0.10781}, "CVE-2024-52329": {"epss_score": 0.0012, "epss_percentile": 0.31732}, "CVE-2024-52330": {"epss_score": 0.0011, "epss_percentile": 0.3013}, "CVE-2024-52331": {"epss_score": 0.00031, "epss_percentile": 0.08684}, "CVE-2024-52332": {"epss_score": 0.00051, "epss_percentile": 0.16155}, "CVE-2024-52333": {"epss_score": 0.00067, "epss_percentile": 0.20968}, "CVE-2024-52335": {"epss_score": 0.00633, "epss_percentile": 0.69763}, "CVE-2024-52336": {"epss_score": 0.00024, "epss_percentile": 0.0586}, "CVE-2024-52337": {"epss_score": 0.00033, "epss_percentile": 0.09423}, "CVE-2024-52338": {"epss_score": 0.01157, "epss_percentile": 0.78108}, "CVE-2024-52339": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-52340": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-52341": {"epss_score": 0.00175, "epss_percentile": 0.39335}, "CVE-2024-52342": {"epss_score": 0.00175, "epss_percentile": 0.39335}, "CVE-2024-52343": {"epss_score": 0.00175, "epss_percentile": 0.39335}, "CVE-2024-52344": {"epss_score": 0.00175, "epss_percentile": 0.39335}, "CVE-2024-52345": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-52346": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-52347": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-52348": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-52349": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-52350": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-52351": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-52352": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-52353": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-52354": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-52355": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-52356": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-52357": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-52358": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2024-52359": {"epss_score": 0.001, "epss_percentile": 0.28484}, "CVE-2024-52360": {"epss_score": 0.00171, "epss_percentile": 0.38887}, "CVE-2024-52361": {"epss_score": 0.00032, "epss_percentile": 0.09019}, "CVE-2024-52362": {"epss_score": 0.00104, "epss_percentile": 0.29149}, "CVE-2024-52363": {"epss_score": 0.00117, "epss_percentile": 0.31213}, "CVE-2024-52364": {"epss_score": 0.00239, "epss_percentile": 0.46931}, "CVE-2024-52365": {"epss_score": 0.00106, "epss_percentile": 0.29478}, "CVE-2024-52366": {"epss_score": 0.00032, "epss_percentile": 0.08787}, "CVE-2024-52367": {"epss_score": 0.00107, "epss_percentile": 0.29599}, "CVE-2024-52369": {"epss_score": 0.00656, "epss_percentile": 0.70432}, "CVE-2024-52370": {"epss_score": 0.00656, "epss_percentile": 0.70432}, "CVE-2024-52371": {"epss_score": 0.00377, "epss_percentile": 0.58714}, "CVE-2024-52372": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2024-52373": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2024-52374": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2024-52375": {"epss_score": 0.54564, "epss_percentile": 0.97933}, "CVE-2024-52376": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2024-52377": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2024-52378": {"epss_score": 0.00952, "epss_percentile": 0.75871}, "CVE-2024-52379": {"epss_score": 0.00655, "epss_percentile": 0.70417}, "CVE-2024-52380": {"epss_score": 0.52328, "epss_percentile": 0.97819}, "CVE-2024-52381": {"epss_score": 0.0288, "epss_percentile": 0.85897}, "CVE-2024-52382": {"epss_score": 0.11923, "epss_percentile": 0.93517}, "CVE-2024-52383": {"epss_score": 0.00299, "epss_percentile": 0.52854}, "CVE-2024-52384": {"epss_score": 0.00656, "epss_percentile": 0.70432}, "CVE-2024-52385": {"epss_score": 0.00175, "epss_percentile": 0.39308}, "CVE-2024-52386": {"epss_score": 0.00365, "epss_percentile": 0.5797}, "CVE-2024-52388": {"epss_score": 0.00141, "epss_percentile": 0.34918}, "CVE-2024-52389": {"epss_score": 0.00153, "epss_percentile": 0.36517}, "CVE-2024-52390": {"epss_score": 0.00698, "epss_percentile": 0.71428}, "CVE-2024-52391": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2024-52392": {"epss_score": 0.00132, "epss_percentile": 0.33551}, "CVE-2024-52393": {"epss_score": 0.00483, "epss_percentile": 0.64566}, "CVE-2024-52394": {"epss_score": 0.00167, "epss_percentile": 0.38289}, "CVE-2024-52395": {"epss_score": 0.0033, "epss_percentile": 0.55434}, "CVE-2024-52396": {"epss_score": 0.006, "epss_percentile": 0.68811}, "CVE-2024-52397": {"epss_score": 0.00297, "epss_percentile": 0.52687}, "CVE-2024-52398": {"epss_score": 0.00297, "epss_percentile": 0.52687}, "CVE-2024-52399": {"epss_score": 0.00426, "epss_percentile": 0.61749}, "CVE-2024-52400": {"epss_score": 0.00426, "epss_percentile": 0.61749}, "CVE-2024-52401": {"epss_score": 0.00202, "epss_percentile": 0.42451}, "CVE-2024-52402": {"epss_score": 0.1417, "epss_percentile": 0.94148}, "CVE-2024-52403": {"epss_score": 0.00426, "epss_percentile": 0.61749}, "CVE-2024-52404": {"epss_score": 0.00426, "epss_percentile": 0.61749}, "CVE-2024-52405": {"epss_score": 0.00556, "epss_percentile": 0.67531}, "CVE-2024-52406": {"epss_score": 0.00426, "epss_percentile": 0.61749}, "CVE-2024-52407": {"epss_score": 0.00556, "epss_percentile": 0.67531}, "CVE-2024-52408": {"epss_score": 0.00426, "epss_percentile": 0.61749}, "CVE-2024-52409": {"epss_score": 0.00538, "epss_percentile": 0.66929}, "CVE-2024-52410": {"epss_score": 0.00412, "epss_percentile": 0.60913}, "CVE-2024-52411": {"epss_score": 0.00412, "epss_percentile": 0.60913}, "CVE-2024-52412": {"epss_score": 0.00412, "epss_percentile": 0.60913}, "CVE-2024-52413": {"epss_score": 0.02817, "epss_percentile": 0.85736}, "CVE-2024-52414": {"epss_score": 0.00412, "epss_percentile": 0.60913}, "CVE-2024-52415": {"epss_score": 0.00131, "epss_percentile": 0.33423}, "CVE-2024-52416": {"epss_score": 0.00112, "epss_percentile": 0.30432}, "CVE-2024-52417": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-52418": {"epss_score": 0.00166, "epss_percentile": 0.38269}, "CVE-2024-52419": {"epss_score": 0.00153, "epss_percentile": 0.36517}, "CVE-2024-52420": {"epss_score": 0.00216, "epss_percentile": 0.44175}, "CVE-2024-52421": {"epss_score": 0.00141, "epss_percentile": 0.34918}, "CVE-2024-52422": {"epss_score": 0.00153, "epss_percentile": 0.36517}, "CVE-2024-52423": {"epss_score": 0.00098, "epss_percentile": 0.27787}, "CVE-2024-52424": {"epss_score": 0.00125, "epss_percentile": 0.32616}, "CVE-2024-52425": {"epss_score": 0.00153, "epss_percentile": 0.36517}, "CVE-2024-52426": {"epss_score": 0.00153, "epss_percentile": 0.36517}, "CVE-2024-52427": {"epss_score": 0.12224, "epss_percentile": 0.93607}, "CVE-2024-52428": {"epss_score": 0.0288, "epss_percentile": 0.85897}, "CVE-2024-52429": {"epss_score": 0.32842, "epss_percentile": 0.9673}, "CVE-2024-52430": {"epss_score": 0.2604, "epss_percentile": 0.96102}, "CVE-2024-52431": {"epss_score": 0.00308, "epss_percentile": 0.53586}, "CVE-2024-52432": {"epss_score": 0.00634, "epss_percentile": 0.69789}, "CVE-2024-52433": {"epss_score": 0.827, "epss_percentile": 0.99208}, "CVE-2024-52434": {"epss_score": 0.00993, "epss_percentile": 0.76412}, "CVE-2024-52435": {"epss_score": 0.00291, "epss_percentile": 0.52201}, "CVE-2024-52436": {"epss_score": 0.00225, "epss_percentile": 0.4515}, "CVE-2024-52437": {"epss_score": 0.00138, "epss_percentile": 0.34386}, "CVE-2024-52438": {"epss_score": 0.00138, "epss_percentile": 0.34386}, "CVE-2024-52439": {"epss_score": 0.00412, "epss_percentile": 0.60913}, "CVE-2024-52440": {"epss_score": 0.00474, "epss_percentile": 0.64155}, "CVE-2024-52441": {"epss_score": 0.00479, "epss_percentile": 0.6443}, "CVE-2024-52442": {"epss_score": 0.00145, "epss_percentile": 0.35394}, "CVE-2024-52443": {"epss_score": 0.00474, "epss_percentile": 0.64155}, "CVE-2024-52444": {"epss_score": 0.00332, "epss_percentile": 0.55594}, "CVE-2024-52445": {"epss_score": 0.00485, "epss_percentile": 0.64729}, "CVE-2024-52446": {"epss_score": 0.00131, "epss_percentile": 0.33423}, "CVE-2024-52447": {"epss_score": 0.00377, "epss_percentile": 0.58714}, "CVE-2024-52448": {"epss_score": 0.00476, "epss_percentile": 0.64255}, "CVE-2024-52449": {"epss_score": 0.00587, "epss_percentile": 0.68487}, "CVE-2024-52450": {"epss_score": 0.01819, "epss_percentile": 0.82406}, "CVE-2024-52451": {"epss_score": 0.00062, "epss_percentile": 0.19724}, "CVE-2024-52452": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52453": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52454": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52455": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52456": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52457": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52458": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52459": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52460": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52461": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52462": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52463": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52464": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52465": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52466": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52467": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52468": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52469": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52470": {"epss_score": 0.00112, "epss_percentile": 0.30574}, "CVE-2024-52471": {"epss_score": 0.0011, "epss_percentile": 0.30217}, "CVE-2024-52472": {"epss_score": 0.00112, "epss_percentile": 0.30574}, "CVE-2024-52473": {"epss_score": 0.00112, "epss_percentile": 0.30574}, "CVE-2024-52474": {"epss_score": 0.00042, "epss_percentile": 0.12662}, "CVE-2024-52475": {"epss_score": 0.21761, "epss_percentile": 0.95556}, "CVE-2024-52476": {"epss_score": 0.00459, "epss_percentile": 0.63472}, "CVE-2024-52477": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-52478": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-52479": {"epss_score": 0.00042, "epss_percentile": 0.12583}, "CVE-2024-52480": {"epss_score": 0.00218, "epss_percentile": 0.44365}, "CVE-2024-52481": {"epss_score": 0.00215, "epss_percentile": 0.44083}, "CVE-2024-52482": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52483": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52484": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-52485": {"epss_score": 0.00125, "epss_percentile": 0.32502}, "CVE-2024-52486": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-52487": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-52489": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-52490": {"epss_score": 0.00444, "epss_percentile": 0.62813}, "CVE-2024-52491": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-52492": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-52493": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-52494": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-52495": {"epss_score": 0.00082, "epss_percentile": 0.24499}, "CVE-2024-52496": {"epss_score": 0.00967, "epss_percentile": 0.76065}, "CVE-2024-52497": {"epss_score": 0.00833, "epss_percentile": 0.74087}, "CVE-2024-52498": {"epss_score": 0.00258, "epss_percentile": 0.48976}, "CVE-2024-52499": {"epss_score": 0.00967, "epss_percentile": 0.76065}, "CVE-2024-52500": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2024-52501": {"epss_score": 0.0081, "epss_percentile": 0.7372}, "CVE-2024-52502": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-52503": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-52504": {"epss_score": 0.0012, "epss_percentile": 0.31735}, "CVE-2024-52505": {"epss_score": 0.00279, "epss_percentile": 0.50994}, "CVE-2024-52506": {"epss_score": 0.0029, "epss_percentile": 0.5213}, "CVE-2024-52507": {"epss_score": 0.00169, "epss_percentile": 0.38551}, "CVE-2024-52508": {"epss_score": 0.00161, "epss_percentile": 0.37554}, "CVE-2024-52509": {"epss_score": 0.00233, "epss_percentile": 0.4598}, "CVE-2024-52510": {"epss_score": 0.00301, "epss_percentile": 0.5308}, "CVE-2024-52511": {"epss_score": 0.00197, "epss_percentile": 0.41863}, "CVE-2024-52512": {"epss_score": 0.00401, "epss_percentile": 0.60257}, "CVE-2024-52513": {"epss_score": 0.00422, "epss_percentile": 0.61546}, "CVE-2024-52514": {"epss_score": 0.00346, "epss_percentile": 0.56705}, "CVE-2024-52515": {"epss_score": 0.01435, "epss_percentile": 0.80272}, "CVE-2024-52516": {"epss_score": 0.00619, "epss_percentile": 0.69434}, "CVE-2024-52517": {"epss_score": 0.0055, "epss_percentile": 0.67342}, "CVE-2024-52518": {"epss_score": 0.00134, "epss_percentile": 0.3386}, "CVE-2024-52519": {"epss_score": 0.00693, "epss_percentile": 0.71329}, "CVE-2024-52520": {"epss_score": 0.01308, "epss_percentile": 0.79347}, "CVE-2024-52521": {"epss_score": 0.00731, "epss_percentile": 0.72185}, "CVE-2024-52522": {"epss_score": 0.00024, "epss_percentile": 0.05689}, "CVE-2024-52523": {"epss_score": 0.00393, "epss_percentile": 0.59726}, "CVE-2024-52524": {"epss_score": 0.01477, "epss_percentile": 0.80545}, "CVE-2024-52525": {"epss_score": 0.00518, "epss_percentile": 0.66107}, "CVE-2024-52526": {"epss_score": 0.00878, "epss_percentile": 0.74825}, "CVE-2024-52528": {"epss_score": 0.00107, "epss_percentile": 0.29636}, "CVE-2024-52529": {"epss_score": 0.00084, "epss_percentile": 0.24953}, "CVE-2024-52530": {"epss_score": 0.00366, "epss_percentile": 0.58087}, "CVE-2024-52531": {"epss_score": 0.0011, "epss_percentile": 0.30216}, "CVE-2024-52532": {"epss_score": 0.00204, "epss_percentile": 0.42605}, "CVE-2024-52533": {"epss_score": 0.03091, "epss_percentile": 0.86394}, "CVE-2024-52534": {"epss_score": 0.00115, "epss_percentile": 0.30987}, "CVE-2024-52535": {"epss_score": 0.00211, "epss_percentile": 0.43648}, "CVE-2024-52537": {"epss_score": 0.00018, "epss_percentile": 0.03837}, "CVE-2024-52538": {"epss_score": 0.00304, "epss_percentile": 0.5324}, "CVE-2024-52541": {"epss_score": 0.00034, "epss_percentile": 0.09527}, "CVE-2024-52542": {"epss_score": 0.00039, "epss_percentile": 0.11448}, "CVE-2024-52543": {"epss_score": 0.00019, "epss_percentile": 0.0417}, "CVE-2024-52544": {"epss_score": 0.00676, "epss_percentile": 0.7092}, "CVE-2024-52545": {"epss_score": 0.00317, "epss_percentile": 0.54336}, "CVE-2024-52546": {"epss_score": 0.00258, "epss_percentile": 0.49018}, "CVE-2024-52547": {"epss_score": 0.00317, "epss_percentile": 0.54363}, "CVE-2024-52548": {"epss_score": 0.00026, "epss_percentile": 0.06408}, "CVE-2024-52549": {"epss_score": 0.00203, "epss_percentile": 0.42545}, "CVE-2024-52550": {"epss_score": 0.01035, "epss_percentile": 0.76897}, "CVE-2024-52551": {"epss_score": 0.00404, "epss_percentile": 0.60442}, "CVE-2024-52552": {"epss_score": 0.02286, "epss_percentile": 0.84268}, "CVE-2024-52553": {"epss_score": 0.00275, "epss_percentile": 0.50688}, "CVE-2024-52554": {"epss_score": 0.0039, "epss_percentile": 0.595}, "CVE-2024-52555": {"epss_score": 3e-05, "epss_percentile": 0.00074}, "CVE-2024-52557": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2024-52558": {"epss_score": 0.00187, "epss_percentile": 0.40696}, "CVE-2024-52559": {"epss_score": 0.00039, "epss_percentile": 0.11569}, "CVE-2024-52560": {"epss_score": 0.00047, "epss_percentile": 0.14614}, "CVE-2024-52561": {"epss_score": 0.00053, "epss_percentile": 0.16715}, "CVE-2024-52564": {"epss_score": 0.00074, "epss_percentile": 0.22726}, "CVE-2024-52565": {"epss_score": 0.00118, "epss_percentile": 0.31428}, "CVE-2024-52566": {"epss_score": 0.00118, "epss_percentile": 0.31428}, "CVE-2024-52567": {"epss_score": 0.00154, "epss_percentile": 0.36719}, "CVE-2024-52568": {"epss_score": 0.00151, "epss_percentile": 0.36348}, "CVE-2024-52569": {"epss_score": 0.00118, "epss_percentile": 0.31428}, "CVE-2024-52570": {"epss_score": 0.00118, "epss_percentile": 0.31428}, "CVE-2024-52571": {"epss_score": 0.00118, "epss_percentile": 0.31428}, "CVE-2024-52572": {"epss_score": 0.00118, "epss_percentile": 0.31428}, "CVE-2024-52573": {"epss_score": 0.00118, "epss_percentile": 0.31428}, "CVE-2024-52574": {"epss_score": 0.00154, "epss_percentile": 0.36719}, "CVE-2024-52577": {"epss_score": 0.01736, "epss_percentile": 0.82014}, "CVE-2024-52579": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2024-52581": {"epss_score": 0.00445, "epss_percentile": 0.62884}, "CVE-2024-52582": {"epss_score": 0.00076, "epss_percentile": 0.23168}, "CVE-2024-52583": {"epss_score": 0.00168, "epss_percentile": 0.38473}, "CVE-2024-52584": {"epss_score": 0.00243, "epss_percentile": 0.47413}, "CVE-2024-52585": {"epss_score": 0.00537, "epss_percentile": 0.66924}, "CVE-2024-52586": {"epss_score": 0.00073, "epss_percentile": 0.22495}, "CVE-2024-52587": {"epss_score": 0.01158, "epss_percentile": 0.7812}, "CVE-2024-52588": {"epss_score": 0.00067, "epss_percentile": 0.21064}, "CVE-2024-52589": {"epss_score": 0.00161, "epss_percentile": 0.37567}, "CVE-2024-52590": {"epss_score": 0.00131, "epss_percentile": 0.3339}, "CVE-2024-52591": {"epss_score": 0.00149, "epss_percentile": 0.36045}, "CVE-2024-52592": {"epss_score": 0.00144, "epss_percentile": 0.3524}, "CVE-2024-52593": {"epss_score": 0.00107, "epss_percentile": 0.29685}, "CVE-2024-52594": {"epss_score": 0.00121, "epss_percentile": 0.31952}, "CVE-2024-52595": {"epss_score": 0.00237, "epss_percentile": 0.46694}, "CVE-2024-52596": {"epss_score": 0.00087, "epss_percentile": 0.25601}, "CVE-2024-52597": {"epss_score": 0.00499, "epss_percentile": 0.65261}, "CVE-2024-52598": {"epss_score": 0.00122, "epss_percentile": 0.32036}, "CVE-2024-52599": {"epss_score": 0.00106, "epss_percentile": 0.2953}, "CVE-2024-52600": {"epss_score": 0.00386, "epss_percentile": 0.59286}, "CVE-2024-52601": {"epss_score": 0.00043, "epss_percentile": 0.13229}, "CVE-2024-52602": {"epss_score": 0.00166, "epss_percentile": 0.38159}, "CVE-2024-52606": {"epss_score": 0.00231, "epss_percentile": 0.45791}, "CVE-2024-52611": {"epss_score": 0.00084, "epss_percentile": 0.24895}, "CVE-2024-52612": {"epss_score": 0.00182, "epss_percentile": 0.40228}, "CVE-2024-52613": {"epss_score": 0.00088, "epss_percentile": 0.25673}, "CVE-2024-52614": {"epss_score": 0.00049, "epss_percentile": 0.15611}, "CVE-2024-52615": {"epss_score": 0.00067, "epss_percentile": 0.20983}, "CVE-2024-52616": {"epss_score": 0.00083, "epss_percentile": 0.24784}, "CVE-2024-52675": {"epss_score": 0.00197, "epss_percentile": 0.41911}, "CVE-2024-52676": {"epss_score": 0.00083, "epss_percentile": 0.24795}, "CVE-2024-52677": {"epss_score": 0.00194, "epss_percentile": 0.41547}, "CVE-2024-52680": {"epss_score": 0.00028, "epss_percentile": 0.07232}, "CVE-2024-52701": {"epss_score": 0.00674, "epss_percentile": 0.70858}, "CVE-2024-52702": {"epss_score": 0.00571, "epss_percentile": 0.67989}, "CVE-2024-52711": {"epss_score": 0.03476, "epss_percentile": 0.87209}, "CVE-2024-52714": {"epss_score": 0.0034, "epss_percentile": 0.56282}, "CVE-2024-52723": {"epss_score": 0.0023, "epss_percentile": 0.45733}, "CVE-2024-52724": {"epss_score": 0.00167, "epss_percentile": 0.38313}, "CVE-2024-52725": {"epss_score": 0.00127, "epss_percentile": 0.32848}, "CVE-2024-52726": {"epss_score": 0.30074, "epss_percentile": 0.96504}, "CVE-2024-52732": {"epss_score": 0.00153, "epss_percentile": 0.36553}, "CVE-2024-52739": {"epss_score": 0.00168, "epss_percentile": 0.38419}, "CVE-2024-52754": {"epss_score": 0.00189, "epss_percentile": 0.4093}, "CVE-2024-52755": {"epss_score": 0.0053, "epss_percentile": 0.66614}, "CVE-2024-52757": {"epss_score": 0.00077, "epss_percentile": 0.23317}, "CVE-2024-52759": {"epss_score": 0.03014, "epss_percentile": 0.86208}, "CVE-2024-52762": {"epss_score": 0.00336, "epss_percentile": 0.559}, "CVE-2024-52763": {"epss_score": 0.00326, "epss_percentile": 0.55089}, "CVE-2024-52765": {"epss_score": 0.06555, "epss_percentile": 0.90845}, "CVE-2024-52769": {"epss_score": 0.00148, "epss_percentile": 0.35829}, "CVE-2024-52770": {"epss_score": 0.00224, "epss_percentile": 0.45026}, "CVE-2024-52771": {"epss_score": 0.00403, "epss_percentile": 0.60377}, "CVE-2024-52777": {"epss_score": 0.02032, "epss_percentile": 0.83341}, "CVE-2024-52778": {"epss_score": 0.02032, "epss_percentile": 0.83341}, "CVE-2024-52779": {"epss_score": 0.02032, "epss_percentile": 0.83341}, "CVE-2024-52780": {"epss_score": 0.02032, "epss_percentile": 0.83341}, "CVE-2024-52781": {"epss_score": 0.02032, "epss_percentile": 0.83341}, "CVE-2024-52782": {"epss_score": 0.02032, "epss_percentile": 0.83341}, "CVE-2024-52783": {"epss_score": 0.00026, "epss_percentile": 0.06679}, "CVE-2024-52786": {"epss_score": 0.0059, "epss_percentile": 0.68559}, "CVE-2024-52787": {"epss_score": 0.00277, "epss_percentile": 0.50798}, "CVE-2024-52788": {"epss_score": 0.00129, "epss_percentile": 0.33094}, "CVE-2024-52789": {"epss_score": 0.00129, "epss_percentile": 0.33094}, "CVE-2024-52791": {"epss_score": 0.00406, "epss_percentile": 0.60541}, "CVE-2024-52792": {"epss_score": 0.00379, "epss_percentile": 0.58852}, "CVE-2024-52793": {"epss_score": 0.00141, "epss_percentile": 0.34825}, "CVE-2024-52794": {"epss_score": 0.00319, "epss_percentile": 0.54544}, "CVE-2024-52796": {"epss_score": 0.00115, "epss_percentile": 0.30976}, "CVE-2024-52797": {"epss_score": 0.00357, "epss_percentile": 0.57471}, "CVE-2024-52798": {"epss_score": 0.00086, "epss_percentile": 0.25249}, "CVE-2024-52799": {"epss_score": 0.00035, "epss_percentile": 0.1007}, "CVE-2024-52800": {"epss_score": 0.11926, "epss_percentile": 0.93518}, "CVE-2024-52801": {"epss_score": 0.00107, "epss_percentile": 0.29737}, "CVE-2024-52802": {"epss_score": 0.00404, "epss_percentile": 0.60436}, "CVE-2024-52803": {"epss_score": 0.01656, "epss_percentile": 0.81597}, "CVE-2024-52804": {"epss_score": 0.00118, "epss_percentile": 0.31468}, "CVE-2024-52805": {"epss_score": 0.00121, "epss_percentile": 0.3199}, "CVE-2024-52806": {"epss_score": 0.00158, "epss_percentile": 0.37198}, "CVE-2024-52807": {"epss_score": 0.00108, "epss_percentile": 0.29883}, "CVE-2024-52809": {"epss_score": 0.00131, "epss_percentile": 0.33375}, "CVE-2024-52810": {"epss_score": 0.0009, "epss_percentile": 0.26059}, "CVE-2024-52811": {"epss_score": 0.00147, "epss_percentile": 0.35703}, "CVE-2024-52812": {"epss_score": 0.00282, "epss_percentile": 0.51225}, "CVE-2024-52813": {"epss_score": 0.00129, "epss_percentile": 0.33132}, "CVE-2024-52814": {"epss_score": 0.00073, "epss_percentile": 0.22602}, "CVE-2024-52815": {"epss_score": 0.00092, "epss_percentile": 0.26462}, "CVE-2024-52816": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52817": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52818": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52822": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-52823": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-52824": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52825": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52826": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52827": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52828": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52829": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52830": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52831": {"epss_score": 0.00209, "epss_percentile": 0.43345}, "CVE-2024-52832": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52833": {"epss_score": 0.00037, "epss_percentile": 0.10668}, "CVE-2024-52834": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52835": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52836": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52837": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-52838": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-52839": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-52840": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-52841": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52842": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52843": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52844": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-52845": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52846": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52847": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52848": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52849": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52850": {"epss_score": 0.00098, "epss_percentile": 0.2773}, "CVE-2024-52851": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52852": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52853": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52854": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52855": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52857": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52858": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52859": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52860": {"epss_score": 0.00451, "epss_percentile": 0.6314}, "CVE-2024-52861": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52862": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52864": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52865": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52867": {"epss_score": 0.00039, "epss_percentile": 0.11701}, "CVE-2024-52869": {"epss_score": 0.00029, "epss_percentile": 0.07606}, "CVE-2024-52870": {"epss_score": 0.00037, "epss_percentile": 0.10729}, "CVE-2024-52871": {"epss_score": 0.00048, "epss_percentile": 0.15191}, "CVE-2024-52872": {"epss_score": 0.00096, "epss_percentile": 0.27441}, "CVE-2024-52874": {"epss_score": 0.0009, "epss_percentile": 0.25988}, "CVE-2024-52875": {"epss_score": 0.8611, "epss_percentile": 0.99367}, "CVE-2024-52876": {"epss_score": 0.00074, "epss_percentile": 0.2275}, "CVE-2024-52877": {"epss_score": 0.00041, "epss_percentile": 0.12378}, "CVE-2024-52878": {"epss_score": 0.00041, "epss_percentile": 0.12378}, "CVE-2024-52879": {"epss_score": 0.00041, "epss_percentile": 0.12378}, "CVE-2024-52880": {"epss_score": 0.00023, "epss_percentile": 0.05402}, "CVE-2024-52881": {"epss_score": 0.00146, "epss_percentile": 0.35612}, "CVE-2024-52882": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2024-52883": {"epss_score": 0.0027, "epss_percentile": 0.50267}, "CVE-2024-52884": {"epss_score": 0.00056, "epss_percentile": 0.17891}, "CVE-2024-52885": {"epss_score": 0.00065, "epss_percentile": 0.2046}, "CVE-2024-52887": {"epss_score": 0.00027, "epss_percentile": 0.07114}, "CVE-2024-52888": {"epss_score": 0.00027, "epss_percentile": 0.07114}, "CVE-2024-52890": {"epss_score": 0.00016, "epss_percentile": 0.03042}, "CVE-2024-52891": {"epss_score": 0.00085, "epss_percentile": 0.25234}, "CVE-2024-52892": {"epss_score": 0.00474, "epss_percentile": 0.64141}, "CVE-2024-52893": {"epss_score": 0.00071, "epss_percentile": 0.22068}, "CVE-2024-52894": {"epss_score": 0.00065, "epss_percentile": 0.20524}, "CVE-2024-52895": {"epss_score": 0.00104, "epss_percentile": 0.29107}, "CVE-2024-52896": {"epss_score": 0.00032, "epss_percentile": 0.08991}, "CVE-2024-52897": {"epss_score": 0.00032, "epss_percentile": 0.08991}, "CVE-2024-52898": {"epss_score": 0.00027, "epss_percentile": 0.06883}, "CVE-2024-52899": {"epss_score": 0.00074, "epss_percentile": 0.2286}, "CVE-2024-52900": {"epss_score": 0.00019, "epss_percentile": 0.04356}, "CVE-2024-52901": {"epss_score": 0.00104, "epss_percentile": 0.29149}, "CVE-2024-52902": {"epss_score": 0.00154, "epss_percentile": 0.36692}, "CVE-2024-52903": {"epss_score": 0.00037, "epss_percentile": 0.10922}, "CVE-2024-52905": {"epss_score": 0.00087, "epss_percentile": 0.25495}, "CVE-2024-52906": {"epss_score": 0.00015, "epss_percentile": 0.02185}, "CVE-2024-52912": {"epss_score": 0.00152, "epss_percentile": 0.3649}, "CVE-2024-52913": {"epss_score": 0.00116, "epss_percentile": 0.31161}, "CVE-2024-52914": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2024-52915": {"epss_score": 0.00784, "epss_percentile": 0.73236}, "CVE-2024-52916": {"epss_score": 0.00218, "epss_percentile": 0.44386}, "CVE-2024-52917": {"epss_score": 0.00076, "epss_percentile": 0.23281}, "CVE-2024-52918": {"epss_score": 0.00323, "epss_percentile": 0.54924}, "CVE-2024-52919": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2024-52920": {"epss_score": 0.00649, "epss_percentile": 0.70235}, "CVE-2024-52921": {"epss_score": 0.00081, "epss_percentile": 0.24293}, "CVE-2024-52922": {"epss_score": 0.00215, "epss_percentile": 0.44044}, "CVE-2024-52923": {"epss_score": 0.00205, "epss_percentile": 0.4275}, "CVE-2024-52924": {"epss_score": 0.00205, "epss_percentile": 0.4275}, "CVE-2024-52925": {"epss_score": 0.00077, "epss_percentile": 0.23318}, "CVE-2024-52926": {"epss_score": 0.00017, "epss_percentile": 0.03055}, "CVE-2024-52928": {"epss_score": 0.00046, "epss_percentile": 0.14271}, "CVE-2024-52935": {"epss_score": 0.00043, "epss_percentile": 0.13239}, "CVE-2024-52936": {"epss_score": 0.00035, "epss_percentile": 0.10073}, "CVE-2024-52937": {"epss_score": 0.00029, "epss_percentile": 0.07902}, "CVE-2024-52938": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2024-52939": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2024-52940": {"epss_score": 0.11959, "epss_percentile": 0.93527}, "CVE-2024-52941": {"epss_score": 0.00076, "epss_percentile": 0.23156}, "CVE-2024-52942": {"epss_score": 0.00185, "epss_percentile": 0.4048}, "CVE-2024-52943": {"epss_score": 0.00226, "epss_percentile": 0.4528}, "CVE-2024-52944": {"epss_score": 0.00442, "epss_percentile": 0.62702}, "CVE-2024-52945": {"epss_score": 0.00151, "epss_percentile": 0.36333}, "CVE-2024-52946": {"epss_score": 0.00098, "epss_percentile": 0.27719}, "CVE-2024-52947": {"epss_score": 0.00086, "epss_percentile": 0.25433}, "CVE-2024-52949": {"epss_score": 0.00147, "epss_percentile": 0.35668}, "CVE-2024-52951": {"epss_score": 0.00057, "epss_percentile": 0.18043}, "CVE-2024-52958": {"epss_score": 0.00171, "epss_percentile": 0.38888}, "CVE-2024-52959": {"epss_score": 0.00387, "epss_percentile": 0.59333}, "CVE-2024-52960": {"epss_score": 0.00134, "epss_percentile": 0.33787}, "CVE-2024-52961": {"epss_score": 0.00158, "epss_percentile": 0.37166}, "CVE-2024-52962": {"epss_score": 0.00075, "epss_percentile": 0.22927}, "CVE-2024-52963": {"epss_score": 0.00078, "epss_percentile": 0.23583}, "CVE-2024-52964": {"epss_score": 0.00181, "epss_percentile": 0.40098}, "CVE-2024-52965": {"epss_score": 0.00045, "epss_percentile": 0.13789}, "CVE-2024-52966": {"epss_score": 0.00032, "epss_percentile": 0.08857}, "CVE-2024-52967": {"epss_score": 0.00122, "epss_percentile": 0.32165}, "CVE-2024-52968": {"epss_score": 0.00036, "epss_percentile": 0.10164}, "CVE-2024-52969": {"epss_score": 0.00124, "epss_percentile": 0.32419}, "CVE-2024-52972": {"epss_score": 0.00154, "epss_percentile": 0.36731}, "CVE-2024-52973": {"epss_score": 0.00257, "epss_percentile": 0.48895}, "CVE-2024-52974": {"epss_score": 0.00094, "epss_percentile": 0.26795}, "CVE-2024-52975": {"epss_score": 0.00072, "epss_percentile": 0.22423}, "CVE-2024-52976": {"epss_score": 0.00015, "epss_percentile": 0.02273}, "CVE-2024-52979": {"epss_score": 0.00192, "epss_percentile": 0.41325}, "CVE-2024-52980": {"epss_score": 0.00321, "epss_percentile": 0.54735}, "CVE-2024-52981": {"epss_score": 0.00403, "epss_percentile": 0.60372}, "CVE-2024-52982": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2024-52983": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-52984": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-52985": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-52986": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-52987": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-52988": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-52989": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-52990": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2024-52991": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52992": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52993": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-52994": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-52995": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-52996": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-52997": {"epss_score": 0.0005, "epss_percentile": 0.15977}, "CVE-2024-52998": {"epss_score": 0.00041, "epss_percentile": 0.12324}, "CVE-2024-52999": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-53000": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2024-53001": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-53002": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2024-53003": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-53004": {"epss_score": 0.00083, "epss_percentile": 0.24786}, "CVE-2024-53005": {"epss_score": 0.00083, "epss_percentile": 0.24786}, "CVE-2024-53006": {"epss_score": 0.00037, "epss_percentile": 0.1064}, "CVE-2024-53007": {"epss_score": 0.0002, "epss_percentile": 0.045}, "CVE-2024-53008": {"epss_score": 0.00116, "epss_percentile": 0.31046}, "CVE-2024-53009": {"epss_score": 0.00015, "epss_percentile": 0.02591}, "CVE-2024-53010": {"epss_score": 0.00017, "epss_percentile": 0.03192}, "CVE-2024-53011": {"epss_score": 0.00029, "epss_percentile": 0.07732}, "CVE-2024-53012": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-53013": {"epss_score": 0.0002, "epss_percentile": 0.04464}, "CVE-2024-53014": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-53015": {"epss_score": 0.0002, "epss_percentile": 0.04464}, "CVE-2024-53016": {"epss_score": 0.00015, "epss_percentile": 0.02504}, "CVE-2024-53017": {"epss_score": 0.0002, "epss_percentile": 0.04464}, "CVE-2024-53018": {"epss_score": 0.00015, "epss_percentile": 0.02504}, "CVE-2024-53019": {"epss_score": 0.0005, "epss_percentile": 0.15897}, "CVE-2024-53020": {"epss_score": 0.0005, "epss_percentile": 0.15897}, "CVE-2024-53021": {"epss_score": 0.0005, "epss_percentile": 0.15897}, "CVE-2024-53022": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-53023": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-53024": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-53025": {"epss_score": 0.00033, "epss_percentile": 0.09186}, "CVE-2024-53026": {"epss_score": 0.0005, "epss_percentile": 0.15897}, "CVE-2024-53027": {"epss_score": 0.00205, "epss_percentile": 0.42699}, "CVE-2024-53028": {"epss_score": 0.0002, "epss_percentile": 0.04621}, "CVE-2024-53029": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-53030": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-53031": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-53032": {"epss_score": 0.0002, "epss_percentile": 0.04621}, "CVE-2024-53033": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-53034": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2024-53041": {"epss_score": 0.00033, "epss_percentile": 0.09129}, "CVE-2024-53042": {"epss_score": 0.00011, "epss_percentile": 0.01028}, "CVE-2024-53043": {"epss_score": 0.00012, "epss_percentile": 0.01322}, "CVE-2024-53044": {"epss_score": 0.00012, "epss_percentile": 0.01392}, "CVE-2024-53045": {"epss_score": 0.00012, "epss_percentile": 0.01392}, "CVE-2024-53046": {"epss_score": 0.00013, "epss_percentile": 0.01601}, "CVE-2024-53047": {"epss_score": 9e-05, "epss_percentile": 0.00703}, "CVE-2024-53048": {"epss_score": 0.00012, "epss_percentile": 0.01392}, "CVE-2024-53049": {"epss_score": 0.00021, "epss_percentile": 0.04866}, "CVE-2024-53050": {"epss_score": 0.0001, "epss_percentile": 0.00753}, "CVE-2024-53051": {"epss_score": 0.0001, "epss_percentile": 0.00753}, "CVE-2024-53052": {"epss_score": 8e-05, "epss_percentile": 0.00513}, "CVE-2024-53053": {"epss_score": 0.00036, "epss_percentile": 0.10396}, "CVE-2024-53055": {"epss_score": 5e-05, "epss_percentile": 0.00194}, "CVE-2024-53056": {"epss_score": 0.0001, "epss_percentile": 0.00895}, "CVE-2024-53057": {"epss_score": 0.00015, "epss_percentile": 0.02215}, "CVE-2024-53058": {"epss_score": 9e-05, "epss_percentile": 0.00738}, "CVE-2024-53059": {"epss_score": 0.00014, "epss_percentile": 0.01759}, "CVE-2024-53060": {"epss_score": 0.00011, "epss_percentile": 0.01085}, "CVE-2024-53061": {"epss_score": 0.00014, "epss_percentile": 0.01759}, "CVE-2024-53062": {"epss_score": 0.00033, "epss_percentile": 0.09355}, "CVE-2024-53063": {"epss_score": 0.00016, "epss_percentile": 0.02702}, "CVE-2024-53064": {"epss_score": 0.00023, "epss_percentile": 0.05593}, "CVE-2024-53065": {"epss_score": 0.0006, "epss_percentile": 0.18969}, "CVE-2024-53066": {"epss_score": 0.00024, "epss_percentile": 0.05989}, "CVE-2024-53067": {"epss_score": 0.00021, "epss_percentile": 0.04914}, "CVE-2024-53068": {"epss_score": 0.00026, "epss_percentile": 0.06419}, "CVE-2024-53069": {"epss_score": 0.00053, "epss_percentile": 0.16945}, "CVE-2024-53070": {"epss_score": 0.00017, "epss_percentile": 0.03305}, "CVE-2024-53071": {"epss_score": 0.00031, "epss_percentile": 0.08497}, "CVE-2024-53072": {"epss_score": 0.00022, "epss_percentile": 0.05244}, "CVE-2024-53073": {"epss_score": 0.00016, "epss_percentile": 0.02634}, "CVE-2024-53074": {"epss_score": 0.00016, "epss_percentile": 0.02855}, "CVE-2024-53075": {"epss_score": 0.00035, "epss_percentile": 0.09939}, "CVE-2024-53076": {"epss_score": 0.0002, "epss_percentile": 0.04592}, "CVE-2024-53077": {"epss_score": 0.0002, "epss_percentile": 0.0454}, "CVE-2024-53078": {"epss_score": 0.00053, "epss_percentile": 0.16945}, "CVE-2024-53079": {"epss_score": 0.00016, "epss_percentile": 0.02746}, "CVE-2024-53080": {"epss_score": 0.00017, "epss_percentile": 0.03107}, "CVE-2024-53081": {"epss_score": 0.00032, "epss_percentile": 0.08846}, "CVE-2024-53082": {"epss_score": 0.00017, "epss_percentile": 0.03441}, "CVE-2024-53083": {"epss_score": 0.0002, "epss_percentile": 0.04631}, "CVE-2024-53084": {"epss_score": 0.00036, "epss_percentile": 0.10442}, "CVE-2024-53085": {"epss_score": 0.00016, "epss_percentile": 0.02746}, "CVE-2024-53086": {"epss_score": 0.00016, "epss_percentile": 0.02682}, "CVE-2024-53087": {"epss_score": 0.00041, "epss_percentile": 0.12463}, "CVE-2024-53088": {"epss_score": 0.00014, "epss_percentile": 0.01888}, "CVE-2024-53089": {"epss_score": 0.0001, "epss_percentile": 0.00796}, "CVE-2024-53090": {"epss_score": 4e-05, "epss_percentile": 0.00159}, "CVE-2024-53091": {"epss_score": 9e-05, "epss_percentile": 0.00736}, "CVE-2024-53092": {"epss_score": 0.00028, "epss_percentile": 0.0723}, "CVE-2024-53093": {"epss_score": 0.00014, "epss_percentile": 0.01997}, "CVE-2024-53094": {"epss_score": 0.00015, "epss_percentile": 0.02229}, "CVE-2024-53095": {"epss_score": 0.00013, "epss_percentile": 0.01689}, "CVE-2024-53096": {"epss_score": 9e-05, "epss_percentile": 0.00747}, "CVE-2024-53097": {"epss_score": 8e-05, "epss_percentile": 0.00479}, "CVE-2024-53098": {"epss_score": 0.00014, "epss_percentile": 0.01869}, "CVE-2024-53099": {"epss_score": 7e-05, "epss_percentile": 0.00338}, "CVE-2024-53100": {"epss_score": 8e-05, "epss_percentile": 0.00557}, "CVE-2024-53101": {"epss_score": 7e-05, "epss_percentile": 0.00382}, "CVE-2024-53103": {"epss_score": 0.00034, "epss_percentile": 0.09782}, "CVE-2024-53104": {"epss_score": 0.10061, "epss_percentile": 0.92837}, "CVE-2024-53105": {"epss_score": 0.00047, "epss_percentile": 0.14709}, "CVE-2024-53106": {"epss_score": 0.00036, "epss_percentile": 0.10488}, "CVE-2024-53107": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53108": {"epss_score": 0.00033, "epss_percentile": 0.09279}, "CVE-2024-53109": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-53110": {"epss_score": 0.00036, "epss_percentile": 0.10219}, "CVE-2024-53111": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53112": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-53113": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-53114": {"epss_score": 0.0003, "epss_percentile": 0.08148}, "CVE-2024-53115": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53116": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53117": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53118": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53119": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-53120": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-53121": {"epss_score": 0.00035, "epss_percentile": 0.09904}, "CVE-2024-53122": {"epss_score": 0.00037, "epss_percentile": 0.10648}, "CVE-2024-53123": {"epss_score": 0.00028, "epss_percentile": 0.07256}, "CVE-2024-53124": {"epss_score": 0.0007, "epss_percentile": 0.21804}, "CVE-2024-53125": {"epss_score": 0.00051, "epss_percentile": 0.16253}, "CVE-2024-53126": {"epss_score": 0.00025, "epss_percentile": 0.06236}, "CVE-2024-53127": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-53128": {"epss_score": 0.00073, "epss_percentile": 0.22597}, "CVE-2024-53129": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-53130": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-53131": {"epss_score": 0.00049, "epss_percentile": 0.15352}, "CVE-2024-53132": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53133": {"epss_score": 0.0004, "epss_percentile": 0.11875}, "CVE-2024-53134": {"epss_score": 0.00017, "epss_percentile": 0.03142}, "CVE-2024-53135": {"epss_score": 0.00044, "epss_percentile": 0.13583}, "CVE-2024-53136": {"epss_score": 0.00035, "epss_percentile": 0.09904}, "CVE-2024-53137": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53138": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-53139": {"epss_score": 0.00041, "epss_percentile": 0.12401}, "CVE-2024-53140": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-53141": {"epss_score": 0.00029, "epss_percentile": 0.07835}, "CVE-2024-53142": {"epss_score": 0.00034, "epss_percentile": 0.09554}, "CVE-2024-53143": {"epss_score": 0.00038, "epss_percentile": 0.11233}, "CVE-2024-53144": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2024-53145": {"epss_score": 0.00049, "epss_percentile": 0.15352}, "CVE-2024-53146": {"epss_score": 0.00037, "epss_percentile": 0.10662}, "CVE-2024-53147": {"epss_score": 0.00034, "epss_percentile": 0.09565}, "CVE-2024-53148": {"epss_score": 0.00037, "epss_percentile": 0.10763}, "CVE-2024-53149": {"epss_score": 0.00078, "epss_percentile": 0.23749}, "CVE-2024-53150": {"epss_score": 0.01865, "epss_percentile": 0.82604}, "CVE-2024-53151": {"epss_score": 0.00035, "epss_percentile": 0.09908}, "CVE-2024-53152": {"epss_score": 0.00032, "epss_percentile": 0.08867}, "CVE-2024-53153": {"epss_score": 0.00032, "epss_percentile": 0.08867}, "CVE-2024-53154": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-53155": {"epss_score": 0.00034, "epss_percentile": 0.09782}, "CVE-2024-53156": {"epss_score": 0.00044, "epss_percentile": 0.13429}, "CVE-2024-53157": {"epss_score": 0.00043, "epss_percentile": 0.1313}, "CVE-2024-53158": {"epss_score": 0.00033, "epss_percentile": 0.09127}, "CVE-2024-53160": {"epss_score": 0.00028, "epss_percentile": 0.07575}, "CVE-2024-53161": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-53162": {"epss_score": 0.00038, "epss_percentile": 0.11233}, "CVE-2024-53163": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-53164": {"epss_score": 0.00035, "epss_percentile": 0.10119}, "CVE-2024-53165": {"epss_score": 0.00046, "epss_percentile": 0.14132}, "CVE-2024-53166": {"epss_score": 0.00047, "epss_percentile": 0.14901}, "CVE-2024-53167": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-53168": {"epss_score": 0.00042, "epss_percentile": 0.12727}, "CVE-2024-53169": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-53170": {"epss_score": 0.00047, "epss_percentile": 0.14901}, "CVE-2024-53171": {"epss_score": 0.00019, "epss_percentile": 0.04394}, "CVE-2024-53172": {"epss_score": 0.00033, "epss_percentile": 0.09127}, "CVE-2024-53173": {"epss_score": 0.00034, "epss_percentile": 0.09782}, "CVE-2024-53174": {"epss_score": 0.00027, "epss_percentile": 0.06986}, "CVE-2024-53175": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-53176": {"epss_score": 0.00037, "epss_percentile": 0.10676}, "CVE-2024-53177": {"epss_score": 0.0003, "epss_percentile": 0.08163}, "CVE-2024-53178": {"epss_score": 0.00037, "epss_percentile": 0.10676}, "CVE-2024-53179": {"epss_score": 0.00039, "epss_percentile": 0.11482}, "CVE-2024-53180": {"epss_score": 0.00037, "epss_percentile": 0.10883}, "CVE-2024-53181": {"epss_score": 0.00026, "epss_percentile": 0.0642}, "CVE-2024-53182": {"epss_score": 0.00044, "epss_percentile": 0.135}, "CVE-2024-53183": {"epss_score": 0.00026, "epss_percentile": 0.0642}, "CVE-2024-53184": {"epss_score": 0.00026, "epss_percentile": 0.0642}, "CVE-2024-53185": {"epss_score": 0.00024, "epss_percentile": 0.06016}, "CVE-2024-53186": {"epss_score": 0.00039, "epss_percentile": 0.11592}, "CVE-2024-53187": {"epss_score": 0.00025, "epss_percentile": 0.06211}, "CVE-2024-53188": {"epss_score": 0.00037, "epss_percentile": 0.10676}, "CVE-2024-53189": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-53190": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-53191": {"epss_score": 0.00038, "epss_percentile": 0.11233}, "CVE-2024-53192": {"epss_score": 0.00035, "epss_percentile": 0.09914}, "CVE-2024-53193": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2024-53194": {"epss_score": 0.00034, "epss_percentile": 0.09782}, "CVE-2024-53195": {"epss_score": 0.00029, "epss_percentile": 0.07734}, "CVE-2024-53196": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-53197": {"epss_score": 0.02408, "epss_percentile": 0.84659}, "CVE-2024-53198": {"epss_score": 0.00032, "epss_percentile": 0.08858}, "CVE-2024-53199": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-53200": {"epss_score": 0.00037, "epss_percentile": 0.10676}, "CVE-2024-53201": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-53202": {"epss_score": 0.00037, "epss_percentile": 0.10676}, "CVE-2024-53203": {"epss_score": 0.00055, "epss_percentile": 0.17649}, "CVE-2024-53204": {"epss_score": 0.00036, "epss_percentile": 0.10219}, "CVE-2024-53205": {"epss_score": 0.00036, "epss_percentile": 0.10219}, "CVE-2024-53206": {"epss_score": 0.00048, "epss_percentile": 0.15111}, "CVE-2024-53207": {"epss_score": 0.00037, "epss_percentile": 0.10648}, "CVE-2024-53208": {"epss_score": 0.00048, "epss_percentile": 0.15111}, "CVE-2024-53209": {"epss_score": 0.00061, "epss_percentile": 0.19343}, "CVE-2024-53210": {"epss_score": 0.00037, "epss_percentile": 0.10883}, "CVE-2024-53211": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53212": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-53213": {"epss_score": 0.00048, "epss_percentile": 0.15111}, "CVE-2024-53214": {"epss_score": 0.00033, "epss_percentile": 0.09325}, "CVE-2024-53215": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-53216": {"epss_score": 0.00038, "epss_percentile": 0.11233}, "CVE-2024-53217": {"epss_score": 0.00043, "epss_percentile": 0.1313}, "CVE-2024-53218": {"epss_score": 0.00038, "epss_percentile": 0.11233}, "CVE-2024-53219": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-53220": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-53221": {"epss_score": 0.00048, "epss_percentile": 0.15276}, "CVE-2024-53222": {"epss_score": 0.00044, "epss_percentile": 0.13636}, "CVE-2024-53223": {"epss_score": 0.00037, "epss_percentile": 0.10676}, "CVE-2024-53224": {"epss_score": 0.00037, "epss_percentile": 0.10676}, "CVE-2024-53225": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53226": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-53227": {"epss_score": 0.00044, "epss_percentile": 0.13429}, "CVE-2024-53228": {"epss_score": 0.00031, "epss_percentile": 0.08647}, "CVE-2024-53229": {"epss_score": 0.00052, "epss_percentile": 0.16449}, "CVE-2024-53230": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-53231": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-53232": {"epss_score": 0.00031, "epss_percentile": 0.08647}, "CVE-2024-53233": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-53234": {"epss_score": 0.00052, "epss_percentile": 0.16449}, "CVE-2024-53235": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53236": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-53237": {"epss_score": 0.00046, "epss_percentile": 0.14132}, "CVE-2024-53238": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-53239": {"epss_score": 0.00044, "epss_percentile": 0.13429}, "CVE-2024-53240": {"epss_score": 0.00225, "epss_percentile": 0.45138}, "CVE-2024-53241": {"epss_score": 0.00043, "epss_percentile": 0.13169}, "CVE-2024-53242": {"epss_score": 0.00029, "epss_percentile": 0.07592}, "CVE-2024-53243": {"epss_score": 0.00129, "epss_percentile": 0.33132}, "CVE-2024-53244": {"epss_score": 0.00126, "epss_percentile": 0.32625}, "CVE-2024-53245": {"epss_score": 0.00116, "epss_percentile": 0.31159}, "CVE-2024-53246": {"epss_score": 0.00079, "epss_percentile": 0.23824}, "CVE-2024-53247": {"epss_score": 0.01273, "epss_percentile": 0.79087}, "CVE-2024-53253": {"epss_score": 0.00205, "epss_percentile": 0.42712}, "CVE-2024-53255": {"epss_score": 0.20585, "epss_percentile": 0.95382}, "CVE-2024-53256": {"epss_score": 0.00413, "epss_percentile": 0.61003}, "CVE-2024-53257": {"epss_score": 0.00036, "epss_percentile": 0.1021}, "CVE-2024-53258": {"epss_score": 0.00142, "epss_percentile": 0.35082}, "CVE-2024-53259": {"epss_score": 0.00279, "epss_percentile": 0.50975}, "CVE-2024-53260": {"epss_score": 0.00309, "epss_percentile": 0.53671}, "CVE-2024-53261": {"epss_score": 0.00182, "epss_percentile": 0.40149}, "CVE-2024-53262": {"epss_score": 0.00081, "epss_percentile": 0.24371}, "CVE-2024-53263": {"epss_score": 0.00067, "epss_percentile": 0.20999}, "CVE-2024-53264": {"epss_score": 0.00077, "epss_percentile": 0.23464}, "CVE-2024-53266": {"epss_score": 0.00124, "epss_percentile": 0.32359}, "CVE-2024-53267": {"epss_score": 0.00016, "epss_percentile": 0.02986}, "CVE-2024-53268": {"epss_score": 0.02621, "epss_percentile": 0.85256}, "CVE-2024-53269": {"epss_score": 5e-05, "epss_percentile": 0.00237}, "CVE-2024-53270": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2024-53271": {"epss_score": 5e-05, "epss_percentile": 0.0018}, "CVE-2024-53272": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-53273": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-53274": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-53275": {"epss_score": 0.00021, "epss_percentile": 0.0475}, "CVE-2024-53276": {"epss_score": 0.00035, "epss_percentile": 0.09861}, "CVE-2024-53277": {"epss_score": 0.00246, "epss_percentile": 0.47801}, "CVE-2024-53278": {"epss_score": 0.00101, "epss_percentile": 0.28707}, "CVE-2024-53279": {"epss_score": 0.00151, "epss_percentile": 0.36329}, "CVE-2024-53280": {"epss_score": 0.00151, "epss_percentile": 0.36329}, "CVE-2024-53281": {"epss_score": 0.00151, "epss_percentile": 0.36329}, "CVE-2024-53282": {"epss_score": 0.00151, "epss_percentile": 0.36329}, "CVE-2024-53283": {"epss_score": 0.00151, "epss_percentile": 0.36329}, "CVE-2024-53284": {"epss_score": 0.00151, "epss_percentile": 0.36329}, "CVE-2024-53285": {"epss_score": 0.00151, "epss_percentile": 0.36329}, "CVE-2024-53286": {"epss_score": 0.00231, "epss_percentile": 0.45832}, "CVE-2024-53287": {"epss_score": 0.00065, "epss_percentile": 0.20486}, "CVE-2024-53288": {"epss_score": 0.00065, "epss_percentile": 0.20486}, "CVE-2024-53289": {"epss_score": 0.00021, "epss_percentile": 0.04712}, "CVE-2024-53290": {"epss_score": 0.01171, "epss_percentile": 0.78213}, "CVE-2024-53291": {"epss_score": 0.00179, "epss_percentile": 0.39839}, "CVE-2024-53292": {"epss_score": 0.00024, "epss_percentile": 0.05671}, "CVE-2024-53295": {"epss_score": 0.00032, "epss_percentile": 0.0881}, "CVE-2024-53296": {"epss_score": 0.00194, "epss_percentile": 0.41554}, "CVE-2024-53298": {"epss_score": 0.00221, "epss_percentile": 0.44655}, "CVE-2024-53299": {"epss_score": 0.00839, "epss_percentile": 0.74189}, "CVE-2024-53303": {"epss_score": 0.00613, "epss_percentile": 0.69259}, "CVE-2024-53304": {"epss_score": 0.00223, "epss_percentile": 0.4496}, "CVE-2024-53305": {"epss_score": 0.00223, "epss_percentile": 0.4488}, "CVE-2024-53307": {"epss_score": 0.00109, "epss_percentile": 0.29925}, "CVE-2024-53309": {"epss_score": 0.00124, "epss_percentile": 0.32376}, "CVE-2024-53310": {"epss_score": 0.00124, "epss_percentile": 0.32376}, "CVE-2024-53311": {"epss_score": 0.00125, "epss_percentile": 0.32478}, "CVE-2024-53319": {"epss_score": 0.00196, "epss_percentile": 0.41787}, "CVE-2024-53320": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2024-53333": {"epss_score": 0.00426, "epss_percentile": 0.61735}, "CVE-2024-53334": {"epss_score": 0.00248, "epss_percentile": 0.4797}, "CVE-2024-53335": {"epss_score": 0.00113, "epss_percentile": 0.30693}, "CVE-2024-53345": {"epss_score": 0.06969, "epss_percentile": 0.91153}, "CVE-2024-53348": {"epss_score": 0.00074, "epss_percentile": 0.22874}, "CVE-2024-53349": {"epss_score": 0.00071, "epss_percentile": 0.2199}, "CVE-2024-53350": {"epss_score": 0.00071, "epss_percentile": 0.2199}, "CVE-2024-53351": {"epss_score": 0.00144, "epss_percentile": 0.3534}, "CVE-2024-53354": {"epss_score": 0.0013, "epss_percentile": 0.33314}, "CVE-2024-53355": {"epss_score": 0.00418, "epss_percentile": 0.61279}, "CVE-2024-53356": {"epss_score": 0.00488, "epss_percentile": 0.64828}, "CVE-2024-53357": {"epss_score": 0.00174, "epss_percentile": 0.39178}, "CVE-2024-53359": {"epss_score": 0.00062, "epss_percentile": 0.19734}, "CVE-2024-53364": {"epss_score": 0.00033, "epss_percentile": 0.09287}, "CVE-2024-53365": {"epss_score": 0.00053, "epss_percentile": 0.16979}, "CVE-2024-53375": {"epss_score": 0.42165, "epss_percentile": 0.97316}, "CVE-2024-53376": {"epss_score": 0.86965, "epss_percentile": 0.99405}, "CVE-2024-53379": {"epss_score": 0.00295, "epss_percentile": 0.52484}, "CVE-2024-53382": {"epss_score": 0.00083, "epss_percentile": 0.24795}, "CVE-2024-53384": {"epss_score": 0.0011, "epss_percentile": 0.30219}, "CVE-2024-53386": {"epss_score": 0.00083, "epss_percentile": 0.24795}, "CVE-2024-53387": {"epss_score": 0.00369, "epss_percentile": 0.58263}, "CVE-2024-53388": {"epss_score": 0.00369, "epss_percentile": 0.58263}, "CVE-2024-53406": {"epss_score": 0.00117, "epss_percentile": 0.3137}, "CVE-2024-53407": {"epss_score": 0.02709, "epss_percentile": 0.85481}, "CVE-2024-53408": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2024-53423": {"epss_score": 0.00033, "epss_percentile": 0.09165}, "CVE-2024-53425": {"epss_score": 0.00019, "epss_percentile": 0.04182}, "CVE-2024-53426": {"epss_score": 0.00042, "epss_percentile": 0.12594}, "CVE-2024-53427": {"epss_score": 0.00018, "epss_percentile": 0.03605}, "CVE-2024-53429": {"epss_score": 0.00026, "epss_percentile": 0.0641}, "CVE-2024-53432": {"epss_score": 0.00141, "epss_percentile": 0.34934}, "CVE-2024-53438": {"epss_score": 0.0021, "epss_percentile": 0.43442}, "CVE-2024-53441": {"epss_score": 0.00103, "epss_percentile": 0.28961}, "CVE-2024-53442": {"epss_score": 0.01551, "epss_percentile": 0.80988}, "CVE-2024-53450": {"epss_score": 0.00232, "epss_percentile": 0.45877}, "CVE-2024-53457": {"epss_score": 0.0191, "epss_percentile": 0.82825}, "CVE-2024-53458": {"epss_score": 0.0017, "epss_percentile": 0.3872}, "CVE-2024-53459": {"epss_score": 0.00025, "epss_percentile": 0.0615}, "CVE-2024-53470": {"epss_score": 0.00036, "epss_percentile": 0.10547}, "CVE-2024-53471": {"epss_score": 0.00029, "epss_percentile": 0.0794}, "CVE-2024-53472": {"epss_score": 0.0002, "epss_percentile": 0.04468}, "CVE-2024-53473": {"epss_score": 0.00181, "epss_percentile": 0.40119}, "CVE-2024-53476": {"epss_score": 0.00389, "epss_percentile": 0.59449}, "CVE-2024-53477": {"epss_score": 0.00114, "epss_percentile": 0.30818}, "CVE-2024-53480": {"epss_score": 0.00167, "epss_percentile": 0.38313}, "CVE-2024-53481": {"epss_score": 0.00044, "epss_percentile": 0.13523}, "CVE-2024-53484": {"epss_score": 0.00232, "epss_percentile": 0.45877}, "CVE-2024-53490": {"epss_score": 0.0041, "epss_percentile": 0.6079}, "CVE-2024-53494": {"epss_score": 0.00099, "epss_percentile": 0.28428}, "CVE-2024-53495": {"epss_score": 0.00096, "epss_percentile": 0.273}, "CVE-2024-53496": {"epss_score": 0.00162, "epss_percentile": 0.37666}, "CVE-2024-53499": {"epss_score": 0.00056, "epss_percentile": 0.17826}, "CVE-2024-53502": {"epss_score": 0.00085, "epss_percentile": 0.2517}, "CVE-2024-53504": {"epss_score": 0.0046, "epss_percentile": 0.63531}, "CVE-2024-53505": {"epss_score": 0.00075, "epss_percentile": 0.22958}, "CVE-2024-53506": {"epss_score": 0.00447, "epss_percentile": 0.6294}, "CVE-2024-53507": {"epss_score": 0.00434, "epss_percentile": 0.62313}, "CVE-2024-53522": {"epss_score": 0.00353, "epss_percentile": 0.57154}, "CVE-2024-53523": {"epss_score": 0.00556, "epss_percentile": 0.67511}, "CVE-2024-53526": {"epss_score": 0.00736, "epss_percentile": 0.72316}, "CVE-2024-53537": {"epss_score": 0.076, "epss_percentile": 0.91561}, "CVE-2024-53542": {"epss_score": 0.00125, "epss_percentile": 0.32581}, "CVE-2024-53543": {"epss_score": 0.00069, "epss_percentile": 0.21589}, "CVE-2024-53544": {"epss_score": 0.0024, "epss_percentile": 0.47188}, "CVE-2024-53552": {"epss_score": 0.00234, "epss_percentile": 0.46163}, "CVE-2024-53553": {"epss_score": 0.00213, "epss_percentile": 0.43896}, "CVE-2024-53554": {"epss_score": 0.01221, "epss_percentile": 0.78643}, "CVE-2024-53555": {"epss_score": 0.00249, "epss_percentile": 0.48075}, "CVE-2024-53556": {"epss_score": 0.00107, "epss_percentile": 0.29747}, "CVE-2024-53561": {"epss_score": 0.00349, "epss_percentile": 0.56906}, "CVE-2024-53563": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2024-53564": {"epss_score": 0.00129, "epss_percentile": 0.33161}, "CVE-2024-53566": {"epss_score": 0.00016, "epss_percentile": 0.02794}, "CVE-2024-53568": {"epss_score": 0.00036, "epss_percentile": 0.10362}, "CVE-2024-53569": {"epss_score": 0.00036, "epss_percentile": 0.10362}, "CVE-2024-53573": {"epss_score": 0.00166, "epss_percentile": 0.38251}, "CVE-2024-53580": {"epss_score": 0.00687, "epss_percentile": 0.71183}, "CVE-2024-53582": {"epss_score": 0.06988, "epss_percentile": 0.91165}, "CVE-2024-53584": {"epss_score": 0.11986, "epss_percentile": 0.93536}, "CVE-2024-53586": {"epss_score": 0.08199, "epss_percentile": 0.91926}, "CVE-2024-53588": {"epss_score": 0.00033, "epss_percentile": 0.09212}, "CVE-2024-53589": {"epss_score": 0.00046, "epss_percentile": 0.14177}, "CVE-2024-53591": {"epss_score": 0.00124, "epss_percentile": 0.32379}, "CVE-2024-53597": {"epss_score": 0.0004, "epss_percentile": 0.12076}, "CVE-2024-53599": {"epss_score": 0.00096, "epss_percentile": 0.2739}, "CVE-2024-53603": {"epss_score": 0.00113, "epss_percentile": 0.30719}, "CVE-2024-53604": {"epss_score": 0.00751, "epss_percentile": 0.72636}, "CVE-2024-53605": {"epss_score": 0.00146, "epss_percentile": 0.35612}, "CVE-2024-53614": {"epss_score": 0.00162, "epss_percentile": 0.37657}, "CVE-2024-53615": {"epss_score": 0.17962, "epss_percentile": 0.94933}, "CVE-2024-53617": {"epss_score": 0.01098, "epss_percentile": 0.77532}, "CVE-2024-53619": {"epss_score": 0.00036, "epss_percentile": 0.10527}, "CVE-2024-53620": {"epss_score": 0.00082, "epss_percentile": 0.2443}, "CVE-2024-53621": {"epss_score": 0.00074, "epss_percentile": 0.22689}, "CVE-2024-53623": {"epss_score": 0.00145, "epss_percentile": 0.35524}, "CVE-2024-53635": {"epss_score": 0.00074, "epss_percentile": 0.22877}, "CVE-2024-53636": {"epss_score": 0.00073, "epss_percentile": 0.22628}, "CVE-2024-53647": {"epss_score": 0.00137, "epss_percentile": 0.34258}, "CVE-2024-53648": {"epss_score": 0.00077, "epss_percentile": 0.2332}, "CVE-2024-53649": {"epss_score": 0.00112, "epss_percentile": 0.30552}, "CVE-2024-53651": {"epss_score": 0.00029, "epss_percentile": 0.07952}, "CVE-2024-53672": {"epss_score": 0.00181, "epss_percentile": 0.40123}, "CVE-2024-53673": {"epss_score": 0.00626, "epss_percentile": 0.69617}, "CVE-2024-53674": {"epss_score": 0.0162, "epss_percentile": 0.81383}, "CVE-2024-53675": {"epss_score": 0.20882, "epss_percentile": 0.95432}, "CVE-2024-53676": {"epss_score": 0.75837, "epss_percentile": 0.98866}, "CVE-2024-53677": {"epss_score": 0.87849, "epss_percentile": 0.99447}, "CVE-2024-53678": {"epss_score": 0.00061, "epss_percentile": 0.19425}, "CVE-2024-53679": {"epss_score": 0.00081, "epss_percentile": 0.24312}, "CVE-2024-53680": {"epss_score": 0.00027, "epss_percentile": 0.06823}, "CVE-2024-53681": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53682": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-53683": {"epss_score": 0.00037, "epss_percentile": 0.10927}, "CVE-2024-53684": {"epss_score": 0.00055, "epss_percentile": 0.17419}, "CVE-2024-53685": {"epss_score": 0.00055, "epss_percentile": 0.17465}, "CVE-2024-53687": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-53688": {"epss_score": 0.03336, "epss_percentile": 0.86935}, "CVE-2024-53690": {"epss_score": 0.00033, "epss_percentile": 0.09387}, "CVE-2024-53691": {"epss_score": 0.15199, "epss_percentile": 0.94382}, "CVE-2024-53692": {"epss_score": 0.00126, "epss_percentile": 0.32756}, "CVE-2024-53693": {"epss_score": 0.00151, "epss_percentile": 0.36339}, "CVE-2024-53694": {"epss_score": 0.00023, "epss_percentile": 0.05617}, "CVE-2024-53695": {"epss_score": 0.00172, "epss_percentile": 0.38908}, "CVE-2024-53696": {"epss_score": 0.00098, "epss_percentile": 0.27708}, "CVE-2024-53697": {"epss_score": 0.00151, "epss_percentile": 0.36224}, "CVE-2024-53698": {"epss_score": 0.00071, "epss_percentile": 0.22134}, "CVE-2024-53699": {"epss_score": 0.00151, "epss_percentile": 0.36224}, "CVE-2024-53700": {"epss_score": 0.00202, "epss_percentile": 0.42467}, "CVE-2024-53701": {"epss_score": 0.00038, "epss_percentile": 0.11155}, "CVE-2024-53702": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2024-53703": {"epss_score": 0.00455, "epss_percentile": 0.63284}, "CVE-2024-53704": {"epss_score": 0.93819, "epss_percentile": 0.99852}, "CVE-2024-53705": {"epss_score": 0.00064, "epss_percentile": 0.20111}, "CVE-2024-53706": {"epss_score": 0.00035, "epss_percentile": 0.09977}, "CVE-2024-53707": {"epss_score": 0.0004, "epss_percentile": 0.12088}, "CVE-2024-53708": {"epss_score": 0.00179, "epss_percentile": 0.39828}, "CVE-2024-53709": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53710": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53711": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53712": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53713": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53714": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53715": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53716": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53717": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53718": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-53719": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53720": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53721": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53722": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53723": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53724": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53725": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-53726": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53727": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53728": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53729": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-53730": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53731": {"epss_score": 0.00061, "epss_percentile": 0.19387}, "CVE-2024-53732": {"epss_score": 0.00045, "epss_percentile": 0.13715}, "CVE-2024-53733": {"epss_score": 0.00061, "epss_percentile": 0.19373}, "CVE-2024-53734": {"epss_score": 0.0003, "epss_percentile": 0.08091}, "CVE-2024-53735": {"epss_score": 0.00028, "epss_percentile": 0.07317}, "CVE-2024-53736": {"epss_score": 0.0003, "epss_percentile": 0.08091}, "CVE-2024-53737": {"epss_score": 0.00056, "epss_percentile": 0.17763}, "CVE-2024-53738": {"epss_score": 0.00039, "epss_percentile": 0.11841}, "CVE-2024-53739": {"epss_score": 0.01014, "epss_percentile": 0.76655}, "CVE-2024-53740": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-53741": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53742": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-53743": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53744": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53745": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53746": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53747": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53748": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53749": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53750": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53751": {"epss_score": 0.00045, "epss_percentile": 0.13743}, "CVE-2024-53752": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53753": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53754": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53755": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53756": {"epss_score": 0.00046, "epss_percentile": 0.1412}, "CVE-2024-53757": {"epss_score": 0.00046, "epss_percentile": 0.1412}, "CVE-2024-53758": {"epss_score": 0.00046, "epss_percentile": 0.1412}, "CVE-2024-53759": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-53760": {"epss_score": 0.00046, "epss_percentile": 0.1412}, "CVE-2024-53761": {"epss_score": 0.0004, "epss_percentile": 0.12088}, "CVE-2024-53762": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53763": {"epss_score": 0.00046, "epss_percentile": 0.1412}, "CVE-2024-53764": {"epss_score": 0.00046, "epss_percentile": 0.1412}, "CVE-2024-53765": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53766": {"epss_score": 0.00046, "epss_percentile": 0.1412}, "CVE-2024-53767": {"epss_score": 0.00046, "epss_percentile": 0.1412}, "CVE-2024-53768": {"epss_score": 0.00095, "epss_percentile": 0.2722}, "CVE-2024-53769": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53770": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53771": {"epss_score": 0.00046, "epss_percentile": 0.1412}, "CVE-2024-53772": {"epss_score": 0.00046, "epss_percentile": 0.1412}, "CVE-2024-53773": {"epss_score": 0.00041, "epss_percentile": 0.12416}, "CVE-2024-53774": {"epss_score": 0.00041, "epss_percentile": 0.12416}, "CVE-2024-53775": {"epss_score": 0.0004, "epss_percentile": 0.12088}, "CVE-2024-53776": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53777": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53778": {"epss_score": 0.00035, "epss_percentile": 0.09815}, "CVE-2024-53779": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53780": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53781": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53782": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53783": {"epss_score": 0.00042, "epss_percentile": 0.12573}, "CVE-2024-53784": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-53785": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-53786": {"epss_score": 0.00038, "epss_percentile": 0.11185}, "CVE-2024-53787": {"epss_score": 0.00046, "epss_percentile": 0.1412}, "CVE-2024-53788": {"epss_score": 0.00029, "epss_percentile": 0.07704}, "CVE-2024-53789": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-53790": {"epss_score": 0.00398, "epss_percentile": 0.60087}, "CVE-2024-53791": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53792": {"epss_score": 0.00248, "epss_percentile": 0.47985}, "CVE-2024-53793": {"epss_score": 0.00047, "epss_percentile": 0.14667}, "CVE-2024-53794": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53795": {"epss_score": 0.00179, "epss_percentile": 0.39828}, "CVE-2024-53796": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-53797": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-53798": {"epss_score": 0.00075, "epss_percentile": 0.22984}, "CVE-2024-53799": {"epss_score": 0.00102, "epss_percentile": 0.28777}, "CVE-2024-53800": {"epss_score": 0.00816, "epss_percentile": 0.73802}, "CVE-2024-53801": {"epss_score": 0.00055, "epss_percentile": 0.17605}, "CVE-2024-53802": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-53803": {"epss_score": 0.00316, "epss_percentile": 0.54234}, "CVE-2024-53804": {"epss_score": 0.00322, "epss_percentile": 0.54749}, "CVE-2024-53805": {"epss_score": 0.00407, "epss_percentile": 0.60573}, "CVE-2024-53806": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-53807": {"epss_score": 0.00248, "epss_percentile": 0.47985}, "CVE-2024-53808": {"epss_score": 0.00206, "epss_percentile": 0.43045}, "CVE-2024-53809": {"epss_score": 0.0004, "epss_percentile": 0.12112}, "CVE-2024-53810": {"epss_score": 0.00186, "epss_percentile": 0.40647}, "CVE-2024-53811": {"epss_score": 0.00134, "epss_percentile": 0.33873}, "CVE-2024-53812": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-53813": {"epss_score": 0.00091, "epss_percentile": 0.26387}, "CVE-2024-53814": {"epss_score": 0.00292, "epss_percentile": 0.52255}, "CVE-2024-53815": {"epss_score": 0.00254, "epss_percentile": 0.48509}, "CVE-2024-53816": {"epss_score": 0.00179, "epss_percentile": 0.39772}, "CVE-2024-53817": {"epss_score": 0.00247, "epss_percentile": 0.47826}, "CVE-2024-53818": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53819": {"epss_score": 0.00131, "epss_percentile": 0.33471}, "CVE-2024-53820": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-53821": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-53822": {"epss_score": 0.00459, "epss_percentile": 0.63472}, "CVE-2024-53823": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-53824": {"epss_score": 0.00584, "epss_percentile": 0.68368}, "CVE-2024-53825": {"epss_score": 0.00242, "epss_percentile": 0.474}, "CVE-2024-53826": {"epss_score": 0.00131, "epss_percentile": 0.33471}, "CVE-2024-53827": {"epss_score": 0.00089, "epss_percentile": 0.258}, "CVE-2024-53829": {"epss_score": 0.00086, "epss_percentile": 0.25408}, "CVE-2024-53832": {"epss_score": 0.00058, "epss_percentile": 0.18584}, "CVE-2024-53833": {"epss_score": 0.00011, "epss_percentile": 0.01079}, "CVE-2024-53834": {"epss_score": 0.00143, "epss_percentile": 0.35207}, "CVE-2024-53835": {"epss_score": 0.0001, "epss_percentile": 0.00818}, "CVE-2024-53836": {"epss_score": 0.0001, "epss_percentile": 0.00874}, "CVE-2024-53837": {"epss_score": 0.00011, "epss_percentile": 0.01079}, "CVE-2024-53838": {"epss_score": 0.00011, "epss_percentile": 0.01079}, "CVE-2024-53839": {"epss_score": 0.00012, "epss_percentile": 0.01411}, "CVE-2024-53840": {"epss_score": 0.0001, "epss_percentile": 0.00818}, "CVE-2024-53841": {"epss_score": 0.0001, "epss_percentile": 0.00818}, "CVE-2024-53842": {"epss_score": 0.00268, "epss_percentile": 0.50086}, "CVE-2024-53843": {"epss_score": 0.00085, "epss_percentile": 0.25191}, "CVE-2024-53844": {"epss_score": 0.00054, "epss_percentile": 0.17342}, "CVE-2024-53845": {"epss_score": 0.00277, "epss_percentile": 0.50781}, "CVE-2024-53846": {"epss_score": 0.0012, "epss_percentile": 0.3179}, "CVE-2024-53847": {"epss_score": 0.00302, "epss_percentile": 0.53096}, "CVE-2024-53848": {"epss_score": 0.00047, "epss_percentile": 0.14785}, "CVE-2024-53849": {"epss_score": 0.00105, "epss_percentile": 0.29299}, "CVE-2024-53850": {"epss_score": 0.00643, "epss_percentile": 0.70062}, "CVE-2024-53851": {"epss_score": 0.00316, "epss_percentile": 0.54233}, "CVE-2024-53855": {"epss_score": 0.00189, "epss_percentile": 0.40975}, "CVE-2024-53856": {"epss_score": 0.00083, "epss_percentile": 0.24822}, "CVE-2024-53857": {"epss_score": 0.00301, "epss_percentile": 0.52996}, "CVE-2024-53858": {"epss_score": 0.00042, "epss_percentile": 0.12817}, "CVE-2024-53859": {"epss_score": 0.00036, "epss_percentile": 0.1036}, "CVE-2024-53860": {"epss_score": 0.00055, "epss_percentile": 0.17601}, "CVE-2024-53861": {"epss_score": 0.00734, "epss_percentile": 0.72246}, "CVE-2024-53862": {"epss_score": 0.00068, "epss_percentile": 0.21318}, "CVE-2024-53863": {"epss_score": 0.00085, "epss_percentile": 0.25134}, "CVE-2024-53864": {"epss_score": 0.00236, "epss_percentile": 0.46443}, "CVE-2024-53865": {"epss_score": 0.00017, "epss_percentile": 0.03418}, "CVE-2024-53866": {"epss_score": 0.00244, "epss_percentile": 0.47586}, "CVE-2024-53867": {"epss_score": 0.00042, "epss_percentile": 0.12703}, "CVE-2024-53868": {"epss_score": 0.00501, "epss_percentile": 0.65333}, "CVE-2024-53869": {"epss_score": 0.0005, "epss_percentile": 0.15847}, "CVE-2024-53870": {"epss_score": 0.0003, "epss_percentile": 0.082}, "CVE-2024-53871": {"epss_score": 0.0003, "epss_percentile": 0.082}, "CVE-2024-53872": {"epss_score": 0.0003, "epss_percentile": 0.082}, "CVE-2024-53873": {"epss_score": 0.0003, "epss_percentile": 0.082}, "CVE-2024-53874": {"epss_score": 0.0003, "epss_percentile": 0.082}, "CVE-2024-53875": {"epss_score": 0.0003, "epss_percentile": 0.082}, "CVE-2024-53876": {"epss_score": 0.0003, "epss_percentile": 0.082}, "CVE-2024-53877": {"epss_score": 0.0003, "epss_percentile": 0.082}, "CVE-2024-53878": {"epss_score": 0.0003, "epss_percentile": 0.08283}, "CVE-2024-53879": {"epss_score": 0.0003, "epss_percentile": 0.08283}, "CVE-2024-53880": {"epss_score": 0.00045, "epss_percentile": 0.14055}, "CVE-2024-53881": {"epss_score": 0.00034, "epss_percentile": 0.09582}, "CVE-2024-53899": {"epss_score": 0.00122, "epss_percentile": 0.32131}, "CVE-2024-53900": {"epss_score": 0.61214, "epss_percentile": 0.98239}, "CVE-2024-53901": {"epss_score": 0.00057, "epss_percentile": 0.18162}, "CVE-2024-53907": {"epss_score": 0.00604, "epss_percentile": 0.68956}, "CVE-2024-53908": {"epss_score": 0.00673, "epss_percentile": 0.70829}, "CVE-2024-53909": {"epss_score": 0.04644, "epss_percentile": 0.88957}, "CVE-2024-53910": {"epss_score": 0.04644, "epss_percentile": 0.88957}, "CVE-2024-53911": {"epss_score": 0.04644, "epss_percentile": 0.88957}, "CVE-2024-53912": {"epss_score": 0.04433, "epss_percentile": 0.88681}, "CVE-2024-53913": {"epss_score": 0.04433, "epss_percentile": 0.88681}, "CVE-2024-53914": {"epss_score": 0.04433, "epss_percentile": 0.88681}, "CVE-2024-53915": {"epss_score": 0.05104, "epss_percentile": 0.89504}, "CVE-2024-53916": {"epss_score": 0.00138, "epss_percentile": 0.34464}, "CVE-2024-53919": {"epss_score": 0.00184, "epss_percentile": 0.40416}, "CVE-2024-53920": {"epss_score": 0.00036, "epss_percentile": 0.10294}, "CVE-2024-53921": {"epss_score": 0.00091, "epss_percentile": 0.26231}, "CVE-2024-53923": {"epss_score": 0.00262, "epss_percentile": 0.49403}, "CVE-2024-53924": {"epss_score": 0.00476, "epss_percentile": 0.64289}, "CVE-2024-53930": {"epss_score": 0.00181, "epss_percentile": 0.4007}, "CVE-2024-53931": {"epss_score": 0.00136, "epss_percentile": 0.34058}, "CVE-2024-53932": {"epss_score": 0.00119, "epss_percentile": 0.3155}, "CVE-2024-53933": {"epss_score": 0.00056, "epss_percentile": 0.17951}, "CVE-2024-53934": {"epss_score": 0.00033, "epss_percentile": 0.09246}, "CVE-2024-53935": {"epss_score": 0.00128, "epss_percentile": 0.33038}, "CVE-2024-53936": {"epss_score": 0.00049, "epss_percentile": 0.15626}, "CVE-2024-53937": {"epss_score": 0.00047, "epss_percentile": 0.14874}, "CVE-2024-53938": {"epss_score": 0.00072, "epss_percentile": 0.22462}, "CVE-2024-53939": {"epss_score": 0.01102, "epss_percentile": 0.77586}, "CVE-2024-53940": {"epss_score": 0.00546, "epss_percentile": 0.67219}, "CVE-2024-53941": {"epss_score": 0.00165, "epss_percentile": 0.3808}, "CVE-2024-53942": {"epss_score": 0.00169, "epss_percentile": 0.38631}, "CVE-2024-53943": {"epss_score": 0.00098, "epss_percentile": 0.27785}, "CVE-2024-53944": {"epss_score": 0.01943, "epss_percentile": 0.82992}, "CVE-2024-53945": {"epss_score": 0.00415, "epss_percentile": 0.61112}, "CVE-2024-53946": {"epss_score": 0.00077, "epss_percentile": 0.23362}, "CVE-2024-53947": {"epss_score": 0.00344, "epss_percentile": 0.56538}, "CVE-2024-53948": {"epss_score": 0.00812, "epss_percentile": 0.73748}, "CVE-2024-53949": {"epss_score": 0.00626, "epss_percentile": 0.69599}, "CVE-2024-53951": {"epss_score": 0.00064, "epss_percentile": 0.20358}, "CVE-2024-53952": {"epss_score": 0.00037, "epss_percentile": 0.1064}, "CVE-2024-53953": {"epss_score": 0.0005, "epss_percentile": 0.15977}, "CVE-2024-53954": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-53955": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-53956": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-53957": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-53958": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-53959": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2024-53960": {"epss_score": 0.00245, "epss_percentile": 0.47661}, "CVE-2024-53961": {"epss_score": 0.04123, "epss_percentile": 0.88286}, "CVE-2024-53962": {"epss_score": 0.00167, "epss_percentile": 0.38337}, "CVE-2024-53963": {"epss_score": 0.01386, "epss_percentile": 0.79914}, "CVE-2024-53964": {"epss_score": 0.00167, "epss_percentile": 0.38337}, "CVE-2024-53965": {"epss_score": 0.01386, "epss_percentile": 0.79914}, "CVE-2024-53966": {"epss_score": 0.00474, "epss_percentile": 0.64167}, "CVE-2024-53967": {"epss_score": 0.00372, "epss_percentile": 0.58462}, "CVE-2024-53968": {"epss_score": 0.00372, "epss_percentile": 0.58462}, "CVE-2024-53969": {"epss_score": 0.00372, "epss_percentile": 0.58462}, "CVE-2024-53970": {"epss_score": 0.00071, "epss_percentile": 0.22017}, "CVE-2024-53974": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-53975": {"epss_score": 0.00071, "epss_percentile": 0.22085}, "CVE-2024-53976": {"epss_score": 0.00228, "epss_percentile": 0.45546}, "CVE-2024-53977": {"epss_score": 0.00022, "epss_percentile": 0.05171}, "CVE-2024-53979": {"epss_score": 0.00015, "epss_percentile": 0.02401}, "CVE-2024-53980": {"epss_score": 0.00552, "epss_percentile": 0.67399}, "CVE-2024-53981": {"epss_score": 0.00346, "epss_percentile": 0.56642}, "CVE-2024-53982": {"epss_score": 0.00179, "epss_percentile": 0.3977}, "CVE-2024-53983": {"epss_score": 0.00067, "epss_percentile": 0.21069}, "CVE-2024-53984": {"epss_score": 0.00161, "epss_percentile": 0.37567}, "CVE-2024-53985": {"epss_score": 0.00333, "epss_percentile": 0.55638}, "CVE-2024-53986": {"epss_score": 0.0024, "epss_percentile": 0.47205}, "CVE-2024-53987": {"epss_score": 0.0024, "epss_percentile": 0.47205}, "CVE-2024-53988": {"epss_score": 0.0024, "epss_percentile": 0.47205}, "CVE-2024-53989": {"epss_score": 0.0024, "epss_percentile": 0.47205}, "CVE-2024-53990": {"epss_score": 0.00216, "epss_percentile": 0.44227}, "CVE-2024-53991": {"epss_score": 0.38334, "epss_percentile": 0.97096}, "CVE-2024-53992": {"epss_score": 0.00302, "epss_percentile": 0.53096}, "CVE-2024-53994": {"epss_score": 0.00145, "epss_percentile": 0.35355}, "CVE-2024-53995": {"epss_score": 0.00425, "epss_percentile": 0.61711}, "CVE-2024-53999": {"epss_score": 0.00721, "epss_percentile": 0.71985}, "CVE-2024-54000": {"epss_score": 0.00152, "epss_percentile": 0.36446}, "CVE-2024-54001": {"epss_score": 0.00077, "epss_percentile": 0.23469}, "CVE-2024-54002": {"epss_score": 0.00131, "epss_percentile": 0.3339}, "CVE-2024-54003": {"epss_score": 0.35082, "epss_percentile": 0.96886}, "CVE-2024-54004": {"epss_score": 0.00693, "epss_percentile": 0.71324}, "CVE-2024-54005": {"epss_score": 0.00022, "epss_percentile": 0.05027}, "CVE-2024-54006": {"epss_score": 0.00542, "epss_percentile": 0.67072}, "CVE-2024-54007": {"epss_score": 0.00542, "epss_percentile": 0.67072}, "CVE-2024-54008": {"epss_score": 0.00719, "epss_percentile": 0.71946}, "CVE-2024-54009": {"epss_score": 0.00041, "epss_percentile": 0.12371}, "CVE-2024-54010": {"epss_score": 0.00034, "epss_percentile": 0.09742}, "CVE-2024-54014": {"epss_score": 0.00065, "epss_percentile": 0.20434}, "CVE-2024-54015": {"epss_score": 0.00149, "epss_percentile": 0.36037}, "CVE-2024-54016": {"epss_score": 0.00374, "epss_percentile": 0.58533}, "CVE-2024-54018": {"epss_score": 0.0016, "epss_percentile": 0.3748}, "CVE-2024-54019": {"epss_score": 0.00022, "epss_percentile": 0.05057}, "CVE-2024-54020": {"epss_score": 0.00034, "epss_percentile": 0.09463}, "CVE-2024-54021": {"epss_score": 0.00093, "epss_percentile": 0.26664}, "CVE-2024-54024": {"epss_score": 0.00282, "epss_percentile": 0.51223}, "CVE-2024-54025": {"epss_score": 0.00046, "epss_percentile": 0.14187}, "CVE-2024-54026": {"epss_score": 0.00053, "epss_percentile": 0.1675}, "CVE-2024-54027": {"epss_score": 0.00026, "epss_percentile": 0.06663}, "CVE-2024-54028": {"epss_score": 0.00037, "epss_percentile": 0.10918}, "CVE-2024-54030": {"epss_score": 0.00039, "epss_percentile": 0.11666}, "CVE-2024-54031": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2024-54032": {"epss_score": 0.01114, "epss_percentile": 0.77698}, "CVE-2024-54034": {"epss_score": 0.01114, "epss_percentile": 0.77698}, "CVE-2024-54036": {"epss_score": 0.01114, "epss_percentile": 0.77698}, "CVE-2024-54037": {"epss_score": 0.08534, "epss_percentile": 0.92107}, "CVE-2024-54038": {"epss_score": 0.00141, "epss_percentile": 0.34814}, "CVE-2024-54039": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-54040": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-54041": {"epss_score": 0.00086, "epss_percentile": 0.25272}, "CVE-2024-54042": {"epss_score": 0.00491, "epss_percentile": 0.64964}, "CVE-2024-54043": {"epss_score": 0.00491, "epss_percentile": 0.64964}, "CVE-2024-54044": {"epss_score": 0.00491, "epss_percentile": 0.64964}, "CVE-2024-54045": {"epss_score": 0.00491, "epss_percentile": 0.64964}, "CVE-2024-54046": {"epss_score": 0.00491, "epss_percentile": 0.64964}, "CVE-2024-54047": {"epss_score": 0.00491, "epss_percentile": 0.64964}, "CVE-2024-54048": {"epss_score": 0.00491, "epss_percentile": 0.64964}, "CVE-2024-54049": {"epss_score": 0.00226, "epss_percentile": 0.45256}, "CVE-2024-54050": {"epss_score": 0.00123, "epss_percentile": 0.32206}, "CVE-2024-54051": {"epss_score": 0.00123, "epss_percentile": 0.32206}, "CVE-2024-54082": {"epss_score": 0.0263, "epss_percentile": 0.85277}, "CVE-2024-54083": {"epss_score": 0.00551, "epss_percentile": 0.6737}, "CVE-2024-54084": {"epss_score": 0.00019, "epss_percentile": 0.04078}, "CVE-2024-54085": {"epss_score": 0.10474, "epss_percentile": 0.92998}, "CVE-2024-54089": {"epss_score": 0.00045, "epss_percentile": 0.13745}, "CVE-2024-54090": {"epss_score": 0.00106, "epss_percentile": 0.2951}, "CVE-2024-54091": {"epss_score": 0.00029, "epss_percentile": 0.07592}, "CVE-2024-54092": {"epss_score": 0.00224, "epss_percentile": 0.45015}, "CVE-2024-54093": {"epss_score": 0.00033, "epss_percentile": 0.09179}, "CVE-2024-54094": {"epss_score": 0.00033, "epss_percentile": 0.09179}, "CVE-2024-54095": {"epss_score": 0.00033, "epss_percentile": 0.09179}, "CVE-2024-54096": {"epss_score": 0.00012, "epss_percentile": 0.01327}, "CVE-2024-54097": {"epss_score": 0.00135, "epss_percentile": 0.33944}, "CVE-2024-54098": {"epss_score": 0.00105, "epss_percentile": 0.29342}, "CVE-2024-54099": {"epss_score": 0.00018, "epss_percentile": 0.03894}, "CVE-2024-54100": {"epss_score": 0.00057, "epss_percentile": 0.17985}, "CVE-2024-54101": {"epss_score": 0.00021, "epss_percentile": 0.04703}, "CVE-2024-54102": {"epss_score": 0.00039, "epss_percentile": 0.11577}, "CVE-2024-54103": {"epss_score": 0.00052, "epss_percentile": 0.16482}, "CVE-2024-54104": {"epss_score": 0.00069, "epss_percentile": 0.21605}, "CVE-2024-54105": {"epss_score": 0.00062, "epss_percentile": 0.19679}, "CVE-2024-54106": {"epss_score": 0.00071, "epss_percentile": 0.2208}, "CVE-2024-54107": {"epss_score": 0.00083, "epss_percentile": 0.24819}, "CVE-2024-54108": {"epss_score": 0.00136, "epss_percentile": 0.34061}, "CVE-2024-54109": {"epss_score": 0.00136, "epss_percentile": 0.34061}, "CVE-2024-54110": {"epss_score": 0.00059, "epss_percentile": 0.18877}, "CVE-2024-54111": {"epss_score": 0.0003, "epss_percentile": 0.08296}, "CVE-2024-54112": {"epss_score": 0.00044, "epss_percentile": 0.13679}, "CVE-2024-54113": {"epss_score": 0.00052, "epss_percentile": 0.1639}, "CVE-2024-54114": {"epss_score": 0.0004, "epss_percentile": 0.11881}, "CVE-2024-54115": {"epss_score": 0.00083, "epss_percentile": 0.24819}, "CVE-2024-54116": {"epss_score": 0.00083, "epss_percentile": 0.24819}, "CVE-2024-54117": {"epss_score": 0.00069, "epss_percentile": 0.21605}, "CVE-2024-54119": {"epss_score": 0.00069, "epss_percentile": 0.21605}, "CVE-2024-54120": {"epss_score": 0.00031, "epss_percentile": 0.08448}, "CVE-2024-54121": {"epss_score": 0.00057, "epss_percentile": 0.18234}, "CVE-2024-54122": {"epss_score": 0.00013, "epss_percentile": 0.01521}, "CVE-2024-54123": {"epss_score": 0.00066, "epss_percentile": 0.20928}, "CVE-2024-54124": {"epss_score": 0.00125, "epss_percentile": 0.3262}, "CVE-2024-54125": {"epss_score": 0.00027, "epss_percentile": 0.06844}, "CVE-2024-54126": {"epss_score": 0.00013, "epss_percentile": 0.0149}, "CVE-2024-54127": {"epss_score": 0.00025, "epss_percentile": 0.06206}, "CVE-2024-54128": {"epss_score": 0.0032, "epss_percentile": 0.54574}, "CVE-2024-54129": {"epss_score": 0.00204, "epss_percentile": 0.42639}, "CVE-2024-54130": {"epss_score": 0.00175, "epss_percentile": 0.39338}, "CVE-2024-54131": {"epss_score": 0.00029, "epss_percentile": 0.07947}, "CVE-2024-54132": {"epss_score": 0.00176, "epss_percentile": 0.39378}, "CVE-2024-54133": {"epss_score": 0.00172, "epss_percentile": 0.38979}, "CVE-2024-54134": {"epss_score": 0.00204, "epss_percentile": 0.42639}, "CVE-2024-54135": {"epss_score": 0.00427, "epss_percentile": 0.61776}, "CVE-2024-54136": {"epss_score": 0.00438, "epss_percentile": 0.62567}, "CVE-2024-54137": {"epss_score": 0.00145, "epss_percentile": 0.3535}, "CVE-2024-54138": {"epss_score": 0.00679, "epss_percentile": 0.71024}, "CVE-2024-54139": {"epss_score": 0.00116, "epss_percentile": 0.3118}, "CVE-2024-54140": {"epss_score": 0.00054, "epss_percentile": 0.17168}, "CVE-2024-54141": {"epss_score": 0.00229, "epss_percentile": 0.45615}, "CVE-2024-54142": {"epss_score": 0.00151, "epss_percentile": 0.36321}, "CVE-2024-54143": {"epss_score": 0.03242, "epss_percentile": 0.86735}, "CVE-2024-54145": {"epss_score": 0.00744, "epss_percentile": 0.72504}, "CVE-2024-54146": {"epss_score": 0.01036, "epss_percentile": 0.76907}, "CVE-2024-54147": {"epss_score": 0.00055, "epss_percentile": 0.17552}, "CVE-2024-54148": {"epss_score": 0.00823, "epss_percentile": 0.73925}, "CVE-2024-54149": {"epss_score": 0.0018, "epss_percentile": 0.39869}, "CVE-2024-54150": {"epss_score": 0.0009, "epss_percentile": 0.26061}, "CVE-2024-54151": {"epss_score": 0.003, "epss_percentile": 0.52958}, "CVE-2024-54152": {"epss_score": 0.27636, "epss_percentile": 0.96267}, "CVE-2024-54153": {"epss_score": 2e-05, "epss_percentile": 0.00035}, "CVE-2024-54154": {"epss_score": 0.00103, "epss_percentile": 0.28923}, "CVE-2024-54155": {"epss_score": 2e-05, "epss_percentile": 0.0002}, "CVE-2024-54156": {"epss_score": 5e-05, "epss_percentile": 0.00184}, "CVE-2024-54157": {"epss_score": 4e-05, "epss_percentile": 0.00164}, "CVE-2024-54158": {"epss_score": 2e-05, "epss_percentile": 0.00032}, "CVE-2024-54159": {"epss_score": 0.00029, "epss_percentile": 0.07586}, "CVE-2024-54160": {"epss_score": 0.02861, "epss_percentile": 0.85851}, "CVE-2024-54169": {"epss_score": 0.00171, "epss_percentile": 0.38781}, "CVE-2024-54170": {"epss_score": 0.00019, "epss_percentile": 0.04158}, "CVE-2024-54171": {"epss_score": 0.00163, "epss_percentile": 0.37819}, "CVE-2024-54172": {"epss_score": 0.00012, "epss_percentile": 0.01305}, "CVE-2024-54173": {"epss_score": 0.00017, "epss_percentile": 0.03226}, "CVE-2024-54175": {"epss_score": 0.00019, "epss_percentile": 0.04158}, "CVE-2024-54176": {"epss_score": 0.00074, "epss_percentile": 0.22741}, "CVE-2024-54179": {"epss_score": 0.00055, "epss_percentile": 0.17485}, "CVE-2024-54181": {"epss_score": 0.00663, "epss_percentile": 0.70619}, "CVE-2024-54183": {"epss_score": 0.00019, "epss_percentile": 0.04356}, "CVE-2024-54188": {"epss_score": 0.00067, "epss_percentile": 0.21072}, "CVE-2024-54189": {"epss_score": 0.00057, "epss_percentile": 0.18167}, "CVE-2024-54191": {"epss_score": 0.00028, "epss_percentile": 0.07235}, "CVE-2024-54193": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-54197": {"epss_score": 0.00119, "epss_percentile": 0.31579}, "CVE-2024-54198": {"epss_score": 0.00153, "epss_percentile": 0.36538}, "CVE-2024-54205": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54206": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-54207": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-54208": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54209": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54210": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54211": {"epss_score": 0.00057, "epss_percentile": 0.18155}, "CVE-2024-54212": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-54213": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54214": {"epss_score": 0.00459, "epss_percentile": 0.63472}, "CVE-2024-54215": {"epss_score": 0.00245, "epss_percentile": 0.4768}, "CVE-2024-54216": {"epss_score": 0.00328, "epss_percentile": 0.55168}, "CVE-2024-54217": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-54218": {"epss_score": 0.00125, "epss_percentile": 0.32502}, "CVE-2024-54219": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54220": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54221": {"epss_score": 0.00245, "epss_percentile": 0.4768}, "CVE-2024-54223": {"epss_score": 0.00099, "epss_percentile": 0.2835}, "CVE-2024-54224": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-54225": {"epss_score": 0.00584, "epss_percentile": 0.68368}, "CVE-2024-54226": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54227": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-54228": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54229": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-54230": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54231": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54232": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54233": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54234": {"epss_score": 0.00261, "epss_percentile": 0.49252}, "CVE-2024-54235": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54236": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54237": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54238": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54239": {"epss_score": 0.01031, "epss_percentile": 0.76856}, "CVE-2024-54240": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54241": {"epss_score": 0.00062, "epss_percentile": 0.19729}, "CVE-2024-54242": {"epss_score": 0.00062, "epss_percentile": 0.19729}, "CVE-2024-54243": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54244": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54245": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54246": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54247": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54248": {"epss_score": 0.00045, "epss_percentile": 0.13737}, "CVE-2024-54249": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54250": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54251": {"epss_score": 0.00107, "epss_percentile": 0.2965}, "CVE-2024-54252": {"epss_score": 0.00098, "epss_percentile": 0.27661}, "CVE-2024-54253": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-54254": {"epss_score": 0.00117, "epss_percentile": 0.3129}, "CVE-2024-54255": {"epss_score": 0.00098, "epss_percentile": 0.27798}, "CVE-2024-54256": {"epss_score": 0.00112, "epss_percentile": 0.30567}, "CVE-2024-54257": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54258": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2024-54259": {"epss_score": 0.00445, "epss_percentile": 0.62876}, "CVE-2024-54260": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54261": {"epss_score": 0.0024, "epss_percentile": 0.47188}, "CVE-2024-54262": {"epss_score": 0.36745, "epss_percentile": 0.96999}, "CVE-2024-54264": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2024-54265": {"epss_score": 0.00085, "epss_percentile": 0.25244}, "CVE-2024-54266": {"epss_score": 0.00071, "epss_percentile": 0.22027}, "CVE-2024-54267": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-54268": {"epss_score": 0.00231, "epss_percentile": 0.45849}, "CVE-2024-54269": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-54270": {"epss_score": 0.006, "epss_percentile": 0.68811}, "CVE-2024-54271": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-54272": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54273": {"epss_score": 0.00384, "epss_percentile": 0.59161}, "CVE-2024-54274": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54275": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54276": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54277": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54278": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-54279": {"epss_score": 0.00322, "epss_percentile": 0.54749}, "CVE-2024-54280": {"epss_score": 0.0024, "epss_percentile": 0.47188}, "CVE-2024-54282": {"epss_score": 0.00428, "epss_percentile": 0.61956}, "CVE-2024-54283": {"epss_score": 0.00247, "epss_percentile": 0.47826}, "CVE-2024-54284": {"epss_score": 0.00247, "epss_percentile": 0.47826}, "CVE-2024-54285": {"epss_score": 0.00435, "epss_percentile": 0.62329}, "CVE-2024-54286": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54287": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54288": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54289": {"epss_score": 0.00221, "epss_percentile": 0.44687}, "CVE-2024-54290": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54291": {"epss_score": 0.00095, "epss_percentile": 0.27186}, "CVE-2024-54292": {"epss_score": 0.04212, "epss_percentile": 0.88402}, "CVE-2024-54293": {"epss_score": 0.00153, "epss_percentile": 0.36634}, "CVE-2024-54294": {"epss_score": 0.00369, "epss_percentile": 0.58271}, "CVE-2024-54295": {"epss_score": 0.00369, "epss_percentile": 0.58271}, "CVE-2024-54296": {"epss_score": 0.00369, "epss_percentile": 0.58271}, "CVE-2024-54297": {"epss_score": 0.00369, "epss_percentile": 0.58271}, "CVE-2024-54298": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-54299": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54300": {"epss_score": 0.0004, "epss_percentile": 0.12134}, "CVE-2024-54301": {"epss_score": 0.00071, "epss_percentile": 0.22027}, "CVE-2024-54302": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54303": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54304": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2024-54305": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54306": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-54307": {"epss_score": 0.0004, "epss_percentile": 0.12134}, "CVE-2024-54308": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-54309": {"epss_score": 0.00292, "epss_percentile": 0.52255}, "CVE-2024-54310": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2024-54311": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-54312": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54313": {"epss_score": 0.00445, "epss_percentile": 0.62876}, "CVE-2024-54314": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-54315": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-54316": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-54317": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2024-54318": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54319": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54320": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54321": {"epss_score": 0.0012, "epss_percentile": 0.31705}, "CVE-2024-54322": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54323": {"epss_score": 0.00075, "epss_percentile": 0.22984}, "CVE-2024-54324": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54325": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54326": {"epss_score": 0.00221, "epss_percentile": 0.44687}, "CVE-2024-54327": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54328": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54329": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54330": {"epss_score": 0.56017, "epss_percentile": 0.98005}, "CVE-2024-54331": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54332": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54333": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54334": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54335": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54336": {"epss_score": 0.0032, "epss_percentile": 0.5458}, "CVE-2024-54337": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54338": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54339": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54340": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54341": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54342": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54343": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54344": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54345": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54346": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54347": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54348": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54349": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54350": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54351": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54352": {"epss_score": 0.00045, "epss_percentile": 0.13743}, "CVE-2024-54353": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54354": {"epss_score": 0.00062, "epss_percentile": 0.19729}, "CVE-2024-54355": {"epss_score": 0.00042, "epss_percentile": 0.12583}, "CVE-2024-54356": {"epss_score": 0.0004, "epss_percentile": 0.12088}, "CVE-2024-54357": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-54358": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54359": {"epss_score": 0.0017, "epss_percentile": 0.38649}, "CVE-2024-54360": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54361": {"epss_score": 0.00245, "epss_percentile": 0.4768}, "CVE-2024-54362": {"epss_score": 0.001, "epss_percentile": 0.28455}, "CVE-2024-54363": {"epss_score": 0.28801, "epss_percentile": 0.96385}, "CVE-2024-54364": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54365": {"epss_score": 0.00126, "epss_percentile": 0.32685}, "CVE-2024-54366": {"epss_score": 0.00148, "epss_percentile": 0.35896}, "CVE-2024-54367": {"epss_score": 0.00384, "epss_percentile": 0.59161}, "CVE-2024-54368": {"epss_score": 0.00045, "epss_percentile": 0.13743}, "CVE-2024-54369": {"epss_score": 0.18542, "epss_percentile": 0.9503}, "CVE-2024-54370": {"epss_score": 0.00447, "epss_percentile": 0.62958}, "CVE-2024-54372": {"epss_score": 0.00048, "epss_percentile": 0.15255}, "CVE-2024-54373": {"epss_score": 0.00261, "epss_percentile": 0.49263}, "CVE-2024-54374": {"epss_score": 0.15633, "epss_percentile": 0.94473}, "CVE-2024-54375": {"epss_score": 0.00214, "epss_percentile": 0.43991}, "CVE-2024-54376": {"epss_score": 0.00656, "epss_percentile": 0.70445}, "CVE-2024-54378": {"epss_score": 0.00968, "epss_percentile": 0.76078}, "CVE-2024-54379": {"epss_score": 0.00968, "epss_percentile": 0.76078}, "CVE-2024-54380": {"epss_score": 0.00214, "epss_percentile": 0.43991}, "CVE-2024-54381": {"epss_score": 0.00139, "epss_percentile": 0.34625}, "CVE-2024-54382": {"epss_score": 0.00464, "epss_percentile": 0.6371}, "CVE-2024-54383": {"epss_score": 0.05916, "epss_percentile": 0.90318}, "CVE-2024-54384": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-54385": {"epss_score": 0.84914, "epss_percentile": 0.9931}, "CVE-2024-54386": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54387": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54388": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54389": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54390": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54391": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54392": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54393": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54394": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54395": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54396": {"epss_score": 0.0004, "epss_percentile": 0.12088}, "CVE-2024-54397": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54398": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54399": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54400": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54401": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54402": {"epss_score": 0.00139, "epss_percentile": 0.34625}, "CVE-2024-54403": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54404": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54405": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54406": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54407": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54408": {"epss_score": 0.00063, "epss_percentile": 0.19931}, "CVE-2024-54409": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54410": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54411": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54412": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54413": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54414": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54415": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54416": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54417": {"epss_score": 0.00131, "epss_percentile": 0.33471}, "CVE-2024-54418": {"epss_score": 0.0004, "epss_percentile": 0.12089}, "CVE-2024-54419": {"epss_score": 0.0004, "epss_percentile": 0.12089}, "CVE-2024-54420": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54421": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54422": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54423": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54424": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54425": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54426": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54427": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54428": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54429": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54430": {"epss_score": 0.0004, "epss_percentile": 0.12088}, "CVE-2024-54431": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54432": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54433": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54434": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54435": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54436": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54437": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-54438": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-54439": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54440": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-54441": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54442": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-54443": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-54444": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2024-54445": {"epss_score": 0.00593, "epss_percentile": 0.6864}, "CVE-2024-54446": {"epss_score": 0.00139, "epss_percentile": 0.34633}, "CVE-2024-54447": {"epss_score": 0.00139, "epss_percentile": 0.34633}, "CVE-2024-54448": {"epss_score": 0.00263, "epss_percentile": 0.49505}, "CVE-2024-54449": {"epss_score": 0.00489, "epss_percentile": 0.64906}, "CVE-2024-54450": {"epss_score": 0.00137, "epss_percentile": 0.34256}, "CVE-2024-54451": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-54452": {"epss_score": 0.00182, "epss_percentile": 0.40268}, "CVE-2024-54453": {"epss_score": 0.00114, "epss_percentile": 0.30829}, "CVE-2024-54454": {"epss_score": 0.00098, "epss_percentile": 0.2781}, "CVE-2024-54455": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-54456": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2024-54457": {"epss_score": 0.00172, "epss_percentile": 0.38933}, "CVE-2024-54458": {"epss_score": 0.00033, "epss_percentile": 0.09374}, "CVE-2024-54460": {"epss_score": 0.00028, "epss_percentile": 0.07235}, "CVE-2024-54461": {"epss_score": 8e-05, "epss_percentile": 0.0047}, "CVE-2024-54462": {"epss_score": 8e-05, "epss_percentile": 0.0047}, "CVE-2024-54463": {"epss_score": 0.00085, "epss_percentile": 0.25103}, "CVE-2024-54465": {"epss_score": 0.00338, "epss_percentile": 0.56137}, "CVE-2024-54466": {"epss_score": 0.00197, "epss_percentile": 0.41871}, "CVE-2024-54467": {"epss_score": 0.00187, "epss_percentile": 0.40801}, "CVE-2024-54468": {"epss_score": 0.00032, "epss_percentile": 0.08734}, "CVE-2024-54469": {"epss_score": 0.00081, "epss_percentile": 0.24303}, "CVE-2024-54470": {"epss_score": 0.00099, "epss_percentile": 0.28376}, "CVE-2024-54471": {"epss_score": 0.00131, "epss_percentile": 0.33478}, "CVE-2024-54473": {"epss_score": 0.00085, "epss_percentile": 0.25103}, "CVE-2024-54474": {"epss_score": 0.00053, "epss_percentile": 0.16693}, "CVE-2024-54475": {"epss_score": 0.00024, "epss_percentile": 0.05956}, "CVE-2024-54476": {"epss_score": 0.00039, "epss_percentile": 0.11797}, "CVE-2024-54477": {"epss_score": 0.00039, "epss_percentile": 0.11797}, "CVE-2024-54478": {"epss_score": 0.00241, "epss_percentile": 0.47323}, "CVE-2024-54479": {"epss_score": 0.04747, "epss_percentile": 0.89099}, "CVE-2024-54484": {"epss_score": 0.00029, "epss_percentile": 0.07681}, "CVE-2024-54485": {"epss_score": 0.0004, "epss_percentile": 0.12059}, "CVE-2024-54486": {"epss_score": 0.00397, "epss_percentile": 0.59965}, "CVE-2024-54488": {"epss_score": 0.00238, "epss_percentile": 0.46786}, "CVE-2024-54489": {"epss_score": 0.00029, "epss_percentile": 0.07821}, "CVE-2024-54490": {"epss_score": 0.00018, "epss_percentile": 0.03808}, "CVE-2024-54491": {"epss_score": 0.0003, "epss_percentile": 0.08254}, "CVE-2024-54492": {"epss_score": 0.00294, "epss_percentile": 0.52427}, "CVE-2024-54493": {"epss_score": 0.00041, "epss_percentile": 0.1222}, "CVE-2024-54494": {"epss_score": 0.00304, "epss_percentile": 0.53303}, "CVE-2024-54495": {"epss_score": 0.00033, "epss_percentile": 0.09214}, "CVE-2024-54497": {"epss_score": 0.00343, "epss_percentile": 0.56428}, "CVE-2024-54498": {"epss_score": 0.04338, "epss_percentile": 0.88566}, "CVE-2024-54499": {"epss_score": 0.00204, "epss_percentile": 0.42664}, "CVE-2024-54500": {"epss_score": 0.00051, "epss_percentile": 0.16263}, "CVE-2024-54501": {"epss_score": 0.00047, "epss_percentile": 0.14636}, "CVE-2024-54502": {"epss_score": 0.03208, "epss_percentile": 0.8664}, "CVE-2024-54503": {"epss_score": 0.0008, "epss_percentile": 0.2413}, "CVE-2024-54504": {"epss_score": 0.00043, "epss_percentile": 0.13057}, "CVE-2024-54505": {"epss_score": 0.01493, "epss_percentile": 0.80642}, "CVE-2024-54506": {"epss_score": 0.00706, "epss_percentile": 0.71639}, "CVE-2024-54507": {"epss_score": 0.0017, "epss_percentile": 0.38667}, "CVE-2024-54508": {"epss_score": 0.04484, "epss_percentile": 0.88746}, "CVE-2024-54509": {"epss_score": 0.0005, "epss_percentile": 0.15664}, "CVE-2024-54510": {"epss_score": 0.00031, "epss_percentile": 0.08456}, "CVE-2024-54512": {"epss_score": 0.00101, "epss_percentile": 0.28592}, "CVE-2024-54513": {"epss_score": 0.00029, "epss_percentile": 0.07702}, "CVE-2024-54514": {"epss_score": 0.00038, "epss_percentile": 0.11103}, "CVE-2024-54515": {"epss_score": 0.0003, "epss_percentile": 0.08208}, "CVE-2024-54516": {"epss_score": 0.00022, "epss_percentile": 0.05287}, "CVE-2024-54517": {"epss_score": 0.00054, "epss_percentile": 0.17362}, "CVE-2024-54518": {"epss_score": 0.00037, "epss_percentile": 0.10795}, "CVE-2024-54519": {"epss_score": 0.00021, "epss_percentile": 0.04842}, "CVE-2024-54520": {"epss_score": 0.0005, "epss_percentile": 0.15932}, "CVE-2024-54522": {"epss_score": 0.00066, "epss_percentile": 0.20867}, "CVE-2024-54523": {"epss_score": 0.00081, "epss_percentile": 0.2427}, "CVE-2024-54524": {"epss_score": 0.00038, "epss_percentile": 0.11221}, "CVE-2024-54525": {"epss_score": 0.0151, "epss_percentile": 0.80772}, "CVE-2024-54526": {"epss_score": 0.00066, "epss_percentile": 0.20927}, "CVE-2024-54527": {"epss_score": 0.00097, "epss_percentile": 0.27574}, "CVE-2024-54528": {"epss_score": 0.00057, "epss_percentile": 0.18079}, "CVE-2024-54529": {"epss_score": 0.00159, "epss_percentile": 0.37403}, "CVE-2024-54530": {"epss_score": 0.00139, "epss_percentile": 0.34645}, "CVE-2024-54531": {"epss_score": 0.00043, "epss_percentile": 0.13057}, "CVE-2024-54533": {"epss_score": 0.00056, "epss_percentile": 0.17717}, "CVE-2024-54534": {"epss_score": 0.01941, "epss_percentile": 0.82981}, "CVE-2024-54535": {"epss_score": 0.00302, "epss_percentile": 0.53097}, "CVE-2024-54536": {"epss_score": 0.00033, "epss_percentile": 0.09405}, "CVE-2024-54537": {"epss_score": 0.00026, "epss_percentile": 0.06383}, "CVE-2024-54538": {"epss_score": 0.00699, "epss_percentile": 0.71457}, "CVE-2024-54539": {"epss_score": 0.00026, "epss_percentile": 0.06383}, "CVE-2024-54540": {"epss_score": 0.00115, "epss_percentile": 0.30995}, "CVE-2024-54541": {"epss_score": 0.00044, "epss_percentile": 0.13497}, "CVE-2024-54542": {"epss_score": 0.0023, "epss_percentile": 0.45708}, "CVE-2024-54543": {"epss_score": 0.00482, "epss_percentile": 0.64532}, "CVE-2024-54546": {"epss_score": 0.00216, "epss_percentile": 0.442}, "CVE-2024-54547": {"epss_score": 0.00026, "epss_percentile": 0.06383}, "CVE-2024-54549": {"epss_score": 0.00043, "epss_percentile": 0.13018}, "CVE-2024-54550": {"epss_score": 0.00025, "epss_percentile": 0.06335}, "CVE-2024-54551": {"epss_score": 0.00455, "epss_percentile": 0.63273}, "CVE-2024-54554": {"epss_score": 0.00023, "epss_percentile": 0.0537}, "CVE-2024-54557": {"epss_score": 0.0019, "epss_percentile": 0.41115}, "CVE-2024-54558": {"epss_score": 0.00053, "epss_percentile": 0.16892}, "CVE-2024-54559": {"epss_score": 0.00026, "epss_percentile": 0.06659}, "CVE-2024-54560": {"epss_score": 0.00075, "epss_percentile": 0.23074}, "CVE-2024-54564": {"epss_score": 0.00129, "epss_percentile": 0.33212}, "CVE-2024-54565": {"epss_score": 0.00035, "epss_percentile": 0.09997}, "CVE-2024-54568": {"epss_score": 0.00078, "epss_percentile": 0.23563}, "CVE-2024-54658": {"epss_score": 0.0037, "epss_percentile": 0.5831}, "CVE-2024-54660": {"epss_score": 0.00158, "epss_percentile": 0.37295}, "CVE-2024-54661": {"epss_score": 0.0027, "epss_percentile": 0.50216}, "CVE-2024-54662": {"epss_score": 0.00138, "epss_percentile": 0.34514}, "CVE-2024-54663": {"epss_score": 0.00099, "epss_percentile": 0.28402}, "CVE-2024-54674": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2024-54675": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2024-54676": {"epss_score": 0.03191, "epss_percentile": 0.86601}, "CVE-2024-54677": {"epss_score": 0.07124, "epss_percentile": 0.91265}, "CVE-2024-54678": {"epss_score": 0.00053, "epss_percentile": 0.16928}, "CVE-2024-54679": {"epss_score": 0.01409, "epss_percentile": 0.80074}, "CVE-2024-54681": {"epss_score": 0.00096, "epss_percentile": 0.27296}, "CVE-2024-54682": {"epss_score": 0.00173, "epss_percentile": 0.39096}, "CVE-2024-54683": {"epss_score": 0.00023, "epss_percentile": 0.0546}, "CVE-2024-54687": {"epss_score": 0.00027, "epss_percentile": 0.06758}, "CVE-2024-54724": {"epss_score": 0.00453, "epss_percentile": 0.63231}, "CVE-2024-54728": {"epss_score": 0.0011, "epss_percentile": 0.30075}, "CVE-2024-54730": {"epss_score": 0.00061, "epss_percentile": 0.19492}, "CVE-2024-54731": {"epss_score": 0.00017, "epss_percentile": 0.03412}, "CVE-2024-54745": {"epss_score": 0.00222, "epss_percentile": 0.44793}, "CVE-2024-54747": {"epss_score": 0.00222, "epss_percentile": 0.44793}, "CVE-2024-54749": {"epss_score": 0.0005, "epss_percentile": 0.15785}, "CVE-2024-54750": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-54751": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-54756": {"epss_score": 0.02627, "epss_percentile": 0.85269}, "CVE-2024-54761": {"epss_score": 0.00376, "epss_percentile": 0.58666}, "CVE-2024-54762": {"epss_score": 0.00087, "epss_percentile": 0.25574}, "CVE-2024-54763": {"epss_score": 0.02417, "epss_percentile": 0.84693}, "CVE-2024-54764": {"epss_score": 0.04067, "epss_percentile": 0.88202}, "CVE-2024-54767": {"epss_score": 0.0401, "epss_percentile": 0.88108}, "CVE-2024-54772": {"epss_score": 0.04709, "epss_percentile": 0.89036}, "CVE-2024-54774": {"epss_score": 0.00025, "epss_percentile": 0.0628}, "CVE-2024-54775": {"epss_score": 0.00087, "epss_percentile": 0.25514}, "CVE-2024-54779": {"epss_score": 0.00011, "epss_percentile": 0.00997}, "CVE-2024-54780": {"epss_score": 0.00932, "epss_percentile": 0.75632}, "CVE-2024-54790": {"epss_score": 0.00287, "epss_percentile": 0.51818}, "CVE-2024-54792": {"epss_score": 0.00013, "epss_percentile": 0.0156}, "CVE-2024-54794": {"epss_score": 0.00357, "epss_percentile": 0.57407}, "CVE-2024-54795": {"epss_score": 0.00016, "epss_percentile": 0.03052}, "CVE-2024-54802": {"epss_score": 0.00186, "epss_percentile": 0.40651}, "CVE-2024-54803": {"epss_score": 0.02239, "epss_percentile": 0.8411}, "CVE-2024-54804": {"epss_score": 0.02239, "epss_percentile": 0.8411}, "CVE-2024-54805": {"epss_score": 0.01128, "epss_percentile": 0.77826}, "CVE-2024-54806": {"epss_score": 0.00473, "epss_percentile": 0.64097}, "CVE-2024-54807": {"epss_score": 0.01525, "epss_percentile": 0.80857}, "CVE-2024-54808": {"epss_score": 0.00291, "epss_percentile": 0.52171}, "CVE-2024-54809": {"epss_score": 0.0006, "epss_percentile": 0.1901}, "CVE-2024-54810": {"epss_score": 0.0071, "epss_percentile": 0.7171}, "CVE-2024-54811": {"epss_score": 0.00167, "epss_percentile": 0.38313}, "CVE-2024-54818": {"epss_score": 0.00162, "epss_percentile": 0.37712}, "CVE-2024-54819": {"epss_score": 0.24331, "epss_percentile": 0.95906}, "CVE-2024-54820": {"epss_score": 0.03435, "epss_percentile": 0.8713}, "CVE-2024-54840": {"epss_score": 0.00053, "epss_percentile": 0.16694}, "CVE-2024-54842": {"epss_score": 0.00123, "epss_percentile": 0.32204}, "CVE-2024-54846": {"epss_score": 0.00106, "epss_percentile": 0.29495}, "CVE-2024-54847": {"epss_score": 0.00106, "epss_percentile": 0.29495}, "CVE-2024-54848": {"epss_score": 0.00066, "epss_percentile": 0.20937}, "CVE-2024-54849": {"epss_score": 0.00096, "epss_percentile": 0.27349}, "CVE-2024-54851": {"epss_score": 0.00058, "epss_percentile": 0.1848}, "CVE-2024-54852": {"epss_score": 0.02072, "epss_percentile": 0.8349}, "CVE-2024-54853": {"epss_score": 0.0006, "epss_percentile": 0.19132}, "CVE-2024-54879": {"epss_score": 0.04381, "epss_percentile": 0.88623}, "CVE-2024-54880": {"epss_score": 0.04381, "epss_percentile": 0.88623}, "CVE-2024-54887": {"epss_score": 0.00098, "epss_percentile": 0.27723}, "CVE-2024-54907": {"epss_score": 0.00763, "epss_percentile": 0.72878}, "CVE-2024-54909": {"epss_score": 0.00283, "epss_percentile": 0.51394}, "CVE-2024-54910": {"epss_score": 0.01134, "epss_percentile": 0.77895}, "CVE-2024-54916": {"epss_score": 0.01866, "epss_percentile": 0.82608}, "CVE-2024-54918": {"epss_score": 0.02958, "epss_percentile": 0.86067}, "CVE-2024-54919": {"epss_score": 0.00071, "epss_percentile": 0.22026}, "CVE-2024-54920": {"epss_score": 0.00343, "epss_percentile": 0.56404}, "CVE-2024-54921": {"epss_score": 0.00343, "epss_percentile": 0.56404}, "CVE-2024-54922": {"epss_score": 0.00324, "epss_percentile": 0.5496}, "CVE-2024-54923": {"epss_score": 0.00343, "epss_percentile": 0.56404}, "CVE-2024-54924": {"epss_score": 0.00343, "epss_percentile": 0.56404}, "CVE-2024-54925": {"epss_score": 0.00343, "epss_percentile": 0.56404}, "CVE-2024-54926": {"epss_score": 0.00333, "epss_percentile": 0.55676}, "CVE-2024-54927": {"epss_score": 0.00158, "epss_percentile": 0.37177}, "CVE-2024-54928": {"epss_score": 0.00153, "epss_percentile": 0.36535}, "CVE-2024-54929": {"epss_score": 0.00158, "epss_percentile": 0.37177}, "CVE-2024-54930": {"epss_score": 0.00116, "epss_percentile": 0.3114}, "CVE-2024-54931": {"epss_score": 0.00252, "epss_percentile": 0.4838}, "CVE-2024-54932": {"epss_score": 0.00123, "epss_percentile": 0.32204}, "CVE-2024-54933": {"epss_score": 0.00158, "epss_percentile": 0.37177}, "CVE-2024-54934": {"epss_score": 0.00167, "epss_percentile": 0.38313}, "CVE-2024-54935": {"epss_score": 0.00142, "epss_percentile": 0.35083}, "CVE-2024-54936": {"epss_score": 0.00142, "epss_percentile": 0.35083}, "CVE-2024-54937": {"epss_score": 0.0013, "epss_percentile": 0.33289}, "CVE-2024-54938": {"epss_score": 0.00164, "epss_percentile": 0.3797}, "CVE-2024-54951": {"epss_score": 0.00234, "epss_percentile": 0.46157}, "CVE-2024-54952": {"epss_score": 0.00152, "epss_percentile": 0.3649}, "CVE-2024-54954": {"epss_score": 0.00474, "epss_percentile": 0.64144}, "CVE-2024-54957": {"epss_score": 0.00136, "epss_percentile": 0.34174}, "CVE-2024-54958": {"epss_score": 0.03798, "epss_percentile": 0.87739}, "CVE-2024-54959": {"epss_score": 0.03798, "epss_percentile": 0.87739}, "CVE-2024-54960": {"epss_score": 0.02371, "epss_percentile": 0.84526}, "CVE-2024-54961": {"epss_score": 0.06265, "epss_percentile": 0.90623}, "CVE-2024-54982": {"epss_score": 0.00056, "epss_percentile": 0.17893}, "CVE-2024-54983": {"epss_score": 0.0019, "epss_percentile": 0.41061}, "CVE-2024-54984": {"epss_score": 0.0019, "epss_percentile": 0.41061}, "CVE-2024-54994": {"epss_score": 0.00111, "epss_percentile": 0.30397}, "CVE-2024-54996": {"epss_score": 0.00155, "epss_percentile": 0.36771}, "CVE-2024-54997": {"epss_score": 0.00175, "epss_percentile": 0.39333}, "CVE-2024-54998": {"epss_score": 0.00038, "epss_percentile": 0.11391}, "CVE-2024-54999": {"epss_score": 0.00044, "epss_percentile": 0.13414}, "CVE-2024-55000": {"epss_score": 0.00025, "epss_percentile": 0.0615}, "CVE-2024-55008": {"epss_score": 0.00202, "epss_percentile": 0.42407}, "CVE-2024-55009": {"epss_score": 0.00078, "epss_percentile": 0.23666}, "CVE-2024-55016": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2024-55017": {"epss_score": 0.00056, "epss_percentile": 0.17915}, "CVE-2024-55028": {"epss_score": 0.00448, "epss_percentile": 0.63022}, "CVE-2024-55029": {"epss_score": 0.00059, "epss_percentile": 0.18781}, "CVE-2024-55030": {"epss_score": 0.03317, "epss_percentile": 0.86904}, "CVE-2024-55040": {"epss_score": 0.0016, "epss_percentile": 0.3747}, "CVE-2024-55056": {"epss_score": 0.00018, "epss_percentile": 0.03929}, "CVE-2024-55057": {"epss_score": 0.00027, "epss_percentile": 0.06809}, "CVE-2024-55058": {"epss_score": 0.0003, "epss_percentile": 0.08017}, "CVE-2024-55059": {"epss_score": 0.00024, "epss_percentile": 0.05864}, "CVE-2024-55060": {"epss_score": 0.00245, "epss_percentile": 0.4773}, "CVE-2024-55062": {"epss_score": 0.05429, "epss_percentile": 0.89873}, "CVE-2024-55063": {"epss_score": 0.00791, "epss_percentile": 0.73379}, "CVE-2024-55064": {"epss_score": 0.0006, "epss_percentile": 0.19175}, "CVE-2024-55069": {"epss_score": 0.0006, "epss_percentile": 0.19172}, "CVE-2024-55070": {"epss_score": 0.00041, "epss_percentile": 0.12283}, "CVE-2024-55072": {"epss_score": 0.00074, "epss_percentile": 0.22771}, "CVE-2024-55073": {"epss_score": 0.0007, "epss_percentile": 0.21981}, "CVE-2024-55074": {"epss_score": 0.00099, "epss_percentile": 0.28364}, "CVE-2024-55075": {"epss_score": 0.00036, "epss_percentile": 0.10453}, "CVE-2024-55076": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2024-55078": {"epss_score": 0.00827, "epss_percentile": 0.73985}, "CVE-2024-55081": {"epss_score": 0.00091, "epss_percentile": 0.26199}, "CVE-2024-55082": {"epss_score": 0.00146, "epss_percentile": 0.35612}, "CVE-2024-55085": {"epss_score": 0.00453, "epss_percentile": 0.63231}, "CVE-2024-55086": {"epss_score": 0.00172, "epss_percentile": 0.38933}, "CVE-2024-55088": {"epss_score": 0.00082, "epss_percentile": 0.24417}, "CVE-2024-55089": {"epss_score": 0.00077, "epss_percentile": 0.2355}, "CVE-2024-55093": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2024-55099": {"epss_score": 0.01881, "epss_percentile": 0.82693}, "CVE-2024-55100": {"epss_score": 0.00033, "epss_percentile": 0.09376}, "CVE-2024-55103": {"epss_score": 0.0005, "epss_percentile": 0.15938}, "CVE-2024-55104": {"epss_score": 0.00037, "epss_percentile": 0.10878}, "CVE-2024-55156": {"epss_score": 0.00083, "epss_percentile": 0.2474}, "CVE-2024-55159": {"epss_score": 0.00105, "epss_percentile": 0.29337}, "CVE-2024-55160": {"epss_score": 0.00276, "epss_percentile": 0.50773}, "CVE-2024-55186": {"epss_score": 0.00098, "epss_percentile": 0.27665}, "CVE-2024-55192": {"epss_score": 0.00319, "epss_percentile": 0.54555}, "CVE-2024-55193": {"epss_score": 0.00071, "epss_percentile": 0.2201}, "CVE-2024-55194": {"epss_score": 0.00093, "epss_percentile": 0.26685}, "CVE-2024-55195": {"epss_score": 0.00061, "epss_percentile": 0.19492}, "CVE-2024-55196": {"epss_score": 0.00049, "epss_percentile": 0.15629}, "CVE-2024-55198": {"epss_score": 0.00131, "epss_percentile": 0.33466}, "CVE-2024-55199": {"epss_score": 0.00039, "epss_percentile": 0.11652}, "CVE-2024-55210": {"epss_score": 0.00105, "epss_percentile": 0.29261}, "CVE-2024-55211": {"epss_score": 0.00048, "epss_percentile": 0.15003}, "CVE-2024-55212": {"epss_score": 0.00113, "epss_percentile": 0.30647}, "CVE-2024-55213": {"epss_score": 0.00385, "epss_percentile": 0.59214}, "CVE-2024-55214": {"epss_score": 0.00091, "epss_percentile": 0.26386}, "CVE-2024-55215": {"epss_score": 0.01966, "epss_percentile": 0.83082}, "CVE-2024-55218": {"epss_score": 0.00269, "epss_percentile": 0.50117}, "CVE-2024-55224": {"epss_score": 0.00524, "epss_percentile": 0.66362}, "CVE-2024-55225": {"epss_score": 0.00282, "epss_percentile": 0.51218}, "CVE-2024-55226": {"epss_score": 0.00144, "epss_percentile": 0.35262}, "CVE-2024-55227": {"epss_score": 0.00221, "epss_percentile": 0.4464}, "CVE-2024-55228": {"epss_score": 0.00221, "epss_percentile": 0.4464}, "CVE-2024-55231": {"epss_score": 0.00036, "epss_percentile": 0.10362}, "CVE-2024-55232": {"epss_score": 0.00047, "epss_percentile": 0.14616}, "CVE-2024-55238": {"epss_score": 0.00065, "epss_percentile": 0.20608}, "CVE-2024-55239": {"epss_score": 0.00025, "epss_percentile": 0.0615}, "CVE-2024-55241": {"epss_score": 0.00328, "epss_percentile": 0.55163}, "CVE-2024-55268": {"epss_score": 0.00157, "epss_percentile": 0.37067}, "CVE-2024-55272": {"epss_score": 0.00045, "epss_percentile": 0.13992}, "CVE-2024-55279": {"epss_score": 0.00068, "epss_percentile": 0.21375}, "CVE-2024-55341": {"epss_score": 0.00138, "epss_percentile": 0.34365}, "CVE-2024-55342": {"epss_score": 0.00109, "epss_percentile": 0.29931}, "CVE-2024-55354": {"epss_score": 0.00029, "epss_percentile": 0.07738}, "CVE-2024-55371": {"epss_score": 0.00349, "epss_percentile": 0.56853}, "CVE-2024-55372": {"epss_score": 0.02145, "epss_percentile": 0.83764}, "CVE-2024-55374": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2024-55398": {"epss_score": 0.00035, "epss_percentile": 0.10124}, "CVE-2024-55399": {"epss_score": 0.0003, "epss_percentile": 0.08279}, "CVE-2024-55401": {"epss_score": 0.00074, "epss_percentile": 0.22845}, "CVE-2024-55402": {"epss_score": 0.00032, "epss_percentile": 0.0897}, "CVE-2024-55407": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2024-55408": {"epss_score": 0.00088, "epss_percentile": 0.25709}, "CVE-2024-55411": {"epss_score": 0.00185, "epss_percentile": 0.40554}, "CVE-2024-55412": {"epss_score": 0.00044, "epss_percentile": 0.13588}, "CVE-2024-55413": {"epss_score": 0.00051, "epss_percentile": 0.15985}, "CVE-2024-55414": {"epss_score": 0.00495, "epss_percentile": 0.65131}, "CVE-2024-55415": {"epss_score": 0.36555, "epss_percentile": 0.96987}, "CVE-2024-55416": {"epss_score": 0.0024, "epss_percentile": 0.47231}, "CVE-2024-55417": {"epss_score": 0.05656, "epss_percentile": 0.90092}, "CVE-2024-55451": {"epss_score": 0.00033, "epss_percentile": 0.09388}, "CVE-2024-55452": {"epss_score": 0.00035, "epss_percentile": 0.09945}, "CVE-2024-55456": {"epss_score": 0.00038, "epss_percentile": 0.11196}, "CVE-2024-55457": {"epss_score": 0.76159, "epss_percentile": 0.9888}, "CVE-2024-55459": {"epss_score": 0.00071, "epss_percentile": 0.22169}, "CVE-2024-55460": {"epss_score": 0.00249, "epss_percentile": 0.48075}, "CVE-2024-55461": {"epss_score": 0.01969, "epss_percentile": 0.8309}, "CVE-2024-55466": {"epss_score": 0.00082, "epss_percentile": 0.24445}, "CVE-2024-55470": {"epss_score": 0.0018, "epss_percentile": 0.39935}, "CVE-2024-55471": {"epss_score": 0.00123, "epss_percentile": 0.32293}, "CVE-2024-55488": {"epss_score": 0.00175, "epss_percentile": 0.39274}, "CVE-2024-55492": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-55494": {"epss_score": 0.00111, "epss_percentile": 0.30344}, "CVE-2024-55496": {"epss_score": 0.00068, "epss_percentile": 0.21229}, "CVE-2024-55500": {"epss_score": 0.00189, "epss_percentile": 0.4094}, "CVE-2024-55503": {"epss_score": 0.02067, "epss_percentile": 0.83462}, "CVE-2024-55504": {"epss_score": 0.01841, "epss_percentile": 0.82496}, "CVE-2024-55505": {"epss_score": 0.00132, "epss_percentile": 0.33596}, "CVE-2024-55506": {"epss_score": 0.00151, "epss_percentile": 0.3632}, "CVE-2024-55507": {"epss_score": 0.00581, "epss_percentile": 0.6827}, "CVE-2024-55509": {"epss_score": 0.01028, "epss_percentile": 0.76813}, "CVE-2024-55511": {"epss_score": 0.00191, "epss_percentile": 0.41168}, "CVE-2024-55513": {"epss_score": 0.00364, "epss_percentile": 0.57956}, "CVE-2024-55514": {"epss_score": 0.00127, "epss_percentile": 0.32816}, "CVE-2024-55515": {"epss_score": 0.00434, "epss_percentile": 0.62288}, "CVE-2024-55516": {"epss_score": 0.00364, "epss_percentile": 0.57956}, "CVE-2024-55517": {"epss_score": 0.00162, "epss_percentile": 0.37728}, "CVE-2024-55529": {"epss_score": 0.00957, "epss_percentile": 0.7593}, "CVE-2024-55532": {"epss_score": 0.00863, "epss_percentile": 0.74595}, "CVE-2024-55538": {"epss_score": 0.00026, "epss_percentile": 0.06711}, "CVE-2024-55539": {"epss_score": 0.00015, "epss_percentile": 0.02363}, "CVE-2024-55540": {"epss_score": 0.00021, "epss_percentile": 0.0487}, "CVE-2024-55541": {"epss_score": 0.00095, "epss_percentile": 0.27103}, "CVE-2024-55542": {"epss_score": 0.00016, "epss_percentile": 0.02782}, "CVE-2024-55543": {"epss_score": 0.00026, "epss_percentile": 0.06521}, "CVE-2024-55544": {"epss_score": 0.03533, "epss_percentile": 0.87308}, "CVE-2024-55545": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-55546": {"epss_score": 0.00083, "epss_percentile": 0.24795}, "CVE-2024-55547": {"epss_score": 0.03079, "epss_percentile": 0.86369}, "CVE-2024-55548": {"epss_score": 0.00186, "epss_percentile": 0.40594}, "CVE-2024-55549": {"epss_score": 0.00011, "epss_percentile": 0.00951}, "CVE-2024-55550": {"epss_score": 0.08493, "epss_percentile": 0.92083}, "CVE-2024-55551": {"epss_score": 0.00481, "epss_percentile": 0.64483}, "CVE-2024-55553": {"epss_score": 0.0047, "epss_percentile": 0.6398}, "CVE-2024-55554": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2024-55555": {"epss_score": 0.3325, "epss_percentile": 0.96757}, "CVE-2024-55556": {"epss_score": 0.8111, "epss_percentile": 0.99121}, "CVE-2024-55557": {"epss_score": 0.12844, "epss_percentile": 0.93799}, "CVE-2024-55560": {"epss_score": 0.00261, "epss_percentile": 0.49256}, "CVE-2024-55563": {"epss_score": 0.00088, "epss_percentile": 0.25745}, "CVE-2024-55564": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2024-55565": {"epss_score": 0.00068, "epss_percentile": 0.21318}, "CVE-2024-55566": {"epss_score": 0.00032, "epss_percentile": 0.08826}, "CVE-2024-55567": {"epss_score": 0.00025, "epss_percentile": 0.06262}, "CVE-2024-55568": {"epss_score": 0.00065, "epss_percentile": 0.20623}, "CVE-2024-55569": {"epss_score": 0.00064, "epss_percentile": 0.20382}, "CVE-2024-55570": {"epss_score": 0.00088, "epss_percentile": 0.25674}, "CVE-2024-55573": {"epss_score": 0.00394, "epss_percentile": 0.59783}, "CVE-2024-55577": {"epss_score": 0.0003, "epss_percentile": 0.08185}, "CVE-2024-55578": {"epss_score": 0.00142, "epss_percentile": 0.35079}, "CVE-2024-55579": {"epss_score": 0.0021, "epss_percentile": 0.43471}, "CVE-2024-55580": {"epss_score": 0.00155, "epss_percentile": 0.36848}, "CVE-2024-55581": {"epss_score": 0.00121, "epss_percentile": 0.31926}, "CVE-2024-55582": {"epss_score": 0.00025, "epss_percentile": 0.06115}, "CVE-2024-55585": {"epss_score": 0.00128, "epss_percentile": 0.33024}, "CVE-2024-55586": {"epss_score": 0.00155, "epss_percentile": 0.36819}, "CVE-2024-55587": {"epss_score": 0.13356, "epss_percentile": 0.93939}, "CVE-2024-55590": {"epss_score": 0.0045, "epss_percentile": 0.63076}, "CVE-2024-55591": {"epss_score": 0.93661, "epss_percentile": 0.99831}, "CVE-2024-55592": {"epss_score": 0.00039, "epss_percentile": 0.11571}, "CVE-2024-55593": {"epss_score": 0.00121, "epss_percentile": 0.31815}, "CVE-2024-55594": {"epss_score": 0.00138, "epss_percentile": 0.3452}, "CVE-2024-55597": {"epss_score": 0.00303, "epss_percentile": 0.53207}, "CVE-2024-55599": {"epss_score": 0.00033, "epss_percentile": 0.09211}, "CVE-2024-55601": {"epss_score": 0.0019, "epss_percentile": 0.41073}, "CVE-2024-55602": {"epss_score": 0.00111, "epss_percentile": 0.30375}, "CVE-2024-55603": {"epss_score": 0.00121, "epss_percentile": 0.31835}, "CVE-2024-55604": {"epss_score": 0.00067, "epss_percentile": 0.21094}, "CVE-2024-55605": {"epss_score": 0.00371, "epss_percentile": 0.58418}, "CVE-2024-55626": {"epss_score": 0.00054, "epss_percentile": 0.17133}, "CVE-2024-55627": {"epss_score": 0.00125, "epss_percentile": 0.32547}, "CVE-2024-55628": {"epss_score": 0.00544, "epss_percentile": 0.67135}, "CVE-2024-55629": {"epss_score": 0.00201, "epss_percentile": 0.42306}, "CVE-2024-55630": {"epss_score": 0.00037, "epss_percentile": 0.10773}, "CVE-2024-55631": {"epss_score": 0.0003, "epss_percentile": 0.08195}, "CVE-2024-55632": {"epss_score": 0.0004, "epss_percentile": 0.12136}, "CVE-2024-55633": {"epss_score": 0.01221, "epss_percentile": 0.78645}, "CVE-2024-55634": {"epss_score": 0.00313, "epss_percentile": 0.54059}, "CVE-2024-55635": {"epss_score": 0.00339, "epss_percentile": 0.56188}, "CVE-2024-55636": {"epss_score": 0.04942, "epss_percentile": 0.89309}, "CVE-2024-55637": {"epss_score": 0.04181, "epss_percentile": 0.88357}, "CVE-2024-55638": {"epss_score": 0.04942, "epss_percentile": 0.89309}, "CVE-2024-55639": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-55641": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-55642": {"epss_score": 0.00031, "epss_percentile": 0.08444}, "CVE-2024-55651": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2024-55652": {"epss_score": 0.00095, "epss_percentile": 0.2724}, "CVE-2024-55653": {"epss_score": 0.00105, "epss_percentile": 0.29303}, "CVE-2024-55655": {"epss_score": 0.00047, "epss_percentile": 0.14688}, "CVE-2024-55656": {"epss_score": 0.00355, "epss_percentile": 0.57289}, "CVE-2024-55657": {"epss_score": 0.00379, "epss_percentile": 0.58863}, "CVE-2024-55658": {"epss_score": 0.00306, "epss_percentile": 0.53446}, "CVE-2024-55659": {"epss_score": 0.00158, "epss_percentile": 0.37283}, "CVE-2024-55660": {"epss_score": 0.00564, "epss_percentile": 0.67766}, "CVE-2024-55661": {"epss_score": 0.03614, "epss_percentile": 0.87434}, "CVE-2024-55662": {"epss_score": 0.47541, "epss_percentile": 0.97591}, "CVE-2024-55663": {"epss_score": 0.01842, "epss_percentile": 0.82501}, "CVE-2024-55864": {"epss_score": 0.00141, "epss_percentile": 0.3481}, "CVE-2024-55875": {"epss_score": 0.02398, "epss_percentile": 0.84622}, "CVE-2024-55876": {"epss_score": 0.00182, "epss_percentile": 0.40234}, "CVE-2024-55877": {"epss_score": 0.6411, "epss_percentile": 0.98365}, "CVE-2024-55878": {"epss_score": 0.00097, "epss_percentile": 0.27561}, "CVE-2024-55879": {"epss_score": 0.42526, "epss_percentile": 0.97335}, "CVE-2024-55881": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-55884": {"epss_score": 0.00543, "epss_percentile": 0.6709}, "CVE-2024-55885": {"epss_score": 0.00111, "epss_percentile": 0.30281}, "CVE-2024-55886": {"epss_score": 0.00141, "epss_percentile": 0.34828}, "CVE-2024-55887": {"epss_score": 0.00208, "epss_percentile": 0.43285}, "CVE-2024-55888": {"epss_score": 0.00104, "epss_percentile": 0.29145}, "CVE-2024-55889": {"epss_score": 0.0197, "epss_percentile": 0.83093}, "CVE-2024-55890": {"epss_score": 0.00463, "epss_percentile": 0.63667}, "CVE-2024-55891": {"epss_score": 0.00101, "epss_percentile": 0.28662}, "CVE-2024-55892": {"epss_score": 0.00085, "epss_percentile": 0.25102}, "CVE-2024-55893": {"epss_score": 0.00101, "epss_percentile": 0.28599}, "CVE-2024-55894": {"epss_score": 0.00101, "epss_percentile": 0.28599}, "CVE-2024-55895": {"epss_score": 0.0005, "epss_percentile": 0.15714}, "CVE-2024-55896": {"epss_score": 0.00072, "epss_percentile": 0.22241}, "CVE-2024-55897": {"epss_score": 0.00045, "epss_percentile": 0.13821}, "CVE-2024-55898": {"epss_score": 0.00053, "epss_percentile": 0.16826}, "CVE-2024-55904": {"epss_score": 0.00107, "epss_percentile": 0.29631}, "CVE-2024-55907": {"epss_score": 0.00071, "epss_percentile": 0.22185}, "CVE-2024-55909": {"epss_score": 0.00079, "epss_percentile": 0.23875}, "CVE-2024-55910": {"epss_score": 0.00033, "epss_percentile": 0.09309}, "CVE-2024-55912": {"epss_score": 0.00017, "epss_percentile": 0.03129}, "CVE-2024-55913": {"epss_score": 0.00052, "epss_percentile": 0.1659}, "CVE-2024-55916": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-55917": {"epss_score": 0.0002, "epss_percentile": 0.04538}, "CVE-2024-55918": {"epss_score": 0.00193, "epss_percentile": 0.41464}, "CVE-2024-55920": {"epss_score": 0.00053, "epss_percentile": 0.16705}, "CVE-2024-55921": {"epss_score": 0.00152, "epss_percentile": 0.3644}, "CVE-2024-55922": {"epss_score": 0.00052, "epss_percentile": 0.1637}, "CVE-2024-55923": {"epss_score": 0.00053, "epss_percentile": 0.16705}, "CVE-2024-55924": {"epss_score": 0.00083, "epss_percentile": 0.24749}, "CVE-2024-55925": {"epss_score": 0.00138, "epss_percentile": 0.34517}, "CVE-2024-55926": {"epss_score": 0.00349, "epss_percentile": 0.56899}, "CVE-2024-55927": {"epss_score": 0.00176, "epss_percentile": 0.39469}, "CVE-2024-55928": {"epss_score": 0.00053, "epss_percentile": 0.16688}, "CVE-2024-55929": {"epss_score": 0.00061, "epss_percentile": 0.19524}, "CVE-2024-55930": {"epss_score": 0.00035, "epss_percentile": 0.10137}, "CVE-2024-55931": {"epss_score": 0.00118, "epss_percentile": 0.31431}, "CVE-2024-55945": {"epss_score": 0.00067, "epss_percentile": 0.20981}, "CVE-2024-55946": {"epss_score": 0.00179, "epss_percentile": 0.3977}, "CVE-2024-55947": {"epss_score": 0.01601, "epss_percentile": 0.81266}, "CVE-2024-55948": {"epss_score": 0.00121, "epss_percentile": 0.32}, "CVE-2024-55949": {"epss_score": 0.00288, "epss_percentile": 0.51866}, "CVE-2024-55950": {"epss_score": 0.00034, "epss_percentile": 0.09463}, "CVE-2024-55951": {"epss_score": 0.00192, "epss_percentile": 0.41334}, "CVE-2024-55952": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2024-55953": {"epss_score": 0.01017, "epss_percentile": 0.76696}, "CVE-2024-55954": {"epss_score": 0.00142, "epss_percentile": 0.35004}, "CVE-2024-55955": {"epss_score": 0.00016, "epss_percentile": 0.03052}, "CVE-2024-55956": {"epss_score": 0.91828, "epss_percentile": 0.9967}, "CVE-2024-55957": {"epss_score": 0.00025, "epss_percentile": 0.06331}, "CVE-2024-55958": {"epss_score": 0.00148, "epss_percentile": 0.35911}, "CVE-2024-55959": {"epss_score": 0.00115, "epss_percentile": 0.30885}, "CVE-2024-55963": {"epss_score": 0.24261, "epss_percentile": 0.95897}, "CVE-2024-55964": {"epss_score": 0.44204, "epss_percentile": 0.97424}, "CVE-2024-55965": {"epss_score": 0.00169, "epss_percentile": 0.38638}, "CVE-2024-55968": {"epss_score": 0.13584, "epss_percentile": 0.94002}, "CVE-2024-55969": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2024-55970": {"epss_score": 0.00252, "epss_percentile": 0.48369}, "CVE-2024-55971": {"epss_score": 0.0057, "epss_percentile": 0.67946}, "CVE-2024-55972": {"epss_score": 0.07034, "epss_percentile": 0.91202}, "CVE-2024-55973": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2024-55974": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2024-55975": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2024-55976": {"epss_score": 0.24443, "epss_percentile": 0.95922}, "CVE-2024-55977": {"epss_score": 0.00245, "epss_percentile": 0.4768}, "CVE-2024-55978": {"epss_score": 0.03963, "epss_percentile": 0.88016}, "CVE-2024-55979": {"epss_score": 0.00254, "epss_percentile": 0.48509}, "CVE-2024-55980": {"epss_score": 0.03963, "epss_percentile": 0.88016}, "CVE-2024-55981": {"epss_score": 0.16072, "epss_percentile": 0.94567}, "CVE-2024-55982": {"epss_score": 0.16072, "epss_percentile": 0.94567}, "CVE-2024-55983": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2024-55984": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2024-55985": {"epss_score": 0.00254, "epss_percentile": 0.48509}, "CVE-2024-55986": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2024-55987": {"epss_score": 0.00239, "epss_percentile": 0.46852}, "CVE-2024-55988": {"epss_score": 0.24443, "epss_percentile": 0.95922}, "CVE-2024-55989": {"epss_score": 0.00232, "epss_percentile": 0.45911}, "CVE-2024-55990": {"epss_score": 0.00232, "epss_percentile": 0.45911}, "CVE-2024-55991": {"epss_score": 0.00125, "epss_percentile": 0.32502}, "CVE-2024-55992": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-55993": {"epss_score": 0.00179, "epss_percentile": 0.39828}, "CVE-2024-55994": {"epss_score": 0.00139, "epss_percentile": 0.34625}, "CVE-2024-55995": {"epss_score": 0.00125, "epss_percentile": 0.32502}, "CVE-2024-55996": {"epss_score": 0.00079, "epss_percentile": 0.24}, "CVE-2024-55997": {"epss_score": 0.00125, "epss_percentile": 0.32502}, "CVE-2024-55998": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-55999": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2024-56000": {"epss_score": 0.00182, "epss_percentile": 0.40147}, "CVE-2024-56001": {"epss_score": 0.00125, "epss_percentile": 0.32502}, "CVE-2024-56002": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-56003": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-56004": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-56005": {"epss_score": 0.00063, "epss_percentile": 0.19932}, "CVE-2024-56006": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2024-56007": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-56008": {"epss_score": 0.0013, "epss_percentile": 0.33311}, "CVE-2024-56009": {"epss_score": 0.00096, "epss_percentile": 0.27314}, "CVE-2024-56010": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56011": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56012": {"epss_score": 0.00065, "epss_percentile": 0.20562}, "CVE-2024-56013": {"epss_score": 0.0032, "epss_percentile": 0.5458}, "CVE-2024-56014": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56015": {"epss_score": 0.00038, "epss_percentile": 0.11363}, "CVE-2024-56016": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56017": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2024-56018": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56019": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56020": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56021": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56022": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56023": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56024": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56025": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56026": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56027": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56028": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56029": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56030": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56031": {"epss_score": 0.00153, "epss_percentile": 0.36545}, "CVE-2024-56032": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56033": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56034": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56035": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56036": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56037": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56038": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56039": {"epss_score": 0.00291, "epss_percentile": 0.52166}, "CVE-2024-56040": {"epss_score": 0.00153, "epss_percentile": 0.36634}, "CVE-2024-56041": {"epss_score": 0.00283, "epss_percentile": 0.5138}, "CVE-2024-56042": {"epss_score": 0.00303, "epss_percentile": 0.53184}, "CVE-2024-56043": {"epss_score": 0.00153, "epss_percentile": 0.36634}, "CVE-2024-56044": {"epss_score": 0.00548, "epss_percentile": 0.67276}, "CVE-2024-56045": {"epss_score": 0.00212, "epss_percentile": 0.43748}, "CVE-2024-56046": {"epss_score": 0.00459, "epss_percentile": 0.63472}, "CVE-2024-56047": {"epss_score": 0.00295, "epss_percentile": 0.52446}, "CVE-2024-56048": {"epss_score": 0.00316, "epss_percentile": 0.54234}, "CVE-2024-56049": {"epss_score": 0.00189, "epss_percentile": 0.40923}, "CVE-2024-56050": {"epss_score": 0.00447, "epss_percentile": 0.62958}, "CVE-2024-56051": {"epss_score": 0.00342, "epss_percentile": 0.56357}, "CVE-2024-56052": {"epss_score": 0.00447, "epss_percentile": 0.62958}, "CVE-2024-56053": {"epss_score": 0.00206, "epss_percentile": 0.43045}, "CVE-2024-56054": {"epss_score": 0.00371, "epss_percentile": 0.58384}, "CVE-2024-56055": {"epss_score": 0.0039, "epss_percentile": 0.59514}, "CVE-2024-56056": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56057": {"epss_score": 0.00447, "epss_percentile": 0.62958}, "CVE-2024-56058": {"epss_score": 0.46159, "epss_percentile": 0.97534}, "CVE-2024-56059": {"epss_score": 0.34608, "epss_percentile": 0.9686}, "CVE-2024-56060": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56061": {"epss_score": 0.00126, "epss_percentile": 0.32685}, "CVE-2024-56062": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-56063": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-56064": {"epss_score": 0.34213, "epss_percentile": 0.96832}, "CVE-2024-56065": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56066": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2024-56067": {"epss_score": 0.07665, "epss_percentile": 0.91611}, "CVE-2024-56068": {"epss_score": 0.00332, "epss_percentile": 0.55554}, "CVE-2024-56069": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56070": {"epss_score": 0.00098, "epss_percentile": 0.27661}, "CVE-2024-56071": {"epss_score": 0.00175, "epss_percentile": 0.39355}, "CVE-2024-56072": {"epss_score": 0.00348, "epss_percentile": 0.5685}, "CVE-2024-56073": {"epss_score": 0.00614, "epss_percentile": 0.69285}, "CVE-2024-56074": {"epss_score": 0.00156, "epss_percentile": 0.36955}, "CVE-2024-56082": {"epss_score": 0.00089, "epss_percentile": 0.25925}, "CVE-2024-56083": {"epss_score": 0.00144, "epss_percentile": 0.35328}, "CVE-2024-56084": {"epss_score": 0.00181, "epss_percentile": 0.40074}, "CVE-2024-56085": {"epss_score": 0.00179, "epss_percentile": 0.39839}, "CVE-2024-56086": {"epss_score": 0.00181, "epss_percentile": 0.40074}, "CVE-2024-56087": {"epss_score": 0.00179, "epss_percentile": 0.39839}, "CVE-2024-56089": {"epss_score": 0.00041, "epss_percentile": 0.12392}, "CVE-2024-56112": {"epss_score": 0.00102, "epss_percentile": 0.28718}, "CVE-2024-56113": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2024-56114": {"epss_score": 0.00121, "epss_percentile": 0.31951}, "CVE-2024-56115": {"epss_score": 0.00317, "epss_percentile": 0.54332}, "CVE-2024-56116": {"epss_score": 0.00838, "epss_percentile": 0.74169}, "CVE-2024-56128": {"epss_score": 0.00123, "epss_percentile": 0.32211}, "CVE-2024-56131": {"epss_score": 0.00109, "epss_percentile": 0.29927}, "CVE-2024-56132": {"epss_score": 0.00154, "epss_percentile": 0.36695}, "CVE-2024-56133": {"epss_score": 0.00109, "epss_percentile": 0.29927}, "CVE-2024-56134": {"epss_score": 0.00109, "epss_percentile": 0.29927}, "CVE-2024-56135": {"epss_score": 0.00109, "epss_percentile": 0.29927}, "CVE-2024-56136": {"epss_score": 0.00281, "epss_percentile": 0.51191}, "CVE-2024-56137": {"epss_score": 0.01144, "epss_percentile": 0.77986}, "CVE-2024-56138": {"epss_score": 0.0001, "epss_percentile": 0.00771}, "CVE-2024-56139": {"epss_score": 0.00204, "epss_percentile": 0.42639}, "CVE-2024-56140": {"epss_score": 0.00108, "epss_percentile": 0.29767}, "CVE-2024-56142": {"epss_score": 0.0008, "epss_percentile": 0.24045}, "CVE-2024-56143": {"epss_score": 0.00022, "epss_percentile": 0.04961}, "CVE-2024-56144": {"epss_score": 0.00023, "epss_percentile": 0.05435}, "CVE-2024-56145": {"epss_score": 0.93703, "epss_percentile": 0.99835}, "CVE-2024-56156": {"epss_score": 0.00355, "epss_percentile": 0.57316}, "CVE-2024-56157": {"epss_score": 0.0003, "epss_percentile": 0.08064}, "CVE-2024-56158": {"epss_score": 0.00315, "epss_percentile": 0.54203}, "CVE-2024-56159": {"epss_score": 0.00184, "epss_percentile": 0.40397}, "CVE-2024-56161": {"epss_score": 0.00015, "epss_percentile": 0.02475}, "CVE-2024-56169": {"epss_score": 0.00054, "epss_percentile": 0.17286}, "CVE-2024-56170": {"epss_score": 0.0009, "epss_percentile": 0.26014}, "CVE-2024-56171": {"epss_score": 0.00048, "epss_percentile": 0.15176}, "CVE-2024-56173": {"epss_score": 0.00134, "epss_percentile": 0.33795}, "CVE-2024-56174": {"epss_score": 0.00353, "epss_percentile": 0.5714}, "CVE-2024-56175": {"epss_score": 0.00196, "epss_percentile": 0.41797}, "CVE-2024-56178": {"epss_score": 0.00101, "epss_percentile": 0.2858}, "CVE-2024-56179": {"epss_score": 0.00107, "epss_percentile": 0.29637}, "CVE-2024-56180": {"epss_score": 0.00468, "epss_percentile": 0.63911}, "CVE-2024-56181": {"epss_score": 0.00034, "epss_percentile": 0.09439}, "CVE-2024-56182": {"epss_score": 0.00034, "epss_percentile": 0.09439}, "CVE-2024-56184": {"epss_score": 0.0001, "epss_percentile": 0.00875}, "CVE-2024-56185": {"epss_score": 0.00011, "epss_percentile": 0.00975}, "CVE-2024-56186": {"epss_score": 0.0001, "epss_percentile": 0.00875}, "CVE-2024-56187": {"epss_score": 0.00013, "epss_percentile": 0.01678}, "CVE-2024-56188": {"epss_score": 0.00025, "epss_percentile": 0.06038}, "CVE-2024-56189": {"epss_score": 0.00078, "epss_percentile": 0.23654}, "CVE-2024-56190": {"epss_score": 9e-05, "epss_percentile": 0.00746}, "CVE-2024-56191": {"epss_score": 0.00011, "epss_percentile": 0.00969}, "CVE-2024-56192": {"epss_score": 9e-05, "epss_percentile": 0.00701}, "CVE-2024-56193": {"epss_score": 7e-05, "epss_percentile": 0.00452}, "CVE-2024-56195": {"epss_score": 0.00645, "epss_percentile": 0.7011}, "CVE-2024-56196": {"epss_score": 0.00545, "epss_percentile": 0.67171}, "CVE-2024-56197": {"epss_score": 0.00171, "epss_percentile": 0.3889}, "CVE-2024-56198": {"epss_score": 0.00472, "epss_percentile": 0.64067}, "CVE-2024-56199": {"epss_score": 0.00254, "epss_percentile": 0.48528}, "CVE-2024-56200": {"epss_score": 0.00222, "epss_percentile": 0.44727}, "CVE-2024-56201": {"epss_score": 0.00031, "epss_percentile": 0.08659}, "CVE-2024-56202": {"epss_score": 0.01152, "epss_percentile": 0.78048}, "CVE-2024-56203": {"epss_score": 0.00045, "epss_percentile": 0.13737}, "CVE-2024-56204": {"epss_score": 0.00045, "epss_percentile": 0.13737}, "CVE-2024-56205": {"epss_score": 0.00153, "epss_percentile": 0.36634}, "CVE-2024-56206": {"epss_score": 0.00054, "epss_percentile": 0.17047}, "CVE-2024-56207": {"epss_score": 0.00045, "epss_percentile": 0.13743}, "CVE-2024-56209": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56210": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56211": {"epss_score": 0.00316, "epss_percentile": 0.54234}, "CVE-2024-56212": {"epss_score": 0.00254, "epss_percentile": 0.48509}, "CVE-2024-56213": {"epss_score": 0.00488, "epss_percentile": 0.64865}, "CVE-2024-56214": {"epss_score": 0.00327, "epss_percentile": 0.55128}, "CVE-2024-56215": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-56216": {"epss_score": 0.00238, "epss_percentile": 0.46833}, "CVE-2024-56217": {"epss_score": 0.00098, "epss_percentile": 0.27661}, "CVE-2024-56218": {"epss_score": 0.0004, "epss_percentile": 0.12134}, "CVE-2024-56219": {"epss_score": 0.00139, "epss_percentile": 0.34625}, "CVE-2024-56220": {"epss_score": 0.00153, "epss_percentile": 0.36634}, "CVE-2024-56221": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56222": {"epss_score": 0.0004, "epss_percentile": 0.12088}, "CVE-2024-56223": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56224": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56225": {"epss_score": 0.0017, "epss_percentile": 0.3874}, "CVE-2024-56226": {"epss_score": 0.00071, "epss_percentile": 0.22027}, "CVE-2024-56227": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-56228": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56229": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-56230": {"epss_score": 0.00538, "epss_percentile": 0.6693}, "CVE-2024-56231": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56232": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2024-56233": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56234": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-56235": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56236": {"epss_score": 0.00072, "epss_percentile": 0.22332}, "CVE-2024-56237": {"epss_score": 0.00067, "epss_percentile": 0.21058}, "CVE-2024-56238": {"epss_score": 0.00179, "epss_percentile": 0.39828}, "CVE-2024-56239": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56240": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56241": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56242": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-56243": {"epss_score": 0.00102, "epss_percentile": 0.28777}, "CVE-2024-56244": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-56245": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56246": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56247": {"epss_score": 0.00227, "epss_percentile": 0.45422}, "CVE-2024-56248": {"epss_score": 0.00464, "epss_percentile": 0.6371}, "CVE-2024-56249": {"epss_score": 0.45071, "epss_percentile": 0.97471}, "CVE-2024-56250": {"epss_score": 0.00232, "epss_percentile": 0.45911}, "CVE-2024-56251": {"epss_score": 0.0004, "epss_percentile": 0.12131}, "CVE-2024-56252": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-56253": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-56254": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-56255": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-56256": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-56257": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56258": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56259": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-56260": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56261": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56262": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56263": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56264": {"epss_score": 0.18804, "epss_percentile": 0.95072}, "CVE-2024-56265": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56266": {"epss_score": 0.00222, "epss_percentile": 0.44721}, "CVE-2024-56267": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56268": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56270": {"epss_score": 0.00131, "epss_percentile": 0.33471}, "CVE-2024-56271": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-56272": {"epss_score": 0.00079, "epss_percentile": 0.23848}, "CVE-2024-56273": {"epss_score": 0.00188, "epss_percentile": 0.40903}, "CVE-2024-56274": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-56275": {"epss_score": 0.00111, "epss_percentile": 0.30402}, "CVE-2024-56276": {"epss_score": 0.00331, "epss_percentile": 0.5553}, "CVE-2024-56277": {"epss_score": 0.00137, "epss_percentile": 0.34314}, "CVE-2024-56278": {"epss_score": 0.42651, "epss_percentile": 0.97345}, "CVE-2024-56279": {"epss_score": 0.00075, "epss_percentile": 0.22984}, "CVE-2024-56280": {"epss_score": 0.00126, "epss_percentile": 0.32685}, "CVE-2024-56281": {"epss_score": 0.00584, "epss_percentile": 0.68368}, "CVE-2024-56282": {"epss_score": 0.00584, "epss_percentile": 0.68368}, "CVE-2024-56283": {"epss_score": 0.00316, "epss_percentile": 0.54243}, "CVE-2024-56284": {"epss_score": 0.00245, "epss_percentile": 0.4768}, "CVE-2024-56285": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-56286": {"epss_score": 0.00261, "epss_percentile": 0.49263}, "CVE-2024-56287": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56288": {"epss_score": 0.00067, "epss_percentile": 0.21058}, "CVE-2024-56289": {"epss_score": 0.08506, "epss_percentile": 0.92088}, "CVE-2024-56290": {"epss_score": 0.00261, "epss_percentile": 0.49252}, "CVE-2024-56291": {"epss_score": 0.00289, "epss_percentile": 0.5203}, "CVE-2024-56292": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-56293": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-56294": {"epss_score": 0.00102, "epss_percentile": 0.28865}, "CVE-2024-56295": {"epss_score": 0.00125, "epss_percentile": 0.32502}, "CVE-2024-56296": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56297": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-56298": {"epss_score": 0.00074, "epss_percentile": 0.22788}, "CVE-2024-56299": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56300": {"epss_score": 0.00322, "epss_percentile": 0.54749}, "CVE-2024-56301": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2024-56302": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2024-56310": {"epss_score": 0.00064, "epss_percentile": 0.20324}, "CVE-2024-56311": {"epss_score": 0.00064, "epss_percentile": 0.20324}, "CVE-2024-56312": {"epss_score": 0.00131, "epss_percentile": 0.33426}, "CVE-2024-56313": {"epss_score": 0.00131, "epss_percentile": 0.33426}, "CVE-2024-56314": {"epss_score": 0.00131, "epss_percentile": 0.33426}, "CVE-2024-56316": {"epss_score": 0.00175, "epss_percentile": 0.39324}, "CVE-2024-56317": {"epss_score": 0.00174, "epss_percentile": 0.39149}, "CVE-2024-56318": {"epss_score": 0.00217, "epss_percentile": 0.4433}, "CVE-2024-56319": {"epss_score": 0.00217, "epss_percentile": 0.44253}, "CVE-2024-56320": {"epss_score": 0.00642, "epss_percentile": 0.7002}, "CVE-2024-56321": {"epss_score": 0.00884, "epss_percentile": 0.74925}, "CVE-2024-56322": {"epss_score": 0.00488, "epss_percentile": 0.6483}, "CVE-2024-56323": {"epss_score": 0.00272, "epss_percentile": 0.50372}, "CVE-2024-56324": {"epss_score": 0.00153, "epss_percentile": 0.36572}, "CVE-2024-56325": {"epss_score": 0.13556, "epss_percentile": 0.93995}, "CVE-2024-56326": {"epss_score": 0.00094, "epss_percentile": 0.27006}, "CVE-2024-56327": {"epss_score": 0.00211, "epss_percentile": 0.43709}, "CVE-2024-56328": {"epss_score": 0.00136, "epss_percentile": 0.34159}, "CVE-2024-56329": {"epss_score": 0.00331, "epss_percentile": 0.55549}, "CVE-2024-56330": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2024-56331": {"epss_score": 0.41406, "epss_percentile": 0.97272}, "CVE-2024-56332": {"epss_score": 0.00729, "epss_percentile": 0.72125}, "CVE-2024-56333": {"epss_score": 0.00615, "epss_percentile": 0.69314}, "CVE-2024-56334": {"epss_score": 0.00236, "epss_percentile": 0.46454}, "CVE-2024-56335": {"epss_score": 0.00111, "epss_percentile": 0.30258}, "CVE-2024-56336": {"epss_score": 0.00177, "epss_percentile": 0.39505}, "CVE-2024-56337": {"epss_score": 0.48189, "epss_percentile": 0.97626}, "CVE-2024-56338": {"epss_score": 0.00056, "epss_percentile": 0.17732}, "CVE-2024-56339": {"epss_score": 0.00022, "epss_percentile": 0.05012}, "CVE-2024-56340": {"epss_score": 0.01841, "epss_percentile": 0.82498}, "CVE-2024-56341": {"epss_score": 0.00036, "epss_percentile": 0.10354}, "CVE-2024-56342": {"epss_score": 0.00039, "epss_percentile": 0.11574}, "CVE-2024-56343": {"epss_score": 0.00043, "epss_percentile": 0.13212}, "CVE-2024-56346": {"epss_score": 0.00201, "epss_percentile": 0.42286}, "CVE-2024-56347": {"epss_score": 0.00146, "epss_percentile": 0.35544}, "CVE-2024-56348": {"epss_score": 3e-05, "epss_percentile": 0.00084}, "CVE-2024-56349": {"epss_score": 5e-05, "epss_percentile": 0.00216}, "CVE-2024-56350": {"epss_score": 3e-05, "epss_percentile": 0.00084}, "CVE-2024-56351": {"epss_score": 0.00128, "epss_percentile": 0.32946}, "CVE-2024-56352": {"epss_score": 0.21673, "epss_percentile": 0.95547}, "CVE-2024-56353": {"epss_score": 3e-05, "epss_percentile": 0.00119}, "CVE-2024-56354": {"epss_score": 3e-05, "epss_percentile": 0.00091}, "CVE-2024-56355": {"epss_score": 0.21673, "epss_percentile": 0.95547}, "CVE-2024-56356": {"epss_score": 3e-05, "epss_percentile": 0.0012}, "CVE-2024-56357": {"epss_score": 0.00236, "epss_percentile": 0.46429}, "CVE-2024-56358": {"epss_score": 0.00236, "epss_percentile": 0.46429}, "CVE-2024-56359": {"epss_score": 0.00236, "epss_percentile": 0.46429}, "CVE-2024-56361": {"epss_score": 0.00302, "epss_percentile": 0.53096}, "CVE-2024-56362": {"epss_score": 0.00028, "epss_percentile": 0.07349}, "CVE-2024-56363": {"epss_score": 0.0014, "epss_percentile": 0.34767}, "CVE-2024-56364": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2024-56365": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2024-56366": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2024-56368": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56369": {"epss_score": 0.00028, "epss_percentile": 0.07487}, "CVE-2024-56370": {"epss_score": 0.00091, "epss_percentile": 0.26403}, "CVE-2024-56372": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56374": {"epss_score": 0.00605, "epss_percentile": 0.68982}, "CVE-2024-56375": {"epss_score": 0.00227, "epss_percentile": 0.45398}, "CVE-2024-56376": {"epss_score": 0.00131, "epss_percentile": 0.33426}, "CVE-2024-56377": {"epss_score": 0.00131, "epss_percentile": 0.33426}, "CVE-2024-56378": {"epss_score": 0.00347, "epss_percentile": 0.56767}, "CVE-2024-56404": {"epss_score": 0.00179, "epss_percentile": 0.39829}, "CVE-2024-56406": {"epss_score": 0.00025, "epss_percentile": 0.06273}, "CVE-2024-56408": {"epss_score": 0.00287, "epss_percentile": 0.5184}, "CVE-2024-56409": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2024-56410": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2024-56411": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2024-56412": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2024-56413": {"epss_score": 0.00031, "epss_percentile": 0.08475}, "CVE-2024-56414": {"epss_score": 0.00013, "epss_percentile": 0.01703}, "CVE-2024-56426": {"epss_score": 0.00063, "epss_percentile": 0.1989}, "CVE-2024-56427": {"epss_score": 0.00042, "epss_percentile": 0.12614}, "CVE-2024-56428": {"epss_score": 0.0001, "epss_percentile": 0.00837}, "CVE-2024-56429": {"epss_score": 0.00016, "epss_percentile": 0.02959}, "CVE-2024-56430": {"epss_score": 0.00099, "epss_percentile": 0.28398}, "CVE-2024-56431": {"epss_score": 0.13935, "epss_percentile": 0.94096}, "CVE-2024-56433": {"epss_score": 0.05074, "epss_percentile": 0.89467}, "CVE-2024-56434": {"epss_score": 0.00033, "epss_percentile": 0.09295}, "CVE-2024-56435": {"epss_score": 0.00048, "epss_percentile": 0.1503}, "CVE-2024-56436": {"epss_score": 0.00036, "epss_percentile": 0.1032}, "CVE-2024-56437": {"epss_score": 0.0006, "epss_percentile": 0.18963}, "CVE-2024-56438": {"epss_score": 0.00053, "epss_percentile": 0.16719}, "CVE-2024-56439": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2024-56440": {"epss_score": 0.00049, "epss_percentile": 0.15562}, "CVE-2024-56441": {"epss_score": 0.00028, "epss_percentile": 0.07265}, "CVE-2024-56442": {"epss_score": 0.00052, "epss_percentile": 0.1639}, "CVE-2024-56443": {"epss_score": 0.00056, "epss_percentile": 0.17764}, "CVE-2024-56444": {"epss_score": 0.00097, "epss_percentile": 0.27511}, "CVE-2024-56445": {"epss_score": 0.00095, "epss_percentile": 0.27199}, "CVE-2024-56446": {"epss_score": 0.00057, "epss_percentile": 0.18234}, "CVE-2024-56447": {"epss_score": 0.00047, "epss_percentile": 0.14931}, "CVE-2024-56448": {"epss_score": 0.00051, "epss_percentile": 0.16012}, "CVE-2024-56449": {"epss_score": 0.0005, "epss_percentile": 0.15884}, "CVE-2024-56450": {"epss_score": 0.00015, "epss_percentile": 0.02368}, "CVE-2024-56451": {"epss_score": 0.00022, "epss_percentile": 0.05005}, "CVE-2024-56452": {"epss_score": 0.00017, "epss_percentile": 0.03346}, "CVE-2024-56453": {"epss_score": 0.00016, "epss_percentile": 0.02965}, "CVE-2024-56454": {"epss_score": 0.00017, "epss_percentile": 0.03346}, "CVE-2024-56455": {"epss_score": 0.00017, "epss_percentile": 0.03346}, "CVE-2024-56456": {"epss_score": 0.00016, "epss_percentile": 0.02965}, "CVE-2024-56463": {"epss_score": 0.00096, "epss_percentile": 0.27292}, "CVE-2024-56464": {"epss_score": 0.00031, "epss_percentile": 0.08682}, "CVE-2024-56467": {"epss_score": 0.00024, "epss_percentile": 0.05771}, "CVE-2024-56468": {"epss_score": 0.00109, "epss_percentile": 0.29964}, "CVE-2024-56469": {"epss_score": 0.00017, "epss_percentile": 0.03234}, "CVE-2024-56470": {"epss_score": 0.00084, "epss_percentile": 0.24876}, "CVE-2024-56471": {"epss_score": 0.00084, "epss_percentile": 0.24876}, "CVE-2024-56472": {"epss_score": 0.00106, "epss_percentile": 0.29478}, "CVE-2024-56473": {"epss_score": 0.00132, "epss_percentile": 0.33554}, "CVE-2024-56474": {"epss_score": 0.00023, "epss_percentile": 0.05451}, "CVE-2024-56475": {"epss_score": 0.00036, "epss_percentile": 0.10354}, "CVE-2024-56476": {"epss_score": 0.00056, "epss_percentile": 0.17925}, "CVE-2024-56477": {"epss_score": 0.00541, "epss_percentile": 0.67031}, "CVE-2024-56493": {"epss_score": 0.00022, "epss_percentile": 0.05148}, "CVE-2024-56494": {"epss_score": 0.00022, "epss_percentile": 0.05148}, "CVE-2024-56495": {"epss_score": 0.00022, "epss_percentile": 0.05148}, "CVE-2024-56496": {"epss_score": 0.00022, "epss_percentile": 0.05148}, "CVE-2024-56497": {"epss_score": 0.00084, "epss_percentile": 0.24951}, "CVE-2024-56507": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2024-56508": {"epss_score": 0.00075, "epss_percentile": 0.22964}, "CVE-2024-56509": {"epss_score": 0.00269, "epss_percentile": 0.5015}, "CVE-2024-56510": {"epss_score": 0.0011, "epss_percentile": 0.30183}, "CVE-2024-56511": {"epss_score": 0.00434, "epss_percentile": 0.62301}, "CVE-2024-56512": {"epss_score": 0.23924, "epss_percentile": 0.95834}, "CVE-2024-56513": {"epss_score": 0.00146, "epss_percentile": 0.35642}, "CVE-2024-56514": {"epss_score": 0.00494, "epss_percentile": 0.65069}, "CVE-2024-56515": {"epss_score": 0.00432, "epss_percentile": 0.62105}, "CVE-2024-56516": {"epss_score": 0.00082, "epss_percentile": 0.24586}, "CVE-2024-56517": {"epss_score": 0.00357, "epss_percentile": 0.57435}, "CVE-2024-56518": {"epss_score": 0.0077, "epss_percentile": 0.73}, "CVE-2024-56519": {"epss_score": 0.00175, "epss_percentile": 0.39311}, "CVE-2024-56520": {"epss_score": 0.00173, "epss_percentile": 0.39063}, "CVE-2024-56521": {"epss_score": 0.00289, "epss_percentile": 0.52016}, "CVE-2024-56522": {"epss_score": 0.00243, "epss_percentile": 0.47489}, "CVE-2024-56523": {"epss_score": 0.0008, "epss_percentile": 0.24153}, "CVE-2024-56524": {"epss_score": 0.0008, "epss_percentile": 0.24153}, "CVE-2024-56525": {"epss_score": 0.00148, "epss_percentile": 0.35881}, "CVE-2024-56526": {"epss_score": 0.00051, "epss_percentile": 0.16272}, "CVE-2024-56527": {"epss_score": 0.01029, "epss_percentile": 0.76834}, "CVE-2024-56528": {"epss_score": 0.00093, "epss_percentile": 0.26741}, "CVE-2024-56529": {"epss_score": 0.00067, "epss_percentile": 0.21071}, "CVE-2024-56531": {"epss_score": 0.0002, "epss_percentile": 0.04531}, "CVE-2024-56532": {"epss_score": 0.00025, "epss_percentile": 0.06304}, "CVE-2024-56533": {"epss_score": 0.00021, "epss_percentile": 0.04756}, "CVE-2024-56534": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56535": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56536": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56537": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56538": {"epss_score": 0.0005, "epss_percentile": 0.1587}, "CVE-2024-56539": {"epss_score": 0.00033, "epss_percentile": 0.09127}, "CVE-2024-56540": {"epss_score": 0.00023, "epss_percentile": 0.0546}, "CVE-2024-56541": {"epss_score": 0.00037, "epss_percentile": 0.1066}, "CVE-2024-56542": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56543": {"epss_score": 0.00037, "epss_percentile": 0.10676}, "CVE-2024-56544": {"epss_score": 0.00039, "epss_percentile": 0.11666}, "CVE-2024-56545": {"epss_score": 0.00037, "epss_percentile": 0.10676}, "CVE-2024-56546": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-56547": {"epss_score": 0.00027, "epss_percentile": 0.06833}, "CVE-2024-56548": {"epss_score": 0.00052, "epss_percentile": 0.16612}, "CVE-2024-56549": {"epss_score": 0.00068, "epss_percentile": 0.21414}, "CVE-2024-56550": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56551": {"epss_score": 0.00041, "epss_percentile": 0.12379}, "CVE-2024-56552": {"epss_score": 0.00021, "epss_percentile": 0.04769}, "CVE-2024-56553": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56554": {"epss_score": 0.00044, "epss_percentile": 0.135}, "CVE-2024-56555": {"epss_score": 0.00037, "epss_percentile": 0.11004}, "CVE-2024-56556": {"epss_score": 0.00026, "epss_percentile": 0.06439}, "CVE-2024-56557": {"epss_score": 0.00036, "epss_percentile": 0.10219}, "CVE-2024-56558": {"epss_score": 0.00035, "epss_percentile": 0.09829}, "CVE-2024-56559": {"epss_score": 0.00028, "epss_percentile": 0.07235}, "CVE-2024-56560": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56561": {"epss_score": 0.00044, "epss_percentile": 0.135}, "CVE-2024-56562": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2024-56563": {"epss_score": 0.00037, "epss_percentile": 0.10779}, "CVE-2024-56564": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56565": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56566": {"epss_score": 0.00025, "epss_percentile": 0.06211}, "CVE-2024-56567": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-56568": {"epss_score": 0.00037, "epss_percentile": 0.10648}, "CVE-2024-56569": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-56570": {"epss_score": 0.00027, "epss_percentile": 0.06986}, "CVE-2024-56572": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-56573": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56574": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-56575": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-56576": {"epss_score": 0.00026, "epss_percentile": 0.06669}, "CVE-2024-56577": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56578": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-56579": {"epss_score": 0.00047, "epss_percentile": 0.14709}, "CVE-2024-56580": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56581": {"epss_score": 0.00046, "epss_percentile": 0.14132}, "CVE-2024-56582": {"epss_score": 0.00048, "epss_percentile": 0.15038}, "CVE-2024-56583": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56584": {"epss_score": 0.00036, "epss_percentile": 0.10219}, "CVE-2024-56585": {"epss_score": 0.00028, "epss_percentile": 0.07256}, "CVE-2024-56586": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2024-56587": {"epss_score": 0.00035, "epss_percentile": 0.10119}, "CVE-2024-56588": {"epss_score": 0.00034, "epss_percentile": 0.09534}, "CVE-2024-56589": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-56590": {"epss_score": 0.00028, "epss_percentile": 0.07487}, "CVE-2024-56591": {"epss_score": 0.0003, "epss_percentile": 0.08148}, "CVE-2024-56592": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56593": {"epss_score": 0.00035, "epss_percentile": 0.10119}, "CVE-2024-56594": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2024-56595": {"epss_score": 0.00036, "epss_percentile": 0.10343}, "CVE-2024-56596": {"epss_score": 0.00036, "epss_percentile": 0.10343}, "CVE-2024-56597": {"epss_score": 0.00027, "epss_percentile": 0.06986}, "CVE-2024-56598": {"epss_score": 0.00036, "epss_percentile": 0.10343}, "CVE-2024-56599": {"epss_score": 0.00083, "epss_percentile": 0.24709}, "CVE-2024-56600": {"epss_score": 0.00036, "epss_percentile": 0.10343}, "CVE-2024-56601": {"epss_score": 0.00036, "epss_percentile": 0.10343}, "CVE-2024-56602": {"epss_score": 0.00036, "epss_percentile": 0.10343}, "CVE-2024-56603": {"epss_score": 0.00036, "epss_percentile": 0.10343}, "CVE-2024-56604": {"epss_score": 0.00038, "epss_percentile": 0.11114}, "CVE-2024-56605": {"epss_score": 0.00036, "epss_percentile": 0.10343}, "CVE-2024-56606": {"epss_score": 0.00036, "epss_percentile": 0.10343}, "CVE-2024-56607": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56608": {"epss_score": 0.00057, "epss_percentile": 0.18194}, "CVE-2024-56609": {"epss_score": 0.00036, "epss_percentile": 0.10488}, "CVE-2024-56610": {"epss_score": 0.00043, "epss_percentile": 0.13029}, "CVE-2024-56611": {"epss_score": 0.00025, "epss_percentile": 0.06211}, "CVE-2024-56612": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56613": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56614": {"epss_score": 0.00064, "epss_percentile": 0.20422}, "CVE-2024-56615": {"epss_score": 0.00052, "epss_percentile": 0.16566}, "CVE-2024-56616": {"epss_score": 0.00034, "epss_percentile": 0.09461}, "CVE-2024-56617": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56618": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56619": {"epss_score": 0.00067, "epss_percentile": 0.21163}, "CVE-2024-56620": {"epss_score": 0.0004, "epss_percentile": 0.12075}, "CVE-2024-56621": {"epss_score": 0.0004, "epss_percentile": 0.12075}, "CVE-2024-56622": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-56623": {"epss_score": 0.00038, "epss_percentile": 0.11164}, "CVE-2024-56624": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56625": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-56626": {"epss_score": 0.0002, "epss_percentile": 0.04541}, "CVE-2024-56627": {"epss_score": 0.00014, "epss_percentile": 0.02105}, "CVE-2024-56628": {"epss_score": 0.00036, "epss_percentile": 0.10488}, "CVE-2024-56629": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-56630": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2024-56631": {"epss_score": 0.00055, "epss_percentile": 0.17649}, "CVE-2024-56632": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56633": {"epss_score": 0.00041, "epss_percentile": 0.12436}, "CVE-2024-56634": {"epss_score": 0.0006, "epss_percentile": 0.19107}, "CVE-2024-56635": {"epss_score": 0.00028, "epss_percentile": 0.07568}, "CVE-2024-56636": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-56637": {"epss_score": 0.00026, "epss_percentile": 0.06669}, "CVE-2024-56638": {"epss_score": 0.00031, "epss_percentile": 0.08647}, "CVE-2024-56639": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56640": {"epss_score": 0.00048, "epss_percentile": 0.15111}, "CVE-2024-56641": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56642": {"epss_score": 0.00046, "epss_percentile": 0.14132}, "CVE-2024-56643": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-56644": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2024-56645": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2024-56646": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56647": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56648": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-56649": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56650": {"epss_score": 0.00046, "epss_percentile": 0.14132}, "CVE-2024-56651": {"epss_score": 0.00048, "epss_percentile": 0.15038}, "CVE-2024-56652": {"epss_score": 0.00044, "epss_percentile": 0.135}, "CVE-2024-56653": {"epss_score": 0.00048, "epss_percentile": 0.15256}, "CVE-2024-56654": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56655": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-56656": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56657": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56658": {"epss_score": 0.00048, "epss_percentile": 0.15111}, "CVE-2024-56659": {"epss_score": 0.00035, "epss_percentile": 0.10119}, "CVE-2024-56660": {"epss_score": 0.00047, "epss_percentile": 0.14709}, "CVE-2024-56661": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-56662": {"epss_score": 0.00034, "epss_percentile": 0.09742}, "CVE-2024-56663": {"epss_score": 0.00048, "epss_percentile": 0.15038}, "CVE-2024-56664": {"epss_score": 0.0005, "epss_percentile": 0.15775}, "CVE-2024-56665": {"epss_score": 0.00047, "epss_percentile": 0.14709}, "CVE-2024-56666": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56667": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56668": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56669": {"epss_score": 0.00044, "epss_percentile": 0.135}, "CVE-2024-56670": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-56671": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2024-56672": {"epss_score": 0.0006, "epss_percentile": 0.19141}, "CVE-2024-56673": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56674": {"epss_score": 0.00043, "epss_percentile": 0.13018}, "CVE-2024-56675": {"epss_score": 0.00048, "epss_percentile": 0.15038}, "CVE-2024-56676": {"epss_score": 0.00037, "epss_percentile": 0.10978}, "CVE-2024-56677": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-56678": {"epss_score": 0.00036, "epss_percentile": 0.1054}, "CVE-2024-56679": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-56680": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56681": {"epss_score": 0.00033, "epss_percentile": 0.09127}, "CVE-2024-56682": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56683": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-56684": {"epss_score": 0.00036, "epss_percentile": 0.10248}, "CVE-2024-56685": {"epss_score": 0.00032, "epss_percentile": 0.08998}, "CVE-2024-56687": {"epss_score": 0.0003, "epss_percentile": 0.08203}, "CVE-2024-56688": {"epss_score": 0.00049, "epss_percentile": 0.15352}, "CVE-2024-56689": {"epss_score": 0.00053, "epss_percentile": 0.16698}, "CVE-2024-56690": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2024-56691": {"epss_score": 0.00037, "epss_percentile": 0.10763}, "CVE-2024-56692": {"epss_score": 0.00041, "epss_percentile": 0.12422}, "CVE-2024-56693": {"epss_score": 0.00055, "epss_percentile": 0.17486}, "CVE-2024-56694": {"epss_score": 0.00038, "epss_percentile": 0.11138}, "CVE-2024-56695": {"epss_score": 0.00043, "epss_percentile": 0.1303}, "CVE-2024-56696": {"epss_score": 0.00032, "epss_percentile": 0.08998}, "CVE-2024-56697": {"epss_score": 0.00032, "epss_percentile": 0.08998}, "CVE-2024-56698": {"epss_score": 0.00049, "epss_percentile": 0.15352}, "CVE-2024-56699": {"epss_score": 0.00036, "epss_percentile": 0.10248}, "CVE-2024-56700": {"epss_score": 0.00035, "epss_percentile": 0.10087}, "CVE-2024-56701": {"epss_score": 0.00039, "epss_percentile": 0.11552}, "CVE-2024-56702": {"epss_score": 0.00053, "epss_percentile": 0.16932}, "CVE-2024-56703": {"epss_score": 0.00042, "epss_percentile": 0.12582}, "CVE-2024-56704": {"epss_score": 0.0005, "epss_percentile": 0.15775}, "CVE-2024-56705": {"epss_score": 6e-05, "epss_percentile": 0.00291}, "CVE-2024-56706": {"epss_score": 8e-05, "epss_percentile": 0.00584}, "CVE-2024-56707": {"epss_score": 0.00013, "epss_percentile": 0.0154}, "CVE-2024-56708": {"epss_score": 0.0002, "epss_percentile": 0.04541}, "CVE-2024-56709": {"epss_score": 0.00056, "epss_percentile": 0.178}, "CVE-2024-56710": {"epss_score": 0.00042, "epss_percentile": 0.1292}, "CVE-2024-56711": {"epss_score": 0.00039, "epss_percentile": 0.11434}, "CVE-2024-56712": {"epss_score": 0.00051, "epss_percentile": 0.16129}, "CVE-2024-56713": {"epss_score": 0.00039, "epss_percentile": 0.11434}, "CVE-2024-56714": {"epss_score": 0.00039, "epss_percentile": 0.11434}, "CVE-2024-56715": {"epss_score": 0.00051, "epss_percentile": 0.16253}, "CVE-2024-56716": {"epss_score": 0.00051, "epss_percentile": 0.16253}, "CVE-2024-56717": {"epss_score": 0.00039, "epss_percentile": 0.11458}, "CVE-2024-56718": {"epss_score": 0.00051, "epss_percentile": 0.16159}, "CVE-2024-56719": {"epss_score": 0.00032, "epss_percentile": 0.08998}, "CVE-2024-56720": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-56721": {"epss_score": 0.00031, "epss_percentile": 0.08647}, "CVE-2024-56722": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-56723": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-56724": {"epss_score": 0.00049, "epss_percentile": 0.15352}, "CVE-2024-56725": {"epss_score": 0.00051, "epss_percentile": 0.16253}, "CVE-2024-56726": {"epss_score": 0.00051, "epss_percentile": 0.16253}, "CVE-2024-56727": {"epss_score": 0.00051, "epss_percentile": 0.16253}, "CVE-2024-56728": {"epss_score": 0.00049, "epss_percentile": 0.15352}, "CVE-2024-56729": {"epss_score": 0.00053, "epss_percentile": 0.16698}, "CVE-2024-56730": {"epss_score": 0.00039, "epss_percentile": 0.11434}, "CVE-2024-56731": {"epss_score": 0.00424, "epss_percentile": 0.61656}, "CVE-2024-56732": {"epss_score": 0.00177, "epss_percentile": 0.3961}, "CVE-2024-56733": {"epss_score": 0.0003, "epss_percentile": 0.08211}, "CVE-2024-56734": {"epss_score": 0.00167, "epss_percentile": 0.38297}, "CVE-2024-56736": {"epss_score": 0.00083, "epss_percentile": 0.2479}, "CVE-2024-56737": {"epss_score": 0.0016, "epss_percentile": 0.37431}, "CVE-2024-56738": {"epss_score": 0.00129, "epss_percentile": 0.3316}, "CVE-2024-56739": {"epss_score": 0.00047, "epss_percentile": 0.14499}, "CVE-2024-56740": {"epss_score": 0.0005, "epss_percentile": 0.15931}, "CVE-2024-56742": {"epss_score": 0.00032, "epss_percentile": 0.08998}, "CVE-2024-56743": {"epss_score": 0.0003, "epss_percentile": 0.08154}, "CVE-2024-56744": {"epss_score": 0.00031, "epss_percentile": 0.08473}, "CVE-2024-56745": {"epss_score": 0.00039, "epss_percentile": 0.11552}, "CVE-2024-56746": {"epss_score": 0.00037, "epss_percentile": 0.10763}, "CVE-2024-56747": {"epss_score": 0.00047, "epss_percentile": 0.14499}, "CVE-2024-56748": {"epss_score": 0.00049, "epss_percentile": 0.15352}, "CVE-2024-56749": {"epss_score": 0.00032, "epss_percentile": 0.08998}, "CVE-2024-56750": {"epss_score": 0.00039, "epss_percentile": 0.11434}, "CVE-2024-56751": {"epss_score": 0.00039, "epss_percentile": 0.11552}, "CVE-2024-56752": {"epss_score": 0.0004, "epss_percentile": 0.11966}, "CVE-2024-56753": {"epss_score": 0.00039, "epss_percentile": 0.11434}, "CVE-2024-56754": {"epss_score": 0.00049, "epss_percentile": 0.15352}, "CVE-2024-56755": {"epss_score": 0.00051, "epss_percentile": 0.16253}, "CVE-2024-56756": {"epss_score": 0.00049, "epss_percentile": 0.15352}, "CVE-2024-56757": {"epss_score": 0.0003, "epss_percentile": 0.08148}, "CVE-2024-56758": {"epss_score": 0.0007, "epss_percentile": 0.21779}, "CVE-2024-56759": {"epss_score": 0.00051, "epss_percentile": 0.16271}, "CVE-2024-56760": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-56761": {"epss_score": 0.00043, "epss_percentile": 0.13337}, "CVE-2024-56763": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-56764": {"epss_score": 0.00044, "epss_percentile": 0.135}, "CVE-2024-56765": {"epss_score": 0.00048, "epss_percentile": 0.15038}, "CVE-2024-56766": {"epss_score": 0.00046, "epss_percentile": 0.14132}, "CVE-2024-56767": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-56768": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56769": {"epss_score": 0.00035, "epss_percentile": 0.10119}, "CVE-2024-56770": {"epss_score": 0.0005, "epss_percentile": 0.15707}, "CVE-2024-56771": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56772": {"epss_score": 0.00037, "epss_percentile": 0.11004}, "CVE-2024-56773": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-56774": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-56775": {"epss_score": 0.0004, "epss_percentile": 0.11875}, "CVE-2024-56776": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-56777": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-56778": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-56779": {"epss_score": 0.00035, "epss_percentile": 0.10119}, "CVE-2024-56780": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-56782": {"epss_score": 0.00039, "epss_percentile": 0.11779}, "CVE-2024-56783": {"epss_score": 0.00031, "epss_percentile": 0.08378}, "CVE-2024-56784": {"epss_score": 0.00047, "epss_percentile": 0.14478}, "CVE-2024-56785": {"epss_score": 0.00037, "epss_percentile": 0.10883}, "CVE-2024-56787": {"epss_score": 0.00037, "epss_percentile": 0.10883}, "CVE-2024-56788": {"epss_score": 0.00021, "epss_percentile": 0.04769}, "CVE-2024-56799": {"epss_score": 0.00138, "epss_percentile": 0.34386}, "CVE-2024-56800": {"epss_score": 0.00117, "epss_percentile": 0.3129}, "CVE-2024-56801": {"epss_score": 0.08395, "epss_percentile": 0.92029}, "CVE-2024-56802": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2024-56803": {"epss_score": 0.00651, "epss_percentile": 0.70281}, "CVE-2024-56804": {"epss_score": 0.0012, "epss_percentile": 0.3175}, "CVE-2024-56805": {"epss_score": 0.00099, "epss_percentile": 0.28381}, "CVE-2024-56810": {"epss_score": 0.00022, "epss_percentile": 0.05148}, "CVE-2024-56811": {"epss_score": 0.00022, "epss_percentile": 0.05148}, "CVE-2024-56812": {"epss_score": 0.00023, "epss_percentile": 0.05494}, "CVE-2024-56826": {"epss_score": 0.00061, "epss_percentile": 0.19351}, "CVE-2024-56827": {"epss_score": 0.00066, "epss_percentile": 0.2086}, "CVE-2024-56828": {"epss_score": 0.00167, "epss_percentile": 0.38383}, "CVE-2024-56829": {"epss_score": 0.00177, "epss_percentile": 0.39555}, "CVE-2024-56830": {"epss_score": 0.00183, "epss_percentile": 0.40302}, "CVE-2024-56835": {"epss_score": 0.00055, "epss_percentile": 0.17476}, "CVE-2024-56836": {"epss_score": 0.00055, "epss_percentile": 0.17476}, "CVE-2024-56837": {"epss_score": 0.0006, "epss_percentile": 0.18935}, "CVE-2024-56838": {"epss_score": 0.00056, "epss_percentile": 0.17811}, "CVE-2024-56839": {"epss_score": 0.00098, "epss_percentile": 0.27827}, "CVE-2024-56840": {"epss_score": 0.00098, "epss_percentile": 0.27827}, "CVE-2024-56841": {"epss_score": 0.00256, "epss_percentile": 0.48769}, "CVE-2024-56882": {"epss_score": 0.00061, "epss_percentile": 0.19329}, "CVE-2024-56883": {"epss_score": 0.00647, "epss_percentile": 0.70198}, "CVE-2024-56889": {"epss_score": 0.006, "epss_percentile": 0.68826}, "CVE-2024-56897": {"epss_score": 0.00211, "epss_percentile": 0.43713}, "CVE-2024-56898": {"epss_score": 0.06591, "epss_percentile": 0.90873}, "CVE-2024-56901": {"epss_score": 0.00363, "epss_percentile": 0.57901}, "CVE-2024-56902": {"epss_score": 0.20803, "epss_percentile": 0.95415}, "CVE-2024-56903": {"epss_score": 0.00033, "epss_percentile": 0.09334}, "CVE-2024-56908": {"epss_score": 0.00118, "epss_percentile": 0.31501}, "CVE-2024-56914": {"epss_score": 0.00065, "epss_percentile": 0.20442}, "CVE-2024-56915": {"epss_score": 0.00049, "epss_percentile": 0.15605}, "CVE-2024-56916": {"epss_score": 0.00033, "epss_percentile": 0.09216}, "CVE-2024-56917": {"epss_score": 0.00035, "epss_percentile": 0.10058}, "CVE-2024-56918": {"epss_score": 0.00038, "epss_percentile": 0.11409}, "CVE-2024-56921": {"epss_score": 0.00299, "epss_percentile": 0.52882}, "CVE-2024-56923": {"epss_score": 0.00071, "epss_percentile": 0.22026}, "CVE-2024-56924": {"epss_score": 0.00011, "epss_percentile": 0.01009}, "CVE-2024-56938": {"epss_score": 0.0007, "epss_percentile": 0.21645}, "CVE-2024-56939": {"epss_score": 0.0007, "epss_percentile": 0.21645}, "CVE-2024-56940": {"epss_score": 0.00323, "epss_percentile": 0.54919}, "CVE-2024-56946": {"epss_score": 0.0012, "epss_percentile": 0.31787}, "CVE-2024-56947": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56948": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56949": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56950": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56951": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56952": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56953": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56954": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56955": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56957": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56959": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56960": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56962": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56963": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56964": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56965": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56966": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56967": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56968": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56969": {"epss_score": 0.00084, "epss_percentile": 0.24856}, "CVE-2024-56971": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56972": {"epss_score": 0.00087, "epss_percentile": 0.25523}, "CVE-2024-56973": {"epss_score": 0.00287, "epss_percentile": 0.51846}, "CVE-2024-56975": {"epss_score": 0.00861, "epss_percentile": 0.74546}, "CVE-2024-56990": {"epss_score": 0.00117, "epss_percentile": 0.31335}, "CVE-2024-56997": {"epss_score": 0.00035, "epss_percentile": 0.10128}, "CVE-2024-56998": {"epss_score": 0.00035, "epss_percentile": 0.10128}, "CVE-2024-57004": {"epss_score": 0.00151, "epss_percentile": 0.3623}, "CVE-2024-57011": {"epss_score": 0.02288, "epss_percentile": 0.84272}, "CVE-2024-57012": {"epss_score": 0.06952, "epss_percentile": 0.91142}, "CVE-2024-57013": {"epss_score": 0.06952, "epss_percentile": 0.91142}, "CVE-2024-57014": {"epss_score": 0.03588, "epss_percentile": 0.87396}, "CVE-2024-57015": {"epss_score": 0.06952, "epss_percentile": 0.91142}, "CVE-2024-57016": {"epss_score": 0.06952, "epss_percentile": 0.91142}, "CVE-2024-57017": {"epss_score": 0.06952, "epss_percentile": 0.91142}, "CVE-2024-57018": {"epss_score": 0.06952, "epss_percentile": 0.91142}, "CVE-2024-57019": {"epss_score": 0.06952, "epss_percentile": 0.91142}, "CVE-2024-57020": {"epss_score": 0.06952, "epss_percentile": 0.91142}, "CVE-2024-57021": {"epss_score": 0.06952, "epss_percentile": 0.91142}, "CVE-2024-57022": {"epss_score": 0.06952, "epss_percentile": 0.91142}, "CVE-2024-57023": {"epss_score": 0.01409, "epss_percentile": 0.8007}, "CVE-2024-57024": {"epss_score": 0.01409, "epss_percentile": 0.8007}, "CVE-2024-57025": {"epss_score": 0.01409, "epss_percentile": 0.8007}, "CVE-2024-57026": {"epss_score": 0.00153, "epss_percentile": 0.36642}, "CVE-2024-57030": {"epss_score": 0.007, "epss_percentile": 0.71477}, "CVE-2024-57031": {"epss_score": 0.00325, "epss_percentile": 0.54988}, "CVE-2024-57032": {"epss_score": 0.00432, "epss_percentile": 0.62159}, "CVE-2024-57033": {"epss_score": 0.00077, "epss_percentile": 0.23294}, "CVE-2024-57034": {"epss_score": 0.00325, "epss_percentile": 0.54988}, "CVE-2024-57035": {"epss_score": 0.00081, "epss_percentile": 0.2424}, "CVE-2024-57036": {"epss_score": 0.00132, "epss_percentile": 0.33523}, "CVE-2024-57040": {"epss_score": 0.08496, "epss_percentile": 0.92084}, "CVE-2024-57041": {"epss_score": 0.0013, "epss_percentile": 0.33246}, "CVE-2024-57045": {"epss_score": 0.74502, "epss_percentile": 0.98805}, "CVE-2024-57046": {"epss_score": 0.62426, "epss_percentile": 0.98292}, "CVE-2024-57049": {"epss_score": 0.4878, "epss_percentile": 0.97654}, "CVE-2024-57052": {"epss_score": 0.00294, "epss_percentile": 0.52407}, "CVE-2024-57055": {"epss_score": 0.00078, "epss_percentile": 0.23584}, "CVE-2024-57056": {"epss_score": 0.0007, "epss_percentile": 0.21666}, "CVE-2024-57061": {"epss_score": 0.0028, "epss_percentile": 0.51044}, "CVE-2024-57062": {"epss_score": 0.00019, "epss_percentile": 0.04132}, "CVE-2024-57063": {"epss_score": 0.00206, "epss_percentile": 0.43031}, "CVE-2024-57064": {"epss_score": 0.00224, "epss_percentile": 0.44996}, "CVE-2024-57065": {"epss_score": 0.00064, "epss_percentile": 0.20399}, "CVE-2024-57066": {"epss_score": 0.00224, "epss_percentile": 0.44996}, "CVE-2024-57067": {"epss_score": 0.00224, "epss_percentile": 0.44996}, "CVE-2024-57068": {"epss_score": 0.00188, "epss_percentile": 0.40912}, "CVE-2024-57069": {"epss_score": 0.00206, "epss_percentile": 0.43031}, "CVE-2024-57071": {"epss_score": 0.00206, "epss_percentile": 0.43031}, "CVE-2024-57072": {"epss_score": 0.00064, "epss_percentile": 0.20399}, "CVE-2024-57074": {"epss_score": 0.00213, "epss_percentile": 0.43852}, "CVE-2024-57075": {"epss_score": 0.00066, "epss_percentile": 0.20929}, "CVE-2024-57076": {"epss_score": 0.00061, "epss_percentile": 0.19492}, "CVE-2024-57077": {"epss_score": 0.00235, "epss_percentile": 0.46344}, "CVE-2024-57078": {"epss_score": 0.00224, "epss_percentile": 0.44996}, "CVE-2024-57079": {"epss_score": 0.00213, "epss_percentile": 0.43852}, "CVE-2024-57080": {"epss_score": 0.00224, "epss_percentile": 0.44996}, "CVE-2024-57081": {"epss_score": 0.00061, "epss_percentile": 0.19492}, "CVE-2024-57082": {"epss_score": 0.00072, "epss_percentile": 0.22366}, "CVE-2024-57083": {"epss_score": 0.00035, "epss_percentile": 0.10129}, "CVE-2024-57084": {"epss_score": 0.00206, "epss_percentile": 0.43031}, "CVE-2024-57085": {"epss_score": 0.00196, "epss_percentile": 0.41787}, "CVE-2024-57086": {"epss_score": 0.00206, "epss_percentile": 0.43031}, "CVE-2024-57095": {"epss_score": 0.00317, "epss_percentile": 0.54312}, "CVE-2024-57096": {"epss_score": 0.00017, "epss_percentile": 0.03147}, "CVE-2024-57097": {"epss_score": 0.00201, "epss_percentile": 0.42344}, "CVE-2024-57098": {"epss_score": 0.00167, "epss_percentile": 0.38313}, "CVE-2024-57099": {"epss_score": 0.01459, "epss_percentile": 0.8041}, "CVE-2024-57151": {"epss_score": 0.00344, "epss_percentile": 0.56542}, "CVE-2024-57152": {"epss_score": 0.00096, "epss_percentile": 0.273}, "CVE-2024-57154": {"epss_score": 0.00117, "epss_percentile": 0.31247}, "CVE-2024-57155": {"epss_score": 0.00117, "epss_percentile": 0.31247}, "CVE-2024-57157": {"epss_score": 0.00117, "epss_percentile": 0.31247}, "CVE-2024-57159": {"epss_score": 0.00055, "epss_percentile": 0.17653}, "CVE-2024-57160": {"epss_score": 0.0006, "epss_percentile": 0.18988}, "CVE-2024-57161": {"epss_score": 0.0006, "epss_percentile": 0.18988}, "CVE-2024-57162": {"epss_score": 0.00153, "epss_percentile": 0.36535}, "CVE-2024-57169": {"epss_score": 0.01741, "epss_percentile": 0.82048}, "CVE-2024-57170": {"epss_score": 0.00476, "epss_percentile": 0.64266}, "CVE-2024-57174": {"epss_score": 0.00118, "epss_percentile": 0.31431}, "CVE-2024-57175": {"epss_score": 0.00222, "epss_percentile": 0.4484}, "CVE-2024-57176": {"epss_score": 0.00481, "epss_percentile": 0.64514}, "CVE-2024-57177": {"epss_score": 0.00131, "epss_percentile": 0.33444}, "CVE-2024-57178": {"epss_score": 0.00037, "epss_percentile": 0.10722}, "CVE-2024-57184": {"epss_score": 0.00029, "epss_percentile": 0.07939}, "CVE-2024-57186": {"epss_score": 0.00245, "epss_percentile": 0.47727}, "CVE-2024-57189": {"epss_score": 0.00119, "epss_percentile": 0.31549}, "CVE-2024-57190": {"epss_score": 0.00179, "epss_percentile": 0.39813}, "CVE-2024-57211": {"epss_score": 0.02192, "epss_percentile": 0.8394}, "CVE-2024-57212": {"epss_score": 0.00974, "epss_percentile": 0.76175}, "CVE-2024-57213": {"epss_score": 0.01794, "epss_percentile": 0.82293}, "CVE-2024-57214": {"epss_score": 0.01794, "epss_percentile": 0.82293}, "CVE-2024-57222": {"epss_score": 0.01328, "epss_percentile": 0.79498}, "CVE-2024-57223": {"epss_score": 0.13981, "epss_percentile": 0.94106}, "CVE-2024-57224": {"epss_score": 0.10795, "epss_percentile": 0.93105}, "CVE-2024-57225": {"epss_score": 0.13981, "epss_percentile": 0.94106}, "CVE-2024-57226": {"epss_score": 0.01625, "epss_percentile": 0.8142}, "CVE-2024-57227": {"epss_score": 0.01625, "epss_percentile": 0.8142}, "CVE-2024-57228": {"epss_score": 0.02192, "epss_percentile": 0.8394}, "CVE-2024-57229": {"epss_score": 0.0125, "epss_percentile": 0.78889}, "CVE-2024-57230": {"epss_score": 0.0125, "epss_percentile": 0.78889}, "CVE-2024-57231": {"epss_score": 0.0125, "epss_percentile": 0.78889}, "CVE-2024-57232": {"epss_score": 0.0125, "epss_percentile": 0.78889}, "CVE-2024-57233": {"epss_score": 0.0125, "epss_percentile": 0.78889}, "CVE-2024-57234": {"epss_score": 0.0125, "epss_percentile": 0.78889}, "CVE-2024-57235": {"epss_score": 0.0125, "epss_percentile": 0.78889}, "CVE-2024-57237": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2024-57238": {"epss_score": 0.001, "epss_percentile": 0.28454}, "CVE-2024-57240": {"epss_score": 0.0013, "epss_percentile": 0.33317}, "CVE-2024-57241": {"epss_score": 0.06597, "epss_percentile": 0.90876}, "CVE-2024-57248": {"epss_score": 0.0019, "epss_percentile": 0.41073}, "CVE-2024-57249": {"epss_score": 0.00218, "epss_percentile": 0.44419}, "CVE-2024-57252": {"epss_score": 0.00102, "epss_percentile": 0.28777}, "CVE-2024-57254": {"epss_score": 0.00066, "epss_percentile": 0.20765}, "CVE-2024-57255": {"epss_score": 0.00066, "epss_percentile": 0.20765}, "CVE-2024-57256": {"epss_score": 0.00066, "epss_percentile": 0.20765}, "CVE-2024-57257": {"epss_score": 0.00035, "epss_percentile": 0.10013}, "CVE-2024-57258": {"epss_score": 0.00043, "epss_percentile": 0.13225}, "CVE-2024-57259": {"epss_score": 0.00075, "epss_percentile": 0.23029}, "CVE-2024-57261": {"epss_score": 0.0002, "epss_percentile": 0.04465}, "CVE-2024-57262": {"epss_score": 0.0002, "epss_percentile": 0.04465}, "CVE-2024-57272": {"epss_score": 0.00071, "epss_percentile": 0.22201}, "CVE-2024-57273": {"epss_score": 0.00069, "epss_percentile": 0.21525}, "CVE-2024-57276": {"epss_score": 0.00031, "epss_percentile": 0.08336}, "CVE-2024-57277": {"epss_score": 0.0007, "epss_percentile": 0.21663}, "CVE-2024-57278": {"epss_score": 0.00064, "epss_percentile": 0.20344}, "CVE-2024-57279": {"epss_score": 0.00064, "epss_percentile": 0.20353}, "CVE-2024-57326": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2024-57328": {"epss_score": 0.00202, "epss_percentile": 0.42403}, "CVE-2024-57329": {"epss_score": 0.00083, "epss_percentile": 0.24795}, "CVE-2024-57336": {"epss_score": 0.00037, "epss_percentile": 0.10766}, "CVE-2024-57337": {"epss_score": 0.00077, "epss_percentile": 0.23363}, "CVE-2024-57338": {"epss_score": 0.00077, "epss_percentile": 0.23363}, "CVE-2024-57348": {"epss_score": 0.00147, "epss_percentile": 0.3567}, "CVE-2024-57357": {"epss_score": 0.00612, "epss_percentile": 0.69232}, "CVE-2024-57360": {"epss_score": 0.00028, "epss_percentile": 0.07352}, "CVE-2024-57369": {"epss_score": 0.00118, "epss_percentile": 0.31509}, "CVE-2024-57370": {"epss_score": 0.00024, "epss_percentile": 0.05658}, "CVE-2024-57372": {"epss_score": 0.00024, "epss_percentile": 0.05658}, "CVE-2024-57373": {"epss_score": 0.00047, "epss_percentile": 0.14909}, "CVE-2024-57375": {"epss_score": 0.00047, "epss_percentile": 0.14753}, "CVE-2024-57376": {"epss_score": 0.00153, "epss_percentile": 0.36524}, "CVE-2024-57378": {"epss_score": 0.00194, "epss_percentile": 0.41591}, "CVE-2024-57386": {"epss_score": 0.00041, "epss_percentile": 0.12382}, "CVE-2024-57392": {"epss_score": 0.01411, "epss_percentile": 0.80108}, "CVE-2024-57394": {"epss_score": 0.00116, "epss_percentile": 0.31071}, "CVE-2024-57395": {"epss_score": 0.00871, "epss_percentile": 0.7471}, "CVE-2024-57401": {"epss_score": 0.00533, "epss_percentile": 0.66772}, "CVE-2024-57407": {"epss_score": 0.00083, "epss_percentile": 0.24724}, "CVE-2024-57408": {"epss_score": 0.00237, "epss_percentile": 0.46731}, "CVE-2024-57409": {"epss_score": 0.00082, "epss_percentile": 0.24485}, "CVE-2024-57412": {"epss_score": 0.00013, "epss_percentile": 0.01624}, "CVE-2024-57423": {"epss_score": 0.00147, "epss_percentile": 0.3567}, "CVE-2024-57426": {"epss_score": 0.00393, "epss_percentile": 0.59746}, "CVE-2024-57427": {"epss_score": 0.0028, "epss_percentile": 0.51091}, "CVE-2024-57428": {"epss_score": 0.01031, "epss_percentile": 0.7685}, "CVE-2024-57429": {"epss_score": 0.00267, "epss_percentile": 0.49951}, "CVE-2024-57430": {"epss_score": 0.00926, "epss_percentile": 0.75553}, "CVE-2024-57432": {"epss_score": 0.00128, "epss_percentile": 0.33014}, "CVE-2024-57433": {"epss_score": 0.00164, "epss_percentile": 0.37992}, "CVE-2024-57434": {"epss_score": 0.00182, "epss_percentile": 0.40262}, "CVE-2024-57435": {"epss_score": 0.00176, "epss_percentile": 0.39387}, "CVE-2024-57436": {"epss_score": 0.00295, "epss_percentile": 0.52506}, "CVE-2024-57437": {"epss_score": 0.00164, "epss_percentile": 0.37994}, "CVE-2024-57438": {"epss_score": 0.00133, "epss_percentile": 0.33641}, "CVE-2024-57439": {"epss_score": 0.00311, "epss_percentile": 0.53919}, "CVE-2024-57440": {"epss_score": 0.00116, "epss_percentile": 0.31162}, "CVE-2024-57450": {"epss_score": 0.006, "epss_percentile": 0.68825}, "CVE-2024-57451": {"epss_score": 0.00668, "epss_percentile": 0.70727}, "CVE-2024-57452": {"epss_score": 0.00205, "epss_percentile": 0.42674}, "CVE-2024-57459": {"epss_score": 0.00032, "epss_percentile": 0.08769}, "CVE-2024-57471": {"epss_score": 0.00383, "epss_percentile": 0.59114}, "CVE-2024-57473": {"epss_score": 0.00383, "epss_percentile": 0.59114}, "CVE-2024-57479": {"epss_score": 0.00342, "epss_percentile": 0.56361}, "CVE-2024-57480": {"epss_score": 0.00383, "epss_percentile": 0.59114}, "CVE-2024-57482": {"epss_score": 0.00383, "epss_percentile": 0.59114}, "CVE-2024-57483": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2024-57487": {"epss_score": 0.36526, "epss_percentile": 0.96984}, "CVE-2024-57488": {"epss_score": 0.00033, "epss_percentile": 0.09166}, "CVE-2024-57490": {"epss_score": 0.00112, "epss_percentile": 0.30435}, "CVE-2024-57491": {"epss_score": 0.00107, "epss_percentile": 0.2965}, "CVE-2024-57492": {"epss_score": 0.00029, "epss_percentile": 0.07815}, "CVE-2024-57493": {"epss_score": 0.0003, "epss_percentile": 0.08293}, "CVE-2024-57494": {"epss_score": 0.0006, "epss_percentile": 0.19231}, "CVE-2024-57498": {"epss_score": 0.00086, "epss_percentile": 0.25323}, "CVE-2024-57509": {"epss_score": 0.00031, "epss_percentile": 0.08443}, "CVE-2024-57510": {"epss_score": 0.00037, "epss_percentile": 0.10788}, "CVE-2024-57513": {"epss_score": 0.001, "epss_percentile": 0.28497}, "CVE-2024-57514": {"epss_score": 0.13596, "epss_percentile": 0.94007}, "CVE-2024-57519": {"epss_score": 0.00603, "epss_percentile": 0.68899}, "CVE-2024-57520": {"epss_score": 0.01358, "epss_percentile": 0.79734}, "CVE-2024-57521": {"epss_score": 0.00319, "epss_percentile": 0.54483}, "CVE-2024-57522": {"epss_score": 0.01205, "epss_percentile": 0.78513}, "CVE-2024-57523": {"epss_score": 0.00411, "epss_percentile": 0.60849}, "CVE-2024-57529": {"epss_score": 0.00091, "epss_percentile": 0.26254}, "CVE-2024-57536": {"epss_score": 0.00773, "epss_percentile": 0.73063}, "CVE-2024-57537": {"epss_score": 0.00071, "epss_percentile": 0.22163}, "CVE-2024-57538": {"epss_score": 0.00224, "epss_percentile": 0.45065}, "CVE-2024-57539": {"epss_score": 0.08349, "epss_percentile": 0.92004}, "CVE-2024-57540": {"epss_score": 0.00224, "epss_percentile": 0.45065}, "CVE-2024-57541": {"epss_score": 0.00077, "epss_percentile": 0.23535}, "CVE-2024-57542": {"epss_score": 0.01212, "epss_percentile": 0.78564}, "CVE-2024-57543": {"epss_score": 0.00069, "epss_percentile": 0.2161}, "CVE-2024-57544": {"epss_score": 0.00069, "epss_percentile": 0.2161}, "CVE-2024-57545": {"epss_score": 0.00069, "epss_percentile": 0.2161}, "CVE-2024-57546": {"epss_score": 0.00204, "epss_percentile": 0.42656}, "CVE-2024-57547": {"epss_score": 0.00189, "epss_percentile": 0.40948}, "CVE-2024-57548": {"epss_score": 0.00178, "epss_percentile": 0.3966}, "CVE-2024-57549": {"epss_score": 0.00296, "epss_percentile": 0.52577}, "CVE-2024-57556": {"epss_score": 0.00212, "epss_percentile": 0.43814}, "CVE-2024-57575": {"epss_score": 0.00326, "epss_percentile": 0.55056}, "CVE-2024-57577": {"epss_score": 0.00089, "epss_percentile": 0.25923}, "CVE-2024-57578": {"epss_score": 0.00078, "epss_percentile": 0.23753}, "CVE-2024-57579": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2024-57580": {"epss_score": 0.00093, "epss_percentile": 0.26685}, "CVE-2024-57581": {"epss_score": 0.00292, "epss_percentile": 0.52251}, "CVE-2024-57582": {"epss_score": 0.00292, "epss_percentile": 0.52251}, "CVE-2024-57583": {"epss_score": 0.04293, "epss_percentile": 0.88505}, "CVE-2024-57587": {"epss_score": 0.00251, "epss_percentile": 0.48303}, "CVE-2024-57590": {"epss_score": 0.00484, "epss_percentile": 0.6464}, "CVE-2024-57595": {"epss_score": 0.01501, "epss_percentile": 0.8072}, "CVE-2024-57598": {"epss_score": 0.00226, "epss_percentile": 0.45265}, "CVE-2024-57599": {"epss_score": 0.00131, "epss_percentile": 0.33497}, "CVE-2024-57601": {"epss_score": 0.00044, "epss_percentile": 0.13523}, "CVE-2024-57602": {"epss_score": 0.00581, "epss_percentile": 0.6827}, "CVE-2024-57603": {"epss_score": 0.00035, "epss_percentile": 0.10135}, "CVE-2024-57604": {"epss_score": 0.00537, "epss_percentile": 0.66904}, "CVE-2024-57605": {"epss_score": 0.00083, "epss_percentile": 0.24795}, "CVE-2024-57606": {"epss_score": 0.00118, "epss_percentile": 0.31434}, "CVE-2024-57608": {"epss_score": 0.00213, "epss_percentile": 0.43903}, "CVE-2024-57609": {"epss_score": 0.06776, "epss_percentile": 0.91019}, "CVE-2024-57610": {"epss_score": 0.03369, "epss_percentile": 0.87008}, "CVE-2024-57611": {"epss_score": 0.00055, "epss_percentile": 0.17653}, "CVE-2024-57615": {"epss_score": 0.00087, "epss_percentile": 0.25568}, "CVE-2024-57616": {"epss_score": 0.00087, "epss_percentile": 0.25568}, "CVE-2024-57617": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57618": {"epss_score": 0.00207, "epss_percentile": 0.43203}, "CVE-2024-57619": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57620": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57621": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57622": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57623": {"epss_score": 0.00207, "epss_percentile": 0.43203}, "CVE-2024-57624": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57625": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57626": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57627": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57628": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57629": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57630": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57631": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57632": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57633": {"epss_score": 0.00199, "epss_percentile": 0.42171}, "CVE-2024-57634": {"epss_score": 0.00303, "epss_percentile": 0.53202}, "CVE-2024-57635": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57636": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57637": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57638": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57639": {"epss_score": 0.00602, "epss_percentile": 0.68865}, "CVE-2024-57640": {"epss_score": 0.00602, "epss_percentile": 0.68865}, "CVE-2024-57641": {"epss_score": 0.00602, "epss_percentile": 0.68865}, "CVE-2024-57642": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57643": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57644": {"epss_score": 0.00602, "epss_percentile": 0.68865}, "CVE-2024-57645": {"epss_score": 0.00602, "epss_percentile": 0.68865}, "CVE-2024-57646": {"epss_score": 0.00602, "epss_percentile": 0.68865}, "CVE-2024-57647": {"epss_score": 0.00602, "epss_percentile": 0.68865}, "CVE-2024-57648": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57649": {"epss_score": 0.00602, "epss_percentile": 0.68865}, "CVE-2024-57650": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57651": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57652": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57653": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57654": {"epss_score": 0.0032, "epss_percentile": 0.54624}, "CVE-2024-57655": {"epss_score": 0.0032, "epss_percentile": 0.54624}, "CVE-2024-57656": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57657": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57658": {"epss_score": 0.00923, "epss_percentile": 0.75505}, "CVE-2024-57659": {"epss_score": 0.0032, "epss_percentile": 0.54624}, "CVE-2024-57660": {"epss_score": 0.00474, "epss_percentile": 0.6415}, "CVE-2024-57661": {"epss_score": 0.00261, "epss_percentile": 0.49293}, "CVE-2024-57662": {"epss_score": 0.00075, "epss_percentile": 0.23011}, "CVE-2024-57663": {"epss_score": 0.00075, "epss_percentile": 0.23011}, "CVE-2024-57664": {"epss_score": 0.00075, "epss_percentile": 0.23011}, "CVE-2024-57665": {"epss_score": 0.00167, "epss_percentile": 0.38313}, "CVE-2024-57668": {"epss_score": 0.00161, "epss_percentile": 0.37587}, "CVE-2024-57669": {"epss_score": 0.0099, "epss_percentile": 0.76377}, "CVE-2024-57672": {"epss_score": 0.00033, "epss_percentile": 0.09147}, "CVE-2024-57673": {"epss_score": 0.00033, "epss_percentile": 0.09134}, "CVE-2024-57676": {"epss_score": 0.002, "epss_percentile": 0.42269}, "CVE-2024-57677": {"epss_score": 0.002, "epss_percentile": 0.42269}, "CVE-2024-57678": {"epss_score": 0.00153, "epss_percentile": 0.36586}, "CVE-2024-57679": {"epss_score": 0.00175, "epss_percentile": 0.39365}, "CVE-2024-57680": {"epss_score": 0.00185, "epss_percentile": 0.40566}, "CVE-2024-57681": {"epss_score": 0.00185, "epss_percentile": 0.40566}, "CVE-2024-57682": {"epss_score": 0.00182, "epss_percentile": 0.40159}, "CVE-2024-57683": {"epss_score": 0.00129, "epss_percentile": 0.33193}, "CVE-2024-57684": {"epss_score": 0.00671, "epss_percentile": 0.70797}, "CVE-2024-57685": {"epss_score": 0.00232, "epss_percentile": 0.45907}, "CVE-2024-57686": {"epss_score": 0.02116, "epss_percentile": 0.8366}, "CVE-2024-57687": {"epss_score": 0.03999, "epss_percentile": 0.8809}, "CVE-2024-57695": {"epss_score": 0.00041, "epss_percentile": 0.12295}, "CVE-2024-57698": {"epss_score": 0.0005, "epss_percentile": 0.15902}, "CVE-2024-57699": {"epss_score": 0.00029, "epss_percentile": 0.07753}, "CVE-2024-57703": {"epss_score": 0.00204, "epss_percentile": 0.42611}, "CVE-2024-57704": {"epss_score": 0.00194, "epss_percentile": 0.41576}, "CVE-2024-57707": {"epss_score": 0.00424, "epss_percentile": 0.61678}, "CVE-2024-57708": {"epss_score": 0.0021, "epss_percentile": 0.43589}, "CVE-2024-57716": {"epss_score": 0.00045, "epss_percentile": 0.13992}, "CVE-2024-57719": {"epss_score": 0.00056, "epss_percentile": 0.17891}, "CVE-2024-57720": {"epss_score": 0.00158, "epss_percentile": 0.37237}, "CVE-2024-57721": {"epss_score": 0.00158, "epss_percentile": 0.37237}, "CVE-2024-57722": {"epss_score": 0.00306, "epss_percentile": 0.53467}, "CVE-2024-57723": {"epss_score": 0.00158, "epss_percentile": 0.37237}, "CVE-2024-57724": {"epss_score": 0.00158, "epss_percentile": 0.37237}, "CVE-2024-57725": {"epss_score": 0.056, "epss_percentile": 0.90038}, "CVE-2024-57726": {"epss_score": 0.00316, "epss_percentile": 0.54279}, "CVE-2024-57727": {"epss_score": 0.93845, "epss_percentile": 0.99856}, "CVE-2024-57728": {"epss_score": 0.01159, "epss_percentile": 0.7813}, "CVE-2024-57757": {"epss_score": 0.00148, "epss_percentile": 0.35862}, "CVE-2024-57760": {"epss_score": 0.00142, "epss_percentile": 0.35002}, "CVE-2024-57761": {"epss_score": 0.00248, "epss_percentile": 0.47998}, "CVE-2024-57762": {"epss_score": 0.00177, "epss_percentile": 0.39557}, "CVE-2024-57763": {"epss_score": 0.00177, "epss_percentile": 0.39557}, "CVE-2024-57764": {"epss_score": 0.00177, "epss_percentile": 0.39557}, "CVE-2024-57765": {"epss_score": 0.00156, "epss_percentile": 0.36989}, "CVE-2024-57766": {"epss_score": 0.00177, "epss_percentile": 0.39557}, "CVE-2024-57767": {"epss_score": 0.00164, "epss_percentile": 0.37992}, "CVE-2024-57768": {"epss_score": 0.00195, "epss_percentile": 0.41607}, "CVE-2024-57769": {"epss_score": 0.00162, "epss_percentile": 0.37723}, "CVE-2024-57770": {"epss_score": 0.00162, "epss_percentile": 0.37723}, "CVE-2024-57771": {"epss_score": 0.00084, "epss_percentile": 0.24924}, "CVE-2024-57772": {"epss_score": 0.00084, "epss_percentile": 0.24924}, "CVE-2024-57773": {"epss_score": 0.00084, "epss_percentile": 0.24924}, "CVE-2024-57774": {"epss_score": 0.00084, "epss_percentile": 0.24924}, "CVE-2024-57775": {"epss_score": 0.00162, "epss_percentile": 0.37723}, "CVE-2024-57776": {"epss_score": 0.00083, "epss_percentile": 0.24795}, "CVE-2024-57777": {"epss_score": 0.00041, "epss_percentile": 0.12406}, "CVE-2024-57778": {"epss_score": 0.03363, "epss_percentile": 0.86996}, "CVE-2024-57782": {"epss_score": 0.00116, "epss_percentile": 0.31098}, "CVE-2024-57783": {"epss_score": 0.00021, "epss_percentile": 0.0471}, "CVE-2024-57784": {"epss_score": 0.11168, "epss_percentile": 0.93251}, "CVE-2024-57785": {"epss_score": 0.1611, "epss_percentile": 0.94574}, "CVE-2024-57790": {"epss_score": 0.00051, "epss_percentile": 0.16316}, "CVE-2024-57791": {"epss_score": 0.00572, "epss_percentile": 0.68031}, "CVE-2024-57792": {"epss_score": 0.00036, "epss_percentile": 0.1054}, "CVE-2024-57793": {"epss_score": 0.00037, "epss_percentile": 0.10779}, "CVE-2024-57795": {"epss_score": 0.00044, "epss_percentile": 0.135}, "CVE-2024-57798": {"epss_score": 0.00029, "epss_percentile": 0.07592}, "CVE-2024-57799": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57800": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57801": {"epss_score": 0.00037, "epss_percentile": 0.1066}, "CVE-2024-57802": {"epss_score": 0.00035, "epss_percentile": 0.10119}, "CVE-2024-57804": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57805": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57806": {"epss_score": 0.00015, "epss_percentile": 0.02253}, "CVE-2024-57807": {"epss_score": 0.00021, "epss_percentile": 0.04756}, "CVE-2024-57809": {"epss_score": 0.0003, "epss_percentile": 0.08148}, "CVE-2024-57811": {"epss_score": 0.00188, "epss_percentile": 0.40841}, "CVE-2024-57822": {"epss_score": 0.00074, "epss_percentile": 0.22747}, "CVE-2024-57823": {"epss_score": 0.00066, "epss_percentile": 0.20745}, "CVE-2024-57834": {"epss_score": 0.00048, "epss_percentile": 0.15117}, "CVE-2024-57835": {"epss_score": 0.0009, "epss_percentile": 0.26156}, "CVE-2024-57838": {"epss_score": 0.00034, "epss_percentile": 0.09671}, "CVE-2024-57839": {"epss_score": 0.00042, "epss_percentile": 0.12938}, "CVE-2024-57841": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-57843": {"epss_score": 0.00025, "epss_percentile": 0.06211}, "CVE-2024-57844": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57849": {"epss_score": 0.00029, "epss_percentile": 0.07635}, "CVE-2024-57850": {"epss_score": 0.00042, "epss_percentile": 0.12806}, "CVE-2024-57852": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-57857": {"epss_score": 0.00044, "epss_percentile": 0.135}, "CVE-2024-57868": {"epss_score": 0.00101, "epss_percentile": 0.28668}, "CVE-2024-57872": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57874": {"epss_score": 0.00047, "epss_percentile": 0.14804}, "CVE-2024-57875": {"epss_score": 0.0003, "epss_percentile": 0.08148}, "CVE-2024-57876": {"epss_score": 0.00033, "epss_percentile": 0.09297}, "CVE-2024-57877": {"epss_score": 0.00034, "epss_percentile": 0.09576}, "CVE-2024-57878": {"epss_score": 0.00034, "epss_percentile": 0.09576}, "CVE-2024-57879": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57880": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57881": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57882": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-57883": {"epss_score": 0.0005, "epss_percentile": 0.15859}, "CVE-2024-57884": {"epss_score": 0.00029, "epss_percentile": 0.0786}, "CVE-2024-57885": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-57886": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57887": {"epss_score": 0.00044, "epss_percentile": 0.13417}, "CVE-2024-57888": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-57889": {"epss_score": 0.00026, "epss_percentile": 0.06669}, "CVE-2024-57890": {"epss_score": 0.00035, "epss_percentile": 0.10119}, "CVE-2024-57891": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57892": {"epss_score": 0.00051, "epss_percentile": 0.1618}, "CVE-2024-57893": {"epss_score": 0.00029, "epss_percentile": 0.07845}, "CVE-2024-57895": {"epss_score": 0.00039, "epss_percentile": 0.11666}, "CVE-2024-57896": {"epss_score": 0.00038, "epss_percentile": 0.11164}, "CVE-2024-57897": {"epss_score": 0.00047, "epss_percentile": 0.14817}, "CVE-2024-57898": {"epss_score": 0.00026, "epss_percentile": 0.0656}, "CVE-2024-57899": {"epss_score": 0.00033, "epss_percentile": 0.09279}, "CVE-2024-57900": {"epss_score": 0.00046, "epss_percentile": 0.14132}, "CVE-2024-57901": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-57902": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2024-57903": {"epss_score": 0.00037, "epss_percentile": 0.10648}, "CVE-2024-57904": {"epss_score": 0.00037, "epss_percentile": 0.10879}, "CVE-2024-57905": {"epss_score": 0.00037, "epss_percentile": 0.11004}, "CVE-2024-57906": {"epss_score": 0.00051, "epss_percentile": 0.1618}, "CVE-2024-57907": {"epss_score": 0.00058, "epss_percentile": 0.18568}, "CVE-2024-57908": {"epss_score": 0.00055, "epss_percentile": 0.17649}, "CVE-2024-57909": {"epss_score": 0.00037, "epss_percentile": 0.11004}, "CVE-2024-57910": {"epss_score": 0.00051, "epss_percentile": 0.1618}, "CVE-2024-57911": {"epss_score": 0.00051, "epss_percentile": 0.1618}, "CVE-2024-57912": {"epss_score": 0.00051, "epss_percentile": 0.1618}, "CVE-2024-57913": {"epss_score": 0.00057, "epss_percentile": 0.18161}, "CVE-2024-57914": {"epss_score": 0.00042, "epss_percentile": 0.12938}, "CVE-2024-57916": {"epss_score": 0.00046, "epss_percentile": 0.14116}, "CVE-2024-57917": {"epss_score": 0.00042, "epss_percentile": 0.12927}, "CVE-2024-57918": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57919": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57921": {"epss_score": 0.00028, "epss_percentile": 0.07235}, "CVE-2024-57922": {"epss_score": 0.00058, "epss_percentile": 0.1843}, "CVE-2024-57923": {"epss_score": 0.00015, "epss_percentile": 0.02253}, "CVE-2024-57924": {"epss_score": 0.00035, "epss_percentile": 0.09936}, "CVE-2024-57925": {"epss_score": 0.0006, "epss_percentile": 0.19175}, "CVE-2024-57926": {"epss_score": 0.00037, "epss_percentile": 0.1066}, "CVE-2024-57927": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57928": {"epss_score": 0.00037, "epss_percentile": 0.11004}, "CVE-2024-57929": {"epss_score": 0.00057, "epss_percentile": 0.18082}, "CVE-2024-57930": {"epss_score": 0.00036, "epss_percentile": 0.1028}, "CVE-2024-57931": {"epss_score": 0.0004, "epss_percentile": 0.11877}, "CVE-2024-57932": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-57933": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-57934": {"epss_score": 0.00027, "epss_percentile": 0.06833}, "CVE-2024-57935": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57936": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2024-57938": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2024-57939": {"epss_score": 0.00046, "epss_percentile": 0.14169}, "CVE-2024-57940": {"epss_score": 0.00055, "epss_percentile": 0.17465}, "CVE-2024-57941": {"epss_score": 0.00037, "epss_percentile": 0.10978}, "CVE-2024-57942": {"epss_score": 0.00037, "epss_percentile": 0.10978}, "CVE-2024-57943": {"epss_score": 0.00037, "epss_percentile": 0.11004}, "CVE-2024-57944": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2024-57945": {"epss_score": 0.00038, "epss_percentile": 0.11102}, "CVE-2024-57946": {"epss_score": 0.00027, "epss_percentile": 0.07136}, "CVE-2024-57947": {"epss_score": 0.00052, "epss_percentile": 0.16449}, "CVE-2024-57948": {"epss_score": 0.00048, "epss_percentile": 0.14978}, "CVE-2024-57949": {"epss_score": 9e-05, "epss_percentile": 0.00695}, "CVE-2024-57950": {"epss_score": 0.0003, "epss_percentile": 0.08148}, "CVE-2024-57951": {"epss_score": 0.00037, "epss_percentile": 0.10637}, "CVE-2024-57952": {"epss_score": 0.00031, "epss_percentile": 0.08663}, "CVE-2024-57953": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-57954": {"epss_score": 0.00048, "epss_percentile": 0.1503}, "CVE-2024-57955": {"epss_score": 0.00042, "epss_percentile": 0.12675}, "CVE-2024-57956": {"epss_score": 0.00033, "epss_percentile": 0.09295}, "CVE-2024-57957": {"epss_score": 0.00061, "epss_percentile": 0.19262}, "CVE-2024-57958": {"epss_score": 0.00058, "epss_percentile": 0.18464}, "CVE-2024-57959": {"epss_score": 0.00055, "epss_percentile": 0.17469}, "CVE-2024-57960": {"epss_score": 0.00042, "epss_percentile": 0.12675}, "CVE-2024-57961": {"epss_score": 0.00061, "epss_percentile": 0.19372}, "CVE-2024-57962": {"epss_score": 0.00037, "epss_percentile": 0.1068}, "CVE-2024-57963": {"epss_score": 0.00022, "epss_percentile": 0.05171}, "CVE-2024-57964": {"epss_score": 0.00022, "epss_percentile": 0.05171}, "CVE-2024-57965": {"epss_score": 0.00118, "epss_percentile": 0.31463}, "CVE-2024-57966": {"epss_score": 0.0001, "epss_percentile": 0.00816}, "CVE-2024-57967": {"epss_score": 0.00068, "epss_percentile": 0.21228}, "CVE-2024-57968": {"epss_score": 0.25731, "epss_percentile": 0.9606}, "CVE-2024-57969": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2024-57970": {"epss_score": 0.00018, "epss_percentile": 0.03697}, "CVE-2024-57971": {"epss_score": 0.0012, "epss_percentile": 0.3181}, "CVE-2024-57972": {"epss_score": 0.05593, "epss_percentile": 0.90031}, "CVE-2024-57973": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2024-57974": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2024-57975": {"epss_score": 0.00025, "epss_percentile": 0.06272}, "CVE-2024-57976": {"epss_score": 0.00025, "epss_percentile": 0.06272}, "CVE-2024-57977": {"epss_score": 0.0005, "epss_percentile": 0.15693}, "CVE-2024-57978": {"epss_score": 0.00045, "epss_percentile": 0.13965}, "CVE-2024-57979": {"epss_score": 0.00055, "epss_percentile": 0.17641}, "CVE-2024-57980": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2024-57981": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2024-57982": {"epss_score": 0.00031, "epss_percentile": 0.0847}, "CVE-2024-57983": {"epss_score": 0.00047, "epss_percentile": 0.14497}, "CVE-2024-57984": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2024-57985": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-57986": {"epss_score": 0.00059, "epss_percentile": 0.18742}, "CVE-2024-57987": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-57988": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-57989": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-57990": {"epss_score": 0.00031, "epss_percentile": 0.0847}, "CVE-2024-57991": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-57992": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2024-57993": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2024-57994": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2024-57995": {"epss_score": 0.00041, "epss_percentile": 0.12406}, "CVE-2024-57996": {"epss_score": 0.00048, "epss_percentile": 0.15117}, "CVE-2024-57997": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2024-57998": {"epss_score": 0.00035, "epss_percentile": 0.10151}, "CVE-2024-57999": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-58000": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2024-58001": {"epss_score": 0.00048, "epss_percentile": 0.15117}, "CVE-2024-58002": {"epss_score": 0.00044, "epss_percentile": 0.13425}, "CVE-2024-58003": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2024-58004": {"epss_score": 0.00031, "epss_percentile": 0.0847}, "CVE-2024-58005": {"epss_score": 0.00048, "epss_percentile": 0.15117}, "CVE-2024-58006": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-58007": {"epss_score": 0.00039, "epss_percentile": 0.11711}, "CVE-2024-58008": {"epss_score": 0.0002, "epss_percentile": 0.04472}, "CVE-2024-58009": {"epss_score": 0.00053, "epss_percentile": 0.16835}, "CVE-2024-58010": {"epss_score": 0.00064, "epss_percentile": 0.20318}, "CVE-2024-58011": {"epss_score": 0.00044, "epss_percentile": 0.13519}, "CVE-2024-58012": {"epss_score": 0.00027, "epss_percentile": 0.06875}, "CVE-2024-58013": {"epss_score": 0.00029, "epss_percentile": 0.07584}, "CVE-2024-58014": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2024-58015": {"epss_score": 0.00039, "epss_percentile": 0.11652}, "CVE-2024-58016": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2024-58017": {"epss_score": 0.00051, "epss_percentile": 0.16333}, "CVE-2024-58018": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-58019": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-58020": {"epss_score": 0.00086, "epss_percentile": 0.25327}, "CVE-2024-58021": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-58022": {"epss_score": 0.00056, "epss_percentile": 0.17825}, "CVE-2024-58034": {"epss_score": 0.00035, "epss_percentile": 0.10151}, "CVE-2024-58036": {"epss_score": 0.00101, "epss_percentile": 0.28668}, "CVE-2024-58040": {"epss_score": 0.00025, "epss_percentile": 0.06207}, "CVE-2024-58042": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2024-58043": {"epss_score": 0.00018, "epss_percentile": 0.03897}, "CVE-2024-58044": {"epss_score": 0.00017, "epss_percentile": 0.03321}, "CVE-2024-58045": {"epss_score": 0.00011, "epss_percentile": 0.00967}, "CVE-2024-58046": {"epss_score": 0.00018, "epss_percentile": 0.03831}, "CVE-2024-58047": {"epss_score": 0.00012, "epss_percentile": 0.01333}, "CVE-2024-58048": {"epss_score": 0.0001, "epss_percentile": 0.00809}, "CVE-2024-58049": {"epss_score": 0.00012, "epss_percentile": 0.01333}, "CVE-2024-58050": {"epss_score": 0.00018, "epss_percentile": 0.03831}, "CVE-2024-58051": {"epss_score": 0.0008, "epss_percentile": 0.24136}, "CVE-2024-58052": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2024-58053": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2024-58054": {"epss_score": 0.00207, "epss_percentile": 0.43086}, "CVE-2024-58055": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2024-58056": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2024-58057": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-58058": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2024-58059": {"epss_score": 0.00029, "epss_percentile": 0.0782}, "CVE-2024-58060": {"epss_score": 0.00074, "epss_percentile": 0.22676}, "CVE-2024-58061": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2024-58062": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-58063": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2024-58064": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-58065": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2024-58066": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2024-58067": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2024-58068": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2024-58069": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2024-58070": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2024-58071": {"epss_score": 0.00046, "epss_percentile": 0.14424}, "CVE-2024-58072": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2024-58073": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2024-58074": {"epss_score": 0.00047, "epss_percentile": 0.14614}, "CVE-2024-58075": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-58076": {"epss_score": 0.00045, "epss_percentile": 0.13965}, "CVE-2024-58077": {"epss_score": 0.00051, "epss_percentile": 0.16141}, "CVE-2024-58078": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2024-58079": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2024-58080": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2024-58081": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-58082": {"epss_score": 0.00035, "epss_percentile": 0.09976}, "CVE-2024-58083": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2024-58084": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-58085": {"epss_score": 0.00048, "epss_percentile": 0.15117}, "CVE-2024-58086": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2024-58087": {"epss_score": 0.00277, "epss_percentile": 0.50835}, "CVE-2024-58088": {"epss_score": 0.00028, "epss_percentile": 0.07267}, "CVE-2024-58089": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2024-58090": {"epss_score": 0.00032, "epss_percentile": 0.08851}, "CVE-2024-58091": {"epss_score": 0.00027, "epss_percentile": 0.07084}, "CVE-2024-58092": {"epss_score": 0.00017, "epss_percentile": 0.03057}, "CVE-2024-58093": {"epss_score": 0.00026, "epss_percentile": 0.06422}, "CVE-2024-58094": {"epss_score": 0.00037, "epss_percentile": 0.10979}, "CVE-2024-58095": {"epss_score": 0.00026, "epss_percentile": 0.06627}, "CVE-2024-58096": {"epss_score": 0.00031, "epss_percentile": 0.08388}, "CVE-2024-58097": {"epss_score": 0.00013, "epss_percentile": 0.0152}, "CVE-2024-58098": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2024-58099": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2024-58100": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2024-58101": {"epss_score": 0.00022, "epss_percentile": 0.05031}, "CVE-2024-58102": {"epss_score": 0.00073, "epss_percentile": 0.22606}, "CVE-2024-58103": {"epss_score": 0.00059, "epss_percentile": 0.1884}, "CVE-2024-58104": {"epss_score": 0.00016, "epss_percentile": 0.02854}, "CVE-2024-58105": {"epss_score": 0.00016, "epss_percentile": 0.02854}, "CVE-2024-58106": {"epss_score": 0.00034, "epss_percentile": 0.09803}, "CVE-2024-58107": {"epss_score": 0.00049, "epss_percentile": 0.1547}, "CVE-2024-58108": {"epss_score": 0.00034, "epss_percentile": 0.09803}, "CVE-2024-58109": {"epss_score": 0.00034, "epss_percentile": 0.09803}, "CVE-2024-58110": {"epss_score": 0.00034, "epss_percentile": 0.09803}, "CVE-2024-58111": {"epss_score": 0.0003, "epss_percentile": 0.08084}, "CVE-2024-58112": {"epss_score": 0.0003, "epss_percentile": 0.08084}, "CVE-2024-58113": {"epss_score": 0.00056, "epss_percentile": 0.17694}, "CVE-2024-58114": {"epss_score": 0.00011, "epss_percentile": 0.01052}, "CVE-2024-58115": {"epss_score": 0.00041, "epss_percentile": 0.12321}, "CVE-2024-58116": {"epss_score": 0.00041, "epss_percentile": 0.12321}, "CVE-2024-58117": {"epss_score": 0.0001, "epss_percentile": 0.00889}, "CVE-2024-58124": {"epss_score": 0.00029, "epss_percentile": 0.0791}, "CVE-2024-58125": {"epss_score": 0.00029, "epss_percentile": 0.0791}, "CVE-2024-58126": {"epss_score": 0.00029, "epss_percentile": 0.0791}, "CVE-2024-58127": {"epss_score": 0.00029, "epss_percentile": 0.0791}, "CVE-2024-58128": {"epss_score": 0.00055, "epss_percentile": 0.17443}, "CVE-2024-58129": {"epss_score": 0.00055, "epss_percentile": 0.17443}, "CVE-2024-58130": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2024-58131": {"epss_score": 0.00073, "epss_percentile": 0.22564}, "CVE-2024-58132": {"epss_score": 0.00053, "epss_percentile": 0.16678}, "CVE-2024-58133": {"epss_score": 0.00053, "epss_percentile": 0.16678}, "CVE-2024-58134": {"epss_score": 0.00067, "epss_percentile": 0.21086}, "CVE-2024-58135": {"epss_score": 0.00129, "epss_percentile": 0.33091}, "CVE-2024-58136": {"epss_score": 0.78443, "epss_percentile": 0.98987}, "CVE-2024-58237": {"epss_score": 0.00013, "epss_percentile": 0.01664}, "CVE-2024-58238": {"epss_score": 0.00016, "epss_percentile": 0.0262}, "CVE-2024-58239": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2024-58240": {"epss_score": 0.0005, "epss_percentile": 0.15896}, "CVE-2024-58241": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2024-58248": {"epss_score": 0.00037, "epss_percentile": 0.10887}, "CVE-2024-58249": {"epss_score": 0.00068, "epss_percentile": 0.21306}, "CVE-2024-58250": {"epss_score": 0.00027, "epss_percentile": 0.06741}, "CVE-2024-58251": {"epss_score": 0.00021, "epss_percentile": 0.04881}, "CVE-2024-58252": {"epss_score": 0.0001, "epss_percentile": 0.00896}, "CVE-2024-58253": {"epss_score": 0.00017, "epss_percentile": 0.03182}, "CVE-2024-58255": {"epss_score": 5e-05, "epss_percentile": 0.00187}, "CVE-2024-58256": {"epss_score": 6e-05, "epss_percentile": 0.00306}, "CVE-2024-58257": {"epss_score": 7e-05, "epss_percentile": 0.00415}, "CVE-2024-58258": {"epss_score": 0.01167, "epss_percentile": 0.78189}, "CVE-2024-58259": {"epss_score": 0.00039, "epss_percentile": 0.11631}, "CVE-2024-58260": {"epss_score": 0.00015, "epss_percentile": 0.02229}, "CVE-2024-58261": {"epss_score": 0.00016, "epss_percentile": 0.02648}, "CVE-2024-58262": {"epss_score": 0.00013, "epss_percentile": 0.01433}, "CVE-2024-58263": {"epss_score": 0.00044, "epss_percentile": 0.1349}, "CVE-2024-58264": {"epss_score": 0.00016, "epss_percentile": 0.02742}, "CVE-2024-58265": {"epss_score": 0.00045, "epss_percentile": 0.13822}, "CVE-2024-58266": {"epss_score": 0.00038, "epss_percentile": 0.11283}, "CVE-2024-58267": {"epss_score": 0.0001, "epss_percentile": 0.0086}, "CVE-2024-58269": {"epss_score": 0.00014, "epss_percentile": 0.01762}, "CVE-2024-58273": {"epss_score": 0.00023, "epss_percentile": 0.05328}, "CVE-2024-58274": {"epss_score": 0.00094, "epss_percentile": 0.26802}, "CVE-2024-58275": {"epss_score": 0.01025, "epss_percentile": 0.76787}, "CVE-2024-58276": {"epss_score": 0.00108, "epss_percentile": 0.29855}, "CVE-2024-58277": {"epss_score": 0.00334, "epss_percentile": 0.55688}, "CVE-2024-58278": {"epss_score": 0.00028, "epss_percentile": 0.07262}, "CVE-2024-58279": {"epss_score": 0.00356, "epss_percentile": 0.57356}, "CVE-2024-58280": {"epss_score": 0.00313, "epss_percentile": 0.54035}, "CVE-2024-58281": {"epss_score": 0.00203, "epss_percentile": 0.42516}, "CVE-2024-58282": {"epss_score": 0.0029, "epss_percentile": 0.52118}, "CVE-2024-58283": {"epss_score": 0.00532, "epss_percentile": 0.66677}, "CVE-2024-58284": {"epss_score": 0.00394, "epss_percentile": 0.59779}, "CVE-2024-58285": {"epss_score": 0.00031, "epss_percentile": 0.085}, "CVE-2024-58286": {"epss_score": 0.00586, "epss_percentile": 0.68436}, "CVE-2024-58287": {"epss_score": 0.01488, "epss_percentile": 0.80616}, "CVE-2024-58288": {"epss_score": 0.00065, "epss_percentile": 0.20461}, "CVE-2024-58289": {"epss_score": 0.00062, "epss_percentile": 0.19726}, "CVE-2024-58290": {"epss_score": 0.00038, "epss_percentile": 0.11075}, "CVE-2024-58291": {"epss_score": 0.00062, "epss_percentile": 0.19726}, "CVE-2024-58292": {"epss_score": 0.00088, "epss_percentile": 0.25761}, "CVE-2024-58293": {"epss_score": 0.00057, "epss_percentile": 0.18095}, "CVE-2024-58294": {"epss_score": 0.00762, "epss_percentile": 0.72842}, "CVE-2024-58295": {"epss_score": 0.00511, "epss_percentile": 0.65821}, "CVE-2024-58296": {"epss_score": 0.00067, "epss_percentile": 0.20975}, "CVE-2024-58297": {"epss_score": 0.00062, "epss_percentile": 0.19726}, "CVE-2024-58298": {"epss_score": 0.0174, "epss_percentile": 0.82045}, "CVE-2024-58299": {"epss_score": 0.00234, "epss_percentile": 0.4612}, "CVE-2024-58300": {"epss_score": 0.00242, "epss_percentile": 0.47358}, "CVE-2024-58301": {"epss_score": 0.00038, "epss_percentile": 0.11075}, "CVE-2024-58302": {"epss_score": 0.00051, "epss_percentile": 0.16158}, "CVE-2024-58303": {"epss_score": 0.00028, "epss_percentile": 0.0721}, "CVE-2024-58304": {"epss_score": 0.0007, "epss_percentile": 0.21674}, "CVE-2024-58305": {"epss_score": 0.00054, "epss_percentile": 0.17266}, "CVE-2024-58306": {"epss_score": 0.00273, "epss_percentile": 0.50458}, "CVE-2024-58307": {"epss_score": 0.00071, "epss_percentile": 0.22058}, "CVE-2024-58308": {"epss_score": 0.00782, "epss_percentile": 0.73201}, "CVE-2024-58309": {"epss_score": 0.00218, "epss_percentile": 0.444}, "CVE-2024-58310": {"epss_score": 0.00393, "epss_percentile": 0.59714}, "CVE-2024-58311": {"epss_score": 0.00055, "epss_percentile": 0.17561}, "CVE-2024-58312": {"epss_score": 0.0434, "epss_percentile": 0.88569}, "CVE-2024-58313": {"epss_score": 0.00103, "epss_percentile": 0.29017}, "CVE-2024-58314": {"epss_score": 0.00332, "epss_percentile": 0.55564}, "CVE-2024-58315": {"epss_score": 0.00014, "epss_percentile": 0.01786}, "CVE-2024-58316": {"epss_score": 0.00071, "epss_percentile": 0.22017}, "CVE-2024-58317": {"epss_score": 0.00026, "epss_percentile": 0.06719}, "CVE-2024-58318": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2024-58319": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2024-58320": {"epss_score": 0.00053, "epss_percentile": 0.16752}, "CVE-2024-58321": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2024-58322": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2024-58323": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2024-58335": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2024-58336": {"epss_score": 0.00274, "epss_percentile": 0.50494}, "CVE-2024-58337": {"epss_score": 0.00035, "epss_percentile": 0.09866}, "CVE-2024-58338": {"epss_score": 0.00079, "epss_percentile": 0.23991}, "CVE-2024-5000": {"epss_score": 0.00808, "epss_percentile": 0.73696}, "CVE-2024-5001": {"epss_score": 0.00225, "epss_percentile": 0.45095}, "CVE-2024-5002": {"epss_score": 0.0009, "epss_percentile": 0.26078}, "CVE-2024-5003": {"epss_score": 0.0014, "epss_percentile": 0.34798}, "CVE-2024-5004": {"epss_score": 0.00104, "epss_percentile": 0.29188}, "CVE-2024-5005": {"epss_score": 0.0004, "epss_percentile": 0.12001}, "CVE-2024-5006": {"epss_score": 0.00234, "epss_percentile": 0.46156}, "CVE-2024-5008": {"epss_score": 0.27191, "epss_percentile": 0.96219}, "CVE-2024-5009": {"epss_score": 0.36011, "epss_percentile": 0.96948}, "CVE-2024-5010": {"epss_score": 0.25145, "epss_percentile": 0.9599}, "CVE-2024-5011": {"epss_score": 0.07217, "epss_percentile": 0.91331}, "CVE-2024-5012": {"epss_score": 0.00944, "epss_percentile": 0.75782}, "CVE-2024-5013": {"epss_score": 0.01394, "epss_percentile": 0.79971}, "CVE-2024-5014": {"epss_score": 0.00101, "epss_percentile": 0.28637}, "CVE-2024-5015": {"epss_score": 0.00092, "epss_percentile": 0.26483}, "CVE-2024-5016": {"epss_score": 0.06188, "epss_percentile": 0.90546}, "CVE-2024-5017": {"epss_score": 0.01028, "epss_percentile": 0.76824}, "CVE-2024-5018": {"epss_score": 0.00222, "epss_percentile": 0.44768}, "CVE-2024-5019": {"epss_score": 0.00222, "epss_percentile": 0.44768}, "CVE-2024-5020": {"epss_score": 0.00211, "epss_percentile": 0.43687}, "CVE-2024-5021": {"epss_score": 0.00712, "epss_percentile": 0.71747}, "CVE-2024-5022": {"epss_score": 0.00209, "epss_percentile": 0.43394}, "CVE-2024-5023": {"epss_score": 0.00817, "epss_percentile": 0.73841}, "CVE-2024-5024": {"epss_score": 0.00811, "epss_percentile": 0.73729}, "CVE-2024-5025": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-5026": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-5028": {"epss_score": 0.00163, "epss_percentile": 0.3786}, "CVE-2024-5029": {"epss_score": 0.0013, "epss_percentile": 0.33299}, "CVE-2024-5030": {"epss_score": 0.00086, "epss_percentile": 0.25406}, "CVE-2024-5031": {"epss_score": 0.00503, "epss_percentile": 0.65459}, "CVE-2024-5032": {"epss_score": 0.0019, "epss_percentile": 0.41128}, "CVE-2024-5033": {"epss_score": 0.00104, "epss_percentile": 0.29213}, "CVE-2024-5034": {"epss_score": 0.0018, "epss_percentile": 0.39872}, "CVE-2024-5035": {"epss_score": 0.05963, "epss_percentile": 0.90367}, "CVE-2024-5036": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5037": {"epss_score": 0.00252, "epss_percentile": 0.48353}, "CVE-2024-5038": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5039": {"epss_score": 0.00361, "epss_percentile": 0.57745}, "CVE-2024-5040": {"epss_score": 0.0015, "epss_percentile": 0.3618}, "CVE-2024-5041": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5042": {"epss_score": 0.00177, "epss_percentile": 0.3952}, "CVE-2024-5043": {"epss_score": 0.00115, "epss_percentile": 0.31021}, "CVE-2024-5044": {"epss_score": 0.00245, "epss_percentile": 0.47675}, "CVE-2024-5045": {"epss_score": 0.00378, "epss_percentile": 0.58782}, "CVE-2024-5046": {"epss_score": 0.00136, "epss_percentile": 0.34177}, "CVE-2024-5047": {"epss_score": 0.00251, "epss_percentile": 0.48276}, "CVE-2024-5048": {"epss_score": 0.00136, "epss_percentile": 0.34199}, "CVE-2024-5049": {"epss_score": 0.0011, "epss_percentile": 0.30183}, "CVE-2024-5050": {"epss_score": 0.00055, "epss_percentile": 0.17461}, "CVE-2024-5051": {"epss_score": 0.001, "epss_percentile": 0.28546}, "CVE-2024-5052": {"epss_score": 0.00166, "epss_percentile": 0.38195}, "CVE-2024-5053": {"epss_score": 0.00092, "epss_percentile": 0.2642}, "CVE-2024-5055": {"epss_score": 0.00166, "epss_percentile": 0.38195}, "CVE-2024-5056": {"epss_score": 0.0013, "epss_percentile": 0.33321}, "CVE-2024-5057": {"epss_score": 0.52994, "epss_percentile": 0.97852}, "CVE-2024-5058": {"epss_score": 0.00152, "epss_percentile": 0.36372}, "CVE-2024-5059": {"epss_score": 0.01081, "epss_percentile": 0.77378}, "CVE-2024-5060": {"epss_score": 0.00445, "epss_percentile": 0.62862}, "CVE-2024-5061": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2024-5062": {"epss_score": 0.00168, "epss_percentile": 0.38502}, "CVE-2024-5063": {"epss_score": 0.00145, "epss_percentile": 0.35452}, "CVE-2024-5064": {"epss_score": 0.00145, "epss_percentile": 0.35452}, "CVE-2024-5065": {"epss_score": 0.00142, "epss_percentile": 0.35087}, "CVE-2024-5066": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-5067": {"epss_score": 0.00116, "epss_percentile": 0.31183}, "CVE-2024-5069": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-5071": {"epss_score": 0.00159, "epss_percentile": 0.37342}, "CVE-2024-5072": {"epss_score": 0.00448, "epss_percentile": 0.63028}, "CVE-2024-5073": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5074": {"epss_score": 0.00195, "epss_percentile": 0.41706}, "CVE-2024-5075": {"epss_score": 0.00264, "epss_percentile": 0.49681}, "CVE-2024-5076": {"epss_score": 0.00562, "epss_percentile": 0.67688}, "CVE-2024-5077": {"epss_score": 0.00202, "epss_percentile": 0.42432}, "CVE-2024-5079": {"epss_score": 0.01544, "epss_percentile": 0.8096}, "CVE-2024-5080": {"epss_score": 0.00889, "epss_percentile": 0.7501}, "CVE-2024-5081": {"epss_score": 0.00259, "epss_percentile": 0.49082}, "CVE-2024-5082": {"epss_score": 0.04785, "epss_percentile": 0.89141}, "CVE-2024-5083": {"epss_score": 0.0039, "epss_percentile": 0.5954}, "CVE-2024-5084": {"epss_score": 0.92524, "epss_percentile": 0.99723}, "CVE-2024-5085": {"epss_score": 0.0441, "epss_percentile": 0.88659}, "CVE-2024-5086": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-5087": {"epss_score": 0.00232, "epss_percentile": 0.45933}, "CVE-2024-5088": {"epss_score": 0.00228, "epss_percentile": 0.45463}, "CVE-2024-5090": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-5091": {"epss_score": 0.00198, "epss_percentile": 0.42047}, "CVE-2024-5092": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5093": {"epss_score": 0.00083, "epss_percentile": 0.24812}, "CVE-2024-5094": {"epss_score": 0.00106, "epss_percentile": 0.29563}, "CVE-2024-5095": {"epss_score": 0.00092, "epss_percentile": 0.26548}, "CVE-2024-5096": {"epss_score": 0.00064, "epss_percentile": 0.20335}, "CVE-2024-5097": {"epss_score": 0.00172, "epss_percentile": 0.39003}, "CVE-2024-5098": {"epss_score": 0.00042, "epss_percentile": 0.1271}, "CVE-2024-5099": {"epss_score": 0.0008, "epss_percentile": 0.24183}, "CVE-2024-5100": {"epss_score": 0.0008, "epss_percentile": 0.24183}, "CVE-2024-5101": {"epss_score": 0.00099, "epss_percentile": 0.28427}, "CVE-2024-5102": {"epss_score": 0.00106, "epss_percentile": 0.29429}, "CVE-2024-5103": {"epss_score": 0.00096, "epss_percentile": 0.27245}, "CVE-2024-5104": {"epss_score": 0.00131, "epss_percentile": 0.33419}, "CVE-2024-5105": {"epss_score": 0.00131, "epss_percentile": 0.33419}, "CVE-2024-5106": {"epss_score": 0.00108, "epss_percentile": 0.29879}, "CVE-2024-5107": {"epss_score": 0.00115, "epss_percentile": 0.31001}, "CVE-2024-5108": {"epss_score": 0.00115, "epss_percentile": 0.31001}, "CVE-2024-5109": {"epss_score": 0.00115, "epss_percentile": 0.31001}, "CVE-2024-5110": {"epss_score": 0.00115, "epss_percentile": 0.31001}, "CVE-2024-5111": {"epss_score": 0.00058, "epss_percentile": 0.18493}, "CVE-2024-5112": {"epss_score": 0.00038, "epss_percentile": 0.11308}, "CVE-2024-5113": {"epss_score": 0.00038, "epss_percentile": 0.11308}, "CVE-2024-5114": {"epss_score": 0.0007, "epss_percentile": 0.21869}, "CVE-2024-5115": {"epss_score": 0.00026, "epss_percentile": 0.06446}, "CVE-2024-5116": {"epss_score": 0.00136, "epss_percentile": 0.34177}, "CVE-2024-5117": {"epss_score": 0.00098, "epss_percentile": 0.27826}, "CVE-2024-5118": {"epss_score": 0.00136, "epss_percentile": 0.34177}, "CVE-2024-5119": {"epss_score": 0.00145, "epss_percentile": 0.35488}, "CVE-2024-5120": {"epss_score": 0.00145, "epss_percentile": 0.35488}, "CVE-2024-5121": {"epss_score": 0.00252, "epss_percentile": 0.48371}, "CVE-2024-5122": {"epss_score": 0.00145, "epss_percentile": 0.35452}, "CVE-2024-5123": {"epss_score": 0.00078, "epss_percentile": 0.2375}, "CVE-2024-5124": {"epss_score": 0.49316, "epss_percentile": 0.97679}, "CVE-2024-5125": {"epss_score": 0.0009, "epss_percentile": 0.26125}, "CVE-2024-5126": {"epss_score": 0.00124, "epss_percentile": 0.32462}, "CVE-2024-5127": {"epss_score": 0.00103, "epss_percentile": 0.29098}, "CVE-2024-5128": {"epss_score": 0.00193, "epss_percentile": 0.41488}, "CVE-2024-5129": {"epss_score": 0.00138, "epss_percentile": 0.34369}, "CVE-2024-5130": {"epss_score": 0.00299, "epss_percentile": 0.52882}, "CVE-2024-5131": {"epss_score": 0.00215, "epss_percentile": 0.44097}, "CVE-2024-5133": {"epss_score": 0.00242, "epss_percentile": 0.47402}, "CVE-2024-5134": {"epss_score": 0.00145, "epss_percentile": 0.35488}, "CVE-2024-5135": {"epss_score": 0.00106, "epss_percentile": 0.29489}, "CVE-2024-5136": {"epss_score": 0.00054, "epss_percentile": 0.17165}, "CVE-2024-5137": {"epss_score": 0.0004, "epss_percentile": 0.11924}, "CVE-2024-5138": {"epss_score": 0.00943, "epss_percentile": 0.75781}, "CVE-2024-5141": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5142": {"epss_score": 0.00954, "epss_percentile": 0.75905}, "CVE-2024-5143": {"epss_score": 0.00094, "epss_percentile": 0.27078}, "CVE-2024-5145": {"epss_score": 0.00148, "epss_percentile": 0.35895}, "CVE-2024-5147": {"epss_score": 0.00764, "epss_percentile": 0.72908}, "CVE-2024-5148": {"epss_score": 0.002, "epss_percentile": 0.42217}, "CVE-2024-5149": {"epss_score": 0.00167, "epss_percentile": 0.38397}, "CVE-2024-5150": {"epss_score": 0.00633, "epss_percentile": 0.69769}, "CVE-2024-5151": {"epss_score": 0.00176, "epss_percentile": 0.3946}, "CVE-2024-5152": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5153": {"epss_score": 0.05452, "epss_percentile": 0.89892}, "CVE-2024-5154": {"epss_score": 0.01616, "epss_percentile": 0.81354}, "CVE-2024-5155": {"epss_score": 0.00174, "epss_percentile": 0.392}, "CVE-2024-5156": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5157": {"epss_score": 0.00724, "epss_percentile": 0.72042}, "CVE-2024-5158": {"epss_score": 0.00144, "epss_percentile": 0.35237}, "CVE-2024-5159": {"epss_score": 0.00277, "epss_percentile": 0.5081}, "CVE-2024-5160": {"epss_score": 0.00242, "epss_percentile": 0.47409}, "CVE-2024-5161": {"epss_score": 0.00225, "epss_percentile": 0.45095}, "CVE-2024-5162": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5163": {"epss_score": 0.00168, "epss_percentile": 0.38477}, "CVE-2024-5165": {"epss_score": 0.00882, "epss_percentile": 0.74881}, "CVE-2024-5166": {"epss_score": 0.00067, "epss_percentile": 0.20999}, "CVE-2024-5167": {"epss_score": 0.00145, "epss_percentile": 0.35527}, "CVE-2024-5168": {"epss_score": 0.00054, "epss_percentile": 0.17233}, "CVE-2024-5169": {"epss_score": 0.00148, "epss_percentile": 0.35858}, "CVE-2024-5170": {"epss_score": 0.00078, "epss_percentile": 0.2377}, "CVE-2024-5171": {"epss_score": 0.00209, "epss_percentile": 0.43375}, "CVE-2024-5172": {"epss_score": 0.00284, "epss_percentile": 0.51433}, "CVE-2024-5173": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-5174": {"epss_score": 0.00154, "epss_percentile": 0.36647}, "CVE-2024-5176": {"epss_score": 0.00147, "epss_percentile": 0.35688}, "CVE-2024-5177": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5178": {"epss_score": 0.01405, "epss_percentile": 0.80043}, "CVE-2024-5179": {"epss_score": 0.00329, "epss_percentile": 0.55323}, "CVE-2024-5181": {"epss_score": 0.01048, "epss_percentile": 0.77055}, "CVE-2024-5182": {"epss_score": 0.02492, "epss_percentile": 0.84899}, "CVE-2024-5184": {"epss_score": 0.00107, "epss_percentile": 0.29655}, "CVE-2024-5185": {"epss_score": 0.00099, "epss_percentile": 0.27837}, "CVE-2024-5186": {"epss_score": 0.00106, "epss_percentile": 0.29418}, "CVE-2024-5187": {"epss_score": 0.01357, "epss_percentile": 0.79719}, "CVE-2024-5188": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5189": {"epss_score": 0.00195, "epss_percentile": 0.41653}, "CVE-2024-5191": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5192": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5193": {"epss_score": 0.00391, "epss_percentile": 0.59631}, "CVE-2024-5194": {"epss_score": 0.01051, "epss_percentile": 0.77077}, "CVE-2024-5195": {"epss_score": 0.00203, "epss_percentile": 0.42505}, "CVE-2024-5196": {"epss_score": 0.00256, "epss_percentile": 0.48741}, "CVE-2024-5197": {"epss_score": 0.00353, "epss_percentile": 0.57172}, "CVE-2024-5198": {"epss_score": 0.00036, "epss_percentile": 0.10379}, "CVE-2024-5199": {"epss_score": 0.00216, "epss_percentile": 0.44191}, "CVE-2024-5200": {"epss_score": 0.00036, "epss_percentile": 0.10445}, "CVE-2024-5201": {"epss_score": 0.00141, "epss_percentile": 0.34942}, "CVE-2024-5202": {"epss_score": 0.00164, "epss_percentile": 0.3795}, "CVE-2024-5204": {"epss_score": 0.00134, "epss_percentile": 0.33855}, "CVE-2024-5205": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5206": {"epss_score": 0.00037, "epss_percentile": 0.10968}, "CVE-2024-5207": {"epss_score": 0.00905, "epss_percentile": 0.75233}, "CVE-2024-5208": {"epss_score": 0.00116, "epss_percentile": 0.31132}, "CVE-2024-5209": {"epss_score": 0.00071, "epss_percentile": 0.2219}, "CVE-2024-5210": {"epss_score": 0.00071, "epss_percentile": 0.2219}, "CVE-2024-5211": {"epss_score": 0.00048, "epss_percentile": 0.1528}, "CVE-2024-5212": {"epss_score": 0.00622, "epss_percentile": 0.695}, "CVE-2024-5213": {"epss_score": 0.00246, "epss_percentile": 0.47752}, "CVE-2024-5215": {"epss_score": 0.00187, "epss_percentile": 0.40743}, "CVE-2024-5216": {"epss_score": 0.00195, "epss_percentile": 0.41672}, "CVE-2024-5217": {"epss_score": 0.94108, "epss_percentile": 0.99904}, "CVE-2024-5218": {"epss_score": 0.00167, "epss_percentile": 0.38396}, "CVE-2024-5219": {"epss_score": 0.00277, "epss_percentile": 0.50787}, "CVE-2024-5220": {"epss_score": 0.00254, "epss_percentile": 0.48542}, "CVE-2024-5221": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5222": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5223": {"epss_score": 0.00255, "epss_percentile": 0.48728}, "CVE-2024-5224": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5225": {"epss_score": 0.00243, "epss_percentile": 0.47481}, "CVE-2024-5226": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5227": {"epss_score": 0.01163, "epss_percentile": 0.78157}, "CVE-2024-5228": {"epss_score": 0.03327, "epss_percentile": 0.86925}, "CVE-2024-5229": {"epss_score": 0.00268, "epss_percentile": 0.50067}, "CVE-2024-5230": {"epss_score": 0.36319, "epss_percentile": 0.9697}, "CVE-2024-5231": {"epss_score": 0.00213, "epss_percentile": 0.43845}, "CVE-2024-5232": {"epss_score": 0.00095, "epss_percentile": 0.27212}, "CVE-2024-5233": {"epss_score": 0.00115, "epss_percentile": 0.31001}, "CVE-2024-5234": {"epss_score": 0.00157, "epss_percentile": 0.37023}, "CVE-2024-5235": {"epss_score": 0.00115, "epss_percentile": 0.31001}, "CVE-2024-5236": {"epss_score": 0.00095, "epss_percentile": 0.27212}, "CVE-2024-5237": {"epss_score": 0.00157, "epss_percentile": 0.37023}, "CVE-2024-5238": {"epss_score": 0.00157, "epss_percentile": 0.37023}, "CVE-2024-5239": {"epss_score": 0.00213, "epss_percentile": 0.43845}, "CVE-2024-5240": {"epss_score": 0.00213, "epss_percentile": 0.43845}, "CVE-2024-5241": {"epss_score": 0.00562, "epss_percentile": 0.67695}, "CVE-2024-5242": {"epss_score": 0.01738, "epss_percentile": 0.82027}, "CVE-2024-5243": {"epss_score": 0.01738, "epss_percentile": 0.82027}, "CVE-2024-5244": {"epss_score": 0.00079, "epss_percentile": 0.23966}, "CVE-2024-5245": {"epss_score": 0.00172, "epss_percentile": 0.38925}, "CVE-2024-5246": {"epss_score": 0.74714, "epss_percentile": 0.98814}, "CVE-2024-5247": {"epss_score": 0.58149, "epss_percentile": 0.98101}, "CVE-2024-5248": {"epss_score": 0.00262, "epss_percentile": 0.49405}, "CVE-2024-5249": {"epss_score": 0.00258, "epss_percentile": 0.48988}, "CVE-2024-5250": {"epss_score": 0.00494, "epss_percentile": 0.6508}, "CVE-2024-5251": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-5252": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-5253": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-5254": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-5255": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-5256": {"epss_score": 0.00071, "epss_percentile": 0.22224}, "CVE-2024-5257": {"epss_score": 0.00027, "epss_percentile": 0.07158}, "CVE-2024-5258": {"epss_score": 0.00012, "epss_percentile": 0.01208}, "CVE-2024-5259": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5260": {"epss_score": 0.00169, "epss_percentile": 0.38523}, "CVE-2024-5261": {"epss_score": 0.00565, "epss_percentile": 0.67796}, "CVE-2024-5262": {"epss_score": 0.00592, "epss_percentile": 0.68605}, "CVE-2024-5263": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5264": {"epss_score": 0.00048, "epss_percentile": 0.15176}, "CVE-2024-5265": {"epss_score": 0.00589, "epss_percentile": 0.68532}, "CVE-2024-5266": {"epss_score": 0.00759, "epss_percentile": 0.72786}, "CVE-2024-5267": {"epss_score": 0.01337, "epss_percentile": 0.7956}, "CVE-2024-5268": {"epss_score": 0.00215, "epss_percentile": 0.44028}, "CVE-2024-5269": {"epss_score": 0.02933, "epss_percentile": 0.8602}, "CVE-2024-5270": {"epss_score": 0.00212, "epss_percentile": 0.43744}, "CVE-2024-5271": {"epss_score": 0.00137, "epss_percentile": 0.34232}, "CVE-2024-5272": {"epss_score": 0.00278, "epss_percentile": 0.50846}, "CVE-2024-5273": {"epss_score": 0.00171, "epss_percentile": 0.38788}, "CVE-2024-5274": {"epss_score": 0.06357, "epss_percentile": 0.90695}, "CVE-2024-5275": {"epss_score": 0.00048, "epss_percentile": 0.1499}, "CVE-2024-5276": {"epss_score": 0.85363, "epss_percentile": 0.99331}, "CVE-2024-5277": {"epss_score": 0.00138, "epss_percentile": 0.34351}, "CVE-2024-5278": {"epss_score": 0.00511, "epss_percentile": 0.65822}, "CVE-2024-5279": {"epss_score": 0.00138, "epss_percentile": 0.345}, "CVE-2024-5280": {"epss_score": 0.00209, "epss_percentile": 0.43404}, "CVE-2024-5281": {"epss_score": 0.00244, "epss_percentile": 0.47601}, "CVE-2024-5282": {"epss_score": 0.00396, "epss_percentile": 0.59881}, "CVE-2024-5283": {"epss_score": 0.00319, "epss_percentile": 0.54567}, "CVE-2024-5284": {"epss_score": 0.00085, "epss_percentile": 0.25091}, "CVE-2024-5285": {"epss_score": 0.0013, "epss_percentile": 0.33335}, "CVE-2024-5286": {"epss_score": 0.00091, "epss_percentile": 0.26196}, "CVE-2024-5287": {"epss_score": 0.00075, "epss_percentile": 0.23037}, "CVE-2024-5288": {"epss_score": 0.00046, "epss_percentile": 0.14145}, "CVE-2024-5289": {"epss_score": 0.00254, "epss_percentile": 0.48542}, "CVE-2024-5290": {"epss_score": 0.00316, "epss_percentile": 0.54222}, "CVE-2024-5291": {"epss_score": 0.04555, "epss_percentile": 0.88844}, "CVE-2024-5292": {"epss_score": 0.00122, "epss_percentile": 0.32132}, "CVE-2024-5293": {"epss_score": 0.01278, "epss_percentile": 0.79122}, "CVE-2024-5294": {"epss_score": 0.00111, "epss_percentile": 0.30323}, "CVE-2024-5295": {"epss_score": 0.04251, "epss_percentile": 0.88451}, "CVE-2024-5296": {"epss_score": 0.014, "epss_percentile": 0.80002}, "CVE-2024-5297": {"epss_score": 0.00828, "epss_percentile": 0.73996}, "CVE-2024-5298": {"epss_score": 0.04097, "epss_percentile": 0.88251}, "CVE-2024-5299": {"epss_score": 0.04097, "epss_percentile": 0.88251}, "CVE-2024-5301": {"epss_score": 0.01881, "epss_percentile": 0.8269}, "CVE-2024-5302": {"epss_score": 0.00842, "epss_percentile": 0.74236}, "CVE-2024-5303": {"epss_score": 0.0098, "epss_percentile": 0.76266}, "CVE-2024-5304": {"epss_score": 0.01291, "epss_percentile": 0.79225}, "CVE-2024-5305": {"epss_score": 0.01881, "epss_percentile": 0.8269}, "CVE-2024-5306": {"epss_score": 0.01291, "epss_percentile": 0.79225}, "CVE-2024-5307": {"epss_score": 0.00222, "epss_percentile": 0.44774}, "CVE-2024-5309": {"epss_score": 0.00253, "epss_percentile": 0.48452}, "CVE-2024-5310": {"epss_score": 0.00742, "epss_percentile": 0.72461}, "CVE-2024-5311": {"epss_score": 0.00687, "epss_percentile": 0.71184}, "CVE-2024-5312": {"epss_score": 0.00318, "epss_percentile": 0.54424}, "CVE-2024-5313": {"epss_score": 0.00196, "epss_percentile": 0.41794}, "CVE-2024-5314": {"epss_score": 0.00208, "epss_percentile": 0.43254}, "CVE-2024-5315": {"epss_score": 0.53695, "epss_percentile": 0.97892}, "CVE-2024-5317": {"epss_score": 0.00408, "epss_percentile": 0.60624}, "CVE-2024-5318": {"epss_score": 0.00037, "epss_percentile": 0.10957}, "CVE-2024-5321": {"epss_score": 0.00071, "epss_percentile": 0.21994}, "CVE-2024-5322": {"epss_score": 0.00109, "epss_percentile": 0.29971}, "CVE-2024-5324": {"epss_score": 0.43728, "epss_percentile": 0.974}, "CVE-2024-5325": {"epss_score": 0.01029, "epss_percentile": 0.76829}, "CVE-2024-5326": {"epss_score": 0.52926, "epss_percentile": 0.97846}, "CVE-2024-5327": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5328": {"epss_score": 0.00198, "epss_percentile": 0.42028}, "CVE-2024-5329": {"epss_score": 0.00634, "epss_percentile": 0.69806}, "CVE-2024-5330": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5331": {"epss_score": 0.00115, "epss_percentile": 0.30907}, "CVE-2024-5332": {"epss_score": 0.00286, "epss_percentile": 0.51692}, "CVE-2024-5333": {"epss_score": 0.00074, "epss_percentile": 0.22872}, "CVE-2024-5334": {"epss_score": 0.60416, "epss_percentile": 0.98206}, "CVE-2024-5335": {"epss_score": 0.10318, "epss_percentile": 0.92942}, "CVE-2024-5336": {"epss_score": 0.00148, "epss_percentile": 0.35831}, "CVE-2024-5337": {"epss_score": 0.00148, "epss_percentile": 0.35831}, "CVE-2024-5338": {"epss_score": 0.0036, "epss_percentile": 0.57675}, "CVE-2024-5339": {"epss_score": 0.0036, "epss_percentile": 0.57675}, "CVE-2024-5340": {"epss_score": 0.00331, "epss_percentile": 0.55531}, "CVE-2024-5341": {"epss_score": 0.00374, "epss_percentile": 0.58567}, "CVE-2024-5342": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5343": {"epss_score": 0.00263, "epss_percentile": 0.4951}, "CVE-2024-5344": {"epss_score": 0.01302, "epss_percentile": 0.79296}, "CVE-2024-5345": {"epss_score": 0.00549, "epss_percentile": 0.67309}, "CVE-2024-5346": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5347": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5348": {"epss_score": 0.00365, "epss_percentile": 0.57969}, "CVE-2024-5349": {"epss_score": 0.00487, "epss_percentile": 0.64824}, "CVE-2024-5350": {"epss_score": 0.0009, "epss_percentile": 0.26102}, "CVE-2024-5351": {"epss_score": 0.00099, "epss_percentile": 0.2841}, "CVE-2024-5352": {"epss_score": 0.00099, "epss_percentile": 0.2841}, "CVE-2024-5353": {"epss_score": 0.00174, "epss_percentile": 0.3919}, "CVE-2024-5354": {"epss_score": 0.00074, "epss_percentile": 0.22725}, "CVE-2024-5355": {"epss_score": 0.01047, "epss_percentile": 0.77042}, "CVE-2024-5356": {"epss_score": 0.06337, "epss_percentile": 0.9068}, "CVE-2024-5357": {"epss_score": 0.00095, "epss_percentile": 0.27237}, "CVE-2024-5358": {"epss_score": 0.00096, "epss_percentile": 0.27245}, "CVE-2024-5359": {"epss_score": 0.0008, "epss_percentile": 0.24055}, "CVE-2024-5360": {"epss_score": 0.00096, "epss_percentile": 0.27245}, "CVE-2024-5361": {"epss_score": 0.00073, "epss_percentile": 0.22576}, "CVE-2024-5362": {"epss_score": 0.00135, "epss_percentile": 0.3401}, "CVE-2024-5363": {"epss_score": 0.00054, "epss_percentile": 0.17109}, "CVE-2024-5364": {"epss_score": 0.00029, "epss_percentile": 0.07858}, "CVE-2024-5365": {"epss_score": 0.00054, "epss_percentile": 0.17109}, "CVE-2024-5366": {"epss_score": 0.00029, "epss_percentile": 0.07858}, "CVE-2024-5367": {"epss_score": 0.00131, "epss_percentile": 0.33482}, "CVE-2024-5368": {"epss_score": 0.00143, "epss_percentile": 0.35169}, "CVE-2024-5369": {"epss_score": 0.0018, "epss_percentile": 0.39924}, "CVE-2024-5370": {"epss_score": 0.00166, "epss_percentile": 0.38156}, "CVE-2024-5371": {"epss_score": 0.00166, "epss_percentile": 0.38156}, "CVE-2024-5372": {"epss_score": 0.00127, "epss_percentile": 0.32798}, "CVE-2024-5373": {"epss_score": 0.00166, "epss_percentile": 0.38156}, "CVE-2024-5374": {"epss_score": 0.00166, "epss_percentile": 0.38156}, "CVE-2024-5375": {"epss_score": 0.00166, "epss_percentile": 0.38156}, "CVE-2024-5376": {"epss_score": 0.00166, "epss_percentile": 0.38156}, "CVE-2024-5377": {"epss_score": 0.00183, "epss_percentile": 0.40293}, "CVE-2024-5378": {"epss_score": 0.00099, "epss_percentile": 0.28427}, "CVE-2024-5379": {"epss_score": 0.00955, "epss_percentile": 0.75909}, "CVE-2024-5380": {"epss_score": 0.00129, "epss_percentile": 0.33186}, "CVE-2024-5381": {"epss_score": 0.00054, "epss_percentile": 0.17181}, "CVE-2024-5382": {"epss_score": 0.00238, "epss_percentile": 0.46774}, "CVE-2024-5383": {"epss_score": 0.00118, "epss_percentile": 0.31422}, "CVE-2024-5384": {"epss_score": 0.00133, "epss_percentile": 0.33625}, "CVE-2024-5385": {"epss_score": 0.00058, "epss_percentile": 0.18306}, "CVE-2024-5389": {"epss_score": 0.00125, "epss_percentile": 0.32589}, "CVE-2024-5390": {"epss_score": 0.00078, "epss_percentile": 0.23782}, "CVE-2024-5391": {"epss_score": 0.00043, "epss_percentile": 0.12957}, "CVE-2024-5392": {"epss_score": 0.00078, "epss_percentile": 0.23782}, "CVE-2024-5393": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-5394": {"epss_score": 0.00078, "epss_percentile": 0.23782}, "CVE-2024-5395": {"epss_score": 0.00078, "epss_percentile": 0.23782}, "CVE-2024-5396": {"epss_score": 0.00078, "epss_percentile": 0.23782}, "CVE-2024-5397": {"epss_score": 0.00043, "epss_percentile": 0.12957}, "CVE-2024-5399": {"epss_score": 0.00592, "epss_percentile": 0.68602}, "CVE-2024-5400": {"epss_score": 0.00848, "epss_percentile": 0.74358}, "CVE-2024-5401": {"epss_score": 0.00052, "epss_percentile": 0.16359}, "CVE-2024-5402": {"epss_score": 0.00082, "epss_percentile": 0.24555}, "CVE-2024-5403": {"epss_score": 0.00802, "epss_percentile": 0.73589}, "CVE-2024-5404": {"epss_score": 0.00977, "epss_percentile": 0.76219}, "CVE-2024-5405": {"epss_score": 0.00445, "epss_percentile": 0.62889}, "CVE-2024-5406": {"epss_score": 0.00445, "epss_percentile": 0.62889}, "CVE-2024-5407": {"epss_score": 0.01615, "epss_percentile": 0.81348}, "CVE-2024-5408": {"epss_score": 0.00103, "epss_percentile": 0.2896}, "CVE-2024-5409": {"epss_score": 0.00174, "epss_percentile": 0.39227}, "CVE-2024-5410": {"epss_score": 0.00477, "epss_percentile": 0.64295}, "CVE-2024-5411": {"epss_score": 0.27226, "epss_percentile": 0.96223}, "CVE-2024-5412": {"epss_score": 0.00801, "epss_percentile": 0.73562}, "CVE-2024-5413": {"epss_score": 0.00237, "epss_percentile": 0.46688}, "CVE-2024-5414": {"epss_score": 0.00241, "epss_percentile": 0.47328}, "CVE-2024-5415": {"epss_score": 0.00241, "epss_percentile": 0.47328}, "CVE-2024-5416": {"epss_score": 0.00279, "epss_percentile": 0.50953}, "CVE-2024-5417": {"epss_score": 0.00124, "epss_percentile": 0.32448}, "CVE-2024-5418": {"epss_score": 0.00363, "epss_percentile": 0.57821}, "CVE-2024-5419": {"epss_score": 0.00391, "epss_percentile": 0.59629}, "CVE-2024-5420": {"epss_score": 0.40163, "epss_percentile": 0.97204}, "CVE-2024-5421": {"epss_score": 0.23759, "epss_percentile": 0.95813}, "CVE-2024-5422": {"epss_score": 0.00108, "epss_percentile": 0.29844}, "CVE-2024-5423": {"epss_score": 0.00343, "epss_percentile": 0.56461}, "CVE-2024-5424": {"epss_score": 0.00213, "epss_percentile": 0.43851}, "CVE-2024-5425": {"epss_score": 0.00361, "epss_percentile": 0.57714}, "CVE-2024-5426": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5427": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5428": {"epss_score": 0.00148, "epss_percentile": 0.35845}, "CVE-2024-5429": {"epss_score": 0.00318, "epss_percentile": 0.5445}, "CVE-2024-5430": {"epss_score": 0.00021, "epss_percentile": 0.04842}, "CVE-2024-5431": {"epss_score": 0.01406, "epss_percentile": 0.80048}, "CVE-2024-5432": {"epss_score": 0.01107, "epss_percentile": 0.77624}, "CVE-2024-5433": {"epss_score": 0.0047, "epss_percentile": 0.63969}, "CVE-2024-5434": {"epss_score": 0.00086, "epss_percentile": 0.25395}, "CVE-2024-5435": {"epss_score": 0.00042, "epss_percentile": 0.12882}, "CVE-2024-5436": {"epss_score": 0.00199, "epss_percentile": 0.42114}, "CVE-2024-5437": {"epss_score": 0.00131, "epss_percentile": 0.33449}, "CVE-2024-5438": {"epss_score": 0.00146, "epss_percentile": 0.35539}, "CVE-2024-5439": {"epss_score": 0.00408, "epss_percentile": 0.60624}, "CVE-2024-5440": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2024-5441": {"epss_score": 0.19691, "epss_percentile": 0.95227}, "CVE-2024-5442": {"epss_score": 0.00243, "epss_percentile": 0.47505}, "CVE-2024-5443": {"epss_score": 0.17468, "epss_percentile": 0.94854}, "CVE-2024-5444": {"epss_score": 0.00219, "epss_percentile": 0.44518}, "CVE-2024-5445": {"epss_score": 0.00115, "epss_percentile": 0.30926}, "CVE-2024-5447": {"epss_score": 0.00091, "epss_percentile": 0.26235}, "CVE-2024-5448": {"epss_score": 0.00442, "epss_percentile": 0.62713}, "CVE-2024-5449": {"epss_score": 0.0013, "epss_percentile": 0.33299}, "CVE-2024-5450": {"epss_score": 0.02687, "epss_percentile": 0.85429}, "CVE-2024-5451": {"epss_score": 0.00254, "epss_percentile": 0.48542}, "CVE-2024-5452": {"epss_score": 0.48457, "epss_percentile": 0.97639}, "CVE-2024-5453": {"epss_score": 0.00135, "epss_percentile": 0.34033}, "CVE-2024-5455": {"epss_score": 0.00388, "epss_percentile": 0.59355}, "CVE-2024-5456": {"epss_score": 0.00576, "epss_percentile": 0.68133}, "CVE-2024-5457": {"epss_score": 0.00335, "epss_percentile": 0.55856}, "CVE-2024-5458": {"epss_score": 0.04305, "epss_percentile": 0.8852}, "CVE-2024-5459": {"epss_score": 0.00204, "epss_percentile": 0.42658}, "CVE-2024-5460": {"epss_score": 0.00794, "epss_percentile": 0.73455}, "CVE-2024-5461": {"epss_score": 0.00285, "epss_percentile": 0.51659}, "CVE-2024-5462": {"epss_score": 0.00111, "epss_percentile": 0.3039}, "CVE-2024-5463": {"epss_score": 0.02429, "epss_percentile": 0.84725}, "CVE-2024-5464": {"epss_score": 0.00079, "epss_percentile": 0.23954}, "CVE-2024-5465": {"epss_score": 0.00041, "epss_percentile": 0.1228}, "CVE-2024-5466": {"epss_score": 0.1049, "epss_percentile": 0.93005}, "CVE-2024-5467": {"epss_score": 0.0032, "epss_percentile": 0.54587}, "CVE-2024-5468": {"epss_score": 0.00118, "epss_percentile": 0.31503}, "CVE-2024-5469": {"epss_score": 0.00116, "epss_percentile": 0.31041}, "CVE-2024-5470": {"epss_score": 0.00053, "epss_percentile": 0.16698}, "CVE-2024-5471": {"epss_score": 0.04519, "epss_percentile": 0.88796}, "CVE-2024-5472": {"epss_score": 0.00175, "epss_percentile": 0.39364}, "CVE-2024-5473": {"epss_score": 0.0004, "epss_percentile": 0.1217}, "CVE-2024-5474": {"epss_score": 0.0006, "epss_percentile": 0.19006}, "CVE-2024-5475": {"epss_score": 0.00193, "epss_percentile": 0.41453}, "CVE-2024-5477": {"epss_score": 0.00036, "epss_percentile": 0.10495}, "CVE-2024-5478": {"epss_score": 0.00386, "epss_percentile": 0.59247}, "CVE-2024-5479": {"epss_score": 0.02797, "epss_percentile": 0.85684}, "CVE-2024-5481": {"epss_score": 0.00908, "epss_percentile": 0.75289}, "CVE-2024-5482": {"epss_score": 0.00338, "epss_percentile": 0.56068}, "CVE-2024-5483": {"epss_score": 0.00567, "epss_percentile": 0.6785}, "CVE-2024-5485": {"epss_score": 0.0038, "epss_percentile": 0.58931}, "CVE-2024-5486": {"epss_score": 0.00418, "epss_percentile": 0.6128}, "CVE-2024-5487": {"epss_score": 0.00684, "epss_percentile": 0.71119}, "CVE-2024-5488": {"epss_score": 0.74795, "epss_percentile": 0.98817}, "CVE-2024-5489": {"epss_score": 0.00131, "epss_percentile": 0.33373}, "CVE-2024-5490": {"epss_score": 0.00504, "epss_percentile": 0.65544}, "CVE-2024-5491": {"epss_score": 0.00388, "epss_percentile": 0.59372}, "CVE-2024-5492": {"epss_score": 0.01381, "epss_percentile": 0.79868}, "CVE-2024-5493": {"epss_score": 0.00739, "epss_percentile": 0.72397}, "CVE-2024-5494": {"epss_score": 0.00566, "epss_percentile": 0.67818}, "CVE-2024-5495": {"epss_score": 0.00334, "epss_percentile": 0.55719}, "CVE-2024-5496": {"epss_score": 0.00884, "epss_percentile": 0.74924}, "CVE-2024-5497": {"epss_score": 0.00384, "epss_percentile": 0.59173}, "CVE-2024-5498": {"epss_score": 0.00148, "epss_percentile": 0.35833}, "CVE-2024-5499": {"epss_score": 0.01329, "epss_percentile": 0.79502}, "CVE-2024-5500": {"epss_score": 0.0007, "epss_percentile": 0.21744}, "CVE-2024-5501": {"epss_score": 0.00361, "epss_percentile": 0.57745}, "CVE-2024-5502": {"epss_score": 0.00172, "epss_percentile": 0.39012}, "CVE-2024-5503": {"epss_score": 0.00264, "epss_percentile": 0.4971}, "CVE-2024-5504": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5505": {"epss_score": 0.76002, "epss_percentile": 0.98873}, "CVE-2024-5506": {"epss_score": 0.02584, "epss_percentile": 0.85162}, "CVE-2024-5507": {"epss_score": 0.03881, "epss_percentile": 0.87896}, "CVE-2024-5508": {"epss_score": 0.02584, "epss_percentile": 0.85162}, "CVE-2024-5509": {"epss_score": 0.05013, "epss_percentile": 0.89392}, "CVE-2024-5510": {"epss_score": 0.00545, "epss_percentile": 0.67167}, "CVE-2024-5511": {"epss_score": 0.00545, "epss_percentile": 0.67167}, "CVE-2024-5512": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-5513": {"epss_score": 0.00393, "epss_percentile": 0.59707}, "CVE-2024-5514": {"epss_score": 0.00233, "epss_percentile": 0.45986}, "CVE-2024-5515": {"epss_score": 0.00058, "epss_percentile": 0.18543}, "CVE-2024-5516": {"epss_score": 0.00108, "epss_percentile": 0.29765}, "CVE-2024-5517": {"epss_score": 0.00079, "epss_percentile": 0.23918}, "CVE-2024-5518": {"epss_score": 0.00194, "epss_percentile": 0.41575}, "CVE-2024-5519": {"epss_score": 0.00079, "epss_percentile": 0.23918}, "CVE-2024-5520": {"epss_score": 0.00261, "epss_percentile": 0.49248}, "CVE-2024-5521": {"epss_score": 0.0024, "epss_percentile": 0.4694}, "CVE-2024-5522": {"epss_score": 0.79212, "epss_percentile": 0.99024}, "CVE-2024-5523": {"epss_score": 0.00224, "epss_percentile": 0.45019}, "CVE-2024-5524": {"epss_score": 0.0014, "epss_percentile": 0.34759}, "CVE-2024-5525": {"epss_score": 0.00091, "epss_percentile": 0.26211}, "CVE-2024-5526": {"epss_score": 0.00291, "epss_percentile": 0.52178}, "CVE-2024-5527": {"epss_score": 0.00684, "epss_percentile": 0.71119}, "CVE-2024-5528": {"epss_score": 0.00076, "epss_percentile": 0.23174}, "CVE-2024-5529": {"epss_score": 0.00119, "epss_percentile": 0.31543}, "CVE-2024-5530": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5531": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-5532": {"epss_score": 0.00175, "epss_percentile": 0.39365}, "CVE-2024-5533": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5535": {"epss_score": 0.04373, "epss_percentile": 0.88613}, "CVE-2024-5536": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5539": {"epss_score": 0.00059, "epss_percentile": 0.1864}, "CVE-2024-5540": {"epss_score": 0.00067, "epss_percentile": 0.2117}, "CVE-2024-5541": {"epss_score": 0.00318, "epss_percentile": 0.54397}, "CVE-2024-5542": {"epss_score": 0.01989, "epss_percentile": 0.83172}, "CVE-2024-5543": {"epss_score": 0.0037, "epss_percentile": 0.58313}, "CVE-2024-5544": {"epss_score": 0.01302, "epss_percentile": 0.79296}, "CVE-2024-5545": {"epss_score": 0.00218, "epss_percentile": 0.44395}, "CVE-2024-5546": {"epss_score": 0.00556, "epss_percentile": 0.67507}, "CVE-2024-5547": {"epss_score": 0.01261, "epss_percentile": 0.78975}, "CVE-2024-5548": {"epss_score": 0.00887, "epss_percentile": 0.74967}, "CVE-2024-5549": {"epss_score": 0.00206, "epss_percentile": 0.43048}, "CVE-2024-5550": {"epss_score": 0.01231, "epss_percentile": 0.78735}, "CVE-2024-5551": {"epss_score": 0.00432, "epss_percentile": 0.62131}, "CVE-2024-5552": {"epss_score": 0.00318, "epss_percentile": 0.54443}, "CVE-2024-5553": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5554": {"epss_score": 0.00379, "epss_percentile": 0.58838}, "CVE-2024-5555": {"epss_score": 0.00446, "epss_percentile": 0.62926}, "CVE-2024-5556": {"epss_score": 0.00504, "epss_percentile": 0.65544}, "CVE-2024-5557": {"epss_score": 0.00112, "epss_percentile": 0.30479}, "CVE-2024-5558": {"epss_score": 0.00068, "epss_percentile": 0.21364}, "CVE-2024-5559": {"epss_score": 0.00097, "epss_percentile": 0.27484}, "CVE-2024-5560": {"epss_score": 0.00158, "epss_percentile": 0.37212}, "CVE-2024-5561": {"epss_score": 0.00268, "epss_percentile": 0.5006}, "CVE-2024-5564": {"epss_score": 0.01056, "epss_percentile": 0.77126}, "CVE-2024-5565": {"epss_score": 0.05104, "epss_percentile": 0.89503}, "CVE-2024-5566": {"epss_score": 0.00269, "epss_percentile": 0.50127}, "CVE-2024-5567": {"epss_score": 0.00362, "epss_percentile": 0.57763}, "CVE-2024-5569": {"epss_score": 0.00016, "epss_percentile": 0.02931}, "CVE-2024-5570": {"epss_score": 0.00263, "epss_percentile": 0.4941}, "CVE-2024-5571": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5573": {"epss_score": 0.00118, "epss_percentile": 0.31452}, "CVE-2024-5574": {"epss_score": 0.00255, "epss_percentile": 0.48718}, "CVE-2024-5575": {"epss_score": 0.00347, "epss_percentile": 0.56747}, "CVE-2024-5576": {"epss_score": 0.00185, "epss_percentile": 0.40465}, "CVE-2024-5577": {"epss_score": 0.01787, "epss_percentile": 0.82262}, "CVE-2024-5578": {"epss_score": 0.00158, "epss_percentile": 0.37255}, "CVE-2024-5579": {"epss_score": 0.08416, "epss_percentile": 0.92039}, "CVE-2024-5580": {"epss_score": 0.0432, "epss_percentile": 0.88543}, "CVE-2024-5581": {"epss_score": 0.09347, "epss_percentile": 0.92511}, "CVE-2024-5582": {"epss_score": 0.00428, "epss_percentile": 0.6193}, "CVE-2024-5583": {"epss_score": 0.0024, "epss_percentile": 0.47233}, "CVE-2024-5584": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-5585": {"epss_score": 0.00903, "epss_percentile": 0.75199}, "CVE-2024-5586": {"epss_score": 0.00504, "epss_percentile": 0.65544}, "CVE-2024-5587": {"epss_score": 0.00133, "epss_percentile": 0.33663}, "CVE-2024-5588": {"epss_score": 0.00078, "epss_percentile": 0.23782}, "CVE-2024-5589": {"epss_score": 0.00096, "epss_percentile": 0.27245}, "CVE-2024-5590": {"epss_score": 0.00042, "epss_percentile": 0.12739}, "CVE-2024-5591": {"epss_score": 0.00063, "epss_percentile": 0.20062}, "CVE-2024-5594": {"epss_score": 0.00282, "epss_percentile": 0.51204}, "CVE-2024-5595": {"epss_score": 0.00297, "epss_percentile": 0.52691}, "CVE-2024-5596": {"epss_score": 0.00109, "epss_percentile": 0.29941}, "CVE-2024-5597": {"epss_score": 0.00214, "epss_percentile": 0.43977}, "CVE-2024-5598": {"epss_score": 0.01487, "epss_percentile": 0.8061}, "CVE-2024-5599": {"epss_score": 0.02239, "epss_percentile": 0.84108}, "CVE-2024-5600": {"epss_score": 0.00241, "epss_percentile": 0.47331}, "CVE-2024-5601": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5602": {"epss_score": 0.00259, "epss_percentile": 0.49049}, "CVE-2024-5604": {"epss_score": 0.00194, "epss_percentile": 0.41599}, "CVE-2024-5605": {"epss_score": 0.00702, "epss_percentile": 0.71515}, "CVE-2024-5606": {"epss_score": 0.00108, "epss_percentile": 0.2983}, "CVE-2024-5607": {"epss_score": 0.00264, "epss_percentile": 0.4969}, "CVE-2024-5608": {"epss_score": 0.00135, "epss_percentile": 0.33995}, "CVE-2024-5611": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5612": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-5613": {"epss_score": 0.01684, "epss_percentile": 0.81742}, "CVE-2024-5614": {"epss_score": 0.00461, "epss_percentile": 0.63544}, "CVE-2024-5615": {"epss_score": 0.00461, "epss_percentile": 0.63544}, "CVE-2024-5616": {"epss_score": 0.00077, "epss_percentile": 0.23445}, "CVE-2024-5618": {"epss_score": 0.00128, "epss_percentile": 0.33024}, "CVE-2024-5619": {"epss_score": 0.00029, "epss_percentile": 0.07604}, "CVE-2024-5620": {"epss_score": 0.00061, "epss_percentile": 0.19246}, "CVE-2024-5622": {"epss_score": 0.00052, "epss_percentile": 0.16549}, "CVE-2024-5623": {"epss_score": 0.0006, "epss_percentile": 0.19092}, "CVE-2024-5624": {"epss_score": 0.00663, "epss_percentile": 0.70621}, "CVE-2024-5625": {"epss_score": 0.00096, "epss_percentile": 0.27328}, "CVE-2024-5626": {"epss_score": 0.00127, "epss_percentile": 0.32801}, "CVE-2024-5627": {"epss_score": 0.00311, "epss_percentile": 0.5382}, "CVE-2024-5628": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5629": {"epss_score": 0.00087, "epss_percentile": 0.25507}, "CVE-2024-5630": {"epss_score": 0.0113, "epss_percentile": 0.77848}, "CVE-2024-5631": {"epss_score": 0.00113, "epss_percentile": 0.30599}, "CVE-2024-5632": {"epss_score": 0.00117, "epss_percentile": 0.31215}, "CVE-2024-5633": {"epss_score": 0.03029, "epss_percentile": 0.86244}, "CVE-2024-5634": {"epss_score": 0.00092, "epss_percentile": 0.26516}, "CVE-2024-5635": {"epss_score": 0.00099, "epss_percentile": 0.28427}, "CVE-2024-5636": {"epss_score": 0.00099, "epss_percentile": 0.28427}, "CVE-2024-5637": {"epss_score": 0.05807, "epss_percentile": 0.90224}, "CVE-2024-5638": {"epss_score": 0.02374, "epss_percentile": 0.84536}, "CVE-2024-5639": {"epss_score": 0.00209, "epss_percentile": 0.43323}, "CVE-2024-5640": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5641": {"epss_score": 0.00186, "epss_percentile": 0.40649}, "CVE-2024-5642": {"epss_score": 0.00192, "epss_percentile": 0.41362}, "CVE-2024-5644": {"epss_score": 0.00187, "epss_percentile": 0.40782}, "CVE-2024-5645": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5646": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5647": {"epss_score": 0.00061, "epss_percentile": 0.193}, "CVE-2024-5648": {"epss_score": 0.00227, "epss_percentile": 0.45439}, "CVE-2024-5649": {"epss_score": 0.00615, "epss_percentile": 0.69302}, "CVE-2024-5650": {"epss_score": 0.00174, "epss_percentile": 0.39187}, "CVE-2024-5651": {"epss_score": 0.17604, "epss_percentile": 0.94873}, "CVE-2024-5652": {"epss_score": 0.00046, "epss_percentile": 0.1429}, "CVE-2024-5653": {"epss_score": 0.00095, "epss_percentile": 0.27237}, "CVE-2024-5654": {"epss_score": 0.00325, "epss_percentile": 0.55011}, "CVE-2024-5655": {"epss_score": 0.00733, "epss_percentile": 0.72208}, "CVE-2024-5657": {"epss_score": 0.00157, "epss_percentile": 0.37088}, "CVE-2024-5658": {"epss_score": 0.00117, "epss_percentile": 0.3122}, "CVE-2024-5659": {"epss_score": 0.00398, "epss_percentile": 0.60052}, "CVE-2024-5660": {"epss_score": 0.00289, "epss_percentile": 0.52048}, "CVE-2024-5661": {"epss_score": 0.00071, "epss_percentile": 0.2221}, "CVE-2024-5662": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5663": {"epss_score": 0.00225, "epss_percentile": 0.45095}, "CVE-2024-5664": {"epss_score": 0.00346, "epss_percentile": 0.56675}, "CVE-2024-5665": {"epss_score": 0.00244, "epss_percentile": 0.47565}, "CVE-2024-5666": {"epss_score": 0.00219, "epss_percentile": 0.44488}, "CVE-2024-5667": {"epss_score": 0.00119, "epss_percentile": 0.31548}, "CVE-2024-5668": {"epss_score": 0.00286, "epss_percentile": 0.51692}, "CVE-2024-5669": {"epss_score": 0.00186, "epss_percentile": 0.40651}, "CVE-2024-5670": {"epss_score": 0.02509, "epss_percentile": 0.84944}, "CVE-2024-5671": {"epss_score": 0.05674, "epss_percentile": 0.90106}, "CVE-2024-5672": {"epss_score": 0.00712, "epss_percentile": 0.71749}, "CVE-2024-5673": {"epss_score": 0.00238, "epss_percentile": 0.4674}, "CVE-2024-5674": {"epss_score": 0.01616, "epss_percentile": 0.8136}, "CVE-2024-5675": {"epss_score": 0.00205, "epss_percentile": 0.42718}, "CVE-2024-5676": {"epss_score": 0.00193, "epss_percentile": 0.4144}, "CVE-2024-5677": {"epss_score": 0.00132, "epss_percentile": 0.33584}, "CVE-2024-5678": {"epss_score": 0.01266, "epss_percentile": 0.79012}, "CVE-2024-5679": {"epss_score": 0.00062, "epss_percentile": 0.19617}, "CVE-2024-5680": {"epss_score": 0.00044, "epss_percentile": 0.13488}, "CVE-2024-5681": {"epss_score": 0.00208, "epss_percentile": 0.43295}, "CVE-2024-5682": {"epss_score": 0.00114, "epss_percentile": 0.30798}, "CVE-2024-5683": {"epss_score": 0.00191, "epss_percentile": 0.41272}, "CVE-2024-5684": {"epss_score": 0.00023, "epss_percentile": 0.05508}, "CVE-2024-5685": {"epss_score": 0.00159, "epss_percentile": 0.3741}, "CVE-2024-5686": {"epss_score": 0.00258, "epss_percentile": 0.48992}, "CVE-2024-5687": {"epss_score": 0.00607, "epss_percentile": 0.6904}, "CVE-2024-5688": {"epss_score": 0.01253, "epss_percentile": 0.78916}, "CVE-2024-5689": {"epss_score": 0.00776, "epss_percentile": 0.73099}, "CVE-2024-5690": {"epss_score": 0.03717, "epss_percentile": 0.87614}, "CVE-2024-5691": {"epss_score": 0.00172, "epss_percentile": 0.38998}, "CVE-2024-5692": {"epss_score": 0.00413, "epss_percentile": 0.61009}, "CVE-2024-5693": {"epss_score": 0.0147, "epss_percentile": 0.80496}, "CVE-2024-5694": {"epss_score": 0.00544, "epss_percentile": 0.67127}, "CVE-2024-5695": {"epss_score": 0.00869, "epss_percentile": 0.74691}, "CVE-2024-5696": {"epss_score": 0.02069, "epss_percentile": 0.8347}, "CVE-2024-5697": {"epss_score": 0.00572, "epss_percentile": 0.68018}, "CVE-2024-5698": {"epss_score": 0.00403, "epss_percentile": 0.60383}, "CVE-2024-5699": {"epss_score": 0.00594, "epss_percentile": 0.6867}, "CVE-2024-5700": {"epss_score": 0.0017, "epss_percentile": 0.38662}, "CVE-2024-5701": {"epss_score": 0.00869, "epss_percentile": 0.74691}, "CVE-2024-5702": {"epss_score": 0.00735, "epss_percentile": 0.72286}, "CVE-2024-5703": {"epss_score": 0.00227, "epss_percentile": 0.45402}, "CVE-2024-5704": {"epss_score": 0.00343, "epss_percentile": 0.56423}, "CVE-2024-5705": {"epss_score": 0.00227, "epss_percentile": 0.45422}, "CVE-2024-5706": {"epss_score": 0.00941, "epss_percentile": 0.75744}, "CVE-2024-5708": {"epss_score": 0.00234, "epss_percentile": 0.46117}, "CVE-2024-5709": {"epss_score": 0.00687, "epss_percentile": 0.71186}, "CVE-2024-5710": {"epss_score": 0.00082, "epss_percentile": 0.24448}, "CVE-2024-5711": {"epss_score": 0.00255, "epss_percentile": 0.48648}, "CVE-2024-5712": {"epss_score": 0.00166, "epss_percentile": 0.38237}, "CVE-2024-5713": {"epss_score": 0.00219, "epss_percentile": 0.44504}, "CVE-2024-5714": {"epss_score": 0.0009, "epss_percentile": 0.26165}, "CVE-2024-5715": {"epss_score": 0.00107, "epss_percentile": 0.29589}, "CVE-2024-5716": {"epss_score": 0.00248, "epss_percentile": 0.47972}, "CVE-2024-5717": {"epss_score": 0.00545, "epss_percentile": 0.67161}, "CVE-2024-5718": {"epss_score": 0.0337, "epss_percentile": 0.87009}, "CVE-2024-5719": {"epss_score": 0.00545, "epss_percentile": 0.67161}, "CVE-2024-5720": {"epss_score": 0.00545, "epss_percentile": 0.67161}, "CVE-2024-5721": {"epss_score": 0.57306, "epss_percentile": 0.98056}, "CVE-2024-5722": {"epss_score": 0.00597, "epss_percentile": 0.6874}, "CVE-2024-5723": {"epss_score": 0.80634, "epss_percentile": 0.99097}, "CVE-2024-5724": {"epss_score": 0.01291, "epss_percentile": 0.7923}, "CVE-2024-5725": {"epss_score": 0.51296, "epss_percentile": 0.97774}, "CVE-2024-5726": {"epss_score": 0.0157, "epss_percentile": 0.81092}, "CVE-2024-5727": {"epss_score": 0.00283, "epss_percentile": 0.51382}, "CVE-2024-5728": {"epss_score": 0.00312, "epss_percentile": 0.54004}, "CVE-2024-5729": {"epss_score": 0.00319, "epss_percentile": 0.54567}, "CVE-2024-5730": {"epss_score": 0.00319, "epss_percentile": 0.54567}, "CVE-2024-5731": {"epss_score": 0.00255, "epss_percentile": 0.48723}, "CVE-2024-5732": {"epss_score": 0.00261, "epss_percentile": 0.49248}, "CVE-2024-5733": {"epss_score": 0.00197, "epss_percentile": 0.41956}, "CVE-2024-5734": {"epss_score": 0.0015, "epss_percentile": 0.36066}, "CVE-2024-5735": {"epss_score": 0.30207, "epss_percentile": 0.96519}, "CVE-2024-5736": {"epss_score": 0.28818, "epss_percentile": 0.9639}, "CVE-2024-5737": {"epss_score": 0.16107, "epss_percentile": 0.94573}, "CVE-2024-5739": {"epss_score": 0.00246, "epss_percentile": 0.47792}, "CVE-2024-5741": {"epss_score": 0.00435, "epss_percentile": 0.62376}, "CVE-2024-5742": {"epss_score": 0.00087, "epss_percentile": 0.25569}, "CVE-2024-5743": {"epss_score": 0.00247, "epss_percentile": 0.47815}, "CVE-2024-5744": {"epss_score": 0.00258, "epss_percentile": 0.49004}, "CVE-2024-5745": {"epss_score": 0.00183, "epss_percentile": 0.40363}, "CVE-2024-5746": {"epss_score": 0.00116, "epss_percentile": 0.31092}, "CVE-2024-5749": {"epss_score": 0.00103, "epss_percentile": 0.28902}, "CVE-2024-5751": {"epss_score": 0.05359, "epss_percentile": 0.89782}, "CVE-2024-5752": {"epss_score": 0.01939, "epss_percentile": 0.82975}, "CVE-2024-5753": {"epss_score": 0.00285, "epss_percentile": 0.51534}, "CVE-2024-5754": {"epss_score": 0.00053, "epss_percentile": 0.16686}, "CVE-2024-5755": {"epss_score": 0.00045, "epss_percentile": 0.1394}, "CVE-2024-5756": {"epss_score": 0.00891, "epss_percentile": 0.75049}, "CVE-2024-5757": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5759": {"epss_score": 0.00639, "epss_percentile": 0.69944}, "CVE-2024-5760": {"epss_score": 0.00043, "epss_percentile": 0.12963}, "CVE-2024-5762": {"epss_score": 0.06923, "epss_percentile": 0.91119}, "CVE-2024-5763": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-5764": {"epss_score": 0.02273, "epss_percentile": 0.84222}, "CVE-2024-5765": {"epss_score": 0.78175, "epss_percentile": 0.98972}, "CVE-2024-5766": {"epss_score": 0.00102, "epss_percentile": 0.28795}, "CVE-2024-5767": {"epss_score": 0.0044, "epss_percentile": 0.62642}, "CVE-2024-5768": {"epss_score": 0.00157, "epss_percentile": 0.37036}, "CVE-2024-5769": {"epss_score": 0.00119, "epss_percentile": 0.3163}, "CVE-2024-5770": {"epss_score": 0.00072, "epss_percentile": 0.22454}, "CVE-2024-5771": {"epss_score": 0.0007, "epss_percentile": 0.21741}, "CVE-2024-5772": {"epss_score": 0.00078, "epss_percentile": 0.23782}, "CVE-2024-5773": {"epss_score": 0.00078, "epss_percentile": 0.23782}, "CVE-2024-5774": {"epss_score": 0.00123, "epss_percentile": 0.323}, "CVE-2024-5775": {"epss_score": 0.00124, "epss_percentile": 0.32343}, "CVE-2024-5784": {"epss_score": 0.00507, "epss_percentile": 0.6565}, "CVE-2024-5785": {"epss_score": 0.00287, "epss_percentile": 0.51787}, "CVE-2024-5786": {"epss_score": 0.00103, "epss_percentile": 0.2899}, "CVE-2024-5787": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5788": {"epss_score": 0.00327, "epss_percentile": 0.55105}, "CVE-2024-5789": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2024-5790": {"epss_score": 0.00225, "epss_percentile": 0.45095}, "CVE-2024-5791": {"epss_score": 0.01302, "epss_percentile": 0.79296}, "CVE-2024-5792": {"epss_score": 0.00521, "epss_percentile": 0.66218}, "CVE-2024-5793": {"epss_score": 0.00717, "epss_percentile": 0.71879}, "CVE-2024-5795": {"epss_score": 0.00299, "epss_percentile": 0.5289}, "CVE-2024-5796": {"epss_score": 0.00338, "epss_percentile": 0.56151}, "CVE-2024-5798": {"epss_score": 0.00158, "epss_percentile": 0.37213}, "CVE-2024-5799": {"epss_score": 0.0012, "epss_percentile": 0.31796}, "CVE-2024-5800": {"epss_score": 0.00097, "epss_percentile": 0.27481}, "CVE-2024-5801": {"epss_score": 0.0005, "epss_percentile": 0.15674}, "CVE-2024-5802": {"epss_score": 0.00306, "epss_percentile": 0.53423}, "CVE-2024-5803": {"epss_score": 0.0004, "epss_percentile": 0.12022}, "CVE-2024-5804": {"epss_score": 0.00139, "epss_percentile": 0.34628}, "CVE-2024-5805": {"epss_score": 0.00646, "epss_percentile": 0.70148}, "CVE-2024-5806": {"epss_score": 0.89937, "epss_percentile": 0.99551}, "CVE-2024-5807": {"epss_score": 0.00674, "epss_percentile": 0.70882}, "CVE-2024-5808": {"epss_score": 0.00206, "epss_percentile": 0.43055}, "CVE-2024-5809": {"epss_score": 0.00362, "epss_percentile": 0.57789}, "CVE-2024-5810": {"epss_score": 0.00432, "epss_percentile": 0.62115}, "CVE-2024-5811": {"epss_score": 0.00202, "epss_percentile": 0.42398}, "CVE-2024-5812": {"epss_score": 0.00121, "epss_percentile": 0.31814}, "CVE-2024-5813": {"epss_score": 0.00229, "epss_percentile": 0.45648}, "CVE-2024-5814": {"epss_score": 0.00113, "epss_percentile": 0.30669}, "CVE-2024-5815": {"epss_score": 0.00164, "epss_percentile": 0.37908}, "CVE-2024-5816": {"epss_score": 0.01146, "epss_percentile": 0.77997}, "CVE-2024-5817": {"epss_score": 0.00401, "epss_percentile": 0.60229}, "CVE-2024-5818": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5819": {"epss_score": 0.00218, "epss_percentile": 0.44439}, "CVE-2024-5820": {"epss_score": 0.00104, "epss_percentile": 0.29241}, "CVE-2024-5821": {"epss_score": 0.00088, "epss_percentile": 0.25641}, "CVE-2024-5822": {"epss_score": 0.0004, "epss_percentile": 0.11892}, "CVE-2024-5823": {"epss_score": 0.00103, "epss_percentile": 0.29053}, "CVE-2024-5824": {"epss_score": 0.01395, "epss_percentile": 0.79975}, "CVE-2024-5826": {"epss_score": 0.04078, "epss_percentile": 0.88214}, "CVE-2024-5827": {"epss_score": 0.39855, "epss_percentile": 0.97184}, "CVE-2024-5828": {"epss_score": 0.00768, "epss_percentile": 0.72979}, "CVE-2024-5829": {"epss_score": 0.00196, "epss_percentile": 0.41756}, "CVE-2024-5830": {"epss_score": 0.06676, "epss_percentile": 0.90936}, "CVE-2024-5831": {"epss_score": 0.00318, "epss_percentile": 0.54398}, "CVE-2024-5832": {"epss_score": 0.00256, "epss_percentile": 0.48784}, "CVE-2024-5833": {"epss_score": 0.00196, "epss_percentile": 0.4178}, "CVE-2024-5834": {"epss_score": 0.0088, "epss_percentile": 0.74851}, "CVE-2024-5835": {"epss_score": 0.00085, "epss_percentile": 0.25223}, "CVE-2024-5836": {"epss_score": 0.00322, "epss_percentile": 0.54794}, "CVE-2024-5837": {"epss_score": 0.00224, "epss_percentile": 0.45027}, "CVE-2024-5838": {"epss_score": 0.00196, "epss_percentile": 0.4178}, "CVE-2024-5839": {"epss_score": 0.001, "epss_percentile": 0.28464}, "CVE-2024-5840": {"epss_score": 0.00057, "epss_percentile": 0.18048}, "CVE-2024-5841": {"epss_score": 0.00256, "epss_percentile": 0.48784}, "CVE-2024-5842": {"epss_score": 0.00301, "epss_percentile": 0.5301}, "CVE-2024-5843": {"epss_score": 0.00063, "epss_percentile": 0.1994}, "CVE-2024-5844": {"epss_score": 0.00316, "epss_percentile": 0.54223}, "CVE-2024-5845": {"epss_score": 0.00256, "epss_percentile": 0.48784}, "CVE-2024-5846": {"epss_score": 0.00278, "epss_percentile": 0.50877}, "CVE-2024-5847": {"epss_score": 0.00278, "epss_percentile": 0.50877}, "CVE-2024-5848": {"epss_score": 0.00078, "epss_percentile": 0.23607}, "CVE-2024-5849": {"epss_score": 0.00582, "epss_percentile": 0.68312}, "CVE-2024-5851": {"epss_score": 0.00196, "epss_percentile": 0.41756}, "CVE-2024-5852": {"epss_score": 0.00536, "epss_percentile": 0.66853}, "CVE-2024-5853": {"epss_score": 0.10477, "epss_percentile": 0.93}, "CVE-2024-5855": {"epss_score": 0.00182, "epss_percentile": 0.40197}, "CVE-2024-5856": {"epss_score": 0.00182, "epss_percentile": 0.40197}, "CVE-2024-5857": {"epss_score": 0.00161, "epss_percentile": 0.37533}, "CVE-2024-5858": {"epss_score": 0.00135, "epss_percentile": 0.34033}, "CVE-2024-5859": {"epss_score": 0.01989, "epss_percentile": 0.83172}, "CVE-2024-5860": {"epss_score": 0.00122, "epss_percentile": 0.32104}, "CVE-2024-5861": {"epss_score": 0.00324, "epss_percentile": 0.54958}, "CVE-2024-5862": {"epss_score": 0.00153, "epss_percentile": 0.36575}, "CVE-2024-5863": {"epss_score": 0.00078, "epss_percentile": 0.23579}, "CVE-2024-5864": {"epss_score": 0.00108, "epss_percentile": 0.2977}, "CVE-2024-5865": {"epss_score": 0.00181, "epss_percentile": 0.40122}, "CVE-2024-5866": {"epss_score": 0.00165, "epss_percentile": 0.38063}, "CVE-2024-5867": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2024-5868": {"epss_score": 0.00128, "epss_percentile": 0.33018}, "CVE-2024-5869": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2024-5870": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2024-5871": {"epss_score": 0.05196, "epss_percentile": 0.896}, "CVE-2024-5872": {"epss_score": 0.00135, "epss_percentile": 0.34018}, "CVE-2024-5874": {"epss_score": 0.00328, "epss_percentile": 0.55268}, "CVE-2024-5875": {"epss_score": 0.00328, "epss_percentile": 0.55268}, "CVE-2024-5876": {"epss_score": 0.00481, "epss_percentile": 0.64504}, "CVE-2024-5877": {"epss_score": 0.00328, "epss_percentile": 0.55268}, "CVE-2024-5878": {"epss_score": 0.0004, "epss_percentile": 0.12029}, "CVE-2024-5879": {"epss_score": 0.0026, "epss_percentile": 0.49235}, "CVE-2024-5880": {"epss_score": 0.00172, "epss_percentile": 0.38936}, "CVE-2024-5881": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-5882": {"epss_score": 0.0234, "epss_percentile": 0.84429}, "CVE-2024-5883": {"epss_score": 0.00168, "epss_percentile": 0.3848}, "CVE-2024-5884": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2024-5885": {"epss_score": 0.00221, "epss_percentile": 0.4469}, "CVE-2024-5888": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2024-5889": {"epss_score": 0.01302, "epss_percentile": 0.79296}, "CVE-2024-5890": {"epss_score": 0.00325, "epss_percentile": 0.54991}, "CVE-2024-5891": {"epss_score": 0.00117, "epss_percentile": 0.31238}, "CVE-2024-5892": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-5893": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-5894": {"epss_score": 0.00106, "epss_percentile": 0.29442}, "CVE-2024-5895": {"epss_score": 0.00077, "epss_percentile": 0.23407}, "CVE-2024-5896": {"epss_score": 0.00068, "epss_percentile": 0.21294}, "CVE-2024-5897": {"epss_score": 0.00194, "epss_percentile": 0.41557}, "CVE-2024-5898": {"epss_score": 0.00068, "epss_percentile": 0.21305}, "CVE-2024-5899": {"epss_score": 0.00052, "epss_percentile": 0.16534}, "CVE-2024-5901": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-5902": {"epss_score": 0.03505, "epss_percentile": 0.87256}, "CVE-2024-5905": {"epss_score": 0.00061, "epss_percentile": 0.19448}, "CVE-2024-5906": {"epss_score": 0.00378, "epss_percentile": 0.5879}, "CVE-2024-5907": {"epss_score": 0.00101, "epss_percentile": 0.28654}, "CVE-2024-5908": {"epss_score": 0.00323, "epss_percentile": 0.54913}, "CVE-2024-5909": {"epss_score": 0.0086, "epss_percentile": 0.74542}, "CVE-2024-5910": {"epss_score": 0.91029, "epss_percentile": 0.99614}, "CVE-2024-5911": {"epss_score": 0.00211, "epss_percentile": 0.43642}, "CVE-2024-5912": {"epss_score": 0.00013, "epss_percentile": 0.01583}, "CVE-2024-5913": {"epss_score": 0.00117, "epss_percentile": 0.3137}, "CVE-2024-5914": {"epss_score": 0.02563, "epss_percentile": 0.8511}, "CVE-2024-5915": {"epss_score": 0.00093, "epss_percentile": 0.26725}, "CVE-2024-5916": {"epss_score": 0.00083, "epss_percentile": 0.24821}, "CVE-2024-5917": {"epss_score": 0.00196, "epss_percentile": 0.41728}, "CVE-2024-5918": {"epss_score": 0.00154, "epss_percentile": 0.36692}, "CVE-2024-5919": {"epss_score": 0.00149, "epss_percentile": 0.36009}, "CVE-2024-5920": {"epss_score": 0.00341, "epss_percentile": 0.56294}, "CVE-2024-5921": {"epss_score": 0.00277, "epss_percentile": 0.50797}, "CVE-2024-5922": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-5924": {"epss_score": 0.00424, "epss_percentile": 0.61664}, "CVE-2024-5925": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-5926": {"epss_score": 0.00283, "epss_percentile": 0.51405}, "CVE-2024-5928": {"epss_score": 0.00178, "epss_percentile": 0.39708}, "CVE-2024-5929": {"epss_score": 0.0008, "epss_percentile": 0.24092}, "CVE-2024-5930": {"epss_score": 0.00069, "epss_percentile": 0.21609}, "CVE-2024-5931": {"epss_score": 0.00117, "epss_percentile": 0.3126}, "CVE-2024-5932": {"epss_score": 0.94126, "epss_percentile": 0.99907}, "CVE-2024-5933": {"epss_score": 0.00131, "epss_percentile": 0.33392}, "CVE-2024-5935": {"epss_score": 0.00056, "epss_percentile": 0.1776}, "CVE-2024-5936": {"epss_score": 0.00647, "epss_percentile": 0.70207}, "CVE-2024-5937": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-5938": {"epss_score": 0.00222, "epss_percentile": 0.44781}, "CVE-2024-5939": {"epss_score": 0.00326, "epss_percentile": 0.55048}, "CVE-2024-5940": {"epss_score": 0.00245, "epss_percentile": 0.47639}, "CVE-2024-5941": {"epss_score": 0.00129, "epss_percentile": 0.33218}, "CVE-2024-5942": {"epss_score": 0.00179, "epss_percentile": 0.39858}, "CVE-2024-5943": {"epss_score": 0.00389, "epss_percentile": 0.59405}, "CVE-2024-5945": {"epss_score": 0.00225, "epss_percentile": 0.45126}, "CVE-2024-5946": {"epss_score": 0.00391, "epss_percentile": 0.59629}, "CVE-2024-5947": {"epss_score": 0.74043, "epss_percentile": 0.98784}, "CVE-2024-5948": {"epss_score": 0.03039, "epss_percentile": 0.86269}, "CVE-2024-5949": {"epss_score": 0.00107, "epss_percentile": 0.2965}, "CVE-2024-5950": {"epss_score": 0.03039, "epss_percentile": 0.86269}, "CVE-2024-5951": {"epss_score": 0.00021, "epss_percentile": 0.04909}, "CVE-2024-5952": {"epss_score": 0.00021, "epss_percentile": 0.04694}, "CVE-2024-5953": {"epss_score": 0.00087, "epss_percentile": 0.25614}, "CVE-2024-5955": {"epss_score": 0.00051, "epss_percentile": 0.16116}, "CVE-2024-5956": {"epss_score": 0.00079, "epss_percentile": 0.23835}, "CVE-2024-5957": {"epss_score": 0.00058, "epss_percentile": 0.18583}, "CVE-2024-5958": {"epss_score": 0.00173, "epss_percentile": 0.39041}, "CVE-2024-5959": {"epss_score": 0.00242, "epss_percentile": 0.47342}, "CVE-2024-5960": {"epss_score": 0.00181, "epss_percentile": 0.40078}, "CVE-2024-5961": {"epss_score": 0.0249, "epss_percentile": 0.84895}, "CVE-2024-5962": {"epss_score": 0.00026, "epss_percentile": 0.06444}, "CVE-2024-5963": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2024-5964": {"epss_score": 0.00196, "epss_percentile": 0.4174}, "CVE-2024-5965": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5966": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5967": {"epss_score": 0.00132, "epss_percentile": 0.33512}, "CVE-2024-5968": {"epss_score": 0.00131, "epss_percentile": 0.33504}, "CVE-2024-5969": {"epss_score": 0.00483, "epss_percentile": 0.6459}, "CVE-2024-5970": {"epss_score": 0.00201, "epss_percentile": 0.42318}, "CVE-2024-5971": {"epss_score": 0.03699, "epss_percentile": 0.87588}, "CVE-2024-5973": {"epss_score": 0.00856, "epss_percentile": 0.74477}, "CVE-2024-5974": {"epss_score": 0.06336, "epss_percentile": 0.90679}, "CVE-2024-5975": {"epss_score": 0.39009, "epss_percentile": 0.97134}, "CVE-2024-5976": {"epss_score": 0.00074, "epss_percentile": 0.22875}, "CVE-2024-5977": {"epss_score": 0.00106, "epss_percentile": 0.29495}, "CVE-2024-5979": {"epss_score": 0.00117, "epss_percentile": 0.3135}, "CVE-2024-5980": {"epss_score": 0.10734, "epss_percentile": 0.93087}, "CVE-2024-5981": {"epss_score": 0.00194, "epss_percentile": 0.41535}, "CVE-2024-5982": {"epss_score": 0.08687, "epss_percentile": 0.92203}, "CVE-2024-5983": {"epss_score": 0.00187, "epss_percentile": 0.4071}, "CVE-2024-5984": {"epss_score": 0.001, "epss_percentile": 0.28538}, "CVE-2024-5985": {"epss_score": 0.0006, "epss_percentile": 0.19095}, "CVE-2024-5987": {"epss_score": 0.00086, "epss_percentile": 0.25434}, "CVE-2024-5988": {"epss_score": 0.07123, "epss_percentile": 0.91264}, "CVE-2024-5989": {"epss_score": 0.04686, "epss_percentile": 0.89007}, "CVE-2024-5990": {"epss_score": 0.00491, "epss_percentile": 0.64952}, "CVE-2024-5991": {"epss_score": 0.00132, "epss_percentile": 0.33552}, "CVE-2024-5992": {"epss_score": 0.00151, "epss_percentile": 0.36311}, "CVE-2024-5993": {"epss_score": 0.0008, "epss_percentile": 0.24119}, "CVE-2024-5994": {"epss_score": 0.00272, "epss_percentile": 0.5037}, "CVE-2024-5995": {"epss_score": 0.00234, "epss_percentile": 0.46125}, "CVE-2024-5997": {"epss_score": 0.00099, "epss_percentile": 0.28391}, "CVE-2024-5998": {"epss_score": 0.00066, "epss_percentile": 0.20936}, "CVE-2024-6000": {"epss_score": 0.03703, "epss_percentile": 0.87594}, "CVE-2024-6001": {"epss_score": 0.00179, "epss_percentile": 0.39749}, "CVE-2024-6003": {"epss_score": 0.00048, "epss_percentile": 0.15125}, "CVE-2024-6004": {"epss_score": 0.00071, "epss_percentile": 0.2219}, "CVE-2024-6005": {"epss_score": 0.00166, "epss_percentile": 0.38222}, "CVE-2024-6006": {"epss_score": 0.00166, "epss_percentile": 0.38222}, "CVE-2024-6007": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-6008": {"epss_score": 0.00047, "epss_percentile": 0.14859}, "CVE-2024-6009": {"epss_score": 0.00064, "epss_percentile": 0.20361}, "CVE-2024-6010": {"epss_score": 0.00353, "epss_percentile": 0.57144}, "CVE-2024-6011": {"epss_score": 0.00358, "epss_percentile": 0.57526}, "CVE-2024-6012": {"epss_score": 0.00099, "epss_percentile": 0.28417}, "CVE-2024-6013": {"epss_score": 0.00064, "epss_percentile": 0.20361}, "CVE-2024-6014": {"epss_score": 0.00064, "epss_percentile": 0.20361}, "CVE-2024-6015": {"epss_score": 0.00064, "epss_percentile": 0.20361}, "CVE-2024-6016": {"epss_score": 0.00064, "epss_percentile": 0.20361}, "CVE-2024-6017": {"epss_score": 0.00133, "epss_percentile": 0.33737}, "CVE-2024-6018": {"epss_score": 0.00173, "epss_percentile": 0.39075}, "CVE-2024-6019": {"epss_score": 0.00809, "epss_percentile": 0.73706}, "CVE-2024-6020": {"epss_score": 0.00311, "epss_percentile": 0.53826}, "CVE-2024-6021": {"epss_score": 0.00541, "epss_percentile": 0.67049}, "CVE-2024-6022": {"epss_score": 0.00288, "epss_percentile": 0.51885}, "CVE-2024-6023": {"epss_score": 0.00194, "epss_percentile": 0.41537}, "CVE-2024-6024": {"epss_score": 0.00265, "epss_percentile": 0.49754}, "CVE-2024-6025": {"epss_score": 0.00256, "epss_percentile": 0.48789}, "CVE-2024-6026": {"epss_score": 0.00506, "epss_percentile": 0.65635}, "CVE-2024-6027": {"epss_score": 0.00947, "epss_percentile": 0.7582}, "CVE-2024-6028": {"epss_score": 0.80299, "epss_percentile": 0.9908}, "CVE-2024-6029": {"epss_score": 0.0002, "epss_percentile": 0.04447}, "CVE-2024-6030": {"epss_score": 0.00016, "epss_percentile": 0.02779}, "CVE-2024-6031": {"epss_score": 0.00016, "epss_percentile": 0.02779}, "CVE-2024-6032": {"epss_score": 0.00038, "epss_percentile": 0.11155}, "CVE-2024-6033": {"epss_score": 0.00113, "epss_percentile": 0.30607}, "CVE-2024-6035": {"epss_score": 0.00225, "epss_percentile": 0.4512}, "CVE-2024-6036": {"epss_score": 0.00127, "epss_percentile": 0.32787}, "CVE-2024-6037": {"epss_score": 0.0361, "epss_percentile": 0.87424}, "CVE-2024-6038": {"epss_score": 0.00138, "epss_percentile": 0.345}, "CVE-2024-6039": {"epss_score": 0.00158, "epss_percentile": 0.37182}, "CVE-2024-6040": {"epss_score": 0.00055, "epss_percentile": 0.17536}, "CVE-2024-6041": {"epss_score": 0.00089, "epss_percentile": 0.25866}, "CVE-2024-6042": {"epss_score": 0.00097, "epss_percentile": 0.27594}, "CVE-2024-6043": {"epss_score": 0.26677, "epss_percentile": 0.96165}, "CVE-2024-6044": {"epss_score": 0.0085, "epss_percentile": 0.74388}, "CVE-2024-6045": {"epss_score": 0.07888, "epss_percentile": 0.91744}, "CVE-2024-6047": {"epss_score": 0.72966, "epss_percentile": 0.9873}, "CVE-2024-6048": {"epss_score": 0.01056, "epss_percentile": 0.77128}, "CVE-2024-6049": {"epss_score": 0.68338, "epss_percentile": 0.98542}, "CVE-2024-6050": {"epss_score": 0.02095, "epss_percentile": 0.83585}, "CVE-2024-6051": {"epss_score": 0.00032, "epss_percentile": 0.08776}, "CVE-2024-6052": {"epss_score": 0.00284, "epss_percentile": 0.51444}, "CVE-2024-6053": {"epss_score": 0.00391, "epss_percentile": 0.59573}, "CVE-2024-6054": {"epss_score": 0.06949, "epss_percentile": 0.91136}, "CVE-2024-6055": {"epss_score": 0.00197, "epss_percentile": 0.41837}, "CVE-2024-6056": {"epss_score": 0.00184, "epss_percentile": 0.40409}, "CVE-2024-6057": {"epss_score": 0.00238, "epss_percentile": 0.46813}, "CVE-2024-6058": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-6059": {"epss_score": 0.00102, "epss_percentile": 0.28795}, "CVE-2024-6060": {"epss_score": 0.00074, "epss_percentile": 0.22828}, "CVE-2024-6061": {"epss_score": 0.00039, "epss_percentile": 0.11639}, "CVE-2024-6062": {"epss_score": 0.00039, "epss_percentile": 0.11639}, "CVE-2024-6063": {"epss_score": 0.00037, "epss_percentile": 0.10841}, "CVE-2024-6064": {"epss_score": 0.00036, "epss_percentile": 0.1061}, "CVE-2024-6065": {"epss_score": 0.00097, "epss_percentile": 0.27594}, "CVE-2024-6066": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6067": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6068": {"epss_score": 0.00041, "epss_percentile": 0.12445}, "CVE-2024-6069": {"epss_score": 0.02397, "epss_percentile": 0.8462}, "CVE-2024-6070": {"epss_score": 0.00323, "epss_percentile": 0.54881}, "CVE-2024-6071": {"epss_score": 0.03069, "epss_percentile": 0.86343}, "CVE-2024-6072": {"epss_score": 0.00216, "epss_percentile": 0.44173}, "CVE-2024-6073": {"epss_score": 0.00174, "epss_percentile": 0.39261}, "CVE-2024-6074": {"epss_score": 0.00273, "epss_percentile": 0.50448}, "CVE-2024-6075": {"epss_score": 0.00419, "epss_percentile": 0.61377}, "CVE-2024-6076": {"epss_score": 0.00407, "epss_percentile": 0.60605}, "CVE-2024-6077": {"epss_score": 0.00196, "epss_percentile": 0.41728}, "CVE-2024-6078": {"epss_score": 0.00207, "epss_percentile": 0.43134}, "CVE-2024-6079": {"epss_score": 0.0126, "epss_percentile": 0.7897}, "CVE-2024-6080": {"epss_score": 0.00061, "epss_percentile": 0.1937}, "CVE-2024-6082": {"epss_score": 0.001, "epss_percentile": 0.28499}, "CVE-2024-6083": {"epss_score": 0.00142, "epss_percentile": 0.3505}, "CVE-2024-6084": {"epss_score": 0.00192, "epss_percentile": 0.41337}, "CVE-2024-6085": {"epss_score": 0.00134, "epss_percentile": 0.33918}, "CVE-2024-6086": {"epss_score": 0.00081, "epss_percentile": 0.24337}, "CVE-2024-6087": {"epss_score": 0.00143, "epss_percentile": 0.35225}, "CVE-2024-6088": {"epss_score": 0.01061, "epss_percentile": 0.77175}, "CVE-2024-6089": {"epss_score": 0.00183, "epss_percentile": 0.40301}, "CVE-2024-6090": {"epss_score": 0.0021, "epss_percentile": 0.43448}, "CVE-2024-6091": {"epss_score": 0.00129, "epss_percentile": 0.33151}, "CVE-2024-6094": {"epss_score": 0.00228, "epss_percentile": 0.45512}, "CVE-2024-6095": {"epss_score": 0.88974, "epss_percentile": 0.99502}, "CVE-2024-6096": {"epss_score": 0.00465, "epss_percentile": 0.63743}, "CVE-2024-6097": {"epss_score": 0.00093, "epss_percentile": 0.26689}, "CVE-2024-6098": {"epss_score": 0.0005, "epss_percentile": 0.15843}, "CVE-2024-6099": {"epss_score": 0.00092, "epss_percentile": 0.26561}, "CVE-2024-6100": {"epss_score": 0.00287, "epss_percentile": 0.51817}, "CVE-2024-6101": {"epss_score": 0.00475, "epss_percentile": 0.64189}, "CVE-2024-6102": {"epss_score": 0.00388, "epss_percentile": 0.59378}, "CVE-2024-6103": {"epss_score": 0.00388, "epss_percentile": 0.59378}, "CVE-2024-6104": {"epss_score": 0.00045, "epss_percentile": 0.14069}, "CVE-2024-6107": {"epss_score": 0.00109, "epss_percentile": 0.30021}, "CVE-2024-6108": {"epss_score": 0.0013, "epss_percentile": 0.33254}, "CVE-2024-6109": {"epss_score": 0.0005, "epss_percentile": 0.15838}, "CVE-2024-6110": {"epss_score": 0.00141, "epss_percentile": 0.34937}, "CVE-2024-6111": {"epss_score": 0.00068, "epss_percentile": 0.21294}, "CVE-2024-6112": {"epss_score": 0.00106, "epss_percentile": 0.29442}, "CVE-2024-6113": {"epss_score": 0.00145, "epss_percentile": 0.35452}, "CVE-2024-6114": {"epss_score": 0.00158, "epss_percentile": 0.37164}, "CVE-2024-6115": {"epss_score": 0.0017, "epss_percentile": 0.38651}, "CVE-2024-6116": {"epss_score": 0.0017, "epss_percentile": 0.38651}, "CVE-2024-6117": {"epss_score": 0.00672, "epss_percentile": 0.70811}, "CVE-2024-6118": {"epss_score": 0.00146, "epss_percentile": 0.35569}, "CVE-2024-6119": {"epss_score": 0.06275, "epss_percentile": 0.90631}, "CVE-2024-6120": {"epss_score": 0.004, "epss_percentile": 0.6016}, "CVE-2024-6121": {"epss_score": 0.00175, "epss_percentile": 0.39275}, "CVE-2024-6122": {"epss_score": 0.00094, "epss_percentile": 0.26992}, "CVE-2024-6123": {"epss_score": 0.13592, "epss_percentile": 0.94005}, "CVE-2024-6124": {"epss_score": 0.0023, "epss_percentile": 0.45707}, "CVE-2024-6125": {"epss_score": 0.01143, "epss_percentile": 0.77979}, "CVE-2024-6126": {"epss_score": 0.00019, "epss_percentile": 0.04296}, "CVE-2024-6127": {"epss_score": 0.66113, "epss_percentile": 0.98451}, "CVE-2024-6128": {"epss_score": 0.00137, "epss_percentile": 0.34222}, "CVE-2024-6129": {"epss_score": 0.00184, "epss_percentile": 0.40409}, "CVE-2024-6130": {"epss_score": 0.00486, "epss_percentile": 0.64756}, "CVE-2024-6132": {"epss_score": 0.40417, "epss_percentile": 0.97217}, "CVE-2024-6133": {"epss_score": 0.00317, "epss_percentile": 0.54359}, "CVE-2024-6134": {"epss_score": 0.0039, "epss_percentile": 0.59539}, "CVE-2024-6135": {"epss_score": 0.00165, "epss_percentile": 0.38079}, "CVE-2024-6136": {"epss_score": 0.00384, "epss_percentile": 0.59135}, "CVE-2024-6137": {"epss_score": 0.00155, "epss_percentile": 0.36812}, "CVE-2024-6138": {"epss_score": 0.00102, "epss_percentile": 0.28775}, "CVE-2024-6139": {"epss_score": 0.00121, "epss_percentile": 0.31945}, "CVE-2024-6141": {"epss_score": 0.0012, "epss_percentile": 0.31799}, "CVE-2024-6142": {"epss_score": 0.017, "epss_percentile": 0.81829}, "CVE-2024-6143": {"epss_score": 0.017, "epss_percentile": 0.81829}, "CVE-2024-6144": {"epss_score": 0.017, "epss_percentile": 0.81829}, "CVE-2024-6145": {"epss_score": 0.0112, "epss_percentile": 0.77762}, "CVE-2024-6146": {"epss_score": 0.017, "epss_percentile": 0.81829}, "CVE-2024-6147": {"epss_score": 0.0009, "epss_percentile": 0.2601}, "CVE-2024-6148": {"epss_score": 0.00089, "epss_percentile": 0.25967}, "CVE-2024-6149": {"epss_score": 0.00331, "epss_percentile": 0.55539}, "CVE-2024-6150": {"epss_score": 0.00121, "epss_percentile": 0.31834}, "CVE-2024-6151": {"epss_score": 0.0016, "epss_percentile": 0.37449}, "CVE-2024-6152": {"epss_score": 0.01485, "epss_percentile": 0.80594}, "CVE-2024-6153": {"epss_score": 0.00059, "epss_percentile": 0.1878}, "CVE-2024-6154": {"epss_score": 0.00051, "epss_percentile": 0.16335}, "CVE-2024-6155": {"epss_score": 0.00051, "epss_percentile": 0.16165}, "CVE-2024-6156": {"epss_score": 0.00025, "epss_percentile": 0.06254}, "CVE-2024-6157": {"epss_score": 0.00074, "epss_percentile": 0.22875}, "CVE-2024-6158": {"epss_score": 0.00196, "epss_percentile": 0.41774}, "CVE-2024-6159": {"epss_score": 0.09844, "epss_percentile": 0.92733}, "CVE-2024-6160": {"epss_score": 0.00143, "epss_percentile": 0.35217}, "CVE-2024-6161": {"epss_score": 0.13863, "epss_percentile": 0.94078}, "CVE-2024-6162": {"epss_score": 0.02024, "epss_percentile": 0.8331}, "CVE-2024-6163": {"epss_score": 0.00457, "epss_percentile": 0.63373}, "CVE-2024-6164": {"epss_score": 0.06786, "epss_percentile": 0.91027}, "CVE-2024-6165": {"epss_score": 0.00196, "epss_percentile": 0.41774}, "CVE-2024-6166": {"epss_score": 0.00916, "epss_percentile": 0.75412}, "CVE-2024-6167": {"epss_score": 0.00188, "epss_percentile": 0.40889}, "CVE-2024-6168": {"epss_score": 0.00178, "epss_percentile": 0.39688}, "CVE-2024-6169": {"epss_score": 0.00282, "epss_percentile": 0.51254}, "CVE-2024-6170": {"epss_score": 0.00587, "epss_percentile": 0.6847}, "CVE-2024-6171": {"epss_score": 0.002, "epss_percentile": 0.42229}, "CVE-2024-6172": {"epss_score": 0.02299, "epss_percentile": 0.84304}, "CVE-2024-6173": {"epss_score": 0.00127, "epss_percentile": 0.32799}, "CVE-2024-6174": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2024-6175": {"epss_score": 0.00264, "epss_percentile": 0.4969}, "CVE-2024-6176": {"epss_score": 0.00129, "epss_percentile": 0.33211}, "CVE-2024-6177": {"epss_score": 0.00663, "epss_percentile": 0.70621}, "CVE-2024-6178": {"epss_score": 0.00663, "epss_percentile": 0.70621}, "CVE-2024-6179": {"epss_score": 0.00663, "epss_percentile": 0.70621}, "CVE-2024-6180": {"epss_score": 0.00689, "epss_percentile": 0.71223}, "CVE-2024-6181": {"epss_score": 0.00174, "epss_percentile": 0.39156}, "CVE-2024-6182": {"epss_score": 0.00174, "epss_percentile": 0.39156}, "CVE-2024-6183": {"epss_score": 0.00222, "epss_percentile": 0.4472}, "CVE-2024-6184": {"epss_score": 0.0187, "epss_percentile": 0.82627}, "CVE-2024-6185": {"epss_score": 0.01493, "epss_percentile": 0.80638}, "CVE-2024-6186": {"epss_score": 0.03853, "epss_percentile": 0.87852}, "CVE-2024-6187": {"epss_score": 0.02595, "epss_percentile": 0.85191}, "CVE-2024-6188": {"epss_score": 0.32325, "epss_percentile": 0.96689}, "CVE-2024-6189": {"epss_score": 0.00589, "epss_percentile": 0.68516}, "CVE-2024-6190": {"epss_score": 0.00104, "epss_percentile": 0.29154}, "CVE-2024-6191": {"epss_score": 0.00061, "epss_percentile": 0.19289}, "CVE-2024-6192": {"epss_score": 0.00061, "epss_percentile": 0.19527}, "CVE-2024-6193": {"epss_score": 0.00081, "epss_percentile": 0.24333}, "CVE-2024-6194": {"epss_score": 0.00081, "epss_percentile": 0.24339}, "CVE-2024-6195": {"epss_score": 0.00088, "epss_percentile": 0.25771}, "CVE-2024-6196": {"epss_score": 0.00064, "epss_percentile": 0.20347}, "CVE-2024-6197": {"epss_score": 0.01302, "epss_percentile": 0.79299}, "CVE-2024-6198": {"epss_score": 0.00023, "epss_percentile": 0.0533}, "CVE-2024-6199": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2024-6200": {"epss_score": 0.01005, "epss_percentile": 0.76541}, "CVE-2024-6201": {"epss_score": 0.00355, "epss_percentile": 0.57299}, "CVE-2024-6202": {"epss_score": 0.00881, "epss_percentile": 0.74861}, "CVE-2024-6203": {"epss_score": 0.00224, "epss_percentile": 0.45018}, "CVE-2024-6204": {"epss_score": 0.00179, "epss_percentile": 0.39836}, "CVE-2024-6205": {"epss_score": 0.90372, "epss_percentile": 0.9958}, "CVE-2024-6206": {"epss_score": 0.0016, "epss_percentile": 0.37464}, "CVE-2024-6207": {"epss_score": 0.00333, "epss_percentile": 0.55676}, "CVE-2024-6208": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-6209": {"epss_score": 0.41618, "epss_percentile": 0.97286}, "CVE-2024-6210": {"epss_score": 0.00213, "epss_percentile": 0.43904}, "CVE-2024-6212": {"epss_score": 0.00168, "epss_percentile": 0.38494}, "CVE-2024-6213": {"epss_score": 0.00105, "epss_percentile": 0.29248}, "CVE-2024-6214": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6215": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6216": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6217": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6218": {"epss_score": 0.00054, "epss_percentile": 0.17056}, "CVE-2024-6219": {"epss_score": 0.00025, "epss_percentile": 0.06254}, "CVE-2024-6220": {"epss_score": 0.7782, "epss_percentile": 0.98956}, "CVE-2024-6221": {"epss_score": 0.00637, "epss_percentile": 0.69899}, "CVE-2024-6222": {"epss_score": 0.02246, "epss_percentile": 0.8413}, "CVE-2024-6223": {"epss_score": 0.00319, "epss_percentile": 0.54567}, "CVE-2024-6224": {"epss_score": 0.00067, "epss_percentile": 0.2107}, "CVE-2024-6225": {"epss_score": 0.00311, "epss_percentile": 0.53934}, "CVE-2024-6226": {"epss_score": 0.00552, "epss_percentile": 0.67381}, "CVE-2024-6227": {"epss_score": 0.00272, "epss_percentile": 0.50362}, "CVE-2024-6229": {"epss_score": 0.0016, "epss_percentile": 0.37518}, "CVE-2024-6230": {"epss_score": 0.00322, "epss_percentile": 0.54793}, "CVE-2024-6231": {"epss_score": 0.00194, "epss_percentile": 0.41599}, "CVE-2024-6232": {"epss_score": 0.03034, "epss_percentile": 0.86254}, "CVE-2024-6233": {"epss_score": 0.00035, "epss_percentile": 0.10116}, "CVE-2024-6235": {"epss_score": 0.89928, "epss_percentile": 0.9955}, "CVE-2024-6236": {"epss_score": 0.00577, "epss_percentile": 0.68159}, "CVE-2024-6237": {"epss_score": 0.00816, "epss_percentile": 0.73829}, "CVE-2024-6238": {"epss_score": 0.00067, "epss_percentile": 0.21107}, "CVE-2024-6239": {"epss_score": 0.00127, "epss_percentile": 0.329}, "CVE-2024-6240": {"epss_score": 0.00133, "epss_percentile": 0.33624}, "CVE-2024-6241": {"epss_score": 0.00225, "epss_percentile": 0.45075}, "CVE-2024-6242": {"epss_score": 0.0009, "epss_percentile": 0.26132}, "CVE-2024-6243": {"epss_score": 0.00161, "epss_percentile": 0.37589}, "CVE-2024-6244": {"epss_score": 0.10855, "epss_percentile": 0.93135}, "CVE-2024-6245": {"epss_score": 0.00069, "epss_percentile": 0.21562}, "CVE-2024-6246": {"epss_score": 0.00889, "epss_percentile": 0.75022}, "CVE-2024-6247": {"epss_score": 0.02005, "epss_percentile": 0.83231}, "CVE-2024-6248": {"epss_score": 0.0147, "epss_percentile": 0.80496}, "CVE-2024-6249": {"epss_score": 0.01204, "epss_percentile": 0.78505}, "CVE-2024-6250": {"epss_score": 0.00268, "epss_percentile": 0.50079}, "CVE-2024-6251": {"epss_score": 0.001, "epss_percentile": 0.28499}, "CVE-2024-6252": {"epss_score": 0.001, "epss_percentile": 0.28499}, "CVE-2024-6253": {"epss_score": 0.00073, "epss_percentile": 0.2261}, "CVE-2024-6254": {"epss_score": 0.00206, "epss_percentile": 0.43003}, "CVE-2024-6255": {"epss_score": 0.00659, "epss_percentile": 0.70509}, "CVE-2024-6256": {"epss_score": 0.00445, "epss_percentile": 0.62862}, "CVE-2024-6257": {"epss_score": 0.00393, "epss_percentile": 0.59737}, "CVE-2024-6258": {"epss_score": 0.00172, "epss_percentile": 0.38924}, "CVE-2024-6259": {"epss_score": 0.00165, "epss_percentile": 0.38079}, "CVE-2024-6260": {"epss_score": 0.00107, "epss_percentile": 0.29625}, "CVE-2024-6261": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2024-6262": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-6263": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-6264": {"epss_score": 0.00234, "epss_percentile": 0.46156}, "CVE-2024-6265": {"epss_score": 0.02003, "epss_percentile": 0.83226}, "CVE-2024-6266": {"epss_score": 0.00353, "epss_percentile": 0.5715}, "CVE-2024-6267": {"epss_score": 0.00117, "epss_percentile": 0.31241}, "CVE-2024-6268": {"epss_score": 0.00094, "epss_percentile": 0.27065}, "CVE-2024-6269": {"epss_score": 0.00983, "epss_percentile": 0.76301}, "CVE-2024-6270": {"epss_score": 0.0027, "epss_percentile": 0.50261}, "CVE-2024-6271": {"epss_score": 0.00174, "epss_percentile": 0.3914}, "CVE-2024-6272": {"epss_score": 0.00257, "epss_percentile": 0.48866}, "CVE-2024-6273": {"epss_score": 0.00199, "epss_percentile": 0.42108}, "CVE-2024-6274": {"epss_score": 0.00107, "epss_percentile": 0.29721}, "CVE-2024-6275": {"epss_score": 0.00107, "epss_percentile": 0.29721}, "CVE-2024-6276": {"epss_score": 0.00107, "epss_percentile": 0.29721}, "CVE-2024-6277": {"epss_score": 0.00107, "epss_percentile": 0.29721}, "CVE-2024-6278": {"epss_score": 0.00107, "epss_percentile": 0.29721}, "CVE-2024-6279": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6280": {"epss_score": 0.00158, "epss_percentile": 0.37174}, "CVE-2024-6281": {"epss_score": 0.00107, "epss_percentile": 0.29687}, "CVE-2024-6282": {"epss_score": 0.00265, "epss_percentile": 0.49788}, "CVE-2024-6283": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-6284": {"epss_score": 0.00069, "epss_percentile": 0.21527}, "CVE-2024-6285": {"epss_score": 8e-05, "epss_percentile": 0.00592}, "CVE-2024-6286": {"epss_score": 0.00153, "epss_percentile": 0.36612}, "CVE-2024-6287": {"epss_score": 0.0001, "epss_percentile": 0.00751}, "CVE-2024-6288": {"epss_score": 0.02577, "epss_percentile": 0.85145}, "CVE-2024-6289": {"epss_score": 0.07883, "epss_percentile": 0.91742}, "CVE-2024-6290": {"epss_score": 0.00267, "epss_percentile": 0.4999}, "CVE-2024-6291": {"epss_score": 0.0023, "epss_percentile": 0.45725}, "CVE-2024-6292": {"epss_score": 0.00246, "epss_percentile": 0.47751}, "CVE-2024-6293": {"epss_score": 0.00197, "epss_percentile": 0.41824}, "CVE-2024-6294": {"epss_score": 0.00118, "epss_percentile": 0.31484}, "CVE-2024-6295": {"epss_score": 0.00087, "epss_percentile": 0.2555}, "CVE-2024-6296": {"epss_score": 0.00227, "epss_percentile": 0.45451}, "CVE-2024-6297": {"epss_score": 0.03969, "epss_percentile": 0.88035}, "CVE-2024-6298": {"epss_score": 0.34971, "epss_percentile": 0.9688}, "CVE-2024-6299": {"epss_score": 0.00114, "epss_percentile": 0.30876}, "CVE-2024-6300": {"epss_score": 0.00325, "epss_percentile": 0.55023}, "CVE-2024-6301": {"epss_score": 0.00199, "epss_percentile": 0.42099}, "CVE-2024-6302": {"epss_score": 0.00167, "epss_percentile": 0.38383}, "CVE-2024-6303": {"epss_score": 0.00357, "epss_percentile": 0.57464}, "CVE-2024-6307": {"epss_score": 0.00646, "epss_percentile": 0.70137}, "CVE-2024-6308": {"epss_score": 0.00068, "epss_percentile": 0.21294}, "CVE-2024-6309": {"epss_score": 0.02317, "epss_percentile": 0.8436}, "CVE-2024-6310": {"epss_score": 0.02966, "epss_percentile": 0.86081}, "CVE-2024-6311": {"epss_score": 0.06054, "epss_percentile": 0.90437}, "CVE-2024-6312": {"epss_score": 0.23493, "epss_percentile": 0.95785}, "CVE-2024-6313": {"epss_score": 0.29706, "epss_percentile": 0.96468}, "CVE-2024-6314": {"epss_score": 0.17826, "epss_percentile": 0.94913}, "CVE-2024-6315": {"epss_score": 0.0695, "epss_percentile": 0.91137}, "CVE-2024-6316": {"epss_score": 0.02738, "epss_percentile": 0.85553}, "CVE-2024-6317": {"epss_score": 0.08329, "epss_percentile": 0.91992}, "CVE-2024-6318": {"epss_score": 0.14837, "epss_percentile": 0.943}, "CVE-2024-6319": {"epss_score": 0.10938, "epss_percentile": 0.93166}, "CVE-2024-6320": {"epss_score": 0.02894, "epss_percentile": 0.85923}, "CVE-2024-6321": {"epss_score": 0.02894, "epss_percentile": 0.85923}, "CVE-2024-6322": {"epss_score": 0.00032, "epss_percentile": 0.08969}, "CVE-2024-6323": {"epss_score": 0.00067, "epss_percentile": 0.21101}, "CVE-2024-6324": {"epss_score": 0.00186, "epss_percentile": 0.40604}, "CVE-2024-6325": {"epss_score": 0.0003, "epss_percentile": 0.08055}, "CVE-2024-6326": {"epss_score": 8e-05, "epss_percentile": 0.00535}, "CVE-2024-6327": {"epss_score": 0.03359, "epss_percentile": 0.8699}, "CVE-2024-6328": {"epss_score": 0.00759, "epss_percentile": 0.72789}, "CVE-2024-6329": {"epss_score": 0.00063, "epss_percentile": 0.19907}, "CVE-2024-6330": {"epss_score": 0.41799, "epss_percentile": 0.97295}, "CVE-2024-6331": {"epss_score": 0.0022, "epss_percentile": 0.44602}, "CVE-2024-6332": {"epss_score": 0.00501, "epss_percentile": 0.65334}, "CVE-2024-6333": {"epss_score": 0.02735, "epss_percentile": 0.8555}, "CVE-2024-6334": {"epss_score": 0.00333, "epss_percentile": 0.55636}, "CVE-2024-6335": {"epss_score": 0.00026, "epss_percentile": 0.06556}, "CVE-2024-6336": {"epss_score": 0.00385, "epss_percentile": 0.59191}, "CVE-2024-6337": {"epss_score": 0.00218, "epss_percentile": 0.44371}, "CVE-2024-6338": {"epss_score": 0.00651, "epss_percentile": 0.70288}, "CVE-2024-6339": {"epss_score": 0.01905, "epss_percentile": 0.82795}, "CVE-2024-6340": {"epss_score": 0.00234, "epss_percentile": 0.46156}, "CVE-2024-6342": {"epss_score": 0.04971, "epss_percentile": 0.89351}, "CVE-2024-6343": {"epss_score": 0.00185, "epss_percentile": 0.40481}, "CVE-2024-6344": {"epss_score": 0.00093, "epss_percentile": 0.26712}, "CVE-2024-6345": {"epss_score": 0.04814, "epss_percentile": 0.89169}, "CVE-2024-6346": {"epss_score": 0.00254, "epss_percentile": 0.48542}, "CVE-2024-6347": {"epss_score": 0.00057, "epss_percentile": 0.18222}, "CVE-2024-6348": {"epss_score": 0.00079, "epss_percentile": 0.23895}, "CVE-2024-6350": {"epss_score": 0.00056, "epss_percentile": 0.17898}, "CVE-2024-6351": {"epss_score": 0.00059, "epss_percentile": 0.1874}, "CVE-2024-6352": {"epss_score": 0.00054, "epss_percentile": 0.17308}, "CVE-2024-6353": {"epss_score": 0.00588, "epss_percentile": 0.68496}, "CVE-2024-6354": {"epss_score": 0.00127, "epss_percentile": 0.32784}, "CVE-2024-6355": {"epss_score": 0.00144, "epss_percentile": 0.35249}, "CVE-2024-6356": {"epss_score": 0.00049, "epss_percentile": 0.1546}, "CVE-2024-6357": {"epss_score": 0.0014, "epss_percentile": 0.34746}, "CVE-2024-6358": {"epss_score": 0.00194, "epss_percentile": 0.41575}, "CVE-2024-6359": {"epss_score": 0.00271, "epss_percentile": 0.50289}, "CVE-2024-6360": {"epss_score": 0.00072, "epss_percentile": 0.22423}, "CVE-2024-6361": {"epss_score": 0.00567, "epss_percentile": 0.67844}, "CVE-2024-6362": {"epss_score": 0.00155, "epss_percentile": 0.36846}, "CVE-2024-6363": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-6364": {"epss_score": 0.00021, "epss_percentile": 0.04741}, "CVE-2024-6365": {"epss_score": 0.37681, "epss_percentile": 0.97063}, "CVE-2024-6366": {"epss_score": 0.91471, "epss_percentile": 0.99647}, "CVE-2024-6367": {"epss_score": 0.00127, "epss_percentile": 0.32798}, "CVE-2024-6368": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-6369": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-6370": {"epss_score": 0.00152, "epss_percentile": 0.36395}, "CVE-2024-6371": {"epss_score": 0.00105, "epss_percentile": 0.29248}, "CVE-2024-6372": {"epss_score": 0.00077, "epss_percentile": 0.23407}, "CVE-2024-6373": {"epss_score": 0.00141, "epss_percentile": 0.34937}, "CVE-2024-6374": {"epss_score": 0.00141, "epss_percentile": 0.34816}, "CVE-2024-6375": {"epss_score": 0.00297, "epss_percentile": 0.52707}, "CVE-2024-6376": {"epss_score": 0.0066, "epss_percentile": 0.70538}, "CVE-2024-6377": {"epss_score": 0.00301, "epss_percentile": 0.53067}, "CVE-2024-6378": {"epss_score": 0.00938, "epss_percentile": 0.75702}, "CVE-2024-6379": {"epss_score": 0.00723, "epss_percentile": 0.72004}, "CVE-2024-6380": {"epss_score": 0.00799, "epss_percentile": 0.73523}, "CVE-2024-6381": {"epss_score": 0.00334, "epss_percentile": 0.55691}, "CVE-2024-6382": {"epss_score": 0.00111, "epss_percentile": 0.30281}, "CVE-2024-6383": {"epss_score": 0.00189, "epss_percentile": 0.40933}, "CVE-2024-6384": {"epss_score": 0.00279, "epss_percentile": 0.50955}, "CVE-2024-6385": {"epss_score": 0.00665, "epss_percentile": 0.70654}, "CVE-2024-6386": {"epss_score": 0.75352, "epss_percentile": 0.9884}, "CVE-2024-6387": {"epss_score": 0.50789, "epss_percentile": 0.9775}, "CVE-2024-6388": {"epss_score": 0.00022, "epss_percentile": 0.05314}, "CVE-2024-6389": {"epss_score": 0.00055, "epss_percentile": 0.17567}, "CVE-2024-6390": {"epss_score": 0.00119, "epss_percentile": 0.31541}, "CVE-2024-6391": {"epss_score": 0.0036, "epss_percentile": 0.57645}, "CVE-2024-6392": {"epss_score": 0.00175, "epss_percentile": 0.39352}, "CVE-2024-6393": {"epss_score": 0.0014, "epss_percentile": 0.34758}, "CVE-2024-6394": {"epss_score": 0.00379, "epss_percentile": 0.58838}, "CVE-2024-6395": {"epss_score": 0.0061, "epss_percentile": 0.69143}, "CVE-2024-6396": {"epss_score": 0.9083, "epss_percentile": 0.99603}, "CVE-2024-6397": {"epss_score": 0.00585, "epss_percentile": 0.68413}, "CVE-2024-6398": {"epss_score": 0.00071, "epss_percentile": 0.22059}, "CVE-2024-6400": {"epss_score": 0.00066, "epss_percentile": 0.20964}, "CVE-2024-6401": {"epss_score": 0.00159, "epss_percentile": 0.37335}, "CVE-2024-6402": {"epss_score": 0.00225, "epss_percentile": 0.45222}, "CVE-2024-6403": {"epss_score": 0.00225, "epss_percentile": 0.45222}, "CVE-2024-6405": {"epss_score": 0.00168, "epss_percentile": 0.38496}, "CVE-2024-6406": {"epss_score": 0.00152, "epss_percentile": 0.36487}, "CVE-2024-6407": {"epss_score": 0.0034, "epss_percentile": 0.56217}, "CVE-2024-6408": {"epss_score": 0.00394, "epss_percentile": 0.59781}, "CVE-2024-6409": {"epss_score": 0.76397, "epss_percentile": 0.9889}, "CVE-2024-6410": {"epss_score": 0.00209, "epss_percentile": 0.43323}, "CVE-2024-6411": {"epss_score": 0.01086, "epss_percentile": 0.77425}, "CVE-2024-6412": {"epss_score": 0.00253, "epss_percentile": 0.48474}, "CVE-2024-6414": {"epss_score": 0.00057, "epss_percentile": 0.18062}, "CVE-2024-6415": {"epss_score": 0.001, "epss_percentile": 0.28506}, "CVE-2024-6416": {"epss_score": 0.00096, "epss_percentile": 0.27245}, "CVE-2024-6417": {"epss_score": 0.00086, "epss_percentile": 0.25277}, "CVE-2024-6418": {"epss_score": 0.00087, "epss_percentile": 0.25618}, "CVE-2024-6419": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-6420": {"epss_score": 0.29383, "epss_percentile": 0.96437}, "CVE-2024-6421": {"epss_score": 0.00487, "epss_percentile": 0.64806}, "CVE-2024-6422": {"epss_score": 0.03551, "epss_percentile": 0.87341}, "CVE-2024-6424": {"epss_score": 0.00562, "epss_percentile": 0.67696}, "CVE-2024-6425": {"epss_score": 0.00501, "epss_percentile": 0.65358}, "CVE-2024-6426": {"epss_score": 0.00126, "epss_percentile": 0.3273}, "CVE-2024-6427": {"epss_score": 0.0062, "epss_percentile": 0.69441}, "CVE-2024-6428": {"epss_score": 0.00064, "epss_percentile": 0.20336}, "CVE-2024-6429": {"epss_score": 0.00036, "epss_percentile": 0.10204}, "CVE-2024-6431": {"epss_score": 0.14532, "epss_percentile": 0.94233}, "CVE-2024-6432": {"epss_score": 0.00119, "epss_percentile": 0.31673}, "CVE-2024-6433": {"epss_score": 0.00407, "epss_percentile": 0.60587}, "CVE-2024-6434": {"epss_score": 0.00087, "epss_percentile": 0.25587}, "CVE-2024-6435": {"epss_score": 0.00037, "epss_percentile": 0.1099}, "CVE-2024-6436": {"epss_score": 0.00075, "epss_percentile": 0.22988}, "CVE-2024-6437": {"epss_score": 0.00077, "epss_percentile": 0.23365}, "CVE-2024-6438": {"epss_score": 0.00078, "epss_percentile": 0.23673}, "CVE-2024-6439": {"epss_score": 0.00145, "epss_percentile": 0.35514}, "CVE-2024-6440": {"epss_score": 0.00096, "epss_percentile": 0.27245}, "CVE-2024-6441": {"epss_score": 0.00268, "epss_percentile": 0.50055}, "CVE-2024-6442": {"epss_score": 0.00144, "epss_percentile": 0.35253}, "CVE-2024-6443": {"epss_score": 0.00117, "epss_percentile": 0.3126}, "CVE-2024-6444": {"epss_score": 0.00086, "epss_percentile": 0.25348}, "CVE-2024-6445": {"epss_score": 0.00147, "epss_percentile": 0.35698}, "CVE-2024-6446": {"epss_score": 0.00074, "epss_percentile": 0.22802}, "CVE-2024-6447": {"epss_score": 0.02156, "epss_percentile": 0.83807}, "CVE-2024-6448": {"epss_score": 0.00339, "epss_percentile": 0.56201}, "CVE-2024-6449": {"epss_score": 0.00172, "epss_percentile": 0.39011}, "CVE-2024-6450": {"epss_score": 0.00359, "epss_percentile": 0.57606}, "CVE-2024-6451": {"epss_score": 0.00657, "epss_percentile": 0.70458}, "CVE-2024-6452": {"epss_score": 0.00328, "epss_percentile": 0.55276}, "CVE-2024-6453": {"epss_score": 0.00056, "epss_percentile": 0.17906}, "CVE-2024-6455": {"epss_score": 0.00396, "epss_percentile": 0.59857}, "CVE-2024-6456": {"epss_score": 0.00274, "epss_percentile": 0.50554}, "CVE-2024-6457": {"epss_score": 0.06654, "epss_percentile": 0.90917}, "CVE-2024-6458": {"epss_score": 0.00281, "epss_percentile": 0.51126}, "CVE-2024-6459": {"epss_score": 0.05797, "epss_percentile": 0.90219}, "CVE-2024-6460": {"epss_score": 0.91408, "epss_percentile": 0.99641}, "CVE-2024-6462": {"epss_score": 0.00048, "epss_percentile": 0.15095}, "CVE-2024-6465": {"epss_score": 0.00108, "epss_percentile": 0.29879}, "CVE-2024-6466": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2024-6467": {"epss_score": 0.01093, "epss_percentile": 0.77471}, "CVE-2024-6468": {"epss_score": 0.00396, "epss_percentile": 0.59898}, "CVE-2024-6469": {"epss_score": 0.00132, "epss_percentile": 0.33544}, "CVE-2024-6470": {"epss_score": 0.001, "epss_percentile": 0.28506}, "CVE-2024-6471": {"epss_score": 0.0005, "epss_percentile": 0.15838}, "CVE-2024-6472": {"epss_score": 0.00074, "epss_percentile": 0.22823}, "CVE-2024-6473": {"epss_score": 0.02873, "epss_percentile": 0.8588}, "CVE-2024-6476": {"epss_score": 0.00032, "epss_percentile": 0.08853}, "CVE-2024-6477": {"epss_score": 0.00412, "epss_percentile": 0.60918}, "CVE-2024-6478": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-6479": {"epss_score": 0.00384, "epss_percentile": 0.59152}, "CVE-2024-6480": {"epss_score": 0.00169, "epss_percentile": 0.38531}, "CVE-2024-6481": {"epss_score": 0.00164, "epss_percentile": 0.37992}, "CVE-2024-6482": {"epss_score": 0.00345, "epss_percentile": 0.56586}, "CVE-2024-6483": {"epss_score": 0.00246, "epss_percentile": 0.47781}, "CVE-2024-6485": {"epss_score": 0.00124, "epss_percentile": 0.32427}, "CVE-2024-6486": {"epss_score": 0.00965, "epss_percentile": 0.76043}, "CVE-2024-6487": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2024-6489": {"epss_score": 0.00145, "epss_percentile": 0.3537}, "CVE-2024-6490": {"epss_score": 0.00124, "epss_percentile": 0.3234}, "CVE-2024-6491": {"epss_score": 0.00135, "epss_percentile": 0.34033}, "CVE-2024-6492": {"epss_score": 0.00552, "epss_percentile": 0.67404}, "CVE-2024-6493": {"epss_score": 0.00179, "epss_percentile": 0.39838}, "CVE-2024-6494": {"epss_score": 0.01192, "epss_percentile": 0.78404}, "CVE-2024-6495": {"epss_score": 0.00311, "epss_percentile": 0.53837}, "CVE-2024-6496": {"epss_score": 0.00247, "epss_percentile": 0.47906}, "CVE-2024-6497": {"epss_score": 0.17963, "epss_percentile": 0.94934}, "CVE-2024-6498": {"epss_score": 0.00223, "epss_percentile": 0.44862}, "CVE-2024-6499": {"epss_score": 0.00339, "epss_percentile": 0.56201}, "CVE-2024-6500": {"epss_score": 0.06829, "epss_percentile": 0.91053}, "CVE-2024-6501": {"epss_score": 0.00082, "epss_percentile": 0.24507}, "CVE-2024-6502": {"epss_score": 0.0007, "epss_percentile": 0.21673}, "CVE-2024-6504": {"epss_score": 0.00239, "epss_percentile": 0.46889}, "CVE-2024-6505": {"epss_score": 0.00085, "epss_percentile": 0.25073}, "CVE-2024-6506": {"epss_score": 0.0048, "epss_percentile": 0.64475}, "CVE-2024-6507": {"epss_score": 0.0019, "epss_percentile": 0.41093}, "CVE-2024-6508": {"epss_score": 0.00664, "epss_percentile": 0.70631}, "CVE-2024-6509": {"epss_score": 0.00127, "epss_percentile": 0.32799}, "CVE-2024-6510": {"epss_score": 0.00036, "epss_percentile": 0.10438}, "CVE-2024-6511": {"epss_score": 0.00632, "epss_percentile": 0.69753}, "CVE-2024-6512": {"epss_score": 0.00085, "epss_percentile": 0.25118}, "CVE-2024-6515": {"epss_score": 0.00098, "epss_percentile": 0.27701}, "CVE-2024-6516": {"epss_score": 0.01264, "epss_percentile": 0.78994}, "CVE-2024-6517": {"epss_score": 0.03016, "epss_percentile": 0.86215}, "CVE-2024-6518": {"epss_score": 0.00286, "epss_percentile": 0.51698}, "CVE-2024-6519": {"epss_score": 0.00015, "epss_percentile": 0.02553}, "CVE-2024-6520": {"epss_score": 0.00286, "epss_percentile": 0.51698}, "CVE-2024-6521": {"epss_score": 0.00286, "epss_percentile": 0.51698}, "CVE-2024-6522": {"epss_score": 0.0074, "epss_percentile": 0.7241}, "CVE-2024-6523": {"epss_score": 0.0009, "epss_percentile": 0.26095}, "CVE-2024-6524": {"epss_score": 0.0011, "epss_percentile": 0.30158}, "CVE-2024-6525": {"epss_score": 0.01776, "epss_percentile": 0.8222}, "CVE-2024-6526": {"epss_score": 0.00169, "epss_percentile": 0.38556}, "CVE-2024-6527": {"epss_score": 0.00057, "epss_percentile": 0.18211}, "CVE-2024-6528": {"epss_score": 0.00471, "epss_percentile": 0.64027}, "CVE-2024-6529": {"epss_score": 0.52373, "epss_percentile": 0.97821}, "CVE-2024-6530": {"epss_score": 0.0097, "epss_percentile": 0.76106}, "CVE-2024-6532": {"epss_score": 0.00391, "epss_percentile": 0.59629}, "CVE-2024-6533": {"epss_score": 0.00122, "epss_percentile": 0.32037}, "CVE-2024-6534": {"epss_score": 0.00069, "epss_percentile": 0.21474}, "CVE-2024-6535": {"epss_score": 0.00071, "epss_percentile": 0.22131}, "CVE-2024-6536": {"epss_score": 0.47466, "epss_percentile": 0.97589}, "CVE-2024-6538": {"epss_score": 0.00128, "epss_percentile": 0.3297}, "CVE-2024-6539": {"epss_score": 0.00111, "epss_percentile": 0.30384}, "CVE-2024-6540": {"epss_score": 0.00445, "epss_percentile": 0.62872}, "CVE-2024-6542": {"epss_score": 0.00229, "epss_percentile": 0.45656}, "CVE-2024-6544": {"epss_score": 0.0055, "epss_percentile": 0.67326}, "CVE-2024-6545": {"epss_score": 0.00746, "epss_percentile": 0.72535}, "CVE-2024-6546": {"epss_score": 0.00746, "epss_percentile": 0.72535}, "CVE-2024-6547": {"epss_score": 0.00746, "epss_percentile": 0.72535}, "CVE-2024-6548": {"epss_score": 0.00746, "epss_percentile": 0.72535}, "CVE-2024-6549": {"epss_score": 0.00485, "epss_percentile": 0.64709}, "CVE-2024-6550": {"epss_score": 0.00866, "epss_percentile": 0.74631}, "CVE-2024-6551": {"epss_score": 0.00409, "epss_percentile": 0.60721}, "CVE-2024-6552": {"epss_score": 0.00563, "epss_percentile": 0.67732}, "CVE-2024-6553": {"epss_score": 0.00746, "epss_percentile": 0.72535}, "CVE-2024-6554": {"epss_score": 0.00563, "epss_percentile": 0.67732}, "CVE-2024-6555": {"epss_score": 0.08245, "epss_percentile": 0.91947}, "CVE-2024-6556": {"epss_score": 0.00746, "epss_percentile": 0.72535}, "CVE-2024-6557": {"epss_score": 0.00563, "epss_percentile": 0.67732}, "CVE-2024-6558": {"epss_score": 0.00641, "epss_percentile": 0.69989}, "CVE-2024-6559": {"epss_score": 0.00485, "epss_percentile": 0.64709}, "CVE-2024-6560": {"epss_score": 0.00305, "epss_percentile": 0.53394}, "CVE-2024-6562": {"epss_score": 0.00263, "epss_percentile": 0.49488}, "CVE-2024-6563": {"epss_score": 0.00094, "epss_percentile": 0.2678}, "CVE-2024-6564": {"epss_score": 0.0002, "epss_percentile": 0.04491}, "CVE-2024-6565": {"epss_score": 0.00563, "epss_percentile": 0.67732}, "CVE-2024-6566": {"epss_score": 0.00746, "epss_percentile": 0.72535}, "CVE-2024-6567": {"epss_score": 0.00746, "epss_percentile": 0.72535}, "CVE-2024-6568": {"epss_score": 0.00639, "epss_percentile": 0.69931}, "CVE-2024-6569": {"epss_score": 0.00866, "epss_percentile": 0.74631}, "CVE-2024-6570": {"epss_score": 0.00563, "epss_percentile": 0.67732}, "CVE-2024-6571": {"epss_score": 0.00746, "epss_percentile": 0.72535}, "CVE-2024-6572": {"epss_score": 0.00196, "epss_percentile": 0.41812}, "CVE-2024-6573": {"epss_score": 0.00866, "epss_percentile": 0.74631}, "CVE-2024-6574": {"epss_score": 0.00276, "epss_percentile": 0.50758}, "CVE-2024-6575": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-6576": {"epss_score": 0.02169, "epss_percentile": 0.83863}, "CVE-2024-6577": {"epss_score": 0.00102, "epss_percentile": 0.28721}, "CVE-2024-6578": {"epss_score": 0.00304, "epss_percentile": 0.53291}, "CVE-2024-6579": {"epss_score": 0.00147, "epss_percentile": 0.35743}, "CVE-2024-6580": {"epss_score": 0.00143, "epss_percentile": 0.35221}, "CVE-2024-6581": {"epss_score": 0.01218, "epss_percentile": 0.78603}, "CVE-2024-6582": {"epss_score": 0.00135, "epss_percentile": 0.34055}, "CVE-2024-6583": {"epss_score": 0.00115, "epss_percentile": 0.30935}, "CVE-2024-6584": {"epss_score": 0.00126, "epss_percentile": 0.32638}, "CVE-2024-6585": {"epss_score": 0.00139, "epss_percentile": 0.34593}, "CVE-2024-6586": {"epss_score": 0.15756, "epss_percentile": 0.94499}, "CVE-2024-6587": {"epss_score": 0.87671, "epss_percentile": 0.99438}, "CVE-2024-6588": {"epss_score": 0.00576, "epss_percentile": 0.68128}, "CVE-2024-6589": {"epss_score": 0.02405, "epss_percentile": 0.8465}, "CVE-2024-6590": {"epss_score": 0.0013, "epss_percentile": 0.33268}, "CVE-2024-6591": {"epss_score": 0.00519, "epss_percentile": 0.66175}, "CVE-2024-6592": {"epss_score": 0.01851, "epss_percentile": 0.82538}, "CVE-2024-6593": {"epss_score": 0.00942, "epss_percentile": 0.75767}, "CVE-2024-6594": {"epss_score": 0.00611, "epss_percentile": 0.69192}, "CVE-2024-6595": {"epss_score": 0.00093, "epss_percentile": 0.2672}, "CVE-2024-6596": {"epss_score": 0.01074, "epss_percentile": 0.773}, "CVE-2024-6598": {"epss_score": 0.00881, "epss_percentile": 0.74877}, "CVE-2024-6599": {"epss_score": 0.00228, "epss_percentile": 0.45505}, "CVE-2024-6600": {"epss_score": 0.00169, "epss_percentile": 0.38645}, "CVE-2024-6601": {"epss_score": 0.00122, "epss_percentile": 0.32021}, "CVE-2024-6602": {"epss_score": 0.00945, "epss_percentile": 0.75803}, "CVE-2024-6603": {"epss_score": 0.00374, "epss_percentile": 0.5857}, "CVE-2024-6604": {"epss_score": 0.00413, "epss_percentile": 0.60967}, "CVE-2024-6605": {"epss_score": 0.00564, "epss_percentile": 0.67743}, "CVE-2024-6606": {"epss_score": 0.00187, "epss_percentile": 0.40776}, "CVE-2024-6607": {"epss_score": 0.00932, "epss_percentile": 0.75623}, "CVE-2024-6608": {"epss_score": 0.00121, "epss_percentile": 0.31941}, "CVE-2024-6609": {"epss_score": 0.00621, "epss_percentile": 0.69489}, "CVE-2024-6610": {"epss_score": 0.00087, "epss_percentile": 0.25504}, "CVE-2024-6611": {"epss_score": 0.0059, "epss_percentile": 0.68559}, "CVE-2024-6612": {"epss_score": 0.00273, "epss_percentile": 0.50473}, "CVE-2024-6613": {"epss_score": 0.00076, "epss_percentile": 0.23264}, "CVE-2024-6614": {"epss_score": 0.00212, "epss_percentile": 0.43783}, "CVE-2024-6615": {"epss_score": 0.0059, "epss_percentile": 0.68571}, "CVE-2024-6617": {"epss_score": 0.00071, "epss_percentile": 0.2218}, "CVE-2024-6618": {"epss_score": 0.0155, "epss_percentile": 0.80984}, "CVE-2024-6619": {"epss_score": 0.0011, "epss_percentile": 0.30219}, "CVE-2024-6620": {"epss_score": 0.00121, "epss_percentile": 0.31993}, "CVE-2024-6621": {"epss_score": 0.00171, "epss_percentile": 0.38864}, "CVE-2024-6624": {"epss_score": 0.3928, "epss_percentile": 0.97151}, "CVE-2024-6625": {"epss_score": 0.00236, "epss_percentile": 0.4636}, "CVE-2024-6626": {"epss_score": 0.00729, "epss_percentile": 0.72121}, "CVE-2024-6627": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-6628": {"epss_score": 0.00213, "epss_percentile": 0.43853}, "CVE-2024-6629": {"epss_score": 0.00368, "epss_percentile": 0.58166}, "CVE-2024-6631": {"epss_score": 0.00133, "epss_percentile": 0.3366}, "CVE-2024-6632": {"epss_score": 0.00438, "epss_percentile": 0.6255}, "CVE-2024-6633": {"epss_score": 0.01072, "epss_percentile": 0.77282}, "CVE-2024-6634": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-6635": {"epss_score": 0.00329, "epss_percentile": 0.55413}, "CVE-2024-6636": {"epss_score": 0.02727, "epss_percentile": 0.8553}, "CVE-2024-6637": {"epss_score": 0.00545, "epss_percentile": 0.67171}, "CVE-2024-6638": {"epss_score": 0.00067, "epss_percentile": 0.21046}, "CVE-2024-6639": {"epss_score": 0.00545, "epss_percentile": 0.67154}, "CVE-2024-6640": {"epss_score": 0.00026, "epss_percentile": 0.06532}, "CVE-2024-6641": {"epss_score": 0.00252, "epss_percentile": 0.4835}, "CVE-2024-6644": {"epss_score": 0.00239, "epss_percentile": 0.46856}, "CVE-2024-6645": {"epss_score": 0.00062, "epss_percentile": 0.19776}, "CVE-2024-6646": {"epss_score": 0.91637, "epss_percentile": 0.9966}, "CVE-2024-6647": {"epss_score": 0.00078, "epss_percentile": 0.23675}, "CVE-2024-6648": {"epss_score": 0.00078, "epss_percentile": 0.23745}, "CVE-2024-6649": {"epss_score": 0.00135, "epss_percentile": 0.33931}, "CVE-2024-6650": {"epss_score": 0.00072, "epss_percentile": 0.22309}, "CVE-2024-6651": {"epss_score": 0.11531, "epss_percentile": 0.93394}, "CVE-2024-6652": {"epss_score": 0.00077, "epss_percentile": 0.23407}, "CVE-2024-6653": {"epss_score": 0.00078, "epss_percentile": 0.23765}, "CVE-2024-6654": {"epss_score": 0.00085, "epss_percentile": 0.2514}, "CVE-2024-6655": {"epss_score": 0.00055, "epss_percentile": 0.17645}, "CVE-2024-6656": {"epss_score": 0.00181, "epss_percentile": 0.40078}, "CVE-2024-6657": {"epss_score": 0.00035, "epss_percentile": 0.10076}, "CVE-2024-6658": {"epss_score": 0.00129, "epss_percentile": 0.33093}, "CVE-2024-6660": {"epss_score": 0.00402, "epss_percentile": 0.60298}, "CVE-2024-6661": {"epss_score": 0.0032, "epss_percentile": 0.54632}, "CVE-2024-6662": {"epss_score": 0.00106, "epss_percentile": 0.29573}, "CVE-2024-6665": {"epss_score": 0.00026, "epss_percentile": 0.06556}, "CVE-2024-6666": {"epss_score": 0.00808, "epss_percentile": 0.73689}, "CVE-2024-6667": {"epss_score": 0.00052, "epss_percentile": 0.16625}, "CVE-2024-6668": {"epss_score": 0.00022, "epss_percentile": 0.05165}, "CVE-2024-6669": {"epss_score": 0.00334, "epss_percentile": 0.55706}, "CVE-2024-6670": {"epss_score": 0.94468, "epss_percentile": 0.99996}, "CVE-2024-6671": {"epss_score": 0.03918, "epss_percentile": 0.87949}, "CVE-2024-6672": {"epss_score": 0.01285, "epss_percentile": 0.79175}, "CVE-2024-6673": {"epss_score": 0.00077, "epss_percentile": 0.23402}, "CVE-2024-6674": {"epss_score": 0.00154, "epss_percentile": 0.36653}, "CVE-2024-6675": {"epss_score": 0.01123, "epss_percentile": 0.77788}, "CVE-2024-6676": {"epss_score": 0.0002, "epss_percentile": 0.0451}, "CVE-2024-6677": {"epss_score": 0.00128, "epss_percentile": 0.32963}, "CVE-2024-6678": {"epss_score": 0.00072, "epss_percentile": 0.22246}, "CVE-2024-6679": {"epss_score": 0.0003, "epss_percentile": 0.08274}, "CVE-2024-6680": {"epss_score": 0.00026, "epss_percentile": 0.06519}, "CVE-2024-6681": {"epss_score": 0.0003, "epss_percentile": 0.08274}, "CVE-2024-6684": {"epss_score": 0.00155, "epss_percentile": 0.36846}, "CVE-2024-6685": {"epss_score": 0.00029, "epss_percentile": 0.07977}, "CVE-2024-6687": {"epss_score": 0.00286, "epss_percentile": 0.517}, "CVE-2024-6688": {"epss_score": 0.00111, "epss_percentile": 0.30318}, "CVE-2024-6689": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2024-6690": {"epss_score": 0.00152, "epss_percentile": 0.36455}, "CVE-2024-6691": {"epss_score": 0.00191, "epss_percentile": 0.41191}, "CVE-2024-6692": {"epss_score": 0.00209, "epss_percentile": 0.43362}, "CVE-2024-6693": {"epss_score": 0.00054, "epss_percentile": 0.17287}, "CVE-2024-6694": {"epss_score": 0.03291, "epss_percentile": 0.86837}, "CVE-2024-6695": {"epss_score": 0.0059, "epss_percentile": 0.68558}, "CVE-2024-6696": {"epss_score": 0.00114, "epss_percentile": 0.30763}, "CVE-2024-6697": {"epss_score": 0.00096, "epss_percentile": 0.27378}, "CVE-2024-6698": {"epss_score": 0.00423, "epss_percentile": 0.61604}, "CVE-2024-6699": {"epss_score": 0.0014, "epss_percentile": 0.34758}, "CVE-2024-6700": {"epss_score": 0.00078, "epss_percentile": 0.23676}, "CVE-2024-6701": {"epss_score": 0.00086, "epss_percentile": 0.25442}, "CVE-2024-6702": {"epss_score": 0.00086, "epss_percentile": 0.25442}, "CVE-2024-6703": {"epss_score": 0.00177, "epss_percentile": 0.3957}, "CVE-2024-6704": {"epss_score": 0.08433, "epss_percentile": 0.9205}, "CVE-2024-6705": {"epss_score": 0.00216, "epss_percentile": 0.44173}, "CVE-2024-6706": {"epss_score": 0.00189, "epss_percentile": 0.40936}, "CVE-2024-6707": {"epss_score": 0.00203, "epss_percentile": 0.42565}, "CVE-2024-6708": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-6709": {"epss_score": 0.00147, "epss_percentile": 0.35743}, "CVE-2024-6710": {"epss_score": 0.00206, "epss_percentile": 0.42946}, "CVE-2024-6711": {"epss_score": 0.00054, "epss_percentile": 0.17287}, "CVE-2024-6712": {"epss_score": 0.00027, "epss_percentile": 0.06877}, "CVE-2024-6713": {"epss_score": 0.00048, "epss_percentile": 0.15095}, "CVE-2024-6714": {"epss_score": 0.00087, "epss_percentile": 0.25616}, "CVE-2024-6715": {"epss_score": 0.00235, "epss_percentile": 0.46338}, "CVE-2024-6717": {"epss_score": 0.00454, "epss_percentile": 0.63245}, "CVE-2024-6718": {"epss_score": 0.00022, "epss_percentile": 0.05165}, "CVE-2024-6719": {"epss_score": 0.00022, "epss_percentile": 0.04978}, "CVE-2024-6720": {"epss_score": 0.00056, "epss_percentile": 0.17825}, "CVE-2024-6722": {"epss_score": 0.00132, "epss_percentile": 0.33519}, "CVE-2024-6723": {"epss_score": 0.00157, "epss_percentile": 0.3713}, "CVE-2024-6724": {"epss_score": 0.00179, "epss_percentile": 0.39803}, "CVE-2024-6725": {"epss_score": 0.00176, "epss_percentile": 0.39476}, "CVE-2024-6726": {"epss_score": 0.09831, "epss_percentile": 0.92723}, "CVE-2024-6727": {"epss_score": 0.00109, "epss_percentile": 0.29957}, "CVE-2024-6728": {"epss_score": 0.00068, "epss_percentile": 0.21305}, "CVE-2024-6729": {"epss_score": 0.0008, "epss_percentile": 0.24072}, "CVE-2024-6730": {"epss_score": 0.00036, "epss_percentile": 0.10232}, "CVE-2024-6731": {"epss_score": 0.00081, "epss_percentile": 0.24367}, "CVE-2024-6732": {"epss_score": 0.00081, "epss_percentile": 0.24367}, "CVE-2024-6733": {"epss_score": 0.00056, "epss_percentile": 0.17693}, "CVE-2024-6734": {"epss_score": 0.00056, "epss_percentile": 0.17693}, "CVE-2024-6735": {"epss_score": 0.00056, "epss_percentile": 0.17693}, "CVE-2024-6736": {"epss_score": 0.00056, "epss_percentile": 0.17693}, "CVE-2024-6737": {"epss_score": 0.00353, "epss_percentile": 0.57164}, "CVE-2024-6738": {"epss_score": 0.00126, "epss_percentile": 0.32689}, "CVE-2024-6739": {"epss_score": 0.00119, "epss_percentile": 0.31628}, "CVE-2024-6740": {"epss_score": 0.00379, "epss_percentile": 0.58863}, "CVE-2024-6741": {"epss_score": 0.00175, "epss_percentile": 0.39263}, "CVE-2024-6742": {"epss_score": 0.00167, "epss_percentile": 0.38336}, "CVE-2024-6743": {"epss_score": 0.01056, "epss_percentile": 0.77128}, "CVE-2024-6744": {"epss_score": 0.02459, "epss_percentile": 0.84819}, "CVE-2024-6745": {"epss_score": 0.00067, "epss_percentile": 0.21038}, "CVE-2024-6746": {"epss_score": 0.82258, "epss_percentile": 0.99183}, "CVE-2024-6747": {"epss_score": 0.0031, "epss_percentile": 0.538}, "CVE-2024-6748": {"epss_score": 0.03636, "epss_percentile": 0.87482}, "CVE-2024-6749": {"epss_score": 0.0004, "epss_percentile": 0.12108}, "CVE-2024-6750": {"epss_score": 0.00337, "epss_percentile": 0.56025}, "CVE-2024-6751": {"epss_score": 0.0012, "epss_percentile": 0.31761}, "CVE-2024-6752": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-6753": {"epss_score": 0.07259, "epss_percentile": 0.91354}, "CVE-2024-6754": {"epss_score": 0.00133, "epss_percentile": 0.33717}, "CVE-2024-6755": {"epss_score": 0.00323, "epss_percentile": 0.54906}, "CVE-2024-6756": {"epss_score": 0.11928, "epss_percentile": 0.93518}, "CVE-2024-6757": {"epss_score": 0.00246, "epss_percentile": 0.47776}, "CVE-2024-6758": {"epss_score": 0.0012, "epss_percentile": 0.31738}, "CVE-2024-6759": {"epss_score": 0.00272, "epss_percentile": 0.50399}, "CVE-2024-6760": {"epss_score": 0.00249, "epss_percentile": 0.48036}, "CVE-2024-6762": {"epss_score": 0.00612, "epss_percentile": 0.69219}, "CVE-2024-6763": {"epss_score": 0.01022, "epss_percentile": 0.76761}, "CVE-2024-6766": {"epss_score": 0.00249, "epss_percentile": 0.48073}, "CVE-2024-6767": {"epss_score": 0.00324, "epss_percentile": 0.54959}, "CVE-2024-6768": {"epss_score": 0.24007, "epss_percentile": 0.95842}, "CVE-2024-6769": {"epss_score": 0.13656, "epss_percentile": 0.94027}, "CVE-2024-6770": {"epss_score": 0.02225, "epss_percentile": 0.84068}, "CVE-2024-6772": {"epss_score": 0.00603, "epss_percentile": 0.68904}, "CVE-2024-6773": {"epss_score": 0.00608, "epss_percentile": 0.69087}, "CVE-2024-6774": {"epss_score": 0.00702, "epss_percentile": 0.71519}, "CVE-2024-6775": {"epss_score": 0.00409, "epss_percentile": 0.60697}, "CVE-2024-6776": {"epss_score": 0.00702, "epss_percentile": 0.71519}, "CVE-2024-6777": {"epss_score": 0.00079, "epss_percentile": 0.23893}, "CVE-2024-6778": {"epss_score": 0.12757, "epss_percentile": 0.93765}, "CVE-2024-6779": {"epss_score": 0.00702, "epss_percentile": 0.71519}, "CVE-2024-6780": {"epss_score": 0.00061, "epss_percentile": 0.19424}, "CVE-2024-6781": {"epss_score": 0.93719, "epss_percentile": 0.99836}, "CVE-2024-6782": {"epss_score": 0.93791, "epss_percentile": 0.99847}, "CVE-2024-6783": {"epss_score": 0.00142, "epss_percentile": 0.35076}, "CVE-2024-6784": {"epss_score": 0.00192, "epss_percentile": 0.41355}, "CVE-2024-6785": {"epss_score": 0.00056, "epss_percentile": 0.17819}, "CVE-2024-6786": {"epss_score": 0.00399, "epss_percentile": 0.60129}, "CVE-2024-6787": {"epss_score": 0.00373, "epss_percentile": 0.58504}, "CVE-2024-6788": {"epss_score": 0.04544, "epss_percentile": 0.88831}, "CVE-2024-6789": {"epss_score": 0.00518, "epss_percentile": 0.66136}, "CVE-2024-6790": {"epss_score": 0.00016, "epss_percentile": 0.02681}, "CVE-2024-6791": {"epss_score": 0.02263, "epss_percentile": 0.84192}, "CVE-2024-6792": {"epss_score": 0.00132, "epss_percentile": 0.33519}, "CVE-2024-6793": {"epss_score": 0.05715, "epss_percentile": 0.90146}, "CVE-2024-6794": {"epss_score": 0.07963, "epss_percentile": 0.91792}, "CVE-2024-6795": {"epss_score": 0.00183, "epss_percentile": 0.40334}, "CVE-2024-6796": {"epss_score": 0.00403, "epss_percentile": 0.60343}, "CVE-2024-6797": {"epss_score": 0.00044, "epss_percentile": 0.13629}, "CVE-2024-6798": {"epss_score": 0.00048, "epss_percentile": 0.15095}, "CVE-2024-6799": {"epss_score": 0.00253, "epss_percentile": 0.48443}, "CVE-2024-6800": {"epss_score": 0.02463, "epss_percentile": 0.8483}, "CVE-2024-6801": {"epss_score": 0.0015, "epss_percentile": 0.36066}, "CVE-2024-6802": {"epss_score": 0.00465, "epss_percentile": 0.63775}, "CVE-2024-6803": {"epss_score": 0.001, "epss_percentile": 0.28546}, "CVE-2024-6804": {"epss_score": 0.00223, "epss_percentile": 0.44853}, "CVE-2024-6805": {"epss_score": 0.0154, "epss_percentile": 0.8094}, "CVE-2024-6806": {"epss_score": 0.09768, "epss_percentile": 0.92694}, "CVE-2024-6807": {"epss_score": 0.0024, "epss_percentile": 0.47226}, "CVE-2024-6808": {"epss_score": 0.001, "epss_percentile": 0.28538}, "CVE-2024-6809": {"epss_score": 0.00289, "epss_percentile": 0.51983}, "CVE-2024-6810": {"epss_score": 0.00191, "epss_percentile": 0.41274}, "CVE-2024-6811": {"epss_score": 0.00393, "epss_percentile": 0.59707}, "CVE-2024-6812": {"epss_score": 0.00393, "epss_percentile": 0.59707}, "CVE-2024-6813": {"epss_score": 0.07681, "epss_percentile": 0.91622}, "CVE-2024-6814": {"epss_score": 0.07681, "epss_percentile": 0.91622}, "CVE-2024-6815": {"epss_score": 0.0188, "epss_percentile": 0.82683}, "CVE-2024-6816": {"epss_score": 0.02728, "epss_percentile": 0.85533}, "CVE-2024-6817": {"epss_score": 0.0101, "epss_percentile": 0.76591}, "CVE-2024-6818": {"epss_score": 0.01462, "epss_percentile": 0.80434}, "CVE-2024-6819": {"epss_score": 0.01462, "epss_percentile": 0.80434}, "CVE-2024-6820": {"epss_score": 0.01291, "epss_percentile": 0.79227}, "CVE-2024-6821": {"epss_score": 0.01291, "epss_percentile": 0.79227}, "CVE-2024-6822": {"epss_score": 0.01291, "epss_percentile": 0.79227}, "CVE-2024-6823": {"epss_score": 0.1184, "epss_percentile": 0.93491}, "CVE-2024-6824": {"epss_score": 0.00147, "epss_percentile": 0.35743}, "CVE-2024-6825": {"epss_score": 0.01277, "epss_percentile": 0.79115}, "CVE-2024-6826": {"epss_score": 0.00136, "epss_percentile": 0.34084}, "CVE-2024-6827": {"epss_score": 0.00061, "epss_percentile": 0.1939}, "CVE-2024-6828": {"epss_score": 0.03414, "epss_percentile": 0.87091}, "CVE-2024-6829": {"epss_score": 0.00118, "epss_percentile": 0.31435}, "CVE-2024-6830": {"epss_score": 0.00217, "epss_percentile": 0.4426}, "CVE-2024-6831": {"epss_score": 0.0005, "epss_percentile": 0.15895}, "CVE-2024-6833": {"epss_score": 0.00027, "epss_percentile": 0.06838}, "CVE-2024-6834": {"epss_score": 0.00464, "epss_percentile": 0.63709}, "CVE-2024-6835": {"epss_score": 0.00523, "epss_percentile": 0.66285}, "CVE-2024-6836": {"epss_score": 0.00201, "epss_percentile": 0.42304}, "CVE-2024-6838": {"epss_score": 0.00109, "epss_percentile": 0.29963}, "CVE-2024-6839": {"epss_score": 0.00243, "epss_percentile": 0.47511}, "CVE-2024-6840": {"epss_score": 0.0008, "epss_percentile": 0.24036}, "CVE-2024-6841": {"epss_score": 0.00029, "epss_percentile": 0.07739}, "CVE-2024-6842": {"epss_score": 0.41811, "epss_percentile": 0.97296}, "CVE-2024-6843": {"epss_score": 0.01384, "epss_percentile": 0.79901}, "CVE-2024-6844": {"epss_score": 0.00061, "epss_percentile": 0.19504}, "CVE-2024-6845": {"epss_score": 0.17508, "epss_percentile": 0.94858}, "CVE-2024-6846": {"epss_score": 0.06941, "epss_percentile": 0.91132}, "CVE-2024-6847": {"epss_score": 0.01593, "epss_percentile": 0.81228}, "CVE-2024-6848": {"epss_score": 0.0293, "epss_percentile": 0.86014}, "CVE-2024-6849": {"epss_score": 0.00174, "epss_percentile": 0.39164}, "CVE-2024-6850": {"epss_score": 0.00179, "epss_percentile": 0.39838}, "CVE-2024-6851": {"epss_score": 0.00347, "epss_percentile": 0.56753}, "CVE-2024-6852": {"epss_score": 0.00146, "epss_percentile": 0.35615}, "CVE-2024-6853": {"epss_score": 0.00186, "epss_percentile": 0.40669}, "CVE-2024-6854": {"epss_score": 0.00208, "epss_percentile": 0.43214}, "CVE-2024-6855": {"epss_score": 0.00146, "epss_percentile": 0.35615}, "CVE-2024-6856": {"epss_score": 0.00146, "epss_percentile": 0.35615}, "CVE-2024-6857": {"epss_score": 0.00035, "epss_percentile": 0.10056}, "CVE-2024-6859": {"epss_score": 0.00136, "epss_percentile": 0.34151}, "CVE-2024-6860": {"epss_score": 0.00035, "epss_percentile": 0.10056}, "CVE-2024-6861": {"epss_score": 0.00292, "epss_percentile": 0.52215}, "CVE-2024-6862": {"epss_score": 0.00245, "epss_percentile": 0.47626}, "CVE-2024-6863": {"epss_score": 0.00086, "epss_percentile": 0.25339}, "CVE-2024-6864": {"epss_score": 0.00166, "epss_percentile": 0.38173}, "CVE-2024-6866": {"epss_score": 0.00137, "epss_percentile": 0.34289}, "CVE-2024-6867": {"epss_score": 0.00135, "epss_percentile": 0.34055}, "CVE-2024-6868": {"epss_score": 0.00467, "epss_percentile": 0.63863}, "CVE-2024-6869": {"epss_score": 0.00376, "epss_percentile": 0.58665}, "CVE-2024-6870": {"epss_score": 0.00187, "epss_percentile": 0.40768}, "CVE-2024-6871": {"epss_score": 0.00028, "epss_percentile": 0.07309}, "CVE-2024-6872": {"epss_score": 0.00147, "epss_percentile": 0.35724}, "CVE-2024-6873": {"epss_score": 0.02221, "epss_percentile": 0.8405}, "CVE-2024-6874": {"epss_score": 0.0099, "epss_percentile": 0.76381}, "CVE-2024-6875": {"epss_score": 0.001, "epss_percentile": 0.28552}, "CVE-2024-6876": {"epss_score": 0.00139, "epss_percentile": 0.34593}, "CVE-2024-6877": {"epss_score": 0.00178, "epss_percentile": 0.39674}, "CVE-2024-6878": {"epss_score": 0.00201, "epss_percentile": 0.42304}, "CVE-2024-6879": {"epss_score": 0.00234, "epss_percentile": 0.46088}, "CVE-2024-6880": {"epss_score": 0.00294, "epss_percentile": 0.52384}, "CVE-2024-6881": {"epss_score": 0.002, "epss_percentile": 0.4224}, "CVE-2024-6883": {"epss_score": 0.00188, "epss_percentile": 0.40889}, "CVE-2024-6884": {"epss_score": 0.00273, "epss_percentile": 0.50448}, "CVE-2024-6885": {"epss_score": 0.10842, "epss_percentile": 0.93131}, "CVE-2024-6886": {"epss_score": 0.16577, "epss_percentile": 0.94697}, "CVE-2024-6887": {"epss_score": 0.00168, "epss_percentile": 0.3842}, "CVE-2024-6888": {"epss_score": 0.0027, "epss_percentile": 0.50197}, "CVE-2024-6889": {"epss_score": 0.00217, "epss_percentile": 0.44239}, "CVE-2024-6890": {"epss_score": 0.00114, "epss_percentile": 0.30798}, "CVE-2024-6891": {"epss_score": 0.00156, "epss_percentile": 0.36899}, "CVE-2024-6892": {"epss_score": 0.04411, "epss_percentile": 0.8866}, "CVE-2024-6893": {"epss_score": 0.92287, "epss_percentile": 0.99705}, "CVE-2024-6894": {"epss_score": 0.00265, "epss_percentile": 0.49788}, "CVE-2024-6895": {"epss_score": 0.00061, "epss_percentile": 0.19358}, "CVE-2024-6896": {"epss_score": 0.00245, "epss_percentile": 0.47643}, "CVE-2024-6897": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-6898": {"epss_score": 0.00095, "epss_percentile": 0.27237}, "CVE-2024-6899": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6900": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6901": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6902": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6903": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6904": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6905": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6906": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6907": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-6908": {"epss_score": 0.00051, "epss_percentile": 0.16173}, "CVE-2024-6910": {"epss_score": 0.00199, "epss_percentile": 0.42137}, "CVE-2024-6911": {"epss_score": 0.93904, "epss_percentile": 0.99866}, "CVE-2024-6912": {"epss_score": 0.00207, "epss_percentile": 0.43129}, "CVE-2024-6913": {"epss_score": 0.00291, "epss_percentile": 0.5219}, "CVE-2024-6914": {"epss_score": 0.001, "epss_percentile": 0.28552}, "CVE-2024-6915": {"epss_score": 0.0008, "epss_percentile": 0.242}, "CVE-2024-6916": {"epss_score": 0.00053, "epss_percentile": 0.16831}, "CVE-2024-6917": {"epss_score": 0.01627, "epss_percentile": 0.81432}, "CVE-2024-6918": {"epss_score": 0.00119, "epss_percentile": 0.31572}, "CVE-2024-6919": {"epss_score": 0.00097, "epss_percentile": 0.27619}, "CVE-2024-6920": {"epss_score": 0.00124, "epss_percentile": 0.32448}, "CVE-2024-6921": {"epss_score": 0.00055, "epss_percentile": 0.17472}, "CVE-2024-6922": {"epss_score": 0.35587, "epss_percentile": 0.96921}, "CVE-2024-6923": {"epss_score": 0.00238, "epss_percentile": 0.46772}, "CVE-2024-6924": {"epss_score": 0.72513, "epss_percentile": 0.98714}, "CVE-2024-6925": {"epss_score": 0.0017, "epss_percentile": 0.38743}, "CVE-2024-6926": {"epss_score": 0.65223, "epss_percentile": 0.98408}, "CVE-2024-6927": {"epss_score": 0.0015, "epss_percentile": 0.36095}, "CVE-2024-6928": {"epss_score": 0.7264, "epss_percentile": 0.9872}, "CVE-2024-6929": {"epss_score": 0.00288, "epss_percentile": 0.51929}, "CVE-2024-6930": {"epss_score": 0.00346, "epss_percentile": 0.56675}, "CVE-2024-6931": {"epss_score": 0.27238, "epss_percentile": 0.96223}, "CVE-2024-6932": {"epss_score": 0.00126, "epss_percentile": 0.32746}, "CVE-2024-6933": {"epss_score": 0.00035, "epss_percentile": 0.09964}, "CVE-2024-6934": {"epss_score": 0.00054, "epss_percentile": 0.17232}, "CVE-2024-6935": {"epss_score": 0.001, "epss_percentile": 0.28499}, "CVE-2024-6936": {"epss_score": 0.00109, "epss_percentile": 0.29966}, "CVE-2024-6937": {"epss_score": 0.00126, "epss_percentile": 0.32645}, "CVE-2024-6938": {"epss_score": 0.007, "epss_percentile": 0.7147}, "CVE-2024-6939": {"epss_score": 0.00165, "epss_percentile": 0.38081}, "CVE-2024-6940": {"epss_score": 0.00089, "epss_percentile": 0.258}, "CVE-2024-6941": {"epss_score": 0.00129, "epss_percentile": 0.33097}, "CVE-2024-6942": {"epss_score": 0.00129, "epss_percentile": 0.33097}, "CVE-2024-6943": {"epss_score": 0.00051, "epss_percentile": 0.16242}, "CVE-2024-6944": {"epss_score": 0.24933, "epss_percentile": 0.95969}, "CVE-2024-6945": {"epss_score": 0.00061, "epss_percentile": 0.19381}, "CVE-2024-6946": {"epss_score": 0.00039, "epss_percentile": 0.11428}, "CVE-2024-6947": {"epss_score": 0.00039, "epss_percentile": 0.11428}, "CVE-2024-6948": {"epss_score": 0.00142, "epss_percentile": 0.3505}, "CVE-2024-6949": {"epss_score": 0.00246, "epss_percentile": 0.47761}, "CVE-2024-6950": {"epss_score": 0.00132, "epss_percentile": 0.33543}, "CVE-2024-6951": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6952": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6953": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-6954": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-6955": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-6956": {"epss_score": 0.0011, "epss_percentile": 0.30081}, "CVE-2024-6957": {"epss_score": 0.00097, "epss_percentile": 0.27594}, "CVE-2024-6958": {"epss_score": 0.00145, "epss_percentile": 0.35429}, "CVE-2024-6959": {"epss_score": 0.0013, "epss_percentile": 0.33229}, "CVE-2024-6960": {"epss_score": 0.0022, "epss_percentile": 0.44565}, "CVE-2024-6961": {"epss_score": 0.00079, "epss_percentile": 0.23973}, "CVE-2024-6962": {"epss_score": 0.00247, "epss_percentile": 0.47846}, "CVE-2024-6963": {"epss_score": 0.00779, "epss_percentile": 0.73148}, "CVE-2024-6964": {"epss_score": 0.00247, "epss_percentile": 0.47846}, "CVE-2024-6965": {"epss_score": 0.00578, "epss_percentile": 0.6818}, "CVE-2024-6966": {"epss_score": 0.00458, "epss_percentile": 0.634}, "CVE-2024-6967": {"epss_score": 0.00061, "epss_percentile": 0.19421}, "CVE-2024-6968": {"epss_score": 0.00084, "epss_percentile": 0.2491}, "CVE-2024-6969": {"epss_score": 0.00084, "epss_percentile": 0.2491}, "CVE-2024-6970": {"epss_score": 0.00096, "epss_percentile": 0.27245}, "CVE-2024-6971": {"epss_score": 0.00027, "epss_percentile": 0.07077}, "CVE-2024-6972": {"epss_score": 0.0023, "epss_percentile": 0.45685}, "CVE-2024-6973": {"epss_score": 0.01533, "epss_percentile": 0.80898}, "CVE-2024-6974": {"epss_score": 0.00077, "epss_percentile": 0.2354}, "CVE-2024-6975": {"epss_score": 0.00096, "epss_percentile": 0.27395}, "CVE-2024-6977": {"epss_score": 0.00025, "epss_percentile": 0.06235}, "CVE-2024-6978": {"epss_score": 0.00114, "epss_percentile": 0.30807}, "CVE-2024-6979": {"epss_score": 0.00065, "epss_percentile": 0.20435}, "CVE-2024-6980": {"epss_score": 0.00333, "epss_percentile": 0.55651}, "CVE-2024-6981": {"epss_score": 0.00141, "epss_percentile": 0.34815}, "CVE-2024-6982": {"epss_score": 0.00135, "epss_percentile": 0.34053}, "CVE-2024-6983": {"epss_score": 0.04875, "epss_percentile": 0.89238}, "CVE-2024-6984": {"epss_score": 0.00166, "epss_percentile": 0.38237}, "CVE-2024-6985": {"epss_score": 0.00039, "epss_percentile": 0.11724}, "CVE-2024-6986": {"epss_score": 0.00044, "epss_percentile": 0.13446}, "CVE-2024-6987": {"epss_score": 0.00135, "epss_percentile": 0.34033}, "CVE-2024-6988": {"epss_score": 0.00297, "epss_percentile": 0.52766}, "CVE-2024-6989": {"epss_score": 0.00297, "epss_percentile": 0.52766}, "CVE-2024-6990": {"epss_score": 0.00341, "epss_percentile": 0.56297}, "CVE-2024-6991": {"epss_score": 0.00297, "epss_percentile": 0.52766}, "CVE-2024-6994": {"epss_score": 0.00454, "epss_percentile": 0.63267}, "CVE-2024-6995": {"epss_score": 0.00136, "epss_percentile": 0.34149}, "CVE-2024-6996": {"epss_score": 0.00082, "epss_percentile": 0.2442}, "CVE-2024-6997": {"epss_score": 0.00279, "epss_percentile": 0.50929}, "CVE-2024-6998": {"epss_score": 0.00279, "epss_percentile": 0.50929}, "CVE-2024-6999": {"epss_score": 0.00085, "epss_percentile": 0.2507}, "CVE-2024-7000": {"epss_score": 0.00279, "epss_percentile": 0.50929}, "CVE-2024-7001": {"epss_score": 0.00085, "epss_percentile": 0.2507}, "CVE-2024-7003": {"epss_score": 0.00059, "epss_percentile": 0.18797}, "CVE-2024-7004": {"epss_score": 0.00036, "epss_percentile": 0.10233}, "CVE-2024-7005": {"epss_score": 0.00034, "epss_percentile": 0.09573}, "CVE-2024-7006": {"epss_score": 0.00121, "epss_percentile": 0.31991}, "CVE-2024-7007": {"epss_score": 0.00076, "epss_percentile": 0.231}, "CVE-2024-7008": {"epss_score": 0.1358, "epss_percentile": 0.94001}, "CVE-2024-7009": {"epss_score": 0.10659, "epss_percentile": 0.9306}, "CVE-2024-7010": {"epss_score": 0.00194, "epss_percentile": 0.41544}, "CVE-2024-7011": {"epss_score": 0.00125, "epss_percentile": 0.3251}, "CVE-2024-7012": {"epss_score": 0.00158, "epss_percentile": 0.37169}, "CVE-2024-7013": {"epss_score": 0.00146, "epss_percentile": 0.35571}, "CVE-2024-7014": {"epss_score": 0.25688, "epss_percentile": 0.96056}, "CVE-2024-7015": {"epss_score": 0.00106, "epss_percentile": 0.29527}, "CVE-2024-7016": {"epss_score": 0.00061, "epss_percentile": 0.19423}, "CVE-2024-7017": {"epss_score": 0.00103, "epss_percentile": 0.29091}, "CVE-2024-7018": {"epss_score": 0.00578, "epss_percentile": 0.68207}, "CVE-2024-7019": {"epss_score": 0.00236, "epss_percentile": 0.46431}, "CVE-2024-7020": {"epss_score": 0.00236, "epss_percentile": 0.46431}, "CVE-2024-7021": {"epss_score": 0.00064, "epss_percentile": 0.20147}, "CVE-2024-7022": {"epss_score": 0.00202, "epss_percentile": 0.42438}, "CVE-2024-7023": {"epss_score": 0.00655, "epss_percentile": 0.70421}, "CVE-2024-7024": {"epss_score": 0.00261, "epss_percentile": 0.49268}, "CVE-2024-7025": {"epss_score": 0.00105, "epss_percentile": 0.29282}, "CVE-2024-7026": {"epss_score": 0.00053, "epss_percentile": 0.16726}, "CVE-2024-7027": {"epss_score": 0.00195, "epss_percentile": 0.4163}, "CVE-2024-7029": {"epss_score": 0.9303, "epss_percentile": 0.99769}, "CVE-2024-7030": {"epss_score": 0.00227, "epss_percentile": 0.45402}, "CVE-2024-7031": {"epss_score": 0.00735, "epss_percentile": 0.72297}, "CVE-2024-7032": {"epss_score": 0.00397, "epss_percentile": 0.60018}, "CVE-2024-7033": {"epss_score": 0.01099, "epss_percentile": 0.77549}, "CVE-2024-7034": {"epss_score": 0.02835, "epss_percentile": 0.85789}, "CVE-2024-7035": {"epss_score": 0.00038, "epss_percentile": 0.11237}, "CVE-2024-7036": {"epss_score": 0.00438, "epss_percentile": 0.6254}, "CVE-2024-7037": {"epss_score": 0.02278, "epss_percentile": 0.84233}, "CVE-2024-7038": {"epss_score": 0.00155, "epss_percentile": 0.3682}, "CVE-2024-7039": {"epss_score": 0.00083, "epss_percentile": 0.24759}, "CVE-2024-7040": {"epss_score": 0.00095, "epss_percentile": 0.27154}, "CVE-2024-7041": {"epss_score": 0.00145, "epss_percentile": 0.35458}, "CVE-2024-7042": {"epss_score": 0.00061, "epss_percentile": 0.19321}, "CVE-2024-7043": {"epss_score": 0.00072, "epss_percentile": 0.22458}, "CVE-2024-7044": {"epss_score": 0.00236, "epss_percentile": 0.46382}, "CVE-2024-7045": {"epss_score": 0.00057, "epss_percentile": 0.18084}, "CVE-2024-7046": {"epss_score": 0.00057, "epss_percentile": 0.18084}, "CVE-2024-7047": {"epss_score": 0.00103, "epss_percentile": 0.289}, "CVE-2024-7048": {"epss_score": 0.00118, "epss_percentile": 0.31415}, "CVE-2024-7049": {"epss_score": 0.00047, "epss_percentile": 0.14649}, "CVE-2024-7050": {"epss_score": 0.00155, "epss_percentile": 0.36846}, "CVE-2024-7052": {"epss_score": 0.00087, "epss_percentile": 0.25514}, "CVE-2024-7053": {"epss_score": 0.00159, "epss_percentile": 0.37344}, "CVE-2024-7054": {"epss_score": 0.00148, "epss_percentile": 0.35843}, "CVE-2024-7055": {"epss_score": 0.00133, "epss_percentile": 0.33665}, "CVE-2024-7056": {"epss_score": 0.0014, "epss_percentile": 0.34758}, "CVE-2024-7057": {"epss_score": 0.00096, "epss_percentile": 0.27389}, "CVE-2024-7058": {"epss_score": 0.00044, "epss_percentile": 0.13392}, "CVE-2024-7059": {"epss_score": 0.00262, "epss_percentile": 0.49389}, "CVE-2024-7060": {"epss_score": 0.00063, "epss_percentile": 0.20061}, "CVE-2024-7061": {"epss_score": 0.00132, "epss_percentile": 0.33528}, "CVE-2024-7062": {"epss_score": 0.00036, "epss_percentile": 0.1039}, "CVE-2024-7063": {"epss_score": 0.00306, "epss_percentile": 0.53465}, "CVE-2024-7064": {"epss_score": 0.0031, "epss_percentile": 0.5374}, "CVE-2024-7065": {"epss_score": 0.00108, "epss_percentile": 0.29793}, "CVE-2024-7066": {"epss_score": 0.02113, "epss_percentile": 0.8365}, "CVE-2024-7067": {"epss_score": 0.00156, "epss_percentile": 0.37014}, "CVE-2024-7068": {"epss_score": 0.0014, "epss_percentile": 0.34794}, "CVE-2024-7069": {"epss_score": 0.00213, "epss_percentile": 0.43845}, "CVE-2024-7071": {"epss_score": 0.00117, "epss_percentile": 0.31291}, "CVE-2024-7073": {"epss_score": 0.00077, "epss_percentile": 0.23409}, "CVE-2024-7074": {"epss_score": 0.00156, "epss_percentile": 0.36886}, "CVE-2024-7076": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2024-7077": {"epss_score": 0.00258, "epss_percentile": 0.48978}, "CVE-2024-7078": {"epss_score": 0.0015, "epss_percentile": 0.36133}, "CVE-2024-7079": {"epss_score": 0.00447, "epss_percentile": 0.62987}, "CVE-2024-7080": {"epss_score": 0.00665, "epss_percentile": 0.70656}, "CVE-2024-7081": {"epss_score": 0.001, "epss_percentile": 0.28546}, "CVE-2024-7082": {"epss_score": 0.00244, "epss_percentile": 0.47601}, "CVE-2024-7084": {"epss_score": 0.00186, "epss_percentile": 0.40633}, "CVE-2024-7085": {"epss_score": 0.00302, "epss_percentile": 0.53096}, "CVE-2024-7090": {"epss_score": 0.01905, "epss_percentile": 0.82795}, "CVE-2024-7091": {"epss_score": 0.00076, "epss_percentile": 0.23242}, "CVE-2024-7092": {"epss_score": 0.00232, "epss_percentile": 0.45907}, "CVE-2024-7093": {"epss_score": 0.00174, "epss_percentile": 0.39223}, "CVE-2024-7094": {"epss_score": 0.71963, "epss_percentile": 0.98689}, "CVE-2024-7095": {"epss_score": 0.00106, "epss_percentile": 0.2947}, "CVE-2024-7096": {"epss_score": 0.00038, "epss_percentile": 0.11313}, "CVE-2024-7097": {"epss_score": 0.13504, "epss_percentile": 0.93983}, "CVE-2024-7098": {"epss_score": 0.00161, "epss_percentile": 0.37614}, "CVE-2024-7099": {"epss_score": 0.00102, "epss_percentile": 0.28895}, "CVE-2024-7100": {"epss_score": 0.002, "epss_percentile": 0.42223}, "CVE-2024-7101": {"epss_score": 0.00208, "epss_percentile": 0.43242}, "CVE-2024-7102": {"epss_score": 0.00058, "epss_percentile": 0.18425}, "CVE-2024-7103": {"epss_score": 0.00025, "epss_percentile": 0.06292}, "CVE-2024-7104": {"epss_score": 0.00187, "epss_percentile": 0.40715}, "CVE-2024-7105": {"epss_score": 0.00147, "epss_percentile": 0.35749}, "CVE-2024-7106": {"epss_score": 0.00158, "epss_percentile": 0.37192}, "CVE-2024-7107": {"epss_score": 0.00067, "epss_percentile": 0.21154}, "CVE-2024-7108": {"epss_score": 0.00074, "epss_percentile": 0.2285}, "CVE-2024-7110": {"epss_score": 0.00074, "epss_percentile": 0.22744}, "CVE-2024-7112": {"epss_score": 0.00429, "epss_percentile": 0.61981}, "CVE-2024-7113": {"epss_score": 0.0014, "epss_percentile": 0.34756}, "CVE-2024-7114": {"epss_score": 0.00078, "epss_percentile": 0.23593}, "CVE-2024-7115": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-7116": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-7117": {"epss_score": 0.00057, "epss_percentile": 0.1802}, "CVE-2024-7118": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-7119": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-7120": {"epss_score": 0.90968, "epss_percentile": 0.99612}, "CVE-2024-7122": {"epss_score": 0.0035, "epss_percentile": 0.56938}, "CVE-2024-7124": {"epss_score": 0.01013, "epss_percentile": 0.76638}, "CVE-2024-7125": {"epss_score": 0.00022, "epss_percentile": 0.05152}, "CVE-2024-7127": {"epss_score": 0.00346, "epss_percentile": 0.56649}, "CVE-2024-7128": {"epss_score": 0.00384, "epss_percentile": 0.59174}, "CVE-2024-7129": {"epss_score": 0.12104, "epss_percentile": 0.93568}, "CVE-2024-7130": {"epss_score": 0.00069, "epss_percentile": 0.21526}, "CVE-2024-7132": {"epss_score": 0.00132, "epss_percentile": 0.33519}, "CVE-2024-7133": {"epss_score": 0.00238, "epss_percentile": 0.46748}, "CVE-2024-7134": {"epss_score": 0.01905, "epss_percentile": 0.82795}, "CVE-2024-7135": {"epss_score": 0.47957, "epss_percentile": 0.97611}, "CVE-2024-7136": {"epss_score": 0.00218, "epss_percentile": 0.44439}, "CVE-2024-7137": {"epss_score": 0.00056, "epss_percentile": 0.17898}, "CVE-2024-7138": {"epss_score": 0.00024, "epss_percentile": 0.0597}, "CVE-2024-7139": {"epss_score": 0.00024, "epss_percentile": 0.0597}, "CVE-2024-7141": {"epss_score": 0.00058, "epss_percentile": 0.18303}, "CVE-2024-7142": {"epss_score": 0.00041, "epss_percentile": 0.12248}, "CVE-2024-7143": {"epss_score": 0.00031, "epss_percentile": 0.08431}, "CVE-2024-7144": {"epss_score": 0.0022, "epss_percentile": 0.44538}, "CVE-2024-7145": {"epss_score": 0.00569, "epss_percentile": 0.67921}, "CVE-2024-7146": {"epss_score": 0.0037, "epss_percentile": 0.58283}, "CVE-2024-7147": {"epss_score": 0.00239, "epss_percentile": 0.46876}, "CVE-2024-7149": {"epss_score": 0.00526, "epss_percentile": 0.66434}, "CVE-2024-7150": {"epss_score": 0.01159, "epss_percentile": 0.78124}, "CVE-2024-7151": {"epss_score": 0.00252, "epss_percentile": 0.48342}, "CVE-2024-7152": {"epss_score": 0.00252, "epss_percentile": 0.48342}, "CVE-2024-7153": {"epss_score": 0.00144, "epss_percentile": 0.35324}, "CVE-2024-7154": {"epss_score": 0.0009, "epss_percentile": 0.26032}, "CVE-2024-7155": {"epss_score": 0.00067, "epss_percentile": 0.21088}, "CVE-2024-7156": {"epss_score": 0.08657, "epss_percentile": 0.92175}, "CVE-2024-7157": {"epss_score": 0.07575, "epss_percentile": 0.91548}, "CVE-2024-7158": {"epss_score": 0.02678, "epss_percentile": 0.85408}, "CVE-2024-7159": {"epss_score": 0.00109, "epss_percentile": 0.29927}, "CVE-2024-7160": {"epss_score": 0.03587, "epss_percentile": 0.87394}, "CVE-2024-7161": {"epss_score": 0.00145, "epss_percentile": 0.3543}, "CVE-2024-7162": {"epss_score": 0.00126, "epss_percentile": 0.32667}, "CVE-2024-7163": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-7164": {"epss_score": 0.00097, "epss_percentile": 0.27594}, "CVE-2024-7165": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-7166": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-7167": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-7168": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-7169": {"epss_score": 0.00125, "epss_percentile": 0.326}, "CVE-2024-7170": {"epss_score": 0.00116, "epss_percentile": 0.31039}, "CVE-2024-7171": {"epss_score": 0.03587, "epss_percentile": 0.87394}, "CVE-2024-7172": {"epss_score": 0.00296, "epss_percentile": 0.52531}, "CVE-2024-7173": {"epss_score": 0.00296, "epss_percentile": 0.52531}, "CVE-2024-7174": {"epss_score": 0.0034, "epss_percentile": 0.56217}, "CVE-2024-7175": {"epss_score": 0.0331, "epss_percentile": 0.86885}, "CVE-2024-7176": {"epss_score": 0.00322, "epss_percentile": 0.54744}, "CVE-2024-7177": {"epss_score": 0.00312, "epss_percentile": 0.53988}, "CVE-2024-7178": {"epss_score": 0.00296, "epss_percentile": 0.52531}, "CVE-2024-7179": {"epss_score": 0.00322, "epss_percentile": 0.54744}, "CVE-2024-7180": {"epss_score": 0.00296, "epss_percentile": 0.52531}, "CVE-2024-7181": {"epss_score": 0.0331, "epss_percentile": 0.86885}, "CVE-2024-7182": {"epss_score": 0.00296, "epss_percentile": 0.52531}, "CVE-2024-7183": {"epss_score": 0.00322, "epss_percentile": 0.54744}, "CVE-2024-7184": {"epss_score": 0.00296, "epss_percentile": 0.52531}, "CVE-2024-7185": {"epss_score": 0.00378, "epss_percentile": 0.58793}, "CVE-2024-7186": {"epss_score": 0.00296, "epss_percentile": 0.52531}, "CVE-2024-7187": {"epss_score": 0.00322, "epss_percentile": 0.54744}, "CVE-2024-7188": {"epss_score": 0.86104, "epss_percentile": 0.99367}, "CVE-2024-7189": {"epss_score": 0.00145, "epss_percentile": 0.35429}, "CVE-2024-7190": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-7191": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-7192": {"epss_score": 0.00145, "epss_percentile": 0.35429}, "CVE-2024-7193": {"epss_score": 0.00076, "epss_percentile": 0.2326}, "CVE-2024-7194": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-7195": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-7196": {"epss_score": 0.00095, "epss_percentile": 0.27237}, "CVE-2024-7197": {"epss_score": 0.00197, "epss_percentile": 0.41966}, "CVE-2024-7198": {"epss_score": 0.00197, "epss_percentile": 0.41966}, "CVE-2024-7199": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-7200": {"epss_score": 0.00241, "epss_percentile": 0.47238}, "CVE-2024-7201": {"epss_score": 0.00789, "epss_percentile": 0.73354}, "CVE-2024-7202": {"epss_score": 0.00789, "epss_percentile": 0.73354}, "CVE-2024-7203": {"epss_score": 0.00788, "epss_percentile": 0.73345}, "CVE-2024-7204": {"epss_score": 0.00321, "epss_percentile": 0.54681}, "CVE-2024-7205": {"epss_score": 0.00193, "epss_percentile": 0.41398}, "CVE-2024-7206": {"epss_score": 0.00025, "epss_percentile": 0.06221}, "CVE-2024-7208": {"epss_score": 0.00075, "epss_percentile": 0.23009}, "CVE-2024-7209": {"epss_score": 0.00182, "epss_percentile": 0.40191}, "CVE-2024-7211": {"epss_score": 0.00104, "epss_percentile": 0.29169}, "CVE-2024-7212": {"epss_score": 0.00765, "epss_percentile": 0.7291}, "CVE-2024-7213": {"epss_score": 0.00717, "epss_percentile": 0.71872}, "CVE-2024-7214": {"epss_score": 0.04708, "epss_percentile": 0.89035}, "CVE-2024-7215": {"epss_score": 0.01744, "epss_percentile": 0.82062}, "CVE-2024-7216": {"epss_score": 0.00304, "epss_percentile": 0.53265}, "CVE-2024-7217": {"epss_score": 0.0045, "epss_percentile": 0.63072}, "CVE-2024-7218": {"epss_score": 0.00091, "epss_percentile": 0.2624}, "CVE-2024-7219": {"epss_score": 0.00093, "epss_percentile": 0.26701}, "CVE-2024-7220": {"epss_score": 0.00197, "epss_percentile": 0.41966}, "CVE-2024-7221": {"epss_score": 0.00106, "epss_percentile": 0.29409}, "CVE-2024-7222": {"epss_score": 0.00093, "epss_percentile": 0.26709}, "CVE-2024-7223": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-7224": {"epss_score": 0.00211, "epss_percentile": 0.4363}, "CVE-2024-7225": {"epss_score": 0.00096, "epss_percentile": 0.27267}, "CVE-2024-7226": {"epss_score": 0.00128, "epss_percentile": 0.3307}, "CVE-2024-7227": {"epss_score": 0.00064, "epss_percentile": 0.20407}, "CVE-2024-7228": {"epss_score": 0.0003, "epss_percentile": 0.08167}, "CVE-2024-7229": {"epss_score": 0.00068, "epss_percentile": 0.21226}, "CVE-2024-7230": {"epss_score": 0.00068, "epss_percentile": 0.21226}, "CVE-2024-7231": {"epss_score": 0.00068, "epss_percentile": 0.21226}, "CVE-2024-7232": {"epss_score": 0.00068, "epss_percentile": 0.21226}, "CVE-2024-7233": {"epss_score": 0.00068, "epss_percentile": 0.21226}, "CVE-2024-7234": {"epss_score": 0.00064, "epss_percentile": 0.20407}, "CVE-2024-7235": {"epss_score": 0.00088, "epss_percentile": 0.25758}, "CVE-2024-7236": {"epss_score": 0.00087, "epss_percentile": 0.25465}, "CVE-2024-7237": {"epss_score": 0.00068, "epss_percentile": 0.21226}, "CVE-2024-7238": {"epss_score": 0.00064, "epss_percentile": 0.20407}, "CVE-2024-7239": {"epss_score": 0.00031, "epss_percentile": 0.08476}, "CVE-2024-7240": {"epss_score": 0.0007, "epss_percentile": 0.21833}, "CVE-2024-7241": {"epss_score": 0.00057, "epss_percentile": 0.1805}, "CVE-2024-7242": {"epss_score": 0.00027, "epss_percentile": 0.06744}, "CVE-2024-7243": {"epss_score": 0.00048, "epss_percentile": 0.15072}, "CVE-2024-7244": {"epss_score": 0.00034, "epss_percentile": 0.09654}, "CVE-2024-7245": {"epss_score": 0.00024, "epss_percentile": 0.06025}, "CVE-2024-7246": {"epss_score": 0.00038, "epss_percentile": 0.11155}, "CVE-2024-7247": {"epss_score": 0.00264, "epss_percentile": 0.49577}, "CVE-2024-7248": {"epss_score": 0.00104, "epss_percentile": 0.29169}, "CVE-2024-7249": {"epss_score": 0.001, "epss_percentile": 0.28539}, "CVE-2024-7250": {"epss_score": 0.00119, "epss_percentile": 0.31587}, "CVE-2024-7251": {"epss_score": 0.00124, "epss_percentile": 0.32391}, "CVE-2024-7252": {"epss_score": 0.00119, "epss_percentile": 0.31587}, "CVE-2024-7253": {"epss_score": 0.00056, "epss_percentile": 0.17786}, "CVE-2024-7254": {"epss_score": 0.00085, "epss_percentile": 0.25115}, "CVE-2024-7255": {"epss_score": 0.00616, "epss_percentile": 0.69322}, "CVE-2024-7256": {"epss_score": 0.0072, "epss_percentile": 0.71963}, "CVE-2024-7257": {"epss_score": 0.0799, "epss_percentile": 0.91809}, "CVE-2024-7258": {"epss_score": 0.08017, "epss_percentile": 0.91832}, "CVE-2024-7259": {"epss_score": 0.0013, "epss_percentile": 0.33264}, "CVE-2024-7260": {"epss_score": 0.0044, "epss_percentile": 0.62649}, "CVE-2024-7261": {"epss_score": 0.23162, "epss_percentile": 0.95745}, "CVE-2024-7262": {"epss_score": 0.17276, "epss_percentile": 0.94815}, "CVE-2024-7263": {"epss_score": 0.00133, "epss_percentile": 0.33745}, "CVE-2024-7264": {"epss_score": 0.01024, "epss_percentile": 0.76777}, "CVE-2024-7265": {"epss_score": 0.00291, "epss_percentile": 0.52209}, "CVE-2024-7266": {"epss_score": 0.00257, "epss_percentile": 0.48911}, "CVE-2024-7267": {"epss_score": 0.00356, "epss_percentile": 0.57368}, "CVE-2024-7269": {"epss_score": 0.00133, "epss_percentile": 0.33671}, "CVE-2024-7272": {"epss_score": 0.00204, "epss_percentile": 0.42609}, "CVE-2024-7273": {"epss_score": 0.00097, "epss_percentile": 0.27453}, "CVE-2024-7274": {"epss_score": 0.00074, "epss_percentile": 0.22677}, "CVE-2024-7275": {"epss_score": 0.00074, "epss_percentile": 0.22677}, "CVE-2024-7276": {"epss_score": 0.00063, "epss_percentile": 0.19853}, "CVE-2024-7277": {"epss_score": 0.00056, "epss_percentile": 0.17694}, "CVE-2024-7278": {"epss_score": 0.00118, "epss_percentile": 0.31509}, "CVE-2024-7279": {"epss_score": 0.00181, "epss_percentile": 0.40118}, "CVE-2024-7280": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-7281": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-7282": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-7283": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-7284": {"epss_score": 0.00177, "epss_percentile": 0.39571}, "CVE-2024-7285": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-7286": {"epss_score": 0.00097, "epss_percentile": 0.27594}, "CVE-2024-7287": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-7288": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-7289": {"epss_score": 0.00057, "epss_percentile": 0.1802}, "CVE-2024-7290": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-7291": {"epss_score": 0.00212, "epss_percentile": 0.4381}, "CVE-2024-7292": {"epss_score": 0.00138, "epss_percentile": 0.34519}, "CVE-2024-7293": {"epss_score": 0.00138, "epss_percentile": 0.34519}, "CVE-2024-7294": {"epss_score": 0.00303, "epss_percentile": 0.53191}, "CVE-2024-7295": {"epss_score": 0.00117, "epss_percentile": 0.31373}, "CVE-2024-7296": {"epss_score": 0.00021, "epss_percentile": 0.04885}, "CVE-2024-7297": {"epss_score": 0.00262, "epss_percentile": 0.49352}, "CVE-2024-7299": {"epss_score": 0.0018, "epss_percentile": 0.39924}, "CVE-2024-7300": {"epss_score": 0.00166, "epss_percentile": 0.38156}, "CVE-2024-7301": {"epss_score": 0.03281, "epss_percentile": 0.86816}, "CVE-2024-7302": {"epss_score": 0.00245, "epss_percentile": 0.47684}, "CVE-2024-7303": {"epss_score": 0.00234, "epss_percentile": 0.4615}, "CVE-2024-7304": {"epss_score": 0.00197, "epss_percentile": 0.41827}, "CVE-2024-7305": {"epss_score": 0.00526, "epss_percentile": 0.66422}, "CVE-2024-7306": {"epss_score": 0.00057, "epss_percentile": 0.1802}, "CVE-2024-7307": {"epss_score": 0.00057, "epss_percentile": 0.1802}, "CVE-2024-7308": {"epss_score": 0.00057, "epss_percentile": 0.1802}, "CVE-2024-7309": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-7310": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-7311": {"epss_score": 0.00106, "epss_percentile": 0.29442}, "CVE-2024-7312": {"epss_score": 0.00066, "epss_percentile": 0.20708}, "CVE-2024-7313": {"epss_score": 0.58074, "epss_percentile": 0.98098}, "CVE-2024-7314": {"epss_score": 0.70102, "epss_percentile": 0.98616}, "CVE-2024-7315": {"epss_score": 0.00118, "epss_percentile": 0.3141}, "CVE-2024-7316": {"epss_score": 0.00497, "epss_percentile": 0.65177}, "CVE-2024-7317": {"epss_score": 0.00268, "epss_percentile": 0.50086}, "CVE-2024-7318": {"epss_score": 0.01027, "epss_percentile": 0.76809}, "CVE-2024-7319": {"epss_score": 0.00507, "epss_percentile": 0.65678}, "CVE-2024-7320": {"epss_score": 0.00245, "epss_percentile": 0.47641}, "CVE-2024-7321": {"epss_score": 0.00209, "epss_percentile": 0.43406}, "CVE-2024-7322": {"epss_score": 0.00108, "epss_percentile": 0.29853}, "CVE-2024-7323": {"epss_score": 0.00359, "epss_percentile": 0.57546}, "CVE-2024-7324": {"epss_score": 0.0006, "epss_percentile": 0.19217}, "CVE-2024-7325": {"epss_score": 0.00061, "epss_percentile": 0.1937}, "CVE-2024-7326": {"epss_score": 0.00062, "epss_percentile": 0.19702}, "CVE-2024-7327": {"epss_score": 0.00095, "epss_percentile": 0.27156}, "CVE-2024-7328": {"epss_score": 0.00165, "epss_percentile": 0.38076}, "CVE-2024-7329": {"epss_score": 0.00141, "epss_percentile": 0.34953}, "CVE-2024-7330": {"epss_score": 0.00057, "epss_percentile": 0.18063}, "CVE-2024-7331": {"epss_score": 0.00265, "epss_percentile": 0.49805}, "CVE-2024-7332": {"epss_score": 0.92114, "epss_percentile": 0.99692}, "CVE-2024-7333": {"epss_score": 0.00435, "epss_percentile": 0.62349}, "CVE-2024-7334": {"epss_score": 0.00288, "epss_percentile": 0.51952}, "CVE-2024-7335": {"epss_score": 0.00265, "epss_percentile": 0.49805}, "CVE-2024-7336": {"epss_score": 0.00378, "epss_percentile": 0.58828}, "CVE-2024-7337": {"epss_score": 0.00265, "epss_percentile": 0.49805}, "CVE-2024-7338": {"epss_score": 0.00265, "epss_percentile": 0.49805}, "CVE-2024-7339": {"epss_score": 0.89489, "epss_percentile": 0.99529}, "CVE-2024-7340": {"epss_score": 0.87701, "epss_percentile": 0.9944}, "CVE-2024-7341": {"epss_score": 0.01149, "epss_percentile": 0.78018}, "CVE-2024-7342": {"epss_score": 0.00085, "epss_percentile": 0.25177}, "CVE-2024-7343": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-7344": {"epss_score": 0.00136, "epss_percentile": 0.34092}, "CVE-2024-7345": {"epss_score": 0.00042, "epss_percentile": 0.12666}, "CVE-2024-7346": {"epss_score": 0.00027, "epss_percentile": 0.07115}, "CVE-2024-7347": {"epss_score": 0.00197, "epss_percentile": 0.41826}, "CVE-2024-7348": {"epss_score": 0.00809, "epss_percentile": 0.73705}, "CVE-2024-7349": {"epss_score": 0.00711, "epss_percentile": 0.71731}, "CVE-2024-7350": {"epss_score": 0.00597, "epss_percentile": 0.68743}, "CVE-2024-7351": {"epss_score": 0.02146, "epss_percentile": 0.83766}, "CVE-2024-7352": {"epss_score": 0.00393, "epss_percentile": 0.59707}, "CVE-2024-7353": {"epss_score": 0.00391, "epss_percentile": 0.59629}, "CVE-2024-7354": {"epss_score": 0.00745, "epss_percentile": 0.72529}, "CVE-2024-7355": {"epss_score": 0.00361, "epss_percentile": 0.57714}, "CVE-2024-7356": {"epss_score": 0.00233, "epss_percentile": 0.46074}, "CVE-2024-7357": {"epss_score": 0.01071, "epss_percentile": 0.77266}, "CVE-2024-7358": {"epss_score": 0.00056, "epss_percentile": 0.17669}, "CVE-2024-7359": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-7360": {"epss_score": 0.00115, "epss_percentile": 0.31006}, "CVE-2024-7361": {"epss_score": 0.00097, "epss_percentile": 0.27611}, "CVE-2024-7362": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-7363": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-7364": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-7365": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-7366": {"epss_score": 0.00097, "epss_percentile": 0.27594}, "CVE-2024-7367": {"epss_score": 0.00115, "epss_percentile": 0.31006}, "CVE-2024-7368": {"epss_score": 0.00212, "epss_percentile": 0.43822}, "CVE-2024-7369": {"epss_score": 0.0012, "epss_percentile": 0.31711}, "CVE-2024-7370": {"epss_score": 0.00147, "epss_percentile": 0.35749}, "CVE-2024-7371": {"epss_score": 0.00178, "epss_percentile": 0.39697}, "CVE-2024-7372": {"epss_score": 0.00194, "epss_percentile": 0.41535}, "CVE-2024-7373": {"epss_score": 0.00194, "epss_percentile": 0.41535}, "CVE-2024-7374": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-7375": {"epss_score": 0.00106, "epss_percentile": 0.29409}, "CVE-2024-7376": {"epss_score": 0.00106, "epss_percentile": 0.29409}, "CVE-2024-7377": {"epss_score": 0.00197, "epss_percentile": 0.41966}, "CVE-2024-7378": {"epss_score": 0.00197, "epss_percentile": 0.41966}, "CVE-2024-7380": {"epss_score": 0.00135, "epss_percentile": 0.34033}, "CVE-2024-7381": {"epss_score": 0.00758, "epss_percentile": 0.7277}, "CVE-2024-7382": {"epss_score": 0.00263, "epss_percentile": 0.49488}, "CVE-2024-7383": {"epss_score": 0.00302, "epss_percentile": 0.53089}, "CVE-2024-7384": {"epss_score": 0.0856, "epss_percentile": 0.92126}, "CVE-2024-7385": {"epss_score": 0.10051, "epss_percentile": 0.92828}, "CVE-2024-7386": {"epss_score": 0.00115, "epss_percentile": 0.31028}, "CVE-2024-7387": {"epss_score": 0.00731, "epss_percentile": 0.72168}, "CVE-2024-7388": {"epss_score": 0.00311, "epss_percentile": 0.53934}, "CVE-2024-7389": {"epss_score": 0.02841, "epss_percentile": 0.85805}, "CVE-2024-7390": {"epss_score": 0.00456, "epss_percentile": 0.63338}, "CVE-2024-7391": {"epss_score": 0.00031, "epss_percentile": 0.08507}, "CVE-2024-7392": {"epss_score": 0.00036, "epss_percentile": 0.10389}, "CVE-2024-7394": {"epss_score": 0.03921, "epss_percentile": 0.87953}, "CVE-2024-7395": {"epss_score": 0.00078, "epss_percentile": 0.23597}, "CVE-2024-7396": {"epss_score": 0.00106, "epss_percentile": 0.29497}, "CVE-2024-7397": {"epss_score": 0.00764, "epss_percentile": 0.72901}, "CVE-2024-7398": {"epss_score": 0.00141, "epss_percentile": 0.34805}, "CVE-2024-7399": {"epss_score": 0.67522, "epss_percentile": 0.98511}, "CVE-2024-7400": {"epss_score": 0.00087, "epss_percentile": 0.2559}, "CVE-2024-7401": {"epss_score": 0.00619, "epss_percentile": 0.69434}, "CVE-2024-7402": {"epss_score": 0.00016, "epss_percentile": 0.0273}, "CVE-2024-7404": {"epss_score": 0.00118, "epss_percentile": 0.31396}, "CVE-2024-7407": {"epss_score": 0.00082, "epss_percentile": 0.2445}, "CVE-2024-7408": {"epss_score": 0.00051, "epss_percentile": 0.16029}, "CVE-2024-7409": {"epss_score": 0.01706, "epss_percentile": 0.81854}, "CVE-2024-7410": {"epss_score": 0.00263, "epss_percentile": 0.49488}, "CVE-2024-7411": {"epss_score": 0.00866, "epss_percentile": 0.74631}, "CVE-2024-7412": {"epss_score": 0.00263, "epss_percentile": 0.49488}, "CVE-2024-7413": {"epss_score": 0.00263, "epss_percentile": 0.49488}, "CVE-2024-7414": {"epss_score": 0.00305, "epss_percentile": 0.53394}, "CVE-2024-7415": {"epss_score": 0.00453, "epss_percentile": 0.6324}, "CVE-2024-7416": {"epss_score": 0.00243, "epss_percentile": 0.47512}, "CVE-2024-7417": {"epss_score": 0.00347, "epss_percentile": 0.56766}, "CVE-2024-7418": {"epss_score": 0.00285, "epss_percentile": 0.51529}, "CVE-2024-7419": {"epss_score": 0.00454, "epss_percentile": 0.63245}, "CVE-2024-7420": {"epss_score": 0.00112, "epss_percentile": 0.3046}, "CVE-2024-7421": {"epss_score": 0.00073, "epss_percentile": 0.22567}, "CVE-2024-7422": {"epss_score": 0.00126, "epss_percentile": 0.32627}, "CVE-2024-7423": {"epss_score": 0.00532, "epss_percentile": 0.66702}, "CVE-2024-7424": {"epss_score": 0.00149, "epss_percentile": 0.35975}, "CVE-2024-7425": {"epss_score": 0.00246, "epss_percentile": 0.47747}, "CVE-2024-7426": {"epss_score": 0.00357, "epss_percentile": 0.57436}, "CVE-2024-7427": {"epss_score": 0.00158, "epss_percentile": 0.37147}, "CVE-2024-7428": {"epss_score": 0.00105, "epss_percentile": 0.2938}, "CVE-2024-7429": {"epss_score": 0.00205, "epss_percentile": 0.42683}, "CVE-2024-7432": {"epss_score": 0.00652, "epss_percentile": 0.70306}, "CVE-2024-7433": {"epss_score": 0.00596, "epss_percentile": 0.68721}, "CVE-2024-7434": {"epss_score": 0.00829, "epss_percentile": 0.74008}, "CVE-2024-7435": {"epss_score": 0.01257, "epss_percentile": 0.78949}, "CVE-2024-7436": {"epss_score": 0.02371, "epss_percentile": 0.84527}, "CVE-2024-7437": {"epss_score": 0.00098, "epss_percentile": 0.27813}, "CVE-2024-7438": {"epss_score": 0.00121, "epss_percentile": 0.31937}, "CVE-2024-7439": {"epss_score": 0.00272, "epss_percentile": 0.5035}, "CVE-2024-7440": {"epss_score": 0.01493, "epss_percentile": 0.80639}, "CVE-2024-7441": {"epss_score": 0.07342, "epss_percentile": 0.9142}, "CVE-2024-7442": {"epss_score": 0.00566, "epss_percentile": 0.67825}, "CVE-2024-7443": {"epss_score": 0.00566, "epss_percentile": 0.67825}, "CVE-2024-7444": {"epss_score": 0.00106, "epss_percentile": 0.29442}, "CVE-2024-7445": {"epss_score": 0.00047, "epss_percentile": 0.14875}, "CVE-2024-7446": {"epss_score": 0.00047, "epss_percentile": 0.14875}, "CVE-2024-7447": {"epss_score": 0.00242, "epss_percentile": 0.47334}, "CVE-2024-7448": {"epss_score": 0.00856, "epss_percentile": 0.74487}, "CVE-2024-7449": {"epss_score": 0.00068, "epss_percentile": 0.21294}, "CVE-2024-7450": {"epss_score": 0.00158, "epss_percentile": 0.37174}, "CVE-2024-7451": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-7452": {"epss_score": 0.00106, "epss_percentile": 0.29456}, "CVE-2024-7453": {"epss_score": 0.00117, "epss_percentile": 0.31241}, "CVE-2024-7454": {"epss_score": 0.00087, "epss_percentile": 0.25599}, "CVE-2024-7455": {"epss_score": 0.00087, "epss_percentile": 0.25599}, "CVE-2024-7456": {"epss_score": 0.21254, "epss_percentile": 0.95488}, "CVE-2024-7457": {"epss_score": 0.00025, "epss_percentile": 0.06156}, "CVE-2024-7458": {"epss_score": 0.00513, "epss_percentile": 0.65917}, "CVE-2024-7459": {"epss_score": 0.00115, "epss_percentile": 0.31006}, "CVE-2024-7460": {"epss_score": 0.00115, "epss_percentile": 0.31006}, "CVE-2024-7461": {"epss_score": 0.00095, "epss_percentile": 0.27237}, "CVE-2024-7462": {"epss_score": 0.00296, "epss_percentile": 0.52531}, "CVE-2024-7463": {"epss_score": 0.15101, "epss_percentile": 0.94362}, "CVE-2024-7464": {"epss_score": 0.449, "epss_percentile": 0.97459}, "CVE-2024-7465": {"epss_score": 0.00322, "epss_percentile": 0.54744}, "CVE-2024-7466": {"epss_score": 0.0014, "epss_percentile": 0.34691}, "CVE-2024-7467": {"epss_score": 0.01884, "epss_percentile": 0.82705}, "CVE-2024-7468": {"epss_score": 0.01722, "epss_percentile": 0.81938}, "CVE-2024-7469": {"epss_score": 0.02188, "epss_percentile": 0.83928}, "CVE-2024-7470": {"epss_score": 0.01722, "epss_percentile": 0.81938}, "CVE-2024-7472": {"epss_score": 0.00137, "epss_percentile": 0.34231}, "CVE-2024-7473": {"epss_score": 0.0015, "epss_percentile": 0.36088}, "CVE-2024-7474": {"epss_score": 0.00158, "epss_percentile": 0.37299}, "CVE-2024-7475": {"epss_score": 0.00176, "epss_percentile": 0.39473}, "CVE-2024-7476": {"epss_score": 0.00052, "epss_percentile": 0.16341}, "CVE-2024-7477": {"epss_score": 0.0014, "epss_percentile": 0.34708}, "CVE-2024-7479": {"epss_score": 0.05618, "epss_percentile": 0.90057}, "CVE-2024-7480": {"epss_score": 0.00074, "epss_percentile": 0.22772}, "CVE-2024-7481": {"epss_score": 0.0039, "epss_percentile": 0.59524}, "CVE-2024-7484": {"epss_score": 0.11977, "epss_percentile": 0.93532}, "CVE-2024-7485": {"epss_score": 0.03033, "epss_percentile": 0.86253}, "CVE-2024-7486": {"epss_score": 0.01133, "epss_percentile": 0.77878}, "CVE-2024-7487": {"epss_score": 0.00047, "epss_percentile": 0.14625}, "CVE-2024-7488": {"epss_score": 0.00116, "epss_percentile": 0.3119}, "CVE-2024-7489": {"epss_score": 0.00229, "epss_percentile": 0.45594}, "CVE-2024-7490": {"epss_score": 0.05491, "epss_percentile": 0.8993}, "CVE-2024-7491": {"epss_score": 0.0014, "epss_percentile": 0.34733}, "CVE-2024-7492": {"epss_score": 0.00469, "epss_percentile": 0.63952}, "CVE-2024-7493": {"epss_score": 0.00754, "epss_percentile": 0.72691}, "CVE-2024-7494": {"epss_score": 0.00181, "epss_percentile": 0.40132}, "CVE-2024-7495": {"epss_score": 0.0027, "epss_percentile": 0.50257}, "CVE-2024-7496": {"epss_score": 0.00216, "epss_percentile": 0.44237}, "CVE-2024-7497": {"epss_score": 0.00294, "epss_percentile": 0.52407}, "CVE-2024-7498": {"epss_score": 0.00197, "epss_percentile": 0.41956}, "CVE-2024-7499": {"epss_score": 0.00197, "epss_percentile": 0.41966}, "CVE-2024-7500": {"epss_score": 0.00294, "epss_percentile": 0.52407}, "CVE-2024-7501": {"epss_score": 0.00168, "epss_percentile": 0.38496}, "CVE-2024-7502": {"epss_score": 0.0018, "epss_percentile": 0.39916}, "CVE-2024-7503": {"epss_score": 0.01324, "epss_percentile": 0.79464}, "CVE-2024-7505": {"epss_score": 0.00197, "epss_percentile": 0.41956}, "CVE-2024-7506": {"epss_score": 0.00132, "epss_percentile": 0.33572}, "CVE-2024-7507": {"epss_score": 0.00065, "epss_percentile": 0.20454}, "CVE-2024-7508": {"epss_score": 0.00514, "epss_percentile": 0.65965}, "CVE-2024-7509": {"epss_score": 0.00514, "epss_percentile": 0.65965}, "CVE-2024-7510": {"epss_score": 0.00486, "epss_percentile": 0.64757}, "CVE-2024-7511": {"epss_score": 0.00098, "epss_percentile": 0.27782}, "CVE-2024-7512": {"epss_score": 0.00962, "epss_percentile": 0.75989}, "CVE-2024-7513": {"epss_score": 0.00043, "epss_percentile": 0.13224}, "CVE-2024-7514": {"epss_score": 0.40875, "epss_percentile": 0.97242}, "CVE-2024-7515": {"epss_score": 0.00152, "epss_percentile": 0.3638}, "CVE-2024-7516": {"epss_score": 0.00161, "epss_percentile": 0.37549}, "CVE-2024-7517": {"epss_score": 0.00105, "epss_percentile": 0.29267}, "CVE-2024-7518": {"epss_score": 0.00288, "epss_percentile": 0.51903}, "CVE-2024-7519": {"epss_score": 0.00307, "epss_percentile": 0.53567}, "CVE-2024-7520": {"epss_score": 0.00593, "epss_percentile": 0.68639}, "CVE-2024-7521": {"epss_score": 0.00261, "epss_percentile": 0.49251}, "CVE-2024-7522": {"epss_score": 0.00247, "epss_percentile": 0.47818}, "CVE-2024-7523": {"epss_score": 0.00113, "epss_percentile": 0.30675}, "CVE-2024-7524": {"epss_score": 0.00292, "epss_percentile": 0.52251}, "CVE-2024-7525": {"epss_score": 0.00126, "epss_percentile": 0.32669}, "CVE-2024-7526": {"epss_score": 0.0025, "epss_percentile": 0.48242}, "CVE-2024-7527": {"epss_score": 0.00199, "epss_percentile": 0.42161}, "CVE-2024-7528": {"epss_score": 0.00238, "epss_percentile": 0.4676}, "CVE-2024-7529": {"epss_score": 0.00105, "epss_percentile": 0.29279}, "CVE-2024-7530": {"epss_score": 0.00376, "epss_percentile": 0.58678}, "CVE-2024-7531": {"epss_score": 0.00067, "epss_percentile": 0.21153}, "CVE-2024-7532": {"epss_score": 0.00231, "epss_percentile": 0.45771}, "CVE-2024-7533": {"epss_score": 0.00274, "epss_percentile": 0.50516}, "CVE-2024-7534": {"epss_score": 0.00418, "epss_percentile": 0.61343}, "CVE-2024-7535": {"epss_score": 0.00297, "epss_percentile": 0.52766}, "CVE-2024-7536": {"epss_score": 0.0029, "epss_percentile": 0.52115}, "CVE-2024-7537": {"epss_score": 0.00138, "epss_percentile": 0.34388}, "CVE-2024-7538": {"epss_score": 0.00141, "epss_percentile": 0.34864}, "CVE-2024-7539": {"epss_score": 0.00142, "epss_percentile": 0.35003}, "CVE-2024-7540": {"epss_score": 0.0015, "epss_percentile": 0.36093}, "CVE-2024-7541": {"epss_score": 0.0015, "epss_percentile": 0.36093}, "CVE-2024-7542": {"epss_score": 0.0015, "epss_percentile": 0.36093}, "CVE-2024-7543": {"epss_score": 0.00094, "epss_percentile": 0.27037}, "CVE-2024-7544": {"epss_score": 0.0014, "epss_percentile": 0.3469}, "CVE-2024-7545": {"epss_score": 0.00165, "epss_percentile": 0.3808}, "CVE-2024-7546": {"epss_score": 0.0014, "epss_percentile": 0.3469}, "CVE-2024-7547": {"epss_score": 0.0014, "epss_percentile": 0.3469}, "CVE-2024-7548": {"epss_score": 0.00613, "epss_percentile": 0.69261}, "CVE-2024-7550": {"epss_score": 0.00201, "epss_percentile": 0.42391}, "CVE-2024-7551": {"epss_score": 0.0058, "epss_percentile": 0.68254}, "CVE-2024-7552": {"epss_score": 0.00152, "epss_percentile": 0.36453}, "CVE-2024-7553": {"epss_score": 0.0024, "epss_percentile": 0.47197}, "CVE-2024-7554": {"epss_score": 0.00048, "epss_percentile": 0.1519}, "CVE-2024-7556": {"epss_score": 0.00026, "epss_percentile": 0.06556}, "CVE-2024-7557": {"epss_score": 0.001, "epss_percentile": 0.28458}, "CVE-2024-7558": {"epss_score": 0.0013, "epss_percentile": 0.33276}, "CVE-2024-7559": {"epss_score": 0.09842, "epss_percentile": 0.9273}, "CVE-2024-7560": {"epss_score": 0.01088, "epss_percentile": 0.77436}, "CVE-2024-7561": {"epss_score": 0.01291, "epss_percentile": 0.7923}, "CVE-2024-7562": {"epss_score": 0.00022, "epss_percentile": 0.05005}, "CVE-2024-7564": {"epss_score": 0.00691, "epss_percentile": 0.71267}, "CVE-2024-7565": {"epss_score": 0.01949, "epss_percentile": 0.83012}, "CVE-2024-7567": {"epss_score": 0.0025, "epss_percentile": 0.4811}, "CVE-2024-7568": {"epss_score": 0.00432, "epss_percentile": 0.62117}, "CVE-2024-7569": {"epss_score": 0.07469, "epss_percentile": 0.91491}, "CVE-2024-7570": {"epss_score": 0.01829, "epss_percentile": 0.82441}, "CVE-2024-7571": {"epss_score": 0.0016, "epss_percentile": 0.37512}, "CVE-2024-7572": {"epss_score": 0.00106, "epss_percentile": 0.29443}, "CVE-2024-7573": {"epss_score": 0.00273, "epss_percentile": 0.50476}, "CVE-2024-7574": {"epss_score": 0.00168, "epss_percentile": 0.38496}, "CVE-2024-7575": {"epss_score": 0.00366, "epss_percentile": 0.5806}, "CVE-2024-7576": {"epss_score": 0.00442, "epss_percentile": 0.62697}, "CVE-2024-7577": {"epss_score": 0.00046, "epss_percentile": 0.14188}, "CVE-2024-7578": {"epss_score": 0.00256, "epss_percentile": 0.48767}, "CVE-2024-7579": {"epss_score": 0.04664, "epss_percentile": 0.88978}, "CVE-2024-7580": {"epss_score": 0.062, "epss_percentile": 0.90559}, "CVE-2024-7581": {"epss_score": 0.00611, "epss_percentile": 0.6918}, "CVE-2024-7582": {"epss_score": 0.00611, "epss_percentile": 0.6918}, "CVE-2024-7583": {"epss_score": 0.00611, "epss_percentile": 0.6918}, "CVE-2024-7584": {"epss_score": 0.00269, "epss_percentile": 0.50107}, "CVE-2024-7585": {"epss_score": 0.00312, "epss_percentile": 0.53967}, "CVE-2024-7586": {"epss_score": 0.00013, "epss_percentile": 0.01673}, "CVE-2024-7587": {"epss_score": 0.00162, "epss_percentile": 0.37616}, "CVE-2024-7588": {"epss_score": 0.00243, "epss_percentile": 0.47431}, "CVE-2024-7589": {"epss_score": 0.21961, "epss_percentile": 0.95578}, "CVE-2024-7590": {"epss_score": 0.00152, "epss_percentile": 0.36372}, "CVE-2024-7591": {"epss_score": 0.29739, "epss_percentile": 0.96469}, "CVE-2024-7592": {"epss_score": 0.00796, "epss_percentile": 0.73483}, "CVE-2024-7593": {"epss_score": 0.94436, "epss_percentile": 0.99985}, "CVE-2024-7594": {"epss_score": 0.00539, "epss_percentile": 0.66964}, "CVE-2024-7595": {"epss_score": 0.029, "epss_percentile": 0.85952}, "CVE-2024-7596": {"epss_score": 0.00081, "epss_percentile": 0.24268}, "CVE-2024-7598": {"epss_score": 0.00018, "epss_percentile": 0.03542}, "CVE-2024-7599": {"epss_score": 0.0016, "epss_percentile": 0.37492}, "CVE-2024-7600": {"epss_score": 0.03634, "epss_percentile": 0.87478}, "CVE-2024-7601": {"epss_score": 0.01365, "epss_percentile": 0.79775}, "CVE-2024-7602": {"epss_score": 0.00577, "epss_percentile": 0.68153}, "CVE-2024-7603": {"epss_score": 0.02393, "epss_percentile": 0.84608}, "CVE-2024-7604": {"epss_score": 7e-05, "epss_percentile": 0.00401}, "CVE-2024-7605": {"epss_score": 0.00131, "epss_percentile": 0.33373}, "CVE-2024-7606": {"epss_score": 0.00204, "epss_percentile": 0.42659}, "CVE-2024-7607": {"epss_score": 0.00566, "epss_percentile": 0.67815}, "CVE-2024-7608": {"epss_score": 0.00935, "epss_percentile": 0.75667}, "CVE-2024-7609": {"epss_score": 0.00194, "epss_percentile": 0.41585}, "CVE-2024-7610": {"epss_score": 0.00251, "epss_percentile": 0.48313}, "CVE-2024-7611": {"epss_score": 0.00137, "epss_percentile": 0.34326}, "CVE-2024-7612": {"epss_score": 0.00176, "epss_percentile": 0.39402}, "CVE-2024-7613": {"epss_score": 0.00439, "epss_percentile": 0.6258}, "CVE-2024-7614": {"epss_score": 0.00439, "epss_percentile": 0.6258}, "CVE-2024-7615": {"epss_score": 0.00439, "epss_percentile": 0.6258}, "CVE-2024-7616": {"epss_score": 0.00656, "epss_percentile": 0.70437}, "CVE-2024-7617": {"epss_score": 0.00937, "epss_percentile": 0.75694}, "CVE-2024-7618": {"epss_score": 0.00238, "epss_percentile": 0.46746}, "CVE-2024-7620": {"epss_score": 0.06779, "epss_percentile": 0.9102}, "CVE-2024-7621": {"epss_score": 0.0022, "epss_percentile": 0.44571}, "CVE-2024-7622": {"epss_score": 0.00147, "epss_percentile": 0.35743}, "CVE-2024-7624": {"epss_score": 0.00574, "epss_percentile": 0.68095}, "CVE-2024-7625": {"epss_score": 0.00296, "epss_percentile": 0.52588}, "CVE-2024-7626": {"epss_score": 0.02847, "epss_percentile": 0.85823}, "CVE-2024-7627": {"epss_score": 0.23131, "epss_percentile": 0.95738}, "CVE-2024-7628": {"epss_score": 0.01288, "epss_percentile": 0.79207}, "CVE-2024-7629": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2024-7630": {"epss_score": 0.01595, "epss_percentile": 0.81234}, "CVE-2024-7631": {"epss_score": 0.00141, "epss_percentile": 0.34921}, "CVE-2024-7634": {"epss_score": 0.0062, "epss_percentile": 0.69456}, "CVE-2024-7635": {"epss_score": 0.00145, "epss_percentile": 0.35452}, "CVE-2024-7636": {"epss_score": 0.00098, "epss_percentile": 0.27635}, "CVE-2024-7637": {"epss_score": 0.00139, "epss_percentile": 0.34635}, "CVE-2024-7638": {"epss_score": 0.00114, "epss_percentile": 0.30823}, "CVE-2024-7639": {"epss_score": 0.00155, "epss_percentile": 0.36818}, "CVE-2024-7640": {"epss_score": 0.0006, "epss_percentile": 0.19081}, "CVE-2024-7641": {"epss_score": 0.00053, "epss_percentile": 0.16789}, "CVE-2024-7642": {"epss_score": 0.00155, "epss_percentile": 0.36818}, "CVE-2024-7643": {"epss_score": 0.0015, "epss_percentile": 0.36079}, "CVE-2024-7644": {"epss_score": 0.00154, "epss_percentile": 0.36693}, "CVE-2024-7645": {"epss_score": 0.00065, "epss_percentile": 0.20549}, "CVE-2024-7646": {"epss_score": 0.25756, "epss_percentile": 0.96066}, "CVE-2024-7647": {"epss_score": 0.0031, "epss_percentile": 0.53779}, "CVE-2024-7648": {"epss_score": 0.00139, "epss_percentile": 0.34569}, "CVE-2024-7649": {"epss_score": 0.00772, "epss_percentile": 0.73033}, "CVE-2024-7650": {"epss_score": 0.00041, "epss_percentile": 0.12393}, "CVE-2024-7651": {"epss_score": 0.00149, "epss_percentile": 0.36036}, "CVE-2024-7652": {"epss_score": 0.00277, "epss_percentile": 0.50785}, "CVE-2024-7654": {"epss_score": 0.00101, "epss_percentile": 0.28673}, "CVE-2024-7655": {"epss_score": 0.00238, "epss_percentile": 0.46746}, "CVE-2024-7656": {"epss_score": 0.01207, "epss_percentile": 0.78524}, "CVE-2024-7657": {"epss_score": 0.00296, "epss_percentile": 0.52538}, "CVE-2024-7658": {"epss_score": 0.00323, "epss_percentile": 0.54865}, "CVE-2024-7659": {"epss_score": 0.00223, "epss_percentile": 0.44879}, "CVE-2024-7660": {"epss_score": 0.00138, "epss_percentile": 0.34384}, "CVE-2024-7661": {"epss_score": 0.00161, "epss_percentile": 0.37601}, "CVE-2024-7662": {"epss_score": 0.00138, "epss_percentile": 0.34409}, "CVE-2024-7663": {"epss_score": 0.00077, "epss_percentile": 0.23429}, "CVE-2024-7664": {"epss_score": 0.00077, "epss_percentile": 0.23429}, "CVE-2024-7665": {"epss_score": 0.00077, "epss_percentile": 0.23429}, "CVE-2024-7666": {"epss_score": 0.00079, "epss_percentile": 0.23997}, "CVE-2024-7667": {"epss_score": 0.00081, "epss_percentile": 0.24305}, "CVE-2024-7668": {"epss_score": 0.00077, "epss_percentile": 0.23429}, "CVE-2024-7669": {"epss_score": 0.00077, "epss_percentile": 0.23429}, "CVE-2024-7670": {"epss_score": 0.00209, "epss_percentile": 0.43426}, "CVE-2024-7671": {"epss_score": 0.0016, "epss_percentile": 0.37472}, "CVE-2024-7672": {"epss_score": 0.0016, "epss_percentile": 0.37472}, "CVE-2024-7673": {"epss_score": 0.00065, "epss_percentile": 0.20435}, "CVE-2024-7674": {"epss_score": 0.00065, "epss_percentile": 0.20435}, "CVE-2024-7675": {"epss_score": 0.00198, "epss_percentile": 0.42087}, "CVE-2024-7676": {"epss_score": 0.00077, "epss_percentile": 0.23429}, "CVE-2024-7677": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-7678": {"epss_score": 0.00136, "epss_percentile": 0.34085}, "CVE-2024-7679": {"epss_score": 0.00138, "epss_percentile": 0.34351}, "CVE-2024-7680": {"epss_score": 0.00247, "epss_percentile": 0.47817}, "CVE-2024-7681": {"epss_score": 0.00705, "epss_percentile": 0.71603}, "CVE-2024-7682": {"epss_score": 0.00181, "epss_percentile": 0.40118}, "CVE-2024-7683": {"epss_score": 0.00248, "epss_percentile": 0.47958}, "CVE-2024-7684": {"epss_score": 0.00236, "epss_percentile": 0.46428}, "CVE-2024-7685": {"epss_score": 0.00174, "epss_percentile": 0.39156}, "CVE-2024-7686": {"epss_score": 0.00195, "epss_percentile": 0.41683}, "CVE-2024-7687": {"epss_score": 0.00147, "epss_percentile": 0.35747}, "CVE-2024-7688": {"epss_score": 0.00182, "epss_percentile": 0.4019}, "CVE-2024-7689": {"epss_score": 0.00154, "epss_percentile": 0.36756}, "CVE-2024-7690": {"epss_score": 0.00075, "epss_percentile": 0.22973}, "CVE-2024-7691": {"epss_score": 0.00397, "epss_percentile": 0.60017}, "CVE-2024-7692": {"epss_score": 0.00235, "epss_percentile": 0.46338}, "CVE-2024-7693": {"epss_score": 0.00872, "epss_percentile": 0.74725}, "CVE-2024-7694": {"epss_score": 0.01363, "epss_percentile": 0.79765}, "CVE-2024-7695": {"epss_score": 0.00217, "epss_percentile": 0.44253}, "CVE-2024-7696": {"epss_score": 0.00051, "epss_percentile": 0.16037}, "CVE-2024-7697": {"epss_score": 0.00519, "epss_percentile": 0.66165}, "CVE-2024-7698": {"epss_score": 0.00125, "epss_percentile": 0.32499}, "CVE-2024-7699": {"epss_score": 0.00523, "epss_percentile": 0.66288}, "CVE-2024-7700": {"epss_score": 0.00226, "epss_percentile": 0.45243}, "CVE-2024-7701": {"epss_score": 0.00057, "epss_percentile": 0.18055}, "CVE-2024-7702": {"epss_score": 0.00512, "epss_percentile": 0.65854}, "CVE-2024-7703": {"epss_score": 0.44716, "epss_percentile": 0.97451}, "CVE-2024-7704": {"epss_score": 0.00353, "epss_percentile": 0.57141}, "CVE-2024-7705": {"epss_score": 0.00113, "epss_percentile": 0.30596}, "CVE-2024-7706": {"epss_score": 0.00084, "epss_percentile": 0.24951}, "CVE-2024-7707": {"epss_score": 0.00599, "epss_percentile": 0.68803}, "CVE-2024-7709": {"epss_score": 0.00226, "epss_percentile": 0.45242}, "CVE-2024-7711": {"epss_score": 0.00276, "epss_percentile": 0.50712}, "CVE-2024-7713": {"epss_score": 0.00232, "epss_percentile": 0.45939}, "CVE-2024-7714": {"epss_score": 0.23886, "epss_percentile": 0.95831}, "CVE-2024-7715": {"epss_score": 0.02954, "epss_percentile": 0.86059}, "CVE-2024-7716": {"epss_score": 0.00334, "epss_percentile": 0.55699}, "CVE-2024-7717": {"epss_score": 0.00656, "epss_percentile": 0.70435}, "CVE-2024-7720": {"epss_score": 0.0469, "epss_percentile": 0.89011}, "CVE-2024-7721": {"epss_score": 0.00194, "epss_percentile": 0.41562}, "CVE-2024-7722": {"epss_score": 0.00751, "epss_percentile": 0.72636}, "CVE-2024-7723": {"epss_score": 0.02436, "epss_percentile": 0.84741}, "CVE-2024-7724": {"epss_score": 0.02436, "epss_percentile": 0.84741}, "CVE-2024-7725": {"epss_score": 0.02436, "epss_percentile": 0.84741}, "CVE-2024-7726": {"epss_score": 0.00077, "epss_percentile": 0.2345}, "CVE-2024-7727": {"epss_score": 0.00472, "epss_percentile": 0.64036}, "CVE-2024-7728": {"epss_score": 0.01252, "epss_percentile": 0.78906}, "CVE-2024-7729": {"epss_score": 0.00415, "epss_percentile": 0.61111}, "CVE-2024-7730": {"epss_score": 0.00028, "epss_percentile": 0.07506}, "CVE-2024-7731": {"epss_score": 0.01326, "epss_percentile": 0.79481}, "CVE-2024-7732": {"epss_score": 0.01326, "epss_percentile": 0.79481}, "CVE-2024-7733": {"epss_score": 0.00095, "epss_percentile": 0.27197}, "CVE-2024-7734": {"epss_score": 0.0014, "epss_percentile": 0.34746}, "CVE-2024-7735": {"epss_score": 0.00096, "epss_percentile": 0.27306}, "CVE-2024-7736": {"epss_score": 0.00545, "epss_percentile": 0.67162}, "CVE-2024-7737": {"epss_score": 0.00106, "epss_percentile": 0.29551}, "CVE-2024-7738": {"epss_score": 0.00268, "epss_percentile": 0.50061}, "CVE-2024-7739": {"epss_score": 0.00285, "epss_percentile": 0.51675}, "CVE-2024-7740": {"epss_score": 0.00256, "epss_percentile": 0.48767}, "CVE-2024-7741": {"epss_score": 0.01051, "epss_percentile": 0.77079}, "CVE-2024-7742": {"epss_score": 0.00275, "epss_percentile": 0.50649}, "CVE-2024-7743": {"epss_score": 0.00202, "epss_percentile": 0.42462}, "CVE-2024-7744": {"epss_score": 0.00229, "epss_percentile": 0.45652}, "CVE-2024-7745": {"epss_score": 0.00204, "epss_percentile": 0.42625}, "CVE-2024-7746": {"epss_score": 0.0025, "epss_percentile": 0.4825}, "CVE-2024-7747": {"epss_score": 0.0016, "epss_percentile": 0.37481}, "CVE-2024-7748": {"epss_score": 0.00136, "epss_percentile": 0.34199}, "CVE-2024-7749": {"epss_score": 0.00091, "epss_percentile": 0.2624}, "CVE-2024-7750": {"epss_score": 0.0016, "epss_percentile": 0.37427}, "CVE-2024-7751": {"epss_score": 0.0011, "epss_percentile": 0.30199}, "CVE-2024-7752": {"epss_score": 0.00091, "epss_percentile": 0.2624}, "CVE-2024-7753": {"epss_score": 0.0031, "epss_percentile": 0.53791}, "CVE-2024-7754": {"epss_score": 0.0011, "epss_percentile": 0.30199}, "CVE-2024-7755": {"epss_score": 0.00236, "epss_percentile": 0.46428}, "CVE-2024-7756": {"epss_score": 0.00015, "epss_percentile": 0.02296}, "CVE-2024-7758": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-7759": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-7760": {"epss_score": 0.0007, "epss_percentile": 0.21827}, "CVE-2024-7761": {"epss_score": 0.00021, "epss_percentile": 0.04703}, "CVE-2024-7762": {"epss_score": 0.0011, "epss_percentile": 0.3016}, "CVE-2024-7763": {"epss_score": 0.00149, "epss_percentile": 0.36046}, "CVE-2024-7764": {"epss_score": 0.00109, "epss_percentile": 0.29942}, "CVE-2024-7765": {"epss_score": 0.00152, "epss_percentile": 0.36491}, "CVE-2024-7766": {"epss_score": 0.00313, "epss_percentile": 0.54045}, "CVE-2024-7767": {"epss_score": 0.00058, "epss_percentile": 0.18565}, "CVE-2024-7768": {"epss_score": 0.00108, "epss_percentile": 0.29861}, "CVE-2024-7769": {"epss_score": 9e-05, "epss_percentile": 0.00659}, "CVE-2024-7770": {"epss_score": 0.04134, "epss_percentile": 0.88305}, "CVE-2024-7771": {"epss_score": 0.00106, "epss_percentile": 0.29475}, "CVE-2024-7772": {"epss_score": 0.06558, "epss_percentile": 0.90846}, "CVE-2024-7774": {"epss_score": 0.00438, "epss_percentile": 0.62572}, "CVE-2024-7775": {"epss_score": 0.00181, "epss_percentile": 0.40061}, "CVE-2024-7776": {"epss_score": 0.01218, "epss_percentile": 0.78602}, "CVE-2024-7777": {"epss_score": 0.0301, "epss_percentile": 0.86196}, "CVE-2024-7778": {"epss_score": 0.00181, "epss_percentile": 0.40022}, "CVE-2024-7779": {"epss_score": 0.00078, "epss_percentile": 0.23684}, "CVE-2024-7780": {"epss_score": 0.00499, "epss_percentile": 0.65278}, "CVE-2024-7781": {"epss_score": 0.00315, "epss_percentile": 0.54203}, "CVE-2024-7782": {"epss_score": 0.08198, "epss_percentile": 0.91925}, "CVE-2024-7783": {"epss_score": 0.00096, "epss_percentile": 0.27242}, "CVE-2024-7784": {"epss_score": 0.00011, "epss_percentile": 0.00956}, "CVE-2024-7785": {"epss_score": 0.0015, "epss_percentile": 0.36085}, "CVE-2024-7786": {"epss_score": 0.65504, "epss_percentile": 0.98422}, "CVE-2024-7787": {"epss_score": 0.00194, "epss_percentile": 0.41541}, "CVE-2024-7788": {"epss_score": 0.00049, "epss_percentile": 0.15565}, "CVE-2024-7790": {"epss_score": 0.00052, "epss_percentile": 0.16359}, "CVE-2024-7791": {"epss_score": 0.0018, "epss_percentile": 0.39976}, "CVE-2024-7792": {"epss_score": 0.00099, "epss_percentile": 0.27836}, "CVE-2024-7793": {"epss_score": 0.00089, "epss_percentile": 0.25934}, "CVE-2024-7794": {"epss_score": 0.00125, "epss_percentile": 0.32469}, "CVE-2024-7795": {"epss_score": 0.0124, "epss_percentile": 0.78803}, "CVE-2024-7797": {"epss_score": 0.00194, "epss_percentile": 0.41521}, "CVE-2024-7798": {"epss_score": 0.00134, "epss_percentile": 0.33806}, "CVE-2024-7799": {"epss_score": 0.00186, "epss_percentile": 0.40601}, "CVE-2024-7800": {"epss_score": 0.00089, "epss_percentile": 0.25984}, "CVE-2024-7801": {"epss_score": 0.00289, "epss_percentile": 0.52051}, "CVE-2024-7803": {"epss_score": 0.00052, "epss_percentile": 0.16604}, "CVE-2024-7806": {"epss_score": 0.00747, "epss_percentile": 0.72567}, "CVE-2024-7807": {"epss_score": 0.00148, "epss_percentile": 0.35805}, "CVE-2024-7808": {"epss_score": 0.06605, "epss_percentile": 0.90882}, "CVE-2024-7809": {"epss_score": 0.00309, "epss_percentile": 0.53645}, "CVE-2024-7810": {"epss_score": 0.00082, "epss_percentile": 0.24398}, "CVE-2024-7811": {"epss_score": 0.00134, "epss_percentile": 0.33829}, "CVE-2024-7812": {"epss_score": 0.00131, "epss_percentile": 0.33449}, "CVE-2024-7813": {"epss_score": 0.00733, "epss_percentile": 0.72209}, "CVE-2024-7814": {"epss_score": 0.00076, "epss_percentile": 0.2323}, "CVE-2024-7815": {"epss_score": 0.00478, "epss_percentile": 0.64371}, "CVE-2024-7816": {"epss_score": 0.00123, "epss_percentile": 0.32197}, "CVE-2024-7817": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-7818": {"epss_score": 0.00134, "epss_percentile": 0.33847}, "CVE-2024-7819": {"epss_score": 0.00032, "epss_percentile": 0.09113}, "CVE-2024-7820": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2024-7822": {"epss_score": 0.00123, "epss_percentile": 0.32197}, "CVE-2024-7824": {"epss_score": 0.00189, "epss_percentile": 0.40961}, "CVE-2024-7825": {"epss_score": 0.00257, "epss_percentile": 0.48923}, "CVE-2024-7826": {"epss_score": 0.0022, "epss_percentile": 0.44601}, "CVE-2024-7827": {"epss_score": 0.00656, "epss_percentile": 0.70435}, "CVE-2024-7828": {"epss_score": 0.01168, "epss_percentile": 0.78191}, "CVE-2024-7829": {"epss_score": 0.01168, "epss_percentile": 0.78191}, "CVE-2024-7830": {"epss_score": 0.01168, "epss_percentile": 0.78191}, "CVE-2024-7831": {"epss_score": 0.01074, "epss_percentile": 0.77302}, "CVE-2024-7832": {"epss_score": 0.00964, "epss_percentile": 0.7603}, "CVE-2024-7833": {"epss_score": 0.0091, "epss_percentile": 0.75321}, "CVE-2024-7834": {"epss_score": 0.00082, "epss_percentile": 0.24428}, "CVE-2024-7835": {"epss_score": 0.00194, "epss_percentile": 0.41541}, "CVE-2024-7836": {"epss_score": 0.00181, "epss_percentile": 0.40056}, "CVE-2024-7837": {"epss_score": 0.00053, "epss_percentile": 0.17031}, "CVE-2024-7838": {"epss_score": 0.00091, "epss_percentile": 0.26213}, "CVE-2024-7839": {"epss_score": 0.00086, "epss_percentile": 0.25287}, "CVE-2024-7840": {"epss_score": 0.00229, "epss_percentile": 0.45597}, "CVE-2024-7841": {"epss_score": 0.0016, "epss_percentile": 0.37427}, "CVE-2024-7842": {"epss_score": 0.00249, "epss_percentile": 0.48004}, "CVE-2024-7843": {"epss_score": 0.00249, "epss_percentile": 0.48004}, "CVE-2024-7844": {"epss_score": 0.00091, "epss_percentile": 0.2624}, "CVE-2024-7845": {"epss_score": 0.00062, "epss_percentile": 0.19735}, "CVE-2024-7846": {"epss_score": 0.00161, "epss_percentile": 0.37597}, "CVE-2024-7847": {"epss_score": 0.00259, "epss_percentile": 0.49076}, "CVE-2024-7848": {"epss_score": 0.00452, "epss_percentile": 0.63163}, "CVE-2024-7849": {"epss_score": 0.00235, "epss_percentile": 0.46323}, "CVE-2024-7850": {"epss_score": 0.00184, "epss_percentile": 0.40393}, "CVE-2024-7851": {"epss_score": 0.00112, "epss_percentile": 0.30565}, "CVE-2024-7852": {"epss_score": 0.0012, "epss_percentile": 0.31761}, "CVE-2024-7853": {"epss_score": 0.00072, "epss_percentile": 0.22342}, "CVE-2024-7854": {"epss_score": 0.77085, "epss_percentile": 0.9892}, "CVE-2024-7855": {"epss_score": 0.62901, "epss_percentile": 0.98312}, "CVE-2024-7856": {"epss_score": 0.7695, "epss_percentile": 0.98912}, "CVE-2024-7857": {"epss_score": 0.00422, "epss_percentile": 0.61563}, "CVE-2024-7858": {"epss_score": 0.00097, "epss_percentile": 0.27479}, "CVE-2024-7859": {"epss_score": 0.00167, "epss_percentile": 0.38352}, "CVE-2024-7860": {"epss_score": 0.00134, "epss_percentile": 0.33847}, "CVE-2024-7861": {"epss_score": 0.00134, "epss_percentile": 0.33847}, "CVE-2024-7862": {"epss_score": 0.00134, "epss_percentile": 0.338}, "CVE-2024-7863": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2024-7864": {"epss_score": 0.0016, "epss_percentile": 0.37464}, "CVE-2024-7866": {"epss_score": 0.00105, "epss_percentile": 0.2927}, "CVE-2024-7867": {"epss_score": 0.00054, "epss_percentile": 0.17066}, "CVE-2024-7868": {"epss_score": 0.00255, "epss_percentile": 0.48686}, "CVE-2024-7869": {"epss_score": 0.01334, "epss_percentile": 0.79534}, "CVE-2024-7870": {"epss_score": 0.00527, "epss_percentile": 0.66441}, "CVE-2024-7871": {"epss_score": 0.00337, "epss_percentile": 0.56031}, "CVE-2024-7872": {"epss_score": 0.00068, "epss_percentile": 0.2122}, "CVE-2024-7873": {"epss_score": 0.0015, "epss_percentile": 0.36085}, "CVE-2024-7874": {"epss_score": 0.00277, "epss_percentile": 0.5079}, "CVE-2024-7875": {"epss_score": 0.00277, "epss_percentile": 0.5079}, "CVE-2024-7876": {"epss_score": 0.00151, "epss_percentile": 0.36321}, "CVE-2024-7877": {"epss_score": 0.00195, "epss_percentile": 0.4168}, "CVE-2024-7878": {"epss_score": 0.00297, "epss_percentile": 0.52751}, "CVE-2024-7879": {"epss_score": 0.00176, "epss_percentile": 0.3944}, "CVE-2024-7881": {"epss_score": 0.00038, "epss_percentile": 0.11331}, "CVE-2024-7882": {"epss_score": 0.0007, "epss_percentile": 0.21638}, "CVE-2024-7883": {"epss_score": 0.00278, "epss_percentile": 0.50897}, "CVE-2024-7884": {"epss_score": 0.00118, "epss_percentile": 0.31516}, "CVE-2024-7885": {"epss_score": 0.06348, "epss_percentile": 0.9069}, "CVE-2024-7886": {"epss_score": 0.0006, "epss_percentile": 0.19217}, "CVE-2024-7887": {"epss_score": 0.00027, "epss_percentile": 0.069}, "CVE-2024-7888": {"epss_score": 0.00148, "epss_percentile": 0.35826}, "CVE-2024-7889": {"epss_score": 0.00096, "epss_percentile": 0.27379}, "CVE-2024-7890": {"epss_score": 0.0009, "epss_percentile": 0.26064}, "CVE-2024-7891": {"epss_score": 0.0015, "epss_percentile": 0.36095}, "CVE-2024-7892": {"epss_score": 0.00134, "epss_percentile": 0.338}, "CVE-2024-7894": {"epss_score": 0.00255, "epss_percentile": 0.48683}, "CVE-2024-7895": {"epss_score": 0.00323, "epss_percentile": 0.54906}, "CVE-2024-7896": {"epss_score": 0.03907, "epss_percentile": 0.87929}, "CVE-2024-7897": {"epss_score": 0.007, "epss_percentile": 0.71464}, "CVE-2024-7898": {"epss_score": 0.00271, "epss_percentile": 0.50345}, "CVE-2024-7899": {"epss_score": 0.00199, "epss_percentile": 0.42115}, "CVE-2024-7900": {"epss_score": 0.00074, "epss_percentile": 0.2277}, "CVE-2024-7901": {"epss_score": 0.00177, "epss_percentile": 0.39571}, "CVE-2024-7902": {"epss_score": 0.00159, "epss_percentile": 0.37407}, "CVE-2024-7903": {"epss_score": 0.0015, "epss_percentile": 0.36066}, "CVE-2024-7904": {"epss_score": 0.00145, "epss_percentile": 0.35429}, "CVE-2024-7905": {"epss_score": 0.00118, "epss_percentile": 0.31391}, "CVE-2024-7906": {"epss_score": 0.00142, "epss_percentile": 0.3505}, "CVE-2024-7907": {"epss_score": 0.02741, "epss_percentile": 0.8556}, "CVE-2024-7908": {"epss_score": 0.00422, "epss_percentile": 0.6154}, "CVE-2024-7909": {"epss_score": 0.00422, "epss_percentile": 0.6154}, "CVE-2024-7910": {"epss_score": 0.00075, "epss_percentile": 0.22883}, "CVE-2024-7911": {"epss_score": 0.00079, "epss_percentile": 0.23858}, "CVE-2024-7912": {"epss_score": 0.00153, "epss_percentile": 0.36576}, "CVE-2024-7913": {"epss_score": 0.00091, "epss_percentile": 0.26213}, "CVE-2024-7914": {"epss_score": 0.0012, "epss_percentile": 0.31761}, "CVE-2024-7915": {"epss_score": 0.00019, "epss_percentile": 0.04189}, "CVE-2024-7916": {"epss_score": 0.0014, "epss_percentile": 0.34794}, "CVE-2024-7917": {"epss_score": 0.00096, "epss_percentile": 0.27302}, "CVE-2024-7918": {"epss_score": 0.00154, "epss_percentile": 0.36711}, "CVE-2024-7919": {"epss_score": 0.01831, "epss_percentile": 0.82449}, "CVE-2024-7920": {"epss_score": 0.01208, "epss_percentile": 0.78534}, "CVE-2024-7921": {"epss_score": 0.01068, "epss_percentile": 0.77238}, "CVE-2024-7922": {"epss_score": 0.16661, "epss_percentile": 0.94709}, "CVE-2024-7923": {"epss_score": 0.00292, "epss_percentile": 0.52225}, "CVE-2024-7924": {"epss_score": 0.02443, "epss_percentile": 0.84758}, "CVE-2024-7925": {"epss_score": 0.00122, "epss_percentile": 0.32107}, "CVE-2024-7926": {"epss_score": 0.00365, "epss_percentile": 0.57994}, "CVE-2024-7927": {"epss_score": 0.00365, "epss_percentile": 0.57994}, "CVE-2024-7928": {"epss_score": 0.92925, "epss_percentile": 0.9976}, "CVE-2024-7929": {"epss_score": 0.00172, "epss_percentile": 0.38989}, "CVE-2024-7930": {"epss_score": 0.00099, "epss_percentile": 0.28427}, "CVE-2024-7931": {"epss_score": 0.00091, "epss_percentile": 0.26238}, "CVE-2024-7932": {"epss_score": 0.007, "epss_percentile": 0.71462}, "CVE-2024-7933": {"epss_score": 0.00095, "epss_percentile": 0.27226}, "CVE-2024-7934": {"epss_score": 0.00095, "epss_percentile": 0.27235}, "CVE-2024-7935": {"epss_score": 0.00087, "epss_percentile": 0.25589}, "CVE-2024-7936": {"epss_score": 0.00077, "epss_percentile": 0.23407}, "CVE-2024-7937": {"epss_score": 0.00057, "epss_percentile": 0.1802}, "CVE-2024-7938": {"epss_score": 0.007, "epss_percentile": 0.71462}, "CVE-2024-7939": {"epss_score": 0.007, "epss_percentile": 0.71462}, "CVE-2024-7940": {"epss_score": 0.00457, "epss_percentile": 0.63376}, "CVE-2024-7941": {"epss_score": 0.0033, "epss_percentile": 0.55449}, "CVE-2024-7942": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-7943": {"epss_score": 0.00055, "epss_percentile": 0.17473}, "CVE-2024-7944": {"epss_score": 0.00021, "epss_percentile": 0.04774}, "CVE-2024-7945": {"epss_score": 0.00122, "epss_percentile": 0.32144}, "CVE-2024-7946": {"epss_score": 0.00073, "epss_percentile": 0.2261}, "CVE-2024-7947": {"epss_score": 0.00073, "epss_percentile": 0.2261}, "CVE-2024-7948": {"epss_score": 0.00128, "epss_percentile": 0.33061}, "CVE-2024-7949": {"epss_score": 0.00069, "epss_percentile": 0.21616}, "CVE-2024-7950": {"epss_score": 0.00508, "epss_percentile": 0.65701}, "CVE-2024-7954": {"epss_score": 0.93789, "epss_percentile": 0.99846}, "CVE-2024-7955": {"epss_score": 0.00209, "epss_percentile": 0.43365}, "CVE-2024-7957": {"epss_score": 0.00134, "epss_percentile": 0.33833}, "CVE-2024-7959": {"epss_score": 0.0032, "epss_percentile": 0.54589}, "CVE-2024-7960": {"epss_score": 0.00343, "epss_percentile": 0.56438}, "CVE-2024-7961": {"epss_score": 0.01719, "epss_percentile": 0.81927}, "CVE-2024-7962": {"epss_score": 0.003, "epss_percentile": 0.52909}, "CVE-2024-7963": {"epss_score": 0.00249, "epss_percentile": 0.48051}, "CVE-2024-7964": {"epss_score": 0.00512, "epss_percentile": 0.65871}, "CVE-2024-7965": {"epss_score": 0.27075, "epss_percentile": 0.96204}, "CVE-2024-7966": {"epss_score": 0.00853, "epss_percentile": 0.74443}, "CVE-2024-7967": {"epss_score": 0.00413, "epss_percentile": 0.61003}, "CVE-2024-7968": {"epss_score": 0.00695, "epss_percentile": 0.71371}, "CVE-2024-7969": {"epss_score": 0.00188, "epss_percentile": 0.40806}, "CVE-2024-7970": {"epss_score": 0.00397, "epss_percentile": 0.60031}, "CVE-2024-7971": {"epss_score": 0.01668, "epss_percentile": 0.81659}, "CVE-2024-7972": {"epss_score": 0.00361, "epss_percentile": 0.57694}, "CVE-2024-7973": {"epss_score": 0.00238, "epss_percentile": 0.46802}, "CVE-2024-7974": {"epss_score": 0.00578, "epss_percentile": 0.68207}, "CVE-2024-7975": {"epss_score": 0.00263, "epss_percentile": 0.49477}, "CVE-2024-7976": {"epss_score": 0.00255, "epss_percentile": 0.48722}, "CVE-2024-7977": {"epss_score": 0.00023, "epss_percentile": 0.05632}, "CVE-2024-7978": {"epss_score": 0.00165, "epss_percentile": 0.38083}, "CVE-2024-7979": {"epss_score": 0.00018, "epss_percentile": 0.03798}, "CVE-2024-7980": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2024-7981": {"epss_score": 0.00273, "epss_percentile": 0.50439}, "CVE-2024-7982": {"epss_score": 0.01787, "epss_percentile": 0.82261}, "CVE-2024-7983": {"epss_score": 0.00154, "epss_percentile": 0.36737}, "CVE-2024-7984": {"epss_score": 0.00021, "epss_percentile": 0.04743}, "CVE-2024-7985": {"epss_score": 0.36311, "epss_percentile": 0.96969}, "CVE-2024-7986": {"epss_score": 0.00104, "epss_percentile": 0.29135}, "CVE-2024-7987": {"epss_score": 0.00112, "epss_percentile": 0.30433}, "CVE-2024-7988": {"epss_score": 0.13828, "epss_percentile": 0.94068}, "CVE-2024-7990": {"epss_score": 0.00143, "epss_percentile": 0.35167}, "CVE-2024-7991": {"epss_score": 0.00045, "epss_percentile": 0.1399}, "CVE-2024-7992": {"epss_score": 0.00078, "epss_percentile": 0.23772}, "CVE-2024-7993": {"epss_score": 0.00199, "epss_percentile": 0.4214}, "CVE-2024-7994": {"epss_score": 0.00173, "epss_percentile": 0.39048}, "CVE-2024-7995": {"epss_score": 0.00125, "epss_percentile": 0.32543}, "CVE-2024-7998": {"epss_score": 0.00197, "epss_percentile": 0.41845}, "CVE-2024-8000": {"epss_score": 0.00035, "epss_percentile": 0.10077}, "CVE-2024-8001": {"epss_score": 0.00265, "epss_percentile": 0.49783}, "CVE-2024-8002": {"epss_score": 0.00092, "epss_percentile": 0.26581}, "CVE-2024-8003": {"epss_score": 0.00618, "epss_percentile": 0.69378}, "CVE-2024-8004": {"epss_score": 0.0084, "epss_percentile": 0.74199}, "CVE-2024-8005": {"epss_score": 0.00265, "epss_percentile": 0.49821}, "CVE-2024-8006": {"epss_score": 0.00015, "epss_percentile": 0.02123}, "CVE-2024-8007": {"epss_score": 0.00234, "epss_percentile": 0.46124}, "CVE-2024-8008": {"epss_score": 0.00018, "epss_percentile": 0.03807}, "CVE-2024-8009": {"epss_score": 0.00038, "epss_percentile": 0.11076}, "CVE-2024-8011": {"epss_score": 0.00029, "epss_percentile": 0.07839}, "CVE-2024-8012": {"epss_score": 0.00076, "epss_percentile": 0.23078}, "CVE-2024-8013": {"epss_score": 0.00065, "epss_percentile": 0.20569}, "CVE-2024-8014": {"epss_score": 0.00547, "epss_percentile": 0.67263}, "CVE-2024-8015": {"epss_score": 0.00507, "epss_percentile": 0.6565}, "CVE-2024-8016": {"epss_score": 0.03874, "epss_percentile": 0.87885}, "CVE-2024-8017": {"epss_score": 0.0009, "epss_percentile": 0.26036}, "CVE-2024-8018": {"epss_score": 0.001, "epss_percentile": 0.28462}, "CVE-2024-8019": {"epss_score": 0.00923, "epss_percentile": 0.75508}, "CVE-2024-8020": {"epss_score": 0.00061, "epss_percentile": 0.1929}, "CVE-2024-8021": {"epss_score": 0.02682, "epss_percentile": 0.8542}, "CVE-2024-8022": {"epss_score": 0.00279, "epss_percentile": 0.50936}, "CVE-2024-8023": {"epss_score": 0.00099, "epss_percentile": 0.27836}, "CVE-2024-8024": {"epss_score": 0.0005, "epss_percentile": 0.15891}, "CVE-2024-8025": {"epss_score": 0.02581, "epss_percentile": 0.85152}, "CVE-2024-8026": {"epss_score": 0.00037, "epss_percentile": 0.10774}, "CVE-2024-8027": {"epss_score": 0.00068, "epss_percentile": 0.21422}, "CVE-2024-8028": {"epss_score": 0.00078, "epss_percentile": 0.23684}, "CVE-2024-8029": {"epss_score": 0.00066, "epss_percentile": 0.2081}, "CVE-2024-8030": {"epss_score": 0.37882, "epss_percentile": 0.97075}, "CVE-2024-8031": {"epss_score": 0.00253, "epss_percentile": 0.48444}, "CVE-2024-8032": {"epss_score": 0.00027, "epss_percentile": 0.06877}, "CVE-2024-8033": {"epss_score": 0.00269, "epss_percentile": 0.50184}, "CVE-2024-8034": {"epss_score": 0.00306, "epss_percentile": 0.53397}, "CVE-2024-8035": {"epss_score": 0.0022, "epss_percentile": 0.44624}, "CVE-2024-8036": {"epss_score": 0.00018, "epss_percentile": 0.03908}, "CVE-2024-8037": {"epss_score": 0.0007, "epss_percentile": 0.21742}, "CVE-2024-8038": {"epss_score": 0.001, "epss_percentile": 0.28451}, "CVE-2024-8039": {"epss_score": 0.00112, "epss_percentile": 0.30432}, "CVE-2024-8040": {"epss_score": 0.00035, "epss_percentile": 0.10013}, "CVE-2024-8041": {"epss_score": 0.00388, "epss_percentile": 0.59356}, "CVE-2024-8042": {"epss_score": 0.0002, "epss_percentile": 0.04516}, "CVE-2024-8043": {"epss_score": 0.00063, "epss_percentile": 0.19988}, "CVE-2024-8044": {"epss_score": 0.00069, "epss_percentile": 0.21589}, "CVE-2024-8045": {"epss_score": 0.00402, "epss_percentile": 0.60276}, "CVE-2024-8046": {"epss_score": 0.00188, "epss_percentile": 0.40841}, "CVE-2024-8047": {"epss_score": 0.00087, "epss_percentile": 0.25515}, "CVE-2024-8048": {"epss_score": 0.00056, "epss_percentile": 0.17927}, "CVE-2024-8049": {"epss_score": 0.01511, "epss_percentile": 0.80773}, "CVE-2024-8050": {"epss_score": 0.00024, "epss_percentile": 0.05818}, "CVE-2024-8051": {"epss_score": 0.0006, "epss_percentile": 0.19011}, "CVE-2024-8052": {"epss_score": 0.00119, "epss_percentile": 0.31595}, "CVE-2024-8053": {"epss_score": 0.00746, "epss_percentile": 0.72543}, "CVE-2024-8054": {"epss_score": 0.00186, "epss_percentile": 0.40614}, "CVE-2024-8055": {"epss_score": 0.00062, "epss_percentile": 0.19636}, "CVE-2024-8056": {"epss_score": 0.00173, "epss_percentile": 0.39075}, "CVE-2024-8057": {"epss_score": 0.00042, "epss_percentile": 0.12754}, "CVE-2024-8058": {"epss_score": 0.00169, "epss_percentile": 0.38618}, "CVE-2024-8059": {"epss_score": 0.0005, "epss_percentile": 0.15756}, "CVE-2024-8060": {"epss_score": 0.00868, "epss_percentile": 0.74664}, "CVE-2024-8061": {"epss_score": 0.00091, "epss_percentile": 0.26282}, "CVE-2024-8062": {"epss_score": 0.00091, "epss_percentile": 0.2629}, "CVE-2024-8063": {"epss_score": 0.00214, "epss_percentile": 0.4397}, "CVE-2024-8065": {"epss_score": 0.00027, "epss_percentile": 0.0677}, "CVE-2024-8066": {"epss_score": 0.03566, "epss_percentile": 0.87365}, "CVE-2024-8067": {"epss_score": 0.00047, "epss_percentile": 0.14672}, "CVE-2024-8068": {"epss_score": 0.08987, "epss_percentile": 0.92354}, "CVE-2024-8069": {"epss_score": 0.46249, "epss_percentile": 0.97538}, "CVE-2024-8070": {"epss_score": 0.00021, "epss_percentile": 0.0472}, "CVE-2024-8071": {"epss_score": 0.00093, "epss_percentile": 0.26614}, "CVE-2024-8072": {"epss_score": 0.00112, "epss_percentile": 0.30538}, "CVE-2024-8073": {"epss_score": 0.00938, "epss_percentile": 0.75706}, "CVE-2024-8074": {"epss_score": 0.0016, "epss_percentile": 0.37466}, "CVE-2024-8075": {"epss_score": 0.00776, "epss_percentile": 0.73099}, "CVE-2024-8076": {"epss_score": 0.00256, "epss_percentile": 0.48778}, "CVE-2024-8077": {"epss_score": 0.0208, "epss_percentile": 0.83529}, "CVE-2024-8078": {"epss_score": 0.00213, "epss_percentile": 0.43941}, "CVE-2024-8079": {"epss_score": 0.00218, "epss_percentile": 0.44339}, "CVE-2024-8080": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-8081": {"epss_score": 0.00049, "epss_percentile": 0.15548}, "CVE-2024-8082": {"epss_score": 0.00029, "epss_percentile": 0.07894}, "CVE-2024-8083": {"epss_score": 0.00053, "epss_percentile": 0.1684}, "CVE-2024-8084": {"epss_score": 0.00093, "epss_percentile": 0.26671}, "CVE-2024-8085": {"epss_score": 0.00027, "epss_percentile": 0.06877}, "CVE-2024-8086": {"epss_score": 0.00072, "epss_percentile": 0.22326}, "CVE-2024-8087": {"epss_score": 0.00072, "epss_percentile": 0.22342}, "CVE-2024-8088": {"epss_score": 0.00244, "epss_percentile": 0.47611}, "CVE-2024-8089": {"epss_score": 0.00107, "epss_percentile": 0.29673}, "CVE-2024-8090": {"epss_score": 0.00025, "epss_percentile": 0.06107}, "CVE-2024-8091": {"epss_score": 0.00116, "epss_percentile": 0.31171}, "CVE-2024-8092": {"epss_score": 0.00178, "epss_percentile": 0.39699}, "CVE-2024-8093": {"epss_score": 0.00089, "epss_percentile": 0.25933}, "CVE-2024-8094": {"epss_score": 0.00024, "epss_percentile": 0.05818}, "CVE-2024-8095": {"epss_score": 0.00027, "epss_percentile": 0.06877}, "CVE-2024-8096": {"epss_score": 0.00412, "epss_percentile": 0.60925}, "CVE-2024-8097": {"epss_score": 0.00037, "epss_percentile": 0.10866}, "CVE-2024-8099": {"epss_score": 0.00072, "epss_percentile": 0.2234}, "CVE-2024-8100": {"epss_score": 0.00038, "epss_percentile": 0.11162}, "CVE-2024-8101": {"epss_score": 0.00098, "epss_percentile": 0.27708}, "CVE-2024-8102": {"epss_score": 0.00267, "epss_percentile": 0.50015}, "CVE-2024-8103": {"epss_score": 0.00192, "epss_percentile": 0.41307}, "CVE-2024-8104": {"epss_score": 0.02978, "epss_percentile": 0.86111}, "CVE-2024-8105": {"epss_score": 0.00014, "epss_percentile": 0.01888}, "CVE-2024-8106": {"epss_score": 0.00467, "epss_percentile": 0.63834}, "CVE-2024-8107": {"epss_score": 0.00188, "epss_percentile": 0.4085}, "CVE-2024-8108": {"epss_score": 0.0027, "epss_percentile": 0.50257}, "CVE-2024-8110": {"epss_score": 0.00226, "epss_percentile": 0.45249}, "CVE-2024-8112": {"epss_score": 0.00134, "epss_percentile": 0.33769}, "CVE-2024-8113": {"epss_score": 0.00111, "epss_percentile": 0.30386}, "CVE-2024-8114": {"epss_score": 0.00123, "epss_percentile": 0.32224}, "CVE-2024-8116": {"epss_score": 0.00055, "epss_percentile": 0.17471}, "CVE-2024-8117": {"epss_score": 0.01725, "epss_percentile": 0.81955}, "CVE-2024-8118": {"epss_score": 0.00066, "epss_percentile": 0.20746}, "CVE-2024-8119": {"epss_score": 0.01725, "epss_percentile": 0.81955}, "CVE-2024-8120": {"epss_score": 0.00175, "epss_percentile": 0.39309}, "CVE-2024-8121": {"epss_score": 0.00114, "epss_percentile": 0.30803}, "CVE-2024-8123": {"epss_score": 0.00159, "epss_percentile": 0.37413}, "CVE-2024-8124": {"epss_score": 0.05838, "epss_percentile": 0.9025}, "CVE-2024-8125": {"epss_score": 0.00111, "epss_percentile": 0.30353}, "CVE-2024-8126": {"epss_score": 0.08942, "epss_percentile": 0.9233}, "CVE-2024-8127": {"epss_score": 0.01763, "epss_percentile": 0.82157}, "CVE-2024-8128": {"epss_score": 0.02282, "epss_percentile": 0.84255}, "CVE-2024-8129": {"epss_score": 0.01152, "epss_percentile": 0.78045}, "CVE-2024-8130": {"epss_score": 0.01152, "epss_percentile": 0.78045}, "CVE-2024-8131": {"epss_score": 0.02465, "epss_percentile": 0.84834}, "CVE-2024-8132": {"epss_score": 0.02282, "epss_percentile": 0.84255}, "CVE-2024-8133": {"epss_score": 0.01152, "epss_percentile": 0.78045}, "CVE-2024-8134": {"epss_score": 0.01152, "epss_percentile": 0.78045}, "CVE-2024-8135": {"epss_score": 0.00117, "epss_percentile": 0.31298}, "CVE-2024-8136": {"epss_score": 0.00129, "epss_percentile": 0.33126}, "CVE-2024-8137": {"epss_score": 0.00129, "epss_percentile": 0.33126}, "CVE-2024-8138": {"epss_score": 0.00076, "epss_percentile": 0.23278}, "CVE-2024-8139": {"epss_score": 0.00092, "epss_percentile": 0.26436}, "CVE-2024-8140": {"epss_score": 0.00133, "epss_percentile": 0.3372}, "CVE-2024-8141": {"epss_score": 0.00133, "epss_percentile": 0.3372}, "CVE-2024-8142": {"epss_score": 0.00133, "epss_percentile": 0.3372}, "CVE-2024-8143": {"epss_score": 0.00144, "epss_percentile": 0.35248}, "CVE-2024-8144": {"epss_score": 0.00127, "epss_percentile": 0.32798}, "CVE-2024-8145": {"epss_score": 0.00102, "epss_percentile": 0.28795}, "CVE-2024-8146": {"epss_score": 0.00076, "epss_percentile": 0.23278}, "CVE-2024-8147": {"epss_score": 0.00073, "epss_percentile": 0.22621}, "CVE-2024-8148": {"epss_score": 0.01109, "epss_percentile": 0.77648}, "CVE-2024-8149": {"epss_score": 0.00398, "epss_percentile": 0.60082}, "CVE-2024-8150": {"epss_score": 0.00032, "epss_percentile": 0.08777}, "CVE-2024-8151": {"epss_score": 0.00072, "epss_percentile": 0.22402}, "CVE-2024-8152": {"epss_score": 0.00183, "epss_percentile": 0.40357}, "CVE-2024-8153": {"epss_score": 0.00133, "epss_percentile": 0.3372}, "CVE-2024-8154": {"epss_score": 0.00133, "epss_percentile": 0.3372}, "CVE-2024-8155": {"epss_score": 0.00064, "epss_percentile": 0.2025}, "CVE-2024-8156": {"epss_score": 0.01465, "epss_percentile": 0.80456}, "CVE-2024-8157": {"epss_score": 0.00153, "epss_percentile": 0.36563}, "CVE-2024-8158": {"epss_score": 0.00053, "epss_percentile": 0.1688}, "CVE-2024-8159": {"epss_score": 0.00046, "epss_percentile": 0.14138}, "CVE-2024-8160": {"epss_score": 0.00079, "epss_percentile": 0.23888}, "CVE-2024-8161": {"epss_score": 0.00398, "epss_percentile": 0.60063}, "CVE-2024-8162": {"epss_score": 0.00228, "epss_percentile": 0.45466}, "CVE-2024-8163": {"epss_score": 0.00118, "epss_percentile": 0.31483}, "CVE-2024-8164": {"epss_score": 0.00085, "epss_percentile": 0.25147}, "CVE-2024-8165": {"epss_score": 0.00263, "epss_percentile": 0.495}, "CVE-2024-8166": {"epss_score": 0.00071, "epss_percentile": 0.21987}, "CVE-2024-8167": {"epss_score": 0.00073, "epss_percentile": 0.2261}, "CVE-2024-8168": {"epss_score": 0.00073, "epss_percentile": 0.2261}, "CVE-2024-8169": {"epss_score": 0.00099, "epss_percentile": 0.28408}, "CVE-2024-8170": {"epss_score": 0.00104, "epss_percentile": 0.29245}, "CVE-2024-8171": {"epss_score": 0.00067, "epss_percentile": 0.21048}, "CVE-2024-8172": {"epss_score": 0.00185, "epss_percentile": 0.40521}, "CVE-2024-8173": {"epss_score": 0.00063, "epss_percentile": 0.20079}, "CVE-2024-8174": {"epss_score": 0.00246, "epss_percentile": 0.47802}, "CVE-2024-8175": {"epss_score": 0.00609, "epss_percentile": 0.69087}, "CVE-2024-8176": {"epss_score": 0.00417, "epss_percentile": 0.61248}, "CVE-2024-8177": {"epss_score": 0.00072, "epss_percentile": 0.22294}, "CVE-2024-8178": {"epss_score": 0.022, "epss_percentile": 0.83975}, "CVE-2024-8179": {"epss_score": 0.0037, "epss_percentile": 0.58299}, "CVE-2024-8180": {"epss_score": 0.02943, "epss_percentile": 0.86036}, "CVE-2024-8181": {"epss_score": 0.57875, "epss_percentile": 0.98088}, "CVE-2024-8182": {"epss_score": 0.01449, "epss_percentile": 0.80344}, "CVE-2024-8183": {"epss_score": 0.00063, "epss_percentile": 0.19965}, "CVE-2024-8184": {"epss_score": 0.01487, "epss_percentile": 0.80611}, "CVE-2024-8185": {"epss_score": 0.00586, "epss_percentile": 0.68447}, "CVE-2024-8186": {"epss_score": 0.00065, "epss_percentile": 0.2058}, "CVE-2024-8187": {"epss_score": 0.00127, "epss_percentile": 0.32889}, "CVE-2024-8189": {"epss_score": 0.00151, "epss_percentile": 0.36248}, "CVE-2024-8190": {"epss_score": 0.91935, "epss_percentile": 0.99679}, "CVE-2024-8191": {"epss_score": 0.29384, "epss_percentile": 0.96439}, "CVE-2024-8193": {"epss_score": 0.00372, "epss_percentile": 0.58443}, "CVE-2024-8194": {"epss_score": 0.00121, "epss_percentile": 0.31841}, "CVE-2024-8195": {"epss_score": 0.00471, "epss_percentile": 0.64015}, "CVE-2024-8196": {"epss_score": 0.00186, "epss_percentile": 0.40692}, "CVE-2024-8198": {"epss_score": 0.00244, "epss_percentile": 0.4752}, "CVE-2024-8199": {"epss_score": 0.00142, "epss_percentile": 0.34978}, "CVE-2024-8200": {"epss_score": 0.00123, "epss_percentile": 0.32264}, "CVE-2024-8201": {"epss_score": 0.00014, "epss_percentile": 0.02066}, "CVE-2024-8207": {"epss_score": 0.00063, "epss_percentile": 0.19998}, "CVE-2024-8208": {"epss_score": 0.00127, "epss_percentile": 0.32798}, "CVE-2024-8209": {"epss_score": 0.0018, "epss_percentile": 0.39924}, "CVE-2024-8210": {"epss_score": 0.02587, "epss_percentile": 0.8517}, "CVE-2024-8211": {"epss_score": 0.02368, "epss_percentile": 0.84519}, "CVE-2024-8212": {"epss_score": 0.02587, "epss_percentile": 0.8517}, "CVE-2024-8213": {"epss_score": 0.01152, "epss_percentile": 0.78045}, "CVE-2024-8214": {"epss_score": 0.01052, "epss_percentile": 0.77094}, "CVE-2024-8215": {"epss_score": 0.00219, "epss_percentile": 0.44477}, "CVE-2024-8216": {"epss_score": 0.00066, "epss_percentile": 0.20707}, "CVE-2024-8217": {"epss_score": 0.0008, "epss_percentile": 0.24064}, "CVE-2024-8218": {"epss_score": 0.00078, "epss_percentile": 0.2363}, "CVE-2024-8219": {"epss_score": 0.00078, "epss_percentile": 0.2363}, "CVE-2024-8220": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-8221": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-8222": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-8223": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-8224": {"epss_score": 0.00198, "epss_percentile": 0.42}, "CVE-2024-8225": {"epss_score": 0.00198, "epss_percentile": 0.42}, "CVE-2024-8226": {"epss_score": 0.00324, "epss_percentile": 0.54975}, "CVE-2024-8227": {"epss_score": 0.00324, "epss_percentile": 0.54975}, "CVE-2024-8228": {"epss_score": 0.00635, "epss_percentile": 0.69823}, "CVE-2024-8229": {"epss_score": 0.0051, "epss_percentile": 0.65762}, "CVE-2024-8230": {"epss_score": 0.00635, "epss_percentile": 0.69823}, "CVE-2024-8231": {"epss_score": 0.00676, "epss_percentile": 0.70928}, "CVE-2024-8232": {"epss_score": 0.00349, "epss_percentile": 0.56853}, "CVE-2024-8233": {"epss_score": 0.00107, "epss_percentile": 0.29742}, "CVE-2024-8234": {"epss_score": 0.05759, "epss_percentile": 0.90183}, "CVE-2024-8235": {"epss_score": 0.00101, "epss_percentile": 0.28583}, "CVE-2024-8236": {"epss_score": 0.00111, "epss_percentile": 0.30288}, "CVE-2024-8237": {"epss_score": 0.00271, "epss_percentile": 0.50302}, "CVE-2024-8238": {"epss_score": 0.00235, "epss_percentile": 0.462}, "CVE-2024-8239": {"epss_score": 0.0018, "epss_percentile": 0.39865}, "CVE-2024-8241": {"epss_score": 0.0023, "epss_percentile": 0.45733}, "CVE-2024-8242": {"epss_score": 0.01628, "epss_percentile": 0.81437}, "CVE-2024-8243": {"epss_score": 0.0003, "epss_percentile": 0.08235}, "CVE-2024-8244": {"epss_score": 0.00018, "epss_percentile": 0.03968}, "CVE-2024-8245": {"epss_score": 0.00021, "epss_percentile": 0.04743}, "CVE-2024-8246": {"epss_score": 0.00248, "epss_percentile": 0.47986}, "CVE-2024-8247": {"epss_score": 0.00292, "epss_percentile": 0.52261}, "CVE-2024-8248": {"epss_score": 0.00217, "epss_percentile": 0.4425}, "CVE-2024-8249": {"epss_score": 0.0009, "epss_percentile": 0.26085}, "CVE-2024-8250": {"epss_score": 0.00032, "epss_percentile": 0.08822}, "CVE-2024-8251": {"epss_score": 0.00085, "epss_percentile": 0.25031}, "CVE-2024-8252": {"epss_score": 0.08254, "epss_percentile": 0.91952}, "CVE-2024-8253": {"epss_score": 0.01576, "epss_percentile": 0.81116}, "CVE-2024-8254": {"epss_score": 0.00216, "epss_percentile": 0.44228}, "CVE-2024-8255": {"epss_score": 0.04198, "epss_percentile": 0.88383}, "CVE-2024-8256": {"epss_score": 0.00042, "epss_percentile": 0.12811}, "CVE-2024-8258": {"epss_score": 0.00115, "epss_percentile": 0.30962}, "CVE-2024-8259": {"epss_score": 0.00123, "epss_percentile": 0.32291}, "CVE-2024-8260": {"epss_score": 0.00143, "epss_percentile": 0.3511}, "CVE-2024-8261": {"epss_score": 0.0012, "epss_percentile": 0.31782}, "CVE-2024-8262": {"epss_score": 0.00303, "epss_percentile": 0.53204}, "CVE-2024-8263": {"epss_score": 0.00118, "epss_percentile": 0.31416}, "CVE-2024-8264": {"epss_score": 0.00167, "epss_percentile": 0.38339}, "CVE-2024-8266": {"epss_score": 0.00052, "epss_percentile": 0.16465}, "CVE-2024-8267": {"epss_score": 0.00181, "epss_percentile": 0.40112}, "CVE-2024-8268": {"epss_score": 0.00269, "epss_percentile": 0.50104}, "CVE-2024-8269": {"epss_score": 0.00286, "epss_percentile": 0.51686}, "CVE-2024-8270": {"epss_score": 0.00016, "epss_percentile": 0.02762}, "CVE-2024-8271": {"epss_score": 0.01272, "epss_percentile": 0.79081}, "CVE-2024-8272": {"epss_score": 0.00033, "epss_percentile": 0.09336}, "CVE-2024-8273": {"epss_score": 0.00068, "epss_percentile": 0.21417}, "CVE-2024-8274": {"epss_score": 0.01873, "epss_percentile": 0.82645}, "CVE-2024-8275": {"epss_score": 0.83542, "epss_percentile": 0.99252}, "CVE-2024-8276": {"epss_score": 0.0026, "epss_percentile": 0.49229}, "CVE-2024-8277": {"epss_score": 0.45628, "epss_percentile": 0.97494}, "CVE-2024-8278": {"epss_score": 0.0031, "epss_percentile": 0.53784}, "CVE-2024-8279": {"epss_score": 0.00149, "epss_percentile": 0.35979}, "CVE-2024-8280": {"epss_score": 0.00291, "epss_percentile": 0.52148}, "CVE-2024-8281": {"epss_score": 0.00233, "epss_percentile": 0.46056}, "CVE-2024-8282": {"epss_score": 0.00181, "epss_percentile": 0.40033}, "CVE-2024-8283": {"epss_score": 0.00159, "epss_percentile": 0.37401}, "CVE-2024-8284": {"epss_score": 0.00026, "epss_percentile": 0.06556}, "CVE-2024-8285": {"epss_score": 0.00097, "epss_percentile": 0.27627}, "CVE-2024-8286": {"epss_score": 0.00032, "epss_percentile": 0.09094}, "CVE-2024-8287": {"epss_score": 0.00229, "epss_percentile": 0.45656}, "CVE-2024-8288": {"epss_score": 0.00266, "epss_percentile": 0.49896}, "CVE-2024-8289": {"epss_score": 0.07229, "epss_percentile": 0.91337}, "CVE-2024-8290": {"epss_score": 0.00847, "epss_percentile": 0.74349}, "CVE-2024-8291": {"epss_score": 0.0025, "epss_percentile": 0.48105}, "CVE-2024-8292": {"epss_score": 0.00627, "epss_percentile": 0.69631}, "CVE-2024-8294": {"epss_score": 0.00161, "epss_percentile": 0.37521}, "CVE-2024-8295": {"epss_score": 0.00147, "epss_percentile": 0.35685}, "CVE-2024-8296": {"epss_score": 0.00161, "epss_percentile": 0.37521}, "CVE-2024-8297": {"epss_score": 0.00177, "epss_percentile": 0.39514}, "CVE-2024-8298": {"epss_score": 0.00046, "epss_percentile": 0.14315}, "CVE-2024-8299": {"epss_score": 0.00024, "epss_percentile": 0.05741}, "CVE-2024-8300": {"epss_score": 0.00034, "epss_percentile": 0.09533}, "CVE-2024-8301": {"epss_score": 0.00048, "epss_percentile": 0.14956}, "CVE-2024-8302": {"epss_score": 0.00061, "epss_percentile": 0.19493}, "CVE-2024-8303": {"epss_score": 0.00027, "epss_percentile": 0.0698}, "CVE-2024-8304": {"epss_score": 0.00135, "epss_percentile": 0.34056}, "CVE-2024-8305": {"epss_score": 0.00287, "epss_percentile": 0.51839}, "CVE-2024-8306": {"epss_score": 0.00096, "epss_percentile": 0.27329}, "CVE-2024-8308": {"epss_score": 0.0005, "epss_percentile": 0.15657}, "CVE-2024-8309": {"epss_score": 0.02221, "epss_percentile": 0.84052}, "CVE-2024-8310": {"epss_score": 0.00029, "epss_percentile": 0.07594}, "CVE-2024-8311": {"epss_score": 0.00044, "epss_percentile": 0.13519}, "CVE-2024-8312": {"epss_score": 0.00638, "epss_percentile": 0.69904}, "CVE-2024-8313": {"epss_score": 0.0004, "epss_percentile": 0.11995}, "CVE-2024-8314": {"epss_score": 0.00065, "epss_percentile": 0.20448}, "CVE-2024-8315": {"epss_score": 0.00022, "epss_percentile": 0.05324}, "CVE-2024-8316": {"epss_score": 0.00147, "epss_percentile": 0.35661}, "CVE-2024-8317": {"epss_score": 0.00185, "epss_percentile": 0.40465}, "CVE-2024-8318": {"epss_score": 0.00172, "epss_percentile": 0.39012}, "CVE-2024-8319": {"epss_score": 0.00194, "epss_percentile": 0.41521}, "CVE-2024-8320": {"epss_score": 0.02162, "epss_percentile": 0.83827}, "CVE-2024-8321": {"epss_score": 0.00487, "epss_percentile": 0.64811}, "CVE-2024-8322": {"epss_score": 0.01555, "epss_percentile": 0.81013}, "CVE-2024-8323": {"epss_score": 0.00283, "epss_percentile": 0.51359}, "CVE-2024-8324": {"epss_score": 0.00316, "epss_percentile": 0.54297}, "CVE-2024-8325": {"epss_score": 0.00148, "epss_percentile": 0.35843}, "CVE-2024-8326": {"epss_score": 0.00769, "epss_percentile": 0.72992}, "CVE-2024-8327": {"epss_score": 0.01923, "epss_percentile": 0.8291}, "CVE-2024-8328": {"epss_score": 0.00294, "epss_percentile": 0.52386}, "CVE-2024-8329": {"epss_score": 0.01923, "epss_percentile": 0.8291}, "CVE-2024-8330": {"epss_score": 0.01428, "epss_percentile": 0.80219}, "CVE-2024-8331": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-8332": {"epss_score": 0.00094, "epss_percentile": 0.26968}, "CVE-2024-8334": {"epss_score": 0.00195, "epss_percentile": 0.41707}, "CVE-2024-8335": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-8336": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-8337": {"epss_score": 0.00131, "epss_percentile": 0.33487}, "CVE-2024-8338": {"epss_score": 0.00116, "epss_percentile": 0.31138}, "CVE-2024-8339": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-8340": {"epss_score": 0.00078, "epss_percentile": 0.2363}, "CVE-2024-8341": {"epss_score": 0.00116, "epss_percentile": 0.31138}, "CVE-2024-8342": {"epss_score": 0.00114, "epss_percentile": 0.30801}, "CVE-2024-8343": {"epss_score": 0.00076, "epss_percentile": 0.2327}, "CVE-2024-8344": {"epss_score": 0.00071, "epss_percentile": 0.22137}, "CVE-2024-8345": {"epss_score": 0.00076, "epss_percentile": 0.23278}, "CVE-2024-8346": {"epss_score": 0.00165, "epss_percentile": 0.38114}, "CVE-2024-8347": {"epss_score": 0.00165, "epss_percentile": 0.38114}, "CVE-2024-8348": {"epss_score": 0.00165, "epss_percentile": 0.38114}, "CVE-2024-8349": {"epss_score": 0.03072, "epss_percentile": 0.86351}, "CVE-2024-8350": {"epss_score": 0.00249, "epss_percentile": 0.48066}, "CVE-2024-8352": {"epss_score": 0.03293, "epss_percentile": 0.86839}, "CVE-2024-8353": {"epss_score": 0.91933, "epss_percentile": 0.99679}, "CVE-2024-8354": {"epss_score": 0.00045, "epss_percentile": 0.13812}, "CVE-2024-8355": {"epss_score": 0.00108, "epss_percentile": 0.29773}, "CVE-2024-8356": {"epss_score": 0.00036, "epss_percentile": 0.10162}, "CVE-2024-8357": {"epss_score": 0.00011, "epss_percentile": 0.01076}, "CVE-2024-8358": {"epss_score": 0.00367, "epss_percentile": 0.58133}, "CVE-2024-8359": {"epss_score": 0.00565, "epss_percentile": 0.67801}, "CVE-2024-8360": {"epss_score": 0.00856, "epss_percentile": 0.74477}, "CVE-2024-8361": {"epss_score": 0.00084, "epss_percentile": 0.24908}, "CVE-2024-8362": {"epss_score": 0.00479, "epss_percentile": 0.64437}, "CVE-2024-8363": {"epss_score": 0.00251, "epss_percentile": 0.4833}, "CVE-2024-8364": {"epss_score": 0.01156, "epss_percentile": 0.781}, "CVE-2024-8365": {"epss_score": 0.00255, "epss_percentile": 0.48719}, "CVE-2024-8366": {"epss_score": 0.00105, "epss_percentile": 0.29396}, "CVE-2024-8367": {"epss_score": 0.00057, "epss_percentile": 0.18169}, "CVE-2024-8368": {"epss_score": 0.00266, "epss_percentile": 0.49895}, "CVE-2024-8369": {"epss_score": 0.00665, "epss_percentile": 0.70669}, "CVE-2024-8370": {"epss_score": 0.00073, "epss_percentile": 0.22524}, "CVE-2024-8372": {"epss_score": 0.00018, "epss_percentile": 0.04006}, "CVE-2024-8373": {"epss_score": 0.00013, "epss_percentile": 0.01675}, "CVE-2024-8374": {"epss_score": 0.00098, "epss_percentile": 0.27773}, "CVE-2024-8375": {"epss_score": 0.00032, "epss_percentile": 0.09118}, "CVE-2024-8376": {"epss_score": 0.00295, "epss_percentile": 0.52477}, "CVE-2024-8378": {"epss_score": 0.00114, "epss_percentile": 0.3084}, "CVE-2024-8379": {"epss_score": 0.00617, "epss_percentile": 0.6934}, "CVE-2024-8380": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-8381": {"epss_score": 0.09578, "epss_percentile": 0.92606}, "CVE-2024-8382": {"epss_score": 0.00193, "epss_percentile": 0.4149}, "CVE-2024-8383": {"epss_score": 0.00242, "epss_percentile": 0.47385}, "CVE-2024-8384": {"epss_score": 0.00257, "epss_percentile": 0.48871}, "CVE-2024-8385": {"epss_score": 0.00205, "epss_percentile": 0.42672}, "CVE-2024-8386": {"epss_score": 0.002, "epss_percentile": 0.42202}, "CVE-2024-8387": {"epss_score": 0.004, "epss_percentile": 0.60153}, "CVE-2024-8388": {"epss_score": 0.0046, "epss_percentile": 0.63536}, "CVE-2024-8389": {"epss_score": 0.00301, "epss_percentile": 0.5305}, "CVE-2024-8391": {"epss_score": 0.00364, "epss_percentile": 0.57953}, "CVE-2024-8392": {"epss_score": 0.00227, "epss_percentile": 0.45446}, "CVE-2024-8393": {"epss_score": 0.0014, "epss_percentile": 0.34693}, "CVE-2024-8394": {"epss_score": 0.00363, "epss_percentile": 0.57861}, "CVE-2024-8395": {"epss_score": 0.00135, "epss_percentile": 0.33945}, "CVE-2024-8397": {"epss_score": 0.0008, "epss_percentile": 0.24199}, "CVE-2024-8398": {"epss_score": 0.00024, "epss_percentile": 0.05818}, "CVE-2024-8399": {"epss_score": 0.00222, "epss_percentile": 0.44841}, "CVE-2024-8400": {"epss_score": 0.00096, "epss_percentile": 0.27389}, "CVE-2024-8401": {"epss_score": 0.00061, "epss_percentile": 0.19439}, "CVE-2024-8402": {"epss_score": 0.00111, "epss_percentile": 0.30382}, "CVE-2024-8403": {"epss_score": 0.00607, "epss_percentile": 0.69031}, "CVE-2024-8404": {"epss_score": 0.00154, "epss_percentile": 0.3671}, "CVE-2024-8405": {"epss_score": 0.00208, "epss_percentile": 0.43241}, "CVE-2024-8407": {"epss_score": 0.00177, "epss_percentile": 0.39571}, "CVE-2024-8408": {"epss_score": 0.00216, "epss_percentile": 0.44238}, "CVE-2024-8409": {"epss_score": 0.00617, "epss_percentile": 0.69356}, "CVE-2024-8410": {"epss_score": 0.00549, "epss_percentile": 0.67321}, "CVE-2024-8411": {"epss_score": 0.00174, "epss_percentile": 0.39212}, "CVE-2024-8412": {"epss_score": 0.00192, "epss_percentile": 0.41283}, "CVE-2024-8413": {"epss_score": 0.00296, "epss_percentile": 0.52599}, "CVE-2024-8414": {"epss_score": 0.00149, "epss_percentile": 0.35953}, "CVE-2024-8415": {"epss_score": 0.00134, "epss_percentile": 0.33755}, "CVE-2024-8416": {"epss_score": 0.00134, "epss_percentile": 0.33755}, "CVE-2024-8417": {"epss_score": 0.00095, "epss_percentile": 0.27212}, "CVE-2024-8418": {"epss_score": 0.00102, "epss_percentile": 0.28822}, "CVE-2024-8419": {"epss_score": 0.0021, "epss_percentile": 0.43429}, "CVE-2024-8420": {"epss_score": 0.00482, "epss_percentile": 0.64555}, "CVE-2024-8422": {"epss_score": 0.00102, "epss_percentile": 0.28826}, "CVE-2024-8424": {"epss_score": 0.00039, "epss_percentile": 0.11701}, "CVE-2024-8425": {"epss_score": 0.62585, "epss_percentile": 0.98298}, "CVE-2024-8426": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-8427": {"epss_score": 0.00135, "epss_percentile": 0.34033}, "CVE-2024-8428": {"epss_score": 0.00132, "epss_percentile": 0.3362}, "CVE-2024-8429": {"epss_score": 0.00112, "epss_percentile": 0.30576}, "CVE-2024-8430": {"epss_score": 0.00397, "epss_percentile": 0.60028}, "CVE-2024-8431": {"epss_score": 0.00196, "epss_percentile": 0.41793}, "CVE-2024-8432": {"epss_score": 0.00228, "epss_percentile": 0.45515}, "CVE-2024-8433": {"epss_score": 0.00188, "epss_percentile": 0.4085}, "CVE-2024-8434": {"epss_score": 0.00232, "epss_percentile": 0.45939}, "CVE-2024-8436": {"epss_score": 0.00467, "epss_percentile": 0.63815}, "CVE-2024-8437": {"epss_score": 0.00133, "epss_percentile": 0.33738}, "CVE-2024-8438": {"epss_score": 0.00173, "epss_percentile": 0.39112}, "CVE-2024-8440": {"epss_score": 0.00265, "epss_percentile": 0.49788}, "CVE-2024-8441": {"epss_score": 0.00569, "epss_percentile": 0.6793}, "CVE-2024-8442": {"epss_score": 0.0022, "epss_percentile": 0.44619}, "CVE-2024-8443": {"epss_score": 0.00155, "epss_percentile": 0.36807}, "CVE-2024-8444": {"epss_score": 0.00245, "epss_percentile": 0.47705}, "CVE-2024-8445": {"epss_score": 0.00083, "epss_percentile": 0.2479}, "CVE-2024-8447": {"epss_score": 0.00306, "epss_percentile": 0.53407}, "CVE-2024-8448": {"epss_score": 0.0095, "epss_percentile": 0.75852}, "CVE-2024-8449": {"epss_score": 0.00162, "epss_percentile": 0.37638}, "CVE-2024-8450": {"epss_score": 0.01071, "epss_percentile": 0.77267}, "CVE-2024-8451": {"epss_score": 0.00863, "epss_percentile": 0.74591}, "CVE-2024-8452": {"epss_score": 0.00098, "epss_percentile": 0.27671}, "CVE-2024-8453": {"epss_score": 0.00102, "epss_percentile": 0.2881}, "CVE-2024-8454": {"epss_score": 0.00816, "epss_percentile": 0.73827}, "CVE-2024-8455": {"epss_score": 0.00155, "epss_percentile": 0.36837}, "CVE-2024-8456": {"epss_score": 0.0152, "epss_percentile": 0.8082}, "CVE-2024-8457": {"epss_score": 0.00116, "epss_percentile": 0.31139}, "CVE-2024-8458": {"epss_score": 0.01119, "epss_percentile": 0.77756}, "CVE-2024-8459": {"epss_score": 0.00102, "epss_percentile": 0.28783}, "CVE-2024-8460": {"epss_score": 0.01188, "epss_percentile": 0.78369}, "CVE-2024-8461": {"epss_score": 0.00928, "epss_percentile": 0.75585}, "CVE-2024-8462": {"epss_score": 0.00195, "epss_percentile": 0.41659}, "CVE-2024-8463": {"epss_score": 0.00077, "epss_percentile": 0.23536}, "CVE-2024-8464": {"epss_score": 0.00087, "epss_percentile": 0.25462}, "CVE-2024-8465": {"epss_score": 0.00087, "epss_percentile": 0.25462}, "CVE-2024-8466": {"epss_score": 0.00087, "epss_percentile": 0.25462}, "CVE-2024-8467": {"epss_score": 0.00087, "epss_percentile": 0.25462}, "CVE-2024-8468": {"epss_score": 0.00087, "epss_percentile": 0.25462}, "CVE-2024-8469": {"epss_score": 0.00087, "epss_percentile": 0.25462}, "CVE-2024-8470": {"epss_score": 0.00087, "epss_percentile": 0.25462}, "CVE-2024-8471": {"epss_score": 0.00142, "epss_percentile": 0.34987}, "CVE-2024-8472": {"epss_score": 0.00142, "epss_percentile": 0.34987}, "CVE-2024-8473": {"epss_score": 0.00154, "epss_percentile": 0.3672}, "CVE-2024-8474": {"epss_score": 0.00322, "epss_percentile": 0.54749}, "CVE-2024-8475": {"epss_score": 0.00064, "epss_percentile": 0.20337}, "CVE-2024-8476": {"epss_score": 0.00139, "epss_percentile": 0.34628}, "CVE-2024-8477": {"epss_score": 0.00213, "epss_percentile": 0.43835}, "CVE-2024-8478": {"epss_score": 0.01382, "epss_percentile": 0.7989}, "CVE-2024-8479": {"epss_score": 0.00846, "epss_percentile": 0.74324}, "CVE-2024-8480": {"epss_score": 0.0593, "epss_percentile": 0.90334}, "CVE-2024-8481": {"epss_score": 0.0106, "epss_percentile": 0.77168}, "CVE-2024-8482": {"epss_score": 0.00239, "epss_percentile": 0.46913}, "CVE-2024-8483": {"epss_score": 0.00427, "epss_percentile": 0.61899}, "CVE-2024-8484": {"epss_score": 0.86607, "epss_percentile": 0.99389}, "CVE-2024-8485": {"epss_score": 0.00238, "epss_percentile": 0.46745}, "CVE-2024-8486": {"epss_score": 0.00188, "epss_percentile": 0.40907}, "CVE-2024-8487": {"epss_score": 0.00046, "epss_percentile": 0.14458}, "CVE-2024-8488": {"epss_score": 0.00207, "epss_percentile": 0.43155}, "CVE-2024-8489": {"epss_score": 0.00032, "epss_percentile": 0.09002}, "CVE-2024-8490": {"epss_score": 0.0033, "epss_percentile": 0.55463}, "CVE-2024-8492": {"epss_score": 0.00048, "epss_percentile": 0.15095}, "CVE-2024-8493": {"epss_score": 0.00048, "epss_percentile": 0.15095}, "CVE-2024-8494": {"epss_score": 0.0016, "epss_percentile": 0.37436}, "CVE-2024-8495": {"epss_score": 0.04092, "epss_percentile": 0.88242}, "CVE-2024-8496": {"epss_score": 0.00059, "epss_percentile": 0.18707}, "CVE-2024-8497": {"epss_score": 0.00348, "epss_percentile": 0.56807}, "CVE-2024-8499": {"epss_score": 0.01478, "epss_percentile": 0.80554}, "CVE-2024-8500": {"epss_score": 0.00184, "epss_percentile": 0.40434}, "CVE-2024-8501": {"epss_score": 0.00164, "epss_percentile": 0.37894}, "CVE-2024-8502": {"epss_score": 0.00391, "epss_percentile": 0.59571}, "CVE-2024-8503": {"epss_score": 0.92519, "epss_percentile": 0.99723}, "CVE-2024-8504": {"epss_score": 0.92759, "epss_percentile": 0.99744}, "CVE-2024-8505": {"epss_score": 0.00204, "epss_percentile": 0.42659}, "CVE-2024-8507": {"epss_score": 0.00405, "epss_percentile": 0.60457}, "CVE-2024-8508": {"epss_score": 0.00228, "epss_percentile": 0.45475}, "CVE-2024-8509": {"epss_score": 0.00069, "epss_percentile": 0.21467}, "CVE-2024-8510": {"epss_score": 0.00177, "epss_percentile": 0.39627}, "CVE-2024-8512": {"epss_score": 0.13749, "epss_percentile": 0.94048}, "CVE-2024-8513": {"epss_score": 0.00609, "epss_percentile": 0.69125}, "CVE-2024-8514": {"epss_score": 0.01448, "epss_percentile": 0.80337}, "CVE-2024-8515": {"epss_score": 0.00333, "epss_percentile": 0.55614}, "CVE-2024-8516": {"epss_score": 0.00222, "epss_percentile": 0.44839}, "CVE-2024-8517": {"epss_score": 0.93228, "epss_percentile": 0.99786}, "CVE-2024-8518": {"epss_score": 0.00045, "epss_percentile": 0.13682}, "CVE-2024-8519": {"epss_score": 0.00298, "epss_percentile": 0.52812}, "CVE-2024-8520": {"epss_score": 0.00255, "epss_percentile": 0.48685}, "CVE-2024-8521": {"epss_score": 0.00284, "epss_percentile": 0.51465}, "CVE-2024-8522": {"epss_score": 0.86508, "epss_percentile": 0.99385}, "CVE-2024-8523": {"epss_score": 0.00678, "epss_percentile": 0.70988}, "CVE-2024-8524": {"epss_score": 0.00602, "epss_percentile": 0.68897}, "CVE-2024-8525": {"epss_score": 0.01496, "epss_percentile": 0.80685}, "CVE-2024-8526": {"epss_score": 0.00064, "epss_percentile": 0.20112}, "CVE-2024-8527": {"epss_score": 0.0002, "epss_percentile": 0.04511}, "CVE-2024-8528": {"epss_score": 0.00028, "epss_percentile": 0.07527}, "CVE-2024-8529": {"epss_score": 0.66954, "epss_percentile": 0.98487}, "CVE-2024-8530": {"epss_score": 0.00119, "epss_percentile": 0.3161}, "CVE-2024-8531": {"epss_score": 0.00049, "epss_percentile": 0.15503}, "CVE-2024-8533": {"epss_score": 0.00071, "epss_percentile": 0.22115}, "CVE-2024-8534": {"epss_score": 0.00865, "epss_percentile": 0.74626}, "CVE-2024-8535": {"epss_score": 0.00432, "epss_percentile": 0.62136}, "CVE-2024-8536": {"epss_score": 0.00394, "epss_percentile": 0.59794}, "CVE-2024-8537": {"epss_score": 0.00665, "epss_percentile": 0.70659}, "CVE-2024-8538": {"epss_score": 0.00276, "epss_percentile": 0.50768}, "CVE-2024-8539": {"epss_score": 0.00207, "epss_percentile": 0.43131}, "CVE-2024-8540": {"epss_score": 0.00117, "epss_percentile": 0.31369}, "CVE-2024-8541": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-8542": {"epss_score": 0.00026, "epss_percentile": 0.06556}, "CVE-2024-8543": {"epss_score": 0.00161, "epss_percentile": 0.37536}, "CVE-2024-8544": {"epss_score": 0.01148, "epss_percentile": 0.78014}, "CVE-2024-8546": {"epss_score": 0.00188, "epss_percentile": 0.40863}, "CVE-2024-8547": {"epss_score": 0.00144, "epss_percentile": 0.35285}, "CVE-2024-8548": {"epss_score": 0.00479, "epss_percentile": 0.6444}, "CVE-2024-8549": {"epss_score": 0.00919, "epss_percentile": 0.75452}, "CVE-2024-8550": {"epss_score": 0.00093, "epss_percentile": 0.26652}, "CVE-2024-8551": {"epss_score": 0.00216, "epss_percentile": 0.44171}, "CVE-2024-8552": {"epss_score": 0.00408, "epss_percentile": 0.60648}, "CVE-2024-8553": {"epss_score": 0.00109, "epss_percentile": 0.29944}, "CVE-2024-8554": {"epss_score": 0.00125, "epss_percentile": 0.32618}, "CVE-2024-8555": {"epss_score": 0.00142, "epss_percentile": 0.35008}, "CVE-2024-8556": {"epss_score": 0.00066, "epss_percentile": 0.2081}, "CVE-2024-8557": {"epss_score": 0.00071, "epss_percentile": 0.22084}, "CVE-2024-8558": {"epss_score": 0.00187, "epss_percentile": 0.40712}, "CVE-2024-8559": {"epss_score": 0.00067, "epss_percentile": 0.20965}, "CVE-2024-8560": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-8561": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-8562": {"epss_score": 0.00127, "epss_percentile": 0.32798}, "CVE-2024-8563": {"epss_score": 0.00127, "epss_percentile": 0.32798}, "CVE-2024-8564": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-8565": {"epss_score": 0.00076, "epss_percentile": 0.2327}, "CVE-2024-8566": {"epss_score": 0.00208, "epss_percentile": 0.43266}, "CVE-2024-8567": {"epss_score": 0.0004, "epss_percentile": 0.12003}, "CVE-2024-8568": {"epss_score": 0.0003, "epss_percentile": 0.08244}, "CVE-2024-8569": {"epss_score": 0.00347, "epss_percentile": 0.56747}, "CVE-2024-8570": {"epss_score": 0.00054, "epss_percentile": 0.17181}, "CVE-2024-8571": {"epss_score": 0.00109, "epss_percentile": 0.29963}, "CVE-2024-8572": {"epss_score": 0.00261, "epss_percentile": 0.49272}, "CVE-2024-8573": {"epss_score": 0.00218, "epss_percentile": 0.44339}, "CVE-2024-8574": {"epss_score": 0.02123, "epss_percentile": 0.83686}, "CVE-2024-8575": {"epss_score": 0.00218, "epss_percentile": 0.44339}, "CVE-2024-8576": {"epss_score": 0.00357, "epss_percentile": 0.57452}, "CVE-2024-8577": {"epss_score": 0.00357, "epss_percentile": 0.57452}, "CVE-2024-8578": {"epss_score": 0.00357, "epss_percentile": 0.57452}, "CVE-2024-8579": {"epss_score": 0.00357, "epss_percentile": 0.57452}, "CVE-2024-8580": {"epss_score": 0.00185, "epss_percentile": 0.40519}, "CVE-2024-8581": {"epss_score": 0.00201, "epss_percentile": 0.42381}, "CVE-2024-8582": {"epss_score": 0.00131, "epss_percentile": 0.33487}, "CVE-2024-8583": {"epss_score": 0.00131, "epss_percentile": 0.33487}, "CVE-2024-8584": {"epss_score": 0.0061, "epss_percentile": 0.69154}, "CVE-2024-8585": {"epss_score": 0.00067, "epss_percentile": 0.21049}, "CVE-2024-8586": {"epss_score": 0.00058, "epss_percentile": 0.18549}, "CVE-2024-8587": {"epss_score": 0.00132, "epss_percentile": 0.33536}, "CVE-2024-8588": {"epss_score": 0.00163, "epss_percentile": 0.37846}, "CVE-2024-8589": {"epss_score": 0.00163, "epss_percentile": 0.37846}, "CVE-2024-8590": {"epss_score": 0.00155, "epss_percentile": 0.36781}, "CVE-2024-8591": {"epss_score": 0.00078, "epss_percentile": 0.23772}, "CVE-2024-8592": {"epss_score": 0.00285, "epss_percentile": 0.51663}, "CVE-2024-8593": {"epss_score": 0.00125, "epss_percentile": 0.3253}, "CVE-2024-8594": {"epss_score": 0.00125, "epss_percentile": 0.3253}, "CVE-2024-8595": {"epss_score": 0.00155, "epss_percentile": 0.36781}, "CVE-2024-8596": {"epss_score": 0.00125, "epss_percentile": 0.3253}, "CVE-2024-8597": {"epss_score": 0.00125, "epss_percentile": 0.3253}, "CVE-2024-8598": {"epss_score": 0.00125, "epss_percentile": 0.3253}, "CVE-2024-8599": {"epss_score": 0.00125, "epss_percentile": 0.3253}, "CVE-2024-8600": {"epss_score": 0.00125, "epss_percentile": 0.3253}, "CVE-2024-8601": {"epss_score": 0.00056, "epss_percentile": 0.17807}, "CVE-2024-8602": {"epss_score": 0.00185, "epss_percentile": 0.40549}, "CVE-2024-8603": {"epss_score": 0.00081, "epss_percentile": 0.24329}, "CVE-2024-8604": {"epss_score": 0.00102, "epss_percentile": 0.28825}, "CVE-2024-8605": {"epss_score": 0.00189, "epss_percentile": 0.40921}, "CVE-2024-8606": {"epss_score": 0.00072, "epss_percentile": 0.22394}, "CVE-2024-8607": {"epss_score": 0.00061, "epss_percentile": 0.19335}, "CVE-2024-8608": {"epss_score": 0.00089, "epss_percentile": 0.25951}, "CVE-2024-8609": {"epss_score": 0.00058, "epss_percentile": 0.18361}, "CVE-2024-8610": {"epss_score": 0.0007, "epss_percentile": 0.21698}, "CVE-2024-8611": {"epss_score": 0.00056, "epss_percentile": 0.17693}, "CVE-2024-8612": {"epss_score": 0.00039, "epss_percentile": 0.11633}, "CVE-2024-8613": {"epss_score": 0.00072, "epss_percentile": 0.22458}, "CVE-2024-8614": {"epss_score": 0.12824, "epss_percentile": 0.93787}, "CVE-2024-8615": {"epss_score": 0.13363, "epss_percentile": 0.93942}, "CVE-2024-8616": {"epss_score": 0.00129, "epss_percentile": 0.33141}, "CVE-2024-8617": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-8618": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-8619": {"epss_score": 9e-05, "epss_percentile": 0.00659}, "CVE-2024-8620": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-8621": {"epss_score": 0.00461, "epss_percentile": 0.63551}, "CVE-2024-8622": {"epss_score": 0.00547, "epss_percentile": 0.67242}, "CVE-2024-8623": {"epss_score": 0.01945, "epss_percentile": 0.83}, "CVE-2024-8624": {"epss_score": 0.00529, "epss_percentile": 0.666}, "CVE-2024-8625": {"epss_score": 0.00566, "epss_percentile": 0.67823}, "CVE-2024-8626": {"epss_score": 0.00179, "epss_percentile": 0.39845}, "CVE-2024-8627": {"epss_score": 0.00145, "epss_percentile": 0.35418}, "CVE-2024-8628": {"epss_score": 0.00229, "epss_percentile": 0.45606}, "CVE-2024-8629": {"epss_score": 0.0136, "epss_percentile": 0.79749}, "CVE-2024-8630": {"epss_score": 0.00074, "epss_percentile": 0.22832}, "CVE-2024-8631": {"epss_score": 0.00016, "epss_percentile": 0.02783}, "CVE-2024-8632": {"epss_score": 0.00355, "epss_percentile": 0.57295}, "CVE-2024-8633": {"epss_score": 0.0023, "epss_percentile": 0.45694}, "CVE-2024-8635": {"epss_score": 0.00032, "epss_percentile": 0.0885}, "CVE-2024-8636": {"epss_score": 0.00296, "epss_percentile": 0.52606}, "CVE-2024-8637": {"epss_score": 0.00181, "epss_percentile": 0.40027}, "CVE-2024-8638": {"epss_score": 0.00122, "epss_percentile": 0.32143}, "CVE-2024-8639": {"epss_score": 0.00226, "epss_percentile": 0.45348}, "CVE-2024-8640": {"epss_score": 0.00173, "epss_percentile": 0.39119}, "CVE-2024-8641": {"epss_score": 0.00043, "epss_percentile": 0.13123}, "CVE-2024-8642": {"epss_score": 0.00085, "epss_percentile": 0.25062}, "CVE-2024-8643": {"epss_score": 0.00181, "epss_percentile": 0.40078}, "CVE-2024-8644": {"epss_score": 0.0009, "epss_percentile": 0.26171}, "CVE-2024-8645": {"epss_score": 0.0006, "epss_percentile": 0.19198}, "CVE-2024-8646": {"epss_score": 0.00573, "epss_percentile": 0.68045}, "CVE-2024-8647": {"epss_score": 0.0005, "epss_percentile": 0.159}, "CVE-2024-8648": {"epss_score": 0.02943, "epss_percentile": 0.86036}, "CVE-2024-8650": {"epss_score": 0.00017, "epss_percentile": 0.03415}, "CVE-2024-8651": {"epss_score": 0.0017, "epss_percentile": 0.3866}, "CVE-2024-8652": {"epss_score": 0.00122, "epss_percentile": 0.32155}, "CVE-2024-8653": {"epss_score": 0.00122, "epss_percentile": 0.32155}, "CVE-2024-8654": {"epss_score": 0.00333, "epss_percentile": 0.5568}, "CVE-2024-8655": {"epss_score": 0.00158, "epss_percentile": 0.37289}, "CVE-2024-8656": {"epss_score": 0.00721, "epss_percentile": 0.7198}, "CVE-2024-8657": {"epss_score": 0.00369, "epss_percentile": 0.58241}, "CVE-2024-8658": {"epss_score": 0.00218, "epss_percentile": 0.44395}, "CVE-2024-8660": {"epss_score": 0.00229, "epss_percentile": 0.45612}, "CVE-2024-8661": {"epss_score": 0.00397, "epss_percentile": 0.60019}, "CVE-2024-8662": {"epss_score": 0.02628, "epss_percentile": 0.85272}, "CVE-2024-8663": {"epss_score": 0.02628, "epss_percentile": 0.85272}, "CVE-2024-8664": {"epss_score": 0.02068, "epss_percentile": 0.83466}, "CVE-2024-8665": {"epss_score": 0.00768, "epss_percentile": 0.72977}, "CVE-2024-8666": {"epss_score": 0.00243, "epss_percentile": 0.47484}, "CVE-2024-8667": {"epss_score": 0.00245, "epss_percentile": 0.47626}, "CVE-2024-8668": {"epss_score": 0.00135, "epss_percentile": 0.33968}, "CVE-2024-8669": {"epss_score": 0.04843, "epss_percentile": 0.89204}, "CVE-2024-8670": {"epss_score": 0.00065, "epss_percentile": 0.20575}, "CVE-2024-8671": {"epss_score": 0.07688, "epss_percentile": 0.91627}, "CVE-2024-8672": {"epss_score": 0.69696, "epss_percentile": 0.98599}, "CVE-2024-8673": {"epss_score": 0.06683, "epss_percentile": 0.9094}, "CVE-2024-8675": {"epss_score": 0.00122, "epss_percentile": 0.32104}, "CVE-2024-8676": {"epss_score": 0.00202, "epss_percentile": 0.42456}, "CVE-2024-8678": {"epss_score": 0.00237, "epss_percentile": 0.46693}, "CVE-2024-8679": {"epss_score": 0.0029, "epss_percentile": 0.52085}, "CVE-2024-8680": {"epss_score": 0.00198, "epss_percentile": 0.42012}, "CVE-2024-8681": {"epss_score": 0.00431, "epss_percentile": 0.62058}, "CVE-2024-8682": {"epss_score": 0.00216, "epss_percentile": 0.44143}, "CVE-2024-8684": {"epss_score": 0.00694, "epss_percentile": 0.71363}, "CVE-2024-8685": {"epss_score": 0.00144, "epss_percentile": 0.35327}, "CVE-2024-8686": {"epss_score": 0.00203, "epss_percentile": 0.42545}, "CVE-2024-8687": {"epss_score": 0.00282, "epss_percentile": 0.51264}, "CVE-2024-8688": {"epss_score": 0.00124, "epss_percentile": 0.32341}, "CVE-2024-8689": {"epss_score": 0.00076, "epss_percentile": 0.23216}, "CVE-2024-8690": {"epss_score": 0.00046, "epss_percentile": 0.14423}, "CVE-2024-8691": {"epss_score": 0.00257, "epss_percentile": 0.48853}, "CVE-2024-8692": {"epss_score": 0.00133, "epss_percentile": 0.33741}, "CVE-2024-8693": {"epss_score": 0.00096, "epss_percentile": 0.27398}, "CVE-2024-8694": {"epss_score": 0.00157, "epss_percentile": 0.37125}, "CVE-2024-8695": {"epss_score": 0.05921, "epss_percentile": 0.90322}, "CVE-2024-8696": {"epss_score": 0.05921, "epss_percentile": 0.90322}, "CVE-2024-8698": {"epss_score": 0.80217, "epss_percentile": 0.99077}, "CVE-2024-8699": {"epss_score": 0.00174, "epss_percentile": 0.39215}, "CVE-2024-8700": {"epss_score": 0.00143, "epss_percentile": 0.35097}, "CVE-2024-8701": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-8702": {"epss_score": 0.00054, "epss_percentile": 0.17287}, "CVE-2024-8703": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2024-8704": {"epss_score": 0.00348, "epss_percentile": 0.56822}, "CVE-2024-8705": {"epss_score": 0.00019, "epss_percentile": 0.0426}, "CVE-2024-8706": {"epss_score": 0.00776, "epss_percentile": 0.73103}, "CVE-2024-8707": {"epss_score": 0.00112, "epss_percentile": 0.3051}, "CVE-2024-8708": {"epss_score": 0.0018, "epss_percentile": 0.39924}, "CVE-2024-8709": {"epss_score": 0.00183, "epss_percentile": 0.40337}, "CVE-2024-8710": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-8711": {"epss_score": 0.00142, "epss_percentile": 0.35004}, "CVE-2024-8712": {"epss_score": 0.01354, "epss_percentile": 0.79701}, "CVE-2024-8713": {"epss_score": 0.00993, "epss_percentile": 0.76418}, "CVE-2024-8714": {"epss_score": 0.0079, "epss_percentile": 0.73367}, "CVE-2024-8715": {"epss_score": 0.00928, "epss_percentile": 0.75581}, "CVE-2024-8716": {"epss_score": 0.01051, "epss_percentile": 0.77084}, "CVE-2024-8717": {"epss_score": 0.01453, "epss_percentile": 0.80375}, "CVE-2024-8718": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-8719": {"epss_score": 0.01474, "epss_percentile": 0.8052}, "CVE-2024-8720": {"epss_score": 0.00148, "epss_percentile": 0.35843}, "CVE-2024-8721": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-8722": {"epss_score": 0.00095, "epss_percentile": 0.27098}, "CVE-2024-8723": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2024-8724": {"epss_score": 0.0136, "epss_percentile": 0.79749}, "CVE-2024-8725": {"epss_score": 0.00233, "epss_percentile": 0.46059}, "CVE-2024-8726": {"epss_score": 0.01122, "epss_percentile": 0.77785}, "CVE-2024-8727": {"epss_score": 0.01045, "epss_percentile": 0.77023}, "CVE-2024-8728": {"epss_score": 0.01045, "epss_percentile": 0.77023}, "CVE-2024-8729": {"epss_score": 0.01608, "epss_percentile": 0.81313}, "CVE-2024-8730": {"epss_score": 0.01601, "epss_percentile": 0.81266}, "CVE-2024-8731": {"epss_score": 0.01474, "epss_percentile": 0.8052}, "CVE-2024-8732": {"epss_score": 0.01905, "epss_percentile": 0.82795}, "CVE-2024-8733": {"epss_score": 0.00039, "epss_percentile": 0.11775}, "CVE-2024-8734": {"epss_score": 0.01474, "epss_percentile": 0.8052}, "CVE-2024-8735": {"epss_score": 0.00833, "epss_percentile": 0.74086}, "CVE-2024-8736": {"epss_score": 0.00064, "epss_percentile": 0.20334}, "CVE-2024-8737": {"epss_score": 0.02068, "epss_percentile": 0.83466}, "CVE-2024-8738": {"epss_score": 0.0285, "epss_percentile": 0.85829}, "CVE-2024-8739": {"epss_score": 0.02793, "epss_percentile": 0.85673}, "CVE-2024-8740": {"epss_score": 0.01601, "epss_percentile": 0.81266}, "CVE-2024-8741": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-8742": {"epss_score": 0.00401, "epss_percentile": 0.60245}, "CVE-2024-8743": {"epss_score": 0.2823, "epss_percentile": 0.96335}, "CVE-2024-8746": {"epss_score": 0.03266, "epss_percentile": 0.86783}, "CVE-2024-8747": {"epss_score": 0.00163, "epss_percentile": 0.37856}, "CVE-2024-8748": {"epss_score": 0.00275, "epss_percentile": 0.50669}, "CVE-2024-8749": {"epss_score": 0.00081, "epss_percentile": 0.24272}, "CVE-2024-8750": {"epss_score": 0.00155, "epss_percentile": 0.36782}, "CVE-2024-8751": {"epss_score": 0.00109, "epss_percentile": 0.29941}, "CVE-2024-8752": {"epss_score": 0.91149, "epss_percentile": 0.99623}, "CVE-2024-8754": {"epss_score": 0.0002, "epss_percentile": 0.04421}, "CVE-2024-8755": {"epss_score": 0.00608, "epss_percentile": 0.6907}, "CVE-2024-8756": {"epss_score": 0.00463, "epss_percentile": 0.63689}, "CVE-2024-8757": {"epss_score": 0.00639, "epss_percentile": 0.6995}, "CVE-2024-8758": {"epss_score": 0.00187, "epss_percentile": 0.40793}, "CVE-2024-8759": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-8760": {"epss_score": 0.00667, "epss_percentile": 0.70708}, "CVE-2024-8761": {"epss_score": 0.00187, "epss_percentile": 0.40701}, "CVE-2024-8762": {"epss_score": 0.00082, "epss_percentile": 0.2457}, "CVE-2024-8763": {"epss_score": 0.00113, "epss_percentile": 0.30645}, "CVE-2024-8764": {"epss_score": 0.00113, "epss_percentile": 0.30645}, "CVE-2024-8765": {"epss_score": 0.00172, "epss_percentile": 0.3891}, "CVE-2024-8766": {"epss_score": 0.00041, "epss_percentile": 0.12263}, "CVE-2024-8767": {"epss_score": 0.00365, "epss_percentile": 0.57991}, "CVE-2024-8768": {"epss_score": 0.00095, "epss_percentile": 0.27093}, "CVE-2024-8769": {"epss_score": 0.00637, "epss_percentile": 0.69884}, "CVE-2024-8770": {"epss_score": 0.00316, "epss_percentile": 0.5429}, "CVE-2024-8771": {"epss_score": 0.00303, "epss_percentile": 0.53169}, "CVE-2024-8772": {"epss_score": 0.00073, "epss_percentile": 0.22565}, "CVE-2024-8773": {"epss_score": 0.00097, "epss_percentile": 0.27517}, "CVE-2024-8774": {"epss_score": 0.00053, "epss_percentile": 0.16828}, "CVE-2024-8775": {"epss_score": 0.00029, "epss_percentile": 0.07753}, "CVE-2024-8776": {"epss_score": 0.00133, "epss_percentile": 0.33664}, "CVE-2024-8777": {"epss_score": 0.00123, "epss_percentile": 0.32251}, "CVE-2024-8778": {"epss_score": 0.00114, "epss_percentile": 0.30736}, "CVE-2024-8779": {"epss_score": 0.0041, "epss_percentile": 0.60842}, "CVE-2024-8780": {"epss_score": 0.00112, "epss_percentile": 0.30444}, "CVE-2024-8781": {"epss_score": 0.00018, "epss_percentile": 0.03717}, "CVE-2024-8782": {"epss_score": 0.00084, "epss_percentile": 0.24986}, "CVE-2024-8783": {"epss_score": 0.00224, "epss_percentile": 0.45074}, "CVE-2024-8784": {"epss_score": 0.00044, "epss_percentile": 0.13557}, "CVE-2024-8785": {"epss_score": 0.11016, "epss_percentile": 0.9319}, "CVE-2024-8786": {"epss_score": 0.0148, "epss_percentile": 0.80565}, "CVE-2024-8787": {"epss_score": 0.00905, "epss_percentile": 0.75237}, "CVE-2024-8788": {"epss_score": 0.00928, "epss_percentile": 0.75581}, "CVE-2024-8789": {"epss_score": 0.00113, "epss_percentile": 0.30645}, "CVE-2024-8790": {"epss_score": 0.01474, "epss_percentile": 0.8052}, "CVE-2024-8791": {"epss_score": 0.00212, "epss_percentile": 0.43802}, "CVE-2024-8792": {"epss_score": 0.01315, "epss_percentile": 0.794}, "CVE-2024-8793": {"epss_score": 0.01616, "epss_percentile": 0.81354}, "CVE-2024-8794": {"epss_score": 0.00379, "epss_percentile": 0.58883}, "CVE-2024-8795": {"epss_score": 0.00381, "epss_percentile": 0.58975}, "CVE-2024-8796": {"epss_score": 0.00236, "epss_percentile": 0.46405}, "CVE-2024-8797": {"epss_score": 0.01287, "epss_percentile": 0.79192}, "CVE-2024-8798": {"epss_score": 0.00283, "epss_percentile": 0.51345}, "CVE-2024-8799": {"epss_score": 0.02047, "epss_percentile": 0.83388}, "CVE-2024-8800": {"epss_score": 0.01478, "epss_percentile": 0.80554}, "CVE-2024-8801": {"epss_score": 0.00246, "epss_percentile": 0.47773}, "CVE-2024-8802": {"epss_score": 0.01334, "epss_percentile": 0.79534}, "CVE-2024-8803": {"epss_score": 0.02078, "epss_percentile": 0.83518}, "CVE-2024-8804": {"epss_score": 0.00148, "epss_percentile": 0.35843}, "CVE-2024-8805": {"epss_score": 0.01922, "epss_percentile": 0.82907}, "CVE-2024-8806": {"epss_score": 0.03348, "epss_percentile": 0.86956}, "CVE-2024-8807": {"epss_score": 0.01751, "epss_percentile": 0.82103}, "CVE-2024-8808": {"epss_score": 0.0458, "epss_percentile": 0.88874}, "CVE-2024-8809": {"epss_score": 0.0458, "epss_percentile": 0.88874}, "CVE-2024-8810": {"epss_score": 0.00059, "epss_percentile": 0.18819}, "CVE-2024-8811": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2024-8812": {"epss_score": 0.00519, "epss_percentile": 0.66152}, "CVE-2024-8813": {"epss_score": 0.00519, "epss_percentile": 0.66152}, "CVE-2024-8814": {"epss_score": 0.00519, "epss_percentile": 0.66152}, "CVE-2024-8815": {"epss_score": 0.00519, "epss_percentile": 0.66152}, "CVE-2024-8816": {"epss_score": 0.00171, "epss_percentile": 0.38889}, "CVE-2024-8817": {"epss_score": 0.00519, "epss_percentile": 0.66152}, "CVE-2024-8818": {"epss_score": 0.00642, "epss_percentile": 0.70035}, "CVE-2024-8819": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8820": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8821": {"epss_score": 0.00111, "epss_percentile": 0.30345}, "CVE-2024-8822": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8823": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8824": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8825": {"epss_score": 0.00337, "epss_percentile": 0.56034}, "CVE-2024-8826": {"epss_score": 0.00337, "epss_percentile": 0.56034}, "CVE-2024-8827": {"epss_score": 0.00337, "epss_percentile": 0.56034}, "CVE-2024-8828": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8829": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8830": {"epss_score": 0.00337, "epss_percentile": 0.56034}, "CVE-2024-8831": {"epss_score": 0.00337, "epss_percentile": 0.56034}, "CVE-2024-8832": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8833": {"epss_score": 0.00337, "epss_percentile": 0.56034}, "CVE-2024-8834": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8835": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8836": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8837": {"epss_score": 0.00337, "epss_percentile": 0.56034}, "CVE-2024-8838": {"epss_score": 0.00657, "epss_percentile": 0.70473}, "CVE-2024-8839": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8840": {"epss_score": 0.00337, "epss_percentile": 0.56034}, "CVE-2024-8841": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2024-8842": {"epss_score": 0.00374, "epss_percentile": 0.58555}, "CVE-2024-8843": {"epss_score": 0.00072, "epss_percentile": 0.22359}, "CVE-2024-8844": {"epss_score": 0.00072, "epss_percentile": 0.22359}, "CVE-2024-8845": {"epss_score": 0.00072, "epss_percentile": 0.22359}, "CVE-2024-8846": {"epss_score": 0.00094, "epss_percentile": 0.26985}, "CVE-2024-8847": {"epss_score": 0.00295, "epss_percentile": 0.52519}, "CVE-2024-8848": {"epss_score": 0.00103, "epss_percentile": 0.28987}, "CVE-2024-8849": {"epss_score": 0.00079, "epss_percentile": 0.23835}, "CVE-2024-8850": {"epss_score": 0.00928, "epss_percentile": 0.75581}, "CVE-2024-8851": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2024-8852": {"epss_score": 0.08043, "epss_percentile": 0.91848}, "CVE-2024-8853": {"epss_score": 0.00302, "epss_percentile": 0.53138}, "CVE-2024-8854": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2024-8855": {"epss_score": 0.00103, "epss_percentile": 0.29098}, "CVE-2024-8856": {"epss_score": 0.93045, "epss_percentile": 0.9977}, "CVE-2024-8857": {"epss_score": 0.00021, "epss_percentile": 0.04823}, "CVE-2024-8858": {"epss_score": 0.00188, "epss_percentile": 0.4085}, "CVE-2024-8859": {"epss_score": 0.16065, "epss_percentile": 0.94566}, "CVE-2024-8860": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2024-8861": {"epss_score": 0.00188, "epss_percentile": 0.40907}, "CVE-2024-8862": {"epss_score": 0.01504, "epss_percentile": 0.8074}, "CVE-2024-8863": {"epss_score": 0.00175, "epss_percentile": 0.39323}, "CVE-2024-8864": {"epss_score": 0.00102, "epss_percentile": 0.28746}, "CVE-2024-8865": {"epss_score": 0.00239, "epss_percentile": 0.46911}, "CVE-2024-8866": {"epss_score": 0.00141, "epss_percentile": 0.34931}, "CVE-2024-8867": {"epss_score": 0.00106, "epss_percentile": 0.29434}, "CVE-2024-8868": {"epss_score": 0.00184, "epss_percentile": 0.40458}, "CVE-2024-8869": {"epss_score": 0.00214, "epss_percentile": 0.44021}, "CVE-2024-8870": {"epss_score": 0.00594, "epss_percentile": 0.68655}, "CVE-2024-8871": {"epss_score": 0.01035, "epss_percentile": 0.76906}, "CVE-2024-8872": {"epss_score": 0.00928, "epss_percentile": 0.75581}, "CVE-2024-8873": {"epss_score": 0.013, "epss_percentile": 0.79287}, "CVE-2024-8874": {"epss_score": 0.00712, "epss_percentile": 0.71758}, "CVE-2024-8875": {"epss_score": 0.00133, "epss_percentile": 0.33658}, "CVE-2024-8876": {"epss_score": 0.00352, "epss_percentile": 0.57127}, "CVE-2024-8877": {"epss_score": 0.82236, "epss_percentile": 0.99182}, "CVE-2024-8878": {"epss_score": 0.00542, "epss_percentile": 0.67085}, "CVE-2024-8880": {"epss_score": 0.00094, "epss_percentile": 0.26768}, "CVE-2024-8881": {"epss_score": 0.00144, "epss_percentile": 0.35279}, "CVE-2024-8882": {"epss_score": 0.00095, "epss_percentile": 0.27101}, "CVE-2024-8883": {"epss_score": 0.0339, "epss_percentile": 0.87049}, "CVE-2024-8884": {"epss_score": 0.00139, "epss_percentile": 0.34608}, "CVE-2024-8885": {"epss_score": 0.00031, "epss_percentile": 0.08566}, "CVE-2024-8887": {"epss_score": 0.00074, "epss_percentile": 0.22768}, "CVE-2024-8888": {"epss_score": 0.00203, "epss_percentile": 0.42491}, "CVE-2024-8889": {"epss_score": 0.0023, "epss_percentile": 0.45762}, "CVE-2024-8890": {"epss_score": 0.0009, "epss_percentile": 0.26052}, "CVE-2024-8891": {"epss_score": 0.00176, "epss_percentile": 0.39457}, "CVE-2024-8892": {"epss_score": 0.0019, "epss_percentile": 0.4105}, "CVE-2024-8893": {"epss_score": 0.00121, "epss_percentile": 0.31914}, "CVE-2024-8894": {"epss_score": 0.00047, "epss_percentile": 0.14494}, "CVE-2024-8896": {"epss_score": 0.00245, "epss_percentile": 0.47729}, "CVE-2024-8897": {"epss_score": 0.10374, "epss_percentile": 0.92964}, "CVE-2024-8898": {"epss_score": 0.00107, "epss_percentile": 0.29693}, "CVE-2024-8899": {"epss_score": 0.0012, "epss_percentile": 0.31743}, "CVE-2024-8900": {"epss_score": 0.00198, "epss_percentile": 0.42093}, "CVE-2024-8901": {"epss_score": 0.00039, "epss_percentile": 0.11837}, "CVE-2024-8902": {"epss_score": 0.00212, "epss_percentile": 0.4374}, "CVE-2024-8903": {"epss_score": 0.00049, "epss_percentile": 0.15557}, "CVE-2024-8904": {"epss_score": 0.0027, "epss_percentile": 0.50218}, "CVE-2024-8905": {"epss_score": 0.00294, "epss_percentile": 0.52413}, "CVE-2024-8906": {"epss_score": 0.00085, "epss_percentile": 0.25139}, "CVE-2024-8907": {"epss_score": 0.00069, "epss_percentile": 0.21577}, "CVE-2024-8908": {"epss_score": 0.0012, "epss_percentile": 0.317}, "CVE-2024-8909": {"epss_score": 0.00105, "epss_percentile": 0.29335}, "CVE-2024-8910": {"epss_score": 0.00169, "epss_percentile": 0.38551}, "CVE-2024-8911": {"epss_score": 0.00774, "epss_percentile": 0.73076}, "CVE-2024-8912": {"epss_score": 0.00112, "epss_percentile": 0.30488}, "CVE-2024-8913": {"epss_score": 0.00212, "epss_percentile": 0.4374}, "CVE-2024-8914": {"epss_score": 0.00444, "epss_percentile": 0.6283}, "CVE-2024-8915": {"epss_score": 0.00187, "epss_percentile": 0.40742}, "CVE-2024-8916": {"epss_score": 0.00161, "epss_percentile": 0.37556}, "CVE-2024-8917": {"epss_score": 0.00119, "epss_percentile": 0.31591}, "CVE-2024-8918": {"epss_score": 0.00827, "epss_percentile": 0.73977}, "CVE-2024-8919": {"epss_score": 0.00161, "epss_percentile": 0.37536}, "CVE-2024-8920": {"epss_score": 0.00188, "epss_percentile": 0.40841}, "CVE-2024-8921": {"epss_score": 0.00209, "epss_percentile": 0.43378}, "CVE-2024-8922": {"epss_score": 0.01953, "epss_percentile": 0.83025}, "CVE-2024-8923": {"epss_score": 0.0083, "epss_percentile": 0.74027}, "CVE-2024-8924": {"epss_score": 0.00597, "epss_percentile": 0.68738}, "CVE-2024-8925": {"epss_score": 0.01777, "epss_percentile": 0.82224}, "CVE-2024-8926": {"epss_score": 0.02149, "epss_percentile": 0.83776}, "CVE-2024-8927": {"epss_score": 0.00331, "epss_percentile": 0.55532}, "CVE-2024-8929": {"epss_score": 0.00143, "epss_percentile": 0.35219}, "CVE-2024-8932": {"epss_score": 0.00377, "epss_percentile": 0.58699}, "CVE-2024-8933": {"epss_score": 0.00052, "epss_percentile": 0.16595}, "CVE-2024-8934": {"epss_score": 0.00084, "epss_percentile": 0.25021}, "CVE-2024-8935": {"epss_score": 0.00018, "epss_percentile": 0.03959}, "CVE-2024-8936": {"epss_score": 0.00077, "epss_percentile": 0.23362}, "CVE-2024-8937": {"epss_score": 0.00075, "epss_percentile": 0.229}, "CVE-2024-8938": {"epss_score": 0.00138, "epss_percentile": 0.34511}, "CVE-2024-8939": {"epss_score": 0.00039, "epss_percentile": 0.11723}, "CVE-2024-8940": {"epss_score": 0.00113, "epss_percentile": 0.3064}, "CVE-2024-8941": {"epss_score": 0.00069, "epss_percentile": 0.21433}, "CVE-2024-8942": {"epss_score": 0.00072, "epss_percentile": 0.22466}, "CVE-2024-8943": {"epss_score": 0.00397, "epss_percentile": 0.60017}, "CVE-2024-8944": {"epss_score": 0.00234, "epss_percentile": 0.4615}, "CVE-2024-8945": {"epss_score": 0.00608, "epss_percentile": 0.69072}, "CVE-2024-8946": {"epss_score": 0.00119, "epss_percentile": 0.31557}, "CVE-2024-8947": {"epss_score": 0.00142, "epss_percentile": 0.35083}, "CVE-2024-8948": {"epss_score": 0.0012, "epss_percentile": 0.31807}, "CVE-2024-8949": {"epss_score": 0.01173, "epss_percentile": 0.78239}, "CVE-2024-8950": {"epss_score": 0.0012, "epss_percentile": 0.31737}, "CVE-2024-8951": {"epss_score": 0.00168, "epss_percentile": 0.38452}, "CVE-2024-8952": {"epss_score": 0.00083, "epss_percentile": 0.24639}, "CVE-2024-8953": {"epss_score": 0.00295, "epss_percentile": 0.52525}, "CVE-2024-8954": {"epss_score": 0.00179, "epss_percentile": 0.39749}, "CVE-2024-8955": {"epss_score": 0.00083, "epss_percentile": 0.24639}, "CVE-2024-8956": {"epss_score": 0.83611, "epss_percentile": 0.99254}, "CVE-2024-8957": {"epss_score": 0.55516, "epss_percentile": 0.97981}, "CVE-2024-8958": {"epss_score": 0.00952, "epss_percentile": 0.75872}, "CVE-2024-8959": {"epss_score": 0.00183, "epss_percentile": 0.40359}, "CVE-2024-8960": {"epss_score": 0.00184, "epss_percentile": 0.40379}, "CVE-2024-8961": {"epss_score": 0.0026, "epss_percentile": 0.49171}, "CVE-2024-8962": {"epss_score": 0.00058, "epss_percentile": 0.18353}, "CVE-2024-8963": {"epss_score": 0.94225, "epss_percentile": 0.9992}, "CVE-2024-8964": {"epss_score": 0.00204, "epss_percentile": 0.42659}, "CVE-2024-8965": {"epss_score": 0.00179, "epss_percentile": 0.39771}, "CVE-2024-8966": {"epss_score": 0.00199, "epss_percentile": 0.42181}, "CVE-2024-8967": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-8968": {"epss_score": 0.0021, "epss_percentile": 0.43467}, "CVE-2024-8969": {"epss_score": 0.00207, "epss_percentile": 0.43093}, "CVE-2024-8970": {"epss_score": 0.00057, "epss_percentile": 0.18182}, "CVE-2024-8972": {"epss_score": 0.00123, "epss_percentile": 0.32291}, "CVE-2024-8973": {"epss_score": 0.00052, "epss_percentile": 0.16604}, "CVE-2024-8974": {"epss_score": 0.00047, "epss_percentile": 0.14488}, "CVE-2024-8975": {"epss_score": 0.00072, "epss_percentile": 0.22368}, "CVE-2024-8977": {"epss_score": 0.00054, "epss_percentile": 0.17175}, "CVE-2024-8978": {"epss_score": 0.00658, "epss_percentile": 0.7048}, "CVE-2024-8979": {"epss_score": 0.00881, "epss_percentile": 0.74872}, "CVE-2024-8980": {"epss_score": 0.00281, "epss_percentile": 0.51107}, "CVE-2024-8981": {"epss_score": 0.01748, "epss_percentile": 0.82079}, "CVE-2024-8982": {"epss_score": 0.00032, "epss_percentile": 0.08955}, "CVE-2024-8983": {"epss_score": 0.0015, "epss_percentile": 0.36095}, "CVE-2024-8984": {"epss_score": 0.00182, "epss_percentile": 0.40201}, "CVE-2024-8985": {"epss_score": 0.00164, "epss_percentile": 0.37952}, "CVE-2024-8986": {"epss_score": 0.00065, "epss_percentile": 0.20602}, "CVE-2024-8987": {"epss_score": 0.00289, "epss_percentile": 0.52076}, "CVE-2024-8988": {"epss_score": 0.00039, "epss_percentile": 0.11672}, "CVE-2024-8989": {"epss_score": 0.00187, "epss_percentile": 0.40803}, "CVE-2024-8990": {"epss_score": 0.00261, "epss_percentile": 0.49288}, "CVE-2024-8991": {"epss_score": 0.00608, "epss_percentile": 0.69064}, "CVE-2024-8992": {"epss_score": 0.00041, "epss_percentile": 0.12273}, "CVE-2024-8993": {"epss_score": 0.00043, "epss_percentile": 0.13057}, "CVE-2024-8994": {"epss_score": 0.00043, "epss_percentile": 0.13057}, "CVE-2024-8996": {"epss_score": 0.0006, "epss_percentile": 0.19208}, "CVE-2024-8997": {"epss_score": 0.00093, "epss_percentile": 0.26629}, "CVE-2024-8998": {"epss_score": 0.00113, "epss_percentile": 0.30645}, "CVE-2024-8999": {"epss_score": 0.00107, "epss_percentile": 0.29726}, "CVE-2024-9000": {"epss_score": 0.00029, "epss_percentile": 0.07927}, "CVE-2024-9001": {"epss_score": 0.00972, "epss_percentile": 0.76131}, "CVE-2024-9002": {"epss_score": 0.0004, "epss_percentile": 0.12188}, "CVE-2024-9003": {"epss_score": 0.00099, "epss_percentile": 0.28306}, "CVE-2024-9004": {"epss_score": 0.1267, "epss_percentile": 0.93745}, "CVE-2024-9005": {"epss_score": 0.00172, "epss_percentile": 0.38927}, "CVE-2024-9006": {"epss_score": 0.00176, "epss_percentile": 0.39458}, "CVE-2024-9007": {"epss_score": 0.02767, "epss_percentile": 0.85613}, "CVE-2024-9008": {"epss_score": 0.00082, "epss_percentile": 0.2457}, "CVE-2024-9009": {"epss_score": 0.00077, "epss_percentile": 0.23407}, "CVE-2024-9011": {"epss_score": 0.00077, "epss_percentile": 0.23407}, "CVE-2024-9014": {"epss_score": 0.92822, "epss_percentile": 0.99752}, "CVE-2024-9017": {"epss_score": 0.00032, "epss_percentile": 0.08831}, "CVE-2024-9018": {"epss_score": 0.00478, "epss_percentile": 0.64409}, "CVE-2024-9019": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2024-9020": {"epss_score": 0.00069, "epss_percentile": 0.21635}, "CVE-2024-9021": {"epss_score": 0.00487, "epss_percentile": 0.6481}, "CVE-2024-9022": {"epss_score": 0.01112, "epss_percentile": 0.77682}, "CVE-2024-9023": {"epss_score": 0.00124, "epss_percentile": 0.32353}, "CVE-2024-9024": {"epss_score": 0.00124, "epss_percentile": 0.32353}, "CVE-2024-9025": {"epss_score": 0.00291, "epss_percentile": 0.52201}, "CVE-2024-9026": {"epss_score": 0.0077, "epss_percentile": 0.73003}, "CVE-2024-9027": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-9028": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-9029": {"epss_score": 0.00212, "epss_percentile": 0.43817}, "CVE-2024-9030": {"epss_score": 0.00127, "epss_percentile": 0.32798}, "CVE-2024-9031": {"epss_score": 0.00129, "epss_percentile": 0.33157}, "CVE-2024-9032": {"epss_score": 0.00112, "epss_percentile": 0.30479}, "CVE-2024-9033": {"epss_score": 0.00122, "epss_percentile": 0.32061}, "CVE-2024-9034": {"epss_score": 0.00062, "epss_percentile": 0.19784}, "CVE-2024-9035": {"epss_score": 0.00062, "epss_percentile": 0.19784}, "CVE-2024-9036": {"epss_score": 0.00095, "epss_percentile": 0.2721}, "CVE-2024-9037": {"epss_score": 0.00067, "epss_percentile": 0.20972}, "CVE-2024-9038": {"epss_score": 0.00136, "epss_percentile": 0.34131}, "CVE-2024-9039": {"epss_score": 0.00078, "epss_percentile": 0.2363}, "CVE-2024-9040": {"epss_score": 0.00011, "epss_percentile": 0.01044}, "CVE-2024-9041": {"epss_score": 0.00048, "epss_percentile": 0.14961}, "CVE-2024-9042": {"epss_score": 0.0007, "epss_percentile": 0.21831}, "CVE-2024-9043": {"epss_score": 0.00044, "epss_percentile": 0.13373}, "CVE-2024-9044": {"epss_score": 0.0004, "epss_percentile": 0.12074}, "CVE-2024-9046": {"epss_score": 0.00084, "epss_percentile": 0.24972}, "CVE-2024-9047": {"epss_score": 0.93781, "epss_percentile": 0.99845}, "CVE-2024-9048": {"epss_score": 0.00136, "epss_percentile": 0.34129}, "CVE-2024-9049": {"epss_score": 0.00214, "epss_percentile": 0.43965}, "CVE-2024-9050": {"epss_score": 0.00037, "epss_percentile": 0.10882}, "CVE-2024-9051": {"epss_score": 0.00187, "epss_percentile": 0.40803}, "CVE-2024-9053": {"epss_score": 0.02063, "epss_percentile": 0.8345}, "CVE-2024-9054": {"epss_score": 0.17051, "epss_percentile": 0.94765}, "CVE-2024-9055": {"epss_score": 0.00038, "epss_percentile": 0.11422}, "CVE-2024-9056": {"epss_score": 0.00136, "epss_percentile": 0.34096}, "CVE-2024-9057": {"epss_score": 0.00249, "epss_percentile": 0.48051}, "CVE-2024-9058": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-9059": {"epss_score": 0.00141, "epss_percentile": 0.34912}, "CVE-2024-9060": {"epss_score": 0.00134, "epss_percentile": 0.33861}, "CVE-2024-9061": {"epss_score": 0.88524, "epss_percentile": 0.99476}, "CVE-2024-9062": {"epss_score": 0.00016, "epss_percentile": 0.02681}, "CVE-2024-9064": {"epss_score": 0.00115, "epss_percentile": 0.31033}, "CVE-2024-9065": {"epss_score": 0.00498, "epss_percentile": 0.65243}, "CVE-2024-9066": {"epss_score": 0.00176, "epss_percentile": 0.39422}, "CVE-2024-9067": {"epss_score": 0.00206, "epss_percentile": 0.42921}, "CVE-2024-9068": {"epss_score": 0.00144, "epss_percentile": 0.35285}, "CVE-2024-9069": {"epss_score": 0.00144, "epss_percentile": 0.35285}, "CVE-2024-9070": {"epss_score": 0.00225, "epss_percentile": 0.45144}, "CVE-2024-9071": {"epss_score": 0.00187, "epss_percentile": 0.40742}, "CVE-2024-9072": {"epss_score": 0.00176, "epss_percentile": 0.39422}, "CVE-2024-9073": {"epss_score": 0.00161, "epss_percentile": 0.37536}, "CVE-2024-9074": {"epss_score": 0.00176, "epss_percentile": 0.39422}, "CVE-2024-9075": {"epss_score": 0.00126, "epss_percentile": 0.32746}, "CVE-2024-9076": {"epss_score": 0.01374, "epss_percentile": 0.79823}, "CVE-2024-9077": {"epss_score": 0.0012, "epss_percentile": 0.31708}, "CVE-2024-9078": {"epss_score": 0.00065, "epss_percentile": 0.20451}, "CVE-2024-9079": {"epss_score": 0.00069, "epss_percentile": 0.21473}, "CVE-2024-9080": {"epss_score": 0.00196, "epss_percentile": 0.41733}, "CVE-2024-9081": {"epss_score": 0.00063, "epss_percentile": 0.19935}, "CVE-2024-9082": {"epss_score": 0.00173, "epss_percentile": 0.39117}, "CVE-2024-9083": {"epss_score": 0.00104, "epss_percentile": 0.29144}, "CVE-2024-9084": {"epss_score": 0.00131, "epss_percentile": 0.33487}, "CVE-2024-9085": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-9086": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-9087": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-9088": {"epss_score": 0.00131, "epss_percentile": 0.33473}, "CVE-2024-9089": {"epss_score": 0.00131, "epss_percentile": 0.33487}, "CVE-2024-9090": {"epss_score": 0.00067, "epss_percentile": 0.21137}, "CVE-2024-9091": {"epss_score": 0.00193, "epss_percentile": 0.41391}, "CVE-2024-9092": {"epss_score": 0.00143, "epss_percentile": 0.35172}, "CVE-2024-9093": {"epss_score": 0.00079, "epss_percentile": 0.23878}, "CVE-2024-9094": {"epss_score": 0.00061, "epss_percentile": 0.19293}, "CVE-2024-9095": {"epss_score": 0.0011, "epss_percentile": 0.3022}, "CVE-2024-9096": {"epss_score": 0.00084, "epss_percentile": 0.24863}, "CVE-2024-9097": {"epss_score": 0.00148, "epss_percentile": 0.35825}, "CVE-2024-9098": {"epss_score": 0.00065, "epss_percentile": 0.20654}, "CVE-2024-9099": {"epss_score": 0.00062, "epss_percentile": 0.1971}, "CVE-2024-9100": {"epss_score": 0.00162, "epss_percentile": 0.37721}, "CVE-2024-9101": {"epss_score": 0.00325, "epss_percentile": 0.5503}, "CVE-2024-9102": {"epss_score": 0.00268, "epss_percentile": 0.501}, "CVE-2024-9103": {"epss_score": 0.00045, "epss_percentile": 0.13715}, "CVE-2024-9104": {"epss_score": 0.00048, "epss_percentile": 0.15138}, "CVE-2024-9105": {"epss_score": 0.00221, "epss_percentile": 0.4466}, "CVE-2024-9106": {"epss_score": 0.3476, "epss_percentile": 0.96872}, "CVE-2024-9107": {"epss_score": 0.0012, "epss_percentile": 0.31786}, "CVE-2024-9108": {"epss_score": 0.05691, "epss_percentile": 0.90123}, "CVE-2024-9109": {"epss_score": 0.00111, "epss_percentile": 0.30268}, "CVE-2024-9110": {"epss_score": 0.00378, "epss_percentile": 0.58823}, "CVE-2024-9111": {"epss_score": 0.00079, "epss_percentile": 0.23805}, "CVE-2024-9112": {"epss_score": 0.01045, "epss_percentile": 0.77013}, "CVE-2024-9113": {"epss_score": 0.00657, "epss_percentile": 0.70473}, "CVE-2024-9114": {"epss_score": 0.00599, "epss_percentile": 0.68799}, "CVE-2024-9115": {"epss_score": 0.00144, "epss_percentile": 0.35285}, "CVE-2024-9116": {"epss_score": 0.00085, "epss_percentile": 0.25229}, "CVE-2024-9117": {"epss_score": 0.00144, "epss_percentile": 0.35285}, "CVE-2024-9118": {"epss_score": 0.00204, "epss_percentile": 0.42602}, "CVE-2024-9119": {"epss_score": 0.00161, "epss_percentile": 0.37556}, "CVE-2024-9120": {"epss_score": 0.00246, "epss_percentile": 0.4776}, "CVE-2024-9121": {"epss_score": 0.00192, "epss_percentile": 0.41375}, "CVE-2024-9122": {"epss_score": 0.05718, "epss_percentile": 0.90149}, "CVE-2024-9123": {"epss_score": 0.00217, "epss_percentile": 0.44321}, "CVE-2024-9124": {"epss_score": 0.00282, "epss_percentile": 0.51233}, "CVE-2024-9125": {"epss_score": 0.00161, "epss_percentile": 0.37536}, "CVE-2024-9126": {"epss_score": 0.00156, "epss_percentile": 0.36879}, "CVE-2024-9127": {"epss_score": 0.00187, "epss_percentile": 0.40742}, "CVE-2024-9129": {"epss_score": 0.00142, "epss_percentile": 0.34998}, "CVE-2024-9130": {"epss_score": 0.0051, "epss_percentile": 0.65768}, "CVE-2024-9131": {"epss_score": 0.00613, "epss_percentile": 0.69257}, "CVE-2024-9132": {"epss_score": 0.00372, "epss_percentile": 0.58445}, "CVE-2024-9133": {"epss_score": 0.00026, "epss_percentile": 0.06382}, "CVE-2024-9134": {"epss_score": 0.00568, "epss_percentile": 0.67885}, "CVE-2024-9135": {"epss_score": 0.00152, "epss_percentile": 0.3637}, "CVE-2024-9136": {"epss_score": 0.00079, "epss_percentile": 0.23952}, "CVE-2024-9137": {"epss_score": 0.0013, "epss_percentile": 0.33242}, "CVE-2024-9138": {"epss_score": 0.00317, "epss_percentile": 0.54363}, "CVE-2024-9139": {"epss_score": 0.00232, "epss_percentile": 0.45971}, "CVE-2024-9140": {"epss_score": 0.0245, "epss_percentile": 0.84779}, "CVE-2024-9141": {"epss_score": 0.00114, "epss_percentile": 0.3074}, "CVE-2024-9142": {"epss_score": 0.00088, "epss_percentile": 0.25712}, "CVE-2024-9143": {"epss_score": 0.00639, "epss_percentile": 0.69934}, "CVE-2024-9145": {"epss_score": 0.00326, "epss_percentile": 0.55057}, "CVE-2024-9146": {"epss_score": 0.00432, "epss_percentile": 0.62119}, "CVE-2024-9147": {"epss_score": 0.00181, "epss_percentile": 0.40112}, "CVE-2024-9148": {"epss_score": 0.01427, "epss_percentile": 0.80211}, "CVE-2024-9149": {"epss_score": 0.00099, "epss_percentile": 0.28367}, "CVE-2024-9150": {"epss_score": 0.00252, "epss_percentile": 0.48405}, "CVE-2024-9154": {"epss_score": 0.00354, "epss_percentile": 0.57257}, "CVE-2024-9155": {"epss_score": 0.00204, "epss_percentile": 0.4265}, "CVE-2024-9156": {"epss_score": 0.00462, "epss_percentile": 0.63624}, "CVE-2024-9157": {"epss_score": 0.00032, "epss_percentile": 0.08858}, "CVE-2024-9158": {"epss_score": 0.00264, "epss_percentile": 0.49696}, "CVE-2024-9159": {"epss_score": 0.00084, "epss_percentile": 0.24927}, "CVE-2024-9160": {"epss_score": 0.00014, "epss_percentile": 0.0208}, "CVE-2024-9161": {"epss_score": 0.22013, "epss_percentile": 0.95583}, "CVE-2024-9162": {"epss_score": 0.5671, "epss_percentile": 0.98034}, "CVE-2024-9163": {"epss_score": 0.00012, "epss_percentile": 0.01392}, "CVE-2024-9164": {"epss_score": 0.00145, "epss_percentile": 0.35461}, "CVE-2024-9165": {"epss_score": 0.00184, "epss_percentile": 0.40379}, "CVE-2024-9166": {"epss_score": 0.04578, "epss_percentile": 0.8887}, "CVE-2024-9167": {"epss_score": 0.00362, "epss_percentile": 0.57779}, "CVE-2024-9169": {"epss_score": 0.00137, "epss_percentile": 0.34226}, "CVE-2024-9170": {"epss_score": 0.00347, "epss_percentile": 0.56748}, "CVE-2024-9172": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-9173": {"epss_score": 0.00144, "epss_percentile": 0.35285}, "CVE-2024-9174": {"epss_score": 0.00765, "epss_percentile": 0.72929}, "CVE-2024-9177": {"epss_score": 0.00167, "epss_percentile": 0.38396}, "CVE-2024-9178": {"epss_score": 0.00184, "epss_percentile": 0.40379}, "CVE-2024-9180": {"epss_score": 0.00259, "epss_percentile": 0.49071}, "CVE-2024-9182": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-9183": {"epss_score": 0.00011, "epss_percentile": 0.00927}, "CVE-2024-9184": {"epss_score": 0.03359, "epss_percentile": 0.86988}, "CVE-2024-9186": {"epss_score": 0.21731, "epss_percentile": 0.95553}, "CVE-2024-9187": {"epss_score": 0.00133, "epss_percentile": 0.3366}, "CVE-2024-9188": {"epss_score": 0.00304, "epss_percentile": 0.53256}, "CVE-2024-9189": {"epss_score": 0.00165, "epss_percentile": 0.3812}, "CVE-2024-9191": {"epss_score": 0.00174, "epss_percentile": 0.3922}, "CVE-2024-9192": {"epss_score": 0.00204, "epss_percentile": 0.42653}, "CVE-2024-9193": {"epss_score": 0.29039, "epss_percentile": 0.96413}, "CVE-2024-9194": {"epss_score": 0.00497, "epss_percentile": 0.65211}, "CVE-2024-9195": {"epss_score": 0.00176, "epss_percentile": 0.39416}, "CVE-2024-9197": {"epss_score": 0.00239, "epss_percentile": 0.46897}, "CVE-2024-9198": {"epss_score": 0.00379, "epss_percentile": 0.58883}, "CVE-2024-9199": {"epss_score": 0.00112, "epss_percentile": 0.3053}, "CVE-2024-9200": {"epss_score": 0.01428, "epss_percentile": 0.80218}, "CVE-2024-9201": {"epss_score": 0.00332, "epss_percentile": 0.55573}, "CVE-2024-9202": {"epss_score": 0.00372, "epss_percentile": 0.58459}, "CVE-2024-9203": {"epss_score": 0.00019, "epss_percentile": 0.04201}, "CVE-2024-9204": {"epss_score": 0.01354, "epss_percentile": 0.79701}, "CVE-2024-9205": {"epss_score": 0.02077, "epss_percentile": 0.83516}, "CVE-2024-9206": {"epss_score": 0.01905, "epss_percentile": 0.82795}, "CVE-2024-9207": {"epss_score": 0.01377, "epss_percentile": 0.79846}, "CVE-2024-9208": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-9209": {"epss_score": 0.01608, "epss_percentile": 0.81313}, "CVE-2024-9210": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-9211": {"epss_score": 0.01409, "epss_percentile": 0.80065}, "CVE-2024-9212": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2024-9213": {"epss_score": 0.01268, "epss_percentile": 0.79027}, "CVE-2024-9214": {"epss_score": 0.01478, "epss_percentile": 0.80556}, "CVE-2024-9215": {"epss_score": 0.00249, "epss_percentile": 0.48011}, "CVE-2024-9216": {"epss_score": 0.00119, "epss_percentile": 0.31604}, "CVE-2024-9217": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2024-9218": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-9219": {"epss_score": 0.01914, "epss_percentile": 0.82845}, "CVE-2024-9220": {"epss_score": 0.01925, "epss_percentile": 0.82919}, "CVE-2024-9221": {"epss_score": 0.01725, "epss_percentile": 0.81955}, "CVE-2024-9222": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-9223": {"epss_score": 0.00082, "epss_percentile": 0.24491}, "CVE-2024-9224": {"epss_score": 0.4429, "epss_percentile": 0.97428}, "CVE-2024-9225": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-9226": {"epss_score": 0.01453, "epss_percentile": 0.80375}, "CVE-2024-9227": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-9228": {"epss_score": 0.0148, "epss_percentile": 0.80565}, "CVE-2024-9229": {"epss_score": 0.0024, "epss_percentile": 0.47205}, "CVE-2024-9230": {"epss_score": 0.0006, "epss_percentile": 0.19031}, "CVE-2024-9231": {"epss_score": 0.01453, "epss_percentile": 0.80375}, "CVE-2024-9232": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-9233": {"epss_score": 0.00017, "epss_percentile": 0.0342}, "CVE-2024-9234": {"epss_score": 0.92975, "epss_percentile": 0.99765}, "CVE-2024-9235": {"epss_score": 0.00443, "epss_percentile": 0.62758}, "CVE-2024-9236": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-9237": {"epss_score": 0.01377, "epss_percentile": 0.79846}, "CVE-2024-9238": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2024-9239": {"epss_score": 0.01236, "epss_percentile": 0.78769}, "CVE-2024-9240": {"epss_score": 0.01914, "epss_percentile": 0.82845}, "CVE-2024-9241": {"epss_score": 0.0148, "epss_percentile": 0.80565}, "CVE-2024-9242": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-9243": {"epss_score": 0.00366, "epss_percentile": 0.58072}, "CVE-2024-9244": {"epss_score": 0.00036, "epss_percentile": 0.10384}, "CVE-2024-9245": {"epss_score": 0.00034, "epss_percentile": 0.09711}, "CVE-2024-9246": {"epss_score": 0.00257, "epss_percentile": 0.48885}, "CVE-2024-9247": {"epss_score": 0.00832, "epss_percentile": 0.7406}, "CVE-2024-9248": {"epss_score": 0.00947, "epss_percentile": 0.75821}, "CVE-2024-9249": {"epss_score": 0.00821, "epss_percentile": 0.73901}, "CVE-2024-9250": {"epss_score": 0.01302, "epss_percentile": 0.79302}, "CVE-2024-9251": {"epss_score": 0.00404, "epss_percentile": 0.60452}, "CVE-2024-9252": {"epss_score": 0.00404, "epss_percentile": 0.60452}, "CVE-2024-9253": {"epss_score": 0.00257, "epss_percentile": 0.48885}, "CVE-2024-9254": {"epss_score": 0.0119, "epss_percentile": 0.78381}, "CVE-2024-9255": {"epss_score": 0.01302, "epss_percentile": 0.79302}, "CVE-2024-9256": {"epss_score": 0.00257, "epss_percentile": 0.48885}, "CVE-2024-9257": {"epss_score": 0.00062, "epss_percentile": 0.19693}, "CVE-2024-9258": {"epss_score": 0.00765, "epss_percentile": 0.72922}, "CVE-2024-9259": {"epss_score": 0.00765, "epss_percentile": 0.72922}, "CVE-2024-9260": {"epss_score": 0.00765, "epss_percentile": 0.72922}, "CVE-2024-9261": {"epss_score": 0.01119, "epss_percentile": 0.77754}, "CVE-2024-9262": {"epss_score": 0.00357, "epss_percentile": 0.57459}, "CVE-2024-9263": {"epss_score": 0.01148, "epss_percentile": 0.78013}, "CVE-2024-9264": {"epss_score": 0.93989, "epss_percentile": 0.99881}, "CVE-2024-9265": {"epss_score": 0.0026, "epss_percentile": 0.49197}, "CVE-2024-9266": {"epss_score": 0.00092, "epss_percentile": 0.2646}, "CVE-2024-9267": {"epss_score": 0.01051, "epss_percentile": 0.77084}, "CVE-2024-9269": {"epss_score": 0.00161, "epss_percentile": 0.37556}, "CVE-2024-9270": {"epss_score": 0.00159, "epss_percentile": 0.37323}, "CVE-2024-9271": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-9272": {"epss_score": 0.00161, "epss_percentile": 0.37556}, "CVE-2024-9274": {"epss_score": 0.00161, "epss_percentile": 0.37556}, "CVE-2024-9275": {"epss_score": 0.00026, "epss_percentile": 0.06413}, "CVE-2024-9276": {"epss_score": 0.00196, "epss_percentile": 0.41756}, "CVE-2024-9277": {"epss_score": 0.0017, "epss_percentile": 0.38706}, "CVE-2024-9278": {"epss_score": 0.00018, "epss_percentile": 0.03968}, "CVE-2024-9279": {"epss_score": 0.0014, "epss_percentile": 0.34725}, "CVE-2024-9280": {"epss_score": 0.00134, "epss_percentile": 0.33833}, "CVE-2024-9281": {"epss_score": 0.00108, "epss_percentile": 0.29793}, "CVE-2024-9282": {"epss_score": 0.00217, "epss_percentile": 0.443}, "CVE-2024-9283": {"epss_score": 0.00049, "epss_percentile": 0.1562}, "CVE-2024-9284": {"epss_score": 0.00065, "epss_percentile": 0.20541}, "CVE-2024-9285": {"epss_score": 0.00098, "epss_percentile": 0.27825}, "CVE-2024-9286": {"epss_score": 0.00096, "epss_percentile": 0.27306}, "CVE-2024-9287": {"epss_score": 0.00018, "epss_percentile": 0.0404}, "CVE-2024-9289": {"epss_score": 0.00324, "epss_percentile": 0.5495}, "CVE-2024-9290": {"epss_score": 0.72576, "epss_percentile": 0.98716}, "CVE-2024-9291": {"epss_score": 0.00136, "epss_percentile": 0.34113}, "CVE-2024-9292": {"epss_score": 0.00112, "epss_percentile": 0.30424}, "CVE-2024-9293": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-9294": {"epss_score": 0.00067, "epss_percentile": 0.21097}, "CVE-2024-9295": {"epss_score": 0.00078, "epss_percentile": 0.2363}, "CVE-2024-9296": {"epss_score": 0.00078, "epss_percentile": 0.2363}, "CVE-2024-9297": {"epss_score": 0.0007, "epss_percentile": 0.21709}, "CVE-2024-9298": {"epss_score": 0.00071, "epss_percentile": 0.22196}, "CVE-2024-9299": {"epss_score": 0.00128, "epss_percentile": 0.33016}, "CVE-2024-9300": {"epss_score": 0.00202, "epss_percentile": 0.42429}, "CVE-2024-9301": {"epss_score": 0.01446, "epss_percentile": 0.80328}, "CVE-2024-9302": {"epss_score": 0.00527, "epss_percentile": 0.6653}, "CVE-2024-9304": {"epss_score": 0.00175, "epss_percentile": 0.39345}, "CVE-2024-9305": {"epss_score": 0.00363, "epss_percentile": 0.579}, "CVE-2024-9306": {"epss_score": 0.00149, "epss_percentile": 0.3595}, "CVE-2024-9307": {"epss_score": 0.05887, "epss_percentile": 0.90295}, "CVE-2024-9308": {"epss_score": 0.00088, "epss_percentile": 0.25748}, "CVE-2024-9309": {"epss_score": 0.00105, "epss_percentile": 0.29276}, "CVE-2024-9310": {"epss_score": 0.00041, "epss_percentile": 0.12315}, "CVE-2024-9311": {"epss_score": 0.00032, "epss_percentile": 0.08963}, "CVE-2024-9312": {"epss_score": 0.00044, "epss_percentile": 0.13558}, "CVE-2024-9313": {"epss_score": 0.00628, "epss_percentile": 0.69652}, "CVE-2024-9314": {"epss_score": 0.01469, "epss_percentile": 0.80484}, "CVE-2024-9315": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-9316": {"epss_score": 0.00062, "epss_percentile": 0.19644}, "CVE-2024-9317": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-9318": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-9319": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-9320": {"epss_score": 0.00143, "epss_percentile": 0.35172}, "CVE-2024-9321": {"epss_score": 0.00127, "epss_percentile": 0.32792}, "CVE-2024-9322": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2024-9323": {"epss_score": 0.00131, "epss_percentile": 0.33487}, "CVE-2024-9324": {"epss_score": 0.00159, "epss_percentile": 0.37357}, "CVE-2024-9325": {"epss_score": 0.00045, "epss_percentile": 0.13809}, "CVE-2024-9326": {"epss_score": 0.15555, "epss_percentile": 0.94458}, "CVE-2024-9327": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-9328": {"epss_score": 0.00052, "epss_percentile": 0.1655}, "CVE-2024-9329": {"epss_score": 0.00442, "epss_percentile": 0.62708}, "CVE-2024-9333": {"epss_score": 0.00036, "epss_percentile": 0.10201}, "CVE-2024-9334": {"epss_score": 0.0018, "epss_percentile": 0.3998}, "CVE-2024-9340": {"epss_score": 0.00215, "epss_percentile": 0.44074}, "CVE-2024-9341": {"epss_score": 0.00899, "epss_percentile": 0.75151}, "CVE-2024-9342": {"epss_score": 0.00064, "epss_percentile": 0.20379}, "CVE-2024-9343": {"epss_score": 0.00022, "epss_percentile": 0.05159}, "CVE-2024-9344": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-9345": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-9346": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-9347": {"epss_score": 0.01801, "epss_percentile": 0.82328}, "CVE-2024-9348": {"epss_score": 0.00145, "epss_percentile": 0.35438}, "CVE-2024-9349": {"epss_score": 0.01725, "epss_percentile": 0.81955}, "CVE-2024-9350": {"epss_score": 0.01474, "epss_percentile": 0.8052}, "CVE-2024-9351": {"epss_score": 0.00128, "epss_percentile": 0.33003}, "CVE-2024-9352": {"epss_score": 0.00128, "epss_percentile": 0.33003}, "CVE-2024-9353": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-9354": {"epss_score": 0.00843, "epss_percentile": 0.74266}, "CVE-2024-9355": {"epss_score": 0.0007, "epss_percentile": 0.21943}, "CVE-2024-9356": {"epss_score": 0.00611, "epss_percentile": 0.69201}, "CVE-2024-9357": {"epss_score": 0.00948, "epss_percentile": 0.7583}, "CVE-2024-9358": {"epss_score": 0.00179, "epss_percentile": 0.39787}, "CVE-2024-9359": {"epss_score": 0.00041, "epss_percentile": 0.12348}, "CVE-2024-9360": {"epss_score": 0.00041, "epss_percentile": 0.12348}, "CVE-2024-9361": {"epss_score": 0.00188, "epss_percentile": 0.40889}, "CVE-2024-9362": {"epss_score": 0.01894, "epss_percentile": 0.82743}, "CVE-2024-9363": {"epss_score": 0.00468, "epss_percentile": 0.63873}, "CVE-2024-9364": {"epss_score": 0.00209, "epss_percentile": 0.43323}, "CVE-2024-9365": {"epss_score": 0.00029, "epss_percentile": 0.07739}, "CVE-2024-9366": {"epss_score": 0.00161, "epss_percentile": 0.37556}, "CVE-2024-9367": {"epss_score": 0.00187, "epss_percentile": 0.4073}, "CVE-2024-9368": {"epss_score": 0.00148, "epss_percentile": 0.35843}, "CVE-2024-9369": {"epss_score": 0.00094, "epss_percentile": 0.26953}, "CVE-2024-9371": {"epss_score": 0.00924, "epss_percentile": 0.75514}, "CVE-2024-9372": {"epss_score": 0.00161, "epss_percentile": 0.37536}, "CVE-2024-9373": {"epss_score": 0.00161, "epss_percentile": 0.37556}, "CVE-2024-9374": {"epss_score": 0.01122, "epss_percentile": 0.77785}, "CVE-2024-9375": {"epss_score": 0.01045, "epss_percentile": 0.77023}, "CVE-2024-9376": {"epss_score": 0.00184, "epss_percentile": 0.40379}, "CVE-2024-9377": {"epss_score": 0.00776, "epss_percentile": 0.73101}, "CVE-2024-9378": {"epss_score": 0.00928, "epss_percentile": 0.75581}, "CVE-2024-9379": {"epss_score": 0.817, "epss_percentile": 0.99152}, "CVE-2024-9380": {"epss_score": 0.88144, "epss_percentile": 0.9946}, "CVE-2024-9381": {"epss_score": 0.0121, "epss_percentile": 0.7855}, "CVE-2024-9382": {"epss_score": 0.01474, "epss_percentile": 0.8052}, "CVE-2024-9383": {"epss_score": 0.01474, "epss_percentile": 0.8052}, "CVE-2024-9384": {"epss_score": 0.01354, "epss_percentile": 0.79701}, "CVE-2024-9385": {"epss_score": 0.01905, "epss_percentile": 0.82795}, "CVE-2024-9386": {"epss_score": 0.00184, "epss_percentile": 0.40379}, "CVE-2024-9387": {"epss_score": 0.00012, "epss_percentile": 0.01424}, "CVE-2024-9388": {"epss_score": 0.00184, "epss_percentile": 0.40379}, "CVE-2024-9390": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2024-9391": {"epss_score": 0.0034, "epss_percentile": 0.56263}, "CVE-2024-9392": {"epss_score": 0.0019, "epss_percentile": 0.41123}, "CVE-2024-9393": {"epss_score": 0.00174, "epss_percentile": 0.39179}, "CVE-2024-9394": {"epss_score": 0.00123, "epss_percentile": 0.32332}, "CVE-2024-9395": {"epss_score": 0.00286, "epss_percentile": 0.51721}, "CVE-2024-9396": {"epss_score": 0.00171, "epss_percentile": 0.38819}, "CVE-2024-9397": {"epss_score": 0.00191, "epss_percentile": 0.41255}, "CVE-2024-9398": {"epss_score": 0.00595, "epss_percentile": 0.68683}, "CVE-2024-9399": {"epss_score": 0.00239, "epss_percentile": 0.46906}, "CVE-2024-9400": {"epss_score": 0.00101, "epss_percentile": 0.28711}, "CVE-2024-9401": {"epss_score": 0.00237, "epss_percentile": 0.46645}, "CVE-2024-9402": {"epss_score": 0.00115, "epss_percentile": 0.31009}, "CVE-2024-9403": {"epss_score": 0.00076, "epss_percentile": 0.23178}, "CVE-2024-9404": {"epss_score": 0.00235, "epss_percentile": 0.46321}, "CVE-2024-9405": {"epss_score": 0.0093, "epss_percentile": 0.75604}, "CVE-2024-9407": {"epss_score": 0.00014, "epss_percentile": 0.01913}, "CVE-2024-9408": {"epss_score": 0.00051, "epss_percentile": 0.16149}, "CVE-2024-9409": {"epss_score": 0.00271, "epss_percentile": 0.50291}, "CVE-2024-9410": {"epss_score": 0.00107, "epss_percentile": 0.29613}, "CVE-2024-9411": {"epss_score": 0.00127, "epss_percentile": 0.32865}, "CVE-2024-9412": {"epss_score": 0.00102, "epss_percentile": 0.28836}, "CVE-2024-9413": {"epss_score": 0.00656, "epss_percentile": 0.70444}, "CVE-2024-9414": {"epss_score": 0.00204, "epss_percentile": 0.42602}, "CVE-2024-9415": {"epss_score": 0.01277, "epss_percentile": 0.79111}, "CVE-2024-9416": {"epss_score": 0.0004, "epss_percentile": 0.12042}, "CVE-2024-9417": {"epss_score": 0.00293, "epss_percentile": 0.52344}, "CVE-2024-9418": {"epss_score": 0.00049, "epss_percentile": 0.15455}, "CVE-2024-9419": {"epss_score": 0.01456, "epss_percentile": 0.80394}, "CVE-2024-9420": {"epss_score": 0.2574, "epss_percentile": 0.96061}, "CVE-2024-9421": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-9422": {"epss_score": 0.00372, "epss_percentile": 0.58459}, "CVE-2024-9423": {"epss_score": 0.00047, "epss_percentile": 0.14874}, "CVE-2024-9425": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-9426": {"epss_score": 0.0009, "epss_percentile": 0.26058}, "CVE-2024-9427": {"epss_score": 0.00115, "epss_percentile": 0.3103}, "CVE-2024-9428": {"epss_score": 0.00021, "epss_percentile": 0.04823}, "CVE-2024-9429": {"epss_score": 0.00075, "epss_percentile": 0.23041}, "CVE-2024-9430": {"epss_score": 0.00474, "epss_percentile": 0.64112}, "CVE-2024-9431": {"epss_score": 0.00051, "epss_percentile": 0.16051}, "CVE-2024-9434": {"epss_score": 0.00267, "epss_percentile": 0.50011}, "CVE-2024-9435": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-9436": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-9437": {"epss_score": 0.00142, "epss_percentile": 0.35006}, "CVE-2024-9438": {"epss_score": 0.01459, "epss_percentile": 0.80414}, "CVE-2024-9439": {"epss_score": 0.00601, "epss_percentile": 0.68849}, "CVE-2024-9440": {"epss_score": 0.00144, "epss_percentile": 0.35293}, "CVE-2024-9441": {"epss_score": 0.54042, "epss_percentile": 0.97909}, "CVE-2024-9442": {"epss_score": 0.00079, "epss_percentile": 0.23805}, "CVE-2024-9443": {"epss_score": 0.00184, "epss_percentile": 0.40379}, "CVE-2024-9444": {"epss_score": 0.00187, "epss_percentile": 0.40768}, "CVE-2024-9445": {"epss_score": 0.00187, "epss_percentile": 0.40742}, "CVE-2024-9446": {"epss_score": 0.0026, "epss_percentile": 0.49171}, "CVE-2024-9447": {"epss_score": 0.00088, "epss_percentile": 0.25661}, "CVE-2024-9448": {"epss_score": 0.0006, "epss_percentile": 0.19171}, "CVE-2024-9449": {"epss_score": 0.00289, "epss_percentile": 0.52028}, "CVE-2024-9450": {"epss_score": 0.00027, "epss_percentile": 0.06929}, "CVE-2024-9451": {"epss_score": 0.00141, "epss_percentile": 0.34823}, "CVE-2024-9452": {"epss_score": 0.00115, "epss_percentile": 0.31033}, "CVE-2024-9453": {"epss_score": 0.00042, "epss_percentile": 0.12805}, "CVE-2024-9454": {"epss_score": 0.00158, "epss_percentile": 0.37168}, "CVE-2024-9455": {"epss_score": 0.00115, "epss_percentile": 0.31033}, "CVE-2024-9456": {"epss_score": 0.00141, "epss_percentile": 0.34927}, "CVE-2024-9457": {"epss_score": 0.00115, "epss_percentile": 0.31033}, "CVE-2024-9458": {"epss_score": 0.02254, "epss_percentile": 0.84165}, "CVE-2024-9459": {"epss_score": 0.00371, "epss_percentile": 0.58406}, "CVE-2024-9460": {"epss_score": 0.00034, "epss_percentile": 0.0967}, "CVE-2024-9461": {"epss_score": 0.03016, "epss_percentile": 0.86217}, "CVE-2024-9462": {"epss_score": 0.0017, "epss_percentile": 0.38664}, "CVE-2024-9463": {"epss_score": 0.94199, "epss_percentile": 0.99916}, "CVE-2024-9464": {"epss_score": 0.83054, "epss_percentile": 0.99229}, "CVE-2024-9465": {"epss_score": 0.94286, "epss_percentile": 0.99935}, "CVE-2024-9466": {"epss_score": 0.17297, "epss_percentile": 0.94818}, "CVE-2024-9467": {"epss_score": 0.01696, "epss_percentile": 0.81808}, "CVE-2024-9468": {"epss_score": 0.00601, "epss_percentile": 0.6885}, "CVE-2024-9469": {"epss_score": 0.00078, "epss_percentile": 0.23672}, "CVE-2024-9470": {"epss_score": 0.00169, "epss_percentile": 0.38564}, "CVE-2024-9471": {"epss_score": 0.00203, "epss_percentile": 0.42561}, "CVE-2024-9472": {"epss_score": 0.00245, "epss_percentile": 0.47682}, "CVE-2024-9473": {"epss_score": 0.00235, "epss_percentile": 0.46337}, "CVE-2024-9474": {"epss_score": 0.94223, "epss_percentile": 0.99919}, "CVE-2024-9475": {"epss_score": 0.00269, "epss_percentile": 0.50172}, "CVE-2024-9476": {"epss_score": 0.00012, "epss_percentile": 0.01292}, "CVE-2024-9477": {"epss_score": 0.00096, "epss_percentile": 0.27412}, "CVE-2024-9478": {"epss_score": 0.00121, "epss_percentile": 0.31916}, "CVE-2024-9479": {"epss_score": 0.00121, "epss_percentile": 0.31916}, "CVE-2024-9481": {"epss_score": 0.00045, "epss_percentile": 0.13949}, "CVE-2024-9482": {"epss_score": 0.00045, "epss_percentile": 0.13949}, "CVE-2024-9483": {"epss_score": 0.00061, "epss_percentile": 0.1949}, "CVE-2024-9484": {"epss_score": 0.00061, "epss_percentile": 0.1949}, "CVE-2024-9486": {"epss_score": 0.02607, "epss_percentile": 0.85227}, "CVE-2024-9487": {"epss_score": 0.55491, "epss_percentile": 0.97979}, "CVE-2024-9488": {"epss_score": 0.00933, "epss_percentile": 0.75644}, "CVE-2024-9489": {"epss_score": 0.00285, "epss_percentile": 0.51663}, "CVE-2024-9490": {"epss_score": 0.00032, "epss_percentile": 0.08955}, "CVE-2024-9491": {"epss_score": 0.00032, "epss_percentile": 0.08955}, "CVE-2024-9492": {"epss_score": 0.00032, "epss_percentile": 0.08955}, "CVE-2024-9493": {"epss_score": 0.00032, "epss_percentile": 0.08955}, "CVE-2024-9494": {"epss_score": 0.00032, "epss_percentile": 0.08955}, "CVE-2024-9495": {"epss_score": 0.00032, "epss_percentile": 0.08955}, "CVE-2024-9496": {"epss_score": 0.00032, "epss_percentile": 0.08779}, "CVE-2024-9497": {"epss_score": 0.00022, "epss_percentile": 0.05167}, "CVE-2024-9498": {"epss_score": 0.00032, "epss_percentile": 0.08779}, "CVE-2024-9499": {"epss_score": 0.00032, "epss_percentile": 0.08779}, "CVE-2024-9500": {"epss_score": 0.00533, "epss_percentile": 0.66769}, "CVE-2024-9501": {"epss_score": 0.00246, "epss_percentile": 0.47737}, "CVE-2024-9502": {"epss_score": 0.00093, "epss_percentile": 0.26668}, "CVE-2024-9503": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-9504": {"epss_score": 0.00505, "epss_percentile": 0.656}, "CVE-2024-9505": {"epss_score": 0.00353, "epss_percentile": 0.57169}, "CVE-2024-9506": {"epss_score": 0.00027, "epss_percentile": 0.06949}, "CVE-2024-9507": {"epss_score": 0.00482, "epss_percentile": 0.64548}, "CVE-2024-9508": {"epss_score": 0.00036, "epss_percentile": 0.10329}, "CVE-2024-9511": {"epss_score": 0.01956, "epss_percentile": 0.83036}, "CVE-2024-9512": {"epss_score": 8e-05, "epss_percentile": 0.00559}, "CVE-2024-9513": {"epss_score": 0.06904, "epss_percentile": 0.91107}, "CVE-2024-9514": {"epss_score": 0.00087, "epss_percentile": 0.25599}, "CVE-2024-9515": {"epss_score": 0.00143, "epss_percentile": 0.35213}, "CVE-2024-9518": {"epss_score": 0.00704, "epss_percentile": 0.71573}, "CVE-2024-9519": {"epss_score": 0.00169, "epss_percentile": 0.38606}, "CVE-2024-9520": {"epss_score": 0.00114, "epss_percentile": 0.30837}, "CVE-2024-9521": {"epss_score": 0.00112, "epss_percentile": 0.30424}, "CVE-2024-9522": {"epss_score": 0.00206, "epss_percentile": 0.43063}, "CVE-2024-9524": {"epss_score": 0.00022, "epss_percentile": 0.04987}, "CVE-2024-9526": {"epss_score": 0.00103, "epss_percentile": 0.2904}, "CVE-2024-9528": {"epss_score": 0.00173, "epss_percentile": 0.39136}, "CVE-2024-9529": {"epss_score": 0.00132, "epss_percentile": 0.33561}, "CVE-2024-9530": {"epss_score": 0.0019, "epss_percentile": 0.41078}, "CVE-2024-9531": {"epss_score": 0.00133, "epss_percentile": 0.33651}, "CVE-2024-9532": {"epss_score": 0.00343, "epss_percentile": 0.56453}, "CVE-2024-9533": {"epss_score": 0.00368, "epss_percentile": 0.5821}, "CVE-2024-9534": {"epss_score": 0.00368, "epss_percentile": 0.5821}, "CVE-2024-9535": {"epss_score": 0.00492, "epss_percentile": 0.6499}, "CVE-2024-9536": {"epss_score": 0.00033, "epss_percentile": 0.0943}, "CVE-2024-9537": {"epss_score": 0.63906, "epss_percentile": 0.98355}, "CVE-2024-9538": {"epss_score": 0.00368, "epss_percentile": 0.58167}, "CVE-2024-9539": {"epss_score": 0.0044, "epss_percentile": 0.62634}, "CVE-2024-9540": {"epss_score": 0.00298, "epss_percentile": 0.52837}, "CVE-2024-9541": {"epss_score": 0.00293, "epss_percentile": 0.52307}, "CVE-2024-9542": {"epss_score": 0.0019, "epss_percentile": 0.41078}, "CVE-2024-9543": {"epss_score": 0.00172, "epss_percentile": 0.39012}, "CVE-2024-9544": {"epss_score": 0.00025, "epss_percentile": 0.06048}, "CVE-2024-9545": {"epss_score": 0.00079, "epss_percentile": 0.23975}, "CVE-2024-9546": {"epss_score": 0.0093, "epss_percentile": 0.75601}, "CVE-2024-9548": {"epss_score": 0.01857, "epss_percentile": 0.82574}, "CVE-2024-9549": {"epss_score": 0.00368, "epss_percentile": 0.5821}, "CVE-2024-9550": {"epss_score": 0.00368, "epss_percentile": 0.5821}, "CVE-2024-9551": {"epss_score": 0.0019, "epss_percentile": 0.41069}, "CVE-2024-9552": {"epss_score": 0.0019, "epss_percentile": 0.41069}, "CVE-2024-9553": {"epss_score": 0.0008, "epss_percentile": 0.24152}, "CVE-2024-9554": {"epss_score": 0.00066, "epss_percentile": 0.20932}, "CVE-2024-9555": {"epss_score": 0.0008, "epss_percentile": 0.24152}, "CVE-2024-9556": {"epss_score": 0.00087, "epss_percentile": 0.25599}, "CVE-2024-9557": {"epss_score": 0.00207, "epss_percentile": 0.43079}, "CVE-2024-9558": {"epss_score": 0.0019, "epss_percentile": 0.41069}, "CVE-2024-9559": {"epss_score": 0.0019, "epss_percentile": 0.41069}, "CVE-2024-9560": {"epss_score": 0.00039, "epss_percentile": 0.1159}, "CVE-2024-9561": {"epss_score": 0.0008, "epss_percentile": 0.24152}, "CVE-2024-9562": {"epss_score": 0.0008, "epss_percentile": 0.24152}, "CVE-2024-9563": {"epss_score": 0.0019, "epss_percentile": 0.41069}, "CVE-2024-9564": {"epss_score": 0.00103, "epss_percentile": 0.2898}, "CVE-2024-9565": {"epss_score": 0.00044, "epss_percentile": 0.13377}, "CVE-2024-9566": {"epss_score": 0.00106, "epss_percentile": 0.29424}, "CVE-2024-9567": {"epss_score": 0.00195, "epss_percentile": 0.41674}, "CVE-2024-9568": {"epss_score": 0.00195, "epss_percentile": 0.41674}, "CVE-2024-9569": {"epss_score": 0.00349, "epss_percentile": 0.56852}, "CVE-2024-9570": {"epss_score": 0.29081, "epss_percentile": 0.96416}, "CVE-2024-9571": {"epss_score": 0.00081, "epss_percentile": 0.24366}, "CVE-2024-9572": {"epss_score": 0.00074, "epss_percentile": 0.22742}, "CVE-2024-9573": {"epss_score": 0.00069, "epss_percentile": 0.21468}, "CVE-2024-9574": {"epss_score": 0.00137, "epss_percentile": 0.34204}, "CVE-2024-9575": {"epss_score": 0.00356, "epss_percentile": 0.57353}, "CVE-2024-9576": {"epss_score": 0.00061, "epss_percentile": 0.19417}, "CVE-2024-9578": {"epss_score": 0.02094, "epss_percentile": 0.83579}, "CVE-2024-9579": {"epss_score": 0.00225, "epss_percentile": 0.45128}, "CVE-2024-9581": {"epss_score": 0.00624, "epss_percentile": 0.69575}, "CVE-2024-9582": {"epss_score": 0.01136, "epss_percentile": 0.77917}, "CVE-2024-9583": {"epss_score": 0.0018, "epss_percentile": 0.39986}, "CVE-2024-9584": {"epss_score": 0.00094, "epss_percentile": 0.26982}, "CVE-2024-9585": {"epss_score": 0.00119, "epss_percentile": 0.31637}, "CVE-2024-9586": {"epss_score": 0.00117, "epss_percentile": 0.3126}, "CVE-2024-9587": {"epss_score": 0.00047, "epss_percentile": 0.14619}, "CVE-2024-9588": {"epss_score": 0.00132, "epss_percentile": 0.33595}, "CVE-2024-9589": {"epss_score": 0.00241, "epss_percentile": 0.47269}, "CVE-2024-9590": {"epss_score": 0.00207, "epss_percentile": 0.43115}, "CVE-2024-9591": {"epss_score": 0.00207, "epss_percentile": 0.43115}, "CVE-2024-9592": {"epss_score": 0.00188, "epss_percentile": 0.40882}, "CVE-2024-9593": {"epss_score": 0.80841, "epss_percentile": 0.99109}, "CVE-2024-9594": {"epss_score": 0.01358, "epss_percentile": 0.79733}, "CVE-2024-9595": {"epss_score": 0.0021, "epss_percentile": 0.43496}, "CVE-2024-9596": {"epss_score": 0.00096, "epss_percentile": 0.27376}, "CVE-2024-9597": {"epss_score": 0.00053, "epss_percentile": 0.16714}, "CVE-2024-9598": {"epss_score": 0.00405, "epss_percentile": 0.60503}, "CVE-2024-9599": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2024-9600": {"epss_score": 0.00064, "epss_percentile": 0.2029}, "CVE-2024-9601": {"epss_score": 0.00114, "epss_percentile": 0.30876}, "CVE-2024-9602": {"epss_score": 0.0035, "epss_percentile": 0.56924}, "CVE-2024-9603": {"epss_score": 0.00121, "epss_percentile": 0.31841}, "CVE-2024-9606": {"epss_score": 0.00098, "epss_percentile": 0.27809}, "CVE-2024-9607": {"epss_score": 0.01122, "epss_percentile": 0.77785}, "CVE-2024-9608": {"epss_score": 0.00609, "epss_percentile": 0.69123}, "CVE-2024-9609": {"epss_score": 0.01056, "epss_percentile": 0.77123}, "CVE-2024-9610": {"epss_score": 0.01354, "epss_percentile": 0.79701}, "CVE-2024-9611": {"epss_score": 0.0174, "epss_percentile": 0.82043}, "CVE-2024-9612": {"epss_score": 0.00062, "epss_percentile": 0.19601}, "CVE-2024-9613": {"epss_score": 0.00795, "epss_percentile": 0.73467}, "CVE-2024-9614": {"epss_score": 0.00936, "epss_percentile": 0.75675}, "CVE-2024-9615": {"epss_score": 0.01122, "epss_percentile": 0.77785}, "CVE-2024-9616": {"epss_score": 0.00699, "epss_percentile": 0.71447}, "CVE-2024-9617": {"epss_score": 0.17349, "epss_percentile": 0.94832}, "CVE-2024-9618": {"epss_score": 0.00245, "epss_percentile": 0.47651}, "CVE-2024-9619": {"epss_score": 0.00055, "epss_percentile": 0.17622}, "CVE-2024-9620": {"epss_score": 0.00041, "epss_percentile": 0.1236}, "CVE-2024-9621": {"epss_score": 0.00057, "epss_percentile": 0.18126}, "CVE-2024-9622": {"epss_score": 0.00026, "epss_percentile": 0.06625}, "CVE-2024-9623": {"epss_score": 0.00028, "epss_percentile": 0.07214}, "CVE-2024-9624": {"epss_score": 0.00211, "epss_percentile": 0.43669}, "CVE-2024-9626": {"epss_score": 0.0013, "epss_percentile": 0.33314}, "CVE-2024-9627": {"epss_score": 0.00557, "epss_percentile": 0.67552}, "CVE-2024-9628": {"epss_score": 0.00236, "epss_percentile": 0.46359}, "CVE-2024-9629": {"epss_score": 0.00096, "epss_percentile": 0.27291}, "CVE-2024-9630": {"epss_score": 0.00157, "epss_percentile": 0.37069}, "CVE-2024-9631": {"epss_score": 0.00096, "epss_percentile": 0.27363}, "CVE-2024-9632": {"epss_score": 0.00042, "epss_percentile": 0.12725}, "CVE-2024-9633": {"epss_score": 0.00012, "epss_percentile": 0.01147}, "CVE-2024-9634": {"epss_score": 0.26412, "epss_percentile": 0.96145}, "CVE-2024-9635": {"epss_score": 0.00525, "epss_percentile": 0.66372}, "CVE-2024-9636": {"epss_score": 0.01172, "epss_percentile": 0.78234}, "CVE-2024-9637": {"epss_score": 0.00219, "epss_percentile": 0.44521}, "CVE-2024-9638": {"epss_score": 0.00021, "epss_percentile": 0.04823}, "CVE-2024-9639": {"epss_score": 0.00351, "epss_percentile": 0.57006}, "CVE-2024-9641": {"epss_score": 0.00021, "epss_percentile": 0.04823}, "CVE-2024-9642": {"epss_score": 0.00183, "epss_percentile": 0.40359}, "CVE-2024-9643": {"epss_score": 0.0014, "epss_percentile": 0.34684}, "CVE-2024-9644": {"epss_score": 0.00084, "epss_percentile": 0.25024}, "CVE-2024-9645": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2024-9647": {"epss_score": 0.01354, "epss_percentile": 0.79701}, "CVE-2024-9648": {"epss_score": 0.00078, "epss_percentile": 0.23577}, "CVE-2024-9649": {"epss_score": 0.00145, "epss_percentile": 0.355}, "CVE-2024-9650": {"epss_score": 0.00495, "epss_percentile": 0.65127}, "CVE-2024-9651": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2024-9652": {"epss_score": 0.01246, "epss_percentile": 0.78854}, "CVE-2024-9653": {"epss_score": 0.00836, "epss_percentile": 0.74141}, "CVE-2024-9654": {"epss_score": 0.0011, "epss_percentile": 0.30159}, "CVE-2024-9655": {"epss_score": 0.00224, "epss_percentile": 0.45058}, "CVE-2024-9656": {"epss_score": 0.00161, "epss_percentile": 0.37536}, "CVE-2024-9657": {"epss_score": 0.00975, "epss_percentile": 0.762}, "CVE-2024-9658": {"epss_score": 0.00156, "epss_percentile": 0.37}, "CVE-2024-9659": {"epss_score": 0.15673, "epss_percentile": 0.94481}, "CVE-2024-9660": {"epss_score": 0.04549, "epss_percentile": 0.88838}, "CVE-2024-9661": {"epss_score": 0.00039, "epss_percentile": 0.11436}, "CVE-2024-9662": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2024-9663": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2024-9664": {"epss_score": 0.00978, "epss_percentile": 0.76235}, "CVE-2024-9665": {"epss_score": 0.00043, "epss_percentile": 0.13032}, "CVE-2024-9666": {"epss_score": 0.00014, "epss_percentile": 0.0206}, "CVE-2024-9667": {"epss_score": 0.01453, "epss_percentile": 0.80375}, "CVE-2024-9668": {"epss_score": 0.00141, "epss_percentile": 0.34912}, "CVE-2024-9669": {"epss_score": 0.00101, "epss_percentile": 0.28645}, "CVE-2024-9670": {"epss_score": 0.01354, "epss_percentile": 0.79701}, "CVE-2024-9671": {"epss_score": 0.0026, "epss_percentile": 0.49241}, "CVE-2024-9672": {"epss_score": 0.00165, "epss_percentile": 0.38037}, "CVE-2024-9674": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-9675": {"epss_score": 0.00134, "epss_percentile": 0.33903}, "CVE-2024-9676": {"epss_score": 0.01331, "epss_percentile": 0.79519}, "CVE-2024-9677": {"epss_score": 0.00066, "epss_percentile": 0.20925}, "CVE-2024-9678": {"epss_score": 0.00094, "epss_percentile": 0.268}, "CVE-2024-9679": {"epss_score": 0.00089, "epss_percentile": 0.25818}, "CVE-2024-9680": {"epss_score": 0.24625, "epss_percentile": 0.95941}, "CVE-2024-9681": {"epss_score": 0.0058, "epss_percentile": 0.68257}, "CVE-2024-9682": {"epss_score": 0.00185, "epss_percentile": 0.40467}, "CVE-2024-9683": {"epss_score": 0.00168, "epss_percentile": 0.38408}, "CVE-2024-9684": {"epss_score": 0.00139, "epss_percentile": 0.3459}, "CVE-2024-9685": {"epss_score": 0.00228, "epss_percentile": 0.45505}, "CVE-2024-9686": {"epss_score": 0.00472, "epss_percentile": 0.64055}, "CVE-2024-9687": {"epss_score": 0.00112, "epss_percentile": 0.30445}, "CVE-2024-9689": {"epss_score": 0.00182, "epss_percentile": 0.40185}, "CVE-2024-9692": {"epss_score": 0.00275, "epss_percentile": 0.50684}, "CVE-2024-9693": {"epss_score": 0.0005, "epss_percentile": 0.15726}, "CVE-2024-9694": {"epss_score": 0.00085, "epss_percentile": 0.25217}, "CVE-2024-9696": {"epss_score": 0.00161, "epss_percentile": 0.37536}, "CVE-2024-9697": {"epss_score": 0.00139, "epss_percentile": 0.34584}, "CVE-2024-9698": {"epss_score": 0.37163, "epss_percentile": 0.97024}, "CVE-2024-9699": {"epss_score": 0.00025, "epss_percentile": 0.06321}, "CVE-2024-9700": {"epss_score": 0.00183, "epss_percentile": 0.40306}, "CVE-2024-9701": {"epss_score": 0.01126, "epss_percentile": 0.7781}, "CVE-2024-9702": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-9703": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2024-9704": {"epss_score": 0.00161, "epss_percentile": 0.37536}, "CVE-2024-9705": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2024-9706": {"epss_score": 0.00325, "epss_percentile": 0.55026}, "CVE-2024-9707": {"epss_score": 0.88889, "epss_percentile": 0.99497}, "CVE-2024-9708": {"epss_score": 0.00158, "epss_percentile": 0.37195}, "CVE-2024-9709": {"epss_score": 0.00021, "epss_percentile": 0.04807}, "CVE-2024-9710": {"epss_score": 0.00808, "epss_percentile": 0.73693}, "CVE-2024-9711": {"epss_score": 0.00021, "epss_percentile": 0.04807}, "CVE-2024-9712": {"epss_score": 0.01238, "epss_percentile": 0.78791}, "CVE-2024-9713": {"epss_score": 0.00865, "epss_percentile": 0.74614}, "CVE-2024-9714": {"epss_score": 0.01238, "epss_percentile": 0.78791}, "CVE-2024-9715": {"epss_score": 0.01238, "epss_percentile": 0.78791}, "CVE-2024-9716": {"epss_score": 0.01238, "epss_percentile": 0.78791}, "CVE-2024-9717": {"epss_score": 0.00816, "epss_percentile": 0.73802}, "CVE-2024-9718": {"epss_score": 0.00739, "epss_percentile": 0.72394}, "CVE-2024-9719": {"epss_score": 0.01238, "epss_percentile": 0.78791}, "CVE-2024-9720": {"epss_score": 0.00717, "epss_percentile": 0.71915}, "CVE-2024-9721": {"epss_score": 0.01238, "epss_percentile": 0.78791}, "CVE-2024-9722": {"epss_score": 0.00908, "epss_percentile": 0.75282}, "CVE-2024-9723": {"epss_score": 0.01238, "epss_percentile": 0.78791}, "CVE-2024-9724": {"epss_score": 0.00939, "epss_percentile": 0.75724}, "CVE-2024-9725": {"epss_score": 0.00939, "epss_percentile": 0.75724}, "CVE-2024-9726": {"epss_score": 0.0078, "epss_percentile": 0.73173}, "CVE-2024-9727": {"epss_score": 0.00939, "epss_percentile": 0.75724}, "CVE-2024-9728": {"epss_score": 0.00865, "epss_percentile": 0.74614}, "CVE-2024-9729": {"epss_score": 0.00417, "epss_percentile": 0.61251}, "CVE-2024-9730": {"epss_score": 0.00393, "epss_percentile": 0.59707}, "CVE-2024-9731": {"epss_score": 0.00412, "epss_percentile": 0.60955}, "CVE-2024-9732": {"epss_score": 0.00655, "epss_percentile": 0.70364}, "CVE-2024-9733": {"epss_score": 0.00529, "epss_percentile": 0.66591}, "CVE-2024-9734": {"epss_score": 0.0054, "epss_percentile": 0.67023}, "CVE-2024-9735": {"epss_score": 0.00545, "epss_percentile": 0.67167}, "CVE-2024-9736": {"epss_score": 0.00354, "epss_percentile": 0.5722}, "CVE-2024-9737": {"epss_score": 0.00337, "epss_percentile": 0.56034}, "CVE-2024-9738": {"epss_score": 0.00529, "epss_percentile": 0.66591}, "CVE-2024-9739": {"epss_score": 0.00529, "epss_percentile": 0.66591}, "CVE-2024-9740": {"epss_score": 0.00529, "epss_percentile": 0.66591}, "CVE-2024-9741": {"epss_score": 0.0054, "epss_percentile": 0.67023}, "CVE-2024-9742": {"epss_score": 0.00774, "epss_percentile": 0.73075}, "CVE-2024-9743": {"epss_score": 0.00774, "epss_percentile": 0.73075}, "CVE-2024-9744": {"epss_score": 0.00354, "epss_percentile": 0.5722}, "CVE-2024-9745": {"epss_score": 0.00774, "epss_percentile": 0.73075}, "CVE-2024-9746": {"epss_score": 0.00529, "epss_percentile": 0.66591}, "CVE-2024-9747": {"epss_score": 0.00936, "epss_percentile": 0.75681}, "CVE-2024-9748": {"epss_score": 0.00438, "epss_percentile": 0.62572}, "CVE-2024-9749": {"epss_score": 0.00157, "epss_percentile": 0.37112}, "CVE-2024-9750": {"epss_score": 0.00529, "epss_percentile": 0.66591}, "CVE-2024-9751": {"epss_score": 0.00529, "epss_percentile": 0.66591}, "CVE-2024-9752": {"epss_score": 0.00091, "epss_percentile": 0.26244}, "CVE-2024-9753": {"epss_score": 0.00157, "epss_percentile": 0.37112}, "CVE-2024-9754": {"epss_score": 0.00091, "epss_percentile": 0.26244}, "CVE-2024-9755": {"epss_score": 0.00519, "epss_percentile": 0.66152}, "CVE-2024-9756": {"epss_score": 0.02444, "epss_percentile": 0.84763}, "CVE-2024-9757": {"epss_score": 0.0014, "epss_percentile": 0.34775}, "CVE-2024-9758": {"epss_score": 0.00262, "epss_percentile": 0.49349}, "CVE-2024-9759": {"epss_score": 0.00157, "epss_percentile": 0.37112}, "CVE-2024-9760": {"epss_score": 0.00157, "epss_percentile": 0.37112}, "CVE-2024-9761": {"epss_score": 0.0014, "epss_percentile": 0.34775}, "CVE-2024-9762": {"epss_score": 0.00206, "epss_percentile": 0.42774}, "CVE-2024-9763": {"epss_score": 0.00193, "epss_percentile": 0.41435}, "CVE-2024-9764": {"epss_score": 0.00438, "epss_percentile": 0.62572}, "CVE-2024-9765": {"epss_score": 0.00048, "epss_percentile": 0.15122}, "CVE-2024-9766": {"epss_score": 0.00026, "epss_percentile": 0.06576}, "CVE-2024-9767": {"epss_score": 0.00393, "epss_percentile": 0.59707}, "CVE-2024-9768": {"epss_score": 0.00132, "epss_percentile": 0.33587}, "CVE-2024-9769": {"epss_score": 0.00096, "epss_percentile": 0.27302}, "CVE-2024-9770": {"epss_score": 0.00063, "epss_percentile": 0.19815}, "CVE-2024-9771": {"epss_score": 0.00034, "epss_percentile": 0.09564}, "CVE-2024-9772": {"epss_score": 0.06203, "epss_percentile": 0.90564}, "CVE-2024-9773": {"epss_score": 0.0007, "epss_percentile": 0.21682}, "CVE-2024-9774": {"epss_score": 0.00244, "epss_percentile": 0.47569}, "CVE-2024-9775": {"epss_score": 0.00207, "epss_percentile": 0.43115}, "CVE-2024-9776": {"epss_score": 0.00155, "epss_percentile": 0.36795}, "CVE-2024-9777": {"epss_score": 0.01922, "epss_percentile": 0.82906}, "CVE-2024-9778": {"epss_score": 0.00102, "epss_percentile": 0.28841}, "CVE-2024-9779": {"epss_score": 0.00227, "epss_percentile": 0.45383}, "CVE-2024-9780": {"epss_score": 0.00052, "epss_percentile": 0.16455}, "CVE-2024-9781": {"epss_score": 0.00131, "epss_percentile": 0.33412}, "CVE-2024-9782": {"epss_score": 0.00191, "epss_percentile": 0.41277}, "CVE-2024-9783": {"epss_score": 0.00158, "epss_percentile": 0.37287}, "CVE-2024-9784": {"epss_score": 0.00158, "epss_percentile": 0.37287}, "CVE-2024-9785": {"epss_score": 0.0031, "epss_percentile": 0.53746}, "CVE-2024-9786": {"epss_score": 0.0031, "epss_percentile": 0.53746}, "CVE-2024-9787": {"epss_score": 0.00133, "epss_percentile": 0.3365}, "CVE-2024-9788": {"epss_score": 0.00126, "epss_percentile": 0.32753}, "CVE-2024-9789": {"epss_score": 0.00126, "epss_percentile": 0.32753}, "CVE-2024-9790": {"epss_score": 0.00126, "epss_percentile": 0.32753}, "CVE-2024-9792": {"epss_score": 0.0022, "epss_percentile": 0.44606}, "CVE-2024-9793": {"epss_score": 0.02596, "epss_percentile": 0.85194}, "CVE-2024-9794": {"epss_score": 0.00116, "epss_percentile": 0.31138}, "CVE-2024-9796": {"epss_score": 0.77778, "epss_percentile": 0.98953}, "CVE-2024-9797": {"epss_score": 0.00063, "epss_percentile": 0.20068}, "CVE-2024-9798": {"epss_score": 0.00089, "epss_percentile": 0.25804}, "CVE-2024-9799": {"epss_score": 0.00143, "epss_percentile": 0.35172}, "CVE-2024-9802": {"epss_score": 0.00082, "epss_percentile": 0.24551}, "CVE-2024-9803": {"epss_score": 0.00171, "epss_percentile": 0.38873}, "CVE-2024-9804": {"epss_score": 0.00064, "epss_percentile": 0.2025}, "CVE-2024-9805": {"epss_score": 0.00187, "epss_percentile": 0.40738}, "CVE-2024-9806": {"epss_score": 0.00112, "epss_percentile": 0.30521}, "CVE-2024-9807": {"epss_score": 0.00102, "epss_percentile": 0.28795}, "CVE-2024-9808": {"epss_score": 0.00063, "epss_percentile": 0.19935}, "CVE-2024-9809": {"epss_score": 0.00063, "epss_percentile": 0.19935}, "CVE-2024-9810": {"epss_score": 0.00131, "epss_percentile": 0.33487}, "CVE-2024-9811": {"epss_score": 0.00073, "epss_percentile": 0.22599}, "CVE-2024-9812": {"epss_score": 0.00073, "epss_percentile": 0.22599}, "CVE-2024-9813": {"epss_score": 0.00061, "epss_percentile": 0.1927}, "CVE-2024-9814": {"epss_score": 0.00061, "epss_percentile": 0.1927}, "CVE-2024-9815": {"epss_score": 0.00074, "epss_percentile": 0.2284}, "CVE-2024-9816": {"epss_score": 0.00074, "epss_percentile": 0.2284}, "CVE-2024-9817": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-9818": {"epss_score": 0.00072, "epss_percentile": 0.22258}, "CVE-2024-9819": {"epss_score": 0.00094, "epss_percentile": 0.26782}, "CVE-2024-9820": {"epss_score": 0.00067, "epss_percentile": 0.21039}, "CVE-2024-9821": {"epss_score": 0.41052, "epss_percentile": 0.97251}, "CVE-2024-9822": {"epss_score": 0.11311, "epss_percentile": 0.93302}, "CVE-2024-9823": {"epss_score": 0.00591, "epss_percentile": 0.68581}, "CVE-2024-9824": {"epss_score": 0.00147, "epss_percentile": 0.35743}, "CVE-2024-9825": {"epss_score": 0.00059, "epss_percentile": 0.18709}, "CVE-2024-9826": {"epss_score": 0.00155, "epss_percentile": 0.36781}, "CVE-2024-9827": {"epss_score": 0.00163, "epss_percentile": 0.37846}, "CVE-2024-9828": {"epss_score": 0.0011, "epss_percentile": 0.3019}, "CVE-2024-9829": {"epss_score": 0.00341, "epss_percentile": 0.56302}, "CVE-2024-9830": {"epss_score": 0.01922, "epss_percentile": 0.82906}, "CVE-2024-9831": {"epss_score": 0.00051, "epss_percentile": 0.16211}, "CVE-2024-9832": {"epss_score": 0.00065, "epss_percentile": 0.20588}, "CVE-2024-9834": {"epss_score": 0.00034, "epss_percentile": 0.09711}, "CVE-2024-9835": {"epss_score": 0.00109, "epss_percentile": 0.29913}, "CVE-2024-9836": {"epss_score": 0.00086, "epss_percentile": 0.25286}, "CVE-2024-9837": {"epss_score": 0.01297, "epss_percentile": 0.79269}, "CVE-2024-9838": {"epss_score": 0.00035, "epss_percentile": 0.0981}, "CVE-2024-9839": {"epss_score": 0.01126, "epss_percentile": 0.77815}, "CVE-2024-9841": {"epss_score": 0.00663, "epss_percentile": 0.70621}, "CVE-2024-9842": {"epss_score": 0.00163, "epss_percentile": 0.37782}, "CVE-2024-9843": {"epss_score": 0.00151, "epss_percentile": 0.3633}, "CVE-2024-9844": {"epss_score": 0.02977, "epss_percentile": 0.86107}, "CVE-2024-9845": {"epss_score": 0.00059, "epss_percentile": 0.18707}, "CVE-2024-9846": {"epss_score": 0.00591, "epss_percentile": 0.68589}, "CVE-2024-9847": {"epss_score": 0.00076, "epss_percentile": 0.23218}, "CVE-2024-9848": {"epss_score": 0.00175, "epss_percentile": 0.39345}, "CVE-2024-9849": {"epss_score": 0.12219, "epss_percentile": 0.93605}, "CVE-2024-9850": {"epss_score": 0.00158, "epss_percentile": 0.37195}, "CVE-2024-9851": {"epss_score": 0.0009, "epss_percentile": 0.26058}, "CVE-2024-9852": {"epss_score": 0.00024, "epss_percentile": 0.05741}, "CVE-2024-9853": {"epss_score": 0.00158, "epss_percentile": 0.37168}, "CVE-2024-9855": {"epss_score": 0.00074, "epss_percentile": 0.2284}, "CVE-2024-9856": {"epss_score": 0.00102, "epss_percentile": 0.28795}, "CVE-2024-9858": {"epss_score": 0.00026, "epss_percentile": 0.06521}, "CVE-2024-9859": {"epss_score": 0.00862, "epss_percentile": 0.74572}, "CVE-2024-9860": {"epss_score": 0.00086, "epss_percentile": 0.25312}, "CVE-2024-9861": {"epss_score": 0.0014, "epss_percentile": 0.34793}, "CVE-2024-9862": {"epss_score": 0.00329, "epss_percentile": 0.55308}, "CVE-2024-9863": {"epss_score": 0.00499, "epss_percentile": 0.65262}, "CVE-2024-9864": {"epss_score": 0.0122, "epss_percentile": 0.78618}, "CVE-2024-9865": {"epss_score": 0.01128, "epss_percentile": 0.77828}, "CVE-2024-9866": {"epss_score": 0.00074, "epss_percentile": 0.228}, "CVE-2024-9867": {"epss_score": 0.00224, "epss_percentile": 0.44974}, "CVE-2024-9868": {"epss_score": 0.00243, "epss_percentile": 0.47484}, "CVE-2024-9870": {"epss_score": 0.00044, "epss_percentile": 0.13527}, "CVE-2024-9872": {"epss_score": 0.00064, "epss_percentile": 0.2028}, "CVE-2024-9873": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2024-9874": {"epss_score": 0.00793, "epss_percentile": 0.73418}, "CVE-2024-9875": {"epss_score": 0.00104, "epss_percentile": 0.29191}, "CVE-2024-9876": {"epss_score": 0.00024, "epss_percentile": 0.05885}, "CVE-2024-9877": {"epss_score": 0.00021, "epss_percentile": 0.04749}, "CVE-2024-9878": {"epss_score": 0.00289, "epss_percentile": 0.51998}, "CVE-2024-9879": {"epss_score": 0.00035, "epss_percentile": 0.0981}, "CVE-2024-9881": {"epss_score": 0.00072, "epss_percentile": 0.22462}, "CVE-2024-9882": {"epss_score": 0.00026, "epss_percentile": 0.06556}, "CVE-2024-9883": {"epss_score": 0.00188, "epss_percentile": 0.40853}, "CVE-2024-9884": {"epss_score": 0.00169, "epss_percentile": 0.38531}, "CVE-2024-9885": {"epss_score": 0.00169, "epss_percentile": 0.38531}, "CVE-2024-9886": {"epss_score": 0.00169, "epss_percentile": 0.38531}, "CVE-2024-9887": {"epss_score": 0.00721, "epss_percentile": 0.7198}, "CVE-2024-9888": {"epss_score": 0.00228, "epss_percentile": 0.4549}, "CVE-2024-9889": {"epss_score": 0.00298, "epss_percentile": 0.52837}, "CVE-2024-9890": {"epss_score": 0.1123, "epss_percentile": 0.9327}, "CVE-2024-9891": {"epss_score": 0.00135, "epss_percentile": 0.34033}, "CVE-2024-9892": {"epss_score": 0.00211, "epss_percentile": 0.43633}, "CVE-2024-9893": {"epss_score": 0.00538, "epss_percentile": 0.66927}, "CVE-2024-9894": {"epss_score": 0.00072, "epss_percentile": 0.22292}, "CVE-2024-9895": {"epss_score": 0.00322, "epss_percentile": 0.54756}, "CVE-2024-9896": {"epss_score": 0.01453, "epss_percentile": 0.80375}, "CVE-2024-9897": {"epss_score": 0.00172, "epss_percentile": 0.38951}, "CVE-2024-9898": {"epss_score": 0.00242, "epss_percentile": 0.47408}, "CVE-2024-9900": {"epss_score": 0.00106, "epss_percentile": 0.29484}, "CVE-2024-9902": {"epss_score": 0.00027, "epss_percentile": 0.06773}, "CVE-2024-9903": {"epss_score": 0.00074, "epss_percentile": 0.2284}, "CVE-2024-9904": {"epss_score": 0.00081, "epss_percentile": 0.24265}, "CVE-2024-9905": {"epss_score": 0.00078, "epss_percentile": 0.23646}, "CVE-2024-9906": {"epss_score": 0.00143, "epss_percentile": 0.35172}, "CVE-2024-9907": {"epss_score": 0.00124, "epss_percentile": 0.32394}, "CVE-2024-9908": {"epss_score": 0.00168, "epss_percentile": 0.3846}, "CVE-2024-9909": {"epss_score": 0.00091, "epss_percentile": 0.26208}, "CVE-2024-9910": {"epss_score": 0.00167, "epss_percentile": 0.38394}, "CVE-2024-9911": {"epss_score": 0.00167, "epss_percentile": 0.38394}, "CVE-2024-9912": {"epss_score": 0.00167, "epss_percentile": 0.38394}, "CVE-2024-9913": {"epss_score": 0.00219, "epss_percentile": 0.44496}, "CVE-2024-9914": {"epss_score": 0.00219, "epss_percentile": 0.44496}, "CVE-2024-9915": {"epss_score": 0.00219, "epss_percentile": 0.44496}, "CVE-2024-9916": {"epss_score": 0.85103, "epss_percentile": 0.99318}, "CVE-2024-9917": {"epss_score": 0.02657, "epss_percentile": 0.85359}, "CVE-2024-9918": {"epss_score": 0.00074, "epss_percentile": 0.22718}, "CVE-2024-9919": {"epss_score": 0.00031, "epss_percentile": 0.08645}, "CVE-2024-9920": {"epss_score": 0.0074, "epss_percentile": 0.7241}, "CVE-2024-9921": {"epss_score": 0.0078, "epss_percentile": 0.73161}, "CVE-2024-9922": {"epss_score": 0.00234, "epss_percentile": 0.46167}, "CVE-2024-9923": {"epss_score": 0.00097, "epss_percentile": 0.27464}, "CVE-2024-9924": {"epss_score": 0.012, "epss_percentile": 0.78466}, "CVE-2024-9925": {"epss_score": 0.00763, "epss_percentile": 0.72853}, "CVE-2024-9926": {"epss_score": 0.18125, "epss_percentile": 0.94961}, "CVE-2024-9927": {"epss_score": 0.00113, "epss_percentile": 0.30716}, "CVE-2024-9928": {"epss_score": 0.0009, "epss_percentile": 0.26088}, "CVE-2024-9929": {"epss_score": 0.00088, "epss_percentile": 0.25783}, "CVE-2024-9930": {"epss_score": 0.00159, "epss_percentile": 0.37374}, "CVE-2024-9931": {"epss_score": 0.00086, "epss_percentile": 0.25372}, "CVE-2024-9932": {"epss_score": 0.90007, "epss_percentile": 0.99556}, "CVE-2024-9933": {"epss_score": 0.30549, "epss_percentile": 0.9655}, "CVE-2024-9934": {"epss_score": 0.0024, "epss_percentile": 0.47224}, "CVE-2024-9935": {"epss_score": 0.93615, "epss_percentile": 0.99824}, "CVE-2024-9936": {"epss_score": 0.00311, "epss_percentile": 0.5384}, "CVE-2024-9937": {"epss_score": 0.01905, "epss_percentile": 0.82795}, "CVE-2024-9938": {"epss_score": 0.01122, "epss_percentile": 0.77785}, "CVE-2024-9939": {"epss_score": 0.02667, "epss_percentile": 0.85378}, "CVE-2024-9940": {"epss_score": 0.007, "epss_percentile": 0.71482}, "CVE-2024-9941": {"epss_score": 0.00072, "epss_percentile": 0.22318}, "CVE-2024-9942": {"epss_score": 0.03744, "epss_percentile": 0.87659}, "CVE-2024-9943": {"epss_score": 0.00104, "epss_percentile": 0.2921}, "CVE-2024-9944": {"epss_score": 0.00359, "epss_percentile": 0.57593}, "CVE-2024-9945": {"epss_score": 0.00098, "epss_percentile": 0.27792}, "CVE-2024-9946": {"epss_score": 0.00535, "epss_percentile": 0.66842}, "CVE-2024-9947": {"epss_score": 0.00375, "epss_percentile": 0.58622}, "CVE-2024-9949": {"epss_score": 0.00152, "epss_percentile": 0.36454}, "CVE-2024-9950": {"epss_score": 0.01092, "epss_percentile": 0.77467}, "CVE-2024-9951": {"epss_score": 0.00962, "epss_percentile": 0.75988}, "CVE-2024-9952": {"epss_score": 0.00211, "epss_percentile": 0.43619}, "CVE-2024-9953": {"epss_score": 0.00195, "epss_percentile": 0.41708}, "CVE-2024-9954": {"epss_score": 0.04408, "epss_percentile": 0.88654}, "CVE-2024-9955": {"epss_score": 0.20421, "epss_percentile": 0.95342}, "CVE-2024-9956": {"epss_score": 0.0002, "epss_percentile": 0.04678}, "CVE-2024-9957": {"epss_score": 0.00226, "epss_percentile": 0.45348}, "CVE-2024-9958": {"epss_score": 0.00075, "epss_percentile": 0.22965}, "CVE-2024-9959": {"epss_score": 0.00295, "epss_percentile": 0.525}, "CVE-2024-9960": {"epss_score": 0.00226, "epss_percentile": 0.45348}, "CVE-2024-9961": {"epss_score": 0.00226, "epss_percentile": 0.45348}, "CVE-2024-9962": {"epss_score": 0.00064, "epss_percentile": 0.20406}, "CVE-2024-9963": {"epss_score": 0.00098, "epss_percentile": 0.27763}, "CVE-2024-9964": {"epss_score": 0.00098, "epss_percentile": 0.27685}, "CVE-2024-9965": {"epss_score": 0.01014, "epss_percentile": 0.7664}, "CVE-2024-9966": {"epss_score": 0.00055, "epss_percentile": 0.1756}, "CVE-2024-9967": {"epss_score": 0.00191, "epss_percentile": 0.41187}, "CVE-2024-9968": {"epss_score": 0.01172, "epss_percentile": 0.7823}, "CVE-2024-9969": {"epss_score": 0.00138, "epss_percentile": 0.34427}, "CVE-2024-9970": {"epss_score": 0.0086, "epss_percentile": 0.74527}, "CVE-2024-9971": {"epss_score": 0.01441, "epss_percentile": 0.80302}, "CVE-2024-9972": {"epss_score": 0.00559, "epss_percentile": 0.67622}, "CVE-2024-9973": {"epss_score": 0.00143, "epss_percentile": 0.351}, "CVE-2024-9974": {"epss_score": 0.00145, "epss_percentile": 0.35488}, "CVE-2024-9975": {"epss_score": 0.00195, "epss_percentile": 0.41679}, "CVE-2024-9976": {"epss_score": 0.00134, "epss_percentile": 0.33818}, "CVE-2024-9977": {"epss_score": 0.14521, "epss_percentile": 0.9423}, "CVE-2024-9978": {"epss_score": 0.00038, "epss_percentile": 0.11274}, "CVE-2024-9979": {"epss_score": 0.00051, "epss_percentile": 0.1605}, "CVE-2024-9980": {"epss_score": 0.01222, "epss_percentile": 0.78658}, "CVE-2024-9981": {"epss_score": 0.03901, "epss_percentile": 0.87922}, "CVE-2024-9982": {"epss_score": 0.01262, "epss_percentile": 0.78984}, "CVE-2024-9983": {"epss_score": 0.00544, "epss_percentile": 0.67134}, "CVE-2024-9984": {"epss_score": 0.01615, "epss_percentile": 0.81353}, "CVE-2024-9985": {"epss_score": 0.00395, "epss_percentile": 0.59841}, "CVE-2024-9986": {"epss_score": 0.00076, "epss_percentile": 0.23154}, "CVE-2024-9987": {"epss_score": 0.00393, "epss_percentile": 0.59734}, "CVE-2024-9988": {"epss_score": 0.08564, "epss_percentile": 0.92127}, "CVE-2024-9989": {"epss_score": 0.92504, "epss_percentile": 0.99722}, "CVE-2024-9990": {"epss_score": 0.00305, "epss_percentile": 0.5334}, "CVE-2024-9991": {"epss_score": 0.0006, "epss_percentile": 0.19173}, "CVE-2024-9993": {"epss_score": 0.00025, "epss_percentile": 0.06378}, "CVE-2024-9994": {"epss_score": 0.00025, "epss_percentile": 0.06378}, "CVE-2024-9996": {"epss_score": 0.00285, "epss_percentile": 0.51663}, "CVE-2024-9997": {"epss_score": 0.00285, "epss_percentile": 0.51663}, "CVE-2024-9999": {"epss_score": 0.00129, "epss_percentile": 0.33133}, "CVE-2025-0001": {"epss_score": 0.00275, "epss_percentile": 0.5063}, "CVE-2025-0003": {"epss_score": 0.00014, "epss_percentile": 0.01916}, "CVE-2025-0005": {"epss_score": 0.00018, "epss_percentile": 0.03612}, "CVE-2025-0007": {"epss_score": 0.00015, "epss_percentile": 0.02199}, "CVE-2025-0009": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-0010": {"epss_score": 0.00024, "epss_percentile": 0.05678}, "CVE-2025-0011": {"epss_score": 0.00016, "epss_percentile": 0.02931}, "CVE-2025-0014": {"epss_score": 0.00016, "epss_percentile": 0.02954}, "CVE-2025-0015": {"epss_score": 0.0005, "epss_percentile": 0.15955}, "CVE-2025-0032": {"epss_score": 0.00019, "epss_percentile": 0.04395}, "CVE-2025-0033": {"epss_score": 0.00016, "epss_percentile": 0.02659}, "CVE-2025-0034": {"epss_score": 0.00029, "epss_percentile": 0.0795}, "CVE-2025-0035": {"epss_score": 0.00014, "epss_percentile": 0.01887}, "CVE-2025-0036": {"epss_score": 0.00012, "epss_percentile": 0.01232}, "CVE-2025-0037": {"epss_score": 0.00028, "epss_percentile": 0.07526}, "CVE-2025-0038": {"epss_score": 0.00018, "epss_percentile": 0.04044}, "CVE-2025-0049": {"epss_score": 0.00032, "epss_percentile": 0.09089}, "CVE-2025-0050": {"epss_score": 0.00028, "epss_percentile": 0.07579}, "CVE-2025-0051": {"epss_score": 0.00185, "epss_percentile": 0.40505}, "CVE-2025-0052": {"epss_score": 0.00102, "epss_percentile": 0.28723}, "CVE-2025-0053": {"epss_score": 0.00133, "epss_percentile": 0.3369}, "CVE-2025-0054": {"epss_score": 0.0007, "epss_percentile": 0.21645}, "CVE-2025-0055": {"epss_score": 0.00035, "epss_percentile": 0.10135}, "CVE-2025-0056": {"epss_score": 0.00035, "epss_percentile": 0.10135}, "CVE-2025-0057": {"epss_score": 0.00076, "epss_percentile": 0.23183}, "CVE-2025-0058": {"epss_score": 0.00094, "epss_percentile": 0.26959}, "CVE-2025-0059": {"epss_score": 0.00035, "epss_percentile": 0.10135}, "CVE-2025-0060": {"epss_score": 0.00118, "epss_percentile": 0.31503}, "CVE-2025-0061": {"epss_score": 0.00174, "epss_percentile": 0.39142}, "CVE-2025-0062": {"epss_score": 0.00103, "epss_percentile": 0.29093}, "CVE-2025-0063": {"epss_score": 0.003, "epss_percentile": 0.52985}, "CVE-2025-0064": {"epss_score": 0.00114, "epss_percentile": 0.30773}, "CVE-2025-0065": {"epss_score": 0.00075, "epss_percentile": 0.22956}, "CVE-2025-0066": {"epss_score": 0.00162, "epss_percentile": 0.37712}, "CVE-2025-0067": {"epss_score": 0.00103, "epss_percentile": 0.29059}, "CVE-2025-0068": {"epss_score": 0.0008, "epss_percentile": 0.24009}, "CVE-2025-0069": {"epss_score": 0.00027, "epss_percentile": 0.0676}, "CVE-2025-0070": {"epss_score": 0.00202, "epss_percentile": 0.42485}, "CVE-2025-0071": {"epss_score": 0.00138, "epss_percentile": 0.344}, "CVE-2025-0072": {"epss_score": 9e-05, "epss_percentile": 0.0068}, "CVE-2025-0073": {"epss_score": 0.00024, "epss_percentile": 0.05739}, "CVE-2025-0074": {"epss_score": 0.00228, "epss_percentile": 0.45504}, "CVE-2025-0075": {"epss_score": 0.00228, "epss_percentile": 0.45504}, "CVE-2025-0076": {"epss_score": 5e-05, "epss_percentile": 0.00192}, "CVE-2025-0077": {"epss_score": 9e-05, "epss_percentile": 0.00693}, "CVE-2025-0078": {"epss_score": 0.0003, "epss_percentile": 0.08256}, "CVE-2025-0079": {"epss_score": 6e-05, "epss_percentile": 0.00305}, "CVE-2025-0080": {"epss_score": 6e-05, "epss_percentile": 0.00312}, "CVE-2025-0081": {"epss_score": 0.00111, "epss_percentile": 0.3026}, "CVE-2025-0082": {"epss_score": 7e-05, "epss_percentile": 0.00433}, "CVE-2025-0083": {"epss_score": 8e-05, "epss_percentile": 0.00528}, "CVE-2025-0084": {"epss_score": 0.00031, "epss_percentile": 0.08564}, "CVE-2025-0086": {"epss_score": 0.00012, "epss_percentile": 0.01356}, "CVE-2025-0087": {"epss_score": 7e-05, "epss_percentile": 0.0046}, "CVE-2025-0089": {"epss_score": 0.00031, "epss_percentile": 0.08613}, "CVE-2025-0092": {"epss_score": 9e-05, "epss_percentile": 0.00642}, "CVE-2025-0093": {"epss_score": 0.00064, "epss_percentile": 0.20253}, "CVE-2025-0101": {"epss_score": 0.00083, "epss_percentile": 0.24748}, "CVE-2025-0103": {"epss_score": 0.0023, "epss_percentile": 0.45664}, "CVE-2025-0104": {"epss_score": 0.0043, "epss_percentile": 0.62028}, "CVE-2025-0105": {"epss_score": 0.01161, "epss_percentile": 0.78139}, "CVE-2025-0106": {"epss_score": 0.00411, "epss_percentile": 0.60867}, "CVE-2025-0107": {"epss_score": 0.32774, "epss_percentile": 0.96723}, "CVE-2025-0108": {"epss_score": 0.94007, "epss_percentile": 0.99884}, "CVE-2025-0109": {"epss_score": 0.00732, "epss_percentile": 0.72191}, "CVE-2025-0110": {"epss_score": 0.03138, "epss_percentile": 0.86483}, "CVE-2025-0111": {"epss_score": 0.02035, "epss_percentile": 0.83351}, "CVE-2025-0112": {"epss_score": 0.00034, "epss_percentile": 0.09546}, "CVE-2025-0113": {"epss_score": 0.00213, "epss_percentile": 0.43899}, "CVE-2025-0114": {"epss_score": 0.00046, "epss_percentile": 0.14109}, "CVE-2025-0115": {"epss_score": 0.00045, "epss_percentile": 0.14043}, "CVE-2025-0116": {"epss_score": 0.00054, "epss_percentile": 0.17308}, "CVE-2025-0117": {"epss_score": 0.00034, "epss_percentile": 0.09546}, "CVE-2025-0118": {"epss_score": 0.00143, "epss_percentile": 0.35167}, "CVE-2025-0119": {"epss_score": 0.00115, "epss_percentile": 0.30989}, "CVE-2025-0120": {"epss_score": 0.0002, "epss_percentile": 0.0465}, "CVE-2025-0121": {"epss_score": 0.00032, "epss_percentile": 0.08971}, "CVE-2025-0122": {"epss_score": 0.00052, "epss_percentile": 0.16357}, "CVE-2025-0123": {"epss_score": 0.00016, "epss_percentile": 0.02933}, "CVE-2025-0124": {"epss_score": 0.00125, "epss_percentile": 0.32617}, "CVE-2025-0125": {"epss_score": 0.00093, "epss_percentile": 0.267}, "CVE-2025-0126": {"epss_score": 0.00082, "epss_percentile": 0.2445}, "CVE-2025-0127": {"epss_score": 0.00093, "epss_percentile": 0.26666}, "CVE-2025-0128": {"epss_score": 0.00072, "epss_percentile": 0.22364}, "CVE-2025-0129": {"epss_score": 0.00029, "epss_percentile": 0.07747}, "CVE-2025-0130": {"epss_score": 0.00038, "epss_percentile": 0.11184}, "CVE-2025-0131": {"epss_score": 0.00017, "epss_percentile": 0.03251}, "CVE-2025-0132": {"epss_score": 0.00163, "epss_percentile": 0.37779}, "CVE-2025-0133": {"epss_score": 0.0596, "epss_percentile": 0.90366}, "CVE-2025-0134": {"epss_score": 0.0012, "epss_percentile": 0.31697}, "CVE-2025-0135": {"epss_score": 0.00018, "epss_percentile": 0.04026}, "CVE-2025-0136": {"epss_score": 0.00023, "epss_percentile": 0.05417}, "CVE-2025-0137": {"epss_score": 0.00051, "epss_percentile": 0.16293}, "CVE-2025-0138": {"epss_score": 0.00067, "epss_percentile": 0.21124}, "CVE-2025-0139": {"epss_score": 0.00019, "epss_percentile": 0.04087}, "CVE-2025-0140": {"epss_score": 0.00019, "epss_percentile": 0.04087}, "CVE-2025-0141": {"epss_score": 0.0002, "epss_percentile": 0.04601}, "CVE-2025-0142": {"epss_score": 0.00052, "epss_percentile": 0.16405}, "CVE-2025-0143": {"epss_score": 0.00086, "epss_percentile": 0.25381}, "CVE-2025-0144": {"epss_score": 0.00086, "epss_percentile": 0.2536}, "CVE-2025-0145": {"epss_score": 0.00022, "epss_percentile": 0.0523}, "CVE-2025-0146": {"epss_score": 0.0002, "epss_percentile": 0.04595}, "CVE-2025-0147": {"epss_score": 0.00198, "epss_percentile": 0.42079}, "CVE-2025-0148": {"epss_score": 0.00051, "epss_percentile": 0.16216}, "CVE-2025-0149": {"epss_score": 0.00065, "epss_percentile": 0.20452}, "CVE-2025-0150": {"epss_score": 0.00063, "epss_percentile": 0.20075}, "CVE-2025-0151": {"epss_score": 0.00131, "epss_percentile": 0.33402}, "CVE-2025-0154": {"epss_score": 0.00066, "epss_percentile": 0.20898}, "CVE-2025-0158": {"epss_score": 0.0002, "epss_percentile": 0.04439}, "CVE-2025-0159": {"epss_score": 0.00114, "epss_percentile": 0.30826}, "CVE-2025-0160": {"epss_score": 0.002, "epss_percentile": 0.42258}, "CVE-2025-0161": {"epss_score": 9e-05, "epss_percentile": 0.00648}, "CVE-2025-0162": {"epss_score": 0.00189, "epss_percentile": 0.40994}, "CVE-2025-0163": {"epss_score": 0.00042, "epss_percentile": 0.12937}, "CVE-2025-0164": {"epss_score": 0.00013, "epss_percentile": 0.01718}, "CVE-2025-0165": {"epss_score": 0.00185, "epss_percentile": 0.40474}, "CVE-2025-0167": {"epss_score": 0.0016, "epss_percentile": 0.37455}, "CVE-2025-0168": {"epss_score": 0.00025, "epss_percentile": 0.06208}, "CVE-2025-0169": {"epss_score": 0.00022, "epss_percentile": 0.05022}, "CVE-2025-0170": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2025-0171": {"epss_score": 0.00086, "epss_percentile": 0.25439}, "CVE-2025-0172": {"epss_score": 0.00086, "epss_percentile": 0.25439}, "CVE-2025-0173": {"epss_score": 0.00077, "epss_percentile": 0.23528}, "CVE-2025-0174": {"epss_score": 0.00079, "epss_percentile": 0.23984}, "CVE-2025-0175": {"epss_score": 0.00098, "epss_percentile": 0.27745}, "CVE-2025-0176": {"epss_score": 0.0008, "epss_percentile": 0.24174}, "CVE-2025-0177": {"epss_score": 0.00551, "epss_percentile": 0.67361}, "CVE-2025-0178": {"epss_score": 0.00152, "epss_percentile": 0.3637}, "CVE-2025-0180": {"epss_score": 0.00416, "epss_percentile": 0.61178}, "CVE-2025-0181": {"epss_score": 0.00454, "epss_percentile": 0.63255}, "CVE-2025-0182": {"epss_score": 0.00078, "epss_percentile": 0.23684}, "CVE-2025-0183": {"epss_score": 0.00047, "epss_percentile": 0.14633}, "CVE-2025-0184": {"epss_score": 0.00102, "epss_percentile": 0.28829}, "CVE-2025-0185": {"epss_score": 0.00834, "epss_percentile": 0.74102}, "CVE-2025-0187": {"epss_score": 0.00557, "epss_percentile": 0.67533}, "CVE-2025-0188": {"epss_score": 0.00107, "epss_percentile": 0.29588}, "CVE-2025-0189": {"epss_score": 0.00122, "epss_percentile": 0.32171}, "CVE-2025-0190": {"epss_score": 0.00122, "epss_percentile": 0.32171}, "CVE-2025-0191": {"epss_score": 0.00083, "epss_percentile": 0.2479}, "CVE-2025-0192": {"epss_score": 0.00043, "epss_percentile": 0.13275}, "CVE-2025-0193": {"epss_score": 0.00297, "epss_percentile": 0.52684}, "CVE-2025-0194": {"epss_score": 0.00059, "epss_percentile": 0.18825}, "CVE-2025-0195": {"epss_score": 0.00077, "epss_percentile": 0.23528}, "CVE-2025-0196": {"epss_score": 0.00079, "epss_percentile": 0.23984}, "CVE-2025-0197": {"epss_score": 0.00071, "epss_percentile": 0.22114}, "CVE-2025-0198": {"epss_score": 0.00077, "epss_percentile": 0.23528}, "CVE-2025-0199": {"epss_score": 0.00086, "epss_percentile": 0.25439}, "CVE-2025-0200": {"epss_score": 0.00079, "epss_percentile": 0.23984}, "CVE-2025-0201": {"epss_score": 0.00079, "epss_percentile": 0.23984}, "CVE-2025-0202": {"epss_score": 0.00035, "epss_percentile": 0.09938}, "CVE-2025-0203": {"epss_score": 0.00135, "epss_percentile": 0.3393}, "CVE-2025-0204": {"epss_score": 0.00135, "epss_percentile": 0.3393}, "CVE-2025-0205": {"epss_score": 0.00136, "epss_percentile": 0.34163}, "CVE-2025-0206": {"epss_score": 0.00167, "epss_percentile": 0.3829}, "CVE-2025-0207": {"epss_score": 0.00116, "epss_percentile": 0.31129}, "CVE-2025-0208": {"epss_score": 0.00123, "epss_percentile": 0.32333}, "CVE-2025-0209": {"epss_score": 0.00051, "epss_percentile": 0.16193}, "CVE-2025-0210": {"epss_score": 0.00131, "epss_percentile": 0.33452}, "CVE-2025-0211": {"epss_score": 0.00265, "epss_percentile": 0.49826}, "CVE-2025-0212": {"epss_score": 0.00125, "epss_percentile": 0.32558}, "CVE-2025-0213": {"epss_score": 0.00205, "epss_percentile": 0.42723}, "CVE-2025-0214": {"epss_score": 0.0008, "epss_percentile": 0.24097}, "CVE-2025-0215": {"epss_score": 0.0136, "epss_percentile": 0.79749}, "CVE-2025-0217": {"epss_score": 0.00028, "epss_percentile": 0.07352}, "CVE-2025-0218": {"epss_score": 0.00042, "epss_percentile": 0.12523}, "CVE-2025-0219": {"epss_score": 0.00089, "epss_percentile": 0.25817}, "CVE-2025-0220": {"epss_score": 0.00099, "epss_percentile": 0.28398}, "CVE-2025-0221": {"epss_score": 0.00032, "epss_percentile": 0.09109}, "CVE-2025-0222": {"epss_score": 0.00032, "epss_percentile": 0.09109}, "CVE-2025-0223": {"epss_score": 0.00032, "epss_percentile": 0.09109}, "CVE-2025-0224": {"epss_score": 0.00111, "epss_percentile": 0.30408}, "CVE-2025-0225": {"epss_score": 0.00185, "epss_percentile": 0.40575}, "CVE-2025-0226": {"epss_score": 0.00092, "epss_percentile": 0.26421}, "CVE-2025-0227": {"epss_score": 0.00092, "epss_percentile": 0.26421}, "CVE-2025-0228": {"epss_score": 0.00086, "epss_percentile": 0.25413}, "CVE-2025-0229": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2025-0230": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2025-0231": {"epss_score": 0.00147, "epss_percentile": 0.35794}, "CVE-2025-0232": {"epss_score": 0.00136, "epss_percentile": 0.34117}, "CVE-2025-0233": {"epss_score": 0.00128, "epss_percentile": 0.33035}, "CVE-2025-0234": {"epss_score": 0.00152, "epss_percentile": 0.3637}, "CVE-2025-0235": {"epss_score": 0.00152, "epss_percentile": 0.3637}, "CVE-2025-0236": {"epss_score": 0.00152, "epss_percentile": 0.3637}, "CVE-2025-0237": {"epss_score": 0.00338, "epss_percentile": 0.5614}, "CVE-2025-0238": {"epss_score": 0.00463, "epss_percentile": 0.63676}, "CVE-2025-0239": {"epss_score": 0.00045, "epss_percentile": 0.13895}, "CVE-2025-0240": {"epss_score": 0.00093, "epss_percentile": 0.26651}, "CVE-2025-0241": {"epss_score": 0.00555, "epss_percentile": 0.67467}, "CVE-2025-0242": {"epss_score": 0.00841, "epss_percentile": 0.74217}, "CVE-2025-0243": {"epss_score": 0.00087, "epss_percentile": 0.25536}, "CVE-2025-0244": {"epss_score": 0.0026, "epss_percentile": 0.49232}, "CVE-2025-0245": {"epss_score": 0.00028, "epss_percentile": 0.07326}, "CVE-2025-0246": {"epss_score": 0.00139, "epss_percentile": 0.34589}, "CVE-2025-0247": {"epss_score": 0.00758, "epss_percentile": 0.72777}, "CVE-2025-0248": {"epss_score": 0.00031, "epss_percentile": 0.08623}, "CVE-2025-0249": {"epss_score": 0.00032, "epss_percentile": 0.09004}, "CVE-2025-0250": {"epss_score": 0.00016, "epss_percentile": 0.02965}, "CVE-2025-0251": {"epss_score": 0.00029, "epss_percentile": 0.0766}, "CVE-2025-0252": {"epss_score": 0.0002, "epss_percentile": 0.04642}, "CVE-2025-0253": {"epss_score": 0.00025, "epss_percentile": 0.06147}, "CVE-2025-0254": {"epss_score": 0.00053, "epss_percentile": 0.16862}, "CVE-2025-0255": {"epss_score": 0.00179, "epss_percentile": 0.39824}, "CVE-2025-0256": {"epss_score": 0.00067, "epss_percentile": 0.21102}, "CVE-2025-0257": {"epss_score": 0.00052, "epss_percentile": 0.16598}, "CVE-2025-0272": {"epss_score": 0.00052, "epss_percentile": 0.16368}, "CVE-2025-0273": {"epss_score": 0.00025, "epss_percentile": 0.06313}, "CVE-2025-0274": {"epss_score": 0.00044, "epss_percentile": 0.13533}, "CVE-2025-0275": {"epss_score": 0.00044, "epss_percentile": 0.13533}, "CVE-2025-0276": {"epss_score": 0.00053, "epss_percentile": 0.16902}, "CVE-2025-0277": {"epss_score": 0.00053, "epss_percentile": 0.16902}, "CVE-2025-0278": {"epss_score": 0.00071, "epss_percentile": 0.22222}, "CVE-2025-0279": {"epss_score": 0.00071, "epss_percentile": 0.22222}, "CVE-2025-0280": {"epss_score": 0.00023, "epss_percentile": 0.05431}, "CVE-2025-0281": {"epss_score": 0.00069, "epss_percentile": 0.21599}, "CVE-2025-0282": {"epss_score": 0.94105, "epss_percentile": 0.99904}, "CVE-2025-0283": {"epss_score": 0.2299, "epss_percentile": 0.95714}, "CVE-2025-0285": {"epss_score": 0.00035, "epss_percentile": 0.09906}, "CVE-2025-0286": {"epss_score": 0.00039, "epss_percentile": 0.11718}, "CVE-2025-0287": {"epss_score": 0.00037, "epss_percentile": 0.10623}, "CVE-2025-0288": {"epss_score": 0.00038, "epss_percentile": 0.11118}, "CVE-2025-0289": {"epss_score": 0.00035, "epss_percentile": 0.09906}, "CVE-2025-0290": {"epss_score": 0.00024, "epss_percentile": 0.05821}, "CVE-2025-0291": {"epss_score": 0.01457, "epss_percentile": 0.80401}, "CVE-2025-0292": {"epss_score": 0.00511, "epss_percentile": 0.65835}, "CVE-2025-0293": {"epss_score": 0.0003, "epss_percentile": 0.0814}, "CVE-2025-0294": {"epss_score": 0.00138, "epss_percentile": 0.34466}, "CVE-2025-0295": {"epss_score": 0.00098, "epss_percentile": 0.27745}, "CVE-2025-0296": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-0297": {"epss_score": 0.00199, "epss_percentile": 0.42114}, "CVE-2025-0298": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2025-0299": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2025-0300": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2025-0301": {"epss_score": 0.00098, "epss_percentile": 0.27745}, "CVE-2025-0302": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2025-0303": {"epss_score": 0.00035, "epss_percentile": 0.10064}, "CVE-2025-0304": {"epss_score": 0.00039, "epss_percentile": 0.11719}, "CVE-2025-0306": {"epss_score": 0.0027, "epss_percentile": 0.50255}, "CVE-2025-0308": {"epss_score": 0.01257, "epss_percentile": 0.78945}, "CVE-2025-0309": {"epss_score": 0.00019, "epss_percentile": 0.04247}, "CVE-2025-0311": {"epss_score": 0.0017, "epss_percentile": 0.38685}, "CVE-2025-0312": {"epss_score": 0.00198, "epss_percentile": 0.42078}, "CVE-2025-0314": {"epss_score": 0.02269, "epss_percentile": 0.84205}, "CVE-2025-0315": {"epss_score": 0.00214, "epss_percentile": 0.4402}, "CVE-2025-0316": {"epss_score": 0.01592, "epss_percentile": 0.81225}, "CVE-2025-0317": {"epss_score": 0.00348, "epss_percentile": 0.56832}, "CVE-2025-0318": {"epss_score": 0.00281, "epss_percentile": 0.51191}, "CVE-2025-0320": {"epss_score": 0.00019, "epss_percentile": 0.04076}, "CVE-2025-0321": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2025-0324": {"epss_score": 0.00064, "epss_percentile": 0.20306}, "CVE-2025-0325": {"epss_score": 0.00073, "epss_percentile": 0.2264}, "CVE-2025-0327": {"epss_score": 0.00033, "epss_percentile": 0.09326}, "CVE-2025-0328": {"epss_score": 0.02137, "epss_percentile": 0.83732}, "CVE-2025-0329": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2025-0330": {"epss_score": 0.0012, "epss_percentile": 0.31762}, "CVE-2025-0331": {"epss_score": 0.00096, "epss_percentile": 0.27344}, "CVE-2025-0332": {"epss_score": 0.00144, "epss_percentile": 0.35306}, "CVE-2025-0333": {"epss_score": 0.00147, "epss_percentile": 0.35794}, "CVE-2025-0334": {"epss_score": 0.00147, "epss_percentile": 0.35794}, "CVE-2025-0335": {"epss_score": 0.00173, "epss_percentile": 0.39086}, "CVE-2025-0336": {"epss_score": 0.00154, "epss_percentile": 0.36744}, "CVE-2025-0337": {"epss_score": 0.00094, "epss_percentile": 0.26959}, "CVE-2025-0339": {"epss_score": 0.00092, "epss_percentile": 0.26559}, "CVE-2025-0340": {"epss_score": 0.00134, "epss_percentile": 0.33841}, "CVE-2025-0341": {"epss_score": 0.00185, "epss_percentile": 0.40527}, "CVE-2025-0342": {"epss_score": 0.00098, "epss_percentile": 0.27745}, "CVE-2025-0343": {"epss_score": 0.00172, "epss_percentile": 0.38974}, "CVE-2025-0344": {"epss_score": 0.00115, "epss_percentile": 0.31016}, "CVE-2025-0345": {"epss_score": 0.00147, "epss_percentile": 0.35794}, "CVE-2025-0346": {"epss_score": 0.00159, "epss_percentile": 0.37306}, "CVE-2025-0347": {"epss_score": 0.00116, "epss_percentile": 0.31129}, "CVE-2025-0348": {"epss_score": 0.00098, "epss_percentile": 0.27745}, "CVE-2025-0349": {"epss_score": 0.00771, "epss_percentile": 0.73015}, "CVE-2025-0350": {"epss_score": 0.00028, "epss_percentile": 0.07523}, "CVE-2025-0352": {"epss_score": 0.00116, "epss_percentile": 0.31112}, "CVE-2025-0353": {"epss_score": 0.00245, "epss_percentile": 0.47669}, "CVE-2025-0354": {"epss_score": 0.0008, "epss_percentile": 0.24146}, "CVE-2025-0355": {"epss_score": 0.00164, "epss_percentile": 0.37944}, "CVE-2025-0356": {"epss_score": 0.00147, "epss_percentile": 0.35694}, "CVE-2025-0357": {"epss_score": 0.01115, "epss_percentile": 0.77714}, "CVE-2025-0358": {"epss_score": 0.00019, "epss_percentile": 0.04281}, "CVE-2025-0359": {"epss_score": 0.00032, "epss_percentile": 0.08855}, "CVE-2025-0360": {"epss_score": 0.00028, "epss_percentile": 0.07345}, "CVE-2025-0361": {"epss_score": 0.00083, "epss_percentile": 0.24822}, "CVE-2025-0362": {"epss_score": 0.00016, "epss_percentile": 0.03042}, "CVE-2025-0364": {"epss_score": 0.25628, "epss_percentile": 0.96051}, "CVE-2025-0365": {"epss_score": 0.01114, "epss_percentile": 0.777}, "CVE-2025-0366": {"epss_score": 0.01097, "epss_percentile": 0.77525}, "CVE-2025-0367": {"epss_score": 0.00141, "epss_percentile": 0.34925}, "CVE-2025-0368": {"epss_score": 0.00237, "epss_percentile": 0.46648}, "CVE-2025-0369": {"epss_score": 0.00119, "epss_percentile": 0.31548}, "CVE-2025-0370": {"epss_score": 0.00348, "epss_percentile": 0.5682}, "CVE-2025-0371": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2025-0372": {"epss_score": 0.00013, "epss_percentile": 0.0169}, "CVE-2025-0373": {"epss_score": 0.00359, "epss_percentile": 0.57616}, "CVE-2025-0374": {"epss_score": 0.00101, "epss_percentile": 0.28631}, "CVE-2025-0376": {"epss_score": 0.02081, "epss_percentile": 0.83532}, "CVE-2025-0377": {"epss_score": 0.0011, "epss_percentile": 0.30195}, "CVE-2025-0390": {"epss_score": 0.00678, "epss_percentile": 0.7099}, "CVE-2025-0391": {"epss_score": 0.00124, "epss_percentile": 0.32396}, "CVE-2025-0392": {"epss_score": 0.00095, "epss_percentile": 0.27174}, "CVE-2025-0393": {"epss_score": 0.00057, "epss_percentile": 0.1822}, "CVE-2025-0394": {"epss_score": 0.01391, "epss_percentile": 0.79954}, "CVE-2025-0395": {"epss_score": 0.00645, "epss_percentile": 0.7012}, "CVE-2025-0396": {"epss_score": 0.00305, "epss_percentile": 0.53371}, "CVE-2025-0397": {"epss_score": 0.00104, "epss_percentile": 0.29184}, "CVE-2025-0398": {"epss_score": 0.00115, "epss_percentile": 0.309}, "CVE-2025-0399": {"epss_score": 0.00146, "epss_percentile": 0.35622}, "CVE-2025-0400": {"epss_score": 0.00108, "epss_percentile": 0.2985}, "CVE-2025-0401": {"epss_score": 0.00226, "epss_percentile": 0.45355}, "CVE-2025-0402": {"epss_score": 0.00151, "epss_percentile": 0.36359}, "CVE-2025-0403": {"epss_score": 0.00096, "epss_percentile": 0.27287}, "CVE-2025-0404": {"epss_score": 0.00085, "epss_percentile": 0.25123}, "CVE-2025-0405": {"epss_score": 0.00105, "epss_percentile": 0.2935}, "CVE-2025-0406": {"epss_score": 0.00096, "epss_percentile": 0.27381}, "CVE-2025-0407": {"epss_score": 0.00096, "epss_percentile": 0.27381}, "CVE-2025-0408": {"epss_score": 0.00096, "epss_percentile": 0.27381}, "CVE-2025-0409": {"epss_score": 0.00096, "epss_percentile": 0.27381}, "CVE-2025-0410": {"epss_score": 0.00096, "epss_percentile": 0.27381}, "CVE-2025-0411": {"epss_score": 0.32631, "epss_percentile": 0.96714}, "CVE-2025-0412": {"epss_score": 0.00108, "epss_percentile": 0.29788}, "CVE-2025-0413": {"epss_score": 0.0005, "epss_percentile": 0.15723}, "CVE-2025-0415": {"epss_score": 0.00219, "epss_percentile": 0.44499}, "CVE-2025-0416": {"epss_score": 0.00028, "epss_percentile": 0.07274}, "CVE-2025-0417": {"epss_score": 0.00029, "epss_percentile": 0.07747}, "CVE-2025-0418": {"epss_score": 0.00022, "epss_percentile": 0.0506}, "CVE-2025-0419": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2025-0420": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2025-0421": {"epss_score": 0.00045, "epss_percentile": 0.13771}, "CVE-2025-0422": {"epss_score": 0.003, "epss_percentile": 0.52992}, "CVE-2025-0423": {"epss_score": 0.00502, "epss_percentile": 0.65405}, "CVE-2025-0424": {"epss_score": 0.00156, "epss_percentile": 0.36995}, "CVE-2025-0425": {"epss_score": 0.00035, "epss_percentile": 0.09915}, "CVE-2025-0426": {"epss_score": 0.00037, "epss_percentile": 0.10969}, "CVE-2025-0427": {"epss_score": 0.00021, "epss_percentile": 0.04879}, "CVE-2025-0428": {"epss_score": 0.01468, "epss_percentile": 0.8048}, "CVE-2025-0429": {"epss_score": 0.01468, "epss_percentile": 0.8048}, "CVE-2025-0430": {"epss_score": 0.0026, "epss_percentile": 0.49148}, "CVE-2025-0431": {"epss_score": 0.00066, "epss_percentile": 0.2088}, "CVE-2025-0432": {"epss_score": 0.0001, "epss_percentile": 0.00847}, "CVE-2025-0433": {"epss_score": 0.00097, "epss_percentile": 0.27602}, "CVE-2025-0434": {"epss_score": 0.00165, "epss_percentile": 0.38104}, "CVE-2025-0435": {"epss_score": 0.00077, "epss_percentile": 0.23463}, "CVE-2025-0436": {"epss_score": 0.00195, "epss_percentile": 0.41635}, "CVE-2025-0437": {"epss_score": 0.00089, "epss_percentile": 0.25907}, "CVE-2025-0438": {"epss_score": 0.00219, "epss_percentile": 0.44531}, "CVE-2025-0439": {"epss_score": 0.00082, "epss_percentile": 0.24561}, "CVE-2025-0440": {"epss_score": 0.00067, "epss_percentile": 0.21113}, "CVE-2025-0441": {"epss_score": 0.00111, "epss_percentile": 0.30407}, "CVE-2025-0442": {"epss_score": 0.00124, "epss_percentile": 0.32385}, "CVE-2025-0443": {"epss_score": 0.00438, "epss_percentile": 0.62541}, "CVE-2025-0444": {"epss_score": 0.00423, "epss_percentile": 0.61593}, "CVE-2025-0445": {"epss_score": 0.00152, "epss_percentile": 0.36444}, "CVE-2025-0446": {"epss_score": 0.00101, "epss_percentile": 0.28659}, "CVE-2025-0447": {"epss_score": 0.00365, "epss_percentile": 0.57964}, "CVE-2025-0448": {"epss_score": 0.0011, "epss_percentile": 0.30099}, "CVE-2025-0450": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2025-0451": {"epss_score": 0.00267, "epss_percentile": 0.4999}, "CVE-2025-0452": {"epss_score": 0.00157, "epss_percentile": 0.37111}, "CVE-2025-0453": {"epss_score": 0.00122, "epss_percentile": 0.32171}, "CVE-2025-0454": {"epss_score": 0.00087, "epss_percentile": 0.25444}, "CVE-2025-0455": {"epss_score": 0.01089, "epss_percentile": 0.77446}, "CVE-2025-0456": {"epss_score": 0.005, "epss_percentile": 0.65326}, "CVE-2025-0457": {"epss_score": 0.01331, "epss_percentile": 0.79515}, "CVE-2025-0458": {"epss_score": 0.00079, "epss_percentile": 0.23874}, "CVE-2025-0459": {"epss_score": 0.00031, "epss_percentile": 0.08416}, "CVE-2025-0460": {"epss_score": 0.00133, "epss_percentile": 0.33713}, "CVE-2025-0461": {"epss_score": 0.00437, "epss_percentile": 0.62518}, "CVE-2025-0462": {"epss_score": 0.00121, "epss_percentile": 0.32011}, "CVE-2025-0463": {"epss_score": 0.00175, "epss_percentile": 0.39336}, "CVE-2025-0464": {"epss_score": 0.00094, "epss_percentile": 0.26762}, "CVE-2025-0465": {"epss_score": 0.00179, "epss_percentile": 0.39798}, "CVE-2025-0466": {"epss_score": 0.00219, "epss_percentile": 0.44522}, "CVE-2025-0467": {"epss_score": 0.00021, "epss_percentile": 0.04757}, "CVE-2025-0468": {"epss_score": 0.00023, "epss_percentile": 0.0559}, "CVE-2025-0469": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2025-0470": {"epss_score": 0.00676, "epss_percentile": 0.70919}, "CVE-2025-0471": {"epss_score": 0.00723, "epss_percentile": 0.7202}, "CVE-2025-0472": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2025-0473": {"epss_score": 0.00243, "epss_percentile": 0.47426}, "CVE-2025-0474": {"epss_score": 0.00136, "epss_percentile": 0.34129}, "CVE-2025-0475": {"epss_score": 0.00314, "epss_percentile": 0.54141}, "CVE-2025-0476": {"epss_score": 0.00311, "epss_percentile": 0.53923}, "CVE-2025-0477": {"epss_score": 0.00461, "epss_percentile": 0.63545}, "CVE-2025-0478": {"epss_score": 0.00022, "epss_percentile": 0.05061}, "CVE-2025-0479": {"epss_score": 0.00143, "epss_percentile": 0.35099}, "CVE-2025-0480": {"epss_score": 0.00094, "epss_percentile": 0.27047}, "CVE-2025-0481": {"epss_score": 0.0011, "epss_percentile": 0.30131}, "CVE-2025-0482": {"epss_score": 0.00185, "epss_percentile": 0.4046}, "CVE-2025-0483": {"epss_score": 0.00138, "epss_percentile": 0.34402}, "CVE-2025-0484": {"epss_score": 0.00112, "epss_percentile": 0.30544}, "CVE-2025-0485": {"epss_score": 0.001, "epss_percentile": 0.28511}, "CVE-2025-0486": {"epss_score": 0.0012, "epss_percentile": 0.31794}, "CVE-2025-0487": {"epss_score": 0.00109, "epss_percentile": 0.30002}, "CVE-2025-0488": {"epss_score": 0.00108, "epss_percentile": 0.29889}, "CVE-2025-0489": {"epss_score": 0.00108, "epss_percentile": 0.29889}, "CVE-2025-0490": {"epss_score": 0.00108, "epss_percentile": 0.29889}, "CVE-2025-0491": {"epss_score": 0.00109, "epss_percentile": 0.30002}, "CVE-2025-0492": {"epss_score": 0.01701, "epss_percentile": 0.81836}, "CVE-2025-0493": {"epss_score": 0.00924, "epss_percentile": 0.75525}, "CVE-2025-0495": {"epss_score": 0.00039, "epss_percentile": 0.11774}, "CVE-2025-0497": {"epss_score": 0.00089, "epss_percentile": 0.25797}, "CVE-2025-0498": {"epss_score": 0.00151, "epss_percentile": 0.36225}, "CVE-2025-0500": {"epss_score": 0.00304, "epss_percentile": 0.53297}, "CVE-2025-0501": {"epss_score": 0.00211, "epss_percentile": 0.43676}, "CVE-2025-0502": {"epss_score": 0.00289, "epss_percentile": 0.52048}, "CVE-2025-0503": {"epss_score": 0.00107, "epss_percentile": 0.2969}, "CVE-2025-0504": {"epss_score": 0.00026, "epss_percentile": 0.06722}, "CVE-2025-0505": {"epss_score": 0.00051, "epss_percentile": 0.16021}, "CVE-2025-0506": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2025-0507": {"epss_score": 0.00104, "epss_percentile": 0.29108}, "CVE-2025-0508": {"epss_score": 0.00048, "epss_percentile": 0.15134}, "CVE-2025-0509": {"epss_score": 0.00074, "epss_percentile": 0.2279}, "CVE-2025-0510": {"epss_score": 0.00159, "epss_percentile": 0.37302}, "CVE-2025-0511": {"epss_score": 0.0081, "epss_percentile": 0.73717}, "CVE-2025-0512": {"epss_score": 0.001, "epss_percentile": 0.2844}, "CVE-2025-0513": {"epss_score": 0.00059, "epss_percentile": 0.18709}, "CVE-2025-0514": {"epss_score": 0.00046, "epss_percentile": 0.1424}, "CVE-2025-0515": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2025-0516": {"epss_score": 0.00036, "epss_percentile": 0.10448}, "CVE-2025-0518": {"epss_score": 0.00162, "epss_percentile": 0.37733}, "CVE-2025-0520": {"epss_score": 0.00628, "epss_percentile": 0.69646}, "CVE-2025-0521": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2025-0522": {"epss_score": 0.00082, "epss_percentile": 0.24454}, "CVE-2025-0525": {"epss_score": 0.00118, "epss_percentile": 0.31431}, "CVE-2025-0526": {"epss_score": 0.00114, "epss_percentile": 0.30855}, "CVE-2025-0527": {"epss_score": 0.00118, "epss_percentile": 0.31425}, "CVE-2025-0528": {"epss_score": 0.05589, "epss_percentile": 0.90028}, "CVE-2025-0529": {"epss_score": 0.0004, "epss_percentile": 0.12056}, "CVE-2025-0530": {"epss_score": 0.00268, "epss_percentile": 0.5007}, "CVE-2025-0531": {"epss_score": 0.00077, "epss_percentile": 0.23528}, "CVE-2025-0532": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-0533": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2025-0534": {"epss_score": 0.00158, "epss_percentile": 0.37181}, "CVE-2025-0535": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-0536": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-0537": {"epss_score": 0.00098, "epss_percentile": 0.27761}, "CVE-2025-0538": {"epss_score": 0.00112, "epss_percentile": 0.30507}, "CVE-2025-0539": {"epss_score": 0.00055, "epss_percentile": 0.17556}, "CVE-2025-0540": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-0541": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-0542": {"epss_score": 0.00032, "epss_percentile": 0.08866}, "CVE-2025-0543": {"epss_score": 0.00028, "epss_percentile": 0.07476}, "CVE-2025-0545": {"epss_score": 0.00143, "epss_percentile": 0.351}, "CVE-2025-0546": {"epss_score": 0.00052, "epss_percentile": 0.16581}, "CVE-2025-0547": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2025-0549": {"epss_score": 0.00012, "epss_percentile": 0.01347}, "CVE-2025-0554": {"epss_score": 0.00131, "epss_percentile": 0.3343}, "CVE-2025-0555": {"epss_score": 0.00232, "epss_percentile": 0.45889}, "CVE-2025-0556": {"epss_score": 0.00194, "epss_percentile": 0.41545}, "CVE-2025-0557": {"epss_score": 0.00144, "epss_percentile": 0.35269}, "CVE-2025-0558": {"epss_score": 0.00121, "epss_percentile": 0.32011}, "CVE-2025-0559": {"epss_score": 0.00098, "epss_percentile": 0.27761}, "CVE-2025-0560": {"epss_score": 0.00098, "epss_percentile": 0.27761}, "CVE-2025-0561": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2025-0562": {"epss_score": 0.00142, "epss_percentile": 0.35036}, "CVE-2025-0563": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2025-0564": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2025-0565": {"epss_score": 0.00179, "epss_percentile": 0.39805}, "CVE-2025-0566": {"epss_score": 0.01072, "epss_percentile": 0.7728}, "CVE-2025-0567": {"epss_score": 0.00024, "epss_percentile": 0.06017}, "CVE-2025-0568": {"epss_score": 0.00369, "epss_percentile": 0.58236}, "CVE-2025-0569": {"epss_score": 0.00416, "epss_percentile": 0.61168}, "CVE-2025-0570": {"epss_score": 0.0024, "epss_percentile": 0.47199}, "CVE-2025-0571": {"epss_score": 0.00269, "epss_percentile": 0.50153}, "CVE-2025-0572": {"epss_score": 0.01993, "epss_percentile": 0.83183}, "CVE-2025-0573": {"epss_score": 0.03003, "epss_percentile": 0.86175}, "CVE-2025-0574": {"epss_score": 0.00299, "epss_percentile": 0.52867}, "CVE-2025-0575": {"epss_score": 0.00037, "epss_percentile": 0.10893}, "CVE-2025-0576": {"epss_score": 0.00079, "epss_percentile": 0.23874}, "CVE-2025-0578": {"epss_score": 0.00081, "epss_percentile": 0.24208}, "CVE-2025-0579": {"epss_score": 0.00092, "epss_percentile": 0.26592}, "CVE-2025-0580": {"epss_score": 0.00143, "epss_percentile": 0.35154}, "CVE-2025-0581": {"epss_score": 0.00091, "epss_percentile": 0.26192}, "CVE-2025-0582": {"epss_score": 0.00159, "epss_percentile": 0.37306}, "CVE-2025-0583": {"epss_score": 0.00032, "epss_percentile": 0.08798}, "CVE-2025-0584": {"epss_score": 0.00031, "epss_percentile": 0.08571}, "CVE-2025-0585": {"epss_score": 0.00152, "epss_percentile": 0.36425}, "CVE-2025-0586": {"epss_score": 0.02527, "epss_percentile": 0.85016}, "CVE-2025-0587": {"epss_score": 0.00027, "epss_percentile": 0.06772}, "CVE-2025-0588": {"epss_score": 0.00107, "epss_percentile": 0.29686}, "CVE-2025-0589": {"epss_score": 0.0014, "epss_percentile": 0.34755}, "CVE-2025-0590": {"epss_score": 0.00146, "epss_percentile": 0.35612}, "CVE-2025-0591": {"epss_score": 0.00031, "epss_percentile": 0.08326}, "CVE-2025-0592": {"epss_score": 0.00168, "epss_percentile": 0.38505}, "CVE-2025-0593": {"epss_score": 0.00477, "epss_percentile": 0.64354}, "CVE-2025-0595": {"epss_score": 0.00068, "epss_percentile": 0.2139}, "CVE-2025-0596": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2025-0598": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2025-0599": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2025-0600": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2025-0601": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2025-0602": {"epss_score": 0.00029, "epss_percentile": 0.07648}, "CVE-2025-0603": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-0604": {"epss_score": 0.00056, "epss_percentile": 0.17864}, "CVE-2025-0605": {"epss_score": 0.00018, "epss_percentile": 0.03612}, "CVE-2025-0606": {"epss_score": 0.00052, "epss_percentile": 0.16667}, "CVE-2025-0607": {"epss_score": 0.00039, "epss_percentile": 0.11768}, "CVE-2025-0608": {"epss_score": 0.00039, "epss_percentile": 0.11708}, "CVE-2025-0609": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2025-0610": {"epss_score": 0.00033, "epss_percentile": 0.09291}, "CVE-2025-0611": {"epss_score": 0.00254, "epss_percentile": 0.48496}, "CVE-2025-0612": {"epss_score": 0.002, "epss_percentile": 0.42248}, "CVE-2025-0613": {"epss_score": 0.00157, "epss_percentile": 0.37062}, "CVE-2025-0614": {"epss_score": 0.00234, "epss_percentile": 0.46154}, "CVE-2025-0615": {"epss_score": 0.00234, "epss_percentile": 0.46154}, "CVE-2025-0616": {"epss_score": 0.00053, "epss_percentile": 0.1673}, "CVE-2025-0617": {"epss_score": 0.00352, "epss_percentile": 0.57129}, "CVE-2025-0618": {"epss_score": 0.00151, "epss_percentile": 0.36249}, "CVE-2025-0619": {"epss_score": 0.00101, "epss_percentile": 0.2858}, "CVE-2025-0620": {"epss_score": 0.00078, "epss_percentile": 0.23774}, "CVE-2025-0622": {"epss_score": 0.00086, "epss_percentile": 0.25356}, "CVE-2025-0624": {"epss_score": 0.02486, "epss_percentile": 0.84886}, "CVE-2025-0625": {"epss_score": 0.00128, "epss_percentile": 0.32999}, "CVE-2025-0626": {"epss_score": 0.00319, "epss_percentile": 0.54481}, "CVE-2025-0627": {"epss_score": 0.00034, "epss_percentile": 0.09564}, "CVE-2025-0628": {"epss_score": 0.00081, "epss_percentile": 0.24343}, "CVE-2025-0629": {"epss_score": 0.00087, "epss_percentile": 0.25514}, "CVE-2025-0630": {"epss_score": 0.0012, "epss_percentile": 0.31731}, "CVE-2025-0631": {"epss_score": 0.00082, "epss_percentile": 0.24586}, "CVE-2025-0632": {"epss_score": 0.01002, "epss_percentile": 0.76506}, "CVE-2025-0633": {"epss_score": 0.00042, "epss_percentile": 0.12602}, "CVE-2025-0634": {"epss_score": 0.00061, "epss_percentile": 0.19431}, "CVE-2025-0635": {"epss_score": 0.00131, "epss_percentile": 0.33497}, "CVE-2025-0636": {"epss_score": 0.00058, "epss_percentile": 0.18289}, "CVE-2025-0637": {"epss_score": 0.00173, "epss_percentile": 0.39043}, "CVE-2025-0638": {"epss_score": 0.00253, "epss_percentile": 0.4849}, "CVE-2025-0639": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2025-0640": {"epss_score": 0.0006, "epss_percentile": 0.19224}, "CVE-2025-0642": {"epss_score": 0.00074, "epss_percentile": 0.22864}, "CVE-2025-0643": {"epss_score": 0.00063, "epss_percentile": 0.19819}, "CVE-2025-0645": {"epss_score": 0.00056, "epss_percentile": 0.17809}, "CVE-2025-0648": {"epss_score": 0.00064, "epss_percentile": 0.20287}, "CVE-2025-0649": {"epss_score": 0.00026, "epss_percentile": 0.06427}, "CVE-2025-0650": {"epss_score": 0.01297, "epss_percentile": 0.7927}, "CVE-2025-0651": {"epss_score": 0.00068, "epss_percentile": 0.21393}, "CVE-2025-0652": {"epss_score": 0.00044, "epss_percentile": 0.13411}, "CVE-2025-0656": {"epss_score": 0.00153, "epss_percentile": 0.36629}, "CVE-2025-0657": {"epss_score": 0.0006, "epss_percentile": 0.19205}, "CVE-2025-0658": {"epss_score": 0.00109, "epss_percentile": 0.29965}, "CVE-2025-0659": {"epss_score": 0.00139, "epss_percentile": 0.34565}, "CVE-2025-0660": {"epss_score": 0.0015, "epss_percentile": 0.36055}, "CVE-2025-0661": {"epss_score": 0.00098, "epss_percentile": 0.27641}, "CVE-2025-0662": {"epss_score": 0.00151, "epss_percentile": 0.36325}, "CVE-2025-0663": {"epss_score": 0.00043, "epss_percentile": 0.13282}, "CVE-2025-0664": {"epss_score": 0.0004, "epss_percentile": 0.12055}, "CVE-2025-0665": {"epss_score": 0.1193, "epss_percentile": 0.93519}, "CVE-2025-0666": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2025-0667": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2025-0668": {"epss_score": 0.00116, "epss_percentile": 0.31195}, "CVE-2025-0669": {"epss_score": 0.00029, "epss_percentile": 0.07759}, "CVE-2025-0670": {"epss_score": 0.0006, "epss_percentile": 0.19224}, "CVE-2025-0671": {"epss_score": 0.00037, "epss_percentile": 0.10777}, "CVE-2025-0672": {"epss_score": 0.00055, "epss_percentile": 0.17492}, "CVE-2025-0673": {"epss_score": 0.00018, "epss_percentile": 0.03806}, "CVE-2025-0674": {"epss_score": 0.45032, "epss_percentile": 0.97468}, "CVE-2025-0675": {"epss_score": 0.0014, "epss_percentile": 0.34753}, "CVE-2025-0676": {"epss_score": 0.00361, "epss_percentile": 0.57707}, "CVE-2025-0677": {"epss_score": 0.00074, "epss_percentile": 0.22838}, "CVE-2025-0678": {"epss_score": 0.00037, "epss_percentile": 0.10901}, "CVE-2025-0679": {"epss_score": 0.00015, "epss_percentile": 0.02271}, "CVE-2025-0680": {"epss_score": 0.00275, "epss_percentile": 0.50679}, "CVE-2025-0681": {"epss_score": 0.00036, "epss_percentile": 0.10299}, "CVE-2025-0682": {"epss_score": 0.00388, "epss_percentile": 0.59364}, "CVE-2025-0683": {"epss_score": 0.00141, "epss_percentile": 0.3481}, "CVE-2025-0684": {"epss_score": 0.00027, "epss_percentile": 0.0709}, "CVE-2025-0685": {"epss_score": 0.00026, "epss_percentile": 0.06598}, "CVE-2025-0686": {"epss_score": 0.00026, "epss_percentile": 0.06598}, "CVE-2025-0687": {"epss_score": 0.00025, "epss_percentile": 0.0635}, "CVE-2025-0688": {"epss_score": 0.00025, "epss_percentile": 0.0635}, "CVE-2025-0689": {"epss_score": 0.0003, "epss_percentile": 0.08219}, "CVE-2025-0690": {"epss_score": 0.00098, "epss_percentile": 0.27728}, "CVE-2025-0691": {"epss_score": 0.00037, "epss_percentile": 0.10936}, "CVE-2025-0692": {"epss_score": 0.00087, "epss_percentile": 0.25514}, "CVE-2025-0693": {"epss_score": 0.00126, "epss_percentile": 0.32647}, "CVE-2025-0694": {"epss_score": 0.00095, "epss_percentile": 0.27105}, "CVE-2025-0695": {"epss_score": 0.00152, "epss_percentile": 0.3637}, "CVE-2025-0696": {"epss_score": 0.00152, "epss_percentile": 0.36442}, "CVE-2025-0697": {"epss_score": 0.00095, "epss_percentile": 0.27124}, "CVE-2025-0698": {"epss_score": 0.00111, "epss_percentile": 0.30285}, "CVE-2025-0699": {"epss_score": 0.00111, "epss_percentile": 0.30285}, "CVE-2025-0700": {"epss_score": 0.00076, "epss_percentile": 0.23093}, "CVE-2025-0701": {"epss_score": 0.00076, "epss_percentile": 0.23093}, "CVE-2025-0702": {"epss_score": 0.00103, "epss_percentile": 0.29083}, "CVE-2025-0703": {"epss_score": 0.00172, "epss_percentile": 0.38973}, "CVE-2025-0704": {"epss_score": 0.00242, "epss_percentile": 0.47374}, "CVE-2025-0705": {"epss_score": 0.00061, "epss_percentile": 0.19441}, "CVE-2025-0706": {"epss_score": 0.00081, "epss_percentile": 0.24212}, "CVE-2025-0707": {"epss_score": 0.00031, "epss_percentile": 0.08706}, "CVE-2025-0708": {"epss_score": 0.00076, "epss_percentile": 0.23222}, "CVE-2025-0709": {"epss_score": 0.00096, "epss_percentile": 0.27421}, "CVE-2025-0710": {"epss_score": 0.00081, "epss_percentile": 0.24306}, "CVE-2025-0712": {"epss_score": 0.00011, "epss_percentile": 0.00953}, "CVE-2025-0714": {"epss_score": 0.00042, "epss_percentile": 0.12896}, "CVE-2025-0716": {"epss_score": 0.00014, "epss_percentile": 0.01812}, "CVE-2025-0717": {"epss_score": 0.00054, "epss_percentile": 0.17328}, "CVE-2025-0718": {"epss_score": 0.00064, "epss_percentile": 0.20197}, "CVE-2025-0719": {"epss_score": 0.00138, "epss_percentile": 0.34422}, "CVE-2025-0720": {"epss_score": 0.0003, "epss_percentile": 0.07978}, "CVE-2025-0721": {"epss_score": 0.00097, "epss_percentile": 0.27547}, "CVE-2025-0722": {"epss_score": 0.00199, "epss_percentile": 0.42107}, "CVE-2025-0723": {"epss_score": 0.00098, "epss_percentile": 0.27777}, "CVE-2025-0724": {"epss_score": 0.00515, "epss_percentile": 0.65983}, "CVE-2025-0725": {"epss_score": 0.00738, "epss_percentile": 0.72342}, "CVE-2025-0726": {"epss_score": 0.00132, "epss_percentile": 0.33569}, "CVE-2025-0727": {"epss_score": 0.00132, "epss_percentile": 0.33569}, "CVE-2025-0728": {"epss_score": 0.00132, "epss_percentile": 0.33569}, "CVE-2025-0729": {"epss_score": 0.00085, "epss_percentile": 0.2516}, "CVE-2025-0730": {"epss_score": 0.00208, "epss_percentile": 0.43249}, "CVE-2025-0731": {"epss_score": 0.00155, "epss_percentile": 0.36798}, "CVE-2025-0732": {"epss_score": 0.0002, "epss_percentile": 0.0447}, "CVE-2025-0733": {"epss_score": 0.0002, "epss_percentile": 0.0447}, "CVE-2025-0734": {"epss_score": 0.00227, "epss_percentile": 0.45381}, "CVE-2025-0736": {"epss_score": 0.00015, "epss_percentile": 0.02279}, "CVE-2025-0739": {"epss_score": 0.00105, "epss_percentile": 0.29253}, "CVE-2025-0740": {"epss_score": 0.00105, "epss_percentile": 0.29253}, "CVE-2025-0741": {"epss_score": 0.00088, "epss_percentile": 0.25699}, "CVE-2025-0742": {"epss_score": 0.001, "epss_percentile": 0.28451}, "CVE-2025-0743": {"epss_score": 0.00089, "epss_percentile": 0.25807}, "CVE-2025-0744": {"epss_score": 0.00094, "epss_percentile": 0.27009}, "CVE-2025-0745": {"epss_score": 0.0012, "epss_percentile": 0.31721}, "CVE-2025-0746": {"epss_score": 0.00061, "epss_percentile": 0.19439}, "CVE-2025-0747": {"epss_score": 0.00086, "epss_percentile": 0.25292}, "CVE-2025-0748": {"epss_score": 0.00012, "epss_percentile": 0.01351}, "CVE-2025-0749": {"epss_score": 0.00085, "epss_percentile": 0.25067}, "CVE-2025-0750": {"epss_score": 0.00061, "epss_percentile": 0.19506}, "CVE-2025-0751": {"epss_score": 0.00134, "epss_percentile": 0.33903}, "CVE-2025-0752": {"epss_score": 0.00196, "epss_percentile": 0.4175}, "CVE-2025-0753": {"epss_score": 0.00134, "epss_percentile": 0.33903}, "CVE-2025-0754": {"epss_score": 0.00125, "epss_percentile": 0.32482}, "CVE-2025-0755": {"epss_score": 0.0017, "epss_percentile": 0.38652}, "CVE-2025-0756": {"epss_score": 0.00621, "epss_percentile": 0.69483}, "CVE-2025-0757": {"epss_score": 0.00037, "epss_percentile": 0.10769}, "CVE-2025-0758": {"epss_score": 0.00017, "epss_percentile": 0.03311}, "CVE-2025-0759": {"epss_score": 0.00019, "epss_percentile": 0.04159}, "CVE-2025-0760": {"epss_score": 0.0006, "epss_percentile": 0.18962}, "CVE-2025-0762": {"epss_score": 0.00341, "epss_percentile": 0.56301}, "CVE-2025-0763": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-0764": {"epss_score": 0.00154, "epss_percentile": 0.36743}, "CVE-2025-0765": {"epss_score": 0.00015, "epss_percentile": 0.0248}, "CVE-2025-0767": {"epss_score": 0.00241, "epss_percentile": 0.47279}, "CVE-2025-0769": {"epss_score": 0.00192, "epss_percentile": 0.41319}, "CVE-2025-0781": {"epss_score": 0.00084, "epss_percentile": 0.25022}, "CVE-2025-0783": {"epss_score": 0.00112, "epss_percentile": 0.30459}, "CVE-2025-0784": {"epss_score": 0.00063, "epss_percentile": 0.19922}, "CVE-2025-0785": {"epss_score": 0.00079, "epss_percentile": 0.23942}, "CVE-2025-0786": {"epss_score": 0.00117, "epss_percentile": 0.31279}, "CVE-2025-0787": {"epss_score": 0.00079, "epss_percentile": 0.23942}, "CVE-2025-0788": {"epss_score": 0.00117, "epss_percentile": 0.31279}, "CVE-2025-0789": {"epss_score": 0.00148, "epss_percentile": 0.35884}, "CVE-2025-0790": {"epss_score": 0.00101, "epss_percentile": 0.28661}, "CVE-2025-0791": {"epss_score": 0.00148, "epss_percentile": 0.35884}, "CVE-2025-0792": {"epss_score": 0.00148, "epss_percentile": 0.35884}, "CVE-2025-0793": {"epss_score": 0.00046, "epss_percentile": 0.14359}, "CVE-2025-0794": {"epss_score": 0.00031, "epss_percentile": 0.08448}, "CVE-2025-0795": {"epss_score": 0.00028, "epss_percentile": 0.07233}, "CVE-2025-0796": {"epss_score": 0.0004, "epss_percentile": 0.11874}, "CVE-2025-0797": {"epss_score": 0.0001, "epss_percentile": 0.00822}, "CVE-2025-0798": {"epss_score": 0.02096, "epss_percentile": 0.83587}, "CVE-2025-0799": {"epss_score": 0.00076, "epss_percentile": 0.23243}, "CVE-2025-0800": {"epss_score": 0.00026, "epss_percentile": 0.06453}, "CVE-2025-0801": {"epss_score": 0.00041, "epss_percentile": 0.12362}, "CVE-2025-0802": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-0803": {"epss_score": 0.00044, "epss_percentile": 0.13516}, "CVE-2025-0804": {"epss_score": 0.0003, "epss_percentile": 0.08252}, "CVE-2025-0805": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2025-0806": {"epss_score": 0.00035, "epss_percentile": 0.09855}, "CVE-2025-0807": {"epss_score": 0.00054, "epss_percentile": 0.17245}, "CVE-2025-0808": {"epss_score": 0.00045, "epss_percentile": 0.13948}, "CVE-2025-0809": {"epss_score": 0.00696, "epss_percentile": 0.71391}, "CVE-2025-0810": {"epss_score": 0.00038, "epss_percentile": 0.11199}, "CVE-2025-0811": {"epss_score": 0.00133, "epss_percentile": 0.33636}, "CVE-2025-0813": {"epss_score": 0.00054, "epss_percentile": 0.17232}, "CVE-2025-0814": {"epss_score": 0.00152, "epss_percentile": 0.3637}, "CVE-2025-0815": {"epss_score": 0.00066, "epss_percentile": 0.20924}, "CVE-2025-0816": {"epss_score": 0.00066, "epss_percentile": 0.20924}, "CVE-2025-0817": {"epss_score": 0.00572, "epss_percentile": 0.68023}, "CVE-2025-0818": {"epss_score": 0.01289, "epss_percentile": 0.7921}, "CVE-2025-0819": {"epss_score": 0.00021, "epss_percentile": 0.04754}, "CVE-2025-0820": {"epss_score": 0.00119, "epss_percentile": 0.31548}, "CVE-2025-0821": {"epss_score": 0.00236, "epss_percentile": 0.46374}, "CVE-2025-0822": {"epss_score": 0.0025, "epss_percentile": 0.48212}, "CVE-2025-0823": {"epss_score": 0.0011, "epss_percentile": 0.30079}, "CVE-2025-0825": {"epss_score": 0.00159, "epss_percentile": 0.37357}, "CVE-2025-0826": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2025-0827": {"epss_score": 0.00068, "epss_percentile": 0.2139}, "CVE-2025-0828": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2025-0829": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2025-0830": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2025-0831": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2025-0832": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2025-0833": {"epss_score": 0.00071, "epss_percentile": 0.22108}, "CVE-2025-0834": {"epss_score": 0.00028, "epss_percentile": 0.07345}, "CVE-2025-0835": {"epss_score": 0.00026, "epss_percentile": 0.06447}, "CVE-2025-0836": {"epss_score": 0.00038, "epss_percentile": 0.11198}, "CVE-2025-0837": {"epss_score": 0.00066, "epss_percentile": 0.20735}, "CVE-2025-0838": {"epss_score": 0.00269, "epss_percentile": 0.50175}, "CVE-2025-0839": {"epss_score": 0.00037, "epss_percentile": 0.10879}, "CVE-2025-0840": {"epss_score": 0.00443, "epss_percentile": 0.62769}, "CVE-2025-0841": {"epss_score": 0.00162, "epss_percentile": 0.37627}, "CVE-2025-0842": {"epss_score": 0.00139, "epss_percentile": 0.34549}, "CVE-2025-0843": {"epss_score": 0.00133, "epss_percentile": 0.33627}, "CVE-2025-0844": {"epss_score": 0.00077, "epss_percentile": 0.23448}, "CVE-2025-0845": {"epss_score": 0.00058, "epss_percentile": 0.18456}, "CVE-2025-0846": {"epss_score": 0.00118, "epss_percentile": 0.31425}, "CVE-2025-0847": {"epss_score": 0.00038, "epss_percentile": 0.11407}, "CVE-2025-0848": {"epss_score": 0.00145, "epss_percentile": 0.35401}, "CVE-2025-0849": {"epss_score": 0.00032, "epss_percentile": 0.08854}, "CVE-2025-0851": {"epss_score": 0.04707, "epss_percentile": 0.89032}, "CVE-2025-0853": {"epss_score": 0.001, "epss_percentile": 0.28455}, "CVE-2025-0855": {"epss_score": 0.00901, "epss_percentile": 0.75179}, "CVE-2025-0856": {"epss_score": 0.00179, "epss_percentile": 0.39806}, "CVE-2025-0858": {"epss_score": 0.00081, "epss_percentile": 0.24396}, "CVE-2025-0859": {"epss_score": 0.00236, "epss_percentile": 0.46358}, "CVE-2025-0860": {"epss_score": 0.00456, "epss_percentile": 0.6334}, "CVE-2025-0861": {"epss_score": 0.00209, "epss_percentile": 0.43411}, "CVE-2025-0862": {"epss_score": 0.00107, "epss_percentile": 0.29692}, "CVE-2025-0863": {"epss_score": 0.00116, "epss_percentile": 0.31134}, "CVE-2025-0864": {"epss_score": 0.00756, "epss_percentile": 0.72745}, "CVE-2025-0865": {"epss_score": 0.00075, "epss_percentile": 0.22983}, "CVE-2025-0866": {"epss_score": 0.00121, "epss_percentile": 0.31919}, "CVE-2025-0867": {"epss_score": 0.00393, "epss_percentile": 0.59746}, "CVE-2025-0868": {"epss_score": 0.11125, "epss_percentile": 0.9323}, "CVE-2025-0869": {"epss_score": 0.00079, "epss_percentile": 0.23874}, "CVE-2025-0870": {"epss_score": 0.00207, "epss_percentile": 0.4315}, "CVE-2025-0871": {"epss_score": 0.00084, "epss_percentile": 0.2489}, "CVE-2025-0872": {"epss_score": 0.0011, "epss_percentile": 0.30205}, "CVE-2025-0873": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-0874": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-0875": {"epss_score": 0.00035, "epss_percentile": 0.09967}, "CVE-2025-0876": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2025-0877": {"epss_score": 0.0012, "epss_percentile": 0.31754}, "CVE-2025-0878": {"epss_score": 0.00073, "epss_percentile": 0.22641}, "CVE-2025-0879": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2025-0880": {"epss_score": 0.00086, "epss_percentile": 0.25303}, "CVE-2025-0881": {"epss_score": 0.00083, "epss_percentile": 0.24714}, "CVE-2025-0882": {"epss_score": 0.00077, "epss_percentile": 0.2353}, "CVE-2025-0883": {"epss_score": 0.00093, "epss_percentile": 0.2669}, "CVE-2025-0884": {"epss_score": 0.00032, "epss_percentile": 0.09033}, "CVE-2025-0885": {"epss_score": 0.0002, "epss_percentile": 0.04685}, "CVE-2025-0886": {"epss_score": 0.00017, "epss_percentile": 0.03415}, "CVE-2025-0889": {"epss_score": 0.00028, "epss_percentile": 0.07526}, "CVE-2025-0890": {"epss_score": 0.01235, "epss_percentile": 0.78765}, "CVE-2025-0893": {"epss_score": 0.00035, "epss_percentile": 0.10042}, "CVE-2025-0895": {"epss_score": 0.00036, "epss_percentile": 0.10337}, "CVE-2025-0896": {"epss_score": 0.00152, "epss_percentile": 0.36497}, "CVE-2025-0897": {"epss_score": 0.001, "epss_percentile": 0.2844}, "CVE-2025-0899": {"epss_score": 0.00164, "epss_percentile": 0.37941}, "CVE-2025-0900": {"epss_score": 0.00034, "epss_percentile": 0.09707}, "CVE-2025-0901": {"epss_score": 0.00164, "epss_percentile": 0.37941}, "CVE-2025-0902": {"epss_score": 0.00096, "epss_percentile": 0.27388}, "CVE-2025-0903": {"epss_score": 0.00147, "epss_percentile": 0.3565}, "CVE-2025-0904": {"epss_score": 0.00096, "epss_percentile": 0.27388}, "CVE-2025-0905": {"epss_score": 0.00096, "epss_percentile": 0.27388}, "CVE-2025-0906": {"epss_score": 0.00096, "epss_percentile": 0.27388}, "CVE-2025-0907": {"epss_score": 0.00096, "epss_percentile": 0.27388}, "CVE-2025-0908": {"epss_score": 0.00104, "epss_percentile": 0.29212}, "CVE-2025-0909": {"epss_score": 0.00096, "epss_percentile": 0.27388}, "CVE-2025-0910": {"epss_score": 0.00164, "epss_percentile": 0.37941}, "CVE-2025-0911": {"epss_score": 0.00096, "epss_percentile": 0.27388}, "CVE-2025-0912": {"epss_score": 0.0281, "epss_percentile": 0.85715}, "CVE-2025-0913": {"epss_score": 9e-05, "epss_percentile": 0.00717}, "CVE-2025-0914": {"epss_score": 0.00081, "epss_percentile": 0.24295}, "CVE-2025-0915": {"epss_score": 0.00044, "epss_percentile": 0.13437}, "CVE-2025-0916": {"epss_score": 0.00846, "epss_percentile": 0.7433}, "CVE-2025-0917": {"epss_score": 0.00019, "epss_percentile": 0.04283}, "CVE-2025-0918": {"epss_score": 0.00846, "epss_percentile": 0.7433}, "CVE-2025-0921": {"epss_score": 0.00014, "epss_percentile": 0.0177}, "CVE-2025-0923": {"epss_score": 0.00033, "epss_percentile": 0.09213}, "CVE-2025-0924": {"epss_score": 0.15422, "epss_percentile": 0.94428}, "CVE-2025-0926": {"epss_score": 0.00016, "epss_percentile": 0.02693}, "CVE-2025-0928": {"epss_score": 0.00381, "epss_percentile": 0.58984}, "CVE-2025-0929": {"epss_score": 0.01202, "epss_percentile": 0.78486}, "CVE-2025-0930": {"epss_score": 0.00056, "epss_percentile": 0.17894}, "CVE-2025-0932": {"epss_score": 0.00033, "epss_percentile": 0.09177}, "CVE-2025-0934": {"epss_score": 0.0007, "epss_percentile": 0.21761}, "CVE-2025-0935": {"epss_score": 0.00143, "epss_percentile": 0.35169}, "CVE-2025-0936": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-0937": {"epss_score": 0.00044, "epss_percentile": 0.13605}, "CVE-2025-0938": {"epss_score": 0.01244, "epss_percentile": 0.78833}, "CVE-2025-0939": {"epss_score": 0.00111, "epss_percentile": 0.30299}, "CVE-2025-0941": {"epss_score": 0.00046, "epss_percentile": 0.14179}, "CVE-2025-0942": {"epss_score": 0.00222, "epss_percentile": 0.4481}, "CVE-2025-0943": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-0944": {"epss_score": 0.00283, "epss_percentile": 0.51385}, "CVE-2025-0945": {"epss_score": 0.00177, "epss_percentile": 0.39578}, "CVE-2025-0946": {"epss_score": 0.00177, "epss_percentile": 0.39578}, "CVE-2025-0947": {"epss_score": 0.00177, "epss_percentile": 0.39578}, "CVE-2025-0948": {"epss_score": 0.00177, "epss_percentile": 0.39578}, "CVE-2025-0949": {"epss_score": 0.00177, "epss_percentile": 0.39578}, "CVE-2025-0950": {"epss_score": 0.00177, "epss_percentile": 0.39578}, "CVE-2025-0951": {"epss_score": 0.00057, "epss_percentile": 0.18171}, "CVE-2025-0952": {"epss_score": 0.00146, "epss_percentile": 0.35604}, "CVE-2025-0953": {"epss_score": 0.00846, "epss_percentile": 0.7433}, "CVE-2025-0954": {"epss_score": 0.00245, "epss_percentile": 0.4769}, "CVE-2025-0955": {"epss_score": 0.00297, "epss_percentile": 0.52773}, "CVE-2025-0956": {"epss_score": 0.00797, "epss_percentile": 0.735}, "CVE-2025-0957": {"epss_score": 0.01126, "epss_percentile": 0.77817}, "CVE-2025-0958": {"epss_score": 0.00053, "epss_percentile": 0.16846}, "CVE-2025-0959": {"epss_score": 0.00102, "epss_percentile": 0.28832}, "CVE-2025-0960": {"epss_score": 0.00891, "epss_percentile": 0.75051}, "CVE-2025-0961": {"epss_score": 0.00094, "epss_percentile": 0.2678}, "CVE-2025-0966": {"epss_score": 0.00072, "epss_percentile": 0.22473}, "CVE-2025-0967": {"epss_score": 0.00025, "epss_percentile": 0.06293}, "CVE-2025-0968": {"epss_score": 0.00261, "epss_percentile": 0.49284}, "CVE-2025-0969": {"epss_score": 0.00034, "epss_percentile": 0.09567}, "CVE-2025-0970": {"epss_score": 0.00074, "epss_percentile": 0.22781}, "CVE-2025-0971": {"epss_score": 0.0006, "epss_percentile": 0.19223}, "CVE-2025-0972": {"epss_score": 0.0002, "epss_percentile": 0.04448}, "CVE-2025-0973": {"epss_score": 0.00147, "epss_percentile": 0.35723}, "CVE-2025-0974": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-0975": {"epss_score": 0.00431, "epss_percentile": 0.62095}, "CVE-2025-0980": {"epss_score": 0.00015, "epss_percentile": 0.02137}, "CVE-2025-0981": {"epss_score": 0.0013, "epss_percentile": 0.33279}, "CVE-2025-0982": {"epss_score": 0.00076, "epss_percentile": 0.23225}, "CVE-2025-0984": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-0985": {"epss_score": 0.00064, "epss_percentile": 0.20303}, "CVE-2025-0986": {"epss_score": 0.00014, "epss_percentile": 0.01998}, "CVE-2025-0987": {"epss_score": 0.00049, "epss_percentile": 0.15457}, "CVE-2025-0990": {"epss_score": 0.0004, "epss_percentile": 0.11874}, "CVE-2025-0993": {"epss_score": 0.00092, "epss_percentile": 0.26423}, "CVE-2025-0994": {"epss_score": 0.77795, "epss_percentile": 0.98955}, "CVE-2025-0995": {"epss_score": 0.00225, "epss_percentile": 0.45075}, "CVE-2025-0996": {"epss_score": 0.00074, "epss_percentile": 0.22819}, "CVE-2025-0997": {"epss_score": 0.00095, "epss_percentile": 0.27187}, "CVE-2025-0999": {"epss_score": 0.00372, "epss_percentile": 0.5846}, "CVE-2025-10000": {"epss_score": 0.00117, "epss_percentile": 0.31283}, "CVE-2025-10001": {"epss_score": 0.00358, "epss_percentile": 0.57531}, "CVE-2025-10002": {"epss_score": 0.00036, "epss_percentile": 0.1024}, "CVE-2025-10003": {"epss_score": 0.00089, "epss_percentile": 0.2596}, "CVE-2025-10004": {"epss_score": 0.00058, "epss_percentile": 0.18523}, "CVE-2025-10006": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-10008": {"epss_score": 0.00089, "epss_percentile": 0.25971}, "CVE-2025-10009": {"epss_score": 0.00096, "epss_percentile": 0.27256}, "CVE-2025-10011": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-10012": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-10013": {"epss_score": 0.00061, "epss_percentile": 0.19529}, "CVE-2025-10014": {"epss_score": 0.00055, "epss_percentile": 0.17533}, "CVE-2025-10015": {"epss_score": 0.00014, "epss_percentile": 0.0212}, "CVE-2025-10016": {"epss_score": 0.0003, "epss_percentile": 0.08184}, "CVE-2025-10018": {"epss_score": 0.00031, "epss_percentile": 0.08681}, "CVE-2025-10019": {"epss_score": 0.00035, "epss_percentile": 0.0999}, "CVE-2025-10020": {"epss_score": 0.01062, "epss_percentile": 0.77179}, "CVE-2025-10021": {"epss_score": 0.00021, "epss_percentile": 0.04937}, "CVE-2025-10023": {"epss_score": 0.00034, "epss_percentile": 0.09576}, "CVE-2025-10025": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10026": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-10027": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-10028": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-10029": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-10030": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10031": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10032": {"epss_score": 0.00079, "epss_percentile": 0.23916}, "CVE-2025-10033": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10034": {"epss_score": 0.00089, "epss_percentile": 0.2587}, "CVE-2025-10035": {"epss_score": 0.57754, "epss_percentile": 0.98081}, "CVE-2025-10036": {"epss_score": 0.00034, "epss_percentile": 0.09522}, "CVE-2025-10037": {"epss_score": 0.00034, "epss_percentile": 0.09522}, "CVE-2025-10038": {"epss_score": 0.00096, "epss_percentile": 0.27294}, "CVE-2025-10039": {"epss_score": 0.00032, "epss_percentile": 0.08961}, "CVE-2025-10040": {"epss_score": 0.0004, "epss_percentile": 0.11962}, "CVE-2025-10041": {"epss_score": 0.00082, "epss_percentile": 0.24534}, "CVE-2025-10042": {"epss_score": 0.00189, "epss_percentile": 0.40935}, "CVE-2025-10044": {"epss_score": 0.00066, "epss_percentile": 0.20952}, "CVE-2025-10045": {"epss_score": 0.00036, "epss_percentile": 0.1024}, "CVE-2025-10046": {"epss_score": 0.00142, "epss_percentile": 0.3501}, "CVE-2025-10047": {"epss_score": 0.00036, "epss_percentile": 0.1024}, "CVE-2025-10048": {"epss_score": 0.00036, "epss_percentile": 0.1024}, "CVE-2025-10049": {"epss_score": 0.00358, "epss_percentile": 0.57531}, "CVE-2025-10050": {"epss_score": 0.00192, "epss_percentile": 0.41367}, "CVE-2025-10051": {"epss_score": 0.00358, "epss_percentile": 0.57531}, "CVE-2025-10053": {"epss_score": 0.00033, "epss_percentile": 0.0912}, "CVE-2025-10054": {"epss_score": 0.00034, "epss_percentile": 0.09553}, "CVE-2025-10055": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-10056": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2025-10057": {"epss_score": 0.00361, "epss_percentile": 0.57738}, "CVE-2025-10058": {"epss_score": 0.00333, "epss_percentile": 0.5565}, "CVE-2025-10059": {"epss_score": 0.00064, "epss_percentile": 0.20286}, "CVE-2025-10060": {"epss_score": 0.00225, "epss_percentile": 0.45106}, "CVE-2025-10061": {"epss_score": 0.00137, "epss_percentile": 0.343}, "CVE-2025-10062": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-10063": {"epss_score": 0.00064, "epss_percentile": 0.20321}, "CVE-2025-10064": {"epss_score": 0.00064, "epss_percentile": 0.20321}, "CVE-2025-10065": {"epss_score": 0.00064, "epss_percentile": 0.20321}, "CVE-2025-10066": {"epss_score": 0.00064, "epss_percentile": 0.20321}, "CVE-2025-10067": {"epss_score": 0.00064, "epss_percentile": 0.20321}, "CVE-2025-10068": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10070": {"epss_score": 0.00061, "epss_percentile": 0.19529}, "CVE-2025-10071": {"epss_score": 0.00061, "epss_percentile": 0.19529}, "CVE-2025-10072": {"epss_score": 0.00061, "epss_percentile": 0.19529}, "CVE-2025-10073": {"epss_score": 0.00043, "epss_percentile": 0.13132}, "CVE-2025-10074": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-10075": {"epss_score": 0.00045, "epss_percentile": 0.13891}, "CVE-2025-10076": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-10077": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-10078": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10079": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-10080": {"epss_score": 0.00046, "epss_percentile": 0.14082}, "CVE-2025-10081": {"epss_score": 0.00082, "epss_percentile": 0.24552}, "CVE-2025-10082": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10083": {"epss_score": 0.00082, "epss_percentile": 0.24554}, "CVE-2025-10084": {"epss_score": 0.00041, "epss_percentile": 0.12449}, "CVE-2025-10085": {"epss_score": 0.00073, "epss_percentile": 0.22601}, "CVE-2025-10086": {"epss_score": 0.0006, "epss_percentile": 0.19202}, "CVE-2025-10087": {"epss_score": 0.00046, "epss_percentile": 0.1416}, "CVE-2025-10088": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-10089": {"epss_score": 0.00015, "epss_percentile": 0.02231}, "CVE-2025-10090": {"epss_score": 0.00059, "epss_percentile": 0.18674}, "CVE-2025-10091": {"epss_score": 0.00081, "epss_percentile": 0.24377}, "CVE-2025-10092": {"epss_score": 0.00081, "epss_percentile": 0.24377}, "CVE-2025-10093": {"epss_score": 0.00088, "epss_percentile": 0.25781}, "CVE-2025-10094": {"epss_score": 0.00039, "epss_percentile": 0.11709}, "CVE-2025-10095": {"epss_score": 0.00027, "epss_percentile": 0.06985}, "CVE-2025-10096": {"epss_score": 0.00078, "epss_percentile": 0.23777}, "CVE-2025-10097": {"epss_score": 0.00069, "epss_percentile": 0.21443}, "CVE-2025-10098": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-10099": {"epss_score": 0.00059, "epss_percentile": 0.1868}, "CVE-2025-10100": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10101": {"epss_score": 0.0002, "epss_percentile": 0.04544}, "CVE-2025-10102": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10103": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10104": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10105": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-10106": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-10107": {"epss_score": 0.0033, "epss_percentile": 0.55455}, "CVE-2025-10108": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10109": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10110": {"epss_score": 0.00046, "epss_percentile": 0.14463}, "CVE-2025-10111": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-10112": {"epss_score": 0.00021, "epss_percentile": 0.04761}, "CVE-2025-10113": {"epss_score": 0.00052, "epss_percentile": 0.16648}, "CVE-2025-10114": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-10115": {"epss_score": 0.00042, "epss_percentile": 0.12665}, "CVE-2025-10116": {"epss_score": 0.00057, "epss_percentile": 0.18024}, "CVE-2025-10117": {"epss_score": 0.00037, "epss_percentile": 0.10728}, "CVE-2025-10118": {"epss_score": 0.00052, "epss_percentile": 0.16648}, "CVE-2025-10120": {"epss_score": 0.00112, "epss_percentile": 0.30454}, "CVE-2025-10121": {"epss_score": 0.00039, "epss_percentile": 0.117}, "CVE-2025-10122": {"epss_score": 0.00034, "epss_percentile": 0.09586}, "CVE-2025-10123": {"epss_score": 0.0057, "epss_percentile": 0.67953}, "CVE-2025-10124": {"epss_score": 0.00033, "epss_percentile": 0.0932}, "CVE-2025-10125": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10126": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10127": {"epss_score": 0.00125, "epss_percentile": 0.32612}, "CVE-2025-10128": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10129": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10130": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10131": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10132": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10133": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10134": {"epss_score": 0.00385, "epss_percentile": 0.59206}, "CVE-2025-10135": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10136": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10137": {"epss_score": 0.00081, "epss_percentile": 0.24387}, "CVE-2025-10138": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10139": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10140": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10141": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10142": {"epss_score": 0.00035, "epss_percentile": 0.10061}, "CVE-2025-10143": {"epss_score": 0.00127, "epss_percentile": 0.32781}, "CVE-2025-10144": {"epss_score": 0.00033, "epss_percentile": 0.09353}, "CVE-2025-10145": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-10146": {"epss_score": 0.00134, "epss_percentile": 0.33845}, "CVE-2025-10147": {"epss_score": 0.00192, "epss_percentile": 0.41339}, "CVE-2025-10148": {"epss_score": 0.0007, "epss_percentile": 0.21725}, "CVE-2025-10150": {"epss_score": 0.00049, "epss_percentile": 0.15424}, "CVE-2025-10151": {"epss_score": 0.00048, "epss_percentile": 0.1527}, "CVE-2025-10155": {"epss_score": 0.0017, "epss_percentile": 0.38704}, "CVE-2025-10156": {"epss_score": 0.00275, "epss_percentile": 0.50652}, "CVE-2025-10157": {"epss_score": 0.00197, "epss_percentile": 0.41949}, "CVE-2025-10158": {"epss_score": 0.00037, "epss_percentile": 0.10737}, "CVE-2025-10159": {"epss_score": 0.00134, "epss_percentile": 0.33848}, "CVE-2025-10161": {"epss_score": 0.00066, "epss_percentile": 0.20731}, "CVE-2025-10162": {"epss_score": 0.00146, "epss_percentile": 0.35557}, "CVE-2025-10163": {"epss_score": 0.00029, "epss_percentile": 0.07737}, "CVE-2025-10164": {"epss_score": 0.00051, "epss_percentile": 0.16256}, "CVE-2025-10165": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10166": {"epss_score": 0.00045, "epss_percentile": 0.13997}, "CVE-2025-10167": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10168": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10169": {"epss_score": 0.00085, "epss_percentile": 0.25046}, "CVE-2025-10170": {"epss_score": 0.00062, "epss_percentile": 0.19571}, "CVE-2025-10171": {"epss_score": 0.00062, "epss_percentile": 0.19571}, "CVE-2025-10172": {"epss_score": 0.00062, "epss_percentile": 0.19571}, "CVE-2025-10173": {"epss_score": 0.00043, "epss_percentile": 0.13308}, "CVE-2025-10175": {"epss_score": 0.00036, "epss_percentile": 0.10613}, "CVE-2025-10176": {"epss_score": 0.01115, "epss_percentile": 0.77714}, "CVE-2025-10178": {"epss_score": 0.00048, "epss_percentile": 0.15288}, "CVE-2025-10179": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10180": {"epss_score": 0.00045, "epss_percentile": 0.13997}, "CVE-2025-10181": {"epss_score": 0.00048, "epss_percentile": 0.15288}, "CVE-2025-10182": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10183": {"epss_score": 0.00083, "epss_percentile": 0.24703}, "CVE-2025-10184": {"epss_score": 0.00087, "epss_percentile": 0.25465}, "CVE-2025-10185": {"epss_score": 0.00034, "epss_percentile": 0.09522}, "CVE-2025-10186": {"epss_score": 0.00075, "epss_percentile": 0.22974}, "CVE-2025-10187": {"epss_score": 0.00034, "epss_percentile": 0.09522}, "CVE-2025-10188": {"epss_score": 0.00018, "epss_percentile": 0.03888}, "CVE-2025-10189": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10190": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10191": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10192": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10193": {"epss_score": 0.00027, "epss_percentile": 0.06834}, "CVE-2025-10194": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10195": {"epss_score": 0.00018, "epss_percentile": 0.03572}, "CVE-2025-10196": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-10197": {"epss_score": 0.00039, "epss_percentile": 0.117}, "CVE-2025-10198": {"epss_score": 0.00017, "epss_percentile": 0.03089}, "CVE-2025-10199": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-10200": {"epss_score": 0.00076, "epss_percentile": 0.23099}, "CVE-2025-10201": {"epss_score": 0.0002, "epss_percentile": 0.04501}, "CVE-2025-10203": {"epss_score": 0.00026, "epss_percentile": 0.06578}, "CVE-2025-10204": {"epss_score": 0.02939, "epss_percentile": 0.86031}, "CVE-2025-10205": {"epss_score": 0.0001, "epss_percentile": 0.00779}, "CVE-2025-10207": {"epss_score": 0.00087, "epss_percentile": 0.25505}, "CVE-2025-10209": {"epss_score": 0.00054, "epss_percentile": 0.17227}, "CVE-2025-10210": {"epss_score": 0.0128, "epss_percentile": 0.79136}, "CVE-2025-10211": {"epss_score": 0.06062, "epss_percentile": 0.90444}, "CVE-2025-10212": {"epss_score": 0.00058, "epss_percentile": 0.18452}, "CVE-2025-10213": {"epss_score": 0.00021, "epss_percentile": 0.04877}, "CVE-2025-10214": {"epss_score": 0.00021, "epss_percentile": 0.04877}, "CVE-2025-10215": {"epss_score": 0.00021, "epss_percentile": 0.04877}, "CVE-2025-10216": {"epss_score": 0.00027, "epss_percentile": 0.06921}, "CVE-2025-10217": {"epss_score": 0.00063, "epss_percentile": 0.19809}, "CVE-2025-10218": {"epss_score": 0.00039, "epss_percentile": 0.1147}, "CVE-2025-10220": {"epss_score": 0.00271, "epss_percentile": 0.50316}, "CVE-2025-10221": {"epss_score": 0.00017, "epss_percentile": 0.03227}, "CVE-2025-10222": {"epss_score": 0.00018, "epss_percentile": 0.03521}, "CVE-2025-10223": {"epss_score": 0.0005, "epss_percentile": 0.15954}, "CVE-2025-10224": {"epss_score": 0.00221, "epss_percentile": 0.44654}, "CVE-2025-10225": {"epss_score": 0.00158, "epss_percentile": 0.37226}, "CVE-2025-10226": {"epss_score": 0.00385, "epss_percentile": 0.59217}, "CVE-2025-10227": {"epss_score": 6e-05, "epss_percentile": 0.00268}, "CVE-2025-10228": {"epss_score": 0.00052, "epss_percentile": 0.16374}, "CVE-2025-10229": {"epss_score": 0.00038, "epss_percentile": 0.11337}, "CVE-2025-10230": {"epss_score": 0.00357, "epss_percentile": 0.57448}, "CVE-2025-10231": {"epss_score": 0.00015, "epss_percentile": 0.02251}, "CVE-2025-10232": {"epss_score": 0.00107, "epss_percentile": 0.29607}, "CVE-2025-10233": {"epss_score": 0.00106, "epss_percentile": 0.29526}, "CVE-2025-10234": {"epss_score": 0.00043, "epss_percentile": 0.13177}, "CVE-2025-10235": {"epss_score": 0.00043, "epss_percentile": 0.13177}, "CVE-2025-10236": {"epss_score": 0.00116, "epss_percentile": 0.31075}, "CVE-2025-10239": {"epss_score": 0.00065, "epss_percentile": 0.20621}, "CVE-2025-10240": {"epss_score": 0.00056, "epss_percentile": 0.17882}, "CVE-2025-10242": {"epss_score": 0.02289, "epss_percentile": 0.84275}, "CVE-2025-10243": {"epss_score": 0.02289, "epss_percentile": 0.84275}, "CVE-2025-10244": {"epss_score": 0.00059, "epss_percentile": 0.18623}, "CVE-2025-10245": {"epss_score": 0.0006, "epss_percentile": 0.18956}, "CVE-2025-10246": {"epss_score": 0.00037, "epss_percentile": 0.10725}, "CVE-2025-10247": {"epss_score": 0.0005, "epss_percentile": 0.15941}, "CVE-2025-10249": {"epss_score": 0.00072, "epss_percentile": 0.22319}, "CVE-2025-10250": {"epss_score": 0.0002, "epss_percentile": 0.04679}, "CVE-2025-10251": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2025-10252": {"epss_score": 0.00026, "epss_percentile": 0.06537}, "CVE-2025-10253": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-10254": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-10255": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-10259": {"epss_score": 0.00023, "epss_percentile": 0.05488}, "CVE-2025-10264": {"epss_score": 0.00064, "epss_percentile": 0.20262}, "CVE-2025-10265": {"epss_score": 0.00419, "epss_percentile": 0.61364}, "CVE-2025-10266": {"epss_score": 0.00121, "epss_percentile": 0.31948}, "CVE-2025-10267": {"epss_score": 0.00089, "epss_percentile": 0.25834}, "CVE-2025-10269": {"epss_score": 0.00118, "epss_percentile": 0.31487}, "CVE-2025-10271": {"epss_score": 0.00047, "epss_percentile": 0.1469}, "CVE-2025-10272": {"epss_score": 0.00047, "epss_percentile": 0.1469}, "CVE-2025-10273": {"epss_score": 0.00089, "epss_percentile": 0.25814}, "CVE-2025-10274": {"epss_score": 0.00047, "epss_percentile": 0.1469}, "CVE-2025-10275": {"epss_score": 0.0005, "epss_percentile": 0.15697}, "CVE-2025-10276": {"epss_score": 0.0005, "epss_percentile": 0.15697}, "CVE-2025-10277": {"epss_score": 0.0005, "epss_percentile": 0.15697}, "CVE-2025-10278": {"epss_score": 0.0005, "epss_percentile": 0.15697}, "CVE-2025-10280": {"epss_score": 0.00038, "epss_percentile": 0.11408}, "CVE-2025-10281": {"epss_score": 0.00037, "epss_percentile": 0.10987}, "CVE-2025-10282": {"epss_score": 0.00037, "epss_percentile": 0.10987}, "CVE-2025-10283": {"epss_score": 0.0008, "epss_percentile": 0.24149}, "CVE-2025-10284": {"epss_score": 0.00256, "epss_percentile": 0.48829}, "CVE-2025-10285": {"epss_score": 0.00031, "epss_percentile": 0.08334}, "CVE-2025-10287": {"epss_score": 0.00037, "epss_percentile": 0.10941}, "CVE-2025-10288": {"epss_score": 0.00063, "epss_percentile": 0.19917}, "CVE-2025-10289": {"epss_score": 0.00084, "epss_percentile": 0.25018}, "CVE-2025-10290": {"epss_score": 0.00033, "epss_percentile": 0.09308}, "CVE-2025-10291": {"epss_score": 0.0005, "epss_percentile": 0.15697}, "CVE-2025-10293": {"epss_score": 0.00113, "epss_percentile": 0.30671}, "CVE-2025-10294": {"epss_score": 0.00447, "epss_percentile": 0.62947}, "CVE-2025-10295": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-10299": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-10300": {"epss_score": 0.00017, "epss_percentile": 0.03118}, "CVE-2025-10301": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-10302": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-10303": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-10304": {"epss_score": 0.00115, "epss_percentile": 0.30927}, "CVE-2025-10305": {"epss_score": 0.0005, "epss_percentile": 0.15737}, "CVE-2025-10306": {"epss_score": 0.00038, "epss_percentile": 0.11109}, "CVE-2025-10307": {"epss_score": 0.01977, "epss_percentile": 0.83124}, "CVE-2025-10309": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-10310": {"epss_score": 0.00069, "epss_percentile": 0.21444}, "CVE-2025-10311": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-10312": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-10313": {"epss_score": 0.00096, "epss_percentile": 0.27373}, "CVE-2025-10316": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-10317": {"epss_score": 0.00028, "epss_percentile": 0.07534}, "CVE-2025-10318": {"epss_score": 0.00057, "epss_percentile": 0.17988}, "CVE-2025-10319": {"epss_score": 0.0004, "epss_percentile": 0.12011}, "CVE-2025-10320": {"epss_score": 0.00037, "epss_percentile": 0.10993}, "CVE-2025-10321": {"epss_score": 0.0005, "epss_percentile": 0.15849}, "CVE-2025-10322": {"epss_score": 0.00155, "epss_percentile": 0.36767}, "CVE-2025-10323": {"epss_score": 0.0033, "epss_percentile": 0.55428}, "CVE-2025-10324": {"epss_score": 0.0033, "epss_percentile": 0.55428}, "CVE-2025-10325": {"epss_score": 0.00377, "epss_percentile": 0.58706}, "CVE-2025-10326": {"epss_score": 0.00559, "epss_percentile": 0.67613}, "CVE-2025-10327": {"epss_score": 0.00412, "epss_percentile": 0.60922}, "CVE-2025-10328": {"epss_score": 0.00412, "epss_percentile": 0.60922}, "CVE-2025-10329": {"epss_score": 0.00069, "epss_percentile": 0.21517}, "CVE-2025-10330": {"epss_score": 0.00049, "epss_percentile": 0.1529}, "CVE-2025-10331": {"epss_score": 0.00035, "epss_percentile": 0.10156}, "CVE-2025-10332": {"epss_score": 0.00031, "epss_percentile": 0.08546}, "CVE-2025-10340": {"epss_score": 0.00042, "epss_percentile": 0.12645}, "CVE-2025-10341": {"epss_score": 0.00039, "epss_percentile": 0.11608}, "CVE-2025-10342": {"epss_score": 0.00039, "epss_percentile": 0.11608}, "CVE-2025-10343": {"epss_score": 0.00039, "epss_percentile": 0.11608}, "CVE-2025-10344": {"epss_score": 0.00039, "epss_percentile": 0.11608}, "CVE-2025-10345": {"epss_score": 0.00039, "epss_percentile": 0.11608}, "CVE-2025-10346": {"epss_score": 0.00039, "epss_percentile": 0.11608}, "CVE-2025-10348": {"epss_score": 0.0021, "epss_percentile": 0.43428}, "CVE-2025-10351": {"epss_score": 0.00045, "epss_percentile": 0.13956}, "CVE-2025-10352": {"epss_score": 0.00133, "epss_percentile": 0.33664}, "CVE-2025-10353": {"epss_score": 0.00154, "epss_percentile": 0.36666}, "CVE-2025-10355": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-10357": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-10358": {"epss_score": 0.00448, "epss_percentile": 0.62999}, "CVE-2025-10359": {"epss_score": 0.00448, "epss_percentile": 0.62999}, "CVE-2025-10360": {"epss_score": 0.0003, "epss_percentile": 0.08273}, "CVE-2025-10363": {"epss_score": 0.00559, "epss_percentile": 0.6761}, "CVE-2025-10364": {"epss_score": 0.00322, "epss_percentile": 0.54786}, "CVE-2025-10365": {"epss_score": 0.00225, "epss_percentile": 0.45161}, "CVE-2025-10366": {"epss_score": 0.00038, "epss_percentile": 0.11264}, "CVE-2025-10367": {"epss_score": 0.00037, "epss_percentile": 0.10728}, "CVE-2025-10368": {"epss_score": 0.00037, "epss_percentile": 0.10728}, "CVE-2025-10369": {"epss_score": 0.00043, "epss_percentile": 0.13178}, "CVE-2025-10370": {"epss_score": 0.00038, "epss_percentile": 0.11264}, "CVE-2025-10371": {"epss_score": 0.00061, "epss_percentile": 0.19299}, "CVE-2025-10372": {"epss_score": 0.00036, "epss_percentile": 0.10397}, "CVE-2025-10373": {"epss_score": 0.00036, "epss_percentile": 0.10397}, "CVE-2025-10374": {"epss_score": 0.00057, "epss_percentile": 0.18024}, "CVE-2025-10375": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-10376": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-10377": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-10380": {"epss_score": 0.00067, "epss_percentile": 0.2106}, "CVE-2025-10383": {"epss_score": 0.00054, "epss_percentile": 0.17188}, "CVE-2025-10384": {"epss_score": 0.00031, "epss_percentile": 0.08459}, "CVE-2025-10385": {"epss_score": 0.00085, "epss_percentile": 0.25046}, "CVE-2025-10386": {"epss_score": 0.00042, "epss_percentile": 0.12577}, "CVE-2025-10387": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10388": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-10389": {"epss_score": 0.00101, "epss_percentile": 0.28587}, "CVE-2025-10390": {"epss_score": 0.00101, "epss_percentile": 0.28587}, "CVE-2025-10391": {"epss_score": 0.0005, "epss_percentile": 0.15697}, "CVE-2025-10392": {"epss_score": 0.00062, "epss_percentile": 0.19672}, "CVE-2025-10393": {"epss_score": 0.0005, "epss_percentile": 0.15941}, "CVE-2025-10394": {"epss_score": 0.00055, "epss_percentile": 0.17565}, "CVE-2025-10395": {"epss_score": 0.00044, "epss_percentile": 0.13379}, "CVE-2025-10396": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10397": {"epss_score": 0.00044, "epss_percentile": 0.13379}, "CVE-2025-10398": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-10399": {"epss_score": 0.00037, "epss_percentile": 0.1077}, "CVE-2025-10400": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10401": {"epss_score": 0.00099, "epss_percentile": 0.28423}, "CVE-2025-10402": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10403": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10404": {"epss_score": 0.00035, "epss_percentile": 0.10001}, "CVE-2025-10405": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10406": {"epss_score": 0.00061, "epss_percentile": 0.1946}, "CVE-2025-10407": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10408": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10409": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10410": {"epss_score": 0.00051, "epss_percentile": 0.16067}, "CVE-2025-10411": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-10412": {"epss_score": 0.00224, "epss_percentile": 0.45039}, "CVE-2025-10413": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10414": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10415": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10416": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10417": {"epss_score": 0.00052, "epss_percentile": 0.16648}, "CVE-2025-10418": {"epss_score": 0.00051, "epss_percentile": 0.1612}, "CVE-2025-10419": {"epss_score": 0.00051, "epss_percentile": 0.1612}, "CVE-2025-10420": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10421": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10422": {"epss_score": 0.00047, "epss_percentile": 0.14574}, "CVE-2025-10423": {"epss_score": 0.00051, "epss_percentile": 0.16106}, "CVE-2025-10424": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-10425": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-10426": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10427": {"epss_score": 0.00057, "epss_percentile": 0.17988}, "CVE-2025-10428": {"epss_score": 0.00057, "epss_percentile": 0.17988}, "CVE-2025-10429": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10430": {"epss_score": 0.00054, "epss_percentile": 0.17222}, "CVE-2025-10431": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10432": {"epss_score": 0.00239, "epss_percentile": 0.46856}, "CVE-2025-10433": {"epss_score": 0.00064, "epss_percentile": 0.20385}, "CVE-2025-10434": {"epss_score": 0.00038, "epss_percentile": 0.11301}, "CVE-2025-10435": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10436": {"epss_score": 0.00035, "epss_percentile": 0.10001}, "CVE-2025-10437": {"epss_score": 0.00044, "epss_percentile": 0.13452}, "CVE-2025-10438": {"epss_score": 0.00065, "epss_percentile": 0.20498}, "CVE-2025-10439": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-10440": {"epss_score": 0.01055, "epss_percentile": 0.77115}, "CVE-2025-10441": {"epss_score": 0.01055, "epss_percentile": 0.77115}, "CVE-2025-10442": {"epss_score": 0.00524, "epss_percentile": 0.66334}, "CVE-2025-10443": {"epss_score": 0.00112, "epss_percentile": 0.30454}, "CVE-2025-10444": {"epss_score": 0.00052, "epss_percentile": 0.16648}, "CVE-2025-10445": {"epss_score": 0.00052, "epss_percentile": 0.16648}, "CVE-2025-10446": {"epss_score": 0.00052, "epss_percentile": 0.16648}, "CVE-2025-10447": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-10448": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10449": {"epss_score": 0.00065, "epss_percentile": 0.20498}, "CVE-2025-10450": {"epss_score": 0.00047, "epss_percentile": 0.14624}, "CVE-2025-10451": {"epss_score": 0.00018, "epss_percentile": 0.03825}, "CVE-2025-10452": {"epss_score": 0.00229, "epss_percentile": 0.45657}, "CVE-2025-10453": {"epss_score": 0.00045, "epss_percentile": 0.13706}, "CVE-2025-10456": {"epss_score": 0.0003, "epss_percentile": 0.08015}, "CVE-2025-10457": {"epss_score": 0.00043, "epss_percentile": 0.13073}, "CVE-2025-10458": {"epss_score": 0.00037, "epss_percentile": 0.10771}, "CVE-2025-10459": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10460": {"epss_score": 0.00074, "epss_percentile": 0.22723}, "CVE-2025-10467": {"epss_score": 0.00054, "epss_percentile": 0.17301}, "CVE-2025-10468": {"epss_score": 0.00065, "epss_percentile": 0.20513}, "CVE-2025-10471": {"epss_score": 0.0005, "epss_percentile": 0.15697}, "CVE-2025-10472": {"epss_score": 0.00205, "epss_percentile": 0.42748}, "CVE-2025-10473": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10475": {"epss_score": 0.00016, "epss_percentile": 0.02964}, "CVE-2025-10476": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-10477": {"epss_score": 0.00039, "epss_percentile": 0.1147}, "CVE-2025-10479": {"epss_score": 0.00035, "epss_percentile": 0.10001}, "CVE-2025-10480": {"epss_score": 0.00049, "epss_percentile": 0.15354}, "CVE-2025-10481": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10482": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10483": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10485": {"epss_score": 0.00042, "epss_percentile": 0.12577}, "CVE-2025-10486": {"epss_score": 0.00053, "epss_percentile": 0.16968}, "CVE-2025-10487": {"epss_score": 0.00346, "epss_percentile": 0.56636}, "CVE-2025-10488": {"epss_score": 0.00285, "epss_percentile": 0.51651}, "CVE-2025-10489": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-10490": {"epss_score": 0.00033, "epss_percentile": 0.0912}, "CVE-2025-10491": {"epss_score": 0.00018, "epss_percentile": 0.03676}, "CVE-2025-10492": {"epss_score": 0.00331, "epss_percentile": 0.55527}, "CVE-2025-10493": {"epss_score": 0.02427, "epss_percentile": 0.84719}, "CVE-2025-10494": {"epss_score": 0.00457, "epss_percentile": 0.63362}, "CVE-2025-10495": {"epss_score": 0.00022, "epss_percentile": 0.05168}, "CVE-2025-10496": {"epss_score": 0.00186, "epss_percentile": 0.40625}, "CVE-2025-10497": {"epss_score": 0.00051, "epss_percentile": 0.16126}, "CVE-2025-10498": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-10499": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-10500": {"epss_score": 0.00138, "epss_percentile": 0.34346}, "CVE-2025-10501": {"epss_score": 0.00127, "epss_percentile": 0.32807}, "CVE-2025-10502": {"epss_score": 0.00093, "epss_percentile": 0.26608}, "CVE-2025-10504": {"epss_score": 0.00019, "epss_percentile": 0.0437}, "CVE-2025-10527": {"epss_score": 0.00057, "epss_percentile": 0.18078}, "CVE-2025-10528": {"epss_score": 0.00097, "epss_percentile": 0.27499}, "CVE-2025-10529": {"epss_score": 0.00053, "epss_percentile": 0.16755}, "CVE-2025-10530": {"epss_score": 0.00042, "epss_percentile": 0.12603}, "CVE-2025-10531": {"epss_score": 0.00038, "epss_percentile": 0.1122}, "CVE-2025-10532": {"epss_score": 0.00054, "epss_percentile": 0.17326}, "CVE-2025-10533": {"epss_score": 0.00073, "epss_percentile": 0.22657}, "CVE-2025-10534": {"epss_score": 0.00045, "epss_percentile": 0.1372}, "CVE-2025-10535": {"epss_score": 0.00045, "epss_percentile": 0.14068}, "CVE-2025-10536": {"epss_score": 0.00016, "epss_percentile": 0.03034}, "CVE-2025-10537": {"epss_score": 0.00054, "epss_percentile": 0.172}, "CVE-2025-10538": {"epss_score": 0.001, "epss_percentile": 0.28561}, "CVE-2025-10540": {"epss_score": 0.00012, "epss_percentile": 0.01408}, "CVE-2025-10541": {"epss_score": 0.00016, "epss_percentile": 0.0287}, "CVE-2025-10542": {"epss_score": 0.00152, "epss_percentile": 0.36452}, "CVE-2025-10543": {"epss_score": 0.0006, "epss_percentile": 0.19205}, "CVE-2025-10544": {"epss_score": 0.00058, "epss_percentile": 0.18373}, "CVE-2025-10545": {"epss_score": 0.00011, "epss_percentile": 0.00998}, "CVE-2025-10546": {"epss_score": 0.00227, "epss_percentile": 0.45454}, "CVE-2025-10547": {"epss_score": 0.00064, "epss_percentile": 0.20262}, "CVE-2025-10548": {"epss_score": 0.00195, "epss_percentile": 0.4165}, "CVE-2025-10552": {"epss_score": 0.00043, "epss_percentile": 0.13335}, "CVE-2025-10554": {"epss_score": 0.00038, "epss_percentile": 0.11195}, "CVE-2025-10555": {"epss_score": 0.00038, "epss_percentile": 0.11195}, "CVE-2025-10556": {"epss_score": 0.00043, "epss_percentile": 0.13335}, "CVE-2025-10557": {"epss_score": 0.00043, "epss_percentile": 0.13335}, "CVE-2025-10558": {"epss_score": 0.00043, "epss_percentile": 0.13335}, "CVE-2025-10562": {"epss_score": 0.00035, "epss_percentile": 0.10001}, "CVE-2025-10563": {"epss_score": 0.00016, "epss_percentile": 0.02891}, "CVE-2025-10564": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10565": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10566": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-10567": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-10568": {"epss_score": 0.00034, "epss_percentile": 0.09792}, "CVE-2025-10570": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-10571": {"epss_score": 0.00029, "epss_percentile": 0.07836}, "CVE-2025-10573": {"epss_score": 0.00039, "epss_percentile": 0.11609}, "CVE-2025-10575": {"epss_score": 0.00039, "epss_percentile": 0.11446}, "CVE-2025-10576": {"epss_score": 0.00019, "epss_percentile": 0.04415}, "CVE-2025-10577": {"epss_score": 0.00019, "epss_percentile": 0.04415}, "CVE-2025-10578": {"epss_score": 0.00019, "epss_percentile": 0.04415}, "CVE-2025-10579": {"epss_score": 0.0004, "epss_percentile": 0.11962}, "CVE-2025-10580": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10581": {"epss_score": 0.0002, "epss_percentile": 0.04607}, "CVE-2025-10582": {"epss_score": 0.00043, "epss_percentile": 0.13095}, "CVE-2025-10583": {"epss_score": 0.00028, "epss_percentile": 0.07326}, "CVE-2025-10584": {"epss_score": 0.00036, "epss_percentile": 0.10397}, "CVE-2025-10585": {"epss_score": 0.00697, "epss_percentile": 0.71402}, "CVE-2025-10586": {"epss_score": 0.00047, "epss_percentile": 0.14648}, "CVE-2025-10587": {"epss_score": 0.00047, "epss_percentile": 0.14648}, "CVE-2025-10588": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-10589": {"epss_score": 0.00419, "epss_percentile": 0.61364}, "CVE-2025-10590": {"epss_score": 0.00036, "epss_percentile": 0.10355}, "CVE-2025-10591": {"epss_score": 0.00035, "epss_percentile": 0.10156}, "CVE-2025-10592": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10593": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10594": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10595": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10596": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10597": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10598": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10599": {"epss_score": 0.00045, "epss_percentile": 0.14053}, "CVE-2025-10600": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-10601": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10602": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10603": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-10604": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-10605": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-10606": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-10607": {"epss_score": 0.00039, "epss_percentile": 0.11542}, "CVE-2025-10608": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-10609": {"epss_score": 0.00023, "epss_percentile": 0.05506}, "CVE-2025-10610": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-10611": {"epss_score": 0.00242, "epss_percentile": 0.47398}, "CVE-2025-10612": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-10613": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10614": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-10615": {"epss_score": 0.00057, "epss_percentile": 0.17988}, "CVE-2025-10616": {"epss_score": 0.00057, "epss_percentile": 0.17988}, "CVE-2025-10617": {"epss_score": 0.00054, "epss_percentile": 0.17222}, "CVE-2025-10618": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10619": {"epss_score": 0.0132, "epss_percentile": 0.79439}, "CVE-2025-10620": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10621": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10622": {"epss_score": 0.00127, "epss_percentile": 0.32892}, "CVE-2025-10623": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10624": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10625": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10626": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10627": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10628": {"epss_score": 0.00202, "epss_percentile": 0.42466}, "CVE-2025-10629": {"epss_score": 0.00099, "epss_percentile": 0.28423}, "CVE-2025-10630": {"epss_score": 0.00086, "epss_percentile": 0.25247}, "CVE-2025-10631": {"epss_score": 0.00037, "epss_percentile": 0.10728}, "CVE-2025-10632": {"epss_score": 0.00037, "epss_percentile": 0.10728}, "CVE-2025-10634": {"epss_score": 0.00087, "epss_percentile": 0.25531}, "CVE-2025-10635": {"epss_score": 0.00039, "epss_percentile": 0.11446}, "CVE-2025-10636": {"epss_score": 0.00036, "epss_percentile": 0.10445}, "CVE-2025-10637": {"epss_score": 0.00058, "epss_percentile": 0.18452}, "CVE-2025-10638": {"epss_score": 0.00059, "epss_percentile": 0.18616}, "CVE-2025-10639": {"epss_score": 0.00321, "epss_percentile": 0.54652}, "CVE-2025-10640": {"epss_score": 0.00447, "epss_percentile": 0.62947}, "CVE-2025-10641": {"epss_score": 0.00019, "epss_percentile": 0.04334}, "CVE-2025-10642": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-10643": {"epss_score": 0.00436, "epss_percentile": 0.62457}, "CVE-2025-10644": {"epss_score": 0.02586, "epss_percentile": 0.85168}, "CVE-2025-10645": {"epss_score": 0.00057, "epss_percentile": 0.18133}, "CVE-2025-10646": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-10647": {"epss_score": 0.00303, "epss_percentile": 0.53227}, "CVE-2025-10648": {"epss_score": 0.00055, "epss_percentile": 0.17411}, "CVE-2025-10649": {"epss_score": 0.00039, "epss_percentile": 0.11446}, "CVE-2025-10650": {"epss_score": 0.00058, "epss_percentile": 0.18279}, "CVE-2025-10651": {"epss_score": 0.00032, "epss_percentile": 0.09031}, "CVE-2025-10652": {"epss_score": 0.00036, "epss_percentile": 0.10613}, "CVE-2025-10653": {"epss_score": 0.0006, "epss_percentile": 0.19211}, "CVE-2025-10655": {"epss_score": 0.00032, "epss_percentile": 0.0878}, "CVE-2025-10657": {"epss_score": 0.00018, "epss_percentile": 0.03806}, "CVE-2025-10658": {"epss_score": 0.00334, "epss_percentile": 0.55715}, "CVE-2025-10659": {"epss_score": 0.01392, "epss_percentile": 0.79959}, "CVE-2025-10660": {"epss_score": 0.00036, "epss_percentile": 0.10613}, "CVE-2025-10662": {"epss_score": 0.00035, "epss_percentile": 0.10149}, "CVE-2025-10663": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-10664": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10665": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10666": {"epss_score": 0.00091, "epss_percentile": 0.26404}, "CVE-2025-10667": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10668": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10669": {"epss_score": 0.0005, "epss_percentile": 0.15941}, "CVE-2025-10670": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10671": {"epss_score": 0.00043, "epss_percentile": 0.13288}, "CVE-2025-10672": {"epss_score": 0.00029, "epss_percentile": 0.07758}, "CVE-2025-10673": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10674": {"epss_score": 0.00035, "epss_percentile": 0.09852}, "CVE-2025-10675": {"epss_score": 0.00035, "epss_percentile": 0.09852}, "CVE-2025-10676": {"epss_score": 0.00035, "epss_percentile": 0.09852}, "CVE-2025-10678": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-10680": {"epss_score": 0.00258, "epss_percentile": 0.48963}, "CVE-2025-10682": {"epss_score": 0.00036, "epss_percentile": 0.10613}, "CVE-2025-10683": {"epss_score": 0.00034, "epss_percentile": 0.09677}, "CVE-2025-10684": {"epss_score": 0.00016, "epss_percentile": 0.02848}, "CVE-2025-10686": {"epss_score": 0.00095, "epss_percentile": 0.27131}, "CVE-2025-10687": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10688": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10689": {"epss_score": 0.00109, "epss_percentile": 0.29928}, "CVE-2025-10690": {"epss_score": 0.00235, "epss_percentile": 0.46233}, "CVE-2025-10691": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-10692": {"epss_score": 0.0007, "epss_percentile": 0.21704}, "CVE-2025-10693": {"epss_score": 0.0011, "epss_percentile": 0.30223}, "CVE-2025-10694": {"epss_score": 0.0007, "epss_percentile": 0.21694}, "CVE-2025-10695": {"epss_score": 0.00054, "epss_percentile": 0.17211}, "CVE-2025-10696": {"epss_score": 0.0004, "epss_percentile": 0.11882}, "CVE-2025-10699": {"epss_score": 0.00043, "epss_percentile": 0.13173}, "CVE-2025-10700": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-10701": {"epss_score": 0.00045, "epss_percentile": 0.13997}, "CVE-2025-10702": {"epss_score": 0.00245, "epss_percentile": 0.47667}, "CVE-2025-10703": {"epss_score": 0.00245, "epss_percentile": 0.47667}, "CVE-2025-10705": {"epss_score": 0.00034, "epss_percentile": 0.09682}, "CVE-2025-10706": {"epss_score": 0.00321, "epss_percentile": 0.54652}, "CVE-2025-10707": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-10708": {"epss_score": 0.00338, "epss_percentile": 0.56143}, "CVE-2025-10709": {"epss_score": 0.00338, "epss_percentile": 0.56143}, "CVE-2025-10710": {"epss_score": 0.00042, "epss_percentile": 0.12577}, "CVE-2025-10711": {"epss_score": 0.00042, "epss_percentile": 0.12577}, "CVE-2025-10712": {"epss_score": 0.00042, "epss_percentile": 0.12665}, "CVE-2025-10713": {"epss_score": 0.00101, "epss_percentile": 0.28697}, "CVE-2025-10714": {"epss_score": 0.00016, "epss_percentile": 0.0278}, "CVE-2025-10715": {"epss_score": 0.00018, "epss_percentile": 0.03572}, "CVE-2025-10716": {"epss_score": 0.00017, "epss_percentile": 0.03403}, "CVE-2025-10717": {"epss_score": 0.00018, "epss_percentile": 0.03572}, "CVE-2025-10718": {"epss_score": 0.00017, "epss_percentile": 0.03403}, "CVE-2025-10719": {"epss_score": 0.00051, "epss_percentile": 0.16216}, "CVE-2025-10720": {"epss_score": 0.00134, "epss_percentile": 0.3386}, "CVE-2025-10721": {"epss_score": 0.00018, "epss_percentile": 0.03572}, "CVE-2025-10722": {"epss_score": 0.00018, "epss_percentile": 0.03572}, "CVE-2025-10723": {"epss_score": 0.00053, "epss_percentile": 0.16842}, "CVE-2025-10725": {"epss_score": 0.00114, "epss_percentile": 0.30817}, "CVE-2025-10726": {"epss_score": 0.00178, "epss_percentile": 0.39728}, "CVE-2025-10727": {"epss_score": 0.00048, "epss_percentile": 0.14954}, "CVE-2025-10728": {"epss_score": 0.00021, "epss_percentile": 0.04909}, "CVE-2025-10729": {"epss_score": 0.00021, "epss_percentile": 0.04909}, "CVE-2025-10730": {"epss_score": 0.00039, "epss_percentile": 0.11446}, "CVE-2025-10732": {"epss_score": 0.0004, "epss_percentile": 0.11866}, "CVE-2025-10735": {"epss_score": 0.00076, "epss_percentile": 0.23181}, "CVE-2025-10737": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-10738": {"epss_score": 0.00065, "epss_percentile": 0.20504}, "CVE-2025-10740": {"epss_score": 0.00061, "epss_percentile": 0.19344}, "CVE-2025-10741": {"epss_score": 0.00054, "epss_percentile": 0.17177}, "CVE-2025-10742": {"epss_score": 0.00221, "epss_percentile": 0.44669}, "CVE-2025-10743": {"epss_score": 0.00102, "epss_percentile": 0.28737}, "CVE-2025-10744": {"epss_score": 0.00057, "epss_percentile": 0.17997}, "CVE-2025-10745": {"epss_score": 0.00137, "epss_percentile": 0.34212}, "CVE-2025-10746": {"epss_score": 0.00095, "epss_percentile": 0.27159}, "CVE-2025-10747": {"epss_score": 0.00333, "epss_percentile": 0.55636}, "CVE-2025-10748": {"epss_score": 0.00032, "epss_percentile": 0.08735}, "CVE-2025-10749": {"epss_score": 0.0005, "epss_percentile": 0.15866}, "CVE-2025-10750": {"epss_score": 0.00125, "epss_percentile": 0.32544}, "CVE-2025-10751": {"epss_score": 0.00016, "epss_percentile": 0.0287}, "CVE-2025-10752": {"epss_score": 0.00028, "epss_percentile": 0.07524}, "CVE-2025-10754": {"epss_score": 0.00307, "epss_percentile": 0.53527}, "CVE-2025-10755": {"epss_score": 0.0005, "epss_percentile": 0.15941}, "CVE-2025-10756": {"epss_score": 0.00065, "epss_percentile": 0.20497}, "CVE-2025-10757": {"epss_score": 0.00065, "epss_percentile": 0.20497}, "CVE-2025-10758": {"epss_score": 0.00043, "epss_percentile": 0.13177}, "CVE-2025-10759": {"epss_score": 0.00072, "epss_percentile": 0.22457}, "CVE-2025-10760": {"epss_score": 0.00054, "epss_percentile": 0.17177}, "CVE-2025-10761": {"epss_score": 0.00067, "epss_percentile": 0.21158}, "CVE-2025-10762": {"epss_score": 0.00042, "epss_percentile": 0.12714}, "CVE-2025-10763": {"epss_score": 0.0005, "epss_percentile": 0.15941}, "CVE-2025-10764": {"epss_score": 0.0005, "epss_percentile": 0.15697}, "CVE-2025-10765": {"epss_score": 0.00054, "epss_percentile": 0.17264}, "CVE-2025-10766": {"epss_score": 0.00098, "epss_percentile": 0.27712}, "CVE-2025-10767": {"epss_score": 0.00475, "epss_percentile": 0.64247}, "CVE-2025-10768": {"epss_score": 0.0005, "epss_percentile": 0.15885}, "CVE-2025-10769": {"epss_score": 0.00066, "epss_percentile": 0.20868}, "CVE-2025-10770": {"epss_score": 0.00055, "epss_percentile": 0.17413}, "CVE-2025-10771": {"epss_score": 0.00049, "epss_percentile": 0.15365}, "CVE-2025-10772": {"epss_score": 0.00028, "epss_percentile": 0.07583}, "CVE-2025-10773": {"epss_score": 0.00125, "epss_percentile": 0.3255}, "CVE-2025-10774": {"epss_score": 0.0033, "epss_percentile": 0.55455}, "CVE-2025-10775": {"epss_score": 0.00243, "epss_percentile": 0.47485}, "CVE-2025-10776": {"epss_score": 0.00019, "epss_percentile": 0.04234}, "CVE-2025-10777": {"epss_score": 0.00076, "epss_percentile": 0.23273}, "CVE-2025-10778": {"epss_score": 0.0003, "epss_percentile": 0.08056}, "CVE-2025-10779": {"epss_score": 0.00091, "epss_percentile": 0.26404}, "CVE-2025-10780": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10781": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10782": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10783": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10784": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10785": {"epss_score": 0.00051, "epss_percentile": 0.16007}, "CVE-2025-10786": {"epss_score": 0.00048, "epss_percentile": 0.15186}, "CVE-2025-10787": {"epss_score": 0.0005, "epss_percentile": 0.15941}, "CVE-2025-10788": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10789": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10790": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10791": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10792": {"epss_score": 0.0069, "epss_percentile": 0.71246}, "CVE-2025-10793": {"epss_score": 0.00045, "epss_percentile": 0.14053}, "CVE-2025-10794": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-10795": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10796": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10797": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10798": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10799": {"epss_score": 0.00048, "epss_percentile": 0.15186}, "CVE-2025-10800": {"epss_score": 0.00051, "epss_percentile": 0.16007}, "CVE-2025-10801": {"epss_score": 0.00055, "epss_percentile": 0.17568}, "CVE-2025-10802": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10803": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-10804": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10805": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10806": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10807": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10808": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10809": {"epss_score": 0.00055, "epss_percentile": 0.17568}, "CVE-2025-10810": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10811": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10812": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10813": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-10814": {"epss_score": 0.00099, "epss_percentile": 0.28423}, "CVE-2025-10815": {"epss_score": 0.00109, "epss_percentile": 0.29951}, "CVE-2025-10816": {"epss_score": 0.00063, "epss_percentile": 0.19926}, "CVE-2025-10817": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-10819": {"epss_score": 0.00035, "epss_percentile": 0.09852}, "CVE-2025-10820": {"epss_score": 0.00035, "epss_percentile": 0.09852}, "CVE-2025-10821": {"epss_score": 0.00035, "epss_percentile": 0.09852}, "CVE-2025-10822": {"epss_score": 0.00035, "epss_percentile": 0.09852}, "CVE-2025-10823": {"epss_score": 0.00019, "epss_percentile": 0.04274}, "CVE-2025-10824": {"epss_score": 0.00019, "epss_percentile": 0.0425}, "CVE-2025-10825": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10826": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10827": {"epss_score": 0.00047, "epss_percentile": 0.1469}, "CVE-2025-10828": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10829": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10830": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10831": {"epss_score": 0.00052, "epss_percentile": 0.16648}, "CVE-2025-10832": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10833": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10834": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10835": {"epss_score": 0.00051, "epss_percentile": 0.1612}, "CVE-2025-10836": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10837": {"epss_score": 0.00037, "epss_percentile": 0.10728}, "CVE-2025-10838": {"epss_score": 0.00112, "epss_percentile": 0.30454}, "CVE-2025-10839": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10840": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10841": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10842": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10843": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-10844": {"epss_score": 0.00039, "epss_percentile": 0.1147}, "CVE-2025-10845": {"epss_score": 0.00039, "epss_percentile": 0.1147}, "CVE-2025-10846": {"epss_score": 0.00039, "epss_percentile": 0.1147}, "CVE-2025-10847": {"epss_score": 0.00234, "epss_percentile": 0.46088}, "CVE-2025-10848": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-10849": {"epss_score": 0.001, "epss_percentile": 0.2856}, "CVE-2025-10850": {"epss_score": 0.0027, "epss_percentile": 0.5023}, "CVE-2025-10851": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10853": {"epss_score": 0.00031, "epss_percentile": 0.08682}, "CVE-2025-10854": {"epss_score": 0.00095, "epss_percentile": 0.27155}, "CVE-2025-10857": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-10858": {"epss_score": 0.00062, "epss_percentile": 0.19742}, "CVE-2025-10859": {"epss_score": 0.00016, "epss_percentile": 0.03034}, "CVE-2025-10861": {"epss_score": 0.00048, "epss_percentile": 0.1505}, "CVE-2025-10862": {"epss_score": 0.00106, "epss_percentile": 0.29509}, "CVE-2025-10867": {"epss_score": 0.00038, "epss_percentile": 0.11113}, "CVE-2025-10868": {"epss_score": 0.00017, "epss_percentile": 0.03348}, "CVE-2025-10869": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-10870": {"epss_score": 0.00043, "epss_percentile": 0.13277}, "CVE-2025-10871": {"epss_score": 0.00016, "epss_percentile": 0.02687}, "CVE-2025-10873": {"epss_score": 0.00056, "epss_percentile": 0.17803}, "CVE-2025-10874": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2025-10875": {"epss_score": 0.00056, "epss_percentile": 0.17674}, "CVE-2025-10876": {"epss_score": 0.00038, "epss_percentile": 0.11296}, "CVE-2025-10879": {"epss_score": 0.00045, "epss_percentile": 0.13758}, "CVE-2025-10880": {"epss_score": 0.00045, "epss_percentile": 0.13782}, "CVE-2025-10881": {"epss_score": 0.00023, "epss_percentile": 0.05457}, "CVE-2025-10882": {"epss_score": 0.00029, "epss_percentile": 0.07704}, "CVE-2025-10883": {"epss_score": 0.00023, "epss_percentile": 0.05457}, "CVE-2025-10884": {"epss_score": 0.00029, "epss_percentile": 0.07704}, "CVE-2025-10885": {"epss_score": 0.00019, "epss_percentile": 0.04054}, "CVE-2025-10886": {"epss_score": 0.0002, "epss_percentile": 0.04682}, "CVE-2025-10887": {"epss_score": 0.00023, "epss_percentile": 0.05457}, "CVE-2025-10888": {"epss_score": 0.00029, "epss_percentile": 0.07704}, "CVE-2025-10889": {"epss_score": 0.00023, "epss_percentile": 0.05457}, "CVE-2025-10890": {"epss_score": 0.00042, "epss_percentile": 0.12666}, "CVE-2025-10891": {"epss_score": 0.00101, "epss_percentile": 0.28674}, "CVE-2025-10892": {"epss_score": 0.00101, "epss_percentile": 0.28674}, "CVE-2025-10894": {"epss_score": 0.00067, "epss_percentile": 0.20971}, "CVE-2025-10896": {"epss_score": 0.00256, "epss_percentile": 0.48836}, "CVE-2025-10897": {"epss_score": 0.00196, "epss_percentile": 0.41792}, "CVE-2025-10898": {"epss_score": 0.00029, "epss_percentile": 0.07704}, "CVE-2025-10899": {"epss_score": 0.00029, "epss_percentile": 0.07704}, "CVE-2025-10900": {"epss_score": 0.00029, "epss_percentile": 0.07704}, "CVE-2025-10901": {"epss_score": 0.00045, "epss_percentile": 0.13747}, "CVE-2025-10902": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-10905": {"epss_score": 0.00022, "epss_percentile": 0.05266}, "CVE-2025-10906": {"epss_score": 0.00029, "epss_percentile": 0.07834}, "CVE-2025-10907": {"epss_score": 0.00444, "epss_percentile": 0.62828}, "CVE-2025-10909": {"epss_score": 0.00012, "epss_percentile": 0.01336}, "CVE-2025-10910": {"epss_score": 0.00188, "epss_percentile": 0.40896}, "CVE-2025-10911": {"epss_score": 0.00016, "epss_percentile": 0.02757}, "CVE-2025-10914": {"epss_score": 0.00055, "epss_percentile": 0.17457}, "CVE-2025-10916": {"epss_score": 0.00123, "epss_percentile": 0.32252}, "CVE-2025-10918": {"epss_score": 0.00029, "epss_percentile": 0.07948}, "CVE-2025-10920": {"epss_score": 0.00108, "epss_percentile": 0.29806}, "CVE-2025-10921": {"epss_score": 0.00089, "epss_percentile": 0.25799}, "CVE-2025-10922": {"epss_score": 0.00119, "epss_percentile": 0.31559}, "CVE-2025-10923": {"epss_score": 0.00086, "epss_percentile": 0.25301}, "CVE-2025-10924": {"epss_score": 0.00086, "epss_percentile": 0.25301}, "CVE-2025-10925": {"epss_score": 0.00078, "epss_percentile": 0.23773}, "CVE-2025-10926": {"epss_score": 0.00041, "epss_percentile": 0.12317}, "CVE-2025-10927": {"epss_score": 0.00041, "epss_percentile": 0.12317}, "CVE-2025-10928": {"epss_score": 0.00061, "epss_percentile": 0.19374}, "CVE-2025-10929": {"epss_score": 0.00124, "epss_percentile": 0.32367}, "CVE-2025-10930": {"epss_score": 0.00021, "epss_percentile": 0.04733}, "CVE-2025-10931": {"epss_score": 0.00041, "epss_percentile": 0.1238}, "CVE-2025-10932": {"epss_score": 0.00019, "epss_percentile": 0.04294}, "CVE-2025-10933": {"epss_score": 0.00084, "epss_percentile": 0.24939}, "CVE-2025-10934": {"epss_score": 0.00089, "epss_percentile": 0.25799}, "CVE-2025-10937": {"epss_score": 0.0004, "epss_percentile": 0.11989}, "CVE-2025-10938": {"epss_score": 0.00036, "epss_percentile": 0.105}, "CVE-2025-10939": {"epss_score": 0.00016, "epss_percentile": 0.02782}, "CVE-2025-10940": {"epss_score": 0.00036, "epss_percentile": 0.10323}, "CVE-2025-10941": {"epss_score": 0.00015, "epss_percentile": 0.02487}, "CVE-2025-10942": {"epss_score": 0.00123, "epss_percentile": 0.32186}, "CVE-2025-10943": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-10944": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-10945": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-10946": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-10947": {"epss_score": 0.00047, "epss_percentile": 0.1493}, "CVE-2025-10948": {"epss_score": 0.00065, "epss_percentile": 0.20497}, "CVE-2025-10949": {"epss_score": 0.00038, "epss_percentile": 0.11301}, "CVE-2025-10950": {"epss_score": 0.0006, "epss_percentile": 0.19105}, "CVE-2025-10951": {"epss_score": 0.00087, "epss_percentile": 0.25505}, "CVE-2025-10952": {"epss_score": 0.00044, "epss_percentile": 0.1364}, "CVE-2025-10953": {"epss_score": 0.00123, "epss_percentile": 0.32186}, "CVE-2025-10954": {"epss_score": 0.001, "epss_percentile": 0.28488}, "CVE-2025-10955": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-10957": {"epss_score": 0.00241, "epss_percentile": 0.47236}, "CVE-2025-10958": {"epss_score": 0.00377, "epss_percentile": 0.58706}, "CVE-2025-10959": {"epss_score": 0.00377, "epss_percentile": 0.58706}, "CVE-2025-10960": {"epss_score": 0.00377, "epss_percentile": 0.58706}, "CVE-2025-10961": {"epss_score": 0.00796, "epss_percentile": 0.73488}, "CVE-2025-10962": {"epss_score": 0.00377, "epss_percentile": 0.58706}, "CVE-2025-10963": {"epss_score": 0.00377, "epss_percentile": 0.58706}, "CVE-2025-10964": {"epss_score": 0.00377, "epss_percentile": 0.58706}, "CVE-2025-10965": {"epss_score": 0.0006, "epss_percentile": 0.19105}, "CVE-2025-10966": {"epss_score": 0.00017, "epss_percentile": 0.03246}, "CVE-2025-10967": {"epss_score": 0.00042, "epss_percentile": 0.12665}, "CVE-2025-10968": {"epss_score": 0.00039, "epss_percentile": 0.11662}, "CVE-2025-10971": {"epss_score": 0.0002, "epss_percentile": 0.04654}, "CVE-2025-10973": {"epss_score": 0.00042, "epss_percentile": 0.12665}, "CVE-2025-10974": {"epss_score": 0.00064, "epss_percentile": 0.20385}, "CVE-2025-10975": {"epss_score": 0.00064, "epss_percentile": 0.20385}, "CVE-2025-10976": {"epss_score": 0.00039, "epss_percentile": 0.11542}, "CVE-2025-10977": {"epss_score": 0.00039, "epss_percentile": 0.11542}, "CVE-2025-10978": {"epss_score": 0.00039, "epss_percentile": 0.11542}, "CVE-2025-10979": {"epss_score": 0.00039, "epss_percentile": 0.11542}, "CVE-2025-10980": {"epss_score": 0.00039, "epss_percentile": 0.11542}, "CVE-2025-10981": {"epss_score": 0.00039, "epss_percentile": 0.11542}, "CVE-2025-10985": {"epss_score": 0.02289, "epss_percentile": 0.84275}, "CVE-2025-10986": {"epss_score": 0.00707, "epss_percentile": 0.71642}, "CVE-2025-10987": {"epss_score": 0.0005, "epss_percentile": 0.15697}, "CVE-2025-10988": {"epss_score": 0.0005, "epss_percentile": 0.15697}, "CVE-2025-10989": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-10991": {"epss_score": 0.00027, "epss_percentile": 0.06793}, "CVE-2025-10992": {"epss_score": 0.00044, "epss_percentile": 0.1364}, "CVE-2025-10993": {"epss_score": 0.00049, "epss_percentile": 0.15507}, "CVE-2025-10994": {"epss_score": 0.0003, "epss_percentile": 0.08263}, "CVE-2025-10995": {"epss_score": 0.00036, "epss_percentile": 0.10235}, "CVE-2025-10996": {"epss_score": 0.0003, "epss_percentile": 0.08263}, "CVE-2025-10997": {"epss_score": 0.0003, "epss_percentile": 0.08263}, "CVE-2025-10998": {"epss_score": 0.00031, "epss_percentile": 0.08511}, "CVE-2025-10999": {"epss_score": 0.00031, "epss_percentile": 0.08511}, "CVE-2025-11000": {"epss_score": 0.00028, "epss_percentile": 0.07255}, "CVE-2025-11001": {"epss_score": 0.00319, "epss_percentile": 0.5455}, "CVE-2025-11003": {"epss_score": 0.00032, "epss_percentile": 0.08961}, "CVE-2025-11005": {"epss_score": 0.02823, "epss_percentile": 0.85753}, "CVE-2025-11007": {"epss_score": 0.00255, "epss_percentile": 0.48703}, "CVE-2025-11008": {"epss_score": 0.0019, "epss_percentile": 0.41132}, "CVE-2025-11009": {"epss_score": 0.0001, "epss_percentile": 0.00869}, "CVE-2025-11010": {"epss_score": 0.00019, "epss_percentile": 0.0425}, "CVE-2025-11011": {"epss_score": 0.00028, "epss_percentile": 0.07529}, "CVE-2025-11012": {"epss_score": 0.00029, "epss_percentile": 0.07665}, "CVE-2025-11013": {"epss_score": 0.00026, "epss_percentile": 0.06489}, "CVE-2025-11014": {"epss_score": 0.0003, "epss_percentile": 0.08263}, "CVE-2025-11015": {"epss_score": 0.00019, "epss_percentile": 0.04379}, "CVE-2025-11016": {"epss_score": 0.00073, "epss_percentile": 0.22527}, "CVE-2025-11017": {"epss_score": 0.00031, "epss_percentile": 0.08511}, "CVE-2025-11018": {"epss_score": 0.00338, "epss_percentile": 0.56143}, "CVE-2025-11019": {"epss_score": 0.00036, "epss_percentile": 0.10323}, "CVE-2025-11020": {"epss_score": 0.00054, "epss_percentile": 0.17089}, "CVE-2025-11021": {"epss_score": 0.00062, "epss_percentile": 0.19754}, "CVE-2025-11022": {"epss_score": 0.00069, "epss_percentile": 0.21545}, "CVE-2025-11023": {"epss_score": 0.00172, "epss_percentile": 0.38969}, "CVE-2025-11025": {"epss_score": 0.00042, "epss_percentile": 0.12728}, "CVE-2025-11026": {"epss_score": 0.00041, "epss_percentile": 0.12196}, "CVE-2025-11027": {"epss_score": 0.00034, "epss_percentile": 0.0978}, "CVE-2025-11028": {"epss_score": 0.00055, "epss_percentile": 0.17412}, "CVE-2025-11029": {"epss_score": 0.00029, "epss_percentile": 0.07948}, "CVE-2025-11030": {"epss_score": 0.00057, "epss_percentile": 0.18024}, "CVE-2025-11031": {"epss_score": 0.00166, "epss_percentile": 0.38254}, "CVE-2025-11032": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11033": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11034": {"epss_score": 0.00057, "epss_percentile": 0.18108}, "CVE-2025-11035": {"epss_score": 0.00015, "epss_percentile": 0.0242}, "CVE-2025-11036": {"epss_score": 0.00045, "epss_percentile": 0.14053}, "CVE-2025-11037": {"epss_score": 0.00045, "epss_percentile": 0.14053}, "CVE-2025-11038": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11039": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11040": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11041": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11042": {"epss_score": 0.0006, "epss_percentile": 0.19234}, "CVE-2025-11045": {"epss_score": 0.01773, "epss_percentile": 0.82207}, "CVE-2025-11046": {"epss_score": 0.0006, "epss_percentile": 0.19024}, "CVE-2025-11047": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-11048": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-11049": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-11050": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-11051": {"epss_score": 0.00041, "epss_percentile": 0.12306}, "CVE-2025-11052": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11053": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11054": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11055": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11056": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11057": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11060": {"epss_score": 0.00044, "epss_percentile": 0.13548}, "CVE-2025-11061": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11062": {"epss_score": 0.00048, "epss_percentile": 0.15186}, "CVE-2025-11063": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11064": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11066": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11067": {"epss_score": 0.00043, "epss_percentile": 0.13177}, "CVE-2025-11068": {"epss_score": 0.00043, "epss_percentile": 0.13177}, "CVE-2025-11069": {"epss_score": 0.00043, "epss_percentile": 0.13177}, "CVE-2025-11070": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11071": {"epss_score": 0.00034, "epss_percentile": 0.09649}, "CVE-2025-11072": {"epss_score": 0.00091, "epss_percentile": 0.26403}, "CVE-2025-11073": {"epss_score": 0.00336, "epss_percentile": 0.55929}, "CVE-2025-11074": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11075": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11076": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11077": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11078": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-11079": {"epss_score": 0.00257, "epss_percentile": 0.48868}, "CVE-2025-11080": {"epss_score": 0.0004, "epss_percentile": 0.12006}, "CVE-2025-11081": {"epss_score": 0.00027, "epss_percentile": 0.0682}, "CVE-2025-11082": {"epss_score": 0.00023, "epss_percentile": 0.05642}, "CVE-2025-11083": {"epss_score": 0.00026, "epss_percentile": 0.0662}, "CVE-2025-11084": {"epss_score": 0.00021, "epss_percentile": 0.04769}, "CVE-2025-11085": {"epss_score": 0.00081, "epss_percentile": 0.24341}, "CVE-2025-11086": {"epss_score": 0.00103, "epss_percentile": 0.29046}, "CVE-2025-11087": {"epss_score": 0.00059, "epss_percentile": 0.18687}, "CVE-2025-11088": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11089": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11090": {"epss_score": 0.00054, "epss_percentile": 0.17222}, "CVE-2025-11091": {"epss_score": 0.00102, "epss_percentile": 0.288}, "CVE-2025-11092": {"epss_score": 0.00099, "epss_percentile": 0.28423}, "CVE-2025-11093": {"epss_score": 0.00151, "epss_percentile": 0.36315}, "CVE-2025-11094": {"epss_score": 0.00042, "epss_percentile": 0.12792}, "CVE-2025-11095": {"epss_score": 0.00099, "epss_percentile": 0.28423}, "CVE-2025-11096": {"epss_score": 0.00099, "epss_percentile": 0.28423}, "CVE-2025-11097": {"epss_score": 0.00099, "epss_percentile": 0.28423}, "CVE-2025-11098": {"epss_score": 0.00099, "epss_percentile": 0.28423}, "CVE-2025-11099": {"epss_score": 0.00099, "epss_percentile": 0.28423}, "CVE-2025-11100": {"epss_score": 0.00099, "epss_percentile": 0.28423}, "CVE-2025-11101": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11102": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11103": {"epss_score": 0.00054, "epss_percentile": 0.17264}, "CVE-2025-11104": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11105": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11106": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11107": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11108": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11109": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11110": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11111": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11112": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-11113": {"epss_score": 0.00039, "epss_percentile": 0.1147}, "CVE-2025-11114": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11115": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11116": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11117": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11118": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11119": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-11120": {"epss_score": 0.00102, "epss_percentile": 0.288}, "CVE-2025-11121": {"epss_score": 0.00901, "epss_percentile": 0.75172}, "CVE-2025-11122": {"epss_score": 0.00112, "epss_percentile": 0.30454}, "CVE-2025-11123": {"epss_score": 0.00112, "epss_percentile": 0.30454}, "CVE-2025-11124": {"epss_score": 0.00051, "epss_percentile": 0.16134}, "CVE-2025-11125": {"epss_score": 0.00042, "epss_percentile": 0.12577}, "CVE-2025-11126": {"epss_score": 0.00064, "epss_percentile": 0.20205}, "CVE-2025-11127": {"epss_score": 0.0014, "epss_percentile": 0.34789}, "CVE-2025-11128": {"epss_score": 0.00047, "epss_percentile": 0.14754}, "CVE-2025-11129": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-11130": {"epss_score": 0.00029, "epss_percentile": 0.07834}, "CVE-2025-11131": {"epss_score": 0.00167, "epss_percentile": 0.38334}, "CVE-2025-11132": {"epss_score": 0.00167, "epss_percentile": 0.38334}, "CVE-2025-11133": {"epss_score": 0.00167, "epss_percentile": 0.38334}, "CVE-2025-11134": {"epss_score": 0.00038, "epss_percentile": 0.11301}, "CVE-2025-11135": {"epss_score": 0.00058, "epss_percentile": 0.18537}, "CVE-2025-11136": {"epss_score": 0.00052, "epss_percentile": 0.16493}, "CVE-2025-11137": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-11138": {"epss_score": 0.00377, "epss_percentile": 0.58706}, "CVE-2025-11139": {"epss_score": 0.00116, "epss_percentile": 0.31174}, "CVE-2025-11140": {"epss_score": 0.00054, "epss_percentile": 0.17072}, "CVE-2025-11141": {"epss_score": 0.0033, "epss_percentile": 0.55455}, "CVE-2025-11145": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-11146": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-11147": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-11148": {"epss_score": 0.00123, "epss_percentile": 0.32316}, "CVE-2025-11149": {"epss_score": 0.00018, "epss_percentile": 0.03883}, "CVE-2025-11151": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-11152": {"epss_score": 0.00054, "epss_percentile": 0.17345}, "CVE-2025-11153": {"epss_score": 0.00044, "epss_percentile": 0.13473}, "CVE-2025-11154": {"epss_score": 0.00025, "epss_percentile": 0.06111}, "CVE-2025-11155": {"epss_score": 0.00022, "epss_percentile": 0.05028}, "CVE-2025-11156": {"epss_score": 0.00019, "epss_percentile": 0.04092}, "CVE-2025-11157": {"epss_score": 0.00312, "epss_percentile": 0.53953}, "CVE-2025-11160": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-11161": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-11162": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-11163": {"epss_score": 0.00037, "epss_percentile": 0.10898}, "CVE-2025-11164": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-11166": {"epss_score": 8e-05, "epss_percentile": 0.00573}, "CVE-2025-11167": {"epss_score": 0.0005, "epss_percentile": 0.15856}, "CVE-2025-11168": {"epss_score": 0.00048, "epss_percentile": 0.14935}, "CVE-2025-11170": {"epss_score": 0.00215, "epss_percentile": 0.44025}, "CVE-2025-11171": {"epss_score": 0.00294, "epss_percentile": 0.52405}, "CVE-2025-11172": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-11174": {"epss_score": 0.00062, "epss_percentile": 0.19715}, "CVE-2025-11176": {"epss_score": 0.00037, "epss_percentile": 0.10898}, "CVE-2025-11177": {"epss_score": 0.00264, "epss_percentile": 0.49714}, "CVE-2025-11178": {"epss_score": 0.00019, "epss_percentile": 0.04231}, "CVE-2025-11182": {"epss_score": 0.00014, "epss_percentile": 0.02035}, "CVE-2025-11183": {"epss_score": 0.00021, "epss_percentile": 0.04739}, "CVE-2025-11184": {"epss_score": 0.00021, "epss_percentile": 0.04739}, "CVE-2025-11186": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-11188": {"epss_score": 0.00038, "epss_percentile": 0.11094}, "CVE-2025-11189": {"epss_score": 0.00105, "epss_percentile": 0.29278}, "CVE-2025-11190": {"epss_score": 0.00095, "epss_percentile": 0.27118}, "CVE-2025-11191": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-11192": {"epss_score": 0.0004, "epss_percentile": 0.11927}, "CVE-2025-11193": {"epss_score": 0.00015, "epss_percentile": 0.02213}, "CVE-2025-11195": {"epss_score": 0.00014, "epss_percentile": 0.0191}, "CVE-2025-11196": {"epss_score": 0.00043, "epss_percentile": 0.13096}, "CVE-2025-11197": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11198": {"epss_score": 0.00064, "epss_percentile": 0.20187}, "CVE-2025-11200": {"epss_score": 0.00414, "epss_percentile": 0.61024}, "CVE-2025-11201": {"epss_score": 0.15552, "epss_percentile": 0.94457}, "CVE-2025-11202": {"epss_score": 0.01463, "epss_percentile": 0.80445}, "CVE-2025-11203": {"epss_score": 0.00217, "epss_percentile": 0.44282}, "CVE-2025-11204": {"epss_score": 0.00097, "epss_percentile": 0.27552}, "CVE-2025-11205": {"epss_score": 0.00074, "epss_percentile": 0.2274}, "CVE-2025-11206": {"epss_score": 0.00065, "epss_percentile": 0.20459}, "CVE-2025-11207": {"epss_score": 0.00039, "epss_percentile": 0.11447}, "CVE-2025-11208": {"epss_score": 0.00074, "epss_percentile": 0.22685}, "CVE-2025-11209": {"epss_score": 0.00042, "epss_percentile": 0.12735}, "CVE-2025-11210": {"epss_score": 0.00032, "epss_percentile": 0.08812}, "CVE-2025-11211": {"epss_score": 0.00043, "epss_percentile": 0.13288}, "CVE-2025-11212": {"epss_score": 0.00074, "epss_percentile": 0.22685}, "CVE-2025-11213": {"epss_score": 0.00074, "epss_percentile": 0.22685}, "CVE-2025-11215": {"epss_score": 0.00032, "epss_percentile": 0.08812}, "CVE-2025-11216": {"epss_score": 0.00022, "epss_percentile": 0.05185}, "CVE-2025-11219": {"epss_score": 0.00043, "epss_percentile": 0.13221}, "CVE-2025-11220": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-11221": {"epss_score": 0.00042, "epss_percentile": 0.12571}, "CVE-2025-11222": {"epss_score": 0.00033, "epss_percentile": 0.09349}, "CVE-2025-11223": {"epss_score": 0.00017, "epss_percentile": 0.03247}, "CVE-2025-11226": {"epss_score": 0.00071, "epss_percentile": 0.22219}, "CVE-2025-11227": {"epss_score": 0.00117, "epss_percentile": 0.31302}, "CVE-2025-11228": {"epss_score": 0.00089, "epss_percentile": 0.25971}, "CVE-2025-11230": {"epss_score": 0.00205, "epss_percentile": 0.42722}, "CVE-2025-11232": {"epss_score": 0.0003, "epss_percentile": 0.08145}, "CVE-2025-11233": {"epss_score": 0.00094, "epss_percentile": 0.26799}, "CVE-2025-11234": {"epss_score": 0.00096, "epss_percentile": 0.2745}, "CVE-2025-11235": {"epss_score": 0.0002, "epss_percentile": 0.04544}, "CVE-2025-11237": {"epss_score": 0.00013, "epss_percentile": 0.01593}, "CVE-2025-11238": {"epss_score": 0.00147, "epss_percentile": 0.35773}, "CVE-2025-11239": {"epss_score": 0.0004, "epss_percentile": 0.11882}, "CVE-2025-11240": {"epss_score": 0.00049, "epss_percentile": 0.15514}, "CVE-2025-11241": {"epss_score": 0.00014, "epss_percentile": 0.02017}, "CVE-2025-11243": {"epss_score": 0.00021, "epss_percentile": 0.04717}, "CVE-2025-11244": {"epss_score": 0.00042, "epss_percentile": 0.12617}, "CVE-2025-11247": {"epss_score": 0.00014, "epss_percentile": 0.0211}, "CVE-2025-11248": {"epss_score": 0.00189, "epss_percentile": 0.40985}, "CVE-2025-11253": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-11254": {"epss_score": 0.00116, "epss_percentile": 0.31104}, "CVE-2025-11255": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-11256": {"epss_score": 0.00089, "epss_percentile": 0.25971}, "CVE-2025-11257": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-11260": {"epss_score": 0.00092, "epss_percentile": 0.26566}, "CVE-2025-11263": {"epss_score": 0.00116, "epss_percentile": 0.31145}, "CVE-2025-11265": {"epss_score": 0.00042, "epss_percentile": 0.12632}, "CVE-2025-11266": {"epss_score": 0.00016, "epss_percentile": 0.02834}, "CVE-2025-11267": {"epss_score": 0.00039, "epss_percentile": 0.11637}, "CVE-2025-11268": {"epss_score": 0.00141, "epss_percentile": 0.34953}, "CVE-2025-11269": {"epss_score": 0.00089, "epss_percentile": 0.25971}, "CVE-2025-11270": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-11271": {"epss_score": 0.00054, "epss_percentile": 0.17124}, "CVE-2025-11272": {"epss_score": 0.00054, "epss_percentile": 0.17227}, "CVE-2025-11273": {"epss_score": 0.0006, "epss_percentile": 0.19105}, "CVE-2025-11274": {"epss_score": 0.00028, "epss_percentile": 0.07255}, "CVE-2025-11275": {"epss_score": 0.00021, "epss_percentile": 0.04817}, "CVE-2025-11276": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-11277": {"epss_score": 0.0003, "epss_percentile": 0.08263}, "CVE-2025-11278": {"epss_score": 0.00039, "epss_percentile": 0.11696}, "CVE-2025-11279": {"epss_score": 0.00045, "epss_percentile": 0.13771}, "CVE-2025-11280": {"epss_score": 0.00047, "epss_percentile": 0.14928}, "CVE-2025-11281": {"epss_score": 0.00044, "epss_percentile": 0.13604}, "CVE-2025-11282": {"epss_score": 0.00093, "epss_percentile": 0.26746}, "CVE-2025-11283": {"epss_score": 0.00095, "epss_percentile": 0.27148}, "CVE-2025-11284": {"epss_score": 0.00082, "epss_percentile": 0.24456}, "CVE-2025-11285": {"epss_score": 0.00361, "epss_percentile": 0.57741}, "CVE-2025-11286": {"epss_score": 0.00051, "epss_percentile": 0.16104}, "CVE-2025-11287": {"epss_score": 0.00327, "epss_percentile": 0.55142}, "CVE-2025-11288": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11289": {"epss_score": 0.00038, "epss_percentile": 0.11301}, "CVE-2025-11290": {"epss_score": 0.00052, "epss_percentile": 0.16638}, "CVE-2025-11291": {"epss_score": 0.00045, "epss_percentile": 0.13704}, "CVE-2025-11292": {"epss_score": 0.00377, "epss_percentile": 0.58706}, "CVE-2025-11293": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11294": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11295": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11296": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11297": {"epss_score": 0.00125, "epss_percentile": 0.3255}, "CVE-2025-11298": {"epss_score": 0.00377, "epss_percentile": 0.58706}, "CVE-2025-11299": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11300": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11301": {"epss_score": 0.00125, "epss_percentile": 0.3255}, "CVE-2025-11302": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11303": {"epss_score": 0.00377, "epss_percentile": 0.58706}, "CVE-2025-11304": {"epss_score": 0.00022, "epss_percentile": 0.05043}, "CVE-2025-11305": {"epss_score": 0.00062, "epss_percentile": 0.19571}, "CVE-2025-11306": {"epss_score": 0.00037, "epss_percentile": 0.10657}, "CVE-2025-11307": {"epss_score": 0.06752, "epss_percentile": 0.91003}, "CVE-2025-11308": {"epss_score": 0.00042, "epss_percentile": 0.12645}, "CVE-2025-11309": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11310": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11311": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11312": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11313": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11314": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11315": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11316": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11317": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11318": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-11319": {"epss_score": 0.00039, "epss_percentile": 0.117}, "CVE-2025-11320": {"epss_score": 0.00054, "epss_percentile": 0.17177}, "CVE-2025-11321": {"epss_score": 0.0004, "epss_percentile": 0.12006}, "CVE-2025-11322": {"epss_score": 0.00047, "epss_percentile": 0.1493}, "CVE-2025-11323": {"epss_score": 0.00062, "epss_percentile": 0.19571}, "CVE-2025-11324": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11325": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11326": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11327": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11328": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11329": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11330": {"epss_score": 0.00054, "epss_percentile": 0.17222}, "CVE-2025-11331": {"epss_score": 0.00232, "epss_percentile": 0.4593}, "CVE-2025-11332": {"epss_score": 0.00036, "epss_percentile": 0.10437}, "CVE-2025-11333": {"epss_score": 0.00038, "epss_percentile": 0.11301}, "CVE-2025-11334": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11335": {"epss_score": 0.00147, "epss_percentile": 0.35789}, "CVE-2025-11336": {"epss_score": 0.00085, "epss_percentile": 0.25054}, "CVE-2025-11337": {"epss_score": 0.00085, "epss_percentile": 0.25054}, "CVE-2025-11338": {"epss_score": 0.00154, "epss_percentile": 0.36663}, "CVE-2025-11339": {"epss_score": 0.0014, "epss_percentile": 0.34748}, "CVE-2025-11340": {"epss_score": 0.00018, "epss_percentile": 0.03676}, "CVE-2025-11341": {"epss_score": 0.00066, "epss_percentile": 0.20882}, "CVE-2025-11342": {"epss_score": 0.00016, "epss_percentile": 0.02615}, "CVE-2025-11343": {"epss_score": 0.0004, "epss_percentile": 0.12173}, "CVE-2025-11344": {"epss_score": 0.00194, "epss_percentile": 0.41595}, "CVE-2025-11345": {"epss_score": 0.00117, "epss_percentile": 0.31225}, "CVE-2025-11346": {"epss_score": 0.00049, "epss_percentile": 0.15365}, "CVE-2025-11347": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-11348": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11349": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11350": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11351": {"epss_score": 0.00046, "epss_percentile": 0.14349}, "CVE-2025-11352": {"epss_score": 0.00046, "epss_percentile": 0.14349}, "CVE-2025-11353": {"epss_score": 0.00046, "epss_percentile": 0.14349}, "CVE-2025-11354": {"epss_score": 0.00051, "epss_percentile": 0.16067}, "CVE-2025-11355": {"epss_score": 0.00065, "epss_percentile": 0.20497}, "CVE-2025-11356": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11357": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2025-11358": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2025-11359": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2025-11360": {"epss_score": 0.00045, "epss_percentile": 0.13704}, "CVE-2025-11361": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-11362": {"epss_score": 0.0006, "epss_percentile": 0.19004}, "CVE-2025-11363": {"epss_score": 0.00069, "epss_percentile": 0.21444}, "CVE-2025-11365": {"epss_score": 0.00039, "epss_percentile": 0.11446}, "CVE-2025-11366": {"epss_score": 0.00128, "epss_percentile": 0.32944}, "CVE-2025-11367": {"epss_score": 0.00896, "epss_percentile": 0.75111}, "CVE-2025-11368": {"epss_score": 0.00082, "epss_percentile": 0.24438}, "CVE-2025-11369": {"epss_score": 0.0003, "epss_percentile": 0.08026}, "CVE-2025-11370": {"epss_score": 0.00048, "epss_percentile": 0.1504}, "CVE-2025-11371": {"epss_score": 0.66002, "epss_percentile": 0.98446}, "CVE-2025-11372": {"epss_score": 0.00138, "epss_percentile": 0.34432}, "CVE-2025-11373": {"epss_score": 0.00034, "epss_percentile": 0.09664}, "CVE-2025-11374": {"epss_score": 0.00019, "epss_percentile": 0.04148}, "CVE-2025-11375": {"epss_score": 0.00019, "epss_percentile": 0.04148}, "CVE-2025-11376": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-11377": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-11378": {"epss_score": 0.0004, "epss_percentile": 0.11866}, "CVE-2025-11379": {"epss_score": 0.00059, "epss_percentile": 0.18695}, "CVE-2025-11380": {"epss_score": 0.00106, "epss_percentile": 0.29559}, "CVE-2025-11385": {"epss_score": 0.00112, "epss_percentile": 0.30454}, "CVE-2025-11386": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11387": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11388": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11389": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11390": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-11391": {"epss_score": 0.00192, "epss_percentile": 0.41339}, "CVE-2025-11393": {"epss_score": 0.00023, "epss_percentile": 0.05474}, "CVE-2025-11396": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11397": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11398": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-11399": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11400": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11401": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11402": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11403": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11404": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11405": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11406": {"epss_score": 0.00037, "epss_percentile": 0.10941}, "CVE-2025-11407": {"epss_score": 0.00109, "epss_percentile": 0.29928}, "CVE-2025-11408": {"epss_score": 0.00052, "epss_percentile": 0.16339}, "CVE-2025-11409": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2025-11410": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2025-11411": {"epss_score": 0.00054, "epss_percentile": 0.17143}, "CVE-2025-11412": {"epss_score": 0.00027, "epss_percentile": 0.0682}, "CVE-2025-11413": {"epss_score": 0.00027, "epss_percentile": 0.0682}, "CVE-2025-11414": {"epss_score": 0.00027, "epss_percentile": 0.0682}, "CVE-2025-11415": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11416": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11417": {"epss_score": 0.00046, "epss_percentile": 0.14349}, "CVE-2025-11418": {"epss_score": 0.00328, "epss_percentile": 0.55257}, "CVE-2025-11419": {"epss_score": 0.00187, "epss_percentile": 0.40769}, "CVE-2025-11420": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11421": {"epss_score": 0.00034, "epss_percentile": 0.09457}, "CVE-2025-11422": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11423": {"epss_score": 0.00239, "epss_percentile": 0.46856}, "CVE-2025-11424": {"epss_score": 0.00045, "epss_percentile": 0.14053}, "CVE-2025-11425": {"epss_score": 0.00043, "epss_percentile": 0.13177}, "CVE-2025-11426": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-11427": {"epss_score": 0.00063, "epss_percentile": 0.20063}, "CVE-2025-11429": {"epss_score": 0.00047, "epss_percentile": 0.14754}, "CVE-2025-11430": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11431": {"epss_score": 0.00044, "epss_percentile": 0.13516}, "CVE-2025-11432": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11433": {"epss_score": 0.00037, "epss_percentile": 0.10728}, "CVE-2025-11434": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11435": {"epss_score": 0.00063, "epss_percentile": 0.19842}, "CVE-2025-11436": {"epss_score": 0.00047, "epss_percentile": 0.14501}, "CVE-2025-11437": {"epss_score": 0.00043, "epss_percentile": 0.13177}, "CVE-2025-11438": {"epss_score": 0.00046, "epss_percentile": 0.14284}, "CVE-2025-11439": {"epss_score": 0.00034, "epss_percentile": 0.09656}, "CVE-2025-11440": {"epss_score": 0.00034, "epss_percentile": 0.09656}, "CVE-2025-11441": {"epss_score": 0.00212, "epss_percentile": 0.4382}, "CVE-2025-11442": {"epss_score": 0.00121, "epss_percentile": 0.31989}, "CVE-2025-11443": {"epss_score": 0.00052, "epss_percentile": 0.16374}, "CVE-2025-11444": {"epss_score": 0.00171, "epss_percentile": 0.38857}, "CVE-2025-11445": {"epss_score": 0.00057, "epss_percentile": 0.1809}, "CVE-2025-11446": {"epss_score": 0.00031, "epss_percentile": 0.08378}, "CVE-2025-11447": {"epss_score": 0.00051, "epss_percentile": 0.16126}, "CVE-2025-11448": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-11449": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-11450": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-11451": {"epss_score": 0.00055, "epss_percentile": 0.17592}, "CVE-2025-11452": {"epss_score": 0.00097, "epss_percentile": 0.27583}, "CVE-2025-11454": {"epss_score": 0.00033, "epss_percentile": 0.09353}, "CVE-2025-11456": {"epss_score": 0.0033, "epss_percentile": 0.55488}, "CVE-2025-11457": {"epss_score": 0.0014, "epss_percentile": 0.34789}, "CVE-2025-11458": {"epss_score": 0.00036, "epss_percentile": 0.10253}, "CVE-2025-11460": {"epss_score": 0.00141, "epss_percentile": 0.34822}, "CVE-2025-11461": {"epss_score": 0.00034, "epss_percentile": 0.09783}, "CVE-2025-11462": {"epss_score": 0.00034, "epss_percentile": 0.0957}, "CVE-2025-11463": {"epss_score": 0.0006, "epss_percentile": 0.19022}, "CVE-2025-11464": {"epss_score": 0.00055, "epss_percentile": 0.17427}, "CVE-2025-11465": {"epss_score": 0.0006, "epss_percentile": 0.19022}, "CVE-2025-11466": {"epss_score": 0.29582, "epss_percentile": 0.96459}, "CVE-2025-11467": {"epss_score": 0.00055, "epss_percentile": 0.17593}, "CVE-2025-11469": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11470": {"epss_score": 0.00064, "epss_percentile": 0.2015}, "CVE-2025-11471": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11472": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11473": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11474": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11475": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11476": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11477": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11478": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11479": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11480": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11481": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11485": {"epss_score": 0.00044, "epss_percentile": 0.13444}, "CVE-2025-11486": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11487": {"epss_score": 0.00051, "epss_percentile": 0.1612}, "CVE-2025-11488": {"epss_score": 0.02347, "epss_percentile": 0.84455}, "CVE-2025-11489": {"epss_score": 0.00029, "epss_percentile": 0.07768}, "CVE-2025-11490": {"epss_score": 0.00255, "epss_percentile": 0.48711}, "CVE-2025-11491": {"epss_score": 0.00246, "epss_percentile": 0.47774}, "CVE-2025-11492": {"epss_score": 8e-05, "epss_percentile": 0.00554}, "CVE-2025-11493": {"epss_score": 0.00015, "epss_percentile": 0.02244}, "CVE-2025-11494": {"epss_score": 0.00027, "epss_percentile": 0.0682}, "CVE-2025-11495": {"epss_score": 0.00027, "epss_percentile": 0.0682}, "CVE-2025-11496": {"epss_score": 0.0008, "epss_percentile": 0.24172}, "CVE-2025-11497": {"epss_score": 0.00077, "epss_percentile": 0.23377}, "CVE-2025-11498": {"epss_score": 0.00054, "epss_percentile": 0.17164}, "CVE-2025-11499": {"epss_score": 0.00192, "epss_percentile": 0.41339}, "CVE-2025-11501": {"epss_score": 0.00096, "epss_percentile": 0.27361}, "CVE-2025-11502": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11503": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11504": {"epss_score": 0.00087, "epss_percentile": 0.25542}, "CVE-2025-11505": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11506": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11507": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-11508": {"epss_score": 0.00057, "epss_percentile": 0.18142}, "CVE-2025-11509": {"epss_score": 0.00044, "epss_percentile": 0.13516}, "CVE-2025-11510": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-11511": {"epss_score": 0.00044, "epss_percentile": 0.13516}, "CVE-2025-11512": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-11513": {"epss_score": 0.00065, "epss_percentile": 0.20521}, "CVE-2025-11514": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11515": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11516": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11517": {"epss_score": 0.00131, "epss_percentile": 0.33386}, "CVE-2025-11518": {"epss_score": 0.00055, "epss_percentile": 0.17533}, "CVE-2025-11519": {"epss_score": 0.00037, "epss_percentile": 0.10898}, "CVE-2025-11521": {"epss_score": 0.00181, "epss_percentile": 0.40031}, "CVE-2025-11522": {"epss_score": 0.00322, "epss_percentile": 0.54792}, "CVE-2025-11523": {"epss_score": 0.00901, "epss_percentile": 0.75172}, "CVE-2025-11524": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11525": {"epss_score": 0.00112, "epss_percentile": 0.30454}, "CVE-2025-11526": {"epss_score": 0.00112, "epss_percentile": 0.30454}, "CVE-2025-11527": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11528": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-11529": {"epss_score": 0.00211, "epss_percentile": 0.43678}, "CVE-2025-11530": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11531": {"epss_score": 0.0002, "epss_percentile": 0.04614}, "CVE-2025-11532": {"epss_score": 0.00053, "epss_percentile": 0.16736}, "CVE-2025-11533": {"epss_score": 0.00147, "epss_percentile": 0.35666}, "CVE-2025-11534": {"epss_score": 0.00155, "epss_percentile": 0.36773}, "CVE-2025-11535": {"epss_score": 0.00019, "epss_percentile": 0.04415}, "CVE-2025-11536": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-11538": {"epss_score": 0.00017, "epss_percentile": 0.03212}, "CVE-2025-11539": {"epss_score": 0.00389, "epss_percentile": 0.59467}, "CVE-2025-11540": {"epss_score": 0.00061, "epss_percentile": 0.19348}, "CVE-2025-11541": {"epss_score": 0.0007, "epss_percentile": 0.2195}, "CVE-2025-11542": {"epss_score": 0.0007, "epss_percentile": 0.2195}, "CVE-2025-11543": {"epss_score": 0.00025, "epss_percentile": 0.06215}, "CVE-2025-11544": {"epss_score": 0.00058, "epss_percentile": 0.18298}, "CVE-2025-11545": {"epss_score": 0.00055, "epss_percentile": 0.17626}, "CVE-2025-11546": {"epss_score": 0.00069, "epss_percentile": 0.2156}, "CVE-2025-11548": {"epss_score": 0.00561, "epss_percentile": 0.67658}, "CVE-2025-11549": {"epss_score": 0.0022, "epss_percentile": 0.4456}, "CVE-2025-11550": {"epss_score": 0.00091, "epss_percentile": 0.26251}, "CVE-2025-11551": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11552": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11553": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11554": {"epss_score": 0.00056, "epss_percentile": 0.17829}, "CVE-2025-11555": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11556": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11557": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11558": {"epss_score": 0.00045, "epss_percentile": 0.14053}, "CVE-2025-11560": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-11561": {"epss_score": 0.0017, "epss_percentile": 0.38726}, "CVE-2025-11564": {"epss_score": 0.00141, "epss_percentile": 0.34838}, "CVE-2025-11565": {"epss_score": 0.00025, "epss_percentile": 0.06136}, "CVE-2025-11566": {"epss_score": 0.00069, "epss_percentile": 0.21548}, "CVE-2025-11567": {"epss_score": 0.00014, "epss_percentile": 0.01862}, "CVE-2025-11568": {"epss_score": 0.00016, "epss_percentile": 0.02635}, "CVE-2025-11570": {"epss_score": 0.00039, "epss_percentile": 0.11576}, "CVE-2025-11573": {"epss_score": 0.00063, "epss_percentile": 0.19822}, "CVE-2025-11575": {"epss_score": 0.00015, "epss_percentile": 0.02167}, "CVE-2025-11576": {"epss_score": 0.00119, "epss_percentile": 0.31534}, "CVE-2025-11577": {"epss_score": 0.00027, "epss_percentile": 0.06879}, "CVE-2025-11578": {"epss_score": 0.00122, "epss_percentile": 0.32115}, "CVE-2025-11579": {"epss_score": 0.00019, "epss_percentile": 0.0409}, "CVE-2025-11580": {"epss_score": 0.00039, "epss_percentile": 0.11643}, "CVE-2025-11581": {"epss_score": 0.00041, "epss_percentile": 0.12414}, "CVE-2025-11582": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11583": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11584": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11585": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11586": {"epss_score": 0.00112, "epss_percentile": 0.30454}, "CVE-2025-11587": {"epss_score": 0.00037, "epss_percentile": 0.10898}, "CVE-2025-11588": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11589": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11590": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11591": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11592": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11593": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11594": {"epss_score": 0.00064, "epss_percentile": 0.20333}, "CVE-2025-11595": {"epss_score": 0.00035, "epss_percentile": 0.10149}, "CVE-2025-11596": {"epss_score": 0.00045, "epss_percentile": 0.14053}, "CVE-2025-11597": {"epss_score": 0.00044, "epss_percentile": 0.13516}, "CVE-2025-11599": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11600": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11601": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11602": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-11603": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11604": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11605": {"epss_score": 0.00054, "epss_percentile": 0.17222}, "CVE-2025-11606": {"epss_score": 0.00039, "epss_percentile": 0.117}, "CVE-2025-11607": {"epss_score": 0.00112, "epss_percentile": 0.30442}, "CVE-2025-11608": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11609": {"epss_score": 0.00199, "epss_percentile": 0.42144}, "CVE-2025-11610": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11611": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11612": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11613": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11614": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11615": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11616": {"epss_score": 0.00058, "epss_percentile": 0.1827}, "CVE-2025-11617": {"epss_score": 0.00058, "epss_percentile": 0.1827}, "CVE-2025-11618": {"epss_score": 0.00049, "epss_percentile": 0.15618}, "CVE-2025-11619": {"epss_score": 0.00027, "epss_percentile": 0.06738}, "CVE-2025-11620": {"epss_score": 0.00049, "epss_percentile": 0.1537}, "CVE-2025-11621": {"epss_score": 0.00146, "epss_percentile": 0.35546}, "CVE-2025-11622": {"epss_score": 0.00093, "epss_percentile": 0.26754}, "CVE-2025-11623": {"epss_score": 0.00156, "epss_percentile": 0.36908}, "CVE-2025-11624": {"epss_score": 0.00054, "epss_percentile": 0.17345}, "CVE-2025-11625": {"epss_score": 0.00093, "epss_percentile": 0.26723}, "CVE-2025-11626": {"epss_score": 9e-05, "epss_percentile": 0.00702}, "CVE-2025-11627": {"epss_score": 0.00112, "epss_percentile": 0.30474}, "CVE-2025-11628": {"epss_score": 0.00038, "epss_percentile": 0.11388}, "CVE-2025-11629": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11630": {"epss_score": 0.00149, "epss_percentile": 0.35942}, "CVE-2025-11631": {"epss_score": 0.00138, "epss_percentile": 0.34387}, "CVE-2025-11632": {"epss_score": 0.00047, "epss_percentile": 0.14754}, "CVE-2025-11633": {"epss_score": 0.00059, "epss_percentile": 0.18751}, "CVE-2025-11634": {"epss_score": 0.00019, "epss_percentile": 0.04083}, "CVE-2025-11635": {"epss_score": 0.00073, "epss_percentile": 0.22483}, "CVE-2025-11636": {"epss_score": 0.00052, "epss_percentile": 0.16638}, "CVE-2025-11637": {"epss_score": 0.00057, "epss_percentile": 0.17995}, "CVE-2025-11638": {"epss_score": 0.00051, "epss_percentile": 0.16066}, "CVE-2025-11639": {"epss_score": 0.00026, "epss_percentile": 0.06457}, "CVE-2025-11640": {"epss_score": 8e-05, "epss_percentile": 0.00565}, "CVE-2025-11641": {"epss_score": 0.00018, "epss_percentile": 0.04044}, "CVE-2025-11642": {"epss_score": 0.0002, "epss_percentile": 0.04532}, "CVE-2025-11643": {"epss_score": 0.00065, "epss_percentile": 0.20542}, "CVE-2025-11644": {"epss_score": 0.00029, "epss_percentile": 0.07701}, "CVE-2025-11645": {"epss_score": 0.00027, "epss_percentile": 0.06902}, "CVE-2025-11646": {"epss_score": 0.00027, "epss_percentile": 0.06812}, "CVE-2025-11647": {"epss_score": 0.00026, "epss_percentile": 0.06541}, "CVE-2025-11648": {"epss_score": 0.00059, "epss_percentile": 0.18741}, "CVE-2025-11649": {"epss_score": 0.00018, "epss_percentile": 0.03809}, "CVE-2025-11650": {"epss_score": 9e-05, "epss_percentile": 0.00668}, "CVE-2025-11651": {"epss_score": 0.00065, "epss_percentile": 0.20497}, "CVE-2025-11652": {"epss_score": 0.00065, "epss_percentile": 0.20497}, "CVE-2025-11653": {"epss_score": 0.00062, "epss_percentile": 0.19571}, "CVE-2025-11654": {"epss_score": 0.00042, "epss_percentile": 0.12665}, "CVE-2025-11655": {"epss_score": 0.00049, "epss_percentile": 0.15578}, "CVE-2025-11656": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-11657": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-11658": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-11659": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-11660": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-11661": {"epss_score": 0.00167, "epss_percentile": 0.38294}, "CVE-2025-11662": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11663": {"epss_score": 0.00029, "epss_percentile": 0.07943}, "CVE-2025-11664": {"epss_score": 0.00035, "epss_percentile": 0.10149}, "CVE-2025-11665": {"epss_score": 0.00223, "epss_percentile": 0.44874}, "CVE-2025-11666": {"epss_score": 0.00014, "epss_percentile": 0.01973}, "CVE-2025-11667": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11668": {"epss_score": 0.00035, "epss_percentile": 0.10149}, "CVE-2025-11670": {"epss_score": 0.00029, "epss_percentile": 0.07743}, "CVE-2025-11671": {"epss_score": 0.00054, "epss_percentile": 0.1707}, "CVE-2025-11672": {"epss_score": 0.00054, "epss_percentile": 0.1707}, "CVE-2025-11673": {"epss_score": 0.00367, "epss_percentile": 0.58132}, "CVE-2025-11674": {"epss_score": 0.00053, "epss_percentile": 0.16873}, "CVE-2025-11675": {"epss_score": 0.00317, "epss_percentile": 0.54366}, "CVE-2025-11676": {"epss_score": 0.00036, "epss_percentile": 0.1054}, "CVE-2025-11677": {"epss_score": 0.00078, "epss_percentile": 0.23748}, "CVE-2025-11678": {"epss_score": 0.00029, "epss_percentile": 0.07929}, "CVE-2025-11679": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-11680": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-11681": {"epss_score": 0.00054, "epss_percentile": 0.17152}, "CVE-2025-11682": {"epss_score": 0.00032, "epss_percentile": 0.08802}, "CVE-2025-11683": {"epss_score": 0.00019, "epss_percentile": 0.04411}, "CVE-2025-11690": {"epss_score": 0.00026, "epss_percentile": 0.06403}, "CVE-2025-11691": {"epss_score": 0.00102, "epss_percentile": 0.28737}, "CVE-2025-11692": {"epss_score": 0.00134, "epss_percentile": 0.33849}, "CVE-2025-11693": {"epss_score": 0.00177, "epss_percentile": 0.39499}, "CVE-2025-11695": {"epss_score": 0.00025, "epss_percentile": 0.06054}, "CVE-2025-11696": {"epss_score": 0.00028, "epss_percentile": 0.07281}, "CVE-2025-11697": {"epss_score": 0.00023, "epss_percentile": 0.0564}, "CVE-2025-11699": {"epss_score": 0.00031, "epss_percentile": 0.0847}, "CVE-2025-11700": {"epss_score": 0.67764, "epss_percentile": 0.98519}, "CVE-2025-11701": {"epss_score": 0.0003, "epss_percentile": 0.08187}, "CVE-2025-11702": {"epss_score": 0.00016, "epss_percentile": 0.02613}, "CVE-2025-11703": {"epss_score": 0.00033, "epss_percentile": 0.09287}, "CVE-2025-11704": {"epss_score": 0.00099, "epss_percentile": 0.28401}, "CVE-2025-11705": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-11707": {"epss_score": 0.00059, "epss_percentile": 0.18858}, "CVE-2025-11708": {"epss_score": 0.00069, "epss_percentile": 0.21513}, "CVE-2025-11709": {"epss_score": 0.00081, "epss_percentile": 0.24302}, "CVE-2025-11710": {"epss_score": 0.00081, "epss_percentile": 0.24302}, "CVE-2025-11711": {"epss_score": 0.00034, "epss_percentile": 0.09667}, "CVE-2025-11712": {"epss_score": 0.00046, "epss_percentile": 0.14303}, "CVE-2025-11713": {"epss_score": 0.00043, "epss_percentile": 0.13076}, "CVE-2025-11714": {"epss_score": 0.00051, "epss_percentile": 0.16337}, "CVE-2025-11715": {"epss_score": 0.00054, "epss_percentile": 0.172}, "CVE-2025-11716": {"epss_score": 0.00035, "epss_percentile": 0.10127}, "CVE-2025-11717": {"epss_score": 0.00045, "epss_percentile": 0.13979}, "CVE-2025-11718": {"epss_score": 0.00033, "epss_percentile": 0.09308}, "CVE-2025-11719": {"epss_score": 0.00059, "epss_percentile": 0.18875}, "CVE-2025-11720": {"epss_score": 0.00054, "epss_percentile": 0.17278}, "CVE-2025-11721": {"epss_score": 0.00059, "epss_percentile": 0.18875}, "CVE-2025-11722": {"epss_score": 0.00117, "epss_percentile": 0.31238}, "CVE-2025-11723": {"epss_score": 0.0005, "epss_percentile": 0.15712}, "CVE-2025-11724": {"epss_score": 0.00283, "epss_percentile": 0.51377}, "CVE-2025-11726": {"epss_score": 0.00035, "epss_percentile": 0.10061}, "CVE-2025-11727": {"epss_score": 0.00198, "epss_percentile": 0.42045}, "CVE-2025-11728": {"epss_score": 0.00258, "epss_percentile": 0.49019}, "CVE-2025-11731": {"epss_score": 0.00049, "epss_percentile": 0.15359}, "CVE-2025-11733": {"epss_score": 0.00141, "epss_percentile": 0.34867}, "CVE-2025-11734": {"epss_score": 0.00046, "epss_percentile": 0.14146}, "CVE-2025-11735": {"epss_score": 0.00096, "epss_percentile": 0.27361}, "CVE-2025-11736": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-11738": {"epss_score": 0.00053, "epss_percentile": 0.16968}, "CVE-2025-11740": {"epss_score": 0.00039, "epss_percentile": 0.11446}, "CVE-2025-11741": {"epss_score": 0.00059, "epss_percentile": 0.18616}, "CVE-2025-11742": {"epss_score": 0.00045, "epss_percentile": 0.13747}, "CVE-2025-11745": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-11746": {"epss_score": 0.00177, "epss_percentile": 0.39542}, "CVE-2025-11747": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-11748": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-11749": {"epss_score": 0.84872, "epss_percentile": 0.99309}, "CVE-2025-11750": {"epss_score": 0.00488, "epss_percentile": 0.64842}, "CVE-2025-11753": {"epss_score": 0.00031, "epss_percentile": 0.08475}, "CVE-2025-11755": {"epss_score": 0.00303, "epss_percentile": 0.53203}, "CVE-2025-11756": {"epss_score": 0.00119, "epss_percentile": 0.31633}, "CVE-2025-11757": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-11758": {"epss_score": 0.00091, "epss_percentile": 0.26241}, "CVE-2025-11759": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-11760": {"epss_score": 0.00057, "epss_percentile": 0.18189}, "CVE-2025-11761": {"epss_score": 0.00018, "epss_percentile": 0.03913}, "CVE-2025-11763": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-11764": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11765": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11767": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11768": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11769": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-11770": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11771": {"epss_score": 0.00182, "epss_percentile": 0.40157}, "CVE-2025-11772": {"epss_score": 0.00024, "epss_percentile": 0.05743}, "CVE-2025-11773": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-11774": {"epss_score": 0.00038, "epss_percentile": 0.11402}, "CVE-2025-11775": {"epss_score": 0.00015, "epss_percentile": 0.0241}, "CVE-2025-11776": {"epss_score": 0.00034, "epss_percentile": 0.09676}, "CVE-2025-11777": {"epss_score": 0.00028, "epss_percentile": 0.07337}, "CVE-2025-11778": {"epss_score": 0.00061, "epss_percentile": 0.19455}, "CVE-2025-11779": {"epss_score": 0.02906, "epss_percentile": 0.85963}, "CVE-2025-11780": {"epss_score": 0.00055, "epss_percentile": 0.17403}, "CVE-2025-11781": {"epss_score": 0.00021, "epss_percentile": 0.04868}, "CVE-2025-11782": {"epss_score": 0.00069, "epss_percentile": 0.21549}, "CVE-2025-11783": {"epss_score": 0.0024, "epss_percentile": 0.47196}, "CVE-2025-11784": {"epss_score": 0.00072, "epss_percentile": 0.22409}, "CVE-2025-11785": {"epss_score": 0.00072, "epss_percentile": 0.22409}, "CVE-2025-11786": {"epss_score": 0.00072, "epss_percentile": 0.22409}, "CVE-2025-11787": {"epss_score": 0.00252, "epss_percentile": 0.48355}, "CVE-2025-11788": {"epss_score": 0.00055, "epss_percentile": 0.17403}, "CVE-2025-11789": {"epss_score": 0.00039, "epss_percentile": 0.11777}, "CVE-2025-11794": {"epss_score": 0.00043, "epss_percentile": 0.13}, "CVE-2025-11795": {"epss_score": 0.00031, "epss_percentile": 0.08689}, "CVE-2025-11797": {"epss_score": 0.00025, "epss_percentile": 0.06243}, "CVE-2025-11799": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-11800": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11801": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11802": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11803": {"epss_score": 0.00039, "epss_percentile": 0.11637}, "CVE-2025-11804": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11805": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-11806": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11807": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11808": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11809": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-11810": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11811": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11812": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-11813": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11814": {"epss_score": 0.00146, "epss_percentile": 0.35588}, "CVE-2025-11815": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-11816": {"epss_score": 0.00095, "epss_percentile": 0.27165}, "CVE-2025-11817": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11818": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11819": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11820": {"epss_score": 0.00046, "epss_percentile": 0.14471}, "CVE-2025-11821": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-11822": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-11823": {"epss_score": 0.0004, "epss_percentile": 0.1207}, "CVE-2025-11824": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11825": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11826": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11827": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11828": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-11829": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11830": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-11832": {"epss_score": 0.00067, "epss_percentile": 0.21178}, "CVE-2025-11833": {"epss_score": 0.26562, "epss_percentile": 0.96157}, "CVE-2025-11834": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-11835": {"epss_score": 0.00053, "epss_percentile": 0.16736}, "CVE-2025-11837": {"epss_score": 0.00129, "epss_percentile": 0.33191}, "CVE-2025-11838": {"epss_score": 0.00064, "epss_percentile": 0.20284}, "CVE-2025-11839": {"epss_score": 0.00016, "epss_percentile": 0.03023}, "CVE-2025-11840": {"epss_score": 0.00027, "epss_percentile": 0.0682}, "CVE-2025-11841": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11842": {"epss_score": 0.00087, "epss_percentile": 0.25542}, "CVE-2025-11843": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-11844": {"epss_score": 0.00045, "epss_percentile": 0.14072}, "CVE-2025-11849": {"epss_score": 0.0033, "epss_percentile": 0.55436}, "CVE-2025-11851": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-11852": {"epss_score": 0.00063, "epss_percentile": 0.19917}, "CVE-2025-11853": {"epss_score": 0.00043, "epss_percentile": 0.13169}, "CVE-2025-11855": {"epss_score": 0.0005, "epss_percentile": 0.15884}, "CVE-2025-11856": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11857": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11859": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11860": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11862": {"epss_score": 0.0005, "epss_percentile": 0.15677}, "CVE-2025-11863": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11864": {"epss_score": 0.00057, "epss_percentile": 0.18024}, "CVE-2025-11865": {"epss_score": 0.00016, "epss_percentile": 0.02895}, "CVE-2025-11866": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-11867": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-11868": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11869": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11870": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-11872": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-11873": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11874": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-11875": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11876": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-11877": {"epss_score": 0.00051, "epss_percentile": 0.16017}, "CVE-2025-11878": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-11879": {"epss_score": 0.00042, "epss_percentile": 0.12567}, "CVE-2025-11880": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-11881": {"epss_score": 0.00058, "epss_percentile": 0.18452}, "CVE-2025-11882": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-11883": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-11884": {"epss_score": 0.0006, "epss_percentile": 0.19139}, "CVE-2025-11885": {"epss_score": 0.00116, "epss_percentile": 0.31145}, "CVE-2025-11886": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-11887": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-11888": {"epss_score": 0.00036, "epss_percentile": 0.10517}, "CVE-2025-11889": {"epss_score": 0.00358, "epss_percentile": 0.57531}, "CVE-2025-11890": {"epss_score": 0.0009, "epss_percentile": 0.26128}, "CVE-2025-11891": {"epss_score": 0.00041, "epss_percentile": 0.12274}, "CVE-2025-11892": {"epss_score": 0.00047, "epss_percentile": 0.14619}, "CVE-2025-11893": {"epss_score": 0.00043, "epss_percentile": 0.13095}, "CVE-2025-11894": {"epss_score": 0.00072, "epss_percentile": 0.22316}, "CVE-2025-11895": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-11896": {"epss_score": 0.00021, "epss_percentile": 0.04909}, "CVE-2025-11897": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-11898": {"epss_score": 0.00098, "epss_percentile": 0.27788}, "CVE-2025-11899": {"epss_score": 0.00126, "epss_percentile": 0.32758}, "CVE-2025-11900": {"epss_score": 0.00632, "epss_percentile": 0.69752}, "CVE-2025-11901": {"epss_score": 0.00023, "epss_percentile": 0.0565}, "CVE-2025-11902": {"epss_score": 0.00034, "epss_percentile": 0.09753}, "CVE-2025-11903": {"epss_score": 0.00034, "epss_percentile": 0.09753}, "CVE-2025-11904": {"epss_score": 0.00034, "epss_percentile": 0.09753}, "CVE-2025-11905": {"epss_score": 0.00058, "epss_percentile": 0.1858}, "CVE-2025-11906": {"epss_score": 0.00014, "epss_percentile": 0.01748}, "CVE-2025-11908": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-11909": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11910": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11911": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11912": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-11913": {"epss_score": 0.0011, "epss_percentile": 0.30105}, "CVE-2025-11914": {"epss_score": 0.0011, "epss_percentile": 0.30105}, "CVE-2025-11915": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-11917": {"epss_score": 0.00036, "epss_percentile": 0.10607}, "CVE-2025-11918": {"epss_score": 4e-05, "epss_percentile": 0.00157}, "CVE-2025-11920": {"epss_score": 0.00158, "epss_percentile": 0.37252}, "CVE-2025-11921": {"epss_score": 0.00194, "epss_percentile": 0.41564}, "CVE-2025-11922": {"epss_score": 0.00048, "epss_percentile": 0.15288}, "CVE-2025-11923": {"epss_score": 0.00053, "epss_percentile": 0.16817}, "CVE-2025-11924": {"epss_score": 0.00093, "epss_percentile": 0.26745}, "CVE-2025-11925": {"epss_score": 0.00039, "epss_percentile": 0.11594}, "CVE-2025-11926": {"epss_score": 0.00032, "epss_percentile": 0.08777}, "CVE-2025-11927": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-11928": {"epss_score": 0.00033, "epss_percentile": 0.0912}, "CVE-2025-11931": {"epss_score": 0.00053, "epss_percentile": 0.16937}, "CVE-2025-11932": {"epss_score": 0.00033, "epss_percentile": 0.0916}, "CVE-2025-11933": {"epss_score": 0.00116, "epss_percentile": 0.31112}, "CVE-2025-11934": {"epss_score": 0.00031, "epss_percentile": 0.08509}, "CVE-2025-11935": {"epss_score": 0.00017, "epss_percentile": 0.03417}, "CVE-2025-11936": {"epss_score": 0.00092, "epss_percentile": 0.26589}, "CVE-2025-11937": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-11938": {"epss_score": 0.0006, "epss_percentile": 0.19064}, "CVE-2025-11939": {"epss_score": 0.00242, "epss_percentile": 0.47353}, "CVE-2025-11940": {"epss_score": 0.00016, "epss_percentile": 0.02912}, "CVE-2025-11941": {"epss_score": 0.00114, "epss_percentile": 0.30842}, "CVE-2025-11942": {"epss_score": 0.00369, "epss_percentile": 0.58273}, "CVE-2025-11943": {"epss_score": 0.00073, "epss_percentile": 0.22626}, "CVE-2025-11944": {"epss_score": 0.00054, "epss_percentile": 0.1715}, "CVE-2025-11945": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-11946": {"epss_score": 0.00038, "epss_percentile": 0.11264}, "CVE-2025-11947": {"epss_score": 0.00019, "epss_percentile": 0.04144}, "CVE-2025-11948": {"epss_score": 0.00246, "epss_percentile": 0.47759}, "CVE-2025-11949": {"epss_score": 0.00089, "epss_percentile": 0.25921}, "CVE-2025-11952": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-11953": {"epss_score": 0.00609, "epss_percentile": 0.69088}, "CVE-2025-11955": {"epss_score": 0.00047, "epss_percentile": 0.14592}, "CVE-2025-11956": {"epss_score": 0.00047, "epss_percentile": 0.14632}, "CVE-2025-11957": {"epss_score": 0.00072, "epss_percentile": 0.22241}, "CVE-2025-11958": {"epss_score": 0.00064, "epss_percentile": 0.20287}, "CVE-2025-11959": {"epss_score": 0.00039, "epss_percentile": 0.11777}, "CVE-2025-11960": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-11961": {"epss_score": 0.00015, "epss_percentile": 0.02308}, "CVE-2025-11962": {"epss_score": 0.00038, "epss_percentile": 0.11195}, "CVE-2025-11963": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-11964": {"epss_score": 0.00015, "epss_percentile": 0.02308}, "CVE-2025-11965": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-11966": {"epss_score": 0.0007, "epss_percentile": 0.21704}, "CVE-2025-11967": {"epss_score": 0.00343, "epss_percentile": 0.56443}, "CVE-2025-11970": {"epss_score": 0.0003, "epss_percentile": 0.08305}, "CVE-2025-11971": {"epss_score": 0.00016, "epss_percentile": 0.02671}, "CVE-2025-11972": {"epss_score": 0.00035, "epss_percentile": 0.10158}, "CVE-2025-11973": {"epss_score": 0.0004, "epss_percentile": 0.12174}, "CVE-2025-11974": {"epss_score": 0.00046, "epss_percentile": 0.1415}, "CVE-2025-11975": {"epss_score": 0.00095, "epss_percentile": 0.27079}, "CVE-2025-11976": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-11979": {"epss_score": 0.00077, "epss_percentile": 0.23531}, "CVE-2025-11980": {"epss_score": 0.00034, "epss_percentile": 0.09533}, "CVE-2025-11981": {"epss_score": 0.00034, "epss_percentile": 0.09533}, "CVE-2025-11983": {"epss_score": 0.00046, "epss_percentile": 0.14198}, "CVE-2025-11984": {"epss_score": 0.00024, "epss_percentile": 0.05813}, "CVE-2025-11985": {"epss_score": 0.00064, "epss_percentile": 0.20335}, "CVE-2025-11986": {"epss_score": 0.0023, "epss_percentile": 0.45691}, "CVE-2025-11987": {"epss_score": 0.00039, "epss_percentile": 0.11637}, "CVE-2025-11988": {"epss_score": 0.00064, "epss_percentile": 0.20138}, "CVE-2025-11989": {"epss_score": 0.00014, "epss_percentile": 0.01857}, "CVE-2025-11990": {"epss_score": 0.00017, "epss_percentile": 0.034}, "CVE-2025-11991": {"epss_score": 0.00067, "epss_percentile": 0.20973}, "CVE-2025-11992": {"epss_score": 0.0005, "epss_percentile": 0.15887}, "CVE-2025-11994": {"epss_score": 0.00124, "epss_percentile": 0.32391}, "CVE-2025-11995": {"epss_score": 0.00163, "epss_percentile": 0.37835}, "CVE-2025-11996": {"epss_score": 0.0007, "epss_percentile": 0.2183}, "CVE-2025-11997": {"epss_score": 0.00038, "epss_percentile": 0.11281}, "CVE-2025-11998": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-11999": {"epss_score": 0.00064, "epss_percentile": 0.20207}, "CVE-2025-12000": {"epss_score": 0.01027, "epss_percentile": 0.76809}, "CVE-2025-12001": {"epss_score": 0.00082, "epss_percentile": 0.24502}, "CVE-2025-12003": {"epss_score": 0.00285, "epss_percentile": 0.51669}, "CVE-2025-12004": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-12005": {"epss_score": 0.00037, "epss_percentile": 0.10898}, "CVE-2025-12010": {"epss_score": 0.00037, "epss_percentile": 0.10915}, "CVE-2025-12014": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-12015": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12016": {"epss_score": 0.0004, "epss_percentile": 0.11942}, "CVE-2025-12017": {"epss_score": 0.00134, "epss_percentile": 0.33845}, "CVE-2025-12018": {"epss_score": 0.00036, "epss_percentile": 0.10409}, "CVE-2025-12019": {"epss_score": 0.00057, "epss_percentile": 0.1806}, "CVE-2025-12020": {"epss_score": 0.0003, "epss_percentile": 0.08021}, "CVE-2025-12021": {"epss_score": 0.00137, "epss_percentile": 0.34248}, "CVE-2025-12022": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12023": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12025": {"epss_score": 0.0003, "epss_percentile": 0.08276}, "CVE-2025-12026": {"epss_score": 0.00108, "epss_percentile": 0.2977}, "CVE-2025-12028": {"epss_score": 0.00041, "epss_percentile": 0.12274}, "CVE-2025-12029": {"epss_score": 0.00092, "epss_percentile": 0.26459}, "CVE-2025-12030": {"epss_score": 0.0002, "epss_percentile": 0.04655}, "CVE-2025-12031": {"epss_score": 0.00044, "epss_percentile": 0.13533}, "CVE-2025-12032": {"epss_score": 0.00038, "epss_percentile": 0.11269}, "CVE-2025-12033": {"epss_score": 0.0004, "epss_percentile": 0.11942}, "CVE-2025-12034": {"epss_score": 0.00032, "epss_percentile": 0.09031}, "CVE-2025-12035": {"epss_score": 0.00022, "epss_percentile": 0.04981}, "CVE-2025-12036": {"epss_score": 0.00089, "epss_percentile": 0.25826}, "CVE-2025-12038": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-12039": {"epss_score": 0.00028, "epss_percentile": 0.07366}, "CVE-2025-12040": {"epss_score": 0.0005, "epss_percentile": 0.15885}, "CVE-2025-12041": {"epss_score": 0.0007, "epss_percentile": 0.21694}, "CVE-2025-12042": {"epss_score": 0.00067, "epss_percentile": 0.21037}, "CVE-2025-12043": {"epss_score": 0.00072, "epss_percentile": 0.22316}, "CVE-2025-12044": {"epss_score": 0.00121, "epss_percentile": 0.31894}, "CVE-2025-12045": {"epss_score": 0.00042, "epss_percentile": 0.12632}, "CVE-2025-12046": {"epss_score": 0.00015, "epss_percentile": 0.02465}, "CVE-2025-12047": {"epss_score": 0.00018, "epss_percentile": 0.03982}, "CVE-2025-12048": {"epss_score": 0.00071, "epss_percentile": 0.22029}, "CVE-2025-12049": {"epss_score": 0.00079, "epss_percentile": 0.23866}, "CVE-2025-12055": {"epss_score": 0.4282, "epss_percentile": 0.97356}, "CVE-2025-12056": {"epss_score": 0.00023, "epss_percentile": 0.0535}, "CVE-2025-12057": {"epss_score": 0.00145, "epss_percentile": 0.35374}, "CVE-2025-12058": {"epss_score": 0.00052, "epss_percentile": 0.16578}, "CVE-2025-12060": {"epss_score": 0.00104, "epss_percentile": 0.292}, "CVE-2025-12061": {"epss_score": 0.00036, "epss_percentile": 0.1027}, "CVE-2025-12064": {"epss_score": 0.00116, "epss_percentile": 0.31145}, "CVE-2025-12065": {"epss_score": 0.00038, "epss_percentile": 0.11269}, "CVE-2025-12066": {"epss_score": 0.00031, "epss_percentile": 0.08582}, "CVE-2025-12067": {"epss_score": 0.00029, "epss_percentile": 0.07681}, "CVE-2025-12069": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-12070": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-12072": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-12076": {"epss_score": 0.0008, "epss_percentile": 0.24172}, "CVE-2025-12077": {"epss_score": 0.00089, "epss_percentile": 0.25907}, "CVE-2025-12078": {"epss_score": 0.00116, "epss_percentile": 0.31145}, "CVE-2025-12079": {"epss_score": 0.00116, "epss_percentile": 0.31145}, "CVE-2025-12080": {"epss_score": 2e-05, "epss_percentile": 0.00042}, "CVE-2025-12082": {"epss_score": 0.0005, "epss_percentile": 0.15759}, "CVE-2025-12083": {"epss_score": 0.00041, "epss_percentile": 0.12317}, "CVE-2025-12084": {"epss_score": 0.00173, "epss_percentile": 0.39133}, "CVE-2025-12085": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12086": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12087": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12088": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12089": {"epss_score": 0.01894, "epss_percentile": 0.82741}, "CVE-2025-12090": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-12091": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-12092": {"epss_score": 0.01629, "epss_percentile": 0.8144}, "CVE-2025-12093": {"epss_score": 0.00115, "epss_percentile": 0.30927}, "CVE-2025-12094": {"epss_score": 0.00156, "epss_percentile": 0.36934}, "CVE-2025-12095": {"epss_score": 0.00022, "epss_percentile": 0.05182}, "CVE-2025-12096": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-12097": {"epss_score": 0.00121, "epss_percentile": 0.31951}, "CVE-2025-12098": {"epss_score": 0.00055, "epss_percentile": 0.17409}, "CVE-2025-12099": {"epss_score": 0.00137, "epss_percentile": 0.34218}, "CVE-2025-12100": {"epss_score": 0.00015, "epss_percentile": 0.02167}, "CVE-2025-12101": {"epss_score": 0.02324, "epss_percentile": 0.84381}, "CVE-2025-12103": {"epss_score": 0.0003, "epss_percentile": 0.08293}, "CVE-2025-12104": {"epss_score": 0.00221, "epss_percentile": 0.44698}, "CVE-2025-12105": {"epss_score": 0.00062, "epss_percentile": 0.19722}, "CVE-2025-12106": {"epss_score": 0.00083, "epss_percentile": 0.24804}, "CVE-2025-12108": {"epss_score": 0.00059, "epss_percentile": 0.1864}, "CVE-2025-12109": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-12110": {"epss_score": 0.00047, "epss_percentile": 0.14754}, "CVE-2025-12112": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12113": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12114": {"epss_score": 0.00019, "epss_percentile": 0.04183}, "CVE-2025-12115": {"epss_score": 0.00135, "epss_percentile": 0.33932}, "CVE-2025-12118": {"epss_score": 0.00045, "epss_percentile": 0.13997}, "CVE-2025-12119": {"epss_score": 6e-05, "epss_percentile": 0.00242}, "CVE-2025-12120": {"epss_score": 0.0002, "epss_percentile": 0.04604}, "CVE-2025-12121": {"epss_score": 0.00021, "epss_percentile": 0.04904}, "CVE-2025-12123": {"epss_score": 0.00116, "epss_percentile": 0.31145}, "CVE-2025-12124": {"epss_score": 0.00031, "epss_percentile": 0.08582}, "CVE-2025-12125": {"epss_score": 0.00031, "epss_percentile": 0.08582}, "CVE-2025-12126": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-12128": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-12130": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-12132": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-12133": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12134": {"epss_score": 0.001, "epss_percentile": 0.2856}, "CVE-2025-12135": {"epss_score": 0.00198, "epss_percentile": 0.42045}, "CVE-2025-12136": {"epss_score": 0.00045, "epss_percentile": 0.13772}, "CVE-2025-12137": {"epss_score": 0.00063, "epss_percentile": 0.20049}, "CVE-2025-12138": {"epss_score": 0.00262, "epss_percentile": 0.49349}, "CVE-2025-12139": {"epss_score": 0.3428, "epss_percentile": 0.96839}, "CVE-2025-12140": {"epss_score": 0.00112, "epss_percentile": 0.30417}, "CVE-2025-12142": {"epss_score": 0.00019, "epss_percentile": 0.0437}, "CVE-2025-12143": {"epss_score": 0.00019, "epss_percentile": 0.0406}, "CVE-2025-12147": {"epss_score": 0.00058, "epss_percentile": 0.18279}, "CVE-2025-12148": {"epss_score": 0.00058, "epss_percentile": 0.18279}, "CVE-2025-12149": {"epss_score": 0.00047, "epss_percentile": 0.14661}, "CVE-2025-12151": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12153": {"epss_score": 0.00305, "epss_percentile": 0.53322}, "CVE-2025-12154": {"epss_score": 0.00305, "epss_percentile": 0.53322}, "CVE-2025-12155": {"epss_score": 0.00609, "epss_percentile": 0.69097}, "CVE-2025-12156": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12157": {"epss_score": 0.00086, "epss_percentile": 0.25278}, "CVE-2025-12158": {"epss_score": 0.00133, "epss_percentile": 0.33646}, "CVE-2025-12160": {"epss_score": 0.00141, "epss_percentile": 0.34867}, "CVE-2025-12161": {"epss_score": 0.00305, "epss_percentile": 0.53322}, "CVE-2025-12163": {"epss_score": 0.00014, "epss_percentile": 0.02053}, "CVE-2025-12165": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12167": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12169": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12170": {"epss_score": 0.00096, "epss_percentile": 0.27366}, "CVE-2025-12171": {"epss_score": 0.00354, "epss_percentile": 0.57208}, "CVE-2025-12173": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-12174": {"epss_score": 0.00045, "epss_percentile": 0.14069}, "CVE-2025-12175": {"epss_score": 0.00037, "epss_percentile": 0.10894}, "CVE-2025-12176": {"epss_score": 0.00065, "epss_percentile": 0.20659}, "CVE-2025-12177": {"epss_score": 0.00115, "epss_percentile": 0.30927}, "CVE-2025-12180": {"epss_score": 0.00037, "epss_percentile": 0.10681}, "CVE-2025-12181": {"epss_score": 0.00305, "epss_percentile": 0.53322}, "CVE-2025-12182": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-12183": {"epss_score": 0.002, "epss_percentile": 0.42227}, "CVE-2025-12184": {"epss_score": 0.00031, "epss_percentile": 0.08582}, "CVE-2025-12185": {"epss_score": 0.00031, "epss_percentile": 0.08475}, "CVE-2025-12186": {"epss_score": 0.00031, "epss_percentile": 0.08582}, "CVE-2025-12188": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-12189": {"epss_score": 0.00022, "epss_percentile": 0.05265}, "CVE-2025-12190": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2025-12191": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-12192": {"epss_score": 0.00055, "epss_percentile": 0.17409}, "CVE-2025-12193": {"epss_score": 0.00116, "epss_percentile": 0.31145}, "CVE-2025-12194": {"epss_score": 0.00021, "epss_percentile": 0.04909}, "CVE-2025-12195": {"epss_score": 0.00139, "epss_percentile": 0.3464}, "CVE-2025-12196": {"epss_score": 0.00139, "epss_percentile": 0.3464}, "CVE-2025-12197": {"epss_score": 0.00127, "epss_percentile": 0.32812}, "CVE-2025-12201": {"epss_score": 0.00049, "epss_percentile": 0.15578}, "CVE-2025-12202": {"epss_score": 0.0002, "epss_percentile": 0.0449}, "CVE-2025-12203": {"epss_score": 0.0007, "epss_percentile": 0.21808}, "CVE-2025-12204": {"epss_score": 0.00018, "epss_percentile": 0.03909}, "CVE-2025-12205": {"epss_score": 0.00018, "epss_percentile": 0.03909}, "CVE-2025-12206": {"epss_score": 0.00028, "epss_percentile": 0.07315}, "CVE-2025-12207": {"epss_score": 0.00028, "epss_percentile": 0.07315}, "CVE-2025-12208": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12209": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-12210": {"epss_score": 0.0016, "epss_percentile": 0.37459}, "CVE-2025-12211": {"epss_score": 0.0016, "epss_percentile": 0.37459}, "CVE-2025-12212": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-12213": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-12214": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-12215": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12216": {"epss_score": 0.00036, "epss_percentile": 0.10492}, "CVE-2025-12217": {"epss_score": 0.00047, "epss_percentile": 0.14808}, "CVE-2025-12218": {"epss_score": 0.00047, "epss_percentile": 0.14808}, "CVE-2025-12219": {"epss_score": 0.00067, "epss_percentile": 0.21178}, "CVE-2025-12220": {"epss_score": 0.00067, "epss_percentile": 0.21178}, "CVE-2025-12221": {"epss_score": 0.00025, "epss_percentile": 0.06252}, "CVE-2025-12222": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-12223": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-12224": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-12225": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-12226": {"epss_score": 0.00051, "epss_percentile": 0.16012}, "CVE-2025-12227": {"epss_score": 0.00036, "epss_percentile": 0.10437}, "CVE-2025-12228": {"epss_score": 0.00039, "epss_percentile": 0.11724}, "CVE-2025-12229": {"epss_score": 0.00039, "epss_percentile": 0.11724}, "CVE-2025-12230": {"epss_score": 0.00039, "epss_percentile": 0.11724}, "CVE-2025-12231": {"epss_score": 0.00039, "epss_percentile": 0.11724}, "CVE-2025-12232": {"epss_score": 0.0022, "epss_percentile": 0.4456}, "CVE-2025-12233": {"epss_score": 0.00146, "epss_percentile": 0.35613}, "CVE-2025-12234": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-12235": {"epss_score": 0.00199, "epss_percentile": 0.42146}, "CVE-2025-12236": {"epss_score": 0.00146, "epss_percentile": 0.35613}, "CVE-2025-12237": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12238": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-12239": {"epss_score": 0.00245, "epss_percentile": 0.4764}, "CVE-2025-12240": {"epss_score": 0.00245, "epss_percentile": 0.4764}, "CVE-2025-12241": {"epss_score": 0.00163, "epss_percentile": 0.37784}, "CVE-2025-12242": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2025-12243": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-12244": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-12245": {"epss_score": 0.00025, "epss_percentile": 0.06258}, "CVE-2025-12246": {"epss_score": 0.00047, "epss_percentile": 0.1469}, "CVE-2025-12247": {"epss_score": 0.00016, "epss_percentile": 0.03052}, "CVE-2025-12248": {"epss_score": 0.00042, "epss_percentile": 0.12665}, "CVE-2025-12249": {"epss_score": 0.00061, "epss_percentile": 0.19432}, "CVE-2025-12250": {"epss_score": 0.00121, "epss_percentile": 0.3196}, "CVE-2025-12251": {"epss_score": 0.00039, "epss_percentile": 0.1165}, "CVE-2025-12252": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2025-12253": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-12254": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2025-12255": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2025-12256": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2025-12257": {"epss_score": 0.00037, "epss_percentile": 0.10876}, "CVE-2025-12258": {"epss_score": 0.00163, "epss_percentile": 0.37784}, "CVE-2025-12259": {"epss_score": 0.00163, "epss_percentile": 0.37784}, "CVE-2025-12260": {"epss_score": 0.00163, "epss_percentile": 0.37784}, "CVE-2025-12261": {"epss_score": 0.00036, "epss_percentile": 0.10359}, "CVE-2025-12262": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-12263": {"epss_score": 0.00037, "epss_percentile": 0.11036}, "CVE-2025-12264": {"epss_score": 0.00037, "epss_percentile": 0.10725}, "CVE-2025-12265": {"epss_score": 0.0016, "epss_percentile": 0.37459}, "CVE-2025-12266": {"epss_score": 0.00076, "epss_percentile": 0.23225}, "CVE-2025-12267": {"epss_score": 0.00042, "epss_percentile": 0.12577}, "CVE-2025-12268": {"epss_score": 0.00051, "epss_percentile": 0.16067}, "CVE-2025-12269": {"epss_score": 0.00036, "epss_percentile": 0.10437}, "CVE-2025-12270": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-12271": {"epss_score": 0.0016, "epss_percentile": 0.37459}, "CVE-2025-12272": {"epss_score": 0.0016, "epss_percentile": 0.37459}, "CVE-2025-12273": {"epss_score": 0.00188, "epss_percentile": 0.40855}, "CVE-2025-12274": {"epss_score": 0.00102, "epss_percentile": 0.288}, "CVE-2025-12275": {"epss_score": 0.00187, "epss_percentile": 0.40769}, "CVE-2025-12276": {"epss_score": 0.00043, "epss_percentile": 0.13227}, "CVE-2025-12277": {"epss_score": 0.00042, "epss_percentile": 0.12665}, "CVE-2025-12278": {"epss_score": 0.00085, "epss_percentile": 0.25063}, "CVE-2025-12279": {"epss_score": 0.00044, "epss_percentile": 0.13444}, "CVE-2025-12280": {"epss_score": 0.00036, "epss_percentile": 0.1025}, "CVE-2025-12281": {"epss_score": 0.00036, "epss_percentile": 0.1025}, "CVE-2025-12282": {"epss_score": 0.00059, "epss_percentile": 0.18615}, "CVE-2025-12283": {"epss_score": 0.00039, "epss_percentile": 0.11542}, "CVE-2025-12284": {"epss_score": 0.00082, "epss_percentile": 0.24502}, "CVE-2025-12285": {"epss_score": 0.00132, "epss_percentile": 0.33558}, "CVE-2025-12286": {"epss_score": 0.00016, "epss_percentile": 0.02751}, "CVE-2025-12287": {"epss_score": 0.00035, "epss_percentile": 0.10149}, "CVE-2025-12288": {"epss_score": 0.00036, "epss_percentile": 0.10255}, "CVE-2025-12289": {"epss_score": 0.00042, "epss_percentile": 0.12577}, "CVE-2025-12290": {"epss_score": 0.00042, "epss_percentile": 0.12577}, "CVE-2025-12291": {"epss_score": 0.00049, "epss_percentile": 0.15578}, "CVE-2025-12292": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12293": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12294": {"epss_score": 0.00035, "epss_percentile": 0.10149}, "CVE-2025-12295": {"epss_score": 0.00121, "epss_percentile": 0.31841}, "CVE-2025-12296": {"epss_score": 0.00223, "epss_percentile": 0.44874}, "CVE-2025-12297": {"epss_score": 0.00035, "epss_percentile": 0.09852}, "CVE-2025-12298": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-12299": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-12300": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-12301": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-12302": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-12303": {"epss_score": 0.00044, "epss_percentile": 0.13444}, "CVE-2025-12304": {"epss_score": 0.00037, "epss_percentile": 0.10941}, "CVE-2025-12305": {"epss_score": 0.00049, "epss_percentile": 0.15365}, "CVE-2025-12306": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12307": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12308": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12309": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12310": {"epss_score": 0.00104, "epss_percentile": 0.29151}, "CVE-2025-12311": {"epss_score": 0.00044, "epss_percentile": 0.13444}, "CVE-2025-12312": {"epss_score": 0.00044, "epss_percentile": 0.13444}, "CVE-2025-12313": {"epss_score": 0.00109, "epss_percentile": 0.29928}, "CVE-2025-12314": {"epss_score": 0.00035, "epss_percentile": 0.10149}, "CVE-2025-12315": {"epss_score": 0.00035, "epss_percentile": 0.10149}, "CVE-2025-12316": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12322": {"epss_score": 0.00106, "epss_percentile": 0.2955}, "CVE-2025-12324": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12325": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12326": {"epss_score": 0.00035, "epss_percentile": 0.10145}, "CVE-2025-12327": {"epss_score": 0.00034, "epss_percentile": 0.09752}, "CVE-2025-12328": {"epss_score": 0.00034, "epss_percentile": 0.09752}, "CVE-2025-12329": {"epss_score": 0.00034, "epss_percentile": 0.09752}, "CVE-2025-12330": {"epss_score": 0.00044, "epss_percentile": 0.13444}, "CVE-2025-12331": {"epss_score": 0.00054, "epss_percentile": 0.17264}, "CVE-2025-12332": {"epss_score": 0.00063, "epss_percentile": 0.19851}, "CVE-2025-12333": {"epss_score": 0.00056, "epss_percentile": 0.17854}, "CVE-2025-12334": {"epss_score": 0.00056, "epss_percentile": 0.17854}, "CVE-2025-12335": {"epss_score": 0.00056, "epss_percentile": 0.17854}, "CVE-2025-12336": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12337": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12338": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12339": {"epss_score": 0.00039, "epss_percentile": 0.11525}, "CVE-2025-12341": {"epss_score": 0.00029, "epss_percentile": 0.07903}, "CVE-2025-12342": {"epss_score": 0.00042, "epss_percentile": 0.12665}, "CVE-2025-12344": {"epss_score": 0.0005, "epss_percentile": 0.15941}, "CVE-2025-12346": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-12347": {"epss_score": 0.00048, "epss_percentile": 0.15157}, "CVE-2025-12348": {"epss_score": 0.00063, "epss_percentile": 0.19919}, "CVE-2025-12349": {"epss_score": 0.00118, "epss_percentile": 0.31511}, "CVE-2025-12350": {"epss_score": 0.00115, "epss_percentile": 0.30927}, "CVE-2025-12351": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-12352": {"epss_score": 0.00184, "epss_percentile": 0.40404}, "CVE-2025-12353": {"epss_score": 0.00096, "epss_percentile": 0.27366}, "CVE-2025-12354": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12355": {"epss_score": 0.00096, "epss_percentile": 0.27366}, "CVE-2025-12357": {"epss_score": 0.00018, "epss_percentile": 0.03759}, "CVE-2025-12358": {"epss_score": 0.00016, "epss_percentile": 0.02659}, "CVE-2025-12359": {"epss_score": 0.00041, "epss_percentile": 0.12213}, "CVE-2025-12360": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-12361": {"epss_score": 0.00028, "epss_percentile": 0.07324}, "CVE-2025-12362": {"epss_score": 0.00059, "epss_percentile": 0.18843}, "CVE-2025-12363": {"epss_score": 0.00049, "epss_percentile": 0.15342}, "CVE-2025-12364": {"epss_score": 0.00065, "epss_percentile": 0.20659}, "CVE-2025-12365": {"epss_score": 0.00043, "epss_percentile": 0.13318}, "CVE-2025-12366": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-12367": {"epss_score": 0.00037, "epss_percentile": 0.10898}, "CVE-2025-12368": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12369": {"epss_score": 0.00039, "epss_percentile": 0.11637}, "CVE-2025-12370": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12371": {"epss_score": 0.00031, "epss_percentile": 0.08582}, "CVE-2025-12372": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-12373": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-12374": {"epss_score": 0.00422, "epss_percentile": 0.61577}, "CVE-2025-12376": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-12377": {"epss_score": 0.00041, "epss_percentile": 0.12214}, "CVE-2025-12378": {"epss_score": 0.00062, "epss_percentile": 0.19764}, "CVE-2025-12380": {"epss_score": 0.00059, "epss_percentile": 0.18681}, "CVE-2025-12381": {"epss_score": 0.00013, "epss_percentile": 0.01687}, "CVE-2025-12382": {"epss_score": 0.00104, "epss_percentile": 0.29102}, "CVE-2025-12383": {"epss_score": 0.00068, "epss_percentile": 0.21272}, "CVE-2025-12384": {"epss_score": 0.00104, "epss_percentile": 0.2921}, "CVE-2025-12385": {"epss_score": 0.00118, "epss_percentile": 0.31514}, "CVE-2025-12388": {"epss_score": 0.00032, "epss_percentile": 0.08961}, "CVE-2025-12389": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12390": {"epss_score": 0.00015, "epss_percentile": 0.02587}, "CVE-2025-12391": {"epss_score": 0.00096, "epss_percentile": 0.27366}, "CVE-2025-12392": {"epss_score": 0.00096, "epss_percentile": 0.27366}, "CVE-2025-12393": {"epss_score": 0.00031, "epss_percentile": 0.08582}, "CVE-2025-12394": {"epss_score": 0.00097, "epss_percentile": 0.27634}, "CVE-2025-12396": {"epss_score": 0.00031, "epss_percentile": 0.08582}, "CVE-2025-12397": {"epss_score": 0.00032, "epss_percentile": 0.08747}, "CVE-2025-12398": {"epss_score": 0.0008, "epss_percentile": 0.24172}, "CVE-2025-12399": {"epss_score": 0.00319, "epss_percentile": 0.54466}, "CVE-2025-12400": {"epss_score": 0.00014, "epss_percentile": 0.02107}, "CVE-2025-12401": {"epss_score": 0.00014, "epss_percentile": 0.02107}, "CVE-2025-12402": {"epss_score": 0.00014, "epss_percentile": 0.02107}, "CVE-2025-12403": {"epss_score": 0.00014, "epss_percentile": 0.02107}, "CVE-2025-12404": {"epss_score": 0.00014, "epss_percentile": 0.02107}, "CVE-2025-12405": {"epss_score": 0.0005, "epss_percentile": 0.15677}, "CVE-2025-12406": {"epss_score": 0.00014, "epss_percentile": 0.02107}, "CVE-2025-12407": {"epss_score": 0.00014, "epss_percentile": 0.01936}, "CVE-2025-12408": {"epss_score": 0.0005, "epss_percentile": 0.15855}, "CVE-2025-12409": {"epss_score": 0.00032, "epss_percentile": 0.08747}, "CVE-2025-12410": {"epss_score": 0.00014, "epss_percentile": 0.02107}, "CVE-2025-12411": {"epss_score": 0.00031, "epss_percentile": 0.08697}, "CVE-2025-12412": {"epss_score": 0.00014, "epss_percentile": 0.01778}, "CVE-2025-12413": {"epss_score": 0.00016, "epss_percentile": 0.02744}, "CVE-2025-12414": {"epss_score": 0.00069, "epss_percentile": 0.21548}, "CVE-2025-12415": {"epss_score": 0.00014, "epss_percentile": 0.02107}, "CVE-2025-12416": {"epss_score": 0.00014, "epss_percentile": 0.01778}, "CVE-2025-12417": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12418": {"epss_score": 0.00025, "epss_percentile": 0.06108}, "CVE-2025-12419": {"epss_score": 0.00065, "epss_percentile": 0.20527}, "CVE-2025-12421": {"epss_score": 0.00065, "epss_percentile": 0.20527}, "CVE-2025-12422": {"epss_score": 0.00113, "epss_percentile": 0.30638}, "CVE-2025-12423": {"epss_score": 0.00063, "epss_percentile": 0.19877}, "CVE-2025-12424": {"epss_score": 0.00065, "epss_percentile": 0.20659}, "CVE-2025-12425": {"epss_score": 0.00045, "epss_percentile": 0.14012}, "CVE-2025-12426": {"epss_score": 0.0008, "epss_percentile": 0.24133}, "CVE-2025-12427": {"epss_score": 0.00059, "epss_percentile": 0.18908}, "CVE-2025-12428": {"epss_score": 0.00122, "epss_percentile": 0.32144}, "CVE-2025-12429": {"epss_score": 0.00088, "epss_percentile": 0.25661}, "CVE-2025-12430": {"epss_score": 0.00044, "epss_percentile": 0.13641}, "CVE-2025-12431": {"epss_score": 0.00019, "epss_percentile": 0.04413}, "CVE-2025-12432": {"epss_score": 0.00079, "epss_percentile": 0.23959}, "CVE-2025-12433": {"epss_score": 0.00032, "epss_percentile": 0.08812}, "CVE-2025-12434": {"epss_score": 0.00064, "epss_percentile": 0.20255}, "CVE-2025-12435": {"epss_score": 0.00075, "epss_percentile": 0.23058}, "CVE-2025-12436": {"epss_score": 0.00023, "epss_percentile": 0.05468}, "CVE-2025-12437": {"epss_score": 0.00119, "epss_percentile": 0.31633}, "CVE-2025-12438": {"epss_score": 0.00119, "epss_percentile": 0.31633}, "CVE-2025-12439": {"epss_score": 3e-05, "epss_percentile": 0.00062}, "CVE-2025-12440": {"epss_score": 0.00036, "epss_percentile": 0.10253}, "CVE-2025-12441": {"epss_score": 0.00032, "epss_percentile": 0.08812}, "CVE-2025-12443": {"epss_score": 0.00027, "epss_percentile": 0.06953}, "CVE-2025-12444": {"epss_score": 0.00072, "epss_percentile": 0.22471}, "CVE-2025-12445": {"epss_score": 0.00019, "epss_percentile": 0.04413}, "CVE-2025-12446": {"epss_score": 0.00074, "epss_percentile": 0.22685}, "CVE-2025-12447": {"epss_score": 0.00072, "epss_percentile": 0.22471}, "CVE-2025-12449": {"epss_score": 0.00026, "epss_percentile": 0.06721}, "CVE-2025-12450": {"epss_score": 0.00134, "epss_percentile": 0.33845}, "CVE-2025-12452": {"epss_score": 0.00015, "epss_percentile": 0.02155}, "CVE-2025-12456": {"epss_score": 0.00015, "epss_percentile": 0.0259}, "CVE-2025-12457": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12460": {"epss_score": 0.00227, "epss_percentile": 0.45454}, "CVE-2025-12461": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-12463": {"epss_score": 0.00044, "epss_percentile": 0.13452}, "CVE-2025-12464": {"epss_score": 0.00019, "epss_percentile": 0.04349}, "CVE-2025-12465": {"epss_score": 0.0004, "epss_percentile": 0.11901}, "CVE-2025-12466": {"epss_score": 0.00079, "epss_percentile": 0.23956}, "CVE-2025-12468": {"epss_score": 0.00213, "epss_percentile": 0.43842}, "CVE-2025-12469": {"epss_score": 0.00085, "epss_percentile": 0.25167}, "CVE-2025-12471": {"epss_score": 0.00129, "epss_percentile": 0.33114}, "CVE-2025-12472": {"epss_score": 0.00077, "epss_percentile": 0.23359}, "CVE-2025-12475": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-12476": {"epss_score": 0.00065, "epss_percentile": 0.20659}, "CVE-2025-12477": {"epss_score": 0.00065, "epss_percentile": 0.20659}, "CVE-2025-12478": {"epss_score": 0.00028, "epss_percentile": 0.0753}, "CVE-2025-12479": {"epss_score": 0.00025, "epss_percentile": 0.06311}, "CVE-2025-12480": {"epss_score": 0.74171, "epss_percentile": 0.9879}, "CVE-2025-12481": {"epss_score": 0.00034, "epss_percentile": 0.09661}, "CVE-2025-12482": {"epss_score": 0.00092, "epss_percentile": 0.26514}, "CVE-2025-12483": {"epss_score": 0.00033, "epss_percentile": 0.09204}, "CVE-2025-12484": {"epss_score": 0.0031, "epss_percentile": 0.53789}, "CVE-2025-12485": {"epss_score": 0.00053, "epss_percentile": 0.16878}, "CVE-2025-12486": {"epss_score": 0.0026, "epss_percentile": 0.49103}, "CVE-2025-12487": {"epss_score": 0.01759, "epss_percentile": 0.82142}, "CVE-2025-12488": {"epss_score": 0.01759, "epss_percentile": 0.82142}, "CVE-2025-12489": {"epss_score": 0.00093, "epss_percentile": 0.26608}, "CVE-2025-12490": {"epss_score": 0.13811, "epss_percentile": 0.94064}, "CVE-2025-12491": {"epss_score": 0.00209, "epss_percentile": 0.43368}, "CVE-2025-12492": {"epss_score": 0.00059, "epss_percentile": 0.18841}, "CVE-2025-12493": {"epss_score": 0.00331, "epss_percentile": 0.55507}, "CVE-2025-12494": {"epss_score": 0.00034, "epss_percentile": 0.09433}, "CVE-2025-12495": {"epss_score": 0.00046, "epss_percentile": 0.14197}, "CVE-2025-12496": {"epss_score": 0.0022, "epss_percentile": 0.44555}, "CVE-2025-12497": {"epss_score": 0.00328, "epss_percentile": 0.55267}, "CVE-2025-12498": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-12499": {"epss_score": 0.00156, "epss_percentile": 0.36995}, "CVE-2025-12501": {"epss_score": 0.0006, "epss_percentile": 0.19004}, "CVE-2025-12502": {"epss_score": 0.00034, "epss_percentile": 0.09677}, "CVE-2025-12503": {"epss_score": 0.00045, "epss_percentile": 0.13998}, "CVE-2025-12504": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-12505": {"epss_score": 0.00028, "epss_percentile": 0.07251}, "CVE-2025-12507": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-12508": {"epss_score": 0.00032, "epss_percentile": 0.08956}, "CVE-2025-12509": {"epss_score": 0.00049, "epss_percentile": 0.15371}, "CVE-2025-12510": {"epss_score": 0.00166, "epss_percentile": 0.38229}, "CVE-2025-12511": {"epss_score": 0.00015, "epss_percentile": 0.02392}, "CVE-2025-12512": {"epss_score": 0.00034, "epss_percentile": 0.09763}, "CVE-2025-12513": {"epss_score": 0.00015, "epss_percentile": 0.02392}, "CVE-2025-12514": {"epss_score": 0.00024, "epss_percentile": 0.06012}, "CVE-2025-12515": {"epss_score": 0.00067, "epss_percentile": 0.21178}, "CVE-2025-12516": {"epss_score": 0.00067, "epss_percentile": 0.21178}, "CVE-2025-12517": {"epss_score": 0.00039, "epss_percentile": 0.11526}, "CVE-2025-12519": {"epss_score": 8e-05, "epss_percentile": 0.00494}, "CVE-2025-12520": {"epss_score": 0.00025, "epss_percentile": 0.06248}, "CVE-2025-12521": {"epss_score": 0.00057, "epss_percentile": 0.18133}, "CVE-2025-12524": {"epss_score": 0.00055, "epss_percentile": 0.1744}, "CVE-2025-12525": {"epss_score": 0.00055, "epss_percentile": 0.17409}, "CVE-2025-12526": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12527": {"epss_score": 0.00034, "epss_percentile": 0.09664}, "CVE-2025-12528": {"epss_score": 0.00176, "epss_percentile": 0.39387}, "CVE-2025-12529": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-12531": {"epss_score": 0.00145, "epss_percentile": 0.35518}, "CVE-2025-12535": {"epss_score": 0.00096, "epss_percentile": 0.27348}, "CVE-2025-12536": {"epss_score": 0.00051, "epss_percentile": 0.16153}, "CVE-2025-12537": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-12538": {"epss_score": 0.00031, "epss_percentile": 0.08582}, "CVE-2025-12539": {"epss_score": 0.00275, "epss_percentile": 0.50631}, "CVE-2025-12540": {"epss_score": 0.00041, "epss_percentile": 0.12338}, "CVE-2025-12543": {"epss_score": 0.00095, "epss_percentile": 0.27192}, "CVE-2025-12545": {"epss_score": 0.00038, "epss_percentile": 0.11281}, "CVE-2025-12546": {"epss_score": 0.00036, "epss_percentile": 0.10437}, "CVE-2025-12547": {"epss_score": 0.00204, "epss_percentile": 0.42603}, "CVE-2025-12549": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-12550": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-12551": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-12552": {"epss_score": 0.00065, "epss_percentile": 0.20659}, "CVE-2025-12553": {"epss_score": 0.00037, "epss_percentile": 0.10935}, "CVE-2025-12554": {"epss_score": 0.00089, "epss_percentile": 0.2587}, "CVE-2025-12556": {"epss_score": 0.00092, "epss_percentile": 0.26497}, "CVE-2025-12558": {"epss_score": 0.00033, "epss_percentile": 0.0935}, "CVE-2025-12559": {"epss_score": 0.00037, "epss_percentile": 0.10836}, "CVE-2025-12560": {"epss_score": 0.0004, "epss_percentile": 0.1204}, "CVE-2025-12562": {"epss_score": 0.00067, "epss_percentile": 0.21134}, "CVE-2025-12563": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12569": {"epss_score": 0.00033, "epss_percentile": 0.09359}, "CVE-2025-12570": {"epss_score": 0.00098, "epss_percentile": 0.27642}, "CVE-2025-12571": {"epss_score": 0.00058, "epss_percentile": 0.18427}, "CVE-2025-12574": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12577": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12578": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-12579": {"epss_score": 0.00096, "epss_percentile": 0.27366}, "CVE-2025-12580": {"epss_score": 0.00129, "epss_percentile": 0.33114}, "CVE-2025-12581": {"epss_score": 0.00089, "epss_percentile": 0.25907}, "CVE-2025-12582": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12583": {"epss_score": 0.00032, "epss_percentile": 0.08961}, "CVE-2025-12584": {"epss_score": 0.00055, "epss_percentile": 0.17409}, "CVE-2025-12585": {"epss_score": 0.00051, "epss_percentile": 0.16153}, "CVE-2025-12586": {"epss_score": 0.00016, "epss_percentile": 0.02744}, "CVE-2025-12587": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2025-12588": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2025-12589": {"epss_score": 0.0003, "epss_percentile": 0.08184}, "CVE-2025-12590": {"epss_score": 0.00026, "epss_percentile": 0.06678}, "CVE-2025-12592": {"epss_score": 0.00059, "epss_percentile": 0.1864}, "CVE-2025-12593": {"epss_score": 0.00052, "epss_percentile": 0.16457}, "CVE-2025-12594": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-12595": {"epss_score": 0.00138, "epss_percentile": 0.34372}, "CVE-2025-12596": {"epss_score": 0.00138, "epss_percentile": 0.34372}, "CVE-2025-12597": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-12598": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-12599": {"epss_score": 0.00065, "epss_percentile": 0.20659}, "CVE-2025-12600": {"epss_score": 0.00067, "epss_percentile": 0.21178}, "CVE-2025-12601": {"epss_score": 0.00063, "epss_percentile": 0.19877}, "CVE-2025-12602": {"epss_score": 0.00067, "epss_percentile": 0.21055}, "CVE-2025-12603": {"epss_score": 0.00067, "epss_percentile": 0.21055}, "CVE-2025-12604": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-12605": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-12606": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-12607": {"epss_score": 0.00036, "epss_percentile": 0.10198}, "CVE-2025-12608": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-12609": {"epss_score": 0.00043, "epss_percentile": 0.13003}, "CVE-2025-12610": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-12611": {"epss_score": 0.00138, "epss_percentile": 0.34372}, "CVE-2025-12612": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-12613": {"epss_score": 0.00067, "epss_percentile": 0.21181}, "CVE-2025-12614": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-12615": {"epss_score": 0.00045, "epss_percentile": 0.13897}, "CVE-2025-12616": {"epss_score": 0.00049, "epss_percentile": 0.15634}, "CVE-2025-12617": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-12618": {"epss_score": 0.00129, "epss_percentile": 0.33122}, "CVE-2025-12619": {"epss_score": 0.00094, "epss_percentile": 0.26792}, "CVE-2025-12620": {"epss_score": 0.00032, "epss_percentile": 0.09037}, "CVE-2025-12621": {"epss_score": 0.00038, "epss_percentile": 0.11183}, "CVE-2025-12622": {"epss_score": 0.00094, "epss_percentile": 0.26792}, "CVE-2025-12623": {"epss_score": 0.00068, "epss_percentile": 0.21338}, "CVE-2025-12626": {"epss_score": 0.00053, "epss_percentile": 0.16691}, "CVE-2025-12628": {"epss_score": 0.00047, "epss_percentile": 0.14885}, "CVE-2025-12629": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-12630": {"epss_score": 0.00037, "epss_percentile": 0.1091}, "CVE-2025-12631": {"epss_score": 0.00031, "epss_percentile": 0.08582}, "CVE-2025-12632": {"epss_score": 0.00031, "epss_percentile": 0.08582}, "CVE-2025-12633": {"epss_score": 0.00096, "epss_percentile": 0.27366}, "CVE-2025-12634": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12635": {"epss_score": 0.00027, "epss_percentile": 0.07109}, "CVE-2025-12636": {"epss_score": 0.00043, "epss_percentile": 0.13272}, "CVE-2025-12637": {"epss_score": 0.00335, "epss_percentile": 0.55846}, "CVE-2025-12638": {"epss_score": 0.0002, "epss_percentile": 0.04539}, "CVE-2025-12639": {"epss_score": 0.00036, "epss_percentile": 0.10607}, "CVE-2025-12640": {"epss_score": 0.00026, "epss_percentile": 0.06661}, "CVE-2025-12642": {"epss_score": 0.00057, "epss_percentile": 0.18082}, "CVE-2025-12643": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12644": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12645": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12646": {"epss_score": 0.00092, "epss_percentile": 0.26514}, "CVE-2025-12648": {"epss_score": 0.00038, "epss_percentile": 0.11183}, "CVE-2025-12649": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12650": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-12651": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12652": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12653": {"epss_score": 0.00049, "epss_percentile": 0.15542}, "CVE-2025-12654": {"epss_score": 9e-05, "epss_percentile": 0.00687}, "CVE-2025-12655": {"epss_score": 0.00063, "epss_percentile": 0.19919}, "CVE-2025-12657": {"epss_score": 0.00065, "epss_percentile": 0.20583}, "CVE-2025-12658": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12660": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12661": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12662": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12663": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12665": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12666": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12667": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12668": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12670": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12671": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12672": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12673": {"epss_score": 0.00199, "epss_percentile": 0.42169}, "CVE-2025-12674": {"epss_score": 0.00215, "epss_percentile": 0.44025}, "CVE-2025-12675": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12676": {"epss_score": 0.0026, "epss_percentile": 0.49192}, "CVE-2025-12677": {"epss_score": 0.00059, "epss_percentile": 0.18695}, "CVE-2025-12681": {"epss_score": 0.00051, "epss_percentile": 0.16153}, "CVE-2025-12682": {"epss_score": 0.00215, "epss_percentile": 0.44025}, "CVE-2025-12683": {"epss_score": 0.00017, "epss_percentile": 0.03168}, "CVE-2025-12684": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-12685": {"epss_score": 0.00029, "epss_percentile": 0.07867}, "CVE-2025-12687": {"epss_score": 0.00021, "epss_percentile": 0.04933}, "CVE-2025-12689": {"epss_score": 0.00071, "epss_percentile": 0.22135}, "CVE-2025-12691": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12695": {"epss_score": 0.00015, "epss_percentile": 0.024}, "CVE-2025-12696": {"epss_score": 0.00031, "epss_percentile": 0.0841}, "CVE-2025-12705": {"epss_score": 0.00137, "epss_percentile": 0.34263}, "CVE-2025-12710": {"epss_score": 0.00042, "epss_percentile": 0.12632}, "CVE-2025-12711": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12712": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12713": {"epss_score": 0.00042, "epss_percentile": 0.12632}, "CVE-2025-12715": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12716": {"epss_score": 0.00064, "epss_percentile": 0.2016}, "CVE-2025-12717": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12720": {"epss_score": 0.00091, "epss_percentile": 0.26243}, "CVE-2025-12721": {"epss_score": 0.00056, "epss_percentile": 0.17673}, "CVE-2025-12725": {"epss_score": 0.00102, "epss_percentile": 0.28725}, "CVE-2025-12726": {"epss_score": 0.00085, "epss_percentile": 0.25131}, "CVE-2025-12727": {"epss_score": 0.00088, "epss_percentile": 0.25661}, "CVE-2025-12728": {"epss_score": 0.00074, "epss_percentile": 0.22685}, "CVE-2025-12729": {"epss_score": 0.00033, "epss_percentile": 0.09311}, "CVE-2025-12732": {"epss_score": 0.00037, "epss_percentile": 0.10791}, "CVE-2025-12733": {"epss_score": 0.00287, "epss_percentile": 0.51844}, "CVE-2025-12734": {"epss_score": 0.00013, "epss_percentile": 0.01438}, "CVE-2025-12735": {"epss_score": 0.0006, "epss_percentile": 0.19161}, "CVE-2025-12739": {"epss_score": 0.00049, "epss_percentile": 0.15543}, "CVE-2025-12740": {"epss_score": 0.00109, "epss_percentile": 0.29911}, "CVE-2025-12741": {"epss_score": 0.00109, "epss_percentile": 0.29911}, "CVE-2025-12742": {"epss_score": 0.00062, "epss_percentile": 0.19619}, "CVE-2025-12743": {"epss_score": 0.00032, "epss_percentile": 0.08747}, "CVE-2025-12744": {"epss_score": 0.00026, "epss_percentile": 0.06479}, "CVE-2025-12745": {"epss_score": 0.00017, "epss_percentile": 0.03193}, "CVE-2025-12746": {"epss_score": 0.00129, "epss_percentile": 0.33114}, "CVE-2025-12747": {"epss_score": 0.00051, "epss_percentile": 0.16153}, "CVE-2025-12748": {"epss_score": 0.00014, "epss_percentile": 0.01786}, "CVE-2025-12750": {"epss_score": 0.00032, "epss_percentile": 0.09037}, "CVE-2025-12751": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12752": {"epss_score": 0.0003, "epss_percentile": 0.08081}, "CVE-2025-12753": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12754": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-12756": {"epss_score": 0.00029, "epss_percentile": 0.07899}, "CVE-2025-12758": {"epss_score": 0.00065, "epss_percentile": 0.20433}, "CVE-2025-12760": {"epss_score": 0.00048, "epss_percentile": 0.14965}, "CVE-2025-12761": {"epss_score": 0.00033, "epss_percentile": 0.09122}, "CVE-2025-12762": {"epss_score": 0.00116, "epss_percentile": 0.31073}, "CVE-2025-12763": {"epss_score": 0.00055, "epss_percentile": 0.17628}, "CVE-2025-12764": {"epss_score": 0.00079, "epss_percentile": 0.23876}, "CVE-2025-12765": {"epss_score": 0.00034, "epss_percentile": 0.0955}, "CVE-2025-12766": {"epss_score": 0.00034, "epss_percentile": 0.09676}, "CVE-2025-12770": {"epss_score": 0.0003, "epss_percentile": 0.08091}, "CVE-2025-12771": {"epss_score": 0.00015, "epss_percentile": 0.02465}, "CVE-2025-12775": {"epss_score": 0.00283, "epss_percentile": 0.51377}, "CVE-2025-12776": {"epss_score": 0.00035, "epss_percentile": 0.10074}, "CVE-2025-12777": {"epss_score": 0.00141, "epss_percentile": 0.34906}, "CVE-2025-12778": {"epss_score": 0.00067, "epss_percentile": 0.21037}, "CVE-2025-12779": {"epss_score": 0.00023, "epss_percentile": 0.05409}, "CVE-2025-12782": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12783": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-12784": {"epss_score": 0.00055, "epss_percentile": 0.17588}, "CVE-2025-12785": {"epss_score": 0.00055, "epss_percentile": 0.17588}, "CVE-2025-12787": {"epss_score": 0.00074, "epss_percentile": 0.22771}, "CVE-2025-12788": {"epss_score": 0.00125, "epss_percentile": 0.32556}, "CVE-2025-12789": {"epss_score": 0.00031, "epss_percentile": 0.08712}, "CVE-2025-12790": {"epss_score": 0.00062, "epss_percentile": 0.19633}, "CVE-2025-12792": {"epss_score": 0.0001, "epss_percentile": 0.00916}, "CVE-2025-12793": {"epss_score": 0.00015, "epss_percentile": 0.02288}, "CVE-2025-12800": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-12804": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12807": {"epss_score": 0.00052, "epss_percentile": 0.16586}, "CVE-2025-12808": {"epss_score": 0.00038, "epss_percentile": 0.11344}, "CVE-2025-12809": {"epss_score": 0.00061, "epss_percentile": 0.19498}, "CVE-2025-12813": {"epss_score": 0.00365, "epss_percentile": 0.57963}, "CVE-2025-12814": {"epss_score": 0.00038, "epss_percentile": 0.11183}, "CVE-2025-12815": {"epss_score": 0.00044, "epss_percentile": 0.13421}, "CVE-2025-12816": {"epss_score": 0.00057, "epss_percentile": 0.18058}, "CVE-2025-12817": {"epss_score": 0.00046, "epss_percentile": 0.14099}, "CVE-2025-12818": {"epss_score": 0.00057, "epss_percentile": 0.18164}, "CVE-2025-12819": {"epss_score": 0.00162, "epss_percentile": 0.37693}, "CVE-2025-12820": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-12822": {"epss_score": 0.00039, "epss_percentile": 0.11431}, "CVE-2025-12823": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-12824": {"epss_score": 0.00531, "epss_percentile": 0.66644}, "CVE-2025-12826": {"epss_score": 0.00054, "epss_percentile": 0.17216}, "CVE-2025-12827": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-12829": {"epss_score": 0.00016, "epss_percentile": 0.02874}, "CVE-2025-12830": {"epss_score": 0.00036, "epss_percentile": 0.10508}, "CVE-2025-12832": {"epss_score": 0.00039, "epss_percentile": 0.1163}, "CVE-2025-12833": {"epss_score": 0.00034, "epss_percentile": 0.09664}, "CVE-2025-12834": {"epss_score": 0.0008, "epss_percentile": 0.24172}, "CVE-2025-12835": {"epss_score": 0.00055, "epss_percentile": 0.17601}, "CVE-2025-12837": {"epss_score": 0.0003, "epss_percentile": 0.08021}, "CVE-2025-12838": {"epss_score": 0.00017, "epss_percentile": 0.03276}, "CVE-2025-12839": {"epss_score": 0.00046, "epss_percentile": 0.14197}, "CVE-2025-12840": {"epss_score": 0.00046, "epss_percentile": 0.14197}, "CVE-2025-12841": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-12842": {"epss_score": 0.00068, "epss_percentile": 0.21362}, "CVE-2025-12843": {"epss_score": 0.00021, "epss_percentile": 0.04793}, "CVE-2025-12844": {"epss_score": 0.00069, "epss_percentile": 0.21469}, "CVE-2025-12846": {"epss_score": 0.00127, "epss_percentile": 0.32934}, "CVE-2025-12847": {"epss_score": 0.00041, "epss_percentile": 0.12214}, "CVE-2025-12848": {"epss_score": 0.0006, "epss_percentile": 0.18978}, "CVE-2025-12849": {"epss_score": 0.00141, "epss_percentile": 0.34906}, "CVE-2025-12850": {"epss_score": 0.00092, "epss_percentile": 0.26514}, "CVE-2025-12851": {"epss_score": 0.00328, "epss_percentile": 0.55267}, "CVE-2025-12852": {"epss_score": 0.0002, "epss_percentile": 0.04654}, "CVE-2025-12853": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-12854": {"epss_score": 0.00065, "epss_percentile": 0.20459}, "CVE-2025-12855": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-12856": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-12857": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-12859": {"epss_score": 0.00032, "epss_percentile": 0.09112}, "CVE-2025-12860": {"epss_score": 0.00032, "epss_percentile": 0.09112}, "CVE-2025-12861": {"epss_score": 0.00032, "epss_percentile": 0.09112}, "CVE-2025-12862": {"epss_score": 0.00044, "epss_percentile": 0.13431}, "CVE-2025-12864": {"epss_score": 0.00103, "epss_percentile": 0.29082}, "CVE-2025-12865": {"epss_score": 0.00103, "epss_percentile": 0.29082}, "CVE-2025-12866": {"epss_score": 0.00112, "epss_percentile": 0.30501}, "CVE-2025-12867": {"epss_score": 0.0026, "epss_percentile": 0.49216}, "CVE-2025-12868": {"epss_score": 0.00255, "epss_percentile": 0.48687}, "CVE-2025-12869": {"epss_score": 0.00043, "epss_percentile": 0.12968}, "CVE-2025-12870": {"epss_score": 0.00233, "epss_percentile": 0.46031}, "CVE-2025-12871": {"epss_score": 0.00371, "epss_percentile": 0.58361}, "CVE-2025-12872": {"epss_score": 0.00046, "epss_percentile": 0.14287}, "CVE-2025-12873": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-12874": {"epss_score": 0.00099, "epss_percentile": 0.28335}, "CVE-2025-12875": {"epss_score": 0.00014, "epss_percentile": 0.02091}, "CVE-2025-12876": {"epss_score": 0.00096, "epss_percentile": 0.27366}, "CVE-2025-12877": {"epss_score": 0.00086, "epss_percentile": 0.25278}, "CVE-2025-12878": {"epss_score": 0.00046, "epss_percentile": 0.14471}, "CVE-2025-12879": {"epss_score": 0.0002, "epss_percentile": 0.04615}, "CVE-2025-12880": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-12881": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-12883": {"epss_score": 0.00065, "epss_percentile": 0.20458}, "CVE-2025-12885": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-12887": {"epss_score": 0.00046, "epss_percentile": 0.14146}, "CVE-2025-12888": {"epss_score": 0.00039, "epss_percentile": 0.11777}, "CVE-2025-12889": {"epss_score": 0.00033, "epss_percentile": 0.0925}, "CVE-2025-12890": {"epss_score": 0.00037, "epss_percentile": 0.10833}, "CVE-2025-12891": {"epss_score": 0.00067, "epss_percentile": 0.21037}, "CVE-2025-12892": {"epss_score": 0.00096, "epss_percentile": 0.27366}, "CVE-2025-12893": {"epss_score": 0.00025, "epss_percentile": 0.06367}, "CVE-2025-12894": {"epss_score": 0.00055, "epss_percentile": 0.17409}, "CVE-2025-12896": {"epss_score": 0.00015, "epss_percentile": 0.0239}, "CVE-2025-12898": {"epss_score": 0.00061, "epss_percentile": 0.19498}, "CVE-2025-12900": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-12901": {"epss_score": 0.00015, "epss_percentile": 0.0259}, "CVE-2025-12902": {"epss_score": 0.00015, "epss_percentile": 0.02477}, "CVE-2025-12903": {"epss_score": 0.00358, "epss_percentile": 0.57514}, "CVE-2025-12904": {"epss_score": 0.00141, "epss_percentile": 0.34867}, "CVE-2025-12905": {"epss_score": 0.00013, "epss_percentile": 0.0149}, "CVE-2025-12906": {"epss_score": 0.00068, "epss_percentile": 0.21254}, "CVE-2025-12907": {"epss_score": 0.00172, "epss_percentile": 0.38974}, "CVE-2025-12908": {"epss_score": 0.00113, "epss_percentile": 0.30669}, "CVE-2025-12909": {"epss_score": 0.00054, "epss_percentile": 0.17312}, "CVE-2025-12910": {"epss_score": 8e-05, "epss_percentile": 0.00527}, "CVE-2025-12911": {"epss_score": 0.00021, "epss_percentile": 0.04798}, "CVE-2025-12913": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-12914": {"epss_score": 0.00039, "epss_percentile": 0.11721}, "CVE-2025-12915": {"epss_score": 0.00025, "epss_percentile": 0.06373}, "CVE-2025-12916": {"epss_score": 0.00476, "epss_percentile": 0.64252}, "CVE-2025-12917": {"epss_score": 0.00125, "epss_percentile": 0.32615}, "CVE-2025-12918": {"epss_score": 0.00033, "epss_percentile": 0.09205}, "CVE-2025-12919": {"epss_score": 0.00053, "epss_percentile": 0.16977}, "CVE-2025-12920": {"epss_score": 0.00051, "epss_percentile": 0.16048}, "CVE-2025-12921": {"epss_score": 0.00035, "epss_percentile": 0.09901}, "CVE-2025-12922": {"epss_score": 0.001, "epss_percentile": 0.28518}, "CVE-2025-12923": {"epss_score": 0.0018, "epss_percentile": 0.39904}, "CVE-2025-12924": {"epss_score": 0.00032, "epss_percentile": 0.09005}, "CVE-2025-12925": {"epss_score": 0.00054, "epss_percentile": 0.17291}, "CVE-2025-12926": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-12927": {"epss_score": 0.00032, "epss_percentile": 0.09112}, "CVE-2025-12928": {"epss_score": 0.00053, "epss_percentile": 0.16827}, "CVE-2025-12929": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-12930": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-12931": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-12932": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-12933": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-12934": {"epss_score": 0.00031, "epss_percentile": 0.08612}, "CVE-2025-12935": {"epss_score": 0.00039, "epss_percentile": 0.11637}, "CVE-2025-12937": {"epss_score": 0.00092, "epss_percentile": 0.26443}, "CVE-2025-12938": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-12939": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-12940": {"epss_score": 0.0003, "epss_percentile": 0.08234}, "CVE-2025-12941": {"epss_score": 0.00031, "epss_percentile": 0.08618}, "CVE-2025-12942": {"epss_score": 0.00048, "epss_percentile": 0.14937}, "CVE-2025-12943": {"epss_score": 0.00017, "epss_percentile": 0.03165}, "CVE-2025-12944": {"epss_score": 0.00045, "epss_percentile": 0.13829}, "CVE-2025-12945": {"epss_score": 0.00477, "epss_percentile": 0.64332}, "CVE-2025-12946": {"epss_score": 0.00112, "epss_percentile": 0.30495}, "CVE-2025-12952": {"epss_score": 0.00053, "epss_percentile": 0.16686}, "CVE-2025-12953": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-12954": {"epss_score": 0.00033, "epss_percentile": 0.09339}, "CVE-2025-12955": {"epss_score": 0.00085, "epss_percentile": 0.25224}, "CVE-2025-12956": {"epss_score": 0.00033, "epss_percentile": 0.09211}, "CVE-2025-12958": {"epss_score": 0.00024, "epss_percentile": 0.05998}, "CVE-2025-12960": {"epss_score": 0.01125, "epss_percentile": 0.77804}, "CVE-2025-12961": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-12962": {"epss_score": 0.00032, "epss_percentile": 0.08961}, "CVE-2025-12963": {"epss_score": 0.00097, "epss_percentile": 0.27553}, "CVE-2025-12964": {"epss_score": 0.00039, "epss_percentile": 0.11637}, "CVE-2025-12965": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-12966": {"epss_score": 0.00305, "epss_percentile": 0.53322}, "CVE-2025-12967": {"epss_score": 0.00112, "epss_percentile": 0.3046}, "CVE-2025-12968": {"epss_score": 0.00264, "epss_percentile": 0.49736}, "CVE-2025-12969": {"epss_score": 0.00106, "epss_percentile": 0.29419}, "CVE-2025-12970": {"epss_score": 0.00134, "epss_percentile": 0.3387}, "CVE-2025-12971": {"epss_score": 0.00034, "epss_percentile": 0.09664}, "CVE-2025-12972": {"epss_score": 0.00093, "epss_percentile": 0.26758}, "CVE-2025-12973": {"epss_score": 0.00109, "epss_percentile": 0.30035}, "CVE-2025-12974": {"epss_score": 0.00155, "epss_percentile": 0.36858}, "CVE-2025-12976": {"epss_score": 0.0004, "epss_percentile": 0.1216}, "CVE-2025-12977": {"epss_score": 0.00078, "epss_percentile": 0.23772}, "CVE-2025-12978": {"epss_score": 0.00131, "epss_percentile": 0.33504}, "CVE-2025-12979": {"epss_score": 0.00067, "epss_percentile": 0.21037}, "CVE-2025-12980": {"epss_score": 0.00101, "epss_percentile": 0.28575}, "CVE-2025-12983": {"epss_score": 0.00022, "epss_percentile": 0.05237}, "CVE-2025-12986": {"epss_score": 0.00031, "epss_percentile": 0.08334}, "CVE-2025-12994": {"epss_score": 0.00048, "epss_percentile": 0.15286}, "CVE-2025-12995": {"epss_score": 0.00121, "epss_percentile": 0.31893}, "CVE-2025-12996": {"epss_score": 0.00016, "epss_percentile": 0.02943}, "CVE-2025-12997": {"epss_score": 0.00031, "epss_percentile": 0.08649}, "CVE-2025-12998": {"epss_score": 0.00069, "epss_percentile": 0.21548}, "CVE-2025-13000": {"epss_score": 0.00042, "epss_percentile": 0.12565}, "CVE-2025-13001": {"epss_score": 0.0003, "epss_percentile": 0.0829}, "CVE-2025-13003": {"epss_score": 0.00038, "epss_percentile": 0.11198}, "CVE-2025-13006": {"epss_score": 0.00051, "epss_percentile": 0.16153}, "CVE-2025-13007": {"epss_score": 0.00163, "epss_percentile": 0.37815}, "CVE-2025-13008": {"epss_score": 0.00047, "epss_percentile": 0.14624}, "CVE-2025-13012": {"epss_score": 0.00052, "epss_percentile": 0.16568}, "CVE-2025-13013": {"epss_score": 0.0006, "epss_percentile": 0.19213}, "CVE-2025-13014": {"epss_score": 0.00058, "epss_percentile": 0.18313}, "CVE-2025-13015": {"epss_score": 0.00064, "epss_percentile": 0.20199}, "CVE-2025-13016": {"epss_score": 0.00049, "epss_percentile": 0.15354}, "CVE-2025-13017": {"epss_score": 0.00038, "epss_percentile": 0.1133}, "CVE-2025-13018": {"epss_score": 0.00038, "epss_percentile": 0.1133}, "CVE-2025-13019": {"epss_score": 0.00038, "epss_percentile": 0.1133}, "CVE-2025-13020": {"epss_score": 0.00049, "epss_percentile": 0.15354}, "CVE-2025-13021": {"epss_score": 0.00061, "epss_percentile": 0.19419}, "CVE-2025-13022": {"epss_score": 0.00061, "epss_percentile": 0.19419}, "CVE-2025-13023": {"epss_score": 0.00061, "epss_percentile": 0.19419}, "CVE-2025-13024": {"epss_score": 0.00061, "epss_percentile": 0.19419}, "CVE-2025-13025": {"epss_score": 0.0004, "epss_percentile": 0.12009}, "CVE-2025-13026": {"epss_score": 0.00061, "epss_percentile": 0.19419}, "CVE-2025-13027": {"epss_score": 0.00061, "epss_percentile": 0.19419}, "CVE-2025-13029": {"epss_score": 0.00067, "epss_percentile": 0.20973}, "CVE-2025-13031": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-13032": {"epss_score": 0.00036, "epss_percentile": 0.10555}, "CVE-2025-13033": {"epss_score": 0.00046, "epss_percentile": 0.14183}, "CVE-2025-13034": {"epss_score": 0.0001, "epss_percentile": 0.0081}, "CVE-2025-13035": {"epss_score": 0.00049, "epss_percentile": 0.15373}, "CVE-2025-13042": {"epss_score": 0.00088, "epss_percentile": 0.25661}, "CVE-2025-13051": {"epss_score": 0.00019, "epss_percentile": 0.04271}, "CVE-2025-13052": {"epss_score": 0.00031, "epss_percentile": 0.08411}, "CVE-2025-13053": {"epss_score": 0.00013, "epss_percentile": 0.01701}, "CVE-2025-13054": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-13056": {"epss_score": 0.00015, "epss_percentile": 0.02392}, "CVE-2025-13057": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13058": {"epss_score": 0.00068, "epss_percentile": 0.21357}, "CVE-2025-13059": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13060": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13061": {"epss_score": 0.00042, "epss_percentile": 0.12481}, "CVE-2025-13063": {"epss_score": 0.00054, "epss_percentile": 0.17291}, "CVE-2025-13065": {"epss_score": 0.00127, "epss_percentile": 0.32934}, "CVE-2025-13066": {"epss_score": 0.00127, "epss_percentile": 0.32934}, "CVE-2025-13068": {"epss_score": 0.00141, "epss_percentile": 0.34867}, "CVE-2025-13069": {"epss_score": 0.00127, "epss_percentile": 0.32934}, "CVE-2025-13070": {"epss_score": 0.00053, "epss_percentile": 0.1683}, "CVE-2025-13071": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-13072": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-13073": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-13075": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-13076": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-13077": {"epss_score": 0.00093, "epss_percentile": 0.26734}, "CVE-2025-13080": {"epss_score": 0.00075, "epss_percentile": 0.22915}, "CVE-2025-13081": {"epss_score": 0.00156, "epss_percentile": 0.36885}, "CVE-2025-13082": {"epss_score": 0.00045, "epss_percentile": 0.13738}, "CVE-2025-13083": {"epss_score": 0.00053, "epss_percentile": 0.16728}, "CVE-2025-13084": {"epss_score": 0.00046, "epss_percentile": 0.14387}, "CVE-2025-13085": {"epss_score": 0.00036, "epss_percentile": 0.10607}, "CVE-2025-13086": {"epss_score": 0.00055, "epss_percentile": 0.17553}, "CVE-2025-13087": {"epss_score": 0.00281, "epss_percentile": 0.51145}, "CVE-2025-13088": {"epss_score": 0.00055, "epss_percentile": 0.17403}, "CVE-2025-13089": {"epss_score": 0.00089, "epss_percentile": 0.25936}, "CVE-2025-13090": {"epss_score": 0.00032, "epss_percentile": 0.09037}, "CVE-2025-13092": {"epss_score": 0.00061, "epss_percentile": 0.19498}, "CVE-2025-13093": {"epss_score": 0.0005, "epss_percentile": 0.157}, "CVE-2025-13094": {"epss_score": 0.00264, "epss_percentile": 0.49736}, "CVE-2025-13097": {"epss_score": 0.00043, "epss_percentile": 0.1318}, "CVE-2025-13102": {"epss_score": 0.00059, "epss_percentile": 0.1865}, "CVE-2025-13107": {"epss_score": 0.00083, "epss_percentile": 0.24733}, "CVE-2025-13109": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-13110": {"epss_score": 0.00028, "epss_percentile": 0.07326}, "CVE-2025-13114": {"epss_score": 0.00031, "epss_percentile": 0.08706}, "CVE-2025-13115": {"epss_score": 0.00043, "epss_percentile": 0.13073}, "CVE-2025-13116": {"epss_score": 0.0004, "epss_percentile": 0.12153}, "CVE-2025-13117": {"epss_score": 0.0004, "epss_percentile": 0.12153}, "CVE-2025-13118": {"epss_score": 0.00041, "epss_percentile": 0.12319}, "CVE-2025-13119": {"epss_score": 0.00046, "epss_percentile": 0.14357}, "CVE-2025-13120": {"epss_score": 0.00014, "epss_percentile": 0.02009}, "CVE-2025-13121": {"epss_score": 0.00043, "epss_percentile": 0.13084}, "CVE-2025-13122": {"epss_score": 0.00038, "epss_percentile": 0.11314}, "CVE-2025-13123": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13124": {"epss_score": 0.00038, "epss_percentile": 0.11198}, "CVE-2025-13125": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-13126": {"epss_score": 0.00098, "epss_percentile": 0.27783}, "CVE-2025-13127": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-13129": {"epss_score": 0.00037, "epss_percentile": 0.10737}, "CVE-2025-13130": {"epss_score": 0.00014, "epss_percentile": 0.0176}, "CVE-2025-13131": {"epss_score": 0.00014, "epss_percentile": 0.0176}, "CVE-2025-13132": {"epss_score": 0.00031, "epss_percentile": 0.08509}, "CVE-2025-13133": {"epss_score": 0.00089, "epss_percentile": 0.25795}, "CVE-2025-13134": {"epss_score": 0.00015, "epss_percentile": 0.02155}, "CVE-2025-13135": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-13136": {"epss_score": 0.00039, "epss_percentile": 0.11431}, "CVE-2025-13137": {"epss_score": 0.00116, "epss_percentile": 0.31145}, "CVE-2025-13138": {"epss_score": 0.00102, "epss_percentile": 0.28747}, "CVE-2025-13140": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2025-13141": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-13142": {"epss_score": 0.00015, "epss_percentile": 0.02485}, "CVE-2025-13143": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2025-13144": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2025-13145": {"epss_score": 0.00137, "epss_percentile": 0.34218}, "CVE-2025-13147": {"epss_score": 8e-05, "epss_percentile": 0.00514}, "CVE-2025-13148": {"epss_score": 0.0003, "epss_percentile": 0.08159}, "CVE-2025-13149": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-13151": {"epss_score": 0.0004, "epss_percentile": 0.12002}, "CVE-2025-13152": {"epss_score": 0.00015, "epss_percentile": 0.02465}, "CVE-2025-13153": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-13155": {"epss_score": 0.00012, "epss_percentile": 0.01232}, "CVE-2025-13156": {"epss_score": 0.00305, "epss_percentile": 0.53322}, "CVE-2025-13157": {"epss_score": 0.00047, "epss_percentile": 0.14668}, "CVE-2025-13158": {"epss_score": 0.00244, "epss_percentile": 0.47614}, "CVE-2025-13159": {"epss_score": 0.00053, "epss_percentile": 0.16934}, "CVE-2025-13160": {"epss_score": 0.00042, "epss_percentile": 0.12568}, "CVE-2025-13161": {"epss_score": 0.00096, "epss_percentile": 0.27332}, "CVE-2025-13163": {"epss_score": 0.00051, "epss_percentile": 0.16063}, "CVE-2025-13164": {"epss_score": 0.00051, "epss_percentile": 0.16063}, "CVE-2025-13165": {"epss_score": 0.00117, "epss_percentile": 0.31337}, "CVE-2025-13168": {"epss_score": 0.00043, "epss_percentile": 0.13031}, "CVE-2025-13169": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13170": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13171": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13172": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13174": {"epss_score": 0.00043, "epss_percentile": 0.13329}, "CVE-2025-13177": {"epss_score": 0.00041, "epss_percentile": 0.12287}, "CVE-2025-13178": {"epss_score": 0.00031, "epss_percentile": 0.08615}, "CVE-2025-13179": {"epss_score": 0.00046, "epss_percentile": 0.14357}, "CVE-2025-13180": {"epss_score": 0.00031, "epss_percentile": 0.08615}, "CVE-2025-13181": {"epss_score": 0.0003, "epss_percentile": 0.08196}, "CVE-2025-13182": {"epss_score": 0.00041, "epss_percentile": 0.12261}, "CVE-2025-13183": {"epss_score": 0.00033, "epss_percentile": 0.09211}, "CVE-2025-13184": {"epss_score": 0.00394, "epss_percentile": 0.59795}, "CVE-2025-13185": {"epss_score": 0.00052, "epss_percentile": 0.16457}, "CVE-2025-13186": {"epss_score": 0.0003, "epss_percentile": 0.08242}, "CVE-2025-13187": {"epss_score": 0.00045, "epss_percentile": 0.14067}, "CVE-2025-13188": {"epss_score": 0.00368, "epss_percentile": 0.58172}, "CVE-2025-13189": {"epss_score": 0.00079, "epss_percentile": 0.23972}, "CVE-2025-13190": {"epss_score": 0.00053, "epss_percentile": 0.16815}, "CVE-2025-13191": {"epss_score": 0.00079, "epss_percentile": 0.23972}, "CVE-2025-13193": {"epss_score": 0.00015, "epss_percentile": 0.02213}, "CVE-2025-13196": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-13198": {"epss_score": 0.00047, "epss_percentile": 0.14794}, "CVE-2025-13199": {"epss_score": 0.00039, "epss_percentile": 0.11526}, "CVE-2025-13200": {"epss_score": 0.00048, "epss_percentile": 0.1495}, "CVE-2025-13201": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13202": {"epss_score": 0.00032, "epss_percentile": 0.08782}, "CVE-2025-13203": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13204": {"epss_score": 0.00075, "epss_percentile": 0.23007}, "CVE-2025-13206": {"epss_score": 0.00152, "epss_percentile": 0.36377}, "CVE-2025-13208": {"epss_score": 0.00043, "epss_percentile": 0.13031}, "CVE-2025-13209": {"epss_score": 0.00064, "epss_percentile": 0.20184}, "CVE-2025-13210": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-13211": {"epss_score": 0.00047, "epss_percentile": 0.1449}, "CVE-2025-13214": {"epss_score": 0.00107, "epss_percentile": 0.29607}, "CVE-2025-13215": {"epss_score": 0.00038, "epss_percentile": 0.11303}, "CVE-2025-13217": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13220": {"epss_score": 0.00047, "epss_percentile": 0.149}, "CVE-2025-13221": {"epss_score": 0.00042, "epss_percentile": 0.1293}, "CVE-2025-13223": {"epss_score": 0.01156, "epss_percentile": 0.78081}, "CVE-2025-13224": {"epss_score": 0.00089, "epss_percentile": 0.25903}, "CVE-2025-13225": {"epss_score": 0.00018, "epss_percentile": 0.03602}, "CVE-2025-13226": {"epss_score": 0.00089, "epss_percentile": 0.25903}, "CVE-2025-13227": {"epss_score": 0.00089, "epss_percentile": 0.25903}, "CVE-2025-13228": {"epss_score": 0.00089, "epss_percentile": 0.25903}, "CVE-2025-13229": {"epss_score": 0.00089, "epss_percentile": 0.25903}, "CVE-2025-13230": {"epss_score": 0.00089, "epss_percentile": 0.25903}, "CVE-2025-13231": {"epss_score": 0.00032, "epss_percentile": 0.09114}, "CVE-2025-13232": {"epss_score": 0.0004, "epss_percentile": 0.12057}, "CVE-2025-13233": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13234": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13235": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13236": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13237": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13238": {"epss_score": 0.00042, "epss_percentile": 0.12481}, "CVE-2025-13239": {"epss_score": 0.00065, "epss_percentile": 0.20451}, "CVE-2025-13240": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13241": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13242": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13243": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13244": {"epss_score": 0.00041, "epss_percentile": 0.12448}, "CVE-2025-13245": {"epss_score": 0.00032, "epss_percentile": 0.08782}, "CVE-2025-13246": {"epss_score": 0.00119, "epss_percentile": 0.31587}, "CVE-2025-13247": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13248": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13249": {"epss_score": 0.00043, "epss_percentile": 0.13329}, "CVE-2025-13250": {"epss_score": 0.00049, "epss_percentile": 0.15363}, "CVE-2025-13251": {"epss_score": 0.00038, "epss_percentile": 0.11212}, "CVE-2025-13252": {"epss_score": 0.00058, "epss_percentile": 0.18468}, "CVE-2025-13253": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13254": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13255": {"epss_score": 0.00043, "epss_percentile": 0.12999}, "CVE-2025-13256": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13257": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13258": {"epss_score": 0.00096, "epss_percentile": 0.27384}, "CVE-2025-13259": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13260": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13261": {"epss_score": 0.00256, "epss_percentile": 0.48799}, "CVE-2025-13262": {"epss_score": 0.00324, "epss_percentile": 0.54936}, "CVE-2025-13263": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13264": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13265": {"epss_score": 0.00065, "epss_percentile": 0.20502}, "CVE-2025-13266": {"epss_score": 0.00058, "epss_percentile": 0.18536}, "CVE-2025-13267": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13268": {"epss_score": 0.00053, "epss_percentile": 0.16713}, "CVE-2025-13269": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13270": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13271": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13272": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13273": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13274": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13275": {"epss_score": 0.00047, "epss_percentile": 0.14794}, "CVE-2025-13276": {"epss_score": 0.0004, "epss_percentile": 0.12054}, "CVE-2025-13277": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13278": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13279": {"epss_score": 0.00047, "epss_percentile": 0.14494}, "CVE-2025-13280": {"epss_score": 0.00036, "epss_percentile": 0.10198}, "CVE-2025-13281": {"epss_score": 0.00011, "epss_percentile": 0.01045}, "CVE-2025-13282": {"epss_score": 0.00461, "epss_percentile": 0.6356}, "CVE-2025-13283": {"epss_score": 0.00121, "epss_percentile": 0.31957}, "CVE-2025-13284": {"epss_score": 0.00605, "epss_percentile": 0.68995}, "CVE-2025-13285": {"epss_score": 0.00053, "epss_percentile": 0.16827}, "CVE-2025-13286": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13287": {"epss_score": 0.00047, "epss_percentile": 0.14494}, "CVE-2025-13288": {"epss_score": 0.00088, "epss_percentile": 0.25691}, "CVE-2025-13289": {"epss_score": 0.00031, "epss_percentile": 0.08544}, "CVE-2025-13290": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13291": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13292": {"epss_score": 0.0005, "epss_percentile": 0.15677}, "CVE-2025-13295": {"epss_score": 0.00044, "epss_percentile": 0.13552}, "CVE-2025-13296": {"epss_score": 0.00016, "epss_percentile": 0.02919}, "CVE-2025-13297": {"epss_score": 0.00043, "epss_percentile": 0.13359}, "CVE-2025-13298": {"epss_score": 0.00054, "epss_percentile": 0.17275}, "CVE-2025-13299": {"epss_score": 0.00043, "epss_percentile": 0.13359}, "CVE-2025-13300": {"epss_score": 0.00043, "epss_percentile": 0.13359}, "CVE-2025-13301": {"epss_score": 0.00043, "epss_percentile": 0.13359}, "CVE-2025-13302": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-13303": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13304": {"epss_score": 0.00205, "epss_percentile": 0.42684}, "CVE-2025-13305": {"epss_score": 0.00205, "epss_percentile": 0.42684}, "CVE-2025-13306": {"epss_score": 0.009, "epss_percentile": 0.75166}, "CVE-2025-13307": {"epss_score": 0.00305, "epss_percentile": 0.53323}, "CVE-2025-13308": {"epss_score": 0.00135, "epss_percentile": 0.33985}, "CVE-2025-13309": {"epss_score": 0.00034, "epss_percentile": 0.09664}, "CVE-2025-13311": {"epss_score": 0.00038, "epss_percentile": 0.11134}, "CVE-2025-13312": {"epss_score": 0.00064, "epss_percentile": 0.20207}, "CVE-2025-13313": {"epss_score": 0.00275, "epss_percentile": 0.5063}, "CVE-2025-13314": {"epss_score": 0.0005, "epss_percentile": 0.15926}, "CVE-2025-13315": {"epss_score": 0.82476, "epss_percentile": 0.99196}, "CVE-2025-13316": {"epss_score": 0.71372, "epss_percentile": 0.98664}, "CVE-2025-13317": {"epss_score": 0.00097, "epss_percentile": 0.27619}, "CVE-2025-13318": {"epss_score": 0.00118, "epss_percentile": 0.31511}, "CVE-2025-13319": {"epss_score": 0.0009, "epss_percentile": 0.26162}, "CVE-2025-13320": {"epss_score": 0.00215, "epss_percentile": 0.44045}, "CVE-2025-13321": {"epss_score": 0.00013, "epss_percentile": 0.01615}, "CVE-2025-13322": {"epss_score": 0.00287, "epss_percentile": 0.51818}, "CVE-2025-13323": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13324": {"epss_score": 0.00039, "epss_percentile": 0.11559}, "CVE-2025-13325": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13326": {"epss_score": 0.00013, "epss_percentile": 0.01499}, "CVE-2025-13329": {"epss_score": 0.00197, "epss_percentile": 0.41863}, "CVE-2025-13334": {"epss_score": 0.00049, "epss_percentile": 0.15357}, "CVE-2025-13339": {"epss_score": 0.00057, "epss_percentile": 0.18212}, "CVE-2025-13342": {"epss_score": 0.00077, "epss_percentile": 0.23379}, "CVE-2025-13343": {"epss_score": 0.00032, "epss_percentile": 0.08782}, "CVE-2025-13344": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13345": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13346": {"epss_score": 0.00031, "epss_percentile": 0.08544}, "CVE-2025-13347": {"epss_score": 0.00031, "epss_percentile": 0.08544}, "CVE-2025-13349": {"epss_score": 0.00037, "epss_percentile": 0.10778}, "CVE-2025-13352": {"epss_score": 0.00047, "epss_percentile": 0.14481}, "CVE-2025-13353": {"epss_score": 0.00026, "epss_percentile": 0.06418}, "CVE-2025-13354": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-13355": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-13357": {"epss_score": 0.00062, "epss_percentile": 0.19553}, "CVE-2025-13358": {"epss_score": 0.00043, "epss_percentile": 0.13179}, "CVE-2025-13359": {"epss_score": 0.00033, "epss_percentile": 0.09346}, "CVE-2025-13360": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2025-13361": {"epss_score": 0.00013, "epss_percentile": 0.01663}, "CVE-2025-13362": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2025-13363": {"epss_score": 0.00013, "epss_percentile": 0.01441}, "CVE-2025-13365": {"epss_score": 0.00016, "epss_percentile": 0.02733}, "CVE-2025-13366": {"epss_score": 0.00013, "epss_percentile": 0.01441}, "CVE-2025-13367": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13369": {"epss_score": 0.00093, "epss_percentile": 0.2676}, "CVE-2025-13370": {"epss_score": 0.00034, "epss_percentile": 0.09533}, "CVE-2025-13371": {"epss_score": 0.00176, "epss_percentile": 0.39399}, "CVE-2025-13372": {"epss_score": 8e-05, "epss_percentile": 0.00583}, "CVE-2025-13373": {"epss_score": 0.00044, "epss_percentile": 0.13533}, "CVE-2025-13376": {"epss_score": 0.00294, "epss_percentile": 0.52404}, "CVE-2025-13377": {"epss_score": 0.00052, "epss_percentile": 0.16565}, "CVE-2025-13378": {"epss_score": 0.00105, "epss_percentile": 0.29291}, "CVE-2025-13380": {"epss_score": 0.00017, "epss_percentile": 0.03124}, "CVE-2025-13381": {"epss_score": 0.00108, "epss_percentile": 0.29881}, "CVE-2025-13382": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-13383": {"epss_score": 0.00137, "epss_percentile": 0.34248}, "CVE-2025-13384": {"epss_score": 0.00152, "epss_percentile": 0.36487}, "CVE-2025-13385": {"epss_score": 0.00032, "epss_percentile": 0.09037}, "CVE-2025-13386": {"epss_score": 0.00086, "epss_percentile": 0.25278}, "CVE-2025-13387": {"epss_score": 0.00141, "epss_percentile": 0.34867}, "CVE-2025-13389": {"epss_score": 0.00052, "epss_percentile": 0.16598}, "CVE-2025-13390": {"epss_score": 0.01368, "epss_percentile": 0.79787}, "CVE-2025-13395": {"epss_score": 0.00043, "epss_percentile": 0.13084}, "CVE-2025-13396": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13397": {"epss_score": 0.00014, "epss_percentile": 0.02023}, "CVE-2025-13400": {"epss_score": 0.00138, "epss_percentile": 0.34372}, "CVE-2025-13401": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-13403": {"epss_score": 0.00037, "epss_percentile": 0.10783}, "CVE-2025-13404": {"epss_score": 0.0004, "epss_percentile": 0.12016}, "CVE-2025-13405": {"epss_score": 0.00038, "epss_percentile": 0.11183}, "CVE-2025-13407": {"epss_score": 0.00086, "epss_percentile": 0.25419}, "CVE-2025-13408": {"epss_score": 0.00013, "epss_percentile": 0.01663}, "CVE-2025-13409": {"epss_score": 0.00024, "epss_percentile": 0.05679}, "CVE-2025-13410": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13411": {"epss_score": 0.00064, "epss_percentile": 0.20156}, "CVE-2025-13412": {"epss_score": 0.00038, "epss_percentile": 0.11218}, "CVE-2025-13414": {"epss_score": 0.00052, "epss_percentile": 0.16598}, "CVE-2025-13415": {"epss_score": 0.00031, "epss_percentile": 0.08615}, "CVE-2025-13417": {"epss_score": 0.00046, "epss_percentile": 0.14394}, "CVE-2025-13418": {"epss_score": 0.00029, "epss_percentile": 0.07681}, "CVE-2025-13419": {"epss_score": 0.00038, "epss_percentile": 0.11166}, "CVE-2025-13420": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13421": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13422": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13423": {"epss_score": 0.00052, "epss_percentile": 0.16457}, "CVE-2025-13424": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-13425": {"epss_score": 7e-05, "epss_percentile": 0.00369}, "CVE-2025-13426": {"epss_score": 0.00411, "epss_percentile": 0.60875}, "CVE-2025-13427": {"epss_score": 0.00138, "epss_percentile": 0.34524}, "CVE-2025-13428": {"epss_score": 0.00424, "epss_percentile": 0.61653}, "CVE-2025-13432": {"epss_score": 0.00029, "epss_percentile": 0.07899}, "CVE-2025-13433": {"epss_score": 0.00014, "epss_percentile": 0.01816}, "CVE-2025-13434": {"epss_score": 0.00152, "epss_percentile": 0.36502}, "CVE-2025-13435": {"epss_score": 0.00343, "epss_percentile": 0.56462}, "CVE-2025-13437": {"epss_score": 8e-05, "epss_percentile": 0.00493}, "CVE-2025-13439": {"epss_score": 0.00042, "epss_percentile": 0.12709}, "CVE-2025-13440": {"epss_score": 0.00035, "epss_percentile": 0.09894}, "CVE-2025-13441": {"epss_score": 0.00091, "epss_percentile": 0.26243}, "CVE-2025-13442": {"epss_score": 0.02085, "epss_percentile": 0.83544}, "CVE-2025-13443": {"epss_score": 0.00031, "epss_percentile": 0.08706}, "CVE-2025-13445": {"epss_score": 0.00138, "epss_percentile": 0.34372}, "CVE-2025-13446": {"epss_score": 0.00096, "epss_percentile": 0.27384}, "CVE-2025-13448": {"epss_score": 0.00039, "epss_percentile": 0.11637}, "CVE-2025-13449": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13450": {"epss_score": 0.00032, "epss_percentile": 0.08782}, "CVE-2025-13451": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13452": {"epss_score": 0.00082, "epss_percentile": 0.24573}, "CVE-2025-13456": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-13466": {"epss_score": 0.00019, "epss_percentile": 0.04359}, "CVE-2025-13467": {"epss_score": 0.00022, "epss_percentile": 0.0506}, "CVE-2025-13468": {"epss_score": 0.00057, "epss_percentile": 0.18072}, "CVE-2025-13469": {"epss_score": 0.00039, "epss_percentile": 0.11764}, "CVE-2025-13470": {"epss_score": 0.00028, "epss_percentile": 0.07535}, "CVE-2025-13472": {"epss_score": 0.00041, "epss_percentile": 0.1222}, "CVE-2025-13474": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-13481": {"epss_score": 0.00044, "epss_percentile": 0.13369}, "CVE-2025-13483": {"epss_score": 0.00213, "epss_percentile": 0.43832}, "CVE-2025-13484": {"epss_score": 0.00038, "epss_percentile": 0.11218}, "CVE-2025-13485": {"epss_score": 0.00035, "epss_percentile": 0.10142}, "CVE-2025-13486": {"epss_score": 0.81487, "epss_percentile": 0.99141}, "CVE-2025-13488": {"epss_score": 0.0006, "epss_percentile": 0.19139}, "CVE-2025-13489": {"epss_score": 0.00014, "epss_percentile": 0.01875}, "CVE-2025-13492": {"epss_score": 0.00011, "epss_percentile": 0.00925}, "CVE-2025-13493": {"epss_score": 0.0003, "epss_percentile": 0.08306}, "CVE-2025-13494": {"epss_score": 0.00041, "epss_percentile": 0.12326}, "CVE-2025-13495": {"epss_score": 0.00034, "epss_percentile": 0.09533}, "CVE-2025-13496": {"epss_score": 0.00026, "epss_percentile": 0.06725}, "CVE-2025-13497": {"epss_score": 0.0003, "epss_percentile": 0.0827}, "CVE-2025-13498": {"epss_score": 0.00032, "epss_percentile": 0.08769}, "CVE-2025-13499": {"epss_score": 0.0001, "epss_percentile": 0.00833}, "CVE-2025-13502": {"epss_score": 0.00082, "epss_percentile": 0.24407}, "CVE-2025-13504": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-13505": {"epss_score": 0.00034, "epss_percentile": 0.0969}, "CVE-2025-13506": {"epss_score": 0.00071, "epss_percentile": 0.22216}, "CVE-2025-13507": {"epss_score": 0.00101, "epss_percentile": 0.28716}, "CVE-2025-13510": {"epss_score": 0.00159, "epss_percentile": 0.373}, "CVE-2025-13512": {"epss_score": 0.00129, "epss_percentile": 0.33114}, "CVE-2025-13513": {"epss_score": 0.00129, "epss_percentile": 0.33114}, "CVE-2025-13515": {"epss_score": 0.00129, "epss_percentile": 0.33114}, "CVE-2025-13516": {"epss_score": 0.00208, "epss_percentile": 0.43266}, "CVE-2025-13519": {"epss_score": 0.00012, "epss_percentile": 0.01148}, "CVE-2025-13520": {"epss_score": 0.00012, "epss_percentile": 0.01152}, "CVE-2025-13521": {"epss_score": 0.00012, "epss_percentile": 0.01152}, "CVE-2025-13524": {"epss_score": 0.00036, "epss_percentile": 0.10317}, "CVE-2025-13525": {"epss_score": 0.00147, "epss_percentile": 0.35646}, "CVE-2025-13526": {"epss_score": 0.00041, "epss_percentile": 0.12243}, "CVE-2025-13527": {"epss_score": 0.00012, "epss_percentile": 0.01152}, "CVE-2025-13528": {"epss_score": 0.00056, "epss_percentile": 0.17884}, "CVE-2025-13529": {"epss_score": 0.00045, "epss_percentile": 0.13905}, "CVE-2025-13531": {"epss_score": 0.00032, "epss_percentile": 0.09104}, "CVE-2025-13532": {"epss_score": 7e-05, "epss_percentile": 0.00395}, "CVE-2025-13534": {"epss_score": 0.00055, "epss_percentile": 0.17416}, "CVE-2025-13536": {"epss_score": 0.00283, "epss_percentile": 0.51377}, "CVE-2025-13537": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-13538": {"epss_score": 0.0014, "epss_percentile": 0.34789}, "CVE-2025-13539": {"epss_score": 0.00422, "epss_percentile": 0.61577}, "CVE-2025-13540": {"epss_score": 0.0014, "epss_percentile": 0.34789}, "CVE-2025-13542": {"epss_score": 0.0014, "epss_percentile": 0.34789}, "CVE-2025-13543": {"epss_score": 0.00261, "epss_percentile": 0.49269}, "CVE-2025-13544": {"epss_score": 0.00044, "epss_percentile": 0.13431}, "CVE-2025-13545": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-13546": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13547": {"epss_score": 0.0011, "epss_percentile": 0.30176}, "CVE-2025-13548": {"epss_score": 0.001, "epss_percentile": 0.28556}, "CVE-2025-13549": {"epss_score": 0.00051, "epss_percentile": 0.1604}, "CVE-2025-13550": {"epss_score": 0.001, "epss_percentile": 0.28556}, "CVE-2025-13551": {"epss_score": 0.001, "epss_percentile": 0.28556}, "CVE-2025-13552": {"epss_score": 0.001, "epss_percentile": 0.28556}, "CVE-2025-13553": {"epss_score": 0.00053, "epss_percentile": 0.16815}, "CVE-2025-13554": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13555": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13556": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13557": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13558": {"epss_score": 0.00043, "epss_percentile": 0.13281}, "CVE-2025-13559": {"epss_score": 0.0014, "epss_percentile": 0.34789}, "CVE-2025-13560": {"epss_score": 0.00043, "epss_percentile": 0.13359}, "CVE-2025-13561": {"epss_score": 0.00043, "epss_percentile": 0.13359}, "CVE-2025-13562": {"epss_score": 0.004, "epss_percentile": 0.6016}, "CVE-2025-13564": {"epss_score": 0.00057, "epss_percentile": 0.18179}, "CVE-2025-13565": {"epss_score": 0.00156, "epss_percentile": 0.37015}, "CVE-2025-13566": {"epss_score": 0.00017, "epss_percentile": 0.03106}, "CVE-2025-13567": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13568": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13569": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13570": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13571": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13572": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13573": {"epss_score": 0.00042, "epss_percentile": 0.12481}, "CVE-2025-13574": {"epss_score": 0.00079, "epss_percentile": 0.23872}, "CVE-2025-13575": {"epss_score": 0.00043, "epss_percentile": 0.12999}, "CVE-2025-13576": {"epss_score": 0.00042, "epss_percentile": 0.12481}, "CVE-2025-13577": {"epss_score": 0.00031, "epss_percentile": 0.08337}, "CVE-2025-13578": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13579": {"epss_score": 0.00015, "epss_percentile": 0.02223}, "CVE-2025-13580": {"epss_score": 0.00031, "epss_percentile": 0.08544}, "CVE-2025-13581": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-13582": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13583": {"epss_score": 0.00037, "epss_percentile": 0.10832}, "CVE-2025-13584": {"epss_score": 0.0004, "epss_percentile": 0.12057}, "CVE-2025-13585": {"epss_score": 0.00053, "epss_percentile": 0.16827}, "CVE-2025-13586": {"epss_score": 0.00034, "epss_percentile": 0.09614}, "CVE-2025-13588": {"epss_score": 0.00055, "epss_percentile": 0.17502}, "CVE-2025-13589": {"epss_score": 0.00243, "epss_percentile": 0.47425}, "CVE-2025-13592": {"epss_score": 0.00254, "epss_percentile": 0.48555}, "CVE-2025-13595": {"epss_score": 0.00268, "epss_percentile": 0.50043}, "CVE-2025-13596": {"epss_score": 0.00149, "epss_percentile": 0.36017}, "CVE-2025-13597": {"epss_score": 0.00268, "epss_percentile": 0.50043}, "CVE-2025-13601": {"epss_score": 0.00017, "epss_percentile": 0.03125}, "CVE-2025-13604": {"epss_score": 0.00098, "epss_percentile": 0.27642}, "CVE-2025-13606": {"epss_score": 0.00016, "epss_percentile": 0.02932}, "CVE-2025-13607": {"epss_score": 0.00055, "epss_percentile": 0.17539}, "CVE-2025-13608": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-13609": {"epss_score": 0.00068, "epss_percentile": 0.21346}, "CVE-2025-13610": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-13611": {"epss_score": 0.0001, "epss_percentile": 0.00814}, "CVE-2025-13613": {"epss_score": 0.00292, "epss_percentile": 0.52275}, "CVE-2025-13614": {"epss_score": 0.00042, "epss_percentile": 0.12565}, "CVE-2025-13615": {"epss_score": 0.00211, "epss_percentile": 0.43716}, "CVE-2025-13619": {"epss_score": 0.00097, "epss_percentile": 0.27553}, "CVE-2025-13620": {"epss_score": 0.00053, "epss_percentile": 0.16736}, "CVE-2025-13621": {"epss_score": 0.00015, "epss_percentile": 0.0259}, "CVE-2025-13622": {"epss_score": 0.00137, "epss_percentile": 0.34248}, "CVE-2025-13623": {"epss_score": 0.00137, "epss_percentile": 0.34248}, "CVE-2025-13624": {"epss_score": 0.00095, "epss_percentile": 0.27097}, "CVE-2025-13625": {"epss_score": 0.00137, "epss_percentile": 0.34248}, "CVE-2025-13626": {"epss_score": 0.00137, "epss_percentile": 0.34248}, "CVE-2025-13629": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2025-13630": {"epss_score": 0.00089, "epss_percentile": 0.25903}, "CVE-2025-13631": {"epss_score": 0.00088, "epss_percentile": 0.25661}, "CVE-2025-13632": {"epss_score": 0.00019, "epss_percentile": 0.04223}, "CVE-2025-13633": {"epss_score": 0.00119, "epss_percentile": 0.31633}, "CVE-2025-13634": {"epss_score": 6e-05, "epss_percentile": 0.00256}, "CVE-2025-13635": {"epss_score": 6e-05, "epss_percentile": 0.00313}, "CVE-2025-13636": {"epss_score": 0.00076, "epss_percentile": 0.23169}, "CVE-2025-13637": {"epss_score": 0.00023, "epss_percentile": 0.05605}, "CVE-2025-13638": {"epss_score": 0.00119, "epss_percentile": 0.31633}, "CVE-2025-13639": {"epss_score": 0.00035, "epss_percentile": 0.09885}, "CVE-2025-13640": {"epss_score": 0.00022, "epss_percentile": 0.05026}, "CVE-2025-13641": {"epss_score": 0.00103, "epss_percentile": 0.29}, "CVE-2025-13642": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-13643": {"epss_score": 0.00045, "epss_percentile": 0.13894}, "CVE-2025-13644": {"epss_score": 0.00067, "epss_percentile": 0.20998}, "CVE-2025-13645": {"epss_score": 0.00848, "epss_percentile": 0.74366}, "CVE-2025-13646": {"epss_score": 0.00276, "epss_percentile": 0.50703}, "CVE-2025-13652": {"epss_score": 0.00026, "epss_percentile": 0.06474}, "CVE-2025-13653": {"epss_score": 0.0003, "epss_percentile": 0.08291}, "CVE-2025-13654": {"epss_score": 0.00057, "epss_percentile": 0.18186}, "CVE-2025-13656": {"epss_score": 0.00039, "epss_percentile": 0.11637}, "CVE-2025-13657": {"epss_score": 0.00012, "epss_percentile": 0.01152}, "CVE-2025-13658": {"epss_score": 0.00112, "epss_percentile": 0.30417}, "CVE-2025-13659": {"epss_score": 0.00296, "epss_percentile": 0.52571}, "CVE-2025-13660": {"epss_score": 0.00138, "epss_percentile": 0.34358}, "CVE-2025-13661": {"epss_score": 0.00406, "epss_percentile": 0.60533}, "CVE-2025-13662": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2025-13663": {"epss_score": 0.0001, "epss_percentile": 0.00844}, "CVE-2025-13664": {"epss_score": 0.00013, "epss_percentile": 0.01635}, "CVE-2025-13665": {"epss_score": 0.00013, "epss_percentile": 0.01635}, "CVE-2025-13666": {"epss_score": 0.00086, "epss_percentile": 0.25278}, "CVE-2025-13667": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-13668": {"epss_score": 0.00013, "epss_percentile": 0.01635}, "CVE-2025-13669": {"epss_score": 0.00013, "epss_percentile": 0.01481}, "CVE-2025-13670": {"epss_score": 0.00013, "epss_percentile": 0.01635}, "CVE-2025-13674": {"epss_score": 0.00011, "epss_percentile": 0.00951}, "CVE-2025-13675": {"epss_score": 0.0014, "epss_percentile": 0.34789}, "CVE-2025-13677": {"epss_score": 0.00054, "epss_percentile": 0.17083}, "CVE-2025-13678": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-13679": {"epss_score": 0.00034, "epss_percentile": 0.0945}, "CVE-2025-13680": {"epss_score": 0.0005, "epss_percentile": 0.15884}, "CVE-2025-13682": {"epss_score": 0.00031, "epss_percentile": 0.08582}, "CVE-2025-13683": {"epss_score": 0.00042, "epss_percentile": 0.12497}, "CVE-2025-13684": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2025-13685": {"epss_score": 0.00026, "epss_percentile": 0.06571}, "CVE-2025-13692": {"epss_score": 0.00198, "epss_percentile": 0.42045}, "CVE-2025-13693": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-13694": {"epss_score": 0.0002, "epss_percentile": 0.04432}, "CVE-2025-13696": {"epss_score": 0.00058, "epss_percentile": 0.18428}, "CVE-2025-13697": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-13698": {"epss_score": 0.0015, "epss_percentile": 0.36091}, "CVE-2025-13699": {"epss_score": 0.00124, "epss_percentile": 0.32358}, "CVE-2025-13700": {"epss_score": 0.01344, "epss_percentile": 0.79613}, "CVE-2025-13703": {"epss_score": 0.00013, "epss_percentile": 0.01518}, "CVE-2025-13705": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13706": {"epss_score": 0.00303, "epss_percentile": 0.5319}, "CVE-2025-13707": {"epss_score": 0.00303, "epss_percentile": 0.5319}, "CVE-2025-13708": {"epss_score": 0.00303, "epss_percentile": 0.5319}, "CVE-2025-13709": {"epss_score": 0.00303, "epss_percentile": 0.5319}, "CVE-2025-13710": {"epss_score": 0.00303, "epss_percentile": 0.5319}, "CVE-2025-13711": {"epss_score": 0.00303, "epss_percentile": 0.5319}, "CVE-2025-13712": {"epss_score": 0.00303, "epss_percentile": 0.5319}, "CVE-2025-13713": {"epss_score": 0.00303, "epss_percentile": 0.5319}, "CVE-2025-13714": {"epss_score": 0.00303, "epss_percentile": 0.5319}, "CVE-2025-13715": {"epss_score": 0.00303, "epss_percentile": 0.5319}, "CVE-2025-13716": {"epss_score": 0.00303, "epss_percentile": 0.5319}, "CVE-2025-13720": {"epss_score": 0.00089, "epss_percentile": 0.25903}, "CVE-2025-13721": {"epss_score": 0.00079, "epss_percentile": 0.23959}, "CVE-2025-13722": {"epss_score": 0.00028, "epss_percentile": 0.07353}, "CVE-2025-13724": {"epss_score": 0.0005, "epss_percentile": 0.15757}, "CVE-2025-13728": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-13730": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-13731": {"epss_score": 0.00039, "epss_percentile": 0.11637}, "CVE-2025-13733": {"epss_score": 0.00013, "epss_percentile": 0.01687}, "CVE-2025-13735": {"epss_score": 0.00047, "epss_percentile": 0.14885}, "CVE-2025-13737": {"epss_score": 0.00014, "epss_percentile": 0.01784}, "CVE-2025-13739": {"epss_score": 0.00042, "epss_percentile": 0.12632}, "CVE-2025-13740": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-13741": {"epss_score": 0.00033, "epss_percentile": 0.09415}, "CVE-2025-13742": {"epss_score": 0.00032, "epss_percentile": 0.09101}, "CVE-2025-13743": {"epss_score": 0.00016, "epss_percentile": 0.02783}, "CVE-2025-13744": {"epss_score": 0.00042, "epss_percentile": 0.1283}, "CVE-2025-13746": {"epss_score": 0.0003, "epss_percentile": 0.0827}, "CVE-2025-13747": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-13748": {"epss_score": 0.0005, "epss_percentile": 0.15673}, "CVE-2025-13750": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-13751": {"epss_score": 0.00016, "epss_percentile": 0.03039}, "CVE-2025-13754": {"epss_score": 0.0007, "epss_percentile": 0.21665}, "CVE-2025-13756": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-13757": {"epss_score": 0.00037, "epss_percentile": 0.1079}, "CVE-2025-13758": {"epss_score": 0.00031, "epss_percentile": 0.08565}, "CVE-2025-13762": {"epss_score": 0.00028, "epss_percentile": 0.07581}, "CVE-2025-13764": {"epss_score": 0.00097, "epss_percentile": 0.27553}, "CVE-2025-13765": {"epss_score": 0.00037, "epss_percentile": 0.10836}, "CVE-2025-13766": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2025-13767": {"epss_score": 0.0003, "epss_percentile": 0.0805}, "CVE-2025-13768": {"epss_score": 0.00292, "epss_percentile": 0.52229}, "CVE-2025-13769": {"epss_score": 0.00045, "epss_percentile": 0.13918}, "CVE-2025-13770": {"epss_score": 0.00045, "epss_percentile": 0.13918}, "CVE-2025-13771": {"epss_score": 0.00063, "epss_percentile": 0.19918}, "CVE-2025-13773": {"epss_score": 0.0053, "epss_percentile": 0.66628}, "CVE-2025-13780": {"epss_score": 0.00125, "epss_percentile": 0.32543}, "CVE-2025-13782": {"epss_score": 0.00035, "epss_percentile": 0.10142}, "CVE-2025-13783": {"epss_score": 0.00044, "epss_percentile": 0.1344}, "CVE-2025-13784": {"epss_score": 0.00028, "epss_percentile": 0.07223}, "CVE-2025-13785": {"epss_score": 0.00033, "epss_percentile": 0.094}, "CVE-2025-13786": {"epss_score": 0.00051, "epss_percentile": 0.16013}, "CVE-2025-13787": {"epss_score": 0.00056, "epss_percentile": 0.1779}, "CVE-2025-13788": {"epss_score": 0.00032, "epss_percentile": 0.09116}, "CVE-2025-13789": {"epss_score": 0.00044, "epss_percentile": 0.1359}, "CVE-2025-13790": {"epss_score": 0.0003, "epss_percentile": 0.08217}, "CVE-2025-13791": {"epss_score": 0.00089, "epss_percentile": 0.25835}, "CVE-2025-13792": {"epss_score": 0.00074, "epss_percentile": 0.22864}, "CVE-2025-13793": {"epss_score": 0.00036, "epss_percentile": 0.10395}, "CVE-2025-13794": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-13795": {"epss_score": 0.00033, "epss_percentile": 0.09304}, "CVE-2025-13796": {"epss_score": 0.00046, "epss_percentile": 0.14463}, "CVE-2025-13797": {"epss_score": 0.00645, "epss_percentile": 0.70118}, "CVE-2025-13798": {"epss_score": 0.00645, "epss_percentile": 0.70118}, "CVE-2025-13799": {"epss_score": 0.00476, "epss_percentile": 0.64252}, "CVE-2025-13800": {"epss_score": 0.00476, "epss_percentile": 0.64252}, "CVE-2025-13801": {"epss_score": 0.00127, "epss_percentile": 0.32784}, "CVE-2025-13802": {"epss_score": 0.00036, "epss_percentile": 0.10395}, "CVE-2025-13803": {"epss_score": 0.00056, "epss_percentile": 0.17785}, "CVE-2025-13804": {"epss_score": 0.00034, "epss_percentile": 0.09786}, "CVE-2025-13805": {"epss_score": 0.00044, "epss_percentile": 0.13428}, "CVE-2025-13806": {"epss_score": 0.00048, "epss_percentile": 0.15074}, "CVE-2025-13807": {"epss_score": 0.00037, "epss_percentile": 0.10764}, "CVE-2025-13808": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2025-13809": {"epss_score": 0.00039, "epss_percentile": 0.11706}, "CVE-2025-13810": {"epss_score": 0.00206, "epss_percentile": 0.43}, "CVE-2025-13811": {"epss_score": 0.00035, "epss_percentile": 0.09895}, "CVE-2025-13812": {"epss_score": 0.0003, "epss_percentile": 0.08162}, "CVE-2025-13813": {"epss_score": 0.00045, "epss_percentile": 0.14002}, "CVE-2025-13814": {"epss_score": 0.00045, "epss_percentile": 0.14002}, "CVE-2025-13815": {"epss_score": 0.00045, "epss_percentile": 0.1393}, "CVE-2025-13816": {"epss_score": 0.00128, "epss_percentile": 0.33011}, "CVE-2025-13819": {"epss_score": 0.0004, "epss_percentile": 0.11868}, "CVE-2025-13820": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-13823": {"epss_score": 0.00023, "epss_percentile": 0.05405}, "CVE-2025-13824": {"epss_score": 0.00055, "epss_percentile": 0.17626}, "CVE-2025-13827": {"epss_score": 0.00344, "epss_percentile": 0.56546}, "CVE-2025-13828": {"epss_score": 0.0005, "epss_percentile": 0.15677}, "CVE-2025-13829": {"epss_score": 0.0005, "epss_percentile": 0.15677}, "CVE-2025-13835": {"epss_score": 0.00039, "epss_percentile": 0.11557}, "CVE-2025-13836": {"epss_score": 0.00087, "epss_percentile": 0.25498}, "CVE-2025-13837": {"epss_score": 0.0002, "epss_percentile": 0.04564}, "CVE-2025-13838": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-13839": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13840": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13841": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-13843": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13846": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13847": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-13848": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-13849": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-13850": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13856": {"epss_score": 0.00039, "epss_percentile": 0.11637}, "CVE-2025-13857": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-13860": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-13861": {"epss_score": 0.00095, "epss_percentile": 0.27097}, "CVE-2025-13863": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-13866": {"epss_score": 0.00028, "epss_percentile": 0.07324}, "CVE-2025-13870": {"epss_score": 0.00034, "epss_percentile": 0.09676}, "CVE-2025-13871": {"epss_score": 0.0002, "epss_percentile": 0.04519}, "CVE-2025-13872": {"epss_score": 0.00048, "epss_percentile": 0.15138}, "CVE-2025-13873": {"epss_score": 0.00038, "epss_percentile": 0.11211}, "CVE-2025-13875": {"epss_score": 0.00062, "epss_percentile": 0.19732}, "CVE-2025-13876": {"epss_score": 0.00023, "epss_percentile": 0.05432}, "CVE-2025-13877": {"epss_score": 0.00054, "epss_percentile": 0.17291}, "CVE-2025-13879": {"epss_score": 0.00268, "epss_percentile": 0.50044}, "CVE-2025-13880": {"epss_score": 0.00067, "epss_percentile": 0.21156}, "CVE-2025-13884": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13885": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13886": {"epss_score": 0.00093, "epss_percentile": 0.26744}, "CVE-2025-13887": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-13888": {"epss_score": 0.00071, "epss_percentile": 0.22176}, "CVE-2025-13889": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13891": {"epss_score": 0.00049, "epss_percentile": 0.15291}, "CVE-2025-13894": {"epss_score": 0.00116, "epss_percentile": 0.31145}, "CVE-2025-13896": {"epss_score": 0.00042, "epss_percentile": 0.12632}, "CVE-2025-13898": {"epss_score": 0.00042, "epss_percentile": 0.12632}, "CVE-2025-13899": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-13904": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13906": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13907": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-13911": {"epss_score": 0.00024, "epss_percentile": 0.05866}, "CVE-2025-13912": {"epss_score": 0.00017, "epss_percentile": 0.03353}, "CVE-2025-13915": {"epss_score": 0.00373, "epss_percentile": 0.58477}, "CVE-2025-13922": {"epss_score": 0.00025, "epss_percentile": 0.06209}, "CVE-2025-13924": {"epss_score": 0.00013, "epss_percentile": 0.01441}, "CVE-2025-13932": {"epss_score": 0.0005, "epss_percentile": 0.15677}, "CVE-2025-13936": {"epss_score": 0.00028, "epss_percentile": 0.07536}, "CVE-2025-13937": {"epss_score": 0.00028, "epss_percentile": 0.07536}, "CVE-2025-13938": {"epss_score": 0.00028, "epss_percentile": 0.07536}, "CVE-2025-13939": {"epss_score": 0.00028, "epss_percentile": 0.07536}, "CVE-2025-13940": {"epss_score": 0.00015, "epss_percentile": 0.02151}, "CVE-2025-13941": {"epss_score": 0.00012, "epss_percentile": 0.01232}, "CVE-2025-13945": {"epss_score": 0.00018, "epss_percentile": 0.03796}, "CVE-2025-13946": {"epss_score": 0.00011, "epss_percentile": 0.01112}, "CVE-2025-13947": {"epss_score": 0.00048, "epss_percentile": 0.14993}, "CVE-2025-13948": {"epss_score": 0.00054, "epss_percentile": 0.17291}, "CVE-2025-13949": {"epss_score": 0.00043, "epss_percentile": 0.13329}, "CVE-2025-13950": {"epss_score": 0.00072, "epss_percentile": 0.22261}, "CVE-2025-13953": {"epss_score": 0.00068, "epss_percentile": 0.21417}, "CVE-2025-13954": {"epss_score": 0.00022, "epss_percentile": 0.05195}, "CVE-2025-13955": {"epss_score": 0.00023, "epss_percentile": 0.05405}, "CVE-2025-13956": {"epss_score": 0.00061, "epss_percentile": 0.19498}, "CVE-2025-13958": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-13960": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13961": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-13962": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-13963": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-13964": {"epss_score": 0.00045, "epss_percentile": 0.13905}, "CVE-2025-13966": {"epss_score": 0.00036, "epss_percentile": 0.10508}, "CVE-2025-13969": {"epss_score": 0.00063, "epss_percentile": 0.19978}, "CVE-2025-13970": {"epss_score": 0.00015, "epss_percentile": 0.02537}, "CVE-2025-13971": {"epss_score": 0.00039, "epss_percentile": 0.11776}, "CVE-2025-13972": {"epss_score": 0.00154, "epss_percentile": 0.36699}, "CVE-2025-13974": {"epss_score": 0.00026, "epss_percentile": 0.06674}, "CVE-2025-13975": {"epss_score": 0.00037, "epss_percentile": 0.10735}, "CVE-2025-13977": {"epss_score": 0.00036, "epss_percentile": 0.10508}, "CVE-2025-13978": {"epss_score": 0.00014, "epss_percentile": 0.0183}, "CVE-2025-13987": {"epss_score": 0.00013, "epss_percentile": 0.01441}, "CVE-2025-13988": {"epss_score": 0.00089, "epss_percentile": 0.25907}, "CVE-2025-13989": {"epss_score": 0.00036, "epss_percentile": 0.10508}, "CVE-2025-13990": {"epss_score": 0.00018, "epss_percentile": 0.03795}, "CVE-2025-13992": {"epss_score": 0.00025, "epss_percentile": 0.06263}, "CVE-2025-13993": {"epss_score": 0.00044, "epss_percentile": 0.13449}, "CVE-2025-13999": {"epss_score": 0.00068, "epss_percentile": 0.21369}, "CVE-2025-14000": {"epss_score": 0.0004, "epss_percentile": 0.1216}, "CVE-2025-14002": {"epss_score": 0.00152, "epss_percentile": 0.36501}, "CVE-2025-14003": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-14004": {"epss_score": 0.0004, "epss_percentile": 0.12115}, "CVE-2025-14005": {"epss_score": 0.00028, "epss_percentile": 0.07223}, "CVE-2025-14006": {"epss_score": 0.00031, "epss_percentile": 0.08615}, "CVE-2025-14007": {"epss_score": 0.00028, "epss_percentile": 0.07223}, "CVE-2025-14008": {"epss_score": 0.00038, "epss_percentile": 0.11329}, "CVE-2025-14010": {"epss_score": 0.00013, "epss_percentile": 0.01563}, "CVE-2025-14011": {"epss_score": 0.0003, "epss_percentile": 0.08086}, "CVE-2025-14012": {"epss_score": 0.0003, "epss_percentile": 0.08086}, "CVE-2025-14013": {"epss_score": 0.00028, "epss_percentile": 0.07223}, "CVE-2025-14015": {"epss_score": 0.00138, "epss_percentile": 0.34372}, "CVE-2025-14016": {"epss_score": 0.0006, "epss_percentile": 0.18961}, "CVE-2025-14017": {"epss_score": 9e-05, "epss_percentile": 0.00635}, "CVE-2025-14018": {"epss_score": 0.00014, "epss_percentile": 0.01969}, "CVE-2025-14019": {"epss_score": 0.00027, "epss_percentile": 0.06839}, "CVE-2025-14020": {"epss_score": 0.00026, "epss_percentile": 0.06409}, "CVE-2025-14021": {"epss_score": 0.00027, "epss_percentile": 0.06839}, "CVE-2025-14022": {"epss_score": 0.00017, "epss_percentile": 0.03295}, "CVE-2025-14023": {"epss_score": 0.00027, "epss_percentile": 0.06839}, "CVE-2025-14026": {"epss_score": 0.0005, "epss_percentile": 0.1569}, "CVE-2025-14028": {"epss_score": 0.0003, "epss_percentile": 0.08183}, "CVE-2025-14030": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-14032": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-14034": {"epss_score": 0.00033, "epss_percentile": 0.09412}, "CVE-2025-14035": {"epss_score": 0.00044, "epss_percentile": 0.13449}, "CVE-2025-14038": {"epss_score": 0.00161, "epss_percentile": 0.37548}, "CVE-2025-14043": {"epss_score": 0.00181, "epss_percentile": 0.40089}, "CVE-2025-14044": {"epss_score": 0.00096, "epss_percentile": 0.27402}, "CVE-2025-14045": {"epss_score": 0.0003, "epss_percentile": 0.0803}, "CVE-2025-14046": {"epss_score": 0.00028, "epss_percentile": 0.07338}, "CVE-2025-14047": {"epss_score": 0.00075, "epss_percentile": 0.22978}, "CVE-2025-14048": {"epss_score": 0.00035, "epss_percentile": 0.09856}, "CVE-2025-14049": {"epss_score": 0.00095, "epss_percentile": 0.27097}, "CVE-2025-14050": {"epss_score": 0.00031, "epss_percentile": 0.08533}, "CVE-2025-14051": {"epss_score": 0.00067, "epss_percentile": 0.20968}, "CVE-2025-14052": {"epss_score": 0.00033, "epss_percentile": 0.094}, "CVE-2025-14053": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14054": {"epss_score": 0.00037, "epss_percentile": 0.10735}, "CVE-2025-14056": {"epss_score": 0.00037, "epss_percentile": 0.10735}, "CVE-2025-14057": {"epss_score": 0.00021, "epss_percentile": 0.04896}, "CVE-2025-14059": {"epss_score": 0.00024, "epss_percentile": 0.05737}, "CVE-2025-14061": {"epss_score": 0.00059, "epss_percentile": 0.18843}, "CVE-2025-14062": {"epss_score": 0.00013, "epss_percentile": 0.01441}, "CVE-2025-14064": {"epss_score": 0.00043, "epss_percentile": 0.13102}, "CVE-2025-14065": {"epss_score": 0.00039, "epss_percentile": 0.11623}, "CVE-2025-14068": {"epss_score": 0.00109, "epss_percentile": 0.29947}, "CVE-2025-14070": {"epss_score": 0.00028, "epss_percentile": 0.07485}, "CVE-2025-14071": {"epss_score": 0.00085, "epss_percentile": 0.25093}, "CVE-2025-14072": {"epss_score": 0.00051, "epss_percentile": 0.16309}, "CVE-2025-14074": {"epss_score": 0.00039, "epss_percentile": 0.11623}, "CVE-2025-14077": {"epss_score": 0.00012, "epss_percentile": 0.01152}, "CVE-2025-14080": {"epss_score": 0.00063, "epss_percentile": 0.19919}, "CVE-2025-14081": {"epss_score": 0.0003, "epss_percentile": 0.0803}, "CVE-2025-14082": {"epss_score": 0.0003, "epss_percentile": 0.08305}, "CVE-2025-14085": {"epss_score": 0.0005, "epss_percentile": 0.15933}, "CVE-2025-14086": {"epss_score": 0.00042, "epss_percentile": 0.12481}, "CVE-2025-14087": {"epss_score": 0.00259, "epss_percentile": 0.49049}, "CVE-2025-14088": {"epss_score": 0.00043, "epss_percentile": 0.13329}, "CVE-2025-14089": {"epss_score": 0.00043, "epss_percentile": 0.13329}, "CVE-2025-14090": {"epss_score": 0.0003, "epss_percentile": 0.08086}, "CVE-2025-14091": {"epss_score": 0.0004, "epss_percentile": 0.12054}, "CVE-2025-14092": {"epss_score": 0.0028, "epss_percentile": 0.51092}, "CVE-2025-14093": {"epss_score": 0.00306, "epss_percentile": 0.53462}, "CVE-2025-14094": {"epss_score": 0.00223, "epss_percentile": 0.44887}, "CVE-2025-14095": {"epss_score": 0.00035, "epss_percentile": 0.10119}, "CVE-2025-14096": {"epss_score": 0.00017, "epss_percentile": 0.03122}, "CVE-2025-14097": {"epss_score": 0.00251, "epss_percentile": 0.48301}, "CVE-2025-14101": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-14104": {"epss_score": 0.00016, "epss_percentile": 0.02753}, "CVE-2025-14105": {"epss_score": 0.0002, "epss_percentile": 0.04513}, "CVE-2025-14106": {"epss_score": 0.00691, "epss_percentile": 0.71267}, "CVE-2025-14107": {"epss_score": 0.00936, "epss_percentile": 0.7569}, "CVE-2025-14108": {"epss_score": 0.00452, "epss_percentile": 0.63165}, "CVE-2025-14109": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14110": {"epss_score": 0.00032, "epss_percentile": 0.09104}, "CVE-2025-14111": {"epss_score": 0.00208, "epss_percentile": 0.4328}, "CVE-2025-14112": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14113": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14114": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14116": {"epss_score": 0.00058, "epss_percentile": 0.1842}, "CVE-2025-14117": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2025-14118": {"epss_score": 0.00061, "epss_percentile": 0.19502}, "CVE-2025-14119": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-14120": {"epss_score": 0.0003, "epss_percentile": 0.0827}, "CVE-2025-14121": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14122": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14124": {"epss_score": 0.00064, "epss_percentile": 0.20348}, "CVE-2025-14125": {"epss_score": 0.00089, "epss_percentile": 0.25907}, "CVE-2025-14126": {"epss_score": 0.00039, "epss_percentile": 0.11569}, "CVE-2025-14127": {"epss_score": 0.00065, "epss_percentile": 0.20578}, "CVE-2025-14128": {"epss_score": 0.00065, "epss_percentile": 0.20578}, "CVE-2025-14129": {"epss_score": 0.00095, "epss_percentile": 0.27097}, "CVE-2025-14130": {"epss_score": 0.00061, "epss_percentile": 0.19502}, "CVE-2025-14131": {"epss_score": 0.00087, "epss_percentile": 0.25602}, "CVE-2025-14132": {"epss_score": 0.00089, "epss_percentile": 0.25907}, "CVE-2025-14133": {"epss_score": 0.00096, "epss_percentile": 0.27384}, "CVE-2025-14134": {"epss_score": 0.00096, "epss_percentile": 0.27384}, "CVE-2025-14135": {"epss_score": 0.00096, "epss_percentile": 0.27384}, "CVE-2025-14136": {"epss_score": 0.00096, "epss_percentile": 0.27384}, "CVE-2025-14137": {"epss_score": 0.00095, "epss_percentile": 0.27097}, "CVE-2025-14138": {"epss_score": 0.00089, "epss_percentile": 0.25907}, "CVE-2025-14139": {"epss_score": 0.00094, "epss_percentile": 0.27077}, "CVE-2025-14140": {"epss_score": 0.00103, "epss_percentile": 0.2901}, "CVE-2025-14141": {"epss_score": 0.00138, "epss_percentile": 0.34372}, "CVE-2025-14143": {"epss_score": 0.00036, "epss_percentile": 0.10508}, "CVE-2025-14144": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14145": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14147": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14148": {"epss_score": 0.0003, "epss_percentile": 0.08159}, "CVE-2025-14151": {"epss_score": 0.00095, "epss_percentile": 0.27097}, "CVE-2025-14153": {"epss_score": 0.00026, "epss_percentile": 0.06389}, "CVE-2025-14154": {"epss_score": 0.0008, "epss_percentile": 0.24172}, "CVE-2025-14155": {"epss_score": 0.00053, "epss_percentile": 0.16751}, "CVE-2025-14156": {"epss_score": 0.00133, "epss_percentile": 0.33676}, "CVE-2025-14157": {"epss_score": 0.00038, "epss_percentile": 0.11121}, "CVE-2025-14158": {"epss_score": 0.00013, "epss_percentile": 0.01663}, "CVE-2025-14159": {"epss_score": 0.00013, "epss_percentile": 0.01661}, "CVE-2025-14160": {"epss_score": 0.00014, "epss_percentile": 0.02021}, "CVE-2025-14161": {"epss_score": 0.00013, "epss_percentile": 0.01441}, "CVE-2025-14162": {"epss_score": 0.00013, "epss_percentile": 0.01441}, "CVE-2025-14163": {"epss_score": 0.00018, "epss_percentile": 0.0367}, "CVE-2025-14164": {"epss_score": 0.00013, "epss_percentile": 0.01441}, "CVE-2025-14165": {"epss_score": 0.00014, "epss_percentile": 0.02021}, "CVE-2025-14166": {"epss_score": 0.00128, "epss_percentile": 0.32974}, "CVE-2025-14168": {"epss_score": 0.00013, "epss_percentile": 0.01441}, "CVE-2025-14169": {"epss_score": 0.00093, "epss_percentile": 0.26734}, "CVE-2025-14170": {"epss_score": 0.00035, "epss_percentile": 0.09894}, "CVE-2025-14174": {"epss_score": 0.00409, "epss_percentile": 0.60696}, "CVE-2025-14175": {"epss_score": 8e-05, "epss_percentile": 0.00517}, "CVE-2025-14177": {"epss_score": 0.00055, "epss_percentile": 0.17626}, "CVE-2025-14178": {"epss_score": 0.00052, "epss_percentile": 0.16645}, "CVE-2025-14180": {"epss_score": 0.00058, "epss_percentile": 0.18298}, "CVE-2025-14182": {"epss_score": 0.00096, "epss_percentile": 0.27372}, "CVE-2025-14183": {"epss_score": 0.00038, "epss_percentile": 0.11344}, "CVE-2025-14184": {"epss_score": 0.01521, "epss_percentile": 0.80831}, "CVE-2025-14185": {"epss_score": 0.00034, "epss_percentile": 0.09551}, "CVE-2025-14186": {"epss_score": 0.00034, "epss_percentile": 0.09511}, "CVE-2025-14187": {"epss_score": 0.00054, "epss_percentile": 0.17298}, "CVE-2025-14188": {"epss_score": 0.00169, "epss_percentile": 0.38541}, "CVE-2025-14189": {"epss_score": 0.00043, "epss_percentile": 0.13084}, "CVE-2025-14190": {"epss_score": 0.00043, "epss_percentile": 0.13084}, "CVE-2025-14191": {"epss_score": 0.00138, "epss_percentile": 0.34372}, "CVE-2025-14192": {"epss_score": 0.0004, "epss_percentile": 0.12054}, "CVE-2025-14193": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-14194": {"epss_score": 0.00032, "epss_percentile": 0.08782}, "CVE-2025-14195": {"epss_score": 0.00042, "epss_percentile": 0.12481}, "CVE-2025-14196": {"epss_score": 0.00056, "epss_percentile": 0.17749}, "CVE-2025-14197": {"epss_score": 0.00051, "epss_percentile": 0.16006}, "CVE-2025-14198": {"epss_score": 0.00042, "epss_percentile": 0.12478}, "CVE-2025-14199": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2025-14200": {"epss_score": 0.00031, "epss_percentile": 0.08337}, "CVE-2025-14201": {"epss_score": 0.00027, "epss_percentile": 0.06921}, "CVE-2025-14202": {"epss_score": 0.00052, "epss_percentile": 0.16586}, "CVE-2025-14203": {"epss_score": 0.00032, "epss_percentile": 0.0906}, "CVE-2025-14204": {"epss_score": 0.01741, "epss_percentile": 0.82047}, "CVE-2025-14205": {"epss_score": 0.0003, "epss_percentile": 0.08234}, "CVE-2025-14206": {"epss_score": 0.00118, "epss_percentile": 0.31517}, "CVE-2025-14207": {"epss_score": 0.00037, "epss_percentile": 0.10731}, "CVE-2025-14208": {"epss_score": 0.00717, "epss_percentile": 0.71877}, "CVE-2025-14209": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14210": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14211": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14212": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14214": {"epss_score": 0.0004, "epss_percentile": 0.12181}, "CVE-2025-14215": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14216": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14217": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14218": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14219": {"epss_score": 0.00041, "epss_percentile": 0.12291}, "CVE-2025-14220": {"epss_score": 0.00056, "epss_percentile": 0.17757}, "CVE-2025-14221": {"epss_score": 0.00027, "epss_percentile": 0.06925}, "CVE-2025-14222": {"epss_score": 0.00028, "epss_percentile": 0.07444}, "CVE-2025-14223": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14224": {"epss_score": 0.00179, "epss_percentile": 0.39843}, "CVE-2025-14225": {"epss_score": 0.00122, "epss_percentile": 0.32172}, "CVE-2025-14226": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14227": {"epss_score": 0.00029, "epss_percentile": 0.0793}, "CVE-2025-14228": {"epss_score": 0.00029, "epss_percentile": 0.07895}, "CVE-2025-14229": {"epss_score": 0.00037, "epss_percentile": 0.10723}, "CVE-2025-14230": {"epss_score": 0.00028, "epss_percentile": 0.07444}, "CVE-2025-14244": {"epss_score": 0.00025, "epss_percentile": 0.06313}, "CVE-2025-14245": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14246": {"epss_score": 0.00028, "epss_percentile": 0.07444}, "CVE-2025-14247": {"epss_score": 0.00028, "epss_percentile": 0.07444}, "CVE-2025-14248": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14249": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14250": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14251": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14252": {"epss_score": 0.00013, "epss_percentile": 0.01512}, "CVE-2025-14253": {"epss_score": 0.00064, "epss_percentile": 0.20143}, "CVE-2025-14254": {"epss_score": 0.00039, "epss_percentile": 0.11766}, "CVE-2025-14255": {"epss_score": 0.00039, "epss_percentile": 0.11766}, "CVE-2025-14256": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14257": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14258": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14259": {"epss_score": 0.00029, "epss_percentile": 0.0793}, "CVE-2025-14261": {"epss_score": 0.00074, "epss_percentile": 0.22852}, "CVE-2025-14262": {"epss_score": 0.00035, "epss_percentile": 0.10059}, "CVE-2025-14265": {"epss_score": 0.00045, "epss_percentile": 0.14056}, "CVE-2025-14266": {"epss_score": 0.00025, "epss_percentile": 0.06215}, "CVE-2025-14267": {"epss_score": 0.00039, "epss_percentile": 0.11694}, "CVE-2025-14273": {"epss_score": 0.00082, "epss_percentile": 0.2443}, "CVE-2025-14275": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14276": {"epss_score": 0.01881, "epss_percentile": 0.82694}, "CVE-2025-14277": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-14278": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-14280": {"epss_score": 0.0005, "epss_percentile": 0.15715}, "CVE-2025-14284": {"epss_score": 0.00031, "epss_percentile": 0.08662}, "CVE-2025-14285": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14286": {"epss_score": 0.0004, "epss_percentile": 0.11973}, "CVE-2025-14288": {"epss_score": 0.00028, "epss_percentile": 0.07326}, "CVE-2025-14293": {"epss_score": 0.00045, "epss_percentile": 0.13894}, "CVE-2025-14298": {"epss_score": 0.00033, "epss_percentile": 0.09302}, "CVE-2025-14299": {"epss_score": 0.00074, "epss_percentile": 0.22764}, "CVE-2025-14300": {"epss_score": 0.00048, "epss_percentile": 0.15187}, "CVE-2025-14302": {"epss_score": 0.00053, "epss_percentile": 0.16979}, "CVE-2025-14303": {"epss_score": 0.00053, "epss_percentile": 0.16979}, "CVE-2025-14304": {"epss_score": 0.00058, "epss_percentile": 0.18364}, "CVE-2025-14305": {"epss_score": 0.00013, "epss_percentile": 0.01687}, "CVE-2025-14306": {"epss_score": 0.00514, "epss_percentile": 0.65967}, "CVE-2025-14307": {"epss_score": 0.00054, "epss_percentile": 0.17107}, "CVE-2025-14308": {"epss_score": 0.0008, "epss_percentile": 0.24025}, "CVE-2025-14309": {"epss_score": 0.00053, "epss_percentile": 0.16716}, "CVE-2025-14310": {"epss_score": 0.00055, "epss_percentile": 0.17626}, "CVE-2025-14311": {"epss_score": 0.00019, "epss_percentile": 0.04195}, "CVE-2025-14312": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-14313": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-14314": {"epss_score": 0.00029, "epss_percentile": 0.07737}, "CVE-2025-14318": {"epss_score": 0.0003, "epss_percentile": 0.0805}, "CVE-2025-14321": {"epss_score": 0.0007, "epss_percentile": 0.2188}, "CVE-2025-14322": {"epss_score": 0.00045, "epss_percentile": 0.13746}, "CVE-2025-14323": {"epss_score": 0.00051, "epss_percentile": 0.16113}, "CVE-2025-14324": {"epss_score": 0.00079, "epss_percentile": 0.23821}, "CVE-2025-14325": {"epss_score": 0.00094, "epss_percentile": 0.26987}, "CVE-2025-14326": {"epss_score": 0.00052, "epss_percentile": 0.16559}, "CVE-2025-14327": {"epss_score": 0.00034, "epss_percentile": 0.09682}, "CVE-2025-14328": {"epss_score": 0.0005, "epss_percentile": 0.15758}, "CVE-2025-14329": {"epss_score": 0.0005, "epss_percentile": 0.15758}, "CVE-2025-14330": {"epss_score": 0.00073, "epss_percentile": 0.22612}, "CVE-2025-14331": {"epss_score": 0.00038, "epss_percentile": 0.11426}, "CVE-2025-14332": {"epss_score": 0.00047, "epss_percentile": 0.14912}, "CVE-2025-14333": {"epss_score": 0.0007, "epss_percentile": 0.2188}, "CVE-2025-14334": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14335": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14336": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14337": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14344": {"epss_score": 0.00182, "epss_percentile": 0.40201}, "CVE-2025-14345": {"epss_score": 0.00048, "epss_percentile": 0.15012}, "CVE-2025-14346": {"epss_score": 0.00092, "epss_percentile": 0.26559}, "CVE-2025-14347": {"epss_score": 0.00033, "epss_percentile": 0.09211}, "CVE-2025-14352": {"epss_score": 0.00034, "epss_percentile": 0.09483}, "CVE-2025-14354": {"epss_score": 0.00016, "epss_percentile": 0.02734}, "CVE-2025-14356": {"epss_score": 0.00035, "epss_percentile": 0.10052}, "CVE-2025-14358": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-14359": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-14360": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-14364": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-14365": {"epss_score": 0.00059, "epss_percentile": 0.18843}, "CVE-2025-14366": {"epss_score": 0.00059, "epss_percentile": 0.18843}, "CVE-2025-14367": {"epss_score": 0.00035, "epss_percentile": 0.09894}, "CVE-2025-14370": {"epss_score": 0.00028, "epss_percentile": 0.07353}, "CVE-2025-14371": {"epss_score": 0.00026, "epss_percentile": 0.06661}, "CVE-2025-14372": {"epss_score": 0.0004, "epss_percentile": 0.11893}, "CVE-2025-14373": {"epss_score": 0.0003, "epss_percentile": 0.08171}, "CVE-2025-14378": {"epss_score": 0.00029, "epss_percentile": 0.07612}, "CVE-2025-14383": {"epss_score": 0.00084, "epss_percentile": 0.25018}, "CVE-2025-14385": {"epss_score": 0.00036, "epss_percentile": 0.10508}, "CVE-2025-14387": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-14388": {"epss_score": 0.0007, "epss_percentile": 0.21774}, "CVE-2025-14390": {"epss_score": 0.00091, "epss_percentile": 0.26388}, "CVE-2025-14391": {"epss_score": 0.00014, "epss_percentile": 0.01936}, "CVE-2025-14392": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-14393": {"epss_score": 0.0004, "epss_percentile": 0.1216}, "CVE-2025-14394": {"epss_score": 0.00014, "epss_percentile": 0.01936}, "CVE-2025-14395": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-14397": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-14399": {"epss_score": 0.00014, "epss_percentile": 0.01936}, "CVE-2025-14401": {"epss_score": 0.0005, "epss_percentile": 0.15869}, "CVE-2025-14402": {"epss_score": 0.00066, "epss_percentile": 0.20865}, "CVE-2025-14403": {"epss_score": 0.00066, "epss_percentile": 0.20865}, "CVE-2025-14404": {"epss_score": 0.00066, "epss_percentile": 0.20865}, "CVE-2025-14405": {"epss_score": 0.0002, "epss_percentile": 0.04669}, "CVE-2025-14406": {"epss_score": 0.00016, "epss_percentile": 0.02724}, "CVE-2025-14407": {"epss_score": 0.00022, "epss_percentile": 0.05285}, "CVE-2025-14408": {"epss_score": 0.00022, "epss_percentile": 0.05285}, "CVE-2025-14409": {"epss_score": 0.00063, "epss_percentile": 0.19958}, "CVE-2025-14410": {"epss_score": 0.00022, "epss_percentile": 0.05285}, "CVE-2025-14411": {"epss_score": 0.00022, "epss_percentile": 0.05285}, "CVE-2025-14412": {"epss_score": 0.00066, "epss_percentile": 0.20865}, "CVE-2025-14413": {"epss_score": 0.00225, "epss_percentile": 0.45135}, "CVE-2025-14414": {"epss_score": 0.00066, "epss_percentile": 0.20865}, "CVE-2025-14415": {"epss_score": 0.00066, "epss_percentile": 0.20865}, "CVE-2025-14416": {"epss_score": 0.00066, "epss_percentile": 0.20865}, "CVE-2025-14417": {"epss_score": 0.00066, "epss_percentile": 0.20865}, "CVE-2025-14418": {"epss_score": 0.00066, "epss_percentile": 0.20865}, "CVE-2025-14419": {"epss_score": 0.0005, "epss_percentile": 0.15869}, "CVE-2025-14420": {"epss_score": 0.00225, "epss_percentile": 0.45135}, "CVE-2025-14421": {"epss_score": 0.00021, "epss_percentile": 0.04783}, "CVE-2025-14422": {"epss_score": 0.00068, "epss_percentile": 0.21348}, "CVE-2025-14423": {"epss_score": 0.00062, "epss_percentile": 0.19756}, "CVE-2025-14424": {"epss_score": 0.00068, "epss_percentile": 0.21348}, "CVE-2025-14425": {"epss_score": 0.00062, "epss_percentile": 0.19756}, "CVE-2025-14426": {"epss_score": 0.0003, "epss_percentile": 0.0803}, "CVE-2025-14428": {"epss_score": 0.00032, "epss_percentile": 0.08773}, "CVE-2025-14429": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-14430": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-14431": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-14432": {"epss_score": 0.00022, "epss_percentile": 0.05247}, "CVE-2025-14434": {"epss_score": 0.00056, "epss_percentile": 0.17718}, "CVE-2025-14437": {"epss_score": 0.00076, "epss_percentile": 0.23263}, "CVE-2025-14438": {"epss_score": 0.00028, "epss_percentile": 0.07526}, "CVE-2025-14440": {"epss_score": 0.00292, "epss_percentile": 0.52275}, "CVE-2025-14441": {"epss_score": 0.0003, "epss_percentile": 0.08207}, "CVE-2025-14442": {"epss_score": 0.0005, "epss_percentile": 0.15715}, "CVE-2025-14443": {"epss_score": 0.0004, "epss_percentile": 0.12081}, "CVE-2025-14446": {"epss_score": 0.00047, "epss_percentile": 0.14658}, "CVE-2025-14447": {"epss_score": 0.00035, "epss_percentile": 0.09894}, "CVE-2025-14449": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-14451": {"epss_score": 0.00027, "epss_percentile": 0.06844}, "CVE-2025-14453": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14454": {"epss_score": 0.00013, "epss_percentile": 0.01663}, "CVE-2025-14455": {"epss_score": 0.00043, "epss_percentile": 0.13018}, "CVE-2025-14460": {"epss_score": 0.00045, "epss_percentile": 0.13905}, "CVE-2025-14462": {"epss_score": 0.00014, "epss_percentile": 0.01936}, "CVE-2025-14465": {"epss_score": 0.00013, "epss_percentile": 0.01568}, "CVE-2025-14466": {"epss_score": 0.0012, "epss_percentile": 0.31756}, "CVE-2025-14467": {"epss_score": 0.00044, "epss_percentile": 0.13449}, "CVE-2025-14468": {"epss_score": 0.00024, "epss_percentile": 0.05735}, "CVE-2025-14475": {"epss_score": 0.00055, "epss_percentile": 0.17413}, "CVE-2025-14476": {"epss_score": 0.00085, "epss_percentile": 0.25093}, "CVE-2025-14477": {"epss_score": 0.00036, "epss_percentile": 0.1039}, "CVE-2025-14485": {"epss_score": 0.01258, "epss_percentile": 0.78958}, "CVE-2025-14488": {"epss_score": 0.00016, "epss_percentile": 0.03039}, "CVE-2025-14489": {"epss_score": 0.00016, "epss_percentile": 0.03039}, "CVE-2025-14490": {"epss_score": 0.00016, "epss_percentile": 0.03039}, "CVE-2025-14491": {"epss_score": 0.00016, "epss_percentile": 0.03039}, "CVE-2025-14492": {"epss_score": 0.00016, "epss_percentile": 0.03039}, "CVE-2025-14493": {"epss_score": 0.00016, "epss_percentile": 0.03039}, "CVE-2025-14494": {"epss_score": 0.00016, "epss_percentile": 0.03039}, "CVE-2025-14495": {"epss_score": 0.00016, "epss_percentile": 0.03039}, "CVE-2025-14496": {"epss_score": 0.00016, "epss_percentile": 0.03039}, "CVE-2025-14497": {"epss_score": 0.00016, "epss_percentile": 0.03039}, "CVE-2025-14498": {"epss_score": 0.00016, "epss_percentile": 0.02724}, "CVE-2025-14499": {"epss_score": 0.00176, "epss_percentile": 0.39483}, "CVE-2025-14500": {"epss_score": 0.01269, "epss_percentile": 0.7904}, "CVE-2025-14501": {"epss_score": 0.00502, "epss_percentile": 0.65376}, "CVE-2025-14503": {"epss_score": 0.00043, "epss_percentile": 0.1301}, "CVE-2025-14508": {"epss_score": 0.0003, "epss_percentile": 0.0803}, "CVE-2025-14509": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-14512": {"epss_score": 0.00037, "epss_percentile": 0.10741}, "CVE-2025-14514": {"epss_score": 0.00039, "epss_percentile": 0.11616}, "CVE-2025-14515": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14516": {"epss_score": 0.0004, "epss_percentile": 0.12152}, "CVE-2025-14517": {"epss_score": 0.00013, "epss_percentile": 0.01644}, "CVE-2025-14518": {"epss_score": 0.00036, "epss_percentile": 0.10607}, "CVE-2025-14519": {"epss_score": 0.00027, "epss_percentile": 0.06936}, "CVE-2025-14520": {"epss_score": 0.00051, "epss_percentile": 0.16018}, "CVE-2025-14521": {"epss_score": 0.00044, "epss_percentile": 0.13397}, "CVE-2025-14522": {"epss_score": 0.00038, "epss_percentile": 0.11127}, "CVE-2025-14523": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-14524": {"epss_score": 0.00016, "epss_percentile": 0.0296}, "CVE-2025-14526": {"epss_score": 0.00084, "epss_percentile": 0.24834}, "CVE-2025-14527": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14528": {"epss_score": 0.00055, "epss_percentile": 0.17372}, "CVE-2025-14529": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14530": {"epss_score": 0.00035, "epss_percentile": 0.10005}, "CVE-2025-14531": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2025-14534": {"epss_score": 0.00154, "epss_percentile": 0.36722}, "CVE-2025-14535": {"epss_score": 0.00154, "epss_percentile": 0.36722}, "CVE-2025-14536": {"epss_score": 0.00039, "epss_percentile": 0.11616}, "CVE-2025-14537": {"epss_score": 0.00039, "epss_percentile": 0.11616}, "CVE-2025-14538": {"epss_score": 0.00029, "epss_percentile": 0.07895}, "CVE-2025-14539": {"epss_score": 0.00114, "epss_percentile": 0.30763}, "CVE-2025-14540": {"epss_score": 0.00033, "epss_percentile": 0.09415}, "CVE-2025-14542": {"epss_score": 0.00042, "epss_percentile": 0.12912}, "CVE-2025-14546": {"epss_score": 0.00108, "epss_percentile": 0.29789}, "CVE-2025-14548": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-14549": {"epss_score": 0.00055, "epss_percentile": 0.17626}, "CVE-2025-14552": {"epss_score": 0.00029, "epss_percentile": 0.07681}, "CVE-2025-14553": {"epss_score": 0.00022, "epss_percentile": 0.05064}, "CVE-2025-14565": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14566": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14567": {"epss_score": 0.00139, "epss_percentile": 0.34639}, "CVE-2025-14568": {"epss_score": 0.00029, "epss_percentile": 0.0793}, "CVE-2025-14569": {"epss_score": 0.00014, "epss_percentile": 0.02077}, "CVE-2025-14570": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14571": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14572": {"epss_score": 0.00046, "epss_percentile": 0.14298}, "CVE-2025-14578": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14580": {"epss_score": 0.00025, "epss_percentile": 0.06056}, "CVE-2025-14581": {"epss_score": 0.00037, "epss_percentile": 0.10783}, "CVE-2025-14582": {"epss_score": 0.00041, "epss_percentile": 0.12291}, "CVE-2025-14583": {"epss_score": 0.00047, "epss_percentile": 0.14706}, "CVE-2025-14584": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14585": {"epss_score": 0.00043, "epss_percentile": 0.12961}, "CVE-2025-14586": {"epss_score": 0.01554, "epss_percentile": 0.81001}, "CVE-2025-14587": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14588": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14589": {"epss_score": 0.00028, "epss_percentile": 0.07444}, "CVE-2025-14590": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14591": {"epss_score": 0.00031, "epss_percentile": 0.08706}, "CVE-2025-14593": {"epss_score": 0.00023, "epss_percentile": 0.05457}, "CVE-2025-14596": {"epss_score": 0.00012, "epss_percentile": 0.01416}, "CVE-2025-14599": {"epss_score": 0.00012, "epss_percentile": 0.01416}, "CVE-2025-14605": {"epss_score": 0.00012, "epss_percentile": 0.01416}, "CVE-2025-14606": {"epss_score": 0.00045, "epss_percentile": 0.14039}, "CVE-2025-14607": {"epss_score": 0.00052, "epss_percentile": 0.16454}, "CVE-2025-14611": {"epss_score": 0.37829, "epss_percentile": 0.97072}, "CVE-2025-14612": {"epss_score": 0.00013, "epss_percentile": 0.01578}, "CVE-2025-14614": {"epss_score": 0.00013, "epss_percentile": 0.01578}, "CVE-2025-14617": {"epss_score": 0.00018, "epss_percentile": 0.03671}, "CVE-2025-14618": {"epss_score": 0.00028, "epss_percentile": 0.07326}, "CVE-2025-14619": {"epss_score": 0.00043, "epss_percentile": 0.12961}, "CVE-2025-14620": {"epss_score": 0.00043, "epss_percentile": 0.12961}, "CVE-2025-14621": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14622": {"epss_score": 0.00043, "epss_percentile": 0.12961}, "CVE-2025-14623": {"epss_score": 0.00043, "epss_percentile": 0.12961}, "CVE-2025-14625": {"epss_score": 0.00012, "epss_percentile": 0.01416}, "CVE-2025-14626": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14627": {"epss_score": 0.0003, "epss_percentile": 0.08026}, "CVE-2025-14631": {"epss_score": 0.00016, "epss_percentile": 0.0261}, "CVE-2025-14633": {"epss_score": 0.00048, "epss_percentile": 0.15081}, "CVE-2025-14635": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-14636": {"epss_score": 0.00043, "epss_percentile": 0.13024}, "CVE-2025-14637": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14638": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14639": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14640": {"epss_score": 0.00043, "epss_percentile": 0.12961}, "CVE-2025-14641": {"epss_score": 0.00035, "epss_percentile": 0.10005}, "CVE-2025-14642": {"epss_score": 0.00035, "epss_percentile": 0.10005}, "CVE-2025-14643": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14644": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14645": {"epss_score": 0.00043, "epss_percentile": 0.12961}, "CVE-2025-14646": {"epss_score": 0.00043, "epss_percentile": 0.12961}, "CVE-2025-14647": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14648": {"epss_score": 0.0021, "epss_percentile": 0.4343}, "CVE-2025-14649": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14650": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14651": {"epss_score": 0.00046, "epss_percentile": 0.14456}, "CVE-2025-14652": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14653": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14654": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2025-14655": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2025-14656": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2025-14659": {"epss_score": 0.00243, "epss_percentile": 0.47498}, "CVE-2025-14660": {"epss_score": 0.00058, "epss_percentile": 0.18422}, "CVE-2025-14661": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14662": {"epss_score": 0.00027, "epss_percentile": 0.06815}, "CVE-2025-14663": {"epss_score": 0.00026, "epss_percentile": 0.06444}, "CVE-2025-14664": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14665": {"epss_score": 0.00093, "epss_percentile": 0.26733}, "CVE-2025-14666": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14667": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14668": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14672": {"epss_score": 0.00048, "epss_percentile": 0.15225}, "CVE-2025-14673": {"epss_score": 0.00048, "epss_percentile": 0.15225}, "CVE-2025-14674": {"epss_score": 0.00058, "epss_percentile": 0.18408}, "CVE-2025-14687": {"epss_score": 0.00037, "epss_percentile": 0.10923}, "CVE-2025-14691": {"epss_score": 0.00094, "epss_percentile": 0.26979}, "CVE-2025-14692": {"epss_score": 0.00103, "epss_percentile": 0.29068}, "CVE-2025-14693": {"epss_score": 0.00018, "epss_percentile": 0.03741}, "CVE-2025-14694": {"epss_score": 0.00034, "epss_percentile": 0.09525}, "CVE-2025-14695": {"epss_score": 0.00041, "epss_percentile": 0.12312}, "CVE-2025-14696": {"epss_score": 0.0004, "epss_percentile": 0.11866}, "CVE-2025-14697": {"epss_score": 0.00042, "epss_percentile": 0.12609}, "CVE-2025-14698": {"epss_score": 0.0002, "epss_percentile": 0.04542}, "CVE-2025-14699": {"epss_score": 0.0002, "epss_percentile": 0.04532}, "CVE-2025-14700": {"epss_score": 0.00073, "epss_percentile": 0.22532}, "CVE-2025-14701": {"epss_score": 0.00049, "epss_percentile": 0.15447}, "CVE-2025-14702": {"epss_score": 0.0002, "epss_percentile": 0.04542}, "CVE-2025-14703": {"epss_score": 0.00102, "epss_percentile": 0.28859}, "CVE-2025-14704": {"epss_score": 0.00232, "epss_percentile": 0.45904}, "CVE-2025-14705": {"epss_score": 0.00812, "epss_percentile": 0.73753}, "CVE-2025-14706": {"epss_score": 0.00812, "epss_percentile": 0.73753}, "CVE-2025-14707": {"epss_score": 0.00812, "epss_percentile": 0.73753}, "CVE-2025-14708": {"epss_score": 0.00154, "epss_percentile": 0.36722}, "CVE-2025-14709": {"epss_score": 0.00154, "epss_percentile": 0.36722}, "CVE-2025-14710": {"epss_score": 0.00037, "epss_percentile": 0.10731}, "CVE-2025-14711": {"epss_score": 0.00044, "epss_percentile": 0.13442}, "CVE-2025-14712": {"epss_score": 0.00043, "epss_percentile": 0.13078}, "CVE-2025-14714": {"epss_score": 0.00016, "epss_percentile": 0.0267}, "CVE-2025-14719": {"epss_score": 0.00024, "epss_percentile": 0.05808}, "CVE-2025-14721": {"epss_score": 0.00035, "epss_percentile": 0.09946}, "CVE-2025-14722": {"epss_score": 0.0003, "epss_percentile": 0.08278}, "CVE-2025-14727": {"epss_score": 0.00117, "epss_percentile": 0.3131}, "CVE-2025-14728": {"epss_score": 0.00252, "epss_percentile": 0.48335}, "CVE-2025-14729": {"epss_score": 0.00043, "epss_percentile": 0.12956}, "CVE-2025-14730": {"epss_score": 0.00043, "epss_percentile": 0.12956}, "CVE-2025-14731": {"epss_score": 0.00053, "epss_percentile": 0.16832}, "CVE-2025-14733": {"epss_score": 0.36326, "epss_percentile": 0.96971}, "CVE-2025-14734": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2025-14735": {"epss_score": 0.00028, "epss_percentile": 0.07537}, "CVE-2025-14737": {"epss_score": 0.00851, "epss_percentile": 0.74403}, "CVE-2025-14738": {"epss_score": 0.00111, "epss_percentile": 0.30374}, "CVE-2025-14739": {"epss_score": 0.00018, "epss_percentile": 0.03873}, "CVE-2025-14744": {"epss_score": 0.00028, "epss_percentile": 0.07527}, "CVE-2025-14746": {"epss_score": 0.00069, "epss_percentile": 0.2143}, "CVE-2025-14747": {"epss_score": 0.00047, "epss_percentile": 0.1489}, "CVE-2025-14748": {"epss_score": 0.00099, "epss_percentile": 0.28315}, "CVE-2025-14749": {"epss_score": 0.00022, "epss_percentile": 0.05013}, "CVE-2025-14758": {"epss_score": 0.00019, "epss_percentile": 0.04229}, "CVE-2025-14759": {"epss_score": 8e-05, "epss_percentile": 0.0047}, "CVE-2025-14760": {"epss_score": 0.00013, "epss_percentile": 0.01445}, "CVE-2025-14761": {"epss_score": 0.00013, "epss_percentile": 0.01445}, "CVE-2025-14762": {"epss_score": 0.00013, "epss_percentile": 0.01445}, "CVE-2025-14763": {"epss_score": 8e-05, "epss_percentile": 0.0047}, "CVE-2025-14764": {"epss_score": 8e-05, "epss_percentile": 0.0047}, "CVE-2025-14765": {"epss_score": 0.00101, "epss_percentile": 0.28586}, "CVE-2025-14766": {"epss_score": 0.0008, "epss_percentile": 0.24198}, "CVE-2025-14777": {"epss_score": 0.00034, "epss_percentile": 0.09469}, "CVE-2025-14780": {"epss_score": 0.00029, "epss_percentile": 0.0793}, "CVE-2025-14783": {"epss_score": 0.00029, "epss_percentile": 0.07593}, "CVE-2025-14792": {"epss_score": 0.00027, "epss_percentile": 0.06767}, "CVE-2025-14796": {"epss_score": 0.00029, "epss_percentile": 0.07602}, "CVE-2025-14800": {"epss_score": 0.00039, "epss_percentile": 0.11467}, "CVE-2025-14801": {"epss_score": 0.0003, "epss_percentile": 0.08278}, "CVE-2025-14802": {"epss_score": 0.00031, "epss_percentile": 0.08322}, "CVE-2025-14804": {"epss_score": 0.00025, "epss_percentile": 0.06288}, "CVE-2025-14809": {"epss_score": 0.0003, "epss_percentile": 0.08267}, "CVE-2025-14812": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-14817": {"epss_score": 0.00032, "epss_percentile": 0.09021}, "CVE-2025-14819": {"epss_score": 0.00015, "epss_percentile": 0.02586}, "CVE-2025-14823": {"epss_score": 0.00029, "epss_percentile": 0.07617}, "CVE-2025-14830": {"epss_score": 0.0003, "epss_percentile": 0.08149}, "CVE-2025-14832": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14833": {"epss_score": 0.0003, "epss_percentile": 0.08255}, "CVE-2025-14834": {"epss_score": 0.00028, "epss_percentile": 0.07444}, "CVE-2025-14835": {"epss_score": 0.0008, "epss_percentile": 0.24201}, "CVE-2025-14836": {"epss_score": 0.00013, "epss_percentile": 0.01493}, "CVE-2025-14837": {"epss_score": 0.0005, "epss_percentile": 0.15784}, "CVE-2025-14841": {"epss_score": 0.00014, "epss_percentile": 0.02113}, "CVE-2025-14842": {"epss_score": 0.00039, "epss_percentile": 0.11465}, "CVE-2025-14845": {"epss_score": 0.00015, "epss_percentile": 0.02161}, "CVE-2025-14847": {"epss_score": 0.68325, "epss_percentile": 0.98542}, "CVE-2025-14848": {"epss_score": 0.0005, "epss_percentile": 0.15962}, "CVE-2025-14849": {"epss_score": 0.00055, "epss_percentile": 0.17616}, "CVE-2025-14850": {"epss_score": 0.00225, "epss_percentile": 0.45147}, "CVE-2025-14855": {"epss_score": 0.00108, "epss_percentile": 0.2984}, "CVE-2025-14856": {"epss_score": 0.00044, "epss_percentile": 0.13423}, "CVE-2025-14860": {"epss_score": 0.00059, "epss_percentile": 0.18851}, "CVE-2025-14861": {"epss_score": 0.00045, "epss_percentile": 0.13754}, "CVE-2025-14867": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-14874": {"epss_score": 0.00054, "epss_percentile": 0.17216}, "CVE-2025-14875": {"epss_score": 0.00074, "epss_percentile": 0.22811}, "CVE-2025-14877": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14878": {"epss_score": 0.00154, "epss_percentile": 0.36722}, "CVE-2025-14879": {"epss_score": 0.00154, "epss_percentile": 0.36722}, "CVE-2025-14881": {"epss_score": 0.00043, "epss_percentile": 0.13184}, "CVE-2025-14882": {"epss_score": 0.00043, "epss_percentile": 0.13184}, "CVE-2025-14884": {"epss_score": 0.00311, "epss_percentile": 0.53809}, "CVE-2025-14885": {"epss_score": 0.00036, "epss_percentile": 0.10389}, "CVE-2025-14887": {"epss_score": 0.00025, "epss_percentile": 0.06307}, "CVE-2025-14888": {"epss_score": 0.00027, "epss_percentile": 0.06767}, "CVE-2025-14889": {"epss_score": 0.00036, "epss_percentile": 0.10214}, "CVE-2025-14891": {"epss_score": 0.00195, "epss_percentile": 0.41687}, "CVE-2025-14896": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-14897": {"epss_score": 0.00027, "epss_percentile": 0.07113}, "CVE-2025-14898": {"epss_score": 0.00027, "epss_percentile": 0.07113}, "CVE-2025-14899": {"epss_score": 0.00027, "epss_percentile": 0.07113}, "CVE-2025-14900": {"epss_score": 0.00027, "epss_percentile": 0.07113}, "CVE-2025-14901": {"epss_score": 0.00095, "epss_percentile": 0.27108}, "CVE-2025-14904": {"epss_score": 0.00013, "epss_percentile": 0.01568}, "CVE-2025-14908": {"epss_score": 0.00113, "epss_percentile": 0.30609}, "CVE-2025-14909": {"epss_score": 0.00075, "epss_percentile": 0.23069}, "CVE-2025-14910": {"epss_score": 0.00043, "epss_percentile": 0.12976}, "CVE-2025-14913": {"epss_score": 0.00059, "epss_percentile": 0.18843}, "CVE-2025-14920": {"epss_score": 0.00223, "epss_percentile": 0.44872}, "CVE-2025-14921": {"epss_score": 0.00223, "epss_percentile": 0.44872}, "CVE-2025-14922": {"epss_score": 0.00223, "epss_percentile": 0.44872}, "CVE-2025-14924": {"epss_score": 0.00223, "epss_percentile": 0.44872}, "CVE-2025-14925": {"epss_score": 0.00223, "epss_percentile": 0.44872}, "CVE-2025-14926": {"epss_score": 0.00078, "epss_percentile": 0.23795}, "CVE-2025-14927": {"epss_score": 0.00078, "epss_percentile": 0.23795}, "CVE-2025-14928": {"epss_score": 0.00078, "epss_percentile": 0.23795}, "CVE-2025-14929": {"epss_score": 0.00223, "epss_percentile": 0.44872}, "CVE-2025-14930": {"epss_score": 0.00223, "epss_percentile": 0.44872}, "CVE-2025-14931": {"epss_score": 0.01667, "epss_percentile": 0.81655}, "CVE-2025-14932": {"epss_score": 0.00046, "epss_percentile": 0.14197}, "CVE-2025-14933": {"epss_score": 0.0005, "epss_percentile": 0.15869}, "CVE-2025-14934": {"epss_score": 0.00046, "epss_percentile": 0.14197}, "CVE-2025-14935": {"epss_score": 0.00046, "epss_percentile": 0.14197}, "CVE-2025-14936": {"epss_score": 0.00046, "epss_percentile": 0.14197}, "CVE-2025-14939": {"epss_score": 0.00027, "epss_percentile": 0.07113}, "CVE-2025-14940": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14942": {"epss_score": 0.00066, "epss_percentile": 0.20861}, "CVE-2025-14946": {"epss_score": 0.00019, "epss_percentile": 0.04231}, "CVE-2025-14950": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14951": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14952": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14953": {"epss_score": 0.00064, "epss_percentile": 0.20107}, "CVE-2025-14954": {"epss_score": 0.0009, "epss_percentile": 0.26151}, "CVE-2025-14955": {"epss_score": 0.00092, "epss_percentile": 0.26444}, "CVE-2025-14956": {"epss_score": 0.00025, "epss_percentile": 0.06308}, "CVE-2025-14957": {"epss_score": 0.00016, "epss_percentile": 0.0275}, "CVE-2025-14958": {"epss_score": 0.0002, "epss_percentile": 0.0449}, "CVE-2025-14959": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-14960": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-14961": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-14962": {"epss_score": 0.00026, "epss_percentile": 0.06426}, "CVE-2025-14964": {"epss_score": 0.00273, "epss_percentile": 0.50468}, "CVE-2025-14965": {"epss_score": 0.00038, "epss_percentile": 0.11072}, "CVE-2025-14966": {"epss_score": 0.00043, "epss_percentile": 0.13007}, "CVE-2025-14967": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14968": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-14979": {"epss_score": 0.00012, "epss_percentile": 0.01246}, "CVE-2025-14984": {"epss_score": 0.00042, "epss_percentile": 0.12586}, "CVE-2025-14986": {"epss_score": 0.00056, "epss_percentile": 0.17804}, "CVE-2025-14987": {"epss_score": 0.00056, "epss_percentile": 0.17804}, "CVE-2025-14989": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-14990": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-14991": {"epss_score": 0.00024, "epss_percentile": 0.0566}, "CVE-2025-14992": {"epss_score": 0.00084, "epss_percentile": 0.24834}, "CVE-2025-14993": {"epss_score": 0.00084, "epss_percentile": 0.24834}, "CVE-2025-14994": {"epss_score": 0.00098, "epss_percentile": 0.27782}, "CVE-2025-14995": {"epss_score": 0.00084, "epss_percentile": 0.24834}, "CVE-2025-14996": {"epss_score": 0.00074, "epss_percentile": 0.22729}, "CVE-2025-14997": {"epss_score": 0.00465, "epss_percentile": 0.63753}, "CVE-2025-14998": {"epss_score": 0.00092, "epss_percentile": 0.26468}, "CVE-2025-14999": {"epss_score": 0.00013, "epss_percentile": 0.01568}, "CVE-2025-15000": {"epss_score": 0.00027, "epss_percentile": 0.06767}, "CVE-2025-15001": {"epss_score": 0.0007, "epss_percentile": 0.2169}, "CVE-2025-15002": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15003": {"epss_score": 0.00027, "epss_percentile": 0.07113}, "CVE-2025-15004": {"epss_score": 0.00031, "epss_percentile": 0.08551}, "CVE-2025-15005": {"epss_score": 0.00033, "epss_percentile": 0.09292}, "CVE-2025-15006": {"epss_score": 0.00093, "epss_percentile": 0.26733}, "CVE-2025-15007": {"epss_score": 0.00093, "epss_percentile": 0.26733}, "CVE-2025-15008": {"epss_score": 0.00054, "epss_percentile": 0.17278}, "CVE-2025-15009": {"epss_score": 0.00036, "epss_percentile": 0.10389}, "CVE-2025-15010": {"epss_score": 0.00093, "epss_percentile": 0.26733}, "CVE-2025-15011": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15012": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15013": {"epss_score": 0.00014, "epss_percentile": 0.02092}, "CVE-2025-15014": {"epss_score": 0.00029, "epss_percentile": 0.0793}, "CVE-2025-15015": {"epss_score": 0.00086, "epss_percentile": 0.25402}, "CVE-2025-15016": {"epss_score": 0.00111, "epss_percentile": 0.3032}, "CVE-2025-15017": {"epss_score": 0.00045, "epss_percentile": 0.13963}, "CVE-2025-15018": {"epss_score": 0.00074, "epss_percentile": 0.22729}, "CVE-2025-15022": {"epss_score": 0.00047, "epss_percentile": 0.1458}, "CVE-2025-15026": {"epss_score": 0.00025, "epss_percentile": 0.06291}, "CVE-2025-15029": {"epss_score": 0.00022, "epss_percentile": 0.05182}, "CVE-2025-15033": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-15034": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15044": {"epss_score": 0.00093, "epss_percentile": 0.26733}, "CVE-2025-15045": {"epss_score": 0.00093, "epss_percentile": 0.26733}, "CVE-2025-15046": {"epss_score": 0.00093, "epss_percentile": 0.26733}, "CVE-2025-15047": {"epss_score": 0.00093, "epss_percentile": 0.26733}, "CVE-2025-15048": {"epss_score": 0.00574, "epss_percentile": 0.68086}, "CVE-2025-15049": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-15050": {"epss_score": 0.00052, "epss_percentile": 0.16507}, "CVE-2025-15052": {"epss_score": 0.00032, "epss_percentile": 0.08963}, "CVE-2025-15053": {"epss_score": 0.00036, "epss_percentile": 0.10501}, "CVE-2025-15058": {"epss_score": 0.00029, "epss_percentile": 0.07681}, "CVE-2025-15065": {"epss_score": 4e-05, "epss_percentile": 0.0014}, "CVE-2025-15066": {"epss_score": 0.00018, "epss_percentile": 0.04026}, "CVE-2025-15067": {"epss_score": 0.00016, "epss_percentile": 0.02956}, "CVE-2025-15068": {"epss_score": 0.00031, "epss_percentile": 0.08577}, "CVE-2025-15069": {"epss_score": 0.00031, "epss_percentile": 0.08516}, "CVE-2025-15070": {"epss_score": 0.00031, "epss_percentile": 0.08693}, "CVE-2025-15073": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-15074": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-15075": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-15076": {"epss_score": 0.00212, "epss_percentile": 0.43726}, "CVE-2025-15077": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-15078": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-15079": {"epss_score": 0.00016, "epss_percentile": 0.0296}, "CVE-2025-15081": {"epss_score": 0.01409, "epss_percentile": 0.80071}, "CVE-2025-15082": {"epss_score": 0.00042, "epss_percentile": 0.12609}, "CVE-2025-15083": {"epss_score": 0.00016, "epss_percentile": 0.02854}, "CVE-2025-15084": {"epss_score": 0.00034, "epss_percentile": 0.09789}, "CVE-2025-15085": {"epss_score": 0.00029, "epss_percentile": 0.07767}, "CVE-2025-15086": {"epss_score": 0.00026, "epss_percentile": 0.06524}, "CVE-2025-15087": {"epss_score": 0.00034, "epss_percentile": 0.09789}, "CVE-2025-15088": {"epss_score": 0.00031, "epss_percentile": 0.08689}, "CVE-2025-15089": {"epss_score": 0.00119, "epss_percentile": 0.3168}, "CVE-2025-15090": {"epss_score": 0.00119, "epss_percentile": 0.3168}, "CVE-2025-15091": {"epss_score": 0.00119, "epss_percentile": 0.3168}, "CVE-2025-15092": {"epss_score": 0.00119, "epss_percentile": 0.3168}, "CVE-2025-15093": {"epss_score": 0.00024, "epss_percentile": 0.05806}, "CVE-2025-15094": {"epss_score": 0.00024, "epss_percentile": 0.05806}, "CVE-2025-15095": {"epss_score": 0.00029, "epss_percentile": 0.07895}, "CVE-2025-15097": {"epss_score": 0.00116, "epss_percentile": 0.31181}, "CVE-2025-15098": {"epss_score": 0.0004, "epss_percentile": 0.12152}, "CVE-2025-15099": {"epss_score": 0.00116, "epss_percentile": 0.31181}, "CVE-2025-15102": {"epss_score": 0.00058, "epss_percentile": 0.18261}, "CVE-2025-15103": {"epss_score": 0.00093, "epss_percentile": 0.26674}, "CVE-2025-15105": {"epss_score": 0.00034, "epss_percentile": 0.09747}, "CVE-2025-15106": {"epss_score": 0.00072, "epss_percentile": 0.22426}, "CVE-2025-15107": {"epss_score": 0.00032, "epss_percentile": 0.08763}, "CVE-2025-15108": {"epss_score": 0.00039, "epss_percentile": 0.11623}, "CVE-2025-15109": {"epss_score": 0.0005, "epss_percentile": 0.1573}, "CVE-2025-15110": {"epss_score": 0.00043, "epss_percentile": 0.13306}, "CVE-2025-15111": {"epss_score": 0.00041, "epss_percentile": 0.12345}, "CVE-2025-15112": {"epss_score": 0.00036, "epss_percentile": 0.10281}, "CVE-2025-15113": {"epss_score": 0.00049, "epss_percentile": 0.15468}, "CVE-2025-15114": {"epss_score": 0.0011, "epss_percentile": 0.30186}, "CVE-2025-15115": {"epss_score": 0.00105, "epss_percentile": 0.2928}, "CVE-2025-15116": {"epss_score": 0.00037, "epss_percentile": 0.10739}, "CVE-2025-15117": {"epss_score": 0.00046, "epss_percentile": 0.14077}, "CVE-2025-15118": {"epss_score": 0.00034, "epss_percentile": 0.09789}, "CVE-2025-15119": {"epss_score": 0.00026, "epss_percentile": 0.06524}, "CVE-2025-15120": {"epss_score": 0.00026, "epss_percentile": 0.06524}, "CVE-2025-15121": {"epss_score": 0.00031, "epss_percentile": 0.08449}, "CVE-2025-15122": {"epss_score": 0.00026, "epss_percentile": 0.06524}, "CVE-2025-15123": {"epss_score": 0.00026, "epss_percentile": 0.06524}, "CVE-2025-15124": {"epss_score": 0.00026, "epss_percentile": 0.06524}, "CVE-2025-15125": {"epss_score": 0.00026, "epss_percentile": 0.06524}, "CVE-2025-15126": {"epss_score": 0.00028, "epss_percentile": 0.0724}, "CVE-2025-15127": {"epss_score": 0.00037, "epss_percentile": 0.10731}, "CVE-2025-15128": {"epss_score": 0.00022, "epss_percentile": 0.05264}, "CVE-2025-15129": {"epss_score": 0.00046, "epss_percentile": 0.14136}, "CVE-2025-15130": {"epss_score": 0.00053, "epss_percentile": 0.16677}, "CVE-2025-15131": {"epss_score": 0.00351, "epss_percentile": 0.57012}, "CVE-2025-15132": {"epss_score": 0.00351, "epss_percentile": 0.57012}, "CVE-2025-15133": {"epss_score": 0.00351, "epss_percentile": 0.57012}, "CVE-2025-15134": {"epss_score": 0.00031, "epss_percentile": 0.08662}, "CVE-2025-15135": {"epss_score": 0.00074, "epss_percentile": 0.22774}, "CVE-2025-15136": {"epss_score": 0.00551, "epss_percentile": 0.67362}, "CVE-2025-15137": {"epss_score": 0.00551, "epss_percentile": 0.67362}, "CVE-2025-15138": {"epss_score": 0.00156, "epss_percentile": 0.36985}, "CVE-2025-15139": {"epss_score": 0.00351, "epss_percentile": 0.57012}, "CVE-2025-15140": {"epss_score": 0.00039, "epss_percentile": 0.11772}, "CVE-2025-15141": {"epss_score": 0.00028, "epss_percentile": 0.07342}, "CVE-2025-15142": {"epss_score": 0.00037, "epss_percentile": 0.10731}, "CVE-2025-15143": {"epss_score": 0.00027, "epss_percentile": 0.07113}, "CVE-2025-15144": {"epss_score": 0.00028, "epss_percentile": 0.07245}, "CVE-2025-15145": {"epss_score": 0.00024, "epss_percentile": 0.0566}, "CVE-2025-15146": {"epss_score": 0.00024, "epss_percentile": 0.0566}, "CVE-2025-15148": {"epss_score": 0.00043, "epss_percentile": 0.12956}, "CVE-2025-15149": {"epss_score": 0.0003, "epss_percentile": 0.08278}, "CVE-2025-15150": {"epss_score": 0.00021, "epss_percentile": 0.04871}, "CVE-2025-15151": {"epss_score": 0.00039, "epss_percentile": 0.11623}, "CVE-2025-15152": {"epss_score": 0.00038, "epss_percentile": 0.11127}, "CVE-2025-15153": {"epss_score": 0.00035, "epss_percentile": 0.10132}, "CVE-2025-15154": {"epss_score": 0.00038, "epss_percentile": 0.11212}, "CVE-2025-15155": {"epss_score": 0.0002, "epss_percentile": 0.0449}, "CVE-2025-15156": {"epss_score": 0.00041, "epss_percentile": 0.12379}, "CVE-2025-15158": {"epss_score": 0.00209, "epss_percentile": 0.43377}, "CVE-2025-15160": {"epss_score": 0.00094, "epss_percentile": 0.26978}, "CVE-2025-15161": {"epss_score": 0.00094, "epss_percentile": 0.26978}, "CVE-2025-15162": {"epss_score": 0.00094, "epss_percentile": 0.26978}, "CVE-2025-15163": {"epss_score": 0.00094, "epss_percentile": 0.26978}, "CVE-2025-15164": {"epss_score": 0.00094, "epss_percentile": 0.26978}, "CVE-2025-15165": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-15166": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-15167": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-15168": {"epss_score": 0.00039, "epss_percentile": 0.11772}, "CVE-2025-15169": {"epss_score": 0.00027, "epss_percentile": 0.07113}, "CVE-2025-15170": {"epss_score": 0.00027, "epss_percentile": 0.06935}, "CVE-2025-15171": {"epss_score": 0.00024, "epss_percentile": 0.05796}, "CVE-2025-15172": {"epss_score": 0.00024, "epss_percentile": 0.05796}, "CVE-2025-15173": {"epss_score": 0.00024, "epss_percentile": 0.05796}, "CVE-2025-15174": {"epss_score": 0.00024, "epss_percentile": 0.05796}, "CVE-2025-15175": {"epss_score": 0.00039, "epss_percentile": 0.11659}, "CVE-2025-15176": {"epss_score": 0.00086, "epss_percentile": 0.25273}, "CVE-2025-15177": {"epss_score": 0.00085, "epss_percentile": 0.25237}, "CVE-2025-15178": {"epss_score": 0.00085, "epss_percentile": 0.25237}, "CVE-2025-15179": {"epss_score": 0.00085, "epss_percentile": 0.25237}, "CVE-2025-15180": {"epss_score": 0.001, "epss_percentile": 0.28547}, "CVE-2025-15181": {"epss_score": 0.00043, "epss_percentile": 0.12961}, "CVE-2025-15182": {"epss_score": 0.00032, "epss_percentile": 0.08737}, "CVE-2025-15183": {"epss_score": 0.00045, "epss_percentile": 0.14038}, "CVE-2025-15184": {"epss_score": 0.00032, "epss_percentile": 0.08737}, "CVE-2025-15185": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-15186": {"epss_score": 0.00043, "epss_percentile": 0.12961}, "CVE-2025-15187": {"epss_score": 0.00067, "epss_percentile": 0.21175}, "CVE-2025-15188": {"epss_score": 0.00026, "epss_percentile": 0.06444}, "CVE-2025-15189": {"epss_score": 0.00066, "epss_percentile": 0.20748}, "CVE-2025-15190": {"epss_score": 0.00066, "epss_percentile": 0.20748}, "CVE-2025-15191": {"epss_score": 0.0018, "epss_percentile": 0.39914}, "CVE-2025-15192": {"epss_score": 0.0018, "epss_percentile": 0.39914}, "CVE-2025-15193": {"epss_score": 0.00066, "epss_percentile": 0.20748}, "CVE-2025-15194": {"epss_score": 0.00151, "epss_percentile": 0.3626}, "CVE-2025-15195": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15196": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15197": {"epss_score": 0.00035, "epss_percentile": 0.10005}, "CVE-2025-15198": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15199": {"epss_score": 0.00037, "epss_percentile": 0.1089}, "CVE-2025-15200": {"epss_score": 0.00038, "epss_percentile": 0.11414}, "CVE-2025-15201": {"epss_score": 0.00023, "epss_percentile": 0.05639}, "CVE-2025-15202": {"epss_score": 0.00022, "epss_percentile": 0.05131}, "CVE-2025-15203": {"epss_score": 0.00022, "epss_percentile": 0.05131}, "CVE-2025-15204": {"epss_score": 0.00022, "epss_percentile": 0.05131}, "CVE-2025-15205": {"epss_score": 0.00028, "epss_percentile": 0.07444}, "CVE-2025-15206": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15207": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15208": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15209": {"epss_score": 0.00038, "epss_percentile": 0.11236}, "CVE-2025-15210": {"epss_score": 0.00028, "epss_percentile": 0.07444}, "CVE-2025-15211": {"epss_score": 0.00028, "epss_percentile": 0.07444}, "CVE-2025-15212": {"epss_score": 0.00038, "epss_percentile": 0.11236}, "CVE-2025-15213": {"epss_score": 0.00026, "epss_percentile": 0.06677}, "CVE-2025-15214": {"epss_score": 0.00035, "epss_percentile": 0.0983}, "CVE-2025-15215": {"epss_score": 0.00049, "epss_percentile": 0.15579}, "CVE-2025-15216": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2025-15217": {"epss_score": 0.00084, "epss_percentile": 0.24834}, "CVE-2025-15218": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2025-15219": {"epss_score": 0.00039, "epss_percentile": 0.11659}, "CVE-2025-15220": {"epss_score": 0.00024, "epss_percentile": 0.05806}, "CVE-2025-15221": {"epss_score": 0.00023, "epss_percentile": 0.05639}, "CVE-2025-15222": {"epss_score": 0.00045, "epss_percentile": 0.14039}, "CVE-2025-15223": {"epss_score": 0.00033, "epss_percentile": 0.09327}, "CVE-2025-15224": {"epss_score": 0.00033, "epss_percentile": 0.09335}, "CVE-2025-15225": {"epss_score": 0.0009, "epss_percentile": 0.26031}, "CVE-2025-15226": {"epss_score": 0.00262, "epss_percentile": 0.49367}, "CVE-2025-15227": {"epss_score": 0.00094, "epss_percentile": 0.2707}, "CVE-2025-15228": {"epss_score": 0.00262, "epss_percentile": 0.49367}, "CVE-2025-15229": {"epss_score": 0.00089, "epss_percentile": 0.25961}, "CVE-2025-15230": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2025-15231": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2025-15232": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2025-15233": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2025-15234": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2025-15235": {"epss_score": 0.00038, "epss_percentile": 0.11395}, "CVE-2025-15236": {"epss_score": 0.00044, "epss_percentile": 0.13418}, "CVE-2025-15237": {"epss_score": 0.00044, "epss_percentile": 0.13418}, "CVE-2025-15238": {"epss_score": 0.00035, "epss_percentile": 0.10044}, "CVE-2025-15239": {"epss_score": 0.00035, "epss_percentile": 0.10044}, "CVE-2025-15240": {"epss_score": 0.00209, "epss_percentile": 0.43377}, "CVE-2025-15241": {"epss_score": 0.0003, "epss_percentile": 0.08281}, "CVE-2025-15242": {"epss_score": 0.00039, "epss_percentile": 0.11768}, "CVE-2025-15243": {"epss_score": 0.00029, "epss_percentile": 0.07633}, "CVE-2025-15244": {"epss_score": 0.00108, "epss_percentile": 0.29892}, "CVE-2025-15245": {"epss_score": 0.00075, "epss_percentile": 0.2297}, "CVE-2025-15246": {"epss_score": 0.00043, "epss_percentile": 0.13014}, "CVE-2025-15247": {"epss_score": 0.00048, "epss_percentile": 0.15225}, "CVE-2025-15248": {"epss_score": 0.00028, "epss_percentile": 0.07232}, "CVE-2025-15249": {"epss_score": 0.00028, "epss_percentile": 0.07232}, "CVE-2025-15250": {"epss_score": 0.00049, "epss_percentile": 0.15625}, "CVE-2025-15251": {"epss_score": 0.00058, "epss_percentile": 0.18483}, "CVE-2025-15252": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2025-15253": {"epss_score": 0.00079, "epss_percentile": 0.24005}, "CVE-2025-15254": {"epss_score": 0.00839, "epss_percentile": 0.74192}, "CVE-2025-15255": {"epss_score": 0.00181, "epss_percentile": 0.40107}, "CVE-2025-15256": {"epss_score": 0.02177, "epss_percentile": 0.83887}, "CVE-2025-15257": {"epss_score": 0.0214, "epss_percentile": 0.83747}, "CVE-2025-15258": {"epss_score": 0.00026, "epss_percentile": 0.06395}, "CVE-2025-15262": {"epss_score": 0.00043, "epss_percentile": 0.13306}, "CVE-2025-15263": {"epss_score": 0.00037, "epss_percentile": 0.10731}, "CVE-2025-15264": {"epss_score": 0.0004, "epss_percentile": 0.11954}, "CVE-2025-15269": {"epss_score": 0.00396, "epss_percentile": 0.59852}, "CVE-2025-15270": {"epss_score": 0.00396, "epss_percentile": 0.59852}, "CVE-2025-15271": {"epss_score": 0.00396, "epss_percentile": 0.59852}, "CVE-2025-15272": {"epss_score": 0.00353, "epss_percentile": 0.57188}, "CVE-2025-15273": {"epss_score": 0.00353, "epss_percentile": 0.57188}, "CVE-2025-15274": {"epss_score": 0.00353, "epss_percentile": 0.57188}, "CVE-2025-15275": {"epss_score": 0.00353, "epss_percentile": 0.57188}, "CVE-2025-15276": {"epss_score": 0.00223, "epss_percentile": 0.44872}, "CVE-2025-15277": {"epss_score": 0.00046, "epss_percentile": 0.14197}, "CVE-2025-15278": {"epss_score": 0.0005, "epss_percentile": 0.15869}, "CVE-2025-15279": {"epss_score": 0.00046, "epss_percentile": 0.14197}, "CVE-2025-15280": {"epss_score": 0.00396, "epss_percentile": 0.59852}, "CVE-2025-15284": {"epss_score": 0.00152, "epss_percentile": 0.36378}, "CVE-2025-15346": {"epss_score": 0.00057, "epss_percentile": 0.18166}, "CVE-2025-15353": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15354": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15355": {"epss_score": 0.00043, "epss_percentile": 0.13268}, "CVE-2025-15356": {"epss_score": 0.00084, "epss_percentile": 0.24834}, "CVE-2025-15357": {"epss_score": 0.00836, "epss_percentile": 0.74143}, "CVE-2025-15358": {"epss_score": 0.00101, "epss_percentile": 0.28701}, "CVE-2025-15359": {"epss_score": 0.00059, "epss_percentile": 0.18851}, "CVE-2025-15360": {"epss_score": 0.00043, "epss_percentile": 0.13306}, "CVE-2025-15364": {"epss_score": 0.00025, "epss_percentile": 0.0633}, "CVE-2025-15371": {"epss_score": 0.00011, "epss_percentile": 0.01067}, "CVE-2025-15372": {"epss_score": 0.00032, "epss_percentile": 0.09117}, "CVE-2025-15373": {"epss_score": 0.00026, "epss_percentile": 0.06677}, "CVE-2025-15374": {"epss_score": 0.00028, "epss_percentile": 0.07233}, "CVE-2025-15375": {"epss_score": 0.00043, "epss_percentile": 0.13331}, "CVE-2025-15382": {"epss_score": 0.00146, "epss_percentile": 0.35599}, "CVE-2025-15385": {"epss_score": 0.00019, "epss_percentile": 0.04331}, "CVE-2025-15387": {"epss_score": 0.00086, "epss_percentile": 0.25387}, "CVE-2025-15388": {"epss_score": 0.0039, "epss_percentile": 0.59529}, "CVE-2025-15389": {"epss_score": 0.0039, "epss_percentile": 0.59529}, "CVE-2025-15390": {"epss_score": 0.0004, "epss_percentile": 0.12152}, "CVE-2025-15391": {"epss_score": 0.00836, "epss_percentile": 0.74143}, "CVE-2025-15392": {"epss_score": 0.00028, "epss_percentile": 0.07258}, "CVE-2025-15393": {"epss_score": 0.00047, "epss_percentile": 0.14793}, "CVE-2025-15394": {"epss_score": 0.00053, "epss_percentile": 0.16677}, "CVE-2025-15398": {"epss_score": 0.00042, "epss_percentile": 0.12609}, "CVE-2025-15404": {"epss_score": 0.00036, "epss_percentile": 0.10389}, "CVE-2025-15405": {"epss_score": 0.00016, "epss_percentile": 0.02728}, "CVE-2025-15406": {"epss_score": 0.00036, "epss_percentile": 0.10389}, "CVE-2025-15407": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15408": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15409": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15410": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15411": {"epss_score": 0.00027, "epss_percentile": 0.06806}, "CVE-2025-15412": {"epss_score": 0.00023, "epss_percentile": 0.05387}, "CVE-2025-15413": {"epss_score": 0.00017, "epss_percentile": 0.03215}, "CVE-2025-15414": {"epss_score": 0.00046, "epss_percentile": 0.14414}, "CVE-2025-15415": {"epss_score": 0.00043, "epss_percentile": 0.13306}, "CVE-2025-15416": {"epss_score": 0.0003, "epss_percentile": 0.08278}, "CVE-2025-15417": {"epss_score": 0.00019, "epss_percentile": 0.04368}, "CVE-2025-15418": {"epss_score": 0.00019, "epss_percentile": 0.04368}, "CVE-2025-15419": {"epss_score": 0.00019, "epss_percentile": 0.04368}, "CVE-2025-15420": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15421": {"epss_score": 0.00039, "epss_percentile": 0.11772}, "CVE-2025-15422": {"epss_score": 0.00136, "epss_percentile": 0.34145}, "CVE-2025-15423": {"epss_score": 0.00036, "epss_percentile": 0.10389}, "CVE-2025-15424": {"epss_score": 0.00044, "epss_percentile": 0.13442}, "CVE-2025-15425": {"epss_score": 0.00039, "epss_percentile": 0.11772}, "CVE-2025-15426": {"epss_score": 0.00053, "epss_percentile": 0.16981}, "CVE-2025-15427": {"epss_score": 0.00037, "epss_percentile": 0.10731}, "CVE-2025-15428": {"epss_score": 0.00048, "epss_percentile": 0.1527}, "CVE-2025-15429": {"epss_score": 0.00048, "epss_percentile": 0.1527}, "CVE-2025-15430": {"epss_score": 0.00048, "epss_percentile": 0.1527}, "CVE-2025-15431": {"epss_score": 0.00048, "epss_percentile": 0.1527}, "CVE-2025-15432": {"epss_score": 0.00053, "epss_percentile": 0.17033}, "CVE-2025-15434": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15435": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15436": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2025-15437": {"epss_score": 0.00035, "epss_percentile": 0.09909}, "CVE-2025-15438": {"epss_score": 0.00047, "epss_percentile": 0.1459}, "CVE-2025-15439": {"epss_score": 0.00031, "epss_percentile": 0.08689}, "CVE-2025-15442": {"epss_score": 0.00027, "epss_percentile": 0.07174}, "CVE-2025-15443": {"epss_score": 0.00027, "epss_percentile": 0.07174}, "CVE-2025-15444": {"epss_score": 0.0004, "epss_percentile": 0.12165}, "CVE-2025-15446": {"epss_score": 0.00028, "epss_percentile": 0.07358}, "CVE-2025-15447": {"epss_score": 0.00028, "epss_percentile": 0.07358}, "CVE-2025-15448": {"epss_score": 0.00034, "epss_percentile": 0.09518}, "CVE-2025-15449": {"epss_score": 0.00045, "epss_percentile": 0.13964}, "CVE-2025-15450": {"epss_score": 0.00028, "epss_percentile": 0.0744}, "CVE-2025-15451": {"epss_score": 0.00028, "epss_percentile": 0.07365}, "CVE-2025-15452": {"epss_score": 0.00028, "epss_percentile": 0.07365}, "CVE-2025-15453": {"epss_score": 0.00051, "epss_percentile": 0.16297}, "CVE-2025-15454": {"epss_score": 0.00036, "epss_percentile": 0.10544}, "CVE-2025-15455": {"epss_score": 0.00106, "epss_percentile": 0.29426}, "CVE-2025-15456": {"epss_score": 0.00082, "epss_percentile": 0.24458}, "CVE-2025-15457": {"epss_score": 0.00082, "epss_percentile": 0.24458}, "CVE-2025-15458": {"epss_score": 0.00082, "epss_percentile": 0.24458}, "CVE-2025-15459": {"epss_score": 0.00043, "epss_percentile": 0.1329}, "CVE-2025-15460": {"epss_score": 0.00025, "epss_percentile": 0.0636}, "CVE-2025-15461": {"epss_score": 0.00043, "epss_percentile": 0.1329}, "CVE-2025-15462": {"epss_score": 0.00043, "epss_percentile": 0.1329}, "CVE-2025-15471": {"epss_score": 0.00153, "epss_percentile": 0.36571}, "CVE-2025-15472": {"epss_score": 0.00123, "epss_percentile": 0.32208}, "CVE-2025-15474": {"epss_score": 0.00041, "epss_percentile": 0.12381}, "CVE-2025-15479": {"epss_score": 0.0015, "epss_percentile": 0.36152}, "CVE-2025-1000": {"epss_score": 0.00044, "epss_percentile": 0.13437}, "CVE-2025-1001": {"epss_score": 9e-05, "epss_percentile": 0.00658}, "CVE-2025-1002": {"epss_score": 0.00019, "epss_percentile": 0.04146}, "CVE-2025-1003": {"epss_score": 0.00041, "epss_percentile": 0.1229}, "CVE-2025-1004": {"epss_score": 0.00152, "epss_percentile": 0.3637}, "CVE-2025-1005": {"epss_score": 0.001, "epss_percentile": 0.2844}, "CVE-2025-1006": {"epss_score": 0.00259, "epss_percentile": 0.49056}, "CVE-2025-1007": {"epss_score": 0.00134, "epss_percentile": 0.33909}, "CVE-2025-1008": {"epss_score": 0.00119, "epss_percentile": 0.31548}, "CVE-2025-1009": {"epss_score": 0.01004, "epss_percentile": 0.76525}, "CVE-2025-1010": {"epss_score": 0.00588, "epss_percentile": 0.68509}, "CVE-2025-1011": {"epss_score": 0.00323, "epss_percentile": 0.54917}, "CVE-2025-1012": {"epss_score": 0.00729, "epss_percentile": 0.72139}, "CVE-2025-1013": {"epss_score": 0.00362, "epss_percentile": 0.57819}, "CVE-2025-1014": {"epss_score": 0.00191, "epss_percentile": 0.41215}, "CVE-2025-1015": {"epss_score": 0.29013, "epss_percentile": 0.9641}, "CVE-2025-1016": {"epss_score": 0.00755, "epss_percentile": 0.72713}, "CVE-2025-1017": {"epss_score": 0.00755, "epss_percentile": 0.72713}, "CVE-2025-1018": {"epss_score": 0.00109, "epss_percentile": 0.2997}, "CVE-2025-1019": {"epss_score": 0.00116, "epss_percentile": 0.31155}, "CVE-2025-1020": {"epss_score": 0.00519, "epss_percentile": 0.66165}, "CVE-2025-1021": {"epss_score": 0.00091, "epss_percentile": 0.26273}, "CVE-2025-1022": {"epss_score": 0.00236, "epss_percentile": 0.46408}, "CVE-2025-1023": {"epss_score": 0.00926, "epss_percentile": 0.7555}, "CVE-2025-1024": {"epss_score": 0.00147, "epss_percentile": 0.35742}, "CVE-2025-1025": {"epss_score": 0.06605, "epss_percentile": 0.90882}, "CVE-2025-1026": {"epss_score": 0.0021, "epss_percentile": 0.43445}, "CVE-2025-1028": {"epss_score": 0.01618, "epss_percentile": 0.81371}, "CVE-2025-1029": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-1030": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-1031": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-1033": {"epss_score": 0.00024, "epss_percentile": 0.05795}, "CVE-2025-1035": {"epss_score": 0.23682, "epss_percentile": 0.95803}, "CVE-2025-1036": {"epss_score": 0.0075, "epss_percentile": 0.7262}, "CVE-2025-1037": {"epss_score": 0.00028, "epss_percentile": 0.07276}, "CVE-2025-1038": {"epss_score": 0.00065, "epss_percentile": 0.20439}, "CVE-2025-1039": {"epss_score": 0.00375, "epss_percentile": 0.58619}, "CVE-2025-1040": {"epss_score": 0.01614, "epss_percentile": 0.81344}, "CVE-2025-1041": {"epss_score": 0.00109, "epss_percentile": 0.3003}, "CVE-2025-1042": {"epss_score": 0.00056, "epss_percentile": 0.17948}, "CVE-2025-1043": {"epss_score": 0.00098, "epss_percentile": 0.27641}, "CVE-2025-1044": {"epss_score": 0.01157, "epss_percentile": 0.78115}, "CVE-2025-1045": {"epss_score": 0.00059, "epss_percentile": 0.18714}, "CVE-2025-1046": {"epss_score": 0.00064, "epss_percentile": 0.20392}, "CVE-2025-1047": {"epss_score": 0.00064, "epss_percentile": 0.20392}, "CVE-2025-1048": {"epss_score": 0.00078, "epss_percentile": 0.23634}, "CVE-2025-1049": {"epss_score": 0.00071, "epss_percentile": 0.22164}, "CVE-2025-1050": {"epss_score": 0.00078, "epss_percentile": 0.23634}, "CVE-2025-1051": {"epss_score": 0.00063, "epss_percentile": 0.2009}, "CVE-2025-1052": {"epss_score": 0.00405, "epss_percentile": 0.60511}, "CVE-2025-1053": {"epss_score": 0.00062, "epss_percentile": 0.19641}, "CVE-2025-1054": {"epss_score": 0.00048, "epss_percentile": 0.15069}, "CVE-2025-1055": {"epss_score": 0.00017, "epss_percentile": 0.03268}, "CVE-2025-1056": {"epss_score": 0.00025, "epss_percentile": 0.06096}, "CVE-2025-1057": {"epss_score": 0.00105, "epss_percentile": 0.29337}, "CVE-2025-1058": {"epss_score": 0.00068, "epss_percentile": 0.21283}, "CVE-2025-1059": {"epss_score": 0.0047, "epss_percentile": 0.63974}, "CVE-2025-1060": {"epss_score": 0.0009, "epss_percentile": 0.26061}, "CVE-2025-1061": {"epss_score": 0.0087, "epss_percentile": 0.74705}, "CVE-2025-1062": {"epss_score": 0.00064, "epss_percentile": 0.20197}, "CVE-2025-1063": {"epss_score": 0.00212, "epss_percentile": 0.43824}, "CVE-2025-1064": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2025-1065": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2025-1066": {"epss_score": 0.00384, "epss_percentile": 0.5915}, "CVE-2025-1067": {"epss_score": 0.00027, "epss_percentile": 0.07076}, "CVE-2025-1068": {"epss_score": 0.00034, "epss_percentile": 0.0957}, "CVE-2025-1070": {"epss_score": 0.00191, "epss_percentile": 0.41184}, "CVE-2025-1071": {"epss_score": 0.00511, "epss_percentile": 0.65815}, "CVE-2025-1072": {"epss_score": 0.00285, "epss_percentile": 0.51523}, "CVE-2025-1073": {"epss_score": 0.00037, "epss_percentile": 0.10741}, "CVE-2025-1074": {"epss_score": 0.00131, "epss_percentile": 0.33375}, "CVE-2025-1075": {"epss_score": 0.0014, "epss_percentile": 0.34686}, "CVE-2025-1076": {"epss_score": 0.00065, "epss_percentile": 0.20618}, "CVE-2025-1077": {"epss_score": 0.00865, "epss_percentile": 0.74622}, "CVE-2025-1078": {"epss_score": 0.00029, "epss_percentile": 0.07752}, "CVE-2025-1079": {"epss_score": 0.00027, "epss_percentile": 0.0714}, "CVE-2025-1080": {"epss_score": 0.00069, "epss_percentile": 0.21564}, "CVE-2025-1081": {"epss_score": 0.00084, "epss_percentile": 0.24982}, "CVE-2025-1082": {"epss_score": 0.00109, "epss_percentile": 0.29966}, "CVE-2025-1083": {"epss_score": 0.00111, "epss_percentile": 0.30344}, "CVE-2025-1084": {"epss_score": 0.00143, "epss_percentile": 0.35149}, "CVE-2025-1085": {"epss_score": 0.00079, "epss_percentile": 0.23874}, "CVE-2025-1086": {"epss_score": 0.00086, "epss_percentile": 0.25318}, "CVE-2025-1087": {"epss_score": 0.00246, "epss_percentile": 0.47766}, "CVE-2025-1088": {"epss_score": 0.00084, "epss_percentile": 0.24856}, "CVE-2025-1091": {"epss_score": 0.00085, "epss_percentile": 0.25154}, "CVE-2025-1093": {"epss_score": 0.01051, "epss_percentile": 0.77074}, "CVE-2025-1094": {"epss_score": 0.80274, "epss_percentile": 0.99079}, "CVE-2025-1095": {"epss_score": 0.00015, "epss_percentile": 0.0225}, "CVE-2025-1097": {"epss_score": 0.13418, "epss_percentile": 0.93957}, "CVE-2025-1098": {"epss_score": 0.57586, "epss_percentile": 0.98072}, "CVE-2025-1099": {"epss_score": 0.00018, "epss_percentile": 0.03755}, "CVE-2025-1100": {"epss_score": 0.0057, "epss_percentile": 0.67959}, "CVE-2025-1101": {"epss_score": 0.00291, "epss_percentile": 0.52191}, "CVE-2025-1102": {"epss_score": 0.00011, "epss_percentile": 0.01096}, "CVE-2025-1103": {"epss_score": 0.00949, "epss_percentile": 0.75841}, "CVE-2025-1104": {"epss_score": 0.01042, "epss_percentile": 0.76978}, "CVE-2025-1105": {"epss_score": 0.0007, "epss_percentile": 0.21654}, "CVE-2025-1106": {"epss_score": 0.0026, "epss_percentile": 0.49175}, "CVE-2025-1107": {"epss_score": 0.0025, "epss_percentile": 0.48243}, "CVE-2025-1108": {"epss_score": 0.00054, "epss_percentile": 0.17253}, "CVE-2025-1110": {"epss_score": 0.00013, "epss_percentile": 0.01668}, "CVE-2025-1112": {"epss_score": 0.00028, "epss_percentile": 0.07355}, "CVE-2025-1113": {"epss_score": 0.0013, "epss_percentile": 0.33221}, "CVE-2025-1114": {"epss_score": 0.00147, "epss_percentile": 0.35705}, "CVE-2025-1115": {"epss_score": 0.0004, "epss_percentile": 0.12184}, "CVE-2025-1116": {"epss_score": 0.00092, "epss_percentile": 0.26592}, "CVE-2025-1117": {"epss_score": 0.00125, "epss_percentile": 0.32484}, "CVE-2025-1118": {"epss_score": 0.00047, "epss_percentile": 0.14767}, "CVE-2025-1119": {"epss_score": 0.01074, "epss_percentile": 0.77301}, "CVE-2025-1121": {"epss_score": 8e-05, "epss_percentile": 0.00587}, "CVE-2025-1122": {"epss_score": 5e-05, "epss_percentile": 0.0021}, "CVE-2025-1123": {"epss_score": 0.00145, "epss_percentile": 0.35497}, "CVE-2025-1125": {"epss_score": 0.0003, "epss_percentile": 0.08219}, "CVE-2025-1126": {"epss_score": 0.00037, "epss_percentile": 0.10648}, "CVE-2025-1127": {"epss_score": 0.00469, "epss_percentile": 0.63937}, "CVE-2025-1128": {"epss_score": 0.05692, "epss_percentile": 0.90124}, "CVE-2025-1131": {"epss_score": 0.00044, "epss_percentile": 0.13386}, "CVE-2025-1132": {"epss_score": 0.00116, "epss_percentile": 0.31039}, "CVE-2025-1133": {"epss_score": 0.00158, "epss_percentile": 0.37177}, "CVE-2025-1134": {"epss_score": 0.00288, "epss_percentile": 0.51916}, "CVE-2025-1135": {"epss_score": 0.00288, "epss_percentile": 0.51916}, "CVE-2025-1137": {"epss_score": 0.00035, "epss_percentile": 0.09922}, "CVE-2025-1138": {"epss_score": 0.00031, "epss_percentile": 0.08584}, "CVE-2025-1139": {"epss_score": 0.00018, "epss_percentile": 0.0363}, "CVE-2025-1142": {"epss_score": 0.00043, "epss_percentile": 0.13331}, "CVE-2025-1143": {"epss_score": 0.00036, "epss_percentile": 0.10524}, "CVE-2025-1144": {"epss_score": 0.00435, "epss_percentile": 0.62359}, "CVE-2025-1145": {"epss_score": 0.00137, "epss_percentile": 0.34236}, "CVE-2025-1146": {"epss_score": 0.00121, "epss_percentile": 0.31943}, "CVE-2025-1147": {"epss_score": 0.0039, "epss_percentile": 0.59547}, "CVE-2025-1148": {"epss_score": 0.00405, "epss_percentile": 0.60499}, "CVE-2025-1149": {"epss_score": 0.00181, "epss_percentile": 0.40025}, "CVE-2025-1150": {"epss_score": 0.00181, "epss_percentile": 0.40025}, "CVE-2025-1151": {"epss_score": 0.00167, "epss_percentile": 0.38318}, "CVE-2025-1152": {"epss_score": 0.00181, "epss_percentile": 0.40025}, "CVE-2025-1153": {"epss_score": 0.00599, "epss_percentile": 0.68809}, "CVE-2025-1154": {"epss_score": 0.00071, "epss_percentile": 0.22079}, "CVE-2025-1155": {"epss_score": 0.0011, "epss_percentile": 0.30219}, "CVE-2025-1156": {"epss_score": 0.00083, "epss_percentile": 0.24593}, "CVE-2025-1157": {"epss_score": 0.00059, "epss_percentile": 0.18782}, "CVE-2025-1158": {"epss_score": 0.00085, "epss_percentile": 0.25121}, "CVE-2025-1159": {"epss_score": 0.00101, "epss_percentile": 0.28631}, "CVE-2025-1160": {"epss_score": 0.00214, "epss_percentile": 0.43994}, "CVE-2025-1161": {"epss_score": 0.00036, "epss_percentile": 0.10536}, "CVE-2025-1162": {"epss_score": 0.00077, "epss_percentile": 0.23528}, "CVE-2025-1163": {"epss_score": 0.00177, "epss_percentile": 0.39504}, "CVE-2025-1164": {"epss_score": 0.00043, "epss_percentile": 0.13013}, "CVE-2025-1165": {"epss_score": 0.00133, "epss_percentile": 0.33713}, "CVE-2025-1166": {"epss_score": 0.00185, "epss_percentile": 0.40522}, "CVE-2025-1167": {"epss_score": 0.00096, "epss_percentile": 0.27326}, "CVE-2025-1168": {"epss_score": 0.00147, "epss_percentile": 0.35794}, "CVE-2025-1169": {"epss_score": 0.00092, "epss_percentile": 0.26559}, "CVE-2025-1170": {"epss_score": 0.00088, "epss_percentile": 0.25669}, "CVE-2025-1171": {"epss_score": 0.00088, "epss_percentile": 0.25669}, "CVE-2025-1172": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-1173": {"epss_score": 0.00111, "epss_percentile": 0.30261}, "CVE-2025-1174": {"epss_score": 0.0009, "epss_percentile": 0.2604}, "CVE-2025-1175": {"epss_score": 0.00071, "epss_percentile": 0.22201}, "CVE-2025-1176": {"epss_score": 0.00348, "epss_percentile": 0.56818}, "CVE-2025-1177": {"epss_score": 0.00156, "epss_percentile": 0.36978}, "CVE-2025-1178": {"epss_score": 0.00357, "epss_percentile": 0.57472}, "CVE-2025-1179": {"epss_score": 0.00337, "epss_percentile": 0.56052}, "CVE-2025-1180": {"epss_score": 0.00279, "epss_percentile": 0.50959}, "CVE-2025-1181": {"epss_score": 0.00408, "epss_percentile": 0.60687}, "CVE-2025-1182": {"epss_score": 0.00306, "epss_percentile": 0.53464}, "CVE-2025-1183": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-1184": {"epss_score": 0.00132, "epss_percentile": 0.3362}, "CVE-2025-1185": {"epss_score": 0.00132, "epss_percentile": 0.3362}, "CVE-2025-1186": {"epss_score": 0.00167, "epss_percentile": 0.38389}, "CVE-2025-1187": {"epss_score": 0.00042, "epss_percentile": 0.12595}, "CVE-2025-1188": {"epss_score": 0.00142, "epss_percentile": 0.35036}, "CVE-2025-1189": {"epss_score": 0.00109, "epss_percentile": 0.2993}, "CVE-2025-1190": {"epss_score": 0.00082, "epss_percentile": 0.24475}, "CVE-2025-1191": {"epss_score": 0.00162, "epss_percentile": 0.37655}, "CVE-2025-1192": {"epss_score": 0.00115, "epss_percentile": 0.30907}, "CVE-2025-1193": {"epss_score": 0.00053, "epss_percentile": 0.1679}, "CVE-2025-1194": {"epss_score": 0.00106, "epss_percentile": 0.29482}, "CVE-2025-1195": {"epss_score": 0.00089, "epss_percentile": 0.25802}, "CVE-2025-1196": {"epss_score": 0.00025, "epss_percentile": 0.06256}, "CVE-2025-1197": {"epss_score": 0.00077, "epss_percentile": 0.23528}, "CVE-2025-1198": {"epss_score": 0.00011, "epss_percentile": 0.01112}, "CVE-2025-1199": {"epss_score": 0.00073, "epss_percentile": 0.22656}, "CVE-2025-1200": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-1201": {"epss_score": 0.00073, "epss_percentile": 0.22656}, "CVE-2025-1202": {"epss_score": 0.00073, "epss_percentile": 0.22656}, "CVE-2025-1203": {"epss_score": 0.00019, "epss_percentile": 0.04071}, "CVE-2025-1204": {"epss_score": 0.00061, "epss_percentile": 0.19448}, "CVE-2025-1206": {"epss_score": 0.00042, "epss_percentile": 0.12789}, "CVE-2025-1207": {"epss_score": 0.00063, "epss_percentile": 0.20089}, "CVE-2025-1208": {"epss_score": 0.00079, "epss_percentile": 0.23953}, "CVE-2025-1209": {"epss_score": 0.00079, "epss_percentile": 0.23953}, "CVE-2025-1210": {"epss_score": 0.00109, "epss_percentile": 0.2993}, "CVE-2025-1211": {"epss_score": 0.00053, "epss_percentile": 0.16876}, "CVE-2025-1212": {"epss_score": 0.00058, "epss_percentile": 0.18425}, "CVE-2025-1213": {"epss_score": 0.00024, "epss_percentile": 0.06026}, "CVE-2025-1214": {"epss_score": 0.00327, "epss_percentile": 0.55106}, "CVE-2025-1215": {"epss_score": 0.00382, "epss_percentile": 0.59045}, "CVE-2025-1216": {"epss_score": 0.00074, "epss_percentile": 0.22849}, "CVE-2025-1217": {"epss_score": 0.00042, "epss_percentile": 0.12804}, "CVE-2025-1219": {"epss_score": 0.00022, "epss_percentile": 0.05061}, "CVE-2025-1220": {"epss_score": 0.00018, "epss_percentile": 0.0385}, "CVE-2025-1221": {"epss_score": 0.00029, "epss_percentile": 0.07779}, "CVE-2025-1222": {"epss_score": 0.00035, "epss_percentile": 0.09898}, "CVE-2025-1223": {"epss_score": 0.00035, "epss_percentile": 0.09898}, "CVE-2025-1224": {"epss_score": 0.00079, "epss_percentile": 0.23909}, "CVE-2025-1225": {"epss_score": 0.00107, "epss_percentile": 0.29585}, "CVE-2025-1226": {"epss_score": 0.00102, "epss_percentile": 0.28838}, "CVE-2025-1227": {"epss_score": 0.00079, "epss_percentile": 0.23909}, "CVE-2025-1228": {"epss_score": 0.0013, "epss_percentile": 0.33337}, "CVE-2025-1229": {"epss_score": 0.00523, "epss_percentile": 0.66299}, "CVE-2025-1230": {"epss_score": 0.00066, "epss_percentile": 0.20754}, "CVE-2025-1231": {"epss_score": 0.00096, "epss_percentile": 0.2732}, "CVE-2025-1232": {"epss_score": 0.00908, "epss_percentile": 0.75283}, "CVE-2025-1233": {"epss_score": 0.00065, "epss_percentile": 0.20559}, "CVE-2025-1235": {"epss_score": 0.00045, "epss_percentile": 0.14054}, "CVE-2025-1239": {"epss_score": 0.00511, "epss_percentile": 0.65815}, "CVE-2025-1240": {"epss_score": 0.00526, "epss_percentile": 0.66411}, "CVE-2025-1243": {"epss_score": 0.0001, "epss_percentile": 0.0089}, "CVE-2025-1244": {"epss_score": 0.00207, "epss_percentile": 0.43134}, "CVE-2025-1245": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-1246": {"epss_score": 0.00024, "epss_percentile": 0.05739}, "CVE-2025-1247": {"epss_score": 0.00101, "epss_percentile": 0.2857}, "CVE-2025-1249": {"epss_score": 0.00116, "epss_percentile": 0.31088}, "CVE-2025-1250": {"epss_score": 0.00057, "epss_percentile": 0.18006}, "CVE-2025-1252": {"epss_score": 0.0002, "epss_percentile": 0.04488}, "CVE-2025-1253": {"epss_score": 0.00021, "epss_percentile": 0.04754}, "CVE-2025-1254": {"epss_score": 0.00036, "epss_percentile": 0.10311}, "CVE-2025-1255": {"epss_score": 0.00071, "epss_percentile": 0.22148}, "CVE-2025-1257": {"epss_score": 0.00079, "epss_percentile": 0.23806}, "CVE-2025-1259": {"epss_score": 0.00094, "epss_percentile": 0.26782}, "CVE-2025-1260": {"epss_score": 0.00129, "epss_percentile": 0.33086}, "CVE-2025-1261": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2025-1262": {"epss_score": 0.00241, "epss_percentile": 0.47234}, "CVE-2025-1264": {"epss_score": 0.00069, "epss_percentile": 0.21431}, "CVE-2025-1265": {"epss_score": 0.00702, "epss_percentile": 0.71519}, "CVE-2025-1267": {"epss_score": 0.00082, "epss_percentile": 0.24574}, "CVE-2025-1268": {"epss_score": 0.00148, "epss_percentile": 0.3588}, "CVE-2025-1269": {"epss_score": 0.0003, "epss_percentile": 0.08057}, "CVE-2025-1270": {"epss_score": 0.0014, "epss_percentile": 0.3472}, "CVE-2025-1271": {"epss_score": 0.00103, "epss_percentile": 0.29093}, "CVE-2025-1273": {"epss_score": 0.00023, "epss_percentile": 0.05355}, "CVE-2025-1274": {"epss_score": 0.00048, "epss_percentile": 0.15177}, "CVE-2025-1275": {"epss_score": 0.00042, "epss_percentile": 0.12817}, "CVE-2025-1276": {"epss_score": 0.0002, "epss_percentile": 0.04518}, "CVE-2025-1277": {"epss_score": 0.00023, "epss_percentile": 0.05355}, "CVE-2025-1278": {"epss_score": 0.00017, "epss_percentile": 0.03376}, "CVE-2025-1279": {"epss_score": 0.00066, "epss_percentile": 0.2075}, "CVE-2025-1282": {"epss_score": 0.01, "epss_percentile": 0.76489}, "CVE-2025-1283": {"epss_score": 0.00135, "epss_percentile": 0.33974}, "CVE-2025-1284": {"epss_score": 0.00051, "epss_percentile": 0.16064}, "CVE-2025-1285": {"epss_score": 0.00297, "epss_percentile": 0.52773}, "CVE-2025-1286": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-1287": {"epss_score": 0.00111, "epss_percentile": 0.30401}, "CVE-2025-1288": {"epss_score": 0.00025, "epss_percentile": 0.0635}, "CVE-2025-1289": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2025-1290": {"epss_score": 0.00089, "epss_percentile": 0.25929}, "CVE-2025-1291": {"epss_score": 0.00119, "epss_percentile": 0.31548}, "CVE-2025-1292": {"epss_score": 0.00012, "epss_percentile": 0.01395}, "CVE-2025-1293": {"epss_score": 0.00158, "epss_percentile": 0.37174}, "CVE-2025-1294": {"epss_score": 0.00289, "epss_percentile": 0.52009}, "CVE-2025-1295": {"epss_score": 0.00201, "epss_percentile": 0.4233}, "CVE-2025-1296": {"epss_score": 0.00064, "epss_percentile": 0.20272}, "CVE-2025-1298": {"epss_score": 0.00227, "epss_percentile": 0.45387}, "CVE-2025-1299": {"epss_score": 0.00015, "epss_percentile": 0.02198}, "CVE-2025-1300": {"epss_score": 0.00098, "epss_percentile": 0.27638}, "CVE-2025-1301": {"epss_score": 0.00027, "epss_percentile": 0.06771}, "CVE-2025-1302": {"epss_score": 0.86146, "epss_percentile": 0.9937}, "CVE-2025-1303": {"epss_score": 0.00073, "epss_percentile": 0.22572}, "CVE-2025-1304": {"epss_score": 0.00475, "epss_percentile": 0.64173}, "CVE-2025-1305": {"epss_score": 0.0009, "epss_percentile": 0.26075}, "CVE-2025-1306": {"epss_score": 0.00127, "epss_percentile": 0.32813}, "CVE-2025-1307": {"epss_score": 0.23879, "epss_percentile": 0.95829}, "CVE-2025-1308": {"epss_score": 0.00022, "epss_percentile": 0.05005}, "CVE-2025-1309": {"epss_score": 0.00194, "epss_percentile": 0.41585}, "CVE-2025-1310": {"epss_score": 0.00796, "epss_percentile": 0.73487}, "CVE-2025-1311": {"epss_score": 0.00098, "epss_percentile": 0.27777}, "CVE-2025-1312": {"epss_score": 0.00081, "epss_percentile": 0.24325}, "CVE-2025-1313": {"epss_score": 0.00056, "epss_percentile": 0.17737}, "CVE-2025-1314": {"epss_score": 0.00067, "epss_percentile": 0.21184}, "CVE-2025-1315": {"epss_score": 0.00164, "epss_percentile": 0.37896}, "CVE-2025-1316": {"epss_score": 0.84082, "epss_percentile": 0.99273}, "CVE-2025-1319": {"epss_score": 0.00112, "epss_percentile": 0.30518}, "CVE-2025-1320": {"epss_score": 0.00027, "epss_percentile": 0.06763}, "CVE-2025-1321": {"epss_score": 0.00102, "epss_percentile": 0.28832}, "CVE-2025-1322": {"epss_score": 0.00082, "epss_percentile": 0.24407}, "CVE-2025-1323": {"epss_score": 0.53214, "epss_percentile": 0.97864}, "CVE-2025-1324": {"epss_score": 0.0003, "epss_percentile": 0.08252}, "CVE-2025-1325": {"epss_score": 0.00087, "epss_percentile": 0.25502}, "CVE-2025-1326": {"epss_score": 0.00039, "epss_percentile": 0.11862}, "CVE-2025-1327": {"epss_score": 0.00039, "epss_percentile": 0.11862}, "CVE-2025-1328": {"epss_score": 0.00035, "epss_percentile": 0.09986}, "CVE-2025-1329": {"epss_score": 0.00012, "epss_percentile": 0.0112}, "CVE-2025-1330": {"epss_score": 0.00012, "epss_percentile": 0.0112}, "CVE-2025-1331": {"epss_score": 0.00012, "epss_percentile": 0.0112}, "CVE-2025-1332": {"epss_score": 0.00064, "epss_percentile": 0.20103}, "CVE-2025-1333": {"epss_score": 0.00031, "epss_percentile": 0.0844}, "CVE-2025-1334": {"epss_score": 0.00013, "epss_percentile": 0.0172}, "CVE-2025-1335": {"epss_score": 0.00107, "epss_percentile": 0.29675}, "CVE-2025-1336": {"epss_score": 0.00153, "epss_percentile": 0.36552}, "CVE-2025-1337": {"epss_score": 0.00029, "epss_percentile": 0.07775}, "CVE-2025-1338": {"epss_score": 0.02752, "epss_percentile": 0.85585}, "CVE-2025-1339": {"epss_score": 0.00357, "epss_percentile": 0.57454}, "CVE-2025-1340": {"epss_score": 0.00196, "epss_percentile": 0.41794}, "CVE-2025-1341": {"epss_score": 0.00031, "epss_percentile": 0.08549}, "CVE-2025-1348": {"epss_score": 0.00011, "epss_percentile": 0.01064}, "CVE-2025-1349": {"epss_score": 0.00018, "epss_percentile": 0.03729}, "CVE-2025-1351": {"epss_score": 7e-05, "epss_percentile": 0.00459}, "CVE-2025-1352": {"epss_score": 0.00398, "epss_percentile": 0.60078}, "CVE-2025-1353": {"epss_score": 0.00025, "epss_percentile": 0.06109}, "CVE-2025-1354": {"epss_score": 0.00287, "epss_percentile": 0.51831}, "CVE-2025-1355": {"epss_score": 0.00235, "epss_percentile": 0.46215}, "CVE-2025-1356": {"epss_score": 0.00075, "epss_percentile": 0.22988}, "CVE-2025-1357": {"epss_score": 0.00134, "epss_percentile": 0.33749}, "CVE-2025-1358": {"epss_score": 0.00037, "epss_percentile": 0.10934}, "CVE-2025-1359": {"epss_score": 0.03726, "epss_percentile": 0.87633}, "CVE-2025-1360": {"epss_score": 0.00067, "epss_percentile": 0.21116}, "CVE-2025-1361": {"epss_score": 0.00342, "epss_percentile": 0.56352}, "CVE-2025-1362": {"epss_score": 0.00012, "epss_percentile": 0.01354}, "CVE-2025-1363": {"epss_score": 0.00025, "epss_percentile": 0.0628}, "CVE-2025-1364": {"epss_score": 0.0005, "epss_percentile": 0.15689}, "CVE-2025-1365": {"epss_score": 0.00067, "epss_percentile": 0.21127}, "CVE-2025-1366": {"epss_score": 0.00045, "epss_percentile": 0.13947}, "CVE-2025-1367": {"epss_score": 0.00013, "epss_percentile": 0.01588}, "CVE-2025-1368": {"epss_score": 0.00014, "epss_percentile": 0.0185}, "CVE-2025-1369": {"epss_score": 0.00057, "epss_percentile": 0.17995}, "CVE-2025-1370": {"epss_score": 0.00048, "epss_percentile": 0.15171}, "CVE-2025-1371": {"epss_score": 0.00055, "epss_percentile": 0.17581}, "CVE-2025-1372": {"epss_score": 0.00104, "epss_percentile": 0.29176}, "CVE-2025-1373": {"epss_score": 0.00072, "epss_percentile": 0.22459}, "CVE-2025-1374": {"epss_score": 0.00086, "epss_percentile": 0.25439}, "CVE-2025-1376": {"epss_score": 0.00068, "epss_percentile": 0.21192}, "CVE-2025-1377": {"epss_score": 0.00068, "epss_percentile": 0.21192}, "CVE-2025-1378": {"epss_score": 0.00077, "epss_percentile": 0.23354}, "CVE-2025-1379": {"epss_score": 0.0013, "epss_percentile": 0.33235}, "CVE-2025-1380": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-1381": {"epss_score": 0.00086, "epss_percentile": 0.25439}, "CVE-2025-1382": {"epss_score": 0.00013, "epss_percentile": 0.01584}, "CVE-2025-1383": {"epss_score": 0.00046, "epss_percentile": 0.14422}, "CVE-2025-1384": {"epss_score": 0.00047, "epss_percentile": 0.14907}, "CVE-2025-1385": {"epss_score": 0.00207, "epss_percentile": 0.43163}, "CVE-2025-1386": {"epss_score": 0.00017, "epss_percentile": 0.03422}, "CVE-2025-1387": {"epss_score": 0.00395, "epss_percentile": 0.59844}, "CVE-2025-1388": {"epss_score": 0.00227, "epss_percentile": 0.45398}, "CVE-2025-1389": {"epss_score": 0.0012, "epss_percentile": 0.31737}, "CVE-2025-1390": {"epss_score": 0.00041, "epss_percentile": 0.12292}, "CVE-2025-1391": {"epss_score": 0.0004, "epss_percentile": 0.11984}, "CVE-2025-1392": {"epss_score": 0.00054, "epss_percentile": 0.17152}, "CVE-2025-1393": {"epss_score": 0.00305, "epss_percentile": 0.53389}, "CVE-2025-1394": {"epss_score": 0.00037, "epss_percentile": 0.11006}, "CVE-2025-1396": {"epss_score": 0.00043, "epss_percentile": 0.13318}, "CVE-2025-1398": {"epss_score": 0.00032, "epss_percentile": 0.09046}, "CVE-2025-1399": {"epss_score": 0.00029, "epss_percentile": 0.07593}, "CVE-2025-1400": {"epss_score": 0.00029, "epss_percentile": 0.0786}, "CVE-2025-1401": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2025-1402": {"epss_score": 0.00174, "epss_percentile": 0.39192}, "CVE-2025-1403": {"epss_score": 0.00371, "epss_percentile": 0.58366}, "CVE-2025-1404": {"epss_score": 0.00299, "epss_percentile": 0.52902}, "CVE-2025-1405": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2025-1406": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2025-1407": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2025-1408": {"epss_score": 0.00096, "epss_percentile": 0.27363}, "CVE-2025-1410": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2025-1411": {"epss_score": 6e-05, "epss_percentile": 0.00304}, "CVE-2025-1412": {"epss_score": 0.00081, "epss_percentile": 0.24332}, "CVE-2025-1413": {"epss_score": 0.00023, "epss_percentile": 0.05448}, "CVE-2025-1414": {"epss_score": 0.00461, "epss_percentile": 0.63549}, "CVE-2025-1415": {"epss_score": 0.00023, "epss_percentile": 0.0562}, "CVE-2025-1416": {"epss_score": 0.00023, "epss_percentile": 0.0562}, "CVE-2025-1417": {"epss_score": 0.00023, "epss_percentile": 0.0562}, "CVE-2025-1418": {"epss_score": 0.00023, "epss_percentile": 0.0562}, "CVE-2025-1419": {"epss_score": 0.0003, "epss_percentile": 0.08057}, "CVE-2025-1420": {"epss_score": 0.0003, "epss_percentile": 0.08057}, "CVE-2025-1421": {"epss_score": 0.00023, "epss_percentile": 0.05418}, "CVE-2025-1424": {"epss_score": 0.00054, "epss_percentile": 0.17201}, "CVE-2025-1425": {"epss_score": 0.00049, "epss_percentile": 0.15302}, "CVE-2025-1426": {"epss_score": 0.00158, "epss_percentile": 0.37145}, "CVE-2025-1427": {"epss_score": 0.00082, "epss_percentile": 0.24531}, "CVE-2025-1428": {"epss_score": 0.00082, "epss_percentile": 0.24531}, "CVE-2025-1429": {"epss_score": 0.00082, "epss_percentile": 0.24531}, "CVE-2025-1430": {"epss_score": 0.00082, "epss_percentile": 0.24531}, "CVE-2025-1431": {"epss_score": 0.00082, "epss_percentile": 0.24531}, "CVE-2025-1432": {"epss_score": 0.00082, "epss_percentile": 0.24531}, "CVE-2025-1433": {"epss_score": 0.00082, "epss_percentile": 0.24531}, "CVE-2025-1434": {"epss_score": 0.00079, "epss_percentile": 0.23895}, "CVE-2025-1435": {"epss_score": 0.00046, "epss_percentile": 0.14377}, "CVE-2025-1436": {"epss_score": 0.00044, "epss_percentile": 0.13618}, "CVE-2025-1437": {"epss_score": 0.00052, "epss_percentile": 0.16641}, "CVE-2025-1439": {"epss_score": 0.00052, "epss_percentile": 0.16641}, "CVE-2025-1440": {"epss_score": 0.00361, "epss_percentile": 0.57699}, "CVE-2025-1441": {"epss_score": 0.00079, "epss_percentile": 0.23967}, "CVE-2025-1445": {"epss_score": 0.0007, "epss_percentile": 0.21742}, "CVE-2025-1446": {"epss_score": 0.001, "epss_percentile": 0.2854}, "CVE-2025-1447": {"epss_score": 0.00144, "epss_percentile": 0.35243}, "CVE-2025-1448": {"epss_score": 0.01737, "epss_percentile": 0.8202}, "CVE-2025-1449": {"epss_score": 0.00089, "epss_percentile": 0.25983}, "CVE-2025-1450": {"epss_score": 0.001, "epss_percentile": 0.2844}, "CVE-2025-1451": {"epss_score": 0.00224, "epss_percentile": 0.45014}, "CVE-2025-1452": {"epss_score": 0.00059, "epss_percentile": 0.18724}, "CVE-2025-1453": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2025-1454": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2025-1455": {"epss_score": 0.0004, "epss_percentile": 0.11922}, "CVE-2025-1456": {"epss_score": 0.0004, "epss_percentile": 0.11922}, "CVE-2025-1457": {"epss_score": 0.00066, "epss_percentile": 0.20934}, "CVE-2025-1458": {"epss_score": 0.00026, "epss_percentile": 0.06675}, "CVE-2025-1459": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2025-1461": {"epss_score": 0.0004, "epss_percentile": 0.12089}, "CVE-2025-1463": {"epss_score": 0.00052, "epss_percentile": 0.16464}, "CVE-2025-1464": {"epss_score": 0.00092, "epss_percentile": 0.26592}, "CVE-2025-1465": {"epss_score": 0.00176, "epss_percentile": 0.39471}, "CVE-2025-1467": {"epss_score": 0.0011, "epss_percentile": 0.30172}, "CVE-2025-1468": {"epss_score": 0.00112, "epss_percentile": 0.30529}, "CVE-2025-1469": {"epss_score": 0.00043, "epss_percentile": 0.13007}, "CVE-2025-1470": {"epss_score": 0.00036, "epss_percentile": 0.10232}, "CVE-2025-1471": {"epss_score": 0.00031, "epss_percentile": 0.08538}, "CVE-2025-1472": {"epss_score": 0.00086, "epss_percentile": 0.25415}, "CVE-2025-1473": {"epss_score": 0.00052, "epss_percentile": 0.16631}, "CVE-2025-1474": {"epss_score": 0.00082, "epss_percentile": 0.24505}, "CVE-2025-1475": {"epss_score": 0.00539, "epss_percentile": 0.66965}, "CVE-2025-1477": {"epss_score": 0.00139, "epss_percentile": 0.34627}, "CVE-2025-1478": {"epss_score": 0.00182, "epss_percentile": 0.40217}, "CVE-2025-1479": {"epss_score": 0.00019, "epss_percentile": 0.04129}, "CVE-2025-1481": {"epss_score": 0.00129, "epss_percentile": 0.33124}, "CVE-2025-1483": {"epss_score": 0.0021, "epss_percentile": 0.43615}, "CVE-2025-1484": {"epss_score": 0.00034, "epss_percentile": 0.09759}, "CVE-2025-1485": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2025-1486": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2025-1487": {"epss_score": 0.00102, "epss_percentile": 0.28734}, "CVE-2025-1488": {"epss_score": 0.00085, "epss_percentile": 0.25176}, "CVE-2025-1489": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2025-1490": {"epss_score": 0.00333, "epss_percentile": 0.55625}, "CVE-2025-1491": {"epss_score": 0.00119, "epss_percentile": 0.31548}, "CVE-2025-1492": {"epss_score": 0.00024, "epss_percentile": 0.0603}, "CVE-2025-1493": {"epss_score": 0.00056, "epss_percentile": 0.17782}, "CVE-2025-1494": {"epss_score": 0.00055, "epss_percentile": 0.17493}, "CVE-2025-1495": {"epss_score": 0.00031, "epss_percentile": 0.08583}, "CVE-2025-1496": {"epss_score": 0.00093, "epss_percentile": 0.26708}, "CVE-2025-1497": {"epss_score": 0.01795, "epss_percentile": 0.82297}, "CVE-2025-1499": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-1500": {"epss_score": 0.0005, "epss_percentile": 0.15782}, "CVE-2025-1501": {"epss_score": 0.00046, "epss_percentile": 0.1415}, "CVE-2025-1502": {"epss_score": 0.00259, "epss_percentile": 0.4908}, "CVE-2025-1503": {"epss_score": 0.00102, "epss_percentile": 0.28854}, "CVE-2025-1504": {"epss_score": 0.00111, "epss_percentile": 0.30353}, "CVE-2025-1505": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2025-1506": {"epss_score": 0.00041, "epss_percentile": 0.12362}, "CVE-2025-1507": {"epss_score": 0.0021, "epss_percentile": 0.43615}, "CVE-2025-1508": {"epss_score": 0.0015, "epss_percentile": 0.36087}, "CVE-2025-1509": {"epss_score": 0.00449, "epss_percentile": 0.63058}, "CVE-2025-1510": {"epss_score": 0.00449, "epss_percentile": 0.63058}, "CVE-2025-1511": {"epss_score": 0.00676, "epss_percentile": 0.70919}, "CVE-2025-1512": {"epss_score": 0.00053, "epss_percentile": 0.16992}, "CVE-2025-1513": {"epss_score": 0.00522, "epss_percentile": 0.6627}, "CVE-2025-1514": {"epss_score": 0.00245, "epss_percentile": 0.47631}, "CVE-2025-1515": {"epss_score": 0.00505, "epss_percentile": 0.65605}, "CVE-2025-1516": {"epss_score": 0.00182, "epss_percentile": 0.40217}, "CVE-2025-1517": {"epss_score": 0.00173, "epss_percentile": 0.39064}, "CVE-2025-1520": {"epss_score": 0.00095, "epss_percentile": 0.27082}, "CVE-2025-1521": {"epss_score": 0.00244, "epss_percentile": 0.47579}, "CVE-2025-1522": {"epss_score": 0.00117, "epss_percentile": 0.31222}, "CVE-2025-1523": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2025-1524": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2025-1525": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2025-1526": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2025-1527": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2025-1528": {"epss_score": 0.00102, "epss_percentile": 0.28736}, "CVE-2025-1529": {"epss_score": 0.00035, "epss_percentile": 0.10019}, "CVE-2025-1530": {"epss_score": 0.00067, "epss_percentile": 0.21184}, "CVE-2025-1531": {"epss_score": 0.00038, "epss_percentile": 0.11414}, "CVE-2025-1532": {"epss_score": 0.00049, "epss_percentile": 0.15494}, "CVE-2025-1533": {"epss_score": 0.00023, "epss_percentile": 0.05388}, "CVE-2025-1534": {"epss_score": 0.00047, "epss_percentile": 0.14686}, "CVE-2025-1535": {"epss_score": 0.00108, "epss_percentile": 0.29833}, "CVE-2025-1536": {"epss_score": 0.02137, "epss_percentile": 0.83732}, "CVE-2025-1537": {"epss_score": 0.00071, "epss_percentile": 0.22079}, "CVE-2025-1538": {"epss_score": 0.00803, "epss_percentile": 0.73597}, "CVE-2025-1539": {"epss_score": 0.00692, "epss_percentile": 0.71283}, "CVE-2025-1540": {"epss_score": 0.00032, "epss_percentile": 0.08801}, "CVE-2025-1542": {"epss_score": 0.0009, "epss_percentile": 0.26172}, "CVE-2025-1543": {"epss_score": 0.00329, "epss_percentile": 0.55383}, "CVE-2025-1544": {"epss_score": 0.00085, "epss_percentile": 0.25121}, "CVE-2025-1545": {"epss_score": 0.00085, "epss_percentile": 0.25223}, "CVE-2025-1546": {"epss_score": 0.02137, "epss_percentile": 0.83732}, "CVE-2025-1547": {"epss_score": 0.00042, "epss_percentile": 0.12587}, "CVE-2025-1548": {"epss_score": 0.00094, "epss_percentile": 0.26975}, "CVE-2025-1549": {"epss_score": 0.00033, "epss_percentile": 0.09232}, "CVE-2025-1550": {"epss_score": 0.04785, "epss_percentile": 0.8914}, "CVE-2025-1551": {"epss_score": 0.00075, "epss_percentile": 0.22905}, "CVE-2025-1553": {"epss_score": 0.00151, "epss_percentile": 0.3619}, "CVE-2025-1555": {"epss_score": 0.00133, "epss_percentile": 0.33713}, "CVE-2025-1556": {"epss_score": 0.00269, "epss_percentile": 0.50153}, "CVE-2025-1557": {"epss_score": 0.00108, "epss_percentile": 0.29819}, "CVE-2025-1558": {"epss_score": 0.00111, "epss_percentile": 0.30255}, "CVE-2025-1559": {"epss_score": 0.00104, "epss_percentile": 0.29108}, "CVE-2025-1560": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2025-1561": {"epss_score": 0.00676, "epss_percentile": 0.70919}, "CVE-2025-1562": {"epss_score": 0.12591, "epss_percentile": 0.93722}, "CVE-2025-1564": {"epss_score": 0.00364, "epss_percentile": 0.57941}, "CVE-2025-1565": {"epss_score": 0.00314, "epss_percentile": 0.54114}, "CVE-2025-1566": {"epss_score": 0.00037, "epss_percentile": 0.10677}, "CVE-2025-1568": {"epss_score": 0.00287, "epss_percentile": 0.51814}, "CVE-2025-1570": {"epss_score": 0.00306, "epss_percentile": 0.53414}, "CVE-2025-1571": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2025-1572": {"epss_score": 0.0021, "epss_percentile": 0.43427}, "CVE-2025-1575": {"epss_score": 0.00025, "epss_percentile": 0.06115}, "CVE-2025-1576": {"epss_score": 0.00038, "epss_percentile": 0.11413}, "CVE-2025-1577": {"epss_score": 0.00079, "epss_percentile": 0.23953}, "CVE-2025-1578": {"epss_score": 0.00078, "epss_percentile": 0.23615}, "CVE-2025-1579": {"epss_score": 0.00025, "epss_percentile": 0.06224}, "CVE-2025-1580": {"epss_score": 0.00039, "epss_percentile": 0.11694}, "CVE-2025-1581": {"epss_score": 0.00036, "epss_percentile": 0.10313}, "CVE-2025-1582": {"epss_score": 0.00036, "epss_percentile": 0.10313}, "CVE-2025-1583": {"epss_score": 0.00036, "epss_percentile": 0.10313}, "CVE-2025-1584": {"epss_score": 0.00083, "epss_percentile": 0.24593}, "CVE-2025-1585": {"epss_score": 0.00113, "epss_percentile": 0.30674}, "CVE-2025-1586": {"epss_score": 0.00097, "epss_percentile": 0.27507}, "CVE-2025-1587": {"epss_score": 0.0004, "epss_percentile": 0.12056}, "CVE-2025-1588": {"epss_score": 0.00328, "epss_percentile": 0.55293}, "CVE-2025-1589": {"epss_score": 0.00082, "epss_percentile": 0.24504}, "CVE-2025-1590": {"epss_score": 0.00155, "epss_percentile": 0.36772}, "CVE-2025-1591": {"epss_score": 0.00083, "epss_percentile": 0.24763}, "CVE-2025-1592": {"epss_score": 0.00075, "epss_percentile": 0.23014}, "CVE-2025-1593": {"epss_score": 0.00163, "epss_percentile": 0.37811}, "CVE-2025-1594": {"epss_score": 0.00354, "epss_percentile": 0.5721}, "CVE-2025-1595": {"epss_score": 0.03765, "epss_percentile": 0.87695}, "CVE-2025-1596": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2025-1597": {"epss_score": 0.00088, "epss_percentile": 0.25669}, "CVE-2025-1598": {"epss_score": 0.00202, "epss_percentile": 0.42487}, "CVE-2025-1599": {"epss_score": 0.00616, "epss_percentile": 0.69317}, "CVE-2025-1606": {"epss_score": 0.00112, "epss_percentile": 0.30529}, "CVE-2025-1607": {"epss_score": 0.00028, "epss_percentile": 0.07237}, "CVE-2025-1608": {"epss_score": 0.00671, "epss_percentile": 0.70794}, "CVE-2025-1609": {"epss_score": 0.00671, "epss_percentile": 0.70794}, "CVE-2025-1610": {"epss_score": 0.00671, "epss_percentile": 0.70794}, "CVE-2025-1611": {"epss_score": 0.00037, "epss_percentile": 0.10924}, "CVE-2025-1612": {"epss_score": 0.00018, "epss_percentile": 0.03662}, "CVE-2025-1613": {"epss_score": 0.00058, "epss_percentile": 0.18467}, "CVE-2025-1614": {"epss_score": 0.00058, "epss_percentile": 0.18467}, "CVE-2025-1615": {"epss_score": 0.00058, "epss_percentile": 0.18467}, "CVE-2025-1616": {"epss_score": 0.00106, "epss_percentile": 0.29481}, "CVE-2025-1617": {"epss_score": 0.00072, "epss_percentile": 0.22412}, "CVE-2025-1618": {"epss_score": 0.00095, "epss_percentile": 0.27123}, "CVE-2025-1619": {"epss_score": 0.00074, "epss_percentile": 0.2276}, "CVE-2025-1620": {"epss_score": 0.00074, "epss_percentile": 0.2276}, "CVE-2025-1621": {"epss_score": 0.00074, "epss_percentile": 0.2276}, "CVE-2025-1622": {"epss_score": 0.00068, "epss_percentile": 0.21366}, "CVE-2025-1623": {"epss_score": 0.00074, "epss_percentile": 0.2276}, "CVE-2025-1624": {"epss_score": 0.00074, "epss_percentile": 0.2276}, "CVE-2025-1625": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2025-1626": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2025-1627": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2025-1629": {"epss_score": 0.00016, "epss_percentile": 0.02835}, "CVE-2025-1632": {"epss_score": 0.00198, "epss_percentile": 0.42084}, "CVE-2025-1634": {"epss_score": 0.00555, "epss_percentile": 0.67479}, "CVE-2025-1635": {"epss_score": 0.00155, "epss_percentile": 0.36761}, "CVE-2025-1636": {"epss_score": 0.00155, "epss_percentile": 0.36761}, "CVE-2025-1638": {"epss_score": 0.00505, "epss_percentile": 0.65605}, "CVE-2025-1639": {"epss_score": 0.0964, "epss_percentile": 0.92636}, "CVE-2025-1640": {"epss_score": 0.00183, "epss_percentile": 0.4033}, "CVE-2025-1641": {"epss_score": 0.00183, "epss_percentile": 0.4033}, "CVE-2025-1642": {"epss_score": 0.00114, "epss_percentile": 0.30817}, "CVE-2025-1643": {"epss_score": 0.00025, "epss_percentile": 0.06359}, "CVE-2025-1644": {"epss_score": 0.00022, "epss_percentile": 0.05248}, "CVE-2025-1645": {"epss_score": 0.00046, "epss_percentile": 0.1427}, "CVE-2025-1646": {"epss_score": 0.00178, "epss_percentile": 0.39679}, "CVE-2025-1647": {"epss_score": 0.00039, "epss_percentile": 0.11774}, "CVE-2025-1648": {"epss_score": 0.01508, "epss_percentile": 0.80761}, "CVE-2025-1649": {"epss_score": 0.00082, "epss_percentile": 0.24531}, "CVE-2025-1650": {"epss_score": 0.00082, "epss_percentile": 0.24531}, "CVE-2025-1651": {"epss_score": 0.00082, "epss_percentile": 0.24531}, "CVE-2025-1652": {"epss_score": 0.00082, "epss_percentile": 0.24531}, "CVE-2025-1653": {"epss_score": 0.00062, "epss_percentile": 0.19615}, "CVE-2025-1656": {"epss_score": 0.00023, "epss_percentile": 0.05355}, "CVE-2025-1657": {"epss_score": 0.0015, "epss_percentile": 0.3606}, "CVE-2025-1658": {"epss_score": 0.00064, "epss_percentile": 0.20189}, "CVE-2025-1659": {"epss_score": 0.00064, "epss_percentile": 0.20189}, "CVE-2025-1660": {"epss_score": 0.00064, "epss_percentile": 0.20189}, "CVE-2025-1661": {"epss_score": 0.91448, "epss_percentile": 0.99644}, "CVE-2025-1662": {"epss_score": 0.00098, "epss_percentile": 0.27641}, "CVE-2025-1663": {"epss_score": 0.0004, "epss_percentile": 0.12042}, "CVE-2025-1664": {"epss_score": 0.00077, "epss_percentile": 0.23345}, "CVE-2025-1665": {"epss_score": 0.0004, "epss_percentile": 0.12042}, "CVE-2025-1666": {"epss_score": 0.00099, "epss_percentile": 0.27868}, "CVE-2025-1667": {"epss_score": 0.00115, "epss_percentile": 0.30964}, "CVE-2025-1668": {"epss_score": 0.00087, "epss_percentile": 0.25556}, "CVE-2025-1669": {"epss_score": 0.00089, "epss_percentile": 0.25871}, "CVE-2025-1670": {"epss_score": 0.00089, "epss_percentile": 0.25871}, "CVE-2025-1671": {"epss_score": 0.00364, "epss_percentile": 0.57941}, "CVE-2025-1672": {"epss_score": 0.00147, "epss_percentile": 0.35696}, "CVE-2025-1673": {"epss_score": 0.0028, "epss_percentile": 0.51085}, "CVE-2025-1674": {"epss_score": 0.00242, "epss_percentile": 0.47359}, "CVE-2025-1675": {"epss_score": 0.00324, "epss_percentile": 0.54948}, "CVE-2025-1676": {"epss_score": 0.0086, "epss_percentile": 0.7453}, "CVE-2025-1677": {"epss_score": 0.0009, "epss_percentile": 0.26023}, "CVE-2025-1679": {"epss_score": 0.00065, "epss_percentile": 0.20439}, "CVE-2025-1680": {"epss_score": 0.00028, "epss_percentile": 0.07472}, "CVE-2025-1681": {"epss_score": 0.00168, "epss_percentile": 0.38457}, "CVE-2025-1682": {"epss_score": 0.00222, "epss_percentile": 0.44773}, "CVE-2025-1683": {"epss_score": 0.00043, "epss_percentile": 0.12971}, "CVE-2025-1686": {"epss_score": 0.00078, "epss_percentile": 0.23748}, "CVE-2025-1687": {"epss_score": 0.00065, "epss_percentile": 0.20472}, "CVE-2025-1688": {"epss_score": 0.00046, "epss_percentile": 0.14202}, "CVE-2025-1689": {"epss_score": 0.00076, "epss_percentile": 0.23217}, "CVE-2025-1690": {"epss_score": 0.00076, "epss_percentile": 0.23217}, "CVE-2025-1691": {"epss_score": 0.00234, "epss_percentile": 0.46084}, "CVE-2025-1692": {"epss_score": 0.00087, "epss_percentile": 0.2559}, "CVE-2025-1693": {"epss_score": 0.00111, "epss_percentile": 0.30383}, "CVE-2025-1695": {"epss_score": 0.00053, "epss_percentile": 0.16689}, "CVE-2025-1696": {"epss_score": 0.00055, "epss_percentile": 0.17578}, "CVE-2025-1697": {"epss_score": 0.00034, "epss_percentile": 0.09574}, "CVE-2025-1698": {"epss_score": 0.00023, "epss_percentile": 0.05602}, "CVE-2025-1699": {"epss_score": 0.00014, "epss_percentile": 0.01918}, "CVE-2025-1700": {"epss_score": 0.00013, "epss_percentile": 0.01437}, "CVE-2025-1701": {"epss_score": 0.00032, "epss_percentile": 0.08815}, "CVE-2025-1702": {"epss_score": 0.01647, "epss_percentile": 0.81541}, "CVE-2025-1703": {"epss_score": 0.00102, "epss_percentile": 0.28752}, "CVE-2025-1704": {"epss_score": 0.00033, "epss_percentile": 0.09364}, "CVE-2025-1705": {"epss_score": 0.00113, "epss_percentile": 0.30604}, "CVE-2025-1706": {"epss_score": 0.00058, "epss_percentile": 0.18604}, "CVE-2025-1707": {"epss_score": 0.00293, "epss_percentile": 0.52317}, "CVE-2025-1708": {"epss_score": 0.00051, "epss_percentile": 0.16249}, "CVE-2025-1709": {"epss_score": 0.0005, "epss_percentile": 0.15879}, "CVE-2025-1710": {"epss_score": 0.001, "epss_percentile": 0.2852}, "CVE-2025-1711": {"epss_score": 0.00049, "epss_percentile": 0.1537}, "CVE-2025-1712": {"epss_score": 0.00061, "epss_percentile": 0.19516}, "CVE-2025-1713": {"epss_score": 0.00082, "epss_percentile": 0.2451}, "CVE-2025-1714": {"epss_score": 0.00127, "epss_percentile": 0.32841}, "CVE-2025-1716": {"epss_score": 0.04248, "epss_percentile": 0.88448}, "CVE-2025-1717": {"epss_score": 0.0034, "epss_percentile": 0.56215}, "CVE-2025-1718": {"epss_score": 0.00066, "epss_percentile": 0.20957}, "CVE-2025-1721": {"epss_score": 0.0005, "epss_percentile": 0.15692}, "CVE-2025-1723": {"epss_score": 0.00066, "epss_percentile": 0.20689}, "CVE-2025-1724": {"epss_score": 0.01122, "epss_percentile": 0.77785}, "CVE-2025-1725": {"epss_score": 0.00025, "epss_percentile": 0.06048}, "CVE-2025-1726": {"epss_score": 0.00061, "epss_percentile": 0.1953}, "CVE-2025-1727": {"epss_score": 0.00023, "epss_percentile": 0.05444}, "CVE-2025-1729": {"epss_score": 0.00012, "epss_percentile": 0.01408}, "CVE-2025-1730": {"epss_score": 0.0018, "epss_percentile": 0.39925}, "CVE-2025-1731": {"epss_score": 0.00081, "epss_percentile": 0.24207}, "CVE-2025-1732": {"epss_score": 0.00022, "epss_percentile": 0.05316}, "CVE-2025-1734": {"epss_score": 0.00127, "epss_percentile": 0.32938}, "CVE-2025-1735": {"epss_score": 0.0007, "epss_percentile": 0.21698}, "CVE-2025-1736": {"epss_score": 0.00216, "epss_percentile": 0.44153}, "CVE-2025-1738": {"epss_score": 0.00039, "epss_percentile": 0.11462}, "CVE-2025-1739": {"epss_score": 0.0007, "epss_percentile": 0.21695}, "CVE-2025-1740": {"epss_score": 0.00117, "epss_percentile": 0.31247}, "CVE-2025-1741": {"epss_score": 0.00415, "epss_percentile": 0.61129}, "CVE-2025-1742": {"epss_score": 0.00093, "epss_percentile": 0.26748}, "CVE-2025-1743": {"epss_score": 0.04933, "epss_percentile": 0.893}, "CVE-2025-1744": {"epss_score": 0.00311, "epss_percentile": 0.5393}, "CVE-2025-1745": {"epss_score": 0.00115, "epss_percentile": 0.30951}, "CVE-2025-1746": {"epss_score": 0.00071, "epss_percentile": 0.22201}, "CVE-2025-1747": {"epss_score": 0.00075, "epss_percentile": 0.22956}, "CVE-2025-1748": {"epss_score": 0.00075, "epss_percentile": 0.22956}, "CVE-2025-1749": {"epss_score": 0.00075, "epss_percentile": 0.22956}, "CVE-2025-1750": {"epss_score": 0.00472, "epss_percentile": 0.64053}, "CVE-2025-1751": {"epss_score": 0.00123, "epss_percentile": 0.32291}, "CVE-2025-1752": {"epss_score": 0.00058, "epss_percentile": 0.18398}, "CVE-2025-1753": {"epss_score": 0.00035, "epss_percentile": 0.09853}, "CVE-2025-1754": {"epss_score": 0.0006, "epss_percentile": 0.19005}, "CVE-2025-1755": {"epss_score": 0.00022, "epss_percentile": 0.05171}, "CVE-2025-1756": {"epss_score": 0.00027, "epss_percentile": 0.06945}, "CVE-2025-1757": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2025-1758": {"epss_score": 0.0005, "epss_percentile": 0.1593}, "CVE-2025-1759": {"epss_score": 0.0007, "epss_percentile": 0.21798}, "CVE-2025-1761": {"epss_score": 0.00069, "epss_percentile": 0.21533}, "CVE-2025-1762": {"epss_score": 0.00036, "epss_percentile": 0.10318}, "CVE-2025-1763": {"epss_score": 0.00087, "epss_percentile": 0.2563}, "CVE-2025-1764": {"epss_score": 0.00059, "epss_percentile": 0.18633}, "CVE-2025-1766": {"epss_score": 0.00293, "epss_percentile": 0.52289}, "CVE-2025-1767": {"epss_score": 0.00106, "epss_percentile": 0.29402}, "CVE-2025-1768": {"epss_score": 0.00285, "epss_percentile": 0.51636}, "CVE-2025-1769": {"epss_score": 0.003, "epss_percentile": 0.52911}, "CVE-2025-1770": {"epss_score": 0.00499, "epss_percentile": 0.65259}, "CVE-2025-1771": {"epss_score": 0.01025, "epss_percentile": 0.7679}, "CVE-2025-1773": {"epss_score": 0.00388, "epss_percentile": 0.59377}, "CVE-2025-1774": {"epss_score": 0.00151, "epss_percentile": 0.36256}, "CVE-2025-1776": {"epss_score": 0.00117, "epss_percentile": 0.31294}, "CVE-2025-1777": {"epss_score": 0.00036, "epss_percentile": 0.10516}, "CVE-2025-1778": {"epss_score": 0.00045, "epss_percentile": 0.14056}, "CVE-2025-1780": {"epss_score": 0.00139, "epss_percentile": 0.34666}, "CVE-2025-1781": {"epss_score": 0.00079, "epss_percentile": 0.23901}, "CVE-2025-1783": {"epss_score": 0.00089, "epss_percentile": 0.25865}, "CVE-2025-1784": {"epss_score": 0.00081, "epss_percentile": 0.24325}, "CVE-2025-1785": {"epss_score": 0.00978, "epss_percentile": 0.76234}, "CVE-2025-1786": {"epss_score": 0.00057, "epss_percentile": 0.18175}, "CVE-2025-1788": {"epss_score": 0.0005, "epss_percentile": 0.15852}, "CVE-2025-1791": {"epss_score": 0.00226, "epss_percentile": 0.45251}, "CVE-2025-1792": {"epss_score": 0.0003, "epss_percentile": 0.08168}, "CVE-2025-1793": {"epss_score": 0.00012, "epss_percentile": 0.01414}, "CVE-2025-1795": {"epss_score": 0.00593, "epss_percentile": 0.6864}, "CVE-2025-1796": {"epss_score": 0.00114, "epss_percentile": 0.30841}, "CVE-2025-1797": {"epss_score": 0.00071, "epss_percentile": 0.22079}, "CVE-2025-1798": {"epss_score": 0.00292, "epss_percentile": 0.52263}, "CVE-2025-1799": {"epss_score": 0.00092, "epss_percentile": 0.26469}, "CVE-2025-1800": {"epss_score": 0.00495, "epss_percentile": 0.6511}, "CVE-2025-1801": {"epss_score": 0.00101, "epss_percentile": 0.28594}, "CVE-2025-1802": {"epss_score": 0.0012, "epss_percentile": 0.31722}, "CVE-2025-1804": {"epss_score": 0.00021, "epss_percentile": 0.04944}, "CVE-2025-1805": {"epss_score": 0.00085, "epss_percentile": 0.2515}, "CVE-2025-1806": {"epss_score": 0.00089, "epss_percentile": 0.25938}, "CVE-2025-1807": {"epss_score": 0.00025, "epss_percentile": 0.06226}, "CVE-2025-1808": {"epss_score": 0.00036, "epss_percentile": 0.10367}, "CVE-2025-1809": {"epss_score": 0.00036, "epss_percentile": 0.10367}, "CVE-2025-1810": {"epss_score": 0.0003, "epss_percentile": 0.08212}, "CVE-2025-1811": {"epss_score": 0.00036, "epss_percentile": 0.10367}, "CVE-2025-1812": {"epss_score": 0.00041, "epss_percentile": 0.12282}, "CVE-2025-1813": {"epss_score": 0.00036, "epss_percentile": 0.10383}, "CVE-2025-1814": {"epss_score": 0.00103, "epss_percentile": 0.28899}, "CVE-2025-1815": {"epss_score": 0.00051, "epss_percentile": 0.16061}, "CVE-2025-1816": {"epss_score": 0.00245, "epss_percentile": 0.47681}, "CVE-2025-1817": {"epss_score": 0.00081, "epss_percentile": 0.24322}, "CVE-2025-1818": {"epss_score": 0.00161, "epss_percentile": 0.37566}, "CVE-2025-1819": {"epss_score": 0.0166, "epss_percentile": 0.8162}, "CVE-2025-1820": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-1821": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-1826": {"epss_score": 0.00036, "epss_percentile": 0.1062}, "CVE-2025-1828": {"epss_score": 0.00131, "epss_percentile": 0.33503}, "CVE-2025-1829": {"epss_score": 0.03421, "epss_percentile": 0.87101}, "CVE-2025-1830": {"epss_score": 0.00089, "epss_percentile": 0.25869}, "CVE-2025-1831": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-1832": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-1833": {"epss_score": 0.0018, "epss_percentile": 0.39903}, "CVE-2025-1834": {"epss_score": 0.0019, "epss_percentile": 0.41059}, "CVE-2025-1835": {"epss_score": 0.00097, "epss_percentile": 0.2753}, "CVE-2025-1836": {"epss_score": 0.00067, "epss_percentile": 0.21116}, "CVE-2025-1838": {"epss_score": 0.00079, "epss_percentile": 0.23875}, "CVE-2025-1840": {"epss_score": 0.00129, "epss_percentile": 0.3317}, "CVE-2025-1841": {"epss_score": 0.00134, "epss_percentile": 0.33841}, "CVE-2025-1842": {"epss_score": 0.00079, "epss_percentile": 0.23874}, "CVE-2025-1843": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-1844": {"epss_score": 0.00121, "epss_percentile": 0.32011}, "CVE-2025-1845": {"epss_score": 0.01211, "epss_percentile": 0.78554}, "CVE-2025-1846": {"epss_score": 0.00274, "epss_percentile": 0.50505}, "CVE-2025-1847": {"epss_score": 0.0018, "epss_percentile": 0.39903}, "CVE-2025-1848": {"epss_score": 0.0018, "epss_percentile": 0.39903}, "CVE-2025-1849": {"epss_score": 0.0018, "epss_percentile": 0.39903}, "CVE-2025-1850": {"epss_score": 0.00133, "epss_percentile": 0.33627}, "CVE-2025-1851": {"epss_score": 0.00824, "epss_percentile": 0.73945}, "CVE-2025-1852": {"epss_score": 0.00676, "epss_percentile": 0.70932}, "CVE-2025-1853": {"epss_score": 0.01261, "epss_percentile": 0.78973}, "CVE-2025-1854": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-1855": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-1856": {"epss_score": 0.00139, "epss_percentile": 0.34549}, "CVE-2025-1857": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2025-1858": {"epss_score": 0.00141, "epss_percentile": 0.34949}, "CVE-2025-1859": {"epss_score": 0.00113, "epss_percentile": 0.30613}, "CVE-2025-1860": {"epss_score": 0.00027, "epss_percentile": 0.07165}, "CVE-2025-1861": {"epss_score": 0.00238, "epss_percentile": 0.46818}, "CVE-2025-1862": {"epss_score": 0.00315, "epss_percentile": 0.542}, "CVE-2025-1863": {"epss_score": 0.00073, "epss_percentile": 0.22546}, "CVE-2025-1864": {"epss_score": 0.0026, "epss_percentile": 0.49228}, "CVE-2025-1865": {"epss_score": 0.00025, "epss_percentile": 0.06043}, "CVE-2025-1866": {"epss_score": 0.00114, "epss_percentile": 0.30831}, "CVE-2025-1867": {"epss_score": 0.00179, "epss_percentile": 0.3977}, "CVE-2025-1868": {"epss_score": 0.00048, "epss_percentile": 0.14993}, "CVE-2025-1869": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2025-1870": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2025-1871": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2025-1872": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2025-1873": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2025-1874": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2025-1875": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2025-1876": {"epss_score": 0.00245, "epss_percentile": 0.47657}, "CVE-2025-1877": {"epss_score": 0.00304, "epss_percentile": 0.53303}, "CVE-2025-1878": {"epss_score": 0.00042, "epss_percentile": 0.12929}, "CVE-2025-1879": {"epss_score": 0.00034, "epss_percentile": 0.09793}, "CVE-2025-1880": {"epss_score": 0.00032, "epss_percentile": 0.08774}, "CVE-2025-1881": {"epss_score": 0.0008, "epss_percentile": 0.24056}, "CVE-2025-1882": {"epss_score": 0.0003, "epss_percentile": 0.08063}, "CVE-2025-1883": {"epss_score": 0.00018, "epss_percentile": 0.04046}, "CVE-2025-1884": {"epss_score": 0.00018, "epss_percentile": 0.04046}, "CVE-2025-1885": {"epss_score": 0.00031, "epss_percentile": 0.08458}, "CVE-2025-1886": {"epss_score": 0.00133, "epss_percentile": 0.33667}, "CVE-2025-1887": {"epss_score": 0.00122, "epss_percentile": 0.32128}, "CVE-2025-1888": {"epss_score": 0.00061, "epss_percentile": 0.19439}, "CVE-2025-1889": {"epss_score": 0.00036, "epss_percentile": 0.10453}, "CVE-2025-1890": {"epss_score": 0.00167, "epss_percentile": 0.38392}, "CVE-2025-1891": {"epss_score": 0.00047, "epss_percentile": 0.14916}, "CVE-2025-1892": {"epss_score": 0.00027, "epss_percentile": 0.06979}, "CVE-2025-1893": {"epss_score": 0.00108, "epss_percentile": 0.29796}, "CVE-2025-1894": {"epss_score": 0.00044, "epss_percentile": 0.13554}, "CVE-2025-1895": {"epss_score": 0.00055, "epss_percentile": 0.17647}, "CVE-2025-1896": {"epss_score": 0.00055, "epss_percentile": 0.17647}, "CVE-2025-1897": {"epss_score": 0.00055, "epss_percentile": 0.17647}, "CVE-2025-1898": {"epss_score": 0.00055, "epss_percentile": 0.17647}, "CVE-2025-1899": {"epss_score": 0.00187, "epss_percentile": 0.40793}, "CVE-2025-1900": {"epss_score": 0.00127, "epss_percentile": 0.32834}, "CVE-2025-1901": {"epss_score": 0.00127, "epss_percentile": 0.32834}, "CVE-2025-1902": {"epss_score": 0.00138, "epss_percentile": 0.34503}, "CVE-2025-1903": {"epss_score": 0.00138, "epss_percentile": 0.34396}, "CVE-2025-1904": {"epss_score": 0.00101, "epss_percentile": 0.28568}, "CVE-2025-1905": {"epss_score": 0.00101, "epss_percentile": 0.28568}, "CVE-2025-1906": {"epss_score": 0.00105, "epss_percentile": 0.29398}, "CVE-2025-1907": {"epss_score": 0.00117, "epss_percentile": 0.31278}, "CVE-2025-1908": {"epss_score": 0.00017, "epss_percentile": 0.03138}, "CVE-2025-1909": {"epss_score": 0.00427, "epss_percentile": 0.61874}, "CVE-2025-1910": {"epss_score": 0.00017, "epss_percentile": 0.03352}, "CVE-2025-1911": {"epss_score": 0.00216, "epss_percentile": 0.44224}, "CVE-2025-1912": {"epss_score": 0.00104, "epss_percentile": 0.29172}, "CVE-2025-1913": {"epss_score": 0.01373, "epss_percentile": 0.79821}, "CVE-2025-1914": {"epss_score": 0.00111, "epss_percentile": 0.30302}, "CVE-2025-1915": {"epss_score": 0.00085, "epss_percentile": 0.25165}, "CVE-2025-1916": {"epss_score": 0.00165, "epss_percentile": 0.38133}, "CVE-2025-1917": {"epss_score": 0.00087, "epss_percentile": 0.25531}, "CVE-2025-1918": {"epss_score": 0.00111, "epss_percentile": 0.30302}, "CVE-2025-1919": {"epss_score": 0.00111, "epss_percentile": 0.30302}, "CVE-2025-1920": {"epss_score": 0.00152, "epss_percentile": 0.36468}, "CVE-2025-1921": {"epss_score": 0.00095, "epss_percentile": 0.27158}, "CVE-2025-1922": {"epss_score": 0.00083, "epss_percentile": 0.24812}, "CVE-2025-1923": {"epss_score": 0.00076, "epss_percentile": 0.23126}, "CVE-2025-1925": {"epss_score": 0.0085, "epss_percentile": 0.74383}, "CVE-2025-1926": {"epss_score": 0.00025, "epss_percentile": 0.0625}, "CVE-2025-1927": {"epss_score": 0.00015, "epss_percentile": 0.0251}, "CVE-2025-1928": {"epss_score": 0.0006, "epss_percentile": 0.1909}, "CVE-2025-1929": {"epss_score": 0.00054, "epss_percentile": 0.17262}, "CVE-2025-1930": {"epss_score": 0.00379, "epss_percentile": 0.58888}, "CVE-2025-1931": {"epss_score": 0.01113, "epss_percentile": 0.77692}, "CVE-2025-1932": {"epss_score": 0.00449, "epss_percentile": 0.63044}, "CVE-2025-1933": {"epss_score": 0.00762, "epss_percentile": 0.72838}, "CVE-2025-1934": {"epss_score": 0.00539, "epss_percentile": 0.66965}, "CVE-2025-1935": {"epss_score": 0.00358, "epss_percentile": 0.57523}, "CVE-2025-1936": {"epss_score": 0.00731, "epss_percentile": 0.7218}, "CVE-2025-1937": {"epss_score": 0.00451, "epss_percentile": 0.63125}, "CVE-2025-1938": {"epss_score": 0.00423, "epss_percentile": 0.61596}, "CVE-2025-1939": {"epss_score": 0.00024, "epss_percentile": 0.05974}, "CVE-2025-1940": {"epss_score": 0.00097, "epss_percentile": 0.27533}, "CVE-2025-1941": {"epss_score": 0.00155, "epss_percentile": 0.36856}, "CVE-2025-1942": {"epss_score": 0.00371, "epss_percentile": 0.58383}, "CVE-2025-1943": {"epss_score": 0.00343, "epss_percentile": 0.5644}, "CVE-2025-1944": {"epss_score": 0.00135, "epss_percentile": 0.33991}, "CVE-2025-1945": {"epss_score": 0.00312, "epss_percentile": 0.53941}, "CVE-2025-1946": {"epss_score": 0.00696, "epss_percentile": 0.71394}, "CVE-2025-1947": {"epss_score": 0.00453, "epss_percentile": 0.63203}, "CVE-2025-1948": {"epss_score": 0.00089, "epss_percentile": 0.25796}, "CVE-2025-1949": {"epss_score": 0.00097, "epss_percentile": 0.27547}, "CVE-2025-1950": {"epss_score": 8e-05, "epss_percentile": 0.00566}, "CVE-2025-1951": {"epss_score": 9e-05, "epss_percentile": 0.00734}, "CVE-2025-1952": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2025-1953": {"epss_score": 0.00063, "epss_percentile": 0.19854}, "CVE-2025-1954": {"epss_score": 0.00121, "epss_percentile": 0.31885}, "CVE-2025-1955": {"epss_score": 0.00088, "epss_percentile": 0.25669}, "CVE-2025-1956": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2025-1957": {"epss_score": 0.00117, "epss_percentile": 0.31234}, "CVE-2025-1958": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-1959": {"epss_score": 0.00133, "epss_percentile": 0.33627}, "CVE-2025-1960": {"epss_score": 0.00177, "epss_percentile": 0.3952}, "CVE-2025-1961": {"epss_score": 0.00055, "epss_percentile": 0.17559}, "CVE-2025-1962": {"epss_score": 0.00127, "epss_percentile": 0.32897}, "CVE-2025-1963": {"epss_score": 0.00139, "epss_percentile": 0.34549}, "CVE-2025-1964": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2025-1965": {"epss_score": 0.00042, "epss_percentile": 0.12773}, "CVE-2025-1966": {"epss_score": 0.00038, "epss_percentile": 0.11407}, "CVE-2025-1967": {"epss_score": 0.00033, "epss_percentile": 0.09133}, "CVE-2025-1968": {"epss_score": 0.00064, "epss_percentile": 0.20255}, "CVE-2025-1969": {"epss_score": 0.00116, "epss_percentile": 0.31067}, "CVE-2025-1970": {"epss_score": 0.00134, "epss_percentile": 0.33781}, "CVE-2025-1971": {"epss_score": 0.01423, "epss_percentile": 0.80187}, "CVE-2025-1972": {"epss_score": 0.00291, "epss_percentile": 0.52171}, "CVE-2025-1973": {"epss_score": 0.00268, "epss_percentile": 0.50064}, "CVE-2025-1974": {"epss_score": 0.91853, "epss_percentile": 0.99673}, "CVE-2025-1975": {"epss_score": 0.00177, "epss_percentile": 0.39527}, "CVE-2025-1976": {"epss_score": 0.00709, "epss_percentile": 0.71697}, "CVE-2025-1977": {"epss_score": 0.0007, "epss_percentile": 0.21983}, "CVE-2025-1979": {"epss_score": 0.00032, "epss_percentile": 0.09003}, "CVE-2025-1980": {"epss_score": 0.00824, "epss_percentile": 0.73942}, "CVE-2025-1981": {"epss_score": 0.00048, "epss_percentile": 0.15036}, "CVE-2025-1982": {"epss_score": 0.00073, "epss_percentile": 0.22594}, "CVE-2025-1983": {"epss_score": 0.00075, "epss_percentile": 0.2291}, "CVE-2025-1984": {"epss_score": 0.00029, "epss_percentile": 0.07939}, "CVE-2025-1985": {"epss_score": 0.00033, "epss_percentile": 0.09129}, "CVE-2025-1986": {"epss_score": 0.00061, "epss_percentile": 0.19471}, "CVE-2025-1987": {"epss_score": 0.00025, "epss_percentile": 0.06154}, "CVE-2025-1991": {"epss_score": 0.0011, "epss_percentile": 0.30126}, "CVE-2025-1992": {"epss_score": 0.00044, "epss_percentile": 0.13437}, "CVE-2025-1993": {"epss_score": 0.0001, "epss_percentile": 0.00872}, "CVE-2025-1994": {"epss_score": 0.00026, "epss_percentile": 0.06564}, "CVE-2025-1997": {"epss_score": 0.00036, "epss_percentile": 0.10354}, "CVE-2025-1998": {"epss_score": 0.00017, "epss_percentile": 0.03057}, "CVE-2025-20001": {"epss_score": 0.00066, "epss_percentile": 0.20804}, "CVE-2025-20002": {"epss_score": 0.00142, "epss_percentile": 0.3501}, "CVE-2025-20003": {"epss_score": 0.00017, "epss_percentile": 0.03103}, "CVE-2025-20004": {"epss_score": 7e-05, "epss_percentile": 0.00444}, "CVE-2025-20006": {"epss_score": 0.00025, "epss_percentile": 0.06221}, "CVE-2025-20008": {"epss_score": 0.00012, "epss_percentile": 0.0141}, "CVE-2025-20009": {"epss_score": 0.0002, "epss_percentile": 0.04493}, "CVE-2025-20010": {"epss_score": 0.00021, "epss_percentile": 0.04721}, "CVE-2025-20011": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2025-20012": {"epss_score": 0.00019, "epss_percentile": 0.04097}, "CVE-2025-20013": {"epss_score": 0.00019, "epss_percentile": 0.04141}, "CVE-2025-20014": {"epss_score": 0.00342, "epss_percentile": 0.5636}, "CVE-2025-20015": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2025-20016": {"epss_score": 0.02069, "epss_percentile": 0.83467}, "CVE-2025-20017": {"epss_score": 0.00012, "epss_percentile": 0.01188}, "CVE-2025-20018": {"epss_score": 0.0002, "epss_percentile": 0.04488}, "CVE-2025-20021": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2025-20022": {"epss_score": 0.0001, "epss_percentile": 0.00905}, "CVE-2025-20023": {"epss_score": 0.00011, "epss_percentile": 0.00924}, "CVE-2025-20024": {"epss_score": 0.00029, "epss_percentile": 0.0765}, "CVE-2025-20025": {"epss_score": 8e-05, "epss_percentile": 0.00566}, "CVE-2025-20026": {"epss_score": 0.00019, "epss_percentile": 0.0422}, "CVE-2025-20029": {"epss_score": 0.58328, "epss_percentile": 0.9811}, "CVE-2025-20030": {"epss_score": 0.00014, "epss_percentile": 0.02079}, "CVE-2025-20031": {"epss_score": 0.00029, "epss_percentile": 0.07664}, "CVE-2025-20032": {"epss_score": 0.00027, "epss_percentile": 0.06753}, "CVE-2025-20033": {"epss_score": 0.00264, "epss_percentile": 0.4969}, "CVE-2025-20034": {"epss_score": 0.0002, "epss_percentile": 0.04493}, "CVE-2025-20036": {"epss_score": 0.00155, "epss_percentile": 0.36774}, "CVE-2025-20037": {"epss_score": 9e-05, "epss_percentile": 0.0065}, "CVE-2025-20039": {"epss_score": 0.0002, "epss_percentile": 0.04478}, "CVE-2025-20041": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2025-20042": {"epss_score": 0.00031, "epss_percentile": 0.08515}, "CVE-2025-20043": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2025-20044": {"epss_score": 8e-05, "epss_percentile": 0.00531}, "CVE-2025-20045": {"epss_score": 0.00397, "epss_percentile": 0.60035}, "CVE-2025-20046": {"epss_score": 0.00024, "epss_percentile": 0.06006}, "CVE-2025-20047": {"epss_score": 0.00024, "epss_percentile": 0.05809}, "CVE-2025-20048": {"epss_score": 0.00012, "epss_percentile": 0.01188}, "CVE-2025-20049": {"epss_score": 0.00076, "epss_percentile": 0.2312}, "CVE-2025-20050": {"epss_score": 0.00015, "epss_percentile": 0.02469}, "CVE-2025-20051": {"epss_score": 0.00279, "epss_percentile": 0.50974}, "CVE-2025-20052": {"epss_score": 0.00023, "epss_percentile": 0.05616}, "CVE-2025-20053": {"epss_score": 0.0001, "epss_percentile": 0.00862}, "CVE-2025-20054": {"epss_score": 0.00014, "epss_percentile": 0.01813}, "CVE-2025-20055": {"epss_score": 0.03838, "epss_percentile": 0.87826}, "CVE-2025-20056": {"epss_score": 0.00025, "epss_percentile": 0.06155}, "CVE-2025-20057": {"epss_score": 0.00034, "epss_percentile": 0.09435}, "CVE-2025-20058": {"epss_score": 0.00341, "epss_percentile": 0.5631}, "CVE-2025-20059": {"epss_score": 0.0074, "epss_percentile": 0.724}, "CVE-2025-20060": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2025-20061": {"epss_score": 0.00342, "epss_percentile": 0.5636}, "CVE-2025-20062": {"epss_score": 0.00019, "epss_percentile": 0.0422}, "CVE-2025-20063": {"epss_score": 0.00018, "epss_percentile": 0.03559}, "CVE-2025-20065": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2025-20067": {"epss_score": 0.00021, "epss_percentile": 0.04744}, "CVE-2025-20071": {"epss_score": 0.00025, "epss_percentile": 0.06324}, "CVE-2025-20072": {"epss_score": 0.00154, "epss_percentile": 0.36731}, "CVE-2025-20074": {"epss_score": 0.00019, "epss_percentile": 0.04351}, "CVE-2025-20075": {"epss_score": 0.00102, "epss_percentile": 0.28809}, "CVE-2025-20076": {"epss_score": 0.00027, "epss_percentile": 0.06927}, "CVE-2025-20077": {"epss_score": 0.00029, "epss_percentile": 0.0795}, "CVE-2025-20079": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2025-20081": {"epss_score": 0.00029, "epss_percentile": 0.0765}, "CVE-2025-20082": {"epss_score": 0.00011, "epss_percentile": 0.01091}, "CVE-2025-20083": {"epss_score": 0.00013, "epss_percentile": 0.01703}, "CVE-2025-20084": {"epss_score": 0.00034, "epss_percentile": 0.09435}, "CVE-2025-20085": {"epss_score": 0.0004, "epss_percentile": 0.11959}, "CVE-2025-20086": {"epss_score": 0.00303, "epss_percentile": 0.53207}, "CVE-2025-20087": {"epss_score": 0.00011, "epss_percentile": 0.00924}, "CVE-2025-20088": {"epss_score": 0.00303, "epss_percentile": 0.53207}, "CVE-2025-20090": {"epss_score": 0.00028, "epss_percentile": 0.07364}, "CVE-2025-20091": {"epss_score": 0.00027, "epss_percentile": 0.06772}, "CVE-2025-20092": {"epss_score": 0.00012, "epss_percentile": 0.01188}, "CVE-2025-20093": {"epss_score": 0.00012, "epss_percentile": 0.01325}, "CVE-2025-20094": {"epss_score": 0.00024, "epss_percentile": 0.06026}, "CVE-2025-20095": {"epss_score": 0.00013, "epss_percentile": 0.01699}, "CVE-2025-20097": {"epss_score": 0.00056, "epss_percentile": 0.17675}, "CVE-2025-20099": {"epss_score": 0.00011, "epss_percentile": 0.0108}, "CVE-2025-20100": {"epss_score": 0.00013, "epss_percentile": 0.01705}, "CVE-2025-20101": {"epss_score": 0.00025, "epss_percentile": 0.06241}, "CVE-2025-20102": {"epss_score": 0.00024, "epss_percentile": 0.0601}, "CVE-2025-20103": {"epss_score": 0.00031, "epss_percentile": 0.08712}, "CVE-2025-20104": {"epss_score": 0.00012, "epss_percentile": 0.01319}, "CVE-2025-20108": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2025-20109": {"epss_score": 0.00012, "epss_percentile": 0.01298}, "CVE-2025-20111": {"epss_score": 0.00053, "epss_percentile": 0.16934}, "CVE-2025-20112": {"epss_score": 0.00013, "epss_percentile": 0.015}, "CVE-2025-20113": {"epss_score": 0.0006, "epss_percentile": 0.1901}, "CVE-2025-20114": {"epss_score": 0.00047, "epss_percentile": 0.1485}, "CVE-2025-20115": {"epss_score": 0.00968, "epss_percentile": 0.76079}, "CVE-2025-20116": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2025-20117": {"epss_score": 0.00017, "epss_percentile": 0.03124}, "CVE-2025-20118": {"epss_score": 0.00036, "epss_percentile": 0.10303}, "CVE-2025-20119": {"epss_score": 0.00024, "epss_percentile": 0.05815}, "CVE-2025-20120": {"epss_score": 0.00024, "epss_percentile": 0.05955}, "CVE-2025-20122": {"epss_score": 0.00017, "epss_percentile": 0.0327}, "CVE-2025-20123": {"epss_score": 0.00057, "epss_percentile": 0.17979}, "CVE-2025-20124": {"epss_score": 0.00986, "epss_percentile": 0.76337}, "CVE-2025-20125": {"epss_score": 0.00201, "epss_percentile": 0.42305}, "CVE-2025-20126": {"epss_score": 0.00026, "epss_percentile": 0.06429}, "CVE-2025-20127": {"epss_score": 0.00251, "epss_percentile": 0.48284}, "CVE-2025-20128": {"epss_score": 0.05916, "epss_percentile": 0.90319}, "CVE-2025-20129": {"epss_score": 0.00014, "epss_percentile": 0.01832}, "CVE-2025-20130": {"epss_score": 0.00044, "epss_percentile": 0.13563}, "CVE-2025-20131": {"epss_score": 0.00061, "epss_percentile": 0.19243}, "CVE-2025-20133": {"epss_score": 0.00096, "epss_percentile": 0.27331}, "CVE-2025-20134": {"epss_score": 0.00127, "epss_percentile": 0.32935}, "CVE-2025-20135": {"epss_score": 0.00031, "epss_percentile": 0.08652}, "CVE-2025-20136": {"epss_score": 0.00175, "epss_percentile": 0.39292}, "CVE-2025-20137": {"epss_score": 0.00027, "epss_percentile": 0.06828}, "CVE-2025-20138": {"epss_score": 0.00056, "epss_percentile": 0.17659}, "CVE-2025-20139": {"epss_score": 0.00114, "epss_percentile": 0.30864}, "CVE-2025-20140": {"epss_score": 0.00019, "epss_percentile": 0.042}, "CVE-2025-20141": {"epss_score": 0.00067, "epss_percentile": 0.2098}, "CVE-2025-20142": {"epss_score": 0.00328, "epss_percentile": 0.55161}, "CVE-2025-20143": {"epss_score": 0.00019, "epss_percentile": 0.0435}, "CVE-2025-20144": {"epss_score": 0.00075, "epss_percentile": 0.23022}, "CVE-2025-20145": {"epss_score": 0.00103, "epss_percentile": 0.29013}, "CVE-2025-20146": {"epss_score": 0.00436, "epss_percentile": 0.6248}, "CVE-2025-20147": {"epss_score": 0.00031, "epss_percentile": 0.08321}, "CVE-2025-20148": {"epss_score": 0.00071, "epss_percentile": 0.21988}, "CVE-2025-20149": {"epss_score": 0.00035, "epss_percentile": 0.09925}, "CVE-2025-20150": {"epss_score": 0.0005, "epss_percentile": 0.15856}, "CVE-2025-20151": {"epss_score": 0.00054, "epss_percentile": 0.17169}, "CVE-2025-20152": {"epss_score": 0.00098, "epss_percentile": 0.27661}, "CVE-2025-20153": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-20154": {"epss_score": 0.00159, "epss_percentile": 0.37372}, "CVE-2025-20155": {"epss_score": 0.00015, "epss_percentile": 0.02557}, "CVE-2025-20156": {"epss_score": 0.00341, "epss_percentile": 0.56341}, "CVE-2025-20157": {"epss_score": 0.0002, "epss_percentile": 0.04679}, "CVE-2025-20158": {"epss_score": 0.00036, "epss_percentile": 0.10303}, "CVE-2025-20159": {"epss_score": 0.00034, "epss_percentile": 0.09552}, "CVE-2025-20160": {"epss_score": 0.00125, "epss_percentile": 0.32553}, "CVE-2025-20161": {"epss_score": 0.00046, "epss_percentile": 0.14319}, "CVE-2025-20162": {"epss_score": 0.00162, "epss_percentile": 0.37617}, "CVE-2025-20163": {"epss_score": 0.00029, "epss_percentile": 0.07827}, "CVE-2025-20164": {"epss_score": 0.00172, "epss_percentile": 0.38903}, "CVE-2025-20165": {"epss_score": 0.00397, "epss_percentile": 0.60046}, "CVE-2025-20166": {"epss_score": 0.00048, "epss_percentile": 0.15241}, "CVE-2025-20167": {"epss_score": 0.00048, "epss_percentile": 0.15241}, "CVE-2025-20168": {"epss_score": 0.00048, "epss_percentile": 0.15241}, "CVE-2025-20169": {"epss_score": 0.00368, "epss_percentile": 0.58213}, "CVE-2025-20170": {"epss_score": 0.00368, "epss_percentile": 0.58213}, "CVE-2025-20171": {"epss_score": 0.00152, "epss_percentile": 0.36434}, "CVE-2025-20172": {"epss_score": 0.00152, "epss_percentile": 0.36434}, "CVE-2025-20173": {"epss_score": 0.00152, "epss_percentile": 0.36434}, "CVE-2025-20174": {"epss_score": 0.00368, "epss_percentile": 0.58213}, "CVE-2025-20175": {"epss_score": 0.00368, "epss_percentile": 0.58213}, "CVE-2025-20176": {"epss_score": 0.00152, "epss_percentile": 0.36434}, "CVE-2025-20177": {"epss_score": 0.00022, "epss_percentile": 0.0518}, "CVE-2025-20178": {"epss_score": 0.00037, "epss_percentile": 0.10925}, "CVE-2025-20179": {"epss_score": 0.00109, "epss_percentile": 0.30023}, "CVE-2025-20180": {"epss_score": 0.00071, "epss_percentile": 0.22022}, "CVE-2025-20181": {"epss_score": 0.00044, "epss_percentile": 0.13509}, "CVE-2025-20182": {"epss_score": 0.00104, "epss_percentile": 0.29215}, "CVE-2025-20183": {"epss_score": 0.00147, "epss_percentile": 0.35667}, "CVE-2025-20184": {"epss_score": 0.00204, "epss_percentile": 0.42609}, "CVE-2025-20185": {"epss_score": 0.0003, "epss_percentile": 0.08169}, "CVE-2025-20186": {"epss_score": 0.00326, "epss_percentile": 0.55073}, "CVE-2025-20187": {"epss_score": 0.00353, "epss_percentile": 0.57167}, "CVE-2025-20188": {"epss_score": 0.02535, "epss_percentile": 0.85037}, "CVE-2025-20189": {"epss_score": 0.00019, "epss_percentile": 0.042}, "CVE-2025-20190": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2025-20191": {"epss_score": 0.00018, "epss_percentile": 0.03733}, "CVE-2025-20192": {"epss_score": 0.00187, "epss_percentile": 0.40742}, "CVE-2025-20193": {"epss_score": 0.00071, "epss_percentile": 0.22154}, "CVE-2025-20194": {"epss_score": 0.00063, "epss_percentile": 0.20088}, "CVE-2025-20195": {"epss_score": 0.00061, "epss_percentile": 0.19314}, "CVE-2025-20196": {"epss_score": 0.00073, "epss_percentile": 0.22588}, "CVE-2025-20197": {"epss_score": 0.00015, "epss_percentile": 0.0222}, "CVE-2025-20198": {"epss_score": 0.00015, "epss_percentile": 0.02587}, "CVE-2025-20199": {"epss_score": 0.00015, "epss_percentile": 0.02587}, "CVE-2025-20200": {"epss_score": 0.00015, "epss_percentile": 0.0222}, "CVE-2025-20201": {"epss_score": 0.00015, "epss_percentile": 0.0222}, "CVE-2025-20202": {"epss_score": 0.00017, "epss_percentile": 0.03311}, "CVE-2025-20203": {"epss_score": 0.00041, "epss_percentile": 0.12313}, "CVE-2025-20204": {"epss_score": 0.00071, "epss_percentile": 0.22022}, "CVE-2025-20205": {"epss_score": 0.00071, "epss_percentile": 0.22022}, "CVE-2025-20206": {"epss_score": 0.00019, "epss_percentile": 0.04167}, "CVE-2025-20207": {"epss_score": 0.00088, "epss_percentile": 0.25646}, "CVE-2025-20208": {"epss_score": 0.00056, "epss_percentile": 0.17668}, "CVE-2025-20209": {"epss_score": 0.00287, "epss_percentile": 0.51811}, "CVE-2025-20210": {"epss_score": 0.00104, "epss_percentile": 0.29141}, "CVE-2025-20211": {"epss_score": 0.00074, "epss_percentile": 0.22794}, "CVE-2025-20212": {"epss_score": 0.00144, "epss_percentile": 0.35309}, "CVE-2025-20213": {"epss_score": 0.00021, "epss_percentile": 0.04833}, "CVE-2025-20214": {"epss_score": 0.00056, "epss_percentile": 0.17778}, "CVE-2025-20215": {"epss_score": 8e-05, "epss_percentile": 0.00549}, "CVE-2025-20216": {"epss_score": 0.00034, "epss_percentile": 0.09683}, "CVE-2025-20217": {"epss_score": 0.00175, "epss_percentile": 0.39292}, "CVE-2025-20218": {"epss_score": 0.00068, "epss_percentile": 0.21282}, "CVE-2025-20219": {"epss_score": 0.00038, "epss_percentile": 0.11099}, "CVE-2025-20220": {"epss_score": 0.00022, "epss_percentile": 0.05261}, "CVE-2025-20221": {"epss_score": 0.00029, "epss_percentile": 0.07901}, "CVE-2025-20222": {"epss_score": 0.00175, "epss_percentile": 0.39292}, "CVE-2025-20223": {"epss_score": 0.00094, "epss_percentile": 0.26987}, "CVE-2025-20224": {"epss_score": 0.00131, "epss_percentile": 0.33443}, "CVE-2025-20225": {"epss_score": 0.00156, "epss_percentile": 0.36979}, "CVE-2025-20226": {"epss_score": 0.00048, "epss_percentile": 0.15152}, "CVE-2025-20227": {"epss_score": 0.00094, "epss_percentile": 0.26981}, "CVE-2025-20228": {"epss_score": 0.00026, "epss_percentile": 0.06557}, "CVE-2025-20229": {"epss_score": 0.00621, "epss_percentile": 0.69475}, "CVE-2025-20230": {"epss_score": 0.00051, "epss_percentile": 0.16247}, "CVE-2025-20231": {"epss_score": 0.0005, "epss_percentile": 0.15772}, "CVE-2025-20232": {"epss_score": 0.00048, "epss_percentile": 0.15152}, "CVE-2025-20233": {"epss_score": 0.00014, "epss_percentile": 0.01768}, "CVE-2025-20234": {"epss_score": 0.00188, "epss_percentile": 0.40831}, "CVE-2025-20235": {"epss_score": 0.00034, "epss_percentile": 0.09598}, "CVE-2025-20236": {"epss_score": 0.00138, "epss_percentile": 0.34382}, "CVE-2025-20237": {"epss_score": 0.00015, "epss_percentile": 0.02152}, "CVE-2025-20238": {"epss_score": 0.00013, "epss_percentile": 0.01705}, "CVE-2025-20239": {"epss_score": 0.00175, "epss_percentile": 0.39292}, "CVE-2025-20240": {"epss_score": 0.00058, "epss_percentile": 0.18569}, "CVE-2025-20241": {"epss_score": 0.00072, "epss_percentile": 0.22262}, "CVE-2025-20242": {"epss_score": 0.00012, "epss_percentile": 0.01324}, "CVE-2025-20243": {"epss_score": 0.00113, "epss_percentile": 0.30732}, "CVE-2025-20244": {"epss_score": 0.00166, "epss_percentile": 0.38198}, "CVE-2025-20246": {"epss_score": 0.00033, "epss_percentile": 0.09129}, "CVE-2025-20247": {"epss_score": 0.00033, "epss_percentile": 0.09129}, "CVE-2025-20248": {"epss_score": 8e-05, "epss_percentile": 0.00579}, "CVE-2025-20250": {"epss_score": 0.00033, "epss_percentile": 0.09129}, "CVE-2025-20251": {"epss_score": 0.00188, "epss_percentile": 0.40846}, "CVE-2025-20252": {"epss_score": 0.00131, "epss_percentile": 0.33443}, "CVE-2025-20253": {"epss_score": 0.00144, "epss_percentile": 0.35227}, "CVE-2025-20254": {"epss_score": 0.00131, "epss_percentile": 0.33443}, "CVE-2025-20255": {"epss_score": 0.00021, "epss_percentile": 0.04899}, "CVE-2025-20256": {"epss_score": 0.00048, "epss_percentile": 0.15099}, "CVE-2025-20257": {"epss_score": 0.0005, "epss_percentile": 0.15678}, "CVE-2025-20258": {"epss_score": 0.00018, "epss_percentile": 0.03864}, "CVE-2025-20259": {"epss_score": 0.00027, "epss_percentile": 0.06959}, "CVE-2025-20260": {"epss_score": 0.00198, "epss_percentile": 0.41987}, "CVE-2025-20261": {"epss_score": 0.00159, "epss_percentile": 0.37363}, "CVE-2025-20262": {"epss_score": 0.00206, "epss_percentile": 0.43059}, "CVE-2025-20263": {"epss_score": 0.0015, "epss_percentile": 0.36119}, "CVE-2025-20264": {"epss_score": 0.00058, "epss_percentile": 0.18464}, "CVE-2025-20265": {"epss_score": 0.00251, "epss_percentile": 0.48323}, "CVE-2025-20267": {"epss_score": 0.00028, "epss_percentile": 0.07502}, "CVE-2025-20268": {"epss_score": 0.00053, "epss_percentile": 0.16847}, "CVE-2025-20269": {"epss_score": 0.00065, "epss_percentile": 0.20495}, "CVE-2025-20270": {"epss_score": 0.00067, "epss_percentile": 0.2105}, "CVE-2025-20271": {"epss_score": 0.00092, "epss_percentile": 0.26546}, "CVE-2025-20272": {"epss_score": 0.00042, "epss_percentile": 0.12607}, "CVE-2025-20273": {"epss_score": 0.00017, "epss_percentile": 0.03155}, "CVE-2025-20274": {"epss_score": 0.00248, "epss_percentile": 0.47976}, "CVE-2025-20275": {"epss_score": 0.00466, "epss_percentile": 0.63807}, "CVE-2025-20276": {"epss_score": 0.0058, "epss_percentile": 0.68245}, "CVE-2025-20277": {"epss_score": 0.00025, "epss_percentile": 0.06346}, "CVE-2025-20278": {"epss_score": 0.00012, "epss_percentile": 0.01395}, "CVE-2025-20279": {"epss_score": 0.00028, "epss_percentile": 0.07502}, "CVE-2025-20280": {"epss_score": 0.00061, "epss_percentile": 0.19379}, "CVE-2025-20281": {"epss_score": 0.26728, "epss_percentile": 0.9617}, "CVE-2025-20282": {"epss_score": 0.00127, "epss_percentile": 0.32933}, "CVE-2025-20283": {"epss_score": 0.00077, "epss_percentile": 0.23317}, "CVE-2025-20284": {"epss_score": 0.00102, "epss_percentile": 0.2874}, "CVE-2025-20285": {"epss_score": 0.00035, "epss_percentile": 0.10087}, "CVE-2025-20286": {"epss_score": 0.00052, "epss_percentile": 0.16437}, "CVE-2025-20287": {"epss_score": 0.00073, "epss_percentile": 0.22599}, "CVE-2025-20288": {"epss_score": 0.00013, "epss_percentile": 0.01486}, "CVE-2025-20289": {"epss_score": 0.0004, "epss_percentile": 0.1191}, "CVE-2025-20290": {"epss_score": 0.00026, "epss_percentile": 0.06445}, "CVE-2025-20291": {"epss_score": 0.00038, "epss_percentile": 0.11097}, "CVE-2025-20292": {"epss_score": 0.00503, "epss_percentile": 0.65462}, "CVE-2025-20293": {"epss_score": 0.00025, "epss_percentile": 0.06295}, "CVE-2025-20294": {"epss_score": 0.00085, "epss_percentile": 0.25227}, "CVE-2025-20295": {"epss_score": 0.00037, "epss_percentile": 0.1065}, "CVE-2025-20296": {"epss_score": 0.00071, "epss_percentile": 0.22128}, "CVE-2025-20297": {"epss_score": 0.0006, "epss_percentile": 0.19082}, "CVE-2025-20298": {"epss_score": 0.0004, "epss_percentile": 0.12149}, "CVE-2025-20300": {"epss_score": 0.00037, "epss_percentile": 0.11037}, "CVE-2025-20301": {"epss_score": 0.00065, "epss_percentile": 0.20448}, "CVE-2025-20302": {"epss_score": 0.00058, "epss_percentile": 0.18264}, "CVE-2025-20303": {"epss_score": 0.00043, "epss_percentile": 0.13289}, "CVE-2025-20304": {"epss_score": 0.00043, "epss_percentile": 0.13289}, "CVE-2025-20305": {"epss_score": 0.00041, "epss_percentile": 0.12236}, "CVE-2025-20306": {"epss_score": 0.0003, "epss_percentile": 0.08202}, "CVE-2025-20307": {"epss_score": 0.00037, "epss_percentile": 0.10967}, "CVE-2025-20308": {"epss_score": 0.00015, "epss_percentile": 0.02217}, "CVE-2025-20309": {"epss_score": 0.00162, "epss_percentile": 0.37626}, "CVE-2025-20310": {"epss_score": 0.00032, "epss_percentile": 0.08799}, "CVE-2025-20311": {"epss_score": 0.00049, "epss_percentile": 0.15301}, "CVE-2025-20312": {"epss_score": 0.00261, "epss_percentile": 0.49294}, "CVE-2025-20313": {"epss_score": 0.00115, "epss_percentile": 0.30995}, "CVE-2025-20314": {"epss_score": 0.00098, "epss_percentile": 0.27803}, "CVE-2025-20315": {"epss_score": 0.00157, "epss_percentile": 0.3708}, "CVE-2025-20316": {"epss_score": 0.00034, "epss_percentile": 0.09552}, "CVE-2025-20317": {"epss_score": 0.00052, "epss_percentile": 0.16589}, "CVE-2025-20319": {"epss_score": 0.00046, "epss_percentile": 0.1432}, "CVE-2025-20320": {"epss_score": 0.00097, "epss_percentile": 0.27496}, "CVE-2025-20321": {"epss_score": 0.00023, "epss_percentile": 0.05373}, "CVE-2025-20322": {"epss_score": 0.00045, "epss_percentile": 0.13952}, "CVE-2025-20323": {"epss_score": 0.00037, "epss_percentile": 0.11037}, "CVE-2025-20324": {"epss_score": 0.00036, "epss_percentile": 0.10274}, "CVE-2025-20325": {"epss_score": 0.00031, "epss_percentile": 0.08658}, "CVE-2025-20326": {"epss_score": 0.00036, "epss_percentile": 0.10436}, "CVE-2025-20327": {"epss_score": 0.00182, "epss_percentile": 0.40269}, "CVE-2025-20328": {"epss_score": 0.00066, "epss_percentile": 0.20827}, "CVE-2025-20329": {"epss_score": 0.00053, "epss_percentile": 0.16886}, "CVE-2025-20330": {"epss_score": 0.00066, "epss_percentile": 0.20944}, "CVE-2025-20331": {"epss_score": 0.00025, "epss_percentile": 0.06278}, "CVE-2025-20332": {"epss_score": 0.00094, "epss_percentile": 0.26997}, "CVE-2025-20333": {"epss_score": 0.08671, "epss_percentile": 0.92182}, "CVE-2025-20334": {"epss_score": 0.00133, "epss_percentile": 0.33721}, "CVE-2025-20335": {"epss_score": 0.0007, "epss_percentile": 0.21658}, "CVE-2025-20336": {"epss_score": 0.00024, "epss_percentile": 0.05733}, "CVE-2025-20337": {"epss_score": 0.00612, "epss_percentile": 0.69229}, "CVE-2025-20338": {"epss_score": 0.00016, "epss_percentile": 0.02612}, "CVE-2025-20339": {"epss_score": 0.00034, "epss_percentile": 0.09552}, "CVE-2025-20340": {"epss_score": 0.00049, "epss_percentile": 0.15301}, "CVE-2025-20341": {"epss_score": 0.00275, "epss_percentile": 0.50679}, "CVE-2025-20342": {"epss_score": 0.00066, "epss_percentile": 0.20827}, "CVE-2025-20343": {"epss_score": 0.0015, "epss_percentile": 0.36135}, "CVE-2025-20344": {"epss_score": 0.00114, "epss_percentile": 0.30816}, "CVE-2025-20345": {"epss_score": 0.00184, "epss_percentile": 0.40423}, "CVE-2025-20346": {"epss_score": 0.00047, "epss_percentile": 0.14801}, "CVE-2025-20347": {"epss_score": 0.00088, "epss_percentile": 0.2572}, "CVE-2025-20348": {"epss_score": 0.00068, "epss_percentile": 0.21266}, "CVE-2025-20349": {"epss_score": 0.00309, "epss_percentile": 0.53651}, "CVE-2025-20350": {"epss_score": 0.00093, "epss_percentile": 0.26655}, "CVE-2025-20351": {"epss_score": 0.00054, "epss_percentile": 0.17303}, "CVE-2025-20352": {"epss_score": 0.0208, "epss_percentile": 0.83531}, "CVE-2025-20353": {"epss_score": 0.00024, "epss_percentile": 0.05864}, "CVE-2025-20354": {"epss_score": 0.00136, "epss_percentile": 0.34189}, "CVE-2025-20355": {"epss_score": 0.00024, "epss_percentile": 0.0585}, "CVE-2025-20356": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-20357": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-20358": {"epss_score": 0.00291, "epss_percentile": 0.52204}, "CVE-2025-20359": {"epss_score": 0.00291, "epss_percentile": 0.5216}, "CVE-2025-20360": {"epss_score": 0.00134, "epss_percentile": 0.33773}, "CVE-2025-20361": {"epss_score": 0.00045, "epss_percentile": 0.14065}, "CVE-2025-20362": {"epss_score": 0.42189, "epss_percentile": 0.97317}, "CVE-2025-20363": {"epss_score": 0.00373, "epss_percentile": 0.58514}, "CVE-2025-20364": {"epss_score": 0.00015, "epss_percentile": 0.0235}, "CVE-2025-20365": {"epss_score": 0.00039, "epss_percentile": 0.11764}, "CVE-2025-20366": {"epss_score": 0.00044, "epss_percentile": 0.13656}, "CVE-2025-20367": {"epss_score": 0.00049, "epss_percentile": 0.15632}, "CVE-2025-20368": {"epss_score": 0.00049, "epss_percentile": 0.15632}, "CVE-2025-20369": {"epss_score": 0.00044, "epss_percentile": 0.13648}, "CVE-2025-20370": {"epss_score": 0.00104, "epss_percentile": 0.29189}, "CVE-2025-20371": {"epss_score": 0.00075, "epss_percentile": 0.22916}, "CVE-2025-20373": {"epss_score": 0.00036, "epss_percentile": 0.10379}, "CVE-2025-20374": {"epss_score": 0.00258, "epss_percentile": 0.48955}, "CVE-2025-20375": {"epss_score": 0.00053, "epss_percentile": 0.16852}, "CVE-2025-20376": {"epss_score": 0.00056, "epss_percentile": 0.17777}, "CVE-2025-20377": {"epss_score": 0.00049, "epss_percentile": 0.15417}, "CVE-2025-20378": {"epss_score": 0.00048, "epss_percentile": 0.14968}, "CVE-2025-20379": {"epss_score": 0.00028, "epss_percentile": 0.0725}, "CVE-2025-20381": {"epss_score": 0.00046, "epss_percentile": 0.14146}, "CVE-2025-20382": {"epss_score": 0.00031, "epss_percentile": 0.08565}, "CVE-2025-20383": {"epss_score": 0.00037, "epss_percentile": 0.10836}, "CVE-2025-20384": {"epss_score": 0.00066, "epss_percentile": 0.20807}, "CVE-2025-20385": {"epss_score": 0.00041, "epss_percentile": 0.12227}, "CVE-2025-20386": {"epss_score": 0.00029, "epss_percentile": 0.079}, "CVE-2025-20387": {"epss_score": 0.00029, "epss_percentile": 0.079}, "CVE-2025-20388": {"epss_score": 0.00044, "epss_percentile": 0.13674}, "CVE-2025-20389": {"epss_score": 0.00061, "epss_percentile": 0.19487}, "CVE-2025-20393": {"epss_score": 0.06766, "epss_percentile": 0.91012}, "CVE-2025-20611": {"epss_score": 0.00014, "epss_percentile": 0.0202}, "CVE-2025-20612": {"epss_score": 0.0002, "epss_percentile": 0.04676}, "CVE-2025-20613": {"epss_score": 0.00014, "epss_percentile": 0.01895}, "CVE-2025-20614": {"epss_score": 0.00016, "epss_percentile": 0.02943}, "CVE-2025-20615": {"epss_score": 0.00064, "epss_percentile": 0.20327}, "CVE-2025-20616": {"epss_score": 0.00022, "epss_percentile": 0.05265}, "CVE-2025-20617": {"epss_score": 0.01371, "epss_percentile": 0.7981}, "CVE-2025-20618": {"epss_score": 0.00023, "epss_percentile": 0.05633}, "CVE-2025-20620": {"epss_score": 0.00115, "epss_percentile": 0.31034}, "CVE-2025-20621": {"epss_score": 0.00264, "epss_percentile": 0.4969}, "CVE-2025-20622": {"epss_score": 0.00015, "epss_percentile": 0.02419}, "CVE-2025-20623": {"epss_score": 0.00018, "epss_percentile": 0.04038}, "CVE-2025-20624": {"epss_score": 0.00022, "epss_percentile": 0.05242}, "CVE-2025-20625": {"epss_score": 0.00028, "epss_percentile": 0.07318}, "CVE-2025-20626": {"epss_score": 0.00027, "epss_percentile": 0.06772}, "CVE-2025-20627": {"epss_score": 0.00012, "epss_percentile": 0.01188}, "CVE-2025-20629": {"epss_score": 0.00013, "epss_percentile": 0.01699}, "CVE-2025-20630": {"epss_score": 0.00154, "epss_percentile": 0.36731}, "CVE-2025-20631": {"epss_score": 0.00037, "epss_percentile": 0.10768}, "CVE-2025-20632": {"epss_score": 0.00037, "epss_percentile": 0.10768}, "CVE-2025-20633": {"epss_score": 0.002, "epss_percentile": 0.42241}, "CVE-2025-20634": {"epss_score": 0.00839, "epss_percentile": 0.7419}, "CVE-2025-20635": {"epss_score": 0.00016, "epss_percentile": 0.02728}, "CVE-2025-20636": {"epss_score": 0.0001, "epss_percentile": 0.00829}, "CVE-2025-20637": {"epss_score": 0.00231, "epss_percentile": 0.45847}, "CVE-2025-20638": {"epss_score": 0.00015, "epss_percentile": 0.02172}, "CVE-2025-20639": {"epss_score": 0.00016, "epss_percentile": 0.02728}, "CVE-2025-20640": {"epss_score": 0.00015, "epss_percentile": 0.02172}, "CVE-2025-20641": {"epss_score": 8e-05, "epss_percentile": 0.0059}, "CVE-2025-20642": {"epss_score": 0.00016, "epss_percentile": 0.02728}, "CVE-2025-20643": {"epss_score": 0.00014, "epss_percentile": 0.01922}, "CVE-2025-20644": {"epss_score": 0.00508, "epss_percentile": 0.65714}, "CVE-2025-20645": {"epss_score": 0.0001, "epss_percentile": 0.00771}, "CVE-2025-20646": {"epss_score": 0.00572, "epss_percentile": 0.68007}, "CVE-2025-20647": {"epss_score": 0.00592, "epss_percentile": 0.68616}, "CVE-2025-20648": {"epss_score": 0.0001, "epss_percentile": 0.0079}, "CVE-2025-20649": {"epss_score": 0.00049, "epss_percentile": 0.15356}, "CVE-2025-20650": {"epss_score": 0.00021, "epss_percentile": 0.04729}, "CVE-2025-20651": {"epss_score": 0.00014, "epss_percentile": 0.01742}, "CVE-2025-20652": {"epss_score": 0.00018, "epss_percentile": 0.03657}, "CVE-2025-20653": {"epss_score": 8e-05, "epss_percentile": 0.00486}, "CVE-2025-20654": {"epss_score": 0.00518, "epss_percentile": 0.66126}, "CVE-2025-20655": {"epss_score": 9e-05, "epss_percentile": 0.00624}, "CVE-2025-20656": {"epss_score": 0.00017, "epss_percentile": 0.03396}, "CVE-2025-20657": {"epss_score": 8e-05, "epss_percentile": 0.00511}, "CVE-2025-20658": {"epss_score": 0.00015, "epss_percentile": 0.02391}, "CVE-2025-20659": {"epss_score": 0.00268, "epss_percentile": 0.50069}, "CVE-2025-20660": {"epss_score": 8e-05, "epss_percentile": 0.00511}, "CVE-2025-20661": {"epss_score": 8e-05, "epss_percentile": 0.00511}, "CVE-2025-20662": {"epss_score": 8e-05, "epss_percentile": 0.00511}, "CVE-2025-20663": {"epss_score": 0.00083, "epss_percentile": 0.24706}, "CVE-2025-20664": {"epss_score": 0.00083, "epss_percentile": 0.24706}, "CVE-2025-20665": {"epss_score": 6e-05, "epss_percentile": 0.00321}, "CVE-2025-20666": {"epss_score": 0.00304, "epss_percentile": 0.5325}, "CVE-2025-20667": {"epss_score": 0.00116, "epss_percentile": 0.31163}, "CVE-2025-20668": {"epss_score": 7e-05, "epss_percentile": 0.00336}, "CVE-2025-20670": {"epss_score": 0.0008, "epss_percentile": 0.24109}, "CVE-2025-20671": {"epss_score": 5e-05, "epss_percentile": 0.00214}, "CVE-2025-20672": {"epss_score": 0.00174, "epss_percentile": 0.39141}, "CVE-2025-20673": {"epss_score": 0.0003, "epss_percentile": 0.08071}, "CVE-2025-20674": {"epss_score": 0.0031, "epss_percentile": 0.53764}, "CVE-2025-20675": {"epss_score": 0.0003, "epss_percentile": 0.08071}, "CVE-2025-20676": {"epss_score": 0.0003, "epss_percentile": 0.08071}, "CVE-2025-20677": {"epss_score": 0.0003, "epss_percentile": 0.08071}, "CVE-2025-20678": {"epss_score": 0.00141, "epss_percentile": 0.34816}, "CVE-2025-20680": {"epss_score": 0.00113, "epss_percentile": 0.30658}, "CVE-2025-20681": {"epss_score": 0.00113, "epss_percentile": 0.30658}, "CVE-2025-20682": {"epss_score": 0.00113, "epss_percentile": 0.30658}, "CVE-2025-20683": {"epss_score": 0.00113, "epss_percentile": 0.30658}, "CVE-2025-20684": {"epss_score": 0.00113, "epss_percentile": 0.30658}, "CVE-2025-20685": {"epss_score": 0.00043, "epss_percentile": 0.12966}, "CVE-2025-20686": {"epss_score": 0.00043, "epss_percentile": 0.12966}, "CVE-2025-20687": {"epss_score": 0.00028, "epss_percentile": 0.07273}, "CVE-2025-20688": {"epss_score": 0.00017, "epss_percentile": 0.03114}, "CVE-2025-20689": {"epss_score": 0.00017, "epss_percentile": 0.03114}, "CVE-2025-20690": {"epss_score": 0.00017, "epss_percentile": 0.03114}, "CVE-2025-20691": {"epss_score": 0.00017, "epss_percentile": 0.03114}, "CVE-2025-20692": {"epss_score": 0.00017, "epss_percentile": 0.03114}, "CVE-2025-20693": {"epss_score": 0.00011, "epss_percentile": 0.00977}, "CVE-2025-20694": {"epss_score": 0.00026, "epss_percentile": 0.06419}, "CVE-2025-20695": {"epss_score": 0.00026, "epss_percentile": 0.06419}, "CVE-2025-20696": {"epss_score": 0.0001, "epss_percentile": 0.0091}, "CVE-2025-20697": {"epss_score": 6e-05, "epss_percentile": 0.00244}, "CVE-2025-20698": {"epss_score": 6e-05, "epss_percentile": 0.00244}, "CVE-2025-20700": {"epss_score": 0.00038, "epss_percentile": 0.11072}, "CVE-2025-20701": {"epss_score": 0.00066, "epss_percentile": 0.20928}, "CVE-2025-20702": {"epss_score": 0.0009, "epss_percentile": 0.2616}, "CVE-2025-20703": {"epss_score": 0.00466, "epss_percentile": 0.63797}, "CVE-2025-20704": {"epss_score": 0.00281, "epss_percentile": 0.51151}, "CVE-2025-20705": {"epss_score": 8e-05, "epss_percentile": 0.00572}, "CVE-2025-20706": {"epss_score": 8e-05, "epss_percentile": 0.00572}, "CVE-2025-20707": {"epss_score": 8e-05, "epss_percentile": 0.00496}, "CVE-2025-20708": {"epss_score": 0.00438, "epss_percentile": 0.62573}, "CVE-2025-20709": {"epss_score": 0.00025, "epss_percentile": 0.0611}, "CVE-2025-20710": {"epss_score": 0.00053, "epss_percentile": 0.16727}, "CVE-2025-20711": {"epss_score": 0.00049, "epss_percentile": 0.15636}, "CVE-2025-20712": {"epss_score": 0.00025, "epss_percentile": 0.0611}, "CVE-2025-20713": {"epss_score": 0.00015, "epss_percentile": 0.02317}, "CVE-2025-20714": {"epss_score": 0.00015, "epss_percentile": 0.02317}, "CVE-2025-20715": {"epss_score": 0.00015, "epss_percentile": 0.02317}, "CVE-2025-20716": {"epss_score": 0.00015, "epss_percentile": 0.02317}, "CVE-2025-20717": {"epss_score": 0.00015, "epss_percentile": 0.02317}, "CVE-2025-20718": {"epss_score": 0.00016, "epss_percentile": 0.02683}, "CVE-2025-20719": {"epss_score": 0.00025, "epss_percentile": 0.0611}, "CVE-2025-20720": {"epss_score": 0.00025, "epss_percentile": 0.0611}, "CVE-2025-20721": {"epss_score": 7e-05, "epss_percentile": 0.00331}, "CVE-2025-20722": {"epss_score": 7e-05, "epss_percentile": 0.00385}, "CVE-2025-20723": {"epss_score": 7e-05, "epss_percentile": 0.00331}, "CVE-2025-20724": {"epss_score": 0.00018, "epss_percentile": 0.03887}, "CVE-2025-20725": {"epss_score": 0.00264, "epss_percentile": 0.49693}, "CVE-2025-20726": {"epss_score": 0.00264, "epss_percentile": 0.49693}, "CVE-2025-20727": {"epss_score": 0.00189, "epss_percentile": 0.41004}, "CVE-2025-20728": {"epss_score": 0.00014, "epss_percentile": 0.01764}, "CVE-2025-20729": {"epss_score": 0.00014, "epss_percentile": 0.01747}, "CVE-2025-20730": {"epss_score": 6e-05, "epss_percentile": 0.00292}, "CVE-2025-20731": {"epss_score": 0.0001, "epss_percentile": 0.00801}, "CVE-2025-20732": {"epss_score": 0.0001, "epss_percentile": 0.00801}, "CVE-2025-20733": {"epss_score": 0.00014, "epss_percentile": 0.01764}, "CVE-2025-20734": {"epss_score": 0.0001, "epss_percentile": 0.00801}, "CVE-2025-20735": {"epss_score": 0.00014, "epss_percentile": 0.01764}, "CVE-2025-20736": {"epss_score": 0.00018, "epss_percentile": 0.03731}, "CVE-2025-20737": {"epss_score": 0.00014, "epss_percentile": 0.01764}, "CVE-2025-20738": {"epss_score": 0.00018, "epss_percentile": 0.03731}, "CVE-2025-20739": {"epss_score": 0.00018, "epss_percentile": 0.03731}, "CVE-2025-20740": {"epss_score": 0.00014, "epss_percentile": 0.02035}, "CVE-2025-20741": {"epss_score": 0.00018, "epss_percentile": 0.03731}, "CVE-2025-20742": {"epss_score": 0.00022, "epss_percentile": 0.0523}, "CVE-2025-20743": {"epss_score": 5e-05, "epss_percentile": 0.00174}, "CVE-2025-20744": {"epss_score": 5e-05, "epss_percentile": 0.00174}, "CVE-2025-20745": {"epss_score": 5e-05, "epss_percentile": 0.00174}, "CVE-2025-20746": {"epss_score": 6e-05, "epss_percentile": 0.00277}, "CVE-2025-20747": {"epss_score": 6e-05, "epss_percentile": 0.00277}, "CVE-2025-20748": {"epss_score": 0.00018, "epss_percentile": 0.03731}, "CVE-2025-20749": {"epss_score": 6e-05, "epss_percentile": 0.00277}, "CVE-2025-20750": {"epss_score": 0.00287, "epss_percentile": 0.51861}, "CVE-2025-20751": {"epss_score": 0.00247, "epss_percentile": 0.47825}, "CVE-2025-20752": {"epss_score": 0.00247, "epss_percentile": 0.47825}, "CVE-2025-20753": {"epss_score": 0.00247, "epss_percentile": 0.47825}, "CVE-2025-20754": {"epss_score": 0.00247, "epss_percentile": 0.47825}, "CVE-2025-20755": {"epss_score": 0.00287, "epss_percentile": 0.51861}, "CVE-2025-20756": {"epss_score": 0.00219, "epss_percentile": 0.4449}, "CVE-2025-20757": {"epss_score": 0.00218, "epss_percentile": 0.44372}, "CVE-2025-20758": {"epss_score": 0.00333, "epss_percentile": 0.55651}, "CVE-2025-20759": {"epss_score": 0.00218, "epss_percentile": 0.44372}, "CVE-2025-20760": {"epss_score": 0.00211, "epss_percentile": 0.43717}, "CVE-2025-20761": {"epss_score": 0.00211, "epss_percentile": 0.43717}, "CVE-2025-20762": {"epss_score": 0.00211, "epss_percentile": 0.43717}, "CVE-2025-20763": {"epss_score": 6e-05, "epss_percentile": 0.00254}, "CVE-2025-20764": {"epss_score": 6e-05, "epss_percentile": 0.00254}, "CVE-2025-20765": {"epss_score": 5e-05, "epss_percentile": 0.00217}, "CVE-2025-20766": {"epss_score": 6e-05, "epss_percentile": 0.00254}, "CVE-2025-20767": {"epss_score": 6e-05, "epss_percentile": 0.00254}, "CVE-2025-20768": {"epss_score": 6e-05, "epss_percentile": 0.00254}, "CVE-2025-20769": {"epss_score": 4e-05, "epss_percentile": 0.00172}, "CVE-2025-20770": {"epss_score": 6e-05, "epss_percentile": 0.00277}, "CVE-2025-20771": {"epss_score": 6e-05, "epss_percentile": 0.00277}, "CVE-2025-20772": {"epss_score": 6e-05, "epss_percentile": 0.00277}, "CVE-2025-20773": {"epss_score": 6e-05, "epss_percentile": 0.00277}, "CVE-2025-20774": {"epss_score": 6e-05, "epss_percentile": 0.00277}, "CVE-2025-20775": {"epss_score": 6e-05, "epss_percentile": 0.00277}, "CVE-2025-20776": {"epss_score": 6e-05, "epss_percentile": 0.00277}, "CVE-2025-20777": {"epss_score": 6e-05, "epss_percentile": 0.00277}, "CVE-2025-20778": {"epss_score": 0.00013, "epss_percentile": 0.01578}, "CVE-2025-20779": {"epss_score": 0.00013, "epss_percentile": 0.01578}, "CVE-2025-20780": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-20781": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-20782": {"epss_score": 0.00012, "epss_percentile": 0.01275}, "CVE-2025-20783": {"epss_score": 0.00012, "epss_percentile": 0.01275}, "CVE-2025-20784": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-20785": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-20786": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-20787": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-20788": {"epss_score": 6e-05, "epss_percentile": 0.00298}, "CVE-2025-20789": {"epss_score": 5e-05, "epss_percentile": 0.00175}, "CVE-2025-20790": {"epss_score": 0.00254, "epss_percentile": 0.48519}, "CVE-2025-20791": {"epss_score": 0.00247, "epss_percentile": 0.47825}, "CVE-2025-20792": {"epss_score": 0.00247, "epss_percentile": 0.47825}, "CVE-2025-20793": {"epss_score": 0.00246, "epss_percentile": 0.47805}, "CVE-2025-20794": {"epss_score": 0.00211, "epss_percentile": 0.43717}, "CVE-2025-20795": {"epss_score": 0.00013, "epss_percentile": 0.01578}, "CVE-2025-20796": {"epss_score": 0.00019, "epss_percentile": 0.04258}, "CVE-2025-20797": {"epss_score": 0.00013, "epss_percentile": 0.01578}, "CVE-2025-20798": {"epss_score": 0.00013, "epss_percentile": 0.01578}, "CVE-2025-20799": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-20800": {"epss_score": 0.00013, "epss_percentile": 0.01578}, "CVE-2025-20801": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-20802": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-20803": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-20804": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-20805": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-20806": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-20807": {"epss_score": 0.00012, "epss_percentile": 0.01275}, "CVE-2025-20881": {"epss_score": 0.00027, "epss_percentile": 0.07122}, "CVE-2025-20882": {"epss_score": 0.00026, "epss_percentile": 0.06655}, "CVE-2025-20883": {"epss_score": 0.00056, "epss_percentile": 0.17731}, "CVE-2025-20884": {"epss_score": 0.00056, "epss_percentile": 0.17731}, "CVE-2025-20885": {"epss_score": 0.00028, "epss_percentile": 0.07511}, "CVE-2025-20886": {"epss_score": 0.00026, "epss_percentile": 0.06552}, "CVE-2025-20887": {"epss_score": 0.00028, "epss_percentile": 0.07514}, "CVE-2025-20888": {"epss_score": 0.00027, "epss_percentile": 0.07122}, "CVE-2025-20889": {"epss_score": 0.00028, "epss_percentile": 0.07514}, "CVE-2025-20890": {"epss_score": 0.00027, "epss_percentile": 0.07122}, "CVE-2025-20891": {"epss_score": 0.00028, "epss_percentile": 0.07514}, "CVE-2025-20892": {"epss_score": 0.00044, "epss_percentile": 0.13601}, "CVE-2025-20893": {"epss_score": 0.0004, "epss_percentile": 0.12018}, "CVE-2025-20894": {"epss_score": 0.00056, "epss_percentile": 0.17731}, "CVE-2025-20895": {"epss_score": 0.00039, "epss_percentile": 0.11481}, "CVE-2025-20896": {"epss_score": 0.00033, "epss_percentile": 0.09123}, "CVE-2025-20897": {"epss_score": 0.00036, "epss_percentile": 0.1032}, "CVE-2025-20898": {"epss_score": 0.00059, "epss_percentile": 0.18783}, "CVE-2025-20899": {"epss_score": 0.00033, "epss_percentile": 0.09141}, "CVE-2025-20900": {"epss_score": 0.00034, "epss_percentile": 0.09801}, "CVE-2025-20901": {"epss_score": 0.00034, "epss_percentile": 0.09801}, "CVE-2025-20902": {"epss_score": 0.00032, "epss_percentile": 0.091}, "CVE-2025-20903": {"epss_score": 0.00019, "epss_percentile": 0.04132}, "CVE-2025-20904": {"epss_score": 0.00037, "epss_percentile": 0.10995}, "CVE-2025-20905": {"epss_score": 0.00032, "epss_percentile": 0.08818}, "CVE-2025-20906": {"epss_score": 0.00031, "epss_percentile": 0.08575}, "CVE-2025-20907": {"epss_score": 0.00031, "epss_percentile": 0.08379}, "CVE-2025-20908": {"epss_score": 0.00054, "epss_percentile": 0.1717}, "CVE-2025-20909": {"epss_score": 0.00029, "epss_percentile": 0.07925}, "CVE-2025-20910": {"epss_score": 0.00032, "epss_percentile": 0.09108}, "CVE-2025-20911": {"epss_score": 0.00025, "epss_percentile": 0.06337}, "CVE-2025-20912": {"epss_score": 0.00032, "epss_percentile": 0.09108}, "CVE-2025-20913": {"epss_score": 0.00035, "epss_percentile": 0.09898}, "CVE-2025-20914": {"epss_score": 0.00092, "epss_percentile": 0.26528}, "CVE-2025-20915": {"epss_score": 0.00092, "epss_percentile": 0.26528}, "CVE-2025-20916": {"epss_score": 0.00092, "epss_percentile": 0.26528}, "CVE-2025-20917": {"epss_score": 0.00092, "epss_percentile": 0.26528}, "CVE-2025-20918": {"epss_score": 0.00092, "epss_percentile": 0.26528}, "CVE-2025-20919": {"epss_score": 0.00092, "epss_percentile": 0.26528}, "CVE-2025-20920": {"epss_score": 0.00092, "epss_percentile": 0.26528}, "CVE-2025-20921": {"epss_score": 0.00092, "epss_percentile": 0.26528}, "CVE-2025-20922": {"epss_score": 0.00092, "epss_percentile": 0.26528}, "CVE-2025-20923": {"epss_score": 0.00024, "epss_percentile": 0.05733}, "CVE-2025-20924": {"epss_score": 0.00051, "epss_percentile": 0.16125}, "CVE-2025-20925": {"epss_score": 0.00031, "epss_percentile": 0.08515}, "CVE-2025-20926": {"epss_score": 0.00026, "epss_percentile": 0.06621}, "CVE-2025-20927": {"epss_score": 0.00031, "epss_percentile": 0.08515}, "CVE-2025-20928": {"epss_score": 0.00031, "epss_percentile": 0.08515}, "CVE-2025-20929": {"epss_score": 0.00029, "epss_percentile": 0.07912}, "CVE-2025-20930": {"epss_score": 0.00031, "epss_percentile": 0.08515}, "CVE-2025-20931": {"epss_score": 0.00029, "epss_percentile": 0.07912}, "CVE-2025-20932": {"epss_score": 0.00031, "epss_percentile": 0.08515}, "CVE-2025-20933": {"epss_score": 0.00031, "epss_percentile": 0.08515}, "CVE-2025-20934": {"epss_score": 0.00023, "epss_percentile": 0.05468}, "CVE-2025-20935": {"epss_score": 0.00019, "epss_percentile": 0.04406}, "CVE-2025-20936": {"epss_score": 0.00022, "epss_percentile": 0.05045}, "CVE-2025-20937": {"epss_score": 0.00017, "epss_percentile": 0.03324}, "CVE-2025-20938": {"epss_score": 0.00023, "epss_percentile": 0.05468}, "CVE-2025-20939": {"epss_score": 0.00015, "epss_percentile": 0.02128}, "CVE-2025-20940": {"epss_score": 0.00024, "epss_percentile": 0.06007}, "CVE-2025-20941": {"epss_score": 0.00026, "epss_percentile": 0.06484}, "CVE-2025-20942": {"epss_score": 0.00024, "epss_percentile": 0.05657}, "CVE-2025-20943": {"epss_score": 0.00021, "epss_percentile": 0.04849}, "CVE-2025-20944": {"epss_score": 0.00027, "epss_percentile": 0.07118}, "CVE-2025-20945": {"epss_score": 0.00023, "epss_percentile": 0.05628}, "CVE-2025-20946": {"epss_score": 0.00034, "epss_percentile": 0.09621}, "CVE-2025-20947": {"epss_score": 0.00019, "epss_percentile": 0.04406}, "CVE-2025-20948": {"epss_score": 0.00027, "epss_percentile": 0.06946}, "CVE-2025-20949": {"epss_score": 0.00091, "epss_percentile": 0.262}, "CVE-2025-20950": {"epss_score": 0.00024, "epss_percentile": 0.06022}, "CVE-2025-20951": {"epss_score": 0.00029, "epss_percentile": 0.0773}, "CVE-2025-20952": {"epss_score": 0.00023, "epss_percentile": 0.05468}, "CVE-2025-20953": {"epss_score": 0.00018, "epss_percentile": 0.04006}, "CVE-2025-20954": {"epss_score": 0.00013, "epss_percentile": 0.01585}, "CVE-2025-20955": {"epss_score": 0.00015, "epss_percentile": 0.02583}, "CVE-2025-20956": {"epss_score": 0.00015, "epss_percentile": 0.02214}, "CVE-2025-20957": {"epss_score": 0.00017, "epss_percentile": 0.03328}, "CVE-2025-20958": {"epss_score": 0.00021, "epss_percentile": 0.04709}, "CVE-2025-20959": {"epss_score": 0.00017, "epss_percentile": 0.03332}, "CVE-2025-20960": {"epss_score": 0.00019, "epss_percentile": 0.04335}, "CVE-2025-20961": {"epss_score": 0.00013, "epss_percentile": 0.01559}, "CVE-2025-20962": {"epss_score": 0.00019, "epss_percentile": 0.04092}, "CVE-2025-20963": {"epss_score": 0.00013, "epss_percentile": 0.01706}, "CVE-2025-20964": {"epss_score": 0.00013, "epss_percentile": 0.01706}, "CVE-2025-20965": {"epss_score": 0.00017, "epss_percentile": 0.03325}, "CVE-2025-20966": {"epss_score": 0.00023, "epss_percentile": 0.05452}, "CVE-2025-20967": {"epss_score": 0.00017, "epss_percentile": 0.03115}, "CVE-2025-20968": {"epss_score": 0.0005, "epss_percentile": 0.15888}, "CVE-2025-20969": {"epss_score": 0.00025, "epss_percentile": 0.06275}, "CVE-2025-20970": {"epss_score": 0.00016, "epss_percentile": 0.02613}, "CVE-2025-20971": {"epss_score": 0.00025, "epss_percentile": 0.06275}, "CVE-2025-20972": {"epss_score": 0.00019, "epss_percentile": 0.04251}, "CVE-2025-20973": {"epss_score": 0.00016, "epss_percentile": 0.02682}, "CVE-2025-20974": {"epss_score": 0.00016, "epss_percentile": 0.02896}, "CVE-2025-20975": {"epss_score": 0.00015, "epss_percentile": 0.02583}, "CVE-2025-20976": {"epss_score": 0.00039, "epss_percentile": 0.11806}, "CVE-2025-20977": {"epss_score": 0.00014, "epss_percentile": 0.0196}, "CVE-2025-20978": {"epss_score": 0.00016, "epss_percentile": 0.02613}, "CVE-2025-20979": {"epss_score": 7e-05, "epss_percentile": 0.00416}, "CVE-2025-20980": {"epss_score": 6e-05, "epss_percentile": 0.00303}, "CVE-2025-20981": {"epss_score": 0.00017, "epss_percentile": 0.03399}, "CVE-2025-20982": {"epss_score": 0.00012, "epss_percentile": 0.01137}, "CVE-2025-20983": {"epss_score": 0.00012, "epss_percentile": 0.01137}, "CVE-2025-20984": {"epss_score": 0.00015, "epss_percentile": 0.02271}, "CVE-2025-20985": {"epss_score": 0.00015, "epss_percentile": 0.02188}, "CVE-2025-20986": {"epss_score": 0.00015, "epss_percentile": 0.02583}, "CVE-2025-20987": {"epss_score": 0.00014, "epss_percentile": 0.01864}, "CVE-2025-20988": {"epss_score": 0.00017, "epss_percentile": 0.03147}, "CVE-2025-20989": {"epss_score": 0.00014, "epss_percentile": 0.01864}, "CVE-2025-20990": {"epss_score": 0.00016, "epss_percentile": 0.02957}, "CVE-2025-20991": {"epss_score": 0.00016, "epss_percentile": 0.02932}, "CVE-2025-20992": {"epss_score": 0.00015, "epss_percentile": 0.02486}, "CVE-2025-20993": {"epss_score": 0.00017, "epss_percentile": 0.03185}, "CVE-2025-20994": {"epss_score": 0.00012, "epss_percentile": 0.01336}, "CVE-2025-20995": {"epss_score": 0.00012, "epss_percentile": 0.01354}, "CVE-2025-20996": {"epss_score": 0.00012, "epss_percentile": 0.01165}, "CVE-2025-20997": {"epss_score": 0.00014, "epss_percentile": 0.02123}, "CVE-2025-20998": {"epss_score": 0.00014, "epss_percentile": 0.01822}, "CVE-2025-20999": {"epss_score": 0.00014, "epss_percentile": 0.01827}, "CVE-2025-21000": {"epss_score": 0.00018, "epss_percentile": 0.03762}, "CVE-2025-21001": {"epss_score": 0.00017, "epss_percentile": 0.03323}, "CVE-2025-21002": {"epss_score": 0.00017, "epss_percentile": 0.03323}, "CVE-2025-21003": {"epss_score": 0.00014, "epss_percentile": 0.02011}, "CVE-2025-21004": {"epss_score": 0.00017, "epss_percentile": 0.03243}, "CVE-2025-21005": {"epss_score": 0.00014, "epss_percentile": 0.01822}, "CVE-2025-21006": {"epss_score": 0.00012, "epss_percentile": 0.01425}, "CVE-2025-21007": {"epss_score": 0.00023, "epss_percentile": 0.05438}, "CVE-2025-21008": {"epss_score": 0.00023, "epss_percentile": 0.05438}, "CVE-2025-21009": {"epss_score": 0.00023, "epss_percentile": 0.05438}, "CVE-2025-21010": {"epss_score": 0.00016, "epss_percentile": 0.02745}, "CVE-2025-21011": {"epss_score": 0.00013, "epss_percentile": 0.0158}, "CVE-2025-21012": {"epss_score": 0.00014, "epss_percentile": 0.02073}, "CVE-2025-21013": {"epss_score": 0.00015, "epss_percentile": 0.02158}, "CVE-2025-21014": {"epss_score": 0.00014, "epss_percentile": 0.01785}, "CVE-2025-21015": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-21016": {"epss_score": 0.00019, "epss_percentile": 0.04207}, "CVE-2025-21017": {"epss_score": 0.00014, "epss_percentile": 0.02103}, "CVE-2025-21018": {"epss_score": 0.00013, "epss_percentile": 0.01587}, "CVE-2025-21019": {"epss_score": 0.00011, "epss_percentile": 0.01023}, "CVE-2025-21020": {"epss_score": 0.0001, "epss_percentile": 0.00794}, "CVE-2025-21021": {"epss_score": 0.0001, "epss_percentile": 0.00794}, "CVE-2025-21022": {"epss_score": 0.00012, "epss_percentile": 0.01407}, "CVE-2025-21023": {"epss_score": 0.00012, "epss_percentile": 0.01386}, "CVE-2025-21024": {"epss_score": 5e-05, "epss_percentile": 0.00196}, "CVE-2025-21025": {"epss_score": 0.00028, "epss_percentile": 0.07298}, "CVE-2025-21026": {"epss_score": 0.00026, "epss_percentile": 0.06567}, "CVE-2025-21027": {"epss_score": 0.00029, "epss_percentile": 0.07828}, "CVE-2025-21028": {"epss_score": 0.00025, "epss_percentile": 0.06056}, "CVE-2025-21029": {"epss_score": 0.00026, "epss_percentile": 0.06491}, "CVE-2025-21030": {"epss_score": 0.0003, "epss_percentile": 0.08256}, "CVE-2025-21031": {"epss_score": 0.00026, "epss_percentile": 0.0657}, "CVE-2025-21032": {"epss_score": 0.00035, "epss_percentile": 0.0988}, "CVE-2025-21033": {"epss_score": 0.00022, "epss_percentile": 0.05137}, "CVE-2025-21034": {"epss_score": 0.00022, "epss_percentile": 0.04966}, "CVE-2025-21035": {"epss_score": 0.00029, "epss_percentile": 0.0769}, "CVE-2025-21036": {"epss_score": 0.00021, "epss_percentile": 0.04726}, "CVE-2025-21037": {"epss_score": 0.00029, "epss_percentile": 0.07604}, "CVE-2025-21038": {"epss_score": 0.00026, "epss_percentile": 0.06491}, "CVE-2025-21039": {"epss_score": 0.00026, "epss_percentile": 0.06491}, "CVE-2025-21040": {"epss_score": 0.00026, "epss_percentile": 0.06491}, "CVE-2025-21041": {"epss_score": 0.00022, "epss_percentile": 0.05303}, "CVE-2025-21042": {"epss_score": 0.03087, "epss_percentile": 0.86388}, "CVE-2025-21043": {"epss_score": 0.11152, "epss_percentile": 0.93245}, "CVE-2025-21044": {"epss_score": 0.00017, "epss_percentile": 0.03302}, "CVE-2025-21045": {"epss_score": 0.00018, "epss_percentile": 0.0362}, "CVE-2025-21046": {"epss_score": 0.00025, "epss_percentile": 0.06312}, "CVE-2025-21047": {"epss_score": 0.00028, "epss_percentile": 0.07567}, "CVE-2025-21048": {"epss_score": 0.00018, "epss_percentile": 0.03759}, "CVE-2025-21049": {"epss_score": 0.00017, "epss_percentile": 0.03432}, "CVE-2025-21050": {"epss_score": 0.00037, "epss_percentile": 0.10736}, "CVE-2025-21051": {"epss_score": 0.00018, "epss_percentile": 0.03871}, "CVE-2025-21052": {"epss_score": 0.00021, "epss_percentile": 0.04903}, "CVE-2025-21053": {"epss_score": 0.00021, "epss_percentile": 0.04903}, "CVE-2025-21054": {"epss_score": 0.00018, "epss_percentile": 0.04016}, "CVE-2025-21055": {"epss_score": 0.00055, "epss_percentile": 0.17381}, "CVE-2025-21056": {"epss_score": 0.00041, "epss_percentile": 0.12241}, "CVE-2025-21057": {"epss_score": 0.00021, "epss_percentile": 0.04928}, "CVE-2025-21058": {"epss_score": 0.00019, "epss_percentile": 0.04134}, "CVE-2025-21059": {"epss_score": 0.00019, "epss_percentile": 0.04183}, "CVE-2025-21060": {"epss_score": 7e-05, "epss_percentile": 0.00434}, "CVE-2025-21061": {"epss_score": 7e-05, "epss_percentile": 0.00414}, "CVE-2025-21062": {"epss_score": 8e-05, "epss_percentile": 0.00483}, "CVE-2025-21063": {"epss_score": 0.00024, "epss_percentile": 0.0569}, "CVE-2025-21064": {"epss_score": 0.00057, "epss_percentile": 0.1805}, "CVE-2025-21065": {"epss_score": 0.00041, "epss_percentile": 0.12241}, "CVE-2025-21066": {"epss_score": 0.00018, "epss_percentile": 0.03871}, "CVE-2025-21067": {"epss_score": 0.00018, "epss_percentile": 0.03871}, "CVE-2025-21068": {"epss_score": 0.00018, "epss_percentile": 0.03871}, "CVE-2025-21069": {"epss_score": 0.00018, "epss_percentile": 0.03871}, "CVE-2025-21070": {"epss_score": 0.00022, "epss_percentile": 0.05066}, "CVE-2025-21071": {"epss_score": 0.00016, "epss_percentile": 0.02943}, "CVE-2025-21072": {"epss_score": 0.00016, "epss_percentile": 0.02943}, "CVE-2025-21073": {"epss_score": 0.00025, "epss_percentile": 0.0614}, "CVE-2025-21074": {"epss_score": 0.00047, "epss_percentile": 0.14852}, "CVE-2025-21075": {"epss_score": 0.00058, "epss_percentile": 0.18358}, "CVE-2025-21076": {"epss_score": 0.00015, "epss_percentile": 0.02602}, "CVE-2025-21077": {"epss_score": 0.00027, "epss_percentile": 0.07088}, "CVE-2025-21078": {"epss_score": 0.00033, "epss_percentile": 0.09425}, "CVE-2025-21079": {"epss_score": 0.00074, "epss_percentile": 0.22709}, "CVE-2025-21080": {"epss_score": 0.00015, "epss_percentile": 0.02592}, "CVE-2025-21081": {"epss_score": 0.00014, "epss_percentile": 0.02111}, "CVE-2025-21082": {"epss_score": 0.00018, "epss_percentile": 0.03559}, "CVE-2025-21083": {"epss_score": 0.00155, "epss_percentile": 0.36774}, "CVE-2025-21084": {"epss_score": 0.00033, "epss_percentile": 0.09182}, "CVE-2025-21085": {"epss_score": 0.00062, "epss_percentile": 0.19726}, "CVE-2025-21086": {"epss_score": 0.00018, "epss_percentile": 0.03798}, "CVE-2025-21087": {"epss_score": 0.00341, "epss_percentile": 0.5631}, "CVE-2025-21088": {"epss_score": 0.00264, "epss_percentile": 0.4969}, "CVE-2025-21089": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2025-21090": {"epss_score": 0.00026, "epss_percentile": 0.06452}, "CVE-2025-21091": {"epss_score": 0.00341, "epss_percentile": 0.5631}, "CVE-2025-21092": {"epss_score": 0.00145, "epss_percentile": 0.35359}, "CVE-2025-21093": {"epss_score": 0.00012, "epss_percentile": 0.01188}, "CVE-2025-21094": {"epss_score": 0.00022, "epss_percentile": 0.0506}, "CVE-2025-21095": {"epss_score": 0.00229, "epss_percentile": 0.45584}, "CVE-2025-21096": {"epss_score": 0.0001, "epss_percentile": 0.00876}, "CVE-2025-21097": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2025-21098": {"epss_score": 0.00031, "epss_percentile": 0.08515}, "CVE-2025-21099": {"epss_score": 0.00015, "epss_percentile": 0.02328}, "CVE-2025-21100": {"epss_score": 0.00013, "epss_percentile": 0.01611}, "CVE-2025-21101": {"epss_score": 0.00017, "epss_percentile": 0.03172}, "CVE-2025-21102": {"epss_score": 0.00023, "epss_percentile": 0.05431}, "CVE-2025-21103": {"epss_score": 0.0007, "epss_percentile": 0.21934}, "CVE-2025-21104": {"epss_score": 0.00175, "epss_percentile": 0.39317}, "CVE-2025-21105": {"epss_score": 0.00021, "epss_percentile": 0.04894}, "CVE-2025-21106": {"epss_score": 0.00033, "epss_percentile": 0.09351}, "CVE-2025-21107": {"epss_score": 0.00029, "epss_percentile": 0.07844}, "CVE-2025-21110": {"epss_score": 0.00026, "epss_percentile": 0.0668}, "CVE-2025-21111": {"epss_score": 0.00021, "epss_percentile": 0.04865}, "CVE-2025-21117": {"epss_score": 0.00067, "epss_percentile": 0.21133}, "CVE-2025-21120": {"epss_score": 0.0005, "epss_percentile": 0.15712}, "CVE-2025-21121": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21122": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2025-21123": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21124": {"epss_score": 0.00077, "epss_percentile": 0.23414}, "CVE-2025-21125": {"epss_score": 0.00037, "epss_percentile": 0.10668}, "CVE-2025-21126": {"epss_score": 0.00037, "epss_percentile": 0.10668}, "CVE-2025-21127": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2025-21128": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21129": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21130": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21131": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21132": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21133": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21134": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21135": {"epss_score": 0.00043, "epss_percentile": 0.13304}, "CVE-2025-21136": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21137": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21138": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21139": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21155": {"epss_score": 0.00037, "epss_percentile": 0.10668}, "CVE-2025-21156": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-21157": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21158": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-21159": {"epss_score": 0.00043, "epss_percentile": 0.13089}, "CVE-2025-21160": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-21161": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-21162": {"epss_score": 0.00042, "epss_percentile": 0.12737}, "CVE-2025-21163": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-21164": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-21165": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-21166": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-21167": {"epss_score": 0.00023, "epss_percentile": 0.05395}, "CVE-2025-21168": {"epss_score": 0.00023, "epss_percentile": 0.05395}, "CVE-2025-21169": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-21170": {"epss_score": 0.00037, "epss_percentile": 0.10668}, "CVE-2025-21171": {"epss_score": 0.00303, "epss_percentile": 0.53217}, "CVE-2025-21172": {"epss_score": 0.00445, "epss_percentile": 0.62852}, "CVE-2025-21173": {"epss_score": 0.06298, "epss_percentile": 0.90653}, "CVE-2025-21174": {"epss_score": 0.21552, "epss_percentile": 0.95532}, "CVE-2025-21176": {"epss_score": 0.01023, "epss_percentile": 0.76763}, "CVE-2025-21177": {"epss_score": 0.00403, "epss_percentile": 0.60328}, "CVE-2025-21178": {"epss_score": 0.01176, "epss_percentile": 0.78267}, "CVE-2025-21179": {"epss_score": 0.00461, "epss_percentile": 0.63553}, "CVE-2025-21180": {"epss_score": 0.00324, "epss_percentile": 0.54927}, "CVE-2025-21181": {"epss_score": 0.27133, "epss_percentile": 0.9621}, "CVE-2025-21182": {"epss_score": 0.00099, "epss_percentile": 0.2836}, "CVE-2025-21183": {"epss_score": 0.00099, "epss_percentile": 0.2836}, "CVE-2025-21184": {"epss_score": 0.001, "epss_percentile": 0.28515}, "CVE-2025-21185": {"epss_score": 0.00471, "epss_percentile": 0.63995}, "CVE-2025-21186": {"epss_score": 0.01045, "epss_percentile": 0.77012}, "CVE-2025-21187": {"epss_score": 0.00479, "epss_percentile": 0.6441}, "CVE-2025-21188": {"epss_score": 0.00193, "epss_percentile": 0.41379}, "CVE-2025-21189": {"epss_score": 0.00407, "epss_percentile": 0.60615}, "CVE-2025-21190": {"epss_score": 0.00412, "epss_percentile": 0.60915}, "CVE-2025-21191": {"epss_score": 0.00102, "epss_percentile": 0.28771}, "CVE-2025-21193": {"epss_score": 0.00377, "epss_percentile": 0.58708}, "CVE-2025-21194": {"epss_score": 0.00326, "epss_percentile": 0.55077}, "CVE-2025-21195": {"epss_score": 0.00042, "epss_percentile": 0.12725}, "CVE-2025-21197": {"epss_score": 0.00648, "epss_percentile": 0.70212}, "CVE-2025-21198": {"epss_score": 0.00248, "epss_percentile": 0.47915}, "CVE-2025-21199": {"epss_score": 0.00193, "epss_percentile": 0.41451}, "CVE-2025-21200": {"epss_score": 0.00412, "epss_percentile": 0.60915}, "CVE-2025-21201": {"epss_score": 0.00412, "epss_percentile": 0.60915}, "CVE-2025-21202": {"epss_score": 0.00241, "epss_percentile": 0.47239}, "CVE-2025-21203": {"epss_score": 0.0041, "epss_percentile": 0.60791}, "CVE-2025-21204": {"epss_score": 0.03066, "epss_percentile": 0.86338}, "CVE-2025-21205": {"epss_score": 0.00263, "epss_percentile": 0.49514}, "CVE-2025-21206": {"epss_score": 0.01657, "epss_percentile": 0.81605}, "CVE-2025-21207": {"epss_score": 0.02834, "epss_percentile": 0.85786}, "CVE-2025-21208": {"epss_score": 0.00746, "epss_percentile": 0.72549}, "CVE-2025-21210": {"epss_score": 0.00159, "epss_percentile": 0.37398}, "CVE-2025-21211": {"epss_score": 0.00312, "epss_percentile": 0.53946}, "CVE-2025-21212": {"epss_score": 0.00277, "epss_percentile": 0.50817}, "CVE-2025-21213": {"epss_score": 0.00332, "epss_percentile": 0.55603}, "CVE-2025-21214": {"epss_score": 0.00152, "epss_percentile": 0.36503}, "CVE-2025-21215": {"epss_score": 0.00224, "epss_percentile": 0.45055}, "CVE-2025-21216": {"epss_score": 0.00277, "epss_percentile": 0.50817}, "CVE-2025-21217": {"epss_score": 0.00752, "epss_percentile": 0.72651}, "CVE-2025-21218": {"epss_score": 0.02834, "epss_percentile": 0.85786}, "CVE-2025-21219": {"epss_score": 0.00357, "epss_percentile": 0.57462}, "CVE-2025-21220": {"epss_score": 0.01646, "epss_percentile": 0.81536}, "CVE-2025-21221": {"epss_score": 0.00263, "epss_percentile": 0.49514}, "CVE-2025-21222": {"epss_score": 0.00263, "epss_percentile": 0.49514}, "CVE-2025-21223": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2025-21224": {"epss_score": 0.01134, "epss_percentile": 0.77893}, "CVE-2025-21225": {"epss_score": 0.00496, "epss_percentile": 0.65171}, "CVE-2025-21226": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2025-21227": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2025-21228": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2025-21229": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2025-21230": {"epss_score": 0.02834, "epss_percentile": 0.85786}, "CVE-2025-21231": {"epss_score": 0.02834, "epss_percentile": 0.85786}, "CVE-2025-21232": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2025-21233": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2025-21234": {"epss_score": 0.003, "epss_percentile": 0.52966}, "CVE-2025-21235": {"epss_score": 0.003, "epss_percentile": 0.52966}, "CVE-2025-21236": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2025-21237": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2025-21238": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2025-21239": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2025-21240": {"epss_score": 0.01391, "epss_percentile": 0.79951}, "CVE-2025-21241": {"epss_score": 0.01391, "epss_percentile": 0.79951}, "CVE-2025-21242": {"epss_score": 0.00245, "epss_percentile": 0.47663}, "CVE-2025-21243": {"epss_score": 0.01107, "epss_percentile": 0.77622}, "CVE-2025-21244": {"epss_score": 0.01107, "epss_percentile": 0.77622}, "CVE-2025-21245": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2025-21246": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2025-21247": {"epss_score": 0.00455, "epss_percentile": 0.63302}, "CVE-2025-21248": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2025-21249": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2025-21250": {"epss_score": 0.01391, "epss_percentile": 0.79951}, "CVE-2025-21251": {"epss_score": 0.02834, "epss_percentile": 0.85786}, "CVE-2025-21252": {"epss_score": 0.01391, "epss_percentile": 0.79951}, "CVE-2025-21253": {"epss_score": 0.00917, "epss_percentile": 0.75431}, "CVE-2025-21254": {"epss_score": 0.00277, "epss_percentile": 0.50817}, "CVE-2025-21255": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2025-21256": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2025-21257": {"epss_score": 0.00162, "epss_percentile": 0.37639}, "CVE-2025-21258": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2025-21259": {"epss_score": 0.00344, "epss_percentile": 0.56538}, "CVE-2025-21260": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2025-21261": {"epss_score": 0.0026, "epss_percentile": 0.49202}, "CVE-2025-21262": {"epss_score": 0.00315, "epss_percentile": 0.54177}, "CVE-2025-21263": {"epss_score": 0.0026, "epss_percentile": 0.49202}, "CVE-2025-21264": {"epss_score": 0.00094, "epss_percentile": 0.27064}, "CVE-2025-21265": {"epss_score": 0.0026, "epss_percentile": 0.49202}, "CVE-2025-21266": {"epss_score": 0.01391, "epss_percentile": 0.79951}, "CVE-2025-21267": {"epss_score": 0.00365, "epss_percentile": 0.58004}, "CVE-2025-21268": {"epss_score": 0.00183, "epss_percentile": 0.40337}, "CVE-2025-21269": {"epss_score": 0.00229, "epss_percentile": 0.45556}, "CVE-2025-21270": {"epss_score": 0.02834, "epss_percentile": 0.85786}, "CVE-2025-21271": {"epss_score": 0.00279, "epss_percentile": 0.50935}, "CVE-2025-21272": {"epss_score": 0.00173, "epss_percentile": 0.39095}, "CVE-2025-21273": {"epss_score": 0.01391, "epss_percentile": 0.79951}, "CVE-2025-21274": {"epss_score": 0.00143, "epss_percentile": 0.35217}, "CVE-2025-21275": {"epss_score": 0.00241, "epss_percentile": 0.47298}, "CVE-2025-21276": {"epss_score": 0.10391, "epss_percentile": 0.92972}, "CVE-2025-21277": {"epss_score": 0.17734, "epss_percentile": 0.94897}, "CVE-2025-21278": {"epss_score": 0.00113, "epss_percentile": 0.30596}, "CVE-2025-21279": {"epss_score": 0.00969, "epss_percentile": 0.76101}, "CVE-2025-21280": {"epss_score": 0.00188, "epss_percentile": 0.40871}, "CVE-2025-21281": {"epss_score": 0.00279, "epss_percentile": 0.50935}, "CVE-2025-21282": {"epss_score": 0.01391, "epss_percentile": 0.79951}, "CVE-2025-21283": {"epss_score": 0.00645, "epss_percentile": 0.70102}, "CVE-2025-21284": {"epss_score": 0.00188, "epss_percentile": 0.40871}, "CVE-2025-21285": {"epss_score": 0.17653, "epss_percentile": 0.94885}, "CVE-2025-21286": {"epss_score": 0.02799, "epss_percentile": 0.85693}, "CVE-2025-21287": {"epss_score": 0.00241, "epss_percentile": 0.47298}, "CVE-2025-21288": {"epss_score": 0.00173, "epss_percentile": 0.39095}, "CVE-2025-21289": {"epss_score": 0.02834, "epss_percentile": 0.85786}, "CVE-2025-21290": {"epss_score": 0.02834, "epss_percentile": 0.85786}, "CVE-2025-21291": {"epss_score": 0.01391, "epss_percentile": 0.79951}, "CVE-2025-21292": {"epss_score": 0.0028, "epss_percentile": 0.51097}, "CVE-2025-21293": {"epss_score": 0.78111, "epss_percentile": 0.98969}, "CVE-2025-21294": {"epss_score": 0.01142, "epss_percentile": 0.77974}, "CVE-2025-21295": {"epss_score": 0.02554, "epss_percentile": 0.85089}, "CVE-2025-21296": {"epss_score": 0.00238, "epss_percentile": 0.46783}, "CVE-2025-21297": {"epss_score": 0.02554, "epss_percentile": 0.85089}, "CVE-2025-21298": {"epss_score": 0.74032, "epss_percentile": 0.98783}, "CVE-2025-21299": {"epss_score": 0.00436, "epss_percentile": 0.62386}, "CVE-2025-21300": {"epss_score": 0.02834, "epss_percentile": 0.85786}, "CVE-2025-21301": {"epss_score": 0.00545, "epss_percentile": 0.67188}, "CVE-2025-21302": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2025-21303": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2025-21304": {"epss_score": 0.00279, "epss_percentile": 0.50935}, "CVE-2025-21305": {"epss_score": 0.01028, "epss_percentile": 0.76821}, "CVE-2025-21306": {"epss_score": 0.01391, "epss_percentile": 0.79951}, "CVE-2025-21307": {"epss_score": 0.10757, "epss_percentile": 0.93095}, "CVE-2025-21308": {"epss_score": 0.01558, "epss_percentile": 0.81024}, "CVE-2025-21309": {"epss_score": 0.00698, "epss_percentile": 0.71429}, "CVE-2025-21310": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2025-21311": {"epss_score": 0.05879, "epss_percentile": 0.90289}, "CVE-2025-21312": {"epss_score": 0.00233, "epss_percentile": 0.46059}, "CVE-2025-21313": {"epss_score": 0.01219, "epss_percentile": 0.78611}, "CVE-2025-21314": {"epss_score": 0.00328, "epss_percentile": 0.55271}, "CVE-2025-21315": {"epss_score": 0.00099, "epss_percentile": 0.2834}, "CVE-2025-21316": {"epss_score": 0.00309, "epss_percentile": 0.53661}, "CVE-2025-21317": {"epss_score": 0.00181, "epss_percentile": 0.40091}, "CVE-2025-21318": {"epss_score": 0.00181, "epss_percentile": 0.40091}, "CVE-2025-21319": {"epss_score": 0.00181, "epss_percentile": 0.40091}, "CVE-2025-21320": {"epss_score": 0.00181, "epss_percentile": 0.40091}, "CVE-2025-21321": {"epss_score": 0.00181, "epss_percentile": 0.40091}, "CVE-2025-21322": {"epss_score": 0.00265, "epss_percentile": 0.49831}, "CVE-2025-21323": {"epss_score": 0.00181, "epss_percentile": 0.40091}, "CVE-2025-21324": {"epss_score": 0.00263, "epss_percentile": 0.4954}, "CVE-2025-21325": {"epss_score": 0.00845, "epss_percentile": 0.74316}, "CVE-2025-21326": {"epss_score": 0.00482, "epss_percentile": 0.64527}, "CVE-2025-21327": {"epss_score": 0.0026, "epss_percentile": 0.49202}, "CVE-2025-21328": {"epss_score": 0.00183, "epss_percentile": 0.40337}, "CVE-2025-21329": {"epss_score": 0.0021, "epss_percentile": 0.43441}, "CVE-2025-21330": {"epss_score": 0.02834, "epss_percentile": 0.85786}, "CVE-2025-21331": {"epss_score": 0.00418, "epss_percentile": 0.61292}, "CVE-2025-21332": {"epss_score": 0.00276, "epss_percentile": 0.50716}, "CVE-2025-21333": {"epss_score": 0.7674, "epss_percentile": 0.98902}, "CVE-2025-21334": {"epss_score": 0.03799, "epss_percentile": 0.87741}, "CVE-2025-21335": {"epss_score": 0.04798, "epss_percentile": 0.89155}, "CVE-2025-21336": {"epss_score": 0.00136, "epss_percentile": 0.34149}, "CVE-2025-21337": {"epss_score": 0.0014, "epss_percentile": 0.34711}, "CVE-2025-21338": {"epss_score": 0.00516, "epss_percentile": 0.66048}, "CVE-2025-21339": {"epss_score": 0.05181, "epss_percentile": 0.89579}, "CVE-2025-21340": {"epss_score": 0.00146, "epss_percentile": 0.35574}, "CVE-2025-21341": {"epss_score": 0.0026, "epss_percentile": 0.49202}, "CVE-2025-21342": {"epss_score": 0.0117, "epss_percentile": 0.78209}, "CVE-2025-21343": {"epss_score": 0.06469, "epss_percentile": 0.90777}, "CVE-2025-21344": {"epss_score": 0.00558, "epss_percentile": 0.67571}, "CVE-2025-21345": {"epss_score": 0.01045, "epss_percentile": 0.77012}, "CVE-2025-21346": {"epss_score": 0.006, "epss_percentile": 0.68832}, "CVE-2025-21347": {"epss_score": 0.00164, "epss_percentile": 0.37886}, "CVE-2025-21348": {"epss_score": 0.03354, "epss_percentile": 0.8697}, "CVE-2025-21349": {"epss_score": 0.00159, "epss_percentile": 0.37363}, "CVE-2025-21350": {"epss_score": 0.00391, "epss_percentile": 0.5958}, "CVE-2025-21351": {"epss_score": 0.22082, "epss_percentile": 0.95593}, "CVE-2025-21352": {"epss_score": 0.00726, "epss_percentile": 0.72068}, "CVE-2025-21354": {"epss_score": 0.01162, "epss_percentile": 0.78155}, "CVE-2025-21355": {"epss_score": 0.03247, "epss_percentile": 0.86745}, "CVE-2025-21356": {"epss_score": 0.0096, "epss_percentile": 0.75968}, "CVE-2025-21357": {"epss_score": 0.00303, "epss_percentile": 0.5317}, "CVE-2025-21358": {"epss_score": 0.0017, "epss_percentile": 0.38745}, "CVE-2025-21359": {"epss_score": 0.00148, "epss_percentile": 0.358}, "CVE-2025-21360": {"epss_score": 0.00241, "epss_percentile": 0.47298}, "CVE-2025-21361": {"epss_score": 0.00597, "epss_percentile": 0.68741}, "CVE-2025-21362": {"epss_score": 0.00592, "epss_percentile": 0.68604}, "CVE-2025-21363": {"epss_score": 0.01022, "epss_percentile": 0.7676}, "CVE-2025-21364": {"epss_score": 0.00583, "epss_percentile": 0.68325}, "CVE-2025-21365": {"epss_score": 0.00877, "epss_percentile": 0.74801}, "CVE-2025-21366": {"epss_score": 0.01045, "epss_percentile": 0.77012}, "CVE-2025-21367": {"epss_score": 0.0017, "epss_percentile": 0.38745}, "CVE-2025-21368": {"epss_score": 0.00662, "epss_percentile": 0.70592}, "CVE-2025-21369": {"epss_score": 0.00722, "epss_percentile": 0.71999}, "CVE-2025-21370": {"epss_score": 0.00246, "epss_percentile": 0.47781}, "CVE-2025-21371": {"epss_score": 0.00748, "epss_percentile": 0.72586}, "CVE-2025-21372": {"epss_score": 0.00099, "epss_percentile": 0.2834}, "CVE-2025-21373": {"epss_score": 0.00232, "epss_percentile": 0.45885}, "CVE-2025-21374": {"epss_score": 0.0016, "epss_percentile": 0.37453}, "CVE-2025-21375": {"epss_score": 0.00162, "epss_percentile": 0.37688}, "CVE-2025-21376": {"epss_score": 0.00779, "epss_percentile": 0.73154}, "CVE-2025-21377": {"epss_score": 0.12843, "epss_percentile": 0.93799}, "CVE-2025-21378": {"epss_score": 0.00279, "epss_percentile": 0.50935}, "CVE-2025-21379": {"epss_score": 0.00573, "epss_percentile": 0.68044}, "CVE-2025-21380": {"epss_score": 0.09199, "epss_percentile": 0.92445}, "CVE-2025-21381": {"epss_score": 0.00375, "epss_percentile": 0.58599}, "CVE-2025-21382": {"epss_score": 0.00411, "epss_percentile": 0.60886}, "CVE-2025-21383": {"epss_score": 0.00325, "epss_percentile": 0.54983}, "CVE-2025-21384": {"epss_score": 0.00468, "epss_percentile": 0.63869}, "CVE-2025-21385": {"epss_score": 0.52126, "epss_percentile": 0.9781}, "CVE-2025-21386": {"epss_score": 0.00375, "epss_percentile": 0.58599}, "CVE-2025-21387": {"epss_score": 0.00479, "epss_percentile": 0.64421}, "CVE-2025-21389": {"epss_score": 0.02834, "epss_percentile": 0.85786}, "CVE-2025-21390": {"epss_score": 0.00375, "epss_percentile": 0.58599}, "CVE-2025-21391": {"epss_score": 0.02267, "epss_percentile": 0.842}, "CVE-2025-21392": {"epss_score": 0.00429, "epss_percentile": 0.61989}, "CVE-2025-21393": {"epss_score": 0.00219, "epss_percentile": 0.4453}, "CVE-2025-21394": {"epss_score": 0.00375, "epss_percentile": 0.58599}, "CVE-2025-21395": {"epss_score": 0.01045, "epss_percentile": 0.77012}, "CVE-2025-21396": {"epss_score": 0.02377, "epss_percentile": 0.84553}, "CVE-2025-21397": {"epss_score": 0.00375, "epss_percentile": 0.58599}, "CVE-2025-21399": {"epss_score": 0.00322, "epss_percentile": 0.54798}, "CVE-2025-21400": {"epss_score": 0.00651, "epss_percentile": 0.70298}, "CVE-2025-21401": {"epss_score": 0.00335, "epss_percentile": 0.55862}, "CVE-2025-21402": {"epss_score": 0.00498, "epss_percentile": 0.6522}, "CVE-2025-21403": {"epss_score": 0.00168, "epss_percentile": 0.38411}, "CVE-2025-21404": {"epss_score": 0.00314, "epss_percentile": 0.54148}, "CVE-2025-21405": {"epss_score": 0.00427, "epss_percentile": 0.61776}, "CVE-2025-21406": {"epss_score": 0.00412, "epss_percentile": 0.60915}, "CVE-2025-21407": {"epss_score": 0.00412, "epss_percentile": 0.60915}, "CVE-2025-21408": {"epss_score": 0.0047, "epss_percentile": 0.63967}, "CVE-2025-21409": {"epss_score": 0.05181, "epss_percentile": 0.89579}, "CVE-2025-21410": {"epss_score": 0.00412, "epss_percentile": 0.60915}, "CVE-2025-21411": {"epss_score": 0.05181, "epss_percentile": 0.89579}, "CVE-2025-21413": {"epss_score": 0.05181, "epss_percentile": 0.89579}, "CVE-2025-21414": {"epss_score": 0.001, "epss_percentile": 0.28515}, "CVE-2025-21415": {"epss_score": 0.01845, "epss_percentile": 0.82511}, "CVE-2025-21416": {"epss_score": 0.00082, "epss_percentile": 0.24575}, "CVE-2025-21417": {"epss_score": 0.05181, "epss_percentile": 0.89579}, "CVE-2025-21418": {"epss_score": 0.08742, "epss_percentile": 0.92235}, "CVE-2025-21419": {"epss_score": 0.00305, "epss_percentile": 0.53317}, "CVE-2025-21420": {"epss_score": 0.26155, "epss_percentile": 0.96118}, "CVE-2025-21421": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2025-21422": {"epss_score": 0.00012, "epss_percentile": 0.0134}, "CVE-2025-21423": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2025-21424": {"epss_score": 0.00029, "epss_percentile": 0.0773}, "CVE-2025-21425": {"epss_score": 0.00022, "epss_percentile": 0.0495}, "CVE-2025-21426": {"epss_score": 0.00015, "epss_percentile": 0.02591}, "CVE-2025-21427": {"epss_score": 0.00047, "epss_percentile": 0.14596}, "CVE-2025-21428": {"epss_score": 0.00089, "epss_percentile": 0.25924}, "CVE-2025-21429": {"epss_score": 0.00089, "epss_percentile": 0.25924}, "CVE-2025-21430": {"epss_score": 0.00089, "epss_percentile": 0.25924}, "CVE-2025-21431": {"epss_score": 0.00013, "epss_percentile": 0.01692}, "CVE-2025-21432": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-21433": {"epss_score": 0.00016, "epss_percentile": 0.02869}, "CVE-2025-21434": {"epss_score": 0.00115, "epss_percentile": 0.30993}, "CVE-2025-21435": {"epss_score": 0.00115, "epss_percentile": 0.30993}, "CVE-2025-21436": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2025-21437": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2025-21438": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2025-21439": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2025-21440": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2025-21441": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2025-21442": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2025-21443": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2025-21444": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-21445": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-21446": {"epss_score": 0.00068, "epss_percentile": 0.21319}, "CVE-2025-21447": {"epss_score": 0.00025, "epss_percentile": 0.06329}, "CVE-2025-21448": {"epss_score": 0.00115, "epss_percentile": 0.30993}, "CVE-2025-21449": {"epss_score": 0.00053, "epss_percentile": 0.16724}, "CVE-2025-21450": {"epss_score": 0.00032, "epss_percentile": 0.08787}, "CVE-2025-21452": {"epss_score": 0.00019, "epss_percentile": 0.04052}, "CVE-2025-21453": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2025-21454": {"epss_score": 0.00053, "epss_percentile": 0.16724}, "CVE-2025-21455": {"epss_score": 0.00011, "epss_percentile": 0.00974}, "CVE-2025-21456": {"epss_score": 0.00014, "epss_percentile": 0.01821}, "CVE-2025-21457": {"epss_score": 0.00012, "epss_percentile": 0.01244}, "CVE-2025-21458": {"epss_score": 0.00014, "epss_percentile": 0.01821}, "CVE-2025-21459": {"epss_score": 0.0007, "epss_percentile": 0.21669}, "CVE-2025-21460": {"epss_score": 0.00027, "epss_percentile": 0.07157}, "CVE-2025-21461": {"epss_score": 0.00014, "epss_percentile": 0.01821}, "CVE-2025-21462": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2025-21463": {"epss_score": 0.00054, "epss_percentile": 0.17195}, "CVE-2025-21464": {"epss_score": 0.00011, "epss_percentile": 0.00947}, "CVE-2025-21465": {"epss_score": 0.00011, "epss_percentile": 0.00947}, "CVE-2025-21466": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-21467": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2025-21468": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2025-21469": {"epss_score": 0.00017, "epss_percentile": 0.03192}, "CVE-2025-21470": {"epss_score": 0.00017, "epss_percentile": 0.03192}, "CVE-2025-21472": {"epss_score": 0.00011, "epss_percentile": 0.00947}, "CVE-2025-21473": {"epss_score": 8e-05, "epss_percentile": 0.0055}, "CVE-2025-21474": {"epss_score": 0.00014, "epss_percentile": 0.01821}, "CVE-2025-21475": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2025-21476": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-21477": {"epss_score": 0.00089, "epss_percentile": 0.25973}, "CVE-2025-21479": {"epss_score": 0.00083, "epss_percentile": 0.24735}, "CVE-2025-21480": {"epss_score": 0.01176, "epss_percentile": 0.78267}, "CVE-2025-21481": {"epss_score": 0.0001, "epss_percentile": 0.00905}, "CVE-2025-21482": {"epss_score": 0.00014, "epss_percentile": 0.01856}, "CVE-2025-21483": {"epss_score": 0.0005, "epss_percentile": 0.15862}, "CVE-2025-21484": {"epss_score": 0.00049, "epss_percentile": 0.15426}, "CVE-2025-21485": {"epss_score": 0.00014, "epss_percentile": 0.02018}, "CVE-2025-21486": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2025-21487": {"epss_score": 0.00049, "epss_percentile": 0.15426}, "CVE-2025-21488": {"epss_score": 0.00049, "epss_percentile": 0.15426}, "CVE-2025-21489": {"epss_score": 0.00034, "epss_percentile": 0.09672}, "CVE-2025-21490": {"epss_score": 0.00442, "epss_percentile": 0.6271}, "CVE-2025-21491": {"epss_score": 0.00195, "epss_percentile": 0.4161}, "CVE-2025-21492": {"epss_score": 0.00195, "epss_percentile": 0.4161}, "CVE-2025-21493": {"epss_score": 0.00171, "epss_percentile": 0.38804}, "CVE-2025-21494": {"epss_score": 0.00024, "epss_percentile": 0.05821}, "CVE-2025-21495": {"epss_score": 0.001, "epss_percentile": 0.28491}, "CVE-2025-21497": {"epss_score": 0.00061, "epss_percentile": 0.19441}, "CVE-2025-21498": {"epss_score": 0.00134, "epss_percentile": 0.33872}, "CVE-2025-21499": {"epss_score": 0.00227, "epss_percentile": 0.45403}, "CVE-2025-21500": {"epss_score": 0.00283, "epss_percentile": 0.51347}, "CVE-2025-21501": {"epss_score": 0.00283, "epss_percentile": 0.51347}, "CVE-2025-21502": {"epss_score": 0.00083, "epss_percentile": 0.24746}, "CVE-2025-21503": {"epss_score": 0.00195, "epss_percentile": 0.4161}, "CVE-2025-21504": {"epss_score": 0.00466, "epss_percentile": 0.63809}, "CVE-2025-21505": {"epss_score": 0.00195, "epss_percentile": 0.4161}, "CVE-2025-21506": {"epss_score": 0.00236, "epss_percentile": 0.4635}, "CVE-2025-21507": {"epss_score": 0.00031, "epss_percentile": 0.0843}, "CVE-2025-21508": {"epss_score": 0.00131, "epss_percentile": 0.33357}, "CVE-2025-21509": {"epss_score": 0.00131, "epss_percentile": 0.33357}, "CVE-2025-21510": {"epss_score": 0.00201, "epss_percentile": 0.42332}, "CVE-2025-21511": {"epss_score": 0.00094, "epss_percentile": 0.27029}, "CVE-2025-21512": {"epss_score": 0.00087, "epss_percentile": 0.25596}, "CVE-2025-21513": {"epss_score": 0.00034, "epss_percentile": 0.09672}, "CVE-2025-21514": {"epss_score": 0.00146, "epss_percentile": 0.35554}, "CVE-2025-21515": {"epss_score": 0.00507, "epss_percentile": 0.65652}, "CVE-2025-21516": {"epss_score": 0.00236, "epss_percentile": 0.4635}, "CVE-2025-21517": {"epss_score": 0.00101, "epss_percentile": 0.28704}, "CVE-2025-21518": {"epss_score": 0.00283, "epss_percentile": 0.51347}, "CVE-2025-21519": {"epss_score": 0.00149, "epss_percentile": 0.36014}, "CVE-2025-21520": {"epss_score": 0.00095, "epss_percentile": 0.27211}, "CVE-2025-21521": {"epss_score": 0.00279, "epss_percentile": 0.50987}, "CVE-2025-21522": {"epss_score": 0.00283, "epss_percentile": 0.51347}, "CVE-2025-21523": {"epss_score": 0.00198, "epss_percentile": 0.4209}, "CVE-2025-21524": {"epss_score": 0.00617, "epss_percentile": 0.6935}, "CVE-2025-21525": {"epss_score": 0.00195, "epss_percentile": 0.4161}, "CVE-2025-21526": {"epss_score": 0.00031, "epss_percentile": 0.0843}, "CVE-2025-21527": {"epss_score": 0.00087, "epss_percentile": 0.25596}, "CVE-2025-21528": {"epss_score": 0.00039, "epss_percentile": 0.11595}, "CVE-2025-21529": {"epss_score": 0.00195, "epss_percentile": 0.4161}, "CVE-2025-21530": {"epss_score": 0.00095, "epss_percentile": 0.27136}, "CVE-2025-21531": {"epss_score": 0.00195, "epss_percentile": 0.4161}, "CVE-2025-21532": {"epss_score": 0.00054, "epss_percentile": 0.17284}, "CVE-2025-21533": {"epss_score": 0.00044, "epss_percentile": 0.13399}, "CVE-2025-21534": {"epss_score": 0.00195, "epss_percentile": 0.4161}, "CVE-2025-21535": {"epss_score": 0.01194, "epss_percentile": 0.78414}, "CVE-2025-21536": {"epss_score": 0.00195, "epss_percentile": 0.4161}, "CVE-2025-21537": {"epss_score": 0.00099, "epss_percentile": 0.28416}, "CVE-2025-21538": {"epss_score": 0.00034, "epss_percentile": 0.09672}, "CVE-2025-21539": {"epss_score": 0.00099, "epss_percentile": 0.28416}, "CVE-2025-21540": {"epss_score": 0.00107, "epss_percentile": 0.29677}, "CVE-2025-21541": {"epss_score": 0.00099, "epss_percentile": 0.28416}, "CVE-2025-21542": {"epss_score": 0.00048, "epss_percentile": 0.15069}, "CVE-2025-21543": {"epss_score": 0.00195, "epss_percentile": 0.4161}, "CVE-2025-21544": {"epss_score": 0.00074, "epss_percentile": 0.22881}, "CVE-2025-21545": {"epss_score": 0.00204, "epss_percentile": 0.42589}, "CVE-2025-21546": {"epss_score": 0.00117, "epss_percentile": 0.31297}, "CVE-2025-21547": {"epss_score": 0.00319, "epss_percentile": 0.54468}, "CVE-2025-21548": {"epss_score": 0.00108, "epss_percentile": 0.29794}, "CVE-2025-21549": {"epss_score": 0.00204, "epss_percentile": 0.42589}, "CVE-2025-21550": {"epss_score": 0.00034, "epss_percentile": 0.09672}, "CVE-2025-21551": {"epss_score": 0.0003, "epss_percentile": 0.08014}, "CVE-2025-21552": {"epss_score": 0.00148, "epss_percentile": 0.35923}, "CVE-2025-21553": {"epss_score": 0.00075, "epss_percentile": 0.22945}, "CVE-2025-21554": {"epss_score": 0.00134, "epss_percentile": 0.33872}, "CVE-2025-21555": {"epss_score": 0.00198, "epss_percentile": 0.4209}, "CVE-2025-21556": {"epss_score": 0.00507, "epss_percentile": 0.65652}, "CVE-2025-21557": {"epss_score": 0.00074, "epss_percentile": 0.22881}, "CVE-2025-21558": {"epss_score": 0.00074, "epss_percentile": 0.22881}, "CVE-2025-21559": {"epss_score": 0.00198, "epss_percentile": 0.4209}, "CVE-2025-21560": {"epss_score": 0.00148, "epss_percentile": 0.35923}, "CVE-2025-21561": {"epss_score": 0.00099, "epss_percentile": 0.28416}, "CVE-2025-21562": {"epss_score": 0.00108, "epss_percentile": 0.29887}, "CVE-2025-21563": {"epss_score": 0.00101, "epss_percentile": 0.28704}, "CVE-2025-21564": {"epss_score": 0.00281, "epss_percentile": 0.51179}, "CVE-2025-21565": {"epss_score": 0.00228, "epss_percentile": 0.45534}, "CVE-2025-21566": {"epss_score": 0.00246, "epss_percentile": 0.47806}, "CVE-2025-21567": {"epss_score": 0.00117, "epss_percentile": 0.31227}, "CVE-2025-21568": {"epss_score": 0.00113, "epss_percentile": 0.30688}, "CVE-2025-21569": {"epss_score": 0.0027, "epss_percentile": 0.50197}, "CVE-2025-21570": {"epss_score": 0.00087, "epss_percentile": 0.25596}, "CVE-2025-21571": {"epss_score": 0.00026, "epss_percentile": 0.06618}, "CVE-2025-21572": {"epss_score": 0.0003, "epss_percentile": 0.08033}, "CVE-2025-21573": {"epss_score": 0.00141, "epss_percentile": 0.34903}, "CVE-2025-21574": {"epss_score": 0.00077, "epss_percentile": 0.23374}, "CVE-2025-21575": {"epss_score": 0.00077, "epss_percentile": 0.23374}, "CVE-2025-21576": {"epss_score": 0.00019, "epss_percentile": 0.04326}, "CVE-2025-21577": {"epss_score": 0.00077, "epss_percentile": 0.23374}, "CVE-2025-21578": {"epss_score": 0.00034, "epss_percentile": 0.09451}, "CVE-2025-21579": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-21580": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-21581": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-21582": {"epss_score": 0.00051, "epss_percentile": 0.16044}, "CVE-2025-21583": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-21584": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-21585": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-21586": {"epss_score": 0.00048, "epss_percentile": 0.14982}, "CVE-2025-21587": {"epss_score": 0.00142, "epss_percentile": 0.35085}, "CVE-2025-21588": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-21590": {"epss_score": 0.02418, "epss_percentile": 0.84696}, "CVE-2025-21591": {"epss_score": 0.00041, "epss_percentile": 0.12324}, "CVE-2025-21592": {"epss_score": 0.00026, "epss_percentile": 0.06518}, "CVE-2025-21593": {"epss_score": 0.00056, "epss_percentile": 0.17898}, "CVE-2025-21594": {"epss_score": 0.001, "epss_percentile": 0.2853}, "CVE-2025-21595": {"epss_score": 0.00042, "epss_percentile": 0.12786}, "CVE-2025-21596": {"epss_score": 0.00029, "epss_percentile": 0.07833}, "CVE-2025-21597": {"epss_score": 0.00064, "epss_percentile": 0.2011}, "CVE-2025-21598": {"epss_score": 0.00213, "epss_percentile": 0.43883}, "CVE-2025-21599": {"epss_score": 0.00213, "epss_percentile": 0.43883}, "CVE-2025-21600": {"epss_score": 0.00067, "epss_percentile": 0.21168}, "CVE-2025-21601": {"epss_score": 0.00128, "epss_percentile": 0.32965}, "CVE-2025-21602": {"epss_score": 0.00056, "epss_percentile": 0.17898}, "CVE-2025-21603": {"epss_score": 0.00064, "epss_percentile": 0.2036}, "CVE-2025-21604": {"epss_score": 0.00158, "epss_percentile": 0.37246}, "CVE-2025-21605": {"epss_score": 0.00148, "epss_percentile": 0.35895}, "CVE-2025-21606": {"epss_score": 0.00136, "epss_percentile": 0.34114}, "CVE-2025-21607": {"epss_score": 0.0014, "epss_percentile": 0.34694}, "CVE-2025-21608": {"epss_score": 0.00073, "epss_percentile": 0.225}, "CVE-2025-21609": {"epss_score": 0.00432, "epss_percentile": 0.62098}, "CVE-2025-21610": {"epss_score": 0.00124, "epss_percentile": 0.3239}, "CVE-2025-21611": {"epss_score": 0.00212, "epss_percentile": 0.43728}, "CVE-2025-21612": {"epss_score": 0.00254, "epss_percentile": 0.48571}, "CVE-2025-21613": {"epss_score": 0.00592, "epss_percentile": 0.68603}, "CVE-2025-21614": {"epss_score": 0.00095, "epss_percentile": 0.27083}, "CVE-2025-21615": {"epss_score": 0.00029, "epss_percentile": 0.07761}, "CVE-2025-21616": {"epss_score": 0.00233, "epss_percentile": 0.46032}, "CVE-2025-21617": {"epss_score": 0.00205, "epss_percentile": 0.42726}, "CVE-2025-21618": {"epss_score": 0.00131, "epss_percentile": 0.33494}, "CVE-2025-21619": {"epss_score": 0.00219, "epss_percentile": 0.44465}, "CVE-2025-21620": {"epss_score": 0.00179, "epss_percentile": 0.39834}, "CVE-2025-21621": {"epss_score": 0.00042, "epss_percentile": 0.12806}, "CVE-2025-21622": {"epss_score": 0.00948, "epss_percentile": 0.75831}, "CVE-2025-21623": {"epss_score": 0.01185, "epss_percentile": 0.78335}, "CVE-2025-21624": {"epss_score": 0.23017, "epss_percentile": 0.95719}, "CVE-2025-21626": {"epss_score": 0.00178, "epss_percentile": 0.39707}, "CVE-2025-21627": {"epss_score": 0.00444, "epss_percentile": 0.62847}, "CVE-2025-21628": {"epss_score": 0.00999, "epss_percentile": 0.7648}, "CVE-2025-21629": {"epss_score": 0.00039, "epss_percentile": 0.11458}, "CVE-2025-21631": {"epss_score": 0.00036, "epss_percentile": 0.10328}, "CVE-2025-21632": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2025-21634": {"epss_score": 0.00036, "epss_percentile": 0.10523}, "CVE-2025-21635": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2025-21636": {"epss_score": 0.00052, "epss_percentile": 0.16449}, "CVE-2025-21637": {"epss_score": 0.00046, "epss_percentile": 0.14169}, "CVE-2025-21638": {"epss_score": 0.00054, "epss_percentile": 0.17067}, "CVE-2025-21639": {"epss_score": 0.00054, "epss_percentile": 0.17067}, "CVE-2025-21640": {"epss_score": 0.00054, "epss_percentile": 0.17067}, "CVE-2025-21641": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2025-21642": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2025-21643": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2025-21644": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2025-21645": {"epss_score": 0.0005, "epss_percentile": 0.15741}, "CVE-2025-21646": {"epss_score": 0.00064, "epss_percentile": 0.20186}, "CVE-2025-21647": {"epss_score": 0.00061, "epss_percentile": 0.1939}, "CVE-2025-21648": {"epss_score": 0.00064, "epss_percentile": 0.20186}, "CVE-2025-21649": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2025-21650": {"epss_score": 0.00037, "epss_percentile": 0.11004}, "CVE-2025-21651": {"epss_score": 0.00021, "epss_percentile": 0.04769}, "CVE-2025-21652": {"epss_score": 0.00048, "epss_percentile": 0.15256}, "CVE-2025-21653": {"epss_score": 0.00061, "epss_percentile": 0.19284}, "CVE-2025-21654": {"epss_score": 0.00017, "epss_percentile": 0.03142}, "CVE-2025-21655": {"epss_score": 0.00056, "epss_percentile": 0.17878}, "CVE-2025-21656": {"epss_score": 0.00031, "epss_percentile": 0.08617}, "CVE-2025-21657": {"epss_score": 0.00037, "epss_percentile": 0.10978}, "CVE-2025-21658": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2025-21659": {"epss_score": 0.00037, "epss_percentile": 0.10978}, "CVE-2025-21660": {"epss_score": 0.00052, "epss_percentile": 0.16361}, "CVE-2025-21661": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2025-21662": {"epss_score": 0.00046, "epss_percentile": 0.14116}, "CVE-2025-21663": {"epss_score": 0.00031, "epss_percentile": 0.08617}, "CVE-2025-21664": {"epss_score": 0.00054, "epss_percentile": 0.17067}, "CVE-2025-21665": {"epss_score": 0.00039, "epss_percentile": 0.11773}, "CVE-2025-21666": {"epss_score": 0.00061, "epss_percentile": 0.19453}, "CVE-2025-21667": {"epss_score": 0.00035, "epss_percentile": 0.09936}, "CVE-2025-21668": {"epss_score": 0.00041, "epss_percentile": 0.12455}, "CVE-2025-21669": {"epss_score": 0.00069, "epss_percentile": 0.21576}, "CVE-2025-21670": {"epss_score": 0.00034, "epss_percentile": 0.0956}, "CVE-2025-21671": {"epss_score": 0.00036, "epss_percentile": 0.10282}, "CVE-2025-21672": {"epss_score": 0.00023, "epss_percentile": 0.05507}, "CVE-2025-21673": {"epss_score": 0.00031, "epss_percentile": 0.08617}, "CVE-2025-21674": {"epss_score": 0.00024, "epss_percentile": 0.05959}, "CVE-2025-21675": {"epss_score": 0.00048, "epss_percentile": 0.15096}, "CVE-2025-21676": {"epss_score": 0.00031, "epss_percentile": 0.08617}, "CVE-2025-21677": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2025-21678": {"epss_score": 0.00061, "epss_percentile": 0.19284}, "CVE-2025-21679": {"epss_score": 0.00024, "epss_percentile": 0.05865}, "CVE-2025-21680": {"epss_score": 0.00036, "epss_percentile": 0.10328}, "CVE-2025-21681": {"epss_score": 0.00039, "epss_percentile": 0.11696}, "CVE-2025-21682": {"epss_score": 0.00048, "epss_percentile": 0.15197}, "CVE-2025-21683": {"epss_score": 0.00069, "epss_percentile": 0.21576}, "CVE-2025-21684": {"epss_score": 0.00013, "epss_percentile": 0.01724}, "CVE-2025-21685": {"epss_score": 8e-05, "epss_percentile": 0.00592}, "CVE-2025-21687": {"epss_score": 0.00044, "epss_percentile": 0.13528}, "CVE-2025-21688": {"epss_score": 0.00035, "epss_percentile": 0.09823}, "CVE-2025-21689": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2025-21690": {"epss_score": 0.00028, "epss_percentile": 0.07487}, "CVE-2025-21691": {"epss_score": 0.00038, "epss_percentile": 0.11323}, "CVE-2025-21692": {"epss_score": 0.00012, "epss_percentile": 0.01359}, "CVE-2025-21693": {"epss_score": 0.00039, "epss_percentile": 0.11796}, "CVE-2025-21694": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2025-21695": {"epss_score": 0.00027, "epss_percentile": 0.06833}, "CVE-2025-21696": {"epss_score": 0.00035, "epss_percentile": 0.09975}, "CVE-2025-21697": {"epss_score": 0.00034, "epss_percentile": 0.09632}, "CVE-2025-21699": {"epss_score": 0.00027, "epss_percentile": 0.06823}, "CVE-2025-21700": {"epss_score": 0.00031, "epss_percentile": 0.08657}, "CVE-2025-21701": {"epss_score": 0.00032, "epss_percentile": 0.08794}, "CVE-2025-21702": {"epss_score": 0.00051, "epss_percentile": 0.16039}, "CVE-2025-21703": {"epss_score": 0.00019, "epss_percentile": 0.04147}, "CVE-2025-21704": {"epss_score": 0.00041, "epss_percentile": 0.12205}, "CVE-2025-21705": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2025-21706": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2025-21707": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2025-21708": {"epss_score": 0.00043, "epss_percentile": 0.12939}, "CVE-2025-21709": {"epss_score": 0.00047, "epss_percentile": 0.14614}, "CVE-2025-21710": {"epss_score": 0.00028, "epss_percentile": 0.0748}, "CVE-2025-21711": {"epss_score": 0.00043, "epss_percentile": 0.12939}, "CVE-2025-21712": {"epss_score": 0.00041, "epss_percentile": 0.12361}, "CVE-2025-21713": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21714": {"epss_score": 0.00036, "epss_percentile": 0.10447}, "CVE-2025-21715": {"epss_score": 0.00037, "epss_percentile": 0.10657}, "CVE-2025-21716": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2025-21717": {"epss_score": 0.0004, "epss_percentile": 0.11899}, "CVE-2025-21718": {"epss_score": 0.00023, "epss_percentile": 0.05427}, "CVE-2025-21719": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2025-21720": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21721": {"epss_score": 0.00051, "epss_percentile": 0.16315}, "CVE-2025-21722": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2025-21723": {"epss_score": 0.00032, "epss_percentile": 0.08763}, "CVE-2025-21724": {"epss_score": 0.00035, "epss_percentile": 0.10151}, "CVE-2025-21725": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2025-21726": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2025-21727": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2025-21728": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21729": {"epss_score": 0.00036, "epss_percentile": 0.10447}, "CVE-2025-21730": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21731": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2025-21732": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2025-21733": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21734": {"epss_score": 0.00035, "epss_percentile": 0.10151}, "CVE-2025-21735": {"epss_score": 0.00049, "epss_percentile": 0.15339}, "CVE-2025-21736": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21737": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21738": {"epss_score": 0.00041, "epss_percentile": 0.12361}, "CVE-2025-21739": {"epss_score": 0.00036, "epss_percentile": 0.10447}, "CVE-2025-21741": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2025-21742": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2025-21743": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2025-21744": {"epss_score": 0.00048, "epss_percentile": 0.15117}, "CVE-2025-21745": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21746": {"epss_score": 0.00035, "epss_percentile": 0.09965}, "CVE-2025-21747": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2025-21748": {"epss_score": 0.0006, "epss_percentile": 0.19111}, "CVE-2025-21749": {"epss_score": 0.00037, "epss_percentile": 0.1092}, "CVE-2025-21750": {"epss_score": 0.00048, "epss_percentile": 0.15034}, "CVE-2025-21751": {"epss_score": 0.0004, "epss_percentile": 0.11869}, "CVE-2025-21752": {"epss_score": 0.00047, "epss_percentile": 0.14614}, "CVE-2025-21753": {"epss_score": 0.00047, "epss_percentile": 0.1486}, "CVE-2025-21754": {"epss_score": 0.00031, "epss_percentile": 0.0859}, "CVE-2025-21756": {"epss_score": 0.00022, "epss_percentile": 0.05183}, "CVE-2025-21758": {"epss_score": 0.00056, "epss_percentile": 0.17658}, "CVE-2025-21759": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2025-21760": {"epss_score": 0.00047, "epss_percentile": 0.1486}, "CVE-2025-21761": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2025-21762": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2025-21763": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2025-21764": {"epss_score": 0.00038, "epss_percentile": 0.11059}, "CVE-2025-21765": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21766": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2025-21767": {"epss_score": 0.00046, "epss_percentile": 0.14424}, "CVE-2025-21768": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21769": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2025-21770": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21771": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21772": {"epss_score": 0.00033, "epss_percentile": 0.09374}, "CVE-2025-21773": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21774": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21775": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2025-21776": {"epss_score": 0.00048, "epss_percentile": 0.15117}, "CVE-2025-21777": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21778": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21779": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21780": {"epss_score": 0.00029, "epss_percentile": 0.07584}, "CVE-2025-21781": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21782": {"epss_score": 0.00036, "epss_percentile": 0.10244}, "CVE-2025-21783": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21784": {"epss_score": 0.00023, "epss_percentile": 0.0559}, "CVE-2025-21785": {"epss_score": 0.00044, "epss_percentile": 0.13643}, "CVE-2025-21786": {"epss_score": 0.0003, "epss_percentile": 0.08014}, "CVE-2025-21787": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21788": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21789": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2025-21790": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2025-21791": {"epss_score": 0.00044, "epss_percentile": 0.13643}, "CVE-2025-21792": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2025-21793": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21794": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2025-21795": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21796": {"epss_score": 0.00033, "epss_percentile": 0.09374}, "CVE-2025-21797": {"epss_score": 0.00046, "epss_percentile": 0.14467}, "CVE-2025-21798": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21799": {"epss_score": 0.00053, "epss_percentile": 0.16835}, "CVE-2025-21800": {"epss_score": 0.00031, "epss_percentile": 0.0847}, "CVE-2025-21801": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21802": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21803": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-21804": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21805": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21806": {"epss_score": 0.00048, "epss_percentile": 0.15117}, "CVE-2025-21807": {"epss_score": 0.00036, "epss_percentile": 0.10487}, "CVE-2025-21808": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21809": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2025-21810": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21811": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2025-21812": {"epss_score": 0.00036, "epss_percentile": 0.10336}, "CVE-2025-21813": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21814": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21815": {"epss_score": 0.00031, "epss_percentile": 0.0847}, "CVE-2025-21816": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2025-21817": {"epss_score": 0.00029, "epss_percentile": 0.0782}, "CVE-2025-21819": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2025-21820": {"epss_score": 0.00027, "epss_percentile": 0.0713}, "CVE-2025-21821": {"epss_score": 0.00028, "epss_percentile": 0.07556}, "CVE-2025-21822": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2025-21823": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21824": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21825": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21826": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21827": {"epss_score": 0.00023, "epss_percentile": 0.05386}, "CVE-2025-21828": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21829": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2025-21830": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2025-21831": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21832": {"epss_score": 0.00035, "epss_percentile": 0.10112}, "CVE-2025-21833": {"epss_score": 0.00042, "epss_percentile": 0.12906}, "CVE-2025-21834": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21835": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21836": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21838": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2025-21839": {"epss_score": 0.0005, "epss_percentile": 0.1595}, "CVE-2025-21840": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2025-21841": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21842": {"epss_score": 0.00032, "epss_percentile": 0.08763}, "CVE-2025-21843": {"epss_score": 0.00038, "epss_percentile": 0.11091}, "CVE-2025-21844": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21845": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21846": {"epss_score": 0.00048, "epss_percentile": 0.15117}, "CVE-2025-21847": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21848": {"epss_score": 0.00064, "epss_percentile": 0.20318}, "CVE-2025-21849": {"epss_score": 0.00025, "epss_percentile": 0.0605}, "CVE-2025-21850": {"epss_score": 0.00016, "epss_percentile": 0.0265}, "CVE-2025-21851": {"epss_score": 0.00025, "epss_percentile": 0.06052}, "CVE-2025-21852": {"epss_score": 0.00029, "epss_percentile": 0.07893}, "CVE-2025-21853": {"epss_score": 0.00069, "epss_percentile": 0.2147}, "CVE-2025-21854": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21855": {"epss_score": 0.00038, "epss_percentile": 0.11215}, "CVE-2025-21856": {"epss_score": 0.00038, "epss_percentile": 0.11071}, "CVE-2025-21857": {"epss_score": 0.00036, "epss_percentile": 0.10485}, "CVE-2025-21858": {"epss_score": 0.00044, "epss_percentile": 0.13643}, "CVE-2025-21859": {"epss_score": 0.00046, "epss_percentile": 0.14424}, "CVE-2025-21860": {"epss_score": 0.00041, "epss_percentile": 0.12232}, "CVE-2025-21861": {"epss_score": 0.00063, "epss_percentile": 0.19927}, "CVE-2025-21862": {"epss_score": 0.00064, "epss_percentile": 0.20318}, "CVE-2025-21863": {"epss_score": 0.0004, "epss_percentile": 0.12077}, "CVE-2025-21864": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2025-21865": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21866": {"epss_score": 0.0006, "epss_percentile": 0.19061}, "CVE-2025-21867": {"epss_score": 0.00024, "epss_percentile": 0.05674}, "CVE-2025-21868": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2025-21869": {"epss_score": 0.00019, "epss_percentile": 0.04362}, "CVE-2025-21870": {"epss_score": 0.00018, "epss_percentile": 0.03839}, "CVE-2025-21871": {"epss_score": 0.00034, "epss_percentile": 0.09691}, "CVE-2025-21872": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21873": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2025-21874": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21875": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21876": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21877": {"epss_score": 0.00032, "epss_percentile": 0.08851}, "CVE-2025-21878": {"epss_score": 0.00031, "epss_percentile": 0.08461}, "CVE-2025-21879": {"epss_score": 0.00026, "epss_percentile": 0.06583}, "CVE-2025-21880": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21881": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21882": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2025-21883": {"epss_score": 0.0003, "epss_percentile": 0.08254}, "CVE-2025-21884": {"epss_score": 0.0003, "epss_percentile": 0.08179}, "CVE-2025-21885": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21886": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21887": {"epss_score": 0.00026, "epss_percentile": 0.06458}, "CVE-2025-21888": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21889": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2025-21890": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21891": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21892": {"epss_score": 0.00017, "epss_percentile": 0.03399}, "CVE-2025-21893": {"epss_score": 0.00019, "epss_percentile": 0.04362}, "CVE-2025-21894": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2025-21895": {"epss_score": 0.00019, "epss_percentile": 0.04137}, "CVE-2025-21896": {"epss_score": 0.00044, "epss_percentile": 0.13549}, "CVE-2025-21897": {"epss_score": 0.00014, "epss_percentile": 0.02049}, "CVE-2025-21898": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21899": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21900": {"epss_score": 0.00014, "epss_percentile": 0.02049}, "CVE-2025-21901": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21902": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21903": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21904": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21905": {"epss_score": 0.00028, "epss_percentile": 0.07237}, "CVE-2025-21906": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21907": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21908": {"epss_score": 0.00019, "epss_percentile": 0.04137}, "CVE-2025-21909": {"epss_score": 0.00031, "epss_percentile": 0.08461}, "CVE-2025-21910": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21911": {"epss_score": 0.00014, "epss_percentile": 0.02049}, "CVE-2025-21912": {"epss_score": 0.00025, "epss_percentile": 0.06142}, "CVE-2025-21913": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21914": {"epss_score": 0.00018, "epss_percentile": 0.03662}, "CVE-2025-21915": {"epss_score": 0.00025, "epss_percentile": 0.06223}, "CVE-2025-21916": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21917": {"epss_score": 0.00042, "epss_percentile": 0.12671}, "CVE-2025-21918": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21919": {"epss_score": 0.00028, "epss_percentile": 0.07265}, "CVE-2025-21920": {"epss_score": 0.00028, "epss_percentile": 0.07237}, "CVE-2025-21921": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21922": {"epss_score": 0.00032, "epss_percentile": 0.08851}, "CVE-2025-21923": {"epss_score": 0.00025, "epss_percentile": 0.06223}, "CVE-2025-21924": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21925": {"epss_score": 0.00032, "epss_percentile": 0.08851}, "CVE-2025-21926": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21927": {"epss_score": 0.00023, "epss_percentile": 0.0538}, "CVE-2025-21928": {"epss_score": 0.00028, "epss_percentile": 0.07237}, "CVE-2025-21929": {"epss_score": 0.00019, "epss_percentile": 0.04362}, "CVE-2025-21930": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21931": {"epss_score": 0.00026, "epss_percentile": 0.06671}, "CVE-2025-21932": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21933": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2025-21934": {"epss_score": 0.00028, "epss_percentile": 0.07237}, "CVE-2025-21935": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21936": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21937": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21938": {"epss_score": 0.00026, "epss_percentile": 0.06671}, "CVE-2025-21939": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21940": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21941": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21942": {"epss_score": 0.0001, "epss_percentile": 0.009}, "CVE-2025-21943": {"epss_score": 0.00027, "epss_percentile": 0.07081}, "CVE-2025-21944": {"epss_score": 0.00026, "epss_percentile": 0.06671}, "CVE-2025-21945": {"epss_score": 0.00024, "epss_percentile": 0.05674}, "CVE-2025-21946": {"epss_score": 0.00025, "epss_percentile": 0.06223}, "CVE-2025-21947": {"epss_score": 0.00026, "epss_percentile": 0.06671}, "CVE-2025-21948": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21949": {"epss_score": 0.00034, "epss_percentile": 0.09662}, "CVE-2025-21950": {"epss_score": 0.00094, "epss_percentile": 0.27066}, "CVE-2025-21951": {"epss_score": 0.00026, "epss_percentile": 0.06671}, "CVE-2025-21952": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2025-21953": {"epss_score": 0.00027, "epss_percentile": 0.07135}, "CVE-2025-21954": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21955": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2025-21956": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21957": {"epss_score": 0.00032, "epss_percentile": 0.08851}, "CVE-2025-21958": {"epss_score": 0.00014, "epss_percentile": 0.02049}, "CVE-2025-21959": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21960": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21961": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21962": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21963": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21964": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21965": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21966": {"epss_score": 0.00029, "epss_percentile": 0.07925}, "CVE-2025-21967": {"epss_score": 0.00025, "epss_percentile": 0.06223}, "CVE-2025-21968": {"epss_score": 0.00028, "epss_percentile": 0.07237}, "CVE-2025-21969": {"epss_score": 0.0002, "epss_percentile": 0.04584}, "CVE-2025-21970": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21971": {"epss_score": 0.00034, "epss_percentile": 0.09691}, "CVE-2025-21972": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21973": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-21974": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21975": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21976": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21977": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21978": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21979": {"epss_score": 0.00024, "epss_percentile": 0.05674}, "CVE-2025-21980": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21981": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21982": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21983": {"epss_score": 0.00019, "epss_percentile": 0.04362}, "CVE-2025-21984": {"epss_score": 0.00014, "epss_percentile": 0.02049}, "CVE-2025-21985": {"epss_score": 0.00019, "epss_percentile": 0.04362}, "CVE-2025-21986": {"epss_score": 0.00026, "epss_percentile": 0.06671}, "CVE-2025-21987": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21988": {"epss_score": 0.00027, "epss_percentile": 0.07084}, "CVE-2025-21989": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21990": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-21991": {"epss_score": 0.00025, "epss_percentile": 0.06222}, "CVE-2025-21992": {"epss_score": 0.00027, "epss_percentile": 0.07109}, "CVE-2025-21993": {"epss_score": 0.00022, "epss_percentile": 0.05228}, "CVE-2025-21994": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21995": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2025-21996": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-21997": {"epss_score": 0.00034, "epss_percentile": 0.0964}, "CVE-2025-21998": {"epss_score": 0.00014, "epss_percentile": 0.02049}, "CVE-2025-21999": {"epss_score": 0.00018, "epss_percentile": 0.03936}, "CVE-2025-22000": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-22001": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2025-22002": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-22003": {"epss_score": 0.00024, "epss_percentile": 0.05752}, "CVE-2025-22004": {"epss_score": 0.00018, "epss_percentile": 0.03936}, "CVE-2025-22005": {"epss_score": 0.00022, "epss_percentile": 0.05271}, "CVE-2025-22006": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-22007": {"epss_score": 0.00022, "epss_percentile": 0.05271}, "CVE-2025-22008": {"epss_score": 0.00019, "epss_percentile": 0.04198}, "CVE-2025-22009": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2025-22010": {"epss_score": 0.00017, "epss_percentile": 0.03443}, "CVE-2025-22011": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-22012": {"epss_score": 0.00021, "epss_percentile": 0.04899}, "CVE-2025-22013": {"epss_score": 0.00023, "epss_percentile": 0.05656}, "CVE-2025-22014": {"epss_score": 0.00017, "epss_percentile": 0.03443}, "CVE-2025-22015": {"epss_score": 0.00031, "epss_percentile": 0.08679}, "CVE-2025-22016": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-22017": {"epss_score": 0.00018, "epss_percentile": 0.03956}, "CVE-2025-22018": {"epss_score": 0.00016, "epss_percentile": 0.02614}, "CVE-2025-22019": {"epss_score": 0.00025, "epss_percentile": 0.06294}, "CVE-2025-22020": {"epss_score": 0.0002, "epss_percentile": 0.0444}, "CVE-2025-22021": {"epss_score": 0.00019, "epss_percentile": 0.04207}, "CVE-2025-22022": {"epss_score": 0.00018, "epss_percentile": 0.03849}, "CVE-2025-22023": {"epss_score": 0.00027, "epss_percentile": 0.06838}, "CVE-2025-22024": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-22025": {"epss_score": 0.00029, "epss_percentile": 0.07662}, "CVE-2025-22026": {"epss_score": 0.00022, "epss_percentile": 0.05012}, "CVE-2025-22027": {"epss_score": 0.00028, "epss_percentile": 0.07276}, "CVE-2025-22028": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2025-22030": {"epss_score": 0.00017, "epss_percentile": 0.03216}, "CVE-2025-22031": {"epss_score": 0.00025, "epss_percentile": 0.06043}, "CVE-2025-22032": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-22033": {"epss_score": 0.00031, "epss_percentile": 0.0833}, "CVE-2025-22034": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-22035": {"epss_score": 0.00024, "epss_percentile": 0.05748}, "CVE-2025-22036": {"epss_score": 0.00017, "epss_percentile": 0.03501}, "CVE-2025-22037": {"epss_score": 0.00046, "epss_percentile": 0.1432}, "CVE-2025-22038": {"epss_score": 0.00017, "epss_percentile": 0.03317}, "CVE-2025-22039": {"epss_score": 0.00014, "epss_percentile": 0.02121}, "CVE-2025-22040": {"epss_score": 0.00017, "epss_percentile": 0.03317}, "CVE-2025-22041": {"epss_score": 0.00017, "epss_percentile": 0.03317}, "CVE-2025-22042": {"epss_score": 0.00085, "epss_percentile": 0.25094}, "CVE-2025-22043": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2025-22044": {"epss_score": 0.00036, "epss_percentile": 0.10259}, "CVE-2025-22045": {"epss_score": 0.00034, "epss_percentile": 0.09703}, "CVE-2025-22046": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-22047": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2025-22048": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2025-22049": {"epss_score": 0.00031, "epss_percentile": 0.0833}, "CVE-2025-22050": {"epss_score": 0.00038, "epss_percentile": 0.11095}, "CVE-2025-22051": {"epss_score": 0.00025, "epss_percentile": 0.06043}, "CVE-2025-22052": {"epss_score": 0.0002, "epss_percentile": 0.04684}, "CVE-2025-22053": {"epss_score": 0.00024, "epss_percentile": 0.05862}, "CVE-2025-22054": {"epss_score": 0.00046, "epss_percentile": 0.14142}, "CVE-2025-22055": {"epss_score": 0.00035, "epss_percentile": 0.10045}, "CVE-2025-22056": {"epss_score": 9e-05, "epss_percentile": 0.0073}, "CVE-2025-22057": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2025-22058": {"epss_score": 0.00033, "epss_percentile": 0.09377}, "CVE-2025-22059": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-22060": {"epss_score": 0.00034, "epss_percentile": 0.09697}, "CVE-2025-22061": {"epss_score": 0.00037, "epss_percentile": 0.1068}, "CVE-2025-22062": {"epss_score": 0.00038, "epss_percentile": 0.11095}, "CVE-2025-22063": {"epss_score": 0.00034, "epss_percentile": 0.09703}, "CVE-2025-22064": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2025-22065": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-22066": {"epss_score": 0.0005, "epss_percentile": 0.15885}, "CVE-2025-22067": {"epss_score": 0.00022, "epss_percentile": 0.05311}, "CVE-2025-22068": {"epss_score": 0.00022, "epss_percentile": 0.05311}, "CVE-2025-22069": {"epss_score": 0.00054, "epss_percentile": 0.1705}, "CVE-2025-22070": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-22071": {"epss_score": 0.00036, "epss_percentile": 0.10259}, "CVE-2025-22072": {"epss_score": 0.00025, "epss_percentile": 0.0606}, "CVE-2025-22073": {"epss_score": 0.00029, "epss_percentile": 0.07662}, "CVE-2025-22074": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2025-22075": {"epss_score": 0.00036, "epss_percentile": 0.10259}, "CVE-2025-22076": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-22077": {"epss_score": 0.00021, "epss_percentile": 0.04797}, "CVE-2025-22078": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-22079": {"epss_score": 0.00019, "epss_percentile": 0.04267}, "CVE-2025-22080": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2025-22081": {"epss_score": 0.00038, "epss_percentile": 0.11095}, "CVE-2025-22082": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-22083": {"epss_score": 0.00021, "epss_percentile": 0.04933}, "CVE-2025-22084": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-22085": {"epss_score": 0.00022, "epss_percentile": 0.05311}, "CVE-2025-22086": {"epss_score": 0.00034, "epss_percentile": 0.09703}, "CVE-2025-22087": {"epss_score": 0.00023, "epss_percentile": 0.05408}, "CVE-2025-22088": {"epss_score": 0.00021, "epss_percentile": 0.04887}, "CVE-2025-22089": {"epss_score": 0.00044, "epss_percentile": 0.13541}, "CVE-2025-22090": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2025-22091": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-22092": {"epss_score": 0.00025, "epss_percentile": 0.06043}, "CVE-2025-22093": {"epss_score": 0.00031, "epss_percentile": 0.0833}, "CVE-2025-22094": {"epss_score": 0.00025, "epss_percentile": 0.06043}, "CVE-2025-22095": {"epss_score": 0.00031, "epss_percentile": 0.0833}, "CVE-2025-22096": {"epss_score": 0.00037, "epss_percentile": 0.1068}, "CVE-2025-22097": {"epss_score": 0.00024, "epss_percentile": 0.05988}, "CVE-2025-22098": {"epss_score": 0.00019, "epss_percentile": 0.04238}, "CVE-2025-22099": {"epss_score": 0.00037, "epss_percentile": 0.1068}, "CVE-2025-22100": {"epss_score": 0.00019, "epss_percentile": 0.04238}, "CVE-2025-22101": {"epss_score": 0.0002, "epss_percentile": 0.04684}, "CVE-2025-22102": {"epss_score": 0.00027, "epss_percentile": 0.06887}, "CVE-2025-22103": {"epss_score": 0.00027, "epss_percentile": 0.06887}, "CVE-2025-22104": {"epss_score": 0.00026, "epss_percentile": 0.06422}, "CVE-2025-22105": {"epss_score": 0.00027, "epss_percentile": 0.06887}, "CVE-2025-22106": {"epss_score": 0.00027, "epss_percentile": 0.06887}, "CVE-2025-22107": {"epss_score": 0.00023, "epss_percentile": 0.05512}, "CVE-2025-22108": {"epss_score": 0.00031, "epss_percentile": 0.08388}, "CVE-2025-22109": {"epss_score": 0.00026, "epss_percentile": 0.06627}, "CVE-2025-22110": {"epss_score": 0.00031, "epss_percentile": 0.08388}, "CVE-2025-22111": {"epss_score": 0.00031, "epss_percentile": 0.08388}, "CVE-2025-22112": {"epss_score": 0.00021, "epss_percentile": 0.04698}, "CVE-2025-22113": {"epss_score": 0.0002, "epss_percentile": 0.04684}, "CVE-2025-22114": {"epss_score": 0.00031, "epss_percentile": 0.08388}, "CVE-2025-22115": {"epss_score": 0.00016, "epss_percentile": 0.02806}, "CVE-2025-22116": {"epss_score": 0.00037, "epss_percentile": 0.10654}, "CVE-2025-22117": {"epss_score": 0.00031, "epss_percentile": 0.08388}, "CVE-2025-22118": {"epss_score": 0.00026, "epss_percentile": 0.06422}, "CVE-2025-22119": {"epss_score": 0.00034, "epss_percentile": 0.0956}, "CVE-2025-22120": {"epss_score": 0.00027, "epss_percentile": 0.06887}, "CVE-2025-22121": {"epss_score": 0.00023, "epss_percentile": 0.05512}, "CVE-2025-22122": {"epss_score": 0.00025, "epss_percentile": 0.06043}, "CVE-2025-22123": {"epss_score": 0.00025, "epss_percentile": 0.06043}, "CVE-2025-22124": {"epss_score": 0.0002, "epss_percentile": 0.04684}, "CVE-2025-22125": {"epss_score": 0.00018, "epss_percentile": 0.03605}, "CVE-2025-22126": {"epss_score": 0.00021, "epss_percentile": 0.04887}, "CVE-2025-22127": {"epss_score": 0.00024, "epss_percentile": 0.05769}, "CVE-2025-22128": {"epss_score": 0.00017, "epss_percentile": 0.03057}, "CVE-2025-22129": {"epss_score": 0.0011, "epss_percentile": 0.30102}, "CVE-2025-22130": {"epss_score": 0.00683, "epss_percentile": 0.711}, "CVE-2025-22131": {"epss_score": 0.00061, "epss_percentile": 0.19458}, "CVE-2025-22132": {"epss_score": 0.00394, "epss_percentile": 0.5978}, "CVE-2025-22133": {"epss_score": 0.00588, "epss_percentile": 0.68503}, "CVE-2025-22134": {"epss_score": 0.00028, "epss_percentile": 0.07356}, "CVE-2025-22136": {"epss_score": 0.00422, "epss_percentile": 0.61575}, "CVE-2025-22137": {"epss_score": 0.00347, "epss_percentile": 0.56769}, "CVE-2025-22138": {"epss_score": 0.00179, "epss_percentile": 0.3977}, "CVE-2025-22139": {"epss_score": 0.00185, "epss_percentile": 0.40507}, "CVE-2025-22140": {"epss_score": 0.00317, "epss_percentile": 0.54361}, "CVE-2025-22141": {"epss_score": 0.00317, "epss_percentile": 0.54361}, "CVE-2025-22142": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-22143": {"epss_score": 0.00213, "epss_percentile": 0.43828}, "CVE-2025-22144": {"epss_score": 0.0026, "epss_percentile": 0.4923}, "CVE-2025-22145": {"epss_score": 0.00112, "epss_percentile": 0.30516}, "CVE-2025-22146": {"epss_score": 0.00164, "epss_percentile": 0.38}, "CVE-2025-22149": {"epss_score": 0.00345, "epss_percentile": 0.56546}, "CVE-2025-22150": {"epss_score": 0.00128, "epss_percentile": 0.32973}, "CVE-2025-22151": {"epss_score": 0.00107, "epss_percentile": 0.29635}, "CVE-2025-22152": {"epss_score": 0.00252, "epss_percentile": 0.4839}, "CVE-2025-22153": {"epss_score": 0.0016, "epss_percentile": 0.37454}, "CVE-2025-22157": {"epss_score": 0.00068, "epss_percentile": 0.21409}, "CVE-2025-22165": {"epss_score": 0.00014, "epss_percentile": 0.01901}, "CVE-2025-22166": {"epss_score": 0.00054, "epss_percentile": 0.17265}, "CVE-2025-22167": {"epss_score": 0.00068, "epss_percentile": 0.21386}, "CVE-2025-22168": {"epss_score": 0.00046, "epss_percentile": 0.14281}, "CVE-2025-22169": {"epss_score": 0.00046, "epss_percentile": 0.14281}, "CVE-2025-22170": {"epss_score": 0.00046, "epss_percentile": 0.14281}, "CVE-2025-22171": {"epss_score": 0.00048, "epss_percentile": 0.15188}, "CVE-2025-22172": {"epss_score": 0.00046, "epss_percentile": 0.14281}, "CVE-2025-22173": {"epss_score": 0.00046, "epss_percentile": 0.14281}, "CVE-2025-22174": {"epss_score": 0.00046, "epss_percentile": 0.14281}, "CVE-2025-22175": {"epss_score": 0.00046, "epss_percentile": 0.14281}, "CVE-2025-22176": {"epss_score": 0.00046, "epss_percentile": 0.14281}, "CVE-2025-22177": {"epss_score": 0.00046, "epss_percentile": 0.14281}, "CVE-2025-22178": {"epss_score": 0.00046, "epss_percentile": 0.14281}, "CVE-2025-22204": {"epss_score": 0.00966, "epss_percentile": 0.76055}, "CVE-2025-22205": {"epss_score": 0.00252, "epss_percentile": 0.48369}, "CVE-2025-22206": {"epss_score": 0.00293, "epss_percentile": 0.52342}, "CVE-2025-22207": {"epss_score": 0.00149, "epss_percentile": 0.35975}, "CVE-2025-22208": {"epss_score": 0.00157, "epss_percentile": 0.37084}, "CVE-2025-22209": {"epss_score": 0.00157, "epss_percentile": 0.37084}, "CVE-2025-22210": {"epss_score": 0.00225, "epss_percentile": 0.45085}, "CVE-2025-22211": {"epss_score": 0.00019, "epss_percentile": 0.04371}, "CVE-2025-22212": {"epss_score": 0.00025, "epss_percentile": 0.06098}, "CVE-2025-22213": {"epss_score": 0.00139, "epss_percentile": 0.34565}, "CVE-2025-22214": {"epss_score": 0.00074, "epss_percentile": 0.22868}, "CVE-2025-22215": {"epss_score": 0.00109, "epss_percentile": 0.29958}, "CVE-2025-22216": {"epss_score": 0.00048, "epss_percentile": 0.14948}, "CVE-2025-22217": {"epss_score": 0.0016, "epss_percentile": 0.37511}, "CVE-2025-22218": {"epss_score": 0.00205, "epss_percentile": 0.42715}, "CVE-2025-22219": {"epss_score": 0.00202, "epss_percentile": 0.42423}, "CVE-2025-22220": {"epss_score": 0.00115, "epss_percentile": 0.30955}, "CVE-2025-22221": {"epss_score": 0.00173, "epss_percentile": 0.39114}, "CVE-2025-22222": {"epss_score": 0.00309, "epss_percentile": 0.53644}, "CVE-2025-22223": {"epss_score": 0.00031, "epss_percentile": 0.08503}, "CVE-2025-22224": {"epss_score": 0.51468, "epss_percentile": 0.9778}, "CVE-2025-22225": {"epss_score": 0.04189, "epss_percentile": 0.88369}, "CVE-2025-22226": {"epss_score": 0.03959, "epss_percentile": 0.8801}, "CVE-2025-22227": {"epss_score": 0.00092, "epss_percentile": 0.26445}, "CVE-2025-22228": {"epss_score": 0.00101, "epss_percentile": 0.28667}, "CVE-2025-22230": {"epss_score": 0.00019, "epss_percentile": 0.04389}, "CVE-2025-22231": {"epss_score": 0.00028, "epss_percentile": 0.07511}, "CVE-2025-22232": {"epss_score": 0.00058, "epss_percentile": 0.18598}, "CVE-2025-22233": {"epss_score": 0.0002, "epss_percentile": 0.04461}, "CVE-2025-22235": {"epss_score": 0.00094, "epss_percentile": 0.27075}, "CVE-2025-22236": {"epss_score": 0.0003, "epss_percentile": 0.08298}, "CVE-2025-22237": {"epss_score": 0.00029, "epss_percentile": 0.07757}, "CVE-2025-22238": {"epss_score": 0.00137, "epss_percentile": 0.34306}, "CVE-2025-22239": {"epss_score": 0.0003, "epss_percentile": 0.08298}, "CVE-2025-22240": {"epss_score": 0.0002, "epss_percentile": 0.04501}, "CVE-2025-22241": {"epss_score": 0.00039, "epss_percentile": 0.1171}, "CVE-2025-22242": {"epss_score": 0.00035, "epss_percentile": 0.09884}, "CVE-2025-22243": {"epss_score": 0.00026, "epss_percentile": 0.06467}, "CVE-2025-22244": {"epss_score": 0.00028, "epss_percentile": 0.07259}, "CVE-2025-22245": {"epss_score": 0.00025, "epss_percentile": 0.06277}, "CVE-2025-22246": {"epss_score": 0.00026, "epss_percentile": 0.06616}, "CVE-2025-22247": {"epss_score": 0.00074, "epss_percentile": 0.22705}, "CVE-2025-22248": {"epss_score": 0.0006, "epss_percentile": 0.18976}, "CVE-2025-22249": {"epss_score": 0.00036, "epss_percentile": 0.10206}, "CVE-2025-22251": {"epss_score": 0.00055, "epss_percentile": 0.17603}, "CVE-2025-22252": {"epss_score": 0.00069, "epss_percentile": 0.21493}, "CVE-2025-22254": {"epss_score": 0.0006, "epss_percentile": 0.19095}, "CVE-2025-22256": {"epss_score": 0.00035, "epss_percentile": 0.10138}, "CVE-2025-22258": {"epss_score": 0.00069, "epss_percentile": 0.21592}, "CVE-2025-22260": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2025-22261": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22262": {"epss_score": 0.00086, "epss_percentile": 0.25335}, "CVE-2025-22263": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-22264": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22265": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2025-22267": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22268": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-22269": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-22270": {"epss_score": 0.00534, "epss_percentile": 0.66785}, "CVE-2025-22271": {"epss_score": 0.0014, "epss_percentile": 0.34765}, "CVE-2025-22272": {"epss_score": 0.00252, "epss_percentile": 0.48405}, "CVE-2025-22273": {"epss_score": 0.00197, "epss_percentile": 0.41959}, "CVE-2025-22274": {"epss_score": 0.00252, "epss_percentile": 0.48405}, "CVE-2025-22275": {"epss_score": 0.00151, "epss_percentile": 0.36228}, "CVE-2025-22276": {"epss_score": 0.00086, "epss_percentile": 0.25335}, "CVE-2025-22277": {"epss_score": 0.00076, "epss_percentile": 0.23242}, "CVE-2025-22278": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-22279": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-22280": {"epss_score": 0.00117, "epss_percentile": 0.3129}, "CVE-2025-22281": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-22282": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-22283": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-22284": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-22285": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-22286": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22287": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2025-22288": {"epss_score": 0.00051, "epss_percentile": 0.16008}, "CVE-2025-22289": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2025-22290": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-22291": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-22292": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22293": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22294": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22295": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22296": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22297": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-22298": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22299": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22300": {"epss_score": 0.00048, "epss_percentile": 0.15164}, "CVE-2025-22301": {"epss_score": 0.00048, "epss_percentile": 0.15164}, "CVE-2025-22302": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-22303": {"epss_score": 0.00157, "epss_percentile": 0.37133}, "CVE-2025-22304": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22305": {"epss_score": 0.00108, "epss_percentile": 0.29882}, "CVE-2025-22306": {"epss_score": 0.00131, "epss_percentile": 0.3339}, "CVE-2025-22307": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22308": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22309": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22310": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22311": {"epss_score": 0.00265, "epss_percentile": 0.49824}, "CVE-2025-22312": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22313": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22314": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22315": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22316": {"epss_score": 0.00069, "epss_percentile": 0.21427}, "CVE-2025-22317": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22318": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-22319": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22320": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22321": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22322": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22323": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22324": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22325": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22326": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22327": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22328": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22329": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22330": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22331": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22332": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22333": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22334": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22335": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22336": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22337": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22338": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22339": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22340": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-22341": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22342": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22343": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22344": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22345": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22346": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2025-22347": {"epss_score": 0.0006, "epss_percentile": 0.19212}, "CVE-2025-22348": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-22349": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-22350": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-22351": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-22352": {"epss_score": 0.0294, "epss_percentile": 0.86033}, "CVE-2025-22353": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22354": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22355": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22356": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-22357": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22358": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22359": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22360": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-22361": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22362": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22363": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-22364": {"epss_score": 0.00236, "epss_percentile": 0.46389}, "CVE-2025-22365": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22366": {"epss_score": 0.00423, "epss_percentile": 0.61615}, "CVE-2025-22367": {"epss_score": 0.00423, "epss_percentile": 0.61615}, "CVE-2025-22368": {"epss_score": 0.00423, "epss_percentile": 0.61615}, "CVE-2025-22369": {"epss_score": 0.00151, "epss_percentile": 0.36187}, "CVE-2025-22370": {"epss_score": 0.00252, "epss_percentile": 0.48405}, "CVE-2025-22371": {"epss_score": 0.0025, "epss_percentile": 0.48136}, "CVE-2025-22372": {"epss_score": 0.0004, "epss_percentile": 0.11866}, "CVE-2025-22373": {"epss_score": 0.00084, "epss_percentile": 0.24893}, "CVE-2025-22374": {"epss_score": 0.00092, "epss_percentile": 0.26474}, "CVE-2025-22375": {"epss_score": 0.00098, "epss_percentile": 0.27705}, "CVE-2025-22376": {"epss_score": 0.00527, "epss_percentile": 0.66531}, "CVE-2025-22377": {"epss_score": 0.00016, "epss_percentile": 0.02828}, "CVE-2025-22381": {"epss_score": 0.00023, "epss_percentile": 0.05372}, "CVE-2025-22383": {"epss_score": 0.00135, "epss_percentile": 0.34034}, "CVE-2025-22384": {"epss_score": 0.00213, "epss_percentile": 0.43876}, "CVE-2025-22385": {"epss_score": 0.00155, "epss_percentile": 0.36788}, "CVE-2025-22386": {"epss_score": 0.00088, "epss_percentile": 0.25784}, "CVE-2025-22387": {"epss_score": 0.00178, "epss_percentile": 0.39705}, "CVE-2025-22388": {"epss_score": 0.0014, "epss_percentile": 0.34757}, "CVE-2025-22389": {"epss_score": 0.00192, "epss_percentile": 0.41315}, "CVE-2025-22390": {"epss_score": 0.00152, "epss_percentile": 0.36446}, "CVE-2025-22391": {"epss_score": 0.00014, "epss_percentile": 0.01932}, "CVE-2025-22392": {"epss_score": 0.00025, "epss_percentile": 0.06301}, "CVE-2025-22394": {"epss_score": 0.00018, "epss_percentile": 0.0376}, "CVE-2025-22395": {"epss_score": 0.00022, "epss_percentile": 0.05246}, "CVE-2025-22397": {"epss_score": 0.00215, "epss_percentile": 0.4405}, "CVE-2025-22398": {"epss_score": 0.00717, "epss_percentile": 0.71913}, "CVE-2025-22399": {"epss_score": 0.00049, "epss_percentile": 0.15544}, "CVE-2025-22402": {"epss_score": 0.00198, "epss_percentile": 0.42095}, "CVE-2025-22403": {"epss_score": 0.00158, "epss_percentile": 0.37187}, "CVE-2025-22404": {"epss_score": 8e-05, "epss_percentile": 0.00518}, "CVE-2025-22405": {"epss_score": 7e-05, "epss_percentile": 0.00384}, "CVE-2025-22406": {"epss_score": 7e-05, "epss_percentile": 0.00384}, "CVE-2025-22407": {"epss_score": 5e-05, "epss_percentile": 0.00231}, "CVE-2025-22408": {"epss_score": 0.00138, "epss_percentile": 0.34467}, "CVE-2025-22409": {"epss_score": 7e-05, "epss_percentile": 0.00384}, "CVE-2025-22410": {"epss_score": 7e-05, "epss_percentile": 0.00384}, "CVE-2025-22411": {"epss_score": 0.0001, "epss_percentile": 0.00803}, "CVE-2025-22412": {"epss_score": 0.0001, "epss_percentile": 0.00803}, "CVE-2025-22413": {"epss_score": 8e-05, "epss_percentile": 0.00514}, "CVE-2025-22414": {"epss_score": 9e-05, "epss_percentile": 0.00648}, "CVE-2025-22415": {"epss_score": 9e-05, "epss_percentile": 0.00622}, "CVE-2025-22416": {"epss_score": 6e-05, "epss_percentile": 0.00284}, "CVE-2025-22417": {"epss_score": 5e-05, "epss_percentile": 0.00177}, "CVE-2025-22418": {"epss_score": 6e-05, "epss_percentile": 0.00284}, "CVE-2025-22419": {"epss_score": 5e-05, "epss_percentile": 0.00177}, "CVE-2025-22420": {"epss_score": 5e-05, "epss_percentile": 0.00225}, "CVE-2025-22421": {"epss_score": 5e-05, "epss_percentile": 0.00227}, "CVE-2025-22422": {"epss_score": 0.00011, "epss_percentile": 0.00927}, "CVE-2025-22423": {"epss_score": 0.00177, "epss_percentile": 0.39527}, "CVE-2025-22425": {"epss_score": 9e-05, "epss_percentile": 0.00624}, "CVE-2025-22427": {"epss_score": 6e-05, "epss_percentile": 0.00301}, "CVE-2025-22428": {"epss_score": 5e-05, "epss_percentile": 0.00232}, "CVE-2025-22429": {"epss_score": 0.00044, "epss_percentile": 0.1352}, "CVE-2025-22430": {"epss_score": 5e-05, "epss_percentile": 0.00231}, "CVE-2025-22431": {"epss_score": 0.00011, "epss_percentile": 0.01008}, "CVE-2025-22432": {"epss_score": 7e-05, "epss_percentile": 0.00337}, "CVE-2025-22433": {"epss_score": 0.00011, "epss_percentile": 0.0104}, "CVE-2025-22434": {"epss_score": 8e-05, "epss_percentile": 0.00547}, "CVE-2025-22435": {"epss_score": 0.00034, "epss_percentile": 0.09628}, "CVE-2025-22437": {"epss_score": 8e-05, "epss_percentile": 0.00547}, "CVE-2025-22438": {"epss_score": 6e-05, "epss_percentile": 0.00312}, "CVE-2025-22439": {"epss_score": 5e-05, "epss_percentile": 0.00177}, "CVE-2025-22441": {"epss_score": 5e-05, "epss_percentile": 0.00177}, "CVE-2025-22442": {"epss_score": 4e-05, "epss_percentile": 0.00144}, "CVE-2025-22443": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2025-22445": {"epss_score": 0.00116, "epss_percentile": 0.31068}, "CVE-2025-22446": {"epss_score": 7e-05, "epss_percentile": 0.0043}, "CVE-2025-22447": {"epss_score": 0.00021, "epss_percentile": 0.04727}, "CVE-2025-22448": {"epss_score": 0.00067, "epss_percentile": 0.2114}, "CVE-2025-22449": {"epss_score": 0.001, "epss_percentile": 0.28524}, "CVE-2025-22450": {"epss_score": 0.00078, "epss_percentile": 0.2379}, "CVE-2025-22452": {"epss_score": 0.00024, "epss_percentile": 0.0601}, "CVE-2025-22454": {"epss_score": 0.00189, "epss_percentile": 0.40951}, "CVE-2025-22455": {"epss_score": 0.00073, "epss_percentile": 0.22497}, "CVE-2025-22457": {"epss_score": 0.49132, "epss_percentile": 0.97669}, "CVE-2025-22458": {"epss_score": 0.00126, "epss_percentile": 0.32772}, "CVE-2025-22459": {"epss_score": 0.00062, "epss_percentile": 0.19589}, "CVE-2025-22460": {"epss_score": 0.00099, "epss_percentile": 0.27857}, "CVE-2025-22461": {"epss_score": 0.03494, "epss_percentile": 0.87233}, "CVE-2025-22462": {"epss_score": 0.02982, "epss_percentile": 0.86124}, "CVE-2025-22463": {"epss_score": 0.001, "epss_percentile": 0.28518}, "CVE-2025-22464": {"epss_score": 0.00074, "epss_percentile": 0.22702}, "CVE-2025-22465": {"epss_score": 0.00031, "epss_percentile": 0.08416}, "CVE-2025-22466": {"epss_score": 0.00046, "epss_percentile": 0.14189}, "CVE-2025-22467": {"epss_score": 0.5325, "epss_percentile": 0.97868}, "CVE-2025-22469": {"epss_score": 0.00494, "epss_percentile": 0.6507}, "CVE-2025-22470": {"epss_score": 0.00041, "epss_percentile": 0.12368}, "CVE-2025-22471": {"epss_score": 0.00072, "epss_percentile": 0.22326}, "CVE-2025-22472": {"epss_score": 0.00054, "epss_percentile": 0.17286}, "CVE-2025-22473": {"epss_score": 0.00053, "epss_percentile": 0.16887}, "CVE-2025-22474": {"epss_score": 0.00117, "epss_percentile": 0.31301}, "CVE-2025-22475": {"epss_score": 0.00056, "epss_percentile": 0.17817}, "CVE-2025-22476": {"epss_score": 0.00075, "epss_percentile": 0.23013}, "CVE-2025-22477": {"epss_score": 0.00063, "epss_percentile": 0.19983}, "CVE-2025-22478": {"epss_score": 0.00044, "epss_percentile": 0.13502}, "CVE-2025-22479": {"epss_score": 0.00025, "epss_percentile": 0.0612}, "CVE-2025-22480": {"epss_score": 0.00017, "epss_percentile": 0.03127}, "CVE-2025-22481": {"epss_score": 0.00184, "epss_percentile": 0.40441}, "CVE-2025-22482": {"epss_score": 0.00048, "epss_percentile": 0.15031}, "CVE-2025-22483": {"epss_score": 0.00123, "epss_percentile": 0.32213}, "CVE-2025-22484": {"epss_score": 0.00156, "epss_percentile": 0.36896}, "CVE-2025-22486": {"epss_score": 0.00078, "epss_percentile": 0.23793}, "CVE-2025-22490": {"epss_score": 0.00112, "epss_percentile": 0.3045}, "CVE-2025-22491": {"epss_score": 0.00045, "epss_percentile": 0.13726}, "CVE-2025-22492": {"epss_score": 0.00036, "epss_percentile": 0.10493}, "CVE-2025-22493": {"epss_score": 0.00018, "epss_percentile": 0.03796}, "CVE-2025-22495": {"epss_score": 0.00182, "epss_percentile": 0.40236}, "CVE-2025-22496": {"epss_score": 0.0006, "epss_percentile": 0.19147}, "CVE-2025-22497": {"epss_score": 0.00059, "epss_percentile": 0.18812}, "CVE-2025-22498": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22499": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22500": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22501": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-22502": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-22503": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-22504": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2025-22505": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-22506": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22507": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-22508": {"epss_score": 0.00248, "epss_percentile": 0.47982}, "CVE-2025-22509": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-22510": {"epss_score": 0.31253, "epss_percentile": 0.96604}, "CVE-2025-22511": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22512": {"epss_score": 0.00086, "epss_percentile": 0.2537}, "CVE-2025-22513": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22514": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22515": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22516": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22517": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22518": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22519": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-22520": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22521": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22522": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22523": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-22524": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22525": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22526": {"epss_score": 0.00138, "epss_percentile": 0.34421}, "CVE-2025-22527": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-22528": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22529": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22530": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22531": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22532": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22533": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-22534": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-22535": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-22536": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-22537": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-22538": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22539": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22540": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-22541": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-22542": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-22543": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-22544": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22545": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22546": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22547": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22548": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22549": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22550": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22551": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22552": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22553": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-22554": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22555": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22556": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22557": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22558": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22559": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22560": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-22561": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22562": {"epss_score": 0.00048, "epss_percentile": 0.15203}, "CVE-2025-22563": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-22564": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22565": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-22566": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-22567": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22568": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22569": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22570": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22571": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22572": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22573": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22574": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22575": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-22576": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22577": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22578": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-22579": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-22580": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22581": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22582": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22583": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22584": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22585": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22586": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22587": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22588": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22589": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22590": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22591": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22592": {"epss_score": 0.00146, "epss_percentile": 0.35612}, "CVE-2025-22593": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22594": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22595": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22596": {"epss_score": 0.00284, "epss_percentile": 0.51435}, "CVE-2025-22597": {"epss_score": 0.00256, "epss_percentile": 0.48773}, "CVE-2025-22598": {"epss_score": 0.00256, "epss_percentile": 0.48773}, "CVE-2025-22599": {"epss_score": 0.00469, "epss_percentile": 0.63938}, "CVE-2025-22600": {"epss_score": 0.00469, "epss_percentile": 0.63938}, "CVE-2025-22601": {"epss_score": 0.00321, "epss_percentile": 0.54741}, "CVE-2025-22602": {"epss_score": 0.00136, "epss_percentile": 0.34159}, "CVE-2025-22603": {"epss_score": 0.00169, "epss_percentile": 0.38527}, "CVE-2025-22604": {"epss_score": 0.5421, "epss_percentile": 0.97915}, "CVE-2025-22605": {"epss_score": 0.00167, "epss_percentile": 0.38386}, "CVE-2025-22606": {"epss_score": 0.0014, "epss_percentile": 0.34798}, "CVE-2025-22607": {"epss_score": 0.0003, "epss_percentile": 0.07979}, "CVE-2025-22608": {"epss_score": 0.00151, "epss_percentile": 0.36222}, "CVE-2025-22609": {"epss_score": 0.00559, "epss_percentile": 0.67613}, "CVE-2025-22610": {"epss_score": 0.00111, "epss_percentile": 0.30354}, "CVE-2025-22611": {"epss_score": 0.00283, "epss_percentile": 0.51372}, "CVE-2025-22612": {"epss_score": 0.00559, "epss_percentile": 0.67613}, "CVE-2025-22613": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-22614": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-22615": {"epss_score": 0.00263, "epss_percentile": 0.49477}, "CVE-2025-22616": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-22617": {"epss_score": 0.00263, "epss_percentile": 0.49477}, "CVE-2025-22618": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-22619": {"epss_score": 0.00263, "epss_percentile": 0.49477}, "CVE-2025-22620": {"epss_score": 0.00159, "epss_percentile": 0.37367}, "CVE-2025-22621": {"epss_score": 0.00097, "epss_percentile": 0.27565}, "CVE-2025-22622": {"epss_score": 0.00089, "epss_percentile": 0.25883}, "CVE-2025-22623": {"epss_score": 0.00302, "epss_percentile": 0.53096}, "CVE-2025-22624": {"epss_score": 0.00302, "epss_percentile": 0.53096}, "CVE-2025-22628": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-22629": {"epss_score": 0.00078, "epss_percentile": 0.23673}, "CVE-2025-22630": {"epss_score": 0.0121, "epss_percentile": 0.78549}, "CVE-2025-22631": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22632": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22633": {"epss_score": 0.00131, "epss_percentile": 0.3339}, "CVE-2025-22634": {"epss_score": 0.00036, "epss_percentile": 0.10374}, "CVE-2025-22635": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-22636": {"epss_score": 0.00054, "epss_percentile": 0.17071}, "CVE-2025-22637": {"epss_score": 0.00036, "epss_percentile": 0.10393}, "CVE-2025-22638": {"epss_score": 0.00059, "epss_percentile": 0.18812}, "CVE-2025-22639": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-22640": {"epss_score": 0.0006, "epss_percentile": 0.19147}, "CVE-2025-22641": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-22642": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22643": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22644": {"epss_score": 0.00059, "epss_percentile": 0.18812}, "CVE-2025-22645": {"epss_score": 0.00136, "epss_percentile": 0.34187}, "CVE-2025-22646": {"epss_score": 0.00053, "epss_percentile": 0.1701}, "CVE-2025-22647": {"epss_score": 0.00069, "epss_percentile": 0.2158}, "CVE-2025-22648": {"epss_score": 0.00059, "epss_percentile": 0.18812}, "CVE-2025-22649": {"epss_score": 0.00054, "epss_percentile": 0.17328}, "CVE-2025-22650": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22651": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-22652": {"epss_score": 0.00868, "epss_percentile": 0.74674}, "CVE-2025-22653": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22654": {"epss_score": 0.06543, "epss_percentile": 0.90837}, "CVE-2025-22655": {"epss_score": 0.00053, "epss_percentile": 0.16856}, "CVE-2025-22656": {"epss_score": 0.00248, "epss_percentile": 0.47982}, "CVE-2025-22657": {"epss_score": 0.00174, "epss_percentile": 0.39149}, "CVE-2025-22658": {"epss_score": 0.00034, "epss_percentile": 0.09748}, "CVE-2025-22659": {"epss_score": 0.00053, "epss_percentile": 0.1701}, "CVE-2025-22660": {"epss_score": 0.00059, "epss_percentile": 0.18812}, "CVE-2025-22661": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22662": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22663": {"epss_score": 0.00188, "epss_percentile": 0.40835}, "CVE-2025-22664": {"epss_score": 0.0008, "epss_percentile": 0.24146}, "CVE-2025-22665": {"epss_score": 0.00069, "epss_percentile": 0.2158}, "CVE-2025-22667": {"epss_score": 0.00069, "epss_percentile": 0.2158}, "CVE-2025-22668": {"epss_score": 0.00106, "epss_percentile": 0.29403}, "CVE-2025-22669": {"epss_score": 0.00036, "epss_percentile": 0.10393}, "CVE-2025-22670": {"epss_score": 0.00106, "epss_percentile": 0.29403}, "CVE-2025-22671": {"epss_score": 0.00069, "epss_percentile": 0.2158}, "CVE-2025-22672": {"epss_score": 0.0005, "epss_percentile": 0.15703}, "CVE-2025-22673": {"epss_score": 0.00066, "epss_percentile": 0.20827}, "CVE-2025-22674": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22675": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22676": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22677": {"epss_score": 0.00082, "epss_percentile": 0.24583}, "CVE-2025-22678": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-22679": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22680": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22681": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22682": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22683": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22684": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22685": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22686": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-22687": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-22688": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22689": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22690": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22691": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-22692": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-22693": {"epss_score": 0.00117, "epss_percentile": 0.3121}, "CVE-2025-22694": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22695": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22696": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-22697": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-22698": {"epss_score": 0.00117, "epss_percentile": 0.3129}, "CVE-2025-22699": {"epss_score": 0.00093, "epss_percentile": 0.26635}, "CVE-2025-22700": {"epss_score": 0.0009, "epss_percentile": 0.26134}, "CVE-2025-22701": {"epss_score": 0.00082, "epss_percentile": 0.24583}, "CVE-2025-22702": {"epss_score": 0.00117, "epss_percentile": 0.3129}, "CVE-2025-22703": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-22704": {"epss_score": 0.00048, "epss_percentile": 0.15164}, "CVE-2025-22705": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-22706": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22707": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-22708": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-22709": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22710": {"epss_score": 0.15376, "epss_percentile": 0.94419}, "CVE-2025-22711": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22712": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-22713": {"epss_score": 0.00021, "epss_percentile": 0.04865}, "CVE-2025-22714": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22715": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-22716": {"epss_score": 0.0012, "epss_percentile": 0.31737}, "CVE-2025-22717": {"epss_score": 0.00146, "epss_percentile": 0.35612}, "CVE-2025-22718": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22719": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22720": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-22721": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2025-22722": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22723": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2025-22724": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22725": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-22726": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-22727": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22728": {"epss_score": 0.00021, "epss_percentile": 0.04865}, "CVE-2025-22729": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22730": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2025-22731": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-22732": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22733": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22734": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-22735": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22736": {"epss_score": 0.00162, "epss_percentile": 0.37712}, "CVE-2025-22737": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-22738": {"epss_score": 0.0008, "epss_percentile": 0.24146}, "CVE-2025-22739": {"epss_score": 0.00058, "epss_percentile": 0.18598}, "CVE-2025-22740": {"epss_score": 0.00058, "epss_percentile": 0.18598}, "CVE-2025-22742": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22743": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22744": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22745": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22746": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22747": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22748": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22749": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22750": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22751": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22752": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-22753": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22754": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22755": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22757": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-22758": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22759": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-22760": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-22761": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22762": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-22763": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-22764": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22765": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22766": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22767": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-22768": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22769": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22770": {"epss_score": 0.0009, "epss_percentile": 0.26091}, "CVE-2025-22771": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-22772": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22773": {"epss_score": 0.00131, "epss_percentile": 0.3339}, "CVE-2025-22774": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-22775": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22776": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22777": {"epss_score": 0.00265, "epss_percentile": 0.49782}, "CVE-2025-22778": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22779": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-22780": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22781": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22782": {"epss_score": 0.0023, "epss_percentile": 0.45675}, "CVE-2025-22783": {"epss_score": 0.00686, "epss_percentile": 0.71166}, "CVE-2025-22784": {"epss_score": 0.0007, "epss_percentile": 0.21676}, "CVE-2025-22785": {"epss_score": 0.00349, "epss_percentile": 0.56858}, "CVE-2025-22786": {"epss_score": 0.00134, "epss_percentile": 0.33828}, "CVE-2025-22787": {"epss_score": 0.00119, "epss_percentile": 0.31577}, "CVE-2025-22788": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-22789": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-22790": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-22791": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-22792": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-22793": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22794": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22795": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-22796": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-22797": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22798": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22799": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-22800": {"epss_score": 0.00162, "epss_percentile": 0.37712}, "CVE-2025-22801": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22802": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22803": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22804": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22805": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22806": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-22807": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22808": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22809": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22810": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22811": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22812": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22813": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22814": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-22815": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-22816": {"epss_score": 0.00057, "epss_percentile": 0.18085}, "CVE-2025-22817": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22818": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22819": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22820": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22821": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22822": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22823": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22824": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22825": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22826": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22827": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-22828": {"epss_score": 0.14883, "epss_percentile": 0.94314}, "CVE-2025-22829": {"epss_score": 0.00171, "epss_percentile": 0.38885}, "CVE-2025-22830": {"epss_score": 9e-05, "epss_percentile": 0.00636}, "CVE-2025-22831": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-22832": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-22833": {"epss_score": 0.00018, "epss_percentile": 0.04023}, "CVE-2025-22834": {"epss_score": 0.00014, "epss_percentile": 0.02077}, "CVE-2025-22835": {"epss_score": 0.00033, "epss_percentile": 0.09182}, "CVE-2025-22836": {"epss_score": 0.00012, "epss_percentile": 0.0134}, "CVE-2025-22837": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2025-22838": {"epss_score": 0.00012, "epss_percentile": 0.01188}, "CVE-2025-22839": {"epss_score": 0.00017, "epss_percentile": 0.03156}, "CVE-2025-22840": {"epss_score": 7e-05, "epss_percentile": 0.00334}, "CVE-2025-22841": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2025-22842": {"epss_score": 0.00024, "epss_percentile": 0.0601}, "CVE-2025-22843": {"epss_score": 0.00013, "epss_percentile": 0.0154}, "CVE-2025-22844": {"epss_score": 0.00028, "epss_percentile": 0.07289}, "CVE-2025-22846": {"epss_score": 0.00341, "epss_percentile": 0.5631}, "CVE-2025-22847": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2025-22848": {"epss_score": 0.00034, "epss_percentile": 0.09435}, "CVE-2025-22851": {"epss_score": 0.00024, "epss_percentile": 0.06033}, "CVE-2025-22853": {"epss_score": 0.00014, "epss_percentile": 0.01746}, "CVE-2025-22854": {"epss_score": 0.0006, "epss_percentile": 0.19018}, "CVE-2025-22855": {"epss_score": 0.00045, "epss_percentile": 0.14039}, "CVE-2025-22859": {"epss_score": 0.00093, "epss_percentile": 0.26716}, "CVE-2025-22862": {"epss_score": 0.00015, "epss_percentile": 0.02245}, "CVE-2025-22865": {"epss_score": 0.00078, "epss_percentile": 0.23758}, "CVE-2025-22866": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2025-22867": {"epss_score": 0.00485, "epss_percentile": 0.64735}, "CVE-2025-22868": {"epss_score": 0.00112, "epss_percentile": 0.3048}, "CVE-2025-22869": {"epss_score": 0.00215, "epss_percentile": 0.44044}, "CVE-2025-22870": {"epss_score": 0.00024, "epss_percentile": 0.05801}, "CVE-2025-22871": {"epss_score": 0.00043, "epss_percentile": 0.13136}, "CVE-2025-22872": {"epss_score": 0.00027, "epss_percentile": 0.07004}, "CVE-2025-22874": {"epss_score": 0.00013, "epss_percentile": 0.01704}, "CVE-2025-22880": {"epss_score": 0.00035, "epss_percentile": 0.10009}, "CVE-2025-22881": {"epss_score": 0.00031, "epss_percentile": 0.08447}, "CVE-2025-22882": {"epss_score": 0.00069, "epss_percentile": 0.21459}, "CVE-2025-22883": {"epss_score": 0.00062, "epss_percentile": 0.19668}, "CVE-2025-22884": {"epss_score": 0.00057, "epss_percentile": 0.18187}, "CVE-2025-22886": {"epss_score": 0.00018, "epss_percentile": 0.03559}, "CVE-2025-22888": {"epss_score": 0.0014, "epss_percentile": 0.3469}, "CVE-2025-22889": {"epss_score": 0.00012, "epss_percentile": 0.01358}, "CVE-2025-22890": {"epss_score": 0.0003, "epss_percentile": 0.08282}, "CVE-2025-22891": {"epss_score": 0.00341, "epss_percentile": 0.5631}, "CVE-2025-22892": {"epss_score": 0.00036, "epss_percentile": 0.10252}, "CVE-2025-22893": {"epss_score": 7e-05, "epss_percentile": 0.00369}, "CVE-2025-22894": {"epss_score": 0.00024, "epss_percentile": 0.06027}, "CVE-2025-22895": {"epss_score": 0.00019, "epss_percentile": 0.04141}, "CVE-2025-22896": {"epss_score": 0.45914, "epss_percentile": 0.97506}, "CVE-2025-22897": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2025-22900": {"epss_score": 0.00205, "epss_percentile": 0.42671}, "CVE-2025-22903": {"epss_score": 0.00082, "epss_percentile": 0.24534}, "CVE-2025-22904": {"epss_score": 0.00282, "epss_percentile": 0.51277}, "CVE-2025-22905": {"epss_score": 0.05598, "epss_percentile": 0.90035}, "CVE-2025-22906": {"epss_score": 0.04037, "epss_percentile": 0.88159}, "CVE-2025-22907": {"epss_score": 0.00282, "epss_percentile": 0.51277}, "CVE-2025-22911": {"epss_score": 0.00081, "epss_percentile": 0.24232}, "CVE-2025-22912": {"epss_score": 0.04037, "epss_percentile": 0.88159}, "CVE-2025-22913": {"epss_score": 0.00256, "epss_percentile": 0.48765}, "CVE-2025-22916": {"epss_score": 0.00282, "epss_percentile": 0.51277}, "CVE-2025-22917": {"epss_score": 0.00056, "epss_percentile": 0.17668}, "CVE-2025-22918": {"epss_score": 0.00142, "epss_percentile": 0.34972}, "CVE-2025-22919": {"epss_score": 0.00081, "epss_percentile": 0.2428}, "CVE-2025-22920": {"epss_score": 0.00137, "epss_percentile": 0.34314}, "CVE-2025-22921": {"epss_score": 0.00181, "epss_percentile": 0.40136}, "CVE-2025-22923": {"epss_score": 0.00719, "epss_percentile": 0.71943}, "CVE-2025-22924": {"epss_score": 0.00061, "epss_percentile": 0.19263}, "CVE-2025-22925": {"epss_score": 0.0012, "epss_percentile": 0.31774}, "CVE-2025-22926": {"epss_score": 0.00772, "epss_percentile": 0.73045}, "CVE-2025-22927": {"epss_score": 0.00745, "epss_percentile": 0.72526}, "CVE-2025-22928": {"epss_score": 0.00061, "epss_percentile": 0.19436}, "CVE-2025-22929": {"epss_score": 0.00061, "epss_percentile": 0.19436}, "CVE-2025-22930": {"epss_score": 0.00061, "epss_percentile": 0.19436}, "CVE-2025-22931": {"epss_score": 0.00221, "epss_percentile": 0.44689}, "CVE-2025-22936": {"epss_score": 0.00063, "epss_percentile": 0.1983}, "CVE-2025-22937": {"epss_score": 0.00127, "epss_percentile": 0.32866}, "CVE-2025-22938": {"epss_score": 0.00127, "epss_percentile": 0.32866}, "CVE-2025-22939": {"epss_score": 0.04372, "epss_percentile": 0.88611}, "CVE-2025-22940": {"epss_score": 0.00094, "epss_percentile": 0.27003}, "CVE-2025-22941": {"epss_score": 0.03286, "epss_percentile": 0.86825}, "CVE-2025-22946": {"epss_score": 0.01057, "epss_percentile": 0.77133}, "CVE-2025-22949": {"epss_score": 0.04653, "epss_percentile": 0.88966}, "CVE-2025-22952": {"epss_score": 0.34979, "epss_percentile": 0.96881}, "CVE-2025-22953": {"epss_score": 0.00416, "epss_percentile": 0.6122}, "CVE-2025-22954": {"epss_score": 0.11933, "epss_percentile": 0.9352}, "CVE-2025-22956": {"epss_score": 0.00083, "epss_percentile": 0.24616}, "CVE-2025-22957": {"epss_score": 0.00362, "epss_percentile": 0.57789}, "CVE-2025-22960": {"epss_score": 0.00249, "epss_percentile": 0.48067}, "CVE-2025-22961": {"epss_score": 0.00294, "epss_percentile": 0.52414}, "CVE-2025-22962": {"epss_score": 0.00605, "epss_percentile": 0.68969}, "CVE-2025-22963": {"epss_score": 0.00077, "epss_percentile": 0.23446}, "CVE-2025-22964": {"epss_score": 0.1392, "epss_percentile": 0.94093}, "CVE-2025-22968": {"epss_score": 0.41251, "epss_percentile": 0.97262}, "CVE-2025-22973": {"epss_score": 0.00116, "epss_percentile": 0.31141}, "CVE-2025-22974": {"epss_score": 0.00811, "epss_percentile": 0.73727}, "CVE-2025-22976": {"epss_score": 0.00036, "epss_percentile": 0.10381}, "CVE-2025-22978": {"epss_score": 0.00599, "epss_percentile": 0.68799}, "CVE-2025-22980": {"epss_score": 0.00143, "epss_percentile": 0.35224}, "CVE-2025-22983": {"epss_score": 0.00267, "epss_percentile": 0.50001}, "CVE-2025-22984": {"epss_score": 0.00267, "epss_percentile": 0.50001}, "CVE-2025-22992": {"epss_score": 0.00167, "epss_percentile": 0.38313}, "CVE-2025-22994": {"epss_score": 0.00145, "epss_percentile": 0.35406}, "CVE-2025-22996": {"epss_score": 0.00058, "epss_percentile": 0.18566}, "CVE-2025-22997": {"epss_score": 0.00058, "epss_percentile": 0.18566}, "CVE-2025-23001": {"epss_score": 0.00114, "epss_percentile": 0.30741}, "CVE-2025-23006": {"epss_score": 0.52066, "epss_percentile": 0.97806}, "CVE-2025-23007": {"epss_score": 0.00027, "epss_percentile": 0.06738}, "CVE-2025-23008": {"epss_score": 0.00021, "epss_percentile": 0.04935}, "CVE-2025-23009": {"epss_score": 0.00016, "epss_percentile": 0.02985}, "CVE-2025-23010": {"epss_score": 0.0002, "epss_percentile": 0.04566}, "CVE-2025-23011": {"epss_score": 0.00655, "epss_percentile": 0.7037}, "CVE-2025-23012": {"epss_score": 0.00156, "epss_percentile": 0.3695}, "CVE-2025-23013": {"epss_score": 0.00079, "epss_percentile": 0.2384}, "CVE-2025-23015": {"epss_score": 0.00259, "epss_percentile": 0.49072}, "CVE-2025-23016": {"epss_score": 0.00067, "epss_percentile": 0.21062}, "CVE-2025-23017": {"epss_score": 0.00079, "epss_percentile": 0.23816}, "CVE-2025-23018": {"epss_score": 0.00099, "epss_percentile": 0.27843}, "CVE-2025-23019": {"epss_score": 0.00099, "epss_percentile": 0.27843}, "CVE-2025-23020": {"epss_score": 0.00085, "epss_percentile": 0.25238}, "CVE-2025-23022": {"epss_score": 0.00037, "epss_percentile": 0.11001}, "CVE-2025-23023": {"epss_score": 0.00121, "epss_percentile": 0.32}, "CVE-2025-23024": {"epss_score": 0.00107, "epss_percentile": 0.29652}, "CVE-2025-23025": {"epss_score": 0.0505, "epss_percentile": 0.89439}, "CVE-2025-23026": {"epss_score": 0.00098, "epss_percentile": 0.27785}, "CVE-2025-23027": {"epss_score": 0.00073, "epss_percentile": 0.22612}, "CVE-2025-23028": {"epss_score": 0.00194, "epss_percentile": 0.41551}, "CVE-2025-23030": {"epss_score": 0.00193, "epss_percentile": 0.41457}, "CVE-2025-23031": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-23032": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-23033": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-23034": {"epss_score": 0.00193, "epss_percentile": 0.41457}, "CVE-2025-23035": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-23036": {"epss_score": 0.00195, "epss_percentile": 0.4171}, "CVE-2025-23037": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-23038": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-23039": {"epss_score": 0.00042, "epss_percentile": 0.12698}, "CVE-2025-23040": {"epss_score": 0.01284, "epss_percentile": 0.79166}, "CVE-2025-23041": {"epss_score": 0.00149, "epss_percentile": 0.35983}, "CVE-2025-23042": {"epss_score": 0.00245, "epss_percentile": 0.47726}, "CVE-2025-23044": {"epss_score": 0.0007, "epss_percentile": 0.21664}, "CVE-2025-23045": {"epss_score": 0.00899, "epss_percentile": 0.75153}, "CVE-2025-23046": {"epss_score": 0.00078, "epss_percentile": 0.23666}, "CVE-2025-23047": {"epss_score": 0.00043, "epss_percentile": 0.13079}, "CVE-2025-23048": {"epss_score": 0.00099, "epss_percentile": 0.28317}, "CVE-2025-23049": {"epss_score": 0.00355, "epss_percentile": 0.57294}, "CVE-2025-23050": {"epss_score": 0.00012, "epss_percentile": 0.01179}, "CVE-2025-23051": {"epss_score": 0.00324, "epss_percentile": 0.54937}, "CVE-2025-23052": {"epss_score": 0.014, "epss_percentile": 0.80004}, "CVE-2025-23053": {"epss_score": 0.00088, "epss_percentile": 0.25721}, "CVE-2025-23054": {"epss_score": 0.00088, "epss_percentile": 0.25721}, "CVE-2025-23055": {"epss_score": 0.00048, "epss_percentile": 0.15105}, "CVE-2025-23056": {"epss_score": 0.00048, "epss_percentile": 0.15105}, "CVE-2025-23057": {"epss_score": 0.00048, "epss_percentile": 0.15105}, "CVE-2025-23058": {"epss_score": 0.00153, "epss_percentile": 0.36557}, "CVE-2025-23059": {"epss_score": 0.00105, "epss_percentile": 0.29251}, "CVE-2025-23060": {"epss_score": 0.0011, "epss_percentile": 0.30169}, "CVE-2025-23061": {"epss_score": 0.7213, "epss_percentile": 0.98696}, "CVE-2025-23072": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-23073": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-23074": {"epss_score": 0.0009, "epss_percentile": 0.26034}, "CVE-2025-23078": {"epss_score": 0.00113, "epss_percentile": 0.30684}, "CVE-2025-23079": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-23080": {"epss_score": 0.00113, "epss_percentile": 0.30684}, "CVE-2025-23081": {"epss_score": 0.00084, "epss_percentile": 0.24852}, "CVE-2025-23082": {"epss_score": 0.00175, "epss_percentile": 0.39308}, "CVE-2025-23083": {"epss_score": 0.00013, "epss_percentile": 0.01549}, "CVE-2025-23084": {"epss_score": 0.00116, "epss_percentile": 0.31044}, "CVE-2025-23085": {"epss_score": 0.00105, "epss_percentile": 0.29346}, "CVE-2025-23086": {"epss_score": 0.00093, "epss_percentile": 0.26746}, "CVE-2025-23091": {"epss_score": 0.00045, "epss_percentile": 0.13831}, "CVE-2025-23092": {"epss_score": 0.00066, "epss_percentile": 0.20842}, "CVE-2025-23093": {"epss_score": 0.00296, "epss_percentile": 0.52544}, "CVE-2025-23094": {"epss_score": 0.28953, "epss_percentile": 0.96404}, "CVE-2025-23095": {"epss_score": 0.00042, "epss_percentile": 0.12614}, "CVE-2025-23096": {"epss_score": 0.00042, "epss_percentile": 0.12614}, "CVE-2025-23097": {"epss_score": 0.0006, "epss_percentile": 0.19222}, "CVE-2025-23098": {"epss_score": 0.00018, "epss_percentile": 0.03862}, "CVE-2025-23099": {"epss_score": 0.0006, "epss_percentile": 0.19222}, "CVE-2025-23100": {"epss_score": 0.00131, "epss_percentile": 0.33466}, "CVE-2025-23101": {"epss_score": 0.00042, "epss_percentile": 0.12614}, "CVE-2025-23102": {"epss_score": 0.0006, "epss_percentile": 0.19074}, "CVE-2025-23103": {"epss_score": 0.00059, "epss_percentile": 0.18718}, "CVE-2025-23104": {"epss_score": 0.00042, "epss_percentile": 0.12614}, "CVE-2025-23105": {"epss_score": 0.00017, "epss_percentile": 0.03148}, "CVE-2025-23106": {"epss_score": 0.00042, "epss_percentile": 0.12614}, "CVE-2025-23107": {"epss_score": 0.00059, "epss_percentile": 0.18718}, "CVE-2025-23108": {"epss_score": 0.0028, "epss_percentile": 0.51023}, "CVE-2025-23109": {"epss_score": 0.00168, "epss_percentile": 0.38447}, "CVE-2025-23110": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-23111": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-23112": {"epss_score": 0.00121, "epss_percentile": 0.31914}, "CVE-2025-23113": {"epss_score": 0.00054, "epss_percentile": 0.17065}, "CVE-2025-23114": {"epss_score": 0.00381, "epss_percentile": 0.59002}, "CVE-2025-23115": {"epss_score": 0.00596, "epss_percentile": 0.68702}, "CVE-2025-23116": {"epss_score": 0.00058, "epss_percentile": 0.18573}, "CVE-2025-23117": {"epss_score": 0.00022, "epss_percentile": 0.05133}, "CVE-2025-23118": {"epss_score": 0.00023, "epss_percentile": 0.05378}, "CVE-2025-23119": {"epss_score": 0.00229, "epss_percentile": 0.45606}, "CVE-2025-23120": {"epss_score": 0.04714, "epss_percentile": 0.89041}, "CVE-2025-23121": {"epss_score": 0.00169, "epss_percentile": 0.38567}, "CVE-2025-23123": {"epss_score": 0.00472, "epss_percentile": 0.64052}, "CVE-2025-23129": {"epss_score": 0.00028, "epss_percentile": 0.07279}, "CVE-2025-23130": {"epss_score": 0.0002, "epss_percentile": 0.04684}, "CVE-2025-23131": {"epss_score": 0.00031, "epss_percentile": 0.08388}, "CVE-2025-23132": {"epss_score": 0.00031, "epss_percentile": 0.08388}, "CVE-2025-23133": {"epss_score": 0.00024, "epss_percentile": 0.05669}, "CVE-2025-23134": {"epss_score": 0.00017, "epss_percentile": 0.03216}, "CVE-2025-23135": {"epss_score": 0.0002, "epss_percentile": 0.04684}, "CVE-2025-23136": {"epss_score": 0.00034, "epss_percentile": 0.09703}, "CVE-2025-23137": {"epss_score": 0.00028, "epss_percentile": 0.07279}, "CVE-2025-23138": {"epss_score": 0.0004, "epss_percentile": 0.11869}, "CVE-2025-23140": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-23141": {"epss_score": 0.0001, "epss_percentile": 0.00772}, "CVE-2025-23142": {"epss_score": 0.00018, "epss_percentile": 0.03631}, "CVE-2025-23143": {"epss_score": 0.00025, "epss_percentile": 0.06248}, "CVE-2025-23144": {"epss_score": 0.00032, "epss_percentile": 0.09008}, "CVE-2025-23145": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-23146": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-23147": {"epss_score": 0.0003, "epss_percentile": 0.08233}, "CVE-2025-23148": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-23149": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2025-23150": {"epss_score": 0.00017, "epss_percentile": 0.03443}, "CVE-2025-23151": {"epss_score": 0.00015, "epss_percentile": 0.02274}, "CVE-2025-23152": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2025-23153": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2025-23154": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2025-23155": {"epss_score": 0.00029, "epss_percentile": 0.07699}, "CVE-2025-23156": {"epss_score": 0.00018, "epss_percentile": 0.03885}, "CVE-2025-23157": {"epss_score": 0.00018, "epss_percentile": 0.03631}, "CVE-2025-23158": {"epss_score": 0.00018, "epss_percentile": 0.03631}, "CVE-2025-23159": {"epss_score": 0.00017, "epss_percentile": 0.03443}, "CVE-2025-23160": {"epss_score": 0.00028, "epss_percentile": 0.07225}, "CVE-2025-23161": {"epss_score": 0.00012, "epss_percentile": 0.01155}, "CVE-2025-23162": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2025-23163": {"epss_score": 0.00011, "epss_percentile": 0.0095}, "CVE-2025-23164": {"epss_score": 0.0003, "epss_percentile": 0.08241}, "CVE-2025-23165": {"epss_score": 0.00073, "epss_percentile": 0.22609}, "CVE-2025-23166": {"epss_score": 0.0004, "epss_percentile": 0.12044}, "CVE-2025-23167": {"epss_score": 0.00011, "epss_percentile": 0.01022}, "CVE-2025-23168": {"epss_score": 0.00092, "epss_percentile": 0.2646}, "CVE-2025-23169": {"epss_score": 0.00029, "epss_percentile": 0.07932}, "CVE-2025-23170": {"epss_score": 0.00021, "epss_percentile": 0.04926}, "CVE-2025-23171": {"epss_score": 0.00054, "epss_percentile": 0.17297}, "CVE-2025-23172": {"epss_score": 0.00304, "epss_percentile": 0.53309}, "CVE-2025-23173": {"epss_score": 0.00116, "epss_percentile": 0.31148}, "CVE-2025-23174": {"epss_score": 0.0007, "epss_percentile": 0.21748}, "CVE-2025-23175": {"epss_score": 0.00038, "epss_percentile": 0.11323}, "CVE-2025-23176": {"epss_score": 0.00054, "epss_percentile": 0.17338}, "CVE-2025-23177": {"epss_score": 0.00058, "epss_percentile": 0.18395}, "CVE-2025-23178": {"epss_score": 0.00056, "epss_percentile": 0.17742}, "CVE-2025-23179": {"epss_score": 0.00022, "epss_percentile": 0.05265}, "CVE-2025-23180": {"epss_score": 0.00032, "epss_percentile": 0.08736}, "CVE-2025-23181": {"epss_score": 0.00032, "epss_percentile": 0.08736}, "CVE-2025-23182": {"epss_score": 0.00038, "epss_percentile": 0.1112}, "CVE-2025-23183": {"epss_score": 0.00028, "epss_percentile": 0.07269}, "CVE-2025-23184": {"epss_score": 0.01337, "epss_percentile": 0.79564}, "CVE-2025-23185": {"epss_score": 0.00117, "epss_percentile": 0.31236}, "CVE-2025-23186": {"epss_score": 0.00068, "epss_percentile": 0.21201}, "CVE-2025-23187": {"epss_score": 0.00224, "epss_percentile": 0.45017}, "CVE-2025-23188": {"epss_score": 0.00085, "epss_percentile": 0.25219}, "CVE-2025-23189": {"epss_score": 0.00083, "epss_percentile": 0.2481}, "CVE-2025-23190": {"epss_score": 0.0008, "epss_percentile": 0.24009}, "CVE-2025-23191": {"epss_score": 0.00079, "epss_percentile": 0.23863}, "CVE-2025-23192": {"epss_score": 0.00134, "epss_percentile": 0.33748}, "CVE-2025-23193": {"epss_score": 0.00195, "epss_percentile": 0.41637}, "CVE-2025-23194": {"epss_score": 0.00107, "epss_percentile": 0.29616}, "CVE-2025-23195": {"epss_score": 0.00137, "epss_percentile": 0.34268}, "CVE-2025-23196": {"epss_score": 0.00706, "epss_percentile": 0.71618}, "CVE-2025-23197": {"epss_score": 0.00257, "epss_percentile": 0.48916}, "CVE-2025-23198": {"epss_score": 0.00079, "epss_percentile": 0.2389}, "CVE-2025-23199": {"epss_score": 0.00086, "epss_percentile": 0.25322}, "CVE-2025-23200": {"epss_score": 0.00107, "epss_percentile": 0.29729}, "CVE-2025-23201": {"epss_score": 0.0001, "epss_percentile": 0.00892}, "CVE-2025-23202": {"epss_score": 0.00213, "epss_percentile": 0.43908}, "CVE-2025-23203": {"epss_score": 0.00098, "epss_percentile": 0.27816}, "CVE-2025-23204": {"epss_score": 0.0014, "epss_percentile": 0.34688}, "CVE-2025-23205": {"epss_score": 0.00217, "epss_percentile": 0.44261}, "CVE-2025-23206": {"epss_score": 0.00055, "epss_percentile": 0.17622}, "CVE-2025-23207": {"epss_score": 0.00044, "epss_percentile": 0.13631}, "CVE-2025-23208": {"epss_score": 0.00182, "epss_percentile": 0.40185}, "CVE-2025-23209": {"epss_score": 0.04657, "epss_percentile": 0.88974}, "CVE-2025-23210": {"epss_score": 0.00294, "epss_percentile": 0.52367}, "CVE-2025-23211": {"epss_score": 0.02223, "epss_percentile": 0.84064}, "CVE-2025-23212": {"epss_score": 0.00195, "epss_percentile": 0.41622}, "CVE-2025-23213": {"epss_score": 0.00084, "epss_percentile": 0.24855}, "CVE-2025-23214": {"epss_score": 0.00179, "epss_percentile": 0.3977}, "CVE-2025-23215": {"epss_score": 0.0012, "epss_percentile": 0.31707}, "CVE-2025-23216": {"epss_score": 0.00142, "epss_percentile": 0.3505}, "CVE-2025-23217": {"epss_score": 0.0119, "epss_percentile": 0.78381}, "CVE-2025-23218": {"epss_score": 0.00583, "epss_percentile": 0.68347}, "CVE-2025-23219": {"epss_score": 0.00583, "epss_percentile": 0.68347}, "CVE-2025-23220": {"epss_score": 0.00583, "epss_percentile": 0.68347}, "CVE-2025-23221": {"epss_score": 0.00108, "epss_percentile": 0.29807}, "CVE-2025-23222": {"epss_score": 0.00013, "epss_percentile": 0.01484}, "CVE-2025-23225": {"epss_score": 0.00113, "epss_percentile": 0.30611}, "CVE-2025-23227": {"epss_score": 0.00055, "epss_percentile": 0.17485}, "CVE-2025-23233": {"epss_score": 0.00018, "epss_percentile": 0.0391}, "CVE-2025-23234": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2025-23235": {"epss_score": 0.00018, "epss_percentile": 0.03559}, "CVE-2025-23236": {"epss_score": 0.00029, "epss_percentile": 0.0786}, "CVE-2025-23237": {"epss_score": 0.0044, "epss_percentile": 0.62636}, "CVE-2025-23239": {"epss_score": 0.00463, "epss_percentile": 0.63664}, "CVE-2025-23240": {"epss_score": 0.00033, "epss_percentile": 0.09182}, "CVE-2025-23241": {"epss_score": 0.00021, "epss_percentile": 0.0474}, "CVE-2025-23242": {"epss_score": 0.00152, "epss_percentile": 0.36393}, "CVE-2025-23243": {"epss_score": 0.00151, "epss_percentile": 0.36302}, "CVE-2025-23244": {"epss_score": 0.00035, "epss_percentile": 0.1005}, "CVE-2025-23245": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-23246": {"epss_score": 0.00035, "epss_percentile": 0.09967}, "CVE-2025-23247": {"epss_score": 0.00016, "epss_percentile": 0.02932}, "CVE-2025-23248": {"epss_score": 0.00016, "epss_percentile": 0.02898}, "CVE-2025-23249": {"epss_score": 0.00802, "epss_percentile": 0.7359}, "CVE-2025-23250": {"epss_score": 0.00119, "epss_percentile": 0.31637}, "CVE-2025-23251": {"epss_score": 0.00181, "epss_percentile": 0.40053}, "CVE-2025-23252": {"epss_score": 0.00031, "epss_percentile": 0.08532}, "CVE-2025-23253": {"epss_score": 0.00024, "epss_percentile": 0.05972}, "CVE-2025-23254": {"epss_score": 0.00189, "epss_percentile": 0.4097}, "CVE-2025-23255": {"epss_score": 0.00016, "epss_percentile": 0.02898}, "CVE-2025-23256": {"epss_score": 0.00027, "epss_percentile": 0.06745}, "CVE-2025-23257": {"epss_score": 0.00021, "epss_percentile": 0.04745}, "CVE-2025-23258": {"epss_score": 0.00021, "epss_percentile": 0.04745}, "CVE-2025-23259": {"epss_score": 0.00073, "epss_percentile": 0.22553}, "CVE-2025-23260": {"epss_score": 0.00036, "epss_percentile": 0.10274}, "CVE-2025-23261": {"epss_score": 0.0002, "epss_percentile": 0.04628}, "CVE-2025-23262": {"epss_score": 0.00033, "epss_percentile": 0.0935}, "CVE-2025-23263": {"epss_score": 0.0003, "epss_percentile": 0.07983}, "CVE-2025-23264": {"epss_score": 0.00025, "epss_percentile": 0.0624}, "CVE-2025-23265": {"epss_score": 0.00025, "epss_percentile": 0.0624}, "CVE-2025-23266": {"epss_score": 0.00028, "epss_percentile": 0.07334}, "CVE-2025-23267": {"epss_score": 0.00092, "epss_percentile": 0.26506}, "CVE-2025-23268": {"epss_score": 0.00206, "epss_percentile": 0.43043}, "CVE-2025-23269": {"epss_score": 0.00013, "epss_percentile": 0.01452}, "CVE-2025-23270": {"epss_score": 0.00018, "epss_percentile": 0.03934}, "CVE-2025-23271": {"epss_score": 0.00017, "epss_percentile": 0.0335}, "CVE-2025-23272": {"epss_score": 0.00017, "epss_percentile": 0.03513}, "CVE-2025-23273": {"epss_score": 0.00017, "epss_percentile": 0.03415}, "CVE-2025-23274": {"epss_score": 0.00018, "epss_percentile": 0.03596}, "CVE-2025-23275": {"epss_score": 0.00019, "epss_percentile": 0.04085}, "CVE-2025-23276": {"epss_score": 0.00021, "epss_percentile": 0.04758}, "CVE-2025-23277": {"epss_score": 0.00018, "epss_percentile": 0.03598}, "CVE-2025-23278": {"epss_score": 0.00027, "epss_percentile": 0.06899}, "CVE-2025-23279": {"epss_score": 9e-05, "epss_percentile": 0.00697}, "CVE-2025-23280": {"epss_score": 0.00022, "epss_percentile": 0.05188}, "CVE-2025-23281": {"epss_score": 0.00012, "epss_percentile": 0.01178}, "CVE-2025-23282": {"epss_score": 0.00022, "epss_percentile": 0.05188}, "CVE-2025-23283": {"epss_score": 0.00015, "epss_percentile": 0.0258}, "CVE-2025-23284": {"epss_score": 0.00015, "epss_percentile": 0.0258}, "CVE-2025-23285": {"epss_score": 0.00025, "epss_percentile": 0.06161}, "CVE-2025-23286": {"epss_score": 0.00013, "epss_percentile": 0.01587}, "CVE-2025-23287": {"epss_score": 0.00013, "epss_percentile": 0.01695}, "CVE-2025-23288": {"epss_score": 0.00013, "epss_percentile": 0.01695}, "CVE-2025-23289": {"epss_score": 0.00017, "epss_percentile": 0.03128}, "CVE-2025-23290": {"epss_score": 0.0001, "epss_percentile": 0.00866}, "CVE-2025-23291": {"epss_score": 6e-05, "epss_percentile": 0.003}, "CVE-2025-23292": {"epss_score": 0.00019, "epss_percentile": 0.04404}, "CVE-2025-23293": {"epss_score": 0.00075, "epss_percentile": 0.2299}, "CVE-2025-23294": {"epss_score": 0.00042, "epss_percentile": 0.12667}, "CVE-2025-23295": {"epss_score": 0.00036, "epss_percentile": 0.10187}, "CVE-2025-23296": {"epss_score": 0.00036, "epss_percentile": 0.10187}, "CVE-2025-23297": {"epss_score": 0.00016, "epss_percentile": 0.0287}, "CVE-2025-23298": {"epss_score": 0.00036, "epss_percentile": 0.10187}, "CVE-2025-23299": {"epss_score": 0.00018, "epss_percentile": 0.03758}, "CVE-2025-23300": {"epss_score": 0.00022, "epss_percentile": 0.04959}, "CVE-2025-23301": {"epss_score": 0.00027, "epss_percentile": 0.06888}, "CVE-2025-23302": {"epss_score": 0.00027, "epss_percentile": 0.06888}, "CVE-2025-23303": {"epss_score": 0.01017, "epss_percentile": 0.76687}, "CVE-2025-23304": {"epss_score": 0.00767, "epss_percentile": 0.72959}, "CVE-2025-23305": {"epss_score": 0.00036, "epss_percentile": 0.10187}, "CVE-2025-23306": {"epss_score": 0.00036, "epss_percentile": 0.10187}, "CVE-2025-23307": {"epss_score": 0.00036, "epss_percentile": 0.10187}, "CVE-2025-23308": {"epss_score": 0.00016, "epss_percentile": 0.02809}, "CVE-2025-23309": {"epss_score": 0.00015, "epss_percentile": 0.02415}, "CVE-2025-23310": {"epss_score": 0.00473, "epss_percentile": 0.64089}, "CVE-2025-23311": {"epss_score": 0.01029, "epss_percentile": 0.76829}, "CVE-2025-23312": {"epss_score": 0.00035, "epss_percentile": 0.09914}, "CVE-2025-23313": {"epss_score": 0.00035, "epss_percentile": 0.09914}, "CVE-2025-23314": {"epss_score": 0.00035, "epss_percentile": 0.09914}, "CVE-2025-23315": {"epss_score": 0.00035, "epss_percentile": 0.09914}, "CVE-2025-23316": {"epss_score": 0.00355, "epss_percentile": 0.57269}, "CVE-2025-23317": {"epss_score": 0.03138, "epss_percentile": 0.86482}, "CVE-2025-23318": {"epss_score": 0.00105, "epss_percentile": 0.29364}, "CVE-2025-23319": {"epss_score": 0.00417, "epss_percentile": 0.61243}, "CVE-2025-23320": {"epss_score": 0.00046, "epss_percentile": 0.14124}, "CVE-2025-23321": {"epss_score": 0.00094, "epss_percentile": 0.26996}, "CVE-2025-23322": {"epss_score": 0.00124, "epss_percentile": 0.32467}, "CVE-2025-23323": {"epss_score": 0.00094, "epss_percentile": 0.26996}, "CVE-2025-23324": {"epss_score": 0.00094, "epss_percentile": 0.26996}, "CVE-2025-23325": {"epss_score": 0.00036, "epss_percentile": 0.10541}, "CVE-2025-23326": {"epss_score": 0.00124, "epss_percentile": 0.32467}, "CVE-2025-23327": {"epss_score": 0.00052, "epss_percentile": 0.16445}, "CVE-2025-23328": {"epss_score": 0.00063, "epss_percentile": 0.19877}, "CVE-2025-23329": {"epss_score": 0.00064, "epss_percentile": 0.204}, "CVE-2025-23330": {"epss_score": 0.00022, "epss_percentile": 0.04959}, "CVE-2025-23331": {"epss_score": 0.00124, "epss_percentile": 0.32467}, "CVE-2025-23332": {"epss_score": 0.0002, "epss_percentile": 0.04448}, "CVE-2025-23333": {"epss_score": 0.00042, "epss_percentile": 0.12701}, "CVE-2025-23334": {"epss_score": 0.00045, "epss_percentile": 0.14057}, "CVE-2025-23335": {"epss_score": 0.00048, "epss_percentile": 0.15004}, "CVE-2025-23336": {"epss_score": 0.00087, "epss_percentile": 0.25532}, "CVE-2025-23337": {"epss_score": 0.00016, "epss_percentile": 0.02851}, "CVE-2025-23338": {"epss_score": 0.0002, "epss_percentile": 0.04497}, "CVE-2025-23339": {"epss_score": 0.00016, "epss_percentile": 0.02809}, "CVE-2025-23340": {"epss_score": 0.00017, "epss_percentile": 0.0335}, "CVE-2025-23342": {"epss_score": 0.00048, "epss_percentile": 0.14932}, "CVE-2025-23343": {"epss_score": 0.00105, "epss_percentile": 0.29288}, "CVE-2025-23344": {"epss_score": 0.00038, "epss_percentile": 0.11139}, "CVE-2025-23345": {"epss_score": 0.00022, "epss_percentile": 0.05056}, "CVE-2025-23346": {"epss_score": 0.00016, "epss_percentile": 0.02898}, "CVE-2025-23347": {"epss_score": 0.00013, "epss_percentile": 0.01545}, "CVE-2025-23348": {"epss_score": 0.00028, "epss_percentile": 0.07218}, "CVE-2025-23349": {"epss_score": 0.00028, "epss_percentile": 0.07218}, "CVE-2025-23352": {"epss_score": 0.00017, "epss_percentile": 0.03102}, "CVE-2025-23353": {"epss_score": 0.00028, "epss_percentile": 0.07218}, "CVE-2025-23354": {"epss_score": 0.00028, "epss_percentile": 0.07218}, "CVE-2025-23355": {"epss_score": 0.00015, "epss_percentile": 0.02291}, "CVE-2025-23356": {"epss_score": 0.00018, "epss_percentile": 0.04015}, "CVE-2025-23357": {"epss_score": 0.00024, "epss_percentile": 0.05751}, "CVE-2025-23358": {"epss_score": 0.00013, "epss_percentile": 0.0168}, "CVE-2025-23359": {"epss_score": 0.00666, "epss_percentile": 0.70678}, "CVE-2025-23360": {"epss_score": 0.00157, "epss_percentile": 0.37129}, "CVE-2025-23361": {"epss_score": 0.00024, "epss_percentile": 0.05751}, "CVE-2025-23362": {"epss_score": 0.00057, "epss_percentile": 0.18204}, "CVE-2025-23363": {"epss_score": 0.00114, "epss_percentile": 0.3079}, "CVE-2025-23364": {"epss_score": 6e-05, "epss_percentile": 0.0032}, "CVE-2025-23365": {"epss_score": 0.00017, "epss_percentile": 0.03278}, "CVE-2025-23366": {"epss_score": 0.00085, "epss_percentile": 0.25179}, "CVE-2025-23367": {"epss_score": 0.00186, "epss_percentile": 0.4063}, "CVE-2025-23368": {"epss_score": 0.00226, "epss_percentile": 0.45287}, "CVE-2025-23369": {"epss_score": 0.09966, "epss_percentile": 0.92797}, "CVE-2025-23374": {"epss_score": 0.00102, "epss_percentile": 0.28823}, "CVE-2025-23375": {"epss_score": 0.00017, "epss_percentile": 0.03449}, "CVE-2025-23376": {"epss_score": 0.0002, "epss_percentile": 0.04549}, "CVE-2025-23377": {"epss_score": 0.00016, "epss_percentile": 0.02892}, "CVE-2025-23378": {"epss_score": 0.00025, "epss_percentile": 0.06047}, "CVE-2025-23379": {"epss_score": 0.00035, "epss_percentile": 0.10131}, "CVE-2025-23382": {"epss_score": 0.00083, "epss_percentile": 0.24701}, "CVE-2025-23383": {"epss_score": 0.00046, "epss_percentile": 0.14365}, "CVE-2025-23384": {"epss_score": 0.00074, "epss_percentile": 0.22826}, "CVE-2025-23385": {"epss_score": 2e-05, "epss_percentile": 0.00033}, "CVE-2025-23386": {"epss_score": 0.00023, "epss_percentile": 0.05399}, "CVE-2025-23387": {"epss_score": 0.00131, "epss_percentile": 0.33443}, "CVE-2025-23388": {"epss_score": 0.00115, "epss_percentile": 0.30901}, "CVE-2025-23389": {"epss_score": 0.00051, "epss_percentile": 0.16254}, "CVE-2025-23391": {"epss_score": 0.00087, "epss_percentile": 0.25605}, "CVE-2025-23392": {"epss_score": 0.00047, "epss_percentile": 0.14712}, "CVE-2025-23393": {"epss_score": 0.00047, "epss_percentile": 0.14712}, "CVE-2025-23394": {"epss_score": 0.00113, "epss_percentile": 0.30612}, "CVE-2025-23395": {"epss_score": 0.00019, "epss_percentile": 0.04281}, "CVE-2025-23396": {"epss_score": 0.00031, "epss_percentile": 0.08447}, "CVE-2025-23397": {"epss_score": 0.00031, "epss_percentile": 0.08447}, "CVE-2025-23398": {"epss_score": 0.00031, "epss_percentile": 0.08447}, "CVE-2025-23399": {"epss_score": 0.00031, "epss_percentile": 0.08447}, "CVE-2025-23400": {"epss_score": 0.00031, "epss_percentile": 0.08447}, "CVE-2025-23401": {"epss_score": 0.00031, "epss_percentile": 0.08447}, "CVE-2025-23402": {"epss_score": 0.00034, "epss_percentile": 0.09759}, "CVE-2025-23403": {"epss_score": 0.00024, "epss_percentile": 0.05688}, "CVE-2025-23405": {"epss_score": 0.00134, "epss_percentile": 0.33817}, "CVE-2025-23406": {"epss_score": 0.00063, "epss_percentile": 0.19829}, "CVE-2025-23407": {"epss_score": 0.00066, "epss_percentile": 0.20941}, "CVE-2025-23408": {"epss_score": 0.00139, "epss_percentile": 0.34555}, "CVE-2025-23409": {"epss_score": 0.00038, "epss_percentile": 0.114}, "CVE-2025-23410": {"epss_score": 0.00434, "epss_percentile": 0.62288}, "CVE-2025-23411": {"epss_score": 0.00046, "epss_percentile": 0.14417}, "CVE-2025-23412": {"epss_score": 0.00341, "epss_percentile": 0.5631}, "CVE-2025-23413": {"epss_score": 0.00056, "epss_percentile": 0.17849}, "CVE-2025-23414": {"epss_score": 0.00038, "epss_percentile": 0.114}, "CVE-2025-23415": {"epss_score": 0.00074, "epss_percentile": 0.2269}, "CVE-2025-23416": {"epss_score": 0.00381, "epss_percentile": 0.59021}, "CVE-2025-23417": {"epss_score": 0.00058, "epss_percentile": 0.18528}, "CVE-2025-23418": {"epss_score": 0.00028, "epss_percentile": 0.07304}, "CVE-2025-23419": {"epss_score": 0.00632, "epss_percentile": 0.69745}, "CVE-2025-23420": {"epss_score": 0.00033, "epss_percentile": 0.09182}, "CVE-2025-23421": {"epss_score": 0.00068, "epss_percentile": 0.2122}, "CVE-2025-23422": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-23423": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-23424": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23425": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23426": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-23427": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23428": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23429": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23430": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23431": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23432": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23433": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23434": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23435": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23436": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23437": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23438": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23439": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23440": {"epss_score": 0.00117, "epss_percentile": 0.3129}, "CVE-2025-23441": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23442": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23443": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-23444": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23445": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23446": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-23447": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23448": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-23449": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23450": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23451": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23452": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23453": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23454": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23455": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23456": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23457": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23458": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-23459": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23460": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23461": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23462": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23463": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23464": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23465": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23466": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23467": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23468": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23469": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-23470": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23471": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23472": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23473": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23474": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23475": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23476": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23477": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2025-23478": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23479": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23480": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23481": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23482": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23483": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23484": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23485": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23486": {"epss_score": 0.00114, "epss_percentile": 0.30739}, "CVE-2025-23487": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23488": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23489": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23490": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23491": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23492": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23493": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23494": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23495": {"epss_score": 0.00213, "epss_percentile": 0.43882}, "CVE-2025-23496": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23497": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23498": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23499": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23500": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23501": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23502": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-23503": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23504": {"epss_score": 0.00024, "epss_percentile": 0.0577}, "CVE-2025-23505": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23506": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23507": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23508": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23509": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23510": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23511": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23512": {"epss_score": 0.00174, "epss_percentile": 0.39149}, "CVE-2025-23513": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23514": {"epss_score": 0.00158, "epss_percentile": 0.37225}, "CVE-2025-23515": {"epss_score": 0.00135, "epss_percentile": 0.3398}, "CVE-2025-23516": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23517": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23518": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23519": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23520": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23521": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23522": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23523": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23524": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23525": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23526": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-23527": {"epss_score": 0.00135, "epss_percentile": 0.3398}, "CVE-2025-23528": {"epss_score": 0.00162, "epss_percentile": 0.37712}, "CVE-2025-23529": {"epss_score": 0.00135, "epss_percentile": 0.3398}, "CVE-2025-23530": {"epss_score": 0.00057, "epss_percentile": 0.18231}, "CVE-2025-23531": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23532": {"epss_score": 0.00057, "epss_percentile": 0.18231}, "CVE-2025-23533": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23534": {"epss_score": 0.00135, "epss_percentile": 0.3398}, "CVE-2025-23535": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23536": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23537": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23538": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23539": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23540": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23541": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23542": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23543": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23544": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23545": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23546": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23547": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23548": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23549": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23550": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-23551": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23552": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23553": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23554": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-23555": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23556": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23557": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23558": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23559": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-23560": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23561": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23562": {"epss_score": 0.00171, "epss_percentile": 0.3882}, "CVE-2025-23563": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23564": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23565": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23566": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23567": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23568": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23569": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23570": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23571": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23572": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23573": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23574": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23575": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23576": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23577": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23578": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23579": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23580": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23581": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23582": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23583": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23584": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23585": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23586": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23587": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23588": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23589": {"epss_score": 0.00213, "epss_percentile": 0.43882}, "CVE-2025-23590": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23591": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23592": {"epss_score": 0.00213, "epss_percentile": 0.43882}, "CVE-2025-23593": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23594": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23595": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23596": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23597": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23598": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23599": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23600": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23601": {"epss_score": 0.00213, "epss_percentile": 0.43882}, "CVE-2025-23602": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23603": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23604": {"epss_score": 0.00213, "epss_percentile": 0.43882}, "CVE-2025-23605": {"epss_score": 0.00213, "epss_percentile": 0.43882}, "CVE-2025-23606": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23607": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23608": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-23609": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23610": {"epss_score": 0.00213, "epss_percentile": 0.43882}, "CVE-2025-23611": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23612": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23613": {"epss_score": 0.00135, "epss_percentile": 0.3398}, "CVE-2025-23614": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23615": {"epss_score": 0.00135, "epss_percentile": 0.3398}, "CVE-2025-23616": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23617": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23618": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23619": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23620": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23621": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23622": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23623": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23624": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23625": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23626": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23627": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23628": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23629": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23630": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23631": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23632": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23633": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23634": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23635": {"epss_score": 0.0008, "epss_percentile": 0.24195}, "CVE-2025-23636": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23637": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23638": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23639": {"epss_score": 0.00046, "epss_percentile": 0.14285}, "CVE-2025-23640": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23641": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23642": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23643": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23644": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23645": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23646": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23647": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23648": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23649": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23650": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23651": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23652": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23653": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23654": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23655": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23656": {"epss_score": 0.00075, "epss_percentile": 0.22897}, "CVE-2025-23657": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23658": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23659": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23660": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23661": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23662": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23663": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23664": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23665": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23666": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23667": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-23668": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23669": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23670": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23671": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23672": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23673": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23674": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23675": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23676": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23677": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23678": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23679": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23680": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23681": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23682": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23683": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23684": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2025-23685": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23686": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23687": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23688": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23689": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23690": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23691": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23692": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23693": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23694": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23695": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23696": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23697": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23698": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23699": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23700": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23701": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23702": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23703": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23704": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23705": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-23706": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23707": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-23708": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-23709": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23710": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23711": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23712": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23713": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23714": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23715": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23716": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23717": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23718": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23719": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-23720": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23721": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23722": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23723": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23724": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23725": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23726": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23727": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23728": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23729": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23730": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23731": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23732": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23733": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23734": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23735": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23736": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23737": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23738": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23739": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23740": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23741": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23742": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23743": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23744": {"epss_score": 0.00071, "epss_percentile": 0.22162}, "CVE-2025-23745": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23746": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23747": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23748": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23749": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23750": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23751": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23752": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23753": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23754": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23755": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23756": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23757": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-23758": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23759": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23760": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23761": {"epss_score": 0.0017, "epss_percentile": 0.38673}, "CVE-2025-23762": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23763": {"epss_score": 0.00114, "epss_percentile": 0.30739}, "CVE-2025-23764": {"epss_score": 0.00159, "epss_percentile": 0.37356}, "CVE-2025-23765": {"epss_score": 0.00048, "epss_percentile": 0.15203}, "CVE-2025-23766": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2025-23767": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23768": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23769": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23770": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23771": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2025-23772": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23773": {"epss_score": 0.00074, "epss_percentile": 0.22701}, "CVE-2025-23774": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2025-23775": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23776": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-23777": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23778": {"epss_score": 0.0017, "epss_percentile": 0.38673}, "CVE-2025-23779": {"epss_score": 0.00202, "epss_percentile": 0.42489}, "CVE-2025-23780": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-23781": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2025-23782": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-23783": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23784": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-23785": {"epss_score": 0.0013, "epss_percentile": 0.33323}, "CVE-2025-23786": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23787": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23788": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23789": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23790": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23791": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23792": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23793": {"epss_score": 0.00085, "epss_percentile": 0.2505}, "CVE-2025-23794": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23795": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23796": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23797": {"epss_score": 0.00084, "epss_percentile": 0.24882}, "CVE-2025-23798": {"epss_score": 0.00136, "epss_percentile": 0.34159}, "CVE-2025-23799": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23800": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23801": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23802": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23803": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-23804": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23805": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23806": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-23807": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23808": {"epss_score": 0.00085, "epss_percentile": 0.2505}, "CVE-2025-23809": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23810": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23811": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23812": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23813": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23814": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23815": {"epss_score": 0.00085, "epss_percentile": 0.2505}, "CVE-2025-23816": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23817": {"epss_score": 0.00085, "epss_percentile": 0.2505}, "CVE-2025-23818": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23819": {"epss_score": 0.00252, "epss_percentile": 0.48369}, "CVE-2025-23820": {"epss_score": 0.00085, "epss_percentile": 0.2505}, "CVE-2025-23821": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23822": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23823": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23824": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23825": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23826": {"epss_score": 0.00213, "epss_percentile": 0.43882}, "CVE-2025-23827": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23828": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23829": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23830": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23831": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23832": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23833": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23834": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23835": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23836": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23837": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23838": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23839": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23840": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23841": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23842": {"epss_score": 0.00085, "epss_percentile": 0.2505}, "CVE-2025-23843": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23844": {"epss_score": 0.00085, "epss_percentile": 0.2505}, "CVE-2025-23845": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23846": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23847": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23848": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23849": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-23850": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23851": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23852": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23853": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23854": {"epss_score": 0.00202, "epss_percentile": 0.42394}, "CVE-2025-23855": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-23856": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23857": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-23858": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-23859": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23860": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23861": {"epss_score": 0.00085, "epss_percentile": 0.2505}, "CVE-2025-23862": {"epss_score": 0.00219, "epss_percentile": 0.4444}, "CVE-2025-23863": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23864": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23865": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23866": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23867": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23868": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23869": {"epss_score": 0.00085, "epss_percentile": 0.2505}, "CVE-2025-23870": {"epss_score": 0.00085, "epss_percentile": 0.2505}, "CVE-2025-23871": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23872": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-23873": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23874": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23875": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23876": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23877": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23878": {"epss_score": 0.00202, "epss_percentile": 0.42394}, "CVE-2025-23879": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23880": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23881": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23882": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23883": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23884": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23885": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23886": {"epss_score": 0.00207, "epss_percentile": 0.43176}, "CVE-2025-23887": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23888": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23889": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23890": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23891": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23892": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23893": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23894": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23895": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23896": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23897": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23898": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23899": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23900": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23901": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23902": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23903": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23904": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23905": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23906": {"epss_score": 0.00074, "epss_percentile": 0.22701}, "CVE-2025-23907": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23908": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23909": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23910": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-23911": {"epss_score": 0.0013, "epss_percentile": 0.33308}, "CVE-2025-23912": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-23913": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-23914": {"epss_score": 0.00197, "epss_percentile": 0.41954}, "CVE-2025-23915": {"epss_score": 0.00242, "epss_percentile": 0.47349}, "CVE-2025-23916": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-23917": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-23918": {"epss_score": 0.0023, "epss_percentile": 0.45675}, "CVE-2025-23919": {"epss_score": 0.00159, "epss_percentile": 0.3737}, "CVE-2025-23920": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23921": {"epss_score": 0.00178, "epss_percentile": 0.39636}, "CVE-2025-23922": {"epss_score": 0.01316, "epss_percentile": 0.79408}, "CVE-2025-23923": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23924": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23925": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23926": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23927": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23928": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23929": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-23930": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-23931": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-23932": {"epss_score": 0.00197, "epss_percentile": 0.41954}, "CVE-2025-23933": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23934": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23935": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23936": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23937": {"epss_score": 0.00192, "epss_percentile": 0.41296}, "CVE-2025-23938": {"epss_score": 0.00242, "epss_percentile": 0.47349}, "CVE-2025-23939": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23940": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23941": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23942": {"epss_score": 0.43227, "epss_percentile": 0.97376}, "CVE-2025-23943": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23944": {"epss_score": 0.00226, "epss_percentile": 0.45354}, "CVE-2025-23945": {"epss_score": 0.00242, "epss_percentile": 0.47349}, "CVE-2025-23946": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23947": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23948": {"epss_score": 0.00229, "epss_percentile": 0.45589}, "CVE-2025-23949": {"epss_score": 0.00248, "epss_percentile": 0.47982}, "CVE-2025-23950": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23951": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23952": {"epss_score": 0.00192, "epss_percentile": 0.41296}, "CVE-2025-23953": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2025-23954": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-23955": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-23956": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23957": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-23958": {"epss_score": 0.00074, "epss_percentile": 0.22701}, "CVE-2025-23959": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23960": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23961": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-23962": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-23963": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-23964": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-23965": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23966": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23967": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-23968": {"epss_score": 0.0006, "epss_percentile": 0.19213}, "CVE-2025-23969": {"epss_score": 0.0004, "epss_percentile": 0.11971}, "CVE-2025-23970": {"epss_score": 0.00059, "epss_percentile": 0.18855}, "CVE-2025-23971": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-23972": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-23973": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-23974": {"epss_score": 0.0005, "epss_percentile": 0.15942}, "CVE-2025-23975": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23976": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-23977": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-23978": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-23979": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-23980": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-23981": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-23982": {"epss_score": 0.00091, "epss_percentile": 0.26232}, "CVE-2025-23983": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-23984": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23985": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-23986": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-23987": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23988": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-23989": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23990": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-23991": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-23992": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-23993": {"epss_score": 0.00021, "epss_percentile": 0.04865}, "CVE-2025-23994": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23995": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-23996": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-23997": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-23998": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-23999": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-24000": {"epss_score": 0.00071, "epss_percentile": 0.22052}, "CVE-2025-24001": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-24002": {"epss_score": 0.001, "epss_percentile": 0.28544}, "CVE-2025-24003": {"epss_score": 0.00112, "epss_percentile": 0.30557}, "CVE-2025-24004": {"epss_score": 0.00024, "epss_percentile": 0.05969}, "CVE-2025-24005": {"epss_score": 0.00025, "epss_percentile": 0.06118}, "CVE-2025-24006": {"epss_score": 0.00014, "epss_percentile": 0.0197}, "CVE-2025-24007": {"epss_score": 0.00025, "epss_percentile": 0.0604}, "CVE-2025-24008": {"epss_score": 0.00018, "epss_percentile": 0.04039}, "CVE-2025-24009": {"epss_score": 0.00034, "epss_percentile": 0.09694}, "CVE-2025-24010": {"epss_score": 0.00025, "epss_percentile": 0.06144}, "CVE-2025-24011": {"epss_score": 0.19267, "epss_percentile": 0.95157}, "CVE-2025-24012": {"epss_score": 0.00228, "epss_percentile": 0.45485}, "CVE-2025-24013": {"epss_score": 0.00195, "epss_percentile": 0.41685}, "CVE-2025-24014": {"epss_score": 0.00058, "epss_percentile": 0.18595}, "CVE-2025-24015": {"epss_score": 0.00046, "epss_percentile": 0.14344}, "CVE-2025-24016": {"epss_score": 0.93403, "epss_percentile": 0.99804}, "CVE-2025-24017": {"epss_score": 0.00182, "epss_percentile": 0.40242}, "CVE-2025-24018": {"epss_score": 0.0011, "epss_percentile": 0.30237}, "CVE-2025-24019": {"epss_score": 0.00434, "epss_percentile": 0.6229}, "CVE-2025-24020": {"epss_score": 0.00104, "epss_percentile": 0.29208}, "CVE-2025-24021": {"epss_score": 0.00038, "epss_percentile": 0.11399}, "CVE-2025-24022": {"epss_score": 0.00099, "epss_percentile": 0.284}, "CVE-2025-24023": {"epss_score": 0.00179, "epss_percentile": 0.3981}, "CVE-2025-24024": {"epss_score": 0.00217, "epss_percentile": 0.44253}, "CVE-2025-24025": {"epss_score": 0.00091, "epss_percentile": 0.26223}, "CVE-2025-24026": {"epss_score": 0.00059, "epss_percentile": 0.189}, "CVE-2025-24027": {"epss_score": 0.00088, "epss_percentile": 0.25666}, "CVE-2025-24028": {"epss_score": 0.00298, "epss_percentile": 0.52836}, "CVE-2025-24029": {"epss_score": 0.00158, "epss_percentile": 0.37148}, "CVE-2025-24030": {"epss_score": 0.00224, "epss_percentile": 0.45054}, "CVE-2025-24031": {"epss_score": 0.00031, "epss_percentile": 0.08708}, "CVE-2025-24032": {"epss_score": 0.00444, "epss_percentile": 0.62844}, "CVE-2025-24033": {"epss_score": 0.00325, "epss_percentile": 0.5503}, "CVE-2025-24034": {"epss_score": 0.0005, "epss_percentile": 0.15861}, "CVE-2025-24035": {"epss_score": 0.00376, "epss_percentile": 0.58648}, "CVE-2025-24036": {"epss_score": 0.00084, "epss_percentile": 0.24834}, "CVE-2025-24039": {"epss_score": 0.00791, "epss_percentile": 0.73395}, "CVE-2025-24042": {"epss_score": 0.00233, "epss_percentile": 0.45994}, "CVE-2025-24043": {"epss_score": 0.00157, "epss_percentile": 0.37131}, "CVE-2025-24044": {"epss_score": 0.002, "epss_percentile": 0.42209}, "CVE-2025-24045": {"epss_score": 0.00329, "epss_percentile": 0.55384}, "CVE-2025-24046": {"epss_score": 0.00174, "epss_percentile": 0.39214}, "CVE-2025-24048": {"epss_score": 0.00174, "epss_percentile": 0.39214}, "CVE-2025-24049": {"epss_score": 0.00213, "epss_percentile": 0.4384}, "CVE-2025-24050": {"epss_score": 0.00174, "epss_percentile": 0.39214}, "CVE-2025-24051": {"epss_score": 0.00321, "epss_percentile": 0.54692}, "CVE-2025-24052": {"epss_score": 0.0012, "epss_percentile": 0.31762}, "CVE-2025-24053": {"epss_score": 0.00398, "epss_percentile": 0.60089}, "CVE-2025-24054": {"epss_score": 0.09866, "epss_percentile": 0.92744}, "CVE-2025-24055": {"epss_score": 0.00188, "epss_percentile": 0.40842}, "CVE-2025-24056": {"epss_score": 0.00306, "epss_percentile": 0.53397}, "CVE-2025-24057": {"epss_score": 0.00324, "epss_percentile": 0.54927}, "CVE-2025-24058": {"epss_score": 0.00519, "epss_percentile": 0.66177}, "CVE-2025-24059": {"epss_score": 0.00261, "epss_percentile": 0.49299}, "CVE-2025-24060": {"epss_score": 0.00519, "epss_percentile": 0.66177}, "CVE-2025-24061": {"epss_score": 0.00366, "epss_percentile": 0.58083}, "CVE-2025-24062": {"epss_score": 0.00519, "epss_percentile": 0.66177}, "CVE-2025-24063": {"epss_score": 0.00083, "epss_percentile": 0.24642}, "CVE-2025-24064": {"epss_score": 0.00406, "epss_percentile": 0.60522}, "CVE-2025-24065": {"epss_score": 0.00059, "epss_percentile": 0.18907}, "CVE-2025-24066": {"epss_score": 0.002, "epss_percentile": 0.42209}, "CVE-2025-24067": {"epss_score": 0.002, "epss_percentile": 0.42209}, "CVE-2025-24068": {"epss_score": 0.00059, "epss_percentile": 0.18907}, "CVE-2025-24069": {"epss_score": 0.00059, "epss_percentile": 0.18907}, "CVE-2025-24070": {"epss_score": 0.00238, "epss_percentile": 0.46767}, "CVE-2025-24071": {"epss_score": 0.57652, "epss_percentile": 0.98076}, "CVE-2025-24072": {"epss_score": 0.00174, "epss_percentile": 0.39214}, "CVE-2025-24073": {"epss_score": 0.00519, "epss_percentile": 0.66177}, "CVE-2025-24074": {"epss_score": 0.00519, "epss_percentile": 0.66177}, "CVE-2025-24075": {"epss_score": 0.00282, "epss_percentile": 0.51285}, "CVE-2025-24076": {"epss_score": 0.02027, "epss_percentile": 0.83318}, "CVE-2025-24077": {"epss_score": 0.00282, "epss_percentile": 0.51285}, "CVE-2025-24078": {"epss_score": 0.00287, "epss_percentile": 0.51859}, "CVE-2025-24079": {"epss_score": 0.00301, "epss_percentile": 0.53005}, "CVE-2025-24080": {"epss_score": 0.00301, "epss_percentile": 0.53005}, "CVE-2025-24081": {"epss_score": 0.00301, "epss_percentile": 0.53005}, "CVE-2025-24082": {"epss_score": 0.00301, "epss_percentile": 0.53005}, "CVE-2025-24083": {"epss_score": 0.00301, "epss_percentile": 0.53005}, "CVE-2025-24084": {"epss_score": 0.00214, "epss_percentile": 0.43968}, "CVE-2025-24085": {"epss_score": 0.28136, "epss_percentile": 0.96314}, "CVE-2025-24086": {"epss_score": 0.00029, "epss_percentile": 0.07671}, "CVE-2025-24087": {"epss_score": 0.00031, "epss_percentile": 0.08577}, "CVE-2025-24088": {"epss_score": 0.0005, "epss_percentile": 0.15759}, "CVE-2025-24091": {"epss_score": 0.00015, "epss_percentile": 0.02252}, "CVE-2025-24092": {"epss_score": 0.0003, "epss_percentile": 0.08197}, "CVE-2025-24093": {"epss_score": 0.00318, "epss_percentile": 0.54442}, "CVE-2025-24094": {"epss_score": 0.00022, "epss_percentile": 0.05199}, "CVE-2025-24095": {"epss_score": 0.00064, "epss_percentile": 0.20198}, "CVE-2025-24096": {"epss_score": 0.00034, "epss_percentile": 0.09478}, "CVE-2025-24097": {"epss_score": 0.00021, "epss_percentile": 0.04707}, "CVE-2025-24099": {"epss_score": 0.00026, "epss_percentile": 0.0641}, "CVE-2025-24100": {"epss_score": 0.00044, "epss_percentile": 0.13667}, "CVE-2025-24101": {"epss_score": 0.00029, "epss_percentile": 0.07761}, "CVE-2025-24102": {"epss_score": 0.00388, "epss_percentile": 0.59344}, "CVE-2025-24103": {"epss_score": 0.0011, "epss_percentile": 0.30217}, "CVE-2025-24104": {"epss_score": 0.05982, "epss_percentile": 0.90379}, "CVE-2025-24106": {"epss_score": 0.00082, "epss_percentile": 0.24497}, "CVE-2025-24107": {"epss_score": 0.00025, "epss_percentile": 0.06248}, "CVE-2025-24108": {"epss_score": 0.00034, "epss_percentile": 0.09478}, "CVE-2025-24109": {"epss_score": 0.00083, "epss_percentile": 0.24629}, "CVE-2025-24111": {"epss_score": 0.00021, "epss_percentile": 0.04891}, "CVE-2025-24112": {"epss_score": 0.00029, "epss_percentile": 0.07743}, "CVE-2025-24113": {"epss_score": 0.00304, "epss_percentile": 0.53284}, "CVE-2025-24114": {"epss_score": 0.00027, "epss_percentile": 0.06934}, "CVE-2025-24115": {"epss_score": 0.00032, "epss_percentile": 0.08734}, "CVE-2025-24116": {"epss_score": 0.00032, "epss_percentile": 0.0873}, "CVE-2025-24117": {"epss_score": 0.00035, "epss_percentile": 0.10128}, "CVE-2025-24118": {"epss_score": 0.06788, "epss_percentile": 0.91028}, "CVE-2025-24119": {"epss_score": 0.00017, "epss_percentile": 0.03217}, "CVE-2025-24120": {"epss_score": 0.00404, "epss_percentile": 0.60429}, "CVE-2025-24121": {"epss_score": 0.00039, "epss_percentile": 0.11689}, "CVE-2025-24122": {"epss_score": 0.00031, "epss_percentile": 0.08538}, "CVE-2025-24123": {"epss_score": 0.00085, "epss_percentile": 0.2522}, "CVE-2025-24124": {"epss_score": 0.00029, "epss_percentile": 0.07671}, "CVE-2025-24126": {"epss_score": 0.00465, "epss_percentile": 0.63741}, "CVE-2025-24127": {"epss_score": 0.00028, "epss_percentile": 0.07502}, "CVE-2025-24128": {"epss_score": 0.0029, "epss_percentile": 0.52095}, "CVE-2025-24129": {"epss_score": 0.00532, "epss_percentile": 0.66672}, "CVE-2025-24130": {"epss_score": 0.00076, "epss_percentile": 0.23134}, "CVE-2025-24131": {"epss_score": 0.0048, "epss_percentile": 0.64479}, "CVE-2025-24132": {"epss_score": 9e-05, "epss_percentile": 0.00602}, "CVE-2025-24134": {"epss_score": 0.00036, "epss_percentile": 0.10235}, "CVE-2025-24135": {"epss_score": 0.00026, "epss_percentile": 0.06557}, "CVE-2025-24136": {"epss_score": 0.00045, "epss_percentile": 0.13824}, "CVE-2025-24137": {"epss_score": 0.0038, "epss_percentile": 0.58974}, "CVE-2025-24138": {"epss_score": 0.00032, "epss_percentile": 0.08734}, "CVE-2025-24139": {"epss_score": 0.00031, "epss_percentile": 0.0869}, "CVE-2025-24140": {"epss_score": 0.00098, "epss_percentile": 0.27646}, "CVE-2025-24141": {"epss_score": 0.00038, "epss_percentile": 0.1112}, "CVE-2025-24142": {"epss_score": 0.00014, "epss_percentile": 0.0186}, "CVE-2025-24143": {"epss_score": 0.00195, "epss_percentile": 0.41615}, "CVE-2025-24144": {"epss_score": 0.00015, "epss_percentile": 0.02283}, "CVE-2025-24145": {"epss_score": 0.00047, "epss_percentile": 0.14793}, "CVE-2025-24146": {"epss_score": 0.00416, "epss_percentile": 0.61191}, "CVE-2025-24148": {"epss_score": 0.00014, "epss_percentile": 0.01828}, "CVE-2025-24149": {"epss_score": 0.00029, "epss_percentile": 0.07948}, "CVE-2025-24150": {"epss_score": 0.00477, "epss_percentile": 0.6435}, "CVE-2025-24151": {"epss_score": 0.00031, "epss_percentile": 0.08466}, "CVE-2025-24152": {"epss_score": 0.00031, "epss_percentile": 0.08638}, "CVE-2025-24153": {"epss_score": 0.00035, "epss_percentile": 0.10047}, "CVE-2025-24154": {"epss_score": 0.00501, "epss_percentile": 0.65359}, "CVE-2025-24155": {"epss_score": 0.00014, "epss_percentile": 0.01845}, "CVE-2025-24156": {"epss_score": 0.00093, "epss_percentile": 0.26625}, "CVE-2025-24157": {"epss_score": 0.00126, "epss_percentile": 0.32734}, "CVE-2025-24158": {"epss_score": 0.01377, "epss_percentile": 0.79842}, "CVE-2025-24159": {"epss_score": 0.0006, "epss_percentile": 0.19106}, "CVE-2025-24160": {"epss_score": 0.0038, "epss_percentile": 0.58947}, "CVE-2025-24161": {"epss_score": 0.00036, "epss_percentile": 0.10433}, "CVE-2025-24162": {"epss_score": 0.01845, "epss_percentile": 0.8251}, "CVE-2025-24163": {"epss_score": 0.00034, "epss_percentile": 0.09622}, "CVE-2025-24164": {"epss_score": 0.00026, "epss_percentile": 0.06621}, "CVE-2025-24167": {"epss_score": 0.00163, "epss_percentile": 0.37806}, "CVE-2025-24169": {"epss_score": 0.0018, "epss_percentile": 0.39906}, "CVE-2025-24170": {"epss_score": 0.00018, "epss_percentile": 0.03829}, "CVE-2025-24172": {"epss_score": 0.00113, "epss_percentile": 0.3068}, "CVE-2025-24173": {"epss_score": 0.00018, "epss_percentile": 0.03746}, "CVE-2025-24174": {"epss_score": 0.00042, "epss_percentile": 0.12744}, "CVE-2025-24176": {"epss_score": 0.00024, "epss_percentile": 0.05998}, "CVE-2025-24177": {"epss_score": 0.00317, "epss_percentile": 0.54351}, "CVE-2025-24178": {"epss_score": 0.00166, "epss_percentile": 0.38173}, "CVE-2025-24179": {"epss_score": 0.0003, "epss_percentile": 0.08276}, "CVE-2025-24180": {"epss_score": 0.001, "epss_percentile": 0.28544}, "CVE-2025-24181": {"epss_score": 0.00167, "epss_percentile": 0.384}, "CVE-2025-24182": {"epss_score": 0.00029, "epss_percentile": 0.07755}, "CVE-2025-24183": {"epss_score": 0.00011, "epss_percentile": 0.01035}, "CVE-2025-24184": {"epss_score": 0.00019, "epss_percentile": 0.04247}, "CVE-2025-24185": {"epss_score": 0.00021, "epss_percentile": 0.04772}, "CVE-2025-24188": {"epss_score": 0.00066, "epss_percentile": 0.20857}, "CVE-2025-24189": {"epss_score": 0.00082, "epss_percentile": 0.24413}, "CVE-2025-24190": {"epss_score": 0.00197, "epss_percentile": 0.41857}, "CVE-2025-24191": {"epss_score": 0.00029, "epss_percentile": 0.07828}, "CVE-2025-24192": {"epss_score": 0.00082, "epss_percentile": 0.24447}, "CVE-2025-24193": {"epss_score": 0.00028, "epss_percentile": 0.07267}, "CVE-2025-24194": {"epss_score": 0.00274, "epss_percentile": 0.50559}, "CVE-2025-24195": {"epss_score": 0.00144, "epss_percentile": 0.35247}, "CVE-2025-24196": {"epss_score": 0.00148, "epss_percentile": 0.35871}, "CVE-2025-24197": {"epss_score": 0.00016, "epss_percentile": 0.02652}, "CVE-2025-24198": {"epss_score": 0.00059, "epss_percentile": 0.18733}, "CVE-2025-24199": {"epss_score": 0.00026, "epss_percentile": 0.06679}, "CVE-2025-24200": {"epss_score": 0.43616, "epss_percentile": 0.97395}, "CVE-2025-24201": {"epss_score": 0.00068, "epss_percentile": 0.21322}, "CVE-2025-24202": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-24203": {"epss_score": 0.00012, "epss_percentile": 0.01285}, "CVE-2025-24204": {"epss_score": 0.00044, "epss_percentile": 0.13452}, "CVE-2025-24205": {"epss_score": 0.00027, "epss_percentile": 0.07118}, "CVE-2025-24206": {"epss_score": 0.00032, "epss_percentile": 0.08773}, "CVE-2025-24207": {"epss_score": 0.00167, "epss_percentile": 0.384}, "CVE-2025-24208": {"epss_score": 0.0008, "epss_percentile": 0.24084}, "CVE-2025-24209": {"epss_score": 0.00885, "epss_percentile": 0.7494}, "CVE-2025-24210": {"epss_score": 0.0002, "epss_percentile": 0.0442}, "CVE-2025-24211": {"epss_score": 0.00197, "epss_percentile": 0.41857}, "CVE-2025-24212": {"epss_score": 0.0004, "epss_percentile": 0.12113}, "CVE-2025-24213": {"epss_score": 0.00036, "epss_percentile": 0.10554}, "CVE-2025-24214": {"epss_score": 0.00027, "epss_percentile": 0.07118}, "CVE-2025-24215": {"epss_score": 0.00025, "epss_percentile": 0.06339}, "CVE-2025-24216": {"epss_score": 0.00209, "epss_percentile": 0.43393}, "CVE-2025-24217": {"epss_score": 0.00035, "epss_percentile": 0.10142}, "CVE-2025-24218": {"epss_score": 0.00022, "epss_percentile": 0.05044}, "CVE-2025-24220": {"epss_score": 0.00015, "epss_percentile": 0.02464}, "CVE-2025-24221": {"epss_score": 0.00106, "epss_percentile": 0.29539}, "CVE-2025-24222": {"epss_score": 0.00053, "epss_percentile": 0.17021}, "CVE-2025-24223": {"epss_score": 0.00061, "epss_percentile": 0.19541}, "CVE-2025-24224": {"epss_score": 0.0025, "epss_percentile": 0.48112}, "CVE-2025-24225": {"epss_score": 0.00025, "epss_percentile": 0.06165}, "CVE-2025-24226": {"epss_score": 0.00023, "epss_percentile": 0.05491}, "CVE-2025-24228": {"epss_score": 0.00041, "epss_percentile": 0.12213}, "CVE-2025-24229": {"epss_score": 0.00084, "epss_percentile": 0.24839}, "CVE-2025-24230": {"epss_score": 0.00197, "epss_percentile": 0.41857}, "CVE-2025-24231": {"epss_score": 0.00178, "epss_percentile": 0.39633}, "CVE-2025-24232": {"epss_score": 0.00178, "epss_percentile": 0.39633}, "CVE-2025-24233": {"epss_score": 0.00167, "epss_percentile": 0.384}, "CVE-2025-24234": {"epss_score": 0.00024, "epss_percentile": 0.05851}, "CVE-2025-24235": {"epss_score": 0.00116, "epss_percentile": 0.31113}, "CVE-2025-24236": {"epss_score": 0.0002, "epss_percentile": 0.04593}, "CVE-2025-24237": {"epss_score": 0.00461, "epss_percentile": 0.63551}, "CVE-2025-24238": {"epss_score": 0.00193, "epss_percentile": 0.41393}, "CVE-2025-24239": {"epss_score": 0.00084, "epss_percentile": 0.24985}, "CVE-2025-24240": {"epss_score": 0.00021, "epss_percentile": 0.04776}, "CVE-2025-24241": {"epss_score": 0.00144, "epss_percentile": 0.35247}, "CVE-2025-24242": {"epss_score": 0.00036, "epss_percentile": 0.1027}, "CVE-2025-24243": {"epss_score": 0.00036, "epss_percentile": 0.10435}, "CVE-2025-24244": {"epss_score": 0.0003, "epss_percentile": 0.08068}, "CVE-2025-24245": {"epss_score": 0.00093, "epss_percentile": 0.26667}, "CVE-2025-24246": {"epss_score": 0.00178, "epss_percentile": 0.39633}, "CVE-2025-24247": {"epss_score": 0.00178, "epss_percentile": 0.39633}, "CVE-2025-24248": {"epss_score": 0.00028, "epss_percentile": 0.07227}, "CVE-2025-24249": {"epss_score": 0.00167, "epss_percentile": 0.384}, "CVE-2025-24250": {"epss_score": 0.00178, "epss_percentile": 0.39633}, "CVE-2025-24251": {"epss_score": 0.00046, "epss_percentile": 0.14084}, "CVE-2025-24252": {"epss_score": 0.00019, "epss_percentile": 0.0416}, "CVE-2025-24253": {"epss_score": 0.00178, "epss_percentile": 0.39633}, "CVE-2025-24254": {"epss_score": 0.00135, "epss_percentile": 0.34017}, "CVE-2025-24255": {"epss_score": 0.00043, "epss_percentile": 0.13085}, "CVE-2025-24256": {"epss_score": 0.00178, "epss_percentile": 0.39633}, "CVE-2025-24257": {"epss_score": 0.00026, "epss_percentile": 0.06679}, "CVE-2025-24258": {"epss_score": 0.00015, "epss_percentile": 0.02531}, "CVE-2025-24259": {"epss_score": 0.00144, "epss_percentile": 0.35247}, "CVE-2025-24260": {"epss_score": 0.00178, "epss_percentile": 0.39633}, "CVE-2025-24261": {"epss_score": 0.00026, "epss_percentile": 0.06668}, "CVE-2025-24262": {"epss_score": 0.00023, "epss_percentile": 0.05637}, "CVE-2025-24263": {"epss_score": 0.00115, "epss_percentile": 0.30929}, "CVE-2025-24264": {"epss_score": 0.00355, "epss_percentile": 0.57268}, "CVE-2025-24265": {"epss_score": 0.00178, "epss_percentile": 0.39633}, "CVE-2025-24266": {"epss_score": 0.00224, "epss_percentile": 0.45048}, "CVE-2025-24267": {"epss_score": 0.00032, "epss_percentile": 0.08854}, "CVE-2025-24269": {"epss_score": 0.00115, "epss_percentile": 0.30929}, "CVE-2025-24270": {"epss_score": 0.00025, "epss_percentile": 0.06259}, "CVE-2025-24271": {"epss_score": 0.00077, "epss_percentile": 0.2355}, "CVE-2025-24272": {"epss_score": 0.00092, "epss_percentile": 0.26439}, "CVE-2025-24273": {"epss_score": 0.00178, "epss_percentile": 0.39633}, "CVE-2025-24274": {"epss_score": 0.00029, "epss_percentile": 0.07861}, "CVE-2025-24276": {"epss_score": 0.00027, "epss_percentile": 0.06842}, "CVE-2025-24277": {"epss_score": 0.00027, "epss_percentile": 0.07152}, "CVE-2025-24278": {"epss_score": 0.00067, "epss_percentile": 0.21173}, "CVE-2025-24279": {"epss_score": 0.0011, "epss_percentile": 0.30192}, "CVE-2025-24280": {"epss_score": 0.00026, "epss_percentile": 0.06406}, "CVE-2025-24281": {"epss_score": 0.00023, "epss_percentile": 0.05637}, "CVE-2025-24282": {"epss_score": 0.00022, "epss_percentile": 0.05238}, "CVE-2025-24283": {"epss_score": 0.00027, "epss_percentile": 0.06842}, "CVE-2025-24285": {"epss_score": 0.00236, "epss_percentile": 0.46455}, "CVE-2025-24286": {"epss_score": 0.00085, "epss_percentile": 0.25164}, "CVE-2025-24287": {"epss_score": 0.00018, "epss_percentile": 0.04049}, "CVE-2025-24288": {"epss_score": 0.0009, "epss_percentile": 0.26002}, "CVE-2025-24289": {"epss_score": 0.0002, "epss_percentile": 0.04594}, "CVE-2025-24290": {"epss_score": 0.00028, "epss_percentile": 0.07506}, "CVE-2025-24291": {"epss_score": 0.00019, "epss_percentile": 0.04201}, "CVE-2025-24292": {"epss_score": 0.00065, "epss_percentile": 0.20574}, "CVE-2025-24294": {"epss_score": 0.00056, "epss_percentile": 0.17675}, "CVE-2025-24296": {"epss_score": 0.00021, "epss_percentile": 0.04905}, "CVE-2025-24297": {"epss_score": 0.0013, "epss_percentile": 0.33222}, "CVE-2025-24298": {"epss_score": 0.00016, "epss_percentile": 0.02955}, "CVE-2025-24299": {"epss_score": 0.00088, "epss_percentile": 0.25666}, "CVE-2025-24301": {"epss_score": 0.00038, "epss_percentile": 0.114}, "CVE-2025-24302": {"epss_score": 7e-05, "epss_percentile": 0.00332}, "CVE-2025-24303": {"epss_score": 0.00012, "epss_percentile": 0.0134}, "CVE-2025-24304": {"epss_score": 0.00024, "epss_percentile": 0.0601}, "CVE-2025-24305": {"epss_score": 6e-05, "epss_percentile": 0.00265}, "CVE-2025-24306": {"epss_score": 0.00584, "epss_percentile": 0.68369}, "CVE-2025-24307": {"epss_score": 0.00028, "epss_percentile": 0.07577}, "CVE-2025-24308": {"epss_score": 0.00022, "epss_percentile": 0.0506}, "CVE-2025-24309": {"epss_score": 0.00033, "epss_percentile": 0.09182}, "CVE-2025-24310": {"epss_score": 0.00061, "epss_percentile": 0.19507}, "CVE-2025-24311": {"epss_score": 0.00022, "epss_percentile": 0.05039}, "CVE-2025-24312": {"epss_score": 0.00341, "epss_percentile": 0.5631}, "CVE-2025-24313": {"epss_score": 0.00024, "epss_percentile": 0.05809}, "CVE-2025-24314": {"epss_score": 0.00037, "epss_percentile": 0.10998}, "CVE-2025-24315": {"epss_score": 0.00154, "epss_percentile": 0.36648}, "CVE-2025-24316": {"epss_score": 0.00111, "epss_percentile": 0.30324}, "CVE-2025-24317": {"epss_score": 0.00089, "epss_percentile": 0.25794}, "CVE-2025-24318": {"epss_score": 0.00087, "epss_percentile": 0.25593}, "CVE-2025-24319": {"epss_score": 0.00345, "epss_percentile": 0.56567}, "CVE-2025-24320": {"epss_score": 0.00435, "epss_percentile": 0.6238}, "CVE-2025-24322": {"epss_score": 0.00137, "epss_percentile": 0.34253}, "CVE-2025-24323": {"epss_score": 0.0001, "epss_percentile": 0.00913}, "CVE-2025-24324": {"epss_score": 0.00011, "epss_percentile": 0.01035}, "CVE-2025-24325": {"epss_score": 0.00024, "epss_percentile": 0.05808}, "CVE-2025-24326": {"epss_score": 0.00341, "epss_percentile": 0.5631}, "CVE-2025-24327": {"epss_score": 0.00012, "epss_percentile": 0.01389}, "CVE-2025-24328": {"epss_score": 0.00016, "epss_percentile": 0.02984}, "CVE-2025-24329": {"epss_score": 0.00023, "epss_percentile": 0.05332}, "CVE-2025-24330": {"epss_score": 0.00023, "epss_percentile": 0.05332}, "CVE-2025-24331": {"epss_score": 0.00013, "epss_percentile": 0.01561}, "CVE-2025-24332": {"epss_score": 0.00017, "epss_percentile": 0.03448}, "CVE-2025-24333": {"epss_score": 0.00019, "epss_percentile": 0.04134}, "CVE-2025-24334": {"epss_score": 0.00016, "epss_percentile": 0.02752}, "CVE-2025-24335": {"epss_score": 0.00024, "epss_percentile": 0.05851}, "CVE-2025-24336": {"epss_score": 0.00028, "epss_percentile": 0.07269}, "CVE-2025-24337": {"epss_score": 0.00042, "epss_percentile": 0.12623}, "CVE-2025-24338": {"epss_score": 0.00104, "epss_percentile": 0.29218}, "CVE-2025-24339": {"epss_score": 0.00049, "epss_percentile": 0.15417}, "CVE-2025-24340": {"epss_score": 0.00036, "epss_percentile": 0.1033}, "CVE-2025-24341": {"epss_score": 0.00157, "epss_percentile": 0.37053}, "CVE-2025-24342": {"epss_score": 0.00065, "epss_percentile": 0.20617}, "CVE-2025-24343": {"epss_score": 0.00224, "epss_percentile": 0.44968}, "CVE-2025-24344": {"epss_score": 0.00044, "epss_percentile": 0.13419}, "CVE-2025-24345": {"epss_score": 0.00131, "epss_percentile": 0.33377}, "CVE-2025-24346": {"epss_score": 0.00115, "epss_percentile": 0.30882}, "CVE-2025-24347": {"epss_score": 0.00084, "epss_percentile": 0.24836}, "CVE-2025-24348": {"epss_score": 0.00081, "epss_percentile": 0.24222}, "CVE-2025-24349": {"epss_score": 0.00154, "epss_percentile": 0.36728}, "CVE-2025-24350": {"epss_score": 0.00158, "epss_percentile": 0.37149}, "CVE-2025-24351": {"epss_score": 0.00255, "epss_percentile": 0.48697}, "CVE-2025-24353": {"epss_score": 0.00173, "epss_percentile": 0.39074}, "CVE-2025-24354": {"epss_score": 0.02217, "epss_percentile": 0.84037}, "CVE-2025-24355": {"epss_score": 0.00036, "epss_percentile": 0.10241}, "CVE-2025-24356": {"epss_score": 0.00697, "epss_percentile": 0.71412}, "CVE-2025-24357": {"epss_score": 0.00274, "epss_percentile": 0.50528}, "CVE-2025-24358": {"epss_score": 0.0002, "epss_percentile": 0.04553}, "CVE-2025-24359": {"epss_score": 0.00053, "epss_percentile": 0.16874}, "CVE-2025-24360": {"epss_score": 0.00232, "epss_percentile": 0.45932}, "CVE-2025-24361": {"epss_score": 0.00134, "epss_percentile": 0.33864}, "CVE-2025-24362": {"epss_score": 0.00373, "epss_percentile": 0.58475}, "CVE-2025-24363": {"epss_score": 0.00035, "epss_percentile": 0.09964}, "CVE-2025-24364": {"epss_score": 0.02157, "epss_percentile": 0.83812}, "CVE-2025-24365": {"epss_score": 0.00135, "epss_percentile": 0.34011}, "CVE-2025-24366": {"epss_score": 0.00664, "epss_percentile": 0.70634}, "CVE-2025-24367": {"epss_score": 0.05528, "epss_percentile": 0.89963}, "CVE-2025-24368": {"epss_score": 0.00344, "epss_percentile": 0.56481}, "CVE-2025-24369": {"epss_score": 0.00186, "epss_percentile": 0.40681}, "CVE-2025-24370": {"epss_score": 0.00288, "epss_percentile": 0.51975}, "CVE-2025-24371": {"epss_score": 0.00219, "epss_percentile": 0.44531}, "CVE-2025-24372": {"epss_score": 0.00118, "epss_percentile": 0.31517}, "CVE-2025-24373": {"epss_score": 0.0018, "epss_percentile": 0.39882}, "CVE-2025-24374": {"epss_score": 0.00141, "epss_percentile": 0.34841}, "CVE-2025-24375": {"epss_score": 0.00019, "epss_percentile": 0.04369}, "CVE-2025-24376": {"epss_score": 0.00171, "epss_percentile": 0.38831}, "CVE-2025-24377": {"epss_score": 0.00046, "epss_percentile": 0.14317}, "CVE-2025-24378": {"epss_score": 0.00046, "epss_percentile": 0.14365}, "CVE-2025-24379": {"epss_score": 0.00046, "epss_percentile": 0.14365}, "CVE-2025-24380": {"epss_score": 0.00046, "epss_percentile": 0.14365}, "CVE-2025-24381": {"epss_score": 0.00162, "epss_percentile": 0.37626}, "CVE-2025-24382": {"epss_score": 0.02475, "epss_percentile": 0.84857}, "CVE-2025-24383": {"epss_score": 0.08044, "epss_percentile": 0.91848}, "CVE-2025-24385": {"epss_score": 0.00046, "epss_percentile": 0.14317}, "CVE-2025-24386": {"epss_score": 0.00046, "epss_percentile": 0.14365}, "CVE-2025-24387": {"epss_score": 0.0003, "epss_percentile": 0.08292}, "CVE-2025-24388": {"epss_score": 0.0005, "epss_percentile": 0.15849}, "CVE-2025-24389": {"epss_score": 0.00026, "epss_percentile": 0.06615}, "CVE-2025-24390": {"epss_score": 0.00048, "epss_percentile": 0.15229}, "CVE-2025-24391": {"epss_score": 0.00037, "epss_percentile": 0.10864}, "CVE-2025-24397": {"epss_score": 0.00301, "epss_percentile": 0.53019}, "CVE-2025-24398": {"epss_score": 0.001, "epss_percentile": 0.28557}, "CVE-2025-24399": {"epss_score": 0.00346, "epss_percentile": 0.56673}, "CVE-2025-24400": {"epss_score": 0.00076, "epss_percentile": 0.23158}, "CVE-2025-24401": {"epss_score": 0.00089, "epss_percentile": 0.25949}, "CVE-2025-24402": {"epss_score": 0.00271, "epss_percentile": 0.50337}, "CVE-2025-24403": {"epss_score": 0.00261, "epss_percentile": 0.49302}, "CVE-2025-24404": {"epss_score": 0.00078, "epss_percentile": 0.23556}, "CVE-2025-24406": {"epss_score": 0.01214, "epss_percentile": 0.7858}, "CVE-2025-24407": {"epss_score": 0.0018, "epss_percentile": 0.39906}, "CVE-2025-24408": {"epss_score": 0.00347, "epss_percentile": 0.56786}, "CVE-2025-24409": {"epss_score": 0.00329, "epss_percentile": 0.55409}, "CVE-2025-24410": {"epss_score": 0.00352, "epss_percentile": 0.57114}, "CVE-2025-24411": {"epss_score": 0.00254, "epss_percentile": 0.48566}, "CVE-2025-24412": {"epss_score": 0.00352, "epss_percentile": 0.57114}, "CVE-2025-24413": {"epss_score": 0.00352, "epss_percentile": 0.57114}, "CVE-2025-24414": {"epss_score": 0.00352, "epss_percentile": 0.57114}, "CVE-2025-24415": {"epss_score": 0.00352, "epss_percentile": 0.57114}, "CVE-2025-24416": {"epss_score": 0.00352, "epss_percentile": 0.57114}, "CVE-2025-24417": {"epss_score": 0.00352, "epss_percentile": 0.57114}, "CVE-2025-24418": {"epss_score": 0.0025, "epss_percentile": 0.48253}, "CVE-2025-24419": {"epss_score": 0.00149, "epss_percentile": 0.35967}, "CVE-2025-24420": {"epss_score": 0.00149, "epss_percentile": 0.35967}, "CVE-2025-24421": {"epss_score": 0.00119, "epss_percentile": 0.31644}, "CVE-2025-24422": {"epss_score": 0.0021, "epss_percentile": 0.43468}, "CVE-2025-24423": {"epss_score": 0.00147, "epss_percentile": 0.35653}, "CVE-2025-24424": {"epss_score": 0.0024, "epss_percentile": 0.46955}, "CVE-2025-24425": {"epss_score": 0.00735, "epss_percentile": 0.72254}, "CVE-2025-24426": {"epss_score": 0.0021, "epss_percentile": 0.43468}, "CVE-2025-24427": {"epss_score": 0.00151, "epss_percentile": 0.36317}, "CVE-2025-24428": {"epss_score": 0.00238, "epss_percentile": 0.46787}, "CVE-2025-24429": {"epss_score": 0.00129, "epss_percentile": 0.3311}, "CVE-2025-24430": {"epss_score": 0.0028, "epss_percentile": 0.5107}, "CVE-2025-24431": {"epss_score": 0.00053, "epss_percentile": 0.16681}, "CVE-2025-24432": {"epss_score": 0.0028, "epss_percentile": 0.5107}, "CVE-2025-24434": {"epss_score": 0.00606, "epss_percentile": 0.69001}, "CVE-2025-24435": {"epss_score": 0.0018, "epss_percentile": 0.39972}, "CVE-2025-24436": {"epss_score": 0.00119, "epss_percentile": 0.31644}, "CVE-2025-24437": {"epss_score": 0.00119, "epss_percentile": 0.31644}, "CVE-2025-24438": {"epss_score": 0.00352, "epss_percentile": 0.57114}, "CVE-2025-24439": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-24440": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-24441": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-24442": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-24443": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-24444": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-24445": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-24446": {"epss_score": 0.02659, "epss_percentile": 0.85363}, "CVE-2025-24447": {"epss_score": 0.30285, "epss_percentile": 0.96524}, "CVE-2025-24448": {"epss_score": 0.00053, "epss_percentile": 0.16681}, "CVE-2025-24449": {"epss_score": 0.00053, "epss_percentile": 0.16681}, "CVE-2025-24450": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-24451": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-24452": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-24453": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-24456": {"epss_score": 2e-05, "epss_percentile": 0.00024}, "CVE-2025-24457": {"epss_score": 1e-05, "epss_percentile": 2e-05}, "CVE-2025-24458": {"epss_score": 2e-05, "epss_percentile": 0.00037}, "CVE-2025-24459": {"epss_score": 0.04889, "epss_percentile": 0.89258}, "CVE-2025-24460": {"epss_score": 2e-05, "epss_percentile": 0.00049}, "CVE-2025-24461": {"epss_score": 2e-05, "epss_percentile": 0.0004}, "CVE-2025-24470": {"epss_score": 0.0025, "epss_percentile": 0.48102}, "CVE-2025-24471": {"epss_score": 0.00038, "epss_percentile": 0.112}, "CVE-2025-24472": {"epss_score": 0.04369, "epss_percentile": 0.88607}, "CVE-2025-24473": {"epss_score": 0.00038, "epss_percentile": 0.11419}, "CVE-2025-24474": {"epss_score": 0.00023, "epss_percentile": 0.05434}, "CVE-2025-24477": {"epss_score": 0.00017, "epss_percentile": 0.0345}, "CVE-2025-24478": {"epss_score": 0.00174, "epss_percentile": 0.39166}, "CVE-2025-24479": {"epss_score": 0.00032, "epss_percentile": 0.08761}, "CVE-2025-24480": {"epss_score": 0.00953, "epss_percentile": 0.75893}, "CVE-2025-24481": {"epss_score": 0.00029, "epss_percentile": 0.07683}, "CVE-2025-24482": {"epss_score": 0.00053, "epss_percentile": 0.16683}, "CVE-2025-24483": {"epss_score": 0.00023, "epss_percentile": 0.05475}, "CVE-2025-24484": {"epss_score": 0.00018, "epss_percentile": 0.03836}, "CVE-2025-24485": {"epss_score": 0.00044, "epss_percentile": 0.13657}, "CVE-2025-24486": {"epss_score": 0.00018, "epss_percentile": 0.03836}, "CVE-2025-24487": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-24489": {"epss_score": 0.00046, "epss_percentile": 0.14304}, "CVE-2025-24490": {"epss_score": 0.0027, "epss_percentile": 0.50271}, "CVE-2025-24491": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2025-24493": {"epss_score": 0.0001, "epss_percentile": 0.00816}, "CVE-2025-24494": {"epss_score": 0.01739, "epss_percentile": 0.82042}, "CVE-2025-24495": {"epss_score": 0.00014, "epss_percentile": 0.01932}, "CVE-2025-24496": {"epss_score": 0.00058, "epss_percentile": 0.18311}, "CVE-2025-24497": {"epss_score": 0.00341, "epss_percentile": 0.5631}, "CVE-2025-24499": {"epss_score": 0.003, "epss_percentile": 0.52976}, "CVE-2025-24500": {"epss_score": 0.00094, "epss_percentile": 0.26773}, "CVE-2025-24501": {"epss_score": 0.00134, "epss_percentile": 0.33859}, "CVE-2025-24502": {"epss_score": 0.0007, "epss_percentile": 0.21667}, "CVE-2025-24503": {"epss_score": 0.00062, "epss_percentile": 0.19594}, "CVE-2025-24504": {"epss_score": 0.00069, "epss_percentile": 0.21538}, "CVE-2025-24505": {"epss_score": 0.00052, "epss_percentile": 0.16606}, "CVE-2025-24506": {"epss_score": 0.0007, "epss_percentile": 0.2164}, "CVE-2025-24507": {"epss_score": 0.00042, "epss_percentile": 0.12602}, "CVE-2025-24508": {"epss_score": 0.00012, "epss_percentile": 0.01257}, "CVE-2025-24510": {"epss_score": 0.00039, "epss_percentile": 0.11795}, "CVE-2025-24511": {"epss_score": 0.00014, "epss_percentile": 0.01895}, "CVE-2025-24512": {"epss_score": 0.00018, "epss_percentile": 0.03968}, "CVE-2025-24513": {"epss_score": 0.00038, "epss_percentile": 0.11123}, "CVE-2025-24514": {"epss_score": 0.44989, "epss_percentile": 0.97465}, "CVE-2025-24515": {"epss_score": 0.00021, "epss_percentile": 0.0474}, "CVE-2025-24516": {"epss_score": 0.00015, "epss_percentile": 0.02417}, "CVE-2025-24517": {"epss_score": 0.0017, "epss_percentile": 0.38711}, "CVE-2025-24519": {"epss_score": 0.00016, "epss_percentile": 0.02761}, "CVE-2025-24520": {"epss_score": 0.00014, "epss_percentile": 0.01895}, "CVE-2025-24521": {"epss_score": 0.00123, "epss_percentile": 0.32256}, "CVE-2025-24522": {"epss_score": 0.00155, "epss_percentile": 0.36812}, "CVE-2025-24523": {"epss_score": 0.00036, "epss_percentile": 0.10544}, "CVE-2025-24525": {"epss_score": 0.0005, "epss_percentile": 0.15662}, "CVE-2025-24526": {"epss_score": 0.0003, "epss_percentile": 0.0823}, "CVE-2025-24527": {"epss_score": 0.00129, "epss_percentile": 0.33168}, "CVE-2025-24529": {"epss_score": 0.00154, "epss_percentile": 0.36669}, "CVE-2025-24530": {"epss_score": 0.00154, "epss_percentile": 0.36669}, "CVE-2025-24532": {"epss_score": 0.00083, "epss_percentile": 0.24759}, "CVE-2025-24533": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24534": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24535": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24536": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24537": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24538": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24539": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24540": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-24541": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24542": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24543": {"epss_score": 0.00028, "epss_percentile": 0.07568}, "CVE-2025-24544": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24545": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24546": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24547": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24548": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24549": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-24550": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-24551": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24552": {"epss_score": 0.00131, "epss_percentile": 0.3339}, "CVE-2025-24553": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24554": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24555": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-24556": {"epss_score": 0.00165, "epss_percentile": 0.38111}, "CVE-2025-24557": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24558": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24559": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-24560": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24561": {"epss_score": 0.00085, "epss_percentile": 0.25052}, "CVE-2025-24562": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-24563": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24564": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24565": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24566": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24567": {"epss_score": 0.0015, "epss_percentile": 0.361}, "CVE-2025-24568": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-24569": {"epss_score": 0.00252, "epss_percentile": 0.48369}, "CVE-2025-24570": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24571": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-24572": {"epss_score": 0.00076, "epss_percentile": 0.23077}, "CVE-2025-24573": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24574": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24575": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24576": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24577": {"epss_score": 0.00086, "epss_percentile": 0.25327}, "CVE-2025-24578": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-24579": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-24580": {"epss_score": 0.00135, "epss_percentile": 0.3398}, "CVE-2025-24581": {"epss_score": 0.00074, "epss_percentile": 0.22701}, "CVE-2025-24582": {"epss_score": 0.00131, "epss_percentile": 0.3339}, "CVE-2025-24583": {"epss_score": 0.00074, "epss_percentile": 0.22701}, "CVE-2025-24584": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-24585": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24586": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24587": {"epss_score": 0.14676, "epss_percentile": 0.94261}, "CVE-2025-24588": {"epss_score": 0.00207, "epss_percentile": 0.43113}, "CVE-2025-24589": {"epss_score": 0.00124, "epss_percentile": 0.32432}, "CVE-2025-24590": {"epss_score": 0.00116, "epss_percentile": 0.31088}, "CVE-2025-24591": {"epss_score": 0.00172, "epss_percentile": 0.39004}, "CVE-2025-24592": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24593": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-24594": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2025-24595": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24596": {"epss_score": 0.0021, "epss_percentile": 0.43457}, "CVE-2025-24597": {"epss_score": 0.0015, "epss_percentile": 0.361}, "CVE-2025-24598": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-24599": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24600": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-24601": {"epss_score": 0.00197, "epss_percentile": 0.41954}, "CVE-2025-24602": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24603": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-24604": {"epss_score": 0.0017, "epss_percentile": 0.38673}, "CVE-2025-24605": {"epss_score": 0.00262, "epss_percentile": 0.49341}, "CVE-2025-24606": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-24607": {"epss_score": 0.00152, "epss_percentile": 0.36422}, "CVE-2025-24608": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24609": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24610": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24611": {"epss_score": 0.00329, "epss_percentile": 0.55405}, "CVE-2025-24612": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-24613": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-24614": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24615": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24616": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24617": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24618": {"epss_score": 0.00142, "epss_percentile": 0.35085}, "CVE-2025-24619": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24620": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24621": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24622": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24623": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-24624": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24625": {"epss_score": 0.00101, "epss_percentile": 0.28594}, "CVE-2025-24626": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24627": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24628": {"epss_score": 0.0015, "epss_percentile": 0.36104}, "CVE-2025-24629": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24630": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24631": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24632": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24633": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-24634": {"epss_score": 0.00086, "epss_percentile": 0.25335}, "CVE-2025-24635": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24636": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-24637": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24638": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24639": {"epss_score": 0.0015, "epss_percentile": 0.361}, "CVE-2025-24640": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24641": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24642": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2025-24643": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2025-24644": {"epss_score": 0.0008, "epss_percentile": 0.24146}, "CVE-2025-24645": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24646": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24647": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24648": {"epss_score": 0.00122, "epss_percentile": 0.32099}, "CVE-2025-24649": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-24650": {"epss_score": 0.00223, "epss_percentile": 0.44958}, "CVE-2025-24651": {"epss_score": 0.00053, "epss_percentile": 0.16721}, "CVE-2025-24652": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-24653": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-24654": {"epss_score": 0.00119, "epss_percentile": 0.31577}, "CVE-2025-24655": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24656": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24657": {"epss_score": 0.00086, "epss_percentile": 0.25335}, "CVE-2025-24658": {"epss_score": 0.00086, "epss_percentile": 0.25335}, "CVE-2025-24659": {"epss_score": 0.03941, "epss_percentile": 0.87989}, "CVE-2025-24660": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24661": {"epss_score": 0.00226, "epss_percentile": 0.45354}, "CVE-2025-24662": {"epss_score": 0.00116, "epss_percentile": 0.31088}, "CVE-2025-24663": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-24664": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-24665": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-24666": {"epss_score": 0.00086, "epss_percentile": 0.25335}, "CVE-2025-24667": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-24668": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-24669": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-24670": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24671": {"epss_score": 0.00197, "epss_percentile": 0.41954}, "CVE-2025-24672": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-24673": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24674": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-24675": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24676": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24677": {"epss_score": 0.00233, "epss_percentile": 0.46055}, "CVE-2025-24678": {"epss_score": 0.00071, "epss_percentile": 0.22123}, "CVE-2025-24679": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2025-24680": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-24681": {"epss_score": 0.00086, "epss_percentile": 0.25335}, "CVE-2025-24682": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2025-24683": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-24684": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24685": {"epss_score": 0.00138, "epss_percentile": 0.34349}, "CVE-2025-24686": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-24687": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24688": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24689": {"epss_score": 0.00124, "epss_percentile": 0.32432}, "CVE-2025-24690": {"epss_score": 0.00192, "epss_percentile": 0.41296}, "CVE-2025-24691": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-24692": {"epss_score": 0.00135, "epss_percentile": 0.3398}, "CVE-2025-24693": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-24694": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24695": {"epss_score": 0.00074, "epss_percentile": 0.2279}, "CVE-2025-24696": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-24697": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2025-24698": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-24699": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-24700": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24701": {"epss_score": 0.00074, "epss_percentile": 0.2279}, "CVE-2025-24702": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24703": {"epss_score": 0.00072, "epss_percentile": 0.22274}, "CVE-2025-24704": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24705": {"epss_score": 0.00116, "epss_percentile": 0.31088}, "CVE-2025-24706": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24707": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24708": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24709": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24710": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24711": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24712": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24713": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24714": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24715": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24716": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24717": {"epss_score": 0.00058, "epss_percentile": 0.18265}, "CVE-2025-24718": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24719": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24720": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24721": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24722": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-24723": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-24724": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24725": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2025-24726": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24727": {"epss_score": 0.0008, "epss_percentile": 0.24146}, "CVE-2025-24728": {"epss_score": 0.0013, "epss_percentile": 0.33308}, "CVE-2025-24729": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-24730": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24731": {"epss_score": 0.0008, "epss_percentile": 0.24146}, "CVE-2025-24732": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24733": {"epss_score": 0.00122, "epss_percentile": 0.32145}, "CVE-2025-24734": {"epss_score": 0.00162, "epss_percentile": 0.37712}, "CVE-2025-24735": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-24736": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-24737": {"epss_score": 0.00054, "epss_percentile": 0.17194}, "CVE-2025-24738": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-24739": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-24740": {"epss_score": 0.00087, "epss_percentile": 0.2549}, "CVE-2025-24741": {"epss_score": 0.00087, "epss_percentile": 0.2549}, "CVE-2025-24742": {"epss_score": 0.00054, "epss_percentile": 0.17065}, "CVE-2025-24743": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-24744": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-24745": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-24746": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-24747": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-24748": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-24749": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-24750": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2025-24751": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2025-24752": {"epss_score": 0.03281, "epss_percentile": 0.86816}, "CVE-2025-24753": {"epss_score": 0.00125, "epss_percentile": 0.32484}, "CVE-2025-24754": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-24755": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-24756": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-24757": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-24758": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24759": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-24760": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-24761": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-24762": {"epss_score": 0.00054, "epss_percentile": 0.17355}, "CVE-2025-24763": {"epss_score": 0.00041, "epss_percentile": 0.12279}, "CVE-2025-24764": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-24765": {"epss_score": 0.00058, "epss_percentile": 0.18297}, "CVE-2025-24766": {"epss_score": 0.00099, "epss_percentile": 0.2786}, "CVE-2025-24767": {"epss_score": 0.00039, "epss_percentile": 0.11665}, "CVE-2025-24768": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-24769": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-24770": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-24771": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-24772": {"epss_score": 0.00017, "epss_percentile": 0.03358}, "CVE-2025-24773": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-24774": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-24775": {"epss_score": 0.00082, "epss_percentile": 0.24472}, "CVE-2025-24776": {"epss_score": 0.00054, "epss_percentile": 0.17355}, "CVE-2025-24777": {"epss_score": 0.00118, "epss_percentile": 0.31508}, "CVE-2025-24778": {"epss_score": 0.00054, "epss_percentile": 0.17355}, "CVE-2025-24779": {"epss_score": 0.00118, "epss_percentile": 0.31508}, "CVE-2025-24780": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-24781": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-24782": {"epss_score": 0.00134, "epss_percentile": 0.33899}, "CVE-2025-24783": {"epss_score": 0.00313, "epss_percentile": 0.54077}, "CVE-2025-24784": {"epss_score": 0.00098, "epss_percentile": 0.27665}, "CVE-2025-24785": {"epss_score": 0.00058, "epss_percentile": 0.18446}, "CVE-2025-24786": {"epss_score": 0.00654, "epss_percentile": 0.70343}, "CVE-2025-24787": {"epss_score": 0.00243, "epss_percentile": 0.47507}, "CVE-2025-24788": {"epss_score": 0.00028, "epss_percentile": 0.07377}, "CVE-2025-24789": {"epss_score": 0.00017, "epss_percentile": 0.03411}, "CVE-2025-24790": {"epss_score": 0.00012, "epss_percentile": 0.01248}, "CVE-2025-24791": {"epss_score": 0.00031, "epss_percentile": 0.08318}, "CVE-2025-24792": {"epss_score": 0.00028, "epss_percentile": 0.07497}, "CVE-2025-24793": {"epss_score": 0.00102, "epss_percentile": 0.28721}, "CVE-2025-24794": {"epss_score": 0.00087, "epss_percentile": 0.25563}, "CVE-2025-24795": {"epss_score": 0.00036, "epss_percentile": 0.10228}, "CVE-2025-24796": {"epss_score": 0.00179, "epss_percentile": 0.3977}, "CVE-2025-24797": {"epss_score": 0.00822, "epss_percentile": 0.73916}, "CVE-2025-24798": {"epss_score": 0.00011, "epss_percentile": 0.01113}, "CVE-2025-24799": {"epss_score": 0.63756, "epss_percentile": 0.98347}, "CVE-2025-24800": {"epss_score": 0.00041, "epss_percentile": 0.12291}, "CVE-2025-24801": {"epss_score": 0.00127, "epss_percentile": 0.32892}, "CVE-2025-24802": {"epss_score": 0.00092, "epss_percentile": 0.26499}, "CVE-2025-24803": {"epss_score": 0.00213, "epss_percentile": 0.43917}, "CVE-2025-24804": {"epss_score": 0.00159, "epss_percentile": 0.37318}, "CVE-2025-24805": {"epss_score": 0.00092, "epss_percentile": 0.2644}, "CVE-2025-24806": {"epss_score": 0.00097, "epss_percentile": 0.27562}, "CVE-2025-24807": {"epss_score": 0.00064, "epss_percentile": 0.20333}, "CVE-2025-24808": {"epss_score": 0.00086, "epss_percentile": 0.25302}, "CVE-2025-24810": {"epss_score": 0.00141, "epss_percentile": 0.34834}, "CVE-2025-24811": {"epss_score": 0.00117, "epss_percentile": 0.31262}, "CVE-2025-24812": {"epss_score": 0.00094, "epss_percentile": 0.26994}, "CVE-2025-24813": {"epss_score": 0.94183, "epss_percentile": 0.99914}, "CVE-2025-24814": {"epss_score": 0.00234, "epss_percentile": 0.46109}, "CVE-2025-24826": {"epss_score": 0.00016, "epss_percentile": 0.02866}, "CVE-2025-24827": {"epss_score": 0.00023, "epss_percentile": 0.0542}, "CVE-2025-24828": {"epss_score": 0.00023, "epss_percentile": 0.0552}, "CVE-2025-24829": {"epss_score": 0.00023, "epss_percentile": 0.0542}, "CVE-2025-24830": {"epss_score": 0.00023, "epss_percentile": 0.0542}, "CVE-2025-24831": {"epss_score": 0.00022, "epss_percentile": 0.05316}, "CVE-2025-24832": {"epss_score": 0.00052, "epss_percentile": 0.16385}, "CVE-2025-24833": {"epss_score": 0.00048, "epss_percentile": 0.15235}, "CVE-2025-24834": {"epss_score": 0.00053, "epss_percentile": 0.16704}, "CVE-2025-24835": {"epss_score": 0.00027, "epss_percentile": 0.06978}, "CVE-2025-24836": {"epss_score": 0.00026, "epss_percentile": 0.06579}, "CVE-2025-24838": {"epss_score": 0.00053, "epss_percentile": 0.16878}, "CVE-2025-24839": {"epss_score": 0.00048, "epss_percentile": 0.15238}, "CVE-2025-24840": {"epss_score": 0.00021, "epss_percentile": 0.04863}, "CVE-2025-24841": {"epss_score": 0.0014, "epss_percentile": 0.3469}, "CVE-2025-24842": {"epss_score": 0.00015, "epss_percentile": 0.02469}, "CVE-2025-24843": {"epss_score": 0.00034, "epss_percentile": 0.09437}, "CVE-2025-24844": {"epss_score": 0.00016, "epss_percentile": 0.0262}, "CVE-2025-24845": {"epss_score": 0.0007, "epss_percentile": 0.2166}, "CVE-2025-24846": {"epss_score": 0.00216, "epss_percentile": 0.44203}, "CVE-2025-24847": {"epss_score": 0.00072, "epss_percentile": 0.22244}, "CVE-2025-24848": {"epss_score": 0.00025, "epss_percentile": 0.06036}, "CVE-2025-24849": {"epss_score": 0.00016, "epss_percentile": 0.02938}, "CVE-2025-24850": {"epss_score": 0.00072, "epss_percentile": 0.22435}, "CVE-2025-24852": {"epss_score": 0.00036, "epss_percentile": 0.10545}, "CVE-2025-24853": {"epss_score": 0.00221, "epss_percentile": 0.44634}, "CVE-2025-24854": {"epss_score": 0.00185, "epss_percentile": 0.40573}, "CVE-2025-24855": {"epss_score": 0.00012, "epss_percentile": 0.01318}, "CVE-2025-24856": {"epss_score": 0.00061, "epss_percentile": 0.19528}, "CVE-2025-24857": {"epss_score": 0.00025, "epss_percentile": 0.0615}, "CVE-2025-24858": {"epss_score": 0.00045, "epss_percentile": 0.14039}, "CVE-2025-24859": {"epss_score": 0.0006, "epss_percentile": 0.18976}, "CVE-2025-24860": {"epss_score": 0.0009, "epss_percentile": 0.26153}, "CVE-2025-24861": {"epss_score": 0.00124, "epss_percentile": 0.32366}, "CVE-2025-24862": {"epss_score": 0.00033, "epss_percentile": 0.09207}, "CVE-2025-24863": {"epss_score": 0.00038, "epss_percentile": 0.11344}, "CVE-2025-24864": {"epss_score": 0.00021, "epss_percentile": 0.04727}, "CVE-2025-24865": {"epss_score": 0.64092, "epss_percentile": 0.98364}, "CVE-2025-24866": {"epss_score": 0.00055, "epss_percentile": 0.17523}, "CVE-2025-24867": {"epss_score": 0.00309, "epss_percentile": 0.5373}, "CVE-2025-24868": {"epss_score": 0.0011, "epss_percentile": 0.30182}, "CVE-2025-24869": {"epss_score": 0.00079, "epss_percentile": 0.2397}, "CVE-2025-24870": {"epss_score": 0.00042, "epss_percentile": 0.12705}, "CVE-2025-24872": {"epss_score": 0.00095, "epss_percentile": 0.27129}, "CVE-2025-24874": {"epss_score": 0.00082, "epss_percentile": 0.24533}, "CVE-2025-24875": {"epss_score": 0.00037, "epss_percentile": 0.10838}, "CVE-2025-24876": {"epss_score": 0.00174, "epss_percentile": 0.39193}, "CVE-2025-24882": {"epss_score": 0.00044, "epss_percentile": 0.13378}, "CVE-2025-24883": {"epss_score": 0.00041, "epss_percentile": 0.1223}, "CVE-2025-24884": {"epss_score": 0.00048, "epss_percentile": 0.14964}, "CVE-2025-24885": {"epss_score": 0.0006, "epss_percentile": 0.19161}, "CVE-2025-24886": {"epss_score": 0.00141, "epss_percentile": 0.34837}, "CVE-2025-24887": {"epss_score": 0.00057, "epss_percentile": 0.18056}, "CVE-2025-24888": {"epss_score": 0.00995, "epss_percentile": 0.76434}, "CVE-2025-24889": {"epss_score": 0.00055, "epss_percentile": 0.17369}, "CVE-2025-24891": {"epss_score": 0.00267, "epss_percentile": 0.50008}, "CVE-2025-24892": {"epss_score": 0.00335, "epss_percentile": 0.55836}, "CVE-2025-24893": {"epss_score": 0.94178, "epss_percentile": 0.99913}, "CVE-2025-24894": {"epss_score": 0.00234, "epss_percentile": 0.46085}, "CVE-2025-24895": {"epss_score": 0.00234, "epss_percentile": 0.46085}, "CVE-2025-24896": {"epss_score": 0.00134, "epss_percentile": 0.33909}, "CVE-2025-24897": {"epss_score": 0.00021, "epss_percentile": 0.04789}, "CVE-2025-24898": {"epss_score": 0.00322, "epss_percentile": 0.5479}, "CVE-2025-24899": {"epss_score": 0.00195, "epss_percentile": 0.41622}, "CVE-2025-24900": {"epss_score": 0.00082, "epss_percentile": 0.24501}, "CVE-2025-24901": {"epss_score": 0.00411, "epss_percentile": 0.60855}, "CVE-2025-24902": {"epss_score": 0.00495, "epss_percentile": 0.65109}, "CVE-2025-24903": {"epss_score": 0.0005, "epss_percentile": 0.15672}, "CVE-2025-24904": {"epss_score": 0.00061, "epss_percentile": 0.1947}, "CVE-2025-24905": {"epss_score": 0.00406, "epss_percentile": 0.60536}, "CVE-2025-24906": {"epss_score": 0.00406, "epss_percentile": 0.60536}, "CVE-2025-24907": {"epss_score": 0.00084, "epss_percentile": 0.24964}, "CVE-2025-24908": {"epss_score": 0.00077, "epss_percentile": 0.23299}, "CVE-2025-24909": {"epss_score": 0.00037, "epss_percentile": 0.10769}, "CVE-2025-24910": {"epss_score": 0.00049, "epss_percentile": 0.15621}, "CVE-2025-24911": {"epss_score": 0.00049, "epss_percentile": 0.15621}, "CVE-2025-24912": {"epss_score": 0.00203, "epss_percentile": 0.42492}, "CVE-2025-24914": {"epss_score": 0.00014, "epss_percentile": 0.01914}, "CVE-2025-24915": {"epss_score": 0.00014, "epss_percentile": 0.02062}, "CVE-2025-24916": {"epss_score": 9e-05, "epss_percentile": 0.00631}, "CVE-2025-24917": {"epss_score": 0.00012, "epss_percentile": 0.01388}, "CVE-2025-24918": {"epss_score": 0.00023, "epss_percentile": 0.05346}, "CVE-2025-24919": {"epss_score": 0.00323, "epss_percentile": 0.54898}, "CVE-2025-24920": {"epss_score": 0.00096, "epss_percentile": 0.27268}, "CVE-2025-24921": {"epss_score": 0.00019, "epss_percentile": 0.04138}, "CVE-2025-24922": {"epss_score": 0.00023, "epss_percentile": 0.05425}, "CVE-2025-24923": {"epss_score": 0.00012, "epss_percentile": 0.01188}, "CVE-2025-24924": {"epss_score": 0.00197, "epss_percentile": 0.41928}, "CVE-2025-24925": {"epss_score": 0.00016, "epss_percentile": 0.0262}, "CVE-2025-24928": {"epss_score": 0.00044, "epss_percentile": 0.13466}, "CVE-2025-24934": {"epss_score": 0.00037, "epss_percentile": 0.10987}, "CVE-2025-24936": {"epss_score": 0.00041, "epss_percentile": 0.12232}, "CVE-2025-24937": {"epss_score": 0.00032, "epss_percentile": 0.08847}, "CVE-2025-24938": {"epss_score": 0.0003, "epss_percentile": 0.0826}, "CVE-2025-24946": {"epss_score": 0.00085, "epss_percentile": 0.25238}, "CVE-2025-24947": {"epss_score": 0.00094, "epss_percentile": 0.27066}, "CVE-2025-24948": {"epss_score": 0.00059, "epss_percentile": 0.18859}, "CVE-2025-24949": {"epss_score": 0.00048, "epss_percentile": 0.1507}, "CVE-2025-24956": {"epss_score": 0.00134, "epss_percentile": 0.33837}, "CVE-2025-24957": {"epss_score": 0.00406, "epss_percentile": 0.60536}, "CVE-2025-24958": {"epss_score": 0.00411, "epss_percentile": 0.60855}, "CVE-2025-24959": {"epss_score": 0.00092, "epss_percentile": 0.26446}, "CVE-2025-24960": {"epss_score": 0.00232, "epss_percentile": 0.45933}, "CVE-2025-24961": {"epss_score": 0.00353, "epss_percentile": 0.57173}, "CVE-2025-24962": {"epss_score": 0.01134, "epss_percentile": 0.77892}, "CVE-2025-24963": {"epss_score": 0.06086, "epss_percentile": 0.90465}, "CVE-2025-24964": {"epss_score": 0.00145, "epss_percentile": 0.35499}, "CVE-2025-24965": {"epss_score": 0.00274, "epss_percentile": 0.50543}, "CVE-2025-24966": {"epss_score": 0.00266, "epss_percentile": 0.49866}, "CVE-2025-24967": {"epss_score": 0.00287, "epss_percentile": 0.51834}, "CVE-2025-24968": {"epss_score": 0.00216, "epss_percentile": 0.44198}, "CVE-2025-24969": {"epss_score": 0.00037, "epss_percentile": 0.10649}, "CVE-2025-24970": {"epss_score": 0.00347, "epss_percentile": 0.56788}, "CVE-2025-24971": {"epss_score": 0.49049, "epss_percentile": 0.97664}, "CVE-2025-24972": {"epss_score": 0.00113, "epss_percentile": 0.30673}, "CVE-2025-24973": {"epss_score": 0.00034, "epss_percentile": 0.09714}, "CVE-2025-24974": {"epss_score": 0.00399, "epss_percentile": 0.6013}, "CVE-2025-24975": {"epss_score": 0.00091, "epss_percentile": 0.26406}, "CVE-2025-24976": {"epss_score": 0.00103, "epss_percentile": 0.29001}, "CVE-2025-24977": {"epss_score": 0.00088, "epss_percentile": 0.25639}, "CVE-2025-24980": {"epss_score": 5e-05, "epss_percentile": 0.00195}, "CVE-2025-24981": {"epss_score": 0.0038, "epss_percentile": 0.58925}, "CVE-2025-24982": {"epss_score": 0.00047, "epss_percentile": 0.14914}, "CVE-2025-24983": {"epss_score": 0.00663, "epss_percentile": 0.70625}, "CVE-2025-24984": {"epss_score": 0.04971, "epss_percentile": 0.89351}, "CVE-2025-24985": {"epss_score": 0.00968, "epss_percentile": 0.76089}, "CVE-2025-24986": {"epss_score": 0.00361, "epss_percentile": 0.57732}, "CVE-2025-24987": {"epss_score": 0.00245, "epss_percentile": 0.47676}, "CVE-2025-24988": {"epss_score": 0.00245, "epss_percentile": 0.47676}, "CVE-2025-24989": {"epss_score": 0.16517, "epss_percentile": 0.94683}, "CVE-2025-24990": {"epss_score": 0.06154, "epss_percentile": 0.90523}, "CVE-2025-24991": {"epss_score": 0.00711, "epss_percentile": 0.71729}, "CVE-2025-24992": {"epss_score": 0.00265, "epss_percentile": 0.49814}, "CVE-2025-24993": {"epss_score": 0.01483, "epss_percentile": 0.80583}, "CVE-2025-24994": {"epss_score": 0.00258, "epss_percentile": 0.48982}, "CVE-2025-24995": {"epss_score": 0.002, "epss_percentile": 0.42209}, "CVE-2025-24996": {"epss_score": 0.009, "epss_percentile": 0.7516}, "CVE-2025-24997": {"epss_score": 0.0018, "epss_percentile": 0.39972}, "CVE-2025-24998": {"epss_score": 0.00907, "epss_percentile": 0.75261}, "CVE-2025-24999": {"epss_score": 0.00097, "epss_percentile": 0.27612}, "CVE-2025-25000": {"epss_score": 0.00579, "epss_percentile": 0.68236}, "CVE-2025-25001": {"epss_score": 0.00571, "epss_percentile": 0.67977}, "CVE-2025-25002": {"epss_score": 0.00729, "epss_percentile": 0.72133}, "CVE-2025-25003": {"epss_score": 0.00907, "epss_percentile": 0.75261}, "CVE-2025-25004": {"epss_score": 0.00059, "epss_percentile": 0.18755}, "CVE-2025-25005": {"epss_score": 0.00185, "epss_percentile": 0.40508}, "CVE-2025-25006": {"epss_score": 0.00079, "epss_percentile": 0.23965}, "CVE-2025-25007": {"epss_score": 0.00147, "epss_percentile": 0.35749}, "CVE-2025-25008": {"epss_score": 0.00202, "epss_percentile": 0.4246}, "CVE-2025-25009": {"epss_score": 0.00043, "epss_percentile": 0.13335}, "CVE-2025-25010": {"epss_score": 0.0005, "epss_percentile": 0.15959}, "CVE-2025-25011": {"epss_score": 0.00011, "epss_percentile": 0.00953}, "CVE-2025-25012": {"epss_score": 0.00054, "epss_percentile": 0.1722}, "CVE-2025-25013": {"epss_score": 0.00077, "epss_percentile": 0.23462}, "CVE-2025-25014": {"epss_score": 0.0086, "epss_percentile": 0.74526}, "CVE-2025-25015": {"epss_score": 0.01091, "epss_percentile": 0.77459}, "CVE-2025-25016": {"epss_score": 0.00037, "epss_percentile": 0.10901}, "CVE-2025-25017": {"epss_score": 0.00041, "epss_percentile": 0.12317}, "CVE-2025-25018": {"epss_score": 0.00043, "epss_percentile": 0.13335}, "CVE-2025-25019": {"epss_score": 0.00023, "epss_percentile": 0.05459}, "CVE-2025-25020": {"epss_score": 0.00082, "epss_percentile": 0.24437}, "CVE-2025-25021": {"epss_score": 0.0009, "epss_percentile": 0.26044}, "CVE-2025-25022": {"epss_score": 0.00054, "epss_percentile": 0.17359}, "CVE-2025-25023": {"epss_score": 0.00047, "epss_percentile": 0.14643}, "CVE-2025-25025": {"epss_score": 0.00037, "epss_percentile": 0.10838}, "CVE-2025-25026": {"epss_score": 0.00032, "epss_percentile": 0.08716}, "CVE-2025-25029": {"epss_score": 0.00034, "epss_percentile": 0.09474}, "CVE-2025-25032": {"epss_score": 0.00076, "epss_percentile": 0.23175}, "CVE-2025-25034": {"epss_score": 0.70094, "epss_percentile": 0.98616}, "CVE-2025-25035": {"epss_score": 0.00097, "epss_percentile": 0.27542}, "CVE-2025-25036": {"epss_score": 0.00085, "epss_percentile": 0.25072}, "CVE-2025-25037": {"epss_score": 0.01334, "epss_percentile": 0.79539}, "CVE-2025-25038": {"epss_score": 0.16507, "epss_percentile": 0.94681}, "CVE-2025-25039": {"epss_score": 0.00208, "epss_percentile": 0.4325}, "CVE-2025-25040": {"epss_score": 0.00025, "epss_percentile": 0.06314}, "CVE-2025-25041": {"epss_score": 0.00025, "epss_percentile": 0.06049}, "CVE-2025-25042": {"epss_score": 0.001, "epss_percentile": 0.28468}, "CVE-2025-25044": {"epss_score": 0.0002, "epss_percentile": 0.04504}, "CVE-2025-25045": {"epss_score": 0.0005, "epss_percentile": 0.15874}, "CVE-2025-25046": {"epss_score": 0.00021, "epss_percentile": 0.04791}, "CVE-2025-25048": {"epss_score": 0.00059, "epss_percentile": 0.18838}, "CVE-2025-25050": {"epss_score": 0.00022, "epss_percentile": 0.05039}, "CVE-2025-25052": {"epss_score": 0.00018, "epss_percentile": 0.03559}, "CVE-2025-25053": {"epss_score": 0.00247, "epss_percentile": 0.47858}, "CVE-2025-25054": {"epss_score": 0.00201, "epss_percentile": 0.42339}, "CVE-2025-25055": {"epss_score": 0.00077, "epss_percentile": 0.23326}, "CVE-2025-25056": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-25057": {"epss_score": 0.00024, "epss_percentile": 0.0601}, "CVE-2025-25059": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2025-25060": {"epss_score": 0.00109, "epss_percentile": 0.29959}, "CVE-2025-25061": {"epss_score": 0.00045, "epss_percentile": 0.1393}, "CVE-2025-25062": {"epss_score": 0.34064, "epss_percentile": 0.96825}, "CVE-2025-25063": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-25064": {"epss_score": 0.36224, "epss_percentile": 0.96962}, "CVE-2025-25065": {"epss_score": 0.00303, "epss_percentile": 0.53169}, "CVE-2025-25066": {"epss_score": 0.00031, "epss_percentile": 0.08683}, "CVE-2025-25067": {"epss_score": 0.00791, "epss_percentile": 0.73384}, "CVE-2025-25068": {"epss_score": 0.00141, "epss_percentile": 0.34844}, "CVE-2025-25069": {"epss_score": 0.0087, "epss_percentile": 0.74703}, "CVE-2025-25070": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25071": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25072": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25073": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-25074": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25075": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25076": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25077": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25078": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25079": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25080": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25081": {"epss_score": 0.00068, "epss_percentile": 0.21228}, "CVE-2025-25082": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25083": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25084": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25085": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25086": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-25087": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25088": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25089": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25090": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25091": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25092": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25093": {"epss_score": 0.00044, "epss_percentile": 0.13675}, "CVE-2025-25094": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25095": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25096": {"epss_score": 0.00076, "epss_percentile": 0.23208}, "CVE-2025-25097": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25098": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25099": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25100": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-25101": {"epss_score": 0.00789, "epss_percentile": 0.7335}, "CVE-2025-25102": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25103": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-25104": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25105": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-25106": {"epss_score": 0.00058, "epss_percentile": 0.18262}, "CVE-2025-25107": {"epss_score": 0.00058, "epss_percentile": 0.18262}, "CVE-2025-25108": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25109": {"epss_score": 0.00248, "epss_percentile": 0.47982}, "CVE-2025-25110": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-25111": {"epss_score": 0.00048, "epss_percentile": 0.15164}, "CVE-2025-25112": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-25113": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25114": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25115": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25116": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-25117": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25118": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25119": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25120": {"epss_score": 0.00094, "epss_percentile": 0.2706}, "CVE-2025-25121": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25122": {"epss_score": 0.00138, "epss_percentile": 0.34349}, "CVE-2025-25123": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25124": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25125": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25126": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25127": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25128": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25129": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25130": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-25131": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25132": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25133": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25134": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-25135": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25136": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25137": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-25138": {"epss_score": 0.00046, "epss_percentile": 0.14239}, "CVE-2025-25139": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25140": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25141": {"epss_score": 0.00236, "epss_percentile": 0.46389}, "CVE-2025-25142": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25143": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-25144": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25145": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-25146": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-25147": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25148": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25149": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25150": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-25151": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-25152": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25153": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25154": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25155": {"epss_score": 0.00252, "epss_percentile": 0.48369}, "CVE-2025-25156": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-25157": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25158": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25159": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25160": {"epss_score": 0.00046, "epss_percentile": 0.14294}, "CVE-2025-25161": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25162": {"epss_score": 0.00252, "epss_percentile": 0.48369}, "CVE-2025-25163": {"epss_score": 0.17526, "epss_percentile": 0.9486}, "CVE-2025-25164": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25165": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25166": {"epss_score": 0.00046, "epss_percentile": 0.14294}, "CVE-2025-25167": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2025-25168": {"epss_score": 0.00046, "epss_percentile": 0.14292}, "CVE-2025-25169": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25170": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-25171": {"epss_score": 0.00078, "epss_percentile": 0.23669}, "CVE-2025-25172": {"epss_score": 0.00108, "epss_percentile": 0.29873}, "CVE-2025-25173": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-25174": {"epss_score": 0.00144, "epss_percentile": 0.35271}, "CVE-2025-25175": {"epss_score": 0.00029, "epss_percentile": 0.077}, "CVE-2025-25177": {"epss_score": 0.00018, "epss_percentile": 0.0362}, "CVE-2025-25178": {"epss_score": 0.00045, "epss_percentile": 0.13723}, "CVE-2025-25179": {"epss_score": 0.00019, "epss_percentile": 0.04281}, "CVE-2025-25180": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-25181": {"epss_score": 0.81691, "epss_percentile": 0.99151}, "CVE-2025-25182": {"epss_score": 0.00327, "epss_percentile": 0.55131}, "CVE-2025-25183": {"epss_score": 0.00064, "epss_percentile": 0.20203}, "CVE-2025-25184": {"epss_score": 0.01035, "epss_percentile": 0.76905}, "CVE-2025-25185": {"epss_score": 0.00306, "epss_percentile": 0.53396}, "CVE-2025-25186": {"epss_score": 0.00247, "epss_percentile": 0.47901}, "CVE-2025-25187": {"epss_score": 0.00272, "epss_percentile": 0.50387}, "CVE-2025-25188": {"epss_score": 0.00026, "epss_percentile": 0.06445}, "CVE-2025-25189": {"epss_score": 0.00302, "epss_percentile": 0.53096}, "CVE-2025-25190": {"epss_score": 0.00609, "epss_percentile": 0.69126}, "CVE-2025-25191": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-25192": {"epss_score": 0.00186, "epss_percentile": 0.4069}, "CVE-2025-25193": {"epss_score": 0.00063, "epss_percentile": 0.19959}, "CVE-2025-25194": {"epss_score": 0.00095, "epss_percentile": 0.27088}, "CVE-2025-25195": {"epss_score": 0.00155, "epss_percentile": 0.36852}, "CVE-2025-25196": {"epss_score": 0.00279, "epss_percentile": 0.50968}, "CVE-2025-25197": {"epss_score": 0.00056, "epss_percentile": 0.17726}, "CVE-2025-25198": {"epss_score": 0.00121, "epss_percentile": 0.31883}, "CVE-2025-25199": {"epss_score": 0.07502, "epss_percentile": 0.91507}, "CVE-2025-25200": {"epss_score": 0.00412, "epss_percentile": 0.60934}, "CVE-2025-25201": {"epss_score": 0.00023, "epss_percentile": 0.05453}, "CVE-2025-25202": {"epss_score": 0.00081, "epss_percentile": 0.24291}, "CVE-2025-25203": {"epss_score": 0.0013, "epss_percentile": 0.33243}, "CVE-2025-25204": {"epss_score": 0.00137, "epss_percentile": 0.34281}, "CVE-2025-25205": {"epss_score": 0.00634, "epss_percentile": 0.69801}, "CVE-2025-25206": {"epss_score": 0.00585, "epss_percentile": 0.68402}, "CVE-2025-25207": {"epss_score": 0.00078, "epss_percentile": 0.23616}, "CVE-2025-25208": {"epss_score": 0.00042, "epss_percentile": 0.12751}, "CVE-2025-25209": {"epss_score": 0.00025, "epss_percentile": 0.06334}, "CVE-2025-25211": {"epss_score": 0.00114, "epss_percentile": 0.30876}, "CVE-2025-25212": {"epss_score": 0.00023, "epss_percentile": 0.05654}, "CVE-2025-25213": {"epss_score": 0.00044, "epss_percentile": 0.13371}, "CVE-2025-25214": {"epss_score": 0.00345, "epss_percentile": 0.56579}, "CVE-2025-25215": {"epss_score": 0.0003, "epss_percentile": 0.07985}, "CVE-2025-25216": {"epss_score": 0.00019, "epss_percentile": 0.04091}, "CVE-2025-25217": {"epss_score": 0.00018, "epss_percentile": 0.03559}, "CVE-2025-25218": {"epss_score": 0.00018, "epss_percentile": 0.03559}, "CVE-2025-25220": {"epss_score": 0.00781, "epss_percentile": 0.73191}, "CVE-2025-25221": {"epss_score": 0.00038, "epss_percentile": 0.11396}, "CVE-2025-25222": {"epss_score": 0.00038, "epss_percentile": 0.11396}, "CVE-2025-25223": {"epss_score": 0.00051, "epss_percentile": 0.16154}, "CVE-2025-25224": {"epss_score": 0.00047, "epss_percentile": 0.14489}, "CVE-2025-25225": {"epss_score": 0.00017, "epss_percentile": 0.03496}, "CVE-2025-25226": {"epss_score": 4e-05, "epss_percentile": 0.00141}, "CVE-2025-25227": {"epss_score": 2e-05, "epss_percentile": 0.00053}, "CVE-2025-25228": {"epss_score": 0.00043, "epss_percentile": 0.13279}, "CVE-2025-25229": {"epss_score": 0.00029, "epss_percentile": 0.07608}, "CVE-2025-25230": {"epss_score": 0.00024, "epss_percentile": 0.0582}, "CVE-2025-25231": {"epss_score": 0.08479, "epss_percentile": 0.92073}, "CVE-2025-25234": {"epss_score": 0.00046, "epss_percentile": 0.14417}, "CVE-2025-25235": {"epss_score": 0.00036, "epss_percentile": 0.10369}, "CVE-2025-25236": {"epss_score": 0.00039, "epss_percentile": 0.11732}, "CVE-2025-25241": {"epss_score": 0.00079, "epss_percentile": 0.2397}, "CVE-2025-25242": {"epss_score": 0.00071, "epss_percentile": 0.22201}, "CVE-2025-25243": {"epss_score": 0.00887, "epss_percentile": 0.74972}, "CVE-2025-25244": {"epss_score": 0.00035, "epss_percentile": 0.10043}, "CVE-2025-25245": {"epss_score": 0.00071, "epss_percentile": 0.22201}, "CVE-2025-25246": {"epss_score": 0.00676, "epss_percentile": 0.70926}, "CVE-2025-25247": {"epss_score": 0.00266, "epss_percentile": 0.49924}, "CVE-2025-25248": {"epss_score": 0.0004, "epss_percentile": 0.12047}, "CVE-2025-25250": {"epss_score": 0.00045, "epss_percentile": 0.13703}, "CVE-2025-25251": {"epss_score": 0.00018, "epss_percentile": 0.03908}, "CVE-2025-25252": {"epss_score": 0.00058, "epss_percentile": 0.18483}, "CVE-2025-25253": {"epss_score": 0.00016, "epss_percentile": 0.02851}, "CVE-2025-25254": {"epss_score": 0.0018, "epss_percentile": 0.39971}, "CVE-2025-25255": {"epss_score": 0.00038, "epss_percentile": 0.11344}, "CVE-2025-25256": {"epss_score": 0.26274, "epss_percentile": 0.96133}, "CVE-2025-25257": {"epss_score": 0.67546, "epss_percentile": 0.98512}, "CVE-2025-25264": {"epss_score": 0.00032, "epss_percentile": 0.09114}, "CVE-2025-25265": {"epss_score": 0.00044, "epss_percentile": 0.13549}, "CVE-2025-25266": {"epss_score": 0.00037, "epss_percentile": 0.10881}, "CVE-2025-25267": {"epss_score": 0.00035, "epss_percentile": 0.09898}, "CVE-2025-25268": {"epss_score": 0.00031, "epss_percentile": 0.0855}, "CVE-2025-25269": {"epss_score": 0.00065, "epss_percentile": 0.2057}, "CVE-2025-25270": {"epss_score": 0.00245, "epss_percentile": 0.47641}, "CVE-2025-25271": {"epss_score": 0.00025, "epss_percentile": 0.06286}, "CVE-2025-25273": {"epss_score": 7e-05, "epss_percentile": 0.00369}, "CVE-2025-25274": {"epss_score": 0.00284, "epss_percentile": 0.5149}, "CVE-2025-25276": {"epss_score": 0.00146, "epss_percentile": 0.35626}, "CVE-2025-25278": {"epss_score": 0.0001, "epss_percentile": 0.00784}, "CVE-2025-25279": {"epss_score": 0.29287, "epss_percentile": 0.9643}, "CVE-2025-25280": {"epss_score": 0.00192, "epss_percentile": 0.41372}, "CVE-2025-25281": {"epss_score": 0.00119, "epss_percentile": 0.31653}, "CVE-2025-25282": {"epss_score": 0.00135, "epss_percentile": 0.34046}, "CVE-2025-25283": {"epss_score": 0.00252, "epss_percentile": 0.48367}, "CVE-2025-25284": {"epss_score": 0.00894, "epss_percentile": 0.75086}, "CVE-2025-25285": {"epss_score": 0.00229, "epss_percentile": 0.45659}, "CVE-2025-25286": {"epss_score": 0.01038, "epss_percentile": 0.76936}, "CVE-2025-25287": {"epss_score": 0.00191, "epss_percentile": 0.41259}, "CVE-2025-25288": {"epss_score": 0.00229, "epss_percentile": 0.45659}, "CVE-2025-25289": {"epss_score": 0.00214, "epss_percentile": 0.44003}, "CVE-2025-25290": {"epss_score": 0.00194, "epss_percentile": 0.41551}, "CVE-2025-25291": {"epss_score": 0.13848, "epss_percentile": 0.94076}, "CVE-2025-25292": {"epss_score": 0.03825, "epss_percentile": 0.87792}, "CVE-2025-25293": {"epss_score": 0.02704, "epss_percentile": 0.85463}, "CVE-2025-25294": {"epss_score": 0.00322, "epss_percentile": 0.54757}, "CVE-2025-25295": {"epss_score": 0.00241, "epss_percentile": 0.47294}, "CVE-2025-25296": {"epss_score": 0.0555, "epss_percentile": 0.89985}, "CVE-2025-25297": {"epss_score": 0.00163, "epss_percentile": 0.37828}, "CVE-2025-25298": {"epss_score": 0.00058, "epss_percentile": 0.18424}, "CVE-2025-25299": {"epss_score": 0.00623, "epss_percentile": 0.69535}, "CVE-2025-25300": {"epss_score": 0.00253, "epss_percentile": 0.48444}, "CVE-2025-25301": {"epss_score": 0.00057, "epss_percentile": 0.18077}, "CVE-2025-25302": {"epss_score": 0.00038, "epss_percentile": 0.11393}, "CVE-2025-25303": {"epss_score": 0.0016, "epss_percentile": 0.37483}, "CVE-2025-25304": {"epss_score": 0.00386, "epss_percentile": 0.59248}, "CVE-2025-25305": {"epss_score": 0.00082, "epss_percentile": 0.24557}, "CVE-2025-25306": {"epss_score": 0.00053, "epss_percentile": 0.16875}, "CVE-2025-25323": {"epss_score": 0.00036, "epss_percentile": 0.10523}, "CVE-2025-25324": {"epss_score": 0.00036, "epss_percentile": 0.10523}, "CVE-2025-25325": {"epss_score": 0.00036, "epss_percentile": 0.10523}, "CVE-2025-25326": {"epss_score": 0.00036, "epss_percentile": 0.10523}, "CVE-2025-25329": {"epss_score": 0.00036, "epss_percentile": 0.10523}, "CVE-2025-25330": {"epss_score": 0.00036, "epss_percentile": 0.10523}, "CVE-2025-25331": {"epss_score": 0.00036, "epss_percentile": 0.10523}, "CVE-2025-25333": {"epss_score": 0.00131, "epss_percentile": 0.33416}, "CVE-2025-25334": {"epss_score": 0.00036, "epss_percentile": 0.10523}, "CVE-2025-25341": {"epss_score": 0.00019, "epss_percentile": 0.04277}, "CVE-2025-25343": {"epss_score": 0.00256, "epss_percentile": 0.48765}, "CVE-2025-25349": {"epss_score": 0.00139, "epss_percentile": 0.3461}, "CVE-2025-25351": {"epss_score": 0.00139, "epss_percentile": 0.3461}, "CVE-2025-25352": {"epss_score": 0.00703, "epss_percentile": 0.71541}, "CVE-2025-25354": {"epss_score": 0.00703, "epss_percentile": 0.71541}, "CVE-2025-25355": {"epss_score": 0.00703, "epss_percentile": 0.71541}, "CVE-2025-25356": {"epss_score": 0.00703, "epss_percentile": 0.71541}, "CVE-2025-25357": {"epss_score": 0.00703, "epss_percentile": 0.71541}, "CVE-2025-25361": {"epss_score": 0.00813, "epss_percentile": 0.73763}, "CVE-2025-25362": {"epss_score": 0.00453, "epss_percentile": 0.63231}, "CVE-2025-25363": {"epss_score": 0.00068, "epss_percentile": 0.21213}, "CVE-2025-25364": {"epss_score": 0.00032, "epss_percentile": 0.08799}, "CVE-2025-25370": {"epss_score": 0.00022, "epss_percentile": 0.05304}, "CVE-2025-25371": {"epss_score": 0.00176, "epss_percentile": 0.3941}, "CVE-2025-25372": {"epss_score": 0.0013, "epss_percentile": 0.33258}, "CVE-2025-25373": {"epss_score": 0.00148, "epss_percentile": 0.35872}, "CVE-2025-25374": {"epss_score": 0.00139, "epss_percentile": 0.34664}, "CVE-2025-25379": {"epss_score": 0.00145, "epss_percentile": 0.35377}, "CVE-2025-25381": {"epss_score": 0.00128, "epss_percentile": 0.33031}, "CVE-2025-25382": {"epss_score": 0.00116, "epss_percentile": 0.3119}, "CVE-2025-25387": {"epss_score": 0.00703, "epss_percentile": 0.71541}, "CVE-2025-25388": {"epss_score": 0.00954, "epss_percentile": 0.75895}, "CVE-2025-25389": {"epss_score": 0.00954, "epss_percentile": 0.75895}, "CVE-2025-25403": {"epss_score": 0.00042, "epss_percentile": 0.12736}, "CVE-2025-25426": {"epss_score": 0.00127, "epss_percentile": 0.32781}, "CVE-2025-25427": {"epss_score": 0.00138, "epss_percentile": 0.34516}, "CVE-2025-25428": {"epss_score": 0.00052, "epss_percentile": 0.16537}, "CVE-2025-25429": {"epss_score": 0.00042, "epss_percentile": 0.12753}, "CVE-2025-25430": {"epss_score": 0.00042, "epss_percentile": 0.12753}, "CVE-2025-25431": {"epss_score": 0.00042, "epss_percentile": 0.12753}, "CVE-2025-25450": {"epss_score": 0.00052, "epss_percentile": 0.16509}, "CVE-2025-25451": {"epss_score": 0.00034, "epss_percentile": 0.09549}, "CVE-2025-25452": {"epss_score": 0.00052, "epss_percentile": 0.16509}, "CVE-2025-25453": {"epss_score": 0.00053, "epss_percentile": 0.16791}, "CVE-2025-25454": {"epss_score": 0.00117, "epss_percentile": 0.31209}, "CVE-2025-25455": {"epss_score": 0.00117, "epss_percentile": 0.31209}, "CVE-2025-25456": {"epss_score": 0.00131, "epss_percentile": 0.33462}, "CVE-2025-25457": {"epss_score": 0.00117, "epss_percentile": 0.31209}, "CVE-2025-25458": {"epss_score": 0.00053, "epss_percentile": 0.16791}, "CVE-2025-25460": {"epss_score": 0.01223, "epss_percentile": 0.78667}, "CVE-2025-25461": {"epss_score": 0.00223, "epss_percentile": 0.44884}, "CVE-2025-25462": {"epss_score": 0.00243, "epss_percentile": 0.47481}, "CVE-2025-25467": {"epss_score": 0.00491, "epss_percentile": 0.64977}, "CVE-2025-25468": {"epss_score": 0.00125, "epss_percentile": 0.32542}, "CVE-2025-25469": {"epss_score": 0.00131, "epss_percentile": 0.3339}, "CVE-2025-25471": {"epss_score": 0.00054, "epss_percentile": 0.17096}, "CVE-2025-25472": {"epss_score": 0.00284, "epss_percentile": 0.51466}, "CVE-2025-25473": {"epss_score": 0.00139, "epss_percentile": 0.34645}, "CVE-2025-25474": {"epss_score": 0.00271, "epss_percentile": 0.50295}, "CVE-2025-25475": {"epss_score": 0.00578, "epss_percentile": 0.68181}, "CVE-2025-25476": {"epss_score": 0.0007, "epss_percentile": 0.21645}, "CVE-2025-25477": {"epss_score": 0.00158, "epss_percentile": 0.37244}, "CVE-2025-25478": {"epss_score": 0.00105, "epss_percentile": 0.29283}, "CVE-2025-25497": {"epss_score": 0.00118, "epss_percentile": 0.31431}, "CVE-2025-25500": {"epss_score": 0.00575, "epss_percentile": 0.68105}, "CVE-2025-25504": {"epss_score": 0.00194, "epss_percentile": 0.41584}, "CVE-2025-25505": {"epss_score": 0.00142, "epss_percentile": 0.34983}, "CVE-2025-25507": {"epss_score": 0.0067, "epss_percentile": 0.70785}, "CVE-2025-25510": {"epss_score": 0.0012, "epss_percentile": 0.31773}, "CVE-2025-25513": {"epss_score": 0.00325, "epss_percentile": 0.54988}, "CVE-2025-25514": {"epss_score": 0.00102, "epss_percentile": 0.28805}, "CVE-2025-25515": {"epss_score": 0.00362, "epss_percentile": 0.57776}, "CVE-2025-25516": {"epss_score": 0.00325, "epss_percentile": 0.54988}, "CVE-2025-25517": {"epss_score": 0.00325, "epss_percentile": 0.54988}, "CVE-2025-25519": {"epss_score": 0.00325, "epss_percentile": 0.54988}, "CVE-2025-25520": {"epss_score": 0.00325, "epss_percentile": 0.54988}, "CVE-2025-25521": {"epss_score": 0.00325, "epss_percentile": 0.54988}, "CVE-2025-25522": {"epss_score": 0.00036, "epss_percentile": 0.10284}, "CVE-2025-25523": {"epss_score": 0.00036, "epss_percentile": 0.10284}, "CVE-2025-25524": {"epss_score": 0.0005, "epss_percentile": 0.15876}, "CVE-2025-25525": {"epss_score": 0.00058, "epss_percentile": 0.18459}, "CVE-2025-25526": {"epss_score": 0.00058, "epss_percentile": 0.18459}, "CVE-2025-25527": {"epss_score": 0.00058, "epss_percentile": 0.18459}, "CVE-2025-25528": {"epss_score": 0.001, "epss_percentile": 0.28477}, "CVE-2025-25529": {"epss_score": 0.00043, "epss_percentile": 0.13057}, "CVE-2025-25530": {"epss_score": 0.00252, "epss_percentile": 0.48378}, "CVE-2025-25535": {"epss_score": 0.00226, "epss_percentile": 0.45269}, "CVE-2025-25539": {"epss_score": 0.00041, "epss_percentile": 0.12439}, "CVE-2025-25565": {"epss_score": 0.00191, "epss_percentile": 0.41267}, "CVE-2025-25566": {"epss_score": 0.00118, "epss_percentile": 0.314}, "CVE-2025-25567": {"epss_score": 0.0017, "epss_percentile": 0.38727}, "CVE-2025-25568": {"epss_score": 0.00191, "epss_percentile": 0.41267}, "CVE-2025-25570": {"epss_score": 0.00148, "epss_percentile": 0.35881}, "CVE-2025-25579": {"epss_score": 0.08557, "epss_percentile": 0.92125}, "CVE-2025-25580": {"epss_score": 0.00035, "epss_percentile": 0.09903}, "CVE-2025-25582": {"epss_score": 0.00035, "epss_percentile": 0.09903}, "CVE-2025-25585": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-25586": {"epss_score": 0.00025, "epss_percentile": 0.06147}, "CVE-2025-25589": {"epss_score": 0.00164, "epss_percentile": 0.37943}, "CVE-2025-25590": {"epss_score": 0.00035, "epss_percentile": 0.09903}, "CVE-2025-25595": {"epss_score": 0.00169, "epss_percentile": 0.38643}, "CVE-2025-25598": {"epss_score": 0.00151, "epss_percentile": 0.36331}, "CVE-2025-25604": {"epss_score": 0.04945, "epss_percentile": 0.89314}, "CVE-2025-25605": {"epss_score": 0.04945, "epss_percentile": 0.89314}, "CVE-2025-25609": {"epss_score": 0.00049, "epss_percentile": 0.15486}, "CVE-2025-25610": {"epss_score": 0.00049, "epss_percentile": 0.15486}, "CVE-2025-25612": {"epss_score": 0.00283, "epss_percentile": 0.51353}, "CVE-2025-25613": {"epss_score": 0.00017, "epss_percentile": 0.03349}, "CVE-2025-25614": {"epss_score": 0.00213, "epss_percentile": 0.43883}, "CVE-2025-25615": {"epss_score": 0.00639, "epss_percentile": 0.69937}, "CVE-2025-25616": {"epss_score": 0.0046, "epss_percentile": 0.63501}, "CVE-2025-25617": {"epss_score": 0.00062, "epss_percentile": 0.1974}, "CVE-2025-25618": {"epss_score": 0.00064, "epss_percentile": 0.20175}, "CVE-2025-25620": {"epss_score": 0.00149, "epss_percentile": 0.35963}, "CVE-2025-25621": {"epss_score": 0.00051, "epss_percentile": 0.16334}, "CVE-2025-25625": {"epss_score": 0.00061, "epss_percentile": 0.19439}, "CVE-2025-25632": {"epss_score": 0.09622, "epss_percentile": 0.92627}, "CVE-2025-25634": {"epss_score": 0.0012, "epss_percentile": 0.31773}, "CVE-2025-25635": {"epss_score": 0.00053, "epss_percentile": 0.16907}, "CVE-2025-25650": {"epss_score": 0.0026, "epss_percentile": 0.49149}, "CVE-2025-25662": {"epss_score": 0.00177, "epss_percentile": 0.3952}, "CVE-2025-25663": {"epss_score": 0.00191, "epss_percentile": 0.41267}, "CVE-2025-25664": {"epss_score": 0.00191, "epss_percentile": 0.41267}, "CVE-2025-25667": {"epss_score": 0.00191, "epss_percentile": 0.41267}, "CVE-2025-25668": {"epss_score": 0.00191, "epss_percentile": 0.41267}, "CVE-2025-25674": {"epss_score": 0.00177, "epss_percentile": 0.3952}, "CVE-2025-25675": {"epss_score": 0.00795, "epss_percentile": 0.73475}, "CVE-2025-25676": {"epss_score": 0.00177, "epss_percentile": 0.3952}, "CVE-2025-25678": {"epss_score": 0.00177, "epss_percentile": 0.3952}, "CVE-2025-25679": {"epss_score": 0.00057, "epss_percentile": 0.1804}, "CVE-2025-25680": {"epss_score": 0.00304, "epss_percentile": 0.53258}, "CVE-2025-25683": {"epss_score": 0.00123, "epss_percentile": 0.3219}, "CVE-2025-25684": {"epss_score": 0.00238, "epss_percentile": 0.4674}, "CVE-2025-25685": {"epss_score": 0.00192, "epss_percentile": 0.41309}, "CVE-2025-25686": {"epss_score": 0.00089, "epss_percentile": 0.25918}, "CVE-2025-25691": {"epss_score": 0.00227, "epss_percentile": 0.45378}, "CVE-2025-25692": {"epss_score": 0.0017, "epss_percentile": 0.38711}, "CVE-2025-25709": {"epss_score": 0.00132, "epss_percentile": 0.33589}, "CVE-2025-25711": {"epss_score": 0.00332, "epss_percentile": 0.55614}, "CVE-2025-25723": {"epss_score": 0.00035, "epss_percentile": 0.09853}, "CVE-2025-25724": {"epss_score": 0.00013, "epss_percentile": 0.01588}, "CVE-2025-25727": {"epss_score": 0.00036, "epss_percentile": 0.10616}, "CVE-2025-25728": {"epss_score": 0.00045, "epss_percentile": 0.14071}, "CVE-2025-25729": {"epss_score": 0.00131, "epss_percentile": 0.33416}, "CVE-2025-25730": {"epss_score": 0.00057, "epss_percentile": 0.17992}, "CVE-2025-25732": {"epss_score": 0.00092, "epss_percentile": 0.26456}, "CVE-2025-25733": {"epss_score": 0.00045, "epss_percentile": 0.13888}, "CVE-2025-25734": {"epss_score": 0.00102, "epss_percentile": 0.28872}, "CVE-2025-25735": {"epss_score": 0.00045, "epss_percentile": 0.13892}, "CVE-2025-25736": {"epss_score": 0.00045, "epss_percentile": 0.13918}, "CVE-2025-25737": {"epss_score": 0.00327, "epss_percentile": 0.55112}, "CVE-2025-25740": {"epss_score": 0.00308, "epss_percentile": 0.53603}, "CVE-2025-25741": {"epss_score": 0.00346, "epss_percentile": 0.56733}, "CVE-2025-25742": {"epss_score": 0.02562, "epss_percentile": 0.85107}, "CVE-2025-25743": {"epss_score": 0.10885, "epss_percentile": 0.93146}, "CVE-2025-25744": {"epss_score": 0.01429, "epss_percentile": 0.80224}, "CVE-2025-25745": {"epss_score": 0.00984, "epss_percentile": 0.76315}, "CVE-2025-25746": {"epss_score": 0.01429, "epss_percentile": 0.80224}, "CVE-2025-25747": {"epss_score": 0.00154, "epss_percentile": 0.36644}, "CVE-2025-25748": {"epss_score": 0.00057, "epss_percentile": 0.1807}, "CVE-2025-25749": {"epss_score": 0.0044, "epss_percentile": 0.62631}, "CVE-2025-25758": {"epss_score": 0.00083, "epss_percentile": 0.24701}, "CVE-2025-25759": {"epss_score": 0.01164, "epss_percentile": 0.78162}, "CVE-2025-25760": {"epss_score": 0.00116, "epss_percentile": 0.31112}, "CVE-2025-25761": {"epss_score": 0.00162, "epss_percentile": 0.37653}, "CVE-2025-25763": {"epss_score": 0.00061, "epss_percentile": 0.19245}, "CVE-2025-25765": {"epss_score": 0.00029, "epss_percentile": 0.07584}, "CVE-2025-25766": {"epss_score": 0.00161, "epss_percentile": 0.37531}, "CVE-2025-25767": {"epss_score": 0.00079, "epss_percentile": 0.23827}, "CVE-2025-25768": {"epss_score": 0.00074, "epss_percentile": 0.22716}, "CVE-2025-25769": {"epss_score": 0.00041, "epss_percentile": 0.12357}, "CVE-2025-25770": {"epss_score": 0.00047, "epss_percentile": 0.14571}, "CVE-2025-25772": {"epss_score": 0.00023, "epss_percentile": 0.0539}, "CVE-2025-25774": {"epss_score": 0.00078, "epss_percentile": 0.23565}, "CVE-2025-25775": {"epss_score": 0.00061, "epss_percentile": 0.19459}, "CVE-2025-25776": {"epss_score": 0.00029, "epss_percentile": 0.07664}, "CVE-2025-25777": {"epss_score": 0.00038, "epss_percentile": 0.11206}, "CVE-2025-25783": {"epss_score": 0.00556, "epss_percentile": 0.67509}, "CVE-2025-25784": {"epss_score": 0.00708, "epss_percentile": 0.7168}, "CVE-2025-25785": {"epss_score": 0.0011, "epss_percentile": 0.3011}, "CVE-2025-25789": {"epss_score": 0.01921, "epss_percentile": 0.82898}, "CVE-2025-25790": {"epss_score": 0.00649, "epss_percentile": 0.70231}, "CVE-2025-25791": {"epss_score": 0.00027, "epss_percentile": 0.06763}, "CVE-2025-25792": {"epss_score": 0.0008, "epss_percentile": 0.24114}, "CVE-2025-25793": {"epss_score": 0.00114, "epss_percentile": 0.30859}, "CVE-2025-25794": {"epss_score": 0.00114, "epss_percentile": 0.30859}, "CVE-2025-25796": {"epss_score": 0.00114, "epss_percentile": 0.30859}, "CVE-2025-25797": {"epss_score": 0.00114, "epss_percentile": 0.30859}, "CVE-2025-25799": {"epss_score": 0.0004, "epss_percentile": 0.12183}, "CVE-2025-25800": {"epss_score": 0.00226, "epss_percentile": 0.45314}, "CVE-2025-25802": {"epss_score": 0.00114, "epss_percentile": 0.30859}, "CVE-2025-25813": {"epss_score": 0.00114, "epss_percentile": 0.30859}, "CVE-2025-25818": {"epss_score": 0.00049, "epss_percentile": 0.15291}, "CVE-2025-25823": {"epss_score": 0.0004, "epss_percentile": 0.11959}, "CVE-2025-25825": {"epss_score": 0.00038, "epss_percentile": 0.11404}, "CVE-2025-25827": {"epss_score": 0.00036, "epss_percentile": 0.10613}, "CVE-2025-25871": {"epss_score": 0.00181, "epss_percentile": 0.4003}, "CVE-2025-25872": {"epss_score": 0.00137, "epss_percentile": 0.34306}, "CVE-2025-25873": {"epss_score": 0.00072, "epss_percentile": 0.22382}, "CVE-2025-25875": {"epss_score": 0.00091, "epss_percentile": 0.26376}, "CVE-2025-25876": {"epss_score": 0.00153, "epss_percentile": 0.36535}, "CVE-2025-25877": {"epss_score": 0.00112, "epss_percentile": 0.30515}, "CVE-2025-25878": {"epss_score": 0.00112, "epss_percentile": 0.30515}, "CVE-2025-25891": {"epss_score": 0.00013, "epss_percentile": 0.01652}, "CVE-2025-25892": {"epss_score": 0.00013, "epss_percentile": 0.01652}, "CVE-2025-25893": {"epss_score": 0.00036, "epss_percentile": 0.1026}, "CVE-2025-25894": {"epss_score": 0.00036, "epss_percentile": 0.1026}, "CVE-2025-25895": {"epss_score": 0.00036, "epss_percentile": 0.1026}, "CVE-2025-25896": {"epss_score": 0.00016, "epss_percentile": 0.03035}, "CVE-2025-25897": {"epss_score": 0.00089, "epss_percentile": 0.25825}, "CVE-2025-25898": {"epss_score": 0.00089, "epss_percentile": 0.25825}, "CVE-2025-25899": {"epss_score": 0.00058, "epss_percentile": 0.18394}, "CVE-2025-25900": {"epss_score": 0.00075, "epss_percentile": 0.22981}, "CVE-2025-25901": {"epss_score": 0.00089, "epss_percentile": 0.25825}, "CVE-2025-25905": {"epss_score": 0.00062, "epss_percentile": 0.19654}, "CVE-2025-25907": {"epss_score": 0.00058, "epss_percentile": 0.1848}, "CVE-2025-25908": {"epss_score": 0.0007, "epss_percentile": 0.21645}, "CVE-2025-25914": {"epss_score": 0.00902, "epss_percentile": 0.75195}, "CVE-2025-25916": {"epss_score": 0.0007, "epss_percentile": 0.21645}, "CVE-2025-25925": {"epss_score": 0.00083, "epss_percentile": 0.24825}, "CVE-2025-25927": {"epss_score": 0.00047, "epss_percentile": 0.14571}, "CVE-2025-25928": {"epss_score": 0.00088, "epss_percentile": 0.25702}, "CVE-2025-25929": {"epss_score": 0.0007, "epss_percentile": 0.21645}, "CVE-2025-25939": {"epss_score": 0.00021, "epss_percentile": 0.04745}, "CVE-2025-25940": {"epss_score": 0.01319, "epss_percentile": 0.79435}, "CVE-2025-25942": {"epss_score": 0.0013, "epss_percentile": 0.33244}, "CVE-2025-25943": {"epss_score": 0.00126, "epss_percentile": 0.32623}, "CVE-2025-25944": {"epss_score": 0.00094, "epss_percentile": 0.26984}, "CVE-2025-25945": {"epss_score": 0.0013, "epss_percentile": 0.33244}, "CVE-2025-25946": {"epss_score": 0.00027, "epss_percentile": 0.06941}, "CVE-2025-25947": {"epss_score": 0.00027, "epss_percentile": 0.06941}, "CVE-2025-25948": {"epss_score": 0.00121, "epss_percentile": 0.31952}, "CVE-2025-25949": {"epss_score": 0.00074, "epss_percentile": 0.22861}, "CVE-2025-25950": {"epss_score": 0.00103, "epss_percentile": 0.29094}, "CVE-2025-25951": {"epss_score": 0.00145, "epss_percentile": 0.35378}, "CVE-2025-25952": {"epss_score": 0.00103, "epss_percentile": 0.29094}, "CVE-2025-25953": {"epss_score": 0.00106, "epss_percentile": 0.29404}, "CVE-2025-25957": {"epss_score": 0.00073, "epss_percentile": 0.22489}, "CVE-2025-25958": {"epss_score": 0.00065, "epss_percentile": 0.20601}, "CVE-2025-25960": {"epss_score": 0.00073, "epss_percentile": 0.22489}, "CVE-2025-25962": {"epss_score": 0.00185, "epss_percentile": 0.40567}, "CVE-2025-25967": {"epss_score": 0.00251, "epss_percentile": 0.48289}, "CVE-2025-25968": {"epss_score": 0.00579, "epss_percentile": 0.68235}, "CVE-2025-25973": {"epss_score": 0.00398, "epss_percentile": 0.60057}, "CVE-2025-25975": {"epss_score": 0.00056, "epss_percentile": 0.17722}, "CVE-2025-25977": {"epss_score": 0.00444, "epss_percentile": 0.62848}, "CVE-2025-25983": {"epss_score": 0.00051, "epss_percentile": 0.16041}, "CVE-2025-25984": {"epss_score": 0.00088, "epss_percentile": 0.25705}, "CVE-2025-25985": {"epss_score": 0.00051, "epss_percentile": 0.16212}, "CVE-2025-25988": {"epss_score": 0.00066, "epss_percentile": 0.20945}, "CVE-2025-25990": {"epss_score": 0.00073, "epss_percentile": 0.22489}, "CVE-2025-25991": {"epss_score": 0.00067, "epss_percentile": 0.21147}, "CVE-2025-25992": {"epss_score": 0.00067, "epss_percentile": 0.21147}, "CVE-2025-25993": {"epss_score": 0.00067, "epss_percentile": 0.21147}, "CVE-2025-25994": {"epss_score": 0.00134, "epss_percentile": 0.33892}, "CVE-2025-25997": {"epss_score": 0.00685, "epss_percentile": 0.71148}, "CVE-2025-26001": {"epss_score": 0.00078, "epss_percentile": 0.23631}, "CVE-2025-26002": {"epss_score": 0.00105, "epss_percentile": 0.29341}, "CVE-2025-26003": {"epss_score": 0.00187, "epss_percentile": 0.40775}, "CVE-2025-26004": {"epss_score": 0.00105, "epss_percentile": 0.29341}, "CVE-2025-26005": {"epss_score": 0.00105, "epss_percentile": 0.29341}, "CVE-2025-26006": {"epss_score": 0.00105, "epss_percentile": 0.29341}, "CVE-2025-26007": {"epss_score": 0.00105, "epss_percentile": 0.29341}, "CVE-2025-26008": {"epss_score": 0.00105, "epss_percentile": 0.29341}, "CVE-2025-26009": {"epss_score": 0.00078, "epss_percentile": 0.23631}, "CVE-2025-26010": {"epss_score": 0.00088, "epss_percentile": 0.25712}, "CVE-2025-26011": {"epss_score": 0.00105, "epss_percentile": 0.29341}, "CVE-2025-26013": {"epss_score": 0.00159, "epss_percentile": 0.37336}, "CVE-2025-26014": {"epss_score": 0.01921, "epss_percentile": 0.82898}, "CVE-2025-26042": {"epss_score": 0.00029, "epss_percentile": 0.07616}, "CVE-2025-26047": {"epss_score": 0.00047, "epss_percentile": 0.14883}, "CVE-2025-26054": {"epss_score": 9e-05, "epss_percentile": 0.00601}, "CVE-2025-26055": {"epss_score": 0.00569, "epss_percentile": 0.67922}, "CVE-2025-26056": {"epss_score": 0.00425, "epss_percentile": 0.61718}, "CVE-2025-26058": {"epss_score": 0.00038, "epss_percentile": 0.11309}, "CVE-2025-26062": {"epss_score": 0.00336, "epss_percentile": 0.55901}, "CVE-2025-26063": {"epss_score": 0.00586, "epss_percentile": 0.68442}, "CVE-2025-26064": {"epss_score": 0.00087, "epss_percentile": 0.25469}, "CVE-2025-26065": {"epss_score": 0.00059, "epss_percentile": 0.18901}, "CVE-2025-26074": {"epss_score": 0.00136, "epss_percentile": 0.3413}, "CVE-2025-26086": {"epss_score": 0.0016, "epss_percentile": 0.37471}, "CVE-2025-26091": {"epss_score": 0.00063, "epss_percentile": 0.19812}, "CVE-2025-26125": {"epss_score": 0.00058, "epss_percentile": 0.18425}, "CVE-2025-26127": {"epss_score": 0.0008, "epss_percentile": 0.24108}, "CVE-2025-26136": {"epss_score": 0.00103, "epss_percentile": 0.28967}, "CVE-2025-26137": {"epss_score": 0.00248, "epss_percentile": 0.47977}, "CVE-2025-26138": {"epss_score": 0.00084, "epss_percentile": 0.25013}, "CVE-2025-26153": {"epss_score": 0.00038, "epss_percentile": 0.11092}, "CVE-2025-26155": {"epss_score": 0.00075, "epss_percentile": 0.22974}, "CVE-2025-26156": {"epss_score": 0.00691, "epss_percentile": 0.71262}, "CVE-2025-26157": {"epss_score": 0.00176, "epss_percentile": 0.3947}, "CVE-2025-26158": {"epss_score": 0.00166, "epss_percentile": 0.38146}, "CVE-2025-26159": {"epss_score": 0.00038, "epss_percentile": 0.11323}, "CVE-2025-26163": {"epss_score": 0.00139, "epss_percentile": 0.3461}, "CVE-2025-26167": {"epss_score": 0.00271, "epss_percentile": 0.50332}, "CVE-2025-26168": {"epss_score": 0.00014, "epss_percentile": 0.02067}, "CVE-2025-26169": {"epss_score": 0.00014, "epss_percentile": 0.02067}, "CVE-2025-26182": {"epss_score": 0.00318, "epss_percentile": 0.54441}, "CVE-2025-26186": {"epss_score": 0.00142, "epss_percentile": 0.35021}, "CVE-2025-26198": {"epss_score": 0.00438, "epss_percentile": 0.62557}, "CVE-2025-26199": {"epss_score": 0.00501, "epss_percentile": 0.65341}, "CVE-2025-26200": {"epss_score": 0.00184, "epss_percentile": 0.40396}, "CVE-2025-26201": {"epss_score": 0.00378, "epss_percentile": 0.58781}, "CVE-2025-26202": {"epss_score": 0.00071, "epss_percentile": 0.22069}, "CVE-2025-26206": {"epss_score": 0.00089, "epss_percentile": 0.25961}, "CVE-2025-26210": {"epss_score": 0.0011, "epss_percentile": 0.30206}, "CVE-2025-26211": {"epss_score": 0.00026, "epss_percentile": 0.06618}, "CVE-2025-26241": {"epss_score": 0.00041, "epss_percentile": 0.12262}, "CVE-2025-26258": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-26260": {"epss_score": 0.00917, "epss_percentile": 0.75425}, "CVE-2025-26262": {"epss_score": 0.00076, "epss_percentile": 0.23108}, "CVE-2025-26263": {"epss_score": 0.00334, "epss_percentile": 0.55705}, "CVE-2025-26264": {"epss_score": 0.1053, "epss_percentile": 0.9302}, "CVE-2025-26265": {"epss_score": 0.00084, "epss_percentile": 0.24913}, "CVE-2025-26268": {"epss_score": 0.00081, "epss_percentile": 0.24221}, "CVE-2025-26269": {"epss_score": 0.00054, "epss_percentile": 0.17255}, "CVE-2025-26278": {"epss_score": 0.00061, "epss_percentile": 0.19384}, "CVE-2025-26304": {"epss_score": 0.00173, "epss_percentile": 0.39109}, "CVE-2025-26305": {"epss_score": 0.00162, "epss_percentile": 0.37702}, "CVE-2025-26306": {"epss_score": 0.00121, "epss_percentile": 0.31913}, "CVE-2025-26307": {"epss_score": 0.00121, "epss_percentile": 0.31913}, "CVE-2025-26308": {"epss_score": 0.00121, "epss_percentile": 0.31913}, "CVE-2025-26309": {"epss_score": 0.00121, "epss_percentile": 0.31913}, "CVE-2025-26310": {"epss_score": 0.00156, "epss_percentile": 0.36984}, "CVE-2025-26311": {"epss_score": 0.00156, "epss_percentile": 0.36984}, "CVE-2025-26312": {"epss_score": 0.00054, "epss_percentile": 0.17308}, "CVE-2025-26318": {"epss_score": 0.01174, "epss_percentile": 0.78248}, "CVE-2025-26319": {"epss_score": 0.78804, "epss_percentile": 0.99003}, "CVE-2025-26320": {"epss_score": 0.007, "epss_percentile": 0.71483}, "CVE-2025-26325": {"epss_score": 0.00394, "epss_percentile": 0.59773}, "CVE-2025-26326": {"epss_score": 0.03161, "epss_percentile": 0.86531}, "CVE-2025-26330": {"epss_score": 0.00033, "epss_percentile": 0.09408}, "CVE-2025-26331": {"epss_score": 0.00057, "epss_percentile": 0.18014}, "CVE-2025-26332": {"epss_score": 0.00016, "epss_percentile": 0.03028}, "CVE-2025-26333": {"epss_score": 0.00063, "epss_percentile": 0.19905}, "CVE-2025-26335": {"epss_score": 0.00054, "epss_percentile": 0.17102}, "CVE-2025-26336": {"epss_score": 0.00134, "epss_percentile": 0.33824}, "CVE-2025-26339": {"epss_score": 0.00296, "epss_percentile": 0.52584}, "CVE-2025-26340": {"epss_score": 0.0018, "epss_percentile": 0.39921}, "CVE-2025-26341": {"epss_score": 0.00296, "epss_percentile": 0.52584}, "CVE-2025-26342": {"epss_score": 0.00296, "epss_percentile": 0.52584}, "CVE-2025-26343": {"epss_score": 0.00121, "epss_percentile": 0.31827}, "CVE-2025-26344": {"epss_score": 0.00296, "epss_percentile": 0.52584}, "CVE-2025-26345": {"epss_score": 0.00254, "epss_percentile": 0.48532}, "CVE-2025-26346": {"epss_score": 0.00412, "epss_percentile": 0.60948}, "CVE-2025-26347": {"epss_score": 0.00306, "epss_percentile": 0.53446}, "CVE-2025-26348": {"epss_score": 0.00412, "epss_percentile": 0.60948}, "CVE-2025-26349": {"epss_score": 0.01478, "epss_percentile": 0.80555}, "CVE-2025-26350": {"epss_score": 0.00242, "epss_percentile": 0.4735}, "CVE-2025-26351": {"epss_score": 0.00362, "epss_percentile": 0.57758}, "CVE-2025-26352": {"epss_score": 0.01803, "epss_percentile": 0.82336}, "CVE-2025-26353": {"epss_score": 0.00362, "epss_percentile": 0.57758}, "CVE-2025-26354": {"epss_score": 0.02174, "epss_percentile": 0.8388}, "CVE-2025-26355": {"epss_score": 0.01803, "epss_percentile": 0.82336}, "CVE-2025-26356": {"epss_score": 0.02174, "epss_percentile": 0.8388}, "CVE-2025-26357": {"epss_score": 0.00362, "epss_percentile": 0.57758}, "CVE-2025-26358": {"epss_score": 0.00345, "epss_percentile": 0.56583}, "CVE-2025-26359": {"epss_score": 0.00357, "epss_percentile": 0.57437}, "CVE-2025-26360": {"epss_score": 0.00136, "epss_percentile": 0.34085}, "CVE-2025-26361": {"epss_score": 0.00312, "epss_percentile": 0.53962}, "CVE-2025-26362": {"epss_score": 0.00144, "epss_percentile": 0.35335}, "CVE-2025-26363": {"epss_score": 0.00144, "epss_percentile": 0.35335}, "CVE-2025-26364": {"epss_score": 0.00144, "epss_percentile": 0.35335}, "CVE-2025-26365": {"epss_score": 0.00144, "epss_percentile": 0.35335}, "CVE-2025-26366": {"epss_score": 0.00144, "epss_percentile": 0.35335}, "CVE-2025-26367": {"epss_score": 0.00158, "epss_percentile": 0.37211}, "CVE-2025-26368": {"epss_score": 0.00266, "epss_percentile": 0.49897}, "CVE-2025-26369": {"epss_score": 0.00304, "epss_percentile": 0.53307}, "CVE-2025-26370": {"epss_score": 0.00242, "epss_percentile": 0.47399}, "CVE-2025-26371": {"epss_score": 0.00304, "epss_percentile": 0.53307}, "CVE-2025-26372": {"epss_score": 0.00266, "epss_percentile": 0.49897}, "CVE-2025-26373": {"epss_score": 0.00169, "epss_percentile": 0.38615}, "CVE-2025-26374": {"epss_score": 0.00119, "epss_percentile": 0.31555}, "CVE-2025-26375": {"epss_score": 0.00304, "epss_percentile": 0.53307}, "CVE-2025-26376": {"epss_score": 0.00158, "epss_percentile": 0.37211}, "CVE-2025-26377": {"epss_score": 0.00266, "epss_percentile": 0.49897}, "CVE-2025-26378": {"epss_score": 0.00304, "epss_percentile": 0.53307}, "CVE-2025-26379": {"epss_score": 0.00024, "epss_percentile": 0.05908}, "CVE-2025-26381": {"epss_score": 0.00064, "epss_percentile": 0.20322}, "CVE-2025-26382": {"epss_score": 0.00088, "epss_percentile": 0.2567}, "CVE-2025-26383": {"epss_score": 0.00027, "epss_percentile": 0.06826}, "CVE-2025-26389": {"epss_score": 0.00414, "epss_percentile": 0.61106}, "CVE-2025-26390": {"epss_score": 0.00141, "epss_percentile": 0.34939}, "CVE-2025-26391": {"epss_score": 0.00091, "epss_percentile": 0.26236}, "CVE-2025-26392": {"epss_score": 0.00125, "epss_percentile": 0.32584}, "CVE-2025-26393": {"epss_score": 0.00264, "epss_percentile": 0.49684}, "CVE-2025-26394": {"epss_score": 0.00019, "epss_percentile": 0.04064}, "CVE-2025-26395": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-26396": {"epss_score": 0.00015, "epss_percentile": 0.026}, "CVE-2025-26397": {"epss_score": 0.00065, "epss_percentile": 0.2054}, "CVE-2025-26398": {"epss_score": 6e-05, "epss_percentile": 0.0031}, "CVE-2025-26399": {"epss_score": 0.13075, "epss_percentile": 0.93866}, "CVE-2025-26400": {"epss_score": 8e-05, "epss_percentile": 0.00503}, "CVE-2025-26401": {"epss_score": 0.00024, "epss_percentile": 0.05663}, "CVE-2025-26402": {"epss_score": 0.00022, "epss_percentile": 0.05004}, "CVE-2025-26403": {"epss_score": 0.0001, "epss_percentile": 0.00862}, "CVE-2025-26404": {"epss_score": 0.00012, "epss_percentile": 0.01188}, "CVE-2025-26405": {"epss_score": 0.00015, "epss_percentile": 0.02408}, "CVE-2025-26408": {"epss_score": 0.00057, "epss_percentile": 0.17982}, "CVE-2025-26409": {"epss_score": 0.0007, "epss_percentile": 0.21802}, "CVE-2025-26410": {"epss_score": 0.00218, "epss_percentile": 0.44429}, "CVE-2025-26411": {"epss_score": 0.00228, "epss_percentile": 0.45517}, "CVE-2025-26412": {"epss_score": 0.00031, "epss_percentile": 0.08566}, "CVE-2025-26413": {"epss_score": 0.00381, "epss_percentile": 0.59012}, "CVE-2025-26416": {"epss_score": 0.00143, "epss_percentile": 0.35199}, "CVE-2025-26417": {"epss_score": 0.00021, "epss_percentile": 0.04738}, "CVE-2025-26419": {"epss_score": 9e-05, "epss_percentile": 0.00622}, "CVE-2025-26420": {"epss_score": 5e-05, "epss_percentile": 0.00198}, "CVE-2025-26421": {"epss_score": 8e-05, "epss_percentile": 0.00539}, "CVE-2025-26422": {"epss_score": 6e-05, "epss_percentile": 0.00266}, "CVE-2025-26423": {"epss_score": 7e-05, "epss_percentile": 0.00379}, "CVE-2025-26424": {"epss_score": 6e-05, "epss_percentile": 0.00253}, "CVE-2025-26425": {"epss_score": 6e-05, "epss_percentile": 0.00253}, "CVE-2025-26426": {"epss_score": 0.00016, "epss_percentile": 0.02725}, "CVE-2025-26427": {"epss_score": 5e-05, "epss_percentile": 0.00194}, "CVE-2025-26428": {"epss_score": 6e-05, "epss_percentile": 0.00247}, "CVE-2025-26429": {"epss_score": 0.0001, "epss_percentile": 0.00771}, "CVE-2025-26430": {"epss_score": 6e-05, "epss_percentile": 0.00271}, "CVE-2025-26431": {"epss_score": 0.00013, "epss_percentile": 0.01437}, "CVE-2025-26432": {"epss_score": 9e-05, "epss_percentile": 0.00596}, "CVE-2025-26434": {"epss_score": 8e-05, "epss_percentile": 0.00541}, "CVE-2025-26435": {"epss_score": 6e-05, "epss_percentile": 0.00271}, "CVE-2025-26436": {"epss_score": 8e-05, "epss_percentile": 0.00527}, "CVE-2025-26437": {"epss_score": 5e-05, "epss_percentile": 0.00208}, "CVE-2025-26438": {"epss_score": 0.00123, "epss_percentile": 0.32306}, "CVE-2025-26439": {"epss_score": 0.00013, "epss_percentile": 0.01437}, "CVE-2025-26440": {"epss_score": 7e-05, "epss_percentile": 0.00461}, "CVE-2025-26441": {"epss_score": 0.00063, "epss_percentile": 0.20049}, "CVE-2025-26442": {"epss_score": 5e-05, "epss_percentile": 0.00203}, "CVE-2025-26443": {"epss_score": 6e-05, "epss_percentile": 0.00292}, "CVE-2025-26444": {"epss_score": 8e-05, "epss_percentile": 0.00547}, "CVE-2025-26445": {"epss_score": 5e-05, "epss_percentile": 0.00208}, "CVE-2025-26448": {"epss_score": 5e-05, "epss_percentile": 0.00231}, "CVE-2025-26449": {"epss_score": 9e-05, "epss_percentile": 0.00596}, "CVE-2025-26450": {"epss_score": 6e-05, "epss_percentile": 0.00284}, "CVE-2025-26452": {"epss_score": 6e-05, "epss_percentile": 0.00284}, "CVE-2025-26453": {"epss_score": 5e-05, "epss_percentile": 0.00227}, "CVE-2025-26454": {"epss_score": 0.00012, "epss_percentile": 0.01295}, "CVE-2025-26455": {"epss_score": 6e-05, "epss_percentile": 0.00312}, "CVE-2025-26456": {"epss_score": 0.0002, "epss_percentile": 0.04543}, "CVE-2025-26458": {"epss_score": 8e-05, "epss_percentile": 0.00547}, "CVE-2025-26461": {"epss_score": 8e-05, "epss_percentile": 0.00492}, "CVE-2025-26462": {"epss_score": 6e-05, "epss_percentile": 0.00271}, "CVE-2025-26463": {"epss_score": 9e-05, "epss_percentile": 0.00596}, "CVE-2025-26464": {"epss_score": 0.00013, "epss_percentile": 0.01437}, "CVE-2025-26465": {"epss_score": 0.67323, "epss_percentile": 0.98501}, "CVE-2025-26466": {"epss_score": 0.42081, "epss_percentile": 0.97312}, "CVE-2025-26467": {"epss_score": 0.00054, "epss_percentile": 0.17305}, "CVE-2025-26468": {"epss_score": 0.00076, "epss_percentile": 0.23078}, "CVE-2025-26469": {"epss_score": 0.00067, "epss_percentile": 0.21081}, "CVE-2025-26470": {"epss_score": 0.00011, "epss_percentile": 0.00924}, "CVE-2025-26472": {"epss_score": 0.00028, "epss_percentile": 0.07568}, "CVE-2025-26473": {"epss_score": 0.00119, "epss_percentile": 0.31653}, "CVE-2025-26475": {"epss_score": 0.00063, "epss_percentile": 0.19828}, "CVE-2025-26476": {"epss_score": 0.00048, "epss_percentile": 0.15048}, "CVE-2025-26477": {"epss_score": 0.00222, "epss_percentile": 0.44809}, "CVE-2025-26478": {"epss_score": 0.00027, "epss_percentile": 0.06838}, "CVE-2025-26479": {"epss_score": 0.00056, "epss_percentile": 0.17952}, "CVE-2025-26480": {"epss_score": 0.00113, "epss_percentile": 0.30613}, "CVE-2025-26481": {"epss_score": 0.00108, "epss_percentile": 0.29837}, "CVE-2025-26482": {"epss_score": 0.00042, "epss_percentile": 0.12828}, "CVE-2025-26484": {"epss_score": 0.00124, "epss_percentile": 0.32436}, "CVE-2025-26485": {"epss_score": 0.00112, "epss_percentile": 0.30516}, "CVE-2025-26486": {"epss_score": 0.00021, "epss_percentile": 0.0471}, "CVE-2025-26487": {"epss_score": 0.00044, "epss_percentile": 0.13497}, "CVE-2025-26488": {"epss_score": 0.0007, "epss_percentile": 0.21681}, "CVE-2025-26489": {"epss_score": 0.00115, "epss_percentile": 0.30929}, "CVE-2025-26492": {"epss_score": 5e-05, "epss_percentile": 0.00197}, "CVE-2025-26493": {"epss_score": 0.4585, "epss_percentile": 0.97505}, "CVE-2025-26494": {"epss_score": 0.00095, "epss_percentile": 0.2711}, "CVE-2025-26495": {"epss_score": 0.00071, "epss_percentile": 0.22186}, "CVE-2025-26496": {"epss_score": 0.00025, "epss_percentile": 0.0625}, "CVE-2025-26497": {"epss_score": 0.00076, "epss_percentile": 0.23101}, "CVE-2025-26498": {"epss_score": 0.00076, "epss_percentile": 0.23101}, "CVE-2025-26499": {"epss_score": 0.00021, "epss_percentile": 0.04816}, "CVE-2025-26500": {"epss_score": 0.00053, "epss_percentile": 0.16995}, "CVE-2025-26503": {"epss_score": 0.00021, "epss_percentile": 0.04799}, "CVE-2025-26506": {"epss_score": 0.00553, "epss_percentile": 0.67409}, "CVE-2025-26507": {"epss_score": 0.00511, "epss_percentile": 0.65837}, "CVE-2025-26508": {"epss_score": 0.00544, "epss_percentile": 0.67136}, "CVE-2025-26511": {"epss_score": 0.00066, "epss_percentile": 0.20766}, "CVE-2025-26512": {"epss_score": 0.00114, "epss_percentile": 0.30832}, "CVE-2025-26513": {"epss_score": 0.00017, "epss_percentile": 0.03224}, "CVE-2025-26514": {"epss_score": 0.00047, "epss_percentile": 0.14756}, "CVE-2025-26515": {"epss_score": 0.00044, "epss_percentile": 0.13551}, "CVE-2025-26516": {"epss_score": 0.00075, "epss_percentile": 0.22966}, "CVE-2025-26517": {"epss_score": 0.0004, "epss_percentile": 0.11882}, "CVE-2025-26519": {"epss_score": 0.00022, "epss_percentile": 0.05169}, "CVE-2025-26520": {"epss_score": 0.00122, "epss_percentile": 0.32018}, "CVE-2025-26521": {"epss_score": 0.00069, "epss_percentile": 0.21513}, "CVE-2025-26522": {"epss_score": 0.00236, "epss_percentile": 0.46391}, "CVE-2025-26523": {"epss_score": 0.00164, "epss_percentile": 0.37955}, "CVE-2025-26524": {"epss_score": 0.00096, "epss_percentile": 0.27319}, "CVE-2025-26525": {"epss_score": 0.00224, "epss_percentile": 0.45012}, "CVE-2025-26526": {"epss_score": 0.00159, "epss_percentile": 0.37356}, "CVE-2025-26527": {"epss_score": 0.00159, "epss_percentile": 0.37422}, "CVE-2025-26528": {"epss_score": 0.00239, "epss_percentile": 0.4693}, "CVE-2025-26529": {"epss_score": 0.00117, "epss_percentile": 0.31382}, "CVE-2025-26530": {"epss_score": 0.00369, "epss_percentile": 0.58228}, "CVE-2025-26531": {"epss_score": 0.00125, "epss_percentile": 0.32514}, "CVE-2025-26532": {"epss_score": 0.00103, "epss_percentile": 0.29001}, "CVE-2025-26533": {"epss_score": 0.00342, "epss_percentile": 0.56393}, "CVE-2025-26534": {"epss_score": 0.00188, "epss_percentile": 0.40835}, "CVE-2025-26535": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-26536": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-26537": {"epss_score": 0.00059, "epss_percentile": 0.18812}, "CVE-2025-26538": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26539": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26540": {"epss_score": 0.00183, "epss_percentile": 0.40286}, "CVE-2025-26541": {"epss_score": 0.00074, "epss_percentile": 0.22699}, "CVE-2025-26542": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-26543": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26544": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-26545": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26546": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-26547": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26548": {"epss_score": 0.0008, "epss_percentile": 0.24068}, "CVE-2025-26549": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26550": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26551": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26552": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26553": {"epss_score": 0.0008, "epss_percentile": 0.24068}, "CVE-2025-26554": {"epss_score": 0.0008, "epss_percentile": 0.24068}, "CVE-2025-26555": {"epss_score": 0.0008, "epss_percentile": 0.24068}, "CVE-2025-26556": {"epss_score": 0.0008, "epss_percentile": 0.24068}, "CVE-2025-26557": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26558": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26559": {"epss_score": 0.00059, "epss_percentile": 0.18812}, "CVE-2025-26560": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-26561": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-26562": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26563": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26564": {"epss_score": 0.00074, "epss_percentile": 0.22699}, "CVE-2025-26565": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-26566": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-26567": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26568": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26569": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26570": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26571": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26572": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26573": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-26574": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26575": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-26576": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-26577": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26578": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26579": {"epss_score": 0.00074, "epss_percentile": 0.22699}, "CVE-2025-26580": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26581": {"epss_score": 0.00074, "epss_percentile": 0.22699}, "CVE-2025-26582": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26583": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-26584": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-26585": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26586": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26587": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26588": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26589": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26590": {"epss_score": 0.00036, "epss_percentile": 0.1031}, "CVE-2025-26591": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-26592": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-26593": {"epss_score": 0.00017, "epss_percentile": 0.03358}, "CVE-2025-26594": {"epss_score": 0.00052, "epss_percentile": 0.16505}, "CVE-2025-26595": {"epss_score": 0.00052, "epss_percentile": 0.16505}, "CVE-2025-26596": {"epss_score": 0.00052, "epss_percentile": 0.16505}, "CVE-2025-26597": {"epss_score": 0.00052, "epss_percentile": 0.16505}, "CVE-2025-26598": {"epss_score": 0.00058, "epss_percentile": 0.18578}, "CVE-2025-26599": {"epss_score": 0.00052, "epss_percentile": 0.16505}, "CVE-2025-26600": {"epss_score": 0.00052, "epss_percentile": 0.16505}, "CVE-2025-26601": {"epss_score": 0.00052, "epss_percentile": 0.16505}, "CVE-2025-26603": {"epss_score": 0.00047, "epss_percentile": 0.14671}, "CVE-2025-26604": {"epss_score": 0.00175, "epss_percentile": 0.39277}, "CVE-2025-26605": {"epss_score": 0.00411, "epss_percentile": 0.60855}, "CVE-2025-26606": {"epss_score": 0.00447, "epss_percentile": 0.62975}, "CVE-2025-26607": {"epss_score": 0.00447, "epss_percentile": 0.62975}, "CVE-2025-26608": {"epss_score": 0.00447, "epss_percentile": 0.62975}, "CVE-2025-26609": {"epss_score": 0.00447, "epss_percentile": 0.62975}, "CVE-2025-26610": {"epss_score": 0.00411, "epss_percentile": 0.60855}, "CVE-2025-26611": {"epss_score": 0.00447, "epss_percentile": 0.62975}, "CVE-2025-26612": {"epss_score": 0.00484, "epss_percentile": 0.6465}, "CVE-2025-26613": {"epss_score": 0.0398, "epss_percentile": 0.88058}, "CVE-2025-26614": {"epss_score": 0.00411, "epss_percentile": 0.60855}, "CVE-2025-26615": {"epss_score": 0.00236, "epss_percentile": 0.46381}, "CVE-2025-26616": {"epss_score": 0.00311, "epss_percentile": 0.53843}, "CVE-2025-26617": {"epss_score": 0.00447, "epss_percentile": 0.62975}, "CVE-2025-26618": {"epss_score": 0.00269, "epss_percentile": 0.50174}, "CVE-2025-26619": {"epss_score": 0.0008, "epss_percentile": 0.24028}, "CVE-2025-26620": {"epss_score": 0.00197, "epss_percentile": 0.4187}, "CVE-2025-26621": {"epss_score": 0.00156, "epss_percentile": 0.36887}, "CVE-2025-26622": {"epss_score": 0.00116, "epss_percentile": 0.31042}, "CVE-2025-26623": {"epss_score": 0.01029, "epss_percentile": 0.76831}, "CVE-2025-26624": {"epss_score": 0.00046, "epss_percentile": 0.14416}, "CVE-2025-26625": {"epss_score": 0.00029, "epss_percentile": 0.07615}, "CVE-2025-26626": {"epss_score": 0.00107, "epss_percentile": 0.29659}, "CVE-2025-26627": {"epss_score": 0.00146, "epss_percentile": 0.35634}, "CVE-2025-26628": {"epss_score": 0.00271, "epss_percentile": 0.50297}, "CVE-2025-26629": {"epss_score": 0.00282, "epss_percentile": 0.51285}, "CVE-2025-26630": {"epss_score": 0.00282, "epss_percentile": 0.51285}, "CVE-2025-26631": {"epss_score": 0.00792, "epss_percentile": 0.73413}, "CVE-2025-26633": {"epss_score": 0.10107, "epss_percentile": 0.92853}, "CVE-2025-26634": {"epss_score": 0.00391, "epss_percentile": 0.59579}, "CVE-2025-26635": {"epss_score": 0.00276, "epss_percentile": 0.5072}, "CVE-2025-26636": {"epss_score": 0.00048, "epss_percentile": 0.15005}, "CVE-2025-26637": {"epss_score": 0.00424, "epss_percentile": 0.61639}, "CVE-2025-26639": {"epss_score": 0.00399, "epss_percentile": 0.60132}, "CVE-2025-26640": {"epss_score": 0.00097, "epss_percentile": 0.27515}, "CVE-2025-26641": {"epss_score": 0.26764, "epss_percentile": 0.96176}, "CVE-2025-26642": {"epss_score": 0.00264, "epss_percentile": 0.49551}, "CVE-2025-26643": {"epss_score": 0.00271, "epss_percentile": 0.50317}, "CVE-2025-26644": {"epss_score": 0.0013, "epss_percentile": 0.33302}, "CVE-2025-26645": {"epss_score": 0.00321, "epss_percentile": 0.54696}, "CVE-2025-26646": {"epss_score": 0.00045, "epss_percentile": 0.13832}, "CVE-2025-26647": {"epss_score": 0.01081, "epss_percentile": 0.77374}, "CVE-2025-26648": {"epss_score": 0.00225, "epss_percentile": 0.45144}, "CVE-2025-26649": {"epss_score": 0.00086, "epss_percentile": 0.2533}, "CVE-2025-26651": {"epss_score": 0.29118, "epss_percentile": 0.96419}, "CVE-2025-26652": {"epss_score": 0.26764, "epss_percentile": 0.96176}, "CVE-2025-26653": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-26654": {"epss_score": 0.00015, "epss_percentile": 0.0243}, "CVE-2025-26655": {"epss_score": 0.00063, "epss_percentile": 0.19878}, "CVE-2025-26656": {"epss_score": 0.00083, "epss_percentile": 0.2481}, "CVE-2025-26657": {"epss_score": 0.00104, "epss_percentile": 0.29167}, "CVE-2025-26658": {"epss_score": 0.00084, "epss_percentile": 0.2497}, "CVE-2025-26659": {"epss_score": 0.00071, "epss_percentile": 0.22201}, "CVE-2025-26660": {"epss_score": 0.00105, "epss_percentile": 0.29375}, "CVE-2025-26661": {"epss_score": 0.00162, "epss_percentile": 0.37712}, "CVE-2025-26662": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-26663": {"epss_score": 0.00242, "epss_percentile": 0.47349}, "CVE-2025-26664": {"epss_score": 0.00556, "epss_percentile": 0.67512}, "CVE-2025-26665": {"epss_score": 0.00102, "epss_percentile": 0.28771}, "CVE-2025-26666": {"epss_score": 0.00333, "epss_percentile": 0.55648}, "CVE-2025-26667": {"epss_score": 0.01022, "epss_percentile": 0.76755}, "CVE-2025-26668": {"epss_score": 0.0012, "epss_percentile": 0.31727}, "CVE-2025-26669": {"epss_score": 0.00357, "epss_percentile": 0.57468}, "CVE-2025-26670": {"epss_score": 0.00249, "epss_percentile": 0.48087}, "CVE-2025-26671": {"epss_score": 0.00187, "epss_percentile": 0.4076}, "CVE-2025-26672": {"epss_score": 0.00556, "epss_percentile": 0.67512}, "CVE-2025-26673": {"epss_score": 0.28265, "epss_percentile": 0.96338}, "CVE-2025-26674": {"epss_score": 0.00333, "epss_percentile": 0.55648}, "CVE-2025-26675": {"epss_score": 0.00291, "epss_percentile": 0.52173}, "CVE-2025-26676": {"epss_score": 0.00556, "epss_percentile": 0.67512}, "CVE-2025-26677": {"epss_score": 0.06198, "epss_percentile": 0.90557}, "CVE-2025-26678": {"epss_score": 0.00266, "epss_percentile": 0.49912}, "CVE-2025-26679": {"epss_score": 0.00291, "epss_percentile": 0.52173}, "CVE-2025-26680": {"epss_score": 0.26764, "epss_percentile": 0.96176}, "CVE-2025-26681": {"epss_score": 0.0012, "epss_percentile": 0.31693}, "CVE-2025-26682": {"epss_score": 0.30854, "epss_percentile": 0.96572}, "CVE-2025-26683": {"epss_score": 0.00239, "epss_percentile": 0.46875}, "CVE-2025-26684": {"epss_score": 0.00226, "epss_percentile": 0.453}, "CVE-2025-26685": {"epss_score": 0.00122, "epss_percentile": 0.32138}, "CVE-2025-26686": {"epss_score": 0.00137, "epss_percentile": 0.34241}, "CVE-2025-26687": {"epss_score": 0.0012, "epss_percentile": 0.31727}, "CVE-2025-26688": {"epss_score": 0.00291, "epss_percentile": 0.52173}, "CVE-2025-26689": {"epss_score": 0.00301, "epss_percentile": 0.53008}, "CVE-2025-26690": {"epss_score": 0.00016, "epss_percentile": 0.0262}, "CVE-2025-26691": {"epss_score": 0.00015, "epss_percentile": 0.02583}, "CVE-2025-26692": {"epss_score": 0.00202, "epss_percentile": 0.42435}, "CVE-2025-26693": {"epss_score": 0.00015, "epss_percentile": 0.02224}, "CVE-2025-26694": {"epss_score": 0.00017, "epss_percentile": 0.03092}, "CVE-2025-26695": {"epss_score": 0.00041, "epss_percentile": 0.12388}, "CVE-2025-26696": {"epss_score": 0.00182, "epss_percentile": 0.40236}, "CVE-2025-26697": {"epss_score": 0.00028, "epss_percentile": 0.07575}, "CVE-2025-26698": {"epss_score": 0.0003, "epss_percentile": 0.08188}, "CVE-2025-26699": {"epss_score": 0.01596, "epss_percentile": 0.81241}, "CVE-2025-26700": {"epss_score": 0.00054, "epss_percentile": 0.17181}, "CVE-2025-26701": {"epss_score": 0.00148, "epss_percentile": 0.35881}, "CVE-2025-26702": {"epss_score": 0.00157, "epss_percentile": 0.37098}, "CVE-2025-26703": {"epss_score": 0.00084, "epss_percentile": 0.24873}, "CVE-2025-26704": {"epss_score": 0.00088, "epss_percentile": 0.25691}, "CVE-2025-26705": {"epss_score": 0.00117, "epss_percentile": 0.31226}, "CVE-2025-26706": {"epss_score": 0.00093, "epss_percentile": 0.26624}, "CVE-2025-26707": {"epss_score": 0.00098, "epss_percentile": 0.27792}, "CVE-2025-26708": {"epss_score": 0.00019, "epss_percentile": 0.0417}, "CVE-2025-26709": {"epss_score": 0.00043, "epss_percentile": 0.13283}, "CVE-2025-26710": {"epss_score": 0.00041, "epss_percentile": 0.1233}, "CVE-2025-26711": {"epss_score": 0.00055, "epss_percentile": 0.17407}, "CVE-2025-26730": {"epss_score": 0.0007, "epss_percentile": 0.21748}, "CVE-2025-26731": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-26732": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-26733": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-26734": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-26735": {"epss_score": 0.00121, "epss_percentile": 0.31956}, "CVE-2025-26736": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-26737": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-26738": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-26739": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-26740": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26741": {"epss_score": 0.00081, "epss_percentile": 0.24255}, "CVE-2025-26742": {"epss_score": 0.00057, "epss_percentile": 0.18085}, "CVE-2025-26743": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-26744": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26745": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26746": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-26747": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-26748": {"epss_score": 0.00025, "epss_percentile": 0.0631}, "CVE-2025-26749": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26750": {"epss_score": 0.00114, "epss_percentile": 0.30739}, "CVE-2025-26751": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26752": {"epss_score": 0.00188, "epss_percentile": 0.40835}, "CVE-2025-26753": {"epss_score": 0.00252, "epss_percentile": 0.48369}, "CVE-2025-26754": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26755": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-26756": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26757": {"epss_score": 0.00236, "epss_percentile": 0.46389}, "CVE-2025-26758": {"epss_score": 0.00131, "epss_percentile": 0.3339}, "CVE-2025-26759": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26760": {"epss_score": 0.00236, "epss_percentile": 0.46389}, "CVE-2025-26761": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26762": {"epss_score": 0.0006, "epss_percentile": 0.19147}, "CVE-2025-26763": {"epss_score": 0.00197, "epss_percentile": 0.41954}, "CVE-2025-26764": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2025-26765": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-26766": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26767": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-26768": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26769": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26770": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26771": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-26772": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-26773": {"epss_score": 0.00119, "epss_percentile": 0.31577}, "CVE-2025-26774": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26775": {"epss_score": 0.0008, "epss_percentile": 0.24146}, "CVE-2025-26776": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2025-26778": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-26779": {"epss_score": 0.00259, "epss_percentile": 0.49038}, "CVE-2025-26780": {"epss_score": 0.00125, "epss_percentile": 0.3254}, "CVE-2025-26781": {"epss_score": 0.00099, "epss_percentile": 0.28319}, "CVE-2025-26782": {"epss_score": 0.00065, "epss_percentile": 0.20623}, "CVE-2025-26783": {"epss_score": 0.00113, "epss_percentile": 0.30602}, "CVE-2025-26784": {"epss_score": 0.00042, "epss_percentile": 0.12614}, "CVE-2025-26785": {"epss_score": 0.00064, "epss_percentile": 0.20382}, "CVE-2025-26787": {"epss_score": 0.00033, "epss_percentile": 0.09248}, "CVE-2025-26788": {"epss_score": 0.0004, "epss_percentile": 0.11974}, "CVE-2025-26789": {"epss_score": 0.00233, "epss_percentile": 0.4598}, "CVE-2025-26791": {"epss_score": 0.00051, "epss_percentile": 0.16014}, "CVE-2025-26793": {"epss_score": 0.10326, "epss_percentile": 0.92946}, "CVE-2025-26794": {"epss_score": 0.72088, "epss_percentile": 0.98695}, "CVE-2025-26795": {"epss_score": 0.00102, "epss_percentile": 0.28718}, "CVE-2025-26796": {"epss_score": 0.00378, "epss_percentile": 0.58776}, "CVE-2025-26803": {"epss_score": 0.00605, "epss_percentile": 0.68991}, "CVE-2025-26816": {"epss_score": 0.00091, "epss_percentile": 0.26261}, "CVE-2025-26817": {"epss_score": 0.00624, "epss_percentile": 0.69557}, "CVE-2025-26818": {"epss_score": 0.00525, "epss_percentile": 0.66377}, "CVE-2025-26819": {"epss_score": 0.00293, "epss_percentile": 0.52354}, "CVE-2025-26841": {"epss_score": 0.00034, "epss_percentile": 0.09788}, "CVE-2025-26842": {"epss_score": 0.00048, "epss_percentile": 0.15281}, "CVE-2025-26844": {"epss_score": 0.00067, "epss_percentile": 0.21155}, "CVE-2025-26845": {"epss_score": 0.00062, "epss_percentile": 0.19664}, "CVE-2025-26846": {"epss_score": 0.00074, "epss_percentile": 0.22849}, "CVE-2025-26847": {"epss_score": 0.0005, "epss_percentile": 0.15725}, "CVE-2025-26849": {"epss_score": 0.00044, "epss_percentile": 0.13471}, "CVE-2025-26850": {"epss_score": 0.00018, "epss_percentile": 0.03839}, "CVE-2025-26852": {"epss_score": 0.00141, "epss_percentile": 0.34832}, "CVE-2025-26853": {"epss_score": 0.0024, "epss_percentile": 0.47208}, "CVE-2025-26854": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-26855": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-26856": {"epss_score": 0.00956, "epss_percentile": 0.75921}, "CVE-2025-26857": {"epss_score": 0.00089, "epss_percentile": 0.25956}, "CVE-2025-26858": {"epss_score": 0.00106, "epss_percentile": 0.29534}, "CVE-2025-26859": {"epss_score": 0.00021, "epss_percentile": 0.04843}, "CVE-2025-26860": {"epss_score": 0.00021, "epss_percentile": 0.04843}, "CVE-2025-26861": {"epss_score": 0.00021, "epss_percentile": 0.04843}, "CVE-2025-26862": {"epss_score": 0.00089, "epss_percentile": 0.25889}, "CVE-2025-26863": {"epss_score": 0.00021, "epss_percentile": 0.04825}, "CVE-2025-26864": {"epss_score": 0.00102, "epss_percentile": 0.28718}, "CVE-2025-26865": {"epss_score": 0.00557, "epss_percentile": 0.67555}, "CVE-2025-26866": {"epss_score": 0.0117, "epss_percentile": 0.78209}, "CVE-2025-26867": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-26868": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26869": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-26870": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26871": {"epss_score": 0.00125, "epss_percentile": 0.32484}, "CVE-2025-26872": {"epss_score": 0.00065, "epss_percentile": 0.20582}, "CVE-2025-26873": {"epss_score": 0.00104, "epss_percentile": 0.29146}, "CVE-2025-26874": {"epss_score": 0.00046, "epss_percentile": 0.14074}, "CVE-2025-26875": {"epss_score": 0.00107, "epss_percentile": 0.29681}, "CVE-2025-26876": {"epss_score": 0.00193, "epss_percentile": 0.41385}, "CVE-2025-26877": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-26878": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26879": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26880": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26881": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26882": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26883": {"epss_score": 0.00114, "epss_percentile": 0.30739}, "CVE-2025-26884": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-26885": {"epss_score": 0.0022, "epss_percentile": 0.44598}, "CVE-2025-26886": {"epss_score": 0.00101, "epss_percentile": 0.28692}, "CVE-2025-26887": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26888": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-26889": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-26890": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-26891": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26892": {"epss_score": 0.00074, "epss_percentile": 0.22878}, "CVE-2025-26893": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26894": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-26895": {"epss_score": 0.00078, "epss_percentile": 0.23587}, "CVE-2025-26896": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26897": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26898": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-26899": {"epss_score": 0.00068, "epss_percentile": 0.2131}, "CVE-2025-26900": {"epss_score": 0.00197, "epss_percentile": 0.41954}, "CVE-2025-26901": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2025-26902": {"epss_score": 0.00027, "epss_percentile": 0.06845}, "CVE-2025-26903": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-26904": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26905": {"epss_score": 0.00261, "epss_percentile": 0.49263}, "CVE-2025-26906": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26907": {"epss_score": 0.00176, "epss_percentile": 0.39376}, "CVE-2025-26908": {"epss_score": 0.00049, "epss_percentile": 0.15291}, "CVE-2025-26909": {"epss_score": 0.00069, "epss_percentile": 0.21445}, "CVE-2025-26910": {"epss_score": 0.00046, "epss_percentile": 0.14294}, "CVE-2025-26911": {"epss_score": 0.00119, "epss_percentile": 0.31576}, "CVE-2025-26912": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26913": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26914": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26915": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-26916": {"epss_score": 0.00279, "epss_percentile": 0.50987}, "CVE-2025-26917": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-26918": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-26919": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26920": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2025-26921": {"epss_score": 0.00189, "epss_percentile": 0.40994}, "CVE-2025-26922": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-26923": {"epss_score": 0.00059, "epss_percentile": 0.18812}, "CVE-2025-26924": {"epss_score": 0.00086, "epss_percentile": 0.25338}, "CVE-2025-26925": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-26926": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-26927": {"epss_score": 0.00094, "epss_percentile": 0.27045}, "CVE-2025-26928": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2025-26929": {"epss_score": 0.0006, "epss_percentile": 0.19147}, "CVE-2025-26930": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26931": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-26932": {"epss_score": 0.00242, "epss_percentile": 0.47349}, "CVE-2025-26933": {"epss_score": 0.00236, "epss_percentile": 0.46389}, "CVE-2025-26934": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26935": {"epss_score": 0.00134, "epss_percentile": 0.33828}, "CVE-2025-26936": {"epss_score": 0.0024, "epss_percentile": 0.46954}, "CVE-2025-26937": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26938": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26939": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26940": {"epss_score": 0.00098, "epss_percentile": 0.27668}, "CVE-2025-26941": {"epss_score": 0.00079, "epss_percentile": 0.23978}, "CVE-2025-26942": {"epss_score": 0.00067, "epss_percentile": 0.21143}, "CVE-2025-26943": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-26944": {"epss_score": 0.00067, "epss_percentile": 0.21143}, "CVE-2025-26945": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26946": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-26947": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26948": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2025-26949": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26950": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26951": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26952": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26953": {"epss_score": 0.00067, "epss_percentile": 0.21143}, "CVE-2025-26954": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-26955": {"epss_score": 0.00069, "epss_percentile": 0.21585}, "CVE-2025-26956": {"epss_score": 0.0007, "epss_percentile": 0.2181}, "CVE-2025-26957": {"epss_score": 0.00242, "epss_percentile": 0.47349}, "CVE-2025-26958": {"epss_score": 0.00067, "epss_percentile": 0.21143}, "CVE-2025-26959": {"epss_score": 0.00081, "epss_percentile": 0.24255}, "CVE-2025-26960": {"epss_score": 0.0015, "epss_percentile": 0.36065}, "CVE-2025-26961": {"epss_score": 0.00109, "epss_percentile": 0.29992}, "CVE-2025-26962": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26963": {"epss_score": 0.00058, "epss_percentile": 0.18265}, "CVE-2025-26964": {"epss_score": 0.00273, "epss_percentile": 0.5044}, "CVE-2025-26965": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-26966": {"epss_score": 0.00258, "epss_percentile": 0.48973}, "CVE-2025-26967": {"epss_score": 0.00226, "epss_percentile": 0.45354}, "CVE-2025-26968": {"epss_score": 0.00057, "epss_percentile": 0.17999}, "CVE-2025-26969": {"epss_score": 0.00109, "epss_percentile": 0.30035}, "CVE-2025-26970": {"epss_score": 0.0024, "epss_percentile": 0.46954}, "CVE-2025-26971": {"epss_score": 0.00117, "epss_percentile": 0.3121}, "CVE-2025-26972": {"epss_score": 0.0008, "epss_percentile": 0.24068}, "CVE-2025-26973": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26974": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-26975": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-26976": {"epss_score": 0.00104, "epss_percentile": 0.29199}, "CVE-2025-26977": {"epss_score": 0.0013, "epss_percentile": 0.3327}, "CVE-2025-26978": {"epss_score": 0.0008, "epss_percentile": 0.24181}, "CVE-2025-26979": {"epss_score": 0.00236, "epss_percentile": 0.46389}, "CVE-2025-26980": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-26981": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26982": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-26983": {"epss_score": 0.0009, "epss_percentile": 0.26073}, "CVE-2025-26984": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-26985": {"epss_score": 0.00248, "epss_percentile": 0.47982}, "CVE-2025-26986": {"epss_score": 0.00192, "epss_percentile": 0.41296}, "CVE-2025-26987": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-26988": {"epss_score": 0.00115, "epss_percentile": 0.31034}, "CVE-2025-26989": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-26990": {"epss_score": 0.0004, "epss_percentile": 0.11943}, "CVE-2025-26991": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26992": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-26993": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-26994": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-26995": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-26996": {"epss_score": 0.00051, "epss_percentile": 0.16138}, "CVE-2025-26997": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-26998": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-26999": {"epss_score": 0.00226, "epss_percentile": 0.45354}, "CVE-2025-27000": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-27001": {"epss_score": 0.00077, "epss_percentile": 0.23462}, "CVE-2025-27002": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-27003": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-27004": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-27006": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-27007": {"epss_score": 0.74426, "epss_percentile": 0.98799}, "CVE-2025-27008": {"epss_score": 0.00067, "epss_percentile": 0.21143}, "CVE-2025-27009": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-27010": {"epss_score": 0.00041, "epss_percentile": 0.12301}, "CVE-2025-27011": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-27012": {"epss_score": 0.00058, "epss_percentile": 0.18262}, "CVE-2025-27013": {"epss_score": 0.00116, "epss_percentile": 0.31088}, "CVE-2025-27014": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-27015": {"epss_score": 0.00172, "epss_percentile": 0.39026}, "CVE-2025-27016": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27017": {"epss_score": 0.00108, "epss_percentile": 0.29812}, "CVE-2025-27018": {"epss_score": 0.00316, "epss_percentile": 0.54285}, "CVE-2025-27019": {"epss_score": 0.00054, "epss_percentile": 0.17357}, "CVE-2025-27020": {"epss_score": 0.00117, "epss_percentile": 0.31296}, "CVE-2025-27021": {"epss_score": 0.00015, "epss_percentile": 0.02609}, "CVE-2025-27022": {"epss_score": 0.00065, "epss_percentile": 0.20455}, "CVE-2025-27023": {"epss_score": 0.00103, "epss_percentile": 0.29079}, "CVE-2025-27024": {"epss_score": 0.00052, "epss_percentile": 0.16447}, "CVE-2025-27025": {"epss_score": 0.00497, "epss_percentile": 0.6521}, "CVE-2025-27026": {"epss_score": 0.00048, "epss_percentile": 0.15144}, "CVE-2025-27027": {"epss_score": 0.00034, "epss_percentile": 0.09634}, "CVE-2025-27028": {"epss_score": 0.00035, "epss_percentile": 0.10012}, "CVE-2025-27029": {"epss_score": 0.00054, "epss_percentile": 0.17195}, "CVE-2025-27030": {"epss_score": 0.00015, "epss_percentile": 0.02196}, "CVE-2025-27031": {"epss_score": 0.00018, "epss_percentile": 0.03906}, "CVE-2025-27032": {"epss_score": 0.00016, "epss_percentile": 0.02643}, "CVE-2025-27033": {"epss_score": 0.00015, "epss_percentile": 0.02196}, "CVE-2025-27034": {"epss_score": 0.0005, "epss_percentile": 0.15862}, "CVE-2025-27036": {"epss_score": 0.00015, "epss_percentile": 0.02196}, "CVE-2025-27037": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-27038": {"epss_score": 0.01071, "epss_percentile": 0.77266}, "CVE-2025-27039": {"epss_score": 0.00019, "epss_percentile": 0.04174}, "CVE-2025-27040": {"epss_score": 0.00021, "epss_percentile": 0.04758}, "CVE-2025-27041": {"epss_score": 0.00017, "epss_percentile": 0.03205}, "CVE-2025-27042": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-27043": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-27044": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-27045": {"epss_score": 0.00015, "epss_percentile": 0.02553}, "CVE-2025-27046": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-27047": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-27048": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-27049": {"epss_score": 0.00017, "epss_percentile": 0.03205}, "CVE-2025-27050": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-27051": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-27052": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-27053": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-27054": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-27055": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-27056": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-27057": {"epss_score": 0.00053, "epss_percentile": 0.16724}, "CVE-2025-27058": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-27059": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-27060": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-27061": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-27062": {"epss_score": 0.00013, "epss_percentile": 0.01478}, "CVE-2025-27063": {"epss_score": 0.00017, "epss_percentile": 0.0328}, "CVE-2025-27064": {"epss_score": 0.00013, "epss_percentile": 0.01484}, "CVE-2025-27065": {"epss_score": 0.00052, "epss_percentile": 0.16391}, "CVE-2025-27066": {"epss_score": 0.00022, "epss_percentile": 0.04953}, "CVE-2025-27067": {"epss_score": 0.00014, "epss_percentile": 0.01821}, "CVE-2025-27068": {"epss_score": 0.00014, "epss_percentile": 0.01821}, "CVE-2025-27069": {"epss_score": 0.00014, "epss_percentile": 0.01821}, "CVE-2025-27070": {"epss_score": 9e-05, "epss_percentile": 0.00684}, "CVE-2025-27071": {"epss_score": 0.00039, "epss_percentile": 0.11443}, "CVE-2025-27072": {"epss_score": 0.00011, "epss_percentile": 0.00947}, "CVE-2025-27073": {"epss_score": 0.00022, "epss_percentile": 0.04953}, "CVE-2025-27074": {"epss_score": 0.00015, "epss_percentile": 0.0219}, "CVE-2025-27075": {"epss_score": 0.00014, "epss_percentile": 0.01821}, "CVE-2025-27076": {"epss_score": 8e-05, "epss_percentile": 0.0055}, "CVE-2025-27077": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-27078": {"epss_score": 0.0007, "epss_percentile": 0.21724}, "CVE-2025-27079": {"epss_score": 0.00057, "epss_percentile": 0.18134}, "CVE-2025-27080": {"epss_score": 0.00046, "epss_percentile": 0.14277}, "CVE-2025-27081": {"epss_score": 0.00036, "epss_percentile": 0.10433}, "CVE-2025-27082": {"epss_score": 0.00111, "epss_percentile": 0.30313}, "CVE-2025-27083": {"epss_score": 0.0011, "epss_percentile": 0.30194}, "CVE-2025-27084": {"epss_score": 0.00044, "epss_percentile": 0.13613}, "CVE-2025-27085": {"epss_score": 0.00075, "epss_percentile": 0.22953}, "CVE-2025-27086": {"epss_score": 0.0006, "epss_percentile": 0.18982}, "CVE-2025-27087": {"epss_score": 0.00031, "epss_percentile": 0.08565}, "CVE-2025-27088": {"epss_score": 0.00218, "epss_percentile": 0.44408}, "CVE-2025-27089": {"epss_score": 0.00092, "epss_percentile": 0.2644}, "CVE-2025-27090": {"epss_score": 0.00381, "epss_percentile": 0.59029}, "CVE-2025-27091": {"epss_score": 0.00374, "epss_percentile": 0.58559}, "CVE-2025-27092": {"epss_score": 0.00243, "epss_percentile": 0.4748}, "CVE-2025-27093": {"epss_score": 0.00041, "epss_percentile": 0.12421}, "CVE-2025-27094": {"epss_score": 0.00201, "epss_percentile": 0.42357}, "CVE-2025-27095": {"epss_score": 0.00074, "epss_percentile": 0.22693}, "CVE-2025-27096": {"epss_score": 0.00411, "epss_percentile": 0.60855}, "CVE-2025-27097": {"epss_score": 0.00243, "epss_percentile": 0.47483}, "CVE-2025-27098": {"epss_score": 0.00111, "epss_percentile": 0.30338}, "CVE-2025-27099": {"epss_score": 0.00233, "epss_percentile": 0.4604}, "CVE-2025-27100": {"epss_score": 0.00063, "epss_percentile": 0.19964}, "CVE-2025-27101": {"epss_score": 0.00428, "epss_percentile": 0.61958}, "CVE-2025-27102": {"epss_score": 0.00912, "epss_percentile": 0.75362}, "CVE-2025-27103": {"epss_score": 0.00209, "epss_percentile": 0.43367}, "CVE-2025-27104": {"epss_score": 0.0031, "epss_percentile": 0.53766}, "CVE-2025-27105": {"epss_score": 0.00301, "epss_percentile": 0.53016}, "CVE-2025-27106": {"epss_score": 0.01489, "epss_percentile": 0.8062}, "CVE-2025-27107": {"epss_score": 0.00567, "epss_percentile": 0.67858}, "CVE-2025-27108": {"epss_score": 0.00196, "epss_percentile": 0.41797}, "CVE-2025-27109": {"epss_score": 0.00156, "epss_percentile": 0.36902}, "CVE-2025-27110": {"epss_score": 0.00144, "epss_percentile": 0.35268}, "CVE-2025-27111": {"epss_score": 0.00429, "epss_percentile": 0.61963}, "CVE-2025-27112": {"epss_score": 0.12881, "epss_percentile": 0.93811}, "CVE-2025-27113": {"epss_score": 0.00217, "epss_percentile": 0.44242}, "CVE-2025-27127": {"epss_score": 0.00097, "epss_percentile": 0.27453}, "CVE-2025-27128": {"epss_score": 0.00016, "epss_percentile": 0.02955}, "CVE-2025-27129": {"epss_score": 0.00244, "epss_percentile": 0.47563}, "CVE-2025-27130": {"epss_score": 0.00481, "epss_percentile": 0.645}, "CVE-2025-27131": {"epss_score": 0.00026, "epss_percentile": 0.06682}, "CVE-2025-27132": {"epss_score": 0.00019, "epss_percentile": 0.04391}, "CVE-2025-27133": {"epss_score": 0.00495, "epss_percentile": 0.65109}, "CVE-2025-27134": {"epss_score": 0.09082, "epss_percentile": 0.92392}, "CVE-2025-27135": {"epss_score": 0.00322, "epss_percentile": 0.5483}, "CVE-2025-27136": {"epss_score": 0.00125, "epss_percentile": 0.32554}, "CVE-2025-27137": {"epss_score": 0.0005, "epss_percentile": 0.15779}, "CVE-2025-27138": {"epss_score": 0.0023, "epss_percentile": 0.45685}, "CVE-2025-27139": {"epss_score": 0.00239, "epss_percentile": 0.46875}, "CVE-2025-27140": {"epss_score": 0.11887, "epss_percentile": 0.93506}, "CVE-2025-27141": {"epss_score": 0.00112, "epss_percentile": 0.30473}, "CVE-2025-27142": {"epss_score": 0.00485, "epss_percentile": 0.64724}, "CVE-2025-27143": {"epss_score": 0.00151, "epss_percentile": 0.3631}, "CVE-2025-27144": {"epss_score": 0.00078, "epss_percentile": 0.23592}, "CVE-2025-27145": {"epss_score": 0.00074, "epss_percentile": 0.22769}, "CVE-2025-27146": {"epss_score": 0.00361, "epss_percentile": 0.57723}, "CVE-2025-27147": {"epss_score": 0.00164, "epss_percentile": 0.37895}, "CVE-2025-27148": {"epss_score": 0.00054, "epss_percentile": 0.17134}, "CVE-2025-27149": {"epss_score": 0.0006, "epss_percentile": 0.19228}, "CVE-2025-27150": {"epss_score": 0.00116, "epss_percentile": 0.3118}, "CVE-2025-27151": {"epss_score": 0.00069, "epss_percentile": 0.21487}, "CVE-2025-27152": {"epss_score": 0.00065, "epss_percentile": 0.20618}, "CVE-2025-27153": {"epss_score": 0.00036, "epss_percentile": 0.10372}, "CVE-2025-27154": {"epss_score": 0.00177, "epss_percentile": 0.39575}, "CVE-2025-27155": {"epss_score": 0.00085, "epss_percentile": 0.25087}, "CVE-2025-27156": {"epss_score": 0.00226, "epss_percentile": 0.45294}, "CVE-2025-27157": {"epss_score": 0.00233, "epss_percentile": 0.46075}, "CVE-2025-27158": {"epss_score": 0.00042, "epss_percentile": 0.12659}, "CVE-2025-27159": {"epss_score": 0.00043, "epss_percentile": 0.13089}, "CVE-2025-27160": {"epss_score": 0.00043, "epss_percentile": 0.13089}, "CVE-2025-27161": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-27162": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-27163": {"epss_score": 0.0006, "epss_percentile": 0.18975}, "CVE-2025-27164": {"epss_score": 0.00055, "epss_percentile": 0.17499}, "CVE-2025-27165": {"epss_score": 0.00023, "epss_percentile": 0.05395}, "CVE-2025-27166": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-27167": {"epss_score": 0.00038, "epss_percentile": 0.1127}, "CVE-2025-27168": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-27169": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-27170": {"epss_score": 0.00037, "epss_percentile": 0.10668}, "CVE-2025-27171": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-27172": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-27173": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-27174": {"epss_score": 0.00043, "epss_percentile": 0.13089}, "CVE-2025-27175": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-27176": {"epss_score": 0.00037, "epss_percentile": 0.10668}, "CVE-2025-27177": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-27178": {"epss_score": 0.00042, "epss_percentile": 0.12724}, "CVE-2025-27179": {"epss_score": 0.00037, "epss_percentile": 0.10668}, "CVE-2025-27180": {"epss_score": 0.00053, "epss_percentile": 0.16681}, "CVE-2025-27181": {"epss_score": 0.00043, "epss_percentile": 0.13089}, "CVE-2025-27182": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-27183": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-27184": {"epss_score": 0.00042, "epss_percentile": 0.12626}, "CVE-2025-27185": {"epss_score": 0.00029, "epss_percentile": 0.07844}, "CVE-2025-27186": {"epss_score": 0.00042, "epss_percentile": 0.12626}, "CVE-2025-27187": {"epss_score": 0.00042, "epss_percentile": 0.12626}, "CVE-2025-27188": {"epss_score": 0.00108, "epss_percentile": 0.29777}, "CVE-2025-27189": {"epss_score": 0.00078, "epss_percentile": 0.23639}, "CVE-2025-27190": {"epss_score": 0.00181, "epss_percentile": 0.40051}, "CVE-2025-27191": {"epss_score": 0.00181, "epss_percentile": 0.40051}, "CVE-2025-27192": {"epss_score": 0.00126, "epss_percentile": 0.32627}, "CVE-2025-27193": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-27194": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-27195": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-27196": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-27197": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-27198": {"epss_score": 0.00134, "epss_percentile": 0.33924}, "CVE-2025-27199": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-27200": {"epss_score": 0.00057, "epss_percentile": 0.17982}, "CVE-2025-27201": {"epss_score": 0.00042, "epss_percentile": 0.12626}, "CVE-2025-27202": {"epss_score": 0.00042, "epss_percentile": 0.12626}, "CVE-2025-27203": {"epss_score": 0.10293, "epss_percentile": 0.92931}, "CVE-2025-27204": {"epss_score": 0.00042, "epss_percentile": 0.12626}, "CVE-2025-27205": {"epss_score": 0.00047, "epss_percentile": 0.149}, "CVE-2025-27206": {"epss_score": 0.00106, "epss_percentile": 0.29417}, "CVE-2025-27207": {"epss_score": 0.00081, "epss_percentile": 0.24304}, "CVE-2025-27208": {"epss_score": 0.0001, "epss_percentile": 0.00877}, "CVE-2025-27209": {"epss_score": 0.00019, "epss_percentile": 0.04328}, "CVE-2025-27210": {"epss_score": 0.0217, "epss_percentile": 0.83869}, "CVE-2025-27211": {"epss_score": 0.00454, "epss_percentile": 0.63269}, "CVE-2025-27212": {"epss_score": 0.00299, "epss_percentile": 0.52844}, "CVE-2025-27213": {"epss_score": 0.00044, "epss_percentile": 0.13633}, "CVE-2025-27214": {"epss_score": 0.00106, "epss_percentile": 0.29502}, "CVE-2025-27215": {"epss_score": 0.00051, "epss_percentile": 0.1629}, "CVE-2025-27216": {"epss_score": 0.00062, "epss_percentile": 0.19586}, "CVE-2025-27217": {"epss_score": 0.00041, "epss_percentile": 0.12391}, "CVE-2025-27218": {"epss_score": 0.62828, "epss_percentile": 0.98309}, "CVE-2025-27219": {"epss_score": 0.00778, "epss_percentile": 0.73136}, "CVE-2025-27220": {"epss_score": 0.00566, "epss_percentile": 0.6781}, "CVE-2025-27221": {"epss_score": 0.00038, "epss_percentile": 0.11122}, "CVE-2025-27222": {"epss_score": 0.05942, "epss_percentile": 0.90352}, "CVE-2025-27223": {"epss_score": 0.07049, "epss_percentile": 0.91212}, "CVE-2025-27224": {"epss_score": 0.00171, "epss_percentile": 0.38831}, "CVE-2025-27225": {"epss_score": 0.18973, "epss_percentile": 0.95104}, "CVE-2025-27231": {"epss_score": 0.00033, "epss_percentile": 0.09325}, "CVE-2025-27232": {"epss_score": 0.00022, "epss_percentile": 0.05164}, "CVE-2025-27233": {"epss_score": 0.00032, "epss_percentile": 0.08802}, "CVE-2025-27234": {"epss_score": 0.001, "epss_percentile": 0.28519}, "CVE-2025-27236": {"epss_score": 0.00049, "epss_percentile": 0.15375}, "CVE-2025-27237": {"epss_score": 0.00021, "epss_percentile": 0.04863}, "CVE-2025-27238": {"epss_score": 0.00021, "epss_percentile": 0.04742}, "CVE-2025-27240": {"epss_score": 0.00068, "epss_percentile": 0.21254}, "CVE-2025-27241": {"epss_score": 0.00018, "epss_percentile": 0.03559}, "CVE-2025-27242": {"epss_score": 0.00026, "epss_percentile": 0.06682}, "CVE-2025-27244": {"epss_score": 0.00072, "epss_percentile": 0.22314}, "CVE-2025-27246": {"epss_score": 0.00012, "epss_percentile": 0.01389}, "CVE-2025-27247": {"epss_score": 0.00015, "epss_percentile": 0.02583}, "CVE-2025-27248": {"epss_score": 0.00018, "epss_percentile": 0.03559}, "CVE-2025-27249": {"epss_score": 0.00017, "epss_percentile": 0.03092}, "CVE-2025-27250": {"epss_score": 0.00028, "epss_percentile": 0.07272}, "CVE-2025-27253": {"epss_score": 0.00052, "epss_percentile": 0.16438}, "CVE-2025-27254": {"epss_score": 0.00039, "epss_percentile": 0.11792}, "CVE-2025-27255": {"epss_score": 0.00029, "epss_percentile": 0.07867}, "CVE-2025-27256": {"epss_score": 0.00064, "epss_percentile": 0.20301}, "CVE-2025-27257": {"epss_score": 0.0002, "epss_percentile": 0.04442}, "CVE-2025-27258": {"epss_score": 0.00072, "epss_percentile": 0.22302}, "CVE-2025-27259": {"epss_score": 0.00049, "epss_percentile": 0.15347}, "CVE-2025-27261": {"epss_score": 0.00043, "epss_percentile": 0.13091}, "CVE-2025-27262": {"epss_score": 0.00049, "epss_percentile": 0.15459}, "CVE-2025-27263": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-27264": {"epss_score": 0.00242, "epss_percentile": 0.47349}, "CVE-2025-27265": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27266": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27267": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-27268": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-27269": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-27270": {"epss_score": 0.00198, "epss_percentile": 0.41998}, "CVE-2025-27271": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-27272": {"epss_score": 0.00242, "epss_percentile": 0.47349}, "CVE-2025-27273": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-27274": {"epss_score": 0.00231, "epss_percentile": 0.45774}, "CVE-2025-27275": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-27276": {"epss_score": 0.00058, "epss_percentile": 0.18265}, "CVE-2025-27277": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-27278": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-27279": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-27280": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27281": {"epss_score": 0.00104, "epss_percentile": 0.29199}, "CVE-2025-27282": {"epss_score": 0.00094, "epss_percentile": 0.26767}, "CVE-2025-27283": {"epss_score": 0.00113, "epss_percentile": 0.30602}, "CVE-2025-27284": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27285": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27286": {"epss_score": 0.00134, "epss_percentile": 0.33853}, "CVE-2025-27287": {"epss_score": 0.00134, "epss_percentile": 0.33853}, "CVE-2025-27288": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27289": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27290": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27291": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27292": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27293": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27294": {"epss_score": 0.00082, "epss_percentile": 0.24583}, "CVE-2025-27295": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27296": {"epss_score": 0.00177, "epss_percentile": 0.39623}, "CVE-2025-27297": {"epss_score": 0.00119, "epss_percentile": 0.31626}, "CVE-2025-27298": {"epss_score": 0.00098, "epss_percentile": 0.27715}, "CVE-2025-27299": {"epss_score": 0.00096, "epss_percentile": 0.27372}, "CVE-2025-27300": {"epss_score": 0.0022, "epss_percentile": 0.44598}, "CVE-2025-27301": {"epss_score": 0.0022, "epss_percentile": 0.44598}, "CVE-2025-27302": {"epss_score": 0.00053, "epss_percentile": 0.16856}, "CVE-2025-27303": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-27304": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-27305": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27306": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27307": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27308": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27309": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27310": {"epss_score": 0.00072, "epss_percentile": 0.2232}, "CVE-2025-27311": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27312": {"epss_score": 0.00122, "epss_percentile": 0.3217}, "CVE-2025-27313": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27314": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27315": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27316": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27317": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27318": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27319": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27320": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27321": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-27322": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27323": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27324": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27325": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27326": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-27327": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27328": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27329": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27330": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27331": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27332": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-27333": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27334": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-27335": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27336": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27337": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27338": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27339": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27340": {"epss_score": 0.00048, "epss_percentile": 0.1517}, "CVE-2025-27341": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27342": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27343": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27344": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27345": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27346": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27347": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27348": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27349": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27350": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-27351": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-27352": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-27353": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27354": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-27355": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-27356": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-27357": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-27358": {"epss_score": 0.0003, "epss_percentile": 0.0825}, "CVE-2025-27359": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-27360": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-27361": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-27362": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-27363": {"epss_score": 0.76675, "epss_percentile": 0.98901}, "CVE-2025-27364": {"epss_score": 0.0304, "epss_percentile": 0.86271}, "CVE-2025-27365": {"epss_score": 0.00045, "epss_percentile": 0.13921}, "CVE-2025-27367": {"epss_score": 0.00023, "epss_percentile": 0.05619}, "CVE-2025-27368": {"epss_score": 0.00033, "epss_percentile": 0.09371}, "CVE-2025-27369": {"epss_score": 0.0003, "epss_percentile": 0.08286}, "CVE-2025-27370": {"epss_score": 0.00116, "epss_percentile": 0.31149}, "CVE-2025-27371": {"epss_score": 0.00092, "epss_percentile": 0.26416}, "CVE-2025-27374": {"epss_score": 0.00061, "epss_percentile": 0.19467}, "CVE-2025-27387": {"epss_score": 0.00021, "epss_percentile": 0.04775}, "CVE-2025-27388": {"epss_score": 0.00164, "epss_percentile": 0.38007}, "CVE-2025-27389": {"epss_score": 0.0002, "epss_percentile": 0.04511}, "CVE-2025-27391": {"epss_score": 0.00099, "epss_percentile": 0.27834}, "CVE-2025-27392": {"epss_score": 0.00819, "epss_percentile": 0.7387}, "CVE-2025-27393": {"epss_score": 0.00819, "epss_percentile": 0.7387}, "CVE-2025-27394": {"epss_score": 0.00819, "epss_percentile": 0.7387}, "CVE-2025-27395": {"epss_score": 0.00188, "epss_percentile": 0.409}, "CVE-2025-27396": {"epss_score": 0.00256, "epss_percentile": 0.48832}, "CVE-2025-27397": {"epss_score": 0.00082, "epss_percentile": 0.2448}, "CVE-2025-27398": {"epss_score": 0.00081, "epss_percentile": 0.2433}, "CVE-2025-27399": {"epss_score": 0.00237, "epss_percentile": 0.46708}, "CVE-2025-27400": {"epss_score": 0.00464, "epss_percentile": 0.63713}, "CVE-2025-27401": {"epss_score": 0.00099, "epss_percentile": 0.28352}, "CVE-2025-27402": {"epss_score": 0.00051, "epss_percentile": 0.16272}, "CVE-2025-27403": {"epss_score": 0.00199, "epss_percentile": 0.42157}, "CVE-2025-27404": {"epss_score": 0.00252, "epss_percentile": 0.484}, "CVE-2025-27405": {"epss_score": 0.00252, "epss_percentile": 0.484}, "CVE-2025-27406": {"epss_score": 0.00089, "epss_percentile": 0.25832}, "CVE-2025-27407": {"epss_score": 0.05864, "epss_percentile": 0.90273}, "CVE-2025-27408": {"epss_score": 0.00061, "epss_percentile": 0.19485}, "CVE-2025-27409": {"epss_score": 0.00121, "epss_percentile": 0.31818}, "CVE-2025-27410": {"epss_score": 0.21644, "epss_percentile": 0.95543}, "CVE-2025-27411": {"epss_score": 0.00086, "epss_percentile": 0.25281}, "CVE-2025-27412": {"epss_score": 0.00213, "epss_percentile": 0.43828}, "CVE-2025-27413": {"epss_score": 0.0078, "epss_percentile": 0.73159}, "CVE-2025-27414": {"epss_score": 0.00219, "epss_percentile": 0.44489}, "CVE-2025-27415": {"epss_score": 0.00131, "epss_percentile": 0.33351}, "CVE-2025-27416": {"epss_score": 0.00055, "epss_percentile": 0.17649}, "CVE-2025-27417": {"epss_score": 0.00213, "epss_percentile": 0.43828}, "CVE-2025-27418": {"epss_score": 0.00083, "epss_percentile": 0.24795}, "CVE-2025-27419": {"epss_score": 0.00853, "epss_percentile": 0.74429}, "CVE-2025-27420": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-27421": {"epss_score": 0.00213, "epss_percentile": 0.43852}, "CVE-2025-27422": {"epss_score": 0.00157, "epss_percentile": 0.37116}, "CVE-2025-27423": {"epss_score": 0.01209, "epss_percentile": 0.78543}, "CVE-2025-27424": {"epss_score": 0.00035, "epss_percentile": 0.10121}, "CVE-2025-27425": {"epss_score": 0.00092, "epss_percentile": 0.26521}, "CVE-2025-27426": {"epss_score": 0.00034, "epss_percentile": 0.09481}, "CVE-2025-27427": {"epss_score": 0.0028, "epss_percentile": 0.51069}, "CVE-2025-27428": {"epss_score": 0.00213, "epss_percentile": 0.43835}, "CVE-2025-27429": {"epss_score": 0.00127, "epss_percentile": 0.32872}, "CVE-2025-27430": {"epss_score": 0.0006, "epss_percentile": 0.18988}, "CVE-2025-27431": {"epss_score": 0.00064, "epss_percentile": 0.20353}, "CVE-2025-27432": {"epss_score": 0.00042, "epss_percentile": 0.12933}, "CVE-2025-27433": {"epss_score": 0.00083, "epss_percentile": 0.2481}, "CVE-2025-27434": {"epss_score": 0.00237, "epss_percentile": 0.46733}, "CVE-2025-27435": {"epss_score": 0.00095, "epss_percentile": 0.2713}, "CVE-2025-27436": {"epss_score": 0.00083, "epss_percentile": 0.2481}, "CVE-2025-27437": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2025-27438": {"epss_score": 0.00031, "epss_percentile": 0.08447}, "CVE-2025-27439": {"epss_score": 0.00221, "epss_percentile": 0.44642}, "CVE-2025-27440": {"epss_score": 0.00225, "epss_percentile": 0.45099}, "CVE-2025-27441": {"epss_score": 0.00023, "epss_percentile": 0.05646}, "CVE-2025-27442": {"epss_score": 0.00023, "epss_percentile": 0.05646}, "CVE-2025-27443": {"epss_score": 0.00022, "epss_percentile": 0.05024}, "CVE-2025-27444": {"epss_score": 0.00022, "epss_percentile": 0.0532}, "CVE-2025-27445": {"epss_score": 0.00108, "epss_percentile": 0.29822}, "CVE-2025-27446": {"epss_score": 0.00013, "epss_percentile": 0.01544}, "CVE-2025-27447": {"epss_score": 0.00035, "epss_percentile": 0.10158}, "CVE-2025-27448": {"epss_score": 0.00043, "epss_percentile": 0.13307}, "CVE-2025-27449": {"epss_score": 0.001, "epss_percentile": 0.2852}, "CVE-2025-27450": {"epss_score": 0.00022, "epss_percentile": 0.05176}, "CVE-2025-27451": {"epss_score": 0.00053, "epss_percentile": 0.17011}, "CVE-2025-27452": {"epss_score": 0.00053, "epss_percentile": 0.17011}, "CVE-2025-27453": {"epss_score": 0.00042, "epss_percentile": 0.12899}, "CVE-2025-27454": {"epss_score": 0.0002, "epss_percentile": 0.04563}, "CVE-2025-27455": {"epss_score": 0.00039, "epss_percentile": 0.1159}, "CVE-2025-27456": {"epss_score": 0.001, "epss_percentile": 0.2852}, "CVE-2025-27457": {"epss_score": 0.00022, "epss_percentile": 0.05176}, "CVE-2025-27458": {"epss_score": 0.00024, "epss_percentile": 0.05965}, "CVE-2025-27459": {"epss_score": 0.00011, "epss_percentile": 0.01075}, "CVE-2025-27460": {"epss_score": 0.00019, "epss_percentile": 0.04108}, "CVE-2025-27461": {"epss_score": 0.00051, "epss_percentile": 0.1619}, "CVE-2025-27465": {"epss_score": 0.00051, "epss_percentile": 0.16282}, "CVE-2025-27466": {"epss_score": 0.00064, "epss_percentile": 0.20179}, "CVE-2025-27467": {"epss_score": 0.00291, "epss_percentile": 0.52173}, "CVE-2025-27468": {"epss_score": 0.00046, "epss_percentile": 0.14459}, "CVE-2025-27469": {"epss_score": 0.26764, "epss_percentile": 0.96176}, "CVE-2025-27470": {"epss_score": 0.24365, "epss_percentile": 0.95911}, "CVE-2025-27471": {"epss_score": 0.00169, "epss_percentile": 0.38635}, "CVE-2025-27472": {"epss_score": 0.00829, "epss_percentile": 0.74011}, "CVE-2025-27473": {"epss_score": 0.26764, "epss_percentile": 0.96176}, "CVE-2025-27474": {"epss_score": 0.01107, "epss_percentile": 0.77625}, "CVE-2025-27475": {"epss_score": 0.00089, "epss_percentile": 0.25877}, "CVE-2025-27476": {"epss_score": 0.00291, "epss_percentile": 0.52173}, "CVE-2025-27477": {"epss_score": 0.00861, "epss_percentile": 0.74563}, "CVE-2025-27478": {"epss_score": 0.00097, "epss_percentile": 0.27515}, "CVE-2025-27479": {"epss_score": 0.24365, "epss_percentile": 0.95911}, "CVE-2025-27480": {"epss_score": 0.00397, "epss_percentile": 0.59964}, "CVE-2025-27481": {"epss_score": 0.00263, "epss_percentile": 0.49514}, "CVE-2025-27482": {"epss_score": 0.00216, "epss_percentile": 0.44129}, "CVE-2025-27483": {"epss_score": 0.00208, "epss_percentile": 0.43264}, "CVE-2025-27484": {"epss_score": 0.00177, "epss_percentile": 0.39585}, "CVE-2025-27485": {"epss_score": 0.19467, "epss_percentile": 0.95188}, "CVE-2025-27486": {"epss_score": 0.19467, "epss_percentile": 0.95188}, "CVE-2025-27487": {"epss_score": 0.00468, "epss_percentile": 0.63883}, "CVE-2025-27488": {"epss_score": 0.00091, "epss_percentile": 0.26225}, "CVE-2025-27489": {"epss_score": 0.00519, "epss_percentile": 0.66177}, "CVE-2025-27490": {"epss_score": 0.00254, "epss_percentile": 0.48521}, "CVE-2025-27491": {"epss_score": 0.00317, "epss_percentile": 0.54364}, "CVE-2025-27492": {"epss_score": 0.00065, "epss_percentile": 0.20654}, "CVE-2025-27493": {"epss_score": 0.00036, "epss_percentile": 0.10295}, "CVE-2025-27494": {"epss_score": 0.00265, "epss_percentile": 0.49843}, "CVE-2025-27495": {"epss_score": 0.00359, "epss_percentile": 0.57613}, "CVE-2025-27496": {"epss_score": 0.00029, "epss_percentile": 0.07838}, "CVE-2025-27497": {"epss_score": 0.0007, "epss_percentile": 0.21652}, "CVE-2025-27498": {"epss_score": 0.0002, "epss_percentile": 0.04478}, "CVE-2025-27499": {"epss_score": 0.00213, "epss_percentile": 0.43828}, "CVE-2025-27500": {"epss_score": 0.00086, "epss_percentile": 0.25407}, "CVE-2025-27501": {"epss_score": 0.00104, "epss_percentile": 0.29105}, "CVE-2025-27505": {"epss_score": 0.00321, "epss_percentile": 0.54683}, "CVE-2025-27506": {"epss_score": 0.00174, "epss_percentile": 0.39203}, "CVE-2025-27507": {"epss_score": 0.00308, "epss_percentile": 0.53617}, "CVE-2025-27508": {"epss_score": 0.00085, "epss_percentile": 0.25224}, "CVE-2025-27509": {"epss_score": 0.00187, "epss_percentile": 0.40716}, "CVE-2025-27510": {"epss_score": 0.0089, "epss_percentile": 0.75025}, "CVE-2025-27512": {"epss_score": 0.00022, "epss_percentile": 0.05064}, "CVE-2025-27513": {"epss_score": 0.00081, "epss_percentile": 0.24366}, "CVE-2025-27514": {"epss_score": 0.00024, "epss_percentile": 0.05892}, "CVE-2025-27515": {"epss_score": 0.00152, "epss_percentile": 0.36486}, "CVE-2025-27516": {"epss_score": 0.00272, "epss_percentile": 0.504}, "CVE-2025-27517": {"epss_score": 0.00824, "epss_percentile": 0.73938}, "CVE-2025-27518": {"epss_score": 0.00281, "epss_percentile": 0.51115}, "CVE-2025-27519": {"epss_score": 0.00347, "epss_percentile": 0.56768}, "CVE-2025-27520": {"epss_score": 0.69938, "epss_percentile": 0.98609}, "CVE-2025-27521": {"epss_score": 0.00018, "epss_percentile": 0.03831}, "CVE-2025-27522": {"epss_score": 0.00208, "epss_percentile": 0.43306}, "CVE-2025-27523": {"epss_score": 0.00051, "epss_percentile": 0.16071}, "CVE-2025-27524": {"epss_score": 0.00021, "epss_percentile": 0.04732}, "CVE-2025-27525": {"epss_score": 0.00014, "epss_percentile": 0.02086}, "CVE-2025-27526": {"epss_score": 0.00152, "epss_percentile": 0.36415}, "CVE-2025-27528": {"epss_score": 0.00138, "epss_percentile": 0.34368}, "CVE-2025-27531": {"epss_score": 0.00612, "epss_percentile": 0.69233}, "CVE-2025-27532": {"epss_score": 0.00084, "epss_percentile": 0.25012}, "CVE-2025-27533": {"epss_score": 0.00583, "epss_percentile": 0.68332}, "CVE-2025-27534": {"epss_score": 0.00024, "epss_percentile": 0.0601}, "CVE-2025-27536": {"epss_score": 0.00016, "epss_percentile": 0.0262}, "CVE-2025-27537": {"epss_score": 0.00027, "epss_percentile": 0.06984}, "CVE-2025-27538": {"epss_score": 0.00045, "epss_percentile": 0.1374}, "CVE-2025-27539": {"epss_score": 0.00359, "epss_percentile": 0.57613}, "CVE-2025-27540": {"epss_score": 0.00359, "epss_percentile": 0.57613}, "CVE-2025-27551": {"epss_score": 0.0002, "epss_percentile": 0.04591}, "CVE-2025-27552": {"epss_score": 0.0002, "epss_percentile": 0.04591}, "CVE-2025-27553": {"epss_score": 0.00339, "epss_percentile": 0.56185}, "CVE-2025-27554": {"epss_score": 0.00623, "epss_percentile": 0.69534}, "CVE-2025-27556": {"epss_score": 0.00053, "epss_percentile": 0.16678}, "CVE-2025-27558": {"epss_score": 0.00025, "epss_percentile": 0.06285}, "CVE-2025-27559": {"epss_score": 0.00011, "epss_percentile": 0.00924}, "CVE-2025-27561": {"epss_score": 0.00154, "epss_percentile": 0.36648}, "CVE-2025-27562": {"epss_score": 0.00016, "epss_percentile": 0.0262}, "CVE-2025-27563": {"epss_score": 0.00015, "epss_percentile": 0.02224}, "CVE-2025-27565": {"epss_score": 0.00154, "epss_percentile": 0.36648}, "CVE-2025-27566": {"epss_score": 0.00092, "epss_percentile": 0.26502}, "CVE-2025-27567": {"epss_score": 0.00045, "epss_percentile": 0.13811}, "CVE-2025-27568": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-27571": {"epss_score": 0.00058, "epss_percentile": 0.18478}, "CVE-2025-27574": {"epss_score": 0.00031, "epss_percentile": 0.08507}, "CVE-2025-27575": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-27576": {"epss_score": 0.00017, "epss_percentile": 0.03137}, "CVE-2025-27577": {"epss_score": 0.0001, "epss_percentile": 0.00784}, "CVE-2025-27578": {"epss_score": 0.00055, "epss_percentile": 0.17581}, "CVE-2025-27579": {"epss_score": 0.00063, "epss_percentile": 0.19884}, "CVE-2025-27580": {"epss_score": 0.00273, "epss_percentile": 0.50442}, "CVE-2025-27581": {"epss_score": 0.00057, "epss_percentile": 0.18235}, "CVE-2025-27582": {"epss_score": 0.00024, "epss_percentile": 0.05676}, "CVE-2025-27583": {"epss_score": 0.0011, "epss_percentile": 0.3011}, "CVE-2025-27584": {"epss_score": 0.00064, "epss_percentile": 0.20353}, "CVE-2025-27585": {"epss_score": 0.00064, "epss_percentile": 0.20353}, "CVE-2025-27587": {"epss_score": 0.00035, "epss_percentile": 0.10126}, "CVE-2025-27590": {"epss_score": 0.0138, "epss_percentile": 0.79865}, "CVE-2025-27591": {"epss_score": 0.00014, "epss_percentile": 0.01822}, "CVE-2025-27593": {"epss_score": 0.00115, "epss_percentile": 0.31009}, "CVE-2025-27594": {"epss_score": 0.00155, "epss_percentile": 0.36814}, "CVE-2025-27595": {"epss_score": 0.00258, "epss_percentile": 0.49016}, "CVE-2025-27597": {"epss_score": 0.00301, "epss_percentile": 0.53082}, "CVE-2025-27598": {"epss_score": 0.00339, "epss_percentile": 0.56165}, "CVE-2025-27599": {"epss_score": 0.00082, "epss_percentile": 0.24481}, "CVE-2025-27600": {"epss_score": 0.00098, "epss_percentile": 0.27764}, "CVE-2025-27601": {"epss_score": 0.00129, "epss_percentile": 0.33167}, "CVE-2025-27602": {"epss_score": 0.00125, "epss_percentile": 0.32542}, "CVE-2025-27603": {"epss_score": 0.00459, "epss_percentile": 0.63452}, "CVE-2025-27604": {"epss_score": 0.00218, "epss_percentile": 0.44396}, "CVE-2025-27606": {"epss_score": 0.00045, "epss_percentile": 0.13741}, "CVE-2025-27607": {"epss_score": 0.09297, "epss_percentile": 0.92488}, "CVE-2025-27608": {"epss_score": 0.00041, "epss_percentile": 0.12334}, "CVE-2025-27609": {"epss_score": 0.00169, "epss_percentile": 0.38549}, "CVE-2025-27610": {"epss_score": 0.00415, "epss_percentile": 0.61148}, "CVE-2025-27611": {"epss_score": 0.0008, "epss_percentile": 0.24054}, "CVE-2025-27612": {"epss_score": 0.00078, "epss_percentile": 0.23591}, "CVE-2025-27613": {"epss_score": 0.00027, "epss_percentile": 0.07118}, "CVE-2025-27614": {"epss_score": 0.00017, "epss_percentile": 0.03253}, "CVE-2025-27615": {"epss_score": 0.00299, "epss_percentile": 0.52879}, "CVE-2025-27616": {"epss_score": 0.00091, "epss_percentile": 0.26201}, "CVE-2025-27617": {"epss_score": 0.0051, "epss_percentile": 0.65795}, "CVE-2025-27622": {"epss_score": 0.00112, "epss_percentile": 0.30475}, "CVE-2025-27623": {"epss_score": 0.00328, "epss_percentile": 0.55293}, "CVE-2025-27624": {"epss_score": 0.00061, "epss_percentile": 0.19373}, "CVE-2025-27625": {"epss_score": 0.00085, "epss_percentile": 0.25231}, "CVE-2025-27631": {"epss_score": 0.00057, "epss_percentile": 0.18022}, "CVE-2025-27632": {"epss_score": 0.00049, "epss_percentile": 0.15644}, "CVE-2025-27633": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-27636": {"epss_score": 0.28414, "epss_percentile": 0.96355}, "CVE-2025-27637": {"epss_score": 0.00172, "epss_percentile": 0.39034}, "CVE-2025-27638": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27639": {"epss_score": 0.00226, "epss_percentile": 0.45265}, "CVE-2025-27640": {"epss_score": 0.00156, "epss_percentile": 0.37012}, "CVE-2025-27641": {"epss_score": 0.00265, "epss_percentile": 0.49811}, "CVE-2025-27642": {"epss_score": 0.00265, "epss_percentile": 0.49811}, "CVE-2025-27643": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27644": {"epss_score": 0.0004, "epss_percentile": 0.12061}, "CVE-2025-27645": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27646": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27647": {"epss_score": 0.00279, "epss_percentile": 0.50957}, "CVE-2025-27648": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27649": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27650": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27651": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27652": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27653": {"epss_score": 0.00173, "epss_percentile": 0.39071}, "CVE-2025-27654": {"epss_score": 0.00172, "epss_percentile": 0.39034}, "CVE-2025-27655": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27656": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27657": {"epss_score": 0.0127, "epss_percentile": 0.79052}, "CVE-2025-27658": {"epss_score": 0.0023, "epss_percentile": 0.45686}, "CVE-2025-27659": {"epss_score": 0.00156, "epss_percentile": 0.37012}, "CVE-2025-27660": {"epss_score": 0.00119, "epss_percentile": 0.31638}, "CVE-2025-27661": {"epss_score": 0.00178, "epss_percentile": 0.3963}, "CVE-2025-27662": {"epss_score": 0.00239, "epss_percentile": 0.46932}, "CVE-2025-27663": {"epss_score": 0.0015, "epss_percentile": 0.36076}, "CVE-2025-27664": {"epss_score": 0.00076, "epss_percentile": 0.23238}, "CVE-2025-27665": {"epss_score": 0.00296, "epss_percentile": 0.52557}, "CVE-2025-27666": {"epss_score": 0.00239, "epss_percentile": 0.46932}, "CVE-2025-27667": {"epss_score": 0.00296, "epss_percentile": 0.52557}, "CVE-2025-27668": {"epss_score": 0.00296, "epss_percentile": 0.52557}, "CVE-2025-27669": {"epss_score": 0.00263, "epss_percentile": 0.49503}, "CVE-2025-27670": {"epss_score": 0.00161, "epss_percentile": 0.37557}, "CVE-2025-27671": {"epss_score": 0.00239, "epss_percentile": 0.46932}, "CVE-2025-27672": {"epss_score": 0.00239, "epss_percentile": 0.46932}, "CVE-2025-27673": {"epss_score": 0.00219, "epss_percentile": 0.44516}, "CVE-2025-27674": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27675": {"epss_score": 0.00327, "epss_percentile": 0.55102}, "CVE-2025-27676": {"epss_score": 0.00172, "epss_percentile": 0.39034}, "CVE-2025-27677": {"epss_score": 0.00265, "epss_percentile": 0.49758}, "CVE-2025-27678": {"epss_score": 0.00997, "epss_percentile": 0.76454}, "CVE-2025-27679": {"epss_score": 0.00108, "epss_percentile": 0.29826}, "CVE-2025-27680": {"epss_score": 0.00089, "epss_percentile": 0.25854}, "CVE-2025-27681": {"epss_score": 0.00255, "epss_percentile": 0.48727}, "CVE-2025-27682": {"epss_score": 0.00177, "epss_percentile": 0.3961}, "CVE-2025-27683": {"epss_score": 0.0023, "epss_percentile": 0.45679}, "CVE-2025-27684": {"epss_score": 0.00189, "epss_percentile": 0.40997}, "CVE-2025-27685": {"epss_score": 0.001, "epss_percentile": 0.28557}, "CVE-2025-27686": {"epss_score": 0.00075, "epss_percentile": 0.22958}, "CVE-2025-27688": {"epss_score": 0.0002, "epss_percentile": 0.04623}, "CVE-2025-27689": {"epss_score": 0.00017, "epss_percentile": 0.03308}, "CVE-2025-27690": {"epss_score": 0.00219, "epss_percentile": 0.44492}, "CVE-2025-27692": {"epss_score": 0.0062, "epss_percentile": 0.69453}, "CVE-2025-27693": {"epss_score": 0.00048, "epss_percentile": 0.14989}, "CVE-2025-27694": {"epss_score": 0.00113, "epss_percentile": 0.30613}, "CVE-2025-27695": {"epss_score": 0.00076, "epss_percentile": 0.23103}, "CVE-2025-27696": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2025-27700": {"epss_score": 8e-05, "epss_percentile": 0.0052}, "CVE-2025-27701": {"epss_score": 7e-05, "epss_percentile": 0.00402}, "CVE-2025-27702": {"epss_score": 0.00033, "epss_percentile": 0.09215}, "CVE-2025-27703": {"epss_score": 0.00045, "epss_percentile": 0.13779}, "CVE-2025-27704": {"epss_score": 0.0008, "epss_percentile": 0.24113}, "CVE-2025-27705": {"epss_score": 0.00148, "epss_percentile": 0.35834}, "CVE-2025-27706": {"epss_score": 0.00023, "epss_percentile": 0.05373}, "CVE-2025-27707": {"epss_score": 0.00015, "epss_percentile": 0.02609}, "CVE-2025-27709": {"epss_score": 0.00167, "epss_percentile": 0.38291}, "CVE-2025-27710": {"epss_score": 0.00016, "epss_percentile": 0.02797}, "CVE-2025-27711": {"epss_score": 0.00012, "epss_percentile": 0.01132}, "CVE-2025-27712": {"epss_score": 0.00015, "epss_percentile": 0.02199}, "CVE-2025-27713": {"epss_score": 0.00017, "epss_percentile": 0.0313}, "CVE-2025-27714": {"epss_score": 0.00069, "epss_percentile": 0.21622}, "CVE-2025-27715": {"epss_score": 0.00072, "epss_percentile": 0.22456}, "CVE-2025-27716": {"epss_score": 0.00266, "epss_percentile": 0.4987}, "CVE-2025-27717": {"epss_score": 0.00012, "epss_percentile": 0.01188}, "CVE-2025-27718": {"epss_score": 0.00326, "epss_percentile": 0.55083}, "CVE-2025-27719": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-27720": {"epss_score": 0.00011, "epss_percentile": 0.01109}, "CVE-2025-27721": {"epss_score": 0.00044, "epss_percentile": 0.13367}, "CVE-2025-27722": {"epss_score": 0.00024, "epss_percentile": 0.05901}, "CVE-2025-27724": {"epss_score": 0.00058, "epss_percentile": 0.18268}, "CVE-2025-27725": {"epss_score": 0.00014, "epss_percentile": 0.01802}, "CVE-2025-27726": {"epss_score": 0.00073, "epss_percentile": 0.22575}, "CVE-2025-27727": {"epss_score": 0.0081, "epss_percentile": 0.73722}, "CVE-2025-27728": {"epss_score": 0.00254, "epss_percentile": 0.48521}, "CVE-2025-27729": {"epss_score": 0.00208, "epss_percentile": 0.43264}, "CVE-2025-27730": {"epss_score": 0.00291, "epss_percentile": 0.52173}, "CVE-2025-27731": {"epss_score": 0.00589, "epss_percentile": 0.68522}, "CVE-2025-27732": {"epss_score": 0.00102, "epss_percentile": 0.28771}, "CVE-2025-27733": {"epss_score": 0.00208, "epss_percentile": 0.43264}, "CVE-2025-27735": {"epss_score": 0.00181, "epss_percentile": 0.4003}, "CVE-2025-27736": {"epss_score": 0.00339, "epss_percentile": 0.56205}, "CVE-2025-27737": {"epss_score": 0.00396, "epss_percentile": 0.5986}, "CVE-2025-27738": {"epss_score": 0.00878, "epss_percentile": 0.74825}, "CVE-2025-27739": {"epss_score": 0.00254, "epss_percentile": 0.48521}, "CVE-2025-27740": {"epss_score": 0.00958, "epss_percentile": 0.75948}, "CVE-2025-27741": {"epss_score": 0.00208, "epss_percentile": 0.43264}, "CVE-2025-27742": {"epss_score": 0.00217, "epss_percentile": 0.44287}, "CVE-2025-27743": {"epss_score": 0.00545, "epss_percentile": 0.6716}, "CVE-2025-27744": {"epss_score": 0.0025, "epss_percentile": 0.48249}, "CVE-2025-27745": {"epss_score": 0.00374, "epss_percentile": 0.58538}, "CVE-2025-27746": {"epss_score": 0.00208, "epss_percentile": 0.43264}, "CVE-2025-27747": {"epss_score": 0.00208, "epss_percentile": 0.43264}, "CVE-2025-27748": {"epss_score": 0.00374, "epss_percentile": 0.58538}, "CVE-2025-27749": {"epss_score": 0.00374, "epss_percentile": 0.58538}, "CVE-2025-27750": {"epss_score": 0.00238, "epss_percentile": 0.46815}, "CVE-2025-27751": {"epss_score": 0.00556, "epss_percentile": 0.67508}, "CVE-2025-27752": {"epss_score": 0.00326, "epss_percentile": 0.55067}, "CVE-2025-27753": {"epss_score": 0.00034, "epss_percentile": 0.09711}, "CVE-2025-27754": {"epss_score": 0.00039, "epss_percentile": 0.11604}, "CVE-2025-27759": {"epss_score": 0.00026, "epss_percentile": 0.06428}, "CVE-2025-27773": {"epss_score": 0.00181, "epss_percentile": 0.40061}, "CVE-2025-27774": {"epss_score": 0.00416, "epss_percentile": 0.61215}, "CVE-2025-27775": {"epss_score": 0.00416, "epss_percentile": 0.61215}, "CVE-2025-27776": {"epss_score": 0.00391, "epss_percentile": 0.59623}, "CVE-2025-27777": {"epss_score": 0.00141, "epss_percentile": 0.34869}, "CVE-2025-27778": {"epss_score": 0.03175, "epss_percentile": 0.86562}, "CVE-2025-27779": {"epss_score": 0.04364, "epss_percentile": 0.88601}, "CVE-2025-27780": {"epss_score": 0.04364, "epss_percentile": 0.88601}, "CVE-2025-27781": {"epss_score": 0.04549, "epss_percentile": 0.88838}, "CVE-2025-27782": {"epss_score": 0.03452, "epss_percentile": 0.87167}, "CVE-2025-27783": {"epss_score": 0.02024, "epss_percentile": 0.8331}, "CVE-2025-27784": {"epss_score": 0.00168, "epss_percentile": 0.38405}, "CVE-2025-27785": {"epss_score": 0.00251, "epss_percentile": 0.48309}, "CVE-2025-27786": {"epss_score": 0.00327, "epss_percentile": 0.55147}, "CVE-2025-27787": {"epss_score": 0.00308, "epss_percentile": 0.53617}, "CVE-2025-27788": {"epss_score": 0.00372, "epss_percentile": 0.58427}, "CVE-2025-27789": {"epss_score": 0.00139, "epss_percentile": 0.3464}, "CVE-2025-27791": {"epss_score": 0.00221, "epss_percentile": 0.44652}, "CVE-2025-27792": {"epss_score": 0.00098, "epss_percentile": 0.27775}, "CVE-2025-27793": {"epss_score": 0.00105, "epss_percentile": 0.29271}, "CVE-2025-27794": {"epss_score": 0.00224, "epss_percentile": 0.45013}, "CVE-2025-27795": {"epss_score": 0.00077, "epss_percentile": 0.2336}, "CVE-2025-27796": {"epss_score": 0.00033, "epss_percentile": 0.09348}, "CVE-2025-27797": {"epss_score": 0.00358, "epss_percentile": 0.57512}, "CVE-2025-27800": {"epss_score": 0.00025, "epss_percentile": 0.06356}, "CVE-2025-27801": {"epss_score": 0.00025, "epss_percentile": 0.06356}, "CVE-2025-27802": {"epss_score": 0.00025, "epss_percentile": 0.06356}, "CVE-2025-27803": {"epss_score": 0.00034, "epss_percentile": 0.09694}, "CVE-2025-27804": {"epss_score": 0.00105, "epss_percentile": 0.29259}, "CVE-2025-27807": {"epss_score": 0.00043, "epss_percentile": 0.13015}, "CVE-2025-27809": {"epss_score": 0.00067, "epss_percentile": 0.21053}, "CVE-2025-27810": {"epss_score": 0.00082, "epss_percentile": 0.24453}, "CVE-2025-27811": {"epss_score": 0.00017, "epss_percentile": 0.03308}, "CVE-2025-27812": {"epss_score": 0.00015, "epss_percentile": 0.02479}, "CVE-2025-27813": {"epss_score": 0.00012, "epss_percentile": 0.01303}, "CVE-2025-27816": {"epss_score": 0.00197, "epss_percentile": 0.41954}, "CVE-2025-27817": {"epss_score": 0.00039, "epss_percentile": 0.11769}, "CVE-2025-27818": {"epss_score": 0.00343, "epss_percentile": 0.56467}, "CVE-2025-27819": {"epss_score": 0.00969, "epss_percentile": 0.76099}, "CVE-2025-27820": {"epss_score": 0.00066, "epss_percentile": 0.20898}, "CVE-2025-27822": {"epss_score": 0.00095, "epss_percentile": 0.2716}, "CVE-2025-27823": {"epss_score": 0.00086, "epss_percentile": 0.25296}, "CVE-2025-27824": {"epss_score": 0.00086, "epss_percentile": 0.25296}, "CVE-2025-27825": {"epss_score": 0.00086, "epss_percentile": 0.25296}, "CVE-2025-27826": {"epss_score": 0.00086, "epss_percentile": 0.25296}, "CVE-2025-27827": {"epss_score": 0.00086, "epss_percentile": 0.25418}, "CVE-2025-27828": {"epss_score": 0.00056, "epss_percentile": 0.17777}, "CVE-2025-27829": {"epss_score": 0.00098, "epss_percentile": 0.27754}, "CVE-2025-27830": {"epss_score": 0.00026, "epss_percentile": 0.06435}, "CVE-2025-27831": {"epss_score": 0.00164, "epss_percentile": 0.37994}, "CVE-2025-27832": {"epss_score": 0.00108, "epss_percentile": 0.29879}, "CVE-2025-27833": {"epss_score": 0.00026, "epss_percentile": 0.06435}, "CVE-2025-27834": {"epss_score": 0.00018, "epss_percentile": 0.03863}, "CVE-2025-27835": {"epss_score": 0.00026, "epss_percentile": 0.06435}, "CVE-2025-27836": {"epss_score": 0.00164, "epss_percentile": 0.37994}, "CVE-2025-27837": {"epss_score": 0.0031, "epss_percentile": 0.53785}, "CVE-2025-27839": {"epss_score": 0.00104, "epss_percentile": 0.29145}, "CVE-2025-27840": {"epss_score": 0.00375, "epss_percentile": 0.58622}, "CVE-2025-27845": {"epss_score": 0.00124, "epss_percentile": 0.32465}, "CVE-2025-27846": {"epss_score": 0.0003, "epss_percentile": 0.08256}, "CVE-2025-27847": {"epss_score": 0.0003, "epss_percentile": 0.08256}, "CVE-2025-27867": {"epss_score": 0.00447, "epss_percentile": 0.62935}, "CVE-2025-27888": {"epss_score": 0.01092, "epss_percentile": 0.77467}, "CVE-2025-27889": {"epss_score": 0.00034, "epss_percentile": 0.09782}, "CVE-2025-27891": {"epss_score": 0.00066, "epss_percentile": 0.20681}, "CVE-2025-27892": {"epss_score": 0.02119, "epss_percentile": 0.83671}, "CVE-2025-27893": {"epss_score": 0.00066, "epss_percentile": 0.20805}, "CVE-2025-27906": {"epss_score": 0.00039, "epss_percentile": 0.11614}, "CVE-2025-27907": {"epss_score": 0.00039, "epss_percentile": 0.11543}, "CVE-2025-27909": {"epss_score": 0.00051, "epss_percentile": 0.16046}, "CVE-2025-27910": {"epss_score": 0.00056, "epss_percentile": 0.17868}, "CVE-2025-27911": {"epss_score": 0.00154, "epss_percentile": 0.36731}, "CVE-2025-27912": {"epss_score": 0.00055, "epss_percentile": 0.17517}, "CVE-2025-27913": {"epss_score": 0.00063, "epss_percentile": 0.19928}, "CVE-2025-27914": {"epss_score": 0.00061, "epss_percentile": 0.19439}, "CVE-2025-27915": {"epss_score": 0.26521, "epss_percentile": 0.96153}, "CVE-2025-27916": {"epss_score": 0.00051, "epss_percentile": 0.16279}, "CVE-2025-27917": {"epss_score": 0.00269, "epss_percentile": 0.50126}, "CVE-2025-27918": {"epss_score": 0.00078, "epss_percentile": 0.238}, "CVE-2025-27919": {"epss_score": 0.00055, "epss_percentile": 0.17489}, "CVE-2025-27920": {"epss_score": 0.46075, "epss_percentile": 0.97521}, "CVE-2025-27921": {"epss_score": 0.00028, "epss_percentile": 0.07244}, "CVE-2025-27924": {"epss_score": 0.00064, "epss_percentile": 0.20353}, "CVE-2025-27925": {"epss_score": 0.0017, "epss_percentile": 0.38745}, "CVE-2025-27926": {"epss_score": 0.00033, "epss_percentile": 0.09249}, "CVE-2025-27927": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-27929": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-27930": {"epss_score": 0.00013, "epss_percentile": 0.01556}, "CVE-2025-27931": {"epss_score": 0.00037, "epss_percentile": 0.10632}, "CVE-2025-27932": {"epss_score": 0.00213, "epss_percentile": 0.43848}, "CVE-2025-27933": {"epss_score": 0.00091, "epss_percentile": 0.26238}, "CVE-2025-27934": {"epss_score": 0.00086, "epss_percentile": 0.25377}, "CVE-2025-27935": {"epss_score": 0.00104, "epss_percentile": 0.29185}, "CVE-2025-27936": {"epss_score": 0.00057, "epss_percentile": 0.1801}, "CVE-2025-27937": {"epss_score": 0.00053, "epss_percentile": 0.16719}, "CVE-2025-27938": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-27939": {"epss_score": 0.00072, "epss_percentile": 0.22332}, "CVE-2025-27953": {"epss_score": 0.00143, "epss_percentile": 0.35182}, "CVE-2025-27954": {"epss_score": 0.00163, "epss_percentile": 0.3776}, "CVE-2025-27955": {"epss_score": 0.00162, "epss_percentile": 0.37631}, "CVE-2025-27956": {"epss_score": 0.01722, "epss_percentile": 0.81937}, "CVE-2025-27980": {"epss_score": 0.00073, "epss_percentile": 0.22613}, "CVE-2025-27997": {"epss_score": 0.00024, "epss_percentile": 0.05809}, "CVE-2025-27998": {"epss_score": 0.00027, "epss_percentile": 0.06742}, "CVE-2025-28009": {"epss_score": 0.00055, "epss_percentile": 0.17487}, "CVE-2025-28010": {"epss_score": 0.00072, "epss_percentile": 0.22246}, "CVE-2025-28011": {"epss_score": 0.00096, "epss_percentile": 0.27329}, "CVE-2025-28015": {"epss_score": 0.00111, "epss_percentile": 0.30279}, "CVE-2025-28016": {"epss_score": 0.00068, "epss_percentile": 0.21209}, "CVE-2025-28017": {"epss_score": 0.03526, "epss_percentile": 0.87295}, "CVE-2025-28018": {"epss_score": 0.00167, "epss_percentile": 0.38354}, "CVE-2025-28019": {"epss_score": 0.00124, "epss_percentile": 0.32371}, "CVE-2025-28020": {"epss_score": 0.00124, "epss_percentile": 0.32371}, "CVE-2025-28021": {"epss_score": 0.00124, "epss_percentile": 0.32371}, "CVE-2025-28022": {"epss_score": 0.00124, "epss_percentile": 0.32371}, "CVE-2025-28024": {"epss_score": 0.00205, "epss_percentile": 0.42671}, "CVE-2025-28025": {"epss_score": 0.00124, "epss_percentile": 0.32371}, "CVE-2025-28026": {"epss_score": 0.00124, "epss_percentile": 0.32371}, "CVE-2025-28027": {"epss_score": 0.00124, "epss_percentile": 0.32371}, "CVE-2025-28028": {"epss_score": 0.00124, "epss_percentile": 0.32371}, "CVE-2025-28029": {"epss_score": 0.00124, "epss_percentile": 0.32371}, "CVE-2025-28030": {"epss_score": 0.0014, "epss_percentile": 0.34757}, "CVE-2025-28031": {"epss_score": 0.00108, "epss_percentile": 0.2979}, "CVE-2025-28032": {"epss_score": 0.00167, "epss_percentile": 0.38354}, "CVE-2025-28033": {"epss_score": 0.00124, "epss_percentile": 0.32371}, "CVE-2025-28034": {"epss_score": 0.03263, "epss_percentile": 0.86779}, "CVE-2025-28035": {"epss_score": 0.03263, "epss_percentile": 0.86779}, "CVE-2025-28036": {"epss_score": 0.03263, "epss_percentile": 0.86779}, "CVE-2025-28037": {"epss_score": 0.03869, "epss_percentile": 0.87878}, "CVE-2025-28038": {"epss_score": 0.04263, "epss_percentile": 0.88466}, "CVE-2025-28039": {"epss_score": 0.03869, "epss_percentile": 0.87878}, "CVE-2025-28041": {"epss_score": 0.00124, "epss_percentile": 0.32443}, "CVE-2025-28055": {"epss_score": 0.00101, "epss_percentile": 0.28638}, "CVE-2025-28056": {"epss_score": 0.00056, "epss_percentile": 0.17755}, "CVE-2025-28057": {"epss_score": 0.00051, "epss_percentile": 0.16211}, "CVE-2025-28059": {"epss_score": 0.00264, "epss_percentile": 0.4957}, "CVE-2025-28062": {"epss_score": 0.00126, "epss_percentile": 0.32696}, "CVE-2025-28072": {"epss_score": 0.00751, "epss_percentile": 0.72647}, "CVE-2025-28073": {"epss_score": 0.00041, "epss_percentile": 0.1225}, "CVE-2025-28074": {"epss_score": 0.00041, "epss_percentile": 0.1225}, "CVE-2025-28076": {"epss_score": 0.00052, "epss_percentile": 0.16609}, "CVE-2025-28087": {"epss_score": 0.00089, "epss_percentile": 0.25918}, "CVE-2025-28089": {"epss_score": 0.00094, "epss_percentile": 0.27003}, "CVE-2025-28090": {"epss_score": 0.00094, "epss_percentile": 0.27003}, "CVE-2025-28091": {"epss_score": 0.00094, "epss_percentile": 0.27003}, "CVE-2025-28092": {"epss_score": 0.00087, "epss_percentile": 0.25516}, "CVE-2025-28093": {"epss_score": 0.00087, "epss_percentile": 0.25516}, "CVE-2025-28094": {"epss_score": 0.00053, "epss_percentile": 0.16962}, "CVE-2025-28096": {"epss_score": 0.00044, "epss_percentile": 0.13462}, "CVE-2025-28097": {"epss_score": 0.0005, "epss_percentile": 0.15973}, "CVE-2025-28099": {"epss_score": 0.00103, "epss_percentile": 0.29071}, "CVE-2025-28100": {"epss_score": 0.00186, "epss_percentile": 0.40617}, "CVE-2025-28101": {"epss_score": 0.00071, "epss_percentile": 0.22016}, "CVE-2025-28102": {"epss_score": 0.00053, "epss_percentile": 0.16872}, "CVE-2025-28103": {"epss_score": 0.00049, "epss_percentile": 0.15646}, "CVE-2025-28104": {"epss_score": 0.00092, "epss_percentile": 0.26483}, "CVE-2025-28121": {"epss_score": 0.00435, "epss_percentile": 0.62366}, "CVE-2025-28128": {"epss_score": 0.00068, "epss_percentile": 0.21259}, "CVE-2025-28129": {"epss_score": 0.00047, "epss_percentile": 0.14479}, "CVE-2025-28131": {"epss_score": 0.00052, "epss_percentile": 0.16565}, "CVE-2025-28132": {"epss_score": 0.00056, "epss_percentile": 0.17799}, "CVE-2025-28135": {"epss_score": 0.0015, "epss_percentile": 0.36097}, "CVE-2025-28136": {"epss_score": 0.00068, "epss_percentile": 0.21416}, "CVE-2025-28137": {"epss_score": 0.06322, "epss_percentile": 0.9067}, "CVE-2025-28138": {"epss_score": 0.04084, "epss_percentile": 0.88224}, "CVE-2025-28142": {"epss_score": 0.04774, "epss_percentile": 0.8913}, "CVE-2025-28143": {"epss_score": 0.04774, "epss_percentile": 0.8913}, "CVE-2025-28144": {"epss_score": 0.00138, "epss_percentile": 0.34423}, "CVE-2025-28145": {"epss_score": 0.04774, "epss_percentile": 0.8913}, "CVE-2025-28146": {"epss_score": 0.04726, "epss_percentile": 0.89065}, "CVE-2025-28168": {"epss_score": 0.00047, "epss_percentile": 0.14802}, "CVE-2025-28169": {"epss_score": 0.00055, "epss_percentile": 0.17499}, "CVE-2025-28170": {"epss_score": 0.00076, "epss_percentile": 0.23215}, "CVE-2025-28171": {"epss_score": 0.00049, "epss_percentile": 0.15375}, "CVE-2025-28172": {"epss_score": 0.00044, "epss_percentile": 0.13521}, "CVE-2025-28197": {"epss_score": 0.00073, "epss_percentile": 0.22524}, "CVE-2025-28198": {"epss_score": 0.00123, "epss_percentile": 0.32306}, "CVE-2025-28200": {"epss_score": 0.00084, "epss_percentile": 0.24888}, "CVE-2025-28201": {"epss_score": 0.00041, "epss_percentile": 0.12373}, "CVE-2025-28202": {"epss_score": 0.00036, "epss_percentile": 0.10505}, "CVE-2025-28203": {"epss_score": 0.00388, "epss_percentile": 0.59373}, "CVE-2025-28219": {"epss_score": 0.00501, "epss_percentile": 0.65338}, "CVE-2025-28220": {"epss_score": 0.00174, "epss_percentile": 0.39196}, "CVE-2025-28221": {"epss_score": 0.00174, "epss_percentile": 0.39196}, "CVE-2025-28228": {"epss_score": 0.04857, "epss_percentile": 0.89219}, "CVE-2025-28229": {"epss_score": 0.00108, "epss_percentile": 0.29881}, "CVE-2025-28230": {"epss_score": 0.00092, "epss_percentile": 0.26483}, "CVE-2025-28231": {"epss_score": 0.00081, "epss_percentile": 0.24293}, "CVE-2025-28232": {"epss_score": 0.00073, "epss_percentile": 0.22593}, "CVE-2025-28233": {"epss_score": 0.00064, "epss_percentile": 0.20157}, "CVE-2025-28235": {"epss_score": 0.0007, "epss_percentile": 0.21748}, "CVE-2025-28236": {"epss_score": 0.00298, "epss_percentile": 0.52808}, "CVE-2025-28237": {"epss_score": 0.00081, "epss_percentile": 0.24255}, "CVE-2025-28238": {"epss_score": 0.00086, "epss_percentile": 0.25327}, "CVE-2025-28242": {"epss_score": 0.00086, "epss_percentile": 0.25327}, "CVE-2025-28243": {"epss_score": 0.00053, "epss_percentile": 0.16994}, "CVE-2025-28244": {"epss_score": 0.00131, "epss_percentile": 0.33401}, "CVE-2025-28245": {"epss_score": 0.00043, "epss_percentile": 0.13319}, "CVE-2025-28254": {"epss_score": 0.00068, "epss_percentile": 0.21414}, "CVE-2025-28256": {"epss_score": 0.02108, "epss_percentile": 0.8364}, "CVE-2025-28354": {"epss_score": 0.00089, "epss_percentile": 0.25874}, "CVE-2025-28355": {"epss_score": 0.00058, "epss_percentile": 0.18428}, "CVE-2025-28357": {"epss_score": 0.00272, "epss_percentile": 0.50361}, "CVE-2025-28361": {"epss_score": 0.00089, "epss_percentile": 0.25881}, "CVE-2025-28367": {"epss_score": 0.10002, "epss_percentile": 0.92811}, "CVE-2025-28371": {"epss_score": 0.00077, "epss_percentile": 0.23346}, "CVE-2025-28380": {"epss_score": 0.00057, "epss_percentile": 0.18195}, "CVE-2025-28381": {"epss_score": 0.00084, "epss_percentile": 0.2483}, "CVE-2025-28382": {"epss_score": 0.00691, "epss_percentile": 0.71268}, "CVE-2025-28384": {"epss_score": 0.00727, "epss_percentile": 0.72098}, "CVE-2025-28386": {"epss_score": 0.00854, "epss_percentile": 0.74457}, "CVE-2025-28388": {"epss_score": 0.00128, "epss_percentile": 0.33007}, "CVE-2025-28389": {"epss_score": 0.00165, "epss_percentile": 0.38129}, "CVE-2025-28395": {"epss_score": 0.00156, "epss_percentile": 0.36962}, "CVE-2025-28398": {"epss_score": 0.00156, "epss_percentile": 0.36962}, "CVE-2025-28399": {"epss_score": 0.00363, "epss_percentile": 0.57839}, "CVE-2025-28400": {"epss_score": 0.00155, "epss_percentile": 0.36764}, "CVE-2025-28401": {"epss_score": 0.00155, "epss_percentile": 0.36764}, "CVE-2025-28402": {"epss_score": 0.00363, "epss_percentile": 0.57839}, "CVE-2025-28403": {"epss_score": 0.00315, "epss_percentile": 0.54195}, "CVE-2025-28405": {"epss_score": 0.00363, "epss_percentile": 0.57839}, "CVE-2025-28406": {"epss_score": 0.00363, "epss_percentile": 0.57839}, "CVE-2025-28407": {"epss_score": 0.00266, "epss_percentile": 0.4988}, "CVE-2025-28408": {"epss_score": 0.00363, "epss_percentile": 0.57839}, "CVE-2025-28409": {"epss_score": 0.00266, "epss_percentile": 0.4988}, "CVE-2025-28410": {"epss_score": 0.00363, "epss_percentile": 0.57839}, "CVE-2025-28411": {"epss_score": 0.00363, "epss_percentile": 0.57839}, "CVE-2025-28412": {"epss_score": 0.00363, "epss_percentile": 0.57839}, "CVE-2025-28413": {"epss_score": 0.00363, "epss_percentile": 0.57839}, "CVE-2025-28855": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-28856": {"epss_score": 0.00054, "epss_percentile": 0.17065}, "CVE-2025-28857": {"epss_score": 0.00046, "epss_percentile": 0.14294}, "CVE-2025-28858": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-28859": {"epss_score": 0.00054, "epss_percentile": 0.17065}, "CVE-2025-28860": {"epss_score": 0.00046, "epss_percentile": 0.14294}, "CVE-2025-28861": {"epss_score": 0.00046, "epss_percentile": 0.14294}, "CVE-2025-28862": {"epss_score": 0.00054, "epss_percentile": 0.17065}, "CVE-2025-28863": {"epss_score": 0.00054, "epss_percentile": 0.17065}, "CVE-2025-28864": {"epss_score": 0.00054, "epss_percentile": 0.17065}, "CVE-2025-28865": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-28866": {"epss_score": 0.00054, "epss_percentile": 0.17065}, "CVE-2025-28867": {"epss_score": 0.00054, "epss_percentile": 0.17065}, "CVE-2025-28868": {"epss_score": 0.00054, "epss_percentile": 0.17065}, "CVE-2025-28869": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-28870": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-28871": {"epss_score": 0.00078, "epss_percentile": 0.23575}, "CVE-2025-28872": {"epss_score": 0.00209, "epss_percentile": 0.43374}, "CVE-2025-28873": {"epss_score": 0.00052, "epss_percentile": 0.16468}, "CVE-2025-28874": {"epss_score": 0.00113, "epss_percentile": 0.30706}, "CVE-2025-28875": {"epss_score": 0.00078, "epss_percentile": 0.23575}, "CVE-2025-28876": {"epss_score": 0.00054, "epss_percentile": 0.17065}, "CVE-2025-28877": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-28878": {"epss_score": 0.0008, "epss_percentile": 0.24146}, "CVE-2025-28879": {"epss_score": 0.00077, "epss_percentile": 0.23399}, "CVE-2025-28880": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-28881": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-28882": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-28883": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28884": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-28885": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-28886": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-28887": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-28888": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-28889": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-28890": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-28891": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28892": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28893": {"epss_score": 0.00084, "epss_percentile": 0.24911}, "CVE-2025-28894": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28895": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-28896": {"epss_score": 0.00087, "epss_percentile": 0.2549}, "CVE-2025-28897": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28898": {"epss_score": 0.00082, "epss_percentile": 0.24574}, "CVE-2025-28899": {"epss_score": 0.00046, "epss_percentile": 0.14074}, "CVE-2025-28900": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28901": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28902": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-28903": {"epss_score": 0.00046, "epss_percentile": 0.14074}, "CVE-2025-28904": {"epss_score": 0.00082, "epss_percentile": 0.24574}, "CVE-2025-28905": {"epss_score": 0.00094, "epss_percentile": 0.26949}, "CVE-2025-28906": {"epss_score": 0.01172, "epss_percentile": 0.78229}, "CVE-2025-28907": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-28908": {"epss_score": 0.00086, "epss_percentile": 0.25335}, "CVE-2025-28909": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-28910": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-28911": {"epss_score": 0.00046, "epss_percentile": 0.14074}, "CVE-2025-28912": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-28913": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-28914": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-28915": {"epss_score": 0.21414, "epss_percentile": 0.95514}, "CVE-2025-28916": {"epss_score": 0.00255, "epss_percentile": 0.48649}, "CVE-2025-28917": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-28918": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-28919": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-28920": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-28921": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-28922": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28923": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28924": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-28925": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28926": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-28927": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-28928": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-28929": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-28930": {"epss_score": 0.00091, "epss_percentile": 0.26374}, "CVE-2025-28931": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28932": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28933": {"epss_score": 0.00046, "epss_percentile": 0.14264}, "CVE-2025-28934": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-28935": {"epss_score": 0.00066, "epss_percentile": 0.20723}, "CVE-2025-28936": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-28937": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-28938": {"epss_score": 0.00123, "epss_percentile": 0.32222}, "CVE-2025-28939": {"epss_score": 0.00096, "epss_percentile": 0.27349}, "CVE-2025-28940": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-28941": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-28942": {"epss_score": 0.00079, "epss_percentile": 0.23978}, "CVE-2025-28943": {"epss_score": 0.00089, "epss_percentile": 0.25849}, "CVE-2025-28944": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-28945": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-28946": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-28947": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-28948": {"epss_score": 0.00016, "epss_percentile": 0.03021}, "CVE-2025-28949": {"epss_score": 0.00018, "epss_percentile": 0.04012}, "CVE-2025-28950": {"epss_score": 0.00016, "epss_percentile": 0.03021}, "CVE-2025-28951": {"epss_score": 0.00056, "epss_percentile": 0.17792}, "CVE-2025-28952": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-28953": {"epss_score": 0.00033, "epss_percentile": 0.09353}, "CVE-2025-28954": {"epss_score": 0.00018, "epss_percentile": 0.03629}, "CVE-2025-28955": {"epss_score": 0.00067, "epss_percentile": 0.2118}, "CVE-2025-28956": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-28957": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-28958": {"epss_score": 0.00016, "epss_percentile": 0.03021}, "CVE-2025-28959": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-28960": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-28961": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-28962": {"epss_score": 0.00033, "epss_percentile": 0.09379}, "CVE-2025-28963": {"epss_score": 0.00027, "epss_percentile": 0.06951}, "CVE-2025-28964": {"epss_score": 0.00016, "epss_percentile": 0.03021}, "CVE-2025-28965": {"epss_score": 0.00051, "epss_percentile": 0.16316}, "CVE-2025-28966": {"epss_score": 0.00016, "epss_percentile": 0.03021}, "CVE-2025-28967": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-28968": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-28969": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-28970": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-28971": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-28972": {"epss_score": 0.00032, "epss_percentile": 0.08798}, "CVE-2025-28973": {"epss_score": 0.00048, "epss_percentile": 0.15125}, "CVE-2025-28974": {"epss_score": 0.00016, "epss_percentile": 0.03021}, "CVE-2025-28975": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-28976": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-28977": {"epss_score": 0.00053, "epss_percentile": 0.1685}, "CVE-2025-28978": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-28979": {"epss_score": 0.00108, "epss_percentile": 0.29873}, "CVE-2025-28980": {"epss_score": 0.00058, "epss_percentile": 0.18297}, "CVE-2025-28981": {"epss_score": 0.00016, "epss_percentile": 0.03021}, "CVE-2025-28982": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-28983": {"epss_score": 0.00036, "epss_percentile": 0.10543}, "CVE-2025-28984": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-28985": {"epss_score": 0.00054, "epss_percentile": 0.17355}, "CVE-2025-28986": {"epss_score": 0.00019, "epss_percentile": 0.04207}, "CVE-2025-28987": {"epss_score": 0.00046, "epss_percentile": 0.1415}, "CVE-2025-28988": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-28989": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-28990": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-28991": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-28992": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-28993": {"epss_score": 0.00048, "epss_percentile": 0.15033}, "CVE-2025-28994": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-28995": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-28996": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-28997": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-28998": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-28999": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-29000": {"epss_score": 0.00043, "epss_percentile": 0.13007}, "CVE-2025-29001": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-29002": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-29003": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-29004": {"epss_score": 0.00039, "epss_percentile": 0.11622}, "CVE-2025-29005": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-29006": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-29007": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-29008": {"epss_score": 0.00027, "epss_percentile": 0.07152}, "CVE-2025-29009": {"epss_score": 0.0007, "epss_percentile": 0.21693}, "CVE-2025-29010": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-29011": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-29012": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-29013": {"epss_score": 0.00054, "epss_percentile": 0.17355}, "CVE-2025-29014": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-29015": {"epss_score": 0.00053, "epss_percentile": 0.16872}, "CVE-2025-29017": {"epss_score": 0.0076, "epss_percentile": 0.72802}, "CVE-2025-29018": {"epss_score": 0.00054, "epss_percentile": 0.17222}, "CVE-2025-29029": {"epss_score": 0.00191, "epss_percentile": 0.41267}, "CVE-2025-29030": {"epss_score": 0.00191, "epss_percentile": 0.41267}, "CVE-2025-29031": {"epss_score": 0.00191, "epss_percentile": 0.41267}, "CVE-2025-29032": {"epss_score": 0.00122, "epss_percentile": 0.321}, "CVE-2025-29033": {"epss_score": 0.00184, "epss_percentile": 0.40455}, "CVE-2025-29036": {"epss_score": 0.001, "epss_percentile": 0.2855}, "CVE-2025-29039": {"epss_score": 0.01152, "epss_percentile": 0.7805}, "CVE-2025-29040": {"epss_score": 0.02833, "epss_percentile": 0.8578}, "CVE-2025-29041": {"epss_score": 0.02833, "epss_percentile": 0.8578}, "CVE-2025-29042": {"epss_score": 0.02833, "epss_percentile": 0.8578}, "CVE-2025-29043": {"epss_score": 0.02833, "epss_percentile": 0.8578}, "CVE-2025-29044": {"epss_score": 0.01078, "epss_percentile": 0.77345}, "CVE-2025-29045": {"epss_score": 0.01078, "epss_percentile": 0.77345}, "CVE-2025-29046": {"epss_score": 0.01078, "epss_percentile": 0.77345}, "CVE-2025-29047": {"epss_score": 0.01078, "epss_percentile": 0.77345}, "CVE-2025-29049": {"epss_score": 0.00164, "epss_percentile": 0.37917}, "CVE-2025-29058": {"epss_score": 0.00678, "epss_percentile": 0.70984}, "CVE-2025-29062": {"epss_score": 0.01914, "epss_percentile": 0.82845}, "CVE-2025-29063": {"epss_score": 0.01691, "epss_percentile": 0.81777}, "CVE-2025-29064": {"epss_score": 0.01046, "epss_percentile": 0.77025}, "CVE-2025-29069": {"epss_score": 0.00085, "epss_percentile": 0.25146}, "CVE-2025-29070": {"epss_score": 0.00189, "epss_percentile": 0.40972}, "CVE-2025-29072": {"epss_score": 0.00489, "epss_percentile": 0.64873}, "CVE-2025-29083": {"epss_score": 0.001, "epss_percentile": 0.28514}, "CVE-2025-29084": {"epss_score": 0.001, "epss_percentile": 0.28514}, "CVE-2025-29085": {"epss_score": 0.18259, "epss_percentile": 0.94983}, "CVE-2025-29087": {"epss_score": 0.00055, "epss_percentile": 0.17564}, "CVE-2025-29088": {"epss_score": 0.00025, "epss_percentile": 0.06209}, "CVE-2025-29089": {"epss_score": 0.00063, "epss_percentile": 0.19905}, "CVE-2025-29093": {"epss_score": 0.00264, "epss_percentile": 0.49712}, "CVE-2025-29094": {"epss_score": 0.00091, "epss_percentile": 0.26254}, "CVE-2025-29100": {"epss_score": 0.00141, "epss_percentile": 0.34818}, "CVE-2025-29101": {"epss_score": 0.00153, "epss_percentile": 0.36625}, "CVE-2025-29118": {"epss_score": 0.00058, "epss_percentile": 0.18379}, "CVE-2025-29121": {"epss_score": 0.00181, "epss_percentile": 0.40032}, "CVE-2025-29135": {"epss_score": 0.00959, "epss_percentile": 0.75949}, "CVE-2025-29137": {"epss_score": 0.00173, "epss_percentile": 0.39052}, "CVE-2025-29149": {"epss_score": 0.00181, "epss_percentile": 0.40032}, "CVE-2025-29150": {"epss_score": 0.0013, "epss_percentile": 0.33327}, "CVE-2025-29152": {"epss_score": 0.00054, "epss_percentile": 0.17267}, "CVE-2025-29153": {"epss_score": 0.00058, "epss_percentile": 0.18429}, "CVE-2025-29154": {"epss_score": 0.00193, "epss_percentile": 0.41404}, "CVE-2025-29155": {"epss_score": 0.00128, "epss_percentile": 0.3299}, "CVE-2025-29156": {"epss_score": 0.00093, "epss_percentile": 0.26724}, "CVE-2025-29157": {"epss_score": 0.00161, "epss_percentile": 0.37606}, "CVE-2025-29180": {"epss_score": 0.0005, "epss_percentile": 0.15895}, "CVE-2025-29181": {"epss_score": 0.0005, "epss_percentile": 0.15895}, "CVE-2025-29189": {"epss_score": 0.00182, "epss_percentile": 0.40151}, "CVE-2025-29192": {"epss_score": 0.00074, "epss_percentile": 0.22778}, "CVE-2025-29208": {"epss_score": 0.00066, "epss_percentile": 0.20868}, "CVE-2025-29209": {"epss_score": 0.00618, "epss_percentile": 0.69383}, "CVE-2025-29213": {"epss_score": 0.00099, "epss_percentile": 0.2831}, "CVE-2025-29214": {"epss_score": 0.00181, "epss_percentile": 0.40032}, "CVE-2025-29215": {"epss_score": 0.00192, "epss_percentile": 0.41287}, "CVE-2025-29217": {"epss_score": 0.00194, "epss_percentile": 0.41583}, "CVE-2025-29218": {"epss_score": 0.00176, "epss_percentile": 0.39412}, "CVE-2025-29223": {"epss_score": 0.0065, "epss_percentile": 0.70262}, "CVE-2025-29226": {"epss_score": 0.0065, "epss_percentile": 0.70262}, "CVE-2025-29227": {"epss_score": 0.0065, "epss_percentile": 0.70262}, "CVE-2025-29228": {"epss_score": 0.00288, "epss_percentile": 0.51873}, "CVE-2025-29229": {"epss_score": 0.00288, "epss_percentile": 0.51873}, "CVE-2025-29230": {"epss_score": 0.00704, "epss_percentile": 0.71558}, "CVE-2025-29231": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-29266": {"epss_score": 0.00092, "epss_percentile": 0.26585}, "CVE-2025-29267": {"epss_score": 0.00047, "epss_percentile": 0.14578}, "CVE-2025-29268": {"epss_score": 0.00054, "epss_percentile": 0.17086}, "CVE-2025-29269": {"epss_score": 0.00426, "epss_percentile": 0.61745}, "CVE-2025-29270": {"epss_score": 0.00062, "epss_percentile": 0.19687}, "CVE-2025-29280": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2025-29281": {"epss_score": 0.00246, "epss_percentile": 0.47774}, "CVE-2025-29287": {"epss_score": 0.00488, "epss_percentile": 0.64856}, "CVE-2025-29306": {"epss_score": 0.85317, "epss_percentile": 0.99328}, "CVE-2025-29310": {"epss_score": 0.00066, "epss_percentile": 0.20744}, "CVE-2025-29311": {"epss_score": 0.00084, "epss_percentile": 0.2502}, "CVE-2025-29312": {"epss_score": 0.00053, "epss_percentile": 0.17029}, "CVE-2025-29313": {"epss_score": 0.00106, "epss_percentile": 0.2951}, "CVE-2025-29314": {"epss_score": 0.00045, "epss_percentile": 0.14041}, "CVE-2025-29315": {"epss_score": 0.00109, "epss_percentile": 0.29987}, "CVE-2025-29316": {"epss_score": 0.00028, "epss_percentile": 0.07262}, "CVE-2025-29322": {"epss_score": 0.00068, "epss_percentile": 0.21403}, "CVE-2025-29331": {"epss_score": 0.00374, "epss_percentile": 0.58544}, "CVE-2025-29339": {"epss_score": 0.00046, "epss_percentile": 0.14295}, "CVE-2025-29357": {"epss_score": 0.00089, "epss_percentile": 0.25825}, "CVE-2025-29358": {"epss_score": 0.00097, "epss_percentile": 0.27466}, "CVE-2025-29359": {"epss_score": 0.00089, "epss_percentile": 0.25825}, "CVE-2025-29360": {"epss_score": 0.00089, "epss_percentile": 0.25825}, "CVE-2025-29361": {"epss_score": 0.00097, "epss_percentile": 0.27466}, "CVE-2025-29362": {"epss_score": 0.00089, "epss_percentile": 0.25825}, "CVE-2025-29363": {"epss_score": 0.00089, "epss_percentile": 0.25825}, "CVE-2025-29364": {"epss_score": 0.00092, "epss_percentile": 0.26511}, "CVE-2025-29365": {"epss_score": 0.00111, "epss_percentile": 0.30256}, "CVE-2025-29366": {"epss_score": 0.00089, "epss_percentile": 0.25903}, "CVE-2025-29369": {"epss_score": 0.00089, "epss_percentile": 0.25918}, "CVE-2025-29384": {"epss_score": 0.14625, "epss_percentile": 0.94253}, "CVE-2025-29385": {"epss_score": 0.01134, "epss_percentile": 0.77889}, "CVE-2025-29386": {"epss_score": 0.01134, "epss_percentile": 0.77889}, "CVE-2025-29387": {"epss_score": 0.00478, "epss_percentile": 0.64402}, "CVE-2025-29389": {"epss_score": 0.00059, "epss_percentile": 0.18781}, "CVE-2025-29390": {"epss_score": 0.00082, "epss_percentile": 0.24479}, "CVE-2025-29391": {"epss_score": 0.00082, "epss_percentile": 0.24418}, "CVE-2025-29394": {"epss_score": 0.00257, "epss_percentile": 0.48849}, "CVE-2025-29401": {"epss_score": 0.00626, "epss_percentile": 0.69619}, "CVE-2025-29405": {"epss_score": 0.00168, "epss_percentile": 0.3845}, "CVE-2025-29410": {"epss_score": 0.0007, "epss_percentile": 0.21675}, "CVE-2025-29411": {"epss_score": 0.00649, "epss_percentile": 0.70226}, "CVE-2025-29412": {"epss_score": 0.00072, "epss_percentile": 0.2224}, "CVE-2025-29420": {"epss_score": 0.00809, "epss_percentile": 0.73711}, "CVE-2025-29421": {"epss_score": 0.00074, "epss_percentile": 0.22789}, "CVE-2025-29425": {"epss_score": 0.00063, "epss_percentile": 0.19926}, "CVE-2025-29426": {"epss_score": 0.0003, "epss_percentile": 0.08276}, "CVE-2025-29427": {"epss_score": 0.00088, "epss_percentile": 0.25727}, "CVE-2025-29429": {"epss_score": 0.0007, "epss_percentile": 0.21675}, "CVE-2025-29430": {"epss_score": 0.00066, "epss_percentile": 0.20741}, "CVE-2025-29431": {"epss_score": 0.00032, "epss_percentile": 0.08817}, "CVE-2025-29446": {"epss_score": 0.00025, "epss_percentile": 0.06116}, "CVE-2025-29448": {"epss_score": 0.00328, "epss_percentile": 0.55266}, "CVE-2025-29449": {"epss_score": 0.0009, "epss_percentile": 0.26139}, "CVE-2025-29450": {"epss_score": 0.0009, "epss_percentile": 0.26139}, "CVE-2025-29451": {"epss_score": 0.00256, "epss_percentile": 0.48839}, "CVE-2025-29452": {"epss_score": 0.00256, "epss_percentile": 0.48839}, "CVE-2025-29453": {"epss_score": 0.0009, "epss_percentile": 0.26139}, "CVE-2025-29454": {"epss_score": 0.0009, "epss_percentile": 0.26139}, "CVE-2025-29455": {"epss_score": 0.0009, "epss_percentile": 0.26139}, "CVE-2025-29456": {"epss_score": 0.0009, "epss_percentile": 0.26139}, "CVE-2025-29457": {"epss_score": 0.00259, "epss_percentile": 0.49029}, "CVE-2025-29458": {"epss_score": 0.00259, "epss_percentile": 0.49029}, "CVE-2025-29459": {"epss_score": 0.00256, "epss_percentile": 0.48839}, "CVE-2025-29460": {"epss_score": 0.00205, "epss_percentile": 0.42702}, "CVE-2025-29461": {"epss_score": 0.00256, "epss_percentile": 0.48839}, "CVE-2025-29462": {"epss_score": 0.00146, "epss_percentile": 0.35592}, "CVE-2025-29471": {"epss_score": 0.10791, "epss_percentile": 0.93104}, "CVE-2025-29476": {"epss_score": 0.00054, "epss_percentile": 0.17289}, "CVE-2025-29477": {"epss_score": 0.00021, "epss_percentile": 0.04913}, "CVE-2025-29478": {"epss_score": 0.00028, "epss_percentile": 0.07528}, "CVE-2025-29480": {"epss_score": 0.00028, "epss_percentile": 0.07528}, "CVE-2025-29481": {"epss_score": 0.00031, "epss_percentile": 0.08694}, "CVE-2025-29482": {"epss_score": 0.00034, "epss_percentile": 0.09665}, "CVE-2025-29483": {"epss_score": 0.0008, "epss_percentile": 0.2415}, "CVE-2025-29484": {"epss_score": 0.00152, "epss_percentile": 0.36492}, "CVE-2025-29485": {"epss_score": 0.00097, "epss_percentile": 0.27548}, "CVE-2025-29486": {"epss_score": 0.0009, "epss_percentile": 0.26152}, "CVE-2025-29487": {"epss_score": 0.00139, "epss_percentile": 0.34664}, "CVE-2025-29488": {"epss_score": 0.00083, "epss_percentile": 0.24624}, "CVE-2025-29489": {"epss_score": 0.00083, "epss_percentile": 0.24624}, "CVE-2025-29490": {"epss_score": 0.00089, "epss_percentile": 0.25869}, "CVE-2025-29491": {"epss_score": 0.00089, "epss_percentile": 0.25869}, "CVE-2025-29492": {"epss_score": 0.00083, "epss_percentile": 0.24624}, "CVE-2025-29493": {"epss_score": 0.00089, "epss_percentile": 0.25869}, "CVE-2025-29494": {"epss_score": 0.00089, "epss_percentile": 0.25869}, "CVE-2025-29496": {"epss_score": 0.00089, "epss_percentile": 0.25869}, "CVE-2025-29497": {"epss_score": 0.00083, "epss_percentile": 0.24624}, "CVE-2025-29504": {"epss_score": 0.00024, "epss_percentile": 0.05686}, "CVE-2025-29509": {"epss_score": 0.00182, "epss_percentile": 0.40141}, "CVE-2025-29512": {"epss_score": 0.00048, "epss_percentile": 0.15281}, "CVE-2025-29513": {"epss_score": 0.00096, "epss_percentile": 0.2741}, "CVE-2025-29514": {"epss_score": 0.00123, "epss_percentile": 0.32268}, "CVE-2025-29515": {"epss_score": 0.0028, "epss_percentile": 0.51063}, "CVE-2025-29516": {"epss_score": 0.00327, "epss_percentile": 0.55097}, "CVE-2025-29517": {"epss_score": 0.00169, "epss_percentile": 0.38533}, "CVE-2025-29519": {"epss_score": 0.01595, "epss_percentile": 0.81238}, "CVE-2025-29520": {"epss_score": 0.00072, "epss_percentile": 0.22333}, "CVE-2025-29521": {"epss_score": 0.00132, "epss_percentile": 0.33555}, "CVE-2025-29522": {"epss_score": 0.01684, "epss_percentile": 0.81746}, "CVE-2025-29523": {"epss_score": 0.0038, "epss_percentile": 0.58969}, "CVE-2025-29524": {"epss_score": 0.00049, "epss_percentile": 0.15332}, "CVE-2025-29525": {"epss_score": 0.00051, "epss_percentile": 0.16308}, "CVE-2025-29526": {"epss_score": 0.00038, "epss_percentile": 0.11323}, "CVE-2025-29529": {"epss_score": 0.00041, "epss_percentile": 0.12384}, "CVE-2025-29534": {"epss_score": 0.00303, "epss_percentile": 0.53219}, "CVE-2025-29547": {"epss_score": 0.00085, "epss_percentile": 0.25141}, "CVE-2025-29556": {"epss_score": 0.00059, "epss_percentile": 0.18682}, "CVE-2025-29557": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-29568": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2025-29570": {"epss_score": 0.00024, "epss_percentile": 0.05686}, "CVE-2025-29573": {"epss_score": 0.00037, "epss_percentile": 0.10777}, "CVE-2025-29592": {"epss_score": 0.0021, "epss_percentile": 0.43604}, "CVE-2025-29594": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-29602": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-29606": {"epss_score": 0.00099, "epss_percentile": 0.28353}, "CVE-2025-29621": {"epss_score": 0.0007, "epss_percentile": 0.21819}, "CVE-2025-29625": {"epss_score": 0.00025, "epss_percentile": 0.06364}, "CVE-2025-29627": {"epss_score": 0.00048, "epss_percentile": 0.15032}, "CVE-2025-29628": {"epss_score": 0.00051, "epss_percentile": 0.16256}, "CVE-2025-29629": {"epss_score": 0.00134, "epss_percentile": 0.3375}, "CVE-2025-29630": {"epss_score": 0.00052, "epss_percentile": 0.16447}, "CVE-2025-29631": {"epss_score": 0.00334, "epss_percentile": 0.55743}, "CVE-2025-29632": {"epss_score": 0.00062, "epss_percentile": 0.19656}, "CVE-2025-29635": {"epss_score": 0.01552, "epss_percentile": 0.80995}, "CVE-2025-29640": {"epss_score": 0.0008, "epss_percentile": 0.24204}, "CVE-2025-29641": {"epss_score": 0.00098, "epss_percentile": 0.27635}, "CVE-2025-29646": {"epss_score": 0.00055, "epss_percentile": 0.17612}, "CVE-2025-29647": {"epss_score": 0.00089, "epss_percentile": 0.25918}, "CVE-2025-29659": {"epss_score": 0.01618, "epss_percentile": 0.81369}, "CVE-2025-29660": {"epss_score": 0.00367, "epss_percentile": 0.58102}, "CVE-2025-29661": {"epss_score": 0.00153, "epss_percentile": 0.36577}, "CVE-2025-29662": {"epss_score": 0.00853, "epss_percentile": 0.74431}, "CVE-2025-29686": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-29688": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-29689": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-29690": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-29691": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-29699": {"epss_score": 0.00071, "epss_percentile": 0.2222}, "CVE-2025-29705": {"epss_score": 0.00062, "epss_percentile": 0.19657}, "CVE-2025-29708": {"epss_score": 0.00214, "epss_percentile": 0.43951}, "CVE-2025-29709": {"epss_score": 0.00214, "epss_percentile": 0.43951}, "CVE-2025-29710": {"epss_score": 0.00053, "epss_percentile": 0.16872}, "CVE-2025-29719": {"epss_score": 0.00059, "epss_percentile": 0.18781}, "CVE-2025-29720": {"epss_score": 0.0002, "epss_percentile": 0.04422}, "CVE-2025-29722": {"epss_score": 0.0009, "epss_percentile": 0.26097}, "CVE-2025-29743": {"epss_score": 0.03818, "epss_percentile": 0.87771}, "CVE-2025-29744": {"epss_score": 0.00022, "epss_percentile": 0.05037}, "CVE-2025-29745": {"epss_score": 0.00035, "epss_percentile": 0.10008}, "CVE-2025-29746": {"epss_score": 0.00048, "epss_percentile": 0.15158}, "CVE-2025-29756": {"epss_score": 0.00038, "epss_percentile": 0.11269}, "CVE-2025-29757": {"epss_score": 0.00061, "epss_percentile": 0.19319}, "CVE-2025-29766": {"epss_score": 0.00033, "epss_percentile": 0.09279}, "CVE-2025-29768": {"epss_score": 0.00153, "epss_percentile": 0.36584}, "CVE-2025-29769": {"epss_score": 0.0005, "epss_percentile": 0.15708}, "CVE-2025-29770": {"epss_score": 0.00269, "epss_percentile": 0.50163}, "CVE-2025-29771": {"epss_score": 0.00302, "epss_percentile": 0.53096}, "CVE-2025-29772": {"epss_score": 0.00269, "epss_percentile": 0.50164}, "CVE-2025-29773": {"epss_score": 0.00035, "epss_percentile": 0.10132}, "CVE-2025-29774": {"epss_score": 0.00138, "epss_percentile": 0.34522}, "CVE-2025-29775": {"epss_score": 0.00135, "epss_percentile": 0.34038}, "CVE-2025-29776": {"epss_score": 0.0007, "epss_percentile": 0.21652}, "CVE-2025-29778": {"epss_score": 0.00108, "epss_percentile": 0.29798}, "CVE-2025-29779": {"epss_score": 0.00024, "epss_percentile": 0.06014}, "CVE-2025-29780": {"epss_score": 0.0034, "epss_percentile": 0.56278}, "CVE-2025-29781": {"epss_score": 0.00049, "epss_percentile": 0.15487}, "CVE-2025-29782": {"epss_score": 0.00215, "epss_percentile": 0.44071}, "CVE-2025-29783": {"epss_score": 0.01607, "epss_percentile": 0.81307}, "CVE-2025-29784": {"epss_score": 0.00158, "epss_percentile": 0.37289}, "CVE-2025-29785": {"epss_score": 0.00022, "epss_percentile": 0.05013}, "CVE-2025-29786": {"epss_score": 0.00112, "epss_percentile": 0.30519}, "CVE-2025-29787": {"epss_score": 0.00233, "epss_percentile": 0.45979}, "CVE-2025-29788": {"epss_score": 0.00418, "epss_percentile": 0.61272}, "CVE-2025-29789": {"epss_score": 0.00158, "epss_percentile": 0.37149}, "CVE-2025-29790": {"epss_score": 0.00115, "epss_percentile": 0.30983}, "CVE-2025-29791": {"epss_score": 0.00385, "epss_percentile": 0.59216}, "CVE-2025-29792": {"epss_score": 0.00316, "epss_percentile": 0.54235}, "CVE-2025-29793": {"epss_score": 0.20543, "epss_percentile": 0.95376}, "CVE-2025-29794": {"epss_score": 0.00818, "epss_percentile": 0.7386}, "CVE-2025-29795": {"epss_score": 0.00514, "epss_percentile": 0.65952}, "CVE-2025-29796": {"epss_score": 0.00711, "epss_percentile": 0.71743}, "CVE-2025-29800": {"epss_score": 0.00219, "epss_percentile": 0.44443}, "CVE-2025-29801": {"epss_score": 0.00219, "epss_percentile": 0.44443}, "CVE-2025-29802": {"epss_score": 0.00221, "epss_percentile": 0.44694}, "CVE-2025-29803": {"epss_score": 0.00221, "epss_percentile": 0.44694}, "CVE-2025-29804": {"epss_score": 0.0017, "epss_percentile": 0.38666}, "CVE-2025-29805": {"epss_score": 0.0143, "epss_percentile": 0.80239}, "CVE-2025-29806": {"epss_score": 0.01078, "epss_percentile": 0.77348}, "CVE-2025-29807": {"epss_score": 0.01438, "epss_percentile": 0.80286}, "CVE-2025-29808": {"epss_score": 0.00174, "epss_percentile": 0.39179}, "CVE-2025-29809": {"epss_score": 0.00739, "epss_percentile": 0.7235}, "CVE-2025-29810": {"epss_score": 0.00058, "epss_percentile": 0.18357}, "CVE-2025-29811": {"epss_score": 0.00434, "epss_percentile": 0.62293}, "CVE-2025-29812": {"epss_score": 0.00445, "epss_percentile": 0.62879}, "CVE-2025-29813": {"epss_score": 0.00192, "epss_percentile": 0.41313}, "CVE-2025-29814": {"epss_score": 0.18431, "epss_percentile": 0.95015}, "CVE-2025-29815": {"epss_score": 0.00435, "epss_percentile": 0.62342}, "CVE-2025-29816": {"epss_score": 0.00056, "epss_percentile": 0.17865}, "CVE-2025-29817": {"epss_score": 0.00223, "epss_percentile": 0.44962}, "CVE-2025-29819": {"epss_score": 0.00376, "epss_percentile": 0.58643}, "CVE-2025-29820": {"epss_score": 0.00182, "epss_percentile": 0.40145}, "CVE-2025-29821": {"epss_score": 0.00429, "epss_percentile": 0.61996}, "CVE-2025-29822": {"epss_score": 0.00416, "epss_percentile": 0.61162}, "CVE-2025-29823": {"epss_score": 0.00182, "epss_percentile": 0.40145}, "CVE-2025-29824": {"epss_score": 0.00761, "epss_percentile": 0.7283}, "CVE-2025-29825": {"epss_score": 0.00118, "epss_percentile": 0.31389}, "CVE-2025-29826": {"epss_score": 0.00071, "epss_percentile": 0.22043}, "CVE-2025-29827": {"epss_score": 0.00148, "epss_percentile": 0.35804}, "CVE-2025-29828": {"epss_score": 0.00127, "epss_percentile": 0.3282}, "CVE-2025-29829": {"epss_score": 0.00134, "epss_percentile": 0.33904}, "CVE-2025-29830": {"epss_score": 0.00176, "epss_percentile": 0.3939}, "CVE-2025-29831": {"epss_score": 0.00123, "epss_percentile": 0.32223}, "CVE-2025-29832": {"epss_score": 0.00073, "epss_percentile": 0.22534}, "CVE-2025-29833": {"epss_score": 0.0005, "epss_percentile": 0.15718}, "CVE-2025-29834": {"epss_score": 0.00137, "epss_percentile": 0.34264}, "CVE-2025-29835": {"epss_score": 0.00088, "epss_percentile": 0.25676}, "CVE-2025-29836": {"epss_score": 0.00073, "epss_percentile": 0.22534}, "CVE-2025-29837": {"epss_score": 0.00081, "epss_percentile": 0.24356}, "CVE-2025-29838": {"epss_score": 0.0006, "epss_percentile": 0.18989}, "CVE-2025-29839": {"epss_score": 0.00059, "epss_percentile": 0.18806}, "CVE-2025-29840": {"epss_score": 0.00086, "epss_percentile": 0.25371}, "CVE-2025-29841": {"epss_score": 0.00045, "epss_percentile": 0.13688}, "CVE-2025-29842": {"epss_score": 0.00038, "epss_percentile": 0.11159}, "CVE-2025-29843": {"epss_score": 0.00035, "epss_percentile": 0.09993}, "CVE-2025-29844": {"epss_score": 0.00038, "epss_percentile": 0.11342}, "CVE-2025-29845": {"epss_score": 0.00038, "epss_percentile": 0.11342}, "CVE-2025-29846": {"epss_score": 0.0008, "epss_percentile": 0.24014}, "CVE-2025-29864": {"epss_score": 0.00027, "epss_percentile": 0.06828}, "CVE-2025-29865": {"epss_score": 0.00093, "epss_percentile": 0.26623}, "CVE-2025-29866": {"epss_score": 0.00051, "epss_percentile": 0.16109}, "CVE-2025-29868": {"epss_score": 0.00636, "epss_percentile": 0.69832}, "CVE-2025-29870": {"epss_score": 0.00086, "epss_percentile": 0.25377}, "CVE-2025-29871": {"epss_score": 0.00015, "epss_percentile": 0.02532}, "CVE-2025-29872": {"epss_score": 0.00113, "epss_percentile": 0.30683}, "CVE-2025-29873": {"epss_score": 0.00112, "epss_percentile": 0.3045}, "CVE-2025-29874": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-29875": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-29876": {"epss_score": 0.00112, "epss_percentile": 0.3045}, "CVE-2025-29877": {"epss_score": 0.00112, "epss_percentile": 0.3045}, "CVE-2025-29878": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-29879": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-29882": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-29883": {"epss_score": 0.00078, "epss_percentile": 0.23793}, "CVE-2025-29884": {"epss_score": 0.00078, "epss_percentile": 0.23793}, "CVE-2025-29885": {"epss_score": 0.00078, "epss_percentile": 0.23793}, "CVE-2025-29886": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-29887": {"epss_score": 0.00234, "epss_percentile": 0.46152}, "CVE-2025-29888": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-29889": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-29890": {"epss_score": 0.00206, "epss_percentile": 0.42948}, "CVE-2025-29891": {"epss_score": 0.00181, "epss_percentile": 0.40017}, "CVE-2025-29892": {"epss_score": 0.00073, "epss_percentile": 0.22558}, "CVE-2025-29893": {"epss_score": 0.00155, "epss_percentile": 0.36838}, "CVE-2025-29894": {"epss_score": 0.00155, "epss_percentile": 0.36838}, "CVE-2025-29898": {"epss_score": 0.00206, "epss_percentile": 0.42948}, "CVE-2025-29899": {"epss_score": 0.00206, "epss_percentile": 0.42948}, "CVE-2025-29900": {"epss_score": 0.00206, "epss_percentile": 0.42948}, "CVE-2025-29901": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-29902": {"epss_score": 0.00373, "epss_percentile": 0.58468}, "CVE-2025-29903": {"epss_score": 4e-05, "epss_percentile": 0.00171}, "CVE-2025-29904": {"epss_score": 4e-05, "epss_percentile": 0.00136}, "CVE-2025-29905": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-29906": {"epss_score": 0.00021, "epss_percentile": 0.04734}, "CVE-2025-29907": {"epss_score": 0.00306, "epss_percentile": 0.53412}, "CVE-2025-29908": {"epss_score": 0.00141, "epss_percentile": 0.34863}, "CVE-2025-29909": {"epss_score": 0.01627, "epss_percentile": 0.81432}, "CVE-2025-29910": {"epss_score": 0.00222, "epss_percentile": 0.44717}, "CVE-2025-29911": {"epss_score": 0.00451, "epss_percentile": 0.63124}, "CVE-2025-29912": {"epss_score": 0.01047, "epss_percentile": 0.77036}, "CVE-2025-29913": {"epss_score": 0.00451, "epss_percentile": 0.63124}, "CVE-2025-29914": {"epss_score": 0.00096, "epss_percentile": 0.27279}, "CVE-2025-29915": {"epss_score": 0.00036, "epss_percentile": 0.10364}, "CVE-2025-29916": {"epss_score": 0.00025, "epss_percentile": 0.06287}, "CVE-2025-29917": {"epss_score": 0.00023, "epss_percentile": 0.05651}, "CVE-2025-29918": {"epss_score": 0.00026, "epss_percentile": 0.06513}, "CVE-2025-29922": {"epss_score": 0.00122, "epss_percentile": 0.32087}, "CVE-2025-29923": {"epss_score": 0.00037, "epss_percentile": 0.10903}, "CVE-2025-29924": {"epss_score": 0.00048, "epss_percentile": 0.14998}, "CVE-2025-29925": {"epss_score": 0.00357, "epss_percentile": 0.57405}, "CVE-2025-29926": {"epss_score": 0.01277, "epss_percentile": 0.79113}, "CVE-2025-29927": {"epss_score": 0.92896, "epss_percentile": 0.99758}, "CVE-2025-29928": {"epss_score": 0.0006, "epss_percentile": 0.19075}, "CVE-2025-29929": {"epss_score": 0.00033, "epss_percentile": 0.09279}, "CVE-2025-29930": {"epss_score": 0.00121, "epss_percentile": 0.32004}, "CVE-2025-29931": {"epss_score": 0.00179, "epss_percentile": 0.39812}, "CVE-2025-29932": {"epss_score": 1e-05, "epss_percentile": 0.00017}, "CVE-2025-29933": {"epss_score": 0.00017, "epss_percentile": 0.03092}, "CVE-2025-29934": {"epss_score": 0.00016, "epss_percentile": 0.0292}, "CVE-2025-29953": {"epss_score": 0.00236, "epss_percentile": 0.46386}, "CVE-2025-29954": {"epss_score": 0.00242, "epss_percentile": 0.47375}, "CVE-2025-29955": {"epss_score": 0.00106, "epss_percentile": 0.29489}, "CVE-2025-29956": {"epss_score": 0.00083, "epss_percentile": 0.24596}, "CVE-2025-29957": {"epss_score": 0.00233, "epss_percentile": 0.4603}, "CVE-2025-29958": {"epss_score": 0.00181, "epss_percentile": 0.39992}, "CVE-2025-29959": {"epss_score": 0.00181, "epss_percentile": 0.39992}, "CVE-2025-29960": {"epss_score": 0.00073, "epss_percentile": 0.22534}, "CVE-2025-29961": {"epss_score": 0.00073, "epss_percentile": 0.22534}, "CVE-2025-29962": {"epss_score": 0.00094, "epss_percentile": 0.26783}, "CVE-2025-29963": {"epss_score": 0.00086, "epss_percentile": 0.25371}, "CVE-2025-29964": {"epss_score": 0.00086, "epss_percentile": 0.25371}, "CVE-2025-29966": {"epss_score": 0.00202, "epss_percentile": 0.42397}, "CVE-2025-29967": {"epss_score": 0.00202, "epss_percentile": 0.42397}, "CVE-2025-29968": {"epss_score": 0.00287, "epss_percentile": 0.51804}, "CVE-2025-29969": {"epss_score": 0.00083, "epss_percentile": 0.2475}, "CVE-2025-29970": {"epss_score": 0.00083, "epss_percentile": 0.24642}, "CVE-2025-29971": {"epss_score": 0.00276, "epss_percentile": 0.50755}, "CVE-2025-29972": {"epss_score": 0.01795, "epss_percentile": 0.82301}, "CVE-2025-29973": {"epss_score": 0.00055, "epss_percentile": 0.175}, "CVE-2025-29974": {"epss_score": 0.00081, "epss_percentile": 0.24386}, "CVE-2025-29975": {"epss_score": 0.00101, "epss_percentile": 0.2863}, "CVE-2025-29976": {"epss_score": 0.00125, "epss_percentile": 0.32494}, "CVE-2025-29977": {"epss_score": 0.00082, "epss_percentile": 0.24456}, "CVE-2025-29978": {"epss_score": 0.00082, "epss_percentile": 0.24456}, "CVE-2025-29979": {"epss_score": 0.00082, "epss_percentile": 0.24456}, "CVE-2025-29980": {"epss_score": 0.0013, "epss_percentile": 0.33239}, "CVE-2025-29981": {"epss_score": 0.0016, "epss_percentile": 0.37459}, "CVE-2025-29982": {"epss_score": 0.00016, "epss_percentile": 0.03022}, "CVE-2025-29983": {"epss_score": 0.00014, "epss_percentile": 0.01808}, "CVE-2025-29984": {"epss_score": 0.00015, "epss_percentile": 0.02288}, "CVE-2025-29985": {"epss_score": 0.00247, "epss_percentile": 0.47856}, "CVE-2025-29986": {"epss_score": 0.00229, "epss_percentile": 0.45556}, "CVE-2025-29987": {"epss_score": 0.00127, "epss_percentile": 0.32849}, "CVE-2025-29988": {"epss_score": 0.0002, "epss_percentile": 0.04426}, "CVE-2025-29989": {"epss_score": 0.00015, "epss_percentile": 0.02431}, "CVE-2025-29991": {"epss_score": 0.00018, "epss_percentile": 0.04045}, "CVE-2025-29992": {"epss_score": 0.00059, "epss_percentile": 0.18904}, "CVE-2025-29993": {"epss_score": 0.00048, "epss_percentile": 0.14932}, "CVE-2025-29994": {"epss_score": 0.00154, "epss_percentile": 0.36702}, "CVE-2025-29995": {"epss_score": 0.00205, "epss_percentile": 0.42728}, "CVE-2025-29996": {"epss_score": 0.0019, "epss_percentile": 0.41052}, "CVE-2025-29997": {"epss_score": 0.00245, "epss_percentile": 0.47657}, "CVE-2025-29998": {"epss_score": 0.00115, "epss_percentile": 0.31036}, "CVE-2025-29999": {"epss_score": 0.00018, "epss_percentile": 0.03603}, "CVE-2025-2000": {"epss_score": 0.00372, "epss_percentile": 0.5842}, "CVE-2025-2002": {"epss_score": 0.00035, "epss_percentile": 0.10135}, "CVE-2025-2003": {"epss_score": 0.00115, "epss_percentile": 0.30893}, "CVE-2025-2004": {"epss_score": 0.00906, "epss_percentile": 0.75257}, "CVE-2025-2005": {"epss_score": 0.00506, "epss_percentile": 0.6562}, "CVE-2025-2006": {"epss_score": 0.0024, "epss_percentile": 0.47223}, "CVE-2025-2007": {"epss_score": 0.02188, "epss_percentile": 0.83928}, "CVE-2025-2008": {"epss_score": 0.00506, "epss_percentile": 0.65634}, "CVE-2025-2009": {"epss_score": 0.00617, "epss_percentile": 0.69351}, "CVE-2025-2010": {"epss_score": 0.18963, "epss_percentile": 0.95102}, "CVE-2025-2011": {"epss_score": 0.50355, "epss_percentile": 0.97733}, "CVE-2025-2012": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2025-2013": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2025-2014": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2025-2015": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2025-2016": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2025-2017": {"epss_score": 0.00049, "epss_percentile": 0.15559}, "CVE-2025-2018": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2025-2019": {"epss_score": 0.00049, "epss_percentile": 0.15559}, "CVE-2025-2020": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2025-2021": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2025-2022": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2025-2023": {"epss_score": 0.00054, "epss_percentile": 0.1714}, "CVE-2025-2024": {"epss_score": 0.00074, "epss_percentile": 0.22876}, "CVE-2025-2025": {"epss_score": 0.00185, "epss_percentile": 0.40547}, "CVE-2025-2026": {"epss_score": 0.00151, "epss_percentile": 0.36227}, "CVE-2025-2027": {"epss_score": 0.00032, "epss_percentile": 0.09076}, "CVE-2025-2028": {"epss_score": 0.00025, "epss_percentile": 0.06341}, "CVE-2025-2029": {"epss_score": 0.00037, "epss_percentile": 0.10991}, "CVE-2025-2030": {"epss_score": 0.00087, "epss_percentile": 0.25487}, "CVE-2025-2031": {"epss_score": 0.00106, "epss_percentile": 0.29574}, "CVE-2025-2032": {"epss_score": 0.00097, "epss_percentile": 0.27521}, "CVE-2025-2033": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-2034": {"epss_score": 0.00121, "epss_percentile": 0.31885}, "CVE-2025-2035": {"epss_score": 0.00202, "epss_percentile": 0.42488}, "CVE-2025-2036": {"epss_score": 0.00141, "epss_percentile": 0.34936}, "CVE-2025-2037": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-2038": {"epss_score": 0.00149, "epss_percentile": 0.35939}, "CVE-2025-2039": {"epss_score": 0.00111, "epss_percentile": 0.30261}, "CVE-2025-2040": {"epss_score": 0.00115, "epss_percentile": 0.30973}, "CVE-2025-2041": {"epss_score": 0.00143, "epss_percentile": 0.3522}, "CVE-2025-2042": {"epss_score": 0.00079, "epss_percentile": 0.23866}, "CVE-2025-2043": {"epss_score": 0.00227, "epss_percentile": 0.45381}, "CVE-2025-2044": {"epss_score": 0.00111, "epss_percentile": 0.30261}, "CVE-2025-2045": {"epss_score": 0.00039, "epss_percentile": 0.11714}, "CVE-2025-2046": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-2047": {"epss_score": 0.00117, "epss_percentile": 0.31234}, "CVE-2025-2048": {"epss_score": 0.001, "epss_percentile": 0.2854}, "CVE-2025-2049": {"epss_score": 0.00117, "epss_percentile": 0.31234}, "CVE-2025-2050": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2025-2051": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-2052": {"epss_score": 0.00115, "epss_percentile": 0.30891}, "CVE-2025-2053": {"epss_score": 0.00036, "epss_percentile": 0.10304}, "CVE-2025-2054": {"epss_score": 0.00034, "epss_percentile": 0.09483}, "CVE-2025-2055": {"epss_score": 0.0011, "epss_percentile": 0.30229}, "CVE-2025-2056": {"epss_score": 0.00977, "epss_percentile": 0.7622}, "CVE-2025-2057": {"epss_score": 0.00038, "epss_percentile": 0.11407}, "CVE-2025-2058": {"epss_score": 0.00038, "epss_percentile": 0.11407}, "CVE-2025-2059": {"epss_score": 0.00038, "epss_percentile": 0.11407}, "CVE-2025-2060": {"epss_score": 0.00126, "epss_percentile": 0.32768}, "CVE-2025-2061": {"epss_score": 0.00098, "epss_percentile": 0.27741}, "CVE-2025-2062": {"epss_score": 0.00133, "epss_percentile": 0.33627}, "CVE-2025-2063": {"epss_score": 0.00139, "epss_percentile": 0.34549}, "CVE-2025-2064": {"epss_score": 0.00139, "epss_percentile": 0.34549}, "CVE-2025-2065": {"epss_score": 0.00139, "epss_percentile": 0.34549}, "CVE-2025-2066": {"epss_score": 0.00133, "epss_percentile": 0.33627}, "CVE-2025-2067": {"epss_score": 0.00139, "epss_percentile": 0.34549}, "CVE-2025-2068": {"epss_score": 0.00013, "epss_percentile": 0.01472}, "CVE-2025-2069": {"epss_score": 0.00017, "epss_percentile": 0.03129}, "CVE-2025-2070": {"epss_score": 0.00013, "epss_percentile": 0.01472}, "CVE-2025-2071": {"epss_score": 0.00463, "epss_percentile": 0.63659}, "CVE-2025-2072": {"epss_score": 0.00088, "epss_percentile": 0.257}, "CVE-2025-2073": {"epss_score": 0.00039, "epss_percentile": 0.11778}, "CVE-2025-2074": {"epss_score": 0.00056, "epss_percentile": 0.1796}, "CVE-2025-2075": {"epss_score": 0.27711, "epss_percentile": 0.96275}, "CVE-2025-2076": {"epss_score": 0.00098, "epss_percentile": 0.27774}, "CVE-2025-2077": {"epss_score": 0.00456, "epss_percentile": 0.6334}, "CVE-2025-2078": {"epss_score": 0.00098, "epss_percentile": 0.27774}, "CVE-2025-2079": {"epss_score": 0.00158, "epss_percentile": 0.37164}, "CVE-2025-2080": {"epss_score": 0.00122, "epss_percentile": 0.32069}, "CVE-2025-2081": {"epss_score": 0.00158, "epss_percentile": 0.37164}, "CVE-2025-2082": {"epss_score": 0.00053, "epss_percentile": 0.16888}, "CVE-2025-2083": {"epss_score": 0.00059, "epss_percentile": 0.18865}, "CVE-2025-2084": {"epss_score": 0.00087, "epss_percentile": 0.25458}, "CVE-2025-2085": {"epss_score": 0.00087, "epss_percentile": 0.2557}, "CVE-2025-2086": {"epss_score": 0.00087, "epss_percentile": 0.2557}, "CVE-2025-2087": {"epss_score": 0.00026, "epss_percentile": 0.06525}, "CVE-2025-2088": {"epss_score": 0.00131, "epss_percentile": 0.33452}, "CVE-2025-2089": {"epss_score": 0.00144, "epss_percentile": 0.35346}, "CVE-2025-2090": {"epss_score": 0.00112, "epss_percentile": 0.3054}, "CVE-2025-2091": {"epss_score": 0.00031, "epss_percentile": 0.08389}, "CVE-2025-2092": {"epss_score": 0.00049, "epss_percentile": 0.15561}, "CVE-2025-2093": {"epss_score": 0.00117, "epss_percentile": 0.312}, "CVE-2025-2094": {"epss_score": 0.06137, "epss_percentile": 0.90511}, "CVE-2025-2095": {"epss_score": 0.03722, "epss_percentile": 0.87622}, "CVE-2025-2096": {"epss_score": 0.03722, "epss_percentile": 0.87622}, "CVE-2025-2097": {"epss_score": 0.0115, "epss_percentile": 0.78032}, "CVE-2025-2098": {"epss_score": 0.00022, "epss_percentile": 0.05285}, "CVE-2025-2099": {"epss_score": 0.00114, "epss_percentile": 0.3076}, "CVE-2025-2101": {"epss_score": 0.00323, "epss_percentile": 0.54885}, "CVE-2025-2102": {"epss_score": 0.00024, "epss_percentile": 0.05691}, "CVE-2025-2103": {"epss_score": 0.00176, "epss_percentile": 0.39416}, "CVE-2025-2104": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2025-2105": {"epss_score": 0.01016, "epss_percentile": 0.76681}, "CVE-2025-2106": {"epss_score": 0.00333, "epss_percentile": 0.55631}, "CVE-2025-2107": {"epss_score": 0.00302, "epss_percentile": 0.53117}, "CVE-2025-2108": {"epss_score": 0.00101, "epss_percentile": 0.28627}, "CVE-2025-2109": {"epss_score": 0.0023, "epss_percentile": 0.45691}, "CVE-2025-2110": {"epss_score": 0.00172, "epss_percentile": 0.38931}, "CVE-2025-2111": {"epss_score": 0.00034, "epss_percentile": 0.09659}, "CVE-2025-2112": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-2113": {"epss_score": 0.00138, "epss_percentile": 0.34343}, "CVE-2025-2114": {"epss_score": 0.00031, "epss_percentile": 0.0838}, "CVE-2025-2115": {"epss_score": 0.00068, "epss_percentile": 0.212}, "CVE-2025-2116": {"epss_score": 0.00026, "epss_percentile": 0.06453}, "CVE-2025-2117": {"epss_score": 0.00022, "epss_percentile": 0.0516}, "CVE-2025-2118": {"epss_score": 0.00024, "epss_percentile": 0.0596}, "CVE-2025-2119": {"epss_score": 0.0001, "epss_percentile": 0.00878}, "CVE-2025-2120": {"epss_score": 0.00012, "epss_percentile": 0.01337}, "CVE-2025-2121": {"epss_score": 0.00036, "epss_percentile": 0.1061}, "CVE-2025-2122": {"epss_score": 0.00043, "epss_percentile": 0.13058}, "CVE-2025-2123": {"epss_score": 0.00091, "epss_percentile": 0.2638}, "CVE-2025-2124": {"epss_score": 0.00084, "epss_percentile": 0.2489}, "CVE-2025-2125": {"epss_score": 0.00059, "epss_percentile": 0.18872}, "CVE-2025-2126": {"epss_score": 0.00593, "epss_percentile": 0.68639}, "CVE-2025-2127": {"epss_score": 0.00415, "epss_percentile": 0.61137}, "CVE-2025-2128": {"epss_score": 0.00056, "epss_percentile": 0.17882}, "CVE-2025-2129": {"epss_score": 0.05384, "epss_percentile": 0.89817}, "CVE-2025-2130": {"epss_score": 0.00091, "epss_percentile": 0.26217}, "CVE-2025-2131": {"epss_score": 0.00085, "epss_percentile": 0.25041}, "CVE-2025-2132": {"epss_score": 0.00126, "epss_percentile": 0.32685}, "CVE-2025-2133": {"epss_score": 0.00085, "epss_percentile": 0.25041}, "CVE-2025-2135": {"epss_score": 0.00198, "epss_percentile": 0.42092}, "CVE-2025-2136": {"epss_score": 0.00207, "epss_percentile": 0.43129}, "CVE-2025-2137": {"epss_score": 0.00083, "epss_percentile": 0.24742}, "CVE-2025-2138": {"epss_score": 0.00037, "epss_percentile": 0.10789}, "CVE-2025-2139": {"epss_score": 0.00028, "epss_percentile": 0.07224}, "CVE-2025-2140": {"epss_score": 0.00014, "epss_percentile": 0.02067}, "CVE-2025-2141": {"epss_score": 0.00019, "epss_percentile": 0.04416}, "CVE-2025-2146": {"epss_score": 0.00294, "epss_percentile": 0.52402}, "CVE-2025-2147": {"epss_score": 0.00129, "epss_percentile": 0.33198}, "CVE-2025-2148": {"epss_score": 0.00155, "epss_percentile": 0.36802}, "CVE-2025-2149": {"epss_score": 0.00043, "epss_percentile": 0.13336}, "CVE-2025-2150": {"epss_score": 0.00062, "epss_percentile": 0.19594}, "CVE-2025-2151": {"epss_score": 0.00579, "epss_percentile": 0.68214}, "CVE-2025-2152": {"epss_score": 0.00234, "epss_percentile": 0.46093}, "CVE-2025-2153": {"epss_score": 0.00234, "epss_percentile": 0.46093}, "CVE-2025-2154": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-2155": {"epss_score": 0.00047, "epss_percentile": 0.14894}, "CVE-2025-2157": {"epss_score": 0.00029, "epss_percentile": 0.0766}, "CVE-2025-2158": {"epss_score": 0.00161, "epss_percentile": 0.3755}, "CVE-2025-2159": {"epss_score": 0.00036, "epss_percentile": 0.10442}, "CVE-2025-2160": {"epss_score": 0.00052, "epss_percentile": 0.16549}, "CVE-2025-2161": {"epss_score": 0.00052, "epss_percentile": 0.16549}, "CVE-2025-2162": {"epss_score": 0.00049, "epss_percentile": 0.15313}, "CVE-2025-2163": {"epss_score": 0.00052, "epss_percentile": 0.16581}, "CVE-2025-2164": {"epss_score": 0.00563, "epss_percentile": 0.67728}, "CVE-2025-2165": {"epss_score": 0.00333, "epss_percentile": 0.55625}, "CVE-2025-2166": {"epss_score": 0.00661, "epss_percentile": 0.70581}, "CVE-2025-2167": {"epss_score": 0.0007, "epss_percentile": 0.21759}, "CVE-2025-2168": {"epss_score": 0.00016, "epss_percentile": 0.02647}, "CVE-2025-2169": {"epss_score": 0.01437, "epss_percentile": 0.80282}, "CVE-2025-2170": {"epss_score": 0.0003, "epss_percentile": 0.08268}, "CVE-2025-2171": {"epss_score": 0.00058, "epss_percentile": 0.18613}, "CVE-2025-2172": {"epss_score": 0.00181, "epss_percentile": 0.40102}, "CVE-2025-2173": {"epss_score": 0.00379, "epss_percentile": 0.58842}, "CVE-2025-2174": {"epss_score": 0.00795, "epss_percentile": 0.73471}, "CVE-2025-2175": {"epss_score": 0.00456, "epss_percentile": 0.63349}, "CVE-2025-2176": {"epss_score": 0.0041, "epss_percentile": 0.60821}, "CVE-2025-2177": {"epss_score": 0.00399, "epss_percentile": 0.60119}, "CVE-2025-2179": {"epss_score": 0.00019, "epss_percentile": 0.04087}, "CVE-2025-2180": {"epss_score": 0.00269, "epss_percentile": 0.50162}, "CVE-2025-2181": {"epss_score": 0.00026, "epss_percentile": 0.06619}, "CVE-2025-2182": {"epss_score": 0.00014, "epss_percentile": 0.01856}, "CVE-2025-2183": {"epss_score": 0.0002, "epss_percentile": 0.04489}, "CVE-2025-2184": {"epss_score": 0.00034, "epss_percentile": 0.09784}, "CVE-2025-2185": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2025-2186": {"epss_score": 0.00208, "epss_percentile": 0.433}, "CVE-2025-2188": {"epss_score": 0.0005, "epss_percentile": 0.15949}, "CVE-2025-2189": {"epss_score": 0.0003, "epss_percentile": 0.08064}, "CVE-2025-2190": {"epss_score": 0.001, "epss_percentile": 0.28485}, "CVE-2025-2191": {"epss_score": 0.00072, "epss_percentile": 0.22412}, "CVE-2025-2192": {"epss_score": 0.00105, "epss_percentile": 0.29258}, "CVE-2025-2193": {"epss_score": 0.00391, "epss_percentile": 0.5956}, "CVE-2025-2194": {"epss_score": 0.00087, "epss_percentile": 0.25507}, "CVE-2025-2195": {"epss_score": 0.00087, "epss_percentile": 0.25507}, "CVE-2025-2196": {"epss_score": 0.00087, "epss_percentile": 0.25507}, "CVE-2025-2197": {"epss_score": 0.00061, "epss_percentile": 0.19438}, "CVE-2025-2199": {"epss_score": 0.00164, "epss_percentile": 0.37982}, "CVE-2025-2200": {"epss_score": 0.00164, "epss_percentile": 0.37982}, "CVE-2025-2201": {"epss_score": 0.00114, "epss_percentile": 0.30869}, "CVE-2025-2202": {"epss_score": 0.00114, "epss_percentile": 0.30869}, "CVE-2025-2203": {"epss_score": 0.00028, "epss_percentile": 0.07491}, "CVE-2025-2205": {"epss_score": 0.00144, "epss_percentile": 0.35282}, "CVE-2025-2206": {"epss_score": 0.00086, "epss_percentile": 0.25251}, "CVE-2025-2207": {"epss_score": 0.00086, "epss_percentile": 0.25251}, "CVE-2025-2208": {"epss_score": 0.00086, "epss_percentile": 0.25251}, "CVE-2025-2209": {"epss_score": 0.00086, "epss_percentile": 0.25251}, "CVE-2025-2210": {"epss_score": 0.00086, "epss_percentile": 0.25251}, "CVE-2025-2211": {"epss_score": 0.00086, "epss_percentile": 0.25251}, "CVE-2025-2212": {"epss_score": 0.00072, "epss_percentile": 0.22412}, "CVE-2025-2213": {"epss_score": 0.00072, "epss_percentile": 0.22412}, "CVE-2025-2214": {"epss_score": 0.00089, "epss_percentile": 0.25934}, "CVE-2025-2215": {"epss_score": 0.00239, "epss_percentile": 0.46903}, "CVE-2025-2216": {"epss_score": 0.00217, "epss_percentile": 0.44255}, "CVE-2025-2217": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-2218": {"epss_score": 0.00469, "epss_percentile": 0.63933}, "CVE-2025-2219": {"epss_score": 0.00159, "epss_percentile": 0.37408}, "CVE-2025-2220": {"epss_score": 0.00043, "epss_percentile": 0.13081}, "CVE-2025-2221": {"epss_score": 0.00452, "epss_percentile": 0.6317}, "CVE-2025-2222": {"epss_score": 0.00042, "epss_percentile": 0.1261}, "CVE-2025-2223": {"epss_score": 0.00029, "epss_percentile": 0.07662}, "CVE-2025-2224": {"epss_score": 0.00159, "epss_percentile": 0.37322}, "CVE-2025-2225": {"epss_score": 0.00046, "epss_percentile": 0.14283}, "CVE-2025-2228": {"epss_score": 0.00087, "epss_percentile": 0.25603}, "CVE-2025-2229": {"epss_score": 0.00023, "epss_percentile": 0.05336}, "CVE-2025-2230": {"epss_score": 0.00041, "epss_percentile": 0.1244}, "CVE-2025-2231": {"epss_score": 0.00093, "epss_percentile": 0.26659}, "CVE-2025-2232": {"epss_score": 0.00669, "epss_percentile": 0.70761}, "CVE-2025-2233": {"epss_score": 0.00074, "epss_percentile": 0.22855}, "CVE-2025-2236": {"epss_score": 0.0002, "epss_percentile": 0.04612}, "CVE-2025-2237": {"epss_score": 0.00439, "epss_percentile": 0.62589}, "CVE-2025-2238": {"epss_score": 0.00066, "epss_percentile": 0.2075}, "CVE-2025-2239": {"epss_score": 0.00111, "epss_percentile": 0.30324}, "CVE-2025-2240": {"epss_score": 0.00876, "epss_percentile": 0.74786}, "CVE-2025-2241": {"epss_score": 0.0011, "epss_percentile": 0.30103}, "CVE-2025-2242": {"epss_score": 0.00026, "epss_percentile": 0.06673}, "CVE-2025-2243": {"epss_score": 0.00275, "epss_percentile": 0.50637}, "CVE-2025-2244": {"epss_score": 0.01096, "epss_percentile": 0.77518}, "CVE-2025-2245": {"epss_score": 0.00061, "epss_percentile": 0.19485}, "CVE-2025-2246": {"epss_score": 0.00035, "epss_percentile": 0.10068}, "CVE-2025-2247": {"epss_score": 0.00021, "epss_percentile": 0.04807}, "CVE-2025-2248": {"epss_score": 0.00019, "epss_percentile": 0.04418}, "CVE-2025-2249": {"epss_score": 0.00578, "epss_percentile": 0.68197}, "CVE-2025-2250": {"epss_score": 0.00143, "epss_percentile": 0.35222}, "CVE-2025-2251": {"epss_score": 0.02633, "epss_percentile": 0.85286}, "CVE-2025-2252": {"epss_score": 0.00153, "epss_percentile": 0.36585}, "CVE-2025-2253": {"epss_score": 0.00198, "epss_percentile": 0.42066}, "CVE-2025-2254": {"epss_score": 0.00061, "epss_percentile": 0.19527}, "CVE-2025-2255": {"epss_score": 0.00133, "epss_percentile": 0.33636}, "CVE-2025-2256": {"epss_score": 0.00053, "epss_percentile": 0.1698}, "CVE-2025-2257": {"epss_score": 0.01569, "epss_percentile": 0.81082}, "CVE-2025-2258": {"epss_score": 0.00052, "epss_percentile": 0.16535}, "CVE-2025-2259": {"epss_score": 0.00052, "epss_percentile": 0.16535}, "CVE-2025-2260": {"epss_score": 0.00052, "epss_percentile": 0.16535}, "CVE-2025-2261": {"epss_score": 0.00056, "epss_percentile": 0.17684}, "CVE-2025-2262": {"epss_score": 0.0037, "epss_percentile": 0.58333}, "CVE-2025-2263": {"epss_score": 0.01536, "epss_percentile": 0.80916}, "CVE-2025-2264": {"epss_score": 0.68778, "epss_percentile": 0.98563}, "CVE-2025-2265": {"epss_score": 0.00027, "epss_percentile": 0.06852}, "CVE-2025-2266": {"epss_score": 0.00312, "epss_percentile": 0.53938}, "CVE-2025-2267": {"epss_score": 0.00101, "epss_percentile": 0.28647}, "CVE-2025-2268": {"epss_score": 0.00152, "epss_percentile": 0.3637}, "CVE-2025-2269": {"epss_score": 0.00217, "epss_percentile": 0.44325}, "CVE-2025-2270": {"epss_score": 0.00462, "epss_percentile": 0.63618}, "CVE-2025-2271": {"epss_score": 0.00112, "epss_percentile": 0.30434}, "CVE-2025-2272": {"epss_score": 0.00015, "epss_percentile": 0.02366}, "CVE-2025-2276": {"epss_score": 0.0007, "epss_percentile": 0.21753}, "CVE-2025-2277": {"epss_score": 0.00101, "epss_percentile": 0.28658}, "CVE-2025-2278": {"epss_score": 0.00099, "epss_percentile": 0.28366}, "CVE-2025-2279": {"epss_score": 0.0006, "epss_percentile": 0.19031}, "CVE-2025-2280": {"epss_score": 0.00099, "epss_percentile": 0.28366}, "CVE-2025-2284": {"epss_score": 0.00393, "epss_percentile": 0.59707}, "CVE-2025-2285": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2025-2286": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2025-2287": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2025-2288": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2025-2289": {"epss_score": 0.00141, "epss_percentile": 0.34838}, "CVE-2025-2290": {"epss_score": 0.00213, "epss_percentile": 0.43944}, "CVE-2025-2291": {"epss_score": 0.00068, "epss_percentile": 0.2119}, "CVE-2025-2292": {"epss_score": 0.4613, "epss_percentile": 0.97531}, "CVE-2025-2293": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2025-2294": {"epss_score": 0.54347, "epss_percentile": 0.97922}, "CVE-2025-2295": {"epss_score": 0.00108, "epss_percentile": 0.29786}, "CVE-2025-2296": {"epss_score": 0.00164, "epss_percentile": 0.37917}, "CVE-2025-2297": {"epss_score": 0.00012, "epss_percentile": 0.01123}, "CVE-2025-2298": {"epss_score": 0.00109, "epss_percentile": 0.30075}, "CVE-2025-2299": {"epss_score": 0.00078, "epss_percentile": 0.23767}, "CVE-2025-2300": {"epss_score": 0.00027, "epss_percentile": 0.07139}, "CVE-2025-2301": {"epss_score": 0.00026, "epss_percentile": 0.06737}, "CVE-2025-2302": {"epss_score": 0.00081, "epss_percentile": 0.24325}, "CVE-2025-2303": {"epss_score": 0.01226, "epss_percentile": 0.7869}, "CVE-2025-2304": {"epss_score": 0.00334, "epss_percentile": 0.5574}, "CVE-2025-2305": {"epss_score": 0.00168, "epss_percentile": 0.38475}, "CVE-2025-2306": {"epss_score": 0.00071, "epss_percentile": 0.22082}, "CVE-2025-2307": {"epss_score": 0.00046, "epss_percentile": 0.14201}, "CVE-2025-2308": {"epss_score": 0.0005, "epss_percentile": 0.15689}, "CVE-2025-2309": {"epss_score": 0.00055, "epss_percentile": 0.17481}, "CVE-2025-2310": {"epss_score": 0.0005, "epss_percentile": 0.15689}, "CVE-2025-2311": {"epss_score": 0.00027, "epss_percentile": 0.06787}, "CVE-2025-2312": {"epss_score": 0.00031, "epss_percentile": 0.08393}, "CVE-2025-2313": {"epss_score": 0.00053, "epss_percentile": 0.16904}, "CVE-2025-2314": {"epss_score": 0.00048, "epss_percentile": 0.14943}, "CVE-2025-2317": {"epss_score": 0.00157, "epss_percentile": 0.37093}, "CVE-2025-2319": {"epss_score": 0.00111, "epss_percentile": 0.30248}, "CVE-2025-2320": {"epss_score": 0.00235, "epss_percentile": 0.46215}, "CVE-2025-2321": {"epss_score": 0.00097, "epss_percentile": 0.27554}, "CVE-2025-2322": {"epss_score": 0.002, "epss_percentile": 0.42207}, "CVE-2025-2323": {"epss_score": 0.00093, "epss_percentile": 0.26632}, "CVE-2025-2324": {"epss_score": 0.00053, "epss_percentile": 0.1688}, "CVE-2025-2325": {"epss_score": 0.00444, "epss_percentile": 0.62847}, "CVE-2025-2327": {"epss_score": 0.00037, "epss_percentile": 0.10649}, "CVE-2025-2328": {"epss_score": 0.01457, "epss_percentile": 0.804}, "CVE-2025-2329": {"epss_score": 0.00032, "epss_percentile": 0.09086}, "CVE-2025-2330": {"epss_score": 0.00028, "epss_percentile": 0.07566}, "CVE-2025-2331": {"epss_score": 0.00145, "epss_percentile": 0.35356}, "CVE-2025-2332": {"epss_score": 0.01628, "epss_percentile": 0.81436}, "CVE-2025-2334": {"epss_score": 0.00346, "epss_percentile": 0.56676}, "CVE-2025-2335": {"epss_score": 0.00076, "epss_percentile": 0.23088}, "CVE-2025-2336": {"epss_score": 0.00051, "epss_percentile": 0.1599}, "CVE-2025-2337": {"epss_score": 0.00462, "epss_percentile": 0.63574}, "CVE-2025-2338": {"epss_score": 0.00174, "epss_percentile": 0.39185}, "CVE-2025-2339": {"epss_score": 0.00236, "epss_percentile": 0.46359}, "CVE-2025-2340": {"epss_score": 0.00077, "epss_percentile": 0.23441}, "CVE-2025-2341": {"epss_score": 0.00042, "epss_percentile": 0.12644}, "CVE-2025-2342": {"epss_score": 0.00094, "epss_percentile": 0.27036}, "CVE-2025-2343": {"epss_score": 0.0005, "epss_percentile": 0.15933}, "CVE-2025-2344": {"epss_score": 0.00094, "epss_percentile": 0.2699}, "CVE-2025-2345": {"epss_score": 0.00282, "epss_percentile": 0.51227}, "CVE-2025-2346": {"epss_score": 0.00048, "epss_percentile": 0.1519}, "CVE-2025-2347": {"epss_score": 0.0003, "epss_percentile": 0.08056}, "CVE-2025-2348": {"epss_score": 0.00033, "epss_percentile": 0.09304}, "CVE-2025-2349": {"epss_score": 0.00019, "epss_percentile": 0.04133}, "CVE-2025-2350": {"epss_score": 0.00054, "epss_percentile": 0.17105}, "CVE-2025-2351": {"epss_score": 0.00063, "epss_percentile": 0.19843}, "CVE-2025-2352": {"epss_score": 0.00069, "epss_percentile": 0.21581}, "CVE-2025-2353": {"epss_score": 0.00063, "epss_percentile": 0.19843}, "CVE-2025-2354": {"epss_score": 0.00071, "epss_percentile": 0.22134}, "CVE-2025-2355": {"epss_score": 0.00026, "epss_percentile": 0.06452}, "CVE-2025-2356": {"epss_score": 0.00085, "epss_percentile": 0.25193}, "CVE-2025-2357": {"epss_score": 0.00311, "epss_percentile": 0.53929}, "CVE-2025-2358": {"epss_score": 0.00066, "epss_percentile": 0.20939}, "CVE-2025-2359": {"epss_score": 0.00476, "epss_percentile": 0.64272}, "CVE-2025-2360": {"epss_score": 0.00312, "epss_percentile": 0.53958}, "CVE-2025-2361": {"epss_score": 0.0015, "epss_percentile": 0.36069}, "CVE-2025-2362": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2025-2363": {"epss_score": 0.00406, "epss_percentile": 0.60552}, "CVE-2025-2364": {"epss_score": 0.00069, "epss_percentile": 0.21484}, "CVE-2025-2365": {"epss_score": 0.0008, "epss_percentile": 0.24009}, "CVE-2025-2366": {"epss_score": 0.00081, "epss_percentile": 0.24359}, "CVE-2025-2367": {"epss_score": 0.00413, "epss_percentile": 0.60964}, "CVE-2025-2368": {"epss_score": 0.00451, "epss_percentile": 0.63153}, "CVE-2025-2369": {"epss_score": 0.00522, "epss_percentile": 0.66263}, "CVE-2025-2370": {"epss_score": 0.0054, "epss_percentile": 0.67006}, "CVE-2025-2371": {"epss_score": 0.00079, "epss_percentile": 0.23914}, "CVE-2025-2372": {"epss_score": 0.00108, "epss_percentile": 0.29762}, "CVE-2025-2373": {"epss_score": 0.00103, "epss_percentile": 0.29074}, "CVE-2025-2374": {"epss_score": 0.00103, "epss_percentile": 0.29074}, "CVE-2025-2375": {"epss_score": 0.00079, "epss_percentile": 0.23914}, "CVE-2025-2376": {"epss_score": 0.0015, "epss_percentile": 0.36059}, "CVE-2025-2377": {"epss_score": 0.00082, "epss_percentile": 0.24512}, "CVE-2025-2378": {"epss_score": 0.00077, "epss_percentile": 0.23449}, "CVE-2025-2379": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2025-2380": {"epss_score": 0.00108, "epss_percentile": 0.29762}, "CVE-2025-2381": {"epss_score": 0.00108, "epss_percentile": 0.29762}, "CVE-2025-2382": {"epss_score": 0.00108, "epss_percentile": 0.29762}, "CVE-2025-2383": {"epss_score": 0.00108, "epss_percentile": 0.29762}, "CVE-2025-2384": {"epss_score": 0.0007, "epss_percentile": 0.21689}, "CVE-2025-2385": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2025-2386": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2025-2387": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2025-2388": {"epss_score": 0.00114, "epss_percentile": 0.3086}, "CVE-2025-2389": {"epss_score": 0.001, "epss_percentile": 0.28466}, "CVE-2025-2390": {"epss_score": 0.00069, "epss_percentile": 0.21544}, "CVE-2025-2391": {"epss_score": 0.00108, "epss_percentile": 0.29762}, "CVE-2025-2392": {"epss_score": 0.001, "epss_percentile": 0.28466}, "CVE-2025-2393": {"epss_score": 0.00073, "epss_percentile": 0.22653}, "CVE-2025-2394": {"epss_score": 0.00026, "epss_percentile": 0.06578}, "CVE-2025-2395": {"epss_score": 0.00514, "epss_percentile": 0.65944}, "CVE-2025-2396": {"epss_score": 0.00612, "epss_percentile": 0.69229}, "CVE-2025-2397": {"epss_score": 0.00033, "epss_percentile": 0.09401}, "CVE-2025-2398": {"epss_score": 0.00332, "epss_percentile": 0.55589}, "CVE-2025-2401": {"epss_score": 0.00023, "epss_percentile": 0.05343}, "CVE-2025-2402": {"epss_score": 0.00193, "epss_percentile": 0.41447}, "CVE-2025-2403": {"epss_score": 0.00057, "epss_percentile": 0.18139}, "CVE-2025-2404": {"epss_score": 0.00045, "epss_percentile": 0.13933}, "CVE-2025-2405": {"epss_score": 0.00046, "epss_percentile": 0.14201}, "CVE-2025-2406": {"epss_score": 0.00046, "epss_percentile": 0.14201}, "CVE-2025-2407": {"epss_score": 0.00057, "epss_percentile": 0.18152}, "CVE-2025-2408": {"epss_score": 0.0003, "epss_percentile": 0.0816}, "CVE-2025-2409": {"epss_score": 0.0006, "epss_percentile": 0.19158}, "CVE-2025-2410": {"epss_score": 0.00055, "epss_percentile": 0.1743}, "CVE-2025-2411": {"epss_score": 0.00114, "epss_percentile": 0.30771}, "CVE-2025-2412": {"epss_score": 0.00114, "epss_percentile": 0.30771}, "CVE-2025-2413": {"epss_score": 0.00114, "epss_percentile": 0.30771}, "CVE-2025-2414": {"epss_score": 0.00114, "epss_percentile": 0.30771}, "CVE-2025-2415": {"epss_score": 0.00114, "epss_percentile": 0.30771}, "CVE-2025-2416": {"epss_score": 0.00114, "epss_percentile": 0.30771}, "CVE-2025-2417": {"epss_score": 0.00114, "epss_percentile": 0.30771}, "CVE-2025-2419": {"epss_score": 0.0007, "epss_percentile": 0.21689}, "CVE-2025-2420": {"epss_score": 0.00044, "epss_percentile": 0.13635}, "CVE-2025-2421": {"epss_score": 0.00065, "epss_percentile": 0.20669}, "CVE-2025-2424": {"epss_score": 0.00045, "epss_percentile": 0.13806}, "CVE-2025-2425": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-2440": {"epss_score": 0.00028, "epss_percentile": 0.07226}, "CVE-2025-2441": {"epss_score": 0.00037, "epss_percentile": 0.10623}, "CVE-2025-2442": {"epss_score": 0.00051, "epss_percentile": 0.16135}, "CVE-2025-2443": {"epss_score": 0.00046, "epss_percentile": 0.142}, "CVE-2025-2449": {"epss_score": 0.00785, "epss_percentile": 0.73253}, "CVE-2025-2450": {"epss_score": 0.00155, "epss_percentile": 0.36832}, "CVE-2025-2469": {"epss_score": 0.00024, "epss_percentile": 0.05988}, "CVE-2025-2470": {"epss_score": 0.00217, "epss_percentile": 0.44327}, "CVE-2025-2471": {"epss_score": 0.00103, "epss_percentile": 0.29074}, "CVE-2025-2472": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2025-2473": {"epss_score": 0.08031, "epss_percentile": 0.91842}, "CVE-2025-2474": {"epss_score": 0.00327, "epss_percentile": 0.5511}, "CVE-2025-2475": {"epss_score": 0.00063, "epss_percentile": 0.19853}, "CVE-2025-2476": {"epss_score": 0.13524, "epss_percentile": 0.93988}, "CVE-2025-2477": {"epss_score": 0.00374, "epss_percentile": 0.58569}, "CVE-2025-2478": {"epss_score": 0.00118, "epss_percentile": 0.31464}, "CVE-2025-2479": {"epss_score": 0.00503, "epss_percentile": 0.65443}, "CVE-2025-2480": {"epss_score": 0.00041, "epss_percentile": 0.12413}, "CVE-2025-2481": {"epss_score": 0.00256, "epss_percentile": 0.4882}, "CVE-2025-2482": {"epss_score": 0.00503, "epss_percentile": 0.65443}, "CVE-2025-2483": {"epss_score": 0.00159, "epss_percentile": 0.37411}, "CVE-2025-2484": {"epss_score": 0.00563, "epss_percentile": 0.67728}, "CVE-2025-2485": {"epss_score": 0.02071, "epss_percentile": 0.8348}, "CVE-2025-2486": {"epss_score": 0.00017, "epss_percentile": 0.0313}, "CVE-2025-2487": {"epss_score": 0.00473, "epss_percentile": 0.64095}, "CVE-2025-2488": {"epss_score": 0.00027, "epss_percentile": 0.06771}, "CVE-2025-2489": {"epss_score": 0.00032, "epss_percentile": 0.08865}, "CVE-2025-2490": {"epss_score": 0.00053, "epss_percentile": 0.16699}, "CVE-2025-2491": {"epss_score": 0.00075, "epss_percentile": 0.22902}, "CVE-2025-2492": {"epss_score": 0.00197, "epss_percentile": 0.41886}, "CVE-2025-2493": {"epss_score": 0.00214, "epss_percentile": 0.44013}, "CVE-2025-2494": {"epss_score": 0.00713, "epss_percentile": 0.718}, "CVE-2025-2495": {"epss_score": 0.00058, "epss_percentile": 0.18409}, "CVE-2025-2497": {"epss_score": 0.00023, "epss_percentile": 0.05355}, "CVE-2025-2498": {"epss_score": 0.00021, "epss_percentile": 0.04693}, "CVE-2025-2499": {"epss_score": 0.00051, "epss_percentile": 0.16137}, "CVE-2025-2500": {"epss_score": 0.00039, "epss_percentile": 0.11638}, "CVE-2025-2501": {"epss_score": 0.00018, "epss_percentile": 0.03563}, "CVE-2025-2502": {"epss_score": 0.00016, "epss_percentile": 0.02759}, "CVE-2025-2503": {"epss_score": 0.00015, "epss_percentile": 0.02282}, "CVE-2025-2505": {"epss_score": 0.01016, "epss_percentile": 0.76679}, "CVE-2025-2506": {"epss_score": 0.00044, "epss_percentile": 0.1342}, "CVE-2025-2509": {"epss_score": 8e-05, "epss_percentile": 0.0059}, "CVE-2025-2510": {"epss_score": 0.00071, "epss_percentile": 0.22188}, "CVE-2025-2511": {"epss_score": 0.0011, "epss_percentile": 0.30228}, "CVE-2025-2512": {"epss_score": 0.01648, "epss_percentile": 0.81545}, "CVE-2025-2513": {"epss_score": 0.00043, "epss_percentile": 0.1309}, "CVE-2025-2515": {"epss_score": 0.00024, "epss_percentile": 0.05855}, "CVE-2025-2516": {"epss_score": 0.00027, "epss_percentile": 0.06773}, "CVE-2025-2517": {"epss_score": 0.00104, "epss_percentile": 0.29109}, "CVE-2025-2518": {"epss_score": 0.0004, "epss_percentile": 0.12003}, "CVE-2025-2519": {"epss_score": 0.0013, "epss_percentile": 0.33323}, "CVE-2025-2520": {"epss_score": 0.001, "epss_percentile": 0.28486}, "CVE-2025-2521": {"epss_score": 0.002, "epss_percentile": 0.42226}, "CVE-2025-2522": {"epss_score": 0.00037, "epss_percentile": 0.10864}, "CVE-2025-2523": {"epss_score": 0.002, "epss_percentile": 0.42226}, "CVE-2025-2524": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2025-2525": {"epss_score": 0.00463, "epss_percentile": 0.63663}, "CVE-2025-2526": {"epss_score": 0.0028, "epss_percentile": 0.51091}, "CVE-2025-2527": {"epss_score": 0.00037, "epss_percentile": 0.10738}, "CVE-2025-2528": {"epss_score": 0.00018, "epss_percentile": 0.03638}, "CVE-2025-2529": {"epss_score": 0.0002, "epss_percentile": 0.04476}, "CVE-2025-2530": {"epss_score": 0.00047, "epss_percentile": 0.14896}, "CVE-2025-2531": {"epss_score": 0.00043, "epss_percentile": 0.1332}, "CVE-2025-2532": {"epss_score": 0.00047, "epss_percentile": 0.14896}, "CVE-2025-2533": {"epss_score": 0.00039, "epss_percentile": 0.11619}, "CVE-2025-2534": {"epss_score": 0.00054, "epss_percentile": 0.17081}, "CVE-2025-2536": {"epss_score": 0.00058, "epss_percentile": 0.18572}, "CVE-2025-2537": {"epss_score": 0.00041, "epss_percentile": 0.12309}, "CVE-2025-2538": {"epss_score": 0.0018, "epss_percentile": 0.39875}, "CVE-2025-2539": {"epss_score": 0.20811, "epss_percentile": 0.95416}, "CVE-2025-2540": {"epss_score": 0.00053, "epss_percentile": 0.17028}, "CVE-2025-2541": {"epss_score": 0.00033, "epss_percentile": 0.09369}, "CVE-2025-2542": {"epss_score": 0.00071, "epss_percentile": 0.22133}, "CVE-2025-2543": {"epss_score": 0.00043, "epss_percentile": 0.13221}, "CVE-2025-2544": {"epss_score": 0.00048, "epss_percentile": 0.15098}, "CVE-2025-2545": {"epss_score": 0.00026, "epss_percentile": 0.06597}, "CVE-2025-2546": {"epss_score": 0.00556, "epss_percentile": 0.67514}, "CVE-2025-2547": {"epss_score": 0.00396, "epss_percentile": 0.59868}, "CVE-2025-2548": {"epss_score": 0.00526, "epss_percentile": 0.66433}, "CVE-2025-2549": {"epss_score": 0.00526, "epss_percentile": 0.66433}, "CVE-2025-2550": {"epss_score": 0.00396, "epss_percentile": 0.59868}, "CVE-2025-2551": {"epss_score": 0.00396, "epss_percentile": 0.59868}, "CVE-2025-2552": {"epss_score": 0.00396, "epss_percentile": 0.59868}, "CVE-2025-2553": {"epss_score": 0.00431, "epss_percentile": 0.62061}, "CVE-2025-2555": {"epss_score": 0.00032, "epss_percentile": 0.08816}, "CVE-2025-2556": {"epss_score": 0.00042, "epss_percentile": 0.12644}, "CVE-2025-2557": {"epss_score": 0.00035, "epss_percentile": 0.0997}, "CVE-2025-2558": {"epss_score": 0.0035, "epss_percentile": 0.56976}, "CVE-2025-2559": {"epss_score": 0.00344, "epss_percentile": 0.5652}, "CVE-2025-2560": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2025-2561": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2025-2562": {"epss_score": 0.00071, "epss_percentile": 0.22222}, "CVE-2025-2563": {"epss_score": 0.83885, "epss_percentile": 0.99264}, "CVE-2025-2564": {"epss_score": 0.00058, "epss_percentile": 0.18478}, "CVE-2025-2565": {"epss_score": 0.00089, "epss_percentile": 0.25855}, "CVE-2025-2566": {"epss_score": 0.00284, "epss_percentile": 0.51431}, "CVE-2025-2567": {"epss_score": 0.00086, "epss_percentile": 0.25327}, "CVE-2025-2568": {"epss_score": 0.00283, "epss_percentile": 0.51348}, "CVE-2025-2570": {"epss_score": 0.00037, "epss_percentile": 0.10672}, "CVE-2025-2571": {"epss_score": 0.00038, "epss_percentile": 0.11074}, "CVE-2025-2572": {"epss_score": 0.0001, "epss_percentile": 0.00844}, "CVE-2025-2573": {"epss_score": 0.00061, "epss_percentile": 0.19452}, "CVE-2025-2574": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-2575": {"epss_score": 0.00041, "epss_percentile": 0.12446}, "CVE-2025-2576": {"epss_score": 0.00061, "epss_percentile": 0.19452}, "CVE-2025-2577": {"epss_score": 0.00064, "epss_percentile": 0.20314}, "CVE-2025-2578": {"epss_score": 0.00127, "epss_percentile": 0.32941}, "CVE-2025-2579": {"epss_score": 0.00039, "epss_percentile": 0.11438}, "CVE-2025-2580": {"epss_score": 0.00017, "epss_percentile": 0.03347}, "CVE-2025-2581": {"epss_score": 0.00655, "epss_percentile": 0.70419}, "CVE-2025-2582": {"epss_score": 0.00191, "epss_percentile": 0.41142}, "CVE-2025-2583": {"epss_score": 0.00191, "epss_percentile": 0.41142}, "CVE-2025-2584": {"epss_score": 0.00143, "epss_percentile": 0.35143}, "CVE-2025-2585": {"epss_score": 0.0015, "epss_percentile": 0.36087}, "CVE-2025-2586": {"epss_score": 0.00103, "epss_percentile": 0.29081}, "CVE-2025-2587": {"epss_score": 0.00069, "epss_percentile": 0.21446}, "CVE-2025-2588": {"epss_score": 0.00168, "epss_percentile": 0.38419}, "CVE-2025-2589": {"epss_score": 0.00171, "epss_percentile": 0.38787}, "CVE-2025-2590": {"epss_score": 0.00069, "epss_percentile": 0.21593}, "CVE-2025-2591": {"epss_score": 0.00084, "epss_percentile": 0.25027}, "CVE-2025-2592": {"epss_score": 0.00313, "epss_percentile": 0.5405}, "CVE-2025-2593": {"epss_score": 0.00065, "epss_percentile": 0.20484}, "CVE-2025-2594": {"epss_score": 0.04809, "epss_percentile": 0.89163}, "CVE-2025-2595": {"epss_score": 0.0006, "epss_percentile": 0.19079}, "CVE-2025-2596": {"epss_score": 0.00061, "epss_percentile": 0.19436}, "CVE-2025-2597": {"epss_score": 0.00064, "epss_percentile": 0.20397}, "CVE-2025-2598": {"epss_score": 0.00038, "epss_percentile": 0.11144}, "CVE-2025-2600": {"epss_score": 0.00058, "epss_percentile": 0.18382}, "CVE-2025-2601": {"epss_score": 0.00103, "epss_percentile": 0.29074}, "CVE-2025-2602": {"epss_score": 0.00103, "epss_percentile": 0.29074}, "CVE-2025-2603": {"epss_score": 0.00071, "epss_percentile": 0.22054}, "CVE-2025-2604": {"epss_score": 0.00071, "epss_percentile": 0.22054}, "CVE-2025-2605": {"epss_score": 0.00147, "epss_percentile": 0.35722}, "CVE-2025-2606": {"epss_score": 0.00101, "epss_percentile": 0.28705}, "CVE-2025-2607": {"epss_score": 0.00097, "epss_percentile": 0.27465}, "CVE-2025-2608": {"epss_score": 0.00103, "epss_percentile": 0.29074}, "CVE-2025-2609": {"epss_score": 0.05524, "epss_percentile": 0.89961}, "CVE-2025-2610": {"epss_score": 0.02286, "epss_percentile": 0.84267}, "CVE-2025-2611": {"epss_score": 0.42393, "epss_percentile": 0.97329}, "CVE-2025-2613": {"epss_score": 0.00037, "epss_percentile": 0.1097}, "CVE-2025-2614": {"epss_score": 0.001, "epss_percentile": 0.28527}, "CVE-2025-2615": {"epss_score": 0.00013, "epss_percentile": 0.01692}, "CVE-2025-2616": {"epss_score": 0.00081, "epss_percentile": 0.24359}, "CVE-2025-2617": {"epss_score": 0.00065, "epss_percentile": 0.20572}, "CVE-2025-2618": {"epss_score": 0.00664, "epss_percentile": 0.70628}, "CVE-2025-2619": {"epss_score": 0.00664, "epss_percentile": 0.70628}, "CVE-2025-2620": {"epss_score": 0.35608, "epss_percentile": 0.96922}, "CVE-2025-2621": {"epss_score": 0.00664, "epss_percentile": 0.70628}, "CVE-2025-2622": {"epss_score": 0.00125, "epss_percentile": 0.32567}, "CVE-2025-2623": {"epss_score": 0.00075, "epss_percentile": 0.23051}, "CVE-2025-2624": {"epss_score": 0.0007, "epss_percentile": 0.21824}, "CVE-2025-2625": {"epss_score": 0.00062, "epss_percentile": 0.19676}, "CVE-2025-2626": {"epss_score": 0.00099, "epss_percentile": 0.28419}, "CVE-2025-2627": {"epss_score": 0.00099, "epss_percentile": 0.28419}, "CVE-2025-2628": {"epss_score": 0.00103, "epss_percentile": 0.29074}, "CVE-2025-2629": {"epss_score": 0.00022, "epss_percentile": 0.05032}, "CVE-2025-2630": {"epss_score": 0.00022, "epss_percentile": 0.05032}, "CVE-2025-2631": {"epss_score": 0.00025, "epss_percentile": 0.06283}, "CVE-2025-2632": {"epss_score": 0.00025, "epss_percentile": 0.06283}, "CVE-2025-2633": {"epss_score": 0.00024, "epss_percentile": 0.05959}, "CVE-2025-2634": {"epss_score": 0.00024, "epss_percentile": 0.05959}, "CVE-2025-2635": {"epss_score": 0.0032, "epss_percentile": 0.54597}, "CVE-2025-2636": {"epss_score": 0.13543, "epss_percentile": 0.93991}, "CVE-2025-2637": {"epss_score": 0.00095, "epss_percentile": 0.27149}, "CVE-2025-2638": {"epss_score": 0.00073, "epss_percentile": 0.22623}, "CVE-2025-2639": {"epss_score": 0.00073, "epss_percentile": 0.22623}, "CVE-2025-2640": {"epss_score": 0.00105, "epss_percentile": 0.29311}, "CVE-2025-2641": {"epss_score": 0.00064, "epss_percentile": 0.20209}, "CVE-2025-2642": {"epss_score": 0.00064, "epss_percentile": 0.20209}, "CVE-2025-2643": {"epss_score": 0.00064, "epss_percentile": 0.20209}, "CVE-2025-2644": {"epss_score": 0.00064, "epss_percentile": 0.20209}, "CVE-2025-2645": {"epss_score": 0.00055, "epss_percentile": 0.17631}, "CVE-2025-2646": {"epss_score": 0.00105, "epss_percentile": 0.29311}, "CVE-2025-2647": {"epss_score": 0.00109, "epss_percentile": 0.29962}, "CVE-2025-2648": {"epss_score": 0.00109, "epss_percentile": 0.29962}, "CVE-2025-2649": {"epss_score": 0.00109, "epss_percentile": 0.29962}, "CVE-2025-2650": {"epss_score": 0.00055, "epss_percentile": 0.17439}, "CVE-2025-2651": {"epss_score": 0.00084, "epss_percentile": 0.24912}, "CVE-2025-2652": {"epss_score": 0.00078, "epss_percentile": 0.23556}, "CVE-2025-2653": {"epss_score": 0.00059, "epss_percentile": 0.18866}, "CVE-2025-2654": {"epss_score": 0.00109, "epss_percentile": 0.29962}, "CVE-2025-2655": {"epss_score": 0.00091, "epss_percentile": 0.26379}, "CVE-2025-2656": {"epss_score": 0.00064, "epss_percentile": 0.20209}, "CVE-2025-2657": {"epss_score": 0.0007, "epss_percentile": 0.21763}, "CVE-2025-2658": {"epss_score": 0.00064, "epss_percentile": 0.20209}, "CVE-2025-2659": {"epss_score": 0.0007, "epss_percentile": 0.21763}, "CVE-2025-2660": {"epss_score": 0.0007, "epss_percentile": 0.21763}, "CVE-2025-2661": {"epss_score": 0.0007, "epss_percentile": 0.21763}, "CVE-2025-2662": {"epss_score": 0.00109, "epss_percentile": 0.29991}, "CVE-2025-2663": {"epss_score": 0.00064, "epss_percentile": 0.20209}, "CVE-2025-2664": {"epss_score": 0.00105, "epss_percentile": 0.29381}, "CVE-2025-2665": {"epss_score": 0.00105, "epss_percentile": 0.29311}, "CVE-2025-2667": {"epss_score": 0.00047, "epss_percentile": 0.14499}, "CVE-2025-2670": {"epss_score": 0.0003, "epss_percentile": 0.08286}, "CVE-2025-2671": {"epss_score": 0.00087, "epss_percentile": 0.2561}, "CVE-2025-2672": {"epss_score": 0.00075, "epss_percentile": 0.23012}, "CVE-2025-2673": {"epss_score": 0.00081, "epss_percentile": 0.24327}, "CVE-2025-2674": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2025-2675": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2025-2676": {"epss_score": 0.00113, "epss_percentile": 0.30672}, "CVE-2025-2677": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2025-2678": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2025-2679": {"epss_score": 0.00113, "epss_percentile": 0.30672}, "CVE-2025-2680": {"epss_score": 0.00113, "epss_percentile": 0.30672}, "CVE-2025-2681": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2025-2682": {"epss_score": 0.00109, "epss_percentile": 0.29983}, "CVE-2025-2683": {"epss_score": 0.001, "epss_percentile": 0.28493}, "CVE-2025-2684": {"epss_score": 0.001, "epss_percentile": 0.28493}, "CVE-2025-2685": {"epss_score": 0.00059, "epss_percentile": 0.18694}, "CVE-2025-2686": {"epss_score": 0.00109, "epss_percentile": 0.29905}, "CVE-2025-2687": {"epss_score": 0.00162, "epss_percentile": 0.37651}, "CVE-2025-2688": {"epss_score": 0.00052, "epss_percentile": 0.16605}, "CVE-2025-2689": {"epss_score": 0.00234, "epss_percentile": 0.46194}, "CVE-2025-2690": {"epss_score": 0.00141, "epss_percentile": 0.34814}, "CVE-2025-2691": {"epss_score": 0.00127, "epss_percentile": 0.32875}, "CVE-2025-2694": {"epss_score": 0.00045, "epss_percentile": 0.13959}, "CVE-2025-2697": {"epss_score": 0.0006, "epss_percentile": 0.19069}, "CVE-2025-2699": {"epss_score": 0.00074, "epss_percentile": 0.22869}, "CVE-2025-2700": {"epss_score": 0.00047, "epss_percentile": 0.14668}, "CVE-2025-2701": {"epss_score": 0.01242, "epss_percentile": 0.78821}, "CVE-2025-2702": {"epss_score": 0.00087, "epss_percentile": 0.2561}, "CVE-2025-2703": {"epss_score": 0.00016, "epss_percentile": 0.02958}, "CVE-2025-2704": {"epss_score": 0.00198, "epss_percentile": 0.42094}, "CVE-2025-2705": {"epss_score": 0.00125, "epss_percentile": 0.32573}, "CVE-2025-2706": {"epss_score": 0.00061, "epss_percentile": 0.19476}, "CVE-2025-2707": {"epss_score": 0.00317, "epss_percentile": 0.54351}, "CVE-2025-2708": {"epss_score": 0.00515, "epss_percentile": 0.65999}, "CVE-2025-2709": {"epss_score": 0.00061, "epss_percentile": 0.19472}, "CVE-2025-2710": {"epss_score": 0.00063, "epss_percentile": 0.19997}, "CVE-2025-2711": {"epss_score": 0.00063, "epss_percentile": 0.19997}, "CVE-2025-2712": {"epss_score": 0.00053, "epss_percentile": 0.16904}, "CVE-2025-2713": {"epss_score": 7e-05, "epss_percentile": 0.00433}, "CVE-2025-2714": {"epss_score": 0.00129, "epss_percentile": 0.33186}, "CVE-2025-2715": {"epss_score": 0.00051, "epss_percentile": 0.16165}, "CVE-2025-2716": {"epss_score": 0.00122, "epss_percentile": 0.32174}, "CVE-2025-2717": {"epss_score": 0.00254, "epss_percentile": 0.48521}, "CVE-2025-2719": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-2725": {"epss_score": 0.00696, "epss_percentile": 0.71387}, "CVE-2025-2726": {"epss_score": 0.00688, "epss_percentile": 0.71197}, "CVE-2025-2727": {"epss_score": 0.00688, "epss_percentile": 0.71197}, "CVE-2025-2728": {"epss_score": 0.00688, "epss_percentile": 0.71197}, "CVE-2025-2729": {"epss_score": 0.00688, "epss_percentile": 0.71197}, "CVE-2025-2730": {"epss_score": 0.00688, "epss_percentile": 0.71197}, "CVE-2025-2731": {"epss_score": 0.00688, "epss_percentile": 0.71197}, "CVE-2025-2732": {"epss_score": 0.00688, "epss_percentile": 0.71197}, "CVE-2025-2733": {"epss_score": 0.0037, "epss_percentile": 0.58309}, "CVE-2025-2734": {"epss_score": 0.00059, "epss_percentile": 0.18732}, "CVE-2025-2735": {"epss_score": 0.00059, "epss_percentile": 0.18732}, "CVE-2025-2736": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-2737": {"epss_score": 0.00094, "epss_percentile": 0.26776}, "CVE-2025-2738": {"epss_score": 0.00094, "epss_percentile": 0.26776}, "CVE-2025-2739": {"epss_score": 0.00097, "epss_percentile": 0.27502}, "CVE-2025-2740": {"epss_score": 0.00073, "epss_percentile": 0.22575}, "CVE-2025-2742": {"epss_score": 0.00313, "epss_percentile": 0.54026}, "CVE-2025-2743": {"epss_score": 0.00333, "epss_percentile": 0.55621}, "CVE-2025-2744": {"epss_score": 0.00132, "epss_percentile": 0.33531}, "CVE-2025-2745": {"epss_score": 0.0003, "epss_percentile": 0.08186}, "CVE-2025-2746": {"epss_score": 0.87412, "epss_percentile": 0.99428}, "CVE-2025-2747": {"epss_score": 0.88933, "epss_percentile": 0.99499}, "CVE-2025-2748": {"epss_score": 0.00232, "epss_percentile": 0.45961}, "CVE-2025-2749": {"epss_score": 0.01162, "epss_percentile": 0.78148}, "CVE-2025-2750": {"epss_score": 0.00132, "epss_percentile": 0.33522}, "CVE-2025-2751": {"epss_score": 0.00381, "epss_percentile": 0.58991}, "CVE-2025-2752": {"epss_score": 0.00381, "epss_percentile": 0.58991}, "CVE-2025-2753": {"epss_score": 0.00132, "epss_percentile": 0.33522}, "CVE-2025-2754": {"epss_score": 0.00132, "epss_percentile": 0.33522}, "CVE-2025-2755": {"epss_score": 0.00132, "epss_percentile": 0.33522}, "CVE-2025-2756": {"epss_score": 0.00132, "epss_percentile": 0.33522}, "CVE-2025-2757": {"epss_score": 0.00132, "epss_percentile": 0.33522}, "CVE-2025-2759": {"epss_score": 0.00011, "epss_percentile": 0.01065}, "CVE-2025-2760": {"epss_score": 0.00167, "epss_percentile": 0.38365}, "CVE-2025-2761": {"epss_score": 0.00082, "epss_percentile": 0.24426}, "CVE-2025-2762": {"epss_score": 0.00019, "epss_percentile": 0.04397}, "CVE-2025-2763": {"epss_score": 0.00017, "epss_percentile": 0.03249}, "CVE-2025-2764": {"epss_score": 0.00015, "epss_percentile": 0.02541}, "CVE-2025-2765": {"epss_score": 0.0003, "epss_percentile": 0.08161}, "CVE-2025-2766": {"epss_score": 0.00045, "epss_percentile": 0.13739}, "CVE-2025-2767": {"epss_score": 0.00186, "epss_percentile": 0.40688}, "CVE-2025-2768": {"epss_score": 0.00018, "epss_percentile": 0.04042}, "CVE-2025-2769": {"epss_score": 0.00018, "epss_percentile": 0.04042}, "CVE-2025-2770": {"epss_score": 0.00051, "epss_percentile": 0.16212}, "CVE-2025-2771": {"epss_score": 0.00143, "epss_percentile": 0.35189}, "CVE-2025-2772": {"epss_score": 0.00031, "epss_percentile": 0.08462}, "CVE-2025-2773": {"epss_score": 0.00635, "epss_percentile": 0.69816}, "CVE-2025-2775": {"epss_score": 0.65187, "epss_percentile": 0.98407}, "CVE-2025-2776": {"epss_score": 0.50933, "epss_percentile": 0.97756}, "CVE-2025-2777": {"epss_score": 0.15806, "epss_percentile": 0.94512}, "CVE-2025-2779": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-2780": {"epss_score": 0.00506, "epss_percentile": 0.65634}, "CVE-2025-2781": {"epss_score": 0.00022, "epss_percentile": 0.05324}, "CVE-2025-2782": {"epss_score": 0.00022, "epss_percentile": 0.05324}, "CVE-2025-2783": {"epss_score": 0.38105, "epss_percentile": 0.97086}, "CVE-2025-2784": {"epss_score": 0.00758, "epss_percentile": 0.7277}, "CVE-2025-2786": {"epss_score": 0.00069, "epss_percentile": 0.21625}, "CVE-2025-2787": {"epss_score": 0.00109, "epss_percentile": 0.29948}, "CVE-2025-2789": {"epss_score": 0.00218, "epss_percentile": 0.44409}, "CVE-2025-2793": {"epss_score": 0.00019, "epss_percentile": 0.04356}, "CVE-2025-2794": {"epss_score": 0.00473, "epss_percentile": 0.64081}, "CVE-2025-2796": {"epss_score": 0.00026, "epss_percentile": 0.06719}, "CVE-2025-2797": {"epss_score": 0.00024, "epss_percentile": 0.06017}, "CVE-2025-2798": {"epss_score": 0.00581, "epss_percentile": 0.68278}, "CVE-2025-2799": {"epss_score": 0.00022, "epss_percentile": 0.05159}, "CVE-2025-2800": {"epss_score": 0.00106, "epss_percentile": 0.29506}, "CVE-2025-2801": {"epss_score": 0.00596, "epss_percentile": 0.68708}, "CVE-2025-2802": {"epss_score": 0.0044, "epss_percentile": 0.6262}, "CVE-2025-2803": {"epss_score": 0.00796, "epss_percentile": 0.73481}, "CVE-2025-2804": {"epss_score": 0.00217, "epss_percentile": 0.44325}, "CVE-2025-2805": {"epss_score": 0.00796, "epss_percentile": 0.73481}, "CVE-2025-2806": {"epss_score": 0.00121, "epss_percentile": 0.31828}, "CVE-2025-2807": {"epss_score": 0.0028, "epss_percentile": 0.51004}, "CVE-2025-2808": {"epss_score": 0.0004, "epss_percentile": 0.12042}, "CVE-2025-2809": {"epss_score": 0.00796, "epss_percentile": 0.73481}, "CVE-2025-2810": {"epss_score": 0.00013, "epss_percentile": 0.0158}, "CVE-2025-2811": {"epss_score": 0.00021, "epss_percentile": 0.04722}, "CVE-2025-2812": {"epss_score": 0.00042, "epss_percentile": 0.12736}, "CVE-2025-2813": {"epss_score": 0.00139, "epss_percentile": 0.34597}, "CVE-2025-2814": {"epss_score": 0.00034, "epss_percentile": 0.09482}, "CVE-2025-2815": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2025-2816": {"epss_score": 0.00102, "epss_percentile": 0.28893}, "CVE-2025-2817": {"epss_score": 0.00098, "epss_percentile": 0.27723}, "CVE-2025-2818": {"epss_score": 8e-05, "epss_percentile": 0.00508}, "CVE-2025-2819": {"epss_score": 0.00029, "epss_percentile": 0.07666}, "CVE-2025-2820": {"epss_score": 0.00107, "epss_percentile": 0.29742}, "CVE-2025-2821": {"epss_score": 0.00109, "epss_percentile": 0.29906}, "CVE-2025-2824": {"epss_score": 0.00023, "epss_percentile": 0.05421}, "CVE-2025-2826": {"epss_score": 0.00023, "epss_percentile": 0.05353}, "CVE-2025-2827": {"epss_score": 0.0003, "epss_percentile": 0.08286}, "CVE-2025-2828": {"epss_score": 0.00023, "epss_percentile": 0.05618}, "CVE-2025-2829": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2025-2830": {"epss_score": 0.00061, "epss_percentile": 0.19456}, "CVE-2025-2831": {"epss_score": 0.0006, "epss_percentile": 0.18966}, "CVE-2025-2832": {"epss_score": 0.00054, "epss_percentile": 0.17329}, "CVE-2025-2833": {"epss_score": 0.00233, "epss_percentile": 0.46044}, "CVE-2025-2835": {"epss_score": 0.00059, "epss_percentile": 0.18856}, "CVE-2025-2836": {"epss_score": 0.00074, "epss_percentile": 0.22762}, "CVE-2025-2837": {"epss_score": 0.00124, "epss_percentile": 0.32419}, "CVE-2025-2838": {"epss_score": 0.00026, "epss_percentile": 0.06682}, "CVE-2025-2839": {"epss_score": 0.00036, "epss_percentile": 0.10245}, "CVE-2025-2840": {"epss_score": 0.00095, "epss_percentile": 0.27134}, "CVE-2025-2841": {"epss_score": 0.00133, "epss_percentile": 0.33637}, "CVE-2025-2842": {"epss_score": 0.00069, "epss_percentile": 0.21625}, "CVE-2025-2843": {"epss_score": 0.00032, "epss_percentile": 0.09069}, "CVE-2025-2846": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-2847": {"epss_score": 0.0007, "epss_percentile": 0.21968}, "CVE-2025-2848": {"epss_score": 0.00078, "epss_percentile": 0.23755}, "CVE-2025-2849": {"epss_score": 0.00037, "epss_percentile": 0.10767}, "CVE-2025-2850": {"epss_score": 0.00013, "epss_percentile": 0.01475}, "CVE-2025-2851": {"epss_score": 0.00019, "epss_percentile": 0.04348}, "CVE-2025-2852": {"epss_score": 0.00044, "epss_percentile": 0.13563}, "CVE-2025-2853": {"epss_score": 0.00174, "epss_percentile": 0.39147}, "CVE-2025-2854": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-2855": {"epss_score": 0.00486, "epss_percentile": 0.64753}, "CVE-2025-2857": {"epss_score": 0.00113, "epss_percentile": 0.30595}, "CVE-2025-2858": {"epss_score": 0.00056, "epss_percentile": 0.17914}, "CVE-2025-2859": {"epss_score": 0.00088, "epss_percentile": 0.25712}, "CVE-2025-2860": {"epss_score": 0.00055, "epss_percentile": 0.17563}, "CVE-2025-2861": {"epss_score": 0.00042, "epss_percentile": 0.12934}, "CVE-2025-2862": {"epss_score": 0.00047, "epss_percentile": 0.14491}, "CVE-2025-2863": {"epss_score": 0.00016, "epss_percentile": 0.02898}, "CVE-2025-2864": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-2865": {"epss_score": 0.00032, "epss_percentile": 0.08746}, "CVE-2025-2866": {"epss_score": 0.00019, "epss_percentile": 0.0419}, "CVE-2025-2867": {"epss_score": 0.00023, "epss_percentile": 0.05405}, "CVE-2025-2868": {"epss_score": 0.00042, "epss_percentile": 0.12797}, "CVE-2025-2869": {"epss_score": 0.00042, "epss_percentile": 0.12797}, "CVE-2025-2870": {"epss_score": 0.00042, "epss_percentile": 0.12797}, "CVE-2025-2871": {"epss_score": 0.00023, "epss_percentile": 0.05411}, "CVE-2025-2874": {"epss_score": 0.00042, "epss_percentile": 0.12496}, "CVE-2025-2875": {"epss_score": 0.00119, "epss_percentile": 0.31684}, "CVE-2025-2876": {"epss_score": 0.00194, "epss_percentile": 0.41533}, "CVE-2025-2877": {"epss_score": 0.00085, "epss_percentile": 0.25176}, "CVE-2025-2878": {"epss_score": 0.00046, "epss_percentile": 0.14267}, "CVE-2025-2879": {"epss_score": 0.00017, "epss_percentile": 0.03232}, "CVE-2025-2880": {"epss_score": 0.00052, "epss_percentile": 0.16378}, "CVE-2025-2881": {"epss_score": 0.00095, "epss_percentile": 0.27134}, "CVE-2025-2882": {"epss_score": 0.00118, "epss_percentile": 0.31515}, "CVE-2025-2883": {"epss_score": 0.00118, "epss_percentile": 0.31515}, "CVE-2025-2884": {"epss_score": 0.00019, "epss_percentile": 0.04285}, "CVE-2025-2885": {"epss_score": 0.00074, "epss_percentile": 0.22714}, "CVE-2025-2886": {"epss_score": 0.00024, "epss_percentile": 0.06011}, "CVE-2025-2887": {"epss_score": 0.00056, "epss_percentile": 0.17818}, "CVE-2025-2888": {"epss_score": 0.00056, "epss_percentile": 0.17818}, "CVE-2025-2889": {"epss_score": 0.00053, "epss_percentile": 0.16992}, "CVE-2025-2890": {"epss_score": 0.00037, "epss_percentile": 0.10635}, "CVE-2025-2891": {"epss_score": 0.00506, "epss_percentile": 0.65634}, "CVE-2025-2892": {"epss_score": 0.00033, "epss_percentile": 0.09217}, "CVE-2025-2893": {"epss_score": 0.00034, "epss_percentile": 0.09526}, "CVE-2025-2894": {"epss_score": 0.00112, "epss_percentile": 0.30541}, "CVE-2025-2895": {"epss_score": 0.00023, "epss_percentile": 0.0548}, "CVE-2025-2896": {"epss_score": 0.00018, "epss_percentile": 0.03872}, "CVE-2025-2898": {"epss_score": 0.00028, "epss_percentile": 0.07349}, "CVE-2025-2900": {"epss_score": 0.00036, "epss_percentile": 0.10392}, "CVE-2025-2903": {"epss_score": 0.0003, "epss_percentile": 0.08253}, "CVE-2025-2905": {"epss_score": 0.00043, "epss_percentile": 0.13}, "CVE-2025-2906": {"epss_score": 0.00049, "epss_percentile": 0.15487}, "CVE-2025-2907": {"epss_score": 0.07604, "epss_percentile": 0.91564}, "CVE-2025-2908": {"epss_score": 0.00034, "epss_percentile": 0.09451}, "CVE-2025-2909": {"epss_score": 0.00012, "epss_percentile": 0.01357}, "CVE-2025-2910": {"epss_score": 0.00075, "epss_percentile": 0.23058}, "CVE-2025-2911": {"epss_score": 0.00077, "epss_percentile": 0.23404}, "CVE-2025-2912": {"epss_score": 0.00032, "epss_percentile": 0.09}, "CVE-2025-2913": {"epss_score": 0.00032, "epss_percentile": 0.09}, "CVE-2025-2914": {"epss_score": 0.00032, "epss_percentile": 0.09045}, "CVE-2025-2915": {"epss_score": 0.00032, "epss_percentile": 0.08863}, "CVE-2025-2916": {"epss_score": 0.00416, "epss_percentile": 0.61202}, "CVE-2025-2917": {"epss_score": 0.00171, "epss_percentile": 0.38782}, "CVE-2025-2918": {"epss_score": 0.00036, "epss_percentile": 0.10527}, "CVE-2025-2919": {"epss_score": 0.00029, "epss_percentile": 0.07848}, "CVE-2025-2920": {"epss_score": 0.00013, "epss_percentile": 0.01589}, "CVE-2025-2921": {"epss_score": 0.00031, "epss_percentile": 0.0845}, "CVE-2025-2922": {"epss_score": 0.00013, "epss_percentile": 0.01589}, "CVE-2025-2923": {"epss_score": 0.00032, "epss_percentile": 0.09045}, "CVE-2025-2924": {"epss_score": 0.00032, "epss_percentile": 0.08863}, "CVE-2025-2925": {"epss_score": 0.00032, "epss_percentile": 0.08863}, "CVE-2025-2926": {"epss_score": 0.00032, "epss_percentile": 0.0875}, "CVE-2025-2927": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-2928": {"epss_score": 0.00031, "epss_percentile": 0.08464}, "CVE-2025-2929": {"epss_score": 0.00041, "epss_percentile": 0.12418}, "CVE-2025-2932": {"epss_score": 0.00555, "epss_percentile": 0.67471}, "CVE-2025-2933": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2025-2934": {"epss_score": 0.00142, "epss_percentile": 0.34993}, "CVE-2025-2935": {"epss_score": 0.00015, "epss_percentile": 0.02408}, "CVE-2025-2937": {"epss_score": 0.00121, "epss_percentile": 0.31915}, "CVE-2025-2938": {"epss_score": 0.0001, "epss_percentile": 0.00766}, "CVE-2025-2939": {"epss_score": 0.0013, "epss_percentile": 0.33341}, "CVE-2025-2940": {"epss_score": 0.00154, "epss_percentile": 0.36724}, "CVE-2025-2941": {"epss_score": 0.0149, "epss_percentile": 0.80627}, "CVE-2025-2942": {"epss_score": 0.00039, "epss_percentile": 0.11461}, "CVE-2025-2944": {"epss_score": 0.00032, "epss_percentile": 0.08985}, "CVE-2025-2945": {"epss_score": 0.6337, "epss_percentile": 0.9833}, "CVE-2025-2946": {"epss_score": 0.00044, "epss_percentile": 0.13418}, "CVE-2025-2947": {"epss_score": 0.00056, "epss_percentile": 0.17739}, "CVE-2025-2950": {"epss_score": 0.0005, "epss_percentile": 0.15874}, "CVE-2025-2951": {"epss_score": 0.00073, "epss_percentile": 0.22593}, "CVE-2025-2952": {"epss_score": 0.00063, "epss_percentile": 0.20065}, "CVE-2025-2953": {"epss_score": 0.00045, "epss_percentile": 0.13702}, "CVE-2025-2954": {"epss_score": 0.00024, "epss_percentile": 0.05846}, "CVE-2025-2955": {"epss_score": 0.00082, "epss_percentile": 0.24427}, "CVE-2025-2956": {"epss_score": 0.00032, "epss_percentile": 0.08775}, "CVE-2025-2957": {"epss_score": 0.00032, "epss_percentile": 0.08775}, "CVE-2025-2958": {"epss_score": 0.00288, "epss_percentile": 0.51888}, "CVE-2025-2959": {"epss_score": 0.0026, "epss_percentile": 0.49106}, "CVE-2025-2960": {"epss_score": 0.0026, "epss_percentile": 0.49106}, "CVE-2025-2961": {"epss_score": 0.0009, "epss_percentile": 0.26123}, "CVE-2025-2962": {"epss_score": 0.0003, "epss_percentile": 0.08241}, "CVE-2025-2973": {"epss_score": 0.00097, "epss_percentile": 0.27539}, "CVE-2025-2974": {"epss_score": 0.00049, "epss_percentile": 0.15367}, "CVE-2025-2975": {"epss_score": 0.00044, "epss_percentile": 0.1367}, "CVE-2025-2976": {"epss_score": 0.00022, "epss_percentile": 0.04984}, "CVE-2025-2977": {"epss_score": 0.00044, "epss_percentile": 0.1367}, "CVE-2025-2978": {"epss_score": 0.00106, "epss_percentile": 0.29537}, "CVE-2025-2979": {"epss_score": 0.00047, "epss_percentile": 0.14851}, "CVE-2025-2980": {"epss_score": 0.00035, "epss_percentile": 0.0997}, "CVE-2025-2981": {"epss_score": 0.0004, "epss_percentile": 0.12005}, "CVE-2025-2982": {"epss_score": 0.00057, "epss_percentile": 0.18217}, "CVE-2025-2983": {"epss_score": 0.0022, "epss_percentile": 0.4455}, "CVE-2025-2984": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-2985": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-2986": {"epss_score": 0.0002, "epss_percentile": 0.04477}, "CVE-2025-2987": {"epss_score": 0.00038, "epss_percentile": 0.11408}, "CVE-2025-2988": {"epss_score": 0.00046, "epss_percentile": 0.14347}, "CVE-2025-2989": {"epss_score": 0.0014, "epss_percentile": 0.34752}, "CVE-2025-2990": {"epss_score": 0.0014, "epss_percentile": 0.34752}, "CVE-2025-2991": {"epss_score": 0.00235, "epss_percentile": 0.46219}, "CVE-2025-2992": {"epss_score": 0.00235, "epss_percentile": 0.46219}, "CVE-2025-2993": {"epss_score": 0.00152, "epss_percentile": 0.36469}, "CVE-2025-2994": {"epss_score": 0.0014, "epss_percentile": 0.34752}, "CVE-2025-2995": {"epss_score": 0.0014, "epss_percentile": 0.34752}, "CVE-2025-2996": {"epss_score": 0.00235, "epss_percentile": 0.46219}, "CVE-2025-2997": {"epss_score": 0.00101, "epss_percentile": 0.28625}, "CVE-2025-2998": {"epss_score": 0.00036, "epss_percentile": 0.10208}, "CVE-2025-2999": {"epss_score": 0.00036, "epss_percentile": 0.10208}, "CVE-2025-30000": {"epss_score": 0.00017, "epss_percentile": 0.03327}, "CVE-2025-30001": {"epss_score": 0.00124, "epss_percentile": 0.32388}, "CVE-2025-30002": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-30003": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-30004": {"epss_score": 0.61226, "epss_percentile": 0.98241}, "CVE-2025-30005": {"epss_score": 0.5477, "epss_percentile": 0.97943}, "CVE-2025-30006": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-30009": {"epss_score": 0.00109, "epss_percentile": 0.29955}, "CVE-2025-30010": {"epss_score": 0.00094, "epss_percentile": 0.26792}, "CVE-2025-30011": {"epss_score": 0.00051, "epss_percentile": 0.16151}, "CVE-2025-30012": {"epss_score": 0.00619, "epss_percentile": 0.69431}, "CVE-2025-30013": {"epss_score": 0.00074, "epss_percentile": 0.22879}, "CVE-2025-30014": {"epss_score": 0.00371, "epss_percentile": 0.58365}, "CVE-2025-30015": {"epss_score": 0.00068, "epss_percentile": 0.21271}, "CVE-2025-30016": {"epss_score": 0.00265, "epss_percentile": 0.49808}, "CVE-2025-30017": {"epss_score": 0.00025, "epss_percentile": 0.06274}, "CVE-2025-30018": {"epss_score": 0.00114, "epss_percentile": 0.30781}, "CVE-2025-30022": {"epss_score": 0.00089, "epss_percentile": 0.25822}, "CVE-2025-30023": {"epss_score": 0.01916, "epss_percentile": 0.8286}, "CVE-2025-30024": {"epss_score": 0.00026, "epss_percentile": 0.06474}, "CVE-2025-30025": {"epss_score": 0.00037, "epss_percentile": 0.10641}, "CVE-2025-30026": {"epss_score": 0.00034, "epss_percentile": 0.0975}, "CVE-2025-30027": {"epss_score": 0.00025, "epss_percentile": 0.06345}, "CVE-2025-30030": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-30031": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-30032": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-30033": {"epss_score": 0.00014, "epss_percentile": 0.01995}, "CVE-2025-30034": {"epss_score": 0.0001, "epss_percentile": 0.00898}, "CVE-2025-30036": {"epss_score": 0.00054, "epss_percentile": 0.17296}, "CVE-2025-30037": {"epss_score": 0.00045, "epss_percentile": 0.13717}, "CVE-2025-30038": {"epss_score": 0.00027, "epss_percentile": 0.07152}, "CVE-2025-30039": {"epss_score": 0.00032, "epss_percentile": 0.08729}, "CVE-2025-30040": {"epss_score": 0.00052, "epss_percentile": 0.16614}, "CVE-2025-30041": {"epss_score": 0.00032, "epss_percentile": 0.08729}, "CVE-2025-30048": {"epss_score": 0.00045, "epss_percentile": 0.13717}, "CVE-2025-30055": {"epss_score": 0.00053, "epss_percentile": 0.16904}, "CVE-2025-30056": {"epss_score": 0.00053, "epss_percentile": 0.16904}, "CVE-2025-30057": {"epss_score": 0.00698, "epss_percentile": 0.71425}, "CVE-2025-30058": {"epss_score": 0.00037, "epss_percentile": 0.1078}, "CVE-2025-30059": {"epss_score": 0.00037, "epss_percentile": 0.1078}, "CVE-2025-30060": {"epss_score": 0.00037, "epss_percentile": 0.1078}, "CVE-2025-30061": {"epss_score": 0.00037, "epss_percentile": 0.1078}, "CVE-2025-30063": {"epss_score": 0.00027, "epss_percentile": 0.06783}, "CVE-2025-30064": {"epss_score": 0.00012, "epss_percentile": 0.01153}, "CVE-2025-30065": {"epss_score": 0.00289, "epss_percentile": 0.52007}, "CVE-2025-30066": {"epss_score": 0.90878, "epss_percentile": 0.99607}, "CVE-2025-30067": {"epss_score": 0.0029, "epss_percentile": 0.52086}, "CVE-2025-30072": {"epss_score": 0.00057, "epss_percentile": 0.18219}, "CVE-2025-30073": {"epss_score": 0.00075, "epss_percentile": 0.23047}, "CVE-2025-30074": {"epss_score": 0.0002, "epss_percentile": 0.04561}, "CVE-2025-30075": {"epss_score": 0.00016, "epss_percentile": 0.0289}, "CVE-2025-30076": {"epss_score": 0.00067, "epss_percentile": 0.20976}, "CVE-2025-30077": {"epss_score": 0.00036, "epss_percentile": 0.10249}, "CVE-2025-30080": {"epss_score": 0.00207, "epss_percentile": 0.4312}, "CVE-2025-30084": {"epss_score": 0.00026, "epss_percentile": 0.06436}, "CVE-2025-30085": {"epss_score": 0.00423, "epss_percentile": 0.61635}, "CVE-2025-30086": {"epss_score": 0.00045, "epss_percentile": 0.13821}, "CVE-2025-30087": {"epss_score": 0.00037, "epss_percentile": 0.10889}, "CVE-2025-30089": {"epss_score": 0.00131, "epss_percentile": 0.33365}, "CVE-2025-30090": {"epss_score": 0.00057, "epss_percentile": 0.18022}, "CVE-2025-30091": {"epss_score": 0.00967, "epss_percentile": 0.76067}, "CVE-2025-30092": {"epss_score": 0.00064, "epss_percentile": 0.20397}, "CVE-2025-30093": {"epss_score": 0.00065, "epss_percentile": 0.20504}, "CVE-2025-30095": {"epss_score": 0.00086, "epss_percentile": 0.25412}, "CVE-2025-30096": {"epss_score": 0.00014, "epss_percentile": 0.01815}, "CVE-2025-30097": {"epss_score": 0.00014, "epss_percentile": 0.01815}, "CVE-2025-30098": {"epss_score": 0.00014, "epss_percentile": 0.01815}, "CVE-2025-30099": {"epss_score": 0.00028, "epss_percentile": 0.07252}, "CVE-2025-30100": {"epss_score": 0.00016, "epss_percentile": 0.02852}, "CVE-2025-30101": {"epss_score": 0.0002, "epss_percentile": 0.04597}, "CVE-2025-30102": {"epss_score": 0.00031, "epss_percentile": 0.0832}, "CVE-2025-30103": {"epss_score": 0.00015, "epss_percentile": 0.02275}, "CVE-2025-30105": {"epss_score": 0.00016, "epss_percentile": 0.03028}, "CVE-2025-30106": {"epss_score": 0.00063, "epss_percentile": 0.19906}, "CVE-2025-30107": {"epss_score": 0.00088, "epss_percentile": 0.25701}, "CVE-2025-30109": {"epss_score": 0.00048, "epss_percentile": 0.15182}, "CVE-2025-30110": {"epss_score": 0.00052, "epss_percentile": 0.16383}, "CVE-2025-30111": {"epss_score": 0.00114, "epss_percentile": 0.30844}, "CVE-2025-30112": {"epss_score": 0.00057, "epss_percentile": 0.18171}, "CVE-2025-30113": {"epss_score": 0.00159, "epss_percentile": 0.37403}, "CVE-2025-30114": {"epss_score": 0.00126, "epss_percentile": 0.32636}, "CVE-2025-30115": {"epss_score": 0.00159, "epss_percentile": 0.37403}, "CVE-2025-30116": {"epss_score": 0.00341, "epss_percentile": 0.5632}, "CVE-2025-30117": {"epss_score": 0.00182, "epss_percentile": 0.40192}, "CVE-2025-30118": {"epss_score": 0.00085, "epss_percentile": 0.25101}, "CVE-2025-30122": {"epss_score": 0.00159, "epss_percentile": 0.37403}, "CVE-2025-30123": {"epss_score": 0.00159, "epss_percentile": 0.37403}, "CVE-2025-30124": {"epss_score": 0.00042, "epss_percentile": 0.12498}, "CVE-2025-30125": {"epss_score": 0.00076, "epss_percentile": 0.2317}, "CVE-2025-30126": {"epss_score": 0.00057, "epss_percentile": 0.18074}, "CVE-2025-30127": {"epss_score": 0.00051, "epss_percentile": 0.16233}, "CVE-2025-30131": {"epss_score": 0.0019, "epss_percentile": 0.41101}, "CVE-2025-30132": {"epss_score": 0.00084, "epss_percentile": 0.24951}, "CVE-2025-30133": {"epss_score": 0.00105, "epss_percentile": 0.29343}, "CVE-2025-30135": {"epss_score": 0.00093, "epss_percentile": 0.26689}, "CVE-2025-30137": {"epss_score": 0.00154, "epss_percentile": 0.36711}, "CVE-2025-30138": {"epss_score": 0.00041, "epss_percentile": 0.12268}, "CVE-2025-30139": {"epss_score": 0.00133, "epss_percentile": 0.33742}, "CVE-2025-30140": {"epss_score": 0.00089, "epss_percentile": 0.25881}, "CVE-2025-30141": {"epss_score": 0.00105, "epss_percentile": 0.29255}, "CVE-2025-30142": {"epss_score": 0.00058, "epss_percentile": 0.18406}, "CVE-2025-30143": {"epss_score": 0.00065, "epss_percentile": 0.20463}, "CVE-2025-30144": {"epss_score": 0.01694, "epss_percentile": 0.81801}, "CVE-2025-30145": {"epss_score": 0.00041, "epss_percentile": 0.12391}, "CVE-2025-30147": {"epss_score": 0.00034, "epss_percentile": 0.09527}, "CVE-2025-30148": {"epss_score": 0.00055, "epss_percentile": 0.17366}, "CVE-2025-30149": {"epss_score": 0.00248, "epss_percentile": 0.47999}, "CVE-2025-30150": {"epss_score": 0.00109, "epss_percentile": 0.29932}, "CVE-2025-30151": {"epss_score": 0.00135, "epss_percentile": 0.34016}, "CVE-2025-30152": {"epss_score": 0.001, "epss_percentile": 0.28482}, "CVE-2025-30153": {"epss_score": 0.00282, "epss_percentile": 0.51232}, "CVE-2025-30154": {"epss_score": 0.17943, "epss_percentile": 0.94931}, "CVE-2025-30155": {"epss_score": 0.00058, "epss_percentile": 0.18536}, "CVE-2025-30157": {"epss_score": 0.00012, "epss_percentile": 0.01251}, "CVE-2025-30158": {"epss_score": 0.00132, "epss_percentile": 0.33596}, "CVE-2025-30159": {"epss_score": 0.00158, "epss_percentile": 0.37165}, "CVE-2025-30160": {"epss_score": 0.00236, "epss_percentile": 0.46373}, "CVE-2025-30161": {"epss_score": 0.00195, "epss_percentile": 0.41648}, "CVE-2025-30162": {"epss_score": 9e-05, "epss_percentile": 0.00723}, "CVE-2025-30163": {"epss_score": 0.00044, "epss_percentile": 0.13396}, "CVE-2025-30164": {"epss_score": 0.00062, "epss_percentile": 0.196}, "CVE-2025-30165": {"epss_score": 0.00482, "epss_percentile": 0.64525}, "CVE-2025-30166": {"epss_score": 1e-05, "epss_percentile": 1e-05}, "CVE-2025-30167": {"epss_score": 0.00017, "epss_percentile": 0.03099}, "CVE-2025-30168": {"epss_score": 0.00154, "epss_percentile": 0.36737}, "CVE-2025-30169": {"epss_score": 0.00042, "epss_percentile": 0.12715}, "CVE-2025-30170": {"epss_score": 0.00041, "epss_percentile": 0.12341}, "CVE-2025-30171": {"epss_score": 0.00065, "epss_percentile": 0.20627}, "CVE-2025-30172": {"epss_score": 0.00351, "epss_percentile": 0.57006}, "CVE-2025-30173": {"epss_score": 0.00042, "epss_percentile": 0.12715}, "CVE-2025-30174": {"epss_score": 0.00089, "epss_percentile": 0.25837}, "CVE-2025-30175": {"epss_score": 0.00089, "epss_percentile": 0.25837}, "CVE-2025-30176": {"epss_score": 0.00089, "epss_percentile": 0.25837}, "CVE-2025-30177": {"epss_score": 0.0017, "epss_percentile": 0.387}, "CVE-2025-30179": {"epss_score": 0.00026, "epss_percentile": 0.06458}, "CVE-2025-30182": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2025-30183": {"epss_score": 0.00058, "epss_percentile": 0.18399}, "CVE-2025-30184": {"epss_score": 0.00165, "epss_percentile": 0.38045}, "CVE-2025-30185": {"epss_score": 0.00017, "epss_percentile": 0.03248}, "CVE-2025-30186": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-30187": {"epss_score": 8e-05, "epss_percentile": 0.00536}, "CVE-2025-30188": {"epss_score": 0.0006, "epss_percentile": 0.19004}, "CVE-2025-30189": {"epss_score": 0.00044, "epss_percentile": 0.13388}, "CVE-2025-30190": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-30191": {"epss_score": 0.00036, "epss_percentile": 0.10504}, "CVE-2025-30192": {"epss_score": 0.00033, "epss_percentile": 0.09399}, "CVE-2025-30193": {"epss_score": 0.00069, "epss_percentile": 0.21482}, "CVE-2025-30194": {"epss_score": 0.00128, "epss_percentile": 0.32969}, "CVE-2025-30195": {"epss_score": 0.00082, "epss_percentile": 0.24504}, "CVE-2025-30196": {"epss_score": 0.00144, "epss_percentile": 0.35324}, "CVE-2025-30197": {"epss_score": 0.0004, "epss_percentile": 0.12063}, "CVE-2025-30198": {"epss_score": 0.00017, "epss_percentile": 0.03444}, "CVE-2025-30199": {"epss_score": 0.00021, "epss_percentile": 0.0488}, "CVE-2025-30200": {"epss_score": 0.00011, "epss_percentile": 0.0106}, "CVE-2025-30201": {"epss_score": 0.0027, "epss_percentile": 0.50208}, "CVE-2025-30202": {"epss_score": 0.00169, "epss_percentile": 0.38607}, "CVE-2025-30203": {"epss_score": 0.00052, "epss_percentile": 0.16645}, "CVE-2025-30204": {"epss_score": 0.00087, "epss_percentile": 0.25514}, "CVE-2025-30205": {"epss_score": 0.00066, "epss_percentile": 0.20677}, "CVE-2025-30206": {"epss_score": 0.00047, "epss_percentile": 0.14648}, "CVE-2025-30207": {"epss_score": 0.00084, "epss_percentile": 0.24838}, "CVE-2025-30208": {"epss_score": 0.88123, "epss_percentile": 0.99458}, "CVE-2025-30209": {"epss_score": 0.00076, "epss_percentile": 0.2325}, "CVE-2025-30210": {"epss_score": 0.00057, "epss_percentile": 0.18222}, "CVE-2025-30211": {"epss_score": 0.00116, "epss_percentile": 0.31182}, "CVE-2025-30212": {"epss_score": 0.00083, "epss_percentile": 0.24738}, "CVE-2025-30213": {"epss_score": 0.0068, "epss_percentile": 0.71036}, "CVE-2025-30214": {"epss_score": 0.00111, "epss_percentile": 0.30239}, "CVE-2025-30215": {"epss_score": 0.00021, "epss_percentile": 0.04936}, "CVE-2025-30216": {"epss_score": 0.05628, "epss_percentile": 0.90066}, "CVE-2025-30217": {"epss_score": 0.00075, "epss_percentile": 0.23013}, "CVE-2025-30218": {"epss_score": 0.00064, "epss_percentile": 0.20266}, "CVE-2025-30219": {"epss_score": 0.00144, "epss_percentile": 0.35318}, "CVE-2025-30220": {"epss_score": 0.068, "epss_percentile": 0.91034}, "CVE-2025-30221": {"epss_score": 0.00086, "epss_percentile": 0.25421}, "CVE-2025-30222": {"epss_score": 0.00047, "epss_percentile": 0.14617}, "CVE-2025-30223": {"epss_score": 0.0011, "epss_percentile": 0.30223}, "CVE-2025-30224": {"epss_score": 0.00167, "epss_percentile": 0.38368}, "CVE-2025-30225": {"epss_score": 0.00149, "epss_percentile": 0.35993}, "CVE-2025-30232": {"epss_score": 0.00025, "epss_percentile": 0.06349}, "CVE-2025-30234": {"epss_score": 0.0005, "epss_percentile": 0.15833}, "CVE-2025-30235": {"epss_score": 0.00055, "epss_percentile": 0.17377}, "CVE-2025-30236": {"epss_score": 0.00131, "epss_percentile": 0.33391}, "CVE-2025-30247": {"epss_score": 0.01544, "epss_percentile": 0.80958}, "CVE-2025-30254": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-30255": {"epss_score": 0.00035, "epss_percentile": 0.10016}, "CVE-2025-30256": {"epss_score": 0.00129, "epss_percentile": 0.3309}, "CVE-2025-30257": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-30258": {"epss_score": 0.00025, "epss_percentile": 0.06148}, "CVE-2025-30259": {"epss_score": 0.00068, "epss_percentile": 0.2124}, "CVE-2025-30260": {"epss_score": 0.00206, "epss_percentile": 0.42948}, "CVE-2025-30261": {"epss_score": 0.00206, "epss_percentile": 0.42948}, "CVE-2025-30262": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-30263": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-30264": {"epss_score": 0.00419, "epss_percentile": 0.61399}, "CVE-2025-30265": {"epss_score": 0.00185, "epss_percentile": 0.40577}, "CVE-2025-30267": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-30268": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-30270": {"epss_score": 0.00087, "epss_percentile": 0.25458}, "CVE-2025-30271": {"epss_score": 0.00087, "epss_percentile": 0.25458}, "CVE-2025-30272": {"epss_score": 0.00074, "epss_percentile": 0.22833}, "CVE-2025-30273": {"epss_score": 0.00203, "epss_percentile": 0.42524}, "CVE-2025-30274": {"epss_score": 0.00074, "epss_percentile": 0.22833}, "CVE-2025-30275": {"epss_score": 0.00203, "epss_percentile": 0.42587}, "CVE-2025-30277": {"epss_score": 0.00117, "epss_percentile": 0.31239}, "CVE-2025-30278": {"epss_score": 0.00117, "epss_percentile": 0.31239}, "CVE-2025-30279": {"epss_score": 0.00078, "epss_percentile": 0.23793}, "CVE-2025-30280": {"epss_score": 0.00056, "epss_percentile": 0.17952}, "CVE-2025-30281": {"epss_score": 0.02486, "epss_percentile": 0.84887}, "CVE-2025-30282": {"epss_score": 0.00545, "epss_percentile": 0.67172}, "CVE-2025-30284": {"epss_score": 0.3001, "epss_percentile": 0.96493}, "CVE-2025-30285": {"epss_score": 0.31003, "epss_percentile": 0.96581}, "CVE-2025-30286": {"epss_score": 0.01157, "epss_percentile": 0.78109}, "CVE-2025-30287": {"epss_score": 0.00029, "epss_percentile": 0.07652}, "CVE-2025-30288": {"epss_score": 0.0003, "epss_percentile": 0.07988}, "CVE-2025-30289": {"epss_score": 0.00032, "epss_percentile": 0.08866}, "CVE-2025-30290": {"epss_score": 0.00169, "epss_percentile": 0.38639}, "CVE-2025-30291": {"epss_score": 0.00065, "epss_percentile": 0.2065}, "CVE-2025-30292": {"epss_score": 0.00159, "epss_percentile": 0.37386}, "CVE-2025-30293": {"epss_score": 0.00333, "epss_percentile": 0.55639}, "CVE-2025-30294": {"epss_score": 0.00494, "epss_percentile": 0.65069}, "CVE-2025-30295": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-30296": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-30297": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-30298": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-30299": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-30300": {"epss_score": 0.00031, "epss_percentile": 0.08667}, "CVE-2025-30301": {"epss_score": 0.00029, "epss_percentile": 0.07844}, "CVE-2025-30302": {"epss_score": 0.00042, "epss_percentile": 0.12626}, "CVE-2025-30303": {"epss_score": 0.00042, "epss_percentile": 0.12626}, "CVE-2025-30304": {"epss_score": 0.00043, "epss_percentile": 0.13037}, "CVE-2025-30305": {"epss_score": 0.00045, "epss_percentile": 0.13999}, "CVE-2025-30306": {"epss_score": 0.00045, "epss_percentile": 0.13999}, "CVE-2025-30307": {"epss_score": 0.00045, "epss_percentile": 0.13999}, "CVE-2025-30308": {"epss_score": 0.00045, "epss_percentile": 0.13999}, "CVE-2025-30309": {"epss_score": 0.00045, "epss_percentile": 0.13999}, "CVE-2025-30310": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-30312": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-30313": {"epss_score": 0.00023, "epss_percentile": 0.05395}, "CVE-2025-30314": {"epss_score": 0.00062, "epss_percentile": 0.19658}, "CVE-2025-30315": {"epss_score": 0.00062, "epss_percentile": 0.19658}, "CVE-2025-30316": {"epss_score": 0.00026, "epss_percentile": 0.06551}, "CVE-2025-30317": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-30318": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-30319": {"epss_score": 0.00021, "epss_percentile": 0.04813}, "CVE-2025-30320": {"epss_score": 0.00021, "epss_percentile": 0.04813}, "CVE-2025-30321": {"epss_score": 0.00021, "epss_percentile": 0.04813}, "CVE-2025-30322": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-30324": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-30325": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-30326": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-30327": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-30328": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-30329": {"epss_score": 0.00021, "epss_percentile": 0.04813}, "CVE-2025-30330": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-30334": {"epss_score": 0.00104, "epss_percentile": 0.29105}, "CVE-2025-30342": {"epss_score": 0.00077, "epss_percentile": 0.23543}, "CVE-2025-30343": {"epss_score": 0.00365, "epss_percentile": 0.58005}, "CVE-2025-30344": {"epss_score": 0.00082, "epss_percentile": 0.24403}, "CVE-2025-30345": {"epss_score": 0.00066, "epss_percentile": 0.20741}, "CVE-2025-30346": {"epss_score": 0.00119, "epss_percentile": 0.31609}, "CVE-2025-30347": {"epss_score": 0.00078, "epss_percentile": 0.23795}, "CVE-2025-30348": {"epss_score": 0.00152, "epss_percentile": 0.36433}, "CVE-2025-30349": {"epss_score": 0.17821, "epss_percentile": 0.94912}, "CVE-2025-30350": {"epss_score": 0.00162, "epss_percentile": 0.37647}, "CVE-2025-30351": {"epss_score": 0.00253, "epss_percentile": 0.48448}, "CVE-2025-30352": {"epss_score": 0.00086, "epss_percentile": 0.25331}, "CVE-2025-30353": {"epss_score": 0.00128, "epss_percentile": 0.33019}, "CVE-2025-30354": {"epss_score": 0.00059, "epss_percentile": 0.18808}, "CVE-2025-30355": {"epss_score": 0.07168, "epss_percentile": 0.91296}, "CVE-2025-30356": {"epss_score": 0.00162, "epss_percentile": 0.37754}, "CVE-2025-30357": {"epss_score": 0.00078, "epss_percentile": 0.23636}, "CVE-2025-30358": {"epss_score": 0.01183, "epss_percentile": 0.78323}, "CVE-2025-30359": {"epss_score": 0.00053, "epss_percentile": 0.17005}, "CVE-2025-30360": {"epss_score": 0.0003, "epss_percentile": 0.08244}, "CVE-2025-30361": {"epss_score": 0.00091, "epss_percentile": 0.26195}, "CVE-2025-30362": {"epss_score": 0.00046, "epss_percentile": 0.14115}, "CVE-2025-30363": {"epss_score": 0.0005, "epss_percentile": 0.15713}, "CVE-2025-30364": {"epss_score": 0.00206, "epss_percentile": 0.42927}, "CVE-2025-30365": {"epss_score": 0.00189, "epss_percentile": 0.40981}, "CVE-2025-30366": {"epss_score": 0.00046, "epss_percentile": 0.14085}, "CVE-2025-30367": {"epss_score": 0.00089, "epss_percentile": 0.25808}, "CVE-2025-30368": {"epss_score": 0.00059, "epss_percentile": 0.18622}, "CVE-2025-30369": {"epss_score": 0.0005, "epss_percentile": 0.15959}, "CVE-2025-30370": {"epss_score": 0.00029, "epss_percentile": 0.07764}, "CVE-2025-30371": {"epss_score": 0.00115, "epss_percentile": 0.3102}, "CVE-2025-30372": {"epss_score": 0.00089, "epss_percentile": 0.25918}, "CVE-2025-30373": {"epss_score": 0.00019, "epss_percentile": 0.04337}, "CVE-2025-30375": {"epss_score": 0.00128, "epss_percentile": 0.33015}, "CVE-2025-30376": {"epss_score": 0.00082, "epss_percentile": 0.24456}, "CVE-2025-30377": {"epss_score": 0.00083, "epss_percentile": 0.24642}, "CVE-2025-30378": {"epss_score": 0.00378, "epss_percentile": 0.58806}, "CVE-2025-30379": {"epss_score": 0.00082, "epss_percentile": 0.24456}, "CVE-2025-30381": {"epss_score": 0.00082, "epss_percentile": 0.24456}, "CVE-2025-30382": {"epss_score": 0.00356, "epss_percentile": 0.57372}, "CVE-2025-30383": {"epss_score": 0.00128, "epss_percentile": 0.33015}, "CVE-2025-30384": {"epss_score": 0.00966, "epss_percentile": 0.76053}, "CVE-2025-30385": {"epss_score": 0.00072, "epss_percentile": 0.2242}, "CVE-2025-30386": {"epss_score": 0.00065, "epss_percentile": 0.20615}, "CVE-2025-30387": {"epss_score": 0.00137, "epss_percentile": 0.34287}, "CVE-2025-30388": {"epss_score": 0.00087, "epss_percentile": 0.25548}, "CVE-2025-30389": {"epss_score": 0.0007, "epss_percentile": 0.21809}, "CVE-2025-30390": {"epss_score": 0.00156, "epss_percentile": 0.37001}, "CVE-2025-30391": {"epss_score": 0.00111, "epss_percentile": 0.30377}, "CVE-2025-30392": {"epss_score": 0.00178, "epss_percentile": 0.39678}, "CVE-2025-30393": {"epss_score": 0.00082, "epss_percentile": 0.24456}, "CVE-2025-30394": {"epss_score": 0.00111, "epss_percentile": 0.30347}, "CVE-2025-30397": {"epss_score": 0.21265, "epss_percentile": 0.95491}, "CVE-2025-30398": {"epss_score": 0.00046, "epss_percentile": 0.1417}, "CVE-2025-30399": {"epss_score": 0.00035, "epss_percentile": 0.09923}, "CVE-2025-30400": {"epss_score": 0.01126, "epss_percentile": 0.77813}, "CVE-2025-30401": {"epss_score": 0.00105, "epss_percentile": 0.29269}, "CVE-2025-30402": {"epss_score": 0.00057, "epss_percentile": 0.18057}, "CVE-2025-30403": {"epss_score": 0.00042, "epss_percentile": 0.12711}, "CVE-2025-30404": {"epss_score": 0.00084, "epss_percentile": 0.24907}, "CVE-2025-30405": {"epss_score": 0.00084, "epss_percentile": 0.24907}, "CVE-2025-30406": {"epss_score": 0.86805, "epss_percentile": 0.99398}, "CVE-2025-30407": {"epss_score": 0.00019, "epss_percentile": 0.0436}, "CVE-2025-30408": {"epss_score": 0.00016, "epss_percentile": 0.02778}, "CVE-2025-30409": {"epss_score": 0.00028, "epss_percentile": 0.07337}, "CVE-2025-30415": {"epss_score": 0.00093, "epss_percentile": 0.26663}, "CVE-2025-30417": {"epss_score": 0.00018, "epss_percentile": 0.0386}, "CVE-2025-30418": {"epss_score": 0.00018, "epss_percentile": 0.0386}, "CVE-2025-30419": {"epss_score": 0.00018, "epss_percentile": 0.0386}, "CVE-2025-30420": {"epss_score": 0.00018, "epss_percentile": 0.0386}, "CVE-2025-30421": {"epss_score": 0.00018, "epss_percentile": 0.0386}, "CVE-2025-30422": {"epss_score": 0.00027, "epss_percentile": 0.06743}, "CVE-2025-30424": {"epss_score": 0.00178, "epss_percentile": 0.39633}, "CVE-2025-30425": {"epss_score": 0.00103, "epss_percentile": 0.29008}, "CVE-2025-30426": {"epss_score": 0.00199, "epss_percentile": 0.42111}, "CVE-2025-30427": {"epss_score": 0.00286, "epss_percentile": 0.51708}, "CVE-2025-30428": {"epss_score": 0.00033, "epss_percentile": 0.09183}, "CVE-2025-30429": {"epss_score": 0.0004, "epss_percentile": 0.12113}, "CVE-2025-30430": {"epss_score": 0.00161, "epss_percentile": 0.376}, "CVE-2025-30432": {"epss_score": 0.00131, "epss_percentile": 0.33461}, "CVE-2025-30433": {"epss_score": 0.00156, "epss_percentile": 0.36966}, "CVE-2025-30434": {"epss_score": 0.00026, "epss_percentile": 0.06593}, "CVE-2025-30435": {"epss_score": 0.00023, "epss_percentile": 0.05491}, "CVE-2025-30436": {"epss_score": 0.00071, "epss_percentile": 0.22147}, "CVE-2025-30437": {"epss_score": 0.00064, "epss_percentile": 0.20302}, "CVE-2025-30438": {"epss_score": 0.00021, "epss_percentile": 0.04768}, "CVE-2025-30439": {"epss_score": 0.00055, "epss_percentile": 0.17429}, "CVE-2025-30440": {"epss_score": 0.00013, "epss_percentile": 0.01605}, "CVE-2025-30441": {"epss_score": 0.00022, "epss_percentile": 0.05138}, "CVE-2025-30442": {"epss_score": 0.00031, "epss_percentile": 0.08323}, "CVE-2025-30443": {"epss_score": 0.00027, "epss_percentile": 0.06842}, "CVE-2025-30444": {"epss_score": 0.00137, "epss_percentile": 0.34323}, "CVE-2025-30445": {"epss_score": 0.00039, "epss_percentile": 0.11663}, "CVE-2025-30446": {"epss_score": 0.00184, "epss_percentile": 0.40402}, "CVE-2025-30447": {"epss_score": 0.0003, "epss_percentile": 0.08265}, "CVE-2025-30448": {"epss_score": 0.00143, "epss_percentile": 0.35203}, "CVE-2025-30449": {"epss_score": 0.00028, "epss_percentile": 0.07341}, "CVE-2025-30450": {"epss_score": 0.00025, "epss_percentile": 0.06339}, "CVE-2025-30451": {"epss_score": 0.00023, "epss_percentile": 0.05491}, "CVE-2025-30452": {"epss_score": 0.00234, "epss_percentile": 0.46083}, "CVE-2025-30453": {"epss_score": 0.00016, "epss_percentile": 0.02858}, "CVE-2025-30454": {"epss_score": 0.00029, "epss_percentile": 0.07755}, "CVE-2025-30455": {"epss_score": 0.00026, "epss_percentile": 0.06406}, "CVE-2025-30456": {"epss_score": 0.00019, "epss_percentile": 0.04295}, "CVE-2025-30457": {"epss_score": 0.00245, "epss_percentile": 0.47664}, "CVE-2025-30458": {"epss_score": 0.00134, "epss_percentile": 0.33782}, "CVE-2025-30460": {"epss_score": 0.00055, "epss_percentile": 0.17495}, "CVE-2025-30461": {"epss_score": 0.00093, "epss_percentile": 0.26667}, "CVE-2025-30462": {"epss_score": 0.00132, "epss_percentile": 0.33552}, "CVE-2025-30463": {"epss_score": 0.00021, "epss_percentile": 0.04911}, "CVE-2025-30464": {"epss_score": 0.00021, "epss_percentile": 0.0494}, "CVE-2025-30465": {"epss_score": 0.00095, "epss_percentile": 0.27151}, "CVE-2025-30466": {"epss_score": 0.00037, "epss_percentile": 0.10889}, "CVE-2025-30467": {"epss_score": 0.00082, "epss_percentile": 0.24417}, "CVE-2025-30468": {"epss_score": 0.00059, "epss_percentile": 0.18807}, "CVE-2025-30469": {"epss_score": 0.00029, "epss_percentile": 0.07937}, "CVE-2025-30470": {"epss_score": 0.00021, "epss_percentile": 0.04884}, "CVE-2025-30471": {"epss_score": 0.00287, "epss_percentile": 0.51817}, "CVE-2025-30472": {"epss_score": 0.00192, "epss_percentile": 0.41322}, "CVE-2025-30473": {"epss_score": 0.00077, "epss_percentile": 0.23356}, "CVE-2025-30474": {"epss_score": 0.00213, "epss_percentile": 0.43829}, "CVE-2025-30475": {"epss_score": 0.00091, "epss_percentile": 0.26272}, "CVE-2025-30476": {"epss_score": 0.00111, "epss_percentile": 0.30348}, "CVE-2025-30477": {"epss_score": 0.00017, "epss_percentile": 0.03135}, "CVE-2025-30479": {"epss_score": 0.00732, "epss_percentile": 0.72194}, "CVE-2025-30480": {"epss_score": 0.00066, "epss_percentile": 0.20769}, "CVE-2025-30483": {"epss_score": 0.00015, "epss_percentile": 0.02275}, "CVE-2025-30485": {"epss_score": 0.00055, "epss_percentile": 0.17495}, "CVE-2025-30506": {"epss_score": 0.00015, "epss_percentile": 0.02469}, "CVE-2025-30507": {"epss_score": 0.00063, "epss_percentile": 0.19925}, "CVE-2025-30509": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-30510": {"epss_score": 0.00048, "epss_percentile": 0.14992}, "CVE-2025-30511": {"epss_score": 0.00068, "epss_percentile": 0.21395}, "CVE-2025-30512": {"epss_score": 0.00227, "epss_percentile": 0.45403}, "CVE-2025-30514": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-30515": {"epss_score": 0.00132, "epss_percentile": 0.33532}, "CVE-2025-30516": {"epss_score": 0.00052, "epss_percentile": 0.16592}, "CVE-2025-30518": {"epss_score": 0.00012, "epss_percentile": 0.01132}, "CVE-2025-30519": {"epss_score": 0.00062, "epss_percentile": 0.19687}, "CVE-2025-30520": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30521": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2025-30522": {"epss_score": 0.00027, "epss_percentile": 0.06792}, "CVE-2025-30523": {"epss_score": 0.00059, "epss_percentile": 0.18625}, "CVE-2025-30524": {"epss_score": 0.00079, "epss_percentile": 0.23978}, "CVE-2025-30525": {"epss_score": 0.00059, "epss_percentile": 0.18625}, "CVE-2025-30526": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2025-30527": {"epss_score": 0.00047, "epss_percentile": 0.14589}, "CVE-2025-30528": {"epss_score": 0.0004, "epss_percentile": 0.12048}, "CVE-2025-30529": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2025-30530": {"epss_score": 0.00047, "epss_percentile": 0.14589}, "CVE-2025-30531": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2025-30532": {"epss_score": 0.00047, "epss_percentile": 0.14589}, "CVE-2025-30533": {"epss_score": 0.00063, "epss_percentile": 0.19883}, "CVE-2025-30534": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2025-30535": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2025-30536": {"epss_score": 0.00047, "epss_percentile": 0.14589}, "CVE-2025-30537": {"epss_score": 0.00047, "epss_percentile": 0.14589}, "CVE-2025-30538": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2025-30539": {"epss_score": 0.00047, "epss_percentile": 0.14589}, "CVE-2025-30540": {"epss_score": 0.00047, "epss_percentile": 0.14589}, "CVE-2025-30541": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2025-30542": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2025-30543": {"epss_score": 0.00059, "epss_percentile": 0.18827}, "CVE-2025-30544": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30545": {"epss_score": 0.00047, "epss_percentile": 0.14589}, "CVE-2025-30546": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2025-30547": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30548": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30549": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2025-30550": {"epss_score": 0.00027, "epss_percentile": 0.06792}, "CVE-2025-30551": {"epss_score": 0.00051, "epss_percentile": 0.15987}, "CVE-2025-30552": {"epss_score": 0.00027, "epss_percentile": 0.06792}, "CVE-2025-30553": {"epss_score": 0.00064, "epss_percentile": 0.20311}, "CVE-2025-30554": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30555": {"epss_score": 0.00037, "epss_percentile": 0.109}, "CVE-2025-30556": {"epss_score": 0.00039, "epss_percentile": 0.11658}, "CVE-2025-30557": {"epss_score": 0.00039, "epss_percentile": 0.11658}, "CVE-2025-30558": {"epss_score": 0.00037, "epss_percentile": 0.109}, "CVE-2025-30559": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30560": {"epss_score": 0.00037, "epss_percentile": 0.109}, "CVE-2025-30561": {"epss_score": 0.00037, "epss_percentile": 0.109}, "CVE-2025-30562": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-30563": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30564": {"epss_score": 0.00037, "epss_percentile": 0.109}, "CVE-2025-30565": {"epss_score": 0.00037, "epss_percentile": 0.109}, "CVE-2025-30566": {"epss_score": 0.00062, "epss_percentile": 0.19605}, "CVE-2025-30567": {"epss_score": 0.30947, "epss_percentile": 0.96577}, "CVE-2025-30568": {"epss_score": 0.00039, "epss_percentile": 0.11658}, "CVE-2025-30569": {"epss_score": 0.0008, "epss_percentile": 0.24181}, "CVE-2025-30570": {"epss_score": 0.00079, "epss_percentile": 0.2386}, "CVE-2025-30571": {"epss_score": 0.00079, "epss_percentile": 0.2386}, "CVE-2025-30572": {"epss_score": 0.00037, "epss_percentile": 0.109}, "CVE-2025-30573": {"epss_score": 0.00065, "epss_percentile": 0.20592}, "CVE-2025-30574": {"epss_score": 0.00065, "epss_percentile": 0.20592}, "CVE-2025-30575": {"epss_score": 0.00065, "epss_percentile": 0.20592}, "CVE-2025-30576": {"epss_score": 0.00039, "epss_percentile": 0.11658}, "CVE-2025-30577": {"epss_score": 0.00037, "epss_percentile": 0.109}, "CVE-2025-30578": {"epss_score": 0.00027, "epss_percentile": 0.06792}, "CVE-2025-30579": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30580": {"epss_score": 0.00095, "epss_percentile": 0.27228}, "CVE-2025-30581": {"epss_score": 0.00085, "epss_percentile": 0.25179}, "CVE-2025-30582": {"epss_score": 0.00065, "epss_percentile": 0.20596}, "CVE-2025-30583": {"epss_score": 0.00027, "epss_percentile": 0.06792}, "CVE-2025-30584": {"epss_score": 0.00027, "epss_percentile": 0.06792}, "CVE-2025-30585": {"epss_score": 0.00028, "epss_percentile": 0.07362}, "CVE-2025-30586": {"epss_score": 0.00027, "epss_percentile": 0.06792}, "CVE-2025-30587": {"epss_score": 0.00027, "epss_percentile": 0.06792}, "CVE-2025-30588": {"epss_score": 0.00027, "epss_percentile": 0.06792}, "CVE-2025-30589": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-30590": {"epss_score": 0.00056, "epss_percentile": 0.1789}, "CVE-2025-30591": {"epss_score": 0.00063, "epss_percentile": 0.20072}, "CVE-2025-30592": {"epss_score": 0.00085, "epss_percentile": 0.25179}, "CVE-2025-30593": {"epss_score": 0.00045, "epss_percentile": 0.13811}, "CVE-2025-30594": {"epss_score": 0.00125, "epss_percentile": 0.32604}, "CVE-2025-30595": {"epss_score": 0.00045, "epss_percentile": 0.13811}, "CVE-2025-30596": {"epss_score": 0.00125, "epss_percentile": 0.32604}, "CVE-2025-30597": {"epss_score": 0.00045, "epss_percentile": 0.13811}, "CVE-2025-30598": {"epss_score": 0.00027, "epss_percentile": 0.06945}, "CVE-2025-30599": {"epss_score": 0.00045, "epss_percentile": 0.13954}, "CVE-2025-30600": {"epss_score": 0.00045, "epss_percentile": 0.13954}, "CVE-2025-30601": {"epss_score": 0.00027, "epss_percentile": 0.06945}, "CVE-2025-30602": {"epss_score": 0.00049, "epss_percentile": 0.15603}, "CVE-2025-30603": {"epss_score": 0.00026, "epss_percentile": 0.06467}, "CVE-2025-30604": {"epss_score": 0.00082, "epss_percentile": 0.24446}, "CVE-2025-30605": {"epss_score": 0.00053, "epss_percentile": 0.1669}, "CVE-2025-30606": {"epss_score": 0.00045, "epss_percentile": 0.13954}, "CVE-2025-30607": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30608": {"epss_score": 0.00026, "epss_percentile": 0.06467}, "CVE-2025-30609": {"epss_score": 0.00069, "epss_percentile": 0.21576}, "CVE-2025-30610": {"epss_score": 0.00064, "epss_percentile": 0.20311}, "CVE-2025-30611": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30612": {"epss_score": 0.00026, "epss_percentile": 0.06467}, "CVE-2025-30613": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30614": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30615": {"epss_score": 0.00042, "epss_percentile": 0.12711}, "CVE-2025-30616": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30617": {"epss_score": 0.00027, "epss_percentile": 0.06945}, "CVE-2025-30618": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-30619": {"epss_score": 0.00027, "epss_percentile": 0.0693}, "CVE-2025-30620": {"epss_score": 0.00026, "epss_percentile": 0.06467}, "CVE-2025-30621": {"epss_score": 0.00026, "epss_percentile": 0.06467}, "CVE-2025-30622": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-30623": {"epss_score": 0.00045, "epss_percentile": 0.13954}, "CVE-2025-30624": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-30625": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30626": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-30627": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30628": {"epss_score": 0.00033, "epss_percentile": 0.09312}, "CVE-2025-30629": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-30630": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30631": {"epss_score": 0.00016, "epss_percentile": 0.02731}, "CVE-2025-30632": {"epss_score": 0.00017, "epss_percentile": 0.03358}, "CVE-2025-30633": {"epss_score": 0.00018, "epss_percentile": 0.03929}, "CVE-2025-30634": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30635": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-30636": {"epss_score": 0.00054, "epss_percentile": 0.17355}, "CVE-2025-30637": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30638": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30639": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-30640": {"epss_score": 0.00041, "epss_percentile": 0.12376}, "CVE-2025-30641": {"epss_score": 0.00047, "epss_percentile": 0.14708}, "CVE-2025-30642": {"epss_score": 0.00058, "epss_percentile": 0.18424}, "CVE-2025-30644": {"epss_score": 0.00069, "epss_percentile": 0.21598}, "CVE-2025-30645": {"epss_score": 0.00101, "epss_percentile": 0.28582}, "CVE-2025-30646": {"epss_score": 0.00041, "epss_percentile": 0.12324}, "CVE-2025-30647": {"epss_score": 0.00038, "epss_percentile": 0.11304}, "CVE-2025-30648": {"epss_score": 0.00047, "epss_percentile": 0.14482}, "CVE-2025-30649": {"epss_score": 0.00131, "epss_percentile": 0.33371}, "CVE-2025-30651": {"epss_score": 0.00115, "epss_percentile": 0.30971}, "CVE-2025-30652": {"epss_score": 0.00027, "epss_percentile": 0.07159}, "CVE-2025-30653": {"epss_score": 0.00041, "epss_percentile": 0.12324}, "CVE-2025-30654": {"epss_score": 0.00025, "epss_percentile": 0.06053}, "CVE-2025-30655": {"epss_score": 0.00024, "epss_percentile": 0.0601}, "CVE-2025-30656": {"epss_score": 0.00107, "epss_percentile": 0.29681}, "CVE-2025-30657": {"epss_score": 0.00103, "epss_percentile": 0.29069}, "CVE-2025-30658": {"epss_score": 0.00107, "epss_percentile": 0.29681}, "CVE-2025-30659": {"epss_score": 0.00107, "epss_percentile": 0.29681}, "CVE-2025-30660": {"epss_score": 0.00107, "epss_percentile": 0.29681}, "CVE-2025-30661": {"epss_score": 0.00013, "epss_percentile": 0.01598}, "CVE-2025-30662": {"epss_score": 7e-05, "epss_percentile": 0.00453}, "CVE-2025-30663": {"epss_score": 0.00012, "epss_percentile": 0.01332}, "CVE-2025-30664": {"epss_score": 0.00018, "epss_percentile": 0.03677}, "CVE-2025-30665": {"epss_score": 0.00108, "epss_percentile": 0.29757}, "CVE-2025-30666": {"epss_score": 0.00108, "epss_percentile": 0.29757}, "CVE-2025-30667": {"epss_score": 0.00108, "epss_percentile": 0.29757}, "CVE-2025-30668": {"epss_score": 0.00107, "epss_percentile": 0.29695}, "CVE-2025-30669": {"epss_score": 0.0001, "epss_percentile": 0.00913}, "CVE-2025-30670": {"epss_score": 0.00109, "epss_percentile": 0.29977}, "CVE-2025-30671": {"epss_score": 0.00109, "epss_percentile": 0.29977}, "CVE-2025-30672": {"epss_score": 0.00176, "epss_percentile": 0.39426}, "CVE-2025-30673": {"epss_score": 0.00176, "epss_percentile": 0.39392}, "CVE-2025-30675": {"epss_score": 0.00081, "epss_percentile": 0.24374}, "CVE-2025-30676": {"epss_score": 0.0063, "epss_percentile": 0.69697}, "CVE-2025-30677": {"epss_score": 0.00127, "epss_percentile": 0.32829}, "CVE-2025-30678": {"epss_score": 0.00033, "epss_percentile": 0.09376}, "CVE-2025-30679": {"epss_score": 0.00033, "epss_percentile": 0.09376}, "CVE-2025-30680": {"epss_score": 0.00054, "epss_percentile": 0.17085}, "CVE-2025-30681": {"epss_score": 0.0007, "epss_percentile": 0.21881}, "CVE-2025-30682": {"epss_score": 0.00085, "epss_percentile": 0.2515}, "CVE-2025-30683": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-30684": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-30685": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-30686": {"epss_score": 0.00102, "epss_percentile": 0.28827}, "CVE-2025-30687": {"epss_score": 0.00085, "epss_percentile": 0.2515}, "CVE-2025-30688": {"epss_score": 0.00085, "epss_percentile": 0.2515}, "CVE-2025-30689": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-30690": {"epss_score": 0.00043, "epss_percentile": 0.13322}, "CVE-2025-30691": {"epss_score": 0.00091, "epss_percentile": 0.26388}, "CVE-2025-30692": {"epss_score": 0.00095, "epss_percentile": 0.27135}, "CVE-2025-30693": {"epss_score": 0.00084, "epss_percentile": 0.24886}, "CVE-2025-30694": {"epss_score": 0.00048, "epss_percentile": 0.14982}, "CVE-2025-30695": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-30696": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-30697": {"epss_score": 0.00048, "epss_percentile": 0.14982}, "CVE-2025-30698": {"epss_score": 0.0015, "epss_percentile": 0.36116}, "CVE-2025-30699": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-30700": {"epss_score": 0.00083, "epss_percentile": 0.24814}, "CVE-2025-30701": {"epss_score": 0.00094, "epss_percentile": 0.27063}, "CVE-2025-30702": {"epss_score": 0.00056, "epss_percentile": 0.17921}, "CVE-2025-30703": {"epss_score": 0.0006, "epss_percentile": 0.19074}, "CVE-2025-30704": {"epss_score": 0.00053, "epss_percentile": 0.1703}, "CVE-2025-30705": {"epss_score": 0.00071, "epss_percentile": 0.22109}, "CVE-2025-30706": {"epss_score": 0.00169, "epss_percentile": 0.38628}, "CVE-2025-30707": {"epss_score": 0.00107, "epss_percentile": 0.29605}, "CVE-2025-30708": {"epss_score": 0.00107, "epss_percentile": 0.29605}, "CVE-2025-30709": {"epss_score": 0.00051, "epss_percentile": 0.16044}, "CVE-2025-30710": {"epss_score": 0.00079, "epss_percentile": 0.23834}, "CVE-2025-30711": {"epss_score": 0.00048, "epss_percentile": 0.14982}, "CVE-2025-30712": {"epss_score": 0.00031, "epss_percentile": 0.08612}, "CVE-2025-30713": {"epss_score": 0.00048, "epss_percentile": 0.14982}, "CVE-2025-30714": {"epss_score": 0.00071, "epss_percentile": 0.22129}, "CVE-2025-30715": {"epss_score": 0.00071, "epss_percentile": 0.22109}, "CVE-2025-30716": {"epss_score": 0.00107, "epss_percentile": 0.29605}, "CVE-2025-30717": {"epss_score": 0.00086, "epss_percentile": 0.25291}, "CVE-2025-30718": {"epss_score": 0.00051, "epss_percentile": 0.16268}, "CVE-2025-30719": {"epss_score": 0.00024, "epss_percentile": 0.0601}, "CVE-2025-30720": {"epss_score": 0.00039, "epss_percentile": 0.1157}, "CVE-2025-30721": {"epss_score": 0.00055, "epss_percentile": 0.17612}, "CVE-2025-30722": {"epss_score": 0.00098, "epss_percentile": 0.27758}, "CVE-2025-30723": {"epss_score": 0.00076, "epss_percentile": 0.2321}, "CVE-2025-30724": {"epss_score": 0.00086, "epss_percentile": 0.25426}, "CVE-2025-30725": {"epss_score": 0.00014, "epss_percentile": 0.01922}, "CVE-2025-30726": {"epss_score": 0.00078, "epss_percentile": 0.23633}, "CVE-2025-30727": {"epss_score": 0.00239, "epss_percentile": 0.46913}, "CVE-2025-30728": {"epss_score": 0.00107, "epss_percentile": 0.29605}, "CVE-2025-30729": {"epss_score": 0.00053, "epss_percentile": 0.16751}, "CVE-2025-30730": {"epss_score": 0.00078, "epss_percentile": 0.23558}, "CVE-2025-30731": {"epss_score": 0.00023, "epss_percentile": 0.05492}, "CVE-2025-30732": {"epss_score": 0.00051, "epss_percentile": 0.16044}, "CVE-2025-30733": {"epss_score": 0.0008, "epss_percentile": 0.24089}, "CVE-2025-30735": {"epss_score": 0.00126, "epss_percentile": 0.32701}, "CVE-2025-30736": {"epss_score": 0.00101, "epss_percentile": 0.28618}, "CVE-2025-30737": {"epss_score": 0.00107, "epss_percentile": 0.29656}, "CVE-2025-30739": {"epss_score": 0.0003, "epss_percentile": 0.0802}, "CVE-2025-30740": {"epss_score": 0.00095, "epss_percentile": 0.27135}, "CVE-2025-30741": {"epss_score": 0.00057, "epss_percentile": 0.18166}, "CVE-2025-30742": {"epss_score": 0.00082, "epss_percentile": 0.24569}, "CVE-2025-30743": {"epss_score": 0.0006, "epss_percentile": 0.19136}, "CVE-2025-30744": {"epss_score": 0.0006, "epss_percentile": 0.19136}, "CVE-2025-30745": {"epss_score": 0.00012, "epss_percentile": 0.01242}, "CVE-2025-30746": {"epss_score": 0.00012, "epss_percentile": 0.01243}, "CVE-2025-30747": {"epss_score": 0.00029, "epss_percentile": 0.07941}, "CVE-2025-30748": {"epss_score": 0.00026, "epss_percentile": 0.06397}, "CVE-2025-30749": {"epss_score": 0.0018, "epss_percentile": 0.39896}, "CVE-2025-30750": {"epss_score": 0.00023, "epss_percentile": 0.0537}, "CVE-2025-30751": {"epss_score": 0.00117, "epss_percentile": 0.31266}, "CVE-2025-30752": {"epss_score": 0.00038, "epss_percentile": 0.11416}, "CVE-2025-30753": {"epss_score": 0.00051, "epss_percentile": 0.16011}, "CVE-2025-30754": {"epss_score": 0.00066, "epss_percentile": 0.20938}, "CVE-2025-30755": {"epss_score": 0.00044, "epss_percentile": 0.13508}, "CVE-2025-30756": {"epss_score": 0.00012, "epss_percentile": 0.01242}, "CVE-2025-30758": {"epss_score": 0.00034, "epss_percentile": 0.09673}, "CVE-2025-30759": {"epss_score": 0.00026, "epss_percentile": 0.06397}, "CVE-2025-30760": {"epss_score": 0.00032, "epss_percentile": 0.0886}, "CVE-2025-30761": {"epss_score": 0.00088, "epss_percentile": 0.25676}, "CVE-2025-30762": {"epss_score": 0.00051, "epss_percentile": 0.16136}, "CVE-2025-30763": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30764": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30765": {"epss_score": 0.00103, "epss_percentile": 0.28901}, "CVE-2025-30766": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30767": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2025-30768": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30769": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-30770": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30771": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30772": {"epss_score": 0.00095, "epss_percentile": 0.27088}, "CVE-2025-30773": {"epss_score": 0.00149, "epss_percentile": 0.35977}, "CVE-2025-30774": {"epss_score": 0.00045, "epss_percentile": 0.14071}, "CVE-2025-30775": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-30776": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30777": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-30778": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30779": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30780": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30781": {"epss_score": 0.00044, "epss_percentile": 0.1346}, "CVE-2025-30782": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-30783": {"epss_score": 0.00028, "epss_percentile": 0.07579}, "CVE-2025-30784": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-30785": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-30786": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30787": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-30788": {"epss_score": 0.00028, "epss_percentile": 0.07579}, "CVE-2025-30789": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-30790": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-30791": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-30792": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-30793": {"epss_score": 0.00126, "epss_percentile": 0.32777}, "CVE-2025-30794": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30795": {"epss_score": 0.00044, "epss_percentile": 0.1346}, "CVE-2025-30796": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30797": {"epss_score": 0.00083, "epss_percentile": 0.2462}, "CVE-2025-30798": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30799": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-30800": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30801": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30802": {"epss_score": 0.00065, "epss_percentile": 0.2065}, "CVE-2025-30803": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-30804": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30805": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30806": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-30807": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-30808": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30809": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-30810": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-30811": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30812": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30813": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30814": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-30815": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30816": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30817": {"epss_score": 0.0011, "epss_percentile": 0.30084}, "CVE-2025-30818": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30819": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-30820": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-30821": {"epss_score": 0.0008, "epss_percentile": 0.24061}, "CVE-2025-30822": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30823": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30824": {"epss_score": 0.0011, "epss_percentile": 0.30084}, "CVE-2025-30825": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2025-30826": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30827": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30828": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-30829": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-30830": {"epss_score": 0.00058, "epss_percentile": 0.18598}, "CVE-2025-30831": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-30832": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30833": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30834": {"epss_score": 0.00139, "epss_percentile": 0.3463}, "CVE-2025-30835": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-30836": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30837": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30838": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30839": {"epss_score": 0.0009, "epss_percentile": 0.25998}, "CVE-2025-30840": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30841": {"epss_score": 0.00131, "epss_percentile": 0.33491}, "CVE-2025-30842": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30843": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-30844": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-30845": {"epss_score": 0.00144, "epss_percentile": 0.35321}, "CVE-2025-30846": {"epss_score": 0.00208, "epss_percentile": 0.43288}, "CVE-2025-30847": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-30848": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30849": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-30850": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30851": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-30852": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30853": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-30854": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30855": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-30856": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30857": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-30858": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30859": {"epss_score": 0.00044, "epss_percentile": 0.1346}, "CVE-2025-30860": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30861": {"epss_score": 0.00068, "epss_percentile": 0.21308}, "CVE-2025-30862": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30863": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30864": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-30865": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30866": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-30867": {"epss_score": 0.00042, "epss_percentile": 0.12797}, "CVE-2025-30868": {"epss_score": 0.00144, "epss_percentile": 0.35321}, "CVE-2025-30869": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30870": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-30871": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-30872": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30873": {"epss_score": 0.00042, "epss_percentile": 0.12797}, "CVE-2025-30874": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2025-30875": {"epss_score": 0.00019, "epss_percentile": 0.04234}, "CVE-2025-30876": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-30877": {"epss_score": 0.00048, "epss_percentile": 0.15113}, "CVE-2025-30878": {"epss_score": 0.00095, "epss_percentile": 0.27186}, "CVE-2025-30879": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-30880": {"epss_score": 0.00083, "epss_percentile": 0.2462}, "CVE-2025-30881": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-30882": {"epss_score": 0.00126, "epss_percentile": 0.32777}, "CVE-2025-30883": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-30884": {"epss_score": 0.00044, "epss_percentile": 0.1346}, "CVE-2025-30885": {"epss_score": 0.00044, "epss_percentile": 0.1346}, "CVE-2025-30886": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-30887": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-30888": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30889": {"epss_score": 0.00161, "epss_percentile": 0.3758}, "CVE-2025-30890": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-30891": {"epss_score": 0.00208, "epss_percentile": 0.43288}, "CVE-2025-30892": {"epss_score": 0.00161, "epss_percentile": 0.3758}, "CVE-2025-30893": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30894": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-30895": {"epss_score": 0.00065, "epss_percentile": 0.20471}, "CVE-2025-30896": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-30897": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-30898": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30899": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-30900": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30901": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-30902": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30903": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30904": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-30905": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30906": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30907": {"epss_score": 0.00042, "epss_percentile": 0.12797}, "CVE-2025-30908": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-30909": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-30910": {"epss_score": 0.00095, "epss_percentile": 0.27186}, "CVE-2025-30911": {"epss_score": 0.00378, "epss_percentile": 0.5879}, "CVE-2025-30912": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-30913": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30914": {"epss_score": 0.00036, "epss_percentile": 0.10486}, "CVE-2025-30915": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-30916": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-30917": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30918": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30919": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-30920": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30921": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-30922": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30923": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-30924": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-30925": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30926": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-30927": {"epss_score": 0.00036, "epss_percentile": 0.10516}, "CVE-2025-30928": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30929": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-30930": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30931": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30932": {"epss_score": 0.00054, "epss_percentile": 0.17355}, "CVE-2025-30933": {"epss_score": 0.00061, "epss_percentile": 0.19431}, "CVE-2025-30934": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-30935": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-30936": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-30937": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30938": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30939": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30940": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30941": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30942": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30943": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-30944": {"epss_score": 0.00032, "epss_percentile": 0.09002}, "CVE-2025-30945": {"epss_score": 0.00041, "epss_percentile": 0.12279}, "CVE-2025-30946": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-30947": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-30948": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-30949": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-30950": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-30951": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-30952": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-30953": {"epss_score": 0.00031, "epss_percentile": 0.08392}, "CVE-2025-30954": {"epss_score": 0.00031, "epss_percentile": 0.08392}, "CVE-2025-30955": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-30956": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-30957": {"epss_score": 0.00054, "epss_percentile": 0.17355}, "CVE-2025-30958": {"epss_score": 0.00054, "epss_percentile": 0.17355}, "CVE-2025-30959": {"epss_score": 0.00054, "epss_percentile": 0.17191}, "CVE-2025-30960": {"epss_score": 0.00068, "epss_percentile": 0.21409}, "CVE-2025-30961": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30962": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-30963": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30964": {"epss_score": 0.00041, "epss_percentile": 0.12241}, "CVE-2025-30965": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-30966": {"epss_score": 0.00118, "epss_percentile": 0.31465}, "CVE-2025-30967": {"epss_score": 0.0003, "epss_percentile": 0.08012}, "CVE-2025-30968": {"epss_score": 0.00017, "epss_percentile": 0.03358}, "CVE-2025-30969": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-30970": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-30971": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-30972": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-30973": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-30974": {"epss_score": 0.00044, "epss_percentile": 0.13514}, "CVE-2025-30975": {"epss_score": 0.00092, "epss_percentile": 0.26415}, "CVE-2025-30976": {"epss_score": 0.00027, "epss_percentile": 0.07152}, "CVE-2025-30977": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-30978": {"epss_score": 0.00054, "epss_percentile": 0.17355}, "CVE-2025-30979": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-30980": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-30981": {"epss_score": 0.00016, "epss_percentile": 0.03021}, "CVE-2025-30982": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-30983": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-30984": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-30985": {"epss_score": 0.00134, "epss_percentile": 0.33853}, "CVE-2025-30986": {"epss_score": 0.00017, "epss_percentile": 0.03358}, "CVE-2025-30987": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-30988": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-30989": {"epss_score": 0.00036, "epss_percentile": 0.1031}, "CVE-2025-30990": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-30991": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-30992": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-30993": {"epss_score": 0.00051, "epss_percentile": 0.1629}, "CVE-2025-30994": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-30995": {"epss_score": 0.00016, "epss_percentile": 0.03021}, "CVE-2025-30996": {"epss_score": 0.00099, "epss_percentile": 0.28431}, "CVE-2025-30997": {"epss_score": 0.00029, "epss_percentile": 0.07828}, "CVE-2025-30998": {"epss_score": 0.0003, "epss_percentile": 0.08224}, "CVE-2025-30999": {"epss_score": 0.00123, "epss_percentile": 0.32243}, "CVE-2025-31000": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-31001": {"epss_score": 0.00078, "epss_percentile": 0.23631}, "CVE-2025-31002": {"epss_score": 0.00096, "epss_percentile": 0.27371}, "CVE-2025-31003": {"epss_score": 0.0006, "epss_percentile": 0.19228}, "CVE-2025-31004": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31005": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31006": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-31007": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-31008": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31009": {"epss_score": 0.00042, "epss_percentile": 0.12592}, "CVE-2025-31010": {"epss_score": 0.00034, "epss_percentile": 0.09689}, "CVE-2025-31011": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-31012": {"epss_score": 0.00058, "epss_percentile": 0.18598}, "CVE-2025-31014": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-31015": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-31016": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-31017": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31018": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-31019": {"epss_score": 0.0009, "epss_percentile": 0.26002}, "CVE-2025-31020": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31021": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31022": {"epss_score": 0.0009, "epss_percentile": 0.26157}, "CVE-2025-31023": {"epss_score": 0.00029, "epss_percentile": 0.0769}, "CVE-2025-31024": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-31025": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-31026": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31027": {"epss_score": 0.00025, "epss_percentile": 0.06047}, "CVE-2025-31028": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31029": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-31030": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-31031": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31032": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31033": {"epss_score": 0.00048, "epss_percentile": 0.15033}, "CVE-2025-31034": {"epss_score": 0.00053, "epss_percentile": 0.16893}, "CVE-2025-31035": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31036": {"epss_score": 0.00029, "epss_percentile": 0.0769}, "CVE-2025-31037": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-31038": {"epss_score": 0.00029, "epss_percentile": 0.0769}, "CVE-2025-31039": {"epss_score": 0.00044, "epss_percentile": 0.13501}, "CVE-2025-31040": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-31041": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31042": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31043": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31044": {"epss_score": 0.0003, "epss_percentile": 0.08023}, "CVE-2025-31045": {"epss_score": 0.00047, "epss_percentile": 0.1467}, "CVE-2025-31046": {"epss_score": 0.0002, "epss_percentile": 0.0451}, "CVE-2025-31047": {"epss_score": 0.00036, "epss_percentile": 0.10344}, "CVE-2025-31048": {"epss_score": 0.00042, "epss_percentile": 0.12903}, "CVE-2025-31049": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-31050": {"epss_score": 0.00076, "epss_percentile": 0.23211}, "CVE-2025-31051": {"epss_score": 0.00016, "epss_percentile": 0.02811}, "CVE-2025-31052": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-31053": {"epss_score": 0.00059, "epss_percentile": 0.188}, "CVE-2025-31054": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-31055": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-31056": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-31057": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-31058": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-31059": {"epss_score": 0.00039, "epss_percentile": 0.11665}, "CVE-2025-31060": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-31061": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-31062": {"epss_score": 0.00038, "epss_percentile": 0.1112}, "CVE-2025-31063": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-31064": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-31065": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-31066": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-31067": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-31068": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-31069": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-31070": {"epss_score": 0.00067, "epss_percentile": 0.2118}, "CVE-2025-31071": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-31072": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-31073": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31074": {"epss_score": 0.00161, "epss_percentile": 0.3758}, "CVE-2025-31075": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31076": {"epss_score": 0.00039, "epss_percentile": 0.11703}, "CVE-2025-31077": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31078": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31079": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31080": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31081": {"epss_score": 0.00051, "epss_percentile": 0.16117}, "CVE-2025-31082": {"epss_score": 0.00146, "epss_percentile": 0.35533}, "CVE-2025-31083": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31084": {"epss_score": 0.00138, "epss_percentile": 0.34421}, "CVE-2025-31085": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31086": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31087": {"epss_score": 0.00138, "epss_percentile": 0.34421}, "CVE-2025-31088": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31089": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-31090": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31091": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31092": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31093": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31094": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31095": {"epss_score": 0.00077, "epss_percentile": 0.23408}, "CVE-2025-31096": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31097": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-31098": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-31099": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-31100": {"epss_score": 0.00082, "epss_percentile": 0.24472}, "CVE-2025-31101": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31102": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31103": {"epss_score": 0.00162, "epss_percentile": 0.37651}, "CVE-2025-31104": {"epss_score": 0.00079, "epss_percentile": 0.23892}, "CVE-2025-31115": {"epss_score": 0.00077, "epss_percentile": 0.23377}, "CVE-2025-31116": {"epss_score": 0.00101, "epss_percentile": 0.28639}, "CVE-2025-31117": {"epss_score": 0.0036, "epss_percentile": 0.57622}, "CVE-2025-31118": {"epss_score": 0.00093, "epss_percentile": 0.26673}, "CVE-2025-31119": {"epss_score": 0.00742, "epss_percentile": 0.72454}, "CVE-2025-31120": {"epss_score": 0.00099, "epss_percentile": 0.27869}, "CVE-2025-31121": {"epss_score": 0.0041, "epss_percentile": 0.60838}, "CVE-2025-31122": {"epss_score": 0.00062, "epss_percentile": 0.19581}, "CVE-2025-31123": {"epss_score": 0.00101, "epss_percentile": 0.28673}, "CVE-2025-31124": {"epss_score": 0.00151, "epss_percentile": 0.36312}, "CVE-2025-31125": {"epss_score": 0.03613, "epss_percentile": 0.87428}, "CVE-2025-31126": {"epss_score": 0.00044, "epss_percentile": 0.13428}, "CVE-2025-31127": {"epss_score": 0.00044, "epss_percentile": 0.13428}, "CVE-2025-31128": {"epss_score": 0.00084, "epss_percentile": 0.24893}, "CVE-2025-31129": {"epss_score": 0.00112, "epss_percentile": 0.30429}, "CVE-2025-31130": {"epss_score": 0.00014, "epss_percentile": 0.02083}, "CVE-2025-31131": {"epss_score": 0.0842, "epss_percentile": 0.92043}, "CVE-2025-31132": {"epss_score": 0.00219, "epss_percentile": 0.4447}, "CVE-2025-31133": {"epss_score": 0.00018, "epss_percentile": 0.0354}, "CVE-2025-31134": {"epss_score": 0.00071, "epss_percentile": 0.22168}, "CVE-2025-31135": {"epss_score": 0.00104, "epss_percentile": 0.29183}, "CVE-2025-31136": {"epss_score": 0.00054, "epss_percentile": 0.17056}, "CVE-2025-31137": {"epss_score": 0.00023, "epss_percentile": 0.05646}, "CVE-2025-31138": {"epss_score": 0.00058, "epss_percentile": 0.18416}, "CVE-2025-31139": {"epss_score": 2e-05, "epss_percentile": 0.00023}, "CVE-2025-31140": {"epss_score": 0.00408, "epss_percentile": 0.60687}, "CVE-2025-31141": {"epss_score": 2e-05, "epss_percentile": 0.00037}, "CVE-2025-31144": {"epss_score": 0.00036, "epss_percentile": 0.10234}, "CVE-2025-31146": {"epss_score": 0.00024, "epss_percentile": 0.05823}, "CVE-2025-31147": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-31160": {"epss_score": 0.00099, "epss_percentile": 0.28424}, "CVE-2025-31161": {"epss_score": 0.82329, "epss_percentile": 0.99188}, "CVE-2025-31162": {"epss_score": 0.0004, "epss_percentile": 0.12063}, "CVE-2025-31163": {"epss_score": 0.0004, "epss_percentile": 0.12063}, "CVE-2025-31164": {"epss_score": 0.00035, "epss_percentile": 0.1004}, "CVE-2025-31165": {"epss_score": 0.00078, "epss_percentile": 0.23672}, "CVE-2025-31170": {"epss_score": 0.00029, "epss_percentile": 0.0791}, "CVE-2025-31171": {"epss_score": 0.00016, "epss_percentile": 0.02761}, "CVE-2025-31172": {"epss_score": 0.00013, "epss_percentile": 0.01631}, "CVE-2025-31173": {"epss_score": 0.00013, "epss_percentile": 0.01631}, "CVE-2025-31174": {"epss_score": 0.00071, "epss_percentile": 0.2223}, "CVE-2025-31175": {"epss_score": 0.00265, "epss_percentile": 0.49764}, "CVE-2025-31176": {"epss_score": 0.00033, "epss_percentile": 0.09197}, "CVE-2025-31177": {"epss_score": 0.0002, "epss_percentile": 0.04488}, "CVE-2025-31178": {"epss_score": 0.00033, "epss_percentile": 0.09197}, "CVE-2025-31179": {"epss_score": 0.00033, "epss_percentile": 0.09197}, "CVE-2025-31180": {"epss_score": 0.00033, "epss_percentile": 0.09197}, "CVE-2025-31181": {"epss_score": 0.00033, "epss_percentile": 0.09197}, "CVE-2025-31182": {"epss_score": 0.00175, "epss_percentile": 0.39373}, "CVE-2025-31183": {"epss_score": 0.00182, "epss_percentile": 0.40264}, "CVE-2025-31184": {"epss_score": 0.00028, "epss_percentile": 0.07341}, "CVE-2025-31185": {"epss_score": 0.00026, "epss_percentile": 0.0673}, "CVE-2025-31187": {"epss_score": 0.0002, "epss_percentile": 0.04475}, "CVE-2025-31188": {"epss_score": 0.00021, "epss_percentile": 0.04782}, "CVE-2025-31189": {"epss_score": 0.00011, "epss_percentile": 0.0097}, "CVE-2025-31191": {"epss_score": 0.00028, "epss_percentile": 0.07253}, "CVE-2025-31192": {"epss_score": 0.00078, "epss_percentile": 0.23605}, "CVE-2025-31194": {"epss_score": 0.00148, "epss_percentile": 0.35889}, "CVE-2025-31195": {"epss_score": 0.00016, "epss_percentile": 0.02784}, "CVE-2025-31196": {"epss_score": 0.00016, "epss_percentile": 0.02742}, "CVE-2025-31197": {"epss_score": 0.0003, "epss_percentile": 0.08251}, "CVE-2025-31198": {"epss_score": 0.00017, "epss_percentile": 0.03204}, "CVE-2025-31199": {"epss_score": 0.00014, "epss_percentile": 0.01964}, "CVE-2025-31200": {"epss_score": 0.01731, "epss_percentile": 0.81994}, "CVE-2025-31201": {"epss_score": 0.04376, "epss_percentile": 0.88616}, "CVE-2025-31202": {"epss_score": 0.00015, "epss_percentile": 0.02132}, "CVE-2025-31203": {"epss_score": 0.00039, "epss_percentile": 0.11663}, "CVE-2025-31204": {"epss_score": 0.00102, "epss_percentile": 0.28846}, "CVE-2025-31205": {"epss_score": 0.00029, "epss_percentile": 0.07606}, "CVE-2025-31206": {"epss_score": 0.00173, "epss_percentile": 0.39112}, "CVE-2025-31207": {"epss_score": 0.00025, "epss_percentile": 0.06345}, "CVE-2025-31208": {"epss_score": 0.0024, "epss_percentile": 0.47232}, "CVE-2025-31209": {"epss_score": 0.00105, "epss_percentile": 0.29324}, "CVE-2025-31210": {"epss_score": 0.00047, "epss_percentile": 0.14809}, "CVE-2025-31212": {"epss_score": 0.00018, "epss_percentile": 0.03829}, "CVE-2025-31213": {"epss_score": 0.00097, "epss_percentile": 0.2759}, "CVE-2025-31214": {"epss_score": 0.00063, "epss_percentile": 0.20073}, "CVE-2025-31215": {"epss_score": 0.00263, "epss_percentile": 0.49408}, "CVE-2025-31216": {"epss_score": 0.00022, "epss_percentile": 0.05015}, "CVE-2025-31217": {"epss_score": 0.00177, "epss_percentile": 0.39579}, "CVE-2025-31218": {"epss_score": 0.00019, "epss_percentile": 0.04285}, "CVE-2025-31219": {"epss_score": 0.00098, "epss_percentile": 0.27825}, "CVE-2025-31220": {"epss_score": 0.00018, "epss_percentile": 0.03871}, "CVE-2025-31221": {"epss_score": 0.00152, "epss_percentile": 0.36419}, "CVE-2025-31222": {"epss_score": 0.00016, "epss_percentile": 0.02961}, "CVE-2025-31223": {"epss_score": 0.00103, "epss_percentile": 0.28985}, "CVE-2025-31224": {"epss_score": 0.00023, "epss_percentile": 0.05506}, "CVE-2025-31225": {"epss_score": 0.00047, "epss_percentile": 0.14651}, "CVE-2025-31226": {"epss_score": 0.00018, "epss_percentile": 0.038}, "CVE-2025-31227": {"epss_score": 0.00027, "epss_percentile": 0.07169}, "CVE-2025-31228": {"epss_score": 0.00042, "epss_percentile": 0.12804}, "CVE-2025-31229": {"epss_score": 0.00079, "epss_percentile": 0.23944}, "CVE-2025-31231": {"epss_score": 0.00017, "epss_percentile": 0.03183}, "CVE-2025-31232": {"epss_score": 0.00064, "epss_percentile": 0.20173}, "CVE-2025-31233": {"epss_score": 0.00154, "epss_percentile": 0.36671}, "CVE-2025-31234": {"epss_score": 0.0008, "epss_percentile": 0.24169}, "CVE-2025-31235": {"epss_score": 0.00019, "epss_percentile": 0.04247}, "CVE-2025-31236": {"epss_score": 0.00019, "epss_percentile": 0.04222}, "CVE-2025-31237": {"epss_score": 0.00096, "epss_percentile": 0.27273}, "CVE-2025-31238": {"epss_score": 0.00197, "epss_percentile": 0.41858}, "CVE-2025-31239": {"epss_score": 0.00093, "epss_percentile": 0.26631}, "CVE-2025-31240": {"epss_score": 0.00145, "epss_percentile": 0.35416}, "CVE-2025-31241": {"epss_score": 0.00185, "epss_percentile": 0.40488}, "CVE-2025-31242": {"epss_score": 0.00014, "epss_percentile": 0.0186}, "CVE-2025-31243": {"epss_score": 0.00012, "epss_percentile": 0.0123}, "CVE-2025-31244": {"epss_score": 0.00021, "epss_percentile": 0.04835}, "CVE-2025-31245": {"epss_score": 0.00018, "epss_percentile": 0.03683}, "CVE-2025-31246": {"epss_score": 0.00082, "epss_percentile": 0.24513}, "CVE-2025-31247": {"epss_score": 0.00072, "epss_percentile": 0.22273}, "CVE-2025-31248": {"epss_score": 0.00022, "epss_percentile": 0.05229}, "CVE-2025-31249": {"epss_score": 0.00052, "epss_percentile": 0.16373}, "CVE-2025-31250": {"epss_score": 0.00014, "epss_percentile": 0.02114}, "CVE-2025-31251": {"epss_score": 0.00015, "epss_percentile": 0.02168}, "CVE-2025-31253": {"epss_score": 0.00062, "epss_percentile": 0.19556}, "CVE-2025-31254": {"epss_score": 0.00039, "epss_percentile": 0.11712}, "CVE-2025-31255": {"epss_score": 0.00094, "epss_percentile": 0.26775}, "CVE-2025-31256": {"epss_score": 0.00019, "epss_percentile": 0.04222}, "CVE-2025-31257": {"epss_score": 0.00124, "epss_percentile": 0.32415}, "CVE-2025-31258": {"epss_score": 0.00016, "epss_percentile": 0.02617}, "CVE-2025-31259": {"epss_score": 0.00035, "epss_percentile": 0.10146}, "CVE-2025-31260": {"epss_score": 0.00016, "epss_percentile": 0.02923}, "CVE-2025-31261": {"epss_score": 0.00013, "epss_percentile": 0.01538}, "CVE-2025-31262": {"epss_score": 0.00014, "epss_percentile": 0.01973}, "CVE-2025-31263": {"epss_score": 0.00062, "epss_percentile": 0.1961}, "CVE-2025-31264": {"epss_score": 0.00027, "epss_percentile": 0.06743}, "CVE-2025-31266": {"epss_score": 0.00031, "epss_percentile": 0.08464}, "CVE-2025-31267": {"epss_score": 0.00027, "epss_percentile": 0.06835}, "CVE-2025-31268": {"epss_score": 0.00012, "epss_percentile": 0.01247}, "CVE-2025-31269": {"epss_score": 0.00016, "epss_percentile": 0.02957}, "CVE-2025-31270": {"epss_score": 0.00018, "epss_percentile": 0.03835}, "CVE-2025-31271": {"epss_score": 0.00044, "epss_percentile": 0.13551}, "CVE-2025-31273": {"epss_score": 0.00064, "epss_percentile": 0.20165}, "CVE-2025-31275": {"epss_score": 0.00019, "epss_percentile": 0.04272}, "CVE-2025-31276": {"epss_score": 0.00036, "epss_percentile": 0.10241}, "CVE-2025-31277": {"epss_score": 0.0007, "epss_percentile": 0.21696}, "CVE-2025-31278": {"epss_score": 0.00064, "epss_percentile": 0.20396}, "CVE-2025-31279": {"epss_score": 0.00065, "epss_percentile": 0.20517}, "CVE-2025-31280": {"epss_score": 0.00017, "epss_percentile": 0.03136}, "CVE-2025-31281": {"epss_score": 0.00115, "epss_percentile": 0.30893}, "CVE-2025-31282": {"epss_score": 0.00043, "epss_percentile": 0.13315}, "CVE-2025-31283": {"epss_score": 0.00043, "epss_percentile": 0.13315}, "CVE-2025-31284": {"epss_score": 0.00043, "epss_percentile": 0.13315}, "CVE-2025-31285": {"epss_score": 0.00043, "epss_percentile": 0.13315}, "CVE-2025-31286": {"epss_score": 0.00065, "epss_percentile": 0.205}, "CVE-2025-31324": {"epss_score": 0.38727, "epss_percentile": 0.97117}, "CVE-2025-31325": {"epss_score": 0.00088, "epss_percentile": 0.25707}, "CVE-2025-31326": {"epss_score": 0.00025, "epss_percentile": 0.06063}, "CVE-2025-31327": {"epss_score": 0.00062, "epss_percentile": 0.19595}, "CVE-2025-31328": {"epss_score": 0.00021, "epss_percentile": 0.0479}, "CVE-2025-31329": {"epss_score": 0.00036, "epss_percentile": 0.10489}, "CVE-2025-31330": {"epss_score": 0.00127, "epss_percentile": 0.32872}, "CVE-2025-31331": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2025-31332": {"epss_score": 0.00016, "epss_percentile": 0.02915}, "CVE-2025-31333": {"epss_score": 0.00069, "epss_percentile": 0.21468}, "CVE-2025-31334": {"epss_score": 0.00177, "epss_percentile": 0.39594}, "CVE-2025-31335": {"epss_score": 0.00037, "epss_percentile": 0.10976}, "CVE-2025-31338": {"epss_score": 0.00278, "epss_percentile": 0.50854}, "CVE-2025-31339": {"epss_score": 0.00284, "epss_percentile": 0.51426}, "CVE-2025-31340": {"epss_score": 0.00286, "epss_percentile": 0.51744}, "CVE-2025-31342": {"epss_score": 0.00219, "epss_percentile": 0.44494}, "CVE-2025-31343": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-31344": {"epss_score": 0.00035, "epss_percentile": 0.09906}, "CVE-2025-31349": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-31350": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-31351": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-31352": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-31353": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-31354": {"epss_score": 0.00033, "epss_percentile": 0.09324}, "CVE-2025-31355": {"epss_score": 0.00055, "epss_percentile": 0.17577}, "CVE-2025-31357": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-31359": {"epss_score": 0.00139, "epss_percentile": 0.34535}, "CVE-2025-31360": {"epss_score": 0.00154, "epss_percentile": 0.36648}, "CVE-2025-31361": {"epss_score": 0.00015, "epss_percentile": 0.02517}, "CVE-2025-31362": {"epss_score": 0.00043, "epss_percentile": 0.13071}, "CVE-2025-31363": {"epss_score": 0.00046, "epss_percentile": 0.14433}, "CVE-2025-31365": {"epss_score": 0.00037, "epss_percentile": 0.10793}, "CVE-2025-31366": {"epss_score": 0.00046, "epss_percentile": 0.14413}, "CVE-2025-31375": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31376": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31377": {"epss_score": 0.00083, "epss_percentile": 0.2462}, "CVE-2025-31378": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31379": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31380": {"epss_score": 0.00086, "epss_percentile": 0.25327}, "CVE-2025-31381": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-31382": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31383": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31384": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31385": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31386": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31387": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-31388": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31389": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31390": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31391": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31392": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31393": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31394": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31395": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31396": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-31397": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-31398": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-31399": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31400": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31401": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31402": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31403": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-31404": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31405": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-31406": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31407": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31408": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31409": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31410": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31411": {"epss_score": 0.00079, "epss_percentile": 0.23986}, "CVE-2025-31412": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31414": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31415": {"epss_score": 0.0007, "epss_percentile": 0.2181}, "CVE-2025-31416": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31417": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31418": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31419": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31420": {"epss_score": 0.00068, "epss_percentile": 0.21217}, "CVE-2025-31421": {"epss_score": 0.00066, "epss_percentile": 0.20848}, "CVE-2025-31422": {"epss_score": 0.00118, "epss_percentile": 0.31508}, "CVE-2025-31423": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-31424": {"epss_score": 0.00039, "epss_percentile": 0.11665}, "CVE-2025-31425": {"epss_score": 0.00079, "epss_percentile": 0.23946}, "CVE-2025-31426": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-31427": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-31428": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-31429": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-31430": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-31431": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31432": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-31433": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31434": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31435": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31436": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31437": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31438": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31439": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-31440": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31441": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31442": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31443": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31444": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31445": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31446": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31447": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-31448": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-31449": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31450": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31451": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31452": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31453": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31454": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31455": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31456": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31457": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-31458": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31459": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31460": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31461": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31462": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31463": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31464": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31465": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31466": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-31467": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31468": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31469": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31470": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31471": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31472": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31473": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31474": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31475": {"epss_score": 0.00576, "epss_percentile": 0.68142}, "CVE-2025-31476": {"epss_score": 0.00069, "epss_percentile": 0.21603}, "CVE-2025-31477": {"epss_score": 0.01519, "epss_percentile": 0.80818}, "CVE-2025-31478": {"epss_score": 0.00051, "epss_percentile": 0.16047}, "CVE-2025-31479": {"epss_score": 0.00075, "epss_percentile": 0.23024}, "CVE-2025-31480": {"epss_score": 0.00096, "epss_percentile": 0.27371}, "CVE-2025-31481": {"epss_score": 0.00083, "epss_percentile": 0.24617}, "CVE-2025-31482": {"epss_score": 0.00045, "epss_percentile": 0.14001}, "CVE-2025-31483": {"epss_score": 0.00088, "epss_percentile": 0.257}, "CVE-2025-31484": {"epss_score": 0.00082, "epss_percentile": 0.2445}, "CVE-2025-31485": {"epss_score": 0.00042, "epss_percentile": 0.12643}, "CVE-2025-31486": {"epss_score": 0.02592, "epss_percentile": 0.85186}, "CVE-2025-31487": {"epss_score": 0.00074, "epss_percentile": 0.22682}, "CVE-2025-31488": {"epss_score": 0.00042, "epss_percentile": 0.12938}, "CVE-2025-31489": {"epss_score": 0.02925, "epss_percentile": 0.86005}, "CVE-2025-31490": {"epss_score": 0.00105, "epss_percentile": 0.29339}, "CVE-2025-31491": {"epss_score": 0.00105, "epss_percentile": 0.29339}, "CVE-2025-31492": {"epss_score": 0.00319, "epss_percentile": 0.54473}, "CVE-2025-31493": {"epss_score": 0.00109, "epss_percentile": 0.29972}, "CVE-2025-31494": {"epss_score": 0.00061, "epss_percentile": 0.19507}, "CVE-2025-31496": {"epss_score": 0.00109, "epss_percentile": 0.29959}, "CVE-2025-31497": {"epss_score": 0.00048, "epss_percentile": 0.14986}, "CVE-2025-31498": {"epss_score": 0.00179, "epss_percentile": 0.39778}, "CVE-2025-31499": {"epss_score": 0.00265, "epss_percentile": 0.4981}, "CVE-2025-31500": {"epss_score": 0.0003, "epss_percentile": 0.08205}, "CVE-2025-31501": {"epss_score": 0.0003, "epss_percentile": 0.08205}, "CVE-2025-31511": {"epss_score": 0.00051, "epss_percentile": 0.16156}, "CVE-2025-31512": {"epss_score": 0.00051, "epss_percentile": 0.16156}, "CVE-2025-31513": {"epss_score": 0.00036, "epss_percentile": 0.10255}, "CVE-2025-31514": {"epss_score": 0.00042, "epss_percentile": 0.12775}, "CVE-2025-31524": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2025-31525": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31526": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-31527": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2025-31528": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31529": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31530": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31531": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-31532": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31533": {"epss_score": 0.0008, "epss_percentile": 0.24061}, "CVE-2025-31534": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-31535": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31536": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31537": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31538": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31539": {"epss_score": 0.00061, "epss_percentile": 0.19522}, "CVE-2025-31540": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2025-31541": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31542": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-31543": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31544": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2025-31545": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31546": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31547": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-31548": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31549": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31550": {"epss_score": 0.00066, "epss_percentile": 0.20848}, "CVE-2025-31551": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-31552": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-31553": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-31554": {"epss_score": 0.00095, "epss_percentile": 0.2719}, "CVE-2025-31555": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31556": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31557": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31558": {"epss_score": 0.00066, "epss_percentile": 0.20848}, "CVE-2025-31559": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31560": {"epss_score": 0.00076, "epss_percentile": 0.23274}, "CVE-2025-31561": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-31562": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31563": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31564": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-31565": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-31566": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31567": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31568": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31569": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31570": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31571": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31572": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31573": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31574": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31575": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31576": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31577": {"epss_score": 0.00079, "epss_percentile": 0.23824}, "CVE-2025-31578": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31579": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-31580": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31581": {"epss_score": 0.00055, "epss_percentile": 0.17594}, "CVE-2025-31582": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31583": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31584": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31585": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31586": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31587": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31588": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-31589": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31590": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31591": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31592": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31593": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31594": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31595": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31596": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31597": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31598": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31599": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-31600": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31601": {"epss_score": 0.0004, "epss_percentile": 0.12161}, "CVE-2025-31602": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31603": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31604": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31605": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31606": {"epss_score": 0.00042, "epss_percentile": 0.12592}, "CVE-2025-31607": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31608": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31609": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2025-31610": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31611": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31612": {"epss_score": 0.00138, "epss_percentile": 0.34421}, "CVE-2025-31613": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31614": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31615": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31616": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31617": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31618": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31619": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-31620": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31621": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31622": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31623": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31624": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31625": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31626": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31627": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31628": {"epss_score": 0.00058, "epss_percentile": 0.18598}, "CVE-2025-31629": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31630": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-31631": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-31632": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-31633": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-31634": {"epss_score": 0.00071, "epss_percentile": 0.22114}, "CVE-2025-31635": {"epss_score": 0.00076, "epss_percentile": 0.23211}, "CVE-2025-31636": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-31637": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-31638": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-31639": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-31640": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-31641": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-31642": {"epss_score": 0.00033, "epss_percentile": 0.09387}, "CVE-2025-31643": {"epss_score": 0.00023, "epss_percentile": 0.0533}, "CVE-2025-31644": {"epss_score": 0.00064, "epss_percentile": 0.2016}, "CVE-2025-31645": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2025-31647": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2025-31649": {"epss_score": 0.00015, "epss_percentile": 0.02517}, "CVE-2025-31650": {"epss_score": 0.08122, "epss_percentile": 0.9189}, "CVE-2025-31651": {"epss_score": 0.00063, "epss_percentile": 0.19964}, "CVE-2025-31654": {"epss_score": 0.00072, "epss_percentile": 0.22435}, "CVE-2025-31672": {"epss_score": 0.00453, "epss_percentile": 0.63239}, "CVE-2025-31673": {"epss_score": 0.00091, "epss_percentile": 0.26222}, "CVE-2025-31674": {"epss_score": 0.00612, "epss_percentile": 0.69237}, "CVE-2025-31675": {"epss_score": 0.00089, "epss_percentile": 0.25811}, "CVE-2025-31676": {"epss_score": 0.00073, "epss_percentile": 0.22633}, "CVE-2025-31677": {"epss_score": 0.00031, "epss_percentile": 0.08695}, "CVE-2025-31678": {"epss_score": 0.0009, "epss_percentile": 0.26144}, "CVE-2025-31679": {"epss_score": 0.00046, "epss_percentile": 0.14396}, "CVE-2025-31680": {"epss_score": 0.0003, "epss_percentile": 0.08063}, "CVE-2025-31681": {"epss_score": 0.00106, "epss_percentile": 0.29492}, "CVE-2025-31682": {"epss_score": 0.00042, "epss_percentile": 0.12921}, "CVE-2025-31683": {"epss_score": 0.00026, "epss_percentile": 0.06557}, "CVE-2025-31684": {"epss_score": 0.00024, "epss_percentile": 0.05798}, "CVE-2025-31685": {"epss_score": 0.00094, "epss_percentile": 0.27044}, "CVE-2025-31686": {"epss_score": 0.0008, "epss_percentile": 0.24086}, "CVE-2025-31687": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-31688": {"epss_score": 0.00024, "epss_percentile": 0.05798}, "CVE-2025-31689": {"epss_score": 0.00027, "epss_percentile": 0.06981}, "CVE-2025-31690": {"epss_score": 0.00029, "epss_percentile": 0.0769}, "CVE-2025-31691": {"epss_score": 0.00101, "epss_percentile": 0.28569}, "CVE-2025-31692": {"epss_score": 0.00148, "epss_percentile": 0.35897}, "CVE-2025-31693": {"epss_score": 0.00137, "epss_percentile": 0.34257}, "CVE-2025-31694": {"epss_score": 0.0006, "epss_percentile": 0.19155}, "CVE-2025-31695": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-31696": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-31697": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-31698": {"epss_score": 0.00113, "epss_percentile": 0.30695}, "CVE-2025-31700": {"epss_score": 0.00121, "epss_percentile": 0.31949}, "CVE-2025-31701": {"epss_score": 0.00121, "epss_percentile": 0.31949}, "CVE-2025-31702": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-31710": {"epss_score": 7e-05, "epss_percentile": 0.0046}, "CVE-2025-31711": {"epss_score": 0.00011, "epss_percentile": 0.00966}, "CVE-2025-31712": {"epss_score": 0.00011, "epss_percentile": 0.00966}, "CVE-2025-31713": {"epss_score": 0.00121, "epss_percentile": 0.31958}, "CVE-2025-31714": {"epss_score": 0.00056, "epss_percentile": 0.17686}, "CVE-2025-31715": {"epss_score": 0.00691, "epss_percentile": 0.71278}, "CVE-2025-31716": {"epss_score": 0.00025, "epss_percentile": 0.06141}, "CVE-2025-31717": {"epss_score": 0.0031, "epss_percentile": 0.53802}, "CVE-2025-31718": {"epss_score": 0.0031, "epss_percentile": 0.53802}, "CVE-2025-31719": {"epss_score": 0.00019, "epss_percentile": 0.04173}, "CVE-2025-31720": {"epss_score": 0.00045, "epss_percentile": 0.13916}, "CVE-2025-31721": {"epss_score": 0.00045, "epss_percentile": 0.13916}, "CVE-2025-31722": {"epss_score": 0.0028, "epss_percentile": 0.51035}, "CVE-2025-31723": {"epss_score": 0.00035, "epss_percentile": 0.09875}, "CVE-2025-31724": {"epss_score": 0.00172, "epss_percentile": 0.38959}, "CVE-2025-31725": {"epss_score": 0.0004, "epss_percentile": 0.12014}, "CVE-2025-31726": {"epss_score": 0.0004, "epss_percentile": 0.12014}, "CVE-2025-31727": {"epss_score": 0.0004, "epss_percentile": 0.12014}, "CVE-2025-31728": {"epss_score": 0.00029, "epss_percentile": 0.07773}, "CVE-2025-31729": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-31730": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31731": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31732": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31733": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31734": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31735": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31736": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-31737": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31738": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31739": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31740": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31741": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31742": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31743": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31744": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31745": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31746": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31747": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31748": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31749": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31750": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31751": {"epss_score": 0.0004, "epss_percentile": 0.12161}, "CVE-2025-31752": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31753": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31754": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31755": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31756": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31757": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31758": {"epss_score": 0.00074, "epss_percentile": 0.22688}, "CVE-2025-31759": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31760": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31761": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31762": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31763": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31764": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31765": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31766": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31767": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31768": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-31769": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31770": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31771": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31772": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31773": {"epss_score": 0.0008, "epss_percentile": 0.24061}, "CVE-2025-31774": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31775": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31776": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31777": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31778": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31779": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-31780": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-31781": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31782": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31783": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31784": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31785": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-31786": {"epss_score": 0.00058, "epss_percentile": 0.18598}, "CVE-2025-31787": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2025-31788": {"epss_score": 0.00066, "epss_percentile": 0.20848}, "CVE-2025-31789": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31790": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31791": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31792": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31793": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31794": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31795": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-31796": {"epss_score": 0.00042, "epss_percentile": 0.12592}, "CVE-2025-31797": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31798": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31799": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31800": {"epss_score": 0.00125, "epss_percentile": 0.32604}, "CVE-2025-31801": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31802": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31803": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31804": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31805": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31806": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31807": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31808": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31809": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31810": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31811": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31812": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31813": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31814": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31815": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31816": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31817": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31818": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31819": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31820": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31821": {"epss_score": 0.00044, "epss_percentile": 0.1346}, "CVE-2025-31822": {"epss_score": 0.0008, "epss_percentile": 0.24061}, "CVE-2025-31823": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31824": {"epss_score": 0.00042, "epss_percentile": 0.12592}, "CVE-2025-31825": {"epss_score": 0.00116, "epss_percentile": 0.31084}, "CVE-2025-31826": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31827": {"epss_score": 0.00116, "epss_percentile": 0.31084}, "CVE-2025-31828": {"epss_score": 0.00027, "epss_percentile": 0.06845}, "CVE-2025-31829": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31830": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31831": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31832": {"epss_score": 0.00066, "epss_percentile": 0.20848}, "CVE-2025-31833": {"epss_score": 0.0005, "epss_percentile": 0.15959}, "CVE-2025-31834": {"epss_score": 0.00058, "epss_percentile": 0.18598}, "CVE-2025-31835": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31836": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31837": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31838": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31839": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31840": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31841": {"epss_score": 0.00068, "epss_percentile": 0.21217}, "CVE-2025-31842": {"epss_score": 0.00066, "epss_percentile": 0.20848}, "CVE-2025-31843": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31844": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31845": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31846": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31847": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31848": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31849": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31850": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31851": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31852": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31853": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31854": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31855": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31856": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2025-31857": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31858": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-31859": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-31860": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31861": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31862": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31863": {"epss_score": 0.00058, "epss_percentile": 0.18598}, "CVE-2025-31864": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31865": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31866": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31867": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31868": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31869": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31870": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31871": {"epss_score": 0.00044, "epss_percentile": 0.1346}, "CVE-2025-31872": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-31873": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31874": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31875": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31876": {"epss_score": 0.00058, "epss_percentile": 0.18598}, "CVE-2025-31877": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31878": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31879": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31880": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31881": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-31882": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2025-31883": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-31884": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31885": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31886": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31887": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-31888": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-31889": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31890": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31891": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31892": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31893": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31894": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31895": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31896": {"epss_score": 0.00074, "epss_percentile": 0.22688}, "CVE-2025-31897": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-31898": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31899": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31900": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31901": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31902": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31903": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31904": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31905": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31906": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31907": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-31908": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-31909": {"epss_score": 0.00083, "epss_percentile": 0.2462}, "CVE-2025-31910": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-31911": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-31912": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-31913": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-31914": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-31915": {"epss_score": 0.00016, "epss_percentile": 0.03033}, "CVE-2025-31916": {"epss_score": 0.0005, "epss_percentile": 0.15656}, "CVE-2025-31917": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-31918": {"epss_score": 0.00064, "epss_percentile": 0.20192}, "CVE-2025-31919": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-31920": {"epss_score": 0.00039, "epss_percentile": 0.11553}, "CVE-2025-31921": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-31922": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-31923": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2025-31924": {"epss_score": 0.00113, "epss_percentile": 0.30655}, "CVE-2025-31925": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-31926": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-31927": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-31928": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-31929": {"epss_score": 0.00018, "epss_percentile": 0.03559}, "CVE-2025-31930": {"epss_score": 0.00027, "epss_percentile": 0.06937}, "CVE-2025-31931": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2025-31932": {"epss_score": 0.00197, "epss_percentile": 0.41885}, "CVE-2025-31933": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-31935": {"epss_score": 0.00054, "epss_percentile": 0.17148}, "CVE-2025-31937": {"epss_score": 0.00017, "epss_percentile": 0.03092}, "CVE-2025-31940": {"epss_score": 0.00012, "epss_percentile": 0.01132}, "CVE-2025-31941": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-31945": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-31946": {"epss_score": 0.00021, "epss_percentile": 0.04868}, "CVE-2025-31947": {"epss_score": 0.00067, "epss_percentile": 0.21054}, "CVE-2025-31948": {"epss_score": 0.00019, "epss_percentile": 0.04091}, "CVE-2025-31949": {"epss_score": 0.00072, "epss_percentile": 0.22435}, "CVE-2025-31950": {"epss_score": 0.00081, "epss_percentile": 0.2429}, "CVE-2025-31952": {"epss_score": 0.00074, "epss_percentile": 0.22822}, "CVE-2025-31953": {"epss_score": 0.0004, "epss_percentile": 0.12061}, "CVE-2025-31954": {"epss_score": 0.00037, "epss_percentile": 0.10836}, "CVE-2025-31955": {"epss_score": 0.00056, "epss_percentile": 0.17898}, "CVE-2025-31961": {"epss_score": 0.00048, "epss_percentile": 0.15218}, "CVE-2025-31962": {"epss_score": 0.00031, "epss_percentile": 0.08464}, "CVE-2025-31963": {"epss_score": 6e-05, "epss_percentile": 0.00238}, "CVE-2025-31964": {"epss_score": 0.00042, "epss_percentile": 0.12737}, "CVE-2025-31965": {"epss_score": 0.00031, "epss_percentile": 0.08506}, "CVE-2025-31969": {"epss_score": 0.00033, "epss_percentile": 0.09347}, "CVE-2025-31971": {"epss_score": 0.00027, "epss_percentile": 0.06848}, "CVE-2025-31972": {"epss_score": 0.00011, "epss_percentile": 0.00976}, "CVE-2025-31977": {"epss_score": 0.00015, "epss_percentile": 0.02186}, "CVE-2025-31979": {"epss_score": 0.0005, "epss_percentile": 0.15705}, "CVE-2025-31987": {"epss_score": 0.00089, "epss_percentile": 0.25815}, "CVE-2025-31988": {"epss_score": 0.0005, "epss_percentile": 0.15887}, "CVE-2025-31992": {"epss_score": 0.00039, "epss_percentile": 0.11472}, "CVE-2025-31993": {"epss_score": 0.0005, "epss_percentile": 0.1593}, "CVE-2025-31994": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-31995": {"epss_score": 0.00974, "epss_percentile": 0.7617}, "CVE-2025-31996": {"epss_score": 0.00044, "epss_percentile": 0.13612}, "CVE-2025-31997": {"epss_score": 0.00042, "epss_percentile": 0.12568}, "CVE-2025-31998": {"epss_score": 0.00066, "epss_percentile": 0.20958}, "CVE-2025-32001": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2025-32002": {"epss_score": 0.00286, "epss_percentile": 0.5177}, "CVE-2025-32004": {"epss_score": 0.00014, "epss_percentile": 0.02076}, "CVE-2025-32010": {"epss_score": 0.00903, "epss_percentile": 0.75205}, "CVE-2025-32011": {"epss_score": 0.00625, "epss_percentile": 0.69578}, "CVE-2025-32012": {"epss_score": 0.01051, "epss_percentile": 0.77078}, "CVE-2025-32013": {"epss_score": 0.00026, "epss_percentile": 0.06568}, "CVE-2025-32014": {"epss_score": 0.00165, "epss_percentile": 0.3813}, "CVE-2025-32015": {"epss_score": 0.00103, "epss_percentile": 0.29062}, "CVE-2025-32016": {"epss_score": 0.00018, "epss_percentile": 0.03659}, "CVE-2025-32017": {"epss_score": 0.00126, "epss_percentile": 0.32705}, "CVE-2025-32018": {"epss_score": 0.00071, "epss_percentile": 0.22075}, "CVE-2025-32019": {"epss_score": 0.00027, "epss_percentile": 0.07174}, "CVE-2025-32020": {"epss_score": 0.00057, "epss_percentile": 0.18065}, "CVE-2025-32021": {"epss_score": 0.00093, "epss_percentile": 0.26673}, "CVE-2025-32022": {"epss_score": 0.00014, "epss_percentile": 0.01909}, "CVE-2025-32023": {"epss_score": 0.00373, "epss_percentile": 0.58514}, "CVE-2025-32024": {"epss_score": 0.00037, "epss_percentile": 0.10785}, "CVE-2025-32025": {"epss_score": 0.00037, "epss_percentile": 0.10785}, "CVE-2025-32026": {"epss_score": 0.0004, "epss_percentile": 0.12049}, "CVE-2025-32027": {"epss_score": 0.00046, "epss_percentile": 0.14396}, "CVE-2025-32028": {"epss_score": 0.00131, "epss_percentile": 0.33411}, "CVE-2025-32029": {"epss_score": 0.00013, "epss_percentile": 0.01527}, "CVE-2025-32030": {"epss_score": 0.00112, "epss_percentile": 0.30564}, "CVE-2025-32031": {"epss_score": 0.00112, "epss_percentile": 0.30564}, "CVE-2025-32032": {"epss_score": 0.00103, "epss_percentile": 0.28998}, "CVE-2025-32033": {"epss_score": 0.00096, "epss_percentile": 0.27297}, "CVE-2025-32034": {"epss_score": 0.00103, "epss_percentile": 0.28998}, "CVE-2025-32035": {"epss_score": 0.00028, "epss_percentile": 0.07353}, "CVE-2025-32036": {"epss_score": 0.00044, "epss_percentile": 0.13441}, "CVE-2025-32037": {"epss_score": 0.00022, "epss_percentile": 0.05309}, "CVE-2025-32038": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2025-32044": {"epss_score": 0.00146, "epss_percentile": 0.35572}, "CVE-2025-32045": {"epss_score": 0.00088, "epss_percentile": 0.25789}, "CVE-2025-32049": {"epss_score": 0.0043, "epss_percentile": 0.62025}, "CVE-2025-32050": {"epss_score": 0.00225, "epss_percentile": 0.45092}, "CVE-2025-32051": {"epss_score": 0.00094, "epss_percentile": 0.26993}, "CVE-2025-32052": {"epss_score": 0.00285, "epss_percentile": 0.51543}, "CVE-2025-32053": {"epss_score": 0.00285, "epss_percentile": 0.51543}, "CVE-2025-32054": {"epss_score": 1e-05, "epss_percentile": 2e-05}, "CVE-2025-32067": {"epss_score": 0.00064, "epss_percentile": 0.20427}, "CVE-2025-32068": {"epss_score": 0.0006, "epss_percentile": 0.19091}, "CVE-2025-32069": {"epss_score": 0.00064, "epss_percentile": 0.20427}, "CVE-2025-32070": {"epss_score": 0.00064, "epss_percentile": 0.20427}, "CVE-2025-32071": {"epss_score": 0.00064, "epss_percentile": 0.20427}, "CVE-2025-32072": {"epss_score": 0.00115, "epss_percentile": 0.30984}, "CVE-2025-32073": {"epss_score": 0.00064, "epss_percentile": 0.20427}, "CVE-2025-32074": {"epss_score": 0.00049, "epss_percentile": 0.15482}, "CVE-2025-32075": {"epss_score": 0.00129, "epss_percentile": 0.33077}, "CVE-2025-32076": {"epss_score": 0.00129, "epss_percentile": 0.33077}, "CVE-2025-32077": {"epss_score": 0.00129, "epss_percentile": 0.33077}, "CVE-2025-32078": {"epss_score": 0.00098, "epss_percentile": 0.27683}, "CVE-2025-32079": {"epss_score": 0.00122, "epss_percentile": 0.32066}, "CVE-2025-32080": {"epss_score": 0.00092, "epss_percentile": 0.26577}, "CVE-2025-32086": {"epss_score": 0.0001, "epss_percentile": 0.00862}, "CVE-2025-32088": {"epss_score": 0.00017, "epss_percentile": 0.03183}, "CVE-2025-32089": {"epss_score": 0.00015, "epss_percentile": 0.0253}, "CVE-2025-32091": {"epss_score": 0.00013, "epss_percentile": 0.01562}, "CVE-2025-32093": {"epss_score": 0.00058, "epss_percentile": 0.18416}, "CVE-2025-32094": {"epss_score": 0.00029, "epss_percentile": 0.0783}, "CVE-2025-32095": {"epss_score": 0.0004, "epss_percentile": 0.12147}, "CVE-2025-32096": {"epss_score": 0.00055, "epss_percentile": 0.17554}, "CVE-2025-32098": {"epss_score": 0.00056, "epss_percentile": 0.17964}, "CVE-2025-32100": {"epss_score": 0.00055, "epss_percentile": 0.17539}, "CVE-2025-32102": {"epss_score": 0.00145, "epss_percentile": 0.35405}, "CVE-2025-32103": {"epss_score": 0.0079, "epss_percentile": 0.73373}, "CVE-2025-32105": {"epss_score": 0.00551, "epss_percentile": 0.67376}, "CVE-2025-32106": {"epss_score": 0.00887, "epss_percentile": 0.74974}, "CVE-2025-32107": {"epss_score": 0.00239, "epss_percentile": 0.46878}, "CVE-2025-32111": {"epss_score": 0.00046, "epss_percentile": 0.14468}, "CVE-2025-32112": {"epss_score": 0.0005, "epss_percentile": 0.15982}, "CVE-2025-32113": {"epss_score": 0.0005, "epss_percentile": 0.15982}, "CVE-2025-32114": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32115": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32116": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32117": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32118": {"epss_score": 0.0011, "epss_percentile": 0.30149}, "CVE-2025-32119": {"epss_score": 0.00044, "epss_percentile": 0.13474}, "CVE-2025-32120": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-32121": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-32122": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-32124": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-32125": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-32126": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-32127": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-32128": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-32129": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32130": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32131": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32132": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32133": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32134": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32135": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32136": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32137": {"epss_score": 0.00179, "epss_percentile": 0.39797}, "CVE-2025-32138": {"epss_score": 0.00064, "epss_percentile": 0.20331}, "CVE-2025-32139": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32140": {"epss_score": 0.00119, "epss_percentile": 0.316}, "CVE-2025-32141": {"epss_score": 0.00208, "epss_percentile": 0.43288}, "CVE-2025-32142": {"epss_score": 0.00208, "epss_percentile": 0.43288}, "CVE-2025-32143": {"epss_score": 0.00161, "epss_percentile": 0.3758}, "CVE-2025-32144": {"epss_score": 0.00161, "epss_percentile": 0.3758}, "CVE-2025-32145": {"epss_score": 0.00161, "epss_percentile": 0.3758}, "CVE-2025-32146": {"epss_score": 0.00208, "epss_percentile": 0.43288}, "CVE-2025-32147": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2025-32148": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-32149": {"epss_score": 0.00061, "epss_percentile": 0.19263}, "CVE-2025-32150": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-32151": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-32152": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-32153": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-32154": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-32155": {"epss_score": 0.00322, "epss_percentile": 0.54747}, "CVE-2025-32156": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-32157": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-32158": {"epss_score": 0.00176, "epss_percentile": 0.39463}, "CVE-2025-32159": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-32160": {"epss_score": 0.00176, "epss_percentile": 0.39463}, "CVE-2025-32161": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32162": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32163": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32164": {"epss_score": 0.00077, "epss_percentile": 0.23462}, "CVE-2025-32165": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32166": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32167": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32168": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32169": {"epss_score": 0.00118, "epss_percentile": 0.3147}, "CVE-2025-32170": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32171": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32172": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32173": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32174": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32175": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32176": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32177": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32178": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-32179": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32180": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-32181": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32182": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32183": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32184": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32185": {"epss_score": 0.00042, "epss_percentile": 0.12797}, "CVE-2025-32186": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32187": {"epss_score": 0.00118, "epss_percentile": 0.3147}, "CVE-2025-32188": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32189": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32190": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32191": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32192": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32193": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32194": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32195": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32196": {"epss_score": 0.00118, "epss_percentile": 0.3147}, "CVE-2025-32197": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32198": {"epss_score": 0.00042, "epss_percentile": 0.12797}, "CVE-2025-32199": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32201": {"epss_score": 0.0008, "epss_percentile": 0.24157}, "CVE-2025-32202": {"epss_score": 0.00096, "epss_percentile": 0.27371}, "CVE-2025-32203": {"epss_score": 0.00103, "epss_percentile": 0.28901}, "CVE-2025-32204": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-32205": {"epss_score": 0.00098, "epss_percentile": 0.27754}, "CVE-2025-32206": {"epss_score": 0.00042, "epss_percentile": 0.12774}, "CVE-2025-32207": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32208": {"epss_score": 0.00074, "epss_percentile": 0.22688}, "CVE-2025-32209": {"epss_score": 0.00125, "epss_percentile": 0.32604}, "CVE-2025-32210": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-32211": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32212": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-32213": {"epss_score": 0.00061, "epss_percentile": 0.19522}, "CVE-2025-32214": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32215": {"epss_score": 0.00054, "epss_percentile": 0.17289}, "CVE-2025-32216": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-32217": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-32218": {"epss_score": 0.0011, "epss_percentile": 0.30084}, "CVE-2025-32219": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-32220": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2025-32221": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-32222": {"epss_score": 0.00058, "epss_percentile": 0.18369}, "CVE-2025-32224": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-32225": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-32226": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-32227": {"epss_score": 0.0005, "epss_percentile": 0.15935}, "CVE-2025-32228": {"epss_score": 0.00065, "epss_percentile": 0.2065}, "CVE-2025-32229": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-32230": {"epss_score": 0.00059, "epss_percentile": 0.18743}, "CVE-2025-32231": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-32232": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-32233": {"epss_score": 0.00084, "epss_percentile": 0.24968}, "CVE-2025-32234": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-32235": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-32236": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-32237": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-32238": {"epss_score": 0.00065, "epss_percentile": 0.2065}, "CVE-2025-32239": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-32240": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-32241": {"epss_score": 0.0004, "epss_percentile": 0.12161}, "CVE-2025-32242": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-32243": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-32244": {"epss_score": 0.00075, "epss_percentile": 0.23068}, "CVE-2025-32245": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-32246": {"epss_score": 0.00071, "epss_percentile": 0.22101}, "CVE-2025-32247": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-32248": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-32249": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-32250": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-32251": {"epss_score": 0.00066, "epss_percentile": 0.20848}, "CVE-2025-32252": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-32253": {"epss_score": 0.0008, "epss_percentile": 0.24061}, "CVE-2025-32254": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-32255": {"epss_score": 0.00066, "epss_percentile": 0.20848}, "CVE-2025-32256": {"epss_score": 0.0008, "epss_percentile": 0.24061}, "CVE-2025-32257": {"epss_score": 0.00066, "epss_percentile": 0.20848}, "CVE-2025-32258": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-32259": {"epss_score": 0.00066, "epss_percentile": 0.20902}, "CVE-2025-32260": {"epss_score": 0.00058, "epss_percentile": 0.18598}, "CVE-2025-32261": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32262": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32263": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32264": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32265": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32266": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32267": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32268": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32269": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32270": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32271": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32272": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32273": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32274": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32275": {"epss_score": 0.00038, "epss_percentile": 0.11282}, "CVE-2025-32276": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32277": {"epss_score": 0.00055, "epss_percentile": 0.174}, "CVE-2025-32278": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32279": {"epss_score": 0.00044, "epss_percentile": 0.13371}, "CVE-2025-32280": {"epss_score": 0.00027, "epss_percentile": 0.06845}, "CVE-2025-32281": {"epss_score": 0.00059, "epss_percentile": 0.18855}, "CVE-2025-32282": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32283": {"epss_score": 0.00048, "epss_percentile": 0.15194}, "CVE-2025-32284": {"epss_score": 0.00113, "epss_percentile": 0.30655}, "CVE-2025-32285": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-32286": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-32287": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-32288": {"epss_score": 0.00099, "epss_percentile": 0.2786}, "CVE-2025-32289": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-32290": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-32291": {"epss_score": 0.00069, "epss_percentile": 0.2152}, "CVE-2025-32292": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-32293": {"epss_score": 0.00113, "epss_percentile": 0.30655}, "CVE-2025-32294": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-32295": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-32296": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-32297": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-32298": {"epss_score": 0.001, "epss_percentile": 0.28502}, "CVE-2025-32299": {"epss_score": 0.00038, "epss_percentile": 0.1112}, "CVE-2025-32300": {"epss_score": 0.00033, "epss_percentile": 0.09387}, "CVE-2025-32301": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-32302": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-32303": {"epss_score": 0.0003, "epss_percentile": 0.08141}, "CVE-2025-32304": {"epss_score": 0.00066, "epss_percentile": 0.20807}, "CVE-2025-32305": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-32306": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-32307": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-32308": {"epss_score": 0.00052, "epss_percentile": 0.16469}, "CVE-2025-32309": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-32310": {"epss_score": 0.0002, "epss_percentile": 0.0464}, "CVE-2025-32311": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-32312": {"epss_score": 0.00039, "epss_percentile": 0.11619}, "CVE-2025-32316": {"epss_score": 8e-05, "epss_percentile": 0.00541}, "CVE-2025-32317": {"epss_score": 8e-05, "epss_percentile": 0.00468}, "CVE-2025-32318": {"epss_score": 0.00108, "epss_percentile": 0.29891}, "CVE-2025-32319": {"epss_score": 6e-05, "epss_percentile": 0.00268}, "CVE-2025-32320": {"epss_score": 9e-05, "epss_percentile": 0.00648}, "CVE-2025-32321": {"epss_score": 9e-05, "epss_percentile": 0.00648}, "CVE-2025-32322": {"epss_score": 0.00014, "epss_percentile": 0.01959}, "CVE-2025-32323": {"epss_score": 0.00014, "epss_percentile": 0.02091}, "CVE-2025-32324": {"epss_score": 6e-05, "epss_percentile": 0.00284}, "CVE-2025-32325": {"epss_score": 0.0001, "epss_percentile": 0.00764}, "CVE-2025-32326": {"epss_score": 9e-05, "epss_percentile": 0.00648}, "CVE-2025-32327": {"epss_score": 0.00011, "epss_percentile": 0.01061}, "CVE-2025-32328": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-32329": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-32330": {"epss_score": 0.00015, "epss_percentile": 0.02539}, "CVE-2025-32331": {"epss_score": 0.00013, "epss_percentile": 0.01437}, "CVE-2025-32332": {"epss_score": 6e-05, "epss_percentile": 0.00312}, "CVE-2025-32333": {"epss_score": 6e-05, "epss_percentile": 0.00271}, "CVE-2025-32345": {"epss_score": 6e-05, "epss_percentile": 0.00271}, "CVE-2025-32346": {"epss_score": 9e-05, "epss_percentile": 0.00648}, "CVE-2025-32347": {"epss_score": 6e-05, "epss_percentile": 0.00284}, "CVE-2025-32349": {"epss_score": 8e-05, "epss_percentile": 0.00527}, "CVE-2025-32350": {"epss_score": 9e-05, "epss_percentile": 0.00648}, "CVE-2025-32352": {"epss_score": 0.00067, "epss_percentile": 0.21093}, "CVE-2025-32353": {"epss_score": 9e-05, "epss_percentile": 0.00618}, "CVE-2025-32354": {"epss_score": 0.0002, "epss_percentile": 0.04516}, "CVE-2025-32357": {"epss_score": 0.00051, "epss_percentile": 0.16137}, "CVE-2025-32358": {"epss_score": 0.00043, "epss_percentile": 0.12965}, "CVE-2025-32359": {"epss_score": 0.00048, "epss_percentile": 0.15273}, "CVE-2025-32360": {"epss_score": 0.00061, "epss_percentile": 0.19245}, "CVE-2025-32363": {"epss_score": 0.00798, "epss_percentile": 0.73518}, "CVE-2025-32364": {"epss_score": 0.00035, "epss_percentile": 0.10006}, "CVE-2025-32365": {"epss_score": 0.00032, "epss_percentile": 0.08847}, "CVE-2025-32366": {"epss_score": 0.00092, "epss_percentile": 0.26473}, "CVE-2025-32367": {"epss_score": 0.00075, "epss_percentile": 0.22948}, "CVE-2025-32369": {"epss_score": 0.00028, "epss_percentile": 0.07502}, "CVE-2025-32370": {"epss_score": 0.0021, "epss_percentile": 0.43455}, "CVE-2025-32371": {"epss_score": 0.00049, "epss_percentile": 0.15331}, "CVE-2025-32372": {"epss_score": 0.00201, "epss_percentile": 0.42278}, "CVE-2025-32373": {"epss_score": 0.00065, "epss_percentile": 0.20504}, "CVE-2025-32374": {"epss_score": 0.00082, "epss_percentile": 0.2458}, "CVE-2025-32375": {"epss_score": 0.55251, "epss_percentile": 0.97968}, "CVE-2025-32376": {"epss_score": 0.00049, "epss_percentile": 0.15575}, "CVE-2025-32377": {"epss_score": 0.00067, "epss_percentile": 0.21067}, "CVE-2025-32378": {"epss_score": 0.0003, "epss_percentile": 0.08064}, "CVE-2025-32379": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32380": {"epss_score": 0.00145, "epss_percentile": 0.35485}, "CVE-2025-32381": {"epss_score": 0.00111, "epss_percentile": 0.30395}, "CVE-2025-32382": {"epss_score": 0.00089, "epss_percentile": 0.25983}, "CVE-2025-32383": {"epss_score": 0.00059, "epss_percentile": 0.18719}, "CVE-2025-32385": {"epss_score": 0.00053, "epss_percentile": 0.16962}, "CVE-2025-32386": {"epss_score": 0.00019, "epss_percentile": 0.04161}, "CVE-2025-32387": {"epss_score": 9e-05, "epss_percentile": 0.00627}, "CVE-2025-32388": {"epss_score": 0.00038, "epss_percentile": 0.11199}, "CVE-2025-32389": {"epss_score": 0.00061, "epss_percentile": 0.19473}, "CVE-2025-32390": {"epss_score": 0.00052, "epss_percentile": 0.16571}, "CVE-2025-32391": {"epss_score": 0.00044, "epss_percentile": 0.13673}, "CVE-2025-32395": {"epss_score": 0.00043, "epss_percentile": 0.13023}, "CVE-2025-32396": {"epss_score": 0.00058, "epss_percentile": 0.18604}, "CVE-2025-32397": {"epss_score": 0.00058, "epss_percentile": 0.18604}, "CVE-2025-32398": {"epss_score": 0.00059, "epss_percentile": 0.18662}, "CVE-2025-32399": {"epss_score": 0.00089, "epss_percentile": 0.258}, "CVE-2025-32400": {"epss_score": 0.00058, "epss_percentile": 0.18604}, "CVE-2025-32401": {"epss_score": 0.0005, "epss_percentile": 0.15656}, "CVE-2025-32402": {"epss_score": 0.00058, "epss_percentile": 0.18604}, "CVE-2025-32403": {"epss_score": 0.0005, "epss_percentile": 0.15656}, "CVE-2025-32404": {"epss_score": 0.0005, "epss_percentile": 0.15656}, "CVE-2025-32405": {"epss_score": 0.00058, "epss_percentile": 0.18604}, "CVE-2025-32406": {"epss_score": 0.00091, "epss_percentile": 0.26273}, "CVE-2025-32407": {"epss_score": 0.0001, "epss_percentile": 0.00749}, "CVE-2025-32408": {"epss_score": 0.00018, "epss_percentile": 0.03852}, "CVE-2025-32409": {"epss_score": 0.01473, "epss_percentile": 0.80515}, "CVE-2025-32412": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2025-32413": {"epss_score": 0.00056, "epss_percentile": 0.17872}, "CVE-2025-32414": {"epss_score": 0.00058, "epss_percentile": 0.18479}, "CVE-2025-32415": {"epss_score": 0.00028, "epss_percentile": 0.07263}, "CVE-2025-32421": {"epss_score": 0.00043, "epss_percentile": 0.13357}, "CVE-2025-32426": {"epss_score": 0.00046, "epss_percentile": 0.14202}, "CVE-2025-32427": {"epss_score": 0.00046, "epss_percentile": 0.14202}, "CVE-2025-32428": {"epss_score": 0.00046, "epss_percentile": 0.14094}, "CVE-2025-32429": {"epss_score": 0.28949, "epss_percentile": 0.96403}, "CVE-2025-32430": {"epss_score": 0.00097, "epss_percentile": 0.27618}, "CVE-2025-32431": {"epss_score": 0.00063, "epss_percentile": 0.19962}, "CVE-2025-32432": {"epss_score": 0.77564, "epss_percentile": 0.98941}, "CVE-2025-32433": {"epss_score": 0.53613, "epss_percentile": 0.97884}, "CVE-2025-32434": {"epss_score": 0.0042, "epss_percentile": 0.61437}, "CVE-2025-32435": {"epss_score": 0.00051, "epss_percentile": 0.16166}, "CVE-2025-32438": {"epss_score": 0.00021, "epss_percentile": 0.04798}, "CVE-2025-32439": {"epss_score": 0.0009, "epss_percentile": 0.26134}, "CVE-2025-32440": {"epss_score": 0.00084, "epss_percentile": 0.24983}, "CVE-2025-32441": {"epss_score": 0.00039, "epss_percentile": 0.11766}, "CVE-2025-32442": {"epss_score": 0.00194, "epss_percentile": 0.41531}, "CVE-2025-32444": {"epss_score": 0.02538, "epss_percentile": 0.85042}, "CVE-2025-32445": {"epss_score": 0.00107, "epss_percentile": 0.29645}, "CVE-2025-32446": {"epss_score": 0.00016, "epss_percentile": 0.02761}, "CVE-2025-32449": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2025-32451": {"epss_score": 0.00119, "epss_percentile": 0.31665}, "CVE-2025-32454": {"epss_score": 0.00016, "epss_percentile": 0.02746}, "CVE-2025-32455": {"epss_score": 0.00087, "epss_percentile": 0.25482}, "CVE-2025-32456": {"epss_score": 0.00087, "epss_percentile": 0.25482}, "CVE-2025-32457": {"epss_score": 0.00087, "epss_percentile": 0.25482}, "CVE-2025-32458": {"epss_score": 0.00087, "epss_percentile": 0.25482}, "CVE-2025-32459": {"epss_score": 0.00087, "epss_percentile": 0.25482}, "CVE-2025-32460": {"epss_score": 0.00033, "epss_percentile": 0.09193}, "CVE-2025-32461": {"epss_score": 0.0019, "epss_percentile": 0.41119}, "CVE-2025-32462": {"epss_score": 0.13619, "epss_percentile": 0.94015}, "CVE-2025-32463": {"epss_score": 0.18491, "epss_percentile": 0.95023}, "CVE-2025-32464": {"epss_score": 0.00875, "epss_percentile": 0.74781}, "CVE-2025-32465": {"epss_score": 0.00058, "epss_percentile": 0.18529}, "CVE-2025-32466": {"epss_score": 0.00035, "epss_percentile": 0.09819}, "CVE-2025-32468": {"epss_score": 0.00356, "epss_percentile": 0.57357}, "CVE-2025-32469": {"epss_score": 0.00256, "epss_percentile": 0.48781}, "CVE-2025-32470": {"epss_score": 0.00229, "epss_percentile": 0.45622}, "CVE-2025-32471": {"epss_score": 0.00049, "epss_percentile": 0.15479}, "CVE-2025-32472": {"epss_score": 0.00236, "epss_percentile": 0.46414}, "CVE-2025-32475": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32476": {"epss_score": 0.0005, "epss_percentile": 0.15982}, "CVE-2025-32477": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32478": {"epss_score": 0.0005, "epss_percentile": 0.15982}, "CVE-2025-32479": {"epss_score": 0.0005, "epss_percentile": 0.15982}, "CVE-2025-32480": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32481": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32482": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32483": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32484": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32485": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32486": {"epss_score": 0.00042, "epss_percentile": 0.128}, "CVE-2025-32487": {"epss_score": 0.00039, "epss_percentile": 0.11703}, "CVE-2025-32488": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32489": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32490": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32491": {"epss_score": 0.00088, "epss_percentile": 0.25712}, "CVE-2025-32492": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32493": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32494": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32495": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32496": {"epss_score": 0.00029, "epss_percentile": 0.0769}, "CVE-2025-32497": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32498": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32499": {"epss_score": 0.0008, "epss_percentile": 0.24022}, "CVE-2025-32500": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32501": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32502": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32503": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32504": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32505": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32506": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32507": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32508": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32509": {"epss_score": 0.00129, "epss_percentile": 0.33187}, "CVE-2025-32510": {"epss_score": 0.00061, "epss_percentile": 0.19431}, "CVE-2025-32511": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32512": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32513": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32514": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32515": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32516": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32517": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32518": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32519": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-32520": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32521": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32522": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32523": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32524": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32525": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32526": {"epss_score": 0.00038, "epss_percentile": 0.11323}, "CVE-2025-32527": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32528": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32529": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32530": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32531": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32532": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32533": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32534": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32535": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32536": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32537": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32538": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32539": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32540": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32541": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32542": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2025-32543": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32544": {"epss_score": 0.00067, "epss_percentile": 0.21143}, "CVE-2025-32545": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-32546": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-32547": {"epss_score": 0.00028, "epss_percentile": 0.07579}, "CVE-2025-32548": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32549": {"epss_score": 0.00109, "epss_percentile": 0.2997}, "CVE-2025-32550": {"epss_score": 0.00052, "epss_percentile": 0.16631}, "CVE-2025-32551": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32552": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32553": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32554": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32555": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32556": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32557": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32558": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-32559": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32560": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32561": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32562": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32563": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32564": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32565": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-32566": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32567": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-32568": {"epss_score": 0.00138, "epss_percentile": 0.34421}, "CVE-2025-32569": {"epss_score": 0.00138, "epss_percentile": 0.34421}, "CVE-2025-32570": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32571": {"epss_score": 0.00157, "epss_percentile": 0.37061}, "CVE-2025-32572": {"epss_score": 0.00134, "epss_percentile": 0.33853}, "CVE-2025-32573": {"epss_score": 0.00053, "epss_percentile": 0.16675}, "CVE-2025-32574": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-32575": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32576": {"epss_score": 0.00029, "epss_percentile": 0.0769}, "CVE-2025-32577": {"epss_score": 0.0021, "epss_percentile": 0.43485}, "CVE-2025-32578": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32579": {"epss_score": 0.00119, "epss_percentile": 0.316}, "CVE-2025-32580": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32581": {"epss_score": 0.00119, "epss_percentile": 0.31636}, "CVE-2025-32582": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32583": {"epss_score": 0.00115, "epss_percentile": 0.30961}, "CVE-2025-32584": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32585": {"epss_score": 0.00065, "epss_percentile": 0.20471}, "CVE-2025-32586": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32587": {"epss_score": 0.00065, "epss_percentile": 0.20596}, "CVE-2025-32588": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32589": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-32590": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32591": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32592": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32593": {"epss_score": 0.00076, "epss_percentile": 0.23241}, "CVE-2025-32594": {"epss_score": 0.0007, "epss_percentile": 0.21748}, "CVE-2025-32595": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-32596": {"epss_score": 0.0007, "epss_percentile": 0.21764}, "CVE-2025-32597": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32598": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-32599": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32600": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32601": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32602": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32603": {"epss_score": 0.00059, "epss_percentile": 0.18749}, "CVE-2025-32604": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32605": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32606": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-32607": {"epss_score": 0.00138, "epss_percentile": 0.34421}, "CVE-2025-32608": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32609": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32610": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32611": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32612": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32613": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32614": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-32615": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32616": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32617": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32618": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-32619": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32620": {"epss_score": 0.00069, "epss_percentile": 0.21585}, "CVE-2025-32621": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32622": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32623": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32624": {"epss_score": 0.00046, "epss_percentile": 0.14183}, "CVE-2025-32625": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32626": {"epss_score": 0.00053, "epss_percentile": 0.16856}, "CVE-2025-32627": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-32628": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32629": {"epss_score": 0.00095, "epss_percentile": 0.27186}, "CVE-2025-32630": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32631": {"epss_score": 0.00095, "epss_percentile": 0.27186}, "CVE-2025-32632": {"epss_score": 0.00047, "epss_percentile": 0.14752}, "CVE-2025-32633": {"epss_score": 0.00095, "epss_percentile": 0.27186}, "CVE-2025-32634": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32635": {"epss_score": 0.0007, "epss_percentile": 0.21748}, "CVE-2025-32636": {"epss_score": 0.00053, "epss_percentile": 0.16856}, "CVE-2025-32637": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32638": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32639": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32640": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32641": {"epss_score": 0.00033, "epss_percentile": 0.09204}, "CVE-2025-32642": {"epss_score": 0.00042, "epss_percentile": 0.12702}, "CVE-2025-32643": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-32644": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32645": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32646": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32647": {"epss_score": 0.00157, "epss_percentile": 0.37061}, "CVE-2025-32648": {"epss_score": 0.00086, "epss_percentile": 0.25327}, "CVE-2025-32649": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32650": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-32651": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32652": {"epss_score": 0.00094, "epss_percentile": 0.26767}, "CVE-2025-32653": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32654": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-32655": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-32656": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-32657": {"epss_score": 0.00087, "epss_percentile": 0.25549}, "CVE-2025-32658": {"epss_score": 0.00134, "epss_percentile": 0.33853}, "CVE-2025-32659": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32660": {"epss_score": 0.00094, "epss_percentile": 0.27045}, "CVE-2025-32661": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32662": {"epss_score": 0.00157, "epss_percentile": 0.37061}, "CVE-2025-32663": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-32664": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32665": {"epss_score": 0.00053, "epss_percentile": 0.16856}, "CVE-2025-32666": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32667": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32668": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-32669": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32670": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32671": {"epss_score": 0.00126, "epss_percentile": 0.32777}, "CVE-2025-32672": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-32673": {"epss_score": 0.00025, "epss_percentile": 0.06095}, "CVE-2025-32674": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32675": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2025-32676": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-32677": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-32678": {"epss_score": 0.00026, "epss_percentile": 0.06512}, "CVE-2025-32679": {"epss_score": 0.00026, "epss_percentile": 0.06473}, "CVE-2025-32680": {"epss_score": 0.00043, "epss_percentile": 0.13203}, "CVE-2025-32681": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-32682": {"epss_score": 0.00107, "epss_percentile": 0.29645}, "CVE-2025-32683": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32684": {"epss_score": 0.00052, "epss_percentile": 0.16522}, "CVE-2025-32685": {"epss_score": 0.00054, "epss_percentile": 0.1721}, "CVE-2025-32686": {"epss_score": 0.00157, "epss_percentile": 0.37061}, "CVE-2025-32687": {"epss_score": 0.00058, "epss_percentile": 0.18592}, "CVE-2025-32688": {"epss_score": 0.00026, "epss_percentile": 0.06398}, "CVE-2025-32689": {"epss_score": 0.00064, "epss_percentile": 0.20205}, "CVE-2025-32690": {"epss_score": 0.00047, "epss_percentile": 0.1457}, "CVE-2025-32691": {"epss_score": 0.00039, "epss_percentile": 0.11703}, "CVE-2025-32692": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-32693": {"epss_score": 0.00044, "epss_percentile": 0.1346}, "CVE-2025-32694": {"epss_score": 0.00044, "epss_percentile": 0.1346}, "CVE-2025-32695": {"epss_score": 0.00088, "epss_percentile": 0.25712}, "CVE-2025-32696": {"epss_score": 0.00089, "epss_percentile": 0.25882}, "CVE-2025-32697": {"epss_score": 0.00084, "epss_percentile": 0.24925}, "CVE-2025-32698": {"epss_score": 0.00122, "epss_percentile": 0.32064}, "CVE-2025-32699": {"epss_score": 0.00083, "epss_percentile": 0.24753}, "CVE-2025-32700": {"epss_score": 0.00122, "epss_percentile": 0.32064}, "CVE-2025-32701": {"epss_score": 0.01544, "epss_percentile": 0.8096}, "CVE-2025-32702": {"epss_score": 0.00071, "epss_percentile": 0.22086}, "CVE-2025-32703": {"epss_score": 0.00088, "epss_percentile": 0.25671}, "CVE-2025-32704": {"epss_score": 0.00083, "epss_percentile": 0.24642}, "CVE-2025-32705": {"epss_score": 0.00082, "epss_percentile": 0.24419}, "CVE-2025-32706": {"epss_score": 0.013, "epss_percentile": 0.79286}, "CVE-2025-32707": {"epss_score": 0.00071, "epss_percentile": 0.22222}, "CVE-2025-32709": {"epss_score": 0.01137, "epss_percentile": 0.77921}, "CVE-2025-32710": {"epss_score": 0.00098, "epss_percentile": 0.27774}, "CVE-2025-32711": {"epss_score": 0.00581, "epss_percentile": 0.68263}, "CVE-2025-32712": {"epss_score": 0.00073, "epss_percentile": 0.22669}, "CVE-2025-32713": {"epss_score": 0.00073, "epss_percentile": 0.22669}, "CVE-2025-32714": {"epss_score": 0.0007, "epss_percentile": 0.21871}, "CVE-2025-32715": {"epss_score": 0.00065, "epss_percentile": 0.2045}, "CVE-2025-32716": {"epss_score": 0.00073, "epss_percentile": 0.22669}, "CVE-2025-32717": {"epss_score": 0.00074, "epss_percentile": 0.22806}, "CVE-2025-32718": {"epss_score": 0.00101, "epss_percentile": 0.28627}, "CVE-2025-32719": {"epss_score": 0.00059, "epss_percentile": 0.18907}, "CVE-2025-32720": {"epss_score": 0.00131, "epss_percentile": 0.33379}, "CVE-2025-32721": {"epss_score": 0.00061, "epss_percentile": 0.19355}, "CVE-2025-32722": {"epss_score": 0.00057, "epss_percentile": 0.18064}, "CVE-2025-32724": {"epss_score": 0.14428, "epss_percentile": 0.94211}, "CVE-2025-32725": {"epss_score": 0.0015, "epss_percentile": 0.3606}, "CVE-2025-32726": {"epss_score": 0.00268, "epss_percentile": 0.50039}, "CVE-2025-32728": {"epss_score": 0.00095, "epss_percentile": 0.2722}, "CVE-2025-32730": {"epss_score": 0.00023, "epss_percentile": 0.05448}, "CVE-2025-32731": {"epss_score": 0.00041, "epss_percentile": 0.12265}, "CVE-2025-32732": {"epss_score": 0.00016, "epss_percentile": 0.02739}, "CVE-2025-32738": {"epss_score": 0.00069, "epss_percentile": 0.21535}, "CVE-2025-32743": {"epss_score": 0.00193, "epss_percentile": 0.4139}, "CVE-2025-32744": {"epss_score": 0.00261, "epss_percentile": 0.49311}, "CVE-2025-32752": {"epss_score": 0.00012, "epss_percentile": 0.0139}, "CVE-2025-32753": {"epss_score": 0.00028, "epss_percentile": 0.07228}, "CVE-2025-32754": {"epss_score": 0.00119, "epss_percentile": 0.31544}, "CVE-2025-32755": {"epss_score": 0.00119, "epss_percentile": 0.31544}, "CVE-2025-32756": {"epss_score": 0.30472, "epss_percentile": 0.96543}, "CVE-2025-32766": {"epss_score": 0.00014, "epss_percentile": 0.01897}, "CVE-2025-32776": {"epss_score": 0.00031, "epss_percentile": 0.08652}, "CVE-2025-32777": {"epss_score": 0.00147, "epss_percentile": 0.35662}, "CVE-2025-32778": {"epss_score": 0.00146, "epss_percentile": 0.3564}, "CVE-2025-32779": {"epss_score": 0.0112, "epss_percentile": 0.77765}, "CVE-2025-32780": {"epss_score": 0.0002, "epss_percentile": 0.04686}, "CVE-2025-32782": {"epss_score": 0.00064, "epss_percentile": 0.20393}, "CVE-2025-32783": {"epss_score": 0.00048, "epss_percentile": 0.14973}, "CVE-2025-32784": {"epss_score": 0.00047, "epss_percentile": 0.14643}, "CVE-2025-32785": {"epss_score": 0.00041, "epss_percentile": 0.12229}, "CVE-2025-32786": {"epss_score": 0.00065, "epss_percentile": 0.20493}, "CVE-2025-32787": {"epss_score": 0.00049, "epss_percentile": 0.15465}, "CVE-2025-32788": {"epss_score": 0.00029, "epss_percentile": 0.07933}, "CVE-2025-32789": {"epss_score": 0.00052, "epss_percentile": 0.16461}, "CVE-2025-32790": {"epss_score": 0.00064, "epss_percentile": 0.20425}, "CVE-2025-32791": {"epss_score": 0.00059, "epss_percentile": 0.18813}, "CVE-2025-32792": {"epss_score": 0.00262, "epss_percentile": 0.49366}, "CVE-2025-32793": {"epss_score": 7e-05, "epss_percentile": 0.00417}, "CVE-2025-32794": {"epss_score": 0.00142, "epss_percentile": 0.35074}, "CVE-2025-32795": {"epss_score": 0.00054, "epss_percentile": 0.17134}, "CVE-2025-32796": {"epss_score": 0.00079, "epss_percentile": 0.23891}, "CVE-2025-32797": {"epss_score": 0.00017, "epss_percentile": 0.03155}, "CVE-2025-32798": {"epss_score": 0.00162, "epss_percentile": 0.3764}, "CVE-2025-32799": {"epss_score": 0.00473, "epss_percentile": 0.6408}, "CVE-2025-32800": {"epss_score": 0.00066, "epss_percentile": 0.20927}, "CVE-2025-32801": {"epss_score": 0.00012, "epss_percentile": 0.01264}, "CVE-2025-32802": {"epss_score": 0.00011, "epss_percentile": 0.01077}, "CVE-2025-32803": {"epss_score": 0.00011, "epss_percentile": 0.00996}, "CVE-2025-32807": {"epss_score": 0.0008, "epss_percentile": 0.24047}, "CVE-2025-32808": {"epss_score": 0.00074, "epss_percentile": 0.22851}, "CVE-2025-32809": {"epss_score": 0.00046, "epss_percentile": 0.14115}, "CVE-2025-32813": {"epss_score": 0.04228, "epss_percentile": 0.88418}, "CVE-2025-32814": {"epss_score": 0.21505, "epss_percentile": 0.95527}, "CVE-2025-32815": {"epss_score": 0.24881, "epss_percentile": 0.95963}, "CVE-2025-32816": {"epss_score": 0.00052, "epss_percentile": 0.16379}, "CVE-2025-32817": {"epss_score": 0.0004, "epss_percentile": 0.11992}, "CVE-2025-32818": {"epss_score": 0.00072, "epss_percentile": 0.22308}, "CVE-2025-32819": {"epss_score": 0.00587, "epss_percentile": 0.68484}, "CVE-2025-32820": {"epss_score": 0.00273, "epss_percentile": 0.50467}, "CVE-2025-32821": {"epss_score": 0.00102, "epss_percentile": 0.28766}, "CVE-2025-32822": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32823": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32824": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32825": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32826": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32827": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32828": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32829": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32830": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32831": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32832": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32833": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32834": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32835": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32836": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32837": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32838": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32839": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32840": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32841": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32842": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32843": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32844": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32845": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32846": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32847": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32848": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32849": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32850": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32851": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32852": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32853": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32854": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32855": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32856": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32857": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32858": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32859": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32860": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32861": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32862": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32863": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32864": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32865": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32866": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32867": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32868": {"epss_score": 0.00238, "epss_percentile": 0.46839}, "CVE-2025-32869": {"epss_score": 0.00238, "epss_percentile": 0.46839}, "CVE-2025-32870": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32871": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32872": {"epss_score": 0.00351, "epss_percentile": 0.57003}, "CVE-2025-32873": {"epss_score": 0.00024, "epss_percentile": 0.05774}, "CVE-2025-32874": {"epss_score": 9e-05, "epss_percentile": 0.00631}, "CVE-2025-32875": {"epss_score": 8e-05, "epss_percentile": 0.00519}, "CVE-2025-32876": {"epss_score": 0.00019, "epss_percentile": 0.04283}, "CVE-2025-32877": {"epss_score": 0.00245, "epss_percentile": 0.47639}, "CVE-2025-32878": {"epss_score": 0.00052, "epss_percentile": 0.16349}, "CVE-2025-32879": {"epss_score": 0.00101, "epss_percentile": 0.28638}, "CVE-2025-32880": {"epss_score": 0.00043, "epss_percentile": 0.13}, "CVE-2025-32881": {"epss_score": 0.00013, "epss_percentile": 0.01523}, "CVE-2025-32882": {"epss_score": 6e-05, "epss_percentile": 0.00292}, "CVE-2025-32884": {"epss_score": 0.00013, "epss_percentile": 0.01523}, "CVE-2025-32885": {"epss_score": 0.00025, "epss_percentile": 0.06217}, "CVE-2025-32886": {"epss_score": 0.0002, "epss_percentile": 0.04525}, "CVE-2025-32887": {"epss_score": 0.00014, "epss_percentile": 0.01899}, "CVE-2025-32888": {"epss_score": 0.00019, "epss_percentile": 0.04161}, "CVE-2025-32889": {"epss_score": 0.00019, "epss_percentile": 0.04161}, "CVE-2025-32890": {"epss_score": 8e-05, "epss_percentile": 0.00556}, "CVE-2025-32896": {"epss_score": 0.00147, "epss_percentile": 0.3574}, "CVE-2025-32897": {"epss_score": 0.00369, "epss_percentile": 0.58277}, "CVE-2025-32898": {"epss_score": 0.00023, "epss_percentile": 0.0544}, "CVE-2025-32899": {"epss_score": 0.00029, "epss_percentile": 0.07586}, "CVE-2025-32900": {"epss_score": 0.00012, "epss_percentile": 0.01318}, "CVE-2025-32901": {"epss_score": 0.00038, "epss_percentile": 0.11156}, "CVE-2025-32906": {"epss_score": 0.00216, "epss_percentile": 0.44184}, "CVE-2025-32907": {"epss_score": 0.00271, "epss_percentile": 0.50308}, "CVE-2025-32908": {"epss_score": 0.00095, "epss_percentile": 0.27125}, "CVE-2025-32909": {"epss_score": 0.00133, "epss_percentile": 0.33677}, "CVE-2025-32910": {"epss_score": 0.00097, "epss_percentile": 0.27577}, "CVE-2025-32911": {"epss_score": 0.0014, "epss_percentile": 0.34708}, "CVE-2025-32912": {"epss_score": 0.00097, "epss_percentile": 0.27577}, "CVE-2025-32913": {"epss_score": 0.00252, "epss_percentile": 0.48403}, "CVE-2025-32914": {"epss_score": 0.00132, "epss_percentile": 0.3361}, "CVE-2025-32915": {"epss_score": 0.00014, "epss_percentile": 0.02059}, "CVE-2025-32916": {"epss_score": 0.00031, "epss_percentile": 0.08463}, "CVE-2025-32917": {"epss_score": 0.0005, "epss_percentile": 0.15952}, "CVE-2025-32918": {"epss_score": 0.00064, "epss_percentile": 0.20267}, "CVE-2025-32919": {"epss_score": 0.00028, "epss_percentile": 0.07218}, "CVE-2025-32920": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-32921": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-32922": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-32923": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-32924": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-32925": {"epss_score": 0.00108, "epss_percentile": 0.298}, "CVE-2025-32926": {"epss_score": 0.00113, "epss_percentile": 0.30612}, "CVE-2025-32927": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-32928": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-32929": {"epss_score": 0.00081, "epss_percentile": 0.24233}, "CVE-2025-32931": {"epss_score": 0.00095, "epss_percentile": 0.27098}, "CVE-2025-32932": {"epss_score": 0.0003, "epss_percentile": 0.08158}, "CVE-2025-32942": {"epss_score": 0.00051, "epss_percentile": 0.16072}, "CVE-2025-32943": {"epss_score": 0.00022, "epss_percentile": 0.05143}, "CVE-2025-32944": {"epss_score": 9e-05, "epss_percentile": 0.00737}, "CVE-2025-32945": {"epss_score": 0.0002, "epss_percentile": 0.04656}, "CVE-2025-32946": {"epss_score": 0.00027, "epss_percentile": 0.06912}, "CVE-2025-32947": {"epss_score": 0.00015, "epss_percentile": 0.0255}, "CVE-2025-32948": {"epss_score": 0.00052, "epss_percentile": 0.16457}, "CVE-2025-32949": {"epss_score": 0.00028, "epss_percentile": 0.07248}, "CVE-2025-32950": {"epss_score": 0.00151, "epss_percentile": 0.36191}, "CVE-2025-32951": {"epss_score": 0.00111, "epss_percentile": 0.30352}, "CVE-2025-32952": {"epss_score": 0.00303, "epss_percentile": 0.5323}, "CVE-2025-32953": {"epss_score": 0.00105, "epss_percentile": 0.29358}, "CVE-2025-32955": {"epss_score": 0.00022, "epss_percentile": 0.05006}, "CVE-2025-32956": {"epss_score": 0.00052, "epss_percentile": 0.16383}, "CVE-2025-32958": {"epss_score": 0.00094, "epss_percentile": 0.27045}, "CVE-2025-32959": {"epss_score": 0.00182, "epss_percentile": 0.40222}, "CVE-2025-32960": {"epss_score": 0.0007, "epss_percentile": 0.21723}, "CVE-2025-32961": {"epss_score": 0.00062, "epss_percentile": 0.19777}, "CVE-2025-32962": {"epss_score": 0.00033, "epss_percentile": 0.09415}, "CVE-2025-32963": {"epss_score": 0.00091, "epss_percentile": 0.26222}, "CVE-2025-32964": {"epss_score": 0.00043, "epss_percentile": 0.13276}, "CVE-2025-32965": {"epss_score": 0.00108, "epss_percentile": 0.29789}, "CVE-2025-32966": {"epss_score": 0.00098, "epss_percentile": 0.27817}, "CVE-2025-32967": {"epss_score": 0.00159, "epss_percentile": 0.3732}, "CVE-2025-32968": {"epss_score": 0.00332, "epss_percentile": 0.55585}, "CVE-2025-32969": {"epss_score": 0.25201, "epss_percentile": 0.95996}, "CVE-2025-32970": {"epss_score": 0.00142, "epss_percentile": 0.35041}, "CVE-2025-32971": {"epss_score": 0.00034, "epss_percentile": 0.09739}, "CVE-2025-32972": {"epss_score": 0.00047, "epss_percentile": 0.14485}, "CVE-2025-32973": {"epss_score": 0.0086, "epss_percentile": 0.74532}, "CVE-2025-32974": {"epss_score": 0.00544, "epss_percentile": 0.67133}, "CVE-2025-32975": {"epss_score": 0.00167, "epss_percentile": 0.38391}, "CVE-2025-32976": {"epss_score": 0.00169, "epss_percentile": 0.38598}, "CVE-2025-32977": {"epss_score": 0.00046, "epss_percentile": 0.14094}, "CVE-2025-32978": {"epss_score": 0.0019, "epss_percentile": 0.41055}, "CVE-2025-32979": {"epss_score": 0.00045, "epss_percentile": 0.13981}, "CVE-2025-32980": {"epss_score": 0.0007, "epss_percentile": 0.21752}, "CVE-2025-32981": {"epss_score": 0.00017, "epss_percentile": 0.03176}, "CVE-2025-32982": {"epss_score": 0.00053, "epss_percentile": 0.16718}, "CVE-2025-32983": {"epss_score": 0.00051, "epss_percentile": 0.16288}, "CVE-2025-32984": {"epss_score": 0.00028, "epss_percentile": 0.07244}, "CVE-2025-32985": {"epss_score": 0.00074, "epss_percentile": 0.22746}, "CVE-2025-32986": {"epss_score": 0.00053, "epss_percentile": 0.16893}, "CVE-2025-32987": {"epss_score": 0.00025, "epss_percentile": 0.06334}, "CVE-2025-32988": {"epss_score": 0.00117, "epss_percentile": 0.31244}, "CVE-2025-32989": {"epss_score": 0.00086, "epss_percentile": 0.25282}, "CVE-2025-32990": {"epss_score": 0.00155, "epss_percentile": 0.36824}, "CVE-2025-32992": {"epss_score": 0.00046, "epss_percentile": 0.1415}, "CVE-2025-32993": {"epss_score": 0.00065, "epss_percentile": 0.20478}, "CVE-2025-32996": {"epss_score": 0.00046, "epss_percentile": 0.14422}, "CVE-2025-32997": {"epss_score": 0.00063, "epss_percentile": 0.19956}, "CVE-2025-32999": {"epss_score": 0.00025, "epss_percentile": 0.06292}, "CVE-2025-33000": {"epss_score": 0.00025, "epss_percentile": 0.06289}, "CVE-2025-33003": {"epss_score": 0.0002, "epss_percentile": 0.04607}, "CVE-2025-33004": {"epss_score": 0.00138, "epss_percentile": 0.3446}, "CVE-2025-33005": {"epss_score": 0.00041, "epss_percentile": 0.12234}, "CVE-2025-33008": {"epss_score": 0.00049, "epss_percentile": 0.15434}, "CVE-2025-33012": {"epss_score": 0.00023, "epss_percentile": 0.05488}, "CVE-2025-33013": {"epss_score": 0.00012, "epss_percentile": 0.01182}, "CVE-2025-33014": {"epss_score": 0.00026, "epss_percentile": 0.06667}, "CVE-2025-33020": {"epss_score": 0.0001, "epss_percentile": 0.00761}, "CVE-2025-33023": {"epss_score": 0.0004, "epss_percentile": 0.11987}, "CVE-2025-33024": {"epss_score": 0.00256, "epss_percentile": 0.48781}, "CVE-2025-33025": {"epss_score": 0.00256, "epss_percentile": 0.48781}, "CVE-2025-33026": {"epss_score": 0.00063, "epss_percentile": 0.19911}, "CVE-2025-33027": {"epss_score": 0.00063, "epss_percentile": 0.19911}, "CVE-2025-33028": {"epss_score": 0.00073, "epss_percentile": 0.22497}, "CVE-2025-33029": {"epss_score": 0.0002, "epss_percentile": 0.0466}, "CVE-2025-33031": {"epss_score": 0.00078, "epss_percentile": 0.23793}, "CVE-2025-33032": {"epss_score": 0.0008, "epss_percentile": 0.2411}, "CVE-2025-33033": {"epss_score": 0.00087, "epss_percentile": 0.25458}, "CVE-2025-33034": {"epss_score": 0.00078, "epss_percentile": 0.23773}, "CVE-2025-33035": {"epss_score": 0.00068, "epss_percentile": 0.21247}, "CVE-2025-33036": {"epss_score": 0.00087, "epss_percentile": 0.25458}, "CVE-2025-33037": {"epss_score": 0.00087, "epss_percentile": 0.25458}, "CVE-2025-33038": {"epss_score": 0.00087, "epss_percentile": 0.25458}, "CVE-2025-33039": {"epss_score": 0.00159, "epss_percentile": 0.37401}, "CVE-2025-33040": {"epss_score": 0.00159, "epss_percentile": 0.37401}, "CVE-2025-33043": {"epss_score": 0.00018, "epss_percentile": 0.03607}, "CVE-2025-33044": {"epss_score": 0.00023, "epss_percentile": 0.05359}, "CVE-2025-33045": {"epss_score": 0.00018, "epss_percentile": 0.03716}, "CVE-2025-33050": {"epss_score": 0.0015, "epss_percentile": 0.3606}, "CVE-2025-33051": {"epss_score": 0.00106, "epss_percentile": 0.29445}, "CVE-2025-33052": {"epss_score": 0.00161, "epss_percentile": 0.37554}, "CVE-2025-33053": {"epss_score": 0.29537, "epss_percentile": 0.96451}, "CVE-2025-33054": {"epss_score": 0.00044, "epss_percentile": 0.13491}, "CVE-2025-33055": {"epss_score": 0.00059, "epss_percentile": 0.18907}, "CVE-2025-33056": {"epss_score": 0.00153, "epss_percentile": 0.3664}, "CVE-2025-33057": {"epss_score": 0.00239, "epss_percentile": 0.46938}, "CVE-2025-33058": {"epss_score": 0.00059, "epss_percentile": 0.18907}, "CVE-2025-33059": {"epss_score": 0.00059, "epss_percentile": 0.18907}, "CVE-2025-33060": {"epss_score": 0.00059, "epss_percentile": 0.18907}, "CVE-2025-33061": {"epss_score": 0.00059, "epss_percentile": 0.18907}, "CVE-2025-33062": {"epss_score": 0.00059, "epss_percentile": 0.18907}, "CVE-2025-33063": {"epss_score": 0.00059, "epss_percentile": 0.18907}, "CVE-2025-33064": {"epss_score": 0.00115, "epss_percentile": 0.31029}, "CVE-2025-33065": {"epss_score": 0.00059, "epss_percentile": 0.18907}, "CVE-2025-33066": {"epss_score": 0.00076, "epss_percentile": 0.23266}, "CVE-2025-33067": {"epss_score": 0.00075, "epss_percentile": 0.22927}, "CVE-2025-33068": {"epss_score": 0.13489, "epss_percentile": 0.93979}, "CVE-2025-33069": {"epss_score": 0.00033, "epss_percentile": 0.092}, "CVE-2025-33070": {"epss_score": 0.00236, "epss_percentile": 0.46424}, "CVE-2025-33071": {"epss_score": 0.002, "epss_percentile": 0.42232}, "CVE-2025-33072": {"epss_score": 0.00109, "epss_percentile": 0.30023}, "CVE-2025-33073": {"epss_score": 0.51186, "epss_percentile": 0.97768}, "CVE-2025-33074": {"epss_score": 0.00048, "epss_percentile": 0.15007}, "CVE-2025-33075": {"epss_score": 0.0009, "epss_percentile": 0.25995}, "CVE-2025-33076": {"epss_score": 0.0005, "epss_percentile": 0.1589}, "CVE-2025-33077": {"epss_score": 0.0005, "epss_percentile": 0.1589}, "CVE-2025-33079": {"epss_score": 0.00034, "epss_percentile": 0.0956}, "CVE-2025-33082": {"epss_score": 0.00049, "epss_percentile": 0.15434}, "CVE-2025-33083": {"epss_score": 0.00049, "epss_percentile": 0.15434}, "CVE-2025-33084": {"epss_score": 0.00025, "epss_percentile": 0.06111}, "CVE-2025-33090": {"epss_score": 0.00225, "epss_percentile": 0.45132}, "CVE-2025-33092": {"epss_score": 0.00012, "epss_percentile": 0.01183}, "CVE-2025-33093": {"epss_score": 0.00038, "epss_percentile": 0.11217}, "CVE-2025-33096": {"epss_score": 0.00062, "epss_percentile": 0.19737}, "CVE-2025-33097": {"epss_score": 0.00019, "epss_percentile": 0.04356}, "CVE-2025-33099": {"epss_score": 0.00034, "epss_percentile": 0.09744}, "CVE-2025-33100": {"epss_score": 0.00025, "epss_percentile": 0.06341}, "CVE-2025-33102": {"epss_score": 0.00022, "epss_percentile": 0.05313}, "CVE-2025-33103": {"epss_score": 0.00035, "epss_percentile": 0.09922}, "CVE-2025-33104": {"epss_score": 0.00022, "epss_percentile": 0.05236}, "CVE-2025-33108": {"epss_score": 0.00037, "epss_percentile": 0.10627}, "CVE-2025-33109": {"epss_score": 0.00036, "epss_percentile": 0.10489}, "CVE-2025-33110": {"epss_score": 0.00038, "epss_percentile": 0.11109}, "CVE-2025-33111": {"epss_score": 0.00029, "epss_percentile": 0.07748}, "CVE-2025-33112": {"epss_score": 0.0002, "epss_percentile": 0.04595}, "CVE-2025-33114": {"epss_score": 0.00035, "epss_percentile": 0.099}, "CVE-2025-33116": {"epss_score": 0.00036, "epss_percentile": 0.1062}, "CVE-2025-33117": {"epss_score": 0.00039, "epss_percentile": 0.11526}, "CVE-2025-33118": {"epss_score": 0.00016, "epss_percentile": 0.0295}, "CVE-2025-33119": {"epss_score": 0.00034, "epss_percentile": 0.09783}, "CVE-2025-33120": {"epss_score": 0.00026, "epss_percentile": 0.06564}, "CVE-2025-33121": {"epss_score": 0.00145, "epss_percentile": 0.35454}, "CVE-2025-33122": {"epss_score": 0.00032, "epss_percentile": 0.09094}, "CVE-2025-33126": {"epss_score": 0.00062, "epss_percentile": 0.19803}, "CVE-2025-33131": {"epss_score": 0.00062, "epss_percentile": 0.19803}, "CVE-2025-33132": {"epss_score": 0.00062, "epss_percentile": 0.19803}, "CVE-2025-33133": {"epss_score": 0.00062, "epss_percentile": 0.19803}, "CVE-2025-33136": {"epss_score": 0.00038, "epss_percentile": 0.11124}, "CVE-2025-33137": {"epss_score": 0.00037, "epss_percentile": 0.10886}, "CVE-2025-33138": {"epss_score": 0.00024, "epss_percentile": 0.05676}, "CVE-2025-33142": {"epss_score": 0.00055, "epss_percentile": 0.1744}, "CVE-2025-33150": {"epss_score": 0.00037, "epss_percentile": 0.10935}, "CVE-2025-33176": {"epss_score": 0.00019, "epss_percentile": 0.04397}, "CVE-2025-33177": {"epss_score": 0.00019, "epss_percentile": 0.04275}, "CVE-2025-33178": {"epss_score": 0.00024, "epss_percentile": 0.05751}, "CVE-2025-33182": {"epss_score": 0.00096, "epss_percentile": 0.27342}, "CVE-2025-33183": {"epss_score": 0.00024, "epss_percentile": 0.05751}, "CVE-2025-33184": {"epss_score": 0.00024, "epss_percentile": 0.05751}, "CVE-2025-33185": {"epss_score": 0.00039, "epss_percentile": 0.11639}, "CVE-2025-33186": {"epss_score": 0.00042, "epss_percentile": 0.12906}, "CVE-2025-33187": {"epss_score": 0.00013, "epss_percentile": 0.01482}, "CVE-2025-33188": {"epss_score": 0.00014, "epss_percentile": 0.01819}, "CVE-2025-33189": {"epss_score": 0.00014, "epss_percentile": 0.02061}, "CVE-2025-33190": {"epss_score": 0.00013, "epss_percentile": 0.01611}, "CVE-2025-33191": {"epss_score": 0.00022, "epss_percentile": 0.05314}, "CVE-2025-33192": {"epss_score": 0.00015, "epss_percentile": 0.02335}, "CVE-2025-33193": {"epss_score": 7e-05, "epss_percentile": 0.00442}, "CVE-2025-33194": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-33195": {"epss_score": 0.00014, "epss_percentile": 0.01979}, "CVE-2025-33196": {"epss_score": 0.00013, "epss_percentile": 0.01635}, "CVE-2025-33197": {"epss_score": 0.00015, "epss_percentile": 0.02335}, "CVE-2025-33198": {"epss_score": 0.00014, "epss_percentile": 0.02078}, "CVE-2025-33199": {"epss_score": 0.00013, "epss_percentile": 0.01618}, "CVE-2025-33200": {"epss_score": 0.00013, "epss_percentile": 0.01618}, "CVE-2025-33201": {"epss_score": 0.00057, "epss_percentile": 0.18061}, "CVE-2025-33202": {"epss_score": 0.00052, "epss_percentile": 0.16363}, "CVE-2025-33203": {"epss_score": 0.00043, "epss_percentile": 0.13237}, "CVE-2025-33204": {"epss_score": 0.00024, "epss_percentile": 0.05751}, "CVE-2025-33205": {"epss_score": 0.00014, "epss_percentile": 0.01921}, "CVE-2025-33208": {"epss_score": 0.00052, "epss_percentile": 0.16569}, "CVE-2025-33210": {"epss_score": 0.00053, "epss_percentile": 0.1673}, "CVE-2025-33211": {"epss_score": 0.00104, "epss_percentile": 0.29234}, "CVE-2025-33212": {"epss_score": 0.00045, "epss_percentile": 0.13819}, "CVE-2025-33213": {"epss_score": 0.00063, "epss_percentile": 0.19855}, "CVE-2025-33214": {"epss_score": 0.00063, "epss_percentile": 0.19855}, "CVE-2025-33222": {"epss_score": 0.00072, "epss_percentile": 0.22473}, "CVE-2025-33223": {"epss_score": 0.00075, "epss_percentile": 0.22918}, "CVE-2025-33224": {"epss_score": 0.00075, "epss_percentile": 0.22918}, "CVE-2025-33225": {"epss_score": 0.00025, "epss_percentile": 0.0638}, "CVE-2025-33226": {"epss_score": 0.00069, "epss_percentile": 0.21626}, "CVE-2025-33235": {"epss_score": 0.00011, "epss_percentile": 0.01049}, "CVE-2025-34021": {"epss_score": 0.00056, "epss_percentile": 0.17909}, "CVE-2025-34022": {"epss_score": 0.00345, "epss_percentile": 0.56551}, "CVE-2025-34023": {"epss_score": 0.01848, "epss_percentile": 0.82525}, "CVE-2025-34024": {"epss_score": 0.0034, "epss_percentile": 0.5624}, "CVE-2025-34025": {"epss_score": 0.00061, "epss_percentile": 0.19496}, "CVE-2025-34026": {"epss_score": 0.07882, "epss_percentile": 0.9174}, "CVE-2025-34027": {"epss_score": 0.03964, "epss_percentile": 0.88021}, "CVE-2025-34028": {"epss_score": 0.45932, "epss_percentile": 0.97509}, "CVE-2025-34029": {"epss_score": 0.0093, "epss_percentile": 0.75602}, "CVE-2025-34030": {"epss_score": 0.01036, "epss_percentile": 0.76918}, "CVE-2025-34031": {"epss_score": 0.14521, "epss_percentile": 0.94229}, "CVE-2025-34032": {"epss_score": 0.00115, "epss_percentile": 0.30884}, "CVE-2025-34033": {"epss_score": 0.00183, "epss_percentile": 0.40347}, "CVE-2025-34034": {"epss_score": 0.00064, "epss_percentile": 0.20146}, "CVE-2025-34035": {"epss_score": 0.07633, "epss_percentile": 0.91586}, "CVE-2025-34036": {"epss_score": 0.04199, "epss_percentile": 0.88385}, "CVE-2025-34037": {"epss_score": 0.79616, "epss_percentile": 0.99049}, "CVE-2025-34038": {"epss_score": 0.05475, "epss_percentile": 0.8991}, "CVE-2025-34039": {"epss_score": 0.00361, "epss_percentile": 0.57747}, "CVE-2025-34040": {"epss_score": 0.06587, "epss_percentile": 0.90868}, "CVE-2025-34041": {"epss_score": 0.01032, "epss_percentile": 0.76864}, "CVE-2025-34042": {"epss_score": 0.0027, "epss_percentile": 0.50261}, "CVE-2025-34043": {"epss_score": 0.00487, "epss_percentile": 0.64812}, "CVE-2025-34044": {"epss_score": 0.00408, "epss_percentile": 0.60642}, "CVE-2025-34045": {"epss_score": 0.1859, "epss_percentile": 0.95038}, "CVE-2025-34046": {"epss_score": 0.02626, "epss_percentile": 0.85265}, "CVE-2025-34047": {"epss_score": 0.00716, "epss_percentile": 0.71867}, "CVE-2025-34048": {"epss_score": 0.00212, "epss_percentile": 0.43751}, "CVE-2025-34049": {"epss_score": 0.00307, "epss_percentile": 0.53529}, "CVE-2025-34050": {"epss_score": 0.00033, "epss_percentile": 0.09406}, "CVE-2025-34051": {"epss_score": 0.00125, "epss_percentile": 0.32589}, "CVE-2025-34053": {"epss_score": 0.00126, "epss_percentile": 0.32642}, "CVE-2025-34054": {"epss_score": 0.00264, "epss_percentile": 0.49737}, "CVE-2025-34055": {"epss_score": 0.00316, "epss_percentile": 0.5429}, "CVE-2025-34056": {"epss_score": 0.00254, "epss_percentile": 0.48546}, "CVE-2025-34057": {"epss_score": 0.00618, "epss_percentile": 0.69368}, "CVE-2025-34058": {"epss_score": 0.00984, "epss_percentile": 0.76316}, "CVE-2025-34059": {"epss_score": 0.00151, "epss_percentile": 0.36231}, "CVE-2025-34060": {"epss_score": 0.00343, "epss_percentile": 0.56426}, "CVE-2025-34061": {"epss_score": 0.59249, "epss_percentile": 0.98157}, "CVE-2025-34062": {"epss_score": 0.00017, "epss_percentile": 0.03218}, "CVE-2025-34063": {"epss_score": 0.00122, "epss_percentile": 0.32026}, "CVE-2025-34064": {"epss_score": 0.00057, "epss_percentile": 0.18111}, "CVE-2025-34065": {"epss_score": 0.00126, "epss_percentile": 0.32642}, "CVE-2025-34066": {"epss_score": 0.00048, "epss_percentile": 0.15041}, "CVE-2025-34067": {"epss_score": 0.01579, "epss_percentile": 0.81127}, "CVE-2025-34068": {"epss_score": 0.0103, "epss_percentile": 0.76837}, "CVE-2025-34069": {"epss_score": 0.00638, "epss_percentile": 0.69908}, "CVE-2025-34070": {"epss_score": 0.00995, "epss_percentile": 0.76431}, "CVE-2025-34071": {"epss_score": 0.00517, "epss_percentile": 0.66071}, "CVE-2025-34072": {"epss_score": 0.00091, "epss_percentile": 0.26375}, "CVE-2025-34073": {"epss_score": 0.54239, "epss_percentile": 0.97917}, "CVE-2025-34074": {"epss_score": 0.53327, "epss_percentile": 0.97872}, "CVE-2025-34076": {"epss_score": 0.21321, "epss_percentile": 0.955}, "CVE-2025-34077": {"epss_score": 0.71207, "epss_percentile": 0.98659}, "CVE-2025-34078": {"epss_score": 0.0229, "epss_percentile": 0.84282}, "CVE-2025-34079": {"epss_score": 0.51893, "epss_percentile": 0.97801}, "CVE-2025-34080": {"epss_score": 0.0003, "epss_percentile": 0.08151}, "CVE-2025-34081": {"epss_score": 0.00076, "epss_percentile": 0.23134}, "CVE-2025-34082": {"epss_score": 0.46036, "epss_percentile": 0.97518}, "CVE-2025-34086": {"epss_score": 0.50829, "epss_percentile": 0.97751}, "CVE-2025-34087": {"epss_score": 0.46719, "epss_percentile": 0.97555}, "CVE-2025-34088": {"epss_score": 0.49712, "epss_percentile": 0.97701}, "CVE-2025-34089": {"epss_score": 0.565, "epss_percentile": 0.98025}, "CVE-2025-34093": {"epss_score": 0.46601, "epss_percentile": 0.97554}, "CVE-2025-34095": {"epss_score": 0.45366, "epss_percentile": 0.97483}, "CVE-2025-34096": {"epss_score": 0.49128, "epss_percentile": 0.97669}, "CVE-2025-34097": {"epss_score": 0.28314, "epss_percentile": 0.96342}, "CVE-2025-34098": {"epss_score": 0.41376, "epss_percentile": 0.9727}, "CVE-2025-34099": {"epss_score": 0.19992, "epss_percentile": 0.95272}, "CVE-2025-34100": {"epss_score": 0.62386, "epss_percentile": 0.9829}, "CVE-2025-34101": {"epss_score": 0.5394, "epss_percentile": 0.97903}, "CVE-2025-34102": {"epss_score": 0.60032, "epss_percentile": 0.9819}, "CVE-2025-34103": {"epss_score": 0.52158, "epss_percentile": 0.97811}, "CVE-2025-34104": {"epss_score": 0.52612, "epss_percentile": 0.97832}, "CVE-2025-34105": {"epss_score": 0.49128, "epss_percentile": 0.97669}, "CVE-2025-34106": {"epss_score": 0.08151, "epss_percentile": 0.91904}, "CVE-2025-34107": {"epss_score": 0.52665, "epss_percentile": 0.97834}, "CVE-2025-34108": {"epss_score": 0.58476, "epss_percentile": 0.9812}, "CVE-2025-34109": {"epss_score": 0.02439, "epss_percentile": 0.84749}, "CVE-2025-34110": {"epss_score": 0.37116, "epss_percentile": 0.9702}, "CVE-2025-34111": {"epss_score": 0.70887, "epss_percentile": 0.98646}, "CVE-2025-34112": {"epss_score": 0.45477, "epss_percentile": 0.97489}, "CVE-2025-34113": {"epss_score": 0.40157, "epss_percentile": 0.972}, "CVE-2025-34114": {"epss_score": 0.0002, "epss_percentile": 0.04522}, "CVE-2025-34115": {"epss_score": 0.48424, "epss_percentile": 0.97637}, "CVE-2025-34116": {"epss_score": 0.56873, "epss_percentile": 0.9804}, "CVE-2025-34117": {"epss_score": 0.503, "epss_percentile": 0.97731}, "CVE-2025-34118": {"epss_score": 0.44926, "epss_percentile": 0.9746}, "CVE-2025-34119": {"epss_score": 0.29559, "epss_percentile": 0.96457}, "CVE-2025-34120": {"epss_score": 0.50175, "epss_percentile": 0.97723}, "CVE-2025-34121": {"epss_score": 0.64474, "epss_percentile": 0.9838}, "CVE-2025-34123": {"epss_score": 0.07317, "epss_percentile": 0.91404}, "CVE-2025-34124": {"epss_score": 0.10674, "epss_percentile": 0.93065}, "CVE-2025-34125": {"epss_score": 0.4516, "epss_percentile": 0.97476}, "CVE-2025-34126": {"epss_score": 0.73557, "epss_percentile": 0.98762}, "CVE-2025-34127": {"epss_score": 0.52216, "epss_percentile": 0.97813}, "CVE-2025-34128": {"epss_score": 0.47949, "epss_percentile": 0.9761}, "CVE-2025-34129": {"epss_score": 0.00196, "epss_percentile": 0.41755}, "CVE-2025-34130": {"epss_score": 0.0027, "epss_percentile": 0.50225}, "CVE-2025-34132": {"epss_score": 0.00553, "epss_percentile": 0.67406}, "CVE-2025-34133": {"epss_score": 0.00027, "epss_percentile": 0.06834}, "CVE-2025-34134": {"epss_score": 0.00693, "epss_percentile": 0.71333}, "CVE-2025-34135": {"epss_score": 0.0003, "epss_percentile": 0.08053}, "CVE-2025-34136": {"epss_score": 0.00187, "epss_percentile": 0.40774}, "CVE-2025-34139": {"epss_score": 0.00148, "epss_percentile": 0.35904}, "CVE-2025-34140": {"epss_score": 0.00296, "epss_percentile": 0.52561}, "CVE-2025-34141": {"epss_score": 0.01565, "epss_percentile": 0.81064}, "CVE-2025-34142": {"epss_score": 0.00099, "epss_percentile": 0.2831}, "CVE-2025-34143": {"epss_score": 0.03342, "epss_percentile": 0.86945}, "CVE-2025-34146": {"epss_score": 0.00342, "epss_percentile": 0.56398}, "CVE-2025-34147": {"epss_score": 0.0013, "epss_percentile": 0.3324}, "CVE-2025-34148": {"epss_score": 0.0013, "epss_percentile": 0.3324}, "CVE-2025-34149": {"epss_score": 0.00839, "epss_percentile": 0.74186}, "CVE-2025-34150": {"epss_score": 0.00685, "epss_percentile": 0.71142}, "CVE-2025-34151": {"epss_score": 0.0394, "epss_percentile": 0.87988}, "CVE-2025-34152": {"epss_score": 0.12367, "epss_percentile": 0.93651}, "CVE-2025-34153": {"epss_score": 0.00833, "epss_percentile": 0.74088}, "CVE-2025-34154": {"epss_score": 0.00188, "epss_percentile": 0.40811}, "CVE-2025-34155": {"epss_score": 0.00375, "epss_percentile": 0.58625}, "CVE-2025-34156": {"epss_score": 0.0006, "epss_percentile": 0.18975}, "CVE-2025-34157": {"epss_score": 0.00111, "epss_percentile": 0.30343}, "CVE-2025-34158": {"epss_score": 0.00063, "epss_percentile": 0.19867}, "CVE-2025-34159": {"epss_score": 0.00527, "epss_percentile": 0.66445}, "CVE-2025-34160": {"epss_score": 0.01228, "epss_percentile": 0.78705}, "CVE-2025-34161": {"epss_score": 0.00669, "epss_percentile": 0.70751}, "CVE-2025-34162": {"epss_score": 0.00517, "epss_percentile": 0.66074}, "CVE-2025-34163": {"epss_score": 0.00771, "epss_percentile": 0.73018}, "CVE-2025-34164": {"epss_score": 0.00435, "epss_percentile": 0.62355}, "CVE-2025-34165": {"epss_score": 0.00278, "epss_percentile": 0.50903}, "CVE-2025-34171": {"epss_score": 0.00135, "epss_percentile": 0.34025}, "CVE-2025-34172": {"epss_score": 0.00025, "epss_percentile": 0.06214}, "CVE-2025-34173": {"epss_score": 0.00042, "epss_percentile": 0.12889}, "CVE-2025-34174": {"epss_score": 0.00027, "epss_percentile": 0.06982}, "CVE-2025-34175": {"epss_score": 0.00025, "epss_percentile": 0.06365}, "CVE-2025-34176": {"epss_score": 0.00042, "epss_percentile": 0.12889}, "CVE-2025-34177": {"epss_score": 0.0002, "epss_percentile": 0.04529}, "CVE-2025-34178": {"epss_score": 0.0002, "epss_percentile": 0.04529}, "CVE-2025-34179": {"epss_score": 0.00131, "epss_percentile": 0.33463}, "CVE-2025-34180": {"epss_score": 0.00032, "epss_percentile": 0.08856}, "CVE-2025-34181": {"epss_score": 0.00816, "epss_percentile": 0.73799}, "CVE-2025-34182": {"epss_score": 0.0007, "epss_percentile": 0.21704}, "CVE-2025-34183": {"epss_score": 0.00363, "epss_percentile": 0.57894}, "CVE-2025-34184": {"epss_score": 0.01393, "epss_percentile": 0.79964}, "CVE-2025-34185": {"epss_score": 0.00355, "epss_percentile": 0.5729}, "CVE-2025-34186": {"epss_score": 0.00934, "epss_percentile": 0.75655}, "CVE-2025-34187": {"epss_score": 0.01109, "epss_percentile": 0.77647}, "CVE-2025-34188": {"epss_score": 0.00056, "epss_percentile": 0.17926}, "CVE-2025-34189": {"epss_score": 0.00017, "epss_percentile": 0.03217}, "CVE-2025-34190": {"epss_score": 0.00061, "epss_percentile": 0.1946}, "CVE-2025-34191": {"epss_score": 0.00024, "epss_percentile": 0.0584}, "CVE-2025-34192": {"epss_score": 0.00158, "epss_percentile": 0.3715}, "CVE-2025-34193": {"epss_score": 0.00111, "epss_percentile": 0.3027}, "CVE-2025-34194": {"epss_score": 0.00029, "epss_percentile": 0.07749}, "CVE-2025-34195": {"epss_score": 0.00433, "epss_percentile": 0.62172}, "CVE-2025-34196": {"epss_score": 0.00042, "epss_percentile": 0.12593}, "CVE-2025-34197": {"epss_score": 0.00017, "epss_percentile": 0.03407}, "CVE-2025-34198": {"epss_score": 0.00073, "epss_percentile": 0.22607}, "CVE-2025-34199": {"epss_score": 0.00092, "epss_percentile": 0.26442}, "CVE-2025-34200": {"epss_score": 7e-05, "epss_percentile": 0.00426}, "CVE-2025-34201": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2025-34202": {"epss_score": 0.00653, "epss_percentile": 0.70327}, "CVE-2025-34203": {"epss_score": 0.00089, "epss_percentile": 0.25822}, "CVE-2025-34204": {"epss_score": 0.00066, "epss_percentile": 0.20946}, "CVE-2025-34205": {"epss_score": 0.05283, "epss_percentile": 0.89691}, "CVE-2025-34206": {"epss_score": 0.00036, "epss_percentile": 0.10392}, "CVE-2025-34207": {"epss_score": 0.00067, "epss_percentile": 0.21086}, "CVE-2025-34208": {"epss_score": 0.00098, "epss_percentile": 0.27821}, "CVE-2025-34209": {"epss_score": 0.00075, "epss_percentile": 0.22929}, "CVE-2025-34210": {"epss_score": 0.00012, "epss_percentile": 0.01133}, "CVE-2025-34211": {"epss_score": 0.00025, "epss_percentile": 0.06312}, "CVE-2025-34212": {"epss_score": 0.0021, "epss_percentile": 0.43476}, "CVE-2025-34215": {"epss_score": 0.00464, "epss_percentile": 0.63717}, "CVE-2025-34216": {"epss_score": 0.00207, "epss_percentile": 0.43081}, "CVE-2025-34217": {"epss_score": 0.00086, "epss_percentile": 0.25354}, "CVE-2025-34218": {"epss_score": 0.00795, "epss_percentile": 0.73466}, "CVE-2025-34220": {"epss_score": 0.00282, "epss_percentile": 0.5124}, "CVE-2025-34221": {"epss_score": 0.02942, "epss_percentile": 0.86034}, "CVE-2025-34222": {"epss_score": 0.00227, "epss_percentile": 0.45404}, "CVE-2025-34223": {"epss_score": 0.02416, "epss_percentile": 0.84687}, "CVE-2025-34224": {"epss_score": 0.01954, "epss_percentile": 0.8303}, "CVE-2025-34225": {"epss_score": 0.007, "epss_percentile": 0.71467}, "CVE-2025-34226": {"epss_score": 0.00095, "epss_percentile": 0.27091}, "CVE-2025-34227": {"epss_score": 0.01378, "epss_percentile": 0.79847}, "CVE-2025-34228": {"epss_score": 0.007, "epss_percentile": 0.71467}, "CVE-2025-34229": {"epss_score": 0.00056, "epss_percentile": 0.17707}, "CVE-2025-34230": {"epss_score": 0.00056, "epss_percentile": 0.17707}, "CVE-2025-34231": {"epss_score": 0.00402, "epss_percentile": 0.60297}, "CVE-2025-34232": {"epss_score": 0.00056, "epss_percentile": 0.17707}, "CVE-2025-34233": {"epss_score": 0.00052, "epss_percentile": 0.16518}, "CVE-2025-34234": {"epss_score": 0.00036, "epss_percentile": 0.1039}, "CVE-2025-34235": {"epss_score": 0.00239, "epss_percentile": 0.46909}, "CVE-2025-34236": {"epss_score": 0.00038, "epss_percentile": 0.11101}, "CVE-2025-34237": {"epss_score": 0.00033, "epss_percentile": 0.0942}, "CVE-2025-34238": {"epss_score": 0.00055, "epss_percentile": 0.17543}, "CVE-2025-34239": {"epss_score": 0.00231, "epss_percentile": 0.45827}, "CVE-2025-34240": {"epss_score": 0.00031, "epss_percentile": 0.08687}, "CVE-2025-34241": {"epss_score": 0.00031, "epss_percentile": 0.08687}, "CVE-2025-34242": {"epss_score": 0.00031, "epss_percentile": 0.08687}, "CVE-2025-34243": {"epss_score": 0.00031, "epss_percentile": 0.08687}, "CVE-2025-34244": {"epss_score": 0.00031, "epss_percentile": 0.08687}, "CVE-2025-34245": {"epss_score": 0.00031, "epss_percentile": 0.08687}, "CVE-2025-34246": {"epss_score": 0.00032, "epss_percentile": 0.08988}, "CVE-2025-34247": {"epss_score": 0.00035, "epss_percentile": 0.10086}, "CVE-2025-34248": {"epss_score": 0.00713, "epss_percentile": 0.718}, "CVE-2025-34251": {"epss_score": 0.00056, "epss_percentile": 0.17696}, "CVE-2025-34253": {"epss_score": 0.00022, "epss_percentile": 0.05138}, "CVE-2025-34254": {"epss_score": 0.0005, "epss_percentile": 0.15703}, "CVE-2025-34255": {"epss_score": 0.0005, "epss_percentile": 0.15703}, "CVE-2025-34256": {"epss_score": 0.00236, "epss_percentile": 0.46425}, "CVE-2025-34257": {"epss_score": 0.00033, "epss_percentile": 0.0942}, "CVE-2025-34258": {"epss_score": 0.00033, "epss_percentile": 0.0942}, "CVE-2025-34259": {"epss_score": 0.00033, "epss_percentile": 0.0942}, "CVE-2025-34260": {"epss_score": 0.00033, "epss_percentile": 0.0942}, "CVE-2025-34261": {"epss_score": 0.00033, "epss_percentile": 0.0942}, "CVE-2025-34262": {"epss_score": 0.00033, "epss_percentile": 0.0942}, "CVE-2025-34263": {"epss_score": 0.00033, "epss_percentile": 0.0942}, "CVE-2025-34264": {"epss_score": 0.00033, "epss_percentile": 0.0942}, "CVE-2025-34265": {"epss_score": 0.00033, "epss_percentile": 0.0942}, "CVE-2025-34266": {"epss_score": 0.00033, "epss_percentile": 0.0942}, "CVE-2025-34267": {"epss_score": 0.00536, "epss_percentile": 0.66859}, "CVE-2025-34270": {"epss_score": 0.00088, "epss_percentile": 0.25775}, "CVE-2025-34271": {"epss_score": 0.00661, "epss_percentile": 0.70583}, "CVE-2025-34272": {"epss_score": 0.01097, "epss_percentile": 0.77528}, "CVE-2025-34273": {"epss_score": 0.0022, "epss_percentile": 0.44581}, "CVE-2025-34274": {"epss_score": 0.00693, "epss_percentile": 0.71314}, "CVE-2025-34277": {"epss_score": 0.00242, "epss_percentile": 0.47393}, "CVE-2025-34278": {"epss_score": 0.00714, "epss_percentile": 0.71805}, "CVE-2025-34280": {"epss_score": 0.00463, "epss_percentile": 0.63663}, "CVE-2025-34281": {"epss_score": 0.00041, "epss_percentile": 0.12318}, "CVE-2025-34282": {"epss_score": 0.00039, "epss_percentile": 0.11766}, "CVE-2025-34283": {"epss_score": 0.01097, "epss_percentile": 0.77528}, "CVE-2025-34284": {"epss_score": 0.00594, "epss_percentile": 0.68659}, "CVE-2025-34286": {"epss_score": 0.00693, "epss_percentile": 0.71333}, "CVE-2025-34287": {"epss_score": 0.00012, "epss_percentile": 0.01299}, "CVE-2025-34288": {"epss_score": 0.0013, "epss_percentile": 0.33244}, "CVE-2025-34290": {"epss_score": 0.00015, "epss_percentile": 0.0241}, "CVE-2025-34291": {"epss_score": 0.03305, "epss_percentile": 0.86875}, "CVE-2025-34292": {"epss_score": 0.00554, "epss_percentile": 0.67439}, "CVE-2025-34293": {"epss_score": 0.00058, "epss_percentile": 0.1839}, "CVE-2025-34297": {"epss_score": 0.00018, "epss_percentile": 0.04049}, "CVE-2025-34298": {"epss_score": 0.00076, "epss_percentile": 0.23154}, "CVE-2025-34299": {"epss_score": 0.67725, "epss_percentile": 0.98518}, "CVE-2025-34300": {"epss_score": 0.72595, "epss_percentile": 0.98718}, "CVE-2025-34301": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34302": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34303": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34304": {"epss_score": 0.00034, "epss_percentile": 0.09584}, "CVE-2025-34305": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34306": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34307": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34308": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34309": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34310": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34311": {"epss_score": 0.00596, "epss_percentile": 0.68722}, "CVE-2025-34312": {"epss_score": 0.00408, "epss_percentile": 0.60683}, "CVE-2025-34313": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34314": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34315": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34316": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34317": {"epss_score": 0.00036, "epss_percentile": 0.10432}, "CVE-2025-34318": {"epss_score": 0.00066, "epss_percentile": 0.20852}, "CVE-2025-34319": {"epss_score": 0.0329, "epss_percentile": 0.86835}, "CVE-2025-34320": {"epss_score": 0.00655, "epss_percentile": 0.70424}, "CVE-2025-34322": {"epss_score": 0.00371, "epss_percentile": 0.58345}, "CVE-2025-34323": {"epss_score": 0.00014, "epss_percentile": 0.02019}, "CVE-2025-34324": {"epss_score": 6e-05, "epss_percentile": 0.00295}, "CVE-2025-34328": {"epss_score": 0.00454, "epss_percentile": 0.63243}, "CVE-2025-34329": {"epss_score": 0.0259, "epss_percentile": 0.8518}, "CVE-2025-34330": {"epss_score": 0.00537, "epss_percentile": 0.66888}, "CVE-2025-34331": {"epss_score": 0.0008, "epss_percentile": 0.24058}, "CVE-2025-34332": {"epss_score": 0.00026, "epss_percentile": 0.06442}, "CVE-2025-34333": {"epss_score": 0.0003, "epss_percentile": 0.08165}, "CVE-2025-34334": {"epss_score": 0.00196, "epss_percentile": 0.41739}, "CVE-2025-34335": {"epss_score": 0.00524, "epss_percentile": 0.66316}, "CVE-2025-34336": {"epss_score": 0.00453, "epss_percentile": 0.63213}, "CVE-2025-34337": {"epss_score": 0.00107, "epss_percentile": 0.29666}, "CVE-2025-34350": {"epss_score": 0.00306, "epss_percentile": 0.53431}, "CVE-2025-34352": {"epss_score": 0.00023, "epss_percentile": 0.05628}, "CVE-2025-34392": {"epss_score": 0.00391, "epss_percentile": 0.59629}, "CVE-2025-34393": {"epss_score": 0.0044, "epss_percentile": 0.62622}, "CVE-2025-34394": {"epss_score": 0.0044, "epss_percentile": 0.62622}, "CVE-2025-34395": {"epss_score": 0.00129, "epss_percentile": 0.33164}, "CVE-2025-34396": {"epss_score": 5e-05, "epss_percentile": 0.00227}, "CVE-2025-34397": {"epss_score": 0.00014, "epss_percentile": 0.02065}, "CVE-2025-34398": {"epss_score": 0.00014, "epss_percentile": 0.02065}, "CVE-2025-34399": {"epss_score": 0.00014, "epss_percentile": 0.02065}, "CVE-2025-34400": {"epss_score": 0.00014, "epss_percentile": 0.02065}, "CVE-2025-34401": {"epss_score": 0.00014, "epss_percentile": 0.02065}, "CVE-2025-34402": {"epss_score": 0.00014, "epss_percentile": 0.02065}, "CVE-2025-34403": {"epss_score": 0.00014, "epss_percentile": 0.02065}, "CVE-2025-34404": {"epss_score": 0.00014, "epss_percentile": 0.02065}, "CVE-2025-34406": {"epss_score": 0.00014, "epss_percentile": 0.02065}, "CVE-2025-34407": {"epss_score": 0.00018, "epss_percentile": 0.03674}, "CVE-2025-34408": {"epss_score": 0.00018, "epss_percentile": 0.03674}, "CVE-2025-34409": {"epss_score": 0.00018, "epss_percentile": 0.03674}, "CVE-2025-34410": {"epss_score": 0.00028, "epss_percentile": 0.07481}, "CVE-2025-34413": {"epss_score": 0.00128, "epss_percentile": 0.33006}, "CVE-2025-34414": {"epss_score": 0.0141, "epss_percentile": 0.80078}, "CVE-2025-34416": {"epss_score": 7e-05, "epss_percentile": 0.00329}, "CVE-2025-34417": {"epss_score": 7e-05, "epss_percentile": 0.00329}, "CVE-2025-34418": {"epss_score": 7e-05, "epss_percentile": 0.00329}, "CVE-2025-34419": {"epss_score": 7e-05, "epss_percentile": 0.00329}, "CVE-2025-34420": {"epss_score": 7e-05, "epss_percentile": 0.00329}, "CVE-2025-34421": {"epss_score": 7e-05, "epss_percentile": 0.00329}, "CVE-2025-34422": {"epss_score": 7e-05, "epss_percentile": 0.00329}, "CVE-2025-34423": {"epss_score": 7e-05, "epss_percentile": 0.00329}, "CVE-2025-34424": {"epss_score": 7e-05, "epss_percentile": 0.00329}, "CVE-2025-34425": {"epss_score": 0.00018, "epss_percentile": 0.03674}, "CVE-2025-34427": {"epss_score": 2e-05, "epss_percentile": 0.00045}, "CVE-2025-34428": {"epss_score": 2e-05, "epss_percentile": 0.00045}, "CVE-2025-34429": {"epss_score": 0.00028, "epss_percentile": 0.07481}, "CVE-2025-34430": {"epss_score": 0.00026, "epss_percentile": 0.06484}, "CVE-2025-34433": {"epss_score": 0.00406, "epss_percentile": 0.60542}, "CVE-2025-34434": {"epss_score": 0.00152, "epss_percentile": 0.36449}, "CVE-2025-34435": {"epss_score": 0.00053, "epss_percentile": 0.16986}, "CVE-2025-34436": {"epss_score": 0.00103, "epss_percentile": 0.28984}, "CVE-2025-34437": {"epss_score": 0.00103, "epss_percentile": 0.28984}, "CVE-2025-34438": {"epss_score": 0.00024, "epss_percentile": 0.05684}, "CVE-2025-34439": {"epss_score": 0.00028, "epss_percentile": 0.0756}, "CVE-2025-34440": {"epss_score": 0.00028, "epss_percentile": 0.0756}, "CVE-2025-34441": {"epss_score": 0.0004, "epss_percentile": 0.12046}, "CVE-2025-34442": {"epss_score": 0.0004, "epss_percentile": 0.12046}, "CVE-2025-34449": {"epss_score": 0.00042, "epss_percentile": 0.12812}, "CVE-2025-34450": {"epss_score": 0.00016, "epss_percentile": 0.02966}, "CVE-2025-34451": {"epss_score": 0.00022, "epss_percentile": 0.05018}, "CVE-2025-34452": {"epss_score": 0.00422, "epss_percentile": 0.61562}, "CVE-2025-34457": {"epss_score": 0.00118, "epss_percentile": 0.31514}, "CVE-2025-34458": {"epss_score": 0.0013, "epss_percentile": 0.33227}, "CVE-2025-34467": {"epss_score": 0.00037, "epss_percentile": 0.10742}, "CVE-2025-34468": {"epss_score": 0.00331, "epss_percentile": 0.55542}, "CVE-2025-34469": {"epss_score": 0.00135, "epss_percentile": 0.3394}, "CVE-2025-34489": {"epss_score": 0.0004, "epss_percentile": 0.1207}, "CVE-2025-34490": {"epss_score": 0.00067, "epss_percentile": 0.21056}, "CVE-2025-34491": {"epss_score": 0.00374, "epss_percentile": 0.58558}, "CVE-2025-34499": {"epss_score": 0.00073, "epss_percentile": 0.22584}, "CVE-2025-34500": {"epss_score": 0.00011, "epss_percentile": 0.00996}, "CVE-2025-34501": {"epss_score": 0.00026, "epss_percentile": 0.06395}, "CVE-2025-34502": {"epss_score": 0.0005, "epss_percentile": 0.15928}, "CVE-2025-34503": {"epss_score": 0.0002, "epss_percentile": 0.04601}, "CVE-2025-34504": {"epss_score": 0.00204, "epss_percentile": 0.42665}, "CVE-2025-34506": {"epss_score": 0.00585, "epss_percentile": 0.68399}, "CVE-2025-34508": {"epss_score": 0.003, "epss_percentile": 0.5291}, "CVE-2025-34509": {"epss_score": 0.14459, "epss_percentile": 0.94217}, "CVE-2025-34510": {"epss_score": 0.80802, "epss_percentile": 0.99107}, "CVE-2025-34511": {"epss_score": 0.78652, "epss_percentile": 0.98995}, "CVE-2025-34512": {"epss_score": 0.00107, "epss_percentile": 0.29751}, "CVE-2025-34513": {"epss_score": 0.13129, "epss_percentile": 0.93881}, "CVE-2025-34514": {"epss_score": 0.00467, "epss_percentile": 0.63829}, "CVE-2025-34515": {"epss_score": 0.00091, "epss_percentile": 0.26279}, "CVE-2025-34516": {"epss_score": 0.00139, "epss_percentile": 0.34554}, "CVE-2025-34517": {"epss_score": 0.00079, "epss_percentile": 0.23839}, "CVE-2025-34518": {"epss_score": 0.00079, "epss_percentile": 0.23839}, "CVE-2025-34519": {"epss_score": 0.00018, "epss_percentile": 0.03753}, "CVE-2025-34520": {"epss_score": 0.00283, "epss_percentile": 0.514}, "CVE-2025-34521": {"epss_score": 0.00066, "epss_percentile": 0.20827}, "CVE-2025-34522": {"epss_score": 0.00668, "epss_percentile": 0.70743}, "CVE-2025-34523": {"epss_score": 0.00509, "epss_percentile": 0.6575}, "CVE-2025-35003": {"epss_score": 0.00152, "epss_percentile": 0.365}, "CVE-2025-35004": {"epss_score": 0.0007, "epss_percentile": 0.21781}, "CVE-2025-35005": {"epss_score": 0.0007, "epss_percentile": 0.21781}, "CVE-2025-35006": {"epss_score": 0.0007, "epss_percentile": 0.21781}, "CVE-2025-35007": {"epss_score": 0.0007, "epss_percentile": 0.21781}, "CVE-2025-35008": {"epss_score": 0.0007, "epss_percentile": 0.21781}, "CVE-2025-35009": {"epss_score": 0.0007, "epss_percentile": 0.21781}, "CVE-2025-35010": {"epss_score": 0.0007, "epss_percentile": 0.21781}, "CVE-2025-35021": {"epss_score": 0.00039, "epss_percentile": 0.1162}, "CVE-2025-35027": {"epss_score": 0.0104, "epss_percentile": 0.7696}, "CVE-2025-35028": {"epss_score": 0.00047, "epss_percentile": 0.14498}, "CVE-2025-35029": {"epss_score": 0.00031, "epss_percentile": 0.08707}, "CVE-2025-35030": {"epss_score": 0.00038, "epss_percentile": 0.11229}, "CVE-2025-35031": {"epss_score": 0.00016, "epss_percentile": 0.02866}, "CVE-2025-35032": {"epss_score": 0.00039, "epss_percentile": 0.11671}, "CVE-2025-35033": {"epss_score": 0.00057, "epss_percentile": 0.18216}, "CVE-2025-35034": {"epss_score": 0.00081, "epss_percentile": 0.24223}, "CVE-2025-35036": {"epss_score": 0.00273, "epss_percentile": 0.50466}, "CVE-2025-35041": {"epss_score": 0.00154, "epss_percentile": 0.3675}, "CVE-2025-35042": {"epss_score": 0.00164, "epss_percentile": 0.37968}, "CVE-2025-35050": {"epss_score": 0.00427, "epss_percentile": 0.61779}, "CVE-2025-35051": {"epss_score": 0.00413, "epss_percentile": 0.61014}, "CVE-2025-35052": {"epss_score": 0.00059, "epss_percentile": 0.1882}, "CVE-2025-35053": {"epss_score": 0.00056, "epss_percentile": 0.1767}, "CVE-2025-35054": {"epss_score": 0.00011, "epss_percentile": 0.00943}, "CVE-2025-35055": {"epss_score": 0.00241, "epss_percentile": 0.47293}, "CVE-2025-35056": {"epss_score": 0.00064, "epss_percentile": 0.20111}, "CVE-2025-35057": {"epss_score": 0.00048, "epss_percentile": 0.14989}, "CVE-2025-35058": {"epss_score": 0.00054, "epss_percentile": 0.17071}, "CVE-2025-35059": {"epss_score": 0.0002, "epss_percentile": 0.04655}, "CVE-2025-35060": {"epss_score": 0.00053, "epss_percentile": 0.16938}, "CVE-2025-35061": {"epss_score": 0.00054, "epss_percentile": 0.17071}, "CVE-2025-35062": {"epss_score": 0.00133, "epss_percentile": 0.33727}, "CVE-2025-35112": {"epss_score": 0.00058, "epss_percentile": 0.1847}, "CVE-2025-35113": {"epss_score": 0.00286, "epss_percentile": 0.51747}, "CVE-2025-35114": {"epss_score": 0.00058, "epss_percentile": 0.18281}, "CVE-2025-35115": {"epss_score": 0.0004, "epss_percentile": 0.1187}, "CVE-2025-35430": {"epss_score": 0.00055, "epss_percentile": 0.17448}, "CVE-2025-35431": {"epss_score": 0.00064, "epss_percentile": 0.20381}, "CVE-2025-35432": {"epss_score": 0.00152, "epss_percentile": 0.36435}, "CVE-2025-35433": {"epss_score": 0.00063, "epss_percentile": 0.19939}, "CVE-2025-35434": {"epss_score": 0.00037, "epss_percentile": 0.1077}, "CVE-2025-35435": {"epss_score": 0.00141, "epss_percentile": 0.34943}, "CVE-2025-35436": {"epss_score": 0.00136, "epss_percentile": 0.34122}, "CVE-2025-35451": {"epss_score": 0.00056, "epss_percentile": 0.17796}, "CVE-2025-35452": {"epss_score": 0.00079, "epss_percentile": 0.23902}, "CVE-2025-35471": {"epss_score": 0.00014, "epss_percentile": 0.01897}, "CVE-2025-35939": {"epss_score": 0.16709, "epss_percentile": 0.94719}, "CVE-2025-35940": {"epss_score": 0.00099, "epss_percentile": 0.28365}, "CVE-2025-35941": {"epss_score": 0.00017, "epss_percentile": 0.03402}, "CVE-2025-35963": {"epss_score": 0.00028, "epss_percentile": 0.07224}, "CVE-2025-35965": {"epss_score": 0.00099, "epss_percentile": 0.27835}, "CVE-2025-35966": {"epss_score": 0.00139, "epss_percentile": 0.3466}, "CVE-2025-35967": {"epss_score": 0.0002, "epss_percentile": 0.0466}, "CVE-2025-35968": {"epss_score": 0.0003, "epss_percentile": 0.08059}, "CVE-2025-35970": {"epss_score": 0.00046, "epss_percentile": 0.14432}, "CVE-2025-35971": {"epss_score": 0.00035, "epss_percentile": 0.10016}, "CVE-2025-35972": {"epss_score": 0.00015, "epss_percentile": 0.02136}, "CVE-2025-35975": {"epss_score": 0.00088, "epss_percentile": 0.25729}, "CVE-2025-35978": {"epss_score": 0.00013, "epss_percentile": 0.01579}, "CVE-2025-35981": {"epss_score": 0.00015, "epss_percentile": 0.02415}, "CVE-2025-35983": {"epss_score": 0.00035, "epss_percentile": 0.0988}, "CVE-2025-35984": {"epss_score": 0.00318, "epss_percentile": 0.5444}, "CVE-2025-35995": {"epss_score": 0.00087, "epss_percentile": 0.25629}, "CVE-2025-35996": {"epss_score": 0.00077, "epss_percentile": 0.23453}, "CVE-2025-36000": {"epss_score": 0.00016, "epss_percentile": 0.02694}, "CVE-2025-36002": {"epss_score": 0.00015, "epss_percentile": 0.02508}, "CVE-2025-36003": {"epss_score": 0.00066, "epss_percentile": 0.2074}, "CVE-2025-36004": {"epss_score": 0.00043, "epss_percentile": 0.13132}, "CVE-2025-36005": {"epss_score": 0.00018, "epss_percentile": 0.03834}, "CVE-2025-36006": {"epss_score": 0.00054, "epss_percentile": 0.17152}, "CVE-2025-36007": {"epss_score": 0.00018, "epss_percentile": 0.03676}, "CVE-2025-36008": {"epss_score": 0.00054, "epss_percentile": 0.17081}, "CVE-2025-36010": {"epss_score": 0.00056, "epss_percentile": 0.17789}, "CVE-2025-36011": {"epss_score": 0.00015, "epss_percentile": 0.02364}, "CVE-2025-36014": {"epss_score": 0.00015, "epss_percentile": 0.02171}, "CVE-2025-36015": {"epss_score": 0.00053, "epss_percentile": 0.16935}, "CVE-2025-36016": {"epss_score": 0.00029, "epss_percentile": 0.07661}, "CVE-2025-36017": {"epss_score": 0.00032, "epss_percentile": 0.09111}, "CVE-2025-36020": {"epss_score": 0.00016, "epss_percentile": 0.02621}, "CVE-2025-36023": {"epss_score": 0.00027, "epss_percentile": 0.06739}, "CVE-2025-36026": {"epss_score": 0.00013, "epss_percentile": 0.01494}, "CVE-2025-36027": {"epss_score": 0.00025, "epss_percentile": 0.06242}, "CVE-2025-36034": {"epss_score": 0.00012, "epss_percentile": 0.01293}, "CVE-2025-36035": {"epss_score": 0.00017, "epss_percentile": 0.03227}, "CVE-2025-36037": {"epss_score": 0.00036, "epss_percentile": 0.10214}, "CVE-2025-36038": {"epss_score": 0.00131, "epss_percentile": 0.3336}, "CVE-2025-36039": {"epss_score": 0.00031, "epss_percentile": 0.0851}, "CVE-2025-36040": {"epss_score": 0.00029, "epss_percentile": 0.07932}, "CVE-2025-36041": {"epss_score": 7e-05, "epss_percentile": 0.00339}, "CVE-2025-36042": {"epss_score": 0.00049, "epss_percentile": 0.15434}, "CVE-2025-36047": {"epss_score": 0.00203, "epss_percentile": 0.42535}, "CVE-2025-36048": {"epss_score": 0.00066, "epss_percentile": 0.20687}, "CVE-2025-36049": {"epss_score": 0.00072, "epss_percentile": 0.22377}, "CVE-2025-36050": {"epss_score": 0.00012, "epss_percentile": 0.01227}, "CVE-2025-36054": {"epss_score": 0.00084, "epss_percentile": 0.24965}, "CVE-2025-36056": {"epss_score": 0.00019, "epss_percentile": 0.04356}, "CVE-2025-36057": {"epss_score": 0.00014, "epss_percentile": 0.01803}, "CVE-2025-36062": {"epss_score": 0.00014, "epss_percentile": 0.02051}, "CVE-2025-36064": {"epss_score": 0.00058, "epss_percentile": 0.18418}, "CVE-2025-36071": {"epss_score": 0.0007, "epss_percentile": 0.21837}, "CVE-2025-36072": {"epss_score": 0.00403, "epss_percentile": 0.60375}, "CVE-2025-36081": {"epss_score": 0.00041, "epss_percentile": 0.12293}, "CVE-2025-36082": {"epss_score": 0.00016, "epss_percentile": 0.02734}, "CVE-2025-36083": {"epss_score": 0.00016, "epss_percentile": 0.0295}, "CVE-2025-36085": {"epss_score": 0.00036, "epss_percentile": 0.10214}, "CVE-2025-36087": {"epss_score": 0.0005, "epss_percentile": 0.15843}, "CVE-2025-36088": {"epss_score": 0.00049, "epss_percentile": 0.15434}, "CVE-2025-36090": {"epss_score": 0.00039, "epss_percentile": 0.11715}, "CVE-2025-36091": {"epss_score": 0.00048, "epss_percentile": 0.15202}, "CVE-2025-36092": {"epss_score": 0.00061, "epss_percentile": 0.19487}, "CVE-2025-36093": {"epss_score": 0.00044, "epss_percentile": 0.1353}, "CVE-2025-36096": {"epss_score": 0.00064, "epss_percentile": 0.20129}, "CVE-2025-36097": {"epss_score": 0.00071, "epss_percentile": 0.22069}, "CVE-2025-36099": {"epss_score": 0.00056, "epss_percentile": 0.17909}, "CVE-2025-36100": {"epss_score": 0.00021, "epss_percentile": 0.04729}, "CVE-2025-36102": {"epss_score": 0.00043, "epss_percentile": 0.13008}, "CVE-2025-36104": {"epss_score": 0.00029, "epss_percentile": 0.0783}, "CVE-2025-36106": {"epss_score": 0.00014, "epss_percentile": 0.02051}, "CVE-2025-36107": {"epss_score": 0.00014, "epss_percentile": 0.02051}, "CVE-2025-36112": {"epss_score": 0.00037, "epss_percentile": 0.10935}, "CVE-2025-36114": {"epss_score": 0.0009, "epss_percentile": 0.26126}, "CVE-2025-36116": {"epss_score": 0.00027, "epss_percentile": 0.07085}, "CVE-2025-36117": {"epss_score": 0.00034, "epss_percentile": 0.09757}, "CVE-2025-36118": {"epss_score": 0.00054, "epss_percentile": 0.17244}, "CVE-2025-36119": {"epss_score": 0.00017, "epss_percentile": 0.0338}, "CVE-2025-36120": {"epss_score": 0.0008, "epss_percentile": 0.24029}, "CVE-2025-36121": {"epss_score": 0.00036, "epss_percentile": 0.10379}, "CVE-2025-36124": {"epss_score": 0.00032, "epss_percentile": 0.0911}, "CVE-2025-36125": {"epss_score": 0.00036, "epss_percentile": 0.1062}, "CVE-2025-36128": {"epss_score": 0.00143, "epss_percentile": 0.35153}, "CVE-2025-36131": {"epss_score": 0.0002, "epss_percentile": 0.04524}, "CVE-2025-36132": {"epss_score": 0.00036, "epss_percentile": 0.1062}, "CVE-2025-36133": {"epss_score": 0.0002, "epss_percentile": 0.04597}, "CVE-2025-36134": {"epss_score": 0.00041, "epss_percentile": 0.12311}, "CVE-2025-36135": {"epss_score": 0.00031, "epss_percentile": 0.08708}, "CVE-2025-36136": {"epss_score": 0.00017, "epss_percentile": 0.03092}, "CVE-2025-36137": {"epss_score": 0.00051, "epss_percentile": 0.15982}, "CVE-2025-36138": {"epss_score": 0.00036, "epss_percentile": 0.1062}, "CVE-2025-36139": {"epss_score": 0.00034, "epss_percentile": 0.09529}, "CVE-2025-36140": {"epss_score": 0.00047, "epss_percentile": 0.1449}, "CVE-2025-36143": {"epss_score": 0.00048, "epss_percentile": 0.15137}, "CVE-2025-36144": {"epss_score": 0.00016, "epss_percentile": 0.02748}, "CVE-2025-36146": {"epss_score": 0.00039, "epss_percentile": 0.11466}, "CVE-2025-36149": {"epss_score": 0.00036, "epss_percentile": 0.10391}, "CVE-2025-36150": {"epss_score": 0.00018, "epss_percentile": 0.03629}, "CVE-2025-36153": {"epss_score": 0.00084, "epss_percentile": 0.24965}, "CVE-2025-36154": {"epss_score": 6e-05, "epss_percentile": 0.00314}, "CVE-2025-36156": {"epss_score": 0.0002, "epss_percentile": 0.04607}, "CVE-2025-36157": {"epss_score": 0.00133, "epss_percentile": 0.33693}, "CVE-2025-36158": {"epss_score": 0.00014, "epss_percentile": 0.02072}, "CVE-2025-36159": {"epss_score": 0.00014, "epss_percentile": 0.02045}, "CVE-2025-36160": {"epss_score": 0.0004, "epss_percentile": 0.12}, "CVE-2025-36161": {"epss_score": 0.00019, "epss_percentile": 0.04391}, "CVE-2025-36162": {"epss_score": 0.00047, "epss_percentile": 0.14786}, "CVE-2025-36170": {"epss_score": 0.00036, "epss_percentile": 0.1062}, "CVE-2025-36171": {"epss_score": 0.00058, "epss_percentile": 0.1826}, "CVE-2025-36172": {"epss_score": 0.00031, "epss_percentile": 0.08708}, "CVE-2025-36174": {"epss_score": 0.00079, "epss_percentile": 0.23941}, "CVE-2025-36185": {"epss_score": 0.00026, "epss_percentile": 0.06424}, "CVE-2025-36186": {"epss_score": 0.00017, "epss_percentile": 0.03502}, "CVE-2025-36192": {"epss_score": 0.00017, "epss_percentile": 0.03274}, "CVE-2025-36193": {"epss_score": 0.00022, "epss_percentile": 0.05263}, "CVE-2025-36202": {"epss_score": 0.0006, "epss_percentile": 0.19212}, "CVE-2025-36222": {"epss_score": 0.00066, "epss_percentile": 0.20959}, "CVE-2025-36223": {"epss_score": 0.0003, "epss_percentile": 0.08161}, "CVE-2025-36225": {"epss_score": 0.00039, "epss_percentile": 0.11466}, "CVE-2025-36228": {"epss_score": 0.00024, "epss_percentile": 0.05736}, "CVE-2025-36229": {"epss_score": 0.00029, "epss_percentile": 0.07748}, "CVE-2025-36230": {"epss_score": 0.00033, "epss_percentile": 0.09166}, "CVE-2025-36236": {"epss_score": 0.00094, "epss_percentile": 0.2679}, "CVE-2025-36239": {"epss_score": 0.00097, "epss_percentile": 0.27581}, "CVE-2025-36244": {"epss_score": 0.00019, "epss_percentile": 0.04088}, "CVE-2025-36245": {"epss_score": 0.00058, "epss_percentile": 0.18486}, "CVE-2025-36248": {"epss_score": 0.00097, "epss_percentile": 0.27581}, "CVE-2025-36249": {"epss_score": 0.00016, "epss_percentile": 0.03041}, "CVE-2025-36250": {"epss_score": 0.00111, "epss_percentile": 0.30323}, "CVE-2025-36251": {"epss_score": 0.00084, "epss_percentile": 0.24857}, "CVE-2025-36262": {"epss_score": 0.00073, "epss_percentile": 0.22507}, "CVE-2025-36274": {"epss_score": 0.00031, "epss_percentile": 0.08696}, "CVE-2025-36299": {"epss_score": 0.00033, "epss_percentile": 0.09371}, "CVE-2025-36326": {"epss_score": 0.00043, "epss_percentile": 0.13023}, "CVE-2025-36351": {"epss_score": 0.00066, "epss_percentile": 0.20818}, "CVE-2025-36352": {"epss_score": 0.00036, "epss_percentile": 0.1062}, "CVE-2025-36354": {"epss_score": 0.00102, "epss_percentile": 0.28722}, "CVE-2025-36355": {"epss_score": 0.0002, "epss_percentile": 0.04497}, "CVE-2025-36356": {"epss_score": 0.00022, "epss_percentile": 0.0527}, "CVE-2025-36357": {"epss_score": 0.00034, "epss_percentile": 0.09657}, "CVE-2025-36360": {"epss_score": 0.00048, "epss_percentile": 0.14972}, "CVE-2025-36361": {"epss_score": 0.00059, "epss_percentile": 0.18673}, "CVE-2025-36367": {"epss_score": 0.00062, "epss_percentile": 0.19574}, "CVE-2025-36371": {"epss_score": 0.00037, "epss_percentile": 0.10977}, "CVE-2025-36386": {"epss_score": 0.00312, "epss_percentile": 0.54008}, "CVE-2025-36437": {"epss_score": 0.00027, "epss_percentile": 0.07155}, "CVE-2025-36460": {"epss_score": 0.00018, "epss_percentile": 0.03701}, "CVE-2025-36461": {"epss_score": 0.00018, "epss_percentile": 0.03701}, "CVE-2025-36462": {"epss_score": 0.00018, "epss_percentile": 0.03701}, "CVE-2025-36463": {"epss_score": 0.00018, "epss_percentile": 0.03701}, "CVE-2025-36504": {"epss_score": 0.00087, "epss_percentile": 0.25629}, "CVE-2025-36506": {"epss_score": 0.00046, "epss_percentile": 0.14162}, "CVE-2025-36512": {"epss_score": 0.00055, "epss_percentile": 0.17501}, "CVE-2025-36513": {"epss_score": 0.00017, "epss_percentile": 0.03155}, "CVE-2025-36519": {"epss_score": 0.00042, "epss_percentile": 0.12616}, "CVE-2025-36520": {"epss_score": 0.00152, "epss_percentile": 0.36427}, "CVE-2025-36521": {"epss_score": 0.00049, "epss_percentile": 0.15644}, "CVE-2025-36525": {"epss_score": 0.00087, "epss_percentile": 0.25629}, "CVE-2025-36527": {"epss_score": 0.00171, "epss_percentile": 0.38895}, "CVE-2025-36528": {"epss_score": 0.00167, "epss_percentile": 0.38291}, "CVE-2025-36529": {"epss_score": 0.00158, "epss_percentile": 0.37173}, "CVE-2025-36530": {"epss_score": 0.00068, "epss_percentile": 0.21418}, "CVE-2025-36535": {"epss_score": 0.00143, "epss_percentile": 0.35223}, "CVE-2025-36537": {"epss_score": 0.00012, "epss_percentile": 0.0141}, "CVE-2025-36539": {"epss_score": 0.00046, "epss_percentile": 0.14113}, "CVE-2025-36546": {"epss_score": 0.00068, "epss_percentile": 0.21349}, "CVE-2025-36548": {"epss_score": 0.00126, "epss_percentile": 0.32757}, "CVE-2025-36553": {"epss_score": 0.00018, "epss_percentile": 0.03653}, "CVE-2025-36557": {"epss_score": 0.00087, "epss_percentile": 0.25629}, "CVE-2025-36558": {"epss_score": 0.00034, "epss_percentile": 0.09754}, "CVE-2025-36560": {"epss_score": 0.00081, "epss_percentile": 0.24236}, "CVE-2025-36563": {"epss_score": 0.00025, "epss_percentile": 0.06154}, "CVE-2025-36564": {"epss_score": 0.00023, "epss_percentile": 0.0547}, "CVE-2025-36565": {"epss_score": 0.00022, "epss_percentile": 0.05319}, "CVE-2025-36566": {"epss_score": 0.0003, "epss_percentile": 0.0824}, "CVE-2025-36567": {"epss_score": 0.0003, "epss_percentile": 0.0824}, "CVE-2025-36569": {"epss_score": 0.00024, "epss_percentile": 0.05894}, "CVE-2025-36572": {"epss_score": 0.00051, "epss_percentile": 0.16327}, "CVE-2025-36573": {"epss_score": 0.00017, "epss_percentile": 0.03212}, "CVE-2025-36574": {"epss_score": 0.00713, "epss_percentile": 0.71797}, "CVE-2025-36575": {"epss_score": 0.00114, "epss_percentile": 0.30866}, "CVE-2025-36576": {"epss_score": 0.00026, "epss_percentile": 0.06524}, "CVE-2025-36577": {"epss_score": 0.00028, "epss_percentile": 0.07559}, "CVE-2025-36578": {"epss_score": 0.00041, "epss_percentile": 0.12237}, "CVE-2025-36580": {"epss_score": 0.00027, "epss_percentile": 0.06935}, "CVE-2025-36581": {"epss_score": 0.00021, "epss_percentile": 0.04906}, "CVE-2025-36582": {"epss_score": 0.00069, "epss_percentile": 0.21486}, "CVE-2025-36589": {"epss_score": 0.00067, "epss_percentile": 0.20973}, "CVE-2025-36592": {"epss_score": 0.00107, "epss_percentile": 0.29609}, "CVE-2025-36593": {"epss_score": 0.0003, "epss_percentile": 0.08274}, "CVE-2025-36594": {"epss_score": 0.00216, "epss_percentile": 0.44172}, "CVE-2025-36595": {"epss_score": 0.00084, "epss_percentile": 0.24917}, "CVE-2025-36599": {"epss_score": 0.00037, "epss_percentile": 0.10725}, "CVE-2025-36600": {"epss_score": 0.00015, "epss_percentile": 0.02196}, "CVE-2025-36601": {"epss_score": 0.00054, "epss_percentile": 0.1727}, "CVE-2025-36603": {"epss_score": 0.0001, "epss_percentile": 0.0087}, "CVE-2025-36604": {"epss_score": 0.12865, "epss_percentile": 0.93804}, "CVE-2025-36605": {"epss_score": 0.0009, "epss_percentile": 0.2615}, "CVE-2025-36606": {"epss_score": 0.00028, "epss_percentile": 0.07252}, "CVE-2025-36607": {"epss_score": 0.00028, "epss_percentile": 0.07252}, "CVE-2025-36608": {"epss_score": 0.0005, "epss_percentile": 0.15822}, "CVE-2025-36609": {"epss_score": 0.0001, "epss_percentile": 0.008}, "CVE-2025-36611": {"epss_score": 0.00015, "epss_percentile": 0.02414}, "CVE-2025-36612": {"epss_score": 0.00023, "epss_percentile": 0.05431}, "CVE-2025-36613": {"epss_score": 0.00024, "epss_percentile": 0.05961}, "CVE-2025-36625": {"epss_score": 0.00075, "epss_percentile": 0.23041}, "CVE-2025-36630": {"epss_score": 0.00017, "epss_percentile": 0.03245}, "CVE-2025-36631": {"epss_score": 0.00019, "epss_percentile": 0.04281}, "CVE-2025-36632": {"epss_score": 0.00016, "epss_percentile": 0.02909}, "CVE-2025-36633": {"epss_score": 0.00012, "epss_percentile": 0.01388}, "CVE-2025-36636": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-36727": {"epss_score": 0.00042, "epss_percentile": 0.12711}, "CVE-2025-36728": {"epss_score": 0.00018, "epss_percentile": 0.03834}, "CVE-2025-36729": {"epss_score": 0.00057, "epss_percentile": 0.18089}, "CVE-2025-36730": {"epss_score": 0.00033, "epss_percentile": 0.09324}, "CVE-2025-36743": {"epss_score": 0.00026, "epss_percentile": 0.06408}, "CVE-2025-36744": {"epss_score": 0.00018, "epss_percentile": 0.03889}, "CVE-2025-36745": {"epss_score": 0.00313, "epss_percentile": 0.54059}, "CVE-2025-36746": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-36747": {"epss_score": 0.00022, "epss_percentile": 0.05195}, "CVE-2025-36748": {"epss_score": 0.00052, "epss_percentile": 0.16586}, "CVE-2025-36750": {"epss_score": 0.00052, "epss_percentile": 0.16586}, "CVE-2025-36751": {"epss_score": 6e-05, "epss_percentile": 0.00257}, "CVE-2025-36752": {"epss_score": 0.00022, "epss_percentile": 0.05195}, "CVE-2025-36753": {"epss_score": 0.00023, "epss_percentile": 0.0565}, "CVE-2025-36754": {"epss_score": 0.00019, "epss_percentile": 0.04254}, "CVE-2025-36755": {"epss_score": 0.00023, "epss_percentile": 0.0565}, "CVE-2025-36756": {"epss_score": 0.00058, "epss_percentile": 0.18279}, "CVE-2025-36757": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-36758": {"epss_score": 0.00126, "epss_percentile": 0.32646}, "CVE-2025-36759": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-36845": {"epss_score": 0.00059, "epss_percentile": 0.18849}, "CVE-2025-36846": {"epss_score": 0.60109, "epss_percentile": 0.98192}, "CVE-2025-36852": {"epss_score": 0.00044, "epss_percentile": 0.1342}, "CVE-2025-36853": {"epss_score": 0.00195, "epss_percentile": 0.41644}, "CVE-2025-36854": {"epss_score": 0.00208, "epss_percentile": 0.43222}, "CVE-2025-36855": {"epss_score": 0.00189, "epss_percentile": 0.40959}, "CVE-2025-36857": {"epss_score": 0.00017, "epss_percentile": 0.03234}, "CVE-2025-36887": {"epss_score": 0.0001, "epss_percentile": 0.00764}, "CVE-2025-36889": {"epss_score": 5e-05, "epss_percentile": 0.0019}, "CVE-2025-36890": {"epss_score": 0.00037, "epss_percentile": 0.10834}, "CVE-2025-36891": {"epss_score": 0.00035, "epss_percentile": 0.09916}, "CVE-2025-36892": {"epss_score": 0.00062, "epss_percentile": 0.19767}, "CVE-2025-36893": {"epss_score": 8e-05, "epss_percentile": 0.00541}, "CVE-2025-36894": {"epss_score": 0.00249, "epss_percentile": 0.48072}, "CVE-2025-36895": {"epss_score": 0.00026, "epss_percentile": 0.06565}, "CVE-2025-36896": {"epss_score": 0.00037, "epss_percentile": 0.10834}, "CVE-2025-36897": {"epss_score": 0.00241, "epss_percentile": 0.47324}, "CVE-2025-36898": {"epss_score": 0.00013, "epss_percentile": 0.01437}, "CVE-2025-36899": {"epss_score": 0.00011, "epss_percentile": 0.00943}, "CVE-2025-36900": {"epss_score": 0.0001, "epss_percentile": 0.00786}, "CVE-2025-36901": {"epss_score": 0.00019, "epss_percentile": 0.04201}, "CVE-2025-36902": {"epss_score": 0.0001, "epss_percentile": 0.00786}, "CVE-2025-36903": {"epss_score": 0.0001, "epss_percentile": 0.00764}, "CVE-2025-36904": {"epss_score": 0.00037, "epss_percentile": 0.10834}, "CVE-2025-36905": {"epss_score": 0.00013, "epss_percentile": 0.01437}, "CVE-2025-36906": {"epss_score": 0.0001, "epss_percentile": 0.00764}, "CVE-2025-36907": {"epss_score": 0.0001, "epss_percentile": 0.00764}, "CVE-2025-36908": {"epss_score": 0.0001, "epss_percentile": 0.00786}, "CVE-2025-36909": {"epss_score": 0.00024, "epss_percentile": 0.05789}, "CVE-2025-36912": {"epss_score": 0.00118, "epss_percentile": 0.31414}, "CVE-2025-36916": {"epss_score": 5e-05, "epss_percentile": 0.00219}, "CVE-2025-36917": {"epss_score": 0.00118, "epss_percentile": 0.31414}, "CVE-2025-36918": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-36919": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-36921": {"epss_score": 5e-05, "epss_percentile": 0.00228}, "CVE-2025-36922": {"epss_score": 7e-05, "epss_percentile": 0.0035}, "CVE-2025-36923": {"epss_score": 0.00011, "epss_percentile": 0.01039}, "CVE-2025-36924": {"epss_score": 0.00011, "epss_percentile": 0.01039}, "CVE-2025-36925": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-36927": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-36928": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-36929": {"epss_score": 8e-05, "epss_percentile": 0.00477}, "CVE-2025-36930": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-36931": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-36932": {"epss_score": 9e-05, "epss_percentile": 0.00597}, "CVE-2025-36934": {"epss_score": 6e-05, "epss_percentile": 0.00298}, "CVE-2025-36935": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-36936": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-36937": {"epss_score": 0.00164, "epss_percentile": 0.37907}, "CVE-2025-36938": {"epss_score": 0.00012, "epss_percentile": 0.01418}, "CVE-2025-37087": {"epss_score": 0.00086, "epss_percentile": 0.25327}, "CVE-2025-37088": {"epss_score": 0.00026, "epss_percentile": 0.06577}, "CVE-2025-37089": {"epss_score": 0.00317, "epss_percentile": 0.54369}, "CVE-2025-37090": {"epss_score": 0.00067, "epss_percentile": 0.21155}, "CVE-2025-37091": {"epss_score": 0.00317, "epss_percentile": 0.54369}, "CVE-2025-37092": {"epss_score": 0.00317, "epss_percentile": 0.54369}, "CVE-2025-37093": {"epss_score": 0.0007, "epss_percentile": 0.21834}, "CVE-2025-37094": {"epss_score": 0.00716, "epss_percentile": 0.71868}, "CVE-2025-37095": {"epss_score": 0.00221, "epss_percentile": 0.4468}, "CVE-2025-37096": {"epss_score": 0.00317, "epss_percentile": 0.54369}, "CVE-2025-37097": {"epss_score": 0.00147, "epss_percentile": 0.35675}, "CVE-2025-37098": {"epss_score": 0.00104, "epss_percentile": 0.29215}, "CVE-2025-37099": {"epss_score": 0.00204, "epss_percentile": 0.42615}, "CVE-2025-37100": {"epss_score": 0.00056, "epss_percentile": 0.17681}, "CVE-2025-37101": {"epss_score": 0.00038, "epss_percentile": 0.11222}, "CVE-2025-37102": {"epss_score": 0.00143, "epss_percentile": 0.3512}, "CVE-2025-37103": {"epss_score": 0.00213, "epss_percentile": 0.43839}, "CVE-2025-37104": {"epss_score": 0.0002, "epss_percentile": 0.04471}, "CVE-2025-37105": {"epss_score": 0.00146, "epss_percentile": 0.35532}, "CVE-2025-37106": {"epss_score": 0.00058, "epss_percentile": 0.18567}, "CVE-2025-37107": {"epss_score": 0.00058, "epss_percentile": 0.18567}, "CVE-2025-37108": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-37109": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-37110": {"epss_score": 0.00015, "epss_percentile": 0.02585}, "CVE-2025-37111": {"epss_score": 0.00015, "epss_percentile": 0.02537}, "CVE-2025-37112": {"epss_score": 0.0001, "epss_percentile": 0.00816}, "CVE-2025-37122": {"epss_score": 0.00054, "epss_percentile": 0.17303}, "CVE-2025-37123": {"epss_score": 0.00237, "epss_percentile": 0.46661}, "CVE-2025-37124": {"epss_score": 0.00087, "epss_percentile": 0.25603}, "CVE-2025-37125": {"epss_score": 0.00047, "epss_percentile": 0.14844}, "CVE-2025-37126": {"epss_score": 0.0016, "epss_percentile": 0.37506}, "CVE-2025-37127": {"epss_score": 0.00014, "epss_percentile": 0.01874}, "CVE-2025-37128": {"epss_score": 0.00112, "epss_percentile": 0.30448}, "CVE-2025-37129": {"epss_score": 0.00022, "epss_percentile": 0.05319}, "CVE-2025-37130": {"epss_score": 0.00046, "epss_percentile": 0.14136}, "CVE-2025-37131": {"epss_score": 0.00039, "epss_percentile": 0.11587}, "CVE-2025-37132": {"epss_score": 0.00065, "epss_percentile": 0.20585}, "CVE-2025-37133": {"epss_score": 0.00091, "epss_percentile": 0.26246}, "CVE-2025-37134": {"epss_score": 0.00091, "epss_percentile": 0.26246}, "CVE-2025-37135": {"epss_score": 0.00086, "epss_percentile": 0.25401}, "CVE-2025-37136": {"epss_score": 0.00086, "epss_percentile": 0.25401}, "CVE-2025-37137": {"epss_score": 0.00086, "epss_percentile": 0.25401}, "CVE-2025-37138": {"epss_score": 0.00035, "epss_percentile": 0.10122}, "CVE-2025-37139": {"epss_score": 0.00018, "epss_percentile": 0.0365}, "CVE-2025-37140": {"epss_score": 0.00041, "epss_percentile": 0.12338}, "CVE-2025-37141": {"epss_score": 0.00041, "epss_percentile": 0.12338}, "CVE-2025-37142": {"epss_score": 0.00041, "epss_percentile": 0.12338}, "CVE-2025-37143": {"epss_score": 0.00041, "epss_percentile": 0.12338}, "CVE-2025-37144": {"epss_score": 0.00059, "epss_percentile": 0.18672}, "CVE-2025-37145": {"epss_score": 0.00059, "epss_percentile": 0.18672}, "CVE-2025-37146": {"epss_score": 0.00216, "epss_percentile": 0.44197}, "CVE-2025-37147": {"epss_score": 0.00018, "epss_percentile": 0.03757}, "CVE-2025-37148": {"epss_score": 0.00115, "epss_percentile": 0.30904}, "CVE-2025-37149": {"epss_score": 0.00017, "epss_percentile": 0.03302}, "CVE-2025-37155": {"epss_score": 0.00015, "epss_percentile": 0.02541}, "CVE-2025-37156": {"epss_score": 0.00055, "epss_percentile": 0.17579}, "CVE-2025-37157": {"epss_score": 0.00102, "epss_percentile": 0.28874}, "CVE-2025-37158": {"epss_score": 0.00102, "epss_percentile": 0.28874}, "CVE-2025-37159": {"epss_score": 0.00039, "epss_percentile": 0.11632}, "CVE-2025-37160": {"epss_score": 0.00047, "epss_percentile": 0.14796}, "CVE-2025-37161": {"epss_score": 0.00117, "epss_percentile": 0.31337}, "CVE-2025-37162": {"epss_score": 0.00082, "epss_percentile": 0.24501}, "CVE-2025-37163": {"epss_score": 0.00144, "epss_percentile": 0.35254}, "CVE-2025-37164": {"epss_score": 0.84246, "epss_percentile": 0.9928}, "CVE-2025-37727": {"epss_score": 0.00037, "epss_percentile": 0.10679}, "CVE-2025-37728": {"epss_score": 0.00034, "epss_percentile": 0.09685}, "CVE-2025-37729": {"epss_score": 0.00068, "epss_percentile": 0.21254}, "CVE-2025-37730": {"epss_score": 0.00019, "epss_percentile": 0.04075}, "CVE-2025-37731": {"epss_score": 0.00036, "epss_percentile": 0.1052}, "CVE-2025-37732": {"epss_score": 0.0003, "epss_percentile": 0.08185}, "CVE-2025-37734": {"epss_score": 0.00019, "epss_percentile": 0.04397}, "CVE-2025-37735": {"epss_score": 0.00013, "epss_percentile": 0.01474}, "CVE-2025-37736": {"epss_score": 0.00053, "epss_percentile": 0.16878}, "CVE-2025-37738": {"epss_score": 0.00014, "epss_percentile": 0.01861}, "CVE-2025-37739": {"epss_score": 0.00018, "epss_percentile": 0.0404}, "CVE-2025-37740": {"epss_score": 0.00014, "epss_percentile": 0.01769}, "CVE-2025-37741": {"epss_score": 0.00011, "epss_percentile": 0.0095}, "CVE-2025-37742": {"epss_score": 0.00015, "epss_percentile": 0.02283}, "CVE-2025-37743": {"epss_score": 0.00025, "epss_percentile": 0.0622}, "CVE-2025-37744": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2025-37745": {"epss_score": 0.00011, "epss_percentile": 0.01049}, "CVE-2025-37746": {"epss_score": 0.00025, "epss_percentile": 0.0622}, "CVE-2025-37747": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2025-37748": {"epss_score": 0.00019, "epss_percentile": 0.0424}, "CVE-2025-37749": {"epss_score": 0.00014, "epss_percentile": 0.01861}, "CVE-2025-37750": {"epss_score": 0.00018, "epss_percentile": 0.03653}, "CVE-2025-37751": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2025-37752": {"epss_score": 0.0001, "epss_percentile": 0.00837}, "CVE-2025-37754": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2025-37755": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2025-37756": {"epss_score": 7e-05, "epss_percentile": 0.00408}, "CVE-2025-37757": {"epss_score": 0.00017, "epss_percentile": 0.03443}, "CVE-2025-37758": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-37759": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2025-37760": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2025-37761": {"epss_score": 0.00014, "epss_percentile": 0.0203}, "CVE-2025-37762": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2025-37763": {"epss_score": 0.00014, "epss_percentile": 0.0203}, "CVE-2025-37764": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2025-37765": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-37766": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-37767": {"epss_score": 0.00019, "epss_percentile": 0.0424}, "CVE-2025-37768": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-37769": {"epss_score": 0.00019, "epss_percentile": 0.0424}, "CVE-2025-37770": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-37771": {"epss_score": 0.00019, "epss_percentile": 0.0424}, "CVE-2025-37772": {"epss_score": 0.00019, "epss_percentile": 0.0424}, "CVE-2025-37773": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-37774": {"epss_score": 0.00013, "epss_percentile": 0.01741}, "CVE-2025-37775": {"epss_score": 0.00048, "epss_percentile": 0.14934}, "CVE-2025-37776": {"epss_score": 0.00018, "epss_percentile": 0.03939}, "CVE-2025-37777": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-37778": {"epss_score": 0.00052, "epss_percentile": 0.16367}, "CVE-2025-37779": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2025-37780": {"epss_score": 0.00014, "epss_percentile": 0.02089}, "CVE-2025-37781": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-37783": {"epss_score": 0.0002, "epss_percentile": 0.0458}, "CVE-2025-37784": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2025-37785": {"epss_score": 0.00019, "epss_percentile": 0.04267}, "CVE-2025-37786": {"epss_score": 0.00018, "epss_percentile": 0.03939}, "CVE-2025-37787": {"epss_score": 0.00017, "epss_percentile": 0.03394}, "CVE-2025-37788": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-37789": {"epss_score": 0.00018, "epss_percentile": 0.0404}, "CVE-2025-37790": {"epss_score": 0.00019, "epss_percentile": 0.0424}, "CVE-2025-37791": {"epss_score": 0.00026, "epss_percentile": 0.06711}, "CVE-2025-37792": {"epss_score": 0.00018, "epss_percentile": 0.03868}, "CVE-2025-37793": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2025-37794": {"epss_score": 0.00016, "epss_percentile": 0.02986}, "CVE-2025-37796": {"epss_score": 0.00017, "epss_percentile": 0.03141}, "CVE-2025-37797": {"epss_score": 0.00022, "epss_percentile": 0.05272}, "CVE-2025-37798": {"epss_score": 0.00021, "epss_percentile": 0.04929}, "CVE-2025-37799": {"epss_score": 0.00018, "epss_percentile": 0.03648}, "CVE-2025-37800": {"epss_score": 0.00014, "epss_percentile": 0.01931}, "CVE-2025-37801": {"epss_score": 0.00014, "epss_percentile": 0.01801}, "CVE-2025-37802": {"epss_score": 9e-05, "epss_percentile": 0.00655}, "CVE-2025-37803": {"epss_score": 0.00013, "epss_percentile": 0.01631}, "CVE-2025-37805": {"epss_score": 0.00014, "epss_percentile": 0.01801}, "CVE-2025-37806": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37807": {"epss_score": 0.00011, "epss_percentile": 0.01099}, "CVE-2025-37808": {"epss_score": 0.00018, "epss_percentile": 0.03682}, "CVE-2025-37809": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37810": {"epss_score": 0.00018, "epss_percentile": 0.03851}, "CVE-2025-37811": {"epss_score": 0.00019, "epss_percentile": 0.04112}, "CVE-2025-37812": {"epss_score": 0.00014, "epss_percentile": 0.0187}, "CVE-2025-37813": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37814": {"epss_score": 0.00016, "epss_percentile": 0.0274}, "CVE-2025-37815": {"epss_score": 0.00017, "epss_percentile": 0.03235}, "CVE-2025-37816": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37817": {"epss_score": 0.00018, "epss_percentile": 0.03851}, "CVE-2025-37818": {"epss_score": 0.00019, "epss_percentile": 0.04112}, "CVE-2025-37819": {"epss_score": 0.00022, "epss_percentile": 0.0514}, "CVE-2025-37820": {"epss_score": 0.00019, "epss_percentile": 0.04112}, "CVE-2025-37821": {"epss_score": 0.00016, "epss_percentile": 0.02984}, "CVE-2025-37822": {"epss_score": 0.00014, "epss_percentile": 0.02008}, "CVE-2025-37823": {"epss_score": 0.00014, "epss_percentile": 0.01993}, "CVE-2025-37824": {"epss_score": 0.00018, "epss_percentile": 0.03682}, "CVE-2025-37825": {"epss_score": 0.00025, "epss_percentile": 0.06051}, "CVE-2025-37826": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37827": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37828": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37829": {"epss_score": 0.00018, "epss_percentile": 0.03682}, "CVE-2025-37830": {"epss_score": 0.00019, "epss_percentile": 0.04112}, "CVE-2025-37831": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37833": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37834": {"epss_score": 0.00011, "epss_percentile": 0.01099}, "CVE-2025-37836": {"epss_score": 0.00018, "epss_percentile": 0.03682}, "CVE-2025-37837": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37838": {"epss_score": 0.00019, "epss_percentile": 0.04267}, "CVE-2025-37839": {"epss_score": 0.00014, "epss_percentile": 0.01993}, "CVE-2025-37840": {"epss_score": 0.00018, "epss_percentile": 0.03851}, "CVE-2025-37841": {"epss_score": 0.00014, "epss_percentile": 0.01886}, "CVE-2025-37842": {"epss_score": 0.00024, "epss_percentile": 0.05979}, "CVE-2025-37843": {"epss_score": 0.00014, "epss_percentile": 0.01757}, "CVE-2025-37844": {"epss_score": 0.00018, "epss_percentile": 0.03682}, "CVE-2025-37845": {"epss_score": 0.00018, "epss_percentile": 0.03762}, "CVE-2025-37846": {"epss_score": 0.00018, "epss_percentile": 0.03762}, "CVE-2025-37847": {"epss_score": 0.00014, "epss_percentile": 0.01757}, "CVE-2025-37848": {"epss_score": 0.00014, "epss_percentile": 0.01757}, "CVE-2025-37849": {"epss_score": 0.00015, "epss_percentile": 0.02278}, "CVE-2025-37850": {"epss_score": 0.00018, "epss_percentile": 0.03682}, "CVE-2025-37851": {"epss_score": 0.00015, "epss_percentile": 0.02528}, "CVE-2025-37852": {"epss_score": 0.00015, "epss_percentile": 0.02168}, "CVE-2025-37853": {"epss_score": 0.00017, "epss_percentile": 0.03211}, "CVE-2025-37854": {"epss_score": 0.00019, "epss_percentile": 0.04227}, "CVE-2025-37855": {"epss_score": 0.0002, "epss_percentile": 0.04488}, "CVE-2025-37856": {"epss_score": 0.00014, "epss_percentile": 0.01931}, "CVE-2025-37857": {"epss_score": 0.00014, "epss_percentile": 0.01886}, "CVE-2025-37858": {"epss_score": 9e-05, "epss_percentile": 0.00681}, "CVE-2025-37859": {"epss_score": 0.00015, "epss_percentile": 0.02528}, "CVE-2025-37860": {"epss_score": 0.00028, "epss_percentile": 0.07279}, "CVE-2025-37861": {"epss_score": 0.00018, "epss_percentile": 0.03762}, "CVE-2025-37862": {"epss_score": 0.00014, "epss_percentile": 0.01817}, "CVE-2025-37863": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37864": {"epss_score": 0.00015, "epss_percentile": 0.02321}, "CVE-2025-37865": {"epss_score": 0.00018, "epss_percentile": 0.0398}, "CVE-2025-37866": {"epss_score": 0.0002, "epss_percentile": 0.04488}, "CVE-2025-37867": {"epss_score": 0.00018, "epss_percentile": 0.03682}, "CVE-2025-37868": {"epss_score": 0.0001, "epss_percentile": 0.00887}, "CVE-2025-37869": {"epss_score": 0.00014, "epss_percentile": 0.01907}, "CVE-2025-37870": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37871": {"epss_score": 0.00018, "epss_percentile": 0.03682}, "CVE-2025-37872": {"epss_score": 0.00013, "epss_percentile": 0.0171}, "CVE-2025-37873": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37874": {"epss_score": 0.00018, "epss_percentile": 0.03609}, "CVE-2025-37875": {"epss_score": 0.00018, "epss_percentile": 0.04017}, "CVE-2025-37876": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37877": {"epss_score": 0.00011, "epss_percentile": 0.01099}, "CVE-2025-37878": {"epss_score": 7e-05, "epss_percentile": 0.00332}, "CVE-2025-37879": {"epss_score": 0.00015, "epss_percentile": 0.02278}, "CVE-2025-37880": {"epss_score": 0.0002, "epss_percentile": 0.04432}, "CVE-2025-37881": {"epss_score": 0.00024, "epss_percentile": 0.05743}, "CVE-2025-37882": {"epss_score": 0.00011, "epss_percentile": 0.01108}, "CVE-2025-37883": {"epss_score": 0.00015, "epss_percentile": 0.02168}, "CVE-2025-37884": {"epss_score": 0.00013, "epss_percentile": 0.01522}, "CVE-2025-37885": {"epss_score": 0.00018, "epss_percentile": 0.03851}, "CVE-2025-37886": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37887": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37888": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37889": {"epss_score": 0.00019, "epss_percentile": 0.04112}, "CVE-2025-37890": {"epss_score": 0.00022, "epss_percentile": 0.0514}, "CVE-2025-37891": {"epss_score": 0.00018, "epss_percentile": 0.03762}, "CVE-2025-37892": {"epss_score": 0.00014, "epss_percentile": 0.01993}, "CVE-2025-37893": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2025-37894": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37895": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37896": {"epss_score": 0.0002, "epss_percentile": 0.04488}, "CVE-2025-37897": {"epss_score": 0.00023, "epss_percentile": 0.05522}, "CVE-2025-37898": {"epss_score": 0.0002, "epss_percentile": 0.04488}, "CVE-2025-37899": {"epss_score": 0.00014, "epss_percentile": 0.02079}, "CVE-2025-37900": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37901": {"epss_score": 0.00027, "epss_percentile": 0.06919}, "CVE-2025-37903": {"epss_score": 0.00019, "epss_percentile": 0.04159}, "CVE-2025-37904": {"epss_score": 0.0002, "epss_percentile": 0.04488}, "CVE-2025-37905": {"epss_score": 0.00027, "epss_percentile": 0.06919}, "CVE-2025-37906": {"epss_score": 0.00014, "epss_percentile": 0.02089}, "CVE-2025-37907": {"epss_score": 0.0001, "epss_percentile": 0.00887}, "CVE-2025-37908": {"epss_score": 0.00014, "epss_percentile": 0.01907}, "CVE-2025-37909": {"epss_score": 0.00032, "epss_percentile": 0.08743}, "CVE-2025-37910": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37911": {"epss_score": 0.00031, "epss_percentile": 0.08625}, "CVE-2025-37912": {"epss_score": 0.00027, "epss_percentile": 0.06919}, "CVE-2025-37913": {"epss_score": 0.00026, "epss_percentile": 0.06433}, "CVE-2025-37914": {"epss_score": 0.00024, "epss_percentile": 0.05842}, "CVE-2025-37915": {"epss_score": 0.00023, "epss_percentile": 0.05521}, "CVE-2025-37916": {"epss_score": 0.00018, "epss_percentile": 0.03914}, "CVE-2025-37917": {"epss_score": 0.00027, "epss_percentile": 0.06919}, "CVE-2025-37918": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37919": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37920": {"epss_score": 0.0001, "epss_percentile": 0.00887}, "CVE-2025-37921": {"epss_score": 0.00019, "epss_percentile": 0.04159}, "CVE-2025-37922": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37923": {"epss_score": 0.00022, "epss_percentile": 0.0514}, "CVE-2025-37924": {"epss_score": 0.00037, "epss_percentile": 0.10651}, "CVE-2025-37925": {"epss_score": 0.00031, "epss_percentile": 0.0833}, "CVE-2025-37926": {"epss_score": 0.00014, "epss_percentile": 0.01907}, "CVE-2025-37927": {"epss_score": 0.00022, "epss_percentile": 0.04982}, "CVE-2025-37928": {"epss_score": 0.00258, "epss_percentile": 0.48948}, "CVE-2025-37929": {"epss_score": 0.00033, "epss_percentile": 0.09344}, "CVE-2025-37930": {"epss_score": 0.00027, "epss_percentile": 0.06948}, "CVE-2025-37931": {"epss_score": 0.00027, "epss_percentile": 0.06764}, "CVE-2025-37932": {"epss_score": 0.00025, "epss_percentile": 0.06058}, "CVE-2025-37933": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37934": {"epss_score": 0.00014, "epss_percentile": 0.01907}, "CVE-2025-37935": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37936": {"epss_score": 0.00027, "epss_percentile": 0.06919}, "CVE-2025-37937": {"epss_score": 0.00018, "epss_percentile": 0.03682}, "CVE-2025-37938": {"epss_score": 0.00019, "epss_percentile": 0.04112}, "CVE-2025-37939": {"epss_score": 0.00013, "epss_percentile": 0.01459}, "CVE-2025-37940": {"epss_score": 0.00014, "epss_percentile": 0.0187}, "CVE-2025-37941": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37943": {"epss_score": 0.0002, "epss_percentile": 0.04588}, "CVE-2025-37944": {"epss_score": 0.00011, "epss_percentile": 0.0104}, "CVE-2025-37945": {"epss_score": 0.00017, "epss_percentile": 0.03184}, "CVE-2025-37946": {"epss_score": 0.00014, "epss_percentile": 0.01907}, "CVE-2025-37947": {"epss_score": 0.00012, "epss_percentile": 0.0113}, "CVE-2025-37948": {"epss_score": 0.00025, "epss_percentile": 0.06058}, "CVE-2025-37949": {"epss_score": 0.00032, "epss_percentile": 0.08743}, "CVE-2025-37950": {"epss_score": 0.0002, "epss_percentile": 0.04488}, "CVE-2025-37951": {"epss_score": 0.00027, "epss_percentile": 0.06919}, "CVE-2025-37952": {"epss_score": 0.00018, "epss_percentile": 0.03762}, "CVE-2025-37953": {"epss_score": 0.00032, "epss_percentile": 0.08743}, "CVE-2025-37954": {"epss_score": 0.00014, "epss_percentile": 0.01931}, "CVE-2025-37955": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37956": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37957": {"epss_score": 0.00018, "epss_percentile": 0.03762}, "CVE-2025-37958": {"epss_score": 0.00032, "epss_percentile": 0.08743}, "CVE-2025-37959": {"epss_score": 0.00027, "epss_percentile": 0.06919}, "CVE-2025-37960": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37961": {"epss_score": 0.00027, "epss_percentile": 0.06919}, "CVE-2025-37962": {"epss_score": 0.00027, "epss_percentile": 0.06919}, "CVE-2025-37963": {"epss_score": 0.00025, "epss_percentile": 0.06058}, "CVE-2025-37964": {"epss_score": 0.00027, "epss_percentile": 0.06919}, "CVE-2025-37965": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37966": {"epss_score": 0.00033, "epss_percentile": 0.09416}, "CVE-2025-37967": {"epss_score": 0.00021, "epss_percentile": 0.0481}, "CVE-2025-37968": {"epss_score": 0.00025, "epss_percentile": 0.06037}, "CVE-2025-37969": {"epss_score": 0.00025, "epss_percentile": 0.06037}, "CVE-2025-37970": {"epss_score": 0.00025, "epss_percentile": 0.06037}, "CVE-2025-37971": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37972": {"epss_score": 0.00027, "epss_percentile": 0.06919}, "CVE-2025-37973": {"epss_score": 0.00018, "epss_percentile": 0.03762}, "CVE-2025-37974": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37975": {"epss_score": 0.00014, "epss_percentile": 0.01907}, "CVE-2025-37977": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37978": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37979": {"epss_score": 0.00019, "epss_percentile": 0.04227}, "CVE-2025-37980": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37981": {"epss_score": 0.00016, "epss_percentile": 0.02955}, "CVE-2025-37982": {"epss_score": 0.00018, "epss_percentile": 0.03682}, "CVE-2025-37983": {"epss_score": 0.00014, "epss_percentile": 0.01886}, "CVE-2025-37984": {"epss_score": 0.00022, "epss_percentile": 0.04974}, "CVE-2025-37985": {"epss_score": 0.00015, "epss_percentile": 0.02157}, "CVE-2025-37986": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37987": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-37988": {"epss_score": 0.00014, "epss_percentile": 0.01757}, "CVE-2025-37989": {"epss_score": 0.00018, "epss_percentile": 0.03682}, "CVE-2025-37990": {"epss_score": 0.00032, "epss_percentile": 0.08743}, "CVE-2025-37991": {"epss_score": 0.00017, "epss_percentile": 0.03316}, "CVE-2025-37992": {"epss_score": 0.00032, "epss_percentile": 0.08743}, "CVE-2025-37993": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-37994": {"epss_score": 0.00032, "epss_percentile": 0.08743}, "CVE-2025-37995": {"epss_score": 0.00032, "epss_percentile": 0.08743}, "CVE-2025-37996": {"epss_score": 0.0002, "epss_percentile": 0.04488}, "CVE-2025-37997": {"epss_score": 0.00025, "epss_percentile": 0.06037}, "CVE-2025-37998": {"epss_score": 0.00032, "epss_percentile": 0.08855}, "CVE-2025-37999": {"epss_score": 0.00013, "epss_percentile": 0.01643}, "CVE-2025-38000": {"epss_score": 0.00022, "epss_percentile": 0.0514}, "CVE-2025-38001": {"epss_score": 9e-05, "epss_percentile": 0.00681}, "CVE-2025-38002": {"epss_score": 0.00019, "epss_percentile": 0.04349}, "CVE-2025-38003": {"epss_score": 0.00032, "epss_percentile": 0.08743}, "CVE-2025-38004": {"epss_score": 0.00022, "epss_percentile": 0.0514}, "CVE-2025-38005": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38006": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38007": {"epss_score": 0.00036, "epss_percentile": 0.10435}, "CVE-2025-38008": {"epss_score": 0.00012, "epss_percentile": 0.0124}, "CVE-2025-38009": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38010": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38011": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38012": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38013": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-38014": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38015": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38016": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38017": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38018": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38019": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-38020": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38021": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38022": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38023": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38024": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38025": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38027": {"epss_score": 0.00012, "epss_percentile": 0.01357}, "CVE-2025-38028": {"epss_score": 0.00011, "epss_percentile": 0.01003}, "CVE-2025-38029": {"epss_score": 0.00023, "epss_percentile": 0.05413}, "CVE-2025-38031": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38032": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38033": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38034": {"epss_score": 0.00025, "epss_percentile": 0.0623}, "CVE-2025-38035": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38036": {"epss_score": 0.00023, "epss_percentile": 0.05413}, "CVE-2025-38037": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38038": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38039": {"epss_score": 0.00014, "epss_percentile": 0.02035}, "CVE-2025-38040": {"epss_score": 0.00021, "epss_percentile": 0.04927}, "CVE-2025-38041": {"epss_score": 0.00021, "epss_percentile": 0.0492}, "CVE-2025-38042": {"epss_score": 0.00023, "epss_percentile": 0.05413}, "CVE-2025-38043": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38044": {"epss_score": 0.00025, "epss_percentile": 0.0623}, "CVE-2025-38045": {"epss_score": 0.00014, "epss_percentile": 0.02035}, "CVE-2025-38047": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38048": {"epss_score": 0.00017, "epss_percentile": 0.03124}, "CVE-2025-38049": {"epss_score": 0.00026, "epss_percentile": 0.06517}, "CVE-2025-38050": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38051": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38052": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38053": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38054": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38055": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38056": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38057": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2025-38058": {"epss_score": 0.00019, "epss_percentile": 0.04392}, "CVE-2025-38059": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38060": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38061": {"epss_score": 0.00025, "epss_percentile": 0.0623}, "CVE-2025-38062": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38063": {"epss_score": 0.00021, "epss_percentile": 0.04927}, "CVE-2025-38064": {"epss_score": 0.00021, "epss_percentile": 0.0492}, "CVE-2025-38065": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38066": {"epss_score": 0.00021, "epss_percentile": 0.04948}, "CVE-2025-38067": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38068": {"epss_score": 0.00015, "epss_percentile": 0.02287}, "CVE-2025-38069": {"epss_score": 0.00012, "epss_percentile": 0.01162}, "CVE-2025-38070": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38071": {"epss_score": 0.00021, "epss_percentile": 0.04927}, "CVE-2025-38072": {"epss_score": 0.00025, "epss_percentile": 0.0623}, "CVE-2025-38074": {"epss_score": 0.00025, "epss_percentile": 0.0623}, "CVE-2025-38075": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38076": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38077": {"epss_score": 0.00019, "epss_percentile": 0.04253}, "CVE-2025-38078": {"epss_score": 0.00019, "epss_percentile": 0.04392}, "CVE-2025-38079": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38080": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38081": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-38082": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38083": {"epss_score": 0.00025, "epss_percentile": 0.06208}, "CVE-2025-38084": {"epss_score": 0.00025, "epss_percentile": 0.06212}, "CVE-2025-38085": {"epss_score": 0.00023, "epss_percentile": 0.05465}, "CVE-2025-38086": {"epss_score": 0.0003, "epss_percentile": 0.0817}, "CVE-2025-38087": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-38088": {"epss_score": 0.00019, "epss_percentile": 0.04253}, "CVE-2025-38089": {"epss_score": 0.00023, "epss_percentile": 0.05348}, "CVE-2025-38090": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38091": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38092": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38093": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38094": {"epss_score": 0.00025, "epss_percentile": 0.06208}, "CVE-2025-38095": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38096": {"epss_score": 0.00012, "epss_percentile": 0.01151}, "CVE-2025-38097": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38098": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38099": {"epss_score": 0.00012, "epss_percentile": 0.01151}, "CVE-2025-38100": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38101": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38102": {"epss_score": 0.00017, "epss_percentile": 0.03413}, "CVE-2025-38103": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38104": {"epss_score": 0.00021, "epss_percentile": 0.04797}, "CVE-2025-38105": {"epss_score": 0.00018, "epss_percentile": 0.03615}, "CVE-2025-38106": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38107": {"epss_score": 0.00017, "epss_percentile": 0.03413}, "CVE-2025-38108": {"epss_score": 0.00017, "epss_percentile": 0.03413}, "CVE-2025-38109": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-38110": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-38111": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38112": {"epss_score": 0.00025, "epss_percentile": 0.06208}, "CVE-2025-38113": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38114": {"epss_score": 0.00014, "epss_percentile": 0.02056}, "CVE-2025-38115": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38116": {"epss_score": 0.00019, "epss_percentile": 0.04368}, "CVE-2025-38117": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-38118": {"epss_score": 0.00019, "epss_percentile": 0.04253}, "CVE-2025-38119": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38120": {"epss_score": 0.00034, "epss_percentile": 0.09536}, "CVE-2025-38121": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38122": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38123": {"epss_score": 0.00015, "epss_percentile": 0.02323}, "CVE-2025-38124": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38125": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38126": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38127": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38128": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38129": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38130": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38131": {"epss_score": 0.00019, "epss_percentile": 0.04253}, "CVE-2025-38132": {"epss_score": 0.00023, "epss_percentile": 0.05413}, "CVE-2025-38133": {"epss_score": 0.00022, "epss_percentile": 0.05}, "CVE-2025-38134": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38135": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38136": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38137": {"epss_score": 0.00018, "epss_percentile": 0.03892}, "CVE-2025-38138": {"epss_score": 0.00043, "epss_percentile": 0.13093}, "CVE-2025-38139": {"epss_score": 0.00012, "epss_percentile": 0.01326}, "CVE-2025-38140": {"epss_score": 0.00023, "epss_percentile": 0.05413}, "CVE-2025-38141": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38142": {"epss_score": 0.00018, "epss_percentile": 0.03622}, "CVE-2025-38143": {"epss_score": 0.00043, "epss_percentile": 0.13093}, "CVE-2025-38144": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38145": {"epss_score": 0.00043, "epss_percentile": 0.13093}, "CVE-2025-38146": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38147": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38148": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38149": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38150": {"epss_score": 0.00014, "epss_percentile": 0.02056}, "CVE-2025-38151": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38152": {"epss_score": 0.00038, "epss_percentile": 0.11095}, "CVE-2025-38153": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38154": {"epss_score": 0.00019, "epss_percentile": 0.04253}, "CVE-2025-38155": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38156": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38157": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38158": {"epss_score": 0.0002, "epss_percentile": 0.04419}, "CVE-2025-38159": {"epss_score": 0.00019, "epss_percentile": 0.04253}, "CVE-2025-38160": {"epss_score": 0.00043, "epss_percentile": 0.13093}, "CVE-2025-38161": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38162": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38163": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38164": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38165": {"epss_score": 0.00027, "epss_percentile": 0.06925}, "CVE-2025-38166": {"epss_score": 0.00037, "epss_percentile": 0.10906}, "CVE-2025-38167": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38168": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38169": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38170": {"epss_score": 0.00027, "epss_percentile": 0.06925}, "CVE-2025-38171": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38172": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38173": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38174": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38175": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38176": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38177": {"epss_score": 0.00025, "epss_percentile": 0.0623}, "CVE-2025-38179": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38180": {"epss_score": 0.00017, "epss_percentile": 0.03444}, "CVE-2025-38181": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38182": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-38183": {"epss_score": 0.00019, "epss_percentile": 0.04253}, "CVE-2025-38184": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38185": {"epss_score": 0.00025, "epss_percentile": 0.0623}, "CVE-2025-38186": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38187": {"epss_score": 0.00018, "epss_percentile": 0.03892}, "CVE-2025-38188": {"epss_score": 0.00021, "epss_percentile": 0.04919}, "CVE-2025-38189": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38190": {"epss_score": 0.00014, "epss_percentile": 0.01986}, "CVE-2025-38191": {"epss_score": 0.00021, "epss_percentile": 0.0472}, "CVE-2025-38192": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38193": {"epss_score": 0.00014, "epss_percentile": 0.01986}, "CVE-2025-38194": {"epss_score": 0.00014, "epss_percentile": 0.01986}, "CVE-2025-38195": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38196": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38197": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38198": {"epss_score": 0.00015, "epss_percentile": 0.02414}, "CVE-2025-38199": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38200": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38201": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38202": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38203": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38204": {"epss_score": 0.00015, "epss_percentile": 0.02414}, "CVE-2025-38205": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38206": {"epss_score": 0.00019, "epss_percentile": 0.04333}, "CVE-2025-38207": {"epss_score": 0.00017, "epss_percentile": 0.03106}, "CVE-2025-38208": {"epss_score": 0.00014, "epss_percentile": 0.02035}, "CVE-2025-38209": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38210": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38211": {"epss_score": 0.00017, "epss_percentile": 0.0335}, "CVE-2025-38212": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38214": {"epss_score": 0.00025, "epss_percentile": 0.0623}, "CVE-2025-38215": {"epss_score": 0.00021, "epss_percentile": 0.04927}, "CVE-2025-38216": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38217": {"epss_score": 0.00012, "epss_percentile": 0.0124}, "CVE-2025-38218": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38219": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38220": {"epss_score": 0.00015, "epss_percentile": 0.02323}, "CVE-2025-38221": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38222": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38223": {"epss_score": 5e-05, "epss_percentile": 0.00215}, "CVE-2025-38224": {"epss_score": 0.00012, "epss_percentile": 0.01321}, "CVE-2025-38225": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38226": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38227": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38228": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38229": {"epss_score": 0.00025, "epss_percentile": 0.0623}, "CVE-2025-38230": {"epss_score": 0.00017, "epss_percentile": 0.03444}, "CVE-2025-38231": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38232": {"epss_score": 9e-05, "epss_percentile": 0.00686}, "CVE-2025-38233": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38234": {"epss_score": 9e-05, "epss_percentile": 0.00711}, "CVE-2025-38235": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38236": {"epss_score": 0.00022, "epss_percentile": 0.05176}, "CVE-2025-38237": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38238": {"epss_score": 0.00018, "epss_percentile": 0.03854}, "CVE-2025-38239": {"epss_score": 0.00019, "epss_percentile": 0.04367}, "CVE-2025-38240": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2025-38241": {"epss_score": 0.00014, "epss_percentile": 0.02056}, "CVE-2025-38242": {"epss_score": 0.00012, "epss_percentile": 0.01256}, "CVE-2025-38243": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38244": {"epss_score": 0.00012, "epss_percentile": 0.0124}, "CVE-2025-38245": {"epss_score": 0.00014, "epss_percentile": 0.02081}, "CVE-2025-38246": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38247": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38248": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38249": {"epss_score": 0.00018, "epss_percentile": 0.04011}, "CVE-2025-38250": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-38251": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38252": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38253": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38254": {"epss_score": 0.00022, "epss_percentile": 0.0498}, "CVE-2025-38255": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38256": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38257": {"epss_score": 0.00019, "epss_percentile": 0.04367}, "CVE-2025-38258": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38259": {"epss_score": 0.00019, "epss_percentile": 0.04367}, "CVE-2025-38260": {"epss_score": 0.00019, "epss_percentile": 0.04131}, "CVE-2025-38261": {"epss_score": 0.00019, "epss_percentile": 0.04336}, "CVE-2025-38262": {"epss_score": 0.00015, "epss_percentile": 0.02273}, "CVE-2025-38263": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38264": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38265": {"epss_score": 0.00015, "epss_percentile": 0.02242}, "CVE-2025-38266": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38267": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38268": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2025-38269": {"epss_score": 8e-05, "epss_percentile": 0.00475}, "CVE-2025-38270": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38271": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38272": {"epss_score": 0.00015, "epss_percentile": 0.02511}, "CVE-2025-38273": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38274": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38275": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38276": {"epss_score": 0.00014, "epss_percentile": 0.02056}, "CVE-2025-38277": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38278": {"epss_score": 0.00015, "epss_percentile": 0.02323}, "CVE-2025-38279": {"epss_score": 0.0003, "epss_percentile": 0.08018}, "CVE-2025-38280": {"epss_score": 0.00019, "epss_percentile": 0.04367}, "CVE-2025-38281": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38282": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38283": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38284": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38285": {"epss_score": 0.00028, "epss_percentile": 0.07246}, "CVE-2025-38286": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38287": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38288": {"epss_score": 0.00024, "epss_percentile": 0.05773}, "CVE-2025-38289": {"epss_score": 0.00012, "epss_percentile": 0.01326}, "CVE-2025-38290": {"epss_score": 0.00089, "epss_percentile": 0.25872}, "CVE-2025-38291": {"epss_score": 8e-05, "epss_percentile": 0.00502}, "CVE-2025-38292": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38293": {"epss_score": 0.00034, "epss_percentile": 0.09559}, "CVE-2025-38294": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38295": {"epss_score": 0.00027, "epss_percentile": 0.07108}, "CVE-2025-38296": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38297": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38298": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38299": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38300": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38301": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38302": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2025-38303": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38304": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38305": {"epss_score": 0.00019, "epss_percentile": 0.04131}, "CVE-2025-38306": {"epss_score": 0.00012, "epss_percentile": 0.01256}, "CVE-2025-38307": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38308": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38309": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38310": {"epss_score": 0.00019, "epss_percentile": 0.04099}, "CVE-2025-38311": {"epss_score": 0.00014, "epss_percentile": 0.01973}, "CVE-2025-38312": {"epss_score": 0.00025, "epss_percentile": 0.0623}, "CVE-2025-38313": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38314": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38315": {"epss_score": 7e-05, "epss_percentile": 0.00397}, "CVE-2025-38316": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38317": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38318": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38319": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38320": {"epss_score": 0.00018, "epss_percentile": 0.04011}, "CVE-2025-38321": {"epss_score": 0.00014, "epss_percentile": 0.02035}, "CVE-2025-38322": {"epss_score": 0.00027, "epss_percentile": 0.07164}, "CVE-2025-38323": {"epss_score": 0.00014, "epss_percentile": 0.02081}, "CVE-2025-38324": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38325": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38326": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38327": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38328": {"epss_score": 0.00014, "epss_percentile": 0.01889}, "CVE-2025-38329": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38330": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38331": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38332": {"epss_score": 0.00013, "epss_percentile": 0.01621}, "CVE-2025-38333": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38334": {"epss_score": 0.00019, "epss_percentile": 0.04131}, "CVE-2025-38335": {"epss_score": 0.00021, "epss_percentile": 0.04913}, "CVE-2025-38336": {"epss_score": 0.00025, "epss_percentile": 0.0623}, "CVE-2025-38337": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38338": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-38339": {"epss_score": 0.00018, "epss_percentile": 0.03854}, "CVE-2025-38340": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38341": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38342": {"epss_score": 0.00018, "epss_percentile": 0.04011}, "CVE-2025-38343": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38344": {"epss_score": 0.00014, "epss_percentile": 0.01986}, "CVE-2025-38345": {"epss_score": 0.00014, "epss_percentile": 0.01986}, "CVE-2025-38346": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38347": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38348": {"epss_score": 0.00022, "epss_percentile": 0.05257}, "CVE-2025-38349": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2025-38350": {"epss_score": 0.00017, "epss_percentile": 0.0335}, "CVE-2025-38351": {"epss_score": 0.00019, "epss_percentile": 0.04171}, "CVE-2025-38352": {"epss_score": 0.00192, "epss_percentile": 0.4135}, "CVE-2025-38353": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2025-38354": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38355": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38356": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38357": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38358": {"epss_score": 0.00011, "epss_percentile": 0.01003}, "CVE-2025-38359": {"epss_score": 0.00013, "epss_percentile": 0.01701}, "CVE-2025-38360": {"epss_score": 0.00012, "epss_percentile": 0.01305}, "CVE-2025-38361": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38362": {"epss_score": 0.00014, "epss_percentile": 0.01757}, "CVE-2025-38363": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38364": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38365": {"epss_score": 0.00015, "epss_percentile": 0.02251}, "CVE-2025-38366": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38367": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38368": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38369": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-38370": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38371": {"epss_score": 0.00024, "epss_percentile": 0.05866}, "CVE-2025-38372": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38373": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2025-38374": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38375": {"epss_score": 0.00018, "epss_percentile": 0.04011}, "CVE-2025-38376": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38377": {"epss_score": 0.00014, "epss_percentile": 0.02081}, "CVE-2025-38378": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38379": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38381": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38382": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38383": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2025-38384": {"epss_score": 0.00015, "epss_percentile": 0.02273}, "CVE-2025-38385": {"epss_score": 0.00019, "epss_percentile": 0.04367}, "CVE-2025-38386": {"epss_score": 0.00014, "epss_percentile": 0.01986}, "CVE-2025-38387": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38388": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2025-38389": {"epss_score": 0.00018, "epss_percentile": 0.04011}, "CVE-2025-38390": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38391": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38392": {"epss_score": 0.00011, "epss_percentile": 0.01063}, "CVE-2025-38393": {"epss_score": 0.00014, "epss_percentile": 0.01968}, "CVE-2025-38394": {"epss_score": 0.00022, "epss_percentile": 0.05}, "CVE-2025-38395": {"epss_score": 0.00018, "epss_percentile": 0.04011}, "CVE-2025-38396": {"epss_score": 0.00019, "epss_percentile": 0.04367}, "CVE-2025-38397": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38398": {"epss_score": 0.00022, "epss_percentile": 0.0498}, "CVE-2025-38399": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38400": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38401": {"epss_score": 0.00022, "epss_percentile": 0.04975}, "CVE-2025-38402": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38403": {"epss_score": 0.00018, "epss_percentile": 0.04011}, "CVE-2025-38404": {"epss_score": 0.00014, "epss_percentile": 0.01968}, "CVE-2025-38405": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38406": {"epss_score": 0.00018, "epss_percentile": 0.03665}, "CVE-2025-38407": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38408": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38409": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38410": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38411": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38412": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38413": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38414": {"epss_score": 0.00013, "epss_percentile": 0.01682}, "CVE-2025-38415": {"epss_score": 0.00025, "epss_percentile": 0.06357}, "CVE-2025-38416": {"epss_score": 0.0003, "epss_percentile": 0.0808}, "CVE-2025-38417": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38418": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38419": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38420": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38421": {"epss_score": 0.00018, "epss_percentile": 0.04036}, "CVE-2025-38422": {"epss_score": 0.00019, "epss_percentile": 0.04367}, "CVE-2025-38423": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38424": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38425": {"epss_score": 0.00019, "epss_percentile": 0.04208}, "CVE-2025-38426": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38427": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38428": {"epss_score": 0.00026, "epss_percentile": 0.06578}, "CVE-2025-38429": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38430": {"epss_score": 0.00031, "epss_percentile": 0.08713}, "CVE-2025-38431": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38432": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38433": {"epss_score": 0.00028, "epss_percentile": 0.07347}, "CVE-2025-38434": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38435": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38436": {"epss_score": 0.00012, "epss_percentile": 0.01272}, "CVE-2025-38437": {"epss_score": 0.00019, "epss_percentile": 0.04367}, "CVE-2025-38438": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38439": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38440": {"epss_score": 0.0001, "epss_percentile": 0.00776}, "CVE-2025-38441": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38442": {"epss_score": 0.00022, "epss_percentile": 0.0515}, "CVE-2025-38443": {"epss_score": 0.00019, "epss_percentile": 0.04367}, "CVE-2025-38444": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38445": {"epss_score": 0.00018, "epss_percentile": 0.04011}, "CVE-2025-38446": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38447": {"epss_score": 0.00028, "epss_percentile": 0.07441}, "CVE-2025-38448": {"epss_score": 0.00014, "epss_percentile": 0.01968}, "CVE-2025-38449": {"epss_score": 0.00013, "epss_percentile": 0.01665}, "CVE-2025-38450": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38451": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38452": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38453": {"epss_score": 0.00015, "epss_percentile": 0.02511}, "CVE-2025-38454": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38455": {"epss_score": 0.00019, "epss_percentile": 0.04219}, "CVE-2025-38456": {"epss_score": 0.00023, "epss_percentile": 0.05369}, "CVE-2025-38457": {"epss_score": 0.00018, "epss_percentile": 0.03665}, "CVE-2025-38458": {"epss_score": 0.00018, "epss_percentile": 0.03665}, "CVE-2025-38459": {"epss_score": 0.00016, "epss_percentile": 0.02623}, "CVE-2025-38460": {"epss_score": 0.00018, "epss_percentile": 0.03665}, "CVE-2025-38461": {"epss_score": 0.00014, "epss_percentile": 0.01968}, "CVE-2025-38462": {"epss_score": 0.00014, "epss_percentile": 0.01968}, "CVE-2025-38463": {"epss_score": 0.00015, "epss_percentile": 0.02323}, "CVE-2025-38464": {"epss_score": 0.00017, "epss_percentile": 0.0335}, "CVE-2025-38465": {"epss_score": 0.00018, "epss_percentile": 0.03665}, "CVE-2025-38466": {"epss_score": 0.00019, "epss_percentile": 0.04229}, "CVE-2025-38467": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38468": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38469": {"epss_score": 0.00018, "epss_percentile": 0.0386}, "CVE-2025-38470": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38471": {"epss_score": 0.00019, "epss_percentile": 0.04367}, "CVE-2025-38472": {"epss_score": 0.00019, "epss_percentile": 0.04131}, "CVE-2025-38473": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38474": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38475": {"epss_score": 0.00012, "epss_percentile": 0.01385}, "CVE-2025-38476": {"epss_score": 0.00018, "epss_percentile": 0.04011}, "CVE-2025-38477": {"epss_score": 0.00014, "epss_percentile": 0.01968}, "CVE-2025-38478": {"epss_score": 0.00018, "epss_percentile": 0.03847}, "CVE-2025-38479": {"epss_score": 0.00022, "epss_percentile": 0.05311}, "CVE-2025-38480": {"epss_score": 0.00015, "epss_percentile": 0.02214}, "CVE-2025-38481": {"epss_score": 0.00015, "epss_percentile": 0.02214}, "CVE-2025-38482": {"epss_score": 0.00015, "epss_percentile": 0.02297}, "CVE-2025-38483": {"epss_score": 0.00015, "epss_percentile": 0.02297}, "CVE-2025-38484": {"epss_score": 0.00012, "epss_percentile": 0.01406}, "CVE-2025-38485": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-38486": {"epss_score": 0.00018, "epss_percentile": 0.04004}, "CVE-2025-38487": {"epss_score": 0.0002, "epss_percentile": 0.04427}, "CVE-2025-38488": {"epss_score": 0.00011, "epss_percentile": 0.00975}, "CVE-2025-38489": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38490": {"epss_score": 0.00016, "epss_percentile": 0.02721}, "CVE-2025-38491": {"epss_score": 0.00017, "epss_percentile": 0.03406}, "CVE-2025-38492": {"epss_score": 0.00011, "epss_percentile": 0.01003}, "CVE-2025-38493": {"epss_score": 0.00013, "epss_percentile": 0.016}, "CVE-2025-38494": {"epss_score": 0.00028, "epss_percentile": 0.07221}, "CVE-2025-38495": {"epss_score": 5e-05, "epss_percentile": 0.00222}, "CVE-2025-38496": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-38497": {"epss_score": 0.00015, "epss_percentile": 0.02297}, "CVE-2025-38498": {"epss_score": 0.00025, "epss_percentile": 0.06213}, "CVE-2025-38499": {"epss_score": 0.00011, "epss_percentile": 0.00949}, "CVE-2025-38500": {"epss_score": 0.00011, "epss_percentile": 0.01029}, "CVE-2025-38501": {"epss_score": 0.00065, "epss_percentile": 0.2053}, "CVE-2025-38502": {"epss_score": 0.00023, "epss_percentile": 0.05396}, "CVE-2025-38503": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-38504": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38505": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38506": {"epss_score": 0.00017, "epss_percentile": 0.03485}, "CVE-2025-38507": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38508": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38509": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38510": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-38511": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38512": {"epss_score": 0.00023, "epss_percentile": 0.05472}, "CVE-2025-38513": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38514": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38515": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38516": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38517": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38518": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38519": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38520": {"epss_score": 0.00018, "epss_percentile": 0.03606}, "CVE-2025-38521": {"epss_score": 0.00032, "epss_percentile": 0.08981}, "CVE-2025-38522": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38523": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38524": {"epss_score": 0.00017, "epss_percentile": 0.03379}, "CVE-2025-38525": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38526": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38527": {"epss_score": 0.00023, "epss_percentile": 0.05472}, "CVE-2025-38528": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-38529": {"epss_score": 0.00022, "epss_percentile": 0.05143}, "CVE-2025-38530": {"epss_score": 0.00022, "epss_percentile": 0.05143}, "CVE-2025-38531": {"epss_score": 0.00021, "epss_percentile": 0.04811}, "CVE-2025-38532": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38533": {"epss_score": 0.00023, "epss_percentile": 0.05447}, "CVE-2025-38534": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38535": {"epss_score": 0.00022, "epss_percentile": 0.05143}, "CVE-2025-38536": {"epss_score": 0.00025, "epss_percentile": 0.0616}, "CVE-2025-38537": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38538": {"epss_score": 0.00026, "epss_percentile": 0.06433}, "CVE-2025-38539": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38540": {"epss_score": 0.00079, "epss_percentile": 0.23859}, "CVE-2025-38541": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38542": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38543": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-38544": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38545": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38546": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38547": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38548": {"epss_score": 0.00022, "epss_percentile": 0.05143}, "CVE-2025-38549": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38550": {"epss_score": 0.00023, "epss_percentile": 0.05472}, "CVE-2025-38551": {"epss_score": 0.00017, "epss_percentile": 0.03485}, "CVE-2025-38552": {"epss_score": 0.00023, "epss_percentile": 0.05396}, "CVE-2025-38553": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38554": {"epss_score": 0.00022, "epss_percentile": 0.05323}, "CVE-2025-38555": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38556": {"epss_score": 0.00021, "epss_percentile": 0.04907}, "CVE-2025-38557": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38558": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38559": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38560": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-38561": {"epss_score": 0.00036, "epss_percentile": 0.10384}, "CVE-2025-38562": {"epss_score": 0.00037, "epss_percentile": 0.10741}, "CVE-2025-38563": {"epss_score": 0.00076, "epss_percentile": 0.23256}, "CVE-2025-38564": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38565": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38566": {"epss_score": 0.00086, "epss_percentile": 0.25357}, "CVE-2025-38567": {"epss_score": 0.00017, "epss_percentile": 0.03485}, "CVE-2025-38568": {"epss_score": 0.00023, "epss_percentile": 0.05447}, "CVE-2025-38569": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38570": {"epss_score": 0.00022, "epss_percentile": 0.05323}, "CVE-2025-38571": {"epss_score": 0.00023, "epss_percentile": 0.05341}, "CVE-2025-38572": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38573": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38574": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38575": {"epss_score": 0.00085, "epss_percentile": 0.25094}, "CVE-2025-38576": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38577": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38578": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38579": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-38580": {"epss_score": 0.00022, "epss_percentile": 0.05323}, "CVE-2025-38581": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38582": {"epss_score": 0.00023, "epss_percentile": 0.05447}, "CVE-2025-38583": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-38584": {"epss_score": 0.00022, "epss_percentile": 0.05323}, "CVE-2025-38585": {"epss_score": 0.00023, "epss_percentile": 0.05611}, "CVE-2025-38586": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38587": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-38588": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-38589": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38590": {"epss_score": 0.00023, "epss_percentile": 0.05341}, "CVE-2025-38591": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38592": {"epss_score": 0.00022, "epss_percentile": 0.05323}, "CVE-2025-38593": {"epss_score": 0.00023, "epss_percentile": 0.05472}, "CVE-2025-38594": {"epss_score": 0.00025, "epss_percentile": 0.0616}, "CVE-2025-38595": {"epss_score": 0.00023, "epss_percentile": 0.05447}, "CVE-2025-38596": {"epss_score": 0.00025, "epss_percentile": 0.0616}, "CVE-2025-38597": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38598": {"epss_score": 0.00025, "epss_percentile": 0.0616}, "CVE-2025-38599": {"epss_score": 0.00022, "epss_percentile": 0.05323}, "CVE-2025-38600": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38601": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38602": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38604": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38605": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38606": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38607": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38608": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38609": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-38610": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-38612": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38613": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38614": {"epss_score": 0.00068, "epss_percentile": 0.21379}, "CVE-2025-38615": {"epss_score": 0.00023, "epss_percentile": 0.05341}, "CVE-2025-38616": {"epss_score": 0.00023, "epss_percentile": 0.05368}, "CVE-2025-38617": {"epss_score": 0.00017, "epss_percentile": 0.03171}, "CVE-2025-38618": {"epss_score": 0.00022, "epss_percentile": 0.05143}, "CVE-2025-38619": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38620": {"epss_score": 0.00025, "epss_percentile": 0.0616}, "CVE-2025-38621": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38622": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38623": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38624": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38625": {"epss_score": 0.00023, "epss_percentile": 0.05341}, "CVE-2025-38626": {"epss_score": 0.00023, "epss_percentile": 0.05341}, "CVE-2025-38627": {"epss_score": 0.00022, "epss_percentile": 0.05323}, "CVE-2025-38628": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38629": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38630": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38631": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38632": {"epss_score": 0.00018, "epss_percentile": 0.03541}, "CVE-2025-38633": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38634": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-38635": {"epss_score": 0.00029, "epss_percentile": 0.07668}, "CVE-2025-38636": {"epss_score": 0.00025, "epss_percentile": 0.0616}, "CVE-2025-38637": {"epss_score": 0.00033, "epss_percentile": 0.09124}, "CVE-2025-38638": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38639": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38640": {"epss_score": 0.00023, "epss_percentile": 0.05341}, "CVE-2025-38641": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38642": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38643": {"epss_score": 0.00018, "epss_percentile": 0.03541}, "CVE-2025-38644": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-38645": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-38646": {"epss_score": 0.00023, "epss_percentile": 0.05341}, "CVE-2025-38647": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38648": {"epss_score": 0.00023, "epss_percentile": 0.05341}, "CVE-2025-38649": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38650": {"epss_score": 0.00017, "epss_percentile": 0.03171}, "CVE-2025-38651": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38652": {"epss_score": 0.00022, "epss_percentile": 0.05143}, "CVE-2025-38653": {"epss_score": 0.00023, "epss_percentile": 0.05472}, "CVE-2025-38654": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38655": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38656": {"epss_score": 0.00022, "epss_percentile": 0.05323}, "CVE-2025-38657": {"epss_score": 0.00025, "epss_percentile": 0.0616}, "CVE-2025-38658": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38659": {"epss_score": 0.00023, "epss_percentile": 0.05341}, "CVE-2025-38660": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38661": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38662": {"epss_score": 0.00022, "epss_percentile": 0.05323}, "CVE-2025-38663": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38664": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-38665": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-38666": {"epss_score": 0.00022, "epss_percentile": 0.05143}, "CVE-2025-38667": {"epss_score": 0.00025, "epss_percentile": 0.0616}, "CVE-2025-38668": {"epss_score": 0.00138, "epss_percentile": 0.34442}, "CVE-2025-38669": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38670": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-38671": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38672": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38673": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38674": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38675": {"epss_score": 0.00017, "epss_percentile": 0.03485}, "CVE-2025-38676": {"epss_score": 0.00218, "epss_percentile": 0.44436}, "CVE-2025-38677": {"epss_score": 0.00092, "epss_percentile": 0.26564}, "CVE-2025-38678": {"epss_score": 0.00033, "epss_percentile": 0.09186}, "CVE-2025-38679": {"epss_score": 0.00054, "epss_percentile": 0.17213}, "CVE-2025-38680": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38681": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38682": {"epss_score": 0.00025, "epss_percentile": 0.0616}, "CVE-2025-38683": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38684": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38685": {"epss_score": 0.00068, "epss_percentile": 0.21379}, "CVE-2025-38686": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38687": {"epss_score": 0.00092, "epss_percentile": 0.26564}, "CVE-2025-38688": {"epss_score": 0.00023, "epss_percentile": 0.05447}, "CVE-2025-38689": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38690": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-38691": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38692": {"epss_score": 0.00023, "epss_percentile": 0.05341}, "CVE-2025-38693": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38694": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38695": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38696": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38697": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38698": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38699": {"epss_score": 0.00022, "epss_percentile": 0.05143}, "CVE-2025-38700": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38701": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38702": {"epss_score": 0.00058, "epss_percentile": 0.18547}, "CVE-2025-38703": {"epss_score": 0.00023, "epss_percentile": 0.05447}, "CVE-2025-38704": {"epss_score": 0.00022, "epss_percentile": 0.0495}, "CVE-2025-38705": {"epss_score": 0.00021, "epss_percentile": 0.04752}, "CVE-2025-38706": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38707": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-38708": {"epss_score": 0.00092, "epss_percentile": 0.26564}, "CVE-2025-38709": {"epss_score": 0.00022, "epss_percentile": 0.05268}, "CVE-2025-38710": {"epss_score": 0.00021, "epss_percentile": 0.04752}, "CVE-2025-38711": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-38712": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38713": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38714": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38715": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38716": {"epss_score": 0.00022, "epss_percentile": 0.05268}, "CVE-2025-38717": {"epss_score": 0.00017, "epss_percentile": 0.03379}, "CVE-2025-38718": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38719": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38720": {"epss_score": 0.00017, "epss_percentile": 0.03485}, "CVE-2025-38721": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38722": {"epss_score": 0.00023, "epss_percentile": 0.05447}, "CVE-2025-38723": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-38724": {"epss_score": 0.00092, "epss_percentile": 0.26564}, "CVE-2025-38725": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-38726": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-38727": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38728": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-38729": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38730": {"epss_score": 0.00023, "epss_percentile": 0.05611}, "CVE-2025-38731": {"epss_score": 0.00025, "epss_percentile": 0.0616}, "CVE-2025-38732": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-38733": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38734": {"epss_score": 0.00023, "epss_percentile": 0.05611}, "CVE-2025-38735": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-38736": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-38737": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-38738": {"epss_score": 0.00023, "epss_percentile": 0.05431}, "CVE-2025-38739": {"epss_score": 0.00038, "epss_percentile": 0.11328}, "CVE-2025-38741": {"epss_score": 0.00044, "epss_percentile": 0.13472}, "CVE-2025-38742": {"epss_score": 0.00021, "epss_percentile": 0.04833}, "CVE-2025-38743": {"epss_score": 0.00026, "epss_percentile": 0.06564}, "CVE-2025-38745": {"epss_score": 0.00059, "epss_percentile": 0.18722}, "CVE-2025-38746": {"epss_score": 0.00026, "epss_percentile": 0.06533}, "CVE-2025-38747": {"epss_score": 0.00014, "epss_percentile": 0.02122}, "CVE-2025-39201": {"epss_score": 0.00042, "epss_percentile": 0.12609}, "CVE-2025-39202": {"epss_score": 0.00016, "epss_percentile": 0.02892}, "CVE-2025-39203": {"epss_score": 0.00044, "epss_percentile": 0.13645}, "CVE-2025-39204": {"epss_score": 0.00041, "epss_percentile": 0.124}, "CVE-2025-39205": {"epss_score": 0.00022, "epss_percentile": 0.0519}, "CVE-2025-39240": {"epss_score": 0.00114, "epss_percentile": 0.30821}, "CVE-2025-39245": {"epss_score": 0.00068, "epss_percentile": 0.21204}, "CVE-2025-39246": {"epss_score": 0.00053, "epss_percentile": 0.16701}, "CVE-2025-39247": {"epss_score": 0.0008, "epss_percentile": 0.24131}, "CVE-2025-39348": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-39349": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-39350": {"epss_score": 0.00057, "epss_percentile": 0.18041}, "CVE-2025-39351": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-39352": {"epss_score": 0.00057, "epss_percentile": 0.18041}, "CVE-2025-39353": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-39354": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-39355": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-39356": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-39357": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-39358": {"epss_score": 0.00118, "epss_percentile": 0.31508}, "CVE-2025-39359": {"epss_score": 0.00133, "epss_percentile": 0.33631}, "CVE-2025-39360": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-39361": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-39362": {"epss_score": 0.00054, "epss_percentile": 0.17191}, "CVE-2025-39363": {"epss_score": 0.00026, "epss_percentile": 0.06675}, "CVE-2025-39364": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-39365": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-39366": {"epss_score": 0.0006, "epss_percentile": 0.19099}, "CVE-2025-39367": {"epss_score": 0.00042, "epss_percentile": 0.12889}, "CVE-2025-39368": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-39369": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-39370": {"epss_score": 0.00034, "epss_percentile": 0.09702}, "CVE-2025-39371": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-39372": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-39373": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-39374": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-39375": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-39376": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-39377": {"epss_score": 0.00053, "epss_percentile": 0.16675}, "CVE-2025-39378": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-39379": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-39380": {"epss_score": 0.00066, "epss_percentile": 0.20739}, "CVE-2025-39381": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39382": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39383": {"epss_score": 0.00133, "epss_percentile": 0.33631}, "CVE-2025-39384": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-39385": {"epss_score": 0.00053, "epss_percentile": 0.16965}, "CVE-2025-39386": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-39387": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-39388": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-39389": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-39390": {"epss_score": 0.00057, "epss_percentile": 0.17999}, "CVE-2025-39391": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-39392": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-39393": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-39394": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2025-39395": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-39396": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-39397": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39398": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-39399": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-39400": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39401": {"epss_score": 0.00075, "epss_percentile": 0.23007}, "CVE-2025-39402": {"epss_score": 0.00065, "epss_percentile": 0.20582}, "CVE-2025-39403": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-39404": {"epss_score": 0.00043, "epss_percentile": 0.13027}, "CVE-2025-39405": {"epss_score": 0.0006, "epss_percentile": 0.19099}, "CVE-2025-39406": {"epss_score": 0.00157, "epss_percentile": 0.37115}, "CVE-2025-39407": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-39408": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39409": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-39410": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-39411": {"epss_score": 0.00121, "epss_percentile": 0.31956}, "CVE-2025-39412": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-39413": {"epss_score": 0.00046, "epss_percentile": 0.14291}, "CVE-2025-39414": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39415": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39416": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39417": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39418": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39419": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39420": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39421": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39422": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39423": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39424": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39425": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-39426": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-39427": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-39428": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-39429": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-39430": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39431": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39432": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39433": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39434": {"epss_score": 0.00053, "epss_percentile": 0.16965}, "CVE-2025-39435": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39436": {"epss_score": 0.00032, "epss_percentile": 0.08749}, "CVE-2025-39437": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-39438": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-39439": {"epss_score": 0.00059, "epss_percentile": 0.18859}, "CVE-2025-39440": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39441": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39442": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39443": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-39444": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-39445": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-39446": {"epss_score": 0.00025, "epss_percentile": 0.06047}, "CVE-2025-39447": {"epss_score": 0.00046, "epss_percentile": 0.14268}, "CVE-2025-39448": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-39449": {"epss_score": 0.00046, "epss_percentile": 0.14268}, "CVE-2025-39450": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-39451": {"epss_score": 0.00046, "epss_percentile": 0.14268}, "CVE-2025-39452": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-39453": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-39454": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-39455": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39456": {"epss_score": 0.00069, "epss_percentile": 0.21585}, "CVE-2025-39457": {"epss_score": 0.00057, "epss_percentile": 0.17999}, "CVE-2025-39458": {"epss_score": 0.00161, "epss_percentile": 0.376}, "CVE-2025-39459": {"epss_score": 0.00053, "epss_percentile": 0.1672}, "CVE-2025-39460": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-39461": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-39462": {"epss_score": 0.00144, "epss_percentile": 0.35277}, "CVE-2025-39463": {"epss_score": 0.00112, "epss_percentile": 0.30427}, "CVE-2025-39464": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39465": {"epss_score": 0.00025, "epss_percentile": 0.06117}, "CVE-2025-39466": {"epss_score": 0.00112, "epss_percentile": 0.30427}, "CVE-2025-39467": {"epss_score": 0.00045, "epss_percentile": 0.1407}, "CVE-2025-39468": {"epss_score": 0.00112, "epss_percentile": 0.30427}, "CVE-2025-39469": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39470": {"epss_score": 0.00059, "epss_percentile": 0.18648}, "CVE-2025-39471": {"epss_score": 0.00053, "epss_percentile": 0.16856}, "CVE-2025-39472": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-39473": {"epss_score": 0.00043, "epss_percentile": 0.13078}, "CVE-2025-39474": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-39475": {"epss_score": 0.00043, "epss_percentile": 0.13078}, "CVE-2025-39476": {"epss_score": 0.00113, "epss_percentile": 0.3066}, "CVE-2025-39477": {"epss_score": 0.00041, "epss_percentile": 0.12455}, "CVE-2025-39478": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-39479": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-39480": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-39481": {"epss_score": 0.00038, "epss_percentile": 0.11365}, "CVE-2025-39482": {"epss_score": 0.0004, "epss_percentile": 0.12043}, "CVE-2025-39483": {"epss_score": 0.00071, "epss_percentile": 0.22071}, "CVE-2025-39484": {"epss_score": 0.0003, "epss_percentile": 0.08141}, "CVE-2025-39485": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-39486": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-39487": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-39488": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-39489": {"epss_score": 0.00064, "epss_percentile": 0.20192}, "CVE-2025-39490": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-39491": {"epss_score": 0.00062, "epss_percentile": 0.19773}, "CVE-2025-39492": {"epss_score": 0.00062, "epss_percentile": 0.19654}, "CVE-2025-39493": {"epss_score": 0.00042, "epss_percentile": 0.12734}, "CVE-2025-39494": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-39495": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-39496": {"epss_score": 0.00058, "epss_percentile": 0.18292}, "CVE-2025-39497": {"epss_score": 0.00015, "epss_percentile": 0.02478}, "CVE-2025-39498": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2025-39499": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-39500": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-39501": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-39502": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-39503": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-39504": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-39505": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-39506": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-39507": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-39508": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-39509": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-39510": {"epss_score": 0.00057, "epss_percentile": 0.18148}, "CVE-2025-39511": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-39512": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-39513": {"epss_score": 0.00078, "epss_percentile": 0.2361}, "CVE-2025-39514": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39515": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39516": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39517": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-39518": {"epss_score": 0.00049, "epss_percentile": 0.15291}, "CVE-2025-39519": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39520": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39521": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39522": {"epss_score": 0.00069, "epss_percentile": 0.21585}, "CVE-2025-39523": {"epss_score": 0.00022, "epss_percentile": 0.04975}, "CVE-2025-39524": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39525": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39526": {"epss_score": 0.00158, "epss_percentile": 0.37209}, "CVE-2025-39527": {"epss_score": 0.00157, "epss_percentile": 0.37061}, "CVE-2025-39528": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-39529": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39530": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39531": {"epss_score": 0.00078, "epss_percentile": 0.2361}, "CVE-2025-39532": {"epss_score": 0.00057, "epss_percentile": 0.17999}, "CVE-2025-39533": {"epss_score": 0.00081, "epss_percentile": 0.24255}, "CVE-2025-39534": {"epss_score": 0.00021, "epss_percentile": 0.04753}, "CVE-2025-39535": {"epss_score": 0.00069, "epss_percentile": 0.21488}, "CVE-2025-39536": {"epss_score": 0.00057, "epss_percentile": 0.18041}, "CVE-2025-39537": {"epss_score": 0.00039, "epss_percentile": 0.1161}, "CVE-2025-39538": {"epss_score": 0.00071, "epss_percentile": 0.22011}, "CVE-2025-39539": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-39540": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39541": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-39542": {"epss_score": 0.00081, "epss_percentile": 0.24255}, "CVE-2025-39543": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39544": {"epss_score": 0.00021, "epss_percentile": 0.04939}, "CVE-2025-39545": {"epss_score": 0.00058, "epss_percentile": 0.18466}, "CVE-2025-39546": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-39547": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39548": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-39549": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39550": {"epss_score": 0.00134, "epss_percentile": 0.33853}, "CVE-2025-39551": {"epss_score": 0.00134, "epss_percentile": 0.33853}, "CVE-2025-39552": {"epss_score": 0.00051, "epss_percentile": 0.16064}, "CVE-2025-39553": {"epss_score": 0.00026, "epss_percentile": 0.06398}, "CVE-2025-39554": {"epss_score": 0.00074, "epss_percentile": 0.22701}, "CVE-2025-39555": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39556": {"epss_score": 0.00059, "epss_percentile": 0.18859}, "CVE-2025-39557": {"epss_score": 0.00086, "epss_percentile": 0.25424}, "CVE-2025-39558": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39559": {"epss_score": 0.0006, "epss_percentile": 0.19071}, "CVE-2025-39560": {"epss_score": 0.00069, "epss_percentile": 0.21585}, "CVE-2025-39561": {"epss_score": 0.00038, "epss_percentile": 0.1114}, "CVE-2025-39562": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-39563": {"epss_score": 0.00021, "epss_percentile": 0.04939}, "CVE-2025-39564": {"epss_score": 0.00021, "epss_percentile": 0.04939}, "CVE-2025-39565": {"epss_score": 0.00109, "epss_percentile": 0.29975}, "CVE-2025-39566": {"epss_score": 0.00049, "epss_percentile": 0.15291}, "CVE-2025-39567": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39568": {"epss_score": 0.00114, "epss_percentile": 0.30744}, "CVE-2025-39569": {"epss_score": 0.00053, "epss_percentile": 0.16675}, "CVE-2025-39570": {"epss_score": 0.00208, "epss_percentile": 0.43288}, "CVE-2025-39571": {"epss_score": 0.00053, "epss_percentile": 0.16965}, "CVE-2025-39572": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39573": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39574": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39575": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39576": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39577": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39578": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39579": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39580": {"epss_score": 0.00057, "epss_percentile": 0.18128}, "CVE-2025-39581": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39582": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39583": {"epss_score": 0.00072, "epss_percentile": 0.2232}, "CVE-2025-39584": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-39585": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39586": {"epss_score": 0.00053, "epss_percentile": 0.16675}, "CVE-2025-39587": {"epss_score": 0.00053, "epss_percentile": 0.16856}, "CVE-2025-39588": {"epss_score": 0.00134, "epss_percentile": 0.33853}, "CVE-2025-39589": {"epss_score": 0.00059, "epss_percentile": 0.18696}, "CVE-2025-39590": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-39591": {"epss_score": 0.00069, "epss_percentile": 0.21585}, "CVE-2025-39592": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-39593": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-39594": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-39595": {"epss_score": 0.00053, "epss_percentile": 0.16856}, "CVE-2025-39596": {"epss_score": 0.00078, "epss_percentile": 0.23663}, "CVE-2025-39597": {"epss_score": 0.00043, "epss_percentile": 0.13027}, "CVE-2025-39598": {"epss_score": 0.00104, "epss_percentile": 0.29174}, "CVE-2025-39599": {"epss_score": 0.00043, "epss_percentile": 0.13027}, "CVE-2025-39600": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-39601": {"epss_score": 0.0001, "epss_percentile": 0.00781}, "CVE-2025-39602": {"epss_score": 0.00053, "epss_percentile": 0.16965}, "CVE-2025-39663": {"epss_score": 0.00065, "epss_percentile": 0.20499}, "CVE-2025-39664": {"epss_score": 0.00074, "epss_percentile": 0.2272}, "CVE-2025-39665": {"epss_score": 0.00052, "epss_percentile": 0.16619}, "CVE-2025-39673": {"epss_score": 0.00018, "epss_percentile": 0.03606}, "CVE-2025-39674": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-39675": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-39676": {"epss_score": 0.00022, "epss_percentile": 0.04973}, "CVE-2025-39677": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-39678": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-39679": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-39680": {"epss_score": 0.00025, "epss_percentile": 0.06039}, "CVE-2025-39681": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-39682": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-39683": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-39684": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-39685": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-39686": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-39687": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-39688": {"epss_score": 0.00022, "epss_percentile": 0.05011}, "CVE-2025-39689": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-39690": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-39691": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-39692": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-39693": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-39694": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-39695": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-39696": {"epss_score": 0.00029, "epss_percentile": 0.07785}, "CVE-2025-39697": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-39698": {"epss_score": 0.00029, "epss_percentile": 0.07931}, "CVE-2025-39699": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-39700": {"epss_score": 0.00033, "epss_percentile": 0.09323}, "CVE-2025-39701": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-39702": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-39703": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-39704": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-39705": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-39706": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-39707": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-39708": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-39709": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-39710": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-39711": {"epss_score": 0.00023, "epss_percentile": 0.05447}, "CVE-2025-39712": {"epss_score": 0.00022, "epss_percentile": 0.04991}, "CVE-2025-39713": {"epss_score": 0.00017, "epss_percentile": 0.03171}, "CVE-2025-39714": {"epss_score": 0.00064, "epss_percentile": 0.20127}, "CVE-2025-39715": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-39716": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-39717": {"epss_score": 0.00025, "epss_percentile": 0.0616}, "CVE-2025-39718": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-39719": {"epss_score": 0.00023, "epss_percentile": 0.05472}, "CVE-2025-39720": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-39721": {"epss_score": 0.00028, "epss_percentile": 0.07229}, "CVE-2025-39722": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-39723": {"epss_score": 0.00022, "epss_percentile": 0.05323}, "CVE-2025-39724": {"epss_score": 0.00061, "epss_percentile": 0.19352}, "CVE-2025-39725": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-39726": {"epss_score": 0.00017, "epss_percentile": 0.03379}, "CVE-2025-39727": {"epss_score": 0.00023, "epss_percentile": 0.05447}, "CVE-2025-39728": {"epss_score": 0.00036, "epss_percentile": 0.10259}, "CVE-2025-39729": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-39730": {"epss_score": 0.00092, "epss_percentile": 0.26564}, "CVE-2025-39731": {"epss_score": 0.00023, "epss_percentile": 0.05367}, "CVE-2025-39732": {"epss_score": 0.00022, "epss_percentile": 0.05224}, "CVE-2025-39733": {"epss_score": 0.00022, "epss_percentile": 0.05299}, "CVE-2025-39734": {"epss_score": 0.00047, "epss_percentile": 0.14766}, "CVE-2025-39735": {"epss_score": 0.00024, "epss_percentile": 0.05748}, "CVE-2025-39736": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39737": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39738": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39739": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2025-39740": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39741": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39742": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39743": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39744": {"epss_score": 0.00018, "epss_percentile": 0.03618}, "CVE-2025-39745": {"epss_score": 0.00016, "epss_percentile": 0.02938}, "CVE-2025-39746": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2025-39747": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2025-39748": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2025-39749": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39750": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2025-39752": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39753": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2025-39754": {"epss_score": 0.00013, "epss_percentile": 0.01703}, "CVE-2025-39755": {"epss_score": 0.00017, "epss_percentile": 0.03057}, "CVE-2025-39756": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39757": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39758": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2025-39759": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39760": {"epss_score": 0.00082, "epss_percentile": 0.24473}, "CVE-2025-39761": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2025-39762": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39763": {"epss_score": 0.00017, "epss_percentile": 0.03422}, "CVE-2025-39764": {"epss_score": 0.00018, "epss_percentile": 0.03799}, "CVE-2025-39765": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39766": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39767": {"epss_score": 0.00013, "epss_percentile": 0.01703}, "CVE-2025-39768": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39769": {"epss_score": 0.00015, "epss_percentile": 0.02313}, "CVE-2025-39770": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39771": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39772": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39773": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39774": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39775": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39776": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39777": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39778": {"epss_score": 0.00022, "epss_percentile": 0.05311}, "CVE-2025-39779": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39780": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39781": {"epss_score": 0.00016, "epss_percentile": 0.02885}, "CVE-2025-39782": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39783": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39784": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39785": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39786": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39787": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39788": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39789": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39790": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39791": {"epss_score": 0.00014, "epss_percentile": 0.01851}, "CVE-2025-39792": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2025-39793": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2025-39794": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39795": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39796": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2025-39797": {"epss_score": 0.00017, "epss_percentile": 0.03481}, "CVE-2025-39798": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39800": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39801": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39802": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39803": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39804": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39805": {"epss_score": 0.00018, "epss_percentile": 0.03538}, "CVE-2025-39806": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39807": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39808": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39809": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39810": {"epss_score": 0.00021, "epss_percentile": 0.04692}, "CVE-2025-39811": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39812": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39813": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39814": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39815": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39816": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39817": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39818": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39819": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39820": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39821": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39822": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39823": {"epss_score": 0.00047, "epss_percentile": 0.14781}, "CVE-2025-39824": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39825": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39826": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39827": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39828": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39829": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39830": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39831": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39832": {"epss_score": 0.00013, "epss_percentile": 0.01703}, "CVE-2025-39833": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39834": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39835": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39836": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2025-39837": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39838": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-39839": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39840": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39841": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39842": {"epss_score": 0.00035, "epss_percentile": 0.10072}, "CVE-2025-39843": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39844": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39845": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39846": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39847": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39848": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39849": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39850": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39851": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39852": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39853": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39854": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2025-39855": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39856": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39857": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39858": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39859": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39860": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39861": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2025-39862": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39863": {"epss_score": 0.00018, "epss_percentile": 0.03853}, "CVE-2025-39864": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39865": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39866": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39868": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39869": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39870": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39871": {"epss_score": 0.00021, "epss_percentile": 0.04794}, "CVE-2025-39872": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39873": {"epss_score": 0.00035, "epss_percentile": 0.10072}, "CVE-2025-39874": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39875": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39876": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39877": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39878": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39879": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39880": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39881": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39882": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2025-39883": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39884": {"epss_score": 0.00014, "epss_percentile": 0.01767}, "CVE-2025-39885": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39886": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2025-39887": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39888": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-39889": {"epss_score": 5e-05, "epss_percentile": 0.00183}, "CVE-2025-39890": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2025-39891": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39892": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39893": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39894": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39895": {"epss_score": 0.00017, "epss_percentile": 0.03371}, "CVE-2025-39896": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2025-39897": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39899": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39900": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39901": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2025-39902": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39903": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39904": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39905": {"epss_score": 0.00014, "epss_percentile": 0.01963}, "CVE-2025-39906": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39907": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39908": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39909": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39910": {"epss_score": 0.00015, "epss_percentile": 0.02313}, "CVE-2025-39911": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39912": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39913": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39914": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39915": {"epss_score": 0.00015, "epss_percentile": 0.02313}, "CVE-2025-39916": {"epss_score": 0.00036, "epss_percentile": 0.10603}, "CVE-2025-39917": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2025-39918": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39919": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39920": {"epss_score": 0.00049, "epss_percentile": 0.15541}, "CVE-2025-39921": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39922": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2025-39923": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39924": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39925": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39926": {"epss_score": 0.00017, "epss_percentile": 0.03478}, "CVE-2025-39927": {"epss_score": 0.00014, "epss_percentile": 0.01767}, "CVE-2025-39928": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-39929": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-39930": {"epss_score": 0.00025, "epss_percentile": 0.06096}, "CVE-2025-39931": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-39932": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-39933": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39934": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39935": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39936": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39937": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39938": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-39939": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39940": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-39941": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39942": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-39943": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39944": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-39945": {"epss_score": 0.00069, "epss_percentile": 0.21619}, "CVE-2025-39946": {"epss_score": 0.00021, "epss_percentile": 0.0486}, "CVE-2025-39947": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-39948": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-39949": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39950": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-39951": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39952": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-39953": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39954": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39955": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39956": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-39957": {"epss_score": 0.00033, "epss_percentile": 0.092}, "CVE-2025-39958": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39959": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39960": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39961": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-39962": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39963": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-39964": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39965": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-39966": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-39967": {"epss_score": 0.00065, "epss_percentile": 0.20668}, "CVE-2025-39968": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39969": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39970": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39971": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39972": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39973": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39974": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39975": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-39976": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39977": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-39978": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-39979": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39980": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-39981": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-39982": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-39983": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-39984": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-39985": {"epss_score": 0.00065, "epss_percentile": 0.20668}, "CVE-2025-39986": {"epss_score": 0.00065, "epss_percentile": 0.20668}, "CVE-2025-39987": {"epss_score": 0.00065, "epss_percentile": 0.20668}, "CVE-2025-39988": {"epss_score": 0.00065, "epss_percentile": 0.20668}, "CVE-2025-39989": {"epss_score": 0.00021, "epss_percentile": 0.04829}, "CVE-2025-39990": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-39991": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-39992": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-39993": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39994": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39995": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39996": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-39997": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2025-39998": {"epss_score": 0.00169, "epss_percentile": 0.38556}, "CVE-2025-39999": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-3000": {"epss_score": 0.00036, "epss_percentile": 0.10208}, "CVE-2025-3001": {"epss_score": 0.00036, "epss_percentile": 0.10208}, "CVE-2025-3002": {"epss_score": 0.00812, "epss_percentile": 0.7374}, "CVE-2025-3003": {"epss_score": 0.00041, "epss_percentile": 0.12434}, "CVE-2025-3004": {"epss_score": 0.00052, "epss_percentile": 0.16498}, "CVE-2025-3005": {"epss_score": 0.00052, "epss_percentile": 0.16498}, "CVE-2025-3006": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3007": {"epss_score": 0.00025, "epss_percentile": 0.06247}, "CVE-2025-3008": {"epss_score": 0.00202, "epss_percentile": 0.42396}, "CVE-2025-3009": {"epss_score": 0.00041, "epss_percentile": 0.12434}, "CVE-2025-3010": {"epss_score": 0.00026, "epss_percentile": 0.06624}, "CVE-2025-3011": {"epss_score": 0.00178, "epss_percentile": 0.39663}, "CVE-2025-3012": {"epss_score": 0.00167, "epss_percentile": 0.38334}, "CVE-2025-3013": {"epss_score": 0.00077, "epss_percentile": 0.23404}, "CVE-2025-3014": {"epss_score": 0.00077, "epss_percentile": 0.23404}, "CVE-2025-3015": {"epss_score": 0.00155, "epss_percentile": 0.36821}, "CVE-2025-3016": {"epss_score": 0.00187, "epss_percentile": 0.40712}, "CVE-2025-3017": {"epss_score": 0.00026, "epss_percentile": 0.06631}, "CVE-2025-3018": {"epss_score": 0.00045, "epss_percentile": 0.13943}, "CVE-2025-3019": {"epss_score": 0.00072, "epss_percentile": 0.22366}, "CVE-2025-3020": {"epss_score": 0.00031, "epss_percentile": 0.08453}, "CVE-2025-3021": {"epss_score": 0.00167, "epss_percentile": 0.38397}, "CVE-2025-3022": {"epss_score": 0.00421, "epss_percentile": 0.61524}, "CVE-2025-3025": {"epss_score": 0.00018, "epss_percentile": 0.03564}, "CVE-2025-3026": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-3027": {"epss_score": 0.00041, "epss_percentile": 0.12461}, "CVE-2025-3028": {"epss_score": 0.00294, "epss_percentile": 0.52392}, "CVE-2025-3029": {"epss_score": 0.00166, "epss_percentile": 0.38233}, "CVE-2025-3030": {"epss_score": 0.00111, "epss_percentile": 0.30253}, "CVE-2025-3031": {"epss_score": 0.00071, "epss_percentile": 0.22228}, "CVE-2025-3032": {"epss_score": 0.00061, "epss_percentile": 0.19251}, "CVE-2025-3033": {"epss_score": 0.00028, "epss_percentile": 0.07311}, "CVE-2025-3034": {"epss_score": 0.00082, "epss_percentile": 0.24419}, "CVE-2025-3035": {"epss_score": 0.00078, "epss_percentile": 0.23726}, "CVE-2025-3036": {"epss_score": 0.00062, "epss_percentile": 0.19731}, "CVE-2025-3037": {"epss_score": 0.00029, "epss_percentile": 0.07755}, "CVE-2025-3038": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3039": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3040": {"epss_score": 0.00106, "epss_percentile": 0.29537}, "CVE-2025-3041": {"epss_score": 0.00106, "epss_percentile": 0.29537}, "CVE-2025-3042": {"epss_score": 0.00106, "epss_percentile": 0.29537}, "CVE-2025-3043": {"epss_score": 0.00099, "epss_percentile": 0.28403}, "CVE-2025-3044": {"epss_score": 0.00042, "epss_percentile": 0.12888}, "CVE-2025-3045": {"epss_score": 0.0007, "epss_percentile": 0.21968}, "CVE-2025-3046": {"epss_score": 0.00085, "epss_percentile": 0.25042}, "CVE-2025-3047": {"epss_score": 0.00028, "epss_percentile": 0.07294}, "CVE-2025-3048": {"epss_score": 0.00022, "epss_percentile": 0.05181}, "CVE-2025-3050": {"epss_score": 0.0004, "epss_percentile": 0.12003}, "CVE-2025-3051": {"epss_score": 0.00141, "epss_percentile": 0.34854}, "CVE-2025-3052": {"epss_score": 0.00019, "epss_percentile": 0.04377}, "CVE-2025-3053": {"epss_score": 0.00522, "epss_percentile": 0.66275}, "CVE-2025-3054": {"epss_score": 0.00301, "epss_percentile": 0.53011}, "CVE-2025-3055": {"epss_score": 0.01215, "epss_percentile": 0.78582}, "CVE-2025-3056": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-3057": {"epss_score": 0.00089, "epss_percentile": 0.25967}, "CVE-2025-3058": {"epss_score": 0.00081, "epss_percentile": 0.24255}, "CVE-2025-3059": {"epss_score": 0.00066, "epss_percentile": 0.20848}, "CVE-2025-3060": {"epss_score": 0.00072, "epss_percentile": 0.22443}, "CVE-2025-3061": {"epss_score": 0.00058, "epss_percentile": 0.18275}, "CVE-2025-3062": {"epss_score": 0.00058, "epss_percentile": 0.18275}, "CVE-2025-3063": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2025-3064": {"epss_score": 0.00042, "epss_percentile": 0.12581}, "CVE-2025-3065": {"epss_score": 0.02257, "epss_percentile": 0.84176}, "CVE-2025-3066": {"epss_score": 0.00095, "epss_percentile": 0.27082}, "CVE-2025-3067": {"epss_score": 0.00061, "epss_percentile": 0.19344}, "CVE-2025-3068": {"epss_score": 0.00084, "epss_percentile": 0.24828}, "CVE-2025-3069": {"epss_score": 0.00087, "epss_percentile": 0.25527}, "CVE-2025-3070": {"epss_score": 0.00082, "epss_percentile": 0.24513}, "CVE-2025-3071": {"epss_score": 0.00013, "epss_percentile": 0.01518}, "CVE-2025-3072": {"epss_score": 0.00064, "epss_percentile": 0.20307}, "CVE-2025-3073": {"epss_score": 0.00064, "epss_percentile": 0.20307}, "CVE-2025-3074": {"epss_score": 0.00064, "epss_percentile": 0.20307}, "CVE-2025-3075": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-3076": {"epss_score": 0.00025, "epss_percentile": 0.06378}, "CVE-2025-3077": {"epss_score": 0.00036, "epss_percentile": 0.10245}, "CVE-2025-3078": {"epss_score": 0.00051, "epss_percentile": 0.1607}, "CVE-2025-3079": {"epss_score": 0.00051, "epss_percentile": 0.1607}, "CVE-2025-3082": {"epss_score": 0.00059, "epss_percentile": 0.18689}, "CVE-2025-3083": {"epss_score": 0.00065, "epss_percentile": 0.20523}, "CVE-2025-3084": {"epss_score": 0.00156, "epss_percentile": 0.36936}, "CVE-2025-3085": {"epss_score": 0.00049, "epss_percentile": 0.15609}, "CVE-2025-3086": {"epss_score": 0.00109, "epss_percentile": 0.29917}, "CVE-2025-3087": {"epss_score": 0.00046, "epss_percentile": 0.14202}, "CVE-2025-3089": {"epss_score": 0.00074, "epss_percentile": 0.22733}, "CVE-2025-3090": {"epss_score": 0.00155, "epss_percentile": 0.36815}, "CVE-2025-3091": {"epss_score": 0.00111, "epss_percentile": 0.30337}, "CVE-2025-3092": {"epss_score": 0.00058, "epss_percentile": 0.18369}, "CVE-2025-3096": {"epss_score": 0.33305, "epss_percentile": 0.96762}, "CVE-2025-3097": {"epss_score": 0.0009, "epss_percentile": 0.26134}, "CVE-2025-3098": {"epss_score": 0.00301, "epss_percentile": 0.53003}, "CVE-2025-3099": {"epss_score": 0.00032, "epss_percentile": 0.0879}, "CVE-2025-3100": {"epss_score": 0.00024, "epss_percentile": 0.05841}, "CVE-2025-3101": {"epss_score": 0.00081, "epss_percentile": 0.24255}, "CVE-2025-3102": {"epss_score": 0.84446, "epss_percentile": 0.99289}, "CVE-2025-3103": {"epss_score": 0.00109, "epss_percentile": 0.29984}, "CVE-2025-3104": {"epss_score": 0.00091, "epss_percentile": 0.26376}, "CVE-2025-3105": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2025-3106": {"epss_score": 0.00059, "epss_percentile": 0.18865}, "CVE-2025-3107": {"epss_score": 0.00041, "epss_percentile": 0.12321}, "CVE-2025-3108": {"epss_score": 0.00541, "epss_percentile": 0.67027}, "CVE-2025-3111": {"epss_score": 0.00174, "epss_percentile": 0.39147}, "CVE-2025-3112": {"epss_score": 0.00106, "epss_percentile": 0.29553}, "CVE-2025-3113": {"epss_score": 0.00075, "epss_percentile": 0.23001}, "CVE-2025-3114": {"epss_score": 0.00189, "epss_percentile": 0.40991}, "CVE-2025-3115": {"epss_score": 0.00281, "epss_percentile": 0.51117}, "CVE-2025-3116": {"epss_score": 0.00121, "epss_percentile": 0.31892}, "CVE-2025-3117": {"epss_score": 0.00025, "epss_percentile": 0.06378}, "CVE-2025-3118": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3119": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3120": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3121": {"epss_score": 0.00035, "epss_percentile": 0.09806}, "CVE-2025-3122": {"epss_score": 0.00261, "epss_percentile": 0.49265}, "CVE-2025-3123": {"epss_score": 0.00206, "epss_percentile": 0.42934}, "CVE-2025-3124": {"epss_score": 0.00058, "epss_percentile": 0.18298}, "CVE-2025-3125": {"epss_score": 0.00258, "epss_percentile": 0.49018}, "CVE-2025-3128": {"epss_score": 0.00123, "epss_percentile": 0.32258}, "CVE-2025-3129": {"epss_score": 0.00033, "epss_percentile": 0.09344}, "CVE-2025-3130": {"epss_score": 0.00046, "epss_percentile": 0.14202}, "CVE-2025-3131": {"epss_score": 0.00027, "epss_percentile": 0.06883}, "CVE-2025-3134": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3135": {"epss_score": 0.00068, "epss_percentile": 0.21346}, "CVE-2025-3136": {"epss_score": 0.00054, "epss_percentile": 0.17343}, "CVE-2025-3137": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3138": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3139": {"epss_score": 0.00027, "epss_percentile": 0.07169}, "CVE-2025-3140": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3141": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3142": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3143": {"epss_score": 0.00085, "epss_percentile": 0.25157}, "CVE-2025-3144": {"epss_score": 0.00029, "epss_percentile": 0.07772}, "CVE-2025-3145": {"epss_score": 0.00023, "epss_percentile": 0.05613}, "CVE-2025-3146": {"epss_score": 0.00095, "epss_percentile": 0.27126}, "CVE-2025-3147": {"epss_score": 0.00061, "epss_percentile": 0.19353}, "CVE-2025-3148": {"epss_score": 0.0003, "epss_percentile": 0.08245}, "CVE-2025-3149": {"epss_score": 0.00057, "epss_percentile": 0.18191}, "CVE-2025-3150": {"epss_score": 0.00061, "epss_percentile": 0.19473}, "CVE-2025-3151": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3152": {"epss_score": 0.00047, "epss_percentile": 0.14772}, "CVE-2025-3153": {"epss_score": 0.00035, "epss_percentile": 0.10013}, "CVE-2025-3154": {"epss_score": 0.00024, "epss_percentile": 0.06019}, "CVE-2025-3155": {"epss_score": 0.00211, "epss_percentile": 0.43702}, "CVE-2025-3157": {"epss_score": 0.00037, "epss_percentile": 0.10762}, "CVE-2025-3158": {"epss_score": 0.00047, "epss_percentile": 0.14711}, "CVE-2025-3159": {"epss_score": 0.00041, "epss_percentile": 0.12253}, "CVE-2025-3160": {"epss_score": 0.00035, "epss_percentile": 0.09882}, "CVE-2025-3161": {"epss_score": 0.00274, "epss_percentile": 0.50527}, "CVE-2025-3162": {"epss_score": 0.0007, "epss_percentile": 0.21655}, "CVE-2025-3163": {"epss_score": 0.00041, "epss_percentile": 0.1224}, "CVE-2025-3164": {"epss_score": 0.00084, "epss_percentile": 0.24933}, "CVE-2025-3165": {"epss_score": 0.0007, "epss_percentile": 0.21723}, "CVE-2025-3166": {"epss_score": 0.0003, "epss_percentile": 0.0821}, "CVE-2025-3167": {"epss_score": 0.00111, "epss_percentile": 0.30322}, "CVE-2025-3168": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3169": {"epss_score": 0.00065, "epss_percentile": 0.20573}, "CVE-2025-3170": {"epss_score": 0.00056, "epss_percentile": 0.17738}, "CVE-2025-3171": {"epss_score": 0.00078, "epss_percentile": 0.23789}, "CVE-2025-3172": {"epss_score": 0.00065, "epss_percentile": 0.20591}, "CVE-2025-3173": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3174": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3175": {"epss_score": 0.00065, "epss_percentile": 0.20591}, "CVE-2025-3176": {"epss_score": 0.00065, "epss_percentile": 0.20591}, "CVE-2025-3177": {"epss_score": 0.00106, "epss_percentile": 0.29537}, "CVE-2025-3178": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3179": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3180": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3181": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3182": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3183": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3184": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3185": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3186": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3187": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3188": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3189": {"epss_score": 0.00081, "epss_percentile": 0.24342}, "CVE-2025-3191": {"epss_score": 0.00043, "epss_percentile": 0.12947}, "CVE-2025-3192": {"epss_score": 0.00075, "epss_percentile": 0.22894}, "CVE-2025-3193": {"epss_score": 0.00073, "epss_percentile": 0.22486}, "CVE-2025-3194": {"epss_score": 0.00096, "epss_percentile": 0.27297}, "CVE-2025-3195": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3196": {"epss_score": 0.00042, "epss_percentile": 0.127}, "CVE-2025-3197": {"epss_score": 0.00144, "epss_percentile": 0.35298}, "CVE-2025-3198": {"epss_score": 0.00025, "epss_percentile": 0.06346}, "CVE-2025-3199": {"epss_score": 0.00204, "epss_percentile": 0.42654}, "CVE-2025-3200": {"epss_score": 0.00027, "epss_percentile": 0.0698}, "CVE-2025-3201": {"epss_score": 0.00038, "epss_percentile": 0.11186}, "CVE-2025-3202": {"epss_score": 0.0012, "epss_percentile": 0.31691}, "CVE-2025-3203": {"epss_score": 0.00105, "epss_percentile": 0.29384}, "CVE-2025-3204": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3205": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3206": {"epss_score": 0.00045, "epss_percentile": 0.13943}, "CVE-2025-3207": {"epss_score": 0.00045, "epss_percentile": 0.13943}, "CVE-2025-3208": {"epss_score": 0.00045, "epss_percentile": 0.13943}, "CVE-2025-3209": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3210": {"epss_score": 0.00045, "epss_percentile": 0.13943}, "CVE-2025-3211": {"epss_score": 0.00045, "epss_percentile": 0.13943}, "CVE-2025-3212": {"epss_score": 0.00079, "epss_percentile": 0.23986}, "CVE-2025-3213": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3214": {"epss_score": 0.00083, "epss_percentile": 0.24741}, "CVE-2025-3215": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3216": {"epss_score": 0.00087, "epss_percentile": 0.25554}, "CVE-2025-3217": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3218": {"epss_score": 0.00035, "epss_percentile": 0.09852}, "CVE-2025-3219": {"epss_score": 0.00049, "epss_percentile": 0.15367}, "CVE-2025-3220": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3221": {"epss_score": 0.00112, "epss_percentile": 0.30414}, "CVE-2025-3222": {"epss_score": 0.00069, "epss_percentile": 0.21548}, "CVE-2025-3223": {"epss_score": 0.00022, "epss_percentile": 0.05034}, "CVE-2025-3224": {"epss_score": 0.00011, "epss_percentile": 0.00955}, "CVE-2025-3225": {"epss_score": 0.0012, "epss_percentile": 0.31795}, "CVE-2025-3227": {"epss_score": 0.00036, "epss_percentile": 0.10346}, "CVE-2025-3228": {"epss_score": 0.00039, "epss_percentile": 0.1155}, "CVE-2025-3229": {"epss_score": 0.00061, "epss_percentile": 0.19311}, "CVE-2025-3230": {"epss_score": 0.00042, "epss_percentile": 0.12628}, "CVE-2025-3231": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3232": {"epss_score": 0.00089, "epss_percentile": 0.25914}, "CVE-2025-3234": {"epss_score": 0.00281, "epss_percentile": 0.51197}, "CVE-2025-3235": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3236": {"epss_score": 0.00235, "epss_percentile": 0.46219}, "CVE-2025-3237": {"epss_score": 0.0022, "epss_percentile": 0.44577}, "CVE-2025-3238": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3239": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3240": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3241": {"epss_score": 0.00058, "epss_percentile": 0.1847}, "CVE-2025-3242": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3243": {"epss_score": 0.00019, "epss_percentile": 0.0408}, "CVE-2025-3244": {"epss_score": 0.00098, "epss_percentile": 0.27785}, "CVE-2025-3245": {"epss_score": 0.00059, "epss_percentile": 0.18758}, "CVE-2025-3246": {"epss_score": 0.00045, "epss_percentile": 0.13738}, "CVE-2025-3247": {"epss_score": 0.00068, "epss_percentile": 0.21203}, "CVE-2025-3248": {"epss_score": 0.91417, "epss_percentile": 0.99641}, "CVE-2025-3249": {"epss_score": 0.02502, "epss_percentile": 0.84925}, "CVE-2025-3250": {"epss_score": 0.00103, "epss_percentile": 0.28987}, "CVE-2025-3251": {"epss_score": 0.00049, "epss_percentile": 0.15367}, "CVE-2025-3252": {"epss_score": 0.00048, "epss_percentile": 0.15139}, "CVE-2025-3253": {"epss_score": 0.00048, "epss_percentile": 0.15139}, "CVE-2025-3254": {"epss_score": 0.00106, "epss_percentile": 0.29537}, "CVE-2025-3255": {"epss_score": 0.0006, "epss_percentile": 0.19152}, "CVE-2025-3256": {"epss_score": 0.00049, "epss_percentile": 0.15615}, "CVE-2025-3257": {"epss_score": 0.00079, "epss_percentile": 0.23981}, "CVE-2025-3258": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3259": {"epss_score": 0.007, "epss_percentile": 0.71465}, "CVE-2025-3260": {"epss_score": 0.0002, "epss_percentile": 0.0468}, "CVE-2025-3262": {"epss_score": 0.00111, "epss_percentile": 0.30332}, "CVE-2025-3263": {"epss_score": 0.00117, "epss_percentile": 0.31335}, "CVE-2025-3264": {"epss_score": 0.00117, "epss_percentile": 0.31335}, "CVE-2025-3265": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3266": {"epss_score": 0.0016, "epss_percentile": 0.37511}, "CVE-2025-3267": {"epss_score": 0.00075, "epss_percentile": 0.23015}, "CVE-2025-3268": {"epss_score": 0.00099, "epss_percentile": 0.28312}, "CVE-2025-3272": {"epss_score": 0.00021, "epss_percentile": 0.04884}, "CVE-2025-3275": {"epss_score": 0.00048, "epss_percentile": 0.14943}, "CVE-2025-3276": {"epss_score": 0.0004, "epss_percentile": 0.12042}, "CVE-2025-3277": {"epss_score": 0.00243, "epss_percentile": 0.47468}, "CVE-2025-3278": {"epss_score": 0.00267, "epss_percentile": 0.4997}, "CVE-2025-3279": {"epss_score": 0.00051, "epss_percentile": 0.16175}, "CVE-2025-3280": {"epss_score": 0.00046, "epss_percentile": 0.1416}, "CVE-2025-3281": {"epss_score": 0.00059, "epss_percentile": 0.18922}, "CVE-2025-3282": {"epss_score": 0.00096, "epss_percentile": 0.27242}, "CVE-2025-3284": {"epss_score": 0.00023, "epss_percentile": 0.05462}, "CVE-2025-3285": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2025-3286": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2025-3287": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2025-3288": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2025-3289": {"epss_score": 0.00034, "epss_percentile": 0.09681}, "CVE-2025-3292": {"epss_score": 0.0008, "epss_percentile": 0.24094}, "CVE-2025-3294": {"epss_score": 0.0088, "epss_percentile": 0.7485}, "CVE-2025-3295": {"epss_score": 0.00112, "epss_percentile": 0.30417}, "CVE-2025-3296": {"epss_score": 0.00044, "epss_percentile": 0.13546}, "CVE-2025-3297": {"epss_score": 0.00067, "epss_percentile": 0.21106}, "CVE-2025-3298": {"epss_score": 0.00065, "epss_percentile": 0.20439}, "CVE-2025-3299": {"epss_score": 0.00048, "epss_percentile": 0.15173}, "CVE-2025-3300": {"epss_score": 0.0049, "epss_percentile": 0.64941}, "CVE-2025-3301": {"epss_score": 0.00029, "epss_percentile": 0.07847}, "CVE-2025-3302": {"epss_score": 0.00467, "epss_percentile": 0.63852}, "CVE-2025-3303": {"epss_score": 0.00045, "epss_percentile": 0.13943}, "CVE-2025-3304": {"epss_score": 0.00062, "epss_percentile": 0.19718}, "CVE-2025-3305": {"epss_score": 0.00061, "epss_percentile": 0.19546}, "CVE-2025-3306": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3307": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3308": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3309": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3310": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3311": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3312": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3313": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3314": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3315": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3316": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3317": {"epss_score": 0.0015, "epss_percentile": 0.3605}, "CVE-2025-3318": {"epss_score": 0.00031, "epss_percentile": 0.08665}, "CVE-2025-3319": {"epss_score": 0.00042, "epss_percentile": 0.12764}, "CVE-2025-3320": {"epss_score": 0.001, "epss_percentile": 0.28475}, "CVE-2025-3321": {"epss_score": 0.00021, "epss_percentile": 0.04884}, "CVE-2025-3322": {"epss_score": 0.00462, "epss_percentile": 0.63623}, "CVE-2025-3323": {"epss_score": 0.0007, "epss_percentile": 0.21968}, "CVE-2025-3324": {"epss_score": 0.00101, "epss_percentile": 0.28625}, "CVE-2025-3325": {"epss_score": 0.00061, "epss_percentile": 0.19546}, "CVE-2025-3326": {"epss_score": 0.00042, "epss_percentile": 0.12562}, "CVE-2025-3327": {"epss_score": 0.00038, "epss_percentile": 0.11277}, "CVE-2025-3328": {"epss_score": 0.00373, "epss_percentile": 0.58496}, "CVE-2025-3329": {"epss_score": 0.00027, "epss_percentile": 0.06898}, "CVE-2025-3330": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3331": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3332": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3333": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3334": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3335": {"epss_score": 0.00046, "epss_percentile": 0.14266}, "CVE-2025-3336": {"epss_score": 0.00046, "epss_percentile": 0.14266}, "CVE-2025-3337": {"epss_score": 0.00046, "epss_percentile": 0.14266}, "CVE-2025-3338": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3339": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3340": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3341": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3342": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3343": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3344": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3345": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3346": {"epss_score": 0.00632, "epss_percentile": 0.69737}, "CVE-2025-3347": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3348": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3349": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2025-3350": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3351": {"epss_score": 0.00059, "epss_percentile": 0.1893}, "CVE-2025-3352": {"epss_score": 0.00059, "epss_percentile": 0.1893}, "CVE-2025-3353": {"epss_score": 0.00048, "epss_percentile": 0.15173}, "CVE-2025-3354": {"epss_score": 0.001, "epss_percentile": 0.28475}, "CVE-2025-3355": {"epss_score": 0.00079, "epss_percentile": 0.2391}, "CVE-2025-3356": {"epss_score": 0.00237, "epss_percentile": 0.46464}, "CVE-2025-3357": {"epss_score": 0.00263, "epss_percentile": 0.49518}, "CVE-2025-3359": {"epss_score": 0.00028, "epss_percentile": 0.07258}, "CVE-2025-3360": {"epss_score": 0.00108, "epss_percentile": 0.29804}, "CVE-2025-3361": {"epss_score": 0.00413, "epss_percentile": 0.60961}, "CVE-2025-3362": {"epss_score": 0.00413, "epss_percentile": 0.60961}, "CVE-2025-3363": {"epss_score": 0.00413, "epss_percentile": 0.60961}, "CVE-2025-3364": {"epss_score": 0.00027, "epss_percentile": 0.06811}, "CVE-2025-3365": {"epss_score": 0.00118, "epss_percentile": 0.31466}, "CVE-2025-3369": {"epss_score": 0.0007, "epss_percentile": 0.21968}, "CVE-2025-3370": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3371": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2025-3372": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2025-3373": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2025-3374": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2025-3375": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2025-3376": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2025-3377": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2025-3378": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2025-3379": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2025-3380": {"epss_score": 0.00156, "epss_percentile": 0.36948}, "CVE-2025-3381": {"epss_score": 0.00228, "epss_percentile": 0.45535}, "CVE-2025-3382": {"epss_score": 0.00041, "epss_percentile": 0.12434}, "CVE-2025-3383": {"epss_score": 0.00071, "epss_percentile": 0.22049}, "CVE-2025-3384": {"epss_score": 0.00066, "epss_percentile": 0.20923}, "CVE-2025-3385": {"epss_score": 0.00045, "epss_percentile": 0.1383}, "CVE-2025-3386": {"epss_score": 0.00045, "epss_percentile": 0.1383}, "CVE-2025-3387": {"epss_score": 0.00036, "epss_percentile": 0.10316}, "CVE-2025-3388": {"epss_score": 0.00049, "epss_percentile": 0.15494}, "CVE-2025-3389": {"epss_score": 0.00036, "epss_percentile": 0.10316}, "CVE-2025-3390": {"epss_score": 0.00036, "epss_percentile": 0.10316}, "CVE-2025-3391": {"epss_score": 0.00038, "epss_percentile": 0.11202}, "CVE-2025-3392": {"epss_score": 0.00036, "epss_percentile": 0.10316}, "CVE-2025-3393": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-3394": {"epss_score": 0.0002, "epss_percentile": 0.04425}, "CVE-2025-3395": {"epss_score": 0.0001, "epss_percentile": 0.00895}, "CVE-2025-3396": {"epss_score": 0.00015, "epss_percentile": 0.0248}, "CVE-2025-3397": {"epss_score": 0.00069, "epss_percentile": 0.21491}, "CVE-2025-3398": {"epss_score": 0.00098, "epss_percentile": 0.27772}, "CVE-2025-3399": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3400": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3401": {"epss_score": 0.00073, "epss_percentile": 0.22522}, "CVE-2025-3402": {"epss_score": 0.00044, "epss_percentile": 0.13438}, "CVE-2025-3403": {"epss_score": 0.00055, "epss_percentile": 0.17532}, "CVE-2025-3404": {"epss_score": 0.0076, "epss_percentile": 0.72798}, "CVE-2025-3405": {"epss_score": 0.00048, "epss_percentile": 0.15242}, "CVE-2025-3406": {"epss_score": 0.0005, "epss_percentile": 0.1598}, "CVE-2025-3407": {"epss_score": 0.00062, "epss_percentile": 0.19748}, "CVE-2025-3408": {"epss_score": 0.00062, "epss_percentile": 0.19748}, "CVE-2025-3409": {"epss_score": 0.00062, "epss_percentile": 0.19748}, "CVE-2025-3410": {"epss_score": 0.00105, "epss_percentile": 0.29271}, "CVE-2025-3411": {"epss_score": 0.00061, "epss_percentile": 0.19356}, "CVE-2025-3412": {"epss_score": 0.00061, "epss_percentile": 0.19356}, "CVE-2025-3413": {"epss_score": 0.00143, "epss_percentile": 0.35163}, "CVE-2025-3414": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-3415": {"epss_score": 0.00243, "epss_percentile": 0.47475}, "CVE-2025-3416": {"epss_score": 0.00114, "epss_percentile": 0.30871}, "CVE-2025-3417": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2025-3418": {"epss_score": 0.00083, "epss_percentile": 0.24637}, "CVE-2025-3419": {"epss_score": 0.00044, "epss_percentile": 0.13617}, "CVE-2025-3421": {"epss_score": 0.00217, "epss_percentile": 0.44325}, "CVE-2025-3422": {"epss_score": 0.00113, "epss_percentile": 0.30686}, "CVE-2025-3423": {"epss_score": 0.00036, "epss_percentile": 0.10354}, "CVE-2025-3424": {"epss_score": 0.00052, "epss_percentile": 0.16459}, "CVE-2025-3425": {"epss_score": 0.01917, "epss_percentile": 0.8287}, "CVE-2025-3426": {"epss_score": 0.00033, "epss_percentile": 0.09372}, "CVE-2025-3427": {"epss_score": 0.00136, "epss_percentile": 0.34136}, "CVE-2025-3428": {"epss_score": 0.00136, "epss_percentile": 0.34136}, "CVE-2025-3429": {"epss_score": 0.00136, "epss_percentile": 0.34136}, "CVE-2025-3430": {"epss_score": 0.00136, "epss_percentile": 0.34136}, "CVE-2025-3431": {"epss_score": 0.00222, "epss_percentile": 0.44725}, "CVE-2025-3432": {"epss_score": 0.00053, "epss_percentile": 0.16992}, "CVE-2025-3433": {"epss_score": 0.0007, "epss_percentile": 0.2171}, "CVE-2025-3434": {"epss_score": 0.00449, "epss_percentile": 0.63053}, "CVE-2025-3435": {"epss_score": 0.0004, "epss_percentile": 0.12105}, "CVE-2025-3436": {"epss_score": 0.00051, "epss_percentile": 0.16141}, "CVE-2025-3437": {"epss_score": 0.00052, "epss_percentile": 0.1636}, "CVE-2025-3438": {"epss_score": 0.0017, "epss_percentile": 0.38762}, "CVE-2025-3439": {"epss_score": 0.02593, "epss_percentile": 0.85186}, "CVE-2025-3440": {"epss_score": 0.00024, "epss_percentile": 0.05977}, "CVE-2025-3442": {"epss_score": 0.00017, "epss_percentile": 0.03093}, "CVE-2025-3444": {"epss_score": 0.00198, "epss_percentile": 0.42083}, "CVE-2025-3445": {"epss_score": 0.0022, "epss_percentile": 0.44565}, "CVE-2025-3446": {"epss_score": 0.00041, "epss_percentile": 0.12239}, "CVE-2025-3448": {"epss_score": 0.0005, "epss_percentile": 0.15687}, "CVE-2025-3449": {"epss_score": 0.00037, "epss_percentile": 0.10987}, "CVE-2025-3450": {"epss_score": 0.00046, "epss_percentile": 0.14306}, "CVE-2025-3452": {"epss_score": 0.00037, "epss_percentile": 0.10972}, "CVE-2025-3453": {"epss_score": 0.00097, "epss_percentile": 0.27561}, "CVE-2025-3454": {"epss_score": 0.00011, "epss_percentile": 0.00948}, "CVE-2025-3455": {"epss_score": 0.00405, "epss_percentile": 0.6048}, "CVE-2025-3456": {"epss_score": 0.0001, "epss_percentile": 0.00826}, "CVE-2025-3457": {"epss_score": 0.00051, "epss_percentile": 0.16329}, "CVE-2025-3458": {"epss_score": 0.00046, "epss_percentile": 0.14283}, "CVE-2025-3459": {"epss_score": 0.00087, "epss_percentile": 0.25482}, "CVE-2025-3460": {"epss_score": 0.00087, "epss_percentile": 0.25482}, "CVE-2025-3461": {"epss_score": 0.00077, "epss_percentile": 0.2339}, "CVE-2025-3462": {"epss_score": 0.00072, "epss_percentile": 0.22247}, "CVE-2025-3463": {"epss_score": 0.00114, "epss_percentile": 0.30843}, "CVE-2025-3464": {"epss_score": 0.00025, "epss_percentile": 0.06357}, "CVE-2025-3465": {"epss_score": 0.0002, "epss_percentile": 0.04654}, "CVE-2025-3466": {"epss_score": 0.00133, "epss_percentile": 0.33662}, "CVE-2025-3467": {"epss_score": 0.00028, "epss_percentile": 0.07284}, "CVE-2025-3468": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-3469": {"epss_score": 0.00111, "epss_percentile": 0.30244}, "CVE-2025-3470": {"epss_score": 0.00051, "epss_percentile": 0.16166}, "CVE-2025-3471": {"epss_score": 0.00051, "epss_percentile": 0.16034}, "CVE-2025-3472": {"epss_score": 0.00575, "epss_percentile": 0.68111}, "CVE-2025-3473": {"epss_score": 0.0001, "epss_percentile": 0.0083}, "CVE-2025-3474": {"epss_score": 0.00046, "epss_percentile": 0.1447}, "CVE-2025-3475": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2025-3476": {"epss_score": 0.00056, "epss_percentile": 0.17917}, "CVE-2025-3478": {"epss_score": 0.0009, "epss_percentile": 0.26151}, "CVE-2025-3479": {"epss_score": 0.00027, "epss_percentile": 0.07089}, "CVE-2025-3480": {"epss_score": 7e-05, "epss_percentile": 0.00379}, "CVE-2025-3481": {"epss_score": 0.00204, "epss_percentile": 0.42645}, "CVE-2025-3482": {"epss_score": 0.00204, "epss_percentile": 0.42645}, "CVE-2025-3483": {"epss_score": 0.00204, "epss_percentile": 0.42645}, "CVE-2025-3484": {"epss_score": 0.00783, "epss_percentile": 0.73225}, "CVE-2025-3485": {"epss_score": 0.01061, "epss_percentile": 0.77173}, "CVE-2025-3486": {"epss_score": 0.01033, "epss_percentile": 0.76872}, "CVE-2025-3487": {"epss_score": 0.00046, "epss_percentile": 0.14283}, "CVE-2025-3488": {"epss_score": 0.00045, "epss_percentile": 0.13751}, "CVE-2025-3489": {"epss_score": 0.00063, "epss_percentile": 0.19824}, "CVE-2025-3491": {"epss_score": 0.0058, "epss_percentile": 0.68249}, "CVE-2025-3495": {"epss_score": 0.0022, "epss_percentile": 0.44556}, "CVE-2025-3496": {"epss_score": 0.00105, "epss_percentile": 0.29358}, "CVE-2025-3497": {"epss_score": 0.00081, "epss_percentile": 0.24241}, "CVE-2025-3498": {"epss_score": 0.00158, "epss_percentile": 0.3716}, "CVE-2025-3499": {"epss_score": 0.00331, "epss_percentile": 0.55506}, "CVE-2025-3500": {"epss_score": 0.00029, "epss_percentile": 0.07825}, "CVE-2025-3501": {"epss_score": 0.00021, "epss_percentile": 0.0471}, "CVE-2025-3502": {"epss_score": 0.00034, "epss_percentile": 0.09564}, "CVE-2025-3503": {"epss_score": 0.00038, "epss_percentile": 0.11234}, "CVE-2025-3504": {"epss_score": 0.00034, "epss_percentile": 0.09564}, "CVE-2025-3506": {"epss_score": 0.00041, "epss_percentile": 0.12226}, "CVE-2025-3508": {"epss_score": 0.00059, "epss_percentile": 0.18853}, "CVE-2025-3509": {"epss_score": 0.00853, "epss_percentile": 0.74428}, "CVE-2025-3510": {"epss_score": 0.00033, "epss_percentile": 0.0914}, "CVE-2025-3511": {"epss_score": 0.00106, "epss_percentile": 0.29469}, "CVE-2025-3512": {"epss_score": 0.00039, "epss_percentile": 0.11618}, "CVE-2025-3513": {"epss_score": 0.00034, "epss_percentile": 0.09564}, "CVE-2025-3514": {"epss_score": 0.00034, "epss_percentile": 0.09564}, "CVE-2025-3515": {"epss_score": 0.03371, "epss_percentile": 0.87011}, "CVE-2025-3516": {"epss_score": 0.00038, "epss_percentile": 0.11186}, "CVE-2025-3517": {"epss_score": 0.00057, "epss_percentile": 0.18056}, "CVE-2025-3518": {"epss_score": 0.00046, "epss_percentile": 0.14334}, "CVE-2025-3519": {"epss_score": 0.00057, "epss_percentile": 0.17969}, "CVE-2025-3520": {"epss_score": 0.01883, "epss_percentile": 0.82701}, "CVE-2025-3521": {"epss_score": 0.00035, "epss_percentile": 0.10019}, "CVE-2025-3522": {"epss_score": 0.00068, "epss_percentile": 0.2141}, "CVE-2025-3523": {"epss_score": 0.00081, "epss_percentile": 0.24292}, "CVE-2025-3526": {"epss_score": 0.00246, "epss_percentile": 0.47769}, "CVE-2025-3527": {"epss_score": 0.00026, "epss_percentile": 0.06561}, "CVE-2025-3528": {"epss_score": 0.00013, "epss_percentile": 0.01599}, "CVE-2025-3529": {"epss_score": 0.00206, "epss_percentile": 0.43054}, "CVE-2025-3530": {"epss_score": 0.00486, "epss_percentile": 0.64756}, "CVE-2025-3531": {"epss_score": 0.00068, "epss_percentile": 0.21209}, "CVE-2025-3532": {"epss_score": 0.00062, "epss_percentile": 0.19751}, "CVE-2025-3533": {"epss_score": 0.00062, "epss_percentile": 0.19751}, "CVE-2025-3534": {"epss_score": 0.00041, "epss_percentile": 0.12434}, "CVE-2025-3535": {"epss_score": 0.00087, "epss_percentile": 0.25453}, "CVE-2025-3536": {"epss_score": 0.00093, "epss_percentile": 0.26693}, "CVE-2025-3537": {"epss_score": 0.00224, "epss_percentile": 0.45002}, "CVE-2025-3538": {"epss_score": 0.00677, "epss_percentile": 0.70966}, "CVE-2025-3539": {"epss_score": 0.00358, "epss_percentile": 0.57525}, "CVE-2025-3540": {"epss_score": 0.00358, "epss_percentile": 0.57525}, "CVE-2025-3541": {"epss_score": 0.00358, "epss_percentile": 0.57525}, "CVE-2025-3542": {"epss_score": 0.00358, "epss_percentile": 0.57525}, "CVE-2025-3543": {"epss_score": 0.00358, "epss_percentile": 0.57525}, "CVE-2025-3544": {"epss_score": 0.00286, "epss_percentile": 0.51723}, "CVE-2025-3545": {"epss_score": 0.00358, "epss_percentile": 0.57525}, "CVE-2025-3546": {"epss_score": 0.00306, "epss_percentile": 0.53464}, "CVE-2025-3547": {"epss_score": 0.00072, "epss_percentile": 0.22321}, "CVE-2025-3548": {"epss_score": 0.00046, "epss_percentile": 0.14424}, "CVE-2025-3549": {"epss_score": 0.00054, "epss_percentile": 0.17058}, "CVE-2025-3550": {"epss_score": 0.00045, "epss_percentile": 0.13773}, "CVE-2025-3553": {"epss_score": 0.0007, "epss_percentile": 0.21968}, "CVE-2025-3554": {"epss_score": 0.00063, "epss_percentile": 0.20086}, "CVE-2025-3555": {"epss_score": 0.00286, "epss_percentile": 0.51736}, "CVE-2025-3556": {"epss_score": 0.00314, "epss_percentile": 0.54084}, "CVE-2025-3557": {"epss_score": 0.00092, "epss_percentile": 0.26496}, "CVE-2025-3558": {"epss_score": 0.00106, "epss_percentile": 0.29537}, "CVE-2025-3559": {"epss_score": 0.0007, "epss_percentile": 0.21968}, "CVE-2025-3560": {"epss_score": 0.00049, "epss_percentile": 0.15367}, "CVE-2025-3561": {"epss_score": 0.00091, "epss_percentile": 0.26208}, "CVE-2025-3562": {"epss_score": 0.00108, "epss_percentile": 0.29756}, "CVE-2025-3563": {"epss_score": 0.00095, "epss_percentile": 0.27233}, "CVE-2025-3564": {"epss_score": 0.00094, "epss_percentile": 0.26801}, "CVE-2025-3565": {"epss_score": 0.00114, "epss_percentile": 0.30736}, "CVE-2025-3566": {"epss_score": 0.00064, "epss_percentile": 0.2014}, "CVE-2025-3567": {"epss_score": 0.00045, "epss_percentile": 0.13773}, "CVE-2025-3568": {"epss_score": 0.00016, "epss_percentile": 0.02732}, "CVE-2025-3569": {"epss_score": 0.00056, "epss_percentile": 0.17963}, "CVE-2025-3570": {"epss_score": 0.00049, "epss_percentile": 0.15367}, "CVE-2025-3571": {"epss_score": 0.00041, "epss_percentile": 0.12434}, "CVE-2025-3572": {"epss_score": 0.00096, "epss_percentile": 0.27443}, "CVE-2025-3573": {"epss_score": 0.00058, "epss_percentile": 0.18455}, "CVE-2025-3574": {"epss_score": 0.0008, "epss_percentile": 0.24079}, "CVE-2025-3575": {"epss_score": 0.0008, "epss_percentile": 0.24079}, "CVE-2025-3576": {"epss_score": 0.00071, "epss_percentile": 0.22072}, "CVE-2025-3577": {"epss_score": 0.00691, "epss_percentile": 0.71264}, "CVE-2025-3578": {"epss_score": 0.00101, "epss_percentile": 0.28574}, "CVE-2025-3579": {"epss_score": 0.00216, "epss_percentile": 0.44142}, "CVE-2025-3580": {"epss_score": 0.00017, "epss_percentile": 0.03143}, "CVE-2025-3581": {"epss_score": 0.00033, "epss_percentile": 0.09149}, "CVE-2025-3582": {"epss_score": 0.00033, "epss_percentile": 0.09149}, "CVE-2025-3583": {"epss_score": 0.00034, "epss_percentile": 0.09564}, "CVE-2025-3584": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2025-3585": {"epss_score": 0.00101, "epss_percentile": 0.28625}, "CVE-2025-3586": {"epss_score": 0.0037, "epss_percentile": 0.58285}, "CVE-2025-3587": {"epss_score": 0.00101, "epss_percentile": 0.28625}, "CVE-2025-3588": {"epss_score": 0.0003, "epss_percentile": 0.08156}, "CVE-2025-3589": {"epss_score": 0.00064, "epss_percentile": 0.20374}, "CVE-2025-3590": {"epss_score": 0.00098, "epss_percentile": 0.27821}, "CVE-2025-3591": {"epss_score": 0.00049, "epss_percentile": 0.15367}, "CVE-2025-3592": {"epss_score": 0.00049, "epss_percentile": 0.15367}, "CVE-2025-3593": {"epss_score": 0.00106, "epss_percentile": 0.29537}, "CVE-2025-3594": {"epss_score": 0.00324, "epss_percentile": 0.54928}, "CVE-2025-3597": {"epss_score": 0.00038, "epss_percentile": 0.11186}, "CVE-2025-3598": {"epss_score": 0.00195, "epss_percentile": 0.41674}, "CVE-2025-3599": {"epss_score": 0.00029, "epss_percentile": 0.07649}, "CVE-2025-3600": {"epss_score": 0.00353, "epss_percentile": 0.57143}, "CVE-2025-3601": {"epss_score": 0.00121, "epss_percentile": 0.31915}, "CVE-2025-3602": {"epss_score": 0.00115, "epss_percentile": 0.31022}, "CVE-2025-3603": {"epss_score": 0.00267, "epss_percentile": 0.4997}, "CVE-2025-3604": {"epss_score": 0.00267, "epss_percentile": 0.4997}, "CVE-2025-3605": {"epss_score": 0.19545, "epss_percentile": 0.95204}, "CVE-2025-3606": {"epss_score": 0.0007, "epss_percentile": 0.21748}, "CVE-2025-3607": {"epss_score": 0.00081, "epss_percentile": 0.24255}, "CVE-2025-3608": {"epss_score": 0.00042, "epss_percentile": 0.12793}, "CVE-2025-3609": {"epss_score": 0.00122, "epss_percentile": 0.32091}, "CVE-2025-3610": {"epss_score": 0.00535, "epss_percentile": 0.66826}, "CVE-2025-3611": {"epss_score": 0.0003, "epss_percentile": 0.08168}, "CVE-2025-3612": {"epss_score": 0.00045, "epss_percentile": 0.13906}, "CVE-2025-3613": {"epss_score": 0.00042, "epss_percentile": 0.12891}, "CVE-2025-3614": {"epss_score": 0.00024, "epss_percentile": 0.05997}, "CVE-2025-3615": {"epss_score": 0.00059, "epss_percentile": 0.18865}, "CVE-2025-3616": {"epss_score": 0.00505, "epss_percentile": 0.65601}, "CVE-2025-3617": {"epss_score": 0.00016, "epss_percentile": 0.02908}, "CVE-2025-3618": {"epss_score": 0.00023, "epss_percentile": 0.0559}, "CVE-2025-3619": {"epss_score": 0.00036, "epss_percentile": 0.10254}, "CVE-2025-3620": {"epss_score": 0.00071, "epss_percentile": 0.22036}, "CVE-2025-3621": {"epss_score": 0.00404, "epss_percentile": 0.60408}, "CVE-2025-3622": {"epss_score": 0.00087, "epss_percentile": 0.25539}, "CVE-2025-3623": {"epss_score": 0.0025, "epss_percentile": 0.48254}, "CVE-2025-3624": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-3625": {"epss_score": 0.00102, "epss_percentile": 0.28813}, "CVE-2025-3626": {"epss_score": 0.00226, "epss_percentile": 0.45252}, "CVE-2025-3627": {"epss_score": 0.00095, "epss_percentile": 0.2714}, "CVE-2025-3628": {"epss_score": 0.00073, "epss_percentile": 0.22655}, "CVE-2025-3629": {"epss_score": 0.00029, "epss_percentile": 0.07932}, "CVE-2025-3630": {"epss_score": 0.00019, "epss_percentile": 0.04356}, "CVE-2025-3631": {"epss_score": 0.00035, "epss_percentile": 0.09976}, "CVE-2025-3632": {"epss_score": 0.00079, "epss_percentile": 0.2394}, "CVE-2025-3634": {"epss_score": 0.00075, "epss_percentile": 0.22909}, "CVE-2025-3635": {"epss_score": 0.0003, "epss_percentile": 0.0825}, "CVE-2025-3636": {"epss_score": 0.00049, "epss_percentile": 0.15612}, "CVE-2025-3637": {"epss_score": 0.0004, "epss_percentile": 0.12165}, "CVE-2025-3638": {"epss_score": 0.00028, "epss_percentile": 0.0754}, "CVE-2025-3639": {"epss_score": 0.00032, "epss_percentile": 0.08986}, "CVE-2025-3640": {"epss_score": 0.00071, "epss_percentile": 0.2204}, "CVE-2025-3641": {"epss_score": 0.00428, "epss_percentile": 0.61937}, "CVE-2025-3642": {"epss_score": 0.00428, "epss_percentile": 0.61937}, "CVE-2025-3643": {"epss_score": 0.00045, "epss_percentile": 0.13775}, "CVE-2025-3644": {"epss_score": 0.00074, "epss_percentile": 0.22881}, "CVE-2025-3645": {"epss_score": 0.00071, "epss_percentile": 0.2204}, "CVE-2025-3646": {"epss_score": 0.00043, "epss_percentile": 0.13083}, "CVE-2025-3647": {"epss_score": 0.00071, "epss_percentile": 0.2204}, "CVE-2025-3648": {"epss_score": 0.00051, "epss_percentile": 0.1619}, "CVE-2025-3649": {"epss_score": 0.00069, "epss_percentile": 0.21556}, "CVE-2025-3650": {"epss_score": 0.00036, "epss_percentile": 0.10445}, "CVE-2025-3651": {"epss_score": 0.0005, "epss_percentile": 0.15776}, "CVE-2025-3652": {"epss_score": 0.00034, "epss_percentile": 0.09455}, "CVE-2025-3653": {"epss_score": 0.00036, "epss_percentile": 0.10366}, "CVE-2025-3654": {"epss_score": 0.00034, "epss_percentile": 0.09455}, "CVE-2025-3659": {"epss_score": 0.00129, "epss_percentile": 0.33145}, "CVE-2025-3660": {"epss_score": 0.00027, "epss_percentile": 0.06805}, "CVE-2025-3661": {"epss_score": 0.00059, "epss_percentile": 0.18865}, "CVE-2025-3662": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-3663": {"epss_score": 0.007, "epss_percentile": 0.7146}, "CVE-2025-3664": {"epss_score": 0.00145, "epss_percentile": 0.35434}, "CVE-2025-3665": {"epss_score": 0.00145, "epss_percentile": 0.35434}, "CVE-2025-3666": {"epss_score": 0.00246, "epss_percentile": 0.47779}, "CVE-2025-3667": {"epss_score": 0.00246, "epss_percentile": 0.47779}, "CVE-2025-3668": {"epss_score": 0.00268, "epss_percentile": 0.50081}, "CVE-2025-3669": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-3670": {"epss_score": 0.00035, "epss_percentile": 0.09916}, "CVE-2025-3671": {"epss_score": 0.0019, "epss_percentile": 0.41127}, "CVE-2025-3674": {"epss_score": 0.00145, "epss_percentile": 0.35434}, "CVE-2025-3675": {"epss_score": 0.00246, "epss_percentile": 0.47779}, "CVE-2025-3676": {"epss_score": 0.00066, "epss_percentile": 0.20698}, "CVE-2025-3677": {"epss_score": 0.00068, "epss_percentile": 0.21309}, "CVE-2025-3678": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3679": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3680": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3681": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3682": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3683": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3684": {"epss_score": 0.00066, "epss_percentile": 0.20698}, "CVE-2025-3685": {"epss_score": 0.00058, "epss_percentile": 0.1836}, "CVE-2025-3686": {"epss_score": 0.00147, "epss_percentile": 0.35756}, "CVE-2025-3687": {"epss_score": 0.00063, "epss_percentile": 0.19942}, "CVE-2025-3688": {"epss_score": 0.00041, "epss_percentile": 0.12406}, "CVE-2025-3689": {"epss_score": 0.0006, "epss_percentile": 0.1896}, "CVE-2025-3690": {"epss_score": 0.0006, "epss_percentile": 0.1896}, "CVE-2025-3691": {"epss_score": 0.00187, "epss_percentile": 0.40773}, "CVE-2025-3692": {"epss_score": 0.00045, "epss_percentile": 0.13714}, "CVE-2025-3693": {"epss_score": 0.00669, "epss_percentile": 0.70761}, "CVE-2025-3694": {"epss_score": 0.00064, "epss_percentile": 0.20132}, "CVE-2025-3696": {"epss_score": 0.00062, "epss_percentile": 0.19579}, "CVE-2025-3697": {"epss_score": 0.00062, "epss_percentile": 0.19579}, "CVE-2025-3698": {"epss_score": 0.00076, "epss_percentile": 0.23263}, "CVE-2025-3699": {"epss_score": 0.00172, "epss_percentile": 0.38981}, "CVE-2025-3701": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-3702": {"epss_score": 0.00051, "epss_percentile": 0.1606}, "CVE-2025-3703": {"epss_score": 0.00107, "epss_percentile": 0.29739}, "CVE-2025-3704": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-3705": {"epss_score": 0.00091, "epss_percentile": 0.2627}, "CVE-2025-3706": {"epss_score": 0.00048, "epss_percentile": 0.15056}, "CVE-2025-3707": {"epss_score": 0.00047, "epss_percentile": 0.14652}, "CVE-2025-3708": {"epss_score": 0.00146, "epss_percentile": 0.35578}, "CVE-2025-3709": {"epss_score": 0.0009, "epss_percentile": 0.2603}, "CVE-2025-3710": {"epss_score": 0.00518, "epss_percentile": 0.66137}, "CVE-2025-3711": {"epss_score": 0.00518, "epss_percentile": 0.66137}, "CVE-2025-3712": {"epss_score": 0.00143, "epss_percentile": 0.3518}, "CVE-2025-3713": {"epss_score": 0.00143, "epss_percentile": 0.3518}, "CVE-2025-3714": {"epss_score": 0.00518, "epss_percentile": 0.66137}, "CVE-2025-3715": {"epss_score": 0.00032, "epss_percentile": 0.08985}, "CVE-2025-3717": {"epss_score": 0.00054, "epss_percentile": 0.17168}, "CVE-2025-3718": {"epss_score": 0.00047, "epss_percentile": 0.14782}, "CVE-2025-3719": {"epss_score": 0.00058, "epss_percentile": 0.18271}, "CVE-2025-3722": {"epss_score": 0.00013, "epss_percentile": 0.0171}, "CVE-2025-3723": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3724": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3725": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3726": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3727": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3728": {"epss_score": 0.00027, "epss_percentile": 0.06929}, "CVE-2025-3729": {"epss_score": 0.00875, "epss_percentile": 0.74772}, "CVE-2025-3730": {"epss_score": 0.00057, "epss_percentile": 0.18221}, "CVE-2025-3733": {"epss_score": 0.00053, "epss_percentile": 0.16732}, "CVE-2025-3734": {"epss_score": 0.00063, "epss_percentile": 0.19962}, "CVE-2025-3735": {"epss_score": 0.00048, "epss_percentile": 0.15193}, "CVE-2025-3736": {"epss_score": 0.00048, "epss_percentile": 0.15193}, "CVE-2025-3737": {"epss_score": 0.00048, "epss_percentile": 0.15193}, "CVE-2025-3738": {"epss_score": 0.00048, "epss_percentile": 0.15193}, "CVE-2025-3739": {"epss_score": 0.00053, "epss_percentile": 0.16723}, "CVE-2025-3740": {"epss_score": 0.00148, "epss_percentile": 0.35912}, "CVE-2025-3742": {"epss_score": 0.00069, "epss_percentile": 0.21556}, "CVE-2025-3743": {"epss_score": 0.00189, "epss_percentile": 0.40969}, "CVE-2025-3744": {"epss_score": 0.0006, "epss_percentile": 0.19004}, "CVE-2025-3745": {"epss_score": 0.0004, "epss_percentile": 0.12156}, "CVE-2025-3746": {"epss_score": 0.00263, "epss_percentile": 0.49547}, "CVE-2025-3748": {"epss_score": 0.00034, "epss_percentile": 0.09526}, "CVE-2025-3749": {"epss_score": 0.00059, "epss_percentile": 0.18865}, "CVE-2025-3750": {"epss_score": 0.00032, "epss_percentile": 0.08985}, "CVE-2025-3751": {"epss_score": 0.00036, "epss_percentile": 0.10249}, "CVE-2025-3752": {"epss_score": 0.00043, "epss_percentile": 0.13343}, "CVE-2025-3753": {"epss_score": 0.0002, "epss_percentile": 0.04637}, "CVE-2025-3755": {"epss_score": 0.00039, "epss_percentile": 0.11792}, "CVE-2025-3757": {"epss_score": 0.0004, "epss_percentile": 0.11957}, "CVE-2025-3758": {"epss_score": 0.00025, "epss_percentile": 0.06144}, "CVE-2025-3759": {"epss_score": 0.00031, "epss_percentile": 0.08567}, "CVE-2025-3760": {"epss_score": 0.00044, "epss_percentile": 0.13524}, "CVE-2025-3761": {"epss_score": 0.00081, "epss_percentile": 0.24255}, "CVE-2025-3762": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3763": {"epss_score": 0.00027, "epss_percentile": 0.06929}, "CVE-2025-3764": {"epss_score": 0.00096, "epss_percentile": 0.27298}, "CVE-2025-3765": {"epss_score": 0.00096, "epss_percentile": 0.27298}, "CVE-2025-3766": {"epss_score": 0.00034, "epss_percentile": 0.09772}, "CVE-2025-3767": {"epss_score": 0.01302, "epss_percentile": 0.79306}, "CVE-2025-3768": {"epss_score": 0.00041, "epss_percentile": 0.12408}, "CVE-2025-3769": {"epss_score": 0.00036, "epss_percentile": 0.10528}, "CVE-2025-3770": {"epss_score": 0.00016, "epss_percentile": 0.02908}, "CVE-2025-3771": {"epss_score": 0.00019, "epss_percentile": 0.04411}, "CVE-2025-3773": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2025-3774": {"epss_score": 0.00142, "epss_percentile": 0.35}, "CVE-2025-3775": {"epss_score": 0.00136, "epss_percentile": 0.34123}, "CVE-2025-3776": {"epss_score": 0.00309, "epss_percentile": 0.53681}, "CVE-2025-3777": {"epss_score": 0.00051, "epss_percentile": 0.16143}, "CVE-2025-3779": {"epss_score": 0.00035, "epss_percentile": 0.09916}, "CVE-2025-3780": {"epss_score": 0.0011, "epss_percentile": 0.30081}, "CVE-2025-3781": {"epss_score": 0.00032, "epss_percentile": 0.08985}, "CVE-2025-3782": {"epss_score": 0.0004, "epss_percentile": 0.12029}, "CVE-2025-3783": {"epss_score": 0.00101, "epss_percentile": 0.28639}, "CVE-2025-3784": {"epss_score": 0.0001, "epss_percentile": 0.00767}, "CVE-2025-3785": {"epss_score": 0.00182, "epss_percentile": 0.40157}, "CVE-2025-3786": {"epss_score": 0.00182, "epss_percentile": 0.40223}, "CVE-2025-3787": {"epss_score": 0.00084, "epss_percentile": 0.24829}, "CVE-2025-3788": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-3789": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-3790": {"epss_score": 0.00073, "epss_percentile": 0.22536}, "CVE-2025-3791": {"epss_score": 0.00024, "epss_percentile": 0.05668}, "CVE-2025-3792": {"epss_score": 0.0006, "epss_percentile": 0.1903}, "CVE-2025-3793": {"epss_score": 0.00038, "epss_percentile": 0.11336}, "CVE-2025-3794": {"epss_score": 0.00029, "epss_percentile": 0.07684}, "CVE-2025-3795": {"epss_score": 0.00112, "epss_percentile": 0.30448}, "CVE-2025-3796": {"epss_score": 0.00058, "epss_percentile": 0.1836}, "CVE-2025-3797": {"epss_score": 0.0006, "epss_percentile": 0.1903}, "CVE-2025-3798": {"epss_score": 0.00115, "epss_percentile": 0.30951}, "CVE-2025-3799": {"epss_score": 0.00068, "epss_percentile": 0.21247}, "CVE-2025-3800": {"epss_score": 0.00068, "epss_percentile": 0.21247}, "CVE-2025-3801": {"epss_score": 0.00041, "epss_percentile": 0.12406}, "CVE-2025-3802": {"epss_score": 0.00182, "epss_percentile": 0.40223}, "CVE-2025-3803": {"epss_score": 0.00182, "epss_percentile": 0.40223}, "CVE-2025-3804": {"epss_score": 0.00039, "epss_percentile": 0.11836}, "CVE-2025-3805": {"epss_score": 0.00039, "epss_percentile": 0.11836}, "CVE-2025-3806": {"epss_score": 0.00041, "epss_percentile": 0.12406}, "CVE-2025-3807": {"epss_score": 0.00104, "epss_percentile": 0.29132}, "CVE-2025-3808": {"epss_score": 0.00077, "epss_percentile": 0.23541}, "CVE-2025-3809": {"epss_score": 0.00261, "epss_percentile": 0.49249}, "CVE-2025-3810": {"epss_score": 0.00198, "epss_percentile": 0.42066}, "CVE-2025-3811": {"epss_score": 0.00198, "epss_percentile": 0.42066}, "CVE-2025-3812": {"epss_score": 0.00615, "epss_percentile": 0.69308}, "CVE-2025-3813": {"epss_score": 0.00031, "epss_percentile": 0.08553}, "CVE-2025-3814": {"epss_score": 0.00059, "epss_percentile": 0.18865}, "CVE-2025-3815": {"epss_score": 0.00049, "epss_percentile": 0.15323}, "CVE-2025-3816": {"epss_score": 0.00685, "epss_percentile": 0.71152}, "CVE-2025-3817": {"epss_score": 0.00058, "epss_percentile": 0.1836}, "CVE-2025-3818": {"epss_score": 0.00062, "epss_percentile": 0.19727}, "CVE-2025-3819": {"epss_score": 0.0006, "epss_percentile": 0.1896}, "CVE-2025-3820": {"epss_score": 0.00184, "epss_percentile": 0.40429}, "CVE-2025-3821": {"epss_score": 0.00049, "epss_percentile": 0.15544}, "CVE-2025-3822": {"epss_score": 0.00057, "epss_percentile": 0.18085}, "CVE-2025-3823": {"epss_score": 0.00075, "epss_percentile": 0.22916}, "CVE-2025-3824": {"epss_score": 0.00045, "epss_percentile": 0.13818}, "CVE-2025-3825": {"epss_score": 0.00045, "epss_percentile": 0.13818}, "CVE-2025-3826": {"epss_score": 0.00045, "epss_percentile": 0.13818}, "CVE-2025-3827": {"epss_score": 0.0006, "epss_percentile": 0.1896}, "CVE-2025-3828": {"epss_score": 0.0006, "epss_percentile": 0.1896}, "CVE-2025-3829": {"epss_score": 0.00055, "epss_percentile": 0.1743}, "CVE-2025-3830": {"epss_score": 0.00108, "epss_percentile": 0.29775}, "CVE-2025-3831": {"epss_score": 0.00041, "epss_percentile": 0.12414}, "CVE-2025-3832": {"epss_score": 0.00048, "epss_percentile": 0.14943}, "CVE-2025-3833": {"epss_score": 0.00257, "epss_percentile": 0.48911}, "CVE-2025-3834": {"epss_score": 0.00237, "epss_percentile": 0.46465}, "CVE-2025-3835": {"epss_score": 0.00256, "epss_percentile": 0.48798}, "CVE-2025-3836": {"epss_score": 0.00372, "epss_percentile": 0.58436}, "CVE-2025-3837": {"epss_score": 0.00141, "epss_percentile": 0.34914}, "CVE-2025-3838": {"epss_score": 0.00017, "epss_percentile": 0.03345}, "CVE-2025-3840": {"epss_score": 0.00045, "epss_percentile": 0.14069}, "CVE-2025-3841": {"epss_score": 0.00044, "epss_percentile": 0.13663}, "CVE-2025-3842": {"epss_score": 0.00099, "epss_percentile": 0.28309}, "CVE-2025-3843": {"epss_score": 0.00077, "epss_percentile": 0.23541}, "CVE-2025-3844": {"epss_score": 0.00415, "epss_percentile": 0.61137}, "CVE-2025-3845": {"epss_score": 0.00101, "epss_percentile": 0.2859}, "CVE-2025-3846": {"epss_score": 0.00053, "epss_percentile": 0.1702}, "CVE-2025-3847": {"epss_score": 0.00059, "epss_percentile": 0.18643}, "CVE-2025-3849": {"epss_score": 0.00063, "epss_percentile": 0.20063}, "CVE-2025-3850": {"epss_score": 0.0008, "epss_percentile": 0.2409}, "CVE-2025-3851": {"epss_score": 0.00038, "epss_percentile": 0.1112}, "CVE-2025-3852": {"epss_score": 0.00078, "epss_percentile": 0.23661}, "CVE-2025-3853": {"epss_score": 0.00037, "epss_percentile": 0.10766}, "CVE-2025-3854": {"epss_score": 0.00087, "epss_percentile": 0.25511}, "CVE-2025-3855": {"epss_score": 0.00058, "epss_percentile": 0.18523}, "CVE-2025-3856": {"epss_score": 0.00063, "epss_percentile": 0.20051}, "CVE-2025-3857": {"epss_score": 0.00055, "epss_percentile": 0.17373}, "CVE-2025-3858": {"epss_score": 0.00034, "epss_percentile": 0.09526}, "CVE-2025-3859": {"epss_score": 0.00035, "epss_percentile": 0.09912}, "CVE-2025-3860": {"epss_score": 0.00032, "epss_percentile": 0.08985}, "CVE-2025-3861": {"epss_score": 0.00037, "epss_percentile": 0.10969}, "CVE-2025-3862": {"epss_score": 0.00039, "epss_percentile": 0.11458}, "CVE-2025-3863": {"epss_score": 0.00041, "epss_percentile": 0.12223}, "CVE-2025-3864": {"epss_score": 0.00301, "epss_percentile": 0.53025}, "CVE-2025-3866": {"epss_score": 0.00049, "epss_percentile": 0.15508}, "CVE-2025-3867": {"epss_score": 0.00044, "epss_percentile": 0.13633}, "CVE-2025-3868": {"epss_score": 0.00131, "epss_percentile": 0.33429}, "CVE-2025-3869": {"epss_score": 0.00045, "epss_percentile": 0.13976}, "CVE-2025-3870": {"epss_score": 0.00049, "epss_percentile": 0.15508}, "CVE-2025-3871": {"epss_score": 0.00119, "epss_percentile": 0.31607}, "CVE-2025-3872": {"epss_score": 0.00041, "epss_percentile": 0.12373}, "CVE-2025-3873": {"epss_score": 0.00045, "epss_percentile": 0.13893}, "CVE-2025-3874": {"epss_score": 0.00281, "epss_percentile": 0.51131}, "CVE-2025-3875": {"epss_score": 0.00053, "epss_percentile": 0.16795}, "CVE-2025-3876": {"epss_score": 0.00081, "epss_percentile": 0.24295}, "CVE-2025-3878": {"epss_score": 0.0003, "epss_percentile": 0.0819}, "CVE-2025-3879": {"epss_score": 0.00059, "epss_percentile": 0.18798}, "CVE-2025-3880": {"epss_score": 0.00041, "epss_percentile": 0.12223}, "CVE-2025-3881": {"epss_score": 0.00082, "epss_percentile": 0.24465}, "CVE-2025-3882": {"epss_score": 0.00082, "epss_percentile": 0.24465}, "CVE-2025-3883": {"epss_score": 0.00082, "epss_percentile": 0.24465}, "CVE-2025-3884": {"epss_score": 0.07276, "epss_percentile": 0.91379}, "CVE-2025-3885": {"epss_score": 0.00055, "epss_percentile": 0.1738}, "CVE-2025-3886": {"epss_score": 0.0003, "epss_percentile": 0.0819}, "CVE-2025-3887": {"epss_score": 0.00454, "epss_percentile": 0.63255}, "CVE-2025-3888": {"epss_score": 0.00024, "epss_percentile": 0.05887}, "CVE-2025-3889": {"epss_score": 0.00093, "epss_percentile": 0.26736}, "CVE-2025-3890": {"epss_score": 0.00034, "epss_percentile": 0.09526}, "CVE-2025-3891": {"epss_score": 0.005, "epss_percentile": 0.6529}, "CVE-2025-3892": {"epss_score": 0.00015, "epss_percentile": 0.02346}, "CVE-2025-3893": {"epss_score": 0.00031, "epss_percentile": 0.08621}, "CVE-2025-3894": {"epss_score": 0.00049, "epss_percentile": 0.15305}, "CVE-2025-3895": {"epss_score": 0.00157, "epss_percentile": 0.37026}, "CVE-2025-3897": {"epss_score": 0.00206, "epss_percentile": 0.42767}, "CVE-2025-3898": {"epss_score": 0.00121, "epss_percentile": 0.31892}, "CVE-2025-3899": {"epss_score": 0.00017, "epss_percentile": 0.03493}, "CVE-2025-3900": {"epss_score": 0.00038, "epss_percentile": 0.11323}, "CVE-2025-3901": {"epss_score": 0.00042, "epss_percentile": 0.12573}, "CVE-2025-3902": {"epss_score": 0.00042, "epss_percentile": 0.12573}, "CVE-2025-3903": {"epss_score": 0.00077, "epss_percentile": 0.23435}, "CVE-2025-3904": {"epss_score": 0.00077, "epss_percentile": 0.23435}, "CVE-2025-3905": {"epss_score": 0.00025, "epss_percentile": 0.06378}, "CVE-2025-3906": {"epss_score": 0.00086, "epss_percentile": 0.25276}, "CVE-2025-3907": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-3908": {"epss_score": 0.00025, "epss_percentile": 0.06139}, "CVE-2025-3909": {"epss_score": 0.00129, "epss_percentile": 0.33144}, "CVE-2025-3910": {"epss_score": 0.00022, "epss_percentile": 0.05044}, "CVE-2025-3911": {"epss_score": 0.00028, "epss_percentile": 0.0735}, "CVE-2025-3912": {"epss_score": 0.00121, "epss_percentile": 0.32007}, "CVE-2025-3913": {"epss_score": 0.00048, "epss_percentile": 0.14945}, "CVE-2025-3914": {"epss_score": 0.00963, "epss_percentile": 0.76023}, "CVE-2025-3915": {"epss_score": 0.00048, "epss_percentile": 0.15151}, "CVE-2025-3916": {"epss_score": 0.00022, "epss_percentile": 0.05273}, "CVE-2025-3917": {"epss_score": 0.00499, "epss_percentile": 0.65262}, "CVE-2025-3918": {"epss_score": 0.00205, "epss_percentile": 0.42762}, "CVE-2025-3919": {"epss_score": 0.0004, "epss_percentile": 0.12029}, "CVE-2025-3920": {"epss_score": 0.00017, "epss_percentile": 0.03107}, "CVE-2025-3921": {"epss_score": 0.0014, "epss_percentile": 0.34743}, "CVE-2025-3923": {"epss_score": 0.00052, "epss_percentile": 0.16378}, "CVE-2025-3924": {"epss_score": 0.00093, "epss_percentile": 0.26603}, "CVE-2025-3925": {"epss_score": 0.00022, "epss_percentile": 0.05035}, "CVE-2025-3927": {"epss_score": 0.0007, "epss_percentile": 0.21752}, "CVE-2025-3928": {"epss_score": 0.13115, "epss_percentile": 0.93878}, "CVE-2025-3929": {"epss_score": 0.00033, "epss_percentile": 0.09401}, "CVE-2025-3930": {"epss_score": 0.00102, "epss_percentile": 0.28754}, "CVE-2025-3931": {"epss_score": 0.00032, "epss_percentile": 0.08849}, "CVE-2025-3932": {"epss_score": 0.0004, "epss_percentile": 0.119}, "CVE-2025-3933": {"epss_score": 0.00108, "epss_percentile": 0.29836}, "CVE-2025-3935": {"epss_score": 0.12304, "epss_percentile": 0.93628}, "CVE-2025-3936": {"epss_score": 0.0004, "epss_percentile": 0.11978}, "CVE-2025-3937": {"epss_score": 0.00026, "epss_percentile": 0.06655}, "CVE-2025-3938": {"epss_score": 0.00024, "epss_percentile": 0.0599}, "CVE-2025-3939": {"epss_score": 0.0004, "epss_percentile": 0.12058}, "CVE-2025-3940": {"epss_score": 0.00073, "epss_percentile": 0.22671}, "CVE-2025-3941": {"epss_score": 0.00068, "epss_percentile": 0.21263}, "CVE-2025-3942": {"epss_score": 0.00042, "epss_percentile": 0.12598}, "CVE-2025-3943": {"epss_score": 0.00075, "epss_percentile": 0.23024}, "CVE-2025-3944": {"epss_score": 0.00062, "epss_percentile": 0.19605}, "CVE-2025-3945": {"epss_score": 0.00057, "epss_percentile": 0.18024}, "CVE-2025-3946": {"epss_score": 0.00086, "epss_percentile": 0.25384}, "CVE-2025-3947": {"epss_score": 0.001, "epss_percentile": 0.28486}, "CVE-2025-3949": {"epss_score": 0.00043, "epss_percentile": 0.13082}, "CVE-2025-3951": {"epss_score": 0.00035, "epss_percentile": 0.09896}, "CVE-2025-3952": {"epss_score": 0.00097, "epss_percentile": 0.27517}, "CVE-2025-3953": {"epss_score": 0.0004, "epss_percentile": 0.1192}, "CVE-2025-3954": {"epss_score": 0.00146, "epss_percentile": 0.35568}, "CVE-2025-3955": {"epss_score": 0.00027, "epss_percentile": 0.06922}, "CVE-2025-3956": {"epss_score": 0.00047, "epss_percentile": 0.14634}, "CVE-2025-3957": {"epss_score": 0.0005, "epss_percentile": 0.1587}, "CVE-2025-3958": {"epss_score": 0.0004, "epss_percentile": 0.12025}, "CVE-2025-3959": {"epss_score": 0.00043, "epss_percentile": 0.13004}, "CVE-2025-3960": {"epss_score": 0.00104, "epss_percentile": 0.29151}, "CVE-2025-3961": {"epss_score": 0.0004, "epss_percentile": 0.12025}, "CVE-2025-3962": {"epss_score": 0.0004, "epss_percentile": 0.12025}, "CVE-2025-3963": {"epss_score": 0.00104, "epss_percentile": 0.29151}, "CVE-2025-3964": {"epss_score": 0.00043, "epss_percentile": 0.13004}, "CVE-2025-3965": {"epss_score": 0.00033, "epss_percentile": 0.0916}, "CVE-2025-3966": {"epss_score": 0.00039, "epss_percentile": 0.11836}, "CVE-2025-3967": {"epss_score": 0.00067, "epss_percentile": 0.21152}, "CVE-2025-3968": {"epss_score": 0.00048, "epss_percentile": 0.15253}, "CVE-2025-3969": {"epss_score": 0.00093, "epss_percentile": 0.26681}, "CVE-2025-3970": {"epss_score": 0.0003, "epss_percentile": 0.08214}, "CVE-2025-3971": {"epss_score": 0.00041, "epss_percentile": 0.123}, "CVE-2025-3972": {"epss_score": 0.00041, "epss_percentile": 0.123}, "CVE-2025-3973": {"epss_score": 0.00041, "epss_percentile": 0.123}, "CVE-2025-3974": {"epss_score": 0.00041, "epss_percentile": 0.123}, "CVE-2025-3975": {"epss_score": 0.00052, "epss_percentile": 0.16507}, "CVE-2025-3976": {"epss_score": 0.00041, "epss_percentile": 0.123}, "CVE-2025-3977": {"epss_score": 0.00032, "epss_percentile": 0.09098}, "CVE-2025-3978": {"epss_score": 0.00044, "epss_percentile": 0.13374}, "CVE-2025-3979": {"epss_score": 0.00043, "epss_percentile": 0.13004}, "CVE-2025-3980": {"epss_score": 0.00062, "epss_percentile": 0.19771}, "CVE-2025-3981": {"epss_score": 0.00028, "epss_percentile": 0.07245}, "CVE-2025-3982": {"epss_score": 0.0011, "epss_percentile": 0.3021}, "CVE-2025-3983": {"epss_score": 0.00463, "epss_percentile": 0.63677}, "CVE-2025-3984": {"epss_score": 0.00073, "epss_percentile": 0.22577}, "CVE-2025-3985": {"epss_score": 0.00156, "epss_percentile": 0.36992}, "CVE-2025-3986": {"epss_score": 0.00131, "epss_percentile": 0.33489}, "CVE-2025-3987": {"epss_score": 0.03177, "epss_percentile": 0.86571}, "CVE-2025-3988": {"epss_score": 0.00161, "epss_percentile": 0.37528}, "CVE-2025-3989": {"epss_score": 0.00167, "epss_percentile": 0.38301}, "CVE-2025-3990": {"epss_score": 0.00167, "epss_percentile": 0.38301}, "CVE-2025-3991": {"epss_score": 0.00167, "epss_percentile": 0.38301}, "CVE-2025-3992": {"epss_score": 0.00167, "epss_percentile": 0.38301}, "CVE-2025-3993": {"epss_score": 0.00167, "epss_percentile": 0.38301}, "CVE-2025-3994": {"epss_score": 0.00151, "epss_percentile": 0.3622}, "CVE-2025-3995": {"epss_score": 0.00093, "epss_percentile": 0.26754}, "CVE-2025-3996": {"epss_score": 0.00044, "epss_percentile": 0.13416}, "CVE-2025-3997": {"epss_score": 0.00018, "epss_percentile": 0.03927}, "CVE-2025-3998": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-3999": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-40000": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-40001": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40002": {"epss_score": 0.00029, "epss_percentile": 0.07699}, "CVE-2025-40003": {"epss_score": 0.00031, "epss_percentile": 0.0851}, "CVE-2025-40004": {"epss_score": 0.00029, "epss_percentile": 0.07591}, "CVE-2025-40005": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40006": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40007": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40008": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40009": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40010": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40011": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40012": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40013": {"epss_score": 0.00061, "epss_percentile": 0.19287}, "CVE-2025-40014": {"epss_score": 0.00026, "epss_percentile": 0.06533}, "CVE-2025-40015": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40016": {"epss_score": 0.00027, "epss_percentile": 0.06874}, "CVE-2025-40017": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40018": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40019": {"epss_score": 0.0003, "epss_percentile": 0.08219}, "CVE-2025-40020": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40021": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40022": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40023": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40024": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-40025": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40026": {"epss_score": 0.00068, "epss_percentile": 0.21397}, "CVE-2025-40027": {"epss_score": 0.00071, "epss_percentile": 0.22195}, "CVE-2025-40028": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-40029": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40030": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40031": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40032": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40033": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-40034": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40035": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40036": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40037": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40038": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-40039": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40040": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40041": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40042": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40043": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40044": {"epss_score": 0.00061, "epss_percentile": 0.19287}, "CVE-2025-40045": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40046": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40047": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40048": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40049": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40050": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40051": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40052": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-40053": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40054": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40055": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40056": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40057": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40058": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40059": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40060": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40061": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-40062": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40063": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40064": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40065": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40066": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40067": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-40068": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40069": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40070": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40071": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-40072": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40073": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40074": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40075": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40076": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40077": {"epss_score": 0.00026, "epss_percentile": 0.0671}, "CVE-2025-40078": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40079": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40080": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40081": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40082": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40083": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40084": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40085": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40086": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40087": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40088": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40089": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40090": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40091": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40092": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40093": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40094": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40095": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40096": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40097": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40098": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-40099": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40100": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40101": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-40102": {"epss_score": 0.00027, "epss_percentile": 0.07119}, "CVE-2025-40103": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40104": {"epss_score": 0.00039, "epss_percentile": 0.11603}, "CVE-2025-40105": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40106": {"epss_score": 0.00053, "epss_percentile": 0.16814}, "CVE-2025-40107": {"epss_score": 0.00037, "epss_percentile": 0.10921}, "CVE-2025-40108": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40109": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40110": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40111": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40112": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40113": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40114": {"epss_score": 0.00022, "epss_percentile": 0.05311}, "CVE-2025-40115": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40116": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40117": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40118": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40119": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40120": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40121": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40122": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40123": {"epss_score": 0.00037, "epss_percentile": 0.10921}, "CVE-2025-40124": {"epss_score": 0.00068, "epss_percentile": 0.21228}, "CVE-2025-40125": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40126": {"epss_score": 0.00068, "epss_percentile": 0.21228}, "CVE-2025-40127": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40129": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40130": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40131": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40132": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40133": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40134": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40135": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40136": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40137": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40138": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40139": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40140": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40141": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40142": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40143": {"epss_score": 0.00028, "epss_percentile": 0.07249}, "CVE-2025-40145": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40146": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40147": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40148": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40149": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40150": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40151": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40152": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40153": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40154": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40155": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40156": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40157": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40158": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40159": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40160": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40161": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40162": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40163": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40164": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40165": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40166": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40167": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40168": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40169": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40170": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40171": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40172": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40173": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40174": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40175": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40176": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40177": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40178": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40179": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40180": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40181": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40182": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40183": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40184": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40185": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40186": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40187": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40188": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40189": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40190": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40191": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40192": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40193": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40194": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40195": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40196": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40197": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40198": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40199": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40200": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40201": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40202": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40203": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40204": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40205": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-40206": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40207": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40208": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40209": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40210": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40211": {"epss_score": 0.00061, "epss_percentile": 0.19295}, "CVE-2025-40212": {"epss_score": 0.00035, "epss_percentile": 0.10126}, "CVE-2025-40213": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40214": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40215": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40216": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40217": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40218": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40219": {"epss_score": 0.00061, "epss_percentile": 0.19295}, "CVE-2025-40220": {"epss_score": 0.00061, "epss_percentile": 0.19295}, "CVE-2025-40221": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40222": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40223": {"epss_score": 0.00061, "epss_percentile": 0.19295}, "CVE-2025-40224": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40225": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40226": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40227": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40228": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40229": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40230": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40231": {"epss_score": 0.00061, "epss_percentile": 0.19295}, "CVE-2025-40232": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40233": {"epss_score": 0.00061, "epss_percentile": 0.19295}, "CVE-2025-40234": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40235": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40236": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40237": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40238": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40239": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40240": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40241": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40242": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40243": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40244": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40245": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40246": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40247": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40248": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40249": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40250": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40251": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40252": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40253": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40254": {"epss_score": 0.0004, "epss_percentile": 0.12036}, "CVE-2025-40255": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40256": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40257": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40258": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40259": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40260": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40261": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40262": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40263": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40264": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40265": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40266": {"epss_score": 0.00025, "epss_percentile": 0.0632}, "CVE-2025-40267": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40268": {"epss_score": 0.00029, "epss_percentile": 0.07764}, "CVE-2025-40269": {"epss_score": 0.00105, "epss_percentile": 0.29314}, "CVE-2025-40270": {"epss_score": 0.00026, "epss_percentile": 0.06654}, "CVE-2025-40271": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40272": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40273": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40274": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40275": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40276": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40277": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40278": {"epss_score": 0.00043, "epss_percentile": 0.13241}, "CVE-2025-40279": {"epss_score": 0.00043, "epss_percentile": 0.13241}, "CVE-2025-40280": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40281": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40282": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40283": {"epss_score": 0.00035, "epss_percentile": 0.09935}, "CVE-2025-40284": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40285": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40286": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40287": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40288": {"epss_score": 0.00026, "epss_percentile": 0.06451}, "CVE-2025-40289": {"epss_score": 0.00024, "epss_percentile": 0.05788}, "CVE-2025-40290": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-40291": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40292": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-40293": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-40294": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-40295": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40296": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40297": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-40298": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40299": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40300": {"epss_score": 0.00058, "epss_percentile": 0.18571}, "CVE-2025-40301": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-40302": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-40303": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-40304": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40305": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40306": {"epss_score": 0.0004, "epss_percentile": 0.11914}, "CVE-2025-40307": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-40308": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40309": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40310": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-40311": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-40312": {"epss_score": 0.00022, "epss_percentile": 0.05054}, "CVE-2025-40313": {"epss_score": 0.00017, "epss_percentile": 0.03212}, "CVE-2025-40314": {"epss_score": 0.00022, "epss_percentile": 0.05054}, "CVE-2025-40315": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40316": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-40317": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40318": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-40319": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40320": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-40321": {"epss_score": 0.00029, "epss_percentile": 0.0783}, "CVE-2025-40322": {"epss_score": 0.00022, "epss_percentile": 0.05054}, "CVE-2025-40323": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-40324": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40325": {"epss_score": 0.00022, "epss_percentile": 0.05262}, "CVE-2025-40326": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40327": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40328": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-40329": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-40330": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40331": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40332": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-40333": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-40334": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40335": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40336": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40337": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-40338": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40339": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-40340": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-40341": {"epss_score": 0.00018, "epss_percentile": 0.03755}, "CVE-2025-40342": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40343": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40344": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-40345": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40346": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40347": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-40348": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-40349": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40350": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-40351": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40352": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40353": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-40354": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-40355": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40356": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-40357": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-40358": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-40359": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-40360": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40361": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40362": {"epss_score": 0.00059, "epss_percentile": 0.18799}, "CVE-2025-40363": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-40364": {"epss_score": 0.00025, "epss_percentile": 0.06041}, "CVE-2025-40545": {"epss_score": 0.00036, "epss_percentile": 0.10185}, "CVE-2025-40547": {"epss_score": 0.0013, "epss_percentile": 0.33272}, "CVE-2025-40548": {"epss_score": 0.00048, "epss_percentile": 0.14995}, "CVE-2025-40549": {"epss_score": 0.00181, "epss_percentile": 0.40026}, "CVE-2025-40555": {"epss_score": 0.00027, "epss_percentile": 0.07158}, "CVE-2025-40556": {"epss_score": 0.00039, "epss_percentile": 0.11795}, "CVE-2025-40566": {"epss_score": 0.0006, "epss_percentile": 0.1898}, "CVE-2025-40567": {"epss_score": 0.00048, "epss_percentile": 0.15049}, "CVE-2025-40568": {"epss_score": 0.00133, "epss_percentile": 0.33663}, "CVE-2025-40569": {"epss_score": 0.0003, "epss_percentile": 0.08251}, "CVE-2025-40570": {"epss_score": 0.00012, "epss_percentile": 0.01206}, "CVE-2025-40571": {"epss_score": 0.00024, "epss_percentile": 0.05957}, "CVE-2025-40572": {"epss_score": 0.00014, "epss_percentile": 0.02059}, "CVE-2025-40573": {"epss_score": 0.00023, "epss_percentile": 0.05425}, "CVE-2025-40574": {"epss_score": 0.00016, "epss_percentile": 0.02759}, "CVE-2025-40575": {"epss_score": 0.00107, "epss_percentile": 0.29721}, "CVE-2025-40576": {"epss_score": 0.00045, "epss_percentile": 0.13729}, "CVE-2025-40577": {"epss_score": 0.00052, "epss_percentile": 0.16515}, "CVE-2025-40578": {"epss_score": 0.00052, "epss_percentile": 0.16515}, "CVE-2025-40579": {"epss_score": 0.00014, "epss_percentile": 0.01857}, "CVE-2025-40580": {"epss_score": 0.00014, "epss_percentile": 0.01857}, "CVE-2025-40581": {"epss_score": 0.00019, "epss_percentile": 0.04066}, "CVE-2025-40582": {"epss_score": 0.00023, "epss_percentile": 0.05633}, "CVE-2025-40583": {"epss_score": 9e-05, "epss_percentile": 0.00609}, "CVE-2025-40584": {"epss_score": 8e-05, "epss_percentile": 0.00543}, "CVE-2025-40585": {"epss_score": 0.00055, "epss_percentile": 0.17561}, "CVE-2025-40591": {"epss_score": 0.00107, "epss_percentile": 0.29625}, "CVE-2025-40592": {"epss_score": 0.00033, "epss_percentile": 0.09396}, "CVE-2025-40593": {"epss_score": 0.00119, "epss_percentile": 0.3159}, "CVE-2025-40594": {"epss_score": 0.00038, "epss_percentile": 0.11302}, "CVE-2025-40595": {"epss_score": 0.00024, "epss_percentile": 0.05842}, "CVE-2025-40596": {"epss_score": 0.00114, "epss_percentile": 0.30825}, "CVE-2025-40597": {"epss_score": 0.00101, "epss_percentile": 0.28662}, "CVE-2025-40598": {"epss_score": 0.00082, "epss_percentile": 0.24474}, "CVE-2025-40599": {"epss_score": 0.00107, "epss_percentile": 0.29657}, "CVE-2025-40600": {"epss_score": 0.00081, "epss_percentile": 0.24361}, "CVE-2025-40601": {"epss_score": 0.00038, "epss_percentile": 0.11327}, "CVE-2025-40602": {"epss_score": 0.02086, "epss_percentile": 0.8355}, "CVE-2025-40603": {"epss_score": 0.00058, "epss_percentile": 0.18443}, "CVE-2025-40604": {"epss_score": 0.00026, "epss_percentile": 0.06558}, "CVE-2025-40605": {"epss_score": 0.00047, "epss_percentile": 0.14592}, "CVE-2025-40615": {"epss_score": 0.00027, "epss_percentile": 0.06771}, "CVE-2025-40616": {"epss_score": 0.00027, "epss_percentile": 0.06771}, "CVE-2025-40617": {"epss_score": 0.00042, "epss_percentile": 0.12736}, "CVE-2025-40618": {"epss_score": 0.00042, "epss_percentile": 0.12736}, "CVE-2025-40619": {"epss_score": 0.0005, "epss_percentile": 0.15902}, "CVE-2025-40620": {"epss_score": 0.00114, "epss_percentile": 0.30757}, "CVE-2025-40621": {"epss_score": 0.00114, "epss_percentile": 0.30757}, "CVE-2025-40622": {"epss_score": 0.00114, "epss_percentile": 0.30757}, "CVE-2025-40623": {"epss_score": 0.00114, "epss_percentile": 0.30757}, "CVE-2025-40624": {"epss_score": 0.00114, "epss_percentile": 0.30757}, "CVE-2025-40625": {"epss_score": 0.00868, "epss_percentile": 0.74669}, "CVE-2025-40626": {"epss_score": 0.00025, "epss_percentile": 0.06047}, "CVE-2025-40627": {"epss_score": 0.00025, "epss_percentile": 0.06047}, "CVE-2025-40628": {"epss_score": 0.00036, "epss_percentile": 0.10368}, "CVE-2025-40629": {"epss_score": 0.00399, "epss_percentile": 0.60107}, "CVE-2025-40630": {"epss_score": 0.00414, "epss_percentile": 0.61096}, "CVE-2025-40631": {"epss_score": 0.00028, "epss_percentile": 0.07485}, "CVE-2025-40632": {"epss_score": 0.00025, "epss_percentile": 0.06047}, "CVE-2025-40633": {"epss_score": 0.00056, "epss_percentile": 0.17684}, "CVE-2025-40634": {"epss_score": 0.0003, "epss_percentile": 0.08035}, "CVE-2025-40635": {"epss_score": 0.00036, "epss_percentile": 0.10368}, "CVE-2025-40636": {"epss_score": 0.00045, "epss_percentile": 0.13956}, "CVE-2025-40640": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-40641": {"epss_score": 0.00317, "epss_percentile": 0.54311}, "CVE-2025-40642": {"epss_score": 0.00565, "epss_percentile": 0.67799}, "CVE-2025-40643": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-40645": {"epss_score": 0.00147, "epss_percentile": 0.35776}, "CVE-2025-40646": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-40647": {"epss_score": 0.0007, "epss_percentile": 0.21704}, "CVE-2025-40648": {"epss_score": 0.00065, "epss_percentile": 0.20439}, "CVE-2025-40649": {"epss_score": 0.00245, "epss_percentile": 0.47644}, "CVE-2025-40650": {"epss_score": 0.0006, "epss_percentile": 0.19077}, "CVE-2025-40651": {"epss_score": 0.00056, "epss_percentile": 0.17828}, "CVE-2025-40652": {"epss_score": 0.00056, "epss_percentile": 0.17828}, "CVE-2025-40653": {"epss_score": 0.00057, "epss_percentile": 0.18152}, "CVE-2025-40654": {"epss_score": 0.0004, "epss_percentile": 0.12069}, "CVE-2025-40655": {"epss_score": 0.0004, "epss_percentile": 0.12069}, "CVE-2025-40656": {"epss_score": 0.0004, "epss_percentile": 0.12069}, "CVE-2025-40657": {"epss_score": 0.0004, "epss_percentile": 0.12069}, "CVE-2025-40658": {"epss_score": 0.00048, "epss_percentile": 0.15146}, "CVE-2025-40659": {"epss_score": 0.00048, "epss_percentile": 0.15146}, "CVE-2025-40660": {"epss_score": 0.00048, "epss_percentile": 0.15146}, "CVE-2025-40661": {"epss_score": 0.00048, "epss_percentile": 0.15146}, "CVE-2025-40662": {"epss_score": 0.00047, "epss_percentile": 0.1467}, "CVE-2025-40663": {"epss_score": 0.00056, "epss_percentile": 0.17684}, "CVE-2025-40664": {"epss_score": 0.00143, "epss_percentile": 0.35197}, "CVE-2025-40665": {"epss_score": 0.00038, "epss_percentile": 0.11222}, "CVE-2025-40666": {"epss_score": 0.00038, "epss_percentile": 0.11222}, "CVE-2025-40667": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-40668": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-40669": {"epss_score": 0.00035, "epss_percentile": 0.10127}, "CVE-2025-40670": {"epss_score": 0.00063, "epss_percentile": 0.1991}, "CVE-2025-40671": {"epss_score": 0.00036, "epss_percentile": 0.10368}, "CVE-2025-40672": {"epss_score": 0.00032, "epss_percentile": 0.0903}, "CVE-2025-40673": {"epss_score": 0.00056, "epss_percentile": 0.17917}, "CVE-2025-40674": {"epss_score": 0.00055, "epss_percentile": 0.17447}, "CVE-2025-40675": {"epss_score": 0.00026, "epss_percentile": 0.06436}, "CVE-2025-40676": {"epss_score": 0.00058, "epss_percentile": 0.18279}, "CVE-2025-40677": {"epss_score": 0.00209, "epss_percentile": 0.43372}, "CVE-2025-40678": {"epss_score": 0.00063, "epss_percentile": 0.19809}, "CVE-2025-40680": {"epss_score": 7e-05, "epss_percentile": 0.00411}, "CVE-2025-40681": {"epss_score": 0.00067, "epss_percentile": 0.2117}, "CVE-2025-40682": {"epss_score": 0.00035, "epss_percentile": 0.10114}, "CVE-2025-40683": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-40684": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-40685": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-40686": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-40687": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-40689": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-40690": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-40691": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-40692": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-40693": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-40694": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-40695": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-40696": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-40698": {"epss_score": 0.00045, "epss_percentile": 0.13775}, "CVE-2025-40700": {"epss_score": 0.00067, "epss_percentile": 0.2117}, "CVE-2025-40702": {"epss_score": 0.00072, "epss_percentile": 0.22269}, "CVE-2025-40703": {"epss_score": 0.00072, "epss_percentile": 0.22269}, "CVE-2025-40704": {"epss_score": 0.00072, "epss_percentile": 0.22269}, "CVE-2025-40705": {"epss_score": 0.00072, "epss_percentile": 0.22269}, "CVE-2025-40706": {"epss_score": 0.00028, "epss_percentile": 0.07543}, "CVE-2025-40707": {"epss_score": 0.00072, "epss_percentile": 0.22269}, "CVE-2025-40708": {"epss_score": 0.00072, "epss_percentile": 0.22269}, "CVE-2025-40709": {"epss_score": 0.00072, "epss_percentile": 0.22269}, "CVE-2025-40710": {"epss_score": 0.00041, "epss_percentile": 0.12393}, "CVE-2025-40711": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-40712": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-40713": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-40714": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-40715": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-40716": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-40717": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-40718": {"epss_score": 0.00042, "epss_percentile": 0.12575}, "CVE-2025-40719": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-40720": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-40721": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-40722": {"epss_score": 0.00054, "epss_percentile": 0.17294}, "CVE-2025-40723": {"epss_score": 0.00054, "epss_percentile": 0.17294}, "CVE-2025-40724": {"epss_score": 0.00054, "epss_percentile": 0.17294}, "CVE-2025-40725": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-40726": {"epss_score": 0.00384, "epss_percentile": 0.59155}, "CVE-2025-40727": {"epss_score": 0.00521, "epss_percentile": 0.66245}, "CVE-2025-40728": {"epss_score": 0.00035, "epss_percentile": 0.10114}, "CVE-2025-40729": {"epss_score": 0.00041, "epss_percentile": 0.12403}, "CVE-2025-40730": {"epss_score": 0.00054, "epss_percentile": 0.17294}, "CVE-2025-40731": {"epss_score": 0.00035, "epss_percentile": 0.10114}, "CVE-2025-40732": {"epss_score": 0.00042, "epss_percentile": 0.12575}, "CVE-2025-40733": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-40734": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-40735": {"epss_score": 0.0009, "epss_percentile": 0.26125}, "CVE-2025-40736": {"epss_score": 0.00151, "epss_percentile": 0.3633}, "CVE-2025-40737": {"epss_score": 0.00165, "epss_percentile": 0.38118}, "CVE-2025-40738": {"epss_score": 0.00165, "epss_percentile": 0.38118}, "CVE-2025-40739": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2025-40740": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2025-40741": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2025-40742": {"epss_score": 0.00037, "epss_percentile": 0.10908}, "CVE-2025-40743": {"epss_score": 0.00028, "epss_percentile": 0.07215}, "CVE-2025-40744": {"epss_score": 0.00023, "epss_percentile": 0.05604}, "CVE-2025-40746": {"epss_score": 0.00262, "epss_percentile": 0.49327}, "CVE-2025-40751": {"epss_score": 0.00014, "epss_percentile": 0.02042}, "CVE-2025-40752": {"epss_score": 8e-05, "epss_percentile": 0.00551}, "CVE-2025-40753": {"epss_score": 8e-05, "epss_percentile": 0.00551}, "CVE-2025-40755": {"epss_score": 0.00043, "epss_percentile": 0.13091}, "CVE-2025-40757": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-40758": {"epss_score": 0.00017, "epss_percentile": 0.03314}, "CVE-2025-40759": {"epss_score": 0.00092, "epss_percentile": 0.26422}, "CVE-2025-40760": {"epss_score": 0.00018, "epss_percentile": 0.03873}, "CVE-2025-40761": {"epss_score": 0.00032, "epss_percentile": 0.09007}, "CVE-2025-40762": {"epss_score": 0.00014, "epss_percentile": 0.01995}, "CVE-2025-40763": {"epss_score": 0.00017, "epss_percentile": 0.03502}, "CVE-2025-40764": {"epss_score": 0.00014, "epss_percentile": 0.01995}, "CVE-2025-40765": {"epss_score": 0.00126, "epss_percentile": 0.32758}, "CVE-2025-40766": {"epss_score": 0.00016, "epss_percentile": 0.02889}, "CVE-2025-40767": {"epss_score": 0.00012, "epss_percentile": 0.0134}, "CVE-2025-40768": {"epss_score": 0.00015, "epss_percentile": 0.026}, "CVE-2025-40769": {"epss_score": 0.00014, "epss_percentile": 0.02026}, "CVE-2025-40770": {"epss_score": 0.0001, "epss_percentile": 0.00869}, "CVE-2025-40771": {"epss_score": 0.00126, "epss_percentile": 0.32758}, "CVE-2025-40772": {"epss_score": 0.00064, "epss_percentile": 0.20171}, "CVE-2025-40773": {"epss_score": 0.00048, "epss_percentile": 0.15112}, "CVE-2025-40774": {"epss_score": 0.00019, "epss_percentile": 0.04101}, "CVE-2025-40775": {"epss_score": 0.00029, "epss_percentile": 0.07745}, "CVE-2025-40776": {"epss_score": 9e-05, "epss_percentile": 0.00601}, "CVE-2025-40777": {"epss_score": 0.00016, "epss_percentile": 0.02835}, "CVE-2025-40778": {"epss_score": 5e-05, "epss_percentile": 0.00206}, "CVE-2025-40779": {"epss_score": 0.00082, "epss_percentile": 0.24494}, "CVE-2025-40780": {"epss_score": 0.00027, "epss_percentile": 0.06837}, "CVE-2025-40795": {"epss_score": 0.00175, "epss_percentile": 0.39368}, "CVE-2025-40796": {"epss_score": 0.00122, "epss_percentile": 0.32043}, "CVE-2025-40797": {"epss_score": 0.00122, "epss_percentile": 0.32043}, "CVE-2025-40798": {"epss_score": 0.00122, "epss_percentile": 0.32043}, "CVE-2025-40800": {"epss_score": 0.00019, "epss_percentile": 0.04284}, "CVE-2025-40801": {"epss_score": 0.00026, "epss_percentile": 0.06724}, "CVE-2025-40802": {"epss_score": 0.00021, "epss_percentile": 0.04711}, "CVE-2025-40803": {"epss_score": 0.00021, "epss_percentile": 0.0485}, "CVE-2025-40804": {"epss_score": 0.00068, "epss_percentile": 0.21374}, "CVE-2025-40806": {"epss_score": 0.00045, "epss_percentile": 0.13687}, "CVE-2025-40807": {"epss_score": 0.00038, "epss_percentile": 0.11112}, "CVE-2025-40809": {"epss_score": 0.00026, "epss_percentile": 0.06386}, "CVE-2025-40810": {"epss_score": 0.00026, "epss_percentile": 0.06386}, "CVE-2025-40811": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-40812": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-40815": {"epss_score": 0.00056, "epss_percentile": 0.17809}, "CVE-2025-40816": {"epss_score": 0.00058, "epss_percentile": 0.18465}, "CVE-2025-40817": {"epss_score": 0.00036, "epss_percentile": 0.10214}, "CVE-2025-40818": {"epss_score": 9e-05, "epss_percentile": 0.00665}, "CVE-2025-40819": {"epss_score": 0.00031, "epss_percentile": 0.08569}, "CVE-2025-40820": {"epss_score": 0.00082, "epss_percentile": 0.24407}, "CVE-2025-40827": {"epss_score": 0.00018, "epss_percentile": 0.03637}, "CVE-2025-40829": {"epss_score": 0.00016, "epss_percentile": 0.02918}, "CVE-2025-40830": {"epss_score": 0.00015, "epss_percentile": 0.02124}, "CVE-2025-40831": {"epss_score": 0.00053, "epss_percentile": 0.16935}, "CVE-2025-40834": {"epss_score": 0.00038, "epss_percentile": 0.11195}, "CVE-2025-40836": {"epss_score": 0.00207, "epss_percentile": 0.43125}, "CVE-2025-40837": {"epss_score": 0.00062, "epss_percentile": 0.19574}, "CVE-2025-40838": {"epss_score": 0.00046, "epss_percentile": 0.14134}, "CVE-2025-40843": {"epss_score": 0.00018, "epss_percentile": 0.04012}, "CVE-2025-40846": {"epss_score": 0.00085, "epss_percentile": 0.25192}, "CVE-2025-40885": {"epss_score": 0.00037, "epss_percentile": 0.10928}, "CVE-2025-40886": {"epss_score": 0.00043, "epss_percentile": 0.13091}, "CVE-2025-40887": {"epss_score": 0.00037, "epss_percentile": 0.10928}, "CVE-2025-40888": {"epss_score": 0.00037, "epss_percentile": 0.10928}, "CVE-2025-40889": {"epss_score": 0.00084, "epss_percentile": 0.2496}, "CVE-2025-40890": {"epss_score": 0.0004, "epss_percentile": 0.1197}, "CVE-2025-40891": {"epss_score": 0.00024, "epss_percentile": 0.06003}, "CVE-2025-40892": {"epss_score": 0.00038, "epss_percentile": 0.11165}, "CVE-2025-40893": {"epss_score": 0.00033, "epss_percentile": 0.09156}, "CVE-2025-40898": {"epss_score": 0.00067, "epss_percentile": 0.21155}, "CVE-2025-40906": {"epss_score": 0.00104, "epss_percentile": 0.29134}, "CVE-2025-40907": {"epss_score": 0.00156, "epss_percentile": 0.36984}, "CVE-2025-40908": {"epss_score": 0.00058, "epss_percentile": 0.18447}, "CVE-2025-40909": {"epss_score": 0.0001, "epss_percentile": 0.00883}, "CVE-2025-40910": {"epss_score": 0.00056, "epss_percentile": 0.17688}, "CVE-2025-40911": {"epss_score": 0.00057, "epss_percentile": 0.18097}, "CVE-2025-40912": {"epss_score": 0.00069, "epss_percentile": 0.2152}, "CVE-2025-40913": {"epss_score": 0.00043, "epss_percentile": 0.13128}, "CVE-2025-40914": {"epss_score": 0.0009, "epss_percentile": 0.2601}, "CVE-2025-40915": {"epss_score": 0.00051, "epss_percentile": 0.15993}, "CVE-2025-40916": {"epss_score": 0.00044, "epss_percentile": 0.13475}, "CVE-2025-40918": {"epss_score": 0.00082, "epss_percentile": 0.24439}, "CVE-2025-40919": {"epss_score": 0.00044, "epss_percentile": 0.13521}, "CVE-2025-40920": {"epss_score": 0.00118, "epss_percentile": 0.31386}, "CVE-2025-40923": {"epss_score": 0.00069, "epss_percentile": 0.21476}, "CVE-2025-40924": {"epss_score": 0.00037, "epss_percentile": 0.10728}, "CVE-2025-40925": {"epss_score": 0.00044, "epss_percentile": 0.13388}, "CVE-2025-40927": {"epss_score": 0.00164, "epss_percentile": 0.37887}, "CVE-2025-40928": {"epss_score": 0.00129, "epss_percentile": 0.33205}, "CVE-2025-40929": {"epss_score": 0.00083, "epss_percentile": 0.24782}, "CVE-2025-40930": {"epss_score": 0.00104, "epss_percentile": 0.29147}, "CVE-2025-40933": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-40934": {"epss_score": 0.00015, "epss_percentile": 0.02603}, "CVE-2025-40935": {"epss_score": 0.0006, "epss_percentile": 0.19153}, "CVE-2025-40936": {"epss_score": 0.00018, "epss_percentile": 0.03637}, "CVE-2025-40937": {"epss_score": 0.00083, "epss_percentile": 0.24622}, "CVE-2025-40938": {"epss_score": 0.00058, "epss_percentile": 0.18261}, "CVE-2025-40939": {"epss_score": 0.00023, "epss_percentile": 0.05629}, "CVE-2025-40940": {"epss_score": 0.00039, "epss_percentile": 0.11694}, "CVE-2025-40941": {"epss_score": 0.00032, "epss_percentile": 0.09007}, "CVE-2025-40979": {"epss_score": 0.00022, "epss_percentile": 0.05216}, "CVE-2025-40980": {"epss_score": 0.0019, "epss_percentile": 0.41095}, "CVE-2025-40985": {"epss_score": 0.00027, "epss_percentile": 0.0674}, "CVE-2025-40989": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-40990": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-40991": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-40992": {"epss_score": 0.00245, "epss_percentile": 0.47644}, "CVE-2025-41000": {"epss_score": 0.00079, "epss_percentile": 0.23939}, "CVE-2025-41001": {"epss_score": 0.00046, "epss_percentile": 0.14287}, "CVE-2025-41009": {"epss_score": 0.00045, "epss_percentile": 0.13956}, "CVE-2025-41010": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-41012": {"epss_score": 0.00072, "epss_percentile": 0.22349}, "CVE-2025-41013": {"epss_score": 0.00039, "epss_percentile": 0.11662}, "CVE-2025-41014": {"epss_score": 0.0009, "epss_percentile": 0.26005}, "CVE-2025-41015": {"epss_score": 0.0009, "epss_percentile": 0.26005}, "CVE-2025-41016": {"epss_score": 0.00059, "epss_percentile": 0.1864}, "CVE-2025-41017": {"epss_score": 0.00059, "epss_percentile": 0.1864}, "CVE-2025-41018": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-41019": {"epss_score": 0.00045, "epss_percentile": 0.13956}, "CVE-2025-41020": {"epss_score": 0.00047, "epss_percentile": 0.14644}, "CVE-2025-41021": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-41028": {"epss_score": 0.00045, "epss_percentile": 0.13956}, "CVE-2025-41030": {"epss_score": 0.00126, "epss_percentile": 0.32755}, "CVE-2025-41031": {"epss_score": 0.00126, "epss_percentile": 0.32755}, "CVE-2025-41032": {"epss_score": 0.00059, "epss_percentile": 0.1866}, "CVE-2025-41033": {"epss_score": 0.00059, "epss_percentile": 0.1866}, "CVE-2025-41034": {"epss_score": 0.00059, "epss_percentile": 0.1866}, "CVE-2025-41035": {"epss_score": 0.0005, "epss_percentile": 0.15734}, "CVE-2025-41036": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41037": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41038": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41039": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41040": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41041": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41042": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41043": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41044": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41045": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41046": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41047": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41048": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41049": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41050": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41051": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41052": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41053": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41054": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41055": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41056": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41057": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41058": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41059": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41060": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41061": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41062": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41063": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-41064": {"epss_score": 0.00091, "epss_percentile": 0.26392}, "CVE-2025-41066": {"epss_score": 0.00055, "epss_percentile": 0.17409}, "CVE-2025-41067": {"epss_score": 0.00059, "epss_percentile": 0.18927}, "CVE-2025-41068": {"epss_score": 0.00059, "epss_percentile": 0.18927}, "CVE-2025-41069": {"epss_score": 0.0005, "epss_percentile": 0.15677}, "CVE-2025-41070": {"epss_score": 0.0006, "epss_percentile": 0.19139}, "CVE-2025-41073": {"epss_score": 0.0006, "epss_percentile": 0.19145}, "CVE-2025-41074": {"epss_score": 0.00057, "epss_percentile": 0.18164}, "CVE-2025-41075": {"epss_score": 0.00057, "epss_percentile": 0.18164}, "CVE-2025-41076": {"epss_score": 0.00039, "epss_percentile": 0.11777}, "CVE-2025-41079": {"epss_score": 0.00038, "epss_percentile": 0.1141}, "CVE-2025-41080": {"epss_score": 0.00038, "epss_percentile": 0.1141}, "CVE-2025-41086": {"epss_score": 0.00059, "epss_percentile": 0.1864}, "CVE-2025-41087": {"epss_score": 0.0006, "epss_percentile": 0.19139}, "CVE-2025-41088": {"epss_score": 0.0007, "epss_percentile": 0.21704}, "CVE-2025-41089": {"epss_score": 0.0007, "epss_percentile": 0.21704}, "CVE-2025-41090": {"epss_score": 0.00058, "epss_percentile": 0.18279}, "CVE-2025-41091": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-41092": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-41093": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-41094": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-41095": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-41096": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-41097": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-41098": {"epss_score": 0.00047, "epss_percentile": 0.14644}, "CVE-2025-41099": {"epss_score": 0.00034, "epss_percentile": 0.09785}, "CVE-2025-41100": {"epss_score": 0.00037, "epss_percentile": 0.10764}, "CVE-2025-41101": {"epss_score": 0.00033, "epss_percentile": 0.09367}, "CVE-2025-41102": {"epss_score": 0.00033, "epss_percentile": 0.09367}, "CVE-2025-41103": {"epss_score": 0.00033, "epss_percentile": 0.09367}, "CVE-2025-41104": {"epss_score": 0.00033, "epss_percentile": 0.09367}, "CVE-2025-41105": {"epss_score": 0.00033, "epss_percentile": 0.09367}, "CVE-2025-41106": {"epss_score": 0.00033, "epss_percentile": 0.09367}, "CVE-2025-41107": {"epss_score": 0.00046, "epss_percentile": 0.14287}, "CVE-2025-41108": {"epss_score": 0.0005, "epss_percentile": 0.15778}, "CVE-2025-41109": {"epss_score": 0.00032, "epss_percentile": 0.0882}, "CVE-2025-41110": {"epss_score": 0.00037, "epss_percentile": 0.10774}, "CVE-2025-41111": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41112": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41113": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41114": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41115": {"epss_score": 0.0004, "epss_percentile": 0.11969}, "CVE-2025-41116": {"epss_score": 0.00054, "epss_percentile": 0.17168}, "CVE-2025-41222": {"epss_score": 0.00097, "epss_percentile": 0.27616}, "CVE-2025-41223": {"epss_score": 0.00015, "epss_percentile": 0.02551}, "CVE-2025-41224": {"epss_score": 0.00025, "epss_percentile": 0.06138}, "CVE-2025-41225": {"epss_score": 0.00033, "epss_percentile": 0.09209}, "CVE-2025-41226": {"epss_score": 0.00039, "epss_percentile": 0.11536}, "CVE-2025-41227": {"epss_score": 0.00023, "epss_percentile": 0.05652}, "CVE-2025-41228": {"epss_score": 0.02571, "epss_percentile": 0.85131}, "CVE-2025-41229": {"epss_score": 0.00533, "epss_percentile": 0.66751}, "CVE-2025-41230": {"epss_score": 0.00057, "epss_percentile": 0.18084}, "CVE-2025-41231": {"epss_score": 0.00025, "epss_percentile": 0.06338}, "CVE-2025-41232": {"epss_score": 0.0005, "epss_percentile": 0.15962}, "CVE-2025-41233": {"epss_score": 0.00039, "epss_percentile": 0.11789}, "CVE-2025-41234": {"epss_score": 0.00119, "epss_percentile": 0.31683}, "CVE-2025-41235": {"epss_score": 0.00058, "epss_percentile": 0.1838}, "CVE-2025-41236": {"epss_score": 0.0003, "epss_percentile": 0.0822}, "CVE-2025-41237": {"epss_score": 0.00025, "epss_percentile": 0.06372}, "CVE-2025-41238": {"epss_score": 0.00025, "epss_percentile": 0.06372}, "CVE-2025-41239": {"epss_score": 0.00032, "epss_percentile": 0.09032}, "CVE-2025-41240": {"epss_score": 0.00268, "epss_percentile": 0.50065}, "CVE-2025-41241": {"epss_score": 0.0005, "epss_percentile": 0.1571}, "CVE-2025-41242": {"epss_score": 0.00064, "epss_percentile": 0.20156}, "CVE-2025-41243": {"epss_score": 0.07004, "epss_percentile": 0.91179}, "CVE-2025-41244": {"epss_score": 0.00915, "epss_percentile": 0.75397}, "CVE-2025-41245": {"epss_score": 0.00054, "epss_percentile": 0.17083}, "CVE-2025-41246": {"epss_score": 0.00033, "epss_percentile": 0.09352}, "CVE-2025-41248": {"epss_score": 0.00059, "epss_percentile": 0.18634}, "CVE-2025-41249": {"epss_score": 0.0008, "epss_percentile": 0.24198}, "CVE-2025-41250": {"epss_score": 0.00081, "epss_percentile": 0.24364}, "CVE-2025-41251": {"epss_score": 0.00081, "epss_percentile": 0.24239}, "CVE-2025-41252": {"epss_score": 0.0007, "epss_percentile": 0.21705}, "CVE-2025-41253": {"epss_score": 0.00062, "epss_percentile": 0.19652}, "CVE-2025-41254": {"epss_score": 0.00087, "epss_percentile": 0.25572}, "CVE-2025-41255": {"epss_score": 0.0002, "epss_percentile": 0.04597}, "CVE-2025-41256": {"epss_score": 0.00012, "epss_percentile": 0.01135}, "CVE-2025-41335": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41336": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41337": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41338": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41339": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41340": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41341": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41342": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41343": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41344": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41345": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-41346": {"epss_score": 0.00059, "epss_percentile": 0.18882}, "CVE-2025-41347": {"epss_score": 0.00055, "epss_percentile": 0.17403}, "CVE-2025-41348": {"epss_score": 0.00039, "epss_percentile": 0.11662}, "CVE-2025-41349": {"epss_score": 0.00046, "epss_percentile": 0.14287}, "CVE-2025-41350": {"epss_score": 0.00046, "epss_percentile": 0.14287}, "CVE-2025-41358": {"epss_score": 0.00043, "epss_percentile": 0.13184}, "CVE-2025-41360": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-41361": {"epss_score": 0.00075, "epss_percentile": 0.22985}, "CVE-2025-41362": {"epss_score": 0.00058, "epss_percentile": 0.18529}, "CVE-2025-41363": {"epss_score": 0.00059, "epss_percentile": 0.18803}, "CVE-2025-41364": {"epss_score": 0.00058, "epss_percentile": 0.18529}, "CVE-2025-41365": {"epss_score": 0.0005, "epss_percentile": 0.15766}, "CVE-2025-41366": {"epss_score": 0.00051, "epss_percentile": 0.16013}, "CVE-2025-41367": {"epss_score": 0.0005, "epss_percentile": 0.15766}, "CVE-2025-41370": {"epss_score": 0.0003, "epss_percentile": 0.08089}, "CVE-2025-41371": {"epss_score": 0.0003, "epss_percentile": 0.08089}, "CVE-2025-41372": {"epss_score": 0.0003, "epss_percentile": 0.08089}, "CVE-2025-41373": {"epss_score": 0.00029, "epss_percentile": 0.07814}, "CVE-2025-41374": {"epss_score": 0.0003, "epss_percentile": 0.08089}, "CVE-2025-41375": {"epss_score": 0.0003, "epss_percentile": 0.08051}, "CVE-2025-41376": {"epss_score": 0.00162, "epss_percentile": 0.37617}, "CVE-2025-41377": {"epss_score": 0.00036, "epss_percentile": 0.10249}, "CVE-2025-41378": {"epss_score": 0.00038, "epss_percentile": 0.11333}, "CVE-2025-41379": {"epss_score": 0.00093, "epss_percentile": 0.26637}, "CVE-2025-41380": {"epss_score": 0.00018, "epss_percentile": 0.03683}, "CVE-2025-41384": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-41385": {"epss_score": 0.00066, "epss_percentile": 0.20933}, "CVE-2025-41388": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2025-41390": {"epss_score": 0.00018, "epss_percentile": 0.0372}, "CVE-2025-41391": {"epss_score": 0.00025, "epss_percentile": 0.06066}, "CVE-2025-41392": {"epss_score": 0.00038, "epss_percentile": 0.11287}, "CVE-2025-41393": {"epss_score": 0.00621, "epss_percentile": 0.69483}, "CVE-2025-41395": {"epss_score": 0.00063, "epss_percentile": 0.19835}, "CVE-2025-41396": {"epss_score": 0.00036, "epss_percentile": 0.10306}, "CVE-2025-41399": {"epss_score": 0.00087, "epss_percentile": 0.25629}, "CVE-2025-41402": {"epss_score": 0.00024, "epss_percentile": 0.05745}, "CVE-2025-41403": {"epss_score": 0.00342, "epss_percentile": 0.56371}, "CVE-2025-41404": {"epss_score": 0.00029, "epss_percentile": 0.07611}, "CVE-2025-41406": {"epss_score": 0.00023, "epss_percentile": 0.05358}, "CVE-2025-41407": {"epss_score": 0.00158, "epss_percentile": 0.37165}, "CVE-2025-41408": {"epss_score": 0.00053, "epss_percentile": 0.16703}, "CVE-2025-41410": {"epss_score": 0.00013, "epss_percentile": 0.01616}, "CVE-2025-41413": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2025-41414": {"epss_score": 0.00102, "epss_percentile": 0.28791}, "CVE-2025-41415": {"epss_score": 0.00056, "epss_percentile": 0.17746}, "CVE-2025-41418": {"epss_score": 0.00053, "epss_percentile": 0.16996}, "CVE-2025-41420": {"epss_score": 0.00126, "epss_percentile": 0.32757}, "CVE-2025-41421": {"epss_score": 0.00023, "epss_percentile": 0.05346}, "CVE-2025-41423": {"epss_score": 0.00014, "epss_percentile": 0.01744}, "CVE-2025-41425": {"epss_score": 0.00051, "epss_percentile": 0.16305}, "CVE-2025-41426": {"epss_score": 0.00194, "epss_percentile": 0.41566}, "CVE-2025-41427": {"epss_score": 0.00273, "epss_percentile": 0.5043}, "CVE-2025-41428": {"epss_score": 0.00071, "epss_percentile": 0.22218}, "CVE-2025-41429": {"epss_score": 0.0005, "epss_percentile": 0.15774}, "CVE-2025-41430": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-41431": {"epss_score": 0.00087, "epss_percentile": 0.25629}, "CVE-2025-41433": {"epss_score": 0.00102, "epss_percentile": 0.28791}, "CVE-2025-41436": {"epss_score": 0.00034, "epss_percentile": 0.09676}, "CVE-2025-41437": {"epss_score": 0.00026, "epss_percentile": 0.06436}, "CVE-2025-41438": {"epss_score": 0.00077, "epss_percentile": 0.23316}, "CVE-2025-41439": {"epss_score": 0.00026, "epss_percentile": 0.06382}, "CVE-2025-41441": {"epss_score": 0.00039, "epss_percentile": 0.1158}, "CVE-2025-41442": {"epss_score": 0.00038, "epss_percentile": 0.11277}, "CVE-2025-41443": {"epss_score": 0.00011, "epss_percentile": 0.00998}, "CVE-2025-41444": {"epss_score": 0.00167, "epss_percentile": 0.38291}, "CVE-2025-41450": {"epss_score": 0.00042, "epss_percentile": 0.12493}, "CVE-2025-41451": {"epss_score": 0.00775, "epss_percentile": 0.73083}, "CVE-2025-41452": {"epss_score": 0.00096, "epss_percentile": 0.27395}, "CVE-2025-41458": {"epss_score": 8e-05, "epss_percentile": 0.00561}, "CVE-2025-41459": {"epss_score": 0.00014, "epss_percentile": 0.01911}, "CVE-2025-41645": {"epss_score": 0.00041, "epss_percentile": 0.1243}, "CVE-2025-41646": {"epss_score": 0.16049, "epss_percentile": 0.94565}, "CVE-2025-41647": {"epss_score": 8e-05, "epss_percentile": 0.00561}, "CVE-2025-41648": {"epss_score": 0.00083, "epss_percentile": 0.24813}, "CVE-2025-41649": {"epss_score": 0.00086, "epss_percentile": 0.2529}, "CVE-2025-41650": {"epss_score": 0.00086, "epss_percentile": 0.2529}, "CVE-2025-41651": {"epss_score": 0.00151, "epss_percentile": 0.36228}, "CVE-2025-41652": {"epss_score": 0.00081, "epss_percentile": 0.2421}, "CVE-2025-41653": {"epss_score": 0.0016, "epss_percentile": 0.37491}, "CVE-2025-41654": {"epss_score": 0.00112, "epss_percentile": 0.30579}, "CVE-2025-41655": {"epss_score": 0.00118, "epss_percentile": 0.31453}, "CVE-2025-41656": {"epss_score": 0.00139, "epss_percentile": 0.3463}, "CVE-2025-41657": {"epss_score": 0.0002, "epss_percentile": 0.04562}, "CVE-2025-41658": {"epss_score": 0.00012, "epss_percentile": 0.01288}, "CVE-2025-41659": {"epss_score": 0.00031, "epss_percentile": 0.0863}, "CVE-2025-41661": {"epss_score": 0.00068, "epss_percentile": 0.2135}, "CVE-2025-41663": {"epss_score": 0.00123, "epss_percentile": 0.32294}, "CVE-2025-41664": {"epss_score": 0.0014, "epss_percentile": 0.34779}, "CVE-2025-41665": {"epss_score": 0.00119, "epss_percentile": 0.31536}, "CVE-2025-41666": {"epss_score": 0.00305, "epss_percentile": 0.53345}, "CVE-2025-41667": {"epss_score": 0.00305, "epss_percentile": 0.53345}, "CVE-2025-41668": {"epss_score": 0.00305, "epss_percentile": 0.53345}, "CVE-2025-41672": {"epss_score": 0.0011, "epss_percentile": 0.30118}, "CVE-2025-41673": {"epss_score": 0.00134, "epss_percentile": 0.33926}, "CVE-2025-41674": {"epss_score": 0.00134, "epss_percentile": 0.33926}, "CVE-2025-41675": {"epss_score": 0.00134, "epss_percentile": 0.33926}, "CVE-2025-41676": {"epss_score": 0.00141, "epss_percentile": 0.34806}, "CVE-2025-41677": {"epss_score": 0.00141, "epss_percentile": 0.34806}, "CVE-2025-41678": {"epss_score": 0.00134, "epss_percentile": 0.33926}, "CVE-2025-41679": {"epss_score": 0.00184, "epss_percentile": 0.40458}, "CVE-2025-41681": {"epss_score": 0.0003, "epss_percentile": 0.08156}, "CVE-2025-41682": {"epss_score": 0.00075, "epss_percentile": 0.23056}, "CVE-2025-41683": {"epss_score": 0.00234, "epss_percentile": 0.46178}, "CVE-2025-41684": {"epss_score": 0.00234, "epss_percentile": 0.46178}, "CVE-2025-41685": {"epss_score": 0.00076, "epss_percentile": 0.23209}, "CVE-2025-41686": {"epss_score": 0.00014, "epss_percentile": 0.01883}, "CVE-2025-41687": {"epss_score": 0.0011, "epss_percentile": 0.30153}, "CVE-2025-41688": {"epss_score": 0.00148, "epss_percentile": 0.35889}, "CVE-2025-41689": {"epss_score": 0.00056, "epss_percentile": 0.17714}, "CVE-2025-41690": {"epss_score": 0.00039, "epss_percentile": 0.11454}, "CVE-2025-41691": {"epss_score": 0.00095, "epss_percentile": 0.27151}, "CVE-2025-41692": {"epss_score": 0.0002, "epss_percentile": 0.04659}, "CVE-2025-41693": {"epss_score": 0.00229, "epss_percentile": 0.45646}, "CVE-2025-41694": {"epss_score": 0.00114, "epss_percentile": 0.30806}, "CVE-2025-41695": {"epss_score": 0.00091, "epss_percentile": 0.26272}, "CVE-2025-41696": {"epss_score": 0.00021, "epss_percentile": 0.0476}, "CVE-2025-41697": {"epss_score": 0.00024, "epss_percentile": 0.05734}, "CVE-2025-41698": {"epss_score": 0.00014, "epss_percentile": 0.02086}, "CVE-2025-41699": {"epss_score": 0.00386, "epss_percentile": 0.59254}, "CVE-2025-41700": {"epss_score": 0.00033, "epss_percentile": 0.09149}, "CVE-2025-41701": {"epss_score": 0.00051, "epss_percentile": 0.16132}, "CVE-2025-41702": {"epss_score": 0.00213, "epss_percentile": 0.43902}, "CVE-2025-41703": {"epss_score": 0.00125, "epss_percentile": 0.32505}, "CVE-2025-41704": {"epss_score": 0.00156, "epss_percentile": 0.3701}, "CVE-2025-41705": {"epss_score": 0.00036, "epss_percentile": 0.1052}, "CVE-2025-41706": {"epss_score": 0.00108, "epss_percentile": 0.29803}, "CVE-2025-41707": {"epss_score": 0.00108, "epss_percentile": 0.29803}, "CVE-2025-41708": {"epss_score": 0.00045, "epss_percentile": 0.13752}, "CVE-2025-41713": {"epss_score": 0.00105, "epss_percentile": 0.29365}, "CVE-2025-41714": {"epss_score": 0.00518, "epss_percentile": 0.66104}, "CVE-2025-41715": {"epss_score": 0.00184, "epss_percentile": 0.4044}, "CVE-2025-41716": {"epss_score": 0.00047, "epss_percentile": 0.14705}, "CVE-2025-41718": {"epss_score": 0.00024, "epss_percentile": 0.05998}, "CVE-2025-41719": {"epss_score": 0.00151, "epss_percentile": 0.36347}, "CVE-2025-41720": {"epss_score": 0.00027, "epss_percentile": 0.06822}, "CVE-2025-41721": {"epss_score": 0.00032, "epss_percentile": 0.091}, "CVE-2025-41722": {"epss_score": 0.00029, "epss_percentile": 0.07603}, "CVE-2025-41723": {"epss_score": 0.00635, "epss_percentile": 0.69813}, "CVE-2025-41724": {"epss_score": 0.00122, "epss_percentile": 0.32043}, "CVE-2025-41729": {"epss_score": 0.00102, "epss_percentile": 0.28807}, "CVE-2025-41730": {"epss_score": 0.00114, "epss_percentile": 0.30864}, "CVE-2025-41731": {"epss_score": 0.00028, "epss_percentile": 0.07348}, "CVE-2025-41732": {"epss_score": 0.00114, "epss_percentile": 0.30864}, "CVE-2025-41733": {"epss_score": 0.00121, "epss_percentile": 0.31893}, "CVE-2025-41734": {"epss_score": 0.00127, "epss_percentile": 0.3279}, "CVE-2025-41735": {"epss_score": 0.00268, "epss_percentile": 0.50072}, "CVE-2025-41736": {"epss_score": 0.00501, "epss_percentile": 0.65362}, "CVE-2025-41737": {"epss_score": 0.00049, "epss_percentile": 0.15611}, "CVE-2025-41738": {"epss_score": 0.00118, "epss_percentile": 0.31486}, "CVE-2025-41739": {"epss_score": 0.00116, "epss_percentile": 0.31193}, "CVE-2025-41742": {"epss_score": 0.00157, "epss_percentile": 0.37109}, "CVE-2025-41743": {"epss_score": 5e-05, "epss_percentile": 0.00175}, "CVE-2025-41744": {"epss_score": 0.00058, "epss_percentile": 0.18577}, "CVE-2025-41745": {"epss_score": 0.00088, "epss_percentile": 0.25657}, "CVE-2025-41746": {"epss_score": 0.00088, "epss_percentile": 0.25657}, "CVE-2025-41747": {"epss_score": 0.00088, "epss_percentile": 0.25657}, "CVE-2025-41748": {"epss_score": 0.00088, "epss_percentile": 0.25657}, "CVE-2025-41749": {"epss_score": 0.00088, "epss_percentile": 0.25657}, "CVE-2025-41750": {"epss_score": 0.00088, "epss_percentile": 0.25657}, "CVE-2025-41751": {"epss_score": 0.00088, "epss_percentile": 0.25657}, "CVE-2025-41752": {"epss_score": 0.00088, "epss_percentile": 0.25657}, "CVE-2025-42598": {"epss_score": 0.00018, "epss_percentile": 0.04039}, "CVE-2025-42599": {"epss_score": 0.08014, "epss_percentile": 0.91829}, "CVE-2025-42600": {"epss_score": 0.00331, "epss_percentile": 0.55536}, "CVE-2025-42601": {"epss_score": 0.00129, "epss_percentile": 0.33147}, "CVE-2025-42602": {"epss_score": 0.00196, "epss_percentile": 0.41808}, "CVE-2025-42603": {"epss_score": 0.00186, "epss_percentile": 0.40613}, "CVE-2025-42604": {"epss_score": 0.00286, "epss_percentile": 0.51744}, "CVE-2025-42605": {"epss_score": 0.00331, "epss_percentile": 0.55536}, "CVE-2025-42615": {"epss_score": 0.00057, "epss_percentile": 0.18126}, "CVE-2025-42616": {"epss_score": 0.00023, "epss_percentile": 0.0542}, "CVE-2025-42620": {"epss_score": 0.00057, "epss_percentile": 0.18017}, "CVE-2025-42701": {"epss_score": 0.00017, "epss_percentile": 0.03155}, "CVE-2025-42706": {"epss_score": 0.0001, "epss_percentile": 0.00857}, "CVE-2025-42872": {"epss_score": 0.0006, "epss_percentile": 0.19183}, "CVE-2025-42873": {"epss_score": 0.00052, "epss_percentile": 0.16594}, "CVE-2025-42874": {"epss_score": 0.00075, "epss_percentile": 0.22911}, "CVE-2025-42875": {"epss_score": 0.00079, "epss_percentile": 0.23821}, "CVE-2025-42876": {"epss_score": 0.00034, "epss_percentile": 0.0971}, "CVE-2025-42877": {"epss_score": 0.00077, "epss_percentile": 0.2344}, "CVE-2025-42878": {"epss_score": 0.00056, "epss_percentile": 0.17799}, "CVE-2025-42880": {"epss_score": 0.00073, "epss_percentile": 0.22509}, "CVE-2025-42882": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-42883": {"epss_score": 0.00038, "epss_percentile": 0.11159}, "CVE-2025-42884": {"epss_score": 0.00131, "epss_percentile": 0.33414}, "CVE-2025-42885": {"epss_score": 0.001, "epss_percentile": 0.28488}, "CVE-2025-42886": {"epss_score": 0.00145, "epss_percentile": 0.35447}, "CVE-2025-42887": {"epss_score": 0.00061, "epss_percentile": 0.19377}, "CVE-2025-42888": {"epss_score": 6e-05, "epss_percentile": 0.00282}, "CVE-2025-42889": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-42890": {"epss_score": 0.00097, "epss_percentile": 0.27506}, "CVE-2025-42891": {"epss_score": 0.00034, "epss_percentile": 0.09696}, "CVE-2025-42892": {"epss_score": 0.01106, "epss_percentile": 0.77613}, "CVE-2025-42893": {"epss_score": 0.00081, "epss_percentile": 0.24354}, "CVE-2025-42894": {"epss_score": 0.00109, "epss_percentile": 0.29964}, "CVE-2025-42895": {"epss_score": 0.00021, "epss_percentile": 0.04763}, "CVE-2025-42896": {"epss_score": 0.00031, "epss_percentile": 0.08475}, "CVE-2025-42897": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-42899": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-42901": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-42902": {"epss_score": 0.00063, "epss_percentile": 0.19817}, "CVE-2025-42903": {"epss_score": 0.00028, "epss_percentile": 0.07284}, "CVE-2025-42904": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-42906": {"epss_score": 0.0006, "epss_percentile": 0.19078}, "CVE-2025-42907": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-42908": {"epss_score": 0.0002, "epss_percentile": 0.04518}, "CVE-2025-42909": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2025-42910": {"epss_score": 0.00053, "epss_percentile": 0.16792}, "CVE-2025-42911": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-42912": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-42913": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-42914": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-42915": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-42916": {"epss_score": 0.00052, "epss_percentile": 0.16445}, "CVE-2025-42917": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-42918": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-42919": {"epss_score": 0.00204, "epss_percentile": 0.42667}, "CVE-2025-42920": {"epss_score": 0.00168, "epss_percentile": 0.38411}, "CVE-2025-42921": {"epss_score": 1e-05, "epss_percentile": 0.00017}, "CVE-2025-42922": {"epss_score": 0.00071, "epss_percentile": 0.22046}, "CVE-2025-42923": {"epss_score": 0.00021, "epss_percentile": 0.04914}, "CVE-2025-42924": {"epss_score": 0.00076, "epss_percentile": 0.23074}, "CVE-2025-42925": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-42926": {"epss_score": 0.00076, "epss_percentile": 0.23268}, "CVE-2025-42927": {"epss_score": 0.00016, "epss_percentile": 0.02906}, "CVE-2025-42928": {"epss_score": 0.00759, "epss_percentile": 0.72795}, "CVE-2025-42929": {"epss_score": 0.00052, "epss_percentile": 0.16445}, "CVE-2025-42930": {"epss_score": 0.00088, "epss_percentile": 0.2568}, "CVE-2025-42933": {"epss_score": 0.00034, "epss_percentile": 0.09698}, "CVE-2025-42934": {"epss_score": 0.00029, "epss_percentile": 0.07661}, "CVE-2025-42935": {"epss_score": 0.0001, "epss_percentile": 0.00881}, "CVE-2025-42936": {"epss_score": 0.0003, "epss_percentile": 0.08069}, "CVE-2025-42937": {"epss_score": 0.00185, "epss_percentile": 0.40506}, "CVE-2025-42938": {"epss_score": 0.00134, "epss_percentile": 0.33845}, "CVE-2025-42939": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-42940": {"epss_score": 0.0013, "epss_percentile": 0.33294}, "CVE-2025-42941": {"epss_score": 0.00021, "epss_percentile": 0.04725}, "CVE-2025-42942": {"epss_score": 0.00069, "epss_percentile": 0.21435}, "CVE-2025-42943": {"epss_score": 0.00043, "epss_percentile": 0.13345}, "CVE-2025-42944": {"epss_score": 0.0002, "epss_percentile": 0.04539}, "CVE-2025-42945": {"epss_score": 0.00021, "epss_percentile": 0.04748}, "CVE-2025-42946": {"epss_score": 0.0009, "epss_percentile": 0.26163}, "CVE-2025-42947": {"epss_score": 0.00046, "epss_percentile": 0.14376}, "CVE-2025-42948": {"epss_score": 0.00069, "epss_percentile": 0.21435}, "CVE-2025-42949": {"epss_score": 0.00031, "epss_percentile": 0.08457}, "CVE-2025-42950": {"epss_score": 0.00062, "epss_percentile": 0.1964}, "CVE-2025-42951": {"epss_score": 0.00049, "epss_percentile": 0.15428}, "CVE-2025-42952": {"epss_score": 0.00052, "epss_percentile": 0.16552}, "CVE-2025-42953": {"epss_score": 0.00052, "epss_percentile": 0.16552}, "CVE-2025-42954": {"epss_score": 0.00021, "epss_percentile": 0.04846}, "CVE-2025-42955": {"epss_score": 0.00017, "epss_percentile": 0.03229}, "CVE-2025-42956": {"epss_score": 0.00106, "epss_percentile": 0.29506}, "CVE-2025-42957": {"epss_score": 0.00067, "epss_percentile": 0.20984}, "CVE-2025-42958": {"epss_score": 0.00104, "epss_percentile": 0.29235}, "CVE-2025-42959": {"epss_score": 0.00125, "epss_percentile": 0.32469}, "CVE-2025-42960": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-42961": {"epss_score": 0.00033, "epss_percentile": 0.09135}, "CVE-2025-42962": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-42963": {"epss_score": 0.00149, "epss_percentile": 0.3594}, "CVE-2025-42964": {"epss_score": 0.00117, "epss_percentile": 0.31366}, "CVE-2025-42965": {"epss_score": 0.0003, "epss_percentile": 0.08202}, "CVE-2025-42966": {"epss_score": 0.00149, "epss_percentile": 0.3594}, "CVE-2025-42967": {"epss_score": 0.00388, "epss_percentile": 0.59371}, "CVE-2025-42968": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-42969": {"epss_score": 0.00106, "epss_percentile": 0.29506}, "CVE-2025-42970": {"epss_score": 0.0005, "epss_percentile": 0.15709}, "CVE-2025-42971": {"epss_score": 0.00015, "epss_percentile": 0.02159}, "CVE-2025-42973": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-42974": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-42975": {"epss_score": 0.00069, "epss_percentile": 0.21435}, "CVE-2025-42976": {"epss_score": 0.00053, "epss_percentile": 0.16891}, "CVE-2025-42977": {"epss_score": 0.00206, "epss_percentile": 0.43059}, "CVE-2025-42978": {"epss_score": 0.00017, "epss_percentile": 0.03481}, "CVE-2025-42979": {"epss_score": 0.00013, "epss_percentile": 0.01475}, "CVE-2025-42980": {"epss_score": 0.00117, "epss_percentile": 0.31366}, "CVE-2025-42981": {"epss_score": 0.00091, "epss_percentile": 0.26409}, "CVE-2025-42982": {"epss_score": 0.00063, "epss_percentile": 0.1991}, "CVE-2025-42983": {"epss_score": 0.00056, "epss_percentile": 0.17784}, "CVE-2025-42984": {"epss_score": 0.00052, "epss_percentile": 0.16469}, "CVE-2025-42985": {"epss_score": 0.00027, "epss_percentile": 0.06924}, "CVE-2025-42986": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-42987": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-42988": {"epss_score": 0.00056, "epss_percentile": 0.17805}, "CVE-2025-42989": {"epss_score": 0.00056, "epss_percentile": 0.17784}, "CVE-2025-42990": {"epss_score": 0.00027, "epss_percentile": 0.06813}, "CVE-2025-42991": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-42992": {"epss_score": 0.00011, "epss_percentile": 0.00968}, "CVE-2025-42993": {"epss_score": 0.00104, "epss_percentile": 0.29106}, "CVE-2025-42994": {"epss_score": 0.00052, "epss_percentile": 0.16348}, "CVE-2025-42995": {"epss_score": 0.00052, "epss_percentile": 0.16348}, "CVE-2025-42996": {"epss_score": 0.00043, "epss_percentile": 0.13076}, "CVE-2025-42997": {"epss_score": 0.00046, "epss_percentile": 0.14163}, "CVE-2025-42998": {"epss_score": 0.0002, "epss_percentile": 0.0453}, "CVE-2025-42999": {"epss_score": 0.41001, "epss_percentile": 0.97249}, "CVE-2025-43000": {"epss_score": 0.00019, "epss_percentile": 0.04405}, "CVE-2025-43001": {"epss_score": 0.00011, "epss_percentile": 0.00968}, "CVE-2025-43002": {"epss_score": 0.00038, "epss_percentile": 0.1112}, "CVE-2025-43003": {"epss_score": 0.00048, "epss_percentile": 0.15029}, "CVE-2025-43004": {"epss_score": 0.00088, "epss_percentile": 0.25649}, "CVE-2025-43005": {"epss_score": 0.00025, "epss_percentile": 0.06143}, "CVE-2025-43006": {"epss_score": 0.00101, "epss_percentile": 0.28656}, "CVE-2025-43007": {"epss_score": 0.0005, "epss_percentile": 0.15664}, "CVE-2025-43008": {"epss_score": 0.00029, "epss_percentile": 0.07585}, "CVE-2025-43009": {"epss_score": 0.0005, "epss_percentile": 0.15664}, "CVE-2025-43010": {"epss_score": 0.0005, "epss_percentile": 0.15863}, "CVE-2025-43011": {"epss_score": 0.00041, "epss_percentile": 0.12303}, "CVE-2025-43012": {"epss_score": 2e-05, "epss_percentile": 0.00052}, "CVE-2025-43013": {"epss_score": 1e-05, "epss_percentile": 2e-05}, "CVE-2025-43014": {"epss_score": 0.00011, "epss_percentile": 0.01001}, "CVE-2025-43015": {"epss_score": 0.00016, "epss_percentile": 0.02743}, "CVE-2025-43016": {"epss_score": 2e-05, "epss_percentile": 0.00033}, "CVE-2025-43017": {"epss_score": 0.00021, "epss_percentile": 0.04863}, "CVE-2025-43018": {"epss_score": 0.0006, "epss_percentile": 0.19177}, "CVE-2025-43019": {"epss_score": 0.00015, "epss_percentile": 0.02476}, "CVE-2025-43020": {"epss_score": 0.0002, "epss_percentile": 0.04492}, "CVE-2025-43021": {"epss_score": 0.00013, "epss_percentile": 0.0172}, "CVE-2025-43022": {"epss_score": 0.0002, "epss_percentile": 0.04501}, "CVE-2025-43023": {"epss_score": 0.00023, "epss_percentile": 0.05404}, "CVE-2025-43024": {"epss_score": 0.00021, "epss_percentile": 0.04909}, "CVE-2025-43025": {"epss_score": 0.00026, "epss_percentile": 0.06594}, "CVE-2025-43026": {"epss_score": 0.00022, "epss_percentile": 0.04965}, "CVE-2025-43027": {"epss_score": 0.00062, "epss_percentile": 0.19687}, "CVE-2025-43079": {"epss_score": 0.0001, "epss_percentile": 0.00824}, "CVE-2025-43184": {"epss_score": 0.00074, "epss_percentile": 0.22716}, "CVE-2025-43185": {"epss_score": 7e-05, "epss_percentile": 0.00412}, "CVE-2025-43186": {"epss_score": 0.00146, "epss_percentile": 0.35635}, "CVE-2025-43187": {"epss_score": 0.00014, "epss_percentile": 0.01777}, "CVE-2025-43188": {"epss_score": 0.00016, "epss_percentile": 0.02845}, "CVE-2025-43189": {"epss_score": 0.00076, "epss_percentile": 0.23113}, "CVE-2025-43190": {"epss_score": 0.00014, "epss_percentile": 0.02074}, "CVE-2025-43191": {"epss_score": 0.00029, "epss_percentile": 0.07687}, "CVE-2025-43192": {"epss_score": 0.00074, "epss_percentile": 0.22678}, "CVE-2025-43193": {"epss_score": 0.0009, "epss_percentile": 0.26096}, "CVE-2025-43194": {"epss_score": 0.00087, "epss_percentile": 0.25612}, "CVE-2025-43195": {"epss_score": 0.00018, "epss_percentile": 0.03857}, "CVE-2025-43196": {"epss_score": 0.00031, "epss_percentile": 0.08684}, "CVE-2025-43197": {"epss_score": 0.00016, "epss_percentile": 0.02871}, "CVE-2025-43198": {"epss_score": 0.00074, "epss_percentile": 0.22678}, "CVE-2025-43199": {"epss_score": 0.00075, "epss_percentile": 0.22968}, "CVE-2025-43200": {"epss_score": 0.00323, "epss_percentile": 0.549}, "CVE-2025-43201": {"epss_score": 0.00023, "epss_percentile": 0.0535}, "CVE-2025-43203": {"epss_score": 0.00016, "epss_percentile": 0.02889}, "CVE-2025-43204": {"epss_score": 0.00017, "epss_percentile": 0.03495}, "CVE-2025-43205": {"epss_score": 0.0001, "epss_percentile": 0.00799}, "CVE-2025-43206": {"epss_score": 0.00022, "epss_percentile": 0.05269}, "CVE-2025-43207": {"epss_score": 0.00018, "epss_percentile": 0.03597}, "CVE-2025-43208": {"epss_score": 0.00018, "epss_percentile": 0.03835}, "CVE-2025-43209": {"epss_score": 0.00093, "epss_percentile": 0.26664}, "CVE-2025-43211": {"epss_score": 0.00017, "epss_percentile": 0.03191}, "CVE-2025-43212": {"epss_score": 0.00058, "epss_percentile": 0.18263}, "CVE-2025-43213": {"epss_score": 0.00074, "epss_percentile": 0.22873}, "CVE-2025-43214": {"epss_score": 0.00099, "epss_percentile": 0.27866}, "CVE-2025-43215": {"epss_score": 0.00013, "epss_percentile": 0.01539}, "CVE-2025-43216": {"epss_score": 0.00069, "epss_percentile": 0.21628}, "CVE-2025-43217": {"epss_score": 0.00018, "epss_percentile": 0.0357}, "CVE-2025-43218": {"epss_score": 0.00013, "epss_percentile": 0.01539}, "CVE-2025-43220": {"epss_score": 0.00141, "epss_percentile": 0.34951}, "CVE-2025-43221": {"epss_score": 0.00014, "epss_percentile": 0.0199}, "CVE-2025-43222": {"epss_score": 0.00076, "epss_percentile": 0.23095}, "CVE-2025-43223": {"epss_score": 0.00138, "epss_percentile": 0.34356}, "CVE-2025-43224": {"epss_score": 0.00014, "epss_percentile": 0.0199}, "CVE-2025-43225": {"epss_score": 0.00012, "epss_percentile": 0.0129}, "CVE-2025-43226": {"epss_score": 0.00017, "epss_percentile": 0.03125}, "CVE-2025-43227": {"epss_score": 0.00089, "epss_percentile": 0.25852}, "CVE-2025-43228": {"epss_score": 0.00033, "epss_percentile": 0.09389}, "CVE-2025-43229": {"epss_score": 0.00029, "epss_percentile": 0.07664}, "CVE-2025-43230": {"epss_score": 0.00015, "epss_percentile": 0.02312}, "CVE-2025-43231": {"epss_score": 0.00018, "epss_percentile": 0.03597}, "CVE-2025-43232": {"epss_score": 0.00075, "epss_percentile": 0.22968}, "CVE-2025-43233": {"epss_score": 0.00087, "epss_percentile": 0.25612}, "CVE-2025-43234": {"epss_score": 0.00164, "epss_percentile": 0.37999}, "CVE-2025-43235": {"epss_score": 0.00014, "epss_percentile": 0.02012}, "CVE-2025-43237": {"epss_score": 0.00064, "epss_percentile": 0.20428}, "CVE-2025-43239": {"epss_score": 0.00014, "epss_percentile": 0.0199}, "CVE-2025-43240": {"epss_score": 0.00025, "epss_percentile": 0.06315}, "CVE-2025-43241": {"epss_score": 0.00011, "epss_percentile": 0.00971}, "CVE-2025-43243": {"epss_score": 0.00075, "epss_percentile": 0.22968}, "CVE-2025-43244": {"epss_score": 0.0007, "epss_percentile": 0.21685}, "CVE-2025-43245": {"epss_score": 0.00087, "epss_percentile": 0.25612}, "CVE-2025-43246": {"epss_score": 0.00012, "epss_percentile": 0.01135}, "CVE-2025-43247": {"epss_score": 0.00046, "epss_percentile": 0.14282}, "CVE-2025-43248": {"epss_score": 0.0002, "epss_percentile": 0.04519}, "CVE-2025-43249": {"epss_score": 0.00021, "epss_percentile": 0.04765}, "CVE-2025-43250": {"epss_score": 0.00022, "epss_percentile": 0.05272}, "CVE-2025-43251": {"epss_score": 0.00013, "epss_percentile": 0.01527}, "CVE-2025-43252": {"epss_score": 0.00039, "epss_percentile": 0.11432}, "CVE-2025-43253": {"epss_score": 0.00115, "epss_percentile": 0.3093}, "CVE-2025-43254": {"epss_score": 0.00014, "epss_percentile": 0.0199}, "CVE-2025-43255": {"epss_score": 0.00013, "epss_percentile": 0.01717}, "CVE-2025-43256": {"epss_score": 0.00013, "epss_percentile": 0.01598}, "CVE-2025-43259": {"epss_score": 0.00028, "epss_percentile": 0.07487}, "CVE-2025-43260": {"epss_score": 0.00014, "epss_percentile": 0.02061}, "CVE-2025-43261": {"epss_score": 0.00136, "epss_percentile": 0.34101}, "CVE-2025-43262": {"epss_score": 0.00018, "epss_percentile": 0.03978}, "CVE-2025-43263": {"epss_score": 0.00017, "epss_percentile": 0.03133}, "CVE-2025-43265": {"epss_score": 0.00016, "epss_percentile": 0.02939}, "CVE-2025-43266": {"epss_score": 0.00013, "epss_percentile": 0.01611}, "CVE-2025-43267": {"epss_score": 0.00016, "epss_percentile": 0.0275}, "CVE-2025-43268": {"epss_score": 0.00014, "epss_percentile": 0.01965}, "CVE-2025-43270": {"epss_score": 0.00016, "epss_percentile": 0.02658}, "CVE-2025-43272": {"epss_score": 0.0005, "epss_percentile": 0.15852}, "CVE-2025-43273": {"epss_score": 0.00047, "epss_percentile": 0.14664}, "CVE-2025-43274": {"epss_score": 0.0001, "epss_percentile": 0.00836}, "CVE-2025-43275": {"epss_score": 0.0007, "epss_percentile": 0.21685}, "CVE-2025-43276": {"epss_score": 0.0007, "epss_percentile": 0.21653}, "CVE-2025-43277": {"epss_score": 0.0002, "epss_percentile": 0.04568}, "CVE-2025-43279": {"epss_score": 0.00019, "epss_percentile": 0.04169}, "CVE-2025-43280": {"epss_score": 0.0004, "epss_percentile": 0.12184}, "CVE-2025-43281": {"epss_score": 0.0002, "epss_percentile": 0.0455}, "CVE-2025-43282": {"epss_score": 0.00015, "epss_percentile": 0.02218}, "CVE-2025-43283": {"epss_score": 0.0002, "epss_percentile": 0.04421}, "CVE-2025-43284": {"epss_score": 0.0002, "epss_percentile": 0.04635}, "CVE-2025-43285": {"epss_score": 0.00012, "epss_percentile": 0.01247}, "CVE-2025-43286": {"epss_score": 0.00017, "epss_percentile": 0.03217}, "CVE-2025-43287": {"epss_score": 0.00018, "epss_percentile": 0.03764}, "CVE-2025-43288": {"epss_score": 0.00016, "epss_percentile": 0.02762}, "CVE-2025-43291": {"epss_score": 0.00011, "epss_percentile": 0.0104}, "CVE-2025-43292": {"epss_score": 0.00013, "epss_percentile": 0.01599}, "CVE-2025-43293": {"epss_score": 0.0003, "epss_percentile": 0.08261}, "CVE-2025-43294": {"epss_score": 0.00017, "epss_percentile": 0.03096}, "CVE-2025-43295": {"epss_score": 0.00015, "epss_percentile": 0.02218}, "CVE-2025-43296": {"epss_score": 0.00011, "epss_percentile": 0.0105}, "CVE-2025-43297": {"epss_score": 0.0002, "epss_percentile": 0.04469}, "CVE-2025-43298": {"epss_score": 0.00033, "epss_percentile": 0.09191}, "CVE-2025-43299": {"epss_score": 0.00029, "epss_percentile": 0.07834}, "CVE-2025-43300": {"epss_score": 0.01079, "epss_percentile": 0.77357}, "CVE-2025-43301": {"epss_score": 0.00015, "epss_percentile": 0.02337}, "CVE-2025-43302": {"epss_score": 0.00017, "epss_percentile": 0.03196}, "CVE-2025-43303": {"epss_score": 0.00015, "epss_percentile": 0.02515}, "CVE-2025-43304": {"epss_score": 0.00013, "epss_percentile": 0.01473}, "CVE-2025-43305": {"epss_score": 0.00016, "epss_percentile": 0.02652}, "CVE-2025-43307": {"epss_score": 0.00018, "epss_percentile": 0.03957}, "CVE-2025-43308": {"epss_score": 0.00038, "epss_percentile": 0.11398}, "CVE-2025-43309": {"epss_score": 0.0002, "epss_percentile": 0.04623}, "CVE-2025-43310": {"epss_score": 0.00016, "epss_percentile": 0.02929}, "CVE-2025-43311": {"epss_score": 0.00016, "epss_percentile": 0.0281}, "CVE-2025-43312": {"epss_score": 0.00015, "epss_percentile": 0.02192}, "CVE-2025-43313": {"epss_score": 0.00014, "epss_percentile": 0.02046}, "CVE-2025-43314": {"epss_score": 0.00015, "epss_percentile": 0.02346}, "CVE-2025-43315": {"epss_score": 0.00016, "epss_percentile": 0.02652}, "CVE-2025-43316": {"epss_score": 0.00013, "epss_percentile": 0.017}, "CVE-2025-43317": {"epss_score": 0.00012, "epss_percentile": 0.01259}, "CVE-2025-43318": {"epss_score": 0.00019, "epss_percentile": 0.04348}, "CVE-2025-43319": {"epss_score": 0.00016, "epss_percentile": 0.02652}, "CVE-2025-43320": {"epss_score": 0.00014, "epss_percentile": 0.01768}, "CVE-2025-43321": {"epss_score": 0.00016, "epss_percentile": 0.02652}, "CVE-2025-43322": {"epss_score": 0.00012, "epss_percentile": 0.01413}, "CVE-2025-43323": {"epss_score": 0.00038, "epss_percentile": 0.11217}, "CVE-2025-43325": {"epss_score": 0.00018, "epss_percentile": 0.03597}, "CVE-2025-43326": {"epss_score": 0.00015, "epss_percentile": 0.02479}, "CVE-2025-43327": {"epss_score": 0.00045, "epss_percentile": 0.13754}, "CVE-2025-43328": {"epss_score": 0.00013, "epss_percentile": 0.01709}, "CVE-2025-43329": {"epss_score": 0.00011, "epss_percentile": 0.01103}, "CVE-2025-43330": {"epss_score": 0.0002, "epss_percentile": 0.04582}, "CVE-2025-43331": {"epss_score": 0.00018, "epss_percentile": 0.03957}, "CVE-2025-43332": {"epss_score": 0.00015, "epss_percentile": 0.02364}, "CVE-2025-43333": {"epss_score": 0.00018, "epss_percentile": 0.03743}, "CVE-2025-43334": {"epss_score": 0.00012, "epss_percentile": 0.01413}, "CVE-2025-43335": {"epss_score": 0.00012, "epss_percentile": 0.01413}, "CVE-2025-43336": {"epss_score": 0.00012, "epss_percentile": 0.01419}, "CVE-2025-43337": {"epss_score": 0.00016, "epss_percentile": 0.02722}, "CVE-2025-43338": {"epss_score": 0.00024, "epss_percentile": 0.05961}, "CVE-2025-43340": {"epss_score": 0.00018, "epss_percentile": 0.03743}, "CVE-2025-43341": {"epss_score": 0.00013, "epss_percentile": 0.017}, "CVE-2025-43342": {"epss_score": 0.00357, "epss_percentile": 0.57478}, "CVE-2025-43343": {"epss_score": 0.00136, "epss_percentile": 0.34099}, "CVE-2025-43344": {"epss_score": 0.00017, "epss_percentile": 0.03448}, "CVE-2025-43345": {"epss_score": 0.00013, "epss_percentile": 0.01669}, "CVE-2025-43346": {"epss_score": 0.00014, "epss_percentile": 0.01917}, "CVE-2025-43347": {"epss_score": 0.00195, "epss_percentile": 0.41606}, "CVE-2025-43348": {"epss_score": 0.00025, "epss_percentile": 0.06219}, "CVE-2025-43349": {"epss_score": 0.00019, "epss_percentile": 0.04058}, "CVE-2025-43350": {"epss_score": 0.00021, "epss_percentile": 0.04769}, "CVE-2025-43351": {"epss_score": 0.00011, "epss_percentile": 0.00967}, "CVE-2025-43353": {"epss_score": 0.00015, "epss_percentile": 0.02192}, "CVE-2025-43354": {"epss_score": 0.00015, "epss_percentile": 0.0216}, "CVE-2025-43355": {"epss_score": 0.00014, "epss_percentile": 0.0183}, "CVE-2025-43356": {"epss_score": 0.0006, "epss_percentile": 0.18971}, "CVE-2025-43357": {"epss_score": 0.00016, "epss_percentile": 0.02621}, "CVE-2025-43358": {"epss_score": 0.00011, "epss_percentile": 0.01103}, "CVE-2025-43359": {"epss_score": 0.00112, "epss_percentile": 0.30556}, "CVE-2025-43360": {"epss_score": 0.00016, "epss_percentile": 0.02876}, "CVE-2025-43361": {"epss_score": 0.00014, "epss_percentile": 0.01959}, "CVE-2025-43362": {"epss_score": 0.00069, "epss_percentile": 0.21548}, "CVE-2025-43364": {"epss_score": 0.00011, "epss_percentile": 0.01039}, "CVE-2025-43365": {"epss_score": 0.00023, "epss_percentile": 0.05381}, "CVE-2025-43366": {"epss_score": 0.00017, "epss_percentile": 0.03337}, "CVE-2025-43367": {"epss_score": 0.00016, "epss_percentile": 0.02623}, "CVE-2025-43368": {"epss_score": 0.00057, "epss_percentile": 0.18141}, "CVE-2025-43369": {"epss_score": 0.00018, "epss_percentile": 0.03597}, "CVE-2025-43370": {"epss_score": 0.0002, "epss_percentile": 0.04537}, "CVE-2025-43371": {"epss_score": 0.00017, "epss_percentile": 0.03133}, "CVE-2025-43372": {"epss_score": 0.00053, "epss_percentile": 0.16887}, "CVE-2025-43373": {"epss_score": 0.00044, "epss_percentile": 0.13523}, "CVE-2025-43374": {"epss_score": 0.00032, "epss_percentile": 0.09006}, "CVE-2025-43375": {"epss_score": 0.00074, "epss_percentile": 0.22706}, "CVE-2025-43376": {"epss_score": 0.00063, "epss_percentile": 0.19825}, "CVE-2025-43377": {"epss_score": 0.00015, "epss_percentile": 0.0237}, "CVE-2025-43378": {"epss_score": 0.00015, "epss_percentile": 0.02514}, "CVE-2025-43379": {"epss_score": 0.0002, "epss_percentile": 0.0442}, "CVE-2025-43380": {"epss_score": 0.00014, "epss_percentile": 0.01801}, "CVE-2025-43381": {"epss_score": 0.00019, "epss_percentile": 0.04233}, "CVE-2025-43382": {"epss_score": 0.00018, "epss_percentile": 0.03663}, "CVE-2025-43383": {"epss_score": 0.00047, "epss_percentile": 0.14602}, "CVE-2025-43384": {"epss_score": 0.00047, "epss_percentile": 0.14602}, "CVE-2025-43385": {"epss_score": 0.00047, "epss_percentile": 0.14602}, "CVE-2025-43386": {"epss_score": 0.00014, "epss_percentile": 0.02038}, "CVE-2025-43387": {"epss_score": 0.00013, "epss_percentile": 0.01519}, "CVE-2025-43388": {"epss_score": 0.0002, "epss_percentile": 0.04615}, "CVE-2025-43389": {"epss_score": 0.00016, "epss_percentile": 0.0276}, "CVE-2025-43390": {"epss_score": 6e-05, "epss_percentile": 0.00322}, "CVE-2025-43391": {"epss_score": 0.00013, "epss_percentile": 0.0165}, "CVE-2025-43392": {"epss_score": 0.00042, "epss_percentile": 0.12597}, "CVE-2025-43393": {"epss_score": 0.0001, "epss_percentile": 0.00859}, "CVE-2025-43394": {"epss_score": 0.0001, "epss_percentile": 0.00785}, "CVE-2025-43395": {"epss_score": 0.00014, "epss_percentile": 0.02076}, "CVE-2025-43396": {"epss_score": 0.00012, "epss_percentile": 0.01413}, "CVE-2025-43397": {"epss_score": 0.0001, "epss_percentile": 0.00892}, "CVE-2025-43398": {"epss_score": 0.00015, "epss_percentile": 0.02462}, "CVE-2025-43399": {"epss_score": 0.00042, "epss_percentile": 0.12606}, "CVE-2025-43400": {"epss_score": 0.00055, "epss_percentile": 0.17412}, "CVE-2025-43401": {"epss_score": 0.00184, "epss_percentile": 0.40446}, "CVE-2025-43402": {"epss_score": 0.00015, "epss_percentile": 0.02223}, "CVE-2025-43404": {"epss_score": 0.0001, "epss_percentile": 0.00859}, "CVE-2025-43405": {"epss_score": 0.00045, "epss_percentile": 0.13963}, "CVE-2025-43406": {"epss_score": 0.00014, "epss_percentile": 0.01958}, "CVE-2025-43407": {"epss_score": 0.00013, "epss_percentile": 0.01475}, "CVE-2025-43408": {"epss_score": 0.00019, "epss_percentile": 0.04332}, "CVE-2025-43409": {"epss_score": 0.00013, "epss_percentile": 0.01644}, "CVE-2025-43410": {"epss_score": 0.00017, "epss_percentile": 0.03399}, "CVE-2025-43411": {"epss_score": 0.00012, "epss_percentile": 0.01296}, "CVE-2025-43412": {"epss_score": 0.00013, "epss_percentile": 0.01518}, "CVE-2025-43413": {"epss_score": 0.00071, "epss_percentile": 0.22208}, "CVE-2025-43414": {"epss_score": 0.00015, "epss_percentile": 0.02551}, "CVE-2025-43416": {"epss_score": 0.00025, "epss_percentile": 0.06274}, "CVE-2025-43418": {"epss_score": 0.00023, "epss_percentile": 0.05357}, "CVE-2025-43419": {"epss_score": 0.00049, "epss_percentile": 0.15609}, "CVE-2025-43420": {"epss_score": 0.00012, "epss_percentile": 0.01244}, "CVE-2025-43421": {"epss_score": 0.00041, "epss_percentile": 0.12447}, "CVE-2025-43422": {"epss_score": 0.0002, "epss_percentile": 0.04593}, "CVE-2025-43423": {"epss_score": 0.0002, "epss_percentile": 0.04626}, "CVE-2025-43424": {"epss_score": 0.00021, "epss_percentile": 0.04782}, "CVE-2025-43425": {"epss_score": 0.00049, "epss_percentile": 0.15645}, "CVE-2025-43426": {"epss_score": 0.00016, "epss_percentile": 0.02876}, "CVE-2025-43427": {"epss_score": 0.00119, "epss_percentile": 0.31685}, "CVE-2025-43428": {"epss_score": 0.00113, "epss_percentile": 0.30636}, "CVE-2025-43429": {"epss_score": 0.00058, "epss_percentile": 0.18468}, "CVE-2025-43430": {"epss_score": 0.00181, "epss_percentile": 0.40032}, "CVE-2025-43431": {"epss_score": 0.00056, "epss_percentile": 0.17681}, "CVE-2025-43432": {"epss_score": 0.00049, "epss_percentile": 0.15645}, "CVE-2025-43433": {"epss_score": 0.00056, "epss_percentile": 0.17681}, "CVE-2025-43434": {"epss_score": 0.00047, "epss_percentile": 0.14653}, "CVE-2025-43435": {"epss_score": 0.00047, "epss_percentile": 0.14653}, "CVE-2025-43436": {"epss_score": 0.00038, "epss_percentile": 0.11096}, "CVE-2025-43437": {"epss_score": 0.00013, "epss_percentile": 0.01677}, "CVE-2025-43438": {"epss_score": 0.00047, "epss_percentile": 0.14653}, "CVE-2025-43439": {"epss_score": 0.00014, "epss_percentile": 0.02095}, "CVE-2025-43440": {"epss_score": 0.00064, "epss_percentile": 0.20259}, "CVE-2025-43441": {"epss_score": 0.00047, "epss_percentile": 0.14653}, "CVE-2025-43442": {"epss_score": 0.00011, "epss_percentile": 0.01111}, "CVE-2025-43443": {"epss_score": 0.00063, "epss_percentile": 0.20091}, "CVE-2025-43444": {"epss_score": 0.00038, "epss_percentile": 0.11341}, "CVE-2025-43445": {"epss_score": 0.00045, "epss_percentile": 0.13718}, "CVE-2025-43446": {"epss_score": 0.00024, "epss_percentile": 0.05807}, "CVE-2025-43447": {"epss_score": 0.00014, "epss_percentile": 0.01749}, "CVE-2025-43448": {"epss_score": 0.00028, "epss_percentile": 0.07354}, "CVE-2025-43449": {"epss_score": 0.00047, "epss_percentile": 0.14492}, "CVE-2025-43450": {"epss_score": 0.0004, "epss_percentile": 0.1204}, "CVE-2025-43452": {"epss_score": 0.00022, "epss_percentile": 0.05187}, "CVE-2025-43454": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-43455": {"epss_score": 0.00013, "epss_percentile": 0.0165}, "CVE-2025-43457": {"epss_score": 0.00044, "epss_percentile": 0.13632}, "CVE-2025-43458": {"epss_score": 0.00097, "epss_percentile": 0.27559}, "CVE-2025-43459": {"epss_score": 0.00026, "epss_percentile": 0.06464}, "CVE-2025-43460": {"epss_score": 0.00022, "epss_percentile": 0.05187}, "CVE-2025-43461": {"epss_score": 0.00019, "epss_percentile": 0.04228}, "CVE-2025-43462": {"epss_score": 0.00067, "epss_percentile": 0.21128}, "CVE-2025-43463": {"epss_score": 0.00019, "epss_percentile": 0.04348}, "CVE-2025-43464": {"epss_score": 0.00105, "epss_percentile": 0.2927}, "CVE-2025-43465": {"epss_score": 0.00018, "epss_percentile": 0.03879}, "CVE-2025-43466": {"epss_score": 0.00021, "epss_percentile": 0.04888}, "CVE-2025-43467": {"epss_score": 0.00015, "epss_percentile": 0.02223}, "CVE-2025-43468": {"epss_score": 6e-05, "epss_percentile": 0.00297}, "CVE-2025-43469": {"epss_score": 0.00011, "epss_percentile": 0.00984}, "CVE-2025-43470": {"epss_score": 0.00011, "epss_percentile": 0.00967}, "CVE-2025-43471": {"epss_score": 0.00014, "epss_percentile": 0.01958}, "CVE-2025-43472": {"epss_score": 0.00021, "epss_percentile": 0.04734}, "CVE-2025-43473": {"epss_score": 0.00014, "epss_percentile": 0.01958}, "CVE-2025-43474": {"epss_score": 0.00014, "epss_percentile": 0.01827}, "CVE-2025-43475": {"epss_score": 0.00014, "epss_percentile": 0.01958}, "CVE-2025-43476": {"epss_score": 0.00013, "epss_percentile": 0.01478}, "CVE-2025-43477": {"epss_score": 0.00012, "epss_percentile": 0.01413}, "CVE-2025-43478": {"epss_score": 0.00014, "epss_percentile": 0.01801}, "CVE-2025-43479": {"epss_score": 0.00012, "epss_percentile": 0.0142}, "CVE-2025-43480": {"epss_score": 0.00043, "epss_percentile": 0.13092}, "CVE-2025-43481": {"epss_score": 0.00014, "epss_percentile": 0.01994}, "CVE-2025-43482": {"epss_score": 0.00018, "epss_percentile": 0.03754}, "CVE-2025-43483": {"epss_score": 0.00013, "epss_percentile": 0.0172}, "CVE-2025-43484": {"epss_score": 0.00016, "epss_percentile": 0.0304}, "CVE-2025-43485": {"epss_score": 0.00016, "epss_percentile": 0.02919}, "CVE-2025-43486": {"epss_score": 0.00015, "epss_percentile": 0.02415}, "CVE-2025-43487": {"epss_score": 0.0002, "epss_percentile": 0.04546}, "CVE-2025-43488": {"epss_score": 0.00015, "epss_percentile": 0.02415}, "CVE-2025-43489": {"epss_score": 0.001, "epss_percentile": 0.28545}, "CVE-2025-43490": {"epss_score": 0.0004, "epss_percentile": 0.12066}, "CVE-2025-43491": {"epss_score": 0.00033, "epss_percentile": 0.09195}, "CVE-2025-43493": {"epss_score": 0.00035, "epss_percentile": 0.10161}, "CVE-2025-43494": {"epss_score": 0.002, "epss_percentile": 0.42235}, "CVE-2025-43495": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-43496": {"epss_score": 0.00049, "epss_percentile": 0.15606}, "CVE-2025-43497": {"epss_score": 0.00012, "epss_percentile": 0.01355}, "CVE-2025-43498": {"epss_score": 0.00014, "epss_percentile": 0.01771}, "CVE-2025-43499": {"epss_score": 0.00015, "epss_percentile": 0.02324}, "CVE-2025-43500": {"epss_score": 0.00046, "epss_percentile": 0.14296}, "CVE-2025-43501": {"epss_score": 0.00072, "epss_percentile": 0.22394}, "CVE-2025-43502": {"epss_score": 0.00047, "epss_percentile": 0.14808}, "CVE-2025-43503": {"epss_score": 0.00039, "epss_percentile": 0.11837}, "CVE-2025-43504": {"epss_score": 0.00069, "epss_percentile": 0.21547}, "CVE-2025-43505": {"epss_score": 0.00061, "epss_percentile": 0.19475}, "CVE-2025-43506": {"epss_score": 0.00043, "epss_percentile": 0.13025}, "CVE-2025-43507": {"epss_score": 0.00043, "epss_percentile": 0.13171}, "CVE-2025-43509": {"epss_score": 0.00011, "epss_percentile": 0.0105}, "CVE-2025-43510": {"epss_score": 0.00013, "epss_percentile": 0.01485}, "CVE-2025-43511": {"epss_score": 0.00049, "epss_percentile": 0.15323}, "CVE-2025-43512": {"epss_score": 0.00011, "epss_percentile": 0.00991}, "CVE-2025-43513": {"epss_score": 0.00012, "epss_percentile": 0.01203}, "CVE-2025-43514": {"epss_score": 0.00014, "epss_percentile": 0.01958}, "CVE-2025-43515": {"epss_score": 0.00078, "epss_percentile": 0.23776}, "CVE-2025-43516": {"epss_score": 0.00011, "epss_percentile": 0.00923}, "CVE-2025-43517": {"epss_score": 0.00011, "epss_percentile": 0.01094}, "CVE-2025-43518": {"epss_score": 0.00011, "epss_percentile": 0.01086}, "CVE-2025-43519": {"epss_score": 0.00026, "epss_percentile": 0.06595}, "CVE-2025-43520": {"epss_score": 0.00014, "epss_percentile": 0.01962}, "CVE-2025-43521": {"epss_score": 6e-05, "epss_percentile": 0.0029}, "CVE-2025-43522": {"epss_score": 6e-05, "epss_percentile": 0.00273}, "CVE-2025-43523": {"epss_score": 0.00014, "epss_percentile": 0.0197}, "CVE-2025-43526": {"epss_score": 0.0005, "epss_percentile": 0.15841}, "CVE-2025-43527": {"epss_score": 0.00011, "epss_percentile": 0.0105}, "CVE-2025-43529": {"epss_score": 0.00052, "epss_percentile": 0.1662}, "CVE-2025-43530": {"epss_score": 0.00012, "epss_percentile": 0.0143}, "CVE-2025-43531": {"epss_score": 0.00097, "epss_percentile": 0.2751}, "CVE-2025-43532": {"epss_score": 0.00014, "epss_percentile": 0.01914}, "CVE-2025-43533": {"epss_score": 0.00039, "epss_percentile": 0.1155}, "CVE-2025-43535": {"epss_score": 0.00036, "epss_percentile": 0.10604}, "CVE-2025-43536": {"epss_score": 0.00057, "epss_percentile": 0.18058}, "CVE-2025-43538": {"epss_score": 0.00014, "epss_percentile": 0.01772}, "CVE-2025-43539": {"epss_score": 0.00039, "epss_percentile": 0.1164}, "CVE-2025-43541": {"epss_score": 0.00039, "epss_percentile": 0.11801}, "CVE-2025-43542": {"epss_score": 0.0003, "epss_percentile": 0.08249}, "CVE-2025-43545": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43546": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43547": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43548": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43549": {"epss_score": 0.00041, "epss_percentile": 0.12218}, "CVE-2025-43550": {"epss_score": 0.00041, "epss_percentile": 0.12218}, "CVE-2025-43551": {"epss_score": 0.00026, "epss_percentile": 0.06423}, "CVE-2025-43553": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43554": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43555": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43556": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43557": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43558": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43559": {"epss_score": 0.0303, "epss_percentile": 0.86245}, "CVE-2025-43560": {"epss_score": 0.02779, "epss_percentile": 0.85646}, "CVE-2025-43561": {"epss_score": 0.00496, "epss_percentile": 0.65155}, "CVE-2025-43562": {"epss_score": 0.01193, "epss_percentile": 0.78407}, "CVE-2025-43563": {"epss_score": 0.00103, "epss_percentile": 0.29092}, "CVE-2025-43564": {"epss_score": 0.00103, "epss_percentile": 0.29092}, "CVE-2025-43565": {"epss_score": 0.00699, "epss_percentile": 0.71433}, "CVE-2025-43566": {"epss_score": 0.00231, "epss_percentile": 0.4577}, "CVE-2025-43567": {"epss_score": 0.00092, "epss_percentile": 0.26413}, "CVE-2025-43568": {"epss_score": 0.00041, "epss_percentile": 0.12218}, "CVE-2025-43569": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43570": {"epss_score": 0.00041, "epss_percentile": 0.12218}, "CVE-2025-43571": {"epss_score": 0.00041, "epss_percentile": 0.12218}, "CVE-2025-43572": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43573": {"epss_score": 0.00041, "epss_percentile": 0.12218}, "CVE-2025-43574": {"epss_score": 0.00041, "epss_percentile": 0.12218}, "CVE-2025-43575": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43576": {"epss_score": 0.00041, "epss_percentile": 0.12218}, "CVE-2025-43577": {"epss_score": 0.00041, "epss_percentile": 0.12218}, "CVE-2025-43578": {"epss_score": 0.00026, "epss_percentile": 0.06423}, "CVE-2025-43579": {"epss_score": 0.0007, "epss_percentile": 0.21803}, "CVE-2025-43580": {"epss_score": 0.0002, "epss_percentile": 0.04436}, "CVE-2025-43581": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43582": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-43583": {"epss_score": 0.0002, "epss_percentile": 0.04436}, "CVE-2025-43584": {"epss_score": 0.00023, "epss_percentile": 0.05395}, "CVE-2025-43585": {"epss_score": 0.00088, "epss_percentile": 0.25781}, "CVE-2025-43586": {"epss_score": 0.00081, "epss_percentile": 0.24304}, "CVE-2025-43587": {"epss_score": 0.00023, "epss_percentile": 0.05395}, "CVE-2025-43588": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43589": {"epss_score": 0.00041, "epss_percentile": 0.12218}, "CVE-2025-43590": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43591": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-43592": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-43593": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-43594": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-43595": {"epss_score": 0.00091, "epss_percentile": 0.26212}, "CVE-2025-43596": {"epss_score": 0.00144, "epss_percentile": 0.35342}, "CVE-2025-43697": {"epss_score": 0.00056, "epss_percentile": 0.17822}, "CVE-2025-43698": {"epss_score": 0.00053, "epss_percentile": 0.16879}, "CVE-2025-43699": {"epss_score": 0.00039, "epss_percentile": 0.11715}, "CVE-2025-43700": {"epss_score": 0.00056, "epss_percentile": 0.17822}, "CVE-2025-43701": {"epss_score": 0.00056, "epss_percentile": 0.17822}, "CVE-2025-43703": {"epss_score": 0.00044, "epss_percentile": 0.13668}, "CVE-2025-43704": {"epss_score": 0.00012, "epss_percentile": 0.0126}, "CVE-2025-43706": {"epss_score": 0.0004, "epss_percentile": 0.11957}, "CVE-2025-43708": {"epss_score": 0.00038, "epss_percentile": 0.11158}, "CVE-2025-43711": {"epss_score": 0.00016, "epss_percentile": 0.02891}, "CVE-2025-43712": {"epss_score": 0.00033, "epss_percentile": 0.09175}, "CVE-2025-43713": {"epss_score": 0.00136, "epss_percentile": 0.34127}, "CVE-2025-43714": {"epss_score": 0.00046, "epss_percentile": 0.14414}, "CVE-2025-43715": {"epss_score": 0.00033, "epss_percentile": 0.0932}, "CVE-2025-43716": {"epss_score": 0.00143, "epss_percentile": 0.35179}, "CVE-2025-43717": {"epss_score": 0.00063, "epss_percentile": 0.19945}, "CVE-2025-43718": {"epss_score": 0.0002, "epss_percentile": 0.04476}, "CVE-2025-43720": {"epss_score": 0.00036, "epss_percentile": 0.1034}, "CVE-2025-43722": {"epss_score": 0.00021, "epss_percentile": 0.04876}, "CVE-2025-43723": {"epss_score": 0.00033, "epss_percentile": 0.09421}, "CVE-2025-43724": {"epss_score": 0.00018, "epss_percentile": 0.04008}, "CVE-2025-43725": {"epss_score": 0.00016, "epss_percentile": 0.02687}, "CVE-2025-43726": {"epss_score": 0.00021, "epss_percentile": 0.04741}, "CVE-2025-43727": {"epss_score": 0.00124, "epss_percentile": 0.32361}, "CVE-2025-43728": {"epss_score": 0.00261, "epss_percentile": 0.49291}, "CVE-2025-43729": {"epss_score": 0.00027, "epss_percentile": 0.07006}, "CVE-2025-43730": {"epss_score": 0.0009, "epss_percentile": 0.25998}, "CVE-2025-43731": {"epss_score": 0.00072, "epss_percentile": 0.22269}, "CVE-2025-43732": {"epss_score": 0.00053, "epss_percentile": 0.1694}, "CVE-2025-43733": {"epss_score": 0.00042, "epss_percentile": 0.12593}, "CVE-2025-43734": {"epss_score": 0.00028, "epss_percentile": 0.07543}, "CVE-2025-43735": {"epss_score": 0.00022, "epss_percentile": 0.05036}, "CVE-2025-43736": {"epss_score": 0.002, "epss_percentile": 0.42202}, "CVE-2025-43737": {"epss_score": 0.00066, "epss_percentile": 0.20827}, "CVE-2025-43738": {"epss_score": 0.00066, "epss_percentile": 0.20827}, "CVE-2025-43739": {"epss_score": 0.00055, "epss_percentile": 0.17516}, "CVE-2025-43740": {"epss_score": 0.0006, "epss_percentile": 0.1922}, "CVE-2025-43741": {"epss_score": 0.00066, "epss_percentile": 0.20827}, "CVE-2025-43742": {"epss_score": 0.00055, "epss_percentile": 0.17484}, "CVE-2025-43743": {"epss_score": 0.00068, "epss_percentile": 0.21266}, "CVE-2025-43744": {"epss_score": 0.00054, "epss_percentile": 0.17334}, "CVE-2025-43745": {"epss_score": 0.00038, "epss_percentile": 0.11317}, "CVE-2025-43746": {"epss_score": 0.0006, "epss_percentile": 0.1922}, "CVE-2025-43747": {"epss_score": 0.00047, "epss_percentile": 0.14712}, "CVE-2025-43748": {"epss_score": 0.00033, "epss_percentile": 0.09193}, "CVE-2025-43749": {"epss_score": 0.00066, "epss_percentile": 0.20758}, "CVE-2025-43750": {"epss_score": 0.00057, "epss_percentile": 0.18003}, "CVE-2025-43751": {"epss_score": 0.00068, "epss_percentile": 0.21407}, "CVE-2025-43752": {"epss_score": 0.00081, "epss_percentile": 0.24264}, "CVE-2025-43753": {"epss_score": 0.00066, "epss_percentile": 0.20687}, "CVE-2025-43754": {"epss_score": 0.00053, "epss_percentile": 0.16837}, "CVE-2025-43755": {"epss_score": 0.0006, "epss_percentile": 0.1922}, "CVE-2025-43756": {"epss_score": 0.00072, "epss_percentile": 0.22269}, "CVE-2025-43757": {"epss_score": 0.0006, "epss_percentile": 0.1922}, "CVE-2025-43758": {"epss_score": 0.00066, "epss_percentile": 0.20758}, "CVE-2025-43759": {"epss_score": 0.00045, "epss_percentile": 0.13727}, "CVE-2025-43760": {"epss_score": 0.00072, "epss_percentile": 0.22269}, "CVE-2025-43761": {"epss_score": 0.00055, "epss_percentile": 0.17484}, "CVE-2025-43762": {"epss_score": 0.00081, "epss_percentile": 0.24264}, "CVE-2025-43763": {"epss_score": 0.00047, "epss_percentile": 0.14712}, "CVE-2025-43764": {"epss_score": 0.00106, "epss_percentile": 0.29457}, "CVE-2025-43765": {"epss_score": 0.00055, "epss_percentile": 0.17484}, "CVE-2025-43766": {"epss_score": 0.00132, "epss_percentile": 0.3359}, "CVE-2025-43767": {"epss_score": 0.00051, "epss_percentile": 0.16286}, "CVE-2025-43768": {"epss_score": 0.00048, "epss_percentile": 0.15138}, "CVE-2025-43769": {"epss_score": 0.00061, "epss_percentile": 0.19379}, "CVE-2025-43770": {"epss_score": 0.00055, "epss_percentile": 0.17484}, "CVE-2025-43771": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43772": {"epss_score": 0.00772, "epss_percentile": 0.73043}, "CVE-2025-43773": {"epss_score": 0.00053, "epss_percentile": 0.1679}, "CVE-2025-43775": {"epss_score": 0.00045, "epss_percentile": 0.1391}, "CVE-2025-43776": {"epss_score": 0.00049, "epss_percentile": 0.15443}, "CVE-2025-43777": {"epss_score": 0.00043, "epss_percentile": 0.13132}, "CVE-2025-43778": {"epss_score": 0.00049, "epss_percentile": 0.15606}, "CVE-2025-43779": {"epss_score": 0.0005, "epss_percentile": 0.15687}, "CVE-2025-43781": {"epss_score": 0.0005, "epss_percentile": 0.15687}, "CVE-2025-43782": {"epss_score": 0.00051, "epss_percentile": 0.16216}, "CVE-2025-43783": {"epss_score": 0.0005, "epss_percentile": 0.15687}, "CVE-2025-43784": {"epss_score": 0.00044, "epss_percentile": 0.13656}, "CVE-2025-43785": {"epss_score": 0.00045, "epss_percentile": 0.14065}, "CVE-2025-43786": {"epss_score": 0.00045, "epss_percentile": 0.13826}, "CVE-2025-43787": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-43788": {"epss_score": 0.00051, "epss_percentile": 0.16216}, "CVE-2025-43789": {"epss_score": 0.00048, "epss_percentile": 0.15104}, "CVE-2025-43790": {"epss_score": 0.00057, "epss_percentile": 0.18206}, "CVE-2025-43791": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43792": {"epss_score": 0.00057, "epss_percentile": 0.18219}, "CVE-2025-43793": {"epss_score": 0.00077, "epss_percentile": 0.23422}, "CVE-2025-43794": {"epss_score": 0.00045, "epss_percentile": 0.14065}, "CVE-2025-43795": {"epss_score": 0.00046, "epss_percentile": 0.14109}, "CVE-2025-43796": {"epss_score": 0.00159, "epss_percentile": 0.37401}, "CVE-2025-43797": {"epss_score": 0.00056, "epss_percentile": 0.17926}, "CVE-2025-43798": {"epss_score": 0.00042, "epss_percentile": 0.12754}, "CVE-2025-43799": {"epss_score": 0.00054, "epss_percentile": 0.17315}, "CVE-2025-43800": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43801": {"epss_score": 0.00211, "epss_percentile": 0.43619}, "CVE-2025-43802": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43803": {"epss_score": 0.00052, "epss_percentile": 0.16641}, "CVE-2025-43804": {"epss_score": 0.0005, "epss_percentile": 0.15687}, "CVE-2025-43805": {"epss_score": 0.00057, "epss_percentile": 0.18223}, "CVE-2025-43806": {"epss_score": 0.00051, "epss_percentile": 0.16216}, "CVE-2025-43807": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43808": {"epss_score": 0.00018, "epss_percentile": 0.03801}, "CVE-2025-43809": {"epss_score": 9e-05, "epss_percentile": 0.00602}, "CVE-2025-43810": {"epss_score": 0.00049, "epss_percentile": 0.15627}, "CVE-2025-43811": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43812": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43813": {"epss_score": 0.00201, "epss_percentile": 0.42319}, "CVE-2025-43814": {"epss_score": 0.00057, "epss_percentile": 0.18141}, "CVE-2025-43815": {"epss_score": 0.0005, "epss_percentile": 0.15687}, "CVE-2025-43816": {"epss_score": 0.00063, "epss_percentile": 0.19877}, "CVE-2025-43817": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43818": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43819": {"epss_score": 0.00042, "epss_percentile": 0.126}, "CVE-2025-43820": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43821": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43822": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43823": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43824": {"epss_score": 0.00053, "epss_percentile": 0.17003}, "CVE-2025-43825": {"epss_score": 0.00044, "epss_percentile": 0.13575}, "CVE-2025-43826": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43827": {"epss_score": 0.00047, "epss_percentile": 0.14781}, "CVE-2025-43829": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-43830": {"epss_score": 0.0005, "epss_percentile": 0.15687}, "CVE-2025-43832": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-43833": {"epss_score": 0.00034, "epss_percentile": 0.09702}, "CVE-2025-43834": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-43835": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-43836": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-43837": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-43838": {"epss_score": 0.00055, "epss_percentile": 0.17577}, "CVE-2025-43839": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-43840": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-43841": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-43842": {"epss_score": 0.00311, "epss_percentile": 0.53847}, "CVE-2025-43843": {"epss_score": 0.0021, "epss_percentile": 0.43435}, "CVE-2025-43844": {"epss_score": 0.00296, "epss_percentile": 0.52626}, "CVE-2025-43845": {"epss_score": 0.00683, "epss_percentile": 0.71103}, "CVE-2025-43846": {"epss_score": 0.02892, "epss_percentile": 0.85921}, "CVE-2025-43847": {"epss_score": 0.02892, "epss_percentile": 0.85921}, "CVE-2025-43848": {"epss_score": 0.02892, "epss_percentile": 0.85921}, "CVE-2025-43849": {"epss_score": 0.03017, "epss_percentile": 0.86218}, "CVE-2025-43850": {"epss_score": 0.02892, "epss_percentile": 0.85921}, "CVE-2025-43851": {"epss_score": 0.02892, "epss_percentile": 0.85921}, "CVE-2025-43852": {"epss_score": 0.02892, "epss_percentile": 0.85921}, "CVE-2025-43853": {"epss_score": 0.00027, "epss_percentile": 0.06812}, "CVE-2025-43854": {"epss_score": 0.00032, "epss_percentile": 0.08778}, "CVE-2025-43855": {"epss_score": 0.0012, "epss_percentile": 0.31771}, "CVE-2025-43856": {"epss_score": 0.00055, "epss_percentile": 0.17518}, "CVE-2025-43857": {"epss_score": 0.00156, "epss_percentile": 0.3691}, "CVE-2025-43858": {"epss_score": 0.00032, "epss_percentile": 0.09113}, "CVE-2025-43859": {"epss_score": 0.00079, "epss_percentile": 0.2387}, "CVE-2025-43860": {"epss_score": 0.00178, "epss_percentile": 0.39688}, "CVE-2025-43861": {"epss_score": 0.00045, "epss_percentile": 0.13739}, "CVE-2025-43862": {"epss_score": 0.00068, "epss_percentile": 0.21312}, "CVE-2025-43863": {"epss_score": 0.00061, "epss_percentile": 0.19302}, "CVE-2025-43864": {"epss_score": 0.00054, "epss_percentile": 0.17203}, "CVE-2025-43865": {"epss_score": 0.00051, "epss_percentile": 0.16112}, "CVE-2025-43866": {"epss_score": 0.00041, "epss_percentile": 0.12197}, "CVE-2025-43873": {"epss_score": 0.00052, "epss_percentile": 0.16586}, "CVE-2025-43875": {"epss_score": 0.00052, "epss_percentile": 0.16586}, "CVE-2025-43876": {"epss_score": 0.00052, "epss_percentile": 0.16586}, "CVE-2025-43877": {"epss_score": 0.00025, "epss_percentile": 0.06313}, "CVE-2025-43878": {"epss_score": 0.00037, "epss_percentile": 0.10775}, "CVE-2025-43879": {"epss_score": 0.00478, "epss_percentile": 0.64407}, "CVE-2025-43880": {"epss_score": 0.00077, "epss_percentile": 0.23415}, "CVE-2025-43881": {"epss_score": 0.00088, "epss_percentile": 0.25641}, "CVE-2025-43882": {"epss_score": 0.00027, "epss_percentile": 0.07006}, "CVE-2025-43884": {"epss_score": 0.0003, "epss_percentile": 0.0824}, "CVE-2025-43885": {"epss_score": 0.00048, "epss_percentile": 0.15245}, "CVE-2025-43886": {"epss_score": 0.00017, "epss_percentile": 0.03407}, "CVE-2025-43887": {"epss_score": 0.00015, "epss_percentile": 0.02167}, "CVE-2025-43888": {"epss_score": 0.00023, "epss_percentile": 0.0544}, "CVE-2025-43889": {"epss_score": 0.00154, "epss_percentile": 0.36691}, "CVE-2025-43890": {"epss_score": 0.0003, "epss_percentile": 0.0824}, "CVE-2025-43891": {"epss_score": 0.00036, "epss_percentile": 0.10518}, "CVE-2025-43903": {"epss_score": 0.00014, "epss_percentile": 0.02055}, "CVE-2025-43905": {"epss_score": 0.00068, "epss_percentile": 0.21373}, "CVE-2025-43906": {"epss_score": 0.0003, "epss_percentile": 0.0824}, "CVE-2025-43907": {"epss_score": 0.00068, "epss_percentile": 0.21289}, "CVE-2025-43908": {"epss_score": 0.00024, "epss_percentile": 0.05894}, "CVE-2025-43909": {"epss_score": 0.00033, "epss_percentile": 0.09382}, "CVE-2025-43910": {"epss_score": 0.00018, "epss_percentile": 0.0365}, "CVE-2025-43911": {"epss_score": 0.0003, "epss_percentile": 0.0824}, "CVE-2025-43912": {"epss_score": 0.00068, "epss_percentile": 0.21322}, "CVE-2025-43913": {"epss_score": 0.00032, "epss_percentile": 0.08818}, "CVE-2025-43914": {"epss_score": 0.00019, "epss_percentile": 0.04336}, "CVE-2025-43915": {"epss_score": 0.00058, "epss_percentile": 0.18515}, "CVE-2025-43916": {"epss_score": 0.00042, "epss_percentile": 0.12927}, "CVE-2025-43917": {"epss_score": 0.00022, "epss_percentile": 0.05197}, "CVE-2025-43918": {"epss_score": 0.00021, "epss_percentile": 0.04909}, "CVE-2025-43919": {"epss_score": 0.00152, "epss_percentile": 0.36401}, "CVE-2025-43920": {"epss_score": 0.00588, "epss_percentile": 0.68501}, "CVE-2025-43921": {"epss_score": 0.0017, "epss_percentile": 0.38717}, "CVE-2025-43922": {"epss_score": 0.00017, "epss_percentile": 0.03325}, "CVE-2025-43923": {"epss_score": 0.00033, "epss_percentile": 0.09405}, "CVE-2025-43924": {"epss_score": 0.00025, "epss_percentile": 0.06363}, "CVE-2025-43925": {"epss_score": 0.00016, "epss_percentile": 0.02983}, "CVE-2025-43926": {"epss_score": 0.0003, "epss_percentile": 0.08017}, "CVE-2025-43928": {"epss_score": 0.00111, "epss_percentile": 0.30311}, "CVE-2025-43929": {"epss_score": 0.00023, "epss_percentile": 0.05426}, "CVE-2025-43930": {"epss_score": 0.00061, "epss_percentile": 0.19431}, "CVE-2025-43931": {"epss_score": 0.00059, "epss_percentile": 0.18855}, "CVE-2025-43932": {"epss_score": 0.00059, "epss_percentile": 0.18855}, "CVE-2025-43933": {"epss_score": 0.00061, "epss_percentile": 0.19431}, "CVE-2025-43934": {"epss_score": 0.00019, "epss_percentile": 0.0407}, "CVE-2025-43938": {"epss_score": 0.00017, "epss_percentile": 0.03295}, "CVE-2025-43939": {"epss_score": 0.00048, "epss_percentile": 0.15245}, "CVE-2025-43940": {"epss_score": 0.00048, "epss_percentile": 0.15245}, "CVE-2025-43941": {"epss_score": 0.00101, "epss_percentile": 0.28699}, "CVE-2025-43942": {"epss_score": 0.00048, "epss_percentile": 0.15245}, "CVE-2025-43943": {"epss_score": 0.00041, "epss_percentile": 0.12385}, "CVE-2025-43946": {"epss_score": 0.02179, "epss_percentile": 0.83893}, "CVE-2025-43947": {"epss_score": 0.00101, "epss_percentile": 0.28677}, "CVE-2025-43948": {"epss_score": 0.0007, "epss_percentile": 0.21764}, "CVE-2025-43949": {"epss_score": 0.00055, "epss_percentile": 0.17487}, "CVE-2025-43950": {"epss_score": 0.0002, "epss_percentile": 0.0449}, "CVE-2025-43951": {"epss_score": 0.00096, "epss_percentile": 0.27358}, "CVE-2025-43952": {"epss_score": 0.00038, "epss_percentile": 0.11323}, "CVE-2025-43953": {"epss_score": 0.00097, "epss_percentile": 0.27459}, "CVE-2025-43954": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-43955": {"epss_score": 0.00038, "epss_percentile": 0.11113}, "CVE-2025-43960": {"epss_score": 0.00328, "epss_percentile": 0.55281}, "CVE-2025-43961": {"epss_score": 0.00071, "epss_percentile": 0.22038}, "CVE-2025-43962": {"epss_score": 0.00071, "epss_percentile": 0.22038}, "CVE-2025-43963": {"epss_score": 0.00071, "epss_percentile": 0.22038}, "CVE-2025-43964": {"epss_score": 0.00068, "epss_percentile": 0.21421}, "CVE-2025-43965": {"epss_score": 0.0005, "epss_percentile": 0.15778}, "CVE-2025-43966": {"epss_score": 0.00044, "epss_percentile": 0.13615}, "CVE-2025-43967": {"epss_score": 0.00058, "epss_percentile": 0.18499}, "CVE-2025-43970": {"epss_score": 0.00027, "epss_percentile": 0.07158}, "CVE-2025-43971": {"epss_score": 0.00026, "epss_percentile": 0.06663}, "CVE-2025-43972": {"epss_score": 0.00026, "epss_percentile": 0.06571}, "CVE-2025-43973": {"epss_score": 0.00025, "epss_percentile": 0.06118}, "CVE-2025-43976": {"epss_score": 0.00018, "epss_percentile": 0.0394}, "CVE-2025-43977": {"epss_score": 0.00017, "epss_percentile": 0.03246}, "CVE-2025-43978": {"epss_score": 0.00079, "epss_percentile": 0.23953}, "CVE-2025-43979": {"epss_score": 0.00038, "epss_percentile": 0.11142}, "CVE-2025-43980": {"epss_score": 0.00045, "epss_percentile": 0.1407}, "CVE-2025-43982": {"epss_score": 0.0008, "epss_percentile": 0.24141}, "CVE-2025-43983": {"epss_score": 0.00124, "epss_percentile": 0.324}, "CVE-2025-43984": {"epss_score": 0.00497, "epss_percentile": 0.65182}, "CVE-2025-43986": {"epss_score": 0.00142, "epss_percentile": 0.34994}, "CVE-2025-43988": {"epss_score": 0.00076, "epss_percentile": 0.23148}, "CVE-2025-43989": {"epss_score": 0.00259, "epss_percentile": 0.49029}, "CVE-2025-43990": {"epss_score": 0.00016, "epss_percentile": 0.02805}, "CVE-2025-43991": {"epss_score": 0.00029, "epss_percentile": 0.07894}, "CVE-2025-43993": {"epss_score": 0.00019, "epss_percentile": 0.04359}, "CVE-2025-43994": {"epss_score": 0.00083, "epss_percentile": 0.24764}, "CVE-2025-43995": {"epss_score": 0.00314, "epss_percentile": 0.54093}, "CVE-2025-44001": {"epss_score": 0.00028, "epss_percentile": 0.07271}, "CVE-2025-44002": {"epss_score": 0.00019, "epss_percentile": 0.04326}, "CVE-2025-44003": {"epss_score": 0.00033, "epss_percentile": 0.0929}, "CVE-2025-44004": {"epss_score": 0.00037, "epss_percentile": 0.10639}, "CVE-2025-44005": {"epss_score": 0.00021, "epss_percentile": 0.04897}, "CVE-2025-44006": {"epss_score": 0.00159, "epss_percentile": 0.37401}, "CVE-2025-44007": {"epss_score": 0.00159, "epss_percentile": 0.37401}, "CVE-2025-44008": {"epss_score": 0.00157, "epss_percentile": 0.37122}, "CVE-2025-44009": {"epss_score": 0.00157, "epss_percentile": 0.37122}, "CVE-2025-44010": {"epss_score": 0.00157, "epss_percentile": 0.37122}, "CVE-2025-44011": {"epss_score": 0.00157, "epss_percentile": 0.37122}, "CVE-2025-44012": {"epss_score": 0.00159, "epss_percentile": 0.37401}, "CVE-2025-44013": {"epss_score": 0.00118, "epss_percentile": 0.31388}, "CVE-2025-44014": {"epss_score": 0.00168, "epss_percentile": 0.38434}, "CVE-2025-44015": {"epss_score": 0.00192, "epss_percentile": 0.41329}, "CVE-2025-44016": {"epss_score": 0.00052, "epss_percentile": 0.16492}, "CVE-2025-44017": {"epss_score": 0.00054, "epss_percentile": 0.17312}, "CVE-2025-44018": {"epss_score": 0.00038, "epss_percentile": 0.11288}, "CVE-2025-44019": {"epss_score": 0.00043, "epss_percentile": 0.13218}, "CVE-2025-44021": {"epss_score": 0.00014, "epss_percentile": 0.01972}, "CVE-2025-44022": {"epss_score": 0.01315, "epss_percentile": 0.794}, "CVE-2025-44023": {"epss_score": 0.00033, "epss_percentile": 0.09155}, "CVE-2025-44024": {"epss_score": 0.00025, "epss_percentile": 0.06047}, "CVE-2025-44033": {"epss_score": 0.00385, "epss_percentile": 0.59193}, "CVE-2025-44034": {"epss_score": 0.00183, "epss_percentile": 0.40363}, "CVE-2025-44039": {"epss_score": 0.00025, "epss_percentile": 0.06373}, "CVE-2025-44040": {"epss_score": 0.00085, "epss_percentile": 0.25137}, "CVE-2025-44043": {"epss_score": 0.00029, "epss_percentile": 0.07762}, "CVE-2025-44044": {"epss_score": 0.0004, "epss_percentile": 0.12021}, "CVE-2025-44071": {"epss_score": 0.01229, "epss_percentile": 0.78711}, "CVE-2025-44072": {"epss_score": 0.00061, "epss_percentile": 0.19459}, "CVE-2025-44073": {"epss_score": 0.00056, "epss_percentile": 0.17755}, "CVE-2025-44074": {"epss_score": 0.00061, "epss_percentile": 0.19459}, "CVE-2025-44083": {"epss_score": 0.00238, "epss_percentile": 0.46782}, "CVE-2025-44084": {"epss_score": 0.00252, "epss_percentile": 0.48401}, "CVE-2025-44091": {"epss_score": 0.00028, "epss_percentile": 0.07239}, "CVE-2025-44108": {"epss_score": 0.00047, "epss_percentile": 0.14818}, "CVE-2025-44109": {"epss_score": 0.00034, "epss_percentile": 0.09783}, "CVE-2025-44110": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2025-44115": {"epss_score": 0.00026, "epss_percentile": 0.06711}, "CVE-2025-44134": {"epss_score": 0.00059, "epss_percentile": 0.18901}, "CVE-2025-44135": {"epss_score": 0.00059, "epss_percentile": 0.18901}, "CVE-2025-44136": {"epss_score": 0.10756, "epss_percentile": 0.93095}, "CVE-2025-44137": {"epss_score": 0.00364, "epss_percentile": 0.57909}, "CVE-2025-44139": {"epss_score": 0.00065, "epss_percentile": 0.20673}, "CVE-2025-44141": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-44148": {"epss_score": 0.10898, "epss_percentile": 0.93147}, "CVE-2025-44163": {"epss_score": 0.00029, "epss_percentile": 0.07615}, "CVE-2025-44172": {"epss_score": 0.0006, "epss_percentile": 0.19156}, "CVE-2025-44175": {"epss_score": 0.00041, "epss_percentile": 0.12267}, "CVE-2025-44176": {"epss_score": 0.00331, "epss_percentile": 0.555}, "CVE-2025-44177": {"epss_score": 0.05816, "epss_percentile": 0.9023}, "CVE-2025-44178": {"epss_score": 0.00052, "epss_percentile": 0.16566}, "CVE-2025-44179": {"epss_score": 0.00478, "epss_percentile": 0.64402}, "CVE-2025-44180": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-44181": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-44182": {"epss_score": 0.00044, "epss_percentile": 0.13372}, "CVE-2025-44183": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-44184": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2025-44185": {"epss_score": 0.00022, "epss_percentile": 0.04952}, "CVE-2025-44186": {"epss_score": 0.00021, "epss_percentile": 0.04807}, "CVE-2025-44192": {"epss_score": 0.00061, "epss_percentile": 0.19459}, "CVE-2025-44193": {"epss_score": 0.00054, "epss_percentile": 0.17094}, "CVE-2025-44194": {"epss_score": 0.00049, "epss_percentile": 0.15644}, "CVE-2025-44203": {"epss_score": 0.00032, "epss_percentile": 0.09094}, "CVE-2025-44206": {"epss_score": 0.00037, "epss_percentile": 0.10634}, "CVE-2025-44251": {"epss_score": 0.00023, "epss_percentile": 0.05406}, "CVE-2025-44525": {"epss_score": 0.00031, "epss_percentile": 0.08699}, "CVE-2025-44526": {"epss_score": 0.0005, "epss_percentile": 0.15663}, "CVE-2025-44528": {"epss_score": 0.00163, "epss_percentile": 0.37821}, "CVE-2025-44531": {"epss_score": 0.00131, "epss_percentile": 0.33494}, "CVE-2025-44557": {"epss_score": 0.00037, "epss_percentile": 0.10721}, "CVE-2025-44559": {"epss_score": 0.00031, "epss_percentile": 0.0841}, "CVE-2025-44593": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-44594": {"epss_score": 0.00045, "epss_percentile": 0.13761}, "CVE-2025-44595": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-44608": {"epss_score": 0.00043, "epss_percentile": 0.13233}, "CVE-2025-44612": {"epss_score": 0.00016, "epss_percentile": 0.02747}, "CVE-2025-44614": {"epss_score": 0.00025, "epss_percentile": 0.0604}, "CVE-2025-44619": {"epss_score": 0.00057, "epss_percentile": 0.18015}, "CVE-2025-44635": {"epss_score": 0.00574, "epss_percentile": 0.68074}, "CVE-2025-44643": {"epss_score": 0.00045, "epss_percentile": 0.13686}, "CVE-2025-44647": {"epss_score": 0.0006, "epss_percentile": 0.19096}, "CVE-2025-44649": {"epss_score": 0.00021, "epss_percentile": 0.04819}, "CVE-2025-44650": {"epss_score": 0.00062, "epss_percentile": 0.19639}, "CVE-2025-44651": {"epss_score": 0.00059, "epss_percentile": 0.18633}, "CVE-2025-44652": {"epss_score": 0.00057, "epss_percentile": 0.18098}, "CVE-2025-44653": {"epss_score": 0.00054, "epss_percentile": 0.17197}, "CVE-2025-44654": {"epss_score": 0.00071, "epss_percentile": 0.2203}, "CVE-2025-44655": {"epss_score": 0.00289, "epss_percentile": 0.52049}, "CVE-2025-44657": {"epss_score": 0.00015, "epss_percentile": 0.02288}, "CVE-2025-44658": {"epss_score": 0.00214, "epss_percentile": 0.43989}, "CVE-2025-44779": {"epss_score": 0.00024, "epss_percentile": 0.05892}, "CVE-2025-44823": {"epss_score": 0.00374, "epss_percentile": 0.58563}, "CVE-2025-44824": {"epss_score": 0.0016, "epss_percentile": 0.3746}, "CVE-2025-44830": {"epss_score": 0.00056, "epss_percentile": 0.17755}, "CVE-2025-44831": {"epss_score": 0.00056, "epss_percentile": 0.17755}, "CVE-2025-44835": {"epss_score": 0.01613, "epss_percentile": 0.81343}, "CVE-2025-44836": {"epss_score": 0.06244, "epss_percentile": 0.90603}, "CVE-2025-44837": {"epss_score": 0.06244, "epss_percentile": 0.90603}, "CVE-2025-44838": {"epss_score": 0.06244, "epss_percentile": 0.90603}, "CVE-2025-44839": {"epss_score": 0.04435, "epss_percentile": 0.88688}, "CVE-2025-44840": {"epss_score": 0.04435, "epss_percentile": 0.88688}, "CVE-2025-44841": {"epss_score": 0.04435, "epss_percentile": 0.88688}, "CVE-2025-44842": {"epss_score": 0.04435, "epss_percentile": 0.88688}, "CVE-2025-44843": {"epss_score": 0.04345, "epss_percentile": 0.88574}, "CVE-2025-44844": {"epss_score": 0.04435, "epss_percentile": 0.88688}, "CVE-2025-44845": {"epss_score": 0.04435, "epss_percentile": 0.88688}, "CVE-2025-44846": {"epss_score": 0.06244, "epss_percentile": 0.90603}, "CVE-2025-44847": {"epss_score": 0.04719, "epss_percentile": 0.89047}, "CVE-2025-44848": {"epss_score": 0.04435, "epss_percentile": 0.88688}, "CVE-2025-44854": {"epss_score": 0.06244, "epss_percentile": 0.90603}, "CVE-2025-44860": {"epss_score": 0.04435, "epss_percentile": 0.88688}, "CVE-2025-44861": {"epss_score": 0.06244, "epss_percentile": 0.90603}, "CVE-2025-44862": {"epss_score": 0.06244, "epss_percentile": 0.90603}, "CVE-2025-44863": {"epss_score": 0.04435, "epss_percentile": 0.88688}, "CVE-2025-44864": {"epss_score": 0.06134, "epss_percentile": 0.90505}, "CVE-2025-44865": {"epss_score": 0.06134, "epss_percentile": 0.90505}, "CVE-2025-44866": {"epss_score": 0.06134, "epss_percentile": 0.90505}, "CVE-2025-44867": {"epss_score": 0.06134, "epss_percentile": 0.90505}, "CVE-2025-44868": {"epss_score": 0.01301, "epss_percentile": 0.79294}, "CVE-2025-44872": {"epss_score": 0.01912, "epss_percentile": 0.82831}, "CVE-2025-44877": {"epss_score": 0.01912, "epss_percentile": 0.82831}, "CVE-2025-44879": {"epss_score": 0.00136, "epss_percentile": 0.3417}, "CVE-2025-44880": {"epss_score": 0.01779, "epss_percentile": 0.82232}, "CVE-2025-44881": {"epss_score": 0.01779, "epss_percentile": 0.82232}, "CVE-2025-44882": {"epss_score": 0.01779, "epss_percentile": 0.82232}, "CVE-2025-44883": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-44884": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-44885": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-44886": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-44887": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-44888": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-44890": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-44891": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-44892": {"epss_score": 0.00053, "epss_percentile": 0.16738}, "CVE-2025-44893": {"epss_score": 0.00086, "epss_percentile": 0.25425}, "CVE-2025-44894": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-44895": {"epss_score": 0.00053, "epss_percentile": 0.16738}, "CVE-2025-44896": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-44897": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-44898": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-44899": {"epss_score": 0.00066, "epss_percentile": 0.20739}, "CVE-2025-44900": {"epss_score": 0.00038, "epss_percentile": 0.11228}, "CVE-2025-44904": {"epss_score": 0.00063, "epss_percentile": 0.19844}, "CVE-2025-44905": {"epss_score": 0.00063, "epss_percentile": 0.19844}, "CVE-2025-44906": {"epss_score": 0.00022, "epss_percentile": 0.05038}, "CVE-2025-44951": {"epss_score": 0.00028, "epss_percentile": 0.07333}, "CVE-2025-44952": {"epss_score": 0.00025, "epss_percentile": 0.06339}, "CVE-2025-44954": {"epss_score": 0.00045, "epss_percentile": 0.13946}, "CVE-2025-44955": {"epss_score": 0.00033, "epss_percentile": 0.0943}, "CVE-2025-44957": {"epss_score": 0.00096, "epss_percentile": 0.27282}, "CVE-2025-44958": {"epss_score": 0.00022, "epss_percentile": 0.05132}, "CVE-2025-44960": {"epss_score": 0.00094, "epss_percentile": 0.26988}, "CVE-2025-44961": {"epss_score": 0.00143, "epss_percentile": 0.35114}, "CVE-2025-44962": {"epss_score": 0.00033, "epss_percentile": 0.09203}, "CVE-2025-44963": {"epss_score": 0.00048, "epss_percentile": 0.15013}, "CVE-2025-44964": {"epss_score": 8e-05, "epss_percentile": 0.00529}, "CVE-2025-44998": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-45001": {"epss_score": 0.00025, "epss_percentile": 0.06217}, "CVE-2025-45002": {"epss_score": 0.00028, "epss_percentile": 0.07239}, "CVE-2025-45006": {"epss_score": 0.00038, "epss_percentile": 0.11206}, "CVE-2025-45007": {"epss_score": 0.00046, "epss_percentile": 0.14309}, "CVE-2025-45009": {"epss_score": 0.00123, "epss_percentile": 0.32196}, "CVE-2025-45010": {"epss_score": 0.00123, "epss_percentile": 0.32196}, "CVE-2025-45011": {"epss_score": 0.00123, "epss_percentile": 0.32196}, "CVE-2025-45015": {"epss_score": 0.0005, "epss_percentile": 0.15928}, "CVE-2025-45017": {"epss_score": 0.00592, "epss_percentile": 0.68623}, "CVE-2025-45018": {"epss_score": 0.00187, "epss_percentile": 0.40797}, "CVE-2025-45019": {"epss_score": 0.00088, "epss_percentile": 0.25671}, "CVE-2025-45020": {"epss_score": 0.00172, "epss_percentile": 0.38914}, "CVE-2025-45021": {"epss_score": 0.00028, "epss_percentile": 0.0754}, "CVE-2025-45029": {"epss_score": 0.00037, "epss_percentile": 0.10728}, "CVE-2025-45042": {"epss_score": 0.02335, "epss_percentile": 0.84413}, "CVE-2025-45055": {"epss_score": 0.00028, "epss_percentile": 0.07239}, "CVE-2025-45065": {"epss_score": 0.00034, "epss_percentile": 0.09482}, "CVE-2025-45081": {"epss_score": 0.00041, "epss_percentile": 0.12249}, "CVE-2025-45083": {"epss_score": 0.00013, "epss_percentile": 0.01585}, "CVE-2025-45091": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-45095": {"epss_score": 0.00089, "epss_percentile": 0.25891}, "CVE-2025-45143": {"epss_score": 0.00081, "epss_percentile": 0.2433}, "CVE-2025-45146": {"epss_score": 0.00214, "epss_percentile": 0.44003}, "CVE-2025-45150": {"epss_score": 0.00053, "epss_percentile": 0.1668}, "CVE-2025-45156": {"epss_score": 0.00071, "epss_percentile": 0.22188}, "CVE-2025-45157": {"epss_score": 0.00054, "epss_percentile": 0.17106}, "CVE-2025-45236": {"epss_score": 0.00038, "epss_percentile": 0.11265}, "CVE-2025-45237": {"epss_score": 0.00069, "epss_percentile": 0.21597}, "CVE-2025-45238": {"epss_score": 0.00441, "epss_percentile": 0.62656}, "CVE-2025-45239": {"epss_score": 0.00102, "epss_percentile": 0.2881}, "CVE-2025-45240": {"epss_score": 0.00041, "epss_percentile": 0.12262}, "CVE-2025-45242": {"epss_score": 0.00065, "epss_percentile": 0.2047}, "CVE-2025-45250": {"epss_score": 0.00023, "epss_percentile": 0.05389}, "CVE-2025-45286": {"epss_score": 0.00033, "epss_percentile": 0.09139}, "CVE-2025-45311": {"epss_score": 0.00053, "epss_percentile": 0.16817}, "CVE-2025-45313": {"epss_score": 0.00068, "epss_percentile": 0.21301}, "CVE-2025-45314": {"epss_score": 0.00067, "epss_percentile": 0.21153}, "CVE-2025-45315": {"epss_score": 0.00074, "epss_percentile": 0.22866}, "CVE-2025-45316": {"epss_score": 0.00103, "epss_percentile": 0.29052}, "CVE-2025-45317": {"epss_score": 0.00109, "epss_percentile": 0.29985}, "CVE-2025-45320": {"epss_score": 0.00064, "epss_percentile": 0.20404}, "CVE-2025-45321": {"epss_score": 0.00056, "epss_percentile": 0.17888}, "CVE-2025-45322": {"epss_score": 0.00056, "epss_percentile": 0.17888}, "CVE-2025-45326": {"epss_score": 0.00135, "epss_percentile": 0.33947}, "CVE-2025-45331": {"epss_score": 0.0008, "epss_percentile": 0.24024}, "CVE-2025-45332": {"epss_score": 0.00054, "epss_percentile": 0.17265}, "CVE-2025-45333": {"epss_score": 0.0008, "epss_percentile": 0.24024}, "CVE-2025-45343": {"epss_score": 0.00178, "epss_percentile": 0.39656}, "CVE-2025-45346": {"epss_score": 0.00196, "epss_percentile": 0.41813}, "CVE-2025-45375": {"epss_score": 0.00018, "epss_percentile": 0.0365}, "CVE-2025-45376": {"epss_score": 0.00013, "epss_percentile": 0.01669}, "CVE-2025-45378": {"epss_score": 0.00077, "epss_percentile": 0.23531}, "CVE-2025-45379": {"epss_score": 0.0023, "epss_percentile": 0.45678}, "CVE-2025-45387": {"epss_score": 0.00024, "epss_percentile": 0.05887}, "CVE-2025-45388": {"epss_score": 0.00029, "epss_percentile": 0.07779}, "CVE-2025-45406": {"epss_score": 0.00028, "epss_percentile": 0.07279}, "CVE-2025-45424": {"epss_score": 0.0007, "epss_percentile": 0.2172}, "CVE-2025-45427": {"epss_score": 0.00846, "epss_percentile": 0.74337}, "CVE-2025-45428": {"epss_score": 0.00846, "epss_percentile": 0.74337}, "CVE-2025-45429": {"epss_score": 0.00921, "epss_percentile": 0.75486}, "CVE-2025-45466": {"epss_score": 0.00033, "epss_percentile": 0.09364}, "CVE-2025-45467": {"epss_score": 0.00031, "epss_percentile": 0.08447}, "CVE-2025-45468": {"epss_score": 0.00056, "epss_percentile": 0.17697}, "CVE-2025-45471": {"epss_score": 0.00064, "epss_percentile": 0.20132}, "CVE-2025-45472": {"epss_score": 0.00056, "epss_percentile": 0.17697}, "CVE-2025-45474": {"epss_score": 0.00073, "epss_percentile": 0.22612}, "CVE-2025-45475": {"epss_score": 0.00054, "epss_percentile": 0.17084}, "CVE-2025-45479": {"epss_score": 0.00157, "epss_percentile": 0.37106}, "CVE-2025-45487": {"epss_score": 0.01122, "epss_percentile": 0.7778}, "CVE-2025-45488": {"epss_score": 0.01517, "epss_percentile": 0.80806}, "CVE-2025-45489": {"epss_score": 0.01115, "epss_percentile": 0.77706}, "CVE-2025-45490": {"epss_score": 0.01115, "epss_percentile": 0.77706}, "CVE-2025-45491": {"epss_score": 0.01612, "epss_percentile": 0.81334}, "CVE-2025-45492": {"epss_score": 0.00823, "epss_percentile": 0.73926}, "CVE-2025-45493": {"epss_score": 0.03272, "epss_percentile": 0.86795}, "CVE-2025-45512": {"epss_score": 0.0006, "epss_percentile": 0.19007}, "CVE-2025-45513": {"epss_score": 0.00091, "epss_percentile": 0.26398}, "CVE-2025-45514": {"epss_score": 0.00053, "epss_percentile": 0.16738}, "CVE-2025-45525": {"epss_score": 0.00015, "epss_percentile": 0.02588}, "CVE-2025-45526": {"epss_score": 0.0002, "epss_percentile": 0.04509}, "CVE-2025-45529": {"epss_score": 0.00048, "epss_percentile": 0.15122}, "CVE-2025-45542": {"epss_score": 0.00229, "epss_percentile": 0.45654}, "CVE-2025-45582": {"epss_score": 0.00049, "epss_percentile": 0.15359}, "CVE-2025-45583": {"epss_score": 0.00057, "epss_percentile": 0.18201}, "CVE-2025-45584": {"epss_score": 0.00088, "epss_percentile": 0.25741}, "CVE-2025-45585": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-45586": {"epss_score": 0.00055, "epss_percentile": 0.17574}, "CVE-2025-45587": {"epss_score": 0.00073, "epss_percentile": 0.22528}, "CVE-2025-45607": {"epss_score": 0.00184, "epss_percentile": 0.40382}, "CVE-2025-45608": {"epss_score": 0.00069, "epss_percentile": 0.21597}, "CVE-2025-45609": {"epss_score": 0.00069, "epss_percentile": 0.21597}, "CVE-2025-45610": {"epss_score": 0.00073, "epss_percentile": 0.22603}, "CVE-2025-45611": {"epss_score": 0.00109, "epss_percentile": 0.30042}, "CVE-2025-45612": {"epss_score": 0.00104, "epss_percentile": 0.29112}, "CVE-2025-45613": {"epss_score": 0.00069, "epss_percentile": 0.21597}, "CVE-2025-45614": {"epss_score": 0.00069, "epss_percentile": 0.21597}, "CVE-2025-45615": {"epss_score": 0.00159, "epss_percentile": 0.37395}, "CVE-2025-45616": {"epss_score": 0.00182, "epss_percentile": 0.40198}, "CVE-2025-45617": {"epss_score": 0.00064, "epss_percentile": 0.20289}, "CVE-2025-45618": {"epss_score": 0.00048, "epss_percentile": 0.15118}, "CVE-2025-45619": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-45620": {"epss_score": 0.00056, "epss_percentile": 0.17774}, "CVE-2025-45661": {"epss_score": 0.00026, "epss_percentile": 0.06676}, "CVE-2025-45662": {"epss_score": 0.00032, "epss_percentile": 0.08829}, "CVE-2025-45663": {"epss_score": 0.00068, "epss_percentile": 0.2134}, "CVE-2025-45702": {"epss_score": 0.00036, "epss_percentile": 0.10372}, "CVE-2025-45729": {"epss_score": 0.00134, "epss_percentile": 0.3375}, "CVE-2025-45731": {"epss_score": 0.00063, "epss_percentile": 0.19974}, "CVE-2025-45737": {"epss_score": 0.00075, "epss_percentile": 0.22969}, "CVE-2025-45746": {"epss_score": 0.00265, "epss_percentile": 0.49795}, "CVE-2025-45751": {"epss_score": 0.00037, "epss_percentile": 0.10777}, "CVE-2025-45752": {"epss_score": 0.00107, "epss_percentile": 0.29603}, "CVE-2025-45753": {"epss_score": 0.00055, "epss_percentile": 0.1743}, "CVE-2025-45754": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2025-45755": {"epss_score": 0.00044, "epss_percentile": 0.13372}, "CVE-2025-45764": {"epss_score": 4e-05, "epss_percentile": 0.00164}, "CVE-2025-45765": {"epss_score": 0.00019, "epss_percentile": 0.04133}, "CVE-2025-45766": {"epss_score": 0.00013, "epss_percentile": 0.01485}, "CVE-2025-45767": {"epss_score": 0.00017, "epss_percentile": 0.0331}, "CVE-2025-45768": {"epss_score": 0.00015, "epss_percentile": 0.02334}, "CVE-2025-45769": {"epss_score": 0.00013, "epss_percentile": 0.01576}, "CVE-2025-45770": {"epss_score": 0.00015, "epss_percentile": 0.02334}, "CVE-2025-45777": {"epss_score": 0.00131, "epss_percentile": 0.33446}, "CVE-2025-45778": {"epss_score": 0.0002, "epss_percentile": 0.04611}, "CVE-2025-45779": {"epss_score": 0.00177, "epss_percentile": 0.39498}, "CVE-2025-45784": {"epss_score": 0.00337, "epss_percentile": 0.56042}, "CVE-2025-45786": {"epss_score": 0.00052, "epss_percentile": 0.16568}, "CVE-2025-45787": {"epss_score": 0.00126, "epss_percentile": 0.32671}, "CVE-2025-45788": {"epss_score": 0.00126, "epss_percentile": 0.32671}, "CVE-2025-45789": {"epss_score": 0.00126, "epss_percentile": 0.32671}, "CVE-2025-45790": {"epss_score": 0.00179, "epss_percentile": 0.39858}, "CVE-2025-45797": {"epss_score": 0.00213, "epss_percentile": 0.43844}, "CVE-2025-45798": {"epss_score": 0.00331, "epss_percentile": 0.55548}, "CVE-2025-45800": {"epss_score": 0.00441, "epss_percentile": 0.62656}, "CVE-2025-45805": {"epss_score": 0.00022, "epss_percentile": 0.04965}, "CVE-2025-45809": {"epss_score": 0.00032, "epss_percentile": 0.08863}, "CVE-2025-45813": {"epss_score": 0.00082, "epss_percentile": 0.24566}, "CVE-2025-45814": {"epss_score": 0.00124, "epss_percentile": 0.32428}, "CVE-2025-45818": {"epss_score": 0.00028, "epss_percentile": 0.07268}, "CVE-2025-45819": {"epss_score": 0.00028, "epss_percentile": 0.07268}, "CVE-2025-45820": {"epss_score": 0.00028, "epss_percentile": 0.07268}, "CVE-2025-45835": {"epss_score": 0.00082, "epss_percentile": 0.244}, "CVE-2025-45841": {"epss_score": 0.00071, "epss_percentile": 0.22223}, "CVE-2025-45842": {"epss_score": 0.00079, "epss_percentile": 0.23897}, "CVE-2025-45843": {"epss_score": 0.00079, "epss_percentile": 0.23897}, "CVE-2025-45844": {"epss_score": 0.00079, "epss_percentile": 0.23897}, "CVE-2025-45845": {"epss_score": 0.00079, "epss_percentile": 0.23897}, "CVE-2025-45846": {"epss_score": 0.00071, "epss_percentile": 0.22008}, "CVE-2025-45847": {"epss_score": 0.00053, "epss_percentile": 0.16738}, "CVE-2025-45851": {"epss_score": 0.0011, "epss_percentile": 0.30184}, "CVE-2025-45854": {"epss_score": 0.13089, "epss_percentile": 0.93871}, "CVE-2025-45855": {"epss_score": 0.00072, "epss_percentile": 0.22317}, "CVE-2025-45857": {"epss_score": 0.01272, "epss_percentile": 0.79083}, "CVE-2025-45858": {"epss_score": 0.06959, "epss_percentile": 0.91149}, "CVE-2025-45859": {"epss_score": 0.00055, "epss_percentile": 0.17656}, "CVE-2025-45861": {"epss_score": 0.00105, "epss_percentile": 0.29262}, "CVE-2025-45862": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-45863": {"epss_score": 0.00105, "epss_percentile": 0.29262}, "CVE-2025-45864": {"epss_score": 0.00055, "epss_percentile": 0.17656}, "CVE-2025-45865": {"epss_score": 0.00105, "epss_percentile": 0.29262}, "CVE-2025-45866": {"epss_score": 0.0003, "epss_percentile": 0.08247}, "CVE-2025-45867": {"epss_score": 0.00055, "epss_percentile": 0.17656}, "CVE-2025-45872": {"epss_score": 0.00082, "epss_percentile": 0.24566}, "CVE-2025-45878": {"epss_score": 0.00024, "epss_percentile": 0.05767}, "CVE-2025-45879": {"epss_score": 0.00024, "epss_percentile": 0.05767}, "CVE-2025-45880": {"epss_score": 0.00024, "epss_percentile": 0.05767}, "CVE-2025-45885": {"epss_score": 0.00056, "epss_percentile": 0.17755}, "CVE-2025-45887": {"epss_score": 0.0006, "epss_percentile": 0.19204}, "CVE-2025-45890": {"epss_score": 0.01786, "epss_percentile": 0.82258}, "CVE-2025-45892": {"epss_score": 0.00032, "epss_percentile": 0.08765}, "CVE-2025-45893": {"epss_score": 0.00025, "epss_percentile": 0.06248}, "CVE-2025-45931": {"epss_score": 0.00783, "epss_percentile": 0.73219}, "CVE-2025-45938": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-45939": {"epss_score": 0.00039, "epss_percentile": 0.11539}, "CVE-2025-45947": {"epss_score": 0.00293, "epss_percentile": 0.52286}, "CVE-2025-45949": {"epss_score": 0.00097, "epss_percentile": 0.27584}, "CVE-2025-45953": {"epss_score": 0.00066, "epss_percentile": 0.20682}, "CVE-2025-45956": {"epss_score": 0.00056, "epss_percentile": 0.17888}, "CVE-2025-45960": {"epss_score": 0.00057, "epss_percentile": 0.18207}, "CVE-2025-45968": {"epss_score": 0.00315, "epss_percentile": 0.542}, "CVE-2025-45984": {"epss_score": 0.01369, "epss_percentile": 0.79795}, "CVE-2025-45985": {"epss_score": 0.33584, "epss_percentile": 0.96785}, "CVE-2025-45986": {"epss_score": 0.01369, "epss_percentile": 0.79795}, "CVE-2025-45987": {"epss_score": 0.01369, "epss_percentile": 0.79795}, "CVE-2025-45988": {"epss_score": 0.01369, "epss_percentile": 0.79795}, "CVE-2025-45994": {"epss_score": 0.00059, "epss_percentile": 0.18819}, "CVE-2025-45997": {"epss_score": 0.00145, "epss_percentile": 0.35409}, "CVE-2025-46000": {"epss_score": 0.00051, "epss_percentile": 0.16319}, "CVE-2025-46001": {"epss_score": 0.00194, "epss_percentile": 0.41562}, "CVE-2025-46002": {"epss_score": 0.0129, "epss_percentile": 0.79222}, "CVE-2025-46011": {"epss_score": 0.00042, "epss_percentile": 0.1271}, "CVE-2025-46014": {"epss_score": 0.0006, "epss_percentile": 0.19202}, "CVE-2025-46018": {"epss_score": 0.00029, "epss_percentile": 0.079}, "CVE-2025-46035": {"epss_score": 0.00086, "epss_percentile": 0.25329}, "CVE-2025-46041": {"epss_score": 0.00205, "epss_percentile": 0.42677}, "CVE-2025-46047": {"epss_score": 0.00024, "epss_percentile": 0.05972}, "CVE-2025-46052": {"epss_score": 0.00056, "epss_percentile": 0.17755}, "CVE-2025-46053": {"epss_score": 0.00025, "epss_percentile": 0.06057}, "CVE-2025-46059": {"epss_score": 0.00107, "epss_percentile": 0.29713}, "CVE-2025-46060": {"epss_score": 0.00816, "epss_percentile": 0.73828}, "CVE-2025-46078": {"epss_score": 0.00053, "epss_percentile": 0.16857}, "CVE-2025-46080": {"epss_score": 0.00053, "epss_percentile": 0.16857}, "CVE-2025-46093": {"epss_score": 0.00071, "epss_percentile": 0.22206}, "CVE-2025-46094": {"epss_score": 0.00116, "epss_percentile": 0.31151}, "CVE-2025-46096": {"epss_score": 0.00145, "epss_percentile": 0.35505}, "CVE-2025-46099": {"epss_score": 0.00063, "epss_percentile": 0.19981}, "CVE-2025-46101": {"epss_score": 0.00119, "epss_percentile": 0.31539}, "CVE-2025-46102": {"epss_score": 0.00037, "epss_percentile": 0.10993}, "CVE-2025-46109": {"epss_score": 0.00104, "epss_percentile": 0.2913}, "CVE-2025-46116": {"epss_score": 0.0006, "epss_percentile": 0.19202}, "CVE-2025-46117": {"epss_score": 0.00129, "epss_percentile": 0.33082}, "CVE-2025-46118": {"epss_score": 0.00067, "epss_percentile": 0.2102}, "CVE-2025-46119": {"epss_score": 0.00052, "epss_percentile": 0.16619}, "CVE-2025-46120": {"epss_score": 0.01733, "epss_percentile": 0.81997}, "CVE-2025-46121": {"epss_score": 0.00801, "epss_percentile": 0.73574}, "CVE-2025-46122": {"epss_score": 0.00361, "epss_percentile": 0.57697}, "CVE-2025-46123": {"epss_score": 0.00598, "epss_percentile": 0.68769}, "CVE-2025-46148": {"epss_score": 0.0004, "epss_percentile": 0.12107}, "CVE-2025-46149": {"epss_score": 0.00038, "epss_percentile": 0.11203}, "CVE-2025-46150": {"epss_score": 0.0004, "epss_percentile": 0.12107}, "CVE-2025-46152": {"epss_score": 0.00051, "epss_percentile": 0.16242}, "CVE-2025-46153": {"epss_score": 0.00043, "epss_percentile": 0.1321}, "CVE-2025-46154": {"epss_score": 0.00027, "epss_percentile": 0.06742}, "CVE-2025-46157": {"epss_score": 0.00143, "epss_percentile": 0.3515}, "CVE-2025-46158": {"epss_score": 0.00036, "epss_percentile": 0.10367}, "CVE-2025-46171": {"epss_score": 0.00066, "epss_percentile": 0.20891}, "CVE-2025-46173": {"epss_score": 0.0001, "epss_percentile": 0.00843}, "CVE-2025-46174": {"epss_score": 0.00042, "epss_percentile": 0.1274}, "CVE-2025-46175": {"epss_score": 0.00042, "epss_percentile": 0.1274}, "CVE-2025-46176": {"epss_score": 0.00044, "epss_percentile": 0.13677}, "CVE-2025-46178": {"epss_score": 0.00033, "epss_percentile": 0.09124}, "CVE-2025-46179": {"epss_score": 0.00052, "epss_percentile": 0.16453}, "CVE-2025-46183": {"epss_score": 0.00076, "epss_percentile": 0.23249}, "CVE-2025-46185": {"epss_score": 0.00019, "epss_percentile": 0.0423}, "CVE-2025-46188": {"epss_score": 0.00056, "epss_percentile": 0.17755}, "CVE-2025-46189": {"epss_score": 0.00056, "epss_percentile": 0.17755}, "CVE-2025-46190": {"epss_score": 0.00038, "epss_percentile": 0.11365}, "CVE-2025-46191": {"epss_score": 0.00324, "epss_percentile": 0.54924}, "CVE-2025-46192": {"epss_score": 0.00038, "epss_percentile": 0.11365}, "CVE-2025-46193": {"epss_score": 0.01046, "epss_percentile": 0.77031}, "CVE-2025-46198": {"epss_score": 0.00091, "epss_percentile": 0.26242}, "CVE-2025-46199": {"epss_score": 0.00174, "epss_percentile": 0.39148}, "CVE-2025-46203": {"epss_score": 0.00023, "epss_percentile": 0.05331}, "CVE-2025-46204": {"epss_score": 0.00023, "epss_percentile": 0.05331}, "CVE-2025-46205": {"epss_score": 0.00047, "epss_percentile": 0.14925}, "CVE-2025-46206": {"epss_score": 0.00143, "epss_percentile": 0.35222}, "CVE-2025-46215": {"epss_score": 0.00077, "epss_percentile": 0.23325}, "CVE-2025-46225": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46226": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46227": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46228": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46229": {"epss_score": 0.00035, "epss_percentile": 0.09981}, "CVE-2025-46230": {"epss_score": 0.00157, "epss_percentile": 0.37049}, "CVE-2025-46231": {"epss_score": 0.00026, "epss_percentile": 0.06517}, "CVE-2025-46232": {"epss_score": 0.00062, "epss_percentile": 0.19701}, "CVE-2025-46233": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46234": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-46235": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46236": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46237": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46238": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46239": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46240": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46241": {"epss_score": 0.00024, "epss_percentile": 0.05692}, "CVE-2025-46242": {"epss_score": 0.00045, "epss_percentile": 0.137}, "CVE-2025-46243": {"epss_score": 0.00024, "epss_percentile": 0.05899}, "CVE-2025-46244": {"epss_score": 0.00066, "epss_percentile": 0.20849}, "CVE-2025-46245": {"epss_score": 0.00024, "epss_percentile": 0.05899}, "CVE-2025-46246": {"epss_score": 0.00024, "epss_percentile": 0.05899}, "CVE-2025-46247": {"epss_score": 0.00091, "epss_percentile": 0.2622}, "CVE-2025-46248": {"epss_score": 0.00053, "epss_percentile": 0.16856}, "CVE-2025-46249": {"epss_score": 0.00024, "epss_percentile": 0.05899}, "CVE-2025-46250": {"epss_score": 0.00035, "epss_percentile": 0.09981}, "CVE-2025-46251": {"epss_score": 0.00025, "epss_percentile": 0.06115}, "CVE-2025-46252": {"epss_score": 0.0005, "epss_percentile": 0.15895}, "CVE-2025-46253": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46254": {"epss_score": 0.00038, "epss_percentile": 0.11193}, "CVE-2025-46255": {"epss_score": 0.00021, "epss_percentile": 0.04824}, "CVE-2025-46256": {"epss_score": 0.00042, "epss_percentile": 0.12887}, "CVE-2025-46257": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-46258": {"epss_score": 0.00036, "epss_percentile": 0.10516}, "CVE-2025-46259": {"epss_score": 0.00051, "epss_percentile": 0.1606}, "CVE-2025-46260": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46261": {"epss_score": 0.00035, "epss_percentile": 0.09981}, "CVE-2025-46262": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-46263": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-46264": {"epss_score": 0.00094, "epss_percentile": 0.26767}, "CVE-2025-46265": {"epss_score": 0.0009, "epss_percentile": 0.26045}, "CVE-2025-46266": {"epss_score": 0.00023, "epss_percentile": 0.05336}, "CVE-2025-46267": {"epss_score": 0.00038, "epss_percentile": 0.11412}, "CVE-2025-46268": {"epss_score": 0.00029, "epss_percentile": 0.07733}, "CVE-2025-46269": {"epss_score": 0.00037, "epss_percentile": 0.10927}, "CVE-2025-46271": {"epss_score": 0.01436, "epss_percentile": 0.80277}, "CVE-2025-46272": {"epss_score": 0.05565, "epss_percentile": 0.89999}, "CVE-2025-46273": {"epss_score": 0.00267, "epss_percentile": 0.4997}, "CVE-2025-46274": {"epss_score": 0.00267, "epss_percentile": 0.4997}, "CVE-2025-46275": {"epss_score": 0.00068, "epss_percentile": 0.21386}, "CVE-2025-46276": {"epss_score": 0.00013, "epss_percentile": 0.01445}, "CVE-2025-46277": {"epss_score": 0.00011, "epss_percentile": 0.011}, "CVE-2025-46278": {"epss_score": 0.00013, "epss_percentile": 0.01526}, "CVE-2025-46279": {"epss_score": 0.00016, "epss_percentile": 0.02985}, "CVE-2025-46281": {"epss_score": 0.00019, "epss_percentile": 0.04332}, "CVE-2025-46282": {"epss_score": 0.00011, "epss_percentile": 0.00934}, "CVE-2025-46283": {"epss_score": 0.00013, "epss_percentile": 0.01526}, "CVE-2025-46285": {"epss_score": 0.00012, "epss_percentile": 0.01326}, "CVE-2025-46287": {"epss_score": 0.00058, "epss_percentile": 0.18535}, "CVE-2025-46288": {"epss_score": 9e-05, "epss_percentile": 0.00658}, "CVE-2025-46289": {"epss_score": 0.00011, "epss_percentile": 0.01106}, "CVE-2025-46291": {"epss_score": 0.00016, "epss_percentile": 0.02928}, "CVE-2025-46292": {"epss_score": 0.0001, "epss_percentile": 0.0088}, "CVE-2025-46294": {"epss_score": 0.0004, "epss_percentile": 0.12082}, "CVE-2025-46295": {"epss_score": 0.00333, "epss_percentile": 0.55629}, "CVE-2025-46296": {"epss_score": 0.0003, "epss_percentile": 0.0805}, "CVE-2025-46326": {"epss_score": 9e-05, "epss_percentile": 0.00598}, "CVE-2025-46327": {"epss_score": 0.0001, "epss_percentile": 0.00877}, "CVE-2025-46328": {"epss_score": 4e-05, "epss_percentile": 0.00131}, "CVE-2025-46329": {"epss_score": 0.00013, "epss_percentile": 0.01523}, "CVE-2025-46330": {"epss_score": 0.00022, "epss_percentile": 0.05014}, "CVE-2025-46331": {"epss_score": 0.00084, "epss_percentile": 0.24857}, "CVE-2025-46332": {"epss_score": 0.00047, "epss_percentile": 0.14594}, "CVE-2025-46333": {"epss_score": 0.0001, "epss_percentile": 0.00905}, "CVE-2025-46334": {"epss_score": 0.00018, "epss_percentile": 0.03869}, "CVE-2025-46335": {"epss_score": 0.0003, "epss_percentile": 0.08027}, "CVE-2025-46336": {"epss_score": 0.00025, "epss_percentile": 0.06245}, "CVE-2025-46337": {"epss_score": 0.00076, "epss_percentile": 0.23105}, "CVE-2025-46338": {"epss_score": 0.00067, "epss_percentile": 0.21065}, "CVE-2025-46339": {"epss_score": 0.00026, "epss_percentile": 0.06433}, "CVE-2025-46340": {"epss_score": 0.00049, "epss_percentile": 0.15352}, "CVE-2025-46341": {"epss_score": 0.00073, "epss_percentile": 0.22608}, "CVE-2025-46342": {"epss_score": 0.00106, "epss_percentile": 0.29558}, "CVE-2025-46343": {"epss_score": 0.00027, "epss_percentile": 0.06854}, "CVE-2025-46344": {"epss_score": 0.00095, "epss_percentile": 0.27199}, "CVE-2025-46345": {"epss_score": 0.00065, "epss_percentile": 0.20556}, "CVE-2025-46346": {"epss_score": 0.00052, "epss_percentile": 0.16384}, "CVE-2025-46347": {"epss_score": 0.01252, "epss_percentile": 0.789}, "CVE-2025-46348": {"epss_score": 0.00142, "epss_percentile": 0.35039}, "CVE-2025-46349": {"epss_score": 0.00051, "epss_percentile": 0.16013}, "CVE-2025-46350": {"epss_score": 0.00035, "epss_percentile": 0.09992}, "CVE-2025-46352": {"epss_score": 0.00064, "epss_percentile": 0.20192}, "CVE-2025-46354": {"epss_score": 0.00055, "epss_percentile": 0.17501}, "CVE-2025-46355": {"epss_score": 0.00013, "epss_percentile": 0.01497}, "CVE-2025-46358": {"epss_score": 0.00015, "epss_percentile": 0.0225}, "CVE-2025-46359": {"epss_score": 0.00165, "epss_percentile": 0.38082}, "CVE-2025-46362": {"epss_score": 0.00014, "epss_percentile": 0.01908}, "CVE-2025-46363": {"epss_score": 0.00057, "epss_percentile": 0.18181}, "CVE-2025-46364": {"epss_score": 0.00054, "epss_percentile": 0.17344}, "CVE-2025-46365": {"epss_score": 0.00037, "epss_percentile": 0.10723}, "CVE-2025-46366": {"epss_score": 0.00016, "epss_percentile": 0.02734}, "CVE-2025-46367": {"epss_score": 0.00017, "epss_percentile": 0.03502}, "CVE-2025-46368": {"epss_score": 0.00015, "epss_percentile": 0.02419}, "CVE-2025-46369": {"epss_score": 0.00017, "epss_percentile": 0.0313}, "CVE-2025-46370": {"epss_score": 0.00014, "epss_percentile": 0.01867}, "CVE-2025-46373": {"epss_score": 0.00019, "epss_percentile": 0.04098}, "CVE-2025-46382": {"epss_score": 0.00037, "epss_percentile": 0.10864}, "CVE-2025-46383": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-46384": {"epss_score": 0.00061, "epss_percentile": 0.19256}, "CVE-2025-46385": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-46386": {"epss_score": 0.00047, "epss_percentile": 0.14702}, "CVE-2025-46387": {"epss_score": 0.00047, "epss_percentile": 0.14702}, "CVE-2025-46388": {"epss_score": 0.00031, "epss_percentile": 0.08546}, "CVE-2025-46389": {"epss_score": 0.0003, "epss_percentile": 0.08177}, "CVE-2025-46390": {"epss_score": 0.00035, "epss_percentile": 0.10008}, "CVE-2025-46391": {"epss_score": 0.0003, "epss_percentile": 0.08177}, "CVE-2025-46392": {"epss_score": 0.00181, "epss_percentile": 0.40033}, "CVE-2025-46393": {"epss_score": 0.00053, "epss_percentile": 0.16797}, "CVE-2025-46394": {"epss_score": 0.00024, "epss_percentile": 0.05978}, "CVE-2025-46397": {"epss_score": 0.00039, "epss_percentile": 0.11719}, "CVE-2025-46398": {"epss_score": 0.00046, "epss_percentile": 0.14431}, "CVE-2025-46399": {"epss_score": 0.00039, "epss_percentile": 0.118}, "CVE-2025-46400": {"epss_score": 0.00039, "epss_percentile": 0.118}, "CVE-2025-46404": {"epss_score": 0.00085, "epss_percentile": 0.2514}, "CVE-2025-46405": {"epss_score": 0.00132, "epss_percentile": 0.33517}, "CVE-2025-46406": {"epss_score": 0.00013, "epss_percentile": 0.0157}, "CVE-2025-46407": {"epss_score": 0.00356, "epss_percentile": 0.57357}, "CVE-2025-46408": {"epss_score": 0.00028, "epss_percentile": 0.07496}, "CVE-2025-46409": {"epss_score": 0.00029, "epss_percentile": 0.07779}, "CVE-2025-46410": {"epss_score": 0.00085, "epss_percentile": 0.25151}, "CVE-2025-46411": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-46412": {"epss_score": 0.00076, "epss_percentile": 0.23144}, "CVE-2025-46413": {"epss_score": 8e-05, "epss_percentile": 0.00521}, "CVE-2025-46414": {"epss_score": 0.00045, "epss_percentile": 0.13796}, "CVE-2025-46415": {"epss_score": 0.00013, "epss_percentile": 0.01433}, "CVE-2025-46416": {"epss_score": 0.00014, "epss_percentile": 0.0187}, "CVE-2025-46417": {"epss_score": 0.00102, "epss_percentile": 0.28724}, "CVE-2025-46419": {"epss_score": 0.00083, "epss_percentile": 0.24733}, "CVE-2025-46420": {"epss_score": 0.00252, "epss_percentile": 0.48372}, "CVE-2025-46421": {"epss_score": 0.00124, "epss_percentile": 0.32362}, "CVE-2025-46422": {"epss_score": 0.00049, "epss_percentile": 0.15493}, "CVE-2025-46423": {"epss_score": 0.00049, "epss_percentile": 0.15493}, "CVE-2025-46424": {"epss_score": 7e-05, "epss_percentile": 0.0037}, "CVE-2025-46425": {"epss_score": 0.00079, "epss_percentile": 0.23967}, "CVE-2025-46427": {"epss_score": 0.0013, "epss_percentile": 0.33269}, "CVE-2025-46428": {"epss_score": 0.0013, "epss_percentile": 0.33229}, "CVE-2025-46430": {"epss_score": 0.00016, "epss_percentile": 0.02805}, "CVE-2025-46432": {"epss_score": 1e-05, "epss_percentile": 0.00013}, "CVE-2025-46433": {"epss_score": 2e-05, "epss_percentile": 0.00055}, "CVE-2025-46434": {"epss_score": 0.00026, "epss_percentile": 0.06661}, "CVE-2025-46435": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46436": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-46437": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-46438": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46439": {"epss_score": 0.00021, "epss_percentile": 0.04939}, "CVE-2025-46440": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-46441": {"epss_score": 0.00062, "epss_percentile": 0.19565}, "CVE-2025-46442": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46443": {"epss_score": 0.00038, "epss_percentile": 0.11336}, "CVE-2025-46444": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-46445": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46446": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-46447": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46448": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-46449": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-46450": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46451": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-46452": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46453": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46454": {"epss_score": 0.00108, "epss_percentile": 0.298}, "CVE-2025-46455": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-46456": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-46457": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46458": {"epss_score": 0.00018, "epss_percentile": 0.03858}, "CVE-2025-46459": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-46460": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-46461": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46462": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-46463": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-46464": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-46465": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46466": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46467": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46468": {"epss_score": 0.00157, "epss_percentile": 0.37115}, "CVE-2025-46469": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-46470": {"epss_score": 0.00053, "epss_percentile": 0.16965}, "CVE-2025-46471": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46472": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46473": {"epss_score": 0.00145, "epss_percentile": 0.354}, "CVE-2025-46474": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-46475": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46476": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46477": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-46478": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-46479": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46480": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46481": {"epss_score": 0.00145, "epss_percentile": 0.354}, "CVE-2025-46482": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-46483": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46484": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46485": {"epss_score": 0.00057, "epss_percentile": 0.17999}, "CVE-2025-46486": {"epss_score": 0.00067, "epss_percentile": 0.2097}, "CVE-2025-46487": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-46488": {"epss_score": 0.00034, "epss_percentile": 0.09477}, "CVE-2025-46489": {"epss_score": 0.00057, "epss_percentile": 0.17999}, "CVE-2025-46490": {"epss_score": 0.00065, "epss_percentile": 0.20582}, "CVE-2025-46491": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46492": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46493": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-46494": {"epss_score": 0.00033, "epss_percentile": 0.09387}, "CVE-2025-46495": {"epss_score": 0.00022, "epss_percentile": 0.05154}, "CVE-2025-46496": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46497": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46498": {"epss_score": 0.00023, "epss_percentile": 0.0552}, "CVE-2025-46499": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-46500": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-46501": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46502": {"epss_score": 0.00042, "epss_percentile": 0.12878}, "CVE-2025-46503": {"epss_score": 0.00038, "epss_percentile": 0.11336}, "CVE-2025-46504": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46505": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46506": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46507": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46508": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46509": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46510": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46511": {"epss_score": 0.00051, "epss_percentile": 0.16064}, "CVE-2025-46512": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46513": {"epss_score": 0.00023, "epss_percentile": 0.05599}, "CVE-2025-46514": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46515": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-46516": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46517": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-46518": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-46519": {"epss_score": 0.00051, "epss_percentile": 0.16064}, "CVE-2025-46520": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46521": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-46522": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46523": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-46524": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46525": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-46526": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-46527": {"epss_score": 0.00072, "epss_percentile": 0.22371}, "CVE-2025-46528": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46529": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-46530": {"epss_score": 0.00022, "epss_percentile": 0.05215}, "CVE-2025-46531": {"epss_score": 0.00038, "epss_percentile": 0.11336}, "CVE-2025-46532": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46533": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-46534": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46535": {"epss_score": 0.00056, "epss_percentile": 0.17955}, "CVE-2025-46536": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46537": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-46538": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46539": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-46540": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46541": {"epss_score": 0.00039, "epss_percentile": 0.11533}, "CVE-2025-46542": {"epss_score": 0.00042, "epss_percentile": 0.12697}, "CVE-2025-46543": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-46544": {"epss_score": 0.00047, "epss_percentile": 0.14488}, "CVE-2025-46545": {"epss_score": 0.0003, "epss_percentile": 0.08217}, "CVE-2025-46546": {"epss_score": 0.00039, "epss_percentile": 0.1179}, "CVE-2025-46547": {"epss_score": 0.00017, "epss_percentile": 0.03187}, "CVE-2025-46548": {"epss_score": 0.00694, "epss_percentile": 0.71341}, "CVE-2025-46549": {"epss_score": 0.00038, "epss_percentile": 0.11334}, "CVE-2025-46550": {"epss_score": 0.00038, "epss_percentile": 0.11334}, "CVE-2025-46551": {"epss_score": 0.00026, "epss_percentile": 0.06441}, "CVE-2025-46552": {"epss_score": 0.00065, "epss_percentile": 0.20556}, "CVE-2025-46553": {"epss_score": 0.00058, "epss_percentile": 0.18295}, "CVE-2025-46554": {"epss_score": 0.00157, "epss_percentile": 0.37029}, "CVE-2025-46556": {"epss_score": 0.0005, "epss_percentile": 0.15865}, "CVE-2025-46557": {"epss_score": 0.00176, "epss_percentile": 0.39428}, "CVE-2025-46558": {"epss_score": 0.00894, "epss_percentile": 0.75087}, "CVE-2025-46559": {"epss_score": 0.00029, "epss_percentile": 0.0776}, "CVE-2025-46560": {"epss_score": 0.00124, "epss_percentile": 0.3241}, "CVE-2025-46565": {"epss_score": 0.00117, "epss_percentile": 0.31333}, "CVE-2025-46566": {"epss_score": 0.0006, "epss_percentile": 0.18983}, "CVE-2025-46567": {"epss_score": 0.00112, "epss_percentile": 0.30419}, "CVE-2025-46568": {"epss_score": 0.00069, "epss_percentile": 0.21597}, "CVE-2025-46569": {"epss_score": 0.00032, "epss_percentile": 0.08743}, "CVE-2025-46570": {"epss_score": 0.00032, "epss_percentile": 0.0897}, "CVE-2025-46571": {"epss_score": 0.00029, "epss_percentile": 0.07928}, "CVE-2025-46572": {"epss_score": 0.00082, "epss_percentile": 0.24415}, "CVE-2025-46573": {"epss_score": 0.00081, "epss_percentile": 0.24274}, "CVE-2025-46574": {"epss_score": 0.00045, "epss_percentile": 0.14055}, "CVE-2025-46575": {"epss_score": 0.00047, "epss_percentile": 0.14756}, "CVE-2025-46576": {"epss_score": 0.00063, "epss_percentile": 0.19882}, "CVE-2025-46577": {"epss_score": 0.00042, "epss_percentile": 0.12918}, "CVE-2025-46578": {"epss_score": 0.00042, "epss_percentile": 0.12918}, "CVE-2025-46579": {"epss_score": 0.00028, "epss_percentile": 0.07229}, "CVE-2025-46580": {"epss_score": 0.00067, "epss_percentile": 0.21096}, "CVE-2025-46581": {"epss_score": 0.00264, "epss_percentile": 0.49727}, "CVE-2025-46582": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-46583": {"epss_score": 0.00058, "epss_percentile": 0.18414}, "CVE-2025-46584": {"epss_score": 0.00016, "epss_percentile": 0.0268}, "CVE-2025-46585": {"epss_score": 8e-05, "epss_percentile": 0.00534}, "CVE-2025-46586": {"epss_score": 0.00011, "epss_percentile": 0.01054}, "CVE-2025-46587": {"epss_score": 0.00011, "epss_percentile": 0.00966}, "CVE-2025-46588": {"epss_score": 9e-05, "epss_percentile": 0.00626}, "CVE-2025-46589": {"epss_score": 9e-05, "epss_percentile": 0.00616}, "CVE-2025-46590": {"epss_score": 0.00024, "epss_percentile": 0.06021}, "CVE-2025-46591": {"epss_score": 0.0001, "epss_percentile": 0.00875}, "CVE-2025-46592": {"epss_score": 0.00011, "epss_percentile": 0.01012}, "CVE-2025-46593": {"epss_score": 0.00011, "epss_percentile": 0.01012}, "CVE-2025-46595": {"epss_score": 0.00035, "epss_percentile": 0.10019}, "CVE-2025-46599": {"epss_score": 0.00048, "epss_percentile": 0.15197}, "CVE-2025-46602": {"epss_score": 0.00017, "epss_percentile": 0.03187}, "CVE-2025-46603": {"epss_score": 0.00081, "epss_percentile": 0.24218}, "CVE-2025-46608": {"epss_score": 0.00065, "epss_percentile": 0.2053}, "CVE-2025-46610": {"epss_score": 0.0002, "epss_percentile": 0.0464}, "CVE-2025-46611": {"epss_score": 0.00044, "epss_percentile": 0.13372}, "CVE-2025-46612": {"epss_score": 0.00407, "epss_percentile": 0.60573}, "CVE-2025-46613": {"epss_score": 0.00037, "epss_percentile": 0.10992}, "CVE-2025-46614": {"epss_score": 0.00018, "epss_percentile": 0.04013}, "CVE-2025-46616": {"epss_score": 0.00499, "epss_percentile": 0.65269}, "CVE-2025-46617": {"epss_score": 0.0004, "epss_percentile": 0.12041}, "CVE-2025-46618": {"epss_score": 0.00024, "epss_percentile": 0.05908}, "CVE-2025-46619": {"epss_score": 0.00126, "epss_percentile": 0.32738}, "CVE-2025-46625": {"epss_score": 0.00538, "epss_percentile": 0.66939}, "CVE-2025-46626": {"epss_score": 0.00045, "epss_percentile": 0.13739}, "CVE-2025-46627": {"epss_score": 0.00111, "epss_percentile": 0.30304}, "CVE-2025-46628": {"epss_score": 0.00349, "epss_percentile": 0.56854}, "CVE-2025-46629": {"epss_score": 0.00072, "epss_percentile": 0.2247}, "CVE-2025-46630": {"epss_score": 0.00075, "epss_percentile": 0.22919}, "CVE-2025-46631": {"epss_score": 0.00126, "epss_percentile": 0.32749}, "CVE-2025-46632": {"epss_score": 0.00057, "epss_percentile": 0.18179}, "CVE-2025-46633": {"epss_score": 0.00052, "epss_percentile": 0.16386}, "CVE-2025-46634": {"epss_score": 0.00043, "epss_percentile": 0.1318}, "CVE-2025-46635": {"epss_score": 0.00048, "epss_percentile": 0.15118}, "CVE-2025-46636": {"epss_score": 8e-05, "epss_percentile": 0.00475}, "CVE-2025-46637": {"epss_score": 8e-05, "epss_percentile": 0.00542}, "CVE-2025-46646": {"epss_score": 0.00017, "epss_percentile": 0.03216}, "CVE-2025-46647": {"epss_score": 0.00059, "epss_percentile": 0.18636}, "CVE-2025-46652": {"epss_score": 0.00031, "epss_percentile": 0.08418}, "CVE-2025-46653": {"epss_score": 0.00014, "epss_percentile": 0.01762}, "CVE-2025-46654": {"epss_score": 0.00033, "epss_percentile": 0.0939}, "CVE-2025-46655": {"epss_score": 0.00031, "epss_percentile": 0.08463}, "CVE-2025-46656": {"epss_score": 0.00027, "epss_percentile": 0.06825}, "CVE-2025-46657": {"epss_score": 0.00011, "epss_percentile": 0.01005}, "CVE-2025-46658": {"epss_score": 0.00051, "epss_percentile": 0.16332}, "CVE-2025-46659": {"epss_score": 0.00035, "epss_percentile": 0.10008}, "CVE-2025-46660": {"epss_score": 0.00031, "epss_percentile": 0.08655}, "CVE-2025-46661": {"epss_score": 0.00213, "epss_percentile": 0.43897}, "CVE-2025-46672": {"epss_score": 0.0004, "epss_percentile": 0.11984}, "CVE-2025-46673": {"epss_score": 0.00065, "epss_percentile": 0.20447}, "CVE-2025-46674": {"epss_score": 0.00064, "epss_percentile": 0.20345}, "CVE-2025-46675": {"epss_score": 0.0004, "epss_percentile": 0.12155}, "CVE-2025-46686": {"epss_score": 0.00028, "epss_percentile": 0.07561}, "CVE-2025-46687": {"epss_score": 0.0002, "epss_percentile": 0.04528}, "CVE-2025-46688": {"epss_score": 0.00024, "epss_percentile": 0.06026}, "CVE-2025-46689": {"epss_score": 0.00038, "epss_percentile": 0.11265}, "CVE-2025-46690": {"epss_score": 0.00049, "epss_percentile": 0.1536}, "CVE-2025-46696": {"epss_score": 0.00014, "epss_percentile": 0.01858}, "CVE-2025-46701": {"epss_score": 0.00026, "epss_percentile": 0.06556}, "CVE-2025-46702": {"epss_score": 0.00045, "epss_percentile": 0.13921}, "CVE-2025-46703": {"epss_score": 0.00045, "epss_percentile": 0.13714}, "CVE-2025-46704": {"epss_score": 0.0009, "epss_percentile": 0.26081}, "CVE-2025-46705": {"epss_score": 0.00073, "epss_percentile": 0.22586}, "CVE-2025-46706": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-46707": {"epss_score": 0.00016, "epss_percentile": 0.02752}, "CVE-2025-46708": {"epss_score": 0.00022, "epss_percentile": 0.05312}, "CVE-2025-46709": {"epss_score": 0.00051, "epss_percentile": 0.16072}, "CVE-2025-46710": {"epss_score": 0.00024, "epss_percentile": 0.05749}, "CVE-2025-46711": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-46712": {"epss_score": 0.00038, "epss_percentile": 0.11179}, "CVE-2025-46713": {"epss_score": 0.00022, "epss_percentile": 0.05315}, "CVE-2025-46714": {"epss_score": 0.00022, "epss_percentile": 0.05315}, "CVE-2025-46715": {"epss_score": 0.00022, "epss_percentile": 0.05315}, "CVE-2025-46716": {"epss_score": 0.0002, "epss_percentile": 0.04619}, "CVE-2025-46717": {"epss_score": 0.00016, "epss_percentile": 0.02858}, "CVE-2025-46718": {"epss_score": 0.00022, "epss_percentile": 0.05307}, "CVE-2025-46719": {"epss_score": 0.00062, "epss_percentile": 0.19698}, "CVE-2025-46720": {"epss_score": 0.00041, "epss_percentile": 0.12349}, "CVE-2025-46721": {"epss_score": 0.0001, "epss_percentile": 0.00794}, "CVE-2025-46722": {"epss_score": 0.0007, "epss_percentile": 0.21665}, "CVE-2025-46723": {"epss_score": 0.00101, "epss_percentile": 0.28672}, "CVE-2025-46724": {"epss_score": 0.0004, "epss_percentile": 0.12043}, "CVE-2025-46725": {"epss_score": 0.00062, "epss_percentile": 0.19664}, "CVE-2025-46726": {"epss_score": 0.00111, "epss_percentile": 0.30378}, "CVE-2025-46727": {"epss_score": 0.00117, "epss_percentile": 0.31238}, "CVE-2025-46728": {"epss_score": 0.00282, "epss_percentile": 0.51231}, "CVE-2025-46729": {"epss_score": 0.00074, "epss_percentile": 0.22778}, "CVE-2025-46730": {"epss_score": 0.00088, "epss_percentile": 0.2574}, "CVE-2025-46731": {"epss_score": 0.00257, "epss_percentile": 0.48844}, "CVE-2025-46732": {"epss_score": 0.00036, "epss_percentile": 0.10274}, "CVE-2025-46733": {"epss_score": 0.00017, "epss_percentile": 0.03336}, "CVE-2025-46734": {"epss_score": 0.00014, "epss_percentile": 0.01955}, "CVE-2025-46735": {"epss_score": 0.00083, "epss_percentile": 0.24791}, "CVE-2025-46736": {"epss_score": 0.00043, "epss_percentile": 0.13216}, "CVE-2025-46737": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-46738": {"epss_score": 0.00131, "epss_percentile": 0.33366}, "CVE-2025-46739": {"epss_score": 0.00111, "epss_percentile": 0.30311}, "CVE-2025-46740": {"epss_score": 0.00042, "epss_percentile": 0.12707}, "CVE-2025-46741": {"epss_score": 0.00012, "epss_percentile": 0.01299}, "CVE-2025-46742": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-46743": {"epss_score": 0.00016, "epss_percentile": 0.02934}, "CVE-2025-46744": {"epss_score": 0.00034, "epss_percentile": 0.09472}, "CVE-2025-46745": {"epss_score": 0.00038, "epss_percentile": 0.11211}, "CVE-2025-46746": {"epss_score": 0.00028, "epss_percentile": 0.07226}, "CVE-2025-46747": {"epss_score": 0.00031, "epss_percentile": 0.08506}, "CVE-2025-46748": {"epss_score": 0.00034, "epss_percentile": 0.09472}, "CVE-2025-46749": {"epss_score": 0.00048, "epss_percentile": 0.15282}, "CVE-2025-46750": {"epss_score": 0.00016, "epss_percentile": 0.02929}, "CVE-2025-46752": {"epss_score": 0.00019, "epss_percentile": 0.04113}, "CVE-2025-46762": {"epss_score": 0.00108, "epss_percentile": 0.29893}, "CVE-2025-46774": {"epss_score": 8e-05, "epss_percentile": 0.00538}, "CVE-2025-46775": {"epss_score": 0.00017, "epss_percentile": 0.03269}, "CVE-2025-46776": {"epss_score": 0.00017, "epss_percentile": 0.03323}, "CVE-2025-46777": {"epss_score": 0.00033, "epss_percentile": 0.09131}, "CVE-2025-46783": {"epss_score": 0.00094, "epss_percentile": 0.27029}, "CVE-2025-46784": {"epss_score": 0.00073, "epss_percentile": 0.22586}, "CVE-2025-46785": {"epss_score": 0.00107, "epss_percentile": 0.29695}, "CVE-2025-46786": {"epss_score": 0.00025, "epss_percentile": 0.06363}, "CVE-2025-46788": {"epss_score": 0.0002, "epss_percentile": 0.04615}, "CVE-2025-46789": {"epss_score": 0.00078, "epss_percentile": 0.23778}, "CVE-2025-46801": {"epss_score": 0.00028, "epss_percentile": 0.07272}, "CVE-2025-46802": {"epss_score": 0.00013, "epss_percentile": 0.01588}, "CVE-2025-46803": {"epss_score": 0.00011, "epss_percentile": 0.01066}, "CVE-2025-46804": {"epss_score": 0.00017, "epss_percentile": 0.03252}, "CVE-2025-46805": {"epss_score": 0.00015, "epss_percentile": 0.02532}, "CVE-2025-46806": {"epss_score": 0.00108, "epss_percentile": 0.29849}, "CVE-2025-46807": {"epss_score": 0.00062, "epss_percentile": 0.19618}, "CVE-2025-46809": {"epss_score": 0.00029, "epss_percentile": 0.07595}, "CVE-2025-46810": {"epss_score": 0.00025, "epss_percentile": 0.06135}, "CVE-2025-46811": {"epss_score": 0.00059, "epss_percentile": 0.18855}, "CVE-2025-46812": {"epss_score": 0.00056, "epss_percentile": 0.17828}, "CVE-2025-46813": {"epss_score": 0.00121, "epss_percentile": 0.3183}, "CVE-2025-46814": {"epss_score": 0.00066, "epss_percentile": 0.20681}, "CVE-2025-46815": {"epss_score": 0.00056, "epss_percentile": 0.17829}, "CVE-2025-46816": {"epss_score": 0.00027, "epss_percentile": 0.06949}, "CVE-2025-46817": {"epss_score": 0.27211, "epss_percentile": 0.9622}, "CVE-2025-46818": {"epss_score": 0.04619, "epss_percentile": 0.88929}, "CVE-2025-46819": {"epss_score": 0.0635, "epss_percentile": 0.9069}, "CVE-2025-46820": {"epss_score": 0.00019, "epss_percentile": 0.04205}, "CVE-2025-46821": {"epss_score": 9e-05, "epss_percentile": 0.00723}, "CVE-2025-46822": {"epss_score": 0.11483, "epss_percentile": 0.9338}, "CVE-2025-46823": {"epss_score": 0.0006, "epss_percentile": 0.19077}, "CVE-2025-46824": {"epss_score": 0.0003, "epss_percentile": 0.08227}, "CVE-2025-46825": {"epss_score": 0.00041, "epss_percentile": 0.12326}, "CVE-2025-46826": {"epss_score": 0.00087, "epss_percentile": 0.25489}, "CVE-2025-46827": {"epss_score": 0.00026, "epss_percentile": 0.06557}, "CVE-2025-46828": {"epss_score": 0.00127, "epss_percentile": 0.32936}, "CVE-2025-46833": {"epss_score": 0.00022, "epss_percentile": 0.05289}, "CVE-2025-46834": {"epss_score": 0.0007, "epss_percentile": 0.21695}, "CVE-2025-46835": {"epss_score": 0.00021, "epss_percentile": 0.04738}, "CVE-2025-46836": {"epss_score": 0.00046, "epss_percentile": 0.14285}, "CVE-2025-46837": {"epss_score": 0.0004, "epss_percentile": 0.12078}, "CVE-2025-46838": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46840": {"epss_score": 0.00072, "epss_percentile": 0.2244}, "CVE-2025-46841": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46842": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46843": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46844": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46845": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46846": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46847": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46848": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46849": {"epss_score": 0.00055, "epss_percentile": 0.17452}, "CVE-2025-46850": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46851": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46852": {"epss_score": 0.00055, "epss_percentile": 0.17452}, "CVE-2025-46853": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46854": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46855": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46856": {"epss_score": 0.00055, "epss_percentile": 0.17452}, "CVE-2025-46857": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46858": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46859": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46860": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46861": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46862": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46863": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46864": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46865": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46866": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46870": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46871": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46872": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46873": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46874": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46875": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46876": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46877": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46878": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46879": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46880": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46881": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46882": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46883": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46884": {"epss_score": 0.0006, "epss_percentile": 0.19067}, "CVE-2025-46885": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46886": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46887": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46888": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46889": {"epss_score": 0.00054, "epss_percentile": 0.17297}, "CVE-2025-46890": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46891": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46892": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46893": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46894": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46895": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46898": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46899": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46900": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46901": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46902": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46903": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46904": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46905": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46906": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46907": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46908": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46909": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46910": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46911": {"epss_score": 0.0006, "epss_percentile": 0.19067}, "CVE-2025-46912": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46913": {"epss_score": 0.0006, "epss_percentile": 0.19067}, "CVE-2025-46914": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46915": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46916": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46917": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46918": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46919": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46920": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46922": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46923": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46924": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46926": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46927": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46929": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46930": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46931": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46932": {"epss_score": 0.00055, "epss_percentile": 0.17452}, "CVE-2025-46933": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46934": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46935": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46936": {"epss_score": 0.00055, "epss_percentile": 0.17452}, "CVE-2025-46939": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46940": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46941": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46942": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46943": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46944": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46945": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46946": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46947": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46948": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46949": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46950": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46951": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46952": {"epss_score": 0.00036, "epss_percentile": 0.10503}, "CVE-2025-46953": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46954": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46955": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46956": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46957": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46958": {"epss_score": 0.0002, "epss_percentile": 0.04443}, "CVE-2025-46959": {"epss_score": 0.00025, "epss_percentile": 0.06355}, "CVE-2025-46960": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46962": {"epss_score": 0.00055, "epss_percentile": 0.17452}, "CVE-2025-46963": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46964": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46965": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46966": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46967": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46968": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46970": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46971": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46972": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46973": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46974": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46975": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46976": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46977": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46978": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46979": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46981": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46982": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46983": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46984": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46985": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46986": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46987": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46988": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46989": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46990": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46991": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46992": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46993": {"epss_score": 0.00025, "epss_percentile": 0.06355}, "CVE-2025-46995": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46996": {"epss_score": 0.00025, "epss_percentile": 0.06355}, "CVE-2025-46997": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-46998": {"epss_score": 0.00055, "epss_percentile": 0.17452}, "CVE-2025-46999": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47000": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47001": {"epss_score": 0.00025, "epss_percentile": 0.06355}, "CVE-2025-47002": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47003": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47004": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47005": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47006": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47007": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47008": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47010": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47011": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47012": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47013": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47014": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47015": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47016": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47017": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47019": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47020": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47021": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47022": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47025": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47026": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47027": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47029": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47030": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47031": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47032": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47033": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47034": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47035": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47036": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47037": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47038": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47039": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47040": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47041": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47042": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47044": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47045": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47047": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47048": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47049": {"epss_score": 0.00065, "epss_percentile": 0.20514}, "CVE-2025-47050": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47051": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47052": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47053": {"epss_score": 0.00025, "epss_percentile": 0.06355}, "CVE-2025-47054": {"epss_score": 0.00053, "epss_percentile": 0.16815}, "CVE-2025-47055": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47056": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47057": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47060": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47061": {"epss_score": 0.00025, "epss_percentile": 0.06355}, "CVE-2025-47062": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47063": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47065": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47066": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47067": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47068": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47069": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47070": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47071": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47072": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47073": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47074": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47075": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47076": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47077": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47078": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47079": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47080": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47081": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47082": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47083": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47084": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47085": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47086": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47087": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47088": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47089": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47090": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47091": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47092": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47093": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47094": {"epss_score": 0.00065, "epss_percentile": 0.20514}, "CVE-2025-47096": {"epss_score": 0.00071, "epss_percentile": 0.22059}, "CVE-2025-47097": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47098": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47099": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47103": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47104": {"epss_score": 0.00026, "epss_percentile": 0.06423}, "CVE-2025-47105": {"epss_score": 0.00026, "epss_percentile": 0.06423}, "CVE-2025-47106": {"epss_score": 0.00031, "epss_percentile": 0.08663}, "CVE-2025-47107": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-47108": {"epss_score": 0.00031, "epss_percentile": 0.08429}, "CVE-2025-47109": {"epss_score": 0.0002, "epss_percentile": 0.04436}, "CVE-2025-47110": {"epss_score": 0.00095, "epss_percentile": 0.27162}, "CVE-2025-47111": {"epss_score": 0.00021, "epss_percentile": 0.04813}, "CVE-2025-47112": {"epss_score": 0.00026, "epss_percentile": 0.06423}, "CVE-2025-47113": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47114": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47115": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47116": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47117": {"epss_score": 0.00027, "epss_percentile": 0.07075}, "CVE-2025-47119": {"epss_score": 0.0002, "epss_percentile": 0.04436}, "CVE-2025-47120": {"epss_score": 0.00023, "epss_percentile": 0.05395}, "CVE-2025-47121": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47122": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47123": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47124": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47125": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47126": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47127": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47128": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47129": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47130": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47131": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47132": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47133": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47134": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47135": {"epss_score": 0.00023, "epss_percentile": 0.05395}, "CVE-2025-47136": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-47148": {"epss_score": 0.00112, "epss_percentile": 0.30563}, "CVE-2025-47149": {"epss_score": 0.00023, "epss_percentile": 0.05416}, "CVE-2025-47150": {"epss_score": 0.00112, "epss_percentile": 0.30563}, "CVE-2025-47151": {"epss_score": 0.00126, "epss_percentile": 0.32697}, "CVE-2025-47152": {"epss_score": 0.00037, "epss_percentile": 0.10632}, "CVE-2025-47153": {"epss_score": 0.00118, "epss_percentile": 0.31465}, "CVE-2025-47154": {"epss_score": 0.00351, "epss_percentile": 0.57074}, "CVE-2025-47158": {"epss_score": 0.00088, "epss_percentile": 0.25782}, "CVE-2025-47159": {"epss_score": 0.00058, "epss_percentile": 0.18473}, "CVE-2025-47160": {"epss_score": 0.0006, "epss_percentile": 0.1921}, "CVE-2025-47161": {"epss_score": 0.00915, "epss_percentile": 0.754}, "CVE-2025-47162": {"epss_score": 0.00074, "epss_percentile": 0.22806}, "CVE-2025-47163": {"epss_score": 0.0286, "epss_percentile": 0.85849}, "CVE-2025-47164": {"epss_score": 0.00074, "epss_percentile": 0.22806}, "CVE-2025-47165": {"epss_score": 0.00199, "epss_percentile": 0.42099}, "CVE-2025-47166": {"epss_score": 0.01917, "epss_percentile": 0.82872}, "CVE-2025-47167": {"epss_score": 0.00201, "epss_percentile": 0.4233}, "CVE-2025-47168": {"epss_score": 0.00073, "epss_percentile": 0.22502}, "CVE-2025-47169": {"epss_score": 0.00073, "epss_percentile": 0.22502}, "CVE-2025-47170": {"epss_score": 0.00063, "epss_percentile": 0.20088}, "CVE-2025-47171": {"epss_score": 0.00978, "epss_percentile": 0.76251}, "CVE-2025-47172": {"epss_score": 0.00226, "epss_percentile": 0.45331}, "CVE-2025-47173": {"epss_score": 0.00055, "epss_percentile": 0.17501}, "CVE-2025-47174": {"epss_score": 0.00063, "epss_percentile": 0.20088}, "CVE-2025-47175": {"epss_score": 0.00247, "epss_percentile": 0.47852}, "CVE-2025-47176": {"epss_score": 0.00089, "epss_percentile": 0.25941}, "CVE-2025-47178": {"epss_score": 0.00323, "epss_percentile": 0.54898}, "CVE-2025-47179": {"epss_score": 0.00066, "epss_percentile": 0.20933}, "CVE-2025-47181": {"epss_score": 0.0009, "epss_percentile": 0.25995}, "CVE-2025-47182": {"epss_score": 0.00048, "epss_percentile": 0.15029}, "CVE-2025-47183": {"epss_score": 0.00013, "epss_percentile": 0.01497}, "CVE-2025-47184": {"epss_score": 0.00071, "epss_percentile": 0.22071}, "CVE-2025-47187": {"epss_score": 0.00305, "epss_percentile": 0.53354}, "CVE-2025-47188": {"epss_score": 0.03648, "epss_percentile": 0.87505}, "CVE-2025-47189": {"epss_score": 0.00028, "epss_percentile": 0.07562}, "CVE-2025-47201": {"epss_score": 0.00044, "epss_percentile": 0.13611}, "CVE-2025-47202": {"epss_score": 0.00056, "epss_percentile": 0.17849}, "CVE-2025-47203": {"epss_score": 0.00073, "epss_percentile": 0.22629}, "CVE-2025-47204": {"epss_score": 0.00762, "epss_percentile": 0.72835}, "CVE-2025-47206": {"epss_score": 0.00203, "epss_percentile": 0.42524}, "CVE-2025-47207": {"epss_score": 0.00135, "epss_percentile": 0.34051}, "CVE-2025-47208": {"epss_score": 0.00119, "epss_percentile": 0.31596}, "CVE-2025-47210": {"epss_score": 0.00157, "epss_percentile": 0.37122}, "CVE-2025-47211": {"epss_score": 0.00072, "epss_percentile": 0.22454}, "CVE-2025-47212": {"epss_score": 0.00204, "epss_percentile": 0.42668}, "CVE-2025-47213": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-47214": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-47219": {"epss_score": 0.00072, "epss_percentile": 0.22441}, "CVE-2025-47220": {"epss_score": 0.0004, "epss_percentile": 0.12016}, "CVE-2025-47221": {"epss_score": 0.00038, "epss_percentile": 0.11183}, "CVE-2025-47222": {"epss_score": 0.00054, "epss_percentile": 0.17194}, "CVE-2025-47226": {"epss_score": 0.00464, "epss_percentile": 0.63715}, "CVE-2025-47227": {"epss_score": 0.01833, "epss_percentile": 0.8246}, "CVE-2025-47228": {"epss_score": 0.07419, "epss_percentile": 0.91464}, "CVE-2025-47229": {"epss_score": 0.00011, "epss_percentile": 0.01073}, "CVE-2025-47241": {"epss_score": 0.00034, "epss_percentile": 0.09691}, "CVE-2025-47244": {"epss_score": 0.00206, "epss_percentile": 0.43001}, "CVE-2025-47245": {"epss_score": 0.00051, "epss_percentile": 0.16283}, "CVE-2025-47256": {"epss_score": 0.00017, "epss_percentile": 0.03333}, "CVE-2025-47268": {"epss_score": 0.00215, "epss_percentile": 0.44103}, "CVE-2025-47269": {"epss_score": 0.00044, "epss_percentile": 0.13463}, "CVE-2025-47270": {"epss_score": 0.00157, "epss_percentile": 0.37054}, "CVE-2025-47271": {"epss_score": 0.00082, "epss_percentile": 0.24528}, "CVE-2025-47272": {"epss_score": 0.00025, "epss_percentile": 0.06156}, "CVE-2025-47273": {"epss_score": 0.00135, "epss_percentile": 0.34}, "CVE-2025-47274": {"epss_score": 0.00011, "epss_percentile": 0.00949}, "CVE-2025-47275": {"epss_score": 0.00023, "epss_percentile": 0.05326}, "CVE-2025-47276": {"epss_score": 0.00036, "epss_percentile": 0.10187}, "CVE-2025-47277": {"epss_score": 0.0033, "epss_percentile": 0.55456}, "CVE-2025-47278": {"epss_score": 0.00021, "epss_percentile": 0.04732}, "CVE-2025-47279": {"epss_score": 0.0004, "epss_percentile": 0.12145}, "CVE-2025-47280": {"epss_score": 0.00048, "epss_percentile": 0.14975}, "CVE-2025-47281": {"epss_score": 0.00035, "epss_percentile": 0.0997}, "CVE-2025-47282": {"epss_score": 0.0009, "epss_percentile": 0.26091}, "CVE-2025-47283": {"epss_score": 0.00083, "epss_percentile": 0.24737}, "CVE-2025-47284": {"epss_score": 0.00055, "epss_percentile": 0.17473}, "CVE-2025-47285": {"epss_score": 0.00023, "epss_percentile": 0.05432}, "CVE-2025-47286": {"epss_score": 0.00107, "epss_percentile": 0.2973}, "CVE-2025-47287": {"epss_score": 0.00253, "epss_percentile": 0.48485}, "CVE-2025-47288": {"epss_score": 0.00028, "epss_percentile": 0.07515}, "CVE-2025-47289": {"epss_score": 0.00028, "epss_percentile": 0.07447}, "CVE-2025-47290": {"epss_score": 9e-05, "epss_percentile": 0.007}, "CVE-2025-47291": {"epss_score": 0.00093, "epss_percentile": 0.26747}, "CVE-2025-47292": {"epss_score": 0.01864, "epss_percentile": 0.82599}, "CVE-2025-47293": {"epss_score": 0.00054, "epss_percentile": 0.17154}, "CVE-2025-47294": {"epss_score": 0.0009, "epss_percentile": 0.26077}, "CVE-2025-47295": {"epss_score": 0.00068, "epss_percentile": 0.2123}, "CVE-2025-47314": {"epss_score": 0.00026, "epss_percentile": 0.06413}, "CVE-2025-47315": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47316": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47317": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47318": {"epss_score": 0.00071, "epss_percentile": 0.2214}, "CVE-2025-47319": {"epss_score": 0.00015, "epss_percentile": 0.02348}, "CVE-2025-47320": {"epss_score": 0.00017, "epss_percentile": 0.0328}, "CVE-2025-47321": {"epss_score": 0.00017, "epss_percentile": 0.0328}, "CVE-2025-47322": {"epss_score": 0.00017, "epss_percentile": 0.0328}, "CVE-2025-47323": {"epss_score": 0.00017, "epss_percentile": 0.0328}, "CVE-2025-47324": {"epss_score": 0.00028, "epss_percentile": 0.07523}, "CVE-2025-47325": {"epss_score": 0.0001, "epss_percentile": 0.00897}, "CVE-2025-47326": {"epss_score": 0.00055, "epss_percentile": 0.17548}, "CVE-2025-47327": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47328": {"epss_score": 0.00055, "epss_percentile": 0.17548}, "CVE-2025-47329": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47330": {"epss_score": 0.00013, "epss_percentile": 0.01563}, "CVE-2025-47331": {"epss_score": 0.00013, "epss_percentile": 0.0162}, "CVE-2025-47332": {"epss_score": 0.00013, "epss_percentile": 0.01516}, "CVE-2025-47333": {"epss_score": 0.00015, "epss_percentile": 0.02222}, "CVE-2025-47334": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-47335": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-47336": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-47337": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2025-47338": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47339": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-47340": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47341": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47342": {"epss_score": 0.00055, "epss_percentile": 0.17417}, "CVE-2025-47343": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-47344": {"epss_score": 0.00013, "epss_percentile": 0.01516}, "CVE-2025-47345": {"epss_score": 0.00012, "epss_percentile": 0.01409}, "CVE-2025-47346": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-47347": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47348": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-47349": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47350": {"epss_score": 0.00013, "epss_percentile": 0.015}, "CVE-2025-47351": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47352": {"epss_score": 0.00015, "epss_percentile": 0.0219}, "CVE-2025-47353": {"epss_score": 0.00015, "epss_percentile": 0.0219}, "CVE-2025-47354": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47355": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-47356": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-47357": {"epss_score": 0.00012, "epss_percentile": 0.01294}, "CVE-2025-47360": {"epss_score": 0.00015, "epss_percentile": 0.0219}, "CVE-2025-47361": {"epss_score": 0.00015, "epss_percentile": 0.0219}, "CVE-2025-47362": {"epss_score": 0.00013, "epss_percentile": 0.01484}, "CVE-2025-47365": {"epss_score": 0.00015, "epss_percentile": 0.0219}, "CVE-2025-47367": {"epss_score": 0.00015, "epss_percentile": 0.0219}, "CVE-2025-47368": {"epss_score": 0.00015, "epss_percentile": 0.0219}, "CVE-2025-47369": {"epss_score": 0.00012, "epss_percentile": 0.01409}, "CVE-2025-47370": {"epss_score": 0.00032, "epss_percentile": 0.09095}, "CVE-2025-47372": {"epss_score": 0.00016, "epss_percentile": 0.02875}, "CVE-2025-47380": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-47382": {"epss_score": 0.00016, "epss_percentile": 0.02687}, "CVE-2025-47387": {"epss_score": 0.00017, "epss_percentile": 0.0328}, "CVE-2025-47388": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-47393": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-47394": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-47395": {"epss_score": 0.0002, "epss_percentile": 0.04543}, "CVE-2025-47396": {"epss_score": 0.00015, "epss_percentile": 0.02474}, "CVE-2025-47410": {"epss_score": 0.00018, "epss_percentile": 0.04005}, "CVE-2025-47411": {"epss_score": 0.00071, "epss_percentile": 0.22227}, "CVE-2025-47415": {"epss_score": 0.00086, "epss_percentile": 0.25322}, "CVE-2025-47416": {"epss_score": 0.00094, "epss_percentile": 0.27011}, "CVE-2025-47417": {"epss_score": 0.00053, "epss_percentile": 0.17032}, "CVE-2025-47418": {"epss_score": 0.00058, "epss_percentile": 0.184}, "CVE-2025-47419": {"epss_score": 0.00031, "epss_percentile": 0.08569}, "CVE-2025-47420": {"epss_score": 0.00053, "epss_percentile": 0.1697}, "CVE-2025-47421": {"epss_score": 0.00079, "epss_percentile": 0.23872}, "CVE-2025-47422": {"epss_score": 0.00053, "epss_percentile": 0.16939}, "CVE-2025-47423": {"epss_score": 0.01034, "epss_percentile": 0.76884}, "CVE-2025-47424": {"epss_score": 0.0002, "epss_percentile": 0.04515}, "CVE-2025-47436": {"epss_score": 0.00064, "epss_percentile": 0.2035}, "CVE-2025-47437": {"epss_score": 0.00026, "epss_percentile": 0.06398}, "CVE-2025-47438": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-47439": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-47440": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-47441": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47442": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47443": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47444": {"epss_score": 0.00037, "epss_percentile": 0.10622}, "CVE-2025-47445": {"epss_score": 0.03653, "epss_percentile": 0.87511}, "CVE-2025-47446": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47447": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47448": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47449": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47450": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-47451": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47452": {"epss_score": 0.00061, "epss_percentile": 0.19256}, "CVE-2025-47453": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-47454": {"epss_score": 0.00029, "epss_percentile": 0.07866}, "CVE-2025-47455": {"epss_score": 0.00029, "epss_percentile": 0.07866}, "CVE-2025-47456": {"epss_score": 0.00029, "epss_percentile": 0.07866}, "CVE-2025-47457": {"epss_score": 0.00039, "epss_percentile": 0.1161}, "CVE-2025-47458": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-47459": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47460": {"epss_score": 0.00034, "epss_percentile": 0.09702}, "CVE-2025-47461": {"epss_score": 0.00066, "epss_percentile": 0.20819}, "CVE-2025-47462": {"epss_score": 0.0002, "epss_percentile": 0.0464}, "CVE-2025-47463": {"epss_score": 0.00056, "epss_percentile": 0.17784}, "CVE-2025-47464": {"epss_score": 0.00026, "epss_percentile": 0.06591}, "CVE-2025-47465": {"epss_score": 0.00034, "epss_percentile": 0.09472}, "CVE-2025-47466": {"epss_score": 0.00016, "epss_percentile": 0.03033}, "CVE-2025-47467": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-47468": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47469": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2025-47470": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47471": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-47472": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2025-47473": {"epss_score": 0.00016, "epss_percentile": 0.03033}, "CVE-2025-47475": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47476": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47477": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-47478": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-47479": {"epss_score": 0.00055, "epss_percentile": 0.17539}, "CVE-2025-47480": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2025-47481": {"epss_score": 0.00044, "epss_percentile": 0.13416}, "CVE-2025-47482": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47483": {"epss_score": 0.00026, "epss_percentile": 0.06591}, "CVE-2025-47484": {"epss_score": 0.00035, "epss_percentile": 0.09875}, "CVE-2025-47485": {"epss_score": 0.00039, "epss_percentile": 0.1161}, "CVE-2025-47486": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-47487": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-47488": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47489": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47490": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-47491": {"epss_score": 0.00017, "epss_percentile": 0.03209}, "CVE-2025-47492": {"epss_score": 0.00207, "epss_percentile": 0.4319}, "CVE-2025-47493": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47494": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-47495": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47496": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-47497": {"epss_score": 0.00044, "epss_percentile": 0.13537}, "CVE-2025-47498": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-47499": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47501": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47502": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47503": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47504": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47505": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47506": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47507": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47508": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-47509": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47510": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-47511": {"epss_score": 0.00057, "epss_percentile": 0.18162}, "CVE-2025-47512": {"epss_score": 0.0006, "epss_percentile": 0.18957}, "CVE-2025-47513": {"epss_score": 0.00067, "epss_percentile": 0.2097}, "CVE-2025-47514": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-47515": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47516": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47517": {"epss_score": 0.00014, "epss_percentile": 0.02066}, "CVE-2025-47518": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47519": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47520": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47521": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47522": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47523": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47524": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47525": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47526": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2025-47527": {"epss_score": 0.00056, "epss_percentile": 0.17784}, "CVE-2025-47528": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-47529": {"epss_score": 0.00055, "epss_percentile": 0.17577}, "CVE-2025-47530": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-47531": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-47532": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-47533": {"epss_score": 0.0002, "epss_percentile": 0.04522}, "CVE-2025-47534": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-47535": {"epss_score": 0.0006, "epss_percentile": 0.18957}, "CVE-2025-47536": {"epss_score": 0.00068, "epss_percentile": 0.21371}, "CVE-2025-47537": {"epss_score": 0.00034, "epss_percentile": 0.09702}, "CVE-2025-47538": {"epss_score": 0.00035, "epss_percentile": 0.10009}, "CVE-2025-47539": {"epss_score": 0.29478, "epss_percentile": 0.96446}, "CVE-2025-47540": {"epss_score": 0.00043, "epss_percentile": 0.13015}, "CVE-2025-47541": {"epss_score": 0.00045, "epss_percentile": 0.13779}, "CVE-2025-47542": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47543": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47544": {"epss_score": 0.00035, "epss_percentile": 0.10009}, "CVE-2025-47545": {"epss_score": 0.00063, "epss_percentile": 0.19983}, "CVE-2025-47546": {"epss_score": 0.00019, "epss_percentile": 0.04393}, "CVE-2025-47547": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-47548": {"epss_score": 0.00032, "epss_percentile": 0.0897}, "CVE-2025-47549": {"epss_score": 0.00098, "epss_percentile": 0.27686}, "CVE-2025-47550": {"epss_score": 0.00086, "epss_percentile": 0.25245}, "CVE-2025-47551": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47552": {"epss_score": 0.00041, "epss_percentile": 0.1234}, "CVE-2025-47553": {"epss_score": 0.00048, "epss_percentile": 0.15057}, "CVE-2025-47554": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-47556": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2025-47557": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47558": {"epss_score": 0.00046, "epss_percentile": 0.14268}, "CVE-2025-47559": {"epss_score": 0.00061, "epss_percentile": 0.19256}, "CVE-2025-47560": {"epss_score": 0.00035, "epss_percentile": 0.09875}, "CVE-2025-47561": {"epss_score": 0.00063, "epss_percentile": 0.1991}, "CVE-2025-47562": {"epss_score": 0.00044, "epss_percentile": 0.13416}, "CVE-2025-47563": {"epss_score": 0.00039, "epss_percentile": 0.1161}, "CVE-2025-47564": {"epss_score": 0.00058, "epss_percentile": 0.18574}, "CVE-2025-47565": {"epss_score": 0.00048, "epss_percentile": 0.15249}, "CVE-2025-47566": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-47567": {"epss_score": 0.00034, "epss_percentile": 0.09702}, "CVE-2025-47568": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-47569": {"epss_score": 0.00045, "epss_percentile": 0.13716}, "CVE-2025-47570": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-47571": {"epss_score": 0.00143, "epss_percentile": 0.35197}, "CVE-2025-47572": {"epss_score": 0.00109, "epss_percentile": 0.2997}, "CVE-2025-47573": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-47574": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-47575": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-47576": {"epss_score": 0.00175, "epss_percentile": 0.39367}, "CVE-2025-47577": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-47578": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47579": {"epss_score": 0.00031, "epss_percentile": 0.08613}, "CVE-2025-47580": {"epss_score": 0.00063, "epss_percentile": 0.20046}, "CVE-2025-47581": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-47582": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-47583": {"epss_score": 0.00016, "epss_percentile": 0.03033}, "CVE-2025-47584": {"epss_score": 0.00089, "epss_percentile": 0.25913}, "CVE-2025-47585": {"epss_score": 0.00055, "epss_percentile": 0.17577}, "CVE-2025-47586": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-47587": {"epss_score": 0.00034, "epss_percentile": 0.09702}, "CVE-2025-47588": {"epss_score": 0.00068, "epss_percentile": 0.21388}, "CVE-2025-47589": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47590": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47591": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2025-47592": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47593": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47594": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47595": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47596": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47597": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47598": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-47599": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-47601": {"epss_score": 0.00063, "epss_percentile": 0.1991}, "CVE-2025-47602": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2025-47603": {"epss_score": 0.00073, "epss_percentile": 0.22501}, "CVE-2025-47604": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47605": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47606": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47607": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47608": {"epss_score": 0.28034, "epss_percentile": 0.96302}, "CVE-2025-47609": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47610": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-47611": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-47612": {"epss_score": 0.0006, "epss_percentile": 0.19099}, "CVE-2025-47613": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-47614": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47615": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47616": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47617": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47618": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-47619": {"epss_score": 0.00041, "epss_percentile": 0.12303}, "CVE-2025-47620": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-47621": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47622": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47623": {"epss_score": 0.00022, "epss_percentile": 0.0532}, "CVE-2025-47624": {"epss_score": 0.00017, "epss_percentile": 0.03402}, "CVE-2025-47625": {"epss_score": 0.00022, "epss_percentile": 0.0532}, "CVE-2025-47626": {"epss_score": 0.00022, "epss_percentile": 0.0532}, "CVE-2025-47627": {"epss_score": 0.00092, "epss_percentile": 0.26545}, "CVE-2025-47628": {"epss_score": 0.0006, "epss_percentile": 0.19099}, "CVE-2025-47629": {"epss_score": 0.00104, "epss_percentile": 0.2922}, "CVE-2025-47630": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-47631": {"epss_score": 0.0006, "epss_percentile": 0.19099}, "CVE-2025-47632": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-47633": {"epss_score": 0.00017, "epss_percentile": 0.03402}, "CVE-2025-47634": {"epss_score": 0.00054, "epss_percentile": 0.17191}, "CVE-2025-47635": {"epss_score": 0.00039, "epss_percentile": 0.11619}, "CVE-2025-47636": {"epss_score": 0.00041, "epss_percentile": 0.12215}, "CVE-2025-47637": {"epss_score": 0.00066, "epss_percentile": 0.20739}, "CVE-2025-47638": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47639": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-47640": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-47641": {"epss_score": 0.00066, "epss_percentile": 0.20739}, "CVE-2025-47642": {"epss_score": 0.00066, "epss_percentile": 0.20739}, "CVE-2025-47643": {"epss_score": 0.00034, "epss_percentile": 0.09702}, "CVE-2025-47644": {"epss_score": 0.00029, "epss_percentile": 0.07866}, "CVE-2025-47645": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-47646": {"epss_score": 0.05125, "epss_percentile": 0.89524}, "CVE-2025-47647": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47648": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-47649": {"epss_score": 0.00073, "epss_percentile": 0.22591}, "CVE-2025-47650": {"epss_score": 0.00071, "epss_percentile": 0.22117}, "CVE-2025-47651": {"epss_score": 0.00039, "epss_percentile": 0.11553}, "CVE-2025-47652": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-47653": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-47654": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-47655": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-47656": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47657": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-47658": {"epss_score": 0.00065, "epss_percentile": 0.20582}, "CVE-2025-47659": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47660": {"epss_score": 0.00113, "epss_percentile": 0.30655}, "CVE-2025-47661": {"epss_score": 0.00016, "epss_percentile": 0.03033}, "CVE-2025-47662": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47663": {"epss_score": 0.00065, "epss_percentile": 0.20582}, "CVE-2025-47664": {"epss_score": 0.00027, "epss_percentile": 0.06957}, "CVE-2025-47665": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47667": {"epss_score": 0.00016, "epss_percentile": 0.03033}, "CVE-2025-47668": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-47669": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47670": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-47671": {"epss_score": 0.00034, "epss_percentile": 0.09702}, "CVE-2025-47672": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-47673": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-47674": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47675": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47676": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47677": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47678": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-47679": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47680": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-47681": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-47682": {"epss_score": 0.00038, "epss_percentile": 0.11365}, "CVE-2025-47683": {"epss_score": 0.00104, "epss_percentile": 0.2922}, "CVE-2025-47684": {"epss_score": 0.00016, "epss_percentile": 0.03033}, "CVE-2025-47685": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-47686": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-47687": {"epss_score": 0.00066, "epss_percentile": 0.20739}, "CVE-2025-47688": {"epss_score": 0.00045, "epss_percentile": 0.13729}, "CVE-2025-47689": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-47690": {"epss_score": 0.0006, "epss_percentile": 0.19099}, "CVE-2025-47691": {"epss_score": 0.00034, "epss_percentile": 0.09658}, "CVE-2025-47692": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-47693": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-47694": {"epss_score": 0.00021, "epss_percentile": 0.04753}, "CVE-2025-47695": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-47696": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-47697": {"epss_score": 0.00141, "epss_percentile": 0.34843}, "CVE-2025-47698": {"epss_score": 0.00015, "epss_percentile": 0.023}, "CVE-2025-47699": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2025-47700": {"epss_score": 0.00051, "epss_percentile": 0.16034}, "CVE-2025-47701": {"epss_score": 0.00021, "epss_percentile": 0.04942}, "CVE-2025-47702": {"epss_score": 0.00025, "epss_percentile": 0.06363}, "CVE-2025-47703": {"epss_score": 0.00025, "epss_percentile": 0.06363}, "CVE-2025-47704": {"epss_score": 0.00025, "epss_percentile": 0.06363}, "CVE-2025-47705": {"epss_score": 0.00025, "epss_percentile": 0.06363}, "CVE-2025-47706": {"epss_score": 0.00034, "epss_percentile": 0.09467}, "CVE-2025-47707": {"epss_score": 0.00053, "epss_percentile": 0.16706}, "CVE-2025-47708": {"epss_score": 0.00021, "epss_percentile": 0.04942}, "CVE-2025-47709": {"epss_score": 0.00039, "epss_percentile": 0.11591}, "CVE-2025-47710": {"epss_score": 0.0004, "epss_percentile": 0.11908}, "CVE-2025-47711": {"epss_score": 0.00064, "epss_percentile": 0.20324}, "CVE-2025-47712": {"epss_score": 0.00102, "epss_percentile": 0.28773}, "CVE-2025-47713": {"epss_score": 0.00106, "epss_percentile": 0.29561}, "CVE-2025-47724": {"epss_score": 0.00015, "epss_percentile": 0.02394}, "CVE-2025-47725": {"epss_score": 0.00015, "epss_percentile": 0.02394}, "CVE-2025-47726": {"epss_score": 0.00015, "epss_percentile": 0.02394}, "CVE-2025-47727": {"epss_score": 0.00015, "epss_percentile": 0.02394}, "CVE-2025-47728": {"epss_score": 0.00015, "epss_percentile": 0.02394}, "CVE-2025-47729": {"epss_score": 0.02152, "epss_percentile": 0.83793}, "CVE-2025-47730": {"epss_score": 0.00043, "epss_percentile": 0.12951}, "CVE-2025-47732": {"epss_score": 0.00276, "epss_percentile": 0.50774}, "CVE-2025-47733": {"epss_score": 0.00165, "epss_percentile": 0.3803}, "CVE-2025-47735": {"epss_score": 0.00012, "epss_percentile": 0.01284}, "CVE-2025-47736": {"epss_score": 0.00017, "epss_percentile": 0.03351}, "CVE-2025-47737": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2025-47748": {"epss_score": 0.00062, "epss_percentile": 0.19592}, "CVE-2025-47749": {"epss_score": 0.00026, "epss_percentile": 0.06735}, "CVE-2025-47750": {"epss_score": 0.00026, "epss_percentile": 0.06735}, "CVE-2025-47751": {"epss_score": 0.00026, "epss_percentile": 0.06735}, "CVE-2025-47752": {"epss_score": 0.00026, "epss_percentile": 0.06735}, "CVE-2025-47753": {"epss_score": 0.00026, "epss_percentile": 0.06735}, "CVE-2025-47754": {"epss_score": 0.00026, "epss_percentile": 0.06735}, "CVE-2025-47755": {"epss_score": 0.00026, "epss_percentile": 0.06735}, "CVE-2025-47756": {"epss_score": 0.00026, "epss_percentile": 0.06735}, "CVE-2025-47757": {"epss_score": 0.00026, "epss_percentile": 0.06735}, "CVE-2025-47758": {"epss_score": 0.00026, "epss_percentile": 0.06735}, "CVE-2025-47759": {"epss_score": 0.00026, "epss_percentile": 0.06735}, "CVE-2025-47760": {"epss_score": 0.00026, "epss_percentile": 0.06735}, "CVE-2025-47761": {"epss_score": 0.00018, "epss_percentile": 0.03685}, "CVE-2025-47771": {"epss_score": 0.00147, "epss_percentile": 0.35674}, "CVE-2025-47773": {"epss_score": 0.00039, "epss_percentile": 0.11617}, "CVE-2025-47774": {"epss_score": 0.00035, "epss_percentile": 0.10145}, "CVE-2025-47775": {"epss_score": 0.00057, "epss_percentile": 0.18228}, "CVE-2025-47776": {"epss_score": 0.00084, "epss_percentile": 0.24857}, "CVE-2025-47777": {"epss_score": 0.00272, "epss_percentile": 0.50346}, "CVE-2025-47778": {"epss_score": 0.00045, "epss_percentile": 0.13953}, "CVE-2025-47779": {"epss_score": 0.00074, "epss_percentile": 0.22863}, "CVE-2025-47780": {"epss_score": 0.00103, "epss_percentile": 0.28977}, "CVE-2025-47781": {"epss_score": 0.00279, "epss_percentile": 0.50956}, "CVE-2025-47782": {"epss_score": 0.00053, "epss_percentile": 0.16867}, "CVE-2025-47783": {"epss_score": 0.00035, "epss_percentile": 0.1006}, "CVE-2025-47784": {"epss_score": 0.00198, "epss_percentile": 0.42088}, "CVE-2025-47785": {"epss_score": 0.0044, "epss_percentile": 0.62621}, "CVE-2025-47786": {"epss_score": 0.00025, "epss_percentile": 0.06234}, "CVE-2025-47787": {"epss_score": 0.0036, "epss_percentile": 0.57621}, "CVE-2025-47788": {"epss_score": 0.00097, "epss_percentile": 0.27515}, "CVE-2025-47789": {"epss_score": 0.00029, "epss_percentile": 0.07847}, "CVE-2025-47790": {"epss_score": 0.00021, "epss_percentile": 0.04919}, "CVE-2025-47791": {"epss_score": 0.00041, "epss_percentile": 0.1229}, "CVE-2025-47792": {"epss_score": 8e-05, "epss_percentile": 0.00558}, "CVE-2025-47793": {"epss_score": 0.00044, "epss_percentile": 0.13391}, "CVE-2025-47794": {"epss_score": 0.00019, "epss_percentile": 0.04227}, "CVE-2025-47806": {"epss_score": 0.00061, "epss_percentile": 0.19526}, "CVE-2025-47807": {"epss_score": 0.0002, "epss_percentile": 0.04608}, "CVE-2025-47808": {"epss_score": 0.00073, "epss_percentile": 0.22651}, "CVE-2025-47809": {"epss_score": 0.00016, "epss_percentile": 0.02742}, "CVE-2025-47811": {"epss_score": 0.00062, "epss_percentile": 0.19672}, "CVE-2025-47812": {"epss_score": 0.924, "epss_percentile": 0.99713}, "CVE-2025-47813": {"epss_score": 0.00576, "epss_percentile": 0.68125}, "CVE-2025-47814": {"epss_score": 0.0005, "epss_percentile": 0.15948}, "CVE-2025-47815": {"epss_score": 0.0005, "epss_percentile": 0.15948}, "CVE-2025-47816": {"epss_score": 0.0005, "epss_percentile": 0.15948}, "CVE-2025-47817": {"epss_score": 0.00062, "epss_percentile": 0.19592}, "CVE-2025-47818": {"epss_score": 0.00017, "epss_percentile": 0.03277}, "CVE-2025-47819": {"epss_score": 0.00024, "epss_percentile": 0.05849}, "CVE-2025-47820": {"epss_score": 9e-05, "epss_percentile": 0.00608}, "CVE-2025-47821": {"epss_score": 0.00017, "epss_percentile": 0.03277}, "CVE-2025-47822": {"epss_score": 0.00024, "epss_percentile": 0.05849}, "CVE-2025-47823": {"epss_score": 0.00017, "epss_percentile": 0.03277}, "CVE-2025-47824": {"epss_score": 9e-05, "epss_percentile": 0.00608}, "CVE-2025-47827": {"epss_score": 0.00849, "epss_percentile": 0.74378}, "CVE-2025-47828": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-47849": {"epss_score": 0.00106, "epss_percentile": 0.29561}, "CVE-2025-47850": {"epss_score": 1e-05, "epss_percentile": 0.0001}, "CVE-2025-47851": {"epss_score": 8e-05, "epss_percentile": 0.00472}, "CVE-2025-47852": {"epss_score": 7e-05, "epss_percentile": 0.00377}, "CVE-2025-47853": {"epss_score": 7e-05, "epss_percentile": 0.00377}, "CVE-2025-47854": {"epss_score": 1e-05, "epss_percentile": 7e-05}, "CVE-2025-47856": {"epss_score": 0.00063, "epss_percentile": 0.19944}, "CVE-2025-47857": {"epss_score": 0.00028, "epss_percentile": 0.07275}, "CVE-2025-47865": {"epss_score": 0.0031, "epss_percentile": 0.53792}, "CVE-2025-47866": {"epss_score": 0.00056, "epss_percentile": 0.17785}, "CVE-2025-47867": {"epss_score": 0.00294, "epss_percentile": 0.52435}, "CVE-2025-47868": {"epss_score": 0.00086, "epss_percentile": 0.25405}, "CVE-2025-47869": {"epss_score": 0.00086, "epss_percentile": 0.25405}, "CVE-2025-47870": {"epss_score": 0.00048, "epss_percentile": 0.15218}, "CVE-2025-47871": {"epss_score": 0.00041, "epss_percentile": 0.12275}, "CVE-2025-47872": {"epss_score": 0.00031, "epss_percentile": 0.08655}, "CVE-2025-47884": {"epss_score": 0.00248, "epss_percentile": 0.47926}, "CVE-2025-47885": {"epss_score": 0.00019, "epss_percentile": 0.04278}, "CVE-2025-47886": {"epss_score": 0.00019, "epss_percentile": 0.04404}, "CVE-2025-47887": {"epss_score": 0.00025, "epss_percentile": 0.06269}, "CVE-2025-47888": {"epss_score": 0.00052, "epss_percentile": 0.16553}, "CVE-2025-47889": {"epss_score": 0.00107, "epss_percentile": 0.29655}, "CVE-2025-47890": {"epss_score": 0.00031, "epss_percentile": 0.08691}, "CVE-2025-47900": {"epss_score": 0.00547, "epss_percentile": 0.67249}, "CVE-2025-47901": {"epss_score": 0.00547, "epss_percentile": 0.67249}, "CVE-2025-47902": {"epss_score": 0.00054, "epss_percentile": 0.17153}, "CVE-2025-47905": {"epss_score": 0.00035, "epss_percentile": 0.10125}, "CVE-2025-47906": {"epss_score": 0.00015, "epss_percentile": 0.02281}, "CVE-2025-47907": {"epss_score": 0.00013, "epss_percentile": 0.01558}, "CVE-2025-47908": {"epss_score": 0.00086, "epss_percentile": 0.25419}, "CVE-2025-47909": {"epss_score": 0.0004, "epss_percentile": 0.12172}, "CVE-2025-47910": {"epss_score": 0.00012, "epss_percentile": 0.01407}, "CVE-2025-47912": {"epss_score": 0.00033, "epss_percentile": 0.09198}, "CVE-2025-47913": {"epss_score": 0.00025, "epss_percentile": 0.06314}, "CVE-2025-47914": {"epss_score": 0.00017, "epss_percentile": 0.03406}, "CVE-2025-47916": {"epss_score": 0.90163, "epss_percentile": 0.99566}, "CVE-2025-47917": {"epss_score": 0.02363, "epss_percentile": 0.84506}, "CVE-2025-47928": {"epss_score": 0.00042, "epss_percentile": 0.1291}, "CVE-2025-47929": {"epss_score": 0.00061, "epss_percentile": 0.19427}, "CVE-2025-47930": {"epss_score": 0.00045, "epss_percentile": 0.13961}, "CVE-2025-47931": {"epss_score": 2e-05, "epss_percentile": 0.00035}, "CVE-2025-47932": {"epss_score": 0.00039, "epss_percentile": 0.11617}, "CVE-2025-47933": {"epss_score": 0.00011, "epss_percentile": 0.00955}, "CVE-2025-47934": {"epss_score": 0.00025, "epss_percentile": 0.06279}, "CVE-2025-47935": {"epss_score": 0.00049, "epss_percentile": 0.15568}, "CVE-2025-47936": {"epss_score": 0.0003, "epss_percentile": 0.07987}, "CVE-2025-47937": {"epss_score": 0.00034, "epss_percentile": 0.09664}, "CVE-2025-47938": {"epss_score": 0.00042, "epss_percentile": 0.12793}, "CVE-2025-47939": {"epss_score": 0.00031, "epss_percentile": 0.08537}, "CVE-2025-47940": {"epss_score": 0.00058, "epss_percentile": 0.18516}, "CVE-2025-47941": {"epss_score": 0.00073, "epss_percentile": 0.22565}, "CVE-2025-47942": {"epss_score": 0.00039, "epss_percentile": 0.11461}, "CVE-2025-47943": {"epss_score": 0.0003, "epss_percentile": 0.08311}, "CVE-2025-47944": {"epss_score": 0.00012, "epss_percentile": 0.01142}, "CVE-2025-47945": {"epss_score": 0.001, "epss_percentile": 0.28483}, "CVE-2025-47946": {"epss_score": 0.00024, "epss_percentile": 0.05956}, "CVE-2025-47947": {"epss_score": 0.00177, "epss_percentile": 0.39588}, "CVE-2025-47948": {"epss_score": 0.00052, "epss_percentile": 0.16386}, "CVE-2025-47949": {"epss_score": 0.00026, "epss_percentile": 0.06622}, "CVE-2025-47950": {"epss_score": 0.00188, "epss_percentile": 0.40858}, "CVE-2025-47951": {"epss_score": 0.0004, "epss_percentile": 0.11972}, "CVE-2025-47952": {"epss_score": 0.00036, "epss_percentile": 0.10208}, "CVE-2025-47953": {"epss_score": 0.00068, "epss_percentile": 0.21422}, "CVE-2025-47954": {"epss_score": 0.00112, "epss_percentile": 0.30475}, "CVE-2025-47955": {"epss_score": 0.00061, "epss_percentile": 0.19513}, "CVE-2025-47956": {"epss_score": 0.00123, "epss_percentile": 0.32273}, "CVE-2025-47957": {"epss_score": 0.00231, "epss_percentile": 0.45844}, "CVE-2025-47959": {"epss_score": 0.00063, "epss_percentile": 0.20077}, "CVE-2025-47962": {"epss_score": 0.00061, "epss_percentile": 0.19513}, "CVE-2025-47963": {"epss_score": 0.00068, "epss_percentile": 0.21361}, "CVE-2025-47964": {"epss_score": 0.0004, "epss_percentile": 0.12194}, "CVE-2025-47966": {"epss_score": 0.0024, "epss_percentile": 0.47206}, "CVE-2025-47967": {"epss_score": 0.0008, "epss_percentile": 0.24056}, "CVE-2025-47968": {"epss_score": 0.00101, "epss_percentile": 0.28636}, "CVE-2025-47969": {"epss_score": 0.00064, "epss_percentile": 0.20346}, "CVE-2025-47971": {"epss_score": 0.00056, "epss_percentile": 0.17875}, "CVE-2025-47972": {"epss_score": 0.00044, "epss_percentile": 0.13371}, "CVE-2025-47973": {"epss_score": 0.00056, "epss_percentile": 0.17875}, "CVE-2025-47975": {"epss_score": 0.00039, "epss_percentile": 0.11841}, "CVE-2025-47976": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-47977": {"epss_score": 0.00059, "epss_percentile": 0.18625}, "CVE-2025-47978": {"epss_score": 0.00132, "epss_percentile": 0.33611}, "CVE-2025-47979": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-47980": {"epss_score": 0.00066, "epss_percentile": 0.20839}, "CVE-2025-47981": {"epss_score": 0.00418, "epss_percentile": 0.61324}, "CVE-2025-47982": {"epss_score": 0.00086, "epss_percentile": 0.25358}, "CVE-2025-47984": {"epss_score": 0.00155, "epss_percentile": 0.36798}, "CVE-2025-47985": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-47986": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-47987": {"epss_score": 0.00078, "epss_percentile": 0.23654}, "CVE-2025-47988": {"epss_score": 0.00076, "epss_percentile": 0.23144}, "CVE-2025-47989": {"epss_score": 0.00041, "epss_percentile": 0.12313}, "CVE-2025-47991": {"epss_score": 0.00039, "epss_percentile": 0.11841}, "CVE-2025-47993": {"epss_score": 0.00054, "epss_percentile": 0.17326}, "CVE-2025-47994": {"epss_score": 0.00268, "epss_percentile": 0.50046}, "CVE-2025-47995": {"epss_score": 0.00145, "epss_percentile": 0.35369}, "CVE-2025-47996": {"epss_score": 0.00078, "epss_percentile": 0.23654}, "CVE-2025-47997": {"epss_score": 0.00116, "epss_percentile": 0.31107}, "CVE-2025-47998": {"epss_score": 0.00065, "epss_percentile": 0.20447}, "CVE-2025-47999": {"epss_score": 0.00233, "epss_percentile": 0.45973}, "CVE-2025-48000": {"epss_score": 0.00044, "epss_percentile": 0.13525}, "CVE-2025-48001": {"epss_score": 0.0006, "epss_percentile": 0.1918}, "CVE-2025-48002": {"epss_score": 0.0019, "epss_percentile": 0.41071}, "CVE-2025-48003": {"epss_score": 0.00077, "epss_percentile": 0.23308}, "CVE-2025-48004": {"epss_score": 0.00081, "epss_percentile": 0.24329}, "CVE-2025-48005": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-48006": {"epss_score": 0.00054, "epss_percentile": 0.17144}, "CVE-2025-48007": {"epss_score": 0.00045, "epss_percentile": 0.13714}, "CVE-2025-48008": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-48009": {"epss_score": 0.00028, "epss_percentile": 0.07251}, "CVE-2025-48010": {"epss_score": 0.00034, "epss_percentile": 0.09467}, "CVE-2025-48011": {"epss_score": 0.00044, "epss_percentile": 0.13533}, "CVE-2025-48012": {"epss_score": 0.00034, "epss_percentile": 0.09467}, "CVE-2025-48013": {"epss_score": 0.00047, "epss_percentile": 0.146}, "CVE-2025-48014": {"epss_score": 0.0005, "epss_percentile": 0.15737}, "CVE-2025-48015": {"epss_score": 0.00029, "epss_percentile": 0.07645}, "CVE-2025-48016": {"epss_score": 0.0001, "epss_percentile": 0.00821}, "CVE-2025-48017": {"epss_score": 0.00062, "epss_percentile": 0.19773}, "CVE-2025-48018": {"epss_score": 0.00038, "epss_percentile": 0.1122}, "CVE-2025-48024": {"epss_score": 0.00052, "epss_percentile": 0.16537}, "CVE-2025-48025": {"epss_score": 0.00041, "epss_percentile": 0.12383}, "CVE-2025-48026": {"epss_score": 0.00206, "epss_percentile": 0.43003}, "CVE-2025-48027": {"epss_score": 0.00032, "epss_percentile": 0.08822}, "CVE-2025-48038": {"epss_score": 0.00098, "epss_percentile": 0.27679}, "CVE-2025-48039": {"epss_score": 0.00098, "epss_percentile": 0.27679}, "CVE-2025-48040": {"epss_score": 0.00068, "epss_percentile": 0.21282}, "CVE-2025-48041": {"epss_score": 0.00098, "epss_percentile": 0.27679}, "CVE-2025-48042": {"epss_score": 0.00074, "epss_percentile": 0.22869}, "CVE-2025-48043": {"epss_score": 0.00125, "epss_percentile": 0.32477}, "CVE-2025-48044": {"epss_score": 0.00125, "epss_percentile": 0.32477}, "CVE-2025-48045": {"epss_score": 0.00077, "epss_percentile": 0.23408}, "CVE-2025-48046": {"epss_score": 0.0007, "epss_percentile": 0.2184}, "CVE-2025-48047": {"epss_score": 0.00252, "epss_percentile": 0.48402}, "CVE-2025-48050": {"epss_score": 0.00057, "epss_percentile": 0.18165}, "CVE-2025-48051": {"epss_score": 0.00035, "epss_percentile": 0.09946}, "CVE-2025-48053": {"epss_score": 0.00104, "epss_percentile": 0.29166}, "CVE-2025-48054": {"epss_score": 0.01214, "epss_percentile": 0.78575}, "CVE-2025-48055": {"epss_score": 0.00037, "epss_percentile": 0.10992}, "CVE-2025-48056": {"epss_score": 0.00034, "epss_percentile": 0.09726}, "CVE-2025-48057": {"epss_score": 0.00045, "epss_percentile": 0.14067}, "CVE-2025-48058": {"epss_score": 0.00114, "epss_percentile": 0.30814}, "CVE-2025-48059": {"epss_score": 0.00114, "epss_percentile": 0.30814}, "CVE-2025-48060": {"epss_score": 0.00116, "epss_percentile": 0.31122}, "CVE-2025-48061": {"epss_score": 0.00012, "epss_percentile": 0.01288}, "CVE-2025-48062": {"epss_score": 0.00045, "epss_percentile": 0.13719}, "CVE-2025-48063": {"epss_score": 0.02793, "epss_percentile": 0.85673}, "CVE-2025-48064": {"epss_score": 0.00013, "epss_percentile": 0.01593}, "CVE-2025-48065": {"epss_score": 0.00039, "epss_percentile": 0.11617}, "CVE-2025-48066": {"epss_score": 0.0001, "epss_percentile": 0.00854}, "CVE-2025-48067": {"epss_score": 0.00024, "epss_percentile": 0.0582}, "CVE-2025-48068": {"epss_score": 0.00015, "epss_percentile": 0.02289}, "CVE-2025-48069": {"epss_score": 0.00096, "epss_percentile": 0.27345}, "CVE-2025-48070": {"epss_score": 0.00029, "epss_percentile": 0.07746}, "CVE-2025-48071": {"epss_score": 0.0002, "epss_percentile": 0.04617}, "CVE-2025-48072": {"epss_score": 0.00066, "epss_percentile": 0.20903}, "CVE-2025-48073": {"epss_score": 0.00044, "epss_percentile": 0.13501}, "CVE-2025-48074": {"epss_score": 0.00028, "epss_percentile": 0.07313}, "CVE-2025-48075": {"epss_score": 0.00163, "epss_percentile": 0.37819}, "CVE-2025-48076": {"epss_score": 0.00035, "epss_percentile": 0.09973}, "CVE-2025-48077": {"epss_score": 0.00021, "epss_percentile": 0.04762}, "CVE-2025-48078": {"epss_score": 0.00021, "epss_percentile": 0.04762}, "CVE-2025-48079": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-48080": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48081": {"epss_score": 0.00083, "epss_percentile": 0.24707}, "CVE-2025-48082": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-48083": {"epss_score": 0.00021, "epss_percentile": 0.04762}, "CVE-2025-48085": {"epss_score": 0.00021, "epss_percentile": 0.04762}, "CVE-2025-48086": {"epss_score": 0.00058, "epss_percentile": 0.18511}, "CVE-2025-48087": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-48088": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-48089": {"epss_score": 0.00044, "epss_percentile": 0.13452}, "CVE-2025-48090": {"epss_score": 0.00057, "epss_percentile": 0.17993}, "CVE-2025-48091": {"epss_score": 0.00039, "epss_percentile": 0.11446}, "CVE-2025-48092": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-48093": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-48095": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-48096": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2025-48097": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-48098": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-48099": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2025-48100": {"epss_score": 0.00085, "epss_percentile": 0.25037}, "CVE-2025-48101": {"epss_score": 0.0006, "epss_percentile": 0.19073}, "CVE-2025-48102": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-48103": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-48104": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48105": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-48106": {"epss_score": 0.00064, "epss_percentile": 0.20262}, "CVE-2025-48107": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-48108": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-48109": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48110": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-48111": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-48112": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-48113": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48114": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-48115": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-48116": {"epss_score": 0.00058, "epss_percentile": 0.18574}, "CVE-2025-48117": {"epss_score": 0.00039, "epss_percentile": 0.1161}, "CVE-2025-48118": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-48119": {"epss_score": 0.00044, "epss_percentile": 0.13416}, "CVE-2025-48120": {"epss_score": 0.00044, "epss_percentile": 0.13416}, "CVE-2025-48121": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48122": {"epss_score": 0.00039, "epss_percentile": 0.11665}, "CVE-2025-48123": {"epss_score": 0.00063, "epss_percentile": 0.19822}, "CVE-2025-48124": {"epss_score": 0.00076, "epss_percentile": 0.23211}, "CVE-2025-48125": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-48126": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-48127": {"epss_score": 0.00037, "epss_percentile": 0.10766}, "CVE-2025-48128": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-48129": {"epss_score": 0.00025, "epss_percentile": 0.0604}, "CVE-2025-48130": {"epss_score": 0.00076, "epss_percentile": 0.23211}, "CVE-2025-48131": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48132": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-48133": {"epss_score": 0.00067, "epss_percentile": 0.21056}, "CVE-2025-48134": {"epss_score": 0.00104, "epss_percentile": 0.2922}, "CVE-2025-48135": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-48136": {"epss_score": 0.00117, "epss_percentile": 0.31347}, "CVE-2025-48137": {"epss_score": 0.0003, "epss_percentile": 0.08307}, "CVE-2025-48138": {"epss_score": 0.0006, "epss_percentile": 0.19099}, "CVE-2025-48139": {"epss_score": 0.00039, "epss_percentile": 0.11464}, "CVE-2025-48140": {"epss_score": 0.00062, "epss_percentile": 0.19696}, "CVE-2025-48141": {"epss_score": 0.00039, "epss_percentile": 0.11665}, "CVE-2025-48142": {"epss_score": 0.00049, "epss_percentile": 0.15428}, "CVE-2025-48143": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-48144": {"epss_score": 0.00014, "epss_percentile": 0.02066}, "CVE-2025-48145": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-48146": {"epss_score": 0.00014, "epss_percentile": 0.02066}, "CVE-2025-48147": {"epss_score": 0.00058, "epss_percentile": 0.18411}, "CVE-2025-48148": {"epss_score": 0.00061, "epss_percentile": 0.19451}, "CVE-2025-48149": {"epss_score": 0.00108, "epss_percentile": 0.29873}, "CVE-2025-48150": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-48151": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-48152": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-48153": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-48154": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-48155": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-48156": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-48157": {"epss_score": 0.00108, "epss_percentile": 0.29873}, "CVE-2025-48158": {"epss_score": 0.00054, "epss_percentile": 0.17285}, "CVE-2025-48159": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-48160": {"epss_score": 0.00108, "epss_percentile": 0.29873}, "CVE-2025-48161": {"epss_score": 0.00032, "epss_percentile": 0.08798}, "CVE-2025-48162": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-48163": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-48164": {"epss_score": 0.00049, "epss_percentile": 0.15428}, "CVE-2025-48165": {"epss_score": 0.00049, "epss_percentile": 0.15428}, "CVE-2025-48166": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-48167": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-48168": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-48169": {"epss_score": 0.00092, "epss_percentile": 0.26415}, "CVE-2025-48170": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-48171": {"epss_score": 0.00108, "epss_percentile": 0.29873}, "CVE-2025-48172": {"epss_score": 0.00015, "epss_percentile": 0.02366}, "CVE-2025-48174": {"epss_score": 0.00062, "epss_percentile": 0.19647}, "CVE-2025-48175": {"epss_score": 0.00071, "epss_percentile": 0.22076}, "CVE-2025-48187": {"epss_score": 0.00062, "epss_percentile": 0.19679}, "CVE-2025-48188": {"epss_score": 0.00015, "epss_percentile": 0.02538}, "CVE-2025-48200": {"epss_score": 0.00602, "epss_percentile": 0.68865}, "CVE-2025-48201": {"epss_score": 0.0005, "epss_percentile": 0.15734}, "CVE-2025-48202": {"epss_score": 0.00042, "epss_percentile": 0.12833}, "CVE-2025-48203": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-48204": {"epss_score": 0.00196, "epss_percentile": 0.41776}, "CVE-2025-48205": {"epss_score": 0.0005, "epss_percentile": 0.15734}, "CVE-2025-48206": {"epss_score": 0.00025, "epss_percentile": 0.06363}, "CVE-2025-48207": {"epss_score": 0.0005, "epss_percentile": 0.15734}, "CVE-2025-48208": {"epss_score": 0.0007, "epss_percentile": 0.21691}, "CVE-2025-48219": {"epss_score": 0.00035, "epss_percentile": 0.10002}, "CVE-2025-48231": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-48232": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48233": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-48234": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48235": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48236": {"epss_score": 0.00058, "epss_percentile": 0.18305}, "CVE-2025-48237": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48238": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-48239": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48240": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48241": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-48242": {"epss_score": 0.00041, "epss_percentile": 0.12303}, "CVE-2025-48243": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-48244": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-48245": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-48246": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2025-48247": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-48248": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48249": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48250": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48251": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48252": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-48253": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-48254": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-48255": {"epss_score": 0.00017, "epss_percentile": 0.03402}, "CVE-2025-48256": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-48257": {"epss_score": 0.00053, "epss_percentile": 0.16991}, "CVE-2025-48258": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48259": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-48260": {"epss_score": 0.00035, "epss_percentile": 0.09875}, "CVE-2025-48261": {"epss_score": 0.00047, "epss_percentile": 0.1467}, "CVE-2025-48262": {"epss_score": 0.00052, "epss_percentile": 0.16503}, "CVE-2025-48263": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-48264": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-48265": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-48266": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48267": {"epss_score": 0.00062, "epss_percentile": 0.19774}, "CVE-2025-48268": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-48269": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48270": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-48271": {"epss_score": 0.00055, "epss_percentile": 0.17577}, "CVE-2025-48272": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-48273": {"epss_score": 0.00073, "epss_percentile": 0.22501}, "CVE-2025-48274": {"epss_score": 0.00029, "epss_percentile": 0.07607}, "CVE-2025-48275": {"epss_score": 0.00055, "epss_percentile": 0.17577}, "CVE-2025-48276": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48277": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-48278": {"epss_score": 0.00037, "epss_percentile": 0.10801}, "CVE-2025-48279": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-48280": {"epss_score": 0.00034, "epss_percentile": 0.09702}, "CVE-2025-48281": {"epss_score": 0.00039, "epss_percentile": 0.11665}, "CVE-2025-48282": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-48283": {"epss_score": 0.00037, "epss_percentile": 0.10964}, "CVE-2025-48284": {"epss_score": 0.00016, "epss_percentile": 0.03033}, "CVE-2025-48285": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-48286": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-48287": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-48288": {"epss_score": 0.0003, "epss_percentile": 0.08011}, "CVE-2025-48289": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-48290": {"epss_score": 0.00165, "epss_percentile": 0.38013}, "CVE-2025-48291": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-48292": {"epss_score": 0.00118, "epss_percentile": 0.31496}, "CVE-2025-48293": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-48294": {"epss_score": 0.00024, "epss_percentile": 0.05688}, "CVE-2025-48295": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-48296": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-48297": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-48298": {"epss_score": 0.00099, "epss_percentile": 0.2786}, "CVE-2025-48299": {"epss_score": 0.00032, "epss_percentile": 0.08798}, "CVE-2025-48300": {"epss_score": 0.00056, "epss_percentile": 0.17792}, "CVE-2025-48301": {"epss_score": 0.00032, "epss_percentile": 0.08798}, "CVE-2025-48302": {"epss_score": 0.0022, "epss_percentile": 0.44626}, "CVE-2025-48303": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-48304": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48305": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-48306": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48307": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48308": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48309": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48310": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-48311": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48312": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-48313": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-48314": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-48315": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-48316": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-48317": {"epss_score": 0.00072, "epss_percentile": 0.22274}, "CVE-2025-48318": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-48319": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-48320": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48321": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48322": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-48323": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-48324": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-48325": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48326": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-48327": {"epss_score": 0.00051, "epss_percentile": 0.16308}, "CVE-2025-48328": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-48329": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-48330": {"epss_score": 0.00112, "epss_percentile": 0.30427}, "CVE-2025-48331": {"epss_score": 0.00045, "epss_percentile": 0.13779}, "CVE-2025-48332": {"epss_score": 0.00099, "epss_percentile": 0.2786}, "CVE-2025-48333": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-48334": {"epss_score": 0.00037, "epss_percentile": 0.10971}, "CVE-2025-48335": {"epss_score": 0.00054, "epss_percentile": 0.17355}, "CVE-2025-48336": {"epss_score": 0.00097, "epss_percentile": 0.27478}, "CVE-2025-48337": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-48338": {"epss_score": 0.00064, "epss_percentile": 0.20212}, "CVE-2025-48339": {"epss_score": 0.00036, "epss_percentile": 0.10372}, "CVE-2025-48340": {"epss_score": 0.0003, "epss_percentile": 0.07989}, "CVE-2025-48341": {"epss_score": 0.00027, "epss_percentile": 0.07105}, "CVE-2025-48342": {"epss_score": 0.00016, "epss_percentile": 0.03033}, "CVE-2025-48343": {"epss_score": 0.0002, "epss_percentile": 0.04565}, "CVE-2025-48344": {"epss_score": 0.00016, "epss_percentile": 0.03033}, "CVE-2025-48345": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-48346": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-48347": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-48348": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-48349": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-48350": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-48351": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48352": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-48353": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48354": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-48355": {"epss_score": 0.0005, "epss_percentile": 0.15854}, "CVE-2025-48356": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-48357": {"epss_score": 0.00025, "epss_percentile": 0.06236}, "CVE-2025-48358": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-48359": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-48360": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-48361": {"epss_score": 0.0005, "epss_percentile": 0.15854}, "CVE-2025-48362": {"epss_score": 0.00029, "epss_percentile": 0.07668}, "CVE-2025-48363": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-48364": {"epss_score": 0.00046, "epss_percentile": 0.1415}, "CVE-2025-48365": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-48366": {"epss_score": 0.00041, "epss_percentile": 0.12272}, "CVE-2025-48367": {"epss_score": 0.00101, "epss_percentile": 0.28665}, "CVE-2025-48368": {"epss_score": 0.00027, "epss_percentile": 0.07082}, "CVE-2025-48369": {"epss_score": 0.00025, "epss_percentile": 0.06234}, "CVE-2025-48370": {"epss_score": 0.00036, "epss_percentile": 0.10548}, "CVE-2025-48371": {"epss_score": 0.00019, "epss_percentile": 0.04329}, "CVE-2025-48372": {"epss_score": 0.00056, "epss_percentile": 0.17685}, "CVE-2025-48373": {"epss_score": 0.00055, "epss_percentile": 0.17435}, "CVE-2025-48374": {"epss_score": 0.00025, "epss_percentile": 0.06213}, "CVE-2025-48375": {"epss_score": 0.00084, "epss_percentile": 0.24829}, "CVE-2025-48376": {"epss_score": 0.00014, "epss_percentile": 0.02119}, "CVE-2025-48377": {"epss_score": 0.00025, "epss_percentile": 0.06292}, "CVE-2025-48378": {"epss_score": 0.0001, "epss_percentile": 0.00857}, "CVE-2025-48379": {"epss_score": 0.00017, "epss_percentile": 0.03215}, "CVE-2025-48381": {"epss_score": 0.0004, "epss_percentile": 0.11948}, "CVE-2025-48382": {"epss_score": 0.00022, "epss_percentile": 0.04976}, "CVE-2025-48383": {"epss_score": 0.0005, "epss_percentile": 0.15692}, "CVE-2025-48384": {"epss_score": 0.0068, "epss_percentile": 0.7103}, "CVE-2025-48385": {"epss_score": 0.00025, "epss_percentile": 0.06117}, "CVE-2025-48386": {"epss_score": 0.00012, "epss_percentile": 0.01423}, "CVE-2025-48387": {"epss_score": 0.00132, "epss_percentile": 0.33531}, "CVE-2025-48388": {"epss_score": 0.00037, "epss_percentile": 0.10636}, "CVE-2025-48389": {"epss_score": 0.01593, "epss_percentile": 0.81227}, "CVE-2025-48390": {"epss_score": 0.00263, "epss_percentile": 0.49486}, "CVE-2025-48391": {"epss_score": 1e-05, "epss_percentile": 0.00014}, "CVE-2025-48392": {"epss_score": 0.00281, "epss_percentile": 0.51145}, "CVE-2025-48393": {"epss_score": 0.00025, "epss_percentile": 0.06138}, "CVE-2025-48394": {"epss_score": 0.00051, "epss_percentile": 0.16298}, "CVE-2025-48395": {"epss_score": 0.00083, "epss_percentile": 0.24603}, "CVE-2025-48396": {"epss_score": 0.00073, "epss_percentile": 0.22636}, "CVE-2025-48397": {"epss_score": 0.00042, "epss_percentile": 0.12675}, "CVE-2025-48413": {"epss_score": 0.00024, "epss_percentile": 0.05797}, "CVE-2025-48414": {"epss_score": 0.00042, "epss_percentile": 0.12765}, "CVE-2025-48415": {"epss_score": 0.00022, "epss_percentile": 0.05056}, "CVE-2025-48416": {"epss_score": 0.00059, "epss_percentile": 0.18716}, "CVE-2025-48417": {"epss_score": 0.00028, "epss_percentile": 0.07338}, "CVE-2025-48428": {"epss_score": 8e-05, "epss_percentile": 0.00489}, "CVE-2025-48429": {"epss_score": 0.00037, "epss_percentile": 0.10866}, "CVE-2025-48430": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-48432": {"epss_score": 0.00106, "epss_percentile": 0.29444}, "CVE-2025-48443": {"epss_score": 0.00018, "epss_percentile": 0.03898}, "CVE-2025-48444": {"epss_score": 0.00047, "epss_percentile": 0.146}, "CVE-2025-48445": {"epss_score": 0.00055, "epss_percentile": 0.17597}, "CVE-2025-48446": {"epss_score": 0.00055, "epss_percentile": 0.17597}, "CVE-2025-48447": {"epss_score": 0.00057, "epss_percentile": 0.18168}, "CVE-2025-48448": {"epss_score": 0.0004, "epss_percentile": 0.12146}, "CVE-2025-48459": {"epss_score": 0.00216, "epss_percentile": 0.44144}, "CVE-2025-48461": {"epss_score": 9e-05, "epss_percentile": 0.00729}, "CVE-2025-48462": {"epss_score": 0.00016, "epss_percentile": 0.02984}, "CVE-2025-48463": {"epss_score": 8e-05, "epss_percentile": 0.00513}, "CVE-2025-48464": {"epss_score": 0.00025, "epss_percentile": 0.06136}, "CVE-2025-48466": {"epss_score": 0.00068, "epss_percentile": 0.21201}, "CVE-2025-48467": {"epss_score": 0.00024, "epss_percentile": 0.05692}, "CVE-2025-48468": {"epss_score": 0.00019, "epss_percentile": 0.04405}, "CVE-2025-48469": {"epss_score": 0.00101, "epss_percentile": 0.28648}, "CVE-2025-48470": {"epss_score": 0.0002, "epss_percentile": 0.04446}, "CVE-2025-48471": {"epss_score": 0.00826, "epss_percentile": 0.73965}, "CVE-2025-48472": {"epss_score": 0.00049, "epss_percentile": 0.15567}, "CVE-2025-48473": {"epss_score": 0.0004, "epss_percentile": 0.11903}, "CVE-2025-48474": {"epss_score": 0.00047, "epss_percentile": 0.14601}, "CVE-2025-48475": {"epss_score": 0.00047, "epss_percentile": 0.14601}, "CVE-2025-48476": {"epss_score": 0.00029, "epss_percentile": 0.07594}, "CVE-2025-48477": {"epss_score": 0.0002, "epss_percentile": 0.04424}, "CVE-2025-48478": {"epss_score": 0.00023, "epss_percentile": 0.05482}, "CVE-2025-48479": {"epss_score": 0.00021, "epss_percentile": 0.04704}, "CVE-2025-48480": {"epss_score": 0.00021, "epss_percentile": 0.04704}, "CVE-2025-48481": {"epss_score": 0.00029, "epss_percentile": 0.07594}, "CVE-2025-48482": {"epss_score": 0.00017, "epss_percentile": 0.03104}, "CVE-2025-48483": {"epss_score": 0.00014, "epss_percentile": 0.01979}, "CVE-2025-48484": {"epss_score": 0.00027, "epss_percentile": 0.07082}, "CVE-2025-48485": {"epss_score": 0.00027, "epss_percentile": 0.07082}, "CVE-2025-48486": {"epss_score": 0.00027, "epss_percentile": 0.07082}, "CVE-2025-48487": {"epss_score": 0.00032, "epss_percentile": 0.09039}, "CVE-2025-48488": {"epss_score": 0.00027, "epss_percentile": 0.07082}, "CVE-2025-48489": {"epss_score": 0.00025, "epss_percentile": 0.06234}, "CVE-2025-48490": {"epss_score": 0.00088, "epss_percentile": 0.25778}, "CVE-2025-48491": {"epss_score": 0.00162, "epss_percentile": 0.37629}, "CVE-2025-48492": {"epss_score": 0.00796, "epss_percentile": 0.73483}, "CVE-2025-48493": {"epss_score": 0.00049, "epss_percentile": 0.15382}, "CVE-2025-48494": {"epss_score": 0.00019, "epss_percentile": 0.0406}, "CVE-2025-48495": {"epss_score": 0.00015, "epss_percentile": 0.02507}, "CVE-2025-48496": {"epss_score": 0.00012, "epss_percentile": 0.01305}, "CVE-2025-48497": {"epss_score": 0.00016, "epss_percentile": 0.02643}, "CVE-2025-48498": {"epss_score": 0.00151, "epss_percentile": 0.36335}, "CVE-2025-48499": {"epss_score": 0.00047, "epss_percentile": 0.14648}, "CVE-2025-48500": {"epss_score": 0.0002, "epss_percentile": 0.04517}, "CVE-2025-48501": {"epss_score": 0.00153, "epss_percentile": 0.36564}, "CVE-2025-48502": {"epss_score": 0.00019, "epss_percentile": 0.04172}, "CVE-2025-48507": {"epss_score": 0.00036, "epss_percentile": 0.10609}, "CVE-2025-48510": {"epss_score": 0.00017, "epss_percentile": 0.0313}, "CVE-2025-48511": {"epss_score": 0.00019, "epss_percentile": 0.04172}, "CVE-2025-48522": {"epss_score": 8e-05, "epss_percentile": 0.00547}, "CVE-2025-48523": {"epss_score": 6e-05, "epss_percentile": 0.00271}, "CVE-2025-48524": {"epss_score": 0.00011, "epss_percentile": 0.01026}, "CVE-2025-48525": {"epss_score": 0.00012, "epss_percentile": 0.01157}, "CVE-2025-48526": {"epss_score": 6e-05, "epss_percentile": 0.00266}, "CVE-2025-48527": {"epss_score": 6e-05, "epss_percentile": 0.00278}, "CVE-2025-48528": {"epss_score": 6e-05, "epss_percentile": 0.00266}, "CVE-2025-48529": {"epss_score": 5e-05, "epss_percentile": 0.00208}, "CVE-2025-48530": {"epss_score": 0.00118, "epss_percentile": 0.31392}, "CVE-2025-48531": {"epss_score": 8e-05, "epss_percentile": 0.00547}, "CVE-2025-48532": {"epss_score": 9e-05, "epss_percentile": 0.00648}, "CVE-2025-48533": {"epss_score": 4e-05, "epss_percentile": 0.00144}, "CVE-2025-48534": {"epss_score": 0.0008, "epss_percentile": 0.24029}, "CVE-2025-48535": {"epss_score": 0.00078, "epss_percentile": 0.23672}, "CVE-2025-48536": {"epss_score": 5e-05, "epss_percentile": 0.00203}, "CVE-2025-48537": {"epss_score": 0.00014, "epss_percentile": 0.02091}, "CVE-2025-48538": {"epss_score": 0.00012, "epss_percentile": 0.01329}, "CVE-2025-48539": {"epss_score": 0.00014, "epss_percentile": 0.01832}, "CVE-2025-48540": {"epss_score": 0.00013, "epss_percentile": 0.01565}, "CVE-2025-48541": {"epss_score": 0.00014, "epss_percentile": 0.02091}, "CVE-2025-48542": {"epss_score": 0.00013, "epss_percentile": 0.0155}, "CVE-2025-48543": {"epss_score": 0.00355, "epss_percentile": 0.57317}, "CVE-2025-48544": {"epss_score": 0.00011, "epss_percentile": 0.01061}, "CVE-2025-48545": {"epss_score": 8e-05, "epss_percentile": 0.00468}, "CVE-2025-48546": {"epss_score": 0.00012, "epss_percentile": 0.01148}, "CVE-2025-48547": {"epss_score": 9e-05, "epss_percentile": 0.00648}, "CVE-2025-48548": {"epss_score": 0.0001, "epss_percentile": 0.00876}, "CVE-2025-48549": {"epss_score": 0.00012, "epss_percentile": 0.0127}, "CVE-2025-48550": {"epss_score": 0.00014, "epss_percentile": 0.02013}, "CVE-2025-48551": {"epss_score": 8e-05, "epss_percentile": 0.00468}, "CVE-2025-48552": {"epss_score": 0.0001, "epss_percentile": 0.00764}, "CVE-2025-48553": {"epss_score": 0.0001, "epss_percentile": 0.00764}, "CVE-2025-48554": {"epss_score": 0.00016, "epss_percentile": 0.02867}, "CVE-2025-48555": {"epss_score": 5e-05, "epss_percentile": 0.00225}, "CVE-2025-48556": {"epss_score": 0.00014, "epss_percentile": 0.02091}, "CVE-2025-48558": {"epss_score": 9e-05, "epss_percentile": 0.00648}, "CVE-2025-48559": {"epss_score": 0.00015, "epss_percentile": 0.02217}, "CVE-2025-48560": {"epss_score": 8e-05, "epss_percentile": 0.00468}, "CVE-2025-48561": {"epss_score": 0.00015, "epss_percentile": 0.02124}, "CVE-2025-48562": {"epss_score": 8e-05, "epss_percentile": 0.00541}, "CVE-2025-48563": {"epss_score": 0.0001, "epss_percentile": 0.00764}, "CVE-2025-48564": {"epss_score": 0.00013, "epss_percentile": 0.01452}, "CVE-2025-48565": {"epss_score": 0.00014, "epss_percentile": 0.01872}, "CVE-2025-48566": {"epss_score": 0.00021, "epss_percentile": 0.04793}, "CVE-2025-48569": {"epss_score": 6e-05, "epss_percentile": 0.00251}, "CVE-2025-48572": {"epss_score": 0.00259, "epss_percentile": 0.49033}, "CVE-2025-48573": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-48575": {"epss_score": 3e-05, "epss_percentile": 0.00109}, "CVE-2025-48576": {"epss_score": 6e-05, "epss_percentile": 0.00251}, "CVE-2025-48580": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-48581": {"epss_score": 5e-05, "epss_percentile": 0.00199}, "CVE-2025-48583": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-48584": {"epss_score": 6e-05, "epss_percentile": 0.00251}, "CVE-2025-48586": {"epss_score": 5e-05, "epss_percentile": 0.00225}, "CVE-2025-48588": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-48589": {"epss_score": 5e-05, "epss_percentile": 0.00226}, "CVE-2025-48590": {"epss_score": 6e-05, "epss_percentile": 0.00251}, "CVE-2025-48591": {"epss_score": 6e-05, "epss_percentile": 0.00316}, "CVE-2025-48592": {"epss_score": 0.00047, "epss_percentile": 0.14691}, "CVE-2025-48593": {"epss_score": 0.0003, "epss_percentile": 0.08243}, "CVE-2025-48594": {"epss_score": 8e-05, "epss_percentile": 0.00496}, "CVE-2025-48596": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-48597": {"epss_score": 5e-05, "epss_percentile": 0.00225}, "CVE-2025-48598": {"epss_score": 8e-05, "epss_percentile": 0.00553}, "CVE-2025-48599": {"epss_score": 5e-05, "epss_percentile": 0.00225}, "CVE-2025-48600": {"epss_score": 5e-05, "epss_percentile": 0.0019}, "CVE-2025-48601": {"epss_score": 6e-05, "epss_percentile": 0.00319}, "CVE-2025-48603": {"epss_score": 6e-05, "epss_percentile": 0.00251}, "CVE-2025-48604": {"epss_score": 5e-05, "epss_percentile": 0.0019}, "CVE-2025-48606": {"epss_score": 8e-05, "epss_percentile": 0.00501}, "CVE-2025-48607": {"epss_score": 6e-05, "epss_percentile": 0.00251}, "CVE-2025-48608": {"epss_score": 5e-05, "epss_percentile": 0.0019}, "CVE-2025-48610": {"epss_score": 7e-05, "epss_percentile": 0.00372}, "CVE-2025-48612": {"epss_score": 9e-05, "epss_percentile": 0.00597}, "CVE-2025-48614": {"epss_score": 9e-05, "epss_percentile": 0.00595}, "CVE-2025-48615": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-48618": {"epss_score": 8e-05, "epss_percentile": 0.0053}, "CVE-2025-48620": {"epss_score": 8e-05, "epss_percentile": 0.00499}, "CVE-2025-48621": {"epss_score": 2e-05, "epss_percentile": 0.0006}, "CVE-2025-48622": {"epss_score": 0.0001, "epss_percentile": 0.00867}, "CVE-2025-48623": {"epss_score": 0.00012, "epss_percentile": 0.01157}, "CVE-2025-48624": {"epss_score": 9e-05, "epss_percentile": 0.00597}, "CVE-2025-48625": {"epss_score": 7e-05, "epss_percentile": 0.00396}, "CVE-2025-48626": {"epss_score": 0.00309, "epss_percentile": 0.53666}, "CVE-2025-48627": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-48628": {"epss_score": 5e-05, "epss_percentile": 0.00225}, "CVE-2025-48629": {"epss_score": 6e-05, "epss_percentile": 0.00263}, "CVE-2025-48631": {"epss_score": 0.00136, "epss_percentile": 0.34122}, "CVE-2025-48632": {"epss_score": 9e-05, "epss_percentile": 0.00597}, "CVE-2025-48633": {"epss_score": 0.00164, "epss_percentile": 0.37976}, "CVE-2025-48637": {"epss_score": 8e-05, "epss_percentile": 0.00499}, "CVE-2025-48638": {"epss_score": 0.00012, "epss_percentile": 0.01157}, "CVE-2025-48639": {"epss_score": 8e-05, "epss_percentile": 0.00503}, "CVE-2025-48695": {"epss_score": 0.00035, "epss_percentile": 0.09875}, "CVE-2025-48700": {"epss_score": 0.00024, "epss_percentile": 0.05973}, "CVE-2025-48701": {"epss_score": 0.00026, "epss_percentile": 0.06516}, "CVE-2025-48703": {"epss_score": 0.60904, "epss_percentile": 0.98226}, "CVE-2025-48704": {"epss_score": 0.00055, "epss_percentile": 0.17554}, "CVE-2025-48705": {"epss_score": 0.0008, "epss_percentile": 0.24024}, "CVE-2025-48706": {"epss_score": 0.00085, "epss_percentile": 0.2511}, "CVE-2025-48707": {"epss_score": 0.00072, "epss_percentile": 0.2238}, "CVE-2025-48708": {"epss_score": 5e-05, "epss_percentile": 0.00233}, "CVE-2025-48709": {"epss_score": 0.00012, "epss_percentile": 0.01322}, "CVE-2025-48710": {"epss_score": 0.00191, "epss_percentile": 0.41219}, "CVE-2025-48721": {"epss_score": 0.00116, "epss_percentile": 0.31165}, "CVE-2025-48726": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-48727": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-48728": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-48729": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-48730": {"epss_score": 0.00058, "epss_percentile": 0.18287}, "CVE-2025-48731": {"epss_score": 0.00034, "epss_percentile": 0.09781}, "CVE-2025-48732": {"epss_score": 0.00988, "epss_percentile": 0.76351}, "CVE-2025-48733": {"epss_score": 0.00084, "epss_percentile": 0.24866}, "CVE-2025-48734": {"epss_score": 0.00077, "epss_percentile": 0.23387}, "CVE-2025-48735": {"epss_score": 0.00035, "epss_percentile": 0.10073}, "CVE-2025-48738": {"epss_score": 0.00148, "epss_percentile": 0.35802}, "CVE-2025-48739": {"epss_score": 0.00157, "epss_percentile": 0.37053}, "CVE-2025-48740": {"epss_score": 0.00051, "epss_percentile": 0.16292}, "CVE-2025-48741": {"epss_score": 0.00052, "epss_percentile": 0.16591}, "CVE-2025-48742": {"epss_score": 0.0016, "epss_percentile": 0.37434}, "CVE-2025-48743": {"epss_score": 0.00041, "epss_percentile": 0.12274}, "CVE-2025-48744": {"epss_score": 0.00244, "epss_percentile": 0.47574}, "CVE-2025-48746": {"epss_score": 0.00051, "epss_percentile": 0.16048}, "CVE-2025-48747": {"epss_score": 0.00037, "epss_percentile": 0.10649}, "CVE-2025-48748": {"epss_score": 0.00067, "epss_percentile": 0.21155}, "CVE-2025-48749": {"epss_score": 0.00064, "epss_percentile": 0.20133}, "CVE-2025-48751": {"epss_score": 0.00013, "epss_percentile": 0.01549}, "CVE-2025-48752": {"epss_score": 0.00017, "epss_percentile": 0.03095}, "CVE-2025-48753": {"epss_score": 0.00012, "epss_percentile": 0.0125}, "CVE-2025-48754": {"epss_score": 0.00017, "epss_percentile": 0.03095}, "CVE-2025-48755": {"epss_score": 0.00015, "epss_percentile": 0.02502}, "CVE-2025-48756": {"epss_score": 0.00017, "epss_percentile": 0.03095}, "CVE-2025-48757": {"epss_score": 0.00047, "epss_percentile": 0.1471}, "CVE-2025-48768": {"epss_score": 0.00065, "epss_percentile": 0.20526}, "CVE-2025-48769": {"epss_score": 0.00063, "epss_percentile": 0.19877}, "CVE-2025-48780": {"epss_score": 0.0041, "epss_percentile": 0.608}, "CVE-2025-48781": {"epss_score": 0.00227, "epss_percentile": 0.45383}, "CVE-2025-48782": {"epss_score": 0.00227, "epss_percentile": 0.45383}, "CVE-2025-48783": {"epss_score": 0.00227, "epss_percentile": 0.45383}, "CVE-2025-48784": {"epss_score": 0.0022, "epss_percentile": 0.44583}, "CVE-2025-48795": {"epss_score": 0.00068, "epss_percentile": 0.21393}, "CVE-2025-48796": {"epss_score": 0.00014, "epss_percentile": 0.02088}, "CVE-2025-48797": {"epss_score": 0.00023, "epss_percentile": 0.05488}, "CVE-2025-48798": {"epss_score": 0.00023, "epss_percentile": 0.05488}, "CVE-2025-48799": {"epss_score": 0.00129, "epss_percentile": 0.33178}, "CVE-2025-48800": {"epss_score": 0.00077, "epss_percentile": 0.23308}, "CVE-2025-48802": {"epss_score": 0.00059, "epss_percentile": 0.18877}, "CVE-2025-48803": {"epss_score": 0.00033, "epss_percentile": 0.09424}, "CVE-2025-48804": {"epss_score": 0.0004, "epss_percentile": 0.11985}, "CVE-2025-48805": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-48806": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-48807": {"epss_score": 0.00046, "epss_percentile": 0.14186}, "CVE-2025-48808": {"epss_score": 0.00065, "epss_percentile": 0.20639}, "CVE-2025-48809": {"epss_score": 0.00048, "epss_percentile": 0.15005}, "CVE-2025-48810": {"epss_score": 0.00048, "epss_percentile": 0.15005}, "CVE-2025-48811": {"epss_score": 0.00033, "epss_percentile": 0.09424}, "CVE-2025-48812": {"epss_score": 0.00045, "epss_percentile": 0.13911}, "CVE-2025-48813": {"epss_score": 0.00024, "epss_percentile": 0.05839}, "CVE-2025-48814": {"epss_score": 0.00095, "epss_percentile": 0.27196}, "CVE-2025-48815": {"epss_score": 0.0015, "epss_percentile": 0.36094}, "CVE-2025-48816": {"epss_score": 0.00078, "epss_percentile": 0.23654}, "CVE-2025-48817": {"epss_score": 0.00047, "epss_percentile": 0.14634}, "CVE-2025-48818": {"epss_score": 0.0006, "epss_percentile": 0.1918}, "CVE-2025-48819": {"epss_score": 0.00149, "epss_percentile": 0.35943}, "CVE-2025-48820": {"epss_score": 0.00069, "epss_percentile": 0.21588}, "CVE-2025-48821": {"epss_score": 0.00185, "epss_percentile": 0.40483}, "CVE-2025-48822": {"epss_score": 0.00056, "epss_percentile": 0.17875}, "CVE-2025-48823": {"epss_score": 0.00026, "epss_percentile": 0.06721}, "CVE-2025-48824": {"epss_score": 0.00059, "epss_percentile": 0.18817}, "CVE-2025-48825": {"epss_score": 9e-05, "epss_percentile": 0.00685}, "CVE-2025-48826": {"epss_score": 0.00087, "epss_percentile": 0.25554}, "CVE-2025-48827": {"epss_score": 0.73845, "epss_percentile": 0.98774}, "CVE-2025-48828": {"epss_score": 0.73998, "epss_percentile": 0.98781}, "CVE-2025-48839": {"epss_score": 0.001, "epss_percentile": 0.28525}, "CVE-2025-48860": {"epss_score": 0.00056, "epss_percentile": 0.17929}, "CVE-2025-48861": {"epss_score": 0.0005, "epss_percentile": 0.15679}, "CVE-2025-48862": {"epss_score": 0.00014, "epss_percentile": 0.01901}, "CVE-2025-48865": {"epss_score": 0.00036, "epss_percentile": 0.10512}, "CVE-2025-48866": {"epss_score": 0.0031, "epss_percentile": 0.53744}, "CVE-2025-48867": {"epss_score": 0.0009, "epss_percentile": 0.26032}, "CVE-2025-48868": {"epss_score": 0.00643, "epss_percentile": 0.70063}, "CVE-2025-48869": {"epss_score": 0.00136, "epss_percentile": 0.34178}, "CVE-2025-48875": {"epss_score": 0.00033, "epss_percentile": 0.09342}, "CVE-2025-48877": {"epss_score": 0.00111, "epss_percentile": 0.30356}, "CVE-2025-48878": {"epss_score": 0.00036, "epss_percentile": 0.10294}, "CVE-2025-48879": {"epss_score": 0.00016, "epss_percentile": 0.02782}, "CVE-2025-48880": {"epss_score": 0.00052, "epss_percentile": 0.16338}, "CVE-2025-48881": {"epss_score": 0.00058, "epss_percentile": 0.186}, "CVE-2025-48882": {"epss_score": 0.00068, "epss_percentile": 0.21416}, "CVE-2025-48883": {"epss_score": 0.00053, "epss_percentile": 0.16867}, "CVE-2025-48884": {"epss_score": 0.00035, "epss_percentile": 0.10162}, "CVE-2025-48885": {"epss_score": 0.00028, "epss_percentile": 0.07213}, "CVE-2025-48886": {"epss_score": 0.00027, "epss_percentile": 0.07131}, "CVE-2025-48887": {"epss_score": 0.00119, "epss_percentile": 0.31604}, "CVE-2025-48888": {"epss_score": 0.00054, "epss_percentile": 0.17112}, "CVE-2025-48889": {"epss_score": 0.00384, "epss_percentile": 0.59135}, "CVE-2025-48890": {"epss_score": 0.00478, "epss_percentile": 0.64407}, "CVE-2025-48891": {"epss_score": 0.00075, "epss_percentile": 0.22989}, "CVE-2025-48902": {"epss_score": 8e-05, "epss_percentile": 0.00515}, "CVE-2025-48903": {"epss_score": 0.0001, "epss_percentile": 0.00831}, "CVE-2025-48904": {"epss_score": 7e-05, "epss_percentile": 0.00432}, "CVE-2025-48905": {"epss_score": 0.00031, "epss_percentile": 0.08616}, "CVE-2025-48906": {"epss_score": 0.00021, "epss_percentile": 0.04936}, "CVE-2025-48907": {"epss_score": 7e-05, "epss_percentile": 0.00379}, "CVE-2025-48908": {"epss_score": 8e-05, "epss_percentile": 0.00569}, "CVE-2025-48909": {"epss_score": 0.00016, "epss_percentile": 0.02642}, "CVE-2025-48910": {"epss_score": 0.00013, "epss_percentile": 0.01553}, "CVE-2025-48911": {"epss_score": 9e-05, "epss_percentile": 0.00668}, "CVE-2025-48912": {"epss_score": 0.00109, "epss_percentile": 0.29948}, "CVE-2025-48913": {"epss_score": 0.00104, "epss_percentile": 0.29134}, "CVE-2025-48914": {"epss_score": 0.00063, "epss_percentile": 0.19988}, "CVE-2025-48915": {"epss_score": 0.00063, "epss_percentile": 0.19988}, "CVE-2025-48916": {"epss_score": 0.00039, "epss_percentile": 0.11464}, "CVE-2025-48917": {"epss_score": 0.00039, "epss_percentile": 0.11456}, "CVE-2025-48918": {"epss_score": 0.0004, "epss_percentile": 0.11891}, "CVE-2025-48919": {"epss_score": 0.00039, "epss_percentile": 0.11456}, "CVE-2025-48920": {"epss_score": 0.00052, "epss_percentile": 0.16373}, "CVE-2025-48921": {"epss_score": 0.00019, "epss_percentile": 0.04199}, "CVE-2025-48922": {"epss_score": 0.00025, "epss_percentile": 0.06154}, "CVE-2025-48923": {"epss_score": 0.00025, "epss_percentile": 0.06154}, "CVE-2025-48924": {"epss_score": 0.00016, "epss_percentile": 0.02906}, "CVE-2025-48925": {"epss_score": 0.0004, "epss_percentile": 0.12017}, "CVE-2025-48926": {"epss_score": 0.00046, "epss_percentile": 0.14087}, "CVE-2025-48927": {"epss_score": 0.04675, "epss_percentile": 0.88992}, "CVE-2025-48928": {"epss_score": 0.04423, "epss_percentile": 0.88673}, "CVE-2025-48929": {"epss_score": 0.00033, "epss_percentile": 0.09413}, "CVE-2025-48930": {"epss_score": 0.00014, "epss_percentile": 0.01921}, "CVE-2025-48931": {"epss_score": 8e-05, "epss_percentile": 0.00476}, "CVE-2025-48934": {"epss_score": 0.00063, "epss_percentile": 0.20089}, "CVE-2025-48935": {"epss_score": 0.00073, "epss_percentile": 0.22536}, "CVE-2025-48936": {"epss_score": 0.00049, "epss_percentile": 0.15573}, "CVE-2025-48937": {"epss_score": 0.00047, "epss_percentile": 0.149}, "CVE-2025-48938": {"epss_score": 0.00078, "epss_percentile": 0.23785}, "CVE-2025-48939": {"epss_score": 0.0002, "epss_percentile": 0.04679}, "CVE-2025-48940": {"epss_score": 0.00077, "epss_percentile": 0.23539}, "CVE-2025-48941": {"epss_score": 0.00047, "epss_percentile": 0.14914}, "CVE-2025-48942": {"epss_score": 0.00041, "epss_percentile": 0.1246}, "CVE-2025-48943": {"epss_score": 0.00082, "epss_percentile": 0.2444}, "CVE-2025-48944": {"epss_score": 0.00095, "epss_percentile": 0.27115}, "CVE-2025-48945": {"epss_score": 0.00074, "epss_percentile": 0.22882}, "CVE-2025-48946": {"epss_score": 0.0002, "epss_percentile": 0.04541}, "CVE-2025-48947": {"epss_score": 0.00065, "epss_percentile": 0.20596}, "CVE-2025-48948": {"epss_score": 0.00045, "epss_percentile": 0.13792}, "CVE-2025-48949": {"epss_score": 0.00074, "epss_percentile": 0.22739}, "CVE-2025-48950": {"epss_score": 0.0012, "epss_percentile": 0.31751}, "CVE-2025-48951": {"epss_score": 0.00064, "epss_percentile": 0.20134}, "CVE-2025-48952": {"epss_score": 0.00183, "epss_percentile": 0.4036}, "CVE-2025-48953": {"epss_score": 0.00039, "epss_percentile": 0.11708}, "CVE-2025-48954": {"epss_score": 0.15576, "epss_percentile": 0.94462}, "CVE-2025-48955": {"epss_score": 0.0002, "epss_percentile": 0.04687}, "CVE-2025-48956": {"epss_score": 0.00432, "epss_percentile": 0.62129}, "CVE-2025-48957": {"epss_score": 0.00192, "epss_percentile": 0.41374}, "CVE-2025-48958": {"epss_score": 0.00049, "epss_percentile": 0.15363}, "CVE-2025-48959": {"epss_score": 0.00013, "epss_percentile": 0.01497}, "CVE-2025-48960": {"epss_score": 6e-05, "epss_percentile": 0.00269}, "CVE-2025-48961": {"epss_score": 0.00013, "epss_percentile": 0.01497}, "CVE-2025-48962": {"epss_score": 0.00028, "epss_percentile": 0.0729}, "CVE-2025-48963": {"epss_score": 0.00027, "epss_percentile": 0.0688}, "CVE-2025-48964": {"epss_score": 0.0012, "epss_percentile": 0.31793}, "CVE-2025-48965": {"epss_score": 0.0003, "epss_percentile": 0.0798}, "CVE-2025-48976": {"epss_score": 0.00168, "epss_percentile": 0.38461}, "CVE-2025-48978": {"epss_score": 0.00878, "epss_percentile": 0.7482}, "CVE-2025-48979": {"epss_score": 0.00806, "epss_percentile": 0.73648}, "CVE-2025-48980": {"epss_score": 0.00052, "epss_percentile": 0.16478}, "CVE-2025-48981": {"epss_score": 0.00015, "epss_percentile": 0.02364}, "CVE-2025-48982": {"epss_score": 0.00011, "epss_percentile": 0.01014}, "CVE-2025-48983": {"epss_score": 0.00282, "epss_percentile": 0.51268}, "CVE-2025-48984": {"epss_score": 0.00342, "epss_percentile": 0.56398}, "CVE-2025-48985": {"epss_score": 0.0007, "epss_percentile": 0.21881}, "CVE-2025-48986": {"epss_score": 0.00018, "epss_percentile": 0.03752}, "CVE-2025-48987": {"epss_score": 0.00026, "epss_percentile": 0.06622}, "CVE-2025-48988": {"epss_score": 0.00124, "epss_percentile": 0.32447}, "CVE-2025-48989": {"epss_score": 0.00248, "epss_percentile": 0.48}, "CVE-2025-48990": {"epss_score": 0.00022, "epss_percentile": 0.05058}, "CVE-2025-48991": {"epss_score": 0.00017, "epss_percentile": 0.03229}, "CVE-2025-48992": {"epss_score": 0.0003, "epss_percentile": 0.08289}, "CVE-2025-48993": {"epss_score": 0.00024, "epss_percentile": 0.05667}, "CVE-2025-48994": {"epss_score": 0.00045, "epss_percentile": 0.14001}, "CVE-2025-48995": {"epss_score": 0.00047, "epss_percentile": 0.14596}, "CVE-2025-48996": {"epss_score": 0.00057, "epss_percentile": 0.18018}, "CVE-2025-48997": {"epss_score": 0.0007, "epss_percentile": 0.21699}, "CVE-2025-48998": {"epss_score": 0.00086, "epss_percentile": 0.25319}, "CVE-2025-48999": {"epss_score": 0.00045, "epss_percentile": 0.13903}, "CVE-2025-49000": {"epss_score": 0.00037, "epss_percentile": 0.10784}, "CVE-2025-49001": {"epss_score": 0.00086, "epss_percentile": 0.25339}, "CVE-2025-49002": {"epss_score": 0.00096, "epss_percentile": 0.27247}, "CVE-2025-49003": {"epss_score": 0.00355, "epss_percentile": 0.57279}, "CVE-2025-49004": {"epss_score": 0.0036, "epss_percentile": 0.5769}, "CVE-2025-49005": {"epss_score": 0.00061, "epss_percentile": 0.1941}, "CVE-2025-49006": {"epss_score": 0.00112, "epss_percentile": 0.30571}, "CVE-2025-49007": {"epss_score": 0.00159, "epss_percentile": 0.37365}, "CVE-2025-49008": {"epss_score": 0.00092, "epss_percentile": 0.26601}, "CVE-2025-49009": {"epss_score": 0.0002, "epss_percentile": 0.04687}, "CVE-2025-49011": {"epss_score": 0.00029, "epss_percentile": 0.07838}, "CVE-2025-49012": {"epss_score": 0.00073, "epss_percentile": 0.22585}, "CVE-2025-49013": {"epss_score": 0.0026, "epss_percentile": 0.4919}, "CVE-2025-49014": {"epss_score": 0.0006, "epss_percentile": 0.19177}, "CVE-2025-49015": {"epss_score": 0.00031, "epss_percentile": 0.08512}, "CVE-2025-49028": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-49029": {"epss_score": 0.0021, "epss_percentile": 0.43591}, "CVE-2025-49031": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-49032": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-49033": {"epss_score": 0.0003, "epss_percentile": 0.08224}, "CVE-2025-49034": {"epss_score": 0.00032, "epss_percentile": 0.08798}, "CVE-2025-49035": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49036": {"epss_score": 0.00205, "epss_percentile": 0.42704}, "CVE-2025-49037": {"epss_score": 0.00055, "epss_percentile": 0.17422}, "CVE-2025-49038": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-49039": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49040": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-49041": {"epss_score": 0.0003, "epss_percentile": 0.08267}, "CVE-2025-49042": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-49044": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-49047": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49048": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49051": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49052": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-49053": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49054": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-49056": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-49057": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-49058": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-49059": {"epss_score": 0.00058, "epss_percentile": 0.18292}, "CVE-2025-49060": {"epss_score": 0.00064, "epss_percentile": 0.20262}, "CVE-2025-49061": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49062": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-49063": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-49064": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-49065": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-49067": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49068": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49069": {"epss_score": 0.00015, "epss_percentile": 0.02362}, "CVE-2025-49070": {"epss_score": 0.00109, "epss_percentile": 0.2997}, "CVE-2025-49071": {"epss_score": 0.00061, "epss_percentile": 0.19431}, "CVE-2025-49072": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-49073": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-49074": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49075": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49076": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49077": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49080": {"epss_score": 0.00113, "epss_percentile": 0.30704}, "CVE-2025-49081": {"epss_score": 0.00083, "epss_percentile": 0.24751}, "CVE-2025-49082": {"epss_score": 0.00031, "epss_percentile": 0.08394}, "CVE-2025-49083": {"epss_score": 0.00378, "epss_percentile": 0.5878}, "CVE-2025-49084": {"epss_score": 0.0005, "epss_percentile": 0.15955}, "CVE-2025-49087": {"epss_score": 0.00042, "epss_percentile": 0.12752}, "CVE-2025-49088": {"epss_score": 0.00139, "epss_percentile": 0.3459}, "CVE-2025-49089": {"epss_score": 0.00057, "epss_percentile": 0.18098}, "CVE-2025-49090": {"epss_score": 0.0003, "epss_percentile": 0.08067}, "CVE-2025-49091": {"epss_score": 0.00164, "epss_percentile": 0.37982}, "CVE-2025-49112": {"epss_score": 0.00016, "epss_percentile": 0.02891}, "CVE-2025-49113": {"epss_score": 0.91835, "epss_percentile": 0.99671}, "CVE-2025-49124": {"epss_score": 0.00025, "epss_percentile": 0.06347}, "CVE-2025-49125": {"epss_score": 0.00091, "epss_percentile": 0.26195}, "CVE-2025-49126": {"epss_score": 0.00035, "epss_percentile": 0.10007}, "CVE-2025-49127": {"epss_score": 0.00498, "epss_percentile": 0.65239}, "CVE-2025-49128": {"epss_score": 4e-05, "epss_percentile": 0.0014}, "CVE-2025-49130": {"epss_score": 0.00063, "epss_percentile": 0.20101}, "CVE-2025-49131": {"epss_score": 0.00149, "epss_percentile": 0.36045}, "CVE-2025-49132": {"epss_score": 0.35395, "epss_percentile": 0.96905}, "CVE-2025-49133": {"epss_score": 0.00026, "epss_percentile": 0.06409}, "CVE-2025-49134": {"epss_score": 0.00042, "epss_percentile": 0.12583}, "CVE-2025-49135": {"epss_score": 0.0004, "epss_percentile": 0.12061}, "CVE-2025-49136": {"epss_score": 0.35141, "epss_percentile": 0.9689}, "CVE-2025-49137": {"epss_score": 0.00043, "epss_percentile": 0.12975}, "CVE-2025-49138": {"epss_score": 0.00074, "epss_percentile": 0.22727}, "CVE-2025-49139": {"epss_score": 0.00054, "epss_percentile": 0.17319}, "CVE-2025-49140": {"epss_score": 0.00092, "epss_percentile": 0.26579}, "CVE-2025-49141": {"epss_score": 0.00635, "epss_percentile": 0.69826}, "CVE-2025-49142": {"epss_score": 0.00034, "epss_percentile": 0.09475}, "CVE-2025-49143": {"epss_score": 0.00068, "epss_percentile": 0.21331}, "CVE-2025-49144": {"epss_score": 0.0001, "epss_percentile": 0.00854}, "CVE-2025-49145": {"epss_score": 0.00051, "epss_percentile": 0.16128}, "CVE-2025-49146": {"epss_score": 0.00015, "epss_percentile": 0.02187}, "CVE-2025-49147": {"epss_score": 0.00029, "epss_percentile": 0.07951}, "CVE-2025-49148": {"epss_score": 0.00015, "epss_percentile": 0.02191}, "CVE-2025-49149": {"epss_score": 0.00034, "epss_percentile": 0.09777}, "CVE-2025-49150": {"epss_score": 0.00045, "epss_percentile": 0.13969}, "CVE-2025-49151": {"epss_score": 0.00328, "epss_percentile": 0.55273}, "CVE-2025-49152": {"epss_score": 0.00058, "epss_percentile": 0.18613}, "CVE-2025-49153": {"epss_score": 0.00778, "epss_percentile": 0.73133}, "CVE-2025-49154": {"epss_score": 0.00013, "epss_percentile": 0.01561}, "CVE-2025-49155": {"epss_score": 0.00057, "epss_percentile": 0.17985}, "CVE-2025-49156": {"epss_score": 0.00021, "epss_percentile": 0.04867}, "CVE-2025-49157": {"epss_score": 0.00038, "epss_percentile": 0.11209}, "CVE-2025-49158": {"epss_score": 0.00012, "epss_percentile": 0.01284}, "CVE-2025-49162": {"epss_score": 0.00022, "epss_percentile": 0.04965}, "CVE-2025-49163": {"epss_score": 0.00019, "epss_percentile": 0.04322}, "CVE-2025-49164": {"epss_score": 0.00018, "epss_percentile": 0.03542}, "CVE-2025-49175": {"epss_score": 0.00041, "epss_percentile": 0.12335}, "CVE-2025-49176": {"epss_score": 0.00041, "epss_percentile": 0.12335}, "CVE-2025-49177": {"epss_score": 0.00019, "epss_percentile": 0.04268}, "CVE-2025-49178": {"epss_score": 0.00062, "epss_percentile": 0.19619}, "CVE-2025-49179": {"epss_score": 0.00028, "epss_percentile": 0.07574}, "CVE-2025-49180": {"epss_score": 0.00028, "epss_percentile": 0.07574}, "CVE-2025-49181": {"epss_score": 0.00218, "epss_percentile": 0.44413}, "CVE-2025-49182": {"epss_score": 0.00063, "epss_percentile": 0.19957}, "CVE-2025-49183": {"epss_score": 0.00034, "epss_percentile": 0.09456}, "CVE-2025-49184": {"epss_score": 0.00063, "epss_percentile": 0.19957}, "CVE-2025-49185": {"epss_score": 0.00048, "epss_percentile": 0.15163}, "CVE-2025-49186": {"epss_score": 0.00083, "epss_percentile": 0.24813}, "CVE-2025-49187": {"epss_score": 0.00061, "epss_percentile": 0.19482}, "CVE-2025-49188": {"epss_score": 0.00061, "epss_percentile": 0.19482}, "CVE-2025-49189": {"epss_score": 0.00063, "epss_percentile": 0.19883}, "CVE-2025-49190": {"epss_score": 0.00056, "epss_percentile": 0.17778}, "CVE-2025-49191": {"epss_score": 0.00036, "epss_percentile": 0.10339}, "CVE-2025-49192": {"epss_score": 0.00045, "epss_percentile": 0.13708}, "CVE-2025-49193": {"epss_score": 0.00045, "epss_percentile": 0.13985}, "CVE-2025-49194": {"epss_score": 0.00062, "epss_percentile": 0.19683}, "CVE-2025-49195": {"epss_score": 0.00083, "epss_percentile": 0.24813}, "CVE-2025-49196": {"epss_score": 0.00025, "epss_percentile": 0.06336}, "CVE-2025-49197": {"epss_score": 0.00033, "epss_percentile": 0.09369}, "CVE-2025-49198": {"epss_score": 0.00046, "epss_percentile": 0.14198}, "CVE-2025-49199": {"epss_score": 0.00047, "epss_percentile": 0.14858}, "CVE-2025-49200": {"epss_score": 0.00063, "epss_percentile": 0.19816}, "CVE-2025-49201": {"epss_score": 0.00084, "epss_percentile": 0.24992}, "CVE-2025-49211": {"epss_score": 0.00014, "epss_percentile": 0.02087}, "CVE-2025-49212": {"epss_score": 0.02494, "epss_percentile": 0.84904}, "CVE-2025-49213": {"epss_score": 0.02494, "epss_percentile": 0.84904}, "CVE-2025-49214": {"epss_score": 0.01512, "epss_percentile": 0.80782}, "CVE-2025-49215": {"epss_score": 0.00035, "epss_percentile": 0.10042}, "CVE-2025-49216": {"epss_score": 0.00075, "epss_percentile": 0.22985}, "CVE-2025-49217": {"epss_score": 0.01382, "epss_percentile": 0.7989}, "CVE-2025-49218": {"epss_score": 0.00014, "epss_percentile": 0.02087}, "CVE-2025-49219": {"epss_score": 0.03738, "epss_percentile": 0.87652}, "CVE-2025-49220": {"epss_score": 0.04047, "epss_percentile": 0.88174}, "CVE-2025-49221": {"epss_score": 0.00046, "epss_percentile": 0.14114}, "CVE-2025-49222": {"epss_score": 0.00054, "epss_percentile": 0.17331}, "CVE-2025-49223": {"epss_score": 0.00257, "epss_percentile": 0.48924}, "CVE-2025-49234": {"epss_score": 0.00052, "epss_percentile": 0.16552}, "CVE-2025-49235": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49236": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-49237": {"epss_score": 0.00018, "epss_percentile": 0.03629}, "CVE-2025-49238": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49239": {"epss_score": 0.00017, "epss_percentile": 0.03358}, "CVE-2025-49240": {"epss_score": 0.00036, "epss_percentile": 0.10516}, "CVE-2025-49241": {"epss_score": 0.00041, "epss_percentile": 0.12279}, "CVE-2025-49242": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49243": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49244": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49245": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-49246": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-49247": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-49248": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-49250": {"epss_score": 0.00033, "epss_percentile": 0.09425}, "CVE-2025-49251": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49252": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49253": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49254": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49255": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49256": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49257": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49258": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49259": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49260": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49261": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49262": {"epss_score": 0.00026, "epss_percentile": 0.06617}, "CVE-2025-49263": {"epss_score": 0.00036, "epss_percentile": 0.1031}, "CVE-2025-49264": {"epss_score": 0.00204, "epss_percentile": 0.42591}, "CVE-2025-49265": {"epss_score": 0.00048, "epss_percentile": 0.15146}, "CVE-2025-49266": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-49267": {"epss_score": 0.00057, "epss_percentile": 0.18148}, "CVE-2025-49268": {"epss_score": 0.00041, "epss_percentile": 0.12279}, "CVE-2025-49269": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49270": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-49271": {"epss_score": 0.00204, "epss_percentile": 0.42591}, "CVE-2025-49272": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-49273": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49274": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-49275": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-49276": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-49277": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-49278": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-49279": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-49280": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-49281": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-49282": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-49283": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49284": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49285": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49286": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49287": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-49288": {"epss_score": 0.00036, "epss_percentile": 0.10516}, "CVE-2025-49289": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-49290": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-49291": {"epss_score": 0.00018, "epss_percentile": 0.03852}, "CVE-2025-49292": {"epss_score": 0.00047, "epss_percentile": 0.1488}, "CVE-2025-49293": {"epss_score": 0.00038, "epss_percentile": 0.11295}, "CVE-2025-49294": {"epss_score": 0.0004, "epss_percentile": 0.11971}, "CVE-2025-49295": {"epss_score": 0.00043, "epss_percentile": 0.13078}, "CVE-2025-49296": {"epss_score": 0.00043, "epss_percentile": 0.13078}, "CVE-2025-49297": {"epss_score": 0.00043, "epss_percentile": 0.13078}, "CVE-2025-49298": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49299": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49300": {"epss_score": 0.00033, "epss_percentile": 0.09308}, "CVE-2025-49301": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49302": {"epss_score": 0.00055, "epss_percentile": 0.17651}, "CVE-2025-49303": {"epss_score": 0.00046, "epss_percentile": 0.14079}, "CVE-2025-49304": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49305": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49306": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49307": {"epss_score": 0.00123, "epss_percentile": 0.32243}, "CVE-2025-49308": {"epss_score": 0.00123, "epss_percentile": 0.32243}, "CVE-2025-49309": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49310": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49311": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49312": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-49313": {"epss_score": 0.00123, "epss_percentile": 0.32243}, "CVE-2025-49314": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49315": {"epss_score": 0.00036, "epss_percentile": 0.1031}, "CVE-2025-49316": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-49317": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49318": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-49319": {"epss_score": 0.00054, "epss_percentile": 0.17191}, "CVE-2025-49320": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-49321": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-49322": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-49323": {"epss_score": 0.00039, "epss_percentile": 0.11553}, "CVE-2025-49324": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-49325": {"epss_score": 0.00031, "epss_percentile": 0.08392}, "CVE-2025-49326": {"epss_score": 0.00036, "epss_percentile": 0.1031}, "CVE-2025-49327": {"epss_score": 0.00036, "epss_percentile": 0.1031}, "CVE-2025-49328": {"epss_score": 0.00036, "epss_percentile": 0.1031}, "CVE-2025-49329": {"epss_score": 0.00052, "epss_percentile": 0.16555}, "CVE-2025-49330": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-49331": {"epss_score": 0.00109, "epss_percentile": 0.3004}, "CVE-2025-49332": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49333": {"epss_score": 0.00029, "epss_percentile": 0.07625}, "CVE-2025-49334": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-49335": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2025-49337": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-49338": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-49339": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-49340": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2025-49341": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-49342": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-49343": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-49344": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-49345": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-49346": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-49347": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-49348": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-49349": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-49350": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-49351": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-49352": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-49353": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-49354": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-49355": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-49356": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-49357": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-49358": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-49359": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-49360": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-49361": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-49362": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-49363": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-49364": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-49365": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-49366": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-49367": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-49368": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-49369": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-49370": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-49371": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-49372": {"epss_score": 0.00068, "epss_percentile": 0.21388}, "CVE-2025-49373": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2025-49374": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-49376": {"epss_score": 0.00047, "epss_percentile": 0.14844}, "CVE-2025-49377": {"epss_score": 0.00047, "epss_percentile": 0.14844}, "CVE-2025-49378": {"epss_score": 0.00045, "epss_percentile": 0.14016}, "CVE-2025-49379": {"epss_score": 0.00047, "epss_percentile": 0.14879}, "CVE-2025-49380": {"epss_score": 0.00062, "epss_percentile": 0.19642}, "CVE-2025-49381": {"epss_score": 0.00034, "epss_percentile": 0.09617}, "CVE-2025-49382": {"epss_score": 0.00034, "epss_percentile": 0.09617}, "CVE-2025-49383": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-49384": {"epss_score": 0.00024, "epss_percentile": 0.05991}, "CVE-2025-49385": {"epss_score": 0.00041, "epss_percentile": 0.12376}, "CVE-2025-49386": {"epss_score": 0.00058, "epss_percentile": 0.18511}, "CVE-2025-49387": {"epss_score": 0.00083, "epss_percentile": 0.24616}, "CVE-2025-49388": {"epss_score": 0.0008, "epss_percentile": 0.24141}, "CVE-2025-49389": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49390": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-49391": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-49392": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49393": {"epss_score": 0.00058, "epss_percentile": 0.18511}, "CVE-2025-49394": {"epss_score": 0.0005, "epss_percentile": 0.15884}, "CVE-2025-49395": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49396": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-49397": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49398": {"epss_score": 0.00034, "epss_percentile": 0.09547}, "CVE-2025-49399": {"epss_score": 0.00034, "epss_percentile": 0.09617}, "CVE-2025-49400": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49401": {"epss_score": 0.00098, "epss_percentile": 0.27674}, "CVE-2025-49402": {"epss_score": 0.00051, "epss_percentile": 0.1629}, "CVE-2025-49404": {"epss_score": 0.00057, "epss_percentile": 0.18148}, "CVE-2025-49405": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-49406": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-49407": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-49408": {"epss_score": 0.00052, "epss_percentile": 0.16346}, "CVE-2025-49409": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49410": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49411": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49412": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49413": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49414": {"epss_score": 0.00061, "epss_percentile": 0.19431}, "CVE-2025-49415": {"epss_score": 0.00058, "epss_percentile": 0.18482}, "CVE-2025-49416": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49417": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-49418": {"epss_score": 0.00036, "epss_percentile": 0.10372}, "CVE-2025-49419": {"epss_score": 0.00043, "epss_percentile": 0.13169}, "CVE-2025-49420": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49421": {"epss_score": 0.00036, "epss_percentile": 0.1031}, "CVE-2025-49422": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49423": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-49424": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49425": {"epss_score": 0.00016, "epss_percentile": 0.03021}, "CVE-2025-49426": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-49427": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49428": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49429": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49430": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2025-49431": {"epss_score": 0.00054, "epss_percentile": 0.17191}, "CVE-2025-49432": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-49433": {"epss_score": 0.00025, "epss_percentile": 0.06331}, "CVE-2025-49434": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49435": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49436": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49437": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49438": {"epss_score": 0.00105, "epss_percentile": 0.2939}, "CVE-2025-49439": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49440": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49441": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-49442": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49443": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49444": {"epss_score": 0.00061, "epss_percentile": 0.19431}, "CVE-2025-49445": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49446": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49447": {"epss_score": 0.00061, "epss_percentile": 0.19431}, "CVE-2025-49448": {"epss_score": 0.00058, "epss_percentile": 0.18482}, "CVE-2025-49449": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49450": {"epss_score": 0.00031, "epss_percentile": 0.08528}, "CVE-2025-49451": {"epss_score": 0.00067, "epss_percentile": 0.2118}, "CVE-2025-49452": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-49453": {"epss_score": 0.00016, "epss_percentile": 0.03021}, "CVE-2025-49454": {"epss_score": 0.00124, "epss_percentile": 0.32409}, "CVE-2025-49455": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-49456": {"epss_score": 0.00014, "epss_percentile": 0.01745}, "CVE-2025-49457": {"epss_score": 0.00066, "epss_percentile": 0.20759}, "CVE-2025-49458": {"epss_score": 0.00063, "epss_percentile": 0.20078}, "CVE-2025-49459": {"epss_score": 0.00018, "epss_percentile": 0.03676}, "CVE-2025-49460": {"epss_score": 0.00052, "epss_percentile": 0.16394}, "CVE-2025-49461": {"epss_score": 0.00062, "epss_percentile": 0.1961}, "CVE-2025-49462": {"epss_score": 0.00014, "epss_percentile": 0.01882}, "CVE-2025-49463": {"epss_score": 0.00039, "epss_percentile": 0.11528}, "CVE-2025-49464": {"epss_score": 0.00073, "epss_percentile": 0.22563}, "CVE-2025-49466": {"epss_score": 0.0029, "epss_percentile": 0.52124}, "CVE-2025-49467": {"epss_score": 0.00038, "epss_percentile": 0.11132}, "CVE-2025-49468": {"epss_score": 0.00121, "epss_percentile": 0.3183}, "CVE-2025-49480": {"epss_score": 0.00061, "epss_percentile": 0.19371}, "CVE-2025-49481": {"epss_score": 0.00055, "epss_percentile": 0.17644}, "CVE-2025-49482": {"epss_score": 0.00053, "epss_percentile": 0.16686}, "CVE-2025-49483": {"epss_score": 0.00053, "epss_percentile": 0.16686}, "CVE-2025-49484": {"epss_score": 0.00455, "epss_percentile": 0.63309}, "CVE-2025-49485": {"epss_score": 0.00032, "epss_percentile": 0.09012}, "CVE-2025-49486": {"epss_score": 0.0005, "epss_percentile": 0.15858}, "CVE-2025-49487": {"epss_score": 0.00035, "epss_percentile": 0.1016}, "CVE-2025-49488": {"epss_score": 0.00055, "epss_percentile": 0.17644}, "CVE-2025-49489": {"epss_score": 0.00055, "epss_percentile": 0.17644}, "CVE-2025-49490": {"epss_score": 0.00055, "epss_percentile": 0.17644}, "CVE-2025-49491": {"epss_score": 0.00055, "epss_percentile": 0.17644}, "CVE-2025-49492": {"epss_score": 0.00061, "epss_percentile": 0.19371}, "CVE-2025-49493": {"epss_score": 0.0263, "epss_percentile": 0.85278}, "CVE-2025-49494": {"epss_score": 0.00063, "epss_percentile": 0.19821}, "CVE-2025-49495": {"epss_score": 0.00013, "epss_percentile": 0.01603}, "CVE-2025-49507": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-49508": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49509": {"epss_score": 0.00041, "epss_percentile": 0.12209}, "CVE-2025-49510": {"epss_score": 0.00016, "epss_percentile": 0.02713}, "CVE-2025-49511": {"epss_score": 0.00018, "epss_percentile": 0.03629}, "CVE-2025-49520": {"epss_score": 0.00093, "epss_percentile": 0.26745}, "CVE-2025-49521": {"epss_score": 0.00093, "epss_percentile": 0.26745}, "CVE-2025-49524": {"epss_score": 0.0002, "epss_percentile": 0.04436}, "CVE-2025-49525": {"epss_score": 0.00023, "epss_percentile": 0.05395}, "CVE-2025-49526": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-49527": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-49528": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-49529": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-49530": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-49531": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-49532": {"epss_score": 0.00027, "epss_percentile": 0.06998}, "CVE-2025-49533": {"epss_score": 0.22146, "epss_percentile": 0.95601}, "CVE-2025-49534": {"epss_score": 0.00025, "epss_percentile": 0.06355}, "CVE-2025-49535": {"epss_score": 0.00038, "epss_percentile": 0.11129}, "CVE-2025-49536": {"epss_score": 0.00039, "epss_percentile": 0.1154}, "CVE-2025-49537": {"epss_score": 0.00069, "epss_percentile": 0.21489}, "CVE-2025-49538": {"epss_score": 0.00097, "epss_percentile": 0.2756}, "CVE-2025-49539": {"epss_score": 0.00034, "epss_percentile": 0.09785}, "CVE-2025-49540": {"epss_score": 0.0003, "epss_percentile": 0.08062}, "CVE-2025-49541": {"epss_score": 0.0003, "epss_percentile": 0.08062}, "CVE-2025-49542": {"epss_score": 0.00083, "epss_percentile": 0.24604}, "CVE-2025-49543": {"epss_score": 0.0003, "epss_percentile": 0.08062}, "CVE-2025-49544": {"epss_score": 0.00076, "epss_percentile": 0.23156}, "CVE-2025-49545": {"epss_score": 0.00029, "epss_percentile": 0.07972}, "CVE-2025-49546": {"epss_score": 0.00033, "epss_percentile": 0.09247}, "CVE-2025-49547": {"epss_score": 0.00025, "epss_percentile": 0.06355}, "CVE-2025-49549": {"epss_score": 0.00072, "epss_percentile": 0.22245}, "CVE-2025-49550": {"epss_score": 0.00065, "epss_percentile": 0.20584}, "CVE-2025-49551": {"epss_score": 0.00037, "epss_percentile": 0.10916}, "CVE-2025-49552": {"epss_score": 0.00127, "epss_percentile": 0.328}, "CVE-2025-49553": {"epss_score": 0.00137, "epss_percentile": 0.34306}, "CVE-2025-49554": {"epss_score": 0.00191, "epss_percentile": 0.41273}, "CVE-2025-49555": {"epss_score": 0.00036, "epss_percentile": 0.10617}, "CVE-2025-49556": {"epss_score": 0.00111, "epss_percentile": 0.30406}, "CVE-2025-49557": {"epss_score": 0.00029, "epss_percentile": 0.07595}, "CVE-2025-49558": {"epss_score": 0.00087, "epss_percentile": 0.25575}, "CVE-2025-49559": {"epss_score": 0.00174, "epss_percentile": 0.39146}, "CVE-2025-49560": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-49561": {"epss_score": 0.00029, "epss_percentile": 0.07686}, "CVE-2025-49562": {"epss_score": 0.00022, "epss_percentile": 0.05251}, "CVE-2025-49563": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-49564": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-49567": {"epss_score": 0.00016, "epss_percentile": 0.02722}, "CVE-2025-49568": {"epss_score": 0.00022, "epss_percentile": 0.05251}, "CVE-2025-49569": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-49570": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-49571": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-49572": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-49573": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-49574": {"epss_score": 0.00026, "epss_percentile": 0.06583}, "CVE-2025-49575": {"epss_score": 0.00029, "epss_percentile": 0.07837}, "CVE-2025-49576": {"epss_score": 0.00029, "epss_percentile": 0.07837}, "CVE-2025-49577": {"epss_score": 0.00029, "epss_percentile": 0.07837}, "CVE-2025-49578": {"epss_score": 0.00029, "epss_percentile": 0.07837}, "CVE-2025-49579": {"epss_score": 0.00038, "epss_percentile": 0.11129}, "CVE-2025-49580": {"epss_score": 0.00302, "epss_percentile": 0.53093}, "CVE-2025-49581": {"epss_score": 0.01181, "epss_percentile": 0.78311}, "CVE-2025-49582": {"epss_score": 0.00686, "epss_percentile": 0.71169}, "CVE-2025-49583": {"epss_score": 0.00016, "epss_percentile": 0.02618}, "CVE-2025-49584": {"epss_score": 0.0003, "epss_percentile": 0.08302}, "CVE-2025-49585": {"epss_score": 0.00257, "epss_percentile": 0.48856}, "CVE-2025-49586": {"epss_score": 0.04057, "epss_percentile": 0.88187}, "CVE-2025-49587": {"epss_score": 0.00257, "epss_percentile": 0.48856}, "CVE-2025-49588": {"epss_score": 0.0006, "epss_percentile": 0.19177}, "CVE-2025-49589": {"epss_score": 0.0007, "epss_percentile": 0.21709}, "CVE-2025-49590": {"epss_score": 0.0004, "epss_percentile": 0.12193}, "CVE-2025-49591": {"epss_score": 0.00278, "epss_percentile": 0.50904}, "CVE-2025-49592": {"epss_score": 0.00035, "epss_percentile": 0.10151}, "CVE-2025-49593": {"epss_score": 0.00069, "epss_percentile": 0.21435}, "CVE-2025-49594": {"epss_score": 0.00139, "epss_percentile": 0.3457}, "CVE-2025-49595": {"epss_score": 0.00069, "epss_percentile": 0.21551}, "CVE-2025-49596": {"epss_score": 0.03596, "epss_percentile": 0.87405}, "CVE-2025-49597": {"epss_score": 0.0191, "epss_percentile": 0.82824}, "CVE-2025-49598": {"epss_score": 0.00022, "epss_percentile": 0.05023}, "CVE-2025-49599": {"epss_score": 0.00011, "epss_percentile": 0.00957}, "CVE-2025-49600": {"epss_score": 8e-05, "epss_percentile": 0.0055}, "CVE-2025-49601": {"epss_score": 0.0004, "epss_percentile": 0.12005}, "CVE-2025-49603": {"epss_score": 0.0004, "epss_percentile": 0.12167}, "CVE-2025-49604": {"epss_score": 0.00036, "epss_percentile": 0.1061}, "CVE-2025-49618": {"epss_score": 0.00037, "epss_percentile": 0.10864}, "CVE-2025-49619": {"epss_score": 0.68398, "epss_percentile": 0.98545}, "CVE-2025-49630": {"epss_score": 0.00452, "epss_percentile": 0.63168}, "CVE-2025-49641": {"epss_score": 0.00043, "epss_percentile": 0.13361}, "CVE-2025-49642": {"epss_score": 0.00018, "epss_percentile": 0.03913}, "CVE-2025-49643": {"epss_score": 0.00028, "epss_percentile": 0.07471}, "CVE-2025-49651": {"epss_score": 0.0005, "epss_percentile": 0.15942}, "CVE-2025-49652": {"epss_score": 0.00082, "epss_percentile": 0.24534}, "CVE-2025-49653": {"epss_score": 0.00048, "epss_percentile": 0.14942}, "CVE-2025-49655": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-49656": {"epss_score": 0.00191, "epss_percentile": 0.41201}, "CVE-2025-49657": {"epss_score": 0.00059, "epss_percentile": 0.18817}, "CVE-2025-49658": {"epss_score": 0.00046, "epss_percentile": 0.14276}, "CVE-2025-49659": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-49660": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-49661": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-49663": {"epss_score": 0.00059, "epss_percentile": 0.18817}, "CVE-2025-49664": {"epss_score": 0.00065, "epss_percentile": 0.20639}, "CVE-2025-49665": {"epss_score": 0.00044, "epss_percentile": 0.13525}, "CVE-2025-49666": {"epss_score": 0.00111, "epss_percentile": 0.30403}, "CVE-2025-49667": {"epss_score": 0.00065, "epss_percentile": 0.20528}, "CVE-2025-49668": {"epss_score": 0.00059, "epss_percentile": 0.18817}, "CVE-2025-49669": {"epss_score": 0.00059, "epss_percentile": 0.18817}, "CVE-2025-49670": {"epss_score": 0.0005, "epss_percentile": 0.15822}, "CVE-2025-49671": {"epss_score": 0.00066, "epss_percentile": 0.20762}, "CVE-2025-49672": {"epss_score": 0.00059, "epss_percentile": 0.18817}, "CVE-2025-49673": {"epss_score": 0.00059, "epss_percentile": 0.18817}, "CVE-2025-49674": {"epss_score": 0.00059, "epss_percentile": 0.18817}, "CVE-2025-49675": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-49676": {"epss_score": 0.00059, "epss_percentile": 0.18817}, "CVE-2025-49677": {"epss_score": 0.008, "epss_percentile": 0.73543}, "CVE-2025-49678": {"epss_score": 0.00032, "epss_percentile": 0.08814}, "CVE-2025-49679": {"epss_score": 0.0015, "epss_percentile": 0.36094}, "CVE-2025-49680": {"epss_score": 0.00047, "epss_percentile": 0.14783}, "CVE-2025-49681": {"epss_score": 0.0005, "epss_percentile": 0.15822}, "CVE-2025-49682": {"epss_score": 0.00056, "epss_percentile": 0.17721}, "CVE-2025-49683": {"epss_score": 0.00219, "epss_percentile": 0.44512}, "CVE-2025-49684": {"epss_score": 0.00046, "epss_percentile": 0.14276}, "CVE-2025-49685": {"epss_score": 0.00039, "epss_percentile": 0.11841}, "CVE-2025-49686": {"epss_score": 0.00059, "epss_percentile": 0.18804}, "CVE-2025-49687": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-49688": {"epss_score": 0.00059, "epss_percentile": 0.18817}, "CVE-2025-49689": {"epss_score": 0.00071, "epss_percentile": 0.22138}, "CVE-2025-49690": {"epss_score": 0.00031, "epss_percentile": 0.08497}, "CVE-2025-49691": {"epss_score": 0.00101, "epss_percentile": 0.28691}, "CVE-2025-49692": {"epss_score": 0.00061, "epss_percentile": 0.19244}, "CVE-2025-49693": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-49694": {"epss_score": 0.00059, "epss_percentile": 0.18804}, "CVE-2025-49695": {"epss_score": 0.00075, "epss_percentile": 0.22892}, "CVE-2025-49696": {"epss_score": 0.00075, "epss_percentile": 0.22892}, "CVE-2025-49697": {"epss_score": 0.00057, "epss_percentile": 0.18192}, "CVE-2025-49698": {"epss_score": 0.00056, "epss_percentile": 0.17875}, "CVE-2025-49699": {"epss_score": 0.00059, "epss_percentile": 0.18879}, "CVE-2025-49700": {"epss_score": 0.00056, "epss_percentile": 0.17875}, "CVE-2025-49701": {"epss_score": 0.00367, "epss_percentile": 0.58118}, "CVE-2025-49702": {"epss_score": 0.00112, "epss_percentile": 0.30551}, "CVE-2025-49703": {"epss_score": 0.00092, "epss_percentile": 0.26515}, "CVE-2025-49704": {"epss_score": 0.70296, "epss_percentile": 0.98627}, "CVE-2025-49705": {"epss_score": 0.00056, "epss_percentile": 0.17875}, "CVE-2025-49706": {"epss_score": 0.71161, "epss_percentile": 0.98657}, "CVE-2025-49707": {"epss_score": 0.00064, "epss_percentile": 0.20357}, "CVE-2025-49708": {"epss_score": 0.00076, "epss_percentile": 0.23158}, "CVE-2025-49709": {"epss_score": 0.00066, "epss_percentile": 0.20757}, "CVE-2025-49710": {"epss_score": 0.00066, "epss_percentile": 0.20757}, "CVE-2025-49711": {"epss_score": 0.00056, "epss_percentile": 0.17875}, "CVE-2025-49712": {"epss_score": 0.03036, "epss_percentile": 0.86261}, "CVE-2025-49713": {"epss_score": 0.00346, "epss_percentile": 0.56732}, "CVE-2025-49714": {"epss_score": 0.00112, "epss_percentile": 0.30551}, "CVE-2025-49715": {"epss_score": 0.00122, "epss_percentile": 0.32157}, "CVE-2025-49716": {"epss_score": 0.10495, "epss_percentile": 0.93009}, "CVE-2025-49717": {"epss_score": 0.00064, "epss_percentile": 0.20166}, "CVE-2025-49718": {"epss_score": 0.01504, "epss_percentile": 0.80737}, "CVE-2025-49719": {"epss_score": 0.00481, "epss_percentile": 0.64519}, "CVE-2025-49721": {"epss_score": 0.00056, "epss_percentile": 0.17875}, "CVE-2025-49722": {"epss_score": 0.00424, "epss_percentile": 0.61658}, "CVE-2025-49723": {"epss_score": 0.00054, "epss_percentile": 0.17326}, "CVE-2025-49724": {"epss_score": 0.0018, "epss_percentile": 0.39877}, "CVE-2025-49725": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-49726": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-49727": {"epss_score": 0.00039, "epss_percentile": 0.11841}, "CVE-2025-49728": {"epss_score": 0.00022, "epss_percentile": 0.04961}, "CVE-2025-49729": {"epss_score": 0.00059, "epss_percentile": 0.18817}, "CVE-2025-49730": {"epss_score": 0.00466, "epss_percentile": 0.63808}, "CVE-2025-49731": {"epss_score": 0.00035, "epss_percentile": 0.09876}, "CVE-2025-49732": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-49733": {"epss_score": 0.00057, "epss_percentile": 0.18069}, "CVE-2025-49734": {"epss_score": 0.00056, "epss_percentile": 0.17667}, "CVE-2025-49735": {"epss_score": 0.0011, "epss_percentile": 0.30116}, "CVE-2025-49736": {"epss_score": 0.00045, "epss_percentile": 0.13723}, "CVE-2025-49737": {"epss_score": 0.00032, "epss_percentile": 0.08814}, "CVE-2025-49738": {"epss_score": 0.00069, "epss_percentile": 0.21588}, "CVE-2025-49739": {"epss_score": 0.00048, "epss_percentile": 0.15187}, "CVE-2025-49740": {"epss_score": 0.0006, "epss_percentile": 0.19225}, "CVE-2025-49741": {"epss_score": 0.00681, "epss_percentile": 0.71054}, "CVE-2025-49742": {"epss_score": 0.00078, "epss_percentile": 0.23654}, "CVE-2025-49743": {"epss_score": 0.00047, "epss_percentile": 0.14784}, "CVE-2025-49744": {"epss_score": 0.00775, "epss_percentile": 0.73084}, "CVE-2025-49745": {"epss_score": 0.00047, "epss_percentile": 0.14669}, "CVE-2025-49746": {"epss_score": 0.00112, "epss_percentile": 0.30512}, "CVE-2025-49747": {"epss_score": 0.00112, "epss_percentile": 0.30512}, "CVE-2025-49751": {"epss_score": 0.00282, "epss_percentile": 0.51226}, "CVE-2025-49752": {"epss_score": 0.00053, "epss_percentile": 0.16726}, "CVE-2025-49753": {"epss_score": 0.00059, "epss_percentile": 0.18817}, "CVE-2025-49755": {"epss_score": 0.00042, "epss_percentile": 0.12881}, "CVE-2025-49756": {"epss_score": 0.00017, "epss_percentile": 0.0332}, "CVE-2025-49757": {"epss_score": 0.0007, "epss_percentile": 0.21768}, "CVE-2025-49758": {"epss_score": 0.00097, "epss_percentile": 0.27612}, "CVE-2025-49759": {"epss_score": 0.00112, "epss_percentile": 0.30475}, "CVE-2025-49760": {"epss_score": 0.00117, "epss_percentile": 0.31339}, "CVE-2025-49761": {"epss_score": 0.00067, "epss_percentile": 0.21149}, "CVE-2025-49762": {"epss_score": 0.00036, "epss_percentile": 0.1049}, "CVE-2025-49763": {"epss_score": 0.00398, "epss_percentile": 0.60061}, "CVE-2025-49794": {"epss_score": 0.00263, "epss_percentile": 0.4947}, "CVE-2025-49795": {"epss_score": 0.00141, "epss_percentile": 0.34913}, "CVE-2025-49796": {"epss_score": 0.00459, "epss_percentile": 0.63451}, "CVE-2025-49797": {"epss_score": 0.00017, "epss_percentile": 0.03294}, "CVE-2025-49809": {"epss_score": 0.00013, "epss_percentile": 0.01542}, "CVE-2025-49810": {"epss_score": 0.00048, "epss_percentile": 0.15218}, "CVE-2025-49812": {"epss_score": 0.00088, "epss_percentile": 0.25718}, "CVE-2025-49813": {"epss_score": 0.00077, "epss_percentile": 0.2344}, "CVE-2025-49823": {"epss_score": 0.00017, "epss_percentile": 0.03243}, "CVE-2025-49824": {"epss_score": 0.00038, "epss_percentile": 0.11157}, "CVE-2025-49825": {"epss_score": 0.11526, "epss_percentile": 0.93392}, "CVE-2025-49826": {"epss_score": 0.00042, "epss_percentile": 0.1274}, "CVE-2025-49827": {"epss_score": 0.00129, "epss_percentile": 0.33125}, "CVE-2025-49828": {"epss_score": 0.00395, "epss_percentile": 0.59801}, "CVE-2025-49829": {"epss_score": 0.00041, "epss_percentile": 0.1244}, "CVE-2025-49830": {"epss_score": 0.00065, "epss_percentile": 0.20609}, "CVE-2025-49831": {"epss_score": 0.00137, "epss_percentile": 0.34228}, "CVE-2025-49832": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-49833": {"epss_score": 0.0041, "epss_percentile": 0.6082}, "CVE-2025-49834": {"epss_score": 0.0052, "epss_percentile": 0.66194}, "CVE-2025-49835": {"epss_score": 0.0041, "epss_percentile": 0.6082}, "CVE-2025-49836": {"epss_score": 0.0052, "epss_percentile": 0.66194}, "CVE-2025-49837": {"epss_score": 0.00255, "epss_percentile": 0.48646}, "CVE-2025-49838": {"epss_score": 0.00255, "epss_percentile": 0.48646}, "CVE-2025-49839": {"epss_score": 0.00255, "epss_percentile": 0.48646}, "CVE-2025-49840": {"epss_score": 0.00232, "epss_percentile": 0.4589}, "CVE-2025-49841": {"epss_score": 0.00232, "epss_percentile": 0.4589}, "CVE-2025-49842": {"epss_score": 0.0002, "epss_percentile": 0.04504}, "CVE-2025-49843": {"epss_score": 0.00064, "epss_percentile": 0.20404}, "CVE-2025-49844": {"epss_score": 0.06875, "epss_percentile": 0.91087}, "CVE-2025-49845": {"epss_score": 0.00057, "epss_percentile": 0.18011}, "CVE-2025-49846": {"epss_score": 0.00017, "epss_percentile": 0.03244}, "CVE-2025-49847": {"epss_score": 0.00079, "epss_percentile": 0.23859}, "CVE-2025-49848": {"epss_score": 0.00024, "epss_percentile": 0.0582}, "CVE-2025-49849": {"epss_score": 0.00024, "epss_percentile": 0.0582}, "CVE-2025-49850": {"epss_score": 0.00024, "epss_percentile": 0.0582}, "CVE-2025-49851": {"epss_score": 0.0011, "epss_percentile": 0.30215}, "CVE-2025-49852": {"epss_score": 0.00078, "epss_percentile": 0.23624}, "CVE-2025-49853": {"epss_score": 0.00054, "epss_percentile": 0.17266}, "CVE-2025-49854": {"epss_score": 0.00032, "epss_percentile": 0.08798}, "CVE-2025-49855": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-49856": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-49857": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-49858": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-49859": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-49860": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-49861": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-49862": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-49863": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-49864": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-49865": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-49866": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-49867": {"epss_score": 0.00059, "epss_percentile": 0.18855}, "CVE-2025-49868": {"epss_score": 0.00029, "epss_percentile": 0.07604}, "CVE-2025-49869": {"epss_score": 0.00114, "epss_percentile": 0.3083}, "CVE-2025-49870": {"epss_score": 0.00026, "epss_percentile": 0.0659}, "CVE-2025-49871": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-49872": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-49873": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-49874": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-49875": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-49876": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-49877": {"epss_score": 0.00026, "epss_percentile": 0.06402}, "CVE-2025-49878": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-49879": {"epss_score": 0.00058, "epss_percentile": 0.18482}, "CVE-2025-49880": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-49881": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-49882": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-49883": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-49884": {"epss_score": 0.00054, "epss_percentile": 0.17191}, "CVE-2025-49885": {"epss_score": 0.00126, "epss_percentile": 0.32656}, "CVE-2025-49886": {"epss_score": 0.00101, "epss_percentile": 0.28671}, "CVE-2025-49887": {"epss_score": 0.00048, "epss_percentile": 0.15178}, "CVE-2025-49888": {"epss_score": 0.00052, "epss_percentile": 0.16552}, "CVE-2025-49889": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49890": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49891": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49892": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49893": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-49894": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49895": {"epss_score": 0.00034, "epss_percentile": 0.09617}, "CVE-2025-49896": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-49897": {"epss_score": 0.00057, "epss_percentile": 0.18148}, "CVE-2025-49898": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-49899": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-49900": {"epss_score": 0.0005, "epss_percentile": 0.15884}, "CVE-2025-49901": {"epss_score": 0.001, "epss_percentile": 0.28527}, "CVE-2025-49902": {"epss_score": 0.0003, "epss_percentile": 0.08267}, "CVE-2025-49903": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-49904": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-49905": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-49906": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-49907": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-49908": {"epss_score": 0.00048, "epss_percentile": 0.15196}, "CVE-2025-49909": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-49910": {"epss_score": 0.00045, "epss_percentile": 0.13761}, "CVE-2025-49911": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49912": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-49913": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-49914": {"epss_score": 0.00034, "epss_percentile": 0.0971}, "CVE-2025-49915": {"epss_score": 0.00053, "epss_percentile": 0.1673}, "CVE-2025-49916": {"epss_score": 0.0006, "epss_percentile": 0.19211}, "CVE-2025-49917": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2025-49918": {"epss_score": 0.00033, "epss_percentile": 0.09399}, "CVE-2025-49919": {"epss_score": 0.00034, "epss_percentile": 0.09704}, "CVE-2025-49920": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-49921": {"epss_score": 0.00149, "epss_percentile": 0.35995}, "CVE-2025-49922": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-49923": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-49924": {"epss_score": 0.00054, "epss_percentile": 0.17143}, "CVE-2025-49925": {"epss_score": 0.00054, "epss_percentile": 0.17143}, "CVE-2025-49926": {"epss_score": 0.00062, "epss_percentile": 0.1967}, "CVE-2025-49927": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-49928": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-49929": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-49930": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49931": {"epss_score": 0.00053, "epss_percentile": 0.1673}, "CVE-2025-49932": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-49933": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-49934": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-49935": {"epss_score": 0.00148, "epss_percentile": 0.35846}, "CVE-2025-49936": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-49937": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-49938": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-49939": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-49940": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-49941": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-49942": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-49943": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-49944": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49945": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49946": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49947": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49948": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49949": {"epss_score": 0.00039, "epss_percentile": 0.11708}, "CVE-2025-49950": {"epss_score": 0.00054, "epss_percentile": 0.17143}, "CVE-2025-49951": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49952": {"epss_score": 0.00051, "epss_percentile": 0.1602}, "CVE-2025-49953": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49954": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49955": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49956": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49957": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49958": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49959": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49960": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-49961": {"epss_score": 0.00051, "epss_percentile": 0.1602}, "CVE-2025-49962": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49963": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49964": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-49965": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-49966": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-49967": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-49968": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-49969": {"epss_score": 0.00051, "epss_percentile": 0.1606}, "CVE-2025-49970": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-49971": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-49972": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-49973": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-49974": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-49975": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-49976": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-49977": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-49978": {"epss_score": 0.00051, "epss_percentile": 0.1606}, "CVE-2025-49979": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-49980": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-49981": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-49982": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-49983": {"epss_score": 0.00026, "epss_percentile": 0.06402}, "CVE-2025-49984": {"epss_score": 0.00026, "epss_percentile": 0.06402}, "CVE-2025-49985": {"epss_score": 0.00026, "epss_percentile": 0.06402}, "CVE-2025-49986": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-49987": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-49988": {"epss_score": 0.00057, "epss_percentile": 0.18124}, "CVE-2025-49989": {"epss_score": 0.00038, "epss_percentile": 0.11266}, "CVE-2025-49990": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-49991": {"epss_score": 0.00057, "epss_percentile": 0.18124}, "CVE-2025-49992": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-49993": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-49995": {"epss_score": 0.00038, "epss_percentile": 0.11266}, "CVE-2025-49996": {"epss_score": 0.00057, "epss_percentile": 0.18124}, "CVE-2025-49997": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-49998": {"epss_score": 0.00051, "epss_percentile": 0.1606}, "CVE-2025-4000": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-4001": {"epss_score": 0.00019, "epss_percentile": 0.04377}, "CVE-2025-4002": {"epss_score": 0.00014, "epss_percentile": 0.02024}, "CVE-2025-4003": {"epss_score": 0.00014, "epss_percentile": 0.02024}, "CVE-2025-4004": {"epss_score": 0.00043, "epss_percentile": 0.13332}, "CVE-2025-4005": {"epss_score": 0.00043, "epss_percentile": 0.13332}, "CVE-2025-4006": {"epss_score": 0.00044, "epss_percentile": 0.13507}, "CVE-2025-4007": {"epss_score": 0.00139, "epss_percentile": 0.34623}, "CVE-2025-4008": {"epss_score": 0.44461, "epss_percentile": 0.97438}, "CVE-2025-4009": {"epss_score": 0.05406, "epss_percentile": 0.89839}, "CVE-2025-4010": {"epss_score": 0.00164, "epss_percentile": 0.38004}, "CVE-2025-4011": {"epss_score": 0.00038, "epss_percentile": 0.11143}, "CVE-2025-4012": {"epss_score": 0.00121, "epss_percentile": 0.31917}, "CVE-2025-4013": {"epss_score": 0.00047, "epss_percentile": 0.14848}, "CVE-2025-4014": {"epss_score": 0.00043, "epss_percentile": 0.13332}, "CVE-2025-4015": {"epss_score": 0.00065, "epss_percentile": 0.20515}, "CVE-2025-4016": {"epss_score": 0.00117, "epss_percentile": 0.31373}, "CVE-2025-4017": {"epss_score": 0.00038, "epss_percentile": 0.11126}, "CVE-2025-4018": {"epss_score": 0.00077, "epss_percentile": 0.23433}, "CVE-2025-4019": {"epss_score": 0.00124, "epss_percentile": 0.32459}, "CVE-2025-4020": {"epss_score": 0.00057, "epss_percentile": 0.18055}, "CVE-2025-4021": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-4022": {"epss_score": 0.00067, "epss_percentile": 0.2118}, "CVE-2025-4023": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-4024": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-4025": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-4026": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-4027": {"epss_score": 0.00062, "epss_percentile": 0.19652}, "CVE-2025-4028": {"epss_score": 0.00047, "epss_percentile": 0.14848}, "CVE-2025-4029": {"epss_score": 0.00022, "epss_percentile": 0.05035}, "CVE-2025-4030": {"epss_score": 0.00047, "epss_percentile": 0.14848}, "CVE-2025-4031": {"epss_score": 0.00047, "epss_percentile": 0.14848}, "CVE-2025-4032": {"epss_score": 0.00319, "epss_percentile": 0.54544}, "CVE-2025-4033": {"epss_score": 0.00047, "epss_percentile": 0.14848}, "CVE-2025-4034": {"epss_score": 0.0005, "epss_percentile": 0.15781}, "CVE-2025-4035": {"epss_score": 0.00031, "epss_percentile": 0.0843}, "CVE-2025-4036": {"epss_score": 0.00084, "epss_percentile": 0.25025}, "CVE-2025-4037": {"epss_score": 0.00024, "epss_percentile": 0.05822}, "CVE-2025-4038": {"epss_score": 0.00021, "epss_percentile": 0.04928}, "CVE-2025-4039": {"epss_score": 0.00057, "epss_percentile": 0.18055}, "CVE-2025-4040": {"epss_score": 0.00038, "epss_percentile": 0.11231}, "CVE-2025-4041": {"epss_score": 0.00118, "epss_percentile": 0.31384}, "CVE-2025-4043": {"epss_score": 0.0005, "epss_percentile": 0.15665}, "CVE-2025-4044": {"epss_score": 0.00025, "epss_percentile": 0.06138}, "CVE-2025-4046": {"epss_score": 0.00075, "epss_percentile": 0.23056}, "CVE-2025-4047": {"epss_score": 0.00034, "epss_percentile": 0.09772}, "CVE-2025-4049": {"epss_score": 0.0002, "epss_percentile": 0.04504}, "CVE-2025-4050": {"epss_score": 0.00045, "epss_percentile": 0.13816}, "CVE-2025-4051": {"epss_score": 0.00031, "epss_percentile": 0.08467}, "CVE-2025-4052": {"epss_score": 0.00048, "epss_percentile": 0.1518}, "CVE-2025-4053": {"epss_score": 0.00015, "epss_percentile": 0.02217}, "CVE-2025-4054": {"epss_score": 0.00169, "epss_percentile": 0.38532}, "CVE-2025-4055": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-4056": {"epss_score": 0.00086, "epss_percentile": 0.25312}, "CVE-2025-4057": {"epss_score": 0.00022, "epss_percentile": 0.05022}, "CVE-2025-4058": {"epss_score": 0.0005, "epss_percentile": 0.15781}, "CVE-2025-4059": {"epss_score": 0.00022, "epss_percentile": 0.0518}, "CVE-2025-4060": {"epss_score": 0.00047, "epss_percentile": 0.14848}, "CVE-2025-4061": {"epss_score": 0.00022, "epss_percentile": 0.05035}, "CVE-2025-4062": {"epss_score": 0.00022, "epss_percentile": 0.05035}, "CVE-2025-4063": {"epss_score": 0.00022, "epss_percentile": 0.05035}, "CVE-2025-4064": {"epss_score": 0.00035, "epss_percentile": 0.1001}, "CVE-2025-4065": {"epss_score": 0.00036, "epss_percentile": 0.10383}, "CVE-2025-4066": {"epss_score": 0.00072, "epss_percentile": 0.2237}, "CVE-2025-4067": {"epss_score": 0.00035, "epss_percentile": 0.1001}, "CVE-2025-4068": {"epss_score": 0.00022, "epss_percentile": 0.0518}, "CVE-2025-4069": {"epss_score": 0.00022, "epss_percentile": 0.0518}, "CVE-2025-4070": {"epss_score": 0.00062, "epss_percentile": 0.19652}, "CVE-2025-4071": {"epss_score": 0.00062, "epss_percentile": 0.19652}, "CVE-2025-4072": {"epss_score": 0.0006, "epss_percentile": 0.19079}, "CVE-2025-4073": {"epss_score": 0.00062, "epss_percentile": 0.19652}, "CVE-2025-4074": {"epss_score": 0.00062, "epss_percentile": 0.19652}, "CVE-2025-4075": {"epss_score": 0.00025, "epss_percentile": 0.06289}, "CVE-2025-4076": {"epss_score": 0.00366, "epss_percentile": 0.58086}, "CVE-2025-4077": {"epss_score": 0.00022, "epss_percentile": 0.0518}, "CVE-2025-4078": {"epss_score": 0.00052, "epss_percentile": 0.16458}, "CVE-2025-4079": {"epss_score": 0.00107, "epss_percentile": 0.29672}, "CVE-2025-4080": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4081": {"epss_score": 0.00017, "epss_percentile": 0.03088}, "CVE-2025-4082": {"epss_score": 0.00062, "epss_percentile": 0.19573}, "CVE-2025-4083": {"epss_score": 0.00075, "epss_percentile": 0.22895}, "CVE-2025-4084": {"epss_score": 0.00067, "epss_percentile": 0.21021}, "CVE-2025-4085": {"epss_score": 0.00044, "epss_percentile": 0.1362}, "CVE-2025-4086": {"epss_score": 0.00045, "epss_percentile": 0.13813}, "CVE-2025-4087": {"epss_score": 0.0008, "epss_percentile": 0.24137}, "CVE-2025-4088": {"epss_score": 0.00022, "epss_percentile": 0.04978}, "CVE-2025-4089": {"epss_score": 0.00021, "epss_percentile": 0.04913}, "CVE-2025-4090": {"epss_score": 0.00043, "epss_percentile": 0.13228}, "CVE-2025-4091": {"epss_score": 0.00088, "epss_percentile": 0.25725}, "CVE-2025-4092": {"epss_score": 0.00043, "epss_percentile": 0.13228}, "CVE-2025-4093": {"epss_score": 0.00086, "epss_percentile": 0.25388}, "CVE-2025-4094": {"epss_score": 0.01574, "epss_percentile": 0.81106}, "CVE-2025-4095": {"epss_score": 0.00022, "epss_percentile": 0.05004}, "CVE-2025-4096": {"epss_score": 0.00048, "epss_percentile": 0.15266}, "CVE-2025-4097": {"epss_score": 0.00038, "epss_percentile": 0.11121}, "CVE-2025-4098": {"epss_score": 0.00025, "epss_percentile": 0.06261}, "CVE-2025-4099": {"epss_score": 0.00026, "epss_percentile": 0.06592}, "CVE-2025-4100": {"epss_score": 0.00035, "epss_percentile": 0.10019}, "CVE-2025-4101": {"epss_score": 0.00034, "epss_percentile": 0.09779}, "CVE-2025-4102": {"epss_score": 0.00222, "epss_percentile": 0.44794}, "CVE-2025-4103": {"epss_score": 0.00057, "epss_percentile": 0.18044}, "CVE-2025-4104": {"epss_score": 0.00307, "epss_percentile": 0.53469}, "CVE-2025-4105": {"epss_score": 0.00034, "epss_percentile": 0.09772}, "CVE-2025-4106": {"epss_score": 0.00041, "epss_percentile": 0.12292}, "CVE-2025-4108": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-4109": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4110": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4111": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4112": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-4113": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4114": {"epss_score": 0.00155, "epss_percentile": 0.36766}, "CVE-2025-4115": {"epss_score": 0.00155, "epss_percentile": 0.36766}, "CVE-2025-4116": {"epss_score": 0.00155, "epss_percentile": 0.36766}, "CVE-2025-4117": {"epss_score": 0.00074, "epss_percentile": 0.22863}, "CVE-2025-4118": {"epss_score": 0.00037, "epss_percentile": 0.1088}, "CVE-2025-4119": {"epss_score": 0.00037, "epss_percentile": 0.1088}, "CVE-2025-4120": {"epss_score": 0.00276, "epss_percentile": 0.50709}, "CVE-2025-4121": {"epss_score": 0.0027, "epss_percentile": 0.50209}, "CVE-2025-4122": {"epss_score": 0.00261, "epss_percentile": 0.49292}, "CVE-2025-4123": {"epss_score": 0.08682, "epss_percentile": 0.92197}, "CVE-2025-4124": {"epss_score": 0.00062, "epss_percentile": 0.19668}, "CVE-2025-4125": {"epss_score": 0.00062, "epss_percentile": 0.19668}, "CVE-2025-4126": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-4127": {"epss_score": 0.00024, "epss_percentile": 0.05887}, "CVE-2025-4128": {"epss_score": 0.00029, "epss_percentile": 0.07786}, "CVE-2025-4129": {"epss_score": 0.00043, "epss_percentile": 0.13007}, "CVE-2025-4130": {"epss_score": 0.00043, "epss_percentile": 0.13007}, "CVE-2025-4131": {"epss_score": 0.00035, "epss_percentile": 0.10019}, "CVE-2025-4133": {"epss_score": 0.00026, "epss_percentile": 0.06638}, "CVE-2025-4134": {"epss_score": 0.00016, "epss_percentile": 0.02791}, "CVE-2025-4135": {"epss_score": 0.00371, "epss_percentile": 0.58381}, "CVE-2025-4136": {"epss_score": 0.00051, "epss_percentile": 0.16328}, "CVE-2025-4138": {"epss_score": 0.00133, "epss_percentile": 0.33743}, "CVE-2025-4139": {"epss_score": 0.00237, "epss_percentile": 0.46649}, "CVE-2025-4140": {"epss_score": 0.0028, "epss_percentile": 0.51076}, "CVE-2025-4141": {"epss_score": 0.0028, "epss_percentile": 0.51076}, "CVE-2025-4142": {"epss_score": 0.0028, "epss_percentile": 0.51076}, "CVE-2025-4143": {"epss_score": 0.00043, "epss_percentile": 0.13081}, "CVE-2025-4144": {"epss_score": 0.0008, "epss_percentile": 0.24096}, "CVE-2025-4145": {"epss_score": 0.0028, "epss_percentile": 0.51076}, "CVE-2025-4146": {"epss_score": 0.0028, "epss_percentile": 0.51076}, "CVE-2025-4147": {"epss_score": 0.0028, "epss_percentile": 0.51076}, "CVE-2025-4148": {"epss_score": 0.00123, "epss_percentile": 0.32193}, "CVE-2025-4149": {"epss_score": 0.00123, "epss_percentile": 0.32193}, "CVE-2025-4150": {"epss_score": 0.00123, "epss_percentile": 0.32193}, "CVE-2025-4151": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-4152": {"epss_score": 0.0003, "epss_percentile": 0.08242}, "CVE-2025-4153": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-4154": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4155": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4156": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4157": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4158": {"epss_score": 0.00107, "epss_percentile": 0.29672}, "CVE-2025-4159": {"epss_score": 0.00107, "epss_percentile": 0.29672}, "CVE-2025-4160": {"epss_score": 0.00107, "epss_percentile": 0.29672}, "CVE-2025-4161": {"epss_score": 0.00107, "epss_percentile": 0.29672}, "CVE-2025-4162": {"epss_score": 0.00107, "epss_percentile": 0.29672}, "CVE-2025-4163": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4164": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-4166": {"epss_score": 0.00023, "epss_percentile": 0.05337}, "CVE-2025-4168": {"epss_score": 0.00035, "epss_percentile": 0.10019}, "CVE-2025-4169": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-4170": {"epss_score": 0.00035, "epss_percentile": 0.10019}, "CVE-2025-4171": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-4172": {"epss_score": 0.00035, "epss_percentile": 0.10019}, "CVE-2025-4173": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4174": {"epss_score": 0.00062, "epss_percentile": 0.19652}, "CVE-2025-4175": {"epss_score": 0.00063, "epss_percentile": 0.19884}, "CVE-2025-4176": {"epss_score": 0.00062, "epss_percentile": 0.19652}, "CVE-2025-4177": {"epss_score": 0.00132, "epss_percentile": 0.33622}, "CVE-2025-4178": {"epss_score": 0.00035, "epss_percentile": 0.10141}, "CVE-2025-4179": {"epss_score": 0.00163, "epss_percentile": 0.37808}, "CVE-2025-4180": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4181": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4182": {"epss_score": 0.00107, "epss_percentile": 0.29672}, "CVE-2025-4183": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4184": {"epss_score": 0.00107, "epss_percentile": 0.29672}, "CVE-2025-4185": {"epss_score": 0.00076, "epss_percentile": 0.23104}, "CVE-2025-4186": {"epss_score": 0.00056, "epss_percentile": 0.17794}, "CVE-2025-4187": {"epss_score": 0.00401, "epss_percentile": 0.60216}, "CVE-2025-4188": {"epss_score": 0.00013, "epss_percentile": 0.01456}, "CVE-2025-4189": {"epss_score": 0.00012, "epss_percentile": 0.01409}, "CVE-2025-4190": {"epss_score": 0.00031, "epss_percentile": 0.08379}, "CVE-2025-4191": {"epss_score": 0.00065, "epss_percentile": 0.20561}, "CVE-2025-4192": {"epss_score": 0.0006, "epss_percentile": 0.19019}, "CVE-2025-4193": {"epss_score": 0.0006, "epss_percentile": 0.19019}, "CVE-2025-4194": {"epss_score": 0.00012, "epss_percentile": 0.01409}, "CVE-2025-4195": {"epss_score": 0.0006, "epss_percentile": 0.19019}, "CVE-2025-4196": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4197": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4198": {"epss_score": 0.00013, "epss_percentile": 0.01456}, "CVE-2025-4199": {"epss_score": 0.00013, "epss_percentile": 0.01456}, "CVE-2025-4200": {"epss_score": 0.00308, "epss_percentile": 0.53619}, "CVE-2025-4203": {"epss_score": 0.0006, "epss_percentile": 0.1896}, "CVE-2025-4204": {"epss_score": 0.0008, "epss_percentile": 0.24055}, "CVE-2025-4205": {"epss_score": 0.0004, "epss_percentile": 0.12029}, "CVE-2025-4206": {"epss_score": 0.01673, "epss_percentile": 0.81683}, "CVE-2025-4207": {"epss_score": 0.00067, "epss_percentile": 0.21046}, "CVE-2025-4208": {"epss_score": 0.00104, "epss_percentile": 0.29111}, "CVE-2025-4210": {"epss_score": 0.00058, "epss_percentile": 0.18563}, "CVE-2025-4211": {"epss_score": 0.0004, "epss_percentile": 0.12164}, "CVE-2025-4212": {"epss_score": 0.00141, "epss_percentile": 0.34867}, "CVE-2025-4213": {"epss_score": 0.0003, "epss_percentile": 0.08242}, "CVE-2025-4214": {"epss_score": 0.0005, "epss_percentile": 0.15781}, "CVE-2025-4215": {"epss_score": 0.00293, "epss_percentile": 0.523}, "CVE-2025-4216": {"epss_score": 0.00034, "epss_percentile": 0.09601}, "CVE-2025-4217": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-4218": {"epss_score": 0.00029, "epss_percentile": 0.07935}, "CVE-2025-4219": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-4220": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-4221": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-4222": {"epss_score": 0.00069, "epss_percentile": 0.21622}, "CVE-2025-4223": {"epss_score": 0.0009, "epss_percentile": 0.26037}, "CVE-2025-4224": {"epss_score": 0.00033, "epss_percentile": 0.09155}, "CVE-2025-4225": {"epss_score": 0.00082, "epss_percentile": 0.24421}, "CVE-2025-4226": {"epss_score": 0.00068, "epss_percentile": 0.21265}, "CVE-2025-4227": {"epss_score": 0.00011, "epss_percentile": 0.01037}, "CVE-2025-4228": {"epss_score": 0.00018, "epss_percentile": 0.04048}, "CVE-2025-4229": {"epss_score": 0.00065, "epss_percentile": 0.2048}, "CVE-2025-4230": {"epss_score": 0.00059, "epss_percentile": 0.18628}, "CVE-2025-4231": {"epss_score": 0.00074, "epss_percentile": 0.22834}, "CVE-2025-4232": {"epss_score": 0.0005, "epss_percentile": 0.15952}, "CVE-2025-4233": {"epss_score": 0.00022, "epss_percentile": 0.05058}, "CVE-2025-4234": {"epss_score": 0.00021, "epss_percentile": 0.04863}, "CVE-2025-4235": {"epss_score": 0.00017, "epss_percentile": 0.03411}, "CVE-2025-4236": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4237": {"epss_score": 0.00107, "epss_percentile": 0.29672}, "CVE-2025-4238": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4239": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4240": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4241": {"epss_score": 0.00062, "epss_percentile": 0.19652}, "CVE-2025-4242": {"epss_score": 0.00041, "epss_percentile": 0.12327}, "CVE-2025-4243": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4244": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4247": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4248": {"epss_score": 0.00044, "epss_percentile": 0.13572}, "CVE-2025-4249": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-4250": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-4251": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4252": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4253": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4254": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4255": {"epss_score": 0.02315, "epss_percentile": 0.84354}, "CVE-2025-4256": {"epss_score": 0.00033, "epss_percentile": 0.0916}, "CVE-2025-4257": {"epss_score": 0.00033, "epss_percentile": 0.0916}, "CVE-2025-4258": {"epss_score": 0.00074, "epss_percentile": 0.22782}, "CVE-2025-4259": {"epss_score": 0.00095, "epss_percentile": 0.27136}, "CVE-2025-4260": {"epss_score": 0.00092, "epss_percentile": 0.26583}, "CVE-2025-4261": {"epss_score": 0.00032, "epss_percentile": 0.08996}, "CVE-2025-4262": {"epss_score": 0.00047, "epss_percentile": 0.14848}, "CVE-2025-4263": {"epss_score": 0.00047, "epss_percentile": 0.14848}, "CVE-2025-4264": {"epss_score": 0.00047, "epss_percentile": 0.14848}, "CVE-2025-4265": {"epss_score": 0.00047, "epss_percentile": 0.14848}, "CVE-2025-4266": {"epss_score": 0.00047, "epss_percentile": 0.14848}, "CVE-2025-4267": {"epss_score": 0.00047, "epss_percentile": 0.14916}, "CVE-2025-4268": {"epss_score": 0.00114, "epss_percentile": 0.30813}, "CVE-2025-4269": {"epss_score": 0.00103, "epss_percentile": 0.29099}, "CVE-2025-4270": {"epss_score": 0.0012, "epss_percentile": 0.31715}, "CVE-2025-4271": {"epss_score": 0.00056, "epss_percentile": 0.17866}, "CVE-2025-4272": {"epss_score": 0.00017, "epss_percentile": 0.03293}, "CVE-2025-4275": {"epss_score": 0.00018, "epss_percentile": 0.03742}, "CVE-2025-4276": {"epss_score": 0.00039, "epss_percentile": 0.11632}, "CVE-2025-4277": {"epss_score": 0.00039, "epss_percentile": 0.11632}, "CVE-2025-4278": {"epss_score": 0.00076, "epss_percentile": 0.23259}, "CVE-2025-4279": {"epss_score": 0.00248, "epss_percentile": 0.47927}, "CVE-2025-4280": {"epss_score": 0.00018, "epss_percentile": 0.03539}, "CVE-2025-4281": {"epss_score": 0.00032, "epss_percentile": 0.09099}, "CVE-2025-4282": {"epss_score": 0.00042, "epss_percentile": 0.12798}, "CVE-2025-4283": {"epss_score": 0.0005, "epss_percentile": 0.15781}, "CVE-2025-4284": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-4285": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-4286": {"epss_score": 0.00048, "epss_percentile": 0.14984}, "CVE-2025-4287": {"epss_score": 0.00036, "epss_percentile": 0.10546}, "CVE-2025-4288": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4289": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4290": {"epss_score": 0.00145, "epss_percentile": 0.35512}, "CVE-2025-4291": {"epss_score": 0.00084, "epss_percentile": 0.25025}, "CVE-2025-4292": {"epss_score": 0.0003, "epss_percentile": 0.08027}, "CVE-2025-4293": {"epss_score": 0.0003, "epss_percentile": 0.08027}, "CVE-2025-4294": {"epss_score": 0.00022, "epss_percentile": 0.05159}, "CVE-2025-4295": {"epss_score": 0.00017, "epss_percentile": 0.03481}, "CVE-2025-4296": {"epss_score": 0.00028, "epss_percentile": 0.07538}, "CVE-2025-4297": {"epss_score": 0.00062, "epss_percentile": 0.19652}, "CVE-2025-4298": {"epss_score": 0.0021, "epss_percentile": 0.43441}, "CVE-2025-4299": {"epss_score": 0.003, "epss_percentile": 0.52922}, "CVE-2025-4300": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4301": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4302": {"epss_score": 0.0104, "epss_percentile": 0.76961}, "CVE-2025-4303": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4304": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4305": {"epss_score": 0.00043, "epss_percentile": 0.12995}, "CVE-2025-4306": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4307": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4308": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4309": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4310": {"epss_score": 0.00044, "epss_percentile": 0.13426}, "CVE-2025-4311": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4312": {"epss_score": 0.00044, "epss_percentile": 0.13635}, "CVE-2025-4313": {"epss_score": 0.00044, "epss_percentile": 0.13635}, "CVE-2025-4314": {"epss_score": 0.0006, "epss_percentile": 0.19152}, "CVE-2025-4315": {"epss_score": 0.00059, "epss_percentile": 0.18922}, "CVE-2025-4316": {"epss_score": 0.00033, "epss_percentile": 0.09431}, "CVE-2025-4317": {"epss_score": 0.00325, "epss_percentile": 0.55023}, "CVE-2025-4318": {"epss_score": 0.00072, "epss_percentile": 0.22342}, "CVE-2025-4321": {"epss_score": 0.00021, "epss_percentile": 0.04923}, "CVE-2025-4322": {"epss_score": 0.33037, "epss_percentile": 0.96742}, "CVE-2025-4323": {"epss_score": 0.00028, "epss_percentile": 0.07449}, "CVE-2025-4324": {"epss_score": 0.00028, "epss_percentile": 0.07449}, "CVE-2025-4325": {"epss_score": 0.00075, "epss_percentile": 0.229}, "CVE-2025-4326": {"epss_score": 0.00028, "epss_percentile": 0.07449}, "CVE-2025-4327": {"epss_score": 0.00052, "epss_percentile": 0.16637}, "CVE-2025-4328": {"epss_score": 0.0003, "epss_percentile": 0.08175}, "CVE-2025-4329": {"epss_score": 0.00087, "epss_percentile": 0.25607}, "CVE-2025-4330": {"epss_score": 0.0016, "epss_percentile": 0.37508}, "CVE-2025-4331": {"epss_score": 0.00038, "epss_percentile": 0.11316}, "CVE-2025-4332": {"epss_score": 0.0009, "epss_percentile": 0.2601}, "CVE-2025-4333": {"epss_score": 0.00043, "epss_percentile": 0.12995}, "CVE-2025-4334": {"epss_score": 0.1827, "epss_percentile": 0.94986}, "CVE-2025-4335": {"epss_score": 0.0006, "epss_percentile": 0.19099}, "CVE-2025-4336": {"epss_score": 0.00706, "epss_percentile": 0.7164}, "CVE-2025-4337": {"epss_score": 0.00013, "epss_percentile": 0.01581}, "CVE-2025-4338": {"epss_score": 0.00014, "epss_percentile": 0.01748}, "CVE-2025-4339": {"epss_score": 0.00034, "epss_percentile": 0.09779}, "CVE-2025-4340": {"epss_score": 0.00206, "epss_percentile": 0.42931}, "CVE-2025-4341": {"epss_score": 0.00075, "epss_percentile": 0.2298}, "CVE-2025-4342": {"epss_score": 0.00169, "epss_percentile": 0.38647}, "CVE-2025-4343": {"epss_score": 0.00169, "epss_percentile": 0.38647}, "CVE-2025-4344": {"epss_score": 0.00209, "epss_percentile": 0.43402}, "CVE-2025-4345": {"epss_score": 0.00209, "epss_percentile": 0.43402}, "CVE-2025-4346": {"epss_score": 0.00209, "epss_percentile": 0.43402}, "CVE-2025-4347": {"epss_score": 0.00209, "epss_percentile": 0.43402}, "CVE-2025-4348": {"epss_score": 0.00209, "epss_percentile": 0.43402}, "CVE-2025-4349": {"epss_score": 0.0067, "epss_percentile": 0.70788}, "CVE-2025-4350": {"epss_score": 0.0067, "epss_percentile": 0.70788}, "CVE-2025-4352": {"epss_score": 0.00046, "epss_percentile": 0.14166}, "CVE-2025-4353": {"epss_score": 0.00046, "epss_percentile": 0.14166}, "CVE-2025-4354": {"epss_score": 0.00259, "epss_percentile": 0.49088}, "CVE-2025-4355": {"epss_score": 0.00259, "epss_percentile": 0.49088}, "CVE-2025-4356": {"epss_score": 0.00222, "epss_percentile": 0.44717}, "CVE-2025-4357": {"epss_score": 0.00777, "epss_percentile": 0.73121}, "CVE-2025-4358": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4359": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4360": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4361": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4362": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4363": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4364": {"epss_score": 0.00129, "epss_percentile": 0.3322}, "CVE-2025-4365": {"epss_score": 0.00074, "epss_percentile": 0.22683}, "CVE-2025-4366": {"epss_score": 0.0009, "epss_percentile": 0.26075}, "CVE-2025-4367": {"epss_score": 0.00028, "epss_percentile": 0.07566}, "CVE-2025-4368": {"epss_score": 0.003, "epss_percentile": 0.52922}, "CVE-2025-4369": {"epss_score": 0.00034, "epss_percentile": 0.09566}, "CVE-2025-4370": {"epss_score": 0.00098, "epss_percentile": 0.27681}, "CVE-2025-4371": {"epss_score": 0.00013, "epss_percentile": 0.01535}, "CVE-2025-4372": {"epss_score": 0.00053, "epss_percentile": 0.16994}, "CVE-2025-4373": {"epss_score": 0.00119, "epss_percentile": 0.31643}, "CVE-2025-4374": {"epss_score": 0.00039, "epss_percentile": 0.11802}, "CVE-2025-4375": {"epss_score": 0.00039, "epss_percentile": 0.11671}, "CVE-2025-4376": {"epss_score": 0.00144, "epss_percentile": 0.35341}, "CVE-2025-4377": {"epss_score": 0.00147, "epss_percentile": 0.35677}, "CVE-2025-4378": {"epss_score": 0.00042, "epss_percentile": 0.12651}, "CVE-2025-4379": {"epss_score": 0.00053, "epss_percentile": 0.16867}, "CVE-2025-4380": {"epss_score": 0.19733, "epss_percentile": 0.95233}, "CVE-2025-4381": {"epss_score": 0.00068, "epss_percentile": 0.21352}, "CVE-2025-4382": {"epss_score": 0.00029, "epss_percentile": 0.07627}, "CVE-2025-4383": {"epss_score": 0.00074, "epss_percentile": 0.22692}, "CVE-2025-4384": {"epss_score": 0.00017, "epss_percentile": 0.03093}, "CVE-2025-4387": {"epss_score": 0.00058, "epss_percentile": 0.18282}, "CVE-2025-4388": {"epss_score": 0.13137, "epss_percentile": 0.93883}, "CVE-2025-4389": {"epss_score": 0.009, "epss_percentile": 0.75165}, "CVE-2025-4390": {"epss_score": 0.00041, "epss_percentile": 0.12265}, "CVE-2025-4391": {"epss_score": 0.00789, "epss_percentile": 0.73353}, "CVE-2025-4392": {"epss_score": 0.00207, "epss_percentile": 0.43127}, "CVE-2025-4393": {"epss_score": 0.00018, "epss_percentile": 0.03649}, "CVE-2025-4394": {"epss_score": 0.00015, "epss_percentile": 0.02166}, "CVE-2025-4395": {"epss_score": 0.00026, "epss_percentile": 0.06443}, "CVE-2025-4396": {"epss_score": 0.21054, "epss_percentile": 0.95458}, "CVE-2025-4403": {"epss_score": 0.01, "epss_percentile": 0.76486}, "CVE-2025-4404": {"epss_score": 0.00117, "epss_percentile": 0.31218}, "CVE-2025-4405": {"epss_score": 0.00031, "epss_percentile": 0.08553}, "CVE-2025-4406": {"epss_score": 0.00015, "epss_percentile": 0.02582}, "CVE-2025-4407": {"epss_score": 0.00014, "epss_percentile": 0.0208}, "CVE-2025-4410": {"epss_score": 0.00034, "epss_percentile": 0.09619}, "CVE-2025-4411": {"epss_score": 0.00048, "epss_percentile": 0.15142}, "CVE-2025-4412": {"epss_score": 0.00019, "epss_percentile": 0.04063}, "CVE-2025-4413": {"epss_score": 0.00219, "epss_percentile": 0.44526}, "CVE-2025-4414": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-4415": {"epss_score": 0.00023, "epss_percentile": 0.05607}, "CVE-2025-4416": {"epss_score": 0.00062, "epss_percentile": 0.1961}, "CVE-2025-4417": {"epss_score": 0.00016, "epss_percentile": 0.0261}, "CVE-2025-4418": {"epss_score": 0.0001, "epss_percentile": 0.00823}, "CVE-2025-4419": {"epss_score": 0.00066, "epss_percentile": 0.20956}, "CVE-2025-4420": {"epss_score": 0.0004, "epss_percentile": 0.12029}, "CVE-2025-4421": {"epss_score": 0.00017, "epss_percentile": 0.03309}, "CVE-2025-4422": {"epss_score": 0.00017, "epss_percentile": 0.03309}, "CVE-2025-4423": {"epss_score": 0.00017, "epss_percentile": 0.03309}, "CVE-2025-4424": {"epss_score": 0.00023, "epss_percentile": 0.05482}, "CVE-2025-4425": {"epss_score": 0.00017, "epss_percentile": 0.03309}, "CVE-2025-4426": {"epss_score": 0.00015, "epss_percentile": 0.02539}, "CVE-2025-4427": {"epss_score": 0.91401, "epss_percentile": 0.99639}, "CVE-2025-4428": {"epss_score": 0.56853, "epss_percentile": 0.98038}, "CVE-2025-4429": {"epss_score": 0.00034, "epss_percentile": 0.09647}, "CVE-2025-4430": {"epss_score": 0.00067, "epss_percentile": 0.21124}, "CVE-2025-4431": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-4432": {"epss_score": 0.00188, "epss_percentile": 0.40876}, "CVE-2025-4433": {"epss_score": 0.00059, "epss_percentile": 0.18685}, "CVE-2025-4435": {"epss_score": 0.00086, "epss_percentile": 0.25441}, "CVE-2025-4437": {"epss_score": 0.00034, "epss_percentile": 0.0976}, "CVE-2025-4439": {"epss_score": 0.00035, "epss_percentile": 0.09811}, "CVE-2025-4440": {"epss_score": 0.0003, "epss_percentile": 0.08287}, "CVE-2025-4441": {"epss_score": 0.00169, "epss_percentile": 0.38647}, "CVE-2025-4442": {"epss_score": 0.00169, "epss_percentile": 0.38647}, "CVE-2025-4443": {"epss_score": 0.00102, "epss_percentile": 0.28774}, "CVE-2025-4444": {"epss_score": 0.0007, "epss_percentile": 0.21661}, "CVE-2025-4445": {"epss_score": 0.00102, "epss_percentile": 0.28774}, "CVE-2025-4446": {"epss_score": 0.0003, "epss_percentile": 0.08287}, "CVE-2025-4447": {"epss_score": 0.00063, "epss_percentile": 0.20076}, "CVE-2025-4448": {"epss_score": 0.00168, "epss_percentile": 0.38467}, "CVE-2025-4449": {"epss_score": 0.00168, "epss_percentile": 0.38467}, "CVE-2025-4450": {"epss_score": 0.00168, "epss_percentile": 0.38467}, "CVE-2025-4451": {"epss_score": 0.00168, "epss_percentile": 0.38467}, "CVE-2025-4452": {"epss_score": 0.00168, "epss_percentile": 0.38467}, "CVE-2025-4453": {"epss_score": 0.00102, "epss_percentile": 0.28774}, "CVE-2025-4454": {"epss_score": 0.00102, "epss_percentile": 0.28774}, "CVE-2025-4455": {"epss_score": 0.00013, "epss_percentile": 0.01477}, "CVE-2025-4456": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-4457": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-4458": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-4459": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-4460": {"epss_score": 0.0004, "epss_percentile": 0.11975}, "CVE-2025-4461": {"epss_score": 0.00032, "epss_percentile": 0.09107}, "CVE-2025-4462": {"epss_score": 0.00284, "epss_percentile": 0.51476}, "CVE-2025-4463": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4464": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4465": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4466": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4467": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4468": {"epss_score": 0.00083, "epss_percentile": 0.2476}, "CVE-2025-4469": {"epss_score": 0.00029, "epss_percentile": 0.07609}, "CVE-2025-4470": {"epss_score": 0.00029, "epss_percentile": 0.07609}, "CVE-2025-4471": {"epss_score": 0.0002, "epss_percentile": 0.04552}, "CVE-2025-4472": {"epss_score": 0.00022, "epss_percentile": 0.04997}, "CVE-2025-4473": {"epss_score": 0.00093, "epss_percentile": 0.26645}, "CVE-2025-4474": {"epss_score": 0.00078, "epss_percentile": 0.23738}, "CVE-2025-4476": {"epss_score": 0.00042, "epss_percentile": 0.12791}, "CVE-2025-4477": {"epss_score": 0.00147, "epss_percentile": 0.35684}, "CVE-2025-4478": {"epss_score": 0.0009, "epss_percentile": 0.26148}, "CVE-2025-4479": {"epss_score": 0.00028, "epss_percentile": 0.07566}, "CVE-2025-4480": {"epss_score": 0.00022, "epss_percentile": 0.04997}, "CVE-2025-4481": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4482": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-4483": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4484": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4485": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4486": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4487": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4488": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4489": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4490": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4491": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4492": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4493": {"epss_score": 0.00039, "epss_percentile": 0.11591}, "CVE-2025-4494": {"epss_score": 0.00274, "epss_percentile": 0.50575}, "CVE-2025-4495": {"epss_score": 0.0003, "epss_percentile": 0.08301}, "CVE-2025-4496": {"epss_score": 0.00193, "epss_percentile": 0.4138}, "CVE-2025-4497": {"epss_score": 0.00022, "epss_percentile": 0.04997}, "CVE-2025-4498": {"epss_score": 0.00022, "epss_percentile": 0.04997}, "CVE-2025-4499": {"epss_score": 0.00022, "epss_percentile": 0.04997}, "CVE-2025-4500": {"epss_score": 0.00022, "epss_percentile": 0.04997}, "CVE-2025-4501": {"epss_score": 0.00022, "epss_percentile": 0.04997}, "CVE-2025-4502": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4503": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4504": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4505": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4506": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4507": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4508": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4509": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4510": {"epss_score": 0.00027, "epss_percentile": 0.06924}, "CVE-2025-4511": {"epss_score": 0.0006, "epss_percentile": 0.18962}, "CVE-2025-4512": {"epss_score": 0.0003, "epss_percentile": 0.08089}, "CVE-2025-4513": {"epss_score": 0.0006, "epss_percentile": 0.19157}, "CVE-2025-4514": {"epss_score": 0.00043, "epss_percentile": 0.13012}, "CVE-2025-4515": {"epss_score": 0.00041, "epss_percentile": 0.12294}, "CVE-2025-4516": {"epss_score": 0.00023, "epss_percentile": 0.05418}, "CVE-2025-4517": {"epss_score": 0.00053, "epss_percentile": 0.16874}, "CVE-2025-4519": {"epss_score": 0.00051, "epss_percentile": 0.16328}, "CVE-2025-4520": {"epss_score": 0.00034, "epss_percentile": 0.09534}, "CVE-2025-4522": {"epss_score": 0.00038, "epss_percentile": 0.11131}, "CVE-2025-4523": {"epss_score": 0.00037, "epss_percentile": 0.10993}, "CVE-2025-4524": {"epss_score": 0.00679, "epss_percentile": 0.71016}, "CVE-2025-4525": {"epss_score": 0.00019, "epss_percentile": 0.04254}, "CVE-2025-4526": {"epss_score": 0.00023, "epss_percentile": 0.05504}, "CVE-2025-4527": {"epss_score": 0.00029, "epss_percentile": 0.07658}, "CVE-2025-4528": {"epss_score": 0.00073, "epss_percentile": 0.22614}, "CVE-2025-4529": {"epss_score": 0.00048, "epss_percentile": 0.15002}, "CVE-2025-4530": {"epss_score": 0.00048, "epss_percentile": 0.15002}, "CVE-2025-4531": {"epss_score": 0.00042, "epss_percentile": 0.12752}, "CVE-2025-4532": {"epss_score": 0.00013, "epss_percentile": 0.01672}, "CVE-2025-4533": {"epss_score": 0.00138, "epss_percentile": 0.34378}, "CVE-2025-4534": {"epss_score": 0.00036, "epss_percentile": 0.10163}, "CVE-2025-4535": {"epss_score": 0.00045, "epss_percentile": 0.13796}, "CVE-2025-4536": {"epss_score": 0.00045, "epss_percentile": 0.13796}, "CVE-2025-4537": {"epss_score": 0.00017, "epss_percentile": 0.03138}, "CVE-2025-4538": {"epss_score": 0.00071, "epss_percentile": 0.22137}, "CVE-2025-4539": {"epss_score": 0.00021, "epss_percentile": 0.0479}, "CVE-2025-4540": {"epss_score": 0.0002, "epss_percentile": 0.04584}, "CVE-2025-4541": {"epss_score": 0.00044, "epss_percentile": 0.13565}, "CVE-2025-4542": {"epss_score": 0.00022, "epss_percentile": 0.05059}, "CVE-2025-4543": {"epss_score": 0.0003, "epss_percentile": 0.08183}, "CVE-2025-4544": {"epss_score": 0.00231, "epss_percentile": 0.45797}, "CVE-2025-4545": {"epss_score": 0.00103, "epss_percentile": 0.29015}, "CVE-2025-4546": {"epss_score": 0.00063, "epss_percentile": 0.19943}, "CVE-2025-4547": {"epss_score": 0.00037, "epss_percentile": 0.10988}, "CVE-2025-4548": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4549": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4550": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4551": {"epss_score": 0.00029, "epss_percentile": 0.07751}, "CVE-2025-4552": {"epss_score": 0.00095, "epss_percentile": 0.27144}, "CVE-2025-4553": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4554": {"epss_score": 0.00038, "epss_percentile": 0.11316}, "CVE-2025-4555": {"epss_score": 0.00183, "epss_percentile": 0.40332}, "CVE-2025-4556": {"epss_score": 0.01007, "epss_percentile": 0.76562}, "CVE-2025-4557": {"epss_score": 0.00178, "epss_percentile": 0.3964}, "CVE-2025-4558": {"epss_score": 0.00171, "epss_percentile": 0.38799}, "CVE-2025-4559": {"epss_score": 0.00133, "epss_percentile": 0.33693}, "CVE-2025-4560": {"epss_score": 0.00066, "epss_percentile": 0.20743}, "CVE-2025-4561": {"epss_score": 0.00336, "epss_percentile": 0.55927}, "CVE-2025-4563": {"epss_score": 0.00027, "epss_percentile": 0.06834}, "CVE-2025-4564": {"epss_score": 0.01418, "epss_percentile": 0.80155}, "CVE-2025-4565": {"epss_score": 0.00017, "epss_percentile": 0.03495}, "CVE-2025-4566": {"epss_score": 0.00037, "epss_percentile": 0.10645}, "CVE-2025-4567": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2025-4568": {"epss_score": 0.00038, "epss_percentile": 0.11132}, "CVE-2025-4569": {"epss_score": 0.00058, "epss_percentile": 0.18613}, "CVE-2025-4570": {"epss_score": 0.00058, "epss_percentile": 0.18613}, "CVE-2025-4571": {"epss_score": 0.00064, "epss_percentile": 0.20291}, "CVE-2025-4573": {"epss_score": 0.0003, "epss_percentile": 0.08083}, "CVE-2025-4574": {"epss_score": 0.0005, "epss_percentile": 0.15861}, "CVE-2025-4575": {"epss_score": 0.00019, "epss_percentile": 0.04336}, "CVE-2025-4576": {"epss_score": 0.00021, "epss_percentile": 0.04803}, "CVE-2025-4577": {"epss_score": 0.00026, "epss_percentile": 0.06581}, "CVE-2025-4578": {"epss_score": 0.00216, "epss_percentile": 0.4419}, "CVE-2025-4579": {"epss_score": 0.00201, "epss_percentile": 0.42344}, "CVE-2025-4580": {"epss_score": 0.00021, "epss_percentile": 0.04743}, "CVE-2025-4581": {"epss_score": 0.00056, "epss_percentile": 0.17727}, "CVE-2025-4582": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-4583": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-4584": {"epss_score": 0.00025, "epss_percentile": 0.06378}, "CVE-2025-4585": {"epss_score": 0.00025, "epss_percentile": 0.06378}, "CVE-2025-4586": {"epss_score": 0.00025, "epss_percentile": 0.06378}, "CVE-2025-4587": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-4588": {"epss_score": 0.00027, "epss_percentile": 0.06804}, "CVE-2025-4589": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-4590": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-4591": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-4592": {"epss_score": 0.00014, "epss_percentile": 0.0178}, "CVE-2025-4593": {"epss_score": 0.00041, "epss_percentile": 0.124}, "CVE-2025-4594": {"epss_score": 0.00024, "epss_percentile": 0.05887}, "CVE-2025-4595": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-4597": {"epss_score": 0.00036, "epss_percentile": 0.10535}, "CVE-2025-4598": {"epss_score": 0.00041, "epss_percentile": 0.12294}, "CVE-2025-4599": {"epss_score": 0.00019, "epss_percentile": 0.04325}, "CVE-2025-4600": {"epss_score": 0.00019, "epss_percentile": 0.04059}, "CVE-2025-4601": {"epss_score": 0.00075, "epss_percentile": 0.23073}, "CVE-2025-4602": {"epss_score": 0.00107, "epss_percentile": 0.29615}, "CVE-2025-4603": {"epss_score": 0.01153, "epss_percentile": 0.78053}, "CVE-2025-4604": {"epss_score": 0.00021, "epss_percentile": 0.04757}, "CVE-2025-4605": {"epss_score": 0.00026, "epss_percentile": 0.06515}, "CVE-2025-4606": {"epss_score": 0.00071, "epss_percentile": 0.22185}, "CVE-2025-4607": {"epss_score": 0.00266, "epss_percentile": 0.49944}, "CVE-2025-4608": {"epss_score": 0.00037, "epss_percentile": 0.10645}, "CVE-2025-4609": {"epss_score": 0.00119, "epss_percentile": 0.31583}, "CVE-2025-4610": {"epss_score": 0.00045, "epss_percentile": 0.13762}, "CVE-2025-4611": {"epss_score": 0.00015, "epss_percentile": 0.02187}, "CVE-2025-4613": {"epss_score": 0.00065, "epss_percentile": 0.20463}, "CVE-2025-4614": {"epss_score": 0.0004, "epss_percentile": 0.11927}, "CVE-2025-4615": {"epss_score": 0.00072, "epss_percentile": 0.22242}, "CVE-2025-4616": {"epss_score": 9e-05, "epss_percentile": 0.00706}, "CVE-2025-4617": {"epss_score": 0.00018, "epss_percentile": 0.03913}, "CVE-2025-4618": {"epss_score": 8e-05, "epss_percentile": 0.00507}, "CVE-2025-4619": {"epss_score": 0.00076, "epss_percentile": 0.23263}, "CVE-2025-4631": {"epss_score": 0.0035, "epss_percentile": 0.56956}, "CVE-2025-4632": {"epss_score": 0.41169, "epss_percentile": 0.97257}, "CVE-2025-4633": {"epss_score": 0.00037, "epss_percentile": 0.10766}, "CVE-2025-4634": {"epss_score": 0.00031, "epss_percentile": 0.08531}, "CVE-2025-4635": {"epss_score": 0.00375, "epss_percentile": 0.58603}, "CVE-2025-4636": {"epss_score": 0.00019, "epss_percentile": 0.04281}, "CVE-2025-4637": {"epss_score": 0.00263, "epss_percentile": 0.49547}, "CVE-2025-4638": {"epss_score": 0.00062, "epss_percentile": 0.19724}, "CVE-2025-4639": {"epss_score": 0.00042, "epss_percentile": 0.12602}, "CVE-2025-4640": {"epss_score": 0.00044, "epss_percentile": 0.13505}, "CVE-2025-4641": {"epss_score": 0.00087, "epss_percentile": 0.25571}, "CVE-2025-4643": {"epss_score": 0.00112, "epss_percentile": 0.30414}, "CVE-2025-4644": {"epss_score": 0.00075, "epss_percentile": 0.22943}, "CVE-2025-4645": {"epss_score": 0.00028, "epss_percentile": 0.07484}, "CVE-2025-4646": {"epss_score": 0.00046, "epss_percentile": 0.14426}, "CVE-2025-4647": {"epss_score": 0.00029, "epss_percentile": 0.07765}, "CVE-2025-4648": {"epss_score": 0.00044, "epss_percentile": 0.13503}, "CVE-2025-4649": {"epss_score": 0.00024, "epss_percentile": 0.05974}, "CVE-2025-4650": {"epss_score": 0.00029, "epss_percentile": 0.07865}, "CVE-2025-4652": {"epss_score": 0.00036, "epss_percentile": 0.10231}, "CVE-2025-4653": {"epss_score": 0.30772, "epss_percentile": 0.96567}, "CVE-2025-4654": {"epss_score": 0.0008, "epss_percentile": 0.24009}, "CVE-2025-4655": {"epss_score": 0.0003, "epss_percentile": 0.08176}, "CVE-2025-4656": {"epss_score": 0.00013, "epss_percentile": 0.01699}, "CVE-2025-4657": {"epss_score": 0.00017, "epss_percentile": 0.03496}, "CVE-2025-4658": {"epss_score": 0.00041, "epss_percentile": 0.12456}, "CVE-2025-4659": {"epss_score": 0.00055, "epss_percentile": 0.17479}, "CVE-2025-4660": {"epss_score": 0.00564, "epss_percentile": 0.67742}, "CVE-2025-4661": {"epss_score": 0.00036, "epss_percentile": 0.10271}, "CVE-2025-4662": {"epss_score": 0.00015, "epss_percentile": 0.02585}, "CVE-2025-4663": {"epss_score": 0.00023, "epss_percentile": 0.05428}, "CVE-2025-4664": {"epss_score": 0.00013, "epss_percentile": 0.01607}, "CVE-2025-4665": {"epss_score": 0.00118, "epss_percentile": 0.31471}, "CVE-2025-4666": {"epss_score": 0.00047, "epss_percentile": 0.14652}, "CVE-2025-4667": {"epss_score": 0.00052, "epss_percentile": 0.16562}, "CVE-2025-4669": {"epss_score": 0.00039, "epss_percentile": 0.11458}, "CVE-2025-4670": {"epss_score": 0.00024, "epss_percentile": 0.05887}, "CVE-2025-4671": {"epss_score": 0.00045, "epss_percentile": 0.13762}, "CVE-2025-4672": {"epss_score": 0.00078, "epss_percentile": 0.23661}, "CVE-2025-4673": {"epss_score": 0.00013, "epss_percentile": 0.01453}, "CVE-2025-4674": {"epss_score": 8e-05, "epss_percentile": 0.00477}, "CVE-2025-4675": {"epss_score": 0.00018, "epss_percentile": 0.03857}, "CVE-2025-4676": {"epss_score": 0.00027, "epss_percentile": 0.07083}, "CVE-2025-4677": {"epss_score": 0.00025, "epss_percentile": 0.06259}, "CVE-2025-4678": {"epss_score": 0.00238, "epss_percentile": 0.46804}, "CVE-2025-4679": {"epss_score": 0.00017, "epss_percentile": 0.03322}, "CVE-2025-4680": {"epss_score": 0.00033, "epss_percentile": 0.09159}, "CVE-2025-4681": {"epss_score": 0.0002, "epss_percentile": 0.04542}, "CVE-2025-4682": {"epss_score": 0.0004, "epss_percentile": 0.12029}, "CVE-2025-4683": {"epss_score": 0.00044, "epss_percentile": 0.13635}, "CVE-2025-4684": {"epss_score": 0.00027, "epss_percentile": 0.06804}, "CVE-2025-4685": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-4687": {"epss_score": 0.00056, "epss_percentile": 0.17917}, "CVE-2025-4688": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-4689": {"epss_score": 0.00257, "epss_percentile": 0.48914}, "CVE-2025-4690": {"epss_score": 0.00049, "epss_percentile": 0.15465}, "CVE-2025-4691": {"epss_score": 0.00037, "epss_percentile": 0.10982}, "CVE-2025-4692": {"epss_score": 0.0004, "epss_percentile": 0.12064}, "CVE-2025-4695": {"epss_score": 0.00044, "epss_percentile": 0.13565}, "CVE-2025-4696": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-4697": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4698": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4699": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4700": {"epss_score": 0.00046, "epss_percentile": 0.142}, "CVE-2025-4701": {"epss_score": 0.00054, "epss_percentile": 0.17276}, "CVE-2025-4702": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4703": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4704": {"epss_score": 0.00031, "epss_percentile": 0.08504}, "CVE-2025-4705": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4706": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-4707": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4708": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4709": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4710": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4711": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4712": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4713": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4714": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4715": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4716": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4717": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4718": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4719": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4720": {"epss_score": 0.00074, "epss_percentile": 0.22749}, "CVE-2025-4721": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4722": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4723": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4724": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4725": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4726": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4727": {"epss_score": 0.00149, "epss_percentile": 0.36045}, "CVE-2025-4728": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4729": {"epss_score": 0.00832, "epss_percentile": 0.74058}, "CVE-2025-4730": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2025-4731": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2025-4732": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2025-4733": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2025-4734": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4735": {"epss_score": 0.00087, "epss_percentile": 0.25597}, "CVE-2025-4736": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4737": {"epss_score": 7e-05, "epss_percentile": 0.00439}, "CVE-2025-4738": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-4739": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-4740": {"epss_score": 0.00058, "epss_percentile": 0.18304}, "CVE-2025-4741": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4742": {"epss_score": 0.00054, "epss_percentile": 0.17276}, "CVE-2025-4743": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-4744": {"epss_score": 0.00029, "epss_percentile": 0.07954}, "CVE-2025-4745": {"epss_score": 0.00029, "epss_percentile": 0.07954}, "CVE-2025-4746": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4747": {"epss_score": 0.0042, "epss_percentile": 0.61439}, "CVE-2025-4748": {"epss_score": 0.00047, "epss_percentile": 0.14892}, "CVE-2025-4749": {"epss_score": 0.00256, "epss_percentile": 0.48831}, "CVE-2025-4750": {"epss_score": 0.00103, "epss_percentile": 0.29015}, "CVE-2025-4751": {"epss_score": 0.00052, "epss_percentile": 0.16603}, "CVE-2025-4752": {"epss_score": 0.00057, "epss_percentile": 0.18008}, "CVE-2025-4753": {"epss_score": 0.00057, "epss_percentile": 0.18008}, "CVE-2025-4754": {"epss_score": 0.00109, "epss_percentile": 0.30061}, "CVE-2025-4755": {"epss_score": 0.00138, "epss_percentile": 0.34465}, "CVE-2025-4756": {"epss_score": 0.0026, "epss_percentile": 0.49099}, "CVE-2025-4757": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4758": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4759": {"epss_score": 0.00033, "epss_percentile": 0.09192}, "CVE-2025-4760": {"epss_score": 0.00038, "epss_percentile": 0.11057}, "CVE-2025-4761": {"epss_score": 0.00036, "epss_percentile": 0.10361}, "CVE-2025-4762": {"epss_score": 0.00148, "epss_percentile": 0.35862}, "CVE-2025-4765": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4766": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4767": {"epss_score": 0.0003, "epss_percentile": 0.08023}, "CVE-2025-4768": {"epss_score": 0.00043, "epss_percentile": 0.12995}, "CVE-2025-4769": {"epss_score": 0.00018, "epss_percentile": 0.03713}, "CVE-2025-4770": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-4771": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4772": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4773": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4774": {"epss_score": 0.00025, "epss_percentile": 0.06378}, "CVE-2025-4775": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-4776": {"epss_score": 0.00029, "epss_percentile": 0.07681}, "CVE-2025-4777": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-4778": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-4779": {"epss_score": 0.00099, "epss_percentile": 0.28371}, "CVE-2025-4780": {"epss_score": 0.00039, "epss_percentile": 0.11613}, "CVE-2025-4781": {"epss_score": 0.00055, "epss_percentile": 0.17423}, "CVE-2025-4782": {"epss_score": 0.00044, "epss_percentile": 0.13565}, "CVE-2025-4783": {"epss_score": 0.00024, "epss_percentile": 0.05986}, "CVE-2025-4784": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-4785": {"epss_score": 0.00055, "epss_percentile": 0.17371}, "CVE-2025-4786": {"epss_score": 0.00044, "epss_percentile": 0.13565}, "CVE-2025-4787": {"epss_score": 0.00044, "epss_percentile": 0.13565}, "CVE-2025-4788": {"epss_score": 0.00094, "epss_percentile": 0.26989}, "CVE-2025-4789": {"epss_score": 0.00094, "epss_percentile": 0.26989}, "CVE-2025-4790": {"epss_score": 0.00094, "epss_percentile": 0.26989}, "CVE-2025-4791": {"epss_score": 0.00094, "epss_percentile": 0.26989}, "CVE-2025-4792": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-4793": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4794": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4795": {"epss_score": 0.00035, "epss_percentile": 0.09974}, "CVE-2025-4796": {"epss_score": 0.00051, "epss_percentile": 0.16141}, "CVE-2025-4797": {"epss_score": 0.00198, "epss_percentile": 0.42066}, "CVE-2025-4798": {"epss_score": 0.00049, "epss_percentile": 0.15496}, "CVE-2025-4799": {"epss_score": 0.01598, "epss_percentile": 0.81248}, "CVE-2025-4800": {"epss_score": 0.00447, "epss_percentile": 0.6298}, "CVE-2025-4802": {"epss_score": 0.00012, "epss_percentile": 0.01164}, "CVE-2025-4803": {"epss_score": 0.00409, "epss_percentile": 0.60722}, "CVE-2025-4804": {"epss_score": 0.00076, "epss_percentile": 0.23155}, "CVE-2025-4805": {"epss_score": 0.00076, "epss_percentile": 0.23155}, "CVE-2025-4806": {"epss_score": 0.00044, "epss_percentile": 0.13565}, "CVE-2025-4807": {"epss_score": 0.00302, "epss_percentile": 0.53105}, "CVE-2025-4808": {"epss_score": 0.00055, "epss_percentile": 0.17423}, "CVE-2025-4809": {"epss_score": 0.00248, "epss_percentile": 0.47965}, "CVE-2025-4810": {"epss_score": 0.00248, "epss_percentile": 0.47965}, "CVE-2025-4811": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4812": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4813": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4814": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4815": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4816": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4817": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4818": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4819": {"epss_score": 0.00059, "epss_percentile": 0.18722}, "CVE-2025-4820": {"epss_score": 0.00247, "epss_percentile": 0.4785}, "CVE-2025-4821": {"epss_score": 0.00237, "epss_percentile": 0.46658}, "CVE-2025-4822": {"epss_score": 0.00012, "epss_percentile": 0.01153}, "CVE-2025-4823": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2025-4824": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2025-4825": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2025-4826": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2025-4827": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2025-4828": {"epss_score": 0.01524, "epss_percentile": 0.80845}, "CVE-2025-4829": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2025-4830": {"epss_score": 0.00295, "epss_percentile": 0.52475}, "CVE-2025-4831": {"epss_score": 0.00165, "epss_percentile": 0.38125}, "CVE-2025-4832": {"epss_score": 0.00165, "epss_percentile": 0.38125}, "CVE-2025-4833": {"epss_score": 0.00165, "epss_percentile": 0.38125}, "CVE-2025-4834": {"epss_score": 0.00165, "epss_percentile": 0.38125}, "CVE-2025-4835": {"epss_score": 0.00165, "epss_percentile": 0.38125}, "CVE-2025-4836": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-4837": {"epss_score": 0.00035, "epss_percentile": 0.09971}, "CVE-2025-4838": {"epss_score": 0.00034, "epss_percentile": 0.09468}, "CVE-2025-4839": {"epss_score": 0.00033, "epss_percentile": 0.09337}, "CVE-2025-4840": {"epss_score": 0.00074, "epss_percentile": 0.2283}, "CVE-2025-4841": {"epss_score": 0.0009, "epss_percentile": 0.26155}, "CVE-2025-4842": {"epss_score": 0.0009, "epss_percentile": 0.26155}, "CVE-2025-4843": {"epss_score": 0.0009, "epss_percentile": 0.26155}, "CVE-2025-4844": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-4845": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-4846": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-4847": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-4848": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-4849": {"epss_score": 0.01087, "epss_percentile": 0.77433}, "CVE-2025-4850": {"epss_score": 0.00832, "epss_percentile": 0.74058}, "CVE-2025-4851": {"epss_score": 0.01087, "epss_percentile": 0.77433}, "CVE-2025-4852": {"epss_score": 0.00085, "epss_percentile": 0.25161}, "CVE-2025-4855": {"epss_score": 0.0022, "epss_percentile": 0.44613}, "CVE-2025-4857": {"epss_score": 0.00126, "epss_percentile": 0.32622}, "CVE-2025-4858": {"epss_score": 0.00037, "epss_percentile": 0.10653}, "CVE-2025-4859": {"epss_score": 0.00037, "epss_percentile": 0.10653}, "CVE-2025-4860": {"epss_score": 0.00037, "epss_percentile": 0.10653}, "CVE-2025-4861": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4862": {"epss_score": 0.00052, "epss_percentile": 0.16465}, "CVE-2025-4863": {"epss_score": 0.00032, "epss_percentile": 0.09039}, "CVE-2025-4864": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4865": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4866": {"epss_score": 0.00056, "epss_percentile": 0.17726}, "CVE-2025-4867": {"epss_score": 0.00127, "epss_percentile": 0.32832}, "CVE-2025-4868": {"epss_score": 0.00032, "epss_percentile": 0.08767}, "CVE-2025-4869": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4870": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4871": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-4872": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-4873": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4874": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4875": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4876": {"epss_score": 0.00011, "epss_percentile": 0.01045}, "CVE-2025-4877": {"epss_score": 0.00015, "epss_percentile": 0.02269}, "CVE-2025-4878": {"epss_score": 0.00016, "epss_percentile": 0.03029}, "CVE-2025-4879": {"epss_score": 0.00018, "epss_percentile": 0.03613}, "CVE-2025-4880": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4881": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4882": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4883": {"epss_score": 0.00222, "epss_percentile": 0.44807}, "CVE-2025-4884": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4885": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4886": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4887": {"epss_score": 0.00043, "epss_percentile": 0.13232}, "CVE-2025-4888": {"epss_score": 0.00022, "epss_percentile": 0.04997}, "CVE-2025-4889": {"epss_score": 0.00022, "epss_percentile": 0.04997}, "CVE-2025-4890": {"epss_score": 0.00022, "epss_percentile": 0.04997}, "CVE-2025-4891": {"epss_score": 0.00022, "epss_percentile": 0.04997}, "CVE-2025-4892": {"epss_score": 0.00022, "epss_percentile": 0.04997}, "CVE-2025-4893": {"epss_score": 0.00032, "epss_percentile": 0.08767}, "CVE-2025-4894": {"epss_score": 0.00014, "epss_percentile": 0.02086}, "CVE-2025-4895": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4896": {"epss_score": 0.00168, "epss_percentile": 0.38457}, "CVE-2025-4897": {"epss_score": 0.00231, "epss_percentile": 0.45812}, "CVE-2025-4898": {"epss_score": 0.00068, "epss_percentile": 0.21365}, "CVE-2025-4899": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4900": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4901": {"epss_score": 0.00101, "epss_percentile": 0.28623}, "CVE-2025-4902": {"epss_score": 0.00088, "epss_percentile": 0.25758}, "CVE-2025-4903": {"epss_score": 0.00289, "epss_percentile": 0.51982}, "CVE-2025-4904": {"epss_score": 0.00072, "epss_percentile": 0.22369}, "CVE-2025-4905": {"epss_score": 0.00035, "epss_percentile": 0.09908}, "CVE-2025-4906": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4907": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4908": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4909": {"epss_score": 0.00064, "epss_percentile": 0.20151}, "CVE-2025-4910": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4911": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4912": {"epss_score": 0.00158, "epss_percentile": 0.3715}, "CVE-2025-4913": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4914": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4915": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4916": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4917": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4918": {"epss_score": 0.00121, "epss_percentile": 0.31875}, "CVE-2025-4919": {"epss_score": 0.00043, "epss_percentile": 0.1294}, "CVE-2025-4922": {"epss_score": 0.00019, "epss_percentile": 0.04202}, "CVE-2025-4923": {"epss_score": 0.00062, "epss_percentile": 0.19629}, "CVE-2025-4924": {"epss_score": 0.00036, "epss_percentile": 0.10361}, "CVE-2025-4925": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4926": {"epss_score": 0.00072, "epss_percentile": 0.22427}, "CVE-2025-4927": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-4928": {"epss_score": 0.00057, "epss_percentile": 0.18064}, "CVE-2025-4929": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4930": {"epss_score": 0.00036, "epss_percentile": 0.10361}, "CVE-2025-4931": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-4932": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-4933": {"epss_score": 0.00044, "epss_percentile": 0.13565}, "CVE-2025-4934": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4935": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4936": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-4937": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4938": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-4939": {"epss_score": 0.00038, "epss_percentile": 0.1134}, "CVE-2025-4940": {"epss_score": 0.00029, "epss_percentile": 0.07758}, "CVE-2025-4941": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-4943": {"epss_score": 0.0003, "epss_percentile": 0.0819}, "CVE-2025-4944": {"epss_score": 0.00032, "epss_percentile": 0.08985}, "CVE-2025-4945": {"epss_score": 0.00141, "epss_percentile": 0.34904}, "CVE-2025-4946": {"epss_score": 0.01011, "epss_percentile": 0.76608}, "CVE-2025-4947": {"epss_score": 0.00018, "epss_percentile": 0.03941}, "CVE-2025-4948": {"epss_score": 0.00157, "epss_percentile": 0.37128}, "CVE-2025-4949": {"epss_score": 0.00075, "epss_percentile": 0.23019}, "CVE-2025-4951": {"epss_score": 0.00016, "epss_percentile": 0.02907}, "CVE-2025-4952": {"epss_score": 0.00012, "epss_percentile": 0.01359}, "CVE-2025-4953": {"epss_score": 0.00063, "epss_percentile": 0.19917}, "CVE-2025-4954": {"epss_score": 0.00074, "epss_percentile": 0.22777}, "CVE-2025-4955": {"epss_score": 0.00061, "epss_percentile": 0.19477}, "CVE-2025-4956": {"epss_score": 0.00063, "epss_percentile": 0.20048}, "CVE-2025-4957": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-4962": {"epss_score": 0.00052, "epss_percentile": 0.16523}, "CVE-2025-4963": {"epss_score": 0.00026, "epss_percentile": 0.06561}, "CVE-2025-4964": {"epss_score": 0.00029, "epss_percentile": 0.07731}, "CVE-2025-4965": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-4966": {"epss_score": 0.00016, "epss_percentile": 0.02911}, "CVE-2025-4967": {"epss_score": 0.00046, "epss_percentile": 0.14296}, "CVE-2025-4968": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-4969": {"epss_score": 0.00124, "epss_percentile": 0.3241}, "CVE-2025-4970": {"epss_score": 4e-05, "epss_percentile": 0.00169}, "CVE-2025-4971": {"epss_score": 0.00331, "epss_percentile": 0.55513}, "CVE-2025-4972": {"epss_score": 0.00014, "epss_percentile": 0.02085}, "CVE-2025-4973": {"epss_score": 0.00528, "epss_percentile": 0.6657}, "CVE-2025-4975": {"epss_score": 0.0002, "epss_percentile": 0.04542}, "CVE-2025-4976": {"epss_score": 0.00014, "epss_percentile": 0.02121}, "CVE-2025-4977": {"epss_score": 0.00045, "epss_percentile": 0.13913}, "CVE-2025-4978": {"epss_score": 0.0054, "epss_percentile": 0.67009}, "CVE-2025-4979": {"epss_score": 0.00015, "epss_percentile": 0.0217}, "CVE-2025-4980": {"epss_score": 0.00045, "epss_percentile": 0.13913}, "CVE-2025-4981": {"epss_score": 0.00275, "epss_percentile": 0.50645}, "CVE-2025-4983": {"epss_score": 0.00029, "epss_percentile": 0.07648}, "CVE-2025-4984": {"epss_score": 0.00029, "epss_percentile": 0.07648}, "CVE-2025-4985": {"epss_score": 0.00029, "epss_percentile": 0.07648}, "CVE-2025-4986": {"epss_score": 0.00029, "epss_percentile": 0.07648}, "CVE-2025-4987": {"epss_score": 0.00027, "epss_percentile": 0.06778}, "CVE-2025-4988": {"epss_score": 0.00029, "epss_percentile": 0.07648}, "CVE-2025-4989": {"epss_score": 0.00029, "epss_percentile": 0.07648}, "CVE-2025-4990": {"epss_score": 0.00029, "epss_percentile": 0.07648}, "CVE-2025-4991": {"epss_score": 0.00029, "epss_percentile": 0.07648}, "CVE-2025-4992": {"epss_score": 0.00029, "epss_percentile": 0.07648}, "CVE-2025-4993": {"epss_score": 0.00071, "epss_percentile": 0.22148}, "CVE-2025-4996": {"epss_score": 0.00022, "epss_percentile": 0.05144}, "CVE-2025-4997": {"epss_score": 0.00096, "epss_percentile": 0.27253}, "CVE-2025-4998": {"epss_score": 0.00096, "epss_percentile": 0.27253}, "CVE-2025-4999": {"epss_score": 0.00259, "epss_percentile": 0.49058}, "CVE-2025-50008": {"epss_score": 0.00051, "epss_percentile": 0.1606}, "CVE-2025-50009": {"epss_score": 0.00051, "epss_percentile": 0.1606}, "CVE-2025-50010": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-50011": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50012": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50013": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50014": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50015": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50016": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50017": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50018": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50019": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50020": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50021": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50022": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50023": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50024": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50025": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50026": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50027": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-50028": {"epss_score": 0.00054, "epss_percentile": 0.17191}, "CVE-2025-50029": {"epss_score": 0.00046, "epss_percentile": 0.14132}, "CVE-2025-50030": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50031": {"epss_score": 0.00051, "epss_percentile": 0.1629}, "CVE-2025-50032": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-50033": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50034": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-50035": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50036": {"epss_score": 0.00016, "epss_percentile": 0.03051}, "CVE-2025-50037": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50038": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50039": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-50040": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-50041": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50042": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50043": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50044": {"epss_score": 0.00016, "epss_percentile": 0.03051}, "CVE-2025-50045": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50046": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50047": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50048": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50049": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50050": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50051": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-50052": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-50053": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-50054": {"epss_score": 0.00015, "epss_percentile": 0.02281}, "CVE-2025-50055": {"epss_score": 0.00056, "epss_percentile": 0.1792}, "CVE-2025-50056": {"epss_score": 0.00177, "epss_percentile": 0.39501}, "CVE-2025-50057": {"epss_score": 0.00144, "epss_percentile": 0.3529}, "CVE-2025-50058": {"epss_score": 0.00162, "epss_percentile": 0.37638}, "CVE-2025-50059": {"epss_score": 0.00052, "epss_percentile": 0.16348}, "CVE-2025-50060": {"epss_score": 0.0006, "epss_percentile": 0.19136}, "CVE-2025-50061": {"epss_score": 0.00024, "epss_percentile": 0.05855}, "CVE-2025-50062": {"epss_score": 0.0006, "epss_percentile": 0.19136}, "CVE-2025-50063": {"epss_score": 0.00031, "epss_percentile": 0.08567}, "CVE-2025-50064": {"epss_score": 0.00022, "epss_percentile": 0.05242}, "CVE-2025-50065": {"epss_score": 0.00039, "epss_percentile": 0.11797}, "CVE-2025-50066": {"epss_score": 0.0003, "epss_percentile": 0.08221}, "CVE-2025-50067": {"epss_score": 0.0008, "epss_percentile": 0.24133}, "CVE-2025-50068": {"epss_score": 0.00036, "epss_percentile": 0.1032}, "CVE-2025-50069": {"epss_score": 0.00045, "epss_percentile": 0.14001}, "CVE-2025-50070": {"epss_score": 0.00013, "epss_percentile": 0.01689}, "CVE-2025-50071": {"epss_score": 0.00032, "epss_percentile": 0.0886}, "CVE-2025-50072": {"epss_score": 0.00015, "epss_percentile": 0.0244}, "CVE-2025-50073": {"epss_score": 0.00026, "epss_percentile": 0.06397}, "CVE-2025-50074": {"epss_score": 0.0005, "epss_percentile": 0.15947}, "CVE-2025-50075": {"epss_score": 0.0005, "epss_percentile": 0.15867}, "CVE-2025-50076": {"epss_score": 0.00058, "epss_percentile": 0.18309}, "CVE-2025-50077": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50078": {"epss_score": 0.00058, "epss_percentile": 0.18309}, "CVE-2025-50079": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50080": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50081": {"epss_score": 0.00025, "epss_percentile": 0.06323}, "CVE-2025-50082": {"epss_score": 0.00058, "epss_percentile": 0.18309}, "CVE-2025-50083": {"epss_score": 0.00058, "epss_percentile": 0.18309}, "CVE-2025-50084": {"epss_score": 0.00049, "epss_percentile": 0.15485}, "CVE-2025-50085": {"epss_score": 0.00049, "epss_percentile": 0.15485}, "CVE-2025-50086": {"epss_score": 0.00049, "epss_percentile": 0.15485}, "CVE-2025-50087": {"epss_score": 0.0004, "epss_percentile": 0.11968}, "CVE-2025-50088": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50089": {"epss_score": 0.00048, "epss_percentile": 0.14996}, "CVE-2025-50090": {"epss_score": 0.00012, "epss_percentile": 0.01208}, "CVE-2025-50091": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50092": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50093": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50094": {"epss_score": 0.00048, "epss_percentile": 0.14996}, "CVE-2025-50095": {"epss_score": 0.00048, "epss_percentile": 0.14996}, "CVE-2025-50096": {"epss_score": 0.00021, "epss_percentile": 0.0491}, "CVE-2025-50097": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50098": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50099": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50100": {"epss_score": 0.0004, "epss_percentile": 0.12068}, "CVE-2025-50101": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50102": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50103": {"epss_score": 0.00036, "epss_percentile": 0.10368}, "CVE-2025-50104": {"epss_score": 0.00053, "epss_percentile": 0.16975}, "CVE-2025-50105": {"epss_score": 0.0006, "epss_percentile": 0.19136}, "CVE-2025-50106": {"epss_score": 0.0018, "epss_percentile": 0.39896}, "CVE-2025-50107": {"epss_score": 0.00026, "epss_percentile": 0.06397}, "CVE-2025-50108": {"epss_score": 0.00024, "epss_percentile": 0.05855}, "CVE-2025-50109": {"epss_score": 8e-05, "epss_percentile": 0.00562}, "CVE-2025-50110": {"epss_score": 0.00022, "epss_percentile": 0.053}, "CVE-2025-50121": {"epss_score": 0.00479, "epss_percentile": 0.64435}, "CVE-2025-50122": {"epss_score": 0.00019, "epss_percentile": 0.04181}, "CVE-2025-50123": {"epss_score": 0.00031, "epss_percentile": 0.08465}, "CVE-2025-50124": {"epss_score": 0.00017, "epss_percentile": 0.03189}, "CVE-2025-50125": {"epss_score": 0.00095, "epss_percentile": 0.27229}, "CVE-2025-50126": {"epss_score": 0.00175, "epss_percentile": 0.39336}, "CVE-2025-50127": {"epss_score": 0.0005, "epss_percentile": 0.15858}, "CVE-2025-50128": {"epss_score": 0.00085, "epss_percentile": 0.25151}, "CVE-2025-50129": {"epss_score": 0.00318, "epss_percentile": 0.5444}, "CVE-2025-50130": {"epss_score": 0.00014, "epss_percentile": 0.0199}, "CVE-2025-50151": {"epss_score": 0.00263, "epss_percentile": 0.49549}, "CVE-2025-50152": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-50153": {"epss_score": 0.00067, "epss_percentile": 0.21149}, "CVE-2025-50154": {"epss_score": 0.11671, "epss_percentile": 0.93441}, "CVE-2025-50155": {"epss_score": 0.00168, "epss_percentile": 0.38446}, "CVE-2025-50156": {"epss_score": 0.00238, "epss_percentile": 0.46812}, "CVE-2025-50157": {"epss_score": 0.00238, "epss_percentile": 0.46812}, "CVE-2025-50158": {"epss_score": 0.00039, "epss_percentile": 0.11613}, "CVE-2025-50159": {"epss_score": 0.00066, "epss_percentile": 0.20842}, "CVE-2025-50160": {"epss_score": 0.00069, "epss_percentile": 0.21624}, "CVE-2025-50161": {"epss_score": 0.00066, "epss_percentile": 0.20842}, "CVE-2025-50162": {"epss_score": 0.00069, "epss_percentile": 0.21624}, "CVE-2025-50163": {"epss_score": 0.0007, "epss_percentile": 0.21768}, "CVE-2025-50164": {"epss_score": 0.00069, "epss_percentile": 0.21624}, "CVE-2025-50165": {"epss_score": 0.02496, "epss_percentile": 0.84906}, "CVE-2025-50166": {"epss_score": 0.00133, "epss_percentile": 0.33679}, "CVE-2025-50167": {"epss_score": 0.00036, "epss_percentile": 0.1049}, "CVE-2025-50168": {"epss_score": 0.00192, "epss_percentile": 0.41313}, "CVE-2025-50169": {"epss_score": 0.00051, "epss_percentile": 0.1633}, "CVE-2025-50170": {"epss_score": 0.00062, "epss_percentile": 0.19679}, "CVE-2025-50171": {"epss_score": 0.00081, "epss_percentile": 0.2423}, "CVE-2025-50172": {"epss_score": 0.12352, "epss_percentile": 0.93647}, "CVE-2025-50173": {"epss_score": 0.00116, "epss_percentile": 0.31065}, "CVE-2025-50174": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-50175": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-50176": {"epss_score": 0.00168, "epss_percentile": 0.38446}, "CVE-2025-50177": {"epss_score": 0.00105, "epss_percentile": 0.29394}, "CVE-2025-50178": {"epss_score": 0.00156, "epss_percentile": 0.37014}, "CVE-2025-50179": {"epss_score": 0.00017, "epss_percentile": 0.03229}, "CVE-2025-50181": {"epss_score": 0.00016, "epss_percentile": 0.02611}, "CVE-2025-50182": {"epss_score": 0.00013, "epss_percentile": 0.01725}, "CVE-2025-50183": {"epss_score": 0.00027, "epss_percentile": 0.06848}, "CVE-2025-50184": {"epss_score": 0.00136, "epss_percentile": 0.34062}, "CVE-2025-50185": {"epss_score": 0.00102, "epss_percentile": 0.28855}, "CVE-2025-50200": {"epss_score": 0.00016, "epss_percentile": 0.02904}, "CVE-2025-50201": {"epss_score": 0.58934, "epss_percentile": 0.98141}, "CVE-2025-50202": {"epss_score": 0.00064, "epss_percentile": 0.2018}, "CVE-2025-50213": {"epss_score": 0.00062, "epss_percentile": 0.1966}, "CVE-2025-50233": {"epss_score": 0.00075, "epss_percentile": 0.22899}, "CVE-2025-50234": {"epss_score": 0.00075, "epss_percentile": 0.22949}, "CVE-2025-50240": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-50251": {"epss_score": 0.00055, "epss_percentile": 0.17405}, "CVE-2025-50255": {"epss_score": 9e-05, "epss_percentile": 0.0066}, "CVE-2025-50258": {"epss_score": 0.00064, "epss_percentile": 0.20252}, "CVE-2025-50260": {"epss_score": 0.00079, "epss_percentile": 0.23968}, "CVE-2025-50262": {"epss_score": 0.00079, "epss_percentile": 0.23968}, "CVE-2025-50263": {"epss_score": 0.00064, "epss_percentile": 0.20252}, "CVE-2025-50270": {"epss_score": 0.00046, "epss_percentile": 0.14122}, "CVE-2025-50286": {"epss_score": 0.01992, "epss_percentile": 0.8318}, "CVE-2025-50340": {"epss_score": 0.0003, "epss_percentile": 0.08212}, "CVE-2025-50341": {"epss_score": 0.00046, "epss_percentile": 0.14181}, "CVE-2025-50343": {"epss_score": 0.00056, "epss_percentile": 0.17857}, "CVE-2025-50348": {"epss_score": 0.00447, "epss_percentile": 0.62981}, "CVE-2025-50349": {"epss_score": 0.00447, "epss_percentile": 0.62981}, "CVE-2025-50350": {"epss_score": 0.00113, "epss_percentile": 0.30691}, "CVE-2025-50360": {"epss_score": 0.00015, "epss_percentile": 0.02461}, "CVE-2025-50361": {"epss_score": 0.00017, "epss_percentile": 0.03277}, "CVE-2025-50363": {"epss_score": 0.00044, "epss_percentile": 0.13482}, "CVE-2025-50367": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-50369": {"epss_score": 0.00019, "epss_percentile": 0.04069}, "CVE-2025-50370": {"epss_score": 0.00019, "epss_percentile": 0.04069}, "CVE-2025-50383": {"epss_score": 0.00046, "epss_percentile": 0.14273}, "CVE-2025-50398": {"epss_score": 0.00053, "epss_percentile": 0.16881}, "CVE-2025-50399": {"epss_score": 0.00078, "epss_percentile": 0.238}, "CVE-2025-50401": {"epss_score": 0.00057, "epss_percentile": 0.18127}, "CVE-2025-50402": {"epss_score": 0.00078, "epss_percentile": 0.238}, "CVE-2025-50404": {"epss_score": 0.0008, "epss_percentile": 0.2417}, "CVE-2025-50405": {"epss_score": 0.00057, "epss_percentile": 0.18132}, "CVE-2025-50420": {"epss_score": 0.00042, "epss_percentile": 0.12829}, "CVE-2025-50422": {"epss_score": 0.00013, "epss_percentile": 0.01725}, "CVE-2025-50428": {"epss_score": 0.01861, "epss_percentile": 0.82591}, "CVE-2025-50433": {"epss_score": 0.00078, "epss_percentile": 0.23652}, "CVE-2025-50434": {"epss_score": 0.00061, "epss_percentile": 0.19493}, "CVE-2025-50454": {"epss_score": 0.00044, "epss_percentile": 0.13475}, "CVE-2025-50460": {"epss_score": 0.0138, "epss_percentile": 0.79865}, "CVE-2025-50461": {"epss_score": 0.00111, "epss_percentile": 0.30373}, "CVE-2025-50464": {"epss_score": 0.00086, "epss_percentile": 0.25386}, "CVE-2025-50465": {"epss_score": 0.00024, "epss_percentile": 0.05844}, "CVE-2025-50466": {"epss_score": 0.00031, "epss_percentile": 0.08622}, "CVE-2025-50467": {"epss_score": 0.00022, "epss_percentile": 0.05179}, "CVE-2025-50468": {"epss_score": 0.00032, "epss_percentile": 0.08776}, "CVE-2025-50472": {"epss_score": 0.00313, "epss_percentile": 0.54062}, "CVE-2025-50475": {"epss_score": 0.00405, "epss_percentile": 0.60506}, "CVE-2025-50477": {"epss_score": 0.00034, "epss_percentile": 0.09783}, "CVE-2025-50481": {"epss_score": 0.00065, "epss_percentile": 0.20583}, "CVE-2025-50484": {"epss_score": 0.0004, "epss_percentile": 0.11956}, "CVE-2025-50485": {"epss_score": 0.0004, "epss_percentile": 0.11956}, "CVE-2025-50486": {"epss_score": 0.0004, "epss_percentile": 0.11956}, "CVE-2025-50487": {"epss_score": 0.0004, "epss_percentile": 0.11956}, "CVE-2025-50488": {"epss_score": 0.0004, "epss_percentile": 0.11956}, "CVE-2025-50489": {"epss_score": 0.00114, "epss_percentile": 0.30746}, "CVE-2025-50490": {"epss_score": 0.00114, "epss_percentile": 0.30746}, "CVE-2025-50491": {"epss_score": 0.00029, "epss_percentile": 0.07653}, "CVE-2025-50492": {"epss_score": 0.00082, "epss_percentile": 0.24429}, "CVE-2025-50493": {"epss_score": 0.00089, "epss_percentile": 0.2582}, "CVE-2025-50494": {"epss_score": 0.00123, "epss_percentile": 0.323}, "CVE-2025-50503": {"epss_score": 0.00154, "epss_percentile": 0.36742}, "CVE-2025-50505": {"epss_score": 0.00018, "epss_percentile": 0.03853}, "CVE-2025-50515": {"epss_score": 0.00086, "epss_percentile": 0.25407}, "CVE-2025-50518": {"epss_score": 0.00085, "epss_percentile": 0.25058}, "CVE-2025-50526": {"epss_score": 0.00488, "epss_percentile": 0.64832}, "CVE-2025-50528": {"epss_score": 0.00084, "epss_percentile": 0.24939}, "CVE-2025-50538": {"epss_score": 0.00102, "epss_percentile": 0.28746}, "CVE-2025-50565": {"epss_score": 0.00042, "epss_percentile": 0.12831}, "CVE-2025-50567": {"epss_score": 0.00168, "epss_percentile": 0.38447}, "CVE-2025-50572": {"epss_score": 0.00039, "epss_percentile": 0.11776}, "CVE-2025-50574": {"epss_score": 0.00084, "epss_percentile": 0.24957}, "CVE-2025-50578": {"epss_score": 0.00434, "epss_percentile": 0.62282}, "CVE-2025-50579": {"epss_score": 0.0006, "epss_percentile": 0.19117}, "CVE-2025-50581": {"epss_score": 0.00036, "epss_percentile": 0.10202}, "CVE-2025-50582": {"epss_score": 0.0003, "epss_percentile": 0.08223}, "CVE-2025-50583": {"epss_score": 0.0003, "epss_percentile": 0.08223}, "CVE-2025-50584": {"epss_score": 0.0003, "epss_percentile": 0.08223}, "CVE-2025-50585": {"epss_score": 0.00045, "epss_percentile": 0.13916}, "CVE-2025-50586": {"epss_score": 0.00026, "epss_percentile": 0.06599}, "CVE-2025-50592": {"epss_score": 0.00027, "epss_percentile": 0.06788}, "CVE-2025-50594": {"epss_score": 0.0008, "epss_percentile": 0.24141}, "CVE-2025-50608": {"epss_score": 0.00128, "epss_percentile": 0.32993}, "CVE-2025-50609": {"epss_score": 0.00128, "epss_percentile": 0.32993}, "CVE-2025-50610": {"epss_score": 0.00128, "epss_percentile": 0.32993}, "CVE-2025-50611": {"epss_score": 0.00128, "epss_percentile": 0.32993}, "CVE-2025-50612": {"epss_score": 0.00128, "epss_percentile": 0.32993}, "CVE-2025-50613": {"epss_score": 0.00128, "epss_percentile": 0.32993}, "CVE-2025-50614": {"epss_score": 0.00128, "epss_percentile": 0.32993}, "CVE-2025-50615": {"epss_score": 0.00128, "epss_percentile": 0.32993}, "CVE-2025-50616": {"epss_score": 0.00128, "epss_percentile": 0.32993}, "CVE-2025-50617": {"epss_score": 0.00128, "epss_percentile": 0.32993}, "CVE-2025-50635": {"epss_score": 0.00099, "epss_percentile": 0.2842}, "CVE-2025-50641": {"epss_score": 0.00044, "epss_percentile": 0.13375}, "CVE-2025-50674": {"epss_score": 0.00048, "epss_percentile": 0.1527}, "CVE-2025-50675": {"epss_score": 5e-05, "epss_percentile": 0.0021}, "CVE-2025-50681": {"epss_score": 0.00158, "epss_percentile": 0.3716}, "CVE-2025-50688": {"epss_score": 0.00244, "epss_percentile": 0.47562}, "CVE-2025-50690": {"epss_score": 0.00212, "epss_percentile": 0.43724}, "CVE-2025-50691": {"epss_score": 0.00051, "epss_percentile": 0.16308}, "CVE-2025-50692": {"epss_score": 0.00123, "epss_percentile": 0.3225}, "CVE-2025-50693": {"epss_score": 0.00075, "epss_percentile": 0.22969}, "CVE-2025-50695": {"epss_score": 0.00033, "epss_percentile": 0.09341}, "CVE-2025-50699": {"epss_score": 0.00033, "epss_percentile": 0.09341}, "CVE-2025-50706": {"epss_score": 0.00624, "epss_percentile": 0.69566}, "CVE-2025-50707": {"epss_score": 0.00624, "epss_percentile": 0.69566}, "CVE-2025-50708": {"epss_score": 0.00057, "epss_percentile": 0.18051}, "CVE-2025-50709": {"epss_score": 0.00056, "epss_percentile": 0.17667}, "CVE-2025-50722": {"epss_score": 0.00641, "epss_percentile": 0.69986}, "CVE-2025-50733": {"epss_score": 0.00053, "epss_percentile": 0.1685}, "CVE-2025-50735": {"epss_score": 0.00471, "epss_percentile": 0.64025}, "CVE-2025-50736": {"epss_score": 0.00036, "epss_percentile": 0.10504}, "CVE-2025-50738": {"epss_score": 0.02484, "epss_percentile": 0.84881}, "CVE-2025-50739": {"epss_score": 0.00485, "epss_percentile": 0.64723}, "CVE-2025-50740": {"epss_score": 0.0002, "epss_percentile": 0.04611}, "CVE-2025-50753": {"epss_score": 0.00017, "epss_percentile": 0.03219}, "CVE-2025-50754": {"epss_score": 0.001, "epss_percentile": 0.28437}, "CVE-2025-50755": {"epss_score": 0.12461, "epss_percentile": 0.9368}, "CVE-2025-50756": {"epss_score": 0.00976, "epss_percentile": 0.76208}, "CVE-2025-50757": {"epss_score": 0.12461, "epss_percentile": 0.9368}, "CVE-2025-50777": {"epss_score": 0.0001, "epss_percentile": 0.00757}, "CVE-2025-50817": {"epss_score": 0.00065, "epss_percentile": 0.20434}, "CVE-2025-50819": {"epss_score": 0.00173, "epss_percentile": 0.39131}, "CVE-2025-50847": {"epss_score": 0.00104, "epss_percentile": 0.2911}, "CVE-2025-50848": {"epss_score": 0.00024, "epss_percentile": 0.05732}, "CVE-2025-50849": {"epss_score": 0.00038, "epss_percentile": 0.11345}, "CVE-2025-50850": {"epss_score": 0.00063, "epss_percentile": 0.19923}, "CVE-2025-50858": {"epss_score": 0.00068, "epss_percentile": 0.21301}, "CVE-2025-50859": {"epss_score": 0.00068, "epss_percentile": 0.21301}, "CVE-2025-50860": {"epss_score": 0.00042, "epss_percentile": 0.12672}, "CVE-2025-50861": {"epss_score": 0.00173, "epss_percentile": 0.39127}, "CVE-2025-50862": {"epss_score": 0.00023, "epss_percentile": 0.05441}, "CVE-2025-50864": {"epss_score": 0.00053, "epss_percentile": 0.16816}, "CVE-2025-50866": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-50867": {"epss_score": 0.00025, "epss_percentile": 0.06374}, "CVE-2025-50868": {"epss_score": 0.00029, "epss_percentile": 0.07817}, "CVE-2025-50869": {"epss_score": 0.0002, "epss_percentile": 0.04611}, "CVE-2025-50870": {"epss_score": 0.00181, "epss_percentile": 0.40024}, "CVE-2025-50891": {"epss_score": 0.00079, "epss_percentile": 0.23951}, "CVE-2025-50892": {"epss_score": 0.00017, "epss_percentile": 0.0311}, "CVE-2025-50897": {"epss_score": 0.00034, "epss_percentile": 0.09712}, "CVE-2025-50900": {"epss_score": 0.00336, "epss_percentile": 0.56003}, "CVE-2025-50901": {"epss_score": 0.00141, "epss_percentile": 0.3483}, "CVE-2025-50902": {"epss_score": 0.00423, "epss_percentile": 0.61614}, "CVE-2025-50904": {"epss_score": 0.00141, "epss_percentile": 0.3483}, "CVE-2025-50926": {"epss_score": 0.00046, "epss_percentile": 0.14081}, "CVE-2025-50927": {"epss_score": 0.00025, "epss_percentile": 0.06055}, "CVE-2025-50928": {"epss_score": 0.00023, "epss_percentile": 0.05615}, "CVE-2025-50938": {"epss_score": 0.00068, "epss_percentile": 0.21301}, "CVE-2025-50944": {"epss_score": 0.00038, "epss_percentile": 0.11158}, "CVE-2025-50946": {"epss_score": 0.04821, "epss_percentile": 0.89177}, "CVE-2025-50949": {"epss_score": 0.00046, "epss_percentile": 0.14386}, "CVE-2025-50950": {"epss_score": 0.00076, "epss_percentile": 0.23075}, "CVE-2025-50951": {"epss_score": 0.00046, "epss_percentile": 0.14386}, "CVE-2025-50952": {"epss_score": 0.00033, "epss_percentile": 0.0913}, "CVE-2025-50971": {"epss_score": 0.00816, "epss_percentile": 0.73796}, "CVE-2025-50972": {"epss_score": 0.00252, "epss_percentile": 0.48361}, "CVE-2025-50974": {"epss_score": 0.0011, "epss_percentile": 0.30115}, "CVE-2025-50975": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-50976": {"epss_score": 0.00068, "epss_percentile": 0.21301}, "CVE-2025-50977": {"epss_score": 0.00073, "epss_percentile": 0.22494}, "CVE-2025-50978": {"epss_score": 0.00088, "epss_percentile": 0.25659}, "CVE-2025-50979": {"epss_score": 0.00126, "epss_percentile": 0.32644}, "CVE-2025-50983": {"epss_score": 0.00062, "epss_percentile": 0.19593}, "CVE-2025-50984": {"epss_score": 0.00071, "epss_percentile": 0.22234}, "CVE-2025-50985": {"epss_score": 0.00103, "epss_percentile": 0.28977}, "CVE-2025-50986": {"epss_score": 0.00103, "epss_percentile": 0.28977}, "CVE-2025-50989": {"epss_score": 0.00719, "epss_percentile": 0.71941}, "CVE-2025-51005": {"epss_score": 0.00075, "epss_percentile": 0.22967}, "CVE-2025-51006": {"epss_score": 0.00037, "epss_percentile": 0.10636}, "CVE-2025-51040": {"epss_score": 0.00058, "epss_percentile": 0.18463}, "CVE-2025-51044": {"epss_score": 0.00037, "epss_percentile": 0.11002}, "CVE-2025-51045": {"epss_score": 0.00037, "epss_percentile": 0.11002}, "CVE-2025-51052": {"epss_score": 0.00106, "epss_percentile": 0.29438}, "CVE-2025-51053": {"epss_score": 0.00055, "epss_percentile": 0.17479}, "CVE-2025-51054": {"epss_score": 0.00085, "epss_percentile": 0.25242}, "CVE-2025-51055": {"epss_score": 0.00027, "epss_percentile": 0.0678}, "CVE-2025-51056": {"epss_score": 0.00113, "epss_percentile": 0.30726}, "CVE-2025-51057": {"epss_score": 0.00052, "epss_percentile": 0.16565}, "CVE-2025-51058": {"epss_score": 0.00047, "epss_percentile": 0.14853}, "CVE-2025-51060": {"epss_score": 0.00042, "epss_percentile": 0.12619}, "CVE-2025-51082": {"epss_score": 0.00084, "epss_percentile": 0.24886}, "CVE-2025-51085": {"epss_score": 0.00125, "epss_percentile": 0.32504}, "CVE-2025-51087": {"epss_score": 0.00241, "epss_percentile": 0.47252}, "CVE-2025-51088": {"epss_score": 0.00225, "epss_percentile": 0.45135}, "CVE-2025-51089": {"epss_score": 0.00131, "epss_percentile": 0.33492}, "CVE-2025-51092": {"epss_score": 0.00059, "epss_percentile": 0.18824}, "CVE-2025-51281": {"epss_score": 0.00079, "epss_percentile": 0.2396}, "CVE-2025-51306": {"epss_score": 0.00043, "epss_percentile": 0.13097}, "CVE-2025-51308": {"epss_score": 0.00044, "epss_percentile": 0.13552}, "CVE-2025-51381": {"epss_score": 0.0008, "epss_percentile": 0.2401}, "CVE-2025-51383": {"epss_score": 0.00046, "epss_percentile": 0.14359}, "CVE-2025-51384": {"epss_score": 0.00046, "epss_percentile": 0.14359}, "CVE-2025-51385": {"epss_score": 0.00014, "epss_percentile": 0.01847}, "CVE-2025-51387": {"epss_score": 0.0007, "epss_percentile": 0.21939}, "CVE-2025-51390": {"epss_score": 0.02894, "epss_percentile": 0.85923}, "CVE-2025-51396": {"epss_score": 0.00172, "epss_percentile": 0.39002}, "CVE-2025-51397": {"epss_score": 0.00249, "epss_percentile": 0.48054}, "CVE-2025-51398": {"epss_score": 0.00172, "epss_percentile": 0.39002}, "CVE-2025-51400": {"epss_score": 0.00172, "epss_percentile": 0.39002}, "CVE-2025-51401": {"epss_score": 0.00172, "epss_percentile": 0.39002}, "CVE-2025-51403": {"epss_score": 0.00231, "epss_percentile": 0.45832}, "CVE-2025-51411": {"epss_score": 0.00023, "epss_percentile": 0.05495}, "CVE-2025-51451": {"epss_score": 0.00171, "epss_percentile": 0.38892}, "CVE-2025-51452": {"epss_score": 0.00171, "epss_percentile": 0.38892}, "CVE-2025-51458": {"epss_score": 0.0005, "epss_percentile": 0.15779}, "CVE-2025-51459": {"epss_score": 0.00107, "epss_percentile": 0.29608}, "CVE-2025-51462": {"epss_score": 0.00045, "epss_percentile": 0.13791}, "CVE-2025-51463": {"epss_score": 0.00182, "epss_percentile": 0.40184}, "CVE-2025-51464": {"epss_score": 0.00345, "epss_percentile": 0.56547}, "CVE-2025-51471": {"epss_score": 0.00138, "epss_percentile": 0.34526}, "CVE-2025-51472": {"epss_score": 0.00045, "epss_percentile": 0.1393}, "CVE-2025-51475": {"epss_score": 0.00054, "epss_percentile": 0.17098}, "CVE-2025-51479": {"epss_score": 0.00041, "epss_percentile": 0.1239}, "CVE-2025-51480": {"epss_score": 0.0013, "epss_percentile": 0.33222}, "CVE-2025-51481": {"epss_score": 0.00028, "epss_percentile": 0.07327}, "CVE-2025-51482": {"epss_score": 0.06813, "epss_percentile": 0.91042}, "CVE-2025-51487": {"epss_score": 0.0007, "epss_percentile": 0.21702}, "CVE-2025-51488": {"epss_score": 0.00095, "epss_percentile": 0.27222}, "CVE-2025-51489": {"epss_score": 0.00071, "epss_percentile": 0.22176}, "CVE-2025-51495": {"epss_score": 0.00067, "epss_percentile": 0.2116}, "CVE-2025-51497": {"epss_score": 0.00016, "epss_percentile": 0.02642}, "CVE-2025-51501": {"epss_score": 0.00131, "epss_percentile": 0.33504}, "CVE-2025-51502": {"epss_score": 0.00111, "epss_percentile": 0.30311}, "CVE-2025-51503": {"epss_score": 0.0007, "epss_percentile": 0.21671}, "CVE-2025-51504": {"epss_score": 0.00054, "epss_percentile": 0.17363}, "CVE-2025-51506": {"epss_score": 0.00043, "epss_percentile": 0.13309}, "CVE-2025-51510": {"epss_score": 0.00046, "epss_percentile": 0.14161}, "CVE-2025-51511": {"epss_score": 0.00049, "epss_percentile": 0.15613}, "CVE-2025-51529": {"epss_score": 0.00095, "epss_percentile": 0.27133}, "CVE-2025-51531": {"epss_score": 0.00028, "epss_percentile": 0.07355}, "CVE-2025-51532": {"epss_score": 0.00048, "epss_percentile": 0.14985}, "CVE-2025-51533": {"epss_score": 0.00045, "epss_percentile": 0.13681}, "CVE-2025-51534": {"epss_score": 0.00057, "epss_percentile": 0.18082}, "CVE-2025-51535": {"epss_score": 0.0005, "epss_percentile": 0.15864}, "CVE-2025-51536": {"epss_score": 0.00098, "epss_percentile": 0.27772}, "CVE-2025-51539": {"epss_score": 0.00216, "epss_percentile": 0.4423}, "CVE-2025-51540": {"epss_score": 0.00051, "epss_percentile": 0.16308}, "CVE-2025-51541": {"epss_score": 0.00065, "epss_percentile": 0.20597}, "CVE-2025-51543": {"epss_score": 0.0008, "epss_percentile": 0.24141}, "CVE-2025-51569": {"epss_score": 0.00106, "epss_percentile": 0.29506}, "CVE-2025-51586": {"epss_score": 0.01034, "epss_percentile": 0.76886}, "CVE-2025-51591": {"epss_score": 0.00059, "epss_percentile": 0.18808}, "CVE-2025-51605": {"epss_score": 0.00049, "epss_percentile": 0.15446}, "CVE-2025-51606": {"epss_score": 0.00105, "epss_percentile": 0.29377}, "CVE-2025-51624": {"epss_score": 0.00045, "epss_percentile": 0.1373}, "CVE-2025-51627": {"epss_score": 0.0003, "epss_percentile": 0.08213}, "CVE-2025-51628": {"epss_score": 0.00079, "epss_percentile": 0.23957}, "CVE-2025-51629": {"epss_score": 0.00029, "epss_percentile": 0.07669}, "CVE-2025-51630": {"epss_score": 0.00304, "epss_percentile": 0.53275}, "CVE-2025-51643": {"epss_score": 0.00028, "epss_percentile": 0.07233}, "CVE-2025-51650": {"epss_score": 0.00082, "epss_percentile": 0.24448}, "CVE-2025-51651": {"epss_score": 0.00036, "epss_percentile": 0.10511}, "CVE-2025-51652": {"epss_score": 0.00033, "epss_percentile": 0.09404}, "CVE-2025-51653": {"epss_score": 0.00033, "epss_percentile": 0.09404}, "CVE-2025-51654": {"epss_score": 0.00033, "epss_percentile": 0.09404}, "CVE-2025-51655": {"epss_score": 0.00033, "epss_percentile": 0.09404}, "CVE-2025-51656": {"epss_score": 0.00033, "epss_percentile": 0.09404}, "CVE-2025-51657": {"epss_score": 0.00033, "epss_percentile": 0.09404}, "CVE-2025-51658": {"epss_score": 0.00033, "epss_percentile": 0.09404}, "CVE-2025-51659": {"epss_score": 0.00033, "epss_percentile": 0.09404}, "CVE-2025-51660": {"epss_score": 0.00033, "epss_percentile": 0.09404}, "CVE-2025-51661": {"epss_score": 0.00082, "epss_percentile": 0.2456}, "CVE-2025-51662": {"epss_score": 0.00031, "epss_percentile": 0.08692}, "CVE-2025-51663": {"epss_score": 0.00115, "epss_percentile": 0.30952}, "CVE-2025-51667": {"epss_score": 0.00055, "epss_percentile": 0.17407}, "CVE-2025-51671": {"epss_score": 0.00046, "epss_percentile": 0.14265}, "CVE-2025-51672": {"epss_score": 0.00095, "epss_percentile": 0.27224}, "CVE-2025-51682": {"epss_score": 0.00076, "epss_percentile": 0.23184}, "CVE-2025-51683": {"epss_score": 0.00166, "epss_percentile": 0.3816}, "CVE-2025-51691": {"epss_score": 0.00082, "epss_percentile": 0.24556}, "CVE-2025-51726": {"epss_score": 7e-05, "epss_percentile": 0.00408}, "CVE-2025-51733": {"epss_score": 0.00017, "epss_percentile": 0.03109}, "CVE-2025-51734": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-51735": {"epss_score": 0.00064, "epss_percentile": 0.20204}, "CVE-2025-51736": {"epss_score": 0.00047, "epss_percentile": 0.14885}, "CVE-2025-51741": {"epss_score": 0.00074, "epss_percentile": 0.22679}, "CVE-2025-51742": {"epss_score": 0.00062, "epss_percentile": 0.19591}, "CVE-2025-51743": {"epss_score": 0.00062, "epss_percentile": 0.19591}, "CVE-2025-51744": {"epss_score": 0.00062, "epss_percentile": 0.19591}, "CVE-2025-51745": {"epss_score": 0.00062, "epss_percentile": 0.19591}, "CVE-2025-51746": {"epss_score": 0.00062, "epss_percentile": 0.19591}, "CVE-2025-51818": {"epss_score": 0.00094, "epss_percentile": 0.27035}, "CVE-2025-51823": {"epss_score": 0.00024, "epss_percentile": 0.05685}, "CVE-2025-51824": {"epss_score": 0.00024, "epss_percentile": 0.05685}, "CVE-2025-51825": {"epss_score": 0.00042, "epss_percentile": 0.12909}, "CVE-2025-51857": {"epss_score": 0.0002, "epss_percentile": 0.04567}, "CVE-2025-51858": {"epss_score": 0.0003, "epss_percentile": 0.08151}, "CVE-2025-51859": {"epss_score": 0.00034, "epss_percentile": 0.09432}, "CVE-2025-51860": {"epss_score": 0.0003, "epss_percentile": 0.08151}, "CVE-2025-51862": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-51863": {"epss_score": 0.0003, "epss_percentile": 0.08151}, "CVE-2025-51864": {"epss_score": 0.00027, "epss_percentile": 0.06848}, "CVE-2025-51865": {"epss_score": 0.00041, "epss_percentile": 0.12249}, "CVE-2025-51867": {"epss_score": 0.00041, "epss_percentile": 0.12386}, "CVE-2025-51868": {"epss_score": 0.00043, "epss_percentile": 0.13007}, "CVE-2025-51869": {"epss_score": 0.00043, "epss_percentile": 0.13007}, "CVE-2025-51951": {"epss_score": 0.00033, "epss_percentile": 0.09341}, "CVE-2025-51954": {"epss_score": 0.00033, "epss_percentile": 0.09216}, "CVE-2025-51962": {"epss_score": 0.0004, "epss_percentile": 0.12194}, "CVE-2025-51965": {"epss_score": 0.00052, "epss_percentile": 0.1667}, "CVE-2025-51966": {"epss_score": 0.00068, "epss_percentile": 0.21301}, "CVE-2025-51967": {"epss_score": 0.00068, "epss_percentile": 0.21301}, "CVE-2025-51968": {"epss_score": 0.00046, "epss_percentile": 0.14081}, "CVE-2025-51969": {"epss_score": 0.00046, "epss_percentile": 0.14081}, "CVE-2025-51970": {"epss_score": 0.00022, "epss_percentile": 0.04979}, "CVE-2025-51971": {"epss_score": 0.00093, "epss_percentile": 0.2664}, "CVE-2025-51972": {"epss_score": 0.00046, "epss_percentile": 0.14081}, "CVE-2025-51986": {"epss_score": 0.00077, "epss_percentile": 0.2346}, "CVE-2025-51989": {"epss_score": 0.00094, "epss_percentile": 0.26762}, "CVE-2025-51990": {"epss_score": 0.00099, "epss_percentile": 0.27854}, "CVE-2025-51991": {"epss_score": 0.02303, "epss_percentile": 0.84316}, "CVE-2025-52021": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-52035": {"epss_score": 0.00063, "epss_percentile": 0.19985}, "CVE-2025-52036": {"epss_score": 0.00063, "epss_percentile": 0.19985}, "CVE-2025-52037": {"epss_score": 0.00049, "epss_percentile": 0.15569}, "CVE-2025-52039": {"epss_score": 0.00042, "epss_percentile": 0.12669}, "CVE-2025-52040": {"epss_score": 0.00042, "epss_percentile": 0.12669}, "CVE-2025-52041": {"epss_score": 0.00042, "epss_percentile": 0.12669}, "CVE-2025-52042": {"epss_score": 0.00042, "epss_percentile": 0.12669}, "CVE-2025-52043": {"epss_score": 0.00037, "epss_percentile": 0.1094}, "CVE-2025-52044": {"epss_score": 0.00042, "epss_percentile": 0.12669}, "CVE-2025-52046": {"epss_score": 0.63895, "epss_percentile": 0.98354}, "CVE-2025-52047": {"epss_score": 0.00037, "epss_percentile": 0.1094}, "CVE-2025-52048": {"epss_score": 0.00035, "epss_percentile": 0.10086}, "CVE-2025-52049": {"epss_score": 0.00037, "epss_percentile": 0.1094}, "CVE-2025-52050": {"epss_score": 0.00037, "epss_percentile": 0.1094}, "CVE-2025-52053": {"epss_score": 0.66788, "epss_percentile": 0.98479}, "CVE-2025-52054": {"epss_score": 0.00083, "epss_percentile": 0.24801}, "CVE-2025-52074": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-52078": {"epss_score": 0.00049, "epss_percentile": 0.15566}, "CVE-2025-52079": {"epss_score": 0.00127, "epss_percentile": 0.32814}, "CVE-2025-52080": {"epss_score": 0.00051, "epss_percentile": 0.16332}, "CVE-2025-52081": {"epss_score": 0.00051, "epss_percentile": 0.16332}, "CVE-2025-52082": {"epss_score": 0.00051, "epss_percentile": 0.16332}, "CVE-2025-52085": {"epss_score": 0.00059, "epss_percentile": 0.1866}, "CVE-2025-52089": {"epss_score": 0.03987, "epss_percentile": 0.88066}, "CVE-2025-52094": {"epss_score": 0.00017, "epss_percentile": 0.03275}, "CVE-2025-52095": {"epss_score": 0.00043, "epss_percentile": 0.13232}, "CVE-2025-52101": {"epss_score": 0.00099, "epss_percentile": 0.27833}, "CVE-2025-52122": {"epss_score": 0.001, "epss_percentile": 0.28437}, "CVE-2025-52130": {"epss_score": 0.00042, "epss_percentile": 0.12812}, "CVE-2025-52131": {"epss_score": 0.00028, "epss_percentile": 0.07475}, "CVE-2025-52132": {"epss_score": 0.00028, "epss_percentile": 0.07475}, "CVE-2025-52133": {"epss_score": 0.00028, "epss_percentile": 0.07475}, "CVE-2025-52136": {"epss_score": 0.00021, "epss_percentile": 0.04945}, "CVE-2025-52159": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-52161": {"epss_score": 0.00087, "epss_percentile": 0.25592}, "CVE-2025-52162": {"epss_score": 0.00026, "epss_percentile": 0.06407}, "CVE-2025-52163": {"epss_score": 0.00035, "epss_percentile": 0.09822}, "CVE-2025-52164": {"epss_score": 0.0004, "epss_percentile": 0.12167}, "CVE-2025-52166": {"epss_score": 0.00036, "epss_percentile": 0.10372}, "CVE-2025-52168": {"epss_score": 0.00122, "epss_percentile": 0.32114}, "CVE-2025-52169": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52179": {"epss_score": 0.00055, "epss_percentile": 0.17458}, "CVE-2025-52180": {"epss_score": 0.00055, "epss_percentile": 0.17458}, "CVE-2025-52184": {"epss_score": 0.00093, "epss_percentile": 0.2664}, "CVE-2025-52186": {"epss_score": 0.00144, "epss_percentile": 0.35296}, "CVE-2025-52187": {"epss_score": 0.00036, "epss_percentile": 0.10232}, "CVE-2025-52194": {"epss_score": 0.00155, "epss_percentile": 0.36757}, "CVE-2025-52196": {"epss_score": 0.00057, "epss_percentile": 0.1801}, "CVE-2025-52203": {"epss_score": 0.00048, "epss_percentile": 0.15268}, "CVE-2025-52207": {"epss_score": 0.05804, "epss_percentile": 0.90222}, "CVE-2025-52217": {"epss_score": 0.00052, "epss_percentile": 0.16574}, "CVE-2025-52218": {"epss_score": 0.00074, "epss_percentile": 0.22854}, "CVE-2025-52219": {"epss_score": 0.00067, "epss_percentile": 0.21157}, "CVE-2025-52237": {"epss_score": 0.00074, "epss_percentile": 0.22845}, "CVE-2025-52239": {"epss_score": 0.00119, "epss_percentile": 0.31686}, "CVE-2025-52263": {"epss_score": 0.00032, "epss_percentile": 0.09004}, "CVE-2025-52264": {"epss_score": 0.00041, "epss_percentile": 0.12239}, "CVE-2025-52268": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-52277": {"epss_score": 0.00095, "epss_percentile": 0.27218}, "CVE-2025-52284": {"epss_score": 0.27307, "epss_percentile": 0.96235}, "CVE-2025-52287": {"epss_score": 0.00136, "epss_percentile": 0.34101}, "CVE-2025-52288": {"epss_score": 0.00186, "epss_percentile": 0.40661}, "CVE-2025-52289": {"epss_score": 0.00042, "epss_percentile": 0.12728}, "CVE-2025-52294": {"epss_score": 0.00025, "epss_percentile": 0.06251}, "CVE-2025-52322": {"epss_score": 0.00222, "epss_percentile": 0.44744}, "CVE-2025-52327": {"epss_score": 0.00015, "epss_percentile": 0.02132}, "CVE-2025-52331": {"epss_score": 0.00034, "epss_percentile": 0.09621}, "CVE-2025-52335": {"epss_score": 0.00053, "epss_percentile": 0.1685}, "CVE-2025-52337": {"epss_score": 0.00079, "epss_percentile": 0.23951}, "CVE-2025-52338": {"epss_score": 0.00085, "epss_percentile": 0.25168}, "CVE-2025-52344": {"epss_score": 0.00044, "epss_percentile": 0.13623}, "CVE-2025-52351": {"epss_score": 0.00034, "epss_percentile": 0.09751}, "CVE-2025-52352": {"epss_score": 0.00448, "epss_percentile": 0.63019}, "CVE-2025-52353": {"epss_score": 0.0017, "epss_percentile": 0.38743}, "CVE-2025-52357": {"epss_score": 0.0003, "epss_percentile": 0.0825}, "CVE-2025-52358": {"epss_score": 0.00073, "epss_percentile": 0.22581}, "CVE-2025-52360": {"epss_score": 0.00045, "epss_percentile": 0.13831}, "CVE-2025-52361": {"epss_score": 0.00018, "epss_percentile": 0.03885}, "CVE-2025-52362": {"epss_score": 0.00048, "epss_percentile": 0.15015}, "CVE-2025-52363": {"epss_score": 0.00023, "epss_percentile": 0.05331}, "CVE-2025-52364": {"epss_score": 0.00173, "epss_percentile": 0.3909}, "CVE-2025-52367": {"epss_score": 0.7001, "epss_percentile": 0.98612}, "CVE-2025-52372": {"epss_score": 0.00023, "epss_percentile": 0.05636}, "CVE-2025-52373": {"epss_score": 0.00027, "epss_percentile": 0.07092}, "CVE-2025-52374": {"epss_score": 0.00019, "epss_percentile": 0.04102}, "CVE-2025-52376": {"epss_score": 0.00197, "epss_percentile": 0.41929}, "CVE-2025-52377": {"epss_score": 0.00423, "epss_percentile": 0.61637}, "CVE-2025-52378": {"epss_score": 0.00032, "epss_percentile": 0.08956}, "CVE-2025-52379": {"epss_score": 0.00109, "epss_percentile": 0.29914}, "CVE-2025-52385": {"epss_score": 0.00517, "epss_percentile": 0.66063}, "CVE-2025-52386": {"epss_score": 0.00052, "epss_percentile": 0.16402}, "CVE-2025-52389": {"epss_score": 0.00091, "epss_percentile": 0.26389}, "CVE-2025-52390": {"epss_score": 0.0005, "epss_percentile": 0.15765}, "CVE-2025-52392": {"epss_score": 0.01152, "epss_percentile": 0.78043}, "CVE-2025-52395": {"epss_score": 0.00483, "epss_percentile": 0.64617}, "CVE-2025-52410": {"epss_score": 0.00039, "epss_percentile": 0.11437}, "CVE-2025-52424": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52425": {"epss_score": 0.00116, "epss_percentile": 0.31095}, "CVE-2025-52426": {"epss_score": 0.00128, "epss_percentile": 0.32955}, "CVE-2025-52427": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52428": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52429": {"epss_score": 0.00058, "epss_percentile": 0.18287}, "CVE-2025-52430": {"epss_score": 0.00128, "epss_percentile": 0.32955}, "CVE-2025-52431": {"epss_score": 0.00128, "epss_percentile": 0.32955}, "CVE-2025-52432": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52433": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52434": {"epss_score": 0.002, "epss_percentile": 0.42265}, "CVE-2025-52446": {"epss_score": 0.00018, "epss_percentile": 0.04007}, "CVE-2025-52447": {"epss_score": 0.0004, "epss_percentile": 0.12061}, "CVE-2025-52448": {"epss_score": 0.00038, "epss_percentile": 0.11231}, "CVE-2025-52449": {"epss_score": 0.00016, "epss_percentile": 0.0304}, "CVE-2025-52450": {"epss_score": 0.00082, "epss_percentile": 0.2451}, "CVE-2025-52451": {"epss_score": 0.00054, "epss_percentile": 0.17279}, "CVE-2025-52452": {"epss_score": 0.00061, "epss_percentile": 0.19292}, "CVE-2025-52453": {"epss_score": 0.0003, "epss_percentile": 0.08246}, "CVE-2025-52454": {"epss_score": 0.0004, "epss_percentile": 0.12065}, "CVE-2025-52455": {"epss_score": 0.0004, "epss_percentile": 0.12065}, "CVE-2025-52456": {"epss_score": 0.00328, "epss_percentile": 0.55166}, "CVE-2025-52457": {"epss_score": 0.00022, "epss_percentile": 0.05187}, "CVE-2025-52459": {"epss_score": 0.00035, "epss_percentile": 0.09983}, "CVE-2025-52460": {"epss_score": 0.00073, "epss_percentile": 0.22578}, "CVE-2025-52461": {"epss_score": 0.00096, "epss_percentile": 0.2735}, "CVE-2025-52462": {"epss_score": 0.00026, "epss_percentile": 0.06382}, "CVE-2025-52463": {"epss_score": 0.00016, "epss_percentile": 0.02643}, "CVE-2025-52464": {"epss_score": 0.00049, "epss_percentile": 0.15485}, "CVE-2025-52467": {"epss_score": 0.00046, "epss_percentile": 0.1417}, "CVE-2025-52471": {"epss_score": 0.00347, "epss_percentile": 0.56791}, "CVE-2025-52472": {"epss_score": 0.00513, "epss_percentile": 0.65926}, "CVE-2025-52473": {"epss_score": 0.00026, "epss_percentile": 0.06677}, "CVE-2025-52474": {"epss_score": 0.00045, "epss_percentile": 0.13915}, "CVE-2025-52477": {"epss_score": 0.00044, "epss_percentile": 0.13439}, "CVE-2025-52478": {"epss_score": 0.00061, "epss_percentile": 0.19345}, "CVE-2025-52479": {"epss_score": 0.0006, "epss_percentile": 0.19018}, "CVE-2025-52480": {"epss_score": 0.00334, "epss_percentile": 0.55743}, "CVE-2025-52483": {"epss_score": 0.00058, "epss_percentile": 0.1826}, "CVE-2025-52484": {"epss_score": 0.00042, "epss_percentile": 0.12922}, "CVE-2025-52485": {"epss_score": 0.00024, "epss_percentile": 0.05798}, "CVE-2025-52486": {"epss_score": 0.00025, "epss_percentile": 0.06154}, "CVE-2025-52487": {"epss_score": 0.00052, "epss_percentile": 0.16558}, "CVE-2025-52488": {"epss_score": 0.25441, "epss_percentile": 0.96029}, "CVE-2025-52490": {"epss_score": 0.00038, "epss_percentile": 0.11278}, "CVE-2025-52491": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-52492": {"epss_score": 0.00069, "epss_percentile": 0.21623}, "CVE-2025-52493": {"epss_score": 0.00035, "epss_percentile": 0.09972}, "CVE-2025-52494": {"epss_score": 0.00082, "epss_percentile": 0.244}, "CVE-2025-52496": {"epss_score": 0.00017, "epss_percentile": 0.03412}, "CVE-2025-52497": {"epss_score": 0.00057, "epss_percentile": 0.18134}, "CVE-2025-52512": {"epss_score": 0.00063, "epss_percentile": 0.19821}, "CVE-2025-52513": {"epss_score": 0.00063, "epss_percentile": 0.19821}, "CVE-2025-52515": {"epss_score": 0.00012, "epss_percentile": 0.01227}, "CVE-2025-52516": {"epss_score": 0.00013, "epss_percentile": 0.01581}, "CVE-2025-52517": {"epss_score": 0.00018, "epss_percentile": 0.04005}, "CVE-2025-52519": {"epss_score": 0.00013, "epss_percentile": 0.01724}, "CVE-2025-52520": {"epss_score": 0.00112, "epss_percentile": 0.30484}, "CVE-2025-52521": {"epss_score": 0.00045, "epss_percentile": 0.13766}, "CVE-2025-52538": {"epss_score": 0.00019, "epss_percentile": 0.04088}, "CVE-2025-52539": {"epss_score": 0.00018, "epss_percentile": 0.03653}, "CVE-2025-52543": {"epss_score": 0.00088, "epss_percentile": 0.25648}, "CVE-2025-52544": {"epss_score": 0.00122, "epss_percentile": 0.32142}, "CVE-2025-52545": {"epss_score": 0.0006, "epss_percentile": 0.19197}, "CVE-2025-52546": {"epss_score": 0.00133, "epss_percentile": 0.33631}, "CVE-2025-52547": {"epss_score": 0.00115, "epss_percentile": 0.30895}, "CVE-2025-52548": {"epss_score": 0.00047, "epss_percentile": 0.14632}, "CVE-2025-52549": {"epss_score": 0.00085, "epss_percentile": 0.25055}, "CVE-2025-52550": {"epss_score": 0.00033, "epss_percentile": 0.09422}, "CVE-2025-52551": {"epss_score": 0.00079, "epss_percentile": 0.23939}, "CVE-2025-52552": {"epss_score": 0.00033, "epss_percentile": 0.09395}, "CVE-2025-52553": {"epss_score": 0.00048, "epss_percentile": 0.15201}, "CVE-2025-52554": {"epss_score": 0.00045, "epss_percentile": 0.14037}, "CVE-2025-52555": {"epss_score": 0.00013, "epss_percentile": 0.01557}, "CVE-2025-52556": {"epss_score": 0.00033, "epss_percentile": 0.09389}, "CVE-2025-52557": {"epss_score": 0.00057, "epss_percentile": 0.18111}, "CVE-2025-52558": {"epss_score": 0.00021, "epss_percentile": 0.04849}, "CVE-2025-52559": {"epss_score": 0.00029, "epss_percentile": 0.07954}, "CVE-2025-52560": {"epss_score": 0.0003, "epss_percentile": 0.08269}, "CVE-2025-52561": {"epss_score": 0.00078, "epss_percentile": 0.23673}, "CVE-2025-52562": {"epss_score": 0.02566, "epss_percentile": 0.85116}, "CVE-2025-52565": {"epss_score": 0.00019, "epss_percentile": 0.04055}, "CVE-2025-52566": {"epss_score": 0.00043, "epss_percentile": 0.13128}, "CVE-2025-52567": {"epss_score": 0.00027, "epss_percentile": 0.06898}, "CVE-2025-52568": {"epss_score": 0.00166, "epss_percentile": 0.38182}, "CVE-2025-52569": {"epss_score": 0.00156, "epss_percentile": 0.37014}, "CVE-2025-52570": {"epss_score": 0.00024, "epss_percentile": 0.05689}, "CVE-2025-52571": {"epss_score": 0.00126, "epss_percentile": 0.32732}, "CVE-2025-52572": {"epss_score": 0.00407, "epss_percentile": 0.60591}, "CVE-2025-52573": {"epss_score": 0.00017, "epss_percentile": 0.03176}, "CVE-2025-52574": {"epss_score": 0.00067, "epss_percentile": 0.2118}, "CVE-2025-52575": {"epss_score": 0.00298, "epss_percentile": 0.52786}, "CVE-2025-52576": {"epss_score": 0.00047, "epss_percentile": 0.14656}, "CVE-2025-52577": {"epss_score": 0.0023, "epss_percentile": 0.4573}, "CVE-2025-52578": {"epss_score": 0.00022, "epss_percentile": 0.05187}, "CVE-2025-52579": {"epss_score": 0.0003, "epss_percentile": 0.08176}, "CVE-2025-52580": {"epss_score": 0.00015, "epss_percentile": 0.02337}, "CVE-2025-52581": {"epss_score": 0.0022, "epss_percentile": 0.44584}, "CVE-2025-52582": {"epss_score": 0.0003, "epss_percentile": 0.08263}, "CVE-2025-52583": {"epss_score": 0.00053, "epss_percentile": 0.17029}, "CVE-2025-52584": {"epss_score": 0.00037, "epss_percentile": 0.10927}, "CVE-2025-52585": {"epss_score": 0.00153, "epss_percentile": 0.36623}, "CVE-2025-52586": {"epss_score": 4e-05, "epss_percentile": 0.00162}, "CVE-2025-52598": {"epss_score": 0.00032, "epss_percentile": 0.08736}, "CVE-2025-52599": {"epss_score": 0.00037, "epss_percentile": 0.10788}, "CVE-2025-52600": {"epss_score": 0.00133, "epss_percentile": 0.33684}, "CVE-2025-52601": {"epss_score": 0.00018, "epss_percentile": 0.03891}, "CVE-2025-52602": {"epss_score": 0.00035, "epss_percentile": 0.10006}, "CVE-2025-52614": {"epss_score": 0.00017, "epss_percentile": 0.03094}, "CVE-2025-52615": {"epss_score": 0.00069, "epss_percentile": 0.21516}, "CVE-2025-52616": {"epss_score": 0.00049, "epss_percentile": 0.15342}, "CVE-2025-52618": {"epss_score": 0.00124, "epss_percentile": 0.32373}, "CVE-2025-52619": {"epss_score": 0.00055, "epss_percentile": 0.17529}, "CVE-2025-52620": {"epss_score": 0.00122, "epss_percentile": 0.3205}, "CVE-2025-52621": {"epss_score": 0.00021, "epss_percentile": 0.04882}, "CVE-2025-52622": {"epss_score": 0.00032, "epss_percentile": 0.09101}, "CVE-2025-52624": {"epss_score": 0.0004, "epss_percentile": 0.12159}, "CVE-2025-52625": {"epss_score": 0.00046, "epss_percentile": 0.14426}, "CVE-2025-52630": {"epss_score": 0.00046, "epss_percentile": 0.14426}, "CVE-2025-52632": {"epss_score": 0.00021, "epss_percentile": 0.04688}, "CVE-2025-52634": {"epss_score": 0.00046, "epss_percentile": 0.14426}, "CVE-2025-52635": {"epss_score": 0.00048, "epss_percentile": 0.14963}, "CVE-2025-52639": {"epss_score": 0.00036, "epss_percentile": 0.10392}, "CVE-2025-52647": {"epss_score": 0.00037, "epss_percentile": 0.10987}, "CVE-2025-52650": {"epss_score": 0.00049, "epss_percentile": 0.15576}, "CVE-2025-52653": {"epss_score": 0.00051, "epss_percentile": 0.16068}, "CVE-2025-52654": {"epss_score": 0.0004, "epss_percentile": 0.12049}, "CVE-2025-52655": {"epss_score": 0.00039, "epss_percentile": 0.11708}, "CVE-2025-52656": {"epss_score": 0.00109, "epss_percentile": 0.30035}, "CVE-2025-52658": {"epss_score": 0.0007, "epss_percentile": 0.21646}, "CVE-2025-52662": {"epss_score": 0.00029, "epss_percentile": 0.07754}, "CVE-2025-52663": {"epss_score": 0.00058, "epss_percentile": 0.1831}, "CVE-2025-52664": {"epss_score": 0.00019, "epss_percentile": 0.04284}, "CVE-2025-52665": {"epss_score": 0.10205, "epss_percentile": 0.92892}, "CVE-2025-52666": {"epss_score": 0.00091, "epss_percentile": 0.26221}, "CVE-2025-52667": {"epss_score": 0.00018, "epss_percentile": 0.03763}, "CVE-2025-52668": {"epss_score": 0.00019, "epss_percentile": 0.04297}, "CVE-2025-52669": {"epss_score": 0.0001, "epss_percentile": 0.00917}, "CVE-2025-52670": {"epss_score": 0.00019, "epss_percentile": 0.0439}, "CVE-2025-52671": {"epss_score": 0.00021, "epss_percentile": 0.04917}, "CVE-2025-52687": {"epss_score": 0.00023, "epss_percentile": 0.05465}, "CVE-2025-52688": {"epss_score": 0.00122, "epss_percentile": 0.32122}, "CVE-2025-52689": {"epss_score": 0.00492, "epss_percentile": 0.65012}, "CVE-2025-52690": {"epss_score": 0.00077, "epss_percentile": 0.23407}, "CVE-2025-52691": {"epss_score": 0.00233, "epss_percentile": 0.45997}, "CVE-2025-52692": {"epss_score": 0.00018, "epss_percentile": 0.0389}, "CVE-2025-52707": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-52708": {"epss_score": 0.00109, "epss_percentile": 0.2997}, "CVE-2025-52710": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-52711": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-52712": {"epss_score": 0.00038, "epss_percentile": 0.11332}, "CVE-2025-52713": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-52714": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-52715": {"epss_score": 0.00109, "epss_percentile": 0.2997}, "CVE-2025-52716": {"epss_score": 0.00099, "epss_percentile": 0.2786}, "CVE-2025-52717": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-52718": {"epss_score": 0.00043, "epss_percentile": 0.12974}, "CVE-2025-52719": {"epss_score": 0.00037, "epss_percentile": 0.10725}, "CVE-2025-52720": {"epss_score": 0.0003, "epss_percentile": 0.08292}, "CVE-2025-52721": {"epss_score": 0.00049, "epss_percentile": 0.15332}, "CVE-2025-52722": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-52723": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-52724": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-52725": {"epss_score": 0.00101, "epss_percentile": 0.2869}, "CVE-2025-52726": {"epss_score": 0.00058, "epss_percentile": 0.18361}, "CVE-2025-52727": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52728": {"epss_score": 0.00203, "epss_percentile": 0.42545}, "CVE-2025-52729": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-52730": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-52731": {"epss_score": 0.00058, "epss_percentile": 0.18311}, "CVE-2025-52732": {"epss_score": 0.00143, "epss_percentile": 0.35119}, "CVE-2025-52733": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-52734": {"epss_score": 0.00062, "epss_percentile": 0.1967}, "CVE-2025-52735": {"epss_score": 0.00062, "epss_percentile": 0.1967}, "CVE-2025-52736": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-52737": {"epss_score": 0.00071, "epss_percentile": 0.22114}, "CVE-2025-52738": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2025-52739": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-52740": {"epss_score": 0.00071, "epss_percentile": 0.22114}, "CVE-2025-52741": {"epss_score": 0.00071, "epss_percentile": 0.22204}, "CVE-2025-52742": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-52743": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-52745": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-52748": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-52749": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-52750": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-52751": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-52752": {"epss_score": 0.00046, "epss_percentile": 0.14136}, "CVE-2025-52753": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-52754": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-52755": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-52756": {"epss_score": 0.00061, "epss_percentile": 0.19522}, "CVE-2025-52757": {"epss_score": 0.00042, "epss_percentile": 0.12598}, "CVE-2025-52758": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-52760": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-52761": {"epss_score": 0.00098, "epss_percentile": 0.27674}, "CVE-2025-52763": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-52764": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-52765": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-52767": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-52768": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-52769": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-52770": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-52771": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-52772": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-52773": {"epss_score": 0.00044, "epss_percentile": 0.13452}, "CVE-2025-52774": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52775": {"epss_score": 0.0007, "epss_percentile": 0.21975}, "CVE-2025-52776": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52777": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52778": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52779": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52780": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-52781": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-52782": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52783": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-52784": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-52785": {"epss_score": 0.0007, "epss_percentile": 0.21975}, "CVE-2025-52786": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52787": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52788": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-52789": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-52790": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-52791": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-52792": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-52793": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-52794": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-52795": {"epss_score": 0.00016, "epss_percentile": 0.03051}, "CVE-2025-52796": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52797": {"epss_score": 0.0003, "epss_percentile": 0.08231}, "CVE-2025-52798": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52799": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-52800": {"epss_score": 0.00045, "epss_percentile": 0.1392}, "CVE-2025-52801": {"epss_score": 0.00045, "epss_percentile": 0.1392}, "CVE-2025-52802": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-52803": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-52804": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-52805": {"epss_score": 0.00027, "epss_percentile": 0.07108}, "CVE-2025-52806": {"epss_score": 0.0022, "epss_percentile": 0.44626}, "CVE-2025-52807": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-52808": {"epss_score": 0.00101, "epss_percentile": 0.28671}, "CVE-2025-52809": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-52810": {"epss_score": 0.00038, "epss_percentile": 0.1123}, "CVE-2025-52811": {"epss_score": 0.00038, "epss_percentile": 0.1123}, "CVE-2025-52812": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-52813": {"epss_score": 0.00052, "epss_percentile": 0.16552}, "CVE-2025-52814": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-52815": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-52816": {"epss_score": 0.0011, "epss_percentile": 0.30144}, "CVE-2025-52817": {"epss_score": 0.00055, "epss_percentile": 0.1762}, "CVE-2025-52818": {"epss_score": 0.0004, "epss_percentile": 0.12167}, "CVE-2025-52819": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-52820": {"epss_score": 0.0003, "epss_percentile": 0.08224}, "CVE-2025-52821": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-52822": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-52823": {"epss_score": 0.0003, "epss_percentile": 0.08224}, "CVE-2025-52824": {"epss_score": 0.00056, "epss_percentile": 0.17737}, "CVE-2025-52825": {"epss_score": 0.00019, "epss_percentile": 0.04199}, "CVE-2025-52826": {"epss_score": 0.00118, "epss_percentile": 0.31508}, "CVE-2025-52827": {"epss_score": 0.00118, "epss_percentile": 0.31508}, "CVE-2025-52828": {"epss_score": 0.00118, "epss_percentile": 0.31508}, "CVE-2025-52829": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-52830": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-52831": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-52832": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-52833": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-52834": {"epss_score": 0.00035, "epss_percentile": 0.09872}, "CVE-2025-52835": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-52836": {"epss_score": 0.00059, "epss_percentile": 0.18855}, "CVE-2025-52837": {"epss_score": 0.00063, "epss_percentile": 0.19888}, "CVE-2025-52841": {"epss_score": 0.00027, "epss_percentile": 0.06889}, "CVE-2025-52842": {"epss_score": 0.00033, "epss_percentile": 0.09341}, "CVE-2025-52853": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52854": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52855": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52856": {"epss_score": 0.00691, "epss_percentile": 0.71265}, "CVE-2025-52857": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52858": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52859": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52860": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52861": {"epss_score": 0.0053, "epss_percentile": 0.66612}, "CVE-2025-52862": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52863": {"epss_score": 0.00107, "epss_percentile": 0.29691}, "CVE-2025-52864": {"epss_score": 0.00107, "epss_percentile": 0.29691}, "CVE-2025-52865": {"epss_score": 0.00135, "epss_percentile": 0.34051}, "CVE-2025-52866": {"epss_score": 0.00145, "epss_percentile": 0.35495}, "CVE-2025-52867": {"epss_score": 0.00159, "epss_percentile": 0.37401}, "CVE-2025-52871": {"epss_score": 0.00047, "epss_percentile": 0.14573}, "CVE-2025-52872": {"epss_score": 0.00107, "epss_percentile": 0.29691}, "CVE-2025-52873": {"epss_score": 0.00084, "epss_percentile": 0.25023}, "CVE-2025-52875": {"epss_score": 0.0007, "epss_percentile": 0.21769}, "CVE-2025-52876": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2025-52877": {"epss_score": 0.0001, "epss_percentile": 0.00865}, "CVE-2025-52878": {"epss_score": 1e-05, "epss_percentile": 6e-05}, "CVE-2025-52879": {"epss_score": 8e-05, "epss_percentile": 0.00482}, "CVE-2025-52880": {"epss_score": 0.00018, "epss_percentile": 0.03522}, "CVE-2025-52881": {"epss_score": 0.00024, "epss_percentile": 0.05964}, "CVE-2025-52882": {"epss_score": 0.00045, "epss_percentile": 0.1374}, "CVE-2025-52883": {"epss_score": 0.00059, "epss_percentile": 0.18716}, "CVE-2025-52884": {"epss_score": 0.00071, "epss_percentile": 0.22175}, "CVE-2025-52885": {"epss_score": 0.0002, "epss_percentile": 0.04686}, "CVE-2025-52886": {"epss_score": 0.00051, "epss_percentile": 0.1632}, "CVE-2025-52887": {"epss_score": 0.00104, "epss_percentile": 0.29224}, "CVE-2025-52888": {"epss_score": 0.00032, "epss_percentile": 0.0878}, "CVE-2025-52889": {"epss_score": 0.00027, "epss_percentile": 0.06739}, "CVE-2025-52890": {"epss_score": 0.00029, "epss_percentile": 0.07975}, "CVE-2025-52891": {"epss_score": 0.00055, "epss_percentile": 0.17545}, "CVE-2025-52892": {"epss_score": 0.00029, "epss_percentile": 0.07973}, "CVE-2025-52893": {"epss_score": 0.00011, "epss_percentile": 0.01016}, "CVE-2025-52894": {"epss_score": 0.00038, "epss_percentile": 0.11347}, "CVE-2025-52895": {"epss_score": 0.00038, "epss_percentile": 0.11188}, "CVE-2025-52896": {"epss_score": 0.00028, "epss_percentile": 0.07578}, "CVE-2025-52897": {"epss_score": 0.00069, "epss_percentile": 0.2147}, "CVE-2025-52898": {"epss_score": 0.00051, "epss_percentile": 0.16205}, "CVE-2025-52899": {"epss_score": 0.00045, "epss_percentile": 0.14002}, "CVE-2025-52900": {"epss_score": 0.00017, "epss_percentile": 0.03142}, "CVE-2025-52901": {"epss_score": 0.00058, "epss_percentile": 0.18284}, "CVE-2025-52902": {"epss_score": 0.00015, "epss_percentile": 0.0255}, "CVE-2025-52903": {"epss_score": 0.00167, "epss_percentile": 0.38347}, "CVE-2025-52904": {"epss_score": 0.00143, "epss_percentile": 0.35214}, "CVE-2025-52905": {"epss_score": 0.00203, "epss_percentile": 0.42509}, "CVE-2025-52906": {"epss_score": 0.02855, "epss_percentile": 0.85838}, "CVE-2025-52907": {"epss_score": 0.00844, "epss_percentile": 0.74276}, "CVE-2025-52910": {"epss_score": 0.00056, "epss_percentile": 0.17876}, "CVE-2025-52913": {"epss_score": 0.0028, "epss_percentile": 0.51086}, "CVE-2025-52914": {"epss_score": 0.00029, "epss_percentile": 0.07777}, "CVE-2025-52915": {"epss_score": 0.0005, "epss_percentile": 0.1589}, "CVE-2025-52916": {"epss_score": 0.00027, "epss_percentile": 0.07108}, "CVE-2025-52917": {"epss_score": 0.00043, "epss_percentile": 0.12966}, "CVE-2025-52918": {"epss_score": 0.00039, "epss_percentile": 0.11705}, "CVE-2025-52919": {"epss_score": 0.00027, "epss_percentile": 0.06825}, "CVE-2025-52920": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-52921": {"epss_score": 0.00081, "epss_percentile": 0.2424}, "CVE-2025-52922": {"epss_score": 0.00193, "epss_percentile": 0.41449}, "CVE-2025-52923": {"epss_score": 0.00017, "epss_percentile": 0.03331}, "CVE-2025-52924": {"epss_score": 0.00024, "epss_percentile": 0.05859}, "CVE-2025-52925": {"epss_score": 0.00025, "epss_percentile": 0.06261}, "CVE-2025-52926": {"epss_score": 0.00013, "epss_percentile": 0.01481}, "CVE-2025-52930": {"epss_score": 0.00318, "epss_percentile": 0.5444}, "CVE-2025-52931": {"epss_score": 0.00055, "epss_percentile": 0.1754}, "CVE-2025-52935": {"epss_score": 0.0006, "epss_percentile": 0.19018}, "CVE-2025-52936": {"epss_score": 0.00039, "epss_percentile": 0.11725}, "CVE-2025-52937": {"epss_score": 8e-05, "epss_percentile": 0.00497}, "CVE-2025-52938": {"epss_score": 0.0002, "epss_percentile": 0.04652}, "CVE-2025-52939": {"epss_score": 0.0002, "epss_percentile": 0.04652}, "CVE-2025-52946": {"epss_score": 0.001, "epss_percentile": 0.28486}, "CVE-2025-52947": {"epss_score": 0.00034, "epss_percentile": 0.09585}, "CVE-2025-52948": {"epss_score": 0.00043, "epss_percentile": 0.13141}, "CVE-2025-52949": {"epss_score": 0.00046, "epss_percentile": 0.14298}, "CVE-2025-52950": {"epss_score": 0.00052, "epss_percentile": 0.16552}, "CVE-2025-52951": {"epss_score": 0.00043, "epss_percentile": 0.13204}, "CVE-2025-52952": {"epss_score": 0.00034, "epss_percentile": 0.09585}, "CVE-2025-52953": {"epss_score": 0.00043, "epss_percentile": 0.13059}, "CVE-2025-52954": {"epss_score": 0.00017, "epss_percentile": 0.03398}, "CVE-2025-52955": {"epss_score": 0.00042, "epss_percentile": 0.12597}, "CVE-2025-52958": {"epss_score": 0.00011, "epss_percentile": 0.01013}, "CVE-2025-52960": {"epss_score": 0.00059, "epss_percentile": 0.18927}, "CVE-2025-52961": {"epss_score": 0.00022, "epss_percentile": 0.05307}, "CVE-2025-52963": {"epss_score": 0.00015, "epss_percentile": 0.02459}, "CVE-2025-52964": {"epss_score": 0.00015, "epss_percentile": 0.02224}, "CVE-2025-52967": {"epss_score": 0.00041, "epss_percentile": 0.12266}, "CVE-2025-52968": {"epss_score": 0.00012, "epss_percentile": 0.01269}, "CVE-2025-52970": {"epss_score": 0.40186, "epss_percentile": 0.97205}, "CVE-2025-52980": {"epss_score": 0.00057, "epss_percentile": 0.18139}, "CVE-2025-52981": {"epss_score": 0.00057, "epss_percentile": 0.18139}, "CVE-2025-52982": {"epss_score": 0.00043, "epss_percentile": 0.13141}, "CVE-2025-52983": {"epss_score": 0.00156, "epss_percentile": 0.36902}, "CVE-2025-52984": {"epss_score": 0.00043, "epss_percentile": 0.13224}, "CVE-2025-52985": {"epss_score": 0.00015, "epss_percentile": 0.02538}, "CVE-2025-52986": {"epss_score": 0.00018, "epss_percentile": 0.03665}, "CVE-2025-52988": {"epss_score": 0.00033, "epss_percentile": 0.09375}, "CVE-2025-52989": {"epss_score": 0.00016, "epss_percentile": 0.02922}, "CVE-2025-52991": {"epss_score": 0.00014, "epss_percentile": 0.0187}, "CVE-2025-52992": {"epss_score": 0.00012, "epss_percentile": 0.01256}, "CVE-2025-52993": {"epss_score": 0.00013, "epss_percentile": 0.01431}, "CVE-2025-52994": {"epss_score": 0.00305, "epss_percentile": 0.53353}, "CVE-2025-52995": {"epss_score": 0.0009, "epss_percentile": 0.26024}, "CVE-2025-52996": {"epss_score": 0.00041, "epss_percentile": 0.12448}, "CVE-2025-52997": {"epss_score": 0.00087, "epss_percentile": 0.25525}, "CVE-2025-52999": {"epss_score": 0.0003, "epss_percentile": 0.08261}, "CVE-2025-53000": {"epss_score": 0.00012, "epss_percentile": 0.01394}, "CVE-2025-53002": {"epss_score": 0.0078, "epss_percentile": 0.73161}, "CVE-2025-53003": {"epss_score": 0.00074, "epss_percentile": 0.22731}, "CVE-2025-53004": {"epss_score": 0.0009, "epss_percentile": 0.26004}, "CVE-2025-53005": {"epss_score": 0.0009, "epss_percentile": 0.26004}, "CVE-2025-53006": {"epss_score": 0.00105, "epss_percentile": 0.29296}, "CVE-2025-53007": {"epss_score": 0.0006, "epss_percentile": 0.19233}, "CVE-2025-53008": {"epss_score": 0.0004, "epss_percentile": 0.12061}, "CVE-2025-53009": {"epss_score": 0.00229, "epss_percentile": 0.4566}, "CVE-2025-53010": {"epss_score": 0.00049, "epss_percentile": 0.15634}, "CVE-2025-53011": {"epss_score": 0.0005, "epss_percentile": 0.1568}, "CVE-2025-53012": {"epss_score": 0.00103, "epss_percentile": 0.29}, "CVE-2025-53013": {"epss_score": 0.00029, "epss_percentile": 0.07924}, "CVE-2025-53014": {"epss_score": 0.00029, "epss_percentile": 0.07752}, "CVE-2025-53015": {"epss_score": 0.00038, "epss_percentile": 0.11154}, "CVE-2025-53018": {"epss_score": 0.00025, "epss_percentile": 0.06369}, "CVE-2025-53019": {"epss_score": 0.00057, "epss_percentile": 0.17967}, "CVE-2025-53020": {"epss_score": 0.0033, "epss_percentile": 0.55435}, "CVE-2025-53021": {"epss_score": 0.00109, "epss_percentile": 0.2995}, "CVE-2025-53022": {"epss_score": 0.00056, "epss_percentile": 0.17883}, "CVE-2025-53023": {"epss_score": 0.00047, "epss_percentile": 0.14618}, "CVE-2025-53024": {"epss_score": 0.00027, "epss_percentile": 0.07117}, "CVE-2025-53025": {"epss_score": 0.00018, "epss_percentile": 0.04008}, "CVE-2025-53026": {"epss_score": 0.00018, "epss_percentile": 0.04008}, "CVE-2025-53027": {"epss_score": 0.00027, "epss_percentile": 0.07117}, "CVE-2025-53028": {"epss_score": 0.00027, "epss_percentile": 0.07117}, "CVE-2025-53029": {"epss_score": 0.00016, "epss_percentile": 0.02749}, "CVE-2025-53030": {"epss_score": 0.00018, "epss_percentile": 0.04008}, "CVE-2025-53031": {"epss_score": 0.00034, "epss_percentile": 0.09673}, "CVE-2025-53032": {"epss_score": 0.00047, "epss_percentile": 0.14618}, "CVE-2025-53034": {"epss_score": 0.00034, "epss_percentile": 0.09735}, "CVE-2025-53035": {"epss_score": 0.0005, "epss_percentile": 0.15867}, "CVE-2025-53036": {"epss_score": 0.00055, "epss_percentile": 0.17504}, "CVE-2025-53037": {"epss_score": 0.0013, "epss_percentile": 0.33284}, "CVE-2025-53040": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-53041": {"epss_score": 0.00034, "epss_percentile": 0.09735}, "CVE-2025-53042": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-53043": {"epss_score": 0.00098, "epss_percentile": 0.27802}, "CVE-2025-53044": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-53045": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-53046": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-53047": {"epss_score": 0.00038, "epss_percentile": 0.11153}, "CVE-2025-53048": {"epss_score": 0.00031, "epss_percentile": 0.08654}, "CVE-2025-53049": {"epss_score": 0.00094, "epss_percentile": 0.26997}, "CVE-2025-53050": {"epss_score": 0.00053, "epss_percentile": 0.16997}, "CVE-2025-53051": {"epss_score": 0.00035, "epss_percentile": 0.09845}, "CVE-2025-53052": {"epss_score": 0.00034, "epss_percentile": 0.09735}, "CVE-2025-53053": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-53054": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-53055": {"epss_score": 0.00032, "epss_percentile": 0.08738}, "CVE-2025-53056": {"epss_score": 0.00034, "epss_percentile": 0.09735}, "CVE-2025-53057": {"epss_score": 0.00094, "epss_percentile": 0.26956}, "CVE-2025-53058": {"epss_score": 0.00034, "epss_percentile": 0.09735}, "CVE-2025-53059": {"epss_score": 0.00046, "epss_percentile": 0.14428}, "CVE-2025-53060": {"epss_score": 0.00034, "epss_percentile": 0.09735}, "CVE-2025-53061": {"epss_score": 0.00033, "epss_percentile": 0.09181}, "CVE-2025-53062": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-53063": {"epss_score": 0.00031, "epss_percentile": 0.08654}, "CVE-2025-53064": {"epss_score": 0.00036, "epss_percentile": 0.10408}, "CVE-2025-53065": {"epss_score": 0.00032, "epss_percentile": 0.08738}, "CVE-2025-53066": {"epss_score": 0.00094, "epss_percentile": 0.26997}, "CVE-2025-53067": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-53068": {"epss_score": 0.00026, "epss_percentile": 0.06621}, "CVE-2025-53069": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-53070": {"epss_score": 0.0002, "epss_percentile": 0.04653}, "CVE-2025-53071": {"epss_score": 0.00036, "epss_percentile": 0.10408}, "CVE-2025-53072": {"epss_score": 0.00106, "epss_percentile": 0.29471}, "CVE-2025-53073": {"epss_score": 0.00025, "epss_percentile": 0.06336}, "CVE-2025-53074": {"epss_score": 0.00061, "epss_percentile": 0.19431}, "CVE-2025-53075": {"epss_score": 0.00065, "epss_percentile": 0.20453}, "CVE-2025-53076": {"epss_score": 0.00093, "epss_percentile": 0.26603}, "CVE-2025-53077": {"epss_score": 0.00056, "epss_percentile": 0.17775}, "CVE-2025-53078": {"epss_score": 0.0024, "epss_percentile": 0.4697}, "CVE-2025-53079": {"epss_score": 0.00061, "epss_percentile": 0.19417}, "CVE-2025-53080": {"epss_score": 0.0005, "epss_percentile": 0.15681}, "CVE-2025-53081": {"epss_score": 0.00118, "epss_percentile": 0.3141}, "CVE-2025-53082": {"epss_score": 0.00357, "epss_percentile": 0.57405}, "CVE-2025-53084": {"epss_score": 0.00066, "epss_percentile": 0.20741}, "CVE-2025-53085": {"epss_score": 0.00318, "epss_percentile": 0.5444}, "CVE-2025-53091": {"epss_score": 0.00216, "epss_percentile": 0.44173}, "CVE-2025-53092": {"epss_score": 0.00038, "epss_percentile": 0.11394}, "CVE-2025-53093": {"epss_score": 0.00071, "epss_percentile": 0.22235}, "CVE-2025-53094": {"epss_score": 0.00052, "epss_percentile": 0.16404}, "CVE-2025-53095": {"epss_score": 0.00021, "epss_percentile": 0.04818}, "CVE-2025-53096": {"epss_score": 0.00034, "epss_percentile": 0.09796}, "CVE-2025-53097": {"epss_score": 0.00048, "epss_percentile": 0.15219}, "CVE-2025-53098": {"epss_score": 0.00041, "epss_percentile": 0.12403}, "CVE-2025-53099": {"epss_score": 0.00074, "epss_percentile": 0.22746}, "CVE-2025-53100": {"epss_score": 0.00413, "epss_percentile": 0.60996}, "CVE-2025-53101": {"epss_score": 0.00064, "epss_percentile": 0.20305}, "CVE-2025-53102": {"epss_score": 0.00074, "epss_percentile": 0.22831}, "CVE-2025-53103": {"epss_score": 7e-05, "epss_percentile": 0.00453}, "CVE-2025-53104": {"epss_score": 0.00182, "epss_percentile": 0.40139}, "CVE-2025-53105": {"epss_score": 0.00112, "epss_percentile": 0.30528}, "CVE-2025-53106": {"epss_score": 0.00058, "epss_percentile": 0.18379}, "CVE-2025-53107": {"epss_score": 0.00089, "epss_percentile": 0.25871}, "CVE-2025-53108": {"epss_score": 0.00055, "epss_percentile": 0.17518}, "CVE-2025-53109": {"epss_score": 0.00185, "epss_percentile": 0.405}, "CVE-2025-53110": {"epss_score": 0.00049, "epss_percentile": 0.15477}, "CVE-2025-53111": {"epss_score": 0.00048, "epss_percentile": 0.15022}, "CVE-2025-53112": {"epss_score": 0.00037, "epss_percentile": 0.11037}, "CVE-2025-53113": {"epss_score": 0.00033, "epss_percentile": 0.09293}, "CVE-2025-53118": {"epss_score": 0.26855, "epss_percentile": 0.96186}, "CVE-2025-53119": {"epss_score": 0.00072, "epss_percentile": 0.2241}, "CVE-2025-53120": {"epss_score": 0.0098, "epss_percentile": 0.76271}, "CVE-2025-53121": {"epss_score": 0.00031, "epss_percentile": 0.08667}, "CVE-2025-53122": {"epss_score": 0.00023, "epss_percentile": 0.05489}, "CVE-2025-53131": {"epss_score": 0.0007, "epss_percentile": 0.21768}, "CVE-2025-53132": {"epss_score": 0.00052, "epss_percentile": 0.16564}, "CVE-2025-53133": {"epss_score": 0.00047, "epss_percentile": 0.14618}, "CVE-2025-53134": {"epss_score": 0.0005, "epss_percentile": 0.15672}, "CVE-2025-53135": {"epss_score": 0.00036, "epss_percentile": 0.1049}, "CVE-2025-53136": {"epss_score": 0.00075, "epss_percentile": 0.22897}, "CVE-2025-53137": {"epss_score": 0.00047, "epss_percentile": 0.14618}, "CVE-2025-53138": {"epss_score": 0.00238, "epss_percentile": 0.46812}, "CVE-2025-53139": {"epss_score": 0.00026, "epss_percentile": 0.06573}, "CVE-2025-53140": {"epss_score": 0.00036, "epss_percentile": 0.10247}, "CVE-2025-53141": {"epss_score": 0.00051, "epss_percentile": 0.16284}, "CVE-2025-53142": {"epss_score": 0.00036, "epss_percentile": 0.10247}, "CVE-2025-53143": {"epss_score": 0.019, "epss_percentile": 0.82769}, "CVE-2025-53144": {"epss_score": 0.019, "epss_percentile": 0.82769}, "CVE-2025-53145": {"epss_score": 0.019, "epss_percentile": 0.82769}, "CVE-2025-53147": {"epss_score": 0.00036, "epss_percentile": 0.10247}, "CVE-2025-53148": {"epss_score": 0.00182, "epss_percentile": 0.40141}, "CVE-2025-53149": {"epss_score": 0.00174, "epss_percentile": 0.39158}, "CVE-2025-53150": {"epss_score": 0.00051, "epss_percentile": 0.16135}, "CVE-2025-53151": {"epss_score": 0.00051, "epss_percentile": 0.16284}, "CVE-2025-53152": {"epss_score": 0.00051, "epss_percentile": 0.16284}, "CVE-2025-53153": {"epss_score": 0.00182, "epss_percentile": 0.40141}, "CVE-2025-53154": {"epss_score": 0.00051, "epss_percentile": 0.16284}, "CVE-2025-53155": {"epss_score": 0.00051, "epss_percentile": 0.16284}, "CVE-2025-53156": {"epss_score": 0.00057, "epss_percentile": 0.18071}, "CVE-2025-53167": {"epss_score": 0.00023, "epss_percentile": 0.05629}, "CVE-2025-53168": {"epss_score": 0.00011, "epss_percentile": 0.01107}, "CVE-2025-53169": {"epss_score": 0.00013, "epss_percentile": 0.0161}, "CVE-2025-53170": {"epss_score": 9e-05, "epss_percentile": 0.00619}, "CVE-2025-53171": {"epss_score": 0.0001, "epss_percentile": 0.00889}, "CVE-2025-53172": {"epss_score": 0.0001, "epss_percentile": 0.00889}, "CVE-2025-53173": {"epss_score": 0.00032, "epss_percentile": 0.0909}, "CVE-2025-53174": {"epss_score": 0.0001, "epss_percentile": 0.00889}, "CVE-2025-53175": {"epss_score": 0.0001, "epss_percentile": 0.00889}, "CVE-2025-53176": {"epss_score": 0.0001, "epss_percentile": 0.00889}, "CVE-2025-53177": {"epss_score": 8e-05, "epss_percentile": 0.00506}, "CVE-2025-53178": {"epss_score": 8e-05, "epss_percentile": 0.00471}, "CVE-2025-53179": {"epss_score": 0.00021, "epss_percentile": 0.04876}, "CVE-2025-53180": {"epss_score": 0.00021, "epss_percentile": 0.04876}, "CVE-2025-53181": {"epss_score": 0.00021, "epss_percentile": 0.04876}, "CVE-2025-53182": {"epss_score": 0.00021, "epss_percentile": 0.04876}, "CVE-2025-53183": {"epss_score": 0.00021, "epss_percentile": 0.04876}, "CVE-2025-53184": {"epss_score": 0.00021, "epss_percentile": 0.04876}, "CVE-2025-53185": {"epss_score": 9e-05, "epss_percentile": 0.00638}, "CVE-2025-53186": {"epss_score": 0.0001, "epss_percentile": 0.00804}, "CVE-2025-53187": {"epss_score": 0.00071, "epss_percentile": 0.22215}, "CVE-2025-53192": {"epss_score": 0.00061, "epss_percentile": 0.19437}, "CVE-2025-53193": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53194": {"epss_score": 0.00092, "epss_percentile": 0.26415}, "CVE-2025-53195": {"epss_score": 0.00025, "epss_percentile": 0.06331}, "CVE-2025-53196": {"epss_score": 0.00056, "epss_percentile": 0.17746}, "CVE-2025-53197": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53198": {"epss_score": 0.00108, "epss_percentile": 0.29873}, "CVE-2025-53199": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53200": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-53201": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-53202": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53203": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53204": {"epss_score": 0.00108, "epss_percentile": 0.29873}, "CVE-2025-53205": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-53206": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53207": {"epss_score": 0.00108, "epss_percentile": 0.29873}, "CVE-2025-53208": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-53210": {"epss_score": 0.0022, "epss_percentile": 0.44626}, "CVE-2025-53211": {"epss_score": 0.00037, "epss_percentile": 0.10864}, "CVE-2025-53212": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53213": {"epss_score": 0.00053, "epss_percentile": 0.16891}, "CVE-2025-53214": {"epss_score": 0.00033, "epss_percentile": 0.09284}, "CVE-2025-53215": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53216": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-53218": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-53219": {"epss_score": 0.00029, "epss_percentile": 0.07668}, "CVE-2025-53220": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53221": {"epss_score": 0.00069, "epss_percentile": 0.21463}, "CVE-2025-53223": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53224": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53225": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53226": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53227": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-53229": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-53230": {"epss_score": 0.00067, "epss_percentile": 0.21112}, "CVE-2025-53232": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-53234": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-53235": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-53236": {"epss_score": 0.00051, "epss_percentile": 0.1602}, "CVE-2025-53238": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-53239": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-53241": {"epss_score": 0.00042, "epss_percentile": 0.12886}, "CVE-2025-53242": {"epss_score": 0.00058, "epss_percentile": 0.18511}, "CVE-2025-53243": {"epss_score": 0.00098, "epss_percentile": 0.27674}, "CVE-2025-53244": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-53245": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-53246": {"epss_score": 0.0005, "epss_percentile": 0.15884}, "CVE-2025-53247": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-53248": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-53249": {"epss_score": 0.0003, "epss_percentile": 0.07981}, "CVE-2025-53250": {"epss_score": 0.00046, "epss_percentile": 0.1415}, "CVE-2025-53251": {"epss_score": 0.00082, "epss_percentile": 0.24472}, "CVE-2025-53252": {"epss_score": 0.00165, "epss_percentile": 0.38013}, "CVE-2025-53253": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-53254": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53255": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-53256": {"epss_score": 0.00032, "epss_percentile": 0.08798}, "CVE-2025-53257": {"epss_score": 0.00109, "epss_percentile": 0.2997}, "CVE-2025-53258": {"epss_score": 0.00032, "epss_percentile": 0.08798}, "CVE-2025-53259": {"epss_score": 0.00109, "epss_percentile": 0.2997}, "CVE-2025-53260": {"epss_score": 0.00056, "epss_percentile": 0.17792}, "CVE-2025-53261": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53262": {"epss_score": 0.00016, "epss_percentile": 0.02857}, "CVE-2025-53263": {"epss_score": 0.00016, "epss_percentile": 0.02857}, "CVE-2025-53264": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53265": {"epss_score": 0.00016, "epss_percentile": 0.02857}, "CVE-2025-53266": {"epss_score": 0.00051, "epss_percentile": 0.1606}, "CVE-2025-53267": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53268": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53269": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53270": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53271": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53272": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53273": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53274": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53275": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53276": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53277": {"epss_score": 0.00019, "epss_percentile": 0.04199}, "CVE-2025-53278": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53279": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53280": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53281": {"epss_score": 0.00109, "epss_percentile": 0.2997}, "CVE-2025-53282": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53283": {"epss_score": 0.00061, "epss_percentile": 0.19455}, "CVE-2025-53284": {"epss_score": 0.00038, "epss_percentile": 0.11231}, "CVE-2025-53285": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-53286": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-53287": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-53288": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-53289": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53290": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53291": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-53292": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53293": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-53294": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53295": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-53296": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-53297": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-53298": {"epss_score": 0.00062, "epss_percentile": 0.19636}, "CVE-2025-53299": {"epss_score": 0.00098, "epss_percentile": 0.27674}, "CVE-2025-53300": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53301": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53303": {"epss_score": 0.00071, "epss_percentile": 0.22114}, "CVE-2025-53304": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-53305": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53306": {"epss_score": 0.00032, "epss_percentile": 0.08798}, "CVE-2025-53307": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53308": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53309": {"epss_score": 0.00037, "epss_percentile": 0.10864}, "CVE-2025-53310": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53311": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53312": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53313": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53314": {"epss_score": 0.00017, "epss_percentile": 0.03211}, "CVE-2025-53315": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53316": {"epss_score": 0.00021, "epss_percentile": 0.04762}, "CVE-2025-53317": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53318": {"epss_score": 0.00048, "epss_percentile": 0.15249}, "CVE-2025-53319": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53320": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53321": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53322": {"epss_score": 0.00037, "epss_percentile": 0.10864}, "CVE-2025-53323": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-53324": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-53325": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-53326": {"epss_score": 0.0022, "epss_percentile": 0.44626}, "CVE-2025-53327": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53328": {"epss_score": 0.00204, "epss_percentile": 0.42591}, "CVE-2025-53329": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53330": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-53331": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53332": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53334": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-53336": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53337": {"epss_score": 0.00069, "epss_percentile": 0.21463}, "CVE-2025-53338": {"epss_score": 0.00015, "epss_percentile": 0.02527}, "CVE-2025-53339": {"epss_score": 0.00109, "epss_percentile": 0.2997}, "CVE-2025-53340": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-53341": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-53342": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-53343": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-53344": {"epss_score": 0.00014, "epss_percentile": 0.02122}, "CVE-2025-53347": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-53348": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-53349": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-53350": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-53351": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-53352": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-53354": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-53355": {"epss_score": 0.00026, "epss_percentile": 0.06714}, "CVE-2025-53357": {"epss_score": 0.00036, "epss_percentile": 0.10274}, "CVE-2025-53358": {"epss_score": 0.00078, "epss_percentile": 0.23745}, "CVE-2025-53359": {"epss_score": 0.00057, "epss_percentile": 0.18111}, "CVE-2025-53360": {"epss_score": 0.00046, "epss_percentile": 0.14275}, "CVE-2025-53363": {"epss_score": 0.00078, "epss_percentile": 0.23585}, "CVE-2025-53364": {"epss_score": 0.00659, "epss_percentile": 0.70505}, "CVE-2025-53365": {"epss_score": 0.00022, "epss_percentile": 0.05278}, "CVE-2025-53366": {"epss_score": 0.00031, "epss_percentile": 0.08385}, "CVE-2025-53367": {"epss_score": 0.00011, "epss_percentile": 0.01097}, "CVE-2025-53368": {"epss_score": 0.00028, "epss_percentile": 0.0751}, "CVE-2025-53369": {"epss_score": 0.00054, "epss_percentile": 0.17217}, "CVE-2025-53370": {"epss_score": 0.00028, "epss_percentile": 0.0751}, "CVE-2025-53371": {"epss_score": 0.0005, "epss_percentile": 0.15697}, "CVE-2025-53372": {"epss_score": 0.00043, "epss_percentile": 0.131}, "CVE-2025-53373": {"epss_score": 0.00058, "epss_percentile": 0.18613}, "CVE-2025-53374": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-53375": {"epss_score": 0.00063, "epss_percentile": 0.19823}, "CVE-2025-53376": {"epss_score": 0.00529, "epss_percentile": 0.66594}, "CVE-2025-53377": {"epss_score": 0.00034, "epss_percentile": 0.09777}, "CVE-2025-53378": {"epss_score": 0.00094, "epss_percentile": 0.27032}, "CVE-2025-53391": {"epss_score": 0.00019, "epss_percentile": 0.04055}, "CVE-2025-53392": {"epss_score": 0.00038, "epss_percentile": 0.11303}, "CVE-2025-53393": {"epss_score": 0.00051, "epss_percentile": 0.16299}, "CVE-2025-53394": {"epss_score": 0.00013, "epss_percentile": 0.01434}, "CVE-2025-53395": {"epss_score": 0.00012, "epss_percentile": 0.01259}, "CVE-2025-53396": {"epss_score": 0.00025, "epss_percentile": 0.06143}, "CVE-2025-53397": {"epss_score": 0.00038, "epss_percentile": 0.11277}, "CVE-2025-53398": {"epss_score": 0.00011, "epss_percentile": 0.01023}, "CVE-2025-53399": {"epss_score": 0.00137, "epss_percentile": 0.34288}, "CVE-2025-53405": {"epss_score": 0.00128, "epss_percentile": 0.32955}, "CVE-2025-53406": {"epss_score": 0.00058, "epss_percentile": 0.18287}, "CVE-2025-53407": {"epss_score": 0.00058, "epss_percentile": 0.18287}, "CVE-2025-53408": {"epss_score": 0.00135, "epss_percentile": 0.34051}, "CVE-2025-53409": {"epss_score": 0.00137, "epss_percentile": 0.34286}, "CVE-2025-53410": {"epss_score": 0.00137, "epss_percentile": 0.34286}, "CVE-2025-53411": {"epss_score": 0.00141, "epss_percentile": 0.34832}, "CVE-2025-53412": {"epss_score": 0.00135, "epss_percentile": 0.34051}, "CVE-2025-53413": {"epss_score": 0.00137, "epss_percentile": 0.34286}, "CVE-2025-53414": {"epss_score": 0.00128, "epss_percentile": 0.32955}, "CVE-2025-53415": {"epss_score": 0.00888, "epss_percentile": 0.74995}, "CVE-2025-53416": {"epss_score": 0.00888, "epss_percentile": 0.74995}, "CVE-2025-53417": {"epss_score": 0.00536, "epss_percentile": 0.66859}, "CVE-2025-53418": {"epss_score": 0.00074, "epss_percentile": 0.22692}, "CVE-2025-53419": {"epss_score": 0.00039, "epss_percentile": 0.11622}, "CVE-2025-53420": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-53421": {"epss_score": 0.00051, "epss_percentile": 0.1602}, "CVE-2025-53422": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-53423": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-53424": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2025-53425": {"epss_score": 0.00057, "epss_percentile": 0.18059}, "CVE-2025-53426": {"epss_score": 0.00044, "epss_percentile": 0.13623}, "CVE-2025-53427": {"epss_score": 0.00061, "epss_percentile": 0.19522}, "CVE-2025-53428": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-53429": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53430": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53431": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53432": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53433": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53434": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53435": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53436": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53437": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53438": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53439": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53441": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53442": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53443": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53445": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53446": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53447": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53448": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53449": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-53450": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-53451": {"epss_score": 0.0002, "epss_percentile": 0.04632}, "CVE-2025-53452": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-53453": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-53454": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-53455": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-53456": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-53457": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2025-53458": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-53460": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-53461": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2025-53462": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-53463": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-53464": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-53465": {"epss_score": 0.00066, "epss_percentile": 0.2069}, "CVE-2025-53466": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-53467": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-53468": {"epss_score": 0.00044, "epss_percentile": 0.13582}, "CVE-2025-53469": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-53471": {"epss_score": 0.00017, "epss_percentile": 0.03375}, "CVE-2025-53472": {"epss_score": 0.00156, "epss_percentile": 0.36982}, "CVE-2025-53473": {"epss_score": 0.00041, "epss_percentile": 0.12358}, "CVE-2025-53474": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-53475": {"epss_score": 0.00489, "epss_percentile": 0.64906}, "CVE-2025-53476": {"epss_score": 0.00058, "epss_percentile": 0.18414}, "CVE-2025-53478": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-53479": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-53480": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-53481": {"epss_score": 0.00054, "epss_percentile": 0.17197}, "CVE-2025-53482": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-53483": {"epss_score": 0.00018, "epss_percentile": 0.03741}, "CVE-2025-53484": {"epss_score": 0.00052, "epss_percentile": 0.16637}, "CVE-2025-53485": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-53486": {"epss_score": 0.00027, "epss_percentile": 0.06922}, "CVE-2025-53487": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-53488": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-53489": {"epss_score": 0.0005, "epss_percentile": 0.15766}, "CVE-2025-53490": {"epss_score": 0.0005, "epss_percentile": 0.15766}, "CVE-2025-53491": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-53492": {"epss_score": 0.00033, "epss_percentile": 0.093}, "CVE-2025-53493": {"epss_score": 0.00061, "epss_percentile": 0.1935}, "CVE-2025-53494": {"epss_score": 0.00061, "epss_percentile": 0.1935}, "CVE-2025-53495": {"epss_score": 0.00048, "epss_percentile": 0.15147}, "CVE-2025-53496": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-53497": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-53498": {"epss_score": 0.00036, "epss_percentile": 0.10367}, "CVE-2025-53499": {"epss_score": 0.00048, "epss_percentile": 0.15147}, "CVE-2025-53500": {"epss_score": 0.00069, "epss_percentile": 0.21606}, "CVE-2025-53501": {"epss_score": 0.00076, "epss_percentile": 0.2312}, "CVE-2025-53502": {"epss_score": 0.00056, "epss_percentile": 0.1783}, "CVE-2025-53503": {"epss_score": 0.00026, "epss_percentile": 0.06658}, "CVE-2025-53504": {"epss_score": 0.00057, "epss_percentile": 0.1808}, "CVE-2025-53505": {"epss_score": 0.00063, "epss_percentile": 0.20048}, "CVE-2025-53506": {"epss_score": 0.00205, "epss_percentile": 0.42761}, "CVE-2025-53507": {"epss_score": 0.00061, "epss_percentile": 0.19394}, "CVE-2025-53508": {"epss_score": 0.00302, "epss_percentile": 0.53088}, "CVE-2025-53509": {"epss_score": 0.00049, "epss_percentile": 0.15451}, "CVE-2025-53510": {"epss_score": 0.00356, "epss_percentile": 0.57357}, "CVE-2025-53511": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-53512": {"epss_score": 0.00047, "epss_percentile": 0.14774}, "CVE-2025-53513": {"epss_score": 0.00085, "epss_percentile": 0.25154}, "CVE-2025-53514": {"epss_score": 0.00042, "epss_percentile": 0.12479}, "CVE-2025-53515": {"epss_score": 0.0023, "epss_percentile": 0.4573}, "CVE-2025-53518": {"epss_score": 0.0022, "epss_percentile": 0.44584}, "CVE-2025-53519": {"epss_score": 0.00038, "epss_percentile": 0.11277}, "CVE-2025-53520": {"epss_score": 0.00016, "epss_percentile": 0.02834}, "CVE-2025-53521": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-53522": {"epss_score": 0.00033, "epss_percentile": 0.09195}, "CVE-2025-53523": {"epss_score": 0.00032, "epss_percentile": 0.088}, "CVE-2025-53524": {"epss_score": 0.00018, "epss_percentile": 0.03717}, "CVE-2025-53525": {"epss_score": 0.00034, "epss_percentile": 0.09777}, "CVE-2025-53526": {"epss_score": 0.00035, "epss_percentile": 0.10049}, "CVE-2025-53527": {"epss_score": 0.00045, "epss_percentile": 0.13915}, "CVE-2025-53528": {"epss_score": 0.00035, "epss_percentile": 0.10007}, "CVE-2025-53529": {"epss_score": 0.00159, "epss_percentile": 0.37357}, "CVE-2025-53530": {"epss_score": 0.00147, "epss_percentile": 0.35675}, "CVE-2025-53531": {"epss_score": 0.00147, "epss_percentile": 0.35675}, "CVE-2025-53532": {"epss_score": 0.00036, "epss_percentile": 0.10256}, "CVE-2025-53533": {"epss_score": 0.00052, "epss_percentile": 0.16668}, "CVE-2025-53534": {"epss_score": 0.00337, "epss_percentile": 0.56024}, "CVE-2025-53535": {"epss_score": 0.00104, "epss_percentile": 0.2919}, "CVE-2025-53536": {"epss_score": 0.00125, "epss_percentile": 0.32512}, "CVE-2025-53537": {"epss_score": 0.00079, "epss_percentile": 0.23952}, "CVE-2025-53538": {"epss_score": 0.00054, "epss_percentile": 0.17103}, "CVE-2025-53539": {"epss_score": 0.00091, "epss_percentile": 0.26233}, "CVE-2025-53540": {"epss_score": 0.00158, "epss_percentile": 0.37238}, "CVE-2025-53541": {"epss_score": 0.00028, "epss_percentile": 0.07578}, "CVE-2025-53542": {"epss_score": 0.00014, "epss_percentile": 0.01774}, "CVE-2025-53543": {"epss_score": 0.00019, "epss_percentile": 0.04179}, "CVE-2025-53544": {"epss_score": 0.00103, "epss_percentile": 0.29049}, "CVE-2025-53545": {"epss_score": 0.00058, "epss_percentile": 0.18613}, "CVE-2025-53546": {"epss_score": 0.00042, "epss_percentile": 0.12575}, "CVE-2025-53547": {"epss_score": 5e-05, "epss_percentile": 0.00228}, "CVE-2025-53548": {"epss_score": 0.00022, "epss_percentile": 0.05227}, "CVE-2025-53549": {"epss_score": 0.00035, "epss_percentile": 0.09911}, "CVE-2025-53557": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-53558": {"epss_score": 0.09942, "epss_percentile": 0.92783}, "CVE-2025-53559": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-53560": {"epss_score": 0.00114, "epss_percentile": 0.3083}, "CVE-2025-53561": {"epss_score": 0.00071, "epss_percentile": 0.22117}, "CVE-2025-53562": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53563": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53564": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53565": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-53566": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53567": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-53568": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53569": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-53570": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-53571": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-53572": {"epss_score": 0.00098, "epss_percentile": 0.27674}, "CVE-2025-53573": {"epss_score": 0.00042, "epss_percentile": 0.12909}, "CVE-2025-53574": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-53575": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53576": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-53577": {"epss_score": 0.00092, "epss_percentile": 0.2657}, "CVE-2025-53578": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-53579": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-53580": {"epss_score": 0.0008, "epss_percentile": 0.24141}, "CVE-2025-53581": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-53582": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-53583": {"epss_score": 0.00098, "epss_percentile": 0.27674}, "CVE-2025-53584": {"epss_score": 0.00098, "epss_percentile": 0.27674}, "CVE-2025-53585": {"epss_score": 0.0004, "epss_percentile": 0.12164}, "CVE-2025-53586": {"epss_score": 0.00058, "epss_percentile": 0.18511}, "CVE-2025-53587": {"epss_score": 0.00034, "epss_percentile": 0.09617}, "CVE-2025-53588": {"epss_score": 0.00083, "epss_percentile": 0.24732}, "CVE-2025-53589": {"epss_score": 0.00128, "epss_percentile": 0.32955}, "CVE-2025-53590": {"epss_score": 0.00128, "epss_percentile": 0.32955}, "CVE-2025-53591": {"epss_score": 0.00051, "epss_percentile": 0.16016}, "CVE-2025-53592": {"epss_score": 0.00118, "epss_percentile": 0.31388}, "CVE-2025-53593": {"epss_score": 0.00116, "epss_percentile": 0.31165}, "CVE-2025-53594": {"epss_score": 0.00014, "epss_percentile": 0.02108}, "CVE-2025-53595": {"epss_score": 0.0012, "epss_percentile": 0.3175}, "CVE-2025-53596": {"epss_score": 0.00128, "epss_percentile": 0.32955}, "CVE-2025-53597": {"epss_score": 0.00116, "epss_percentile": 0.31165}, "CVE-2025-53599": {"epss_score": 0.00058, "epss_percentile": 0.1826}, "CVE-2025-53600": {"epss_score": 0.00021, "epss_percentile": 0.04694}, "CVE-2025-53602": {"epss_score": 0.0004, "epss_percentile": 0.11992}, "CVE-2025-53603": {"epss_score": 0.00098, "epss_percentile": 0.27791}, "CVE-2025-53604": {"epss_score": 0.00055, "epss_percentile": 0.17601}, "CVE-2025-53605": {"epss_score": 0.00027, "epss_percentile": 0.07084}, "CVE-2025-53606": {"epss_score": 0.00337, "epss_percentile": 0.56016}, "CVE-2025-53609": {"epss_score": 0.00082, "epss_percentile": 0.2455}, "CVE-2025-53618": {"epss_score": 0.00039, "epss_percentile": 0.11717}, "CVE-2025-53619": {"epss_score": 0.00039, "epss_percentile": 0.11717}, "CVE-2025-53620": {"epss_score": 0.00025, "epss_percentile": 0.06215}, "CVE-2025-53621": {"epss_score": 0.00048, "epss_percentile": 0.15075}, "CVE-2025-53622": {"epss_score": 0.00039, "epss_percentile": 0.11704}, "CVE-2025-53623": {"epss_score": 0.00086, "epss_percentile": 0.25309}, "CVE-2025-53624": {"epss_score": 0.03312, "epss_percentile": 0.86894}, "CVE-2025-53625": {"epss_score": 0.00075, "epss_percentile": 0.22895}, "CVE-2025-53626": {"epss_score": 0.00044, "epss_percentile": 0.1337}, "CVE-2025-53627": {"epss_score": 0.00029, "epss_percentile": 0.07649}, "CVE-2025-53628": {"epss_score": 0.00028, "epss_percentile": 0.07287}, "CVE-2025-53629": {"epss_score": 0.00099, "epss_percentile": 0.27853}, "CVE-2025-53630": {"epss_score": 0.0006, "epss_percentile": 0.19177}, "CVE-2025-53631": {"epss_score": 0.00062, "epss_percentile": 0.19677}, "CVE-2025-53632": {"epss_score": 0.00049, "epss_percentile": 0.15635}, "CVE-2025-53633": {"epss_score": 0.00115, "epss_percentile": 0.31013}, "CVE-2025-53634": {"epss_score": 0.00187, "epss_percentile": 0.40739}, "CVE-2025-53636": {"epss_score": 0.00091, "epss_percentile": 0.26282}, "CVE-2025-53637": {"epss_score": 0.00028, "epss_percentile": 0.07215}, "CVE-2025-53638": {"epss_score": 0.0006, "epss_percentile": 0.19177}, "CVE-2025-53639": {"epss_score": 0.00057, "epss_percentile": 0.1812}, "CVE-2025-53640": {"epss_score": 0.00107, "epss_percentile": 0.29689}, "CVE-2025-53641": {"epss_score": 0.0004, "epss_percentile": 0.12167}, "CVE-2025-53642": {"epss_score": 0.00027, "epss_percentile": 0.06951}, "CVE-2025-53643": {"epss_score": 0.00047, "epss_percentile": 0.14654}, "CVE-2025-53644": {"epss_score": 0.00062, "epss_percentile": 0.19759}, "CVE-2025-53645": {"epss_score": 0.00286, "epss_percentile": 0.51689}, "CVE-2025-53649": {"epss_score": 0.00013, "epss_percentile": 0.01725}, "CVE-2025-53650": {"epss_score": 0.00065, "epss_percentile": 0.20449}, "CVE-2025-53651": {"epss_score": 0.00241, "epss_percentile": 0.47262}, "CVE-2025-53652": {"epss_score": 0.00026, "epss_percentile": 0.06457}, "CVE-2025-53653": {"epss_score": 0.0003, "epss_percentile": 0.08166}, "CVE-2025-53654": {"epss_score": 0.0003, "epss_percentile": 0.08208}, "CVE-2025-53655": {"epss_score": 0.00042, "epss_percentile": 0.12699}, "CVE-2025-53656": {"epss_score": 0.00048, "epss_percentile": 0.15249}, "CVE-2025-53657": {"epss_score": 0.00029, "epss_percentile": 0.07832}, "CVE-2025-53658": {"epss_score": 0.00022, "epss_percentile": 0.04979}, "CVE-2025-53659": {"epss_score": 0.00033, "epss_percentile": 0.09427}, "CVE-2025-53660": {"epss_score": 0.00029, "epss_percentile": 0.07832}, "CVE-2025-53661": {"epss_score": 0.00029, "epss_percentile": 0.07832}, "CVE-2025-53662": {"epss_score": 0.00048, "epss_percentile": 0.15249}, "CVE-2025-53663": {"epss_score": 0.00054, "epss_percentile": 0.1718}, "CVE-2025-53664": {"epss_score": 0.00085, "epss_percentile": 0.25072}, "CVE-2025-53665": {"epss_score": 0.00038, "epss_percentile": 0.11092}, "CVE-2025-53666": {"epss_score": 0.00033, "epss_percentile": 0.09427}, "CVE-2025-53667": {"epss_score": 0.00042, "epss_percentile": 0.12699}, "CVE-2025-53668": {"epss_score": 0.00033, "epss_percentile": 0.09427}, "CVE-2025-53669": {"epss_score": 0.00029, "epss_percentile": 0.07832}, "CVE-2025-53670": {"epss_score": 0.00019, "epss_percentile": 0.04328}, "CVE-2025-53671": {"epss_score": 0.00019, "epss_percentile": 0.04146}, "CVE-2025-53672": {"epss_score": 0.00023, "epss_percentile": 0.05356}, "CVE-2025-53673": {"epss_score": 0.00023, "epss_percentile": 0.05356}, "CVE-2025-53674": {"epss_score": 0.00039, "epss_percentile": 0.11461}, "CVE-2025-53675": {"epss_score": 0.00048, "epss_percentile": 0.15249}, "CVE-2025-53676": {"epss_score": 0.00023, "epss_percentile": 0.05356}, "CVE-2025-53677": {"epss_score": 0.00042, "epss_percentile": 0.12699}, "CVE-2025-53678": {"epss_score": 0.00023, "epss_percentile": 0.05356}, "CVE-2025-53679": {"epss_score": 0.00237, "epss_percentile": 0.46649}, "CVE-2025-53689": {"epss_score": 0.00062, "epss_percentile": 0.19743}, "CVE-2025-53690": {"epss_score": 0.08901, "epss_percentile": 0.92307}, "CVE-2025-53691": {"epss_score": 0.01859, "epss_percentile": 0.82585}, "CVE-2025-53692": {"epss_score": 0.00042, "epss_percentile": 0.12703}, "CVE-2025-53693": {"epss_score": 0.00201, "epss_percentile": 0.42371}, "CVE-2025-53694": {"epss_score": 0.00077, "epss_percentile": 0.23432}, "CVE-2025-53695": {"epss_score": 0.00197, "epss_percentile": 0.4187}, "CVE-2025-53696": {"epss_score": 9e-05, "epss_percentile": 0.00738}, "CVE-2025-53701": {"epss_score": 0.00035, "epss_percentile": 0.09942}, "CVE-2025-53702": {"epss_score": 0.00029, "epss_percentile": 0.07732}, "CVE-2025-53703": {"epss_score": 0.00015, "epss_percentile": 0.02463}, "CVE-2025-53704": {"epss_score": 0.00038, "epss_percentile": 0.11183}, "CVE-2025-53705": {"epss_score": 0.00021, "epss_percentile": 0.04744}, "CVE-2025-53709": {"epss_score": 0.00058, "epss_percentile": 0.18609}, "CVE-2025-53710": {"epss_score": 0.00047, "epss_percentile": 0.14894}, "CVE-2025-53711": {"epss_score": 0.00056, "epss_percentile": 0.17872}, "CVE-2025-53712": {"epss_score": 0.00056, "epss_percentile": 0.17872}, "CVE-2025-53713": {"epss_score": 0.00056, "epss_percentile": 0.17872}, "CVE-2025-53714": {"epss_score": 0.00056, "epss_percentile": 0.17872}, "CVE-2025-53715": {"epss_score": 0.00056, "epss_percentile": 0.17872}, "CVE-2025-53716": {"epss_score": 0.00169, "epss_percentile": 0.38607}, "CVE-2025-53717": {"epss_score": 0.00079, "epss_percentile": 0.23889}, "CVE-2025-53718": {"epss_score": 0.00036, "epss_percentile": 0.10247}, "CVE-2025-53719": {"epss_score": 0.00182, "epss_percentile": 0.40141}, "CVE-2025-53720": {"epss_score": 0.00053, "epss_percentile": 0.16846}, "CVE-2025-53721": {"epss_score": 0.00036, "epss_percentile": 0.10247}, "CVE-2025-53722": {"epss_score": 0.08292, "epss_percentile": 0.91974}, "CVE-2025-53723": {"epss_score": 0.00128, "epss_percentile": 0.33005}, "CVE-2025-53724": {"epss_score": 0.00128, "epss_percentile": 0.33005}, "CVE-2025-53725": {"epss_score": 0.00128, "epss_percentile": 0.33005}, "CVE-2025-53726": {"epss_score": 0.00128, "epss_percentile": 0.33005}, "CVE-2025-53727": {"epss_score": 0.00085, "epss_percentile": 0.25162}, "CVE-2025-53728": {"epss_score": 0.00066, "epss_percentile": 0.20844}, "CVE-2025-53729": {"epss_score": 0.00047, "epss_percentile": 0.14845}, "CVE-2025-53730": {"epss_score": 0.00051, "epss_percentile": 0.16066}, "CVE-2025-53731": {"epss_score": 0.00088, "epss_percentile": 0.25764}, "CVE-2025-53732": {"epss_score": 0.00051, "epss_percentile": 0.16066}, "CVE-2025-53733": {"epss_score": 0.00169, "epss_percentile": 0.38633}, "CVE-2025-53734": {"epss_score": 0.00051, "epss_percentile": 0.16066}, "CVE-2025-53735": {"epss_score": 0.00067, "epss_percentile": 0.20978}, "CVE-2025-53736": {"epss_score": 0.00052, "epss_percentile": 0.1635}, "CVE-2025-53737": {"epss_score": 0.00067, "epss_percentile": 0.20978}, "CVE-2025-53738": {"epss_score": 0.00067, "epss_percentile": 0.20978}, "CVE-2025-53739": {"epss_score": 0.00126, "epss_percentile": 0.32666}, "CVE-2025-53740": {"epss_score": 0.00088, "epss_percentile": 0.25764}, "CVE-2025-53741": {"epss_score": 0.00067, "epss_percentile": 0.20978}, "CVE-2025-53742": {"epss_score": 0.00033, "epss_percentile": 0.09427}, "CVE-2025-53743": {"epss_score": 0.00042, "epss_percentile": 0.12699}, "CVE-2025-53744": {"epss_score": 0.00128, "epss_percentile": 0.32989}, "CVE-2025-53754": {"epss_score": 0.00026, "epss_percentile": 0.06381}, "CVE-2025-53755": {"epss_score": 0.00012, "epss_percentile": 0.01147}, "CVE-2025-53756": {"epss_score": 0.00126, "epss_percentile": 0.32753}, "CVE-2025-53757": {"epss_score": 0.00103, "epss_percentile": 0.2896}, "CVE-2025-53758": {"epss_score": 0.00017, "epss_percentile": 0.03351}, "CVE-2025-53759": {"epss_score": 0.00126, "epss_percentile": 0.32666}, "CVE-2025-53760": {"epss_score": 0.00169, "epss_percentile": 0.38646}, "CVE-2025-53761": {"epss_score": 0.00067, "epss_percentile": 0.20978}, "CVE-2025-53762": {"epss_score": 0.00099, "epss_percentile": 0.27857}, "CVE-2025-53763": {"epss_score": 0.00174, "epss_percentile": 0.39163}, "CVE-2025-53765": {"epss_score": 0.00065, "epss_percentile": 0.20451}, "CVE-2025-53766": {"epss_score": 0.00359, "epss_percentile": 0.57604}, "CVE-2025-53767": {"epss_score": 0.0012, "epss_percentile": 0.31793}, "CVE-2025-53768": {"epss_score": 0.00026, "epss_percentile": 0.06559}, "CVE-2025-53769": {"epss_score": 0.00083, "epss_percentile": 0.24625}, "CVE-2025-53770": {"epss_score": 0.89607, "epss_percentile": 0.99534}, "CVE-2025-53771": {"epss_score": 0.44417, "epss_percentile": 0.97434}, "CVE-2025-53772": {"epss_score": 0.00855, "epss_percentile": 0.74459}, "CVE-2025-53773": {"epss_score": 0.00494, "epss_percentile": 0.65086}, "CVE-2025-53774": {"epss_score": 0.00073, "epss_percentile": 0.22674}, "CVE-2025-53778": {"epss_score": 0.00199, "epss_percentile": 0.42099}, "CVE-2025-53779": {"epss_score": 0.00305, "epss_percentile": 0.53366}, "CVE-2025-53781": {"epss_score": 0.00164, "epss_percentile": 0.37866}, "CVE-2025-53782": {"epss_score": 0.00064, "epss_percentile": 0.20176}, "CVE-2025-53783": {"epss_score": 0.00051, "epss_percentile": 0.16036}, "CVE-2025-53784": {"epss_score": 0.00052, "epss_percentile": 0.16436}, "CVE-2025-53786": {"epss_score": 0.00086, "epss_percentile": 0.25294}, "CVE-2025-53787": {"epss_score": 0.00086, "epss_percentile": 0.25313}, "CVE-2025-53788": {"epss_score": 0.00028, "epss_percentile": 0.07266}, "CVE-2025-53789": {"epss_score": 0.00047, "epss_percentile": 0.14845}, "CVE-2025-53791": {"epss_score": 0.00087, "epss_percentile": 0.25619}, "CVE-2025-53792": {"epss_score": 0.00078, "epss_percentile": 0.23557}, "CVE-2025-53793": {"epss_score": 0.00134, "epss_percentile": 0.33894}, "CVE-2025-53795": {"epss_score": 0.0013, "epss_percentile": 0.33271}, "CVE-2025-53796": {"epss_score": 0.00074, "epss_percentile": 0.22843}, "CVE-2025-53797": {"epss_score": 0.00074, "epss_percentile": 0.22843}, "CVE-2025-53798": {"epss_score": 0.00074, "epss_percentile": 0.22843}, "CVE-2025-53799": {"epss_score": 0.0011, "epss_percentile": 0.30221}, "CVE-2025-53800": {"epss_score": 0.00164, "epss_percentile": 0.37907}, "CVE-2025-53801": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-53802": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-53803": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-53804": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-53805": {"epss_score": 0.00122, "epss_percentile": 0.32089}, "CVE-2025-53806": {"epss_score": 0.00074, "epss_percentile": 0.22843}, "CVE-2025-53807": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-53808": {"epss_score": 0.00188, "epss_percentile": 0.40857}, "CVE-2025-53809": {"epss_score": 0.00231, "epss_percentile": 0.45853}, "CVE-2025-53810": {"epss_score": 0.00188, "epss_percentile": 0.40857}, "CVE-2025-53811": {"epss_score": 0.00022, "epss_percentile": 0.05191}, "CVE-2025-53813": {"epss_score": 0.00022, "epss_percentile": 0.05191}, "CVE-2025-53814": {"epss_score": 0.00042, "epss_percentile": 0.12774}, "CVE-2025-53816": {"epss_score": 0.00124, "epss_percentile": 0.3245}, "CVE-2025-53817": {"epss_score": 0.00106, "epss_percentile": 0.29416}, "CVE-2025-53818": {"epss_score": 0.00217, "epss_percentile": 0.44335}, "CVE-2025-53819": {"epss_score": 0.00018, "epss_percentile": 0.03878}, "CVE-2025-53820": {"epss_score": 0.00037, "epss_percentile": 0.10734}, "CVE-2025-53821": {"epss_score": 0.0004, "epss_percentile": 0.11876}, "CVE-2025-53822": {"epss_score": 0.00037, "epss_percentile": 0.10734}, "CVE-2025-53823": {"epss_score": 0.00054, "epss_percentile": 0.17196}, "CVE-2025-53824": {"epss_score": 0.00027, "epss_percentile": 0.06776}, "CVE-2025-53825": {"epss_score": 0.00357, "epss_percentile": 0.57469}, "CVE-2025-53826": {"epss_score": 0.00367, "epss_percentile": 0.58105}, "CVE-2025-53832": {"epss_score": 0.00076, "epss_percentile": 0.23239}, "CVE-2025-53833": {"epss_score": 0.16757, "epss_percentile": 0.94729}, "CVE-2025-53834": {"epss_score": 0.00036, "epss_percentile": 0.10508}, "CVE-2025-53835": {"epss_score": 0.01142, "epss_percentile": 0.77978}, "CVE-2025-53836": {"epss_score": 0.02497, "epss_percentile": 0.84912}, "CVE-2025-53838": {"epss_score": 0.00067, "epss_percentile": 0.2105}, "CVE-2025-53839": {"epss_score": 0.00022, "epss_percentile": 0.05159}, "CVE-2025-53840": {"epss_score": 0.00033, "epss_percentile": 0.09289}, "CVE-2025-53841": {"epss_score": 0.00024, "epss_percentile": 0.06012}, "CVE-2025-53842": {"epss_score": 0.00013, "epss_percentile": 0.01531}, "CVE-2025-53843": {"epss_score": 0.00027, "epss_percentile": 0.06817}, "CVE-2025-53845": {"epss_score": 0.00124, "epss_percentile": 0.32435}, "CVE-2025-53853": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-53855": {"epss_score": 0.00045, "epss_percentile": 0.13826}, "CVE-2025-53856": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-53857": {"epss_score": 0.00028, "epss_percentile": 0.07271}, "CVE-2025-53858": {"epss_score": 0.00042, "epss_percentile": 0.12924}, "CVE-2025-53859": {"epss_score": 0.0009, "epss_percentile": 0.26128}, "CVE-2025-53860": {"epss_score": 0.0003, "epss_percentile": 0.08281}, "CVE-2025-53861": {"epss_score": 8e-05, "epss_percentile": 0.00513}, "CVE-2025-53862": {"epss_score": 0.00019, "epss_percentile": 0.04058}, "CVE-2025-53864": {"epss_score": 0.00044, "epss_percentile": 0.13604}, "CVE-2025-53865": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-53867": {"epss_score": 0.00254, "epss_percentile": 0.48512}, "CVE-2025-53868": {"epss_score": 0.00085, "epss_percentile": 0.25167}, "CVE-2025-53880": {"epss_score": 0.00615, "epss_percentile": 0.6929}, "CVE-2025-53881": {"epss_score": 0.00024, "epss_percentile": 0.06013}, "CVE-2025-53882": {"epss_score": 0.00018, "epss_percentile": 0.03962}, "CVE-2025-53883": {"epss_score": 0.0007, "epss_percentile": 0.21704}, "CVE-2025-53884": {"epss_score": 0.00017, "epss_percentile": 0.03422}, "CVE-2025-53885": {"epss_score": 0.00017, "epss_percentile": 0.03254}, "CVE-2025-53886": {"epss_score": 0.00041, "epss_percentile": 0.12426}, "CVE-2025-53887": {"epss_score": 0.00062, "epss_percentile": 0.19771}, "CVE-2025-53888": {"epss_score": 0.00134, "epss_percentile": 0.33804}, "CVE-2025-53889": {"epss_score": 0.0006, "epss_percentile": 0.19011}, "CVE-2025-53890": {"epss_score": 0.00424, "epss_percentile": 0.61685}, "CVE-2025-53891": {"epss_score": 0.00128, "epss_percentile": 0.3297}, "CVE-2025-53892": {"epss_score": 0.001, "epss_percentile": 0.28541}, "CVE-2025-53893": {"epss_score": 0.00248, "epss_percentile": 0.47911}, "CVE-2025-53895": {"epss_score": 0.00069, "epss_percentile": 0.21607}, "CVE-2025-53896": {"epss_score": 0.00029, "epss_percentile": 0.07832}, "CVE-2025-53897": {"epss_score": 0.00018, "epss_percentile": 0.03895}, "CVE-2025-53899": {"epss_score": 0.00052, "epss_percentile": 0.16356}, "CVE-2025-53900": {"epss_score": 0.0003, "epss_percentile": 0.08303}, "CVE-2025-53901": {"epss_score": 0.00089, "epss_percentile": 0.25909}, "CVE-2025-53902": {"epss_score": 0.00045, "epss_percentile": 0.13776}, "CVE-2025-53903": {"epss_score": 0.00055, "epss_percentile": 0.17447}, "CVE-2025-53904": {"epss_score": 0.00055, "epss_percentile": 0.17447}, "CVE-2025-53905": {"epss_score": 0.00022, "epss_percentile": 0.05024}, "CVE-2025-53906": {"epss_score": 0.00022, "epss_percentile": 0.05024}, "CVE-2025-53908": {"epss_score": 0.00071, "epss_percentile": 0.22065}, "CVE-2025-53909": {"epss_score": 0.00086, "epss_percentile": 0.25328}, "CVE-2025-53910": {"epss_score": 0.00029, "epss_percentile": 0.07746}, "CVE-2025-53913": {"epss_score": 0.00024, "epss_percentile": 0.05898}, "CVE-2025-53914": {"epss_score": 0.00024, "epss_percentile": 0.05898}, "CVE-2025-53919": {"epss_score": 0.00011, "epss_percentile": 0.01023}, "CVE-2025-53922": {"epss_score": 0.00028, "epss_percentile": 0.07581}, "CVE-2025-53923": {"epss_score": 0.00046, "epss_percentile": 0.14426}, "CVE-2025-53924": {"epss_score": 0.00042, "epss_percentile": 0.12935}, "CVE-2025-53925": {"epss_score": 0.00027, "epss_percentile": 0.06743}, "CVE-2025-53926": {"epss_score": 0.00042, "epss_percentile": 0.12597}, "CVE-2025-53927": {"epss_score": 0.00025, "epss_percentile": 0.06324}, "CVE-2025-53928": {"epss_score": 0.00383, "epss_percentile": 0.59101}, "CVE-2025-53929": {"epss_score": 0.00027, "epss_percentile": 0.06776}, "CVE-2025-53930": {"epss_score": 0.00027, "epss_percentile": 0.06776}, "CVE-2025-53931": {"epss_score": 0.00027, "epss_percentile": 0.06776}, "CVE-2025-53932": {"epss_score": 0.00034, "epss_percentile": 0.09777}, "CVE-2025-53933": {"epss_score": 0.00027, "epss_percentile": 0.06776}, "CVE-2025-53934": {"epss_score": 0.00027, "epss_percentile": 0.06776}, "CVE-2025-53935": {"epss_score": 0.00034, "epss_percentile": 0.09777}, "CVE-2025-53936": {"epss_score": 0.00034, "epss_percentile": 0.09777}, "CVE-2025-53937": {"epss_score": 0.00033, "epss_percentile": 0.09352}, "CVE-2025-53938": {"epss_score": 0.00121, "epss_percentile": 0.31938}, "CVE-2025-53939": {"epss_score": 0.00063, "epss_percentile": 0.19941}, "CVE-2025-53940": {"epss_score": 0.00016, "epss_percentile": 0.0274}, "CVE-2025-53941": {"epss_score": 0.00023, "epss_percentile": 0.05637}, "CVE-2025-53942": {"epss_score": 0.0007, "epss_percentile": 0.21948}, "CVE-2025-53943": {"epss_score": 0.00055, "epss_percentile": 0.17518}, "CVE-2025-53944": {"epss_score": 0.00061, "epss_percentile": 0.19351}, "CVE-2025-53945": {"epss_score": 0.00017, "epss_percentile": 0.03242}, "CVE-2025-53946": {"epss_score": 0.00045, "epss_percentile": 0.13915}, "CVE-2025-53947": {"epss_score": 0.00019, "epss_percentile": 0.04097}, "CVE-2025-53948": {"epss_score": 0.00832, "epss_percentile": 0.7406}, "CVE-2025-53949": {"epss_score": 0.00079, "epss_percentile": 0.23882}, "CVE-2025-53950": {"epss_score": 0.00017, "epss_percentile": 0.03108}, "CVE-2025-53951": {"epss_score": 0.00033, "epss_percentile": 0.09167}, "CVE-2025-53959": {"epss_score": 4e-05, "epss_percentile": 0.00168}, "CVE-2025-53960": {"epss_score": 0.0006, "epss_percentile": 0.19012}, "CVE-2025-53963": {"epss_score": 0.00089, "epss_percentile": 0.2597}, "CVE-2025-53964": {"epss_score": 0.00065, "epss_percentile": 0.20498}, "CVE-2025-53965": {"epss_score": 0.00061, "epss_percentile": 0.19467}, "CVE-2025-53966": {"epss_score": 0.00013, "epss_percentile": 0.01603}, "CVE-2025-53967": {"epss_score": 0.00038, "epss_percentile": 0.11214}, "CVE-2025-53969": {"epss_score": 0.00123, "epss_percentile": 0.32188}, "CVE-2025-53970": {"epss_score": 0.00299, "epss_percentile": 0.52898}, "CVE-2025-53971": {"epss_score": 0.00045, "epss_percentile": 0.13727}, "CVE-2025-53982": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53983": {"epss_score": 0.00056, "epss_percentile": 0.17746}, "CVE-2025-53984": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53985": {"epss_score": 0.00056, "epss_percentile": 0.17746}, "CVE-2025-53986": {"epss_score": 0.00038, "epss_percentile": 0.11151}, "CVE-2025-53987": {"epss_score": 0.00056, "epss_percentile": 0.17746}, "CVE-2025-53988": {"epss_score": 0.00036, "epss_percentile": 0.10449}, "CVE-2025-53989": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53990": {"epss_score": 0.00109, "epss_percentile": 0.3004}, "CVE-2025-53991": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53992": {"epss_score": 0.00036, "epss_percentile": 0.10449}, "CVE-2025-53993": {"epss_score": 0.00056, "epss_percentile": 0.17746}, "CVE-2025-53994": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53995": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53996": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-53997": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-53998": {"epss_score": 0.00056, "epss_percentile": 0.17746}, "CVE-2025-54004": {"epss_score": 0.00026, "epss_percentile": 0.06411}, "CVE-2025-54005": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-54006": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-54007": {"epss_score": 0.00114, "epss_percentile": 0.3083}, "CVE-2025-54008": {"epss_score": 0.00036, "epss_percentile": 0.10449}, "CVE-2025-54009": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-54010": {"epss_score": 0.00019, "epss_percentile": 0.04199}, "CVE-2025-54011": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-54012": {"epss_score": 0.00105, "epss_percentile": 0.2939}, "CVE-2025-54013": {"epss_score": 0.00027, "epss_percentile": 0.06802}, "CVE-2025-54014": {"epss_score": 0.00063, "epss_percentile": 0.19999}, "CVE-2025-54015": {"epss_score": 0.00101, "epss_percentile": 0.28575}, "CVE-2025-54016": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-54017": {"epss_score": 0.00099, "epss_percentile": 0.2786}, "CVE-2025-54018": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-54019": {"epss_score": 0.0008, "epss_percentile": 0.24124}, "CVE-2025-54020": {"epss_score": 0.00016, "epss_percentile": 0.02857}, "CVE-2025-54021": {"epss_score": 0.00046, "epss_percentile": 0.14462}, "CVE-2025-54022": {"epss_score": 0.00016, "epss_percentile": 0.03051}, "CVE-2025-54023": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-54024": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-54025": {"epss_score": 0.00073, "epss_percentile": 0.2257}, "CVE-2025-54026": {"epss_score": 0.00034, "epss_percentile": 0.0977}, "CVE-2025-54027": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-54028": {"epss_score": 0.00204, "epss_percentile": 0.42591}, "CVE-2025-54029": {"epss_score": 0.00083, "epss_percentile": 0.24732}, "CVE-2025-54030": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-54031": {"epss_score": 0.00108, "epss_percentile": 0.29873}, "CVE-2025-54032": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-54033": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-54034": {"epss_score": 0.00099, "epss_percentile": 0.2786}, "CVE-2025-54035": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-54036": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-54037": {"epss_score": 0.00051, "epss_percentile": 0.1606}, "CVE-2025-54038": {"epss_score": 0.00016, "epss_percentile": 0.02857}, "CVE-2025-54039": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-54040": {"epss_score": 0.00073, "epss_percentile": 0.2257}, "CVE-2025-54041": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-54042": {"epss_score": 0.00015, "epss_percentile": 0.02211}, "CVE-2025-54043": {"epss_score": 0.00032, "epss_percentile": 0.08798}, "CVE-2025-54044": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-54045": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-54046": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54047": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-54048": {"epss_score": 0.00058, "epss_percentile": 0.18292}, "CVE-2025-54049": {"epss_score": 0.00049, "epss_percentile": 0.15428}, "CVE-2025-54050": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-54051": {"epss_score": 0.00029, "epss_percentile": 0.07727}, "CVE-2025-54052": {"epss_score": 0.00017, "epss_percentile": 0.03122}, "CVE-2025-54053": {"epss_score": 0.00105, "epss_percentile": 0.2939}, "CVE-2025-54054": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54055": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-54056": {"epss_score": 0.00026, "epss_percentile": 0.06394}, "CVE-2025-54057": {"epss_score": 0.00289, "epss_percentile": 0.51982}, "CVE-2025-54058": {"epss_score": 0.00045, "epss_percentile": 0.13915}, "CVE-2025-54059": {"epss_score": 0.00019, "epss_percentile": 0.04209}, "CVE-2025-54060": {"epss_score": 0.00045, "epss_percentile": 0.13915}, "CVE-2025-54061": {"epss_score": 0.00045, "epss_percentile": 0.13915}, "CVE-2025-54062": {"epss_score": 0.00033, "epss_percentile": 0.09352}, "CVE-2025-54063": {"epss_score": 0.00203, "epss_percentile": 0.42532}, "CVE-2025-54064": {"epss_score": 0.00072, "epss_percentile": 0.2233}, "CVE-2025-54065": {"epss_score": 0.00014, "epss_percentile": 0.02009}, "CVE-2025-54066": {"epss_score": 0.00031, "epss_percentile": 0.08419}, "CVE-2025-54068": {"epss_score": 0.00095, "epss_percentile": 0.27081}, "CVE-2025-54070": {"epss_score": 0.00044, "epss_percentile": 0.13531}, "CVE-2025-54071": {"epss_score": 0.00998, "epss_percentile": 0.76474}, "CVE-2025-54072": {"epss_score": 0.00066, "epss_percentile": 0.20694}, "CVE-2025-54073": {"epss_score": 0.0012, "epss_percentile": 0.31769}, "CVE-2025-54074": {"epss_score": 0.01306, "epss_percentile": 0.79336}, "CVE-2025-54075": {"epss_score": 0.00052, "epss_percentile": 0.16557}, "CVE-2025-54076": {"epss_score": 0.00037, "epss_percentile": 0.10734}, "CVE-2025-54077": {"epss_score": 0.00037, "epss_percentile": 0.10734}, "CVE-2025-54078": {"epss_score": 0.00037, "epss_percentile": 0.10734}, "CVE-2025-54079": {"epss_score": 0.00045, "epss_percentile": 0.13915}, "CVE-2025-54080": {"epss_score": 0.00044, "epss_percentile": 0.13376}, "CVE-2025-54081": {"epss_score": 0.00016, "epss_percentile": 0.0289}, "CVE-2025-54082": {"epss_score": 0.01042, "epss_percentile": 0.76977}, "CVE-2025-54083": {"epss_score": 0.00025, "epss_percentile": 0.06202}, "CVE-2025-54084": {"epss_score": 0.00596, "epss_percentile": 0.68734}, "CVE-2025-54085": {"epss_score": 0.00031, "epss_percentile": 0.08394}, "CVE-2025-54086": {"epss_score": 0.00028, "epss_percentile": 0.07253}, "CVE-2025-54087": {"epss_score": 0.00035, "epss_percentile": 0.09946}, "CVE-2025-54088": {"epss_score": 0.00038, "epss_percentile": 0.11348}, "CVE-2025-54089": {"epss_score": 0.00039, "epss_percentile": 0.11755}, "CVE-2025-54090": {"epss_score": 0.00223, "epss_percentile": 0.4488}, "CVE-2025-54091": {"epss_score": 0.0009, "epss_percentile": 0.2614}, "CVE-2025-54092": {"epss_score": 0.00051, "epss_percentile": 0.16135}, "CVE-2025-54093": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-54094": {"epss_score": 0.00188, "epss_percentile": 0.40857}, "CVE-2025-54095": {"epss_score": 0.00074, "epss_percentile": 0.22843}, "CVE-2025-54096": {"epss_score": 0.00074, "epss_percentile": 0.22843}, "CVE-2025-54097": {"epss_score": 0.00074, "epss_percentile": 0.22843}, "CVE-2025-54098": {"epss_score": 0.00081, "epss_percentile": 0.24368}, "CVE-2025-54099": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-54100": {"epss_score": 0.00188, "epss_percentile": 0.40918}, "CVE-2025-54101": {"epss_score": 0.00118, "epss_percentile": 0.3146}, "CVE-2025-54102": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-54103": {"epss_score": 0.00061, "epss_percentile": 0.19343}, "CVE-2025-54104": {"epss_score": 0.00188, "epss_percentile": 0.40857}, "CVE-2025-54105": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-54106": {"epss_score": 0.00091, "epss_percentile": 0.2621}, "CVE-2025-54107": {"epss_score": 0.00087, "epss_percentile": 0.25581}, "CVE-2025-54108": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-54109": {"epss_score": 0.00188, "epss_percentile": 0.40857}, "CVE-2025-54110": {"epss_score": 0.00064, "epss_percentile": 0.2014}, "CVE-2025-54111": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-54112": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-54113": {"epss_score": 0.00083, "epss_percentile": 0.24739}, "CVE-2025-54114": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-54115": {"epss_score": 0.00079, "epss_percentile": 0.2395}, "CVE-2025-54116": {"epss_score": 0.00059, "epss_percentile": 0.18755}, "CVE-2025-54117": {"epss_score": 0.00072, "epss_percentile": 0.22474}, "CVE-2025-54118": {"epss_score": 0.00092, "epss_percentile": 0.26422}, "CVE-2025-54119": {"epss_score": 0.00045, "epss_percentile": 0.13898}, "CVE-2025-54120": {"epss_score": 0.0002, "epss_percentile": 0.04652}, "CVE-2025-54121": {"epss_score": 0.0013, "epss_percentile": 0.33324}, "CVE-2025-54122": {"epss_score": 0.00635, "epss_percentile": 0.69814}, "CVE-2025-54123": {"epss_score": 0.3948, "epss_percentile": 0.97163}, "CVE-2025-54124": {"epss_score": 0.00034, "epss_percentile": 0.09582}, "CVE-2025-54125": {"epss_score": 0.01179, "epss_percentile": 0.78292}, "CVE-2025-54126": {"epss_score": 0.00051, "epss_percentile": 0.16174}, "CVE-2025-54127": {"epss_score": 0.00082, "epss_percentile": 0.24451}, "CVE-2025-54128": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-54129": {"epss_score": 0.0004, "epss_percentile": 0.1197}, "CVE-2025-54130": {"epss_score": 0.00045, "epss_percentile": 0.13827}, "CVE-2025-54131": {"epss_score": 0.00028, "epss_percentile": 0.07275}, "CVE-2025-54132": {"epss_score": 0.00035, "epss_percentile": 0.09998}, "CVE-2025-54133": {"epss_score": 0.00032, "epss_percentile": 0.08716}, "CVE-2025-54134": {"epss_score": 0.00056, "epss_percentile": 0.17802}, "CVE-2025-54135": {"epss_score": 0.00045, "epss_percentile": 0.13986}, "CVE-2025-54136": {"epss_score": 0.00065, "epss_percentile": 0.20452}, "CVE-2025-54137": {"epss_score": 0.00168, "epss_percentile": 0.38459}, "CVE-2025-54138": {"epss_score": 0.00013, "epss_percentile": 0.01719}, "CVE-2025-54139": {"epss_score": 0.0007, "epss_percentile": 0.21949}, "CVE-2025-54140": {"epss_score": 0.00245, "epss_percentile": 0.47657}, "CVE-2025-54141": {"epss_score": 0.00219, "epss_percentile": 0.44514}, "CVE-2025-54142": {"epss_score": 0.00053, "epss_percentile": 0.16701}, "CVE-2025-54143": {"epss_score": 0.00101, "epss_percentile": 0.28655}, "CVE-2025-54144": {"epss_score": 0.00025, "epss_percentile": 0.06243}, "CVE-2025-54145": {"epss_score": 0.00037, "epss_percentile": 0.10982}, "CVE-2025-54153": {"epss_score": 0.0012, "epss_percentile": 0.3175}, "CVE-2025-54154": {"epss_score": 0.00082, "epss_percentile": 0.2448}, "CVE-2025-54156": {"epss_score": 0.00014, "epss_percentile": 0.01771}, "CVE-2025-54158": {"epss_score": 0.00011, "epss_percentile": 0.00935}, "CVE-2025-54159": {"epss_score": 0.00079, "epss_percentile": 0.23863}, "CVE-2025-54160": {"epss_score": 0.00012, "epss_percentile": 0.01157}, "CVE-2025-54164": {"epss_score": 0.00051, "epss_percentile": 0.16016}, "CVE-2025-54165": {"epss_score": 0.00051, "epss_percentile": 0.16016}, "CVE-2025-54166": {"epss_score": 0.00051, "epss_percentile": 0.16016}, "CVE-2025-54167": {"epss_score": 0.00122, "epss_percentile": 0.32071}, "CVE-2025-54168": {"epss_score": 0.00079, "epss_percentile": 0.23955}, "CVE-2025-54172": {"epss_score": 0.00048, "epss_percentile": 0.15286}, "CVE-2025-54174": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-54175": {"epss_score": 0.00061, "epss_percentile": 0.19259}, "CVE-2025-54186": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54187": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54188": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54189": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54190": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54191": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54192": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54193": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54194": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54195": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54196": {"epss_score": 0.00053, "epss_percentile": 0.16691}, "CVE-2025-54197": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54198": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54199": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54200": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54201": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54202": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54203": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54204": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54205": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54206": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54207": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54208": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54209": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54210": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54211": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54212": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54213": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54214": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54215": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54216": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54217": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54218": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54219": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54220": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54221": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54222": {"epss_score": 0.00022, "epss_percentile": 0.05053}, "CVE-2025-54223": {"epss_score": 0.00029, "epss_percentile": 0.07686}, "CVE-2025-54224": {"epss_score": 0.00029, "epss_percentile": 0.07686}, "CVE-2025-54225": {"epss_score": 0.00029, "epss_percentile": 0.07686}, "CVE-2025-54226": {"epss_score": 0.00029, "epss_percentile": 0.07686}, "CVE-2025-54227": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54228": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54229": {"epss_score": 0.00029, "epss_percentile": 0.07686}, "CVE-2025-54230": {"epss_score": 0.00029, "epss_percentile": 0.07686}, "CVE-2025-54231": {"epss_score": 0.00029, "epss_percentile": 0.07686}, "CVE-2025-54232": {"epss_score": 0.00029, "epss_percentile": 0.07686}, "CVE-2025-54233": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54234": {"epss_score": 0.00061, "epss_percentile": 0.19376}, "CVE-2025-54235": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54236": {"epss_score": 0.63061, "epss_percentile": 0.9832}, "CVE-2025-54237": {"epss_score": 0.00029, "epss_percentile": 0.07677}, "CVE-2025-54238": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-54239": {"epss_score": 0.00029, "epss_percentile": 0.07677}, "CVE-2025-54240": {"epss_score": 0.00029, "epss_percentile": 0.07677}, "CVE-2025-54241": {"epss_score": 0.00029, "epss_percentile": 0.07677}, "CVE-2025-54242": {"epss_score": 0.00045, "epss_percentile": 0.13684}, "CVE-2025-54243": {"epss_score": 0.00042, "epss_percentile": 0.12894}, "CVE-2025-54244": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-54245": {"epss_score": 0.00042, "epss_percentile": 0.12894}, "CVE-2025-54246": {"epss_score": 0.00058, "epss_percentile": 0.18383}, "CVE-2025-54247": {"epss_score": 0.00145, "epss_percentile": 0.35454}, "CVE-2025-54248": {"epss_score": 0.0013, "epss_percentile": 0.33252}, "CVE-2025-54249": {"epss_score": 0.09163, "epss_percentile": 0.92428}, "CVE-2025-54250": {"epss_score": 0.0021, "epss_percentile": 0.43433}, "CVE-2025-54251": {"epss_score": 0.15953, "epss_percentile": 0.94543}, "CVE-2025-54252": {"epss_score": 0.00053, "epss_percentile": 0.16982}, "CVE-2025-54253": {"epss_score": 0.58737, "epss_percentile": 0.98134}, "CVE-2025-54254": {"epss_score": 0.00085, "epss_percentile": 0.25241}, "CVE-2025-54255": {"epss_score": 0.00056, "epss_percentile": 0.17802}, "CVE-2025-54256": {"epss_score": 0.00016, "epss_percentile": 0.02648}, "CVE-2025-54257": {"epss_score": 0.00045, "epss_percentile": 0.13684}, "CVE-2025-54258": {"epss_score": 0.00045, "epss_percentile": 0.13684}, "CVE-2025-54259": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-54260": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-54261": {"epss_score": 0.01808, "epss_percentile": 0.82356}, "CVE-2025-54262": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-54263": {"epss_score": 0.00092, "epss_percentile": 0.26593}, "CVE-2025-54264": {"epss_score": 0.00127, "epss_percentile": 0.328}, "CVE-2025-54265": {"epss_score": 0.00151, "epss_percentile": 0.36213}, "CVE-2025-54266": {"epss_score": 0.0009, "epss_percentile": 0.2608}, "CVE-2025-54267": {"epss_score": 0.00069, "epss_percentile": 0.21523}, "CVE-2025-54268": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-54269": {"epss_score": 0.00029, "epss_percentile": 0.07677}, "CVE-2025-54270": {"epss_score": 0.00029, "epss_percentile": 0.07677}, "CVE-2025-54271": {"epss_score": 0.00019, "epss_percentile": 0.04329}, "CVE-2025-54272": {"epss_score": 0.00041, "epss_percentile": 0.12288}, "CVE-2025-54273": {"epss_score": 0.00042, "epss_percentile": 0.12894}, "CVE-2025-54274": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-54275": {"epss_score": 0.0003, "epss_percentile": 0.08271}, "CVE-2025-54276": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-54278": {"epss_score": 0.00029, "epss_percentile": 0.07677}, "CVE-2025-54279": {"epss_score": 0.00045, "epss_percentile": 0.13684}, "CVE-2025-54280": {"epss_score": 0.00042, "epss_percentile": 0.12894}, "CVE-2025-54281": {"epss_score": 0.00045, "epss_percentile": 0.13684}, "CVE-2025-54282": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-54283": {"epss_score": 0.00042, "epss_percentile": 0.12894}, "CVE-2025-54284": {"epss_score": 0.00042, "epss_percentile": 0.12894}, "CVE-2025-54286": {"epss_score": 0.00023, "epss_percentile": 0.05486}, "CVE-2025-54287": {"epss_score": 0.0004, "epss_percentile": 0.11977}, "CVE-2025-54288": {"epss_score": 0.00052, "epss_percentile": 0.16467}, "CVE-2025-54289": {"epss_score": 0.00042, "epss_percentile": 0.1267}, "CVE-2025-54290": {"epss_score": 0.00089, "epss_percentile": 0.25883}, "CVE-2025-54291": {"epss_score": 0.00087, "epss_percentile": 0.25451}, "CVE-2025-54292": {"epss_score": 0.00053, "epss_percentile": 0.16887}, "CVE-2025-54293": {"epss_score": 0.00072, "epss_percentile": 0.2244}, "CVE-2025-54294": {"epss_score": 0.00055, "epss_percentile": 0.17447}, "CVE-2025-54295": {"epss_score": 0.00055, "epss_percentile": 0.17447}, "CVE-2025-54296": {"epss_score": 0.00038, "epss_percentile": 0.1116}, "CVE-2025-54297": {"epss_score": 0.00038, "epss_percentile": 0.1116}, "CVE-2025-54298": {"epss_score": 0.00055, "epss_percentile": 0.17447}, "CVE-2025-54299": {"epss_score": 0.00055, "epss_percentile": 0.17447}, "CVE-2025-54300": {"epss_score": 0.00083, "epss_percentile": 0.24811}, "CVE-2025-54301": {"epss_score": 0.00083, "epss_percentile": 0.24811}, "CVE-2025-54303": {"epss_score": 0.00061, "epss_percentile": 0.19489}, "CVE-2025-54304": {"epss_score": 0.00095, "epss_percentile": 0.2722}, "CVE-2025-54305": {"epss_score": 0.00024, "epss_percentile": 0.0581}, "CVE-2025-54306": {"epss_score": 0.00336, "epss_percentile": 0.55952}, "CVE-2025-54307": {"epss_score": 0.00249, "epss_percentile": 0.48054}, "CVE-2025-54309": {"epss_score": 0.72172, "epss_percentile": 0.98697}, "CVE-2025-54310": {"epss_score": 0.00029, "epss_percentile": 0.07931}, "CVE-2025-54313": {"epss_score": 0.00023, "epss_percentile": 0.05409}, "CVE-2025-54314": {"epss_score": 0.00018, "epss_percentile": 0.03603}, "CVE-2025-54315": {"epss_score": 0.00058, "epss_percentile": 0.18306}, "CVE-2025-54316": {"epss_score": 0.00024, "epss_percentile": 0.058}, "CVE-2025-54317": {"epss_score": 0.00157, "epss_percentile": 0.37066}, "CVE-2025-54319": {"epss_score": 0.00037, "epss_percentile": 0.10857}, "CVE-2025-54320": {"epss_score": 0.00052, "epss_percentile": 0.16636}, "CVE-2025-54321": {"epss_score": 0.00065, "epss_percentile": 0.20449}, "CVE-2025-54322": {"epss_score": 0.00378, "epss_percentile": 0.5881}, "CVE-2025-54323": {"epss_score": 0.00041, "epss_percentile": 0.12219}, "CVE-2025-54325": {"epss_score": 0.00061, "epss_percentile": 0.19467}, "CVE-2025-54326": {"epss_score": 0.00063, "epss_percentile": 0.19878}, "CVE-2025-54327": {"epss_score": 0.00106, "epss_percentile": 0.29433}, "CVE-2025-54329": {"epss_score": 0.00064, "epss_percentile": 0.20288}, "CVE-2025-54330": {"epss_score": 0.00043, "epss_percentile": 0.13265}, "CVE-2025-54331": {"epss_score": 0.00061, "epss_percentile": 0.19467}, "CVE-2025-54332": {"epss_score": 0.00063, "epss_percentile": 0.19941}, "CVE-2025-54333": {"epss_score": 0.00061, "epss_percentile": 0.19467}, "CVE-2025-54334": {"epss_score": 0.00063, "epss_percentile": 0.19941}, "CVE-2025-54335": {"epss_score": 0.00043, "epss_percentile": 0.13265}, "CVE-2025-54336": {"epss_score": 0.00078, "epss_percentile": 0.23675}, "CVE-2025-54338": {"epss_score": 0.00048, "epss_percentile": 0.14995}, "CVE-2025-54339": {"epss_score": 0.00061, "epss_percentile": 0.19409}, "CVE-2025-54340": {"epss_score": 7e-05, "epss_percentile": 0.0039}, "CVE-2025-54341": {"epss_score": 0.00043, "epss_percentile": 0.12957}, "CVE-2025-54342": {"epss_score": 7e-05, "epss_percentile": 0.00332}, "CVE-2025-54343": {"epss_score": 0.00038, "epss_percentile": 0.11344}, "CVE-2025-54345": {"epss_score": 0.00047, "epss_percentile": 0.14492}, "CVE-2025-54346": {"epss_score": 0.00056, "epss_percentile": 0.17893}, "CVE-2025-54347": {"epss_score": 0.00281, "epss_percentile": 0.51194}, "CVE-2025-54348": {"epss_score": 0.0004, "epss_percentile": 0.12079}, "CVE-2025-54349": {"epss_score": 0.00036, "epss_percentile": 0.10442}, "CVE-2025-54350": {"epss_score": 0.00032, "epss_percentile": 0.09096}, "CVE-2025-54351": {"epss_score": 0.00038, "epss_percentile": 0.11114}, "CVE-2025-54352": {"epss_score": 0.00042, "epss_percentile": 0.1273}, "CVE-2025-54353": {"epss_score": 0.00056, "epss_percentile": 0.17676}, "CVE-2025-54363": {"epss_score": 0.00683, "epss_percentile": 0.7109}, "CVE-2025-54364": {"epss_score": 0.00648, "epss_percentile": 0.70212}, "CVE-2025-54365": {"epss_score": 0.0013, "epss_percentile": 0.33293}, "CVE-2025-54366": {"epss_score": 0.02535, "epss_percentile": 0.85036}, "CVE-2025-54368": {"epss_score": 0.00011, "epss_percentile": 0.01045}, "CVE-2025-54369": {"epss_score": 0.0006, "epss_percentile": 0.18967}, "CVE-2025-54370": {"epss_score": 0.00095, "epss_percentile": 0.27109}, "CVE-2025-54374": {"epss_score": 0.00237, "epss_percentile": 0.46731}, "CVE-2025-54376": {"epss_score": 0.00178, "epss_percentile": 0.39662}, "CVE-2025-54377": {"epss_score": 0.00074, "epss_percentile": 0.22703}, "CVE-2025-54378": {"epss_score": 0.00061, "epss_percentile": 0.19353}, "CVE-2025-54379": {"epss_score": 0.00123, "epss_percentile": 0.32212}, "CVE-2025-54380": {"epss_score": 0.00038, "epss_percentile": 0.11303}, "CVE-2025-54381": {"epss_score": 0.00339, "epss_percentile": 0.56197}, "CVE-2025-54382": {"epss_score": 0.00381, "epss_percentile": 0.59006}, "CVE-2025-54384": {"epss_score": 0.00044, "epss_percentile": 0.13495}, "CVE-2025-54385": {"epss_score": 0.00719, "epss_percentile": 0.71942}, "CVE-2025-54386": {"epss_score": 0.00568, "epss_percentile": 0.67888}, "CVE-2025-54387": {"epss_score": 0.00151, "epss_percentile": 0.36249}, "CVE-2025-54388": {"epss_score": 5e-05, "epss_percentile": 0.00185}, "CVE-2025-54389": {"epss_score": 0.0002, "epss_percentile": 0.04669}, "CVE-2025-54390": {"epss_score": 0.00011, "epss_percentile": 0.0101}, "CVE-2025-54391": {"epss_score": 0.00074, "epss_percentile": 0.22677}, "CVE-2025-54392": {"epss_score": 0.00019, "epss_percentile": 0.04327}, "CVE-2025-54393": {"epss_score": 0.00027, "epss_percentile": 0.0709}, "CVE-2025-54394": {"epss_score": 0.00034, "epss_percentile": 0.09573}, "CVE-2025-54395": {"epss_score": 0.00019, "epss_percentile": 0.04327}, "CVE-2025-54396": {"epss_score": 0.0002, "epss_percentile": 0.04601}, "CVE-2025-54397": {"epss_score": 0.0003, "epss_percentile": 0.08221}, "CVE-2025-54399": {"epss_score": 0.00063, "epss_percentile": 0.20071}, "CVE-2025-54400": {"epss_score": 0.00063, "epss_percentile": 0.20071}, "CVE-2025-54401": {"epss_score": 0.00063, "epss_percentile": 0.20071}, "CVE-2025-54402": {"epss_score": 0.00063, "epss_percentile": 0.20071}, "CVE-2025-54403": {"epss_score": 0.00266, "epss_percentile": 0.49906}, "CVE-2025-54404": {"epss_score": 0.00266, "epss_percentile": 0.49906}, "CVE-2025-54405": {"epss_score": 0.00266, "epss_percentile": 0.49906}, "CVE-2025-54406": {"epss_score": 0.00266, "epss_percentile": 0.49906}, "CVE-2025-54407": {"epss_score": 0.00034, "epss_percentile": 0.09667}, "CVE-2025-54409": {"epss_score": 0.00037, "epss_percentile": 0.10685}, "CVE-2025-54410": {"epss_score": 4e-05, "epss_percentile": 0.00168}, "CVE-2025-54411": {"epss_score": 0.00058, "epss_percentile": 0.1831}, "CVE-2025-54412": {"epss_score": 0.00011, "epss_percentile": 0.01012}, "CVE-2025-54413": {"epss_score": 0.00013, "epss_percentile": 0.01724}, "CVE-2025-54414": {"epss_score": 0.0005, "epss_percentile": 0.15877}, "CVE-2025-54415": {"epss_score": 0.00091, "epss_percentile": 0.26375}, "CVE-2025-54416": {"epss_score": 0.00075, "epss_percentile": 0.22947}, "CVE-2025-54417": {"epss_score": 0.00035, "epss_percentile": 0.09959}, "CVE-2025-54418": {"epss_score": 0.00357, "epss_percentile": 0.57427}, "CVE-2025-54419": {"epss_score": 0.00043, "epss_percentile": 0.13344}, "CVE-2025-54421": {"epss_score": 0.00066, "epss_percentile": 0.20935}, "CVE-2025-54422": {"epss_score": 6e-05, "epss_percentile": 0.00298}, "CVE-2025-54423": {"epss_score": 0.00059, "epss_percentile": 0.18668}, "CVE-2025-54424": {"epss_score": 0.00189, "epss_percentile": 0.41001}, "CVE-2025-54425": {"epss_score": 0.00038, "epss_percentile": 0.11405}, "CVE-2025-54426": {"epss_score": 0.00035, "epss_percentile": 0.10145}, "CVE-2025-54427": {"epss_score": 0.00086, "epss_percentile": 0.25352}, "CVE-2025-54428": {"epss_score": 0.00071, "epss_percentile": 0.2203}, "CVE-2025-54429": {"epss_score": 0.00057, "epss_percentile": 0.18111}, "CVE-2025-54430": {"epss_score": 0.00042, "epss_percentile": 0.12582}, "CVE-2025-54433": {"epss_score": 0.00191, "epss_percentile": 0.41162}, "CVE-2025-54438": {"epss_score": 0.0011, "epss_percentile": 0.30224}, "CVE-2025-54439": {"epss_score": 0.00064, "epss_percentile": 0.20267}, "CVE-2025-54440": {"epss_score": 0.00064, "epss_percentile": 0.20428}, "CVE-2025-54441": {"epss_score": 0.00064, "epss_percentile": 0.20267}, "CVE-2025-54442": {"epss_score": 0.00064, "epss_percentile": 0.20428}, "CVE-2025-54443": {"epss_score": 0.00115, "epss_percentile": 0.30969}, "CVE-2025-54444": {"epss_score": 0.00061, "epss_percentile": 0.19431}, "CVE-2025-54445": {"epss_score": 0.00023, "epss_percentile": 0.05442}, "CVE-2025-54446": {"epss_score": 0.0011, "epss_percentile": 0.30224}, "CVE-2025-54447": {"epss_score": 0.00049, "epss_percentile": 0.15305}, "CVE-2025-54448": {"epss_score": 0.00064, "epss_percentile": 0.20428}, "CVE-2025-54449": {"epss_score": 0.00064, "epss_percentile": 0.20428}, "CVE-2025-54450": {"epss_score": 0.00101, "epss_percentile": 0.28659}, "CVE-2025-54451": {"epss_score": 0.00058, "epss_percentile": 0.1826}, "CVE-2025-54452": {"epss_score": 0.00058, "epss_percentile": 0.18567}, "CVE-2025-54453": {"epss_score": 0.00108, "epss_percentile": 0.29825}, "CVE-2025-54454": {"epss_score": 0.00064, "epss_percentile": 0.20269}, "CVE-2025-54455": {"epss_score": 0.00064, "epss_percentile": 0.20269}, "CVE-2025-54458": {"epss_score": 0.00033, "epss_percentile": 0.09168}, "CVE-2025-54459": {"epss_score": 0.00208, "epss_percentile": 0.43249}, "CVE-2025-54460": {"epss_score": 0.00048, "epss_percentile": 0.15232}, "CVE-2025-54461": {"epss_score": 0.00046, "epss_percentile": 0.14126}, "CVE-2025-54462": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54463": {"epss_score": 0.00042, "epss_percentile": 0.12479}, "CVE-2025-54464": {"epss_score": 9e-05, "epss_percentile": 0.00623}, "CVE-2025-54465": {"epss_score": 0.00041, "epss_percentile": 0.12331}, "CVE-2025-54466": {"epss_score": 0.00099, "epss_percentile": 0.28402}, "CVE-2025-54467": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-54468": {"epss_score": 0.00012, "epss_percentile": 0.013}, "CVE-2025-54469": {"epss_score": 0.00071, "epss_percentile": 0.22046}, "CVE-2025-54470": {"epss_score": 0.00042, "epss_percentile": 0.12669}, "CVE-2025-54471": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-54472": {"epss_score": 0.00145, "epss_percentile": 0.35354}, "CVE-2025-54473": {"epss_score": 0.00124, "epss_percentile": 0.32348}, "CVE-2025-54474": {"epss_score": 0.00083, "epss_percentile": 0.24811}, "CVE-2025-54475": {"epss_score": 0.00058, "epss_percentile": 0.18399}, "CVE-2025-54476": {"epss_score": 0.00065, "epss_percentile": 0.20439}, "CVE-2025-54477": {"epss_score": 0.00045, "epss_percentile": 0.13778}, "CVE-2025-54478": {"epss_score": 0.0011, "epss_percentile": 0.30213}, "CVE-2025-54479": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-54480": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54481": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54482": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54483": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54484": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54485": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54486": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54487": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54488": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54489": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54490": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54491": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54492": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54493": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54494": {"epss_score": 0.00244, "epss_percentile": 0.47593}, "CVE-2025-54496": {"epss_score": 0.0002, "epss_percentile": 0.04561}, "CVE-2025-54497": {"epss_score": 0.00084, "epss_percentile": 0.25023}, "CVE-2025-54499": {"epss_score": 0.00043, "epss_percentile": 0.13132}, "CVE-2025-54500": {"epss_score": 0.00132, "epss_percentile": 0.33517}, "CVE-2025-54515": {"epss_score": 0.00036, "epss_percentile": 0.10609}, "CVE-2025-54520": {"epss_score": 0.00027, "epss_percentile": 0.07203}, "CVE-2025-54525": {"epss_score": 0.00111, "epss_percentile": 0.30333}, "CVE-2025-54526": {"epss_score": 0.0002, "epss_percentile": 0.04561}, "CVE-2025-54527": {"epss_score": 2e-05, "epss_percentile": 0.0004}, "CVE-2025-54528": {"epss_score": 5e-05, "epss_percentile": 0.00226}, "CVE-2025-54529": {"epss_score": 1e-05, "epss_percentile": 4e-05}, "CVE-2025-54530": {"epss_score": 1e-05, "epss_percentile": 9e-05}, "CVE-2025-54531": {"epss_score": 1e-05, "epss_percentile": 0.00011}, "CVE-2025-54532": {"epss_score": 1e-05, "epss_percentile": 6e-05}, "CVE-2025-54533": {"epss_score": 1e-05, "epss_percentile": 6e-05}, "CVE-2025-54534": {"epss_score": 8e-05, "epss_percentile": 0.00482}, "CVE-2025-54535": {"epss_score": 1e-05, "epss_percentile": 3e-05}, "CVE-2025-54536": {"epss_score": 5e-05, "epss_percentile": 0.00226}, "CVE-2025-54537": {"epss_score": 1e-05, "epss_percentile": 1e-05}, "CVE-2025-54538": {"epss_score": 1e-05, "epss_percentile": 1e-05}, "CVE-2025-54539": {"epss_score": 0.00214, "epss_percentile": 0.43977}, "CVE-2025-54540": {"epss_score": 0.00066, "epss_percentile": 0.20872}, "CVE-2025-54541": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-54542": {"epss_score": 0.00022, "epss_percentile": 0.05303}, "CVE-2025-54543": {"epss_score": 0.00048, "epss_percentile": 0.15286}, "CVE-2025-54544": {"epss_score": 0.00048, "epss_percentile": 0.15286}, "CVE-2025-54545": {"epss_score": 0.00018, "epss_percentile": 0.03676}, "CVE-2025-54546": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-54547": {"epss_score": 0.00017, "epss_percentile": 0.03332}, "CVE-2025-54548": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-54549": {"epss_score": 7e-05, "epss_percentile": 0.00424}, "CVE-2025-54551": {"epss_score": 0.0005, "epss_percentile": 0.15705}, "CVE-2025-54554": {"epss_score": 0.0001, "epss_percentile": 0.00879}, "CVE-2025-54558": {"epss_score": 0.00013, "epss_percentile": 0.01723}, "CVE-2025-54559": {"epss_score": 0.00076, "epss_percentile": 0.23121}, "CVE-2025-54560": {"epss_score": 0.00035, "epss_percentile": 0.09984}, "CVE-2025-54561": {"epss_score": 0.00034, "epss_percentile": 0.09676}, "CVE-2025-54562": {"epss_score": 0.00037, "epss_percentile": 0.10836}, "CVE-2025-54563": {"epss_score": 0.00062, "epss_percentile": 0.19612}, "CVE-2025-54564": {"epss_score": 0.00031, "epss_percentile": 0.08377}, "CVE-2025-54566": {"epss_score": 6e-05, "epss_percentile": 0.0029}, "CVE-2025-54567": {"epss_score": 5e-05, "epss_percentile": 0.00219}, "CVE-2025-54568": {"epss_score": 0.00036, "epss_percentile": 0.10354}, "CVE-2025-54569": {"epss_score": 8e-05, "epss_percentile": 0.00472}, "CVE-2025-54571": {"epss_score": 0.00038, "epss_percentile": 0.11267}, "CVE-2025-54572": {"epss_score": 0.00085, "epss_percentile": 0.25139}, "CVE-2025-54573": {"epss_score": 0.00066, "epss_percentile": 0.20686}, "CVE-2025-54574": {"epss_score": 0.02129, "epss_percentile": 0.83706}, "CVE-2025-54575": {"epss_score": 0.00117, "epss_percentile": 0.31231}, "CVE-2025-54576": {"epss_score": 0.00363, "epss_percentile": 0.57829}, "CVE-2025-54581": {"epss_score": 0.00059, "epss_percentile": 0.18633}, "CVE-2025-54583": {"epss_score": 0.00036, "epss_percentile": 0.10273}, "CVE-2025-54584": {"epss_score": 0.00039, "epss_percentile": 0.11572}, "CVE-2025-54585": {"epss_score": 0.00036, "epss_percentile": 0.10273}, "CVE-2025-54586": {"epss_score": 0.00039, "epss_percentile": 0.11573}, "CVE-2025-54588": {"epss_score": 0.0001, "epss_percentile": 0.00892}, "CVE-2025-54589": {"epss_score": 0.00619, "epss_percentile": 0.69431}, "CVE-2025-54590": {"epss_score": 0.00047, "epss_percentile": 0.14505}, "CVE-2025-54591": {"epss_score": 0.0006, "epss_percentile": 0.19242}, "CVE-2025-54592": {"epss_score": 0.00079, "epss_percentile": 0.23989}, "CVE-2025-54593": {"epss_score": 0.00128, "epss_percentile": 0.3301}, "CVE-2025-54594": {"epss_score": 0.00042, "epss_percentile": 0.12599}, "CVE-2025-54595": {"epss_score": 0.00012, "epss_percentile": 0.01324}, "CVE-2025-54596": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-54597": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-54598": {"epss_score": 0.00033, "epss_percentile": 0.09164}, "CVE-2025-54599": {"epss_score": 0.0007, "epss_percentile": 0.21754}, "CVE-2025-54603": {"epss_score": 0.00073, "epss_percentile": 0.2254}, "CVE-2025-54604": {"epss_score": 0.0006, "epss_percentile": 0.18965}, "CVE-2025-54605": {"epss_score": 0.0006, "epss_percentile": 0.18965}, "CVE-2025-54606": {"epss_score": 9e-05, "epss_percentile": 0.00619}, "CVE-2025-54607": {"epss_score": 0.00021, "epss_percentile": 0.04888}, "CVE-2025-54608": {"epss_score": 8e-05, "epss_percentile": 0.00524}, "CVE-2025-54609": {"epss_score": 0.00014, "epss_percentile": 0.01956}, "CVE-2025-54610": {"epss_score": 0.00014, "epss_percentile": 0.01956}, "CVE-2025-54611": {"epss_score": 8e-05, "epss_percentile": 0.00509}, "CVE-2025-54612": {"epss_score": 8e-05, "epss_percentile": 0.00577}, "CVE-2025-54613": {"epss_score": 8e-05, "epss_percentile": 0.00577}, "CVE-2025-54614": {"epss_score": 0.00017, "epss_percentile": 0.03303}, "CVE-2025-54615": {"epss_score": 8e-05, "epss_percentile": 0.00509}, "CVE-2025-54616": {"epss_score": 9e-05, "epss_percentile": 0.00613}, "CVE-2025-54617": {"epss_score": 0.00027, "epss_percentile": 0.06954}, "CVE-2025-54618": {"epss_score": 9e-05, "epss_percentile": 0.00664}, "CVE-2025-54619": {"epss_score": 8e-05, "epss_percentile": 0.00577}, "CVE-2025-54620": {"epss_score": 0.0007, "epss_percentile": 0.2197}, "CVE-2025-54621": {"epss_score": 8e-05, "epss_percentile": 0.00577}, "CVE-2025-54622": {"epss_score": 0.00011, "epss_percentile": 0.01111}, "CVE-2025-54623": {"epss_score": 0.00011, "epss_percentile": 0.00935}, "CVE-2025-54624": {"epss_score": 0.0001, "epss_percentile": 0.00808}, "CVE-2025-54625": {"epss_score": 5e-05, "epss_percentile": 0.00196}, "CVE-2025-54626": {"epss_score": 9e-05, "epss_percentile": 0.00634}, "CVE-2025-54627": {"epss_score": 0.0002, "epss_percentile": 0.04681}, "CVE-2025-54628": {"epss_score": 0.00028, "epss_percentile": 0.07299}, "CVE-2025-54629": {"epss_score": 4e-05, "epss_percentile": 0.00169}, "CVE-2025-54630": {"epss_score": 0.0003, "epss_percentile": 0.08079}, "CVE-2025-54631": {"epss_score": 8e-05, "epss_percentile": 0.00526}, "CVE-2025-54632": {"epss_score": 0.0001, "epss_percentile": 0.00842}, "CVE-2025-54633": {"epss_score": 7e-05, "epss_percentile": 0.00413}, "CVE-2025-54634": {"epss_score": 9e-05, "epss_percentile": 0.00619}, "CVE-2025-54635": {"epss_score": 0.00015, "epss_percentile": 0.02515}, "CVE-2025-54636": {"epss_score": 0.00012, "epss_percentile": 0.0125}, "CVE-2025-54637": {"epss_score": 7e-05, "epss_percentile": 0.00425}, "CVE-2025-54638": {"epss_score": 0.00047, "epss_percentile": 0.14775}, "CVE-2025-54639": {"epss_score": 0.0007, "epss_percentile": 0.2197}, "CVE-2025-54640": {"epss_score": 0.0007, "epss_percentile": 0.2197}, "CVE-2025-54641": {"epss_score": 0.00012, "epss_percentile": 0.01258}, "CVE-2025-54642": {"epss_score": 0.00012, "epss_percentile": 0.01258}, "CVE-2025-54643": {"epss_score": 8e-05, "epss_percentile": 0.00509}, "CVE-2025-54644": {"epss_score": 7e-05, "epss_percentile": 0.00455}, "CVE-2025-54645": {"epss_score": 6e-05, "epss_percentile": 0.00246}, "CVE-2025-54646": {"epss_score": 8e-05, "epss_percentile": 0.00583}, "CVE-2025-54647": {"epss_score": 0.00011, "epss_percentile": 0.00935}, "CVE-2025-54648": {"epss_score": 0.00011, "epss_percentile": 0.00935}, "CVE-2025-54649": {"epss_score": 6e-05, "epss_percentile": 0.00264}, "CVE-2025-54650": {"epss_score": 0.00014, "epss_percentile": 0.01817}, "CVE-2025-54651": {"epss_score": 5e-05, "epss_percentile": 0.00178}, "CVE-2025-54652": {"epss_score": 8e-05, "epss_percentile": 0.00494}, "CVE-2025-54653": {"epss_score": 8e-05, "epss_percentile": 0.00494}, "CVE-2025-54654": {"epss_score": 9e-05, "epss_percentile": 0.00621}, "CVE-2025-54655": {"epss_score": 5e-05, "epss_percentile": 0.00188}, "CVE-2025-54656": {"epss_score": 0.00229, "epss_percentile": 0.45656}, "CVE-2025-54658": {"epss_score": 0.00034, "epss_percentile": 0.09736}, "CVE-2025-54660": {"epss_score": 0.00017, "epss_percentile": 0.03269}, "CVE-2025-54667": {"epss_score": 0.00026, "epss_percentile": 0.06727}, "CVE-2025-54668": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54669": {"epss_score": 0.00058, "epss_percentile": 0.18292}, "CVE-2025-54670": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-54671": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-54672": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-54673": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-54674": {"epss_score": 0.00029, "epss_percentile": 0.07668}, "CVE-2025-54675": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-54676": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-54677": {"epss_score": 0.00076, "epss_percentile": 0.23102}, "CVE-2025-54678": {"epss_score": 0.00058, "epss_percentile": 0.18292}, "CVE-2025-54679": {"epss_score": 0.00079, "epss_percentile": 0.23946}, "CVE-2025-54680": {"epss_score": 0.00025, "epss_percentile": 0.06331}, "CVE-2025-54681": {"epss_score": 0.00025, "epss_percentile": 0.06251}, "CVE-2025-54682": {"epss_score": 0.00029, "epss_percentile": 0.07668}, "CVE-2025-54683": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-54684": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-54685": {"epss_score": 0.00056, "epss_percentile": 0.17746}, "CVE-2025-54686": {"epss_score": 0.00063, "epss_percentile": 0.19999}, "CVE-2025-54687": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54688": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54689": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-54690": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-54691": {"epss_score": 0.00033, "epss_percentile": 0.09389}, "CVE-2025-54692": {"epss_score": 0.00058, "epss_percentile": 0.18311}, "CVE-2025-54693": {"epss_score": 0.00083, "epss_percentile": 0.24616}, "CVE-2025-54694": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-54695": {"epss_score": 0.00044, "epss_percentile": 0.13679}, "CVE-2025-54696": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54697": {"epss_score": 0.0007, "epss_percentile": 0.21669}, "CVE-2025-54698": {"epss_score": 0.00027, "epss_percentile": 0.06752}, "CVE-2025-54699": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54700": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-54701": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-54702": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-54703": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-54704": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54705": {"epss_score": 0.00069, "epss_percentile": 0.21463}, "CVE-2025-54706": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54707": {"epss_score": 0.00058, "epss_percentile": 0.18292}, "CVE-2025-54708": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54709": {"epss_score": 0.00172, "epss_percentile": 0.38969}, "CVE-2025-54710": {"epss_score": 0.0007, "epss_percentile": 0.21975}, "CVE-2025-54711": {"epss_score": 0.00036, "epss_percentile": 0.105}, "CVE-2025-54712": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-54713": {"epss_score": 0.00117, "epss_percentile": 0.31247}, "CVE-2025-54714": {"epss_score": 0.00051, "epss_percentile": 0.1629}, "CVE-2025-54715": {"epss_score": 0.00066, "epss_percentile": 0.20693}, "CVE-2025-54716": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-54717": {"epss_score": 0.00069, "epss_percentile": 0.21463}, "CVE-2025-54718": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-54719": {"epss_score": 0.00061, "epss_percentile": 0.19456}, "CVE-2025-54720": {"epss_score": 0.00058, "epss_percentile": 0.18292}, "CVE-2025-54721": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-54722": {"epss_score": 0.00047, "epss_percentile": 0.14927}, "CVE-2025-54723": {"epss_score": 0.00054, "epss_percentile": 0.17186}, "CVE-2025-54724": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-54725": {"epss_score": 0.00117, "epss_percentile": 0.31247}, "CVE-2025-54726": {"epss_score": 0.00058, "epss_percentile": 0.18292}, "CVE-2025-54727": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-54728": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-54729": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-54730": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-54731": {"epss_score": 0.00092, "epss_percentile": 0.2657}, "CVE-2025-54732": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-54733": {"epss_score": 0.00073, "epss_percentile": 0.2257}, "CVE-2025-54734": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-54735": {"epss_score": 0.00075, "epss_percentile": 0.23056}, "CVE-2025-54736": {"epss_score": 0.0005, "epss_percentile": 0.15854}, "CVE-2025-54737": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-54738": {"epss_score": 0.00117, "epss_percentile": 0.31247}, "CVE-2025-54739": {"epss_score": 0.00051, "epss_percentile": 0.16308}, "CVE-2025-54740": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54741": {"epss_score": 0.00053, "epss_percentile": 0.16886}, "CVE-2025-54742": {"epss_score": 0.00114, "epss_percentile": 0.3083}, "CVE-2025-54743": {"epss_score": 0.00052, "epss_percentile": 0.16624}, "CVE-2025-54744": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-54745": {"epss_score": 0.00036, "epss_percentile": 0.10188}, "CVE-2025-54746": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54747": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54748": {"epss_score": 0.00048, "epss_percentile": 0.15125}, "CVE-2025-54749": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-54750": {"epss_score": 0.00204, "epss_percentile": 0.42591}, "CVE-2025-54751": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-54752": {"epss_score": 0.00034, "epss_percentile": 0.09662}, "CVE-2025-54754": {"epss_score": 0.00035, "epss_percentile": 0.09926}, "CVE-2025-54755": {"epss_score": 0.00319, "epss_percentile": 0.54477}, "CVE-2025-54757": {"epss_score": 0.00027, "epss_percentile": 0.06984}, "CVE-2025-54759": {"epss_score": 0.00055, "epss_percentile": 0.17624}, "CVE-2025-54760": {"epss_score": 0.00048, "epss_percentile": 0.15235}, "CVE-2025-54761": {"epss_score": 0.00049, "epss_percentile": 0.15322}, "CVE-2025-54762": {"epss_score": 0.00299, "epss_percentile": 0.52898}, "CVE-2025-54763": {"epss_score": 0.00249, "epss_percentile": 0.48077}, "CVE-2025-54764": {"epss_score": 0.00021, "epss_percentile": 0.04737}, "CVE-2025-54765": {"epss_score": 0.00061, "epss_percentile": 0.19379}, "CVE-2025-54766": {"epss_score": 0.00052, "epss_percentile": 0.16611}, "CVE-2025-54767": {"epss_score": 0.00039, "epss_percentile": 0.11588}, "CVE-2025-54768": {"epss_score": 0.00052, "epss_percentile": 0.16611}, "CVE-2025-54769": {"epss_score": 0.02684, "epss_percentile": 0.85422}, "CVE-2025-54770": {"epss_score": 0.00017, "epss_percentile": 0.03271}, "CVE-2025-54771": {"epss_score": 0.00017, "epss_percentile": 0.03271}, "CVE-2025-54777": {"epss_score": 0.00019, "epss_percentile": 0.04083}, "CVE-2025-54780": {"epss_score": 0.00035, "epss_percentile": 0.09906}, "CVE-2025-54781": {"epss_score": 9e-05, "epss_percentile": 0.00658}, "CVE-2025-54782": {"epss_score": 0.14387, "epss_percentile": 0.942}, "CVE-2025-54783": {"epss_score": 0.00021, "epss_percentile": 0.04803}, "CVE-2025-54784": {"epss_score": 0.00021, "epss_percentile": 0.04803}, "CVE-2025-54785": {"epss_score": 0.00093, "epss_percentile": 0.26705}, "CVE-2025-54786": {"epss_score": 0.00042, "epss_percentile": 0.12748}, "CVE-2025-54787": {"epss_score": 0.00042, "epss_percentile": 0.12812}, "CVE-2025-54788": {"epss_score": 0.00044, "epss_percentile": 0.13573}, "CVE-2025-54789": {"epss_score": 0.00033, "epss_percentile": 0.09155}, "CVE-2025-54790": {"epss_score": 0.00045, "epss_percentile": 0.13776}, "CVE-2025-54791": {"epss_score": 0.00053, "epss_percentile": 0.16837}, "CVE-2025-54792": {"epss_score": 0.0001, "epss_percentile": 0.00827}, "CVE-2025-54793": {"epss_score": 9e-05, "epss_percentile": 0.00626}, "CVE-2025-54794": {"epss_score": 0.00035, "epss_percentile": 0.10159}, "CVE-2025-54795": {"epss_score": 0.00159, "epss_percentile": 0.37316}, "CVE-2025-54796": {"epss_score": 0.00052, "epss_percentile": 0.16372}, "CVE-2025-54798": {"epss_score": 0.00066, "epss_percentile": 0.20931}, "CVE-2025-54799": {"epss_score": 0.00024, "epss_percentile": 0.05816}, "CVE-2025-54800": {"epss_score": 0.00022, "epss_percentile": 0.05036}, "CVE-2025-54801": {"epss_score": 0.00055, "epss_percentile": 0.1754}, "CVE-2025-54802": {"epss_score": 0.00575, "epss_percentile": 0.68097}, "CVE-2025-54803": {"epss_score": 0.00083, "epss_percentile": 0.24638}, "CVE-2025-54804": {"epss_score": 0.00059, "epss_percentile": 0.18821}, "CVE-2025-54805": {"epss_score": 0.00112, "epss_percentile": 0.30563}, "CVE-2025-54806": {"epss_score": 0.00037, "epss_percentile": 0.10983}, "CVE-2025-54807": {"epss_score": 0.00125, "epss_percentile": 0.32612}, "CVE-2025-54808": {"epss_score": 0.0003, "epss_percentile": 0.08241}, "CVE-2025-54809": {"epss_score": 0.00093, "epss_percentile": 0.26675}, "CVE-2025-54810": {"epss_score": 0.00022, "epss_percentile": 0.05037}, "CVE-2025-54811": {"epss_score": 0.00039, "epss_percentile": 0.11435}, "CVE-2025-54812": {"epss_score": 0.00405, "epss_percentile": 0.60463}, "CVE-2025-54813": {"epss_score": 0.00204, "epss_percentile": 0.42634}, "CVE-2025-54815": {"epss_score": 0.00114, "epss_percentile": 0.30742}, "CVE-2025-54818": {"epss_score": 0.0001, "epss_percentile": 0.00766}, "CVE-2025-54819": {"epss_score": 0.00137, "epss_percentile": 0.34308}, "CVE-2025-54821": {"epss_score": 0.00016, "epss_percentile": 0.02859}, "CVE-2025-54822": {"epss_score": 0.00037, "epss_percentile": 0.10627}, "CVE-2025-54831": {"epss_score": 0.00066, "epss_percentile": 0.20682}, "CVE-2025-54832": {"epss_score": 0.00036, "epss_percentile": 0.10615}, "CVE-2025-54833": {"epss_score": 0.00029, "epss_percentile": 0.07682}, "CVE-2025-54834": {"epss_score": 0.00035, "epss_percentile": 0.10138}, "CVE-2025-54838": {"epss_score": 0.00021, "epss_percentile": 0.04834}, "CVE-2025-54848": {"epss_score": 0.00062, "epss_percentile": 0.19588}, "CVE-2025-54849": {"epss_score": 0.00062, "epss_percentile": 0.19588}, "CVE-2025-54850": {"epss_score": 0.00062, "epss_percentile": 0.19588}, "CVE-2025-54851": {"epss_score": 0.00062, "epss_percentile": 0.19588}, "CVE-2025-54854": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-54855": {"epss_score": 7e-05, "epss_percentile": 0.0035}, "CVE-2025-54856": {"epss_score": 0.00039, "epss_percentile": 0.11588}, "CVE-2025-54857": {"epss_score": 0.00872, "epss_percentile": 0.74727}, "CVE-2025-54858": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-54859": {"epss_score": 0.00049, "epss_percentile": 0.1546}, "CVE-2025-54860": {"epss_score": 0.00021, "epss_percentile": 0.0486}, "CVE-2025-54862": {"epss_score": 0.00055, "epss_percentile": 0.17491}, "CVE-2025-54863": {"epss_score": 0.00056, "epss_percentile": 0.17889}, "CVE-2025-54864": {"epss_score": 0.00112, "epss_percentile": 0.30509}, "CVE-2025-54865": {"epss_score": 0.00064, "epss_percentile": 0.20337}, "CVE-2025-54866": {"epss_score": 0.00015, "epss_percentile": 0.02505}, "CVE-2025-54867": {"epss_score": 0.00029, "epss_percentile": 0.07847}, "CVE-2025-54868": {"epss_score": 0.00053, "epss_percentile": 0.16733}, "CVE-2025-54869": {"epss_score": 0.00101, "epss_percentile": 0.28593}, "CVE-2025-54870": {"epss_score": 0.00034, "epss_percentile": 0.0952}, "CVE-2025-54871": {"epss_score": 0.00013, "epss_percentile": 0.01496}, "CVE-2025-54872": {"epss_score": 0.00049, "epss_percentile": 0.156}, "CVE-2025-54873": {"epss_score": 0.00055, "epss_percentile": 0.17481}, "CVE-2025-54874": {"epss_score": 0.00047, "epss_percentile": 0.14501}, "CVE-2025-54875": {"epss_score": 0.00079, "epss_percentile": 0.23989}, "CVE-2025-54876": {"epss_score": 0.00047, "epss_percentile": 0.14505}, "CVE-2025-54877": {"epss_score": 0.00043, "epss_percentile": 0.13278}, "CVE-2025-54878": {"epss_score": 0.00116, "epss_percentile": 0.3115}, "CVE-2025-54879": {"epss_score": 0.00121, "epss_percentile": 0.31921}, "CVE-2025-54880": {"epss_score": 0.00054, "epss_percentile": 0.17182}, "CVE-2025-54881": {"epss_score": 0.00025, "epss_percentile": 0.0622}, "CVE-2025-54882": {"epss_score": 0.00013, "epss_percentile": 0.01579}, "CVE-2025-54883": {"epss_score": 0.00078, "epss_percentile": 0.23604}, "CVE-2025-54884": {"epss_score": 0.00084, "epss_percentile": 0.2493}, "CVE-2025-54885": {"epss_score": 0.00059, "epss_percentile": 0.1866}, "CVE-2025-54886": {"epss_score": 0.00226, "epss_percentile": 0.45311}, "CVE-2025-54887": {"epss_score": 7e-05, "epss_percentile": 0.00399}, "CVE-2025-54888": {"epss_score": 0.00089, "epss_percentile": 0.25939}, "CVE-2025-54889": {"epss_score": 0.0001, "epss_percentile": 0.00779}, "CVE-2025-54890": {"epss_score": 0.0002, "epss_percentile": 0.04484}, "CVE-2025-54891": {"epss_score": 0.0001, "epss_percentile": 0.00779}, "CVE-2025-54892": {"epss_score": 0.0001, "epss_percentile": 0.00779}, "CVE-2025-54893": {"epss_score": 0.0001, "epss_percentile": 0.00779}, "CVE-2025-54894": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-54895": {"epss_score": 0.00064, "epss_percentile": 0.20325}, "CVE-2025-54896": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-54897": {"epss_score": 0.02966, "epss_percentile": 0.86082}, "CVE-2025-54898": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-54899": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-54900": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-54901": {"epss_score": 0.00058, "epss_percentile": 0.18605}, "CVE-2025-54902": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-54903": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-54904": {"epss_score": 0.00058, "epss_percentile": 0.18476}, "CVE-2025-54905": {"epss_score": 0.0007, "epss_percentile": 0.21753}, "CVE-2025-54906": {"epss_score": 0.00111, "epss_percentile": 0.30319}, "CVE-2025-54907": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-54908": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-54910": {"epss_score": 0.00066, "epss_percentile": 0.20906}, "CVE-2025-54911": {"epss_score": 0.00078, "epss_percentile": 0.23738}, "CVE-2025-54912": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-54913": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-54914": {"epss_score": 0.0023, "epss_percentile": 0.45688}, "CVE-2025-54915": {"epss_score": 0.00193, "epss_percentile": 0.41428}, "CVE-2025-54916": {"epss_score": 0.00088, "epss_percentile": 0.25777}, "CVE-2025-54917": {"epss_score": 0.00087, "epss_percentile": 0.25533}, "CVE-2025-54918": {"epss_score": 0.00153, "epss_percentile": 0.36526}, "CVE-2025-54919": {"epss_score": 0.00046, "epss_percentile": 0.14099}, "CVE-2025-54923": {"epss_score": 0.0059, "epss_percentile": 0.68569}, "CVE-2025-54924": {"epss_score": 0.00065, "epss_percentile": 0.20614}, "CVE-2025-54925": {"epss_score": 0.00048, "epss_percentile": 0.15217}, "CVE-2025-54926": {"epss_score": 0.00289, "epss_percentile": 0.5205}, "CVE-2025-54927": {"epss_score": 0.00051, "epss_percentile": 0.16309}, "CVE-2025-54939": {"epss_score": 0.00067, "epss_percentile": 0.21166}, "CVE-2025-54940": {"epss_score": 0.0002, "epss_percentile": 0.04674}, "CVE-2025-54941": {"epss_score": 0.001, "epss_percentile": 0.28457}, "CVE-2025-54942": {"epss_score": 0.00425, "epss_percentile": 0.61698}, "CVE-2025-54943": {"epss_score": 0.00212, "epss_percentile": 0.43822}, "CVE-2025-54944": {"epss_score": 0.00445, "epss_percentile": 0.62879}, "CVE-2025-54945": {"epss_score": 0.00219, "epss_percentile": 0.4449}, "CVE-2025-54946": {"epss_score": 0.00157, "epss_percentile": 0.37037}, "CVE-2025-54947": {"epss_score": 0.00048, "epss_percentile": 0.15098}, "CVE-2025-54948": {"epss_score": 0.16877, "epss_percentile": 0.94739}, "CVE-2025-54949": {"epss_score": 0.00093, "epss_percentile": 0.26705}, "CVE-2025-54950": {"epss_score": 0.00109, "epss_percentile": 0.29923}, "CVE-2025-54951": {"epss_score": 0.00093, "epss_percentile": 0.26705}, "CVE-2025-54952": {"epss_score": 0.00124, "epss_percentile": 0.32422}, "CVE-2025-54955": {"epss_score": 0.0008, "epss_percentile": 0.24156}, "CVE-2025-54956": {"epss_score": 0.00015, "epss_percentile": 0.02507}, "CVE-2025-54957": {"epss_score": 0.00047, "epss_percentile": 0.14691}, "CVE-2025-54958": {"epss_score": 0.00474, "epss_percentile": 0.64163}, "CVE-2025-54959": {"epss_score": 0.00043, "epss_percentile": 0.13012}, "CVE-2025-54962": {"epss_score": 0.00035, "epss_percentile": 0.10136}, "CVE-2025-54963": {"epss_score": 0.00289, "epss_percentile": 0.52027}, "CVE-2025-54964": {"epss_score": 0.00115, "epss_percentile": 0.30919}, "CVE-2025-54965": {"epss_score": 0.00041, "epss_percentile": 0.12317}, "CVE-2025-54966": {"epss_score": 0.00043, "epss_percentile": 0.13132}, "CVE-2025-54967": {"epss_score": 0.00046, "epss_percentile": 0.14268}, "CVE-2025-54968": {"epss_score": 0.00244, "epss_percentile": 0.47596}, "CVE-2025-54969": {"epss_score": 0.00022, "epss_percentile": 0.04976}, "CVE-2025-54970": {"epss_score": 0.00038, "epss_percentile": 0.11367}, "CVE-2025-54971": {"epss_score": 0.00042, "epss_percentile": 0.12914}, "CVE-2025-54972": {"epss_score": 0.00039, "epss_percentile": 0.11716}, "CVE-2025-54973": {"epss_score": 0.00043, "epss_percentile": 0.13074}, "CVE-2025-54981": {"epss_score": 0.0002, "epss_percentile": 0.04496}, "CVE-2025-54982": {"epss_score": 0.00036, "epss_percentile": 0.10282}, "CVE-2025-54983": {"epss_score": 0.00015, "epss_percentile": 0.02419}, "CVE-2025-54987": {"epss_score": 0.00601, "epss_percentile": 0.68848}, "CVE-2025-54988": {"epss_score": 0.00028, "epss_percentile": 0.07284}, "CVE-2025-54989": {"epss_score": 0.0014, "epss_percentile": 0.34773}, "CVE-2025-54990": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-54992": {"epss_score": 0.00087, "epss_percentile": 0.25505}, "CVE-2025-54994": {"epss_score": 0.00562, "epss_percentile": 0.67683}, "CVE-2025-54995": {"epss_score": 0.00598, "epss_percentile": 0.68774}, "CVE-2025-54996": {"epss_score": 0.0004, "epss_percentile": 0.12098}, "CVE-2025-54997": {"epss_score": 0.00066, "epss_percentile": 0.20678}, "CVE-2025-54998": {"epss_score": 0.00049, "epss_percentile": 0.15333}, "CVE-2025-54999": {"epss_score": 0.00019, "epss_percentile": 0.04203}, "CVE-2025-55000": {"epss_score": 0.00026, "epss_percentile": 0.06438}, "CVE-2025-55001": {"epss_score": 0.00024, "epss_percentile": 0.0599}, "CVE-2025-55003": {"epss_score": 0.00038, "epss_percentile": 0.11161}, "CVE-2025-55004": {"epss_score": 0.00063, "epss_percentile": 0.19979}, "CVE-2025-55005": {"epss_score": 0.00037, "epss_percentile": 0.10803}, "CVE-2025-55006": {"epss_score": 0.00056, "epss_percentile": 0.1779}, "CVE-2025-55007": {"epss_score": 0.00051, "epss_percentile": 0.16142}, "CVE-2025-55008": {"epss_score": 0.00058, "epss_percentile": 0.18269}, "CVE-2025-55009": {"epss_score": 0.00058, "epss_percentile": 0.18269}, "CVE-2025-55010": {"epss_score": 0.01213, "epss_percentile": 0.7857}, "CVE-2025-55011": {"epss_score": 0.00057, "epss_percentile": 0.18002}, "CVE-2025-55012": {"epss_score": 0.00019, "epss_percentile": 0.04283}, "CVE-2025-55013": {"epss_score": 0.0002, "epss_percentile": 0.04604}, "CVE-2025-55014": {"epss_score": 0.00065, "epss_percentile": 0.20547}, "CVE-2025-55028": {"epss_score": 0.00113, "epss_percentile": 0.30662}, "CVE-2025-55029": {"epss_score": 0.00133, "epss_percentile": 0.33667}, "CVE-2025-55030": {"epss_score": 0.00048, "epss_percentile": 0.15003}, "CVE-2025-55031": {"epss_score": 0.00081, "epss_percentile": 0.24229}, "CVE-2025-55032": {"epss_score": 0.00048, "epss_percentile": 0.15003}, "CVE-2025-55033": {"epss_score": 0.00051, "epss_percentile": 0.16177}, "CVE-2025-55034": {"epss_score": 0.00051, "epss_percentile": 0.16174}, "CVE-2025-55035": {"epss_score": 0.00077, "epss_percentile": 0.23288}, "CVE-2025-55036": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-55037": {"epss_score": 0.00814, "epss_percentile": 0.73778}, "CVE-2025-55038": {"epss_score": 0.00034, "epss_percentile": 0.09785}, "CVE-2025-55039": {"epss_score": 0.00058, "epss_percentile": 0.18472}, "CVE-2025-55047": {"epss_score": 0.00019, "epss_percentile": 0.04187}, "CVE-2025-55048": {"epss_score": 0.00071, "epss_percentile": 0.22204}, "CVE-2025-55049": {"epss_score": 0.00045, "epss_percentile": 0.13761}, "CVE-2025-55050": {"epss_score": 0.00062, "epss_percentile": 0.19687}, "CVE-2025-55051": {"epss_score": 0.00062, "epss_percentile": 0.19687}, "CVE-2025-55052": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-55053": {"epss_score": 0.00019, "epss_percentile": 0.04334}, "CVE-2025-55054": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-55055": {"epss_score": 0.00094, "epss_percentile": 0.27014}, "CVE-2025-55056": {"epss_score": 0.00031, "epss_percentile": 0.08681}, "CVE-2025-55057": {"epss_score": 0.00017, "epss_percentile": 0.03329}, "CVE-2025-55058": {"epss_score": 0.00062, "epss_percentile": 0.1972}, "CVE-2025-55059": {"epss_score": 0.00031, "epss_percentile": 0.08681}, "CVE-2025-55060": {"epss_score": 0.00029, "epss_percentile": 0.07743}, "CVE-2025-55061": {"epss_score": 0.00047, "epss_percentile": 0.14894}, "CVE-2025-55062": {"epss_score": 0.00029, "epss_percentile": 0.07694}, "CVE-2025-55063": {"epss_score": 0.00029, "epss_percentile": 0.07694}, "CVE-2025-55064": {"epss_score": 0.00029, "epss_percentile": 0.07694}, "CVE-2025-55065": {"epss_score": 0.00046, "epss_percentile": 0.14394}, "CVE-2025-55067": {"epss_score": 0.00142, "epss_percentile": 0.35087}, "CVE-2025-55068": {"epss_score": 0.00107, "epss_percentile": 0.29584}, "CVE-2025-55069": {"epss_score": 0.00052, "epss_percentile": 0.16459}, "CVE-2025-55070": {"epss_score": 0.0009, "epss_percentile": 0.26037}, "CVE-2025-55072": {"epss_score": 0.00048, "epss_percentile": 0.15235}, "CVE-2025-55073": {"epss_score": 0.00038, "epss_percentile": 0.1113}, "CVE-2025-55074": {"epss_score": 0.00029, "epss_percentile": 0.07634}, "CVE-2025-55075": {"epss_score": 0.00046, "epss_percentile": 0.14345}, "CVE-2025-55076": {"epss_score": 0.00015, "epss_percentile": 0.0222}, "CVE-2025-55077": {"epss_score": 0.00041, "epss_percentile": 0.12271}, "CVE-2025-55078": {"epss_score": 0.00019, "epss_percentile": 0.04275}, "CVE-2025-55079": {"epss_score": 0.00019, "epss_percentile": 0.04275}, "CVE-2025-55080": {"epss_score": 0.00018, "epss_percentile": 0.04016}, "CVE-2025-55081": {"epss_score": 0.00067, "epss_percentile": 0.21178}, "CVE-2025-55082": {"epss_score": 0.00043, "epss_percentile": 0.13318}, "CVE-2025-55083": {"epss_score": 0.00043, "epss_percentile": 0.13318}, "CVE-2025-55084": {"epss_score": 0.00043, "epss_percentile": 0.13318}, "CVE-2025-55085": {"epss_score": 0.00211, "epss_percentile": 0.43638}, "CVE-2025-55086": {"epss_score": 0.00059, "epss_percentile": 0.18704}, "CVE-2025-55087": {"epss_score": 0.00127, "epss_percentile": 0.32876}, "CVE-2025-55089": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-55090": {"epss_score": 0.00059, "epss_percentile": 0.18626}, "CVE-2025-55091": {"epss_score": 0.00059, "epss_percentile": 0.18626}, "CVE-2025-55092": {"epss_score": 0.00043, "epss_percentile": 0.13318}, "CVE-2025-55093": {"epss_score": 0.00045, "epss_percentile": 0.14068}, "CVE-2025-55094": {"epss_score": 0.00049, "epss_percentile": 0.15342}, "CVE-2025-55096": {"epss_score": 0.00019, "epss_percentile": 0.04406}, "CVE-2025-55097": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2025-55098": {"epss_score": 0.00046, "epss_percentile": 0.14164}, "CVE-2025-55099": {"epss_score": 0.00046, "epss_percentile": 0.14164}, "CVE-2025-55100": {"epss_score": 0.00112, "epss_percentile": 0.30473}, "CVE-2025-55103": {"epss_score": 0.00061, "epss_percentile": 0.19379}, "CVE-2025-55104": {"epss_score": 0.0005, "epss_percentile": 0.15887}, "CVE-2025-55105": {"epss_score": 0.00061, "epss_percentile": 0.19379}, "CVE-2025-55106": {"epss_score": 0.00061, "epss_percentile": 0.19379}, "CVE-2025-55107": {"epss_score": 0.00061, "epss_percentile": 0.19379}, "CVE-2025-55108": {"epss_score": 0.00418, "epss_percentile": 0.61281}, "CVE-2025-55109": {"epss_score": 0.00067, "epss_percentile": 0.21029}, "CVE-2025-55110": {"epss_score": 0.00017, "epss_percentile": 0.03255}, "CVE-2025-55111": {"epss_score": 0.00012, "epss_percentile": 0.01305}, "CVE-2025-55112": {"epss_score": 0.00017, "epss_percentile": 0.0344}, "CVE-2025-55113": {"epss_score": 0.00055, "epss_percentile": 0.17633}, "CVE-2025-55114": {"epss_score": 0.00058, "epss_percentile": 0.18506}, "CVE-2025-55115": {"epss_score": 0.00023, "epss_percentile": 0.05407}, "CVE-2025-55116": {"epss_score": 0.00017, "epss_percentile": 0.03203}, "CVE-2025-55117": {"epss_score": 0.00047, "epss_percentile": 0.14669}, "CVE-2025-55118": {"epss_score": 0.00057, "epss_percentile": 0.18089}, "CVE-2025-55123": {"epss_score": 0.00018, "epss_percentile": 0.03763}, "CVE-2025-55124": {"epss_score": 0.00028, "epss_percentile": 0.07573}, "CVE-2025-55126": {"epss_score": 0.00039, "epss_percentile": 0.11704}, "CVE-2025-55127": {"epss_score": 0.00011, "epss_percentile": 0.01048}, "CVE-2025-55128": {"epss_score": 0.00058, "epss_percentile": 0.18357}, "CVE-2025-55129": {"epss_score": 0.00021, "epss_percentile": 0.04917}, "CVE-2025-55133": {"epss_score": 0.00026, "epss_percentile": 0.06718}, "CVE-2025-55134": {"epss_score": 0.00026, "epss_percentile": 0.06718}, "CVE-2025-55135": {"epss_score": 0.00033, "epss_percentile": 0.09164}, "CVE-2025-55136": {"epss_score": 0.00038, "epss_percentile": 0.11418}, "CVE-2025-55137": {"epss_score": 0.00026, "epss_percentile": 0.06729}, "CVE-2025-55138": {"epss_score": 0.00026, "epss_percentile": 0.06437}, "CVE-2025-55139": {"epss_score": 0.00379, "epss_percentile": 0.58897}, "CVE-2025-55141": {"epss_score": 0.02793, "epss_percentile": 0.85672}, "CVE-2025-55142": {"epss_score": 0.02793, "epss_percentile": 0.85672}, "CVE-2025-55143": {"epss_score": 0.00042, "epss_percentile": 0.12921}, "CVE-2025-55144": {"epss_score": 0.01094, "epss_percentile": 0.7749}, "CVE-2025-55145": {"epss_score": 0.00479, "epss_percentile": 0.64442}, "CVE-2025-55146": {"epss_score": 0.00727, "epss_percentile": 0.72099}, "CVE-2025-55147": {"epss_score": 0.00404, "epss_percentile": 0.60432}, "CVE-2025-55148": {"epss_score": 0.01245, "epss_percentile": 0.78844}, "CVE-2025-55149": {"epss_score": 0.00067, "epss_percentile": 0.21171}, "CVE-2025-55150": {"epss_score": 0.0005, "epss_percentile": 0.15784}, "CVE-2025-55151": {"epss_score": 0.0005, "epss_percentile": 0.15784}, "CVE-2025-55152": {"epss_score": 0.00051, "epss_percentile": 0.16115}, "CVE-2025-55154": {"epss_score": 0.00073, "epss_percentile": 0.22592}, "CVE-2025-55155": {"epss_score": 0.00018, "epss_percentile": 0.03608}, "CVE-2025-55156": {"epss_score": 0.00028, "epss_percentile": 0.07364}, "CVE-2025-55157": {"epss_score": 0.00035, "epss_percentile": 0.10113}, "CVE-2025-55158": {"epss_score": 0.00035, "epss_percentile": 0.10113}, "CVE-2025-55159": {"epss_score": 0.00018, "epss_percentile": 0.03674}, "CVE-2025-55160": {"epss_score": 0.00063, "epss_percentile": 0.20098}, "CVE-2025-55161": {"epss_score": 0.02344, "epss_percentile": 0.84445}, "CVE-2025-55162": {"epss_score": 0.0001, "epss_percentile": 0.00799}, "CVE-2025-55163": {"epss_score": 0.00173, "epss_percentile": 0.39122}, "CVE-2025-55164": {"epss_score": 0.0007, "epss_percentile": 0.21719}, "CVE-2025-55165": {"epss_score": 0.00011, "epss_percentile": 0.01042}, "CVE-2025-55166": {"epss_score": 0.00085, "epss_percentile": 0.25043}, "CVE-2025-55167": {"epss_score": 0.0004, "epss_percentile": 0.11869}, "CVE-2025-55168": {"epss_score": 0.00046, "epss_percentile": 0.14276}, "CVE-2025-55169": {"epss_score": 0.01107, "epss_percentile": 0.77629}, "CVE-2025-55170": {"epss_score": 0.00045, "epss_percentile": 0.13785}, "CVE-2025-55171": {"epss_score": 0.00081, "epss_percentile": 0.24283}, "CVE-2025-55173": {"epss_score": 0.00133, "epss_percentile": 0.33635}, "CVE-2025-55174": {"epss_score": 0.00016, "epss_percentile": 0.02853}, "CVE-2025-55175": {"epss_score": 0.00066, "epss_percentile": 0.20872}, "CVE-2025-55177": {"epss_score": 0.01378, "epss_percentile": 0.79848}, "CVE-2025-55178": {"epss_score": 0.00124, "epss_percentile": 0.3235}, "CVE-2025-55179": {"epss_score": 0.0003, "epss_percentile": 0.08075}, "CVE-2025-55181": {"epss_score": 0.00059, "epss_percentile": 0.18696}, "CVE-2025-55182": {"epss_score": 0.53464, "epss_percentile": 0.97878}, "CVE-2025-55183": {"epss_score": 0.12469, "epss_percentile": 0.93682}, "CVE-2025-55184": {"epss_score": 0.17001, "epss_percentile": 0.94758}, "CVE-2025-55187": {"epss_score": 0.00058, "epss_percentile": 0.18517}, "CVE-2025-55188": {"epss_score": 0.00027, "epss_percentile": 0.06823}, "CVE-2025-55190": {"epss_score": 0.06864, "epss_percentile": 0.91082}, "CVE-2025-55191": {"epss_score": 0.00039, "epss_percentile": 0.11862}, "CVE-2025-55192": {"epss_score": 0.0007, "epss_percentile": 0.21687}, "CVE-2025-55193": {"epss_score": 0.00082, "epss_percentile": 0.2448}, "CVE-2025-55194": {"epss_score": 0.00108, "epss_percentile": 0.29809}, "CVE-2025-55195": {"epss_score": 0.00088, "epss_percentile": 0.25692}, "CVE-2025-55196": {"epss_score": 0.00061, "epss_percentile": 0.19248}, "CVE-2025-55197": {"epss_score": 0.00084, "epss_percentile": 0.25023}, "CVE-2025-55198": {"epss_score": 0.00025, "epss_percentile": 0.06061}, "CVE-2025-55199": {"epss_score": 0.00019, "epss_percentile": 0.04259}, "CVE-2025-55200": {"epss_score": 0.00042, "epss_percentile": 0.12674}, "CVE-2025-55201": {"epss_score": 0.00034, "epss_percentile": 0.09567}, "CVE-2025-55202": {"epss_score": 0.00066, "epss_percentile": 0.20764}, "CVE-2025-55203": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-55204": {"epss_score": 0.00158, "epss_percentile": 0.3719}, "CVE-2025-55205": {"epss_score": 0.00023, "epss_percentile": 0.05406}, "CVE-2025-55207": {"epss_score": 0.00023, "epss_percentile": 0.055}, "CVE-2025-55209": {"epss_score": 0.0009, "epss_percentile": 0.26151}, "CVE-2025-55211": {"epss_score": 0.00075, "epss_percentile": 0.22914}, "CVE-2025-55212": {"epss_score": 0.00334, "epss_percentile": 0.55714}, "CVE-2025-55213": {"epss_score": 0.00074, "epss_percentile": 0.22869}, "CVE-2025-55214": {"epss_score": 0.00035, "epss_percentile": 0.09882}, "CVE-2025-55221": {"epss_score": 0.00062, "epss_percentile": 0.19588}, "CVE-2025-55222": {"epss_score": 0.00062, "epss_percentile": 0.19588}, "CVE-2025-55223": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-55224": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-55225": {"epss_score": 0.00074, "epss_percentile": 0.22843}, "CVE-2025-55226": {"epss_score": 0.00024, "epss_percentile": 0.05861}, "CVE-2025-55227": {"epss_score": 0.00113, "epss_percentile": 0.30694}, "CVE-2025-55228": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-55229": {"epss_score": 0.00056, "epss_percentile": 0.17671}, "CVE-2025-55230": {"epss_score": 0.00106, "epss_percentile": 0.29418}, "CVE-2025-55231": {"epss_score": 0.00104, "epss_percentile": 0.29205}, "CVE-2025-55232": {"epss_score": 0.00615, "epss_percentile": 0.69304}, "CVE-2025-55233": {"epss_score": 0.00049, "epss_percentile": 0.15513}, "CVE-2025-55234": {"epss_score": 0.00621, "epss_percentile": 0.69487}, "CVE-2025-55236": {"epss_score": 0.00115, "epss_percentile": 0.30901}, "CVE-2025-55238": {"epss_score": 0.0017, "epss_percentile": 0.38751}, "CVE-2025-55240": {"epss_score": 0.00059, "epss_percentile": 0.18755}, "CVE-2025-55241": {"epss_score": 0.00135, "epss_percentile": 0.34056}, "CVE-2025-55242": {"epss_score": 0.00194, "epss_percentile": 0.41578}, "CVE-2025-55243": {"epss_score": 0.00109, "epss_percentile": 0.30044}, "CVE-2025-55244": {"epss_score": 0.0016, "epss_percentile": 0.37425}, "CVE-2025-55245": {"epss_score": 0.001, "epss_percentile": 0.28474}, "CVE-2025-55247": {"epss_score": 0.0003, "epss_percentile": 0.08031}, "CVE-2025-55248": {"epss_score": 0.00034, "epss_percentile": 0.09761}, "CVE-2025-55254": {"epss_score": 0.00039, "epss_percentile": 0.11642}, "CVE-2025-55278": {"epss_score": 0.0002, "epss_percentile": 0.04489}, "CVE-2025-55279": {"epss_score": 0.00034, "epss_percentile": 0.09784}, "CVE-2025-55280": {"epss_score": 0.00015, "epss_percentile": 0.0235}, "CVE-2025-55282": {"epss_score": 0.00112, "epss_percentile": 0.30425}, "CVE-2025-55283": {"epss_score": 0.00088, "epss_percentile": 0.25653}, "CVE-2025-55284": {"epss_score": 0.00033, "epss_percentile": 0.09121}, "CVE-2025-55285": {"epss_score": 0.00046, "epss_percentile": 0.14194}, "CVE-2025-55286": {"epss_score": 0.00025, "epss_percentile": 0.06106}, "CVE-2025-55287": {"epss_score": 0.00067, "epss_percentile": 0.21113}, "CVE-2025-55288": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-55291": {"epss_score": 0.00034, "epss_percentile": 0.09744}, "CVE-2025-55293": {"epss_score": 0.00074, "epss_percentile": 0.2287}, "CVE-2025-55294": {"epss_score": 0.00345, "epss_percentile": 0.56581}, "CVE-2025-55295": {"epss_score": 0.0007, "epss_percentile": 0.21877}, "CVE-2025-55296": {"epss_score": 8e-05, "epss_percentile": 0.00482}, "CVE-2025-55297": {"epss_score": 0.00055, "epss_percentile": 0.17581}, "CVE-2025-55298": {"epss_score": 0.005, "epss_percentile": 0.65325}, "CVE-2025-55299": {"epss_score": 0.00044, "epss_percentile": 0.13674}, "CVE-2025-55300": {"epss_score": 0.00642, "epss_percentile": 0.70028}, "CVE-2025-55301": {"epss_score": 0.00034, "epss_percentile": 0.09435}, "CVE-2025-55303": {"epss_score": 0.00021, "epss_percentile": 0.0491}, "CVE-2025-55304": {"epss_score": 8e-05, "epss_percentile": 0.00521}, "CVE-2025-55305": {"epss_score": 9e-05, "epss_percentile": 0.00651}, "CVE-2025-55306": {"epss_score": 0.00106, "epss_percentile": 0.29502}, "CVE-2025-55307": {"epss_score": 0.00015, "epss_percentile": 0.02416}, "CVE-2025-55308": {"epss_score": 0.00015, "epss_percentile": 0.02598}, "CVE-2025-55309": {"epss_score": 0.00015, "epss_percentile": 0.02598}, "CVE-2025-55310": {"epss_score": 7e-05, "epss_percentile": 0.00349}, "CVE-2025-55311": {"epss_score": 0.00014, "epss_percentile": 0.01923}, "CVE-2025-55312": {"epss_score": 0.00016, "epss_percentile": 0.0293}, "CVE-2025-55313": {"epss_score": 0.00025, "epss_percentile": 0.06303}, "CVE-2025-55314": {"epss_score": 0.00016, "epss_percentile": 0.0293}, "CVE-2025-55315": {"epss_score": 0.00284, "epss_percentile": 0.51426}, "CVE-2025-55316": {"epss_score": 0.00133, "epss_percentile": 0.33651}, "CVE-2025-55317": {"epss_score": 0.001, "epss_percentile": 0.28474}, "CVE-2025-55319": {"epss_score": 0.00092, "epss_percentile": 0.26538}, "CVE-2025-55320": {"epss_score": 0.00182, "epss_percentile": 0.40201}, "CVE-2025-55321": {"epss_score": 0.00063, "epss_percentile": 0.20099}, "CVE-2025-55322": {"epss_score": 0.00097, "epss_percentile": 0.27628}, "CVE-2025-55325": {"epss_score": 0.00056, "epss_percentile": 0.17885}, "CVE-2025-55326": {"epss_score": 0.00078, "epss_percentile": 0.23785}, "CVE-2025-55328": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-55330": {"epss_score": 0.00072, "epss_percentile": 0.22261}, "CVE-2025-55331": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-55332": {"epss_score": 0.00072, "epss_percentile": 0.22261}, "CVE-2025-55333": {"epss_score": 0.00072, "epss_percentile": 0.22261}, "CVE-2025-55334": {"epss_score": 0.00023, "epss_percentile": 0.05504}, "CVE-2025-55335": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-55336": {"epss_score": 0.00058, "epss_percentile": 0.18601}, "CVE-2025-55337": {"epss_score": 0.00072, "epss_percentile": 0.22261}, "CVE-2025-55338": {"epss_score": 0.00073, "epss_percentile": 0.22661}, "CVE-2025-55339": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-55340": {"epss_score": 0.00056, "epss_percentile": 0.17667}, "CVE-2025-55341": {"epss_score": 0.00042, "epss_percentile": 0.12484}, "CVE-2025-55342": {"epss_score": 0.00039, "epss_percentile": 0.11732}, "CVE-2025-55343": {"epss_score": 0.00039, "epss_percentile": 0.11662}, "CVE-2025-55345": {"epss_score": 0.0033, "epss_percentile": 0.55459}, "CVE-2025-55346": {"epss_score": 0.0003, "epss_percentile": 0.08016}, "CVE-2025-55366": {"epss_score": 0.00065, "epss_percentile": 0.20622}, "CVE-2025-55367": {"epss_score": 0.00065, "epss_percentile": 0.20622}, "CVE-2025-55368": {"epss_score": 0.00089, "epss_percentile": 0.25904}, "CVE-2025-55370": {"epss_score": 0.00089, "epss_percentile": 0.25904}, "CVE-2025-55371": {"epss_score": 0.00065, "epss_percentile": 0.20622}, "CVE-2025-55372": {"epss_score": 0.00092, "epss_percentile": 0.26481}, "CVE-2025-55373": {"epss_score": 0.0014, "epss_percentile": 0.34753}, "CVE-2025-55383": {"epss_score": 0.0008, "epss_percentile": 0.24204}, "CVE-2025-55398": {"epss_score": 0.00123, "epss_percentile": 0.32198}, "CVE-2025-55409": {"epss_score": 0.00126, "epss_percentile": 0.32724}, "CVE-2025-55420": {"epss_score": 0.00126, "epss_percentile": 0.32724}, "CVE-2025-55422": {"epss_score": 0.00103, "epss_percentile": 0.28918}, "CVE-2025-55443": {"epss_score": 0.00035, "epss_percentile": 0.09856}, "CVE-2025-55444": {"epss_score": 0.0044, "epss_percentile": 0.62639}, "CVE-2025-55454": {"epss_score": 0.00133, "epss_percentile": 0.33727}, "CVE-2025-55455": {"epss_score": 0.0005, "epss_percentile": 0.15705}, "CVE-2025-55469": {"epss_score": 0.00071, "epss_percentile": 0.22034}, "CVE-2025-55471": {"epss_score": 0.00054, "epss_percentile": 0.17169}, "CVE-2025-55472": {"epss_score": 0.00046, "epss_percentile": 0.14335}, "CVE-2025-55473": {"epss_score": 0.00052, "epss_percentile": 0.1667}, "CVE-2025-55474": {"epss_score": 0.00067, "epss_percentile": 0.21153}, "CVE-2025-55476": {"epss_score": 0.00042, "epss_percentile": 0.12738}, "CVE-2025-55482": {"epss_score": 0.00099, "epss_percentile": 0.28371}, "CVE-2025-55483": {"epss_score": 0.00099, "epss_percentile": 0.28371}, "CVE-2025-55495": {"epss_score": 0.00064, "epss_percentile": 0.20387}, "CVE-2025-55498": {"epss_score": 0.00099, "epss_percentile": 0.28371}, "CVE-2025-55499": {"epss_score": 0.00072, "epss_percentile": 0.224}, "CVE-2025-55503": {"epss_score": 0.00092, "epss_percentile": 0.26511}, "CVE-2025-55521": {"epss_score": 0.00134, "epss_percentile": 0.33826}, "CVE-2025-55522": {"epss_score": 0.00086, "epss_percentile": 0.25245}, "CVE-2025-55523": {"epss_score": 0.00789, "epss_percentile": 0.73356}, "CVE-2025-55524": {"epss_score": 0.00071, "epss_percentile": 0.22211}, "CVE-2025-55526": {"epss_score": 0.0091, "epss_percentile": 0.75318}, "CVE-2025-55551": {"epss_score": 0.00055, "epss_percentile": 0.176}, "CVE-2025-55552": {"epss_score": 0.00056, "epss_percentile": 0.17677}, "CVE-2025-55553": {"epss_score": 0.00052, "epss_percentile": 0.16608}, "CVE-2025-55554": {"epss_score": 0.00054, "epss_percentile": 0.17252}, "CVE-2025-55556": {"epss_score": 0.00026, "epss_percentile": 0.06582}, "CVE-2025-55557": {"epss_score": 0.00052, "epss_percentile": 0.16608}, "CVE-2025-55558": {"epss_score": 0.00052, "epss_percentile": 0.16608}, "CVE-2025-55559": {"epss_score": 0.00031, "epss_percentile": 0.08574}, "CVE-2025-55560": {"epss_score": 0.00052, "epss_percentile": 0.16608}, "CVE-2025-55564": {"epss_score": 0.00099, "epss_percentile": 0.28371}, "CVE-2025-55573": {"epss_score": 0.00103, "epss_percentile": 0.28918}, "CVE-2025-55574": {"epss_score": 0.00066, "epss_percentile": 0.20872}, "CVE-2025-55575": {"epss_score": 0.00257, "epss_percentile": 0.48909}, "CVE-2025-55579": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-55580": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-55581": {"epss_score": 0.00019, "epss_percentile": 0.04331}, "CVE-2025-55582": {"epss_score": 0.00015, "epss_percentile": 0.02163}, "CVE-2025-55583": {"epss_score": 0.01432, "epss_percentile": 0.80247}, "CVE-2025-55584": {"epss_score": 0.00238, "epss_percentile": 0.46758}, "CVE-2025-55585": {"epss_score": 0.00203, "epss_percentile": 0.42514}, "CVE-2025-55586": {"epss_score": 0.00468, "epss_percentile": 0.63877}, "CVE-2025-55587": {"epss_score": 0.00468, "epss_percentile": 0.63877}, "CVE-2025-55588": {"epss_score": 0.00468, "epss_percentile": 0.63877}, "CVE-2025-55589": {"epss_score": 0.08628, "epss_percentile": 0.92161}, "CVE-2025-55590": {"epss_score": 0.08628, "epss_percentile": 0.92161}, "CVE-2025-55591": {"epss_score": 0.09758, "epss_percentile": 0.92693}, "CVE-2025-55599": {"epss_score": 0.00247, "epss_percentile": 0.47845}, "CVE-2025-55602": {"epss_score": 0.00182, "epss_percentile": 0.40185}, "CVE-2025-55603": {"epss_score": 0.00106, "epss_percentile": 0.29486}, "CVE-2025-55605": {"epss_score": 0.00106, "epss_percentile": 0.29486}, "CVE-2025-55606": {"epss_score": 0.00106, "epss_percentile": 0.29486}, "CVE-2025-55611": {"epss_score": 0.00247, "epss_percentile": 0.47845}, "CVE-2025-55613": {"epss_score": 0.00106, "epss_percentile": 0.29486}, "CVE-2025-55618": {"epss_score": 0.0008, "epss_percentile": 0.24124}, "CVE-2025-55619": {"epss_score": 0.00108, "epss_percentile": 0.29801}, "CVE-2025-55620": {"epss_score": 0.00068, "epss_percentile": 0.21301}, "CVE-2025-55621": {"epss_score": 0.00062, "epss_percentile": 0.1977}, "CVE-2025-55622": {"epss_score": 0.00092, "epss_percentile": 0.26511}, "CVE-2025-55623": {"epss_score": 0.00082, "epss_percentile": 0.24475}, "CVE-2025-55624": {"epss_score": 0.00066, "epss_percentile": 0.20808}, "CVE-2025-55625": {"epss_score": 0.00076, "epss_percentile": 0.23153}, "CVE-2025-55626": {"epss_score": 0.00051, "epss_percentile": 0.16308}, "CVE-2025-55627": {"epss_score": 0.00051, "epss_percentile": 0.16308}, "CVE-2025-55629": {"epss_score": 0.00051, "epss_percentile": 0.16327}, "CVE-2025-55630": {"epss_score": 0.00089, "epss_percentile": 0.25938}, "CVE-2025-55631": {"epss_score": 0.00044, "epss_percentile": 0.13584}, "CVE-2025-55634": {"epss_score": 0.00164, "epss_percentile": 0.37967}, "CVE-2025-55637": {"epss_score": 0.00821, "epss_percentile": 0.73904}, "CVE-2025-55668": {"epss_score": 0.00018, "epss_percentile": 0.03752}, "CVE-2025-55669": {"epss_score": 0.00274, "epss_percentile": 0.50514}, "CVE-2025-55670": {"epss_score": 0.00112, "epss_percentile": 0.30563}, "CVE-2025-55671": {"epss_score": 0.0003, "epss_percentile": 0.08295}, "CVE-2025-55672": {"epss_score": 0.00062, "epss_percentile": 0.1971}, "CVE-2025-55673": {"epss_score": 0.00142, "epss_percentile": 0.35013}, "CVE-2025-55674": {"epss_score": 0.00091, "epss_percentile": 0.26402}, "CVE-2025-55675": {"epss_score": 0.00058, "epss_percentile": 0.18601}, "CVE-2025-55676": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-55677": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-55678": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-55679": {"epss_score": 0.00143, "epss_percentile": 0.35109}, "CVE-2025-55680": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-55681": {"epss_score": 0.00081, "epss_percentile": 0.24329}, "CVE-2025-55682": {"epss_score": 0.00072, "epss_percentile": 0.22261}, "CVE-2025-55683": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-55684": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-55685": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-55686": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-55687": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-55688": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-55689": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-55690": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-55691": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-55692": {"epss_score": 0.00135, "epss_percentile": 0.33965}, "CVE-2025-55693": {"epss_score": 0.00081, "epss_percentile": 0.24329}, "CVE-2025-55694": {"epss_score": 0.00081, "epss_percentile": 0.24368}, "CVE-2025-55695": {"epss_score": 0.00054, "epss_percentile": 0.17081}, "CVE-2025-55696": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-55697": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-55698": {"epss_score": 0.00195, "epss_percentile": 0.41675}, "CVE-2025-55699": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-55700": {"epss_score": 0.00071, "epss_percentile": 0.22016}, "CVE-2025-55701": {"epss_score": 0.001, "epss_percentile": 0.28504}, "CVE-2025-55703": {"epss_score": 0.00015, "epss_percentile": 0.02391}, "CVE-2025-55706": {"epss_score": 0.00055, "epss_percentile": 0.17596}, "CVE-2025-55707": {"epss_score": 0.00047, "epss_percentile": 0.14879}, "CVE-2025-55708": {"epss_score": 0.00057, "epss_percentile": 0.18148}, "CVE-2025-55709": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-55710": {"epss_score": 0.0005, "epss_percentile": 0.15705}, "CVE-2025-55711": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-55712": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-55713": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-55714": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-55715": {"epss_score": 0.00056, "epss_percentile": 0.17887}, "CVE-2025-55716": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-55727": {"epss_score": 0.11042, "epss_percentile": 0.93198}, "CVE-2025-55728": {"epss_score": 0.11672, "epss_percentile": 0.93442}, "CVE-2025-55729": {"epss_score": 0.00421, "epss_percentile": 0.61487}, "CVE-2025-55730": {"epss_score": 0.00421, "epss_percentile": 0.61487}, "CVE-2025-55731": {"epss_score": 0.0005, "epss_percentile": 0.1576}, "CVE-2025-55732": {"epss_score": 0.00054, "epss_percentile": 0.17343}, "CVE-2025-55733": {"epss_score": 0.00337, "epss_percentile": 0.56062}, "CVE-2025-55734": {"epss_score": 0.00057, "epss_percentile": 0.18169}, "CVE-2025-55735": {"epss_score": 0.00068, "epss_percentile": 0.21345}, "CVE-2025-55736": {"epss_score": 0.00087, "epss_percentile": 0.25592}, "CVE-2025-55737": {"epss_score": 0.00094, "epss_percentile": 0.26786}, "CVE-2025-55739": {"epss_score": 0.00145, "epss_percentile": 0.35453}, "CVE-2025-55740": {"epss_score": 0.00049, "epss_percentile": 0.15332}, "CVE-2025-55741": {"epss_score": 0.0007, "epss_percentile": 0.21879}, "CVE-2025-55742": {"epss_score": 0.00055, "epss_percentile": 0.17587}, "CVE-2025-55743": {"epss_score": 0.00079, "epss_percentile": 0.23947}, "CVE-2025-55744": {"epss_score": 0.00035, "epss_percentile": 0.10141}, "CVE-2025-55745": {"epss_score": 0.00294, "epss_percentile": 0.52432}, "CVE-2025-55746": {"epss_score": 0.00075, "epss_percentile": 0.23019}, "CVE-2025-55747": {"epss_score": 0.04231, "epss_percentile": 0.88423}, "CVE-2025-55748": {"epss_score": 0.01252, "epss_percentile": 0.78901}, "CVE-2025-55749": {"epss_score": 0.01104, "epss_percentile": 0.77596}, "CVE-2025-55750": {"epss_score": 0.00053, "epss_percentile": 0.16939}, "CVE-2025-55751": {"epss_score": 0.00079, "epss_percentile": 0.23939}, "CVE-2025-55752": {"epss_score": 0.00209, "epss_percentile": 0.43376}, "CVE-2025-55753": {"epss_score": 0.00095, "epss_percentile": 0.27192}, "CVE-2025-55754": {"epss_score": 0.00076, "epss_percentile": 0.23222}, "CVE-2025-55757": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-55758": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2025-55763": {"epss_score": 0.03612, "epss_percentile": 0.87427}, "CVE-2025-55780": {"epss_score": 0.00053, "epss_percentile": 0.16727}, "CVE-2025-55795": {"epss_score": 0.0004, "epss_percentile": 0.12175}, "CVE-2025-55796": {"epss_score": 0.00131, "epss_percentile": 0.33447}, "CVE-2025-55797": {"epss_score": 0.00069, "epss_percentile": 0.21495}, "CVE-2025-55810": {"epss_score": 0.00022, "epss_percentile": 0.05196}, "CVE-2025-55816": {"epss_score": 0.0003, "epss_percentile": 0.08079}, "CVE-2025-55824": {"epss_score": 0.00068, "epss_percentile": 0.21301}, "CVE-2025-55834": {"epss_score": 0.00069, "epss_percentile": 0.2155}, "CVE-2025-55835": {"epss_score": 0.00489, "epss_percentile": 0.64914}, "CVE-2025-55847": {"epss_score": 0.00026, "epss_percentile": 0.0643}, "CVE-2025-55848": {"epss_score": 0.00062, "epss_percentile": 0.19787}, "CVE-2025-55849": {"epss_score": 0.00032, "epss_percentile": 0.08782}, "CVE-2025-55852": {"epss_score": 0.00099, "epss_percentile": 0.28371}, "CVE-2025-55885": {"epss_score": 0.00124, "epss_percentile": 0.32437}, "CVE-2025-55886": {"epss_score": 0.00059, "epss_percentile": 0.18862}, "CVE-2025-55887": {"epss_score": 0.00053, "epss_percentile": 0.1699}, "CVE-2025-55888": {"epss_score": 0.00124, "epss_percentile": 0.32458}, "CVE-2025-55893": {"epss_score": 0.00586, "epss_percentile": 0.68441}, "CVE-2025-55895": {"epss_score": 0.00084, "epss_percentile": 0.2488}, "CVE-2025-55901": {"epss_score": 0.00586, "epss_percentile": 0.68441}, "CVE-2025-55903": {"epss_score": 0.00062, "epss_percentile": 0.19607}, "CVE-2025-55904": {"epss_score": 0.00033, "epss_percentile": 0.09385}, "CVE-2025-55910": {"epss_score": 0.00066, "epss_percentile": 0.20755}, "CVE-2025-55911": {"epss_score": 0.02033, "epss_percentile": 0.83344}, "CVE-2025-55912": {"epss_score": 0.05211, "epss_percentile": 0.89615}, "CVE-2025-55944": {"epss_score": 0.00145, "epss_percentile": 0.35373}, "CVE-2025-55948": {"epss_score": 0.00049, "epss_percentile": 0.15347}, "CVE-2025-55971": {"epss_score": 0.00068, "epss_percentile": 0.21271}, "CVE-2025-55972": {"epss_score": 0.00076, "epss_percentile": 0.23246}, "CVE-2025-55976": {"epss_score": 0.00038, "epss_percentile": 0.11107}, "CVE-2025-55996": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-55998": {"epss_score": 0.00078, "epss_percentile": 0.23596}, "CVE-2025-56007": {"epss_score": 0.00052, "epss_percentile": 0.16514}, "CVE-2025-56008": {"epss_score": 0.00042, "epss_percentile": 0.12743}, "CVE-2025-56009": {"epss_score": 0.00022, "epss_percentile": 0.05239}, "CVE-2025-56018": {"epss_score": 0.00059, "epss_percentile": 0.18754}, "CVE-2025-56019": {"epss_score": 0.00099, "epss_percentile": 0.28312}, "CVE-2025-56074": {"epss_score": 0.00151, "epss_percentile": 0.36263}, "CVE-2025-56075": {"epss_score": 0.00046, "epss_percentile": 0.14395}, "CVE-2025-56077": {"epss_score": 0.00853, "epss_percentile": 0.74446}, "CVE-2025-56079": {"epss_score": 0.00853, "epss_percentile": 0.74446}, "CVE-2025-56082": {"epss_score": 0.0038, "epss_percentile": 0.58967}, "CVE-2025-56083": {"epss_score": 0.0038, "epss_percentile": 0.58967}, "CVE-2025-56084": {"epss_score": 0.0038, "epss_percentile": 0.58967}, "CVE-2025-56085": {"epss_score": 0.00853, "epss_percentile": 0.74446}, "CVE-2025-56086": {"epss_score": 0.00853, "epss_percentile": 0.74446}, "CVE-2025-56087": {"epss_score": 0.0038, "epss_percentile": 0.58967}, "CVE-2025-56088": {"epss_score": 0.0038, "epss_percentile": 0.58967}, "CVE-2025-56089": {"epss_score": 0.0038, "epss_percentile": 0.58967}, "CVE-2025-56090": {"epss_score": 0.0038, "epss_percentile": 0.58967}, "CVE-2025-56091": {"epss_score": 0.0038, "epss_percentile": 0.58967}, "CVE-2025-56092": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56093": {"epss_score": 0.00309, "epss_percentile": 0.53679}, "CVE-2025-56094": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56095": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56096": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56097": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56098": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56099": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56101": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56102": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56106": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56107": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56108": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56109": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56110": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56111": {"epss_score": 0.01346, "epss_percentile": 0.7963}, "CVE-2025-56113": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56114": {"epss_score": 0.00853, "epss_percentile": 0.74446}, "CVE-2025-56117": {"epss_score": 0.01346, "epss_percentile": 0.7963}, "CVE-2025-56118": {"epss_score": 0.00853, "epss_percentile": 0.74446}, "CVE-2025-56120": {"epss_score": 0.00853, "epss_percentile": 0.74446}, "CVE-2025-56122": {"epss_score": 0.00853, "epss_percentile": 0.74446}, "CVE-2025-56123": {"epss_score": 0.00295, "epss_percentile": 0.5249}, "CVE-2025-56124": {"epss_score": 0.00144, "epss_percentile": 0.35253}, "CVE-2025-56127": {"epss_score": 0.01346, "epss_percentile": 0.7963}, "CVE-2025-56129": {"epss_score": 0.01129, "epss_percentile": 0.77841}, "CVE-2025-56130": {"epss_score": 0.00847, "epss_percentile": 0.74352}, "CVE-2025-56132": {"epss_score": 0.00152, "epss_percentile": 0.36433}, "CVE-2025-56139": {"epss_score": 0.00065, "epss_percentile": 0.20436}, "CVE-2025-56146": {"epss_score": 0.00024, "epss_percentile": 0.0586}, "CVE-2025-56154": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-56157": {"epss_score": 0.00051, "epss_percentile": 0.16291}, "CVE-2025-56161": {"epss_score": 0.00059, "epss_percentile": 0.18819}, "CVE-2025-56162": {"epss_score": 0.00105, "epss_percentile": 0.29287}, "CVE-2025-56200": {"epss_score": 0.00053, "epss_percentile": 0.1699}, "CVE-2025-56207": {"epss_score": 0.00057, "epss_percentile": 0.18072}, "CVE-2025-56212": {"epss_score": 0.00059, "epss_percentile": 0.18824}, "CVE-2025-56214": {"epss_score": 0.00059, "epss_percentile": 0.18824}, "CVE-2025-56215": {"epss_score": 0.00057, "epss_percentile": 0.18191}, "CVE-2025-56216": {"epss_score": 0.00057, "epss_percentile": 0.18148}, "CVE-2025-56218": {"epss_score": 0.00094, "epss_percentile": 0.27045}, "CVE-2025-56219": {"epss_score": 0.00053, "epss_percentile": 0.16892}, "CVE-2025-56221": {"epss_score": 0.00106, "epss_percentile": 0.29407}, "CVE-2025-56223": {"epss_score": 0.00058, "epss_percentile": 0.18505}, "CVE-2025-56224": {"epss_score": 0.00061, "epss_percentile": 0.19288}, "CVE-2025-56230": {"epss_score": 0.00026, "epss_percentile": 0.06481}, "CVE-2025-56231": {"epss_score": 0.00031, "epss_percentile": 0.08664}, "CVE-2025-56232": {"epss_score": 9e-05, "epss_percentile": 0.0065}, "CVE-2025-56233": {"epss_score": 0.00059, "epss_percentile": 0.18927}, "CVE-2025-56234": {"epss_score": 0.0006, "epss_percentile": 0.19004}, "CVE-2025-56236": {"epss_score": 0.00063, "epss_percentile": 0.19985}, "CVE-2025-56241": {"epss_score": 0.00155, "epss_percentile": 0.3685}, "CVE-2025-56243": {"epss_score": 0.00059, "epss_percentile": 0.18754}, "CVE-2025-56252": {"epss_score": 0.00049, "epss_percentile": 0.1559}, "CVE-2025-56254": {"epss_score": 0.00046, "epss_percentile": 0.1415}, "CVE-2025-56263": {"epss_score": 0.00059, "epss_percentile": 0.1874}, "CVE-2025-56264": {"epss_score": 0.00077, "epss_percentile": 0.23324}, "CVE-2025-56265": {"epss_score": 0.00115, "epss_percentile": 0.30977}, "CVE-2025-56266": {"epss_score": 0.11067, "epss_percentile": 0.93208}, "CVE-2025-56267": {"epss_score": 0.0014, "epss_percentile": 0.3471}, "CVE-2025-56274": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-56276": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-56280": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-56289": {"epss_score": 0.00036, "epss_percentile": 0.10604}, "CVE-2025-56293": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-56295": {"epss_score": 0.00034, "epss_percentile": 0.09657}, "CVE-2025-56301": {"epss_score": 0.00125, "epss_percentile": 0.32502}, "CVE-2025-56304": {"epss_score": 0.00053, "epss_percentile": 0.16717}, "CVE-2025-56311": {"epss_score": 0.0002, "epss_percentile": 0.0467}, "CVE-2025-56313": {"epss_score": 0.00064, "epss_percentile": 0.20144}, "CVE-2025-56316": {"epss_score": 0.00138, "epss_percentile": 0.34388}, "CVE-2025-56320": {"epss_score": 0.00063, "epss_percentile": 0.19833}, "CVE-2025-56332": {"epss_score": 0.00074, "epss_percentile": 0.22872}, "CVE-2025-56333": {"epss_score": 0.00158, "epss_percentile": 0.37152}, "CVE-2025-56379": {"epss_score": 0.00041, "epss_percentile": 0.12396}, "CVE-2025-56380": {"epss_score": 0.00037, "epss_percentile": 0.1094}, "CVE-2025-56381": {"epss_score": 0.00037, "epss_percentile": 0.1094}, "CVE-2025-56382": {"epss_score": 0.00049, "epss_percentile": 0.1559}, "CVE-2025-56383": {"epss_score": 0.00018, "epss_percentile": 0.03795}, "CVE-2025-56385": {"epss_score": 0.00143, "epss_percentile": 0.35187}, "CVE-2025-56392": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-56394": {"epss_score": 0.00071, "epss_percentile": 0.22178}, "CVE-2025-56396": {"epss_score": 0.00049, "epss_percentile": 0.15609}, "CVE-2025-56399": {"epss_score": 0.00389, "epss_percentile": 0.59467}, "CVE-2025-56400": {"epss_score": 0.00022, "epss_percentile": 0.0515}, "CVE-2025-56401": {"epss_score": 0.00038, "epss_percentile": 0.11281}, "CVE-2025-56404": {"epss_score": 0.00082, "epss_percentile": 0.24412}, "CVE-2025-56405": {"epss_score": 0.00056, "epss_percentile": 0.17926}, "CVE-2025-56406": {"epss_score": 0.00165, "epss_percentile": 0.38043}, "CVE-2025-56407": {"epss_score": 0.00042, "epss_percentile": 0.12826}, "CVE-2025-56413": {"epss_score": 0.00287, "epss_percentile": 0.51859}, "CVE-2025-56423": {"epss_score": 0.00056, "epss_percentile": 0.17736}, "CVE-2025-56426": {"epss_score": 0.00138, "epss_percentile": 0.34377}, "CVE-2025-56427": {"epss_score": 0.01215, "epss_percentile": 0.78589}, "CVE-2025-56429": {"epss_score": 0.00038, "epss_percentile": 0.11125}, "CVE-2025-56430": {"epss_score": 0.00382, "epss_percentile": 0.5906}, "CVE-2025-56431": {"epss_score": 0.00382, "epss_percentile": 0.5906}, "CVE-2025-56432": {"epss_score": 0.00674, "epss_percentile": 0.70853}, "CVE-2025-56435": {"epss_score": 0.00164, "epss_percentile": 0.38005}, "CVE-2025-56438": {"epss_score": 0.00013, "epss_percentile": 0.01458}, "CVE-2025-56447": {"epss_score": 0.00059, "epss_percentile": 0.18802}, "CVE-2025-56448": {"epss_score": 0.00034, "epss_percentile": 0.09796}, "CVE-2025-56449": {"epss_score": 0.00091, "epss_percentile": 0.26384}, "CVE-2025-56450": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-56463": {"epss_score": 0.0002, "epss_percentile": 0.04634}, "CVE-2025-56466": {"epss_score": 0.00047, "epss_percentile": 0.14844}, "CVE-2025-56467": {"epss_score": 0.00043, "epss_percentile": 0.13263}, "CVE-2025-56498": {"epss_score": 0.02952, "epss_percentile": 0.86054}, "CVE-2025-56499": {"epss_score": 0.00036, "epss_percentile": 0.105}, "CVE-2025-56503": {"epss_score": 0.00028, "epss_percentile": 0.07438}, "CVE-2025-56513": {"epss_score": 0.00259, "epss_percentile": 0.49082}, "CVE-2025-56514": {"epss_score": 0.00017, "epss_percentile": 0.03401}, "CVE-2025-56515": {"epss_score": 0.00032, "epss_percentile": 0.09116}, "CVE-2025-56520": {"epss_score": 0.0005, "epss_percentile": 0.15878}, "CVE-2025-56526": {"epss_score": 0.00055, "epss_percentile": 0.17378}, "CVE-2025-56527": {"epss_score": 0.00061, "epss_percentile": 0.1955}, "CVE-2025-56551": {"epss_score": 0.00054, "epss_percentile": 0.17214}, "CVE-2025-56556": {"epss_score": 0.00041, "epss_percentile": 0.12418}, "CVE-2025-56557": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-56558": {"epss_score": 0.001, "epss_percentile": 0.2856}, "CVE-2025-56562": {"epss_score": 0.00066, "epss_percentile": 0.20808}, "CVE-2025-56571": {"epss_score": 0.00064, "epss_percentile": 0.20302}, "CVE-2025-56572": {"epss_score": 0.00225, "epss_percentile": 0.4522}, "CVE-2025-56577": {"epss_score": 0.00024, "epss_percentile": 0.05987}, "CVE-2025-56578": {"epss_score": 0.00084, "epss_percentile": 0.24967}, "CVE-2025-56588": {"epss_score": 0.00222, "epss_percentile": 0.44742}, "CVE-2025-56608": {"epss_score": 0.00061, "epss_percentile": 0.1953}, "CVE-2025-56630": {"epss_score": 0.00051, "epss_percentile": 0.16279}, "CVE-2025-56643": {"epss_score": 0.00054, "epss_percentile": 0.17313}, "CVE-2025-56648": {"epss_score": 0.00024, "epss_percentile": 0.0598}, "CVE-2025-56675": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-56676": {"epss_score": 0.00154, "epss_percentile": 0.36678}, "CVE-2025-56683": {"epss_score": 0.00063, "epss_percentile": 0.19833}, "CVE-2025-56689": {"epss_score": 0.00063, "epss_percentile": 0.20058}, "CVE-2025-56694": {"epss_score": 0.00074, "epss_percentile": 0.22762}, "CVE-2025-56697": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-56699": {"epss_score": 0.0008, "epss_percentile": 0.24052}, "CVE-2025-56700": {"epss_score": 0.00034, "epss_percentile": 0.0976}, "CVE-2025-56704": {"epss_score": 0.00073, "epss_percentile": 0.22654}, "CVE-2025-56706": {"epss_score": 0.0022, "epss_percentile": 0.44553}, "CVE-2025-56710": {"epss_score": 0.00013, "epss_percentile": 0.01476}, "CVE-2025-56746": {"epss_score": 0.0002, "epss_percentile": 0.04581}, "CVE-2025-56747": {"epss_score": 0.0006, "epss_percentile": 0.18935}, "CVE-2025-56748": {"epss_score": 0.00075, "epss_percentile": 0.23023}, "CVE-2025-56749": {"epss_score": 0.00154, "epss_percentile": 0.36664}, "CVE-2025-56752": {"epss_score": 0.00263, "epss_percentile": 0.49515}, "CVE-2025-56760": {"epss_score": 0.00086, "epss_percentile": 0.25246}, "CVE-2025-56761": {"epss_score": 0.0007, "epss_percentile": 0.21764}, "CVE-2025-56762": {"epss_score": 0.00016, "epss_percentile": 0.02947}, "CVE-2025-56764": {"epss_score": 0.00043, "epss_percentile": 0.1331}, "CVE-2025-56769": {"epss_score": 0.00139, "epss_percentile": 0.34629}, "CVE-2025-56795": {"epss_score": 0.00049, "epss_percentile": 0.15481}, "CVE-2025-56799": {"epss_score": 0.08927, "epss_percentile": 0.92324}, "CVE-2025-56800": {"epss_score": 0.00043, "epss_percentile": 0.13234}, "CVE-2025-56801": {"epss_score": 0.00023, "epss_percentile": 0.05483}, "CVE-2025-56802": {"epss_score": 0.00023, "epss_percentile": 0.05483}, "CVE-2025-56803": {"epss_score": 0.00176, "epss_percentile": 0.39435}, "CVE-2025-56807": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-56815": {"epss_score": 0.00255, "epss_percentile": 0.48652}, "CVE-2025-56816": {"epss_score": 0.01669, "epss_percentile": 0.81665}, "CVE-2025-56819": {"epss_score": 0.1996, "epss_percentile": 0.95266}, "CVE-2025-56869": {"epss_score": 0.00158, "epss_percentile": 0.37295}, "CVE-2025-57052": {"epss_score": 0.00174, "epss_percentile": 0.39214}, "CVE-2025-57055": {"epss_score": 0.00053, "epss_percentile": 0.16706}, "CVE-2025-57057": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57058": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57059": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57060": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57061": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57062": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57063": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57064": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57069": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57070": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57071": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57072": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57078": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57085": {"epss_score": 0.00076, "epss_percentile": 0.23179}, "CVE-2025-57086": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57087": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-57104": {"epss_score": 0.00032, "epss_percentile": 0.08733}, "CVE-2025-57105": {"epss_score": 0.00216, "epss_percentile": 0.44159}, "CVE-2025-57106": {"epss_score": 0.00071, "epss_percentile": 0.22178}, "CVE-2025-57107": {"epss_score": 0.00021, "epss_percentile": 0.0485}, "CVE-2025-57108": {"epss_score": 0.00076, "epss_percentile": 0.23238}, "CVE-2025-57109": {"epss_score": 0.00055, "epss_percentile": 0.1764}, "CVE-2025-57117": {"epss_score": 0.00069, "epss_percentile": 0.21431}, "CVE-2025-57118": {"epss_score": 0.0008, "epss_percentile": 0.24024}, "CVE-2025-57119": {"epss_score": 0.00084, "epss_percentile": 0.24914}, "CVE-2025-57130": {"epss_score": 0.00103, "epss_percentile": 0.29033}, "CVE-2025-57140": {"epss_score": 0.00059, "epss_percentile": 0.18868}, "CVE-2025-57141": {"epss_score": 0.00754, "epss_percentile": 0.72699}, "CVE-2025-57145": {"epss_score": 0.00039, "epss_percentile": 0.11576}, "CVE-2025-57146": {"epss_score": 0.00051, "epss_percentile": 0.16191}, "CVE-2025-57147": {"epss_score": 0.00052, "epss_percentile": 0.16596}, "CVE-2025-57148": {"epss_score": 0.00097, "epss_percentile": 0.27562}, "CVE-2025-57149": {"epss_score": 0.00047, "epss_percentile": 0.14703}, "CVE-2025-57150": {"epss_score": 0.00109, "epss_percentile": 0.29906}, "CVE-2025-57151": {"epss_score": 0.00092, "epss_percentile": 0.26415}, "CVE-2025-57164": {"epss_score": 0.00161, "epss_percentile": 0.37606}, "CVE-2025-57174": {"epss_score": 0.00104, "epss_percentile": 0.29183}, "CVE-2025-57176": {"epss_score": 0.00037, "epss_percentile": 0.10722}, "CVE-2025-57197": {"epss_score": 0.0003, "epss_percentile": 0.0808}, "CVE-2025-57198": {"epss_score": 0.00808, "epss_percentile": 0.73699}, "CVE-2025-57199": {"epss_score": 0.00808, "epss_percentile": 0.73699}, "CVE-2025-57200": {"epss_score": 0.04498, "epss_percentile": 0.88763}, "CVE-2025-57201": {"epss_score": 0.00948, "epss_percentile": 0.75834}, "CVE-2025-57202": {"epss_score": 0.00032, "epss_percentile": 0.08982}, "CVE-2025-57203": {"epss_score": 0.00045, "epss_percentile": 0.13953}, "CVE-2025-57204": {"epss_score": 0.00048, "epss_percentile": 0.15121}, "CVE-2025-57205": {"epss_score": 0.00048, "epss_percentile": 0.15121}, "CVE-2025-57210": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-57212": {"epss_score": 0.00043, "epss_percentile": 0.13265}, "CVE-2025-57213": {"epss_score": 0.00043, "epss_percentile": 0.13265}, "CVE-2025-57215": {"epss_score": 0.00077, "epss_percentile": 0.2346}, "CVE-2025-57217": {"epss_score": 0.00075, "epss_percentile": 0.23019}, "CVE-2025-57218": {"epss_score": 0.00097, "epss_percentile": 0.27457}, "CVE-2025-57219": {"epss_score": 0.00066, "epss_percentile": 0.2077}, "CVE-2025-57220": {"epss_score": 0.00074, "epss_percentile": 0.22846}, "CVE-2025-57227": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-57240": {"epss_score": 0.00049, "epss_percentile": 0.1559}, "CVE-2025-57244": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-57247": {"epss_score": 0.00058, "epss_percentile": 0.18419}, "CVE-2025-57248": {"epss_score": 0.00069, "epss_percentile": 0.21507}, "CVE-2025-57254": {"epss_score": 0.00076, "epss_percentile": 0.23267}, "CVE-2025-57263": {"epss_score": 0.00058, "epss_percentile": 0.18573}, "CVE-2025-57266": {"epss_score": 0.00147, "epss_percentile": 0.35666}, "CVE-2025-57275": {"epss_score": 0.00055, "epss_percentile": 0.17434}, "CVE-2025-57278": {"epss_score": 0.00084, "epss_percentile": 0.2498}, "CVE-2025-57285": {"epss_score": 0.01273, "epss_percentile": 0.79086}, "CVE-2025-57292": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-57293": {"epss_score": 0.00126, "epss_percentile": 0.32736}, "CVE-2025-57295": {"epss_score": 0.00071, "epss_percentile": 0.22161}, "CVE-2025-57296": {"epss_score": 0.03706, "epss_percentile": 0.87598}, "CVE-2025-57305": {"epss_score": 0.00073, "epss_percentile": 0.22565}, "CVE-2025-57310": {"epss_score": 0.00033, "epss_percentile": 0.09154}, "CVE-2025-57317": {"epss_score": 0.00059, "epss_percentile": 0.18927}, "CVE-2025-57318": {"epss_score": 0.00061, "epss_percentile": 0.19384}, "CVE-2025-57319": {"epss_score": 0.00056, "epss_percentile": 0.1788}, "CVE-2025-57320": {"epss_score": 0.00057, "epss_percentile": 0.17996}, "CVE-2025-57321": {"epss_score": 0.00061, "epss_percentile": 0.19435}, "CVE-2025-57323": {"epss_score": 0.00061, "epss_percentile": 0.19384}, "CVE-2025-57324": {"epss_score": 0.00071, "epss_percentile": 0.22163}, "CVE-2025-57325": {"epss_score": 0.00061, "epss_percentile": 0.19384}, "CVE-2025-57326": {"epss_score": 0.00061, "epss_percentile": 0.19384}, "CVE-2025-57327": {"epss_score": 0.00061, "epss_percentile": 0.19384}, "CVE-2025-57328": {"epss_score": 0.00061, "epss_percentile": 0.19384}, "CVE-2025-57329": {"epss_score": 0.00061, "epss_percentile": 0.19384}, "CVE-2025-57330": {"epss_score": 0.00061, "epss_percentile": 0.19384}, "CVE-2025-57347": {"epss_score": 0.00093, "epss_percentile": 0.26637}, "CVE-2025-57348": {"epss_score": 0.00092, "epss_percentile": 0.26568}, "CVE-2025-57349": {"epss_score": 0.00185, "epss_percentile": 0.40547}, "CVE-2025-57350": {"epss_score": 0.00111, "epss_percentile": 0.30306}, "CVE-2025-57351": {"epss_score": 0.00097, "epss_percentile": 0.27602}, "CVE-2025-57352": {"epss_score": 0.00068, "epss_percentile": 0.2138}, "CVE-2025-57353": {"epss_score": 0.00063, "epss_percentile": 0.2005}, "CVE-2025-57354": {"epss_score": 0.00372, "epss_percentile": 0.58463}, "CVE-2025-57389": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-57392": {"epss_score": 0.00022, "epss_percentile": 0.05017}, "CVE-2025-57393": {"epss_score": 0.00056, "epss_percentile": 0.17882}, "CVE-2025-57396": {"epss_score": 0.00051, "epss_percentile": 0.16192}, "CVE-2025-57403": {"epss_score": 0.00477, "epss_percentile": 0.64341}, "CVE-2025-57407": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-57423": {"epss_score": 0.00077, "epss_percentile": 0.23365}, "CVE-2025-57424": {"epss_score": 0.0004, "epss_percentile": 0.12183}, "CVE-2025-57425": {"epss_score": 0.00068, "epss_percentile": 0.21301}, "CVE-2025-57428": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2025-57430": {"epss_score": 0.00059, "epss_percentile": 0.18819}, "CVE-2025-57431": {"epss_score": 0.00108, "epss_percentile": 0.29773}, "CVE-2025-57432": {"epss_score": 0.00569, "epss_percentile": 0.67927}, "CVE-2025-57433": {"epss_score": 0.00046, "epss_percentile": 0.14136}, "CVE-2025-57434": {"epss_score": 0.00148, "epss_percentile": 0.35903}, "CVE-2025-57437": {"epss_score": 0.00082, "epss_percentile": 0.24489}, "CVE-2025-57438": {"epss_score": 0.00047, "epss_percentile": 0.14874}, "CVE-2025-57439": {"epss_score": 0.00208, "epss_percentile": 0.43303}, "CVE-2025-57440": {"epss_score": 0.00034, "epss_percentile": 0.09661}, "CVE-2025-57441": {"epss_score": 0.00082, "epss_percentile": 0.24489}, "CVE-2025-57443": {"epss_score": 0.00017, "epss_percentile": 0.03328}, "CVE-2025-57444": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-57446": {"epss_score": 0.00157, "epss_percentile": 0.37125}, "CVE-2025-57452": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-57457": {"epss_score": 0.00308, "epss_percentile": 0.53617}, "CVE-2025-57460": {"epss_score": 0.00056, "epss_percentile": 0.17857}, "CVE-2025-57462": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-57483": {"epss_score": 0.00044, "epss_percentile": 0.13623}, "CVE-2025-57489": {"epss_score": 0.00056, "epss_percentile": 0.17848}, "CVE-2025-57515": {"epss_score": 0.00276, "epss_percentile": 0.50711}, "CVE-2025-57516": {"epss_score": 0.03418, "epss_percentile": 0.87095}, "CVE-2025-57520": {"epss_score": 0.00016, "epss_percentile": 0.02905}, "CVE-2025-57521": {"epss_score": 0.00024, "epss_percentile": 0.05861}, "CVE-2025-57528": {"epss_score": 0.00083, "epss_percentile": 0.24718}, "CVE-2025-57538": {"epss_score": 0.00043, "epss_percentile": 0.12965}, "CVE-2025-57539": {"epss_score": 0.00037, "epss_percentile": 0.10996}, "CVE-2025-57540": {"epss_score": 0.00037, "epss_percentile": 0.10996}, "CVE-2025-57563": {"epss_score": 0.00134, "epss_percentile": 0.33801}, "CVE-2025-57564": {"epss_score": 0.00084, "epss_percentile": 0.24961}, "CVE-2025-57567": {"epss_score": 0.00363, "epss_percentile": 0.57835}, "CVE-2025-57569": {"epss_score": 0.00055, "epss_percentile": 0.1764}, "CVE-2025-57570": {"epss_score": 0.00055, "epss_percentile": 0.1764}, "CVE-2025-57571": {"epss_score": 0.00055, "epss_percentile": 0.1764}, "CVE-2025-57572": {"epss_score": 0.00055, "epss_percentile": 0.1764}, "CVE-2025-57573": {"epss_score": 0.00055, "epss_percentile": 0.1764}, "CVE-2025-57576": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-57577": {"epss_score": 0.00192, "epss_percentile": 0.41286}, "CVE-2025-57578": {"epss_score": 0.00164, "epss_percentile": 0.38009}, "CVE-2025-57579": {"epss_score": 0.00442, "epss_percentile": 0.62708}, "CVE-2025-57601": {"epss_score": 0.00091, "epss_percentile": 0.26275}, "CVE-2025-57602": {"epss_score": 0.00329, "epss_percentile": 0.55393}, "CVE-2025-57605": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-57611": {"epss_score": 0.00095, "epss_percentile": 0.27079}, "CVE-2025-57612": {"epss_score": 0.00171, "epss_percentile": 0.38861}, "CVE-2025-57613": {"epss_score": 0.00171, "epss_percentile": 0.38861}, "CVE-2025-57614": {"epss_score": 0.00216, "epss_percentile": 0.44218}, "CVE-2025-57615": {"epss_score": 0.00171, "epss_percentile": 0.38861}, "CVE-2025-57616": {"epss_score": 0.00171, "epss_percentile": 0.3878}, "CVE-2025-57618": {"epss_score": 0.00534, "epss_percentile": 0.6678}, "CVE-2025-57623": {"epss_score": 0.00269, "epss_percentile": 0.50154}, "CVE-2025-57624": {"epss_score": 0.0002, "epss_percentile": 0.04607}, "CVE-2025-57625": {"epss_score": 0.0008, "epss_percentile": 0.24124}, "CVE-2025-57631": {"epss_score": 0.00314, "epss_percentile": 0.54121}, "CVE-2025-57632": {"epss_score": 0.00118, "epss_percentile": 0.31438}, "CVE-2025-57633": {"epss_score": 0.00632, "epss_percentile": 0.69752}, "CVE-2025-57636": {"epss_score": 0.04693, "epss_percentile": 0.89014}, "CVE-2025-57637": {"epss_score": 0.00062, "epss_percentile": 0.1973}, "CVE-2025-57638": {"epss_score": 0.00077, "epss_percentile": 0.23324}, "CVE-2025-57639": {"epss_score": 0.09808, "epss_percentile": 0.9271}, "CVE-2025-57642": {"epss_score": 0.02436, "epss_percentile": 0.84739}, "CVE-2025-57644": {"epss_score": 0.00896, "epss_percentile": 0.75111}, "CVE-2025-57665": {"epss_score": 0.00043, "epss_percentile": 0.13133}, "CVE-2025-57682": {"epss_score": 0.00517, "epss_percentile": 0.66062}, "CVE-2025-57685": {"epss_score": 0.01446, "epss_percentile": 0.80328}, "CVE-2025-57692": {"epss_score": 0.00067, "epss_percentile": 0.21028}, "CVE-2025-57697": {"epss_score": 0.00068, "epss_percentile": 0.2134}, "CVE-2025-57698": {"epss_score": 0.00579, "epss_percentile": 0.68231}, "CVE-2025-57699": {"epss_score": 0.00029, "epss_percentile": 0.07615}, "CVE-2025-57700": {"epss_score": 0.00054, "epss_percentile": 0.17334}, "CVE-2025-57701": {"epss_score": 0.00054, "epss_percentile": 0.17334}, "CVE-2025-57702": {"epss_score": 0.00054, "epss_percentile": 0.17334}, "CVE-2025-57703": {"epss_score": 0.00054, "epss_percentile": 0.17334}, "CVE-2025-57704": {"epss_score": 0.00028, "epss_percentile": 0.07213}, "CVE-2025-57705": {"epss_score": 0.00129, "epss_percentile": 0.33166}, "CVE-2025-57706": {"epss_score": 0.00085, "epss_percentile": 0.25174}, "CVE-2025-57712": {"epss_score": 0.00068, "epss_percentile": 0.21189}, "CVE-2025-57714": {"epss_score": 0.00018, "epss_percentile": 0.04022}, "CVE-2025-57716": {"epss_score": 0.00018, "epss_percentile": 0.03756}, "CVE-2025-57727": {"epss_score": 1e-05, "epss_percentile": 7e-05}, "CVE-2025-57728": {"epss_score": 0.00022, "epss_percentile": 0.05057}, "CVE-2025-57729": {"epss_score": 1e-05, "epss_percentile": 0.00011}, "CVE-2025-57730": {"epss_score": 2e-05, "epss_percentile": 0.00057}, "CVE-2025-57731": {"epss_score": 0.00097, "epss_percentile": 0.27633}, "CVE-2025-57732": {"epss_score": 1e-05, "epss_percentile": 0.00012}, "CVE-2025-57733": {"epss_score": 3e-05, "epss_percentile": 0.00103}, "CVE-2025-57734": {"epss_score": 2e-05, "epss_percentile": 0.0002}, "CVE-2025-57738": {"epss_score": 0.00094, "epss_percentile": 0.27062}, "CVE-2025-57740": {"epss_score": 0.00095, "epss_percentile": 0.271}, "CVE-2025-57741": {"epss_score": 0.00019, "epss_percentile": 0.04211}, "CVE-2025-57749": {"epss_score": 0.00083, "epss_percentile": 0.246}, "CVE-2025-57751": {"epss_score": 0.00082, "epss_percentile": 0.24408}, "CVE-2025-57752": {"epss_score": 0.00026, "epss_percentile": 0.06443}, "CVE-2025-57753": {"epss_score": 0.00144, "epss_percentile": 0.3524}, "CVE-2025-57754": {"epss_score": 0.00096, "epss_percentile": 0.27271}, "CVE-2025-57755": {"epss_score": 0.00079, "epss_percentile": 0.23939}, "CVE-2025-57756": {"epss_score": 0.00054, "epss_percentile": 0.17133}, "CVE-2025-57757": {"epss_score": 0.00052, "epss_percentile": 0.1664}, "CVE-2025-57758": {"epss_score": 0.00048, "epss_percentile": 0.15049}, "CVE-2025-57759": {"epss_score": 0.00039, "epss_percentile": 0.11695}, "CVE-2025-57760": {"epss_score": 0.0002, "epss_percentile": 0.04525}, "CVE-2025-57761": {"epss_score": 0.00055, "epss_percentile": 0.17628}, "CVE-2025-57762": {"epss_score": 0.0007, "epss_percentile": 0.2195}, "CVE-2025-57763": {"epss_score": 0.0007, "epss_percentile": 0.2195}, "CVE-2025-57764": {"epss_score": 0.00079, "epss_percentile": 0.23908}, "CVE-2025-57765": {"epss_score": 0.00079, "epss_percentile": 0.23908}, "CVE-2025-57766": {"epss_score": 0.00065, "epss_percentile": 0.20606}, "CVE-2025-57767": {"epss_score": 0.0012, "epss_percentile": 0.31746}, "CVE-2025-57768": {"epss_score": 0.00091, "epss_percentile": 0.26264}, "CVE-2025-57769": {"epss_score": 0.00051, "epss_percentile": 0.15983}, "CVE-2025-57770": {"epss_score": 0.00087, "epss_percentile": 0.25508}, "CVE-2025-57771": {"epss_score": 0.00139, "epss_percentile": 0.34556}, "CVE-2025-57772": {"epss_score": 0.00163, "epss_percentile": 0.37805}, "CVE-2025-57773": {"epss_score": 0.00219, "epss_percentile": 0.44468}, "CVE-2025-57774": {"epss_score": 0.00058, "epss_percentile": 0.18387}, "CVE-2025-57775": {"epss_score": 0.00058, "epss_percentile": 0.18387}, "CVE-2025-57776": {"epss_score": 0.00058, "epss_percentile": 0.18387}, "CVE-2025-57777": {"epss_score": 0.0003, "epss_percentile": 0.0831}, "CVE-2025-57778": {"epss_score": 0.00058, "epss_percentile": 0.18387}, "CVE-2025-57780": {"epss_score": 0.00034, "epss_percentile": 0.09791}, "CVE-2025-57781": {"epss_score": 0.00018, "epss_percentile": 0.03961}, "CVE-2025-57788": {"epss_score": 0.86096, "epss_percentile": 0.99365}, "CVE-2025-57789": {"epss_score": 0.09833, "epss_percentile": 0.92724}, "CVE-2025-57790": {"epss_score": 0.59782, "epss_percentile": 0.98181}, "CVE-2025-57791": {"epss_score": 0.5048, "epss_percentile": 0.97738}, "CVE-2025-57797": {"epss_score": 0.00022, "epss_percentile": 0.05312}, "CVE-2025-57799": {"epss_score": 0.01291, "epss_percentile": 0.79226}, "CVE-2025-57800": {"epss_score": 0.00171, "epss_percentile": 0.3886}, "CVE-2025-57801": {"epss_score": 0.00033, "epss_percentile": 0.09121}, "CVE-2025-57802": {"epss_score": 0.00109, "epss_percentile": 0.29929}, "CVE-2025-57803": {"epss_score": 0.00087, "epss_percentile": 0.25609}, "CVE-2025-57804": {"epss_score": 0.00107, "epss_percentile": 0.29734}, "CVE-2025-57805": {"epss_score": 0.00164, "epss_percentile": 0.38007}, "CVE-2025-57806": {"epss_score": 6e-05, "epss_percentile": 0.00297}, "CVE-2025-57807": {"epss_score": 0.00061, "epss_percentile": 0.19435}, "CVE-2025-57808": {"epss_score": 0.06043, "epss_percentile": 0.9043}, "CVE-2025-57809": {"epss_score": 0.00092, "epss_percentile": 0.2651}, "CVE-2025-57810": {"epss_score": 0.00269, "epss_percentile": 0.50109}, "CVE-2025-57811": {"epss_score": 0.00527, "epss_percentile": 0.6644}, "CVE-2025-57812": {"epss_score": 0.00042, "epss_percentile": 0.12563}, "CVE-2025-57813": {"epss_score": 0.00068, "epss_percentile": 0.21291}, "CVE-2025-57814": {"epss_score": 0.00079, "epss_percentile": 0.23939}, "CVE-2025-57815": {"epss_score": 0.00077, "epss_percentile": 0.23411}, "CVE-2025-57816": {"epss_score": 0.00135, "epss_percentile": 0.34004}, "CVE-2025-57817": {"epss_score": 0.0007, "epss_percentile": 0.21687}, "CVE-2025-57818": {"epss_score": 0.00069, "epss_percentile": 0.21521}, "CVE-2025-57819": {"epss_score": 0.81282, "epss_percentile": 0.99131}, "CVE-2025-57820": {"epss_score": 0.00088, "epss_percentile": 0.25677}, "CVE-2025-57821": {"epss_score": 0.00051, "epss_percentile": 0.1599}, "CVE-2025-57822": {"epss_score": 0.05353, "epss_percentile": 0.89776}, "CVE-2025-57823": {"epss_score": 0.00028, "epss_percentile": 0.07486}, "CVE-2025-57833": {"epss_score": 0.00014, "epss_percentile": 0.02123}, "CVE-2025-57836": {"epss_score": 0.00011, "epss_percentile": 0.00973}, "CVE-2025-57837": {"epss_score": 0.00018, "epss_percentile": 0.0362}, "CVE-2025-57838": {"epss_score": 0.00018, "epss_percentile": 0.0362}, "CVE-2025-57839": {"epss_score": 0.00018, "epss_percentile": 0.0362}, "CVE-2025-57840": {"epss_score": 0.00012, "epss_percentile": 0.01162}, "CVE-2025-57846": {"epss_score": 0.00019, "epss_percentile": 0.04285}, "CVE-2025-57848": {"epss_score": 5e-05, "epss_percentile": 0.00229}, "CVE-2025-57850": {"epss_score": 6e-05, "epss_percentile": 0.00284}, "CVE-2025-57852": {"epss_score": 7e-05, "epss_percentile": 0.00405}, "CVE-2025-57870": {"epss_score": 0.00179, "epss_percentile": 0.39797}, "CVE-2025-57871": {"epss_score": 0.00045, "epss_percentile": 0.14065}, "CVE-2025-57872": {"epss_score": 0.00044, "epss_percentile": 0.13639}, "CVE-2025-57873": {"epss_score": 0.00045, "epss_percentile": 0.14065}, "CVE-2025-57874": {"epss_score": 0.00045, "epss_percentile": 0.14065}, "CVE-2025-57875": {"epss_score": 0.00045, "epss_percentile": 0.14065}, "CVE-2025-57876": {"epss_score": 0.00045, "epss_percentile": 0.14065}, "CVE-2025-57877": {"epss_score": 0.00045, "epss_percentile": 0.14065}, "CVE-2025-57878": {"epss_score": 0.00044, "epss_percentile": 0.13639}, "CVE-2025-57879": {"epss_score": 0.00044, "epss_percentile": 0.13639}, "CVE-2025-57880": {"epss_score": 0.00041, "epss_percentile": 0.12229}, "CVE-2025-57882": {"epss_score": 0.00061, "epss_percentile": 0.19351}, "CVE-2025-57883": {"epss_score": 0.00034, "epss_percentile": 0.09667}, "CVE-2025-57884": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-57885": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-57886": {"epss_score": 0.00069, "epss_percentile": 0.21463}, "CVE-2025-57887": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-57888": {"epss_score": 0.0005, "epss_percentile": 0.15854}, "CVE-2025-57889": {"epss_score": 0.0022, "epss_percentile": 0.44626}, "CVE-2025-57890": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-57891": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-57892": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-57893": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-57894": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-57895": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-57896": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-57897": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-57898": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57899": {"epss_score": 0.0006, "epss_percentile": 0.18977}, "CVE-2025-57900": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57902": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57903": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57904": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57905": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57906": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57907": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-57908": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57909": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-57910": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57911": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57912": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57913": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57914": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57915": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57916": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-57917": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-57918": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-57919": {"epss_score": 0.00066, "epss_percentile": 0.2069}, "CVE-2025-57920": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57921": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-57922": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-57923": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-57924": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57925": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-57926": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57927": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57928": {"epss_score": 0.00058, "epss_percentile": 0.18453}, "CVE-2025-57929": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57930": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57931": {"epss_score": 0.00022, "epss_percentile": 0.04961}, "CVE-2025-57932": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57933": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57934": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57935": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57936": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-57937": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-57938": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57939": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-57940": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57941": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57942": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57943": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2025-57944": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-57945": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57946": {"epss_score": 0.0002, "epss_percentile": 0.04632}, "CVE-2025-57947": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57948": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57949": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-57950": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57951": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57952": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57953": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57954": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57955": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-57956": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57957": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-57958": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-57959": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57960": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57961": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-57962": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57963": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57964": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57965": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57966": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57967": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57968": {"epss_score": 0.00021, "epss_percentile": 0.04753}, "CVE-2025-57969": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-57970": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57971": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-57972": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-57973": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57974": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57975": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-57976": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-57977": {"epss_score": 0.00021, "epss_percentile": 0.04778}, "CVE-2025-57978": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57979": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57980": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57981": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57982": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57983": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57984": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2025-57985": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-57986": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57987": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-57988": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57989": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57990": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-57991": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-57992": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-57993": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57994": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-57995": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-57996": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-57997": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-57998": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-57999": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58000": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-58001": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58002": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58003": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-58004": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-58005": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2025-58006": {"epss_score": 0.00038, "epss_percentile": 0.11388}, "CVE-2025-58007": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-58008": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58009": {"epss_score": 0.00049, "epss_percentile": 0.15483}, "CVE-2025-58010": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-58011": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-58012": {"epss_score": 0.00049, "epss_percentile": 0.15483}, "CVE-2025-58013": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-58014": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-58015": {"epss_score": 0.00044, "epss_percentile": 0.13496}, "CVE-2025-58016": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-58017": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58018": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58019": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58020": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58021": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58022": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58023": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58025": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58026": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58027": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58028": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58029": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-58030": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58031": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58032": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-58033": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58034": {"epss_score": 0.53937, "epss_percentile": 0.97903}, "CVE-2025-58044": {"epss_score": 0.00033, "epss_percentile": 0.09349}, "CVE-2025-58045": {"epss_score": 0.00757, "epss_percentile": 0.72756}, "CVE-2025-58046": {"epss_score": 0.00314, "epss_percentile": 0.54148}, "CVE-2025-58047": {"epss_score": 0.00102, "epss_percentile": 0.28897}, "CVE-2025-58048": {"epss_score": 0.00077, "epss_percentile": 0.23543}, "CVE-2025-58049": {"epss_score": 0.00112, "epss_percentile": 0.30571}, "CVE-2025-58050": {"epss_score": 0.00036, "epss_percentile": 0.10407}, "CVE-2025-58051": {"epss_score": 0.00032, "epss_percentile": 0.09033}, "CVE-2025-58052": {"epss_score": 0.0004, "epss_percentile": 0.11903}, "CVE-2025-58053": {"epss_score": 0.00049, "epss_percentile": 0.15297}, "CVE-2025-58054": {"epss_score": 0.00056, "epss_percentile": 0.17763}, "CVE-2025-58055": {"epss_score": 0.00066, "epss_percentile": 0.20895}, "CVE-2025-58056": {"epss_score": 0.00027, "epss_percentile": 0.0683}, "CVE-2025-58057": {"epss_score": 0.0007, "epss_percentile": 0.21805}, "CVE-2025-58058": {"epss_score": 0.00075, "epss_percentile": 0.23019}, "CVE-2025-58059": {"epss_score": 0.00085, "epss_percentile": 0.25037}, "CVE-2025-58060": {"epss_score": 0.00056, "epss_percentile": 0.17703}, "CVE-2025-58061": {"epss_score": 0.00022, "epss_percentile": 0.05303}, "CVE-2025-58062": {"epss_score": 0.00411, "epss_percentile": 0.60878}, "CVE-2025-58063": {"epss_score": 0.00059, "epss_percentile": 0.18839}, "CVE-2025-58064": {"epss_score": 0.00149, "epss_percentile": 0.35949}, "CVE-2025-58065": {"epss_score": 0.00031, "epss_percentile": 0.08432}, "CVE-2025-58066": {"epss_score": 0.00132, "epss_percentile": 0.33534}, "CVE-2025-58067": {"epss_score": 0.00051, "epss_percentile": 0.16265}, "CVE-2025-58068": {"epss_score": 0.00054, "epss_percentile": 0.17172}, "CVE-2025-58069": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-58070": {"epss_score": 0.00043, "epss_percentile": 0.13062}, "CVE-2025-58071": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-58072": {"epss_score": 0.00145, "epss_percentile": 0.35409}, "CVE-2025-58073": {"epss_score": 0.00044, "epss_percentile": 0.13656}, "CVE-2025-58075": {"epss_score": 0.00044, "epss_percentile": 0.13656}, "CVE-2025-58078": {"epss_score": 0.00353, "epss_percentile": 0.57194}, "CVE-2025-58079": {"epss_score": 0.00046, "epss_percentile": 0.14392}, "CVE-2025-58081": {"epss_score": 0.00081, "epss_percentile": 0.24388}, "CVE-2025-58083": {"epss_score": 0.00098, "epss_percentile": 0.27814}, "CVE-2025-58084": {"epss_score": 0.00097, "epss_percentile": 0.27566}, "CVE-2025-58096": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-58097": {"epss_score": 0.00012, "epss_percentile": 0.01245}, "CVE-2025-58098": {"epss_score": 0.00091, "epss_percentile": 0.26233}, "CVE-2025-58113": {"epss_score": 0.00034, "epss_percentile": 0.09771}, "CVE-2025-58114": {"epss_score": 0.00056, "epss_percentile": 0.17908}, "CVE-2025-58115": {"epss_score": 0.00043, "epss_percentile": 0.13062}, "CVE-2025-58116": {"epss_score": 0.00387, "epss_percentile": 0.59305}, "CVE-2025-58120": {"epss_score": 0.00132, "epss_percentile": 0.3358}, "CVE-2025-58121": {"epss_score": 0.00034, "epss_percentile": 0.09676}, "CVE-2025-58122": {"epss_score": 0.00034, "epss_percentile": 0.09676}, "CVE-2025-58123": {"epss_score": 0.00028, "epss_percentile": 0.07297}, "CVE-2025-58124": {"epss_score": 0.00028, "epss_percentile": 0.07297}, "CVE-2025-58125": {"epss_score": 0.00028, "epss_percentile": 0.07297}, "CVE-2025-58126": {"epss_score": 0.00028, "epss_percentile": 0.07297}, "CVE-2025-58127": {"epss_score": 0.00028, "epss_percentile": 0.07297}, "CVE-2025-58130": {"epss_score": 0.00095, "epss_percentile": 0.27209}, "CVE-2025-58131": {"epss_score": 0.00013, "epss_percentile": 0.01597}, "CVE-2025-58132": {"epss_score": 0.00103, "epss_percentile": 0.29064}, "CVE-2025-58133": {"epss_score": 0.00177, "epss_percentile": 0.39579}, "CVE-2025-58134": {"epss_score": 0.0004, "epss_percentile": 0.12077}, "CVE-2025-58135": {"epss_score": 0.00076, "epss_percentile": 0.23148}, "CVE-2025-58137": {"epss_score": 0.0006, "epss_percentile": 0.19078}, "CVE-2025-58142": {"epss_score": 0.00064, "epss_percentile": 0.20179}, "CVE-2025-58143": {"epss_score": 0.00049, "epss_percentile": 0.15623}, "CVE-2025-58144": {"epss_score": 0.0006, "epss_percentile": 0.19023}, "CVE-2025-58145": {"epss_score": 0.00046, "epss_percentile": 0.14335}, "CVE-2025-58147": {"epss_score": 0.00044, "epss_percentile": 0.13388}, "CVE-2025-58148": {"epss_score": 0.00044, "epss_percentile": 0.13388}, "CVE-2025-58149": {"epss_score": 0.00048, "epss_percentile": 0.15149}, "CVE-2025-58152": {"epss_score": 0.00062, "epss_percentile": 0.19654}, "CVE-2025-58153": {"epss_score": 0.00088, "epss_percentile": 0.25672}, "CVE-2025-58156": {"epss_score": 0.00065, "epss_percentile": 0.20503}, "CVE-2025-58157": {"epss_score": 0.00178, "epss_percentile": 0.39643}, "CVE-2025-58158": {"epss_score": 0.00103, "epss_percentile": 0.29039}, "CVE-2025-58159": {"epss_score": 0.00496, "epss_percentile": 0.65163}, "CVE-2025-58160": {"epss_score": 0.00082, "epss_percentile": 0.24408}, "CVE-2025-58161": {"epss_score": 0.00165, "epss_percentile": 0.38101}, "CVE-2025-58162": {"epss_score": 0.00133, "epss_percentile": 0.33632}, "CVE-2025-58163": {"epss_score": 0.0054, "epss_percentile": 0.67016}, "CVE-2025-58172": {"epss_score": 0.00115, "epss_percentile": 0.30958}, "CVE-2025-58173": {"epss_score": 0.00119, "epss_percentile": 0.3162}, "CVE-2025-58174": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-58176": {"epss_score": 0.00337, "epss_percentile": 0.56062}, "CVE-2025-58177": {"epss_score": 0.00037, "epss_percentile": 0.10996}, "CVE-2025-58178": {"epss_score": 0.00055, "epss_percentile": 0.17556}, "CVE-2025-58179": {"epss_score": 0.00759, "epss_percentile": 0.72787}, "CVE-2025-58180": {"epss_score": 0.00141, "epss_percentile": 0.34919}, "CVE-2025-58181": {"epss_score": 0.00095, "epss_percentile": 0.27213}, "CVE-2025-58183": {"epss_score": 0.00016, "epss_percentile": 0.02647}, "CVE-2025-58185": {"epss_score": 0.00034, "epss_percentile": 0.09756}, "CVE-2025-58186": {"epss_score": 0.0003, "epss_percentile": 0.08171}, "CVE-2025-58187": {"epss_score": 0.00016, "epss_percentile": 0.02868}, "CVE-2025-58188": {"epss_score": 0.00016, "epss_percentile": 0.02868}, "CVE-2025-58189": {"epss_score": 0.0002, "epss_percentile": 0.04497}, "CVE-2025-58192": {"epss_score": 0.00046, "epss_percentile": 0.1415}, "CVE-2025-58193": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-58194": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58195": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58196": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58197": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58198": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-58199": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-58200": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-58201": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-58202": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-58203": {"epss_score": 0.00042, "epss_percentile": 0.12886}, "CVE-2025-58204": {"epss_score": 0.00051, "epss_percentile": 0.16308}, "CVE-2025-58205": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58206": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-58207": {"epss_score": 0.00043, "epss_percentile": 0.13068}, "CVE-2025-58208": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58209": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58210": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-58211": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58212": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58213": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58214": {"epss_score": 0.00222, "epss_percentile": 0.44817}, "CVE-2025-58215": {"epss_score": 0.00172, "epss_percentile": 0.38969}, "CVE-2025-58216": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58217": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58218": {"epss_score": 0.00105, "epss_percentile": 0.2939}, "CVE-2025-58219": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-58220": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58221": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-58222": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-58223": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58224": {"epss_score": 0.0002, "epss_percentile": 0.04632}, "CVE-2025-58225": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-58226": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-58227": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58228": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58229": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58230": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58231": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58232": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58233": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58234": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58235": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58236": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-58237": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58238": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58239": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58240": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58241": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58242": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58243": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-58244": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-58245": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58246": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-58247": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-58248": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58249": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-58250": {"epss_score": 0.00032, "epss_percentile": 0.08784}, "CVE-2025-58251": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-58252": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-58253": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58254": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58255": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-58256": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58257": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58258": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-58259": {"epss_score": 0.00021, "epss_percentile": 0.04778}, "CVE-2025-58260": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58261": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58262": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58263": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58264": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58265": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58266": {"epss_score": 0.00019, "epss_percentile": 0.04234}, "CVE-2025-58267": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58268": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58269": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-58270": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58271": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58272": {"epss_score": 0.00013, "epss_percentile": 0.01667}, "CVE-2025-58276": {"epss_score": 0.00011, "epss_percentile": 0.01066}, "CVE-2025-58277": {"epss_score": 8e-05, "epss_percentile": 0.00545}, "CVE-2025-58278": {"epss_score": 0.00011, "epss_percentile": 0.01019}, "CVE-2025-58279": {"epss_score": 6e-05, "epss_percentile": 0.00298}, "CVE-2025-58280": {"epss_score": 0.00042, "epss_percentile": 0.12622}, "CVE-2025-58281": {"epss_score": 0.00012, "epss_percentile": 0.01228}, "CVE-2025-58282": {"epss_score": 8e-05, "epss_percentile": 0.00491}, "CVE-2025-58283": {"epss_score": 8e-05, "epss_percentile": 0.00535}, "CVE-2025-58284": {"epss_score": 8e-05, "epss_percentile": 0.00535}, "CVE-2025-58285": {"epss_score": 8e-05, "epss_percentile": 0.00491}, "CVE-2025-58286": {"epss_score": 9e-05, "epss_percentile": 0.00668}, "CVE-2025-58287": {"epss_score": 8e-05, "epss_percentile": 0.0052}, "CVE-2025-58288": {"epss_score": 8e-05, "epss_percentile": 0.00573}, "CVE-2025-58289": {"epss_score": 9e-05, "epss_percentile": 0.00633}, "CVE-2025-58290": {"epss_score": 9e-05, "epss_percentile": 0.00668}, "CVE-2025-58291": {"epss_score": 9e-05, "epss_percentile": 0.00668}, "CVE-2025-58292": {"epss_score": 9e-05, "epss_percentile": 0.00668}, "CVE-2025-58293": {"epss_score": 8e-05, "epss_percentile": 0.0058}, "CVE-2025-58294": {"epss_score": 8e-05, "epss_percentile": 0.00485}, "CVE-2025-58295": {"epss_score": 9e-05, "epss_percentile": 0.00633}, "CVE-2025-58296": {"epss_score": 9e-05, "epss_percentile": 0.00594}, "CVE-2025-58297": {"epss_score": 9e-05, "epss_percentile": 0.00633}, "CVE-2025-58298": {"epss_score": 9e-05, "epss_percentile": 0.00633}, "CVE-2025-58299": {"epss_score": 9e-05, "epss_percentile": 0.00707}, "CVE-2025-58300": {"epss_score": 9e-05, "epss_percentile": 0.00705}, "CVE-2025-58301": {"epss_score": 9e-05, "epss_percentile": 0.00705}, "CVE-2025-58302": {"epss_score": 8e-05, "epss_percentile": 0.00474}, "CVE-2025-58303": {"epss_score": 7e-05, "epss_percentile": 0.00429}, "CVE-2025-58304": {"epss_score": 7e-05, "epss_percentile": 0.00385}, "CVE-2025-58305": {"epss_score": 9e-05, "epss_percentile": 0.00733}, "CVE-2025-58307": {"epss_score": 7e-05, "epss_percentile": 0.00442}, "CVE-2025-58308": {"epss_score": 8e-05, "epss_percentile": 0.00481}, "CVE-2025-58309": {"epss_score": 8e-05, "epss_percentile": 0.00483}, "CVE-2025-58310": {"epss_score": 8e-05, "epss_percentile": 0.00474}, "CVE-2025-58311": {"epss_score": 6e-05, "epss_percentile": 0.00319}, "CVE-2025-58312": {"epss_score": 8e-05, "epss_percentile": 0.00474}, "CVE-2025-58313": {"epss_score": 9e-05, "epss_percentile": 0.00707}, "CVE-2025-58314": {"epss_score": 8e-05, "epss_percentile": 0.00528}, "CVE-2025-58315": {"epss_score": 7e-05, "epss_percentile": 0.00368}, "CVE-2025-58316": {"epss_score": 7e-05, "epss_percentile": 0.00372}, "CVE-2025-58317": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-58318": {"epss_score": 0.0003, "epss_percentile": 0.08215}, "CVE-2025-58319": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-58320": {"epss_score": 0.00077, "epss_percentile": 0.23529}, "CVE-2025-58321": {"epss_score": 0.00698, "epss_percentile": 0.71418}, "CVE-2025-58322": {"epss_score": 0.00023, "epss_percentile": 0.05431}, "CVE-2025-58323": {"epss_score": 0.00022, "epss_percentile": 0.05151}, "CVE-2025-58324": {"epss_score": 0.00054, "epss_percentile": 0.17088}, "CVE-2025-58325": {"epss_score": 0.00019, "epss_percentile": 0.04246}, "CVE-2025-58334": {"epss_score": 6e-05, "epss_percentile": 0.00299}, "CVE-2025-58335": {"epss_score": 1e-05, "epss_percentile": 7e-05}, "CVE-2025-58337": {"epss_score": 0.00096, "epss_percentile": 0.27318}, "CVE-2025-58351": {"epss_score": 0.00061, "epss_percentile": 0.1935}, "CVE-2025-58352": {"epss_score": 0.00067, "epss_percentile": 0.21107}, "CVE-2025-58353": {"epss_score": 0.00086, "epss_percentile": 0.25354}, "CVE-2025-58354": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-58355": {"epss_score": 0.00082, "epss_percentile": 0.24489}, "CVE-2025-58356": {"epss_score": 5e-05, "epss_percentile": 0.00197}, "CVE-2025-58357": {"epss_score": 0.0008, "epss_percentile": 0.24092}, "CVE-2025-58358": {"epss_score": 0.00184, "epss_percentile": 0.40444}, "CVE-2025-58359": {"epss_score": 0.00031, "epss_percentile": 0.08644}, "CVE-2025-58360": {"epss_score": 0.826, "epss_percentile": 0.99201}, "CVE-2025-58361": {"epss_score": 0.00086, "epss_percentile": 0.25354}, "CVE-2025-58362": {"epss_score": 0.00056, "epss_percentile": 0.17857}, "CVE-2025-58364": {"epss_score": 0.00089, "epss_percentile": 0.25939}, "CVE-2025-58365": {"epss_score": 0.00574, "epss_percentile": 0.68081}, "CVE-2025-58366": {"epss_score": 0.00075, "epss_percentile": 0.22943}, "CVE-2025-58367": {"epss_score": 0.00744, "epss_percentile": 0.7251}, "CVE-2025-58369": {"epss_score": 0.00196, "epss_percentile": 0.41737}, "CVE-2025-58370": {"epss_score": 0.00205, "epss_percentile": 0.42679}, "CVE-2025-58371": {"epss_score": 0.00396, "epss_percentile": 0.59905}, "CVE-2025-58372": {"epss_score": 0.00133, "epss_percentile": 0.3363}, "CVE-2025-58373": {"epss_score": 0.00034, "epss_percentile": 0.09475}, "CVE-2025-58374": {"epss_score": 0.00058, "epss_percentile": 0.18309}, "CVE-2025-58384": {"epss_score": 0.00578, "epss_percentile": 0.68188}, "CVE-2025-58385": {"epss_score": 0.00019, "epss_percentile": 0.0423}, "CVE-2025-58386": {"epss_score": 0.00063, "epss_percentile": 0.19836}, "CVE-2025-58400": {"epss_score": 0.00025, "epss_percentile": 0.06252}, "CVE-2025-58401": {"epss_score": 0.00011, "epss_percentile": 0.01051}, "CVE-2025-58407": {"epss_score": 0.0004, "epss_percentile": 0.11994}, "CVE-2025-58408": {"epss_score": 0.00018, "epss_percentile": 0.03763}, "CVE-2025-58410": {"epss_score": 0.00046, "epss_percentile": 0.14463}, "CVE-2025-58412": {"epss_score": 0.00038, "epss_percentile": 0.11216}, "CVE-2025-58413": {"epss_score": 0.0001, "epss_percentile": 0.0086}, "CVE-2025-58422": {"epss_score": 0.00036, "epss_percentile": 0.10242}, "CVE-2025-58423": {"epss_score": 0.00084, "epss_percentile": 0.24877}, "CVE-2025-58424": {"epss_score": 0.00082, "epss_percentile": 0.24427}, "CVE-2025-58426": {"epss_score": 0.00043, "epss_percentile": 0.12976}, "CVE-2025-58428": {"epss_score": 0.006, "epss_percentile": 0.68816}, "CVE-2025-58429": {"epss_score": 0.01146, "epss_percentile": 0.77995}, "CVE-2025-58430": {"epss_score": 0.00026, "epss_percentile": 0.06541}, "CVE-2025-58431": {"epss_score": 0.00024, "epss_percentile": 0.05749}, "CVE-2025-58432": {"epss_score": 0.00019, "epss_percentile": 0.04131}, "CVE-2025-58434": {"epss_score": 0.08177, "epss_percentile": 0.91915}, "CVE-2025-58435": {"epss_score": 0.00058, "epss_percentile": 0.18279}, "CVE-2025-58436": {"epss_score": 0.00013, "epss_percentile": 0.01629}, "CVE-2025-58437": {"epss_score": 0.00055, "epss_percentile": 0.17487}, "CVE-2025-58438": {"epss_score": 0.02743, "epss_percentile": 0.85564}, "CVE-2025-58439": {"epss_score": 0.00054, "epss_percentile": 0.17285}, "CVE-2025-58441": {"epss_score": 0.00041, "epss_percentile": 0.12306}, "CVE-2025-58442": {"epss_score": 0.00043, "epss_percentile": 0.13288}, "CVE-2025-58443": {"epss_score": 0.08226, "epss_percentile": 0.91939}, "CVE-2025-58444": {"epss_score": 0.00039, "epss_percentile": 0.11459}, "CVE-2025-58445": {"epss_score": 0.00076, "epss_percentile": 0.23221}, "CVE-2025-58446": {"epss_score": 0.00105, "epss_percentile": 0.29269}, "CVE-2025-58447": {"epss_score": 0.00291, "epss_percentile": 0.5219}, "CVE-2025-58448": {"epss_score": 0.00051, "epss_percentile": 0.1624}, "CVE-2025-58449": {"epss_score": 0.00168, "epss_percentile": 0.38444}, "CVE-2025-58450": {"epss_score": 0.00058, "epss_percentile": 0.18569}, "CVE-2025-58451": {"epss_score": 0.00143, "epss_percentile": 0.35173}, "CVE-2025-58452": {"epss_score": 0.00068, "epss_percentile": 0.21301}, "CVE-2025-58453": {"epss_score": 0.00062, "epss_percentile": 0.19705}, "CVE-2025-58454": {"epss_score": 0.00062, "epss_percentile": 0.19705}, "CVE-2025-58456": {"epss_score": 0.00097, "epss_percentile": 0.27534}, "CVE-2025-58457": {"epss_score": 0.00093, "epss_percentile": 0.26663}, "CVE-2025-58458": {"epss_score": 0.00078, "epss_percentile": 0.23569}, "CVE-2025-58459": {"epss_score": 0.00061, "epss_percentile": 0.19445}, "CVE-2025-58460": {"epss_score": 0.00047, "epss_percentile": 0.1448}, "CVE-2025-58462": {"epss_score": 0.00112, "epss_percentile": 0.30541}, "CVE-2025-58463": {"epss_score": 0.00069, "epss_percentile": 0.21602}, "CVE-2025-58464": {"epss_score": 0.00076, "epss_percentile": 0.23103}, "CVE-2025-58465": {"epss_score": 0.00085, "epss_percentile": 0.25174}, "CVE-2025-58469": {"epss_score": 0.00055, "epss_percentile": 0.17417}, "CVE-2025-58473": {"epss_score": 0.00082, "epss_percentile": 0.24416}, "CVE-2025-58474": {"epss_score": 0.0011, "epss_percentile": 0.30218}, "CVE-2025-58475": {"epss_score": 0.00023, "epss_percentile": 0.05621}, "CVE-2025-58476": {"epss_score": 0.00022, "epss_percentile": 0.05187}, "CVE-2025-58477": {"epss_score": 0.00062, "epss_percentile": 0.19765}, "CVE-2025-58478": {"epss_score": 0.00062, "epss_percentile": 0.19765}, "CVE-2025-58479": {"epss_score": 0.00047, "epss_percentile": 0.14852}, "CVE-2025-58480": {"epss_score": 0.0005, "epss_percentile": 0.15679}, "CVE-2025-58481": {"epss_score": 0.00014, "epss_percentile": 0.01932}, "CVE-2025-58482": {"epss_score": 0.00014, "epss_percentile": 0.01932}, "CVE-2025-58483": {"epss_score": 0.00018, "epss_percentile": 0.03521}, "CVE-2025-58484": {"epss_score": 0.00018, "epss_percentile": 0.03679}, "CVE-2025-58485": {"epss_score": 0.00024, "epss_percentile": 0.05856}, "CVE-2025-58486": {"epss_score": 0.00036, "epss_percentile": 0.1038}, "CVE-2025-58487": {"epss_score": 0.00019, "epss_percentile": 0.04378}, "CVE-2025-58488": {"epss_score": 0.00042, "epss_percentile": 0.1266}, "CVE-2025-58576": {"epss_score": 0.00017, "epss_percentile": 0.03249}, "CVE-2025-58578": {"epss_score": 0.00064, "epss_percentile": 0.20173}, "CVE-2025-58579": {"epss_score": 0.00104, "epss_percentile": 0.29131}, "CVE-2025-58580": {"epss_score": 0.0007, "epss_percentile": 0.21661}, "CVE-2025-58581": {"epss_score": 0.00051, "epss_percentile": 0.16184}, "CVE-2025-58582": {"epss_score": 0.0007, "epss_percentile": 0.21661}, "CVE-2025-58583": {"epss_score": 0.00052, "epss_percentile": 0.16343}, "CVE-2025-58584": {"epss_score": 0.00052, "epss_percentile": 0.16343}, "CVE-2025-58585": {"epss_score": 0.00079, "epss_percentile": 0.23964}, "CVE-2025-58586": {"epss_score": 0.00052, "epss_percentile": 0.16343}, "CVE-2025-58587": {"epss_score": 0.0014, "epss_percentile": 0.34767}, "CVE-2025-58589": {"epss_score": 0.00047, "epss_percentile": 0.14803}, "CVE-2025-58590": {"epss_score": 0.00074, "epss_percentile": 0.22795}, "CVE-2025-58591": {"epss_score": 0.00074, "epss_percentile": 0.22795}, "CVE-2025-58592": {"epss_score": 0.00058, "epss_percentile": 0.18511}, "CVE-2025-58593": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58594": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-58595": {"epss_score": 0.00057, "epss_percentile": 0.18047}, "CVE-2025-58596": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58597": {"epss_score": 0.00069, "epss_percentile": 0.21463}, "CVE-2025-58598": {"epss_score": 0.00052, "epss_percentile": 0.16346}, "CVE-2025-58599": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-58600": {"epss_score": 0.00077, "epss_percentile": 0.23439}, "CVE-2025-58601": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-58602": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58603": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-58604": {"epss_score": 0.00053, "epss_percentile": 0.16754}, "CVE-2025-58605": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58606": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-58607": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58608": {"epss_score": 0.0022, "epss_percentile": 0.44626}, "CVE-2025-58609": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58610": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58611": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-58612": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58613": {"epss_score": 0.00051, "epss_percentile": 0.16308}, "CVE-2025-58614": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58615": {"epss_score": 0.00042, "epss_percentile": 0.12886}, "CVE-2025-58616": {"epss_score": 0.0007, "epss_percentile": 0.21975}, "CVE-2025-58617": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-58618": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58619": {"epss_score": 0.00052, "epss_percentile": 0.16465}, "CVE-2025-58620": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58621": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58622": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-58623": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58624": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58625": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58626": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58627": {"epss_score": 0.00059, "epss_percentile": 0.18882}, "CVE-2025-58628": {"epss_score": 0.00058, "epss_percentile": 0.18292}, "CVE-2025-58629": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-58630": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58631": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58632": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58633": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58634": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-58635": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-58636": {"epss_score": 0.00058, "epss_percentile": 0.18511}, "CVE-2025-58637": {"epss_score": 0.0022, "epss_percentile": 0.44626}, "CVE-2025-58638": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-58639": {"epss_score": 0.00069, "epss_percentile": 0.21463}, "CVE-2025-58640": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58641": {"epss_score": 0.00049, "epss_percentile": 0.15332}, "CVE-2025-58642": {"epss_score": 0.00105, "epss_percentile": 0.2939}, "CVE-2025-58643": {"epss_score": 0.00105, "epss_percentile": 0.2939}, "CVE-2025-58644": {"epss_score": 0.00105, "epss_percentile": 0.2939}, "CVE-2025-58645": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58646": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58647": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58648": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58649": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-58650": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-58651": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58652": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58653": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58654": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58655": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58656": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-58657": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58658": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58659": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-58660": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-58661": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58662": {"epss_score": 0.00066, "epss_percentile": 0.2069}, "CVE-2025-58663": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-58664": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-58665": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58666": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-58667": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-58668": {"epss_score": 0.00046, "epss_percentile": 0.14079}, "CVE-2025-58669": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58670": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58671": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-58672": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-58673": {"epss_score": 0.00042, "epss_percentile": 0.12927}, "CVE-2025-58674": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58675": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-58676": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58677": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58678": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-58679": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-58680": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-58681": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-58682": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58683": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58684": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58685": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-58686": {"epss_score": 0.00044, "epss_percentile": 0.13582}, "CVE-2025-58687": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58688": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58689": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58690": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58691": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58692": {"epss_score": 0.00038, "epss_percentile": 0.11333}, "CVE-2025-58702": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58703": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58704": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58706": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-58708": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-58709": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-58710": {"epss_score": 0.00053, "epss_percentile": 0.16886}, "CVE-2025-58711": {"epss_score": 0.0006, "epss_percentile": 0.18977}, "CVE-2025-58712": {"epss_score": 0.0001, "epss_percentile": 0.00867}, "CVE-2025-58714": {"epss_score": 0.00061, "epss_percentile": 0.19244}, "CVE-2025-58715": {"epss_score": 0.0009, "epss_percentile": 0.2614}, "CVE-2025-58716": {"epss_score": 0.001, "epss_percentile": 0.28504}, "CVE-2025-58717": {"epss_score": 0.00071, "epss_percentile": 0.22016}, "CVE-2025-58718": {"epss_score": 0.00083, "epss_percentile": 0.24739}, "CVE-2025-58719": {"epss_score": 0.00052, "epss_percentile": 0.16365}, "CVE-2025-58720": {"epss_score": 0.00027, "epss_percentile": 0.0692}, "CVE-2025-58722": {"epss_score": 0.00088, "epss_percentile": 0.25777}, "CVE-2025-58724": {"epss_score": 0.00061, "epss_percentile": 0.19244}, "CVE-2025-58725": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-58726": {"epss_score": 0.00144, "epss_percentile": 0.35342}, "CVE-2025-58727": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-58728": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-58729": {"epss_score": 0.00231, "epss_percentile": 0.45853}, "CVE-2025-58730": {"epss_score": 0.00072, "epss_percentile": 0.22465}, "CVE-2025-58731": {"epss_score": 0.00072, "epss_percentile": 0.22465}, "CVE-2025-58732": {"epss_score": 0.00072, "epss_percentile": 0.22465}, "CVE-2025-58733": {"epss_score": 0.00072, "epss_percentile": 0.22465}, "CVE-2025-58734": {"epss_score": 0.00072, "epss_percentile": 0.22465}, "CVE-2025-58735": {"epss_score": 0.00072, "epss_percentile": 0.22465}, "CVE-2025-58736": {"epss_score": 0.00072, "epss_percentile": 0.22465}, "CVE-2025-58737": {"epss_score": 0.00072, "epss_percentile": 0.22465}, "CVE-2025-58738": {"epss_score": 0.00072, "epss_percentile": 0.22465}, "CVE-2025-58739": {"epss_score": 0.00109, "epss_percentile": 0.29941}, "CVE-2025-58745": {"epss_score": 0.00292, "epss_percentile": 0.5224}, "CVE-2025-58746": {"epss_score": 0.00079, "epss_percentile": 0.23949}, "CVE-2025-58747": {"epss_score": 0.00072, "epss_percentile": 0.22386}, "CVE-2025-58748": {"epss_score": 0.00615, "epss_percentile": 0.69291}, "CVE-2025-58749": {"epss_score": 0.00058, "epss_percentile": 0.18312}, "CVE-2025-58750": {"epss_score": 0.0005, "epss_percentile": 0.15782}, "CVE-2025-58751": {"epss_score": 0.01925, "epss_percentile": 0.8292}, "CVE-2025-58752": {"epss_score": 0.00028, "epss_percentile": 0.07352}, "CVE-2025-58753": {"epss_score": 0.00047, "epss_percentile": 0.14622}, "CVE-2025-58754": {"epss_score": 0.0005, "epss_percentile": 0.15871}, "CVE-2025-58755": {"epss_score": 0.00116, "epss_percentile": 0.31168}, "CVE-2025-58756": {"epss_score": 0.00809, "epss_percentile": 0.73707}, "CVE-2025-58757": {"epss_score": 0.00536, "epss_percentile": 0.66864}, "CVE-2025-58758": {"epss_score": 0.00037, "epss_percentile": 0.10787}, "CVE-2025-58759": {"epss_score": 0.00085, "epss_percentile": 0.2506}, "CVE-2025-58760": {"epss_score": 0.00186, "epss_percentile": 0.40609}, "CVE-2025-58761": {"epss_score": 0.00142, "epss_percentile": 0.34984}, "CVE-2025-58762": {"epss_score": 0.00515, "epss_percentile": 0.65973}, "CVE-2025-58763": {"epss_score": 0.00415, "epss_percentile": 0.61135}, "CVE-2025-58764": {"epss_score": 0.00158, "epss_percentile": 0.37234}, "CVE-2025-58765": {"epss_score": 0.00045, "epss_percentile": 0.13888}, "CVE-2025-58766": {"epss_score": 0.00056, "epss_percentile": 0.17684}, "CVE-2025-58767": {"epss_score": 0.0002, "epss_percentile": 0.04612}, "CVE-2025-58768": {"epss_score": 0.00088, "epss_percentile": 0.25663}, "CVE-2025-58769": {"epss_score": 0.00093, "epss_percentile": 0.26672}, "CVE-2025-58770": {"epss_score": 0.00012, "epss_percentile": 0.01275}, "CVE-2025-58775": {"epss_score": 0.00018, "epss_percentile": 0.03661}, "CVE-2025-58776": {"epss_score": 0.00018, "epss_percentile": 0.03661}, "CVE-2025-58777": {"epss_score": 0.00018, "epss_percentile": 0.03661}, "CVE-2025-58778": {"epss_score": 0.00058, "epss_percentile": 0.18524}, "CVE-2025-58780": {"epss_score": 0.00057, "epss_percentile": 0.18191}, "CVE-2025-58781": {"epss_score": 0.00024, "epss_percentile": 0.0603}, "CVE-2025-58782": {"epss_score": 0.00244, "epss_percentile": 0.4761}, "CVE-2025-58783": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-58784": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58785": {"epss_score": 0.00069, "epss_percentile": 0.21463}, "CVE-2025-58786": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58787": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58788": {"epss_score": 0.00053, "epss_percentile": 0.16754}, "CVE-2025-58789": {"epss_score": 0.00053, "epss_percentile": 0.16754}, "CVE-2025-58790": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58791": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58792": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-58793": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58794": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-58795": {"epss_score": 0.00051, "epss_percentile": 0.16171}, "CVE-2025-58796": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58797": {"epss_score": 0.0005, "epss_percentile": 0.15854}, "CVE-2025-58798": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-58799": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-58800": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-58801": {"epss_score": 0.00029, "epss_percentile": 0.07668}, "CVE-2025-58802": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-58803": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58804": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-58805": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58806": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58807": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58808": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58809": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58810": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58811": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58812": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58813": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-58814": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58815": {"epss_score": 0.00105, "epss_percentile": 0.2939}, "CVE-2025-58816": {"epss_score": 0.00058, "epss_percentile": 0.18576}, "CVE-2025-58817": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-58818": {"epss_score": 0.00029, "epss_percentile": 0.07668}, "CVE-2025-58819": {"epss_score": 0.00076, "epss_percentile": 0.23102}, "CVE-2025-58820": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58821": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58822": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58823": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58824": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-58825": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58826": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58827": {"epss_score": 0.00048, "epss_percentile": 0.15041}, "CVE-2025-58828": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58829": {"epss_score": 0.00046, "epss_percentile": 0.1415}, "CVE-2025-58830": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58831": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-58832": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58833": {"epss_score": 0.00034, "epss_percentile": 0.09617}, "CVE-2025-58834": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58835": {"epss_score": 0.00078, "epss_percentile": 0.23649}, "CVE-2025-58836": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58837": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58838": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58839": {"epss_score": 0.00105, "epss_percentile": 0.2939}, "CVE-2025-58840": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58841": {"epss_score": 0.00065, "epss_percentile": 0.2056}, "CVE-2025-58842": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58843": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58844": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58845": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58846": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58847": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58848": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58849": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58850": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58851": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58852": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58853": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58854": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58855": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-58856": {"epss_score": 0.00034, "epss_percentile": 0.09535}, "CVE-2025-58857": {"epss_score": 0.00064, "epss_percentile": 0.20419}, "CVE-2025-58858": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58859": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58860": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58861": {"epss_score": 0.00027, "epss_percentile": 0.07151}, "CVE-2025-58862": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58863": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58864": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58865": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-58866": {"epss_score": 0.00046, "epss_percentile": 0.14194}, "CVE-2025-58867": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58868": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58869": {"epss_score": 0.00027, "epss_percentile": 0.06955}, "CVE-2025-58870": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58871": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58872": {"epss_score": 0.00056, "epss_percentile": 0.17746}, "CVE-2025-58873": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58874": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58875": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58876": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58877": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-58878": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-58879": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58880": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58881": {"epss_score": 0.00057, "epss_percentile": 0.18148}, "CVE-2025-58882": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58883": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58884": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58885": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58886": {"epss_score": 0.00059, "epss_percentile": 0.18777}, "CVE-2025-58887": {"epss_score": 0.00064, "epss_percentile": 0.20249}, "CVE-2025-58888": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58889": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58890": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58891": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58892": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58893": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58894": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58895": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58896": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58898": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58899": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-58900": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-58901": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-58903": {"epss_score": 0.00059, "epss_percentile": 0.18656}, "CVE-2025-58914": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-58915": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58916": {"epss_score": 0.00044, "epss_percentile": 0.13623}, "CVE-2025-58917": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58918": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-58919": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-58921": {"epss_score": 0.00044, "epss_percentile": 0.13623}, "CVE-2025-58923": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-58925": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-58926": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-58927": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-58928": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-58929": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58930": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58931": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58932": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58933": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-58934": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-58935": {"epss_score": 0.00058, "epss_percentile": 0.18289}, "CVE-2025-58936": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-58937": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-58938": {"epss_score": 0.00043, "epss_percentile": 0.1294}, "CVE-2025-58939": {"epss_score": 0.0002, "epss_percentile": 0.04632}, "CVE-2025-58940": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58941": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58942": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58943": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58944": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58945": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58946": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58947": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-58948": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-58949": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-58950": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-58951": {"epss_score": 0.00028, "epss_percentile": 0.07495}, "CVE-2025-58955": {"epss_score": 0.00172, "epss_percentile": 0.38969}, "CVE-2025-58956": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58957": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-58958": {"epss_score": 0.00057, "epss_percentile": 0.18076}, "CVE-2025-58959": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2025-58960": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58961": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-58962": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-58963": {"epss_score": 0.00064, "epss_percentile": 0.20262}, "CVE-2025-58964": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-58965": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58966": {"epss_score": 0.00044, "epss_percentile": 0.13623}, "CVE-2025-58967": {"epss_score": 0.00064, "epss_percentile": 0.20212}, "CVE-2025-58968": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-58969": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-58970": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58971": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-58972": {"epss_score": 0.00083, "epss_percentile": 0.24763}, "CVE-2025-58973": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-58974": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58975": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-58976": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-58977": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-58978": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-58979": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-58980": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-58981": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-58982": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58983": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58984": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-58985": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58986": {"epss_score": 0.00037, "epss_percentile": 0.1091}, "CVE-2025-58987": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58988": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58989": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58990": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-58991": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-58992": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-58993": {"epss_score": 0.00041, "epss_percentile": 0.12284}, "CVE-2025-58994": {"epss_score": 0.0005, "epss_percentile": 0.15948}, "CVE-2025-58995": {"epss_score": 0.0005, "epss_percentile": 0.15948}, "CVE-2025-58996": {"epss_score": 0.00056, "epss_percentile": 0.17809}, "CVE-2025-58997": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-58998": {"epss_score": 0.00058, "epss_percentile": 0.18511}, "CVE-2025-58999": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-59001": {"epss_score": 0.00029, "epss_percentile": 0.07732}, "CVE-2025-59002": {"epss_score": 0.00071, "epss_percentile": 0.22089}, "CVE-2025-59003": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-59004": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-59005": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-59006": {"epss_score": 0.00044, "epss_percentile": 0.13623}, "CVE-2025-59007": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-59008": {"epss_score": 0.00041, "epss_percentile": 0.12284}, "CVE-2025-59009": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-59010": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-59011": {"epss_score": 0.00061, "epss_percentile": 0.19482}, "CVE-2025-59012": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-59013": {"epss_score": 0.00038, "epss_percentile": 0.11348}, "CVE-2025-59014": {"epss_score": 0.00056, "epss_percentile": 0.1788}, "CVE-2025-59015": {"epss_score": 0.00043, "epss_percentile": 0.13318}, "CVE-2025-59016": {"epss_score": 0.00043, "epss_percentile": 0.13132}, "CVE-2025-59017": {"epss_score": 0.00062, "epss_percentile": 0.19574}, "CVE-2025-59018": {"epss_score": 0.00048, "epss_percentile": 0.15184}, "CVE-2025-59019": {"epss_score": 0.00043, "epss_percentile": 0.13132}, "CVE-2025-59025": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-59026": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-59029": {"epss_score": 9e-05, "epss_percentile": 0.0064}, "CVE-2025-59030": {"epss_score": 0.00015, "epss_percentile": 0.02126}, "CVE-2025-59033": {"epss_score": 0.00099, "epss_percentile": 0.28311}, "CVE-2025-59034": {"epss_score": 0.00044, "epss_percentile": 0.13426}, "CVE-2025-59035": {"epss_score": 0.00065, "epss_percentile": 0.20559}, "CVE-2025-59036": {"epss_score": 0.00049, "epss_percentile": 0.15506}, "CVE-2025-59037": {"epss_score": 0.00062, "epss_percentile": 0.19695}, "CVE-2025-59038": {"epss_score": 0.00066, "epss_percentile": 0.20697}, "CVE-2025-59039": {"epss_score": 0.00066, "epss_percentile": 0.20697}, "CVE-2025-59040": {"epss_score": 0.0003, "epss_percentile": 0.08166}, "CVE-2025-59041": {"epss_score": 0.00122, "epss_percentile": 0.32156}, "CVE-2025-59042": {"epss_score": 0.0002, "epss_percentile": 0.04427}, "CVE-2025-59043": {"epss_score": 0.00133, "epss_percentile": 0.33634}, "CVE-2025-59044": {"epss_score": 0.00017, "epss_percentile": 0.03114}, "CVE-2025-59045": {"epss_score": 0.00067, "epss_percentile": 0.21135}, "CVE-2025-59046": {"epss_score": 0.00411, "epss_percentile": 0.60886}, "CVE-2025-59047": {"epss_score": 0.00063, "epss_percentile": 0.20077}, "CVE-2025-59048": {"epss_score": 0.00055, "epss_percentile": 0.1749}, "CVE-2025-59049": {"epss_score": 0.04865, "epss_percentile": 0.89228}, "CVE-2025-59050": {"epss_score": 0.0016, "epss_percentile": 0.37513}, "CVE-2025-59051": {"epss_score": 0.00205, "epss_percentile": 0.42683}, "CVE-2025-59052": {"epss_score": 0.00046, "epss_percentile": 0.14346}, "CVE-2025-59053": {"epss_score": 0.00059, "epss_percentile": 0.18858}, "CVE-2025-59054": {"epss_score": 0.00014, "epss_percentile": 0.01867}, "CVE-2025-59055": {"epss_score": 0.00186, "epss_percentile": 0.40629}, "CVE-2025-59056": {"epss_score": 0.0011, "epss_percentile": 0.302}, "CVE-2025-59058": {"epss_score": 0.00043, "epss_percentile": 0.13204}, "CVE-2025-59088": {"epss_score": 0.00062, "epss_percentile": 0.19634}, "CVE-2025-59089": {"epss_score": 0.00084, "epss_percentile": 0.24925}, "CVE-2025-59110": {"epss_score": 0.00017, "epss_percentile": 0.0319}, "CVE-2025-59111": {"epss_score": 0.00048, "epss_percentile": 0.15177}, "CVE-2025-59112": {"epss_score": 0.00017, "epss_percentile": 0.03303}, "CVE-2025-59113": {"epss_score": 0.0004, "epss_percentile": 0.1204}, "CVE-2025-59114": {"epss_score": 0.00017, "epss_percentile": 0.03303}, "CVE-2025-59115": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-59116": {"epss_score": 0.00039, "epss_percentile": 0.11732}, "CVE-2025-59117": {"epss_score": 0.00031, "epss_percentile": 0.08681}, "CVE-2025-59118": {"epss_score": 0.00161, "epss_percentile": 0.37533}, "CVE-2025-59129": {"epss_score": 0.00036, "epss_percentile": 0.10327}, "CVE-2025-59130": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-59131": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-59132": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-59134": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-59135": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-59136": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-59137": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-59138": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-59139": {"epss_score": 0.00061, "epss_percentile": 0.19449}, "CVE-2025-59140": {"epss_score": 0.00071, "epss_percentile": 0.22008}, "CVE-2025-59141": {"epss_score": 0.00071, "epss_percentile": 0.22008}, "CVE-2025-59142": {"epss_score": 0.00071, "epss_percentile": 0.22008}, "CVE-2025-59143": {"epss_score": 0.00071, "epss_percentile": 0.22008}, "CVE-2025-59144": {"epss_score": 0.00071, "epss_percentile": 0.22008}, "CVE-2025-59145": {"epss_score": 0.00071, "epss_percentile": 0.22008}, "CVE-2025-59146": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-59147": {"epss_score": 0.00043, "epss_percentile": 0.13179}, "CVE-2025-59148": {"epss_score": 0.00067, "epss_percentile": 0.21157}, "CVE-2025-59149": {"epss_score": 0.00016, "epss_percentile": 0.02984}, "CVE-2025-59150": {"epss_score": 0.00116, "epss_percentile": 0.31186}, "CVE-2025-59151": {"epss_score": 0.00073, "epss_percentile": 0.22494}, "CVE-2025-59152": {"epss_score": 0.00074, "epss_percentile": 0.22853}, "CVE-2025-59154": {"epss_score": 0.00038, "epss_percentile": 0.11324}, "CVE-2025-59155": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-59156": {"epss_score": 0.00171, "epss_percentile": 0.38893}, "CVE-2025-59157": {"epss_score": 0.00205, "epss_percentile": 0.42687}, "CVE-2025-59158": {"epss_score": 0.00042, "epss_percentile": 0.12629}, "CVE-2025-59159": {"epss_score": 0.00024, "epss_percentile": 0.05973}, "CVE-2025-59160": {"epss_score": 0.00073, "epss_percentile": 0.22523}, "CVE-2025-59161": {"epss_score": 0.00271, "epss_percentile": 0.503}, "CVE-2025-59162": {"epss_score": 0.00071, "epss_percentile": 0.22008}, "CVE-2025-59163": {"epss_score": 0.00203, "epss_percentile": 0.42506}, "CVE-2025-59171": {"epss_score": 0.00106, "epss_percentile": 0.29484}, "CVE-2025-59184": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-59185": {"epss_score": 0.00112, "epss_percentile": 0.30509}, "CVE-2025-59186": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-59187": {"epss_score": 0.001, "epss_percentile": 0.28504}, "CVE-2025-59188": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-59189": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-59190": {"epss_score": 0.00111, "epss_percentile": 0.30339}, "CVE-2025-59191": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-59192": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-59193": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-59194": {"epss_score": 0.00202, "epss_percentile": 0.42471}, "CVE-2025-59195": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-59196": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-59197": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-59198": {"epss_score": 0.00083, "epss_percentile": 0.24757}, "CVE-2025-59199": {"epss_score": 0.00081, "epss_percentile": 0.24368}, "CVE-2025-59200": {"epss_score": 0.00073, "epss_percentile": 0.22525}, "CVE-2025-59201": {"epss_score": 0.00061, "epss_percentile": 0.19244}, "CVE-2025-59202": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-59203": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-59204": {"epss_score": 0.0014, "epss_percentile": 0.34766}, "CVE-2025-59205": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-59206": {"epss_score": 0.00061, "epss_percentile": 0.19343}, "CVE-2025-59207": {"epss_score": 0.001, "epss_percentile": 0.28504}, "CVE-2025-59208": {"epss_score": 0.00065, "epss_percentile": 0.20497}, "CVE-2025-59209": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-59210": {"epss_score": 0.00061, "epss_percentile": 0.19343}, "CVE-2025-59211": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-59213": {"epss_score": 0.0007, "epss_percentile": 0.21766}, "CVE-2025-59214": {"epss_score": 0.00125, "epss_percentile": 0.32601}, "CVE-2025-59215": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-59216": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-59218": {"epss_score": 0.00078, "epss_percentile": 0.23789}, "CVE-2025-59220": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-59221": {"epss_score": 0.00102, "epss_percentile": 0.28767}, "CVE-2025-59222": {"epss_score": 0.00111, "epss_percentile": 0.30319}, "CVE-2025-59223": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-59224": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-59225": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-59226": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-59227": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-59228": {"epss_score": 0.00164, "epss_percentile": 0.37893}, "CVE-2025-59229": {"epss_score": 0.00055, "epss_percentile": 0.17597}, "CVE-2025-59230": {"epss_score": 0.09525, "epss_percentile": 0.92586}, "CVE-2025-59231": {"epss_score": 0.00149, "epss_percentile": 0.36002}, "CVE-2025-59232": {"epss_score": 0.00098, "epss_percentile": 0.27808}, "CVE-2025-59233": {"epss_score": 0.00149, "epss_percentile": 0.36002}, "CVE-2025-59234": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-59235": {"epss_score": 0.00098, "epss_percentile": 0.27808}, "CVE-2025-59236": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-59237": {"epss_score": 0.02966, "epss_percentile": 0.86082}, "CVE-2025-59238": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-59240": {"epss_score": 0.00042, "epss_percentile": 0.12701}, "CVE-2025-59241": {"epss_score": 0.001, "epss_percentile": 0.28474}, "CVE-2025-59242": {"epss_score": 0.0009, "epss_percentile": 0.2614}, "CVE-2025-59243": {"epss_score": 0.00079, "epss_percentile": 0.23887}, "CVE-2025-59244": {"epss_score": 0.00112, "epss_percentile": 0.30509}, "CVE-2025-59245": {"epss_score": 0.00589, "epss_percentile": 0.68521}, "CVE-2025-59246": {"epss_score": 0.00107, "epss_percentile": 0.29673}, "CVE-2025-59247": {"epss_score": 0.00134, "epss_percentile": 0.33919}, "CVE-2025-59248": {"epss_score": 0.00202, "epss_percentile": 0.42392}, "CVE-2025-59249": {"epss_score": 0.00095, "epss_percentile": 0.27159}, "CVE-2025-59250": {"epss_score": 0.00145, "epss_percentile": 0.35513}, "CVE-2025-59251": {"epss_score": 0.00083, "epss_percentile": 0.24751}, "CVE-2025-59252": {"epss_score": 0.00089, "epss_percentile": 0.25916}, "CVE-2025-59253": {"epss_score": 0.00052, "epss_percentile": 0.16438}, "CVE-2025-59254": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-59255": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-59257": {"epss_score": 0.00231, "epss_percentile": 0.45853}, "CVE-2025-59258": {"epss_score": 0.00078, "epss_percentile": 0.23601}, "CVE-2025-59259": {"epss_score": 0.00231, "epss_percentile": 0.45853}, "CVE-2025-59260": {"epss_score": 0.00077, "epss_percentile": 0.23426}, "CVE-2025-59261": {"epss_score": 0.00047, "epss_percentile": 0.1461}, "CVE-2025-59268": {"epss_score": 0.00082, "epss_percentile": 0.24557}, "CVE-2025-59269": {"epss_score": 0.00076, "epss_percentile": 0.23082}, "CVE-2025-59270": {"epss_score": 0.00033, "epss_percentile": 0.09128}, "CVE-2025-59271": {"epss_score": 0.00076, "epss_percentile": 0.23282}, "CVE-2025-59272": {"epss_score": 0.00089, "epss_percentile": 0.25916}, "CVE-2025-59273": {"epss_score": 0.00103, "epss_percentile": 0.29012}, "CVE-2025-59275": {"epss_score": 0.001, "epss_percentile": 0.28504}, "CVE-2025-59277": {"epss_score": 0.001, "epss_percentile": 0.28504}, "CVE-2025-59278": {"epss_score": 0.001, "epss_percentile": 0.28504}, "CVE-2025-59280": {"epss_score": 0.00055, "epss_percentile": 0.1752}, "CVE-2025-59281": {"epss_score": 0.001, "epss_percentile": 0.28474}, "CVE-2025-59282": {"epss_score": 0.00056, "epss_percentile": 0.17834}, "CVE-2025-59284": {"epss_score": 0.0006, "epss_percentile": 0.19145}, "CVE-2025-59285": {"epss_score": 0.00969, "epss_percentile": 0.76096}, "CVE-2025-59286": {"epss_score": 0.00089, "epss_percentile": 0.25916}, "CVE-2025-59287": {"epss_score": 0.74662, "epss_percentile": 0.98812}, "CVE-2025-59288": {"epss_score": 0.00042, "epss_percentile": 0.12888}, "CVE-2025-59289": {"epss_score": 0.0006, "epss_percentile": 0.19191}, "CVE-2025-59290": {"epss_score": 0.00066, "epss_percentile": 0.20729}, "CVE-2025-59291": {"epss_score": 0.00133, "epss_percentile": 0.33648}, "CVE-2025-59292": {"epss_score": 0.00133, "epss_percentile": 0.33648}, "CVE-2025-59294": {"epss_score": 0.00077, "epss_percentile": 0.23427}, "CVE-2025-59295": {"epss_score": 0.00385, "epss_percentile": 0.59183}, "CVE-2025-59297": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-59298": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-59299": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-59300": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-59301": {"epss_score": 0.00018, "epss_percentile": 0.0362}, "CVE-2025-59302": {"epss_score": 0.00088, "epss_percentile": 0.25716}, "CVE-2025-59303": {"epss_score": 2e-05, "epss_percentile": 0.00021}, "CVE-2025-59304": {"epss_score": 0.07461, "epss_percentile": 0.91485}, "CVE-2025-59305": {"epss_score": 0.00057, "epss_percentile": 0.18206}, "CVE-2025-59307": {"epss_score": 0.00022, "epss_percentile": 0.05229}, "CVE-2025-59328": {"epss_score": 0.01174, "epss_percentile": 0.78249}, "CVE-2025-59330": {"epss_score": 0.00071, "epss_percentile": 0.22008}, "CVE-2025-59331": {"epss_score": 0.00071, "epss_percentile": 0.22008}, "CVE-2025-59332": {"epss_score": 0.0007, "epss_percentile": 0.21645}, "CVE-2025-59333": {"epss_score": 0.00057, "epss_percentile": 0.18219}, "CVE-2025-59334": {"epss_score": 0.00079, "epss_percentile": 0.23867}, "CVE-2025-59335": {"epss_score": 0.00015, "epss_percentile": 0.0255}, "CVE-2025-59336": {"epss_score": 0.00088, "epss_percentile": 0.2575}, "CVE-2025-59337": {"epss_score": 0.00064, "epss_percentile": 0.20148}, "CVE-2025-59339": {"epss_score": 0.0001, "epss_percentile": 0.00882}, "CVE-2025-59340": {"epss_score": 0.00445, "epss_percentile": 0.62865}, "CVE-2025-59341": {"epss_score": 0.00094, "epss_percentile": 0.26799}, "CVE-2025-59342": {"epss_score": 0.00711, "epss_percentile": 0.71728}, "CVE-2025-59343": {"epss_score": 0.00024, "epss_percentile": 0.0567}, "CVE-2025-59344": {"epss_score": 0.00042, "epss_percentile": 0.12567}, "CVE-2025-59345": {"epss_score": 0.00089, "epss_percentile": 0.2595}, "CVE-2025-59346": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-59347": {"epss_score": 0.00044, "epss_percentile": 0.13489}, "CVE-2025-59348": {"epss_score": 0.0006, "epss_percentile": 0.19004}, "CVE-2025-59349": {"epss_score": 0.00018, "epss_percentile": 0.03928}, "CVE-2025-59350": {"epss_score": 0.00067, "epss_percentile": 0.2106}, "CVE-2025-59351": {"epss_score": 0.0005, "epss_percentile": 0.15768}, "CVE-2025-59352": {"epss_score": 0.00641, "epss_percentile": 0.69984}, "CVE-2025-59353": {"epss_score": 0.00051, "epss_percentile": 0.16131}, "CVE-2025-59354": {"epss_score": 0.00018, "epss_percentile": 0.03885}, "CVE-2025-59358": {"epss_score": 0.00214, "epss_percentile": 0.43984}, "CVE-2025-59359": {"epss_score": 0.00822, "epss_percentile": 0.73911}, "CVE-2025-59360": {"epss_score": 0.00602, "epss_percentile": 0.6889}, "CVE-2025-59361": {"epss_score": 0.00602, "epss_percentile": 0.6889}, "CVE-2025-59362": {"epss_score": 0.00089, "epss_percentile": 0.25983}, "CVE-2025-59363": {"epss_score": 0.00046, "epss_percentile": 0.14136}, "CVE-2025-59364": {"epss_score": 0.00018, "epss_percentile": 0.03651}, "CVE-2025-59365": {"epss_score": 0.00052, "epss_percentile": 0.16649}, "CVE-2025-59366": {"epss_score": 0.00184, "epss_percentile": 0.40403}, "CVE-2025-59367": {"epss_score": 0.00235, "epss_percentile": 0.46322}, "CVE-2025-59368": {"epss_score": 0.00051, "epss_percentile": 0.16215}, "CVE-2025-59369": {"epss_score": 0.00138, "epss_percentile": 0.34531}, "CVE-2025-59370": {"epss_score": 0.00715, "epss_percentile": 0.71847}, "CVE-2025-59371": {"epss_score": 0.00215, "epss_percentile": 0.44104}, "CVE-2025-59372": {"epss_score": 0.00221, "epss_percentile": 0.44662}, "CVE-2025-59373": {"epss_score": 0.00017, "epss_percentile": 0.03196}, "CVE-2025-59374": {"epss_score": 0.35959, "epss_percentile": 0.96943}, "CVE-2025-59375": {"epss_score": 0.00131, "epss_percentile": 0.33379}, "CVE-2025-59376": {"epss_score": 0.00014, "epss_percentile": 0.02045}, "CVE-2025-59377": {"epss_score": 0.00053, "epss_percentile": 0.1702}, "CVE-2025-59378": {"epss_score": 0.00018, "epss_percentile": 0.0362}, "CVE-2025-59379": {"epss_score": 0.00033, "epss_percentile": 0.09384}, "CVE-2025-59380": {"epss_score": 0.00064, "epss_percentile": 0.20143}, "CVE-2025-59381": {"epss_score": 0.00064, "epss_percentile": 0.20143}, "CVE-2025-59384": {"epss_score": 0.00237, "epss_percentile": 0.4664}, "CVE-2025-59385": {"epss_score": 0.00671, "epss_percentile": 0.70798}, "CVE-2025-59387": {"epss_score": 0.00139, "epss_percentile": 0.3457}, "CVE-2025-59389": {"epss_score": 0.00139, "epss_percentile": 0.3457}, "CVE-2025-59390": {"epss_score": 0.00098, "epss_percentile": 0.27709}, "CVE-2025-59391": {"epss_score": 0.00038, "epss_percentile": 0.11318}, "CVE-2025-59392": {"epss_score": 0.00026, "epss_percentile": 0.06453}, "CVE-2025-59397": {"epss_score": 0.00043, "epss_percentile": 0.13209}, "CVE-2025-59398": {"epss_score": 0.00025, "epss_percentile": 0.06124}, "CVE-2025-59399": {"epss_score": 0.00029, "epss_percentile": 0.07952}, "CVE-2025-59402": {"epss_score": 0.00028, "epss_percentile": 0.07351}, "CVE-2025-59403": {"epss_score": 0.04192, "epss_percentile": 0.88378}, "CVE-2025-59404": {"epss_score": 0.00056, "epss_percentile": 0.17723}, "CVE-2025-59405": {"epss_score": 0.0006, "epss_percentile": 0.19229}, "CVE-2025-59406": {"epss_score": 0.00012, "epss_percentile": 0.01291}, "CVE-2025-59407": {"epss_score": 0.00084, "epss_percentile": 0.24978}, "CVE-2025-59408": {"epss_score": 0.00032, "epss_percentile": 0.08782}, "CVE-2025-59409": {"epss_score": 0.00025, "epss_percentile": 0.06139}, "CVE-2025-59410": {"epss_score": 0.00018, "epss_percentile": 0.03885}, "CVE-2025-59411": {"epss_score": 0.00043, "epss_percentile": 0.13222}, "CVE-2025-59412": {"epss_score": 0.0004, "epss_percentile": 0.12097}, "CVE-2025-59413": {"epss_score": 0.00069, "epss_percentile": 0.21488}, "CVE-2025-59414": {"epss_score": 0.00048, "epss_percentile": 0.15114}, "CVE-2025-59415": {"epss_score": 0.00046, "epss_percentile": 0.14358}, "CVE-2025-59416": {"epss_score": 0.00058, "epss_percentile": 0.18279}, "CVE-2025-59417": {"epss_score": 0.00109, "epss_percentile": 0.29946}, "CVE-2025-59418": {"epss_score": 0.00018, "epss_percentile": 0.03624}, "CVE-2025-59419": {"epss_score": 0.03365, "epss_percentile": 0.87}, "CVE-2025-59420": {"epss_score": 0.00034, "epss_percentile": 0.09693}, "CVE-2025-59421": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-59422": {"epss_score": 0.0004, "epss_percentile": 0.11882}, "CVE-2025-59424": {"epss_score": 0.00046, "epss_percentile": 0.14087}, "CVE-2025-59425": {"epss_score": 0.00455, "epss_percentile": 0.63281}, "CVE-2025-59426": {"epss_score": 0.00067, "epss_percentile": 0.21093}, "CVE-2025-59427": {"epss_score": 0.00063, "epss_percentile": 0.20077}, "CVE-2025-59428": {"epss_score": 0.0002, "epss_percentile": 0.04468}, "CVE-2025-59429": {"epss_score": 0.00223, "epss_percentile": 0.44845}, "CVE-2025-59430": {"epss_score": 0.00048, "epss_percentile": 0.15127}, "CVE-2025-59431": {"epss_score": 0.00046, "epss_percentile": 0.14288}, "CVE-2025-59432": {"epss_score": 0.00191, "epss_percentile": 0.41203}, "CVE-2025-59433": {"epss_score": 0.00043, "epss_percentile": 0.13007}, "CVE-2025-59434": {"epss_score": 0.00058, "epss_percentile": 0.1837}, "CVE-2025-59436": {"epss_score": 0.00018, "epss_percentile": 0.03757}, "CVE-2025-59437": {"epss_score": 0.00018, "epss_percentile": 0.03757}, "CVE-2025-59438": {"epss_score": 0.00038, "epss_percentile": 0.11143}, "CVE-2025-59447": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-59448": {"epss_score": 0.0001, "epss_percentile": 0.00845}, "CVE-2025-59449": {"epss_score": 0.0004, "epss_percentile": 0.11866}, "CVE-2025-59450": {"epss_score": 7e-05, "epss_percentile": 0.00395}, "CVE-2025-59451": {"epss_score": 0.0004, "epss_percentile": 0.11868}, "CVE-2025-59452": {"epss_score": 0.00043, "epss_percentile": 0.13288}, "CVE-2025-59453": {"epss_score": 0.00023, "epss_percentile": 0.05508}, "CVE-2025-59454": {"epss_score": 0.00106, "epss_percentile": 0.2949}, "CVE-2025-59455": {"epss_score": 2e-05, "epss_percentile": 0.0003}, "CVE-2025-59456": {"epss_score": 3e-05, "epss_percentile": 0.00094}, "CVE-2025-59457": {"epss_score": 2e-05, "epss_percentile": 0.00032}, "CVE-2025-59458": {"epss_score": 2e-05, "epss_percentile": 0.0006}, "CVE-2025-59459": {"epss_score": 0.00032, "epss_percentile": 0.09109}, "CVE-2025-59460": {"epss_score": 0.00058, "epss_percentile": 0.1843}, "CVE-2025-59461": {"epss_score": 0.00201, "epss_percentile": 0.42319}, "CVE-2025-59462": {"epss_score": 0.00118, "epss_percentile": 0.31419}, "CVE-2025-59463": {"epss_score": 0.00091, "epss_percentile": 0.26271}, "CVE-2025-59467": {"epss_score": 0.00041, "epss_percentile": 0.12411}, "CVE-2025-59474": {"epss_score": 0.0032, "epss_percentile": 0.54587}, "CVE-2025-59475": {"epss_score": 0.00031, "epss_percentile": 0.08508}, "CVE-2025-59476": {"epss_score": 0.00094, "epss_percentile": 0.26774}, "CVE-2025-59478": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-59479": {"epss_score": 0.00031, "epss_percentile": 0.08317}, "CVE-2025-59480": {"epss_score": 0.00018, "epss_percentile": 0.03895}, "CVE-2025-59481": {"epss_score": 0.00082, "epss_percentile": 0.24533}, "CVE-2025-59483": {"epss_score": 0.0008, "epss_percentile": 0.24117}, "CVE-2025-59484": {"epss_score": 0.00013, "epss_percentile": 0.01454}, "CVE-2025-59485": {"epss_score": 0.00013, "epss_percentile": 0.01579}, "CVE-2025-59489": {"epss_score": 0.00027, "epss_percentile": 0.06899}, "CVE-2025-59491": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-59494": {"epss_score": 0.00061, "epss_percentile": 0.19244}, "CVE-2025-59497": {"epss_score": 0.00041, "epss_percentile": 0.12456}, "CVE-2025-59499": {"epss_score": 0.00098, "epss_percentile": 0.27635}, "CVE-2025-59500": {"epss_score": 0.00075, "epss_percentile": 0.23028}, "CVE-2025-59501": {"epss_score": 0.00285, "epss_percentile": 0.51676}, "CVE-2025-59502": {"epss_score": 0.09379, "epss_percentile": 0.92523}, "CVE-2025-59503": {"epss_score": 0.0008, "epss_percentile": 0.24017}, "CVE-2025-59504": {"epss_score": 0.00058, "epss_percentile": 0.18572}, "CVE-2025-59505": {"epss_score": 0.00057, "epss_percentile": 0.18001}, "CVE-2025-59506": {"epss_score": 0.00047, "epss_percentile": 0.147}, "CVE-2025-59507": {"epss_score": 0.00047, "epss_percentile": 0.147}, "CVE-2025-59508": {"epss_score": 0.00047, "epss_percentile": 0.147}, "CVE-2025-59509": {"epss_score": 0.0005, "epss_percentile": 0.15944}, "CVE-2025-59510": {"epss_score": 0.00059, "epss_percentile": 0.18921}, "CVE-2025-59511": {"epss_score": 0.00114, "epss_percentile": 0.30851}, "CVE-2025-59512": {"epss_score": 0.0008, "epss_percentile": 0.24168}, "CVE-2025-59513": {"epss_score": 0.00048, "epss_percentile": 0.15278}, "CVE-2025-59514": {"epss_score": 0.00052, "epss_percentile": 0.16559}, "CVE-2025-59515": {"epss_score": 0.00052, "epss_percentile": 0.16497}, "CVE-2025-59516": {"epss_score": 0.00123, "epss_percentile": 0.32223}, "CVE-2025-59517": {"epss_score": 0.00061, "epss_percentile": 0.19335}, "CVE-2025-59518": {"epss_score": 0.0017, "epss_percentile": 0.38762}, "CVE-2025-59524": {"epss_score": 0.00049, "epss_percentile": 0.15459}, "CVE-2025-59525": {"epss_score": 0.00052, "epss_percentile": 0.16531}, "CVE-2025-59526": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-59527": {"epss_score": 0.00069, "epss_percentile": 0.21502}, "CVE-2025-59528": {"epss_score": 0.83159, "epss_percentile": 0.99234}, "CVE-2025-59529": {"epss_score": 0.00013, "epss_percentile": 0.01648}, "CVE-2025-59530": {"epss_score": 0.00114, "epss_percentile": 0.30755}, "CVE-2025-59531": {"epss_score": 0.00085, "epss_percentile": 0.25129}, "CVE-2025-59532": {"epss_score": 0.00061, "epss_percentile": 0.19523}, "CVE-2025-59534": {"epss_score": 0.00037, "epss_percentile": 0.10989}, "CVE-2025-59535": {"epss_score": 0.00117, "epss_percentile": 0.31284}, "CVE-2025-59536": {"epss_score": 0.00073, "epss_percentile": 0.22545}, "CVE-2025-59537": {"epss_score": 0.00142, "epss_percentile": 0.35016}, "CVE-2025-59538": {"epss_score": 0.00081, "epss_percentile": 0.24284}, "CVE-2025-59539": {"epss_score": 0.00041, "epss_percentile": 0.12229}, "CVE-2025-59545": {"epss_score": 0.00066, "epss_percentile": 0.20758}, "CVE-2025-59546": {"epss_score": 0.00038, "epss_percentile": 0.11057}, "CVE-2025-59547": {"epss_score": 0.00056, "epss_percentile": 0.17672}, "CVE-2025-59548": {"epss_score": 0.00037, "epss_percentile": 0.10791}, "CVE-2025-59549": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59550": {"epss_score": 0.00172, "epss_percentile": 0.38969}, "CVE-2025-59551": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-59552": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59553": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59555": {"epss_score": 0.00172, "epss_percentile": 0.38969}, "CVE-2025-59556": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-59557": {"epss_score": 0.00053, "epss_percentile": 0.1673}, "CVE-2025-59558": {"epss_score": 0.00172, "epss_percentile": 0.38969}, "CVE-2025-59559": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-59561": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-59562": {"epss_score": 0.00048, "epss_percentile": 0.151}, "CVE-2025-59564": {"epss_score": 0.00172, "epss_percentile": 0.38969}, "CVE-2025-59565": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59566": {"epss_score": 0.00092, "epss_percentile": 0.26455}, "CVE-2025-59567": {"epss_score": 0.00047, "epss_percentile": 0.14623}, "CVE-2025-59568": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-59569": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59570": {"epss_score": 0.00041, "epss_percentile": 0.12284}, "CVE-2025-59571": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-59572": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-59573": {"epss_score": 0.00058, "epss_percentile": 0.18453}, "CVE-2025-59574": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59575": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-59576": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-59577": {"epss_score": 0.0005, "epss_percentile": 0.15739}, "CVE-2025-59578": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-59579": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-59580": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-59581": {"epss_score": 0.00055, "epss_percentile": 0.17369}, "CVE-2025-59582": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-59583": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59584": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59585": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59586": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59587": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59588": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-59589": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59590": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-59591": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-59592": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-59593": {"epss_score": 0.00048, "epss_percentile": 0.15196}, "CVE-2025-59595": {"epss_score": 0.00049, "epss_percentile": 0.15651}, "CVE-2025-59596": {"epss_score": 0.00021, "epss_percentile": 0.04835}, "CVE-2025-59668": {"epss_score": 0.00068, "epss_percentile": 0.21213}, "CVE-2025-59669": {"epss_score": 0.00015, "epss_percentile": 0.02311}, "CVE-2025-59681": {"epss_score": 0.0002, "epss_percentile": 0.0443}, "CVE-2025-59682": {"epss_score": 0.00036, "epss_percentile": 0.10547}, "CVE-2025-59683": {"epss_score": 0.00136, "epss_percentile": 0.34137}, "CVE-2025-59684": {"epss_score": 0.00063, "epss_percentile": 0.20071}, "CVE-2025-59685": {"epss_score": 0.00013, "epss_percentile": 0.01666}, "CVE-2025-59686": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2025-59687": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-59689": {"epss_score": 0.11361, "epss_percentile": 0.93324}, "CVE-2025-59691": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-59692": {"epss_score": 0.00043, "epss_percentile": 0.13204}, "CVE-2025-59693": {"epss_score": 0.00056, "epss_percentile": 0.1783}, "CVE-2025-59694": {"epss_score": 0.00024, "epss_percentile": 0.06}, "CVE-2025-59695": {"epss_score": 0.00103, "epss_percentile": 0.289}, "CVE-2025-59696": {"epss_score": 0.00016, "epss_percentile": 0.02941}, "CVE-2025-59697": {"epss_score": 0.00021, "epss_percentile": 0.04881}, "CVE-2025-59698": {"epss_score": 0.00024, "epss_percentile": 0.06}, "CVE-2025-59699": {"epss_score": 0.00024, "epss_percentile": 0.06}, "CVE-2025-59700": {"epss_score": 7e-05, "epss_percentile": 0.00331}, "CVE-2025-59701": {"epss_score": 9e-05, "epss_percentile": 0.00651}, "CVE-2025-59702": {"epss_score": 0.00021, "epss_percentile": 0.04881}, "CVE-2025-59703": {"epss_score": 0.0004, "epss_percentile": 0.12186}, "CVE-2025-59704": {"epss_score": 0.00013, "epss_percentile": 0.01671}, "CVE-2025-59705": {"epss_score": 0.00024, "epss_percentile": 0.06}, "CVE-2025-59712": {"epss_score": 0.00013, "epss_percentile": 0.01586}, "CVE-2025-59713": {"epss_score": 0.00022, "epss_percentile": 0.05195}, "CVE-2025-59714": {"epss_score": 0.00041, "epss_percentile": 0.12338}, "CVE-2025-59715": {"epss_score": 0.00037, "epss_percentile": 0.10892}, "CVE-2025-59716": {"epss_score": 0.00048, "epss_percentile": 0.15142}, "CVE-2025-59717": {"epss_score": 0.00059, "epss_percentile": 0.18878}, "CVE-2025-59718": {"epss_score": 0.05281, "epss_percentile": 0.89688}, "CVE-2025-59719": {"epss_score": 0.00056, "epss_percentile": 0.17719}, "CVE-2025-59728": {"epss_score": 0.0003, "epss_percentile": 0.08153}, "CVE-2025-59729": {"epss_score": 0.00034, "epss_percentile": 0.09729}, "CVE-2025-59730": {"epss_score": 0.0003, "epss_percentile": 0.08153}, "CVE-2025-59731": {"epss_score": 0.0003, "epss_percentile": 0.08153}, "CVE-2025-59732": {"epss_score": 0.00022, "epss_percentile": 0.05248}, "CVE-2025-59733": {"epss_score": 0.00026, "epss_percentile": 0.06384}, "CVE-2025-59734": {"epss_score": 0.00022, "epss_percentile": 0.05248}, "CVE-2025-59735": {"epss_score": 0.00392, "epss_percentile": 0.5969}, "CVE-2025-59736": {"epss_score": 0.00392, "epss_percentile": 0.5969}, "CVE-2025-59737": {"epss_score": 0.00392, "epss_percentile": 0.5969}, "CVE-2025-59738": {"epss_score": 0.00392, "epss_percentile": 0.5969}, "CVE-2025-59739": {"epss_score": 0.00392, "epss_percentile": 0.5969}, "CVE-2025-59740": {"epss_score": 0.00392, "epss_percentile": 0.5969}, "CVE-2025-59741": {"epss_score": 0.00392, "epss_percentile": 0.5969}, "CVE-2025-59742": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-59743": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-59744": {"epss_score": 0.00065, "epss_percentile": 0.20513}, "CVE-2025-59745": {"epss_score": 0.00019, "epss_percentile": 0.04399}, "CVE-2025-59746": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59747": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59748": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59749": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59750": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59751": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59752": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59753": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59754": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59755": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59756": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59757": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59758": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59759": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59760": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59761": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59762": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59763": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59764": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59765": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59766": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59767": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59768": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59769": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59770": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59771": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59772": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59773": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59774": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-59775": {"epss_score": 0.00123, "epss_percentile": 0.322}, "CVE-2025-59776": {"epss_score": 0.00114, "epss_percentile": 0.30811}, "CVE-2025-59777": {"epss_score": 0.00049, "epss_percentile": 0.15635}, "CVE-2025-59778": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-59780": {"epss_score": 0.00074, "epss_percentile": 0.22705}, "CVE-2025-59781": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-59788": {"epss_score": 0.00021, "epss_percentile": 0.04814}, "CVE-2025-59789": {"epss_score": 0.00707, "epss_percentile": 0.71659}, "CVE-2025-59790": {"epss_score": 0.00177, "epss_percentile": 0.39569}, "CVE-2025-59792": {"epss_score": 0.00055, "epss_percentile": 0.17372}, "CVE-2025-59797": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-59798": {"epss_score": 0.00015, "epss_percentile": 0.02486}, "CVE-2025-59799": {"epss_score": 0.00015, "epss_percentile": 0.02486}, "CVE-2025-59800": {"epss_score": 0.00017, "epss_percentile": 0.03204}, "CVE-2025-59801": {"epss_score": 0.00019, "epss_percentile": 0.04051}, "CVE-2025-59802": {"epss_score": 0.00039, "epss_percentile": 0.11559}, "CVE-2025-59803": {"epss_score": 0.00017, "epss_percentile": 0.03312}, "CVE-2025-59808": {"epss_score": 0.00046, "epss_percentile": 0.14296}, "CVE-2025-59810": {"epss_score": 0.00046, "epss_percentile": 0.14323}, "CVE-2025-59814": {"epss_score": 0.00081, "epss_percentile": 0.24372}, "CVE-2025-59815": {"epss_score": 0.00061, "epss_percentile": 0.19307}, "CVE-2025-59816": {"epss_score": 0.00096, "epss_percentile": 0.27261}, "CVE-2025-59817": {"epss_score": 0.00045, "epss_percentile": 0.13827}, "CVE-2025-59820": {"epss_score": 0.00028, "epss_percentile": 0.07351}, "CVE-2025-59821": {"epss_score": 0.00044, "epss_percentile": 0.13446}, "CVE-2025-59822": {"epss_score": 0.00058, "epss_percentile": 0.18548}, "CVE-2025-59823": {"epss_score": 0.00097, "epss_percentile": 0.27576}, "CVE-2025-59824": {"epss_score": 0.00036, "epss_percentile": 0.10493}, "CVE-2025-59825": {"epss_score": 0.00023, "epss_percentile": 0.05336}, "CVE-2025-59826": {"epss_score": 0.00053, "epss_percentile": 0.17009}, "CVE-2025-59827": {"epss_score": 0.00046, "epss_percentile": 0.14348}, "CVE-2025-59828": {"epss_score": 0.00062, "epss_percentile": 0.19687}, "CVE-2025-59829": {"epss_score": 0.00045, "epss_percentile": 0.13823}, "CVE-2025-59830": {"epss_score": 0.00067, "epss_percentile": 0.2097}, "CVE-2025-59831": {"epss_score": 0.00088, "epss_percentile": 0.25706}, "CVE-2025-59832": {"epss_score": 0.00071, "epss_percentile": 0.2222}, "CVE-2025-59833": {"epss_score": 0.00049, "epss_percentile": 0.15342}, "CVE-2025-59834": {"epss_score": 0.01002, "epss_percentile": 0.76506}, "CVE-2025-59835": {"epss_score": 0.0008, "epss_percentile": 0.24202}, "CVE-2025-59836": {"epss_score": 0.00213, "epss_percentile": 0.43889}, "CVE-2025-59837": {"epss_score": 0.00054, "epss_percentile": 0.17047}, "CVE-2025-59838": {"epss_score": 0.00034, "epss_percentile": 0.09742}, "CVE-2025-59839": {"epss_score": 0.00047, "epss_percentile": 0.14489}, "CVE-2025-59840": {"epss_score": 0.00048, "epss_percentile": 0.15074}, "CVE-2025-59841": {"epss_score": 0.00065, "epss_percentile": 0.20659}, "CVE-2025-59842": {"epss_score": 0.00038, "epss_percentile": 0.11388}, "CVE-2025-59843": {"epss_score": 0.00043, "epss_percentile": 0.13318}, "CVE-2025-59844": {"epss_score": 0.00435, "epss_percentile": 0.62329}, "CVE-2025-59845": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2025-59849": {"epss_score": 0.00067, "epss_percentile": 0.21082}, "CVE-2025-59886": {"epss_score": 0.0007, "epss_percentile": 0.21839}, "CVE-2025-59887": {"epss_score": 0.00024, "epss_percentile": 0.05687}, "CVE-2025-59888": {"epss_score": 0.00016, "epss_percentile": 0.02964}, "CVE-2025-59889": {"epss_score": 0.0003, "epss_percentile": 0.08052}, "CVE-2025-59890": {"epss_score": 0.00019, "epss_percentile": 0.04251}, "CVE-2025-59921": {"epss_score": 0.00213, "epss_percentile": 0.43908}, "CVE-2025-59923": {"epss_score": 0.00033, "epss_percentile": 0.0915}, "CVE-2025-59932": {"epss_score": 0.00061, "epss_percentile": 0.19542}, "CVE-2025-59933": {"epss_score": 0.00017, "epss_percentile": 0.03116}, "CVE-2025-59934": {"epss_score": 0.00012, "epss_percentile": 0.01158}, "CVE-2025-59935": {"epss_score": 0.00087, "epss_percentile": 0.2559}, "CVE-2025-59936": {"epss_score": 0.00067, "epss_percentile": 0.21186}, "CVE-2025-59937": {"epss_score": 0.0006, "epss_percentile": 0.1895}, "CVE-2025-59938": {"epss_score": 0.00082, "epss_percentile": 0.24515}, "CVE-2025-59939": {"epss_score": 0.00045, "epss_percentile": 0.14016}, "CVE-2025-59940": {"epss_score": 0.00087, "epss_percentile": 0.25479}, "CVE-2025-59941": {"epss_score": 0.00059, "epss_percentile": 0.18802}, "CVE-2025-59942": {"epss_score": 0.00063, "epss_percentile": 0.1994}, "CVE-2025-59943": {"epss_score": 0.00057, "epss_percentile": 0.17994}, "CVE-2025-59944": {"epss_score": 0.00182, "epss_percentile": 0.40137}, "CVE-2025-59945": {"epss_score": 0.00044, "epss_percentile": 0.13656}, "CVE-2025-59946": {"epss_score": 0.00047, "epss_percentile": 0.14894}, "CVE-2025-59947": {"epss_score": 0.00044, "epss_percentile": 0.13586}, "CVE-2025-59948": {"epss_score": 0.00064, "epss_percentile": 0.20282}, "CVE-2025-59949": {"epss_score": 0.00021, "epss_percentile": 0.0493}, "CVE-2025-59950": {"epss_score": 0.00038, "epss_percentile": 0.11328}, "CVE-2025-59951": {"epss_score": 0.00045, "epss_percentile": 0.13699}, "CVE-2025-59952": {"epss_score": 0.00142, "epss_percentile": 0.3502}, "CVE-2025-59954": {"epss_score": 0.00095, "epss_percentile": 0.27157}, "CVE-2025-59955": {"epss_score": 0.00042, "epss_percentile": 0.12629}, "CVE-2025-59956": {"epss_score": 0.00059, "epss_percentile": 0.18634}, "CVE-2025-59957": {"epss_score": 0.00012, "epss_percentile": 0.01206}, "CVE-2025-59958": {"epss_score": 0.00055, "epss_percentile": 0.1764}, "CVE-2025-59962": {"epss_score": 0.00021, "epss_percentile": 0.04815}, "CVE-2025-59964": {"epss_score": 0.00059, "epss_percentile": 0.18927}, "CVE-2025-59967": {"epss_score": 0.00021, "epss_percentile": 0.04886}, "CVE-2025-59968": {"epss_score": 0.00043, "epss_percentile": 0.13204}, "CVE-2025-59974": {"epss_score": 0.00052, "epss_percentile": 0.1634}, "CVE-2025-59975": {"epss_score": 0.00059, "epss_percentile": 0.18927}, "CVE-2025-59976": {"epss_score": 0.00046, "epss_percentile": 0.14136}, "CVE-2025-59978": {"epss_score": 0.00081, "epss_percentile": 0.24241}, "CVE-2025-59980": {"epss_score": 0.00049, "epss_percentile": 0.15566}, "CVE-2025-59981": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59982": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59983": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59984": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59985": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59986": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59987": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59988": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59989": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59990": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59991": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59992": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59993": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59994": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59995": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59996": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59997": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59998": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-59999": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-5000": {"epss_score": 0.00259, "epss_percentile": 0.49058}, "CVE-2025-5001": {"epss_score": 0.0003, "epss_percentile": 0.08087}, "CVE-2025-5002": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5003": {"epss_score": 0.00042, "epss_percentile": 0.12652}, "CVE-2025-5004": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-5005": {"epss_score": 0.00063, "epss_percentile": 0.19887}, "CVE-2025-5006": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-5007": {"epss_score": 0.00035, "epss_percentile": 0.09891}, "CVE-2025-5008": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-5009": {"epss_score": 9e-05, "epss_percentile": 0.00698}, "CVE-2025-5010": {"epss_score": 0.00086, "epss_percentile": 0.25434}, "CVE-2025-5011": {"epss_score": 0.00086, "epss_percentile": 0.25434}, "CVE-2025-5012": {"epss_score": 0.00278, "epss_percentile": 0.50863}, "CVE-2025-5013": {"epss_score": 0.00023, "epss_percentile": 0.0545}, "CVE-2025-5014": {"epss_score": 0.00555, "epss_percentile": 0.67471}, "CVE-2025-5015": {"epss_score": 0.00128, "epss_percentile": 0.33063}, "CVE-2025-5016": {"epss_score": 0.00081, "epss_percentile": 0.243}, "CVE-2025-5018": {"epss_score": 0.00041, "epss_percentile": 0.1221}, "CVE-2025-5019": {"epss_score": 0.00015, "epss_percentile": 0.02408}, "CVE-2025-5020": {"epss_score": 0.00031, "epss_percentile": 0.0839}, "CVE-2025-5022": {"epss_score": 0.00021, "epss_percentile": 0.04919}, "CVE-2025-5023": {"epss_score": 0.00017, "epss_percentile": 0.031}, "CVE-2025-5024": {"epss_score": 0.00126, "epss_percentile": 0.32759}, "CVE-2025-5025": {"epss_score": 0.00019, "epss_percentile": 0.0439}, "CVE-2025-5028": {"epss_score": 0.00017, "epss_percentile": 0.03403}, "CVE-2025-5029": {"epss_score": 0.00071, "epss_percentile": 0.21986}, "CVE-2025-5030": {"epss_score": 0.00069, "epss_percentile": 0.21575}, "CVE-2025-5031": {"epss_score": 0.00051, "epss_percentile": 0.1619}, "CVE-2025-5032": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5033": {"epss_score": 0.0004, "epss_percentile": 0.12195}, "CVE-2025-5034": {"epss_score": 0.0004, "epss_percentile": 0.12156}, "CVE-2025-5035": {"epss_score": 0.00026, "epss_percentile": 0.06434}, "CVE-2025-5036": {"epss_score": 0.00029, "epss_percentile": 0.07816}, "CVE-2025-5037": {"epss_score": 0.00028, "epss_percentile": 0.07341}, "CVE-2025-5038": {"epss_score": 0.00026, "epss_percentile": 0.06478}, "CVE-2025-5039": {"epss_score": 0.00025, "epss_percentile": 0.06114}, "CVE-2025-5040": {"epss_score": 0.00026, "epss_percentile": 0.06478}, "CVE-2025-5042": {"epss_score": 0.00026, "epss_percentile": 0.06478}, "CVE-2025-5043": {"epss_score": 0.00026, "epss_percentile": 0.06478}, "CVE-2025-5046": {"epss_score": 0.00041, "epss_percentile": 0.12298}, "CVE-2025-5047": {"epss_score": 0.00041, "epss_percentile": 0.12298}, "CVE-2025-5048": {"epss_score": 0.00041, "epss_percentile": 0.12298}, "CVE-2025-5049": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-5050": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-5051": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-5052": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-5053": {"epss_score": 0.00111, "epss_percentile": 0.30405}, "CVE-2025-5054": {"epss_score": 6e-05, "epss_percentile": 0.00272}, "CVE-2025-5055": {"epss_score": 0.00021, "epss_percentile": 0.04804}, "CVE-2025-5056": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5057": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-5058": {"epss_score": 0.01179, "epss_percentile": 0.78293}, "CVE-2025-5059": {"epss_score": 0.00072, "epss_percentile": 0.22427}, "CVE-2025-5060": {"epss_score": 0.00231, "epss_percentile": 0.45818}, "CVE-2025-5061": {"epss_score": 0.00184, "epss_percentile": 0.40374}, "CVE-2025-5062": {"epss_score": 0.00298, "epss_percentile": 0.52792}, "CVE-2025-5063": {"epss_score": 0.00168, "epss_percentile": 0.38519}, "CVE-2025-5064": {"epss_score": 0.00038, "epss_percentile": 0.1139}, "CVE-2025-5065": {"epss_score": 0.00037, "epss_percentile": 0.10915}, "CVE-2025-5066": {"epss_score": 0.00045, "epss_percentile": 0.13738}, "CVE-2025-5067": {"epss_score": 0.0002, "epss_percentile": 0.04482}, "CVE-2025-5068": {"epss_score": 0.00089, "epss_percentile": 0.25823}, "CVE-2025-5069": {"epss_score": 0.0001, "epss_percentile": 0.00871}, "CVE-2025-5071": {"epss_score": 0.00053, "epss_percentile": 0.16729}, "CVE-2025-5072": {"epss_score": 0.00055, "epss_percentile": 0.17644}, "CVE-2025-5073": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-5074": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-5075": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-5076": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-5077": {"epss_score": 0.00056, "epss_percentile": 0.1794}, "CVE-2025-5078": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5079": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-5080": {"epss_score": 0.00265, "epss_percentile": 0.49785}, "CVE-2025-5081": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5082": {"epss_score": 0.00169, "epss_percentile": 0.38532}, "CVE-2025-5083": {"epss_score": 0.00041, "epss_percentile": 0.12438}, "CVE-2025-5084": {"epss_score": 0.00085, "epss_percentile": 0.25115}, "CVE-2025-5086": {"epss_score": 0.45387, "epss_percentile": 0.97485}, "CVE-2025-5087": {"epss_score": 0.00025, "epss_percentile": 0.0616}, "CVE-2025-5092": {"epss_score": 0.00046, "epss_percentile": 0.14471}, "CVE-2025-5093": {"epss_score": 0.00026, "epss_percentile": 0.06434}, "CVE-2025-5095": {"epss_score": 0.00093, "epss_percentile": 0.2665}, "CVE-2025-5096": {"epss_score": 0.00067, "epss_percentile": 0.2117}, "CVE-2025-5098": {"epss_score": 0.00034, "epss_percentile": 0.09733}, "CVE-2025-5099": {"epss_score": 0.00212, "epss_percentile": 0.43811}, "CVE-2025-5100": {"epss_score": 0.00027, "epss_percentile": 0.06952}, "CVE-2025-5101": {"epss_score": 0.00031, "epss_percentile": 0.08677}, "CVE-2025-5103": {"epss_score": 0.00032, "epss_percentile": 0.09}, "CVE-2025-5105": {"epss_score": 0.00055, "epss_percentile": 0.17598}, "CVE-2025-5106": {"epss_score": 0.00449, "epss_percentile": 0.63038}, "CVE-2025-5107": {"epss_score": 0.00044, "epss_percentile": 0.13565}, "CVE-2025-5108": {"epss_score": 0.00071, "epss_percentile": 0.22137}, "CVE-2025-5109": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-5110": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-5111": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-5112": {"epss_score": 0.00098, "epss_percentile": 0.27659}, "CVE-2025-5113": {"epss_score": 0.00292, "epss_percentile": 0.52267}, "CVE-2025-5114": {"epss_score": 0.00068, "epss_percentile": 0.21365}, "CVE-2025-5115": {"epss_score": 0.00127, "epss_percentile": 0.32887}, "CVE-2025-5116": {"epss_score": 0.00045, "epss_percentile": 0.13762}, "CVE-2025-5117": {"epss_score": 0.00078, "epss_percentile": 0.23738}, "CVE-2025-5119": {"epss_score": 0.00046, "epss_percentile": 0.14098}, "CVE-2025-5120": {"epss_score": 0.00143, "epss_percentile": 0.35203}, "CVE-2025-5121": {"epss_score": 0.00021, "epss_percentile": 0.04767}, "CVE-2025-5122": {"epss_score": 0.0004, "epss_percentile": 0.12029}, "CVE-2025-5123": {"epss_score": 0.00026, "epss_percentile": 0.06581}, "CVE-2025-5124": {"epss_score": 0.00116, "epss_percentile": 0.31188}, "CVE-2025-5125": {"epss_score": 0.0003, "epss_percentile": 0.08289}, "CVE-2025-5126": {"epss_score": 0.01433, "epss_percentile": 0.80255}, "CVE-2025-5127": {"epss_score": 0.00031, "epss_percentile": 0.08479}, "CVE-2025-5128": {"epss_score": 0.00049, "epss_percentile": 0.15324}, "CVE-2025-5129": {"epss_score": 0.00023, "epss_percentile": 0.05382}, "CVE-2025-5130": {"epss_score": 0.00079, "epss_percentile": 0.23961}, "CVE-2025-5131": {"epss_score": 0.00108, "epss_percentile": 0.29787}, "CVE-2025-5132": {"epss_score": 0.00043, "epss_percentile": 0.13232}, "CVE-2025-5133": {"epss_score": 0.00051, "epss_percentile": 0.16163}, "CVE-2025-5134": {"epss_score": 0.00039, "epss_percentile": 0.11711}, "CVE-2025-5135": {"epss_score": 0.00057, "epss_percentile": 0.18196}, "CVE-2025-5136": {"epss_score": 0.00044, "epss_percentile": 0.13435}, "CVE-2025-5137": {"epss_score": 0.00034, "epss_percentile": 0.09784}, "CVE-2025-5138": {"epss_score": 0.00028, "epss_percentile": 0.07346}, "CVE-2025-5139": {"epss_score": 0.00175, "epss_percentile": 0.39355}, "CVE-2025-5140": {"epss_score": 0.00043, "epss_percentile": 0.12995}, "CVE-2025-5141": {"epss_score": 0.00015, "epss_percentile": 0.02275}, "CVE-2025-5142": {"epss_score": 0.00019, "epss_percentile": 0.04334}, "CVE-2025-5143": {"epss_score": 0.00028, "epss_percentile": 0.07566}, "CVE-2025-5144": {"epss_score": 0.0004, "epss_percentile": 0.12183}, "CVE-2025-5145": {"epss_score": 0.00447, "epss_percentile": 0.62943}, "CVE-2025-5146": {"epss_score": 0.0042, "epss_percentile": 0.61439}, "CVE-2025-5147": {"epss_score": 0.0042, "epss_percentile": 0.61439}, "CVE-2025-5148": {"epss_score": 0.00066, "epss_percentile": 0.20884}, "CVE-2025-5149": {"epss_score": 0.00219, "epss_percentile": 0.4445}, "CVE-2025-5150": {"epss_score": 0.00063, "epss_percentile": 0.19961}, "CVE-2025-5151": {"epss_score": 0.00027, "epss_percentile": 0.07005}, "CVE-2025-5152": {"epss_score": 0.00027, "epss_percentile": 0.06762}, "CVE-2025-5153": {"epss_score": 0.00026, "epss_percentile": 0.06597}, "CVE-2025-5154": {"epss_score": 0.00012, "epss_percentile": 0.01289}, "CVE-2025-5155": {"epss_score": 0.00034, "epss_percentile": 0.09547}, "CVE-2025-5156": {"epss_score": 0.00184, "epss_percentile": 0.40439}, "CVE-2025-5157": {"epss_score": 0.00189, "epss_percentile": 0.40941}, "CVE-2025-5158": {"epss_score": 0.00189, "epss_percentile": 0.40941}, "CVE-2025-5159": {"epss_score": 0.00189, "epss_percentile": 0.40941}, "CVE-2025-5160": {"epss_score": 0.00256, "epss_percentile": 0.48828}, "CVE-2025-5161": {"epss_score": 0.00189, "epss_percentile": 0.40941}, "CVE-2025-5162": {"epss_score": 0.00048, "epss_percentile": 0.15023}, "CVE-2025-5163": {"epss_score": 0.00044, "epss_percentile": 0.13614}, "CVE-2025-5164": {"epss_score": 0.00051, "epss_percentile": 0.16335}, "CVE-2025-5165": {"epss_score": 0.0003, "epss_percentile": 0.08087}, "CVE-2025-5166": {"epss_score": 0.0003, "epss_percentile": 0.08087}, "CVE-2025-5167": {"epss_score": 0.0003, "epss_percentile": 0.08087}, "CVE-2025-5168": {"epss_score": 0.0003, "epss_percentile": 0.08087}, "CVE-2025-5169": {"epss_score": 0.0003, "epss_percentile": 0.08087}, "CVE-2025-5170": {"epss_score": 0.0003, "epss_percentile": 0.08279}, "CVE-2025-5171": {"epss_score": 0.00057, "epss_percentile": 0.1804}, "CVE-2025-5172": {"epss_score": 0.0003, "epss_percentile": 0.08225}, "CVE-2025-5173": {"epss_score": 0.00036, "epss_percentile": 0.10229}, "CVE-2025-5174": {"epss_score": 0.00038, "epss_percentile": 0.11395}, "CVE-2025-5175": {"epss_score": 0.00018, "epss_percentile": 0.03604}, "CVE-2025-5176": {"epss_score": 0.0002, "epss_percentile": 0.04559}, "CVE-2025-5177": {"epss_score": 0.00054, "epss_percentile": 0.1734}, "CVE-2025-5178": {"epss_score": 0.00043, "epss_percentile": 0.13274}, "CVE-2025-5179": {"epss_score": 0.00043, "epss_percentile": 0.12948}, "CVE-2025-5180": {"epss_score": 0.00019, "epss_percentile": 0.04175}, "CVE-2025-5181": {"epss_score": 0.00049, "epss_percentile": 0.15636}, "CVE-2025-5182": {"epss_score": 0.00035, "epss_percentile": 0.10069}, "CVE-2025-5183": {"epss_score": 0.00026, "epss_percentile": 0.06436}, "CVE-2025-5184": {"epss_score": 0.00029, "epss_percentile": 0.07977}, "CVE-2025-5185": {"epss_score": 0.00014, "epss_percentile": 0.01915}, "CVE-2025-5186": {"epss_score": 0.00048, "epss_percentile": 0.15068}, "CVE-2025-5187": {"epss_score": 0.00034, "epss_percentile": 0.09649}, "CVE-2025-5190": {"epss_score": 0.00082, "epss_percentile": 0.24405}, "CVE-2025-5191": {"epss_score": 0.00031, "epss_percentile": 0.08322}, "CVE-2025-5192": {"epss_score": 0.00311, "epss_percentile": 0.53828}, "CVE-2025-5194": {"epss_score": 0.0003, "epss_percentile": 0.08289}, "CVE-2025-5195": {"epss_score": 8e-05, "epss_percentile": 0.00587}, "CVE-2025-5196": {"epss_score": 0.00336, "epss_percentile": 0.55987}, "CVE-2025-5197": {"epss_score": 0.00099, "epss_percentile": 0.28307}, "CVE-2025-5198": {"epss_score": 0.00024, "epss_percentile": 0.05887}, "CVE-2025-5199": {"epss_score": 0.00012, "epss_percentile": 0.0112}, "CVE-2025-5200": {"epss_score": 0.0003, "epss_percentile": 0.08061}, "CVE-2025-5201": {"epss_score": 0.0003, "epss_percentile": 0.08061}, "CVE-2025-5202": {"epss_score": 0.0003, "epss_percentile": 0.08061}, "CVE-2025-5203": {"epss_score": 0.0003, "epss_percentile": 0.08061}, "CVE-2025-5204": {"epss_score": 0.0003, "epss_percentile": 0.08061}, "CVE-2025-5205": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5206": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-5207": {"epss_score": 0.00029, "epss_percentile": 0.0783}, "CVE-2025-5208": {"epss_score": 0.00032, "epss_percentile": 0.08807}, "CVE-2025-5209": {"epss_score": 0.0003, "epss_percentile": 0.08289}, "CVE-2025-5210": {"epss_score": 0.00032, "epss_percentile": 0.08807}, "CVE-2025-5211": {"epss_score": 0.00032, "epss_percentile": 0.08807}, "CVE-2025-5212": {"epss_score": 0.00032, "epss_percentile": 0.08807}, "CVE-2025-5213": {"epss_score": 0.00035, "epss_percentile": 0.09915}, "CVE-2025-5214": {"epss_score": 0.00034, "epss_percentile": 0.09461}, "CVE-2025-5215": {"epss_score": 0.00154, "epss_percentile": 0.36662}, "CVE-2025-5216": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5217": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5218": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5219": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5220": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5221": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5222": {"epss_score": 0.00031, "epss_percentile": 0.08656}, "CVE-2025-5224": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5225": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5226": {"epss_score": 0.00031, "epss_percentile": 0.08504}, "CVE-2025-5227": {"epss_score": 0.00031, "epss_percentile": 0.08504}, "CVE-2025-5228": {"epss_score": 0.00237, "epss_percentile": 0.46712}, "CVE-2025-5229": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5230": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5231": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5232": {"epss_score": 0.00028, "epss_percentile": 0.07481}, "CVE-2025-5233": {"epss_score": 0.00034, "epss_percentile": 0.09474}, "CVE-2025-5234": {"epss_score": 0.00032, "epss_percentile": 0.08792}, "CVE-2025-5235": {"epss_score": 0.00039, "epss_percentile": 0.11458}, "CVE-2025-5236": {"epss_score": 0.0003, "epss_percentile": 0.0819}, "CVE-2025-5237": {"epss_score": 0.00037, "epss_percentile": 0.10645}, "CVE-2025-5238": {"epss_score": 0.00047, "epss_percentile": 0.14652}, "CVE-2025-5239": {"epss_score": 0.00042, "epss_percentile": 0.12708}, "CVE-2025-5240": {"epss_score": 0.00037, "epss_percentile": 0.10645}, "CVE-2025-5241": {"epss_score": 0.0014, "epss_percentile": 0.34723}, "CVE-2025-5243": {"epss_score": 0.00248, "epss_percentile": 0.47986}, "CVE-2025-5244": {"epss_score": 0.00022, "epss_percentile": 0.05019}, "CVE-2025-5245": {"epss_score": 0.00022, "epss_percentile": 0.05309}, "CVE-2025-5246": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5247": {"epss_score": 0.00061, "epss_percentile": 0.19299}, "CVE-2025-5248": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5249": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5250": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5251": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5252": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5253": {"epss_score": 0.00057, "epss_percentile": 0.17993}, "CVE-2025-5254": {"epss_score": 0.00025, "epss_percentile": 0.06069}, "CVE-2025-5255": {"epss_score": 0.00014, "epss_percentile": 0.01914}, "CVE-2025-5256": {"epss_score": 0.00032, "epss_percentile": 0.08749}, "CVE-2025-5257": {"epss_score": 0.00175, "epss_percentile": 0.39351}, "CVE-2025-5258": {"epss_score": 0.00037, "epss_percentile": 0.10645}, "CVE-2025-5259": {"epss_score": 0.0004, "epss_percentile": 0.12029}, "CVE-2025-5260": {"epss_score": 0.00078, "epss_percentile": 0.23671}, "CVE-2025-5261": {"epss_score": 0.00058, "epss_percentile": 0.18311}, "CVE-2025-5262": {"epss_score": 0.00058, "epss_percentile": 0.18564}, "CVE-2025-5263": {"epss_score": 0.0004, "epss_percentile": 0.11992}, "CVE-2025-5264": {"epss_score": 0.00033, "epss_percentile": 0.09398}, "CVE-2025-5265": {"epss_score": 0.00015, "epss_percentile": 0.02293}, "CVE-2025-5266": {"epss_score": 0.00061, "epss_percentile": 0.19457}, "CVE-2025-5267": {"epss_score": 0.00059, "epss_percentile": 0.18899}, "CVE-2025-5268": {"epss_score": 0.00067, "epss_percentile": 0.21066}, "CVE-2025-5269": {"epss_score": 0.00066, "epss_percentile": 0.20705}, "CVE-2025-5270": {"epss_score": 0.00024, "epss_percentile": 0.05799}, "CVE-2025-5271": {"epss_score": 0.00053, "epss_percentile": 0.16936}, "CVE-2025-5272": {"epss_score": 0.00057, "epss_percentile": 0.1806}, "CVE-2025-5273": {"epss_score": 0.00034, "epss_percentile": 0.098}, "CVE-2025-5275": {"epss_score": 0.00022, "epss_percentile": 0.05159}, "CVE-2025-5276": {"epss_score": 0.00035, "epss_percentile": 0.10126}, "CVE-2025-5277": {"epss_score": 0.00079, "epss_percentile": 0.23901}, "CVE-2025-5278": {"epss_score": 0.00018, "epss_percentile": 0.03914}, "CVE-2025-5279": {"epss_score": 0.00043, "epss_percentile": 0.13078}, "CVE-2025-5280": {"epss_score": 0.00142, "epss_percentile": 0.34974}, "CVE-2025-5281": {"epss_score": 0.00038, "epss_percentile": 0.1139}, "CVE-2025-5282": {"epss_score": 0.00128, "epss_percentile": 0.32995}, "CVE-2025-5283": {"epss_score": 0.00059, "epss_percentile": 0.18695}, "CVE-2025-5284": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-5285": {"epss_score": 0.00032, "epss_percentile": 0.08985}, "CVE-2025-5286": {"epss_score": 0.0005, "epss_percentile": 0.15722}, "CVE-2025-5287": {"epss_score": 0.19237, "epss_percentile": 0.95154}, "CVE-2025-5288": {"epss_score": 0.00224, "epss_percentile": 0.45068}, "CVE-2025-5289": {"epss_score": 0.00032, "epss_percentile": 0.08792}, "CVE-2025-5290": {"epss_score": 0.00058, "epss_percentile": 0.186}, "CVE-2025-5291": {"epss_score": 0.00035, "epss_percentile": 0.10121}, "CVE-2025-5292": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-5295": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5296": {"epss_score": 0.00061, "epss_percentile": 0.19318}, "CVE-2025-5297": {"epss_score": 0.00021, "epss_percentile": 0.04895}, "CVE-2025-5298": {"epss_score": 0.00072, "epss_percentile": 0.22386}, "CVE-2025-5299": {"epss_score": 0.00062, "epss_percentile": 0.19629}, "CVE-2025-5301": {"epss_score": 0.04833, "epss_percentile": 0.89191}, "CVE-2025-5302": {"epss_score": 0.00181, "epss_percentile": 0.40027}, "CVE-2025-5303": {"epss_score": 0.00236, "epss_percentile": 0.46392}, "CVE-2025-5304": {"epss_score": 0.00279, "epss_percentile": 0.50928}, "CVE-2025-5305": {"epss_score": 0.00027, "epss_percentile": 0.06843}, "CVE-2025-5306": {"epss_score": 0.40022, "epss_percentile": 0.97191}, "CVE-2025-5307": {"epss_score": 0.00034, "epss_percentile": 0.09665}, "CVE-2025-5309": {"epss_score": 0.00234, "epss_percentile": 0.46117}, "CVE-2025-5310": {"epss_score": 0.00248, "epss_percentile": 0.47908}, "CVE-2025-5314": {"epss_score": 0.00154, "epss_percentile": 0.36706}, "CVE-2025-5315": {"epss_score": 0.00014, "epss_percentile": 0.02011}, "CVE-2025-5317": {"epss_score": 0.00013, "epss_percentile": 0.01704}, "CVE-2025-5318": {"epss_score": 0.00222, "epss_percentile": 0.44807}, "CVE-2025-5320": {"epss_score": 0.00019, "epss_percentile": 0.04378}, "CVE-2025-5321": {"epss_score": 0.00056, "epss_percentile": 0.17918}, "CVE-2025-5322": {"epss_score": 0.00428, "epss_percentile": 0.6192}, "CVE-2025-5323": {"epss_score": 8e-05, "epss_percentile": 0.00469}, "CVE-2025-5324": {"epss_score": 0.00016, "epss_percentile": 0.02732}, "CVE-2025-5325": {"epss_score": 0.0004, "epss_percentile": 0.12185}, "CVE-2025-5326": {"epss_score": 0.00077, "epss_percentile": 0.23431}, "CVE-2025-5327": {"epss_score": 0.00052, "epss_percentile": 0.16463}, "CVE-2025-5328": {"epss_score": 0.00048, "epss_percentile": 0.15175}, "CVE-2025-5330": {"epss_score": 0.00069, "epss_percentile": 0.21582}, "CVE-2025-5331": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5332": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5333": {"epss_score": 0.00289, "epss_percentile": 0.52024}, "CVE-2025-5334": {"epss_score": 0.00057, "epss_percentile": 0.18058}, "CVE-2025-5335": {"epss_score": 0.00021, "epss_percentile": 0.04704}, "CVE-2025-5336": {"epss_score": 0.00047, "epss_percentile": 0.14652}, "CVE-2025-5337": {"epss_score": 0.00033, "epss_percentile": 0.09125}, "CVE-2025-5338": {"epss_score": 0.00028, "epss_percentile": 0.07566}, "CVE-2025-5339": {"epss_score": 0.00068, "epss_percentile": 0.21352}, "CVE-2025-5340": {"epss_score": 0.0004, "epss_percentile": 0.12029}, "CVE-2025-5341": {"epss_score": 0.00043, "epss_percentile": 0.13321}, "CVE-2025-5342": {"epss_score": 0.00092, "epss_percentile": 0.2652}, "CVE-2025-5343": {"epss_score": 0.00046, "epss_percentile": 0.14437}, "CVE-2025-5344": {"epss_score": 0.00018, "epss_percentile": 0.03609}, "CVE-2025-5345": {"epss_score": 0.00025, "epss_percentile": 0.06361}, "CVE-2025-5346": {"epss_score": 0.00018, "epss_percentile": 0.03609}, "CVE-2025-5347": {"epss_score": 0.00046, "epss_percentile": 0.14437}, "CVE-2025-5349": {"epss_score": 0.00068, "epss_percentile": 0.2137}, "CVE-2025-5350": {"epss_score": 0.00022, "epss_percentile": 0.05267}, "CVE-2025-5351": {"epss_score": 0.00057, "epss_percentile": 0.17993}, "CVE-2025-5352": {"epss_score": 0.00126, "epss_percentile": 0.32724}, "CVE-2025-5353": {"epss_score": 0.00073, "epss_percentile": 0.22497}, "CVE-2025-5356": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5357": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5358": {"epss_score": 0.00034, "epss_percentile": 0.09461}, "CVE-2025-5359": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5360": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5361": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5362": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5363": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5364": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5365": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5366": {"epss_score": 0.00113, "epss_percentile": 0.30724}, "CVE-2025-5367": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5368": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-5369": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5370": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5371": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5372": {"epss_score": 0.00058, "epss_percentile": 0.18272}, "CVE-2025-5373": {"epss_score": 0.00027, "epss_percentile": 0.07206}, "CVE-2025-5374": {"epss_score": 0.00027, "epss_percentile": 0.07206}, "CVE-2025-5375": {"epss_score": 0.00027, "epss_percentile": 0.07206}, "CVE-2025-5376": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5377": {"epss_score": 0.00024, "epss_percentile": 0.05814}, "CVE-2025-5378": {"epss_score": 0.00024, "epss_percentile": 0.05814}, "CVE-2025-5379": {"epss_score": 0.00024, "epss_percentile": 0.05842}, "CVE-2025-5380": {"epss_score": 0.00032, "epss_percentile": 0.08767}, "CVE-2025-5381": {"epss_score": 0.00248, "epss_percentile": 0.4795}, "CVE-2025-5382": {"epss_score": 0.00037, "epss_percentile": 0.10892}, "CVE-2025-5383": {"epss_score": 0.00027, "epss_percentile": 0.06835}, "CVE-2025-5384": {"epss_score": 0.00025, "epss_percentile": 0.06067}, "CVE-2025-5385": {"epss_score": 0.00112, "epss_percentile": 0.30572}, "CVE-2025-5386": {"epss_score": 0.00025, "epss_percentile": 0.06067}, "CVE-2025-5387": {"epss_score": 0.00041, "epss_percentile": 0.12302}, "CVE-2025-5388": {"epss_score": 0.00025, "epss_percentile": 0.06067}, "CVE-2025-5389": {"epss_score": 0.00041, "epss_percentile": 0.12302}, "CVE-2025-5390": {"epss_score": 0.00041, "epss_percentile": 0.12302}, "CVE-2025-5391": {"epss_score": 0.00598, "epss_percentile": 0.6877}, "CVE-2025-5392": {"epss_score": 0.00332, "epss_percentile": 0.5558}, "CVE-2025-5393": {"epss_score": 0.00414, "epss_percentile": 0.61099}, "CVE-2025-5394": {"epss_score": 0.22863, "epss_percentile": 0.95701}, "CVE-2025-5395": {"epss_score": 0.00278, "epss_percentile": 0.50863}, "CVE-2025-5396": {"epss_score": 0.00388, "epss_percentile": 0.59396}, "CVE-2025-5397": {"epss_score": 0.00447, "epss_percentile": 0.62947}, "CVE-2025-5398": {"epss_score": 0.00024, "epss_percentile": 0.05667}, "CVE-2025-5399": {"epss_score": 0.00086, "epss_percentile": 0.25331}, "CVE-2025-5400": {"epss_score": 0.00034, "epss_percentile": 0.09461}, "CVE-2025-5401": {"epss_score": 0.00034, "epss_percentile": 0.09461}, "CVE-2025-5402": {"epss_score": 0.00034, "epss_percentile": 0.09461}, "CVE-2025-5403": {"epss_score": 0.00033, "epss_percentile": 0.09134}, "CVE-2025-5404": {"epss_score": 0.00153, "epss_percentile": 0.3663}, "CVE-2025-5405": {"epss_score": 0.00029, "epss_percentile": 0.07751}, "CVE-2025-5406": {"epss_score": 0.00052, "epss_percentile": 0.16463}, "CVE-2025-5407": {"epss_score": 0.00028, "epss_percentile": 0.07449}, "CVE-2025-5408": {"epss_score": 0.00117, "epss_percentile": 0.31212}, "CVE-2025-5409": {"epss_score": 0.00107, "epss_percentile": 0.29633}, "CVE-2025-5410": {"epss_score": 0.0004, "epss_percentile": 0.11949}, "CVE-2025-5411": {"epss_score": 0.00038, "epss_percentile": 0.11105}, "CVE-2025-5412": {"epss_score": 0.00046, "epss_percentile": 0.1443}, "CVE-2025-5416": {"epss_score": 0.00031, "epss_percentile": 0.08643}, "CVE-2025-5417": {"epss_score": 0.00028, "epss_percentile": 0.07347}, "CVE-2025-5419": {"epss_score": 0.01353, "epss_percentile": 0.79696}, "CVE-2025-5420": {"epss_score": 0.00031, "epss_percentile": 0.08479}, "CVE-2025-5421": {"epss_score": 0.00047, "epss_percentile": 0.14835}, "CVE-2025-5422": {"epss_score": 0.00033, "epss_percentile": 0.0931}, "CVE-2025-5423": {"epss_score": 0.00047, "epss_percentile": 0.14835}, "CVE-2025-5424": {"epss_score": 0.00047, "epss_percentile": 0.14835}, "CVE-2025-5425": {"epss_score": 0.00047, "epss_percentile": 0.14835}, "CVE-2025-5426": {"epss_score": 0.00047, "epss_percentile": 0.14835}, "CVE-2025-5427": {"epss_score": 0.00047, "epss_percentile": 0.14835}, "CVE-2025-5428": {"epss_score": 0.00047, "epss_percentile": 0.14835}, "CVE-2025-5429": {"epss_score": 0.00047, "epss_percentile": 0.14835}, "CVE-2025-5430": {"epss_score": 0.00033, "epss_percentile": 0.09134}, "CVE-2025-5431": {"epss_score": 0.00028, "epss_percentile": 0.07328}, "CVE-2025-5432": {"epss_score": 0.00028, "epss_percentile": 0.07328}, "CVE-2025-5433": {"epss_score": 0.00027, "epss_percentile": 0.06924}, "CVE-2025-5434": {"epss_score": 0.00029, "epss_percentile": 0.07729}, "CVE-2025-5435": {"epss_score": 0.00029, "epss_percentile": 0.07729}, "CVE-2025-5436": {"epss_score": 0.00036, "epss_percentile": 0.10163}, "CVE-2025-5437": {"epss_score": 0.0006, "epss_percentile": 0.19157}, "CVE-2025-5438": {"epss_score": 0.00406, "epss_percentile": 0.60567}, "CVE-2025-5439": {"epss_score": 0.0025, "epss_percentile": 0.48114}, "CVE-2025-5440": {"epss_score": 0.0025, "epss_percentile": 0.48114}, "CVE-2025-5441": {"epss_score": 0.00263, "epss_percentile": 0.49535}, "CVE-2025-5442": {"epss_score": 0.00263, "epss_percentile": 0.49535}, "CVE-2025-5443": {"epss_score": 0.00358, "epss_percentile": 0.57486}, "CVE-2025-5444": {"epss_score": 0.00358, "epss_percentile": 0.57486}, "CVE-2025-5445": {"epss_score": 0.00358, "epss_percentile": 0.57486}, "CVE-2025-5446": {"epss_score": 0.00263, "epss_percentile": 0.49535}, "CVE-2025-5447": {"epss_score": 0.00449, "epss_percentile": 0.63037}, "CVE-2025-5449": {"epss_score": 0.0017, "epss_percentile": 0.38666}, "CVE-2025-5450": {"epss_score": 0.00103, "epss_percentile": 0.29071}, "CVE-2025-5451": {"epss_score": 0.00613, "epss_percentile": 0.69261}, "CVE-2025-5452": {"epss_score": 0.00059, "epss_percentile": 0.18822}, "CVE-2025-5454": {"epss_score": 0.00028, "epss_percentile": 0.07286}, "CVE-2025-5455": {"epss_score": 0.00123, "epss_percentile": 0.32238}, "CVE-2025-5456": {"epss_score": 0.00574, "epss_percentile": 0.68081}, "CVE-2025-5459": {"epss_score": 0.00052, "epss_percentile": 0.16566}, "CVE-2025-5462": {"epss_score": 0.00525, "epss_percentile": 0.66377}, "CVE-2025-5463": {"epss_score": 0.00069, "epss_percentile": 0.21573}, "CVE-2025-5464": {"epss_score": 0.00051, "epss_percentile": 0.1615}, "CVE-2025-5466": {"epss_score": 0.00934, "epss_percentile": 0.7565}, "CVE-2025-5467": {"epss_score": 0.00015, "epss_percentile": 0.02127}, "CVE-2025-5468": {"epss_score": 0.00054, "epss_percentile": 0.17294}, "CVE-2025-5469": {"epss_score": 0.00015, "epss_percentile": 0.0244}, "CVE-2025-5470": {"epss_score": 0.00015, "epss_percentile": 0.0244}, "CVE-2025-5471": {"epss_score": 0.00015, "epss_percentile": 0.0244}, "CVE-2025-5472": {"epss_score": 0.00042, "epss_percentile": 0.12561}, "CVE-2025-5473": {"epss_score": 0.00242, "epss_percentile": 0.47363}, "CVE-2025-5474": {"epss_score": 0.0002, "epss_percentile": 0.04602}, "CVE-2025-5475": {"epss_score": 0.00041, "epss_percentile": 0.12454}, "CVE-2025-5476": {"epss_score": 0.00017, "epss_percentile": 0.03332}, "CVE-2025-5477": {"epss_score": 0.00038, "epss_percentile": 0.11207}, "CVE-2025-5478": {"epss_score": 0.0012, "epss_percentile": 0.31753}, "CVE-2025-5479": {"epss_score": 0.0004, "epss_percentile": 0.12031}, "CVE-2025-5480": {"epss_score": 0.00016, "epss_percentile": 0.02829}, "CVE-2025-5481": {"epss_score": 0.00038, "epss_percentile": 0.11327}, "CVE-2025-5482": {"epss_score": 0.00057, "epss_percentile": 0.18044}, "CVE-2025-5483": {"epss_score": 0.00104, "epss_percentile": 0.29233}, "CVE-2025-5484": {"epss_score": 0.00045, "epss_percentile": 0.13751}, "CVE-2025-5485": {"epss_score": 0.00067, "epss_percentile": 0.21104}, "CVE-2025-5486": {"epss_score": 0.00208, "epss_percentile": 0.43226}, "CVE-2025-5487": {"epss_score": 0.00035, "epss_percentile": 0.099}, "CVE-2025-5488": {"epss_score": 0.00024, "epss_percentile": 0.05667}, "CVE-2025-5490": {"epss_score": 0.0002, "epss_percentile": 0.04653}, "CVE-2025-5491": {"epss_score": 0.00333, "epss_percentile": 0.55626}, "CVE-2025-5492": {"epss_score": 0.00043, "epss_percentile": 0.1324}, "CVE-2025-5493": {"epss_score": 0.00033, "epss_percentile": 0.09134}, "CVE-2025-5494": {"epss_score": 0.0001, "epss_percentile": 0.00889}, "CVE-2025-5495": {"epss_score": 0.00232, "epss_percentile": 0.45904}, "CVE-2025-5496": {"epss_score": 7e-05, "epss_percentile": 0.00348}, "CVE-2025-5497": {"epss_score": 0.00088, "epss_percentile": 0.25792}, "CVE-2025-5498": {"epss_score": 0.00096, "epss_percentile": 0.27281}, "CVE-2025-5499": {"epss_score": 0.0011, "epss_percentile": 0.30169}, "CVE-2025-5500": {"epss_score": 0.00018, "epss_percentile": 0.03572}, "CVE-2025-5501": {"epss_score": 0.00161, "epss_percentile": 0.37541}, "CVE-2025-5502": {"epss_score": 0.0172, "epss_percentile": 0.8193}, "CVE-2025-5503": {"epss_score": 0.00448, "epss_percentile": 0.62996}, "CVE-2025-5504": {"epss_score": 0.01234, "epss_percentile": 0.7876}, "CVE-2025-5505": {"epss_score": 0.00086, "epss_percentile": 0.25409}, "CVE-2025-5506": {"epss_score": 0.00032, "epss_percentile": 0.09107}, "CVE-2025-5507": {"epss_score": 0.00032, "epss_percentile": 0.09107}, "CVE-2025-5508": {"epss_score": 0.00086, "epss_percentile": 0.25409}, "CVE-2025-5509": {"epss_score": 0.00126, "epss_percentile": 0.32704}, "CVE-2025-5510": {"epss_score": 0.00052, "epss_percentile": 0.16402}, "CVE-2025-5511": {"epss_score": 0.00047, "epss_percentile": 0.14913}, "CVE-2025-5512": {"epss_score": 0.00202, "epss_percentile": 0.42431}, "CVE-2025-5513": {"epss_score": 0.0003, "epss_percentile": 0.08301}, "CVE-2025-5514": {"epss_score": 0.00299, "epss_percentile": 0.52906}, "CVE-2025-5515": {"epss_score": 0.01137, "epss_percentile": 0.77922}, "CVE-2025-5516": {"epss_score": 0.00039, "epss_percentile": 0.11733}, "CVE-2025-5517": {"epss_score": 0.00059, "epss_percentile": 0.18839}, "CVE-2025-5518": {"epss_score": 0.00035, "epss_percentile": 0.09966}, "CVE-2025-5519": {"epss_score": 0.00055, "epss_percentile": 0.1764}, "CVE-2025-5520": {"epss_score": 0.00144, "epss_percentile": 0.35286}, "CVE-2025-5521": {"epss_score": 0.0004, "epss_percentile": 0.12019}, "CVE-2025-5522": {"epss_score": 0.00048, "epss_percentile": 0.15094}, "CVE-2025-5523": {"epss_score": 0.00023, "epss_percentile": 0.05361}, "CVE-2025-5524": {"epss_score": 0.00024, "epss_percentile": 0.05732}, "CVE-2025-5525": {"epss_score": 0.00169, "epss_percentile": 0.38642}, "CVE-2025-5526": {"epss_score": 0.00038, "epss_percentile": 0.11415}, "CVE-2025-5527": {"epss_score": 0.00385, "epss_percentile": 0.59227}, "CVE-2025-5528": {"epss_score": 0.00114, "epss_percentile": 0.3082}, "CVE-2025-5529": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-5530": {"epss_score": 0.00028, "epss_percentile": 0.07566}, "CVE-2025-5531": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-5532": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-5533": {"epss_score": 0.00034, "epss_percentile": 0.09601}, "CVE-2025-5534": {"epss_score": 0.00034, "epss_percentile": 0.09601}, "CVE-2025-5535": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-5536": {"epss_score": 0.00034, "epss_percentile": 0.09601}, "CVE-2025-5537": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-5538": {"epss_score": 0.00034, "epss_percentile": 0.09601}, "CVE-2025-5539": {"epss_score": 0.00032, "epss_percentile": 0.09085}, "CVE-2025-5540": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-5541": {"epss_score": 0.00034, "epss_percentile": 0.09601}, "CVE-2025-5542": {"epss_score": 0.00039, "epss_percentile": 0.11733}, "CVE-2025-5543": {"epss_score": 0.00045, "epss_percentile": 0.14072}, "CVE-2025-5544": {"epss_score": 0.00106, "epss_percentile": 0.29498}, "CVE-2025-5545": {"epss_score": 0.00137, "epss_percentile": 0.34207}, "CVE-2025-5546": {"epss_score": 0.0003, "epss_percentile": 0.08074}, "CVE-2025-5547": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5548": {"epss_score": 0.01823, "epss_percentile": 0.82416}, "CVE-2025-5549": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5550": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5551": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5552": {"epss_score": 0.00059, "epss_percentile": 0.18681}, "CVE-2025-5553": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5554": {"epss_score": 0.0003, "epss_percentile": 0.08074}, "CVE-2025-5555": {"epss_score": 0.00017, "epss_percentile": 0.03099}, "CVE-2025-5556": {"epss_score": 0.0003, "epss_percentile": 0.08074}, "CVE-2025-5557": {"epss_score": 0.0003, "epss_percentile": 0.08074}, "CVE-2025-5558": {"epss_score": 0.0003, "epss_percentile": 0.08074}, "CVE-2025-5559": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-5560": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5561": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5562": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5563": {"epss_score": 0.0003, "epss_percentile": 0.08243}, "CVE-2025-5564": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-5565": {"epss_score": 0.00034, "epss_percentile": 0.09601}, "CVE-2025-5566": {"epss_score": 0.0003, "epss_percentile": 0.08074}, "CVE-2025-5567": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-5568": {"epss_score": 0.00033, "epss_percentile": 0.09125}, "CVE-2025-5569": {"epss_score": 0.00604, "epss_percentile": 0.68957}, "CVE-2025-5570": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-5571": {"epss_score": 0.00131, "epss_percentile": 0.33369}, "CVE-2025-5572": {"epss_score": 0.00222, "epss_percentile": 0.44718}, "CVE-2025-5573": {"epss_score": 0.00155, "epss_percentile": 0.36848}, "CVE-2025-5574": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5575": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5576": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5577": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5578": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5579": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5580": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5581": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5582": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-5583": {"epss_score": 0.00042, "epss_percentile": 0.12559}, "CVE-2025-5584": {"epss_score": 0.00029, "epss_percentile": 0.07609}, "CVE-2025-5585": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-5586": {"epss_score": 0.00034, "epss_percentile": 0.09474}, "CVE-2025-5587": {"epss_score": 0.00037, "epss_percentile": 0.10645}, "CVE-2025-5588": {"epss_score": 0.00037, "epss_percentile": 0.10645}, "CVE-2025-5589": {"epss_score": 0.00042, "epss_percentile": 0.12708}, "CVE-2025-5590": {"epss_score": 0.00033, "epss_percentile": 0.09392}, "CVE-2025-5591": {"epss_score": 0.00047, "epss_percentile": 0.14771}, "CVE-2025-5592": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5593": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5594": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5595": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5596": {"epss_score": 0.00072, "epss_percentile": 0.22339}, "CVE-2025-5597": {"epss_score": 0.00072, "epss_percentile": 0.2231}, "CVE-2025-5598": {"epss_score": 0.00121, "epss_percentile": 0.31882}, "CVE-2025-5599": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5600": {"epss_score": 0.0036, "epss_percentile": 0.5768}, "CVE-2025-5601": {"epss_score": 0.00052, "epss_percentile": 0.16506}, "CVE-2025-5602": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5603": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5604": {"epss_score": 0.00031, "epss_percentile": 0.08407}, "CVE-2025-5605": {"epss_score": 0.0645, "epss_percentile": 0.90763}, "CVE-2025-5606": {"epss_score": 0.00465, "epss_percentile": 0.63784}, "CVE-2025-5607": {"epss_score": 0.00139, "epss_percentile": 0.34623}, "CVE-2025-5608": {"epss_score": 0.00139, "epss_percentile": 0.34623}, "CVE-2025-5609": {"epss_score": 0.00139, "epss_percentile": 0.34623}, "CVE-2025-5610": {"epss_score": 0.0003, "epss_percentile": 0.08074}, "CVE-2025-5611": {"epss_score": 0.0003, "epss_percentile": 0.08074}, "CVE-2025-5612": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-5613": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-5614": {"epss_score": 0.0003, "epss_percentile": 0.08074}, "CVE-2025-5615": {"epss_score": 0.0003, "epss_percentile": 0.08074}, "CVE-2025-5616": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-5617": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-5618": {"epss_score": 0.0004, "epss_percentile": 0.1212}, "CVE-2025-5619": {"epss_score": 0.00373, "epss_percentile": 0.58476}, "CVE-2025-5620": {"epss_score": 0.00225, "epss_percentile": 0.45102}, "CVE-2025-5621": {"epss_score": 0.00225, "epss_percentile": 0.45102}, "CVE-2025-5622": {"epss_score": 0.00473, "epss_percentile": 0.64078}, "CVE-2025-5623": {"epss_score": 0.00473, "epss_percentile": 0.64078}, "CVE-2025-5624": {"epss_score": 0.00473, "epss_percentile": 0.64078}, "CVE-2025-5625": {"epss_score": 0.00044, "epss_percentile": 0.13382}, "CVE-2025-5626": {"epss_score": 0.00044, "epss_percentile": 0.13382}, "CVE-2025-5627": {"epss_score": 0.00027, "epss_percentile": 0.06852}, "CVE-2025-5628": {"epss_score": 0.00042, "epss_percentile": 0.12652}, "CVE-2025-5629": {"epss_score": 0.00314, "epss_percentile": 0.5414}, "CVE-2025-5630": {"epss_score": 0.00473, "epss_percentile": 0.64078}, "CVE-2025-5631": {"epss_score": 0.00035, "epss_percentile": 0.10051}, "CVE-2025-5632": {"epss_score": 0.00034, "epss_percentile": 0.09674}, "CVE-2025-5633": {"epss_score": 0.00034, "epss_percentile": 0.09674}, "CVE-2025-5634": {"epss_score": 0.00075, "epss_percentile": 0.23036}, "CVE-2025-5635": {"epss_score": 0.00075, "epss_percentile": 0.23036}, "CVE-2025-5636": {"epss_score": 0.00075, "epss_percentile": 0.23036}, "CVE-2025-5637": {"epss_score": 0.00075, "epss_percentile": 0.23036}, "CVE-2025-5638": {"epss_score": 0.00042, "epss_percentile": 0.12826}, "CVE-2025-5639": {"epss_score": 0.00044, "epss_percentile": 0.13382}, "CVE-2025-5640": {"epss_score": 0.00067, "epss_percentile": 0.21166}, "CVE-2025-5641": {"epss_score": 0.00037, "epss_percentile": 0.10688}, "CVE-2025-5642": {"epss_score": 0.00037, "epss_percentile": 0.10688}, "CVE-2025-5643": {"epss_score": 0.00037, "epss_percentile": 0.10688}, "CVE-2025-5644": {"epss_score": 0.00031, "epss_percentile": 0.08663}, "CVE-2025-5645": {"epss_score": 0.00037, "epss_percentile": 0.10688}, "CVE-2025-5646": {"epss_score": 0.00037, "epss_percentile": 0.10688}, "CVE-2025-5647": {"epss_score": 0.00037, "epss_percentile": 0.10688}, "CVE-2025-5648": {"epss_score": 0.00037, "epss_percentile": 0.10688}, "CVE-2025-5649": {"epss_score": 0.00045, "epss_percentile": 0.13987}, "CVE-2025-5650": {"epss_score": 0.00035, "epss_percentile": 0.10051}, "CVE-2025-5651": {"epss_score": 0.00031, "epss_percentile": 0.08473}, "CVE-2025-5652": {"epss_score": 0.00042, "epss_percentile": 0.12826}, "CVE-2025-5653": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5654": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5655": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5656": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5657": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5658": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5659": {"epss_score": 0.00042, "epss_percentile": 0.12826}, "CVE-2025-5660": {"epss_score": 0.00042, "epss_percentile": 0.12826}, "CVE-2025-5661": {"epss_score": 0.00041, "epss_percentile": 0.12229}, "CVE-2025-5662": {"epss_score": 0.01331, "epss_percentile": 0.79518}, "CVE-2025-5663": {"epss_score": 0.00044, "epss_percentile": 0.13382}, "CVE-2025-5664": {"epss_score": 0.00075, "epss_percentile": 0.23036}, "CVE-2025-5665": {"epss_score": 0.00075, "epss_percentile": 0.23036}, "CVE-2025-5666": {"epss_score": 0.00075, "epss_percentile": 0.23036}, "CVE-2025-5667": {"epss_score": 0.00075, "epss_percentile": 0.23036}, "CVE-2025-5668": {"epss_score": 0.00042, "epss_percentile": 0.12826}, "CVE-2025-5669": {"epss_score": 0.00042, "epss_percentile": 0.12826}, "CVE-2025-5670": {"epss_score": 0.00042, "epss_percentile": 0.12826}, "CVE-2025-5671": {"epss_score": 0.00225, "epss_percentile": 0.45098}, "CVE-2025-5672": {"epss_score": 0.00225, "epss_percentile": 0.45098}, "CVE-2025-5673": {"epss_score": 0.00028, "epss_percentile": 0.07542}, "CVE-2025-5674": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5675": {"epss_score": 0.00032, "epss_percentile": 0.08994}, "CVE-2025-5676": {"epss_score": 0.00032, "epss_percentile": 0.08994}, "CVE-2025-5677": {"epss_score": 0.00032, "epss_percentile": 0.08994}, "CVE-2025-5678": {"epss_score": 0.00024, "epss_percentile": 0.05997}, "CVE-2025-5679": {"epss_score": 0.00198, "epss_percentile": 0.42025}, "CVE-2025-5680": {"epss_score": 0.00198, "epss_percentile": 0.42025}, "CVE-2025-5681": {"epss_score": 0.00032, "epss_percentile": 0.08868}, "CVE-2025-5682": {"epss_score": 0.00033, "epss_percentile": 0.09185}, "CVE-2025-5683": {"epss_score": 0.00029, "epss_percentile": 0.07775}, "CVE-2025-5684": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-5685": {"epss_score": 0.00219, "epss_percentile": 0.44507}, "CVE-2025-5686": {"epss_score": 0.00034, "epss_percentile": 0.09601}, "CVE-2025-5687": {"epss_score": 0.00019, "epss_percentile": 0.04281}, "CVE-2025-5688": {"epss_score": 0.0002, "epss_percentile": 0.04509}, "CVE-2025-5689": {"epss_score": 0.00015, "epss_percentile": 0.02468}, "CVE-2025-5690": {"epss_score": 0.00044, "epss_percentile": 0.13657}, "CVE-2025-5692": {"epss_score": 0.00041, "epss_percentile": 0.12219}, "CVE-2025-5693": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5694": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5695": {"epss_score": 0.00425, "epss_percentile": 0.61693}, "CVE-2025-5696": {"epss_score": 0.00033, "epss_percentile": 0.09285}, "CVE-2025-5697": {"epss_score": 0.00033, "epss_percentile": 0.09285}, "CVE-2025-5698": {"epss_score": 0.00033, "epss_percentile": 0.09285}, "CVE-2025-5699": {"epss_score": 0.00039, "epss_percentile": 0.11537}, "CVE-2025-5700": {"epss_score": 0.00041, "epss_percentile": 0.12309}, "CVE-2025-5701": {"epss_score": 0.12932, "epss_percentile": 0.93821}, "CVE-2025-5702": {"epss_score": 0.00049, "epss_percentile": 0.15452}, "CVE-2025-5703": {"epss_score": 0.00026, "epss_percentile": 0.06581}, "CVE-2025-5704": {"epss_score": 0.00044, "epss_percentile": 0.13486}, "CVE-2025-5705": {"epss_score": 0.00044, "epss_percentile": 0.13486}, "CVE-2025-5706": {"epss_score": 0.00032, "epss_percentile": 0.08994}, "CVE-2025-5707": {"epss_score": 0.00032, "epss_percentile": 0.08994}, "CVE-2025-5708": {"epss_score": 0.00044, "epss_percentile": 0.13384}, "CVE-2025-5709": {"epss_score": 0.00044, "epss_percentile": 0.13486}, "CVE-2025-5710": {"epss_score": 0.00044, "epss_percentile": 0.13486}, "CVE-2025-5711": {"epss_score": 0.00044, "epss_percentile": 0.13486}, "CVE-2025-5712": {"epss_score": 0.00032, "epss_percentile": 0.09088}, "CVE-2025-5713": {"epss_score": 0.00034, "epss_percentile": 0.09658}, "CVE-2025-5714": {"epss_score": 0.00103, "epss_percentile": 0.28992}, "CVE-2025-5715": {"epss_score": 0.0008, "epss_percentile": 0.24085}, "CVE-2025-5716": {"epss_score": 0.00032, "epss_percentile": 0.09088}, "CVE-2025-5717": {"epss_score": 0.00452, "epss_percentile": 0.63165}, "CVE-2025-5718": {"epss_score": 0.00063, "epss_percentile": 0.19812}, "CVE-2025-5719": {"epss_score": 0.00037, "epss_percentile": 0.10859}, "CVE-2025-5720": {"epss_score": 0.00182, "epss_percentile": 0.4025}, "CVE-2025-5721": {"epss_score": 0.00041, "epss_percentile": 0.12445}, "CVE-2025-5722": {"epss_score": 0.00052, "epss_percentile": 0.16345}, "CVE-2025-5723": {"epss_score": 0.00052, "epss_percentile": 0.16345}, "CVE-2025-5724": {"epss_score": 0.00052, "epss_percentile": 0.16345}, "CVE-2025-5725": {"epss_score": 0.00035, "epss_percentile": 0.09905}, "CVE-2025-5726": {"epss_score": 0.00042, "epss_percentile": 0.12729}, "CVE-2025-5727": {"epss_score": 0.00042, "epss_percentile": 0.12729}, "CVE-2025-5728": {"epss_score": 0.00053, "epss_percentile": 0.1685}, "CVE-2025-5729": {"epss_score": 0.00027, "epss_percentile": 0.06852}, "CVE-2025-5730": {"epss_score": 0.00037, "epss_percentile": 0.10789}, "CVE-2025-5731": {"epss_score": 0.00017, "epss_percentile": 0.03099}, "CVE-2025-5732": {"epss_score": 0.00045, "epss_percentile": 0.13968}, "CVE-2025-5733": {"epss_score": 0.00037, "epss_percentile": 0.10892}, "CVE-2025-5734": {"epss_score": 0.00401, "epss_percentile": 0.602}, "CVE-2025-5735": {"epss_score": 0.00401, "epss_percentile": 0.602}, "CVE-2025-5736": {"epss_score": 0.00401, "epss_percentile": 0.602}, "CVE-2025-5737": {"epss_score": 0.00401, "epss_percentile": 0.602}, "CVE-2025-5738": {"epss_score": 0.00401, "epss_percentile": 0.602}, "CVE-2025-5739": {"epss_score": 0.00685, "epss_percentile": 0.7115}, "CVE-2025-5740": {"epss_score": 0.00101, "epss_percentile": 0.28669}, "CVE-2025-5741": {"epss_score": 0.00065, "epss_percentile": 0.20598}, "CVE-2025-5742": {"epss_score": 0.00025, "epss_percentile": 0.06378}, "CVE-2025-5743": {"epss_score": 0.00366, "epss_percentile": 0.58087}, "CVE-2025-5745": {"epss_score": 0.00043, "epss_percentile": 0.13076}, "CVE-2025-5746": {"epss_score": 0.00457, "epss_percentile": 0.63385}, "CVE-2025-5747": {"epss_score": 0.00171, "epss_percentile": 0.38818}, "CVE-2025-5748": {"epss_score": 0.00159, "epss_percentile": 0.37368}, "CVE-2025-5749": {"epss_score": 0.00011, "epss_percentile": 0.01106}, "CVE-2025-5750": {"epss_score": 0.00072, "epss_percentile": 0.22473}, "CVE-2025-5751": {"epss_score": 0.00032, "epss_percentile": 0.08795}, "CVE-2025-5752": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-5753": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-5754": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-5755": {"epss_score": 0.00032, "epss_percentile": 0.09088}, "CVE-2025-5756": {"epss_score": 0.00046, "epss_percentile": 0.14174}, "CVE-2025-5757": {"epss_score": 0.00031, "epss_percentile": 0.08473}, "CVE-2025-5758": {"epss_score": 0.00032, "epss_percentile": 0.09088}, "CVE-2025-5759": {"epss_score": 0.00032, "epss_percentile": 0.08994}, "CVE-2025-5760": {"epss_score": 0.00053, "epss_percentile": 0.16943}, "CVE-2025-5761": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5762": {"epss_score": 0.00027, "epss_percentile": 0.06852}, "CVE-2025-5763": {"epss_score": 0.00288, "epss_percentile": 0.51915}, "CVE-2025-5764": {"epss_score": 0.00031, "epss_percentile": 0.08473}, "CVE-2025-5765": {"epss_score": 0.00031, "epss_percentile": 0.08473}, "CVE-2025-5766": {"epss_score": 0.00056, "epss_percentile": 0.17787}, "CVE-2025-5767": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-5770": {"epss_score": 0.00041, "epss_percentile": 0.12296}, "CVE-2025-5777": {"epss_score": 0.78425, "epss_percentile": 0.98986}, "CVE-2025-5778": {"epss_score": 0.00046, "epss_percentile": 0.14174}, "CVE-2025-5779": {"epss_score": 0.00027, "epss_percentile": 0.06852}, "CVE-2025-5780": {"epss_score": 0.00027, "epss_percentile": 0.06852}, "CVE-2025-5782": {"epss_score": 0.00028, "epss_percentile": 0.07264}, "CVE-2025-5783": {"epss_score": 0.0004, "epss_percentile": 0.12079}, "CVE-2025-5784": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5785": {"epss_score": 0.00685, "epss_percentile": 0.7115}, "CVE-2025-5786": {"epss_score": 0.00685, "epss_percentile": 0.7115}, "CVE-2025-5787": {"epss_score": 0.00685, "epss_percentile": 0.7115}, "CVE-2025-5788": {"epss_score": 0.00685, "epss_percentile": 0.7115}, "CVE-2025-5789": {"epss_score": 0.00401, "epss_percentile": 0.602}, "CVE-2025-5790": {"epss_score": 0.00685, "epss_percentile": 0.7115}, "CVE-2025-5791": {"epss_score": 8e-05, "epss_percentile": 0.00498}, "CVE-2025-5792": {"epss_score": 0.00582, "epss_percentile": 0.68302}, "CVE-2025-5793": {"epss_score": 0.00389, "epss_percentile": 0.59475}, "CVE-2025-5794": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-5795": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-5796": {"epss_score": 0.00031, "epss_percentile": 0.08473}, "CVE-2025-5797": {"epss_score": 0.00031, "epss_percentile": 0.08473}, "CVE-2025-5798": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-5799": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-5800": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-5801": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-5803": {"epss_score": 0.0005, "epss_percentile": 0.15884}, "CVE-2025-5806": {"epss_score": 0.00024, "epss_percentile": 0.05775}, "CVE-2025-5807": {"epss_score": 0.00106, "epss_percentile": 0.29506}, "CVE-2025-5808": {"epss_score": 0.00172, "epss_percentile": 0.38911}, "CVE-2025-5811": {"epss_score": 0.00106, "epss_percentile": 0.2947}, "CVE-2025-5812": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-5813": {"epss_score": 0.00119, "epss_percentile": 0.31612}, "CVE-2025-5814": {"epss_score": 0.00128, "epss_percentile": 0.32995}, "CVE-2025-5815": {"epss_score": 0.0004, "epss_percentile": 0.11989}, "CVE-2025-5816": {"epss_score": 0.00034, "epss_percentile": 0.09456}, "CVE-2025-5817": {"epss_score": 0.00122, "epss_percentile": 0.32114}, "CVE-2025-5818": {"epss_score": 0.00031, "epss_percentile": 0.08658}, "CVE-2025-5819": {"epss_score": 0.00021, "epss_percentile": 0.04693}, "CVE-2025-5820": {"epss_score": 0.00017, "epss_percentile": 0.03332}, "CVE-2025-5821": {"epss_score": 0.00388, "epss_percentile": 0.59397}, "CVE-2025-5822": {"epss_score": 0.00039, "epss_percentile": 0.11705}, "CVE-2025-5823": {"epss_score": 0.00154, "epss_percentile": 0.36686}, "CVE-2025-5824": {"epss_score": 7e-05, "epss_percentile": 0.00367}, "CVE-2025-5825": {"epss_score": 0.00042, "epss_percentile": 0.12923}, "CVE-2025-5826": {"epss_score": 0.00035, "epss_percentile": 0.0982}, "CVE-2025-5827": {"epss_score": 0.00044, "epss_percentile": 0.13457}, "CVE-2025-5828": {"epss_score": 0.00059, "epss_percentile": 0.18923}, "CVE-2025-5829": {"epss_score": 0.00059, "epss_percentile": 0.18923}, "CVE-2025-5830": {"epss_score": 0.00044, "epss_percentile": 0.13457}, "CVE-2025-5831": {"epss_score": 0.00219, "epss_percentile": 0.44526}, "CVE-2025-5832": {"epss_score": 0.00023, "epss_percentile": 0.05442}, "CVE-2025-5833": {"epss_score": 0.00013, "epss_percentile": 0.01593}, "CVE-2025-5834": {"epss_score": 0.00012, "epss_percentile": 0.01141}, "CVE-2025-5835": {"epss_score": 0.00056, "epss_percentile": 0.17737}, "CVE-2025-5836": {"epss_score": 0.01263, "epss_percentile": 0.78987}, "CVE-2025-5837": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5838": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5839": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-5840": {"epss_score": 0.00074, "epss_percentile": 0.22767}, "CVE-2025-5841": {"epss_score": 0.00042, "epss_percentile": 0.12708}, "CVE-2025-5842": {"epss_score": 0.00028, "epss_percentile": 0.07566}, "CVE-2025-5843": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-5844": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-5845": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-5846": {"epss_score": 0.00014, "epss_percentile": 0.01924}, "CVE-2025-5847": {"epss_score": 0.00156, "epss_percentile": 0.36896}, "CVE-2025-5848": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-5849": {"epss_score": 0.00156, "epss_percentile": 0.36896}, "CVE-2025-5850": {"epss_score": 0.00218, "epss_percentile": 0.44434}, "CVE-2025-5851": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-5852": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-5853": {"epss_score": 0.00233, "epss_percentile": 0.46045}, "CVE-2025-5854": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-5855": {"epss_score": 0.00219, "epss_percentile": 0.44507}, "CVE-2025-5856": {"epss_score": 0.00032, "epss_percentile": 0.08994}, "CVE-2025-5857": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5858": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5859": {"epss_score": 0.00042, "epss_percentile": 0.12826}, "CVE-2025-5860": {"epss_score": 0.00044, "epss_percentile": 0.13382}, "CVE-2025-5861": {"epss_score": 0.00271, "epss_percentile": 0.50275}, "CVE-2025-5862": {"epss_score": 0.00208, "epss_percentile": 0.43292}, "CVE-2025-5863": {"epss_score": 0.00219, "epss_percentile": 0.44507}, "CVE-2025-5864": {"epss_score": 0.00069, "epss_percentile": 0.21589}, "CVE-2025-5865": {"epss_score": 0.00326, "epss_percentile": 0.55051}, "CVE-2025-5866": {"epss_score": 0.00263, "epss_percentile": 0.49511}, "CVE-2025-5867": {"epss_score": 0.00314, "epss_percentile": 0.54096}, "CVE-2025-5868": {"epss_score": 0.00213, "epss_percentile": 0.43903}, "CVE-2025-5869": {"epss_score": 0.00263, "epss_percentile": 0.49511}, "CVE-2025-5870": {"epss_score": 0.00061, "epss_percentile": 0.19299}, "CVE-2025-5871": {"epss_score": 0.00047, "epss_percentile": 0.14591}, "CVE-2025-5872": {"epss_score": 0.00047, "epss_percentile": 0.14591}, "CVE-2025-5873": {"epss_score": 0.00045, "epss_percentile": 0.13745}, "CVE-2025-5874": {"epss_score": 0.0002, "epss_percentile": 0.04684}, "CVE-2025-5875": {"epss_score": 0.0026, "epss_percentile": 0.49192}, "CVE-2025-5876": {"epss_score": 0.00047, "epss_percentile": 0.14591}, "CVE-2025-5877": {"epss_score": 0.0003, "epss_percentile": 0.08085}, "CVE-2025-5878": {"epss_score": 0.00139, "epss_percentile": 0.34618}, "CVE-2025-5879": {"epss_score": 0.0002, "epss_percentile": 0.04509}, "CVE-2025-5880": {"epss_score": 0.00028, "epss_percentile": 0.07378}, "CVE-2025-5881": {"epss_score": 0.00031, "epss_percentile": 0.08589}, "CVE-2025-5884": {"epss_score": 0.00029, "epss_percentile": 0.07903}, "CVE-2025-5885": {"epss_score": 0.00018, "epss_percentile": 0.0388}, "CVE-2025-5886": {"epss_score": 0.0004, "epss_percentile": 0.12114}, "CVE-2025-5887": {"epss_score": 0.00021, "epss_percentile": 0.04848}, "CVE-2025-5888": {"epss_score": 0.00044, "epss_percentile": 0.13539}, "CVE-2025-5889": {"epss_score": 0.0002, "epss_percentile": 0.04538}, "CVE-2025-5890": {"epss_score": 0.00049, "epss_percentile": 0.15348}, "CVE-2025-5891": {"epss_score": 0.00079, "epss_percentile": 0.23901}, "CVE-2025-5892": {"epss_score": 0.00106, "epss_percentile": 0.29471}, "CVE-2025-5893": {"epss_score": 0.00179, "epss_percentile": 0.39802}, "CVE-2025-5894": {"epss_score": 0.00167, "epss_percentile": 0.38295}, "CVE-2025-5895": {"epss_score": 0.00083, "epss_percentile": 0.24722}, "CVE-2025-5896": {"epss_score": 0.00117, "epss_percentile": 0.31285}, "CVE-2025-5897": {"epss_score": 0.001, "epss_percentile": 0.28496}, "CVE-2025-5898": {"epss_score": 0.00018, "epss_percentile": 0.03677}, "CVE-2025-5899": {"epss_score": 0.00018, "epss_percentile": 0.03677}, "CVE-2025-5900": {"epss_score": 0.00039, "epss_percentile": 0.11728}, "CVE-2025-5901": {"epss_score": 0.00577, "epss_percentile": 0.68175}, "CVE-2025-5902": {"epss_score": 0.00582, "epss_percentile": 0.68302}, "CVE-2025-5903": {"epss_score": 0.00582, "epss_percentile": 0.68302}, "CVE-2025-5904": {"epss_score": 0.00582, "epss_percentile": 0.68302}, "CVE-2025-5905": {"epss_score": 0.00582, "epss_percentile": 0.68302}, "CVE-2025-5906": {"epss_score": 0.00202, "epss_percentile": 0.42431}, "CVE-2025-5907": {"epss_score": 0.00582, "epss_percentile": 0.68302}, "CVE-2025-5908": {"epss_score": 0.00386, "epss_percentile": 0.5927}, "CVE-2025-5909": {"epss_score": 0.00386, "epss_percentile": 0.5927}, "CVE-2025-5910": {"epss_score": 0.00386, "epss_percentile": 0.5927}, "CVE-2025-5911": {"epss_score": 0.00386, "epss_percentile": 0.5927}, "CVE-2025-5912": {"epss_score": 0.00277, "epss_percentile": 0.50794}, "CVE-2025-5913": {"epss_score": 0.00032, "epss_percentile": 0.08994}, "CVE-2025-5914": {"epss_score": 0.0008, "epss_percentile": 0.24167}, "CVE-2025-5915": {"epss_score": 0.0003, "epss_percentile": 0.08111}, "CVE-2025-5916": {"epss_score": 0.00026, "epss_percentile": 0.06576}, "CVE-2025-5917": {"epss_score": 0.00022, "epss_percentile": 0.05241}, "CVE-2025-5918": {"epss_score": 0.00021, "epss_percentile": 0.04943}, "CVE-2025-5919": {"epss_score": 0.00045, "epss_percentile": 0.13903}, "CVE-2025-5920": {"epss_score": 0.00042, "epss_percentile": 0.12575}, "CVE-2025-5921": {"epss_score": 0.00068, "epss_percentile": 0.21298}, "CVE-2025-5922": {"epss_score": 0.0001, "epss_percentile": 0.00884}, "CVE-2025-5923": {"epss_score": 0.00042, "epss_percentile": 0.12708}, "CVE-2025-5924": {"epss_score": 0.00013, "epss_percentile": 0.01492}, "CVE-2025-5925": {"epss_score": 0.00014, "epss_percentile": 0.0178}, "CVE-2025-5926": {"epss_score": 0.00013, "epss_percentile": 0.01575}, "CVE-2025-5927": {"epss_score": 0.00436, "epss_percentile": 0.62434}, "CVE-2025-5928": {"epss_score": 0.00014, "epss_percentile": 0.0178}, "CVE-2025-5929": {"epss_score": 0.00024, "epss_percentile": 0.05997}, "CVE-2025-5930": {"epss_score": 0.00012, "epss_percentile": 0.01304}, "CVE-2025-5931": {"epss_score": 0.00075, "epss_percentile": 0.23056}, "CVE-2025-5932": {"epss_score": 0.00013, "epss_percentile": 0.01492}, "CVE-2025-5933": {"epss_score": 0.00013, "epss_percentile": 0.01492}, "CVE-2025-5934": {"epss_score": 0.00193, "epss_percentile": 0.41431}, "CVE-2025-5935": {"epss_score": 0.00296, "epss_percentile": 0.5258}, "CVE-2025-5936": {"epss_score": 0.00013, "epss_percentile": 0.01492}, "CVE-2025-5937": {"epss_score": 0.00011, "epss_percentile": 0.01091}, "CVE-2025-5938": {"epss_score": 0.00014, "epss_percentile": 0.0178}, "CVE-2025-5939": {"epss_score": 0.00022, "epss_percentile": 0.05154}, "CVE-2025-5940": {"epss_score": 0.00024, "epss_percentile": 0.05997}, "CVE-2025-5941": {"epss_score": 0.00027, "epss_percentile": 0.06983}, "CVE-2025-5942": {"epss_score": 0.00027, "epss_percentile": 0.06983}, "CVE-2025-5943": {"epss_score": 0.00174, "epss_percentile": 0.39216}, "CVE-2025-5944": {"epss_score": 0.00065, "epss_percentile": 0.20461}, "CVE-2025-5946": {"epss_score": 0.28547, "epss_percentile": 0.96366}, "CVE-2025-5947": {"epss_score": 0.00953, "epss_percentile": 0.75885}, "CVE-2025-5948": {"epss_score": 0.00147, "epss_percentile": 0.35666}, "CVE-2025-5949": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-5950": {"epss_score": 0.00026, "epss_percentile": 0.06581}, "CVE-2025-5952": {"epss_score": 0.00482, "epss_percentile": 0.64553}, "CVE-2025-5953": {"epss_score": 0.00074, "epss_percentile": 0.22778}, "CVE-2025-5954": {"epss_score": 0.00155, "epss_percentile": 0.36816}, "CVE-2025-5955": {"epss_score": 0.00266, "epss_percentile": 0.49879}, "CVE-2025-5956": {"epss_score": 0.00034, "epss_percentile": 0.09803}, "CVE-2025-5957": {"epss_score": 0.00124, "epss_percentile": 0.32379}, "CVE-2025-5958": {"epss_score": 0.00061, "epss_percentile": 0.19349}, "CVE-2025-5959": {"epss_score": 0.00043, "epss_percentile": 0.13284}, "CVE-2025-5961": {"epss_score": 0.02035, "epss_percentile": 0.83349}, "CVE-2025-5962": {"epss_score": 0.00021, "epss_percentile": 0.04834}, "CVE-2025-5963": {"epss_score": 0.00015, "epss_percentile": 0.02584}, "CVE-2025-5964": {"epss_score": 0.00036, "epss_percentile": 0.1051}, "CVE-2025-5965": {"epss_score": 0.00105, "epss_percentile": 0.29338}, "CVE-2025-5966": {"epss_score": 0.00113, "epss_percentile": 0.30724}, "CVE-2025-5967": {"epss_score": 0.00022, "epss_percentile": 0.05064}, "CVE-2025-5969": {"epss_score": 0.00279, "epss_percentile": 0.50964}, "CVE-2025-5970": {"epss_score": 0.0003, "epss_percentile": 0.08169}, "CVE-2025-5971": {"epss_score": 0.00045, "epss_percentile": 0.13798}, "CVE-2025-5972": {"epss_score": 0.0003, "epss_percentile": 0.08169}, "CVE-2025-5973": {"epss_score": 0.0003, "epss_percentile": 0.08169}, "CVE-2025-5974": {"epss_score": 0.00031, "epss_percentile": 0.08473}, "CVE-2025-5975": {"epss_score": 0.0004, "epss_percentile": 0.12058}, "CVE-2025-5976": {"epss_score": 0.00031, "epss_percentile": 0.08473}, "CVE-2025-5977": {"epss_score": 0.00032, "epss_percentile": 0.08994}, "CVE-2025-5978": {"epss_score": 0.00368, "epss_percentile": 0.58218}, "CVE-2025-5979": {"epss_score": 0.00032, "epss_percentile": 0.08994}, "CVE-2025-5980": {"epss_score": 0.00032, "epss_percentile": 0.08994}, "CVE-2025-5981": {"epss_score": 0.00032, "epss_percentile": 0.09008}, "CVE-2025-5982": {"epss_score": 0.00013, "epss_percentile": 0.01476}, "CVE-2025-5983": {"epss_score": 0.00055, "epss_percentile": 0.17369}, "CVE-2025-5984": {"epss_score": 0.00028, "epss_percentile": 0.07266}, "CVE-2025-5985": {"epss_score": 0.00203, "epss_percentile": 0.42551}, "CVE-2025-5986": {"epss_score": 0.00078, "epss_percentile": 0.23686}, "CVE-2025-5987": {"epss_score": 0.00061, "epss_percentile": 0.19477}, "CVE-2025-5988": {"epss_score": 0.00013, "epss_percentile": 0.01435}, "CVE-2025-5990": {"epss_score": 0.00037, "epss_percentile": 0.10994}, "CVE-2025-5991": {"epss_score": 0.00017, "epss_percentile": 0.03093}, "CVE-2025-5992": {"epss_score": 0.00066, "epss_percentile": 0.20955}, "CVE-2025-5993": {"epss_score": 0.00436, "epss_percentile": 0.62456}, "CVE-2025-5994": {"epss_score": 0.00052, "epss_percentile": 0.16369}, "CVE-2025-5995": {"epss_score": 0.00017, "epss_percentile": 0.03144}, "CVE-2025-5996": {"epss_score": 0.0012, "epss_percentile": 0.3177}, "CVE-2025-5997": {"epss_score": 0.00056, "epss_percentile": 0.17737}, "CVE-2025-5998": {"epss_score": 0.00051, "epss_percentile": 0.1629}, "CVE-2025-5999": {"epss_score": 0.00019, "epss_percentile": 0.04364}, "CVE-2025-60000": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-60001": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-60002": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-60004": {"epss_score": 0.0006, "epss_percentile": 0.19004}, "CVE-2025-60006": {"epss_score": 0.00464, "epss_percentile": 0.63715}, "CVE-2025-60009": {"epss_score": 0.00047, "epss_percentile": 0.14924}, "CVE-2025-60010": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-60013": {"epss_score": 0.00043, "epss_percentile": 0.13028}, "CVE-2025-60015": {"epss_score": 0.0003, "epss_percentile": 0.07985}, "CVE-2025-60016": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-60017": {"epss_score": 0.00185, "epss_percentile": 0.40516}, "CVE-2025-60018": {"epss_score": 0.00055, "epss_percentile": 0.17501}, "CVE-2025-60019": {"epss_score": 0.00047, "epss_percentile": 0.14803}, "CVE-2025-60020": {"epss_score": 0.00071, "epss_percentile": 0.22047}, "CVE-2025-60022": {"epss_score": 0.00024, "epss_percentile": 0.0569}, "CVE-2025-60023": {"epss_score": 0.00114, "epss_percentile": 0.30811}, "CVE-2025-60024": {"epss_score": 0.00055, "epss_percentile": 0.17454}, "CVE-2025-60039": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-60040": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-60041": {"epss_score": 0.00069, "epss_percentile": 0.21466}, "CVE-2025-60042": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-60043": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-60044": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-60045": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-60046": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-60047": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-60048": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-60049": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-60050": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-60051": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-60052": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-60053": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-60054": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-60055": {"epss_score": 0.00147, "epss_percentile": 0.35709}, "CVE-2025-60056": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-60057": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-60058": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-60059": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-60060": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-60061": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-60062": {"epss_score": 0.00039, "epss_percentile": 0.11697}, "CVE-2025-60063": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-60064": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-60065": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-60066": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-60067": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-60068": {"epss_score": 0.00051, "epss_percentile": 0.16158}, "CVE-2025-60069": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-60070": {"epss_score": 0.00051, "epss_percentile": 0.16158}, "CVE-2025-60071": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-60072": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-60073": {"epss_score": 0.00124, "epss_percentile": 0.32398}, "CVE-2025-60074": {"epss_score": 0.00057, "epss_percentile": 0.18154}, "CVE-2025-60075": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-60076": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-60077": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-60078": {"epss_score": 0.00052, "epss_percentile": 0.1638}, "CVE-2025-60079": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-60080": {"epss_score": 0.00054, "epss_percentile": 0.17088}, "CVE-2025-60081": {"epss_score": 0.00054, "epss_percentile": 0.17088}, "CVE-2025-60082": {"epss_score": 0.00054, "epss_percentile": 0.17088}, "CVE-2025-60083": {"epss_score": 0.00054, "epss_percentile": 0.17088}, "CVE-2025-60084": {"epss_score": 0.00053, "epss_percentile": 0.16687}, "CVE-2025-60086": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-60088": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-60089": {"epss_score": 0.00054, "epss_percentile": 0.17186}, "CVE-2025-60090": {"epss_score": 0.00054, "epss_percentile": 0.17186}, "CVE-2025-60091": {"epss_score": 0.00054, "epss_percentile": 0.17186}, "CVE-2025-60092": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-60093": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-60094": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-60095": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-60096": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-60097": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-60098": {"epss_score": 0.00056, "epss_percentile": 0.17954}, "CVE-2025-60099": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-60100": {"epss_score": 0.00058, "epss_percentile": 0.18453}, "CVE-2025-60101": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60102": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-60103": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-60104": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60105": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-60106": {"epss_score": 0.0005, "epss_percentile": 0.15942}, "CVE-2025-60107": {"epss_score": 0.00044, "epss_percentile": 0.13582}, "CVE-2025-60108": {"epss_score": 0.00044, "epss_percentile": 0.13582}, "CVE-2025-60109": {"epss_score": 0.00044, "epss_percentile": 0.13582}, "CVE-2025-60110": {"epss_score": 0.00044, "epss_percentile": 0.13582}, "CVE-2025-60111": {"epss_score": 0.00032, "epss_percentile": 0.08784}, "CVE-2025-60112": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-60113": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-60114": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2025-60115": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-60116": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-60117": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-60118": {"epss_score": 0.00044, "epss_percentile": 0.13582}, "CVE-2025-60119": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-60120": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-60121": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-60122": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-60123": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-60124": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-60125": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-60126": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-60127": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-60128": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-60129": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-60130": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-60131": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2025-60132": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-60133": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60134": {"epss_score": 0.00021, "epss_percentile": 0.04695}, "CVE-2025-60135": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60136": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60137": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-60138": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-60139": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-60140": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-60141": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60142": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-60143": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-60144": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60145": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-60146": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60147": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-60148": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-60149": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60150": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-60151": {"epss_score": 0.00038, "epss_percentile": 0.11388}, "CVE-2025-60152": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-60153": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-60154": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60155": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-60156": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-60157": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-60158": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60159": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-60160": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60161": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2025-60162": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-60163": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-60164": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-60165": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-60166": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-60167": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-60168": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-60169": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-60170": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-60171": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-60172": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-60173": {"epss_score": 0.00019, "epss_percentile": 0.04387}, "CVE-2025-60174": {"epss_score": 0.00054, "epss_percentile": 0.17186}, "CVE-2025-60176": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60177": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60178": {"epss_score": 0.00174, "epss_percentile": 0.39172}, "CVE-2025-60179": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60180": {"epss_score": 0.00054, "epss_percentile": 0.17186}, "CVE-2025-60181": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2025-60182": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-60184": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60185": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60186": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-60187": {"epss_score": 0.00039, "epss_percentile": 0.11732}, "CVE-2025-60188": {"epss_score": 0.00046, "epss_percentile": 0.14326}, "CVE-2025-60189": {"epss_score": 0.00124, "epss_percentile": 0.32398}, "CVE-2025-60190": {"epss_score": 0.0005, "epss_percentile": 0.15948}, "CVE-2025-60191": {"epss_score": 0.00057, "epss_percentile": 0.18154}, "CVE-2025-60192": {"epss_score": 0.00057, "epss_percentile": 0.18154}, "CVE-2025-60193": {"epss_score": 0.00057, "epss_percentile": 0.18154}, "CVE-2025-60194": {"epss_score": 0.00057, "epss_percentile": 0.18154}, "CVE-2025-60195": {"epss_score": 0.00059, "epss_percentile": 0.18882}, "CVE-2025-60196": {"epss_score": 0.00147, "epss_percentile": 0.35678}, "CVE-2025-60197": {"epss_score": 0.00061, "epss_percentile": 0.19445}, "CVE-2025-60198": {"epss_score": 0.00165, "epss_percentile": 0.38013}, "CVE-2025-60199": {"epss_score": 0.00061, "epss_percentile": 0.19445}, "CVE-2025-60200": {"epss_score": 0.00061, "epss_percentile": 0.19445}, "CVE-2025-60201": {"epss_score": 0.00061, "epss_percentile": 0.19445}, "CVE-2025-60202": {"epss_score": 0.00061, "epss_percentile": 0.19445}, "CVE-2025-60203": {"epss_score": 0.00061, "epss_percentile": 0.19445}, "CVE-2025-60204": {"epss_score": 0.00061, "epss_percentile": 0.19445}, "CVE-2025-60206": {"epss_score": 0.00071, "epss_percentile": 0.22204}, "CVE-2025-60207": {"epss_score": 0.00061, "epss_percentile": 0.19455}, "CVE-2025-60208": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-60209": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-60210": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-60211": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-60212": {"epss_score": 0.00071, "epss_percentile": 0.22114}, "CVE-2025-60213": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-60214": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-60215": {"epss_score": 0.00071, "epss_percentile": 0.22114}, "CVE-2025-60216": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-60217": {"epss_score": 0.00074, "epss_percentile": 0.22834}, "CVE-2025-60219": {"epss_score": 0.00064, "epss_percentile": 0.20262}, "CVE-2025-60220": {"epss_score": 0.00062, "epss_percentile": 0.19687}, "CVE-2025-60221": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-60222": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-60224": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-60225": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-60226": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-60227": {"epss_score": 0.00085, "epss_percentile": 0.25045}, "CVE-2025-60228": {"epss_score": 0.00071, "epss_percentile": 0.22114}, "CVE-2025-60232": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-60234": {"epss_score": 0.00071, "epss_percentile": 0.22114}, "CVE-2025-60235": {"epss_score": 0.00061, "epss_percentile": 0.19455}, "CVE-2025-60238": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-60239": {"epss_score": 0.00039, "epss_percentile": 0.11662}, "CVE-2025-60240": {"epss_score": 0.00124, "epss_percentile": 0.32398}, "CVE-2025-60241": {"epss_score": 0.00124, "epss_percentile": 0.32398}, "CVE-2025-60242": {"epss_score": 0.00077, "epss_percentile": 0.23356}, "CVE-2025-60243": {"epss_score": 0.00059, "epss_percentile": 0.18882}, "CVE-2025-60244": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-60245": {"epss_score": 0.00058, "epss_percentile": 0.18511}, "CVE-2025-60246": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-60247": {"epss_score": 0.00043, "epss_percentile": 0.13068}, "CVE-2025-60248": {"epss_score": 0.00147, "epss_percentile": 0.35678}, "CVE-2025-60249": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-60250": {"epss_score": 0.0004, "epss_percentile": 0.12172}, "CVE-2025-60251": {"epss_score": 0.00026, "epss_percentile": 0.06531}, "CVE-2025-60262": {"epss_score": 0.0011, "epss_percentile": 0.30083}, "CVE-2025-60265": {"epss_score": 0.00037, "epss_percentile": 0.1094}, "CVE-2025-60266": {"epss_score": 0.00035, "epss_percentile": 0.09883}, "CVE-2025-60267": {"epss_score": 0.00037, "epss_percentile": 0.1094}, "CVE-2025-60268": {"epss_score": 0.00158, "epss_percentile": 0.37226}, "CVE-2025-60269": {"epss_score": 0.00045, "epss_percentile": 0.1375}, "CVE-2025-60279": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-60280": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-60291": {"epss_score": 0.00045, "epss_percentile": 0.13761}, "CVE-2025-60298": {"epss_score": 0.00039, "epss_percentile": 0.11576}, "CVE-2025-60299": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-60302": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-60304": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-60305": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-60306": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-60307": {"epss_score": 0.00049, "epss_percentile": 0.15605}, "CVE-2025-60308": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-60311": {"epss_score": 0.00043, "epss_percentile": 0.13095}, "CVE-2025-60312": {"epss_score": 0.00066, "epss_percentile": 0.20885}, "CVE-2025-60313": {"epss_score": 0.00095, "epss_percentile": 0.27218}, "CVE-2025-60314": {"epss_score": 0.00052, "epss_percentile": 0.16573}, "CVE-2025-60316": {"epss_score": 0.00048, "epss_percentile": 0.15107}, "CVE-2025-60318": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-60319": {"epss_score": 0.00056, "epss_percentile": 0.17759}, "CVE-2025-60320": {"epss_score": 0.00018, "epss_percentile": 0.03716}, "CVE-2025-60331": {"epss_score": 0.00038, "epss_percentile": 0.11413}, "CVE-2025-60332": {"epss_score": 0.00291, "epss_percentile": 0.52182}, "CVE-2025-60333": {"epss_score": 0.0028, "epss_percentile": 0.51002}, "CVE-2025-60334": {"epss_score": 0.00156, "epss_percentile": 0.36956}, "CVE-2025-60335": {"epss_score": 0.01982, "epss_percentile": 0.8314}, "CVE-2025-60336": {"epss_score": 0.03457, "epss_percentile": 0.87175}, "CVE-2025-60337": {"epss_score": 0.00076, "epss_percentile": 0.23246}, "CVE-2025-60338": {"epss_score": 0.00076, "epss_percentile": 0.23246}, "CVE-2025-60339": {"epss_score": 0.00076, "epss_percentile": 0.23246}, "CVE-2025-60340": {"epss_score": 0.00076, "epss_percentile": 0.23246}, "CVE-2025-60341": {"epss_score": 0.00076, "epss_percentile": 0.23246}, "CVE-2025-60342": {"epss_score": 0.00076, "epss_percentile": 0.23246}, "CVE-2025-60343": {"epss_score": 0.00076, "epss_percentile": 0.23246}, "CVE-2025-60344": {"epss_score": 0.00064, "epss_percentile": 0.20402}, "CVE-2025-60349": {"epss_score": 0.00059, "epss_percentile": 0.18927}, "CVE-2025-60354": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-60355": {"epss_score": 0.00071, "epss_percentile": 0.22204}, "CVE-2025-60358": {"epss_score": 0.00018, "epss_percentile": 0.03733}, "CVE-2025-60359": {"epss_score": 0.00018, "epss_percentile": 0.03733}, "CVE-2025-60360": {"epss_score": 0.00018, "epss_percentile": 0.03733}, "CVE-2025-60361": {"epss_score": 0.00018, "epss_percentile": 0.03881}, "CVE-2025-60374": {"epss_score": 0.00016, "epss_percentile": 0.02849}, "CVE-2025-60375": {"epss_score": 0.00074, "epss_percentile": 0.22749}, "CVE-2025-60378": {"epss_score": 0.0011, "epss_percentile": 0.30195}, "CVE-2025-60419": {"epss_score": 0.00017, "epss_percentile": 0.03516}, "CVE-2025-60424": {"epss_score": 0.00356, "epss_percentile": 0.57342}, "CVE-2025-60425": {"epss_score": 0.01636, "epss_percentile": 0.81475}, "CVE-2025-60427": {"epss_score": 0.00033, "epss_percentile": 0.09131}, "CVE-2025-60445": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-60447": {"epss_score": 0.00065, "epss_percentile": 0.20674}, "CVE-2025-60448": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-60449": {"epss_score": 0.00054, "epss_percentile": 0.17259}, "CVE-2025-60450": {"epss_score": 0.00059, "epss_percentile": 0.18754}, "CVE-2025-60451": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-60452": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-60453": {"epss_score": 0.00016, "epss_percentile": 0.02947}, "CVE-2025-60454": {"epss_score": 0.00016, "epss_percentile": 0.02947}, "CVE-2025-60455": {"epss_score": 0.00029, "epss_percentile": 0.07652}, "CVE-2025-60458": {"epss_score": 0.00049, "epss_percentile": 0.15547}, "CVE-2025-60500": {"epss_score": 0.00079, "epss_percentile": 0.2396}, "CVE-2025-60503": {"epss_score": 0.00038, "epss_percentile": 0.11195}, "CVE-2025-60506": {"epss_score": 0.00039, "epss_percentile": 0.11576}, "CVE-2025-60507": {"epss_score": 0.00054, "epss_percentile": 0.17095}, "CVE-2025-60511": {"epss_score": 0.0004, "epss_percentile": 0.11866}, "CVE-2025-60514": {"epss_score": 0.00015, "epss_percentile": 0.02431}, "CVE-2025-60534": {"epss_score": 0.00084, "epss_percentile": 0.24961}, "CVE-2025-60535": {"epss_score": 0.00025, "epss_percentile": 0.0612}, "CVE-2025-60536": {"epss_score": 0.00018, "epss_percentile": 0.03849}, "CVE-2025-60537": {"epss_score": 0.00091, "epss_percentile": 0.26262}, "CVE-2025-60540": {"epss_score": 0.00018, "epss_percentile": 0.03932}, "CVE-2025-60541": {"epss_score": 0.00061, "epss_percentile": 0.194}, "CVE-2025-60542": {"epss_score": 0.00047, "epss_percentile": 0.14488}, "CVE-2025-60547": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60548": {"epss_score": 0.00159, "epss_percentile": 0.37332}, "CVE-2025-60549": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60550": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60551": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60552": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60553": {"epss_score": 0.00159, "epss_percentile": 0.37332}, "CVE-2025-60554": {"epss_score": 0.00159, "epss_percentile": 0.37332}, "CVE-2025-60555": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60556": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60557": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60558": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60559": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60561": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60562": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60563": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60564": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60565": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60566": {"epss_score": 0.00131, "epss_percentile": 0.33472}, "CVE-2025-60568": {"epss_score": 0.0008, "epss_percentile": 0.24163}, "CVE-2025-60569": {"epss_score": 0.00024, "epss_percentile": 0.05793}, "CVE-2025-60570": {"epss_score": 0.00032, "epss_percentile": 0.09035}, "CVE-2025-60571": {"epss_score": 0.00032, "epss_percentile": 0.09035}, "CVE-2025-60572": {"epss_score": 0.00032, "epss_percentile": 0.09035}, "CVE-2025-60574": {"epss_score": 0.0008, "epss_percentile": 0.24044}, "CVE-2025-60595": {"epss_score": 0.00071, "epss_percentile": 0.22028}, "CVE-2025-60632": {"epss_score": 0.0005, "epss_percentile": 0.15742}, "CVE-2025-60633": {"epss_score": 0.00059, "epss_percentile": 0.18645}, "CVE-2025-60638": {"epss_score": 0.00068, "epss_percentile": 0.21306}, "CVE-2025-60639": {"epss_score": 0.00042, "epss_percentile": 0.12734}, "CVE-2025-60641": {"epss_score": 0.00149, "epss_percentile": 0.36006}, "CVE-2025-60645": {"epss_score": 0.00021, "epss_percentile": 0.04926}, "CVE-2025-60646": {"epss_score": 0.00042, "epss_percentile": 0.12901}, "CVE-2025-60660": {"epss_score": 0.00077, "epss_percentile": 0.23324}, "CVE-2025-60661": {"epss_score": 0.00024, "epss_percentile": 0.05815}, "CVE-2025-60662": {"epss_score": 0.00077, "epss_percentile": 0.23324}, "CVE-2025-60663": {"epss_score": 0.00077, "epss_percentile": 0.23324}, "CVE-2025-60671": {"epss_score": 0.01181, "epss_percentile": 0.78312}, "CVE-2025-60672": {"epss_score": 0.00407, "epss_percentile": 0.60585}, "CVE-2025-60673": {"epss_score": 0.00407, "epss_percentile": 0.60585}, "CVE-2025-60674": {"epss_score": 0.0005, "epss_percentile": 0.1588}, "CVE-2025-60675": {"epss_score": 0.01181, "epss_percentile": 0.78312}, "CVE-2025-60676": {"epss_score": 0.00407, "epss_percentile": 0.60585}, "CVE-2025-60679": {"epss_score": 0.00129, "epss_percentile": 0.33187}, "CVE-2025-60682": {"epss_score": 0.01916, "epss_percentile": 0.82861}, "CVE-2025-60683": {"epss_score": 0.14488, "epss_percentile": 0.94221}, "CVE-2025-60684": {"epss_score": 0.00547, "epss_percentile": 0.67258}, "CVE-2025-60685": {"epss_score": 0.00023, "epss_percentile": 0.05433}, "CVE-2025-60686": {"epss_score": 0.00023, "epss_percentile": 0.05408}, "CVE-2025-60687": {"epss_score": 0.11912, "epss_percentile": 0.93513}, "CVE-2025-60688": {"epss_score": 0.00547, "epss_percentile": 0.67258}, "CVE-2025-60689": {"epss_score": 0.00346, "epss_percentile": 0.56647}, "CVE-2025-60690": {"epss_score": 0.00789, "epss_percentile": 0.7336}, "CVE-2025-60691": {"epss_score": 0.00789, "epss_percentile": 0.7336}, "CVE-2025-60692": {"epss_score": 0.00019, "epss_percentile": 0.04082}, "CVE-2025-60693": {"epss_score": 0.01661, "epss_percentile": 0.81625}, "CVE-2025-60694": {"epss_score": 0.04174, "epss_percentile": 0.8835}, "CVE-2025-60695": {"epss_score": 0.0002, "epss_percentile": 0.04565}, "CVE-2025-60696": {"epss_score": 0.00019, "epss_percentile": 0.04082}, "CVE-2025-60697": {"epss_score": 0.00479, "epss_percentile": 0.64417}, "CVE-2025-60698": {"epss_score": 0.00479, "epss_percentile": 0.64417}, "CVE-2025-60699": {"epss_score": 0.01547, "epss_percentile": 0.80974}, "CVE-2025-60700": {"epss_score": 0.00172, "epss_percentile": 0.38941}, "CVE-2025-60701": {"epss_score": 0.00172, "epss_percentile": 0.38941}, "CVE-2025-60702": {"epss_score": 0.00707, "epss_percentile": 0.71659}, "CVE-2025-60703": {"epss_score": 0.00057, "epss_percentile": 0.18001}, "CVE-2025-60704": {"epss_score": 0.00041, "epss_percentile": 0.12242}, "CVE-2025-60705": {"epss_score": 0.0007, "epss_percentile": 0.21784}, "CVE-2025-60706": {"epss_score": 0.00048, "epss_percentile": 0.15278}, "CVE-2025-60707": {"epss_score": 0.00065, "epss_percentile": 0.20518}, "CVE-2025-60708": {"epss_score": 0.00048, "epss_percentile": 0.15276}, "CVE-2025-60709": {"epss_score": 0.00057, "epss_percentile": 0.18001}, "CVE-2025-60710": {"epss_score": 0.00203, "epss_percentile": 0.42525}, "CVE-2025-60711": {"epss_score": 0.00083, "epss_percentile": 0.24641}, "CVE-2025-60713": {"epss_score": 0.00057, "epss_percentile": 0.18001}, "CVE-2025-60714": {"epss_score": 0.00068, "epss_percentile": 0.21402}, "CVE-2025-60715": {"epss_score": 0.00071, "epss_percentile": 0.22074}, "CVE-2025-60716": {"epss_score": 0.00052, "epss_percentile": 0.16497}, "CVE-2025-60717": {"epss_score": 0.00052, "epss_percentile": 0.16497}, "CVE-2025-60718": {"epss_score": 0.00114, "epss_percentile": 0.30851}, "CVE-2025-60719": {"epss_score": 0.0007, "epss_percentile": 0.21712}, "CVE-2025-60720": {"epss_score": 0.00057, "epss_percentile": 0.18001}, "CVE-2025-60721": {"epss_score": 0.00052, "epss_percentile": 0.16559}, "CVE-2025-60722": {"epss_score": 0.00107, "epss_percentile": 0.29679}, "CVE-2025-60723": {"epss_score": 0.00076, "epss_percentile": 0.23109}, "CVE-2025-60724": {"epss_score": 0.00143, "epss_percentile": 0.35222}, "CVE-2025-60726": {"epss_score": 0.00061, "epss_percentile": 0.19285}, "CVE-2025-60727": {"epss_score": 0.00068, "epss_percentile": 0.21402}, "CVE-2025-60728": {"epss_score": 0.00058, "epss_percentile": 0.18572}, "CVE-2025-60729": {"epss_score": 0.00052, "epss_percentile": 0.16582}, "CVE-2025-60730": {"epss_score": 0.00071, "epss_percentile": 0.21991}, "CVE-2025-60731": {"epss_score": 0.00058, "epss_percentile": 0.18561}, "CVE-2025-60735": {"epss_score": 0.00058, "epss_percentile": 0.18561}, "CVE-2025-60736": {"epss_score": 0.00041, "epss_percentile": 0.12443}, "CVE-2025-60737": {"epss_score": 0.00083, "epss_percentile": 0.246}, "CVE-2025-60738": {"epss_score": 0.00363, "epss_percentile": 0.57822}, "CVE-2025-60739": {"epss_score": 0.00096, "epss_percentile": 0.27267}, "CVE-2025-60749": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2025-60751": {"epss_score": 0.00018, "epss_percentile": 0.03883}, "CVE-2025-60753": {"epss_score": 0.0002, "epss_percentile": 0.04655}, "CVE-2025-60772": {"epss_score": 0.0031, "epss_percentile": 0.53751}, "CVE-2025-60781": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-60782": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-60783": {"epss_score": 0.00037, "epss_percentile": 0.1094}, "CVE-2025-60784": {"epss_score": 0.00056, "epss_percentile": 0.17886}, "CVE-2025-60785": {"epss_score": 0.00181, "epss_percentile": 0.40072}, "CVE-2025-60786": {"epss_score": 0.00085, "epss_percentile": 0.25166}, "CVE-2025-60787": {"epss_score": 0.34368, "epss_percentile": 0.96843}, "CVE-2025-60790": {"epss_score": 0.00058, "epss_percentile": 0.18409}, "CVE-2025-60791": {"epss_score": 8e-05, "epss_percentile": 0.00527}, "CVE-2025-60794": {"epss_score": 0.00022, "epss_percentile": 0.05269}, "CVE-2025-60796": {"epss_score": 0.00048, "epss_percentile": 0.15284}, "CVE-2025-60797": {"epss_score": 0.00033, "epss_percentile": 0.09346}, "CVE-2025-60798": {"epss_score": 0.00031, "epss_percentile": 0.08687}, "CVE-2025-60799": {"epss_score": 0.00012, "epss_percentile": 0.01304}, "CVE-2025-60800": {"epss_score": 0.0006, "epss_percentile": 0.18936}, "CVE-2025-60801": {"epss_score": 0.00158, "epss_percentile": 0.37226}, "CVE-2025-60803": {"epss_score": 0.00379, "epss_percentile": 0.58853}, "CVE-2025-60805": {"epss_score": 0.00046, "epss_percentile": 0.14105}, "CVE-2025-60828": {"epss_score": 0.00071, "epss_percentile": 0.22103}, "CVE-2025-60830": {"epss_score": 0.00071, "epss_percentile": 0.22103}, "CVE-2025-60833": {"epss_score": 0.00106, "epss_percentile": 0.29491}, "CVE-2025-60834": {"epss_score": 0.00095, "epss_percentile": 0.27163}, "CVE-2025-60837": {"epss_score": 0.00039, "epss_percentile": 0.11692}, "CVE-2025-60838": {"epss_score": 0.00065, "epss_percentile": 0.20516}, "CVE-2025-60852": {"epss_score": 0.00087, "epss_percentile": 0.25516}, "CVE-2025-60854": {"epss_score": 0.00101, "epss_percentile": 0.2865}, "CVE-2025-60855": {"epss_score": 0.00016, "epss_percentile": 0.02751}, "CVE-2025-60856": {"epss_score": 0.00029, "epss_percentile": 0.07695}, "CVE-2025-60858": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-60859": {"epss_score": 0.00062, "epss_percentile": 0.19733}, "CVE-2025-60868": {"epss_score": 0.0004, "epss_percentile": 0.11923}, "CVE-2025-60869": {"epss_score": 0.00044, "epss_percentile": 0.13495}, "CVE-2025-60876": {"epss_score": 0.0005, "epss_percentile": 0.15862}, "CVE-2025-60880": {"epss_score": 0.00017, "epss_percentile": 0.03166}, "CVE-2025-60892": {"epss_score": 0.0002, "epss_percentile": 0.04628}, "CVE-2025-60898": {"epss_score": 0.00057, "epss_percentile": 0.18223}, "CVE-2025-60912": {"epss_score": 0.00089, "epss_percentile": 0.25972}, "CVE-2025-60914": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-60915": {"epss_score": 0.00049, "epss_percentile": 0.15353}, "CVE-2025-60916": {"epss_score": 0.00055, "epss_percentile": 0.1752}, "CVE-2025-60917": {"epss_score": 0.00038, "epss_percentile": 0.1141}, "CVE-2025-60925": {"epss_score": 0.00039, "epss_percentile": 0.11732}, "CVE-2025-60932": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-60933": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-60934": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-60935": {"epss_score": 0.00075, "epss_percentile": 0.23008}, "CVE-2025-60936": {"epss_score": 0.00047, "epss_percentile": 0.14781}, "CVE-2025-60938": {"epss_score": 0.00309, "epss_percentile": 0.53676}, "CVE-2025-60950": {"epss_score": 0.00045, "epss_percentile": 0.13981}, "CVE-2025-60954": {"epss_score": 0.00061, "epss_percentile": 0.19415}, "CVE-2025-60956": {"epss_score": 0.00022, "epss_percentile": 0.05195}, "CVE-2025-60957": {"epss_score": 0.00203, "epss_percentile": 0.4253}, "CVE-2025-60958": {"epss_score": 0.00042, "epss_percentile": 0.12493}, "CVE-2025-60959": {"epss_score": 0.01368, "epss_percentile": 0.79789}, "CVE-2025-60960": {"epss_score": 0.01208, "epss_percentile": 0.78533}, "CVE-2025-60961": {"epss_score": 0.00039, "epss_percentile": 0.11692}, "CVE-2025-60962": {"epss_score": 0.01368, "epss_percentile": 0.79789}, "CVE-2025-60963": {"epss_score": 0.01208, "epss_percentile": 0.78533}, "CVE-2025-60964": {"epss_score": 0.0018, "epss_percentile": 0.39916}, "CVE-2025-60965": {"epss_score": 0.0018, "epss_percentile": 0.39916}, "CVE-2025-60967": {"epss_score": 0.00042, "epss_percentile": 0.12493}, "CVE-2025-60969": {"epss_score": 0.00268, "epss_percentile": 0.50099}, "CVE-2025-60982": {"epss_score": 0.00045, "epss_percentile": 0.13747}, "CVE-2025-60983": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-60991": {"epss_score": 0.00053, "epss_percentile": 0.16934}, "CVE-2025-61035": {"epss_score": 0.00017, "epss_percentile": 0.03482}, "CVE-2025-61037": {"epss_score": 0.00014, "epss_percentile": 0.01856}, "CVE-2025-61043": {"epss_score": 0.00064, "epss_percentile": 0.20262}, "CVE-2025-61044": {"epss_score": 0.05071, "epss_percentile": 0.89465}, "CVE-2025-61045": {"epss_score": 0.05006, "epss_percentile": 0.89386}, "CVE-2025-61074": {"epss_score": 0.00038, "epss_percentile": 0.11345}, "CVE-2025-61075": {"epss_score": 0.00043, "epss_percentile": 0.13124}, "CVE-2025-61078": {"epss_score": 0.00041, "epss_percentile": 0.12345}, "CVE-2025-61080": {"epss_score": 0.00045, "epss_percentile": 0.13718}, "CVE-2025-61084": {"epss_score": 0.00052, "epss_percentile": 0.16505}, "CVE-2025-61087": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-61096": {"epss_score": 0.00037, "epss_percentile": 0.1094}, "CVE-2025-61099": {"epss_score": 0.00081, "epss_percentile": 0.2435}, "CVE-2025-61100": {"epss_score": 0.00081, "epss_percentile": 0.2435}, "CVE-2025-61101": {"epss_score": 0.00081, "epss_percentile": 0.2435}, "CVE-2025-61102": {"epss_score": 0.00081, "epss_percentile": 0.2435}, "CVE-2025-61103": {"epss_score": 0.00081, "epss_percentile": 0.2435}, "CVE-2025-61104": {"epss_score": 0.00081, "epss_percentile": 0.2435}, "CVE-2025-61105": {"epss_score": 0.00081, "epss_percentile": 0.2435}, "CVE-2025-61106": {"epss_score": 0.00081, "epss_percentile": 0.2435}, "CVE-2025-61107": {"epss_score": 0.00081, "epss_percentile": 0.2435}, "CVE-2025-61113": {"epss_score": 0.00056, "epss_percentile": 0.17915}, "CVE-2025-61114": {"epss_score": 0.00068, "epss_percentile": 0.21374}, "CVE-2025-61115": {"epss_score": 0.00075, "epss_percentile": 0.22993}, "CVE-2025-61116": {"epss_score": 0.00068, "epss_percentile": 0.21374}, "CVE-2025-61117": {"epss_score": 0.00068, "epss_percentile": 0.21374}, "CVE-2025-61118": {"epss_score": 0.00056, "epss_percentile": 0.17915}, "CVE-2025-61119": {"epss_score": 0.00056, "epss_percentile": 0.17915}, "CVE-2025-61120": {"epss_score": 0.00047, "epss_percentile": 0.14844}, "CVE-2025-61121": {"epss_score": 0.00047, "epss_percentile": 0.14844}, "CVE-2025-61128": {"epss_score": 0.00091, "epss_percentile": 0.26202}, "CVE-2025-61132": {"epss_score": 0.00158, "epss_percentile": 0.37151}, "CVE-2025-61136": {"epss_score": 0.00191, "epss_percentile": 0.41217}, "CVE-2025-61138": {"epss_score": 0.00047, "epss_percentile": 0.14489}, "CVE-2025-61141": {"epss_score": 0.02012, "epss_percentile": 0.83254}, "CVE-2025-61148": {"epss_score": 0.00034, "epss_percentile": 0.09741}, "CVE-2025-61152": {"epss_score": 0.00079, "epss_percentile": 0.23998}, "CVE-2025-61155": {"epss_score": 0.00026, "epss_percentile": 0.06657}, "CVE-2025-61156": {"epss_score": 0.00019, "epss_percentile": 0.04186}, "CVE-2025-61161": {"epss_score": 0.00021, "epss_percentile": 0.04916}, "CVE-2025-61167": {"epss_score": 0.00035, "epss_percentile": 0.09945}, "CVE-2025-61168": {"epss_score": 0.00102, "epss_percentile": 0.28766}, "CVE-2025-61181": {"epss_score": 0.00053, "epss_percentile": 0.16719}, "CVE-2025-61183": {"epss_score": 0.00089, "epss_percentile": 0.25818}, "CVE-2025-61188": {"epss_score": 0.00068, "epss_percentile": 0.21342}, "CVE-2025-61189": {"epss_score": 0.00068, "epss_percentile": 0.21342}, "CVE-2025-61194": {"epss_score": 0.00037, "epss_percentile": 0.1094}, "CVE-2025-61196": {"epss_score": 0.00342, "epss_percentile": 0.56398}, "CVE-2025-61197": {"epss_score": 0.00224, "epss_percentile": 0.4507}, "CVE-2025-61198": {"epss_score": 0.0005, "epss_percentile": 0.15687}, "CVE-2025-61220": {"epss_score": 0.00044, "epss_percentile": 0.13388}, "CVE-2025-61224": {"epss_score": 0.00085, "epss_percentile": 0.25089}, "CVE-2025-61228": {"epss_score": 8e-05, "epss_percentile": 0.00565}, "CVE-2025-61229": {"epss_score": 0.00014, "epss_percentile": 0.01831}, "CVE-2025-61234": {"epss_score": 0.00068, "epss_percentile": 0.21374}, "CVE-2025-61235": {"epss_score": 0.00095, "epss_percentile": 0.27125}, "CVE-2025-61247": {"epss_score": 0.00047, "epss_percentile": 0.14684}, "CVE-2025-61255": {"epss_score": 0.00039, "epss_percentile": 0.11608}, "CVE-2025-61258": {"epss_score": 0.00047, "epss_percentile": 0.14594}, "CVE-2025-61261": {"epss_score": 0.00054, "epss_percentile": 0.1718}, "CVE-2025-61301": {"epss_score": 0.00056, "epss_percentile": 0.17958}, "CVE-2025-61303": {"epss_score": 0.00106, "epss_percentile": 0.29429}, "CVE-2025-61304": {"epss_score": 0.00375, "epss_percentile": 0.58639}, "CVE-2025-61318": {"epss_score": 0.00463, "epss_percentile": 0.63675}, "CVE-2025-61319": {"epss_score": 0.00049, "epss_percentile": 0.1559}, "CVE-2025-61330": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2025-61385": {"epss_score": 0.00109, "epss_percentile": 0.30041}, "CVE-2025-61413": {"epss_score": 0.00068, "epss_percentile": 0.21194}, "CVE-2025-61417": {"epss_score": 0.00071, "epss_percentile": 0.22046}, "CVE-2025-61427": {"epss_score": 0.00049, "epss_percentile": 0.1559}, "CVE-2025-61429": {"epss_score": 0.00076, "epss_percentile": 0.23119}, "CVE-2025-61430": {"epss_score": 0.00054, "epss_percentile": 0.17315}, "CVE-2025-61431": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-61454": {"epss_score": 0.00051, "epss_percentile": 0.16017}, "CVE-2025-61455": {"epss_score": 0.00258, "epss_percentile": 0.48949}, "CVE-2025-61456": {"epss_score": 0.00051, "epss_percentile": 0.16017}, "CVE-2025-61457": {"epss_score": 0.00042, "epss_percentile": 0.1257}, "CVE-2025-61464": {"epss_score": 0.00039, "epss_percentile": 0.11557}, "CVE-2025-61481": {"epss_score": 0.00024, "epss_percentile": 0.05888}, "CVE-2025-61482": {"epss_score": 0.00021, "epss_percentile": 0.04914}, "CVE-2025-61488": {"epss_score": 0.00112, "epss_percentile": 0.30519}, "CVE-2025-61489": {"epss_score": 0.02455, "epss_percentile": 0.84796}, "CVE-2025-61492": {"epss_score": 0.00244, "epss_percentile": 0.47612}, "CVE-2025-61498": {"epss_score": 0.0005, "epss_percentile": 0.15835}, "CVE-2025-61505": {"epss_score": 0.00188, "epss_percentile": 0.40808}, "CVE-2025-61514": {"epss_score": 0.00065, "epss_percentile": 0.20516}, "CVE-2025-61524": {"epss_score": 0.00063, "epss_percentile": 0.1998}, "CVE-2025-61532": {"epss_score": 0.00045, "epss_percentile": 0.13981}, "CVE-2025-61536": {"epss_score": 0.00064, "epss_percentile": 0.20197}, "CVE-2025-61539": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-61540": {"epss_score": 0.00035, "epss_percentile": 0.09854}, "CVE-2025-61541": {"epss_score": 0.00048, "epss_percentile": 0.15237}, "CVE-2025-61543": {"epss_score": 0.00045, "epss_percentile": 0.13966}, "CVE-2025-61553": {"epss_score": 0.00019, "epss_percentile": 0.04271}, "CVE-2025-61554": {"epss_score": 0.00019, "epss_percentile": 0.04275}, "CVE-2025-61557": {"epss_score": 0.00349, "epss_percentile": 0.56861}, "CVE-2025-61577": {"epss_score": 0.00047, "epss_percentile": 0.14611}, "CVE-2025-61581": {"epss_score": 0.00207, "epss_percentile": 0.43124}, "CVE-2025-61582": {"epss_score": 0.00222, "epss_percentile": 0.44802}, "CVE-2025-61583": {"epss_score": 0.00075, "epss_percentile": 0.23045}, "CVE-2025-61584": {"epss_score": 0.00072, "epss_percentile": 0.22431}, "CVE-2025-61586": {"epss_score": 0.00077, "epss_percentile": 0.23289}, "CVE-2025-61587": {"epss_score": 0.00046, "epss_percentile": 0.14415}, "CVE-2025-61588": {"epss_score": 0.00101, "epss_percentile": 0.28571}, "CVE-2025-61589": {"epss_score": 0.00065, "epss_percentile": 0.20567}, "CVE-2025-61590": {"epss_score": 0.00192, "epss_percentile": 0.4136}, "CVE-2025-61591": {"epss_score": 0.00248, "epss_percentile": 0.47923}, "CVE-2025-61592": {"epss_score": 0.00201, "epss_percentile": 0.42321}, "CVE-2025-61593": {"epss_score": 0.00192, "epss_percentile": 0.41302}, "CVE-2025-61594": {"epss_score": 0.00073, "epss_percentile": 0.22667}, "CVE-2025-61595": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-61597": {"epss_score": 0.00041, "epss_percentile": 0.1241}, "CVE-2025-61598": {"epss_score": 0.00056, "epss_percentile": 0.17819}, "CVE-2025-61599": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-61600": {"epss_score": 0.00192, "epss_percentile": 0.4135}, "CVE-2025-61601": {"epss_score": 0.00071, "epss_percentile": 0.22068}, "CVE-2025-61602": {"epss_score": 0.00075, "epss_percentile": 0.23031}, "CVE-2025-61603": {"epss_score": 0.00043, "epss_percentile": 0.13091}, "CVE-2025-61604": {"epss_score": 0.00029, "epss_percentile": 0.07744}, "CVE-2025-61605": {"epss_score": 0.00043, "epss_percentile": 0.13091}, "CVE-2025-61606": {"epss_score": 0.00044, "epss_percentile": 0.13585}, "CVE-2025-61607": {"epss_score": 0.00167, "epss_percentile": 0.38334}, "CVE-2025-61608": {"epss_score": 0.00167, "epss_percentile": 0.38334}, "CVE-2025-61609": {"epss_score": 0.00167, "epss_percentile": 0.38334}, "CVE-2025-61610": {"epss_score": 0.00167, "epss_percentile": 0.38334}, "CVE-2025-61617": {"epss_score": 0.00167, "epss_percentile": 0.38334}, "CVE-2025-61618": {"epss_score": 0.00167, "epss_percentile": 0.38334}, "CVE-2025-61619": {"epss_score": 0.00167, "epss_percentile": 0.38334}, "CVE-2025-61622": {"epss_score": 0.00207, "epss_percentile": 0.43159}, "CVE-2025-61623": {"epss_score": 0.00128, "epss_percentile": 0.33033}, "CVE-2025-61659": {"epss_score": 0.00019, "epss_percentile": 0.0415}, "CVE-2025-61661": {"epss_score": 0.00022, "epss_percentile": 0.05317}, "CVE-2025-61662": {"epss_score": 0.00017, "epss_percentile": 0.03271}, "CVE-2025-61663": {"epss_score": 0.00018, "epss_percentile": 0.03741}, "CVE-2025-61664": {"epss_score": 0.00018, "epss_percentile": 0.03763}, "CVE-2025-61665": {"epss_score": 0.00199, "epss_percentile": 0.42188}, "CVE-2025-61666": {"epss_score": 0.02617, "epss_percentile": 0.85248}, "CVE-2025-61667": {"epss_score": 0.00014, "epss_percentile": 0.01862}, "CVE-2025-61668": {"epss_score": 0.00077, "epss_percentile": 0.23359}, "CVE-2025-61670": {"epss_score": 0.0002, "epss_percentile": 0.04472}, "CVE-2025-61672": {"epss_score": 0.00049, "epss_percentile": 0.15629}, "CVE-2025-61673": {"epss_score": 0.0023, "epss_percentile": 0.45707}, "CVE-2025-61675": {"epss_score": 0.00038, "epss_percentile": 0.11138}, "CVE-2025-61677": {"epss_score": 0.00091, "epss_percentile": 0.26226}, "CVE-2025-61678": {"epss_score": 0.00068, "epss_percentile": 0.21284}, "CVE-2025-61679": {"epss_score": 0.00016, "epss_percentile": 0.02951}, "CVE-2025-61680": {"epss_score": 0.00058, "epss_percentile": 0.18398}, "CVE-2025-61681": {"epss_score": 0.00039, "epss_percentile": 0.11692}, "CVE-2025-61685": {"epss_score": 0.00185, "epss_percentile": 0.40488}, "CVE-2025-61687": {"epss_score": 0.00234, "epss_percentile": 0.46086}, "CVE-2025-61688": {"epss_score": 0.00049, "epss_percentile": 0.15342}, "CVE-2025-61689": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-61690": {"epss_score": 0.00018, "epss_percentile": 0.03661}, "CVE-2025-61691": {"epss_score": 0.00018, "epss_percentile": 0.03661}, "CVE-2025-61692": {"epss_score": 0.00018, "epss_percentile": 0.03661}, "CVE-2025-61713": {"epss_score": 6e-05, "epss_percentile": 0.00304}, "CVE-2025-61723": {"epss_score": 0.00031, "epss_percentile": 0.08502}, "CVE-2025-61724": {"epss_score": 0.00027, "epss_percentile": 0.0676}, "CVE-2025-61725": {"epss_score": 0.00031, "epss_percentile": 0.08502}, "CVE-2025-61727": {"epss_score": 0.0001, "epss_percentile": 0.00836}, "CVE-2025-61729": {"epss_score": 0.00015, "epss_percentile": 0.02349}, "CVE-2025-61733": {"epss_score": 0.00108, "epss_percentile": 0.29769}, "CVE-2025-61734": {"epss_score": 0.00071, "epss_percentile": 0.22127}, "CVE-2025-61735": {"epss_score": 0.00078, "epss_percentile": 0.23757}, "CVE-2025-61736": {"epss_score": 0.00014, "epss_percentile": 0.01742}, "CVE-2025-61738": {"epss_score": 0.00023, "epss_percentile": 0.05609}, "CVE-2025-61739": {"epss_score": 0.00024, "epss_percentile": 0.05908}, "CVE-2025-61740": {"epss_score": 0.00015, "epss_percentile": 0.02542}, "CVE-2025-61748": {"epss_score": 0.00049, "epss_percentile": 0.15646}, "CVE-2025-61749": {"epss_score": 0.00033, "epss_percentile": 0.09392}, "CVE-2025-61750": {"epss_score": 0.00037, "epss_percentile": 0.10995}, "CVE-2025-61751": {"epss_score": 0.00067, "epss_percentile": 0.20994}, "CVE-2025-61752": {"epss_score": 0.00055, "epss_percentile": 0.17442}, "CVE-2025-61753": {"epss_score": 0.00034, "epss_percentile": 0.09735}, "CVE-2025-61754": {"epss_score": 0.0005, "epss_percentile": 0.15867}, "CVE-2025-61755": {"epss_score": 0.00043, "epss_percentile": 0.13319}, "CVE-2025-61756": {"epss_score": 0.00055, "epss_percentile": 0.17442}, "CVE-2025-61757": {"epss_score": 0.82159, "epss_percentile": 0.99177}, "CVE-2025-61758": {"epss_score": 0.0005, "epss_percentile": 0.15867}, "CVE-2025-61759": {"epss_score": 0.00022, "epss_percentile": 0.05163}, "CVE-2025-61760": {"epss_score": 0.00028, "epss_percentile": 0.07497}, "CVE-2025-61761": {"epss_score": 0.00035, "epss_percentile": 0.10139}, "CVE-2025-61762": {"epss_score": 0.00048, "epss_percentile": 0.15016}, "CVE-2025-61763": {"epss_score": 0.00067, "epss_percentile": 0.20994}, "CVE-2025-61764": {"epss_score": 0.00038, "epss_percentile": 0.11153}, "CVE-2025-61765": {"epss_score": 0.01344, "epss_percentile": 0.79608}, "CVE-2025-61766": {"epss_score": 0.00056, "epss_percentile": 0.17736}, "CVE-2025-61768": {"epss_score": 0.00101, "epss_percentile": 0.28683}, "CVE-2025-61769": {"epss_score": 0.00066, "epss_percentile": 0.20885}, "CVE-2025-61770": {"epss_score": 0.00166, "epss_percentile": 0.38225}, "CVE-2025-61771": {"epss_score": 0.00059, "epss_percentile": 0.18623}, "CVE-2025-61772": {"epss_score": 0.00166, "epss_percentile": 0.38225}, "CVE-2025-61773": {"epss_score": 0.00048, "epss_percentile": 0.15271}, "CVE-2025-61774": {"epss_score": 0.00522, "epss_percentile": 0.66264}, "CVE-2025-61775": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-61776": {"epss_score": 0.00056, "epss_percentile": 0.17802}, "CVE-2025-61777": {"epss_score": 0.0009, "epss_percentile": 0.2612}, "CVE-2025-61778": {"epss_score": 0.00072, "epss_percentile": 0.22387}, "CVE-2025-61779": {"epss_score": 0.00058, "epss_percentile": 0.18398}, "CVE-2025-61780": {"epss_score": 0.00044, "epss_percentile": 0.13601}, "CVE-2025-61781": {"epss_score": 0.00046, "epss_percentile": 0.14347}, "CVE-2025-61782": {"epss_score": 0.00079, "epss_percentile": 0.23998}, "CVE-2025-61783": {"epss_score": 0.00121, "epss_percentile": 0.31954}, "CVE-2025-61784": {"epss_score": 0.0005, "epss_percentile": 0.15979}, "CVE-2025-61785": {"epss_score": 0.00016, "epss_percentile": 0.02654}, "CVE-2025-61786": {"epss_score": 0.00016, "epss_percentile": 0.0265}, "CVE-2025-61787": {"epss_score": 0.00497, "epss_percentile": 0.65206}, "CVE-2025-61788": {"epss_score": 0.00107, "epss_percentile": 0.29727}, "CVE-2025-61789": {"epss_score": 0.00048, "epss_percentile": 0.15184}, "CVE-2025-61792": {"epss_score": 0.00022, "epss_percentile": 0.04964}, "CVE-2025-61795": {"epss_score": 0.00106, "epss_percentile": 0.29496}, "CVE-2025-61796": {"epss_score": 0.00041, "epss_percentile": 0.12288}, "CVE-2025-61797": {"epss_score": 0.00041, "epss_percentile": 0.12288}, "CVE-2025-61798": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-61799": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-61800": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-61801": {"epss_score": 0.00045, "epss_percentile": 0.13684}, "CVE-2025-61802": {"epss_score": 0.00045, "epss_percentile": 0.13684}, "CVE-2025-61803": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-61804": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-61805": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-61806": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-61807": {"epss_score": 0.00034, "epss_percentile": 0.09516}, "CVE-2025-61808": {"epss_score": 0.00368, "epss_percentile": 0.58211}, "CVE-2025-61809": {"epss_score": 0.00774, "epss_percentile": 0.73071}, "CVE-2025-61810": {"epss_score": 0.03038, "epss_percentile": 0.86267}, "CVE-2025-61811": {"epss_score": 0.00898, "epss_percentile": 0.75144}, "CVE-2025-61812": {"epss_score": 0.00061, "epss_percentile": 0.19291}, "CVE-2025-61813": {"epss_score": 0.00074, "epss_percentile": 0.22745}, "CVE-2025-61814": {"epss_score": 0.00039, "epss_percentile": 0.11453}, "CVE-2025-61815": {"epss_score": 0.00039, "epss_percentile": 0.11453}, "CVE-2025-61816": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61817": {"epss_score": 0.00039, "epss_percentile": 0.11453}, "CVE-2025-61818": {"epss_score": 0.00039, "epss_percentile": 0.11453}, "CVE-2025-61819": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61820": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61821": {"epss_score": 0.0009, "epss_percentile": 0.26016}, "CVE-2025-61822": {"epss_score": 0.00041, "epss_percentile": 0.12239}, "CVE-2025-61823": {"epss_score": 0.00077, "epss_percentile": 0.23433}, "CVE-2025-61824": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61826": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61827": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61828": {"epss_score": 0.00037, "epss_percentile": 0.1067}, "CVE-2025-61829": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61830": {"epss_score": 0.00042, "epss_percentile": 0.129}, "CVE-2025-61831": {"epss_score": 0.00037, "epss_percentile": 0.1067}, "CVE-2025-61832": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61833": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61834": {"epss_score": 0.00039, "epss_percentile": 0.11453}, "CVE-2025-61835": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61836": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61837": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61838": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61839": {"epss_score": 0.00029, "epss_percentile": 0.07857}, "CVE-2025-61840": {"epss_score": 0.00025, "epss_percentile": 0.06226}, "CVE-2025-61841": {"epss_score": 0.00025, "epss_percentile": 0.06226}, "CVE-2025-61842": {"epss_score": 0.00035, "epss_percentile": 0.09849}, "CVE-2025-61843": {"epss_score": 0.00025, "epss_percentile": 0.06226}, "CVE-2025-61844": {"epss_score": 0.00025, "epss_percentile": 0.06226}, "CVE-2025-61845": {"epss_score": 0.00025, "epss_percentile": 0.06226}, "CVE-2025-61856": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-61857": {"epss_score": 0.00026, "epss_percentile": 0.06386}, "CVE-2025-61858": {"epss_score": 0.00026, "epss_percentile": 0.06386}, "CVE-2025-61859": {"epss_score": 0.00026, "epss_percentile": 0.06386}, "CVE-2025-61860": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-61861": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-61862": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-61863": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-61864": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-61865": {"epss_score": 0.00019, "epss_percentile": 0.04407}, "CVE-2025-61871": {"epss_score": 0.00022, "epss_percentile": 0.05229}, "CVE-2025-61876": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-61881": {"epss_score": 0.00034, "epss_percentile": 0.09749}, "CVE-2025-61882": {"epss_score": 0.76811, "epss_percentile": 0.98906}, "CVE-2025-61884": {"epss_score": 0.41772, "epss_percentile": 0.97294}, "CVE-2025-61885": {"epss_score": 0.00037, "epss_percentile": 0.10995}, "CVE-2025-61906": {"epss_score": 0.0004, "epss_percentile": 0.11912}, "CVE-2025-61907": {"epss_score": 0.00039, "epss_percentile": 0.11801}, "CVE-2025-61908": {"epss_score": 0.00069, "epss_percentile": 0.215}, "CVE-2025-61909": {"epss_score": 0.00018, "epss_percentile": 0.04013}, "CVE-2025-61910": {"epss_score": 0.00077, "epss_percentile": 0.23436}, "CVE-2025-61911": {"epss_score": 0.00053, "epss_percentile": 0.16955}, "CVE-2025-61912": {"epss_score": 0.0007, "epss_percentile": 0.21868}, "CVE-2025-61913": {"epss_score": 0.00771, "epss_percentile": 0.73013}, "CVE-2025-61914": {"epss_score": 0.00027, "epss_percentile": 0.06765}, "CVE-2025-61915": {"epss_score": 0.00019, "epss_percentile": 0.04061}, "CVE-2025-61916": {"epss_score": 0.00035, "epss_percentile": 0.09899}, "CVE-2025-61919": {"epss_score": 0.00084, "epss_percentile": 0.24992}, "CVE-2025-61920": {"epss_score": 0.00403, "epss_percentile": 0.60373}, "CVE-2025-61921": {"epss_score": 0.00108, "epss_percentile": 0.29815}, "CVE-2025-61922": {"epss_score": 0.00047, "epss_percentile": 0.14808}, "CVE-2025-61923": {"epss_score": 0.00059, "epss_percentile": 0.18856}, "CVE-2025-61924": {"epss_score": 0.00052, "epss_percentile": 0.16341}, "CVE-2025-61925": {"epss_score": 0.00026, "epss_percentile": 0.06525}, "CVE-2025-61926": {"epss_score": 0.00061, "epss_percentile": 0.19546}, "CVE-2025-61927": {"epss_score": 0.00455, "epss_percentile": 0.63301}, "CVE-2025-61928": {"epss_score": 0.00191, "epss_percentile": 0.41146}, "CVE-2025-61929": {"epss_score": 0.00072, "epss_percentile": 0.22395}, "CVE-2025-61930": {"epss_score": 0.00032, "epss_percentile": 0.08735}, "CVE-2025-61931": {"epss_score": 0.00042, "epss_percentile": 0.12924}, "CVE-2025-61932": {"epss_score": 0.08676, "epss_percentile": 0.92193}, "CVE-2025-61933": {"epss_score": 0.00066, "epss_percentile": 0.20946}, "CVE-2025-61934": {"epss_score": 0.0034, "epss_percentile": 0.56256}, "CVE-2025-61935": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-61938": {"epss_score": 0.00229, "epss_percentile": 0.45584}, "CVE-2025-61939": {"epss_score": 0.00076, "epss_percentile": 0.23149}, "CVE-2025-61940": {"epss_score": 0.00065, "epss_percentile": 0.20487}, "CVE-2025-61941": {"epss_score": 0.00094, "epss_percentile": 0.27039}, "CVE-2025-61945": {"epss_score": 0.00202, "epss_percentile": 0.42403}, "CVE-2025-61949": {"epss_score": 0.00035, "epss_percentile": 0.09858}, "CVE-2025-61950": {"epss_score": 0.0003, "epss_percentile": 0.08196}, "CVE-2025-61951": {"epss_score": 0.00084, "epss_percentile": 0.24926}, "CVE-2025-61955": {"epss_score": 0.00054, "epss_percentile": 0.17091}, "CVE-2025-61956": {"epss_score": 0.00108, "epss_percentile": 0.29779}, "CVE-2025-61958": {"epss_score": 0.00082, "epss_percentile": 0.24533}, "CVE-2025-61959": {"epss_score": 0.00043, "epss_percentile": 0.13086}, "CVE-2025-61960": {"epss_score": 0.00132, "epss_percentile": 0.3358}, "CVE-2025-61962": {"epss_score": 0.00062, "epss_percentile": 0.19722}, "CVE-2025-61974": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-61976": {"epss_score": 0.00195, "epss_percentile": 0.41677}, "CVE-2025-61977": {"epss_score": 0.00016, "epss_percentile": 0.03028}, "CVE-2025-61984": {"epss_score": 7e-05, "epss_percentile": 0.00376}, "CVE-2025-61985": {"epss_score": 0.00013, "epss_percentile": 0.01432}, "CVE-2025-61987": {"epss_score": 0.0002, "epss_percentile": 0.04432}, "CVE-2025-61990": {"epss_score": 0.00113, "epss_percentile": 0.30713}, "CVE-2025-61994": {"epss_score": 0.00037, "epss_percentile": 0.1064}, "CVE-2025-61996": {"epss_score": 0.00044, "epss_percentile": 0.13518}, "CVE-2025-61997": {"epss_score": 0.00044, "epss_percentile": 0.13518}, "CVE-2025-61998": {"epss_score": 0.00044, "epss_percentile": 0.13518}, "CVE-2025-61999": {"epss_score": 0.00044, "epss_percentile": 0.13518}, "CVE-2025-62000": {"epss_score": 0.0002, "epss_percentile": 0.04421}, "CVE-2025-62001": {"epss_score": 0.00036, "epss_percentile": 0.10254}, "CVE-2025-62002": {"epss_score": 0.00027, "epss_percentile": 0.0717}, "CVE-2025-62003": {"epss_score": 0.00052, "epss_percentile": 0.16451}, "CVE-2025-62004": {"epss_score": 0.00037, "epss_percentile": 0.10837}, "CVE-2025-62005": {"epss_score": 0.00021, "epss_percentile": 0.04805}, "CVE-2025-62006": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62007": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62008": {"epss_score": 0.00071, "epss_percentile": 0.22114}, "CVE-2025-62009": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2025-62010": {"epss_score": 0.00165, "epss_percentile": 0.38013}, "CVE-2025-62011": {"epss_score": 0.00039, "epss_percentile": 0.11557}, "CVE-2025-62012": {"epss_score": 0.00039, "epss_percentile": 0.11557}, "CVE-2025-62013": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62014": {"epss_score": 0.00165, "epss_percentile": 0.38013}, "CVE-2025-62015": {"epss_score": 0.00036, "epss_percentile": 0.1024}, "CVE-2025-62016": {"epss_score": 0.00055, "epss_percentile": 0.17403}, "CVE-2025-62017": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-62018": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-62019": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2025-62020": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-62021": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62022": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-62023": {"epss_score": 0.00071, "epss_percentile": 0.22204}, "CVE-2025-62024": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62025": {"epss_score": 0.00061, "epss_percentile": 0.19327}, "CVE-2025-62026": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-62027": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62028": {"epss_score": 0.0003, "epss_percentile": 0.0817}, "CVE-2025-62029": {"epss_score": 0.00172, "epss_percentile": 0.38969}, "CVE-2025-62030": {"epss_score": 0.00039, "epss_percentile": 0.11557}, "CVE-2025-62031": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-62032": {"epss_score": 0.00039, "epss_percentile": 0.11557}, "CVE-2025-62033": {"epss_score": 0.00038, "epss_percentile": 0.11308}, "CVE-2025-62034": {"epss_score": 0.0005, "epss_percentile": 0.15884}, "CVE-2025-62035": {"epss_score": 0.00061, "epss_percentile": 0.19456}, "CVE-2025-62036": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-62037": {"epss_score": 0.00038, "epss_percentile": 0.11308}, "CVE-2025-62038": {"epss_score": 0.00039, "epss_percentile": 0.11732}, "CVE-2025-62039": {"epss_score": 0.00044, "epss_percentile": 0.13552}, "CVE-2025-62040": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-62041": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-62042": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62044": {"epss_score": 0.00039, "epss_percentile": 0.11557}, "CVE-2025-62045": {"epss_score": 0.00055, "epss_percentile": 0.17377}, "CVE-2025-62046": {"epss_score": 0.00038, "epss_percentile": 0.11308}, "CVE-2025-62047": {"epss_score": 0.00055, "epss_percentile": 0.17403}, "CVE-2025-62048": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62049": {"epss_score": 0.00038, "epss_percentile": 0.11308}, "CVE-2025-62051": {"epss_score": 0.00039, "epss_percentile": 0.11557}, "CVE-2025-62052": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62053": {"epss_score": 0.00168, "epss_percentile": 0.38463}, "CVE-2025-62054": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-62055": {"epss_score": 0.00055, "epss_percentile": 0.17377}, "CVE-2025-62057": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-62058": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62059": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-62060": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62061": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2025-62062": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-62063": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62064": {"epss_score": 0.00076, "epss_percentile": 0.2312}, "CVE-2025-62065": {"epss_score": 0.00055, "epss_percentile": 0.17403}, "CVE-2025-62066": {"epss_score": 0.00091, "epss_percentile": 0.26256}, "CVE-2025-62067": {"epss_score": 0.00051, "epss_percentile": 0.16255}, "CVE-2025-62068": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62069": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62070": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62071": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62072": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62073": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62074": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-62075": {"epss_score": 0.00025, "epss_percentile": 0.06302}, "CVE-2025-62076": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-62078": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62079": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-62080": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62081": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62082": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62083": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2025-62084": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62085": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62086": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-62087": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-62088": {"epss_score": 0.00035, "epss_percentile": 0.0999}, "CVE-2025-62089": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62090": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62091": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-62092": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62093": {"epss_score": 0.00029, "epss_percentile": 0.07737}, "CVE-2025-62094": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62095": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62096": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62097": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62098": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-62099": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62100": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62101": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62102": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62103": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-62107": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62108": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-62109": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-62111": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62112": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62113": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62114": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-62115": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62116": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62117": {"epss_score": 0.00016, "epss_percentile": 0.02911}, "CVE-2025-62118": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62119": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-62120": {"epss_score": 0.00016, "epss_percentile": 0.02911}, "CVE-2025-62121": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-62122": {"epss_score": 0.00052, "epss_percentile": 0.16624}, "CVE-2025-62123": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62124": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-62125": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62126": {"epss_score": 0.00038, "epss_percentile": 0.11187}, "CVE-2025-62128": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-62129": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-62130": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62131": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62132": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-62133": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62134": {"epss_score": 0.00016, "epss_percentile": 0.02911}, "CVE-2025-62135": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62136": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62137": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62138": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62139": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-62140": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-62141": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62142": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-62143": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2025-62144": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-62145": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62146": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62147": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62148": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62149": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-62150": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62151": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-62152": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-62153": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-62154": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62155": {"epss_score": 0.00036, "epss_percentile": 0.105}, "CVE-2025-62156": {"epss_score": 0.00108, "epss_percentile": 0.29855}, "CVE-2025-62157": {"epss_score": 0.00031, "epss_percentile": 0.08712}, "CVE-2025-62158": {"epss_score": 0.00062, "epss_percentile": 0.19767}, "CVE-2025-62159": {"epss_score": 0.00073, "epss_percentile": 0.22576}, "CVE-2025-62161": {"epss_score": 0.0005, "epss_percentile": 0.15856}, "CVE-2025-62162": {"epss_score": 0.00085, "epss_percentile": 0.25242}, "CVE-2025-62164": {"epss_score": 0.00341, "epss_percentile": 0.56343}, "CVE-2025-62168": {"epss_score": 0.00077, "epss_percentile": 0.23413}, "CVE-2025-62169": {"epss_score": 0.00105, "epss_percentile": 0.29385}, "CVE-2025-62170": {"epss_score": 0.00067, "epss_percentile": 0.21044}, "CVE-2025-62171": {"epss_score": 0.00095, "epss_percentile": 0.27216}, "CVE-2025-62172": {"epss_score": 0.00168, "epss_percentile": 0.38404}, "CVE-2025-62173": {"epss_score": 0.0004, "epss_percentile": 0.11901}, "CVE-2025-62174": {"epss_score": 0.00046, "epss_percentile": 0.14464}, "CVE-2025-62175": {"epss_score": 0.00051, "epss_percentile": 0.16172}, "CVE-2025-62176": {"epss_score": 0.00076, "epss_percentile": 0.23089}, "CVE-2025-62177": {"epss_score": 0.00039, "epss_percentile": 0.11725}, "CVE-2025-62178": {"epss_score": 0.0004, "epss_percentile": 0.12009}, "CVE-2025-62179": {"epss_score": 0.00039, "epss_percentile": 0.11725}, "CVE-2025-62181": {"epss_score": 0.00044, "epss_percentile": 0.13538}, "CVE-2025-62185": {"epss_score": 0.00016, "epss_percentile": 0.03027}, "CVE-2025-62186": {"epss_score": 0.00018, "epss_percentile": 0.04025}, "CVE-2025-62187": {"epss_score": 0.00024, "epss_percentile": 0.05773}, "CVE-2025-62189": {"epss_score": 0.00043, "epss_percentile": 0.13171}, "CVE-2025-62190": {"epss_score": 0.00017, "epss_percentile": 0.03088}, "CVE-2025-62192": {"epss_score": 0.00028, "epss_percentile": 0.07335}, "CVE-2025-62199": {"epss_score": 0.00456, "epss_percentile": 0.63315}, "CVE-2025-62200": {"epss_score": 0.00068, "epss_percentile": 0.21402}, "CVE-2025-62201": {"epss_score": 0.00068, "epss_percentile": 0.21402}, "CVE-2025-62202": {"epss_score": 0.00061, "epss_percentile": 0.19285}, "CVE-2025-62203": {"epss_score": 0.00068, "epss_percentile": 0.21402}, "CVE-2025-62204": {"epss_score": 0.01478, "epss_percentile": 0.80553}, "CVE-2025-62205": {"epss_score": 0.00068, "epss_percentile": 0.21402}, "CVE-2025-62206": {"epss_score": 0.00071, "epss_percentile": 0.22218}, "CVE-2025-62207": {"epss_score": 0.00099, "epss_percentile": 0.28397}, "CVE-2025-62208": {"epss_score": 0.0005, "epss_percentile": 0.15944}, "CVE-2025-62209": {"epss_score": 0.0005, "epss_percentile": 0.15944}, "CVE-2025-62210": {"epss_score": 0.00057, "epss_percentile": 0.18202}, "CVE-2025-62211": {"epss_score": 0.00057, "epss_percentile": 0.18202}, "CVE-2025-62213": {"epss_score": 0.0007, "epss_percentile": 0.21712}, "CVE-2025-62214": {"epss_score": 0.00054, "epss_percentile": 0.17044}, "CVE-2025-62215": {"epss_score": 0.00779, "epss_percentile": 0.73148}, "CVE-2025-62216": {"epss_score": 0.00068, "epss_percentile": 0.21402}, "CVE-2025-62217": {"epss_score": 0.00047, "epss_percentile": 0.147}, "CVE-2025-62218": {"epss_score": 0.00047, "epss_percentile": 0.147}, "CVE-2025-62219": {"epss_score": 0.00047, "epss_percentile": 0.147}, "CVE-2025-62220": {"epss_score": 0.00072, "epss_percentile": 0.22361}, "CVE-2025-62221": {"epss_score": 0.02857, "epss_percentile": 0.85844}, "CVE-2025-62222": {"epss_score": 0.0025, "epss_percentile": 0.48107}, "CVE-2025-62223": {"epss_score": 0.00046, "epss_percentile": 0.1427}, "CVE-2025-62224": {"epss_score": 0.00062, "epss_percentile": 0.19578}, "CVE-2025-62225": {"epss_score": 0.00021, "epss_percentile": 0.04894}, "CVE-2025-62228": {"epss_score": 0.00046, "epss_percentile": 0.14308}, "CVE-2025-62229": {"epss_score": 0.00016, "epss_percentile": 0.02909}, "CVE-2025-62230": {"epss_score": 0.00018, "epss_percentile": 0.03672}, "CVE-2025-62231": {"epss_score": 0.00018, "epss_percentile": 0.03672}, "CVE-2025-62232": {"epss_score": 0.00083, "epss_percentile": 0.24703}, "CVE-2025-62236": {"epss_score": 0.00047, "epss_percentile": 0.14911}, "CVE-2025-62237": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-62238": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-62239": {"epss_score": 0.00045, "epss_percentile": 0.1391}, "CVE-2025-62240": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-62241": {"epss_score": 0.00047, "epss_percentile": 0.14781}, "CVE-2025-62242": {"epss_score": 0.00047, "epss_percentile": 0.14781}, "CVE-2025-62243": {"epss_score": 0.00036, "epss_percentile": 0.10275}, "CVE-2025-62244": {"epss_score": 0.00047, "epss_percentile": 0.14781}, "CVE-2025-62245": {"epss_score": 9e-05, "epss_percentile": 0.00602}, "CVE-2025-62246": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-62247": {"epss_score": 0.00044, "epss_percentile": 0.13656}, "CVE-2025-62248": {"epss_score": 0.00045, "epss_percentile": 0.14065}, "CVE-2025-62249": {"epss_score": 0.00041, "epss_percentile": 0.12317}, "CVE-2025-62250": {"epss_score": 0.00021, "epss_percentile": 0.04689}, "CVE-2025-62251": {"epss_score": 0.00041, "epss_percentile": 0.12247}, "CVE-2025-62252": {"epss_score": 0.00049, "epss_percentile": 0.15627}, "CVE-2025-62253": {"epss_score": 0.00046, "epss_percentile": 0.14109}, "CVE-2025-62254": {"epss_score": 0.00211, "epss_percentile": 0.43631}, "CVE-2025-62255": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-62256": {"epss_score": 0.00018, "epss_percentile": 0.03801}, "CVE-2025-62257": {"epss_score": 0.00018, "epss_percentile": 0.03801}, "CVE-2025-62258": {"epss_score": 0.00027, "epss_percentile": 0.06787}, "CVE-2025-62259": {"epss_score": 0.00054, "epss_percentile": 0.17171}, "CVE-2025-62260": {"epss_score": 0.00159, "epss_percentile": 0.37401}, "CVE-2025-62261": {"epss_score": 0.00019, "epss_percentile": 0.0409}, "CVE-2025-62262": {"epss_score": 0.00017, "epss_percentile": 0.03302}, "CVE-2025-62263": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-62264": {"epss_score": 0.0005, "epss_percentile": 0.15687}, "CVE-2025-62265": {"epss_score": 0.00049, "epss_percentile": 0.15556}, "CVE-2025-62266": {"epss_score": 0.00049, "epss_percentile": 0.15646}, "CVE-2025-62267": {"epss_score": 0.00045, "epss_percentile": 0.14065}, "CVE-2025-62275": {"epss_score": 0.00057, "epss_percentile": 0.18223}, "CVE-2025-62276": {"epss_score": 0.00018, "epss_percentile": 0.04016}, "CVE-2025-62287": {"epss_score": 0.00034, "epss_percentile": 0.09735}, "CVE-2025-62288": {"epss_score": 0.00046, "epss_percentile": 0.14428}, "CVE-2025-62289": {"epss_score": 0.00045, "epss_percentile": 0.13898}, "CVE-2025-62290": {"epss_score": 0.00113, "epss_percentile": 0.30661}, "CVE-2025-62292": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-62293": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-62294": {"epss_score": 0.00044, "epss_percentile": 0.13552}, "CVE-2025-62295": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-62296": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-62297": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-62327": {"epss_score": 0.00026, "epss_percentile": 0.0656}, "CVE-2025-62329": {"epss_score": 0.0005, "epss_percentile": 0.15873}, "CVE-2025-62330": {"epss_score": 0.00015, "epss_percentile": 0.02557}, "CVE-2025-62346": {"epss_score": 0.00014, "epss_percentile": 0.01772}, "CVE-2025-62353": {"epss_score": 0.00095, "epss_percentile": 0.27155}, "CVE-2025-62354": {"epss_score": 0.00279, "epss_percentile": 0.50973}, "CVE-2025-62356": {"epss_score": 0.00087, "epss_percentile": 0.25511}, "CVE-2025-62358": {"epss_score": 0.00052, "epss_percentile": 0.16668}, "CVE-2025-62359": {"epss_score": 0.00044, "epss_percentile": 0.1339}, "CVE-2025-62360": {"epss_score": 0.00037, "epss_percentile": 0.10997}, "CVE-2025-62361": {"epss_score": 0.00038, "epss_percentile": 0.11219}, "CVE-2025-62362": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-62363": {"epss_score": 0.00026, "epss_percentile": 0.06594}, "CVE-2025-62364": {"epss_score": 0.00066, "epss_percentile": 0.20676}, "CVE-2025-62365": {"epss_score": 3e-05, "epss_percentile": 0.00071}, "CVE-2025-62366": {"epss_score": 0.00115, "epss_percentile": 0.30958}, "CVE-2025-62367": {"epss_score": 0.00035, "epss_percentile": 0.1001}, "CVE-2025-62368": {"epss_score": 0.61122, "epss_percentile": 0.98235}, "CVE-2025-62369": {"epss_score": 0.00408, "epss_percentile": 0.60644}, "CVE-2025-62370": {"epss_score": 0.00067, "epss_percentile": 0.20973}, "CVE-2025-62371": {"epss_score": 0.0002, "epss_percentile": 0.0465}, "CVE-2025-62372": {"epss_score": 0.00055, "epss_percentile": 0.17515}, "CVE-2025-62374": {"epss_score": 0.00101, "epss_percentile": 0.28669}, "CVE-2025-62375": {"epss_score": 0.00035, "epss_percentile": 0.09938}, "CVE-2025-62376": {"epss_score": 0.00114, "epss_percentile": 0.30856}, "CVE-2025-62378": {"epss_score": 0.00012, "epss_percentile": 0.0141}, "CVE-2025-62379": {"epss_score": 0.00048, "epss_percentile": 0.14936}, "CVE-2025-62380": {"epss_score": 0.00115, "epss_percentile": 0.30958}, "CVE-2025-62381": {"epss_score": 0.00558, "epss_percentile": 0.67574}, "CVE-2025-62382": {"epss_score": 0.00046, "epss_percentile": 0.14136}, "CVE-2025-62383": {"epss_score": 0.00156, "epss_percentile": 0.36908}, "CVE-2025-62384": {"epss_score": 0.00156, "epss_percentile": 0.36908}, "CVE-2025-62385": {"epss_score": 0.00156, "epss_percentile": 0.36908}, "CVE-2025-62386": {"epss_score": 0.00156, "epss_percentile": 0.36908}, "CVE-2025-62387": {"epss_score": 0.00156, "epss_percentile": 0.36908}, "CVE-2025-62388": {"epss_score": 0.00156, "epss_percentile": 0.36908}, "CVE-2025-62389": {"epss_score": 0.00156, "epss_percentile": 0.36908}, "CVE-2025-62390": {"epss_score": 0.00156, "epss_percentile": 0.36908}, "CVE-2025-62391": {"epss_score": 0.00156, "epss_percentile": 0.36908}, "CVE-2025-62392": {"epss_score": 0.00156, "epss_percentile": 0.36908}, "CVE-2025-62393": {"epss_score": 0.00037, "epss_percentile": 0.10781}, "CVE-2025-62394": {"epss_score": 0.00038, "epss_percentile": 0.11268}, "CVE-2025-62395": {"epss_score": 0.00035, "epss_percentile": 0.10075}, "CVE-2025-62396": {"epss_score": 0.00042, "epss_percentile": 0.12588}, "CVE-2025-62397": {"epss_score": 0.00042, "epss_percentile": 0.12588}, "CVE-2025-62398": {"epss_score": 0.00075, "epss_percentile": 0.23022}, "CVE-2025-62399": {"epss_score": 0.00101, "epss_percentile": 0.28661}, "CVE-2025-62400": {"epss_score": 0.00044, "epss_percentile": 0.13575}, "CVE-2025-62401": {"epss_score": 0.0004, "epss_percentile": 0.11993}, "CVE-2025-62402": {"epss_score": 0.00191, "epss_percentile": 0.41195}, "CVE-2025-62406": {"epss_score": 0.00049, "epss_percentile": 0.15481}, "CVE-2025-62407": {"epss_score": 0.00038, "epss_percentile": 0.11348}, "CVE-2025-62408": {"epss_score": 0.00052, "epss_percentile": 0.16594}, "CVE-2025-62409": {"epss_score": 0.00012, "epss_percentile": 0.01134}, "CVE-2025-62410": {"epss_score": 0.00079, "epss_percentile": 0.23973}, "CVE-2025-62411": {"epss_score": 7e-05, "epss_percentile": 0.00414}, "CVE-2025-62412": {"epss_score": 2e-05, "epss_percentile": 0.00039}, "CVE-2025-62413": {"epss_score": 0.00049, "epss_percentile": 0.15324}, "CVE-2025-62414": {"epss_score": 0.00051, "epss_percentile": 0.16322}, "CVE-2025-62415": {"epss_score": 0.00051, "epss_percentile": 0.16322}, "CVE-2025-62416": {"epss_score": 0.00197, "epss_percentile": 0.41831}, "CVE-2025-62417": {"epss_score": 0.00158, "epss_percentile": 0.37143}, "CVE-2025-62418": {"epss_score": 0.00051, "epss_percentile": 0.16322}, "CVE-2025-62419": {"epss_score": 0.00081, "epss_percentile": 0.2436}, "CVE-2025-62420": {"epss_score": 0.00232, "epss_percentile": 0.45958}, "CVE-2025-62421": {"epss_score": 0.00048, "epss_percentile": 0.15055}, "CVE-2025-62422": {"epss_score": 0.00043, "epss_percentile": 0.13091}, "CVE-2025-62423": {"epss_score": 0.00043, "epss_percentile": 0.13017}, "CVE-2025-62424": {"epss_score": 0.00057, "epss_percentile": 0.18043}, "CVE-2025-62425": {"epss_score": 0.00074, "epss_percentile": 0.22806}, "CVE-2025-62426": {"epss_score": 0.00058, "epss_percentile": 0.1836}, "CVE-2025-62427": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-62428": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-62429": {"epss_score": 0.0015, "epss_percentile": 0.36113}, "CVE-2025-62430": {"epss_score": 0.00041, "epss_percentile": 0.12229}, "CVE-2025-62449": {"epss_score": 0.00053, "epss_percentile": 0.1691}, "CVE-2025-62452": {"epss_score": 0.00071, "epss_percentile": 0.22074}, "CVE-2025-62453": {"epss_score": 0.00061, "epss_percentile": 0.19296}, "CVE-2025-62454": {"epss_score": 0.00066, "epss_percentile": 0.20862}, "CVE-2025-62455": {"epss_score": 0.00075, "epss_percentile": 0.22945}, "CVE-2025-62456": {"epss_score": 0.00077, "epss_percentile": 0.23444}, "CVE-2025-62457": {"epss_score": 0.00049, "epss_percentile": 0.15513}, "CVE-2025-62458": {"epss_score": 0.00049, "epss_percentile": 0.15513}, "CVE-2025-62459": {"epss_score": 0.00055, "epss_percentile": 0.17655}, "CVE-2025-62461": {"epss_score": 0.00049, "epss_percentile": 0.15513}, "CVE-2025-62462": {"epss_score": 0.00049, "epss_percentile": 0.15513}, "CVE-2025-62463": {"epss_score": 0.00042, "epss_percentile": 0.12766}, "CVE-2025-62464": {"epss_score": 0.00049, "epss_percentile": 0.15513}, "CVE-2025-62465": {"epss_score": 0.00042, "epss_percentile": 0.12766}, "CVE-2025-62466": {"epss_score": 0.00049, "epss_percentile": 0.15513}, "CVE-2025-62467": {"epss_score": 0.00067, "epss_percentile": 0.21174}, "CVE-2025-62468": {"epss_score": 0.00042, "epss_percentile": 0.12768}, "CVE-2025-62469": {"epss_score": 0.00041, "epss_percentile": 0.12277}, "CVE-2025-62470": {"epss_score": 0.00049, "epss_percentile": 0.15513}, "CVE-2025-62472": {"epss_score": 0.00121, "epss_percentile": 0.31954}, "CVE-2025-62473": {"epss_score": 0.00058, "epss_percentile": 0.18477}, "CVE-2025-62474": {"epss_score": 0.00045, "epss_percentile": 0.13978}, "CVE-2025-62475": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-62476": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-62477": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-62478": {"epss_score": 0.00049, "epss_percentile": 0.15441}, "CVE-2025-62479": {"epss_score": 0.00045, "epss_percentile": 0.13898}, "CVE-2025-62480": {"epss_score": 0.00045, "epss_percentile": 0.13898}, "CVE-2025-62481": {"epss_score": 0.00081, "epss_percentile": 0.24231}, "CVE-2025-62482": {"epss_score": 0.00113, "epss_percentile": 0.30691}, "CVE-2025-62483": {"epss_score": 0.00055, "epss_percentile": 0.17409}, "CVE-2025-62484": {"epss_score": 0.0008, "epss_percentile": 0.24186}, "CVE-2025-62490": {"epss_score": 0.00028, "epss_percentile": 0.07545}, "CVE-2025-62491": {"epss_score": 0.00028, "epss_percentile": 0.07545}, "CVE-2025-62492": {"epss_score": 0.00024, "epss_percentile": 0.05672}, "CVE-2025-62493": {"epss_score": 0.00025, "epss_percentile": 0.06069}, "CVE-2025-62494": {"epss_score": 0.00029, "epss_percentile": 0.07679}, "CVE-2025-62495": {"epss_score": 0.00039, "epss_percentile": 0.11538}, "CVE-2025-62496": {"epss_score": 0.00039, "epss_percentile": 0.11538}, "CVE-2025-62497": {"epss_score": 0.00017, "epss_percentile": 0.03303}, "CVE-2025-62498": {"epss_score": 0.00062, "epss_percentile": 0.1977}, "CVE-2025-62499": {"epss_score": 0.00039, "epss_percentile": 0.11588}, "CVE-2025-62503": {"epss_score": 0.00108, "epss_percentile": 0.29829}, "CVE-2025-62504": {"epss_score": 0.00015, "epss_percentile": 0.02413}, "CVE-2025-62505": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2025-62506": {"epss_score": 0.00018, "epss_percentile": 0.03669}, "CVE-2025-62507": {"epss_score": 0.00089, "epss_percentile": 0.25833}, "CVE-2025-62508": {"epss_score": 0.00042, "epss_percentile": 0.1258}, "CVE-2025-62509": {"epss_score": 0.00039, "epss_percentile": 0.11645}, "CVE-2025-62510": {"epss_score": 0.00039, "epss_percentile": 0.11645}, "CVE-2025-62511": {"epss_score": 0.00015, "epss_percentile": 0.02313}, "CVE-2025-62513": {"epss_score": 0.00045, "epss_percentile": 0.13708}, "CVE-2025-62515": {"epss_score": 0.00427, "epss_percentile": 0.61873}, "CVE-2025-62517": {"epss_score": 0.0005, "epss_percentile": 0.15744}, "CVE-2025-62518": {"epss_score": 0.00021, "epss_percentile": 0.04945}, "CVE-2025-62519": {"epss_score": 0.00086, "epss_percentile": 0.2538}, "CVE-2025-62520": {"epss_score": 0.00031, "epss_percentile": 0.08714}, "CVE-2025-62521": {"epss_score": 0.00331, "epss_percentile": 0.5553}, "CVE-2025-62522": {"epss_score": 0.02593, "epss_percentile": 0.85188}, "CVE-2025-62523": {"epss_score": 0.00051, "epss_percentile": 0.16263}, "CVE-2025-62524": {"epss_score": 0.00046, "epss_percentile": 0.14143}, "CVE-2025-62525": {"epss_score": 0.00027, "epss_percentile": 0.06901}, "CVE-2025-62526": {"epss_score": 7e-05, "epss_percentile": 0.0036}, "CVE-2025-62527": {"epss_score": 0.00036, "epss_percentile": 0.10326}, "CVE-2025-62528": {"epss_score": 0.00033, "epss_percentile": 0.09209}, "CVE-2025-62549": {"epss_score": 0.00099, "epss_percentile": 0.27866}, "CVE-2025-62550": {"epss_score": 0.00077, "epss_percentile": 0.23444}, "CVE-2025-62552": {"epss_score": 0.00048, "epss_percentile": 0.15148}, "CVE-2025-62553": {"epss_score": 0.00062, "epss_percentile": 0.19616}, "CVE-2025-62554": {"epss_score": 0.00122, "epss_percentile": 0.32156}, "CVE-2025-62555": {"epss_score": 0.0008, "epss_percentile": 0.24031}, "CVE-2025-62556": {"epss_score": 0.00062, "epss_percentile": 0.19616}, "CVE-2025-62557": {"epss_score": 0.00049, "epss_percentile": 0.15513}, "CVE-2025-62558": {"epss_score": 0.00087, "epss_percentile": 0.25491}, "CVE-2025-62559": {"epss_score": 0.00087, "epss_percentile": 0.25491}, "CVE-2025-62560": {"epss_score": 0.00062, "epss_percentile": 0.19616}, "CVE-2025-62561": {"epss_score": 0.00062, "epss_percentile": 0.19616}, "CVE-2025-62562": {"epss_score": 0.00064, "epss_percentile": 0.20251}, "CVE-2025-62563": {"epss_score": 0.00062, "epss_percentile": 0.19616}, "CVE-2025-62564": {"epss_score": 0.00062, "epss_percentile": 0.19616}, "CVE-2025-62565": {"epss_score": 0.00059, "epss_percentile": 0.18614}, "CVE-2025-62567": {"epss_score": 0.00071, "epss_percentile": 0.22024}, "CVE-2025-62569": {"epss_score": 0.00045, "epss_percentile": 0.13943}, "CVE-2025-62570": {"epss_score": 0.00039, "epss_percentile": 0.1155}, "CVE-2025-62571": {"epss_score": 0.00075, "epss_percentile": 0.22945}, "CVE-2025-62572": {"epss_score": 0.00049, "epss_percentile": 0.15513}, "CVE-2025-62573": {"epss_score": 0.00041, "epss_percentile": 0.12277}, "CVE-2025-62575": {"epss_score": 0.00243, "epss_percentile": 0.4747}, "CVE-2025-62577": {"epss_score": 0.00019, "epss_percentile": 0.04225}, "CVE-2025-62578": {"epss_score": 8e-05, "epss_percentile": 0.00584}, "CVE-2025-62579": {"epss_score": 0.00018, "epss_percentile": 0.03661}, "CVE-2025-62580": {"epss_score": 0.00018, "epss_percentile": 0.03661}, "CVE-2025-62583": {"epss_score": 0.0007, "epss_percentile": 0.21826}, "CVE-2025-62584": {"epss_score": 0.00023, "epss_percentile": 0.05379}, "CVE-2025-62585": {"epss_score": 0.00039, "epss_percentile": 0.1163}, "CVE-2025-62586": {"epss_score": 0.00117, "epss_percentile": 0.31286}, "CVE-2025-62587": {"epss_score": 0.00029, "epss_percentile": 0.07627}, "CVE-2025-62588": {"epss_score": 0.00029, "epss_percentile": 0.07627}, "CVE-2025-62589": {"epss_score": 0.00029, "epss_percentile": 0.07627}, "CVE-2025-62590": {"epss_score": 0.00029, "epss_percentile": 0.07627}, "CVE-2025-62591": {"epss_score": 0.0002, "epss_percentile": 0.04638}, "CVE-2025-62592": {"epss_score": 0.0002, "epss_percentile": 0.04638}, "CVE-2025-62593": {"epss_score": 0.0001, "epss_percentile": 0.0083}, "CVE-2025-62594": {"epss_score": 0.00023, "epss_percentile": 0.05345}, "CVE-2025-62595": {"epss_score": 0.00012, "epss_percentile": 0.01424}, "CVE-2025-62596": {"epss_score": 0.0005, "epss_percentile": 0.15725}, "CVE-2025-62597": {"epss_score": 0.00052, "epss_percentile": 0.16531}, "CVE-2025-62598": {"epss_score": 0.00051, "epss_percentile": 0.16028}, "CVE-2025-62604": {"epss_score": 0.00045, "epss_percentile": 0.13721}, "CVE-2025-62605": {"epss_score": 0.00048, "epss_percentile": 0.1528}, "CVE-2025-62606": {"epss_score": 0.00045, "epss_percentile": 0.14016}, "CVE-2025-62607": {"epss_score": 0.00055, "epss_percentile": 0.17411}, "CVE-2025-62608": {"epss_score": 0.00071, "epss_percentile": 0.21993}, "CVE-2025-62609": {"epss_score": 0.00085, "epss_percentile": 0.25239}, "CVE-2025-62610": {"epss_score": 0.00041, "epss_percentile": 0.1226}, "CVE-2025-62611": {"epss_score": 0.0006, "epss_percentile": 0.18975}, "CVE-2025-62612": {"epss_score": 0.00044, "epss_percentile": 0.13666}, "CVE-2025-62613": {"epss_score": 0.00067, "epss_percentile": 0.20984}, "CVE-2025-62614": {"epss_score": 0.00358, "epss_percentile": 0.57526}, "CVE-2025-62617": {"epss_score": 0.00035, "epss_percentile": 0.0996}, "CVE-2025-62618": {"epss_score": 0.00052, "epss_percentile": 0.16512}, "CVE-2025-62626": {"epss_score": 0.00018, "epss_percentile": 0.03913}, "CVE-2025-62630": {"epss_score": 0.00134, "epss_percentile": 0.33827}, "CVE-2025-62631": {"epss_score": 0.00053, "epss_percentile": 0.16993}, "CVE-2025-62641": {"epss_score": 0.00029, "epss_percentile": 0.07627}, "CVE-2025-62642": {"epss_score": 0.00047, "epss_percentile": 0.14491}, "CVE-2025-62643": {"epss_score": 0.0003, "epss_percentile": 0.08154}, "CVE-2025-62644": {"epss_score": 0.00048, "epss_percentile": 0.15255}, "CVE-2025-62645": {"epss_score": 0.00245, "epss_percentile": 0.47729}, "CVE-2025-62646": {"epss_score": 0.00072, "epss_percentile": 0.2237}, "CVE-2025-62647": {"epss_score": 0.00045, "epss_percentile": 0.14054}, "CVE-2025-62648": {"epss_score": 0.0007, "epss_percentile": 0.21868}, "CVE-2025-62649": {"epss_score": 0.00244, "epss_percentile": 0.4761}, "CVE-2025-62650": {"epss_score": 0.00103, "epss_percentile": 0.29003}, "CVE-2025-62651": {"epss_score": 0.00059, "epss_percentile": 0.18687}, "CVE-2025-62652": {"epss_score": 0.0007, "epss_percentile": 0.21704}, "CVE-2025-62653": {"epss_score": 0.00065, "epss_percentile": 0.20439}, "CVE-2025-62654": {"epss_score": 0.00065, "epss_percentile": 0.20439}, "CVE-2025-62655": {"epss_score": 0.00045, "epss_percentile": 0.13775}, "CVE-2025-62656": {"epss_score": 0.00065, "epss_percentile": 0.20439}, "CVE-2025-62657": {"epss_score": 0.00065, "epss_percentile": 0.20439}, "CVE-2025-62658": {"epss_score": 0.00045, "epss_percentile": 0.13775}, "CVE-2025-62659": {"epss_score": 0.0007, "epss_percentile": 0.21704}, "CVE-2025-62661": {"epss_score": 0.00059, "epss_percentile": 0.1891}, "CVE-2025-62662": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62663": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62664": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62665": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62666": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-62667": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62668": {"epss_score": 0.00063, "epss_percentile": 0.19889}, "CVE-2025-62669": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-62670": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62671": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62672": {"epss_score": 0.0014, "epss_percentile": 0.34729}, "CVE-2025-62674": {"epss_score": 0.00033, "epss_percentile": 0.09286}, "CVE-2025-62686": {"epss_score": 0.00015, "epss_percentile": 0.02514}, "CVE-2025-62687": {"epss_score": 0.00019, "epss_percentile": 0.04407}, "CVE-2025-62688": {"epss_score": 0.00016, "epss_percentile": 0.02785}, "CVE-2025-62689": {"epss_score": 0.00049, "epss_percentile": 0.15588}, "CVE-2025-62690": {"epss_score": 0.00031, "epss_percentile": 0.08317}, "CVE-2025-62691": {"epss_score": 0.00326, "epss_percentile": 0.5509}, "CVE-2025-62693": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62694": {"epss_score": 0.00067, "epss_percentile": 0.20984}, "CVE-2025-62695": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62696": {"epss_score": 0.01734, "epss_percentile": 0.82002}, "CVE-2025-62697": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62698": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62699": {"epss_score": 0.0006, "epss_percentile": 0.18975}, "CVE-2025-62700": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62701": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62702": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-62703": {"epss_score": 0.00867, "epss_percentile": 0.74648}, "CVE-2025-62705": {"epss_score": 0.00045, "epss_percentile": 0.13708}, "CVE-2025-62706": {"epss_score": 0.00073, "epss_percentile": 0.22631}, "CVE-2025-62707": {"epss_score": 0.0008, "epss_percentile": 0.24155}, "CVE-2025-62708": {"epss_score": 0.00076, "epss_percentile": 0.23133}, "CVE-2025-62709": {"epss_score": 0.00049, "epss_percentile": 0.15481}, "CVE-2025-62710": {"epss_score": 0.00028, "epss_percentile": 0.07298}, "CVE-2025-62711": {"epss_score": 0.00017, "epss_percentile": 0.03214}, "CVE-2025-62712": {"epss_score": 0.00086, "epss_percentile": 0.2535}, "CVE-2025-62713": {"epss_score": 0.00724, "epss_percentile": 0.72041}, "CVE-2025-62714": {"epss_score": 0.00593, "epss_percentile": 0.6865}, "CVE-2025-62715": {"epss_score": 0.00035, "epss_percentile": 0.09973}, "CVE-2025-62716": {"epss_score": 0.00082, "epss_percentile": 0.24491}, "CVE-2025-62717": {"epss_score": 0.00047, "epss_percentile": 0.14808}, "CVE-2025-62719": {"epss_score": 0.00034, "epss_percentile": 0.09567}, "CVE-2025-62720": {"epss_score": 0.00036, "epss_percentile": 0.10451}, "CVE-2025-62721": {"epss_score": 0.00036, "epss_percentile": 0.10451}, "CVE-2025-62722": {"epss_score": 0.00035, "epss_percentile": 0.09875}, "CVE-2025-62723": {"epss_score": 0.00054, "epss_percentile": 0.17049}, "CVE-2025-62724": {"epss_score": 0.00036, "epss_percentile": 0.10622}, "CVE-2025-62725": {"epss_score": 0.00026, "epss_percentile": 0.06551}, "CVE-2025-62726": {"epss_score": 0.0012, "epss_percentile": 0.31748}, "CVE-2025-62727": {"epss_score": 0.00532, "epss_percentile": 0.66671}, "CVE-2025-62728": {"epss_score": 0.00123, "epss_percentile": 0.32257}, "CVE-2025-62729": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-62730": {"epss_score": 0.00041, "epss_percentile": 0.12358}, "CVE-2025-62731": {"epss_score": 0.00031, "epss_percentile": 0.0851}, "CVE-2025-62733": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62734": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62735": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-62736": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62737": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-62738": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62739": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-62740": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62742": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62743": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62744": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62746": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62747": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62748": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62749": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62750": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-62751": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62752": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62753": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2025-62755": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62756": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62757": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62758": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62759": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62760": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62761": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62762": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62763": {"epss_score": 0.00042, "epss_percentile": 0.12891}, "CVE-2025-62765": {"epss_score": 0.00019, "epss_percentile": 0.04084}, "CVE-2025-62771": {"epss_score": 0.00015, "epss_percentile": 0.02195}, "CVE-2025-62772": {"epss_score": 0.00033, "epss_percentile": 0.09289}, "CVE-2025-62773": {"epss_score": 0.00025, "epss_percentile": 0.06253}, "CVE-2025-62774": {"epss_score": 0.00027, "epss_percentile": 0.06903}, "CVE-2025-62775": {"epss_score": 0.00075, "epss_percentile": 0.22956}, "CVE-2025-62776": {"epss_score": 0.00018, "epss_percentile": 0.03961}, "CVE-2025-62777": {"epss_score": 0.00021, "epss_percentile": 0.04817}, "CVE-2025-62778": {"epss_score": 0.00044, "epss_percentile": 0.13533}, "CVE-2025-62779": {"epss_score": 0.00041, "epss_percentile": 0.12229}, "CVE-2025-62780": {"epss_score": 0.00032, "epss_percentile": 0.08959}, "CVE-2025-62781": {"epss_score": 0.00053, "epss_percentile": 0.17009}, "CVE-2025-62782": {"epss_score": 0.0004, "epss_percentile": 0.11915}, "CVE-2025-62783": {"epss_score": 0.00038, "epss_percentile": 0.11096}, "CVE-2025-62784": {"epss_score": 0.00043, "epss_percentile": 0.13014}, "CVE-2025-62785": {"epss_score": 0.00094, "epss_percentile": 0.27033}, "CVE-2025-62786": {"epss_score": 0.00566, "epss_percentile": 0.67834}, "CVE-2025-62787": {"epss_score": 0.00057, "epss_percentile": 0.1816}, "CVE-2025-62788": {"epss_score": 0.00058, "epss_percentile": 0.18548}, "CVE-2025-62789": {"epss_score": 0.00094, "epss_percentile": 0.27033}, "CVE-2025-62790": {"epss_score": 0.00094, "epss_percentile": 0.27033}, "CVE-2025-62791": {"epss_score": 0.00073, "epss_percentile": 0.22665}, "CVE-2025-62792": {"epss_score": 0.00062, "epss_percentile": 0.19772}, "CVE-2025-62793": {"epss_score": 0.00044, "epss_percentile": 0.13495}, "CVE-2025-62794": {"epss_score": 0.00015, "epss_percentile": 0.02518}, "CVE-2025-62795": {"epss_score": 0.00044, "epss_percentile": 0.13656}, "CVE-2025-62796": {"epss_score": 0.00019, "epss_percentile": 0.04087}, "CVE-2025-62797": {"epss_score": 0.00028, "epss_percentile": 0.07534}, "CVE-2025-62798": {"epss_score": 0.00039, "epss_percentile": 0.11576}, "CVE-2025-62800": {"epss_score": 0.00062, "epss_percentile": 0.19733}, "CVE-2025-62801": {"epss_score": 0.0003, "epss_percentile": 0.0817}, "CVE-2025-62802": {"epss_score": 0.00097, "epss_percentile": 0.27591}, "CVE-2025-62820": {"epss_score": 0.00053, "epss_percentile": 0.16898}, "CVE-2025-62840": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-62842": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-62847": {"epss_score": 0.00109, "epss_percentile": 0.3002}, "CVE-2025-62848": {"epss_score": 0.00139, "epss_percentile": 0.34648}, "CVE-2025-62849": {"epss_score": 0.00106, "epss_percentile": 0.2953}, "CVE-2025-62852": {"epss_score": 0.00116, "epss_percentile": 0.31165}, "CVE-2025-62857": {"epss_score": 0.00079, "epss_percentile": 0.23987}, "CVE-2025-62862": {"epss_score": 0.00014, "epss_percentile": 0.01881}, "CVE-2025-62863": {"epss_score": 0.00056, "epss_percentile": 0.17857}, "CVE-2025-62864": {"epss_score": 0.00056, "epss_percentile": 0.17857}, "CVE-2025-62865": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62866": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62867": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62868": {"epss_score": 0.00172, "epss_percentile": 0.38969}, "CVE-2025-62869": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62870": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-62871": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62872": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62873": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62874": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-62875": {"epss_score": 0.0002, "epss_percentile": 0.04462}, "CVE-2025-62876": {"epss_score": 0.00019, "epss_percentile": 0.04271}, "CVE-2025-62880": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-62881": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62882": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62883": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62884": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-62885": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62886": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-62887": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62888": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-62889": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62890": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-62891": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-62892": {"epss_score": 0.00045, "epss_percentile": 0.13761}, "CVE-2025-62894": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62895": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-62896": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-62897": {"epss_score": 0.00058, "epss_percentile": 0.18453}, "CVE-2025-62898": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62899": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62900": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62901": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62902": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-62903": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62904": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62905": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62906": {"epss_score": 0.00062, "epss_percentile": 0.19687}, "CVE-2025-62907": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62909": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-62910": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62911": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62912": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62913": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62914": {"epss_score": 0.00038, "epss_percentile": 0.11308}, "CVE-2025-62915": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-62916": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62917": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62918": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62919": {"epss_score": 0.00058, "epss_percentile": 0.18419}, "CVE-2025-62920": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62921": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62922": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-62923": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-62924": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62925": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-62926": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62927": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-62928": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-62929": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62930": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-62931": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62932": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62933": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-62934": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-62935": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-62936": {"epss_score": 0.00039, "epss_percentile": 0.11608}, "CVE-2025-62937": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62938": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-62939": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62940": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62941": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62942": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62943": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62944": {"epss_score": 0.00062, "epss_percentile": 0.19687}, "CVE-2025-62945": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-62946": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62947": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-62948": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62949": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62950": {"epss_score": 0.00018, "epss_percentile": 0.03562}, "CVE-2025-62951": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62952": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62953": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62954": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62955": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2025-62956": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-62957": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-62958": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-62959": {"epss_score": 0.00065, "epss_percentile": 0.20621}, "CVE-2025-62960": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-62961": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-62962": {"epss_score": 0.00024, "epss_percentile": 0.05837}, "CVE-2025-62963": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62964": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-62965": {"epss_score": 0.00054, "epss_percentile": 0.17172}, "CVE-2025-62966": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62967": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62968": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62969": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62970": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-62971": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62972": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62973": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-62974": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62975": {"epss_score": 0.0002, "epss_percentile": 0.04641}, "CVE-2025-62976": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-62977": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-62978": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-62979": {"epss_score": 0.00041, "epss_percentile": 0.12354}, "CVE-2025-62980": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-62981": {"epss_score": 0.00038, "epss_percentile": 0.11276}, "CVE-2025-62982": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-62983": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62984": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62985": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62986": {"epss_score": 0.0002, "epss_percentile": 0.04641}, "CVE-2025-62987": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-62988": {"epss_score": 0.00039, "epss_percentile": 0.11587}, "CVE-2025-62989": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-62990": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62991": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-62992": {"epss_score": 0.00017, "epss_percentile": 0.03166}, "CVE-2025-62993": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62994": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2025-62995": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62996": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-62997": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-62998": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2025-62999": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-63000": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-63001": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-63002": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-63003": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2025-63004": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-63005": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-63006": {"epss_score": 0.0003, "epss_percentile": 0.08267}, "CVE-2025-63007": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2025-63008": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-63009": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-63010": {"epss_score": 0.00025, "epss_percentile": 0.06277}, "CVE-2025-63011": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-63012": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-63013": {"epss_score": 0.0003, "epss_percentile": 0.0809}, "CVE-2025-63014": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-63015": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-63016": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-63020": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-63021": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-63022": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-63023": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-63024": {"epss_score": 0.00029, "epss_percentile": 0.07743}, "CVE-2025-63025": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-63027": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-63028": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-63030": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-63031": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-63032": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-63033": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63034": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-63035": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63036": {"epss_score": 0.00052, "epss_percentile": 0.16635}, "CVE-2025-63037": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63038": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-63039": {"epss_score": 0.00034, "epss_percentile": 0.09696}, "CVE-2025-63040": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-63042": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63043": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-63044": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63045": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63046": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63047": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-63048": {"epss_score": 0.00038, "epss_percentile": 0.11296}, "CVE-2025-63049": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-63050": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63052": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63053": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-63054": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-63055": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63056": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-63057": {"epss_score": 0.00035, "epss_percentile": 0.10077}, "CVE-2025-63058": {"epss_score": 0.00015, "epss_percentile": 0.02348}, "CVE-2025-63059": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63060": {"epss_score": 0.00015, "epss_percentile": 0.0251}, "CVE-2025-63061": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63062": {"epss_score": 0.00043, "epss_percentile": 0.13213}, "CVE-2025-63063": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-63064": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63065": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-63066": {"epss_score": 0.00036, "epss_percentile": 0.10428}, "CVE-2025-63067": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-63068": {"epss_score": 0.00051, "epss_percentile": 0.16158}, "CVE-2025-63069": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-63070": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2025-63071": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-63072": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-63073": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-63074": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2025-63075": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-63076": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2025-63077": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-63082": {"epss_score": 0.00043, "epss_percentile": 0.13215}, "CVE-2025-63083": {"epss_score": 0.00043, "epss_percentile": 0.13215}, "CVE-2025-63094": {"epss_score": 0.00061, "epss_percentile": 0.19504}, "CVE-2025-63095": {"epss_score": 0.00057, "epss_percentile": 0.18132}, "CVE-2025-63147": {"epss_score": 0.00074, "epss_percentile": 0.2282}, "CVE-2025-63149": {"epss_score": 0.00072, "epss_percentile": 0.22248}, "CVE-2025-63152": {"epss_score": 0.00072, "epss_percentile": 0.22248}, "CVE-2025-63153": {"epss_score": 0.00262, "epss_percentile": 0.49376}, "CVE-2025-63154": {"epss_score": 0.00268, "epss_percentile": 0.50024}, "CVE-2025-63205": {"epss_score": 0.00044, "epss_percentile": 0.13552}, "CVE-2025-63206": {"epss_score": 0.00166, "epss_percentile": 0.38255}, "CVE-2025-63207": {"epss_score": 0.00135, "epss_percentile": 0.34027}, "CVE-2025-63208": {"epss_score": 0.00019, "epss_percentile": 0.04084}, "CVE-2025-63209": {"epss_score": 0.00083, "epss_percentile": 0.24782}, "CVE-2025-63210": {"epss_score": 0.00119, "epss_percentile": 0.31543}, "CVE-2025-63211": {"epss_score": 0.00043, "epss_percentile": 0.13021}, "CVE-2025-63212": {"epss_score": 0.0008, "epss_percentile": 0.24096}, "CVE-2025-63213": {"epss_score": 0.00277, "epss_percentile": 0.50815}, "CVE-2025-63214": {"epss_score": 0.00069, "epss_percentile": 0.21604}, "CVE-2025-63215": {"epss_score": 0.00115, "epss_percentile": 0.30892}, "CVE-2025-63216": {"epss_score": 0.00119, "epss_percentile": 0.31543}, "CVE-2025-63217": {"epss_score": 0.00119, "epss_percentile": 0.31543}, "CVE-2025-63218": {"epss_score": 0.00217, "epss_percentile": 0.44279}, "CVE-2025-63219": {"epss_score": 0.00109, "epss_percentile": 0.30068}, "CVE-2025-63220": {"epss_score": 0.00115, "epss_percentile": 0.30892}, "CVE-2025-63221": {"epss_score": 0.00084, "epss_percentile": 0.24976}, "CVE-2025-63223": {"epss_score": 0.00217, "epss_percentile": 0.44279}, "CVE-2025-63224": {"epss_score": 0.00119, "epss_percentile": 0.31543}, "CVE-2025-63225": {"epss_score": 0.00338, "epss_percentile": 0.56102}, "CVE-2025-63226": {"epss_score": 0.00032, "epss_percentile": 0.09021}, "CVE-2025-63227": {"epss_score": 0.00099, "epss_percentile": 0.28341}, "CVE-2025-63228": {"epss_score": 0.00503, "epss_percentile": 0.65458}, "CVE-2025-63229": {"epss_score": 0.00054, "epss_percentile": 0.1718}, "CVE-2025-63243": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-63248": {"epss_score": 0.0004, "epss_percentile": 0.1204}, "CVE-2025-63258": {"epss_score": 0.00083, "epss_percentile": 0.24597}, "CVE-2025-63288": {"epss_score": 0.00053, "epss_percentile": 0.16858}, "CVE-2025-63289": {"epss_score": 0.00024, "epss_percentile": 0.06027}, "CVE-2025-63291": {"epss_score": 0.00032, "epss_percentile": 0.08961}, "CVE-2025-63292": {"epss_score": 7e-05, "epss_percentile": 0.00334}, "CVE-2025-63293": {"epss_score": 0.00037, "epss_percentile": 0.10688}, "CVE-2025-63294": {"epss_score": 0.00026, "epss_percentile": 0.06619}, "CVE-2025-63296": {"epss_score": 0.00068, "epss_percentile": 0.21215}, "CVE-2025-63298": {"epss_score": 0.00112, "epss_percentile": 0.3041}, "CVE-2025-63307": {"epss_score": 0.00043, "epss_percentile": 0.13002}, "CVE-2025-63317": {"epss_score": 0.00032, "epss_percentile": 0.09078}, "CVE-2025-63334": {"epss_score": 0.00127, "epss_percentile": 0.32912}, "CVE-2025-63353": {"epss_score": 0.01939, "epss_percentile": 0.82973}, "CVE-2025-63361": {"epss_score": 0.00033, "epss_percentile": 0.09291}, "CVE-2025-63362": {"epss_score": 0.00124, "epss_percentile": 0.32426}, "CVE-2025-63363": {"epss_score": 0.00054, "epss_percentile": 0.17251}, "CVE-2025-63364": {"epss_score": 0.00019, "epss_percentile": 0.04069}, "CVE-2025-63365": {"epss_score": 0.00159, "epss_percentile": 0.37306}, "CVE-2025-63371": {"epss_score": 0.00577, "epss_percentile": 0.68156}, "CVE-2025-63384": {"epss_score": 0.00036, "epss_percentile": 0.105}, "CVE-2025-63386": {"epss_score": 0.00019, "epss_percentile": 0.04179}, "CVE-2025-63387": {"epss_score": 0.04754, "epss_percentile": 0.89108}, "CVE-2025-63388": {"epss_score": 0.00019, "epss_percentile": 0.04179}, "CVE-2025-63389": {"epss_score": 0.00441, "epss_percentile": 0.62677}, "CVE-2025-63390": {"epss_score": 0.00073, "epss_percentile": 0.22659}, "CVE-2025-63391": {"epss_score": 0.0009, "epss_percentile": 0.25997}, "CVE-2025-63396": {"epss_score": 0.00014, "epss_percentile": 0.01971}, "CVE-2025-63397": {"epss_score": 0.00092, "epss_percentile": 0.26448}, "CVE-2025-63401": {"epss_score": 0.00268, "epss_percentile": 0.50099}, "CVE-2025-63402": {"epss_score": 0.00324, "epss_percentile": 0.54967}, "CVE-2025-63406": {"epss_score": 0.00335, "epss_percentile": 0.55846}, "CVE-2025-63408": {"epss_score": 0.00051, "epss_percentile": 0.16258}, "CVE-2025-63414": {"epss_score": 0.01061, "epss_percentile": 0.77172}, "CVE-2025-63416": {"epss_score": 0.00063, "epss_percentile": 0.19945}, "CVE-2025-63417": {"epss_score": 0.00062, "epss_percentile": 0.19691}, "CVE-2025-63418": {"epss_score": 0.00051, "epss_percentile": 0.1621}, "CVE-2025-63419": {"epss_score": 0.00036, "epss_percentile": 0.10541}, "CVE-2025-63420": {"epss_score": 0.0004, "epss_percentile": 0.11963}, "CVE-2025-63422": {"epss_score": 0.00047, "epss_percentile": 0.14844}, "CVE-2025-63423": {"epss_score": 0.00047, "epss_percentile": 0.14844}, "CVE-2025-63432": {"epss_score": 0.00034, "epss_percentile": 0.09517}, "CVE-2025-63433": {"epss_score": 0.00029, "epss_percentile": 0.07952}, "CVE-2025-63434": {"epss_score": 0.0004, "epss_percentile": 0.1217}, "CVE-2025-63435": {"epss_score": 0.00108, "epss_percentile": 0.29892}, "CVE-2025-63441": {"epss_score": 0.00036, "epss_percentile": 0.10302}, "CVE-2025-63442": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-63443": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-63446": {"epss_score": 0.00051, "epss_percentile": 0.1621}, "CVE-2025-63447": {"epss_score": 0.00051, "epss_percentile": 0.1621}, "CVE-2025-63448": {"epss_score": 0.00051, "epss_percentile": 0.1621}, "CVE-2025-63449": {"epss_score": 0.00051, "epss_percentile": 0.1621}, "CVE-2025-63450": {"epss_score": 0.00051, "epss_percentile": 0.1621}, "CVE-2025-63451": {"epss_score": 0.0005, "epss_percentile": 0.15733}, "CVE-2025-63452": {"epss_score": 0.00049, "epss_percentile": 0.15294}, "CVE-2025-63453": {"epss_score": 0.0005, "epss_percentile": 0.15733}, "CVE-2025-63454": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-63455": {"epss_score": 0.00072, "epss_percentile": 0.22248}, "CVE-2025-63456": {"epss_score": 0.00074, "epss_percentile": 0.2282}, "CVE-2025-63457": {"epss_score": 0.00074, "epss_percentile": 0.2282}, "CVE-2025-63458": {"epss_score": 0.00075, "epss_percentile": 0.22937}, "CVE-2025-63459": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2025-63460": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2025-63461": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2025-63462": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2025-63463": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2025-63464": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2025-63465": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2025-63466": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2025-63467": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2025-63468": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2025-63469": {"epss_score": 0.00274, "epss_percentile": 0.50524}, "CVE-2025-63497": {"epss_score": 0.0003, "epss_percentile": 0.08029}, "CVE-2025-63498": {"epss_score": 0.00046, "epss_percentile": 0.14375}, "CVE-2025-63499": {"epss_score": 0.00011, "epss_percentile": 0.00932}, "CVE-2025-63512": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2025-63513": {"epss_score": 0.00036, "epss_percentile": 0.10233}, "CVE-2025-63514": {"epss_score": 0.00042, "epss_percentile": 0.12901}, "CVE-2025-63520": {"epss_score": 0.00031, "epss_percentile": 0.08631}, "CVE-2025-63522": {"epss_score": 0.00029, "epss_percentile": 0.07744}, "CVE-2025-63523": {"epss_score": 0.00036, "epss_percentile": 0.10622}, "CVE-2025-63525": {"epss_score": 0.00034, "epss_percentile": 0.09435}, "CVE-2025-63526": {"epss_score": 0.00036, "epss_percentile": 0.10298}, "CVE-2025-63527": {"epss_score": 0.00036, "epss_percentile": 0.10298}, "CVE-2025-63528": {"epss_score": 0.00036, "epss_percentile": 0.10298}, "CVE-2025-63529": {"epss_score": 0.00119, "epss_percentile": 0.31659}, "CVE-2025-63531": {"epss_score": 0.00145, "epss_percentile": 0.3543}, "CVE-2025-63532": {"epss_score": 0.00118, "epss_percentile": 0.31385}, "CVE-2025-63533": {"epss_score": 0.00036, "epss_percentile": 0.10298}, "CVE-2025-63534": {"epss_score": 0.00036, "epss_percentile": 0.10298}, "CVE-2025-63535": {"epss_score": 0.00118, "epss_percentile": 0.31385}, "CVE-2025-63543": {"epss_score": 0.00051, "epss_percentile": 0.1621}, "CVE-2025-63544": {"epss_score": 0.00051, "epss_percentile": 0.1621}, "CVE-2025-63551": {"epss_score": 0.00072, "epss_percentile": 0.22371}, "CVE-2025-63560": {"epss_score": 0.00142, "epss_percentile": 0.35076}, "CVE-2025-63561": {"epss_score": 0.00077, "epss_percentile": 0.23324}, "CVE-2025-63562": {"epss_score": 0.00051, "epss_percentile": 0.1602}, "CVE-2025-63563": {"epss_score": 0.00057, "epss_percentile": 0.18072}, "CVE-2025-63585": {"epss_score": 0.00045, "epss_percentile": 0.13825}, "CVE-2025-63588": {"epss_score": 0.00064, "epss_percentile": 0.20306}, "CVE-2025-63589": {"epss_score": 0.00061, "epss_percentile": 0.19247}, "CVE-2025-63593": {"epss_score": 0.00044, "epss_percentile": 0.13482}, "CVE-2025-63601": {"epss_score": 0.00373, "epss_percentile": 0.58503}, "CVE-2025-63602": {"epss_score": 0.00068, "epss_percentile": 0.21269}, "CVE-2025-63603": {"epss_score": 0.03446, "epss_percentile": 0.87147}, "CVE-2025-63604": {"epss_score": 0.00097, "epss_percentile": 0.27628}, "CVE-2025-63608": {"epss_score": 0.00034, "epss_percentile": 0.09747}, "CVE-2025-63617": {"epss_score": 0.00044, "epss_percentile": 0.13585}, "CVE-2025-63622": {"epss_score": 0.00046, "epss_percentile": 0.14188}, "CVE-2025-63638": {"epss_score": 0.00051, "epss_percentile": 0.1621}, "CVE-2025-63639": {"epss_score": 0.00051, "epss_percentile": 0.1621}, "CVE-2025-63640": {"epss_score": 0.00051, "epss_percentile": 0.1621}, "CVE-2025-63645": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-63662": {"epss_score": 0.00042, "epss_percentile": 0.12563}, "CVE-2025-63663": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-63664": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-63665": {"epss_score": 0.00102, "epss_percentile": 0.28835}, "CVE-2025-63666": {"epss_score": 0.00094, "epss_percentile": 0.26975}, "CVE-2025-63667": {"epss_score": 0.00096, "epss_percentile": 0.27278}, "CVE-2025-63674": {"epss_score": 0.00037, "epss_percentile": 0.11002}, "CVE-2025-63675": {"epss_score": 0.00036, "epss_percentile": 0.1037}, "CVE-2025-63678": {"epss_score": 0.00112, "epss_percentile": 0.3041}, "CVE-2025-63679": {"epss_score": 0.00073, "epss_percentile": 0.2258}, "CVE-2025-63680": {"epss_score": 7e-05, "epss_percentile": 0.00442}, "CVE-2025-63681": {"epss_score": 0.00011, "epss_percentile": 0.01104}, "CVE-2025-63685": {"epss_score": 0.00073, "epss_percentile": 0.2258}, "CVE-2025-63686": {"epss_score": 0.00054, "epss_percentile": 0.17216}, "CVE-2025-63687": {"epss_score": 0.00038, "epss_percentile": 0.11308}, "CVE-2025-63689": {"epss_score": 0.00264, "epss_percentile": 0.49684}, "CVE-2025-63690": {"epss_score": 0.00972, "epss_percentile": 0.76135}, "CVE-2025-63691": {"epss_score": 0.00059, "epss_percentile": 0.1884}, "CVE-2025-63693": {"epss_score": 0.00031, "epss_percentile": 0.08692}, "CVE-2025-63694": {"epss_score": 0.00044, "epss_percentile": 0.13494}, "CVE-2025-63695": {"epss_score": 0.00073, "epss_percentile": 0.2258}, "CVE-2025-63701": {"epss_score": 0.0002, "epss_percentile": 0.04614}, "CVE-2025-63708": {"epss_score": 0.00057, "epss_percentile": 0.18201}, "CVE-2025-63709": {"epss_score": 0.00048, "epss_percentile": 0.15193}, "CVE-2025-63710": {"epss_score": 0.0003, "epss_percentile": 0.08213}, "CVE-2025-63711": {"epss_score": 0.00087, "epss_percentile": 0.25577}, "CVE-2025-63712": {"epss_score": 0.0003, "epss_percentile": 0.08096}, "CVE-2025-63713": {"epss_score": 0.00074, "epss_percentile": 0.22717}, "CVE-2025-63714": {"epss_score": 0.00048, "epss_percentile": 0.14941}, "CVE-2025-63716": {"epss_score": 0.00026, "epss_percentile": 0.06514}, "CVE-2025-63717": {"epss_score": 0.00026, "epss_percentile": 0.06514}, "CVE-2025-63718": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2025-63719": {"epss_score": 0.00038, "epss_percentile": 0.11301}, "CVE-2025-63721": {"epss_score": 0.00051, "epss_percentile": 0.1616}, "CVE-2025-63724": {"epss_score": 0.00035, "epss_percentile": 0.09915}, "CVE-2025-63725": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-63729": {"epss_score": 6e-05, "epss_percentile": 0.00285}, "CVE-2025-63735": {"epss_score": 0.00044, "epss_percentile": 0.13482}, "CVE-2025-63737": {"epss_score": 0.00036, "epss_percentile": 0.10411}, "CVE-2025-63738": {"epss_score": 0.00028, "epss_percentile": 0.07558}, "CVE-2025-63739": {"epss_score": 0.00027, "epss_percentile": 0.07153}, "CVE-2025-63740": {"epss_score": 0.00021, "epss_percentile": 0.04795}, "CVE-2025-63742": {"epss_score": 0.00035, "epss_percentile": 0.1013}, "CVE-2025-63744": {"epss_score": 0.00037, "epss_percentile": 0.10658}, "CVE-2025-63745": {"epss_score": 0.00017, "epss_percentile": 0.03304}, "CVE-2025-63747": {"epss_score": 0.00076, "epss_percentile": 0.23214}, "CVE-2025-63748": {"epss_score": 0.00055, "epss_percentile": 0.17403}, "CVE-2025-63749": {"epss_score": 0.07467, "epss_percentile": 0.91489}, "CVE-2025-63757": {"epss_score": 0.00046, "epss_percentile": 0.14328}, "CVE-2025-63783": {"epss_score": 0.00072, "epss_percentile": 0.22385}, "CVE-2025-63784": {"epss_score": 0.00138, "epss_percentile": 0.34369}, "CVE-2025-63785": {"epss_score": 0.00083, "epss_percentile": 0.24592}, "CVE-2025-63800": {"epss_score": 0.00278, "epss_percentile": 0.5085}, "CVE-2025-63807": {"epss_score": 0.00076, "epss_percentile": 0.2312}, "CVE-2025-63811": {"epss_score": 0.00048, "epss_percentile": 0.14984}, "CVE-2025-63828": {"epss_score": 0.00033, "epss_percentile": 0.09408}, "CVE-2025-63829": {"epss_score": 0.00055, "epss_percentile": 0.17411}, "CVE-2025-63830": {"epss_score": 0.00014, "epss_percentile": 0.02018}, "CVE-2025-63834": {"epss_score": 0.00046, "epss_percentile": 0.14287}, "CVE-2025-63835": {"epss_score": 0.00265, "epss_percentile": 0.4978}, "CVE-2025-63848": {"epss_score": 0.00043, "epss_percentile": 0.13021}, "CVE-2025-63872": {"epss_score": 0.00043, "epss_percentile": 0.13021}, "CVE-2025-63878": {"epss_score": 0.00036, "epss_percentile": 0.10268}, "CVE-2025-63879": {"epss_score": 0.00044, "epss_percentile": 0.13482}, "CVE-2025-63883": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-63885": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-63888": {"epss_score": 0.00342, "epss_percentile": 0.56368}, "CVE-2025-63889": {"epss_score": 0.00047, "epss_percentile": 0.14489}, "CVE-2025-63891": {"epss_score": 0.0007, "epss_percentile": 0.21799}, "CVE-2025-63892": {"epss_score": 0.00054, "epss_percentile": 0.17257}, "CVE-2025-63895": {"epss_score": 0.00052, "epss_percentile": 0.16594}, "CVE-2025-63896": {"epss_score": 0.00021, "epss_percentile": 0.04891}, "CVE-2025-63914": {"epss_score": 0.00051, "epss_percentile": 0.16162}, "CVE-2025-63916": {"epss_score": 0.00221, "epss_percentile": 0.4468}, "CVE-2025-63917": {"epss_score": 0.00064, "epss_percentile": 0.20161}, "CVE-2025-63918": {"epss_score": 0.00143, "epss_percentile": 0.35188}, "CVE-2025-63927": {"epss_score": 0.00022, "epss_percentile": 0.04993}, "CVE-2025-63929": {"epss_score": 0.00057, "epss_percentile": 0.18198}, "CVE-2025-63932": {"epss_score": 0.00365, "epss_percentile": 0.58008}, "CVE-2025-63938": {"epss_score": 0.00047, "epss_percentile": 0.14475}, "CVE-2025-63947": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-63948": {"epss_score": 0.00026, "epss_percentile": 0.06443}, "CVE-2025-63949": {"epss_score": 0.0005, "epss_percentile": 0.1571}, "CVE-2025-63950": {"epss_score": 0.00257, "epss_percentile": 0.48855}, "CVE-2025-63951": {"epss_score": 0.00257, "epss_percentile": 0.48855}, "CVE-2025-63952": {"epss_score": 0.00018, "epss_percentile": 0.03656}, "CVE-2025-63953": {"epss_score": 0.00023, "epss_percentile": 0.05447}, "CVE-2025-63955": {"epss_score": 0.00033, "epss_percentile": 0.09188}, "CVE-2025-63958": {"epss_score": 0.00429, "epss_percentile": 0.61986}, "CVE-2025-63994": {"epss_score": 0.00119, "epss_percentile": 0.3158}, "CVE-2025-64011": {"epss_score": 0.00023, "epss_percentile": 0.05411}, "CVE-2025-64012": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-64027": {"epss_score": 0.00014, "epss_percentile": 0.0206}, "CVE-2025-64030": {"epss_score": 0.00041, "epss_percentile": 0.12448}, "CVE-2025-64046": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-64047": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-64048": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-64049": {"epss_score": 0.00051, "epss_percentile": 0.1599}, "CVE-2025-64050": {"epss_score": 0.00472, "epss_percentile": 0.64053}, "CVE-2025-64052": {"epss_score": 0.00042, "epss_percentile": 0.12914}, "CVE-2025-64053": {"epss_score": 0.00103, "epss_percentile": 0.28929}, "CVE-2025-64054": {"epss_score": 0.0011, "epss_percentile": 0.30171}, "CVE-2025-64055": {"epss_score": 0.00402, "epss_percentile": 0.60286}, "CVE-2025-64056": {"epss_score": 0.00042, "epss_percentile": 0.12898}, "CVE-2025-64057": {"epss_score": 0.00065, "epss_percentile": 0.20571}, "CVE-2025-64061": {"epss_score": 0.00035, "epss_percentile": 0.10006}, "CVE-2025-64062": {"epss_score": 0.0005, "epss_percentile": 0.15884}, "CVE-2025-64063": {"epss_score": 0.00059, "epss_percentile": 0.18882}, "CVE-2025-64064": {"epss_score": 0.00041, "epss_percentile": 0.12358}, "CVE-2025-64065": {"epss_score": 0.0005, "epss_percentile": 0.15884}, "CVE-2025-64066": {"epss_score": 0.00145, "epss_percentile": 0.35521}, "CVE-2025-64067": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-64070": {"epss_score": 0.00039, "epss_percentile": 0.11722}, "CVE-2025-64076": {"epss_score": 0.00183, "epss_percentile": 0.40343}, "CVE-2025-64081": {"epss_score": 0.00038, "epss_percentile": 0.11236}, "CVE-2025-64084": {"epss_score": 0.0004, "epss_percentile": 0.12023}, "CVE-2025-64085": {"epss_score": 0.00047, "epss_percentile": 0.14576}, "CVE-2025-64086": {"epss_score": 0.00047, "epss_percentile": 0.14576}, "CVE-2025-64094": {"epss_score": 0.00041, "epss_percentile": 0.12229}, "CVE-2025-64095": {"epss_score": 0.38406, "epss_percentile": 0.97099}, "CVE-2025-64096": {"epss_score": 0.00255, "epss_percentile": 0.48628}, "CVE-2025-64099": {"epss_score": 0.00067, "epss_percentile": 0.2117}, "CVE-2025-64100": {"epss_score": 0.00043, "epss_percentile": 0.13173}, "CVE-2025-64101": {"epss_score": 0.00117, "epss_percentile": 0.31376}, "CVE-2025-64102": {"epss_score": 0.00061, "epss_percentile": 0.19248}, "CVE-2025-64103": {"epss_score": 0.00131, "epss_percentile": 0.33477}, "CVE-2025-64104": {"epss_score": 0.00057, "epss_percentile": 0.18063}, "CVE-2025-64106": {"epss_score": 0.00063, "epss_percentile": 0.19889}, "CVE-2025-64107": {"epss_score": 0.00056, "epss_percentile": 0.17867}, "CVE-2025-64108": {"epss_score": 0.00089, "epss_percentile": 0.25853}, "CVE-2025-64109": {"epss_score": 0.00181, "epss_percentile": 0.40072}, "CVE-2025-64110": {"epss_score": 0.00042, "epss_percentile": 0.12628}, "CVE-2025-64112": {"epss_score": 0.00046, "epss_percentile": 0.14107}, "CVE-2025-64113": {"epss_score": 0.00017, "epss_percentile": 0.0341}, "CVE-2025-64114": {"epss_score": 0.00066, "epss_percentile": 0.20762}, "CVE-2025-64115": {"epss_score": 0.00043, "epss_percentile": 0.13102}, "CVE-2025-64116": {"epss_score": 0.00043, "epss_percentile": 0.13102}, "CVE-2025-64117": {"epss_score": 0.00017, "epss_percentile": 0.03516}, "CVE-2025-64118": {"epss_score": 5e-05, "epss_percentile": 0.0022}, "CVE-2025-64119": {"epss_score": 0.00087, "epss_percentile": 0.25468}, "CVE-2025-64120": {"epss_score": 0.00661, "epss_percentile": 0.70583}, "CVE-2025-64121": {"epss_score": 0.00087, "epss_percentile": 0.25468}, "CVE-2025-64122": {"epss_score": 0.00018, "epss_percentile": 0.03894}, "CVE-2025-64123": {"epss_score": 0.00054, "epss_percentile": 0.17131}, "CVE-2025-64124": {"epss_score": 0.00457, "epss_percentile": 0.63373}, "CVE-2025-64125": {"epss_score": 0.00038, "epss_percentile": 0.11425}, "CVE-2025-64126": {"epss_score": 0.05599, "epss_percentile": 0.90037}, "CVE-2025-64127": {"epss_score": 0.05599, "epss_percentile": 0.90037}, "CVE-2025-64128": {"epss_score": 0.05599, "epss_percentile": 0.90037}, "CVE-2025-64129": {"epss_score": 0.00168, "epss_percentile": 0.38435}, "CVE-2025-64130": {"epss_score": 0.00154, "epss_percentile": 0.36741}, "CVE-2025-64131": {"epss_score": 0.00048, "epss_percentile": 0.15174}, "CVE-2025-64132": {"epss_score": 0.00021, "epss_percentile": 0.0479}, "CVE-2025-64133": {"epss_score": 0.00018, "epss_percentile": 0.03914}, "CVE-2025-64134": {"epss_score": 0.00047, "epss_percentile": 0.1488}, "CVE-2025-64135": {"epss_score": 0.00037, "epss_percentile": 0.10787}, "CVE-2025-64136": {"epss_score": 0.0003, "epss_percentile": 0.08249}, "CVE-2025-64137": {"epss_score": 0.00041, "epss_percentile": 0.12407}, "CVE-2025-64138": {"epss_score": 0.00021, "epss_percentile": 0.04892}, "CVE-2025-64139": {"epss_score": 0.00027, "epss_percentile": 0.07171}, "CVE-2025-64140": {"epss_score": 0.00096, "epss_percentile": 0.27373}, "CVE-2025-64141": {"epss_score": 0.00021, "epss_percentile": 0.04892}, "CVE-2025-64142": {"epss_score": 0.00027, "epss_percentile": 0.07171}, "CVE-2025-64143": {"epss_score": 0.00027, "epss_percentile": 0.06788}, "CVE-2025-64144": {"epss_score": 0.00027, "epss_percentile": 0.06788}, "CVE-2025-64145": {"epss_score": 0.00018, "epss_percentile": 0.03836}, "CVE-2025-64146": {"epss_score": 0.00027, "epss_percentile": 0.06788}, "CVE-2025-64147": {"epss_score": 0.00018, "epss_percentile": 0.03836}, "CVE-2025-64148": {"epss_score": 0.0005, "epss_percentile": 0.15845}, "CVE-2025-64149": {"epss_score": 0.00028, "epss_percentile": 0.07333}, "CVE-2025-64150": {"epss_score": 0.00038, "epss_percentile": 0.11299}, "CVE-2025-64151": {"epss_score": 0.00021, "epss_percentile": 0.04894}, "CVE-2025-64153": {"epss_score": 0.00158, "epss_percentile": 0.37216}, "CVE-2025-64156": {"epss_score": 0.00048, "epss_percentile": 0.15244}, "CVE-2025-64163": {"epss_score": 0.00072, "epss_percentile": 0.2237}, "CVE-2025-64164": {"epss_score": 0.00067, "epss_percentile": 0.21101}, "CVE-2025-64167": {"epss_score": 0.00047, "epss_percentile": 0.14895}, "CVE-2025-64168": {"epss_score": 0.00035, "epss_percentile": 0.10141}, "CVE-2025-64169": {"epss_score": 0.00078, "epss_percentile": 0.23749}, "CVE-2025-64170": {"epss_score": 0.00015, "epss_percentile": 0.0259}, "CVE-2025-64171": {"epss_score": 0.00033, "epss_percentile": 0.09399}, "CVE-2025-64173": {"epss_score": 0.00043, "epss_percentile": 0.13032}, "CVE-2025-64174": {"epss_score": 0.00062, "epss_percentile": 0.19619}, "CVE-2025-64176": {"epss_score": 0.00123, "epss_percentile": 0.32194}, "CVE-2025-64177": {"epss_score": 0.00045, "epss_percentile": 0.14072}, "CVE-2025-64178": {"epss_score": 0.00059, "epss_percentile": 0.1864}, "CVE-2025-64179": {"epss_score": 0.00072, "epss_percentile": 0.22351}, "CVE-2025-64180": {"epss_score": 0.00087, "epss_percentile": 0.25627}, "CVE-2025-64181": {"epss_score": 0.00046, "epss_percentile": 0.14375}, "CVE-2025-64182": {"epss_score": 0.00018, "epss_percentile": 0.03879}, "CVE-2025-64183": {"epss_score": 0.00057, "epss_percentile": 0.18212}, "CVE-2025-64184": {"epss_score": 0.00135, "epss_percentile": 0.33974}, "CVE-2025-64185": {"epss_score": 0.00059, "epss_percentile": 0.1864}, "CVE-2025-64186": {"epss_score": 9e-05, "epss_percentile": 0.00696}, "CVE-2025-64187": {"epss_score": 0.00022, "epss_percentile": 0.05012}, "CVE-2025-64188": {"epss_score": 0.00054, "epss_percentile": 0.17357}, "CVE-2025-64189": {"epss_score": 0.00035, "epss_percentile": 0.10077}, "CVE-2025-64190": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-64191": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-64192": {"epss_score": 0.00038, "epss_percentile": 0.11198}, "CVE-2025-64193": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2025-64194": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-64195": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-64196": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-64197": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-64198": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-64199": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-64200": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-64201": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2025-64202": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-64203": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-64204": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-64205": {"epss_score": 0.00147, "epss_percentile": 0.35709}, "CVE-2025-64206": {"epss_score": 0.00054, "epss_percentile": 0.17186}, "CVE-2025-64207": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-64208": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-64209": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-64210": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-64211": {"epss_score": 0.00042, "epss_percentile": 0.12785}, "CVE-2025-64212": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-64213": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-64214": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-64216": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-64217": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-64218": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-64219": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-64220": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-64221": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-64222": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-64223": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-64224": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-64225": {"epss_score": 0.00031, "epss_percentile": 0.08545}, "CVE-2025-64226": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2025-64227": {"epss_score": 0.00054, "epss_percentile": 0.17186}, "CVE-2025-64228": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-64229": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-64230": {"epss_score": 0.00057, "epss_percentile": 0.18103}, "CVE-2025-64231": {"epss_score": 0.00056, "epss_percentile": 0.17857}, "CVE-2025-64232": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-64233": {"epss_score": 0.00054, "epss_percentile": 0.17186}, "CVE-2025-64234": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-64235": {"epss_score": 0.00048, "epss_percentile": 0.15125}, "CVE-2025-64236": {"epss_score": 0.00088, "epss_percentile": 0.2572}, "CVE-2025-64237": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-64238": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-64239": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-64240": {"epss_score": 0.00016, "epss_percentile": 0.02679}, "CVE-2025-64241": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-64242": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-64243": {"epss_score": 0.00029, "epss_percentile": 0.07732}, "CVE-2025-64244": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-64245": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-64246": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-64247": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-64248": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-64249": {"epss_score": 0.00035, "epss_percentile": 0.0999}, "CVE-2025-64250": {"epss_score": 0.00029, "epss_percentile": 0.07743}, "CVE-2025-64251": {"epss_score": 0.00034, "epss_percentile": 0.09696}, "CVE-2025-64253": {"epss_score": 0.00052, "epss_percentile": 0.1657}, "CVE-2025-64254": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-64255": {"epss_score": 0.00047, "epss_percentile": 0.14879}, "CVE-2025-64256": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-64257": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-64258": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-64259": {"epss_score": 0.00038, "epss_percentile": 0.11308}, "CVE-2025-64260": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-64261": {"epss_score": 0.00038, "epss_percentile": 0.11308}, "CVE-2025-64262": {"epss_score": 0.0002, "epss_percentile": 0.04473}, "CVE-2025-64263": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-64264": {"epss_score": 0.00036, "epss_percentile": 0.10383}, "CVE-2025-64265": {"epss_score": 0.00033, "epss_percentile": 0.09359}, "CVE-2025-64266": {"epss_score": 0.00054, "epss_percentile": 0.17088}, "CVE-2025-64267": {"epss_score": 0.00032, "epss_percentile": 0.09101}, "CVE-2025-64268": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-64269": {"epss_score": 0.00033, "epss_percentile": 0.09359}, "CVE-2025-64270": {"epss_score": 0.00034, "epss_percentile": 0.0971}, "CVE-2025-64271": {"epss_score": 0.0002, "epss_percentile": 0.04473}, "CVE-2025-64272": {"epss_score": 0.00034, "epss_percentile": 0.0971}, "CVE-2025-64273": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-64274": {"epss_score": 0.00033, "epss_percentile": 0.09359}, "CVE-2025-64275": {"epss_score": 0.00042, "epss_percentile": 0.12565}, "CVE-2025-64276": {"epss_score": 0.00036, "epss_percentile": 0.105}, "CVE-2025-64277": {"epss_score": 0.0004, "epss_percentile": 0.1204}, "CVE-2025-64280": {"epss_score": 0.00044, "epss_percentile": 0.13452}, "CVE-2025-64281": {"epss_score": 0.00125, "epss_percentile": 0.32531}, "CVE-2025-64282": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-64283": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-64284": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-64285": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-64286": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2025-64287": {"epss_score": 0.00044, "epss_percentile": 0.13514}, "CVE-2025-64288": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2025-64289": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-64290": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2025-64291": {"epss_score": 0.00048, "epss_percentile": 0.15275}, "CVE-2025-64292": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-64293": {"epss_score": 0.00039, "epss_percentile": 0.11656}, "CVE-2025-64294": {"epss_score": 0.0004, "epss_percentile": 0.1204}, "CVE-2025-64295": {"epss_score": 0.00034, "epss_percentile": 0.0971}, "CVE-2025-64296": {"epss_score": 0.00042, "epss_percentile": 0.12642}, "CVE-2025-64298": {"epss_score": 0.00036, "epss_percentile": 0.10297}, "CVE-2025-64299": {"epss_score": 0.00041, "epss_percentile": 0.12244}, "CVE-2025-64302": {"epss_score": 0.00035, "epss_percentile": 0.09986}, "CVE-2025-64304": {"epss_score": 0.0002, "epss_percentile": 0.04627}, "CVE-2025-64305": {"epss_score": 0.0001, "epss_percentile": 0.00863}, "CVE-2025-64307": {"epss_score": 0.00042, "epss_percentile": 0.12913}, "CVE-2025-64308": {"epss_score": 0.00043, "epss_percentile": 0.13032}, "CVE-2025-64309": {"epss_score": 0.00082, "epss_percentile": 0.24438}, "CVE-2025-64310": {"epss_score": 0.00105, "epss_percentile": 0.29314}, "CVE-2025-64311": {"epss_score": 8e-05, "epss_percentile": 0.00485}, "CVE-2025-64312": {"epss_score": 0.00017, "epss_percentile": 0.03347}, "CVE-2025-64313": {"epss_score": 6e-05, "epss_percentile": 0.00308}, "CVE-2025-64314": {"epss_score": 8e-05, "epss_percentile": 0.00474}, "CVE-2025-64315": {"epss_score": 7e-05, "epss_percentile": 0.00344}, "CVE-2025-64318": {"epss_score": 0.00044, "epss_percentile": 0.13379}, "CVE-2025-64319": {"epss_score": 0.0004, "epss_percentile": 0.1204}, "CVE-2025-64320": {"epss_score": 0.00056, "epss_percentile": 0.17674}, "CVE-2025-64321": {"epss_score": 0.00044, "epss_percentile": 0.13379}, "CVE-2025-64322": {"epss_score": 0.0004, "epss_percentile": 0.1204}, "CVE-2025-64323": {"epss_score": 0.00022, "epss_percentile": 0.04974}, "CVE-2025-64324": {"epss_score": 7e-05, "epss_percentile": 0.00463}, "CVE-2025-64325": {"epss_score": 0.00114, "epss_percentile": 0.30791}, "CVE-2025-64326": {"epss_score": 0.00031, "epss_percentile": 0.08683}, "CVE-2025-64327": {"epss_score": 0.00054, "epss_percentile": 0.17246}, "CVE-2025-64328": {"epss_score": 0.00286, "epss_percentile": 0.51768}, "CVE-2025-64329": {"epss_score": 0.00017, "epss_percentile": 0.03107}, "CVE-2025-64330": {"epss_score": 0.00061, "epss_percentile": 0.19533}, "CVE-2025-64331": {"epss_score": 0.00057, "epss_percentile": 0.18164}, "CVE-2025-64332": {"epss_score": 0.00061, "epss_percentile": 0.19533}, "CVE-2025-64333": {"epss_score": 0.00061, "epss_percentile": 0.19533}, "CVE-2025-64334": {"epss_score": 0.00057, "epss_percentile": 0.18164}, "CVE-2025-64335": {"epss_score": 0.00069, "epss_percentile": 0.21604}, "CVE-2025-64336": {"epss_score": 0.00036, "epss_percentile": 0.10511}, "CVE-2025-64338": {"epss_score": 0.0004, "epss_percentile": 0.11974}, "CVE-2025-64339": {"epss_score": 0.00043, "epss_percentile": 0.13128}, "CVE-2025-64342": {"epss_score": 0.00072, "epss_percentile": 0.22417}, "CVE-2025-64343": {"epss_score": 0.00011, "epss_percentile": 0.0111}, "CVE-2025-64344": {"epss_score": 0.00053, "epss_percentile": 0.16937}, "CVE-2025-64345": {"epss_score": 0.00012, "epss_percentile": 0.01265}, "CVE-2025-64346": {"epss_score": 0.00065, "epss_percentile": 0.20625}, "CVE-2025-64347": {"epss_score": 0.00054, "epss_percentile": 0.17182}, "CVE-2025-64348": {"epss_score": 0.00057, "epss_percentile": 0.17965}, "CVE-2025-64349": {"epss_score": 0.0006, "epss_percentile": 0.19006}, "CVE-2025-64350": {"epss_score": 0.00016, "epss_percentile": 0.02887}, "CVE-2025-64351": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-64352": {"epss_score": 0.00036, "epss_percentile": 0.10517}, "CVE-2025-64353": {"epss_score": 0.00071, "epss_percentile": 0.22114}, "CVE-2025-64354": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-64355": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-64356": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-64357": {"epss_score": 0.0002, "epss_percentile": 0.04641}, "CVE-2025-64358": {"epss_score": 0.00038, "epss_percentile": 0.11388}, "CVE-2025-64359": {"epss_score": 0.00064, "epss_percentile": 0.20212}, "CVE-2025-64360": {"epss_score": 0.00064, "epss_percentile": 0.20212}, "CVE-2025-64361": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-64362": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-64363": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-64364": {"epss_score": 0.0017, "epss_percentile": 0.38761}, "CVE-2025-64365": {"epss_score": 0.00048, "epss_percentile": 0.15196}, "CVE-2025-64366": {"epss_score": 0.00044, "epss_percentile": 0.13582}, "CVE-2025-64367": {"epss_score": 0.00045, "epss_percentile": 0.13885}, "CVE-2025-64368": {"epss_score": 0.00019, "epss_percentile": 0.04128}, "CVE-2025-64369": {"epss_score": 0.00036, "epss_percentile": 0.105}, "CVE-2025-64370": {"epss_score": 0.0004, "epss_percentile": 0.1204}, "CVE-2025-64371": {"epss_score": 0.00029, "epss_percentile": 0.07737}, "CVE-2025-64372": {"epss_score": 0.00035, "epss_percentile": 0.10077}, "CVE-2025-64373": {"epss_score": 0.00046, "epss_percentile": 0.14374}, "CVE-2025-64374": {"epss_score": 0.00047, "epss_percentile": 0.14894}, "CVE-2025-64375": {"epss_score": 0.00035, "epss_percentile": 0.0999}, "CVE-2025-64376": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-64377": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-64378": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-64379": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-64380": {"epss_score": 0.00042, "epss_percentile": 0.12565}, "CVE-2025-64381": {"epss_score": 0.00042, "epss_percentile": 0.12565}, "CVE-2025-64382": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-64383": {"epss_score": 0.00042, "epss_percentile": 0.12565}, "CVE-2025-64384": {"epss_score": 0.00044, "epss_percentile": 0.13394}, "CVE-2025-64385": {"epss_score": 0.00266, "epss_percentile": 0.4989}, "CVE-2025-64386": {"epss_score": 0.00058, "epss_percentile": 0.18398}, "CVE-2025-64387": {"epss_score": 0.00058, "epss_percentile": 0.18398}, "CVE-2025-64388": {"epss_score": 0.00059, "epss_percentile": 0.18903}, "CVE-2025-64389": {"epss_score": 0.00024, "epss_percentile": 0.06022}, "CVE-2025-64400": {"epss_score": 0.0003, "epss_percentile": 0.08305}, "CVE-2025-64401": {"epss_score": 0.00118, "epss_percentile": 0.31532}, "CVE-2025-64402": {"epss_score": 0.00069, "epss_percentile": 0.21608}, "CVE-2025-64403": {"epss_score": 0.0004, "epss_percentile": 0.1201}, "CVE-2025-64404": {"epss_score": 0.00129, "epss_percentile": 0.33111}, "CVE-2025-64405": {"epss_score": 0.00129, "epss_percentile": 0.33111}, "CVE-2025-64406": {"epss_score": 0.00097, "epss_percentile": 0.27619}, "CVE-2025-64407": {"epss_score": 0.00162, "epss_percentile": 0.37713}, "CVE-2025-64408": {"epss_score": 0.00737, "epss_percentile": 0.72329}, "CVE-2025-64419": {"epss_score": 0.00053, "epss_percentile": 0.16953}, "CVE-2025-64420": {"epss_score": 0.00039, "epss_percentile": 0.11622}, "CVE-2025-64421": {"epss_score": 0.00038, "epss_percentile": 0.11425}, "CVE-2025-64422": {"epss_score": 0.00042, "epss_percentile": 0.12802}, "CVE-2025-64423": {"epss_score": 0.00038, "epss_percentile": 0.11425}, "CVE-2025-64424": {"epss_score": 0.00497, "epss_percentile": 0.65204}, "CVE-2025-64425": {"epss_score": 0.00042, "epss_percentile": 0.12802}, "CVE-2025-64428": {"epss_score": 0.00072, "epss_percentile": 0.22397}, "CVE-2025-64429": {"epss_score": 0.0001, "epss_percentile": 0.00896}, "CVE-2025-64430": {"epss_score": 0.00094, "epss_percentile": 0.26798}, "CVE-2025-64431": {"epss_score": 0.00047, "epss_percentile": 0.14661}, "CVE-2025-64432": {"epss_score": 0.00012, "epss_percentile": 0.01272}, "CVE-2025-64433": {"epss_score": 0.00057, "epss_percentile": 0.18108}, "CVE-2025-64434": {"epss_score": 0.00014, "epss_percentile": 0.01832}, "CVE-2025-64435": {"epss_score": 0.00054, "epss_percentile": 0.17152}, "CVE-2025-64436": {"epss_score": 0.00056, "epss_percentile": 0.17688}, "CVE-2025-64437": {"epss_score": 0.00028, "epss_percentile": 0.07266}, "CVE-2025-64439": {"epss_score": 0.0054, "epss_percentile": 0.67012}, "CVE-2025-64442": {"epss_score": 0.00035, "epss_percentile": 0.10049}, "CVE-2025-64443": {"epss_score": 0.0002, "epss_percentile": 0.04433}, "CVE-2025-64444": {"epss_score": 0.01061, "epss_percentile": 0.77171}, "CVE-2025-64446": {"epss_score": 0.88837, "epss_percentile": 0.99493}, "CVE-2025-64447": {"epss_score": 0.00094, "epss_percentile": 0.26991}, "CVE-2025-64456": {"epss_score": 1e-05, "epss_percentile": 4e-05}, "CVE-2025-64457": {"epss_score": 1e-05, "epss_percentile": 3e-05}, "CVE-2025-64458": {"epss_score": 0.00021, "epss_percentile": 0.04724}, "CVE-2025-64459": {"epss_score": 0.00096, "epss_percentile": 0.27278}, "CVE-2025-64460": {"epss_score": 0.00053, "epss_percentile": 0.16963}, "CVE-2025-64461": {"epss_score": 0.0002, "epss_percentile": 0.04643}, "CVE-2025-64462": {"epss_score": 0.00016, "epss_percentile": 0.02918}, "CVE-2025-64463": {"epss_score": 0.00016, "epss_percentile": 0.02918}, "CVE-2025-64464": {"epss_score": 0.00016, "epss_percentile": 0.02918}, "CVE-2025-64465": {"epss_score": 0.00016, "epss_percentile": 0.02918}, "CVE-2025-64466": {"epss_score": 0.00016, "epss_percentile": 0.02918}, "CVE-2025-64467": {"epss_score": 0.00016, "epss_percentile": 0.02918}, "CVE-2025-64468": {"epss_score": 0.00016, "epss_percentile": 0.02918}, "CVE-2025-64469": {"epss_score": 0.00016, "epss_percentile": 0.02918}, "CVE-2025-64471": {"epss_score": 0.00029, "epss_percentile": 0.07768}, "CVE-2025-64481": {"epss_score": 0.00055, "epss_percentile": 0.17619}, "CVE-2025-64482": {"epss_score": 0.00017, "epss_percentile": 0.03516}, "CVE-2025-64483": {"epss_score": 0.00041, "epss_percentile": 0.1222}, "CVE-2025-64484": {"epss_score": 0.00034, "epss_percentile": 0.09553}, "CVE-2025-64485": {"epss_score": 0.0008, "epss_percentile": 0.24114}, "CVE-2025-64486": {"epss_score": 0.00023, "epss_percentile": 0.0564}, "CVE-2025-64488": {"epss_score": 0.0006, "epss_percentile": 0.19007}, "CVE-2025-64489": {"epss_score": 0.0005, "epss_percentile": 0.1586}, "CVE-2025-64490": {"epss_score": 0.00052, "epss_percentile": 0.16373}, "CVE-2025-64491": {"epss_score": 0.00035, "epss_percentile": 0.10162}, "CVE-2025-64492": {"epss_score": 0.00037, "epss_percentile": 0.1079}, "CVE-2025-64493": {"epss_score": 0.00043, "epss_percentile": 0.12964}, "CVE-2025-64494": {"epss_score": 0.00032, "epss_percentile": 0.08854}, "CVE-2025-64495": {"epss_score": 0.0001, "epss_percentile": 0.00821}, "CVE-2025-64496": {"epss_score": 0.00248, "epss_percentile": 0.47995}, "CVE-2025-64497": {"epss_score": 0.00031, "epss_percentile": 0.08377}, "CVE-2025-64498": {"epss_score": 0.00014, "epss_percentile": 0.02104}, "CVE-2025-64499": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-64500": {"epss_score": 0.00018, "epss_percentile": 0.03927}, "CVE-2025-64501": {"epss_score": 0.00038, "epss_percentile": 0.11195}, "CVE-2025-64502": {"epss_score": 0.00086, "epss_percentile": 0.25379}, "CVE-2025-64503": {"epss_score": 0.00019, "epss_percentile": 0.04054}, "CVE-2025-64504": {"epss_score": 0.00096, "epss_percentile": 0.27323}, "CVE-2025-64505": {"epss_score": 0.00019, "epss_percentile": 0.04323}, "CVE-2025-64506": {"epss_score": 0.00019, "epss_percentile": 0.04323}, "CVE-2025-64507": {"epss_score": 0.00025, "epss_percentile": 0.06068}, "CVE-2025-64508": {"epss_score": 0.00092, "epss_percentile": 0.26413}, "CVE-2025-64509": {"epss_score": 0.00057, "epss_percentile": 0.1809}, "CVE-2025-64511": {"epss_score": 0.00051, "epss_percentile": 0.15995}, "CVE-2025-64512": {"epss_score": 0.00035, "epss_percentile": 0.09844}, "CVE-2025-64513": {"epss_score": 0.00125, "epss_percentile": 0.32534}, "CVE-2025-64515": {"epss_score": 0.00056, "epss_percentile": 0.17765}, "CVE-2025-64517": {"epss_score": 0.00025, "epss_percentile": 0.06345}, "CVE-2025-64518": {"epss_score": 0.00075, "epss_percentile": 0.22957}, "CVE-2025-64519": {"epss_score": 0.0003, "epss_percentile": 0.08249}, "CVE-2025-64520": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-64521": {"epss_score": 0.00056, "epss_percentile": 0.17784}, "CVE-2025-64522": {"epss_score": 0.00041, "epss_percentile": 0.12245}, "CVE-2025-64523": {"epss_score": 0.0004, "epss_percentile": 0.12167}, "CVE-2025-64524": {"epss_score": 0.00013, "epss_percentile": 0.01712}, "CVE-2025-64525": {"epss_score": 0.01646, "epss_percentile": 0.81536}, "CVE-2025-64527": {"epss_score": 9e-05, "epss_percentile": 0.00635}, "CVE-2025-64528": {"epss_score": 0.00054, "epss_percentile": 0.17215}, "CVE-2025-64529": {"epss_score": 0.0006, "epss_percentile": 0.19196}, "CVE-2025-64530": {"epss_score": 0.00057, "epss_percentile": 0.18047}, "CVE-2025-64531": {"epss_score": 0.00039, "epss_percentile": 0.11453}, "CVE-2025-64537": {"epss_score": 0.0058, "epss_percentile": 0.68242}, "CVE-2025-64538": {"epss_score": 0.0058, "epss_percentile": 0.68242}, "CVE-2025-64539": {"epss_score": 0.0058, "epss_percentile": 0.68242}, "CVE-2025-64541": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64543": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64544": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64545": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64546": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64547": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64548": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64549": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64550": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64551": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64553": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64554": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64555": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64556": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64557": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64558": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64559": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64560": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64562": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64563": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64564": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64565": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64566": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64569": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64572": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64574": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64575": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64576": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64577": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64578": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64579": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64580": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64581": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64582": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64583": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64585": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64586": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64590": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64591": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64592": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64593": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64594": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64596": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64597": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64598": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64599": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64600": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64601": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64602": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64603": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64604": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64605": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64606": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64607": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64609": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64611": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64612": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64613": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64614": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64615": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64616": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64619": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64620": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64622": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64623": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64626": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64627": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64630": {"epss_score": 0.00041, "epss_percentile": 0.1236}, "CVE-2025-64631": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-64632": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-64633": {"epss_score": 0.00051, "epss_percentile": 0.16158}, "CVE-2025-64634": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-64635": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-64638": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-64639": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-64641": {"epss_score": 0.00027, "epss_percentile": 0.06913}, "CVE-2025-64642": {"epss_score": 0.00016, "epss_percentile": 0.02754}, "CVE-2025-64645": {"epss_score": 0.00013, "epss_percentile": 0.01613}, "CVE-2025-64650": {"epss_score": 0.00032, "epss_percentile": 0.09111}, "CVE-2025-64655": {"epss_score": 0.00075, "epss_percentile": 0.22913}, "CVE-2025-64656": {"epss_score": 0.00107, "epss_percentile": 0.29592}, "CVE-2025-64657": {"epss_score": 0.00107, "epss_percentile": 0.29592}, "CVE-2025-64658": {"epss_score": 0.0004, "epss_percentile": 0.11962}, "CVE-2025-64660": {"epss_score": 0.00065, "epss_percentile": 0.206}, "CVE-2025-64661": {"epss_score": 0.00041, "epss_percentile": 0.12277}, "CVE-2025-64663": {"epss_score": 0.00064, "epss_percentile": 0.20335}, "CVE-2025-64666": {"epss_score": 0.00096, "epss_percentile": 0.27256}, "CVE-2025-64667": {"epss_score": 0.00057, "epss_percentile": 0.18187}, "CVE-2025-64669": {"epss_score": 0.00045, "epss_percentile": 0.13978}, "CVE-2025-64670": {"epss_score": 0.00103, "epss_percentile": 0.28933}, "CVE-2025-64671": {"epss_score": 0.0011, "epss_percentile": 0.30175}, "CVE-2025-64672": {"epss_score": 0.00064, "epss_percentile": 0.20199}, "CVE-2025-64673": {"epss_score": 0.00045, "epss_percentile": 0.13978}, "CVE-2025-64675": {"epss_score": 0.00063, "epss_percentile": 0.2006}, "CVE-2025-64676": {"epss_score": 0.00107, "epss_percentile": 0.29657}, "CVE-2025-64677": {"epss_score": 0.00071, "epss_percentile": 0.2206}, "CVE-2025-64678": {"epss_score": 0.00065, "epss_percentile": 0.20535}, "CVE-2025-64679": {"epss_score": 0.00049, "epss_percentile": 0.15513}, "CVE-2025-64680": {"epss_score": 0.00049, "epss_percentile": 0.15513}, "CVE-2025-64681": {"epss_score": 2e-05, "epss_percentile": 0.00019}, "CVE-2025-64682": {"epss_score": 1e-05, "epss_percentile": 0.00018}, "CVE-2025-64683": {"epss_score": 2e-05, "epss_percentile": 0.00051}, "CVE-2025-64684": {"epss_score": 3e-05, "epss_percentile": 0.00075}, "CVE-2025-64685": {"epss_score": 2e-05, "epss_percentile": 0.00028}, "CVE-2025-64693": {"epss_score": 0.00326, "epss_percentile": 0.5509}, "CVE-2025-64695": {"epss_score": 0.00016, "epss_percentile": 0.02808}, "CVE-2025-64696": {"epss_score": 0.00014, "epss_percentile": 0.01897}, "CVE-2025-64699": {"epss_score": 0.00013, "epss_percentile": 0.01687}, "CVE-2025-64700": {"epss_score": 0.00017, "epss_percentile": 0.03249}, "CVE-2025-64701": {"epss_score": 0.00014, "epss_percentile": 0.02121}, "CVE-2025-64702": {"epss_score": 0.00051, "epss_percentile": 0.16192}, "CVE-2025-64703": {"epss_score": 0.0004, "epss_percentile": 0.11905}, "CVE-2025-64704": {"epss_score": 0.0002, "epss_percentile": 0.04524}, "CVE-2025-64705": {"epss_score": 0.00037, "epss_percentile": 0.10836}, "CVE-2025-64706": {"epss_score": 0.00044, "epss_percentile": 0.13394}, "CVE-2025-64707": {"epss_score": 0.00031, "epss_percentile": 0.08649}, "CVE-2025-64708": {"epss_score": 0.00046, "epss_percentile": 0.14428}, "CVE-2025-64709": {"epss_score": 0.00036, "epss_percentile": 0.10301}, "CVE-2025-64710": {"epss_score": 0.00067, "epss_percentile": 0.2117}, "CVE-2025-64711": {"epss_score": 0.00018, "epss_percentile": 0.03807}, "CVE-2025-64713": {"epss_score": 0.00024, "epss_percentile": 0.059}, "CVE-2025-64714": {"epss_score": 0.00198, "epss_percentile": 0.42018}, "CVE-2025-64715": {"epss_score": 0.00016, "epss_percentile": 0.02966}, "CVE-2025-64716": {"epss_score": 0.00105, "epss_percentile": 0.29376}, "CVE-2025-64717": {"epss_score": 0.00451, "epss_percentile": 0.6315}, "CVE-2025-64718": {"epss_score": 0.00019, "epss_percentile": 0.0411}, "CVE-2025-64720": {"epss_score": 0.00074, "epss_percentile": 0.22748}, "CVE-2025-64721": {"epss_score": 0.00069, "epss_percentile": 0.21459}, "CVE-2025-64723": {"epss_score": 0.00011, "epss_percentile": 0.00979}, "CVE-2025-64724": {"epss_score": 0.00011, "epss_percentile": 0.00979}, "CVE-2025-64725": {"epss_score": 0.0001, "epss_percentile": 0.00859}, "CVE-2025-64726": {"epss_score": 0.00019, "epss_percentile": 0.04271}, "CVE-2025-64730": {"epss_score": 0.0003, "epss_percentile": 0.08257}, "CVE-2025-64734": {"epss_score": 0.00024, "epss_percentile": 0.05974}, "CVE-2025-64738": {"epss_score": 0.00015, "epss_percentile": 0.02128}, "CVE-2025-64739": {"epss_score": 0.00045, "epss_percentile": 0.13894}, "CVE-2025-64740": {"epss_score": 7e-05, "epss_percentile": 0.00336}, "CVE-2025-64741": {"epss_score": 0.00121, "epss_percentile": 0.31944}, "CVE-2025-64744": {"epss_score": 0.00035, "epss_percentile": 0.10136}, "CVE-2025-64745": {"epss_score": 0.00039, "epss_percentile": 0.11796}, "CVE-2025-64746": {"epss_score": 0.00034, "epss_percentile": 0.09462}, "CVE-2025-64747": {"epss_score": 0.00069, "epss_percentile": 0.2155}, "CVE-2025-64748": {"epss_score": 0.00034, "epss_percentile": 0.09649}, "CVE-2025-64749": {"epss_score": 0.00037, "epss_percentile": 0.10836}, "CVE-2025-64750": {"epss_score": 0.00014, "epss_percentile": 0.02058}, "CVE-2025-64751": {"epss_score": 0.00053, "epss_percentile": 0.16878}, "CVE-2025-64752": {"epss_score": 0.00043, "epss_percentile": 0.12971}, "CVE-2025-64753": {"epss_score": 0.00038, "epss_percentile": 0.11344}, "CVE-2025-64754": {"epss_score": 0.00134, "epss_percentile": 0.33871}, "CVE-2025-64755": {"epss_score": 0.00091, "epss_percentile": 0.26405}, "CVE-2025-64756": {"epss_score": 0.00044, "epss_percentile": 0.13616}, "CVE-2025-64757": {"epss_score": 0.00026, "epss_percentile": 0.06722}, "CVE-2025-64758": {"epss_score": 0.00033, "epss_percentile": 0.09302}, "CVE-2025-64759": {"epss_score": 0.00064, "epss_percentile": 0.20145}, "CVE-2025-64760": {"epss_score": 0.00014, "epss_percentile": 0.02104}, "CVE-2025-64761": {"epss_score": 0.00038, "epss_percentile": 0.11132}, "CVE-2025-64762": {"epss_score": 0.00091, "epss_percentile": 0.26208}, "CVE-2025-64763": {"epss_score": 0.0001, "epss_percentile": 0.00818}, "CVE-2025-64764": {"epss_score": 0.00473, "epss_percentile": 0.64101}, "CVE-2025-64765": {"epss_score": 0.00024, "epss_percentile": 0.0597}, "CVE-2025-64766": {"epss_score": 0.00045, "epss_percentile": 0.14067}, "CVE-2025-64767": {"epss_score": 0.00024, "epss_percentile": 0.05797}, "CVE-2025-64770": {"epss_score": 0.00033, "epss_percentile": 0.09286}, "CVE-2025-64772": {"epss_score": 0.00016, "epss_percentile": 0.02808}, "CVE-2025-64773": {"epss_score": 1e-05, "epss_percentile": 0.00018}, "CVE-2025-64775": {"epss_score": 0.00137, "epss_percentile": 0.34225}, "CVE-2025-64778": {"epss_score": 0.00018, "epss_percentile": 0.03923}, "CVE-2025-64781": {"epss_score": 0.00034, "epss_percentile": 0.09573}, "CVE-2025-64783": {"epss_score": 0.00027, "epss_percentile": 0.0684}, "CVE-2025-64784": {"epss_score": 0.00024, "epss_percentile": 0.05772}, "CVE-2025-64785": {"epss_score": 0.00027, "epss_percentile": 0.0684}, "CVE-2025-64786": {"epss_score": 0.00017, "epss_percentile": 0.03326}, "CVE-2025-64787": {"epss_score": 0.00017, "epss_percentile": 0.03326}, "CVE-2025-64789": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64790": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64791": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64792": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64793": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64794": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64796": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64797": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64799": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64800": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64801": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64802": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64803": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64804": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64808": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64814": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64817": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64820": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64821": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64822": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64823": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64825": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64826": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64827": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64829": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64833": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64839": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64840": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64841": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64845": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64847": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64850": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64852": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64853": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64857": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64858": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64861": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64863": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64869": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64872": {"epss_score": 0.00072, "epss_percentile": 0.22247}, "CVE-2025-64873": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64875": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64881": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64887": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64888": {"epss_score": 0.00031, "epss_percentile": 0.08376}, "CVE-2025-64893": {"epss_score": 0.00024, "epss_percentile": 0.05772}, "CVE-2025-64894": {"epss_score": 0.00019, "epss_percentile": 0.04347}, "CVE-2025-64896": {"epss_score": 0.0002, "epss_percentile": 0.0451}, "CVE-2025-64897": {"epss_score": 0.00021, "epss_percentile": 0.04937}, "CVE-2025-64898": {"epss_score": 0.00052, "epss_percentile": 0.16605}, "CVE-2025-64899": {"epss_score": 0.00027, "epss_percentile": 0.0684}, "CVE-2025-64983": {"epss_score": 0.00046, "epss_percentile": 0.14177}, "CVE-2025-64984": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-64986": {"epss_score": 0.00371, "epss_percentile": 0.58416}, "CVE-2025-64987": {"epss_score": 0.00371, "epss_percentile": 0.58416}, "CVE-2025-64988": {"epss_score": 0.00371, "epss_percentile": 0.58416}, "CVE-2025-64989": {"epss_score": 0.00371, "epss_percentile": 0.58416}, "CVE-2025-64990": {"epss_score": 0.00162, "epss_percentile": 0.3765}, "CVE-2025-64991": {"epss_score": 0.00162, "epss_percentile": 0.3765}, "CVE-2025-64992": {"epss_score": 0.00162, "epss_percentile": 0.3765}, "CVE-2025-64993": {"epss_score": 0.00162, "epss_percentile": 0.3765}, "CVE-2025-64994": {"epss_score": 0.00014, "epss_percentile": 0.02041}, "CVE-2025-64995": {"epss_score": 0.00015, "epss_percentile": 0.02291}, "CVE-2025-64996": {"epss_score": 0.00017, "epss_percentile": 0.03103}, "CVE-2025-64997": {"epss_score": 0.00033, "epss_percentile": 0.0936}, "CVE-2025-65000": {"epss_score": 0.00032, "epss_percentile": 0.09007}, "CVE-2025-65001": {"epss_score": 0.00017, "epss_percentile": 0.03313}, "CVE-2025-65002": {"epss_score": 0.0005, "epss_percentile": 0.15884}, "CVE-2025-65007": {"epss_score": 0.00068, "epss_percentile": 0.21408}, "CVE-2025-65008": {"epss_score": 0.00033, "epss_percentile": 0.09431}, "CVE-2025-65009": {"epss_score": 0.00021, "epss_percentile": 0.0489}, "CVE-2025-65010": {"epss_score": 0.00021, "epss_percentile": 0.0489}, "CVE-2025-65011": {"epss_score": 0.00021, "epss_percentile": 0.0489}, "CVE-2025-65012": {"epss_score": 0.00035, "epss_percentile": 0.09973}, "CVE-2025-65013": {"epss_score": 2e-05, "epss_percentile": 0.00053}, "CVE-2025-65014": {"epss_score": 2e-05, "epss_percentile": 0.00021}, "CVE-2025-65015": {"epss_score": 0.00037, "epss_percentile": 0.10803}, "CVE-2025-65018": {"epss_score": 0.0004, "epss_percentile": 0.12175}, "CVE-2025-65019": {"epss_score": 0.00044, "epss_percentile": 0.13482}, "CVE-2025-65020": {"epss_score": 0.00052, "epss_percentile": 0.16365}, "CVE-2025-65021": {"epss_score": 0.00075, "epss_percentile": 0.23008}, "CVE-2025-65022": {"epss_score": 0.0004, "epss_percentile": 0.12065}, "CVE-2025-65023": {"epss_score": 0.00041, "epss_percentile": 0.123}, "CVE-2025-65024": {"epss_score": 0.00041, "epss_percentile": 0.123}, "CVE-2025-65025": {"epss_score": 0.00035, "epss_percentile": 0.09974}, "CVE-2025-65026": {"epss_score": 0.00018, "epss_percentile": 0.03831}, "CVE-2025-65027": {"epss_score": 0.00018, "epss_percentile": 0.03764}, "CVE-2025-65028": {"epss_score": 0.00029, "epss_percentile": 0.07899}, "CVE-2025-65029": {"epss_score": 0.0005, "epss_percentile": 0.15669}, "CVE-2025-65030": {"epss_score": 0.00048, "epss_percentile": 0.15202}, "CVE-2025-65031": {"epss_score": 0.00034, "epss_percentile": 0.09597}, "CVE-2025-65032": {"epss_score": 0.00036, "epss_percentile": 0.10294}, "CVE-2025-65033": {"epss_score": 0.0005, "epss_percentile": 0.15669}, "CVE-2025-65034": {"epss_score": 0.0005, "epss_percentile": 0.15669}, "CVE-2025-65035": {"epss_score": 0.00047, "epss_percentile": 0.1448}, "CVE-2025-65036": {"epss_score": 0.00203, "epss_percentile": 0.42497}, "CVE-2025-65037": {"epss_score": 0.00097, "epss_percentile": 0.2756}, "CVE-2025-65041": {"epss_score": 0.00093, "epss_percentile": 0.2674}, "CVE-2025-65046": {"epss_score": 0.00043, "epss_percentile": 0.13186}, "CVE-2025-65073": {"epss_score": 0.00038, "epss_percentile": 0.11308}, "CVE-2025-65074": {"epss_score": 0.0006, "epss_percentile": 0.1898}, "CVE-2025-65075": {"epss_score": 0.00043, "epss_percentile": 0.13016}, "CVE-2025-65076": {"epss_score": 0.00039, "epss_percentile": 0.11447}, "CVE-2025-65082": {"epss_score": 0.00162, "epss_percentile": 0.37739}, "CVE-2025-65083": {"epss_score": 0.0001, "epss_percentile": 0.00885}, "CVE-2025-65084": {"epss_score": 0.00125, "epss_percentile": 0.32566}, "CVE-2025-65085": {"epss_score": 0.00081, "epss_percentile": 0.24224}, "CVE-2025-65089": {"epss_score": 0.00012, "epss_percentile": 0.01317}, "CVE-2025-65092": {"epss_score": 0.00075, "epss_percentile": 0.22894}, "CVE-2025-65093": {"epss_score": 2e-05, "epss_percentile": 0.00036}, "CVE-2025-65094": {"epss_score": 0.00053, "epss_percentile": 0.16878}, "CVE-2025-65095": {"epss_score": 0.00068, "epss_percentile": 0.21248}, "CVE-2025-65096": {"epss_score": 0.0005, "epss_percentile": 0.15677}, "CVE-2025-65097": {"epss_score": 0.0005, "epss_percentile": 0.15677}, "CVE-2025-65099": {"epss_score": 0.00113, "epss_percentile": 0.30669}, "CVE-2025-65100": {"epss_score": 0.00075, "epss_percentile": 0.2301}, "CVE-2025-65102": {"epss_score": 0.0006, "epss_percentile": 0.19205}, "CVE-2025-65103": {"epss_score": 0.00014, "epss_percentile": 0.02085}, "CVE-2025-65105": {"epss_score": 0.00022, "epss_percentile": 0.0498}, "CVE-2025-65106": {"epss_score": 0.00064, "epss_percentile": 0.20171}, "CVE-2025-65107": {"epss_score": 0.0002, "epss_percentile": 0.04613}, "CVE-2025-65108": {"epss_score": 0.00412, "epss_percentile": 0.60926}, "CVE-2025-65109": {"epss_score": 0.00054, "epss_percentile": 0.17168}, "CVE-2025-65110": {"epss_score": 0.00066, "epss_percentile": 0.20682}, "CVE-2025-65111": {"epss_score": 0.00043, "epss_percentile": 0.13323}, "CVE-2025-65112": {"epss_score": 0.00105, "epss_percentile": 0.29362}, "CVE-2025-65113": {"epss_score": 0.00077, "epss_percentile": 0.23453}, "CVE-2025-65120": {"epss_score": 0.00034, "epss_percentile": 0.09667}, "CVE-2025-65125": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-65176": {"epss_score": 0.00039, "epss_percentile": 0.1172}, "CVE-2025-65185": {"epss_score": 0.00012, "epss_percentile": 0.01272}, "CVE-2025-65186": {"epss_score": 0.00032, "epss_percentile": 0.09078}, "CVE-2025-65187": {"epss_score": 0.00032, "epss_percentile": 0.09078}, "CVE-2025-65199": {"epss_score": 0.00054, "epss_percentile": 0.172}, "CVE-2025-65202": {"epss_score": 0.00428, "epss_percentile": 0.61951}, "CVE-2025-65203": {"epss_score": 0.00016, "epss_percentile": 0.0264}, "CVE-2025-65212": {"epss_score": 0.00043, "epss_percentile": 0.13015}, "CVE-2025-65213": {"epss_score": 0.00374, "epss_percentile": 0.58548}, "CVE-2025-65215": {"epss_score": 0.00032, "epss_percentile": 0.09078}, "CVE-2025-65220": {"epss_score": 0.00032, "epss_percentile": 0.09023}, "CVE-2025-65221": {"epss_score": 0.00032, "epss_percentile": 0.09023}, "CVE-2025-65222": {"epss_score": 0.00033, "epss_percentile": 0.09137}, "CVE-2025-65223": {"epss_score": 0.00032, "epss_percentile": 0.09023}, "CVE-2025-65226": {"epss_score": 0.00032, "epss_percentile": 0.09023}, "CVE-2025-65228": {"epss_score": 0.00027, "epss_percentile": 0.07002}, "CVE-2025-65229": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-65230": {"epss_score": 0.00034, "epss_percentile": 0.09683}, "CVE-2025-65231": {"epss_score": 0.0003, "epss_percentile": 0.08079}, "CVE-2025-65233": {"epss_score": 0.00036, "epss_percentile": 0.10411}, "CVE-2025-65235": {"epss_score": 0.00045, "epss_percentile": 0.13733}, "CVE-2025-65236": {"epss_score": 0.00045, "epss_percentile": 0.13733}, "CVE-2025-65237": {"epss_score": 0.00044, "epss_percentile": 0.13373}, "CVE-2025-65238": {"epss_score": 0.00034, "epss_percentile": 0.09741}, "CVE-2025-65239": {"epss_score": 0.00032, "epss_percentile": 0.08961}, "CVE-2025-65267": {"epss_score": 0.00061, "epss_percentile": 0.19433}, "CVE-2025-65270": {"epss_score": 0.00054, "epss_percentile": 0.17255}, "CVE-2025-65271": {"epss_score": 0.00059, "epss_percentile": 0.1875}, "CVE-2025-65276": {"epss_score": 0.00073, "epss_percentile": 0.22491}, "CVE-2025-65278": {"epss_score": 0.0003, "epss_percentile": 0.08299}, "CVE-2025-65287": {"epss_score": 0.00152, "epss_percentile": 0.36396}, "CVE-2025-65288": {"epss_score": 0.00057, "epss_percentile": 0.18042}, "CVE-2025-65289": {"epss_score": 0.00049, "epss_percentile": 0.15484}, "CVE-2025-65290": {"epss_score": 0.00018, "epss_percentile": 0.03864}, "CVE-2025-65291": {"epss_score": 0.00019, "epss_percentile": 0.04284}, "CVE-2025-65292": {"epss_score": 0.00047, "epss_percentile": 0.14574}, "CVE-2025-65293": {"epss_score": 0.00065, "epss_percentile": 0.20525}, "CVE-2025-65294": {"epss_score": 0.00654, "epss_percentile": 0.70341}, "CVE-2025-65295": {"epss_score": 0.00022, "epss_percentile": 0.05267}, "CVE-2025-65296": {"epss_score": 0.00024, "epss_percentile": 0.05747}, "CVE-2025-65297": {"epss_score": 0.00017, "epss_percentile": 0.03321}, "CVE-2025-65300": {"epss_score": 0.00033, "epss_percentile": 0.09393}, "CVE-2025-65318": {"epss_score": 0.0007, "epss_percentile": 0.21808}, "CVE-2025-65319": {"epss_score": 0.0007, "epss_percentile": 0.21808}, "CVE-2025-65320": {"epss_score": 0.00018, "epss_percentile": 0.03604}, "CVE-2025-65328": {"epss_score": 0.00048, "epss_percentile": 0.15236}, "CVE-2025-65345": {"epss_score": 0.00031, "epss_percentile": 0.0834}, "CVE-2025-65346": {"epss_score": 0.00139, "epss_percentile": 0.34567}, "CVE-2025-65354": {"epss_score": 0.00038, "epss_percentile": 0.11236}, "CVE-2025-65358": {"epss_score": 0.00041, "epss_percentile": 0.12443}, "CVE-2025-65363": {"epss_score": 0.00075, "epss_percentile": 0.22898}, "CVE-2025-65379": {"epss_score": 0.00033, "epss_percentile": 0.09332}, "CVE-2025-65380": {"epss_score": 0.00033, "epss_percentile": 0.09332}, "CVE-2025-65403": {"epss_score": 0.00051, "epss_percentile": 0.16031}, "CVE-2025-65404": {"epss_score": 0.00051, "epss_percentile": 0.16031}, "CVE-2025-65405": {"epss_score": 0.00051, "epss_percentile": 0.16031}, "CVE-2025-65406": {"epss_score": 0.00051, "epss_percentile": 0.16031}, "CVE-2025-65407": {"epss_score": 0.00051, "epss_percentile": 0.16031}, "CVE-2025-65408": {"epss_score": 0.00051, "epss_percentile": 0.16109}, "CVE-2025-65409": {"epss_score": 0.00041, "epss_percentile": 0.12439}, "CVE-2025-65410": {"epss_score": 0.00015, "epss_percentile": 0.02431}, "CVE-2025-65411": {"epss_score": 0.00058, "epss_percentile": 0.18578}, "CVE-2025-65427": {"epss_score": 0.00033, "epss_percentile": 0.09198}, "CVE-2025-65430": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-65431": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-65442": {"epss_score": 0.0003, "epss_percentile": 0.08016}, "CVE-2025-65471": {"epss_score": 0.00076, "epss_percentile": 0.23157}, "CVE-2025-65472": {"epss_score": 0.00019, "epss_percentile": 0.04083}, "CVE-2025-65473": {"epss_score": 0.00078, "epss_percentile": 0.23634}, "CVE-2025-65474": {"epss_score": 0.00076, "epss_percentile": 0.23157}, "CVE-2025-65493": {"epss_score": 0.00141, "epss_percentile": 0.34923}, "CVE-2025-65494": {"epss_score": 0.00093, "epss_percentile": 0.2675}, "CVE-2025-65495": {"epss_score": 0.00095, "epss_percentile": 0.27089}, "CVE-2025-65496": {"epss_score": 0.00129, "epss_percentile": 0.33217}, "CVE-2025-65497": {"epss_score": 0.00129, "epss_percentile": 0.33217}, "CVE-2025-65498": {"epss_score": 0.00129, "epss_percentile": 0.33217}, "CVE-2025-65499": {"epss_score": 0.00129, "epss_percentile": 0.33148}, "CVE-2025-65500": {"epss_score": 0.00129, "epss_percentile": 0.33217}, "CVE-2025-65501": {"epss_score": 0.00129, "epss_percentile": 0.33217}, "CVE-2025-65502": {"epss_score": 0.00169, "epss_percentile": 0.38571}, "CVE-2025-65503": {"epss_score": 0.00035, "epss_percentile": 0.09999}, "CVE-2025-65512": {"epss_score": 0.00039, "epss_percentile": 0.11716}, "CVE-2025-65513": {"epss_score": 0.00028, "epss_percentile": 0.07567}, "CVE-2025-65516": {"epss_score": 0.00043, "epss_percentile": 0.13021}, "CVE-2025-65530": {"epss_score": 0.00042, "epss_percentile": 0.12895}, "CVE-2025-65540": {"epss_score": 0.0003, "epss_percentile": 0.08216}, "CVE-2025-65548": {"epss_score": 0.00062, "epss_percentile": 0.19775}, "CVE-2025-65559": {"epss_score": 0.00048, "epss_percentile": 0.15287}, "CVE-2025-65561": {"epss_score": 0.00046, "epss_percentile": 0.14161}, "CVE-2025-65562": {"epss_score": 0.00331, "epss_percentile": 0.55509}, "CVE-2025-65563": {"epss_score": 0.00054, "epss_percentile": 0.17111}, "CVE-2025-65564": {"epss_score": 0.00054, "epss_percentile": 0.17111}, "CVE-2025-65565": {"epss_score": 0.00054, "epss_percentile": 0.17111}, "CVE-2025-65566": {"epss_score": 0.00054, "epss_percentile": 0.17111}, "CVE-2025-65567": {"epss_score": 0.00046, "epss_percentile": 0.14321}, "CVE-2025-65568": {"epss_score": 0.00041, "epss_percentile": 0.12462}, "CVE-2025-65570": {"epss_score": 0.00086, "epss_percentile": 0.25405}, "CVE-2025-65572": {"epss_score": 0.00073, "epss_percentile": 0.22625}, "CVE-2025-65573": {"epss_score": 0.00113, "epss_percentile": 0.30694}, "CVE-2025-65581": {"epss_score": 0.00052, "epss_percentile": 0.16624}, "CVE-2025-65589": {"epss_score": 0.00031, "epss_percentile": 0.08621}, "CVE-2025-65590": {"epss_score": 0.00029, "epss_percentile": 0.07783}, "CVE-2025-65591": {"epss_score": 0.00029, "epss_percentile": 0.07783}, "CVE-2025-65592": {"epss_score": 0.00031, "epss_percentile": 0.08621}, "CVE-2025-65593": {"epss_score": 0.0002, "epss_percentile": 0.04582}, "CVE-2025-65594": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-65602": {"epss_score": 0.00089, "epss_percentile": 0.25985}, "CVE-2025-65621": {"epss_score": 0.00031, "epss_percentile": 0.0857}, "CVE-2025-65622": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-65637": {"epss_score": 0.00023, "epss_percentile": 0.05426}, "CVE-2025-65647": {"epss_score": 0.00034, "epss_percentile": 0.0967}, "CVE-2025-65656": {"epss_score": 0.00061, "epss_percentile": 0.1939}, "CVE-2025-65657": {"epss_score": 0.00104, "epss_percentile": 0.29178}, "CVE-2025-65669": {"epss_score": 0.00293, "epss_percentile": 0.52293}, "CVE-2025-65670": {"epss_score": 0.00033, "epss_percentile": 0.09332}, "CVE-2025-65672": {"epss_score": 0.00057, "epss_percentile": 0.18045}, "CVE-2025-65675": {"epss_score": 0.00051, "epss_percentile": 0.16232}, "CVE-2025-65676": {"epss_score": 0.00051, "epss_percentile": 0.16232}, "CVE-2025-65681": {"epss_score": 6e-05, "epss_percentile": 0.00294}, "CVE-2025-65713": {"epss_score": 0.00025, "epss_percentile": 0.06065}, "CVE-2025-65730": {"epss_score": 0.00437, "epss_percentile": 0.62534}, "CVE-2025-65741": {"epss_score": 0.00069, "epss_percentile": 0.21588}, "CVE-2025-65742": {"epss_score": 0.00037, "epss_percentile": 0.10886}, "CVE-2025-65754": {"epss_score": 0.00011, "epss_percentile": 0.0101}, "CVE-2025-65778": {"epss_score": 0.00042, "epss_percentile": 0.12627}, "CVE-2025-65779": {"epss_score": 0.00052, "epss_percentile": 0.16405}, "CVE-2025-65780": {"epss_score": 0.00047, "epss_percentile": 0.14792}, "CVE-2025-65781": {"epss_score": 0.00056, "epss_percentile": 0.17786}, "CVE-2025-65782": {"epss_score": 0.00031, "epss_percentile": 0.08636}, "CVE-2025-65790": {"epss_score": 0.00036, "epss_percentile": 0.10617}, "CVE-2025-65792": {"epss_score": 0.00092, "epss_percentile": 0.26571}, "CVE-2025-65795": {"epss_score": 0.00031, "epss_percentile": 0.08333}, "CVE-2025-65796": {"epss_score": 0.00028, "epss_percentile": 0.07231}, "CVE-2025-65797": {"epss_score": 0.00039, "epss_percentile": 0.11755}, "CVE-2025-65798": {"epss_score": 0.00028, "epss_percentile": 0.07228}, "CVE-2025-65799": {"epss_score": 0.0003, "epss_percentile": 0.08161}, "CVE-2025-65803": {"epss_score": 0.00043, "epss_percentile": 0.13281}, "CVE-2025-65804": {"epss_score": 0.0007, "epss_percentile": 0.21659}, "CVE-2025-65805": {"epss_score": 0.00096, "epss_percentile": 0.27451}, "CVE-2025-65806": {"epss_score": 0.00158, "epss_percentile": 0.3718}, "CVE-2025-65807": {"epss_score": 0.00014, "epss_percentile": 0.02041}, "CVE-2025-65814": {"epss_score": 0.0011, "epss_percentile": 0.3017}, "CVE-2025-65815": {"epss_score": 0.00073, "epss_percentile": 0.22586}, "CVE-2025-65817": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-65820": {"epss_score": 0.00056, "epss_percentile": 0.17857}, "CVE-2025-65821": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-65822": {"epss_score": 0.00028, "epss_percentile": 0.07494}, "CVE-2025-65823": {"epss_score": 0.00065, "epss_percentile": 0.20538}, "CVE-2025-65824": {"epss_score": 0.00078, "epss_percentile": 0.23794}, "CVE-2025-65825": {"epss_score": 0.0001, "epss_percentile": 0.00883}, "CVE-2025-65826": {"epss_score": 0.00028, "epss_percentile": 0.07482}, "CVE-2025-65827": {"epss_score": 0.00033, "epss_percentile": 0.0917}, "CVE-2025-65828": {"epss_score": 0.00071, "epss_percentile": 0.22224}, "CVE-2025-65829": {"epss_score": 0.0004, "epss_percentile": 0.11971}, "CVE-2025-65830": {"epss_score": 0.00041, "epss_percentile": 0.12233}, "CVE-2025-65831": {"epss_score": 0.00019, "epss_percentile": 0.04229}, "CVE-2025-65832": {"epss_score": 0.00016, "epss_percentile": 0.03022}, "CVE-2025-65834": {"epss_score": 0.00056, "epss_percentile": 0.17857}, "CVE-2025-65835": {"epss_score": 0.00015, "epss_percentile": 0.02394}, "CVE-2025-65836": {"epss_score": 0.00036, "epss_percentile": 0.10228}, "CVE-2025-65837": {"epss_score": 0.00027, "epss_percentile": 0.07094}, "CVE-2025-65838": {"epss_score": 0.00052, "epss_percentile": 0.16359}, "CVE-2025-65840": {"epss_score": 0.00019, "epss_percentile": 0.0418}, "CVE-2025-65841": {"epss_score": 0.00051, "epss_percentile": 0.16189}, "CVE-2025-65842": {"epss_score": 0.00016, "epss_percentile": 0.02615}, "CVE-2025-65843": {"epss_score": 0.00024, "epss_percentile": 0.05993}, "CVE-2025-65844": {"epss_score": 0.00051, "epss_percentile": 0.1627}, "CVE-2025-65849": {"epss_score": 0.00016, "epss_percentile": 0.02743}, "CVE-2025-65854": {"epss_score": 0.00091, "epss_percentile": 0.2621}, "CVE-2025-65855": {"epss_score": 4e-05, "epss_percentile": 0.00163}, "CVE-2025-65856": {"epss_score": 0.01856, "epss_percentile": 0.8257}, "CVE-2025-65857": {"epss_score": 0.00038, "epss_percentile": 0.11321}, "CVE-2025-65858": {"epss_score": 0.0003, "epss_percentile": 0.08056}, "CVE-2025-65865": {"epss_score": 0.00051, "epss_percentile": 0.16308}, "CVE-2025-65868": {"epss_score": 0.00137, "epss_percentile": 0.34254}, "CVE-2025-65877": {"epss_score": 0.00033, "epss_percentile": 0.09175}, "CVE-2025-65878": {"epss_score": 0.00374, "epss_percentile": 0.58532}, "CVE-2025-65879": {"epss_score": 0.00411, "epss_percentile": 0.60902}, "CVE-2025-65881": {"epss_score": 0.00038, "epss_percentile": 0.11124}, "CVE-2025-65882": {"epss_score": 0.00125, "epss_percentile": 0.32507}, "CVE-2025-65883": {"epss_score": 0.00066, "epss_percentile": 0.20881}, "CVE-2025-65885": {"epss_score": 0.00024, "epss_percentile": 0.05794}, "CVE-2025-65892": {"epss_score": 0.00033, "epss_percentile": 0.09169}, "CVE-2025-65896": {"epss_score": 0.00041, "epss_percentile": 0.12267}, "CVE-2025-65897": {"epss_score": 0.00298, "epss_percentile": 0.52774}, "CVE-2025-65899": {"epss_score": 0.00088, "epss_percentile": 0.25665}, "CVE-2025-65900": {"epss_score": 0.0003, "epss_percentile": 0.08059}, "CVE-2025-65922": {"epss_score": 0.00027, "epss_percentile": 0.06789}, "CVE-2025-65925": {"epss_score": 0.00059, "epss_percentile": 0.1882}, "CVE-2025-65942": {"epss_score": 0.00055, "epss_percentile": 0.17474}, "CVE-2025-65944": {"epss_score": 0.00056, "epss_percentile": 0.17675}, "CVE-2025-65945": {"epss_score": 9e-05, "epss_percentile": 0.00687}, "CVE-2025-65946": {"epss_score": 0.00195, "epss_percentile": 0.41669}, "CVE-2025-65947": {"epss_score": 0.00057, "epss_percentile": 0.18137}, "CVE-2025-65950": {"epss_score": 0.00042, "epss_percentile": 0.12917}, "CVE-2025-65951": {"epss_score": 0.0001, "epss_percentile": 0.00815}, "CVE-2025-65952": {"epss_score": 0.00063, "epss_percentile": 0.19852}, "CVE-2025-65953": {"epss_score": 0.00054, "epss_percentile": 0.17168}, "CVE-2025-65955": {"epss_score": 0.00017, "epss_percentile": 0.03309}, "CVE-2025-65956": {"epss_score": 0.00031, "epss_percentile": 0.08611}, "CVE-2025-65957": {"epss_score": 0.00054, "epss_percentile": 0.17168}, "CVE-2025-65958": {"epss_score": 0.00064, "epss_percentile": 0.20429}, "CVE-2025-65959": {"epss_score": 0.00037, "epss_percentile": 0.10992}, "CVE-2025-65960": {"epss_score": 0.00023, "epss_percentile": 0.05507}, "CVE-2025-65961": {"epss_score": 0.00028, "epss_percentile": 0.07533}, "CVE-2025-65962": {"epss_score": 0.00014, "epss_percentile": 0.02104}, "CVE-2025-65963": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-65964": {"epss_score": 0.00019, "epss_percentile": 0.04142}, "CVE-2025-65965": {"epss_score": 0.00018, "epss_percentile": 0.04049}, "CVE-2025-65966": {"epss_score": 0.00052, "epss_percentile": 0.16589}, "CVE-2025-65998": {"epss_score": 0.00074, "epss_percentile": 0.22865}, "CVE-2025-66001": {"epss_score": 0.00049, "epss_percentile": 0.15478}, "CVE-2025-66004": {"epss_score": 0.00029, "epss_percentile": 0.07943}, "CVE-2025-66016": {"epss_score": 0.00027, "epss_percentile": 0.06946}, "CVE-2025-66017": {"epss_score": 0.00025, "epss_percentile": 0.06344}, "CVE-2025-66019": {"epss_score": 0.00066, "epss_percentile": 0.20677}, "CVE-2025-66020": {"epss_score": 0.00057, "epss_percentile": 0.1809}, "CVE-2025-66021": {"epss_score": 0.00015, "epss_percentile": 0.02272}, "CVE-2025-66022": {"epss_score": 0.00522, "epss_percentile": 0.66274}, "CVE-2025-66023": {"epss_score": 0.00048, "epss_percentile": 0.15012}, "CVE-2025-66025": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-66026": {"epss_score": 0.00056, "epss_percentile": 0.17774}, "CVE-2025-66027": {"epss_score": 0.00036, "epss_percentile": 0.10451}, "CVE-2025-66028": {"epss_score": 0.0006, "epss_percentile": 0.18932}, "CVE-2025-66029": {"epss_score": 0.00029, "epss_percentile": 0.07658}, "CVE-2025-66030": {"epss_score": 0.0004, "epss_percentile": 0.11967}, "CVE-2025-66031": {"epss_score": 0.0011, "epss_percentile": 0.30153}, "CVE-2025-66032": {"epss_score": 0.00151, "epss_percentile": 0.36347}, "CVE-2025-66033": {"epss_score": 0.00044, "epss_percentile": 0.13613}, "CVE-2025-66034": {"epss_score": 0.00168, "epss_percentile": 0.38478}, "CVE-2025-66035": {"epss_score": 0.00072, "epss_percentile": 0.22417}, "CVE-2025-66036": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-66039": {"epss_score": 0.00043, "epss_percentile": 0.13328}, "CVE-2025-66040": {"epss_score": 0.00031, "epss_percentile": 0.08319}, "CVE-2025-66043": {"epss_score": 0.00096, "epss_percentile": 0.27255}, "CVE-2025-66044": {"epss_score": 0.00096, "epss_percentile": 0.27255}, "CVE-2025-66045": {"epss_score": 0.00096, "epss_percentile": 0.27255}, "CVE-2025-66046": {"epss_score": 0.00096, "epss_percentile": 0.27255}, "CVE-2025-66047": {"epss_score": 0.00096, "epss_percentile": 0.27255}, "CVE-2025-66048": {"epss_score": 0.00096, "epss_percentile": 0.27255}, "CVE-2025-66053": {"epss_score": 0.00039, "epss_percentile": 0.11557}, "CVE-2025-66054": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-66055": {"epss_score": 0.00063, "epss_percentile": 0.19882}, "CVE-2025-66056": {"epss_score": 0.00035, "epss_percentile": 0.10006}, "CVE-2025-66057": {"epss_score": 0.00039, "epss_percentile": 0.11763}, "CVE-2025-66058": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-66059": {"epss_score": 0.00036, "epss_percentile": 0.10539}, "CVE-2025-66060": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-66061": {"epss_score": 0.00016, "epss_percentile": 0.02919}, "CVE-2025-66062": {"epss_score": 0.00057, "epss_percentile": 0.1814}, "CVE-2025-66063": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-66064": {"epss_score": 0.0002, "epss_percentile": 0.04473}, "CVE-2025-66065": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-66066": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-66067": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-66068": {"epss_score": 0.0003, "epss_percentile": 0.08267}, "CVE-2025-66069": {"epss_score": 0.00031, "epss_percentile": 0.08696}, "CVE-2025-66070": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-66071": {"epss_score": 0.00059, "epss_percentile": 0.18882}, "CVE-2025-66072": {"epss_score": 0.00059, "epss_percentile": 0.18882}, "CVE-2025-66073": {"epss_score": 0.00059, "epss_percentile": 0.18829}, "CVE-2025-66074": {"epss_score": 0.0004, "epss_percentile": 0.11864}, "CVE-2025-66075": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-66077": {"epss_score": 0.00033, "epss_percentile": 0.09359}, "CVE-2025-66078": {"epss_score": 0.00057, "epss_percentile": 0.18177}, "CVE-2025-66079": {"epss_score": 0.00052, "epss_percentile": 0.16337}, "CVE-2025-66080": {"epss_score": 0.00052, "epss_percentile": 0.16624}, "CVE-2025-66081": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-66082": {"epss_score": 0.00033, "epss_percentile": 0.09359}, "CVE-2025-66083": {"epss_score": 0.00033, "epss_percentile": 0.09359}, "CVE-2025-66084": {"epss_score": 0.00033, "epss_percentile": 0.09359}, "CVE-2025-66085": {"epss_score": 0.00033, "epss_percentile": 0.09359}, "CVE-2025-66086": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-66087": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-66088": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-66089": {"epss_score": 0.00031, "epss_percentile": 0.08696}, "CVE-2025-66090": {"epss_score": 0.00042, "epss_percentile": 0.12484}, "CVE-2025-66091": {"epss_score": 0.00042, "epss_percentile": 0.12565}, "CVE-2025-66092": {"epss_score": 0.00039, "epss_percentile": 0.11557}, "CVE-2025-66093": {"epss_score": 0.00039, "epss_percentile": 0.11557}, "CVE-2025-66094": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-66095": {"epss_score": 0.0003, "epss_percentile": 0.08049}, "CVE-2025-66096": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-66097": {"epss_score": 0.00015, "epss_percentile": 0.02593}, "CVE-2025-66098": {"epss_score": 0.00042, "epss_percentile": 0.12484}, "CVE-2025-66099": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-66100": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-66101": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-66102": {"epss_score": 0.00043, "epss_percentile": 0.13033}, "CVE-2025-66103": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-66104": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-66106": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-66107": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-66108": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-66109": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-66110": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-66111": {"epss_score": 0.00034, "epss_percentile": 0.09725}, "CVE-2025-66112": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-66113": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-66114": {"epss_score": 0.0004, "epss_percentile": 0.12144}, "CVE-2025-66115": {"epss_score": 0.00131, "epss_percentile": 0.33365}, "CVE-2025-66116": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-66117": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-66118": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-66119": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-66120": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-66121": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-66122": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-66124": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-66125": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-66126": {"epss_score": 0.00038, "epss_percentile": 0.11187}, "CVE-2025-66127": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-66128": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-66129": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-66130": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-66131": {"epss_score": 0.00039, "epss_percentile": 0.11728}, "CVE-2025-66132": {"epss_score": 0.00035, "epss_percentile": 0.0999}, "CVE-2025-66133": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-66134": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-66144": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66145": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66146": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66147": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-66148": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66149": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66150": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66151": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66152": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66153": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66154": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66155": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66156": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66157": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66158": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66159": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-66160": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-66161": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-66162": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-66163": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-66164": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-66165": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-66166": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-66167": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-66173": {"epss_score": 0.00079, "epss_percentile": 0.23968}, "CVE-2025-66174": {"epss_score": 0.00081, "epss_percentile": 0.24219}, "CVE-2025-66200": {"epss_score": 0.00052, "epss_percentile": 0.16468}, "CVE-2025-66201": {"epss_score": 0.00058, "epss_percentile": 0.18517}, "CVE-2025-66202": {"epss_score": 0.00225, "epss_percentile": 0.45229}, "CVE-2025-66203": {"epss_score": 0.00291, "epss_percentile": 0.52174}, "CVE-2025-66204": {"epss_score": 0.00068, "epss_percentile": 0.21214}, "CVE-2025-66205": {"epss_score": 0.00037, "epss_percentile": 0.1079}, "CVE-2025-66206": {"epss_score": 0.00065, "epss_percentile": 0.2065}, "CVE-2025-66208": {"epss_score": 0.00479, "epss_percentile": 0.64447}, "CVE-2025-66209": {"epss_score": 0.00474, "epss_percentile": 0.64168}, "CVE-2025-66210": {"epss_score": 0.00384, "epss_percentile": 0.59142}, "CVE-2025-66211": {"epss_score": 0.00384, "epss_percentile": 0.59142}, "CVE-2025-66212": {"epss_score": 0.00463, "epss_percentile": 0.63634}, "CVE-2025-66213": {"epss_score": 0.00463, "epss_percentile": 0.63634}, "CVE-2025-66214": {"epss_score": 0.00224, "epss_percentile": 0.45}, "CVE-2025-66216": {"epss_score": 0.00062, "epss_percentile": 0.19715}, "CVE-2025-66217": {"epss_score": 0.00386, "epss_percentile": 0.59242}, "CVE-2025-66219": {"epss_score": 0.00212, "epss_percentile": 0.43743}, "CVE-2025-66220": {"epss_score": 4e-05, "epss_percentile": 0.00138}, "CVE-2025-66221": {"epss_score": 0.00026, "epss_percentile": 0.06624}, "CVE-2025-66222": {"epss_score": 0.00171, "epss_percentile": 0.38833}, "CVE-2025-66223": {"epss_score": 0.00051, "epss_percentile": 0.16136}, "CVE-2025-66224": {"epss_score": 0.00096, "epss_percentile": 0.27262}, "CVE-2025-66225": {"epss_score": 0.00039, "epss_percentile": 0.11732}, "CVE-2025-66237": {"epss_score": 0.00016, "epss_percentile": 0.02734}, "CVE-2025-66238": {"epss_score": 0.00052, "epss_percentile": 0.16356}, "CVE-2025-66250": {"epss_score": 0.00078, "epss_percentile": 0.238}, "CVE-2025-66251": {"epss_score": 0.00398, "epss_percentile": 0.60061}, "CVE-2025-66252": {"epss_score": 0.00094, "epss_percentile": 0.27031}, "CVE-2025-66253": {"epss_score": 0.00605, "epss_percentile": 0.68989}, "CVE-2025-66254": {"epss_score": 0.00119, "epss_percentile": 0.31629}, "CVE-2025-66255": {"epss_score": 0.00186, "epss_percentile": 0.40652}, "CVE-2025-66256": {"epss_score": 0.00078, "epss_percentile": 0.238}, "CVE-2025-66257": {"epss_score": 0.00119, "epss_percentile": 0.31629}, "CVE-2025-66258": {"epss_score": 0.00033, "epss_percentile": 0.09367}, "CVE-2025-66259": {"epss_score": 0.0038, "epss_percentile": 0.58958}, "CVE-2025-66260": {"epss_score": 0.00033, "epss_percentile": 0.09346}, "CVE-2025-66261": {"epss_score": 0.00605, "epss_percentile": 0.68989}, "CVE-2025-66262": {"epss_score": 0.00104, "epss_percentile": 0.2914}, "CVE-2025-66263": {"epss_score": 0.00047, "epss_percentile": 0.1466}, "CVE-2025-66264": {"epss_score": 0.00018, "epss_percentile": 0.03913}, "CVE-2025-66265": {"epss_score": 0.00014, "epss_percentile": 0.01862}, "CVE-2025-66266": {"epss_score": 0.00024, "epss_percentile": 0.05822}, "CVE-2025-66269": {"epss_score": 0.00015, "epss_percentile": 0.02331}, "CVE-2025-66270": {"epss_score": 0.00031, "epss_percentile": 0.08507}, "CVE-2025-66271": {"epss_score": 0.0002, "epss_percentile": 0.04426}, "CVE-2025-66284": {"epss_score": 0.00032, "epss_percentile": 0.088}, "CVE-2025-66287": {"epss_score": 0.00061, "epss_percentile": 0.1932}, "CVE-2025-66289": {"epss_score": 0.00053, "epss_percentile": 0.16878}, "CVE-2025-66290": {"epss_score": 0.00028, "epss_percentile": 0.07337}, "CVE-2025-66291": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-66293": {"epss_score": 0.00063, "epss_percentile": 0.19861}, "CVE-2025-66294": {"epss_score": 0.36035, "epss_percentile": 0.96951}, "CVE-2025-66295": {"epss_score": 0.00066, "epss_percentile": 0.2069}, "CVE-2025-66296": {"epss_score": 0.00043, "epss_percentile": 0.13324}, "CVE-2025-66297": {"epss_score": 0.00345, "epss_percentile": 0.56588}, "CVE-2025-66298": {"epss_score": 0.00044, "epss_percentile": 0.13526}, "CVE-2025-66299": {"epss_score": 0.0009, "epss_percentile": 0.26146}, "CVE-2025-66300": {"epss_score": 0.00066, "epss_percentile": 0.20912}, "CVE-2025-66301": {"epss_score": 0.25226, "epss_percentile": 0.96001}, "CVE-2025-66302": {"epss_score": 0.0005, "epss_percentile": 0.15873}, "CVE-2025-66303": {"epss_score": 0.00049, "epss_percentile": 0.15579}, "CVE-2025-66304": {"epss_score": 0.00056, "epss_percentile": 0.17774}, "CVE-2025-66305": {"epss_score": 0.00067, "epss_percentile": 0.21105}, "CVE-2025-66306": {"epss_score": 0.00036, "epss_percentile": 0.10621}, "CVE-2025-66307": {"epss_score": 0.00039, "epss_percentile": 0.11707}, "CVE-2025-66308": {"epss_score": 0.00032, "epss_percentile": 0.08959}, "CVE-2025-66309": {"epss_score": 0.00031, "epss_percentile": 0.08438}, "CVE-2025-66310": {"epss_score": 0.00032, "epss_percentile": 0.08959}, "CVE-2025-66311": {"epss_score": 0.00032, "epss_percentile": 0.08959}, "CVE-2025-66312": {"epss_score": 0.00032, "epss_percentile": 0.08959}, "CVE-2025-66313": {"epss_score": 0.00036, "epss_percentile": 0.10319}, "CVE-2025-66314": {"epss_score": 0.00045, "epss_percentile": 0.13975}, "CVE-2025-66320": {"epss_score": 6e-05, "epss_percentile": 0.00278}, "CVE-2025-66321": {"epss_score": 6e-05, "epss_percentile": 0.00278}, "CVE-2025-66322": {"epss_score": 6e-05, "epss_percentile": 0.00278}, "CVE-2025-66323": {"epss_score": 6e-05, "epss_percentile": 0.00296}, "CVE-2025-66324": {"epss_score": 6e-05, "epss_percentile": 0.00316}, "CVE-2025-66325": {"epss_score": 7e-05, "epss_percentile": 0.00345}, "CVE-2025-66326": {"epss_score": 6e-05, "epss_percentile": 0.00281}, "CVE-2025-66327": {"epss_score": 6e-05, "epss_percentile": 0.00291}, "CVE-2025-66328": {"epss_score": 6e-05, "epss_percentile": 0.00313}, "CVE-2025-66329": {"epss_score": 7e-05, "epss_percentile": 0.0038}, "CVE-2025-66330": {"epss_score": 6e-05, "epss_percentile": 0.0028}, "CVE-2025-66331": {"epss_score": 3e-05, "epss_percentile": 0.00119}, "CVE-2025-66332": {"epss_score": 3e-05, "epss_percentile": 0.00119}, "CVE-2025-66333": {"epss_score": 3e-05, "epss_percentile": 0.00119}, "CVE-2025-66334": {"epss_score": 3e-05, "epss_percentile": 0.00119}, "CVE-2025-66357": {"epss_score": 0.00058, "epss_percentile": 0.18609}, "CVE-2025-66359": {"epss_score": 0.00038, "epss_percentile": 0.11408}, "CVE-2025-66360": {"epss_score": 0.00049, "epss_percentile": 0.15315}, "CVE-2025-66361": {"epss_score": 0.00039, "epss_percentile": 0.11843}, "CVE-2025-66370": {"epss_score": 0.00034, "epss_percentile": 0.09472}, "CVE-2025-66371": {"epss_score": 0.00032, "epss_percentile": 0.09068}, "CVE-2025-66372": {"epss_score": 0.00013, "epss_percentile": 0.01648}, "CVE-2025-66373": {"epss_score": 0.00048, "epss_percentile": 0.15232}, "CVE-2025-66376": {"epss_score": 0.00033, "epss_percentile": 0.09176}, "CVE-2025-66377": {"epss_score": 0.0003, "epss_percentile": 0.08237}, "CVE-2025-66378": {"epss_score": 0.00057, "epss_percentile": 0.18055}, "CVE-2025-66379": {"epss_score": 0.00139, "epss_percentile": 0.3459}, "CVE-2025-66382": {"epss_score": 0.00014, "epss_percentile": 0.02054}, "CVE-2025-66384": {"epss_score": 0.00051, "epss_percentile": 0.1601}, "CVE-2025-66385": {"epss_score": 0.00052, "epss_percentile": 0.16599}, "CVE-2025-66386": {"epss_score": 0.00051, "epss_percentile": 0.16008}, "CVE-2025-66388": {"epss_score": 0.00036, "epss_percentile": 0.10302}, "CVE-2025-66395": {"epss_score": 0.00032, "epss_percentile": 0.08989}, "CVE-2025-66396": {"epss_score": 0.00033, "epss_percentile": 0.0924}, "CVE-2025-66397": {"epss_score": 0.00041, "epss_percentile": 0.12339}, "CVE-2025-66398": {"epss_score": 0.00155, "epss_percentile": 0.3681}, "CVE-2025-66399": {"epss_score": 0.00113, "epss_percentile": 0.30684}, "CVE-2025-66400": {"epss_score": 0.00073, "epss_percentile": 0.22604}, "CVE-2025-66401": {"epss_score": 0.00327, "epss_percentile": 0.55141}, "CVE-2025-66402": {"epss_score": 0.00033, "epss_percentile": 0.0936}, "CVE-2025-66403": {"epss_score": 0.00035, "epss_percentile": 0.09973}, "CVE-2025-66404": {"epss_score": 0.00379, "epss_percentile": 0.58899}, "CVE-2025-66405": {"epss_score": 0.00055, "epss_percentile": 0.17619}, "CVE-2025-66406": {"epss_score": 0.00028, "epss_percentile": 0.07217}, "CVE-2025-66407": {"epss_score": 0.00015, "epss_percentile": 0.02433}, "CVE-2025-66409": {"epss_score": 0.00072, "epss_percentile": 0.22417}, "CVE-2025-66410": {"epss_score": 0.00066, "epss_percentile": 0.20926}, "CVE-2025-66411": {"epss_score": 0.00015, "epss_percentile": 0.0258}, "CVE-2025-66412": {"epss_score": 0.0006, "epss_percentile": 0.19139}, "CVE-2025-66414": {"epss_score": 0.00106, "epss_percentile": 0.29564}, "CVE-2025-66415": {"epss_score": 0.00059, "epss_percentile": 0.1864}, "CVE-2025-66416": {"epss_score": 0.00106, "epss_percentile": 0.29564}, "CVE-2025-66418": {"epss_score": 0.00019, "epss_percentile": 0.04389}, "CVE-2025-66419": {"epss_score": 0.00043, "epss_percentile": 0.13028}, "CVE-2025-66420": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-66421": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-66422": {"epss_score": 0.00045, "epss_percentile": 0.13698}, "CVE-2025-66423": {"epss_score": 0.00036, "epss_percentile": 0.10233}, "CVE-2025-66424": {"epss_score": 0.00034, "epss_percentile": 0.09543}, "CVE-2025-66429": {"epss_score": 0.00068, "epss_percentile": 0.21264}, "CVE-2025-66430": {"epss_score": 0.00041, "epss_percentile": 0.12463}, "CVE-2025-66431": {"epss_score": 0.00046, "epss_percentile": 0.14137}, "CVE-2025-66432": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-66433": {"epss_score": 0.00014, "epss_percentile": 0.01908}, "CVE-2025-66434": {"epss_score": 0.00085, "epss_percentile": 0.25102}, "CVE-2025-66435": {"epss_score": 0.00051, "epss_percentile": 0.1611}, "CVE-2025-66436": {"epss_score": 0.00051, "epss_percentile": 0.1611}, "CVE-2025-66437": {"epss_score": 0.00085, "epss_percentile": 0.25102}, "CVE-2025-66438": {"epss_score": 0.00053, "epss_percentile": 0.16843}, "CVE-2025-66439": {"epss_score": 0.00034, "epss_percentile": 0.09626}, "CVE-2025-66440": {"epss_score": 0.00034, "epss_percentile": 0.09626}, "CVE-2025-66443": {"epss_score": 0.00055, "epss_percentile": 0.17554}, "CVE-2025-66444": {"epss_score": 0.00041, "epss_percentile": 0.12238}, "CVE-2025-66445": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-66446": {"epss_score": 0.00037, "epss_percentile": 0.10794}, "CVE-2025-66448": {"epss_score": 0.00176, "epss_percentile": 0.39455}, "CVE-2025-66449": {"epss_score": 0.00072, "epss_percentile": 0.22396}, "CVE-2025-66450": {"epss_score": 0.0003, "epss_percentile": 0.08284}, "CVE-2025-66451": {"epss_score": 0.0006, "epss_percentile": 0.19068}, "CVE-2025-66452": {"epss_score": 0.00031, "epss_percentile": 0.08456}, "CVE-2025-66453": {"epss_score": 0.0006, "epss_percentile": 0.19133}, "CVE-2025-66454": {"epss_score": 0.0035, "epss_percentile": 0.56923}, "CVE-2025-66456": {"epss_score": 0.001, "epss_percentile": 0.2845}, "CVE-2025-66457": {"epss_score": 0.00057, "epss_percentile": 0.18125}, "CVE-2025-66458": {"epss_score": 0.00035, "epss_percentile": 0.10162}, "CVE-2025-66459": {"epss_score": 0.00037, "epss_percentile": 0.10983}, "CVE-2025-66460": {"epss_score": 0.00035, "epss_percentile": 0.10162}, "CVE-2025-66461": {"epss_score": 0.0002, "epss_percentile": 0.04426}, "CVE-2025-66468": {"epss_score": 0.00045, "epss_percentile": 0.13735}, "CVE-2025-66469": {"epss_score": 0.00038, "epss_percentile": 0.11167}, "CVE-2025-66470": {"epss_score": 0.0001, "epss_percentile": 0.00845}, "CVE-2025-66471": {"epss_score": 0.00019, "epss_percentile": 0.04389}, "CVE-2025-66472": {"epss_score": 0.00051, "epss_percentile": 0.16124}, "CVE-2025-66473": {"epss_score": 0.00047, "epss_percentile": 0.14595}, "CVE-2025-66474": {"epss_score": 0.00785, "epss_percentile": 0.73251}, "CVE-2025-66476": {"epss_score": 0.00014, "epss_percentile": 0.01787}, "CVE-2025-66479": {"epss_score": 0.00025, "epss_percentile": 0.06051}, "CVE-2025-66481": {"epss_score": 0.00151, "epss_percentile": 0.36303}, "CVE-2025-66482": {"epss_score": 0.00049, "epss_percentile": 0.15642}, "CVE-2025-66489": {"epss_score": 0.00086, "epss_percentile": 0.25363}, "CVE-2025-66490": {"epss_score": 0.00012, "epss_percentile": 0.01154}, "CVE-2025-66491": {"epss_score": 8e-05, "epss_percentile": 0.00556}, "CVE-2025-66492": {"epss_score": 0.00044, "epss_percentile": 0.13369}, "CVE-2025-66493": {"epss_score": 0.00048, "epss_percentile": 0.14977}, "CVE-2025-66494": {"epss_score": 0.00048, "epss_percentile": 0.14977}, "CVE-2025-66495": {"epss_score": 0.00048, "epss_percentile": 0.14977}, "CVE-2025-66496": {"epss_score": 0.00016, "epss_percentile": 0.02791}, "CVE-2025-66497": {"epss_score": 0.00016, "epss_percentile": 0.02791}, "CVE-2025-66498": {"epss_score": 0.00016, "epss_percentile": 0.02791}, "CVE-2025-66499": {"epss_score": 0.00044, "epss_percentile": 0.13389}, "CVE-2025-66500": {"epss_score": 0.00032, "epss_percentile": 0.09092}, "CVE-2025-66501": {"epss_score": 0.00032, "epss_percentile": 0.09092}, "CVE-2025-66502": {"epss_score": 0.00032, "epss_percentile": 0.09092}, "CVE-2025-66506": {"epss_score": 0.00033, "epss_percentile": 0.0914}, "CVE-2025-66507": {"epss_score": 0.00129, "epss_percentile": 0.33125}, "CVE-2025-66508": {"epss_score": 0.00037, "epss_percentile": 0.10788}, "CVE-2025-66509": {"epss_score": 0.00096, "epss_percentile": 0.27252}, "CVE-2025-66510": {"epss_score": 0.00029, "epss_percentile": 0.07764}, "CVE-2025-66511": {"epss_score": 0.00024, "epss_percentile": 0.05967}, "CVE-2025-66512": {"epss_score": 0.0002, "epss_percentile": 0.04618}, "CVE-2025-66513": {"epss_score": 0.00015, "epss_percentile": 0.02216}, "CVE-2025-66514": {"epss_score": 0.00017, "epss_percentile": 0.03449}, "CVE-2025-66515": {"epss_score": 0.00018, "epss_percentile": 0.04018}, "CVE-2025-66516": {"epss_score": 0.00018, "epss_percentile": 0.03686}, "CVE-2025-66518": {"epss_score": 0.00037, "epss_percentile": 0.10706}, "CVE-2025-66519": {"epss_score": 0.00032, "epss_percentile": 0.09092}, "CVE-2025-66520": {"epss_score": 0.00032, "epss_percentile": 0.09092}, "CVE-2025-66521": {"epss_score": 0.00019, "epss_percentile": 0.04249}, "CVE-2025-66522": {"epss_score": 0.00032, "epss_percentile": 0.09092}, "CVE-2025-66524": {"epss_score": 0.00057, "epss_percentile": 0.18226}, "CVE-2025-66525": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-66526": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-66527": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-66528": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-66529": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-66530": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-66531": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-66532": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-66533": {"epss_score": 0.00022, "epss_percentile": 0.05313}, "CVE-2025-66534": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-66545": {"epss_score": 0.00019, "epss_percentile": 0.04208}, "CVE-2025-66546": {"epss_score": 7e-05, "epss_percentile": 0.0033}, "CVE-2025-66547": {"epss_score": 0.00017, "epss_percentile": 0.03244}, "CVE-2025-66548": {"epss_score": 0.0001, "epss_percentile": 0.00848}, "CVE-2025-66549": {"epss_score": 0.00028, "epss_percentile": 0.07489}, "CVE-2025-66550": {"epss_score": 0.00021, "epss_percentile": 0.0487}, "CVE-2025-66551": {"epss_score": 0.00014, "epss_percentile": 0.02108}, "CVE-2025-66552": {"epss_score": 0.0003, "epss_percentile": 0.08198}, "CVE-2025-66553": {"epss_score": 0.00016, "epss_percentile": 0.02935}, "CVE-2025-66554": {"epss_score": 0.00018, "epss_percentile": 0.03606}, "CVE-2025-66555": {"epss_score": 0.00607, "epss_percentile": 0.69055}, "CVE-2025-66556": {"epss_score": 0.00011, "epss_percentile": 0.01053}, "CVE-2025-66557": {"epss_score": 0.00012, "epss_percentile": 0.01328}, "CVE-2025-66558": {"epss_score": 0.00016, "epss_percentile": 0.02797}, "CVE-2025-66559": {"epss_score": 0.0006, "epss_percentile": 0.19205}, "CVE-2025-66560": {"epss_score": 0.0004, "epss_percentile": 0.12002}, "CVE-2025-66561": {"epss_score": 0.00037, "epss_percentile": 0.10992}, "CVE-2025-66562": {"epss_score": 0.00415, "epss_percentile": 0.61118}, "CVE-2025-66563": {"epss_score": 0.00034, "epss_percentile": 0.0944}, "CVE-2025-66564": {"epss_score": 0.00018, "epss_percentile": 0.04008}, "CVE-2025-66565": {"epss_score": 0.00059, "epss_percentile": 0.18851}, "CVE-2025-66566": {"epss_score": 0.00211, "epss_percentile": 0.43719}, "CVE-2025-66567": {"epss_score": 0.00037, "epss_percentile": 0.10998}, "CVE-2025-66568": {"epss_score": 0.00036, "epss_percentile": 0.10382}, "CVE-2025-66570": {"epss_score": 0.0003, "epss_percentile": 0.08205}, "CVE-2025-66571": {"epss_score": 0.00254, "epss_percentile": 0.48502}, "CVE-2025-66572": {"epss_score": 0.00226, "epss_percentile": 0.45268}, "CVE-2025-66573": {"epss_score": 0.00065, "epss_percentile": 0.20526}, "CVE-2025-66574": {"epss_score": 0.0003, "epss_percentile": 0.08165}, "CVE-2025-66575": {"epss_score": 0.00085, "epss_percentile": 0.25065}, "CVE-2025-66576": {"epss_score": 0.00425, "epss_percentile": 0.61722}, "CVE-2025-66577": {"epss_score": 0.00051, "epss_percentile": 0.16005}, "CVE-2025-66578": {"epss_score": 0.00073, "epss_percentile": 0.22641}, "CVE-2025-66580": {"epss_score": 0.00157, "epss_percentile": 0.37075}, "CVE-2025-66581": {"epss_score": 0.00028, "epss_percentile": 0.07292}, "CVE-2025-66585": {"epss_score": 0.00028, "epss_percentile": 0.07561}, "CVE-2025-66586": {"epss_score": 0.00016, "epss_percentile": 0.02811}, "CVE-2025-66588": {"epss_score": 0.00115, "epss_percentile": 0.30934}, "CVE-2025-66589": {"epss_score": 0.00063, "epss_percentile": 0.2005}, "CVE-2025-66590": {"epss_score": 0.00115, "epss_percentile": 0.30934}, "CVE-2025-66620": {"epss_score": 0.00024, "epss_percentile": 0.05657}, "CVE-2025-66622": {"epss_score": 0.00056, "epss_percentile": 0.17712}, "CVE-2025-66623": {"epss_score": 0.00035, "epss_percentile": 0.1016}, "CVE-2025-66624": {"epss_score": 0.00057, "epss_percentile": 0.18164}, "CVE-2025-66625": {"epss_score": 0.00037, "epss_percentile": 0.10877}, "CVE-2025-66626": {"epss_score": 0.00068, "epss_percentile": 0.21239}, "CVE-2025-66627": {"epss_score": 0.00015, "epss_percentile": 0.02465}, "CVE-2025-66628": {"epss_score": 0.00043, "epss_percentile": 0.13025}, "CVE-2025-66629": {"epss_score": 0.00017, "epss_percentile": 0.03228}, "CVE-2025-66631": {"epss_score": 0.00434, "epss_percentile": 0.62306}, "CVE-2025-66635": {"epss_score": 0.00088, "epss_percentile": 0.25757}, "CVE-2025-66644": {"epss_score": 0.03019, "epss_percentile": 0.86221}, "CVE-2025-66645": {"epss_score": 0.00933, "epss_percentile": 0.75642}, "CVE-2025-66646": {"epss_score": 0.00111, "epss_percentile": 0.30394}, "CVE-2025-66647": {"epss_score": 0.00408, "epss_percentile": 0.60634}, "CVE-2025-66648": {"epss_score": 0.00029, "epss_percentile": 0.0777}, "CVE-2025-66675": {"epss_score": 0.00144, "epss_percentile": 0.35286}, "CVE-2025-66686": {"epss_score": 0.00029, "epss_percentile": 0.0777}, "CVE-2025-66723": {"epss_score": 0.0004, "epss_percentile": 0.12135}, "CVE-2025-66735": {"epss_score": 0.00036, "epss_percentile": 0.10608}, "CVE-2025-66736": {"epss_score": 0.00027, "epss_percentile": 0.07116}, "CVE-2025-66737": {"epss_score": 0.00063, "epss_percentile": 0.20066}, "CVE-2025-66738": {"epss_score": 0.00075, "epss_percentile": 0.22953}, "CVE-2025-66786": {"epss_score": 0.00103, "epss_percentile": 0.29084}, "CVE-2025-66823": {"epss_score": 0.00029, "epss_percentile": 0.07744}, "CVE-2025-66824": {"epss_score": 0.00033, "epss_percentile": 0.09211}, "CVE-2025-66834": {"epss_score": 0.00032, "epss_percentile": 0.09103}, "CVE-2025-66835": {"epss_score": 0.00014, "epss_percentile": 0.01755}, "CVE-2025-66837": {"epss_score": 0.00038, "epss_percentile": 0.11423}, "CVE-2025-66838": {"epss_score": 0.0004, "epss_percentile": 0.11889}, "CVE-2025-66843": {"epss_score": 0.00027, "epss_percentile": 0.07094}, "CVE-2025-66844": {"epss_score": 0.00035, "epss_percentile": 0.09824}, "CVE-2025-66845": {"epss_score": 0.00039, "epss_percentile": 0.1171}, "CVE-2025-66848": {"epss_score": 0.00405, "epss_percentile": 0.60499}, "CVE-2025-66861": {"epss_score": 0.00019, "epss_percentile": 0.04236}, "CVE-2025-66862": {"epss_score": 0.00052, "epss_percentile": 0.16594}, "CVE-2025-66863": {"epss_score": 0.00052, "epss_percentile": 0.16594}, "CVE-2025-66864": {"epss_score": 0.00016, "epss_percentile": 0.02868}, "CVE-2025-66865": {"epss_score": 0.00052, "epss_percentile": 0.16594}, "CVE-2025-66866": {"epss_score": 0.00016, "epss_percentile": 0.02868}, "CVE-2025-66869": {"epss_score": 0.00052, "epss_percentile": 0.16645}, "CVE-2025-66877": {"epss_score": 0.00052, "epss_percentile": 0.16645}, "CVE-2025-66905": {"epss_score": 0.00063, "epss_percentile": 0.19895}, "CVE-2025-66906": {"epss_score": 0.00014, "epss_percentile": 0.01994}, "CVE-2025-66908": {"epss_score": 0.00052, "epss_percentile": 0.1646}, "CVE-2025-66909": {"epss_score": 0.00167, "epss_percentile": 0.38394}, "CVE-2025-66910": {"epss_score": 0.00084, "epss_percentile": 0.24882}, "CVE-2025-66911": {"epss_score": 0.00031, "epss_percentile": 0.08459}, "CVE-2025-66918": {"epss_score": 0.00078, "epss_percentile": 0.2379}, "CVE-2025-66921": {"epss_score": 0.00139, "epss_percentile": 0.34668}, "CVE-2025-66923": {"epss_score": 0.00139, "epss_percentile": 0.34668}, "CVE-2025-66924": {"epss_score": 0.00039, "epss_percentile": 0.11572}, "CVE-2025-66947": {"epss_score": 0.00029, "epss_percentile": 0.07678}, "CVE-2025-66953": {"epss_score": 0.00061, "epss_percentile": 0.19449}, "CVE-2025-66963": {"epss_score": 0.00014, "epss_percentile": 0.01871}, "CVE-2025-67013": {"epss_score": 0.00017, "epss_percentile": 0.03313}, "CVE-2025-67014": {"epss_score": 0.00078, "epss_percentile": 0.23764}, "CVE-2025-67015": {"epss_score": 0.00039, "epss_percentile": 0.11716}, "CVE-2025-67073": {"epss_score": 0.00215, "epss_percentile": 0.44094}, "CVE-2025-67074": {"epss_score": 0.0007, "epss_percentile": 0.21659}, "CVE-2025-67108": {"epss_score": 0.0004, "epss_percentile": 0.12084}, "CVE-2025-67109": {"epss_score": 0.00088, "epss_percentile": 0.25785}, "CVE-2025-67111": {"epss_score": 0.00052, "epss_percentile": 0.16594}, "CVE-2025-67158": {"epss_score": 0.00087, "epss_percentile": 0.25634}, "CVE-2025-67159": {"epss_score": 0.00017, "epss_percentile": 0.03321}, "CVE-2025-67160": {"epss_score": 0.00381, "epss_percentile": 0.5901}, "CVE-2025-67163": {"epss_score": 0.00073, "epss_percentile": 0.22558}, "CVE-2025-67164": {"epss_score": 0.00086, "epss_percentile": 0.25361}, "CVE-2025-67165": {"epss_score": 0.00055, "epss_percentile": 0.17376}, "CVE-2025-67168": {"epss_score": 8e-05, "epss_percentile": 0.00579}, "CVE-2025-67170": {"epss_score": 0.00056, "epss_percentile": 0.1774}, "CVE-2025-67171": {"epss_score": 0.00369, "epss_percentile": 0.58223}, "CVE-2025-67172": {"epss_score": 0.00357, "epss_percentile": 0.57477}, "CVE-2025-67173": {"epss_score": 0.00017, "epss_percentile": 0.03105}, "CVE-2025-67174": {"epss_score": 0.00082, "epss_percentile": 0.24454}, "CVE-2025-67254": {"epss_score": 0.00381, "epss_percentile": 0.5901}, "CVE-2025-67255": {"epss_score": 0.00034, "epss_percentile": 0.09626}, "CVE-2025-67268": {"epss_score": 0.00097, "epss_percentile": 0.27495}, "CVE-2025-67269": {"epss_score": 0.00064, "epss_percentile": 0.20176}, "CVE-2025-67285": {"epss_score": 0.00031, "epss_percentile": 0.08433}, "CVE-2025-67288": {"epss_score": 0.00092, "epss_percentile": 0.26426}, "CVE-2025-67289": {"epss_score": 0.00045, "epss_percentile": 0.14068}, "CVE-2025-67290": {"epss_score": 0.0003, "epss_percentile": 0.08079}, "CVE-2025-67291": {"epss_score": 0.0003, "epss_percentile": 0.08079}, "CVE-2025-67303": {"epss_score": 0.00035, "epss_percentile": 0.10016}, "CVE-2025-67315": {"epss_score": 0.00039, "epss_percentile": 0.117}, "CVE-2025-67316": {"epss_score": 0.00044, "epss_percentile": 0.13426}, "CVE-2025-67341": {"epss_score": 0.00028, "epss_percentile": 0.07522}, "CVE-2025-67342": {"epss_score": 0.00025, "epss_percentile": 0.06333}, "CVE-2025-67344": {"epss_score": 0.00028, "epss_percentile": 0.07522}, "CVE-2025-67349": {"epss_score": 0.00042, "epss_percentile": 0.12775}, "CVE-2025-67364": {"epss_score": 0.00044, "epss_percentile": 0.1345}, "CVE-2025-67366": {"epss_score": 0.00052, "epss_percentile": 0.16583}, "CVE-2025-67397": {"epss_score": 0.00231, "epss_percentile": 0.45848}, "CVE-2025-67418": {"epss_score": 0.00257, "epss_percentile": 0.4888}, "CVE-2025-67419": {"epss_score": 0.00054, "epss_percentile": 0.17288}, "CVE-2025-67427": {"epss_score": 0.00027, "epss_percentile": 0.06751}, "CVE-2025-67436": {"epss_score": 0.00104, "epss_percentile": 0.29175}, "CVE-2025-67442": {"epss_score": 0.00388, "epss_percentile": 0.59371}, "CVE-2025-67443": {"epss_score": 0.00033, "epss_percentile": 0.09139}, "CVE-2025-67450": {"epss_score": 0.00015, "epss_percentile": 0.02465}, "CVE-2025-67460": {"epss_score": 0.00029, "epss_percentile": 0.0774}, "CVE-2025-67461": {"epss_score": 0.00013, "epss_percentile": 0.01479}, "CVE-2025-67465": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-67466": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-67467": {"epss_score": 0.00014, "epss_percentile": 0.02082}, "CVE-2025-67468": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-67469": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-67470": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2025-67471": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-67472": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-67473": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-67474": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-67485": {"epss_score": 0.00064, "epss_percentile": 0.20129}, "CVE-2025-67487": {"epss_score": 0.00063, "epss_percentile": 0.19804}, "CVE-2025-67488": {"epss_score": 0.0002, "epss_percentile": 0.04434}, "CVE-2025-67489": {"epss_score": 0.00378, "epss_percentile": 0.5881}, "CVE-2025-67490": {"epss_score": 0.0005, "epss_percentile": 0.15826}, "CVE-2025-67492": {"epss_score": 0.00028, "epss_percentile": 0.07346}, "CVE-2025-67493": {"epss_score": 0.0009, "epss_percentile": 0.26012}, "CVE-2025-67494": {"epss_score": 0.00028, "epss_percentile": 0.07527}, "CVE-2025-67495": {"epss_score": 0.00067, "epss_percentile": 0.20997}, "CVE-2025-67496": {"epss_score": 0.0003, "epss_percentile": 0.08218}, "CVE-2025-67499": {"epss_score": 0.00013, "epss_percentile": 0.01602}, "CVE-2025-67500": {"epss_score": 0.00049, "epss_percentile": 0.15502}, "CVE-2025-67501": {"epss_score": 0.00051, "epss_percentile": 0.16012}, "CVE-2025-67502": {"epss_score": 0.00062, "epss_percentile": 0.19601}, "CVE-2025-67504": {"epss_score": 0.00042, "epss_percentile": 0.1293}, "CVE-2025-67505": {"epss_score": 0.00042, "epss_percentile": 0.12611}, "CVE-2025-67506": {"epss_score": 0.00174, "epss_percentile": 0.39218}, "CVE-2025-67507": {"epss_score": 0.00079, "epss_percentile": 0.2392}, "CVE-2025-67508": {"epss_score": 0.00045, "epss_percentile": 0.13966}, "CVE-2025-67509": {"epss_score": 0.00051, "epss_percentile": 0.15996}, "CVE-2025-67510": {"epss_score": 0.00084, "epss_percentile": 0.2497}, "CVE-2025-67511": {"epss_score": 0.00111, "epss_percentile": 0.30268}, "CVE-2025-67513": {"epss_score": 0.00054, "epss_percentile": 0.17131}, "CVE-2025-67515": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-67516": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-67517": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-67518": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-67519": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-67520": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-67521": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-67522": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-67523": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-67524": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-67525": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-67526": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-67527": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-67528": {"epss_score": 0.00047, "epss_percentile": 0.14818}, "CVE-2025-67529": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-67530": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-67531": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-67532": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-67533": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67534": {"epss_score": 0.00017, "epss_percentile": 0.03166}, "CVE-2025-67535": {"epss_score": 0.00017, "epss_percentile": 0.03251}, "CVE-2025-67536": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67537": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67538": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67539": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67540": {"epss_score": 0.00035, "epss_percentile": 0.0999}, "CVE-2025-67541": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-67542": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67543": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67544": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67545": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67546": {"epss_score": 0.00034, "epss_percentile": 0.0971}, "CVE-2025-67548": {"epss_score": 0.00029, "epss_percentile": 0.07938}, "CVE-2025-67549": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67550": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67551": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67552": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67553": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67554": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-67555": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67556": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-67557": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67558": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67559": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-67560": {"epss_score": 0.00035, "epss_percentile": 0.0999}, "CVE-2025-67561": {"epss_score": 0.00017, "epss_percentile": 0.03102}, "CVE-2025-67562": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67563": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67564": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-67565": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-67566": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67567": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-67568": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-67569": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-67570": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-67571": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-67572": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-67573": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-67574": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67575": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67576": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67577": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67578": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67579": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67580": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67581": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67582": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67583": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67584": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67585": {"epss_score": 0.00031, "epss_percentile": 0.08324}, "CVE-2025-67586": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67587": {"epss_score": 0.00031, "epss_percentile": 0.08324}, "CVE-2025-67588": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-67589": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-67590": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-67591": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-67592": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-67593": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-67594": {"epss_score": 0.0004, "epss_percentile": 0.1194}, "CVE-2025-67595": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-67596": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-67597": {"epss_score": 0.00031, "epss_percentile": 0.08324}, "CVE-2025-67598": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-67599": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-67621": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-67622": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-67623": {"epss_score": 0.00039, "epss_percentile": 0.11728}, "CVE-2025-67625": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-67627": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-67628": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-67629": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-67630": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-67631": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-67632": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-67633": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-67634": {"epss_score": 0.00028, "epss_percentile": 0.07237}, "CVE-2025-67635": {"epss_score": 0.00101, "epss_percentile": 0.28642}, "CVE-2025-67636": {"epss_score": 0.00186, "epss_percentile": 0.40637}, "CVE-2025-67637": {"epss_score": 0.00051, "epss_percentile": 0.15989}, "CVE-2025-67638": {"epss_score": 0.00025, "epss_percentile": 0.0633}, "CVE-2025-67639": {"epss_score": 0.00043, "epss_percentile": 0.1318}, "CVE-2025-67640": {"epss_score": 0.00075, "epss_percentile": 0.23029}, "CVE-2025-67641": {"epss_score": 0.00033, "epss_percentile": 0.09303}, "CVE-2025-67642": {"epss_score": 0.0011, "epss_percentile": 0.30081}, "CVE-2025-67643": {"epss_score": 0.0196, "epss_percentile": 0.83057}, "CVE-2025-67644": {"epss_score": 0.00017, "epss_percentile": 0.03447}, "CVE-2025-67646": {"epss_score": 0.00015, "epss_percentile": 0.02191}, "CVE-2025-67648": {"epss_score": 0.00031, "epss_percentile": 0.08545}, "CVE-2025-67653": {"epss_score": 0.00069, "epss_percentile": 0.21483}, "CVE-2025-67703": {"epss_score": 0.00043, "epss_percentile": 0.13268}, "CVE-2025-67704": {"epss_score": 0.00043, "epss_percentile": 0.13268}, "CVE-2025-67705": {"epss_score": 0.00043, "epss_percentile": 0.13268}, "CVE-2025-67706": {"epss_score": 0.00144, "epss_percentile": 0.35261}, "CVE-2025-67707": {"epss_score": 0.00144, "epss_percentile": 0.35261}, "CVE-2025-67708": {"epss_score": 0.00043, "epss_percentile": 0.13268}, "CVE-2025-67709": {"epss_score": 0.00043, "epss_percentile": 0.13268}, "CVE-2025-67710": {"epss_score": 0.00043, "epss_percentile": 0.13268}, "CVE-2025-67711": {"epss_score": 0.00043, "epss_percentile": 0.13268}, "CVE-2025-67712": {"epss_score": 0.0006, "epss_percentile": 0.19142}, "CVE-2025-67713": {"epss_score": 0.00054, "epss_percentile": 0.17131}, "CVE-2025-67715": {"epss_score": 9e-05, "epss_percentile": 0.0073}, "CVE-2025-67716": {"epss_score": 0.00049, "epss_percentile": 0.15505}, "CVE-2025-67717": {"epss_score": 0.00038, "epss_percentile": 0.11337}, "CVE-2025-67718": {"epss_score": 0.00052, "epss_percentile": 0.16558}, "CVE-2025-67719": {"epss_score": 0.00017, "epss_percentile": 0.03053}, "CVE-2025-67720": {"epss_score": 0.00039, "epss_percentile": 0.11697}, "CVE-2025-67721": {"epss_score": 0.00169, "epss_percentile": 0.38565}, "CVE-2025-67722": {"epss_score": 0.0001, "epss_percentile": 0.0076}, "CVE-2025-67724": {"epss_score": 0.00037, "epss_percentile": 0.10861}, "CVE-2025-67725": {"epss_score": 0.00179, "epss_percentile": 0.39843}, "CVE-2025-67726": {"epss_score": 0.00077, "epss_percentile": 0.2336}, "CVE-2025-67727": {"epss_score": 0.00061, "epss_percentile": 0.19472}, "CVE-2025-67728": {"epss_score": 0.00335, "epss_percentile": 0.55802}, "CVE-2025-67729": {"epss_score": 0.00105, "epss_percentile": 0.2932}, "CVE-2025-67730": {"epss_score": 0.0003, "epss_percentile": 0.08284}, "CVE-2025-67731": {"epss_score": 0.0006, "epss_percentile": 0.19071}, "CVE-2025-67732": {"epss_score": 0.00046, "epss_percentile": 0.1418}, "CVE-2025-67734": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-67735": {"epss_score": 0.0005, "epss_percentile": 0.15783}, "CVE-2025-67736": {"epss_score": 0.00049, "epss_percentile": 0.15615}, "CVE-2025-67737": {"epss_score": 0.0003, "epss_percentile": 0.08267}, "CVE-2025-67738": {"epss_score": 0.00041, "epss_percentile": 0.12307}, "CVE-2025-67739": {"epss_score": 3e-05, "epss_percentile": 0.00063}, "CVE-2025-67740": {"epss_score": 3e-05, "epss_percentile": 0.00073}, "CVE-2025-67741": {"epss_score": 0.00095, "epss_percentile": 0.27125}, "CVE-2025-67742": {"epss_score": 5e-05, "epss_percentile": 0.00192}, "CVE-2025-67743": {"epss_score": 0.00033, "epss_percentile": 0.0936}, "CVE-2025-67744": {"epss_score": 0.00157, "epss_percentile": 0.37075}, "CVE-2025-67745": {"epss_score": 0.0002, "epss_percentile": 0.0459}, "CVE-2025-67746": {"epss_score": 0.00019, "epss_percentile": 0.04072}, "CVE-2025-67747": {"epss_score": 0.00081, "epss_percentile": 0.24234}, "CVE-2025-67748": {"epss_score": 0.00029, "epss_percentile": 0.07652}, "CVE-2025-67749": {"epss_score": 0.00052, "epss_percentile": 0.16622}, "CVE-2025-67750": {"epss_score": 0.00027, "epss_percentile": 0.06822}, "CVE-2025-67751": {"epss_score": 0.00027, "epss_percentile": 0.06897}, "CVE-2025-67779": {"epss_score": 0.00078, "epss_percentile": 0.23596}, "CVE-2025-67780": {"epss_score": 0.00021, "epss_percentile": 0.04706}, "CVE-2025-67781": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-67787": {"epss_score": 0.00045, "epss_percentile": 0.13958}, "CVE-2025-67789": {"epss_score": 0.00039, "epss_percentile": 0.11642}, "CVE-2025-67790": {"epss_score": 0.00059, "epss_percentile": 0.18851}, "CVE-2025-67791": {"epss_score": 0.00063, "epss_percentile": 0.20086}, "CVE-2025-67792": {"epss_score": 0.00014, "epss_percentile": 0.01773}, "CVE-2025-67793": {"epss_score": 0.00059, "epss_percentile": 0.188}, "CVE-2025-67794": {"epss_score": 0.00013, "epss_percentile": 0.01618}, "CVE-2025-67809": {"epss_score": 0.0003, "epss_percentile": 0.08247}, "CVE-2025-67818": {"epss_score": 0.00279, "epss_percentile": 0.50965}, "CVE-2025-67819": {"epss_score": 0.00079, "epss_percentile": 0.23963}, "CVE-2025-67826": {"epss_score": 0.00016, "epss_percentile": 0.02784}, "CVE-2025-67842": {"epss_score": 0.00059, "epss_percentile": 0.18867}, "CVE-2025-67843": {"epss_score": 0.00313, "epss_percentile": 0.54067}, "CVE-2025-67844": {"epss_score": 0.00038, "epss_percentile": 0.11059}, "CVE-2025-67845": {"epss_score": 0.00079, "epss_percentile": 0.23862}, "CVE-2025-67846": {"epss_score": 0.00046, "epss_percentile": 0.14389}, "CVE-2025-67873": {"epss_score": 0.00013, "epss_percentile": 0.01476}, "CVE-2025-67874": {"epss_score": 0.00033, "epss_percentile": 0.09308}, "CVE-2025-67875": {"epss_score": 0.00025, "epss_percentile": 0.06203}, "CVE-2025-67876": {"epss_score": 0.0003, "epss_percentile": 0.08284}, "CVE-2025-67877": {"epss_score": 0.00032, "epss_percentile": 0.08989}, "CVE-2025-67895": {"epss_score": 0.00299, "epss_percentile": 0.52871}, "CVE-2025-67896": {"epss_score": 0.00076, "epss_percentile": 0.23251}, "CVE-2025-67897": {"epss_score": 0.00124, "epss_percentile": 0.32445}, "CVE-2025-67898": {"epss_score": 0.00024, "epss_percentile": 0.05891}, "CVE-2025-67899": {"epss_score": 0.00016, "epss_percentile": 0.02693}, "CVE-2025-67900": {"epss_score": 0.00017, "epss_percentile": 0.03325}, "CVE-2025-67901": {"epss_score": 0.00066, "epss_percentile": 0.20699}, "CVE-2025-67906": {"epss_score": 0.00035, "epss_percentile": 0.09959}, "CVE-2025-67909": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-67910": {"epss_score": 0.00018, "epss_percentile": 0.04042}, "CVE-2025-67911": {"epss_score": 0.00024, "epss_percentile": 0.05893}, "CVE-2025-67912": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-67913": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-67914": {"epss_score": 0.00021, "epss_percentile": 0.04766}, "CVE-2025-67915": {"epss_score": 0.00024, "epss_percentile": 0.0577}, "CVE-2025-67916": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-67917": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-67918": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-67919": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-67920": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-67921": {"epss_score": 0.00021, "epss_percentile": 0.04865}, "CVE-2025-67922": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-67924": {"epss_score": 0.00018, "epss_percentile": 0.04042}, "CVE-2025-67925": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-67926": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-67927": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-67928": {"epss_score": 0.00021, "epss_percentile": 0.04865}, "CVE-2025-67929": {"epss_score": 0.00013, "epss_percentile": 0.01559}, "CVE-2025-67930": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-67931": {"epss_score": 0.00018, "epss_percentile": 0.04042}, "CVE-2025-67932": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-67933": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-67934": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-67935": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-67936": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-67937": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-67948": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2025-67950": {"epss_score": 0.00034, "epss_percentile": 0.09626}, "CVE-2025-67951": {"epss_score": 0.00038, "epss_percentile": 0.11296}, "CVE-2025-67962": {"epss_score": 0.00033, "epss_percentile": 0.09312}, "CVE-2025-67965": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-67976": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-67983": {"epss_score": 0.00034, "epss_percentile": 0.09547}, "CVE-2025-67985": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-67986": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-67989": {"epss_score": 0.00029, "epss_percentile": 0.07743}, "CVE-2025-67999": {"epss_score": 0.00031, "epss_percentile": 0.08666}, "CVE-2025-68014": {"epss_score": 0.00031, "epss_percentile": 0.08335}, "CVE-2025-68029": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-68033": {"epss_score": 0.00031, "epss_percentile": 0.08465}, "CVE-2025-68036": {"epss_score": 0.00042, "epss_percentile": 0.12489}, "CVE-2025-68038": {"epss_score": 0.00054, "epss_percentile": 0.17186}, "CVE-2025-68040": {"epss_score": 0.00034, "epss_percentile": 0.0971}, "CVE-2025-68044": {"epss_score": 0.0004, "epss_percentile": 0.1216}, "CVE-2025-68053": {"epss_score": 0.00034, "epss_percentile": 0.09626}, "CVE-2025-68054": {"epss_score": 0.00034, "epss_percentile": 0.09626}, "CVE-2025-68055": {"epss_score": 0.00034, "epss_percentile": 0.09626}, "CVE-2025-68056": {"epss_score": 0.00034, "epss_percentile": 0.09626}, "CVE-2025-68061": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-68062": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2025-68065": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-68066": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2025-68067": {"epss_score": 0.00056, "epss_percentile": 0.17846}, "CVE-2025-68068": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2025-68070": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-68071": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68076": {"epss_score": 0.00038, "epss_percentile": 0.11296}, "CVE-2025-68077": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-68078": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-68079": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-68080": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-68082": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-68083": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-68084": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-68085": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-68086": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-68087": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-68088": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-68109": {"epss_score": 0.00158, "epss_percentile": 0.37166}, "CVE-2025-68110": {"epss_score": 0.0005, "epss_percentile": 0.1583}, "CVE-2025-68111": {"epss_score": 0.00033, "epss_percentile": 0.0924}, "CVE-2025-68112": {"epss_score": 0.0004, "epss_percentile": 0.12145}, "CVE-2025-68113": {"epss_score": 0.00033, "epss_percentile": 0.09127}, "CVE-2025-68114": {"epss_score": 0.00028, "epss_percentile": 0.07312}, "CVE-2025-68115": {"epss_score": 0.0003, "epss_percentile": 0.08206}, "CVE-2025-68116": {"epss_score": 0.00039, "epss_percentile": 0.11428}, "CVE-2025-68118": {"epss_score": 0.00046, "epss_percentile": 0.14171}, "CVE-2025-68120": {"epss_score": 0.00078, "epss_percentile": 0.23647}, "CVE-2025-68129": {"epss_score": 0.00063, "epss_percentile": 0.19942}, "CVE-2025-68130": {"epss_score": 0.00056, "epss_percentile": 0.17883}, "CVE-2025-68131": {"epss_score": 0.0004, "epss_percentile": 0.12171}, "CVE-2025-68142": {"epss_score": 0.00052, "epss_percentile": 0.16622}, "CVE-2025-68143": {"epss_score": 0.00136, "epss_percentile": 0.34103}, "CVE-2025-68144": {"epss_score": 0.00102, "epss_percentile": 0.28859}, "CVE-2025-68145": {"epss_score": 0.00082, "epss_percentile": 0.24559}, "CVE-2025-68146": {"epss_score": 0.00016, "epss_percentile": 0.0294}, "CVE-2025-68147": {"epss_score": 0.0003, "epss_percentile": 0.08172}, "CVE-2025-68148": {"epss_score": 0.00041, "epss_percentile": 0.12367}, "CVE-2025-68150": {"epss_score": 0.00073, "epss_percentile": 0.22505}, "CVE-2025-68154": {"epss_score": 0.00066, "epss_percentile": 0.20683}, "CVE-2025-68155": {"epss_score": 0.00335, "epss_percentile": 0.55856}, "CVE-2025-68156": {"epss_score": 0.00071, "epss_percentile": 0.22025}, "CVE-2025-68161": {"epss_score": 0.00037, "epss_percentile": 0.10669}, "CVE-2025-68162": {"epss_score": 2e-05, "epss_percentile": 0.0002}, "CVE-2025-68163": {"epss_score": 0.00018, "epss_percentile": 0.03715}, "CVE-2025-68164": {"epss_score": 3e-05, "epss_percentile": 0.00077}, "CVE-2025-68165": {"epss_score": 0.00125, "epss_percentile": 0.32598}, "CVE-2025-68166": {"epss_score": 0.00125, "epss_percentile": 0.32598}, "CVE-2025-68167": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68168": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68169": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68170": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68171": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68172": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68173": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68174": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68175": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68176": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68177": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68178": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68179": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68180": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68181": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68182": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68183": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68184": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68185": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68186": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68187": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68188": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68189": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68190": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68191": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68192": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68193": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68194": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68195": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68196": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68197": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68198": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68199": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68200": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68201": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68202": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68204": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68205": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68206": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68207": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68208": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68209": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68210": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68211": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68212": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68213": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68214": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68215": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68216": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68217": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68218": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68219": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68220": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68221": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68222": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68223": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68225": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68226": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68227": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68228": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68229": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68230": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68231": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68232": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68233": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68234": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68235": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68236": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68237": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68238": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68239": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68240": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68241": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68242": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68243": {"epss_score": 0.00014, "epss_percentile": 0.01888}, "CVE-2025-68244": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68245": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68246": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68247": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68248": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68249": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68250": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68251": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68252": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68253": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68254": {"epss_score": 0.0002, "epss_percentile": 0.04484}, "CVE-2025-68255": {"epss_score": 0.00027, "epss_percentile": 0.06781}, "CVE-2025-68256": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68257": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68258": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68259": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68260": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68261": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68262": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68263": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68264": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68265": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68266": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68267": {"epss_score": 0.0001, "epss_percentile": 0.00748}, "CVE-2025-68268": {"epss_score": 0.00125, "epss_percentile": 0.32598}, "CVE-2025-68269": {"epss_score": 4e-05, "epss_percentile": 0.00128}, "CVE-2025-68270": {"epss_score": 0.00042, "epss_percentile": 0.12742}, "CVE-2025-68272": {"epss_score": 0.00107, "epss_percentile": 0.29626}, "CVE-2025-68273": {"epss_score": 0.00036, "epss_percentile": 0.10375}, "CVE-2025-68274": {"epss_score": 0.00487, "epss_percentile": 0.64823}, "CVE-2025-68275": {"epss_score": 0.00028, "epss_percentile": 0.07507}, "CVE-2025-68278": {"epss_score": 0.00078, "epss_percentile": 0.23581}, "CVE-2025-68279": {"epss_score": 0.00049, "epss_percentile": 0.15294}, "CVE-2025-68280": {"epss_score": 0.00036, "epss_percentile": 0.10199}, "CVE-2025-68281": {"epss_score": 0.00028, "epss_percentile": 0.07279}, "CVE-2025-68282": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68283": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68284": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68285": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68286": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68287": {"epss_score": 0.00031, "epss_percentile": 0.0854}, "CVE-2025-68288": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68289": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68290": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68291": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68292": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68293": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68294": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68295": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68296": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68297": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68298": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68299": {"epss_score": 0.00037, "epss_percentile": 0.10774}, "CVE-2025-68300": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68301": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68302": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68303": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68304": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68305": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68306": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68307": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68308": {"epss_score": 0.00037, "epss_percentile": 0.10686}, "CVE-2025-68309": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68310": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68311": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68312": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68313": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68314": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68315": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68316": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68317": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68318": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68319": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68320": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68321": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68322": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68323": {"epss_score": 0.00022, "epss_percentile": 0.05241}, "CVE-2025-68324": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68325": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68326": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68327": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68328": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68329": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68330": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68331": {"epss_score": 0.00031, "epss_percentile": 0.0854}, "CVE-2025-68332": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68333": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68334": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68335": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68336": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68337": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68338": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68339": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68340": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68341": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68342": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68343": {"epss_score": 0.00024, "epss_percentile": 0.05723}, "CVE-2025-68344": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68345": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68346": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68347": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68348": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68349": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68350": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68351": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68352": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68353": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68354": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68355": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68356": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68357": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68358": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68359": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68360": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68361": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68362": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68363": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68364": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68365": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68366": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68367": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68368": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68369": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68370": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68371": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68372": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68373": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68374": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68375": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68376": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68377": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68378": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68379": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68380": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68381": {"epss_score": 0.00052, "epss_percentile": 0.16532}, "CVE-2025-68382": {"epss_score": 0.00052, "epss_percentile": 0.16532}, "CVE-2025-68383": {"epss_score": 0.00032, "epss_percentile": 0.08857}, "CVE-2025-68384": {"epss_score": 0.00042, "epss_percentile": 0.12926}, "CVE-2025-68385": {"epss_score": 0.00033, "epss_percentile": 0.09139}, "CVE-2025-68386": {"epss_score": 0.00031, "epss_percentile": 0.08569}, "CVE-2025-68387": {"epss_score": 0.00065, "epss_percentile": 0.20515}, "CVE-2025-68388": {"epss_score": 0.00113, "epss_percentile": 0.30682}, "CVE-2025-68389": {"epss_score": 0.00202, "epss_percentile": 0.42452}, "CVE-2025-68390": {"epss_score": 0.00119, "epss_percentile": 0.31561}, "CVE-2025-68398": {"epss_score": 0.00204, "epss_percentile": 0.42635}, "CVE-2025-68399": {"epss_score": 0.0003, "epss_percentile": 0.08284}, "CVE-2025-68400": {"epss_score": 0.00033, "epss_percentile": 0.09251}, "CVE-2025-68401": {"epss_score": 0.00028, "epss_percentile": 0.07507}, "CVE-2025-68422": {"epss_score": 0.00024, "epss_percentile": 0.06024}, "CVE-2025-68428": {"epss_score": 0.00059, "epss_percentile": 0.18829}, "CVE-2025-68429": {"epss_score": 0.00049, "epss_percentile": 0.1536}, "CVE-2025-68430": {"epss_score": 0.00051, "epss_percentile": 0.16301}, "CVE-2025-68431": {"epss_score": 0.00035, "epss_percentile": 0.0991}, "CVE-2025-68432": {"epss_score": 0.00025, "epss_percentile": 0.06293}, "CVE-2025-68433": {"epss_score": 0.00025, "epss_percentile": 0.06293}, "CVE-2025-68434": {"epss_score": 0.00073, "epss_percentile": 0.22563}, "CVE-2025-68435": {"epss_score": 0.00088, "epss_percentile": 0.25701}, "CVE-2025-68436": {"epss_score": 0.00039, "epss_percentile": 0.11729}, "CVE-2025-68437": {"epss_score": 0.00028, "epss_percentile": 0.07221}, "CVE-2025-68454": {"epss_score": 0.00297, "epss_percentile": 0.52682}, "CVE-2025-68455": {"epss_score": 0.00432, "epss_percentile": 0.62108}, "CVE-2025-68456": {"epss_score": 0.00059, "epss_percentile": 0.18927}, "CVE-2025-68457": {"epss_score": 0.00059, "epss_percentile": 0.18617}, "CVE-2025-68459": {"epss_score": 0.00245, "epss_percentile": 0.47688}, "CVE-2025-68460": {"epss_score": 0.00048, "epss_percentile": 0.15185}, "CVE-2025-68461": {"epss_score": 0.00049, "epss_percentile": 0.15333}, "CVE-2025-68462": {"epss_score": 0.00016, "epss_percentile": 0.02954}, "CVE-2025-68463": {"epss_score": 0.00038, "epss_percentile": 0.11198}, "CVE-2025-68469": {"epss_score": 0.00014, "epss_percentile": 0.01767}, "CVE-2025-68473": {"epss_score": 0.00065, "epss_percentile": 0.205}, "CVE-2025-68474": {"epss_score": 0.00028, "epss_percentile": 0.07213}, "CVE-2025-68475": {"epss_score": 0.00111, "epss_percentile": 0.30333}, "CVE-2025-68476": {"epss_score": 0.00135, "epss_percentile": 0.34027}, "CVE-2025-68477": {"epss_score": 0.00054, "epss_percentile": 0.17201}, "CVE-2025-68478": {"epss_score": 0.00046, "epss_percentile": 0.14083}, "CVE-2025-68480": {"epss_score": 0.00051, "epss_percentile": 0.16133}, "CVE-2025-68481": {"epss_score": 0.00023, "epss_percentile": 0.05603}, "CVE-2025-68494": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-68496": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-68497": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68498": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68499": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-68500": {"epss_score": 0.00039, "epss_percentile": 0.11728}, "CVE-2025-68502": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-68503": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68504": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-68505": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68506": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-68508": {"epss_score": 0.00039, "epss_percentile": 0.11728}, "CVE-2025-68509": {"epss_score": 0.00029, "epss_percentile": 0.07743}, "CVE-2025-68511": {"epss_score": 0.00039, "epss_percentile": 0.11728}, "CVE-2025-68512": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68513": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68516": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-68517": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68519": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-68521": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68522": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68523": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68525": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68527": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68528": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68529": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-68530": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-68532": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68533": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68535": {"epss_score": 0.00039, "epss_percentile": 0.11728}, "CVE-2025-68537": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-68540": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-68544": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2025-68546": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2025-68547": {"epss_score": 0.00041, "epss_percentile": 0.12318}, "CVE-2025-68548": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-68550": {"epss_score": 0.00036, "epss_percentile": 0.10327}, "CVE-2025-68551": {"epss_score": 0.00034, "epss_percentile": 0.0971}, "CVE-2025-68556": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-68557": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-68559": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-68560": {"epss_score": 0.00127, "epss_percentile": 0.32922}, "CVE-2025-68561": {"epss_score": 0.00036, "epss_percentile": 0.10327}, "CVE-2025-68562": {"epss_score": 0.00047, "epss_percentile": 0.14894}, "CVE-2025-68563": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-68565": {"epss_score": 0.00054, "epss_percentile": 0.17357}, "CVE-2025-68566": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68567": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-68568": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-68569": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68570": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-68571": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68572": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68573": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-68574": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-68575": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68576": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-68577": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68578": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68579": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68580": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-68581": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68582": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68583": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-68584": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-68585": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68586": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68587": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68588": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68589": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68590": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-68591": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68592": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68593": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68594": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68595": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68596": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68597": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68598": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68599": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68600": {"epss_score": 0.00039, "epss_percentile": 0.11728}, "CVE-2025-68601": {"epss_score": 0.00019, "epss_percentile": 0.04266}, "CVE-2025-68602": {"epss_score": 0.00029, "epss_percentile": 0.07743}, "CVE-2025-68603": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68605": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68606": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-68607": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-68608": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68613": {"epss_score": 0.08424, "epss_percentile": 0.92045}, "CVE-2025-68614": {"epss_score": 2e-05, "epss_percentile": 0.00023}, "CVE-2025-68615": {"epss_score": 0.00046, "epss_percentile": 0.1411}, "CVE-2025-68617": {"epss_score": 0.00013, "epss_percentile": 0.01604}, "CVE-2025-68618": {"epss_score": 0.00052, "epss_percentile": 0.1661}, "CVE-2025-68619": {"epss_score": 0.00111, "epss_percentile": 0.30298}, "CVE-2025-68620": {"epss_score": 0.00124, "epss_percentile": 0.3245}, "CVE-2025-68637": {"epss_score": 0.00015, "epss_percentile": 0.02196}, "CVE-2025-68644": {"epss_score": 0.0006, "epss_percentile": 0.1909}, "CVE-2025-68645": {"epss_score": 0.16047, "epss_percentile": 0.94564}, "CVE-2025-68664": {"epss_score": 0.00071, "epss_percentile": 0.22083}, "CVE-2025-68665": {"epss_score": 0.00061, "epss_percentile": 0.19349}, "CVE-2025-68667": {"epss_score": 0.00237, "epss_percentile": 0.46639}, "CVE-2025-68668": {"epss_score": 0.00101, "epss_percentile": 0.28637}, "CVE-2025-68669": {"epss_score": 0.00041, "epss_percentile": 0.12455}, "CVE-2025-68696": {"epss_score": 0.00039, "epss_percentile": 0.11704}, "CVE-2025-68697": {"epss_score": 0.00041, "epss_percentile": 0.1238}, "CVE-2025-68700": {"epss_score": 0.00055, "epss_percentile": 0.17476}, "CVE-2025-68705": {"epss_score": 0.00018, "epss_percentile": 0.03729}, "CVE-2025-68706": {"epss_score": 0.00096, "epss_percentile": 0.27397}, "CVE-2025-68724": {"epss_score": 0.00013, "epss_percentile": 0.01683}, "CVE-2025-68725": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68726": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68727": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68728": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68729": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68730": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68731": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68732": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68733": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68734": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68735": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68736": {"epss_score": 0.0002, "epss_percentile": 0.04511}, "CVE-2025-68737": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68738": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68739": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68740": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68741": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68742": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68743": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68744": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68745": {"epss_score": 0.00024, "epss_percentile": 0.0595}, "CVE-2025-68746": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68747": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68748": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-68749": {"epss_score": 0.00022, "epss_percentile": 0.0513}, "CVE-2025-68750": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-68751": {"epss_score": 0.00017, "epss_percentile": 0.03152}, "CVE-2025-68752": {"epss_score": 0.00017, "epss_percentile": 0.03152}, "CVE-2025-68753": {"epss_score": 0.00018, "epss_percentile": 0.03668}, "CVE-2025-68754": {"epss_score": 0.00017, "epss_percentile": 0.03152}, "CVE-2025-68755": {"epss_score": 0.00017, "epss_percentile": 0.03152}, "CVE-2025-68756": {"epss_score": 0.00018, "epss_percentile": 0.03668}, "CVE-2025-68757": {"epss_score": 0.00018, "epss_percentile": 0.03668}, "CVE-2025-68758": {"epss_score": 0.00018, "epss_percentile": 0.03668}, "CVE-2025-68759": {"epss_score": 0.00018, "epss_percentile": 0.03668}, "CVE-2025-68760": {"epss_score": 0.00017, "epss_percentile": 0.03152}, "CVE-2025-68761": {"epss_score": 0.00018, "epss_percentile": 0.04042}, "CVE-2025-68762": {"epss_score": 0.00017, "epss_percentile": 0.03152}, "CVE-2025-68763": {"epss_score": 0.00018, "epss_percentile": 0.03668}, "CVE-2025-68764": {"epss_score": 0.00018, "epss_percentile": 0.03668}, "CVE-2025-68765": {"epss_score": 0.00018, "epss_percentile": 0.03668}, "CVE-2025-68766": {"epss_score": 0.00018, "epss_percentile": 0.03668}, "CVE-2025-68850": {"epss_score": 0.00032, "epss_percentile": 0.08764}, "CVE-2025-68860": {"epss_score": 0.00088, "epss_percentile": 0.2572}, "CVE-2025-68861": {"epss_score": 0.00041, "epss_percentile": 0.12272}, "CVE-2025-68865": {"epss_score": 0.0003, "epss_percentile": 0.08141}, "CVE-2025-68867": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-68868": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-68870": {"epss_score": 0.00114, "epss_percentile": 0.30772}, "CVE-2025-68873": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-68874": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-68875": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-68876": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-68877": {"epss_score": 0.00114, "epss_percentile": 0.30772}, "CVE-2025-68878": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-68879": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-68885": {"epss_score": 0.00015, "epss_percentile": 0.02608}, "CVE-2025-68887": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-68889": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-68890": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-68891": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-68892": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-68893": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-68897": {"epss_score": 0.00053, "epss_percentile": 0.16843}, "CVE-2025-68914": {"epss_score": 0.00029, "epss_percentile": 0.07678}, "CVE-2025-68915": {"epss_score": 0.00027, "epss_percentile": 0.07002}, "CVE-2025-68916": {"epss_score": 0.00464, "epss_percentile": 0.63737}, "CVE-2025-68917": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-68919": {"epss_score": 0.00014, "epss_percentile": 0.01871}, "CVE-2025-68920": {"epss_score": 0.00052, "epss_percentile": 0.16639}, "CVE-2025-68922": {"epss_score": 0.00111, "epss_percentile": 0.30385}, "CVE-2025-68926": {"epss_score": 0.03135, "epss_percentile": 0.8648}, "CVE-2025-68927": {"epss_score": 0.0003, "epss_percentile": 0.08282}, "CVE-2025-68928": {"epss_score": 0.0003, "epss_percentile": 0.08218}, "CVE-2025-68929": {"epss_score": 0.00129, "epss_percentile": 0.33219}, "CVE-2025-68932": {"epss_score": 0.00056, "epss_percentile": 0.17818}, "CVE-2025-68935": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68936": {"epss_score": 0.00029, "epss_percentile": 0.07923}, "CVE-2025-68937": {"epss_score": 0.00073, "epss_percentile": 0.22555}, "CVE-2025-68938": {"epss_score": 0.00042, "epss_percentile": 0.12647}, "CVE-2025-68939": {"epss_score": 0.00029, "epss_percentile": 0.07946}, "CVE-2025-68940": {"epss_score": 0.00032, "epss_percentile": 0.08803}, "CVE-2025-68941": {"epss_score": 0.00029, "epss_percentile": 0.07728}, "CVE-2025-68942": {"epss_score": 0.00027, "epss_percentile": 0.06931}, "CVE-2025-68943": {"epss_score": 0.00033, "epss_percentile": 0.09374}, "CVE-2025-68944": {"epss_score": 0.00027, "epss_percentile": 0.07106}, "CVE-2025-68945": {"epss_score": 0.00033, "epss_percentile": 0.09374}, "CVE-2025-68946": {"epss_score": 0.00027, "epss_percentile": 0.06931}, "CVE-2025-68948": {"epss_score": 0.00031, "epss_percentile": 0.08542}, "CVE-2025-68950": {"epss_score": 0.00017, "epss_percentile": 0.03307}, "CVE-2025-68951": {"epss_score": 0.00037, "epss_percentile": 0.1097}, "CVE-2025-68952": {"epss_score": 0.00434, "epss_percentile": 0.62302}, "CVE-2025-68953": {"epss_score": 0.00042, "epss_percentile": 0.12661}, "CVE-2025-68954": {"epss_score": 0.00028, "epss_percentile": 0.07221}, "CVE-2025-68972": {"epss_score": 6e-05, "epss_percentile": 0.00304}, "CVE-2025-68973": {"epss_score": 0.00012, "epss_percentile": 0.01233}, "CVE-2025-68974": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-68975": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68976": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68977": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-68978": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-68979": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68980": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68981": {"epss_score": 0.00044, "epss_percentile": 0.13409}, "CVE-2025-68982": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-68983": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-68984": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-68985": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-68987": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-68988": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-68989": {"epss_score": 0.00041, "epss_percentile": 0.12204}, "CVE-2025-68990": {"epss_score": 0.0004, "epss_percentile": 0.12095}, "CVE-2025-68991": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-68992": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-68993": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-68994": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-68995": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-68996": {"epss_score": 0.00093, "epss_percentile": 0.26752}, "CVE-2025-68997": {"epss_score": 0.00037, "epss_percentile": 0.10815}, "CVE-2025-68998": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-69006": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-69007": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-69008": {"epss_score": 0.00033, "epss_percentile": 0.09318}, "CVE-2025-69009": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-69010": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-69012": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-69013": {"epss_score": 0.00029, "epss_percentile": 0.07732}, "CVE-2025-69014": {"epss_score": 0.00034, "epss_percentile": 0.09696}, "CVE-2025-69015": {"epss_score": 0.0003, "epss_percentile": 0.08305}, "CVE-2025-69016": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-69017": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-69018": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-69019": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-69020": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-69021": {"epss_score": 0.00015, "epss_percentile": 0.02307}, "CVE-2025-69022": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-69023": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-69024": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-69025": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2025-69026": {"epss_score": 0.0003, "epss_percentile": 0.08316}, "CVE-2025-69027": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-69028": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-69029": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-69030": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-69031": {"epss_score": 0.00037, "epss_percentile": 0.10705}, "CVE-2025-69032": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-69033": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-69034": {"epss_score": 0.00047, "epss_percentile": 0.1488}, "CVE-2025-69080": {"epss_score": 0.00115, "epss_percentile": 0.30924}, "CVE-2025-69081": {"epss_score": 0.00115, "epss_percentile": 0.30924}, "CVE-2025-69082": {"epss_score": 0.00033, "epss_percentile": 0.09387}, "CVE-2025-69083": {"epss_score": 0.00115, "epss_percentile": 0.30924}, "CVE-2025-69084": {"epss_score": 0.00033, "epss_percentile": 0.09387}, "CVE-2025-69085": {"epss_score": 0.00033, "epss_percentile": 0.09387}, "CVE-2025-69086": {"epss_score": 0.00115, "epss_percentile": 0.30924}, "CVE-2025-69087": {"epss_score": 0.00115, "epss_percentile": 0.30924}, "CVE-2025-69088": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-69089": {"epss_score": 0.00034, "epss_percentile": 0.0951}, "CVE-2025-69091": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-69092": {"epss_score": 0.00038, "epss_percentile": 0.11101}, "CVE-2025-69093": {"epss_score": 0.00022, "epss_percentile": 0.05251}, "CVE-2025-69169": {"epss_score": 0.00029, "epss_percentile": 0.07643}, "CVE-2025-69197": {"epss_score": 0.00027, "epss_percentile": 0.06782}, "CVE-2025-69200": {"epss_score": 0.00061, "epss_percentile": 0.19461}, "CVE-2025-69201": {"epss_score": 0.00062, "epss_percentile": 0.19726}, "CVE-2025-69202": {"epss_score": 0.00035, "epss_percentile": 0.09829}, "CVE-2025-69203": {"epss_score": 0.0004, "epss_percentile": 0.12066}, "CVE-2025-69204": {"epss_score": 0.00053, "epss_percentile": 0.16976}, "CVE-2025-69205": {"epss_score": 0.00031, "epss_percentile": 0.08393}, "CVE-2025-69206": {"epss_score": 0.00017, "epss_percentile": 0.03503}, "CVE-2025-69210": {"epss_score": 0.00068, "epss_percentile": 0.21305}, "CVE-2025-69211": {"epss_score": 0.00166, "epss_percentile": 0.38245}, "CVE-2025-69217": {"epss_score": 0.00084, "epss_percentile": 0.24963}, "CVE-2025-69220": {"epss_score": 0.00031, "epss_percentile": 0.08692}, "CVE-2025-69221": {"epss_score": 0.0002, "epss_percentile": 0.04655}, "CVE-2025-69222": {"epss_score": 0.00086, "epss_percentile": 0.25436}, "CVE-2025-69223": {"epss_score": 0.0004, "epss_percentile": 0.12002}, "CVE-2025-69224": {"epss_score": 0.00042, "epss_percentile": 0.12802}, "CVE-2025-69225": {"epss_score": 0.00042, "epss_percentile": 0.12802}, "CVE-2025-69226": {"epss_score": 0.00063, "epss_percentile": 0.1982}, "CVE-2025-69227": {"epss_score": 0.00042, "epss_percentile": 0.12802}, "CVE-2025-69228": {"epss_score": 0.00042, "epss_percentile": 0.12802}, "CVE-2025-69229": {"epss_score": 0.0004, "epss_percentile": 0.11983}, "CVE-2025-69230": {"epss_score": 0.00042, "epss_percentile": 0.12802}, "CVE-2025-69234": {"epss_score": 0.00042, "epss_percentile": 0.12793}, "CVE-2025-69235": {"epss_score": 0.00019, "epss_percentile": 0.04204}, "CVE-2025-69255": {"epss_score": 0.00132, "epss_percentile": 0.33514}, "CVE-2025-69256": {"epss_score": 0.00133, "epss_percentile": 0.33679}, "CVE-2025-69257": {"epss_score": 0.00011, "epss_percentile": 0.00989}, "CVE-2025-69261": {"epss_score": 0.00055, "epss_percentile": 0.17626}, "CVE-2025-69262": {"epss_score": 0.00109, "epss_percentile": 0.29916}, "CVE-2025-69263": {"epss_score": 0.00018, "epss_percentile": 0.03624}, "CVE-2025-69264": {"epss_score": 0.00191, "epss_percentile": 0.41196}, "CVE-2025-69277": {"epss_score": 0.00021, "epss_percentile": 0.0473}, "CVE-2025-69284": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-69286": {"epss_score": 0.00062, "epss_percentile": 0.19771}, "CVE-2025-69288": {"epss_score": 0.00233, "epss_percentile": 0.46024}, "CVE-2025-69327": {"epss_score": 0.00026, "epss_percentile": 0.06661}, "CVE-2025-69331": {"epss_score": 0.00026, "epss_percentile": 0.06661}, "CVE-2025-69333": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2025-69334": {"epss_score": 0.00033, "epss_percentile": 0.09301}, "CVE-2025-69335": {"epss_score": 0.00029, "epss_percentile": 0.07681}, "CVE-2025-69336": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2025-69341": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2025-69342": {"epss_score": 0.00114, "epss_percentile": 0.30762}, "CVE-2025-69344": {"epss_score": 0.00026, "epss_percentile": 0.06661}, "CVE-2025-69345": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2025-69346": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2025-69348": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2025-69349": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2025-69350": {"epss_score": 0.00033, "epss_percentile": 0.09301}, "CVE-2025-69351": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-69352": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2025-69353": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2025-69354": {"epss_score": 0.00025, "epss_percentile": 0.06268}, "CVE-2025-69355": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-69356": {"epss_score": 0.00053, "epss_percentile": 0.17019}, "CVE-2025-69357": {"epss_score": 0.00033, "epss_percentile": 0.09301}, "CVE-2025-69359": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-69360": {"epss_score": 0.00033, "epss_percentile": 0.09301}, "CVE-2025-69361": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-69362": {"epss_score": 0.00033, "epss_percentile": 0.09301}, "CVE-2025-69363": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-69364": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2025-69412": {"epss_score": 0.00021, "epss_percentile": 0.04721}, "CVE-2025-69413": {"epss_score": 0.00074, "epss_percentile": 0.22747}, "CVE-2025-69414": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2025-69415": {"epss_score": 0.00043, "epss_percentile": 0.1332}, "CVE-2025-69416": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-69417": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-6000": {"epss_score": 0.00032, "epss_percentile": 0.09009}, "CVE-2025-6001": {"epss_score": 0.00042, "epss_percentile": 0.12924}, "CVE-2025-6002": {"epss_score": 0.00313, "epss_percentile": 0.5406}, "CVE-2025-6003": {"epss_score": 0.00089, "epss_percentile": 0.25835}, "CVE-2025-6004": {"epss_score": 0.00032, "epss_percentile": 0.0904}, "CVE-2025-6005": {"epss_score": 0.00033, "epss_percentile": 0.09413}, "CVE-2025-6006": {"epss_score": 0.00041, "epss_percentile": 0.12339}, "CVE-2025-6007": {"epss_score": 0.00033, "epss_percentile": 0.09413}, "CVE-2025-6008": {"epss_score": 0.00033, "epss_percentile": 0.09413}, "CVE-2025-6009": {"epss_score": 0.00033, "epss_percentile": 0.09413}, "CVE-2025-6011": {"epss_score": 0.0001, "epss_percentile": 0.00782}, "CVE-2025-6012": {"epss_score": 0.00033, "epss_percentile": 0.09309}, "CVE-2025-6013": {"epss_score": 0.00016, "epss_percentile": 0.02906}, "CVE-2025-6014": {"epss_score": 0.00017, "epss_percentile": 0.03186}, "CVE-2025-6015": {"epss_score": 0.00012, "epss_percentile": 0.01182}, "CVE-2025-6017": {"epss_score": 0.00015, "epss_percentile": 0.0215}, "CVE-2025-6018": {"epss_score": 0.00062, "epss_percentile": 0.19652}, "CVE-2025-6019": {"epss_score": 9e-05, "epss_percentile": 0.0065}, "CVE-2025-6020": {"epss_score": 0.00032, "epss_percentile": 0.08985}, "CVE-2025-6021": {"epss_score": 0.00669, "epss_percentile": 0.70752}, "CVE-2025-6023": {"epss_score": 0.04674, "epss_percentile": 0.8899}, "CVE-2025-6025": {"epss_score": 0.00084, "epss_percentile": 0.24903}, "CVE-2025-6026": {"epss_score": 0.00013, "epss_percentile": 0.01668}, "CVE-2025-6027": {"epss_score": 0.00044, "epss_percentile": 0.13394}, "CVE-2025-6029": {"epss_score": 0.00026, "epss_percentile": 0.06536}, "CVE-2025-6030": {"epss_score": 0.00026, "epss_percentile": 0.06536}, "CVE-2025-6031": {"epss_score": 0.00046, "epss_percentile": 0.14274}, "CVE-2025-6032": {"epss_score": 0.00046, "epss_percentile": 0.14112}, "CVE-2025-6033": {"epss_score": 0.00026, "epss_percentile": 0.06386}, "CVE-2025-6034": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-6035": {"epss_score": 0.00028, "epss_percentile": 0.07317}, "CVE-2025-6037": {"epss_score": 0.00029, "epss_percentile": 0.07978}, "CVE-2025-6038": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-6039": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6040": {"epss_score": 0.00043, "epss_percentile": 0.13061}, "CVE-2025-6041": {"epss_score": 0.00012, "epss_percentile": 0.01298}, "CVE-2025-6042": {"epss_score": 0.00054, "epss_percentile": 0.17143}, "CVE-2025-6043": {"epss_score": 0.00314, "epss_percentile": 0.54142}, "CVE-2025-6044": {"epss_score": 9e-05, "epss_percentile": 0.00685}, "CVE-2025-6050": {"epss_score": 0.00012, "epss_percentile": 0.01207}, "CVE-2025-6051": {"epss_score": 0.00075, "epss_percentile": 0.22979}, "CVE-2025-6052": {"epss_score": 0.00054, "epss_percentile": 0.17274}, "CVE-2025-6053": {"epss_score": 0.00012, "epss_percentile": 0.01298}, "CVE-2025-6054": {"epss_score": 0.00012, "epss_percentile": 0.01298}, "CVE-2025-6055": {"epss_score": 0.00013, "epss_percentile": 0.01575}, "CVE-2025-6056": {"epss_score": 0.00126, "epss_percentile": 0.32769}, "CVE-2025-6057": {"epss_score": 0.00422, "epss_percentile": 0.61564}, "CVE-2025-6058": {"epss_score": 0.22759, "epss_percentile": 0.95679}, "CVE-2025-6059": {"epss_score": 0.00012, "epss_percentile": 0.01304}, "CVE-2025-6060": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-6061": {"epss_score": 0.00034, "epss_percentile": 0.09601}, "CVE-2025-6062": {"epss_score": 0.00014, "epss_percentile": 0.0178}, "CVE-2025-6063": {"epss_score": 0.00013, "epss_percentile": 0.01575}, "CVE-2025-6064": {"epss_score": 0.00013, "epss_percentile": 0.01575}, "CVE-2025-6065": {"epss_score": 0.02047, "epss_percentile": 0.8339}, "CVE-2025-6067": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-6068": {"epss_score": 0.00024, "epss_percentile": 0.05997}, "CVE-2025-6069": {"epss_score": 0.00163, "epss_percentile": 0.37811}, "CVE-2025-6070": {"epss_score": 0.00485, "epss_percentile": 0.64705}, "CVE-2025-6071": {"epss_score": 0.00038, "epss_percentile": 0.11266}, "CVE-2025-6072": {"epss_score": 0.00057, "epss_percentile": 0.18139}, "CVE-2025-6073": {"epss_score": 0.00049, "epss_percentile": 0.15603}, "CVE-2025-6074": {"epss_score": 0.00039, "epss_percentile": 0.11536}, "CVE-2025-6075": {"epss_score": 0.00018, "epss_percentile": 0.03924}, "CVE-2025-6076": {"epss_score": 0.00048, "epss_percentile": 0.15195}, "CVE-2025-6077": {"epss_score": 0.00047, "epss_percentile": 0.14829}, "CVE-2025-6078": {"epss_score": 0.0002, "epss_percentile": 0.04528}, "CVE-2025-6079": {"epss_score": 0.00457, "epss_percentile": 0.63383}, "CVE-2025-6080": {"epss_score": 0.00075, "epss_percentile": 0.23056}, "CVE-2025-6081": {"epss_score": 0.00035, "epss_percentile": 0.10012}, "CVE-2025-6082": {"epss_score": 0.01674, "epss_percentile": 0.81694}, "CVE-2025-6083": {"epss_score": 0.00067, "epss_percentile": 0.21176}, "CVE-2025-6085": {"epss_score": 0.01174, "epss_percentile": 0.78256}, "CVE-2025-6086": {"epss_score": 0.00222, "epss_percentile": 0.44794}, "CVE-2025-6087": {"epss_score": 0.00166, "epss_percentile": 0.38172}, "CVE-2025-6088": {"epss_score": 0.00045, "epss_percentile": 0.13747}, "CVE-2025-6089": {"epss_score": 0.00026, "epss_percentile": 0.06666}, "CVE-2025-6090": {"epss_score": 0.00121, "epss_percentile": 0.32014}, "CVE-2025-6091": {"epss_score": 0.00121, "epss_percentile": 0.32014}, "CVE-2025-6092": {"epss_score": 0.00027, "epss_percentile": 0.07003}, "CVE-2025-6093": {"epss_score": 0.00019, "epss_percentile": 0.04182}, "CVE-2025-6094": {"epss_score": 0.0003, "epss_percentile": 0.08093}, "CVE-2025-6095": {"epss_score": 0.24661, "epss_percentile": 0.95944}, "CVE-2025-6096": {"epss_score": 0.0003, "epss_percentile": 0.08093}, "CVE-2025-6097": {"epss_score": 0.00034, "epss_percentile": 0.09763}, "CVE-2025-6098": {"epss_score": 0.00123, "epss_percentile": 0.32182}, "CVE-2025-6099": {"epss_score": 0.00031, "epss_percentile": 0.08442}, "CVE-2025-6100": {"epss_score": 0.00028, "epss_percentile": 0.07262}, "CVE-2025-6101": {"epss_score": 0.00028, "epss_percentile": 0.0749}, "CVE-2025-6102": {"epss_score": 0.00482, "epss_percentile": 0.64526}, "CVE-2025-6103": {"epss_score": 0.00322, "epss_percentile": 0.54784}, "CVE-2025-6104": {"epss_score": 0.00322, "epss_percentile": 0.54784}, "CVE-2025-6105": {"epss_score": 0.00039, "epss_percentile": 0.11841}, "CVE-2025-6106": {"epss_score": 0.00048, "epss_percentile": 0.15074}, "CVE-2025-6107": {"epss_score": 0.00038, "epss_percentile": 0.11177}, "CVE-2025-6108": {"epss_score": 0.00045, "epss_percentile": 0.13831}, "CVE-2025-6109": {"epss_score": 0.00054, "epss_percentile": 0.17274}, "CVE-2025-6110": {"epss_score": 0.00211, "epss_percentile": 0.43631}, "CVE-2025-6111": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-6112": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-6113": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-6114": {"epss_score": 0.00156, "epss_percentile": 0.37007}, "CVE-2025-6115": {"epss_score": 0.00156, "epss_percentile": 0.37007}, "CVE-2025-6116": {"epss_score": 0.00028, "epss_percentile": 0.07247}, "CVE-2025-6117": {"epss_score": 0.00028, "epss_percentile": 0.07247}, "CVE-2025-6118": {"epss_score": 0.00028, "epss_percentile": 0.07247}, "CVE-2025-6119": {"epss_score": 0.00028, "epss_percentile": 0.07257}, "CVE-2025-6120": {"epss_score": 0.00028, "epss_percentile": 0.07257}, "CVE-2025-6121": {"epss_score": 0.00245, "epss_percentile": 0.47658}, "CVE-2025-6122": {"epss_score": 0.00039, "epss_percentile": 0.11691}, "CVE-2025-6123": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6124": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6125": {"epss_score": 0.00026, "epss_percentile": 0.06585}, "CVE-2025-6126": {"epss_score": 0.00029, "epss_percentile": 0.07595}, "CVE-2025-6127": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-6128": {"epss_score": 0.00548, "epss_percentile": 0.67278}, "CVE-2025-6129": {"epss_score": 0.00548, "epss_percentile": 0.67278}, "CVE-2025-6130": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6131": {"epss_score": 0.00037, "epss_percentile": 0.10965}, "CVE-2025-6132": {"epss_score": 0.00031, "epss_percentile": 0.08437}, "CVE-2025-6133": {"epss_score": 0.00025, "epss_percentile": 0.06233}, "CVE-2025-6134": {"epss_score": 0.00025, "epss_percentile": 0.06233}, "CVE-2025-6135": {"epss_score": 0.00031, "epss_percentile": 0.08532}, "CVE-2025-6136": {"epss_score": 0.00025, "epss_percentile": 0.06233}, "CVE-2025-6137": {"epss_score": 0.00389, "epss_percentile": 0.59475}, "CVE-2025-6138": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6139": {"epss_score": 0.00045, "epss_percentile": 0.13726}, "CVE-2025-6140": {"epss_score": 0.00028, "epss_percentile": 0.07286}, "CVE-2025-6141": {"epss_score": 0.00016, "epss_percentile": 0.02641}, "CVE-2025-6142": {"epss_score": 0.00039, "epss_percentile": 0.11625}, "CVE-2025-6143": {"epss_score": 0.00389, "epss_percentile": 0.59475}, "CVE-2025-6144": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6145": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6146": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6147": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6148": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6149": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6150": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6151": {"epss_score": 0.00307, "epss_percentile": 0.53497}, "CVE-2025-6152": {"epss_score": 0.00086, "epss_percentile": 0.25402}, "CVE-2025-6153": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6154": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6155": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6156": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6157": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6158": {"epss_score": 0.00306, "epss_percentile": 0.53397}, "CVE-2025-6159": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6160": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6161": {"epss_score": 0.00056, "epss_percentile": 0.17811}, "CVE-2025-6162": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6163": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6164": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6165": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6166": {"epss_score": 0.00027, "epss_percentile": 0.06923}, "CVE-2025-6167": {"epss_score": 0.00021, "epss_percentile": 0.04723}, "CVE-2025-6168": {"epss_score": 0.00014, "epss_percentile": 0.02085}, "CVE-2025-6169": {"epss_score": 0.00123, "epss_percentile": 0.32175}, "CVE-2025-6170": {"epss_score": 0.00017, "epss_percentile": 0.03397}, "CVE-2025-6171": {"epss_score": 0.00018, "epss_percentile": 0.04027}, "CVE-2025-6172": {"epss_score": 0.00068, "epss_percentile": 0.21229}, "CVE-2025-6173": {"epss_score": 0.00025, "epss_percentile": 0.06291}, "CVE-2025-6174": {"epss_score": 0.00712, "epss_percentile": 0.7178}, "CVE-2025-6175": {"epss_score": 0.00043, "epss_percentile": 0.12974}, "CVE-2025-6176": {"epss_score": 0.00021, "epss_percentile": 0.04737}, "CVE-2025-6177": {"epss_score": 5e-05, "epss_percentile": 0.00222}, "CVE-2025-6179": {"epss_score": 0.00037, "epss_percentile": 0.10958}, "CVE-2025-6180": {"epss_score": 0.00012, "epss_percentile": 0.01219}, "CVE-2025-6181": {"epss_score": 0.00042, "epss_percentile": 0.12915}, "CVE-2025-6182": {"epss_score": 0.00015, "epss_percentile": 0.02544}, "CVE-2025-6183": {"epss_score": 0.00043, "epss_percentile": 0.13026}, "CVE-2025-6184": {"epss_score": 0.00055, "epss_percentile": 0.17631}, "CVE-2025-6185": {"epss_score": 0.00027, "epss_percentile": 0.06848}, "CVE-2025-6186": {"epss_score": 0.00102, "epss_percentile": 0.28792}, "CVE-2025-6187": {"epss_score": 0.00653, "epss_percentile": 0.70322}, "CVE-2025-6188": {"epss_score": 0.00047, "epss_percentile": 0.14856}, "CVE-2025-6189": {"epss_score": 0.00036, "epss_percentile": 0.10613}, "CVE-2025-6190": {"epss_score": 0.00053, "epss_percentile": 0.16729}, "CVE-2025-6191": {"epss_score": 0.0003, "epss_percentile": 0.08022}, "CVE-2025-6192": {"epss_score": 0.00076, "epss_percentile": 0.2322}, "CVE-2025-6193": {"epss_score": 0.00072, "epss_percentile": 0.22401}, "CVE-2025-6195": {"epss_score": 0.00016, "epss_percentile": 0.02723}, "CVE-2025-6196": {"epss_score": 0.00031, "epss_percentile": 0.08441}, "CVE-2025-6197": {"epss_score": 0.00501, "epss_percentile": 0.65359}, "CVE-2025-6198": {"epss_score": 0.00028, "epss_percentile": 0.07316}, "CVE-2025-6199": {"epss_score": 0.00014, "epss_percentile": 0.01915}, "CVE-2025-6200": {"epss_score": 0.00037, "epss_percentile": 0.10789}, "CVE-2025-6201": {"epss_score": 0.00037, "epss_percentile": 0.10645}, "CVE-2025-6202": {"epss_score": 0.00021, "epss_percentile": 0.04863}, "CVE-2025-6203": {"epss_score": 0.00048, "epss_percentile": 0.15068}, "CVE-2025-6204": {"epss_score": 0.06973, "epss_percentile": 0.91154}, "CVE-2025-6205": {"epss_score": 0.63215, "epss_percentile": 0.98324}, "CVE-2025-6206": {"epss_score": 0.00146, "epss_percentile": 0.35527}, "CVE-2025-6207": {"epss_score": 0.00123, "epss_percentile": 0.32338}, "CVE-2025-6209": {"epss_score": 0.00077, "epss_percentile": 0.23416}, "CVE-2025-6210": {"epss_score": 0.00028, "epss_percentile": 0.07437}, "CVE-2025-6211": {"epss_score": 0.0006, "epss_percentile": 0.19226}, "CVE-2025-6212": {"epss_score": 0.00159, "epss_percentile": 0.37413}, "CVE-2025-6213": {"epss_score": 0.00355, "epss_percentile": 0.57323}, "CVE-2025-6214": {"epss_score": 0.00017, "epss_percentile": 0.03245}, "CVE-2025-6215": {"epss_score": 0.00155, "epss_percentile": 0.36817}, "CVE-2025-6216": {"epss_score": 0.33256, "epss_percentile": 0.96757}, "CVE-2025-6217": {"epss_score": 8e-05, "epss_percentile": 0.00529}, "CVE-2025-6218": {"epss_score": 0.08316, "epss_percentile": 0.91988}, "CVE-2025-6220": {"epss_score": 0.00589, "epss_percentile": 0.68513}, "CVE-2025-6221": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-6222": {"epss_score": 0.00457, "epss_percentile": 0.63385}, "CVE-2025-6224": {"epss_score": 0.00018, "epss_percentile": 0.03838}, "CVE-2025-6225": {"epss_score": 0.0071, "epss_percentile": 0.71724}, "CVE-2025-6226": {"epss_score": 0.00043, "epss_percentile": 0.13364}, "CVE-2025-6227": {"epss_score": 0.0003, "epss_percentile": 0.08017}, "CVE-2025-6228": {"epss_score": 0.00028, "epss_percentile": 0.07475}, "CVE-2025-6230": {"epss_score": 0.00017, "epss_percentile": 0.03321}, "CVE-2025-6231": {"epss_score": 0.0002, "epss_percentile": 0.04605}, "CVE-2025-6232": {"epss_score": 0.0002, "epss_percentile": 0.04605}, "CVE-2025-6233": {"epss_score": 0.00052, "epss_percentile": 0.16558}, "CVE-2025-6234": {"epss_score": 0.00033, "epss_percentile": 0.09341}, "CVE-2025-6235": {"epss_score": 0.00055, "epss_percentile": 0.17447}, "CVE-2025-6236": {"epss_score": 0.0003, "epss_percentile": 0.08289}, "CVE-2025-6237": {"epss_score": 0.00106, "epss_percentile": 0.2941}, "CVE-2025-6238": {"epss_score": 0.00078, "epss_percentile": 0.23732}, "CVE-2025-6239": {"epss_score": 0.00019, "epss_percentile": 0.04197}, "CVE-2025-6240": {"epss_score": 0.00084, "epss_percentile": 0.25026}, "CVE-2025-6241": {"epss_score": 0.00012, "epss_percentile": 0.01283}, "CVE-2025-6242": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-6244": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-6247": {"epss_score": 0.00059, "epss_percentile": 0.18742}, "CVE-2025-6248": {"epss_score": 0.00027, "epss_percentile": 0.06848}, "CVE-2025-6249": {"epss_score": 0.00014, "epss_percentile": 0.01961}, "CVE-2025-6250": {"epss_score": 0.00016, "epss_percentile": 0.0276}, "CVE-2025-6251": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-6252": {"epss_score": 0.00024, "epss_percentile": 0.05667}, "CVE-2025-6253": {"epss_score": 0.00068, "epss_percentile": 0.21357}, "CVE-2025-6255": {"epss_score": 0.00055, "epss_percentile": 0.17592}, "CVE-2025-6256": {"epss_score": 0.00026, "epss_percentile": 0.06718}, "CVE-2025-6257": {"epss_score": 0.00037, "epss_percentile": 0.10645}, "CVE-2025-6258": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6259": {"epss_score": 0.00027, "epss_percentile": 0.06804}, "CVE-2025-6260": {"epss_score": 0.00226, "epss_percentile": 0.45344}, "CVE-2025-6261": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6262": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6264": {"epss_score": 0.00044, "epss_percentile": 0.13373}, "CVE-2025-6265": {"epss_score": 0.00114, "epss_percentile": 0.30852}, "CVE-2025-6266": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-6267": {"epss_score": 0.00024, "epss_percentile": 0.05954}, "CVE-2025-6268": {"epss_score": 0.00023, "epss_percentile": 0.05621}, "CVE-2025-6269": {"epss_score": 0.00032, "epss_percentile": 0.08826}, "CVE-2025-6270": {"epss_score": 0.00032, "epss_percentile": 0.08826}, "CVE-2025-6271": {"epss_score": 0.00032, "epss_percentile": 0.08951}, "CVE-2025-6272": {"epss_score": 0.00032, "epss_percentile": 0.08951}, "CVE-2025-6273": {"epss_score": 0.00024, "epss_percentile": 0.06018}, "CVE-2025-6274": {"epss_score": 0.00034, "epss_percentile": 0.09693}, "CVE-2025-6275": {"epss_score": 0.00034, "epss_percentile": 0.09693}, "CVE-2025-6276": {"epss_score": 0.00031, "epss_percentile": 0.08499}, "CVE-2025-6277": {"epss_score": 0.00031, "epss_percentile": 0.08499}, "CVE-2025-6278": {"epss_score": 0.00082, "epss_percentile": 0.24544}, "CVE-2025-6279": {"epss_score": 0.00058, "epss_percentile": 0.18365}, "CVE-2025-6280": {"epss_score": 0.00082, "epss_percentile": 0.24544}, "CVE-2025-6281": {"epss_score": 0.00057, "epss_percentile": 0.1819}, "CVE-2025-6282": {"epss_score": 0.00082, "epss_percentile": 0.24544}, "CVE-2025-6283": {"epss_score": 0.00088, "epss_percentile": 0.25673}, "CVE-2025-6284": {"epss_score": 0.00038, "epss_percentile": 0.11125}, "CVE-2025-6285": {"epss_score": 0.00025, "epss_percentile": 0.06039}, "CVE-2025-6286": {"epss_score": 0.00027, "epss_percentile": 0.07087}, "CVE-2025-6287": {"epss_score": 0.00024, "epss_percentile": 0.05953}, "CVE-2025-6288": {"epss_score": 0.00023, "epss_percentile": 0.05648}, "CVE-2025-6290": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-6291": {"epss_score": 0.00156, "epss_percentile": 0.37007}, "CVE-2025-6292": {"epss_score": 0.00156, "epss_percentile": 0.37007}, "CVE-2025-6293": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6294": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6295": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6296": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6297": {"epss_score": 0.00078, "epss_percentile": 0.23596}, "CVE-2025-6298": {"epss_score": 0.00023, "epss_percentile": 0.05345}, "CVE-2025-6299": {"epss_score": 0.00541, "epss_percentile": 0.67057}, "CVE-2025-6300": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6301": {"epss_score": 0.00023, "epss_percentile": 0.05648}, "CVE-2025-6302": {"epss_score": 0.00226, "epss_percentile": 0.4536}, "CVE-2025-6303": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6304": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6305": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6306": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6307": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6308": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6309": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6310": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6311": {"epss_score": 0.0004, "epss_percentile": 0.12033}, "CVE-2025-6312": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-6313": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-6314": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-6315": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6316": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6317": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6318": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6319": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6320": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6321": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6322": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6323": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6324": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-6325": {"epss_score": 0.00059, "epss_percentile": 0.18882}, "CVE-2025-6326": {"epss_score": 0.00151, "epss_percentile": 0.36288}, "CVE-2025-6327": {"epss_score": 0.00061, "epss_percentile": 0.19455}, "CVE-2025-6328": {"epss_score": 0.00152, "epss_percentile": 0.36427}, "CVE-2025-6329": {"epss_score": 0.00064, "epss_percentile": 0.20254}, "CVE-2025-6330": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6331": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6332": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6333": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6334": {"epss_score": 0.00146, "epss_percentile": 0.3557}, "CVE-2025-6335": {"epss_score": 0.00045, "epss_percentile": 0.13728}, "CVE-2025-6336": {"epss_score": 0.00577, "epss_percentile": 0.68174}, "CVE-2025-6337": {"epss_score": 0.00608, "epss_percentile": 0.69067}, "CVE-2025-6338": {"epss_score": 0.00043, "epss_percentile": 0.13011}, "CVE-2025-6339": {"epss_score": 0.00031, "epss_percentile": 0.08437}, "CVE-2025-6340": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-6341": {"epss_score": 0.00056, "epss_percentile": 0.17732}, "CVE-2025-6342": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6343": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6344": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6345": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-6346": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6347": {"epss_score": 0.00026, "epss_percentile": 0.06585}, "CVE-2025-6348": {"epss_score": 0.00026, "epss_percentile": 0.06615}, "CVE-2025-6349": {"epss_score": 0.00017, "epss_percentile": 0.03232}, "CVE-2025-6350": {"epss_score": 0.00024, "epss_percentile": 0.05667}, "CVE-2025-6351": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6352": {"epss_score": 0.00043, "epss_percentile": 0.13327}, "CVE-2025-6353": {"epss_score": 0.00037, "epss_percentile": 0.1092}, "CVE-2025-6354": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6355": {"epss_score": 0.00035, "epss_percentile": 0.09966}, "CVE-2025-6356": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6357": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6358": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6359": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6360": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6361": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6362": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6363": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6364": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6365": {"epss_score": 0.00095, "epss_percentile": 0.27175}, "CVE-2025-6366": {"epss_score": 0.00075, "epss_percentile": 0.23056}, "CVE-2025-6367": {"epss_score": 0.00146, "epss_percentile": 0.35531}, "CVE-2025-6368": {"epss_score": 0.00146, "epss_percentile": 0.35531}, "CVE-2025-6369": {"epss_score": 0.00146, "epss_percentile": 0.35531}, "CVE-2025-6370": {"epss_score": 0.00146, "epss_percentile": 0.35531}, "CVE-2025-6371": {"epss_score": 0.00146, "epss_percentile": 0.35531}, "CVE-2025-6372": {"epss_score": 0.00146, "epss_percentile": 0.35531}, "CVE-2025-6373": {"epss_score": 0.00117, "epss_percentile": 0.31369}, "CVE-2025-6374": {"epss_score": 0.00146, "epss_percentile": 0.35531}, "CVE-2025-6375": {"epss_score": 0.00033, "epss_percentile": 0.09189}, "CVE-2025-6376": {"epss_score": 0.00025, "epss_percentile": 0.06053}, "CVE-2025-6377": {"epss_score": 0.00025, "epss_percentile": 0.06053}, "CVE-2025-6378": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6379": {"epss_score": 0.00162, "epss_percentile": 0.37753}, "CVE-2025-6380": {"epss_score": 0.00236, "epss_percentile": 0.46372}, "CVE-2025-6381": {"epss_score": 0.00162, "epss_percentile": 0.37753}, "CVE-2025-6382": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-6383": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-6384": {"epss_score": 0.00033, "epss_percentile": 0.09165}, "CVE-2025-6385": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6386": {"epss_score": 0.0013, "epss_percentile": 0.33342}, "CVE-2025-6387": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6388": {"epss_score": 0.00447, "epss_percentile": 0.62947}, "CVE-2025-6389": {"epss_score": 0.00369, "epss_percentile": 0.58243}, "CVE-2025-6390": {"epss_score": 0.00015, "epss_percentile": 0.02585}, "CVE-2025-6391": {"epss_score": 0.00022, "epss_percentile": 0.05241}, "CVE-2025-6392": {"epss_score": 0.00015, "epss_percentile": 0.02585}, "CVE-2025-6393": {"epss_score": 0.01653, "epss_percentile": 0.81582}, "CVE-2025-6394": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6395": {"epss_score": 0.00084, "epss_percentile": 0.24939}, "CVE-2025-6396": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-6398": {"epss_score": 0.00016, "epss_percentile": 0.02744}, "CVE-2025-6399": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6400": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6401": {"epss_score": 0.00114, "epss_percentile": 0.30737}, "CVE-2025-6402": {"epss_score": 0.00218, "epss_percentile": 0.44423}, "CVE-2025-6403": {"epss_score": 0.00577, "epss_percentile": 0.68175}, "CVE-2025-6404": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6405": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6406": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6407": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6408": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6409": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6410": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6411": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6412": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6413": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6414": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6415": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6416": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6417": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6418": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6419": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6420": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6421": {"epss_score": 0.0004, "epss_percentile": 0.12033}, "CVE-2025-6422": {"epss_score": 0.00059, "epss_percentile": 0.18693}, "CVE-2025-6423": {"epss_score": 0.00219, "epss_percentile": 0.44526}, "CVE-2025-6424": {"epss_score": 0.00156, "epss_percentile": 0.36909}, "CVE-2025-6425": {"epss_score": 0.00053, "epss_percentile": 0.16857}, "CVE-2025-6426": {"epss_score": 0.00026, "epss_percentile": 0.0663}, "CVE-2025-6427": {"epss_score": 0.0004, "epss_percentile": 0.12121}, "CVE-2025-6428": {"epss_score": 0.00036, "epss_percentile": 0.10433}, "CVE-2025-6429": {"epss_score": 0.00056, "epss_percentile": 0.17666}, "CVE-2025-6430": {"epss_score": 0.00047, "epss_percentile": 0.1464}, "CVE-2025-6431": {"epss_score": 0.0003, "epss_percentile": 0.08162}, "CVE-2025-6432": {"epss_score": 0.00059, "epss_percentile": 0.189}, "CVE-2025-6433": {"epss_score": 0.00039, "epss_percentile": 0.11702}, "CVE-2025-6434": {"epss_score": 0.00028, "epss_percentile": 0.07522}, "CVE-2025-6435": {"epss_score": 0.00071, "epss_percentile": 0.22086}, "CVE-2025-6436": {"epss_score": 0.00073, "epss_percentile": 0.22555}, "CVE-2025-6437": {"epss_score": 0.00068, "epss_percentile": 0.21352}, "CVE-2025-6438": {"epss_score": 0.00047, "epss_percentile": 0.14575}, "CVE-2025-6439": {"epss_score": 0.01074, "epss_percentile": 0.77297}, "CVE-2025-6440": {"epss_score": 0.00096, "epss_percentile": 0.27319}, "CVE-2025-6441": {"epss_score": 0.00654, "epss_percentile": 0.70356}, "CVE-2025-6442": {"epss_score": 0.00044, "epss_percentile": 0.1367}, "CVE-2025-6443": {"epss_score": 0.00284, "epss_percentile": 0.51446}, "CVE-2025-6444": {"epss_score": 0.00042, "epss_percentile": 0.12648}, "CVE-2025-6445": {"epss_score": 0.00258, "epss_percentile": 0.48977}, "CVE-2025-6446": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6447": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6448": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6449": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6450": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6451": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6452": {"epss_score": 0.00054, "epss_percentile": 0.1734}, "CVE-2025-6453": {"epss_score": 0.00056, "epss_percentile": 0.17716}, "CVE-2025-6454": {"epss_score": 0.00023, "epss_percentile": 0.05492}, "CVE-2025-6455": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6456": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6457": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6458": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6459": {"epss_score": 0.00018, "epss_percentile": 0.03687}, "CVE-2025-6462": {"epss_score": 0.00024, "epss_percentile": 0.05667}, "CVE-2025-6463": {"epss_score": 0.00281, "epss_percentile": 0.5114}, "CVE-2025-6464": {"epss_score": 0.00557, "epss_percentile": 0.67536}, "CVE-2025-6465": {"epss_score": 0.00079, "epss_percentile": 0.23997}, "CVE-2025-6466": {"epss_score": 0.00074, "epss_percentile": 0.22873}, "CVE-2025-6467": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6468": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6469": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6470": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6471": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6472": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6473": {"epss_score": 0.00035, "epss_percentile": 0.0998}, "CVE-2025-6474": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6475": {"epss_score": 0.00023, "epss_percentile": 0.05422}, "CVE-2025-6476": {"epss_score": 0.00049, "epss_percentile": 0.15376}, "CVE-2025-6477": {"epss_score": 0.00032, "epss_percentile": 0.08968}, "CVE-2025-6478": {"epss_score": 0.00027, "epss_percentile": 0.06813}, "CVE-2025-6479": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6480": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6481": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6482": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6483": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6484": {"epss_score": 0.00064, "epss_percentile": 0.20305}, "CVE-2025-6485": {"epss_score": 0.03072, "epss_percentile": 0.86349}, "CVE-2025-6486": {"epss_score": 0.00218, "epss_percentile": 0.44423}, "CVE-2025-6487": {"epss_score": 0.00218, "epss_percentile": 0.44423}, "CVE-2025-6488": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-6489": {"epss_score": 0.00035, "epss_percentile": 0.09944}, "CVE-2025-6490": {"epss_score": 0.00016, "epss_percentile": 0.02641}, "CVE-2025-6491": {"epss_score": 0.00136, "epss_percentile": 0.34089}, "CVE-2025-6492": {"epss_score": 0.00051, "epss_percentile": 0.16014}, "CVE-2025-6493": {"epss_score": 0.00045, "epss_percentile": 0.13976}, "CVE-2025-6494": {"epss_score": 0.00016, "epss_percentile": 0.02641}, "CVE-2025-6495": {"epss_score": 0.00098, "epss_percentile": 0.27706}, "CVE-2025-6496": {"epss_score": 0.00016, "epss_percentile": 0.02616}, "CVE-2025-6497": {"epss_score": 0.00013, "epss_percentile": 0.01693}, "CVE-2025-6498": {"epss_score": 0.0003, "epss_percentile": 0.08204}, "CVE-2025-6499": {"epss_score": 0.0003, "epss_percentile": 0.08204}, "CVE-2025-6500": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6501": {"epss_score": 0.00026, "epss_percentile": 0.06459}, "CVE-2025-6502": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6503": {"epss_score": 0.00026, "epss_percentile": 0.06459}, "CVE-2025-6504": {"epss_score": 0.00011, "epss_percentile": 0.01114}, "CVE-2025-6505": {"epss_score": 0.0003, "epss_percentile": 0.08218}, "CVE-2025-6507": {"epss_score": 0.00175, "epss_percentile": 0.39307}, "CVE-2025-6509": {"epss_score": 0.00029, "epss_percentile": 0.07614}, "CVE-2025-6510": {"epss_score": 0.00211, "epss_percentile": 0.43715}, "CVE-2025-6511": {"epss_score": 0.00211, "epss_percentile": 0.43715}, "CVE-2025-6512": {"epss_score": 0.00055, "epss_percentile": 0.17651}, "CVE-2025-6513": {"epss_score": 0.00018, "epss_percentile": 0.03839}, "CVE-2025-6514": {"epss_score": 0.00727, "epss_percentile": 0.72095}, "CVE-2025-6515": {"epss_score": 0.00046, "epss_percentile": 0.14386}, "CVE-2025-6516": {"epss_score": 0.0003, "epss_percentile": 0.08114}, "CVE-2025-6517": {"epss_score": 0.00056, "epss_percentile": 0.17685}, "CVE-2025-6518": {"epss_score": 0.00012, "epss_percentile": 0.01162}, "CVE-2025-6519": {"epss_score": 0.0008, "epss_percentile": 0.24141}, "CVE-2025-6520": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-6521": {"epss_score": 5e-05, "epss_percentile": 0.00234}, "CVE-2025-6522": {"epss_score": 0.00055, "epss_percentile": 0.17599}, "CVE-2025-6523": {"epss_score": 0.00136, "epss_percentile": 0.34159}, "CVE-2025-6524": {"epss_score": 0.00019, "epss_percentile": 0.04352}, "CVE-2025-6525": {"epss_score": 0.00015, "epss_percentile": 0.02282}, "CVE-2025-6526": {"epss_score": 0.00031, "epss_percentile": 0.08466}, "CVE-2025-6527": {"epss_score": 0.00031, "epss_percentile": 0.08691}, "CVE-2025-6528": {"epss_score": 0.00066, "epss_percentile": 0.20897}, "CVE-2025-6529": {"epss_score": 0.00149, "epss_percentile": 0.35992}, "CVE-2025-6530": {"epss_score": 0.00052, "epss_percentile": 0.16515}, "CVE-2025-6531": {"epss_score": 0.00017, "epss_percentile": 0.03131}, "CVE-2025-6532": {"epss_score": 0.00037, "epss_percentile": 0.10878}, "CVE-2025-6533": {"epss_score": 0.00113, "epss_percentile": 0.30611}, "CVE-2025-6534": {"epss_score": 0.00056, "epss_percentile": 0.17719}, "CVE-2025-6535": {"epss_score": 0.00025, "epss_percentile": 0.06233}, "CVE-2025-6536": {"epss_score": 0.00013, "epss_percentile": 0.01693}, "CVE-2025-6537": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-6538": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-6539": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6540": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6541": {"epss_score": 0.00071, "epss_percentile": 0.22141}, "CVE-2025-6542": {"epss_score": 0.0012, "epss_percentile": 0.31787}, "CVE-2025-6543": {"epss_score": 0.03048, "epss_percentile": 0.86285}, "CVE-2025-6544": {"epss_score": 0.00205, "epss_percentile": 0.42725}, "CVE-2025-6545": {"epss_score": 0.00099, "epss_percentile": 0.27844}, "CVE-2025-6546": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-6547": {"epss_score": 0.00078, "epss_percentile": 0.23796}, "CVE-2025-6549": {"epss_score": 0.00036, "epss_percentile": 0.10372}, "CVE-2025-6550": {"epss_score": 0.00063, "epss_percentile": 0.1986}, "CVE-2025-6551": {"epss_score": 0.00027, "epss_percentile": 0.06985}, "CVE-2025-6552": {"epss_score": 0.00039, "epss_percentile": 0.1171}, "CVE-2025-6553": {"epss_score": 0.00192, "epss_percentile": 0.41339}, "CVE-2025-6554": {"epss_score": 0.00369, "epss_percentile": 0.58267}, "CVE-2025-6555": {"epss_score": 0.00041, "epss_percentile": 0.12285}, "CVE-2025-6556": {"epss_score": 0.00014, "epss_percentile": 0.01851}, "CVE-2025-6557": {"epss_score": 0.00049, "epss_percentile": 0.155}, "CVE-2025-6558": {"epss_score": 0.00094, "epss_percentile": 0.27072}, "CVE-2025-6559": {"epss_score": 0.00526, "epss_percentile": 0.66407}, "CVE-2025-6560": {"epss_score": 0.00159, "epss_percentile": 0.37307}, "CVE-2025-6561": {"epss_score": 0.00159, "epss_percentile": 0.37307}, "CVE-2025-6562": {"epss_score": 0.00265, "epss_percentile": 0.49814}, "CVE-2025-6563": {"epss_score": 0.0028, "epss_percentile": 0.51003}, "CVE-2025-6565": {"epss_score": 0.00234, "epss_percentile": 0.46165}, "CVE-2025-6566": {"epss_score": 0.00178, "epss_percentile": 0.39693}, "CVE-2025-6567": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6568": {"epss_score": 0.00312, "epss_percentile": 0.53947}, "CVE-2025-6569": {"epss_score": 0.00035, "epss_percentile": 0.0998}, "CVE-2025-6570": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6571": {"epss_score": 0.00016, "epss_percentile": 0.02834}, "CVE-2025-6572": {"epss_score": 0.00023, "epss_percentile": 0.05329}, "CVE-2025-6573": {"epss_score": 0.00083, "epss_percentile": 0.24604}, "CVE-2025-6574": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-6575": {"epss_score": 0.00039, "epss_percentile": 0.1186}, "CVE-2025-6578": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6579": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6580": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6581": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6582": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6583": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6585": {"epss_score": 0.00086, "epss_percentile": 0.25294}, "CVE-2025-6586": {"epss_score": 0.00079, "epss_percentile": 0.23862}, "CVE-2025-6587": {"epss_score": 0.00024, "epss_percentile": 0.05851}, "CVE-2025-6588": {"epss_score": 0.00106, "epss_percentile": 0.29506}, "CVE-2025-6599": {"epss_score": 0.0006, "epss_percentile": 0.19196}, "CVE-2025-6600": {"epss_score": 0.00022, "epss_percentile": 0.04952}, "CVE-2025-6601": {"epss_score": 0.0002, "epss_percentile": 0.04675}, "CVE-2025-6603": {"epss_score": 0.00015, "epss_percentile": 0.02163}, "CVE-2025-6604": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6605": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6606": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6607": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6608": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6609": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6610": {"epss_score": 0.00026, "epss_percentile": 0.0644}, "CVE-2025-6611": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6612": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6613": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-6614": {"epss_score": 0.00156, "epss_percentile": 0.37007}, "CVE-2025-6615": {"epss_score": 0.00156, "epss_percentile": 0.37007}, "CVE-2025-6616": {"epss_score": 0.00156, "epss_percentile": 0.37007}, "CVE-2025-6617": {"epss_score": 0.00161, "epss_percentile": 0.37563}, "CVE-2025-6618": {"epss_score": 0.01267, "epss_percentile": 0.79014}, "CVE-2025-6619": {"epss_score": 0.01267, "epss_percentile": 0.79014}, "CVE-2025-6620": {"epss_score": 0.01267, "epss_percentile": 0.79014}, "CVE-2025-6621": {"epss_score": 0.01267, "epss_percentile": 0.79014}, "CVE-2025-6624": {"epss_score": 0.00022, "epss_percentile": 0.05043}, "CVE-2025-6625": {"epss_score": 0.00151, "epss_percentile": 0.36204}, "CVE-2025-6626": {"epss_score": 0.00018, "epss_percentile": 0.0405}, "CVE-2025-6627": {"epss_score": 0.00372, "epss_percentile": 0.58419}, "CVE-2025-6631": {"epss_score": 0.00026, "epss_percentile": 0.06478}, "CVE-2025-6632": {"epss_score": 0.00012, "epss_percentile": 0.01427}, "CVE-2025-6633": {"epss_score": 0.00022, "epss_percentile": 0.0504}, "CVE-2025-6634": {"epss_score": 0.00022, "epss_percentile": 0.0504}, "CVE-2025-6635": {"epss_score": 0.00026, "epss_percentile": 0.06478}, "CVE-2025-6636": {"epss_score": 0.00026, "epss_percentile": 0.06478}, "CVE-2025-6637": {"epss_score": 0.00026, "epss_percentile": 0.06478}, "CVE-2025-6638": {"epss_score": 0.00076, "epss_percentile": 0.23246}, "CVE-2025-6639": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-6640": {"epss_score": 0.00066, "epss_percentile": 0.20901}, "CVE-2025-6641": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6642": {"epss_score": 0.00066, "epss_percentile": 0.20901}, "CVE-2025-6643": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6644": {"epss_score": 0.00066, "epss_percentile": 0.20901}, "CVE-2025-6645": {"epss_score": 0.00066, "epss_percentile": 0.20901}, "CVE-2025-6646": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6647": {"epss_score": 0.00066, "epss_percentile": 0.20901}, "CVE-2025-6648": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6649": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6650": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6651": {"epss_score": 0.00066, "epss_percentile": 0.20901}, "CVE-2025-6652": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6653": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6654": {"epss_score": 0.00066, "epss_percentile": 0.20901}, "CVE-2025-6655": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6656": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6657": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6658": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6659": {"epss_score": 0.00066, "epss_percentile": 0.20901}, "CVE-2025-6660": {"epss_score": 0.00061, "epss_percentile": 0.1927}, "CVE-2025-6661": {"epss_score": 0.00066, "epss_percentile": 0.20901}, "CVE-2025-6662": {"epss_score": 0.00028, "epss_percentile": 0.07323}, "CVE-2025-6663": {"epss_score": 0.00042, "epss_percentile": 0.12746}, "CVE-2025-6664": {"epss_score": 0.00039, "epss_percentile": 0.11774}, "CVE-2025-6665": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6666": {"epss_score": 0.00017, "epss_percentile": 0.03502}, "CVE-2025-6667": {"epss_score": 0.00043, "epss_percentile": 0.13293}, "CVE-2025-6668": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6669": {"epss_score": 0.0004, "epss_percentile": 0.12162}, "CVE-2025-6670": {"epss_score": 0.00022, "epss_percentile": 0.0515}, "CVE-2025-6673": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-6674": {"epss_score": 0.00025, "epss_percentile": 0.06154}, "CVE-2025-6675": {"epss_score": 0.00031, "epss_percentile": 0.0846}, "CVE-2025-6676": {"epss_score": 0.00025, "epss_percentile": 0.06154}, "CVE-2025-6677": {"epss_score": 0.00025, "epss_percentile": 0.06154}, "CVE-2025-6678": {"epss_score": 0.00339, "epss_percentile": 0.56164}, "CVE-2025-6679": {"epss_score": 0.00227, "epss_percentile": 0.45367}, "CVE-2025-6680": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-6681": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6685": {"epss_score": 0.00726, "epss_percentile": 0.72082}, "CVE-2025-6686": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-6687": {"epss_score": 0.00024, "epss_percentile": 0.05997}, "CVE-2025-6688": {"epss_score": 0.00461, "epss_percentile": 0.63541}, "CVE-2025-6689": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-6690": {"epss_score": 0.00027, "epss_percentile": 0.06804}, "CVE-2025-6691": {"epss_score": 0.00344, "epss_percentile": 0.56524}, "CVE-2025-6692": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6693": {"epss_score": 0.00026, "epss_percentile": 0.0653}, "CVE-2025-6694": {"epss_score": 0.00035, "epss_percentile": 0.10041}, "CVE-2025-6695": {"epss_score": 0.00041, "epss_percentile": 0.1231}, "CVE-2025-6696": {"epss_score": 0.00041, "epss_percentile": 0.1231}, "CVE-2025-6697": {"epss_score": 0.00041, "epss_percentile": 0.1231}, "CVE-2025-6698": {"epss_score": 0.00041, "epss_percentile": 0.1231}, "CVE-2025-6699": {"epss_score": 0.00041, "epss_percentile": 0.1231}, "CVE-2025-6700": {"epss_score": 0.00034, "epss_percentile": 0.09775}, "CVE-2025-6701": {"epss_score": 0.0003, "epss_percentile": 0.08157}, "CVE-2025-6702": {"epss_score": 0.00063, "epss_percentile": 0.19843}, "CVE-2025-6703": {"epss_score": 0.00058, "epss_percentile": 0.18506}, "CVE-2025-6704": {"epss_score": 0.00256, "epss_percentile": 0.48838}, "CVE-2025-6705": {"epss_score": 0.00039, "epss_percentile": 0.11449}, "CVE-2025-6706": {"epss_score": 0.00048, "epss_percentile": 0.15082}, "CVE-2025-6707": {"epss_score": 0.00034, "epss_percentile": 0.09705}, "CVE-2025-6709": {"epss_score": 0.00154, "epss_percentile": 0.36644}, "CVE-2025-6710": {"epss_score": 0.0003, "epss_percentile": 0.08232}, "CVE-2025-6711": {"epss_score": 0.00039, "epss_percentile": 0.1143}, "CVE-2025-6712": {"epss_score": 0.00074, "epss_percentile": 0.22767}, "CVE-2025-6713": {"epss_score": 0.00055, "epss_percentile": 0.17575}, "CVE-2025-6714": {"epss_score": 0.00031, "epss_percentile": 0.085}, "CVE-2025-6715": {"epss_score": 0.00156, "epss_percentile": 0.36961}, "CVE-2025-6716": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6717": {"epss_score": 0.00028, "epss_percentile": 0.07542}, "CVE-2025-6718": {"epss_score": 0.00039, "epss_percentile": 0.11656}, "CVE-2025-6719": {"epss_score": 0.0002, "epss_percentile": 0.04681}, "CVE-2025-6720": {"epss_score": 0.00106, "epss_percentile": 0.2947}, "CVE-2025-6721": {"epss_score": 0.00065, "epss_percentile": 0.20471}, "CVE-2025-6722": {"epss_score": 0.00039, "epss_percentile": 0.11698}, "CVE-2025-6724": {"epss_score": 0.00071, "epss_percentile": 0.22046}, "CVE-2025-6725": {"epss_score": 0.0004, "epss_percentile": 0.12021}, "CVE-2025-6726": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-6729": {"epss_score": 0.00034, "epss_percentile": 0.09581}, "CVE-2025-6730": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-6731": {"epss_score": 0.00061, "epss_percentile": 0.19375}, "CVE-2025-6732": {"epss_score": 0.00217, "epss_percentile": 0.44319}, "CVE-2025-6733": {"epss_score": 0.00217, "epss_percentile": 0.44319}, "CVE-2025-6734": {"epss_score": 0.00217, "epss_percentile": 0.44319}, "CVE-2025-6735": {"epss_score": 0.00049, "epss_percentile": 0.15563}, "CVE-2025-6736": {"epss_score": 0.00049, "epss_percentile": 0.15563}, "CVE-2025-6737": {"epss_score": 0.00054, "epss_percentile": 0.17058}, "CVE-2025-6738": {"epss_score": 0.00025, "epss_percentile": 0.06123}, "CVE-2025-6739": {"epss_score": 0.00028, "epss_percentile": 0.07531}, "CVE-2025-6740": {"epss_score": 0.00185, "epss_percentile": 0.40573}, "CVE-2025-6741": {"epss_score": 0.0004, "epss_percentile": 0.12061}, "CVE-2025-6742": {"epss_score": 0.00373, "epss_percentile": 0.58523}, "CVE-2025-6743": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-6744": {"epss_score": 0.00294, "epss_percentile": 0.5236}, "CVE-2025-6745": {"epss_score": 0.0005, "epss_percentile": 0.15724}, "CVE-2025-6746": {"epss_score": 0.00103, "epss_percentile": 0.29076}, "CVE-2025-6747": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6748": {"epss_score": 8e-05, "epss_percentile": 0.00471}, "CVE-2025-6749": {"epss_score": 0.00025, "epss_percentile": 0.06123}, "CVE-2025-6750": {"epss_score": 0.00032, "epss_percentile": 0.08765}, "CVE-2025-6751": {"epss_score": 0.00231, "epss_percentile": 0.45776}, "CVE-2025-6752": {"epss_score": 0.00167, "epss_percentile": 0.38353}, "CVE-2025-6753": {"epss_score": 0.00025, "epss_percentile": 0.06123}, "CVE-2025-6754": {"epss_score": 0.0006, "epss_percentile": 0.19094}, "CVE-2025-6755": {"epss_score": 0.00526, "epss_percentile": 0.66408}, "CVE-2025-6756": {"epss_score": 0.00028, "epss_percentile": 0.07566}, "CVE-2025-6757": {"epss_score": 0.00055, "epss_percentile": 0.17592}, "CVE-2025-6758": {"epss_score": 0.00187, "epss_percentile": 0.40755}, "CVE-2025-6759": {"epss_score": 0.00015, "epss_percentile": 0.02467}, "CVE-2025-6761": {"epss_score": 0.00046, "epss_percentile": 0.14271}, "CVE-2025-6762": {"epss_score": 0.00041, "epss_percentile": 0.1237}, "CVE-2025-6763": {"epss_score": 0.00974, "epss_percentile": 0.7617}, "CVE-2025-6765": {"epss_score": 0.00032, "epss_percentile": 0.08783}, "CVE-2025-6766": {"epss_score": 0.00031, "epss_percentile": 0.08499}, "CVE-2025-6767": {"epss_score": 0.00025, "epss_percentile": 0.06123}, "CVE-2025-6768": {"epss_score": 0.00025, "epss_percentile": 0.06123}, "CVE-2025-6769": {"epss_score": 0.00018, "epss_percentile": 0.03907}, "CVE-2025-6770": {"epss_score": 0.04205, "epss_percentile": 0.88394}, "CVE-2025-6771": {"epss_score": 0.07973, "epss_percentile": 0.91798}, "CVE-2025-6772": {"epss_score": 0.00261, "epss_percentile": 0.4928}, "CVE-2025-6773": {"epss_score": 0.00011, "epss_percentile": 0.01065}, "CVE-2025-6774": {"epss_score": 0.00064, "epss_percentile": 0.20383}, "CVE-2025-6775": {"epss_score": 0.00479, "epss_percentile": 0.64437}, "CVE-2025-6776": {"epss_score": 0.00059, "epss_percentile": 0.18902}, "CVE-2025-6777": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6778": {"epss_score": 0.00041, "epss_percentile": 0.12355}, "CVE-2025-6779": {"epss_score": 0.00021, "epss_percentile": 0.04847}, "CVE-2025-6781": {"epss_score": 0.00013, "epss_percentile": 0.01492}, "CVE-2025-6782": {"epss_score": 0.00068, "epss_percentile": 0.21352}, "CVE-2025-6783": {"epss_score": 0.00068, "epss_percentile": 0.21352}, "CVE-2025-6785": {"epss_score": 0.00054, "epss_percentile": 0.17086}, "CVE-2025-6786": {"epss_score": 0.00069, "epss_percentile": 0.21598}, "CVE-2025-6787": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-6788": {"epss_score": 0.0006, "epss_percentile": 0.19018}, "CVE-2025-6790": {"epss_score": 0.00026, "epss_percentile": 0.06612}, "CVE-2025-6791": {"epss_score": 0.00018, "epss_percentile": 0.03896}, "CVE-2025-6793": {"epss_score": 0.30197, "epss_percentile": 0.96518}, "CVE-2025-6794": {"epss_score": 0.19643, "epss_percentile": 0.95219}, "CVE-2025-6795": {"epss_score": 0.01042, "epss_percentile": 0.76979}, "CVE-2025-6796": {"epss_score": 0.22476, "epss_percentile": 0.95642}, "CVE-2025-6797": {"epss_score": 0.22476, "epss_percentile": 0.95642}, "CVE-2025-6798": {"epss_score": 0.14749, "epss_percentile": 0.94273}, "CVE-2025-6799": {"epss_score": 0.22476, "epss_percentile": 0.95642}, "CVE-2025-6800": {"epss_score": 0.22476, "epss_percentile": 0.95642}, "CVE-2025-6801": {"epss_score": 0.02042, "epss_percentile": 0.83375}, "CVE-2025-6802": {"epss_score": 0.04365, "epss_percentile": 0.88601}, "CVE-2025-6803": {"epss_score": 0.22476, "epss_percentile": 0.95642}, "CVE-2025-6804": {"epss_score": 0.22476, "epss_percentile": 0.95642}, "CVE-2025-6805": {"epss_score": 0.14749, "epss_percentile": 0.94273}, "CVE-2025-6806": {"epss_score": 0.02042, "epss_percentile": 0.83375}, "CVE-2025-6807": {"epss_score": 0.01042, "epss_percentile": 0.76979}, "CVE-2025-6810": {"epss_score": 0.00717, "epss_percentile": 0.71883}, "CVE-2025-6811": {"epss_score": 0.00663, "epss_percentile": 0.7061}, "CVE-2025-6813": {"epss_score": 0.00053, "epss_percentile": 0.16729}, "CVE-2025-6814": {"epss_score": 0.00108, "epss_percentile": 0.29849}, "CVE-2025-6815": {"epss_score": 0.00039, "epss_percentile": 0.1179}, "CVE-2025-6816": {"epss_score": 0.00032, "epss_percentile": 0.08765}, "CVE-2025-6817": {"epss_score": 0.00032, "epss_percentile": 0.08765}, "CVE-2025-6818": {"epss_score": 0.0003, "epss_percentile": 0.08181}, "CVE-2025-6819": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6820": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6821": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6822": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6823": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6824": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6825": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6826": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6827": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6828": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6829": {"epss_score": 0.0004, "epss_percentile": 0.12162}, "CVE-2025-6831": {"epss_score": 0.00041, "epss_percentile": 0.12309}, "CVE-2025-6832": {"epss_score": 0.0009, "epss_percentile": 0.25989}, "CVE-2025-6833": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-6834": {"epss_score": 0.0004, "epss_percentile": 0.12033}, "CVE-2025-6835": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6836": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6837": {"epss_score": 0.00053, "epss_percentile": 0.16928}, "CVE-2025-6838": {"epss_score": 0.00028, "epss_percentile": 0.07348}, "CVE-2025-6839": {"epss_score": 0.00049, "epss_percentile": 0.15576}, "CVE-2025-6840": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6841": {"epss_score": 0.00026, "epss_percentile": 0.0644}, "CVE-2025-6842": {"epss_score": 0.00026, "epss_percentile": 0.0644}, "CVE-2025-6843": {"epss_score": 0.00056, "epss_percentile": 0.17811}, "CVE-2025-6844": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6845": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6846": {"epss_score": 0.00028, "epss_percentile": 0.0752}, "CVE-2025-6847": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6848": {"epss_score": 0.00045, "epss_percentile": 0.13814}, "CVE-2025-6849": {"epss_score": 0.00036, "epss_percentile": 0.10292}, "CVE-2025-6850": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6851": {"epss_score": 0.01187, "epss_percentile": 0.78354}, "CVE-2025-6853": {"epss_score": 0.00087, "epss_percentile": 0.25463}, "CVE-2025-6854": {"epss_score": 0.00083, "epss_percentile": 0.24764}, "CVE-2025-6855": {"epss_score": 0.00087, "epss_percentile": 0.25503}, "CVE-2025-6856": {"epss_score": 0.0003, "epss_percentile": 0.08181}, "CVE-2025-6857": {"epss_score": 0.0003, "epss_percentile": 0.08181}, "CVE-2025-6858": {"epss_score": 0.0003, "epss_percentile": 0.08301}, "CVE-2025-6859": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6860": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6861": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6862": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6863": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6864": {"epss_score": 0.00037, "epss_percentile": 0.10833}, "CVE-2025-6865": {"epss_score": 0.00048, "epss_percentile": 0.15074}, "CVE-2025-6866": {"epss_score": 0.00081, "epss_percentile": 0.24357}, "CVE-2025-6867": {"epss_score": 0.00027, "epss_percentile": 0.07155}, "CVE-2025-6868": {"epss_score": 0.00027, "epss_percentile": 0.07155}, "CVE-2025-6869": {"epss_score": 0.00037, "epss_percentile": 0.1089}, "CVE-2025-6870": {"epss_score": 0.00071, "epss_percentile": 0.22133}, "CVE-2025-6871": {"epss_score": 0.00041, "epss_percentile": 0.12223}, "CVE-2025-6872": {"epss_score": 0.00071, "epss_percentile": 0.21995}, "CVE-2025-6873": {"epss_score": 0.00071, "epss_percentile": 0.21995}, "CVE-2025-6874": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6875": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6876": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6877": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6878": {"epss_score": 0.00038, "epss_percentile": 0.11328}, "CVE-2025-6879": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6880": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6881": {"epss_score": 0.00158, "epss_percentile": 0.37178}, "CVE-2025-6882": {"epss_score": 0.00166, "epss_percentile": 0.38192}, "CVE-2025-6883": {"epss_score": 0.00026, "epss_percentile": 0.06515}, "CVE-2025-6884": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6885": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6886": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-6887": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-6888": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6889": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6890": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6891": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6892": {"epss_score": 0.00091, "epss_percentile": 0.26392}, "CVE-2025-6893": {"epss_score": 0.00087, "epss_percentile": 0.25559}, "CVE-2025-6894": {"epss_score": 0.00094, "epss_percentile": 0.27038}, "CVE-2025-6895": {"epss_score": 0.00666, "epss_percentile": 0.70691}, "CVE-2025-6896": {"epss_score": 0.00068, "epss_percentile": 0.21317}, "CVE-2025-6897": {"epss_score": 0.00095, "epss_percentile": 0.27138}, "CVE-2025-6898": {"epss_score": 0.00061, "epss_percentile": 0.19432}, "CVE-2025-6899": {"epss_score": 0.00071, "epss_percentile": 0.21994}, "CVE-2025-6900": {"epss_score": 0.00053, "epss_percentile": 0.16928}, "CVE-2025-6901": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6902": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6903": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6904": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6905": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6906": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6907": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6908": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6909": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6910": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6911": {"epss_score": 0.00025, "epss_percentile": 0.06214}, "CVE-2025-6912": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6913": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6914": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6915": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-6916": {"epss_score": 0.00167, "epss_percentile": 0.38342}, "CVE-2025-6917": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-6918": {"epss_score": 0.00036, "epss_percentile": 0.10226}, "CVE-2025-6919": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-6920": {"epss_score": 0.00044, "epss_percentile": 0.13672}, "CVE-2025-6921": {"epss_score": 0.00076, "epss_percentile": 0.23246}, "CVE-2025-6923": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-6924": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-6925": {"epss_score": 0.00246, "epss_percentile": 0.47777}, "CVE-2025-6926": {"epss_score": 0.00085, "epss_percentile": 0.25188}, "CVE-2025-6929": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6930": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-6931": {"epss_score": 0.00059, "epss_percentile": 0.18669}, "CVE-2025-6932": {"epss_score": 0.00052, "epss_percentile": 0.16639}, "CVE-2025-6934": {"epss_score": 0.1748, "epss_percentile": 0.94856}, "CVE-2025-6935": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6936": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6937": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6938": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6939": {"epss_score": 0.00218, "epss_percentile": 0.44423}, "CVE-2025-6940": {"epss_score": 0.00312, "epss_percentile": 0.53947}, "CVE-2025-6941": {"epss_score": 0.00045, "epss_percentile": 0.13997}, "CVE-2025-6942": {"epss_score": 0.00013, "epss_percentile": 0.01486}, "CVE-2025-6943": {"epss_score": 0.00014, "epss_percentile": 0.02103}, "CVE-2025-6944": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-6945": {"epss_score": 0.00036, "epss_percentile": 0.10389}, "CVE-2025-6946": {"epss_score": 0.00028, "epss_percentile": 0.07536}, "CVE-2025-6947": {"epss_score": 0.00084, "epss_percentile": 0.2491}, "CVE-2025-6948": {"epss_score": 0.00032, "epss_percentile": 0.09008}, "CVE-2025-6949": {"epss_score": 0.00094, "epss_percentile": 0.27038}, "CVE-2025-6950": {"epss_score": 0.00353, "epss_percentile": 0.57167}, "CVE-2025-6951": {"epss_score": 0.00016, "epss_percentile": 0.02692}, "CVE-2025-6952": {"epss_score": 0.00014, "epss_percentile": 0.01768}, "CVE-2025-6953": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-6954": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6955": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6956": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6957": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6958": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6959": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6960": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6961": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6962": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6963": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-6965": {"epss_score": 0.00057, "epss_percentile": 0.18023}, "CVE-2025-6966": {"epss_score": 0.00015, "epss_percentile": 0.02558}, "CVE-2025-6970": {"epss_score": 0.29945, "epss_percentile": 0.96489}, "CVE-2025-6971": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2025-6972": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2025-6973": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2025-6974": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2025-6975": {"epss_score": 0.00118, "epss_percentile": 0.31424}, "CVE-2025-6976": {"epss_score": 0.00041, "epss_percentile": 0.12459}, "CVE-2025-6977": {"epss_score": 0.00207, "epss_percentile": 0.43203}, "CVE-2025-6978": {"epss_score": 0.00238, "epss_percentile": 0.46769}, "CVE-2025-6979": {"epss_score": 0.00092, "epss_percentile": 0.26461}, "CVE-2025-6980": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-6981": {"epss_score": 0.00036, "epss_percentile": 0.10377}, "CVE-2025-6982": {"epss_score": 0.00023, "epss_percentile": 0.05408}, "CVE-2025-6983": {"epss_score": 0.00058, "epss_percentile": 0.18613}, "CVE-2025-6984": {"epss_score": 0.00073, "epss_percentile": 0.22488}, "CVE-2025-6985": {"epss_score": 0.00651, "epss_percentile": 0.7029}, "CVE-2025-6986": {"epss_score": 0.00023, "epss_percentile": 0.05359}, "CVE-2025-6987": {"epss_score": 0.00041, "epss_percentile": 0.12309}, "CVE-2025-6988": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-6989": {"epss_score": 0.00091, "epss_percentile": 0.26209}, "CVE-2025-6990": {"epss_score": 0.00389, "epss_percentile": 0.59467}, "CVE-2025-6991": {"epss_score": 0.00062, "epss_percentile": 0.19723}, "CVE-2025-6993": {"epss_score": 0.00056, "epss_percentile": 0.17675}, "CVE-2025-6994": {"epss_score": 0.00155, "epss_percentile": 0.36816}, "CVE-2025-6995": {"epss_score": 0.00047, "epss_percentile": 0.14622}, "CVE-2025-6996": {"epss_score": 0.00047, "epss_percentile": 0.14622}, "CVE-2025-6997": {"epss_score": 0.00016, "epss_percentile": 0.02616}, "CVE-2025-6998": {"epss_score": 0.00049, "epss_percentile": 0.15632}, "CVE-2025-6999": {"epss_score": 0.00262, "epss_percentile": 0.49382}, "CVE-2025-7000": {"epss_score": 0.00016, "epss_percentile": 0.02731}, "CVE-2025-7001": {"epss_score": 0.00014, "epss_percentile": 0.01924}, "CVE-2025-7007": {"epss_score": 0.00015, "epss_percentile": 0.0246}, "CVE-2025-7012": {"epss_score": 0.00021, "epss_percentile": 0.04755}, "CVE-2025-7020": {"epss_score": 0.00015, "epss_percentile": 0.02254}, "CVE-2025-7021": {"epss_score": 0.00046, "epss_percentile": 0.14088}, "CVE-2025-7022": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-7025": {"epss_score": 0.00019, "epss_percentile": 0.04089}, "CVE-2025-7026": {"epss_score": 0.00018, "epss_percentile": 0.03518}, "CVE-2025-7027": {"epss_score": 0.00018, "epss_percentile": 0.03518}, "CVE-2025-7028": {"epss_score": 0.00019, "epss_percentile": 0.04196}, "CVE-2025-7029": {"epss_score": 0.00027, "epss_percentile": 0.0677}, "CVE-2025-7030": {"epss_score": 0.00066, "epss_percentile": 0.20691}, "CVE-2025-7031": {"epss_score": 0.00035, "epss_percentile": 0.10069}, "CVE-2025-7032": {"epss_score": 0.00019, "epss_percentile": 0.04089}, "CVE-2025-7033": {"epss_score": 0.00019, "epss_percentile": 0.04089}, "CVE-2025-7035": {"epss_score": 0.00032, "epss_percentile": 0.08792}, "CVE-2025-7036": {"epss_score": 0.00082, "epss_percentile": 0.24577}, "CVE-2025-7037": {"epss_score": 0.00328, "epss_percentile": 0.55187}, "CVE-2025-7038": {"epss_score": 0.00435, "epss_percentile": 0.62376}, "CVE-2025-7039": {"epss_score": 0.00103, "epss_percentile": 0.2907}, "CVE-2025-7040": {"epss_score": 0.001, "epss_percentile": 0.28491}, "CVE-2025-7042": {"epss_score": 0.00016, "epss_percentile": 0.02865}, "CVE-2025-7044": {"epss_score": 0.00036, "epss_percentile": 0.105}, "CVE-2025-7045": {"epss_score": 0.00447, "epss_percentile": 0.62964}, "CVE-2025-7046": {"epss_score": 0.00028, "epss_percentile": 0.07566}, "CVE-2025-7047": {"epss_score": 0.00028, "epss_percentile": 0.07469}, "CVE-2025-7048": {"epss_score": 8e-05, "epss_percentile": 0.00582}, "CVE-2025-7049": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-7050": {"epss_score": 0.00099, "epss_percentile": 0.27864}, "CVE-2025-7051": {"epss_score": 0.00073, "epss_percentile": 0.22664}, "CVE-2025-7052": {"epss_score": 0.00024, "epss_percentile": 0.05687}, "CVE-2025-7053": {"epss_score": 0.00035, "epss_percentile": 0.0991}, "CVE-2025-7054": {"epss_score": 0.00026, "epss_percentile": 0.06674}, "CVE-2025-7056": {"epss_score": 0.00029, "epss_percentile": 0.07813}, "CVE-2025-7057": {"epss_score": 0.00024, "epss_percentile": 0.05765}, "CVE-2025-7058": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-7059": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-7060": {"epss_score": 0.00076, "epss_percentile": 0.23231}, "CVE-2025-7061": {"epss_score": 0.00041, "epss_percentile": 0.12314}, "CVE-2025-7063": {"epss_score": 0.00265, "epss_percentile": 0.49796}, "CVE-2025-7065": {"epss_score": 0.00265, "epss_percentile": 0.49796}, "CVE-2025-7066": {"epss_score": 0.00024, "epss_percentile": 0.05767}, "CVE-2025-7067": {"epss_score": 0.0003, "epss_percentile": 0.08301}, "CVE-2025-7068": {"epss_score": 0.0003, "epss_percentile": 0.08301}, "CVE-2025-7069": {"epss_score": 0.0003, "epss_percentile": 0.08301}, "CVE-2025-7070": {"epss_score": 0.00137, "epss_percentile": 0.34269}, "CVE-2025-7071": {"epss_score": 0.00012, "epss_percentile": 0.01181}, "CVE-2025-7073": {"epss_score": 0.00043, "epss_percentile": 0.13237}, "CVE-2025-7074": {"epss_score": 0.00104, "epss_percentile": 0.29213}, "CVE-2025-7075": {"epss_score": 0.00036, "epss_percentile": 0.10369}, "CVE-2025-7076": {"epss_score": 0.00133, "epss_percentile": 0.33677}, "CVE-2025-7077": {"epss_score": 0.00285, "epss_percentile": 0.51649}, "CVE-2025-7078": {"epss_score": 0.00048, "epss_percentile": 0.15074}, "CVE-2025-7079": {"epss_score": 0.00047, "epss_percentile": 0.14776}, "CVE-2025-7080": {"epss_score": 0.00032, "epss_percentile": 0.09115}, "CVE-2025-7081": {"epss_score": 0.00379, "epss_percentile": 0.58906}, "CVE-2025-7082": {"epss_score": 0.00379, "epss_percentile": 0.58906}, "CVE-2025-7083": {"epss_score": 0.00218, "epss_percentile": 0.44357}, "CVE-2025-7084": {"epss_score": 0.00377, "epss_percentile": 0.58732}, "CVE-2025-7085": {"epss_score": 0.00212, "epss_percentile": 0.43723}, "CVE-2025-7086": {"epss_score": 0.00212, "epss_percentile": 0.43723}, "CVE-2025-7087": {"epss_score": 0.00212, "epss_percentile": 0.43723}, "CVE-2025-7088": {"epss_score": 0.00212, "epss_percentile": 0.43723}, "CVE-2025-7089": {"epss_score": 0.00212, "epss_percentile": 0.43723}, "CVE-2025-7090": {"epss_score": 0.00275, "epss_percentile": 0.50644}, "CVE-2025-7091": {"epss_score": 0.00275, "epss_percentile": 0.50644}, "CVE-2025-7092": {"epss_score": 0.00275, "epss_percentile": 0.50644}, "CVE-2025-7093": {"epss_score": 0.00275, "epss_percentile": 0.50644}, "CVE-2025-7094": {"epss_score": 0.0021, "epss_percentile": 0.43456}, "CVE-2025-7095": {"epss_score": 0.00027, "epss_percentile": 0.06944}, "CVE-2025-7096": {"epss_score": 0.00104, "epss_percentile": 0.29185}, "CVE-2025-7097": {"epss_score": 0.01076, "epss_percentile": 0.77327}, "CVE-2025-7098": {"epss_score": 0.00154, "epss_percentile": 0.36655}, "CVE-2025-7099": {"epss_score": 0.00042, "epss_percentile": 0.12477}, "CVE-2025-7100": {"epss_score": 0.00048, "epss_percentile": 0.15055}, "CVE-2025-7101": {"epss_score": 0.00045, "epss_percentile": 0.13788}, "CVE-2025-7102": {"epss_score": 0.00029, "epss_percentile": 0.07693}, "CVE-2025-7103": {"epss_score": 0.00034, "epss_percentile": 0.09583}, "CVE-2025-7104": {"epss_score": 0.00052, "epss_percentile": 0.1636}, "CVE-2025-7106": {"epss_score": 0.00043, "epss_percentile": 0.13101}, "CVE-2025-7107": {"epss_score": 0.00121, "epss_percentile": 0.31824}, "CVE-2025-7108": {"epss_score": 0.00055, "epss_percentile": 0.17418}, "CVE-2025-7109": {"epss_score": 0.00024, "epss_percentile": 0.05953}, "CVE-2025-7110": {"epss_score": 0.00024, "epss_percentile": 0.05953}, "CVE-2025-7111": {"epss_score": 0.00024, "epss_percentile": 0.05953}, "CVE-2025-7112": {"epss_score": 0.00024, "epss_percentile": 0.05953}, "CVE-2025-7113": {"epss_score": 0.00024, "epss_percentile": 0.05953}, "CVE-2025-7114": {"epss_score": 0.00163, "epss_percentile": 0.37862}, "CVE-2025-7115": {"epss_score": 0.00058, "epss_percentile": 0.1853}, "CVE-2025-7116": {"epss_score": 0.00217, "epss_percentile": 0.44319}, "CVE-2025-7117": {"epss_score": 0.00217, "epss_percentile": 0.44319}, "CVE-2025-7118": {"epss_score": 0.00217, "epss_percentile": 0.44319}, "CVE-2025-7119": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7120": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7121": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7122": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7123": {"epss_score": 0.00039, "epss_percentile": 0.11625}, "CVE-2025-7124": {"epss_score": 0.00059, "epss_percentile": 0.18693}, "CVE-2025-7125": {"epss_score": 0.00034, "epss_percentile": 0.09545}, "CVE-2025-7126": {"epss_score": 0.00034, "epss_percentile": 0.09545}, "CVE-2025-7127": {"epss_score": 0.00035, "epss_percentile": 0.09912}, "CVE-2025-7128": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7129": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7130": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7131": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7132": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7133": {"epss_score": 0.00028, "epss_percentile": 0.07224}, "CVE-2025-7134": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7135": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7136": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7137": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7138": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7139": {"epss_score": 0.00035, "epss_percentile": 0.10144}, "CVE-2025-7140": {"epss_score": 0.00035, "epss_percentile": 0.10144}, "CVE-2025-7141": {"epss_score": 0.00035, "epss_percentile": 0.10144}, "CVE-2025-7142": {"epss_score": 0.00035, "epss_percentile": 0.10144}, "CVE-2025-7143": {"epss_score": 0.00035, "epss_percentile": 0.10144}, "CVE-2025-7144": {"epss_score": 0.00043, "epss_percentile": 0.13361}, "CVE-2025-7145": {"epss_score": 0.00333, "epss_percentile": 0.55632}, "CVE-2025-7146": {"epss_score": 0.00099, "epss_percentile": 0.27869}, "CVE-2025-7147": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7148": {"epss_score": 0.00043, "epss_percentile": 0.1295}, "CVE-2025-7149": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7150": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7151": {"epss_score": 0.00059, "epss_percentile": 0.18693}, "CVE-2025-7152": {"epss_score": 0.00059, "epss_percentile": 0.18693}, "CVE-2025-7153": {"epss_score": 0.00043, "epss_percentile": 0.1295}, "CVE-2025-7154": {"epss_score": 0.00858, "epss_percentile": 0.74509}, "CVE-2025-7155": {"epss_score": 0.00037, "epss_percentile": 0.10706}, "CVE-2025-7156": {"epss_score": 0.00025, "epss_percentile": 0.06123}, "CVE-2025-7157": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7158": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7159": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7160": {"epss_score": 0.01666, "epss_percentile": 0.81654}, "CVE-2025-7161": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7162": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7163": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7164": {"epss_score": 0.00042, "epss_percentile": 0.12591}, "CVE-2025-7165": {"epss_score": 0.00042, "epss_percentile": 0.12591}, "CVE-2025-7166": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7167": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7168": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7169": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7170": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7171": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7172": {"epss_score": 0.0004, "epss_percentile": 0.12033}, "CVE-2025-7173": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7174": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7175": {"epss_score": 0.00054, "epss_percentile": 0.17146}, "CVE-2025-7176": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7177": {"epss_score": 0.00035, "epss_percentile": 0.09912}, "CVE-2025-7178": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7179": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7180": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7181": {"epss_score": 0.00062, "epss_percentile": 0.19671}, "CVE-2025-7182": {"epss_score": 0.00047, "epss_percentile": 0.14925}, "CVE-2025-7183": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7184": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7185": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7186": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7187": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7188": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7189": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7190": {"epss_score": 0.00043, "epss_percentile": 0.13293}, "CVE-2025-7191": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7192": {"epss_score": 0.00068, "epss_percentile": 0.21317}, "CVE-2025-7193": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7194": {"epss_score": 0.00144, "epss_percentile": 0.35263}, "CVE-2025-7195": {"epss_score": 6e-05, "epss_percentile": 0.00248}, "CVE-2025-7196": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7197": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7198": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7199": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7200": {"epss_score": 0.00031, "epss_percentile": 0.08499}, "CVE-2025-7202": {"epss_score": 0.00023, "epss_percentile": 0.05427}, "CVE-2025-7204": {"epss_score": 0.00052, "epss_percentile": 0.16466}, "CVE-2025-7205": {"epss_score": 0.00032, "epss_percentile": 0.08751}, "CVE-2025-7206": {"epss_score": 0.00573, "epss_percentile": 0.68058}, "CVE-2025-7207": {"epss_score": 0.00026, "epss_percentile": 0.06548}, "CVE-2025-7208": {"epss_score": 0.00036, "epss_percentile": 0.10258}, "CVE-2025-7209": {"epss_score": 0.00016, "epss_percentile": 0.02641}, "CVE-2025-7210": {"epss_score": 0.00047, "epss_percentile": 0.14915}, "CVE-2025-7211": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7212": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7213": {"epss_score": 0.00018, "epss_percentile": 0.03898}, "CVE-2025-7214": {"epss_score": 7e-05, "epss_percentile": 0.00335}, "CVE-2025-7215": {"epss_score": 7e-05, "epss_percentile": 0.00335}, "CVE-2025-7216": {"epss_score": 0.00093, "epss_percentile": 0.26623}, "CVE-2025-7217": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7218": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7219": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7220": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7221": {"epss_score": 0.00045, "epss_percentile": 0.14038}, "CVE-2025-7222": {"epss_score": 0.00066, "epss_percentile": 0.20901}, "CVE-2025-7223": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7224": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7225": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7226": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7227": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7228": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7229": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7230": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7231": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7233": {"epss_score": 0.00019, "epss_percentile": 0.04295}, "CVE-2025-7234": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7235": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7236": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7237": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7238": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7239": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7240": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7241": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7242": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7243": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7244": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7246": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7247": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7248": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7249": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7250": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7251": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7252": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7253": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7254": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7255": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7256": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7257": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7258": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7259": {"epss_score": 0.00105, "epss_percentile": 0.29266}, "CVE-2025-7260": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7261": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7262": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7263": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7264": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7265": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7266": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7267": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7268": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7269": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7270": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7271": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7272": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7273": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7274": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7275": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7276": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7277": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7278": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7279": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7280": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7281": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7282": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7283": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7284": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7285": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7286": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7287": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7288": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7289": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7290": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7291": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7292": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7293": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7294": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7295": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7296": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7297": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7298": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7299": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7300": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7301": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7302": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7303": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7304": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7305": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7306": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7307": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7308": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7309": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7310": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7311": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7312": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7313": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7314": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7315": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7316": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7317": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7318": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7319": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7320": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7321": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7322": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7323": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7324": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7325": {"epss_score": 0.00049, "epss_percentile": 0.15414}, "CVE-2025-7326": {"epss_score": 0.0019, "epss_percentile": 0.41066}, "CVE-2025-7327": {"epss_score": 0.00402, "epss_percentile": 0.60267}, "CVE-2025-7328": {"epss_score": 0.00031, "epss_percentile": 0.08705}, "CVE-2025-7329": {"epss_score": 4e-05, "epss_percentile": 0.00141}, "CVE-2025-7330": {"epss_score": 0.0001, "epss_percentile": 0.00756}, "CVE-2025-7337": {"epss_score": 0.00056, "epss_percentile": 0.17927}, "CVE-2025-7338": {"epss_score": 0.00011, "epss_percentile": 0.01083}, "CVE-2025-7339": {"epss_score": 6e-05, "epss_percentile": 0.00287}, "CVE-2025-7340": {"epss_score": 0.00398, "epss_percentile": 0.60058}, "CVE-2025-7341": {"epss_score": 0.00355, "epss_percentile": 0.573}, "CVE-2025-7342": {"epss_score": 0.00039, "epss_percentile": 0.11432}, "CVE-2025-7343": {"epss_score": 0.00084, "epss_percentile": 0.24966}, "CVE-2025-7344": {"epss_score": 0.00137, "epss_percentile": 0.34233}, "CVE-2025-7345": {"epss_score": 0.00213, "epss_percentile": 0.4385}, "CVE-2025-7346": {"epss_score": 0.00248, "epss_percentile": 0.4794}, "CVE-2025-7350": {"epss_score": 0.00645, "epss_percentile": 0.70108}, "CVE-2025-7353": {"epss_score": 0.00506, "epss_percentile": 0.65633}, "CVE-2025-7354": {"epss_score": 0.00046, "epss_percentile": 0.14075}, "CVE-2025-7355": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-7357": {"epss_score": 0.00058, "epss_percentile": 0.18613}, "CVE-2025-7358": {"epss_score": 0.0006, "epss_percentile": 0.1909}, "CVE-2025-7359": {"epss_score": 0.00638, "epss_percentile": 0.69919}, "CVE-2025-7360": {"epss_score": 0.00588, "epss_percentile": 0.68497}, "CVE-2025-7361": {"epss_score": 0.0002, "epss_percentile": 0.04637}, "CVE-2025-7362": {"epss_score": 0.00016, "epss_percentile": 0.02616}, "CVE-2025-7363": {"epss_score": 0.00024, "epss_percentile": 0.05667}, "CVE-2025-7365": {"epss_score": 0.0001, "epss_percentile": 0.00791}, "CVE-2025-7366": {"epss_score": 0.00437, "epss_percentile": 0.62533}, "CVE-2025-7367": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-7368": {"epss_score": 0.00069, "epss_percentile": 0.21471}, "CVE-2025-7369": {"epss_score": 0.00011, "epss_percentile": 0.0109}, "CVE-2025-7371": {"epss_score": 0.00038, "epss_percentile": 0.11299}, "CVE-2025-7374": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-7376": {"epss_score": 0.00011, "epss_percentile": 0.00995}, "CVE-2025-7378": {"epss_score": 0.0003, "epss_percentile": 0.08297}, "CVE-2025-7379": {"epss_score": 0.00019, "epss_percentile": 0.04158}, "CVE-2025-7380": {"epss_score": 0.00054, "epss_percentile": 0.17294}, "CVE-2025-7381": {"epss_score": 0.00037, "epss_percentile": 0.10864}, "CVE-2025-7382": {"epss_score": 0.00195, "epss_percentile": 0.41629}, "CVE-2025-7383": {"epss_score": 0.00012, "epss_percentile": 0.01181}, "CVE-2025-7384": {"epss_score": 0.01131, "epss_percentile": 0.7786}, "CVE-2025-7385": {"epss_score": 0.00218, "epss_percentile": 0.44437}, "CVE-2025-7387": {"epss_score": 0.00027, "epss_percentile": 0.06856}, "CVE-2025-7388": {"epss_score": 0.00396, "epss_percentile": 0.59903}, "CVE-2025-7390": {"epss_score": 0.00031, "epss_percentile": 0.08591}, "CVE-2025-7392": {"epss_score": 0.00025, "epss_percentile": 0.06154}, "CVE-2025-7393": {"epss_score": 0.00076, "epss_percentile": 0.23094}, "CVE-2025-7394": {"epss_score": 0.00045, "epss_percentile": 0.14041}, "CVE-2025-7395": {"epss_score": 0.00039, "epss_percentile": 0.11552}, "CVE-2025-7396": {"epss_score": 0.0002, "epss_percentile": 0.04643}, "CVE-2025-7397": {"epss_score": 0.00012, "epss_percentile": 0.01336}, "CVE-2025-7398": {"epss_score": 0.00011, "epss_percentile": 0.01074}, "CVE-2025-7399": {"epss_score": 0.00027, "epss_percentile": 0.06804}, "CVE-2025-7400": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-7401": {"epss_score": 0.00412, "epss_percentile": 0.60947}, "CVE-2025-7402": {"epss_score": 0.00092, "epss_percentile": 0.26514}, "CVE-2025-7403": {"epss_score": 0.0002, "epss_percentile": 0.04588}, "CVE-2025-7404": {"epss_score": 0.00043, "epss_percentile": 0.12967}, "CVE-2025-7405": {"epss_score": 0.00216, "epss_percentile": 0.44227}, "CVE-2025-7407": {"epss_score": 0.00378, "epss_percentile": 0.58779}, "CVE-2025-7408": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-7409": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7410": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7411": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7412": {"epss_score": 0.00043, "epss_percentile": 0.13293}, "CVE-2025-7413": {"epss_score": 0.00043, "epss_percentile": 0.13293}, "CVE-2025-7414": {"epss_score": 0.00335, "epss_percentile": 0.55812}, "CVE-2025-7415": {"epss_score": 0.00308, "epss_percentile": 0.53604}, "CVE-2025-7416": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7417": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7418": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7419": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7420": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7421": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7422": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7423": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7424": {"epss_score": 0.00095, "epss_percentile": 0.27194}, "CVE-2025-7425": {"epss_score": 0.0003, "epss_percentile": 0.08258}, "CVE-2025-7426": {"epss_score": 0.00056, "epss_percentile": 0.17716}, "CVE-2025-7427": {"epss_score": 0.00017, "epss_percentile": 0.03492}, "CVE-2025-7429": {"epss_score": 0.00034, "epss_percentile": 0.09746}, "CVE-2025-7430": {"epss_score": 0.00034, "epss_percentile": 0.09746}, "CVE-2025-7431": {"epss_score": 0.00022, "epss_percentile": 0.05181}, "CVE-2025-7433": {"epss_score": 0.00034, "epss_percentile": 0.09559}, "CVE-2025-7434": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7435": {"epss_score": 0.00032, "epss_percentile": 0.08802}, "CVE-2025-7436": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7437": {"epss_score": 0.00289, "epss_percentile": 0.52002}, "CVE-2025-7438": {"epss_score": 0.00146, "epss_percentile": 0.35527}, "CVE-2025-7439": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-7440": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-7441": {"epss_score": 0.00717, "epss_percentile": 0.7187}, "CVE-2025-7442": {"epss_score": 0.00093, "epss_percentile": 0.26621}, "CVE-2025-7443": {"epss_score": 0.00143, "epss_percentile": 0.35153}, "CVE-2025-7444": {"epss_score": 0.00461, "epss_percentile": 0.63541}, "CVE-2025-7445": {"epss_score": 6e-05, "epss_percentile": 0.00286}, "CVE-2025-7448": {"epss_score": 0.00023, "epss_percentile": 0.05479}, "CVE-2025-7449": {"epss_score": 0.00036, "epss_percentile": 0.10517}, "CVE-2025-7450": {"epss_score": 0.00049, "epss_percentile": 0.15352}, "CVE-2025-7451": {"epss_score": 0.00526, "epss_percentile": 0.66407}, "CVE-2025-7452": {"epss_score": 0.00054, "epss_percentile": 0.17296}, "CVE-2025-7453": {"epss_score": 0.00032, "epss_percentile": 0.09115}, "CVE-2025-7454": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7455": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7456": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7457": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7458": {"epss_score": 0.00069, "epss_percentile": 0.21611}, "CVE-2025-7459": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7460": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-7461": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7462": {"epss_score": 0.00048, "epss_percentile": 0.15112}, "CVE-2025-7463": {"epss_score": 0.0026, "epss_percentile": 0.49192}, "CVE-2025-7464": {"epss_score": 0.00045, "epss_percentile": 0.13976}, "CVE-2025-7465": {"epss_score": 0.0026, "epss_percentile": 0.49192}, "CVE-2025-7466": {"epss_score": 0.00042, "epss_percentile": 0.12591}, "CVE-2025-7467": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7468": {"epss_score": 0.0026, "epss_percentile": 0.49192}, "CVE-2025-7469": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7470": {"epss_score": 0.00056, "epss_percentile": 0.17811}, "CVE-2025-7471": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7472": {"epss_score": 7e-05, "epss_percentile": 0.00376}, "CVE-2025-7473": {"epss_score": 0.0003, "epss_percentile": 0.08275}, "CVE-2025-7474": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7475": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7476": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7477": {"epss_score": 0.00049, "epss_percentile": 0.15355}, "CVE-2025-7478": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7479": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7480": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7481": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7482": {"epss_score": 0.00039, "epss_percentile": 0.11691}, "CVE-2025-7483": {"epss_score": 0.0004, "epss_percentile": 0.12033}, "CVE-2025-7484": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7485": {"epss_score": 0.00014, "epss_percentile": 0.01768}, "CVE-2025-7486": {"epss_score": 0.00022, "epss_percentile": 0.05065}, "CVE-2025-7487": {"epss_score": 0.00039, "epss_percentile": 0.11625}, "CVE-2025-7488": {"epss_score": 0.00044, "epss_percentile": 0.13418}, "CVE-2025-7489": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7490": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7491": {"epss_score": 0.00043, "epss_percentile": 0.13343}, "CVE-2025-7492": {"epss_score": 0.00043, "epss_percentile": 0.13343}, "CVE-2025-7493": {"epss_score": 0.0009, "epss_percentile": 0.26012}, "CVE-2025-7495": {"epss_score": 0.00041, "epss_percentile": 0.12309}, "CVE-2025-7496": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-7497": {"epss_score": 0.00026, "epss_percentile": 0.06478}, "CVE-2025-7498": {"epss_score": 0.00022, "epss_percentile": 0.05055}, "CVE-2025-7499": {"epss_score": 0.00066, "epss_percentile": 0.20724}, "CVE-2025-7500": {"epss_score": 0.00033, "epss_percentile": 0.09406}, "CVE-2025-7501": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-7502": {"epss_score": 0.0002, "epss_percentile": 0.04566}, "CVE-2025-7503": {"epss_score": 0.00466, "epss_percentile": 0.63787}, "CVE-2025-7504": {"epss_score": 0.00275, "epss_percentile": 0.50701}, "CVE-2025-7505": {"epss_score": 0.00208, "epss_percentile": 0.43292}, "CVE-2025-7506": {"epss_score": 0.00208, "epss_percentile": 0.43292}, "CVE-2025-7507": {"epss_score": 0.00111, "epss_percentile": 0.30254}, "CVE-2025-7508": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7509": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7510": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7511": {"epss_score": 0.00023, "epss_percentile": 0.05653}, "CVE-2025-7512": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7513": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7514": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7515": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7516": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7517": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7518": {"epss_score": 0.00058, "epss_percentile": 0.18384}, "CVE-2025-7519": {"epss_score": 0.00022, "epss_percentile": 0.05045}, "CVE-2025-7520": {"epss_score": 0.00043, "epss_percentile": 0.13343}, "CVE-2025-7521": {"epss_score": 0.00045, "epss_percentile": 0.13783}, "CVE-2025-7522": {"epss_score": 0.00043, "epss_percentile": 0.13343}, "CVE-2025-7523": {"epss_score": 0.00031, "epss_percentile": 0.08419}, "CVE-2025-7524": {"epss_score": 0.00897, "epss_percentile": 0.7513}, "CVE-2025-7525": {"epss_score": 0.00897, "epss_percentile": 0.7513}, "CVE-2025-7526": {"epss_score": 0.01074, "epss_percentile": 0.77297}, "CVE-2025-7527": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-7528": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-7529": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-7530": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-7531": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-7532": {"epss_score": 0.00156, "epss_percentile": 0.36896}, "CVE-2025-7533": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7534": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7535": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7536": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7537": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7538": {"epss_score": 0.00076, "epss_percentile": 0.23176}, "CVE-2025-7539": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7540": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7541": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7542": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7543": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7544": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7545": {"epss_score": 0.00015, "epss_percentile": 0.02343}, "CVE-2025-7546": {"epss_score": 0.00015, "epss_percentile": 0.02343}, "CVE-2025-7547": {"epss_score": 0.00058, "epss_percentile": 0.18476}, "CVE-2025-7548": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7549": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7550": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7551": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7552": {"epss_score": 0.00052, "epss_percentile": 0.16362}, "CVE-2025-7553": {"epss_score": 0.00041, "epss_percentile": 0.12366}, "CVE-2025-7554": {"epss_score": 0.00021, "epss_percentile": 0.04933}, "CVE-2025-7555": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7556": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7557": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7558": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7559": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-7560": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7561": {"epss_score": 0.00032, "epss_percentile": 0.0895}, "CVE-2025-7562": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7563": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7564": {"epss_score": 0.00025, "epss_percentile": 0.06062}, "CVE-2025-7565": {"epss_score": 0.00046, "epss_percentile": 0.14391}, "CVE-2025-7566": {"epss_score": 0.00186, "epss_percentile": 0.40666}, "CVE-2025-7567": {"epss_score": 0.0003, "epss_percentile": 0.08298}, "CVE-2025-7568": {"epss_score": 0.0003, "epss_percentile": 0.08093}, "CVE-2025-7569": {"epss_score": 0.00026, "epss_percentile": 0.0641}, "CVE-2025-7570": {"epss_score": 0.00217, "epss_percentile": 0.44319}, "CVE-2025-7571": {"epss_score": 0.00217, "epss_percentile": 0.44319}, "CVE-2025-7572": {"epss_score": 0.00036, "epss_percentile": 0.10509}, "CVE-2025-7573": {"epss_score": 0.00036, "epss_percentile": 0.10509}, "CVE-2025-7574": {"epss_score": 0.00474, "epss_percentile": 0.64167}, "CVE-2025-7575": {"epss_score": 0.00063, "epss_percentile": 0.19905}, "CVE-2025-7576": {"epss_score": 0.00049, "epss_percentile": 0.15491}, "CVE-2025-7577": {"epss_score": 0.00039, "epss_percentile": 0.11775}, "CVE-2025-7578": {"epss_score": 0.00461, "epss_percentile": 0.63558}, "CVE-2025-7579": {"epss_score": 0.00047, "epss_percentile": 0.14931}, "CVE-2025-7580": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7581": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7582": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7583": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7584": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7585": {"epss_score": 0.00028, "epss_percentile": 0.07501}, "CVE-2025-7586": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7587": {"epss_score": 0.0004, "epss_percentile": 0.12033}, "CVE-2025-7588": {"epss_score": 0.00028, "epss_percentile": 0.07501}, "CVE-2025-7589": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7590": {"epss_score": 0.00028, "epss_percentile": 0.07501}, "CVE-2025-7591": {"epss_score": 0.00028, "epss_percentile": 0.07501}, "CVE-2025-7592": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-7593": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7594": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7595": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7596": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7597": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7598": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7599": {"epss_score": 0.00028, "epss_percentile": 0.07501}, "CVE-2025-7600": {"epss_score": 0.00028, "epss_percentile": 0.07501}, "CVE-2025-7601": {"epss_score": 0.00027, "epss_percentile": 0.06768}, "CVE-2025-7602": {"epss_score": 0.00288, "epss_percentile": 0.51931}, "CVE-2025-7603": {"epss_score": 0.00288, "epss_percentile": 0.51931}, "CVE-2025-7604": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7605": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7606": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7607": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7608": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7609": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7610": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7611": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7612": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7613": {"epss_score": 0.00914, "epss_percentile": 0.75385}, "CVE-2025-7614": {"epss_score": 0.00914, "epss_percentile": 0.75385}, "CVE-2025-7615": {"epss_score": 0.00914, "epss_percentile": 0.75385}, "CVE-2025-7616": {"epss_score": 0.00014, "epss_percentile": 0.02122}, "CVE-2025-7618": {"epss_score": 0.00054, "epss_percentile": 0.17294}, "CVE-2025-7619": {"epss_score": 0.00559, "epss_percentile": 0.6762}, "CVE-2025-7620": {"epss_score": 0.00062, "epss_percentile": 0.19575}, "CVE-2025-7622": {"epss_score": 0.00019, "epss_percentile": 0.04354}, "CVE-2025-7623": {"epss_score": 0.00064, "epss_percentile": 0.20354}, "CVE-2025-7624": {"epss_score": 0.0019, "epss_percentile": 0.41081}, "CVE-2025-7625": {"epss_score": 0.00083, "epss_percentile": 0.24764}, "CVE-2025-7626": {"epss_score": 0.00121, "epss_percentile": 0.32002}, "CVE-2025-7627": {"epss_score": 0.00055, "epss_percentile": 0.17448}, "CVE-2025-7628": {"epss_score": 0.00072, "epss_percentile": 0.22415}, "CVE-2025-7632": {"epss_score": 0.00034, "epss_percentile": 0.09746}, "CVE-2025-7633": {"epss_score": 0.00034, "epss_percentile": 0.09746}, "CVE-2025-7634": {"epss_score": 0.00575, "epss_percentile": 0.68113}, "CVE-2025-7635": {"epss_score": 0.00018, "epss_percentile": 0.03827}, "CVE-2025-7638": {"epss_score": 0.00026, "epss_percentile": 0.06615}, "CVE-2025-7640": {"epss_score": 0.00336, "epss_percentile": 0.55985}, "CVE-2025-7641": {"epss_score": 0.00107, "epss_percentile": 0.29576}, "CVE-2025-7642": {"epss_score": 0.00388, "epss_percentile": 0.59397}, "CVE-2025-7643": {"epss_score": 0.02348, "epss_percentile": 0.8446}, "CVE-2025-7644": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-7645": {"epss_score": 0.0038, "epss_percentile": 0.58935}, "CVE-2025-7646": {"epss_score": 0.00027, "epss_percentile": 0.06804}, "CVE-2025-7647": {"epss_score": 0.00021, "epss_percentile": 0.04881}, "CVE-2025-7648": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-7649": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-7650": {"epss_score": 0.00138, "epss_percentile": 0.34394}, "CVE-2025-7651": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-7652": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-7653": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-7654": {"epss_score": 0.00141, "epss_percentile": 0.34804}, "CVE-2025-7655": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-7656": {"epss_score": 0.00069, "epss_percentile": 0.21608}, "CVE-2025-7657": {"epss_score": 0.00047, "epss_percentile": 0.14498}, "CVE-2025-7658": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-7660": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-7661": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-7662": {"epss_score": 0.00044, "epss_percentile": 0.13678}, "CVE-2025-7663": {"epss_score": 0.00109, "epss_percentile": 0.30039}, "CVE-2025-7664": {"epss_score": 0.00253, "epss_percentile": 0.48447}, "CVE-2025-7665": {"epss_score": 0.00109, "epss_percentile": 0.30001}, "CVE-2025-7667": {"epss_score": 0.00098, "epss_percentile": 0.27773}, "CVE-2025-7668": {"epss_score": 0.00024, "epss_percentile": 0.06033}, "CVE-2025-7669": {"epss_score": 0.00011, "epss_percentile": 0.0109}, "CVE-2025-7670": {"epss_score": 0.00135, "epss_percentile": 0.33942}, "CVE-2025-7672": {"epss_score": 0.00025, "epss_percentile": 0.06055}, "CVE-2025-7673": {"epss_score": 0.01436, "epss_percentile": 0.80276}, "CVE-2025-7674": {"epss_score": 0.00133, "epss_percentile": 0.33732}, "CVE-2025-7675": {"epss_score": 0.00026, "epss_percentile": 0.06478}, "CVE-2025-7676": {"epss_score": 0.00021, "epss_percentile": 0.0488}, "CVE-2025-7677": {"epss_score": 0.00036, "epss_percentile": 0.10494}, "CVE-2025-7679": {"epss_score": 0.00054, "epss_percentile": 0.17132}, "CVE-2025-7683": {"epss_score": 0.00024, "epss_percentile": 0.06033}, "CVE-2025-7684": {"epss_score": 0.00024, "epss_percentile": 0.06033}, "CVE-2025-7685": {"epss_score": 0.00012, "epss_percentile": 0.01298}, "CVE-2025-7686": {"epss_score": 0.00026, "epss_percentile": 0.06614}, "CVE-2025-7687": {"epss_score": 0.00012, "epss_percentile": 0.01298}, "CVE-2025-7688": {"epss_score": 0.00024, "epss_percentile": 0.06033}, "CVE-2025-7689": {"epss_score": 0.00053, "epss_percentile": 0.16729}, "CVE-2025-7690": {"epss_score": 0.00013, "epss_percentile": 0.01621}, "CVE-2025-7691": {"epss_score": 8e-05, "epss_percentile": 0.00525}, "CVE-2025-7692": {"epss_score": 0.00206, "epss_percentile": 0.43057}, "CVE-2025-7693": {"epss_score": 0.00164, "epss_percentile": 0.38007}, "CVE-2025-7694": {"epss_score": 0.0024, "epss_percentile": 0.47207}, "CVE-2025-7695": {"epss_score": 0.00072, "epss_percentile": 0.22244}, "CVE-2025-7696": {"epss_score": 0.01003, "epss_percentile": 0.7652}, "CVE-2025-7697": {"epss_score": 0.01003, "epss_percentile": 0.7652}, "CVE-2025-7698": {"epss_score": 0.00051, "epss_percentile": 0.16269}, "CVE-2025-7699": {"epss_score": 0.00051, "epss_percentile": 0.16164}, "CVE-2025-7700": {"epss_score": 0.00032, "epss_percentile": 0.09086}, "CVE-2025-7702": {"epss_score": 0.00038, "epss_percentile": 0.11388}, "CVE-2025-7703": {"epss_score": 0.00026, "epss_percentile": 0.06667}, "CVE-2025-7704": {"epss_score": 0.0005, "epss_percentile": 0.15701}, "CVE-2025-7705": {"epss_score": 0.00028, "epss_percentile": 0.07239}, "CVE-2025-7707": {"epss_score": 0.00018, "epss_percentile": 0.03804}, "CVE-2025-7709": {"epss_score": 0.00076, "epss_percentile": 0.23267}, "CVE-2025-7710": {"epss_score": 0.00418, "epss_percentile": 0.61273}, "CVE-2025-7711": {"epss_score": 0.00055, "epss_percentile": 0.1752}, "CVE-2025-7712": {"epss_score": 0.02348, "epss_percentile": 0.8446}, "CVE-2025-7715": {"epss_score": 0.00024, "epss_percentile": 0.05831}, "CVE-2025-7716": {"epss_score": 0.00025, "epss_percentile": 0.06154}, "CVE-2025-7717": {"epss_score": 0.00045, "epss_percentile": 0.13903}, "CVE-2025-7718": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-7719": {"epss_score": 0.0008, "epss_percentile": 0.24114}, "CVE-2025-7721": {"epss_score": 0.00575, "epss_percentile": 0.68113}, "CVE-2025-7722": {"epss_score": 0.00056, "epss_percentile": 0.17737}, "CVE-2025-7723": {"epss_score": 0.00482, "epss_percentile": 0.64541}, "CVE-2025-7724": {"epss_score": 0.00416, "epss_percentile": 0.6119}, "CVE-2025-7725": {"epss_score": 0.0012, "epss_percentile": 0.3169}, "CVE-2025-7726": {"epss_score": 0.00028, "epss_percentile": 0.07475}, "CVE-2025-7727": {"epss_score": 0.00026, "epss_percentile": 0.06718}, "CVE-2025-7728": {"epss_score": 0.00026, "epss_percentile": 0.06737}, "CVE-2025-7729": {"epss_score": 0.00026, "epss_percentile": 0.06737}, "CVE-2025-7730": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-7731": {"epss_score": 0.0002, "epss_percentile": 0.04521}, "CVE-2025-7732": {"epss_score": 0.00059, "epss_percentile": 0.18838}, "CVE-2025-7733": {"epss_score": 0.00029, "epss_percentile": 0.0797}, "CVE-2025-7734": {"epss_score": 0.00102, "epss_percentile": 0.28792}, "CVE-2025-7735": {"epss_score": 0.0007, "epss_percentile": 0.21976}, "CVE-2025-7736": {"epss_score": 0.00017, "epss_percentile": 0.03105}, "CVE-2025-7738": {"epss_score": 0.00018, "epss_percentile": 0.03977}, "CVE-2025-7739": {"epss_score": 0.0008, "epss_percentile": 0.2409}, "CVE-2025-7742": {"epss_score": 0.00273, "epss_percentile": 0.50463}, "CVE-2025-7743": {"epss_score": 0.00022, "epss_percentile": 0.0524}, "CVE-2025-7744": {"epss_score": 0.00046, "epss_percentile": 0.14158}, "CVE-2025-7745": {"epss_score": 0.00037, "epss_percentile": 0.10864}, "CVE-2025-7746": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-7747": {"epss_score": 0.00208, "epss_percentile": 0.43292}, "CVE-2025-7748": {"epss_score": 0.00026, "epss_percentile": 0.0641}, "CVE-2025-7749": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7750": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7751": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7752": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7753": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7754": {"epss_score": 0.00023, "epss_percentile": 0.05653}, "CVE-2025-7755": {"epss_score": 0.00045, "epss_percentile": 0.13814}, "CVE-2025-7756": {"epss_score": 0.00038, "epss_percentile": 0.11125}, "CVE-2025-7757": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-7758": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-7759": {"epss_score": 0.00062, "epss_percentile": 0.19599}, "CVE-2025-7761": {"epss_score": 0.00091, "epss_percentile": 0.26264}, "CVE-2025-7762": {"epss_score": 0.00191, "epss_percentile": 0.41169}, "CVE-2025-7763": {"epss_score": 0.00065, "epss_percentile": 0.20464}, "CVE-2025-7764": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7765": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7766": {"epss_score": 0.0022, "epss_percentile": 0.4455}, "CVE-2025-7767": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-7768": {"epss_score": 0.00049, "epss_percentile": 0.156}, "CVE-2025-7769": {"epss_score": 0.02386, "epss_percentile": 0.84579}, "CVE-2025-7770": {"epss_score": 0.0006, "epss_percentile": 0.19108}, "CVE-2025-7771": {"epss_score": 5e-05, "epss_percentile": 0.00181}, "CVE-2025-7772": {"epss_score": 0.00038, "epss_percentile": 0.11231}, "CVE-2025-7773": {"epss_score": 0.00079, "epss_percentile": 0.23939}, "CVE-2025-7774": {"epss_score": 0.00079, "epss_percentile": 0.23939}, "CVE-2025-7775": {"epss_score": 0.18005, "epss_percentile": 0.94942}, "CVE-2025-7776": {"epss_score": 0.00189, "epss_percentile": 0.40958}, "CVE-2025-7777": {"epss_score": 0.00032, "epss_percentile": 0.08746}, "CVE-2025-7778": {"epss_score": 0.00323, "epss_percentile": 0.54885}, "CVE-2025-7779": {"epss_score": 0.00019, "epss_percentile": 0.0433}, "CVE-2025-7780": {"epss_score": 0.00049, "epss_percentile": 0.15577}, "CVE-2025-7781": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-7782": {"epss_score": 0.00043, "epss_percentile": 0.1294}, "CVE-2025-7783": {"epss_score": 0.00172, "epss_percentile": 0.39026}, "CVE-2025-7784": {"epss_score": 0.00013, "epss_percentile": 0.01526}, "CVE-2025-7785": {"epss_score": 0.00065, "epss_percentile": 0.20464}, "CVE-2025-7786": {"epss_score": 0.00026, "epss_percentile": 0.06588}, "CVE-2025-7787": {"epss_score": 0.00059, "epss_percentile": 0.18876}, "CVE-2025-7788": {"epss_score": 0.00157, "epss_percentile": 0.37128}, "CVE-2025-7789": {"epss_score": 0.00022, "epss_percentile": 0.05249}, "CVE-2025-7790": {"epss_score": 0.00139, "epss_percentile": 0.34561}, "CVE-2025-7791": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-7792": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7793": {"epss_score": 0.00396, "epss_percentile": 0.59921}, "CVE-2025-7794": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7795": {"epss_score": 0.10926, "epss_percentile": 0.9316}, "CVE-2025-7796": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7797": {"epss_score": 0.00147, "epss_percentile": 0.35693}, "CVE-2025-7798": {"epss_score": 0.00025, "epss_percentile": 0.06123}, "CVE-2025-7800": {"epss_score": 0.00022, "epss_percentile": 0.05149}, "CVE-2025-7801": {"epss_score": 0.00026, "epss_percentile": 0.06681}, "CVE-2025-7802": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-7803": {"epss_score": 0.00022, "epss_percentile": 0.05149}, "CVE-2025-7805": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7806": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7807": {"epss_score": 0.00371, "epss_percentile": 0.58398}, "CVE-2025-7808": {"epss_score": 0.00053, "epss_percentile": 0.1685}, "CVE-2025-7809": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-7810": {"epss_score": 0.00024, "epss_percentile": 0.05667}, "CVE-2025-7811": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-7812": {"epss_score": 0.00034, "epss_percentile": 0.09648}, "CVE-2025-7813": {"epss_score": 0.0011, "epss_percentile": 0.30076}, "CVE-2025-7814": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7815": {"epss_score": 0.00026, "epss_percentile": 0.06585}, "CVE-2025-7816": {"epss_score": 0.00027, "epss_percentile": 0.06768}, "CVE-2025-7817": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-7818": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-7819": {"epss_score": 0.00026, "epss_percentile": 0.06585}, "CVE-2025-7820": {"epss_score": 0.00168, "epss_percentile": 0.38419}, "CVE-2025-7821": {"epss_score": 0.00108, "epss_percentile": 0.29773}, "CVE-2025-7822": {"epss_score": 0.00036, "epss_percentile": 0.10196}, "CVE-2025-7823": {"epss_score": 0.00032, "epss_percentile": 0.08732}, "CVE-2025-7824": {"epss_score": 0.00032, "epss_percentile": 0.08732}, "CVE-2025-7825": {"epss_score": 0.00067, "epss_percentile": 0.21096}, "CVE-2025-7826": {"epss_score": 0.00039, "epss_percentile": 0.11446}, "CVE-2025-7827": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-7828": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-7829": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7830": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7831": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7832": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7833": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7834": {"epss_score": 0.00049, "epss_percentile": 0.15376}, "CVE-2025-7835": {"epss_score": 0.00013, "epss_percentile": 0.01492}, "CVE-2025-7836": {"epss_score": 0.00074, "epss_percentile": 0.22795}, "CVE-2025-7837": {"epss_score": 0.00312, "epss_percentile": 0.53947}, "CVE-2025-7838": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7839": {"epss_score": 0.00027, "epss_percentile": 0.07208}, "CVE-2025-7840": {"epss_score": 0.00037, "epss_percentile": 0.10625}, "CVE-2025-7841": {"epss_score": 0.00017, "epss_percentile": 0.03189}, "CVE-2025-7842": {"epss_score": 0.00027, "epss_percentile": 0.07208}, "CVE-2025-7843": {"epss_score": 0.00037, "epss_percentile": 0.11056}, "CVE-2025-7844": {"epss_score": 0.00017, "epss_percentile": 0.03184}, "CVE-2025-7845": {"epss_score": 0.00028, "epss_percentile": 0.07475}, "CVE-2025-7846": {"epss_score": 0.00587, "epss_percentile": 0.68474}, "CVE-2025-7847": {"epss_score": 0.00243, "epss_percentile": 0.47428}, "CVE-2025-7848": {"epss_score": 0.00024, "epss_percentile": 0.05959}, "CVE-2025-7849": {"epss_score": 0.00024, "epss_percentile": 0.05959}, "CVE-2025-7850": {"epss_score": 0.01776, "epss_percentile": 0.82221}, "CVE-2025-7851": {"epss_score": 0.00057, "epss_percentile": 0.18218}, "CVE-2025-7852": {"epss_score": 0.00391, "epss_percentile": 0.59585}, "CVE-2025-7853": {"epss_score": 0.00208, "epss_percentile": 0.43292}, "CVE-2025-7854": {"epss_score": 0.00208, "epss_percentile": 0.43292}, "CVE-2025-7855": {"epss_score": 0.00146, "epss_percentile": 0.35565}, "CVE-2025-7856": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-7857": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-7858": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-7859": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7860": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7861": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7862": {"epss_score": 0.00105, "epss_percentile": 0.29353}, "CVE-2025-7863": {"epss_score": 0.00033, "epss_percentile": 0.09416}, "CVE-2025-7864": {"epss_score": 0.00036, "epss_percentile": 0.10293}, "CVE-2025-7865": {"epss_score": 0.00031, "epss_percentile": 0.08683}, "CVE-2025-7866": {"epss_score": 0.00024, "epss_percentile": 0.05953}, "CVE-2025-7867": {"epss_score": 0.00032, "epss_percentile": 0.08804}, "CVE-2025-7868": {"epss_score": 0.00025, "epss_percentile": 0.06212}, "CVE-2025-7869": {"epss_score": 0.00024, "epss_percentile": 0.05953}, "CVE-2025-7870": {"epss_score": 0.00026, "epss_percentile": 0.06737}, "CVE-2025-7871": {"epss_score": 0.00026, "epss_percentile": 0.06737}, "CVE-2025-7872": {"epss_score": 0.00026, "epss_percentile": 0.06737}, "CVE-2025-7873": {"epss_score": 0.0003, "epss_percentile": 0.08093}, "CVE-2025-7874": {"epss_score": 0.00043, "epss_percentile": 0.13327}, "CVE-2025-7875": {"epss_score": 0.00108, "epss_percentile": 0.29781}, "CVE-2025-7876": {"epss_score": 0.00068, "epss_percentile": 0.21394}, "CVE-2025-7877": {"epss_score": 0.0005, "epss_percentile": 0.15827}, "CVE-2025-7878": {"epss_score": 0.00049, "epss_percentile": 0.15563}, "CVE-2025-7879": {"epss_score": 0.0005, "epss_percentile": 0.15827}, "CVE-2025-7880": {"epss_score": 0.00049, "epss_percentile": 0.15563}, "CVE-2025-7881": {"epss_score": 0.00027, "epss_percentile": 0.06821}, "CVE-2025-7882": {"epss_score": 0.0004, "epss_percentile": 0.12054}, "CVE-2025-7883": {"epss_score": 0.0007, "epss_percentile": 0.21696}, "CVE-2025-7884": {"epss_score": 9e-05, "epss_percentile": 0.00607}, "CVE-2025-7885": {"epss_score": 0.00049, "epss_percentile": 0.15444}, "CVE-2025-7886": {"epss_score": 0.00026, "epss_percentile": 0.06681}, "CVE-2025-7887": {"epss_score": 0.0005, "epss_percentile": 0.15848}, "CVE-2025-7888": {"epss_score": 0.0003, "epss_percentile": 0.08093}, "CVE-2025-7889": {"epss_score": 0.00019, "epss_percentile": 0.04418}, "CVE-2025-7890": {"epss_score": 0.00025, "epss_percentile": 0.06244}, "CVE-2025-7891": {"epss_score": 0.00027, "epss_percentile": 0.06808}, "CVE-2025-7892": {"epss_score": 0.00027, "epss_percentile": 0.06947}, "CVE-2025-7893": {"epss_score": 0.00025, "epss_percentile": 0.06244}, "CVE-2025-7894": {"epss_score": 0.0003, "epss_percentile": 0.08093}, "CVE-2025-7895": {"epss_score": 0.0004, "epss_percentile": 0.12072}, "CVE-2025-7896": {"epss_score": 0.00061, "epss_percentile": 0.19338}, "CVE-2025-7897": {"epss_score": 0.0006, "epss_percentile": 0.19064}, "CVE-2025-7898": {"epss_score": 0.00055, "epss_percentile": 0.17612}, "CVE-2025-7899": {"epss_score": 0.00063, "epss_percentile": 0.1989}, "CVE-2025-7900": {"epss_score": 0.00043, "epss_percentile": 0.13059}, "CVE-2025-7901": {"epss_score": 0.00113, "epss_percentile": 0.30733}, "CVE-2025-7902": {"epss_score": 0.00028, "epss_percentile": 0.07214}, "CVE-2025-7903": {"epss_score": 0.0003, "epss_percentile": 0.08016}, "CVE-2025-7904": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7905": {"epss_score": 0.00037, "epss_percentile": 0.10755}, "CVE-2025-7906": {"epss_score": 0.0003, "epss_percentile": 0.08016}, "CVE-2025-7907": {"epss_score": 0.00028, "epss_percentile": 0.07357}, "CVE-2025-7908": {"epss_score": 0.00139, "epss_percentile": 0.34561}, "CVE-2025-7909": {"epss_score": 0.00381, "epss_percentile": 0.59031}, "CVE-2025-7910": {"epss_score": 0.00381, "epss_percentile": 0.59031}, "CVE-2025-7911": {"epss_score": 0.00164, "epss_percentile": 0.37935}, "CVE-2025-7912": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-7913": {"epss_score": 0.00555, "epss_percentile": 0.67486}, "CVE-2025-7914": {"epss_score": 0.00258, "epss_percentile": 0.48985}, "CVE-2025-7915": {"epss_score": 0.00031, "epss_percentile": 0.08437}, "CVE-2025-7916": {"epss_score": 0.01529, "epss_percentile": 0.80881}, "CVE-2025-7917": {"epss_score": 0.00197, "epss_percentile": 0.41837}, "CVE-2025-7918": {"epss_score": 0.00123, "epss_percentile": 0.32175}, "CVE-2025-7919": {"epss_score": 0.00045, "epss_percentile": 0.1401}, "CVE-2025-7920": {"epss_score": 0.00043, "epss_percentile": 0.13205}, "CVE-2025-7921": {"epss_score": 0.003, "epss_percentile": 0.52953}, "CVE-2025-7924": {"epss_score": 0.00037, "epss_percentile": 0.1092}, "CVE-2025-7925": {"epss_score": 0.00051, "epss_percentile": 0.16172}, "CVE-2025-7926": {"epss_score": 0.00037, "epss_percentile": 0.1092}, "CVE-2025-7927": {"epss_score": 0.00036, "epss_percentile": 0.1036}, "CVE-2025-7928": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7929": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7930": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7931": {"epss_score": 0.00056, "epss_percentile": 0.17961}, "CVE-2025-7932": {"epss_score": 0.00074, "epss_percentile": 0.22795}, "CVE-2025-7933": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-7934": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2025-7935": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2025-7936": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2025-7937": {"epss_score": 0.00025, "epss_percentile": 0.06065}, "CVE-2025-7938": {"epss_score": 0.00038, "epss_percentile": 0.11123}, "CVE-2025-7939": {"epss_score": 0.00047, "epss_percentile": 0.14915}, "CVE-2025-7940": {"epss_score": 0.00014, "epss_percentile": 0.0205}, "CVE-2025-7941": {"epss_score": 0.00037, "epss_percentile": 0.1092}, "CVE-2025-7942": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-7943": {"epss_score": 0.00035, "epss_percentile": 0.0998}, "CVE-2025-7944": {"epss_score": 0.00035, "epss_percentile": 0.0998}, "CVE-2025-7945": {"epss_score": 0.00278, "epss_percentile": 0.50864}, "CVE-2025-7946": {"epss_score": 0.00035, "epss_percentile": 0.0998}, "CVE-2025-7947": {"epss_score": 0.00063, "epss_percentile": 0.19955}, "CVE-2025-7948": {"epss_score": 0.00037, "epss_percentile": 0.10901}, "CVE-2025-7949": {"epss_score": 0.0004, "epss_percentile": 0.11975}, "CVE-2025-7950": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-7951": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-7952": {"epss_score": 0.01581, "epss_percentile": 0.81138}, "CVE-2025-7953": {"epss_score": 0.00039, "epss_percentile": 0.11734}, "CVE-2025-7954": {"epss_score": 0.00039, "epss_percentile": 0.11585}, "CVE-2025-7955": {"epss_score": 0.00433, "epss_percentile": 0.62221}, "CVE-2025-7956": {"epss_score": 0.00052, "epss_percentile": 0.16562}, "CVE-2025-7957": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-7959": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-7960": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-7961": {"epss_score": 0.00041, "epss_percentile": 0.12265}, "CVE-2025-7962": {"epss_score": 0.0001, "epss_percentile": 0.00824}, "CVE-2025-7965": {"epss_score": 0.00014, "epss_percentile": 0.01991}, "CVE-2025-7966": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-7969": {"epss_score": 0.00063, "epss_percentile": 0.19834}, "CVE-2025-7970": {"epss_score": 0.00049, "epss_percentile": 0.15643}, "CVE-2025-7971": {"epss_score": 0.00055, "epss_percentile": 0.17418}, "CVE-2025-7972": {"epss_score": 0.00078, "epss_percentile": 0.23796}, "CVE-2025-7973": {"epss_score": 0.00025, "epss_percentile": 0.06257}, "CVE-2025-7974": {"epss_score": 0.00051, "epss_percentile": 0.16153}, "CVE-2025-7975": {"epss_score": 0.00213, "epss_percentile": 0.4392}, "CVE-2025-7976": {"epss_score": 0.00241, "epss_percentile": 0.47258}, "CVE-2025-7977": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7978": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7979": {"epss_score": 0.00032, "epss_percentile": 0.08803}, "CVE-2025-7980": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7981": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7982": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7983": {"epss_score": 0.00032, "epss_percentile": 0.08803}, "CVE-2025-7984": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7985": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7986": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7987": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7988": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7989": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7990": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7991": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7992": {"epss_score": 0.00035, "epss_percentile": 0.0989}, "CVE-2025-7993": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-7994": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-7995": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-7996": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-7997": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-7998": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-7999": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-8000": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-8001": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-8002": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-8003": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-8004": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-8005": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-8006": {"epss_score": 0.00024, "epss_percentile": 0.05906}, "CVE-2025-8007": {"epss_score": 0.00066, "epss_percentile": 0.20755}, "CVE-2025-8008": {"epss_score": 0.00033, "epss_percentile": 0.09184}, "CVE-2025-8009": {"epss_score": 0.00057, "epss_percentile": 0.18165}, "CVE-2025-8010": {"epss_score": 0.0008, "epss_percentile": 0.24194}, "CVE-2025-8011": {"epss_score": 0.0007, "epss_percentile": 0.21949}, "CVE-2025-8013": {"epss_score": 0.00045, "epss_percentile": 0.13703}, "CVE-2025-8014": {"epss_score": 0.00105, "epss_percentile": 0.29387}, "CVE-2025-8015": {"epss_score": 0.00032, "epss_percentile": 0.0876}, "CVE-2025-8017": {"epss_score": 0.00389, "epss_percentile": 0.59494}, "CVE-2025-8018": {"epss_score": 9e-05, "epss_percentile": 0.00629}, "CVE-2025-8019": {"epss_score": 0.00353, "epss_percentile": 0.57186}, "CVE-2025-8020": {"epss_score": 0.00015, "epss_percentile": 0.02294}, "CVE-2025-8021": {"epss_score": 0.00341, "epss_percentile": 0.56342}, "CVE-2025-8023": {"epss_score": 0.00069, "epss_percentile": 0.21558}, "CVE-2025-8027": {"epss_score": 0.00063, "epss_percentile": 0.19908}, "CVE-2025-8028": {"epss_score": 0.0011, "epss_percentile": 0.30125}, "CVE-2025-8029": {"epss_score": 0.00036, "epss_percentile": 0.10399}, "CVE-2025-8030": {"epss_score": 0.00035, "epss_percentile": 0.1}, "CVE-2025-8031": {"epss_score": 0.00136, "epss_percentile": 0.34193}, "CVE-2025-8032": {"epss_score": 0.0004, "epss_percentile": 0.12147}, "CVE-2025-8033": {"epss_score": 0.00065, "epss_percentile": 0.20655}, "CVE-2025-8034": {"epss_score": 0.00076, "epss_percentile": 0.23121}, "CVE-2025-8035": {"epss_score": 0.00057, "epss_percentile": 0.18075}, "CVE-2025-8036": {"epss_score": 0.00042, "epss_percentile": 0.12886}, "CVE-2025-8037": {"epss_score": 0.00027, "epss_percentile": 0.06786}, "CVE-2025-8038": {"epss_score": 0.00037, "epss_percentile": 0.10867}, "CVE-2025-8039": {"epss_score": 0.00039, "epss_percentile": 0.11765}, "CVE-2025-8040": {"epss_score": 0.00059, "epss_percentile": 0.18619}, "CVE-2025-8041": {"epss_score": 0.00031, "epss_percentile": 0.08509}, "CVE-2025-8042": {"epss_score": 0.00055, "epss_percentile": 0.17472}, "CVE-2025-8043": {"epss_score": 0.00088, "epss_percentile": 0.25734}, "CVE-2025-8044": {"epss_score": 0.00061, "epss_percentile": 0.1938}, "CVE-2025-8045": {"epss_score": 0.00017, "epss_percentile": 0.03232}, "CVE-2025-8046": {"epss_score": 0.00052, "epss_percentile": 0.16574}, "CVE-2025-8047": {"epss_score": 0.00083, "epss_percentile": 0.24616}, "CVE-2025-8048": {"epss_score": 0.00048, "epss_percentile": 0.15184}, "CVE-2025-8049": {"epss_score": 0.00065, "epss_percentile": 0.20524}, "CVE-2025-8050": {"epss_score": 0.00048, "epss_percentile": 0.15184}, "CVE-2025-8051": {"epss_score": 0.00068, "epss_percentile": 0.21289}, "CVE-2025-8052": {"epss_score": 0.00054, "epss_percentile": 0.17153}, "CVE-2025-8053": {"epss_score": 0.00051, "epss_percentile": 0.16318}, "CVE-2025-8057": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-8058": {"epss_score": 0.0002, "epss_percentile": 0.04439}, "CVE-2025-8059": {"epss_score": 0.00067, "epss_percentile": 0.20981}, "CVE-2025-8060": {"epss_score": 0.0026, "epss_percentile": 0.49192}, "CVE-2025-8061": {"epss_score": 7e-05, "epss_percentile": 0.00429}, "CVE-2025-8062": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-8064": {"epss_score": 0.00059, "epss_percentile": 0.18838}, "CVE-2025-8065": {"epss_score": 0.00026, "epss_percentile": 0.06723}, "CVE-2025-8066": {"epss_score": 0.0007, "epss_percentile": 0.21932}, "CVE-2025-8067": {"epss_score": 0.00023, "epss_percentile": 0.05387}, "CVE-2025-8068": {"epss_score": 0.00034, "epss_percentile": 0.09459}, "CVE-2025-8069": {"epss_score": 0.00017, "epss_percentile": 0.03278}, "CVE-2025-8070": {"epss_score": 0.00019, "epss_percentile": 0.04183}, "CVE-2025-8071": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-8073": {"epss_score": 0.00055, "epss_percentile": 0.17592}, "CVE-2025-8074": {"epss_score": 4e-05, "epss_percentile": 0.00173}, "CVE-2025-8075": {"epss_score": 0.00061, "epss_percentile": 0.19337}, "CVE-2025-8076": {"epss_score": 0.00056, "epss_percentile": 0.17809}, "CVE-2025-8077": {"epss_score": 0.00114, "epss_percentile": 0.30816}, "CVE-2025-8078": {"epss_score": 0.00188, "epss_percentile": 0.40919}, "CVE-2025-8079": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-8080": {"epss_score": 0.00039, "epss_percentile": 0.1148}, "CVE-2025-8081": {"epss_score": 0.00043, "epss_percentile": 0.13014}, "CVE-2025-8082": {"epss_score": 0.00028, "epss_percentile": 0.07336}, "CVE-2025-8083": {"epss_score": 0.00066, "epss_percentile": 0.2082}, "CVE-2025-8084": {"epss_score": 0.00035, "epss_percentile": 0.10052}, "CVE-2025-8085": {"epss_score": 0.08688, "epss_percentile": 0.92204}, "CVE-2025-8088": {"epss_score": 0.0295, "epss_percentile": 0.86051}, "CVE-2025-8089": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-8091": {"epss_score": 0.0008, "epss_percentile": 0.24196}, "CVE-2025-8092": {"epss_score": 0.00031, "epss_percentile": 0.08454}, "CVE-2025-8093": {"epss_score": 0.00105, "epss_percentile": 0.29311}, "CVE-2025-8097": {"epss_score": 0.00174, "epss_percentile": 0.39221}, "CVE-2025-8098": {"epss_score": 0.00023, "epss_percentile": 0.05431}, "CVE-2025-8100": {"epss_score": 0.00022, "epss_percentile": 0.05055}, "CVE-2025-8101": {"epss_score": 0.00123, "epss_percentile": 0.32292}, "CVE-2025-8102": {"epss_score": 0.00029, "epss_percentile": 0.07594}, "CVE-2025-8103": {"epss_score": 0.00016, "epss_percentile": 0.02875}, "CVE-2025-8104": {"epss_score": 0.00013, "epss_percentile": 0.01622}, "CVE-2025-8105": {"epss_score": 0.00437, "epss_percentile": 0.62533}, "CVE-2025-8107": {"epss_score": 0.00048, "epss_percentile": 0.15249}, "CVE-2025-8108": {"epss_score": 0.00018, "epss_percentile": 0.04049}, "CVE-2025-8109": {"epss_score": 0.00047, "epss_percentile": 0.14702}, "CVE-2025-8110": {"epss_score": 0.00039, "epss_percentile": 0.11839}, "CVE-2025-8113": {"epss_score": 0.00053, "epss_percentile": 0.1685}, "CVE-2025-8114": {"epss_score": 0.00022, "epss_percentile": 0.05019}, "CVE-2025-8115": {"epss_score": 0.00034, "epss_percentile": 0.09779}, "CVE-2025-8116": {"epss_score": 0.00049, "epss_percentile": 0.1559}, "CVE-2025-8117": {"epss_score": 0.00043, "epss_percentile": 0.13204}, "CVE-2025-8118": {"epss_score": 0.0004, "epss_percentile": 0.11982}, "CVE-2025-8119": {"epss_score": 0.0002, "epss_percentile": 0.0446}, "CVE-2025-8120": {"epss_score": 0.00265, "epss_percentile": 0.49796}, "CVE-2025-8121": {"epss_score": 0.00045, "epss_percentile": 0.14016}, "CVE-2025-8122": {"epss_score": 0.00045, "epss_percentile": 0.14016}, "CVE-2025-8123": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2025-8124": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2025-8125": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2025-8126": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2025-8127": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2025-8128": {"epss_score": 0.00044, "epss_percentile": 0.13393}, "CVE-2025-8129": {"epss_score": 0.0005, "epss_percentile": 0.15689}, "CVE-2025-8131": {"epss_score": 0.0026, "epss_percentile": 0.49192}, "CVE-2025-8132": {"epss_score": 0.00103, "epss_percentile": 0.29096}, "CVE-2025-8133": {"epss_score": 0.00055, "epss_percentile": 0.17602}, "CVE-2025-8134": {"epss_score": 0.00043, "epss_percentile": 0.13017}, "CVE-2025-8135": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-8136": {"epss_score": 0.00584, "epss_percentile": 0.6838}, "CVE-2025-8137": {"epss_score": 0.00389, "epss_percentile": 0.59475}, "CVE-2025-8138": {"epss_score": 0.00582, "epss_percentile": 0.68302}, "CVE-2025-8139": {"epss_score": 0.00389, "epss_percentile": 0.59475}, "CVE-2025-8140": {"epss_score": 0.00582, "epss_percentile": 0.68302}, "CVE-2025-8141": {"epss_score": 0.0032, "epss_percentile": 0.54628}, "CVE-2025-8142": {"epss_score": 0.00172, "epss_percentile": 0.39025}, "CVE-2025-8143": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-8145": {"epss_score": 0.00993, "epss_percentile": 0.76404}, "CVE-2025-8146": {"epss_score": 0.00026, "epss_percentile": 0.06718}, "CVE-2025-8147": {"epss_score": 0.00048, "epss_percentile": 0.15182}, "CVE-2025-8148": {"epss_score": 0.00041, "epss_percentile": 0.12341}, "CVE-2025-8149": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-8150": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-8151": {"epss_score": 0.00068, "epss_percentile": 0.21415}, "CVE-2025-8152": {"epss_score": 0.00095, "epss_percentile": 0.27131}, "CVE-2025-8153": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-8155": {"epss_score": 0.00027, "epss_percentile": 0.06947}, "CVE-2025-8156": {"epss_score": 0.00026, "epss_percentile": 0.06483}, "CVE-2025-8157": {"epss_score": 0.00024, "epss_percentile": 0.06024}, "CVE-2025-8158": {"epss_score": 0.00025, "epss_percentile": 0.06216}, "CVE-2025-8159": {"epss_score": 0.00305, "epss_percentile": 0.53317}, "CVE-2025-8160": {"epss_score": 0.00283, "epss_percentile": 0.51407}, "CVE-2025-8161": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2025-8162": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2025-8163": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2025-8164": {"epss_score": 0.00028, "epss_percentile": 0.07501}, "CVE-2025-8165": {"epss_score": 0.00027, "epss_percentile": 0.06977}, "CVE-2025-8166": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8167": {"epss_score": 0.00027, "epss_percentile": 0.06895}, "CVE-2025-8168": {"epss_score": 0.00568, "epss_percentile": 0.6789}, "CVE-2025-8169": {"epss_score": 0.00225, "epss_percentile": 0.45224}, "CVE-2025-8170": {"epss_score": 0.00551, "epss_percentile": 0.67356}, "CVE-2025-8171": {"epss_score": 0.00038, "epss_percentile": 0.11098}, "CVE-2025-8172": {"epss_score": 0.00026, "epss_percentile": 0.0663}, "CVE-2025-8173": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-8174": {"epss_score": 0.00041, "epss_percentile": 0.12385}, "CVE-2025-8175": {"epss_score": 0.00151, "epss_percentile": 0.36201}, "CVE-2025-8176": {"epss_score": 0.00016, "epss_percentile": 0.0294}, "CVE-2025-8177": {"epss_score": 0.00017, "epss_percentile": 0.03172}, "CVE-2025-8178": {"epss_score": 0.00268, "epss_percentile": 0.50042}, "CVE-2025-8179": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8180": {"epss_score": 0.00368, "epss_percentile": 0.58177}, "CVE-2025-8181": {"epss_score": 0.00484, "epss_percentile": 0.64666}, "CVE-2025-8182": {"epss_score": 0.0004, "epss_percentile": 0.12066}, "CVE-2025-8183": {"epss_score": 0.00244, "epss_percentile": 0.47561}, "CVE-2025-8184": {"epss_score": 0.0023, "epss_percentile": 0.45683}, "CVE-2025-8185": {"epss_score": 0.00025, "epss_percentile": 0.06289}, "CVE-2025-8186": {"epss_score": 0.00026, "epss_percentile": 0.0663}, "CVE-2025-8187": {"epss_score": 0.00026, "epss_percentile": 0.0663}, "CVE-2025-8188": {"epss_score": 0.00026, "epss_percentile": 0.0663}, "CVE-2025-8189": {"epss_score": 0.00026, "epss_percentile": 0.0663}, "CVE-2025-8190": {"epss_score": 0.00025, "epss_percentile": 0.06343}, "CVE-2025-8191": {"epss_score": 0.01065, "epss_percentile": 0.77207}, "CVE-2025-8192": {"epss_score": 0.00012, "epss_percentile": 0.01253}, "CVE-2025-8194": {"epss_score": 0.00102, "epss_percentile": 0.28819}, "CVE-2025-8195": {"epss_score": 0.00036, "epss_percentile": 0.10508}, "CVE-2025-8196": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-8198": {"epss_score": 0.00123, "epss_percentile": 0.32208}, "CVE-2025-8199": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-8200": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8203": {"epss_score": 0.00023, "epss_percentile": 0.05416}, "CVE-2025-8204": {"epss_score": 0.00086, "epss_percentile": 0.25387}, "CVE-2025-8205": {"epss_score": 0.00018, "epss_percentile": 0.03678}, "CVE-2025-8206": {"epss_score": 0.00029, "epss_percentile": 0.07606}, "CVE-2025-8207": {"epss_score": 0.00016, "epss_percentile": 0.02733}, "CVE-2025-8208": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-8210": {"epss_score": 0.00016, "epss_percentile": 0.02733}, "CVE-2025-8211": {"epss_score": 0.00029, "epss_percentile": 0.07668}, "CVE-2025-8212": {"epss_score": 0.00027, "epss_percentile": 0.06804}, "CVE-2025-8213": {"epss_score": 0.00159, "epss_percentile": 0.37382}, "CVE-2025-8214": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-8215": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-8216": {"epss_score": 0.00031, "epss_percentile": 0.08676}, "CVE-2025-8217": {"epss_score": 5e-05, "epss_percentile": 0.00221}, "CVE-2025-8218": {"epss_score": 0.00176, "epss_percentile": 0.39411}, "CVE-2025-8219": {"epss_score": 0.00029, "epss_percentile": 0.07693}, "CVE-2025-8220": {"epss_score": 9e-05, "epss_percentile": 0.00616}, "CVE-2025-8221": {"epss_score": 0.00034, "epss_percentile": 0.09775}, "CVE-2025-8222": {"epss_score": 0.00026, "epss_percentile": 0.06737}, "CVE-2025-8223": {"epss_score": 0.00048, "epss_percentile": 0.15074}, "CVE-2025-8224": {"epss_score": 0.00026, "epss_percentile": 0.0652}, "CVE-2025-8225": {"epss_score": 0.00019, "epss_percentile": 0.0439}, "CVE-2025-8226": {"epss_score": 0.00038, "epss_percentile": 0.11391}, "CVE-2025-8227": {"epss_score": 0.00092, "epss_percentile": 0.26427}, "CVE-2025-8228": {"epss_score": 0.00045, "epss_percentile": 0.13814}, "CVE-2025-8229": {"epss_score": 0.00026, "epss_percentile": 0.0663}, "CVE-2025-8230": {"epss_score": 0.00026, "epss_percentile": 0.0663}, "CVE-2025-8231": {"epss_score": 0.00076, "epss_percentile": 0.23255}, "CVE-2025-8232": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8233": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8234": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8235": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8236": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8237": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8238": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8239": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8240": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8241": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-8242": {"epss_score": 0.01331, "epss_percentile": 0.79516}, "CVE-2025-8243": {"epss_score": 0.00914, "epss_percentile": 0.75387}, "CVE-2025-8244": {"epss_score": 0.00928, "epss_percentile": 0.75585}, "CVE-2025-8245": {"epss_score": 0.00584, "epss_percentile": 0.6838}, "CVE-2025-8246": {"epss_score": 0.00584, "epss_percentile": 0.6838}, "CVE-2025-8247": {"epss_score": 0.00031, "epss_percentile": 0.08499}, "CVE-2025-8248": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8249": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-8250": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-8251": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-8252": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8253": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8254": {"epss_score": 0.00026, "epss_percentile": 0.0663}, "CVE-2025-8255": {"epss_score": 0.00056, "epss_percentile": 0.17811}, "CVE-2025-8256": {"epss_score": 0.00046, "epss_percentile": 0.14116}, "CVE-2025-8257": {"epss_score": 0.00018, "epss_percentile": 0.03656}, "CVE-2025-8258": {"epss_score": 0.00018, "epss_percentile": 0.03656}, "CVE-2025-8259": {"epss_score": 0.00213, "epss_percentile": 0.43902}, "CVE-2025-8260": {"epss_score": 0.00018, "epss_percentile": 0.04038}, "CVE-2025-8261": {"epss_score": 0.00061, "epss_percentile": 0.19526}, "CVE-2025-8262": {"epss_score": 0.00075, "epss_percentile": 0.22909}, "CVE-2025-8264": {"epss_score": 0.00104, "epss_percentile": 0.29102}, "CVE-2025-8265": {"epss_score": 0.00038, "epss_percentile": 0.11309}, "CVE-2025-8266": {"epss_score": 0.00188, "epss_percentile": 0.40861}, "CVE-2025-8267": {"epss_score": 0.0007, "epss_percentile": 0.2166}, "CVE-2025-8268": {"epss_score": 0.00165, "epss_percentile": 0.38106}, "CVE-2025-8269": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-8270": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-8271": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-8272": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-8273": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-8274": {"epss_score": 0.00038, "epss_percentile": 0.11263}, "CVE-2025-8275": {"epss_score": 0.00013, "epss_percentile": 0.01718}, "CVE-2025-8276": {"epss_score": 0.00045, "epss_percentile": 0.13795}, "CVE-2025-8277": {"epss_score": 0.00072, "epss_percentile": 0.2234}, "CVE-2025-8279": {"epss_score": 0.00016, "epss_percentile": 0.02933}, "CVE-2025-8280": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-8281": {"epss_score": 0.00161, "epss_percentile": 0.37548}, "CVE-2025-8282": {"epss_score": 0.00036, "epss_percentile": 0.10445}, "CVE-2025-8283": {"epss_score": 0.00037, "epss_percentile": 0.10841}, "CVE-2025-8284": {"epss_score": 0.00065, "epss_percentile": 0.20538}, "CVE-2025-8285": {"epss_score": 0.00029, "epss_percentile": 0.07746}, "CVE-2025-8286": {"epss_score": 0.00583, "epss_percentile": 0.68337}, "CVE-2025-8289": {"epss_score": 0.00216, "epss_percentile": 0.44228}, "CVE-2025-8290": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-8291": {"epss_score": 0.00127, "epss_percentile": 0.32782}, "CVE-2025-8292": {"epss_score": 0.00108, "epss_percentile": 0.29772}, "CVE-2025-8293": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-8294": {"epss_score": 0.00026, "epss_percentile": 0.06718}, "CVE-2025-8295": {"epss_score": 0.00028, "epss_percentile": 0.07475}, "CVE-2025-8296": {"epss_score": 0.00996, "epss_percentile": 0.76442}, "CVE-2025-8297": {"epss_score": 0.01832, "epss_percentile": 0.82451}, "CVE-2025-8298": {"epss_score": 0.00023, "epss_percentile": 0.05326}, "CVE-2025-8299": {"epss_score": 0.00028, "epss_percentile": 0.07508}, "CVE-2025-8300": {"epss_score": 0.00028, "epss_percentile": 0.07508}, "CVE-2025-8301": {"epss_score": 0.00028, "epss_percentile": 0.07508}, "CVE-2025-8302": {"epss_score": 0.00028, "epss_percentile": 0.07508}, "CVE-2025-8304": {"epss_score": 0.00014, "epss_percentile": 0.01871}, "CVE-2025-8305": {"epss_score": 0.00014, "epss_percentile": 0.01871}, "CVE-2025-8309": {"epss_score": 0.00051, "epss_percentile": 0.1629}, "CVE-2025-8310": {"epss_score": 0.00151, "epss_percentile": 0.3625}, "CVE-2025-8311": {"epss_score": 0.01771, "epss_percentile": 0.82199}, "CVE-2025-8312": {"epss_score": 0.00033, "epss_percentile": 0.09361}, "CVE-2025-8313": {"epss_score": 0.00028, "epss_percentile": 0.07475}, "CVE-2025-8314": {"epss_score": 0.00029, "epss_percentile": 0.07852}, "CVE-2025-8315": {"epss_score": 0.00028, "epss_percentile": 0.07475}, "CVE-2025-8316": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8317": {"epss_score": 0.00026, "epss_percentile": 0.06718}, "CVE-2025-8318": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8319": {"epss_score": 0.00039, "epss_percentile": 0.11468}, "CVE-2025-8320": {"epss_score": 0.00164, "epss_percentile": 0.37971}, "CVE-2025-8321": {"epss_score": 0.00053, "epss_percentile": 0.16825}, "CVE-2025-8322": {"epss_score": 0.00148, "epss_percentile": 0.35806}, "CVE-2025-8323": {"epss_score": 0.00211, "epss_percentile": 0.4367}, "CVE-2025-8324": {"epss_score": 0.03478, "epss_percentile": 0.87214}, "CVE-2025-8326": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8327": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8328": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8329": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8330": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8331": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8332": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8333": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8334": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-8335": {"epss_score": 0.00049, "epss_percentile": 0.15376}, "CVE-2025-8336": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-8337": {"epss_score": 0.00026, "epss_percentile": 0.06585}, "CVE-2025-8338": {"epss_score": 0.00032, "epss_percentile": 0.08828}, "CVE-2025-8339": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8340": {"epss_score": 0.00035, "epss_percentile": 0.0998}, "CVE-2025-8341": {"epss_score": 0.00031, "epss_percentile": 0.08536}, "CVE-2025-8342": {"epss_score": 0.00358, "epss_percentile": 0.5751}, "CVE-2025-8343": {"epss_score": 0.00082, "epss_percentile": 0.24548}, "CVE-2025-8344": {"epss_score": 0.0005, "epss_percentile": 0.15783}, "CVE-2025-8345": {"epss_score": 0.00029, "epss_percentile": 0.07693}, "CVE-2025-8346": {"epss_score": 0.00034, "epss_percentile": 0.09775}, "CVE-2025-8347": {"epss_score": 0.00023, "epss_percentile": 0.05653}, "CVE-2025-8348": {"epss_score": 0.00147, "epss_percentile": 0.35696}, "CVE-2025-8349": {"epss_score": 0.0007, "epss_percentile": 0.21966}, "CVE-2025-8351": {"epss_score": 0.00087, "epss_percentile": 0.25488}, "CVE-2025-8353": {"epss_score": 0.00047, "epss_percentile": 0.14642}, "CVE-2025-8354": {"epss_score": 0.00029, "epss_percentile": 0.07705}, "CVE-2025-8355": {"epss_score": 0.0006, "epss_percentile": 0.19161}, "CVE-2025-8356": {"epss_score": 0.00724, "epss_percentile": 0.72038}, "CVE-2025-8357": {"epss_score": 0.00057, "epss_percentile": 0.18139}, "CVE-2025-8359": {"epss_score": 0.0052, "epss_percentile": 0.66211}, "CVE-2025-8360": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-8361": {"epss_score": 0.00071, "epss_percentile": 0.22229}, "CVE-2025-8362": {"epss_score": 0.00053, "epss_percentile": 0.1685}, "CVE-2025-8364": {"epss_score": 0.00056, "epss_percentile": 0.17824}, "CVE-2025-8365": {"epss_score": 0.00042, "epss_percentile": 0.12622}, "CVE-2025-8366": {"epss_score": 0.00058, "epss_percentile": 0.18404}, "CVE-2025-8367": {"epss_score": 0.00058, "epss_percentile": 0.18404}, "CVE-2025-8368": {"epss_score": 0.00058, "epss_percentile": 0.18404}, "CVE-2025-8369": {"epss_score": 0.00058, "epss_percentile": 0.18404}, "CVE-2025-8370": {"epss_score": 0.00058, "epss_percentile": 0.18404}, "CVE-2025-8371": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8372": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8373": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8374": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8375": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8376": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8378": {"epss_score": 0.00029, "epss_percentile": 0.07793}, "CVE-2025-8379": {"epss_score": 0.00051, "epss_percentile": 0.15985}, "CVE-2025-8380": {"epss_score": 0.00027, "epss_percentile": 0.06768}, "CVE-2025-8381": {"epss_score": 0.00028, "epss_percentile": 0.07501}, "CVE-2025-8382": {"epss_score": 0.00028, "epss_percentile": 0.07501}, "CVE-2025-8383": {"epss_score": 0.00018, "epss_percentile": 0.03671}, "CVE-2025-8385": {"epss_score": 0.00102, "epss_percentile": 0.28782}, "CVE-2025-8386": {"epss_score": 0.0002, "epss_percentile": 0.04589}, "CVE-2025-8388": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8391": {"epss_score": 0.00026, "epss_percentile": 0.06718}, "CVE-2025-8392": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8393": {"epss_score": 7e-05, "epss_percentile": 0.00461}, "CVE-2025-8394": {"epss_score": 0.00045, "epss_percentile": 0.13997}, "CVE-2025-8396": {"epss_score": 0.00059, "epss_percentile": 0.18903}, "CVE-2025-8397": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-8398": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8399": {"epss_score": 0.00026, "epss_percentile": 0.06718}, "CVE-2025-8400": {"epss_score": 0.00099, "epss_percentile": 0.28386}, "CVE-2025-8401": {"epss_score": 0.00034, "epss_percentile": 0.09456}, "CVE-2025-8402": {"epss_score": 0.00133, "epss_percentile": 0.33625}, "CVE-2025-8404": {"epss_score": 0.00074, "epss_percentile": 0.22827}, "CVE-2025-8405": {"epss_score": 9e-05, "epss_percentile": 0.00655}, "CVE-2025-8406": {"epss_score": 0.00045, "epss_percentile": 0.14013}, "CVE-2025-8407": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8408": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8409": {"epss_score": 0.00028, "epss_percentile": 0.07436}, "CVE-2025-8410": {"epss_score": 0.00047, "epss_percentile": 0.14612}, "CVE-2025-8411": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-8413": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-8414": {"epss_score": 0.0006, "epss_percentile": 0.19223}, "CVE-2025-8415": {"epss_score": 0.00049, "epss_percentile": 0.15607}, "CVE-2025-8416": {"epss_score": 0.00106, "epss_percentile": 0.29509}, "CVE-2025-8417": {"epss_score": 0.00249, "epss_percentile": 0.48052}, "CVE-2025-8418": {"epss_score": 0.0023, "epss_percentile": 0.45726}, "CVE-2025-8419": {"epss_score": 0.00014, "epss_percentile": 0.01818}, "CVE-2025-8420": {"epss_score": 0.00217, "epss_percentile": 0.44305}, "CVE-2025-8421": {"epss_score": 0.00014, "epss_percentile": 0.01912}, "CVE-2025-8422": {"epss_score": 0.00087, "epss_percentile": 0.25542}, "CVE-2025-8423": {"epss_score": 0.00057, "epss_percentile": 0.18074}, "CVE-2025-8424": {"epss_score": 0.00066, "epss_percentile": 0.20852}, "CVE-2025-8425": {"epss_score": 0.00058, "epss_percentile": 0.18559}, "CVE-2025-8426": {"epss_score": 0.23947, "epss_percentile": 0.95836}, "CVE-2025-8427": {"epss_score": 0.00039, "epss_percentile": 0.11688}, "CVE-2025-8428": {"epss_score": 0.0001, "epss_percentile": 0.00811}, "CVE-2025-8429": {"epss_score": 0.0001, "epss_percentile": 0.00779}, "CVE-2025-8430": {"epss_score": 0.0001, "epss_percentile": 0.00779}, "CVE-2025-8431": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8432": {"epss_score": 0.00051, "epss_percentile": 0.16051}, "CVE-2025-8433": {"epss_score": 0.00051, "epss_percentile": 0.15989}, "CVE-2025-8434": {"epss_score": 0.00042, "epss_percentile": 0.12572}, "CVE-2025-8435": {"epss_score": 0.00055, "epss_percentile": 0.17462}, "CVE-2025-8436": {"epss_score": 0.00021, "epss_percentile": 0.04749}, "CVE-2025-8437": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8438": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8439": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8440": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8441": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8442": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8443": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8445": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-8446": {"epss_score": 0.00037, "epss_percentile": 0.10898}, "CVE-2025-8447": {"epss_score": 0.00031, "epss_percentile": 0.0844}, "CVE-2025-8448": {"epss_score": 0.00038, "epss_percentile": 0.11383}, "CVE-2025-8449": {"epss_score": 0.00033, "epss_percentile": 0.09391}, "CVE-2025-8450": {"epss_score": 0.00208, "epss_percentile": 0.43298}, "CVE-2025-8451": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-8452": {"epss_score": 0.00016, "epss_percentile": 0.02954}, "CVE-2025-8453": {"epss_score": 0.00022, "epss_percentile": 0.05192}, "CVE-2025-8454": {"epss_score": 0.00028, "epss_percentile": 0.07488}, "CVE-2025-8459": {"epss_score": 0.0001, "epss_percentile": 0.00811}, "CVE-2025-8460": {"epss_score": 0.0002, "epss_percentile": 0.04484}, "CVE-2025-8462": {"epss_score": 0.00028, "epss_percentile": 0.07288}, "CVE-2025-8463": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-8464": {"epss_score": 0.00988, "epss_percentile": 0.7635}, "CVE-2025-8466": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8467": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8468": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8469": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8470": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8471": {"epss_score": 0.00052, "epss_percentile": 0.1656}, "CVE-2025-8472": {"epss_score": 0.00057, "epss_percentile": 0.18214}, "CVE-2025-8473": {"epss_score": 0.00027, "epss_percentile": 0.06843}, "CVE-2025-8474": {"epss_score": 0.0002, "epss_percentile": 0.04626}, "CVE-2025-8475": {"epss_score": 0.00044, "epss_percentile": 0.1368}, "CVE-2025-8476": {"epss_score": 0.00014, "epss_percentile": 0.01994}, "CVE-2025-8477": {"epss_score": 0.00057, "epss_percentile": 0.18214}, "CVE-2025-8479": {"epss_score": 0.00017, "epss_percentile": 0.03118}, "CVE-2025-8480": {"epss_score": 0.0008, "epss_percentile": 0.24156}, "CVE-2025-8481": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-8482": {"epss_score": 0.00031, "epss_percentile": 0.08659}, "CVE-2025-8483": {"epss_score": 0.00091, "epss_percentile": 0.26294}, "CVE-2025-8484": {"epss_score": 0.00057, "epss_percentile": 0.18133}, "CVE-2025-8485": {"epss_score": 0.00012, "epss_percentile": 0.01389}, "CVE-2025-8486": {"epss_score": 0.0002, "epss_percentile": 0.04607}, "CVE-2025-8487": {"epss_score": 0.0005, "epss_percentile": 0.15866}, "CVE-2025-8488": {"epss_score": 0.00028, "epss_percentile": 0.07537}, "CVE-2025-8489": {"epss_score": 0.48941, "epss_percentile": 0.97659}, "CVE-2025-8490": {"epss_score": 0.00048, "epss_percentile": 0.15286}, "CVE-2025-8491": {"epss_score": 0.00024, "epss_percentile": 0.06035}, "CVE-2025-8492": {"epss_score": 0.001, "epss_percentile": 0.2856}, "CVE-2025-8493": {"epss_score": 0.00026, "epss_percentile": 0.0648}, "CVE-2025-8494": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8495": {"epss_score": 0.00027, "epss_percentile": 0.06934}, "CVE-2025-8496": {"epss_score": 0.00027, "epss_percentile": 0.06934}, "CVE-2025-8497": {"epss_score": 0.00027, "epss_percentile": 0.06934}, "CVE-2025-8498": {"epss_score": 0.00027, "epss_percentile": 0.06934}, "CVE-2025-8499": {"epss_score": 0.00027, "epss_percentile": 0.06934}, "CVE-2025-8500": {"epss_score": 0.00024, "epss_percentile": 0.05881}, "CVE-2025-8501": {"epss_score": 0.00028, "epss_percentile": 0.07326}, "CVE-2025-8502": {"epss_score": 0.00027, "epss_percentile": 0.06934}, "CVE-2025-8503": {"epss_score": 0.00027, "epss_percentile": 0.06934}, "CVE-2025-8504": {"epss_score": 0.00044, "epss_percentile": 0.13519}, "CVE-2025-8505": {"epss_score": 0.00012, "epss_percentile": 0.01334}, "CVE-2025-8506": {"epss_score": 0.0002, "epss_percentile": 0.04481}, "CVE-2025-8507": {"epss_score": 0.00023, "epss_percentile": 0.05645}, "CVE-2025-8508": {"epss_score": 0.00023, "epss_percentile": 0.05645}, "CVE-2025-8509": {"epss_score": 0.00023, "epss_percentile": 0.05645}, "CVE-2025-8510": {"epss_score": 0.00025, "epss_percentile": 0.06352}, "CVE-2025-8511": {"epss_score": 0.00023, "epss_percentile": 0.05645}, "CVE-2025-8512": {"epss_score": 0.0001, "epss_percentile": 0.009}, "CVE-2025-8513": {"epss_score": 0.0001, "epss_percentile": 0.009}, "CVE-2025-8515": {"epss_score": 0.00021, "epss_percentile": 0.04905}, "CVE-2025-8516": {"epss_score": 0.00061, "epss_percentile": 0.19511}, "CVE-2025-8517": {"epss_score": 0.00082, "epss_percentile": 0.24582}, "CVE-2025-8518": {"epss_score": 0.16724, "epss_percentile": 0.94721}, "CVE-2025-8519": {"epss_score": 0.00042, "epss_percentile": 0.12647}, "CVE-2025-8520": {"epss_score": 0.00064, "epss_percentile": 0.20147}, "CVE-2025-8521": {"epss_score": 0.0003, "epss_percentile": 0.08235}, "CVE-2025-8522": {"epss_score": 0.00051, "epss_percentile": 0.16107}, "CVE-2025-8523": {"epss_score": 0.0001, "epss_percentile": 0.009}, "CVE-2025-8524": {"epss_score": 0.0001, "epss_percentile": 0.009}, "CVE-2025-8525": {"epss_score": 0.00031, "epss_percentile": 0.08699}, "CVE-2025-8526": {"epss_score": 0.00034, "epss_percentile": 0.09482}, "CVE-2025-8527": {"epss_score": 0.00032, "epss_percentile": 0.08853}, "CVE-2025-8528": {"epss_score": 0.00017, "epss_percentile": 0.03417}, "CVE-2025-8529": {"epss_score": 0.00032, "epss_percentile": 0.08951}, "CVE-2025-8530": {"epss_score": 0.00033, "epss_percentile": 0.09341}, "CVE-2025-8531": {"epss_score": 0.00336, "epss_percentile": 0.55926}, "CVE-2025-8532": {"epss_score": 0.00016, "epss_percentile": 0.02887}, "CVE-2025-8533": {"epss_score": 0.00049, "epss_percentile": 0.156}, "CVE-2025-8534": {"epss_score": 0.00021, "epss_percentile": 0.04788}, "CVE-2025-8535": {"epss_score": 0.00059, "epss_percentile": 0.18806}, "CVE-2025-8536": {"epss_score": 0.00045, "epss_percentile": 0.13956}, "CVE-2025-8537": {"epss_score": 0.00161, "epss_percentile": 0.37538}, "CVE-2025-8538": {"epss_score": 0.00024, "epss_percentile": 0.06031}, "CVE-2025-8539": {"epss_score": 0.00024, "epss_percentile": 0.06031}, "CVE-2025-8540": {"epss_score": 0.00024, "epss_percentile": 0.06031}, "CVE-2025-8541": {"epss_score": 0.00023, "epss_percentile": 0.05602}, "CVE-2025-8542": {"epss_score": 0.00023, "epss_percentile": 0.05602}, "CVE-2025-8543": {"epss_score": 0.00023, "epss_percentile": 0.05602}, "CVE-2025-8544": {"epss_score": 0.00023, "epss_percentile": 0.05602}, "CVE-2025-8545": {"epss_score": 0.00023, "epss_percentile": 0.05602}, "CVE-2025-8546": {"epss_score": 0.00044, "epss_percentile": 0.13618}, "CVE-2025-8547": {"epss_score": 0.00056, "epss_percentile": 0.17769}, "CVE-2025-8548": {"epss_score": 0.00043, "epss_percentile": 0.13271}, "CVE-2025-8549": {"epss_score": 0.00044, "epss_percentile": 0.13618}, "CVE-2025-8550": {"epss_score": 0.00224, "epss_percentile": 0.45064}, "CVE-2025-8551": {"epss_score": 0.00027, "epss_percentile": 0.0695}, "CVE-2025-8552": {"epss_score": 0.00026, "epss_percentile": 0.06662}, "CVE-2025-8553": {"epss_score": 0.00026, "epss_percentile": 0.06662}, "CVE-2025-8554": {"epss_score": 0.00026, "epss_percentile": 0.06662}, "CVE-2025-8555": {"epss_score": 0.00027, "epss_percentile": 0.0695}, "CVE-2025-8556": {"epss_score": 0.00011, "epss_percentile": 0.01024}, "CVE-2025-8557": {"epss_score": 0.00026, "epss_percentile": 0.06577}, "CVE-2025-8558": {"epss_score": 0.00079, "epss_percentile": 0.23984}, "CVE-2025-8559": {"epss_score": 0.00057, "epss_percentile": 0.18076}, "CVE-2025-8560": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8561": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8562": {"epss_score": 0.00069, "epss_percentile": 0.21552}, "CVE-2025-8564": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-8565": {"epss_score": 0.00065, "epss_percentile": 0.20545}, "CVE-2025-8566": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-8567": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-8568": {"epss_score": 0.00028, "epss_percentile": 0.07211}, "CVE-2025-8570": {"epss_score": 0.00055, "epss_percentile": 0.17521}, "CVE-2025-8571": {"epss_score": 0.00038, "epss_percentile": 0.11417}, "CVE-2025-8573": {"epss_score": 0.00098, "epss_percentile": 0.27717}, "CVE-2025-8575": {"epss_score": 0.00938, "epss_percentile": 0.75708}, "CVE-2025-8576": {"epss_score": 0.00127, "epss_percentile": 0.32837}, "CVE-2025-8577": {"epss_score": 0.00036, "epss_percentile": 0.10526}, "CVE-2025-8578": {"epss_score": 0.00127, "epss_percentile": 0.32837}, "CVE-2025-8579": {"epss_score": 0.00036, "epss_percentile": 0.10526}, "CVE-2025-8580": {"epss_score": 0.00036, "epss_percentile": 0.10526}, "CVE-2025-8581": {"epss_score": 0.00035, "epss_percentile": 0.09866}, "CVE-2025-8582": {"epss_score": 0.00056, "epss_percentile": 0.17887}, "CVE-2025-8583": {"epss_score": 0.00031, "epss_percentile": 0.0865}, "CVE-2025-8584": {"epss_score": 0.00023, "epss_percentile": 0.05623}, "CVE-2025-8585": {"epss_score": 0.00023, "epss_percentile": 0.05589}, "CVE-2025-8586": {"epss_score": 0.00023, "epss_percentile": 0.05623}, "CVE-2025-8588": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8592": {"epss_score": 0.0003, "epss_percentile": 0.08054}, "CVE-2025-8593": {"epss_score": 0.00076, "epss_percentile": 0.23141}, "CVE-2025-8594": {"epss_score": 0.00035, "epss_percentile": 0.09865}, "CVE-2025-8595": {"epss_score": 0.00028, "epss_percentile": 0.07537}, "CVE-2025-8597": {"epss_score": 0.00022, "epss_percentile": 0.05264}, "CVE-2025-8603": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-8604": {"epss_score": 0.00055, "epss_percentile": 0.17592}, "CVE-2025-8605": {"epss_score": 0.00037, "epss_percentile": 0.10856}, "CVE-2025-8606": {"epss_score": 0.00018, "epss_percentile": 0.0384}, "CVE-2025-8607": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-8608": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-8609": {"epss_score": 0.00037, "epss_percentile": 0.10719}, "CVE-2025-8610": {"epss_score": 0.02616, "epss_percentile": 0.85247}, "CVE-2025-8611": {"epss_score": 0.02616, "epss_percentile": 0.85247}, "CVE-2025-8612": {"epss_score": 0.00019, "epss_percentile": 0.0419}, "CVE-2025-8613": {"epss_score": 0.00485, "epss_percentile": 0.64722}, "CVE-2025-8614": {"epss_score": 0.00032, "epss_percentile": 0.08768}, "CVE-2025-8616": {"epss_score": 0.00053, "epss_percentile": 0.16844}, "CVE-2025-8617": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-8618": {"epss_score": 0.00055, "epss_percentile": 0.17592}, "CVE-2025-8619": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-8620": {"epss_score": 0.0004, "epss_percentile": 0.12033}, "CVE-2025-8621": {"epss_score": 0.00028, "epss_percentile": 0.07288}, "CVE-2025-8622": {"epss_score": 0.00055, "epss_percentile": 0.17592}, "CVE-2025-8623": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8624": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-8625": {"epss_score": 0.00288, "epss_percentile": 0.51882}, "CVE-2025-8627": {"epss_score": 0.00032, "epss_percentile": 0.08804}, "CVE-2025-8628": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8629": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8630": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8631": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8632": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8633": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8634": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8635": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8636": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8637": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8638": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8639": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8640": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8641": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8642": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8643": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8644": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8645": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8646": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8647": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8648": {"epss_score": 0.00054, "epss_percentile": 0.17123}, "CVE-2025-8649": {"epss_score": 0.00098, "epss_percentile": 0.2776}, "CVE-2025-8650": {"epss_score": 0.00098, "epss_percentile": 0.2776}, "CVE-2025-8651": {"epss_score": 0.00098, "epss_percentile": 0.2776}, "CVE-2025-8652": {"epss_score": 0.00098, "epss_percentile": 0.2776}, "CVE-2025-8653": {"epss_score": 0.00073, "epss_percentile": 0.22614}, "CVE-2025-8654": {"epss_score": 0.0009, "epss_percentile": 0.26095}, "CVE-2025-8655": {"epss_score": 0.00098, "epss_percentile": 0.2776}, "CVE-2025-8656": {"epss_score": 0.0005, "epss_percentile": 0.15972}, "CVE-2025-8660": {"epss_score": 0.00034, "epss_percentile": 0.09803}, "CVE-2025-8661": {"epss_score": 0.00019, "epss_percentile": 0.04067}, "CVE-2025-8662": {"epss_score": 0.0012, "epss_percentile": 0.31737}, "CVE-2025-8663": {"epss_score": 0.00059, "epss_percentile": 0.18722}, "CVE-2025-8664": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-8665": {"epss_score": 0.00396, "epss_percentile": 0.59905}, "CVE-2025-8666": {"epss_score": 0.00054, "epss_percentile": 0.17188}, "CVE-2025-8667": {"epss_score": 0.00396, "epss_percentile": 0.59905}, "CVE-2025-8669": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-8671": {"epss_score": 0.00157, "epss_percentile": 0.37097}, "CVE-2025-8672": {"epss_score": 0.00015, "epss_percentile": 0.02286}, "CVE-2025-8675": {"epss_score": 0.00056, "epss_percentile": 0.17678}, "CVE-2025-8676": {"epss_score": 0.00049, "epss_percentile": 0.15576}, "CVE-2025-8677": {"epss_score": 0.00065, "epss_percentile": 0.20517}, "CVE-2025-8678": {"epss_score": 0.00045, "epss_percentile": 0.13793}, "CVE-2025-8679": {"epss_score": 0.00035, "epss_percentile": 0.09855}, "CVE-2025-8680": {"epss_score": 0.00045, "epss_percentile": 0.14014}, "CVE-2025-8681": {"epss_score": 0.0004, "epss_percentile": 0.1196}, "CVE-2025-8682": {"epss_score": 0.00084, "epss_percentile": 0.24932}, "CVE-2025-8684": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-8685": {"epss_score": 0.00028, "epss_percentile": 0.07211}, "CVE-2025-8686": {"epss_score": 0.00045, "epss_percentile": 0.13997}, "CVE-2025-8687": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-8688": {"epss_score": 0.00028, "epss_percentile": 0.07211}, "CVE-2025-8689": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-8690": {"epss_score": 0.00028, "epss_percentile": 0.07211}, "CVE-2025-8691": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8692": {"epss_score": 0.00035, "epss_percentile": 0.10061}, "CVE-2025-8693": {"epss_score": 0.00157, "epss_percentile": 0.37141}, "CVE-2025-8695": {"epss_score": 0.00068, "epss_percentile": 0.21204}, "CVE-2025-8696": {"epss_score": 0.00097, "epss_percentile": 0.27467}, "CVE-2025-8697": {"epss_score": 0.00396, "epss_percentile": 0.59905}, "CVE-2025-8698": {"epss_score": 0.0001, "epss_percentile": 0.00849}, "CVE-2025-8699": {"epss_score": 0.00046, "epss_percentile": 0.14314}, "CVE-2025-8700": {"epss_score": 0.00022, "epss_percentile": 0.05264}, "CVE-2025-8701": {"epss_score": 0.0002, "epss_percentile": 0.04586}, "CVE-2025-8702": {"epss_score": 0.0002, "epss_percentile": 0.04586}, "CVE-2025-8703": {"epss_score": 0.0002, "epss_percentile": 0.04586}, "CVE-2025-8704": {"epss_score": 0.0002, "epss_percentile": 0.04586}, "CVE-2025-8705": {"epss_score": 0.0002, "epss_percentile": 0.04586}, "CVE-2025-8706": {"epss_score": 0.0002, "epss_percentile": 0.04586}, "CVE-2025-8707": {"epss_score": 0.00014, "epss_percentile": 0.02109}, "CVE-2025-8708": {"epss_score": 0.00053, "epss_percentile": 0.16879}, "CVE-2025-8709": {"epss_score": 0.00029, "epss_percentile": 0.07843}, "CVE-2025-8711": {"epss_score": 0.00106, "epss_percentile": 0.29468}, "CVE-2025-8712": {"epss_score": 0.00463, "epss_percentile": 0.63671}, "CVE-2025-8713": {"epss_score": 0.00057, "epss_percentile": 0.18103}, "CVE-2025-8714": {"epss_score": 0.00032, "epss_percentile": 0.09035}, "CVE-2025-8715": {"epss_score": 0.00072, "epss_percentile": 0.22439}, "CVE-2025-8716": {"epss_score": 0.00063, "epss_percentile": 0.19809}, "CVE-2025-8719": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-8720": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-8721": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8722": {"epss_score": 0.00055, "epss_percentile": 0.17592}, "CVE-2025-8723": {"epss_score": 0.00846, "epss_percentile": 0.74331}, "CVE-2025-8726": {"epss_score": 0.00039, "epss_percentile": 0.11576}, "CVE-2025-8727": {"epss_score": 0.00056, "epss_percentile": 0.17809}, "CVE-2025-8729": {"epss_score": 0.00061, "epss_percentile": 0.19449}, "CVE-2025-8730": {"epss_score": 0.20824, "epss_percentile": 0.95419}, "CVE-2025-8731": {"epss_score": 0.00142, "epss_percentile": 0.35091}, "CVE-2025-8732": {"epss_score": 0.0001, "epss_percentile": 0.00829}, "CVE-2025-8735": {"epss_score": 0.00012, "epss_percentile": 0.01136}, "CVE-2025-8736": {"epss_score": 0.00012, "epss_percentile": 0.01128}, "CVE-2025-8737": {"epss_score": 0.00023, "epss_percentile": 0.05333}, "CVE-2025-8738": {"epss_score": 0.00027, "epss_percentile": 0.06806}, "CVE-2025-8739": {"epss_score": 0.00027, "epss_percentile": 0.07107}, "CVE-2025-8740": {"epss_score": 0.0002, "epss_percentile": 0.04546}, "CVE-2025-8741": {"epss_score": 0.00017, "epss_percentile": 0.03152}, "CVE-2025-8742": {"epss_score": 0.00096, "epss_percentile": 0.27321}, "CVE-2025-8743": {"epss_score": 0.00023, "epss_percentile": 0.05645}, "CVE-2025-8744": {"epss_score": 0.00019, "epss_percentile": 0.04272}, "CVE-2025-8745": {"epss_score": 0.00014, "epss_percentile": 0.02109}, "CVE-2025-8746": {"epss_score": 0.00022, "epss_percentile": 0.05006}, "CVE-2025-8747": {"epss_score": 8e-05, "epss_percentile": 0.00565}, "CVE-2025-8748": {"epss_score": 0.00159, "epss_percentile": 0.373}, "CVE-2025-8749": {"epss_score": 0.00056, "epss_percentile": 0.17864}, "CVE-2025-8750": {"epss_score": 0.0002, "epss_percentile": 0.04546}, "CVE-2025-8751": {"epss_score": 0.00026, "epss_percentile": 0.0643}, "CVE-2025-8752": {"epss_score": 0.00086, "epss_percentile": 0.25343}, "CVE-2025-8753": {"epss_score": 0.00054, "epss_percentile": 0.17345}, "CVE-2025-8754": {"epss_score": 0.00099, "epss_percentile": 0.28393}, "CVE-2025-8755": {"epss_score": 0.00032, "epss_percentile": 0.08819}, "CVE-2025-8756": {"epss_score": 0.00034, "epss_percentile": 0.09527}, "CVE-2025-8757": {"epss_score": 9e-05, "epss_percentile": 0.00637}, "CVE-2025-8758": {"epss_score": 9e-05, "epss_percentile": 0.00637}, "CVE-2025-8759": {"epss_score": 0.00023, "epss_percentile": 0.0549}, "CVE-2025-8760": {"epss_score": 0.00085, "epss_percentile": 0.25138}, "CVE-2025-8761": {"epss_score": 0.00164, "epss_percentile": 0.37955}, "CVE-2025-8762": {"epss_score": 0.00021, "epss_percentile": 0.04869}, "CVE-2025-8763": {"epss_score": 9e-05, "epss_percentile": 0.00636}, "CVE-2025-8764": {"epss_score": 0.00022, "epss_percentile": 0.05178}, "CVE-2025-8765": {"epss_score": 0.00019, "epss_percentile": 0.04064}, "CVE-2025-8767": {"epss_score": 0.00024, "epss_percentile": 0.05665}, "CVE-2025-8769": {"epss_score": 0.01232, "epss_percentile": 0.78736}, "CVE-2025-8770": {"epss_score": 0.00021, "epss_percentile": 0.04693}, "CVE-2025-8772": {"epss_score": 0.00021, "epss_percentile": 0.04807}, "CVE-2025-8773": {"epss_score": 0.0002, "epss_percentile": 0.04558}, "CVE-2025-8774": {"epss_score": 0.00012, "epss_percentile": 0.01265}, "CVE-2025-8775": {"epss_score": 0.00032, "epss_percentile": 0.0911}, "CVE-2025-8776": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8777": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-8778": {"epss_score": 0.0004, "epss_percentile": 0.11868}, "CVE-2025-8779": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-8780": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-8783": {"epss_score": 0.00048, "epss_percentile": 0.15122}, "CVE-2025-8784": {"epss_score": 0.00029, "epss_percentile": 0.07942}, "CVE-2025-8785": {"epss_score": 0.00023, "epss_percentile": 0.05645}, "CVE-2025-8786": {"epss_score": 0.00023, "epss_percentile": 0.05645}, "CVE-2025-8787": {"epss_score": 0.00023, "epss_percentile": 0.05645}, "CVE-2025-8788": {"epss_score": 0.00023, "epss_percentile": 0.05645}, "CVE-2025-8789": {"epss_score": 0.00021, "epss_percentile": 0.04807}, "CVE-2025-8790": {"epss_score": 0.00019, "epss_percentile": 0.04388}, "CVE-2025-8791": {"epss_score": 0.0003, "epss_percentile": 0.08155}, "CVE-2025-8792": {"epss_score": 0.00039, "epss_percentile": 0.11669}, "CVE-2025-8793": {"epss_score": 0.00027, "epss_percentile": 0.07115}, "CVE-2025-8794": {"epss_score": 0.00012, "epss_percentile": 0.0143}, "CVE-2025-8795": {"epss_score": 0.00031, "epss_percentile": 0.08457}, "CVE-2025-8796": {"epss_score": 0.0004, "epss_percentile": 0.11919}, "CVE-2025-8797": {"epss_score": 0.00031, "epss_percentile": 0.08457}, "CVE-2025-8798": {"epss_score": 0.00025, "epss_percentile": 0.06106}, "CVE-2025-8799": {"epss_score": 0.00239, "epss_percentile": 0.46869}, "CVE-2025-8800": {"epss_score": 0.00105, "epss_percentile": 0.29352}, "CVE-2025-8801": {"epss_score": 0.00239, "epss_percentile": 0.46869}, "CVE-2025-8802": {"epss_score": 0.00146, "epss_percentile": 0.35615}, "CVE-2025-8803": {"epss_score": 0.00105, "epss_percentile": 0.29352}, "CVE-2025-8804": {"epss_score": 0.00152, "epss_percentile": 0.3643}, "CVE-2025-8805": {"epss_score": 0.00239, "epss_percentile": 0.46869}, "CVE-2025-8806": {"epss_score": 0.0002, "epss_percentile": 0.04466}, "CVE-2025-8807": {"epss_score": 0.00031, "epss_percentile": 0.08457}, "CVE-2025-8808": {"epss_score": 0.00019, "epss_percentile": 0.04399}, "CVE-2025-8809": {"epss_score": 0.00021, "epss_percentile": 0.04749}, "CVE-2025-8810": {"epss_score": 0.00113, "epss_percentile": 0.30632}, "CVE-2025-8811": {"epss_score": 0.00021, "epss_percentile": 0.04749}, "CVE-2025-8812": {"epss_score": 0.00024, "epss_percentile": 0.0599}, "CVE-2025-8813": {"epss_score": 0.00031, "epss_percentile": 0.08395}, "CVE-2025-8814": {"epss_score": 0.00021, "epss_percentile": 0.04812}, "CVE-2025-8815": {"epss_score": 0.00155, "epss_percentile": 0.36844}, "CVE-2025-8816": {"epss_score": 0.00148, "epss_percentile": 0.35852}, "CVE-2025-8817": {"epss_score": 0.00148, "epss_percentile": 0.35852}, "CVE-2025-8818": {"epss_score": 0.00176, "epss_percentile": 0.39489}, "CVE-2025-8819": {"epss_score": 0.00148, "epss_percentile": 0.35852}, "CVE-2025-8820": {"epss_score": 0.00148, "epss_percentile": 0.35852}, "CVE-2025-8821": {"epss_score": 0.00176, "epss_percentile": 0.39489}, "CVE-2025-8822": {"epss_score": 0.00148, "epss_percentile": 0.35852}, "CVE-2025-8823": {"epss_score": 0.00176, "epss_percentile": 0.39489}, "CVE-2025-8824": {"epss_score": 0.00148, "epss_percentile": 0.35852}, "CVE-2025-8825": {"epss_score": 0.00176, "epss_percentile": 0.39489}, "CVE-2025-8826": {"epss_score": 0.00148, "epss_percentile": 0.35852}, "CVE-2025-8827": {"epss_score": 0.00176, "epss_percentile": 0.39489}, "CVE-2025-8828": {"epss_score": 0.00176, "epss_percentile": 0.39489}, "CVE-2025-8829": {"epss_score": 0.00176, "epss_percentile": 0.39489}, "CVE-2025-8830": {"epss_score": 0.00176, "epss_percentile": 0.39489}, "CVE-2025-8831": {"epss_score": 0.00148, "epss_percentile": 0.35852}, "CVE-2025-8832": {"epss_score": 0.00148, "epss_percentile": 0.35852}, "CVE-2025-8833": {"epss_score": 0.00148, "epss_percentile": 0.35852}, "CVE-2025-8834": {"epss_score": 0.00018, "epss_percentile": 0.03849}, "CVE-2025-8835": {"epss_score": 0.00025, "epss_percentile": 0.06112}, "CVE-2025-8836": {"epss_score": 0.00022, "epss_percentile": 0.04967}, "CVE-2025-8837": {"epss_score": 0.00033, "epss_percentile": 0.0935}, "CVE-2025-8838": {"epss_score": 0.00096, "epss_percentile": 0.2744}, "CVE-2025-8839": {"epss_score": 0.00031, "epss_percentile": 0.08457}, "CVE-2025-8840": {"epss_score": 0.0004, "epss_percentile": 0.12162}, "CVE-2025-8841": {"epss_score": 0.00028, "epss_percentile": 0.07249}, "CVE-2025-8842": {"epss_score": 0.00023, "epss_percentile": 0.05393}, "CVE-2025-8843": {"epss_score": 0.00028, "epss_percentile": 0.07543}, "CVE-2025-8844": {"epss_score": 0.0002, "epss_percentile": 0.04629}, "CVE-2025-8845": {"epss_score": 0.00023, "epss_percentile": 0.05393}, "CVE-2025-8846": {"epss_score": 0.00023, "epss_percentile": 0.05393}, "CVE-2025-8847": {"epss_score": 0.00019, "epss_percentile": 0.04335}, "CVE-2025-8848": {"epss_score": 0.00062, "epss_percentile": 0.19728}, "CVE-2025-8849": {"epss_score": 0.00069, "epss_percentile": 0.2148}, "CVE-2025-8850": {"epss_score": 0.00112, "epss_percentile": 0.30415}, "CVE-2025-8851": {"epss_score": 0.00013, "epss_percentile": 0.01527}, "CVE-2025-8852": {"epss_score": 0.00025, "epss_percentile": 0.06216}, "CVE-2025-8853": {"epss_score": 0.00169, "epss_percentile": 0.38597}, "CVE-2025-8854": {"epss_score": 0.00342, "epss_percentile": 0.56392}, "CVE-2025-8855": {"epss_score": 0.00051, "epss_percentile": 0.16029}, "CVE-2025-8857": {"epss_score": 0.00138, "epss_percentile": 0.34431}, "CVE-2025-8858": {"epss_score": 0.00081, "epss_percentile": 0.24395}, "CVE-2025-8859": {"epss_score": 0.00021, "epss_percentile": 0.04774}, "CVE-2025-8861": {"epss_score": 0.00267, "epss_percentile": 0.50006}, "CVE-2025-8862": {"epss_score": 0.00038, "epss_percentile": 0.11345}, "CVE-2025-8863": {"epss_score": 0.00024, "epss_percentile": 0.05816}, "CVE-2025-8864": {"epss_score": 0.00017, "epss_percentile": 0.03133}, "CVE-2025-8865": {"epss_score": 0.00018, "epss_percentile": 0.03943}, "CVE-2025-8866": {"epss_score": 0.00067, "epss_percentile": 0.21051}, "CVE-2025-8867": {"epss_score": 0.00103, "epss_percentile": 0.29056}, "CVE-2025-8868": {"epss_score": 0.18444, "epss_percentile": 0.95017}, "CVE-2025-8869": {"epss_score": 0.0002, "epss_percentile": 0.04659}, "CVE-2025-8870": {"epss_score": 0.00025, "epss_percentile": 0.06216}, "CVE-2025-8871": {"epss_score": 0.00098, "epss_percentile": 0.27807}, "CVE-2025-8872": {"epss_score": 0.00024, "epss_percentile": 0.05768}, "CVE-2025-8874": {"epss_score": 0.00031, "epss_percentile": 0.08648}, "CVE-2025-8875": {"epss_score": 0.05085, "epss_percentile": 0.89477}, "CVE-2025-8876": {"epss_score": 0.13881, "epss_percentile": 0.94083}, "CVE-2025-8877": {"epss_score": 0.00096, "epss_percentile": 0.27361}, "CVE-2025-8878": {"epss_score": 0.00418, "epss_percentile": 0.61269}, "CVE-2025-8879": {"epss_score": 0.0009, "epss_percentile": 0.26081}, "CVE-2025-8880": {"epss_score": 0.0009, "epss_percentile": 0.26079}, "CVE-2025-8881": {"epss_score": 0.00019, "epss_percentile": 0.042}, "CVE-2025-8882": {"epss_score": 0.00134, "epss_percentile": 0.33801}, "CVE-2025-8884": {"epss_score": 0.00017, "epss_percentile": 0.03255}, "CVE-2025-8885": {"epss_score": 0.0006, "epss_percentile": 0.192}, "CVE-2025-8886": {"epss_score": 0.00023, "epss_percentile": 0.05592}, "CVE-2025-8887": {"epss_score": 0.00017, "epss_percentile": 0.03175}, "CVE-2025-8889": {"epss_score": 0.00038, "epss_percentile": 0.11109}, "CVE-2025-8890": {"epss_score": 0.00569, "epss_percentile": 0.6793}, "CVE-2025-8891": {"epss_score": 0.0003, "epss_percentile": 0.08201}, "CVE-2025-8892": {"epss_score": 0.00029, "epss_percentile": 0.07705}, "CVE-2025-8893": {"epss_score": 0.00036, "epss_percentile": 0.10456}, "CVE-2025-8894": {"epss_score": 0.00029, "epss_percentile": 0.07705}, "CVE-2025-8895": {"epss_score": 0.00202, "epss_percentile": 0.42401}, "CVE-2025-8896": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-8897": {"epss_score": 0.00158, "epss_percentile": 0.37175}, "CVE-2025-8898": {"epss_score": 0.00177, "epss_percentile": 0.39525}, "CVE-2025-8900": {"epss_score": 0.0014, "epss_percentile": 0.34789}, "CVE-2025-8901": {"epss_score": 0.00065, "epss_percentile": 0.20441}, "CVE-2025-8902": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-8904": {"epss_score": 0.00071, "epss_percentile": 0.22176}, "CVE-2025-8905": {"epss_score": 0.00436, "epss_percentile": 0.62479}, "CVE-2025-8906": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-8907": {"epss_score": 0.00022, "epss_percentile": 0.04992}, "CVE-2025-8908": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-8909": {"epss_score": 0.0009, "epss_percentile": 0.26091}, "CVE-2025-8910": {"epss_score": 0.00072, "epss_percentile": 0.22346}, "CVE-2025-8911": {"epss_score": 0.00072, "epss_percentile": 0.22346}, "CVE-2025-8912": {"epss_score": 0.00103, "epss_percentile": 0.28997}, "CVE-2025-8913": {"epss_score": 0.00355, "epss_percentile": 0.57288}, "CVE-2025-8914": {"epss_score": 0.00062, "epss_percentile": 0.19648}, "CVE-2025-8915": {"epss_score": 0.00036, "epss_percentile": 0.10351}, "CVE-2025-8916": {"epss_score": 0.00112, "epss_percentile": 0.30527}, "CVE-2025-8917": {"epss_score": 0.00028, "epss_percentile": 0.07245}, "CVE-2025-8918": {"epss_score": 0.00058, "epss_percentile": 0.18313}, "CVE-2025-8919": {"epss_score": 0.00059, "epss_percentile": 0.1868}, "CVE-2025-8920": {"epss_score": 0.00049, "epss_percentile": 0.15631}, "CVE-2025-8921": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-8922": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-8923": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-8924": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-8925": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-8926": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8927": {"epss_score": 0.00151, "epss_percentile": 0.36213}, "CVE-2025-8928": {"epss_score": 0.0007, "epss_percentile": 0.21717}, "CVE-2025-8929": {"epss_score": 0.0007, "epss_percentile": 0.21717}, "CVE-2025-8930": {"epss_score": 0.0007, "epss_percentile": 0.21717}, "CVE-2025-8931": {"epss_score": 0.0007, "epss_percentile": 0.21717}, "CVE-2025-8932": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-8933": {"epss_score": 0.0009, "epss_percentile": 0.26093}, "CVE-2025-8934": {"epss_score": 0.0009, "epss_percentile": 0.26093}, "CVE-2025-8935": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-8936": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8937": {"epss_score": 0.01249, "epss_percentile": 0.78871}, "CVE-2025-8938": {"epss_score": 0.00167, "epss_percentile": 0.38314}, "CVE-2025-8939": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-8940": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-8941": {"epss_score": 0.00035, "epss_percentile": 0.09866}, "CVE-2025-8942": {"epss_score": 0.00045, "epss_percentile": 0.13761}, "CVE-2025-8943": {"epss_score": 0.75859, "epss_percentile": 0.98867}, "CVE-2025-8944": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-8946": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8947": {"epss_score": 0.00066, "epss_percentile": 0.2089}, "CVE-2025-8948": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-8949": {"epss_score": 0.00338, "epss_percentile": 0.5616}, "CVE-2025-8950": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-8951": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-8952": {"epss_score": 0.00065, "epss_percentile": 0.20544}, "CVE-2025-8953": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8954": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-8955": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-8956": {"epss_score": 0.00114, "epss_percentile": 0.30789}, "CVE-2025-8957": {"epss_score": 0.00065, "epss_percentile": 0.20544}, "CVE-2025-8958": {"epss_score": 0.00153, "epss_percentile": 0.36526}, "CVE-2025-8959": {"epss_score": 0.00024, "epss_percentile": 0.05776}, "CVE-2025-8960": {"epss_score": 0.00065, "epss_percentile": 0.20544}, "CVE-2025-8961": {"epss_score": 0.00044, "epss_percentile": 0.13573}, "CVE-2025-8962": {"epss_score": 0.00037, "epss_percentile": 0.10865}, "CVE-2025-8963": {"epss_score": 0.00078, "epss_percentile": 0.23747}, "CVE-2025-8964": {"epss_score": 0.0007, "epss_percentile": 0.21798}, "CVE-2025-8965": {"epss_score": 0.00063, "epss_percentile": 0.19937}, "CVE-2025-8966": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8967": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8968": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8969": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8970": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8971": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8972": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8973": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8974": {"epss_score": 0.00165, "epss_percentile": 0.38077}, "CVE-2025-8975": {"epss_score": 0.00063, "epss_percentile": 0.19936}, "CVE-2025-8976": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-8977": {"epss_score": 0.00035, "epss_percentile": 0.10058}, "CVE-2025-8978": {"epss_score": 0.00241, "epss_percentile": 0.47274}, "CVE-2025-8979": {"epss_score": 0.00064, "epss_percentile": 0.20111}, "CVE-2025-8980": {"epss_score": 0.00048, "epss_percentile": 0.14988}, "CVE-2025-8981": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8982": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8983": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8984": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8985": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8986": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8987": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8988": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8989": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8990": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8991": {"epss_score": 0.00062, "epss_percentile": 0.19646}, "CVE-2025-8992": {"epss_score": 0.00045, "epss_percentile": 0.13812}, "CVE-2025-8993": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-8994": {"epss_score": 0.00031, "epss_percentile": 0.08697}, "CVE-2025-8995": {"epss_score": 0.00123, "epss_percentile": 0.32255}, "CVE-2025-8996": {"epss_score": 0.00039, "epss_percentile": 0.11714}, "CVE-2025-8997": {"epss_score": 0.00081, "epss_percentile": 0.24271}, "CVE-2025-8998": {"epss_score": 0.0005, "epss_percentile": 0.15701}, "CVE-2025-8999": {"epss_score": 0.00042, "epss_percentile": 0.12739}, "CVE-2025-9000": {"epss_score": 0.00034, "epss_percentile": 0.09754}, "CVE-2025-9001": {"epss_score": 0.00195, "epss_percentile": 0.41661}, "CVE-2025-9002": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9003": {"epss_score": 0.00024, "epss_percentile": 0.05995}, "CVE-2025-9004": {"epss_score": 0.00186, "epss_percentile": 0.40649}, "CVE-2025-9005": {"epss_score": 0.00059, "epss_percentile": 0.18624}, "CVE-2025-9006": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2025-9007": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2025-9008": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9009": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9010": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9011": {"epss_score": 0.00048, "epss_percentile": 0.15015}, "CVE-2025-9012": {"epss_score": 0.00048, "epss_percentile": 0.15015}, "CVE-2025-9013": {"epss_score": 0.00048, "epss_percentile": 0.15015}, "CVE-2025-9016": {"epss_score": 0.00034, "epss_percentile": 0.09754}, "CVE-2025-9017": {"epss_score": 0.00064, "epss_percentile": 0.20321}, "CVE-2025-9018": {"epss_score": 0.0006, "epss_percentile": 0.19006}, "CVE-2025-9019": {"epss_score": 0.00332, "epss_percentile": 0.55586}, "CVE-2025-9020": {"epss_score": 0.00025, "epss_percentile": 0.06113}, "CVE-2025-9021": {"epss_score": 0.00048, "epss_percentile": 0.15015}, "CVE-2025-9022": {"epss_score": 0.00048, "epss_percentile": 0.15015}, "CVE-2025-9023": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9024": {"epss_score": 0.00048, "epss_percentile": 0.15015}, "CVE-2025-9025": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9026": {"epss_score": 0.00649, "epss_percentile": 0.7023}, "CVE-2025-9027": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9028": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9029": {"epss_score": 0.00095, "epss_percentile": 0.27079}, "CVE-2025-9030": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9031": {"epss_score": 0.00041, "epss_percentile": 0.12259}, "CVE-2025-9034": {"epss_score": 0.00036, "epss_percentile": 0.10504}, "CVE-2025-9035": {"epss_score": 0.00045, "epss_percentile": 0.14036}, "CVE-2025-9036": {"epss_score": 0.00027, "epss_percentile": 0.07166}, "CVE-2025-9038": {"epss_score": 0.00021, "epss_percentile": 0.0473}, "CVE-2025-9039": {"epss_score": 0.00045, "epss_percentile": 0.14014}, "CVE-2025-9041": {"epss_score": 0.00164, "epss_percentile": 0.38007}, "CVE-2025-9042": {"epss_score": 0.00164, "epss_percentile": 0.38007}, "CVE-2025-9043": {"epss_score": 0.00023, "epss_percentile": 0.05489}, "CVE-2025-9044": {"epss_score": 0.00041, "epss_percentile": 0.1228}, "CVE-2025-9045": {"epss_score": 0.00054, "epss_percentile": 0.17188}, "CVE-2025-9046": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9047": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9048": {"epss_score": 0.00506, "epss_percentile": 0.65633}, "CVE-2025-9050": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9051": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9052": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9053": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9054": {"epss_score": 0.00147, "epss_percentile": 0.35666}, "CVE-2025-9055": {"epss_score": 0.00017, "epss_percentile": 0.03313}, "CVE-2025-9056": {"epss_score": 0.00039, "epss_percentile": 0.11642}, "CVE-2025-9057": {"epss_score": 0.00043, "epss_percentile": 0.13097}, "CVE-2025-9058": {"epss_score": 0.00035, "epss_percentile": 0.10045}, "CVE-2025-9059": {"epss_score": 0.00019, "epss_percentile": 0.04415}, "CVE-2025-9060": {"epss_score": 0.00186, "epss_percentile": 0.40619}, "CVE-2025-9061": {"epss_score": 0.00035, "epss_percentile": 0.10045}, "CVE-2025-9063": {"epss_score": 0.00023, "epss_percentile": 0.05424}, "CVE-2025-9064": {"epss_score": 0.00289, "epss_percentile": 0.52044}, "CVE-2025-9065": {"epss_score": 0.0001, "epss_percentile": 0.00901}, "CVE-2025-9066": {"epss_score": 0.00276, "epss_percentile": 0.50749}, "CVE-2025-9067": {"epss_score": 3e-05, "epss_percentile": 0.00087}, "CVE-2025-9068": {"epss_score": 3e-05, "epss_percentile": 0.00087}, "CVE-2025-9071": {"epss_score": 0.00034, "epss_percentile": 0.09697}, "CVE-2025-9072": {"epss_score": 0.00039, "epss_percentile": 0.11441}, "CVE-2025-9073": {"epss_score": 0.00096, "epss_percentile": 0.27361}, "CVE-2025-9074": {"epss_score": 0.00017, "epss_percentile": 0.03143}, "CVE-2025-9075": {"epss_score": 0.00054, "epss_percentile": 0.17188}, "CVE-2025-9076": {"epss_score": 0.00041, "epss_percentile": 0.12247}, "CVE-2025-9077": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9078": {"epss_score": 0.00018, "epss_percentile": 0.03869}, "CVE-2025-9079": {"epss_score": 0.00047, "epss_percentile": 0.14929}, "CVE-2025-9080": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-9081": {"epss_score": 0.00016, "epss_percentile": 0.02621}, "CVE-2025-9083": {"epss_score": 0.00229, "epss_percentile": 0.45554}, "CVE-2025-9084": {"epss_score": 0.00038, "epss_percentile": 0.11348}, "CVE-2025-9085": {"epss_score": 0.00043, "epss_percentile": 0.13137}, "CVE-2025-9086": {"epss_score": 0.00027, "epss_percentile": 0.06902}, "CVE-2025-9087": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9088": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9089": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9090": {"epss_score": 0.0924, "epss_percentile": 0.92464}, "CVE-2025-9091": {"epss_score": 0.00023, "epss_percentile": 0.05461}, "CVE-2025-9092": {"epss_score": 0.00025, "epss_percentile": 0.06285}, "CVE-2025-9093": {"epss_score": 0.00016, "epss_percentile": 0.02919}, "CVE-2025-9094": {"epss_score": 0.00085, "epss_percentile": 0.25057}, "CVE-2025-9095": {"epss_score": 0.00056, "epss_percentile": 0.17824}, "CVE-2025-9096": {"epss_score": 0.00056, "epss_percentile": 0.17824}, "CVE-2025-9097": {"epss_score": 0.00023, "epss_percentile": 0.05361}, "CVE-2025-9098": {"epss_score": 0.00023, "epss_percentile": 0.05361}, "CVE-2025-9099": {"epss_score": 0.00065, "epss_percentile": 0.20559}, "CVE-2025-9100": {"epss_score": 0.00149, "epss_percentile": 0.3604}, "CVE-2025-9101": {"epss_score": 0.00047, "epss_percentile": 0.14483}, "CVE-2025-9102": {"epss_score": 0.00029, "epss_percentile": 0.07748}, "CVE-2025-9103": {"epss_score": 0.00055, "epss_percentile": 0.17437}, "CVE-2025-9104": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-9105": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-9106": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-9107": {"epss_score": 0.00064, "epss_percentile": 0.20321}, "CVE-2025-9108": {"epss_score": 0.00048, "epss_percentile": 0.15189}, "CVE-2025-9109": {"epss_score": 0.00042, "epss_percentile": 0.12799}, "CVE-2025-9110": {"epss_score": 0.00055, "epss_percentile": 0.17574}, "CVE-2025-9111": {"epss_score": 0.00046, "epss_percentile": 0.14429}, "CVE-2025-9112": {"epss_score": 0.00392, "epss_percentile": 0.59644}, "CVE-2025-9113": {"epss_score": 0.00264, "epss_percentile": 0.49728}, "CVE-2025-9114": {"epss_score": 0.00282, "epss_percentile": 0.51217}, "CVE-2025-9115": {"epss_score": 0.00062, "epss_percentile": 0.1967}, "CVE-2025-9116": {"epss_score": 0.00036, "epss_percentile": 0.10422}, "CVE-2025-9118": {"epss_score": 0.0047, "epss_percentile": 0.63969}, "CVE-2025-9119": {"epss_score": 0.00048, "epss_percentile": 0.15126}, "CVE-2025-9121": {"epss_score": 0.0006, "epss_percentile": 0.19115}, "CVE-2025-9122": {"epss_score": 0.00036, "epss_percentile": 0.10405}, "CVE-2025-9123": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9124": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-9126": {"epss_score": 0.00059, "epss_percentile": 0.18838}, "CVE-2025-9127": {"epss_score": 0.00018, "epss_percentile": 0.03913}, "CVE-2025-9128": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-9129": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-9130": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-9131": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-9132": {"epss_score": 0.00126, "epss_percentile": 0.32677}, "CVE-2025-9133": {"epss_score": 0.00072, "epss_percentile": 0.22421}, "CVE-2025-9134": {"epss_score": 0.00029, "epss_percentile": 0.07748}, "CVE-2025-9135": {"epss_score": 0.00025, "epss_percentile": 0.06254}, "CVE-2025-9136": {"epss_score": 0.00022, "epss_percentile": 0.05029}, "CVE-2025-9137": {"epss_score": 0.00066, "epss_percentile": 0.20959}, "CVE-2025-9138": {"epss_score": 0.00044, "epss_percentile": 0.1343}, "CVE-2025-9139": {"epss_score": 0.00037, "epss_percentile": 0.10775}, "CVE-2025-9140": {"epss_score": 0.00166, "epss_percentile": 0.38228}, "CVE-2025-9143": {"epss_score": 0.00051, "epss_percentile": 0.16148}, "CVE-2025-9144": {"epss_score": 0.00051, "epss_percentile": 0.16148}, "CVE-2025-9145": {"epss_score": 0.00051, "epss_percentile": 0.16148}, "CVE-2025-9146": {"epss_score": 0.00085, "epss_percentile": 0.25065}, "CVE-2025-9147": {"epss_score": 0.00044, "epss_percentile": 0.13484}, "CVE-2025-9148": {"epss_score": 0.00051, "epss_percentile": 0.16022}, "CVE-2025-9149": {"epss_score": 0.0064, "epss_percentile": 0.69955}, "CVE-2025-9150": {"epss_score": 0.00054, "epss_percentile": 0.17232}, "CVE-2025-9151": {"epss_score": 0.0007, "epss_percentile": 0.21672}, "CVE-2025-9152": {"epss_score": 0.00096, "epss_percentile": 0.27381}, "CVE-2025-9153": {"epss_score": 0.0006, "epss_percentile": 0.18989}, "CVE-2025-9154": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9155": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9156": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9157": {"epss_score": 0.00025, "epss_percentile": 0.06113}, "CVE-2025-9158": {"epss_score": 0.00132, "epss_percentile": 0.3356}, "CVE-2025-9160": {"epss_score": 0.00028, "epss_percentile": 0.0735}, "CVE-2025-9161": {"epss_score": 0.0003, "epss_percentile": 0.0831}, "CVE-2025-9162": {"epss_score": 0.00021, "epss_percentile": 0.04935}, "CVE-2025-9163": {"epss_score": 0.00116, "epss_percentile": 0.31145}, "CVE-2025-9164": {"epss_score": 0.00021, "epss_percentile": 0.04863}, "CVE-2025-9165": {"epss_score": 0.00036, "epss_percentile": 0.10501}, "CVE-2025-9166": {"epss_score": 0.00104, "epss_percentile": 0.2914}, "CVE-2025-9167": {"epss_score": 0.00069, "epss_percentile": 0.21568}, "CVE-2025-9168": {"epss_score": 0.00069, "epss_percentile": 0.21568}, "CVE-2025-9169": {"epss_score": 0.00069, "epss_percentile": 0.21568}, "CVE-2025-9170": {"epss_score": 0.00069, "epss_percentile": 0.21568}, "CVE-2025-9171": {"epss_score": 0.00069, "epss_percentile": 0.21568}, "CVE-2025-9172": {"epss_score": 0.00116, "epss_percentile": 0.31077}, "CVE-2025-9174": {"epss_score": 0.0009, "epss_percentile": 0.26154}, "CVE-2025-9175": {"epss_score": 0.00027, "epss_percentile": 0.06759}, "CVE-2025-9176": {"epss_score": 0.0009, "epss_percentile": 0.26154}, "CVE-2025-9177": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-9178": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-9179": {"epss_score": 0.00116, "epss_percentile": 0.3113}, "CVE-2025-9180": {"epss_score": 0.0004, "epss_percentile": 0.12089}, "CVE-2025-9181": {"epss_score": 0.00082, "epss_percentile": 0.24508}, "CVE-2025-9182": {"epss_score": 0.00084, "epss_percentile": 0.25027}, "CVE-2025-9183": {"epss_score": 0.00042, "epss_percentile": 0.12703}, "CVE-2025-9184": {"epss_score": 0.00094, "epss_percentile": 0.26982}, "CVE-2025-9185": {"epss_score": 0.00123, "epss_percentile": 0.32267}, "CVE-2025-9186": {"epss_score": 0.00044, "epss_percentile": 0.13619}, "CVE-2025-9187": {"epss_score": 0.00082, "epss_percentile": 0.24585}, "CVE-2025-9188": {"epss_score": 0.00458, "epss_percentile": 0.63439}, "CVE-2025-9189": {"epss_score": 0.00058, "epss_percentile": 0.18387}, "CVE-2025-9190": {"epss_score": 0.00019, "epss_percentile": 0.04248}, "CVE-2025-9191": {"epss_score": 0.00069, "epss_percentile": 0.2162}, "CVE-2025-9193": {"epss_score": 0.00046, "epss_percentile": 0.14127}, "CVE-2025-9194": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-9195": {"epss_score": 0.00044, "epss_percentile": 0.13641}, "CVE-2025-9196": {"epss_score": 0.01046, "epss_percentile": 0.7703}, "CVE-2025-9198": {"epss_score": 0.00039, "epss_percentile": 0.11446}, "CVE-2025-9199": {"epss_score": 0.00039, "epss_percentile": 0.11446}, "CVE-2025-9200": {"epss_score": 0.00096, "epss_percentile": 0.27361}, "CVE-2025-9201": {"epss_score": 0.0002, "epss_percentile": 0.04607}, "CVE-2025-9202": {"epss_score": 0.00045, "epss_percentile": 0.14038}, "CVE-2025-9203": {"epss_score": 0.00045, "epss_percentile": 0.13997}, "CVE-2025-9204": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9206": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-9207": {"epss_score": 0.00085, "epss_percentile": 0.25115}, "CVE-2025-9209": {"epss_score": 0.00447, "epss_percentile": 0.62947}, "CVE-2025-9212": {"epss_score": 0.00312, "epss_percentile": 0.5396}, "CVE-2025-9213": {"epss_score": 0.00023, "epss_percentile": 0.05616}, "CVE-2025-9214": {"epss_score": 0.0002, "epss_percentile": 0.04562}, "CVE-2025-9215": {"epss_score": 0.00063, "epss_percentile": 0.1982}, "CVE-2025-9216": {"epss_score": 0.00329, "epss_percentile": 0.55303}, "CVE-2025-9217": {"epss_score": 0.00066, "epss_percentile": 0.20955}, "CVE-2025-9218": {"epss_score": 0.00048, "epss_percentile": 0.15081}, "CVE-2025-9219": {"epss_score": 0.00045, "epss_percentile": 0.14038}, "CVE-2025-9223": {"epss_score": 0.01209, "epss_percentile": 0.78538}, "CVE-2025-9225": {"epss_score": 0.00073, "epss_percentile": 0.2253}, "CVE-2025-9227": {"epss_score": 0.00086, "epss_percentile": 0.25388}, "CVE-2025-9228": {"epss_score": 0.00048, "epss_percentile": 0.15093}, "CVE-2025-9229": {"epss_score": 0.00069, "epss_percentile": 0.21471}, "CVE-2025-9230": {"epss_score": 0.00026, "epss_percentile": 0.06576}, "CVE-2025-9231": {"epss_score": 0.00016, "epss_percentile": 0.02871}, "CVE-2025-9232": {"epss_score": 0.00028, "epss_percentile": 0.07294}, "CVE-2025-9233": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-9234": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-9235": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-9236": {"epss_score": 0.0007, "epss_percentile": 0.21717}, "CVE-2025-9237": {"epss_score": 0.0008, "epss_percentile": 0.24148}, "CVE-2025-9238": {"epss_score": 0.00058, "epss_percentile": 0.18404}, "CVE-2025-9239": {"epss_score": 0.00016, "epss_percentile": 0.02695}, "CVE-2025-9240": {"epss_score": 0.00043, "epss_percentile": 0.13069}, "CVE-2025-9241": {"epss_score": 0.00066, "epss_percentile": 0.20757}, "CVE-2025-9242": {"epss_score": 0.73453, "epss_percentile": 0.98756}, "CVE-2025-9243": {"epss_score": 0.0004, "epss_percentile": 0.11962}, "CVE-2025-9244": {"epss_score": 0.00585, "epss_percentile": 0.68428}, "CVE-2025-9245": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2025-9246": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2025-9247": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2025-9248": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2025-9249": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2025-9250": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2025-9251": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2025-9252": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2025-9253": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2025-9254": {"epss_score": 0.00326, "epss_percentile": 0.55038}, "CVE-2025-9255": {"epss_score": 0.00064, "epss_percentile": 0.2039}, "CVE-2025-9256": {"epss_score": 0.00086, "epss_percentile": 0.25402}, "CVE-2025-9257": {"epss_score": 0.00086, "epss_percentile": 0.25402}, "CVE-2025-9258": {"epss_score": 0.00086, "epss_percentile": 0.25402}, "CVE-2025-9259": {"epss_score": 0.00086, "epss_percentile": 0.25402}, "CVE-2025-9260": {"epss_score": 0.00294, "epss_percentile": 0.52411}, "CVE-2025-9262": {"epss_score": 0.00331, "epss_percentile": 0.55509}, "CVE-2025-9263": {"epss_score": 0.00055, "epss_percentile": 0.175}, "CVE-2025-9264": {"epss_score": 0.00082, "epss_percentile": 0.24408}, "CVE-2025-9265": {"epss_score": 0.00069, "epss_percentile": 0.21486}, "CVE-2025-9267": {"epss_score": 0.0002, "epss_percentile": 0.04477}, "CVE-2025-9269": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-9273": {"epss_score": 0.00253, "epss_percentile": 0.4845}, "CVE-2025-9274": {"epss_score": 0.0009, "epss_percentile": 0.26017}, "CVE-2025-9275": {"epss_score": 0.0009, "epss_percentile": 0.26017}, "CVE-2025-9276": {"epss_score": 0.0079, "epss_percentile": 0.73377}, "CVE-2025-9277": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-9286": {"epss_score": 0.00139, "epss_percentile": 0.34554}, "CVE-2025-9287": {"epss_score": 0.00186, "epss_percentile": 0.40591}, "CVE-2025-9288": {"epss_score": 0.00059, "epss_percentile": 0.18715}, "CVE-2025-9294": {"epss_score": 0.00026, "epss_percentile": 0.06661}, "CVE-2025-9296": {"epss_score": 0.00074, "epss_percentile": 0.22734}, "CVE-2025-9297": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9298": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9299": {"epss_score": 0.00172, "epss_percentile": 0.39028}, "CVE-2025-9300": {"epss_score": 0.00046, "epss_percentile": 0.14167}, "CVE-2025-9301": {"epss_score": 0.00025, "epss_percentile": 0.06125}, "CVE-2025-9302": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9303": {"epss_score": 0.00338, "epss_percentile": 0.56072}, "CVE-2025-9304": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9305": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9306": {"epss_score": 0.00068, "epss_percentile": 0.21377}, "CVE-2025-9307": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9308": {"epss_score": 0.00024, "epss_percentile": 0.05848}, "CVE-2025-9309": {"epss_score": 0.00023, "epss_percentile": 0.05461}, "CVE-2025-9310": {"epss_score": 0.00065, "epss_percentile": 0.20471}, "CVE-2025-9311": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9312": {"epss_score": 0.00038, "epss_percentile": 0.11201}, "CVE-2025-9313": {"epss_score": 0.0041, "epss_percentile": 0.60827}, "CVE-2025-9315": {"epss_score": 0.00258, "epss_percentile": 0.49018}, "CVE-2025-9316": {"epss_score": 0.79312, "epss_percentile": 0.99031}, "CVE-2025-9317": {"epss_score": 6e-05, "epss_percentile": 0.00297}, "CVE-2025-9318": {"epss_score": 0.00026, "epss_percentile": 0.06474}, "CVE-2025-9319": {"epss_score": 0.0003, "epss_percentile": 0.08152}, "CVE-2025-9321": {"epss_score": 0.00112, "epss_percentile": 0.3045}, "CVE-2025-9322": {"epss_score": 0.00096, "epss_percentile": 0.27361}, "CVE-2025-9323": {"epss_score": 0.00048, "epss_percentile": 0.1494}, "CVE-2025-9324": {"epss_score": 0.00048, "epss_percentile": 0.1494}, "CVE-2025-9325": {"epss_score": 0.00048, "epss_percentile": 0.1494}, "CVE-2025-9326": {"epss_score": 0.00122, "epss_percentile": 0.32074}, "CVE-2025-9327": {"epss_score": 0.00048, "epss_percentile": 0.1494}, "CVE-2025-9328": {"epss_score": 0.00122, "epss_percentile": 0.32074}, "CVE-2025-9329": {"epss_score": 0.00122, "epss_percentile": 0.32074}, "CVE-2025-9330": {"epss_score": 0.00032, "epss_percentile": 0.08768}, "CVE-2025-9331": {"epss_score": 0.00045, "epss_percentile": 0.14038}, "CVE-2025-9332": {"epss_score": 0.00033, "epss_percentile": 0.0912}, "CVE-2025-9333": {"epss_score": 0.00033, "epss_percentile": 0.0912}, "CVE-2025-9334": {"epss_score": 0.00086, "epss_percentile": 0.25339}, "CVE-2025-9336": {"epss_score": 0.00022, "epss_percentile": 0.05216}, "CVE-2025-9337": {"epss_score": 0.00021, "epss_percentile": 0.04863}, "CVE-2025-9338": {"epss_score": 0.00018, "epss_percentile": 0.03913}, "CVE-2025-9339": {"epss_score": 0.00045, "epss_percentile": 0.13775}, "CVE-2025-9340": {"epss_score": 0.00035, "epss_percentile": 0.10041}, "CVE-2025-9341": {"epss_score": 0.00027, "epss_percentile": 0.07166}, "CVE-2025-9342": {"epss_score": 0.00042, "epss_percentile": 0.12763}, "CVE-2025-9343": {"epss_score": 0.00098, "epss_percentile": 0.27642}, "CVE-2025-9344": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-9345": {"epss_score": 0.00061, "epss_percentile": 0.19525}, "CVE-2025-9346": {"epss_score": 0.00052, "epss_percentile": 0.16666}, "CVE-2025-9352": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-9353": {"epss_score": 0.00054, "epss_percentile": 0.17188}, "CVE-2025-9355": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9356": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9357": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9358": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9359": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9360": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9361": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9362": {"epss_score": 0.00092, "epss_percentile": 0.26482}, "CVE-2025-9363": {"epss_score": 0.00172, "epss_percentile": 0.39028}, "CVE-2025-9364": {"epss_score": 8e-05, "epss_percentile": 0.00516}, "CVE-2025-9365": {"epss_score": 0.00245, "epss_percentile": 0.47689}, "CVE-2025-9367": {"epss_score": 0.00032, "epss_percentile": 0.09031}, "CVE-2025-9368": {"epss_score": 0.00055, "epss_percentile": 0.17626}, "CVE-2025-9371": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9372": {"epss_score": 0.0004, "epss_percentile": 0.11942}, "CVE-2025-9374": {"epss_score": 0.00027, "epss_percentile": 0.07208}, "CVE-2025-9375": {"epss_score": 0.00109, "epss_percentile": 0.29997}, "CVE-2025-9376": {"epss_score": 0.00088, "epss_percentile": 0.25637}, "CVE-2025-9377": {"epss_score": 0.19076, "epss_percentile": 0.95126}, "CVE-2025-9378": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-9379": {"epss_score": 0.00033, "epss_percentile": 0.09215}, "CVE-2025-9380": {"epss_score": 0.0002, "epss_percentile": 0.04467}, "CVE-2025-9381": {"epss_score": 0.00019, "epss_percentile": 0.04086}, "CVE-2025-9382": {"epss_score": 0.00021, "epss_percentile": 0.04934}, "CVE-2025-9383": {"epss_score": 9e-05, "epss_percentile": 0.00695}, "CVE-2025-9384": {"epss_score": 0.00035, "epss_percentile": 0.0981}, "CVE-2025-9385": {"epss_score": 0.00031, "epss_percentile": 0.08431}, "CVE-2025-9386": {"epss_score": 0.0004, "epss_percentile": 0.11931}, "CVE-2025-9387": {"epss_score": 0.00554, "epss_percentile": 0.67432}, "CVE-2025-9388": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-9389": {"epss_score": 0.0004, "epss_percentile": 0.12163}, "CVE-2025-9390": {"epss_score": 0.00049, "epss_percentile": 0.15381}, "CVE-2025-9391": {"epss_score": 0.0005, "epss_percentile": 0.1577}, "CVE-2025-9392": {"epss_score": 0.00172, "epss_percentile": 0.39028}, "CVE-2025-9393": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9394": {"epss_score": 0.00051, "epss_percentile": 0.16145}, "CVE-2025-9395": {"epss_score": 0.0007, "epss_percentile": 0.21672}, "CVE-2025-9396": {"epss_score": 0.0004, "epss_percentile": 0.12007}, "CVE-2025-9397": {"epss_score": 0.00068, "epss_percentile": 0.21217}, "CVE-2025-9398": {"epss_score": 0.00052, "epss_percentile": 0.16507}, "CVE-2025-9399": {"epss_score": 0.0005, "epss_percentile": 0.1577}, "CVE-2025-9400": {"epss_score": 0.00064, "epss_percentile": 0.20347}, "CVE-2025-9401": {"epss_score": 0.00046, "epss_percentile": 0.14458}, "CVE-2025-9402": {"epss_score": 0.00056, "epss_percentile": 0.17892}, "CVE-2025-9403": {"epss_score": 0.0004, "epss_percentile": 0.12007}, "CVE-2025-9404": {"epss_score": 0.00049, "epss_percentile": 0.15631}, "CVE-2025-9405": {"epss_score": 0.0014, "epss_percentile": 0.34781}, "CVE-2025-9406": {"epss_score": 0.00063, "epss_percentile": 0.19915}, "CVE-2025-9407": {"epss_score": 0.00044, "epss_percentile": 0.13587}, "CVE-2025-9408": {"epss_score": 0.00018, "epss_percentile": 0.03848}, "CVE-2025-9409": {"epss_score": 0.0012, "epss_percentile": 0.31797}, "CVE-2025-9410": {"epss_score": 0.00066, "epss_percentile": 0.20702}, "CVE-2025-9411": {"epss_score": 0.0005, "epss_percentile": 0.1577}, "CVE-2025-9412": {"epss_score": 0.00066, "epss_percentile": 0.20702}, "CVE-2025-9413": {"epss_score": 0.00066, "epss_percentile": 0.20702}, "CVE-2025-9414": {"epss_score": 0.00043, "epss_percentile": 0.13028}, "CVE-2025-9415": {"epss_score": 0.00066, "epss_percentile": 0.20693}, "CVE-2025-9416": {"epss_score": 0.00051, "epss_percentile": 0.16205}, "CVE-2025-9417": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9418": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9419": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9420": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9421": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9422": {"epss_score": 0.00047, "epss_percentile": 0.14696}, "CVE-2025-9423": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9424": {"epss_score": 0.00304, "epss_percentile": 0.53295}, "CVE-2025-9425": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9426": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9428": {"epss_score": 0.00259, "epss_percentile": 0.49089}, "CVE-2025-9429": {"epss_score": 0.00068, "epss_percentile": 0.21377}, "CVE-2025-9430": {"epss_score": 0.00053, "epss_percentile": 0.1672}, "CVE-2025-9431": {"epss_score": 0.00058, "epss_percentile": 0.18266}, "CVE-2025-9432": {"epss_score": 0.00058, "epss_percentile": 0.18266}, "CVE-2025-9433": {"epss_score": 0.00063, "epss_percentile": 0.19931}, "CVE-2025-9434": {"epss_score": 0.00086, "epss_percentile": 0.25274}, "CVE-2025-9436": {"epss_score": 0.00032, "epss_percentile": 0.09018}, "CVE-2025-9437": {"epss_score": 0.00063, "epss_percentile": 0.19954}, "CVE-2025-9438": {"epss_score": 0.00086, "epss_percentile": 0.25274}, "CVE-2025-9439": {"epss_score": 0.00086, "epss_percentile": 0.25274}, "CVE-2025-9440": {"epss_score": 0.00086, "epss_percentile": 0.25274}, "CVE-2025-9441": {"epss_score": 0.00044, "epss_percentile": 0.13678}, "CVE-2025-9442": {"epss_score": 0.00055, "epss_percentile": 0.17592}, "CVE-2025-9443": {"epss_score": 0.00138, "epss_percentile": 0.34362}, "CVE-2025-9444": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9447": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-9449": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-9450": {"epss_score": 0.0002, "epss_percentile": 0.04649}, "CVE-2025-9451": {"epss_score": 0.00036, "epss_percentile": 0.10613}, "CVE-2025-9452": {"epss_score": 0.00023, "epss_percentile": 0.05457}, "CVE-2025-9453": {"epss_score": 0.00023, "epss_percentile": 0.05457}, "CVE-2025-9454": {"epss_score": 0.00023, "epss_percentile": 0.05457}, "CVE-2025-9455": {"epss_score": 0.00023, "epss_percentile": 0.05457}, "CVE-2025-9456": {"epss_score": 0.0002, "epss_percentile": 0.04682}, "CVE-2025-9457": {"epss_score": 0.00023, "epss_percentile": 0.05457}, "CVE-2025-9458": {"epss_score": 0.00025, "epss_percentile": 0.06243}, "CVE-2025-9459": {"epss_score": 0.00023, "epss_percentile": 0.05457}, "CVE-2025-9460": {"epss_score": 0.00023, "epss_percentile": 0.05457}, "CVE-2025-9461": {"epss_score": 0.00054, "epss_percentile": 0.17298}, "CVE-2025-9463": {"epss_score": 0.00038, "epss_percentile": 0.11297}, "CVE-2025-9467": {"epss_score": 0.00163, "epss_percentile": 0.37815}, "CVE-2025-9468": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9469": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9470": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9471": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9472": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9473": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9474": {"epss_score": 0.00019, "epss_percentile": 0.04098}, "CVE-2025-9475": {"epss_score": 0.00115, "epss_percentile": 0.31015}, "CVE-2025-9476": {"epss_score": 0.00115, "epss_percentile": 0.31015}, "CVE-2025-9478": {"epss_score": 0.00148, "epss_percentile": 0.35849}, "CVE-2025-9479": {"epss_score": 0.00082, "epss_percentile": 0.24475}, "CVE-2025-9481": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9482": {"epss_score": 0.00172, "epss_percentile": 0.39028}, "CVE-2025-9483": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9485": {"epss_score": 0.00481, "epss_percentile": 0.64486}, "CVE-2025-9487": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2025-9488": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-9489": {"epss_score": 0.00084, "epss_percentile": 0.24879}, "CVE-2025-9490": {"epss_score": 0.00045, "epss_percentile": 0.13997}, "CVE-2025-9491": {"epss_score": 0.00381, "epss_percentile": 0.59008}, "CVE-2025-9492": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9493": {"epss_score": 0.00055, "epss_percentile": 0.17592}, "CVE-2025-9494": {"epss_score": 0.00513, "epss_percentile": 0.65928}, "CVE-2025-9495": {"epss_score": 0.00039, "epss_percentile": 0.11557}, "CVE-2025-9496": {"epss_score": 0.00045, "epss_percentile": 0.13997}, "CVE-2025-9499": {"epss_score": 0.00055, "epss_percentile": 0.17592}, "CVE-2025-9500": {"epss_score": 0.00059, "epss_percentile": 0.18838}, "CVE-2025-9501": {"epss_score": 0.02041, "epss_percentile": 0.8337}, "CVE-2025-9502": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9503": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9504": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9505": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9506": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9507": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9508": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9509": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9510": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9511": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9512": {"epss_score": 0.00125, "epss_percentile": 0.32473}, "CVE-2025-9513": {"epss_score": 0.00012, "epss_percentile": 0.0143}, "CVE-2025-9514": {"epss_score": 0.00047, "epss_percentile": 0.1463}, "CVE-2025-9515": {"epss_score": 0.00397, "epss_percentile": 0.6004}, "CVE-2025-9516": {"epss_score": 0.00058, "epss_percentile": 0.18455}, "CVE-2025-9517": {"epss_score": 0.00509, "epss_percentile": 0.65753}, "CVE-2025-9518": {"epss_score": 0.01096, "epss_percentile": 0.77514}, "CVE-2025-9519": {"epss_score": 0.00437, "epss_percentile": 0.62506}, "CVE-2025-9523": {"epss_score": 0.00309, "epss_percentile": 0.53653}, "CVE-2025-9524": {"epss_score": 0.00074, "epss_percentile": 0.22709}, "CVE-2025-9525": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9526": {"epss_score": 0.00197, "epss_percentile": 0.41826}, "CVE-2025-9527": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9528": {"epss_score": 0.00439, "epss_percentile": 0.62587}, "CVE-2025-9529": {"epss_score": 0.00076, "epss_percentile": 0.23176}, "CVE-2025-9531": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9532": {"epss_score": 0.0007, "epss_percentile": 0.21717}, "CVE-2025-9533": {"epss_score": 0.0019, "epss_percentile": 0.41094}, "CVE-2025-9539": {"epss_score": 0.00214, "epss_percentile": 0.44015}, "CVE-2025-9540": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2025-9541": {"epss_score": 0.00057, "epss_percentile": 0.18032}, "CVE-2025-9542": {"epss_score": 0.00045, "epss_percentile": 0.13747}, "CVE-2025-9543": {"epss_score": 0.00027, "epss_percentile": 0.06767}, "CVE-2025-9544": {"epss_score": 0.00039, "epss_percentile": 0.11754}, "CVE-2025-9548": {"epss_score": 0.00019, "epss_percentile": 0.04319}, "CVE-2025-9549": {"epss_score": 0.00042, "epss_percentile": 0.12754}, "CVE-2025-9550": {"epss_score": 0.00041, "epss_percentile": 0.12317}, "CVE-2025-9551": {"epss_score": 0.00061, "epss_percentile": 0.19542}, "CVE-2025-9552": {"epss_score": 0.00043, "epss_percentile": 0.13318}, "CVE-2025-9553": {"epss_score": 0.00043, "epss_percentile": 0.13318}, "CVE-2025-9554": {"epss_score": 0.00043, "epss_percentile": 0.13318}, "CVE-2025-9556": {"epss_score": 0.00078, "epss_percentile": 0.23652}, "CVE-2025-9557": {"epss_score": 0.0002, "epss_percentile": 0.0459}, "CVE-2025-9558": {"epss_score": 0.0002, "epss_percentile": 0.04589}, "CVE-2025-9559": {"epss_score": 0.00044, "epss_percentile": 0.13656}, "CVE-2025-9560": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-9561": {"epss_score": 0.00303, "epss_percentile": 0.53227}, "CVE-2025-9562": {"epss_score": 0.00045, "epss_percentile": 0.13997}, "CVE-2025-9565": {"epss_score": 0.00048, "epss_percentile": 0.15288}, "CVE-2025-9566": {"epss_score": 0.00146, "epss_percentile": 0.35537}, "CVE-2025-9567": {"epss_score": 0.00072, "epss_percentile": 0.22346}, "CVE-2025-9568": {"epss_score": 0.00072, "epss_percentile": 0.22346}, "CVE-2025-9569": {"epss_score": 0.00072, "epss_percentile": 0.22346}, "CVE-2025-9570": {"epss_score": 0.00078, "epss_percentile": 0.23616}, "CVE-2025-9571": {"epss_score": 0.00453, "epss_percentile": 0.63218}, "CVE-2025-9573": {"epss_score": 0.00379, "epss_percentile": 0.58899}, "CVE-2025-9574": {"epss_score": 0.00091, "epss_percentile": 0.26275}, "CVE-2025-9575": {"epss_score": 0.005, "epss_percentile": 0.65319}, "CVE-2025-9576": {"epss_score": 0.00027, "epss_percentile": 0.06751}, "CVE-2025-9577": {"epss_score": 0.00032, "epss_percentile": 0.08804}, "CVE-2025-9578": {"epss_score": 0.0002, "epss_percentile": 0.04634}, "CVE-2025-9579": {"epss_score": 0.00431, "epss_percentile": 0.62088}, "CVE-2025-9580": {"epss_score": 0.00431, "epss_percentile": 0.62088}, "CVE-2025-9581": {"epss_score": 0.00408, "epss_percentile": 0.60639}, "CVE-2025-9582": {"epss_score": 0.00408, "epss_percentile": 0.60639}, "CVE-2025-9583": {"epss_score": 0.00373, "epss_percentile": 0.58506}, "CVE-2025-9584": {"epss_score": 0.00373, "epss_percentile": 0.58506}, "CVE-2025-9585": {"epss_score": 0.00373, "epss_percentile": 0.58506}, "CVE-2025-9586": {"epss_score": 0.00373, "epss_percentile": 0.58506}, "CVE-2025-9587": {"epss_score": 0.00096, "epss_percentile": 0.27361}, "CVE-2025-9588": {"epss_score": 0.00392, "epss_percentile": 0.5969}, "CVE-2025-9589": {"epss_score": 0.0002, "epss_percentile": 0.0459}, "CVE-2025-9590": {"epss_score": 0.00056, "epss_percentile": 0.17824}, "CVE-2025-9591": {"epss_score": 0.00051, "epss_percentile": 0.16205}, "CVE-2025-9592": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9593": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9594": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9595": {"epss_score": 0.00087, "epss_percentile": 0.25559}, "CVE-2025-9596": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9597": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9598": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9599": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9600": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9601": {"epss_score": 0.00068, "epss_percentile": 0.21281}, "CVE-2025-9602": {"epss_score": 0.00043, "epss_percentile": 0.13069}, "CVE-2025-9603": {"epss_score": 0.0064, "epss_percentile": 0.69955}, "CVE-2025-9604": {"epss_score": 0.00037, "epss_percentile": 0.10722}, "CVE-2025-9605": {"epss_score": 0.00187, "epss_percentile": 0.40731}, "CVE-2025-9606": {"epss_score": 0.00046, "epss_percentile": 0.14463}, "CVE-2025-9607": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9608": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9609": {"epss_score": 0.00062, "epss_percentile": 0.19739}, "CVE-2025-9610": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9611": {"epss_score": 0.0011, "epss_percentile": 0.3015}, "CVE-2025-9612": {"epss_score": 9e-05, "epss_percentile": 0.00652}, "CVE-2025-9613": {"epss_score": 0.00021, "epss_percentile": 0.04726}, "CVE-2025-9614": {"epss_score": 0.00011, "epss_percentile": 0.01042}, "CVE-2025-9616": {"epss_score": 0.00027, "epss_percentile": 0.07208}, "CVE-2025-9617": {"epss_score": 0.00019, "epss_percentile": 0.04331}, "CVE-2025-9618": {"epss_score": 0.00027, "epss_percentile": 0.07208}, "CVE-2025-9619": {"epss_score": 0.00052, "epss_percentile": 0.1667}, "CVE-2025-9620": {"epss_score": 0.00016, "epss_percentile": 0.02662}, "CVE-2025-9621": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-9622": {"epss_score": 0.0002, "epss_percentile": 0.04495}, "CVE-2025-9623": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-9624": {"epss_score": 0.00048, "epss_percentile": 0.15103}, "CVE-2025-9625": {"epss_score": 0.00014, "epss_percentile": 0.0211}, "CVE-2025-9626": {"epss_score": 0.00017, "epss_percentile": 0.03118}, "CVE-2025-9627": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9628": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-9629": {"epss_score": 0.00017, "epss_percentile": 0.03118}, "CVE-2025-9630": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-9631": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-9632": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-9633": {"epss_score": 0.00017, "epss_percentile": 0.03118}, "CVE-2025-9634": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9635": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-9636": {"epss_score": 0.00031, "epss_percentile": 0.08318}, "CVE-2025-9637": {"epss_score": 0.00048, "epss_percentile": 0.15038}, "CVE-2025-9638": {"epss_score": 0.00027, "epss_percentile": 0.07002}, "CVE-2025-9639": {"epss_score": 0.00101, "epss_percentile": 0.28647}, "CVE-2025-9640": {"epss_score": 0.00074, "epss_percentile": 0.22813}, "CVE-2025-9642": {"epss_score": 0.00055, "epss_percentile": 0.17657}, "CVE-2025-9643": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9644": {"epss_score": 0.00046, "epss_percentile": 0.14357}, "CVE-2025-9645": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9646": {"epss_score": 0.00059, "epss_percentile": 0.18757}, "CVE-2025-9647": {"epss_score": 0.00054, "epss_percentile": 0.17341}, "CVE-2025-9648": {"epss_score": 0.00737, "epss_percentile": 0.72317}, "CVE-2025-9649": {"epss_score": 0.00038, "epss_percentile": 0.1116}, "CVE-2025-9650": {"epss_score": 0.00095, "epss_percentile": 0.2722}, "CVE-2025-9651": {"epss_score": 0.00051, "epss_percentile": 0.16022}, "CVE-2025-9652": {"epss_score": 0.00051, "epss_percentile": 0.16148}, "CVE-2025-9653": {"epss_score": 0.00051, "epss_percentile": 0.16148}, "CVE-2025-9654": {"epss_score": 0.01376, "epss_percentile": 0.7984}, "CVE-2025-9655": {"epss_score": 0.00043, "epss_percentile": 0.12969}, "CVE-2025-9656": {"epss_score": 0.00059, "epss_percentile": 0.18623}, "CVE-2025-9657": {"epss_score": 0.00059, "epss_percentile": 0.18757}, "CVE-2025-9658": {"epss_score": 0.00073, "epss_percentile": 0.22602}, "CVE-2025-9659": {"epss_score": 0.00073, "epss_percentile": 0.22602}, "CVE-2025-9660": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9662": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9663": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9664": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9665": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9666": {"epss_score": 0.0005, "epss_percentile": 0.1577}, "CVE-2025-9667": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9669": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9670": {"epss_score": 0.00081, "epss_percentile": 0.24282}, "CVE-2025-9671": {"epss_score": 0.00023, "epss_percentile": 0.05361}, "CVE-2025-9672": {"epss_score": 0.00023, "epss_percentile": 0.05361}, "CVE-2025-9673": {"epss_score": 0.00023, "epss_percentile": 0.05361}, "CVE-2025-9674": {"epss_score": 0.00037, "epss_percentile": 0.10911}, "CVE-2025-9675": {"epss_score": 0.00037, "epss_percentile": 0.10911}, "CVE-2025-9676": {"epss_score": 0.00037, "epss_percentile": 0.10911}, "CVE-2025-9677": {"epss_score": 0.00037, "epss_percentile": 0.10911}, "CVE-2025-9678": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9679": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9680": {"epss_score": 0.00086, "epss_percentile": 0.25285}, "CVE-2025-9681": {"epss_score": 0.00076, "epss_percentile": 0.23096}, "CVE-2025-9682": {"epss_score": 0.00086, "epss_percentile": 0.25285}, "CVE-2025-9683": {"epss_score": 0.00069, "epss_percentile": 0.21543}, "CVE-2025-9684": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9685": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9686": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9687": {"epss_score": 0.00062, "epss_percentile": 0.19739}, "CVE-2025-9688": {"epss_score": 0.00069, "epss_percentile": 0.21493}, "CVE-2025-9689": {"epss_score": 0.00046, "epss_percentile": 0.14463}, "CVE-2025-9690": {"epss_score": 0.00045, "epss_percentile": 0.14057}, "CVE-2025-9691": {"epss_score": 0.00065, "epss_percentile": 0.20579}, "CVE-2025-9692": {"epss_score": 0.00071, "epss_percentile": 0.22209}, "CVE-2025-9693": {"epss_score": 0.00206, "epss_percentile": 0.42776}, "CVE-2025-9694": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9695": {"epss_score": 0.00029, "epss_percentile": 0.07748}, "CVE-2025-9696": {"epss_score": 0.00018, "epss_percentile": 0.03839}, "CVE-2025-9697": {"epss_score": 0.00104, "epss_percentile": 0.29103}, "CVE-2025-9698": {"epss_score": 0.00052, "epss_percentile": 0.1634}, "CVE-2025-9699": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9700": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9701": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9702": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9703": {"epss_score": 0.00042, "epss_percentile": 0.12522}, "CVE-2025-9704": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9705": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9706": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9708": {"epss_score": 9e-05, "epss_percentile": 0.00689}, "CVE-2025-9709": {"epss_score": 0.00058, "epss_percentile": 0.18377}, "CVE-2025-9710": {"epss_score": 0.00129, "epss_percentile": 0.33163}, "CVE-2025-9712": {"epss_score": 0.00669, "epss_percentile": 0.70749}, "CVE-2025-9713": {"epss_score": 0.01092, "epss_percentile": 0.77469}, "CVE-2025-9714": {"epss_score": 0.00024, "epss_percentile": 0.058}, "CVE-2025-9715": {"epss_score": 0.00069, "epss_percentile": 0.21543}, "CVE-2025-9716": {"epss_score": 0.00076, "epss_percentile": 0.23128}, "CVE-2025-9717": {"epss_score": 0.00044, "epss_percentile": 0.13531}, "CVE-2025-9718": {"epss_score": 0.00076, "epss_percentile": 0.23171}, "CVE-2025-9719": {"epss_score": 0.00044, "epss_percentile": 0.13531}, "CVE-2025-9720": {"epss_score": 0.00048, "epss_percentile": 0.15247}, "CVE-2025-9721": {"epss_score": 0.00048, "epss_percentile": 0.15247}, "CVE-2025-9722": {"epss_score": 0.00048, "epss_percentile": 0.15247}, "CVE-2025-9723": {"epss_score": 0.00048, "epss_percentile": 0.15247}, "CVE-2025-9724": {"epss_score": 0.00048, "epss_percentile": 0.14938}, "CVE-2025-9725": {"epss_score": 0.00042, "epss_percentile": 0.12767}, "CVE-2025-9726": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9727": {"epss_score": 0.00124, "epss_percentile": 0.3246}, "CVE-2025-9728": {"epss_score": 0.00094, "epss_percentile": 0.26782}, "CVE-2025-9729": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9730": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9731": {"epss_score": 0.00022, "epss_percentile": 0.05226}, "CVE-2025-9732": {"epss_score": 0.0003, "epss_percentile": 0.08247}, "CVE-2025-9733": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9734": {"epss_score": 0.00076, "epss_percentile": 0.23171}, "CVE-2025-9735": {"epss_score": 0.00051, "epss_percentile": 0.16148}, "CVE-2025-9736": {"epss_score": 0.00076, "epss_percentile": 0.23171}, "CVE-2025-9737": {"epss_score": 0.00076, "epss_percentile": 0.23171}, "CVE-2025-9738": {"epss_score": 0.00051, "epss_percentile": 0.16148}, "CVE-2025-9739": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9740": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9741": {"epss_score": 0.00052, "epss_percentile": 0.1658}, "CVE-2025-9742": {"epss_score": 0.00045, "epss_percentile": 0.13739}, "CVE-2025-9743": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9744": {"epss_score": 0.01153, "epss_percentile": 0.78054}, "CVE-2025-9745": {"epss_score": 0.00343, "epss_percentile": 0.56444}, "CVE-2025-9746": {"epss_score": 0.00046, "epss_percentile": 0.14162}, "CVE-2025-9747": {"epss_score": 0.00039, "epss_percentile": 0.11788}, "CVE-2025-9748": {"epss_score": 0.00207, "epss_percentile": 0.43122}, "CVE-2025-9749": {"epss_score": 0.00059, "epss_percentile": 0.18674}, "CVE-2025-9750": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9751": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9752": {"epss_score": 0.0063, "epss_percentile": 0.69691}, "CVE-2025-9753": {"epss_score": 0.00059, "epss_percentile": 0.1868}, "CVE-2025-9754": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-9755": {"epss_score": 0.00063, "epss_percentile": 0.19931}, "CVE-2025-9756": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9757": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9758": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9759": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9760": {"epss_score": 0.00082, "epss_percentile": 0.24554}, "CVE-2025-9761": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9762": {"epss_score": 0.00209, "epss_percentile": 0.43335}, "CVE-2025-9763": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9764": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9765": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9766": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9767": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9768": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9769": {"epss_score": 0.00079, "epss_percentile": 0.23861}, "CVE-2025-9770": {"epss_score": 0.00052, "epss_percentile": 0.1634}, "CVE-2025-9771": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9772": {"epss_score": 0.00081, "epss_percentile": 0.24223}, "CVE-2025-9773": {"epss_score": 0.00063, "epss_percentile": 0.19931}, "CVE-2025-9774": {"epss_score": 0.00045, "epss_percentile": 0.13932}, "CVE-2025-9775": {"epss_score": 0.00081, "epss_percentile": 0.24223}, "CVE-2025-9776": {"epss_score": 0.00036, "epss_percentile": 0.10613}, "CVE-2025-9778": {"epss_score": 0.00017, "epss_percentile": 0.03411}, "CVE-2025-9779": {"epss_score": 0.00215, "epss_percentile": 0.44119}, "CVE-2025-9780": {"epss_score": 0.00215, "epss_percentile": 0.44119}, "CVE-2025-9781": {"epss_score": 0.00215, "epss_percentile": 0.44119}, "CVE-2025-9782": {"epss_score": 0.00215, "epss_percentile": 0.44119}, "CVE-2025-9783": {"epss_score": 0.00215, "epss_percentile": 0.44119}, "CVE-2025-9784": {"epss_score": 0.00775, "epss_percentile": 0.73087}, "CVE-2025-9785": {"epss_score": 0.00071, "epss_percentile": 0.22175}, "CVE-2025-9786": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9787": {"epss_score": 0.00257, "epss_percentile": 0.4888}, "CVE-2025-9788": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9789": {"epss_score": 0.00065, "epss_percentile": 0.20619}, "CVE-2025-9790": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9791": {"epss_score": 0.00145, "epss_percentile": 0.35368}, "CVE-2025-9792": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9793": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9794": {"epss_score": 0.00071, "epss_percentile": 0.22209}, "CVE-2025-9795": {"epss_score": 0.00041, "epss_percentile": 0.12226}, "CVE-2025-9796": {"epss_score": 0.0006, "epss_percentile": 0.19091}, "CVE-2025-9797": {"epss_score": 0.00054, "epss_percentile": 0.17212}, "CVE-2025-9798": {"epss_score": 0.00054, "epss_percentile": 0.17301}, "CVE-2025-9799": {"epss_score": 0.00058, "epss_percentile": 0.18427}, "CVE-2025-9800": {"epss_score": 0.00074, "epss_percentile": 0.22707}, "CVE-2025-9801": {"epss_score": 0.00137, "epss_percentile": 0.34254}, "CVE-2025-9802": {"epss_score": 0.0005, "epss_percentile": 0.15662}, "CVE-2025-9803": {"epss_score": 0.00106, "epss_percentile": 0.29487}, "CVE-2025-9804": {"epss_score": 0.00059, "epss_percentile": 0.18714}, "CVE-2025-9805": {"epss_score": 0.00082, "epss_percentile": 0.24507}, "CVE-2025-9806": {"epss_score": 0.00017, "epss_percentile": 0.03511}, "CVE-2025-9807": {"epss_score": 0.00096, "epss_percentile": 0.27361}, "CVE-2025-9808": {"epss_score": 0.0188, "epss_percentile": 0.82685}, "CVE-2025-9809": {"epss_score": 0.00513, "epss_percentile": 0.65903}, "CVE-2025-9810": {"epss_score": 0.0002, "epss_percentile": 0.04596}, "CVE-2025-9811": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9812": {"epss_score": 0.00141, "epss_percentile": 0.34831}, "CVE-2025-9813": {"epss_score": 0.00141, "epss_percentile": 0.34831}, "CVE-2025-9814": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9815": {"epss_score": 0.0009, "epss_percentile": 0.26164}, "CVE-2025-9816": {"epss_score": 0.00255, "epss_percentile": 0.48651}, "CVE-2025-9817": {"epss_score": 0.00051, "epss_percentile": 0.16112}, "CVE-2025-9818": {"epss_score": 0.00018, "epss_percentile": 0.03716}, "CVE-2025-9821": {"epss_score": 0.00035, "epss_percentile": 0.09826}, "CVE-2025-9822": {"epss_score": 0.00047, "epss_percentile": 0.14914}, "CVE-2025-9823": {"epss_score": 0.0009, "epss_percentile": 0.26151}, "CVE-2025-9824": {"epss_score": 0.00077, "epss_percentile": 0.2346}, "CVE-2025-9825": {"epss_score": 0.00013, "epss_percentile": 0.01612}, "CVE-2025-9826": {"epss_score": 0.00046, "epss_percentile": 0.14358}, "CVE-2025-9828": {"epss_score": 0.00081, "epss_percentile": 0.24231}, "CVE-2025-9829": {"epss_score": 0.00065, "epss_percentile": 0.20619}, "CVE-2025-9830": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9831": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9832": {"epss_score": 0.00071, "epss_percentile": 0.22209}, "CVE-2025-9833": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9834": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-9835": {"epss_score": 0.00059, "epss_percentile": 0.18805}, "CVE-2025-9836": {"epss_score": 0.00056, "epss_percentile": 0.1782}, "CVE-2025-9837": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9838": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9839": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9840": {"epss_score": 0.00048, "epss_percentile": 0.15265}, "CVE-2025-9841": {"epss_score": 0.0006, "epss_percentile": 0.18989}, "CVE-2025-9842": {"epss_score": 0.00052, "epss_percentile": 0.16507}, "CVE-2025-9843": {"epss_score": 0.00052, "epss_percentile": 0.16507}, "CVE-2025-9844": {"epss_score": 0.00061, "epss_percentile": 0.19246}, "CVE-2025-9845": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-9846": {"epss_score": 0.00297, "epss_percentile": 0.52699}, "CVE-2025-9847": {"epss_score": 0.00066, "epss_percentile": 0.20693}, "CVE-2025-9848": {"epss_score": 0.00098, "epss_percentile": 0.27762}, "CVE-2025-9849": {"epss_score": 0.00056, "epss_percentile": 0.17751}, "CVE-2025-9850": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9851": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9852": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9853": {"epss_score": 0.00052, "epss_percentile": 0.1653}, "CVE-2025-9854": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9855": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9856": {"epss_score": 0.00034, "epss_percentile": 0.09607}, "CVE-2025-9857": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-9858": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9859": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9860": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9861": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9862": {"epss_score": 0.00017, "epss_percentile": 0.03355}, "CVE-2025-9865": {"epss_score": 0.00051, "epss_percentile": 0.16231}, "CVE-2025-9866": {"epss_score": 0.00082, "epss_percentile": 0.24472}, "CVE-2025-9867": {"epss_score": 0.00051, "epss_percentile": 0.16231}, "CVE-2025-9868": {"epss_score": 0.00235, "epss_percentile": 0.46245}, "CVE-2025-9869": {"epss_score": 0.00028, "epss_percentile": 0.07281}, "CVE-2025-9870": {"epss_score": 0.00028, "epss_percentile": 0.07281}, "CVE-2025-9871": {"epss_score": 0.00028, "epss_percentile": 0.07281}, "CVE-2025-9872": {"epss_score": 0.00669, "epss_percentile": 0.70749}, "CVE-2025-9873": {"epss_score": 0.00032, "epss_percentile": 0.08844}, "CVE-2025-9874": {"epss_score": 0.00118, "epss_percentile": 0.31487}, "CVE-2025-9875": {"epss_score": 0.00043, "epss_percentile": 0.12994}, "CVE-2025-9876": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9877": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9879": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9880": {"epss_score": 0.00017, "epss_percentile": 0.03115}, "CVE-2025-9881": {"epss_score": 0.00016, "epss_percentile": 0.02662}, "CVE-2025-9882": {"epss_score": 0.00016, "epss_percentile": 0.02662}, "CVE-2025-9883": {"epss_score": 0.00016, "epss_percentile": 0.02662}, "CVE-2025-9884": {"epss_score": 0.00016, "epss_percentile": 0.02662}, "CVE-2025-9885": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9886": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-9887": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9888": {"epss_score": 0.00017, "epss_percentile": 0.03118}, "CVE-2025-9889": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9890": {"epss_score": 0.00079, "epss_percentile": 0.23891}, "CVE-2025-9891": {"epss_score": 0.00017, "epss_percentile": 0.03127}, "CVE-2025-9892": {"epss_score": 0.00019, "epss_percentile": 0.04331}, "CVE-2025-9893": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9894": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9895": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9896": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9897": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9898": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9899": {"epss_score": 0.00017, "epss_percentile": 0.03167}, "CVE-2025-9900": {"epss_score": 0.00029, "epss_percentile": 0.07837}, "CVE-2025-9901": {"epss_score": 0.0008, "epss_percentile": 0.24013}, "CVE-2025-9902": {"epss_score": 0.00047, "epss_percentile": 0.14844}, "CVE-2025-9903": {"epss_score": 0.00057, "epss_percentile": 0.18081}, "CVE-2025-9904": {"epss_score": 0.00058, "epss_percentile": 0.18594}, "CVE-2025-9905": {"epss_score": 6e-05, "epss_percentile": 0.00265}, "CVE-2025-9906": {"epss_score": 0.0005, "epss_percentile": 0.15762}, "CVE-2025-9910": {"epss_score": 0.00046, "epss_percentile": 0.14271}, "CVE-2025-9913": {"epss_score": 0.00047, "epss_percentile": 0.1462}, "CVE-2025-9914": {"epss_score": 0.00047, "epss_percentile": 0.14754}, "CVE-2025-9918": {"epss_score": 0.00612, "epss_percentile": 0.69234}, "CVE-2025-9919": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9920": {"epss_score": 0.00073, "epss_percentile": 0.22571}, "CVE-2025-9921": {"epss_score": 0.00048, "epss_percentile": 0.15023}, "CVE-2025-9922": {"epss_score": 0.00064, "epss_percentile": 0.20321}, "CVE-2025-9923": {"epss_score": 0.00076, "epss_percentile": 0.23142}, "CVE-2025-9924": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9925": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9926": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9927": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9928": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9929": {"epss_score": 0.00059, "epss_percentile": 0.1868}, "CVE-2025-9930": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9931": {"epss_score": 0.00063, "epss_percentile": 0.19931}, "CVE-2025-9932": {"epss_score": 0.00048, "epss_percentile": 0.15067}, "CVE-2025-9933": {"epss_score": 0.0005, "epss_percentile": 0.15819}, "CVE-2025-9934": {"epss_score": 0.02507, "epss_percentile": 0.84938}, "CVE-2025-9935": {"epss_score": 0.02732, "epss_percentile": 0.85543}, "CVE-2025-9936": {"epss_score": 0.00042, "epss_percentile": 0.12829}, "CVE-2025-9937": {"epss_score": 0.00065, "epss_percentile": 0.20603}, "CVE-2025-9938": {"epss_score": 0.00118, "epss_percentile": 0.31489}, "CVE-2025-9939": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-9940": {"epss_score": 0.00049, "epss_percentile": 0.15586}, "CVE-2025-9941": {"epss_score": 0.00062, "epss_percentile": 0.19739}, "CVE-2025-9942": {"epss_score": 0.00062, "epss_percentile": 0.19739}, "CVE-2025-9943": {"epss_score": 0.00142, "epss_percentile": 0.35089}, "CVE-2025-9944": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9945": {"epss_score": 0.00018, "epss_percentile": 0.03555}, "CVE-2025-9946": {"epss_score": 0.00016, "epss_percentile": 0.02662}, "CVE-2025-9947": {"epss_score": 0.00036, "epss_percentile": 0.1024}, "CVE-2025-9948": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-9949": {"epss_score": 0.00016, "epss_percentile": 0.02668}, "CVE-2025-9950": {"epss_score": 0.00273, "epss_percentile": 0.50476}, "CVE-2025-9951": {"epss_score": 0.004, "epss_percentile": 0.60163}, "CVE-2025-9952": {"epss_score": 0.00158, "epss_percentile": 0.37201}, "CVE-2025-9954": {"epss_score": 0.0005, "epss_percentile": 0.15759}, "CVE-2025-9955": {"epss_score": 0.00042, "epss_percentile": 0.1281}, "CVE-2025-9958": {"epss_score": 0.00014, "epss_percentile": 0.01774}, "CVE-2025-9959": {"epss_score": 0.0008, "epss_percentile": 0.24205}, "CVE-2025-9960": {"epss_score": 0.00061, "epss_percentile": 0.19465}, "CVE-2025-9961": {"epss_score": 0.00148, "epss_percentile": 0.35926}, "CVE-2025-9962": {"epss_score": 0.00083, "epss_percentile": 0.24608}, "CVE-2025-9963": {"epss_score": 0.0003, "epss_percentile": 0.08271}, "CVE-2025-9964": {"epss_score": 0.00027, "epss_percentile": 0.06793}, "CVE-2025-9965": {"epss_score": 0.00248, "epss_percentile": 0.47979}, "CVE-2025-9966": {"epss_score": 0.00023, "epss_percentile": 0.05514}, "CVE-2025-9967": {"epss_score": 0.00147, "epss_percentile": 0.35666}, "CVE-2025-9968": {"epss_score": 0.00025, "epss_percentile": 0.0634}, "CVE-2025-9969": {"epss_score": 0.00044, "epss_percentile": 0.13623}, "CVE-2025-9970": {"epss_score": 7e-05, "epss_percentile": 0.00416}, "CVE-2025-9971": {"epss_score": 0.0024, "epss_percentile": 0.46959}, "CVE-2025-9972": {"epss_score": 0.00543, "epss_percentile": 0.67088}, "CVE-2025-9975": {"epss_score": 0.00039, "epss_percentile": 0.11587}, "CVE-2025-9976": {"epss_score": 0.00085, "epss_percentile": 0.2512}, "CVE-2025-9977": {"epss_score": 0.04438, "epss_percentile": 0.8869}, "CVE-2025-9978": {"epss_score": 0.00052, "epss_percentile": 0.1634}, "CVE-2025-9979": {"epss_score": 0.00037, "epss_percentile": 0.10894}, "CVE-2025-9980": {"epss_score": 0.00036, "epss_percentile": 0.10445}, "CVE-2025-9981": {"epss_score": 0.00036, "epss_percentile": 0.10445}, "CVE-2025-9982": {"epss_score": 0.00053, "epss_percentile": 0.16976}, "CVE-2025-9983": {"epss_score": 0.00023, "epss_percentile": 0.05479}, "CVE-2025-9984": {"epss_score": 0.00055, "epss_percentile": 0.17411}, "CVE-2025-9985": {"epss_score": 0.01936, "epss_percentile": 0.82961}, "CVE-2025-9990": {"epss_score": 0.00399, "epss_percentile": 0.60117}, "CVE-2025-9991": {"epss_score": 0.00343, "epss_percentile": 0.56405}, "CVE-2025-9992": {"epss_score": 0.00043, "epss_percentile": 0.13161}, "CVE-2025-9993": {"epss_score": 0.00129, "epss_percentile": 0.33178}, "CVE-2025-9994": {"epss_score": 0.00114, "epss_percentile": 0.30816}, "CVE-2025-9996": {"epss_score": 0.00241, "epss_percentile": 0.4726}, "CVE-2025-9997": {"epss_score": 0.00245, "epss_percentile": 0.47629}, "CVE-2025-9998": {"epss_score": 0.00032, "epss_percentile": 0.09106}, "CVE-2025-9999": {"epss_score": 0.00063, "epss_percentile": 0.20058}, "CVE-2026-0544": {"epss_score": 0.0003, "epss_percentile": 0.08139}, "CVE-2026-0546": {"epss_score": 0.00039, "epss_percentile": 0.11772}, "CVE-2026-0547": {"epss_score": 0.0004, "epss_percentile": 0.12152}, "CVE-2026-0565": {"epss_score": 0.00039, "epss_percentile": 0.11772}, "CVE-2026-0566": {"epss_score": 0.00046, "epss_percentile": 0.14414}, "CVE-2026-0567": {"epss_score": 0.00039, "epss_percentile": 0.11772}, "CVE-2026-0568": {"epss_score": 0.00039, "epss_percentile": 0.11772}, "CVE-2026-0569": {"epss_score": 0.00039, "epss_percentile": 0.11772}, "CVE-2026-0570": {"epss_score": 0.00039, "epss_percentile": 0.11772}, "CVE-2026-0571": {"epss_score": 0.00046, "epss_percentile": 0.14122}, "CVE-2026-0574": {"epss_score": 0.00036, "epss_percentile": 0.10386}, "CVE-2026-0575": {"epss_score": 0.00033, "epss_percentile": 0.09382}, "CVE-2026-0576": {"epss_score": 0.00033, "epss_percentile": 0.09382}, "CVE-2026-0577": {"epss_score": 0.00043, "epss_percentile": 0.12998}, "CVE-2026-0578": {"epss_score": 0.00033, "epss_percentile": 0.09382}, "CVE-2026-0579": {"epss_score": 0.00033, "epss_percentile": 0.09382}, "CVE-2026-0580": {"epss_score": 0.00031, "epss_percentile": 0.08438}, "CVE-2026-0581": {"epss_score": 0.03408, "epss_percentile": 0.87079}, "CVE-2026-0582": {"epss_score": 0.00028, "epss_percentile": 0.0744}, "CVE-2026-0583": {"epss_score": 0.00033, "epss_percentile": 0.09382}, "CVE-2026-0584": {"epss_score": 0.00033, "epss_percentile": 0.09347}, "CVE-2026-0585": {"epss_score": 0.00033, "epss_percentile": 0.09382}, "CVE-2026-0586": {"epss_score": 0.00036, "epss_percentile": 0.10544}, "CVE-2026-0587": {"epss_score": 0.00027, "epss_percentile": 0.06926}, "CVE-2026-0588": {"epss_score": 0.00027, "epss_percentile": 0.06926}, "CVE-2026-0589": {"epss_score": 0.00098, "epss_percentile": 0.27647}, "CVE-2026-0590": {"epss_score": 0.00033, "epss_percentile": 0.09347}, "CVE-2026-0591": {"epss_score": 0.00033, "epss_percentile": 0.09347}, "CVE-2026-0592": {"epss_score": 0.00033, "epss_percentile": 0.09382}, "CVE-2026-0597": {"epss_score": 0.00028, "epss_percentile": 0.0744}, "CVE-2026-0604": {"epss_score": 0.0004, "epss_percentile": 0.11959}, "CVE-2026-0605": {"epss_score": 0.00033, "epss_percentile": 0.09382}, "CVE-2026-0606": {"epss_score": 0.00033, "epss_percentile": 0.09382}, "CVE-2026-0607": {"epss_score": 0.00033, "epss_percentile": 0.09382}, "CVE-2026-0618": {"epss_score": 0.00029, "epss_percentile": 0.0777}, "CVE-2026-0621": {"epss_score": 0.00042, "epss_percentile": 0.12732}, "CVE-2026-0625": {"epss_score": 0.01382, "epss_percentile": 0.7989}, "CVE-2026-0628": {"epss_score": 0.00017, "epss_percentile": 0.03167}, "CVE-2026-0640": {"epss_score": 0.00088, "epss_percentile": 0.25694}, "CVE-2026-0641": {"epss_score": 0.02539, "epss_percentile": 0.85044}, "CVE-2026-0642": {"epss_score": 0.00028, "epss_percentile": 0.07365}, "CVE-2026-0643": {"epss_score": 0.00038, "epss_percentile": 0.11205}, "CVE-2026-0649": {"epss_score": 0.00033, "epss_percentile": 0.09248}, "CVE-2026-0650": {"epss_score": 0.00115, "epss_percentile": 0.30895}, "CVE-2026-0656": {"epss_score": 0.00151, "epss_percentile": 0.36202}, "CVE-2026-0668": {"epss_score": 0.00042, "epss_percentile": 0.12645}, "CVE-2026-0669": {"epss_score": 0.00043, "epss_percentile": 0.13314}, "CVE-2026-0670": {"epss_score": 0.00029, "epss_percentile": 0.0777}, "CVE-2026-0674": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2026-0675": {"epss_score": 0.00018, "epss_percentile": 0.04042}, "CVE-2026-0676": {"epss_score": 0.00017, "epss_percentile": 0.03285}, "CVE-2026-0697": {"epss_score": 0.00027, "epss_percentile": 0.07174}, "CVE-2026-0698": {"epss_score": 0.00027, "epss_percentile": 0.07174}, "CVE-2026-0699": {"epss_score": 0.00027, "epss_percentile": 0.07174}, "CVE-2026-0700": {"epss_score": 0.0003, "epss_percentile": 0.0818}, "CVE-2026-0701": {"epss_score": 0.00027, "epss_percentile": 0.07174}, "CVE-2026-0707": {"epss_score": 0.00044, "epss_percentile": 0.13539}, "CVE-2026-20026": {"epss_score": 0.00094, "epss_percentile": 0.26773}, "CVE-2026-20027": {"epss_score": 0.00029, "epss_percentile": 0.07785}, "CVE-2026-20029": {"epss_score": 0.00033, "epss_percentile": 0.09166}, "CVE-2026-20893": {"epss_score": 7e-05, "epss_percentile": 0.0038}, "CVE-2026-21411": {"epss_score": 0.00038, "epss_percentile": 0.11268}, "CVE-2026-21427": {"epss_score": 0.00014, "epss_percentile": 0.01767}, "CVE-2026-21428": {"epss_score": 0.00036, "epss_percentile": 0.10273}, "CVE-2026-21429": {"epss_score": 0.00047, "epss_percentile": 0.14602}, "CVE-2026-21430": {"epss_score": 0.00028, "epss_percentile": 0.07306}, "CVE-2026-21431": {"epss_score": 0.00052, "epss_percentile": 0.16586}, "CVE-2026-21432": {"epss_score": 0.00052, "epss_percentile": 0.16586}, "CVE-2026-21433": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2026-21436": {"epss_score": 0.00017, "epss_percentile": 0.03138}, "CVE-2026-21437": {"epss_score": 9e-05, "epss_percentile": 0.00609}, "CVE-2026-21439": {"epss_score": 5e-05, "epss_percentile": 0.00185}, "CVE-2026-21440": {"epss_score": 0.00317, "epss_percentile": 0.5436}, "CVE-2026-21441": {"epss_score": 0.00014, "epss_percentile": 0.01794}, "CVE-2026-21444": {"epss_score": 3e-05, "epss_percentile": 0.00121}, "CVE-2026-21445": {"epss_score": 0.00161, "epss_percentile": 0.3759}, "CVE-2026-21446": {"epss_score": 0.00231, "epss_percentile": 0.45808}, "CVE-2026-21447": {"epss_score": 0.00032, "epss_percentile": 0.08728}, "CVE-2026-21448": {"epss_score": 0.00434, "epss_percentile": 0.62302}, "CVE-2026-21449": {"epss_score": 0.00052, "epss_percentile": 0.16586}, "CVE-2026-21450": {"epss_score": 0.00398, "epss_percentile": 0.60052}, "CVE-2026-21451": {"epss_score": 0.00094, "epss_percentile": 0.26799}, "CVE-2026-21452": {"epss_score": 0.00044, "epss_percentile": 0.13626}, "CVE-2026-21483": {"epss_score": 0.00043, "epss_percentile": 0.13012}, "CVE-2026-21484": {"epss_score": 0.00028, "epss_percentile": 0.0721}, "CVE-2026-21485": {"epss_score": 0.00057, "epss_percentile": 0.18112}, "CVE-2026-21486": {"epss_score": 0.00013, "epss_percentile": 0.01603}, "CVE-2026-21487": {"epss_score": 0.00017, "epss_percentile": 0.03447}, "CVE-2026-21488": {"epss_score": 0.00012, "epss_percentile": 0.01425}, "CVE-2026-21489": {"epss_score": 0.00012, "epss_percentile": 0.01425}, "CVE-2026-21490": {"epss_score": 0.00012, "epss_percentile": 0.01196}, "CVE-2026-21491": {"epss_score": 0.00012, "epss_percentile": 0.01196}, "CVE-2026-21492": {"epss_score": 0.00012, "epss_percentile": 0.01252}, "CVE-2026-21493": {"epss_score": 0.00012, "epss_percentile": 0.01238}, "CVE-2026-21494": {"epss_score": 0.00012, "epss_percentile": 0.01196}, "CVE-2026-21495": {"epss_score": 0.00019, "epss_percentile": 0.04294}, "CVE-2026-21496": {"epss_score": 0.00018, "epss_percentile": 0.03523}, "CVE-2026-21497": {"epss_score": 0.00017, "epss_percentile": 0.03354}, "CVE-2026-21498": {"epss_score": 0.00018, "epss_percentile": 0.03523}, "CVE-2026-21499": {"epss_score": 0.00018, "epss_percentile": 0.03562}, "CVE-2026-21500": {"epss_score": 0.00018, "epss_percentile": 0.03523}, "CVE-2026-21501": {"epss_score": 0.00018, "epss_percentile": 0.03562}, "CVE-2026-21502": {"epss_score": 0.00018, "epss_percentile": 0.03523}, "CVE-2026-21503": {"epss_score": 0.00017, "epss_percentile": 0.03354}, "CVE-2026-21504": {"epss_score": 0.00012, "epss_percentile": 0.01261}, "CVE-2026-21505": {"epss_score": 0.00018, "epss_percentile": 0.03523}, "CVE-2026-21506": {"epss_score": 0.00013, "epss_percentile": 0.01563}, "CVE-2026-21507": {"epss_score": 0.00038, "epss_percentile": 0.11144}, "CVE-2026-21633": {"epss_score": 0.00019, "epss_percentile": 0.04278}, "CVE-2026-21634": {"epss_score": 0.00016, "epss_percentile": 0.02621}, "CVE-2026-21635": {"epss_score": 0.00014, "epss_percentile": 0.01978}, "CVE-2026-21673": {"epss_score": 0.00012, "epss_percentile": 0.01245}, "CVE-2026-21674": {"epss_score": 0.00012, "epss_percentile": 0.01271}, "CVE-2026-21675": {"epss_score": 0.0006, "epss_percentile": 0.19052}, "CVE-2026-21676": {"epss_score": 0.00037, "epss_percentile": 0.10791}, "CVE-2026-21677": {"epss_score": 0.00057, "epss_percentile": 0.18112}, "CVE-2026-21678": {"epss_score": 0.00018, "epss_percentile": 0.03686}, "CVE-2026-21679": {"epss_score": 0.00056, "epss_percentile": 0.1775}, "CVE-2026-21680": {"epss_score": 0.00032, "epss_percentile": 0.09033}, "CVE-2026-21681": {"epss_score": 0.0005, "epss_percentile": 0.15937}, "CVE-2026-21682": {"epss_score": 0.00055, "epss_percentile": 0.17456}, "CVE-2026-21683": {"epss_score": 0.00055, "epss_percentile": 0.17456}, "CVE-2026-21684": {"epss_score": 0.00055, "epss_percentile": 0.17633}, "CVE-2026-21685": {"epss_score": 0.00055, "epss_percentile": 0.17633}, "CVE-2026-21686": {"epss_score": 0.00055, "epss_percentile": 0.17633}, "CVE-2026-21687": {"epss_score": 0.00055, "epss_percentile": 0.17633}, "CVE-2026-21688": {"epss_score": 0.00057, "epss_percentile": 0.18112}, "CVE-2026-21689": {"epss_score": 0.00055, "epss_percentile": 0.17633}, "CVE-2026-21690": {"epss_score": 0.00048, "epss_percentile": 0.15181}, "CVE-2026-21691": {"epss_score": 0.0004, "epss_percentile": 0.11968}, "CVE-2026-21692": {"epss_score": 0.00055, "epss_percentile": 0.17456}, "CVE-2026-21693": {"epss_score": 0.00055, "epss_percentile": 0.17456}, "CVE-2026-21694": {"epss_score": 0.00028, "epss_percentile": 0.07493}, "CVE-2026-21695": {"epss_score": 0.00036, "epss_percentile": 0.10456}, "CVE-2026-21697": {"epss_score": 0.0011, "epss_percentile": 0.3008}, "CVE-2026-21851": {"epss_score": 0.00042, "epss_percentile": 0.12786}, "CVE-2026-21854": {"epss_score": 0.00271, "epss_percentile": 0.50296}, "CVE-2026-21855": {"epss_score": 0.00033, "epss_percentile": 0.09134}, "CVE-2026-21856": {"epss_score": 0.00028, "epss_percentile": 0.07437}, "CVE-2026-21857": {"epss_score": 0.00044, "epss_percentile": 0.13472}, "CVE-2026-21858": {"epss_score": 0.0003, "epss_percentile": 0.08034}, "CVE-2026-21859": {"epss_score": 9e-05, "epss_percentile": 0.0071}, "CVE-2026-21868": {"epss_score": 0.0004, "epss_percentile": 0.11957}, "CVE-2026-21869": {"epss_score": 0.00145, "epss_percentile": 0.35425}, "CVE-2026-21871": {"epss_score": 0.00029, "epss_percentile": 0.0777}, "CVE-2026-21872": {"epss_score": 0.00029, "epss_percentile": 0.0777}, "CVE-2026-21873": {"epss_score": 0.00029, "epss_percentile": 0.0777}, "CVE-2026-21874": {"epss_score": 0.00035, "epss_percentile": 0.09924}, "CVE-2026-21875": {"epss_score": 0.00031, "epss_percentile": 0.08389}, "CVE-2026-21877": {"epss_score": 0.00047, "epss_percentile": 0.1485}, "CVE-2026-21879": {"epss_score": 0.00028, "epss_percentile": 0.07343}, "CVE-2026-21880": {"epss_score": 0.00102, "epss_percentile": 0.28831}, "CVE-2026-21881": {"epss_score": 0.00074, "epss_percentile": 0.22715}, "CVE-2026-21883": {"epss_score": 0.00019, "epss_percentile": 0.04225}, "CVE-2026-21894": {"epss_score": 0.00041, "epss_percentile": 0.12421}, "CVE-2026-22035": {"epss_score": 0.00021, "epss_percentile": 0.04716}, "CVE-2026-22046": {"epss_score": 0.00055, "epss_percentile": 0.17456}, "CVE-2026-22047": {"epss_score": 0.00055, "epss_percentile": 0.17456}, "CVE-2026-22184": {"epss_score": 0.00081, "epss_percentile": 0.24314}, "CVE-2026-22185": {"epss_score": 0.00014, "epss_percentile": 0.01846}, "CVE-2026-22186": {"epss_score": 0.00015, "epss_percentile": 0.02191}, "CVE-2026-22187": {"epss_score": 0.0034, "epss_percentile": 0.56239}, "CVE-2026-22188": {"epss_score": 0.00014, "epss_percentile": 0.01846}, "CVE-2026-22189": {"epss_score": 0.00015, "epss_percentile": 0.02528}, "CVE-2026-22190": {"epss_score": 0.00014, "epss_percentile": 0.0186}, "CVE-2026-22242": {"epss_score": 0.00024, "epss_percentile": 0.05808}, "CVE-2026-22535": {"epss_score": 0.00022, "epss_percentile": 0.05169}, "CVE-2026-22536": {"epss_score": 0.00014, "epss_percentile": 0.02049}, "CVE-2026-22537": {"epss_score": 0.00014, "epss_percentile": 0.02031}, "CVE-2026-22539": {"epss_score": 0.00019, "epss_percentile": 0.04294}, "CVE-2026-22540": {"epss_score": 0.00042, "epss_percentile": 0.12732}, "CVE-2026-22541": {"epss_score": 0.00042, "epss_percentile": 0.12732}, "CVE-2026-22542": {"epss_score": 0.00042, "epss_percentile": 0.12732}, "CVE-2026-22543": {"epss_score": 0.00024, "epss_percentile": 0.05679}, "CVE-2026-22544": {"epss_score": 0.00029, "epss_percentile": 0.07842}}
\ No newline at end of file
diff --git a/data/cache/known_exploited_vulnerabilities.json b/data/cache/known_exploited_vulnerabilities.json
new file mode 100644
index 00000000000..a8924dc9bf9
--- /dev/null
+++ b/data/cache/known_exploited_vulnerabilities.json
@@ -0,0 +1,22056 @@
+{
+    "title": "CISA Catalog of Known Exploited Vulnerabilities",
+    "catalogVersion": "2026.01.07",
+    "dateReleased": "2026-01-07T18:05:19.7238Z",
+    "count": 1486,
+    "vulnerabilities": [
+        {
+            "cveID": "CVE-2009-0556",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office PowerPoint Code Injection Vulnerability",
+            "dateAdded": "2026-01-07",
+            "shortDescription": "Microsoft Office PowerPoint contains a code injection vulnerability that allows remote attackers to execute arbitrary code via a PowerPoint file with an OutlineTextRefAtom containing an invalid index value that triggers memory corruption.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2026-01-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/learn.microsoft.com\/en-us\/security-updates\/securitybulletins\/2009\/ms09-017 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2009-0556",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-37164",
+            "vendorProject": "Hewlett Packard (HP)",
+            "product": "OneView",
+            "vulnerabilityName": "Hewlett Packard Enterprise OneView Code Injection Vulnerability",
+            "dateAdded": "2026-01-07",
+            "shortDescription": "Hewlett Packard Enterprise OneView contains a code injection vulnerability that allows a remote unauthenticated user to perform remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2026-01-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.hpe.com\/hpesc\/public\/docDisplay?docId=hpesbgn04985en_us&docLocale=en_US ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-37164",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-14847",
+            "vendorProject": "MongoDB",
+            "product": "MongoDB and MongoDB Server",
+            "vulnerabilityName": "MongoDB and MongoDB Server Improper Handling of Length Parameter Inconsistency Vulnerability",
+            "dateAdded": "2025-12-29",
+            "shortDescription": "MongoDB Server contains an improper handling of length parameter inconsistency vulnerability in Zlib compressed protocol headers. This vulnerability may allow a read of uninitialized heap memory by an unauthenticated client.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2026-01-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability could affect an open-source component, third-party library, protocol, or proprietary implementation that could be used by different products. For more information, please see: https:\/\/jira.mongodb.org\/browse\/SERVER-115508 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-14847",
+            "cwes": [
+                "CWE-130"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-52163",
+            "vendorProject": "Digiever",
+            "product": "DS-2105 Pro",
+            "vulnerabilityName": "Digiever DS-2105 Pro Missing Authorization Vulnerability",
+            "dateAdded": "2025-12-22",
+            "shortDescription": "Digiever DS-2105 Pro contains a missing authorization vulnerability which could allow for command injection via time_tzsetup.cgi.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2026-01-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.digiever.com\/tw\/support\/faq-content.php?FAQ=217 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-52163",
+            "cwes": [
+                "CWE-862"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-14733",
+            "vendorProject": "WatchGuard",
+            "product": "Firebox",
+            "vulnerabilityName": "WatchGuard Firebox Out of Bounds Write Vulnerability",
+            "dateAdded": "2025-12-19",
+            "shortDescription": "WatchGuard Fireware OS iked process contains an out of bounds write vulnerability in the OS iked process. This vulnerability may allow a remote unauthenticated attacker to execute arbitrary code and affects both the mobile user VPN with IKEv2 and the branch office VPN using IKEv2 when configured with a dynamic gateway peer.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Check for signs of potential compromise on all internet accessible instances after applying mitigations. For more information please see: https:\/\/www.watchguard.com\/wgrd-psirt\/advisory\/wgsa-2025-00027 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-14733",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-59374",
+            "vendorProject": "ASUS",
+            "product": "Live Update",
+            "vulnerabilityName": "ASUS Live Update Embedded Malicious Code Vulnerability",
+            "dateAdded": "2025-12-17",
+            "shortDescription": "ASUS Live Update contains an embedded malicious code vulnerability client were distributed with unauthorized modifications introduced through a supply chain compromise. The modified builds could cause devices meeting specific targeting conditions to perform unintended actions. The impacted product could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2026-01-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.asus.com\/support\/faq\/1018727\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-59374",
+            "cwes": [
+                "CWE-506"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-40602",
+            "vendorProject": "SonicWall",
+            "product": "SMA1000 appliance",
+            "vulnerabilityName": "SonicWall SMA1000 Missing Authorization Vulnerability",
+            "dateAdded": "2025-12-17",
+            "shortDescription": "SonicWall SMA1000 contains a missing authorization vulnerability that could allow for privilege escalation appliance management console (AMC) of affected devices.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable",
+            "dueDate": "2025-12-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Check for signs of potential compromise on all internet accessible SonicWall SMA1000 instances after applying mitigations. For more information please see: https:\/\/psirt.global.sonicwall.com\/vuln-detail\/SNWLID-2025-0019 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-40602",
+            "cwes": [
+                "CWE-862",
+                "CWE-250"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-20393",
+            "vendorProject": "Cisco",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Cisco Multiple Products Improper Input Validation Vulnerability",
+            "dateAdded": "2025-12-17",
+            "shortDescription": "Cisco Secure Email Gateway, Secure Email, AsyncOS Software, and Web Manager appliances contains an improper input validation vulnerability that allows threat actors to execute arbitrary commands with root privileges on the underlying operating system of an affected appliance.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Please adhere to Cisco's guidelines to assess exposure and mitigate risks. Check for signs of potential compromise on all internet accessible Cisco products affected by this vulnerability. Apply any final mitigations provided by the vendor as soon as they become available. For more information please see: https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-sma-attack-N9bf4 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-20393",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-59718",
+            "vendorProject": "Fortinet",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Fortinet Multiple Products Improper Verification of Cryptographic Signature Vulnerability",
+            "dateAdded": "2025-12-16",
+            "shortDescription": "Fortinet FortiOS, FortiSwitchMaster, FortiProxy, and FortiWeb contain an improper verification of cryptographic signature vulnerability that may allow an unauthenticated attacker to bypass the FortiCloud SSO login authentication via a crafted SAML message. Please be aware that CVE-2025-59719 pertains to the same problem and is mentioned in the same vendor advisory. Ensure to apply all patches mentioned in the advisory.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/fortiguard.fortinet.com\/psirt\/FG-IR-25-647 ; https:\/\/docs.fortinet.com\/upgrade-tool\/fortigate ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-59718",
+            "cwes": [
+                "CWE-347"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-14611",
+            "vendorProject": "Gladinet",
+            "product": "CentreStack and Triofox",
+            "vulnerabilityName": "Gladinet CentreStack and Triofox Hard Coded Cryptographic Vulnerability",
+            "dateAdded": "2025-12-15",
+            "shortDescription": "Gladinet CentreStack and TrioFox contain a hardcoded cryptographic keys vulnerability for their implementation of the AES cryptoscheme. This vulnerability degrades security for public exposed endpoints that may make use of it and may offer arbitrary local file inclusion when provided a specially crafted request without authentication.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2026-01-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.centrestack.com\/p\/gce_latest_release.html ; https:\/\/access.triofox.com\/releases_history\/; https:\/\/support.centrestack.com\/hc\/en-us\/articles\/360007159054-Hardening-the-CentreStack-Cluster#h_01JQRV57T37HJFQZKBZH9NBXQP ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-14611",
+            "cwes": [
+                "CWE-798"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-43529",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Use-After-Free WebKit Vulnerability",
+            "dateAdded": "2025-12-15",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and other Apple products contain a use-after-free vulnerability in WebKit. Processing maliciously crafted web content may lead to memory corruption. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2026-01-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/125884 ; https:\/\/support.apple.com\/en-us\/125892 ; https:\/\/support.apple.com\/en-us\/125885 ; https:\/\/support.apple.com\/en-us\/125886 ; https:\/\/support.apple.com\/en-us\/125889 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-43529",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-4063",
+            "vendorProject": "Sierra Wireless",
+            "product": "AirLink ALEOS",
+            "vulnerabilityName": "Sierra Wireless AirLink ALEOS Unrestricted Upload of File with Dangerous Type Vulnerability",
+            "dateAdded": "2025-12-12",
+            "shortDescription": "Sierra Wireless AirLink ALEOS contains an unrestricted upload of file with dangerous type vulnerability. A specially crafted HTTP request can upload a file, resulting in executable code being uploaded, and routable, to the webserver. An attacker can make an authenticated HTTP request to trigger this vulnerability. The impacted product could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2026-01-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.cisa.gov\/news-events\/ics-advisories\/icsa-19-122-03 ; https:\/\/source.sierrawireless.com\/resources\/airlink\/software_reference_docs\/technical-bulletin\/sierra-wireless-technical-bulletin---swi-psa-2019-003 ; https:\/\/source.sierrawireless.com\/resources\/airlink\/hardware_reference_docs\/airlink_es450_eol ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-4063",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-14174",
+            "vendorProject": "Google",
+            "product": "Chromium",
+            "vulnerabilityName": "Google Chromium Out of Bounds Memory Access Vulnerability",
+            "dateAdded": "2025-12-12",
+            "shortDescription": "Google Chromium contains an out of bounds memory access vulnerability in ANGLE that could allow a remote attacker to perform out of bounds memory access via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2026-01-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2025\/12\/stable-channel-update-for-desktop_10.html ; https:\/\/learn.microsoft.com\/en-us\/deployedge\/microsoft-edge-relnotes-security ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-14174",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2025-58360",
+            "vendorProject": "OSGeo",
+            "product": "GeoServer",
+            "vulnerabilityName": "OSGeo GeoServer Improper Restriction of XML External Entity Reference Vulnerability",
+            "dateAdded": "2025-12-11",
+            "shortDescription": "OSGeo GeoServer contains an improper restriction of XML external entity reference vulnerability that occurs when the application accepts XML input through a specific endpoint \/geoserver\/wms operation GetMap and could allow an attacker to define external entities within the XML request.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2026-01-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects an open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/github.com\/geoserver\/geoserver\/security\/advisories\/GHSA-fjf5-xgmq-5525 ; https:\/\/osgeo-org.atlassian.net\/browse\/GEOS-11922 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-58360",
+            "cwes": [
+                "CWE-611"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-6218",
+            "vendorProject": "RARLAB",
+            "product": "WinRAR",
+            "vulnerabilityName": "RARLAB WinRAR Path Traversal Vulnerability",
+            "dateAdded": "2025-12-09",
+            "shortDescription": "RARLAB WinRAR contains a path traversal vulnerability allowing an attacker to execute code in the context of the current user.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.win-rar.com\/singlenewsview.html?&L=0&tx_ttnews%5Btt_news%5D=276&cHash=b5165454d983fc9717bc8748901a64f9 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-6218",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-62221",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Use After Free Vulnerability",
+            "dateAdded": "2025-12-09",
+            "shortDescription": "Microsoft Windows Cloud Files Mini Filter Driver contains a use after free vulnerability that can allow an authorized attacker to elevate privileges locally.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-62221 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-62221",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-37055",
+            "vendorProject": "D-Link",
+            "product": "Routers",
+            "vulnerabilityName": "D-Link Routers Buffer Overflow Vulnerability",
+            "dateAdded": "2025-12-08",
+            "shortDescription": "D-Link Routers contains a buffer overflow vulnerability that has a high impact on confidentiality, integrity, and availability. The impacted products could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportannouncement.us.dlink.com\/security\/publication.aspx?name=SAP10308 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-37055",
+            "cwes": [
+                "CWE-120"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-66644",
+            "vendorProject": "Array Networks ",
+            "product": "ArrayOS AG",
+            "vulnerabilityName": "Array Networks ArrayOS AG OS Command Injection Vulnerability",
+            "dateAdded": "2025-12-08",
+            "shortDescription": "Array Networks ArrayOS AG contains an OS command injection vulnerability that could allow an attacker to execute arbitrary commands.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.arraynetworks.net\/prx\/001\/http\/supportportal.arraynetworks.net\/ag.html ; https:\/\/www.jpcert.or.jp\/at\/2025\/at250024.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-66644",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-55182",
+            "vendorProject": "Meta",
+            "product": "React Server Components",
+            "vulnerabilityName": "Meta React Server Components Remote Code Execution Vulnerability",
+            "dateAdded": "2025-12-05",
+            "shortDescription": "Meta React Server Components contains a remote code execution vulnerability that could allow unauthenticated remote code execution by exploiting a flaw in how React decodes payloads sent to React Server Function endpoints. Please note CVE-2025-66478 has been rejected, but it is associated with CVE-2025- 55182.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-12",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Check for signs of potential compromise on all internet accessible REACT instances after applying mitigations. For more information, please see: https:\/\/react.dev\/blog\/2025\/12\/03\/critical-security-vulnerability-in-react-server-components ; https:\/\/github.com\/vercel-labs\/fix-react2shell-next?tab=readme-ov-file ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-55182",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-26828",
+            "vendorProject": "OpenPLC",
+            "product": "ScadaBR",
+            "vulnerabilityName": "OpenPLC ScadaBR Unrestricted Upload of File with Dangerous Type Vulnerability",
+            "dateAdded": "2025-12-03",
+            "shortDescription": "OpenPLC ScadaBR contains an unrestricted upload of file with dangerous type vulnerability that allows remote authenticated users to upload and execute arbitrary JSP files via view_edit.shtm.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability could affect an open-source component, third-party library, protocol, or proprietary implementation that could be used by different products. For more information, please see: https:\/\/github.com\/SCADA-LTS\/Scada-LTS\/pull\/2174 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-26828",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-48633",
+            "vendorProject": "Android",
+            "product": "Framework",
+            "vulnerabilityName": "Android Framework Information Disclosure Vulnerability",
+            "dateAdded": "2025-12-02",
+            "shortDescription": "Android Framework contains an unspecified vulnerability that allows for information disclosure.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/source.android.com\/docs\/security\/bulletin\/2025-12-01 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-48633",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2025-48572",
+            "vendorProject": "Android",
+            "product": "Framework",
+            "vulnerabilityName": "Android Framework Privilege Escalation Vulnerability",
+            "dateAdded": "2025-12-02",
+            "shortDescription": "Android Framework contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/source.android.com\/docs\/security\/bulletin\/2025-12-01 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-48572",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-26829",
+            "vendorProject": "OpenPLC",
+            "product": "ScadaBR",
+            "vulnerabilityName": "OpenPLC ScadaBR Cross-site Scripting Vulnerability",
+            "dateAdded": "2025-11-28",
+            "shortDescription": "OpenPLC ScadaBR contains a cross-site scripting vulnerability via system_settings.shtm.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability could affect an open-source component, third-party library, protocol, or proprietary implementation that could be used by different products. For more information, please see: https:\/\/github.com\/SCADA-LTS\/Scada-LTS\/pull\/3211 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-26829",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-61757",
+            "vendorProject": "Oracle",
+            "product": "Fusion Middleware",
+            "vulnerabilityName": "Oracle Fusion Middleware Missing Authentication for Critical Function Vulnerability",
+            "dateAdded": "2025-11-21",
+            "shortDescription": "Oracle Fusion Middleware contains a missing authentication for critical function vulnerability, allowing unauthenticated remote attackers to take over Identity Manager.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/cpuoct2025.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-61757",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-13223",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2025-11-19",
+            "shortDescription": "Google Chromium V8 contains a type confusion vulnerability that allows for heap corruption.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2025\/11\/stable-channel-update-for-desktop_17.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-13223",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-58034",
+            "vendorProject": "Fortinet",
+            "product": "FortiWeb",
+            "vulnerabilityName": "Fortinet FortiWeb OS Command Injection Vulnerability",
+            "dateAdded": "2025-11-18",
+            "shortDescription": "Fortinet FortiWeb contains an OS command Injection vulnerability that may allow an authenticated attacker to execute unauthorized code on the underlying system via crafted HTTP requests or CLI commands.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/fortiguard.fortinet.com\/psirt\/FG-IR-25-513 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-58034",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-64446",
+            "vendorProject": "Fortinet",
+            "product": "FortiWeb",
+            "vulnerabilityName": "Fortinet FortiWeb Path Traversal Vulnerability",
+            "dateAdded": "2025-11-14",
+            "shortDescription": "Fortinet FortiWeb contains a relative path traversal vulnerability that may allow an unauthenticated attacker to execute administrative commands on the system via crafted HTTP or HTTPS requests.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.fortiguard.com\/psirt\/FG-IR-25-910 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-64446",
+            "cwes": [
+                "CWE-23"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-12480",
+            "vendorProject": "Gladinet",
+            "product": "Triofox",
+            "vulnerabilityName": "Gladinet Triofox Improper Access Control Vulnerability",
+            "dateAdded": "2025-11-12",
+            "shortDescription": "Gladinet Triofox contains an improper access control vulnerability that allows access to initial setup pages even after setup is complete.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/access.triofox.com\/releases_history ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-12480",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-62215",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Race Condition Vulnerability",
+            "dateAdded": "2025-11-12",
+            "shortDescription": "Microsoft Windows Kernel contains a race condition vulnerability that allows a local attacker with low-level privileges to escalate privileges. Successful exploitation of this vulnerability could enable the attacker to gain SYSTEM-level access.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-62215 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-62215",
+            "cwes": [
+                "CWE-362"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-9242",
+            "vendorProject": "WatchGuard",
+            "product": "Firebox",
+            "vulnerabilityName": "WatchGuard Firebox Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2025-11-12",
+            "shortDescription": "WatchGuard Firebox contains an out-of-bounds write vulnerability in the OS iked process that may allow a remote unauthenticated attacker to execute arbitrary code.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.watchguard.com\/wgrd-psirt\/advisory\/wgsa-2025-00015 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-9242",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-21042",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2025-11-10",
+            "shortDescription": "Samsung mobile devices contain an out-of-bounds write vulnerability in libimagecodec.quram.so. This vulnerability could allow remote attackers to execute arbitrary code.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-12-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb?year=2025&month=04 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-21042",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-48703",
+            "vendorProject": "CWP",
+            "product": "Control Web Panel",
+            "vulnerabilityName": "CWP Control Web Panel OS Command Injection Vulnerability",
+            "dateAdded": "2025-11-04",
+            "shortDescription": "CWP Control Web Panel (formerly CentOS Web Panel) contains an OS command Injection vulnerability that allows unauthenticated remote code execution via shell metacharacters in the t_total parameter in a filemanager changePerm request. A valid non-root username must be known.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/control-webpanel.com\/changelog ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-48703",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-11371",
+            "vendorProject": "Gladinet",
+            "product": "CentreStack and Triofox",
+            "vulnerabilityName": "Gladinet CentreStack and Triofox Files or Directories Accessible to External Parties Vulnerability",
+            "dateAdded": "2025-11-04",
+            "shortDescription": "Gladinet CentreStack and Triofox contains a files or directories accessible to external parties vulnerability that allows unintended disclosure of system files.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.centrestack.com\/p\/gce_latest_release.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-11371",
+            "cwes": [
+                "CWE-552"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-41244",
+            "vendorProject": "Broadcom",
+            "product": "VMware Aria Operations and VMware Tools",
+            "vulnerabilityName": "Broadcom VMware Aria Operations and VMware Tools Privilege Defined with Unsafe Actions Vulnerability",
+            "dateAdded": "2025-10-30",
+            "shortDescription": "Broadcom VMware Aria Operations and VMware Tools contain a privilege defined with unsafe actions vulnerability. A malicious local actor with non-administrative privileges having access to a VM with VMware Tools installed and managed by Aria Operations with SDMP enabled may exploit this vulnerability to escalate privileges to root on the same VM.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.broadcom.com\/web\/ecx\/support-content-notification\/-\/external\/content\/SecurityAdvisories\/0\/36149 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-41244",
+            "cwes": [
+                "CWE-267"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24893",
+            "vendorProject": "XWiki",
+            "product": "Platform",
+            "vulnerabilityName": "XWiki Platform Eval Injection Vulnerability",
+            "dateAdded": "2025-10-30",
+            "shortDescription": "XWiki Platform contains an eval injection vulnerability that could allow any guest to perform arbitrary remote code execution through a request to SolrSearch.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/xwiki\/xwiki-platform\/security\/advisories\/GHSA-rr6p-3pfg-562j ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24893",
+            "cwes": [
+                "CWE-95"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-6204",
+            "vendorProject": "Dassault Syst\u00e8mes",
+            "product": "DELMIA Apriso",
+            "vulnerabilityName": "Dassault Syst\u00e8mes DELMIA Apriso Code Injection Vulnerability",
+            "dateAdded": "2025-10-28",
+            "shortDescription": "Dassault Syst\u00e8mes DELMIA Apriso contains a code injection vulnerability that could allow an attacker to execute arbitrary code.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.3ds.com\/trust-center\/security\/security-advisories\/cve-2025-6204 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-6204",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-6205",
+            "vendorProject": "Dassault Syst\u00e8mes",
+            "product": "DELMIA Apriso",
+            "vulnerabilityName": "Dassault Syst\u00e8mes DELMIA Apriso Missing Authorization Vulnerability",
+            "dateAdded": "2025-10-28",
+            "shortDescription": "Dassault Syst\u00e8mes DELMIA Apriso contains a missing authorization vulnerability that could allow an attacker to gain privileged access to the application.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.3ds.com\/trust-center\/security\/security-advisories\/cve-2025-6205 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-6205",
+            "cwes": [
+                "CWE-862"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-54236",
+            "vendorProject": "Adobe",
+            "product": "Commerce and\u202fMagento",
+            "vulnerabilityName": "Adobe Commerce and\u202fMagento Improper Input Validation Vulnerability",
+            "dateAdded": "2025-10-24",
+            "shortDescription": "Adobe Commerce and Magento Open Source contain an improper input validation vulnerability that could allow an attacker to take over customer accounts through the Commerce REST API.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/experienceleague.adobe.com\/en\/docs\/experience-cloud-kcs\/kbarticles\/ka-27397 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-54236",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-59287",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Server Update Service (WSUS) Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2025-10-24",
+            "shortDescription": "Microsoft Windows Server Update Service (WSUS) contains a deserialization of untrusted data vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-59287 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-59287",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-61932",
+            "vendorProject": "Motex",
+            "product": "LANSCOPE Endpoint Manager",
+            "vulnerabilityName": "Motex LANSCOPE Endpoint Manager Improper Verification of Source of a Communication Channel Vulnerability",
+            "dateAdded": "2025-10-22",
+            "shortDescription": "Motex LANSCOPE Endpoint Manager contains an improper verification of source of a communication channel vulnerability allowing an attacker to execute arbitrary code by sending specially crafted packets.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.motex.co.jp\/news\/notice\/2025\/release251020\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-61932",
+            "cwes": [
+                "CWE-940"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-48503",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Unspecified Vulnerability",
+            "dateAdded": "2025-10-20",
+            "shortDescription": "Apple macOS, iOS, tvOS, Safari, and watchOS contain an unspecified vulnerability in JavaScriptCore that when processing web content may lead to arbitrary code execution. The impacted product could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213340 ; https:\/\/support.apple.com\/en-us\/HT213341 ; https:\/\/support.apple.com\/en-us\/HT213342 ; https:\/\/support.apple.com\/en-us\/HT213345 ; https:\/\/support.apple.com\/en-us\/HT213346 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-48503",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2025-2746",
+            "vendorProject": "Kentico",
+            "product": "Xperience CMS",
+            "vulnerabilityName": "Kentico Xperience CMS Authentication Bypass Using an Alternate Path or Channel Vulnerability",
+            "dateAdded": "2025-10-20",
+            "shortDescription": "Kentico Xperience CMS contains an authentication bypass using an alternate path or channel vulnerability that could allow an attacker to control administrative objects.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/devnet.kentico.com\/download\/hotfixes ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-2746",
+            "cwes": [
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-2747",
+            "vendorProject": "Kentico",
+            "product": "Xperience CMS",
+            "vulnerabilityName": "Kentico Xperience CMS Authentication Bypass Using an Alternate Path or Channel Vulnerability",
+            "dateAdded": "2025-10-20",
+            "shortDescription": "Kentico Xperience CMS contains an authentication bypass using an alternate path or channel vulnerability that could allow an attacker to control administrative objects.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/devnet.kentico.com\/download\/hotfixes ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-2747",
+            "cwes": [
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-33073",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows SMB Client Improper Access Control Vulnerability",
+            "dateAdded": "2025-10-20",
+            "shortDescription": "Microsoft Windows SMB Client contains an improper access control vulnerability that could allow for privilege escalation. An attacker could execute a specially crafted malicious script to coerce the victim machine to connect back to the attack system using SMB and authenticate.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/advisory\/CVE-2025-33073 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-33073",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-61884",
+            "vendorProject": "Oracle",
+            "product": "E-Business Suite",
+            "vulnerabilityName": "Oracle E-Business Suite Server-Side Request Forgery (SSRF) Vulnerability",
+            "dateAdded": "2025-10-20",
+            "shortDescription": "Oracle E-Business Suite contains a server-side request forgery (SSRF) vulnerability in the Runtime component of Oracle Configurator. This vulnerability is remotely exploitable without authentication.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/alert-cve-2025-61884.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-61884",
+            "cwes": [
+                "CWE-918"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-54253",
+            "vendorProject": "Adobe",
+            "product": "Experience Manager (AEM) Forms",
+            "vulnerabilityName": "Adobe Experience Manager Forms Code Execution Vulnerability",
+            "dateAdded": "2025-10-15",
+            "shortDescription": "Adobe Experience Manager Forms in JEE contains an unspecified vulnerability that allows for arbitrary code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/helpx.adobe.com\/security\/products\/aem-forms\/apsb25-82.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-54253",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2025-47827",
+            "vendorProject": "IGEL",
+            "product": "IGEL OS",
+            "vulnerabilityName": "IGEL OS Use of a Key Past its Expiration Date Vulnerability",
+            "dateAdded": "2025-10-14",
+            "shortDescription": "IGEL OS contains a use of a key past its expiration date vulnerability that allows for Secure Boot bypass. The igel-flash-driver module improperly verifies a cryptographic signature. Ultimately, a crafted root filesystem can be mounted from an unverified SquashFS image.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-47827 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-47827",
+            "cwes": [
+                "CWE-324"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24990",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Untrusted Pointer Dereference Vulnerability",
+            "dateAdded": "2025-10-14",
+            "shortDescription": "Microsoft Windows Agere Modem Driver contains an untrusted pointer dereference vulnerability that allows for privilege escalation. An attacker who successfully exploited this vulnerability could gain administrator privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-24990 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24990",
+            "cwes": [
+                "CWE-822"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-59230",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Improper Access Control Vulnerability",
+            "dateAdded": "2025-10-14",
+            "shortDescription": "Microsoft Windows contains an improper access control vulnerability in Windows Remote Access Connection Manager which could allow an authorized attacker to elevate privileges locally.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-59230 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-59230",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-7836",
+            "vendorProject": "SKYSEA",
+            "product": "Client View",
+            "vulnerabilityName": "SKYSEA Client View Improper Authentication Vulnerability",
+            "dateAdded": "2025-10-14",
+            "shortDescription": "SKYSEA Client View contains an improper authentication vulnerability that allows remote code execution via a flaw in processing authentication on the TCP connection with the management console program.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-11-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.skyseaclientview.net\/news\/161221\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-7836",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-43798",
+            "vendorProject": "Grafana Labs",
+            "product": "Grafana",
+            "vulnerabilityName": "Grafana Path Traversal Vulnerability",
+            "dateAdded": "2025-10-09",
+            "shortDescription": "Grafana contains a path traversal vulnerability that could allow access to local files.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/grafana.com\/blog\/2021\/12\/07\/grafana-8.3.1-8.2.7-8.1.8-and-8.0.7-released-with-high-severity-security-fix\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-43798",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-27915",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Cross-site Scripting Vulnerability",
+            "dateAdded": "2025-10-07",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) contains a cross-site scripting vulnerability that exists in the Classic Web Client due to insufficient sanitization of HTML content in ICS files. When a user views an e-mail message containing a malicious ICS entry, its embedded JavaScript executes via an ontoggle event inside a tag. This allows an attacker to run arbitrary JavaScript within the victim's session, potentially leading to unauthorized actions such as setting e-mail filters to redirect messages to an attacker-controlled address. As a result, an attacker can perform unauthorized actions on the victim's account, including e-mail redirection and data exfiltration.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/wiki.zimbra.com\/wiki\/Security_Center ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-27915",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22555",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Heap Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2025-10-06",
+            "shortDescription": "Linux Kernel contains a heap out-of-bounds write vulnerability that could allow an attacker to gain privileges or cause a DoS (via heap memory corruption) through user name space.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/git.kernel.org\/pub\/scm\/linux\/kernel\/git\/torvalds\/linux.git\/commit\/net\/netfilter\/x_tables.c?id=9fa492cdc160cd27ce1046cb36f47d3b2b1efa21 ; https:\/\/git.kernel.org\/pub\/scm\/linux\/kernel\/git\/torvalds\/linux.git\/commit\/net\/netfilter\/x_tables.c?id=b29c457a6511435960115c0f548c4360d5f4801d ; https:\/\/security.netapp.com\/advisory\/ntap-20210805-0010\/ ; https:\/\/github.com\/google\/security-research\/security\/advisories\/GHSA-xxx5-8mvq-3528 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22555",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-3962",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Uninitialized Memory Corruption Vulnerability",
+            "dateAdded": "2025-10-06",
+            "shortDescription": "Microsoft Internet Explorer contains an uninitialized memory corruption vulnerability that could allow for remote code execution. The impacted product could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/learn.microsoft.com\/en-us\/security-updates\/SecurityAdvisories\/2010\/2458511?redirectedfrom=MSDN ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-3962",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-43226",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Privilege Escalation Vulnerability",
+            "dateAdded": "2025-10-06",
+            "shortDescription": "Microsoft Windows Common Log File System Driver contains a privilege escalation vulnerability that could allow a local, privileged attacker to bypass certain security mechanisms.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2021-43226 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-43226",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2013-3918",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2025-10-06",
+            "shortDescription": "Microsoft Windows contains an out-of-bounds write vulnerability in the InformationCardSigninHelper Class ActiveX control, icardie.dll. An attacker could exploit the vulnerability by constructing a specially crafted webpage. When a user views the webpage, the vulnerability could allow remote code execution. An attacker who successfully exploited this vulnerability could gain the same user rights as the current user. The impacted product could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/docs.microsoft.com\/en-us\/security-updates\/securitybulletins\/2013\/ms13-090 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-3918",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2011-3402",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Remote Code Execution Vulnerability",
+            "dateAdded": "2025-10-06",
+            "shortDescription": "Microsoft Windows Kernel contains an unspecified vulnerability in the TrueType font parsing engine in win32k.sys in the kernel-mode drivers that allows remote attackers to execute arbitrary code via crafted font data in a Word document or web page.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/docs.microsoft.com\/en-us\/security-updates\/securitybulletins\/2011\/ms11-087 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2011-3402",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2010-3765",
+            "vendorProject": "Mozilla",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Mozilla Multiple Products Remote Code Execution Vulnerability",
+            "dateAdded": "2025-10-06",
+            "shortDescription": "Mozilla Firefox, SeaMonkey, and Thunderbird contain an unspecified vulnerability when JavaScript is enabled. This allows remote attackers to execute arbitrary code via vectors related to nsCSSFrameConstructor::ContentAppended, the appendChild method, incorrect index tracking, and the creation of multiple frames, which triggers memory corruption.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.mozilla.org\/en-US\/security\/advisories\/mfsa2010-73 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-3765",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2025-61882",
+            "vendorProject": "Oracle",
+            "product": "E-Business Suite",
+            "vulnerabilityName": "Oracle E-Business Suite Unspecified Vulnerability",
+            "dateAdded": "2025-10-06",
+            "shortDescription": "Oracle E-Business Suite contains an unspecified vulnerability in the BI Publisher Integration component. The vulnerability allows unauthenticated attacker with network access via HTTP to compromise Oracle Concurrent Processing. Successful attacks can result in takeover of Oracle Concurrent Processing.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-27",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/alert-cve-2025-61882.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-61882",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2014-6278",
+            "vendorProject": "GNU",
+            "product": "GNU Bash",
+            "vulnerabilityName": "GNU Bash OS Command Injection Vulnerability",
+            "dateAdded": "2025-10-02",
+            "shortDescription": "GNU Bash contains an OS command injection vulnerability which allows remote attackers to execute arbitrary commands via a crafted environment.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable. ",
+            "dueDate": "2025-10-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability could affect an open-source component, third-party library, protocol, or proprietary implementation that could be used by different products. For more information, please see: http:\/\/ftp.gnu.org\/gnu\/bash\/bash-4.3-patches\/bash43-027 ; https:\/\/support.broadcom.com\/web\/ecx\/support-content-notification\/-\/external\/content\/SecurityAdvisories\/0\/23467 ; https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-20140926-bash ; https:\/\/www.ibm.com\/support\/pages\/security-bulletin-update-vulnerabilities-bash-affect-aix-toolbox-linux-applications-cve-2014-6271-cve-2014-6277-cve-2014-6278-cve-2014-7169-cve-2014-7186-and-cve-2014-7187 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-6278",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-1000353",
+            "vendorProject": "Jenkins",
+            "product": "Jenkins",
+            "vulnerabilityName": "Jenkins Remote Code Execution Vulnerability",
+            "dateAdded": "2025-10-02",
+            "shortDescription": "Jenkins contains a remote code execution vulnerability. This vulnerability that could allowed attackers to transfer a serialized Java SignedObject object to the remoting-based Jenkins CLI, that would be deserialized using a new ObjectInputStream, bypassing the existing blocklist-based protection mechanism.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.jenkins.io\/security\/advisory\/2017-04-26\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-1000353",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2015-7755",
+            "vendorProject": "Juniper",
+            "product": "ScreenOS",
+            "vulnerabilityName": "Juniper ScreenOS Improper Authentication Vulnerability",
+            "dateAdded": "2025-10-02",
+            "shortDescription": "Juniper ScreenOS contains an improper authentication vulnerability that could allow unauthorized remote administrative access to the device.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportportal.juniper.net\/s\/article\/2015-12-Out-of-Cycle-Security-Bulletin-ScreenOS-Multiple-Security-issues-with-ScreenOS-CVE-2015-7755-CVE-2015-7756 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-7755",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-21043",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2025-10-02",
+            "shortDescription": "Samsung mobile devices contain an out-of-bounds write vulnerability in libimagecodec.quram.so which allows remote attackers to execute arbitrary code.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb?year=2025&month=09 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-21043",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-4008",
+            "vendorProject": "Smartbedded",
+            "product": "Meteobridge",
+            "vulnerabilityName": "Smartbedded Meteobridge Command Injection Vulnerability",
+            "dateAdded": "2025-10-02",
+            "shortDescription": "Smartbedded Meteobridge contains a command injection vulnerability that could allow remote unauthenticated attackers to gain arbitrary command execution with elevated privileges (root) on affected devices.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forum.meteohub.de\/viewtopic.php?t=18687 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-4008",
+            "cwes": [
+                "CWE-306",
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-32463",
+            "vendorProject": "Sudo",
+            "product": "Sudo",
+            "vulnerabilityName": "Sudo Inclusion of Functionality from Untrusted Control Sphere Vulnerability",
+            "dateAdded": "2025-09-29",
+            "shortDescription": "Sudo contains an inclusion of functionality from untrusted control sphere vulnerability. This vulnerability could allow local attacker to leverage sudo\u2019s -R (--chroot) option to run arbitrary commands as root, even if they are not listed in the sudoers file.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability could affect an open-source component, third-party library, protocol, or proprietary implementation that could be used by different products. For more information, please see: https:\/\/www.sudo.ws\/security\/advisories\/chroot_bug\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-32463",
+            "cwes": [
+                "CWE-829"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-59689",
+            "vendorProject": "Libraesva",
+            "product": "Email Security Gateway",
+            "vulnerabilityName": "Libraesva Email Security Gateway Command Injection Vulnerability",
+            "dateAdded": "2025-09-29",
+            "shortDescription": "Libraesva Email Security Gateway (ESG) contains a command injection vulnerability which allows command injection via a compressed e-mail attachment.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/docs.libraesva.com\/knowledgebase\/security-advisory-command-injection-vulnerability-cve-2025-59689\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-59689",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-10035",
+            "vendorProject": "Fortra",
+            "product": "GoAnywhere MFT",
+            "vulnerabilityName": "Fortra GoAnywhere MFT Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2025-09-29",
+            "shortDescription": "Fortra GoAnywhere MFT contains a deserialization of untrusted data vulnerability allows an actor with a validly forged license response signature to deserialize an arbitrary actor-controlled object, possibly leading to command injection.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-20",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.fortra.com\/security\/advisories\/product-security\/fi-2025-012 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-10035",
+            "cwes": [
+                "CWE-502",
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-20352",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software SNMP Denial of Service and Remote Code Execution Vulnerability",
+            "dateAdded": "2025-09-29",
+            "shortDescription": "Cisco IOS and IOS XE contains a stack-based buffer overflow vulnerability in the Simple Network Management Protocol (SNMP) subsystem that could allow for denial of service or remote code execution. A successful exploit could allow a low-privileged attacker to cause the affected system to reload, resulting in a DoS condition, or allow a high-privileged attacker to execute arbitrary code as the root user and obtain full control of the affected system.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-snmp-x4LPhte ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-20352",
+            "cwes": [
+                "CWE-121"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21311",
+            "vendorProject": "Adminer",
+            "product": "Adminer",
+            "vulnerabilityName": "Adminer Server-Side Request Forgery Vulnerability",
+            "dateAdded": "2025-09-29",
+            "shortDescription": "Adminer contains a server-side request forgery vulnerability that, when exploited, allows a remote attacker to obtain potentially sensitive information.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/vrana\/adminer\/security\/advisories\/GHSA-x5r2-hj5c-8jx6 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21311",
+            "cwes": [
+                "CWE-918"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-20362",
+            "vendorProject": "Cisco",
+            "product": "Secure Firewall Adaptive Security Appliance and Secure Firewall Threat Defense",
+            "vulnerabilityName": "Cisco Secure Firewall Adaptive Security (ASA) Appliance and Secure Firewall Threat Defense (FTD) Missing Authorization Vulnerability",
+            "dateAdded": "2025-09-25",
+            "shortDescription": "Cisco Secure Firewall Adaptive Security (ASA) Appliance and Secure Firewall Threat Defense (FTD) Software VPN Web Server contain a missing authorization vulnerability. This vulnerability could be chained with CVE-2025-20333.",
+            "requiredAction": "The KEV due date refers to the deadline by which FCEB agencies are expected to review and begin implementing the guidance outlined in Emergency Directive (ED) 25-03 (URL listed below in Notes). Agencies must follow the mitigation steps provided by CISA (URL listed below in Notes) and vendor\u2019s instructions (URL listed below in Notes). Adhere to the applicable BOD 22-01 guidance for cloud services or discontinue use of the product if mitigations are not available.",
+            "dueDate": "2025-09-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "CISA Mitigation Instructions: https:\/\/www.cisa.gov\/news-events\/directives\/ed-25-03-identify-and-mitigate-potential-compromise-cisco-devices ; https:\/\/www.cisa.gov\/news-events\/directives\/supplemental-direction-ed-25-03-core-dump-and-hunt-instructions ; https:\/\/www.cisa.gov\/eviction-strategies-tool\/create-from-template ; https:\/\/sec.cloudapps.cisco.com\/security\/center\/resources\/asa_ftd_continued_attacks ;   https:\/\/sec.cloudapps.cisco.com\/security\/center\/private\/resources\/asa_ftd_continued_attacks#Details ; https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-asaftd-webvpn-YROOTUW ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-20362",
+            "cwes": [
+                "CWE-862"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-20333",
+            "vendorProject": "Cisco",
+            "product": "Secure Firewall Adaptive Security Appliance and Secure Firewall Threat Defense",
+            "vulnerabilityName": "Cisco Secure Firewall Adaptive Security Appliance (ASA) and Secure Firewall Threat Defense (FTD) Buffer Overflow Vulnerability",
+            "dateAdded": "2025-09-25",
+            "shortDescription": "Cisco Secure Firewall Adaptive Security (ASA) Appliance and Secure Firewall Threat Defense (FTD) Software VPN Web Server contain a buffer overflow vulnerability that allows for remote code execution. This vulnerability could be chained with CVE-2025-20362.",
+            "requiredAction": "The KEV due date refers to the deadline by which FCEB agencies are expected to review and begin implementing the guidance outlined in Emergency Directive (ED) 25-03 (URL listed below in Notes). Agencies must follow the mitigation steps provided by CISA (URL listed below in Notes) and vendor\u2019s instructions (URL listed below in Notes). Adhere to the applicable BOD 22-01 guidance for cloud services or discontinue use of the product if mitigations are not available.",
+            "dueDate": "2025-09-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "CISA Mitigation Instructions: https:\/\/www.cisa.gov\/news-events\/directives\/ed-25-03-identify-and-mitigate-potential-compromise-cisco-devices ; https:\/\/www.cisa.gov\/news-events\/directives\/supplemental-direction-ed-25-03-core-dump-and-hunt-instructions ; https:\/\/www.cisa.gov\/eviction-strategies-tool\/create-from-template ; https:\/\/sec.cloudapps.cisco.com\/security\/center\/resources\/asa_ftd_continued_attacks ;    https:\/\/sec.cloudapps.cisco.com\/security\/center\/private\/resources\/asa_ftd_continued_attacks#Details ; https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-asaftd-webvpn-z5xP8EUB ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-20333",
+            "cwes": [
+                "CWE-120"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-10585",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2025-09-23",
+            "shortDescription": "Google Chromium contains a type confusion vulnerability in the V8 JavaScript and WebAssembly engine.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2025\/09\/stable-channel-update-for-desktop_17.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-10585",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-5086",
+            "vendorProject": "Dassault Syst\u00e8mes",
+            "product": "DELMIA Apriso",
+            "vulnerabilityName": "Dassault Syst\u00e8mes DELMIA Apriso Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2025-09-11",
+            "shortDescription": "Dassault Syst\u00e8mes DELMIA Apriso contains a deserialization of untrusted data vulnerability that could lead to a remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-10-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.3ds.com\/trust-center\/security\/security-advisories\/cve-2025-5086 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-5086",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-38352",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Time-of-Check Time-of-Use (TOCTOU) Race Condition Vulnerability",
+            "dateAdded": "2025-09-04",
+            "shortDescription": "Linux kernel contains a time-of-check time-of-use (TOCTOU) race condition vulnerability that has a high impact on confidentiality, integrity, and availability.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/git.kernel.org\/pub\/scm\/linux\/kernel\/git\/stable\/linux.git\/commit\/?id=2c72fe18cc5f9f1750f5bc148cf1c94c29e106ff ; https:\/\/source.android.com\/docs\/security\/bulletin\/2025-09-01 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-38352",
+            "cwes": [
+                "CWE-367"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-48543",
+            "vendorProject": "Android",
+            "product": "Runtime",
+            "vulnerabilityName": "Android Runtime Use-After-Free Vulnerability",
+            "dateAdded": "2025-09-04",
+            "shortDescription": "Android Runtime contains a use-after-free vulnerability potentially allowing a chrome sandbox escape leading to local privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/source.android.com\/docs\/security\/bulletin\/2025-09-01 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-48543",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2025-53690",
+            "vendorProject": "Sitecore",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Sitecore Multiple Products Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2025-09-04",
+            "shortDescription": "Sitecore Experience Manager (XM), Experience Platform (XP), Experience Commerce (XC), and Managed Cloud contain a deserialization of untrusted data vulnerability involving the use of default machine keys. This flaw allows attackers to exploit exposed ASP.NET machine keys to achieve remote code execution. ",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.sitecore.com\/kb?id=kb_article_view&sysparm_article=KB1003865 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-53690",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-50224",
+            "vendorProject": "TP-Link",
+            "product": "TL-WR841N",
+            "vulnerabilityName": "TP-Link TL-WR841N Authentication Bypass by Spoofing Vulnerability",
+            "dateAdded": "2025-09-03",
+            "shortDescription": "TP-Link TL-WR841N contains an authentication bypass by spoofing vulnerability within the httpd service, which listens on TCP port 80 by default, leading to the disclose of stored credentials. The impacted products could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.tp-link.com\/us\/support\/faq\/4308\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-50224",
+            "cwes": [
+                "CWE-290"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-9377",
+            "vendorProject": "TP-Link",
+            "product": "Multiple Routers",
+            "vulnerabilityName": "TP-Link Archer C7(EU) and TL-WR841N\/ND(MS) OS Command Injection Vulnerability",
+            "dateAdded": "2025-09-03",
+            "shortDescription": "TP-Link Archer C7(EU) and TL-WR841N\/ND(MS) contain an OS command injection vulnerability that exists in the Parental Control page. The impacted products could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.tp-link.com\/us\/support\/faq\/4308\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-9377",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-24363",
+            "vendorProject": "TP-Link",
+            "product": "TL-WA855RE",
+            "vulnerabilityName": "TP-link TL-WA855RE Missing Authentication for Critical Function Vulnerability",
+            "dateAdded": "2025-09-02",
+            "shortDescription": "TP-link TL-WA855RE contains a missing authentication for critical function vulnerability. This vulnerability could allow an unauthenticated attacker (on the same network) to submit a TDDP_RESET POST request for a factory reset and reboot. The attacker can then obtain incorrect access control by setting a new administrative password. The impacted products could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.tp-link.com\/us\/home-networking\/range-extender\/tl-wa855re\/#overview ; https:\/\/www.tp-link.com\/us\/support\/download\/tl-wa855re\/#FAQs ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-24363",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-55177",
+            "vendorProject": "Meta Platforms",
+            "product": "WhatsApp",
+            "vulnerabilityName": "Meta Platforms WhatsApp Incorrect Authorization Vulnerability",
+            "dateAdded": "2025-09-02",
+            "shortDescription": "Meta Platforms WhatsApp contains an incorrect authorization vulnerability due to an incomplete authorization of linked device synchronization messages. This vulnerability could allow an unrelated user to trigger processing of content from an arbitrary URL on a target\u2019s device.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.whatsapp.com\/security\/advisories\/2025\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-55177",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-57819",
+            "vendorProject": "Sangoma",
+            "product": "FreePBX",
+            "vulnerabilityName": "Sangoma FreePBX Authentication Bypass Vulnerability",
+            "dateAdded": "2025-08-29",
+            "shortDescription": "Sangoma FreePBX contains an authentication bypass vulnerability due to insufficiently sanitized user-supplied data allows unauthenticated access to FreePBX Administrator leading to arbitrary database manipulation and remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/FreePBX\/security-reporting\/security\/advisories\/GHSA-m42g-xg4c-5f3h ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-57819",
+            "cwes": [
+                "CWE-89",
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-7775",
+            "vendorProject": "Citrix",
+            "product": "NetScaler",
+            "vulnerabilityName": "Citrix NetScaler Memory Overflow Vulnerability",
+            "dateAdded": "2025-08-26",
+            "shortDescription": "Citrix NetScaler ADC and NetScaler Gateway contain a memory overflow vulnerability that could allow for remote code execution and\/or denial of service.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.citrix.com\/support-home\/kbsearch\/article?articleNumber=CTX694938 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-7775",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-48384",
+            "vendorProject": "Git",
+            "product": "Git",
+            "vulnerabilityName": "Git Link Following Vulnerability",
+            "dateAdded": "2025-08-25",
+            "shortDescription": "Git contains a link following vulnerability that stems from Git\u2019s inconsistent handling of carriage return characters in configuration files.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/github.com\/git\/git\/security\/advisories\/GHSA-vwqx-4fm8-6qc9 ; https:\/\/access.redhat.com\/errata\/RHSA-2025:13933 ; https:\/\/alas.aws.amazon.com\/AL2\/ALAS2-2025-2941.html ; https:\/\/linux.oracle.com\/errata\/ELSA-2025-11534.html ; https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2025-48384 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-48384",
+            "cwes": [
+                "CWE-59",
+                "CWE-436"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-8068",
+            "vendorProject": "Citrix",
+            "product": "Session Recording",
+            "vulnerabilityName": "Citrix Session Recording Improper Privilege Management Vulnerability",
+            "dateAdded": "2025-08-25",
+            "shortDescription": "Citrix Session Recording contains an improper privilege management vulnerability that could allow for privilege escalation to NetworkService Account access. An attacker must be an authenticated user in the same Windows Active Directory domain as the session recording server domain.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.citrix.com\/external\/article\/691941\/citrix-session-recording-security-bullet.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-8068",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-8069",
+            "vendorProject": "Citrix",
+            "product": "Session Recording",
+            "vulnerabilityName": "Citrix Session Recording Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2025-08-25",
+            "shortDescription": "Citrix Session Recording contains a deserialization of untrusted data vulnerability that allows limited remote code execution with privilege of a NetworkService Account access. Attacker must be an authenticated user on the same intranet as the session recording server.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.citrix.com\/external\/article\/691941\/citrix-session-recording-security-bullet.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-8069",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-43300",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and macOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and macOS Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2025-08-21",
+            "shortDescription": "Apple iOS, iPadOS, and macOS contain an out-of-bounds write vulnerability in the Image I\/O framework.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/124925 ; https:\/\/support.apple.com\/en-us\/124926 ; https:\/\/support.apple.com\/en-us\/124927 ; https:\/\/support.apple.com\/en-us\/124928 ; https:\/\/support.apple.com\/en-us\/124929 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-43300",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-54948",
+            "vendorProject": "Trend Micro",
+            "product": "Apex One",
+            "vulnerabilityName": "Trend Micro Apex One OS Command Injection Vulnerability",
+            "dateAdded": "2025-08-18",
+            "shortDescription": "Trend Micro Apex One Management Console (on-premise) contains an OS command injection vulnerability that could allow a pre-authenticated remote attacker to upload malicious code and execute commands on affected installations.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/success.trendmicro.com\/en-US\/solution\/KA-0020652 ; N\/A ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-54948",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-8876",
+            "vendorProject": "N-able",
+            "product": "N-Central",
+            "vulnerabilityName": "N-able N-Central Command Injection Vulnerability",
+            "dateAdded": "2025-08-13",
+            "shortDescription": "N-able N-Central contains a command injection vulnerability via improper sanitization of user input.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/status.n-able.com\/2025\/08\/13\/announcing-the-ga-of-n-central-2025-3-1\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-8876",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2025-8875",
+            "vendorProject": "N-able",
+            "product": "N-Central",
+            "vulnerabilityName": "N-able N-Central Insecure Deserialization Vulnerability",
+            "dateAdded": "2025-08-13",
+            "shortDescription": "N-able N-Central contains an insecure deserialization vulnerability that could lead to command execution.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/status.n-able.com\/2025\/08\/13\/announcing-the-ga-of-n-central-2025-3-1\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-8875",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2025-8088",
+            "vendorProject": "RARLAB",
+            "product": "WinRAR",
+            "vulnerabilityName": "RARLAB WinRAR Path Traversal Vulnerability",
+            "dateAdded": "2025-08-12",
+            "shortDescription": "RARLAB WinRAR contains a path traversal vulnerability affecting the Windows version of WinRAR. This vulnerability could allow an attacker to execute arbitrary code by crafting malicious archive files.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.win-rar.com\/singlenewsview.html?&L=0&tx_ttnews%5Btt_news%5D=283&cHash=a64b4a8f662d3639dec8d65f47bc93c5 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-8088",
+            "cwes": [
+                "CWE-35"
+            ]
+        },
+        {
+            "cveID": "CVE-2007-0671",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Excel Remote Code Execution Vulnerability",
+            "dateAdded": "2025-08-12",
+            "shortDescription": "Microsoft Office Excel contains a remote code execution vulnerability that can be exploited when a specially crafted Excel file is opened. This malicious file could be delivered as an email attachment or hosted on a malicious website. An attacker could leverage this vulnerability by creating a specially crafted Excel file, which, when opened, allowing an attacker to execute remote code on the affected system.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/learn.microsoft.com\/en-us\/security-updates\/securitybulletins\/2007\/ms07-015 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2007-0671",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2013-3893",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Resource Management Errors Vulnerability",
+            "dateAdded": "2025-08-12",
+            "shortDescription": "Microsoft Internet Explorer contains a memory corruption vulnerability that allows for remote code execution. The impacted products could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-09-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/learn.microsoft.com\/en-us\/security-updates\/securitybulletins\/2013\/ms13-080 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-3893",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-25078",
+            "vendorProject": "D-Link",
+            "product": "DCS-2530L and DCS-2670L Devices",
+            "vulnerabilityName": "D-Link DCS-2530L and DCS-2670L Devices Unspecified Vulnerability",
+            "dateAdded": "2025-08-05",
+            "shortDescription": "D-Link DCS-2530L and DCS-2670L devices contains an unspecified vulnerability that could allow for remote administrator password disclosure. The impacted products could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.dlink.com\/productinfo.aspx?m=DCS-2530L ; https:\/\/supportannouncement.us.dlink.com\/announcement\/publication.aspx?name=SAP10180 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-25078",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-25079",
+            "vendorProject": "D-Link",
+            "product": "DCS-2530L and DCS-2670L Devices",
+            "vulnerabilityName": "D-Link DCS-2530L and DCS-2670L Command Injection Vulnerability",
+            "dateAdded": "2025-08-05",
+            "shortDescription": "D-Link DCS-2530L and DCS-2670L devices contains a command injection vulnerability in the cgi-bin\/ddns_enc.cgi. The impacted products could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.dlink.com\/productinfo.aspx?m=DCS-2530L ; https:\/\/supportannouncement.us.dlink.com\/announcement\/publication.aspx?name=SAP10180 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-25079",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-40799",
+            "vendorProject": "D-Link",
+            "product": "DNR-322L",
+            "vulnerabilityName": "D-Link DNR-322L Download of Code Without Integrity Check Vulnerability",
+            "dateAdded": "2025-08-05",
+            "shortDescription": "D-Link DNR-322L contains a download of code without integrity check vulnerability that could allow an authenticated attacker to execute OS level commands on the device. The impacted products could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.dlink.com\/uk\/en\/products\/dnr-322l-cloud-network-video-recorder ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-40799",
+            "cwes": [
+                "CWE-494"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-2533",
+            "vendorProject": "PaperCut",
+            "product": "NG\/MF",
+            "vulnerabilityName": "PaperCut NG\/MF Cross-Site Request Forgery (CSRF) Vulnerability",
+            "dateAdded": "2025-07-28",
+            "shortDescription": "PaperCut NG\/MF contains a cross-site request forgery (CSRF) vulnerability, which, under specific conditions, could potentially enable an attacker to alter security settings or execute arbitrary code. ",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.papercut.com\/kb\/Main\/SecurityBulletinJune2023 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-2533",
+            "cwes": [
+                "CWE-352"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-20337",
+            "vendorProject": "Cisco",
+            "product": "Identity Services Engine",
+            "vulnerabilityName": "Cisco Identity Services Engine Injection Vulnerability",
+            "dateAdded": "2025-07-28",
+            "shortDescription": "Cisco Identity Services Engine contains an injection vulnerability in a specific API of Cisco ISE and Cisco ISE-PIC due to insufficient validation of user-supplied input allowing an attacker to exploit this vulnerability by submitting a crafted API request. Successful exploitation could allow an attacker to perform remote code execution and obtaining root privileges on an affected device.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-ise-unauth-rce-ZAd2GnJ6 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-20337",
+            "cwes": [
+                "CWE-74"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-20281",
+            "vendorProject": "Cisco",
+            "product": "Identity Services Engine",
+            "vulnerabilityName": "Cisco Identity Services Engine Injection Vulnerability",
+            "dateAdded": "2025-07-28",
+            "shortDescription": "Cisco Identity Services Engine contains an injection vulnerability in a specific API of Cisco ISE and Cisco ISE-PIC due to insufficient validation of user-supplied input allowing an attacker to exploit this vulnerability by submitting a crafted API request. Successful exploitation could allow an attacker to perform remote code execution and obtaining root privileges on an affected device.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-ise-unauth-rce-ZAd2GnJ6 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-20281",
+            "cwes": [
+                "CWE-74"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-2775",
+            "vendorProject": "SysAid",
+            "product": "SysAid On-Prem",
+            "vulnerabilityName": "SysAid On-Prem Improper Restriction of XML External Entity Reference Vulnerability",
+            "dateAdded": "2025-07-22",
+            "shortDescription": "SysAid On-Prem contains an improper restriction of XML external entity reference vulnerability in the Checkin processing functionality, allowing for administrator account takeover and file read primitives.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/documentation.sysaid.com\/docs\/24-40-60 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-2775",
+            "cwes": [
+                "CWE-611"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-2776",
+            "vendorProject": "SysAid",
+            "product": "SysAid On-Prem",
+            "vulnerabilityName": "SysAid On-Prem Improper Restriction of XML External Entity Reference Vulnerability",
+            "dateAdded": "2025-07-22",
+            "shortDescription": "SysAid On-Prem contains an improper restriction of XML external entity reference vulnerability in the Server URL processing functionality, allowing for administrator account takeover and file read primitives.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/documentation.sysaid.com\/docs\/24-40-60 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-2776",
+            "cwes": [
+                "CWE-611"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-6558",
+            "vendorProject": "Google",
+            "product": "Chromium",
+            "vulnerabilityName": "Google Chromium ANGLE and GPU Improper Input Validation Vulnerability",
+            "dateAdded": "2025-07-22",
+            "shortDescription": "Google Chromium contains an improper input validation vulnerability in ANGLE and GPU. This vulnerability could allow a remote attacker to potentially perform a sandbox escape via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2025\/07\/stable-channel-update-for-desktop_15.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-6558",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-54309",
+            "vendorProject": "CrushFTP",
+            "product": "CrushFTP",
+            "vulnerabilityName": " CrushFTP Unprotected Alternate Channel Vulnerability",
+            "dateAdded": "2025-07-22",
+            "shortDescription": "CrushFTP contains an unprotected alternate channel vulnerability. When the DMZ proxy feature is not used, mishandles AS2 validation and consequently allows remote attackers to obtain admin access via HTTPS.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.crushftp.com\/crush11wiki\/Wiki.jsp?page=CompromiseJuly2025 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-54309 ",
+            "cwes": [
+                "CWE-420"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-49704",
+            "vendorProject": "Microsoft",
+            "product": "SharePoint",
+            "vulnerabilityName": "Microsoft SharePoint Code Injection Vulnerability",
+            "dateAdded": "2025-07-22",
+            "shortDescription": "Microsoft SharePoint contains a code injection vulnerability that could allow an authorized attacker to execute code over a network. This vulnerability could be chained with CVE-2025-49706. CVE-2025-53770 is a patch bypass for CVE-2025-49704, and the updates for CVE-2025-53770 include more robust protection than those for CVE-2025-49704.",
+            "requiredAction": "Disconnect public-facing versions of SharePoint Server that have reached their end-of-life (EOL) or end-of-service (EOS) to include SharePoint Server 2013 and earlier versions. For supported versions, please follow the mitigations according to CISA (URL listed below in Notes) and vendor instructions (URL listed below in Notes). Adhere to the applicable BOD 22-01 guidance for cloud services or discontinue use of the product if mitigations are not available.",
+            "dueDate": "2025-07-23",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "CISA Mitigation Instructions: https:\/\/www.cisa.gov\/news-events\/alerts\/2025\/07\/20\/microsoft-releases-guidance-exploitation-sharepoint-vulnerability-cve-2025-53770; https:\/\/www.microsoft.com\/en-us\/security\/blog\/2025\/07\/22\/disrupting-active-exploitation-of-on-premises-sharepoint-vulnerabilities\/ ; https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2025-49704 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-49704",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-49706",
+            "vendorProject": "Microsoft",
+            "product": "SharePoint",
+            "vulnerabilityName": "Microsoft SharePoint Improper Authentication Vulnerability",
+            "dateAdded": "2025-07-22",
+            "shortDescription": "Microsoft SharePoint contains an improper authentication vulnerability that allows an authorized attacker to perform spoofing over a network. Successfully exploitation could allow an attacker to view sensitive information and make some changes to disclosed information. This vulnerability could be chained with CVE-2025-49704. CVE-2025-53771 is a patch bypass for CVE-2025-49706, and the updates for CVE-2025-53771 include more robust protection than those for CVE-2025-49706.",
+            "requiredAction": "Disconnect public-facing versions of SharePoint Server that have reached their end-of-life (EOL) or end-of-service (EOS) to include SharePoint Server 2013 and earlier versions. For supported versions, please follow the mitigations according to CISA (URL listed below in Notes) and vendor instructions (URL listed below in Notes). Adhere to the applicable BOD 22-01 guidance for cloud services or discontinue use of the product if mitigations are not available.",
+            "dueDate": "2025-07-23",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "CISA Mitigation Instructions: https:\/\/www.cisa.gov\/news-events\/alerts\/2025\/07\/20\/microsoft-releases-guidance-exploitation-sharepoint-vulnerability-cve-2025-53770 ; https:\/\/www.microsoft.com\/en-us\/security\/blog\/2025\/07\/22\/disrupting-active-exploitation-of-on-premises-sharepoint-vulnerabilities\/ ; https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2025-49706 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-49706",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-53770",
+            "vendorProject": "Microsoft",
+            "product": "SharePoint",
+            "vulnerabilityName": "Microsoft SharePoint Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2025-07-20",
+            "shortDescription": "Microsoft SharePoint Server on-premises contains a deserialization of untrusted data vulnerability that could allow an unauthorized attacker to execute code over a network. This vulnerability could be chained with CVE-2025-53771. CVE-2025-53770 is a patch bypass for CVE-2025-49704, and the updates for CVE-2025-53770 include more robust protection than those for CVE-2025-49704.",
+            "requiredAction": "Disconnect public-facing versions of SharePoint Server that have reached their end-of-life (EOL) or end-of-service (EOS) to include SharePoint Server 2013 and earlier versions. For supported versions, please follow the mitigations according to CISA (URL listed below in Notes) and vendor instructions (URL listed below in Notes). Adhere to the applicable BOD 22-01 guidance for cloud services or discontinue use of the product if mitigations are not available.",
+            "dueDate": "2025-07-21",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "CISA Mitigation Instructions: https:\/\/www.cisa.gov\/news-events\/alerts\/2025\/07\/20\/microsoft-releases-guidance-exploitation-sharepoint-vulnerability-cve-2025-53770; https:\/\/www.microsoft.com\/en-us\/security\/blog\/2025\/07\/22\/disrupting-active-exploitation-of-on-premises-sharepoint-vulnerabilities\/ ; https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2025-53770 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-53770",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-25257",
+            "vendorProject": "Fortinet",
+            "product": "FortiWeb",
+            "vulnerabilityName": "Fortinet FortiWeb SQL Injection Vulnerability",
+            "dateAdded": "2025-07-18",
+            "shortDescription": "Fortinet FortiWeb contains a SQL injection vulnerability that may allow an unauthenticated attacker to execute unauthorized SQL code or commands via crafted HTTP or HTTPs requests.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/fortiguard.fortinet.com\/psirt\/FG-IR-25-151 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-25257",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-47812",
+            "vendorProject": "Wing FTP Server",
+            "product": "Wing FTP Server",
+            "vulnerabilityName": "Wing FTP Server Improper Neutralization of Null Byte or NUL Character Vulnerability",
+            "dateAdded": "2025-07-14",
+            "shortDescription": "Wing FTP Server contains an improper neutralization of null byte or NUL character vulnerability that can allow injection of arbitrary Lua code into user session files. This can be used to execute arbitrary system commands with the privileges of the FTP service (root or SYSTEM by default).",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-08-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.wftpserver.com\/serverhistory.htm ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-47812",
+            "cwes": [
+                "CWE-158"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-5777",
+            "vendorProject": "Citrix",
+            "product": "NetScaler ADC and Gateway",
+            "vulnerabilityName": "Citrix NetScaler ADC and Gateway Out-of-Bounds Read Vulnerability",
+            "dateAdded": "2025-07-10",
+            "shortDescription": "Citrix NetScaler ADC and Gateway contain an out-of-bounds read vulnerability due to insufficient input validation. This vulnerability can lead to memory overread when the NetScaler is configured as a Gateway (VPN virtual server, ICA Proxy, CVPN, RDP Proxy) OR AAA virtual server.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-11",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/support.citrix.com\/support-home\/kbsearch\/article?articleNumber=CTX693420 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-5777",
+            "cwes": [
+                "CWE-125"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-9621",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Server-Side Request Forgery (SSRF) Vulnerability",
+            "dateAdded": "2025-07-07",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) contains a server-side request forgery (SSRF) vulnerability via the ProxyServlet component.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/wiki.zimbra.com\/wiki\/Zimbra_Security_Advisories ; https:\/\/wiki.zimbra.com\/wiki\/Security_Center ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-9621",
+            "cwes": [
+                "CWE-918",
+                "CWE-807"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-5418",
+            "vendorProject": "Rails",
+            "product": "Ruby on Rails",
+            "vulnerabilityName": "Rails Ruby on Rails Path Traversal Vulnerability",
+            "dateAdded": "2025-07-07",
+            "shortDescription": "Rails Ruby on Rails contains a path traversal vulnerability in Action View. Specially crafted accept headers in combination with calls to `render file:` can cause arbitrary files on the target server to be rendered, disclosing the file contents.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/web.archive.org\/web\/20190313201629\/https:\/\/weblog.rubyonrails.org\/2019\/3\/13\/Rails-4-2-5-1-5-1-6-2-have-been-released\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-5418",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-10033",
+            "vendorProject": "PHP",
+            "product": "PHPMailer",
+            "vulnerabilityName": "PHPMailer Command Injection Vulnerability",
+            "dateAdded": "2025-07-07",
+            "shortDescription": "PHPMailer contains a command injection vulnerability because it fails to sanitize user-supplied input. Specifically, this issue affects the 'mail()' function of 'class.phpmailer.php' script. An attacker can exploit this issue to execute arbitrary code within the context of the application. Failed exploit attempts will result in a denial-of-service condition.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability could affect an open-source component, third-party library, protocol, or proprietary implementation that could be used by different products. For more information, please see: https:\/\/github.com\/PHPMailer\/PHPMailer\/releases\/tag\/v5.2.18 ; https:\/\/github.com\/advisories\/GHSA-5f37-gxvh-23v6 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-10033",
+            "cwes": [
+                "CWE-77",
+                "CWE-88"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-3931",
+            "vendorProject": "Looking Glass",
+            "product": "Multi-Router Looking Glass (MRLG)",
+            "vulnerabilityName": "Multi-Router Looking Glass (MRLG) Buffer Overflow Vulnerability",
+            "dateAdded": "2025-07-07",
+            "shortDescription": "Multi-Router Looking Glass (MRLG) contains a buffer overflow vulnerability that could allow remote attackers to cause an arbitrary memory write and memory corruption.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/mrlg.op-sec.us\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-3931",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-6554",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2025-07-02",
+            "shortDescription": "Google Chromium V8 contains a type confusion vulnerability that could allow a remote attacker to perform arbitrary read\/write via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2025\/06\/stable-channel-update-for-desktop_30.html?m=1 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-6554",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-48928",
+            "vendorProject": "TeleMessage",
+            "product": "TM SGNL",
+            "vulnerabilityName": "TeleMessage TM SGNL Exposure of Core Dump File to an Unauthorized Control Sphere Vulnerability",
+            "dateAdded": "2025-07-01",
+            "shortDescription": "TeleMessage TM SGNL contains an exposure of core dump file to an unauthorized control sphere Vulnerability. This vulnerability is based on a JSP application in which the heap content is roughly equivalent to a \"core dump\" in which a password previously sent over HTTP would be included in this dump.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "It is recommended that mitigations be applied per vendor instructions if available. If these instructions cannot be located or if mitigations are unavailable, discontinue use of the product. ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-48928",
+            "cwes": [
+                "CWE-528"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-48927",
+            "vendorProject": "TeleMessage",
+            "product": "TM SGNL",
+            "vulnerabilityName": "TeleMessage TM SGNL Initialization of a Resource with an Insecure Default Vulnerability",
+            "dateAdded": "2025-07-01",
+            "shortDescription": "TeleMessage TM SGNL contains an initialization of a resource with an insecure default vulnerability. This vulnerability relies on how the Spring Boot Actuator is configured with an exposed heap dump endpoint at a \/heapdump URI.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "It is recommended that mitigations be applied per vendor instructions if available. If these instructions cannot be located or if mitigations are unavailable, discontinue use of the product. ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-48927",
+            "cwes": [
+                "CWE-1188"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-6543",
+            "vendorProject": "Citrix",
+            "product": "NetScaler ADC and Gateway",
+            "vulnerabilityName": "Citrix NetScaler ADC and Gateway Buffer Overflow Vulnerability",
+            "dateAdded": "2025-06-30",
+            "shortDescription": "Citrix NetScaler ADC and Gateway contain a buffer overflow vulnerability leading to unintended control flow and Denial of Service. NetScaler must be configured as Gateway (VPN virtual server, ICA Proxy, CVPN, RDP Proxy) OR AAA virtual server.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.citrix.com\/support-home\/kbsearch\/article?articleNumber=CTX694788 ; https:\/\/www.netscaler.com\/blog\/news\/netscaler-critical-security-updates-for-cve-2025-6543-and-cve-2025-5777\/ ;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-6543",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-6693",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS",
+            "vulnerabilityName": "Fortinet FortiOS Use of Hard-Coded Credentials Vulnerability",
+            "dateAdded": "2025-06-25",
+            "shortDescription": "Fortinet FortiOS contains a use of hard-coded credentials vulnerability that could allow an attacker to cipher sensitive data in FortiOS configuration backup file via knowledge of the hard-coded key. ",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-16",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/fortiguard.com\/advisory\/FG-IR-19-007 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-6693",
+            "cwes": [
+                "CWE-798"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-0769",
+            "vendorProject": "D-Link",
+            "product": "DIR-859 Router",
+            "vulnerabilityName": " D-Link DIR-859 Router Path Traversal Vulnerability",
+            "dateAdded": "2025-06-25",
+            "shortDescription": "D-Link DIR-859 routers contain a path traversal vulnerability in the file \/hedwig.cgi of the component HTTP POST Request Handler. Manipulation of the argument service with the input ..\/..\/..\/..\/htdocs\/webinc\/getcfg\/DHCPS6.BRIDGE-1.xml allows for the leakage of session data potentially enabling privilege escalation and unauthorized control of the device. This vulnerability affects legacy D-Link products. All associated hardware revisions have reached their end-of-life (EOL) or end-of-service (EOS) life cycle and should be retired and replaced per vendor instructions.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportannouncement.us.dlink.com\/announcement\/publication.aspx?name=SAP10371 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-0769",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-54085",
+            "vendorProject": "AMI",
+            "product": "MegaRAC SPx",
+            "vulnerabilityName": "AMI MegaRAC SPx Authentication Bypass by Spoofing Vulnerability",
+            "dateAdded": "2025-06-25",
+            "shortDescription": "AMI MegaRAC SPx contains an authentication bypass by spoofing vulnerability in the Redfish Host Interface. A successful exploitation of this vulnerability may lead to a loss of confidentiality, integrity, and\/or availability.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability could affect an open-source component, third-party library, protocol, or proprietary implementation that could be used by different products. For more information, please see: https:\/\/go.ami.com\/hubfs\/Security%20Advisories\/2025\/AMI-SA-2025003.pdf ; https:\/\/security.netapp.com\/advisory\/ntap-20250328-0003\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-54085",
+            "cwes": [
+                "CWE-290"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-0386",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Improper Ownership Management Vulnerability",
+            "dateAdded": "2025-06-17",
+            "shortDescription": "Linux Kernel contains an improper ownership management vulnerability, where unauthorized access to the execution of the setuid file with capabilities was found in the Linux kernel\u2019s OverlayFS subsystem in how a user copies a capable file from a nosuid mount into another mount. This uid mapping bug allows a local user to escalate their privileges on the system.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/git.kernel.org\/pub\/scm\/linux\/kernel\/git\/torvalds\/linux.git\/commit\/?id=4f11ada10d0a ; https:\/\/access.redhat.com\/security\/cve\/cve-2023-0386 ; https:\/\/security.netapp.com\/advisory\/ntap-20230420-0004\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-0386",
+            "cwes": [
+                "CWE-282"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-33538",
+            "vendorProject": "TP-Link",
+            "product": "Multiple Routers",
+            "vulnerabilityName": "TP-Link Multiple Routers Command Injection Vulnerability",
+            "dateAdded": "2025-06-16",
+            "shortDescription": "TP-Link TL-WR940N V2\/V4, TL-WR841N V8\/V10, and TL-WR740N V1\/V2 contain a command injection vulnerability via the component \/userRpm\/WlanNetworkRpm. The impacted products could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.tp-link.com\/nordic\/support\/faq\/3562\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-33538",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-43200",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Unspecified Vulnerability",
+            "dateAdded": "2025-06-16",
+            "shortDescription": "Apple iOS, iPadOS, macOS, watchOS, and visionOS, contain an unspecified vulnerability when processing a maliciously crafted photo or video shared via an iCloud Link.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/122174 ; https:\/\/support.apple.com\/en-us\/122173 ; https:\/\/support.apple.com\/en-us\/122900 ; https:\/\/support.apple.com\/en-us\/122901 ; https:\/\/support.apple.com\/en-us\/122902 ; https:\/\/support.apple.com\/en-us\/122903 ; https:\/\/support.apple.com\/en-us\/122904 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-43200",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2025-33053",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": " Microsoft Windows External Control of File Name or Path Vulnerability",
+            "dateAdded": "2025-06-10",
+            "shortDescription": "Microsoft Windows contains an external control of file name or path vulnerability that could allow an attacker to execute code from a remote WebDAV location specified by the WorkingDirectory attribute of Internet Shortcut files.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-33053 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-33053",
+            "cwes": [
+                "CWE-73"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24016",
+            "vendorProject": "Wazuh",
+            "product": "Wazuh Server",
+            "vulnerabilityName": "Wazuh Server Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2025-06-10",
+            "shortDescription": "Wazuh contains a deserialization of untrusted data vulnerability that allows for remote code execution on Wazuh servers.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-07-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/wazuh.com\/blog\/addressing-the-cve-2025-24016-vulnerability\/ ; https:\/\/github.com\/wazuh\/wazuh\/security\/advisories\/GHSA-hcrc-79hj-m3qh ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24016",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-42009",
+            "vendorProject": "Roundcube",
+            "product": "Webmail",
+            "vulnerabilityName": "RoundCube Webmail Cross-Site Scripting Vulnerability",
+            "dateAdded": "2025-06-09",
+            "shortDescription": "RoundCube Webmail contains a cross-site scripting vulnerability. This vulnerability could allow a remote attacker to steal and send emails of a victim via a crafted e-mail message that abuses a Desanitization issue in message_body() in program\/actions\/mail\/show.php.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/roundcube.net\/news\/2024\/08\/04\/security-updates-1.6.8-and-1.5.8 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-42009",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-32433",
+            "vendorProject": "Erlang",
+            "product": "Erlang\/OTP",
+            "vulnerabilityName": "Erlang Erlang\/OTP SSH Server Missing Authentication for Critical Function Vulnerability",
+            "dateAdded": "2025-06-09",
+            "shortDescription": "Erlang Erlang\/OTP SSH server contains a missing authentication for critical function vulnerability. This could allow an attacker to execute arbitrary commands without valid credentials, potentially leading to unauthenticated remote code execution (RCE). By exploiting a flaw in how SSH protocol messages are handled, a malicious actor could gain unauthorized access to affected systems. This vulnerability could affect various products that implement Erlang\/OTP SSH server, including\u2014but not limited to\u2014Cisco, NetApp, and SUSE.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source project, third-party library, or a protocol used by different products. For more information, please see: https:\/\/github.com\/erlang\/otp\/security\/advisories\/GHSA-37cp-fgq5-7wc2 ; https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-erlang-otp-ssh-xyZZy ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-32433",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-5419",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Out-of-Bounds Read and Write Vulnerability",
+            "dateAdded": "2025-06-05",
+            "shortDescription": "Google Chromium V8 contains an out-of-bounds read and write vulnerability that could allow a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2025\/06\/stable-channel-update-for-desktop.html;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-5419\",",
+            "cwes": [
+                "CWE-125",
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-21479",
+            "vendorProject": "Qualcomm",
+            "product": "Multiple Chipsets",
+            "vulnerabilityName": "Qualcomm Multiple Chipsets Incorrect Authorization Vulnerability",
+            "dateAdded": "2025-06-03",
+            "shortDescription": "Multiple Qualcomm chipsets contain an incorrect authorization vulnerability. This vulnerability allows for memory corruption due to unauthorized command execution in GPU micronode while executing specific sequence of commands.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Please check with specific vendors (OEMs,) for information on patching status. For more information, please see: https:\/\/docs.qualcomm.com\/product\/publicresources\/securitybulletin\/june-2025-bulletin.html ;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-21479",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-21480",
+            "vendorProject": "Qualcomm",
+            "product": "Multiple Chipsets",
+            "vulnerabilityName": "Qualcomm Multiple Chipsets Incorrect Authorization Vulnerability",
+            "dateAdded": "2025-06-03",
+            "shortDescription": "Multiple Qualcomm chipsets contain an incorrect authorization vulnerability. This vulnerability allows for memory corruption due to unauthorized command execution in GPU micronode while executing specific sequence of commands.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Please check with specific vendors (OEMs,) for information on patching status. For more information, please see: https:\/\/docs.qualcomm.com\/product\/publicresources\/securitybulletin\/june-2025-bulletin.html ;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-21480",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-27038",
+            "vendorProject": "Qualcomm",
+            "product": "Multiple Chipsets",
+            "vulnerabilityName": "Qualcomm Multiple Chipsets Use-After-Free Vulnerability",
+            "dateAdded": "2025-06-03",
+            "shortDescription": "Multiple Qualcomm chipsets contain a use-after-free vulnerability. This vulnerability allows for memory corruption while rendering graphics using Adreno GPU drivers in Chrome.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Please check with specific vendors (OEMs,) for information on patching status. For more information, please see: https:\/\/docs.qualcomm.com\/product\/publicresources\/securitybulletin\/june-2025-bulletin.html ;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-27038",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-32030",
+            "vendorProject": "ASUS",
+            "product": "Routers",
+            "vulnerabilityName": "ASUS Routers Improper Authentication Vulnerability",
+            "dateAdded": "2025-06-02",
+            "shortDescription": "ASUS Lyra Mini and ASUS GT-AC2900 devices contain an improper authentication vulnerability that allows an attacker to gain unauthorized access to the administrative interface. The impacted products could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.asus.com\/us\/supportonly\/lyra%20mini\/helpdesk_bios\/ ; https:\/\/www.asus.com\/us\/supportonly\/rog%20rapture%20gt-ac2900\/helpdesk_bios\/; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-32030",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-3935",
+            "vendorProject": "ConnectWise",
+            "product": "ScreenConnect",
+            "vulnerabilityName": "ConnectWise ScreenConnect Improper Authentication Vulnerability",
+            "dateAdded": "2025-06-02",
+            "shortDescription": "ConnectWise ScreenConnect contains an improper authentication vulnerability. This vulnerability could allow a ViewState code injection attack, which could allow remote code execution if machine keys are compromised.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.connectwise.com\/company\/trust\/security-bulletins\/screenconnect-security-patch-2025.4 ;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-3935",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-35939",
+            "vendorProject": "Craft CMS",
+            "product": "Craft CMS",
+            "vulnerabilityName": "Craft CMS External Control of Assumed-Immutable Web Parameter Vulnerability",
+            "dateAdded": "2025-06-02",
+            "shortDescription": "Craft CMS contains an external control of assumed-immutable web parameter vulnerability. This vulnerability could allow an unauthenticated client to introduce arbitrary values, such as PHP code, to a known local file location on the server. This vulnerability could be chained with CVE-2024-58136 as represented by CVE-2025-32432.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/craftcms\/cms\/pull\/17220 ;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-35939",
+            "cwes": [
+                "CWE-472"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-56145",
+            "vendorProject": "Craft CMS",
+            "product": "Craft CMS",
+            "vulnerabilityName": "Craft CMS Code Injection Vulnerability",
+            "dateAdded": "2025-06-02",
+            "shortDescription": "Craft CMS contains a code injection vulnerability. Users with affected versions are vulnerable to remote code execution if their php.ini configuration has `register_argc_argv` enabled.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/craftcms\/cms\/security\/advisories\/GHSA-2p6p-9rc9-62j9 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-56145",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-39780",
+            "vendorProject": "ASUS",
+            "product": "RT-AX55 Routers",
+            "vulnerabilityName": "ASUS RT-AX55 Routers OS Command Injection Vulnerability",
+            "dateAdded": "2025-06-02",
+            "shortDescription": "ASUS RT-AX55 devices contain an OS command injection vulnerability that could allow a remote, authenticated attacker to execute arbitrary commands. As represented by CVE-2023-41346.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.asus.com\/networking-iot-servers\/wifi-6\/all-series\/rt-ax55\/helpdesk_bios\/?model2Name=RT-AX55 ;   https:\/\/www.asus.com\/content\/asus-product-security-advisory\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-39780",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-4632",
+            "vendorProject": "Samsung",
+            "product": "MagicINFO 9 Server",
+            "vulnerabilityName": "Samsung MagicINFO 9 Server Path Traversal Vulnerability",
+            "dateAdded": "2025-05-22",
+            "shortDescription": "Samsung MagicINFO 9 Server contains a path traversal vulnerability that allows an attacker to write arbitrary file as system authority.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungtv.com\/securityUpdates#SVP-MAY-2025 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-4632",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-38950",
+            "vendorProject": "ZKTeco",
+            "product": "BioTime",
+            "vulnerabilityName": "ZKTeco BioTime Path Traversal Vulnerability",
+            "dateAdded": "2025-05-19",
+            "shortDescription": "ZKTeco BioTime contains a path traversal vulnerability in the iclock API that allows an unauthenticated attacker to read arbitrary files via supplying a crafted payload.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.zkteco.com\/en\/Security_Bulletinsibs ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-38950",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-27443",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2025-05-19",
+            "shortDescription": "Zimbra Collaboration contains a cross-site scripting (XSS) vulnerability in the CalendarInvite feature of the Zimbra webmail classic user interface. An attacker can exploit this vulnerability via an email message containing a crafted calendar header, leading to the execution of arbitrary JavaScript code.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/wiki.zimbra.com\/wiki\/Zimbra_Releases\/8.8.15\/P46#Security_Fixes ; https:\/\/wiki.zimbra.com\/wiki\/Zimbra_Releases\/9.0.0\/P39#Security_Fixes ; https:\/\/wiki.zimbra.com\/wiki\/Zimbra_Releases\/10.0.7#Security_Fixes ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-27443",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-27920",
+            "vendorProject": "Srimax",
+            "product": "Output Messenger",
+            "vulnerabilityName": "Srimax Output Messenger Directory Traversal Vulnerability",
+            "dateAdded": "2025-05-19",
+            "shortDescription": "Srimax Output Messenger contains a directory traversal vulnerability that allows an attacker to access sensitive files outside the intended directory, potentially leading to configuration leakage or arbitrary file access.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.outputmessenger.com\/cve-2025-27920\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-27920",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-11182",
+            "vendorProject": "MDaemon",
+            "product": "Email Server",
+            "vulnerabilityName": "MDaemon Email Server Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2025-05-19",
+            "shortDescription": "MDaemon Email Server contains a cross-site scripting (XSS) vulnerability that allows a remote attacker to load arbitrary JavaScript code via an HTML e-mail message.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/files.mdaemon.com\/mdaemon\/beta\/RelNotes_en.html ; https:\/\/mdaemon.com\/pages\/downloads-critical-updates ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-11182",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-4428",
+            "vendorProject": "Ivanti",
+            "product": "Endpoint Manager Mobile (EPMM)",
+            "vulnerabilityName": "Ivanti Endpoint Manager Mobile (EPMM) Code Injection Vulnerability",
+            "dateAdded": "2025-05-19",
+            "shortDescription": "Ivanti Endpoint Manager Mobile (EPMM) contains a code injection vulnerability in the API component that allows an authenticated attacker to remotely execute arbitrary code via crafted API requests. This vulnerability results from an insecure implementation of the Hibernate Validator open-source library, as represented by CVE-2025-35036.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/Security-Advisory-Ivanti-Endpoint-Manager-Mobile-EPMM ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-4428",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-4427",
+            "vendorProject": "Ivanti",
+            "product": "Endpoint Manager Mobile (EPMM)",
+            "vulnerabilityName": "Ivanti Endpoint Manager Mobile (EPMM) Authentication Bypass Vulnerability",
+            "dateAdded": "2025-05-19",
+            "shortDescription": "Ivanti Endpoint Manager Mobile (EPMM) contains an authentication bypass vulnerability in the API component that allows an attacker to access protected resources without proper credentials via crafted API requests. This vulnerability results from an insecure implementation of the Spring Framework open-source library.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/Security-Advisory-Ivanti-Endpoint-Manager-Mobile-EPMM ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-4427",
+            "cwes": [
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-42999",
+            "vendorProject": "SAP",
+            "product": "NetWeaver",
+            "vulnerabilityName": "SAP NetWeaver Deserialization Vulnerability",
+            "dateAdded": "2025-05-15",
+            "shortDescription": "SAP NetWeaver Visual Composer Metadata Uploader contains a deserialization vulnerability that allows a privileged attacker to compromise the confidentiality, integrity, and availability of the host system by deserializing untrusted or malicious content.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "SAP users must have an account to log in and access the patch: https:\/\/me.sap.com\/notes\/3604119 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-42999",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-12987",
+            "vendorProject": "DrayTek",
+            "product": "Vigor Routers",
+            "vulnerabilityName": "DrayTek Vigor Routers OS Command Injection Vulnerability",
+            "dateAdded": "2025-05-15",
+            "shortDescription": "DrayTek Vigor2960, Vigor300B, and Vigor3900 routers contain an OS command injection vulnerability due to an unknown function of the file \/cgi-bin\/mainfunction.cgi\/apmcfgupload of the component web management interface.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/fw.draytek.com.tw\/Vigor2960\/Firmware\/v1.5.1.5\/DrayTek_Vigor2960_V1.5.1.5_01release-note.pdf ; https:\/\/fw.draytek.com.tw\/Vigor300B\/Firmware\/v1.5.1.5\/DrayTek_Vigor300B_V1.5.1.5_01release-note.pdf ; https:\/\/fw.draytek.com.tw\/Vigor3900\/Firmware\/v1.5.1.5\/DrayTek_Vigor3900_V1.5.1.5_01release-note.pdf ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-12987",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-32756",
+            "vendorProject": "Fortinet",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Fortinet Multiple Products Stack-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2025-05-14",
+            "shortDescription": "Fortinet FortiFone, FortiVoice, FortiNDR and FortiMail contain a stack-based overflow vulnerability that may allow a remote unauthenticated attacker to execute arbitrary code or commands via crafted HTTP requests.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/fortiguard.fortinet.com\/psirt\/FG-IR-25-254 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-32756",
+            "cwes": [
+                "CWE-124"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-32709",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Ancillary Function Driver for WinSock Use-After-Free Vulnerability",
+            "dateAdded": "2025-05-13",
+            "shortDescription": "Microsoft Windows Ancillary Function Driver for WinSock contains a use-after-free vulnerability that allows an authorized attacker to escalate privileges to administrator.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-32709 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-32709",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-30397",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Scripting Engine Type Confusion Vulnerability",
+            "dateAdded": "2025-05-13",
+            "shortDescription": "Microsoft Windows Scripting Engine contains a type confusion vulnerability that allows an unauthorized attacker to execute code over a network via a specially crafted URL.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-30397 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-30397",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-32706",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Common Log File System (CLFS) Driver Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2025-05-13",
+            "shortDescription": "Microsoft Windows Common Log File System (CLFS) Driver contains a heap-based buffer overflow vulnerability that allows an authorized attacker to elevate privileges locally.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-32706 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-32706",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-32701",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Common Log File System (CLFS) Driver Use-After-Free Vulnerability",
+            "dateAdded": "2025-05-13",
+            "shortDescription": "Microsoft Windows Common Log File System (CLFS) Driver contains a use-after-free vulnerability that allows an authorized attacker to elevate privileges locally.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-32701 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-32701",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-30400",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows DWM Core Library Use-After-Free Vulnerability",
+            "dateAdded": "2025-05-13",
+            "shortDescription": "Microsoft Windows DWM Core Library contains a use-after-free vulnerability that allows an authorized attacker to elevate privileges locally.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-30400 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-30400",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-47729",
+            "vendorProject": "TeleMessage",
+            "product": "TM SGNL",
+            "vulnerabilityName": "TeleMessage TM SGNL Hidden Functionality Vulnerability",
+            "dateAdded": "2025-05-12",
+            "shortDescription": "TeleMessage TM SGNL contains a hidden functionality vulnerability in which the archiving backend holds cleartext copies of messages from TM SGNL application users.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-06-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Apply mitigations per vendor instructions. Absent mitigating instructions from the vendor, discontinue use of the product. ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-47729",
+            "cwes": [
+                "CWE-912"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-11120",
+            "vendorProject": "GeoVision",
+            "product": "Multiple Devices",
+            "vulnerabilityName": "GeoVision Devices OS Command Injection Vulnerability",
+            "dateAdded": "2025-05-07",
+            "shortDescription": "Multiple GeoVision devices contain an OS command injection vulnerability that allows a remote, unauthenticated attacker to inject and execute arbitrary system commands. The impacted products could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/dlcdn.geovision.com.tw\/TechNotice\/CyberSecurity\/Security_Advisory_IP_Device_2024-11.pdf ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-11120",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-6047",
+            "vendorProject": "GeoVision",
+            "product": "Multiple Devices",
+            "vulnerabilityName": "GeoVision Devices OS Command Injection Vulnerability",
+            "dateAdded": "2025-05-07",
+            "shortDescription": "Multiple GeoVision devices contain an OS command injection vulnerability that allows a remote, unauthenticated attacker to inject and execute arbitrary system commands. The impacted products could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/dlcdn.geovision.com.tw\/TechNotice\/CyberSecurity\/Security_Advisory_IP_Device_2024-11.pdf ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-6047",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-27363",
+            "vendorProject": "FreeType",
+            "product": "FreeType",
+            "vulnerabilityName": "FreeType Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2025-05-06",
+            "shortDescription": "FreeType contains an out-of-bounds write vulnerability when attempting to parse font subglyph structures related to TrueType GX and variable font files that may allow for arbitrary code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/source.android.com\/docs\/security\/bulletin\/2025-05-01 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-27363",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-3248",
+            "vendorProject": "Langflow",
+            "product": "Langflow",
+            "vulnerabilityName": "Langflow Missing Authentication Vulnerability",
+            "dateAdded": "2025-05-05",
+            "shortDescription": "Langflow contains a missing authentication vulnerability in the \/api\/v1\/validate\/code endpoint that allows a remote, unauthenticated attacker to execute arbitrary code via crafted HTTP requests.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source project, third-party library, or a protocol used by different products. For more information, please see: https:\/\/github.com\/advisories\/GHSA-c995-4fw3-j39m ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-3248",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-34028",
+            "vendorProject": "Commvault",
+            "product": "Command Center",
+            "vulnerabilityName": "Commvault Command Center Path Traversal Vulnerability",
+            "dateAdded": "2025-05-02",
+            "shortDescription": "Commvault Command Center contains a path traversal vulnerability that allows a remote, unauthenticated attacker to execute arbitrary code.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/documentation.commvault.com\/securityadvisories\/CV_2025_04_1.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-34028",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-58136",
+            "vendorProject": "Yiiframework",
+            "product": "Yii",
+            "vulnerabilityName": "Yiiframework Yii Improper Protection of Alternate Path Vulnerability",
+            "dateAdded": "2025-05-02",
+            "shortDescription": "Yii Framework contains an improper protection of alternate path vulnerability that may allow a remote attacker to execute arbitrary code. This vulnerability could affect other products that implement Yii, including\u2014but not limited to\u2014Craft CMS, as represented by CVE-2025-32432.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/www.yiiframework.com\/news\/709\/please-upgrade-to-yii-2-0-52 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-58136",
+            "cwes": [
+                "CWE-424"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38475",
+            "vendorProject": "Apache",
+            "product": "HTTP Server",
+            "vulnerabilityName": "Apache HTTP Server Improper Escaping of Output Vulnerability",
+            "dateAdded": "2025-05-01",
+            "shortDescription": "Apache HTTP Server contains an improper escaping of output vulnerability in mod_rewrite that allows an attacker to map URLs to filesystem locations that are permitted to be served by the server but are not intentionally\/directly reachable by any URL, resulting in code execution or source code disclosure.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/httpd.apache.org\/security\/vulnerabilities_24.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38475",
+            "cwes": [
+                "CWE-116"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-44221",
+            "vendorProject": "SonicWall",
+            "product": "SMA100 Appliances",
+            "vulnerabilityName": "SonicWall SMA100 Appliances OS Command Injection Vulnerability",
+            "dateAdded": "2025-05-01",
+            "shortDescription": "SonicWall SMA100 appliances contain an OS command injection vulnerability in the SSL-VPN management interface that allows a remote, authenticated attacker with administrative privilege to inject arbitrary commands as a 'nobody' user.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/psirt.global.sonicwall.com\/vuln-detail\/SNWLID-2023-0018 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-44221",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-31324",
+            "vendorProject": "SAP",
+            "product": "NetWeaver",
+            "vulnerabilityName": "SAP NetWeaver Unrestricted File Upload Vulnerability",
+            "dateAdded": "2025-04-29",
+            "shortDescription": "SAP NetWeaver Visual Composer Metadata Uploader contains an unrestricted file upload vulnerability that allows an unauthenticated agent to upload potentially malicious executable binaries.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-20",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/me.sap.com\/notes\/3594142 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-31324",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-1976",
+            "vendorProject": "Broadcom",
+            "product": "Brocade Fabric OS",
+            "vulnerabilityName": "Broadcom Brocade Fabric OS Code Injection Vulnerability",
+            "dateAdded": "2025-04-28",
+            "shortDescription": "Broadcom Brocade Fabric OS contains a code injection vulnerability that allows a local user with administrative privileges to execute arbitrary code with full root privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.broadcom.com\/web\/ecx\/support-content-notification\/-\/external\/content\/SecurityAdvisories\/0\/25602 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-1976",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-42599",
+            "vendorProject": "Qualitia",
+            "product": "Active! Mail",
+            "vulnerabilityName": "Qualitia Active! Mail Stack-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2025-04-28",
+            "shortDescription": "Qualitia Active! Mail contains a stack-based buffer overflow vulnerability that allows a remote, unauthenticated attacker to execute arbitrary or trigger a denial-of-service via a specially crafted request.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.qualitia.com\/jp\/news\/2025\/04\/18_1030.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-42599",
+            "cwes": [
+                "CWE-121"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-3928",
+            "vendorProject": "Commvault",
+            "product": "Web Server",
+            "vulnerabilityName": "Commvault Web Server Unspecified Vulnerability",
+            "dateAdded": "2025-04-28",
+            "shortDescription": "Commvault Web Server contains an unspecified vulnerability that allows a remote, authenticated attacker to create and execute webshells.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/documentation.commvault.com\/securityadvisories\/CV_2025_03_1.html;   https:\/\/www.commvault.com\/blogs\/notice-security-advisory-update;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-3928      ",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2025-24054",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows NTLM Hash Disclosure Spoofing Vulnerability",
+            "dateAdded": "2025-04-17",
+            "shortDescription": "Microsoft Windows NTLM contains an external control of file name or path vulnerability that allows an unauthorized attacker to perform spoofing over a network.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2025-24054 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24054",
+            "cwes": [
+                "CWE-73"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-31201",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Arbitrary Read and Write Vulnerability",
+            "dateAdded": "2025-04-17",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and other Apple products contain an arbitrary read and write vulnerability that allows an attacker to bypass Pointer Authentication.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/122282 ; https:\/\/support.apple.com\/en-us\/122400 ; https:\/\/support.apple.com\/en-us\/122401 ; https:\/\/support.apple.com\/en-us\/122402 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-31201",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2025-31200",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Memory Corruption Vulnerability",
+            "dateAdded": "2025-04-17",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and other Apple products contain a memory corruption vulnerability that allows for code execution when processing an audio stream in a maliciously crafted media file.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/122282 ; https:\/\/support.apple.com\/en-us\/122400 ; https:\/\/support.apple.com\/en-us\/122401 ; https:\/\/support.apple.com\/en-us\/122402 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-31200",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-20035",
+            "vendorProject": "SonicWall",
+            "product": "SMA100 Appliances",
+            "vulnerabilityName": "SonicWall SMA100 Appliances OS Command Injection Vulnerability",
+            "dateAdded": "2025-04-16",
+            "shortDescription": "SonicWall SMA100 appliances contain an OS command injection vulnerability in the management interface that allows a remote authenticated attacker to inject arbitrary commands as a 'nobody' user, which could potentially lead to code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-05-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/psirt.global.sonicwall.com\/vuln-detail\/SNWLID-2021-0022 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-20035",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-53150",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Out-of-Bounds Read Vulnerability",
+            "dateAdded": "2025-04-09",
+            "shortDescription": "Linux Kernel contains an out-of-bounds read vulnerability in the USB-audio driver that allows a local, privileged attacker to obtain potentially sensitive information.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/lore.kernel.org\/linux-cve-announce\/2024122427-CVE-2024-53150-3a7d@gregkh\/ ; https:\/\/source.android.com\/docs\/security\/bulletin\/2025-04-01 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-53150",
+            "cwes": [
+                "CWE-125"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-53197",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Out-of-Bounds Access Vulnerability",
+            "dateAdded": "2025-04-09",
+            "shortDescription": "Linux Kernel contains an out-of-bounds access vulnerability in the USB-audio driver that allows an attacker with physical access to the system to use a malicious USB device to potentially manipulate system memory, escalate privileges, or execute arbitrary code.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/lore.kernel.org\/linux-cve-announce\/2024122725-CVE-2024-53197-6aef@gregkh\/ ; https:\/\/source.android.com\/docs\/security\/bulletin\/2025-04-01 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-53197",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-29824",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Common Log File System (CLFS) Driver Use-After-Free Vulnerability",
+            "dateAdded": "2025-04-08",
+            "shortDescription": "Microsoft Windows Common Log File System (CLFS) Driver contains a use-after-free vulnerability that allows an authorized attacker to elevate privileges locally.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-29",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-29824 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-29824",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-30406",
+            "vendorProject": "Gladinet",
+            "product": "CentreStack",
+            "vulnerabilityName": "Gladinet CentreStack and Triofox Use of Hard-coded Cryptographic Key Vulnerability",
+            "dateAdded": "2025-04-08",
+            "shortDescription": "Gladinet CentreStack and Triofox contains a use of hard-coded cryptographic key vulnerability in the way that the application manages keys used for ViewState integrity verification. Successful exploitation allows an attacker to forge ViewState payloads for server-side deserialization, allowing for remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/gladinetsupport.s3.us-east-1.amazonaws.com\/gladinet\/securityadvisory-cve-2005.pdf ; https:\/\/gladinetsupport.s3.us-east-1.amazonaws.com\/gladinet\/securityadvisory-cve-2025-triofox.pdf ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-30406",
+            "cwes": [
+                "CWE-321"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-31161",
+            "vendorProject": "CrushFTP",
+            "product": "CrushFTP",
+            "vulnerabilityName": "CrushFTP Authentication Bypass Vulnerability",
+            "dateAdded": "2025-04-07",
+            "shortDescription": "CrushFTP contains an authentication bypass vulnerability in the HTTP authorization header that allows a remote unauthenticated attacker to authenticate to any known or guessable user account (e.g., crushadmin), potentially leading to a full compromise. ",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-28",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.crushftp.com\/crush11wiki\/Wiki.jsp?page=Update ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-31161",
+            "cwes": [
+                "CWE-305"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-22457",
+            "vendorProject": "Ivanti",
+            "product": "Connect Secure, Policy Secure, and ZTA Gateways",
+            "vulnerabilityName": "Ivanti Connect Secure, Policy Secure, and ZTA Gateways Stack-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2025-04-04",
+            "shortDescription": "Ivanti Connect Secure, Policy Secure, and ZTA Gateways contains a stack-based buffer overflow vulnerability that allows a remote unauthenticated attacker to achieve remote code execution. ",
+            "requiredAction": "Apply mitigations as set forth in the CISA instructions linked below.",
+            "dueDate": "2025-04-11",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "CISA Mitigation Instructions: https:\/\/www.cisa.gov\/cisa-mitigation-instructions-cve-2025-22457 ; Additional References: https:\/\/forums.ivanti.com\/s\/article\/April-Security-Advisory-Ivanti-Connect-Secure-Policy-Secure-ZTA-Gateways-CVE-2025-22457 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-22457",
+            "cwes": [
+                "CWE-121"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24813",
+            "vendorProject": "Apache",
+            "product": "Tomcat",
+            "vulnerabilityName": "Apache Tomcat Path Equivalence Vulnerability",
+            "dateAdded": "2025-04-01",
+            "shortDescription": "Apache Tomcat contains a path equivalence vulnerability that allows a remote attacker to execute code, disclose information, or inject malicious content via a partial PUT request.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/lists.apache.org\/thread\/j5fkjv2k477os90nczf2v9l61fb0kkgq ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24813",
+            "cwes": [
+                "CWE-44",
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-20439",
+            "vendorProject": "Cisco",
+            "product": "Smart Licensing Utility",
+            "vulnerabilityName": "Cisco Smart Licensing Utility Static Credential Vulnerability",
+            "dateAdded": "2025-03-31",
+            "shortDescription": "Cisco Smart Licensing Utility contains a static credential vulnerability that allows an unauthenticated, remote attacker to log in to an affected system and gain administrative credentials.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-cslu-7gHMzWmw ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-20439",
+            "cwes": [
+                "CWE-912"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-2783",
+            "vendorProject": "Google",
+            "product": "Chromium Mojo",
+            "vulnerabilityName": "Google Chromium Mojo Sandbox Escape Vulnerability",
+            "dateAdded": "2025-03-27",
+            "shortDescription": "Google Chromium Mojo on Windows contains a sandbox escape vulnerability caused by a logic error, which results from an incorrect handle being provided in unspecified circumstances. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2025\/03\/stable-channel-update-for-desktop_25.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-2783",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-9875",
+            "vendorProject": "Sitecore",
+            "product": "CMS and Experience Platform (XP)",
+            "vulnerabilityName": "Sitecore CMS and Experience Platform (XP) Deserialization Vulnerability",
+            "dateAdded": "2025-03-26",
+            "shortDescription": "Sitecore CMS and Experience Platform (XP) contain a deserialization vulnerability in the Sitecore.Security.AntiCSRF module that allows an authenticated attacker to execute arbitrary code by sending a serialized .NET object in the HTTP POST parameter __CSRFTOKEN.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.sitecore.com\/kb?id=kb_article_view&sysparm_article=KB0038556 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-9875",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-9874",
+            "vendorProject": "Sitecore",
+            "product": "CMS and Experience Platform (XP)",
+            "vulnerabilityName": "Sitecore CMS and Experience Platform (XP) Deserialization Vulnerability",
+            "dateAdded": "2025-03-26",
+            "shortDescription": "Sitecore CMS and Experience Platform (XP) contain a deserialization vulnerability in the Sitecore.Security.AntiCSRF module that allows an unauthenticated attacker to execute arbitrary code by sending a serialized .NET object in the HTTP POST parameter __CSRFTOKEN.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.sitecore.com\/kb?id=kb_article_view&sysparm_article=KB0334035 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-9874",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-30154",
+            "vendorProject": "reviewdog",
+            "product": "action-setup GitHub Action",
+            "vulnerabilityName": "reviewdog\/action-setup GitHub Action Embedded Malicious Code Vulnerability",
+            "dateAdded": "2025-03-24",
+            "shortDescription": "reviewdog action-setup GitHub Action contains an embedded malicious code vulnerability that dumps exposed secrets to Github Actions Workflow Logs.",
+            "requiredAction": "Apply mitigations as set forth in the CISA instructions linked below. Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source project, third-party library, or a protocol used by different products. For more information, please see: CISA Mitigation Instructions: https:\/\/www.cisa.gov\/news-events\/alerts\/2025\/03\/18\/supply-chain-compromise-third-party-tj-actionschanged-files-cve-2025-30066-and-reviewdogaction ; Additional References: https:\/\/github.com\/reviewdog\/reviewdog\/security\/advisories\/GHSA-qmg3-hpqr-gqvc ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-30154",
+            "cwes": [
+                "CWE-506"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12637",
+            "vendorProject": "SAP",
+            "product": "NetWeaver",
+            "vulnerabilityName": "SAP NetWeaver Directory Traversal Vulnerability",
+            "dateAdded": "2025-03-19",
+            "shortDescription": "SAP NetWeaver Application Server (AS) Java contains a directory traversal vulnerability in scheduler\/ui\/js\/ffffffffbca41eb4\/UIUtilJavaScriptJS that allows a remote attacker to read arbitrary files via a .. (dot dot) in the query string.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "SAP users must have an account to log in and access the patch: https:\/\/me.sap.com\/notes\/3476549 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12637",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-48248",
+            "vendorProject": "NAKIVO",
+            "product": "Backup and Replication",
+            "vulnerabilityName": "NAKIVO Backup and Replication Absolute Path Traversal Vulnerability",
+            "dateAdded": "2025-03-19",
+            "shortDescription": "NAKIVO Backup and Replication contains an absolute path traversal vulnerability that enables an attacker to read arbitrary files.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/helpcenter.nakivo.com\/Release-Notes\/Content\/Release-Notes.htm ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-48248",
+            "cwes": [
+                "CWE-36"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-1316",
+            "vendorProject": "Edimax",
+            "product": "IC-7100 IP Camera",
+            "vulnerabilityName": "Edimax IC-7100 IP Camera OS Command Injection Vulnerability",
+            "dateAdded": "2025-03-19",
+            "shortDescription": "Edimax IC-7100 IP camera contains an OS command injection vulnerability due to improper input sanitization that allows an attacker to achieve remote code execution via specially crafted requests. The impacted product could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.edimax.com\/edimax\/post\/post\/data\/edimax\/global\/press_releases\/4801\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-1316",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-30066",
+            "vendorProject": "tj-actions",
+            "product": "changed-files GitHub Action",
+            "vulnerabilityName": "tj-actions\/changed-files GitHub Action Embedded Malicious Code Vulnerability",
+            "dateAdded": "2025-03-18",
+            "shortDescription": "tj-actions\/changed-files GitHub Action contains an embedded malicious code vulnerability that allows a remote attacker to discover secrets by reading Github Actions Workflow Logs. These secrets may include, but are not limited to, valid AWS access keys, GitHub personal access tokens (PATs), npm tokens, and private RSA keys.",
+            "requiredAction": "Apply mitigations as set forth in the CISA instructions linked below. Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source project, third-party library, or a protocol used by different products. For more information, please see: CISA Mitigation Instructions: https:\/\/www.cisa.gov\/news-events\/alerts\/2025\/03\/18\/supply-chain-compromise-third-party-tj-actionschanged-files-cve-2025-30066-and-reviewdogaction ; Additional References: https:\/\/github.com\/tj-actions\/changed-files\/blob\/45fb12d7a8bedb4da42342e52fe054c6c2c3fd73\/README.md?plain=1#L20-L28 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-30066",
+            "cwes": [
+                "CWE-506"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24472",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS and FortiProxy",
+            "vulnerabilityName": "Fortinet FortiOS and FortiProxy Authentication Bypass Vulnerability",
+            "dateAdded": "2025-03-18",
+            "shortDescription": " Fortinet FortiOS and FortiProxy contain an authentication bypass vulnerability that allows a remote attacker to gain super-admin privileges via crafted CSF proxy requests.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-08",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/fortiguard.fortinet.com\/psirt\/FG-IR-24-535 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24472",
+            "cwes": [
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-21590",
+            "vendorProject": "Juniper",
+            "product": "Junos OS",
+            "vulnerabilityName": "Juniper Junos OS Improper Isolation or Compartmentalization Vulnerability",
+            "dateAdded": "2025-03-13",
+            "shortDescription": "Juniper Junos OS contains an improper isolation or compartmentalization vulnerability. This vulnerability could allows a local attacker with high privileges to inject arbitrary code.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportportal.juniper.net\/s\/article\/2025-03-Out-of-Cycle-Security-Bulletin-Junos-OS-A-local-attacker-with-shell-access-can-execute-arbitrary-code-CVE-2025-21590?language=en_US ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-21590",
+            "cwes": [
+                "CWE-653"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24201",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2025-03-13",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and other Apple products contain an out-of-bounds write vulnerability in WebKit that may allow maliciously crafted web content to break out of Web Content sandbox. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/122281 ; https:\/\/support.apple.com\/en-us\/122283 ; https:\/\/support.apple.com\/en-us\/122284 ; https:\/\/support.apple.com\/en-us\/122285 ; ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24201",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24993",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows NTFS Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2025-03-11",
+            "shortDescription": "Microsoft Windows New Technology File System (NTFS) contains a heap-based buffer overflow vulnerability that allows an unauthorized attacker to execute code locally.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-24993 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24993",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24991",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows NTFS Out-Of-Bounds Read Vulnerability",
+            "dateAdded": "2025-03-11",
+            "shortDescription": "Microsoft Windows New Technology File System (NTFS) contains an out-of-bounds read vulnerability that allows an authorized attacker to disclose information locally.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-24991 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24991",
+            "cwes": [
+                "CWE-125"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24985",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Fast FAT File System Driver Integer Overflow Vulnerability",
+            "dateAdded": "2025-03-11",
+            "shortDescription": "Microsoft Windows Fast FAT File System Driver contains an integer overflow or wraparound vulnerability that allows an unauthorized attacker to execute code locally.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-24985 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24985",
+            "cwes": [
+                "CWE-190",
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24984",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows NTFS Information Disclosure Vulnerability",
+            "dateAdded": "2025-03-11",
+            "shortDescription": "Microsoft Windows New Technology File System (NTFS) contains an insertion of sensitive Information into log file vulnerability that allows an unauthorized attacker to disclose information with a physical attack. An attacker who successfully exploited this vulnerability could potentially read portions of heap memory.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-24984 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24984",
+            "cwes": [
+                "CWE-532"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24983",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Win32k Use-After-Free Vulnerability",
+            "dateAdded": "2025-03-11",
+            "shortDescription": "Microsoft Windows Win32 Kernel Subsystem contains a use-after-free vulnerability that allows an authorized attacker to elevate privileges locally.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-24983 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24983",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-26633",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Management Console (MMC) Improper Neutralization Vulnerability",
+            "dateAdded": "2025-03-11",
+            "shortDescription": "Microsoft Windows Management Console (MMC) contains an improper neutralization vulnerability that allows an unauthorized attacker to bypass a security feature locally.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-04-01",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-26633 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-26633",
+            "cwes": [
+                "CWE-707"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-13161",
+            "vendorProject": "Ivanti",
+            "product": "Endpoint Manager (EPM)",
+            "vulnerabilityName": "Ivanti Endpoint Manager (EPM) Absolute Path Traversal Vulnerability",
+            "dateAdded": "2025-03-10",
+            "shortDescription": "Ivanti Endpoint Manager (EPM) contains an absolute path traversal vulnerability that allows a remote unauthenticated attacker to leak sensitive information.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/Security-Advisory-EPM-January-2025-for-EPM-2024-and-EPM-2022-SU6?language=en_US ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-13161",
+            "cwes": [
+                "CWE-36"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-13160",
+            "vendorProject": "Ivanti",
+            "product": "Endpoint Manager (EPM)",
+            "vulnerabilityName": "Ivanti Endpoint Manager (EPM) Absolute Path Traversal Vulnerability",
+            "dateAdded": "2025-03-10",
+            "shortDescription": "Ivanti Endpoint Manager (EPM) contains an absolute path traversal vulnerability that allows a remote unauthenticated attacker to leak sensitive information.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/Security-Advisory-EPM-January-2025-for-EPM-2024-and-EPM-2022-SU6?language=en_US ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-13160",
+            "cwes": [
+                "CWE-36"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-13159",
+            "vendorProject": "Ivanti",
+            "product": "Endpoint Manager (EPM)",
+            "vulnerabilityName": "Ivanti Endpoint Manager (EPM) Absolute Path Traversal Vulnerability",
+            "dateAdded": "2025-03-10",
+            "shortDescription": "Ivanti Endpoint Manager (EPM) contains an absolute path traversal vulnerability that allows a remote unauthenticated attacker to leak sensitive information.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/Security-Advisory-EPM-January-2025-for-EPM-2024-and-EPM-2022-SU6?language=en_US ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-13159",
+            "cwes": [
+                "CWE-36"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-57968",
+            "vendorProject": "Advantive",
+            "product": "VeraCore",
+            "vulnerabilityName": "Advantive VeraCore Unrestricted File Upload Vulnerability",
+            "dateAdded": "2025-03-10",
+            "shortDescription": "Advantive VeraCore contains an unrestricted file upload vulnerability that allows a remote unauthenticated attacker to upload files to unintended folders via upload.apsx.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/advantive.my.site.com\/support\/s\/article\/VeraCore-Release-Notes-2024-4-2-1 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-57968",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-25181",
+            "vendorProject": "Advantive",
+            "product": "VeraCore",
+            "vulnerabilityName": " Advantive VeraCore SQL Injection Vulnerability",
+            "dateAdded": "2025-03-10",
+            "shortDescription": "Advantive VeraCore contains a SQL injection vulnerability in timeoutWarning.asp that allows a remote attacker to execute arbitrary SQL commands via the PmSess1 parameter.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/advantive.my.site.com\/support\/s\/article\/Veracore-Release-Notes-2025-1-1-3 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-25181",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-22226",
+            "vendorProject": "VMware",
+            "product": "ESXi, Workstation, and Fusion",
+            "vulnerabilityName": "VMware ESXi, Workstation, and Fusion Information Disclosure Vulnerability",
+            "dateAdded": "2025-03-04",
+            "shortDescription": "VMware ESXi, Workstation, and Fusion contain an information disclosure vulnerability due to an out-of-bounds read in HGFS. Successful exploitation allows an attacker with administrative privileges to a virtual machine to leak memory from the vmx process.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.broadcom.com\/web\/ecx\/support-content-notification\/-\/external\/content\/SecurityAdvisories\/0\/25390 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-22226",
+            "cwes": [
+                "CWE-125"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-22225",
+            "vendorProject": "VMware",
+            "product": "ESXi",
+            "vulnerabilityName": "VMware ESXi Arbitrary Write Vulnerability",
+            "dateAdded": "2025-03-04",
+            "shortDescription": "VMware ESXi contains an arbitrary write vulnerability. Successful exploitation allows an attacker with privileges within the VMX process to trigger an arbitrary kernel write leading to an escape of the sandbox.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.broadcom.com\/web\/ecx\/support-content-notification\/-\/external\/content\/SecurityAdvisories\/0\/25390 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-22225",
+            "cwes": [
+                "CWE-123"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-22224",
+            "vendorProject": "VMware",
+            "product": "ESXi and Workstation",
+            "vulnerabilityName": "VMware ESXi and Workstation TOCTOU Race Condition Vulnerability",
+            "dateAdded": "2025-03-04",
+            "shortDescription": "VMware ESXi and Workstation contain a time-of-check time-of-use (TOCTOU) race condition vulnerability that leads to an out-of-bounds write. Successful exploitation enables an attacker with local administrative privileges on a virtual machine to execute code as the virtual machine's VMX process running on the host.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.broadcom.com\/web\/ecx\/support-content-notification\/-\/external\/content\/SecurityAdvisories\/0\/25390 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-22224",
+            "cwes": [
+                "CWE-367"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-50302",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Use of Uninitialized Resource Vulnerability",
+            "dateAdded": "2025-03-04",
+            "shortDescription": "The Linux kernel contains a use of uninitialized resource vulnerability that allows an attacker to leak kernel memory via a specially crafted HID report.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/lore.kernel.org\/linux-cve-announce\/2024111908-CVE-2024-50302-f677@gregkh\/ ; https:\/\/source.android.com\/docs\/security\/bulletin\/2025-03-01 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-50302",
+            "cwes": [
+                "CWE-908"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-4885",
+            "vendorProject": "Progress",
+            "product": "WhatsUp Gold",
+            "vulnerabilityName": "Progress WhatsUp Gold Path Traversal Vulnerability",
+            "dateAdded": "2025-03-03",
+            "shortDescription": "Progress WhatsUp Gold contains a path traversal vulnerability that allows an unauthenticated attacker to achieve remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/community.progress.com\/s\/article\/WhatsUp-Gold-Security-Bulletin-June-2024 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-4885",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-8639",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Win32k Improper Resource Shutdown or Release Vulnerability",
+            "dateAdded": "2025-03-03",
+            "shortDescription": "Microsoft Windows Win32k contains an improper resource shutdown or release vulnerability that allows for local, authenticated privilege escalation. An attacker who successfully exploited this vulnerability could run arbitrary code in kernel mode.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-24",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/advisory\/CVE-2018-8639 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8639",
+            "cwes": [
+                "CWE-404"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-43769",
+            "vendorProject": "Hitachi Vantara",
+            "product": "Pentaho Business Analytics (BA) Server",
+            "vulnerabilityName": "Hitachi Vantara Pentaho BA Server Special Element Injection Vulnerability",
+            "dateAdded": "2025-03-03",
+            "shortDescription": "Hitachi Vantara Pentaho BA Server contains a special element injection vulnerability that allows an attacker to inject Spring templates into properties files, allowing for arbitrary command execution.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.pentaho.com\/hc\/en-us\/articles\/14455561548301--Resolved-Pentaho-BA-Server-Failure-to-Sanitize-Special-Elements-into-a-Different-Plane-Special-Element-Injection-Versions-before-9-4-0-1-and-9-3-0-2-including-8-3-x-Impacted-CVE-2022-43769 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-43769",
+            "cwes": [
+                "CWE-74"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-43939",
+            "vendorProject": "Hitachi Vantara",
+            "product": "Pentaho Business Analytics (BA) Server",
+            "vulnerabilityName": "Hitachi Vantara Pentaho BA Server Authorization Bypass Vulnerability",
+            "dateAdded": "2025-03-03",
+            "shortDescription": "Hitachi Vantara Pentaho BA Server contains a use of non-canonical URL paths for authorization decisions vulnerability that enables an attacker to bypass authorization.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.pentaho.com\/hc\/en-us\/articles\/14455394120333--Resolved-Pentaho-BA-Server-Use-of-Non-Canonical-URL-Paths-for-Authorization-Decisions-Versions-before-9-4-0-1-and-9-3-0-2-including-8-3-x-Impacted-CVE-2022-43939- ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-43939",
+            "cwes": [
+                "CWE-647"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-20118",
+            "vendorProject": "Cisco",
+            "product": "Small Business RV Series Routers",
+            "vulnerabilityName": "Cisco Small Business RV Series Routers Command Injection Vulnerability",
+            "dateAdded": "2025-03-03",
+            "shortDescription": "Multiple Cisco Small Business RV Series Routers contains a command injection vulnerability in the web-based management interface. Successful exploitation could allow an authenticated, remote attacker to gain root-level privileges and access unauthorized data.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-sbr042-multi-vuln-ej76Pke5 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-20118",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-34192",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2025-02-25",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) contains a cross-site scripting (XSS) vulnerability that allows a remote authenticated attacker to execute arbitrary code via a crafted script to the \/h\/autoSaveDraft function.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/wiki.zimbra.com\/wiki\/Zimbra_Security_Advisories ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-34192",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-49035",
+            "vendorProject": "Microsoft",
+            "product": "Partner Center",
+            "vulnerabilityName": "Microsoft Partner Center Improper Access Control Vulnerability",
+            "dateAdded": "2025-02-25",
+            "shortDescription": "Microsoft Partner Center contains an improper access control vulnerability that allows an attacker to escalate privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-49035 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-49035",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-20953",
+            "vendorProject": "Oracle",
+            "product": "Agile Product Lifecycle Management (PLM)",
+            "vulnerabilityName": "Oracle Agile Product Lifecycle Management (PLM) Deserialization Vulnerability",
+            "dateAdded": "2025-02-24",
+            "shortDescription": "Oracle Agile Product Lifecycle Management (PLM) contains a deserialization vulnerability that allows a low-privileged attacker with network access via HTTP to compromise the system.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/cpujan2024.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-20953",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-3066",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Deserialization Vulnerability",
+            "dateAdded": "2025-02-24",
+            "shortDescription": "Adobe ColdFusion contains a deserialization vulnerability in the Apache BlazeDS library that allows for arbitrary code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/helpx.adobe.com\/security\/products\/coldfusion\/apsb17-14.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-3066",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24989",
+            "vendorProject": "Microsoft",
+            "product": "Power Pages",
+            "vulnerabilityName": "Microsoft Power Pages Improper Access Control Vulnerability",
+            "dateAdded": "2025-02-21",
+            "shortDescription": "Microsoft Power Pages contains an improper access control vulnerability that allows an unauthorized attacker to elevate privileges over a network potentially bypassing the user registration control.",
+            "requiredAction": "Apply mitigations per vendor instructions, follow BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/advisory\/CVE-2025-24989 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24989",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-0111",
+            "vendorProject": "Palo Alto Networks",
+            "product": "PAN-OS",
+            "vulnerabilityName": "Palo Alto Networks PAN-OS File Read Vulnerability",
+            "dateAdded": "2025-02-20",
+            "shortDescription": "Palo Alto Networks PAN-OS contains an external control of file name or path vulnerability. Successful exploitation enables an authenticated attacker with network access to the management web interface to read files on the PAN-OS filesystem that are readable by the \u201cnobody\u201d user.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.paloaltonetworks.com\/CVE-2025-0111 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-0111",
+            "cwes": [
+                "CWE-73"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-23209",
+            "vendorProject": "Craft CMS",
+            "product": "Craft CMS",
+            "vulnerabilityName": "Craft CMS Code Injection Vulnerability",
+            "dateAdded": "2025-02-20",
+            "shortDescription": "Craft CMS contains a code injection vulnerability caused by improper validation of the database backup path, ultimately enabling remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/craftcms\/cms\/security\/advisories\/GHSA-x684-96hh-833x ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-23209",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-0108",
+            "vendorProject": "Palo Alto Networks",
+            "product": "PAN-OS",
+            "vulnerabilityName": "Palo Alto Networks PAN-OS Authentication Bypass Vulnerability",
+            "dateAdded": "2025-02-18",
+            "shortDescription": "Palo Alto Networks PAN-OS contains an authentication bypass vulnerability in its management web interface. This vulnerability allows an unauthenticated attacker with network access to the management web interface to bypass the authentication normally required and invoke certain PHP scripts.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.paloaltonetworks.com\/CVE-2025-0108 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-0108",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-53704",
+            "vendorProject": "SonicWall",
+            "product": "SonicOS",
+            "vulnerabilityName": "SonicWall SonicOS SSLVPN Improper Authentication Vulnerability",
+            "dateAdded": "2025-02-18",
+            "shortDescription": "SonicWall SonicOS contains an improper authentication vulnerability in the SSLVPN authentication mechanism that allows a remote attacker to bypass authentication.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-11",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/psirt.global.sonicwall.com\/vuln-detail\/SNWLID-2025-0003 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-53704",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-57727",
+            "vendorProject": "SimpleHelp ",
+            "product": "SimpleHelp",
+            "vulnerabilityName": "SimpleHelp Path Traversal Vulnerability",
+            "dateAdded": "2025-02-13",
+            "shortDescription": "SimpleHelp remote support software contains multiple path traversal vulnerabilities that allow unauthenticated remote attackers to download arbitrary files from the SimpleHelp host via crafted HTTP requests. These files may include server configuration files and hashed user passwords.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-06",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/simple-help.com\/kb---security-vulnerabilities-01-2025 ; Additional CISA Mitigation Instructions: https:\/\/www.cisa.gov\/news-events\/cybersecurity-advisories\/aa25-163a ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-57727",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24200",
+            "vendorProject": "Apple",
+            "product": "iOS and iPadOS",
+            "vulnerabilityName": "Apple iOS and iPadOS Incorrect Authorization Vulnerability",
+            "dateAdded": "2025-02-12",
+            "shortDescription": "Apple iOS and iPadOS contains an incorrect authorization vulnerability that allows a physical attacker to disable USB Restricted Mode on a locked device.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/122173 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24200",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-41710",
+            "vendorProject": "Mitel",
+            "product": "SIP Phones",
+            "vulnerabilityName": "Mitel SIP Phones Argument Injection Vulnerability",
+            "dateAdded": "2025-02-12",
+            "shortDescription": "Mitel 6800 Series, 6900 Series, and 6900w Series SIP Phones, including the 6970 Conference Unit, contain an argument injection vulnerability due to insufficient parameter sanitization during the boot process. Successful exploitation may allow an attacker to execute arbitrary commands within the context of the system.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.mitel.com\/-\/media\/mitel\/file\/pdf\/support\/security-advisories\/security-bulletin_24-0019-001-v2.pdf ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-41710",
+            "cwes": [
+                "CWE-88"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-40891",
+            "vendorProject": "Zyxel",
+            "product": "DSL CPE Devices",
+            "vulnerabilityName": "Zyxel DSL CPE OS Command Injection Vulnerability",
+            "dateAdded": "2025-02-11",
+            "shortDescription": "Multiple Zyxel DSL CPE devices contain a post-authentication command injection vulnerability in the management commands that could allow an authenticated attacker to execute OS commands via Telnet.",
+            "requiredAction": "The impacted product could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization if a current mitigation is unavailable.",
+            "dueDate": "2025-03-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.zyxel.com\/global\/en\/support\/security-advisories\/zyxel-security-advisory-for-command-injection-and-insecure-default-credentials-vulnerabilities-in-certain-legacy-dsl-cpe-02-04-2025 ; https:\/\/www.zyxel.com\/service-provider\/global\/en\/security-advisories\/zyxel-security-advisory-command-injection-insecure-in-certain-legacy-dsl-cpe-02-04-2025 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-40891",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-40890",
+            "vendorProject": "Zyxel",
+            "product": "DSL CPE Devices",
+            "vulnerabilityName": "Zyxel DSL CPE OS Command Injection Vulnerability",
+            "dateAdded": "2025-02-11",
+            "shortDescription": "Multiple Zyxel DSL CPE devices contain a post-authentication command injection vulnerability in the CGI program that could allow an authenticated attacker to execute OS commands via a crafted HTTP request.",
+            "requiredAction": "The impacted product could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization if a current mitigation is unavailable.",
+            "dueDate": "2025-03-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.zyxel.com\/global\/en\/support\/security-advisories\/zyxel-security-advisory-for-command-injection-and-insecure-default-credentials-vulnerabilities-in-certain-legacy-dsl-cpe-02-04-2025 ; https:\/\/www.zyxel.com\/service-provider\/global\/en\/security-advisories\/zyxel-security-advisory-command-injection-insecure-in-certain-legacy-dsl-cpe-02-04-2025 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-40890",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-21418",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Ancillary Function Driver for WinSock Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2025-02-11",
+            "shortDescription": "Microsoft Windows Ancillary Function Driver for WinSock contains a heap-based buffer overflow vulnerability that allows for privilege escalation, enabling a local attacker to gain SYSTEM privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2025-21418 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-21418",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-21391",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Storage Link Following Vulnerability",
+            "dateAdded": "2025-02-11",
+            "shortDescription": "Microsoft Windows Storage contains a link following vulnerability that could allow for privilege escalation. This vulnerability could allow an attacker to delete data including data that results in the service being unavailable.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-03-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2025-21391 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-21391",
+            "cwes": [
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-0994",
+            "vendorProject": "Trimble",
+            "product": "Cityworks",
+            "vulnerabilityName": "Trimble Cityworks Deserialization Vulnerability",
+            "dateAdded": "2025-02-07",
+            "shortDescription": "Trimble Cityworks contains a deserialization vulnerability. This could allow an authenticated user to perform a remote code execution attack against a customer's Microsoft Internet Information Services (IIS) web server.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/learn.assetlifecycle.trimble.com\/i\/1532182-cityworks-customer-communication-2025-02-05-docx\/0?; https:\/\/www.cisa.gov\/news-events\/ics-advisories\/icsa-25-037-04 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-0994",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-15069",
+            "vendorProject": "Sophos",
+            "product": "XG Firewall",
+            "vulnerabilityName": "Sophos XG Firewall Buffer Overflow Vulnerability",
+            "dateAdded": "2025-02-06",
+            "shortDescription": "Sophos XG Firewall contains a buffer overflow vulnerability that allows for remote code execution via the \"HTTP\/S bookmark\" feature.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/community.sophos.com\/b\/security-blog\/posts\/advisory-buffer-overflow-vulnerability-in-user-portal ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-15069",
+            "cwes": [
+                "CWE-120"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-29574",
+            "vendorProject": "Sophos",
+            "product": "CyberoamOS",
+            "vulnerabilityName": "CyberoamOS (CROS) SQL Injection Vulnerability",
+            "dateAdded": "2025-02-06",
+            "shortDescription": "CyberoamOS (CROS) contains a SQL injection vulnerability in the WebAdmin that allows an unauthenticated attacker to execute arbitrary SQL statements remotely.",
+            "requiredAction": "The impacted product is end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue utilization of the product.",
+            "dueDate": "2025-02-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.sophos.com\/support\/s\/article\/KBA-000007526 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-29574",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-21413",
+            "vendorProject": "Microsoft",
+            "product": "Office Outlook",
+            "vulnerabilityName": "Microsoft Outlook Improper Input Validation Vulnerability",
+            "dateAdded": "2025-02-06",
+            "shortDescription": "Microsoft Outlook contains an improper input validation vulnerability that allows for remote code execution. Successful exploitation of this vulnerability would allow an attacker to bypass the Office Protected View and open in editing mode rather than protected mode.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-21413 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-21413",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-23748",
+            "vendorProject": "Audinate",
+            "product": "Dante Discovery",
+            "vulnerabilityName": "Dante Discovery Process Control Vulnerability",
+            "dateAdded": "2025-02-06",
+            "shortDescription": "Dante Discovery contains a process control vulnerability in mDNSResponder.exe that all allows for a DLL sideloading attack. A local attacker can leverage this vulnerability in the Dante Application Library to execute arbitrary code.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.getdante.com\/support\/faq\/audinate-response-to-dante-discovery-mdnsresponder-exe-security-issue-cve-2022-23748\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-23748",
+            "cwes": [
+                "CWE-114"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-0411",
+            "vendorProject": "7-Zip",
+            "product": "7-Zip",
+            "vulnerabilityName": "7-Zip Mark of the Web Bypass Vulnerability",
+            "dateAdded": "2025-02-06",
+            "shortDescription": "7-Zip contains a protection mechanism failure vulnerability that allows remote attackers to bypass the Mark-of-the-Web security feature to execute arbitrary code in the context of the current user.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.7-zip.org\/history.txt ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-0411",
+            "cwes": [
+                "CWE-693"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-53104",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2025-02-05",
+            "shortDescription": "Linux kernel contains an out-of-bounds write vulnerability in the uvc_parse_streaming component of the USB Video Class (UVC) driver that could allow for physical escalation of privilege.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/lore.kernel.org\/linux-cve-announce\/2024120232-CVE-2024-53104-d781@gregkh\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-53104",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-19410",
+            "vendorProject": "Paessler",
+            "product": "PRTG Network Monitor",
+            "vulnerabilityName": "Paessler PRTG Network Monitor Local File Inclusion Vulnerability",
+            "dateAdded": "2025-02-04",
+            "shortDescription": "Paessler PRTG Network Monitor contains a local file inclusion vulnerability that allows a remote, unauthenticated attacker to create users with read-write privileges (including administrator).",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.paessler.com\/prtg\/history\/prtg-18#18.2.41.1652 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-19410",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2018-9276",
+            "vendorProject": "Paessler",
+            "product": "PRTG Network Monitor",
+            "vulnerabilityName": "Paessler PRTG Network Monitor OS Command Injection Vulnerability",
+            "dateAdded": "2025-02-04",
+            "shortDescription": "Paessler PRTG Network Monitor contains an OS command injection vulnerability that allows an attacker with administrative privileges to execute commands via the PRTG System Administrator web console.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.paessler.com\/prtg\/history\/prtg-18#18.2.39 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-9276",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-29059",
+            "vendorProject": "Microsoft",
+            "product": ".NET Framework",
+            "vulnerabilityName": "Microsoft .NET Framework Information Disclosure Vulnerability",
+            "dateAdded": "2025-02-04",
+            "shortDescription": "Microsoft .NET Framework contains an information disclosure vulnerability that exposes the ObjRef URI to an attacker, ultimately enabling remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-29059 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-29059",
+            "cwes": [
+                "CWE-209"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-45195",
+            "vendorProject": "Apache",
+            "product": "OFBiz",
+            "vulnerabilityName": "Apache OFBiz Forced Browsing Vulnerability",
+            "dateAdded": "2025-02-04",
+            "shortDescription": "Apache OFBiz contains a forced browsing vulnerability that allows a remote attacker to obtain unauthorized access.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/ofbiz.apache.org\/security.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-45195",
+            "cwes": [
+                "CWE-425"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-24085",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Use-After-Free Vulnerability",
+            "dateAdded": "2025-01-29",
+            "shortDescription": "Apple iOS, macOS, and other Apple products contain a user-after-free vulnerability that could allow a malicious application to elevate privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/122066 ; https:\/\/support.apple.com\/en-us\/122068 ; https:\/\/support.apple.com\/en-us\/122071 ; https:\/\/support.apple.com\/en-us\/122072 ; https:\/\/support.apple.com\/en-us\/122073 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-24085",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-23006",
+            "vendorProject": "SonicWall",
+            "product": "SMA1000 Appliances",
+            "vulnerabilityName": "SonicWall SMA1000 Appliances Deserialization Vulnerability",
+            "dateAdded": "2025-01-24",
+            "shortDescription": "SonicWall SMA1000 Appliance Management Console (AMC) and Central Management Console (CMC) contain a deserialization of untrusted data vulnerability, which can enable a remote, unauthenticated attacker to execute arbitrary OS commands.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/psirt.global.sonicwall.com\/vuln-detail\/SNWLID-2025-0002 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-23006",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-11023",
+            "vendorProject": "JQuery",
+            "product": "JQuery",
+            "vulnerabilityName": "JQuery Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2025-01-23",
+            "shortDescription": "JQuery contains a persistent cross-site scripting (XSS) vulnerability. When passing maliciously formed, untrusted input enclosed in HTML tags, JQuery's DOM manipulators can execute untrusted code in the context of the user's browser.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability could affect an open-source component, third-party library, protocol, or proprietary implementation that could be used by different products. For more information, please see: https:\/\/github.com\/jquery\/jquery\/security\/advisories\/GHSA-jpcq-cgw6-v4j6 ; https:\/\/blog.jquery.com\/2020\/04\/10\/jquery-3-5-0-released\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-11023",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-50603",
+            "vendorProject": "Aviatrix",
+            "product": "Controllers",
+            "vulnerabilityName": "Aviatrix Controllers OS Command Injection Vulnerability",
+            "dateAdded": "2025-01-16",
+            "shortDescription": "Aviatrix Controllers contain an OS command injection vulnerability that could allow an unauthenticated attacker to execute arbitrary code. Shell metacharacters can be sent to \/v1\/api in cloud_type for list_flightpath_destination_instances, or src_cloud_type for flightpath_connection_test.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/docs.aviatrix.com\/documentation\/latest\/release-notices\/psirt-advisories\/psirt-advisories.html?expand=true ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-50603",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-21335",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Hyper-V NT Kernel Integration VSP Use-After-Free Vulnerability",
+            "dateAdded": "2025-01-14",
+            "shortDescription": "Microsoft Windows Hyper-V NT Kernel Integration VSP contains a use-after-free vulnerability that allows a local attacker to gain SYSTEM privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-21335 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-21335",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-21334",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Hyper-V NT Kernel Integration VSP Use-After-Free Vulnerability",
+            "dateAdded": "2025-01-14",
+            "shortDescription": "Microsoft Windows Hyper-V NT Kernel Integration VSP contains a use-after-free vulnerability that allows a local attacker to gain SYSTEM privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-21334 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-21334",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-21333",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Hyper-V NT Kernel Integration VSP Heap-based Buffer Overflow Vulnerability",
+            "dateAdded": "2025-01-14",
+            "shortDescription": "Microsoft Windows Hyper-V NT Kernel Integration VSP contains a heap-based buffer overflow vulnerability that allows a local attacker to gain SYSTEM privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2025-21333 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-21333",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-55591",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS and FortiProxy",
+            "vulnerabilityName": "Fortinet FortiOS and FortiProxy Authentication Bypass Vulnerability",
+            "dateAdded": "2025-01-14",
+            "shortDescription": "Fortinet FortiOS and FortiProxy contain an authentication bypass vulnerability that may allow an unauthenticated, remote attacker to gain super-admin privileges via crafted requests to Node.js websocket module.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-01-21",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/fortiguard.fortinet.com\/psirt\/FG-IR-24-535 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-55591",
+            "cwes": [
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-48365",
+            "vendorProject": "Qlik",
+            "product": "Sense",
+            "vulnerabilityName": "Qlik Sense HTTP Tunneling Vulnerability",
+            "dateAdded": "2025-01-13",
+            "shortDescription": "Qlik Sense contains an HTTP tunneling vulnerability that allows an attacker to escalate privileges and execute HTTP requests on the backend server hosting the software.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/community.qlik.com\/t5\/Official-Support-Articles\/Critical-Security-fixes-for-Qlik-Sense-Enterprise-for-Windows\/tac-p\/2120510 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-48365",
+            "cwes": [
+                "CWE-444"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-12686",
+            "vendorProject": "BeyondTrust",
+            "product": "Privileged Remote Access (PRA) and Remote Support (RS)",
+            "vulnerabilityName": "BeyondTrust Privileged Remote Access (PRA) and Remote Support (RS) OS Command Injection Vulnerability",
+            "dateAdded": "2025-01-13",
+            "shortDescription": "BeyondTrust Privileged Remote Access (PRA) and Remote Support (RS) contain an OS command injection vulnerability that can be exploited by an attacker with existing administrative privileges to upload a malicious file. Successful exploitation of this vulnerability can allow a remote attacker to execute underlying operating system commands within the context of the site user.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-02-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.beyondtrust.com\/trust-center\/security-advisories\/bt24-11 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-12686",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2025-0282",
+            "vendorProject": "Ivanti",
+            "product": "Connect Secure, Policy Secure, and ZTA Gateways",
+            "vulnerabilityName": "Ivanti Connect Secure, Policy Secure, and ZTA Gateways Stack-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2025-01-08",
+            "shortDescription": "Ivanti Connect Secure, Policy Secure, and ZTA Gateways contain a stack-based buffer overflow which can lead to unauthenticated remote code execution.",
+            "requiredAction": "Apply mitigations as set forth in the CISA instructions linked below to include conducting hunt activities, taking remediation actions if applicable, and applying updates prior to returning a device to service.",
+            "dueDate": "2025-01-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "CISA Mitigation Instructions: https:\/\/www.cisa.gov\/cisa-mitigation-instructions-CVE-2025-0282 Additional References: https:\/\/forums.ivanti.com\/s\/article\/Security-Advisory-Ivanti-Connect-Secure-Policy-Secure-ZTA-Gateways-CVE-2025-0282-CVE-2025-0283 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2025-0282",
+            "cwes": [
+                "CWE-121"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-2883",
+            "vendorProject": "Oracle",
+            "product": "WebLogic Server",
+            "vulnerabilityName": "Oracle WebLogic Server Unspecified Vulnerability",
+            "dateAdded": "2025-01-07",
+            "shortDescription": "Oracle WebLogic Server, a product within the Fusion Middleware suite, contains an unspecified vulnerability exploitable by an unauthenticated attacker with network access via IIOP or T3.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-01-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/cpuapr2020.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-2883",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2024-55550",
+            "vendorProject": "Mitel",
+            "product": "MiCollab",
+            "vulnerabilityName": "Mitel MiCollab Path Traversal Vulnerability",
+            "dateAdded": "2025-01-07",
+            "shortDescription": "Mitel MiCollab contains a path traversal vulnerability that could allow an authenticated attacker with administrative privileges to read local files within the system due to insufficient input sanitization. This vulnerability can be chained with CVE-2024-41713, which allows an unauthenticated, remote attacker to read arbitrary files on the server.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-01-28",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.mitel.com\/support\/security-advisories\/mitel-product-security-advisory-misa-2024-0029 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-55550",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-41713",
+            "vendorProject": "Mitel",
+            "product": "MiCollab",
+            "vulnerabilityName": "Mitel MiCollab Path Traversal Vulnerability",
+            "dateAdded": "2025-01-07",
+            "shortDescription": "Mitel MiCollab contains a path traversal vulnerability that could allow an attacker to gain unauthorized and unauthenticated access. This vulnerability can be chained with CVE-2024-55550, which allows an unauthenticated, remote attacker to read arbitrary files on the server.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-01-28",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.mitel.com\/support\/security-advisories\/mitel-product-security-advisory-misa-2024-0029 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-41713 ",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-3393",
+            "vendorProject": "Palo Alto Networks",
+            "product": "PAN-OS",
+            "vulnerabilityName": "Palo Alto Networks PAN-OS Malicious DNS Packet Vulnerability",
+            "dateAdded": "2024-12-30",
+            "shortDescription": "Palo Alto Networks PAN-OS contains a vulnerability in parsing and logging malicious DNS packets in the DNS Security feature that, when exploited, allows an unauthenticated attacker to remotely reboot the firewall. Repeated attempts to trigger this condition will cause the firewall to enter maintenance mode.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-01-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.paloaltonetworks.com\/CVE-2024-3393 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-3393",
+            "cwes": [
+                "CWE-754"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-44207",
+            "vendorProject": "Acclaim Systems",
+            "product": "USAHERDS",
+            "vulnerabilityName": "Acclaim Systems USAHERDS Use of Hard-Coded Credentials Vulnerability ",
+            "dateAdded": "2024-12-23",
+            "shortDescription": "Acclaim Systems USAHERDS contains a hard-coded credentials vulnerability that could allow an attacker to achieve remote code execution on the system that runs the application. The MachineKey must be obtained via a separate vulnerability or other channel.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable. Please contact the product developer for support and vulnerability mitigation.",
+            "dueDate": "2025-01-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.acclaimsystems.com\/#contact ; https:\/\/www.tnatc.org\/#contact ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-44207",
+            "cwes": [
+                "CWE-798"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-12356",
+            "vendorProject": "BeyondTrust",
+            "product": "Privileged Remote Access (PRA) and Remote Support (RS) ",
+            "vulnerabilityName": "BeyondTrust Privileged Remote Access (PRA) and Remote Support (RS) Command Injection Vulnerability ",
+            "dateAdded": "2024-12-19",
+            "shortDescription": "BeyondTrust Privileged Remote Access (PRA) and Remote Support (RS) contain a command injection vulnerability, which can allow an unauthenticated attacker to inject commands that are run as a site user. ",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.beyondtrust.com\/trust-center\/security-advisories\/bt24-10 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-12356",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-40407",
+            "vendorProject": "Reolink",
+            "product": "RLC-410W IP Camera",
+            "vulnerabilityName": "Reolink RLC-410W IP Camera OS Command Injection Vulnerability ",
+            "dateAdded": "2024-12-18",
+            "shortDescription": "Reolink RLC-410W IP cameras contain an authenticated OS command injection vulnerability in the device network settings functionality.",
+            "requiredAction": "The impacted product could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization if a current mitigation is unavailable.",
+            "dueDate": "2025-01-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/reolink.com\/product-eol\/ ; https:\/\/reolink.com\/download-center\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-40407",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-11001",
+            "vendorProject": "Reolink",
+            "product": "Multiple IP Cameras",
+            "vulnerabilityName": "Reolink Multiple IP Cameras OS Command Injection Vulnerability",
+            "dateAdded": "2024-12-18",
+            "shortDescription": "Reolink RLC-410W, C1 Pro, C2 Pro, RLC-422W, and RLC-511W IP cameras contain an authenticated OS command injection vulnerability. This vulnerability allows an authenticated admin to use the \"TestEmail\" functionality to inject and run OS commands as root.",
+            "requiredAction": "The impacted product could be end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue product utilization if a current mitigation is unavailable.",
+            "dueDate": "2025-01-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/reolink.com\/product-eol\/ ; https:\/\/reolink.com\/download-center\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-11001",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-23227",
+            "vendorProject": "NUUO",
+            "product": "NVRmini2 Devices",
+            "vulnerabilityName": "NUUO NVRmini2 Devices Missing Authentication Vulnerability ",
+            "dateAdded": "2024-12-18",
+            "shortDescription": "NUUO NVRmini2 devices contain a missing authentication vulnerability that allows an unauthenticated attacker to upload an encrypted TAR archive, which can be abused to add arbitrary users. ",
+            "requiredAction": "The impacted product is end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue utilization of the product.",
+            "dueDate": "2025-01-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nuuo.com\/wp-content\/uploads\/2023\/03\/NUUO-EOL-letter\uff3fNVRmini-2-and-NVRsolo-series.pdf ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-23227",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-14933",
+            "vendorProject": "NUUO",
+            "product": "NVRmini Devices",
+            "vulnerabilityName": "NUUO NVRmini Devices OS Command Injection Vulnerability ",
+            "dateAdded": "2024-12-18",
+            "shortDescription": "NUUO NVRmini devices contain an OS command injection vulnerability. This vulnerability allows remote command execution via shell metacharacters in the uploaddir parameter for a writeuploaddir command.",
+            "requiredAction": "The impacted product is end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue utilization of the product.",
+            "dueDate": "2025-01-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nuuo.com\/wp-content\/uploads\/2023\/03\/NUUO-EOL-letter%EF%BC%BFNVRmini-2-and-NVRsolo-series.pdf ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-14933",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-55956",
+            "vendorProject": "Cleo",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Cleo Multiple Products Unauthenticated File Upload Vulnerability",
+            "dateAdded": "2024-12-17",
+            "shortDescription": "Cleo Harmony, VLTrader, and LexiCom, which are managed file transfer products, contain an unrestricted file upload vulnerability that could allow an unauthenticated user to import and execute arbitrary bash or PowerShell commands on the host system by leveraging the default settings of the Autorun directory.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-01-07",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/support.cleo.com\/hc\/en-us\/articles\/28408134019735-Cleo-Product-Security-Update-CVE-2024-55956 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-55956",
+            "cwes": [
+                "CWE-276"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-35250",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel-Mode Driver Untrusted Pointer Dereference Vulnerability ",
+            "dateAdded": "2024-12-16",
+            "shortDescription": "Microsoft Windows Kernel-Mode Driver contains an untrusted pointer dereference vulnerability that allows a local attacker to escalate privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-01-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-35250 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-35250",
+            "cwes": [
+                "CWE-822"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-20767",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Improper Access Control Vulnerability",
+            "dateAdded": "2024-12-16",
+            "shortDescription": "Adobe ColdFusion contains an improper access control vulnerability that could allow an attacker to access or modify restricted files via an internet-exposed admin panel.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-01-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/helpx.adobe.com\/security\/products\/coldfusion\/apsb24-14.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-20767",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-50623",
+            "vendorProject": "Cleo",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Cleo Multiple Products Unrestricted File Upload Vulnerability",
+            "dateAdded": "2024-12-13",
+            "shortDescription": "Cleo Harmony, VLTrader, and LexiCom, which are managed file transfer products, contain an unrestricted file upload and download vulnerability that can lead to remote code execution with elevated privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2025-01-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/support.cleo.com\/hc\/en-us\/articles\/28408134019735-Cleo-Product-Security-Update ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-50623",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-49138",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Common Log File System (CLFS) Driver Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2024-12-10",
+            "shortDescription": "Microsoft Windows Common Log File System (CLFS) driver contains a heap-based buffer overflow vulnerability that allows a local attacker to escalate privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2024-49138 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-49138",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-51378",
+            "vendorProject": "CyberPersons",
+            "product": "CyberPanel",
+            "vulnerabilityName": "CyberPanel Incorrect Default Permissions Vulnerability",
+            "dateAdded": "2024-12-04",
+            "shortDescription": "CyberPanel contains an incorrect default permissions vulnerability that allows for authentication bypass and the execution of arbitrary commands using shell metacharacters in the statusfile property.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-25",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/cyberpanel.net\/KnowledgeBase\/home\/change-logs\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-51378",
+            "cwes": [
+                "CWE-276"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-11667",
+            "vendorProject": "Zyxel",
+            "product": "Multiple Firewalls",
+            "vulnerabilityName": "Zyxel Multiple Firewalls Path Traversal Vulnerability",
+            "dateAdded": "2024-12-03",
+            "shortDescription": "Multiple Zyxel firewalls contain a path traversal vulnerability in the web management interface that could allow an attacker to download or upload files via a crafted URL.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-24",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.zyxel.com\/global\/en\/support\/security-advisories\/zyxel-security-advisory-protecting-against-recent-firewall-threats-11-21-2024 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-11667",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-11680",
+            "vendorProject": "ProjectSend",
+            "product": "ProjectSend",
+            "vulnerabilityName": "ProjectSend Improper Authentication Vulnerability",
+            "dateAdded": "2024-12-03",
+            "shortDescription": "ProjectSend contains an improper authentication vulnerability that allows a remote, unauthenticated attacker to enable unauthorized modification of the application's configuration via crafted HTTP requests to options.php. Successful exploitation allows attackers to create accounts, upload webshells, and embed malicious JavaScript.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/projectsend\/projectsend\/commit\/193367d937b1a59ed5b68dd4e60bd53317473744 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-11680",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-45727",
+            "vendorProject": "North Grid",
+            "product": "Proself",
+            "vulnerabilityName": "North Grid Proself Improper Restriction of XML External Entity (XXE) Reference Vulnerability",
+            "dateAdded": "2024-12-03",
+            "shortDescription": "North Grid Proself Enterprise\/Standard, Gateway, and Mail Sanitize contain an improper restriction of XML External Entity (XXE) reference vulnerability, which could allow a remote, unauthenticated attacker to conduct an XXE attack.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.proself.jp\/information\/153\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-45727",
+            "cwes": [
+                "CWE-611"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-28461",
+            "vendorProject": "Array Networks ",
+            "product": "AG\/vxAG ArrayOS",
+            "vulnerabilityName": "Array Networks AG and vxAG ArrayOS Missing Authentication for Critical Function Vulnerability",
+            "dateAdded": "2024-11-25",
+            "shortDescription": "Array Networks AG and vxAG ArrayOS contain a missing authentication for critical function vulnerability that allows an attacker to read local files and execute code on the SSL VPN gateway.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-16",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/support.arraynetworks.net\/prx\/001\/http\/supportportal.arraynetworks.net\/documentation\/FieldNotice\/Array_Networks_Security_Advisory_for_Remote_Code_Execution_Vulnerability_AG.pdf ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-28461",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-21287",
+            "vendorProject": "Oracle",
+            "product": "Agile Product Lifecycle Management (PLM)",
+            "vulnerabilityName": "Oracle Agile Product Lifecycle Management (PLM) Incorrect Authorization Vulnerability",
+            "dateAdded": "2024-11-21",
+            "shortDescription": "Oracle Agile Product Lifecycle Management (PLM) contains an incorrect authorization vulnerability in the Process Extension component of the Software Development Kit. Successful exploitation of this vulnerability may result in unauthenticated file disclosure.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/alert-cve-2024-21287.html ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-21287",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-44309",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2024-11-21",
+            "shortDescription": "Apple iOS, macOS, and other Apple products contain an unspecified vulnerability when processing maliciously crafted web content that may lead to a cross-site scripting (XSS) attack.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/121752, https:\/\/support.apple.com\/en-us\/121753, https:\/\/support.apple.com\/en-us\/121754, https:\/\/support.apple.com\/en-us\/121755, https:\/\/support.apple.com\/en-us\/121756 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-44309",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-44308",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Code Execution Vulnerability",
+            "dateAdded": "2024-11-21",
+            "shortDescription": "Apple iOS, macOS, and other Apple products contain an unspecified vulnerability when processing maliciously crafted web content that may lead to arbitrary code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/121752, https:\/\/support.apple.com\/en-us\/121753, https:\/\/support.apple.com\/en-us\/121754, https:\/\/support.apple.com\/en-us\/121755, https:\/\/support.apple.com\/en-us\/121756 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-44308",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2024-38813",
+            "vendorProject": "VMware",
+            "product": "vCenter Server",
+            "vulnerabilityName": "VMware vCenter Server Privilege Escalation Vulnerability",
+            "dateAdded": "2024-11-20",
+            "shortDescription": "VMware vCenter contains an improper check for dropped privileges vulnerability. This vulnerability could allow an attacker with network access to the vCenter Server to escalate privileges to root by sending a specially crafted packet.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.broadcom.com\/web\/ecx\/support-content-notification\/-\/external\/content\/SecurityAdvisories\/0\/24968 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38813",
+            "cwes": [
+                "CWE-250",
+                "CWE-273"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38812",
+            "vendorProject": "VMware",
+            "product": "vCenter Server",
+            "vulnerabilityName": "VMware vCenter Server Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2024-11-20",
+            "shortDescription": "VMware vCenter Server contains a heap-based buffer overflow vulnerability in the implementation of the DCERPC protocol. This vulnerability could allow an attacker with network access to the vCenter Server to execute remote code by sending a specially crafted packet.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.broadcom.com\/web\/ecx\/support-content-notification\/-\/external\/content\/SecurityAdvisories\/0\/24968 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38812",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-9474",
+            "vendorProject": "Palo Alto Networks",
+            "product": "PAN-OS",
+            "vulnerabilityName": "Palo Alto Networks PAN-OS Management Interface OS Command Injection Vulnerability",
+            "dateAdded": "2024-11-18",
+            "shortDescription": "Palo Alto Networks PAN-OS contains an OS command injection vulnerability that allows for privilege escalation through the web-based management interface for several PAN products, including firewalls and VPN concentrators.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable. Additionally, the management interfaces for affected devices should not be exposed to untrusted networks, including the internet.",
+            "dueDate": "2024-12-09",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/security.paloaltonetworks.com\/CVE-2024-9474 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-9474",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-0012",
+            "vendorProject": "Palo Alto Networks",
+            "product": "PAN-OS",
+            "vulnerabilityName": "Palo Alto Networks PAN-OS Management Interface Authentication Bypass Vulnerability",
+            "dateAdded": "2024-11-18",
+            "shortDescription": "Palo Alto Networks PAN-OS contains an authentication bypass vulnerability in the web-based management interface for several PAN-OS products, including firewalls and VPN concentrators.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable. Additionally, management interface for affected devices should not be exposed to untrusted networks, including the internet.",
+            "dueDate": "2024-12-09",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/security.paloaltonetworks.com\/CVE-2024-0012 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-0012",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-1212",
+            "vendorProject": "Progress",
+            "product": "Kemp LoadMaster",
+            "vulnerabilityName": "Progress Kemp LoadMaster OS Command Injection Vulnerability",
+            "dateAdded": "2024-11-18",
+            "shortDescription": "Progress Kemp LoadMaster contains an OS command injection vulnerability that allows an unauthenticated, remote attacker to access the system through the LoadMaster management interface, enabling arbitrary system command execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/community.progress.com\/s\/article\/Release-Notice-LMOS-7-2-59-2-7-2-54-8-7-2-48-10-CVE-2024-1212 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-1212",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-9465",
+            "vendorProject": "Palo Alto Networks",
+            "product": "Expedition",
+            "vulnerabilityName": "Palo Alto Networks Expedition SQL Injection Vulnerability",
+            "dateAdded": "2024-11-14",
+            "shortDescription": "Palo Alto Networks Expedition contains a SQL injection vulnerability that allows an unauthenticated attacker to reveal Expedition database contents, such as password hashes, usernames, device configurations, and device API keys. With this, attackers can also create and read arbitrary files on the Expedition system.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.paloaltonetworks.com\/PAN-SA-2024-0010 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-9465",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-9463",
+            "vendorProject": "Palo Alto Networks",
+            "product": "Expedition",
+            "vulnerabilityName": "Palo Alto Networks Expedition OS Command Injection Vulnerability",
+            "dateAdded": "2024-11-14",
+            "shortDescription": "Palo Alto Networks Expedition contains an OS command injection vulnerability that allows an unauthenticated attacker to run arbitrary OS commands as root in Expedition, resulting in disclosure of usernames, cleartext passwords, device configurations, and device API keys of PAN-OS firewalls.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.paloaltonetworks.com\/PAN-SA-2024-0010 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-9463",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-26086",
+            "vendorProject": "Atlassian",
+            "product": "Jira Server and Data Center",
+            "vulnerabilityName": "Atlassian Jira Server and Data Center Path Traversal Vulnerability",
+            "dateAdded": "2024-11-12",
+            "shortDescription": "Atlassian Jira Server and Data Center contain a path traversal vulnerability that allows a remote attacker to read particular files in the \/WEB-INF\/web.xml endpoint.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/jira.atlassian.com\/browse\/JRASERVER-72695 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-26086",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-2120",
+            "vendorProject": "Cisco",
+            "product": "Adaptive Security Appliance (ASA)",
+            "vulnerabilityName": "Cisco Adaptive Security Appliance (ASA) Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2024-11-12",
+            "shortDescription": "Cisco Adaptive Security Appliance (ASA) contains a cross-site scripting (XSS) vulnerability in the WebVPN login page. This vulnerability allows remote attackers to inject arbitrary web script or HTML via an unspecified parameter.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-CVE-2014-2120 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-2120",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-41277",
+            "vendorProject": "Metabase",
+            "product": "Metabase",
+            "vulnerabilityName": "Metabase GeoJSON API Local File Inclusion Vulnerability",
+            "dateAdded": "2024-11-12",
+            "shortDescription": "Metabase contains a local file inclusion vulnerability in the custom map support in the API to read GeoJSON formatted data.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/metabase\/metabase\/security\/advisories\/GHSA-w73v-6p7p-fpfr ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-41277",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-43451",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows NTLMv2 Hash Disclosure Spoofing Vulnerability",
+            "dateAdded": "2024-11-12",
+            "shortDescription": "Microsoft Windows contains an NTLMv2 hash spoofing vulnerability that could result in disclosing a user's NTLMv2 hash to an attacker via a file open operation. The attacker could then leverage this hash to impersonate that user.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-43451 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-43451",
+            "cwes": [
+                "CWE-73"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-49039",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Task Scheduler Privilege Escalation Vulnerability",
+            "dateAdded": "2024-11-12",
+            "shortDescription": "Microsoft Windows Task Scheduler contains a privilege escalation vulnerability that can allow an attacker-provided, local application to escalate privileges outside of its AppContainer, and access privileged RPC functions.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-12-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2024-49039 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-49039",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-16278",
+            "vendorProject": "Nostromo",
+            "product": "nhttpd",
+            "vulnerabilityName": "Nostromo nhttpd Directory Traversal Vulnerability",
+            "dateAdded": "2024-11-07",
+            "shortDescription": "Nostromo nhttpd contains a directory traversal vulnerability in the http_verify() function in a non-chrooted nhttpd server allowing for remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.nazgul.ch\/dev\/nostromo_cl.txt ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-16278",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-51567",
+            "vendorProject": "CyberPersons",
+            "product": "CyberPanel",
+            "vulnerabilityName": "CyberPanel Incorrect Default Permissions Vulnerability",
+            "dateAdded": "2024-11-07",
+            "shortDescription": "CyberPanel contains an incorrect default permissions vulnerability that allows a remote, unauthenticated attacker to execute commands as root.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/cyberpanel.net\/blog\/detials-and-fix-of-recent-security-issue-and-patch-of-cyberpanel ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-51567",
+            "cwes": [
+                "CWE-276"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-43093",
+            "vendorProject": "Android",
+            "product": "Framework",
+            "vulnerabilityName": "Android Framework Privilege Escalation Vulnerability",
+            "dateAdded": "2024-11-07",
+            "shortDescription": "Android Framework contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/source.android.com\/docs\/security\/bulletin\/2024-11-01 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-43093",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2024-5910",
+            "vendorProject": "Palo Alto Networks",
+            "product": "Expedition",
+            "vulnerabilityName": "Palo Alto Networks Expedition Missing Authentication Vulnerability",
+            "dateAdded": "2024-11-07",
+            "shortDescription": "Palo Alto Networks Expedition contains a missing authentication vulnerability that allows an attacker with network access to takeover an Expedition admin account and potentially access configuration secrets, credentials, and other data.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.paloaltonetworks.com\/CVE-2024-5910 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-5910",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-8956",
+            "vendorProject": "PTZOptics",
+            "product": "PT30X-SDI\/NDI Cameras",
+            "vulnerabilityName": "PTZOptics PT30X-SDI\/NDI Cameras Authentication Bypass Vulnerability",
+            "dateAdded": "2024-11-04",
+            "shortDescription": "PTZOptics PT30X-SDI\/NDI cameras contain an insecure direct object reference (IDOR) vulnerability that allows a remote, attacker to bypass authentication for the \/cgi-bin\/param.cgi CGI script. If combined with CVE-2024-8957, this can lead to remote code execution as root.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/ptzoptics.com\/firmware-changelog\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-8956",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-8957",
+            "vendorProject": "PTZOptics",
+            "product": "PT30X-SDI\/NDI Cameras",
+            "vulnerabilityName": "PTZOptics PT30X-SDI\/NDI Cameras OS Command Injection Vulnerability",
+            "dateAdded": "2024-11-04",
+            "shortDescription": "PTZOptics PT30X-SDI\/NDI cameras contain an OS command injection vulnerability that allows a remote, authenticated attacker to escalate privileges to root via a crafted payload with the ntp_addr parameter of the \/cgi-bin\/param.cgi CGI script. ",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/ptzoptics.com\/firmware-changelog\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-8957",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-37383",
+            "vendorProject": "Roundcube",
+            "product": "Webmail",
+            "vulnerabilityName": "RoundCube Webmail Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2024-10-24",
+            "shortDescription": "RoundCube Webmail contains a cross-site scripting (XSS) vulnerability in the handling of SVG animate attributes that allows a remote attacker to run malicious JavaScript code.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/roundcube\/roundcubemail\/releases\/tag\/1.5.7, https:\/\/github.com\/roundcube\/roundcubemail\/releases\/tag\/1.6.7 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-37383",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-20481",
+            "vendorProject": "Cisco",
+            "product": "Adaptive Security Appliance (ASA) and Firepower Threat Defense (FTD)",
+            "vulnerabilityName": "Cisco ASA and FTD Denial-of-Service Vulnerability",
+            "dateAdded": "2024-10-24",
+            "shortDescription": "Cisco Adaptive Security Appliance (ASA) and Firepower Threat Defense (FTD) contain a missing release of resource after effective lifetime vulnerability that could allow an unauthenticated, remote attacker to cause a denial-of-service (DoS) of the RAVPN service.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-asaftd-bf-dos-vDZhLqrW ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-20481",
+            "cwes": [
+                "CWE-772"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-47575",
+            "vendorProject": "Fortinet",
+            "product": "FortiManager",
+            "vulnerabilityName": "Fortinet FortiManager Missing Authentication Vulnerability",
+            "dateAdded": "2024-10-23",
+            "shortDescription": "Fortinet FortiManager contains a missing authentication vulnerability in the fgfmd daemon that allows a remote, unauthenticated attacker to execute arbitrary code or commands via specially crafted requests.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/fortiguard.fortinet.com\/psirt\/FG-IR-24-423 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-47575",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38094",
+            "vendorProject": "Microsoft",
+            "product": "SharePoint",
+            "vulnerabilityName": "Microsoft SharePoint Deserialization Vulnerability",
+            "dateAdded": "2024-10-22",
+            "shortDescription": "Microsoft SharePoint contains a deserialization vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-12",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-38094 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38094",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-9537",
+            "vendorProject": "ScienceLogic",
+            "product": "SL1",
+            "vulnerabilityName": "ScienceLogic SL1 Unspecified Vulnerability",
+            "dateAdded": "2024-10-21",
+            "shortDescription": "ScienceLogic SL1 (formerly EM7) is affected by an unspecified vulnerability involving an unspecified third-party component.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.sciencelogic.com\/s\/article\/15527 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-9537",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2024-40711",
+            "vendorProject": "Veeam",
+            "product": "Backup & Replication",
+            "vulnerabilityName": "Veeam Backup and Replication Deserialization Vulnerability",
+            "dateAdded": "2024-10-17",
+            "shortDescription": "Veeam Backup and Replication contains a deserialization vulnerability allowing an unauthenticated user to perform remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-07",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.veeam.com\/kb4649 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-40711",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-28987",
+            "vendorProject": "SolarWinds",
+            "product": "Web Help Desk",
+            "vulnerabilityName": "SolarWinds Web Help Desk Hardcoded Credential Vulnerability",
+            "dateAdded": "2024-10-15",
+            "shortDescription": "SolarWinds Web Help Desk contains a hardcoded credential vulnerability that could allow a remote, unauthenticated user to access internal functionality and modify data.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.solarwinds.com\/trust-center\/security-advisories\/cve-2024-28987 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-28987",
+            "cwes": [
+                "CWE-798"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-9680",
+            "vendorProject": "Mozilla",
+            "product": "Firefox",
+            "vulnerabilityName": "Mozilla Firefox Use-After-Free Vulnerability",
+            "dateAdded": "2024-10-15",
+            "shortDescription": "Mozilla Firefox and Firefox ESR contain a use-after-free vulnerability in Animation timelines that allows for code execution in the content process.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.mozilla.org\/en-US\/security\/advisories\/mfsa2024-51\/ ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-9680",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-30088",
+            "vendorProject": "Microsoft",
+            "product": "Windows ",
+            "vulnerabilityName": "Microsoft Windows Kernel TOCTOU Race Condition Vulnerability",
+            "dateAdded": "2024-10-15",
+            "shortDescription": "Microsoft Windows Kernel contains a time-of-check to time-of-use (TOCTOU) race condition vulnerability that could allow for privilege escalation. ",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-11-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2024-30088 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-30088",
+            "cwes": [
+                "CWE-367"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-9380",
+            "vendorProject": "Ivanti",
+            "product": "Cloud Services Appliance (CSA)",
+            "vulnerabilityName": "Ivanti Cloud Services Appliance (CSA) OS Command Injection Vulnerability",
+            "dateAdded": "2024-10-09",
+            "shortDescription": "Ivanti Cloud Services Appliance (CSA) contains an OS command injection vulnerability in the administrative console which can allow an authenticated attacker with application admin privileges to pass commands to the underlying OS.",
+            "requiredAction": "As Ivanti CSA 4.6.x has reached End-of-Life status, users are urged to remove CSA 4.6.x from service or upgrade to the 5.0.x line, or later, of supported solution.",
+            "dueDate": "2024-10-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/Security-Advisory-Ivanti-CSA-Cloud-Services-Appliance-CVE-2024-9379-CVE-2024-9380-CVE-2024-9381 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-9380",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-9379",
+            "vendorProject": "Ivanti",
+            "product": "Cloud Services Appliance (CSA)",
+            "vulnerabilityName": "Ivanti Cloud Services Appliance (CSA) SQL Injection Vulnerability",
+            "dateAdded": "2024-10-09",
+            "shortDescription": "Ivanti Cloud Services Appliance (CSA) contains a SQL injection vulnerability in the admin web console in versions prior to 5.0.2, which can allow a remote attacker authenticated as administrator to run arbitrary SQL statements.",
+            "requiredAction": "As Ivanti CSA 4.6.x has reached End-of-Life status, users are urged to remove CSA 4.6.x from service or upgrade to the 5.0.x line, or later, of supported solution.",
+            "dueDate": "2024-10-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/Security-Advisory-Ivanti-CSA-Cloud-Services-Appliance-CVE-2024-9379-CVE-2024-9380-CVE-2024-9381 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-9379",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-23113",
+            "vendorProject": "Fortinet",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Fortinet Multiple Products Format String Vulnerability",
+            "dateAdded": "2024-10-09",
+            "shortDescription": "Fortinet FortiOS, FortiPAM, FortiProxy, and FortiWeb contain a format string vulnerability that allows a remote, unauthenticated attacker to execute arbitrary code or commands via specially crafted requests.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.fortiguard.com\/psirt\/FG-IR-24-029 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-23113",
+            "cwes": [
+                "CWE-134"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-43573",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows MSHTML Platform Spoofing Vulnerability",
+            "dateAdded": "2024-10-08",
+            "shortDescription": "Microsoft Windows MSHTML Platform contains an unspecified spoofing vulnerability which can lead to a loss of confidentiality.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-43573 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-43573",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-43572",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Management Console Remote Code Execution Vulnerability",
+            "dateAdded": "2024-10-08",
+            "shortDescription": "Microsoft Windows Management Console contains unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/advisory\/CVE-2024-43572 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-43572",
+            "cwes": [
+                "CWE-707"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-43047",
+            "vendorProject": "Qualcomm",
+            "product": "Multiple Chipsets ",
+            "vulnerabilityName": "Qualcomm Multiple Chipsets Use-After-Free Vulnerability",
+            "dateAdded": "2024-10-08",
+            "shortDescription": "Multiple Qualcomm chipsets contain a use-after-free vulnerability due to memory corruption in DSP Services while maintaining memory maps of HLOS memory. ",
+            "requiredAction": "Apply remediations or mitigations per vendor instructions or discontinue use of the product if remediation or mitigations are unavailable.",
+            "dueDate": "2024-10-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/git.codelinaro.org\/clo\/la\/platform\/vendor\/qcom\/opensource\/dsp-kernel\/-\/commit\/0e27b6c7d2bd8d0453e4465ac2ca49a8f8c440e2 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-43047",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-45519",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Command Execution Vulnerability",
+            "dateAdded": "2024-10-03",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) contains an unspecified vulnerability in the postjournal service that may allow an unauthenticated user to execute commands.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/wiki.zimbra.com\/wiki\/Zimbra_Security_Advisories ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-45519",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-29824",
+            "vendorProject": "Ivanti",
+            "product": "Endpoint Manager (EPM)",
+            "vulnerabilityName": "Ivanti Endpoint Manager (EPM) SQL Injection Vulnerability",
+            "dateAdded": "2024-10-02",
+            "shortDescription": "Ivanti Endpoint Manager (EPM) contains a SQL injection vulnerability in Core server that allows an unauthenticated attacker within the same network to execute arbitrary code. ",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/Security-Advisory-May-2024 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-29824",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0344",
+            "vendorProject": "SAP",
+            "product": "Commerce Cloud",
+            "vulnerabilityName": "SAP Commerce Cloud Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2024-09-30",
+            "shortDescription": "SAP Commerce Cloud (formerly known as Hybris) contains a deserialization of untrusted data vulnerability within the mediaconversion and virtualjdbc extension that allows for code injection.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/web.archive.org\/web\/20191214053020\/https:\/\/wiki.scn.sap.com\/wiki\/pages\/viewpage.action?pageId=523998017 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0344",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-15415",
+            "vendorProject": "DrayTek",
+            "product": "Multiple Vigor Routers",
+            "vulnerabilityName": "DrayTek Multiple Vigor Routers OS Command Injection Vulnerability",
+            "dateAdded": "2024-09-30",
+            "shortDescription": "DrayTek Vigor3900, Vigor2960, and Vigor300B devices contain an OS command injection vulnerability in cgi-bin\/mainfunction.cgi\/cvmcfgupload that allows for remote code execution via shell metacharacters in a filename when the text\/x-python-script content type is used.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.draytek.com\/about\/security-advisory\/vigor3900-\/-vigor2960-\/-vigor300b-remote-code-injection\/execution-vulnerability-(cve-2020-14472) ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-15415",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-25280",
+            "vendorProject": "D-Link",
+            "product": "DIR-820 Router",
+            "vulnerabilityName": "D-Link DIR-820 Router OS Command Injection Vulnerability",
+            "dateAdded": "2024-09-30",
+            "shortDescription": "D-Link DIR-820 routers contain an OS command injection vulnerability that allows a remote, unauthenticated attacker to escalate privileges to root via a crafted payload with the ping_addr parameter to ping.ccp.",
+            "requiredAction": "The impacted product is end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue utilization of the product.",
+            "dueDate": "2024-10-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportannouncement.us.dlink.com\/security\/publication.aspx?name=SAP10358 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-25280",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-7593",
+            "vendorProject": "Ivanti",
+            "product": "Virtual Traffic Manager",
+            "vulnerabilityName": "Ivanti Virtual Traffic Manager Authentication Bypass Vulnerability",
+            "dateAdded": "2024-09-24",
+            "shortDescription": "Ivanti Virtual Traffic Manager contains an authentication bypass vulnerability that allows a remote, unauthenticated attacker to create a chosen administrator account.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/Security-Advisory-Ivanti-Virtual-Traffic-Manager-vTM-CVE-2024-7593 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-7593",
+            "cwes": [
+                "CWE-287",
+                "CWE-303"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-8963",
+            "vendorProject": "Ivanti",
+            "product": "Cloud Services Appliance (CSA)",
+            "vulnerabilityName": "Ivanti Cloud Services Appliance (CSA) Path Traversal Vulnerability",
+            "dateAdded": "2024-09-19",
+            "shortDescription": "Ivanti Cloud Services Appliance (CSA) contains a path traversal vulnerability that could allow a remote, unauthenticated attacker to access restricted functionality. If CVE-2024-8963 is used in conjunction with CVE-2024-8190, an attacker could bypass admin authentication and execute arbitrary commands on the appliance.",
+            "requiredAction": "As Ivanti CSA has reached End-of-Life status, users are urged to remove CSA 4.6.x from service or upgrade to the 5.0.x line of supported solutions, as future vulnerabilities on the 4.6.x version of CSA are unlikely to receive security updates.",
+            "dueDate": "2024-10-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/Security-Advisory-Ivanti-CSA-4-6-Cloud-Services-Appliance-CVE-2024-8963 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-8963",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-14644",
+            "vendorProject": "Oracle",
+            "product": "WebLogic Server",
+            "vulnerabilityName": "Oracle WebLogic Server Remote Code Execution Vulnerability",
+            "dateAdded": "2024-09-18",
+            "shortDescription": "Oracle WebLogic Server, a product within the Fusion Middleware suite, contains a deserialization vulnerability. Unauthenticated attackers with network access via T3 or IIOP can exploit this vulnerability to achieve remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/cpujul2020.html  ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-14644",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2022-21445",
+            "vendorProject": "Oracle",
+            "product": "ADF Faces",
+            "vulnerabilityName": "Oracle ADF Faces Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2024-09-18",
+            "shortDescription": "Oracle ADF Faces library, included with Oracle JDeveloper Distribution, contains a deserialization of untrusted data vulnerability leading to unauthenticated remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/cpuapr2022.html  ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-21445",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0618",
+            "vendorProject": "Microsoft",
+            "product": "SQL Server",
+            "vulnerabilityName": "Microsoft SQL Server Reporting Services Remote Code Execution Vulnerability",
+            "dateAdded": "2024-09-18",
+            "shortDescription": "Microsoft SQL Server Reporting Services contains a deserialization vulnerability when handling page requests incorrectly. An authenticated attacker can exploit this vulnerability to execute code in the context of the Report Server service account.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/advisory\/CVE-2020-0618  ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0618",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-27348",
+            "vendorProject": "Apache",
+            "product": "HugeGraph-Server",
+            "vulnerabilityName": "Apache HugeGraph-Server Improper Access Control Vulnerability",
+            "dateAdded": "2024-09-18",
+            "shortDescription": "Apache HugeGraph-Server contains an improper access control vulnerability that could allow a remote attacker to execute arbitrary code.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see:  https:\/\/lists.apache.org\/thread\/nx6g6htyhpgtzsocybm242781o8w5kq9 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-27348",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-0502",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Double Free Vulnerablity",
+            "dateAdded": "2024-09-17",
+            "shortDescription": "Adobe Flash Player contains a double free vulnerability that allows a remote attacker to execute arbitrary code.",
+            "requiredAction": "The impacted product is end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue utilization of the product.",
+            "dueDate": "2024-10-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.adobe.com\/products\/flashplayer\/end-of-life-alternative.html#eol-alternative-faq ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-0502",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-0648",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Code Execution Vulnerability",
+            "dateAdded": "2024-09-17",
+            "shortDescription": "Adobe Flash Player contains an unspecified vulnerability in the ExternalInterface ActionScript functionality that allows a remote attacker to execute arbitrary code via crafted SWF content.",
+            "requiredAction": "The impacted product is end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue utilization of the product.",
+            "dueDate": "2024-10-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.adobe.com\/products\/flashplayer\/end-of-life-alternative.html#eol-alternative-faq ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-0648",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2013-0643",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Incorrect Default Permissions Vulnerability",
+            "dateAdded": "2024-09-17",
+            "shortDescription": "Adobe Flash Player contains an incorrect default permissions vulnerability in the Firefox sandbox that allows a remote attacker to execute arbitrary code via crafted SWF content. ",
+            "requiredAction": "The impacted product is end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue utilization of the product.",
+            "dueDate": "2024-10-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.adobe.com\/products\/flashplayer\/end-of-life-alternative.html#eol-alternative-faq ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-0643",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-0497",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Integer Underflow Vulnerablity",
+            "dateAdded": "2024-09-17",
+            "shortDescription": "Adobe Flash Player contains an integer underflow vulnerability that allows a remote attacker to execute arbitrary code.",
+            "requiredAction": "The impacted product is end-of-life (EoL) and\/or end-of-service (EoS). Users should discontinue utilization of the product.",
+            "dueDate": "2024-10-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.adobe.com\/products\/flashplayer\/end-of-life-alternative.html#eol-alternative-faq ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-0497",
+            "cwes": [
+                "CWE-191"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-6670",
+            "vendorProject": "Progress",
+            "product": "WhatsUp Gold",
+            "vulnerabilityName": "Progress WhatsUp Gold SQL Injection Vulnerability",
+            "dateAdded": "2024-09-16",
+            "shortDescription": "Progress WhatsUp Gold contains a SQL injection vulnerability that allows an unauthenticated attacker to retrieve the user's encrypted password if the application is configured with only a single user.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-07",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/community.progress.com\/s\/article\/WhatsUp-Gold-Security-Bulletin-August-2024 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-6670",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-43461",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows MSHTML Platform Spoofing Vulnerability",
+            "dateAdded": "2024-09-16",
+            "shortDescription": "Microsoft Windows MSHTML Platform contains a user interface (UI) misrepresentation of critical information vulnerability that allows an attacker to spoof a web page. This vulnerability was exploited in conjunction with CVE-2024-38112.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-43461 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-43461",
+            "cwes": [
+                "CWE-451"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-8190",
+            "vendorProject": "Ivanti",
+            "product": "Cloud Services Appliance",
+            "vulnerabilityName": "Ivanti Cloud Services Appliance OS Command Injection Vulnerability",
+            "dateAdded": "2024-09-13",
+            "shortDescription": "Ivanti Cloud Services Appliance (CSA) contains an OS command injection vulnerability in the administrative console which can allow an authenticated attacker with application admin privileges to pass commands to the underlying OS.",
+            "requiredAction": "As Ivanti CSA has reached End-of-Life status, users are urged to remove CSA 4.6.x from service or upgrade to the 5.0.x line of supported solutions, as future vulnerabilities on the 4.6.x version of CSA are unlikely to receive future security updates.",
+            "dueDate": "2024-10-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/Security-Advisory-Ivanti-Cloud-Service-Appliance-CSA-CVE-2024-8190; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-8190",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38217",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Mark of the Web (MOTW) Protection Mechanism Failure Vulnerability",
+            "dateAdded": "2024-09-10",
+            "shortDescription": "Microsoft Windows Mark of the Web (MOTW) contains a protection mechanism failure vulnerability that allows an attacker to bypass MOTW-based defenses. This can result in a limited loss of integrity and availability of security features such as Protected View in Microsoft Office, which rely on MOTW tagging.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-38217; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38217",
+            "cwes": [
+                "CWE-693"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38014",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Installer Improper Privilege Management Vulnerability",
+            "dateAdded": "2024-09-10",
+            "shortDescription": "Microsoft Windows Installer contains an improper privilege management vulnerability that could allow an attacker to gain SYSTEM privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-38014; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38014",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38226",
+            "vendorProject": "Microsoft",
+            "product": "Publisher",
+            "vulnerabilityName": "Microsoft Publisher Protection Mechanism Failure Vulnerability",
+            "dateAdded": "2024-09-10",
+            "shortDescription": "Microsoft Publisher contains a protection mechanism failure vulnerability that allows attacker to bypass Office macro policies used to block untrusted or malicious files.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-10-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-38226; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38226",
+            "cwes": [
+                "CWE-693"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-40766",
+            "vendorProject": "SonicWall",
+            "product": "SonicOS",
+            "vulnerabilityName": "SonicWall SonicOS Improper Access Control Vulnerability",
+            "dateAdded": "2024-09-09",
+            "shortDescription": "SonicWall SonicOS contains an improper access control vulnerability that could lead to unauthorized resource access and, under certain conditions, may cause the firewall to crash.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-30",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/psirt.global.sonicwall.com\/vuln-detail\/SNWLID-2024-0015; https:\/\/www.sonicwall.com\/support\/notices\/gen-7-and-newer-sonicwall-firewalls-sslvpn-recent-threat-activity\/kA1VN0000000RDG0A2 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-40766",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-1000253",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel PIE Stack Buffer Corruption Vulnerability ",
+            "dateAdded": "2024-09-09",
+            "shortDescription": "Linux kernel contains a position-independent executable (PIE) stack buffer corruption vulnerability in load_elf_ binary() that allows a local attacker to escalate privileges. ",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-30",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/git.kernel.org\/pub\/scm\/linux\/kernel\/git\/torvalds\/linux.git\/commit\/?id=a87938b2e246b81b4fb713edb371a9fa3c5c3c86; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-1000253",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-3714",
+            "vendorProject": "ImageMagick",
+            "product": "ImageMagick",
+            "vulnerabilityName": "ImageMagick Improper Input Validation Vulnerability",
+            "dateAdded": "2024-09-09",
+            "shortDescription": "ImageMagick contains an improper input validation vulnerability that affects the EPHEMERAL, HTTPS, MVG, MSL, TEXT, SHOW, WIN, and PLT coders. This allows a remote attacker to execute arbitrary code via shell metacharacters in a crafted image.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/www.imagemagick.org\/discourse-server\/viewtopic.php?f=4&t=29588#p132726, https:\/\/imagemagick.org\/archive\/releases\/; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-3714",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-7262",
+            "vendorProject": "Kingsoft",
+            "product": "WPS Office",
+            "vulnerabilityName": "Kingsoft WPS Office Path Traversal Vulnerability",
+            "dateAdded": "2024-09-03",
+            "shortDescription": "Kingsoft WPS Office contains a path traversal vulnerability in promecefpluginhost.exe on Windows that allows an attacker to load an arbitrary Windows library.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "While CISA cannot confirm the effectiveness of patches at this time, it is recommended that mitigations be applied per vendor instructions if available. If these instructions cannot be located or if mitigations are unavailable, discontinue the use of the product.;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-7262",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-20124",
+            "vendorProject": "DrayTek",
+            "product": "VigorConnect",
+            "vulnerabilityName": "Draytek VigorConnect Path Traversal Vulnerability ",
+            "dateAdded": "2024-09-03",
+            "shortDescription": "Draytek VigorConnect contains a path traversal vulnerability in the file download functionality of the WebServlet endpoint. An unauthenticated attacker could leverage this vulnerability to download arbitrary files from the underlying operating system with root privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.draytek.com\/about\/security-advisory\/vigorconnect-software-security-vulnerability-(cve-2021-20123-cve-2021-20129); https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-20124",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-20123",
+            "vendorProject": "DrayTek",
+            "product": "VigorConnect",
+            "vulnerabilityName": "Draytek VigorConnect Path Traversal Vulnerability ",
+            "dateAdded": "2024-09-03",
+            "shortDescription": "Draytek VigorConnect contains a path traversal vulnerability in the DownloadFileServlet endpoint. An unauthenticated attacker could leverage this vulnerability to download arbitrary files from the underlying operating system with root privileges. ",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.draytek.com\/about\/security-advisory\/vigorconnect-software-security-vulnerability-(cve-2021-20123-cve-2021-20129); https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-20123",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-7965",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Inappropriate Implementation Vulnerability",
+            "dateAdded": "2024-08-28",
+            "shortDescription": "Google Chromium V8 contains an inappropriate implementation vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2024\/08\/stable-channel-update-for-desktop_21.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-7965",
+            "cwes": [
+                "CWE-358"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38856",
+            "vendorProject": "Apache",
+            "product": "OFBiz",
+            "vulnerabilityName": "Apache OFBiz Incorrect Authorization Vulnerability",
+            "dateAdded": "2024-08-27",
+            "shortDescription": "Apache OFBiz contains an incorrect authorization vulnerability that could allow remote code execution via a Groovy payload in the context of the OFBiz user process by an unauthenticated attacker.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/lists.apache.org\/thread\/olxxjk6b13sl3wh9cmp0k2dscvp24l7w; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38856",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-7971",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2024-08-26",
+            "shortDescription": "Google Chromium V8 contains a type confusion vulnerability that allows a remote attacker to exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2024\/08\/stable-channel-update-for-desktop_21.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-7971",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-39717",
+            "vendorProject": "Versa",
+            "product": "Director",
+            "vulnerabilityName": "Versa Director Dangerous File Type Upload Vulnerability",
+            "dateAdded": "2024-08-23",
+            "shortDescription": "The Versa Director GUI contains an unrestricted upload of file with dangerous type vulnerability that allows administrators with Provider-Data-Center-Admin or Provider-Data-Center-System-Admin privileges to customize the user interface. The \u201cChange Favicon\u201d (Favorite Icon) enables the upload of a .png file, which can be exploited to upload a malicious file with a .png extension disguised as an image.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/versa-networks.com\/blog\/versa-security-bulletin-update-on-cve-2024-39717-versa-director-dangerous-file-type-upload-vulnerability\/;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-39717",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-31196",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Information Disclosure Vulnerability",
+            "dateAdded": "2024-08-21",
+            "shortDescription": "Microsoft Exchange Server contains an information disclosure vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/advisory\/CVE-2021-31196; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-31196",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2022-0185",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2024-08-21",
+            "shortDescription": "Linux kernel contains a heap-based buffer overflow vulnerability in the legacy_parse_param function in the Filesystem Context functionality. This allows an attacker to open a filesystem that does not support the Filesystem Context API and ultimately escalate privileges.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2024-09-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/git.kernel.org\/pub\/scm\/linux\/kernel\/git\/torvalds\/linux.git\/commit?id=722d94847de2; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-0185",
+            "cwes": [
+                "CWE-190"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-33045",
+            "vendorProject": "Dahua",
+            "product": "IP Camera Firmware",
+            "vulnerabilityName": "Dahua IP Camera Authentication Bypass Vulnerability",
+            "dateAdded": "2024-08-21",
+            "shortDescription": "Dahua IP cameras and related products contain an authentication bypass vulnerability when the loopback device is specified by the client during authentication.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.dahuasecurity.com\/aboutUs\/trustedCenter\/details\/582; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-33045",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-33044",
+            "vendorProject": "Dahua",
+            "product": "IP Camera Firmware",
+            "vulnerabilityName": "Dahua IP Camera Authentication Bypass Vulnerability",
+            "dateAdded": "2024-08-21",
+            "shortDescription": "Dahua IP cameras and related products contain an authentication bypass vulnerability when the NetKeyboard type argument is specified by the client during authentication.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.dahuasecurity.com\/aboutUs\/trustedCenter\/details\/582; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-33044",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-23897",
+            "vendorProject": "Jenkins",
+            "product": "Jenkins Command Line Interface (CLI)",
+            "vulnerabilityName": "Jenkins Command Line Interface (CLI) Path Traversal Vulnerability",
+            "dateAdded": "2024-08-19",
+            "shortDescription": "Jenkins Command Line Interface (CLI) contains a path traversal vulnerability that allows attackers limited read access to certain files, which can lead to code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-09",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.jenkins.io\/security\/advisory\/2024-01-24\/#SECURITY-3314; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-23897",
+            "cwes": [
+                "CWE-27"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-28986",
+            "vendorProject": "SolarWinds",
+            "product": "Web Help Desk",
+            "vulnerabilityName": "SolarWinds Web Help Desk Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2024-08-15",
+            "shortDescription": "SolarWinds Web Help Desk contains a deserialization of untrusted data vulnerability that could allow for remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.solarwinds.com\/trust-center\/security-advisories\/cve-2024-28986; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-28986",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38107",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Power Dependency Coordinator Privilege Escalation Vulnerability",
+            "dateAdded": "2024-08-13",
+            "shortDescription": "Microsoft Windows Power Dependency Coordinator contains an unspecified vulnerability that allows for privilege escalation, enabling a local attacker to obtain SYSTEM privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-38107; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38107",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38106",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2024-08-13",
+            "shortDescription": "Microsoft Windows Kernel contains an unspecified vulnerability that allows for privilege escalation, enabling a local attacker to gain SYSTEM privileges. Successful exploitation of this vulnerability requires an attacker to win a race condition.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-38106; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38106",
+            "cwes": [
+                "CWE-591"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38193",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Ancillary Function Driver for WinSock Privilege Escalation Vulnerability",
+            "dateAdded": "2024-08-13",
+            "shortDescription": "Microsoft Windows Ancillary Function Driver for WinSock contains an unspecified vulnerability that allows for privilege escalation, enabling a local attacker to gain SYSTEM privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-38193; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38193",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38213",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows SmartScreen Security Feature Bypass Vulnerability",
+            "dateAdded": "2024-08-13",
+            "shortDescription": "Microsoft Windows SmartScreen contains a security feature bypass vulnerability that allows an attacker to bypass the SmartScreen user experience via a malicious file.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-38213; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38213",
+            "cwes": [
+                "CWE-693"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38178",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Scripting Engine Memory Corruption Vulnerability",
+            "dateAdded": "2024-08-13",
+            "shortDescription": "Microsoft Windows Scripting Engine contains a memory corruption vulnerability that allows unauthenticated attacker to initiate remote code execution via a specially crafted URL.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-38178; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38178",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38189",
+            "vendorProject": "Microsoft",
+            "product": "Project",
+            "vulnerabilityName": "Microsoft Project Remote Code Execution Vulnerability ",
+            "dateAdded": "2024-08-13",
+            "shortDescription": "Microsoft Project contains an unspecified vulnerability that allows for remote code execution via a malicious file.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-09-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-38189; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38189",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-32113",
+            "vendorProject": "Apache",
+            "product": "OFBiz",
+            "vulnerabilityName": "Apache OFBiz Path Traversal Vulnerability",
+            "dateAdded": "2024-08-07",
+            "shortDescription": "Apache OFBiz contains a path traversal vulnerability that could allow for remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-08-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/lists.apache.org\/thread\/w6s60okgkxp2th1sr8vx0ndmgk68fqrd; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-32113",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-36971",
+            "vendorProject": "Android",
+            "product": "Kernel",
+            "vulnerabilityName": "Android Kernel Remote Code Execution Vulnerability",
+            "dateAdded": "2024-08-07",
+            "shortDescription": "Android contains an unspecified vulnerability in the kernel that allows for remote code execution. This vulnerability resides in Linux Kernel and could impact other products, including but not limited to Android OS.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-08-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see:   https:\/\/source.android.com\/docs\/security\/bulletin\/2024-08-01,  https:\/\/lore.kernel.org\/linux-cve-announce\/20240610090330.1347021-2-lee@kernel.org\/T\/#u ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-36971",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0824",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft COM for Windows Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2024-08-05",
+            "shortDescription": "Microsoft COM for Windows contains a deserialization of untrusted data vulnerability that allows for privilege escalation and remote code execution via a specially crafted file or script.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-08-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/advisory\/CVE-2018-0824; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0824",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-37085",
+            "vendorProject": "VMware",
+            "product": "ESXi",
+            "vulnerabilityName": "VMware ESXi Authentication Bypass Vulnerability",
+            "dateAdded": "2024-07-30",
+            "shortDescription": "VMware ESXi contains an authentication bypass vulnerability. A malicious actor with sufficient Active Directory (AD) permissions can gain full access to an ESXi host that was previously configured to use AD for user management by re-creating the configured AD group ('ESXi Admins' by default) after it was deleted from AD.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-08-20",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/support.broadcom.com\/web\/ecx\/support-content-notification\/-\/external\/content\/SecurityAdvisories\/0\/24505;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-37085",
+            "cwes": [
+                "CWE-305"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-45249",
+            "vendorProject": "Acronis",
+            "product": "Cyber Infrastructure (ACI)",
+            "vulnerabilityName": "Acronis Cyber Infrastructure (ACI) Insecure Default Password Vulnerability",
+            "dateAdded": "2024-07-29",
+            "shortDescription": "Acronis Cyber Infrastructure (ACI) allows an unauthenticated user to execute commands remotely due to the use of default passwords.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-08-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security-advisory.acronis.com\/advisories\/SEC-6452;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-45249",
+            "cwes": [
+                "CWE-1393"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-5217",
+            "vendorProject": "ServiceNow",
+            "product": "Utah, Vancouver, and Washington DC Now Platform",
+            "vulnerabilityName": "ServiceNow Incomplete List of Disallowed Inputs Vulnerability",
+            "dateAdded": "2024-07-29",
+            "shortDescription": "ServiceNow Washington DC, Vancouver, and earlier Now Platform releases contain an incomplete list of disallowed inputs vulnerability in the GlideExpression script. An unauthenticated user could exploit this vulnerability to execute code remotely.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-08-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.servicenow.com\/kb?id=kb_article_view&sysparm_article=KB1648313; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-5217",
+            "cwes": [
+                "CWE-184"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-4879",
+            "vendorProject": "ServiceNow",
+            "product": "Utah, Vancouver, and Washington DC Now Platform",
+            "vulnerabilityName": "ServiceNow Improper Input Validation Vulnerability",
+            "dateAdded": "2024-07-29",
+            "shortDescription": "ServiceNow Utah, Vancouver, and Washington DC Now Platform releases contain a jelly template injection vulnerability in UI macros. An unauthenticated user could exploit this vulnerability to execute code remotely. ",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-08-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.servicenow.com\/kb?id=kb_article_view&sysparm_article=KB1645154; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-4879",
+            "cwes": [
+                "CWE-1287"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-39891",
+            "vendorProject": "Twilio",
+            "product": "Authy",
+            "vulnerabilityName": "Twilio Authy Information Disclosure Vulnerability",
+            "dateAdded": "2024-07-23",
+            "shortDescription": "Twilio Authy contains an information disclosure vulnerability in its API that allows an unauthenticated endpoint to accept a request containing a phone number and respond with information about whether the phone number was registered with Authy.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-08-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.twilio.com\/en-us\/changelog\/Security_Alert_Authy_App_Android_iOS; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-39891",
+            "cwes": [
+                "CWE-203"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-4792",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Use-After-Free Vulnerability",
+            "dateAdded": "2024-07-23",
+            "shortDescription": "Microsoft Internet Explorer contains a use-after-free vulnerability that allows a remote attacker to execute arbitrary code via a crafted web site that triggers access to an object that (1) was not properly allocated or (2) is deleted, as demonstrated by a CDwnBindInfo object.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2024-08-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/learn.microsoft.com\/en-us\/lifecycle\/products\/internet-explorer-11; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-4792",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22948",
+            "vendorProject": "VMware",
+            "product": "vCenter Server",
+            "vulnerabilityName": "VMware vCenter Server Incorrect Default File Permissions Vulnerability ",
+            "dateAdded": "2024-07-17",
+            "shortDescription": "VMware vCenter Server contains an incorrect default file permissions vulnerability that allows a remote, privileged attacker to gain access to sensitive information.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-08-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.vmware.com\/security\/advisories\/VMSA-2022-0009.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22948",
+            "cwes": [
+                "CWE-276"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-28995",
+            "vendorProject": "SolarWinds",
+            "product": "Serv-U",
+            "vulnerabilityName": "SolarWinds Serv-U Path Traversal Vulnerability ",
+            "dateAdded": "2024-07-17",
+            "shortDescription": "SolarWinds Serv-U contains a path traversal vulnerability that allows an attacker access to read sensitive files on the host machine.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-08-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.solarwinds.com\/trust-center\/security-advisories\/cve-2024-28995; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-28995",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-34102",
+            "vendorProject": "Adobe",
+            "product": "Commerce and Magento Open Source",
+            "vulnerabilityName": "Adobe Commerce and Magento Open Source Improper Restriction of XML External Entity Reference (XXE) Vulnerability",
+            "dateAdded": "2024-07-17",
+            "shortDescription": "Adobe Commerce and Magento Open Source contain an improper restriction of XML external entity reference (XXE) vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-08-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/helpx.adobe.com\/security\/products\/magento\/apsb24-40.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-34102",
+            "cwes": [
+                "CWE-611"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-36401",
+            "vendorProject": "OSGeo",
+            "product": "GeoServer",
+            "vulnerabilityName": "OSGeo GeoServer GeoTools Eval Injection Vulnerability",
+            "dateAdded": "2024-07-15",
+            "shortDescription": "OSGeo GeoServer GeoTools contains an improper neutralization of directives in dynamically evaluated code vulnerability due to unsafely evaluating property names as XPath expressions. This allows unauthenticated attackers to conduct remote code execution via specially crafted input.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-08-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects an open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/github.com\/geoserver\/geoserver\/security\/advisories\/GHSA-6jj6-gm7p-fcvv, https:\/\/github.com\/geotools\/geotools\/pull\/4797 ;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-36401",
+            "cwes": [
+                "CWE-95"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-23692",
+            "vendorProject": "Rejetto",
+            "product": "HTTP File Server",
+            "vulnerabilityName": "Rejetto HTTP File Server Improper Neutralization of Special Elements Used in a Template Engine Vulnerability",
+            "dateAdded": "2024-07-09",
+            "shortDescription": "Rejetto HTTP File Server contains an improper neutralization of special elements used in a template engine vulnerability. This allows a remote, unauthenticated attacker to execute commands on the affected system by sending a specially crafted HTTP request.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-07-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "The patched Rejetto HTTP File Server (HFS) is version 3: https:\/\/github.com\/rejetto\/hfs?tab=readme-ov-file#installation, https:\/\/www.rejetto.com\/hfs\/ ;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-23692",
+            "cwes": [
+                "CWE-1336"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38080",
+            "vendorProject": "Microsoft",
+            "product": "Windows ",
+            "vulnerabilityName": "Microsoft Windows Hyper-V Privilege Escalation Vulnerability",
+            "dateAdded": "2024-07-09",
+            "shortDescription": "Microsoft Windows Hyper-V contains a privilege escalation vulnerability that allows a local attacker with user permissions to gain SYSTEM privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-07-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2024-38080; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38080",
+            "cwes": [
+                "CWE-190"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-38112",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows MSHTML Platform Spoofing Vulnerability",
+            "dateAdded": "2024-07-09",
+            "shortDescription": "Microsoft Windows MSHTML Platform contains a spoofing vulnerability that has a high impact to confidentiality, integrity, and availability.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-07-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-38112; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-38112",
+            "cwes": [
+                "CWE-451"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-20399",
+            "vendorProject": "Cisco",
+            "product": "NX-OS",
+            "vulnerabilityName": "Cisco NX-OS Command Injection Vulnerability",
+            "dateAdded": "2024-07-02",
+            "shortDescription": "Cisco NX-OS contains a command injection vulnerability in the command line interface (CLI) that could allow an authenticated, local attacker to execute commands as root on the underlying operating system of an affected device.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-07-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-nxos-cmd-injection-xD9OhyOP;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-20399",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-13965",
+            "vendorProject": "Roundcube",
+            "product": "Webmail",
+            "vulnerabilityName": "Roundcube Webmail Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2024-06-26",
+            "shortDescription": "Roundcube Webmail contains a cross-site scripting (XSS) vulnerability that allows a remote attacker to manipulate data via a malicious XML attachment.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-07-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/roundcube.net\/news\/2020\/06\/02\/security-updates-1.4.5-and-1.3.12; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-13965",
+            "cwes": [
+                "CWE-80"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-2586",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Use-After-Free Vulnerability",
+            "dateAdded": "2024-06-26",
+            "shortDescription": "Linux Kernel contains a use-after-free vulnerability in the nft_object, allowing local attackers to escalate privileges. ",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2024-07-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. For more information, please see: https:\/\/seclists.org\/oss-sec\/2022\/q3\/131;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-2586",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-24816",
+            "vendorProject": "OSGeo",
+            "product": "JAI-EXT",
+            "vulnerabilityName": "OSGeo GeoServer JAI-EXT Code Injection Vulnerability",
+            "dateAdded": "2024-06-26",
+            "shortDescription": "OSGeo GeoServer JAI-EXT contains a code injection vulnerability that, when programs use jt-jiffle and allow Jiffle script to be provided via network request, could allow remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-07-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. The patched JAI-EXT is version 1.1.22: https:\/\/github.com\/geosolutions-it\/jai-ext\/releases\/tag\/1.1.22, https:\/\/github.com\/geosolutions-it\/jai-ext\/security\/advisories\/GHSA-v92f-jx6p-73rx;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-24816",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-4358",
+            "vendorProject": "Progress",
+            "product": "Telerik Report Server",
+            "vulnerabilityName": "Progress Telerik Report Server Authentication Bypass by Spoofing Vulnerability",
+            "dateAdded": "2024-06-13",
+            "shortDescription": "Progress Telerik Report Server contains an authorization bypass by spoofing vulnerability that allows an attacker to obtain unauthorized access.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-07-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/docs.telerik.com\/report-server\/knowledge-base\/registration-auth-bypass-cve-2024-4358; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-4358",
+            "cwes": [
+                "CWE-290"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-26169",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Error Reporting Service Improper Privilege Management Vulnerability",
+            "dateAdded": "2024-06-13",
+            "shortDescription": "Microsoft Windows Error Reporting Service contains an improper privilege management vulnerability that allows a local attacker with user permissions to gain SYSTEM privileges.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2024-07-04",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-26169; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-26169",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-32896",
+            "vendorProject": "Android",
+            "product": "Pixel",
+            "vulnerabilityName": "Android Pixel Privilege Escalation Vulnerability",
+            "dateAdded": "2024-06-13",
+            "shortDescription": "Android Pixel contains an unspecified vulnerability in the firmware that allows for privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-07-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/source.android.com\/docs\/security\/bulletin\/pixel\/2024-06-01; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-32896",
+            "cwes": [
+                "CWE-783"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-4577",
+            "vendorProject": "PHP Group",
+            "product": "PHP",
+            "vulnerabilityName": "PHP-CGI OS Command Injection Vulnerability",
+            "dateAdded": "2024-06-12",
+            "shortDescription": "PHP, specifically Windows-based PHP used in CGI mode, contains an OS command injection vulnerability that allows for arbitrary code execution. This vulnerability is a patch bypass for CVE-2012-1823.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-07-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see:  https:\/\/www.php.net\/ChangeLog-8.php#;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-4577",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-4610",
+            "vendorProject": "Arm",
+            "product": "Mali GPU Kernel Driver",
+            "vulnerabilityName": "Arm Mali GPU Kernel Driver Use-After-Free Vulnerability",
+            "dateAdded": "2024-06-12",
+            "shortDescription": "Arm Bifrost and Valhall GPU kernel drivers contain a use-after-free vulnerability that allows a local, non-privileged user to make improper GPU memory processing operations to gain access to already freed memory.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-07-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/developer.arm.com\/Arm%20Security%20Center\/Mali%20GPU%20Driver%20Vulnerabilities; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-4610",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-3506",
+            "vendorProject": "Oracle",
+            "product": "WebLogic Server",
+            "vulnerabilityName": "Oracle WebLogic Server OS Command Injection Vulnerability",
+            "dateAdded": "2024-06-03",
+            "shortDescription": "Oracle WebLogic Server, a product within the Fusion Middleware suite, contains an OS command injection vulnerability that allows an attacker to execute arbitrary code via a specially crafted HTTP request that includes a malicious XML document.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-06-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/cpuapr2017.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-3506",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-1086",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Use-After-Free Vulnerability",
+            "dateAdded": "2024-05-30",
+            "shortDescription": "Linux kernel contains a use-after-free vulnerability in the netfilter: nf_tables component that allows an attacker to achieve local privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-06-20",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/git.kernel.org\/pub\/scm\/linux\/kernel\/git\/torvalds\/linux.git\/commit\/?id=f342de4e2f33e0e39165d8639387aa6c19dff660;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-1086",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-24919",
+            "vendorProject": "Check Point",
+            "product": "Quantum Security Gateways",
+            "vulnerabilityName": "Check Point Quantum Security Gateways Information Disclosure Vulnerability",
+            "dateAdded": "2024-05-30",
+            "shortDescription": "Check Point Quantum Security Gateways contain an unspecified information disclosure vulnerability. The vulnerability potentially allows an attacker to access information on Gateways connected to the internet, with IPSec VPN, Remote Access VPN or Mobile Access enabled. This issue affects several product lines from Check Point, including CloudGuard Network, Quantum Scalable Chassis, Quantum Security Gateways, and Quantum Spark Appliances.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-06-20",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/support.checkpoint.com\/results\/sk\/sk182336 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-24919",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-4978",
+            "vendorProject": "Justice AV Solutions",
+            "product": "Viewer ",
+            "vulnerabilityName": "Justice AV Solutions (JAVS) Viewer Installer Embedded Malicious Code Vulnerability",
+            "dateAdded": "2024-05-29",
+            "shortDescription": "Justice AV Solutions (JAVS) Viewer installer contains a malicious version of ffmpeg.exe, named fffmpeg.exe (SHA256: 421a4ad2615941b177b6ec4ab5e239c14e62af2ab07c6df1741e2a62223223c4). When run, this creates a backdoor connection to a malicious C2 server.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-06-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Please follow the vendor\u2019s instructions as outlined in the public statements at https:\/\/www.rapid7.com\/blog\/post\/2024\/05\/23\/cve-2024-4978-backdoored-justice-av-solutions-viewer-software-used-in-apparent-supply-chain-attack#remediation and https:\/\/www.javs.com\/downloads;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-4978",
+            "cwes": [
+                "CWE-506"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-5274",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2024-05-28",
+            "shortDescription": "Google Chromium V8 contains a type confusion vulnerability that allows a remote attacker to execute code via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-06-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2024\/05\/stable-channel-update-for-desktop_23.html?m=1; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-5274",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-17519",
+            "vendorProject": "Apache",
+            "product": "Flink",
+            "vulnerabilityName": "Apache Flink Improper Access Control Vulnerability",
+            "dateAdded": "2024-05-23",
+            "shortDescription": "Apache Flink contains an improper access control vulnerability that allows an attacker to read any file on the local filesystem of the JobManager through its REST interface.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/lists.apache.org\/thread\/typ0h03zyfrzjqlnb7plh64df1g2383d; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-17519",
+            "cwes": [
+                "CWE-552"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-4947",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2024-05-20",
+            "shortDescription": "Google Chromium V8 contains a type confusion vulnerability that allows a remote attacker to execute code via a crafted HTML page.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-06-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2024\/05\/stable-channel-update-for-desktop_15.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-4947",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-43208",
+            "vendorProject": "NextGen Healthcare",
+            "product": "Mirth Connect",
+            "vulnerabilityName": "NextGen Healthcare Mirth Connect Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2024-05-20",
+            "shortDescription": "NextGen Healthcare Mirth Connect contains a deserialization of untrusted data vulnerability that allows for unauthenticated remote code execution via a specially crafted request.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-06-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status.   For more information, please see: https:\/\/github.com\/nextgenhealthcare\/connect\/wiki\/4.4.1---What%27s-New ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-43208",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-4761",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Out-of-Bounds Memory Write Vulnerability",
+            "dateAdded": "2024-05-16",
+            "shortDescription": "Google Chromium V8 Engine contains an unspecified out-of-bounds memory write vulnerability via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera. ",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-06-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2024\/05\/stable-channel-update-for-desktop_13.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-4761",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-40655",
+            "vendorProject": "D-Link",
+            "product": "DIR-605 Router",
+            "vulnerabilityName": "D-Link DIR-605 Router Information Disclosure Vulnerability",
+            "dateAdded": "2024-05-16",
+            "shortDescription": "D-Link DIR-605 routers contain an information disclosure vulnerability that allows attackers to obtain a username and password by forging a post request to the \/getcfg.php page. ",
+            "requiredAction": "This vulnerability affects legacy D-Link products. All associated hardware revisions have reached their end-of-life (EOL) or end-of-service (EOS) life cycle and should be retired and replaced per vendor instructions.",
+            "dueDate": "2024-06-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/legacy.us.dlink.com\/pages\/product.aspx?id=2b09e95d90ff4cb38830ecc04c89cee5; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-40655",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-100005",
+            "vendorProject": "D-Link",
+            "product": "DIR-600 Router",
+            "vulnerabilityName": "D-Link DIR-600 Router Cross-Site Request Forgery (CSRF) Vulnerability",
+            "dateAdded": "2024-05-16",
+            "shortDescription": "D-Link DIR-600 routers contain a cross-site request forgery (CSRF) vulnerability that allows an attacker to change router configurations by hijacking an existing administrator session.",
+            "requiredAction": "This vulnerability affects legacy D-Link products. All associated hardware revisions have reached their end-of-life (EOL) or end-of-service (EOS) life cycle and should be retired and replaced per vendor instructions.",
+            "dueDate": "2024-06-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/legacy.us.dlink.com\/pages\/product.aspx?id=4587b63118524aec911191cc81605283; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-100005",
+            "cwes": [
+                "CWE-352"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-30040",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows MSHTML Platform Security Feature Bypass Vulnerability",
+            "dateAdded": "2024-05-14",
+            "shortDescription": "Microsoft Windows MSHTML Platform contains an unspecified vulnerability that allows for a security feature bypass.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-06-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-30040; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-30040",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-30051",
+            "vendorProject": "Microsoft",
+            "product": "DWM Core Library",
+            "vulnerabilityName": " Microsoft DWM Core Library Privilege Escalation Vulnerability",
+            "dateAdded": "2024-05-14",
+            "shortDescription": "Microsoft DWM Core Library contains a privilege escalation vulnerability that allows an attacker to gain SYSTEM privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-06-04",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-30051; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-30051",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-4671",
+            "vendorProject": "Google",
+            "product": "Chromium",
+            "vulnerabilityName": "Google Chromium Visuals Use-After-Free Vulnerability",
+            "dateAdded": "2024-05-13",
+            "shortDescription": "Google Chromium Visuals contains a use-after-free vulnerability that allows a remote attacker to exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-06-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2024\/05\/stable-channel-update-for-desktop_9.html?m=1; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-4671",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-7028",
+            "vendorProject": "GitLab",
+            "product": "GitLab CE\/EE",
+            "vulnerabilityName": "GitLab Community and Enterprise Editions Improper Access Control Vulnerability",
+            "dateAdded": "2024-05-01",
+            "shortDescription": "GitLab Community and Enterprise Editions contain an improper access control vulnerability. This allows an attacker to trigger password reset emails to be sent to an unverified email address to ultimately facilitate an account takeover.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-05-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/about.gitlab.com\/releases\/2024\/01\/11\/critical-security-release-gitlab-16-7-2-released\/ ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-7028",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-29988",
+            "vendorProject": "Microsoft",
+            "product": "SmartScreen Prompt",
+            "vulnerabilityName": "Microsoft SmartScreen Prompt Security Feature Bypass Vulnerability",
+            "dateAdded": "2024-04-30",
+            "shortDescription": "Microsoft SmartScreen Prompt contains a security feature bypass vulnerability that allows an attacker to bypass the Mark of the Web (MotW) feature. This vulnerability can be chained with CVE-2023-38831 and CVE-2024-21412 to execute a malicious file.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-05-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-29988; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-29988",
+            "cwes": [
+                "CWE-693"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-4040",
+            "vendorProject": "CrushFTP",
+            "product": "CrushFTP",
+            "vulnerabilityName": "CrushFTP VFS Sandbox Escape Vulnerability",
+            "dateAdded": "2024-04-24",
+            "shortDescription": "CrushFTP contains an unspecified sandbox escape vulnerability that allows a remote attacker to escape the CrushFTP virtual file system (VFS).",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-05-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.crushftp.com\/crush11wiki\/Wiki.jsp?page=Update&version=34; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-4040",
+            "cwes": [
+                "CWE-1336"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-20359",
+            "vendorProject": "Cisco",
+            "product": "Adaptive Security Appliance (ASA) and Firepower Threat Defense (FTD)",
+            "vulnerabilityName": "Cisco ASA and FTD Privilege Escalation Vulnerability",
+            "dateAdded": "2024-04-24",
+            "shortDescription": "Cisco Adaptive Security Appliance (ASA) and Firepower Threat Defense (FTD) contain a privilege escalation vulnerability that can allow local privilege escalation from Administrator to root.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-05-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-asaftd-persist-rce-FLsNXF4h;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-20359",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-20353",
+            "vendorProject": "Cisco",
+            "product": "Adaptive Security Appliance (ASA) and Firepower Threat Defense (FTD)",
+            "vulnerabilityName": "Cisco ASA and FTD Denial of Service Vulnerability",
+            "dateAdded": "2024-04-24",
+            "shortDescription": "Cisco Adaptive Security Appliance (ASA) and Firepower Threat Defense (FTD) contain an infinite loop vulnerability that can lead to remote denial of service condition.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-05-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-asaftd-websrvs-dos-X8gNucD2;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-20353",
+            "cwes": [
+                "CWE-835"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-38028",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Print Spooler Privilege Escalation Vulnerability ",
+            "dateAdded": "2024-04-23",
+            "shortDescription": "Microsoft Windows Print Spooler service contains a privilege escalation vulnerability. An attacker may modify a JavaScript constraints file and execute it with SYSTEM-level permissions.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.  ",
+            "dueDate": "2024-05-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2022-38028;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-38028",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2024-3400",
+            "vendorProject": "Palo Alto Networks",
+            "product": "PAN-OS",
+            "vulnerabilityName": "Palo Alto Networks PAN-OS Command Injection Vulnerability",
+            "dateAdded": "2024-04-12",
+            "shortDescription": "Palo Alto Networks PAN-OS GlobalProtect feature contains a command injection vulnerability that allows an unauthenticated attacker to execute commands with root privileges on the firewall.",
+            "requiredAction": "Apply mitigations per vendor instructions as they become available. Otherwise, users with vulnerable versions of affected devices should enable Threat Prevention IDs available from the vendor. See the vendor bulletin for more details and a patch release schedule.",
+            "dueDate": "2024-04-19",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/security.paloaltonetworks.com\/CVE-2024-3400 ;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-3400",
+            "cwes": [
+                "CWE-20",
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-3273",
+            "vendorProject": "D-Link",
+            "product": "Multiple NAS Devices",
+            "vulnerabilityName": "D-Link Multiple NAS Devices Command Injection Vulnerability",
+            "dateAdded": "2024-04-11",
+            "shortDescription": "D-Link DNS-320L, DNS-325, DNS-327L, and DNS-340L contain a command injection vulnerability. When combined with CVE-2024-3272, this can lead to remote, unauthorized code execution.",
+            "requiredAction": "This vulnerability affects legacy D-Link products. All associated hardware revisions have reached their end-of-life (EOL) or end-of-service (EOS) life cycle and should be retired and replaced per vendor instructions.",
+            "dueDate": "2024-05-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportannouncement.us.dlink.com\/security\/publication.aspx?name=SAP10383; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-3273",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-3272",
+            "vendorProject": "D-Link",
+            "product": "Multiple NAS Devices",
+            "vulnerabilityName": "D-Link Multiple NAS Devices Use of Hard-Coded Credentials Vulnerability",
+            "dateAdded": "2024-04-11",
+            "shortDescription": "D-Link DNS-320L, DNS-325, DNS-327L, and DNS-340L contains a hard-coded credential that allows an attacker to conduct authenticated command injection, leading to remote, unauthorized code execution.",
+            "requiredAction": "This vulnerability affects legacy D-Link products. All associated hardware revisions have reached their end-of-life (EOL) or end-of-service (EOS) life cycle and should be retired and replaced per vendor instructions.",
+            "dueDate": "2024-05-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportannouncement.us.dlink.com\/security\/publication.aspx?name=SAP10383; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-3272",
+            "cwes": [
+                "CWE-798"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-29748",
+            "vendorProject": "Android",
+            "product": "Pixel",
+            "vulnerabilityName": "Android Pixel Privilege Escalation Vulnerability",
+            "dateAdded": "2024-04-04",
+            "shortDescription": "Android Pixel contains a privilege escalation vulnerability that allows an attacker to interrupt a factory reset triggered by a device admin app.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-04-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/source.android.com\/docs\/security\/bulletin\/pixel\/2024-04-01; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-29748",
+            "cwes": [
+                "CWE-280"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-29745",
+            "vendorProject": "Android",
+            "product": "Pixel",
+            "vulnerabilityName": "Android Pixel Information Disclosure Vulnerability",
+            "dateAdded": "2024-04-04",
+            "shortDescription": "Android Pixel contains an information disclosure vulnerability in the fastboot firmware used to support unlocking, flashing, and locking affected devices.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-04-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/source.android.com\/docs\/security\/bulletin\/pixel\/2024-04-01 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-29745",
+            "cwes": [
+                "CWE-908"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-24955",
+            "vendorProject": "Microsoft",
+            "product": "SharePoint Server",
+            "vulnerabilityName": "Microsoft SharePoint Server Code Injection Vulnerability",
+            "dateAdded": "2024-03-26",
+            "shortDescription": "Microsoft SharePoint Server contains a code injection vulnerability that allows an authenticated attacker with Site Owner privileges to execute code remotely.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-04-16",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2023-24955;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-24955",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-7256",
+            "vendorProject": "Nice",
+            "product": "Linear eMerge E3-Series",
+            "vulnerabilityName": "Nice Linear eMerge E3-Series OS Command Injection Vulnerability",
+            "dateAdded": "2024-03-25",
+            "shortDescription": "Nice Linear eMerge E3-Series contains an OS command injection vulnerability that allows an attacker to conduct remote code execution.",
+            "requiredAction": "Contact the vendor for guidance on remediating firmware, per their advisory.",
+            "dueDate": "2024-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/linear-solutions.com\/wp-content\/uploads\/E3-Bulletin-06-27-2023.pdf, https:\/\/www.cisa.gov\/news-events\/ics-advisories\/icsa-24-065-01; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-7256",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-44529",
+            "vendorProject": "Ivanti",
+            "product": "Endpoint Manager Cloud Service Appliance (EPM CSA)",
+            "vulnerabilityName": "Ivanti Endpoint Manager Cloud Service Appliance (EPM CSA) Code Injection Vulnerability ",
+            "dateAdded": "2024-03-25",
+            "shortDescription": "Ivanti Endpoint Manager Cloud Service Appliance (EPM CSA) contains a code injection vulnerability that allows an unauthenticated user to execute malicious code with limited permissions (nobody).",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-04-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/SA-2021-12-02?language=en_US; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-44529",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-48788",
+            "vendorProject": "Fortinet",
+            "product": "FortiClient EMS",
+            "vulnerabilityName": "Fortinet FortiClient EMS SQL Injection Vulnerability",
+            "dateAdded": "2024-03-25",
+            "shortDescription": "Fortinet FortiClient EMS contains a SQL injection vulnerability that allows an unauthenticated attacker to execute commands as SYSTEM via specifically crafted requests.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-04-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.fortiguard.com\/psirt\/FG-IR-24-007;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-48788",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-27198",
+            "vendorProject": "JetBrains",
+            "product": "TeamCity",
+            "vulnerabilityName": "JetBrains TeamCity Authentication Bypass Vulnerability",
+            "dateAdded": "2024-03-07",
+            "shortDescription": "JetBrains TeamCity contains an authentication bypass vulnerability that allows an attacker to perform admin actions.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-03-28",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.jetbrains.com\/help\/teamcity\/teamcity-2023-11-4-release-notes.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-27198",
+            "cwes": [
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-23225",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Memory Corruption Vulnerability",
+            "dateAdded": "2024-03-06",
+            "shortDescription": "Apple iOS, iPadOS, macOS, tvOS, watchOS, and visionOS kernel contain a memory corruption vulnerability that allows an attacker with arbitrary kernel read and write capability to bypass kernel memory protections.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-03-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT214081, https:\/\/support.apple.com\/en-us\/HT214082, https:\/\/support.apple.com\/en-us\/HT214083, https:\/\/support.apple.com\/en-us\/HT214084, https:\/\/support.apple.com\/en-us\/HT214085, https:\/\/support.apple.com\/en-us\/HT214086, https:\/\/support.apple.com\/en-us\/HT214087, https:\/\/support.apple.com\/en-us\/HT214088 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-23225",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-23296",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Memory Corruption Vulnerability",
+            "dateAdded": "2024-03-06",
+            "shortDescription": "Apple iOS, iPadOS, macOS, tvOS, and watchOS RTKit contain a memory corruption vulnerability that allows an attacker with arbitrary kernel read and write capability to bypass kernel memory protections.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-03-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT214081, https:\/\/support.apple.com\/en-us\/HT214082, https:\/\/support.apple.com\/en-us\/HT214084, https:\/\/support.apple.com\/en-us\/HT214086, https:\/\/support.apple.com\/en-us\/HT214088  ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-23296",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-21237",
+            "vendorProject": "Android",
+            "product": "Pixel",
+            "vulnerabilityName": "Android Pixel Information Disclosure Vulnerability ",
+            "dateAdded": "2024-03-05",
+            "shortDescription": "Android Pixel contains a vulnerability in the Framework component, where the UI may be misleading or insufficient, providing a means to hide a foreground service notification. This could enable a local attacker to disclose sensitive information.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-03-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/source.android.com\/docs\/security\/bulletin\/pixel\/2023-06-01;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-21237",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-36380",
+            "vendorProject": "Sunhillo",
+            "product": "SureLine",
+            "vulnerabilityName": "Sunhillo SureLine OS Command Injection Vulnerablity",
+            "dateAdded": "2024-03-05",
+            "shortDescription": "Sunhillo SureLine contains an OS command injection vulnerability that allows an attacker to cause a denial-of-service or utilize the device for persistence on the network via shell metacharacters in ipAddr or dnsAddr in \/cgi\/networkDiag.cgi.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-03-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.sunhillo.com\/fb011\/; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-36380",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-21338",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Exposed IOCTL with Insufficient Access Control Vulnerability",
+            "dateAdded": "2024-03-04",
+            "shortDescription": "Microsoft Windows Kernel contains an exposed IOCTL with insufficient access control vulnerability within the IOCTL (input and output control) dispatcher in appid.sys that allows a local attacker to achieve privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-03-25",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-21338; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-21338",
+            "cwes": [
+                "CWE-822"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-29360",
+            "vendorProject": "Microsoft",
+            "product": "Streaming Service",
+            "vulnerabilityName": "Microsoft Streaming Service Untrusted Pointer Dereference Vulnerability",
+            "dateAdded": "2024-02-29",
+            "shortDescription": "Microsoft Streaming Service contains an untrusted pointer dereference vulnerability that allows for privilege escalation, enabling a local attacker to gain SYSTEM privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-03-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2023-29360 ;https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-29360",
+            "cwes": [
+                "CWE-822"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-1709",
+            "vendorProject": "ConnectWise",
+            "product": "ScreenConnect",
+            "vulnerabilityName": "ConnectWise ScreenConnect Authentication Bypass Vulnerability",
+            "dateAdded": "2024-02-22",
+            "shortDescription": "ConnectWise ScreenConnect contains an authentication bypass vulnerability that allows an attacker with network access to the management interface to create a new, administrator-level account on affected devices.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-02-29",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.connectwise.com\/company\/trust\/security-bulletins\/connectwise-screenconnect-23.9.8; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-1709",
+            "cwes": [
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3259",
+            "vendorProject": "Cisco",
+            "product": "Adaptive Security Appliance (ASA) and Firepower Threat Defense (FTD)",
+            "vulnerabilityName": "Cisco ASA and FTD Information Disclosure Vulnerability",
+            "dateAdded": "2024-02-15",
+            "shortDescription": "Cisco Adaptive Security Appliance (ASA) and Firepower Threat Defense (FTD) contain an information disclosure vulnerability. An attacker could retrieve memory contents on an affected device, which could lead to the disclosure of confidential information due to a buffer tracking issue when the software parses invalid URLs that are requested from the web services interface. This vulnerability affects only specific AnyConnect and WebVPN configurations.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-03-07",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/tools.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-asaftd-info-disclose-9eJtycMB; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3259",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-21410",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Privilege Escalation Vulnerability",
+            "dateAdded": "2024-02-15",
+            "shortDescription": "Microsoft Exchange Server contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-03-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2024-21410; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-21410",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-21412",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Internet Shortcut Files Security Feature Bypass Vulnerability",
+            "dateAdded": "2024-02-13",
+            "shortDescription": "Microsoft Windows Internet Shortcut Files contains an unspecified vulnerability that allows for a security feature bypass.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-03-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2024-21412; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-21412",
+            "cwes": [
+                "CWE-693"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-21351",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows SmartScreen Security Feature Bypass Vulnerability",
+            "dateAdded": "2024-02-13",
+            "shortDescription": "Microsoft Windows SmartScreen contains a security feature bypass vulnerability that allows an attacker to bypass the SmartScreen user experience and inject code to potentially gain code execution, which could lead to some data exposure, lack of system availability, or both.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-03-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2024-21351; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-21351",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-43770",
+            "vendorProject": "Roundcube",
+            "product": "Webmail",
+            "vulnerabilityName": "Roundcube Webmail Persistent Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2024-02-12",
+            "shortDescription": "Roundcube Webmail contains a persistent cross-site scripting (XSS) vulnerability that can lead to information disclosure via malicious link references in plain\/text messages.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-03-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/roundcube.net\/news\/2023\/09\/15\/security-update-1.6.3-released ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-43770",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-21762",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS",
+            "vulnerabilityName": "Fortinet FortiOS Out-of-Bound Write Vulnerability",
+            "dateAdded": "2024-02-09",
+            "shortDescription": "Fortinet FortiOS contains an out-of-bound write vulnerability that allows a remote unauthenticated attacker to execute code or commands via specially crafted HTTP requests.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-02-16",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/fortiguard.fortinet.com\/psirt\/FG-IR-24-015 ;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-21762",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-4762",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2024-02-06",
+            "shortDescription": "Google Chromium V8 contains a type confusion vulnerability that allows a remote attacker to execute code via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-02-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2023\/09\/stable-channel-update-for-desktop.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-4762",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-48618",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Memory Corruption Vulnerability",
+            "dateAdded": "2024-01-31",
+            "shortDescription": "Apple iOS, iPadOS, macOS, tvOS, and watchOS contain a time-of-check\/time-of-use (TOCTOU) memory corruption vulnerability that allows an attacker with read and write capabilities to bypass Pointer Authentication.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-02-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213530, https:\/\/support.apple.com\/en-us\/HT213532, https:\/\/support.apple.com\/en-us\/HT213535, https:\/\/support.apple.com\/en-us\/HT213536;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-48618",
+            "cwes": [
+                "CWE-367"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-21893",
+            "vendorProject": "Ivanti",
+            "product": "Connect Secure, Policy Secure, and Neurons",
+            "vulnerabilityName": "Ivanti Connect Secure, Policy Secure, and Neurons Server-Side Request Forgery (SSRF) Vulnerability",
+            "dateAdded": "2024-01-31",
+            "shortDescription": "Ivanti Connect Secure (ICS, formerly known as Pulse Connect Secure), Ivanti Policy Secure, and Ivanti Neurons contain a server-side request forgery (SSRF) vulnerability in the SAML component that allows an attacker to access certain restricted resources without authentication.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-02-02",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/KB-CVE-2023-46805-Authentication-Bypass-CVE-2024-21887-Command-Injection-for-Ivanti-Connect-Secure-and-Ivanti-Policy-Secure-Gateways?language=en_US ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-21893",
+            "cwes": [
+                "CWE-918"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-22527",
+            "vendorProject": "Atlassian",
+            "product": "Confluence Data Center and Server",
+            "vulnerabilityName": "Atlassian Confluence Data Center and Server Template Injection Vulnerability",
+            "dateAdded": "2024-01-24",
+            "shortDescription": "Atlassian Confluence Data Center and Server contain an unauthenticated OGNL template injection vulnerability that can lead to remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-02-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/confluence.atlassian.com\/security\/cve-2023-22527-rce-remote-code-execution-vulnerability-in-confluence-data-center-and-confluence-server-1333990257.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-22527",
+            "cwes": [
+                "CWE-74"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-23222",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Type Confusion Vulnerability",
+            "dateAdded": "2024-01-23",
+            "shortDescription": "Apple iOS, iPadOS, macOS, tvOS, and Safari WebKit contain a type confusion vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-02-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT214055,  https:\/\/support.apple.com\/en-us\/HT214056, https:\/\/support.apple.com\/en-us\/HT214057, https:\/\/support.apple.com\/en-us\/HT214058, https:\/\/support.apple.com\/en-us\/HT214059, https:\/\/support.apple.com\/en-us\/HT214061, https:\/\/support.apple.com\/en-us\/HT214063 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-23222",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-34048",
+            "vendorProject": "VMware",
+            "product": "vCenter Server",
+            "vulnerabilityName": "VMware vCenter Server Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2024-01-22",
+            "shortDescription": "VMware vCenter Server contains an out-of-bounds write vulnerability in the implementation of the DCERPC protocol that allows an attacker to conduct remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-02-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.vmware.com\/security\/advisories\/VMSA-2023-0023.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-34048",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-35082",
+            "vendorProject": "Ivanti",
+            "product": "Endpoint Manager Mobile (EPMM) and MobileIron Core",
+            "vulnerabilityName": "Ivanti Endpoint Manager Mobile (EPMM) and MobileIron Core Authentication Bypass Vulnerability",
+            "dateAdded": "2024-01-18",
+            "shortDescription": "Ivanti Endpoint Manager Mobile (EPMM) and MobileIron Core contain an authentication bypass vulnerability that allows unauthorized users to access restricted functionality or resources of the application.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-02-08",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/CVE-2023-35082-Remote-Unauthenticated-API-Access-Vulnerability-in-MobileIron-Core-11-2-and-older;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-35082",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-0519",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Out-of-Bounds Memory Access Vulnerability",
+            "dateAdded": "2024-01-17",
+            "shortDescription": "Google Chromium V8 Engine contains an out-of-bounds memory access vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-02-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2024\/01\/stable-channel-update-for-desktop_16.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-0519",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-6549",
+            "vendorProject": "Citrix",
+            "product": "NetScaler ADC and NetScaler Gateway",
+            "vulnerabilityName": "Citrix NetScaler ADC and NetScaler Gateway Buffer Overflow Vulnerability",
+            "dateAdded": "2024-01-17",
+            "shortDescription": "Citrix NetScaler ADC and NetScaler Gateway contain a buffer overflow vulnerability that allows for a denial-of-service when configured as a Gateway (VPN virtual server, ICA Proxy, CVPN, RDP Proxy) or AAA virtual server.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-02-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.citrix.com\/article\/CTX584986\/netscaler-adc-and-netscaler-gateway-security-bulletin-for-cve20236548-and-cve20236549;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-6549",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-6548",
+            "vendorProject": "Citrix",
+            "product": "NetScaler ADC and NetScaler Gateway",
+            "vulnerabilityName": "Citrix NetScaler ADC and NetScaler Gateway Code Injection Vulnerability",
+            "dateAdded": "2024-01-17",
+            "shortDescription": "Citrix NetScaler ADC and NetScaler Gateway contain a code injection vulnerability that allows for authenticated remote code execution on the management interface with access to NSIP, CLIP, or SNIP.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.citrix.com\/article\/CTX584986\/netscaler-adc-and-netscaler-gateway-security-bulletin-for-cve20236548-and-cve20236549;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-6548",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-15133",
+            "vendorProject": "Laravel",
+            "product": "Laravel Framework",
+            "vulnerabilityName": "Laravel Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2024-01-16",
+            "shortDescription": "Laravel Framework contains a deserialization of untrusted data vulnerability, allowing for remote command execution. This vulnerability may only be exploited if a malicious user has accessed the application encryption key (APP_KEY environment variable).",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-02-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/laravel.com\/docs\/5.6\/upgrade#upgrade-5.6.30; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-15133",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-29357",
+            "vendorProject": "Microsoft",
+            "product": "SharePoint Server",
+            "vulnerabilityName": "Microsoft SharePoint Server Privilege Escalation Vulnerability",
+            "dateAdded": "2024-01-10",
+            "shortDescription": "Microsoft SharePoint Server contains an unspecified vulnerability that allows an unauthenticated attacker, who has gained access to spoofed JWT authentication tokens, to use them for executing a network attack. This attack bypasses authentication, enabling the attacker to gain administrator privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-31",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2023-29357; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-29357",
+            "cwes": [
+                "CWE-303"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-46805",
+            "vendorProject": "Ivanti",
+            "product": "Connect Secure and Policy Secure",
+            "vulnerabilityName": "Ivanti Connect Secure and Policy Secure Authentication Bypass Vulnerability",
+            "dateAdded": "2024-01-10",
+            "shortDescription": "Ivanti Connect Secure (ICS, formerly known as Pulse Connect Secure) and Ivanti Policy Secure gateways contain an authentication bypass vulnerability in the web component that allows an attacker to access restricted resources by bypassing control checks. This vulnerability can be leveraged in conjunction with CVE-2024-21887, a command injection vulnerability.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-22",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Please apply mitigations per vendor instructions. For more information, please see: https:\/\/forums.ivanti.com\/s\/article\/KB-CVE-2023-46805-Authentication-Bypass-CVE-2024-21887-Command-Injection-for-Ivanti-Connect-Secure-and-Ivanti-Policy-Secure-Gateways?language=en_US ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-46805",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2024-21887",
+            "vendorProject": "Ivanti",
+            "product": "Connect Secure and Policy Secure",
+            "vulnerabilityName": "Ivanti Connect Secure and Policy Secure Command Injection Vulnerability",
+            "dateAdded": "2024-01-10",
+            "shortDescription": "Ivanti Connect Secure (ICS, formerly known as Pulse Connect Secure) and Ivanti Policy Secure contain a command injection vulnerability in the web components of these products, which can allow an authenticated administrator to send crafted requests to execute code on affected appliances. This vulnerability can be leveraged in conjunction with CVE-2023-46805, an authenticated bypass issue.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-22",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Please apply mitigations per vendor instructions. For more information, please see: https:\/\/forums.ivanti.com\/s\/article\/KB-CVE-2023-46805-Authentication-Bypass-CVE-2024-21887-Command-Injection-for-Ivanti-Connect-Secure-and-Ivanti-Policy-Secure-Gateways?language=en_US ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2024-21887",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-23752",
+            "vendorProject": "Joomla!",
+            "product": "Joomla!",
+            "vulnerabilityName": "Joomla! Improper Access Control Vulnerability",
+            "dateAdded": "2024-01-08",
+            "shortDescription": "Joomla! contains an improper access control vulnerability that allows unauthorized access to webservice endpoints.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/developer.joomla.org\/security-centre\/894-20230201-core-improper-access-check-in-webservice-endpoints.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-23752",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-20017",
+            "vendorProject": "D-Link",
+            "product": "DSL-2750B Devices",
+            "vulnerabilityName": "D-Link DSL-2750B Devices Command Injection Vulnerability",
+            "dateAdded": "2024-01-08",
+            "shortDescription": "D-Link DSL-2750B devices contain a command injection vulnerability that allows remote, unauthenticated command injection via the login.cgi cli parameter.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportannouncement.us.dlink.com\/announcement\/publication.aspx?name=SAP10088; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-20017",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-41990",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Code Execution Vulnerability",
+            "dateAdded": "2024-01-08",
+            "shortDescription": "Apple iOS, iPadOS, macOS, tvOS, and watchOS contain an unspecified vulnerability that allows for code execution when processing a font file.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213599, https:\/\/support.apple.com\/en-us\/HT213601, https:\/\/support.apple.com\/en-us\/HT213605, https:\/\/support.apple.com\/en-us\/HT213606, https:\/\/support.apple.com\/en-us\/HT213842, https:\/\/support.apple.com\/en-us\/HT213844, https:\/\/support.apple.com\/en-us\/HT213845 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-41990",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-27524",
+            "vendorProject": "Apache",
+            "product": "Superset",
+            "vulnerabilityName": "Apache Superset Insecure Default Initialization of Resource Vulnerability",
+            "dateAdded": "2024-01-08",
+            "shortDescription": "Apache Superset contains an insecure default initialization of a resource vulnerability that allows an attacker to authenticate and access unauthorized resources on installations that have not altered the default configured SECRET_KEY according to installation instructions.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/lists.apache.org\/thread\/n0ftx60sllf527j7g11kmt24wvof8xyk;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-27524",
+            "cwes": [
+                "CWE-1188"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-29300",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2024-01-08",
+            "shortDescription": "Adobe ColdFusion contains a deserialization of untrusted data vulnerability that allows for code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-29",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/helpx.adobe.com\/security\/products\/coldfusion\/apsb23-40.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-29300",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-38203",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2024-01-08",
+            "shortDescription": "Adobe ColdFusion contains a deserialization of untrusted data vulnerability that allows for code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-29",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/helpx.adobe.com\/security\/products\/coldfusion\/apsb23-41.html ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-38203",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-7101",
+            "vendorProject": "Spreadsheet::ParseExcel",
+            "product": "Spreadsheet::ParseExcel",
+            "vulnerabilityName": "Spreadsheet::ParseExcel Remote Code Execution Vulnerability",
+            "dateAdded": "2024-01-02",
+            "shortDescription": "Spreadsheet::ParseExcel contains a remote code execution vulnerability due to passing unvalidated input from a file into a string-type \u201ceval\u201d. Specifically, the issue stems from the evaluation of Number format strings within the Excel parsing logic.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/metacpan.org\/dist\/Spreadsheet-ParseExcel and Barracuda's specific implementation and fix for their downstream issue CVE-2023-7102 at https:\/\/www.barracuda.com\/company\/legal\/esg-vulnerability;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-7101",
+            "cwes": [
+                "CWE-95"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-7024",
+            "vendorProject": "Google",
+            "product": "Chromium WebRTC",
+            "vulnerabilityName": "Google Chromium WebRTC Heap Buffer Overflow Vulnerability",
+            "dateAdded": "2024-01-02",
+            "shortDescription": "Google Chromium WebRTC, an open-source project providing web browsers with real-time communication, contains a heap buffer overflow vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could impact web browsers using WebRTC, including but not limited to Google Chrome.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/chromereleases.googleblog.com\/2023\/12\/stable-channel-update-for-desktop_20.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-7024",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-49897",
+            "vendorProject": "FXC",
+            "product": "AE1021, AE1021PE",
+            "vulnerabilityName": "FXC AE1021, AE1021PE OS Command Injection Vulnerability",
+            "dateAdded": "2023-12-21",
+            "shortDescription": "FXC AE1021 and AE1021PE contain an OS command injection vulnerability that allows authenticated users to execute commands via a network.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.fxc.jp\/news\/20231206 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-49897",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-47565",
+            "vendorProject": "QNAP",
+            "product": "VioStor NVR",
+            "vulnerabilityName": "QNAP VioStor NVR OS Command Injection Vulnerability",
+            "dateAdded": "2023-12-21",
+            "shortDescription": "QNAP VioStar NVR contains an OS command injection vulnerability that allows authenticated users to execute commands via a network.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2024-01-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.qnap.com\/en\/security-advisory\/qsa-23-48 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-47565",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-6448",
+            "vendorProject": "Unitronics",
+            "product": "Vision PLC and HMI",
+            "vulnerabilityName": "Unitronics Vision PLC and HMI Insecure Default Password Vulnerability",
+            "dateAdded": "2023-12-11",
+            "shortDescription": "Unitronics Vision Series PLCs and HMIs ship with an insecure default password, which if left unchanged, can allow attackers to execute remote commands.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-12-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Note that while it is possible to change the default password, implementors are encouraged to remove affected controllers from public networks and update the affected firmware: https:\/\/downloads.unitronicsplc.com\/Sites\/plc\/Technical_Library\/Unitronics-Cybersecurity-Advisory-2023-001-CVE-2023-6448.pdf;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-6448",
+            "cwes": [
+                "CWE-1188"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-41266",
+            "vendorProject": "Qlik",
+            "product": "Sense",
+            "vulnerabilityName": "Qlik Sense Path Traversal Vulnerability",
+            "dateAdded": "2023-12-07",
+            "shortDescription": "Qlik Sense contains a path traversal vulnerability that allows a remote, unauthenticated attacker to create an anonymous session by sending maliciously crafted HTTP requests. This anonymous session could allow the attacker to send further requests to unauthorized endpoints.",
+            "requiredAction": "Apply remediations or mitigations per vendor instructions or discontinue use of the product if remediation or mitigations are unavailable.",
+            "dueDate": "2023-12-28",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/community.qlik.com\/t5\/Official-Support-Articles\/Critical-Security-fixes-for-Qlik-Sense-Enterprise-for-Windows\/ta-p\/2110801  ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-41266",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-41265",
+            "vendorProject": "Qlik",
+            "product": "Sense",
+            "vulnerabilityName": "Qlik Sense HTTP Tunneling Vulnerability",
+            "dateAdded": "2023-12-07",
+            "shortDescription": "Qlik Sense contains an HTTP tunneling vulnerability that allows an attacker to escalate privileges and execute HTTP requests on the backend server hosting the software.",
+            "requiredAction": "Apply remediations or mitigations per vendor instructions or discontinue use of the product if remediation or mitigations are unavailable.",
+            "dueDate": "2023-12-28",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/community.qlik.com\/t5\/Official-Support-Articles\/Critical-Security-fixes-for-Qlik-Sense-Enterprise-for-Windows\/ta-p\/2110801;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-41265",
+            "cwes": [
+                "CWE-444"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-33107",
+            "vendorProject": "Qualcomm",
+            "product": "Multiple Chipsets",
+            "vulnerabilityName": "Qualcomm Multiple Chipsets Integer Overflow Vulnerability",
+            "dateAdded": "2023-12-05",
+            "shortDescription": "Multiple Qualcomm chipsets contain an integer overflow vulnerability due to memory corruption in Graphics Linux while assigning shared virtual memory region during IOCTL call.",
+            "requiredAction": "Apply remediations or mitigations per vendor instructions or discontinue use of the product if remediation or mitigations are unavailable.",
+            "dueDate": "2023-12-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/git.codelinaro.org\/clo\/la\/kernel\/msm-4.19\/-\/commit\/d66b799c804083ea5226cfffac6d6c4e7ad4968b;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-33107",
+            "cwes": [
+                "CWE-190"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-33106",
+            "vendorProject": "Qualcomm",
+            "product": "Multiple Chipsets",
+            "vulnerabilityName": "Qualcomm Multiple Chipsets Use of Out-of-Range Pointer Offset Vulnerability",
+            "dateAdded": "2023-12-05",
+            "shortDescription": "Multiple Qualcomm chipsets contain a use of out-of-range pointer offset vulnerability due to memory corruption in Graphics while submitting a large list of sync points in an AUX command to the IOCTL_KGSL_GPU_AUX_COMMAND.",
+            "requiredAction": "Apply remediations or mitigations per vendor instructions or discontinue use of the product if remediation or mitigations are unavailable.",
+            "dueDate": "2023-12-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/git.codelinaro.org\/clo\/la\/kernel\/msm-4.19\/-\/commit\/1e46e81dbeb69aafd5842ce779f07e617680fd58;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-33106",
+            "cwes": [
+                "CWE-823"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-33063",
+            "vendorProject": "Qualcomm",
+            "product": "Multiple Chipsets",
+            "vulnerabilityName": "Qualcomm Multiple Chipsets Use-After-Free Vulnerability",
+            "dateAdded": "2023-12-05",
+            "shortDescription": "Multiple Qualcomm chipsets contain a use-after-free vulnerability due to memory corruption in DSP Services during a remote call from HLOS to DSP.",
+            "requiredAction": "Apply remediations or mitigations per vendor instructions or discontinue use of the product if remediation or mitigations are unavailable.",
+            "dueDate": "2023-12-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/git.codelinaro.org\/clo\/la\/kernel\/msm-5.15\/-\/commit\/2643808ddbedfaabbb334741873fb2857f78188a, https:\/\/git.codelinaro.org\/clo\/la\/kernel\/msm-4.14\/-\/commit\/d43222efda5a01c9804d74a541e3c1be9b7fe110;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-33063",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22071",
+            "vendorProject": "Qualcomm",
+            "product": "Multiple Chipsets",
+            "vulnerabilityName": "Qualcomm Multiple Chipsets Use-After-Free Vulnerability",
+            "dateAdded": "2023-12-05",
+            "shortDescription": "Multiple Qualcomm chipsets contain a use-after-free vulnerability when process shell memory is freed using IOCTL munmap call and process initialization is in progress.",
+            "requiredAction": "Apply remediations or mitigations per vendor instructions or discontinue use of the product if remediation or mitigations are unavailable.",
+            "dueDate": "2023-12-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/git.codelinaro.org\/clo\/la\/kernel\/msm-5.4\/-\/commit\/586840fde350d7b8563df9889c8ce397e2c20dda;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22071",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-42917",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Memory Corruption Vulnerability",
+            "dateAdded": "2023-12-04",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and Safari WebKit contain a memory corruption vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply remediations or mitigations per vendor instructions or discontinue use of the product if remediation or mitigations are unavailable.",
+            "dueDate": "2023-12-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT214031, https:\/\/support.apple.com\/en-us\/HT214032, https:\/\/support.apple.com\/en-us\/HT214033 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-42917",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-42916",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Out-of-Bounds Read Vulnerability",
+            "dateAdded": "2023-12-04",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and Safari WebKit contain an out-of-bounds read vulnerability that may disclose sensitive information when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply remediations or mitigations per vendor instructions or discontinue use of the product if remediation or mitigations are unavailable.",
+            "dueDate": "2023-12-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT214031, https:\/\/support.apple.com\/en-us\/HT214032, https:\/\/support.apple.com\/en-us\/HT214033 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-42916",
+            "cwes": [
+                "CWE-125"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-6345",
+            "vendorProject": "Google",
+            "product": "Chromium Skia",
+            "vulnerabilityName": "Google Skia Integer Overflow Vulnerability",
+            "dateAdded": "2023-11-30",
+            "shortDescription": "Google Chromium Skia contains an integer overflow vulnerability that allows a remote attacker, who has compromised the renderer process, to potentially perform a sandbox escape via a malicious file. This vulnerability affects Google Chrome and ChromeOS, Android, Flutter, and possibly other products.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-12-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/chromereleases.googleblog.com\/2023\/11\/stable-channel-update-for-desktop_28.html ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-6345",
+            "cwes": [
+                "CWE-190"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-49103",
+            "vendorProject": "ownCloud",
+            "product": "ownCloud graphapi",
+            "vulnerabilityName": "ownCloud graphapi Information Disclosure Vulnerability",
+            "dateAdded": "2023-11-30",
+            "shortDescription": "ownCloud graphapi contains an information disclosure vulnerability that can reveal sensitive data stored in phpinfo() via GetPhpInfo.php, including administrative credentials.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-12-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/owncloud.com\/security-advisories\/disclosure-of-sensitive-credentials-and-configuration-in-containerized-deployments\/ ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-49103",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-4911",
+            "vendorProject": "GNU",
+            "product": "GNU C Library",
+            "vulnerabilityName": "GNU C Library Buffer Overflow Vulnerability",
+            "dateAdded": "2023-11-21",
+            "shortDescription": "GNU C Library's dynamic loader ld.so contains a buffer overflow vulnerability when processing the GLIBC_TUNABLES environment variable, allowing a local attacker to execute code with elevated privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-12-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on patching status. For more information, please see: https:\/\/sourceware.org\/git\/?p=glibc.git;a=commitdiff;h=1056e5b4c3f2d90ed2b4a55f96add28da2f4c8fa, https:\/\/access.redhat.com\/security\/cve\/cve-2023-4911, https:\/\/www.debian.org\/security\/2023\/dsa-5514 ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-4911  ",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-36584",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Mark of the Web (MOTW) Security Feature Bypass Vulnerability",
+            "dateAdded": "2023-11-16",
+            "shortDescription": "Microsoft Windows Mark of the Web (MOTW) contains a security feature bypass vulnerability resulting in a limited loss of integrity and availability of security features.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-12-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2023-36584 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36584",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-1671",
+            "vendorProject": "Sophos",
+            "product": "Web Appliance",
+            "vulnerabilityName": "Sophos Web Appliance Command Injection Vulnerability",
+            "dateAdded": "2023-11-16",
+            "shortDescription": "Sophos Web Appliance contains a command injection vulnerability in the warn-proceed handler that allows for remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-12-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.sophos.com\/en-us\/security-advisories\/sophos-sa-20230404-swa-rce;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-1671",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-2551",
+            "vendorProject": "Oracle",
+            "product": "Fusion Middleware",
+            "vulnerabilityName": "Oracle Fusion Middleware Unspecified Vulnerability",
+            "dateAdded": "2023-11-16",
+            "shortDescription": "Oracle Fusion Middleware contains an unspecified vulnerability in the WLS Core Components that allows an unauthenticated attacker with network access via IIOP to compromise the WebLogic Server.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-12-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/cpujan2020.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-2551",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-36033",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Desktop Window Manager (DWM) Core Library Privilege Escalation Vulnerability",
+            "dateAdded": "2023-11-14",
+            "shortDescription": "Microsoft Windows Desktop Window Manager (DWM) Core Library contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-12-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-36033 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36033",
+            "cwes": [
+                "CWE-822"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-36025",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows SmartScreen Security Feature Bypass Vulnerability",
+            "dateAdded": "2023-11-14",
+            "shortDescription": "Microsoft Windows SmartScreen contains a security feature bypass vulnerability that could allow an attacker to bypass Windows Defender SmartScreen checks and their associated prompts.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-12-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-36025;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36025",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-36036",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Cloud Files Mini Filter Driver Privilege Escalation Vulnerability",
+            "dateAdded": "2023-11-14",
+            "shortDescription": "Microsoft Windows Cloud Files Mini Filter Driver contains a privilege escalation vulnerability that could allow an attacker to gain SYSTEM privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-12-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-36036 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36036",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-47246",
+            "vendorProject": "SysAid",
+            "product": "SysAid Server",
+            "vulnerabilityName": "SysAid Server Path Traversal Vulnerability",
+            "dateAdded": "2023-11-13",
+            "shortDescription": "SysAid Server (on-premises version) contains a path traversal vulnerability that leads to code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-12-04",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.sysaid.com\/blog\/service-desk\/on-premise-software-security-vulnerability-notification; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-47246",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-36844",
+            "vendorProject": "Juniper",
+            "product": "Junos OS",
+            "vulnerabilityName": "Juniper Junos OS EX Series PHP External Variable Modification Vulnerability",
+            "dateAdded": "2023-11-13",
+            "shortDescription": "Juniper Junos OS on EX Series contains a PHP external variable modification vulnerability that allows an unauthenticated, network-based attacker to control certain, important environment variables. Using a crafted request an attacker is able to modify certain PHP environment variables, leading to partial loss of integrity, which may allow chaining to other vulnerabilities.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportportal.juniper.net\/s\/article\/2023-08-Out-of-Cycle-Security-Bulletin-Junos-OS-SRX-Series-and-EX-Series-Multiple-vulnerabilities-in-J-Web-can-be-combined-to-allow-a-preAuth-Remote-Code-Execution?language=en_US ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36844",
+            "cwes": [
+                "CWE-473"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-36845",
+            "vendorProject": "Juniper",
+            "product": "Junos OS",
+            "vulnerabilityName": "Juniper Junos OS EX Series and SRX Series PHP External Variable Modification Vulnerability",
+            "dateAdded": "2023-11-13",
+            "shortDescription": "Juniper Junos OS on EX Series and SRX Series contains a PHP external variable modification vulnerability that allows an unauthenticated, network-based attacker to control an important environment variable. Using a crafted request, which sets the variable PHPRC, an attacker is able to modify the PHP execution environment allowing the injection und execution of code.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportportal.juniper.net\/s\/article\/2023-08-Out-of-Cycle-Security-Bulletin-Junos-OS-SRX-Series-and-EX-Series-Multiple-vulnerabilities-in-J-Web-can-be-combined-to-allow-a-preAuth-Remote-Code-Execution?language=en_US ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36845",
+            "cwes": [
+                "CWE-473"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-36846",
+            "vendorProject": "Juniper",
+            "product": "Junos OS",
+            "vulnerabilityName": "Juniper Junos OS SRX Series Missing Authentication for Critical Function Vulnerability",
+            "dateAdded": "2023-11-13",
+            "shortDescription": "Juniper Junos OS on SRX Series contains a missing authentication for critical function vulnerability that allows an unauthenticated, network-based attacker to cause limited impact to the file system integrity. With a specific request to user.php that doesn't require authentication, an attacker is able to upload arbitrary files via J-Web, leading to a loss of integrity for a certain part of the file system, which may allow chaining to other vulnerabilities.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportportal.juniper.net\/s\/article\/2023-08-Out-of-Cycle-Security-Bulletin-Junos-OS-SRX-Series-and-EX-Series-Multiple-vulnerabilities-in-J-Web-can-be-combined-to-allow-a-preAuth-Remote-Code-Execution?language=en_US ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36846",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-36847",
+            "vendorProject": "Juniper",
+            "product": "Junos OS",
+            "vulnerabilityName": "Juniper Junos OS EX Series Missing Authentication for Critical Function Vulnerability",
+            "dateAdded": "2023-11-13",
+            "shortDescription": "Juniper Junos OS on EX Series contains a missing authentication for critical function vulnerability that allows an unauthenticated, network-based attacker to cause limited impact to the file system integrity. With a specific request to installAppPackage.php that doesn't require authentication, an attacker is able to upload arbitrary files via J-Web, leading to a loss of integrity for a certain part of the file system, which may allow chaining to other vulnerabilities.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportportal.juniper.net\/s\/article\/2023-08-Out-of-Cycle-Security-Bulletin-Junos-OS-SRX-Series-and-EX-Series-Multiple-vulnerabilities-in-J-Web-can-be-combined-to-allow-a-preAuth-Remote-Code-Execution?language=en_US;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36847",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-36851",
+            "vendorProject": "Juniper",
+            "product": "Junos OS",
+            "vulnerabilityName": "Juniper Junos OS SRX Series Missing Authentication for Critical Function Vulnerability",
+            "dateAdded": "2023-11-13",
+            "shortDescription": "Juniper Junos OS on SRX Series contains a missing authentication for critical function vulnerability that allows an unauthenticated, network-based attacker to cause limited impact to the file system integrity. With a specific request to webauth_operation.php that doesn't require authentication, an attacker is able to upload arbitrary files via J-Web, leading to a loss of integrity for a certain part of the file system, which may allow chaining to other vulnerabilities.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportportal.juniper.net\/s\/article\/2023-08-Out-of-Cycle-Security-Bulletin-Junos-OS-SRX-Series-and-EX-Series-Multiple-vulnerabilities-in-J-Web-can-be-combined-to-allow-a-preAuth-Remote-Code-Execution?language=en_US ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36851",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-29552",
+            "vendorProject": "IETF",
+            "product": "Service Location Protocol (SLP)",
+            "vulnerabilityName": "Service Location Protocol (SLP) Denial-of-Service Vulnerability",
+            "dateAdded": "2023-11-08",
+            "shortDescription": "The Service Location Protocol (SLP) contains a denial-of-service (DoS) vulnerability that could allow an unauthenticated, remote attacker to register services and use spoofed UDP traffic to conduct a denial-of-service (DoS) attack with a significant amplification factor.",
+            "requiredAction": "Apply mitigations per vendor instructions or disable SLP service or port 427\/UDP on all systems running on untrusted networks, including those directly connected to the Internet.",
+            "dueDate": "2023-11-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or a protocol used by different products. Please check with specific vendors for information on the patching status. For more information please see https:\/\/www.bitsight.com\/blog\/new-high-severity-vulnerability-cve-2023-29552-discovered-service-location-protocol-slp and https:\/\/www.cisa.gov\/news-events\/alerts\/2023\/04\/25\/abuse-service-location-protocol-may-lead-dos-attacks.;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-29552",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-22518",
+            "vendorProject": "Atlassian",
+            "product": "Confluence Data Center and Server",
+            "vulnerabilityName": "Atlassian Confluence Data Center and Server Improper Authorization Vulnerability",
+            "dateAdded": "2023-11-07",
+            "shortDescription": "Atlassian Confluence Data Center and Server contain an improper authorization vulnerability that can result in significant data loss when exploited by an unauthenticated attacker. There is no impact on confidentiality since the attacker cannot exfiltrate any data.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-11-28",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/confluence.atlassian.com\/security\/cve-2023-22518-improper-authorization-vulnerability-in-confluence-data-center-and-server-1311473907.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-22518",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-46604",
+            "vendorProject": "Apache",
+            "product": "ActiveMQ",
+            "vulnerabilityName": "Apache ActiveMQ Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2023-11-02",
+            "shortDescription": "Apache ActiveMQ contains a deserialization of untrusted data vulnerability that may allow a remote attacker with network access to a broker to run shell commands by manipulating serialized class types in the OpenWire protocol to cause the broker to instantiate any class on the classpath.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-11-23",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/activemq.apache.org\/security-advisories.data\/CVE-2023-46604-announcement.txt; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-46604",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-46748",
+            "vendorProject": "F5",
+            "product": "BIG-IP Configuration Utility",
+            "vulnerabilityName": "F5 BIG-IP Configuration Utility SQL Injection Vulnerability",
+            "dateAdded": "2023-10-31",
+            "shortDescription": "F5 BIG-IP Configuration utility contains an SQL injection vulnerability that may allow an authenticated attacker with network access through the BIG-IP management port and\/or self IP addresses to execute system commands. This vulnerability can be used in conjunction with CVE-2023-46747.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-11-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/my.f5.com\/manage\/s\/article\/K000137365 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-46748",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-46747",
+            "vendorProject": "F5",
+            "product": "BIG-IP Configuration Utility",
+            "vulnerabilityName": "F5 BIG-IP Configuration Utility Authentication Bypass Vulnerability",
+            "dateAdded": "2023-10-31",
+            "shortDescription": "F5 BIG-IP Configuration utility contains an authentication bypass using an alternate path or channel vulnerability due to undisclosed requests that may allow an unauthenticated attacker with network access to the BIG-IP system through the management port and\/or self IP addresses to execute system commands. This vulnerability can be used in conjunction with CVE-2023-46748.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-11-21",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/my.f5.com\/manage\/s\/article\/K000137353;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-46747",
+            "cwes": [
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-5631",
+            "vendorProject": "Roundcube",
+            "product": "Webmail",
+            "vulnerabilityName": "Roundcube Webmail Persistent Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2023-10-26",
+            "shortDescription": "Roundcube Webmail contains a persistent cross-site scripting (XSS) vulnerability that allows a remote attacker to run malicious JavaScript code.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-11-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/roundcube.net\/news\/2023\/10\/16\/security-update-1.6.4-released, https:\/\/roundcube.net\/news\/2023\/10\/16\/security-updates-1.5.5-and-1.4.15 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-5631",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-20273",
+            "vendorProject": "Cisco",
+            "product": "Cisco IOS XE Web UI",
+            "vulnerabilityName": "Cisco IOS XE Web UI Command Injection Vulnerability",
+            "dateAdded": "2023-10-23",
+            "shortDescription": "Cisco IOS XE contains a command injection vulnerability in the web user interface. When chained with CVE-2023-20198, the attacker can leverage the new local user to elevate privilege to root and write the implant to the file system. Cisco identified CVE-2023-20273 as the vulnerability exploited to deploy the implant. CVE-2021-1435, previously associated with the exploitation events, is no longer believed to be related to this activity.",
+            "requiredAction": "Verify that instances of Cisco IOS XE Web UI are in compliance with BOD 23-02 and apply mitigations per vendor instructions. For affected products (Cisco IOS XE Web UI exposed to the internet or to untrusted networks), follow vendor instructions to determine if a system may have been compromised and immediately report positive findings to CISA.",
+            "dueDate": "2023-10-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-iosxe-webui-privesc-j22SaA4z;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-20273",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-4966",
+            "vendorProject": "Citrix",
+            "product": "NetScaler ADC and NetScaler Gateway",
+            "vulnerabilityName": "Citrix NetScaler ADC and NetScaler Gateway Buffer Overflow Vulnerability",
+            "dateAdded": "2023-10-18",
+            "shortDescription": "Citrix NetScaler ADC and NetScaler Gateway contain a buffer overflow vulnerability that allows for sensitive information disclosure when configured as a Gateway (VPN virtual server, ICA Proxy, CVPN, RDP Proxy) or AAA virtual server.",
+            "requiredAction": "Apply mitigations and kill all active and persistent sessions per vendor instructions [https:\/\/www.netscaler.com\/blog\/news\/cve-2023-4966-critical-security-update-now-available-for-netscaler-adc-and-netscaler-gateway\/] OR discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-11-08",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.netscaler.com\/blog\/news\/cve-2023-4966-critical-security-update-now-available-for-netscaler-adc-and-netscaler-gateway\/, https:\/\/support.citrix.com\/article\/CTX579459\/netscaler-adc-and-netscaler-gateway-security-bulletin-for-cve20234966-and-cve20234967 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-4966",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-20198",
+            "vendorProject": "Cisco",
+            "product": "IOS XE Web UI",
+            "vulnerabilityName": "Cisco IOS XE Web UI Privilege Escalation Vulnerability",
+            "dateAdded": "2023-10-16",
+            "shortDescription": "Cisco IOS XE Web UI contains a privilege escalation vulnerability in the web user interface that could allow a remote, unauthenticated attacker to create an account with privilege level 15 access. The attacker can then use that account to gain control of the affected device.",
+            "requiredAction": "Verify that instances of Cisco IOS XE Web UI are in compliance with BOD 23-02 and apply mitigations per vendor instructions. For affected products (Cisco IOS XE Web UI exposed to the internet or to untrusted networks), follow vendor instructions to determine if a system may have been compromised and immediately report positive findings to CISA.",
+            "dueDate": "2023-10-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.cisco.com\/c\/en\/us\/support\/docs\/ios-nx-os-software\/ios-xe-dublin-17121\/221128-software-fix-availability-for-cisco-ios.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-20198",
+            "cwes": [
+                "CWE-420"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-21608",
+            "vendorProject": "Adobe",
+            "product": "Acrobat and Reader",
+            "vulnerabilityName": "Adobe Acrobat and Reader Use-After-Free Vulnerability",
+            "dateAdded": "2023-10-10",
+            "shortDescription": "Adobe Acrobat and Reader contains a use-after-free vulnerability that allows for code execution in the context of the current user.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/helpx.adobe.com\/security\/products\/acrobat\/apsb23-01.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-21608",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-20109",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE",
+            "vulnerabilityName": "Cisco IOS and IOS XE Group Encrypted Transport VPN Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2023-10-10",
+            "shortDescription": "Cisco IOS and IOS XE contain an out-of-bounds write vulnerability in the Group Encrypted Transport VPN (GET VPN) feature that could allow an authenticated, remote attacker who has administrative control of either a group member or a key server to execute malicious code or cause a device to crash.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-getvpn-rce-g8qR68sx;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-20109",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-41763",
+            "vendorProject": "Microsoft",
+            "product": "Skype for Business",
+            "vulnerabilityName": "Microsoft Skype for Business Privilege Escalation Vulnerability",
+            "dateAdded": "2023-10-10",
+            "shortDescription": "Microsoft Skype for Business contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-41763;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-41763",
+            "cwes": [
+                "CWE-918"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-36563",
+            "vendorProject": "Microsoft",
+            "product": "WordPad",
+            "vulnerabilityName": "Microsoft WordPad Information Disclosure Vulnerability",
+            "dateAdded": "2023-10-10",
+            "shortDescription": "Microsoft WordPad contains an unspecified vulnerability that allows for information disclosure.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-36563;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36563",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-44487",
+            "vendorProject": "IETF",
+            "product": "HTTP\/2",
+            "vulnerabilityName": "HTTP\/2 Rapid Reset Attack Vulnerability",
+            "dateAdded": "2023-10-10",
+            "shortDescription": "HTTP\/2 contains a rapid reset vulnerability that allows for a distributed denial-of-service attack (DDoS).",
+            "requiredAction": "Apply mitigations per vendor instructions, follow applicable BOD 22-01 guidance for cloud services, or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "This vulnerability affects a common open-source component, third-party library, or protocol used by different products. For more information, please see: HTTP\/2 Rapid Reset Vulnerability, CVE-2023-44487 | CISA: https:\/\/www.cisa.gov\/news-events\/alerts\/2023\/10\/10\/http2-rapid-reset-vulnerability-cve-2023-44487; https:\/\/blog.cloudflare.com\/technical-breakdown-http2-rapid-reset-ddos-attack\/;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-44487",
+            "cwes": [
+                "CWE-400"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-22515",
+            "vendorProject": "Atlassian",
+            "product": "Confluence Data Center and Server",
+            "vulnerabilityName": "Atlassian Confluence Data Center and Server Broken Access Control Vulnerability",
+            "dateAdded": "2023-10-05",
+            "shortDescription": "Atlassian Confluence Data Center and Server contains a broken access control vulnerability that allows an attacker to create unauthorized Confluence administrator accounts and access Confluence.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable. Check all affected Confluence instances for evidence of compromise per vendor instructions and report any positive findings to CISA.",
+            "dueDate": "2023-10-13",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/confluence.atlassian.com\/security\/cve-2023-22515-privilege-escalation-vulnerability-in-confluence-data-center-and-server-1295682276.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-22515",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-40044",
+            "vendorProject": "Progress",
+            "product": "WS_FTP Server",
+            "vulnerabilityName": "Progress WS_FTP Server Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2023-10-05",
+            "shortDescription": "Progress WS_FTP Server contains a deserialization of untrusted data vulnerability in the Ad Hoc Transfer module that allows an authenticated attacker to execute remote commands on the underlying operating system.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-26",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/community.progress.com\/s\/article\/WS-FTP-Server-Critical-Vulnerability-September-2023; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-40044",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-42824",
+            "vendorProject": "Apple",
+            "product": "iOS and iPadOS",
+            "vulnerabilityName": "Apple iOS and iPadOS Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2023-10-05",
+            "shortDescription": "Apple iOS and iPadOS contain an unspecified vulnerability that allows for local privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213961;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-42824",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-42793",
+            "vendorProject": "JetBrains",
+            "product": "TeamCity",
+            "vulnerabilityName": "JetBrains TeamCity Authentication Bypass Vulnerability",
+            "dateAdded": "2023-10-04",
+            "shortDescription": "JetBrains TeamCity contains an authentication bypass vulnerability that allows for remote code execution on TeamCity Server.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-25",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/blog.jetbrains.com\/teamcity\/2023\/09\/critical-security-issue-affecting-teamcity-on-premises-update-to-2023-05-4-now\/ ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-42793",
+            "cwes": [
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-28229",
+            "vendorProject": "Microsoft",
+            "product": "Windows CNG Key Isolation Service",
+            "vulnerabilityName": "Microsoft Windows CNG Key Isolation Service Privilege Escalation Vulnerability",
+            "dateAdded": "2023-10-04",
+            "shortDescription": "Microsoft Windows Cryptographic Next Generation (CNG) Key Isolation Service contains an unspecified vulnerability that allows an attacker to gain specific limited SYSTEM privileges.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2023-28229; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-28229",
+            "cwes": [
+                "CWE-591"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-4211",
+            "vendorProject": "Arm",
+            "product": "Mali GPU Kernel Driver",
+            "vulnerabilityName": "Arm Mali GPU Kernel Driver Use-After-Free Vulnerability",
+            "dateAdded": "2023-10-03",
+            "shortDescription": "Arm Mali GPU Kernel Driver contains a use-after-free vulnerability that allows a local, non-privileged user to make improper GPU memory processing operations to gain access to already freed memory.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/developer.arm.com\/Arm%20Security%20Center\/Mali%20GPU%20Driver%20Vulnerabilities;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-4211",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-5217",
+            "vendorProject": "Google",
+            "product": "Chromium libvpx",
+            "vulnerabilityName": "Google Chromium libvpx Heap Buffer Overflow Vulnerability",
+            "dateAdded": "2023-10-02",
+            "shortDescription": "Google Chromium libvpx contains a heap buffer overflow vulnerability in vp8 encoding that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could impact web browsers using libvpx, including but not limited to Google Chrome.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2023\/09\/stable-channel-update-for-desktop_27.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-5217",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-14667",
+            "vendorProject": "Red Hat",
+            "product": "JBoss RichFaces Framework",
+            "vulnerabilityName": "Red Hat JBoss RichFaces Framework Expression Language Injection Vulnerability",
+            "dateAdded": "2023-09-28",
+            "shortDescription": "Red Hat JBoss RichFaces Framework contains an expression language injection vulnerability via the UserResource resource. A remote, unauthenticated attacker could exploit this vulnerability to execute malicious code using a chain of Java serialized objects via org.ajax4jsf.resource.UserResource$UriData.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/bugzilla.redhat.com\/show_bug.cgi?id=CVE-2018-14667; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-14667",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-41991",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Improper Certificate Validation Vulnerability",
+            "dateAdded": "2023-09-25",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and watchOS contain an improper certificate validation vulnerability that can allow a malicious app to bypass signature validation.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213926, https:\/\/support.apple.com\/en-us\/HT213927, https:\/\/support.apple.com\/en-us\/HT213928, https:\/\/support.apple.com\/en-us\/HT213929, https:\/\/support.apple.com\/en-us\/HT213931 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-41991",
+            "cwes": [
+                "CWE-295"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-41992",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2023-09-25",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and watchOS contain an unspecified vulnerability that allows for local privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213926, https:\/\/support.apple.com\/en-us\/HT213927, https:\/\/support.apple.com\/en-us\/HT213928, https:\/\/support.apple.com\/en-us\/HT213929, https:\/\/support.apple.com\/en-us\/HT213931, https:\/\/support.apple.com\/en-us\/HT213932;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-41992",
+            "cwes": [
+                "CWE-754"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-41993",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Code Execution Vulnerability",
+            "dateAdded": "2023-09-25",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and Safari WebKit contain an unspecified vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213926, https:\/\/support.apple.com\/en-us\/HT213927, https:\/\/support.apple.com\/en-us\/HT213930;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-41993",
+            "cwes": [
+                "CWE-754"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-41179",
+            "vendorProject": "Trend Micro",
+            "product": "Apex One and Worry-Free Business Security",
+            "vulnerabilityName": "Trend Micro Apex One and Worry-Free Business Security Remote Code Execution Vulnerability",
+            "dateAdded": "2023-09-21",
+            "shortDescription": "Trend Micro Apex One and Worry-Free Business Security contain an unspecified vulnerability in the third-party anti-virus uninstaller that could allow an attacker to manipulate the module to conduct remote code execution. An attacker must first obtain administrative console access on the target system in order to exploit this vulnerability.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/success.trendmicro.com\/dcx\/s\/solution\/000294994?language=en_US ; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-41179",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-28434",
+            "vendorProject": "MinIO",
+            "product": "MinIO",
+            "vulnerabilityName": "MinIO Security Feature Bypass Vulnerability",
+            "dateAdded": "2023-09-19",
+            "shortDescription": "MinIO contains a security feature bypass vulnerability that allows an attacker to use crafted requests to bypass metadata bucket name checking and put an object into any bucket while processing `PostPolicyBucket` to conduct privilege escalation. To carry out this attack, the attacker requires credentials with `arn:aws:s3:::*` permission, as well as enabled Console API access.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/minio\/minio\/security\/advisories\/GHSA-2pxw-r47w-4p8c;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-28434",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22265",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Use-After-Free Vulnerability",
+            "dateAdded": "2023-09-18",
+            "shortDescription": "Samsung devices with selected Exynos chipsets contain a use-after-free vulnerability that allows malicious memory write and code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb?year=2022&month=1;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22265",
+            "cwes": [
+                "CWE-703"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-8361",
+            "vendorProject": "Realtek",
+            "product": "SDK",
+            "vulnerabilityName": "Realtek SDK Improper Input Validation Vulnerability",
+            "dateAdded": "2023-09-18",
+            "shortDescription": "Realtek SDK contains an improper input validation vulnerability in the miniigd SOAP service that allows remote attackers to execute malicious code via a crafted NewInternalClient request.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/web.archive.org\/web\/20150831100501\/http:\/\/securityadvisories.dlink.com\/security\/publication.aspx?name=SAP10055; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-8361",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6884",
+            "vendorProject": "Zyxel",
+            "product": "EMG2926 Routers",
+            "vulnerabilityName": "Zyxel EMG2926 Routers Command Injection Vulnerability",
+            "dateAdded": "2023-09-18",
+            "shortDescription": "Zyxel EMG2926 routers contain a command injection vulnerability located in the diagnostic tools, specifically the nslookup function. A malicious user may exploit numerous vectors to execute malicious commands on the router, such as the ping_ip parameter to the expert\/maintenance\/diagnostic\/nslookup URI.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-09",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.zyxel.com\/global\/en\/support\/security-advisories\/zyxel-security-advisory-for-command-injection-vulnerability-in-emg2926-q10a-ethernet-cpe, https:\/\/www.zyxelguard.com\/Zyxel-EOL.asp; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6884",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-3129",
+            "vendorProject": "Laravel",
+            "product": "Ignition",
+            "vulnerabilityName": "Laravel Ignition File Upload Vulnerability",
+            "dateAdded": "2023-09-18",
+            "shortDescription": "Laravel Ignition contains a file upload vulnerability that allows unauthenticated remote attackers to execute malicious code due to insecure usage of file_get_contents() and file_put_contents().",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-09",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/github.com\/facade\/ignition\/releases\/tag\/2.5.2; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-3129",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-26369",
+            "vendorProject": "Adobe",
+            "product": "Acrobat and Reader",
+            "vulnerabilityName": "Adobe Acrobat and Reader Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2023-09-14",
+            "shortDescription": "Adobe Acrobat and Reader contains an out-of-bounds write vulnerability that allows for code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/helpx.adobe.com\/security\/products\/acrobat\/apsb23-34.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-26369",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-35674",
+            "vendorProject": "Android",
+            "product": "Framework",
+            "vulnerabilityName": "Android Framework Privilege Escalation Vulnerability",
+            "dateAdded": "2023-09-13",
+            "shortDescription": "Android Framework contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/source.android.com\/docs\/security\/bulletin\/2023-09-01;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-35674",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-20269",
+            "vendorProject": "Cisco",
+            "product": "Adaptive Security Appliance and Firepower Threat Defense",
+            "vulnerabilityName": "Cisco Adaptive Security Appliance and Firepower Threat Defense Unauthorized Access Vulnerability",
+            "dateAdded": "2023-09-13",
+            "shortDescription": "Cisco Adaptive Security Appliance and Firepower Threat Defense contain an unauthorized access vulnerability that could allow an unauthenticated, remote attacker to conduct a brute force attack in an attempt to identify valid username and password combinations or establish a clientless SSL VPN session with an unauthorized user.",
+            "requiredAction": "Apply mitigations per vendor instructions for group-lock and vpn-simultaneous-logins or discontinue use of the product for unsupported devices.",
+            "dueDate": "2023-10-04",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-asaftd-ravpn-auth-8LyfCkeC;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-20269",
+            "cwes": [
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-4863",
+            "vendorProject": "Google",
+            "product": "Chromium WebP",
+            "vulnerabilityName": "Google Chromium WebP Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2023-09-13",
+            "shortDescription": "Google Chromium WebP contains a heap-based buffer overflow vulnerability that allows a remote attacker to perform an out-of-bounds memory write via a crafted HTML page. This vulnerability can affect applications that use the WebP Codec.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2023\/09\/stable-channel-update-for-desktop_11.html?m=1; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-4863",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-36761",
+            "vendorProject": "Microsoft",
+            "product": "Word",
+            "vulnerabilityName": "Microsoft Word Information Disclosure Vulnerability",
+            "dateAdded": "2023-09-12",
+            "shortDescription": "Microsoft Word contains an unspecified vulnerability that allows for information disclosure.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2023-36761;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36761",
+            "cwes": [
+                "CWE-668"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-36802",
+            "vendorProject": "Microsoft",
+            "product": "Streaming Service Proxy",
+            "vulnerabilityName": "Microsoft Streaming Service Proxy Privilege Escalation Vulnerability",
+            "dateAdded": "2023-09-12",
+            "shortDescription": "Microsoft Streaming Service Proxy contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2023-36802;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36802",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-41064",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and macOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and macOS ImageIO Buffer Overflow Vulnerability",
+            "dateAdded": "2023-09-11",
+            "shortDescription": "Apple iOS, iPadOS, and macOS contain a buffer overflow vulnerability in ImageIO when processing a maliciously crafted image, which may lead to code execution. This vulnerability was chained with CVE-2023-41061.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213905, https:\/\/support.apple.com\/en-us\/HT213906; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-41064",
+            "cwes": [
+                "CWE-120"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-41061",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and watchOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and watchOS Wallet Code Execution Vulnerability",
+            "dateAdded": "2023-09-11",
+            "shortDescription": "Apple iOS, iPadOS, and watchOS contain an unspecified vulnerability due to a validation issue affecting Wallet in which a maliciously crafted attachment may result in code execution. This vulnerability was chained with CVE-2023-41064.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-10-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213905, https:\/\/support.apple.com\/kb\/HT213907; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-41061",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-33246",
+            "vendorProject": "Apache",
+            "product": "RocketMQ",
+            "vulnerabilityName": "Apache RocketMQ Command Execution Vulnerability",
+            "dateAdded": "2023-09-06",
+            "shortDescription": "Several components of Apache RocketMQ, including NameServer, Broker, and Controller, are exposed to the extranet and lack permission verification. An attacker can exploit this vulnerability by using the update configuration function to execute commands as the system users that RocketMQ is running as or achieve the same effect by forging the RocketMQ protocol content.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-09-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/lists.apache.org\/thread\/1s8j2c8kogthtpv3060yddk03zq0pxyp;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-33246",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-38831",
+            "vendorProject": "RARLAB",
+            "product": "WinRAR",
+            "vulnerabilityName": "RARLAB WinRAR Code Execution Vulnerability",
+            "dateAdded": "2023-08-24",
+            "shortDescription": "RARLAB WinRAR contains an unspecified vulnerability that allows an attacker to execute code when a user attempts to view a benign file within a ZIP archive.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-09-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "http:\/\/www.win-rar.com\/singlenewsview.html?&L=0&tx_ttnews%5Btt_news%5D=232&cHash=c5bf79590657e32554c6683296a8e8aa;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-38831",
+            "cwes": [
+                "CWE-351"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-32315",
+            "vendorProject": "Ignite Realtime",
+            "product": "Openfire",
+            "vulnerabilityName": "Ignite Realtime Openfire Path Traversal Vulnerability",
+            "dateAdded": "2023-08-24",
+            "shortDescription": "Ignite Realtime Openfire contains a path traversal vulnerability that allows an unauthenticated attacker to access restricted pages in the Openfire Admin Console reserved for administrative users.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-09-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.igniterealtime.org\/downloads\/#openfire;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-32315",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-38035",
+            "vendorProject": "Ivanti",
+            "product": "Sentry",
+            "vulnerabilityName": "Ivanti Sentry Authentication Bypass Vulnerability",
+            "dateAdded": "2023-08-22",
+            "shortDescription": "Ivanti Sentry, formerly known as MobileIron Sentry, contains an authentication bypass vulnerability that may allow an attacker to bypass authentication controls on the administrative interface due to an insufficiently restrictive Apache HTTPD configuration.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-09-12",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/CVE-2023-38035-API-Authentication-Bypass-on-Sentry-Administrator-Interface?language=en_US ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-38035",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-27532",
+            "vendorProject": "Veeam",
+            "product": "Backup & Replication",
+            "vulnerabilityName": "Veeam Backup & Replication Cloud Connect Missing Authentication for Critical Function Vulnerability",
+            "dateAdded": "2023-08-22",
+            "shortDescription": "Veeam Backup & Replication Cloud Connect component contains a missing authentication for critical function vulnerability that allows an unauthenticated user operating within the backup infrastructure network perimeter to obtain encrypted credentials stored in the configuration database. This may lead to an attacker gaining access to the backup infrastructure hosts.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-09-12",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.veeam.com\/kb4424;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-27532",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-26359",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2023-08-21",
+            "shortDescription": "Adobe ColdFusion contains a deserialization of untrusted data vulnerability that could result in code execution in the context of the current user.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-09-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/helpx.adobe.com\/security\/products\/coldfusion\/apsb23-25.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-26359",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-24489",
+            "vendorProject": "Citrix",
+            "product": "Content Collaboration",
+            "vulnerabilityName": "Citrix Content Collaboration ShareFile Improper Access Control Vulnerability",
+            "dateAdded": "2023-08-16",
+            "shortDescription": "Citrix Content Collaboration contains an improper access control vulnerability that could allow an unauthenticated attacker to remotely compromise customer-managed ShareFile storage zones controllers.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-09-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.citrix.com\/article\/CTX559517\/sharefile-storagezones-controller-security-update-for-cve202324489;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-24489",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-38180",
+            "vendorProject": "Microsoft",
+            "product": ".NET Core and Visual Studio",
+            "vulnerabilityName": "Microsoft .NET Core and Visual Studio Denial-of-Service Vulnerability",
+            "dateAdded": "2023-08-09",
+            "shortDescription": "Microsoft .NET Core and Visual Studio contain an unspecified vulnerability that allows for denial-of-service (DoS).",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-08-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-38180;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-38180",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2017-18368",
+            "vendorProject": "Zyxel",
+            "product": "P660HN-T1A Routers",
+            "vulnerabilityName": "Zyxel P660HN-T1A Routers Command Injection Vulnerability",
+            "dateAdded": "2023-08-07",
+            "shortDescription": "Zyxel P660HN-T1A routers contain a command injection vulnerability in the Remote System Log forwarding function, which is accessible by an unauthenticated user and exploited via the remote_host parameter of the ViewLog.asp page.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-08-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.zyxel.com\/global\/en\/support\/security-advisories\/zyxel-security-advisory-for-a-new-variant-of-gafgyt-malware; https:\/\/www.zyxel.com\/global\/en\/support\/security-advisories\/zyxel-security-advisory-for-command-injection-vulnerability-in-p660hn-t1a-dsl-cpe; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-18368",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-35081",
+            "vendorProject": "Ivanti",
+            "product": "Endpoint Manager Mobile (EPMM)",
+            "vulnerabilityName": "Ivanti Endpoint Manager Mobile (EPMM) Path Traversal Vulnerability",
+            "dateAdded": "2023-07-31",
+            "shortDescription": "Ivanti Endpoint Manager Mobile (EPMM) contains a path traversal vulnerability that enables an authenticated administrator to perform malicious file writes to the EPMM server. This vulnerability can be used in conjunction with CVE-2023-35078 to bypass authentication and ACLs restrictions (if applicable).",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-08-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/CVE-2023-35081-Arbitrary-File-Write?language=en_US;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-35081",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-37580",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2023-07-27",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) contains a cross-site scripting vulnerability impacting the confidentiality and integrity of data.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-08-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/wiki.zimbra.com\/wiki\/Security_Center ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-37580",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-38606",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Kernel Unspecified Vulnerability",
+            "dateAdded": "2023-07-26",
+            "shortDescription": "Apple iOS, iPadOS, macOS, tvOS, and watchOS contain an unspecified vulnerability allowing an app to modify a sensitive kernel state.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-08-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213841, https:\/\/support.apple.com\/en-us\/HT213842, https:\/\/support.apple.com\/en-us\/HT213843,https:\/\/support.apple.com\/en-us\/HT213844,https:\/\/support.apple.com\/en-us\/HT213845,https:\/\/support.apple.com\/en-us\/HT213846,https:\/\/support.apple.com\/en-us\/HT213848 ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-38606",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-35078",
+            "vendorProject": "Ivanti",
+            "product": "Endpoint Manager Mobile (EPMM)",
+            "vulnerabilityName": "Ivanti Endpoint Manager Mobile Authentication Bypass Vulnerability",
+            "dateAdded": "2023-07-25",
+            "shortDescription": "Ivanti Endpoint Manager Mobile (EPMM, previously branded MobileIron Core) contains an authentication bypass vulnerability that allows unauthenticated access to specific API paths. An attacker with access to these API paths can access personally identifiable information (PII) such as names, phone numbers, and other mobile device details for users on a vulnerable system. An attacker can also make other configuration changes including installing software and modifying security profiles on registered devices.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-08-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/forums.ivanti.com\/s\/article\/CVE-2023-35078-Remote-unauthenticated-API-access-vulnerability?language=en_US;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-35078",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-29298",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Improper Access Control Vulnerability",
+            "dateAdded": "2023-07-20",
+            "shortDescription": "Adobe ColdFusion contains an improper access control vulnerability that allows for a security feature bypass.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-08-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/helpx.adobe.com\/security\/products\/coldfusion\/apsb23-40.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-29298",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-38205",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Improper Access Control Vulnerability",
+            "dateAdded": "2023-07-20",
+            "shortDescription": "Adobe ColdFusion contains an improper access control vulnerability that allows for a security feature bypass.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-08-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/helpx.adobe.com\/security\/products\/coldfusion\/apsb23-47.html ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-38205",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-3519",
+            "vendorProject": "Citrix",
+            "product": "NetScaler ADC and NetScaler Gateway",
+            "vulnerabilityName": "Citrix NetScaler ADC and NetScaler Gateway Code Injection Vulnerability",
+            "dateAdded": "2023-07-19",
+            "shortDescription": "Citrix NetScaler ADC and NetScaler Gateway contains a code injection vulnerability that allows for unauthenticated remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-08-09",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/support.citrix.com\/article\/CTX561482\/citrix-adc-and-citrix-gateway-security-bulletin-for-cve20233519-cve20233466-cve20233467;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-3519",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-36884",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Search Remote Code Execution Vulnerability",
+            "dateAdded": "2023-07-17",
+            "shortDescription": "Microsoft Windows Search contains an unspecified vulnerability that could allow an attacker to evade Mark of the Web (MOTW) defenses via a specially crafted malicious file, leading to remote code execution.",
+            "requiredAction": "Apply mitigations per vendor instructions or discontinue use of the product if mitigations are unavailable.",
+            "dueDate": "2023-08-29",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2023-36884;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36884",
+            "cwes": [
+                "CWE-362"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-29303",
+            "vendorProject": "SolarView",
+            "product": "Compact",
+            "vulnerabilityName": "SolarView Compact Command Injection Vulnerability",
+            "dateAdded": "2023-07-13",
+            "shortDescription": "SolarView Compact contains a command injection vulnerability due to improper validation of input values on the send test mail console of the product's web server.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2023-08-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/jvn.jp\/en\/vu\/JVNVU92327282\/;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-29303",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-37450",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Code Execution Vulnerability",
+            "dateAdded": "2023-07-13",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and Safari WebKit contain an unspecified vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2023-08-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213826, https:\/\/support.apple.com\/en-us\/HT213841, https:\/\/support.apple.com\/en-us\/HT213843, https:\/\/support.apple.com\/en-us\/HT213846, https:\/\/support.apple.com\/en-us\/HT213848;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-37450",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-32046",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows MSHTML Platform Privilege Escalation Vulnerability",
+            "dateAdded": "2023-07-11",
+            "shortDescription": "Microsoft Windows MSHTML Platform contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2023-08-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-32046;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-32046",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-32049",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Defender SmartScreen Security Feature Bypass Vulnerability",
+            "dateAdded": "2023-07-11",
+            "shortDescription": "Microsoft Windows Defender SmartScreen contains a security feature bypass vulnerability that allows an attacker to bypass the Open File - Security Warning prompt.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2023-08-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-32049; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-32049",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-35311",
+            "vendorProject": "Microsoft",
+            "product": "Outlook",
+            "vulnerabilityName": "Microsoft Outlook Security Feature Bypass Vulnerability",
+            "dateAdded": "2023-07-11",
+            "shortDescription": "Microsoft Outlook contains a security feature bypass vulnerability that allows an attacker to bypass the Microsoft Outlook Security Notice prompt.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2023-08-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-35311;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-35311",
+            "cwes": [
+                "CWE-367"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-36874",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Error Reporting Service Privilege Escalation Vulnerability",
+            "dateAdded": "2023-07-11",
+            "shortDescription": "Microsoft Windows Error Reporting Service contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2023-08-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-36874;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-36874",
+            "cwes": [
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-31199",
+            "vendorProject": "Netwrix",
+            "product": "Auditor",
+            "vulnerabilityName": "Netwrix Auditor Insecure Object Deserialization Vulnerability",
+            "dateAdded": "2023-07-11",
+            "shortDescription": "Netwrix Auditor User Activity Video Recording component contains an insecure objection deserialization vulnerability that allows an unauthenticated, remote attacker to execute code as the NT AUTHORITY\\SYSTEM user. Successful exploitation requires that the attacker is able to reach port 9004\/TCP, which is commonly blocked by standard enterprise firewalling.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2023-08-01",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Patch application requires login to customer portal: https:\/\/security.netwrix.com\/Account\/SignIn?ReturnUrl=%2FAdvisories%2FADV-2022-003;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-31199",
+            "cwes": [
+                "CWE-502",
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-29256",
+            "vendorProject": "Arm",
+            "product": "Mali Graphics Processing Unit (GPU)",
+            "vulnerabilityName": "Arm Mali GPU Kernel Driver Use-After-Free Vulnerability",
+            "dateAdded": "2023-07-07",
+            "shortDescription": "Arm Mali GPU Kernel Driver contains a use-after-free vulnerability that may allow a non-privileged user to gain root privilege and\/or disclose information.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2023-07-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/developer.arm.com\/Arm%20Security%20Center\/Mali%20GPU%20Driver%20Vulnerabilities; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-29256",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-17621",
+            "vendorProject": "D-Link",
+            "product": "DIR-859 Router",
+            "vulnerabilityName": "D-Link DIR-859 Router Command Execution Vulnerability",
+            "dateAdded": "2023-06-29",
+            "shortDescription": "D-Link DIR-859 router contains a command execution vulnerability in the UPnP endpoint URL, \/gena.cgi. Exploitation allows an unauthenticated remote attacker to execute system commands as root by sending a specially crafted HTTP SUBSCRIBE request to the UPnP service when connecting to the local network.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2023-07-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportannouncement.us.dlink.com\/announcement\/publication.aspx?name=SAP10147; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-17621",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-20500",
+            "vendorProject": "D-Link",
+            "product": "DWL-2600AP Access Point",
+            "vulnerabilityName": "D-Link DWL-2600AP Access Point Command Injection Vulnerability",
+            "dateAdded": "2023-06-29",
+            "shortDescription": "D-Link DWL-2600AP access point contains an authenticated command injection vulnerability via the Save Configuration functionality in the Web interface, using shell metacharacters in the admin.cgi?action=config_save configBackup or downloadServerip parameter.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable.",
+            "dueDate": "2023-07-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportannouncement.us.dlink.com\/announcement\/publication.aspx?name=SAP10113; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-20500",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-25487",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Out-of-Bounds Read Vulnerability",
+            "dateAdded": "2023-06-29",
+            "shortDescription": "Samsung mobile devices contain an out-of-bounds read vulnerability within the modem interface driver due to a lack of boundary checking of a buffer in set_skb_priv(), leading to remote code execution by dereference of an invalid function pointer.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable",
+            "dueDate": "2023-07-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb?year=2021&month=10; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-25487",
+            "cwes": [
+                "CWE-125"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-25489",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Improper Input Validation Vulnerability",
+            "dateAdded": "2023-06-29",
+            "shortDescription": "Samsung mobile devices contain an improper input validation vulnerability within the modem interface driver that results in a format string bug leading to kernel panic.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable",
+            "dueDate": "2023-07-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb?year=2021&month=10; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-25489",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-25394",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Race Condition Vulnerability",
+            "dateAdded": "2023-06-29",
+            "shortDescription": "Samsung mobile devices contain a race condition vulnerability within the MFC charger driver that leads to a use-after-free allowing for a write given a radio privilege is compromised.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable",
+            "dueDate": "2023-07-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb?year=2021&month=5; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-25394",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-25395",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Race Condition Vulnerability",
+            "dateAdded": "2023-06-29",
+            "shortDescription": "Samsung mobile devices contain a race condition vulnerability within the MFC charger driver that leads to a use-after-free allowing for a write given a radio privilege is compromised.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable",
+            "dueDate": "2023-07-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb?year=2021&month=5; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-25395",
+            "cwes": [
+                "CWE-362"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-25371",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Unspecified Vulnerability",
+            "dateAdded": "2023-06-29",
+            "shortDescription": "Samsung mobile devices contain an unspecified vulnerability within DSP driver that allows attackers to load ELF libraries inside DSP.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable",
+            "dueDate": "2023-07-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb?year=2021&month=3; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-25371",
+            "cwes": [
+                "CWE-912"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-25372",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Improper Boundary Check Vulnerability",
+            "dateAdded": "2023-06-29",
+            "shortDescription": "Samsung mobile devices contain an improper boundary check vulnerability within DSP driver that allows for out-of-bounds memory access.",
+            "requiredAction": "Apply updates per vendor instructions or discontinue use of the product if updates are unavailable",
+            "dueDate": "2023-07-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb?year=2021&month=3; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-25372",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-32434",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Integer Overflow Vulnerability",
+            "dateAdded": "2023-06-23",
+            "shortDescription": "Apple iOS. iPadOS, macOS, and watchOS contain an integer overflow vulnerability that could allow an application to execute code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-07-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213808, https:\/\/support.apple.com\/en-us\/HT213812, https:\/\/support.apple.com\/en-us\/HT213809, https:\/\/support.apple.com\/en-us\/HT213810, https:\/\/support.apple.com\/en-us\/HT213813, https:\/\/support.apple.com\/en-us\/HT213811, https:\/\/support.apple.com\/en-us\/HT213814;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-32434",
+            "cwes": [
+                "CWE-190"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-32435",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Memory Corruption Vulnerability",
+            "dateAdded": "2023-06-23",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and Safari WebKit contain a memory corruption vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-07-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213670, https:\/\/support.apple.com\/en-us\/HT213671, https:\/\/support.apple.com\/en-us\/HT213676, https:\/\/support.apple.com\/en-us\/HT213811;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-32435",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-32439",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Type Confusion Vulnerability",
+            "dateAdded": "2023-06-23",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and Safari WebKit contain a type confusion vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-07-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213813, https:\/\/support.apple.com\/en-us\/HT213811, https:\/\/support.apple.com\/en-us\/HT213814, https:\/\/support.apple.com\/en-us\/HT213816;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-32439",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-20867",
+            "vendorProject": "VMware",
+            "product": "Tools",
+            "vulnerabilityName": "VMware Tools Authentication Bypass Vulnerability",
+            "dateAdded": "2023-06-23",
+            "shortDescription": "VMware Tools contains an authentication bypass vulnerability in the vgauth module. A fully compromised ESXi host can force VMware Tools to fail to authenticate host-to-guest operations, impacting the confidentiality and integrity of the guest virtual machine. An attacker must have root access over ESXi to exploit this vulnerability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-07-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.vmware.com\/security\/advisories\/VMSA-2023-0013.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-20867",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-27992",
+            "vendorProject": "Zyxel",
+            "product": "Multiple Network-Attached Storage (NAS) Devices",
+            "vulnerabilityName": "Zyxel Multiple NAS Devices Command Injection Vulnerability",
+            "dateAdded": "2023-06-23",
+            "shortDescription": "Multiple Zyxel network-attached storage (NAS) devices contain a pre-authentication command injection vulnerability that could allow an unauthenticated attacker to execute commands remotely via a crafted HTTP request.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-07-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.zyxel.com\/global\/en\/support\/security-advisories\/zyxel-security-advisory-for-pre-authentication-command-injection-vulnerability-in-nas-products;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-27992",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-20887",
+            "vendorProject": "VMware",
+            "product": "Aria Operations for Networks",
+            "vulnerabilityName": "Vmware Aria Operations for Networks Command Injection Vulnerability",
+            "dateAdded": "2023-06-22",
+            "shortDescription": "VMware Aria Operations for Networks (formerly vRealize Network Insight) contains a command injection vulnerability that allows a malicious actor with network access to perform an attack resulting in remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-07-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.vmware.com\/security\/advisories\/VMSA-2023-0012.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-20887",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-35730",
+            "vendorProject": "Roundcube",
+            "product": "Roundcube Webmail",
+            "vulnerabilityName": "Roundcube Webmail Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2023-06-22",
+            "shortDescription": "Roundcube Webmail contains a cross-site scripting (XSS) vulnerability that allows an attacker to send a plain text e-mail message with Javascript in a link reference element that is mishandled by linkref_addinindex in rcube_string_replacer.php.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-07-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/roundcube.net\/news\/2020\/12\/27\/security-updates-1.4.10-1.3.16-and-1.2.13; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-35730",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-12641",
+            "vendorProject": "Roundcube",
+            "product": "Roundcube Webmail",
+            "vulnerabilityName": "Roundcube Webmail Remote Code Execution Vulnerability",
+            "dateAdded": "2023-06-22",
+            "shortDescription": "Roundcube Webmail contains an remote code execution vulnerability that allows attackers to execute code via shell metacharacters in a configuration setting for im_convert_path or im_identify_path.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-07-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/roundcube.net\/news\/2020\/04\/29\/security-updates-1.4.4-1.3.11-and-1.2.10; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-12641",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-44026",
+            "vendorProject": "Roundcube",
+            "product": "Roundcube Webmail",
+            "vulnerabilityName": "Roundcube Webmail SQL Injection Vulnerability",
+            "dateAdded": "2023-06-22",
+            "shortDescription": "Roundcube Webmail is vulnerable to SQL injection via search or search_params.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-07-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/roundcube.net\/news\/2021\/11\/12\/security-updates-1.4.12-and-1.3.17-released; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-44026",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-9079",
+            "vendorProject": "Mozilla",
+            "product": "Firefox, Firefox ESR, and Thunderbird",
+            "vulnerabilityName": "Mozilla Firefox, Firefox ESR, and Thunderbird Use-After-Free Vulnerability",
+            "dateAdded": "2023-06-22",
+            "shortDescription": "Mozilla Firefox, Firefox ESR, and Thunderbird contain a use-after-free vulnerability in SVG Animation, targeting Firefox and Tor browser users on Windows.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-07-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.mozilla.org\/en-US\/security\/advisories\/mfsa2016-92\/#CVE-2016-9079; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-9079",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-0165",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2023-06-22",
+            "shortDescription": "Microsoft Win32k contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-07-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/learn.microsoft.com\/en-us\/security-updates\/securitybulletins\/2016\/ms16-039; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-0165",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-27997",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS and FortiProxy SSL-VPN",
+            "vulnerabilityName": "Fortinet FortiOS and FortiProxy SSL-VPN Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2023-06-13",
+            "shortDescription": "Fortinet FortiOS and FortiProxy SSL-VPN contain a heap-based buffer overflow vulnerability which can allow an unauthenticated, remote attacker to execute code or commands via specifically crafted requests.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-07-04",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.fortiguard.com\/psirt\/FG-IR-23-097;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-27997",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-3079",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2023-06-07",
+            "shortDescription": "Google Chromium V8 Engine contains a type confusion vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2023\/06\/stable-channel-update-for-desktop.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-3079",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-33009",
+            "vendorProject": "Zyxel",
+            "product": "Multiple Firewalls",
+            "vulnerabilityName": "Zyxel Multiple Firewalls Buffer Overflow Vulnerability",
+            "dateAdded": "2023-06-05",
+            "shortDescription": "Zyxel ATP, USG FLEX, USG FLEX 50(W), USG20(W)-VPN, VPN, and ZyWALL\/USG firewalls contain a buffer overflow vulnerability in the notification function that could allow an unauthenticated attacker to cause denial-of-service (DoS) conditions and remote code execution on an affected device.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.zyxel.com\/global\/en\/support\/security-advisories\/zyxel-security-advisory-for-multiple-buffer-overflow-vulnerabilities-of-firewalls;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-33009",
+            "cwes": [
+                "CWE-120"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-33010",
+            "vendorProject": "Zyxel",
+            "product": "Multiple Firewalls",
+            "vulnerabilityName": "Zyxel Multiple Firewalls Buffer Overflow Vulnerability",
+            "dateAdded": "2023-06-05",
+            "shortDescription": "Zyxel ATP, USG FLEX, USG FLEX 50(W), USG20(W)-VPN, VPN, and ZyWALL\/USG firewalls contain a buffer overflow vulnerability in the ID processing function that could allow an unauthenticated attacker to cause denial-of-service (DoS) conditions and remote code execution on an affected device.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.zyxel.com\/global\/en\/support\/security-advisories\/zyxel-security-advisory-for-multiple-buffer-overflow-vulnerabilities-of-firewalls;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-33010",
+            "cwes": [
+                "CWE-120"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-34362",
+            "vendorProject": "Progress",
+            "product": "MOVEit Transfer",
+            "vulnerabilityName": "Progress MOVEit Transfer SQL Injection Vulnerability",
+            "dateAdded": "2023-06-02",
+            "shortDescription": "Progress MOVEit Transfer contains a SQL injection vulnerability that could allow an unauthenticated attacker to gain unauthorized access to MOVEit Transfer's database. Depending on the database engine being used (MySQL, Microsoft SQL Server, or Azure SQL), an attacker may be able to infer information about the structure and contents of the database in addition to executing SQL statements that alter or delete database elements.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-23",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "This CVE has a CISA AA located here: https:\/\/www.cisa.gov\/news-events\/cybersecurity-advisories\/aa23-158a. Please see the AA for associated IOCs. Additional information is available at: https:\/\/community.progress.com\/s\/article\/MOVEit-Transfer-Critical-Vulnerability-31May2023.;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-34362",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-28771",
+            "vendorProject": "Zyxel",
+            "product": "Multiple Firewalls",
+            "vulnerabilityName": "Zyxel Multiple Firewalls OS Command Injection Vulnerability",
+            "dateAdded": "2023-05-31",
+            "shortDescription": "Zyxel ATP, USG FLEX, VPN, and ZyWALL\/USG firewalls allow for improper error message handling which could allow an unauthenticated attacker to execute OS commands remotely by sending crafted packets to an affected device.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.zyxel.com\/global\/en\/support\/security-advisories\/zyxel-security-advisory-for-remote-command-injection-vulnerability-of-firewalls;   https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-28771",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-2868",
+            "vendorProject": "Barracuda Networks",
+            "product": "Email Security Gateway (ESG) Appliance",
+            "vulnerabilityName": "Barracuda Networks ESG Appliance Improper Input Validation Vulnerability",
+            "dateAdded": "2023-05-26",
+            "shortDescription": "Barracuda Email Security Gateway (ESG) appliance contains an improper input validation vulnerability of a user-supplied .tar file, leading to remote command injection.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/status.barracuda.com\/incidents\/34kx82j5n4q9;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-2868",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-32409",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Sandbox Escape Vulnerability",
+            "dateAdded": "2023-05-22",
+            "shortDescription": "Apple iOS, iPadOS, macOS, tvOS, watchOS, and Safari WebKit contain an unspecified vulnerability that can allow a remote attacker to break out of the Web Content sandbox. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/HT213757, https:\/\/support.apple.com\/HT213758, https:\/\/support.apple.com\/HT213761, https:\/\/support.apple.com\/HT213762, https:\/\/support.apple.com\/HT213764, https:\/\/support.apple.com\/HT213765; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-32409",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-28204",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Out-of-Bounds Read Vulnerability",
+            "dateAdded": "2023-05-22",
+            "shortDescription": "Apple iOS, iPadOS, macOS, tvOS, watchOS, and Safari WebKit contain an out-of-bounds read vulnerability that may disclose sensitive information when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/HT213757, https:\/\/support.apple.com\/HT213758, https:\/\/support.apple.com\/HT213761, https:\/\/support.apple.com\/HT213762, https:\/\/support.apple.com\/HT213764, https:\/\/support.apple.com\/HT213765;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-28204",
+            "cwes": [
+                "CWE-125"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-32373",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Use-After-Free Vulnerability",
+            "dateAdded": "2023-05-22",
+            "shortDescription": "Apple iOS, iPadOS, macOS, tvOS, watchOS, and Safari WebKit contain a use-after-free vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/HT213757, https:\/\/support.apple.com\/HT213758, https:\/\/support.apple.com\/HT213761, https:\/\/support.apple.com\/HT213762, https:\/\/support.apple.com\/HT213764, https:\/\/support.apple.com\/HT213765; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-32373",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2004-1464",
+            "vendorProject": "Cisco",
+            "product": "IOS",
+            "vulnerabilityName": "Cisco IOS Denial-of-Service Vulnerability",
+            "dateAdded": "2023-05-19",
+            "shortDescription": "Cisco IOS contains an unspecified vulnerability that may block further telnet, reverse telnet, Remote Shell (RSH), Secure Shell (SSH), and in some cases, Hypertext Transport Protocol (HTTP) access to the Cisco device.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-20040827-telnet; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2004-1464",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2016-6415",
+            "vendorProject": "Cisco",
+            "product": "IOS, IOS XR, and IOS XE",
+            "vulnerabilityName": "Cisco IOS, IOS XR, and IOS XE IKEv1 Information Disclosure Vulnerability",
+            "dateAdded": "2023-05-19",
+            "shortDescription": "Cisco IOS, IOS XR, and IOS XE contain insufficient condition checks in the part of the code that handles Internet Key Exchange version 1 (IKEv1) security negotiation requests. contains an information disclosure vulnerability in the Internet Key Exchange version 1 (IKEv1) that could allow an attacker to retrieve memory contents. Successful exploitation could allow the attacker to retrieve memory contents, which can lead to information disclosure.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-20160916-ikev1; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-6415",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-21492",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Insertion of Sensitive Information Into Log File Vulnerability",
+            "dateAdded": "2023-05-19",
+            "shortDescription": "Samsung mobile devices running Android 11, 12, and 13 contain an insertion of sensitive information into log file vulnerability that allows a privileged, local attacker to conduct an address space layout randomization (ASLR) bypass.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-21492",
+            "cwes": [
+                "CWE-532"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-25717",
+            "vendorProject": "Ruckus Wireless",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Multiple Ruckus Wireless Products CSRF and RCE Vulnerability",
+            "dateAdded": "2023-05-12",
+            "shortDescription": "Ruckus Wireless Access Point (AP) software contains an unspecified vulnerability in the web services component. If the web services component is enabled on the AP, an attacker can perform cross-site request forgery (CSRF) or remote code execution (RCE). This vulnerability impacts Ruckus ZoneDirector, SmartZone, and Solo APs.",
+            "requiredAction": "Apply updates per vendor instructions or disconnect product if it is end-of-life.",
+            "dueDate": "2023-06-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.ruckuswireless.com\/security_bulletins\/315;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-25717",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-3560",
+            "vendorProject": "Red Hat",
+            "product": "Polkit",
+            "vulnerabilityName": "Red Hat Polkit Incorrect Authorization Vulnerability",
+            "dateAdded": "2023-05-12",
+            "shortDescription": "Red Hat Polkit contains an incorrect authorization vulnerability through the bypassing of credential checks for D-Bus requests, allowing for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/bugzilla.redhat.com\/show_bug.cgi?id=1961710; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-3560",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-0196",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Race Condition Vulnerability",
+            "dateAdded": "2023-05-12",
+            "shortDescription": "Linux Kernel contains a race condition vulnerability within the n_tty_write function that allows local users to cause a denial-of-service (DoS) or gain privileges via read and write operations with long strings.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2023-06-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/lkml.iu.edu\/hypermail\/linux\/kernel\/1609.1\/02103.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-0196",
+            "cwes": [
+                "CWE-362"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-3904",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Improper Input Validation Vulnerability",
+            "dateAdded": "2023-05-12",
+            "shortDescription": "Linux Kernel contains an improper input validation vulnerability in the Reliable Datagram Sockets (RDS) protocol implementation that allows local users to gain privileges via crafted use of the sendmsg and recvmsg system calls.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2023-06-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/lkml.iu.edu\/hypermail\/linux\/kernel\/1601.3\/06474.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-3904",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-5317",
+            "vendorProject": "Jenkins",
+            "product": "Jenkins User Interface (UI)",
+            "vulnerabilityName": "Jenkins User Interface (UI) Information Disclosure Vulnerability",
+            "dateAdded": "2023-05-12",
+            "shortDescription": "Jenkins User Interface (UI) contains an information disclosure vulnerability that allows users to see the names of jobs and builds otherwise inaccessible to them on the \"Fingerprints\" pages.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.jenkins.io\/security\/advisory\/2015-11-11\/; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-5317",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-3427",
+            "vendorProject": "Oracle",
+            "product": "Java SE and JRockit",
+            "vulnerabilityName": "Oracle Java SE and JRockit Unspecified Vulnerability",
+            "dateAdded": "2023-05-12",
+            "shortDescription": "Oracle Java SE and JRockit contains an unspecified vulnerability that allows remote attackers to affect confidentiality, integrity, and availability via vectors related to Java Management Extensions (JMX). This vulnerability can be exploited through sandboxed Java Web Start applications and sandboxed Java applets. It can also be exploited by supplying data to APIs in the specified component without using sandboxed Java Web Start applications or sandboxed Java applets, such as through a web service.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/cpuapr2016v3.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-3427",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2016-8735",
+            "vendorProject": "Apache",
+            "product": "Tomcat",
+            "vulnerabilityName": "Apache Tomcat Remote Code Execution Vulnerability",
+            "dateAdded": "2023-05-12",
+            "shortDescription": "Apache Tomcat contains an unspecified vulnerability that allows for remote code execution if JmxRemoteLifecycleListener is used and an attacker can reach Java Management Extension (JMX) ports. This CVE exists because this listener wasn't updated for consistency with the Oracle patched issues for CVE-2016-3427 which affected credential types.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-06-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/tomcat.apache.org\/security-9.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-8735",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-29336",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32K Privilege Escalation Vulnerability",
+            "dateAdded": "2023-05-09",
+            "shortDescription": "Microsoft Win32k contains an unspecified vulnerability that allows for privilege escalation up to SYSTEM privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-29336; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-29336",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-1389",
+            "vendorProject": "TP-Link",
+            "product": "Archer AX21",
+            "vulnerabilityName": "TP-Link Archer AX-21 Command Injection Vulnerability",
+            "dateAdded": "2023-05-01",
+            "shortDescription": "TP-Link Archer AX-21 contains a command injection vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.tp-link.com\/us\/support\/download\/archer-ax21\/v3\/#Firmware;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-1389",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-45046",
+            "vendorProject": "Apache",
+            "product": "Log4j2",
+            "vulnerabilityName": "Apache Log4j2 Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2023-05-01",
+            "shortDescription": "Apache Log4j2 contains a deserialization of untrusted data vulnerability due to the incomplete fix of CVE-2021-44228, where the Thread Context Lookup Pattern is vulnerable to remote code execution in certain non-default configurations.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-22",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/logging.apache.org\/log4j\/2.x\/security.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-45046",
+            "cwes": [
+                "CWE-917"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-21839",
+            "vendorProject": "Oracle",
+            "product": "WebLogic Server",
+            "vulnerabilityName": "Oracle WebLogic Server Unspecified Vulnerability",
+            "dateAdded": "2023-05-01",
+            "shortDescription": "Oracle WebLogic Server contains an unspecified vulnerability that allows an unauthenticated attacker with network access via T3, IIOP, to compromise Oracle WebLogic Server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/cpujan2023.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-21839",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-28432",
+            "vendorProject": "MinIO",
+            "product": "MinIO",
+            "vulnerabilityName": "MinIO Information Disclosure Vulnerability",
+            "dateAdded": "2023-04-21",
+            "shortDescription": "MinIO contains a vulnerability in a cluster deployment where MinIO returns all environment variables, which allows for information disclosure.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/minio\/minio\/security\/advisories\/GHSA-6xvq-wj2x-3h3q; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-28432",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-27350",
+            "vendorProject": "PaperCut",
+            "product": "MF\/NG",
+            "vulnerabilityName": "PaperCut MF\/NG Improper Access Control Vulnerability",
+            "dateAdded": "2023-04-21",
+            "shortDescription": "PaperCut MF\/NG contains an improper access control vulnerability within the SetupCompleted class that allows authentication bypass and code execution in the context of system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-12",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.papercut.com\/kb\/Main\/PO-1216-and-PO-1219;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-27350",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-2136",
+            "vendorProject": "Google",
+            "product": "Chromium Skia",
+            "vulnerabilityName": "Google Chrome Skia Integer Overflow Vulnerability",
+            "dateAdded": "2023-04-21",
+            "shortDescription": "Google Chromium Skia contains an integer overflow vulnerability that allows a remote attacker, who has compromised the renderer process, to potentially perform a sandbox escape via a crafted HTML page. This vulnerability affects Google Chrome and ChromeOS, Android, Flutter, and possibly other products.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2023\/04\/stable-channel-update-for-desktop_18.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-2136",
+            "cwes": [
+                "CWE-190"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6742",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software SNMP Remote Code Execution Vulnerability",
+            "dateAdded": "2023-04-19",
+            "shortDescription": "The Simple Network Management Protocol (SNMP) subsystem of Cisco IOS and IOS XE contains a vulnerability that could allow an authenticated, remote attacker to remotely execute code on an affected system or cause an affected system to reload.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/sec.cloudapps.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-20170629-snmp; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6742",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-8526",
+            "vendorProject": "Apple",
+            "product": "macOS",
+            "vulnerabilityName": "Apple macOS Use-After-Free Vulnerability",
+            "dateAdded": "2023-04-17",
+            "shortDescription": "Apple macOS contains a use-after-free vulnerability that could allow for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT209600; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-8526",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-2033",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2023-04-17",
+            "shortDescription": "Google Chromium V8 Engine contains a type confusion vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2023\/04\/stable-channel-update-for-desktop_14.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-2033",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-20963",
+            "vendorProject": "Android",
+            "product": "Framework",
+            "vulnerabilityName": "Android Framework Privilege Escalation Vulnerability",
+            "dateAdded": "2023-04-13",
+            "shortDescription": "Android Framework contains an unspecified vulnerability that allows for privilege escalation after updating an app to a higher Target SDK with no additional execution privileges needed.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/source.android.com\/docs\/security\/bulletin\/2023-03-01;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-20963",
+            "cwes": [
+                "CWE-295"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-29492",
+            "vendorProject": "Novi Survey",
+            "product": "Novi Survey",
+            "vulnerabilityName": "Novi Survey Insecure Deserialization Vulnerability",
+            "dateAdded": "2023-04-13",
+            "shortDescription": "Novi Survey contains an insecure deserialization vulnerability that allows remote attackers to execute code on the server in the context of the service account.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/novisurvey.net\/blog\/novi-survey-security-advisory-apr-2023.aspx; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-29492",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-28252",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Common Log File System (CLFS) Driver Privilege Escalation Vulnerability",
+            "dateAdded": "2023-04-11",
+            "shortDescription": "Microsoft Windows Common Log File System (CLFS) driver contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-02",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-28252;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-28252",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-28205",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Use-After-Free Vulnerability",
+            "dateAdded": "2023-04-10",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and Safari WebKit contain a use-after-free vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213720,https:\/\/support.apple.com\/en-us\/HT213721,https:\/\/support.apple.com\/en-us\/HT213722,https:\/\/support.apple.com\/en-us\/HT213723;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-28205",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-28206",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and macOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and macOS IOSurfaceAccelerator Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2023-04-10",
+            "shortDescription": "Apple iOS, iPadOS, and macOS IOSurfaceAccelerator contain an out-of-bounds write vulnerability that allows an app to execute code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-05-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213720, https:\/\/support.apple.com\/en-us\/HT213721; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-28206",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27876",
+            "vendorProject": "Veritas",
+            "product": "Backup Exec Agent",
+            "vulnerabilityName": "Veritas Backup Exec Agent File Access Vulnerability",
+            "dateAdded": "2023-04-07",
+            "shortDescription": "Veritas Backup Exec (BE) Agent contains a file access vulnerability that could allow an attacker to specially craft input parameters on a data management protocol command to access files on the BE Agent machine.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-28",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.veritas.com\/support\/en_US\/security\/VTS21-001; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27876",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27877",
+            "vendorProject": "Veritas",
+            "product": "Backup Exec Agent",
+            "vulnerabilityName": "Veritas Backup Exec Agent Improper Authentication Vulnerability",
+            "dateAdded": "2023-04-07",
+            "shortDescription": "Veritas Backup Exec (BE) Agent contains an improper authentication vulnerability that could allow an attacker unauthorized access to the BE Agent via SHA authentication scheme.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-28",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.veritas.com\/support\/en_US\/security\/VTS21-001; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27877",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27878",
+            "vendorProject": "Veritas",
+            "product": "Backup Exec Agent",
+            "vulnerabilityName": "Veritas Backup Exec Agent Command Execution Vulnerability",
+            "dateAdded": "2023-04-07",
+            "shortDescription": "Veritas Backup Exec (BE) Agent contains a command execution vulnerability that could allow an attacker to use a data management protocol command to execute a command on the BE Agent machine.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-28",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.veritas.com\/support\/en_US\/security\/VTS21-001; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27878",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1388",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Certificate Dialog Privilege Escalation Vulnerability",
+            "dateAdded": "2023-04-07",
+            "shortDescription": "Microsoft Windows Certificate Dialog contains a privilege escalation vulnerability, allowing attackers to run processes in an elevated context.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-28",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/portal.msrc.microsoft.com\/en-US\/security-guidance\/advisory\/CVE-2019-1388; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1388",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-26083",
+            "vendorProject": "Arm",
+            "product": "Mali Graphics Processing Unit (GPU)",
+            "vulnerabilityName": "Arm Mali GPU Kernel Driver Information Disclosure Vulnerability",
+            "dateAdded": "2023-04-07",
+            "shortDescription": "Arm Mali GPU Kernel Driver contains an information disclosure vulnerability that allows a non-privileged user to make valid GPU processing operations that expose sensitive kernel metadata.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/developer.arm.com\/Arm%20Security%20Center\/Mali%20GPU%20Driver%20Vulnerabilities;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-26083",
+            "cwes": [
+                "CWE-401"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-27926",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2023-04-03",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) contains a cross-site scripting vulnerability by allowing an endpoint URL to accept parameters without sanitizing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/wiki.zimbra.com\/wiki\/Security_Center;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-27926",
+            "cwes": [
+                "CWE-79",
+                "CWE-138"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-3163",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Memory Corruption Vulnerability",
+            "dateAdded": "2023-03-30",
+            "shortDescription": "Microsoft Internet Explorer contains a memory corruption vulnerability that allows remote attackers to execute code or cause a denial of service via a crafted website.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2023-04-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/learn.microsoft.com\/en-us\/security-updates\/securitybulletins\/2013\/ms13-055; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-3163",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-7494",
+            "vendorProject": "Samba",
+            "product": "Samba",
+            "vulnerabilityName": "Samba Remote Code Execution Vulnerability",
+            "dateAdded": "2023-03-30",
+            "shortDescription": "Samba contains a remote code execution vulnerability, allowing a malicious client to upload a shared library to a writable share and then cause the server to load and execute it.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-20",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.samba.org\/samba\/security\/CVE-2017-7494.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-7494",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-42948",
+            "vendorProject": "Fortra",
+            "product": "Cobalt Strike",
+            "vulnerabilityName": "Fortra Cobalt Strike User Interface Remote Code Execution Vulnerability",
+            "dateAdded": "2023-03-30",
+            "shortDescription": "Fortra Cobalt Strike User Interface contains an unspecified vulnerability rooted in Java Swing that may allow remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.cobaltstrike.com\/blog\/out-of-band-update-cobalt-strike-4-7-2\/;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-42948",
+            "cwes": [
+                "CWE-79",
+                "CWE-116"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-39197",
+            "vendorProject": "Fortra",
+            "product": "Cobalt Strike",
+            "vulnerabilityName": "Fortra Cobalt Strike Teamserver Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2023-03-30",
+            "shortDescription": "Fortra Cobalt Strike contains a cross-site scripting (XSS) vulnerability in Teamserver that would allow an attacker to set a malformed username in the Beacon configuration, allowing them to execute code remotely.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.cobaltstrike.com\/blog\/out-of-band-update-cobalt-strike-4-7-1\/;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-39197",
+            "cwes": [
+                "CWE-20",
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30900",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and macOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and macOS Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2023-03-30",
+            "shortDescription": "Apple GPU drivers, included in iOS, iPadOS, and macOS, contain an out-of-bounds write vulnerability that may allow a malicious application to execute code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT21286, https:\/\/support.apple.com\/en-us\/HT212868, https:\/\/support.apple.com\/kb\/HT212872; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30900",
+            "cwes": [
+                "CWE-20",
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-38181",
+            "vendorProject": "Arm",
+            "product": "Mali Graphics Processing Unit (GPU)",
+            "vulnerabilityName": "Arm Mali GPU Kernel Driver Use-After-Free Vulnerability",
+            "dateAdded": "2023-03-30",
+            "shortDescription": "Arm Mali GPU Kernel Driver contains a use-after-free vulnerability that may allow a non-privileged user to gain root privilege and\/or disclose information.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/developer.arm.com\/Arm%20Security%20Center\/Mali%20GPU%20Driver%20Vulnerabilities;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-38181",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-0266",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Use-After-Free Vulnerability",
+            "dateAdded": "2023-03-30",
+            "shortDescription": "Linux kernel contains a use-after-free vulnerability that allows for privilege escalation to gain ring0 access from the system user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/git.kernel.org\/pub\/scm\/linux\/kernel\/git\/stable\/stable-queue.git\/tree\/queue-5.10\/alsa-pcm-move-rwsem-lock-inside-snd_ctl_elem_read-to-prevent-uaf.patch?id=72783cf35e6c55bca84c4bb7b776c58152856fd4;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-0266",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-3038",
+            "vendorProject": "Google",
+            "product": "Chromium Network Service",
+            "vulnerabilityName": "Google Chromium Network Service Use-After-Free Vulnerability",
+            "dateAdded": "2023-03-30",
+            "shortDescription": "Google Chromium Network Service contains a use-after-free vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2022\/08\/stable-channel-update-for-desktop_30.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-3038",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22706",
+            "vendorProject": "Arm",
+            "product": "Mali Graphics Processing Unit (GPU)",
+            "vulnerabilityName": "Arm Mali GPU Kernel Driver Unspecified Vulnerability",
+            "dateAdded": "2023-03-30",
+            "shortDescription": "Arm Mali GPU Kernel Driver contains an unspecified vulnerability that allows a non-privileged user to achieve write access to read-only memory pages.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-20",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/developer.arm.com\/Arm%20Security%20Center\/Mali%20GPU%20Driver%20Vulnerabilities;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22706",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-26360",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2023-03-15",
+            "shortDescription": "Adobe ColdFusion contains a deserialization of untrusted data vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/helpx.adobe.com\/security\/products\/coldfusion\/apsb23-25.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-26360",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-23397",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Outlook Privilege Escalation Vulnerability",
+            "dateAdded": "2023-03-14",
+            "shortDescription": "Microsoft Office Outlook contains a privilege escalation vulnerability that allows for a NTLM Relay attack against another service to authenticate as the user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-23397, https:\/\/msrc.microsoft.com\/blog\/2023\/03\/microsoft-mitigates-outlook-elevation-of-privilege-vulnerability\/, ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-23397",
+            "cwes": [
+                "CWE-294"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-24880",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows SmartScreen Security Feature Bypass Vulnerability",
+            "dateAdded": "2023-03-14",
+            "shortDescription": "Microsoft Windows SmartScreen contains a security feature bypass vulnerability that could allow an attacker to evade Mark of the Web (MOTW) defenses via a specially crafted malicious file.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-04",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-24880;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-24880",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-41328",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS",
+            "vulnerabilityName": "Fortinet FortiOS Path Traversal Vulnerability",
+            "dateAdded": "2023-03-14",
+            "shortDescription": "Fortinet FortiOS contains a path traversal vulnerability that may allow a local privileged attacker to read and write files via crafted CLI commands.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-04-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.fortiguard.com\/psirt\/FG-IR-22-369;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-41328",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-39144",
+            "vendorProject": "XStream",
+            "product": "XStream",
+            "vulnerabilityName": "XStream Remote Code Execution Vulnerability",
+            "dateAdded": "2023-03-10",
+            "shortDescription": "XStream contains a remote code execution vulnerability that allows an attacker to manipulate the processed input stream and replace or inject objects that result in the execution of a local command on the server. This vulnerability can affect multiple products, including but not limited to VMware Cloud Foundation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.vmware.com\/security\/advisories\/VMSA-2022-0027.html, https:\/\/x-stream.github.io\/CVE-2021-39144.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-39144",
+            "cwes": [
+                "CWE-94",
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-5741",
+            "vendorProject": "Plex",
+            "product": "Media Server",
+            "vulnerabilityName": "Plex Media Server Remote Code Execution Vulnerability",
+            "dateAdded": "2023-03-10",
+            "shortDescription": "Plex Media Server contains a remote code execution vulnerability that allows an attacker with access to the server administrator's Plex account to upload a malicious file via the Camera Upload feature and have the media server execute it.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/forums.plex.tv\/t\/security-regarding-cve-2020-5741\/586819; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-5741",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-28810",
+            "vendorProject": "Zoho",
+            "product": "ManageEngine",
+            "vulnerabilityName": "Zoho ManageEngine ADSelfService Plus Remote Code Execution Vulnerability",
+            "dateAdded": "2023-03-07",
+            "shortDescription": "Zoho ManageEngine ADSelfService Plus contains an unspecified vulnerability allowing for remote code execution when performing a password change or reset.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.manageengine.com\/products\/self-service-password\/advisory\/CVE-2022-28810.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-28810",
+            "cwes": [
+                "CWE-78",
+                "CWE-259"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-33891",
+            "vendorProject": "Apache",
+            "product": "Spark",
+            "vulnerabilityName": "Apache Spark Command Injection Vulnerability",
+            "dateAdded": "2023-03-07",
+            "shortDescription": "Apache Spark contains a command injection vulnerability via Spark User Interface (UI) when Access Control Lists (ACLs) are enabled.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/lists.apache.org\/thread\/p847l3kopoo5bjtmxrcwk21xp6tjxqlc;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-33891",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-35914",
+            "vendorProject": "Teclib",
+            "product": "GLPI",
+            "vulnerabilityName": "Teclib GLPI Remote Code Execution Vulnerability",
+            "dateAdded": "2023-03-07",
+            "shortDescription": "Teclib GLPI contains a remote code execution vulnerability in the third-party library, htmlawed.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/glpi-project.org\/fr\/glpi-10-0-3-disponible\/, http:\/\/www.bioinformatics.org\/phplabware\/sourceer\/sourceer.php?&Sfs=htmLawedTest.php&Sl=.%2Finternal_utilities%2FhtmLawed.;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-35914",
+            "cwes": [
+                "CWE-74"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-36537",
+            "vendorProject": "ZK Framework",
+            "product": "AuUploader",
+            "vulnerabilityName": "ZK Framework AuUploader Unspecified Vulnerability",
+            "dateAdded": "2023-02-27",
+            "shortDescription": "ZK Framework AuUploader servlets contain an unspecified vulnerability that could allow an attacker to retrieve the content of a file located in the web context. The ZK Framework is an open-source Java framework. This vulnerability can impact multiple products, including but not limited to ConnectWise R1Soft Server Backup Manager.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-20",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/tracker.zkoss.org\/browse\/ZK-5150;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-36537",
+            "cwes": [
+                "CWE-441"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-47986",
+            "vendorProject": "IBM",
+            "product": "Aspera Faspex",
+            "vulnerabilityName": "IBM Aspera Faspex Code Execution Vulnerability",
+            "dateAdded": "2023-02-21",
+            "shortDescription": "IBM Aspera Faspex could allow a remote attacker to execute code on the system, caused by a YAML deserialization flaw.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/exchange.xforce.ibmcloud.com\/vulnerabilities\/243512?_ga=2.189195179.1800390251.1676559338-700333034.1676325890;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-47986",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-41223",
+            "vendorProject": "Mitel",
+            "product": "MiVoice Connect",
+            "vulnerabilityName": "Mitel MiVoice Connect Code Injection Vulnerability",
+            "dateAdded": "2023-02-21",
+            "shortDescription": "The Director component in Mitel MiVoice Connect allows an authenticated attacker with internal network access to execute code within the context of the application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.mitel.com\/support\/security-advisories\/mitel-product-security-advisory-22-0008;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-41223",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-40765",
+            "vendorProject": "Mitel",
+            "product": "MiVoice Connect",
+            "vulnerabilityName": "Mitel MiVoice Connect Command Injection Vulnerability",
+            "dateAdded": "2023-02-21",
+            "shortDescription": "The Mitel Edge Gateway component of MiVoice Connect allows an authenticated attacker with internal network access to execute commands within the context of the system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.mitel.com\/support\/security-advisories\/mitel-product-security-advisory-22-0007;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-40765",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-46169",
+            "vendorProject": "Cacti",
+            "product": "Cacti",
+            "vulnerabilityName": "Cacti Command Injection Vulnerability",
+            "dateAdded": "2023-02-16",
+            "shortDescription": "Cacti contains a command injection vulnerability that allows an unauthenticated user to execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/Cacti\/cacti\/security\/advisories\/GHSA-6p93-p743-35gf;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-46169",
+            "cwes": [
+                "CWE-74"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-21715",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Publisher Security Feature Bypass Vulnerability",
+            "dateAdded": "2023-02-14",
+            "shortDescription": "Microsoft Office Publisher contains a security feature bypass vulnerability that allows for a local, authenticated attack on a targeted system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-21715;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-21715",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-23376",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Common Log File System (CLFS) Driver Privilege Escalation Vulnerability",
+            "dateAdded": "2023-02-14",
+            "shortDescription": "Microsoft Windows Common Log File System (CLFS) driver contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-07",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-23376;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-23376",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-23529",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Type Confusion Vulnerability",
+            "dateAdded": "2023-02-14",
+            "shortDescription": "Apple iOS, MacOS, Safari and iPadOS WebKit contain a type confusion vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213635, https:\/\/support.apple.com\/en-us\/HT213633, https:\/\/support.apple.com\/en-us\/HT213638;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-23529",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-21823",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Graphic Component Privilege Escalation Vulnerability",
+            "dateAdded": "2023-02-14",
+            "shortDescription": "Microsoft Windows Graphic Component contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-21823;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-21823",
+            "cwes": [
+                "CWE-190"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-2291",
+            "vendorProject": "Intel",
+            "product": "Ethernet Diagnostics Driver for Windows",
+            "vulnerabilityName": "Intel Ethernet Diagnostics Driver for Windows Denial-of-Service Vulnerability",
+            "dateAdded": "2023-02-10",
+            "shortDescription": "Intel ethernet diagnostics driver for Windows IQVW32.sys and IQVW64.sys contain an unspecified vulnerability that allows for a denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.intel.com\/content\/www\/us\/en\/security-center\/advisory\/intel-sa-00051.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-2291",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-24990",
+            "vendorProject": "TerraMaster",
+            "product": "TerraMaster OS",
+            "vulnerabilityName": "TerraMaster OS Remote Command Execution Vulnerability",
+            "dateAdded": "2023-02-10",
+            "shortDescription": "TerraMaster OS contains a remote command execution vulnerability that allows an unauthenticated user to execute commands on the target endpoint.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/forum.terra-master.com\/en\/viewtopic.php?t=3030;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-24990",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-0669",
+            "vendorProject": "Fortra",
+            "product": "GoAnywhere MFT",
+            "vulnerabilityName": "Fortra GoAnywhere MFT Remote Code Execution Vulnerability",
+            "dateAdded": "2023-02-10",
+            "shortDescription": "Fortra (formerly, HelpSystems) GoAnywhere MFT contains a pre-authentication remote code execution vulnerability in the License Response Servlet due to deserializing an attacker-controlled object.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-03-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "This CVE has a CISA AA located here: https:\/\/www.cisa.gov\/news-events\/cybersecurity-advisories\/aa23-158a. Please see the AA for associated IOCs. Additional information is available at: https:\/\/my.goanywhere.com\/webclient\/DownloadProductFiles.xhtml. Fortra users must have an account in order to login and access the patch.;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-0669",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-21587",
+            "vendorProject": "Oracle",
+            "product": "E-Business Suite",
+            "vulnerabilityName": "Oracle E-Business Suite Unspecified Vulnerability",
+            "dateAdded": "2023-02-02",
+            "shortDescription": "Oracle E-Business Suite contains an unspecified vulnerability that allows an unauthenticated attacker with network access via HTTP to compromise Oracle Web Applications Desktop Integrator.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-02-23",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/cpuoct2022.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-21587",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2023-22952",
+            "vendorProject": "SugarCRM",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Multiple SugarCRM Products Remote Code Execution Vulnerability",
+            "dateAdded": "2023-02-02",
+            "shortDescription": "Multiple SugarCRM products contain a remote code execution vulnerability in the EmailTemplates. Using a specially crafted request, custom PHP code can be injected through the EmailTemplates.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-02-23",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.sugarcrm.com\/Resources\/Security\/sugarcrm-sa-2023-001\/;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-22952",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-11357",
+            "vendorProject": "Telerik",
+            "product": "User Interface (UI) for ASP.NET AJAX",
+            "vulnerabilityName": "Telerik UI for ASP.NET AJAX Insecure Direct Object Reference Vulnerability",
+            "dateAdded": "2023-01-26",
+            "shortDescription": "Telerik UI for ASP.NET AJAX contains an insecure direct object reference vulnerability in RadAsyncUpload that can result in file uploads in a limited location and\/or remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-02-16",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/docs.telerik.com\/devtools\/aspnet-ajax\/knowledge-base\/asyncupload-insecure-direct-object-reference; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-11357",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-47966",
+            "vendorProject": "Zoho",
+            "product": "ManageEngine",
+            "vulnerabilityName": "Zoho ManageEngine Multiple Products Remote Code Execution Vulnerability",
+            "dateAdded": "2023-01-23",
+            "shortDescription": "Multiple Zoho ManageEngine products contain an unauthenticated remote code execution vulnerability due to the usage of an outdated third-party dependency, Apache Santuario.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-02-13",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.manageengine.com\/security\/advisory\/CVE\/cve-2022-47966.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-47966",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2022-44877",
+            "vendorProject": "CWP",
+            "product": "Control Web Panel",
+            "vulnerabilityName": "CWP Control Web Panel OS Command Injection Vulnerability",
+            "dateAdded": "2023-01-17",
+            "shortDescription": "CWP Control Web Panel (formerly CentOS Web Panel) contains an OS command injection vulnerability that allows remote attackers to execute commands via shell metacharacters in the login parameter.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-02-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/control-webpanel.com\/changelog#1669855527714-450fb335-6194;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-44877",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-41080",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Privilege Escalation Vulnerability",
+            "dateAdded": "2023-01-10",
+            "shortDescription": "Microsoft Exchange Server contains an unspecified vulnerability that allows for privilege escalation. This vulnerability is chainable with CVE-2022-41082, which allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-01-31",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2022-41080;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-41080",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2023-21674",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Advanced Local Procedure Call (ALPC) Privilege Escalation Vulnerability",
+            "dateAdded": "2023-01-10",
+            "shortDescription": "Microsoft Windows Advanced Local Procedure Call (ALPC) contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-01-31",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2023-21674;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2023-21674",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-5430",
+            "vendorProject": "TIBCO",
+            "product": "JasperReports",
+            "vulnerabilityName": "TIBCO JasperReports Server Information Disclosure Vulnerability",
+            "dateAdded": "2022-12-29",
+            "shortDescription": "TIBCO JasperReports Server contain a vulnerability which may allow any authenticated user read-only access to the contents of the web application, including key configuration files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-01-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.tibco.com\/support\/advisories\/2018\/04\/tibco-security-advisory-april-17-2018-tibco-jasperreports-2018-5430;https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-5430",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-18809",
+            "vendorProject": "TIBCO",
+            "product": "JasperReports",
+            "vulnerabilityName": "TIBCO JasperReports Library Directory Traversal Vulnerability",
+            "dateAdded": "2022-12-29",
+            "shortDescription": "TIBCO JasperReports Library contains a directory-traversal vulnerability that may allow web server users to access contents of the host system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-01-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.tibco.com\/support\/advisories\/2019\/03\/tibco-security-advisory-march-6-2019-tibco-jasperreports-library-2018-18809; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-18809",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-42856",
+            "vendorProject": "Apple",
+            "product": "iOS",
+            "vulnerabilityName": "Apple iOS Type Confusion Vulnerability",
+            "dateAdded": "2022-12-14",
+            "shortDescription": "Apple iOS contains a type confusion vulnerability when processing maliciously crafted web content leading to code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-01-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213516;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-42856",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-42475",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS",
+            "vulnerabilityName": "Fortinet FortiOS Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-12-13",
+            "shortDescription": "Multiple versions of Fortinet FortiOS SSL-VPN contain a heap-based buffer overflow vulnerability which can allow an unauthenticated, remote attacker to execute arbitrary code or commands via specifically crafted requests.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-01-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.fortiguard.com\/psirt\/FG-IR-22-398;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-42475",
+            "cwes": [
+                "CWE-197"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-44698",
+            "vendorProject": "Microsoft",
+            "product": "Defender",
+            "vulnerabilityName": "Microsoft Defender SmartScreen Security Feature Bypass Vulnerability",
+            "dateAdded": "2022-12-13",
+            "shortDescription": "Microsoft Defender SmartScreen contains a security feature bypass vulnerability that could allow an attacker to evade Mark of the Web (MOTW) defenses via a specially crafted malicious file.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-01-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2022-44698;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-44698",
+            "cwes": [
+                "CWE-755"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-27518",
+            "vendorProject": "Citrix",
+            "product": "Application Delivery Controller (ADC) and Gateway",
+            "vulnerabilityName": "Citrix Application Delivery Controller (ADC) and Gateway Authentication Bypass Vulnerability",
+            "dateAdded": "2022-12-13",
+            "shortDescription": "Citrix Application Delivery Controller (ADC) and Gateway, when configured with SAML SP or IdP configuration, contain an authentication bypass vulnerability that allows an attacker to execute code as administrator.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-01-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.citrix.com\/blogs\/2022\/12\/13\/critical-security-update-now-available-for-citrix-adc-citrix-gateway\/;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-27518",
+            "cwes": [
+                "CWE-664"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26500",
+            "vendorProject": "Veeam",
+            "product": "Backup & Replication",
+            "vulnerabilityName": "Veeam Backup & Replication Remote Code Execution Vulnerability",
+            "dateAdded": "2022-12-13",
+            "shortDescription": "The Veeam Distribution Service in the Backup & Replication application allows unauthenticated users to access internal API functions. A remote attacker can send input to the internal API which may lead to uploading and executing of malicious code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-01-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.veeam.com\/kb4288;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26500",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26501",
+            "vendorProject": "Veeam",
+            "product": "Backup & Replication",
+            "vulnerabilityName": "Veeam Backup & Replication Remote Code Execution Vulnerability",
+            "dateAdded": "2022-12-13",
+            "shortDescription": "The Veeam Distribution Service in the Backup & Replication application allows unauthenticated users to access internal API functions. A remote attacker can send input to the internal API which may lead to uploading and executing of malicious code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2023-01-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.veeam.com\/kb4288;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26501",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-4262",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2022-12-05",
+            "shortDescription": "Google Chromium V8 Engine contains a type confusion vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-12-26",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2022\/12\/stable-channel-update-for-desktop.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-4262",
+            "cwes": [
+                "CWE-122",
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-35587",
+            "vendorProject": "Oracle",
+            "product": "Fusion Middleware",
+            "vulnerabilityName": "Oracle Fusion Middleware Unspecified Vulnerability",
+            "dateAdded": "2022-11-28",
+            "shortDescription": "Oracle Fusion Middleware Access Manager allows an unauthenticated attacker with network access via HTTP to takeover the Access Manager product.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-12-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/cpujan2022.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-35587",
+            "cwes": [
+                "CWE-502",
+                "CWE-790"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-4135",
+            "vendorProject": "Google",
+            "product": "Chromium GPU",
+            "vulnerabilityName": "Google Chromium GPU Heap Buffer Overflow Vulnerability",
+            "dateAdded": "2022-11-28",
+            "shortDescription": "Google Chromium GPU contains a heap buffer overflow vulnerability that allows a remote attacker, who has compromised the renderer process, to potentially perform a sandbox escape via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-12-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2022\/11\/stable-channel-update-for-desktop_24.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-4135",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-41049",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Mark of the Web (MOTW) Security Feature Bypass Vulnerability",
+            "dateAdded": "2022-11-14",
+            "shortDescription": "Microsoft Windows Mark of the Web (MOTW) contains a security feature bypass vulnerability resulting in a limited loss of integrity and availability of security features.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-12-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2022-41049;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-41049",
+            "cwes": [
+                "CWE-274"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-41091",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Mark of the Web (MOTW) Security Feature Bypass Vulnerability",
+            "dateAdded": "2022-11-08",
+            "shortDescription": "Microsoft Windows Mark of the Web (MOTW) contains a security feature bypass vulnerability resulting in a limited loss of integrity and availability of security features.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-12-09",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/portal.msrc.microsoft.com\/en-US\/security-guidance\/advisory\/CVE-2022-41091;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-41091",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-41073",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Print Spooler Privilege Escalation Vulnerability",
+            "dateAdded": "2022-11-08",
+            "shortDescription": "Microsoft Windows Print Spooler contains an unspecified vulnerability that allows an attacker to gain SYSTEM-level privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-12-09",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/portal.msrc.microsoft.com\/en-US\/security-guidance\/advisory\/CVE-2022-41073;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-41073",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-41125",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows CNG Key Isolation Service Privilege Escalation Vulnerability",
+            "dateAdded": "2022-11-08",
+            "shortDescription": "Microsoft Windows Cryptographic Next Generation (CNG) Key Isolation Service contains an unspecified vulnerability that allows an attacker to gain SYSTEM-level privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-12-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/portal.msrc.microsoft.com\/en-US\/security-guidance\/advisory\/CVE-2022-41125;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-41125",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-41128",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Scripting Languages Remote Code Execution Vulnerability",
+            "dateAdded": "2022-11-08",
+            "shortDescription": "Microsoft Windows contains an unspecified vulnerability in the JScript9 scripting language which allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-12-09",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2022-41128;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-41128",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-25337",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Improper Access Control Vulnerability",
+            "dateAdded": "2022-11-08",
+            "shortDescription": "Samsung mobile devices contain an improper access control vulnerability in clipboard service which allows untrusted applications to read or write arbitrary files. This vulnerability was chained with CVE-2021-25369 and CVE-2021-25370.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-25337",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-25369",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Improper Access Control Vulnerability",
+            "dateAdded": "2022-11-08",
+            "shortDescription": "Samsung mobile devices using Mali GPU contains an improper access control vulnerability in sec_log file. Exploitation of the vulnerability exposes sensitive kernel information to the userspace. This vulnerability was chained with CVE-2021-25337 and CVE-2021-25370.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-25369",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-25370",
+            "vendorProject": "Samsung",
+            "product": "Mobile Devices",
+            "vulnerabilityName": "Samsung Mobile Devices Memory Corruption Vulnerability",
+            "dateAdded": "2022-11-08",
+            "shortDescription": "Samsung mobile devices using Mali GPU contain an incorrect implementation handling file descriptor in dpu driver. This incorrect implementation results in memory corruption, leading to kernel panic. This vulnerability was chained with CVE-2021-25337 and CVE-2021-25369.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.samsungmobile.com\/securityUpdate.smsb; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-25370",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-3723",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2022-10-28",
+            "shortDescription": "Google Chromium V8 Engine contains a type confusion vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2022\/10\/stable-channel-update-for-desktop_27.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-3723",
+            "cwes": [
+                "CWE-122",
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-42827",
+            "vendorProject": "Apple",
+            "product": "iOS and iPadOS",
+            "vulnerabilityName": "Apple iOS and iPadOS Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2022-10-25",
+            "shortDescription": "Apple iOS and iPadOS kernel contain an out-of-bounds write vulnerability which can allow an application to perform code execution with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213489;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-42827",
+            "cwes": [
+                "CWE-20",
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3433",
+            "vendorProject": "Cisco",
+            "product": "AnyConnect Secure",
+            "vulnerabilityName": "Cisco AnyConnect Secure Mobility Client for Windows DLL Hijacking Vulnerability",
+            "dateAdded": "2022-10-24",
+            "shortDescription": "Cisco AnyConnect Secure Mobility Client for Windows interprocess communication (IPC) channel allows for insufficient validation of resources that are loaded by the application at run time. An attacker with valid credentials on Windows could execute code on the affected machine with SYSTEM privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/tools.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-anyconnect-dll-F26WwJW; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3433",
+            "cwes": [
+                "CWE-427"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3153",
+            "vendorProject": "Cisco",
+            "product": "AnyConnect Secure",
+            "vulnerabilityName": "Cisco AnyConnect Secure Mobility Client for Windows Uncontrolled Search Path Vulnerability",
+            "dateAdded": "2022-10-24",
+            "shortDescription": "Cisco AnyConnect Secure Mobility Client for Windows allows for incorrect handling of directory paths. An attacker with valid credentials on Windows would be able to copy malicious files to arbitrary locations with system level privileges. This could include DLL pre-loading, DLL hijacking, and other related attacks.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/tools.cisco.com\/security\/center\/content\/CiscoSecurityAdvisory\/cisco-sa-ac-win-path-traverse-qO4HWBsj; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3153",
+            "cwes": [
+                "CWE-427"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-19323",
+            "vendorProject": "GIGABYTE",
+            "product": "Multiple Products",
+            "vulnerabilityName": "GIGABYTE Multiple Products Privilege Escalation Vulnerability",
+            "dateAdded": "2022-10-24",
+            "shortDescription": "The GPCIDrv and GDrv low-level drivers in GIGABYTE App Center, AORUS Graphics Engine, XTREME Gaming Engine, and OC GURU expose functionality to read and write arbitrary physical memory. This could be leveraged by a local attacker to elevate privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.gigabyte.com\/Support\/Security\/1801; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-19323",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2018-19322",
+            "vendorProject": "GIGABYTE",
+            "product": "Multiple Products",
+            "vulnerabilityName": "GIGABYTE Multiple Products Code Execution Vulnerability",
+            "dateAdded": "2022-10-24",
+            "shortDescription": "The GPCIDrv and GDrv low-level drivers in GIGABYTE App Center, AORUS Graphics Engine, XTREME Gaming Engine, and OC GURU II expose functionality to read\/write data from\/to IO ports. This could be leveraged in a number of ways to ultimately run code with elevated privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.gigabyte.com\/Support\/Security\/1801; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-19322",
+            "cwes": [
+                "CWE-749"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-19321",
+            "vendorProject": "GIGABYTE",
+            "product": "Multiple Products",
+            "vulnerabilityName": "GIGABYTE Multiple Products Privilege Escalation Vulnerability",
+            "dateAdded": "2022-10-24",
+            "shortDescription": "The GPCIDrv and GDrv low-level drivers in GIGABYTE App Center, AORUS Graphics Engine, XTREME Gaming Engine, and OC GURU II expose functionality to read and write arbitrary physical memory. This could be leveraged by a local attacker to elevate privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.gigabyte.com\/Support\/Security\/1801; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-19321",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2018-19320",
+            "vendorProject": "GIGABYTE",
+            "product": "Multiple Products",
+            "vulnerabilityName": "GIGABYTE Multiple Products Unspecified Vulnerability",
+            "dateAdded": "2022-10-24",
+            "shortDescription": "The GDrv low-level driver in GIGABYTE App Center, AORUS Graphics Engine, XTREME Gaming Engine, and OC GURU II exposes ring0 memcpy-like functionality that could allow a local attacker to take complete control of the affected system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.gigabyte.com\/Support\/Security\/1801; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-19320",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2022-41352",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Arbitrary File Upload Vulnerability",
+            "dateAdded": "2022-10-20",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) allows an attacker to upload arbitrary files using cpio package to gain incorrect access to any other user accounts.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/wiki.zimbra.com\/wiki\/Security_Center;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-41352",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-3493",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-10-20",
+            "shortDescription": "The overlayfs stacking file system in Linux kernel does not properly validate the application of file capabilities against user namespaces, which could lead to privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/git.kernel.org\/pub\/scm\/linux\/kernel\/git\/torvalds\/linux.git\/commit\/?id=7c03e2cda4a584cadc398e8f6641ca9988a39d52; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-3493",
+            "cwes": [
+                "CWE-862"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-40684",
+            "vendorProject": "Fortinet",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Fortinet Multiple Products Authentication Bypass Vulnerability",
+            "dateAdded": "2022-10-11",
+            "shortDescription": "Fortinet FortiOS, FortiProxy, and FortiSwitchManager contain an authentication bypass vulnerability that could allow an unauthenticated attacker to perform operations on the administrative interface via specially crafted HTTP or HTTPS requests.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-01",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.fortiguard.com\/psirt\/FG-IR-22-377;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-40684",
+            "cwes": [
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-41033",
+            "vendorProject": "Microsoft",
+            "product": "Windows COM+ Event System Service",
+            "vulnerabilityName": "Microsoft Windows COM+ Event System Service Privilege Escalation Vulnerability",
+            "dateAdded": "2022-10-11",
+            "shortDescription": "Microsoft Windows COM+ Event System Service contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-11-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2022-41033;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-41033",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-41082",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Remote Code Execution Vulnerability",
+            "dateAdded": "2022-09-30",
+            "shortDescription": "Microsoft Exchange Server contains an unspecified vulnerability that allows for authenticated remote code execution. Dubbed \"ProxyNotShell,\" this vulnerability is chainable with CVE-2022-41040 which allows for the remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-21",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc-blog.microsoft.com\/2022\/09\/29\/customer-guidance-for-reported-zero-day-vulnerabilities-in-microsoft-exchange-server\/;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-41082",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-41040",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Server-Side Request Forgery Vulnerability",
+            "dateAdded": "2022-09-30",
+            "shortDescription": "Microsoft Exchange Server allows for server-side request forgery. Dubbed \"ProxyNotShell,\" this vulnerability is chainable with CVE-2022-41082 which allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-21",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/msrc-blog.microsoft.com\/2022\/09\/29\/customer-guidance-for-reported-zero-day-vulnerabilities-in-microsoft-exchange-server\/;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-41040",
+            "cwes": [
+                "CWE-918"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-36804",
+            "vendorProject": "Atlassian",
+            "product": "Bitbucket Server and Data Center",
+            "vulnerabilityName": "Atlassian Bitbucket Server and Data Center Command Injection Vulnerability",
+            "dateAdded": "2022-09-30",
+            "shortDescription": "Multiple API endpoints of Atlassian Bitbucket Server and Data Center contain a command injection vulnerability where an attacker with access to a public Bitbucket repository, or with read permissions to a private one, can execute code by sending a malicious HTTP request.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/jira.atlassian.com\/browse\/BSERV-13438;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-36804",
+            "cwes": [
+                "CWE-78",
+                "CWE-88",
+                "CWE-158"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-3236",
+            "vendorProject": "Sophos",
+            "product": "Firewall",
+            "vulnerabilityName": "Sophos Firewall Code Injection Vulnerability",
+            "dateAdded": "2022-09-23",
+            "shortDescription": "A code injection vulnerability in the User Portal and Webadmin of Sophos Firewall allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.sophos.com\/en-us\/security-advisories\/sophos-sa-20220923-sfos-rce;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-3236",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-35405",
+            "vendorProject": "Zoho",
+            "product": "ManageEngine",
+            "vulnerabilityName": "Zoho ManageEngine Multiple Products Remote Code Execution Vulnerability",
+            "dateAdded": "2022-09-22",
+            "shortDescription": "Zoho ManageEngine PAM360, Password Manager Pro, and Access Manager Plus contain an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.manageengine.com\/products\/passwordmanagerpro\/advisory\/cve-2022-35405.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-35405",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-40139",
+            "vendorProject": "Trend Micro",
+            "product": "Apex One and Apex One as a Service",
+            "vulnerabilityName": "Trend Micro Apex One and Apex One as a Service Improper Validation Vulnerability",
+            "dateAdded": "2022-09-15",
+            "shortDescription": "Trend Micro Apex One and Apex One as a Service contain an improper validation of rollback mechanism components that could lead to remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/success.trendmicro.com\/dcx\/s\/solution\/000291528?language=en_US;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-40139",
+            "cwes": [
+                "CWE-353",
+                "CWE-641"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-6282",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Improper Input Validation Vulnerability",
+            "dateAdded": "2022-09-15",
+            "shortDescription": "The get_user and put_user API functions of the Linux kernel fail to validate the target address when being used on ARM v6k\/v7 platforms. This allows an application to read and write kernel memory which could lead to privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/git.kernel.org\/pub\/scm\/linux\/kernel\/git\/torvalds\/linux.git\/commit\/?id=8404663f81d212918ff85f493649a7991209fa04; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-6282",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-2597",
+            "vendorProject": "Code Aurora",
+            "product": "ACDB Audio Driver",
+            "vulnerabilityName": "Code Aurora ACDB Audio Driver Stack-based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-09-15",
+            "shortDescription": "The Code Aurora audio calibration database (acdb) audio driver contains a stack-based buffer overflow vulnerability that allows for privilege escalation. Code Aurora is used in third-party products such as Qualcomm and Android.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/web.archive.org\/web\/20161226013354\/https:\/www.codeaurora.org\/news\/security-advisories\/stack-based-buffer-overflow-acdb-audio-driver-cve-2013-2597; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-2597",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-2596",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Integer Overflow Vulnerability",
+            "dateAdded": "2022-09-15",
+            "shortDescription": "Linux kernel fb_mmap function in drivers\/video\/fbmem.c contains an integer overflow vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/git.kernel.org\/pub\/scm\/linux\/kernel\/git\/torvalds\/linux.git\/commit\/?id=fc9bbca8f650e5f738af8806317c0a041a48ae4a; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-2596",
+            "cwes": [
+                "CWE-189"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-2094",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-09-15",
+            "shortDescription": "Linux kernel fails to check all 64 bits of attr.config passed by user space, resulting to out-of-bounds access of the perf_swevent_enabled array in sw_perf_event_destroy(). Explotation allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/git.kernel.org\/pub\/scm\/linux\/kernel\/git\/torvalds\/linux.git\/commit\/?id=8176cced706b5e5d15887584150764894e94e02f; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-2094",
+            "cwes": [
+                "CWE-189"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-2568",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Remote Code Execution Vulnerability",
+            "dateAdded": "2022-09-15",
+            "shortDescription": "Microsoft Windows incorrectly parses shortcuts in such a way that malicious code may be executed when the operating system displays the icon of a malicious shortcut file. An attacker who successfully exploited this vulnerability could execute code as the logged-on user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/docs.microsoft.com\/en-us\/security-updates\/securitybulletins\/2010\/ms10-046; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-2568",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-37969",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Common Log File System (CLFS) Driver Privilege Escalation Vulnerability",
+            "dateAdded": "2022-09-14",
+            "shortDescription": "Microsoft Windows Common Log File System (CLFS) driver contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2022-37969;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-37969",
+            "cwes": [
+                "CWE-20",
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-32917",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and macOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and macOS Remote Code Execution Vulnerability",
+            "dateAdded": "2022-09-14",
+            "shortDescription": "Apple kernel, which is included in iOS, iPadOS, and macOS, contains an unspecified vulnerability where an application may be able to execute code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-10-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT213445, https:\/\/support.apple.com\/en-us\/HT213444;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-32917",
+            "cwes": [
+                "CWE-20",
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-3075",
+            "vendorProject": "Google",
+            "product": "Chromium Mojo",
+            "vulnerabilityName": "Google Chromium Mojo Insufficient Data Validation Vulnerability",
+            "dateAdded": "2022-09-08",
+            "shortDescription": "Google Chromium Mojo contains an insufficient data validation vulnerability that allows a remote attacker, who has compromised the renderer process, to potentially perform a sandbox escape via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2022\/09\/stable-channel-update-for-desktop.html, https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2022-3075;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-3075",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-27593",
+            "vendorProject": "QNAP",
+            "product": "Photo Station",
+            "vulnerabilityName": "QNAP Photo Station Externally Controlled Reference Vulnerability",
+            "dateAdded": "2022-09-08",
+            "shortDescription": "Certain QNAP NAS running Photo Station with internet exposure contain an externally controlled reference to a resource vulnerability which can allow an attacker to modify system files. This vulnerability was observed being utilized in a Deadbolt ransomware campaign.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-29",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.qnap.com\/en\/security-advisory\/qsa-22-24;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-27593",
+            "cwes": [
+                "CWE-610"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26258",
+            "vendorProject": "D-Link",
+            "product": "DIR-820L",
+            "vulnerabilityName": "D-Link DIR-820L Remote Code Execution Vulnerability",
+            "dateAdded": "2022-09-08",
+            "shortDescription": "D-Link DIR-820L contains an unspecified vulnerability in Device Name parameter in \/lan.asp which allows for remote code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-09-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/supportannouncement.us.dlink.com\/announcement\/publication.aspx?name=SAP10295;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26258",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-9934",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and macOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and macOS Input Validation Vulnerability",
+            "dateAdded": "2022-09-08",
+            "shortDescription": "Apple iOS, iPadOS, and macOS contain an unspecified vulnerability involving input validation which can allow a local attacker to view sensitive user information.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT211288, https:\/\/support.apple.com\/en-us\/HT211289; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-9934",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2018-7445",
+            "vendorProject": "MikroTik",
+            "product": "RouterOS",
+            "vulnerabilityName": "MikroTik RouterOS Stack-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-09-08",
+            "shortDescription": "In MikroTik RouterOS, a stack-based buffer overflow occurs when processing NetBIOS session request messages. Remote attackers with access to the service can exploit this vulnerability and gain code execution on the system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.coresecurity.com\/core-labs\/advisories\/mikrotik-routeros-smb-buffer-overflow#vendor_update, https:\/\/mikrotik.com\/download; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-7445",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-6530",
+            "vendorProject": "D-Link",
+            "product": "Multiple Routers",
+            "vulnerabilityName": "D-Link Multiple Routers OS Command Injection Vulnerability",
+            "dateAdded": "2022-09-08",
+            "shortDescription": "Multiple D-Link routers contain an unspecified vulnerability that allows for execution of OS commands.",
+            "requiredAction": "The vendor D-Link published an advisory stating the fix under CVE-2018-20114 properly patches KEV entry CVE-2018-6530. If the device is still supported, apply updates per vendor instructions. If the affected device has since entered its end-of-life, it should be disconnected if still in use.",
+            "dueDate": "2022-09-29",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/supportannouncement.us.dlink.com\/announcement\/publication.aspx?name=SAP10105; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-6530",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-2628",
+            "vendorProject": "Oracle",
+            "product": "WebLogic Server",
+            "vulnerabilityName": "Oracle WebLogic Server Unspecified Vulnerability",
+            "dateAdded": "2022-09-08",
+            "shortDescription": "Oracle WebLogic Server contains an unspecified vulnerability which can allow an unauthenticated attacker with T3 network access to compromise the server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.oracle.com\/security-alerts\/cpuapr2018.html; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-2628",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-13374",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS and FortiADC",
+            "vulnerabilityName": "Fortinet FortiOS and FortiADC Improper Access Control Vulnerability",
+            "dateAdded": "2022-09-08",
+            "shortDescription": "Fortinet FortiOS and FortiADC contain an improper access control vulnerability that allows attackers to obtain the LDAP server login credentials configured in FortiGate by pointing a LDAP server connectivity test request to a rogue LDAP server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-29",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.fortiguard.com\/psirt\/FG-IR-18-157; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-13374",
+            "cwes": [
+                "CWE-732"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-5521",
+            "vendorProject": "NETGEAR",
+            "product": "Multiple Devices",
+            "vulnerabilityName": "NETGEAR Multiple Devices Exposure of Sensitive Information Vulnerability",
+            "dateAdded": "2022-09-08",
+            "shortDescription": "Multiple NETGEAR devices are prone to admin password disclosure via simple crafted requests to the web management server.",
+            "requiredAction": "Apply updates per vendor instructions. If the affected device has since entered end-of-life, it should be disconnected if still in use.",
+            "dueDate": "2022-09-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/kb.netgear.com\/30632\/Web-GUI-Password-Recovery-and-Exposure-Security-Vulnerability; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-5521",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2011-4723",
+            "vendorProject": "D-Link",
+            "product": "DIR-300 Router",
+            "vulnerabilityName": "D-Link DIR-300 Router Cleartext Storage of a Password Vulnerability",
+            "dateAdded": "2022-09-08",
+            "shortDescription": "The D-Link DIR-300 router stores cleartext passwords, which allows context-dependent attackers to obtain sensitive information.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-09-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.dlink.com\/uk\/en\/support\/product\/dir-300-wireless-g-router; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2011-4723",
+            "cwes": [
+                "CWE-310"
+            ]
+        },
+        {
+            "cveID": "CVE-2011-1823",
+            "vendorProject": "Android",
+            "product": "Android OS",
+            "vulnerabilityName": "Android OS Privilege Escalation Vulnerability",
+            "dateAdded": "2022-09-08",
+            "shortDescription": "The vold volume manager daemon in Android kernel trusts messages from a PF_NETLINK socket, which allows an attacker to execute code and gain root privileges. This vulnerability is associated with GingerBreak and Exploit.AndroidOS.Lotoor.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/android.googlesource.com\/platform\/system\/vold\/+\/c51920c82463b240e2be0430849837d6fdc5352e; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2011-1823",
+            "cwes": [
+                "CWE-189"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26352",
+            "vendorProject": "dotCMS",
+            "product": "dotCMS",
+            "vulnerabilityName": "dotCMS Unrestricted Upload of File Vulnerability",
+            "dateAdded": "2022-08-25",
+            "shortDescription": "dotCMS ContentResource API contains an unrestricted upload of file with a dangerous type vulnerability that allows for directory traversal, in which the file is saved outside of the intended storage location. Exploitation allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/www.dotcms.com\/security\/SI-62;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26352",
+            "cwes": [
+                "CWE-22",
+                "CWE-138"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-24706",
+            "vendorProject": "Apache",
+            "product": "CouchDB",
+            "vulnerabilityName": "Apache CouchDB Insecure Default Initialization of Resource Vulnerability",
+            "dateAdded": "2022-08-25",
+            "shortDescription": "Apache CouchDB contains an insecure default initialization of resource vulnerability which can allow an attacker to escalate to administrative privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/lists.apache.org\/thread\/w24wo0h8nlctfps65txvk0oc5hdcnv00;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-24706",
+            "cwes": [
+                "CWE-1188"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-24112",
+            "vendorProject": "Apache",
+            "product": "APISIX",
+            "vulnerabilityName": "Apache APISIX Authentication Bypass Vulnerability",
+            "dateAdded": "2022-08-25",
+            "shortDescription": "Apache APISIX contains an authentication bypass vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/lists.apache.org\/thread\/lcdqywz8zy94mdysk7p3gfdgn51jmt94;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-24112",
+            "cwes": [
+                "CWE-290"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22963",
+            "vendorProject": "VMware Tanzu",
+            "product": "Spring Cloud",
+            "vulnerabilityName": "VMware Tanzu Spring Cloud Function Remote Code Execution Vulnerability",
+            "dateAdded": "2022-08-25",
+            "shortDescription": "When using routing functionality in VMware Tanzu's Spring Cloud Function, it is possible for a user to provide a specially crafted SpEL as a routing-expression that may result in remote code execution and access to local resources.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/tanzu.vmware.com\/security\/cve-2022-22963;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22963",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-2294",
+            "vendorProject": "WebRTC",
+            "product": "WebRTC",
+            "vulnerabilityName": "WebRTC Heap Buffer Overflow Vulnerability",
+            "dateAdded": "2022-08-25",
+            "shortDescription": "WebRTC, an open-source project providing web browsers with real-time communication, contains a heap buffer overflow vulnerability that allows an attacker to perform shellcode execution. This vulnerability impacts web browsers using WebRTC including but not limited to Google Chrome.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/groups.google.com\/g\/discuss-webrtc\/c\/5KBtZx2gvcQ;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-2294",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-39226",
+            "vendorProject": "Grafana Labs",
+            "product": "Grafana",
+            "vulnerabilityName": "Grafana Authentication Bypass Vulnerability",
+            "dateAdded": "2022-08-25",
+            "shortDescription": "Grafana contains an authentication bypass vulnerability that allows authenticated and unauthenticated users to view and delete all snapshot data, potentially resulting in complete snapshot data loss.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/grafana.com\/blog\/2021\/10\/05\/grafana-7.5.11-and-8.1.6-released-with-critical-security-fix\/; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-39226",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-38406",
+            "vendorProject": "Delta Electronics",
+            "product": "DOPSoft 2",
+            "vulnerabilityName": "Delta Electronics DOPSoft 2 Improper Input Validation Vulnerability",
+            "dateAdded": "2022-08-25",
+            "shortDescription": "Delta Electronics DOPSoft 2 lacks proper validation of user-supplied data when parsing specific project files (improper input validation) resulting in an out-of-bounds write that allows for code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-09-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/www.cisa.gov\/uscert\/ics\/advisories\/icsa-21-252-02; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-38406",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-31010",
+            "vendorProject": "Apple",
+            "product": "iOS, macOS, watchOS",
+            "vulnerabilityName": "Apple iOS, macOS, watchOS Sandbox Bypass Vulnerability",
+            "dateAdded": "2022-08-25",
+            "shortDescription": "In affected versions of Apple iOS, macOS, and watchOS, a sandboxed process may be able to circumvent sandbox restrictions.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-us\/HT212804, https:\/\/support.apple.com\/en-us\/HT212805, https:\/\/support.apple.com\/en-us\/HT212806, https:\/\/support.apple.com\/en-us\/HT212807, https:\/\/support.apple.com\/en-us\/HT212824; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-31010",
+            "cwes": [
+                "CWE-20",
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-36193",
+            "vendorProject": "PEAR",
+            "product": "Archive_Tar",
+            "vulnerabilityName": "PEAR Archive_Tar Improper Link Resolution Vulnerability",
+            "dateAdded": "2022-08-25",
+            "shortDescription": "PEAR Archive_Tar Tar.php allows write operations with directory traversal due to inadequate checking of symbolic links. PEAR stands for PHP Extension and Application Repository and it is an open-source framework and distribution system for reusable PHP components with known usage in third-party products such as Drupal Core and Red Hat Linux.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/github.com\/pear\/Archive_Tar\/commit\/cde460582ff389404b5b3ccb59374e9b389de916, https:\/\/www.drupal.org\/sa-core-2021-001, https:\/\/access.redhat.com\/security\/cve\/cve-2020-36193; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-36193",
+            "cwes": [
+                "CWE-22",
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-28949",
+            "vendorProject": "PEAR",
+            "product": "Archive_Tar",
+            "vulnerabilityName": "PEAR Archive_Tar Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2022-08-25",
+            "shortDescription": "PEAR Archive_Tar allows an unserialization attack because phar: is blocked but PHAR: is not blocked. PEAR stands for PHP Extension and Application Repository and it is an open-source framework and distribution system for reusable PHP components with known usage in third-party products such as Drupal Core and Red Hat Linux.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/pear.php.net\/bugs\/bug.php?id=27002, https:\/\/www.drupal.org\/sa-core-2020-013, https:\/\/access.redhat.com\/security\/cve\/cve-2020-28949; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-28949",
+            "cwes": [
+                "CWE-74"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-0028",
+            "vendorProject": "Palo Alto Networks",
+            "product": "PAN-OS",
+            "vulnerabilityName": "Palo Alto Networks PAN-OS Reflected Amplification Denial-of-Service Vulnerability",
+            "dateAdded": "2022-08-22",
+            "shortDescription": "A Palo Alto Networks PAN-OS URL filtering policy misconfiguration could allow a network-based attacker to conduct reflected and amplified TCP denial-of-service (RDoS) attacks.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-12",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.paloaltonetworks.com\/CVE-2022-0028; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-0028",
+            "cwes": [
+                "CWE-940"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22536",
+            "vendorProject": "SAP",
+            "product": "Multiple Products",
+            "vulnerabilityName": "SAP Multiple Products HTTP Request Smuggling Vulnerability",
+            "dateAdded": "2022-08-18",
+            "shortDescription": "SAP NetWeaver Application Server ABAP, SAP NetWeaver Application Server Java, ABAP Platform, SAP Content Server and SAP Web Dispatcher allow HTTP request smuggling. An unauthenticated attacker can prepend a victim's request with arbitrary data, allowing for function execution impersonating the victim or poisoning intermediary Web caches.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "SAP users must have an account in order to login and access the patch. https:\/\/accounts.sap.com\/saml2\/idp\/sso;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22536",
+            "cwes": [
+                "CWE-444"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-32894",
+            "vendorProject": "Apple",
+            "product": "iOS and macOS",
+            "vulnerabilityName": "Apple iOS and macOS Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2022-08-18",
+            "shortDescription": "Apple iOS and macOS contain an out-of-bounds write vulnerability that could allow an application to execute code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-gb\/HT213412, https:\/\/support.apple.com\/en-gb\/HT213413;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-32894",
+            "cwes": [
+                "CWE-20",
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-32893",
+            "vendorProject": "Apple",
+            "product": "iOS and macOS",
+            "vulnerabilityName": "Apple iOS and macOS Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2022-08-18",
+            "shortDescription": "Apple iOS and macOS contain an out-of-bounds write vulnerability that could allow for remote code execution when processing malicious crafted web content.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/support.apple.com\/en-gb\/HT213412, https:\/\/support.apple.com\/en-gb\/HT213413;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-32893",
+            "cwes": [
+                "CWE-20",
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-2856",
+            "vendorProject": "Google",
+            "product": "Chromium Intents",
+            "vulnerabilityName": "Google Chromium Intents Insufficient Input Validation Vulnerability",
+            "dateAdded": "2022-08-18",
+            "shortDescription": "Google Chromium Intents contains an insufficient validation of untrusted input vulnerability that allows a remote attacker to browse to a malicious website via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/chromereleases.googleblog.com\/2022\/08\/stable-channel-update-for-desktop_16.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-2856",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26923",
+            "vendorProject": "Microsoft",
+            "product": "Active Directory",
+            "vulnerabilityName": "Microsoft Active Directory Domain Services Privilege Escalation Vulnerability",
+            "dateAdded": "2022-08-18",
+            "shortDescription": "An authenticated user could manipulate attributes on computer accounts they own or manage, and acquire a certificate from Active Directory Certificate Services that would allow for privilege escalation to SYSTEM.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/en-US\/vulnerability\/CVE-2022-26923;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26923",
+            "cwes": [
+                "CWE-295"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-21971",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Runtime Remote Code Execution Vulnerability",
+            "dateAdded": "2022-08-18",
+            "shortDescription": "Microsoft Windows Runtime contains an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2022-21971;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-21971",
+            "cwes": [
+                "CWE-824"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-15944",
+            "vendorProject": "Palo Alto Networks",
+            "product": "PAN-OS",
+            "vulnerabilityName": "Palo Alto Networks PAN-OS Remote Code Execution Vulnerability",
+            "dateAdded": "2022-08-18",
+            "shortDescription": "Palo Alto Networks PAN-OS contains multiple, unspecified vulnerabilities which can allow for remote code execution when chained.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/security.paloaltonetworks.com\/CVE-2017-15944; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-15944",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2022-27925",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Arbitrary File Upload Vulnerability",
+            "dateAdded": "2022-08-11",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) contains flaw in the mboximport functionality, allowing an authenticated attacker to upload arbitrary files to perform remote code execution. This vulnerability was chained with CVE-2022-37042 which allows for unauthenticated remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-01",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/blog.zimbra.com\/2022\/08\/authentication-bypass-in-mailboximportservlet-vulnerability\/;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-27925",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-37042",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Authentication Bypass Vulnerability",
+            "dateAdded": "2022-08-11",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) contains an authentication bypass vulnerability in MailboxImportServlet. This vulnerability was chained with CVE-2022-27925 which allows for unauthenticated remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-01",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/blog.zimbra.com\/2022\/08\/authentication-bypass-in-mailboximportservlet-vulnerability\/;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-37042",
+            "cwes": [
+                "CWE-23"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-34713",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Support Diagnostic Tool (MSDT) Remote Code Execution Vulnerability",
+            "dateAdded": "2022-08-09",
+            "shortDescription": "A remote code execution vulnerability exists when Microsoft Windows MSDT is called using the URL protocol from a calling application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2022-34713;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-34713",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2022-30333",
+            "vendorProject": "RARLAB",
+            "product": "UnRAR",
+            "vulnerabilityName": "RARLAB UnRAR Directory Traversal Vulnerability",
+            "dateAdded": "2022-08-09",
+            "shortDescription": "RARLAB UnRAR on Linux and UNIX contains a directory traversal vulnerability, allowing an attacker to write to files during an extract (unpack) operation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-30",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Vulnerability updated with version 6.12. Accessing link will download update information: https:\/\/www.rarlab.com\/rar\/rarlinux-x32-612.tar.gz;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-30333",
+            "cwes": [
+                "CWE-22",
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-27924",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Command Injection Vulnerability",
+            "dateAdded": "2022-08-04",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) allows an attacker to inject memcache commands into a targeted instance which causes an overwrite of arbitrary cached entries.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-25",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/wiki.zimbra.com\/wiki\/Zimbra_Releases\/9.0.0\/P24.1#Security_Fixes;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-27924",
+            "cwes": [
+                "CWE-93"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26138",
+            "vendorProject": "Atlassian",
+            "product": "Confluence",
+            "vulnerabilityName": "Atlassian Questions For Confluence App Hard-coded Credentials Vulnerability",
+            "dateAdded": "2022-07-29",
+            "shortDescription": "Atlassian Questions For Confluence App has hard-coded credentials, exposing the username and password in plaintext. A remote unauthenticated attacker can use these credentials to log into Confluence and access all content accessible to users in the confluence-users group.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-19",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/confluence.atlassian.com\/doc\/questions-for-confluence-security-advisory-2022-07-20-1142446709.html;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26138",
+            "cwes": [
+                "CWE-798"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22047",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Client Server Runtime Subsystem (CSRSS) Privilege Escalation Vulnerability",
+            "dateAdded": "2022-07-12",
+            "shortDescription": "Microsoft Windows CSRSS contains an unspecified vulnerability that allows for privilege escalation to SYSTEM privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/msrc.microsoft.com\/update-guide\/vulnerability\/CVE-2022-22047;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22047",
+            "cwes": [
+                "CWE-426"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26925",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows LSA Spoofing Vulnerability",
+            "dateAdded": "2022-07-01",
+            "shortDescription": "Microsoft Windows Local Security Authority (LSA) contains a spoofing vulnerability where an attacker can coerce the domain controller to authenticate to the attacker using NTLM.",
+            "requiredAction": "Apply remediation actions outlined in CISA guidance [https:\/\/www.cisa.gov\/guidance-applying-june-microsoft-patch].",
+            "dueDate": "2022-07-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "WARNING: This update is required on all Microsoft Windows endpoints but if deployed to domain controllers without additional configuration changes the update breaks PIV\/CAC authentication. Read CISA implementation guidance carefully before deploying to domain controllers.;  https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26925",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-29499",
+            "vendorProject": "Mitel",
+            "product": "MiVoice Connect",
+            "vulnerabilityName": "Mitel MiVoice Connect Data Validation Vulnerability",
+            "dateAdded": "2022-06-27",
+            "shortDescription": "The Service Appliance component in Mitel MiVoice Connect allows remote code execution due to incorrect data validation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-18",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-29499",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30533",
+            "vendorProject": "Google",
+            "product": "Chromium PopupBlocker",
+            "vulnerabilityName": "Google Chromium PopupBlocker Security Bypass Vulnerability",
+            "dateAdded": "2022-06-27",
+            "shortDescription": "Google Chromium PopupBlocker contains an insufficient policy enforcement vulnerability that allows a remote attacker to bypass navigation restrictions via a crafted iframe. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30533",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-4034",
+            "vendorProject": "Red Hat",
+            "product": "Polkit",
+            "vulnerabilityName": "Red Hat Polkit Out-of-Bounds Read and Write Vulnerability",
+            "dateAdded": "2022-06-27",
+            "shortDescription": "The Red Hat polkit pkexec utility contains an out-of-bounds read and write vulnerability that allows for privilege escalation with administrative rights.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-4034",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30983",
+            "vendorProject": "Apple",
+            "product": "iOS and iPadOS",
+            "vulnerabilityName": "Apple iOS and iPadOS Buffer Overflow Vulnerability",
+            "dateAdded": "2022-06-27",
+            "shortDescription": "Apple iOS and iPadOS contain a buffer overflow vulnerability that could allow an application to execute code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30983",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3837",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Memory Corruption Vulnerability",
+            "dateAdded": "2022-06-27",
+            "shortDescription": "Apple iOS, iPadOS, macOS, tvOS, and watchOS contain a memory corruption vulnerability that could allow an application to execute code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3837",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-9907",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Memory Corruption Vulnerability",
+            "dateAdded": "2022-06-27",
+            "shortDescription": "Apple iOS, iPadOS, and tvOS contain a memory corruption vulnerability that could allow an application to execute code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-9907",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-8605",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Use-After-Free Vulnerability",
+            "dateAdded": "2022-06-27",
+            "shortDescription": "A use-after-free vulnerability in Apple iOS, macOS, tvOS, and watchOS could allow a malicious application to execute code with system privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-8605",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-4344",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Memory Corruption Vulnerability",
+            "dateAdded": "2022-06-27",
+            "shortDescription": "Apple iOS, macOS, tvOS, and watchOS contain a memory corruption vulnerability which can allow for code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-4344",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-30190",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Support Diagnostic Tool (MSDT) Remote Code Execution Vulnerability",
+            "dateAdded": "2022-06-14",
+            "shortDescription": "A remote code execution vulnerability exists when MSDT is called using the URL protocol from a calling application such as Word. An attacker who successfully exploits this vulnerability can run code with the privileges of the calling application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-30190",
+            "cwes": [
+                "CWE-610"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-38163",
+            "vendorProject": "SAP",
+            "product": "NetWeaver",
+            "vulnerabilityName": "SAP NetWeaver Unrestricted File Upload Vulnerability",
+            "dateAdded": "2022-06-09",
+            "shortDescription": "SAP NetWeaver contains a vulnerability that allows unrestricted file upload.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-38163",
+            "cwes": [
+                "CWE-23"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-2386",
+            "vendorProject": "SAP",
+            "product": "NetWeaver",
+            "vulnerabilityName": "SAP NetWeaver SQL Injection Vulnerability",
+            "dateAdded": "2022-06-09",
+            "shortDescription": "SQL injection vulnerability in the UDDI server in SAP NetWeaver J2EE Engine 7.40 allows remote attackers to execute arbitrary SQL commands via unspecified vectors.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-2386",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-2388",
+            "vendorProject": "SAP",
+            "product": "NetWeaver",
+            "vulnerabilityName": "SAP NetWeaver Information Disclosure Vulnerability",
+            "dateAdded": "2022-06-09",
+            "shortDescription": "The Universal Worklist Configuration in SAP NetWeaver AS JAVA 7.4 allows remote attackers to obtain sensitive user information via a crafted HTTP request.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-30",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-2388",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-7195",
+            "vendorProject": "QNAP",
+            "product": "Photo Station",
+            "vulnerabilityName": "QNAP Photo Station Path Traversal Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "QNAP devices running Photo Station contain an external control of file name or path vulnerability allowing remote attackers to access or modify system files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-7195",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-7194",
+            "vendorProject": "QNAP",
+            "product": "Photo Station",
+            "vulnerabilityName": "QNAP Photo Station Path Traversal Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "QNAP devices running Photo Station contain an external control of file name or path vulnerability allowing remote attackers to access or modify system files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-7194",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-7193",
+            "vendorProject": "QNAP",
+            "product": "QTS",
+            "vulnerabilityName": "QNAP QTS Improper Input Validation Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "QNAP QTS contains an improper input validation vulnerability allowing remote attackers to inject code on the system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-7193",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-7192",
+            "vendorProject": "QNAP",
+            "product": "Photo Station",
+            "vulnerabilityName": "QNAP Photo Station Improper Access Control Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "QNAP NAS devices running Photo Station contain an improper access control vulnerability allowing remote attackers to gain unauthorized access to the system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-7192",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-5825",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Google Chromium V8 Engine contains an out-of-bounds write vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-5825",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-15271",
+            "vendorProject": "Cisco",
+            "product": "RV Series Routers",
+            "vulnerabilityName": "Cisco RV Series Routers Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "A deserialization of untrusted data vulnerability in the web-based management interface of certain Cisco Small Business RV Series Routers could allow an attacker to execute code with root privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-15271",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-6065",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Integer Overflow Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Google Chromium V8 Engine contains an integer overflow vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-6065",
+            "cwes": [
+                "CWE-190",
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-4990",
+            "vendorProject": "Adobe",
+            "product": "Acrobat and Reader",
+            "vulnerabilityName": "Adobe Acrobat and Reader Double Free Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Adobe Acrobat and Reader have a double free vulnerability that could lead to remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-4990",
+            "cwes": [
+                "CWE-415"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-17480",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Google Chromium V8 Engine contains out-of-bounds write vulnerability that allows a remote attacker to execute code inside a sandbox via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-17480",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-17463",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Remote Code Execution Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Google Chromium V8 Engine contains an unspecified vulnerability that allows a remote attacker to execute code inside a sandbox via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-17463",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2017-6862",
+            "vendorProject": "NETGEAR",
+            "product": "Multiple Devices",
+            "vulnerabilityName": "NETGEAR Multiple Devices Buffer Overflow Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Multiple NETGEAR devices contain a buffer overflow vulnerability that allows for authentication bypass and remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6862",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-5070",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Google Chromium V8 Engine contains a type confusion vulnerability that allows a remote attacker to execute code inside a sandbox via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-5070",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-5030",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Memory Corruption Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Google Chromium V8 Engine contains a memory corruption vulnerability that allows a remote attacker to execute code via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-5030",
+            "cwes": [
+                "CWE-125"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-5198",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Out-of-Bounds Memory Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Google Chromium V8 Engine contains an out-of-bounds memory access vulnerability that allows a remote attacker to perform read\/write operations, leading to code execution, via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-5198",
+            "cwes": [
+                "CWE-125",
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-1646",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Out-of-Bounds Read Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Google Chromium V8 Engine contains an out-of-bounds read vulnerability that allows a remote attacker to cause a denial of service or possibly have another unspecified impact via crafted JavaScript code. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-1646",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-1331",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Buffer Overflow Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Microsoft Office contains a buffer overflow vulnerability that allows remote attackers to execute code via crafted PNG data in an Office document.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-1331",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-5054",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Integer Overflow Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Adobe Flash Player contains an integer overflow vulnerability that allows remote attackers to execute code via malformed arguments.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-5054",
+            "cwes": [
+                "CWE-189"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-4969",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Use-After-Free Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Microsoft Internet Explorer contains a use-after-free vulnerability that allows remote attackers to execute code via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-4969",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2012-1889",
+            "vendorProject": "Microsoft",
+            "product": "XML Core Services",
+            "vulnerabilityName": "Microsoft XML Core Services Memory Corruption Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Microsoft XML Core Services contains a memory corruption vulnerability which could allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-1889",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-0767",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Adobe Flash Player contains a XSS vulnerability that allows remote attackers to inject web script or HTML.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-0767",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-0754",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Memory Corruption Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Adobe Flash Player contains a memory corruption vulnerability that allows remote attackers to execute code or cause denial-of-service (DoS).",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-0754",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-0151",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Authenticode Signature Verification Remote Code Execution Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "The Authenticode Signature Verification function in Microsoft Windows (WinVerifyTrust) does not properly validate the digest of a signed portable executable (PE) file, which allows user-assisted remote attackers to execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-0151",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2011-2462",
+            "vendorProject": "Adobe",
+            "product": "Reader and Acrobat",
+            "vulnerabilityName": "Adobe Reader and Acrobat Universal 3D Memory Corruption Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "The Universal 3D (U3D) component in Adobe Reader and Acrobat contains a memory corruption vulnerability which could allow remote attackers to execute code or cause denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2011-2462",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2011-0609",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Unspecified Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Adobe Flash Player contains an unspecified vulnerability that allows remote attackers to execute code or cause denial-of-service (DoS).",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2011-0609",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2010-2883",
+            "vendorProject": "Adobe",
+            "product": "Acrobat and Reader",
+            "vulnerabilityName": "Adobe Acrobat and Reader Stack-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Adobe Acrobat and Reader contain a stack-based buffer overflow vulnerability that allows remote attackers to execute code or cause denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-2883",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-2572",
+            "vendorProject": "Microsoft",
+            "product": "PowerPoint",
+            "vulnerabilityName": "Microsoft PowerPoint Buffer Overflow Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Microsoft PowerPoint contains a buffer overflow vulnerability that alllows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-2572",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-1297",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Memory Corruption Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Adobe Flash Player contains a memory corruption vulnerability that allows remote attackers to execute code or cause denial-of-service (DoS).",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-1297",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2009-4324",
+            "vendorProject": "Adobe",
+            "product": "Acrobat and Reader",
+            "vulnerabilityName": "Adobe Acrobat and Reader Use-After-Free Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Use-after-free vulnerability in Adobe Acrobat and Reader allows remote attackers to execute code via a crafted PDF file.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2009-4324",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2009-3953",
+            "vendorProject": "Adobe",
+            "product": "Acrobat and Reader",
+            "vulnerabilityName": "Adobe Acrobat and Reader Universal 3D Remote Code Execution Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Adobe Acrobat and Reader contains an array boundary issue in Universal 3D (U3D) support that could lead to remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2009-3953",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2009-1862",
+            "vendorProject": "Adobe",
+            "product": "Acrobat and Reader, Flash Player",
+            "vulnerabilityName": "Adobe Acrobat and Reader, Flash Player Unspecified Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Adobe Acrobat and Reader and Adobe Flash Player allows remote attackers to execute code or cause denial-of-service (DoS).",
+            "requiredAction": "For Adobe Acrobat and Reader, apply updates per vendor instructions. For Adobe Flash Player, the impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2009-1862",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2009-0563",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Buffer Overflow Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Microsoft Office contains a buffer overflow vulnerability that allows remote attackers to execute code via a Word document with a crafted tag containing an invalid length field.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2009-0563",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2009-0557",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Object Record Corruption Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Microsoft Office contains an object record corruption vulnerability that allows remote attackers to execute code via a crafted Excel file with a malformed record object.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2009-0557",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2008-0655",
+            "vendorProject": "Adobe",
+            "product": "Acrobat and Reader",
+            "vulnerabilityName": "Adobe Acrobat and Reader Unspecified Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Adobe Acrobat and Reader contains an unespecified vulnerability described as a design flaw which could allow a specially crafted file to be printed silently an arbitrary number of times.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2008-0655",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2007-5659",
+            "vendorProject": "Adobe",
+            "product": "Acrobat and Reader",
+            "vulnerabilityName": "Adobe Acrobat and Reader Buffer Overflow Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Adobe Acrobat and Reader contain a buffer overflow vulnerability that allows remote attackers to execute code via a PDF file with long arguments to unspecified JavaScript methods.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2007-5659",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2006-2492",
+            "vendorProject": "Microsoft",
+            "product": "Word",
+            "vulnerabilityName": "Microsoft Word Malformed Object Pointer Vulnerability",
+            "dateAdded": "2022-06-08",
+            "shortDescription": "Microsoft Word and Microsoft Works Suites contain a malformed object pointer which allows attackers to execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-22",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2006-2492",
+            "cwes": [
+                "CWE-120"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26134",
+            "vendorProject": "Atlassian",
+            "product": "Confluence Server\/Data Center",
+            "vulnerabilityName": "Atlassian Confluence Server and Data Center Remote Code Execution Vulnerability",
+            "dateAdded": "2022-06-02",
+            "shortDescription": "Atlassian Confluence Server and Data Center contain a remote code execution vulnerability that allows for an unauthenticated attacker to perform remote code execution.",
+            "requiredAction": "Immediately block all internet traffic to and from affected products AND apply the update per vendor instructions [https:\/\/confluence.atlassian.com\/doc\/confluence-security-advisory-2022-06-02-1130377146.html] OR remove the affected products by the due date on the right. Note: Once the update is successfully deployed, agencies can reassess the internet blocking rules.",
+            "dueDate": "2022-06-06",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26134",
+            "cwes": [
+                "CWE-917"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-3010",
+            "vendorProject": "Oracle",
+            "product": "Solaris",
+            "vulnerabilityName": "Oracle Solaris Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Oracle Solaris component: XScreenSaver contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-3010",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2016-3393",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Graphics Device Interface (GDI) Remote Code Execution Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "A remote code execution vulnerability exists due to the way the Windows GDI component handles objects in the memory. An attacker who successfully exploits this vulnerability could take control of the affected system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-3393",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-7256",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Open Type Font Remote Code Execution Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "A remote code execution vulnerability exists when the Windows font library improperly handles specially crafted embedded fonts. An attacker who successfully exploits this vulnerability could take control of the affected system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-7256",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-1010",
+            "vendorProject": "Adobe",
+            "product": "Flash Player and AIR",
+            "vulnerabilityName": "Adobe Flash Player and AIR Integer Overflow Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Integer overflow vulnerability in Adobe Flash Player and AIR allows attackers to execute code.",
+            "requiredAction": "The impacted products are end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-1010",
+            "cwes": [
+                "CWE-190"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-0984",
+            "vendorProject": "Adobe",
+            "product": "Flash Player and AIR",
+            "vulnerabilityName": "Adobe Flash Player and AIR Use-After-Free Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Use-after-free vulnerability in Adobe Flash Player and Adobe AIR allows attackers to execute code.",
+            "requiredAction": "The impacted products are end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-0984",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-0034",
+            "vendorProject": "Microsoft",
+            "product": "Silverlight",
+            "vulnerabilityName": "Microsoft Silverlight Runtime Remote Code Execution Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Microsoft Silverlight mishandles negative offsets during decoding, which allows attackers to execute remote code or cause a denial-of-service (DoS).",
+            "requiredAction": "The impacted products are end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-0034",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-0310",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player ASLR Bypass Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Adobe Flash Player does not properly restrict discovery of memory addresses, which allows attackers to bypass the address space layout randomization (ASLR) protection mechanism.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-0310",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-0016",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows TS WebProxy Directory Traversal Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Directory traversal vulnerability in the TS WebProxy (TSWbPrxy) component in Microsoft Windows allows remote attackers to escalate privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-0016",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-0071",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer ASLR Bypass Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Microsoft Internet Explorer allows remote attackers to bypass the address space layout randomization (ASLR) protection mechanism via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-0071",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-2360",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Win32k.sys in the kernel-mode drivers in Microsoft Windows allows local users to gain privileges or cause denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-2360",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-2425",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Memory Corruption Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Microsoft Internet Explorer contains a memory corruption vulnerability that allows remote attackers to execute code or cause denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-2425",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-1769",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Mount Manager Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "A privilege escalation vulnerability exists when the Windows Mount Manager component improperly processes symbolic links.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-1769",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-4495",
+            "vendorProject": "Mozilla",
+            "product": "Firefox",
+            "vulnerabilityName": "Mozilla Firefox Security Feature Bypass Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Moxilla Firefox allows remote attackers to bypass the Same Origin Policy to read arbitrary files or gain privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-4495",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-8651",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Integer Overflow Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Integer overflow in Adobe Flash Player allows attackers to execute code.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-8651",
+            "cwes": [
+                "CWE-189"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-6175",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "The kernel in Microsoft Windows contains a vulnerability that allows local users to gain privileges via a crafted application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-6175",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-1671",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Remote Code Execution Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "A remote code execution vulnerability exists when components of Windows, .NET Framework, Office, Lync, and Silverlight fail to properly handle TrueType fonts.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-1671",
+            "cwes": [
+                "CWE-19"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-4148",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Remote Code Execution Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "A remote code execution vulnerability exists when the Windows kernel-mode driver improperly handles TrueType fonts.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-4148",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-8439",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Dereferenced Pointer Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Adobe Flash Player has a vulnerability in the way it handles a dereferenced memory pointer which could lead to code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-8439",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-4123",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Microsoft Internet Explorer contains an unspecified vulnerability that allows remote attackers to gain privileges via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-4123",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-0546",
+            "vendorProject": "Adobe",
+            "product": "Reader and Acrobat",
+            "vulnerabilityName": "Adobe Reader and Acrobat Sandbox Bypass Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Adobe Reader and Acrobat on Windows allow attackers to bypass a sandbox protection mechanism, and consequently execute native code in a privileged context.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-0546",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2014-2817",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Microsoft Internet Explorer cotains an unspecified vulnerability that allows remote attackers to gain privileges via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-2817",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-4077",
+            "vendorProject": "Microsoft",
+            "product": "Input Method Editor (IME) Japanese",
+            "vulnerabilityName": "Microsoft IME Japanese Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Microsoft Input Method Editor (IME) Japanese is a keyboard with Japanese characters that can be enabled on Windows systems as it is included by default (with the default set as disabled). IME Japanese contains an unspecified vulnerability when IMJPDCT.EXE (IME for Japanese) is installed which allows attackers to bypass a sandbox and perform privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-4077",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-3153",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "The futex_requeue function in kernel\/futex.c in Linux kernel does not ensure that calls have two different futex addresses, which allows local users to gain privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-3153",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-7331",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Information Disclosure Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "An information disclosure vulnerability exists in Internet Explorer which allows resources loaded into memory to be queried. This vulnerability could allow an attacker to detect anti-malware applications.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-7331",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-3993",
+            "vendorProject": "IBM",
+            "product": "InfoSphere BigInsights",
+            "vulnerabilityName": "IBM InfoSphere BigInsights Invalid Input Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Certain APIs within BigInsights can take invalid input that might allow attackers unauthorized access to read, write, modify, or delete data.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-3993",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-3896",
+            "vendorProject": "Microsoft",
+            "product": "Silverlight",
+            "vulnerabilityName": "Microsoft Silverlight Information Disclosure Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Microsoft Silverlight does not properly validate pointers during access to Silverlight elements, which allows remote attackers to obtain sensitive information via a crafted Silverlight application.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-3896",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-2423",
+            "vendorProject": "Oracle",
+            "product": "Java Runtime Environment (JRE)",
+            "vulnerabilityName": "Oracle JRE Unspecified Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Unspecified vulnerability in hotspot for Java Runtime Environment (JRE) allows remote attackers to affect integrity.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-2423",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2013-0431",
+            "vendorProject": "Oracle",
+            "product": "Java Runtime Environment (JRE)",
+            "vulnerabilityName": "Oracle JRE Sandbox Bypass Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle allows remote attackers to bypass the Java security sandbox.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-0431",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2013-0422",
+            "vendorProject": "Oracle",
+            "product": "Java Runtime Environment (JRE)",
+            "vulnerabilityName": "Oracle JRE Remote Code Execution Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "A vulnerability in the way Java restricts the permissions of Java applets could allow an attacker to execute commands on a vulnerable system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-0422",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-0074",
+            "vendorProject": "Microsoft",
+            "product": "Silverlight",
+            "vulnerabilityName": "Microsoft Silverlight Double Dereference Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Microsoft Silverlight does not properly validate pointers during HTML object rendering, which allows remote attackers to execute code via a crafted Silverlight application.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-0074",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2012-1710",
+            "vendorProject": "Oracle",
+            "product": "Fusion Middleware",
+            "vulnerabilityName": "Oracle Fusion Middleware Unspecified Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Unspecified vulnerability in the Oracle WebCenter Forms Recognition component in Oracle Fusion Middleware allows remote attackers to affect confidentiality, integrity, and availability via Unknown vectors related to Designer.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-1710",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2010-1428",
+            "vendorProject": "Red Hat",
+            "product": "JBoss",
+            "vulnerabilityName": "Red Hat JBoss Information Disclosure Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Unauthenticated access to the JBoss Application Server Web Console (\/web-console) is blocked by default. However, it was found that this block was incomplete, and only blocked GET and POST HTTP verbs. A remote attacker could use this flaw to gain access to sensitive information.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-1428",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-0840",
+            "vendorProject": "Oracle",
+            "product": "Java Runtime Environment (JRE)",
+            "vulnerabilityName": "Oracle JRE Unspecified Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "Unspecified vulnerability in the Java Runtime Environment (JRE) in Java SE component allows remote attackers to affect confidentiality, integrity, and availability via Unknown vectors.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-0840",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2010-0738",
+            "vendorProject": "Red Hat",
+            "product": "JBoss",
+            "vulnerabilityName": "Red Hat JBoss Authentication Bypass Vulnerability",
+            "dateAdded": "2022-05-25",
+            "shortDescription": "The JMX-Console web application in JBossAs in Red Hat JBoss Enterprise Application Platform performs access control only for the GET and POST methods, which allows remote attackers to send requests to this application's GET handler by using a different method.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-0738",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-8611",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "A privilege escalation vulnerability exists when the Windows kernel fails to properly handle objects in memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8611",
+            "cwes": [
+                "CWE-404"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-19953",
+            "vendorProject": "QNAP",
+            "product": "Network Attached Storage (NAS)",
+            "vulnerabilityName": "QNAP NAS File Station Cross-Site Scripting Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "A cross-site scripting vulnerability affecting QNAP NAS File Station could allow remote attackers to inject malicious code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-19953",
+            "cwes": [
+                "CWE-79",
+                "CWE-80"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-19949",
+            "vendorProject": "QNAP",
+            "product": "Network Attached Storage (NAS)",
+            "vulnerabilityName": "QNAP NAS File Station Command Injection Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "A command injection vulnerability affecting QNAP NAS File Station could allow remote attackers to run commands.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-19949",
+            "cwes": [
+                "CWE-20",
+                "CWE-77",
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-19943",
+            "vendorProject": "QNAP",
+            "product": "Network Attached Storage (NAS)",
+            "vulnerabilityName": "QNAP NAS File Station Cross-Site Scripting Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "A cross-site scripting vulnerability affecting QNAP NAS File Station could allow remote attackers to inject malicious code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-19943",
+            "cwes": [
+                "CWE-79",
+                "CWE-80"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0147",
+            "vendorProject": "Microsoft",
+            "product": "SMBv1 server",
+            "vulnerabilityName": "Microsoft Windows SMBv1 Information Disclosure Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "The SMBv1 server in Microsoft Windows allows remote attackers to obtain sensitive information from process memory via a crafted packet.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0147",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0022",
+            "vendorProject": "Microsoft",
+            "product": "XML Core Services",
+            "vulnerabilityName": "Microsoft XML Core Services Information Disclosure Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "Microsoft XML Core Services (MSXML) improperly handles objects in memory, allowing attackers to test for files on disk via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0022",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0005",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Graphics Device Interface (GDI) Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "The Graphics Device Interface (GDI) in Microsoft Windows allows local users to gain privileges via a crafted application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0005",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0149",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Memory Corruption Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "Microsoft Internet Explorer contains a memory corruption vulnerability that allows remote attackers to execute code or cause a denial-of-service (DoS) via a crafted website.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0149",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0210",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "A privilege escalation vulnerability exists when Internet Explorer does not properly enforce cross-domain policies, which could allow an attacker to access information.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0210",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2017-8291",
+            "vendorProject": "Artifex",
+            "product": "Ghostscript",
+            "vulnerabilityName": "Artifex Ghostscript Type Confusion Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "Artifex Ghostscript allows -dSAFER bypass and remote command execution via .rsdparams type confusion with a \"\/OutputFile.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-8291",
+            "cwes": [
+                "CWE-704"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-8543",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Search Remote Code Execution Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "Microsoft Windows allows an attacker to take control of the affected system when Windows Search fails to handle objects in memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-8543",
+            "cwes": [
+                "CWE-281"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-18362",
+            "vendorProject": "Kaseya",
+            "product": "Virtual System\/Server Administrator (VSA)",
+            "vulnerabilityName": "Kaseya VSA SQL Injection Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "ConnectWise ManagedITSync integration for Kaseya VSA is vulnerable to unauthenticated remote commands that allow full direct access to the Kaseya VSA database.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-18362",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-0162",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Information Disclosure Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "An information disclosure vulnerability exists when Internet Explorer does not properly handle JavaScript. The vulnerability could allow an attacker to detect specific files on the user's computer.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-0162",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-3351",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer and Edge",
+            "vulnerabilityName": "Microsoft Internet Explorer and Edge Information Disclosure Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "An information disclosure vulnerability exists in the way that certain functions in Internet Explorer and Edge handle objects in memory. The vulnerability could allow an attacker to detect specific files on the user's computer.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-3351",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-4655",
+            "vendorProject": "Apple",
+            "product": "iOS",
+            "vulnerabilityName": "Apple iOS Information Disclosure Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "The Apple iOS kernel allows attackers to obtain sensitive information from memory via a crafted application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-4655",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-4656",
+            "vendorProject": "Apple",
+            "product": "iOS",
+            "vulnerabilityName": "Apple iOS Memory Corruption Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "A memory corruption vulnerability in Apple iOS kernel allows attackers to execute code in a privileged context or cause a denial-of-service (DoS) via a crafted application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-4656",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-4657",
+            "vendorProject": "Apple",
+            "product": "iOS",
+            "vulnerabilityName": "Apple iOS Webkit Memory Corruption Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "Apple iOS WebKit contains a memory corruption vulnerability that allows attackers to execute remote code or cause a denial-of-service (DoS) via a crafted web site. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-4657",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-6366",
+            "vendorProject": "Cisco",
+            "product": "Adaptive Security Appliance (ASA)",
+            "vulnerabilityName": "Cisco Adaptive Security Appliance (ASA) SNMP Buffer Overflow Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "A buffer overflow vulnerability in the Simple Network Management Protocol (SNMP) code of Cisco ASA software could allow an attacker to cause a reload of the affected system or to remotely execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-6366",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-6367",
+            "vendorProject": "Cisco",
+            "product": "Adaptive Security Appliance (ASA)",
+            "vulnerabilityName": "Cisco Adaptive Security Appliance (ASA) CLI Remote Code Execution Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "A vulnerability in the command-line interface (CLI) parser of Cisco ASA software could allow an authenticated, local attacker to create a denial-of-service (DoS) condition or potentially execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-6367",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-3298",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Messaging API Information Disclosure Vulnerability",
+            "dateAdded": "2022-05-24",
+            "shortDescription": "An information disclosure vulnerability exists when the Microsoft Internet Messaging API improperly handles objects in memory. An attacker who successfully exploited this vulnerability could allow the attacker to test for the presence of files on disk.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-14",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-3298",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-20821",
+            "vendorProject": "Cisco",
+            "product": "IOS XR",
+            "vulnerabilityName": "Cisco IOS XR Open Port Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "Cisco IOS XR software health check opens TCP port 6379 by default on activation. An attacker can connect to the Redis instance on the open port and allow access to the Redis instance that is running within the NOSi container.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-20821",
+            "cwes": [
+                "CWE-923"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1048",
+            "vendorProject": "Android",
+            "product": "Kernel",
+            "vulnerabilityName": "Android Kernel Use-After-Free Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "Android kernel contains a use-after-free vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1048",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-0920",
+            "vendorProject": "Android",
+            "product": "Kernel",
+            "vulnerabilityName": "Android Kernel Race Condition Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "Android kernel contains a race condition, which allows for a use-after-free vulnerability. Exploitation can allow for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-0920",
+            "cwes": [
+                "CWE-362",
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30883",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Memory Corruption Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "Apple iOS, macOS, watchOS, and tvOS contain a memory corruption vulnerability that could allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30883",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-1027",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "An elevation of privilege vulnerability exists in the way that the Windows Kernel handles objects in memory. An attacker who successfully exploited the vulnerability could execute code with elevated permissions.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-1027",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0638",
+            "vendorProject": "Microsoft",
+            "product": "Update Notification Manager",
+            "vulnerabilityName": "Microsoft Update Notification Manager Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "Microsoft Update Notification Manager contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0638",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-7286",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Memory Corruption Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "Apple iOS, macOS, watchOS, and tvOS contain a memory corruption vulnerability that could allow for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-7286",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-7287",
+            "vendorProject": "Apple",
+            "product": "iOS",
+            "vulnerabilityName": "Apple iOS Memory Corruption Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "Apple iOS contains a memory corruption vulnerability which could allow an attacker to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-7287",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0676",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Information Disclosure Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "An information disclosure vulnerability exists when Internet Explorer improperly handles objects in memory. An attacker who successfully exploited this vulnerability could test for the presence of files on disk.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0676",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-5786",
+            "vendorProject": "Google",
+            "product": "Chrome Blink",
+            "vulnerabilityName": "Google Chrome Blink Use-After-Free Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "Google Chrome Blink contains a heap use-after-free vulnerability that allows an attacker to potentially perform out of bounds memory access via a crafted HTML page.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-5786",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0703",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows SMB Information Disclosure Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "An information disclosure vulnerability exists in the way that the Windows SMB Server handles certain requests, which could lead to information disclosure from the server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0703",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-0880",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "A local elevation of privilege vulnerability exists in how splwow64.exe handles certain calls. An attacker who successfully exploited the vulnerability could elevate privileges on an affected system from low-integrity to medium-integrity.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0880",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-13720",
+            "vendorProject": "Google",
+            "product": "Chrome WebAudio",
+            "vulnerabilityName": "Google Chrome WebAudio Use-After-Free Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "Google Chrome WebAudio contains a use-after-free vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-13720",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-11707",
+            "vendorProject": "Mozilla",
+            "product": "Firefox and Thunderbird",
+            "vulnerabilityName": "Mozilla Firefox and Thunderbird Type Confusion Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "Mozilla Firefox and Thunderbird contain a type confusion vulnerability that can occur when manipulating JavaScript objects due to issues in Array.pop, allowing for an exploitable crash.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-11707",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-11708",
+            "vendorProject": "Mozilla",
+            "product": "Firefox and Thunderbird",
+            "vulnerabilityName": "Mozilla Firefox and Thunderbird Sandbox Escape Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "Mozilla Firefox and Thunderbird contain a sandbox escape vulnerability that could result in remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-11708",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-8720",
+            "vendorProject": "WebKitGTK",
+            "product": "WebKitGTK",
+            "vulnerabilityName": "WebKitGTK Memory Corruption Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "WebKitGTK contains a memory corruption vulnerability which can allow an attacker to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-8720",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-18426",
+            "vendorProject": "Meta Platforms",
+            "product": "WhatsApp",
+            "vulnerabilityName": "WhatsApp Cross-Site Scripting Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "A vulnerability in WhatsApp Desktop when paired with WhatsApp for iPhone allows cross-site scripting and local file reading.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-18426",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1385",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows AppX Deployment Extensions Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "A privilege escalation vulnerability exists when the Windows AppX Deployment Extensions improperly performs privilege management, resulting in access to system files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1385",
+            "cwes": [
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1130",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows AppX Deployment Service Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "A privilege escalation vulnerability exists when Windows AppX Deployment Service (AppXSVC) improperly handles hard links.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1130",
+            "cwes": [
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-5002",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Stack-based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "Adobe Flash Player have a stack-based buffer overflow vulnerability that could lead to remote code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-5002",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-8589",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-23",
+            "shortDescription": "A privilege escalation vulnerability exists when Windows improperly handles calls to Win32k.sys. An attacker who successfully exploited this vulnerability could run remote code in the security context of the local system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-13",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8589",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2022-30525",
+            "vendorProject": "Zyxel",
+            "product": "Multiple Firewalls",
+            "vulnerabilityName": "Zyxel Multiple Firewalls OS Command Injection Vulnerability",
+            "dateAdded": "2022-05-16",
+            "shortDescription": "A command injection vulnerability in the CGI program of some Zyxel firewall versions could allow an attacker to modify specific files and then execute some OS commands on a vulnerable device.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-30525",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22947",
+            "vendorProject": "VMware",
+            "product": "Spring Cloud Gateway",
+            "vulnerabilityName": "VMware Spring Cloud Gateway Code Injection Vulnerability",
+            "dateAdded": "2022-05-16",
+            "shortDescription": "Spring Cloud Gateway applications are vulnerable to a code injection attack when the Gateway Actuator endpoint is enabled, exposed and unsecured.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22947",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-1388",
+            "vendorProject": "F5",
+            "product": "BIG-IP",
+            "vulnerabilityName": "F5 BIG-IP Missing Authentication Vulnerability",
+            "dateAdded": "2022-05-10",
+            "shortDescription": "F5 BIG-IP contains a missing authentication in critical function vulnerability which can allow for remote code execution, creation or deletion of files, or disabling services.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-31",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-1388",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1789",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Type Confusion Vulnerability",
+            "dateAdded": "2022-05-04",
+            "shortDescription": "A type confusion issue affecting multiple Apple products allows processing of maliciously crafted web content, leading to arbitrary code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1789",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-8506",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Type Confusion Vulnerability",
+            "dateAdded": "2022-05-04",
+            "shortDescription": "A type confusion issue affecting multiple Apple products allows processing of maliciously crafted web content, leading to arbitrary code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-8506",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-4113",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-05-04",
+            "shortDescription": "Microsoft Win32k contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-4113",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-0322",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Use-After-Free Vulnerability",
+            "dateAdded": "2022-05-04",
+            "shortDescription": "Use-after-free vulnerability in Microsoft Internet Explorer allows remote attackers to execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-0322",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-0160",
+            "vendorProject": "OpenSSL",
+            "product": "OpenSSL",
+            "vulnerabilityName": "OpenSSL Information Disclosure Vulnerability",
+            "dateAdded": "2022-05-04",
+            "shortDescription": "The TLS and DTLS implementations in OpenSSL do not properly handle Heartbeat Extension packets, which allows remote attackers to obtain sensitive information.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-0160",
+            "cwes": [
+                "CWE-125"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-29464",
+            "vendorProject": "WSO2",
+            "product": "Multiple Products",
+            "vulnerabilityName": "WSO2 Multiple Products Unrestrictive Upload of File Vulnerability",
+            "dateAdded": "2022-04-25",
+            "shortDescription": "Multiple WSO2 products allow for unrestricted file upload, resulting in remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-16",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-29464",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26904",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows User Profile Service Privilege Escalation Vulnerability",
+            "dateAdded": "2022-04-25",
+            "shortDescription": "Microsoft Windows User Profile Service contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26904",
+            "cwes": [
+                "CWE-362"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-21919",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows User Profile Service Privilege Escalation Vulnerability",
+            "dateAdded": "2022-04-25",
+            "shortDescription": "Microsoft Windows User Profile Service contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-21919",
+            "cwes": [
+                "CWE-1386"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-0847",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-04-25",
+            "shortDescription": "Linux kernel contains an improper initialization vulnerability where an unprivileged local user could escalate their privileges on the system. This vulnerability has the moniker of \"Dirty Pipe.\"",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-0847",
+            "cwes": [
+                "CWE-665"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-41357",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-04-25",
+            "shortDescription": "Microsoft Win32k contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-41357",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-40450",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-04-25",
+            "shortDescription": "Microsoft Win32k contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-40450",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-1003029",
+            "vendorProject": "Jenkins",
+            "product": "Script Security Plugin",
+            "vulnerabilityName": "Jenkins Script Security Plugin Sandbox Bypass Vulnerability",
+            "dateAdded": "2022-04-25",
+            "shortDescription": "Jenkins Script Security Plugin contains a protection mechanism failure, allowing an attacker to bypass the sandbox.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-16",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1003029",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2018-6882",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2022-04-19",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) contains a cross-site scripting vulnerability that might allow remote attackers to inject arbitrary web script or HTML.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-6882",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-3568",
+            "vendorProject": "Meta Platforms",
+            "product": "WhatsApp",
+            "vulnerabilityName": "WhatsApp VOIP Stack Buffer Overflow Vulnerability",
+            "dateAdded": "2022-04-19",
+            "shortDescription": "A buffer overflow vulnerability in WhatsApp VOIP stack allowed remote code execution via specially crafted series of RTCP packets sent to a target phone number.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-3568",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22718",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Print Spooler Privilege Escalation Vulnerability",
+            "dateAdded": "2022-04-19",
+            "shortDescription": "Microsoft Windows Print Spooler contains an unspecified vulnerability which allow for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22718",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2022-22960",
+            "vendorProject": "VMware",
+            "product": "Multiple Products",
+            "vulnerabilityName": "VMware Multiple Products Privilege Escalation Vulnerability",
+            "dateAdded": "2022-04-15",
+            "shortDescription": "VMware Workspace ONE Access, Identity Manager and vRealize Automation contain a privilege escalation vulnerability due to improper permissions in support scripts.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22960",
+            "cwes": [
+                "CWE-250"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-1364",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2022-04-15",
+            "shortDescription": "Google Chromium V8 Engine contains a type confusion vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-1364",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-3929",
+            "vendorProject": "Crestron",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Crestron Multiple Products Command Injection Vulnerability",
+            "dateAdded": "2022-04-15",
+            "shortDescription": "Multiple Crestron products are vulnerable to command injection via the file_transfer.cgi HTTP endpoint. A remote, unauthenticated attacker can use this vulnerability to execute operating system commands as root.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-3929",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-16057",
+            "vendorProject": "D-Link",
+            "product": "DNS-320 Storage Device",
+            "vulnerabilityName": "D-Link DNS-320 Remote Code Execution Vulnerability",
+            "dateAdded": "2022-04-15",
+            "shortDescription": "The login_mgr.cgi script in D-Link DNS-320 is vulnerable to remote code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-05-06",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-16057",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-7841",
+            "vendorProject": "Schneider Electric",
+            "product": "U.motion Builder",
+            "vulnerabilityName": "Schneider Electric U.motion Builder SQL Injection Vulnerability",
+            "dateAdded": "2022-04-15",
+            "shortDescription": "A SQL Injection vulnerability exists in U.motion Builder software which could cause unwanted code execution when an improper set of characters is entered.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-05-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-7841",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-4523",
+            "vendorProject": "Trihedral",
+            "product": "VTScada (formerly VTS)",
+            "vulnerabilityName": "Trihedral VTScada (formerly VTS) Denial-of-Service Vulnerability",
+            "dateAdded": "2022-04-15",
+            "shortDescription": "The WAP interface in Trihedral VTScada (formerly VTS) allows remote attackers to cause a denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-4523",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-0780",
+            "vendorProject": "InduSoft",
+            "product": "Web Studio",
+            "vulnerabilityName": "InduSoft Web Studio NTWebServer Directory Traversal Vulnerability",
+            "dateAdded": "2022-04-15",
+            "shortDescription": "InduSoft Web Studio NTWebServer contains a directory traversal vulnerability that allows remote attackers to read administrative passwords in APP files, allowing for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-0780",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-5330",
+            "vendorProject": "Ubiquiti",
+            "product": "AirOS",
+            "vulnerabilityName": "Ubiquiti AirOS Command Injection Vulnerability",
+            "dateAdded": "2022-04-15",
+            "shortDescription": "Certain Ubiquiti devices contain a command injection vulnerability via a GET request to stainfo.cgi.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-5330",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2007-3010",
+            "vendorProject": "Alcatel",
+            "product": "OmniPCX Enterprise",
+            "vulnerabilityName": "Alcatel OmniPCX Enterprise Remote Code Execution Vulnerability",
+            "dateAdded": "2022-04-15",
+            "shortDescription": "masterCGI in the Unified Maintenance Tool in Alcatel OmniPCX Enterprise Communication Server allows remote attackers to execute arbitrary commands.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-06",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2007-3010",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22954",
+            "vendorProject": "VMware",
+            "product": "Workspace ONE Access and Identity Manager",
+            "vulnerabilityName": "VMware Workspace ONE Access and Identity Manager Server-Side Template Injection Vulnerability",
+            "dateAdded": "2022-04-14",
+            "shortDescription": "VMware Workspace ONE Access and Identity Manager allow for remote code execution due to server-side template injection.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22954",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-24521",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows CLFS Driver Privilege Escalation Vulnerability",
+            "dateAdded": "2022-04-13",
+            "shortDescription": "Microsoft Windows Common Log File System (CLFS) Driver contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-04",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-24521",
+            "cwes": [
+                "CWE-787",
+                "CWE-1285"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-7602",
+            "vendorProject": "Drupal",
+            "product": "Core",
+            "vulnerabilityName": "Drupal Core Remote Code Execution Vulnerability",
+            "dateAdded": "2022-04-13",
+            "shortDescription": "A remote code execution vulnerability exists within multiple subsystems of Drupal that can allow attackers to exploit multiple attack vectors on a Drupal site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-04",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-7602",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2018-20753",
+            "vendorProject": "Kaseya",
+            "product": "Virtual System\/Server Administrator (VSA)",
+            "vulnerabilityName": "Kaseya VSA Remote Code Execution Vulnerability",
+            "dateAdded": "2022-04-13",
+            "shortDescription": "Kaseya VSA RMM allows unprivileged remote attackers to execute PowerShell payloads on all managed devices.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-04",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-20753",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2015-5123",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Use-After-Free Vulnerability",
+            "dateAdded": "2022-04-13",
+            "shortDescription": "Use-after-free vulnerability in the BitmapData class in the ActionScript 3 (AS3) implementation in Adobe Flash Player allows remote attackers to execute code or cause a denial-of-service (DoS).",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-05-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-5123",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-5122",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Use-After-Free Vulnerability",
+            "dateAdded": "2022-04-13",
+            "shortDescription": "Use-after-free vulnerability in the DisplayObject class in the ActionScript 3 (AS3) implementation in Adobe Flash Player allows remote attackers to execute code or cause a denial-of-service (DoS).",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-05-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-5122",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-3113",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-04-13",
+            "shortDescription": "Heap-based buffer overflow vulnerability in Adobe Flash Player allows remote attackers to execute code.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-05-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-3113",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-2502",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Memory Corruption Vulnerability",
+            "dateAdded": "2022-04-13",
+            "shortDescription": "Microsoft Internet Explorer contains a memory corruption vulnerability that allows an attacker to execute code or cause a denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-2502",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-0313",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Use-After-Free Vulnerability",
+            "dateAdded": "2022-04-13",
+            "shortDescription": "Use-after-free vulnerability in Adobe Flash Player allows remote attackers to execute code.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-05-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-0313",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-0311",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Remote Code Execution Vulnerability",
+            "dateAdded": "2022-04-13",
+            "shortDescription": "Unspecified vulnerability in Adobe Flash Player allows remote attackers to execute code.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-05-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-0311",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2014-9163",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Stack-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-04-13",
+            "shortDescription": "Stack-based buffer overflow in Adobe Flash Player allows attackers to execute code remotely.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-05-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-9163",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2022-23176",
+            "vendorProject": "WatchGuard",
+            "product": "Firebox and XTM",
+            "vulnerabilityName": "WatchGuard Firebox and XTM Privilege Escalation Vulnerability",
+            "dateAdded": "2022-04-11",
+            "shortDescription": "WatchGuard Firebox and XTM appliances allow a remote attacker with unprivileged credentials to access the system with a privileged management session via exposed management access.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-23176",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-42287",
+            "vendorProject": "Microsoft",
+            "product": "Active Directory",
+            "vulnerabilityName": "Microsoft Active Directory Domain Services Privilege Escalation Vulnerability",
+            "dateAdded": "2022-04-11",
+            "shortDescription": "Microsoft Active Directory Domain Services contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-02",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-42287",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-42278",
+            "vendorProject": "Microsoft",
+            "product": "Active Directory",
+            "vulnerabilityName": "Microsoft Active Directory Domain Services Privilege Escalation Vulnerability",
+            "dateAdded": "2022-04-11",
+            "shortDescription": "Microsoft Active Directory Domain Services contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-02",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-42278",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-39793",
+            "vendorProject": "Google",
+            "product": "Pixel",
+            "vulnerabilityName": "Google Pixel Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2022-04-11",
+            "shortDescription": "Google Pixel contains a possible out-of-bounds write due to a logic error in the code that could lead to local escalation of privilege.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-39793",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27852",
+            "vendorProject": "Checkbox",
+            "product": "Checkbox Survey",
+            "vulnerabilityName": "Checkbox Survey Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2022-04-11",
+            "shortDescription": "Deserialization of Untrusted Data vulnerability in CheckboxWeb.dll of Checkbox Survey allows an unauthenticated remote attacker to execute arbitrary code.",
+            "requiredAction": "Versions 6 and earlier for this product are end-of-life and must be removed from agency networks. Versions 7 and later are not considered vulnerable.",
+            "dueDate": "2022-05-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27852",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22600",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-04-11",
+            "shortDescription": "Linux Kernel contains a flaw in the packet socket (AF_PACKET) implementation which could lead to incorrectly freeing memory. A local user could exploit this for denial-of-service (DoS) or possibly for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22600",
+            "cwes": [
+                "CWE-415"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-2509",
+            "vendorProject": "QNAP",
+            "product": "QNAP Network-Attached Storage (NAS)",
+            "vulnerabilityName": "QNAP Network-Attached Storage (NAS) Command Injection Vulnerability",
+            "dateAdded": "2022-04-11",
+            "shortDescription": "QNAP NAS devices contain a command injection vulnerability which could allow attackers to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-2509",
+            "cwes": [
+                "CWE-77",
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-11317",
+            "vendorProject": "Telerik",
+            "product": "User Interface (UI) for ASP.NET AJAX",
+            "vulnerabilityName": "Telerik UI for ASP.NET AJAX Unrestricted File Upload Vulnerability",
+            "dateAdded": "2022-04-11",
+            "shortDescription": "Telerik.Web.UI in Progress Telerik UI for ASP.NET AJAX allows remote attackers to perform arbitrary file uploads or execute arbitrary code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-02",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-11317",
+            "cwes": [
+                "CWE-326"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-3156",
+            "vendorProject": "Sudo",
+            "product": "Sudo",
+            "vulnerabilityName": "Sudo Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-04-06",
+            "shortDescription": "Sudo contains an off-by-one error that can result in a heap-based buffer overflow, which allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-3156",
+            "cwes": [
+                "CWE-122",
+                "CWE-193"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-31166",
+            "vendorProject": "Microsoft",
+            "product": "HTTP Protocol Stack",
+            "vulnerabilityName": "Microsoft HTTP Protocol Stack Remote Code Execution Vulnerability",
+            "dateAdded": "2022-04-06",
+            "shortDescription": "Microsoft HTTP Protocol Stack contains a vulnerability in http.sys that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-27",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-31166",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0148",
+            "vendorProject": "Microsoft",
+            "product": "SMBv1 server",
+            "vulnerabilityName": "Microsoft SMBv1 Server Remote Code Execution Vulnerability",
+            "dateAdded": "2022-04-06",
+            "shortDescription": "The SMBv1 server in Microsoft allows remote attackers to execute arbitrary code via crafted packets.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-27",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0148",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22965",
+            "vendorProject": "VMware",
+            "product": "Spring Framework",
+            "vulnerabilityName": "Spring Framework JDK 9+ Remote Code Execution Vulnerability",
+            "dateAdded": "2022-04-04",
+            "shortDescription": "Spring MVC or Spring WebFlux application running on JDK 9+ may be vulnerable to remote code execution (RCE) via data binding.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22965",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22675",
+            "vendorProject": "Apple",
+            "product": "macOS",
+            "vulnerabilityName": "Apple macOS Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2022-04-04",
+            "shortDescription": "macOS Monterey contains an out-of-bounds write vulnerability that could allow an application to execute arbitrary code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22675",
+            "cwes": [
+                "CWE-20",
+                "CWE-125"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22674",
+            "vendorProject": "Apple",
+            "product": "macOS",
+            "vulnerabilityName": "Apple macOS Out-of-Bounds Read Vulnerability",
+            "dateAdded": "2022-04-04",
+            "shortDescription": "macOS Monterey contains an out-of-bounds read vulnerability that could allow an application to read kernel memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22674",
+            "cwes": [
+                "CWE-20",
+                "CWE-125"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-45382",
+            "vendorProject": "D-Link",
+            "product": "Multiple Routers",
+            "vulnerabilityName": "D-Link Multiple Routers Remote Code Execution Vulnerability",
+            "dateAdded": "2022-04-04",
+            "shortDescription": "A remote code execution vulnerability exists in all series H\/W revisions routers via the DDNS function in ncc2 binary file.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-04-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-45382",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26871",
+            "vendorProject": "Trend Micro",
+            "product": "Apex Central",
+            "vulnerabilityName": "Trend Micro Apex Central Arbitrary File Upload Vulnerability",
+            "dateAdded": "2022-03-31",
+            "shortDescription": "An arbitrary file upload vulnerability in Trend Micro Apex Central could allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26871",
+            "cwes": [
+                "CWE-184"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-1040",
+            "vendorProject": "Sophos",
+            "product": "Firewall",
+            "vulnerabilityName": "Sophos Firewall Authentication Bypass Vulnerability",
+            "dateAdded": "2022-03-31",
+            "shortDescription": "An authentication bypass vulnerability in User Portal and Webadmin of Sophos Firewall allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-1040",
+            "cwes": [
+                "CWE-158"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-34484",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows User Profile Service Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-31",
+            "shortDescription": "Microsoft Windows User Profile Service contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-34484",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-28799",
+            "vendorProject": "QNAP",
+            "product": "Network Attached Storage (NAS)",
+            "vulnerabilityName": "QNAP NAS Improper Authorization Vulnerability",
+            "dateAdded": "2022-03-31",
+            "shortDescription": "QNAP NAS running HBS 3 contains an improper authorization vulnerability which can allow remote attackers to log in to a device.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-21",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-28799",
+            "cwes": [
+                "CWE-285"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21551",
+            "vendorProject": "Dell",
+            "product": "dbutil Driver",
+            "vulnerabilityName": "Dell dbutil Driver Insufficient Access Control Vulnerability",
+            "dateAdded": "2022-03-31",
+            "shortDescription": "Dell dbutil driver contains an insufficient access control vulnerability which may lead to escalation of privileges, denial-of-service (DoS), or information disclosure.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21551",
+            "cwes": [
+                "CWE-782"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-10562",
+            "vendorProject": "Dasan",
+            "product": "Gigabit Passive Optical Network (GPON) Routers",
+            "vulnerabilityName": "Dasan GPON Routers Command Injection Vulnerability",
+            "dateAdded": "2022-03-31",
+            "shortDescription": "Dasan GPON Routers contain an authentication bypass vulnerability. When combined with CVE-2018-10561, exploitation can allow an attacker to perform remote code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-04-21",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-10562",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-10561",
+            "vendorProject": "Dasan",
+            "product": "Gigabit Passive Optical Network (GPON) Routers",
+            "vulnerabilityName": "Dasan GPON Routers Authentication Bypass Vulnerability",
+            "dateAdded": "2022-03-31",
+            "shortDescription": "Dasan GPON Routers contain an authentication bypass vulnerability. When combined with CVE-2018-10562, exploitation can allow an attacker to perform remote code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-04-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-10561",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-1096",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Google Chromium V8 Engine contains a type confusion vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-1096",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-0543",
+            "vendorProject": "Redis",
+            "product": "Debian-specific Redis Servers",
+            "vulnerabilityName": "Debian-specific Redis Server Lua Sandbox Escape Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Redis is prone to a (Debian-specific) Lua sandbox escape, which could result in remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-0543",
+            "cwes": [
+                "CWE-862"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-38646",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Access Connectivity Engine Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Microsoft Office Access Connectivity Engine contains an unspecified vulnerability which can allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-38646",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-34486",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Event Tracing Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Microsoft Windows Event Tracing contains an unspecified vulnerability which can allow for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-34486",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-26085",
+            "vendorProject": "Atlassian",
+            "product": "Confluence Server",
+            "vulnerabilityName": "Atlassian Confluence Server Pre-Authorization Arbitrary File Read Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Affected versions of Atlassian Confluence Server allow remote attackers to view restricted resources via a pre-authorization arbitrary file read vulnerability in the \/s\/ endpoint.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-26085",
+            "cwes": [
+                "CWE-425"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-20028",
+            "vendorProject": "SonicWall",
+            "product": "Secure Remote Access (SRA)",
+            "vulnerabilityName": "SonicWall Secure Remote Access (SRA) SQL Injection Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "SonicWall Secure Remote Access (SRA) products contain an improper neutralization of a SQL Command leading to SQL injection.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-20028",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-7483",
+            "vendorProject": "SonicWall",
+            "product": "SMA100",
+            "vulnerabilityName": "SonicWall SMA100 Directory Traversal Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "In SonicWall SMA100, an unauthenticated Directory Traversal vulnerability in the handleWAFRedirect CGI allows the user to test for the presence of a file on the server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-7483",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-8440",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "An elevation of privilege vulnerability exists when Windows improperly handles calls to Advanced Local Procedure Call (ALPC).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8440",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2018-8406",
+            "vendorProject": "Microsoft",
+            "product": "DirectX Graphics Kernel (DXGKRNL)",
+            "vulnerabilityName": "Microsoft DirectX Graphics Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "An elevation of privilege vulnerability exists when the DirectX Graphics Kernel (DXGKRNL) driver improperly handles objects in memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8406",
+            "cwes": [
+                "CWE-404"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-8405",
+            "vendorProject": "Microsoft",
+            "product": "DirectX Graphics Kernel (DXGKRNL)",
+            "vulnerabilityName": "Microsoft DirectX Graphics Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "An elevation of privilege vulnerability exists when the DirectX Graphics Kernel (DXGKRNL) driver improperly handles objects in memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8405",
+            "cwes": [
+                "CWE-404"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0213",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Microsoft Windows COM Aggregate Marshaler allows for privilege escalation when an attacker runs a specially crafted application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0213",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2017-0059",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Information Disclosure Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Microsoft Internet Explorer allow remote attackers to obtain sensitive information from process memory via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0059",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0037",
+            "vendorProject": "Microsoft",
+            "product": "Edge and Internet Explorer",
+            "vulnerabilityName": "Microsoft Edge and Internet Explorer Type Confusion Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Microsoft Edge and Internet Explorer have a type confusion vulnerability in mshtml.dll, which allows remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0037",
+            "cwes": [
+                "CWE-704"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-7201",
+            "vendorProject": "Microsoft",
+            "product": "Edge",
+            "vulnerabilityName": "Microsoft Edge Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "The Chakra JavaScript scripting engine in Microsoft Edge allows remote attackers to execute remote code or cause a denial of service (memory corruption) via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-7201",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-7200",
+            "vendorProject": "Microsoft",
+            "product": "Edge",
+            "vulnerabilityName": "Microsoft Edge Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "The Chakra JavaScript scripting engine in Microsoft Edge allows remote attackers to execute remote code or cause a denial of service (memory corruption) via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-7200",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-0189",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "The Microsoft JScript nd VBScript engines, as used in Internet Explorer and other products, allow attackers to execute remote code or cause a denial of service (memory corruption) via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-0189",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-0151",
+            "vendorProject": "Microsoft",
+            "product": "Client-Server Run-time Subsystem (CSRSS)",
+            "vulnerabilityName": "Microsoft Windows CSRSS Security Feature Bypass Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "The Client-Server Run-time Subsystem (CSRSS) in Microsoft mismanages process tokens, which allows local users to gain privileges via a crafted application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-0151",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-0040",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "The kernel in Microsoft Windows allows local users to gain privileges via a crafted application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-0040",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-2426",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Adobe Type Manager Library Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "A remote code execution vulnerability exists in Microsoft Windows when the Windows Adobe Type Manager Library improperly handles specially crafted OpenType fonts.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-2426",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-2419",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "JScript in Microsoft Internet Explorer allows remote attackers to execute remote code or cause a denial of service (memory corruption) via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-2419",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-1770",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Uninitialized Memory Use Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Microsoft Office allows remote attackers to execute arbitrary code via a crafted Office document.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-1770",
+            "cwes": [
+                "CWE-19"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-3660",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "The EPATHOBJ::pprFlattenRec function in win32k.sys in the kernel-mode drivers in Microsoft does not properly initialize a pointer for the next object in a certain list, which allows local users to gain privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-3660",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-2729",
+            "vendorProject": "Adobe",
+            "product": "Reader and Acrobat",
+            "vulnerabilityName": "Adobe Reader and Acrobat Arbitrary Integer Overflow Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Integer overflow vulnerability in Adobe Reader and Acrobat allows attackers to execute remote code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-2729",
+            "cwes": [
+                "CWE-189"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-2551",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Use-After-Free Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Use-after-free vulnerability in Microsoft Internet Explorer allows remote attackers to execute remote code via a crafted web site that triggers access to a deleted object.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-2551",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-2465",
+            "vendorProject": "Oracle",
+            "product": "Java SE",
+            "vulnerabilityName": "Oracle Java SE Unspecified Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE allows remote attackers to affect confidentiality, integrity, and availability via Unknown vectors related to 2D",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-2465",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2013-1690",
+            "vendorProject": "Mozilla",
+            "product": "Firefox and Thunderbird",
+            "vulnerabilityName": "Mozilla Firefox and Thunderbird Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Mozilla Firefox and Thunderbird do not properly handle onreadystatechange events in conjunction with page reloading, which allows remote attackers to cause a denial-of-service (DoS) or possibly execute malicious code via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-1690",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-5076",
+            "vendorProject": "Oracle",
+            "product": "Java SE",
+            "vulnerabilityName": "Oracle Java SE Sandbox Bypass Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "The default Java security properties configuration did not restrict access to the com.sun.org.glassfish.external and com.sun.org.glassfish.gmbal packages. An untrusted Java application or applet could use these flaws to bypass Java sandbox restrictions.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-5076",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2012-2539",
+            "vendorProject": "Microsoft",
+            "product": "Word",
+            "vulnerabilityName": "Microsoft Word Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Microsoft Word allows attackers to execute remote code or cause a denial-of-service (DoS) via crafted RTF data.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-2539",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-2034",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Adobe Flash Player contains a memory corruption vulnerability that allows for remote code execution or denial-of-service (DoS).",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-2034",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-0518",
+            "vendorProject": "Oracle",
+            "product": "Fusion Middleware",
+            "vulnerabilityName": "Oracle Fusion Middleware Unspecified Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Unspecified vulnerability in the Oracle Application Server Single Sign-On component in Oracle Fusion Middleware allows remote attackers to affect integrity via Unknown vectors",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-0518",
+            "cwes": [
+                "CWE-601"
+            ]
+        },
+        {
+            "cveID": "CVE-2011-2005",
+            "vendorProject": "Microsoft",
+            "product": "Ancillary Function Driver (afd.sys)",
+            "vulnerabilityName": "Microsoft Ancillary Function Driver (afd.sys) Improper Input Validation Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "afd.sys in the Ancillary Function Driver in Microsoft Windows does not properly validate user-mode input passed to kernel mode, which allows local users to gain privileges via a crafted application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2011-2005",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-4398",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Stack-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-28",
+            "shortDescription": "Stack-based buffer overflow in the RtlQueryRegistryValues function in win32k.sys in Microsoft Windows allows local users to gain privileges, and bypass the User Account Control (UAC) feature.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-4398",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26318",
+            "vendorProject": "WatchGuard",
+            "product": "Firebox and XTM Appliances",
+            "vulnerabilityName": "WatchGuard Firebox and XTM Appliances Arbitrary Code Execution",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "On WatchGuard Firebox and XTM appliances, an unauthenticated user can execute arbitrary code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26318",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26143",
+            "vendorProject": "Mitel",
+            "product": "MiCollab, MiVoice Business Express",
+            "vulnerabilityName": "MiCollab, MiVoice Business Express Access Control Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "A vulnerability has been identified in MiCollab and MiVoice Business Express that may allow a malicious actor to gain unauthorized access to sensitive information and services, cause performance degradations or a denial of service condition on the affected system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26143",
+            "cwes": [
+                "CWE-306",
+                "CWE-406"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-21999",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Print Spooler Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Microsoft Windows Print Spooler contains an unspecified vulnerability which can allow for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-21999",
+            "cwes": [
+                "CWE-40",
+                "CWE-1386"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-42237",
+            "vendorProject": "Sitecore",
+            "product": "XP",
+            "vulnerabilityName": "Sitecore XP Remote Command Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Sitcore XP contains an insecure deserialization vulnerability which can allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-42237",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22941",
+            "vendorProject": "Citrix",
+            "product": "ShareFile",
+            "vulnerabilityName": "Citrix ShareFile Improper Access Control Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Improper Access Control in Citrix ShareFile storage zones controller may allow an unauthenticated attacker to remotely compromise the storage zones controller.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22941",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-9377",
+            "vendorProject": "D-Link",
+            "product": "DIR-610 Devices",
+            "vulnerabilityName": "D-Link DIR-610 Devices Remote Command Execution",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "D-Link DIR-610 devices allow remote code execution via the cmd parameter to command.php.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-9377",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-9054",
+            "vendorProject": "Zyxel",
+            "product": "Multiple Network-Attached Storage (NAS) Devices",
+            "vulnerabilityName": "Zyxel Multiple NAS Devices OS Command Injection Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Multiple Zyxel network-attached storage (NAS) devices contain a pre-authentication command injection vulnerability, which may allow a remote, unauthenticated attacker to execute arbitrary code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-9054",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-7247",
+            "vendorProject": "OpenBSD",
+            "product": "OpenSMTPD",
+            "vulnerabilityName": "OpenSMTPD Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "smtp_mailaddr in smtp_session.c in OpenSMTPD, as used in OpenBSD and other products, allows remote attackers to execute arbitrary commands as root via a crafted SMTP session.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-7247",
+            "cwes": [
+                "CWE-755",
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-5410",
+            "vendorProject": "VMware Tanzu",
+            "product": "Spring Cloud Configuration (Config) Server",
+            "vulnerabilityName": "VMware Tanzu Spring Cloud Config Directory Traversal Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Spring, by VMware Tanzu, Cloud Config contains a path traversal vulnerability that allows applications to serve arbitrary configuration files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-5410",
+            "cwes": [
+                "CWE-23"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-25223",
+            "vendorProject": "Sophos",
+            "product": "SG UTM",
+            "vulnerabilityName": "Sophos SG UTM Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "A remote code execution vulnerability exists in the WebAdmin of Sophos SG UTM.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-25223",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-2506",
+            "vendorProject": "QNAP Systems",
+            "product": "Helpdesk",
+            "vulnerabilityName": "QNAP Helpdesk Improper Access Control Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "QNAP Helpdesk contains an improper access control vulnerability which could allow an attacker to gain privileges or to read sensitive information.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-2506",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-2021",
+            "vendorProject": "Palo Alto Networks",
+            "product": "PAN-OS",
+            "vulnerabilityName": "Palo Alto Networks PAN-OS Authentication Bypass Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Palo Alto Networks PAN-OS contains a vulnerability in SAML which allows an attacker to bypass authentication.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-2021",
+            "cwes": [
+                "CWE-347"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-1956",
+            "vendorProject": "Apache",
+            "product": "Kylin",
+            "vulnerabilityName": "Apache Kylin OS Command Injection Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Apache Kylin contains an OS command injection vulnerability which could permit an attacker to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-1956",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-1631",
+            "vendorProject": "Juniper",
+            "product": "Junos OS",
+            "vulnerabilityName": "Juniper Junos OS Path Traversal Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "A path traversal vulnerability in the HTTP\/HTTPS service used by J-Web, Web Authentication, Dynamic-VPN (DVPN), Firewall Authentication Pass-Through with Web-Redirect, and Zero Touch Provisioning (ZTP) allows an unauthenticated attacker to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-1631",
+            "cwes": [
+                "CWE-22",
+                "CWE-73"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-6340",
+            "vendorProject": "Drupal",
+            "product": "Core",
+            "vulnerabilityName": "Drupal Core Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "In Drupal Core, some field types do not properly sanitize data from non-form sources. This can lead to arbitrary PHP code execution in some cases.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-6340",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-2616",
+            "vendorProject": "Oracle",
+            "product": "BI Publisher (Formerly XML Publisher)",
+            "vulnerabilityName": "Oracle BI Publisher Unauthorized Access Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Oracle BI Publisher, formerly XML Publisher, contains an unspecified vulnerability that allows for various unauthorized actions. Open-source reporting attributes this vulnerability to allowing for authentication bypass.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-2616",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-16920",
+            "vendorProject": "D-Link",
+            "product": "Multiple Routers",
+            "vulnerabilityName": "D-Link Multiple Routers Command Injection Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Multiple D-Link routers contain a command injection vulnerability which can allow attackers to achieve full system compromise.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-16920",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-15107",
+            "vendorProject": "Webmin",
+            "product": "Webmin",
+            "vulnerabilityName": "Webmin Command Injection Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "An issue was discovered in Webmin. The parameter old in password_change.cgi contains a command injection vulnerability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-15107",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-12991",
+            "vendorProject": "Citrix",
+            "product": "SD-WAN and NetScaler",
+            "vulnerabilityName": "Citrix SD-WAN and NetScaler Command Injection Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Authenticated Command Injection in Citrix SD-WAN Appliance and NetScaler SD-WAN Appliance.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-12991",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-12989",
+            "vendorProject": "Citrix",
+            "product": "SD-WAN and NetScaler",
+            "vulnerabilityName": "Citrix SD-WAN and NetScaler SQL Injection Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Citrix SD-WAN and NetScaler SD-WAN allow SQL Injection.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-12989",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-11043",
+            "vendorProject": "PHP",
+            "product": "FastCGI Process Manager (FPM)",
+            "vulnerabilityName": "PHP FastCGI Process Manager (FPM) Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "In some versions of PHP in certain configurations of FPM setup, it is possible to cause FPM module to write past allocated buffers allowing the possibility of remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-11043",
+            "cwes": [
+                "CWE-120"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-10068",
+            "vendorProject": "Kentico",
+            "product": "Xperience",
+            "vulnerabilityName": "Kentico Xperience Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Kentico contains a failure to validate security headers. This deserialization can led to unauthenticated remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-10068",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1003030",
+            "vendorProject": "Jenkins",
+            "product": "Matrix Project Plugin",
+            "vulnerabilityName": "Jenkins Matrix Project Plugin Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Jenkins Matrix Project plugin contains a vulnerability which can allow users to escape the sandbox, opening opportunity to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1003030",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-0903",
+            "vendorProject": "Microsoft",
+            "product": "Graphics Device Interface (GDI)",
+            "vulnerabilityName": "Microsoft GDI Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "A remote code execution vulnerability exists in the way that the Windows Graphics Device Interface (GDI) handles objects in the memory. An attacker who successfully exploited this vulnerability could take control of the affected system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0903",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2018-8414",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Shell Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "A remote code execution vulnerability exists when the Windows Shell does not properly validate file paths.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8414",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-8373",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer Scripting Engine",
+            "vulnerabilityName": "Microsoft Scripting Engine Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "A remote code execution vulnerability exists in the way that the scripting engine handles objects in memory in Internet Explorer.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8373",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-6961",
+            "vendorProject": "VMware",
+            "product": "SD-WAN Edge",
+            "vulnerabilityName": "VMware SD-WAN Edge by VeloCloud Command Injection Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "VMware SD-WAN Edge by VeloCloud contains a command injection vulnerability in the local web UI component. Successful exploitation of this issue could result in remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-6961",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-14839",
+            "vendorProject": "LG",
+            "product": "N1A1 NAS",
+            "vulnerabilityName": "LG N1A1 NAS Remote Command Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "LG N1A1 NAS 3718.510 is affected by a remote code execution vulnerability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-14839",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-1273",
+            "vendorProject": "VMware Tanzu",
+            "product": "Spring Data Commons",
+            "vulnerabilityName": "VMware Tanzu Spring Data Commons Property Binder Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Spring Data Commons contains a property binder vulnerability which can allow an attacker to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-1273",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-11138",
+            "vendorProject": "Quest",
+            "product": "KACE System Management Appliance",
+            "vulnerabilityName": "Quest KACE System Management Appliance Remote Command Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "The '\/common\/download_agent_installer.php' script in the Quest KACE System Management Appliance is accessible by anonymous users and can be abused to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-11138",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0147",
+            "vendorProject": "Cisco",
+            "product": "Secure Access Control System (ACS)",
+            "vulnerabilityName": "Cisco Secure Access Control System Java Deserialization Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "A vulnerability in Java deserialization used by Cisco Secure Access Control System (ACS) could allow an unauthenticated, remote attacker to execute arbitrary commands on an affected device. The vulnerability is due to insecure deserialization of user-supplied content by the affected software.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0147",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0125",
+            "vendorProject": "Cisco",
+            "product": "VPN Routers",
+            "vulnerabilityName": "Cisco VPN Routers Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "A vulnerability in the web interface of the Cisco VPN Routers could allow an unauthenticated, remote attacker to execute arbitrary code as root and gain full control of an affected system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0125",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6334",
+            "vendorProject": "NETGEAR",
+            "product": "DGN2200 Devices",
+            "vulnerabilityName": "NETGEAR DGN2200 Devices OS Command Injection Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "dnslookup.cgi on NETGEAR DGN2200 devices with firmware through 10.0.0.50 allows remote authenticated users to execute arbitrary OS commands",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6334",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6316",
+            "vendorProject": "Citrix",
+            "product": "NetScaler SD-WAN Enterprise, CloudBridge Virtual WAN, and XenMobile Server",
+            "vulnerabilityName": "Citrix Multiple Products Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "A vulnerability has been identified in the management interface of Citrix NetScaler SD-WAN Enterprise and Standard Edition and Citrix CloudBridge Virtual WAN Edition that could result in an unauthenticated, remote attacker being able to execute arbitrary code as a root user. This vulnerability also affects XenMobile Server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6316",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-3881",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE",
+            "vulnerabilityName": "Cisco IOS and IOS XE Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "A vulnerability in the Cisco Cluster Management Protocol (CMP) processing code in Cisco IOS and Cisco IOS XE Software could allow an unauthenticated, remote attacker to cause a reload of an affected device or remotely execute code with elevated privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-3881",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12617",
+            "vendorProject": "Apache",
+            "product": "Tomcat",
+            "vulnerabilityName": "Apache Tomcat Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "When running Apache Tomcat, it is possible to upload a JSP file to the server via a specially crafted request. This JSP could then be requested and any code it contained would be executed by the server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12617",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12615",
+            "vendorProject": "Apache",
+            "product": "Tomcat",
+            "vulnerabilityName": "Apache Tomcat on Windows Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "When running Apache Tomcat on Windows with HTTP PUTs enabled, it is possible to upload a JSP file to the server via a specially crafted request. This JSP could then be requested and any code it contained would be executed by the server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12615",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0146",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows SMB Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "The SMBv1 server in Microsoft Windows allows remote attackers to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0146",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-7892",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Use-After-Free Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Adobe Flash Player has an exploitable use-after-free vulnerability in the TextField class.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-7892",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-4171",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Unspecified vulnerability in Adobe Flash Player allows for remote code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-4171",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2016-1555",
+            "vendorProject": "NETGEAR",
+            "product": "Wireless Access Point (WAP) Devices",
+            "vulnerabilityName": "NETGEAR Multiple WAP Devices Command Injection Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Multiple NETGEAR Wireless Access Point devices allows unauthenticated web pages to pass form input directly to the command-line interface. Exploitation allows for arbitrary code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-1555",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-11021",
+            "vendorProject": "D-Link",
+            "product": "DCS-930L Devices",
+            "vulnerabilityName": "D-Link DCS-930L Devices OS Command Injection Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "setSystemCommand on D-Link DCS-930L devices allows a remote attacker to execute code via an OS command.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-11021",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-10174",
+            "vendorProject": "NETGEAR",
+            "product": "WNR2000v5 Router",
+            "vulnerabilityName": "NETGEAR WNR2000v5 Router Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "The NETGEAR WNR2000v5 router contains a buffer overflow which can be exploited to achieve remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-10174",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-0752",
+            "vendorProject": "Rails",
+            "product": "Ruby on Rails",
+            "vulnerabilityName": "Ruby on Rails Directory Traversal Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Directory traversal vulnerability in Action View in Ruby on Rails allows remote attackers to read arbitrary files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-0752",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-4068",
+            "vendorProject": "Arcserve",
+            "product": "Unified Data Protection (UDP)",
+            "vulnerabilityName": "Arcserve Unified Data Protection (UDP) Directory Traversal Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Directory traversal vulnerability in Arcserve UDP allows remote attackers to obtain sensitive information or cause a denial of service.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-4068",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-3035",
+            "vendorProject": "TP-Link",
+            "product": "Multiple Archer Devices",
+            "vulnerabilityName": "TP-Link Multiple Archer Devices Directory Traversal Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Directory traversal vulnerability in multiple TP-Link Archer devices allows remote attackers to read arbitrary files via a .. (dot dot) in the PATH_INFO to login\/.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-3035",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-1427",
+            "vendorProject": "Elastic",
+            "product": "Elasticsearch",
+            "vulnerabilityName": "Elasticsearch Groovy Scripting Engine Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "The Groovy scripting engine in Elasticsearch allows remote attackers to bypass the sandbox protection mechanism and execute arbitrary shell commands.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-1427",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-1187",
+            "vendorProject": "D-Link and TRENDnet",
+            "product": "Multiple Devices",
+            "vulnerabilityName": "D-Link and TRENDnet Multiple Devices Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "The ping tool in multiple D-Link and TRENDnet devices allow remote attackers to perform remote code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-1187",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-0666",
+            "vendorProject": "Cisco",
+            "product": "Prime Data Center Network Manager (DCNM)",
+            "vulnerabilityName": "Cisco Prime Data Center Network Manager (DCNM) Directory Traversal Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Directory traversal vulnerability in the fmserver servlet in Cisco Prime Data Center Network Manager (DCNM) allows remote attackers to read arbitrary files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-0666",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-6332",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Object Linking & Embedding (OLE) Automation Array Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "OleAut32.dll in OLE in Microsoft Windows allows remote attackers to remotely execute code via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-6332",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-6324",
+            "vendorProject": "Microsoft",
+            "product": "Kerberos Key Distribution Center (KDC)",
+            "vulnerabilityName": "Microsoft Kerberos Key Distribution Center (KDC) Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "The Kerberos Key Distribution Center (KDC) in Microsoft allows remote authenticated domain users to obtain domain administrator privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-6324",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-6287",
+            "vendorProject": "Rejetto",
+            "product": "HTTP File Server (HFS)",
+            "vulnerabilityName": "Rejetto HTTP File Server (HFS) Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "The findMacroMarker function in parserLib.pas in Rejetto HTTP File Server (HFS or HttpFileServer) allows remote attackers to execute arbitrary programs.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-6287",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-3120",
+            "vendorProject": "Elastic",
+            "product": "Elasticsearch",
+            "vulnerabilityName": "Elasticsearch Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Elasticsearch enables dynamic scripting, which allows remote attackers to execute arbitrary MVEL expressions and Java code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-3120",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-0130",
+            "vendorProject": "Rails",
+            "product": "Ruby on Rails",
+            "vulnerabilityName": "Ruby on Rails Directory Traversal Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Directory traversal vulnerability in actionpack\/lib\/abstract_controller\/base.rb in the implicit-render implementation in Ruby on Rails allows remote attackers to read arbitrary files via a crafted request.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-0130",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-5223",
+            "vendorProject": "D-Link",
+            "product": "DSL-2760U",
+            "vulnerabilityName": "D-Link DSL-2760U Gateway Cross-Site Scripting Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "A cross-site scripting (XSS) vulnerability exists in the D-Link DSL-2760U gateway, allowing remote authenticated users to inject arbitrary web script or HTML.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-5223",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-4810",
+            "vendorProject": "Hewlett Packard (HP)",
+            "product": "ProCurve Manager (PCM), PCM+, Identity Driven Manager (IDM), and Application Lifecycle Management",
+            "vulnerabilityName": "HP Multiple Products Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "HP ProCurve Manager (PCM), PCM+, Identity Driven Manager (IDM), and Application Lifecycle Management allow remote attackers to execute arbitrary code via a marshalled object to (1) EJBInvokerServlet or (2) JMXInvokerServlet.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-4810",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-2251",
+            "vendorProject": "Apache",
+            "product": "Struts",
+            "vulnerabilityName": "Apache Struts Improper Input Validation Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Apache Struts allows remote attackers to execute arbitrary Object-Graph Navigation Language (OGNL) expressions.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-2251",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-1823",
+            "vendorProject": "PHP",
+            "product": "PHP",
+            "vulnerabilityName": "PHP-CGI Query String Parameter Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "sapi\/cgi\/cgi_main.c in PHP, when configured as a CGI script, does not properly handle query strings, which allows remote attackers to execute arbitrary code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-1823",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-4345",
+            "vendorProject": "Exim",
+            "product": "Exim",
+            "vulnerabilityName": "Exim Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Exim allows local users to gain privileges by leveraging the ability of the exim user account to specify an alternate configuration file with a directive that contains arbitrary commands.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-4345",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-4344",
+            "vendorProject": "Exim",
+            "product": "Exim",
+            "vulnerabilityName": "Exim Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Heap-based buffer overflow in the string_vformat function in string.c in Exim before 4.70 allows remote attackers to execute arbitrary code via an SMTP session.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-4344",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-3035",
+            "vendorProject": "Cisco",
+            "product": "IOS XR",
+            "vulnerabilityName": "Cisco IOS XR Border Gateway Protocol (BGP) Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Cisco IOS XR, when BGP is the configured routing feature, allows remote attackers to cause a denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-3035",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-2861",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Directory Traversal Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "A directory traversal vulnerability exists in the administrator console in Adobe ColdFusion which allows remote attackers to read arbitrary files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-2861",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2009-2055",
+            "vendorProject": "Cisco",
+            "product": "IOS XR",
+            "vulnerabilityName": "Cisco IOS XR Border Gateway Protocol (BGP) Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Cisco IOS XR,when BGP is the configured routing feature, allows remote attackers to cause a denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2009-2055",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2009-1151",
+            "vendorProject": "phpMyAdmin",
+            "product": "phpMyAdmin",
+            "vulnerabilityName": "phpMyAdmin Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Setup script used to generate configuration can be fooled using a crafted POST request to include arbitrary PHP code in generated configuration file.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2009-1151",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2009-0927",
+            "vendorProject": "Adobe",
+            "product": "Reader and Acrobat",
+            "vulnerabilityName": "Adobe Reader and Adobe Acrobat Stack-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "Stack-based buffer overflow in Adobe Reader and Adobe Acrobat allows remote attackers to execute arbitrary code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2009-0927",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2005-2773",
+            "vendorProject": "Hewlett Packard (HP)",
+            "product": "OpenView Network Node Manager",
+            "vulnerabilityName": "HP OpenView Network Node Manager Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-25",
+            "shortDescription": "HP OpenView Network Node Manager could allow a remote attacker to execute arbitrary commands on the system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2005-2773",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-5135",
+            "vendorProject": "SonicWall",
+            "product": "SonicOS",
+            "vulnerabilityName": "SonicWall SonicOS Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A buffer overflow vulnerability in SonicOS allows a remote attacker to cause Denial of Service (DoS) and potentially execute arbitrary code by sending a malicious request to the firewall.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-5135",
+            "cwes": [
+                "CWE-120"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1405",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Universal Plug and Play (UPnP) Service Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists when the Windows UPnP service improperly allows COM object creation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1405",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-1322",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists when Windows improperly handles authentication requests. An attacker who successfully exploited this vulnerability could run processes in an elevated context.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1322",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-1315",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Error Reporting Manager Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists when Windows Error Reporting manager improperly handles hard links. An attacker who successfully exploited this vulnerability could overwrite a targeted file leading to an elevated status.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1315",
+            "cwes": [
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1253",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows AppX Deployment Server Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists when the Windows AppX Deployment Server improperly handles junctions.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1253",
+            "cwes": [
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1132",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists in Windows when the Win32k component fails to properly handle objects in memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1132",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-1129",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows AppX Deployment Service (AppXSVC) Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists when Windows AppXSVC improperly handles hard links. An attacker who successfully exploited this vulnerability could run processes in an elevated context.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1129",
+            "cwes": [
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1069",
+            "vendorProject": "Microsoft",
+            "product": "Task Scheduler",
+            "vulnerabilityName": "Microsoft Task Scheduler Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists in the way the Task Scheduler Service validates certain file operations.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1069",
+            "cwes": [
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1064",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows AppX Deployment Service (AppXSVC) Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists when Windows AppXSVC improperly handles hard links. An attacker who successfully exploited this vulnerability could run processes in an elevated context.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1064",
+            "cwes": [
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0841",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows AppX Deployment Service (AppXSVC) Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists when Windows AppXSVC improperly handles hard links. An attacker who successfully exploited this vulnerability could run processes in an elevated context.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0841",
+            "cwes": [
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0543",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists when Windows improperly handles authentication requests. An attacker who successfully exploited this vulnerability could run processes in an elevated context.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0543",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-8120",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists in Windows when the Win32k component fails to properly handle objects in memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8120",
+            "cwes": [
+                "CWE-404"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0101",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Transaction Manager Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists when the Windows Transaction Manager improperly handles objects in memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0101",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-3309",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "A privilege escalation vulnerability exists when the Windows kernel fails to properly handle objects in memory. An attacker who successfully exploited this vulnerability could run arbitrary code in kernel mode.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-3309",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-2546",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-15",
+            "shortDescription": "The kernel-mode driver in Microsoft Windows OS and Server allows local users to gain privileges via a crafted application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-04-05",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-2546",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26486",
+            "vendorProject": "Mozilla",
+            "product": "Firefox",
+            "vulnerabilityName": "Mozilla Firefox Use-After-Free Vulnerability",
+            "dateAdded": "2022-03-07",
+            "shortDescription": "Mozilla Firefox contains a use-after-free vulnerability in WebGPU IPC Framework which can be exploited to perform arbitrary code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26486",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-26485",
+            "vendorProject": "Mozilla",
+            "product": "Firefox",
+            "vulnerabilityName": "Mozilla Firefox Use-After-Free Vulnerability",
+            "dateAdded": "2022-03-07",
+            "shortDescription": "Mozilla Firefox contains a use-after-free vulnerability in XSLT parameter processing which can be exploited to perform arbitrary code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-26485",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21973",
+            "vendorProject": "VMware",
+            "product": "vCenter Server and Cloud Foundation",
+            "vulnerabilityName": "VMware vCenter Server and Cloud Foundation Server Side Request Forgery (SSRF) Vulnerability",
+            "dateAdded": "2022-03-07",
+            "shortDescription": "VMware vCenter Server and Cloud Foundation Server contain a SSRF vulnerability due to improper validation of URLs in a vCenter Server plugin. This allows for information disclosure.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21973",
+            "cwes": [
+                "CWE-20",
+                "CWE-918"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-8218",
+            "vendorProject": "Pulse Secure",
+            "product": "Pulse Connect Secure",
+            "vulnerabilityName": "Pulse Connect Secure Code Injection Vulnerability",
+            "dateAdded": "2022-03-07",
+            "shortDescription": "A code injection vulnerability exists in Pulse Connect Secure that allows an attacker to crafted a URI to perform an arbitrary code execution via the admin web interface.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8218",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-11581",
+            "vendorProject": "Atlassian",
+            "product": "Jira Server and Data Center",
+            "vulnerabilityName": "Atlassian Jira Server and Data Center Server-Side Template Injection Vulnerability",
+            "dateAdded": "2022-03-07",
+            "shortDescription": "Atlassian Jira Server and Data Center contain a server-side template injection vulnerability which can allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-11581",
+            "cwes": [
+                "CWE-74"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6077",
+            "vendorProject": "NETGEAR",
+            "product": "Wireless Router DGN2200",
+            "vulnerabilityName": "NETGEAR DGN2200 Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-07",
+            "shortDescription": "NETGEAR DGN2200 wireless routers contain a vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6077",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-6277",
+            "vendorProject": "NETGEAR",
+            "product": "Multiple Routers",
+            "vulnerabilityName": "NETGEAR Multiple Routers Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-07",
+            "shortDescription": "NETGEAR confirmed multiple routers allow unauthenticated web pages to pass form input directly to the command-line interface, permitting remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-6277",
+            "cwes": [
+                "CWE-352"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-0631",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Information Disclosure Vulnerability",
+            "dateAdded": "2022-03-07",
+            "shortDescription": "Adobe Coldfusion contains an unspecified vulnerability, which could result in information disclosure from a compromised server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-0631",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-0629",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Directory Traversal Vulnerability",
+            "dateAdded": "2022-03-07",
+            "shortDescription": "Adobe Coldfusion contains a directory traversal vulnerability, which could permit an unauthorized user access to restricted directories.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-0629",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-0625",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Authentication Bypass Vulnerability",
+            "dateAdded": "2022-03-07",
+            "shortDescription": "Adobe Coldfusion contains an authentication bypass vulnerability, which could result in an unauthorized user gaining administrative access.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-07",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-0625",
+            "cwes": [
+                "CWE-255"
+            ]
+        },
+        {
+            "cveID": "CVE-2009-3960",
+            "vendorProject": "Adobe",
+            "product": "BlazeDS",
+            "vulnerabilityName": "Adobe BlazeDS Information Disclosure Vulnerability",
+            "dateAdded": "2022-03-07",
+            "shortDescription": "Adobe BlazeDS, which is utilized in LifeCycle and Coldfusion, contains a vulnerability that allows for information disclosure.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-09-07",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2009-3960",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2022-20708",
+            "vendorProject": "Cisco",
+            "product": "Small Business RV160, RV260, RV340, and RV345 Series Routers",
+            "vulnerabilityName": "Cisco Small Business RV Series Routers Stack-based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in Cisco Small Business RV160, RV260, RV340, and RV345 Series Routers could allow an attacker to do any of the following: Execute arbitrary code elevate privileges, execute arbitrary commands, bypass authentication and authorization protections, fetch and run unsigned software, or cause a denial of service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-20708",
+            "cwes": [
+                "CWE-121"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-20703",
+            "vendorProject": "Cisco",
+            "product": "Small Business RV160, RV260, RV340, and RV345 Series Routers",
+            "vulnerabilityName": "Cisco Small Business RV Series Routers Stack-based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in Cisco Small Business RV160, RV260, RV340, and RV345 Series Routers could allow an attacker to do any of the following: Execute arbitrary code elevate privileges, execute arbitrary commands, bypass authentication and authorization protections, fetch and run unsigned software, or cause a denial of service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-20703",
+            "cwes": [
+                "CWE-347"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-20701",
+            "vendorProject": "Cisco",
+            "product": "Small Business RV160, RV260, RV340, and RV345 Series Routers",
+            "vulnerabilityName": "Cisco Small Business RV Series Routers Stack-based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in Cisco Small Business RV160, RV260, RV340, and RV345 Series Routers could allow an attacker to do any of the following: Execute arbitrary code elevate privileges, execute arbitrary commands, bypass authentication and authorization protections, fetch and run unsigned software, or cause a denial of service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-20701",
+            "cwes": [
+                "CWE-121"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-20700",
+            "vendorProject": "Cisco",
+            "product": "Small Business RV160, RV260, RV340, and RV345 Series Routers",
+            "vulnerabilityName": "Cisco Small Business RV Series Routers Stack-based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in Cisco Small Business RV160, RV260, RV340, and RV345 Series Routers could allow an attacker to do any of the following: Execute arbitrary code elevate privileges, execute arbitrary commands, bypass authentication and authorization protections, fetch and run unsigned software, or cause a denial of service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-20700",
+            "cwes": [
+                "CWE-121"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-20699",
+            "vendorProject": "Cisco",
+            "product": "Small Business RV160, RV260, RV340, and RV345 Series Routers",
+            "vulnerabilityName": "Cisco Small Business RV Series Routers Stack-based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in Cisco Small Business RV160, RV260, RV340, and RV345 Series Routers could allow an attacker to do any of the following: Execute arbitrary code elevate privileges, execute arbitrary commands, bypass authentication and authorization protections, fetch and run unsigned software, or cause a denial of service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-20699",
+            "cwes": [
+                "CWE-785"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-41379",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Installer Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Microsoft Windows Installer contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-41379",
+            "cwes": [
+                "CWE-1386"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-1938",
+            "vendorProject": "Apache",
+            "product": "Tomcat",
+            "vulnerabilityName": "Apache Tomcat Improper Privilege Management Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Apache Tomcat treats Apache JServ Protocol (AJP) connections as having higher trust than, for example, a similar HTTP connection. If such connections are available to an attacker, they can be exploited.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-1938",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-11899",
+            "vendorProject": "Treck TCP\/IP stack",
+            "product": "IPv6",
+            "vulnerabilityName": "Treck TCP\/IP stack Out-of-Bounds Read Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The Treck TCP\/IP stack contains an IPv6 out-of-bounds read vulnerability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-11899",
+            "cwes": [
+                "CWE-125"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-16928",
+            "vendorProject": "Exim",
+            "product": "Exim Internet Mailer",
+            "vulnerabilityName": "Exim Out-of-bounds Write Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Exim contains an out-of-bounds write vulnerability which can allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-16928",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1652",
+            "vendorProject": "Cisco",
+            "product": "Small Business RV320 and RV325 Dual Gigabit WAN VPN Routers",
+            "vulnerabilityName": "Cisco Small Business Routers Improper Input Validation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the web-based management interface of Cisco Small Business RV320 and RV325 Dual Gigabit WAN VPN Routers could allow an authenticated, remote attacker with administrative privileges on an affected device to execute arbitrary commands.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1652",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1297",
+            "vendorProject": "Microsoft",
+            "product": "Excel",
+            "vulnerabilityName": "Microsoft Excel Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A remote code execution vulnerability exists in Microsoft Excel when the software fails to properly handle objects in memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1297",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2018-8581",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A privilege escalation vulnerability exists in Microsoft Exchange Server. An attacker who successfully exploited this vulnerability could attempt to impersonate any other user of the Exchange server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8581",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2018-8298",
+            "vendorProject": "ChakraCore",
+            "product": "ChakraCore scripting engine",
+            "vulnerabilityName": "ChakraCore Scripting Engine Type Confusion Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The ChakraCore scripting engine contains a type confusion vulnerability which can allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8298",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0180",
+            "vendorProject": "Cisco",
+            "product": "IOS Software",
+            "vulnerabilityName": "Cisco IOS Software Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the Login Enhancements (Login Block) feature of Cisco IOS Software could allow an unauthenticated, remote attacker to trigger a reload of an affected system, resulting in a denial of service (DoS) condition.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0180",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0179",
+            "vendorProject": "Cisco",
+            "product": "IOS Software",
+            "vulnerabilityName": "Cisco IOS Software Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the Login Enhancements (Login Block) feature of Cisco IOS Software could allow an unauthenticated, remote attacker to trigger a reload of an affected system, resulting in a denial of service (DoS) condition.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0179",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0175",
+            "vendorProject": "Cisco",
+            "product": "IOS, XR, and XE Software",
+            "vulnerabilityName": "Cisco IOS, XR, and XE Software Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Format string vulnerability in the Link Layer Discovery Protocol (LLDP) subsystem of Cisco IOS Software, Cisco IOS XE Software, and Cisco IOS XR Software could allow an unauthenticated, adjacent attacker to cause a denial of service (DoS) condition or execute arbitrary code with elevated privileges on an affected device.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0175",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0174",
+            "vendorProject": "Cisco",
+            "product": "IOS XE Software",
+            "vulnerabilityName": "Cisco IOS Software and Cisco IOS XE Software Improper Input Validation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the DHCP option 82 encapsulation functionality of Cisco IOS Software and Cisco IOS XE Software could allow for denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0174",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0173",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software Improper Input Validation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the Cisco IOS Software and Cisco IOS XE Software function that restores encapsulated option 82 information in DHCP Version 4 (DHCPv4) packets can allow for denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0173",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0172",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software Improper Input Validation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the DHCP option 82 encapsulation functionality of Cisco IOS Software and Cisco IOS XE Software could allow for denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0172",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0167",
+            "vendorProject": "Cisco",
+            "product": "IOS, XR, and XE Software",
+            "vulnerabilityName": "Cisco IOS, XR, and XE Software Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "There is a buffer overflow vulnerability in the Link Layer Discovery Protocol (LLDP) subsystem of Cisco IOS Software, Cisco IOS XE Software, and Cisco IOS XR Software which could allow an unauthenticated, adjacent attacker to cause a denial of service (DoS) condition or execute arbitrary code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0167",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0161",
+            "vendorProject": "Cisco",
+            "product": "IOS Software",
+            "vulnerabilityName": "Cisco IOS Software Resource Management Errors Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the Simple Network Management Protocol (SNMP) subsystem of Cisco IOS Software running on certain models of Cisco Catalyst Switches could allow an authenticated, remote attacker to cause a denial-of-service (DoS) condition.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0161",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0159",
+            "vendorProject": "Cisco",
+            "product": "IOS Software and Cisco IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and XE Software Internet Key Exchange Version 1 Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the implementation of Internet Key Exchange Version 1 (IKEv1) functionality in Cisco IOS Software and Cisco IOS XE Software could allow an unauthenticated, remote attacker to cause an affected device to reload, resulting in a denial-of-service (DoS) condition.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0159",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0158",
+            "vendorProject": "Cisco",
+            "product": "IOS Software and Cisco IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and XE Software Internet Key Exchange Memory Leak Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the implementation of Internet Key Exchange Version 1 (IKEv1) functionality in Cisco IOS Software and Cisco IOS XE Software could allow an unauthenticated, remote attacker to cause an affected device to reload, resulting in a denial-of-service (DoS) condition.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0158",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0156",
+            "vendorProject": "Cisco",
+            "product": "IOS Software and Cisco IOS XE Software",
+            "vulnerabilityName": "Cisco IOS Software and Cisco IOS XE Software Smart Install Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the Smart Install feature of Cisco IOS Software and Cisco IOS XE Software could allow an unauthenticated, remote attacker to trigger a reload of an affected device, resulting in a denial-of-service (DoS) condition.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0156",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0155",
+            "vendorProject": "Cisco",
+            "product": "Catalyst 4500 Series Switches and Cisco Catalyst 4500-X Series Switches",
+            "vulnerabilityName": "Cisco Catalyst Bidirectional Forwarding Detection Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the Bidirectional Forwarding Detection (BFD) offload implementation of Cisco Catalyst 4500 Series Switches and Cisco Catalyst 4500-X Series Switches could allow an unauthenticated, remote attacker to cause a crash of the iosd process, causing a denial-of-service (DoS) condition.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0155",
+            "cwes": [
+                "CWE-388"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0154",
+            "vendorProject": "Cisco",
+            "product": "IOS Software",
+            "vulnerabilityName": "Cisco IOS Software Integrated Services Module for VPN Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the crypto engine of the Cisco Integrated Services Module for VPN (ISM-VPN) running Cisco IOS Software could allow an unauthenticated, remote attacker to cause a denial-of-service (DoS) condition.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0154",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0151",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS Software and Cisco IOS XE Software Quality of Service Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the quality of service (QoS) subsystem of Cisco IOS Software and Cisco IOS XE Software could allow an unauthenticated, remote attacker to cause a denial of service (DoS) condition or execute arbitrary code with elevated privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0151",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-8540",
+            "vendorProject": "Microsoft",
+            "product": "Malware Protection Engine",
+            "vulnerabilityName": "Microsoft Malware Protection Engine Improper Restriction of Operations Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The Microsoft Malware Protection Engine running on Microsoft Forefront and Microsoft Defender on Microsoft Windows Server 2008 SP2 and R2 SP1, Windows 7 SP1, Windows 8.1, Windows Server 2012 Gold and R2, Windows RT 8.1, Windows 10 Gold, 1511, 1607, and 1703, and Windows Server 2016, Microsoft Exchange Server 2013 and 2016, does not properly scan a specially crafted file leading to memory corruption. aka \"Microsoft Malware Protection Engine Remote Code Execution Vulnerability\".",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-8540",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6744",
+            "vendorProject": "Cisco",
+            "product": "IOS software",
+            "vulnerabilityName": "Cisco IOS Software SNMP Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The Simple Network Management Protocol (SNMP) subsystem of Cisco IOS 1 contains a vulnerability that could allow an authenticated, remote attacker to remotely execute code on an affected system or cause an affected system to reload. An attacker could exploit these vulnerabilities by sending a crafted SNMP packet to an affected system via IPv4 or IPv6.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6744",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6743",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software SNMP Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The Simple Network Management Protocol (SNMP) subsystem of Cisco IOS and IOS XE contains a vulnerability that could allow an authenticated, remote attacker to remotely execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6743",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6740",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software SNMP Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The Simple Network Management Protocol (SNMP) subsystem of Cisco IOS and IOS XE contains a vulnerability that could allow an authenticated, remote attacker to remotely execute code on an affected system or cause an affected system to reload.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6740",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6739",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software SNMP Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The Simple Network Management Protocol (SNMP) subsystem of Cisco IOS and IOS XE contains a vulnerability that could allow an authenticated, remote attacker to remotely execute code on an affected system or cause an affected system to reload.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6739",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6738",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software SNMP Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The Simple Network Management Protocol (SNMP) subsystem of Cisco IOS and IOS XE contains a vulnerability that could allow an authenticated, remote attacker to remotely execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6738",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6737",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software SNMP Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The Simple Network Management Protocol (SNMP) subsystem of Cisco IOS and IOS XE contains a vulnerability that could allow an authenticated, remote attacker to remotely execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6737",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6736",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software SNMP Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The Simple Network Management Protocol (SNMP) subsystem of Cisco IOS and IOS XE contains a vulnerability that could allow an authenticated, remote attacker to remotely execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6736",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6663",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS Software and Cisco IOS XE Software Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the Autonomic Networking feature of Cisco IOS Software and Cisco IOS XE Software could allow an unauthenticated, adjacent attacker to cause autonomic nodes of an affected system to reload, resulting in denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6663",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2017-6627",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS Software and Cisco IOS XE Software UDP Packet Processing Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the UDP processing code of Cisco IOS and IOS XE could allow an unauthenticated, remote attacker to cause the input queue of an affected system to hold UDP packets, causing an interface queue wedge and denial of service.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6627",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12319",
+            "vendorProject": "Cisco",
+            "product": "IOS XE Software",
+            "vulnerabilityName": "Cisco IOS XE Software Ethernet Virtual Private Network Border Gateway Protocol Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the Border Gateway Protocol (BGP) over an Ethernet Virtual Private Network (EVPN) for Cisco IOS XE Software could allow an unauthenticated, remote attacker to cause the device to reload, resulting in a denial of service (DoS) condition, or potentially corrupt the BGP routing table, which could result in network instability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12319",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12240",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software DHCP Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The Dynamic Host Configuration Protocol (DHCP) relay subsystem of Cisco IOS and Cisco IOS XE Software contains a vulnerability that could allow an unauthenticated, remote attacker to execute arbitrary code and gain full control of an affected system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12240",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12238",
+            "vendorProject": "Cisco",
+            "product": "Catalyst 6800 Series Switches",
+            "vulnerabilityName": "Cisco Catalyst 6800 Series Switches VPLS Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the Virtual Private LAN Service (VPLS) code of Cisco IOS for Cisco Catalyst 6800 Series Switches could allow an unauthenticated, adjacent attacker to cause a denial of service.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12238",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12237",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE Software",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software Internet Key Exchange Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the Internet Key Exchange Version 2 (IKEv2) module of Cisco IOS and Cisco IOS XE could allow an unauthenticated, remote attacker to cause high CPU utilization, traceback messages, or a reload of an affected device that leads to a denial of service.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12237",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12235",
+            "vendorProject": "Cisco",
+            "product": "IOS software",
+            "vulnerabilityName": "Cisco IOS Software for Cisco Industrial Ethernet Switches PROFINET Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the implementation of the PROFINET Discovery and Configuration Protocol (PN-DCP) for Cisco IOS could allow an unauthenticated, remote attacker to cause an affected device to reload, resulting in a denial of service.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12235",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12234",
+            "vendorProject": "Cisco",
+            "product": "IOS software",
+            "vulnerabilityName": "Cisco IOS Software Common Industrial Protocol Request Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "There is a vulnerability in the implementation of the Common Industrial Protocol (CIP) feature in Cisco IOS could allow an unauthenticated, remote attacker to cause an affected device to reload, resulting in a denial of service.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12234",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12233",
+            "vendorProject": "Cisco",
+            "product": "IOS software",
+            "vulnerabilityName": "Cisco IOS Software Common Industrial Protocol Request Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "There is a vulnerability in the implementation of the Common Industrial Protocol (CIP) feature in Cisco IOS could allow an unauthenticated, remote attacker to cause an affected device to reload, resulting in a denial of service.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12233",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12232",
+            "vendorProject": "Cisco",
+            "product": "IOS software",
+            "vulnerabilityName": "Cisco IOS Software for Cisco Integrated Services Routers Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the implementation of a protocol in Cisco Integrated Services Routers Generation 2 (ISR G2) Routers running Cisco IOS could allow an unauthenticated, adjacent attacker to cause an affected device to reload, resulting in a denial of service.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12232",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12231",
+            "vendorProject": "Cisco",
+            "product": "IOS software",
+            "vulnerabilityName": "Cisco IOS Software Network Address Translation Denial-of-Service Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability in the implementation of Network Address Translation (NAT) functionality in Cisco IOS could allow an unauthenticated, remote attacker to cause a denial of service.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12231",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-11826",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A remote code execution vulnerability exists in Microsoft Office software when the software fails to properly handle objects in memory. An attacker who successfully exploited the vulnerability could run arbitrary code in the context of the current user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-11826",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-11292",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Type Confusion Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Adobe Flash Player contains a type confusion vulnerability which can allow for remote code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-11292",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0261",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Use-After-Free Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Microsoft Office contains a use-after-free vulnerability which can allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0261",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0001",
+            "vendorProject": "Microsoft",
+            "product": "Graphics Device Interface (GDI)",
+            "vulnerabilityName": "Microsoft Graphics Device Interface (GDI) Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The Graphics Device Interface (GDI) in Microsoft Windows Vista SP2; Windows Server 2008 SP2 and R2 SP1; Windows 7 SP1; Windows 8.1; Windows Server 2012 Gold and R2; Windows RT 8.1; and Windows 10 Gold, 1511, and 1607 allows local users to gain privileges",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0001",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2016-8562",
+            "vendorProject": "Siemens",
+            "product": "SIMATIC CP",
+            "vulnerabilityName": "Siemens SIMATIC CP 1543-1 Improper Privilege Management Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "An improper privilege management vulnerability exists within the Siemens SIMATIC Communication Processor (CP) that allows a privileged attacker to remotely cause a denial of service.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-8562",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-7855",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Use-After-Free Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Use-after-free vulnerability in Adobe Flash Player Windows and OS and Linux allows remote attackers to execute arbitrary code.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-7855",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-7262",
+            "vendorProject": "Microsoft",
+            "product": "Excel",
+            "vulnerabilityName": "Microsoft Office Security Feature Bypass Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A security feature bypass vulnerability exists when Microsoft Office improperly handles input. An attacker who successfully exploited the vulnerability could execute arbitrary commands.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-7262",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-7193",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Microsoft Office contains a memory corruption vulnerability which can allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-7193",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-5195",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Race Condition Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Race condition in mm\/gup.c in the Linux kernel allows local users to escalate privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-5195",
+            "cwes": [
+                "CWE-362"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-4117",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Arbitrary Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "An access of resource using incompatible type vulnerability exists within Adobe Flash Player that allows an attacker to perform remote code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-4117",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2016-1019",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Arbitrary Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Adobe Flash Player allows remote attackers to cause a denial of service or possibly execute arbitrary code.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-1019",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2016-0099",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Secondary Logon Service Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A privilege escalation vulnerability exists in Microsoft Windows if the Windows Secondary Logon Service fails to properly manage request handles in memory. An attacker who successfully exploited this vulnerability could run arbitrary code as an administrator.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-0099",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-7645",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Arbitrary Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Adobe Flash Player allows remote attackers to execute arbitrary code via a crafted SWF file.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-7645",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2015-5119",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Use-After-Free Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A use-after-free vulnerability exists within the ActionScript 3 ByteArray class in Adobe Flash Player that allows an attacker to perform remote code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-5119",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-4902",
+            "vendorProject": "Oracle",
+            "product": "Java SE",
+            "vulnerabilityName": "Oracle Java SE Integrity Check Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Unspecified vulnerability in Oracle Java SE allows remote attackers to affect integrity via Unknown vectors related to deployment.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-4902",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2015-3043",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A memory corruption vulnerability exists in Adobe Flash Player that allows an attacker to perform remote code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-3043",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-2590",
+            "vendorProject": "Oracle",
+            "product": "Java SE",
+            "vulnerabilityName": "Oracle Java SE and Java SE Embedded Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "An unspecified vulnerability exists within Oracle Java Runtime Environment that allows an attacker to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-2590",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2015-2545",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Malformed EPS File Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Microsoft Office allows remote attackers to execute arbitrary code via a crafted EPS image.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-2545",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-2424",
+            "vendorProject": "Microsoft",
+            "product": "PowerPoint",
+            "vulnerabilityName": "Microsoft PowerPoint Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Microsoft PowerPoint allows remote attackers to execute arbitrary code or cause a denial of service (memory corruption) via a crafted Office document.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-2424",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-2387",
+            "vendorProject": "Microsoft",
+            "product": "ATM Font Driver",
+            "vulnerabilityName": "Microsoft ATM Font Driver Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "ATMFD.DLL in the Adobe Type Manager Font Driver in Microsoft Windows Server allows local users to gain privileges via a crafted application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-2387",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-1701",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "An unspecified vulnerability exists in the Win32k.sys kernel-mode driver in Microsoft Windows Server that allows a local attacker to execute arbitrary code with elevated privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-1701",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-1642",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Microsoft Office contains a memory corruption vulnerability that allows remote attackers to execute arbitrary code via a crafted document.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-1642",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-4114",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Object Linking & Embedding (OLE) Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A vulnerability exists in Windows Object Linking & Embedding (OLE) that could allow remote code execution if a user opens a file that contains a specially crafted OLE object.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-4114",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-0496",
+            "vendorProject": "Adobe",
+            "product": "Reader and Acrobat",
+            "vulnerabilityName": "Adobe Reader and Acrobat Use-After-Free Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Adobe Reader and Acrobat contain a use-after-free vulnerability which can allow for code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-0496",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-5065",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Microsoft Windows NDProxy.sys in the kernel contains an improper input validation vulnerability which can allow a local attacker to escalate privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-5065",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-3897",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Use-After-Free Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A use-after-free vulnerability exists within CDisplayPointer in Microsoft Internet Explorer that allows an attacker to remotely execute arbitrary code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-3897",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-3346",
+            "vendorProject": "Adobe",
+            "product": "Reader and Acrobat",
+            "vulnerabilityName": "Adobe Reader and Acrobat Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Adobe Reader and Acrobat contain a memory corruption vulnerability which can allow attackers to execute arbitrary code or cause a denial of service.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-3346",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-1675",
+            "vendorProject": "Mozilla",
+            "product": "Firefox",
+            "vulnerabilityName": "Mozilla Firefox Information Disclosure Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Mozilla Firefox does not properly initialize data structures for the nsDOMSVGZoomEvent::mPreviousScale and nsDOMSVGZoomEvent::mNewScale functions, which allows remote attackers to obtain sensitive information from process memory via a crafted web site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-1675",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-1347",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "This vulnerability may corrupt memory in a way that could allow an attacker to execute arbitrary code in the context of the current user within Internet Explorer.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-1347",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-0641",
+            "vendorProject": "Adobe",
+            "product": "Reader",
+            "vulnerabilityName": "Adobe Reader Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A buffer overflow vulnerability exists in Adobe Reader which allows an attacker to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-0641",
+            "cwes": [
+                "CWE-120"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-0640",
+            "vendorProject": "Adobe",
+            "product": "Reader and Acrobat",
+            "vulnerabilityName": "Adobe Reader and Acrobat Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "An memory corruption vulnerability exists in the acroform.dll in Adobe Reader that allows an attacker to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-0640",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-0632",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Authentication Bypass Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "An authentication bypass vulnerability exists in Adobe ColdFusion which could result in an unauthorized user gaining administrative access.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-0632",
+            "cwes": [
+                "CWE-200"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-4681",
+            "vendorProject": "Oracle",
+            "product": "Java SE",
+            "vulnerabilityName": "Oracle Java SE Runtime Environment (JRE) Arbitrary Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The Java Runtime Environment (JRE) component in Oracle Java SE allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-4681",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2012-1856",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office MSCOMCTL.OCX Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The TabStrip ActiveX control in the Common Controls in MSCOMCTL.OCX in Microsoft Office allows remote attackers to execute arbitrary code via a crafted (1) document or (2) web page that triggers system-state corruption.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-1856",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-1723",
+            "vendorProject": "Oracle",
+            "product": "Java SE",
+            "vulnerabilityName": "Oracle Java SE Runtime Environment (JRE) Arbitrary Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Unspecified vulnerability in the Java Runtime Environment (JRE) component in Oracle Java SE allows remote attackers to affect confidentiality, integrity, and availability via Unknown vectors related to Hotspot.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-1723",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2012-1535",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Arbitrary Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Unspecified vulnerability in Adobe Flash Player allows remote attackers to execute arbitrary code or cause a denial of service via crafted SWF content.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-1535",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2012-0507",
+            "vendorProject": "Oracle",
+            "product": "Java SE",
+            "vulnerabilityName": "Oracle Java SE Runtime Environment (JRE) Arbitrary Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "An incorrect type vulnerability exists in the Concurrency component of Oracle's Java Runtime Environment allows an attacker to remotely execute arbitrary code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-0507",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2011-3544",
+            "vendorProject": "Oracle",
+            "product": "Java SE JDK and JRE",
+            "vulnerabilityName": "Oracle Java SE Runtime Environment (JRE) Arbitrary Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "An access control vulnerability exists in the Applet Rhino Script Engine component of Oracle's Java Runtime Environment allows an attacker to remotely execute arbitrary code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2011-3544",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2011-1889",
+            "vendorProject": "Microsoft",
+            "product": "Forefront Threat Management Gateway (TMG)",
+            "vulnerabilityName": "Microsoft Forefront TMG Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A remote code execution vulnerability exists in the Forefront Threat Management Gateway (TMG) Firewall Client Winsock provider that could allow code execution in the security context of the client application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2011-1889",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2011-0611",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Remote Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Adobe Flash Player contains a vulnerability that allows remote attackers to execute arbitrary code or cause a denial of service (application crash) via crafted Flash content.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2011-0611",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-3333",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Stack-based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A stack-based buffer overflow vulnerability exists in the parsing of RTF data in Microsoft Office and earlier allows an attacker to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-3333",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-0232",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Exception Handler Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The kernel in Microsoft Windows, when access to 16-bit applications is enabled on a 32-bit x86 platform, does not properly validate certain BIOS calls, which allows local users to gain privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-0232",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-0188",
+            "vendorProject": "Adobe",
+            "product": "Reader and Acrobat",
+            "vulnerabilityName": "Adobe Reader and Acrobat Arbitrary Code Execution Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Unspecified vulnerability in Adobe Reader and Acrobat allows attackers to cause a denial of service or possibly execute arbitrary code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-0188",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2009-3129",
+            "vendorProject": "Microsoft",
+            "product": "Excel",
+            "vulnerabilityName": "Microsoft Excel Featheader Record Memory Corruption Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Microsoft Office Excel allows remote attackers to execute arbitrary code via a spreadsheet with a FEATHEADER record containing an invalid cbHdrData size element that affects a pointer offset.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2009-3129",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2009-1123",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Improper Input Validation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "The kernel in Microsoft Windows does not properly validate changes to unspecified kernel objects, which allows local users to gain privileges via a crafted application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2009-1123",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2008-3431",
+            "vendorProject": "Oracle",
+            "product": "VirtualBox",
+            "vulnerabilityName": "Oracle VirtualBox Insufficient Input Validation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "An input validation vulnerability exists in the VBoxDrv.sys driver of Sun xVM VirtualBox which allows attackers to locally execute arbitrary code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2008-3431",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2008-2992",
+            "vendorProject": "Adobe",
+            "product": "Acrobat and Reader",
+            "vulnerabilityName": "Adobe Reader and Acrobat Input Validation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "Adobe Acrobat and Reader contain an input validation issue in a JavaScript method that could potentially lead to remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2008-2992",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2004-0210",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "A privilege elevation vulnerability exists in the POSIX subsystem. This vulnerability could allow a logged on user to take complete control of the system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2004-0210",
+            "cwes": [
+                "CWE-120"
+            ]
+        },
+        {
+            "cveID": "CVE-2002-0367",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Privilege Escalation Vulnerability",
+            "dateAdded": "2022-03-03",
+            "shortDescription": "smss.exe debugging subsystem in Microsoft Windows does not properly authenticate programs that connect to other programs, which allows local users to gain administrator or SYSTEM privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2002-0367",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2022-24682",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaborate Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaborate Suite (ZCS) Cross-Site Scripting Vulnerability",
+            "dateAdded": "2022-02-25",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) contains a cross-site scripting (XSS) vulnerability in the Calendar feature that allows an attacker to execute arbitrary code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-11",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-24682",
+            "cwes": [
+                "CWE-79",
+                "CWE-116"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-8570",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Remote Code Execution Vulnerability",
+            "dateAdded": "2022-02-25",
+            "shortDescription": "A remote code execution vulnerability exists in Microsoft Office software when it fails to properly handle objects in memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-8570",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2017-0222",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Remote Code Execution Vulnerability",
+            "dateAdded": "2022-02-25",
+            "shortDescription": "A remote code execution vulnerability exists when Internet Explorer improperly accesses objects in memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0222",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-6352",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Code Injection Vulnerability",
+            "dateAdded": "2022-02-25",
+            "shortDescription": "Microsoft Windows allow remote attackers to execute arbitrary code via a crafted OLE object.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-6352",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-23131",
+            "vendorProject": "Zabbix",
+            "product": "Frontend",
+            "vulnerabilityName": "Zabbix Frontend Authentication Bypass Vulnerability",
+            "dateAdded": "2022-02-22",
+            "shortDescription": "Unsafe client-side session storage leading to authentication bypass\/instance takeover via Zabbix Frontend with configured SAML.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-23131",
+            "cwes": [
+                "CWE-290"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-23134",
+            "vendorProject": "Zabbix",
+            "product": "Frontend",
+            "vulnerabilityName": "Zabbix Frontend Improper Access Control Vulnerability",
+            "dateAdded": "2022-02-22",
+            "shortDescription": "Malicious actors can pass step checks and potentially change the configuration of Zabbix Frontend.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-08",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-23134",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-24086",
+            "vendorProject": "Adobe",
+            "product": "Commerce and Magento Open Source",
+            "vulnerabilityName": "Adobe Commerce and Magento Open Source Improper Input Validation Vulnerability",
+            "dateAdded": "2022-02-15",
+            "shortDescription": "Adobe Commerce and Magento Open Source contain an improper input validation vulnerability which can allow for arbitrary code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-24086",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-0609",
+            "vendorProject": "Google",
+            "product": "Chromium Animation",
+            "vulnerabilityName": "Google Chromium Animation Use-After-Free Vulnerability",
+            "dateAdded": "2022-02-15",
+            "shortDescription": "Google Chromium Animation contains a use-after-free vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-03-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-0609",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0752",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Type Confusion Vulnerability",
+            "dateAdded": "2022-02-15",
+            "shortDescription": "A remote code execution vulnerability exists in the way that the scripting engine handles objects in memory in Internet Explorer",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0752",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-8174",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows VBScript Engine Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2022-02-15",
+            "shortDescription": "A remote code execution vulnerability exists in the way that the VBScript engine handles objects in memory, aka \"Windows VBScript Engine Remote Code Execution\"",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8174",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-20250",
+            "vendorProject": "RARLAB",
+            "product": "WinRAR",
+            "vulnerabilityName": "WinRAR Absolute Path Traversal Vulnerability",
+            "dateAdded": "2022-02-15",
+            "shortDescription": "WinRAR Absolute Path Traversal vulnerability leads to Remote Code Execution",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-20250",
+            "cwes": [
+                "CWE-36"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-15982",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Use-After-Free Vulnerability",
+            "dateAdded": "2022-02-15",
+            "shortDescription": "Adobe Flash Player com.adobe.tvsdk.mediacore.metadata Use After Free Vulnerability",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-08-15",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-15982",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-9841",
+            "vendorProject": "PHPUnit",
+            "product": "PHPUnit",
+            "vulnerabilityName": "PHPUnit Command Injection Vulnerability",
+            "dateAdded": "2022-02-15",
+            "shortDescription": "PHPUnit allows remote attackers to execute arbitrary PHP code via HTTP POST data beginning with a \"<?php \" substring, as demonstrated by an attack on a site with an exposed \/vendor folder, i.e., external access to the \/vendor\/phpunit\/phpunit\/src\/Util\/PHP\/eval-stdin.php URI.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-9841",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-1761",
+            "vendorProject": "Microsoft",
+            "product": "Word",
+            "vulnerabilityName": "Microsoft Word Memory Corruption Vulnerability",
+            "dateAdded": "2022-02-15",
+            "shortDescription": "Microsoft Word contains a memory corruption vulnerability which when exploited could allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-1761",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2013-3906",
+            "vendorProject": "Microsoft",
+            "product": "Graphics Component",
+            "vulnerabilityName": "Microsoft Graphics Component Memory Corruption Vulnerability",
+            "dateAdded": "2022-02-15",
+            "shortDescription": "Microsoft Graphics Component contains a memory corruption vulnerability which can allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-3906",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22620",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and macOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and macOS Webkit Use-After-Free Vulnerability",
+            "dateAdded": "2022-02-11",
+            "shortDescription": "Apple iOS, iPadOS, and macOS WebKit contain a use-after-free vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-25",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22620",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-36934",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows SAM Local Privilege Escalation Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "If a Volume Shadow Copy (VSS) shadow copy of the system drive is available, users can read the SAM file which would allow any user to escalate privileges to SYSTEM level.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-36934",
+            "cwes": [
+                "CWE-1220"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0796",
+            "vendorProject": "Microsoft",
+            "product": "SMBv3",
+            "vulnerabilityName": "Microsoft SMBv3 Remote Code Execution Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "A remote code execution vulnerability exists in the way that the Microsoft Server Message Block 3.1.1 (SMBv3) protocol handles certain requests. An attacker who successfully exploited the vulnerability could gain the ability to execute code on the target server or client.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0796",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-1000861",
+            "vendorProject": "Jenkins",
+            "product": "Jenkins Stapler Web Framework",
+            "vulnerabilityName": "Jenkins Stapler Web Framework Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "A code execution vulnerability exists in the Stapler web framework used by Jenkins",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-1000861",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-9791",
+            "vendorProject": "Apache",
+            "product": "Struts 1",
+            "vulnerabilityName": "Apache Struts 1 Improper Input Validation Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "The Struts 1 plugin in Apache Struts might allow remote code execution via a malicious field value passed in a raw message to the ActionMessage.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-9791",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-8464",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Shell (.lnk) Remote Code Execution Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "Windows Shell in multiple versions of Microsoft Windows allows local users or remote attackers to execute arbitrary code via a crafted .LNK file",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-8464",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2017-10271",
+            "vendorProject": "Oracle",
+            "product": "WebLogic Server",
+            "vulnerabilityName": "Oracle Corporation WebLogic Server Remote Code Execution Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "Oracle Corporation WebLogic Server contains a vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-10271",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2017-0263",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "Microsoft Win32k contains a privilege escalation vulnerability due to the Windows kernel-mode driver failing to properly handle objects in memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0263",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0262",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Remote Code Execution Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "A remote code execution vulnerability exists in Microsoft Office.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0262",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2017-0145",
+            "vendorProject": "Microsoft",
+            "product": "SMBv1",
+            "vulnerabilityName": "Microsoft SMBv1 Remote Code Execution Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "The SMBv1 server in multiple Microsoft Windows versions allows remote attackers to execute arbitrary code via crafted packets.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0145",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0144",
+            "vendorProject": "Microsoft",
+            "product": "SMBv1",
+            "vulnerabilityName": "Microsoft SMBv1 Remote Code Execution Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "The SMBv1 server in multiple Microsoft Windows versions allows remote attackers to execute arbitrary code via crafted packets.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0144",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-3088",
+            "vendorProject": "Apache",
+            "product": "ActiveMQ",
+            "vulnerabilityName": "Apache ActiveMQ Improper Input Validation Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "The Fileserver web application in Apache ActiveMQ allows remote attackers to upload and execute arbitrary files via an HTTP PUT followed by an HTTP MOVE request",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-3088",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-2051",
+            "vendorProject": "D-Link",
+            "product": "DIR-645 Router",
+            "vulnerabilityName": "D-Link DIR-645 Router Remote Code Execution Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "D-Link DIR-645 Wired\/Wireless Router allows remote attackers to execute arbitrary commands via a GetDeviceSettings action to the HNAP interface.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-2051",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-1635",
+            "vendorProject": "Microsoft",
+            "product": "HTTP.sys",
+            "vulnerabilityName": "Microsoft HTTP.sys Remote Code Execution Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "Microsoft HTTP protocol stack (HTTP.sys) contains a vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-1635",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-1130",
+            "vendorProject": "Apple",
+            "product": "OS X",
+            "vulnerabilityName": "Apple OS X Authentication Bypass Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "The XPC implementation in Admin Framework in Apple OS X before 10.10.3 allows local users to bypass authentication and obtain admin privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-1130",
+            "cwes": [
+                "CWE-254"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-4404",
+            "vendorProject": "Apple",
+            "product": "OS X",
+            "vulnerabilityName": "Apple OS X Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-02-10",
+            "shortDescription": "Heap-based buffer overflow in IOHIDFamily in Apple OS X, which affects, iOS before 8 and Apple TV before 7, allows attackers to execute arbitrary code in a privileged context.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-08-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-4404",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-21882",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-02-04",
+            "shortDescription": "Microsoft Win32k contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-21882",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2022-22587",
+            "vendorProject": "Apple",
+            "product": "iOS and macOS",
+            "vulnerabilityName": "Apple Memory Corruption Vulnerability",
+            "dateAdded": "2022-01-28",
+            "shortDescription": "Apple IOMobileFrameBuffer contains a memory corruption vulnerability which can allow a malicious application to execute arbitrary code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-11",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2022-22587",
+            "cwes": [
+                "CWE-20",
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-20038",
+            "vendorProject": "SonicWall",
+            "product": "SMA 100 Appliances",
+            "vulnerabilityName": "SonicWall SMA 100 Appliances Stack-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2022-01-28",
+            "shortDescription": "SonicWall SMA 100 devies are vulnerable to an unauthenticated stack-based buffer overflow vulnerability where exploitation can result in code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-11",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-20038",
+            "cwes": [
+                "CWE-121"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-5722",
+            "vendorProject": "Grandstream",
+            "product": "UCM6200",
+            "vulnerabilityName": "Grandstream Networks UCM6200 Series SQL Injection Vulnerability",
+            "dateAdded": "2022-01-28",
+            "shortDescription": "Grandstream UCM6200 series is vulnerable to an unauthenticated remote SQL injection via crafted HTTP request. Exploitation can allow for code execution as root.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-5722",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0787",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Background Intelligent Transfer Service (BITS) Improper Privilege Management Vulnerability",
+            "dateAdded": "2022-01-28",
+            "shortDescription": "Microsoft Windows BITS is vulnerable to to a privilege elevation vulnerability if it improperly handles symbolic links. An actor can exploit this vulnerability to execute arbitrary code with system-level privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-28",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0787",
+            "cwes": [
+                "CWE-269",
+                "CWE-59"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-5689",
+            "vendorProject": "Intel",
+            "product": "Active Management Technology (AMT), Small Business Technology (SBT), and Standard Manageability",
+            "vulnerabilityName": "Intel Active Management Technology (AMT), Small Business Technology (SBT), and Standard Manageability Privilege Escalation Vulnerability",
+            "dateAdded": "2022-01-28",
+            "shortDescription": "Intel products contain a vulnerability which can allow attackers to perform privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-5689",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2014-1776",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Memory Corruption Vulnerability",
+            "dateAdded": "2022-01-28",
+            "shortDescription": "Microsoft Internet Explorer contains a memory corruption vulnerability that allows remote attackers to execute code in the context of the current user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/learn.microsoft.com\/en-us\/security-updates\/SecurityBulletins\/2014\/ms14-021?redirectedfrom=MSDN; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-1776",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-6271",
+            "vendorProject": "GNU",
+            "product": "Bourne-Again Shell (Bash)",
+            "vulnerabilityName": "GNU Bourne-Again Shell (Bash) Arbitrary Code Execution Vulnerability",
+            "dateAdded": "2022-01-28",
+            "shortDescription": "GNU Bash through 4.3 processes trailing strings after function definitions in the values of environment variables, which allows remote attackers to execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-6271",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-7169",
+            "vendorProject": "GNU",
+            "product": "Bourne-Again Shell (Bash)",
+            "vulnerabilityName": "GNU Bourne-Again Shell (Bash) Arbitrary Code Execution Vulnerability",
+            "dateAdded": "2022-01-28",
+            "shortDescription": "GNU Bash through 4.3 processes trailing strings after function definitions in the values of environment variables, which allows remote attackers to execute code. This CVE correctly remediates the vulnerability in CVE-2014-6271.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-28",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-7169",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2006-1547",
+            "vendorProject": "Apache",
+            "product": "Struts 1",
+            "vulnerabilityName": "Apache Struts 1 ActionForm Denial-of-Service Vulnerability",
+            "dateAdded": "2022-01-21",
+            "shortDescription": "ActionForm in Apache Struts versions before 1.2.9 with BeanUtils 1.7 contains a vulnerability that allows for denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2006-1547",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2012-0391",
+            "vendorProject": "Apache",
+            "product": "Struts 2",
+            "vulnerabilityName": "Apache Struts 2 Improper Input Validation Vulnerability",
+            "dateAdded": "2022-01-21",
+            "shortDescription": "The ExceptionDelegator component in Apache Struts 2 before 2.2.3.1 contains an improper input validation vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-21",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-0391",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-8453",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-01-21",
+            "shortDescription": "Microsoft Windows Win32k contains a vulnerability that allows an attacker to escalate privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-21",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8453",
+            "cwes": [
+                "CWE-404"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-35247",
+            "vendorProject": "SolarWinds",
+            "product": "Serv-U",
+            "vulnerabilityName": "SolarWinds Serv-U Improper Input Validation Vulnerability",
+            "dateAdded": "2022-01-21",
+            "shortDescription": "SolarWinds Serv-U versions 15.2.5 and earlier contain an improper input validation vulnerability that allows attackers to build and send queries without sanitization.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-04",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-35247",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-32648",
+            "vendorProject": "October CMS",
+            "product": "October CMS",
+            "vulnerabilityName": "October CMS Improper Authentication",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "In affected versions of the october\/system package an attacker can request an account password reset and then gain access to the account using a specially crafted request.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-32648",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-25296",
+            "vendorProject": "Nagios",
+            "product": "Nagios XI",
+            "vulnerabilityName": "Nagios XI OS Command Injection",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "Nagios XI contains a vulnerability which can lead to OS command injection on the Nagios XI server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-25296",
+            "cwes": [
+                "CWE-78",
+                "CWE-138"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-25297",
+            "vendorProject": "Nagios",
+            "product": "Nagios XI",
+            "vulnerabilityName": "Nagios XI OS Command Injection",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "Nagios XI contains a vulnerability which can lead to OS command injection on the Nagios XI server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-25297",
+            "cwes": [
+                "CWE-78",
+                "CWE-138"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-25298",
+            "vendorProject": "Nagios",
+            "product": "Nagios XI",
+            "vulnerabilityName": "Nagios XI OS Command Injection",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "Nagios XI contains a vulnerability which can lead to OS command injection on the Nagios XI server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-25298",
+            "cwes": [
+                "CWE-78",
+                "CWE-138"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-40870",
+            "vendorProject": "Aviatrix",
+            "product": "Aviatrix Controller",
+            "vulnerabilityName": "Aviatrix Controller Unrestricted Upload of File",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "Unrestricted upload of a file with a dangerous type is possible, which allows an unauthenticated user to execute arbitrary code via directory traversal.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-40870",
+            "cwes": [
+                "CWE-25",
+                "CWE-96"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-33766",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Information Disclosure",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "Microsoft Exchange Server contains an information disclosure vulnerability which can allow an unauthenticated attacker to steal email traffic from target.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-33766",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21975",
+            "vendorProject": "VMware",
+            "product": "vRealize Operations Manager API",
+            "vulnerabilityName": "VMware Server Side Request Forgery in vRealize Operations Manager API",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "Server Side Request Forgery (SSRF) in vRealize Operations Manager API prior to 8.4 may allow a malicious actor with network access to the vRealize Operations Manager API to perform a SSRF attack to steal administrative credentials.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-01",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21975",
+            "cwes": [
+                "CWE-918"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21315",
+            "vendorProject": "Npm package",
+            "product": "System Information Library for Node.JS",
+            "vulnerabilityName": "System Information Library for Node.JS Command Injection",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "In this vulnerability, an attacker can send a malicious payload that will exploit the name parameter. After successful exploitation, attackers can execute remote.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21315",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22991",
+            "vendorProject": "F5",
+            "product": "BIG-IP Traffic Management Microkernel",
+            "vulnerabilityName": "F5 BIG-IP Traffic Management Microkernel Buffer Overflow",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "The Traffic Management Microkernel of BIG-IP ASM Risk Engine has a buffer overflow vulnerability, leading to a bypassing of URL-based access controls.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-02-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22991",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-14864",
+            "vendorProject": "Oracle",
+            "product": "Intelligence Enterprise Edition",
+            "vulnerabilityName": "Oracle Business Intelligence Enterprise Edition Path Transversal",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "Path traversal vulnerability, where an attacker can target the preview FilePath parameter of the getPreviewImage function to get access to arbitrary system file.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-14864",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-13671",
+            "vendorProject": "Drupal",
+            "product": "Drupal core",
+            "vulnerabilityName": "Drupal core Un-restricted Upload of File",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "Improper sanitization in the extension file names is present in Drupal core.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-13671",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-11978",
+            "vendorProject": "Apache",
+            "product": "Airflow",
+            "vulnerabilityName": "Apache Airflow Command Injection",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "A remote code\/command injection vulnerability was discovered in one of the example DAGs shipped with Airflow.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-11978",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-13927",
+            "vendorProject": "Apache",
+            "product": "Airflow's Experimental API",
+            "vulnerabilityName": "Apache Airflow's Experimental API Authentication Bypass",
+            "dateAdded": "2022-01-18",
+            "shortDescription": "The previous default setting for Airflow's Experimental API was to allow all API requests without authentication.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-18",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-13927",
+            "cwes": [
+                "CWE-1188",
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22017",
+            "vendorProject": "VMware",
+            "product": "vCenter Server",
+            "vulnerabilityName": "VMware vCenter Server Improper Access Control",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "Rhttproxy as used in vCenter Server contains a vulnerability due to improper implementation of URI normalization.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-01-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22017",
+            "cwes": [
+                "CWE-23"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-36260",
+            "vendorProject": "Hikvision",
+            "product": "Security cameras web server",
+            "vulnerabilityName": "Hikvision Improper Input Validation",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "A command injection vulnerability in the web server of some Hikvision product. Due to the insufficient input validation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-01-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-36260",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-6572",
+            "vendorProject": "Google",
+            "product": "Chrome Media",
+            "vulnerabilityName": "Google Chrome Media Use-After-Free Vulnerability",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "Google Chrome Media contains a use-after-free vulnerability that allows a remote attacker to execute code via a crafted HTML page.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-6572",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1458",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "A privilege escalation vulnerability exists in Windows when the Win32k component fails to properly handle objects in memory, aka 'Win32k EoP.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1458",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2013-3900",
+            "vendorProject": "Microsoft",
+            "product": "WinVerifyTrust function",
+            "vulnerabilityName": "Microsoft WinVerifyTrust function Remote Code Execution",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "A remote code execution vulnerability exists in the way that the WinVerifyTrust function handles Windows Authenticode signature verification for PE files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2013-3900",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-2725",
+            "vendorProject": "Oracle",
+            "product": "WebLogic Server",
+            "vulnerabilityName": "Oracle WebLogic Server, Injection",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "Injection vulnerability in the Oracle WebLogic Server component of Oracle Fusion Middleware (subcomponent: Web Services).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-2725",
+            "cwes": [
+                "CWE-74"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-9670",
+            "vendorProject": "Synacor",
+            "product": "Zimbra Collaboration Suite (ZCS)",
+            "vulnerabilityName": "Synacor Zimbra Collaboration Suite (ZCS) Improper Restriction of XML External Entity Reference",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "Synacor Zimbra Collaboration Suite (ZCS) contains an improper restriction of XML external entity (XXE) vulnerability in the mailboxd component.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-9670",
+            "cwes": [
+                "CWE-611"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-13382",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS and FortiProxy",
+            "vulnerabilityName": "Fortinet FortiOS and FortiProxy Improper Authorization",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "An Improper Authorization vulnerability in Fortinet FortiOS and FortiProxy under SSL VPN web portal allows an unauthenticated attacker to modify the password.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-13382",
+            "cwes": [
+                "CWE-285"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-13383",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS and FortiProxy",
+            "vulnerabilityName": "Fortinet FortiOS and FortiProxy Out-of-bounds Write",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "A heap buffer overflow in Fortinet FortiOS and FortiProxy may cause the SSL VPN web service termination for logged in users.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-13383",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1579",
+            "vendorProject": "Palo Alto Networks",
+            "product": "PAN-OS",
+            "vulnerabilityName": "Palo Alto Networks PAN-OS Remote Code Execution Vulnerability",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "Remote Code Execution in PAN-OS with GlobalProtect Portal or GlobalProtect Gateway Interface enabled.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1579",
+            "cwes": [
+                "CWE-134"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-10149",
+            "vendorProject": "Exim",
+            "product": "Mail Transfer Agent (MTA)",
+            "vulnerabilityName": "Exim Mail Transfer Agent (MTA) Improper Input Validation",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "Improper validation of recipient address in deliver_message() function in \/src\/deliver.c may lead to remote command execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-10149",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-7450",
+            "vendorProject": "IBM",
+            "product": "WebSphere Application Server and Server Hypervisor Edition",
+            "vulnerabilityName": "IBM WebSphere Application Server and Server Hypervisor Edition Code Injection.",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "Serialized-object interfaces in certain IBM analytics, business solutions, cognitive, IT infrastructure, and mobile and social products allow remote attackers to execute arbitrary commands",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-7450",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-1000486",
+            "vendorProject": "Primetek",
+            "product": "Primefaces Application",
+            "vulnerabilityName": "Primetek Primefaces Remote Code Execution Vulnerability",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "Primetek Primefaces is vulnerable to a weak encryption flaw resulting in remote code execution",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-1000486",
+            "cwes": [
+                "CWE-326"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-7609",
+            "vendorProject": "Elastic",
+            "product": "Kibana",
+            "vulnerabilityName": "Kibana Arbitrary Code Execution",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "Kibana contain an arbitrary code execution flaw in the Timelion visualizer.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-07-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-7609",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27860",
+            "vendorProject": "FatPipe",
+            "product": "WARP, IPVPN, and MPVPN software",
+            "vulnerabilityName": "FatPipe WARP, IPVPN, and MPVPN Configuration Upload exploit",
+            "dateAdded": "2022-01-10",
+            "shortDescription": "A vulnerability in the web management interface of FatPipe WARP, IPVPN, and MPVPN software allows a remote, unauthenticated attacker to upload a file to any location on the filesystem.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-01-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27860",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-43890",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows AppX Installer Spoofing Vulnerability",
+            "dateAdded": "2021-12-15",
+            "shortDescription": "Microsoft Windows AppX Installer contains a spoofing vulnerability which has a high impacts to confidentiality, integrity, and availability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-12-29",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-43890",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-4102",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Use-After-Free Vulnerability",
+            "dateAdded": "2021-12-15",
+            "shortDescription": "Google Chromium V8 Engine contains a use-after-free vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-12-29",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-4102",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-44515",
+            "vendorProject": "Zoho",
+            "product": "Desktop Central",
+            "vulnerabilityName": "Zoho Desktop Central Authentication Bypass Vulnerability",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "Zoho Desktop Central contains an authentication bypass vulnerability that could allow an attacker to execute arbitrary code in the Desktop Central MSP server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-12-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-44515",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-13272",
+            "vendorProject": "Linux",
+            "product": "Kernel",
+            "vulnerabilityName": "Linux Kernel Improper Privilege Management Vulnerability",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "Kernel\/ptrace.c in Linux kernel mishandles contains an improper privilege management vulnerability that allows local users to obtain root access.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-13272",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-35394",
+            "vendorProject": "Realtek",
+            "product": "Jungle Software Development Kit (SDK)",
+            "vulnerabilityName": "Realtek Jungle SDK Remote Code Execution Vulnerability",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "RealTek Jungle SDK contains multiple memory corruption vulnerabilities which can allow an attacker to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-12-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-35394",
+            "cwes": [
+                "CWE-78",
+                "CWE-138"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-7238",
+            "vendorProject": "Sonatype",
+            "product": "Nexus Repository Manager",
+            "vulnerabilityName": "Sonatype Nexus Repository Manager Incorrect Access Control Vulnerability",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "Sonatype Nexus Repository Manager before 3.15.0 has an incorrect access control vulnerability. Exploitation allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-7238",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-0193",
+            "vendorProject": "Apache",
+            "product": "Solr",
+            "vulnerabilityName": "Apache Solr DataImportHandler Code Injection Vulnerability",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "The optional Apache Solr module DataImportHandler contains a code injection vulnerability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0193",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-44168",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS",
+            "vulnerabilityName": "Fortinet FortiOS Arbitrary File Download",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "Fortinet FortiOS \"execute restore src-vis\" downloads code without integrity checking, allowing an attacker to arbitrarily download files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-12-24",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-44168",
+            "cwes": [
+                "CWE-494"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-17562",
+            "vendorProject": "Embedthis",
+            "product": "GoAhead",
+            "vulnerabilityName": "Embedthis GoAhead Remote Code Execution Vulnerability",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "Embedthis GoAhead before 3.6.5 allows remote code execution if CGI is enabled and a CGI program is dynamically linked.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-17562",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-12149",
+            "vendorProject": "Red Hat",
+            "product": "JBoss Application Server",
+            "vulnerabilityName": "Red Hat JBoss Application Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "The JBoss Application Server, shipped with Red Hat Enterprise Application Platform 5.2, allows an attacker to execute arbitrary code via crafted serialized data.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-10",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-12149",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-1871",
+            "vendorProject": "Red Hat",
+            "product": "JBoss Seam 2",
+            "vulnerabilityName": "Red Hat Linux JBoss Seam 2 Remote Code Execution Vulnerability",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "JBoss Seam 2 (jboss-seam2), as used in JBoss Enterprise Application Platform 4.3.0 for Red Hat Linux, allows attackers to perform remote code execution. This vulnerability can only be exploited when the Java Security Manager is not properly configured.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-1871",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-17463",
+            "vendorProject": "Fuel CMS",
+            "product": "Fuel CMS",
+            "vulnerabilityName": "Fuel CMS SQL Injection Vulnerability",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "FUEL CMS 1.4.7 allows SQL Injection via the col parameter to \/pages\/items, \/permissions\/items, or \/navigation\/items.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-17463",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-8816",
+            "vendorProject": "Pi-hole",
+            "product": "AdminLTE",
+            "vulnerabilityName": "Pi-Hole AdminLTE Remote Code Execution Vulnerability",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "Pi-hole Web v4.3.2 (aka AdminLTE) allows Remote Code Execution by privileged dashboard users via a crafted DHCP static lease.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8816",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-10758",
+            "vendorProject": "MongoDB",
+            "product": "mongo-express",
+            "vulnerabilityName": "MongoDB mongo-express Remote Code Execution Vulnerability",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "mongo-express before 0.54.0 is vulnerable to Remote Code Execution via endpoints that uses the `toBSON` method.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-10",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-10758",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-44228",
+            "vendorProject": "Apache",
+            "product": "Log4j2",
+            "vulnerabilityName": "Apache Log4j2 Remote Code Execution Vulnerability",
+            "dateAdded": "2021-12-10",
+            "shortDescription": "Apache Log4j2 contains a vulnerability where JNDI features do not protect against attacker-controlled JNDI-related endpoints, allowing for remote code execution.",
+            "requiredAction": "For all affected software assets for which updates exist, the only acceptable remediation actions are: 1) Apply updates; OR 2) remove affected assets from agency networks. Temporary mitigations using one of the measures provided at https:\/\/www.cisa.gov\/uscert\/ed-22-02-apache-log4j-recommended-mitigation-measures are only acceptable until updates are available.",
+            "dueDate": "2021-12-24",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-44228",
+            "cwes": [
+                "CWE-20",
+                "CWE-400",
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-11261",
+            "vendorProject": "Qualcomm",
+            "product": "Snapdragon Auto, Snapdragon Compute, Snapdragon Connectivity, Snapdragon Consumer IOT, Snapdragon Industrial IOT, Snapdragon Mobile, Snapdragon Voice & Music, Snapdragon Wearables",
+            "vulnerabilityName": "Qualcomm Multiple Chipsets Improper Input Validation Vulnerability",
+            "dateAdded": "2021-12-01",
+            "shortDescription": "Memory corruption due to improper check to return error when user application requests memory allocation of a huge size in Snapdragon Auto, Snapdragon Compute, Snapdragon Connectivity, Snapdragon Consumer IOT, Snapdragon Industrial IOT, Snapdragon Mobile, Snapdragon Voice & Music, Snapdragon Wearables",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-11261",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-14847",
+            "vendorProject": "MikroTik",
+            "product": "RouterOS",
+            "vulnerabilityName": "MikroTik Router OS Directory Traversal Vulnerability",
+            "dateAdded": "2021-12-01",
+            "shortDescription": "MikroTik RouterOS through 6.42 allows unauthenticated remote attackers to read arbitrary files and remote authenticated attackers to write arbitrary files due to a directory traversal vulnerability in the WinBox interface.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-06-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-14847",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-37415",
+            "vendorProject": "Zoho",
+            "product": "ManageEngine ServiceDesk Plus (SDP)",
+            "vulnerabilityName": "Zoho ManageEngine ServiceDesk Authentication Bypass Vulnerability",
+            "dateAdded": "2021-12-01",
+            "shortDescription": "Zoho ManageEngine ServiceDesk Plus before 11302 is vulnerable to authentication bypass that allows a few REST-API URLs without authentication",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-12-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-37415",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-40438",
+            "vendorProject": "Apache",
+            "product": "Apache",
+            "vulnerabilityName": "Apache HTTP Server-Side Request Forgery (SSRF)",
+            "dateAdded": "2021-12-01",
+            "shortDescription": "A crafted request uri-path can cause mod_proxy to forward the request to an origin server choosen by the remote user. This issue affects Apache HTTP Server 2.4.48 and earlier.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-12-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-40438",
+            "cwes": [
+                "CWE-918"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-44077",
+            "vendorProject": "Zoho",
+            "product": "ManageEngine ServiceDesk Plus (SDP) \/ SupportCenter Plus",
+            "vulnerabilityName": "Zoho ManageEngine ServiceDesk Plus Remote Code Execution Vulnerability",
+            "dateAdded": "2021-12-01",
+            "shortDescription": "Zoho ManageEngine ServiceDesk Plus before 11306, ServiceDesk Plus MSP before 10530, and SupportCenter Plus before 11014 are vulnerable to unauthenticated remote code execution",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-12-15",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-44077",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22204",
+            "vendorProject": "Perl",
+            "product": "Exiftool",
+            "vulnerabilityName": "ExifTool Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-17",
+            "shortDescription": "Improper neutralization of user data in the DjVu file format in Exiftool versions 7.44 and up allows arbitrary code execution when parsing the malicious image",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-12-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22204",
+            "cwes": [
+                "CWE-95"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-40449",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-17",
+            "shortDescription": "Unspecified vulnerability allows for an authenticated user to escalate privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-12-01",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-40449",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-42321",
+            "vendorProject": "Microsoft",
+            "product": "Exchange",
+            "vulnerabilityName": "Microsoft Exchange Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-17",
+            "shortDescription": "An authenticated attacker could leverage improper validation in cmdlet arguments within Microsoft Exchange and perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-12-01",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-42321",
+            "cwes": [
+                "CWE-184",
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-42292",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Excel Security Feature Bypass",
+            "dateAdded": "2021-11-17",
+            "shortDescription": "A security feature bypass vulnerability in Microsoft Excel would allow a local user to perform arbitrary code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-12-01",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-42292",
+            "cwes": [
+                "CWE-357"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27104",
+            "vendorProject": "Accellion",
+            "product": "FTA",
+            "vulnerabilityName": "Accellion FTA OS Command Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Accellion FTA contains an OS command injection vulnerability exploited via a crafted POST request to various admin endpoints.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27104",
+            "cwes": [
+                "CWE-20",
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27102",
+            "vendorProject": "Accellion",
+            "product": "FTA",
+            "vulnerabilityName": "Accellion FTA OS Command Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Accellion FTA contains an OS command injection vulnerability exploited via a local web service call.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27102",
+            "cwes": [
+                "CWE-20",
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27101",
+            "vendorProject": "Accellion",
+            "product": "FTA",
+            "vulnerabilityName": "Accellion FTA SQL Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Accellion FTA contains a SQL injection vulnerability exploited via a crafted host header in a request to document_root.html.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27101",
+            "cwes": [
+                "CWE-89",
+                "CWE-138"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27103",
+            "vendorProject": "Accellion",
+            "product": "FTA",
+            "vulnerabilityName": "Accellion FTA Server-Side Request Forgery (SSRF) Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Accellion FTA contains a server-side request forgery (SSRF) vulnerability exploited via a crafted POST request to wmProgressstat.html.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27103",
+            "cwes": [
+                "CWE-918"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21017",
+            "vendorProject": "Adobe",
+            "product": "Acrobat and Reader",
+            "vulnerabilityName": "Adobe Acrobat and Reader Heap-based Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Acrobat Acrobat and Reader contain a heap-based buffer overflow vulnerability that could allow an unauthenticated attacker to achieve code execution in the context of the current user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21017",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-28550",
+            "vendorProject": "Adobe",
+            "product": "Acrobat and Reader",
+            "vulnerabilityName": "Adobe Acrobat and Reader Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Adobe Acrobat and Reader contains a use-after-free vulnerability that could allow an unauthenticated attacker to achieve code execution in the context of the current user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-28550",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-4939",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Adobe ColdFusion contains a deserialization of untrusted data vulnerability that could allow for code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-4939",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-15961",
+            "vendorProject": "Adobe",
+            "product": "ColdFusion",
+            "vulnerabilityName": "Adobe ColdFusion Unrestricted File Upload Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Adobe ColdFusion contains an unrestricted file upload vulnerability that could allow for code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-15961",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-4878",
+            "vendorProject": "Adobe",
+            "product": "Flash Player",
+            "vulnerabilityName": "Adobe Flash Player Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Adobe Flash Player contains a use-after-free vulnerability that could allow for code execution.",
+            "requiredAction": "The impacted product is end-of-life and should be disconnected if still in use.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-4878",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-5735",
+            "vendorProject": "Amcrest",
+            "product": "Cameras and Network Video Recorder (NVR)",
+            "vulnerabilityName": "Amcrest Cameras and NVR Stack-based Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Amcrest cameras and NVR contain a stack-based buffer overflow vulnerability through port 37777 that allows an unauthenticated, remote attacker to crash the device and possibly execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-5735",
+            "cwes": [
+                "CWE-121"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-2215",
+            "vendorProject": "Android",
+            "product": "Android Kernel",
+            "vulnerabilityName": "Android Kernel Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Android Kernel contains a use-after-free vulnerability in binder.c that allows for privilege escalation from an application to the Linux Kernel. This vulnerability was observed chained with CVE-2020-0041 and CVE-2020-0069 under exploit chain \"AbstractEmu.\"",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-2215",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0041",
+            "vendorProject": "Android",
+            "product": "Android Kernel",
+            "vulnerabilityName": "Android Kernel Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Android Kernel binder_transaction of binder.c contains an out-of-bounds write vulnerability due to an incorrect bounds check that could allow for local privilege escalation. This vulnerability was observed chained with CVE-2019-2215 and CVE-2020-0069 under exploit chain \"AbstractEmu.\"",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0041",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0069",
+            "vendorProject": "MediaTek",
+            "product": "Multiple Chipsets",
+            "vulnerabilityName": "Mediatek Multiple Chipsets Insufficient Input Validation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Multiple MediaTek chipsets contain an insufficient input validation vulnerability and have missing SELinux restrictions in the Command Queue drivers ioctl handlers. This causes an out-of-bounds write leading to privilege escalation. This vulnerability was observed chained with CVE-2019-2215 and CVE-2020-0041 under exploit chain \"AbstractEmu.\"",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0069",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-9805",
+            "vendorProject": "Apache",
+            "product": "Struts",
+            "vulnerabilityName": "Apache Struts Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apache Struts REST Plugin uses an XStreamHandler with an instance of XStream for deserialization without any type filtering, which can lead to remote code execution when deserializing XML payloads.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-9805",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-42013",
+            "vendorProject": "Apache",
+            "product": "HTTP Server",
+            "vulnerabilityName": "Apache HTTP Server Path Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apache HTTP Server contains a path traversal vulnerability that allows an attacker to perform remote code execution if files outside directories configured by Alias-like directives are not under default require all denied or if CGI scripts are enabled. This CVE ID resolves an incomplete patch for CVE-2021-41773.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-42013",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-41773",
+            "vendorProject": "Apache",
+            "product": "HTTP Server",
+            "vulnerabilityName": "Apache HTTP Server Path Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apache HTTP Server contains a path traversal vulnerability that allows an attacker to perform remote code execution if files outside directories configured by Alias-like directives are not under default \ufffdrequire all denied\ufffd or if CGI scripts are enabled. The original patch issued under this CVE ID is insufficient, please review remediation information under CVE-2021-42013.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-41773",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0211",
+            "vendorProject": "Apache",
+            "product": "HTTP Server",
+            "vulnerabilityName": "Apache HTTP Server Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apache HTTP Server, with MPM event, worker or prefork, code executing in less-privileged child processes or threads (including scripts executed by an in-process scripting interpreter) could execute code with the privileges of the parent process (usually root) by manipulating the scoreboard.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0211",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-4437",
+            "vendorProject": "Apache",
+            "product": "Shiro",
+            "vulnerabilityName": "Apache Shiro Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apache Shiro contains a vulnerability which may allow remote attackers to execute code or bypass intended access restrictions via an unspecified request parameter when a cipher key has not been configured for the \"remember me\" feature.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-4437",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-17558",
+            "vendorProject": "Apache",
+            "product": "Solr",
+            "vulnerabilityName": "Apache Solr VelocityResponseWriter Plug-In Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "The Apache Solr VelocityResponseWriter plug-in contains an unspecified vulnerability which can allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-17558",
+            "cwes": [
+                "CWE-74"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-17530",
+            "vendorProject": "Apache",
+            "product": "Struts",
+            "vulnerabilityName": "Apache Struts Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Forced Object-Graph Navigation Language (OGNL) evaluation in Apache Struts, when evaluated on raw user input in tag attributes, can lead to remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-17530",
+            "cwes": [
+                "CWE-917"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-5638",
+            "vendorProject": "Apache",
+            "product": "Struts",
+            "vulnerabilityName": "Apache Struts Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apache Struts Jakarta Multipart parser allows for malicious file upload using the Content-Type value, leading to remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-5638",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-11776",
+            "vendorProject": "Apache",
+            "product": "Struts",
+            "vulnerabilityName": "Apache Struts Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apache Struts contains a vulnerability that allows for remote code execution under two circumstances. One, where the alwaysSelectFullNamespace option is true and the value isn't set for a result defined in underlying configurations and in same time, its upper package configuration have no or wildcard namespace.  Or, using URL tag which doesn't have value and action set and in same time, its upper package configuration have no or wildcard namespace.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-11776",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30858",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and macOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, macOS Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, and macOS WebKit contain a use-after-free vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30858",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-6223",
+            "vendorProject": "Apple",
+            "product": "iOS and macOS",
+            "vulnerabilityName": "Apple iOS and macOS Group Facetime Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS and macOS Group FaceTime contains an unspecified vulnerability where the call initiator can cause the recipient's Apple device to answer unknowingly or without user interaction.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-6223",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-30860",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Integer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and watchOS CoreGraphics contain an integer overflow vulnerability which may allow code execution when processing a maliciously crafted PDF. The vulnerability is also known under the moniker of FORCEDENTRY.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30860",
+            "cwes": [
+                "CWE-20",
+                "CWE-190"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-27930",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and watchOS FontParser contain a memory corruption vulnerability which may allow for code execution when processing maliciously crafted front.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-27930",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30807",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and watchOS IOMobileFrameBuffer contain a memory corruption vulnerability which may allow an application to execute code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30807",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-27950",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Memory Initialization Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and watchOS contain a memory initialization vulnerability that may allow a malicious application to disclose kernel memory.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-27950",
+            "cwes": [
+                "CWE-665"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-27932",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Type Confusion Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, macOS, and watchOS contain a type confusion vulnerability that may allow a malicious application to execute code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-27932",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-9818",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and watchOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and watchOS Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, and watchOS Mail contains an out-of-bounds write vulnerability which may allow memory modification or application termination when processing a maliciously crafted mail message.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-9818",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-9819",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and watchOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and watchOS Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, and watchOS Mail contains a memory corruption vulnerability that may allow heap corruption when processing a maliciously crafted mail message.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-9819",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30762",
+            "vendorProject": "Apple",
+            "product": "iOS",
+            "vulnerabilityName": "Apple iOS WebKit Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS WebKit contains a use-after-free vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30762",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1782",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Race Condition Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOs, macOS, watchOS, and tvOS contain a race condition vulnerability that may allow a malicious application to elevate privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1782",
+            "cwes": [
+                "CWE-362",
+                "CWE-667"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1870",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and macOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and macOS WebKit Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, and macOS WebKit contain an unspecified logic vulnerability that allows a remote attacker to execute code. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1870",
+            "cwes": [
+                "CWE-1173"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1871",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and macOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and macOS WebKit Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, and macOS WebKit contain an unspecified logic vulnerability that allows a remote attacker to execute code. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1871",
+            "cwes": [
+                "CWE-1173"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1879",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and watchOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and watchOS WebKit Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, and watchOS WebKit contain an unspecified vulnerability that allows for universal cross-site scripting (XSS) when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1879",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30661",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Storage Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, macOS, tvOS, watchOS, and Safari WebKit Storage contain a use-after-free vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30661",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30666",
+            "vendorProject": "Apple",
+            "product": "iOS",
+            "vulnerabilityName": "Apple iOS WebKit Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS WebKit contains a buffer-overflow vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30666",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30713",
+            "vendorProject": "Apple",
+            "product": "macOS",
+            "vulnerabilityName": "Apple macOS Unspecified Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple macOS Transparency, Consent, and Control (TCC) contains an unspecified permissions issue which may allow a malicious application to bypass privacy preferences.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30713",
+            "cwes": [
+                "CWE-862"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30657",
+            "vendorProject": "Apple",
+            "product": "macOS",
+            "vulnerabilityName": "Apple macOS Unspecified Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple macOS contains an unspecified logic issue in System Preferences that may allow a malicious application to bypass Gatekeeper checks.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30657",
+            "cwes": [
+                "CWE-862"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30665",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, macOS, watchOS, and tvOS WebKit contain a memory corruption vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30665",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30663",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products WebKit Integer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, macOS, tvOS, and Safari WebKit contain an integer overflow vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30663",
+            "cwes": [
+                "CWE-20",
+                "CWE-190"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30761",
+            "vendorProject": "Apple",
+            "product": "iOS",
+            "vulnerabilityName": "Apple iOS WebKit Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS WebKit contains a memory corruption vulnerability that leads to code execution when processing maliciously crafted web content. This vulnerability could impact HTML parsers that use WebKit, including but not limited to Apple Safari and non-Apple products which rely on WebKit for HTML processing.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30761",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30869",
+            "vendorProject": "Apple",
+            "product": "iOS, iPadOS, and macOS",
+            "vulnerabilityName": "Apple iOS, iPadOS, and macOS Type Confusion Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, and macOS contain a type confusion vulnerability in the XNU which may allow a malicious application to execute code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30869",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-9859",
+            "vendorProject": "Apple",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Apple Multiple Products Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Apple iOS, iPadOS, macOS, watchOS, and tvOS contain an unspecified vulnerability that may allow an application to execute code with kernel privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-9859",
+            "cwes": [
+                "CWE-415"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-20090",
+            "vendorProject": "Arcadyan",
+            "product": "Buffalo Firmware",
+            "vulnerabilityName": "Arcadyan Buffalo Firmware Path Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Arcadyan Buffalo firmware contains a path traversal vulnerability that could allow unauthenticated, remote attackers to bypass authentication and access sensitive information. This vulnerability affects multiple routers across several different vendors.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-20090",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27562",
+            "vendorProject": "Arm",
+            "product": "Trusted Firmware",
+            "vulnerabilityName": "Arm Trusted Firmware Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Arm Trusted Firmware contains an out-of-bounds write vulnerability allowing the non-secure (NS) world to trigger a system halt, overwrite secure data, or print out secure data when calling secure functions under the non-secure processing environment (NSPE) handler mode. This vulnerability affects Yealink Device Management servers.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27562",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-28664",
+            "vendorProject": "Arm",
+            "product": "Mali Graphics Processing Unit (GPU)",
+            "vulnerabilityName": "Arm Mali Graphics Processing Unit (GPU) Unspecified Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Arm Mali Graphics Processing Unit (GPU) kernel driver contains an unspecified vulnerability that may allow a non-privileged user to gain write access to read-only memory, gain root privilege, corrupt memory, and modify the memory of other processes.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-28664",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-28663",
+            "vendorProject": "Arm",
+            "product": "Mali Graphics Processing Unit (GPU)",
+            "vulnerabilityName": "Arm Mali Graphics Processing Unit (GPU) Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Arm Mali Graphics Processing Unit (GPU) kernel driver contains a use-after-free vulnerability that may allow a non-privileged user to make improper operations on GPU memory to gain root privilege, and\/or disclose information.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-28663",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-3398",
+            "vendorProject": "Atlassian",
+            "product": "Confluence Server and Data Center",
+            "vulnerabilityName": "Atlassian Confluence Server and Data Center Path Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Atlassian Confluence Server and Data Center contain a path traversal vulnerability in the downloadallattachments resource that may allow a privileged, remote attacker to write files. Exploitation can lead to remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-3398",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-26084",
+            "vendorProject": "Atlassian",
+            "product": "Confluence Server and Data Center",
+            "vulnerabilityName": "Atlassian Confluence Server and Data Center Object-Graph Navigation Language (OGNL) Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Atlassian Confluence Server and Data Server contain an Object-Graph Navigation Language (OGNL) injection vulnerability that may allow an unauthenticated attacker to execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-26084",
+            "cwes": [
+                "CWE-917"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-11580",
+            "vendorProject": "Atlassian",
+            "product": "Crowd and Crowd Data Center",
+            "vulnerabilityName": "Atlassian Crowd and Crowd Data Center Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Atlassian Crowd and Crowd Data Center contain a remote code execution vulnerability resulting from a pdkinstall development plugin being incorrectly enabled in release builds.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-11580",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-3396",
+            "vendorProject": "Atlassian",
+            "product": "Confluence Server and Data Server",
+            "vulnerabilityName": "Atlassian Confluence Server and Data Center Server-Side Template Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Atlassian Confluence Server and Data Center contain a server-side template injection vulnerability that may allow an attacker to achieve path traversal and remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-3396",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-42258",
+            "vendorProject": "BQE",
+            "product": "BillQuick Web Suite",
+            "vulnerabilityName": "BQE BillQuick Web Suite SQL Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "BQE BillQuick Web Suite contains an SQL injection vulnerability when accessing the username parameter that may allow for unauthenticated, remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-42258",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3452",
+            "vendorProject": "Cisco",
+            "product": "Adaptive Security Appliance (ASA) and Firepower Threat Defense (FTD)",
+            "vulnerabilityName": "Cisco ASA and FTD Read-Only Path Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Cisco Adaptive Security Appliance (ASA) and Firepower Threat Defense (FTD) contain an improper input validation vulnerability when HTTP requests process URLs.  An attacker could exploit this vulnerability by sending a crafted HTTP request containing directory traversal character sequences to an affected device. A successful exploit could allow the attacker to view arbitrary files within the web services file system on the targeted device.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3452",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3580",
+            "vendorProject": "Cisco",
+            "product": "Adaptive Security Appliance (ASA) and Firepower Threat Defense (FTD)",
+            "vulnerabilityName": "Cisco ASA and FTD Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Cisco Adaptive Security Appliance (ASA) and Firepower Threat Defense (FTD) contain an insufficient input validation vulnerability for user-supplied input by the web services interface.  Successful exploitation could allow an attacker to perform cross-site scripting (XSS) in the context of the interface or access sensitive browser-based information.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3580",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1497",
+            "vendorProject": "Cisco",
+            "product": "HyperFlex HX",
+            "vulnerabilityName": "Cisco HyperFlex HX Installer Virtual Machine Command Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Cisco HyperFlex HX Installer Virtual Machine contains an insufficient input validation vulnerability which could allow an attacker to execute commands on an affected device as the root user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1497",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1498",
+            "vendorProject": "Cisco",
+            "product": "HyperFlex HX",
+            "vulnerabilityName": "Cisco HyperFlex HX Data Platform Command Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Cisco HyperFlex HX Installer Virtual Machine contains an insufficient input validation vulnerability which could allow an attacker to execute commands on an affected device as the tomcat8 user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1498",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0171",
+            "vendorProject": "Cisco",
+            "product": "IOS and IOS XE",
+            "vulnerabilityName": "Cisco IOS and IOS XE Software Smart Install Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Cisco IOS and IOS XE Software improperly validates packet data, allowing an unauthenticated, remote attacker to trigger a reload of an affected device, cause a denial-of-service (DoS) condition, or perform code execution on the affected device.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0171",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3118",
+            "vendorProject": "Cisco",
+            "product": "IOS XR",
+            "vulnerabilityName": "Cisco IOS XR Software Discovery Protocol Format String Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Cisco IOS XR improperly validates string input from certain fields in Cisco Discovery Protocol messages. Exploitation could allow an unauthenticated, adjacent attacker to execute code with administrative privileges or cause a reload on an affected device.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3118",
+            "cwes": [
+                "CWE-134"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3566",
+            "vendorProject": "Cisco",
+            "product": "IOS XR",
+            "vulnerabilityName": "Cisco IOS XR Software DVMRP Memory Exhaustion Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Cisco IOS XR Distance Vector Multicast Routing Protocol (DVMRP) incorrectly handles Internet Group Management Protocol (IGMP) packets. Exploitation could allow an unauthenticated, remote attacker to immediately crash the IGMP process or make it consume available memory and eventually crash.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3566",
+            "cwes": [
+                "CWE-400"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3569",
+            "vendorProject": "Cisco",
+            "product": "IOS XR",
+            "vulnerabilityName": "Cisco IOS XR Software DVMRP Memory Exhaustion Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Cisco IOS XR Distance Vector Multicast Routing Protocol (DVMRP) incorrectly handles Internet Group Management Protocol (IGMP) packets. Exploitation could allow an unauthenticated, remote attacker to immediately crash the IGMP process or make it consume available memory and eventually crash.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3569",
+            "cwes": [
+                "CWE-400"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3161",
+            "vendorProject": "Cisco",
+            "product": "Cisco IP Phones",
+            "vulnerabilityName": "Cisco IP Phones Web Server Remote Code Execution and Denial-of-Service Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Cisco IP Phones contain an improper input validation vulnerability for HTTP requests. Exploitation could allow an attacker to execute code remotely with root privileges or cause a denial-of-service (DoS) condition.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3161",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1653",
+            "vendorProject": "Cisco",
+            "product": "Small Business RV320 and RV325 Routers",
+            "vulnerabilityName": "Cisco Small Business RV320 and RV325 Routers Information Disclosure Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Cisco Small Business RV320 and RV325 Dual Gigabit WAN VPN Routers contain improper access controls for URLs. Exploitation could allow an attacker to download the router configuration or detailed diagnostic information.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1653",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0296",
+            "vendorProject": "Cisco",
+            "product": "Adaptive Security Appliance (ASA)",
+            "vulnerabilityName": "Cisco Adaptive Security Appliance (ASA) Denial-of-Service Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Cisco Adaptive Security Appliance (ASA) contains an improper input validation vulnerability with HTTP URLs. Exploitation could allow an attacker to cause a denial-of-service (DoS) condition or information disclosure.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0296",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-13608",
+            "vendorProject": "Citrix",
+            "product": "StoreFront Server",
+            "vulnerabilityName": "Citrix StoreFront Server XML External Entity (XXE) Processing Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Citrix StoreFront Server contains an XML External Entity (XXE) processing vulnerability that may allow an unauthenticated attacker to retrieve potentially sensitive information.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-13608",
+            "cwes": [
+                "CWE-611"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-8193",
+            "vendorProject": "Citrix",
+            "product": "Application Delivery Controller (ADC), Gateway, and SD-WAN WANOP Appliance",
+            "vulnerabilityName": "Citrix ADC, Gateway, and SD-WAN WANOP Appliance Authorization Bypass Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Citrix ADC, Citrix Gateway, and multiple Citrix SD-WAN WANOP appliance models contain an authorization bypass vulnerability that may allow unauthenticated access to certain URL endpoints. The attacker must have access to the NetScaler IP (NSIP) in order to perform exploitation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8193",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-8195",
+            "vendorProject": "Citrix",
+            "product": "Application Delivery Controller (ADC), Gateway, and SD-WAN WANOP Appliance",
+            "vulnerabilityName": "Citrix ADC, Gateway, and SD-WAN WANOP Appliance Information Disclosure Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Citrix ADC, Citrix Gateway, and multiple Citrix SD-WAN WANOP appliance models contain an information disclosure vulnerability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8195",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-8196",
+            "vendorProject": "Citrix",
+            "product": "Application Delivery Controller (ADC), Gateway, and SD-WAN WANOP Appliance",
+            "vulnerabilityName": "Citrix ADC, Gateway, and SD-WAN WANOP Appliance Information Disclosure Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Citrix ADC, Citrix Gateway, and multiple Citrix SD-WAN WANOP appliance models contain an information disclosure vulnerability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8196",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-19781",
+            "vendorProject": "Citrix",
+            "product": "Application Delivery Controller (ADC), Gateway, and SD-WAN WANOP Appliance",
+            "vulnerabilityName": "Citrix ADC, Gateway, and SD-WAN WANOP Appliance Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Citrix ADC, Citrix Gateway, and multiple Citrix SD-WAN WANOP appliance models contain an unspecified vulnerability that could allow an unauthenticated attacker to perform code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-19781",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-11634",
+            "vendorProject": "Citrix",
+            "product": "Workspace Application and Receiver for Windows",
+            "vulnerabilityName": "Citrix Workspace Application and Receiver for Windows Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Citrix Workspace Application and Receiver for Windows contains remote code execution vulnerability resulting from local drive access preferences not being enforced into the clients' local drives.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-11634",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-29557",
+            "vendorProject": "D-Link",
+            "product": "DIR-825 R1 Devices",
+            "vulnerabilityName": "D-Link DIR-825 R1 Devices Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "D-Link DIR-825 R1 devices contain a buffer overflow vulnerability in the web interface that may allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-29557",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-25506",
+            "vendorProject": "D-Link",
+            "product": "DNS-320 Device",
+            "vulnerabilityName": "D-Link DNS-320 Device Command Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "D-Link DNS-320 device contains a command injection vulnerability in the sytem_mgr.cgi component that may allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-25506",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-15811",
+            "vendorProject": "DotNetNuke (DNN)",
+            "product": "DotNetNuke (DNN)",
+            "vulnerabilityName": "DotNetNuke (DNN) Inadequate Encryption Strength Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "DotNetNuke (DNN) contains an inadequate encryption strength vulnerability resulting from the use of a weak encryption algorithm to protect input parameters.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-15811",
+            "cwes": [
+                "CWE-326"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-18325",
+            "vendorProject": "DotNetNuke (DNN)",
+            "product": "DotNetNuke (DNN)",
+            "vulnerabilityName": "DotNetNuke (DNN) Inadequate Encryption Strength Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "DotNetNuke (DNN) contains an inadequate encryption strength vulnerability resulting from the use of a weak encryption algorithm to protect input parameters. This CVE ID resolves an incomplete patch for CVE-2018-15811.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-18325",
+            "cwes": [
+                "CWE-326"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-9822",
+            "vendorProject": "DotNetNuke (DNN)",
+            "product": "DotNetNuke (DNN)",
+            "vulnerabilityName": "DotNetNuke (DNN) Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "DotNetNuke (DNN) contains a vulnerability that may allow for remote code execution via cookie deserialization.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-9822",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-15752",
+            "vendorProject": "Docker",
+            "product": "Desktop Community Edition",
+            "vulnerabilityName": "Docker Desktop Community Edition Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Docker Desktop Community Edition contains a vulnerability that may allow local users to escalate privileges by placing a trojan horse docker-credential-wincred.exe file in %PROGRAMDATA%\\DockerDesktop\\version-bin\\.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-15752",
+            "cwes": [
+                "CWE-732"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-8515",
+            "vendorProject": "DrayTek",
+            "product": "Multiple Vigor Routers",
+            "vulnerabilityName": "Multiple DrayTek Vigor Routers Web Management Page Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "DrayTek Vigor3900, Vigor2960, and Vigor300B routers contain an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8515",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-7600",
+            "vendorProject": "Drupal",
+            "product": "Drupal Core",
+            "vulnerabilityName": "Drupal Core Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Drupal Core contains a remote code execution vulnerability that could allow an attacker to exploit multiple attack vectors on a Drupal site, resulting in complete site compromise.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-7600",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22205",
+            "vendorProject": "GitLab",
+            "product": "Community and Enterprise Editions",
+            "vulnerabilityName": "GitLab Community and Enterprise Editions Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "GitHub Community and Enterprise Editions that utilize the ability to upload images through GitLab Workhorse are vulnerable to remote code execution. Workhorse passes image file extensions through ExifTool, which improperly validates the image files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22205",
+            "cwes": [
+                "CWE-20",
+                "CWE-95"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-6789",
+            "vendorProject": "Exim",
+            "product": "Exim",
+            "vulnerabilityName": "Exim Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Exim contains a buffer overflow vulnerability in the base64d function part of the SMTP listener that may allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-6789",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-8657",
+            "vendorProject": "EyesOfNetwork",
+            "product": "EyesOfNetwork",
+            "vulnerabilityName": "EyesOfNetwork Use of Hard-Coded Credentials Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "EyesOfNetwork contains a use of hard-coded credentials vulnerability, as it uses the same API key by default. Exploitation allows an attacker to calculate or guess the admin access token.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8657",
+            "cwes": [
+                "CWE-798"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-8655",
+            "vendorProject": "EyesOfNetwork",
+            "product": "EyesOfNetwork",
+            "vulnerabilityName": "EyesOfNetwork Improper Privilege Management Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "EyesOfNetwork contains an improper privilege management vulnerability that may allow a user to run commands as root via a crafted Nmap Scripting Engine (NSE) script to nmap7.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8655",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-5902",
+            "vendorProject": "F5",
+            "product": "BIG-IP",
+            "vulnerabilityName": "F5 BIG-IP Traffic Management User Interface (TMUI) Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "F5 BIG-IP Traffic Management User Interface (TMUI) contains a remote code execution vulnerability in undisclosed pages.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-5902",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22986",
+            "vendorProject": "F5",
+            "product": "BIG-IP and BIG-IQ Centralized Management",
+            "vulnerabilityName": "F5 BIG-IP and BIG-IQ Centralized Management iControl REST Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "F5 BIG-IP and BIG-IQ Centralized Management contain a remote code execution vulnerability in the iControl REST interface that allows unauthenticated attackers with network access to execute system commands, create or delete files, and disable services.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22986",
+            "cwes": [
+                "CWE-863"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-35464",
+            "vendorProject": "ForgeRock",
+            "product": "Access Management (AM)",
+            "vulnerabilityName": "ForgeRock Access Management (AM) Core Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "ForgeRock Access Management (AM) Core Server allows an attacker who sends a specially crafted HTTP request to one of three endpoints (\/ccversion\/Version, \/ccversion\/Masthead, or \/ccversion\/ButtonFrame) to execute code in the context of the current user (unless ForgeRock AM is running as root user, which the vendor does not recommend).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-35464",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-5591",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS",
+            "vulnerabilityName": "Fortinet FortiOS Default Configuration Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Fortinet FortiOS contains a default configuration vulnerability that may allow an unauthenticated attacker on the same subnet to intercept sensitive information by impersonating the Lightweight Directory Access Protocol (LDAP) server.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-5591",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-12812",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS",
+            "vulnerabilityName": "Fortinet FortiOS SSL VPN Improper Authentication Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Fortinet FortiOS SSL VPN contains an improper authentication vulnerability that may allow a user to login successfully without being prompted for the second factor of authentication (FortiToken) if they change the case in their username.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-12812",
+            "cwes": [
+                "CWE-178",
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-13379",
+            "vendorProject": "Fortinet",
+            "product": "FortiOS",
+            "vulnerabilityName": "Fortinet FortiOS SSL VPN Path Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Fortinet FortiOS SSL VPN web portal contains a path traversal vulnerability that may allow an unauthenticated attacker to download FortiOS system files through specially crafted HTTP resource requests.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-13379",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-16010",
+            "vendorProject": "Google",
+            "product": "Chrome for Android UI",
+            "vulnerabilityName": "Google Chrome for Android UI Heap Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chrome for Android UI contains a heap buffer overflow vulnerability that allows a remote attacker, who has compromised the renderer process, to potentially perform a sandbox escape via a crafted HTML page.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-16010",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-15999",
+            "vendorProject": "Google",
+            "product": "Chrome FreeType",
+            "vulnerabilityName": "Google Chrome FreeType Heap Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chrome uses FreeType, an open-source software library to render fonts, which contains a heap buffer overflow vulnerability in the function Load_SBit_Png when processing PNG images embedded into fonts. This vulnerability is part of an exploit chain with CVE-2020-17087 on Windows and CVE-2020-16010 on Android.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-15999",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21166",
+            "vendorProject": "Google",
+            "product": "Chromium",
+            "vulnerabilityName": "Google Chromium Race Condition Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium contains a race condition vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21166",
+            "cwes": [
+                "CWE-122",
+                "CWE-362"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-16017",
+            "vendorProject": "Google",
+            "product": "Chrome",
+            "vulnerabilityName": "Google Chrome Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chrome contains a use-after-free vulnerability that allows a remote attacker, who has compromised the renderer process, to potentially perform a sandbox escape via a crafted HTML page.  ",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-16017",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-37976",
+            "vendorProject": "Google",
+            "product": "Chromium",
+            "vulnerabilityName": "Google Chromium Information Disclosure Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium contains an information disclosure vulnerability within the core memory component that allows a remote attacker to obtain potentially sensitive information from process memory via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-37976",
+            "cwes": [
+                "CWE-862"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-16009",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium V8 Engine contains a type confusion vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-16009",
+            "cwes": [
+                "CWE-787",
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30632",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Out-of-Bounds Write Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium V8 Engine contains an out-of-bounds write vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30632",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-16013",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Incorrect Implementation Vulnerabililty",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium V8 Engine contains an inappropriate implementation vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-16013",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30633",
+            "vendorProject": "Google",
+            "product": "Chromium Indexed DB API",
+            "vulnerabilityName": "Google Chromium Indexed DB API Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium Indexed DB API contains a use-after-free vulnerability that allows a remote attacker, who has compromised the renderer process, to potentially perform a sandbox escape via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30633",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21148",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Heap Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium V8 Engine contains a heap buffer overflow vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21148",
+            "cwes": [
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-37973",
+            "vendorProject": "Google",
+            "product": "Chromium Portals",
+            "vulnerabilityName": "Google Chromium Portals Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium Portals contains a use-after-free vulnerability that allows a remote attacker, who has compromised the renderer process, to potentially perform a sandbox escape via a crafted HTML page. This vulnerability affects web browsers that utilize Chromium, including Google Chrome and Microsoft Edge.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-37973",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30551",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium V8 Engine contains a type confusion vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30551",
+            "cwes": [
+                "CWE-122",
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-37975",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium V8 Engine contains a use-after-free vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-37975",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-6418",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium V8 Engine contains a type confusion vulnerability allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-6418",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30554",
+            "vendorProject": "Google",
+            "product": "Chromium WebGL",
+            "vulnerabilityName": "Google Chromium WebGL Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium WebGL contains a use-after-free vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30554",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21206",
+            "vendorProject": "Google",
+            "product": "Chromium Blink",
+            "vulnerabilityName": "Google Chromium Blink Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium Blink contains a use-after-free vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21206",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-38000",
+            "vendorProject": "Google",
+            "product": "Chromium Intents",
+            "vulnerabilityName": "Google Chromium Intents Improper Input Validation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium Intents contains an improper input validation vulnerability that allows a remote attacker to arbitrarily browser to a malicious URL via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-38000",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-38003",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium V8 Engine has a bug in JSON.stringify, where the internal TheHole value can leak to script code, causing memory corruption. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-38003",
+            "cwes": [
+                "CWE-122",
+                "CWE-755"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21224",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium V8 Engine contains a type confusion vulnerability that allows a remote attacker to execute code inside a sandbox via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21224",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21193",
+            "vendorProject": "Google",
+            "product": "Chromium Blink",
+            "vulnerabilityName": "Google Chromium Blink Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium Blink contains a use-after-free vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21193",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21220",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Improper Input Validation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium V8 Engine contains an improper input validation vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21220",
+            "cwes": [
+                "CWE-20",
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30563",
+            "vendorProject": "Google",
+            "product": "Chromium V8",
+            "vulnerabilityName": "Google Chromium V8 Type Confusion Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Google Chromium V8 Engine contains a type confusion vulnerability that allows a remote attacker to potentially exploit heap corruption via a crafted HTML page. This vulnerability could affect multiple web browsers that utilize Chromium, including, but not limited to, Google Chrome, Microsoft Edge, and Opera.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30563",
+            "cwes": [
+                "CWE-122",
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-4430",
+            "vendorProject": "IBM",
+            "product": "Data Risk Manager",
+            "vulnerabilityName": "IBM Data Risk Manager Directory Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "IBM Data Risk Manager contains a directory traversal vulnerability that could allow a remote authenticated attacker to traverse directories and send a specially crafted URL request to download arbitrary files from the system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-4430",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-4427",
+            "vendorProject": "IBM",
+            "product": "Data Risk Manager",
+            "vulnerabilityName": "IBM Data Risk Manager Security Bypass Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "IBM Data Risk Manager contains a security bypass vulnerability that could allow a remote attacker to bypass security restrictions when configured with SAML authentication. By sending a specially crafted HTTP request, an attacker could exploit this vulnerability to bypass the authentication process and gain full administrative access to the system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-4427",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-4428",
+            "vendorProject": "IBM",
+            "product": "Data Risk Manager",
+            "vulnerabilityName": "IBM Data Risk Manager Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "IBM Data Risk Manager contains an unspecified vulnerability which could allow a remote, authenticated attacker to execute commands on the system.\ufffd",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-4428",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-4716",
+            "vendorProject": "IBM",
+            "product": "Planning Analytics",
+            "vulnerabilityName": "IBM Planning Analytics Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "IBM Planning Analytics is vulnerable to a configuration overwrite that allows an unauthenticated user to login as \"admin\", and then execute code as root or SYSTEM via TM1 scripting.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-4716",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-3715",
+            "vendorProject": "ImageMagick",
+            "product": "ImageMagick",
+            "vulnerabilityName": "ImageMagick Arbitrary File Deletion Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "ImageMagick contains an unspecified vulnerability that could allow users to delete files by using ImageMagick's 'ephemeral' pseudo protocol, which deletes files after reading.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-3715",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-3718",
+            "vendorProject": "ImageMagick",
+            "product": "ImageMagick",
+            "vulnerabilityName": "ImageMagick Server-Side Request Forgery (SSRF) Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "ImageMagick contains an unspecified vulnerability that allows attackers to perform server-side request forgery (SSRF) via a crafted image.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-3718",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-15505",
+            "vendorProject": "Ivanti",
+            "product": "MobileIron Multiple Products",
+            "vulnerabilityName": "Ivanti MobileIron Multiple Products Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Ivanti MobileIron's Core & Connector, Sentry, and Monitor and Reporting Database (RDB) products contain an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-15505",
+            "cwes": [
+                "CWE-706"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-30116",
+            "vendorProject": "Kaseya",
+            "product": "Virtual System\/Server Administrator (VSA)",
+            "vulnerabilityName": "Kaseya Virtual System\/Server Administrator (VSA) Information Disclosure Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Kaseya Virtual System\/Server Administrator (VSA) contains an information disclosure vulnerability allowing an attacker to obtain the sessionId that can be used to execute further attacks against the system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-30116",
+            "cwes": [
+                "CWE-522"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-7961",
+            "vendorProject": "Liferay",
+            "product": "Liferay Portal",
+            "vulnerabilityName": "Liferay Portal Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Liferay Portal contains a deserialization of untrusted data vulnerability that allows remote attackers to execute code via JSON web services.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-7961",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-23874",
+            "vendorProject": "McAfee",
+            "product": "McAfee Total Protection (MTP)",
+            "vulnerabilityName": "McAfee Total Protection (MTP) Improper Privilege Management Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "McAfee Total Protection (MTP) contains an improper privilege management vulnerability that allows a local user to gain elevated privileges and execute code, bypassing MTP self-defense.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-23874",
+            "cwes": [
+                "CWE-284"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22506",
+            "vendorProject": "Micro Focus",
+            "product": "Micro Focus Access Manager",
+            "vulnerabilityName": "Micro Focus Access Manager Information Leakage Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Micro Focus Access Manager contains an information leakage vulnerability resulting from a SAML service provider redirection issue when the Assertion Consumer Service URL is used.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22506",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-22502",
+            "vendorProject": "Micro Focus",
+            "product": "Operation Bridge Reporter (OBR)",
+            "vulnerabilityName": "Micro Focus Operation Bridge Report (OBR) Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Micro Focus Operation Bridge Report (OBR) contains an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22502",
+            "cwes": [
+                "CWE-20",
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2014-1812",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Group Policy Preferences Password Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Active Directory contains a privilege escalation vulnerability due to the way it distributes passwords that are configured using Group Policy preferences. An authenticated attacker who successfully exploits the vulnerability could decrypt the passwords and use them to elevate privileges on the domain.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2014-1812",
+            "cwes": [
+                "CWE-255"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-38647",
+            "vendorProject": "Microsoft",
+            "product": "Open Management Infrastructure (OMI)",
+            "vulnerabilityName": "Microsoft Open Management Infrastructure (OMI) Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Open Management Infrastructure (OMI) within Azure VM Management Extensions contains an unspecified vulnerability allowing remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-38647",
+            "cwes": [
+                "CWE-1390"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-0167",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Win32k contains an unspecified vulnerability that allows for privilege escalation via a crafted application",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-0167",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0878",
+            "vendorProject": "Microsoft",
+            "product": "Edge and Internet Explorer",
+            "vulnerabilityName": "Microsoft Edge and Internet Explorer Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Edge and Internet Explorer contain a memory corruption vulnerability that allows attackers to execute code in the context of the current user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0878",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-31955",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Information Disclosure Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Kernel contains an unspecified vulnerability that allows for information disclosure. Successful exploitation allows attackers to read the contents of kernel memory from a user-mode process.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-31955",
+            "cwes": [
+                "CWE-497"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1647",
+            "vendorProject": "Microsoft",
+            "product": "Defender",
+            "vulnerabilityName": "Microsoft Defender Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Defender contains an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1647",
+            "cwes": [
+                "CWE-122",
+                "CWE-1285"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-33739",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Desktop Window Manager (DWM) Core Library Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Desktop Window Manager (DWM) Core Library contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-33739",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2016-0185",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Media Center Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Media Center contains a remote code execution vulnerability when Windows Media Center opens a specially crafted Media Center link (.mcl) file that references malicious code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-0185",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0683",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Installer Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Installer contains a privilege escalation vulnerability when MSI packages process symbolic links, which allows attackers to bypass access restrictions to add or remove files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0683",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-17087",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows kernel contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-17087",
+            "cwes": [
+                "CWE-131"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-33742",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows MSHTML Platform Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows MSHTML Platform contains an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-33742",
+            "cwes": [
+                "CWE-787",
+                "CWE-823"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-31199",
+            "vendorProject": "Microsoft",
+            "product": "Enhanced Cryptographic Provider",
+            "vulnerabilityName": "Microsoft Enhanced Cryptographic Provider Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Enhanced Cryptographic Provider contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-31199",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-33771",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows kernel contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-33771",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-31956",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows NTFS Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows New Technology File System (NTFS) contains an unspecified vulnerability that allows attackers to escalate privileges via a specially crafted application.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-31956",
+            "cwes": [
+                "CWE-191",
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-31201",
+            "vendorProject": "Microsoft",
+            "product": "Enhanced Cryptographic Provider",
+            "vulnerabilityName": "Microsoft Enhanced Cryptographic Provider Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Enhanced Cryptographic Provider contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-31201",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-31979",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows kernel contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-31979",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0938",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Adobe Font Manager Library Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Adobe Font Manager Library contains an unspecified vulnerability when handling specially crafted multi-master fonts (Adobe Type 1 PostScript format) that allows for remote code execution for all systems except Windows 10. For systems running Windows 10, an attacker who successfully exploited the vulnerability could execute code in an AppContainer sandbox context with limited privileges and capabilities.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0938",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-17144",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Exchange Server improperly validates cmdlet arguments which allow an attacker to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-17144",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0986",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Kernel Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows kernel contains an unspecified vulnerability when handling objects in memory that allows attackers to escalate privileges and execute code in kernel mode.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0986",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-1020",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Adobe Font Manager Library Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Adobe Font Manager Library contains an unspecified vulnerability when handling specially crafted multi-master fonts (Adobe Type 1 PostScript format) that allows for remote code execution for all systems except Windows 10. For systems running Windows 10, an attacker who successfully exploited the vulnerability could execute code in an AppContainer sandbox context with limited privileges and capabilities.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-1020",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-38645",
+            "vendorProject": "Microsoft",
+            "product": "Open Management Infrastructure (OMI)",
+            "vulnerabilityName": "Microsoft Open Management Infrastructure (OMI) Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Open Management Infrastructure (OMI) within Azure VM Management Extensions contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-38645",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-34523",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Exchange Server contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-34523",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-7269",
+            "vendorProject": "Microsoft",
+            "product": "Internet Information Services (IIS)",
+            "vulnerabilityName": "Microsoft Windows Server Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Server 2003 R2 contains a buffer overflow vulnerability in Internet Information Services (IIS) 6.0 which allows remote attackers to execute code via a long header beginning with \"If: <http:\/\/\" in a PROPFIND request.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-7269",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-36948",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Update Medic Service Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Update Medic Service contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-36948",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-38649",
+            "vendorProject": "Microsoft",
+            "product": "Open Management Infrastructure (OMI)",
+            "vulnerabilityName": "Microsoft Open Management Infrastructure (OMI) Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Open Management Infrastructure (OMI) within Azure VM Management Extensions contains an unspecified vulnerability allowing privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-38649",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-0688",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Validation Key Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Exchange Server Validation Key fails to properly create unique keys at install time, allowing for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0688",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0143",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Server Message Block (SMBv1) Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Server Message Block 1.0 (SMBv1) contains an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0143",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-7255",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Win32k kernel-mode driver fails to properly handle objects in memory which allows for privilege escalation. Successful exploitation allows an attacker to run code in kernel mode.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-7255",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0708",
+            "vendorProject": "Microsoft",
+            "product": "Remote Desktop Services",
+            "vulnerabilityName": "Microsoft Remote Desktop Services Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Remote Desktop Services, formerly known as Terminal Service, contains an unspecified vulnerability that allows an unauthenticated attacker to connect to the target system using RDP and send specially crafted requests. Successful exploitation allows for remote code execution. The vulnerability is also known under the moniker of BlueKeep.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0708",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-34473",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Exchange Server contains an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-34473",
+            "cwes": [
+                "CWE-918"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-1464",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Spoofing Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows contains a spoofing vulnerability when Windows incorrectly validates file signatures, allowing an attacker to bypass security features and load improperly signed files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-1464",
+            "cwes": [
+                "CWE-347"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1732",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Win32k contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1732",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-34527",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Print Spooler Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Print Spooler contains an unspecified vulnerability due to the Windows Print Spooler service improperly performing privileged file operations. Successful exploitation allows an attacker to perform remote code execution with SYSTEM privileges. The vulnerability is also known under the moniker of PrintNightmare.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Reference CISA's ED 21-04 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-21-04-mitigate-windows-print-spooler-service-vulnerability) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 21-04. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-34527",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-31207",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Security Feature Bypass Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Exchange Server contains an unspecified vulnerability that allows for security feature bypass.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-31207",
+            "cwes": [
+                "CWE-20",
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0803",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Win32k contains an unspecified vulnerability due to it failing to properly handle objects in memory causing privilege escalation. Successful exploitation allows an attacker to run code in kernel mode.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0803",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-1040",
+            "vendorProject": "Microsoft",
+            "product": "Hyper-V RemoteFX",
+            "vulnerabilityName": "Microsoft Hyper-V RemoteFX vGPU Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Hyper-V RemoteFX vGPU contains an improper input validation vulnerability due to the host server failing to properly validate input from an authenticated user on a guest operating system. Successful exploitation allows for remote code execution on the host operating system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-1040",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-28310",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Win32k contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-28310",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-1350",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows DNS Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows DNS Servers fail to properly handle requests, allowing an attacker to perform remote code execution in the context of the Local System Account. The vulnerability is also known under the moniker of SIGRed.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Reference CISA's ED 20-03 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-20-03-mitigate-windows-dns-server-remote-code-execution-vulnerability-july-2020-patch-tuesday) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 20-03. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-1350",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-26411",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Internet Explorer contains an unspecified vulnerability that allows for memory corruption.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-26411",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0859",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Win32k fails to properly handle objects in memory causing privilege escalation. Successful exploitation allows an attacker to run code in kernel mode.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0859",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-40444",
+            "vendorProject": "Microsoft",
+            "product": "MSHTML",
+            "vulnerabilityName": "Microsoft MSHTML Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft MSHTML contains a unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-40444",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-8759",
+            "vendorProject": "Microsoft",
+            "product": ".NET Framework",
+            "vulnerabilityName": "Microsoft .NET Framework Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft .NET Framework contains a remote code execution vulnerability when processing untrusted input that could allow an attacker to take control of an affected system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-8759",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-8653",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Scripting Engine Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Internet Explorer contains a memory corruption vulnerability due to how the Scripting Engine handles objects in memory, leading to remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-8653",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0797",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Win32k contains a privilege escalation vulnerability when the Win32k component fails to properly handle objects in memory. Successful exploitation allows an attacker to execute code in kernel mode.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0797",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-36942",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Local Security Authority (LSA) Spoofing Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Local Security Authority (LSA) contains a spoofing vulnerability allowing an unauthenticated attacker to call a method on the LSARPC interface and coerce the domain controller to authenticate against another server using NTLM.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-36942",
+            "cwes": [
+                "CWE-749"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1215",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows contains an unspecified vulnerability due to the way ws2ifsl.sys (Winsock) handles objects in memory, allowing for privilege escalation. Successful exploitation allows an attacker to execute code with elevated privileges.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1215",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2018-0798",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Office contains a memory corruption vulnerability due to the way objects are handled in memory. Successful exploitation allows for remote code execution in the context of the current user. This vulnerability is known to be chained with CVE-2018-0802.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0798",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-0802",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Office contains a memory corruption vulnerability due to the way objects are handled in memory. Successful exploitation allows for remote code execution in the context of the current user. This vulnerability is known to be chained with CVE-2018-0798.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-0802",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-0158",
+            "vendorProject": "Microsoft",
+            "product": "MSCOMCTL.OCX",
+            "vulnerabilityName": "Microsoft MSCOMCTL.OCX Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft MSCOMCTL.OCX contains an unspecified vulnerability that allows for remote code execution, allowing an attacker to take complete control of an affected system under the context of the current user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-0158",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-1641",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Office contains a memory corruption vulnerability due to failure to properly handle rich text format files in memory. Successful exploitation allows for remote code execution in the context of the current user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-1641",
+            "cwes": [
+                "CWE-399"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27085",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Internet Explorer contains an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27085",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-0541",
+            "vendorProject": "Microsoft",
+            "product": "MSHTML",
+            "vulnerabilityName": "Microsoft MSHTML Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft MSHTML engine contains an improper input validation vulnerability that allows for remote code execution vulnerability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0541",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-11882",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Office contains a memory corruption vulnerability that allows remote code execution in the context of the current user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-11882",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0674",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Scripting Engine Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Internet Explorer contains a memory corruption vulnerability due to the way the Scripting Engine handles objects in memory. Successful exploitation could allow remote code execution in the context of the current user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0674",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27059",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Office contains an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27059",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-1367",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Scripting Engine Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Internet Explorer contains a memory corruption vulnerability in how the scripting engine handles objects in memory. Successful exploitation allows for remote code execution in the context of the current user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1367",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-0199",
+            "vendorProject": "Microsoft",
+            "product": "Office and WordPad",
+            "vulnerabilityName": "Microsoft Office and WordPad Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Office and WordPad contain an unspecified vulnerability due to the way the applications parse specially crafted files. Successful exploitation allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-0199",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-1380",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Scripting Engine Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Internet Explorer contains a memory corruption vulnerability which can allow for remote code execution in the context of the current user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-1380",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-1429",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Scripting Engine Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Internet Explorer contains a memory corruption vulnerability which can allow for remote code execution in the context of the current user.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1429",
+            "cwes": [
+                "CWE-416",
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-11774",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office Outlook Security Feature Bypass Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Office Outlook contains a security feature bypass vulnerability due to improperly handling objects in memory. Successful exploitation allows an attacker to execute commands.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-11774",
+            "cwes": [
+                "CWE-119"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0968",
+            "vendorProject": "Microsoft",
+            "product": "Internet Explorer",
+            "vulnerabilityName": "Microsoft Internet Explorer Scripting Engine Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Internet Explorer contains a memory corruption vulnerability due to how the Scripting Engine handles objects in memory, leading to remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0968",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-1472",
+            "vendorProject": "Microsoft",
+            "product": "Netlogon",
+            "vulnerabilityName": "Microsoft Netlogon Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft's Netlogon Remote Protocol (MS-NRPC) contains a privilege escalation vulnerability when an attacker establishes a vulnerable Netlogon secure channel connection to a domain controller. An attacker who successfully exploits the vulnerability could run a specially crafted application on a device on the network. The vulnerability is also known under the moniker of Zerologon.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Reference CISA's ED 20-04 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-20-04-mitigate-netlogon-elevation-privilege-vulnerability-august-2020-patch-tuesday) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 20-04. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-1472",
+            "cwes": [
+                "CWE-330"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-26855",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Exchange Server contains an unspecified vulnerability that allows for remote code execution. This vulnerability is part of the ProxyLogon exploit chain.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Reference CISA's ED 21-02 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-21-02-mitigate-microsoft-exchange-premises-product-vulnerabilities) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 21-02. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-26855",
+            "cwes": [
+                "CWE-918"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-26858",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Exchange Server contains an unspecified vulnerability that allows for remote code execution. This vulnerability is part of the ProxyLogon exploit chain.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Reference CISA's ED 21-02 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-21-02-mitigate-microsoft-exchange-premises-product-vulnerabilities) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 21-02. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-26858",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-27065",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Exchange Server contains an unspecified vulnerability that allows for remote code execution. This vulnerability is part of the ProxyLogon exploit chain.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Reference CISA's ED 21-02 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-21-02-mitigate-microsoft-exchange-premises-product-vulnerabilities) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 21-02. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27065",
+            "cwes": [
+                "CWE-39"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-1054",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Win32k contains a privilege escalation vulnerability when the Windows kernel-mode driver fails to properly handle objects in memory. Successful exploitation allows an attacker to execute code in kernel mode.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-1054",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1675",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Print Spooler Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Print Spooler contains an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1675",
+            "cwes": [
+                "CWE-285"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-34448",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Scripting Engine Memory Corruption Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Scripting Engine contains an unspecified vulnerability that allows for memory corruption.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-34448",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0601",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows CryptoAPI Spoofing Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows CryptoAPI (Crypt32.dll) contains a spoofing vulnerability in the way it validates Elliptic Curve Cryptography (ECC) certificates. An attacker could exploit the vulnerability by using a spoofed code-signing certificate to sign a malicious executable, making it appear the file was from a trusted, legitimate source. A successful exploit could also allow the attacker to conduct man-in-the-middle attacks and decrypt confidential information on user connections to the affected software. The vulnerability is also known under the moniker of CurveBall.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Reference CISA's ED 20-02 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-20-02-mitigate-windows-vulnerabilities-january-2020-patch-tuesday) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 20-02. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0601",
+            "cwes": [
+                "CWE-295"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0604",
+            "vendorProject": "Microsoft",
+            "product": "SharePoint",
+            "vulnerabilityName": "Microsoft SharePoint Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft SharePoint fails to check the source markup of an application package. An attacker who successfully exploits the vulnerability could run remote code in the context of the SharePoint application pool and the SharePoint server farm account.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0604",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-0646",
+            "vendorProject": "Microsoft",
+            "product": ".NET Framework",
+            "vulnerabilityName": "Microsoft .NET Framework Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft .NET Framework contains an improper input validation vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-0646",
+            "cwes": [
+                "CWE-91"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0808",
+            "vendorProject": "Microsoft",
+            "product": "Win32k",
+            "vulnerabilityName": "Microsoft Win32k Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Win32k contains a privilege escalation vulnerability due to the component failing to properly handle objects in memory. Successful exploitation allows an attacker to run code in kernel mode.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0808",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-26857",
+            "vendorProject": "Microsoft",
+            "product": "Exchange Server",
+            "vulnerabilityName": "Microsoft Exchange Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Exchange Server contains an unspecified vulnerability that allows for remote code execution. This vulnerability is part of the ProxyLogon exploit chain.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Reference CISA's ED 21-02 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-21-02-mitigate-microsoft-exchange-premises-product-vulnerabilities) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 21-02. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-26857",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-1147",
+            "vendorProject": "Microsoft",
+            "product": ".NET Framework, SharePoint, Visual Studio",
+            "vulnerabilityName": "Microsoft .NET Framework, SharePoint, and Visual Studio Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft .NET Framework, Microsoft SharePoint, and Visual Studio contain a remote code execution vulnerability when the software fails to check the source markup of XML file input. Successful exploitation allows an attacker to execute code in the context of the process responsible for deserialization of the XML content.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-1147",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-1214",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Privilege Common Log File System (CLFS) Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Common Log File System (CLFS) driver improperly handles objects in memory which can allow for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-1214",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2016-3235",
+            "vendorProject": "Microsoft",
+            "product": "Office",
+            "vulnerabilityName": "Microsoft Office OLE DLL Side Loading Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Office Object Linking & Embedding (OLE) dynamic link library (DLL) contains a side loading vulnerability due to it improperly validating input before loading libraries. Successful exploitation allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-3235",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-0863",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Error Reporting (WER) Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Error Reporting (WER) contains a privilege escalation vulnerability due to the way it handles files, allowing for code execution in kernel mode.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-0863",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-36955",
+            "vendorProject": "Microsoft",
+            "product": "Windows",
+            "vulnerabilityName": "Microsoft Windows Common Log File System (CLFS) Driver Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Windows Common Log File System (CLFS) driver contains an unspecified vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-36955",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-38648",
+            "vendorProject": "Microsoft",
+            "product": "Open Management Infrastructure (OMI)",
+            "vulnerabilityName": "Microsoft Open Management Infrastructure (OMI) Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Microsoft Open Management Infrastructure (OMI) within Azure VM Management Extensions contains an unspecified vulnerability allowing privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-38648",
+            "cwes": [
+                "CWE-1390"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-6819",
+            "vendorProject": "Mozilla",
+            "product": "Firefox and Thunderbird",
+            "vulnerabilityName": "Mozilla Firefox And Thunderbird Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Mozilla Firefox and Thunderbird contain a race condition vulnerability when running the nsDocShell destructor under certain conditions. The race condition creates a use-after-free vulnerability, causing unspecified impacts.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-6819",
+            "cwes": [
+                "CWE-362",
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-6820",
+            "vendorProject": "Mozilla",
+            "product": "Firefox and Thunderbird",
+            "vulnerabilityName": "Mozilla Firefox And Thunderbird Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Mozilla Firefox and Thunderbird contain a race condition vulnerability when handling a ReadableStream under certain conditions. The race condition creates a use-after-free vulnerability, causing unspecified impacts.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-6820",
+            "cwes": [
+                "CWE-362"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-17026",
+            "vendorProject": "Mozilla",
+            "product": "Firefox and Thunderbird",
+            "vulnerabilityName": "Mozilla Firefox And Thunderbird Type Confusion Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Mozilla Firefox and Thunderbird contain a type confusion vulnerability due to incorrect alias information in the IonMonkey JIT compiler when setting array elements.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-17026",
+            "cwes": [
+                "CWE-843"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-15949",
+            "vendorProject": "Nagios",
+            "product": "Nagios XI",
+            "vulnerabilityName": "Nagios XI Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Nagios XI contains a remote code execution vulnerability in which a user can modify the check_plugin executable and insert malicious commands to execute as root.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-15949",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-26919",
+            "vendorProject": "NETGEAR",
+            "product": "JGS516PE Devices",
+            "vulnerabilityName": "Netgear JGS516PE Devices Missing Function Level Access Control Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Netgear JGS516PE devices contain a missing function level access control vulnerability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-26919",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-19356",
+            "vendorProject": "Netis",
+            "product": "WF2419 Devices",
+            "vulnerabilityName": "Netis WF2419 Devices Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Netis WF2419 devices contains an unspecified vulnerability that allows an attacker to perform remote code execution as root through the router's web management page.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-19356",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-2555",
+            "vendorProject": "Oracle",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Oracle Multiple Products Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Multiple Oracle products contain a remote code execution vulnerability that allows an unauthenticated attacker with network access via T3 or HTTP to takeover the affected system. Impacted Oracle products: Oracle Coherence in Fusion Middleware, Oracle Utilities Framework, Oracle Retail Assortment Planning, Oracle Commerce, Oracle Communications Diameter Signaling Router (DSR).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-2555",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2012-3152",
+            "vendorProject": "Oracle",
+            "product": "Fusion Middleware",
+            "vulnerabilityName": "Oracle Fusion Middleware Unspecified Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Oracle Fusion Middleware Reports Developer contains an unspecified vulnerability that allows remote attackers to affect confidentiality and integrity of affected systems.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2012-3152",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-14871",
+            "vendorProject": "Oracle",
+            "product": "Solaris and Zettabyte File System (ZFS)",
+            "vulnerabilityName": "Oracle Solaris and Zettabyte File System (ZFS) Unspecified Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Oracle Solaris and Oracle ZFS Storage Appliance Kit contain an unspecified vulnerability causing high impacts to confidentiality, integrity, and availability of affected systems.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-14871",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2015-4852",
+            "vendorProject": "Oracle",
+            "product": "WebLogic Server",
+            "vulnerabilityName": "Oracle WebLogic Server Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Oracle WebLogic Server contains a deserialization of untrusted data vulnerability within Apache Commons, which can allow for for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2015-4852",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-14750",
+            "vendorProject": "Oracle",
+            "product": "WebLogic Server",
+            "vulnerabilityName": "Oracle WebLogic Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Oracle WebLogic Server contains an unspecified vulnerability allowing an unauthenticated attacker to perform remote code execution. This vulnerability is related to CVE-2020-14882.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-14750",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-14882",
+            "vendorProject": "Oracle",
+            "product": "WebLogic Server",
+            "vulnerabilityName": "Oracle WebLogic Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Oracle WebLogic Server contains an unspecified vulnerability, which is assessed to allow for remote code execution, based on this vulnerability being related to CVE-2020-14750.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-14882",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-14883",
+            "vendorProject": "Oracle",
+            "product": "WebLogic Server",
+            "vulnerabilityName": "Oracle WebLogic Server Unspecified Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Oracle WebLogic Server contains an unspecified vulnerability in the Console component with high impacts to confidentilaity, integrity, and availability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-14883",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-8644",
+            "vendorProject": "PlaySMS",
+            "product": "PlaySMS",
+            "vulnerabilityName": "PlaySMS Server-Side Template Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "PlaySMS contains a server-side template injection vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8644",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-18935",
+            "vendorProject": "Progress",
+            "product": "Telerik UI for ASP.NET AJAX",
+            "vulnerabilityName": "Progress Telerik UI for ASP.NET AJAX Deserialization of Untrusted Data Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Progress Telerik UI for ASP.NET AJAX contains a deserialization of untrusted data vulnerability through RadAsyncUpload which leads to code execution on the server in the context of the w3wp.exe process.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-18935",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22893",
+            "vendorProject": "Ivanti",
+            "product": "Pulse Connect Secure",
+            "vulnerabilityName": "Ivanti Pulse Connect Secure Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Ivanti Pulse Connect Secure contains a use-after-free vulnerability that allow a remote, unauthenticated attacker to execute code via license services.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Reference CISA's ED 21-03 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-21-03-mitigate-pulse-connect-secure-product-vulnerabilities) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 21-03. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22893",
+            "cwes": [
+                "CWE-287"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-8243",
+            "vendorProject": "Ivanti",
+            "product": "Pulse Connect Secure",
+            "vulnerabilityName": "Ivanti Pulse Connect Secure Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Ivanti Pulse Connect Secure contains an unspecified vulnerability in the admin web interface that could allow an authenticated attacker to upload a custom template to perform code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Reference CISA's ED 21-03 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-21-03-mitigate-pulse-connect-secure-product-vulnerabilities) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 21-03. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8243",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22900",
+            "vendorProject": "Ivanti",
+            "product": "Pulse Connect Secure",
+            "vulnerabilityName": "Ivanti Pulse Connect Secure Unrestricted File Upload Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Ivanti Pulse Connect Secure contains an unrestricted file upload vulnerability that allows an authenticated administrator to perform a file write via a maliciously crafted archive upload in the administrator web interface.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Reference CISA's ED 21-03 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-21-03-mitigate-pulse-connect-secure-product-vulnerabilities) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 21-03. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22900",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22894",
+            "vendorProject": "Ivanti",
+            "product": "Pulse Connect Secure",
+            "vulnerabilityName": "Ivanti Pulse Connect Secure Collaboration Suite Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Ivanti Pulse Connect Secure Collaboration Suite contains a buffer overflow vulnerabilities that allows a remote authenticated users to execute code as the root user via maliciously crafted meeting room.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Reference CISA's ED 21-03 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-21-03-mitigate-pulse-connect-secure-product-vulnerabilities) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 21-03. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22894",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-8260",
+            "vendorProject": "Ivanti",
+            "product": "Pulse Connect Secure",
+            "vulnerabilityName": "Ivanti Pulse Connect Secure Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Pulse Connect Secure contains an unspecified vulnerability that allows an authenticated attacker to perform code execution using uncontrolled gzip extraction.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Reference CISA's ED 21-03 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-21-03-mitigate-pulse-connect-secure-product-vulnerabilities) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 21-03. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8260",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22899",
+            "vendorProject": "Ivanti",
+            "product": "Pulse Connect Secure",
+            "vulnerabilityName": "Ivanti Pulse Connect Secure Command Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Ivanti Pulse Connect Secure contains a command injection vulnerability that allows remote authenticated users to perform remote code execution via Windows File Resource Profiles.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "Reference CISA's ED 21-03 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-21-03-mitigate-pulse-connect-secure-product-vulnerabilities) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 21-03. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22899",
+            "cwes": [
+                "CWE-77"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-11510",
+            "vendorProject": "Ivanti",
+            "product": "Pulse Connect Secure",
+            "vulnerabilityName": "Ivanti Pulse Connect Secure Arbitrary File Read Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Ivanti Pulse Connect Secure contains an arbitrary file read vulnerability that allows an unauthenticated remote attacker with network access via HTTPS to send a specially crafted URI.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "Reference CISA's ED 21-03 (https:\/\/www.cisa.gov\/news-events\/directives\/ed-21-03-mitigate-pulse-connect-secure-product-vulnerabilities) for further guidance and requirements. Note: The due date for addressing this vulnerability aligns with the requirements outlined in ED 21-03. https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-11510",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-11539",
+            "vendorProject": "Ivanti",
+            "product": "Pulse Connect Secure and Pulse Policy Secure",
+            "vulnerabilityName": "Ivanti Pulse Connect Secure and Policy Secure Command Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Ivanti Pulse Connect Secure and Policy Secure allows an authenticated attacker from the admin web interface to inject and execute commands.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-11539",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1906",
+            "vendorProject": "Qualcomm",
+            "product": "Multiple Chipsets",
+            "vulnerabilityName": "Qualcomm Multiple Chipsets Detection of Error Condition Without Action Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Multiple Qualcomm chipsets contain a detection of error condition without action vulnerability when improper handling of address deregistration on failure can lead to new GPU address allocation failure.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1906",
+            "cwes": [
+                "CWE-390"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-1905",
+            "vendorProject": "Qualcomm",
+            "product": "Multiple Chipsets",
+            "vulnerabilityName": "Qualcomm Multiple Chipsets Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Multiple Qualcomm Chipsets contain a use after free vulnerability due to improper handling of memory mapping of multiple processes simultaneously.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-1905",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-10221",
+            "vendorProject": "rConfig",
+            "product": "rConfig",
+            "vulnerabilityName": "rConfig OS Command Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "rConfig lib\/ajaxHandlers\/ajaxAddTemplate.php contains an OS command injection vulnerability that allows remote attackers to execute OS commands via shell metacharacters in the fileName POST parameter.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-10221",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-35395",
+            "vendorProject": "Realtek",
+            "product": "AP-Router SDK",
+            "vulnerabilityName": "Realtek AP-Router SDK Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Realtek AP-Router SDK HTTP web server boa contains a buffer overflow vulnerability due to unsafe copies of some overly long parameters submitted in the form that lead to denial-of-service (DoS).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-35395",
+            "cwes": [
+                "CWE-20",
+                "CWE-122"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-16651",
+            "vendorProject": "Roundcube",
+            "product": "Roundcube Webmail",
+            "vulnerabilityName": "Roundcube Webmail File Disclosure Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Roundcube Webmail contains a file disclosure vulnerability caused by insufficient input validation in conjunction with file-based attachment plugins, which are used by default.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-16651",
+            "cwes": [
+                "CWE-552"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-11652",
+            "vendorProject": "SaltStack",
+            "product": "Salt",
+            "vulnerabilityName": "SaltStack Salt Path Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SaltStack Salt contains a path traversal vulnerability in the salt-master process ClearFuncs which allows directory access to authenticated users. Salt users who follow fundamental internet security guidelines and best practices are not affected by this vulnerability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-11652",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-11651",
+            "vendorProject": "SaltStack",
+            "product": "Salt",
+            "vulnerabilityName": "SaltStack Salt Authentication Bypass Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SaltStack Salt contains an authentication bypass vulnerability in the salt-master process ClearFuncs due to improperly validating method calls. The vulnerability allows a remote user to access some methods without authentication, which can be used to retrieve user tokens from the salt master and\/or run commands on salt minions. Salt users who follow fundamental internet security guidelines and best practices are not affected by this vulnerability.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-11651",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-16846",
+            "vendorProject": "SaltStack",
+            "product": "Salt",
+            "vulnerabilityName": "SaltStack Salt Shell Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SaltStack Salt allows an unauthenticated user with network access to the Salt API to use shell injections to run code on the Salt API using the SSH client. This vulnerability affects any users running the Salt API.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-16846",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-2380",
+            "vendorProject": "SAP",
+            "product": "Customer Relationship Management (CRM)",
+            "vulnerabilityName": "SAP Customer Relationship Management (CRM) Path Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SAP Customer Relationship Management (CRM) contains a path traversal vulnerability that allows an attacker to exploit insufficient validation of path information provided by users.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-2380",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2010-5326",
+            "vendorProject": "SAP",
+            "product": "NetWeaver",
+            "vulnerabilityName": "SAP NetWeaver Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SAP NetWeaver Application Server Java Platforms Invoker Servlet does not require authentication, allowing for remote code execution via a HTTP or HTTPS request.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2010-5326",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2016-9563",
+            "vendorProject": "SAP",
+            "product": "NetWeaver",
+            "vulnerabilityName": "SAP NetWeaver XML External Entity (XXE) Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SAP NetWeaver Application Server Java Platforms contains an unspecified vulnerability in BC-BMT-BPM-DSK which allows remote, authenticated users to conduct XML External Entity (XXE) attacks.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-9563",
+            "cwes": [
+                "CWE-611"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-6287",
+            "vendorProject": "SAP",
+            "product": "NetWeaver",
+            "vulnerabilityName": "SAP NetWeaver Missing Authentication for Critical Function Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SAP NetWeaver Application Server Java Platforms contains a missing authentication for critical function vulnerability allowing unauthenticated access to execute configuration tasks and create administrative users.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-6287",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-6207",
+            "vendorProject": "SAP",
+            "product": "Solution Manager",
+            "vulnerabilityName": "SAP Solution Manager Missing Authentication for Critical Function Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SAP Solution Manager User Experience Monitoring contains a missing authentication for critical function vulnerability which results in complete compromise of all SMDAgents connected to the Solution Manager.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-6207",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-3976",
+            "vendorProject": "SAP",
+            "product": "NetWeaver",
+            "vulnerabilityName": "SAP NetWeaver Directory Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SAP NetWeaver Application Server Java Platforms contains a directory traversal vulnerability via a ..\\ (dot dot backslash) in the fileName parameter to CrashFileDownloadServlet. This allows remote attackers to read files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-3976",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-16256",
+            "vendorProject": "SIMalliance",
+            "product": "Toolbox Browser",
+            "vulnerabilityName": "SIMalliance Toolbox Browser Command Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SIMalliance Toolbox Browser contains an command injection vulnerability that could allow remote attackers to retrieve location and IMEI information or execute a range of other attacks by modifying the attack message.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-16256",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-10148",
+            "vendorProject": "SolarWinds",
+            "product": "Orion",
+            "vulnerabilityName": "SolarWinds Orion Authentication Bypass Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SolarWinds Orion API contains an authentication bypass vulnerability that could allow a remote attacker to execute API commands.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-10148",
+            "cwes": [
+                "CWE-288"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-35211",
+            "vendorProject": "SolarWinds",
+            "product": "Serv-U",
+            "vulnerabilityName": "SolarWinds Serv-U Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SolarWinds Serv-U contains an unspecified memory escape vulnerability which can allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-35211",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2016-3643",
+            "vendorProject": "SolarWinds",
+            "product": "Virtualization Manager",
+            "vulnerabilityName": "SolarWinds Virtualization Manager Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SolarWinds Virtualization Manager allows for privilege escalation through leveraging a misconfiguration of sudo.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2016-3643",
+            "cwes": [
+                "CWE-264"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-10199",
+            "vendorProject": "Sonatype",
+            "product": "Nexus Repository",
+            "vulnerabilityName": "Sonatype Nexus Repository Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Sonatype Nexus Repository contains an unspecified vulnerability that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-10199",
+            "cwes": [
+                "CWE-917"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-20021",
+            "vendorProject": "SonicWall",
+            "product": "SonicWall Email Security",
+            "vulnerabilityName": "SonicWall Email Security Improper Privilege Management Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SonicWall Email Security contains an improper privilege management vulnerability that allows an attacker to create an administrative account by sending a crafted HTTP request to the remote host. This vulnerability has known usage in a SonicWall Email Security exploit chain along with CVE-2021-20022 and CVE-2021-20023 to achieve privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-20021",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-7481",
+            "vendorProject": "SonicWall",
+            "product": "SMA100",
+            "vulnerabilityName": "SonicWall SMA100 SQL Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SonicWall SMA100 contains a SQL injection vulnerability allowing an unauthenticated user to gain read-only access to unauthorized resources.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-7481",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-20022",
+            "vendorProject": "SonicWall",
+            "product": "SonicWall Email Security",
+            "vulnerabilityName": "SonicWall Email Security Unrestricted Upload of File Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SonicWall Email Security contains an unrestricted upload of file with dangerous type vulnerability that allows a post-authenticated attacker to upload a file to the remote host. This vulnerability has known usage in a SonicWall Email Security exploit chain along with CVE-2021-20021 and CVE-2021-20023 to achieve privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-20022",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-20023",
+            "vendorProject": "SonicWall",
+            "product": "SonicWall Email Security",
+            "vulnerabilityName": "SonicWall Email Security Path Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SonicWall Email Security contains a path traversal vulnerability that allows a post-authenticated attacker to read files on the remote host. This vulnerability has known usage in a SonicWall Email Security exploit chain along with CVE-2021-20021 and CVE-2021-20022 to achieve privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-20023",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-20016",
+            "vendorProject": "SonicWall",
+            "product": "SSLVPN SMA100",
+            "vulnerabilityName": "SonicWall SSLVPN SMA100 SQL Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "SonicWall SSLVPN SMA100 contains a SQL injection vulnerability that allows remote exploitation for credential access by an unauthenticated attacker.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-20016",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-12271",
+            "vendorProject": "Sophos",
+            "product": "SFOS",
+            "vulnerabilityName": "Sophos SFOS SQL Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Sophos Firewall operating system (SFOS) firmware contains a SQL injection vulnerability when configured with either the administration (HTTPS) service or the User Portal is exposed on the WAN zone. Successful exploitation may cause remote code execution to exfiltrate usernames and hashed passwords for the local device admin(s), portal admins, and user accounts used for remote access (but not external Active Directory or LDAP passwords).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-12271",
+            "cwes": [
+                "CWE-89"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-10181",
+            "vendorProject": "Sumavision",
+            "product": "Enhanced Multimedia Router (EMR)",
+            "vulnerabilityName": "Sumavision EMR Cross-Site Request Forgery (CSRF) Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Sumavision Enhanced Multimedia Router (EMR) contains a cross-site request forgery (CSRF) vulnerability allowing the creation of users with elevated privileges as administrator on a device.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-10181",
+            "cwes": [
+                "CWE-352"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-6327",
+            "vendorProject": "Symantec",
+            "product": "Symantec Messaging Gateway",
+            "vulnerabilityName": "Symantec Messaging Gateway Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Symantec Messaging Gateway contains an unspecified vulnerability which can allow for remote code execution. With the ability to perform remote code execution, an attacker may also desire to perform privilege escalating actions.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-6327",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-18988",
+            "vendorProject": "TeamViewer",
+            "product": "Desktop",
+            "vulnerabilityName": "TeamViewer Desktop Bypass Remote Login Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "TeamViewer Desktop allows for bypass of remote-login access control because the same AES key is used for different customers' installations. If an attacker were to know this key, they could decrypt protected information stored in registry or configuration files or decryption of the Unattended Access password to the system (which allows for remote login to the system).",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-18988",
+            "cwes": [
+                "CWE-521"
+            ]
+        },
+        {
+            "cveID": "CVE-2017-9248",
+            "vendorProject": "Progress",
+            "product": "ASP.NET AJAX and Sitefinity",
+            "vulnerabilityName": "Progress Telerik UI for ASP.NET AJAX and Sitefinity Cryptographic Weakness Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Progress Telerik UI for ASP.NET AJAX and Sitefinity have a cryptographic weakness in Telerik.Web.UI.dll that can be exploited to disclose encryption keys (Telerik.Web.UI.DialogParametersEncryptionKey and\/or the MachineKey), perform cross-site-scripting (XSS) attacks, compromise the ASP.NET ViewState, and\/or upload and download files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2017-9248",
+            "cwes": [
+                "CWE-522"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-31755",
+            "vendorProject": "Tenda",
+            "product": "AC11 Router",
+            "vulnerabilityName": "Tenda AC11 Router Stack Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Tenda AC11 devices contain a stack buffer overflow vulnerability in \/goform\/setmac which allows attackers to execute code via a crafted post request.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-31755",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-10987",
+            "vendorProject": "Tenda",
+            "product": "AC1900 Router AC15 Model",
+            "vulnerabilityName": "Tenda AC1900 Router AC15 Model Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Tenda AC1900 Router AC15 Model contains an unspecified vulnerability that allows remote attackers to execute system commands via the deviceName POST parameter.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-10987",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-14558",
+            "vendorProject": "Tenda",
+            "product": "AC7, AC9, and AC10 Routers",
+            "vulnerabilityName": "Tenda AC7, AC9, and AC10 Routers Command Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Tenda AC7, AC9, and AC10 devices contain a command injection vulnerability due to  the \"formsetUsbUnload\" function executes a dosystemCmd function with untrusted input. Successful exploitation allows an attacker to execute OS commands via a crafted goform\/setUsbUnload request.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-14558",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2018-20062",
+            "vendorProject": "ThinkPHP",
+            "product": "noneCms",
+            "vulnerabilityName": "ThinkPHP \"noneCms\" Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "ThinkPHP \"noneCms\" contains an unspecified vulnerability that allows for remote code execution through crafted use of the filter parameter.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2018-20062",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-9082",
+            "vendorProject": "ThinkPHP",
+            "product": "ThinkPHP",
+            "vulnerabilityName": "ThinkPHP Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "ThinkPHP contains an unspecified vulnerability that allows for remote code execution via public\/\/?s=index\/\\think\\app\/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]= followed by the command.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-9082",
+            "cwes": [
+                "CWE-306",
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-18187",
+            "vendorProject": "Trend Micro",
+            "product": "OfficeScan",
+            "vulnerabilityName": "Trend Micro OfficeScan Directory Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Trend Micro OfficeScan contains a directory traversal vulnerability by extracting files from a zip file to a specific folder on the OfficeScan server, leading to remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-18187",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-8467",
+            "vendorProject": "Trend Micro",
+            "product": "Apex One and OfficeScan",
+            "vulnerabilityName": "Trend Micro Apex One and OfficeScan Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Trend Micro Apex One and OfficeScan contain an unspecified vulnerability within a migration tool component that allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8467",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-8468",
+            "vendorProject": "Trend Micro",
+            "product": "Apex One, OfficeScan and Worry-Free Business Security Agents",
+            "vulnerabilityName": "Trend Micro Multiple Products Content Validation Escape Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Trend Micro Apex One, OfficeScan, and Worry-Free Business Security agents contain a content validation escape vulnerability that could allow an attacker to manipulate certain agent client components.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8468",
+            "cwes": [
+                "CWE-74"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-24557",
+            "vendorProject": "Trend Micro",
+            "product": "Apex One, OfficeScan, and Worry-Free Business Security",
+            "vulnerabilityName": "Trend Micro Multiple Products Improper Access Control Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Trend Micro Apex One, OfficeScan, and Worry-Free Business Security on Microsoft Windows contain an improper access control vulnerability that may allow an attacker to manipulate a particular product folder to disable the security temporarily, abuse a specific Windows function, and attain privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-24557",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2020-8599",
+            "vendorProject": "Trend Micro",
+            "product": "Apex One and OfficeScan",
+            "vulnerabilityName": "Trend Micro Apex One and OfficeScan Authentication Bypass Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Trend Micro Apex One and OfficeScan server contain a vulnerable EXE file that could allow a remote attacker to write data to a path on affected installations and bypass root login.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-8599",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2021-36742",
+            "vendorProject": "Trend Micro",
+            "product": "Apex One, Apex One as a Service, and Worry-Free Business Security",
+            "vulnerabilityName": "Trend Micro Multiple Products Improper Input Validation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Trend Micro Apex One, Apex One as a Service, and Worry-Free Business Security contain an improper input validation vulnerability that allows for privilege escalation.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/success.trendmicro.com\/dcx\/s\/solution\/000287819?language=en_US, https:\/\/success.trendmicro.com\/dcx\/s\/solution\/000287820?language=en_US; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-36742",
+            "cwes": [
+                "CWE-20"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-36741",
+            "vendorProject": "Trend Micro",
+            "product": "Apex One, Apex One as a Service, and Worry-Free Business Security",
+            "vulnerabilityName": "Trend Micro Multiple Products Improper Input Validation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Trend Micro Apex One, Apex One as a Service, and Worry-Free Business Security contain an improper input validation vulnerability that allows a remote attacker to upload files.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/success.trendmicro.com\/dcx\/s\/solution\/000287819?language=en_US, https:\/\/success.trendmicro.com\/dcx\/s\/solution\/000287820?language=en_US; https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-36741",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-20085",
+            "vendorProject": "TVT",
+            "product": "NVMS-1000",
+            "vulnerabilityName": "TVT NVMS-1000 Directory Traversal Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "TVT devices utilizing NVMS-1000 software contain a directory traversal vulnerability via GET \/.. requests.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-20085",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-5849",
+            "vendorProject": "Unraid",
+            "product": "Unraid",
+            "vulnerabilityName": "Unraid Authentication Bypass Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Unraid contains an authentication bypass vulnerability that allows attackers to gain access to the administrative interface. This CVE is chainable with CVE-2020-5847 for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-5849",
+            "cwes": [
+                "CWE-287",
+                "CWE-697"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-5847",
+            "vendorProject": "Unraid",
+            "product": "Unraid",
+            "vulnerabilityName": "Unraid Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Unraid contains a vulnerability due to the insecure use of the extract PHP function that can be abused to execute remote code as root. This CVE is chainable with CVE-2020-5849 for initial access.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-5847",
+            "cwes": []
+        },
+        {
+            "cveID": "CVE-2019-16759",
+            "vendorProject": "vBulletin",
+            "product": "vBulletin",
+            "vulnerabilityName": "vBulletin PHP Module Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "The PHP module within vBulletin contains an unspecified vulnerability that allows for remote code execution via the widgetConfig[code] parameter in an ajax\/render\/widget_php routestring request.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-16759",
+            "cwes": [
+                "CWE-94"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-17496",
+            "vendorProject": "vBulletin",
+            "product": "vBulletin",
+            "vulnerabilityName": "vBulletin PHP Module Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "The PHP module within vBulletin contains an unspecified vulnerability that allows for remote code execution via crafted subWidgets data in an ajax\/render\/widget_tabbedcontainer_tab_panel request. This CVE ID resolves an incomplete patch for CVE-2019-16759.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-17496",
+            "cwes": [
+                "CWE-74"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-5544",
+            "vendorProject": "VMware",
+            "product": "VMware ESXi and Horizon DaaS",
+            "vulnerabilityName": "VMware ESXi and Horizon DaaS OpenSLP Heap-Based Buffer Overflow Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "VMware ESXi and Horizon Desktop as a Service (DaaS) OpenSLP contains a heap-based buffer overflow vulnerability that allows an attacker with network access to port 427 to overwrite the heap of the OpenSLP service to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-5544",
+            "cwes": [
+                "CWE-787"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3992",
+            "vendorProject": "VMware",
+            "product": "ESXi",
+            "vulnerabilityName": "VMware ESXi OpenSLP Use-After-Free Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "VMware ESXi OpenSLP contains a use-after-free vulnerability that allows an attacker residing in the management network with access to port 427 to perform remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3992",
+            "cwes": [
+                "CWE-416"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3950",
+            "vendorProject": "VMware",
+            "product": "Multiple Products",
+            "vulnerabilityName": "VMware Multiple Products Privilege Escalation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "VMware Fusion, Remote Console (VMRC) for Mac, and Horizon Client for Mac contain a privilege escalation vulnerability due to improper use of setuid binaries that allows attackers to escalate privileges to root.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3950",
+            "cwes": [
+                "CWE-269"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-22005",
+            "vendorProject": "VMware",
+            "product": "vCenter Server",
+            "vulnerabilityName": "VMware vCenter Server File Upload Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "VMware vCenter Server contains a file upload vulnerability in the Analytics service that allows a user with network access to port 443 to execute code.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-22005",
+            "cwes": [
+                "CWE-23"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-3952",
+            "vendorProject": "VMware",
+            "product": "vCenter Server",
+            "vulnerabilityName": "VMware vCenter Server Information Disclosure Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "VMware vCenter Server contains an information disclosure vulnerability in the VMware Directory Service (vmdir) when the Platform Services Controller (PSC) does not correctly implement access controls. Successful exploitation allows an attacker with network access to port 389 to extract sensitive information.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-3952",
+            "cwes": [
+                "CWE-306"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21972",
+            "vendorProject": "VMware",
+            "product": "vCenter Server",
+            "vulnerabilityName": "VMware vCenter Server Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "VMware vCenter Server vSphere Client contains a remote code execution vulnerability in a vCenter Server plugin which allows an attacker with network access to port 443 to execute commands with unrestricted privileges on the underlying operating system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21972",
+            "cwes": [
+                "CWE-23"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-21985",
+            "vendorProject": "VMware",
+            "product": "vCenter Server",
+            "vulnerabilityName": "VMware vCenter Server Improper Input Validation Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "VMware vSphere Client contains an improper input validation vulnerability in the Virtual SAN Health Check plug-in, which is enabled by default in vCenter Server, which allows for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-21985",
+            "cwes": [
+                "CWE-20",
+                "CWE-470",
+                "CWE-918"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-4006",
+            "vendorProject": "VMware",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Multiple VMware Products Command Injection Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "VMware Workspace One Access, Access Connector, Identity Manager, and Identity Manager Connector contain a command injection vulnerability. An attacker with network access to the administrative configurator on port 8443 and a valid password for the configurator administrator account can execute commands with unrestricted privileges on the underlying operating system.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-4006",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-25213",
+            "vendorProject": "WordPress",
+            "product": "File Manager Plugin",
+            "vulnerabilityName": "WordPress File Manager Plugin Remote Code Execution Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "WordPress File Manager plugin contains a remote code execution vulnerability that allows unauthenticated users to execute PHP code and upload malicious files on a target site.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-25213",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-11738",
+            "vendorProject": "WordPress",
+            "product": "Snap Creek Duplicator Plugin",
+            "vulnerabilityName": "WordPress Snap Creek Duplicator Plugin File Download Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "WordPress Snap Creek Duplicator plugin contains a file download vulnerability when an administrator creates a new copy of their site that allows an attacker to download the generated files from their Wordpress dashboard. This vulnerability affects Duplicator and Dulplicator Pro.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-11738",
+            "cwes": [
+                "CWE-22"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-9978",
+            "vendorProject": "WordPress",
+            "product": "Social Warfare Plugin",
+            "vulnerabilityName": "WordPress Social Warfare Plugin Cross-Site Scripting (XSS) Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "WordPress Social Warfare plugin contains a cross-site scripting (XSS) vulnerability that allows for remote code execution. This vulnerability affects Social Warfare and Social Warfare Pro.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-9978",
+            "cwes": [
+                "CWE-79"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-27561",
+            "vendorProject": "Yealink",
+            "product": "Device Management",
+            "vulnerabilityName": "Yealink Device Management Server-Side Request Forgery (SSRF) Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Yealink Device Management contains a server-side request forgery (SSRF) vulnerability that allows for unauthenticated remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-27561",
+            "cwes": [
+                "CWE-78"
+            ]
+        },
+        {
+            "cveID": "CVE-2021-40539",
+            "vendorProject": "Zoho",
+            "product": "ManageEngine",
+            "vulnerabilityName": "Zoho ManageEngine ADSelfService Plus Authentication Bypass Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Zoho ManageEngine ADSelfService Plus contains an authentication bypass vulnerability affecting the REST API URLs which allow for remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2021-11-17",
+            "knownRansomwareCampaignUse": "Known",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2021-40539",
+            "cwes": [
+                "CWE-55"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-10189",
+            "vendorProject": "Zoho",
+            "product": "ManageEngine",
+            "vulnerabilityName": "Zoho ManageEngine Desktop Central File Upload Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Zoho ManageEngine Desktop Central contains a file upload vulnerability that allows for unauthenticated remote code execution.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-10189",
+            "cwes": [
+                "CWE-502"
+            ]
+        },
+        {
+            "cveID": "CVE-2019-8394",
+            "vendorProject": "Zoho",
+            "product": "ManageEngine",
+            "vulnerabilityName": "Zoho ManageEngine ServiceDesk Plus (SDP) File Upload Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Zoho ManageEngine ServiceDesk Plus (SDP) contains an unspecified vulnerability that allows remote users to upload files via login page customization.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2019-8394",
+            "cwes": [
+                "CWE-434"
+            ]
+        },
+        {
+            "cveID": "CVE-2020-29583",
+            "vendorProject": "Zyxel",
+            "product": "Multiple Products",
+            "vulnerabilityName": "Zyxel Multiple Products Use of Hard-Coded Credentials Vulnerability",
+            "dateAdded": "2021-11-03",
+            "shortDescription": "Zyxel firewalls (ATP, USG, VM) and AP Controllers (NXC2500 and NXC5500) contain a use of hard-coded credentials vulnerability in an undocumented account (\"zyfwp\") with an unchangeable password.",
+            "requiredAction": "Apply updates per vendor instructions.",
+            "dueDate": "2022-05-03",
+            "knownRansomwareCampaignUse": "Unknown",
+            "notes": "https:\/\/nvd.nist.gov\/vuln\/detail\/CVE-2020-29583",
+            "cwes": [
+                "CWE-522"
+            ]
+        }
+    ]
+}
\ No newline at end of file
diff --git a/data/cache/known_exploited_vulnerabilities_parsed.json b/data/cache/known_exploited_vulnerabilities_parsed.json
new file mode 100644
index 00000000000..c9d64334bae
--- /dev/null
+++ b/data/cache/known_exploited_vulnerabilities_parsed.json
@@ -0,0 +1 @@
+{"CVE-2009-0556": true, "CVE-2025-37164": true, "CVE-2025-14847": true, "CVE-2023-52163": true, "CVE-2025-14733": true, "CVE-2025-59374": true, "CVE-2025-40602": true, "CVE-2025-20393": true, "CVE-2025-59718": true, "CVE-2025-14611": true, "CVE-2025-43529": true, "CVE-2018-4063": true, "CVE-2025-14174": true, "CVE-2025-58360": true, "CVE-2025-6218": true, "CVE-2025-62221": true, "CVE-2022-37055": true, "CVE-2025-66644": true, "CVE-2025-55182": true, "CVE-2021-26828": true, "CVE-2025-48633": true, "CVE-2025-48572": true, "CVE-2021-26829": true, "CVE-2025-61757": true, "CVE-2025-13223": true, "CVE-2025-58034": true, "CVE-2025-64446": true, "CVE-2025-12480": true, "CVE-2025-62215": true, "CVE-2025-9242": true, "CVE-2025-21042": true, "CVE-2025-48703": true, "CVE-2025-11371": true, "CVE-2025-41244": true, "CVE-2025-24893": true, "CVE-2025-6204": true, "CVE-2025-6205": true, "CVE-2025-54236": true, "CVE-2025-59287": true, "CVE-2025-61932": true, "CVE-2022-48503": true, "CVE-2025-2746": true, "CVE-2025-2747": true, "CVE-2025-33073": true, "CVE-2025-61884": true, "CVE-2025-54253": true, "CVE-2025-47827": true, "CVE-2025-24990": true, "CVE-2025-59230": true, "CVE-2016-7836": true, "CVE-2021-43798": true, "CVE-2025-27915": true, "CVE-2021-22555": true, "CVE-2010-3962": true, "CVE-2021-43226": true, "CVE-2013-3918": true, "CVE-2011-3402": true, "CVE-2010-3765": true, "CVE-2025-61882": true, "CVE-2014-6278": true, "CVE-2017-1000353": true, "CVE-2015-7755": true, "CVE-2025-21043": true, "CVE-2025-4008": true, "CVE-2025-32463": true, "CVE-2025-59689": true, "CVE-2025-10035": true, "CVE-2025-20352": true, "CVE-2021-21311": true, "CVE-2025-20362": true, "CVE-2025-20333": true, "CVE-2025-10585": true, "CVE-2025-5086": true, "CVE-2025-38352": true, "CVE-2025-48543": true, "CVE-2025-53690": true, "CVE-2023-50224": true, "CVE-2025-9377": true, "CVE-2020-24363": true, "CVE-2025-55177": true, "CVE-2025-57819": true, "CVE-2025-7775": true, "CVE-2025-48384": true, "CVE-2024-8068": true, "CVE-2024-8069": true, "CVE-2025-43300": true, "CVE-2025-54948": true, "CVE-2025-8876": true, "CVE-2025-8875": true, "CVE-2025-8088": true, "CVE-2007-0671": true, "CVE-2013-3893": true, "CVE-2020-25078": true, "CVE-2020-25079": true, "CVE-2022-40799": true, "CVE-2023-2533": true, "CVE-2025-20337": true, "CVE-2025-20281": true, "CVE-2025-2775": true, "CVE-2025-2776": true, "CVE-2025-6558": true, "CVE-2025-54309": true, "CVE-2025-49704": true, "CVE-2025-49706": true, "CVE-2025-53770": true, "CVE-2025-25257": true, "CVE-2025-47812": true, "CVE-2025-5777": true, "CVE-2019-9621": true, "CVE-2019-5418": true, "CVE-2016-10033": true, "CVE-2014-3931": true, "CVE-2025-6554": true, "CVE-2025-48928": true, "CVE-2025-48927": true, "CVE-2025-6543": true, "CVE-2019-6693": true, "CVE-2024-0769": true, "CVE-2024-54085": true, "CVE-2023-0386": true, "CVE-2023-33538": true, "CVE-2025-43200": true, "CVE-2025-33053": true, "CVE-2025-24016": true, "CVE-2024-42009": true, "CVE-2025-32433": true, "CVE-2025-5419": true, "CVE-2025-21479": true, "CVE-2025-21480": true, "CVE-2025-27038": true, "CVE-2021-32030": true, "CVE-2025-3935": true, "CVE-2025-35939": true, "CVE-2024-56145": true, "CVE-2023-39780": true, "CVE-2025-4632": true, "CVE-2023-38950": true, "CVE-2024-27443": true, "CVE-2025-27920": true, "CVE-2024-11182": true, "CVE-2025-4428": true, "CVE-2025-4427": true, "CVE-2025-42999": true, "CVE-2024-12987": true, "CVE-2025-32756": true, "CVE-2025-32709": true, "CVE-2025-30397": true, "CVE-2025-32706": true, "CVE-2025-32701": true, "CVE-2025-30400": true, "CVE-2025-47729": true, "CVE-2024-11120": true, "CVE-2024-6047": true, "CVE-2025-27363": true, "CVE-2025-3248": true, "CVE-2025-34028": true, "CVE-2024-58136": true, "CVE-2024-38475": true, "CVE-2023-44221": true, "CVE-2025-31324": true, "CVE-2025-1976": true, "CVE-2025-42599": true, "CVE-2025-3928": true, "CVE-2025-24054": true, "CVE-2025-31201": true, "CVE-2025-31200": true, "CVE-2021-20035": true, "CVE-2024-53150": true, "CVE-2024-53197": true, "CVE-2025-29824": true, "CVE-2025-30406": true, "CVE-2025-31161": true, "CVE-2025-22457": true, "CVE-2025-24813": true, "CVE-2024-20439": true, "CVE-2025-2783": true, "CVE-2019-9875": true, "CVE-2019-9874": true, "CVE-2025-30154": true, "CVE-2017-12637": true, "CVE-2024-48248": true, "CVE-2025-1316": true, "CVE-2025-30066": true, "CVE-2025-24472": true, "CVE-2025-21590": true, "CVE-2025-24201": true, "CVE-2025-24993": true, "CVE-2025-24991": true, "CVE-2025-24985": true, "CVE-2025-24984": true, "CVE-2025-24983": true, "CVE-2025-26633": true, "CVE-2024-13161": true, "CVE-2024-13160": true, "CVE-2024-13159": true, "CVE-2024-57968": true, "CVE-2025-25181": true, "CVE-2025-22226": true, "CVE-2025-22225": true, "CVE-2025-22224": true, "CVE-2024-50302": true, "CVE-2024-4885": true, "CVE-2018-8639": true, "CVE-2022-43769": true, "CVE-2022-43939": true, "CVE-2023-20118": true, "CVE-2023-34192": true, "CVE-2024-49035": true, "CVE-2024-20953": true, "CVE-2017-3066": true, "CVE-2025-24989": true, "CVE-2025-0111": true, "CVE-2025-23209": true, "CVE-2025-0108": true, "CVE-2024-53704": true, "CVE-2024-57727": true, "CVE-2025-24200": true, "CVE-2024-41710": true, "CVE-2024-40891": true, "CVE-2024-40890": true, "CVE-2025-21418": true, "CVE-2025-21391": true, "CVE-2025-0994": true, "CVE-2020-15069": true, "CVE-2020-29574": true, "CVE-2024-21413": true, "CVE-2022-23748": true, "CVE-2025-0411": true, "CVE-2024-53104": true, "CVE-2018-19410": true, "CVE-2018-9276": true, "CVE-2024-29059": true, "CVE-2024-45195": true, "CVE-2025-24085": true, "CVE-2025-23006": true, "CVE-2020-11023": true, "CVE-2024-50603": true, "CVE-2025-21335": true, "CVE-2025-21334": true, "CVE-2025-21333": true, "CVE-2024-55591": true, "CVE-2023-48365": true, "CVE-2024-12686": true, "CVE-2025-0282": true, "CVE-2020-2883": true, "CVE-2024-55550": true, "CVE-2024-41713": true, "CVE-2024-3393": true, "CVE-2021-44207": true, "CVE-2024-12356": true, "CVE-2021-40407": true, "CVE-2019-11001": true, "CVE-2022-23227": true, "CVE-2018-14933": true, "CVE-2024-55956": true, "CVE-2024-35250": true, "CVE-2024-20767": true, "CVE-2024-50623": true, "CVE-2024-49138": true, "CVE-2024-51378": true, "CVE-2024-11667": true, "CVE-2024-11680": true, "CVE-2023-45727": true, "CVE-2023-28461": true, "CVE-2024-21287": true, "CVE-2024-44309": true, "CVE-2024-44308": true, "CVE-2024-38813": true, "CVE-2024-38812": true, "CVE-2024-9474": true, "CVE-2024-0012": true, "CVE-2024-1212": true, "CVE-2024-9465": true, "CVE-2024-9463": true, "CVE-2021-26086": true, "CVE-2014-2120": true, "CVE-2021-41277": true, "CVE-2024-43451": true, "CVE-2024-49039": true, "CVE-2019-16278": true, "CVE-2024-51567": true, "CVE-2024-43093": true, "CVE-2024-5910": true, "CVE-2024-8956": true, "CVE-2024-8957": true, "CVE-2024-37383": true, "CVE-2024-20481": true, "CVE-2024-47575": true, "CVE-2024-38094": true, "CVE-2024-9537": true, "CVE-2024-40711": true, "CVE-2024-28987": true, "CVE-2024-9680": true, "CVE-2024-30088": true, "CVE-2024-9380": true, "CVE-2024-9379": true, "CVE-2024-23113": true, "CVE-2024-43573": true, "CVE-2024-43572": true, "CVE-2024-43047": true, "CVE-2024-45519": true, "CVE-2024-29824": true, "CVE-2019-0344": true, "CVE-2020-15415": true, "CVE-2023-25280": true, "CVE-2024-7593": true, "CVE-2024-8963": true, "CVE-2020-14644": true, "CVE-2022-21445": true, "CVE-2020-0618": true, "CVE-2024-27348": true, "CVE-2014-0502": true, "CVE-2013-0648": true, "CVE-2013-0643": true, "CVE-2014-0497": true, "CVE-2024-6670": true, "CVE-2024-43461": true, "CVE-2024-8190": true, "CVE-2024-38217": true, "CVE-2024-38014": true, "CVE-2024-38226": true, "CVE-2024-40766": true, "CVE-2017-1000253": true, "CVE-2016-3714": true, "CVE-2024-7262": true, "CVE-2021-20124": true, "CVE-2021-20123": true, "CVE-2024-7965": true, "CVE-2024-38856": true, "CVE-2024-7971": true, "CVE-2024-39717": true, "CVE-2021-31196": true, "CVE-2022-0185": true, "CVE-2021-33045": true, "CVE-2021-33044": true, "CVE-2024-23897": true, "CVE-2024-28986": true, "CVE-2024-38107": true, "CVE-2024-38106": true, "CVE-2024-38193": true, "CVE-2024-38213": true, "CVE-2024-38178": true, "CVE-2024-38189": true, "CVE-2024-32113": true, "CVE-2024-36971": true, "CVE-2018-0824": true, "CVE-2024-37085": true, "CVE-2023-45249": true, "CVE-2024-5217": true, "CVE-2024-4879": true, "CVE-2024-39891": true, "CVE-2012-4792": true, "CVE-2022-22948": true, "CVE-2024-28995": true, "CVE-2024-34102": true, "CVE-2024-36401": true, "CVE-2024-23692": true, "CVE-2024-38080": true, "CVE-2024-38112": true, "CVE-2024-20399": true, "CVE-2020-13965": true, "CVE-2022-2586": true, "CVE-2022-24816": true, "CVE-2024-4358": true, "CVE-2024-26169": true, "CVE-2024-32896": true, "CVE-2024-4577": true, "CVE-2024-4610": true, "CVE-2017-3506": true, "CVE-2024-1086": true, "CVE-2024-24919": true, "CVE-2024-4978": true, "CVE-2024-5274": true, "CVE-2020-17519": true, "CVE-2024-4947": true, "CVE-2023-43208": true, "CVE-2024-4761": true, "CVE-2021-40655": true, "CVE-2014-100005": true, "CVE-2024-30040": true, "CVE-2024-30051": true, "CVE-2024-4671": true, "CVE-2023-7028": true, "CVE-2024-29988": true, "CVE-2024-4040": true, "CVE-2024-20359": true, "CVE-2024-20353": true, "CVE-2022-38028": true, "CVE-2024-3400": true, "CVE-2024-3273": true, "CVE-2024-3272": true, "CVE-2024-29748": true, "CVE-2024-29745": true, "CVE-2023-24955": true, "CVE-2019-7256": true, "CVE-2021-44529": true, "CVE-2023-48788": true, "CVE-2024-27198": true, "CVE-2024-23225": true, "CVE-2024-23296": true, "CVE-2023-21237": true, "CVE-2021-36380": true, "CVE-2024-21338": true, "CVE-2023-29360": true, "CVE-2024-1709": true, "CVE-2020-3259": true, "CVE-2024-21410": true, "CVE-2024-21412": true, "CVE-2024-21351": true, "CVE-2023-43770": true, "CVE-2024-21762": true, "CVE-2023-4762": true, "CVE-2022-48618": true, "CVE-2024-21893": true, "CVE-2023-22527": true, "CVE-2024-23222": true, "CVE-2023-34048": true, "CVE-2023-35082": true, "CVE-2024-0519": true, "CVE-2023-6549": true, "CVE-2023-6548": true, "CVE-2018-15133": true, "CVE-2023-29357": true, "CVE-2023-46805": true, "CVE-2024-21887": true, "CVE-2023-23752": true, "CVE-2016-20017": true, "CVE-2023-41990": true, "CVE-2023-27524": true, "CVE-2023-29300": true, "CVE-2023-38203": true, "CVE-2023-7101": true, "CVE-2023-7024": true, "CVE-2023-49897": true, "CVE-2023-47565": true, "CVE-2023-6448": true, "CVE-2023-41266": true, "CVE-2023-41265": true, "CVE-2023-33107": true, "CVE-2023-33106": true, "CVE-2023-33063": true, "CVE-2022-22071": true, "CVE-2023-42917": true, "CVE-2023-42916": true, "CVE-2023-6345": true, "CVE-2023-49103": true, "CVE-2023-4911": true, "CVE-2023-36584": true, "CVE-2023-1671": true, "CVE-2020-2551": true, "CVE-2023-36033": true, "CVE-2023-36025": true, "CVE-2023-36036": true, "CVE-2023-47246": true, "CVE-2023-36844": true, "CVE-2023-36845": true, "CVE-2023-36846": true, "CVE-2023-36847": true, "CVE-2023-36851": true, "CVE-2023-29552": true, "CVE-2023-22518": true, "CVE-2023-46604": true, "CVE-2023-46748": true, "CVE-2023-46747": true, "CVE-2023-5631": true, "CVE-2023-20273": true, "CVE-2023-4966": true, "CVE-2023-20198": true, "CVE-2023-21608": true, "CVE-2023-20109": true, "CVE-2023-41763": true, "CVE-2023-36563": true, "CVE-2023-44487": true, "CVE-2023-22515": true, "CVE-2023-40044": true, "CVE-2023-42824": true, "CVE-2023-42793": true, "CVE-2023-28229": true, "CVE-2023-4211": true, "CVE-2023-5217": true, "CVE-2018-14667": true, "CVE-2023-41991": true, "CVE-2023-41992": true, "CVE-2023-41993": true, "CVE-2023-41179": true, "CVE-2023-28434": true, "CVE-2022-22265": true, "CVE-2014-8361": true, "CVE-2017-6884": true, "CVE-2021-3129": true, "CVE-2023-26369": true, "CVE-2023-35674": true, "CVE-2023-20269": true, "CVE-2023-4863": true, "CVE-2023-36761": true, "CVE-2023-36802": true, "CVE-2023-41064": true, "CVE-2023-41061": true, "CVE-2023-33246": true, "CVE-2023-38831": true, "CVE-2023-32315": true, "CVE-2023-38035": true, "CVE-2023-27532": true, "CVE-2023-26359": true, "CVE-2023-24489": true, "CVE-2023-38180": true, "CVE-2017-18368": true, "CVE-2023-35081": true, "CVE-2023-37580": true, "CVE-2023-38606": true, "CVE-2023-35078": true, "CVE-2023-29298": true, "CVE-2023-38205": true, "CVE-2023-3519": true, "CVE-2023-36884": true, "CVE-2022-29303": true, "CVE-2023-37450": true, "CVE-2023-32046": true, "CVE-2023-32049": true, "CVE-2023-35311": true, "CVE-2023-36874": true, "CVE-2022-31199": true, "CVE-2021-29256": true, "CVE-2019-17621": true, "CVE-2019-20500": true, "CVE-2021-25487": true, "CVE-2021-25489": true, "CVE-2021-25394": true, "CVE-2021-25395": true, "CVE-2021-25371": true, "CVE-2021-25372": true, "CVE-2023-32434": true, "CVE-2023-32435": true, "CVE-2023-32439": true, "CVE-2023-20867": true, "CVE-2023-27992": true, "CVE-2023-20887": true, "CVE-2020-35730": true, "CVE-2020-12641": true, "CVE-2021-44026": true, "CVE-2016-9079": true, "CVE-2016-0165": true, "CVE-2023-27997": true, "CVE-2023-3079": true, "CVE-2023-33009": true, "CVE-2023-33010": true, "CVE-2023-34362": true, "CVE-2023-28771": true, "CVE-2023-2868": true, "CVE-2023-32409": true, "CVE-2023-28204": true, "CVE-2023-32373": true, "CVE-2004-1464": true, "CVE-2016-6415": true, "CVE-2023-21492": true, "CVE-2023-25717": true, "CVE-2021-3560": true, "CVE-2014-0196": true, "CVE-2010-3904": true, "CVE-2015-5317": true, "CVE-2016-3427": true, "CVE-2016-8735": true, "CVE-2023-29336": true, "CVE-2023-1389": true, "CVE-2021-45046": true, "CVE-2023-21839": true, "CVE-2023-28432": true, "CVE-2023-27350": true, "CVE-2023-2136": true, "CVE-2017-6742": true, "CVE-2019-8526": true, "CVE-2023-2033": true, "CVE-2023-20963": true, "CVE-2023-29492": true, "CVE-2023-28252": true, "CVE-2023-28205": true, "CVE-2023-28206": true, "CVE-2021-27876": true, "CVE-2021-27877": true, "CVE-2021-27878": true, "CVE-2019-1388": true, "CVE-2023-26083": true, "CVE-2022-27926": true, "CVE-2013-3163": true, "CVE-2017-7494": true, "CVE-2022-42948": true, "CVE-2022-39197": true, "CVE-2021-30900": true, "CVE-2022-38181": true, "CVE-2023-0266": true, "CVE-2022-3038": true, "CVE-2022-22706": true, "CVE-2023-26360": true, "CVE-2023-23397": true, "CVE-2023-24880": true, "CVE-2022-41328": true, "CVE-2021-39144": true, "CVE-2020-5741": true, "CVE-2022-28810": true, "CVE-2022-33891": true, "CVE-2022-35914": true, "CVE-2022-36537": true, "CVE-2022-47986": true, "CVE-2022-41223": true, "CVE-2022-40765": true, "CVE-2022-46169": true, "CVE-2023-21715": true, "CVE-2023-23376": true, "CVE-2023-23529": true, "CVE-2023-21823": true, "CVE-2015-2291": true, "CVE-2022-24990": true, "CVE-2023-0669": true, "CVE-2022-21587": true, "CVE-2023-22952": true, "CVE-2017-11357": true, "CVE-2022-47966": true, "CVE-2022-44877": true, "CVE-2022-41080": true, "CVE-2023-21674": true, "CVE-2018-5430": true, "CVE-2018-18809": true, "CVE-2022-42856": true, "CVE-2022-42475": true, "CVE-2022-44698": true, "CVE-2022-27518": true, "CVE-2022-26500": true, "CVE-2022-26501": true, "CVE-2022-4262": true, "CVE-2021-35587": true, "CVE-2022-4135": true, "CVE-2022-41049": true, "CVE-2022-41091": true, "CVE-2022-41073": true, "CVE-2022-41125": true, "CVE-2022-41128": true, "CVE-2021-25337": true, "CVE-2021-25369": true, "CVE-2021-25370": true, "CVE-2022-3723": true, "CVE-2022-42827": true, "CVE-2020-3433": true, "CVE-2020-3153": true, "CVE-2018-19323": true, "CVE-2018-19322": true, "CVE-2018-19321": true, "CVE-2018-19320": true, "CVE-2022-41352": true, "CVE-2021-3493": true, "CVE-2022-40684": true, "CVE-2022-41033": true, "CVE-2022-41082": true, "CVE-2022-41040": true, "CVE-2022-36804": true, "CVE-2022-3236": true, "CVE-2022-35405": true, "CVE-2022-40139": true, "CVE-2013-6282": true, "CVE-2013-2597": true, "CVE-2013-2596": true, "CVE-2013-2094": true, "CVE-2010-2568": true, "CVE-2022-37969": true, "CVE-2022-32917": true, "CVE-2022-3075": true, "CVE-2022-27593": true, "CVE-2022-26258": true, "CVE-2020-9934": true, "CVE-2018-7445": true, "CVE-2018-6530": true, "CVE-2018-2628": true, "CVE-2018-13374": true, "CVE-2017-5521": true, "CVE-2011-4723": true, "CVE-2011-1823": true, "CVE-2022-26352": true, "CVE-2022-24706": true, "CVE-2022-24112": true, "CVE-2022-22963": true, "CVE-2022-2294": true, "CVE-2021-39226": true, "CVE-2021-38406": true, "CVE-2021-31010": true, "CVE-2020-36193": true, "CVE-2020-28949": true, "CVE-2022-0028": true, "CVE-2022-22536": true, "CVE-2022-32894": true, "CVE-2022-32893": true, "CVE-2022-2856": true, "CVE-2022-26923": true, "CVE-2022-21971": true, "CVE-2017-15944": true, "CVE-2022-27925": true, "CVE-2022-37042": true, "CVE-2022-34713": true, "CVE-2022-30333": true, "CVE-2022-27924": true, "CVE-2022-26138": true, "CVE-2022-22047": true, "CVE-2022-26925": true, "CVE-2022-29499": true, "CVE-2021-30533": true, "CVE-2021-4034": true, "CVE-2021-30983": true, "CVE-2020-3837": true, "CVE-2020-9907": true, "CVE-2019-8605": true, "CVE-2018-4344": true, "CVE-2022-30190": true, "CVE-2021-38163": true, "CVE-2016-2386": true, "CVE-2016-2388": true, "CVE-2019-7195": true, "CVE-2019-7194": true, "CVE-2019-7193": true, "CVE-2019-7192": true, "CVE-2019-5825": true, "CVE-2019-15271": true, "CVE-2018-6065": true, "CVE-2018-4990": true, "CVE-2018-17480": true, "CVE-2018-17463": true, "CVE-2017-6862": true, "CVE-2017-5070": true, "CVE-2017-5030": true, "CVE-2016-5198": true, "CVE-2016-1646": true, "CVE-2013-1331": true, "CVE-2012-5054": true, "CVE-2012-4969": true, "CVE-2012-1889": true, "CVE-2012-0767": true, "CVE-2012-0754": true, "CVE-2012-0151": true, "CVE-2011-2462": true, "CVE-2011-0609": true, "CVE-2010-2883": true, "CVE-2010-2572": true, "CVE-2010-1297": true, "CVE-2009-4324": true, "CVE-2009-3953": true, "CVE-2009-1862": true, "CVE-2009-0563": true, "CVE-2009-0557": true, "CVE-2008-0655": true, "CVE-2007-5659": true, "CVE-2006-2492": true, "CVE-2022-26134": true, "CVE-2019-3010": true, "CVE-2016-3393": true, "CVE-2016-7256": true, "CVE-2016-1010": true, "CVE-2016-0984": true, "CVE-2016-0034": true, "CVE-2015-0310": true, "CVE-2015-0016": true, "CVE-2015-0071": true, "CVE-2015-2360": true, "CVE-2015-2425": true, "CVE-2015-1769": true, "CVE-2015-4495": true, "CVE-2015-8651": true, "CVE-2015-6175": true, "CVE-2015-1671": true, "CVE-2014-4148": true, "CVE-2014-8439": true, "CVE-2014-4123": true, "CVE-2014-0546": true, "CVE-2014-2817": true, "CVE-2014-4077": true, "CVE-2014-3153": true, "CVE-2013-7331": true, "CVE-2013-3993": true, "CVE-2013-3896": true, "CVE-2013-2423": true, "CVE-2013-0431": true, "CVE-2013-0422": true, "CVE-2013-0074": true, "CVE-2012-1710": true, "CVE-2010-1428": true, "CVE-2010-0840": true, "CVE-2010-0738": true, "CVE-2018-8611": true, "CVE-2018-19953": true, "CVE-2018-19949": true, "CVE-2018-19943": true, "CVE-2017-0147": true, "CVE-2017-0022": true, "CVE-2017-0005": true, "CVE-2017-0149": true, "CVE-2017-0210": true, "CVE-2017-8291": true, "CVE-2017-8543": true, "CVE-2017-18362": true, "CVE-2016-0162": true, "CVE-2016-3351": true, "CVE-2016-4655": true, "CVE-2016-4656": true, "CVE-2016-4657": true, "CVE-2016-6366": true, "CVE-2016-6367": true, "CVE-2016-3298": true, "CVE-2022-20821": true, "CVE-2021-1048": true, "CVE-2021-0920": true, "CVE-2021-30883": true, "CVE-2020-1027": true, "CVE-2020-0638": true, "CVE-2019-7286": true, "CVE-2019-7287": true, "CVE-2019-0676": true, "CVE-2019-5786": true, "CVE-2019-0703": true, "CVE-2019-0880": true, "CVE-2019-13720": true, "CVE-2019-11707": true, "CVE-2019-11708": true, "CVE-2019-8720": true, "CVE-2019-18426": true, "CVE-2019-1385": true, "CVE-2019-1130": true, "CVE-2018-5002": true, "CVE-2018-8589": true, "CVE-2022-30525": true, "CVE-2022-22947": true, "CVE-2022-1388": true, "CVE-2021-1789": true, "CVE-2019-8506": true, "CVE-2014-4113": true, "CVE-2014-0322": true, "CVE-2014-0160": true, "CVE-2022-29464": true, "CVE-2022-26904": true, "CVE-2022-21919": true, "CVE-2022-0847": true, "CVE-2021-41357": true, "CVE-2021-40450": true, "CVE-2019-1003029": true, "CVE-2018-6882": true, "CVE-2019-3568": true, "CVE-2022-22718": true, "CVE-2022-22960": true, "CVE-2022-1364": true, "CVE-2019-3929": true, "CVE-2019-16057": true, "CVE-2018-7841": true, "CVE-2016-4523": true, "CVE-2014-0780": true, "CVE-2010-5330": true, "CVE-2007-3010": true, "CVE-2022-22954": true, "CVE-2022-24521": true, "CVE-2018-7602": true, "CVE-2018-20753": true, "CVE-2015-5123": true, "CVE-2015-5122": true, "CVE-2015-3113": true, "CVE-2015-2502": true, "CVE-2015-0313": true, "CVE-2015-0311": true, "CVE-2014-9163": true, "CVE-2022-23176": true, "CVE-2021-42287": true, "CVE-2021-42278": true, "CVE-2021-39793": true, "CVE-2021-27852": true, "CVE-2021-22600": true, "CVE-2020-2509": true, "CVE-2017-11317": true, "CVE-2021-3156": true, "CVE-2021-31166": true, "CVE-2017-0148": true, "CVE-2022-22965": true, "CVE-2022-22675": true, "CVE-2022-22674": true, "CVE-2021-45382": true, "CVE-2022-26871": true, "CVE-2022-1040": true, "CVE-2021-34484": true, "CVE-2021-28799": true, "CVE-2021-21551": true, "CVE-2018-10562": true, "CVE-2018-10561": true, "CVE-2022-1096": true, "CVE-2022-0543": true, "CVE-2021-38646": true, "CVE-2021-34486": true, "CVE-2021-26085": true, "CVE-2021-20028": true, "CVE-2019-7483": true, "CVE-2018-8440": true, "CVE-2018-8406": true, "CVE-2018-8405": true, "CVE-2017-0213": true, "CVE-2017-0059": true, "CVE-2017-0037": true, "CVE-2016-7201": true, "CVE-2016-7200": true, "CVE-2016-0189": true, "CVE-2016-0151": true, "CVE-2016-0040": true, "CVE-2015-2426": true, "CVE-2015-2419": true, "CVE-2015-1770": true, "CVE-2013-3660": true, "CVE-2013-2729": true, "CVE-2013-2551": true, "CVE-2013-2465": true, "CVE-2013-1690": true, "CVE-2012-5076": true, "CVE-2012-2539": true, "CVE-2012-2034": true, "CVE-2012-0518": true, "CVE-2011-2005": true, "CVE-2010-4398": true, "CVE-2022-26318": true, "CVE-2022-26143": true, "CVE-2022-21999": true, "CVE-2021-42237": true, "CVE-2021-22941": true, "CVE-2020-9377": true, "CVE-2020-9054": true, "CVE-2020-7247": true, "CVE-2020-5410": true, "CVE-2020-25223": true, "CVE-2020-2506": true, "CVE-2020-2021": true, "CVE-2020-1956": true, "CVE-2020-1631": true, "CVE-2019-6340": true, "CVE-2019-2616": true, "CVE-2019-16920": true, "CVE-2019-15107": true, "CVE-2019-12991": true, "CVE-2019-12989": true, "CVE-2019-11043": true, "CVE-2019-10068": true, "CVE-2019-1003030": true, "CVE-2019-0903": true, "CVE-2018-8414": true, "CVE-2018-8373": true, "CVE-2018-6961": true, "CVE-2018-14839": true, "CVE-2018-1273": true, "CVE-2018-11138": true, "CVE-2018-0147": true, "CVE-2018-0125": true, "CVE-2017-6334": true, "CVE-2017-6316": true, "CVE-2017-3881": true, "CVE-2017-12617": true, "CVE-2017-12615": true, "CVE-2017-0146": true, "CVE-2016-7892": true, "CVE-2016-4171": true, "CVE-2016-1555": true, "CVE-2016-11021": true, "CVE-2016-10174": true, "CVE-2016-0752": true, "CVE-2015-4068": true, "CVE-2015-3035": true, "CVE-2015-1427": true, "CVE-2015-1187": true, "CVE-2015-0666": true, "CVE-2014-6332": true, "CVE-2014-6324": true, "CVE-2014-6287": true, "CVE-2014-3120": true, "CVE-2014-0130": true, "CVE-2013-5223": true, "CVE-2013-4810": true, "CVE-2013-2251": true, "CVE-2012-1823": true, "CVE-2010-4345": true, "CVE-2010-4344": true, "CVE-2010-3035": true, "CVE-2010-2861": true, "CVE-2009-2055": true, "CVE-2009-1151": true, "CVE-2009-0927": true, "CVE-2005-2773": true, "CVE-2020-5135": true, "CVE-2019-1405": true, "CVE-2019-1322": true, "CVE-2019-1315": true, "CVE-2019-1253": true, "CVE-2019-1132": true, "CVE-2019-1129": true, "CVE-2019-1069": true, "CVE-2019-1064": true, "CVE-2019-0841": true, "CVE-2019-0543": true, "CVE-2018-8120": true, "CVE-2017-0101": true, "CVE-2016-3309": true, "CVE-2015-2546": true, "CVE-2022-26486": true, "CVE-2022-26485": true, "CVE-2021-21973": true, "CVE-2020-8218": true, "CVE-2019-11581": true, "CVE-2017-6077": true, "CVE-2016-6277": true, "CVE-2013-0631": true, "CVE-2013-0629": true, "CVE-2013-0625": true, "CVE-2009-3960": true, "CVE-2022-20708": true, "CVE-2022-20703": true, "CVE-2022-20701": true, "CVE-2022-20700": true, "CVE-2022-20699": true, "CVE-2021-41379": true, "CVE-2020-1938": true, "CVE-2020-11899": true, "CVE-2019-16928": true, "CVE-2019-1652": true, "CVE-2019-1297": true, "CVE-2018-8581": true, "CVE-2018-8298": true, "CVE-2018-0180": true, "CVE-2018-0179": true, "CVE-2018-0175": true, "CVE-2018-0174": true, "CVE-2018-0173": true, "CVE-2018-0172": true, "CVE-2018-0167": true, "CVE-2018-0161": true, "CVE-2018-0159": true, "CVE-2018-0158": true, "CVE-2018-0156": true, "CVE-2018-0155": true, "CVE-2018-0154": true, "CVE-2018-0151": true, "CVE-2017-8540": true, "CVE-2017-6744": true, "CVE-2017-6743": true, "CVE-2017-6740": true, "CVE-2017-6739": true, "CVE-2017-6738": true, "CVE-2017-6737": true, "CVE-2017-6736": true, "CVE-2017-6663": true, "CVE-2017-6627": true, "CVE-2017-12319": true, "CVE-2017-12240": true, "CVE-2017-12238": true, "CVE-2017-12237": true, "CVE-2017-12235": true, "CVE-2017-12234": true, "CVE-2017-12233": true, "CVE-2017-12232": true, "CVE-2017-12231": true, "CVE-2017-11826": true, "CVE-2017-11292": true, "CVE-2017-0261": true, "CVE-2017-0001": true, "CVE-2016-8562": true, "CVE-2016-7855": true, "CVE-2016-7262": true, "CVE-2016-7193": true, "CVE-2016-5195": true, "CVE-2016-4117": true, "CVE-2016-1019": true, "CVE-2016-0099": true, "CVE-2015-7645": true, "CVE-2015-5119": true, "CVE-2015-4902": true, "CVE-2015-3043": true, "CVE-2015-2590": true, "CVE-2015-2545": true, "CVE-2015-2424": true, "CVE-2015-2387": true, "CVE-2015-1701": true, "CVE-2015-1642": true, "CVE-2014-4114": true, "CVE-2014-0496": true, "CVE-2013-5065": true, "CVE-2013-3897": true, "CVE-2013-3346": true, "CVE-2013-1675": true, "CVE-2013-1347": true, "CVE-2013-0641": true, "CVE-2013-0640": true, "CVE-2013-0632": true, "CVE-2012-4681": true, "CVE-2012-1856": true, "CVE-2012-1723": true, "CVE-2012-1535": true, "CVE-2012-0507": true, "CVE-2011-3544": true, "CVE-2011-1889": true, "CVE-2011-0611": true, "CVE-2010-3333": true, "CVE-2010-0232": true, "CVE-2010-0188": true, "CVE-2009-3129": true, "CVE-2009-1123": true, "CVE-2008-3431": true, "CVE-2008-2992": true, "CVE-2004-0210": true, "CVE-2002-0367": true, "CVE-2022-24682": true, "CVE-2017-8570": true, "CVE-2017-0222": true, "CVE-2014-6352": true, "CVE-2022-23131": true, "CVE-2022-23134": true, "CVE-2022-24086": true, "CVE-2022-0609": true, "CVE-2019-0752": true, "CVE-2018-8174": true, "CVE-2018-20250": true, "CVE-2018-15982": true, "CVE-2017-9841": true, "CVE-2014-1761": true, "CVE-2013-3906": true, "CVE-2022-22620": true, "CVE-2021-36934": true, "CVE-2020-0796": true, "CVE-2018-1000861": true, "CVE-2017-9791": true, "CVE-2017-8464": true, "CVE-2017-10271": true, "CVE-2017-0263": true, "CVE-2017-0262": true, "CVE-2017-0145": true, "CVE-2017-0144": true, "CVE-2016-3088": true, "CVE-2015-2051": true, "CVE-2015-1635": true, "CVE-2015-1130": true, "CVE-2014-4404": true, "CVE-2022-21882": true, "CVE-2022-22587": true, "CVE-2021-20038": true, "CVE-2020-5722": true, "CVE-2020-0787": true, "CVE-2017-5689": true, "CVE-2014-1776": true, "CVE-2014-6271": true, "CVE-2014-7169": true, "CVE-2006-1547": true, "CVE-2012-0391": true, "CVE-2018-8453": true, "CVE-2021-35247": true, "CVE-2021-32648": true, "CVE-2021-25296": true, "CVE-2021-25297": true, "CVE-2021-25298": true, "CVE-2021-40870": true, "CVE-2021-33766": true, "CVE-2021-21975": true, "CVE-2021-21315": true, "CVE-2021-22991": true, "CVE-2020-14864": true, "CVE-2020-13671": true, "CVE-2020-11978": true, "CVE-2020-13927": true, "CVE-2021-22017": true, "CVE-2021-36260": true, "CVE-2020-6572": true, "CVE-2019-1458": true, "CVE-2013-3900": true, "CVE-2019-2725": true, "CVE-2019-9670": true, "CVE-2018-13382": true, "CVE-2018-13383": true, "CVE-2019-1579": true, "CVE-2019-10149": true, "CVE-2015-7450": true, "CVE-2017-1000486": true, "CVE-2019-7609": true, "CVE-2021-27860": true, "CVE-2021-43890": true, "CVE-2021-4102": true, "CVE-2021-44515": true, "CVE-2019-13272": true, "CVE-2021-35394": true, "CVE-2019-7238": true, "CVE-2019-0193": true, "CVE-2021-44168": true, "CVE-2017-17562": true, "CVE-2017-12149": true, "CVE-2010-1871": true, "CVE-2020-17463": true, "CVE-2020-8816": true, "CVE-2019-10758": true, "CVE-2021-44228": true, "CVE-2020-11261": true, "CVE-2018-14847": true, "CVE-2021-37415": true, "CVE-2021-40438": true, "CVE-2021-44077": true, "CVE-2021-22204": true, "CVE-2021-40449": true, "CVE-2021-42321": true, "CVE-2021-42292": true, "CVE-2021-27104": true, "CVE-2021-27102": true, "CVE-2021-27101": true, "CVE-2021-27103": true, "CVE-2021-21017": true, "CVE-2021-28550": true, "CVE-2018-4939": true, "CVE-2018-15961": true, "CVE-2018-4878": true, "CVE-2020-5735": true, "CVE-2019-2215": true, "CVE-2020-0041": true, "CVE-2020-0069": true, "CVE-2017-9805": true, "CVE-2021-42013": true, "CVE-2021-41773": true, "CVE-2019-0211": true, "CVE-2016-4437": true, "CVE-2019-17558": true, "CVE-2020-17530": true, "CVE-2017-5638": true, "CVE-2018-11776": true, "CVE-2021-30858": true, "CVE-2019-6223": true, "CVE-2021-30860": true, "CVE-2020-27930": true, "CVE-2021-30807": true, "CVE-2020-27950": true, "CVE-2020-27932": true, "CVE-2020-9818": true, "CVE-2020-9819": true, "CVE-2021-30762": true, "CVE-2021-1782": true, "CVE-2021-1870": true, "CVE-2021-1871": true, "CVE-2021-1879": true, "CVE-2021-30661": true, "CVE-2021-30666": true, "CVE-2021-30713": true, "CVE-2021-30657": true, "CVE-2021-30665": true, "CVE-2021-30663": true, "CVE-2021-30761": true, "CVE-2021-30869": true, "CVE-2020-9859": true, "CVE-2021-20090": true, "CVE-2021-27562": true, "CVE-2021-28664": true, "CVE-2021-28663": true, "CVE-2019-3398": true, "CVE-2021-26084": true, "CVE-2019-11580": true, "CVE-2019-3396": true, "CVE-2021-42258": true, "CVE-2020-3452": true, "CVE-2020-3580": true, "CVE-2021-1497": true, "CVE-2021-1498": true, "CVE-2018-0171": true, "CVE-2020-3118": true, "CVE-2020-3566": true, "CVE-2020-3569": true, "CVE-2020-3161": true, "CVE-2019-1653": true, "CVE-2018-0296": true, "CVE-2019-13608": true, "CVE-2020-8193": true, "CVE-2020-8195": true, "CVE-2020-8196": true, "CVE-2019-19781": true, "CVE-2019-11634": true, "CVE-2020-29557": true, "CVE-2020-25506": true, "CVE-2018-15811": true, "CVE-2018-18325": true, "CVE-2017-9822": true, "CVE-2019-15752": true, "CVE-2020-8515": true, "CVE-2018-7600": true, "CVE-2021-22205": true, "CVE-2018-6789": true, "CVE-2020-8657": true, "CVE-2020-8655": true, "CVE-2020-5902": true, "CVE-2021-22986": true, "CVE-2021-35464": true, "CVE-2019-5591": true, "CVE-2020-12812": true, "CVE-2018-13379": true, "CVE-2020-16010": true, "CVE-2020-15999": true, "CVE-2021-21166": true, "CVE-2020-16017": true, "CVE-2021-37976": true, "CVE-2020-16009": true, "CVE-2021-30632": true, "CVE-2020-16013": true, "CVE-2021-30633": true, "CVE-2021-21148": true, "CVE-2021-37973": true, "CVE-2021-30551": true, "CVE-2021-37975": true, "CVE-2020-6418": true, "CVE-2021-30554": true, "CVE-2021-21206": true, "CVE-2021-38000": true, "CVE-2021-38003": true, "CVE-2021-21224": true, "CVE-2021-21193": true, "CVE-2021-21220": true, "CVE-2021-30563": true, "CVE-2020-4430": true, "CVE-2020-4427": true, "CVE-2020-4428": true, "CVE-2019-4716": true, "CVE-2016-3715": true, "CVE-2016-3718": true, "CVE-2020-15505": true, "CVE-2021-30116": true, "CVE-2020-7961": true, "CVE-2021-23874": true, "CVE-2021-22506": true, "CVE-2021-22502": true, "CVE-2014-1812": true, "CVE-2021-38647": true, "CVE-2016-0167": true, "CVE-2020-0878": true, "CVE-2021-31955": true, "CVE-2021-1647": true, "CVE-2021-33739": true, "CVE-2016-0185": true, "CVE-2020-0683": true, "CVE-2020-17087": true, "CVE-2021-33742": true, "CVE-2021-31199": true, "CVE-2021-33771": true, "CVE-2021-31956": true, "CVE-2021-31201": true, "CVE-2021-31979": true, "CVE-2020-0938": true, "CVE-2020-17144": true, "CVE-2020-0986": true, "CVE-2020-1020": true, "CVE-2021-38645": true, "CVE-2021-34523": true, "CVE-2017-7269": true, "CVE-2021-36948": true, "CVE-2021-38649": true, "CVE-2020-0688": true, "CVE-2017-0143": true, "CVE-2016-7255": true, "CVE-2019-0708": true, "CVE-2021-34473": true, "CVE-2020-1464": true, "CVE-2021-1732": true, "CVE-2021-34527": true, "CVE-2021-31207": true, "CVE-2019-0803": true, "CVE-2020-1040": true, "CVE-2021-28310": true, "CVE-2020-1350": true, "CVE-2021-26411": true, "CVE-2019-0859": true, "CVE-2021-40444": true, "CVE-2017-8759": true, "CVE-2018-8653": true, "CVE-2019-0797": true, "CVE-2021-36942": true, "CVE-2019-1215": true, "CVE-2018-0798": true, "CVE-2018-0802": true, "CVE-2012-0158": true, "CVE-2015-1641": true, "CVE-2021-27085": true, "CVE-2019-0541": true, "CVE-2017-11882": true, "CVE-2020-0674": true, "CVE-2021-27059": true, "CVE-2019-1367": true, "CVE-2017-0199": true, "CVE-2020-1380": true, "CVE-2019-1429": true, "CVE-2017-11774": true, "CVE-2020-0968": true, "CVE-2020-1472": true, "CVE-2021-26855": true, "CVE-2021-26858": true, "CVE-2021-27065": true, "CVE-2020-1054": true, "CVE-2021-1675": true, "CVE-2021-34448": true, "CVE-2020-0601": true, "CVE-2019-0604": true, "CVE-2020-0646": true, "CVE-2019-0808": true, "CVE-2021-26857": true, "CVE-2020-1147": true, "CVE-2019-1214": true, "CVE-2016-3235": true, "CVE-2019-0863": true, "CVE-2021-36955": true, "CVE-2021-38648": true, "CVE-2020-6819": true, "CVE-2020-6820": true, "CVE-2019-17026": true, "CVE-2019-15949": true, "CVE-2020-26919": true, "CVE-2019-19356": true, "CVE-2020-2555": true, "CVE-2012-3152": true, "CVE-2020-14871": true, "CVE-2015-4852": true, "CVE-2020-14750": true, "CVE-2020-14882": true, "CVE-2020-14883": true, "CVE-2020-8644": true, "CVE-2019-18935": true, "CVE-2021-22893": true, "CVE-2020-8243": true, "CVE-2021-22900": true, "CVE-2021-22894": true, "CVE-2020-8260": true, "CVE-2021-22899": true, "CVE-2019-11510": true, "CVE-2019-11539": true, "CVE-2021-1906": true, "CVE-2021-1905": true, "CVE-2020-10221": true, "CVE-2021-35395": true, "CVE-2017-16651": true, "CVE-2020-11652": true, "CVE-2020-11651": true, "CVE-2020-16846": true, "CVE-2018-2380": true, "CVE-2010-5326": true, "CVE-2016-9563": true, "CVE-2020-6287": true, "CVE-2020-6207": true, "CVE-2016-3976": true, "CVE-2019-16256": true, "CVE-2020-10148": true, "CVE-2021-35211": true, "CVE-2016-3643": true, "CVE-2020-10199": true, "CVE-2021-20021": true, "CVE-2019-7481": true, "CVE-2021-20022": true, "CVE-2021-20023": true, "CVE-2021-20016": true, "CVE-2020-12271": true, "CVE-2020-10181": true, "CVE-2017-6327": true, "CVE-2019-18988": true, "CVE-2017-9248": true, "CVE-2021-31755": true, "CVE-2020-10987": true, "CVE-2018-14558": true, "CVE-2018-20062": true, "CVE-2019-9082": true, "CVE-2019-18187": true, "CVE-2020-8467": true, "CVE-2020-8468": true, "CVE-2020-24557": true, "CVE-2020-8599": true, "CVE-2021-36742": true, "CVE-2021-36741": true, "CVE-2019-20085": true, "CVE-2020-5849": true, "CVE-2020-5847": true, "CVE-2019-16759": true, "CVE-2020-17496": true, "CVE-2019-5544": true, "CVE-2020-3992": true, "CVE-2020-3950": true, "CVE-2021-22005": true, "CVE-2020-3952": true, "CVE-2021-21972": true, "CVE-2021-21985": true, "CVE-2020-4006": true, "CVE-2020-25213": true, "CVE-2020-11738": true, "CVE-2019-9978": true, "CVE-2021-27561": true, "CVE-2021-40539": true, "CVE-2020-10189": true, "CVE-2019-8394": true, "CVE-2020-29583": true}
\ No newline at end of file
diff --git a/data/cache/source_manifest.json b/data/cache/source_manifest.json
new file mode 100644
index 00000000000..2808fb0eba1
--- /dev/null
+++ b/data/cache/source_manifest.json
@@ -0,0 +1,72 @@
+{
+  "last_run_iso": "2026-09-23T22:43:35.530306+00:00",
+  "cve_count": 396856,
+  "duration_seconds": 275.089565,
+  "commit_sha": "38ff9ea004ec0186966cda3966bb221588e2d4af",
+  "degraded": false,
+  "years_via_api": [],
+  "expected_total": 396869,
+  "completeness_ratio": 1.0,
+  "year_counts": {
+    "1999": 1579,
+    "2000": 1243,
+    "2001": 1556,
+    "2002": 2393,
+    "2003": 1555,
+    "2004": 2707,
+    "2005": 4770,
+    "2006": 7145,
+    "2007": 6580,
+    "2008": 7179,
+    "2009": 5054,
+    "2010": 5249,
+    "2011": 4899,
+    "2012": 5939,
+    "2013": 6831,
+    "2014": 9002,
+    "2015": 8779,
+    "2016": 10648,
+    "2017": 17106,
+    "2018": 17817,
+    "2019": 17624,
+    "2020": 21076,
+    "2021": 23470,
+    "2022": 27555,
+    "2023": 31444,
+    "2024": 39250,
+    "2025": 45309,
+    "2026": 63097
+  },
+  "feed_timestamps": {
+    "2002": "2026-08-28T03:04:40.240591+00:00",
+    "2003": "2026-08-28T03:04:38.841612+00:00",
+    "2004": "2026-08-28T03:04:37.194431+00:00",
+    "2005": "2026-08-28T03:04:34.380129+00:00",
+    "2006": "2026-08-28T03:04:29.783454+00:00",
+    "2007": "2026-08-28T03:04:25.261935+00:00",
+    "2008": "2026-08-28T03:04:20.277819+00:00",
+    "2009": "2026-08-28T03:04:15.689861+00:00",
+    "2010": "2026-08-28T03:04:10.899279+00:00",
+    "2011": "2026-09-15T03:03:36.390024+00:00",
+    "2012": "2026-09-18T03:02:45.991690+00:00",
+    "2013": "2026-09-15T03:03:29.371446+00:00",
+    "2014": "2026-08-28T03:03:47.765220+00:00",
+    "2015": "2026-08-28T03:03:41.728532+00:00",
+    "2016": "2026-09-23T03:03:44.442607+00:00",
+    "2017": "2026-09-23T03:03:33.327808+00:00",
+    "2018": "2026-09-19T03:03:14.220040+00:00",
+    "2019": "2026-09-23T03:03:19.980474+00:00",
+    "2020": "2026-09-23T03:03:02.715013+00:00",
+    "2021": "2026-09-23T03:02:42.612820+00:00",
+    "2022": "2026-09-23T03:02:19.780706+00:00",
+    "2023": "2026-09-23T03:01:54.627023+00:00",
+    "2024": "2026-09-23T03:01:23.730396+00:00",
+    "2025": "2026-09-23T03:00:48.574714+00:00",
+    "2026": "2026-09-23T03:00:02.494303+00:00",
+    "modified": "2026-09-23T18:00:05.766322+00:00"
+  },
+  "schema_version": 2,
+  "data_object_key": "nvd.json",
+  "bytes": 1856883164,
+  "sha256": "71b3a2aa907c684d680964813c5260ae76684ee23803a2674314af72cce4fe13"
+}
\ No newline at end of file
diff --git a/data/calendar_analysis.py b/data/calendar_analysis.py
new file mode 100644
index 00000000000..652745248c9
--- /dev/null
+++ b/data/calendar_analysis.py
@@ -0,0 +1,333 @@
+#!/usr/bin/env python3
+"""
+Calendar Analysis Module for CVEDB
+Generates daily CVE publication data for calendar heatmap visualization
+"""
+
+from __future__ import annotations
+
+import json
+from collections import defaultdict
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class CalendarAnalyzer:
+    """Analyzer for generating calendar-based CVE publication data"""
+
+    base_dir: Path
+    cache_dir: Path
+    data_dir: Path
+    quiet: bool = False
+
+    def __post_init__(self) -> None:
+        """Convert path arguments to Path objects and set up derived attributes."""
+        self.base_dir = Path(self.base_dir)
+        self.cache_dir = Path(self.cache_dir)
+        self.data_dir = Path(self.data_dir)
+        self.nvd_file: Path = self.cache_dir / "nvd.json"
+
+    def load_nvd_data(self) -> list[dict[str, Any]]:
+        """Load and parse NVD data from JSONL file"""
+        if not self.quiet:
+            logger.info("    📂 Loading NVD data for calendar analysis...")
+
+        if not self.nvd_file.exists():
+            logger.error(f"    ❌ NVD file not found: {self.nvd_file}")
+            return []
+
+        cve_records = []
+        try:
+            with open(self.nvd_file, encoding="utf-8") as f:
+                data = json.load(f)
+
+            if not self.quiet:
+                logger.info(f"    📊 Processing {len(data):,} CVE records for calendar analysis...")
+
+            for entry in data:
+                try:
+                    cve_id = entry.get("cve", {}).get("id", "")
+                    published = entry.get("cve", {}).get("published", "")
+
+                    # Extract CVSS score (try v3.1 first, then v3.0, then v2.0)
+                    cvss_score = None
+                    metrics = entry.get("cve", {}).get("metrics", {})
+
+                    if "cvssMetricV31" in metrics and metrics["cvssMetricV31"]:
+                        cvss_score = metrics["cvssMetricV31"][0].get("cvssData", {}).get("baseScore")
+                    elif "cvssMetricV30" in metrics and metrics["cvssMetricV30"]:
+                        cvss_score = metrics["cvssMetricV30"][0].get("cvssData", {}).get("baseScore")
+                    elif "cvssMetricV2" in metrics and metrics["cvssMetricV2"]:
+                        cvss_score = metrics["cvssMetricV2"][0].get("cvssData", {}).get("baseScore")
+
+                    # Skip rejected CVEs
+                    status = entry.get("cve", {}).get("vulnStatus", "")
+                    if "Rejected" in status:
+                        continue
+
+                    if cve_id and published:
+                        cve_records.append({"cve_id": cve_id, "published": published, "cvss_score": cvss_score})
+
+                except (KeyError, TypeError, ValueError):
+                    continue  # Skip malformed entries
+
+            if not self.quiet:
+                logger.info(f"    ✅ Loaded {len(cve_records):,} valid CVE records")
+            return cve_records
+
+        except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+            logger.error(f"    ❌ Error loading NVD data: {e}")
+            return []
+
+    def process_daily_data(self, cve_records: list[dict[str, Any]]) -> dict[str, dict[str, Any]]:
+        """Process CVE records into daily publication counts"""
+        if not self.quiet:
+            logger.info("    📅 Processing daily CVE publication data...")
+
+        daily_counts: dict[str, int] = defaultdict(int)
+        daily_scores: dict[str, list[float]] = defaultdict(list)
+
+        for record in cve_records:
+            try:
+                # Parse publication date
+                pub_date = datetime.fromisoformat(record["published"].replace("Z", "+00:00"))
+                date_key = pub_date.strftime("%Y-%m-%d")
+
+                daily_counts[date_key] += 1
+
+                if record["cvss_score"] is not None:
+                    daily_scores[date_key].append(record["cvss_score"])
+
+            except (ValueError, KeyError, TypeError):
+                continue  # Skip invalid dates
+
+        # Calculate daily averages
+        daily_data = {}
+        for date_key, count in daily_counts.items():
+            scores = daily_scores.get(date_key, [])
+
+            entry: dict[str, Any] = {
+                "date": date_key,
+                "count": count,
+            }
+            # Only include CVSS fields when there is actual score data
+            if scores:
+                entry["avg_cvss_score"] = round(float(np.mean(scores)), 1)
+                entry["cvss_count"] = len(scores)
+
+            daily_data[date_key] = entry
+
+        if not self.quiet:
+            logger.info(f"    ✅ Processed {len(daily_data):,} days of CVE data")
+        return daily_data
+
+    def calculate_statistics(
+        self, daily_data: dict[str, dict[str, Any]], cve_records: list[dict[str, Any]]
+    ) -> dict[str, Any]:
+        """Calculate overall statistics for the calendar analysis"""
+        if not self.quiet:
+            logger.info("    📊 Calculating calendar statistics...")
+
+        total_cves = len(cve_records)
+        total_days = len(daily_data)
+
+        # Calculate date range
+        dates = [datetime.strptime(date_key, "%Y-%m-%d") for date_key in daily_data]
+        start_date = min(dates) if dates else datetime.now()
+        end_date = max(dates) if dates else datetime.now()
+
+        # Calculate averages
+        daily_counts = [data["count"] for data in daily_data.values()]
+        avg_per_day = np.mean(daily_counts) if daily_counts else 0
+        max_per_day = max(daily_counts) if daily_counts else 0
+        min_per_day = min(daily_counts) if daily_counts else 0
+
+        # Find peak day
+        peak_day_data = max(daily_data.values(), key=lambda x: x["count"]) if daily_data else None
+
+        # Calculate CVSS statistics
+        cvss_scores = [record["cvss_score"] for record in cve_records if record["cvss_score"] is not None]
+        avg_cvss = np.mean(cvss_scores) if cvss_scores else None
+
+        # Calculate current year statistics
+        current_year = datetime.now().year
+        current_year_data = {k: v for k, v in daily_data.items() if k.startswith(str(current_year))}
+        current_year_cves = sum(data["count"] for data in current_year_data.values())
+
+        statistics = {
+            "total_cves": total_cves,
+            "total_days_with_data": total_days,
+            "date_range": {"start": start_date.strftime("%Y-%m-%d"), "end": end_date.strftime("%Y-%m-%d")},
+            "daily_stats": {
+                "average_per_day": round(avg_per_day, 2),
+                "max_per_day": max_per_day,
+                "min_per_day": min_per_day,
+                "peak_day": {
+                    "date": peak_day_data["date"] if peak_day_data else None,
+                    "count": peak_day_data["count"] if peak_day_data else 0,
+                },
+            },
+            "cvss_stats": {
+                "average_score": round(avg_cvss, 2) if avg_cvss else None,
+                "total_with_scores": len(cvss_scores),
+            },
+            "current_year": {
+                "year": current_year,
+                "total_cves": current_year_cves,
+                "days_with_data": len(current_year_data),
+            },
+        }
+
+        return statistics
+
+    def generate_calendar_analysis(self) -> dict[str, Any] | None:
+        """Generate comprehensive calendar analysis"""
+        logger.info("  📅 Generating calendar analysis...")
+
+        # Load CVE data
+        cve_records = self.load_nvd_data()
+        if not cve_records:
+            logger.error("  ❌ No CVE data available for calendar analysis")
+            return None
+
+        # Process daily data
+        daily_data = self.process_daily_data(cve_records)
+        if not daily_data:
+            logger.error("  ❌ No daily data generated")
+            return None
+
+        # Calculate statistics
+        statistics = self.calculate_statistics(daily_data, cve_records)
+
+        # Prepare calendar data for frontend
+        calendar_data = []
+        for date_key, data in daily_data.items():
+            entry: dict[str, Any] = {
+                "date": date_key,
+                "value": data["count"],
+            }
+            # Only include CVSS fields when score data exists (saves ~bytes per entry)
+            if "avg_cvss_score" in data:
+                entry["avg_cvss"] = data["avg_cvss_score"]
+                entry["cvss_count"] = data["cvss_count"]
+            calendar_data.append(entry)
+
+        # Sort by date
+        calendar_data.sort(key=lambda x: x["date"])
+
+        analysis_result = {
+            "generated_at": datetime.now().isoformat(),
+            "statistics": statistics,
+            "daily_data": calendar_data,
+            "metadata": {
+                "total_records": len(cve_records),
+                "total_days": len(daily_data),
+                "data_source": "NVD JSONL",
+                "analysis_type": "calendar_heatmap",
+            },
+        }
+
+        # Save to file
+        output_file = self.data_dir / "calendar_analysis.json"
+        with open(output_file, "w") as f:
+            json.dump(analysis_result, f, indent=2)
+
+        if not self.quiet:
+            logger.info(f"  ✅ Generated calendar analysis with {len(calendar_data):,} days of data")
+        return analysis_result
+
+    def generate_current_year_calendar_analysis(self) -> dict[str, Any] | None:
+        """Generate current year specific calendar analysis"""
+        logger.info("  📅 Generating current year calendar analysis...")
+
+        # Load full analysis first
+        full_analysis = self.generate_calendar_analysis()
+        if not full_analysis:
+            return None
+
+        current_year = datetime.now().year
+
+        # Filter for current year data
+        current_year_daily = [
+            data for data in full_analysis["daily_data"] if data["date"].startswith(str(current_year))
+        ]
+
+        # Calculate current year statistics
+        if current_year_daily:
+            total_cves = sum(data["value"] for data in current_year_daily)
+            avg_per_day = total_cves / len(current_year_daily) if current_year_daily else 0
+            max_day = max(current_year_daily, key=lambda x: x["value"]) if current_year_daily else None
+
+            # Calculate CVSS average for current year
+            cvss_scores = [data["avg_cvss"] for data in current_year_daily if data.get("avg_cvss") is not None]
+            avg_cvss = np.mean(cvss_scores) if cvss_scores else None
+
+            current_year_stats = {
+                "year": current_year,
+                "total_cves": total_cves,
+                "total_days_with_data": len(current_year_daily),
+                "average_per_day": round(avg_per_day, 2),
+                "peak_day": {"date": max_day["date"] if max_day else None, "count": max_day["value"] if max_day else 0},
+                "average_cvss": round(avg_cvss, 2) if avg_cvss else None,
+            }
+        else:
+            current_year_stats = {
+                "year": current_year,
+                "total_cves": 0,
+                "total_days_with_data": 0,
+                "average_per_day": 0,
+                "peak_day": {"date": None, "count": 0},
+                "average_cvss": None,
+            }
+
+        current_year_analysis = {
+            "generated_at": datetime.now().isoformat(),
+            "statistics": current_year_stats,
+            "daily_data": current_year_daily,
+            "metadata": {
+                "year": current_year,
+                "total_days": len(current_year_daily),
+                "data_source": "NVD JSONL",
+                "analysis_type": "current_year_calendar",
+            },
+        }
+
+        # Save to file
+        output_file = self.data_dir / "calendar_analysis_current_year.json"
+        with open(output_file, "w") as f:
+            json.dump(current_year_analysis, f, indent=2)
+
+        if not self.quiet:
+            logger.info(f"  ✅ Generated current year calendar analysis with {len(current_year_daily):,} days")
+        return current_year_analysis
+
+
+if __name__ == "__main__":
+    # Test the analyzer
+    base_dir = Path(__file__).parent.parent
+    cache_dir = base_dir / "data" / "cache"
+    data_dir = base_dir / "web" / "data"
+
+    analyzer = CalendarAnalyzer(base_dir, cache_dir, data_dir)
+
+    logger.info("🗓️  Testing Calendar Analysis...")
+    comprehensive_analysis = analyzer.generate_calendar_analysis()
+    current_year_analysis = analyzer.generate_current_year_calendar_analysis()
+
+    if comprehensive_analysis and current_year_analysis:
+        logger.info("✅ Calendar analysis test completed successfully!")
+    else:
+        logger.error("❌ Calendar analysis test failed!")
diff --git a/data/cna_analysis.py b/data/cna_analysis.py
new file mode 100644
index 00000000000..66fb984386f
--- /dev/null
+++ b/data/cna_analysis.py
@@ -0,0 +1,601 @@
+#!/usr/bin/env python3
+"""
+CNA Analysis Module
+Handles all CNA (CVE Numbering Authority) related data processing and analysis
+"""
+
+from __future__ import annotations
+
+import json
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class CNAAnalyzer:
+    """Handles CNA-specific analysis and data processing"""
+
+    base_dir: Path
+    cache_dir: Path
+    data_dir: Path
+    quiet: bool = False
+    current_year: int = field(default_factory=lambda: datetime.now().year)
+    kev_cve_set: set[str] = field(default_factory=set, init=False)
+    epss_data: dict[str, dict[str, float]] = field(default_factory=dict, init=False)
+
+    def __post_init__(self) -> None:
+        """Convert path arguments and load threat intelligence data."""
+        self.base_dir = Path(self.base_dir)
+        self.cache_dir = Path(self.cache_dir)
+        self.data_dir = Path(self.data_dir)
+        # Pre-load threat intelligence data for per-CNA metrics
+        self.kev_cve_set = self._load_kev_set()
+        self.epss_data = self._load_epss_data()
+
+    def _load_kev_set(self) -> set[str]:
+        """Load KEV CVE IDs into a set for fast lookup"""
+        kev_file = self.cache_dir / "known_exploited_vulnerabilities_parsed.json"
+        if kev_file.exists():
+            try:
+                with open(kev_file) as f:
+                    kev_data = json.load(f)
+                return set(kev_data.keys())
+            except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+                logger.warning(f"    ⚠️ Error loading KEV data: {e}")
+        return set()
+
+    def _load_epss_data(self) -> dict[str, dict[str, float]]:
+        """Load EPSS scores for CVE lookup"""
+        epss_file = self.cache_dir / "epss_scores-current.json"
+        if epss_file.exists():
+            try:
+                with open(epss_file) as f:
+                    data: dict[str, dict[str, float]] = json.load(f)
+                    return data
+            except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+                logger.warning(f"    ⚠️ Error loading EPSS data: {e}")
+        return {}
+
+    def load_cna_name_mappings(self) -> dict[str, str]:
+        """Load CNA name mappings for UUID resolution"""
+        logger.info("    🗺️ Loading CNA name mappings...")
+        mappings = {}
+
+        # Load from cna_name_map.json (UUID to name mappings)
+        cna_name_map_file = self.cache_dir / "cna_name_map.json"
+        if cna_name_map_file.exists():
+            try:
+                with open(cna_name_map_file) as f:
+                    data = json.load(f)
+
+                # Handle different data structures
+                if isinstance(data, dict) and "data" in data:
+                    # Structure: {"data": [...]}
+                    for entry in data["data"]:
+                        if isinstance(entry, dict) and "uuid" in entry and "name" in entry:
+                            mappings[entry["uuid"]] = entry["name"]
+                elif isinstance(data, list):
+                    # Structure: [{"uuid": "...", "name": "..."}, ...]
+                    for entry in data:
+                        if isinstance(entry, dict) and "uuid" in entry and "name" in entry:
+                            mappings[entry["uuid"]] = entry["name"]
+                elif isinstance(data, dict):
+                    # Direct UUID to name mapping
+                    mappings.update(data)
+
+                logger.info(f"    ✅ Loaded {len(mappings)} UUID mappings from cna_name_map.json")
+            except (FileNotFoundError, json.JSONDecodeError, KeyError, OSError) as e:
+                logger.warning(f"    ⚠️ Error loading cna_name_map.json: {e}")
+
+        return mappings
+
+    def load_official_cna_list(self) -> list[dict[str, Any]]:
+        """Load official CNA list for comprehensive analysis"""
+        logger.info("    📋 Loading official CNA list...")
+        official_cnas = []
+
+        cna_list_file = self.cache_dir / "cna_list.json"
+        if cna_list_file.exists():
+            try:
+                with open(cna_list_file) as f:
+                    data = json.load(f)
+
+                # Handle different data structures
+                if isinstance(data, dict) and "data" in data:
+                    official_cnas = data["data"]
+                elif isinstance(data, list):
+                    official_cnas = data
+
+                logger.info(f"    ✅ Loaded {len(official_cnas)} official CNAs from cna_list.json")
+            except (FileNotFoundError, json.JSONDecodeError, KeyError, OSError) as e:
+                logger.warning(f"    ⚠️ Error loading cna_list.json: {e}")
+
+        return official_cnas
+
+    def resolve_cna_name(self, source_identifier: str | None, mappings: dict[str, str]) -> str:
+        """Resolve CNA name from source identifier using various methods"""
+        if not source_identifier:
+            return "Unknown"
+
+        # Check UUID mapping first
+        if source_identifier in mappings:
+            return mappings[source_identifier]
+
+        # Domain-based mappings
+        domain_mappings = {
+            "mitre.org": "MITRE Corporation",
+            "cve@mitre.org": "MITRE Corporation",
+            "patchstack.com": "Patchstack",
+            "wordfence.com": "Wordfence",
+            "microsoft.com": "Microsoft Corporation",
+            "apple.com": "Apple Inc.",
+            "google.com": "Google LLC",
+            "redhat.com": "Red Hat Inc.",
+            "debian.org": "Debian",
+            "ubuntu.com": "Canonical Ltd.",
+            "suse.com": "SUSE",
+            "oracle.com": "Oracle Corporation",
+            "ibm.com": "IBM Corporation",
+            "cisco.com": "Cisco Systems Inc.",
+            "adobe.com": "Adobe Inc.",
+            "mozilla.org": "Mozilla Foundation",
+        }
+
+        # Check domain mappings
+        for domain, name in domain_mappings.items():
+            if domain in source_identifier.lower():
+                return name
+
+        # Clean up the identifier for display
+        if "@" in source_identifier:
+            domain = source_identifier.split("@")[-1]
+            return domain.replace(".com", "").replace(".org", "").title()
+
+        # Return cleaned identifier
+        return source_identifier.replace("_", " ").title()
+
+    def process_cna_type_distribution(
+        self, official_cnas: list[dict[str, Any]], cna_stats: dict[str, dict[str, Any]]
+    ) -> dict[str, Any]:
+        """Process CNA type distribution from official data"""
+        logger.info("    📊 Processing CNA type distribution...")
+
+        type_counts: defaultdict[str, int] = defaultdict(int)
+
+        # Count types from official CNAs using correct nested structure
+        for cna in official_cnas:
+            # Use the correct nested path: CNA.type
+            cna_types = cna.get("CNA", {}).get("type", [])
+            if not isinstance(cna_types, list):
+                cna_types = [cna_types] if cna_types else ["Unknown"]
+
+            for cna_type in cna_types:
+                if cna_type and cna_type != "Unknown":
+                    type_counts[cna_type] += 1
+
+        # Calculate percentages using dict comprehension
+        total_official = len(official_cnas)
+        type_percentages = (
+            {cna_type: round((count / total_official) * 100, 1) for cna_type, count in type_counts.items()}
+            if total_official > 0
+            else {}
+        )
+
+        # Sort by count (descending)
+        sorted_types = sorted(type_counts.items(), key=lambda x: x[1], reverse=True)
+
+        return {
+            "type_counts": dict(type_counts),
+            "type_percentages": type_percentages,
+            "sorted_types": sorted_types,
+            "total_official_cnas": total_official,
+        }
+
+    def generate_comprehensive_cna_analysis(self, all_year_data: list[dict[str, Any]]) -> dict[str, Any]:
+        """Generate comprehensive CNA analysis processing all CVEs and official CNA data"""
+        logger.info("  🏢 Generating comprehensive CNA analysis...")
+
+        # Load CNA mappings and official data
+        mappings = self.load_cna_name_mappings()
+        official_cnas = self.load_official_cna_list()
+
+        # Process CVE data to extract CNA statistics
+        cna_stats = {}
+
+        # Load CVE data from cache
+        nvd_file = self.cache_dir / "nvd.json"
+        if nvd_file.exists():
+            if not self.quiet:
+                logger.info(f"    📂 Loading CVE data from {nvd_file}...")
+            with open(nvd_file) as f:
+                cve_data = json.load(f)
+
+            logger.info(f"    📊 Processing {len(cve_data)} CVEs for comprehensive CNA analysis...")
+
+            for i, cve_entry in enumerate(cve_data):
+                if i % 50000 == 0 and i > 0 and not self.quiet:
+                    logger.debug(f"    📊 Processed {i:,} CVEs...")
+
+                try:
+                    cve_section = cve_entry.get("cve", {})
+                    cve_id = cve_section.get("id", "")
+                    vuln_status = cve_section.get("vulnStatus", "")
+
+                    # Keep counting logic aligned with yearly/cve_all outputs.
+                    if "Rejected" in vuln_status:
+                        continue
+
+                    if source_identifier := cve_section.get("sourceIdentifier", ""):
+                        cna_name = self.resolve_cna_name(source_identifier, mappings)
+
+                        if cna_name and cna_name != "Unknown":
+                            if cna_name not in cna_stats:
+                                cna_stats[cna_name] = {
+                                    "count": 0,
+                                    "first_cve_date": cve_section.get("published", ""),
+                                    "last_cve_date": cve_section.get("published", ""),
+                                    "first_cve_year": None,
+                                    "last_cve_year": None,
+                                    "source_identifier": source_identifier,
+                                    # Threat intelligence per CNA
+                                    "kev_count": 0,
+                                    "epss_high_count": 0,  # EPSS > 0.5
+                                    "epss_elevated_count": 0,  # EPSS > 0.1
+                                    "cwe_counts": {},  # CWE tracking
+                                }
+
+                            cna_stats[cna_name]["count"] += 1
+
+                            # Track KEV membership
+                            if cve_id in self.kev_cve_set:
+                                cna_stats[cna_name]["kev_count"] += 1
+
+                            # Track EPSS scores
+                            if cve_id in self.epss_data:
+                                epss_score = self.epss_data[cve_id].get("epss_score", 0)
+                                if epss_score > 0.5:
+                                    cna_stats[cna_name]["epss_high_count"] += 1
+                                if epss_score > 0.1:
+                                    cna_stats[cna_name]["epss_elevated_count"] += 1
+
+                            # Track CWEs for this CNA
+                            weaknesses = cve_section.get("weaknesses", [])
+                            for weakness in weaknesses:
+                                for desc in weakness.get("description", []):
+                                    cwe_val = desc.get("value", "")
+                                    if cwe_val and cwe_val.startswith("CWE-") and cwe_val != "CWE-Other":
+                                        cna_stats[cna_name]["cwe_counts"][cwe_val] = (
+                                            cna_stats[cna_name]["cwe_counts"].get(cwe_val, 0) + 1
+                                        )
+
+                            # Update date tracking
+                            if pub_date := cve_section.get("published", ""):
+                                if (
+                                    pub_date < cna_stats[cna_name]["first_cve_date"]
+                                    or not cna_stats[cna_name]["first_cve_date"]
+                                ):
+                                    cna_stats[cna_name]["first_cve_date"] = pub_date
+                                if pub_date > cna_stats[cna_name]["last_cve_date"]:
+                                    cna_stats[cna_name]["last_cve_date"] = pub_date
+
+                                # Extract year from CVE ID
+                                if cve_id.startswith("CVE-"):
+                                    year = int(cve_id.split("-")[1])
+                                    if (
+                                        cna_stats[cna_name]["first_cve_year"] is None
+                                        or year < cna_stats[cna_name]["first_cve_year"]
+                                    ):
+                                        cna_stats[cna_name]["first_cve_year"] = year
+                                    if (
+                                        cna_stats[cna_name]["last_cve_year"] is None
+                                        or year > cna_stats[cna_name]["last_cve_year"]
+                                    ):
+                                        cna_stats[cna_name]["last_cve_year"] = year
+
+                except (KeyError, ValueError, TypeError):
+                    continue
+
+            if not self.quiet:
+                logger.info(f"    ✅ Processed all CVEs, found {len(cna_stats)} CNAs with published CVEs")
+
+        # Create comprehensive CNA list with official data integration
+        cna_list = []
+        official_cna_names = {cna.get("organizationName", "") for cna in official_cnas}
+
+        # Process CNAs with published CVEs
+        for cna_name, stats in cna_stats.items():
+            # Find matching official CNA data
+            official_info = None
+            for cna in official_cnas:
+                if cna.get("organizationName") == cna_name:
+                    official_info = cna
+                    break
+
+            # Calculate years active based on CNA designation year (from cnaID) not CVE publication dates
+            years_active = 1
+            cna_designation_year = None
+
+            # Extract CNA designation year from official CNA data if available
+            if official_info and "cnaID" in official_info:
+                cna_id = official_info["cnaID"]
+                # Extract year from cnaID format like "CNA-2005-0001"
+                try:
+                    if cna_id.startswith("CNA-") and len(cna_id) >= 8:
+                        year_part = cna_id[4:8]  # Extract "2005" from "CNA-2005-0001"
+                        if year_part.isdigit():
+                            extracted_year = int(year_part)
+                            # Validate: CNA program started in 2005, so no CNA can be older
+                            if extracted_year >= 2005:
+                                cna_designation_year = extracted_year
+                                years_active = max(1, self.current_year - cna_designation_year + 1)
+                            else:
+                                # If cnaID contains pre-2005 year, use 2005 as earliest possible
+                                cna_designation_year = 2005
+                                years_active = max(1, self.current_year - 2005 + 1)
+                except (ValueError, IndexError):
+                    pass
+
+            # Fallback: if no cnaID available, use CVE publication date range (old method)
+            if cna_designation_year is None and stats["first_cve_year"] and stats["last_cve_year"]:
+                calculated_years = max(1, stats["last_cve_year"] - stats["first_cve_year"] + 1)
+                # Validate: No CNA can be older than the CNA program (started 2005)
+                # Maximum possible years active = current_year - 2005 + 1
+                max_possible_years = self.current_year - 2005 + 1
+                years_active = min(calculated_years, max_possible_years)
+
+            # Calculate days since last CVE
+            days_since_last = 0
+            if stats["last_cve_date"]:
+                try:
+                    last_date = datetime.fromisoformat(stats["last_cve_date"].replace("Z", "+00:00"))
+                    days_since_last = (datetime.now() - last_date.replace(tzinfo=None)).days
+                except (ValueError, TypeError):
+                    days_since_last = 365  # Default to inactive if date parsing fails
+
+            # Determine activity status
+            activity_status = "Active" if days_since_last < 365 else "Inactive"
+
+            cna_entry = {
+                "name": cna_name,
+                "count": stats["count"],
+                "years_active": years_active,
+                "first_cve_year": stats["first_cve_year"],
+                "last_cve_year": stats["last_cve_year"],
+                "first_cve_date": stats["first_cve_date"],
+                "last_cve_date": stats["last_cve_date"],
+                "days_since_last_cve": days_since_last,
+                "activity_status": activity_status,
+                "official_info": official_info,
+                "is_official": cna_name in official_cna_names,
+                "cna_types": official_info.get("CNA", {}).get("type", ["Unknown"]) if official_info else ["Unknown"],
+                # Threat intelligence metrics
+                "kev_count": stats.get("kev_count", 0),
+                "epss_high_count": stats.get("epss_high_count", 0),
+                "epss_elevated_count": stats.get("epss_elevated_count", 0),
+                "top_cwes": sorted(stats.get("cwe_counts", {}).items(), key=lambda x: x[1], reverse=True)[:5],
+            }
+            cna_list.append(cna_entry)
+
+        # Add official CNAs that don't have published CVEs
+        for cna in official_cnas:
+            cna_name = cna.get("organizationName", "")
+            if cna_name and cna_name not in cna_stats:
+                cna_entry = {
+                    "name": cna_name,
+                    "count": 0,
+                    "years_active": 0,
+                    "first_cve_year": None,
+                    "last_cve_year": None,
+                    "first_cve_date": "",
+                    "last_cve_date": "",
+                    "days_since_last_cve": 999999,  # Very high number for never published
+                    "activity_status": "Never Published",
+                    "official_info": cna,
+                    "is_official": True,
+                    "cna_types": cna.get("CNA", {}).get("type", ["Unknown"]),
+                    # Threat intelligence metrics (zeros for CNAs with no CVEs)
+                    "kev_count": 0,
+                    "epss_high_count": 0,
+                    "epss_elevated_count": 0,
+                    "top_cwes": [],
+                }
+                cna_list.append(cna_entry)
+
+        # Sort by CVE count (descending)
+        cna_list.sort(key=lambda x: x["count"], reverse=True)
+
+        # Process type distribution
+        type_distribution = self.process_cna_type_distribution(official_cnas, cna_stats)
+
+        # Create comprehensive analysis structure
+        analysis_data = {
+            "generated_at": datetime.now().isoformat(),
+            "total_cnas": len(cna_list),
+            "active_cnas": len([c for c in cna_list if c["activity_status"] == "Active"]),
+            "inactive_cnas": len([c for c in cna_list if c["activity_status"] == "Inactive"]),
+            "never_published_cnas": len([c for c in cna_list if c["activity_status"] == "Never Published"]),
+            "official_cnas": len([c for c in cna_list if c["is_official"]]),
+            "unofficial_cnas": len([c for c in cna_list if not c["is_official"]]),
+            "cna_list": cna_list,
+            "type_distribution": type_distribution,
+        }
+
+        # Save to file
+        output_file = self.data_dir / "cna_analysis.json"
+        with open(output_file, "w") as f:
+            json.dump(analysis_data, f, indent=2)
+
+        logger.info(f"  ✅ Generated comprehensive CNA analysis with {len(cna_list)} CNAs")
+        return analysis_data
+
+    def generate_current_year_cna_analysis(self, current_year_data: dict[str, Any]) -> dict[str, Any]:
+        """Generate current year CNA analysis by filtering comprehensive analysis for current year CVEs"""
+        logger.info(f"    🏢 Generating current year CNA analysis for {self.current_year}...")
+
+        # Load comprehensive CNA analysis first to get all CNA data
+        comprehensive_file = self.data_dir / "cna_analysis.json"
+        comprehensive_data = {}
+
+        if comprehensive_file.exists():
+            with open(comprehensive_file) as f:
+                comprehensive_data = json.load(f)
+            logger.info(
+                f"    ✅ Loaded comprehensive CNA analysis with {len(comprehensive_data.get('cna_list', []))} CNAs"
+            )
+        else:
+            logger.warning("    ⚠️ No comprehensive CNA analysis found, generating from scratch...")
+            # Generate comprehensive analysis if it doesn't exist
+            comprehensive_data = self.generate_comprehensive_cna_analysis([])
+
+        # Filter comprehensive data for current year CNAs
+        current_year_cnas: list[dict[str, Any]] = []
+        cna_counts: dict[str, int] = {}
+
+        # Process all CNAs from comprehensive analysis
+        for cna in comprehensive_data.get("cna_list", []):
+            cna_name = cna.get("name", "")
+            last_cve_year = cna.get("last_cve_year", 0)
+
+            # Include CNAs that published CVEs in current year
+            if last_cve_year == self.current_year:
+                # Create current year CNA entry
+                current_year_cna = {
+                    "name": cna_name,
+                    "count": 0,  # We'll calculate this from the raw data if available
+                    "rank": len(current_year_cnas) + 1,
+                    "years_active": cna.get("years_active", 1),
+                    "first_cve_year": cna.get("first_cve_year", self.current_year),
+                    "last_cve_year": self.current_year,
+                    "first_cve_date": cna.get("first_cve_date", f"{self.current_year}-01-01T00:00:00"),
+                    "last_cve_date": cna.get("last_cve_date", f"{self.current_year}-12-31T23:59:59"),
+                    "days_since_last_cve": 0,  # Active in current year
+                    "activity_status": "Active",
+                    "severity_distribution": cna.get("severity_distribution", {}),
+                    "top_cwe_types": cna.get("top_cwe_types", {}),
+                    "official_info": cna.get("official_info"),
+                    "is_official": cna.get("is_official", True),
+                    "cna_types": cna.get("cna_types", ["Unknown"]),
+                    # Threat intelligence metrics - inherited from comprehensive analysis
+                    "kev_count": cna.get("kev_count", 0),
+                    "epss_high_count": cna.get("epss_high_count", 0),
+                    "epss_elevated_count": cna.get("epss_elevated_count", 0),
+                    "top_cwes": cna.get("top_cwes", []),
+                }
+                current_year_cnas.append(current_year_cna)
+                cna_counts[cna_name] = current_year_cna["count"]
+
+        # If we have access to raw CVE data for current year, get actual counts
+        nvd_file = self.cache_dir / "nvd.json"
+        if nvd_file.exists() and len(current_year_cnas) > 0:
+            logger.info(f"    📊 Calculating actual CVE counts for {self.current_year}...")
+            try:
+                with open(nvd_file) as f:
+                    cve_data = json.load(f)
+
+                # Count current year CVEs by CNA
+                mappings = self.load_cna_name_mappings()
+                actual_counts: dict[str, int] = {}
+
+                for cve_entry in cve_data:
+                    try:
+                        cve_section = cve_entry.get("cve", {})
+                        cve_id = cve_section.get("id", "")
+                        vuln_status = cve_section.get("vulnStatus", "")
+
+                        if cve_id.startswith(f"CVE-{self.current_year}-") and "Rejected" not in vuln_status:
+                            source_identifier = cve_section.get("sourceIdentifier", "")
+                            if source_identifier:
+                                cna_name = self.resolve_cna_name(source_identifier, mappings)
+                                if cna_name:
+                                    actual_counts[cna_name] = actual_counts.get(cna_name, 0) + 1
+                    except (KeyError, TypeError, AttributeError):
+                        continue
+
+                # Update counts in current year CNAs
+                for cna in current_year_cnas:
+                    cna_name = cna["name"]
+                    if cna_name in actual_counts:
+                        cna["count"] = actual_counts[cna_name]
+
+                logger.info(f"    ✅ Updated actual CVE counts for {len(actual_counts)} CNAs")
+
+            except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+                logger.warning(f"    ⚠️ Could not calculate actual counts: {e}")
+
+        # Sort by count (descending)
+        current_year_cnas.sort(key=lambda x: x["count"], reverse=True)
+
+        # Update ranks
+        for i, cna in enumerate(current_year_cnas):
+            cna["rank"] = i + 1
+
+        logger.info(f"    ✅ Found {len(current_year_cnas)} CNAs active in {self.current_year}")
+
+        # Calculate type distribution for current year
+        type_distribution = self._calculate_type_distribution_for_current_year(current_year_cnas)
+
+        # Create current year data structure. No "cna_assigners" alias: it held the
+        # same list as cna_list and nothing consumed it.
+        current_year_cna_data = {
+            "generated_at": datetime.now().isoformat(),
+            "year": self.current_year,
+            "total_cnas": len(current_year_cnas),
+            "active_cnas": len(current_year_cnas),  # All are active in current year
+            "inactive_cnas": 0,
+            "never_published_cnas": 0,
+            "official_cnas": len([c for c in current_year_cnas if c.get("is_official", True)]),
+            "unofficial_cnas": len([c for c in current_year_cnas if not c.get("is_official", True)]),
+            "cna_list": current_year_cnas,  # For consistency with all-time data
+            "type_distribution": type_distribution,
+        }
+
+        # Save current year analysis
+        current_year_file = self.data_dir / "cna_analysis_current_year.json"
+        with open(current_year_file, "w") as f:
+            json.dump(current_year_cna_data, f, indent=2)
+
+        logger.info(f"    📄 Generated enhanced cna_analysis_current_year.json with {len(current_year_cnas)} CNAs")
+        return current_year_cna_data
+
+    def _calculate_type_distribution_for_current_year(self, cna_assigners: list[dict[str, Any]]) -> dict[str, Any]:
+        """Calculate CNA type distribution for current year data"""
+        type_counts: defaultdict[str, int] = defaultdict(int)
+
+        # Count types from current year CNAs
+        for cna in cna_assigners:
+            cna_types = cna.get("cna_types", ["Unknown"])
+            if not isinstance(cna_types, list):
+                cna_types = [cna_types] if cna_types else ["Unknown"]
+
+            for cna_type in cna_types:
+                if cna_type:
+                    type_counts[cna_type] += 1
+
+        # Calculate percentages using dict comprehension
+        total_cnas = len(cna_assigners)
+        type_percentages = (
+            {cna_type: round((count / total_cnas) * 100, 1) for cna_type, count in type_counts.items()}
+            if total_cnas > 0
+            else {}
+        )
+
+        # Sort by count (descending)
+        sorted_types = sorted(type_counts.items(), key=lambda x: x[1], reverse=True)
+
+        return {
+            "type_counts": dict(type_counts),
+            "type_percentages": type_percentages,
+            "sorted_types": sorted_types,
+            "total_official_cnas": total_cnas,
+        }
diff --git a/data/cpe_analysis.py b/data/cpe_analysis.py
new file mode 100644
index 00000000000..27a6b21fbcf
--- /dev/null
+++ b/data/cpe_analysis.py
@@ -0,0 +1,415 @@
+#!/usr/bin/env python3
+"""
+CPE Analysis Module
+Handles all CPE (Common Platform Enumeration) related data processing and analysis
+"""
+
+from __future__ import annotations
+
+import json
+from collections import Counter
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class CPEAnalyzer:
+    """Handles CPE-specific analysis and data processing"""
+
+    base_dir: Path
+    cache_dir: Path
+    data_dir: Path
+    quiet: bool = False
+    current_year: int = field(default_factory=lambda: datetime.now().year)
+
+    def __post_init__(self) -> None:
+        """Convert path arguments to Path objects if needed."""
+        self.base_dir = Path(self.base_dir)
+        self.cache_dir = Path(self.cache_dir)
+        self.data_dir = Path(self.data_dir)
+
+    def extract_cpe_vendor(self, cpe_string: str) -> str:
+        """Extract vendor from CPE string (cpe:2.3:a:vendor:product:...)"""
+        try:
+            parts = cpe_string.split(":")
+            if len(parts) >= 4:
+                return parts[3]  # vendor is at index 3
+            return "unknown"
+        except (TypeError, AttributeError, IndexError):
+            return "unknown"
+
+    def extract_cpe_product(self, cpe_string: str) -> str:
+        """Extract product from CPE string (cpe:2.3:a:vendor:product:...)"""
+        try:
+            parts = cpe_string.split(":")
+            if len(parts) >= 5:
+                return parts[4]  # product is at index 4
+            return "unknown"
+        except (TypeError, AttributeError, IndexError):
+            return "unknown"
+
+    def extract_cpe_type(self, cpe_string: str) -> str:
+        """Extract CPE type from CPE string (a=application, o=operating_system, h=hardware)"""
+        try:
+            parts = cpe_string.split(":")
+            if len(parts) >= 3:
+                cpe_type = parts[2]
+                type_map = {"a": "Application", "o": "Operating System", "h": "Hardware"}
+                return type_map.get(cpe_type, "Unknown")
+            return "Unknown"
+        except (TypeError, AttributeError, IndexError):
+            return "Unknown"
+
+    def generate_cpe_analysis(self, all_year_data: list[dict[str, Any]]) -> dict[str, Any]:
+        """Generate CPE analysis across all years"""
+        if not self.quiet:
+            logger.info("  🔍 Generating CPE analysis...")
+
+        # Process raw CVE data to extract CPE information
+        cpe_data = self._process_cpe_data_from_cache()
+
+        if not cpe_data:
+            logger.warning("  ⚠️  No CPE data found, generating minimal analysis")
+            return self._generate_minimal_cpe_analysis()
+
+        # Analyze CPE patterns
+        cpe_counts = Counter(cpe_data["cpe_list"])
+        vendor_counts = Counter(cpe_data["vendor_list"])
+        product_counts = Counter(cpe_data["product_list"])
+        type_counts = Counter(cpe_data["type_list"])
+
+        # Get top CPEs
+        top_cpes = []
+        for cpe, count in cpe_counts.most_common(50):
+            vendor = self.extract_cpe_vendor(cpe)
+            product = self.extract_cpe_product(cpe)
+            cpe_type = self.extract_cpe_type(cpe)
+
+            top_cpes.append({"cpe": cpe, "count": count, "vendor": vendor, "product": product, "type": cpe_type})
+
+        # Get top vendors
+        top_vendors = [{"vendor": vendor, "count": count} for vendor, count in vendor_counts.most_common(20)]
+
+        # Get top products
+        top_products = [{"product": product, "count": count} for product, count in product_counts.most_common(20)]
+
+        # CPE type distribution
+        cpe_type_distribution = [
+            {"type": cpe_type, "count": count, "percentage": round(count / len(cpe_data["type_list"]) * 100, 1)}
+            for cpe_type, count in type_counts.most_common()
+        ]
+
+        # Calculate CVEs with most CPEs
+        cve_cpe_counts = Counter(cpe_data["cve_list"])
+        cves_with_most_cpes = []
+        for cve, cpe_count in cve_cpe_counts.most_common(20):
+            cves_with_most_cpes.append({"cve": cve, "cpe_count": cpe_count})
+
+        cpe_analysis = {
+            "generated_at": datetime.now().isoformat(),
+            "total_unique_cpes": len(cpe_counts),
+            "total_cpe_entries": len(cpe_data["cpe_list"]),
+            "total_cves_with_cpes": len(set(cpe_data["cve_list"])),
+            "total_unique_vendors": len(vendor_counts),
+            "total_unique_products": len(product_counts),
+            "top_cpes": top_cpes,
+            "top_vendors": top_vendors,
+            "top_products": top_products,
+            "cpe_type_distribution": cpe_type_distribution,
+            "cves_with_most_cpes": cves_with_most_cpes,
+            "average_cpes_per_cve": round(len(cpe_data["cpe_list"]) / len(set(cpe_data["cve_list"])), 1)
+            if cpe_data["cve_list"]
+            else 0,
+        }
+
+        # Save to file
+        output_file = self.data_dir / "cpe_analysis.json"
+        with open(output_file, "w") as f:
+            json.dump(cpe_analysis, f, indent=2)
+
+        logger.info(f"  ✅ Generated CPE analysis with {len(cpe_counts):,} unique CPEs")
+        return cpe_analysis
+
+    def generate_current_year_cpe_analysis(self, current_year_data: dict[str, Any]) -> dict[str, Any]:
+        """Generate current year CPE analysis"""
+        logger.info("    🔍 Generating current year CPE analysis...")
+
+        # Process current year CPE data from cache
+        current_year_cpe_data = self._process_current_year_cpe_data()
+
+        if not current_year_cpe_data:
+            logger.warning(f"    ⚠️  No CPE data found for {self.current_year}")
+            return {}
+
+        # Analyze current year CPE patterns
+        cpe_counts = Counter(current_year_cpe_data["cpe_list"])
+        vendor_counts = Counter(current_year_cpe_data["vendor_list"])
+        product_counts = Counter(current_year_cpe_data["product_list"])
+        type_counts = Counter(current_year_cpe_data["type_list"])
+
+        # Get top CPEs for current year
+        top_cpes = []
+        for cpe, count in cpe_counts.most_common(30):
+            vendor = self.extract_cpe_vendor(cpe)
+            product = self.extract_cpe_product(cpe)
+            cpe_type = self.extract_cpe_type(cpe)
+
+            top_cpes.append({"cpe": cpe, "count": count, "vendor": vendor, "product": product, "type": cpe_type})
+
+        # Get top vendors for current year
+        top_vendors = [{"vendor": vendor, "count": count} for vendor, count in vendor_counts.most_common(15)]
+
+        # Get top products for current year
+        top_products = [{"product": product, "count": count} for product, count in product_counts.most_common(15)]
+
+        # CPE type distribution for current year
+        cpe_type_distribution = [
+            {
+                "type": cpe_type,
+                "count": count,
+                "percentage": round(count / len(current_year_cpe_data["type_list"]) * 100, 1),
+            }
+            for cpe_type, count in type_counts.most_common()
+        ]
+
+        # Calculate CVEs with most CPEs for current year
+        cve_cpe_counts = Counter(current_year_cpe_data["cve_list"])
+        cves_with_most_cpes = []
+        for cve, cpe_count in cve_cpe_counts.most_common(20):
+            cves_with_most_cpes.append({"cve": cve, "cpe_count": cpe_count})
+
+        current_year_cpe_analysis = {
+            "generated_at": datetime.now().isoformat(),
+            "year": self.current_year,
+            "total_unique_cpes": len(cpe_counts),
+            "total_cpe_entries": len(current_year_cpe_data["cpe_list"]),
+            "total_cves_with_cpes": len(set(current_year_cpe_data["cve_list"])),
+            "total_unique_vendors": len(vendor_counts),
+            "total_unique_products": len(product_counts),
+            "top_cpes": top_cpes,
+            "top_vendors": top_vendors,
+            "top_products": top_products,
+            "cpe_type_distribution": cpe_type_distribution,
+            "cves_with_most_cpes": cves_with_most_cpes,
+            "average_cpes_per_cve": round(
+                len(current_year_cpe_data["cpe_list"]) / len(set(current_year_cpe_data["cve_list"])), 1
+            )
+            if current_year_cpe_data["cve_list"]
+            else 0,
+        }
+
+        # Save current year analysis
+        current_year_file = self.data_dir / "cpe_analysis_current_year.json"
+        with open(current_year_file, "w") as f:
+            json.dump(current_year_cpe_analysis, f, indent=2)
+
+        logger.info(f"    ✅ Generated current year CPE analysis with {len(cpe_counts)} unique CPEs")
+        return current_year_cpe_analysis
+
+    def _process_cpe_data_from_cache(self) -> dict[str, list[str]] | None:
+        """Process CPE data from cached nvd.json file"""
+        nvd_file = self.cache_dir / "nvd.json"
+
+        if not nvd_file.exists():
+            logger.warning(f"    ⚠️  NVD cache file not found: {nvd_file}")
+            return None
+
+        if not self.quiet:
+            logger.info(f"    📂 Processing CPE data from {nvd_file}")
+
+        cpe_list = []
+        vendor_list = []
+        product_list = []
+        type_list = []
+        cve_list = []
+
+        try:
+            with open(nvd_file, encoding="utf-8") as f:
+                if not self.quiet:
+                    logger.info(f"    📂 Loading NVD data from {nvd_file}...")
+                nvd_data = json.load(f)
+
+                # Handle different possible data structures
+                cve_items = []
+                if isinstance(nvd_data, list):
+                    cve_items = nvd_data
+                elif isinstance(nvd_data, dict):
+                    # Check for common NVD data structure patterns
+                    if "CVE_Items" in nvd_data:
+                        cve_items = nvd_data["CVE_Items"]
+                    elif "vulnerabilities" in nvd_data:
+                        cve_items = nvd_data["vulnerabilities"]
+                    else:
+                        # Assume it's a single CVE item
+                        cve_items = [nvd_data]
+
+                if not self.quiet:
+                    logger.info(f"    📊 Processing {len(cve_items):,} CVE records...")
+
+                for idx, cve_item in enumerate(cve_items):
+                    if idx % 50000 == 0 and idx > 0 and not self.quiet:
+                        logger.debug(f"    📊 Processed {idx:,} CVE records...")
+
+                    try:
+                        # Handle different CVE data structures
+                        cve_data = cve_item
+                        if "cve" in cve_item:
+                            cve_data = cve_item["cve"]
+
+                        cve_id = cve_data.get("id", cve_data.get("CVE_data_meta", {}).get("ID", ""))
+
+                        # Extract CPE data from configurations
+                        configurations = cve_data.get("configurations", [])
+                        if not configurations and "configurations" in cve_item:
+                            configurations = cve_item["configurations"]
+
+                        for config in configurations:
+                            for node in config.get("nodes", []):
+                                if "cpeMatch" in node:
+                                    for cpe_match in node["cpeMatch"]:
+                                        if cpe_match.get("vulnerable", False):
+                                            if cpe_string := cpe_match.get("criteria", ""):
+                                                cpe_list.append(cpe_string)
+                                                cve_list.append(cve_id)
+                                                vendor_list.append(self.extract_cpe_vendor(cpe_string))
+                                                product_list.append(self.extract_cpe_product(cpe_string))
+                                                type_list.append(self.extract_cpe_type(cpe_string))
+
+                    except (KeyError, TypeError, AttributeError):
+                        continue
+
+        except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+            logger.error(f"    ❌ Error processing NVD file: {e}")
+            return None
+
+        if not self.quiet:
+            logger.info(f"    ✅ Processed {len(cpe_list):,} CPE entries from {len(set(cve_list)):,} CVEs")
+
+        return {
+            "cpe_list": cpe_list,
+            "vendor_list": vendor_list,
+            "product_list": product_list,
+            "type_list": type_list,
+            "cve_list": cve_list,
+        }
+
+    def _process_current_year_cpe_data(self) -> dict[str, list[str]] | None:
+        """Process CPE data for current year only"""
+        nvd_file = self.cache_dir / "nvd.json"
+
+        if not nvd_file.exists():
+            logger.warning(f"    ⚠️  NVD cache file not found: {nvd_file}")
+            return None
+
+        if not self.quiet:
+            logger.info(f"    📂 Processing current year CPE data from {nvd_file}")
+
+        cpe_list = []
+        vendor_list = []
+        product_list = []
+        type_list = []
+        cve_list = []
+
+        try:
+            with open(nvd_file, encoding="utf-8") as f:
+                if not self.quiet:
+                    logger.info(f"    📂 Loading NVD data for current year from {nvd_file}...")
+                nvd_data = json.load(f)
+
+                # Handle different possible data structures
+                cve_items = []
+                if isinstance(nvd_data, list):
+                    cve_items = nvd_data
+                elif isinstance(nvd_data, dict):
+                    # Check for common NVD data structure patterns
+                    if "CVE_Items" in nvd_data:
+                        cve_items = nvd_data["CVE_Items"]
+                    elif "vulnerabilities" in nvd_data:
+                        cve_items = nvd_data["vulnerabilities"]
+                    else:
+                        # Assume it's a single CVE item
+                        cve_items = [nvd_data]
+
+                if not self.quiet:
+                    logger.info(f"    📊 Processing {len(cve_items):,} CVE records for current year...")
+
+                for idx, cve_item in enumerate(cve_items):
+                    if idx % 50000 == 0 and idx > 0 and not self.quiet:
+                        logger.debug(f"    📊 Processed {idx:,} CVE records for current year...")
+
+                    try:
+                        # Handle different CVE data structures
+                        cve_data = cve_item
+                        if "cve" in cve_item:
+                            cve_data = cve_item["cve"]
+
+                        cve_id = cve_data.get("id", cve_data.get("CVE_data_meta", {}).get("ID", ""))
+
+                        # Check if CVE is from current year
+                        published_date = cve_data.get("published", cve_data.get("publishedDate", ""))
+                        if not published_date.startswith(str(self.current_year)):
+                            continue
+
+                        # Extract CPE data from configurations
+                        configurations = cve_data.get("configurations", [])
+                        if not configurations and "configurations" in cve_item:
+                            configurations = cve_item["configurations"]
+
+                        for config in configurations:
+                            for node in config.get("nodes", []):
+                                if "cpeMatch" in node:
+                                    for cpe_match in node["cpeMatch"]:
+                                        if cpe_match.get("vulnerable", False):
+                                            if cpe_string := cpe_match.get("criteria", ""):
+                                                cpe_list.append(cpe_string)
+                                                cve_list.append(cve_id)
+                                                vendor_list.append(self.extract_cpe_vendor(cpe_string))
+                                                product_list.append(self.extract_cpe_product(cpe_string))
+                                                type_list.append(self.extract_cpe_type(cpe_string))
+
+                    except (KeyError, TypeError, AttributeError):
+                        continue
+
+        except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+            logger.error(f"    ❌ Error processing NVD file for current year: {e}")
+            return None
+
+        if not self.quiet:
+            logger.info(
+                f"    ✅ Processed {len(cpe_list):,} CPE entries from {len(set(cve_list)):,} CVEs for {self.current_year}"
+            )
+
+        return {
+            "cpe_list": cpe_list,
+            "vendor_list": vendor_list,
+            "product_list": product_list,
+            "type_list": type_list,
+            "cve_list": cve_list,
+        }
+
+    def _generate_minimal_cpe_analysis(self) -> dict[str, Any]:
+        """Generate minimal CPE analysis when no data is available"""
+        return {
+            "generated_at": datetime.now().isoformat(),
+            "total_unique_cpes": 0,
+            "total_cpe_entries": 0,
+            "total_cves_with_cpes": 0,
+            "total_unique_vendors": 0,
+            "total_unique_products": 0,
+            "top_cpes": [],
+            "top_vendors": [],
+            "top_products": [],
+            "cpe_type_distribution": [],
+            "cves_with_most_cpes": [],
+            "average_cpes_per_cve": 0,
+        }
diff --git a/data/cve_v5_processor.py b/data/cve_v5_processor.py
new file mode 100644
index 00000000000..0d6b5cc2fb6
--- /dev/null
+++ b/data/cve_v5_processor.py
@@ -0,0 +1,1299 @@
+#!/usr/bin/env python3
+"""
+CVE V5 Processor Module
+Handles CVE V5 list data processing as the single source of truth for CNA analysis
+
+Performance Optimizations (2026-01-10):
+- Parallel file processing with multiprocessing
+- Optimized JSON loading with orjson (when available)
+- Batched I/O operations to reduce syscall overhead
+- Pre-compiled patterns for CNA type classification
+- Memory-efficient aggregation with __slots__
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import subprocess
+from collections import defaultdict
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from datetime import datetime
+from multiprocessing import cpu_count
+from pathlib import Path
+from typing import Any
+
+from download_cve_data import CVEDataDownloader
+
+
+# Import optimized utilities if available
+try:
+    from data.fast_json import dump_json_fast, load_json_fast
+    from data.optimized_processing import (
+        collect_cve_files,
+        process_cve_batch,
+    )
+
+    OPTIMIZED_AVAILABLE = True
+except ImportError:
+    try:
+        from fast_json import dump_json_fast, load_json_fast
+        from optimized_processing import (
+            collect_cve_files,
+            process_cve_batch,
+        )
+
+        OPTIMIZED_AVAILABLE = True
+    except ImportError:
+        OPTIMIZED_AVAILABLE = False
+        load_json_fast = None
+        dump_json_fast = None
+
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class CVEV5Processor:
+    """Processes CVE V5 list data for authoritative CNA analysis"""
+
+    base_dir: Path
+    cache_dir: Path
+    data_dir: Path
+    quiet: bool = False
+    current_year: int = field(default_factory=lambda: datetime.now().year)
+    v5_cache_dir: Path = field(init=False)
+    epss_mapping: dict[str, dict[str, float]] = field(default_factory=dict, init=False)
+    kev_cve_set: set[str] = field(default_factory=set, init=False)
+
+    def __post_init__(self) -> None:
+        """Convert paths and load threat intelligence data."""
+        self.base_dir = Path(self.base_dir)
+        self.cache_dir = Path(self.cache_dir)
+        self.data_dir = Path(self.data_dir)
+        self.v5_cache_dir = self.cache_dir / "cvelistV5"
+        # Load threat intelligence data
+        self._load_epss_mapping()
+        self._load_kev_set()
+
+    def _load_epss_mapping(self) -> None:
+        """Load EPSS mapping from cache if available.
+
+        Uses the same cache directory as CVEDataDownloader to avoid
+        duplicate downloads. If EPSS data is unavailable or parsing
+        fails, this method leaves epss_mapping empty and continues
+        silently so that CNA analysis is not blocked.
+        """
+        try:
+            downloader = CVEDataDownloader(cache_dir=self.cache_dir, quiet=True)
+            epss_json_path = downloader.epss_parsed_file
+            # If parsed file does not exist yet, attempt to parse from CSV
+            if not epss_json_path.exists():
+                epss_json_path = downloader.parse_epss_csv()
+
+            if epss_json_path and Path(epss_json_path).exists():
+                # Use optimized JSON loading if available (5x faster with orjson)
+                if OPTIMIZED_AVAILABLE and load_json_fast:
+                    self.epss_mapping = load_json_fast(epss_json_path)
+                else:
+                    with open(epss_json_path, encoding="utf-8") as f:
+                        self.epss_mapping = json.load(f)
+                if not self.quiet:
+                    logger.info(f"  ✅ Loaded EPSS mapping for {len(self.epss_mapping):,} CVEs")
+            else:
+                if not self.quiet:
+                    logger.warning("  ⚠️  EPSS mapping not available; proceeding without enrichment")
+        except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+            if not self.quiet:
+                logger.warning(f"  ⚠️  Could not load EPSS mapping: {e}")
+            self.epss_mapping = {}
+
+    def _load_kev_set(self) -> None:
+        """Load KEV CVE IDs into a set for fast lookup"""
+        kev_file = self.cache_dir / "known_exploited_vulnerabilities_parsed.json"
+        if kev_file.exists():
+            try:
+                # Use optimized JSON loading if available
+                if OPTIMIZED_AVAILABLE and load_json_fast:
+                    kev_data = load_json_fast(kev_file)
+                else:
+                    with open(kev_file) as f:
+                        kev_data = json.load(f)
+                self.kev_cve_set = set(kev_data.keys())
+                if not self.quiet:
+                    logger.info(f"  ✅ Loaded KEV set with {len(self.kev_cve_set):,} CVEs")
+            except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+                if not self.quiet:
+                    logger.warning(f"  ⚠️  Could not load KEV data: {e}")
+                self.kev_cve_set = set()
+        else:
+            if not self.quiet:
+                logger.warning("  ⚠️  KEV data not available; proceeding without KEV enrichment")
+
+        # CNA type classification patterns
+        self.cna_type_patterns = {
+            "Vendor": [
+                "microsoft",
+                "apple",
+                "google",
+                "oracle",
+                "cisco",
+                "adobe",
+                "ibm",
+                "redhat",
+                "canonical",
+                "suse",
+                "debian",
+                "ubuntu",
+                "mozilla",
+                "vmware",
+                "intel",
+                "amd",
+                "nvidia",
+                "qualcomm",
+                "samsung",
+                "huawei",
+                "lenovo",
+                "hp",
+                "dell",
+                "netapp",
+                "citrix",
+            ],
+            "Security Researcher": [
+                "patchstack",
+                "wordfence",
+                "vuldb",
+                "zerodayinitiative",
+                "trendmicro",
+                "rapid7",
+                "tenable",
+                "qualys",
+                "checkmarx",
+                "veracode",
+            ],
+            "CERT": [
+                "cert",
+                "cisa",
+                "ncsc",
+                "jpcert",
+                "kr-cert",
+                "au-cert",
+                "ca-cert",
+                "de-cert",
+                "fr-cert",
+                "nl-cert",
+            ],
+            "Government": ["cisa", "nist", "dhs", "gov", "mil", "defense", "homeland", "treasury", "energy", "state"],
+            "Academic": ["edu", "university", "college", "research", "institute", "academic", "school", "campus"],
+            "Open Source": [
+                "github",
+                "gitlab",
+                "apache",
+                "eclipse",
+                "linux",
+                "kernel",
+                "gnu",
+                "fsf",
+                "oss",
+                "opensource",
+            ],
+        }
+
+    def clone_or_update_cve_v5_repo(self) -> bool:
+        """Clone or update the CVE V5 repository with shallow clone"""
+        logger.info("  📥 Setting up CVE V5 repository...")
+
+        if self.v5_cache_dir.exists():
+            # Check if it's a valid git repository
+            git_dir = self.v5_cache_dir / ".git"
+            if not git_dir.exists():
+                logger.warning("    ⚠️ Invalid git repository, re-cloning...")
+                shutil.rmtree(self.v5_cache_dir)
+                return self._clone_fresh_repo()
+
+            logger.info("    🔄 Updating existing CVE V5 repository...")
+            try:
+                # First try a simple git pull (no --depth flag for existing repos)
+                result = subprocess.run(
+                    ["git", "pull", "origin", "main"],
+                    cwd=self.v5_cache_dir,
+                    capture_output=True,
+                    text=True,
+                    timeout=300,
+                )
+                if result.returncode == 0:
+                    logger.info("    ✅ Successfully updated CVE V5 repository")
+                    return True
+                else:
+                    # Try to reset and pull if there are conflicts
+                    logger.info("    🔄 Pull failed, trying reset and pull...")
+                    reset_result = subprocess.run(
+                        ["git", "reset", "--hard", "origin/main"],
+                        cwd=self.v5_cache_dir,
+                        capture_output=True,
+                        text=True,
+                        timeout=60,
+                    )
+                    if reset_result.returncode == 0:
+                        pull_result = subprocess.run(
+                            ["git", "pull", "origin", "main"],
+                            cwd=self.v5_cache_dir,
+                            capture_output=True,
+                            text=True,
+                            timeout=300,
+                        )
+                        if pull_result.returncode == 0:
+                            logger.info("    ✅ Successfully updated CVE V5 repository after reset")
+                            return True
+
+                    # Only re-clone as last resort
+                    logger.warning("    ⚠️ All update attempts failed, re-cloning as last resort...")
+                    logger.debug(f"    📝 Git pull error: {result.stderr}")
+                    shutil.rmtree(self.v5_cache_dir)
+                    return self._clone_fresh_repo()
+
+            except subprocess.TimeoutExpired:
+                logger.warning("    ⏰ Git pull timed out, repository may be up to date")
+                return True  # Don't re-clone on timeout, assume it's working
+            except (subprocess.SubprocessError, OSError) as e:
+                logger.warning(f"    ⚠️ Update failed with exception: {e}")
+                # Only re-clone if it's a critical error
+                if "not a git repository" in str(e).lower():
+                    shutil.rmtree(self.v5_cache_dir)
+                    return self._clone_fresh_repo()
+                else:
+                    logger.debug("    📝 Assuming repository is usable despite error")
+                    return True
+        else:
+            return self._clone_fresh_repo()
+
+    def _clone_fresh_repo(self) -> bool:
+        """Clone fresh CVE V5 repository"""
+        logger.info("    📦 Cloning CVE V5 repository (shallow clone)...")
+        try:
+            # Ensure cache directory exists
+            self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+            # Shallow clone with depth=1 to minimize data transfer
+            result = subprocess.run(
+                [
+                    "git",
+                    "clone",
+                    "--depth=1",
+                    "--single-branch",
+                    "https://github.com/CVEProject/cvelistV5.git",
+                    str(self.v5_cache_dir),
+                ],
+                capture_output=True,
+                text=True,
+                timeout=600,
+            )
+
+            if result.returncode == 0:
+                logger.info("    ✅ Successfully cloned CVE V5 repository")
+                return True
+            else:
+                logger.error(f"    ❌ Failed to clone CVE V5 repository: {result.stderr}")
+                return False
+
+        except subprocess.TimeoutExpired:
+            logger.error("    ❌ Clone operation timed out")
+            return False
+        except (subprocess.SubprocessError, OSError) as e:
+            logger.error(f"    ❌ Clone failed: {e}")
+            return False
+
+    def get_repo_stats(self) -> dict[str, Any] | None:
+        """Get basic statistics about the cloned repository"""
+        if not self.v5_cache_dir.exists():
+            return None
+
+        cves_dir = self.v5_cache_dir / "cves"
+        if not cves_dir.exists():
+            return None
+
+        stats = {"total_years": 0, "total_cves": 0, "years_available": []}
+
+        for year_dir in sorted(cves_dir.iterdir()):
+            if year_dir.is_dir() and year_dir.name.isdigit():
+                year = int(year_dir.name)
+                stats["years_available"].append(year)
+                stats["total_years"] += 1
+
+                # Count CVE files in this year (handle nested structure)
+                year_cve_count = 0
+                for subdir in year_dir.iterdir():
+                    if subdir.is_dir():
+                        cve_files = list(subdir.glob("CVE-*.json"))
+                        year_cve_count += len(cve_files)
+                stats["total_cves"] += year_cve_count
+
+        return stats
+
+    def classify_cna_type(self, org_id: str, short_name: str) -> list[str]:
+        """Classify CNA type based on organization ID and short name"""
+        # Combine org_id and short_name for pattern matching
+        search_text = f"{org_id} {short_name}".lower()
+
+        # Special cases first
+        if "mitre" in search_text:
+            return ["Program"]  # MITRE is the CVE Program
+
+        # Check patterns for each type
+        matched_types = []
+        for cna_type, patterns in self.cna_type_patterns.items():
+            for pattern in patterns:
+                if pattern in search_text:
+                    matched_types.append(cna_type)
+                    break  # Only add each type once
+
+        # If no specific type matched, use comprehensive inference patterns
+        if not matched_types:
+            # Academic institutions
+            if any(
+                domain in search_text
+                for domain in [".edu", "university", "college", "institut", "research", "academic", "school"]
+            ):
+                matched_types.append("Academic")
+            # Government and military
+            elif any(
+                gov in search_text
+                for gov in [".gov", ".mil", "government", "cisa", "nist", "dhs", "defense", "homeland"]
+            ):
+                matched_types.append("Government")
+            # CERT and security organizations
+            elif any(cert in search_text for cert in ["cert", "csirt", "security", "cyber"]):
+                matched_types.append("CERT")
+            # Open source projects and repositories
+            elif any(
+                oss in search_text
+                for oss in [
+                    "github",
+                    "gitlab",
+                    "apache",
+                    "linux",
+                    "kernel",
+                    "gnu",
+                    "eclipse",
+                    "mozilla",
+                    "debian",
+                    "ubuntu",
+                    "redhat",
+                    "canonical",
+                    "suse",
+                ]
+            ):
+                matched_types.append("Open Source")
+            # Security researchers and vulnerability research
+            elif any(
+                sec in search_text
+                for sec in ["vulnerability", "exploit", "security", "research", "bug", "bounty", "pentest", "audit"]
+            ):
+                matched_types.append("Security Researcher")
+            # Technology vendors (broad patterns)
+            elif any(
+                vendor in search_text
+                for vendor in [
+                    "corp",
+                    "inc",
+                    "ltd",
+                    "llc",
+                    "gmbh",
+                    "co",
+                    "company",
+                    "tech",
+                    "software",
+                    "systems",
+                    "solutions",
+                    "technologies",
+                ]
+            ):
+                matched_types.append("Vendor")
+            # Email domain-based classification
+            elif "@" in search_text:
+                domain = search_text.split("@")[-1] if "@" in search_text else ""
+                if ".edu" in domain or "university" in domain:
+                    matched_types.append("Academic")
+                elif ".gov" in domain or ".mil" in domain:
+                    matched_types.append("Government")
+                elif any(tech in domain for tech in [".com", ".org", ".net", "tech", "software", "systems"]):
+                    matched_types.append("Vendor")
+                else:
+                    matched_types.append("Other")
+            else:
+                # Final fallback - assume most are vendors/organizations
+                matched_types.append("Vendor")
+
+        return matched_types if matched_types else ["Vendor"]
+
+    def calculate_enhanced_statistics(self, cna_list: list[dict[str, Any]]) -> dict[str, Any]:
+        """Calculate enhanced statistics for CNA analysis"""
+        if not cna_list:
+            return {}
+
+        total_cves = sum(cna["count"] for cna in cna_list)
+        total_cnas = len(cna_list)
+
+        # Market concentration (top 5 CNAs)
+        top_5_cves = sum(cna["count"] for cna in cna_list[:5])
+        market_concentration = (top_5_cves / total_cves * 100) if total_cves > 0 else 0
+
+        # High volume CNAs (1000+ CVEs)
+        high_volume_cnas = len([cna for cna in cna_list if cna["count"] >= 1000])
+
+        # Activity statistics
+        active_cnas = len([cna for cna in cna_list if cna["activity_status"] == "Active"])
+        inactive_cnas = total_cnas - active_cnas
+
+        # Years active statistics
+        years_active_list = [cna["years_active"] for cna in cna_list if cna.get("years_active", 0) > 0]
+        median_years_active = 0
+        if years_active_list:
+            years_active_list.sort()
+            n = len(years_active_list)
+            median_years_active = (
+                years_active_list[n // 2]
+                if n % 2 == 1
+                else (years_active_list[n // 2 - 1] + years_active_list[n // 2]) / 2
+            )
+
+        # Type distribution
+        type_counts = defaultdict(int)
+        for cna in cna_list:
+            cna_types = cna.get("cna_types", ["Other"])
+            for cna_type in cna_types:
+                type_counts[cna_type] += 1
+
+        # Convert to format expected by JavaScript using comprehensions
+        # JavaScript expects: type_distribution.sorted_types and type_distribution.type_percentages
+        sorted_type_items = sorted(type_counts.items(), key=lambda x: x[1], reverse=True)
+
+        # List comprehension for sorted_types (JavaScript expects [type, count] pairs)
+        sorted_types = [[cna_type, count] for cna_type, count in sorted_type_items]
+
+        # Dict comprehension for type_percentages
+        type_percentages = {
+            cna_type: round((count / total_cnas * 100), 1) if total_cnas > 0 else 0
+            for cna_type, count in sorted_type_items
+        }
+
+        # Create the structure expected by JavaScript
+        type_distribution = {"sorted_types": sorted_types, "type_percentages": type_percentages}
+
+        return {
+            "total_cves": total_cves,
+            "total_cnas": total_cnas,
+            "active_cnas": active_cnas,
+            "inactive_cnas": inactive_cnas,
+            "high_volume_cnas": high_volume_cnas,
+            "market_concentration": round(market_concentration, 1),
+            "median_years_active": round(median_years_active, 1),
+            "type_distribution": type_distribution,
+        }
+
+    @staticmethod
+    def _severity_from_score(score: float) -> str:
+        """Normalize numeric score to a severity bucket."""
+        if score >= 9.0:
+            return "Critical"
+        if score >= 7.0:
+            return "High"
+        if score >= 4.0:
+            return "Medium"
+        return "Low"
+
+    @staticmethod
+    def _normalize_severity_label(label: Any, score: float | None = None) -> str:
+        """Normalize CVSS severity label across CVE v5 containers."""
+        mapping = {
+            "CRITICAL": "Critical",
+            "HIGH": "High",
+            "MEDIUM": "Medium",
+            "LOW": "Low",
+            "NONE": "Low",
+        }
+        if isinstance(label, str):
+            normalized = mapping.get(label.strip().upper())
+            if normalized:
+                return normalized
+        if score is not None:
+            return CVEV5Processor._severity_from_score(score)
+        return "Low"
+
+    @staticmethod
+    def _iter_v5_containers(cve_data: dict[str, Any]) -> list[dict[str, Any]]:
+        """Yield all CVE v5 containers where CVSS/CWE data may exist."""
+        containers: list[dict[str, Any]] = []
+        container_root = cve_data.get("containers", {})
+        if not isinstance(container_root, dict):
+            return containers
+
+        cna_container = container_root.get("cna")
+        if isinstance(cna_container, dict):
+            containers.append(cna_container)
+
+        adp_containers = container_root.get("adp", [])
+        if isinstance(adp_containers, list):
+            containers.extend(entry for entry in adp_containers if isinstance(entry, dict))
+
+        return containers
+
+    def _extract_cvss_severity_bucket(self, cve_data: dict[str, Any]) -> str | None:
+        """Extract the highest-severity CVSS bucket from CNA and ADP containers."""
+        best_score: float | None = None
+        best_label: str | None = None
+
+        for container in self._iter_v5_containers(cve_data):
+            metrics = container.get("metrics", [])
+            if not isinstance(metrics, list):
+                continue
+
+            for metric in metrics:
+                if not isinstance(metric, dict):
+                    continue
+
+                for cvss_key in ("cvssV4_0", "cvssV3_1", "cvssV3_0", "cvssV2_0"):
+                    cvss = metric.get(cvss_key)
+                    if not isinstance(cvss, dict):
+                        continue
+
+                    base_score = cvss.get("baseScore")
+                    try:
+                        score = float(base_score)
+                    except (TypeError, ValueError):
+                        continue
+
+                    if best_score is None or score > best_score:
+                        best_score = score
+                        best_label = self._normalize_severity_label(cvss.get("baseSeverity"), score)
+
+        return best_label
+
+    def _extract_cwes_from_containers(self, cve_data: dict[str, Any]) -> list[str]:
+        """Extract CWE IDs from CNA and ADP containers."""
+        cwes: set[str] = set()
+        cwe_pattern = re.compile(r"CWE-\d+")
+
+        for container in self._iter_v5_containers(cve_data):
+            problem_types = container.get("problemTypes", [])
+            if not isinstance(problem_types, list):
+                continue
+
+            for problem_type in problem_types:
+                if not isinstance(problem_type, dict):
+                    continue
+
+                descriptions = problem_type.get("descriptions", [])
+                if isinstance(descriptions, dict):
+                    descriptions = [descriptions]
+                if not isinstance(descriptions, list):
+                    continue
+
+                for description in descriptions:
+                    if not isinstance(description, dict):
+                        continue
+
+                    for key in ("cweId", "cweID", "value", "description"):
+                        value = description.get(key)
+                        if not isinstance(value, str):
+                            continue
+                        if match := cwe_pattern.search(value):
+                            cwes.add(match.group(0))
+                            break
+
+        return sorted(cwes)
+
+    def parse_cve_v5_record(self, cve_file_path: Path, include_enrichment: bool = False):
+        """Parse a single CVE v5 record and extract CNA information."""
+        try:
+            with open(cve_file_path, encoding="utf-8") as f:
+                cve_data = json.load(f)
+
+            # Extract CVE metadata
+            cve_metadata = cve_data.get("cveMetadata", {})
+            cve_id = cve_metadata.get("cveId", "")
+            state = cve_metadata.get("state", "")
+
+            # Skip REJECTED CVEs - they don't represent valid vulnerabilities
+            if state == "REJECTED":
+                return None
+
+            # Extract CNA information from V5 format
+            assigner_org_id = cve_metadata.get("assignerOrgId", "")
+            assigner_short_name = cve_metadata.get("assignerShortName", "")
+
+            # Extract publication date
+            date_published = cve_metadata.get("datePublished", "")
+            date_updated = cve_metadata.get("dateUpdated", "")
+
+            # Use publication date for accurate CNA activity tracking
+            # (date_updated reflects record modifications, not actual CVE assignment)
+            pub_date = date_published if date_published else date_updated
+
+            record = {
+                "cve_id": cve_id,
+                "assigner_org_id": assigner_org_id,
+                "assigner_short_name": assigner_short_name,
+                "date_published": date_published,
+                "date_updated": date_updated,
+                "publication_date": pub_date,
+                "year": int(cve_id.split("-")[1]) if cve_id.startswith("CVE-") else None,
+            }
+
+            if include_enrichment:
+                record["severity_bucket"] = self._extract_cvss_severity_bucket(cve_data)
+                record["cwes"] = self._extract_cwes_from_containers(cve_data)
+
+            # Attach EPSS enrichment if available
+            if cve_id and self.epss_mapping:
+                epss = self.epss_mapping.get(cve_id)
+                if epss:
+                    record["epss_score"] = epss.get("epss_score")
+                    record["epss_percentile"] = epss.get("epss_percentile")
+
+            return record
+
+        except (json.JSONDecodeError, KeyError, ValueError, OSError) as e:
+            logger.warning(f"    ⚠️ Error parsing {cve_file_path}: {e}")
+            return None
+
+    def process_all_cves_single_pass(self, use_parallel: bool = True):
+        """Process ALL CVE records in a single pass, tracking by publication year.
+
+        Performance optimizations (2026-01-10):
+        - Parallel file processing with multiprocessing (2-4x speedup)
+        - Optimized file collection using os.scandir (2x faster than glob)
+        - Batched I/O to reduce syscall overhead
+
+        This is more efficient than processing year-by-year since:
+        1. CVE folder year (e.g., cves/2024/) is the CVE ID year, not publication year
+        2. A CVE-2024-XXXX might be published in 2025
+        3. Single pass = read each file once instead of multiple times
+
+        Args:
+            use_parallel: Use parallel processing (default: True)
+        """
+        print("  📊 Processing all CVE files in single pass...")
+
+        cves_dir = self.v5_cache_dir / "cves"
+
+        # Use optimized parallel processing if available and enabled
+        if use_parallel and OPTIMIZED_AVAILABLE and collect_cve_files is not None:
+            print("  ⚡ Using optimized parallel processing...")
+
+            # Use optimized file collection (os.scandir is 2x faster than glob)
+            all_cve_files = collect_cve_files(cves_dir)
+            total_files = len(all_cve_files)
+            print(f"  📊 Found {total_files:,} total CVE files to process")
+
+            if total_files == 0:
+                return {}
+
+            # Determine optimal worker count
+            max_workers = max(1, cpu_count() - 1)
+            batch_size = 500
+
+            print(f"  🔄 Processing with {max_workers} workers, batch size {batch_size}...")
+
+            # Create batches
+            batches = [[str(f) for f in all_cve_files[i : i + batch_size]] for i in range(0, total_files, batch_size)]
+
+            # Initialize aggregated stats
+            all_cna_stats = defaultdict(
+                lambda: {
+                    "count": 0,
+                    "cves": [],
+                    "first_date": None,
+                    "last_date": None,
+                    "first_year": None,
+                    "last_year": None,
+                    "assigner_org_id": "",
+                    "assigner_short_name": "",
+                    "cves_by_pub_year": defaultdict(int),
+                    "kev_count": 0,
+                    "epss_high_count": 0,
+                    "epss_elevated_count": 0,
+                    "cwe_counts": defaultdict(int),
+                }
+            )
+
+            processed = 0
+
+            # Process in parallel
+            with ProcessPoolExecutor(max_workers=max_workers) as executor:
+                futures = {executor.submit(process_cve_batch, batch): i for i, batch in enumerate(batches)}
+
+                for future in as_completed(futures):
+                    try:
+                        records = future.result()
+
+                        for record in records:
+                            org_id = record.get("org_id", "")
+                            if not org_id:
+                                continue
+
+                            cve_id = record.get("cve_id", "")
+                            pub_date = record.get("pub_date", "")
+                            pub_year = record.get("pub_year")
+
+                            # Update CNA statistics
+                            all_cna_stats[org_id]["count"] += 1
+                            all_cna_stats[org_id]["cves"].append(cve_id)
+                            all_cna_stats[org_id]["assigner_org_id"] = org_id
+                            all_cna_stats[org_id]["assigner_short_name"] = record.get("short_name", "")
+
+                            # Track by PUBLICATION year
+                            if pub_year:
+                                all_cna_stats[org_id]["cves_by_pub_year"][pub_year] += 1
+
+                            # Track date ranges
+                            if pub_date:
+                                if (
+                                    not all_cna_stats[org_id]["first_date"]
+                                    or pub_date < all_cna_stats[org_id]["first_date"]
+                                ):
+                                    all_cna_stats[org_id]["first_date"] = pub_date
+                                    all_cna_stats[org_id]["first_year"] = pub_year
+                                if (
+                                    not all_cna_stats[org_id]["last_date"]
+                                    or pub_date > all_cna_stats[org_id]["last_date"]
+                                ):
+                                    all_cna_stats[org_id]["last_date"] = pub_date
+                                    all_cna_stats[org_id]["last_year"] = pub_year
+
+                            # Track KEV membership
+                            if cve_id in self.kev_cve_set:
+                                all_cna_stats[org_id]["kev_count"] += 1
+
+                            # Track EPSS scores
+                            if cve_id in self.epss_mapping:
+                                epss_score = self.epss_mapping[cve_id].get("epss_score", 0)
+                                if epss_score > 0.5:
+                                    all_cna_stats[org_id]["epss_high_count"] += 1
+                                if epss_score > 0.1:
+                                    all_cna_stats[org_id]["epss_elevated_count"] += 1
+
+                        processed += len(records)
+                        if processed % 10000 < batch_size:
+                            print(f"    📈 Processed {processed:,}/{total_files:,} files...")
+
+                    except Exception as e:
+                        logger.warning(f"Batch processing error: {e}")
+
+            print(f"  ✅ Processed {processed:,} CVE files, found {len(all_cna_stats)} unique CNAs")
+            return dict(all_cna_stats)
+
+        # Fallback to original single-threaded processing
+        print("  📊 Using single-threaded processing (install optimized_processing for parallel)...")
+
+        # Initialize CNA stats with publication year tracking
+        all_cna_stats = defaultdict(
+            lambda: {
+                "count": 0,
+                "cves": [],
+                "first_date": None,
+                "last_date": None,
+                "first_year": None,
+                "last_year": None,
+                "assigner_org_id": "",
+                "assigner_short_name": "",
+                "cves_by_pub_year": defaultdict(int),  # Keyed by PUBLICATION year
+                "kev_count": 0,
+                "epss_high_count": 0,
+                "epss_elevated_count": 0,
+                "cwe_counts": defaultdict(int),
+            }
+        )
+
+        # Collect all CVE files from all year directories
+        all_cve_files = []
+
+        for year_dir in sorted(cves_dir.iterdir()):
+            if year_dir.is_dir() and year_dir.name.isdigit():
+                for subdir in year_dir.iterdir():
+                    if subdir.is_dir():
+                        all_cve_files.extend(subdir.glob("CVE-*.json"))
+
+        total_files = len(all_cve_files)
+        print(f"  📊 Found {total_files} total CVE files to process")
+
+        processed = 0
+        for cve_file in all_cve_files:
+            cve_record = self.parse_cve_v5_record(cve_file)
+            if cve_record and cve_record["assigner_org_id"]:
+                org_id = cve_record["assigner_org_id"]
+                cve_id = cve_record["cve_id"]
+                pub_date = cve_record["publication_date"]
+
+                # Extract publication year from the date
+                pub_year = None
+                if pub_date:
+                    try:
+                        pub_year = datetime.fromisoformat(pub_date.replace("Z", "+00:00")).year
+                    except (AttributeError, TypeError, ValueError):
+                        pass
+
+                # Update CNA statistics
+                all_cna_stats[org_id]["count"] += 1
+                all_cna_stats[org_id]["cves"].append(cve_id)
+                all_cna_stats[org_id]["assigner_org_id"] = org_id
+                all_cna_stats[org_id]["assigner_short_name"] = cve_record["assigner_short_name"]
+
+                # Track by PUBLICATION year (not CVE ID year)
+                if pub_year:
+                    all_cna_stats[org_id]["cves_by_pub_year"][pub_year] += 1
+
+                # Track date ranges
+                if pub_date:
+                    if not all_cna_stats[org_id]["first_date"] or pub_date < all_cna_stats[org_id]["first_date"]:
+                        all_cna_stats[org_id]["first_date"] = pub_date
+                        all_cna_stats[org_id]["first_year"] = pub_year
+                    if not all_cna_stats[org_id]["last_date"] or pub_date > all_cna_stats[org_id]["last_date"]:
+                        all_cna_stats[org_id]["last_date"] = pub_date
+                        all_cna_stats[org_id]["last_year"] = pub_year
+
+                # Track KEV membership inline
+                if cve_id in self.kev_cve_set:
+                    all_cna_stats[org_id]["kev_count"] += 1
+
+                # Track EPSS scores inline
+                if cve_id in self.epss_mapping:
+                    epss_score = self.epss_mapping[cve_id].get("epss_score", 0)
+                    if epss_score > 0.5:
+                        all_cna_stats[org_id]["epss_high_count"] += 1
+                    if epss_score > 0.1:
+                        all_cna_stats[org_id]["epss_elevated_count"] += 1
+
+            processed += 1
+            if processed % 10000 == 0:
+                print(f"    📈 Processed {processed}/{total_files} files...")
+
+        print(f"  ✅ Processed {processed} CVE files, found {len(all_cna_stats)} unique CNAs")
+        return dict(all_cna_stats)
+
+    def process_year_data(self, year):
+        """Process all CVE records for a specific year"""
+        logger.info(f"    📅 Processing CVE data for year {year}...")
+
+        year_dir = self.v5_cache_dir / "cves" / str(year)
+        if not year_dir.exists():
+            logger.warning(f"    ⚠️ No data found for year {year}")
+            return {}
+
+        cna_stats = defaultdict(
+            lambda: {
+                "count": 0,
+                "cves": [],
+                "first_date": None,
+                "last_date": None,
+                "assigner_org_id": "",
+                "assigner_short_name": "",
+            }
+        )
+
+        # CVE V5 has nested directory structure (0xxx, 1xxx, etc.)
+        cve_files = []
+        for subdir in year_dir.iterdir():
+            if subdir.is_dir():
+                cve_files.extend(subdir.glob("CVE-*.json"))
+
+        total_files = len(cve_files)
+        processed = 0
+
+        if not self.quiet:
+            logger.info(f"    📊 Found {total_files} CVE files for {year}")
+
+        for cve_file in cve_files:
+            cve_record = self.parse_cve_v5_record(cve_file)
+            if cve_record and cve_record["assigner_org_id"]:
+                org_id = cve_record["assigner_org_id"]
+
+                # Update CNA statistics
+                cna_stats[org_id]["count"] += 1
+                cna_stats[org_id]["cves"].append(cve_record["cve_id"])
+                cna_stats[org_id]["assigner_org_id"] = org_id
+                cna_stats[org_id]["assigner_short_name"] = cve_record["assigner_short_name"]
+
+                # Track date ranges
+                pub_date = cve_record["publication_date"]
+                if pub_date:
+                    if not cna_stats[org_id]["first_date"] or pub_date < cna_stats[org_id]["first_date"]:
+                        cna_stats[org_id]["first_date"] = pub_date
+                    if not cna_stats[org_id]["last_date"] or pub_date > cna_stats[org_id]["last_date"]:
+                        cna_stats[org_id]["last_date"] = pub_date
+
+            processed += 1
+            if processed % 1000 == 0 and not self.quiet:
+                logger.debug(f"    📈 Processed {processed}/{total_files} files...")
+
+        if not self.quiet:
+            logger.info(f"    ✅ Processed {processed} CVE files, found {len(cna_stats)} CNAs for {year}")
+        return dict(cna_stats)
+
+    def generate_comprehensive_cna_analysis(self) -> dict[str, Any] | None:
+        """Generate comprehensive CNA analysis using CVE V5 data as single source of truth"""
+        logger.info("  🏢 Generating comprehensive CNA analysis from CVE V5 data...")
+
+        # Ensure we have the latest CVE V5 data
+        if not self.clone_or_update_cve_v5_repo():
+            logger.error("  ❌ Failed to setup CVE V5 repository")
+            return None
+
+        # Get repository statistics
+        repo_stats = self.get_repo_stats()
+        if not repo_stats:
+            logger.error("  ❌ Failed to get repository statistics")
+            return None
+
+        print(f"  📊 Repository contains {repo_stats['total_cves']} CVEs across {repo_stats['total_years']} years")
+
+        # Use single-pass processing (reads each file once, tracks by publication year)
+        all_cna_stats = self.process_all_cves_single_pass()
+
+        # Convert to final format
+        cna_list = []
+        total_cnas = len(all_cna_stats)
+        print(f"  📊 Building CNA list from {total_cnas} CNAs...")
+        for processed_cnas, (org_id, stats) in enumerate(all_cna_stats.items(), start=1):
+            if processed_cnas % 50 == 0:
+                print(f"    📈 Processing CNA {processed_cnas}/{total_cnas}...")
+            # Calculate years active using publication dates
+            years_active_count = 1
+            first_pub_year = None
+            last_pub_year = None
+            if stats["first_date"]:
+                try:
+                    first_pub_year = datetime.fromisoformat(stats["first_date"].replace("Z", "+00:00")).year
+                except (ValueError, TypeError):
+                    pass
+            if stats["last_date"]:
+                try:
+                    last_pub_year = datetime.fromisoformat(stats["last_date"].replace("Z", "+00:00")).year
+                except (ValueError, TypeError):
+                    pass
+            if first_pub_year and last_pub_year:
+                years_active_count = max(1, last_pub_year - first_pub_year + 1)
+
+            # Calculate days since last CVE
+            days_since_last = 365  # Default to inactive
+            if stats["last_date"]:
+                try:
+                    last_date = datetime.fromisoformat(stats["last_date"].replace("Z", "+00:00"))
+                    days_since_last = (datetime.now(last_date.tzinfo) - last_date).days
+                except (ValueError, TypeError):
+                    days_since_last = 365
+
+            # Determine activity status
+            activity_status = "Active" if days_since_last < 365 else "Inactive"
+
+            # Classify CNA type
+            cna_types = self.classify_cna_type(org_id, stats["assigner_short_name"])
+
+            # KEV and EPSS are already tracked inline during single-pass processing
+            kev_count = stats.get("kev_count", 0)
+            epss_high_count = stats.get("epss_high_count", 0)
+            epss_elevated_count = stats.get("epss_elevated_count", 0)
+
+            # Severity and CWE aggregation is expensive - use simpler approach
+            severity_distribution = {}
+            top_cwe_types = {}
+
+            cna_entry = {
+                "name": stats["assigner_short_name"] or org_id,
+                "assigner_org_id": org_id,
+                "count": stats["count"],
+                "years_active": years_active_count,
+                "first_cve_year": first_pub_year,
+                "last_cve_year": last_pub_year,
+                "first_cve_date": stats["first_date"],
+                "last_cve_date": stats["last_date"],
+                "days_since_last_cve": days_since_last,
+                "activity_status": activity_status,
+                "is_official": True,  # All CVE V5 records are from official CNAs
+                "cna_types": cna_types,  # Add CNA type classification
+                "cves_by_year": dict(stats.get("cves_by_pub_year", {})),  # Use publication year
+                "years_active_list": [first_pub_year, last_pub_year] if first_pub_year and last_pub_year else [],
+                # Add placeholder fields for compatibility
+                "severity_distribution": severity_distribution,
+                "top_cwe_types": top_cwe_types,
+                # Threat intelligence metrics
+                "kev_count": kev_count,
+                "epss_high_count": epss_high_count,
+                "epss_elevated_count": epss_elevated_count,
+                "top_cwes": list(top_cwe_types.items())[:5],  # For template compatibility
+            }
+            cna_list.append(cna_entry)
+
+        # Sort by CVE count (descending)
+        cna_list.sort(key=lambda x: x["count"], reverse=True)
+
+        # Add ranks
+        for i, cna in enumerate(cna_list):
+            cna["rank"] = i + 1
+
+        # Calculate enhanced statistics
+        enhanced_stats = self.calculate_enhanced_statistics(cna_list)
+
+        # Calculate actual published CVE count (sum of all CNA counts, excludes REJECTED)
+        total_published_cves = sum(cna["count"] for cna in cna_list)
+
+        # Update repo_stats with published count (not raw file count)
+        repo_stats["total_cves"] = total_published_cves
+
+        # Create comprehensive analysis data structure
+        comprehensive_data = {
+            "generated_at": datetime.now().isoformat(),
+            "source": "CVE V5 List (Authoritative)",
+            "repository_stats": repo_stats,
+            "total_cnas": enhanced_stats.get("total_cnas", len(cna_list)),
+            "active_cnas": enhanced_stats.get("active_cnas", 0),
+            "inactive_cnas": enhanced_stats.get("inactive_cnas", 0),
+            "official_cnas": enhanced_stats.get("total_cnas", len(cna_list)),  # All are official in V5 data
+            "unofficial_cnas": 0,  # None are unofficial in V5 data
+            "high_volume_cnas": enhanced_stats.get("high_volume_cnas", 0),
+            "market_concentration": enhanced_stats.get("market_concentration", 0),
+            "median_years_active": enhanced_stats.get("median_years_active", 0),
+            "type_distribution": enhanced_stats.get("type_distribution", []),
+            # NOTE: a "cna_assigners" alias used to be emitted here holding the exact
+            # same list. It cost ~270K per file and nothing read it - the CNA pages use
+            # cna_list, and years.html reads cna_assigners from the per-year files.
+            "cna_list": cna_list,
+        }
+
+        # Save comprehensive analysis
+        output_file = self.data_dir / "cna_analysis.json"
+        with open(output_file, "w") as f:
+            json.dump(comprehensive_data, f, indent=2)
+
+        logger.info(f"  📄 Generated comprehensive CNA analysis with {len(cna_list)} CNAs")
+        logger.info(
+            f"  📊 Active: {enhanced_stats.get('active_cnas', 0)}, Inactive: {enhanced_stats.get('inactive_cnas', 0)}"
+        )
+
+        return comprehensive_data
+
+    def process_current_year_by_publication_date(self) -> dict[str, dict[str, Any]]:
+        """Process CVEs from ALL years, filtering by current year publication date"""
+        logger.info(f"    🔍 Scanning all CVE years for {self.current_year} publications...")
+
+        cves_dir = self.v5_cache_dir / "cves"
+        if not cves_dir.exists():
+            logger.error("    ❌ CVEs directory not found")
+            return {}
+
+        cna_stats = defaultdict(
+            lambda: {
+                "count": 0,
+                "cves": [],
+                "first_date": None,
+                "last_date": None,
+                "assigner_org_id": "",
+                "assigner_short_name": "",
+                "severity_counts": defaultdict(int),
+                "cwe_counts": defaultdict(int),
+            }
+        )
+
+        total_processed = 0
+        current_year_cves = 0
+
+        # Scan all year directories
+        for year_dir in sorted(cves_dir.iterdir()):
+            if not year_dir.is_dir() or not year_dir.name.isdigit():
+                continue
+
+            year = int(year_dir.name)
+            if not self.quiet:
+                logger.debug(f"    📂 Scanning CVE-{year}-* files for {self.current_year} publications...")
+
+            # Get all CVE files in this year directory (handle nested structure)
+            cve_files = []
+            for subdir in year_dir.iterdir():
+                if subdir.is_dir():
+                    cve_files.extend(subdir.glob("CVE-*.json"))
+
+            year_current_cves = 0
+            for cve_file in cve_files:
+                cve_record = self.parse_cve_v5_record(cve_file, include_enrichment=True)
+                if cve_record and cve_record["assigner_org_id"]:
+                    # Check if this CVE was published in the current year
+                    pub_date = cve_record["publication_date"]
+                    if pub_date:
+                        try:
+                            pub_year = datetime.fromisoformat(pub_date.replace("Z", "+00:00")).year
+                            if pub_year == self.current_year:
+                                # This CVE was published in current year
+                                org_id = cve_record["assigner_org_id"]
+
+                                # Update CNA statistics
+                                cna_stats[org_id]["count"] += 1
+                                cna_stats[org_id]["cves"].append(cve_record["cve_id"])
+                                cna_stats[org_id]["assigner_org_id"] = org_id
+                                cna_stats[org_id]["assigner_short_name"] = cve_record["assigner_short_name"]
+
+                                # Track date ranges
+                                if not cna_stats[org_id]["first_date"] or pub_date < cna_stats[org_id]["first_date"]:
+                                    cna_stats[org_id]["first_date"] = pub_date
+                                if not cna_stats[org_id]["last_date"] or pub_date > cna_stats[org_id]["last_date"]:
+                                    cna_stats[org_id]["last_date"] = pub_date
+
+                                # CVSS/CWE can be present in either CNA or ADP containers
+                                severity_bucket = cve_record.get("severity_bucket")
+                                if severity_bucket:
+                                    cna_stats[org_id]["severity_counts"][severity_bucket] += 1
+
+                                for cwe_id in cve_record.get("cwes", []):
+                                    cna_stats[org_id]["cwe_counts"][cwe_id] += 1
+
+                                year_current_cves += 1
+                                current_year_cves += 1
+                        except (ValueError, TypeError):
+                            # Skip CVEs with invalid dates
+                            pass
+
+                total_processed += 1
+                if total_processed % 5000 == 0 and not self.quiet:
+                    logger.debug(
+                        f"    📈 Processed {total_processed} files, found {current_year_cves} {self.current_year} publications..."
+                    )
+
+            if year_current_cves > 0 and not self.quiet:
+                logger.debug(
+                    f"    ✅ Found {year_current_cves} CVEs published in {self.current_year} from CVE-{year}-* files"
+                )
+
+        if not self.quiet:
+            logger.info(
+                f"    🎯 Total: {current_year_cves} CVEs published in {self.current_year}, from {len(cna_stats)} CNAs"
+            )
+        return dict(cna_stats)
+
+    def generate_current_year_analysis(self) -> dict[str, Any] | None:
+        """Generate current year CNA analysis from CVE V5 data based on publication date"""
+        logger.info(f"  📅 Generating {self.current_year} CNA analysis from CVE V5 data (by publication date)...")
+
+        # Process data from ALL years, filtering by publication date
+        current_year_data = self.process_current_year_by_publication_date()
+
+        if not current_year_data:
+            logger.warning(f"  ⚠️ No CVEs published in {self.current_year} found")
+            return None
+
+        # Load comprehensive analysis to get full CNA history for years_active calculation
+        logger.info("    📊 Loading comprehensive analysis for full CNA history...")
+        comprehensive_file = self.data_dir / "cna_analysis.json"
+        comprehensive_cnas = {}
+        if comprehensive_file.exists():
+            try:
+                with open(comprehensive_file) as f:
+                    comprehensive_data = json.load(f)
+                    if "cna_list" in comprehensive_data:
+                        # Create lookup by assigner_org_id for quick access
+                        for cna in comprehensive_data["cna_list"]:
+                            if "assigner_org_id" in cna:
+                                comprehensive_cnas[cna["assigner_org_id"]] = cna
+                logger.info(f"    ✅ Loaded {len(comprehensive_cnas)} CNAs from comprehensive analysis")
+            except (FileNotFoundError, json.JSONDecodeError, KeyError, OSError) as e:
+                logger.warning(f"    ⚠️ Could not load comprehensive analysis: {e}")
+
+        # Convert to final format
+        current_year_cnas = []
+        for org_id, stats in current_year_data.items():
+            # Classify CNA type
+            cna_types = self.classify_cna_type(org_id, stats["assigner_short_name"])
+            # Use years_active from comprehensive analysis for consistency
+            years_active = 1  # Default fallback
+            first_cve_year = None
+            last_cve_year = None
+            if org_id in comprehensive_cnas:
+                comprehensive_cna = comprehensive_cnas[org_id]
+                years_active = comprehensive_cna.get("years_active", 1)
+                first_cve_year = comprehensive_cna.get("first_cve_year")
+                last_cve_year = comprehensive_cna.get("last_cve_year")
+            else:
+                if stats["first_date"] and stats["last_date"]:
+                    try:
+                        first_cve_year = datetime.fromisoformat(stats["first_date"].replace("Z", "+00:00")).year
+                        last_cve_year = datetime.fromisoformat(stats["last_date"].replace("Z", "+00:00")).year
+                        years_active = max(1, last_cve_year - first_cve_year + 1)
+                    except (ValueError, TypeError):
+                        years_active = 1
+            # Severity/CWE values are pre-aggregated during single-pass file scan
+            severity_counts = stats.get("severity_counts", {})
+            cwe_counts = stats.get("cwe_counts", {})
+            top_cwe_types = dict(sorted(cwe_counts.items(), key=lambda x: x[1], reverse=True)[:5])
+            severity_distribution = dict(severity_counts)
+
+            # Compute threat intelligence metrics from CVE IDs
+            kev_count = 0
+            epss_high_count = 0
+            epss_elevated_count = 0
+
+            for cve_id in stats["cves"]:
+                if cve_id in self.kev_cve_set:
+                    kev_count += 1
+                if cve_id in self.epss_mapping:
+                    epss_score = self.epss_mapping[cve_id].get("epss_score", 0)
+                    if epss_score > 0.5:
+                        epss_high_count += 1
+                    if epss_score > 0.1:
+                        epss_elevated_count += 1
+
+            cna_entry = {
+                "name": stats["assigner_short_name"] or org_id,
+                "assigner_org_id": org_id,
+                "count": stats["count"],
+                "rank": 0,  # Will be set after sorting
+                "first_cve_date": stats["first_date"],
+                "last_cve_date": stats["last_date"],
+                "years_active": years_active,  # Use comprehensive value
+                "first_cve_year": first_cve_year,
+                "last_cve_year": last_cve_year,
+                "is_official": True,  # All CVE V5 records are from official CNAs
+                "activity_status": "Active",  # All current year CNAs are active
+                "cna_types": cna_types,  # Add CNA type classification
+                "severity_distribution": severity_distribution,
+                "top_cwe_types": top_cwe_types,
+                # Threat intelligence metrics
+                "kev_count": kev_count,
+                "epss_high_count": epss_high_count,
+                "epss_elevated_count": epss_elevated_count,
+                "top_cwes": list(top_cwe_types.items())[:5],
+            }
+            current_year_cnas.append(cna_entry)
+
+        # Sort by count and add ranks
+        current_year_cnas.sort(key=lambda x: x["count"], reverse=True)
+        for i, cna in enumerate(current_year_cnas):
+            cna["rank"] = i + 1
+
+        # Create current year data structure
+        current_year_analysis = {
+            "generated_at": datetime.now().isoformat(),
+            "source": "CVE V5 List (Authoritative)",
+            "year": self.current_year,
+            "total_cnas": len(current_year_cnas),
+            "active_cnas": len(current_year_cnas),
+            "inactive_cnas": 0,
+            "official_cnas": len(current_year_cnas),  # All are official
+            "unofficial_cnas": 0,  # None are unofficial
+            # NOTE: a "cna_assigners" alias used to be emitted here holding the exact
+            # same list. It cost ~270K per file and nothing read it - the CNA pages use
+            # cna_list, and years.html reads cna_assigners from the per-year files.
+            "cna_list": current_year_cnas,
+        }
+
+        # Save current year analysis
+        output_file = self.data_dir / "cna_analysis_current_year.json"
+        with open(output_file, "w") as f:
+            json.dump(current_year_analysis, f, indent=2)
+
+        logger.info(f"  📄 Generated {self.current_year} CNA analysis with {len(current_year_cnas)} CNAs")
+
+        return current_year_analysis
diff --git a/data/cve_years.py b/data/cve_years.py
new file mode 100644
index 00000000000..e07d91c61a2
--- /dev/null
+++ b/data/cve_years.py
@@ -0,0 +1,894 @@
+#!/usr/bin/env python3
+"""
+CVE Years Analyzer
+Processes CVE data from JSONL file and generates yearly analysis data
+Handles historical data (1999-2016) and individual years (2017-present)
+
+Performance Optimizations (2026-01-10):
+- Optimized JSON loading with orjson (when available)
+- Cached date parsing for repeated date strings
+- Pre-computed lookup tables for severity normalization
+- Reduced memory allocations in hot loops
+"""
+
+from __future__ import annotations
+
+import json
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+from download_cve_data import CVEDataDownloader
+
+
+# Import optimized utilities if available
+try:
+    from data.fast_json import load_json_fast, normalize_severity, parse_iso_date_cached
+
+    FAST_JSON_AVAILABLE = True
+except ImportError:
+    try:
+        from fast_json import load_json_fast, normalize_severity, parse_iso_date_cached
+
+        FAST_JSON_AVAILABLE = True
+    except ImportError:
+        FAST_JSON_AVAILABLE = False
+        load_json_fast = None
+        normalize_severity = None
+        parse_iso_date_cached = None
+
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+# Pre-computed severity normalization lookup (faster than match/case in hot loop)
+_SEVERITY_MAP = {
+    "CRITICAL": "CRITICAL",
+    "CRIT": "CRITICAL",
+    "C": "CRITICAL",
+    "HIGH": "HIGH",
+    "H": "HIGH",
+    "MEDIUM": "MEDIUM",
+    "MED": "MEDIUM",
+    "M": "MEDIUM",
+    "LOW": "LOW",
+    "L": "LOW",
+    "NONE": "NONE",
+    "N": "NONE",
+}
+
+
+@lru_cache(maxsize=10000)
+def _fast_parse_date(date_str: str) -> datetime | None:
+    """Parse ISO date string with caching for repeated values."""
+    if not date_str:
+        return None
+    try:
+        return datetime.fromisoformat(date_str.replace("Z", "+00:00"))
+    except (ValueError, TypeError):
+        return None
+
+
+def _normalize_severity_fast(severity: str | None) -> str:
+    """Normalize severity using pre-computed lookup table."""
+    if not severity:
+        return "UNKNOWN"
+    key = severity.strip().upper()
+    return _SEVERITY_MAP.get(key, key or "UNKNOWN")
+
+
+@dataclass
+class CVEYearsAnalyzer:
+    """Analyzes CVE data by year and generates structured data for visualization"""
+
+    quiet: bool = False
+    base_dir: Path = field(default_factory=lambda: Path(__file__).parent)
+    downloader: CVEDataDownloader = field(default=None, init=False)
+    data_file: Path | None = None
+    year_data_cache: dict[int, dict[str, Any]] = field(default_factory=dict)
+    cna_list: dict[str, Any] = field(default_factory=dict)
+    cna_name_map: dict[str, str] = field(default_factory=dict)
+    all_cves_cache: list[dict[str, Any]] | None = None
+    year_cve_buckets: dict[int, list[tuple[dict[str, Any], datetime]]] = field(default_factory=dict)
+    year_buckets_built: bool = False
+    epss_mapping: dict[str, dict[str, Any]] = field(default_factory=dict)
+    kev_mapping: dict[str, bool] = field(default_factory=dict)
+    threat_mappings_loaded: bool = False
+
+    def __post_init__(self) -> None:
+        """Initialize downloader and log startup."""
+        self.downloader = CVEDataDownloader(quiet=self.quiet)
+        if not self.quiet:
+            logger.info("📊 CVE Years Analyzer Initialized")
+            logger.info(f"📅 Target coverage: 1999-{datetime.now().year}")
+
+    def extract_severity_info(self, cve_data: dict[str, Any]) -> dict[str, Any]:
+        """Extract normalized CVSS severity and score from a CVE record.
+
+        This is intentionally conservative and mirrors the original notebook
+        logic: prefer v3.1, then v3.0, then v2.0, and fall back to
+        "UNKNOWN"/0.0 when nothing is available.
+
+        Performance: Uses pre-computed lookup table instead of match/case.
+        """
+        # NVD 1.1+ style: metrics are under cve.metrics
+        metrics = cve_data.get("cve", {}).get("metrics", {})
+
+        # Helper to extract from a metrics list by key (optimized)
+        def _from_metrics(key: str, version_label: str) -> dict[str, Any] | None:
+            entries = metrics.get(key)
+            if not entries:
+                return None
+            # Take the first entry as representative
+            metric = entries[0].get("cvssData") or {}
+            score = metric.get("baseScore")
+            severity = metric.get("baseSeverity")
+            try:
+                score_val = float(score)
+            except (TypeError, ValueError):
+                score_val = 0.0
+            return {
+                "version": version_label,
+                "severity": _normalize_severity_fast(severity),
+                "score": score_val,
+            }
+
+        # Preference order: v4.0 (if present), then v3.1, v3.0, v2.0
+        for key, label in (
+            ("cvssMetricV40", "v4.0"),
+            ("cvssMetricV31", "v3.1"),
+            ("cvssMetricV30", "v3.0"),
+            ("cvssMetricV2", "v2.0"),
+        ):
+            info = _from_metrics(key, label)
+            if info is not None:
+                return info
+
+        # Fallback: some legacy records may expose a flatter shape; be lenient
+        try:
+            base_metric = cve_data.get("impact", {}).get("baseMetricV3", {}).get("cvssV3", {})
+            if base_metric:
+                score = base_metric.get("baseScore", 0.0)
+                severity = base_metric.get("baseSeverity", "UNKNOWN")
+                return {
+                    "version": "v3.0",
+                    "severity": _normalize_severity_fast(severity),
+                    "score": float(score) if score is not None else 0.0,
+                }
+        except (TypeError, KeyError, ValueError):
+            pass
+
+        # Ultimate fallback
+        return {"version": "unknown", "severity": "UNKNOWN", "score": 0.0}
+
+    def extract_all_cvss_versions(self, cve_data: dict[str, Any]) -> list[dict[str, Any]]:
+        """Extract ALL CVSS versions present in a CVE record.
+
+        Unlike extract_severity_info which returns only the highest-priority
+        version, this returns every version so each can be counted independently
+        in the CVSS statistics.
+        """
+        results = []
+        metrics = cve_data.get("cve", {}).get("metrics", {})
+
+        for key, version_label in (
+            ("cvssMetricV40", "v4.0"),
+            ("cvssMetricV31", "v3.1"),
+            ("cvssMetricV30", "v3.0"),
+            ("cvssMetricV2", "v2.0"),
+        ):
+            entries = metrics.get(key)
+            if not entries:
+                continue
+            metric = entries[0].get("cvssData") or {}
+            score = metric.get("baseScore")
+            severity = metric.get("baseSeverity")
+            try:
+                score_val = float(score)
+            except (TypeError, ValueError):
+                continue
+            results.append(
+                {
+                    "version": version_label,
+                    "severity": _normalize_severity_fast(severity),
+                    "score": score_val,
+                }
+            )
+
+        if not results:
+            # Fallback for legacy flat shape
+            try:
+                base_metric = cve_data.get("impact", {}).get("baseMetricV3", {}).get("cvssV3", {})
+                if base_metric:
+                    score = base_metric.get("baseScore", 0.0)
+                    severity = base_metric.get("baseSeverity", "UNKNOWN")
+                    results.append(
+                        {
+                            "version": "v3.0",
+                            "severity": _normalize_severity_fast(severity),
+                            "score": float(score) if score is not None else 0.0,
+                        }
+                    )
+            except (TypeError, KeyError, ValueError):
+                pass
+
+        return results
+
+    def parse_cve_date(self, cve_data: dict[str, Any]) -> datetime | None:
+        """Extract a publication date for a CVE record.
+
+        Tries multiple known NVD-style shapes and falls back to lastModified or
+        the year embedded in the CVE ID if necessary.
+
+        Performance: Uses cached date parsing for repeated date strings.
+        """
+        # Prioritize cve['published'] and similar keys (NVD JSONL structure)
+        for key in ("published", "publishedDate", "publishDate"):
+            date_str = cve_data.get("cve", {}).get(key)
+            if not date_str:
+                date_str = cve_data.get(key)
+            if date_str:
+                # Use cached parsing for better performance
+                result = _fast_parse_date(date_str)
+                if result:
+                    return result
+
+        # Try lastModified style keys as a fallback
+        for key in ("lastModified", "lastModifiedDate"):
+            date_str = cve_data.get(key)
+            if not date_str:
+                date_str = cve_data.get("cve", {}).get(key)
+            if date_str:
+                result = _fast_parse_date(date_str)
+                if result:
+                    return result
+
+        # Legacy / alternative layouts: sometimes dates are nested under cve
+        # metadata or configurations – keep this best-effort and very defensive.
+        try:
+            meta = cve_data.get("cve", {}).get("CVE_data_meta", {})
+            # Some feeds include date in a "DATE_PUBLIC"-style field; rarely used.
+            for key in ("DATE_PUBLIC", "date_public", "date"):
+                date_str = meta.get(key)
+                if date_str:
+                    result = _fast_parse_date(date_str)
+                    if result:
+                        return result
+        except (KeyError, TypeError, AttributeError):
+            pass
+
+        # As a last resort, derive a year from the CVE ID itself; this at least
+        # lets us bucket by year when no explicit published date is available.
+        try:
+            cve_id = cve_data.get("cve", {}).get("id") or cve_data.get("cve", {}).get("CVE_data_meta", {}).get("ID", "")
+            if isinstance(cve_id, str) and cve_id.startswith("CVE-"):
+                parts = cve_id.split("-")
+                if len(parts) >= 3:
+                    year = int(parts[1])
+                    # Use January 1st of that year as a synthetic publication date
+                    return datetime(year, 1, 1)
+        except (ValueError, KeyError, TypeError, IndexError):
+            pass
+
+        # If everything fails, return None so callers can skip this CVE
+        return None
+
+    def ensure_data_loaded(self) -> None:
+        """Ensure CVE data is downloaded and available"""
+        if self.data_file is None:
+            if not self.quiet:
+                logger.info("🔽 Loading CVE data...")
+            self.data_file = self.downloader.ensure_data_available()
+            if not self.quiet:
+                logger.info(f"✅ Data loaded from: {self.data_file}")
+
+    def _load_all_cves(self) -> list[dict[str, Any]]:
+        """Load all CVE records once and cache for reuse across year processing."""
+        if self.all_cves_cache is not None:
+            return self.all_cves_cache
+
+        self.ensure_data_loaded()
+        if not self.quiet:
+            logger.debug("  📊 Reading JSON array format...")
+
+        if self.data_file is None:
+            self.all_cves_cache = []
+            return self.all_cves_cache
+
+        try:
+            if FAST_JSON_AVAILABLE and load_json_fast:
+                self.all_cves_cache = load_json_fast(self.data_file)
+                if not self.quiet:
+                    logger.debug(f"  📊 Loaded {len(self.all_cves_cache)} CVE records (using fast_json)")
+            else:
+                with open(self.data_file, encoding="utf-8") as f:
+                    self.all_cves_cache = json.load(f)
+                if not self.quiet:
+                    logger.debug(f"  📊 Loaded {len(self.all_cves_cache)} CVE records")
+        except (json.JSONDecodeError, OSError) as e:
+            logger.error(f"  ❌ Failed to parse JSON: {e}")
+            self.all_cves_cache = []
+
+        return self.all_cves_cache
+
+    def _ensure_year_buckets(self) -> None:
+        """Bucket CVEs by publication year in a single pass."""
+        if self.year_buckets_built:
+            return
+
+        all_cves = self._load_all_cves()
+        buckets: defaultdict[int, list[tuple[dict[str, Any], datetime]]] = defaultdict(list)
+
+        for cve_idx, cve_data in enumerate(all_cves):
+            if cve_idx % 10000 == 0 and cve_idx > 0 and not self.quiet:
+                logger.debug(f"  📊 Indexed {cve_idx:,} CVEs by publication year...")
+
+            cve_id = cve_data.get("cve", {}).get("id", "")
+            if not cve_id.startswith("CVE-"):
+                continue
+
+            vuln_status = cve_data.get("cve", {}).get("vulnStatus", "")
+            if "Rejected" in vuln_status:
+                continue
+
+            pub_date = self.parse_cve_date(cve_data)
+            if pub_date is None:
+                continue
+
+            buckets[pub_date.year].append((cve_data, pub_date))
+
+        self.year_cve_buckets = dict(buckets)
+        self.year_buckets_built = True
+
+        # Buckets now hold references to CVE records; drop list container overhead.
+        self.all_cves_cache = None
+
+    def _ensure_threat_mappings_loaded(self) -> None:
+        """Load EPSS and KEV mappings once for all year analyses."""
+        if self.threat_mappings_loaded:
+            return
+
+        try:
+            epss_json = self.downloader.epss_parsed_file
+            if not epss_json.exists():
+                epss_json = self.downloader.parse_epss_csv()
+            if epss_json and Path(epss_json).exists():
+                with open(epss_json, encoding="utf-8") as ef:
+                    self.epss_mapping = json.load(ef)
+            else:
+                self.epss_mapping = {}
+        except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+            logger.debug(f"EPSS data not available: {e}")
+            self.epss_mapping = {}
+
+        try:
+            kev_json = self.downloader.kev_parsed_file
+            if not kev_json.exists():
+                kev_json = self.downloader.parse_kev_json()
+            if kev_json and Path(kev_json).exists():
+                with open(kev_json, encoding="utf-8") as kf:
+                    raw = json.load(kf)
+                    self.kev_mapping = {k: bool(v) for k, v in raw.items()}
+            else:
+                self.kev_mapping = {}
+        except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+            logger.debug(f"KEV data not available: {e}")
+            self.kev_mapping = {}
+
+        self.threat_mappings_loaded = True
+
+    def process_year_data(self, year: int) -> dict[str, Any]:
+        """Process CVE data for a specific year"""
+        if year in self.year_data_cache:
+            return self.year_data_cache[year]
+
+        self.ensure_data_loaded()
+
+        if not self.quiet:
+            logger.info(f"📊 Processing CVE data for {year}...")
+
+        # Initialize counters using defaultdict for cleaner code
+        monthly_counts = [0] * 12
+        daily_counts: defaultdict[str, int] = defaultdict(int)
+        cvss_data = {
+            "v2.0": {"severity_counts": Counter(), "score_distribution": Counter(), "total": 0},
+            "v3.0": {"severity_counts": Counter(), "score_distribution": Counter(), "total": 0},
+            "v3.1": {"severity_counts": Counter(), "score_distribution": Counter(), "total": 0},
+            "v4.0": {"severity_counts": Counter(), "score_distribution": Counter(), "total": 0},
+            "unknown": {"severity_counts": Counter(), "score_distribution": Counter(), "total": 0},
+        }
+        vendor_counts = Counter()
+        cwe_counts = Counter()
+        status_counts = Counter()
+        tag_counts = Counter()
+        reference_tag_counts = Counter()
+        cpe_vendor_counts = Counter()
+
+        try:
+            self._ensure_year_buckets()
+        except (json.JSONDecodeError, OSError) as e:
+            logger.error(f"  ❌ Failed to index CVE data by year: {e}")
+            return self.create_empty_year_data(year)
+
+        # EPSS summary buckets for this year (using precomputed mapping)
+        epss_buckets = {
+            "epss_gt_0_1": 0,
+            "epss_gt_0_5": 0,
+            "epss_gt_0_9": 0,
+        }
+
+        # KEV summary for this year: just a simple count of KEV CVEs
+        kev_summary = {
+            "kev_count": 0,
+        }
+
+        self._ensure_threat_mappings_loaded()
+
+        year_records = self.year_cve_buckets.get(year, [])
+        if not self.quiet:
+            logger.debug(f"  📊 Processing {len(year_records):,} CVEs bucketed for {year}")
+
+        # Process each CVE record for the selected year
+        total_cves = 0
+        for cve_idx, (cve_data, pub_date) in enumerate(year_records):
+            if cve_idx % 10000 == 0 and cve_idx > 0 and not self.quiet:
+                logger.debug(f"  📊 Processed {cve_idx:,} CVEs...")
+
+            try:
+                cve_id = cve_data.get("cve", {}).get("id", "")
+                vuln_status = cve_data.get("cve", {}).get("vulnStatus", "")
+
+                total_cves += 1
+
+                month_idx = pub_date.month - 1
+                monthly_counts[month_idx] += 1
+
+                date_str = pub_date.strftime("%Y-%m-%d")
+                daily_counts[date_str] += 1
+
+                all_cvss = self.extract_all_cvss_versions(cve_data)
+                if all_cvss:
+                    for severity_info in all_cvss:
+                        cvss_version = severity_info["version"]
+                        severity = severity_info["severity"]
+                        score = severity_info["score"]
+
+                        if cvss_version in cvss_data:
+                            cvss_data[cvss_version]["severity_counts"][severity] += 1
+                            score_key = round(float(score), 1) if score > 0 else 0.0
+                            cvss_data[cvss_version]["score_distribution"][score_key] += 1
+                            cvss_data[cvss_version]["total"] += 1
+                        else:
+                            cvss_data["unknown"]["severity_counts"][severity] += 1
+                            score_key = round(float(score), 1) if score > 0 else 0.0
+                            cvss_data["unknown"]["score_distribution"][score_key] += 1
+                            cvss_data["unknown"]["total"] += 1
+                else:
+                    cvss_data["unknown"]["severity_counts"]["UNKNOWN"] += 1
+                    cvss_data["unknown"]["score_distribution"][0.0] += 1
+                    cvss_data["unknown"]["total"] += 1
+
+                # EPSS aggregation
+                try:
+                    if getattr(self, "epss_mapping", None):
+                        epss = self.epss_mapping.get(cve_id)
+                        if epss:
+                            epss_score = float(epss.get("epss_score") or 0.0)
+                            if epss_score > 0.1:
+                                epss_buckets["epss_gt_0_1"] += 1
+                            if epss_score > 0.5:
+                                epss_buckets["epss_gt_0_5"] += 1
+                            if epss_score > 0.9:
+                                epss_buckets["epss_gt_0_9"] += 1
+                except (TypeError, ValueError, KeyError):
+                    pass
+
+                # KEV aggregation (simple count per year)
+                try:
+                    if getattr(self, "kev_mapping", None):
+                        if self.kev_mapping.get(cve_id):
+                            kev_summary["kev_count"] += 1
+                except (TypeError, KeyError):
+                    pass
+
+                # Additional fields
+                status_counts[vuln_status] += 1
+
+                cve_tags = cve_data.get("cve", {}).get("cveTags", [])
+                for tag in cve_tags:
+                    if isinstance(tag, str):
+                        tag_counts[tag] += 1
+                    elif isinstance(tag, dict) and "tag" in tag:
+                        tag_counts[tag["tag"]] += 1
+
+                references = cve_data.get("cve", {}).get("references", [])
+                for ref in references:
+                    ref_tags = ref.get("tags", [])
+                    for tag in ref_tags:
+                        reference_tag_counts[tag] += 1
+
+                cpe_vendors = self.extract_cpe_vendor_info(cve_data)
+                for vendor in cpe_vendors:
+                    cpe_vendor_counts[vendor] += 1
+
+                vendors = self.extract_vendor_info(cve_data)
+                for vendor in vendors:
+                    vendor_counts[vendor] += 1
+
+                cwes = self.extract_cwe_info(cve_data)
+                for cwe in cwes:
+                    cwe_counts[cwe] += 1
+
+            except (json.JSONDecodeError, KeyError, ValueError, IndexError) as e:
+                if cve_idx <= 10:
+                    logger.warning(f"  ⚠️  Error processing CVE {cve_idx}: {e}")
+                continue
+
+        # Prepare daily publication analysis
+        complete_daily_counts = self.create_complete_daily_array(daily_counts, year)
+
+        if complete_daily_counts:
+            non_zero_days = {k: v for k, v in complete_daily_counts.items() if v > 0}
+            if non_zero_days:
+                daily_values = list(non_zero_days.values())
+                daily_analysis = {
+                    "total_days": len(non_zero_days),
+                    "avg_per_day": round(sum(daily_values) / len(daily_values), 2),
+                    "highest_day": {"date": max(non_zero_days, key=non_zero_days.get), "count": max(daily_values)},
+                    "lowest_day": {"date": min(non_zero_days, key=non_zero_days.get), "count": min(daily_values)},
+                    "daily_counts": complete_daily_counts,
+                }
+            else:
+                daily_analysis = {
+                    "total_days": 0,
+                    "avg_per_day": 0,
+                    "highest_day": {"date": "", "count": 0},
+                    "lowest_day": {"date": "", "count": 0},
+                    "daily_counts": complete_daily_counts,
+                }
+        else:
+            daily_analysis = {
+                "total_days": 0,
+                "avg_per_day": 0,
+                "highest_day": {"date": "", "count": 0},
+                "lowest_day": {"date": "", "count": 0},
+                "daily_counts": {},
+            }
+
+        year_data = {
+            "year": year,
+            "total_cves": total_cves,
+            "date_data": {
+                "monthly_distribution": {str(i + 1): monthly_counts[i] for i in range(12)},
+                "daily_analysis": daily_analysis,
+            },
+            "cvss": {
+                **{
+                    version: {
+                        "total": data["total"],
+                        "severity_distribution": dict(data["severity_counts"]),
+                        "score_distribution": dict(data["score_distribution"]),
+                    }
+                    for version, data in cvss_data.items()
+                    if data["total"] > 0
+                },
+                "epss_summary": epss_buckets,
+            },
+            "kev": kev_summary,
+            "vendors": {
+                "cna_assigners": [{"name": vendor, "count": count} for vendor, count in vendor_counts.most_common(20)],
+                "cpe_vendors": [
+                    {"name": vendor, "count": count} for vendor, count in cpe_vendor_counts.most_common(20)
+                ],
+            },
+            "cwe": {"top_cwes": [{"cwe": cwe, "count": count} for cwe, count in cwe_counts.most_common(20)]},
+            "metadata": {
+                "vulnerability_status": [
+                    {"status": status, "count": count} for status, count in status_counts.most_common(10)
+                ],
+                "cve_tags": [{"tag": tag, "count": count} for tag, count in tag_counts.most_common(10)],
+                "reference_tags": [{"tag": tag, "count": count} for tag, count in reference_tag_counts.most_common(20)],
+            },
+            "processing_stats": {"processed_at": datetime.now().isoformat(), "data_source": "data/cache/nvd.json"},
+        }
+
+        self.year_data_cache[year] = year_data
+
+        if not self.quiet:
+            logger.info(f"  ✅ Found {total_cves} CVEs for {year}")
+        return year_data
+
+    def create_complete_daily_array(self, daily_counts: dict[str, int], year: int) -> dict[str, int]:
+        """Create complete daily array with zeros for missing dates to prevent UI issues"""
+        try:
+            # Create date range for the entire year
+            start_date = datetime(year, 1, 1)
+            if year == datetime.now().year:
+                # For current year, only go up to today
+                end_date = datetime.now().date()
+            else:
+                # For past years, include the entire year
+                end_date = datetime(year, 12, 31).date()
+
+            complete_daily_counts = {}
+            current_date = start_date.date()
+
+            while current_date <= end_date:
+                date_str = current_date.strftime("%Y-%m-%d")
+                complete_daily_counts[date_str] = daily_counts.get(date_str, 0)
+                current_date += timedelta(days=1)
+
+            return complete_daily_counts
+
+        except (ValueError, OSError) as e:
+            logger.warning(f"⚠️  Warning: Could not create complete daily array: {e}")
+            return daily_counts
+
+    def extract_cwe_info(self, cve_data: dict[str, Any]) -> list[str]:
+        """Extract CWE (Common Weakness Enumeration) information from CVE data"""
+        cwes: list[str] = []
+        try:
+            # Look for CWE information in the weaknesses section
+            weaknesses = cve_data.get("cve", {}).get("weaknesses", [])
+
+            for weakness in weaknesses:
+                descriptions = weakness.get("description", [])
+                for desc in descriptions:
+                    if desc.get("lang") == "en":  # English descriptions only
+                        cwe_value = desc.get("value", "")
+                        if cwe_value and cwe_value.startswith("CWE-"):
+                            # Filter out "Missing" CWEs as per original notebook
+                            if "Missing_" not in cwe_value:
+                                cwes.append(cwe_value)
+
+            return cwes
+
+        except (KeyError, TypeError, AttributeError):
+            return []
+
+    def extract_identifier_info(self, cve_data: dict[str, Any]) -> list[str]:
+        """Extract CVE identifiers and references information (secure hostname check)"""
+        identifiers: list[str] = []
+        try:
+            # Extract references/identifiers from the CVE data
+            references = cve_data.get("cve", {}).get("references", [])
+            for ref in references:
+                if url := ref.get("url", ""):
+                    try:
+                        parsed = urlparse(url)
+                        hostname = parsed.hostname or ""
+                        # Use match/case for hostname classification
+                        match hostname:
+                            case "github.com":
+                                identifiers.append("GitHub")
+                            case h if h.endswith(".github.com"):
+                                identifiers.append("GitHub")
+                            case "nvd.nist.gov":
+                                identifiers.append("NVD")
+                            case "cve.mitre.org":
+                                identifiers.append("MITRE")
+                            case "security-tracker.debian.org":
+                                identifiers.append("Debian")
+                            case "access.redhat.com":
+                                identifiers.append("Red Hat")
+                            case "ubuntu.com":
+                                identifiers.append("Ubuntu")
+                            case h if h.endswith(".ubuntu.com"):
+                                identifiers.append("Ubuntu")
+                            case h if "bugzilla" in h:
+                                identifiers.append("Bugzilla")
+                            case "exploit-db.com" | "www.exploit-db.com":
+                                identifiers.append("Exploit-DB")
+                            case h if h:
+                                identifiers.append(h)
+                    except (ValueError, TypeError, AttributeError):
+                        pass
+            return identifiers
+        except (KeyError, TypeError, AttributeError):
+            return []
+
+    def extract_cpe_vendor_info(self, cve_data: dict[str, Any]) -> list[str]:
+        """Extract vendor information from CPE (Common Platform Enumeration) data"""
+        vendors: list[str] = []
+        try:
+            # Look in cve.configurations for CPE data (it's a list, not dict with nodes)
+            configurations = cve_data.get("cve", {}).get("configurations", [])
+
+            # configurations is a list of configuration objects
+            for config in configurations:
+                # Each config has nodes
+                nodes = config.get("nodes", [])
+                for node in nodes:
+                    cpe_matches = node.get("cpeMatch", [])
+                    for cpe in cpe_matches:
+                        # The CPE URI is in 'criteria' field, not 'cpe23Uri'
+                        cpe_uri = cpe.get("criteria", "")
+                        if not cpe_uri:
+                            # Fallback to cpe23Uri if criteria is empty
+                            cpe_uri = cpe.get("cpe23Uri", "")
+
+                        if cpe_uri and cpe_uri.startswith("cpe:2.3:"):
+                            # Parse CPE format: cpe:2.3:part:vendor:product:version:...
+                            parts = cpe_uri.split(":")
+                            if len(parts) > 3:
+                                vendor = parts[3].replace("_", " ").title()
+                                if vendor and vendor.lower() not in ["*", "n/a", "unknown", "-", ""]:
+                                    vendors.append(vendor)
+
+            return list(set(vendors))  # Remove duplicates
+
+        except (KeyError, TypeError, AttributeError):
+            return []
+
+    def extract_vendor_info(self, cve_data):
+        """Extract CNA (CVE Numbering Authority) information for this CVE.
+
+        This extracts only the actual CNA that assigned the CVE ID, not the
+        affected vendors/products (which are in CPE data).
+        """
+        vendors: set[str] = set()
+
+        try:
+            cve = cve_data.get("cve", {})
+
+            # Preferred: CNA/container shortName or name
+            cna_container = cve.get("cnaContainer", {})
+            provider = cna_container.get("providerMetadata", {})
+            for key in ("shortName", "name"):
+                name = provider.get(key)
+                if isinstance(name, str) and name.strip():
+                    vendors.add(name.strip())
+
+            # Legacy / alternate fields
+            for key in ("assignerShortName", "assigner"):
+                name = cve.get(key)
+                if isinstance(name, str) and name.strip():
+                    vendors.add(name.strip())
+
+            # NOTE: Do NOT include CPE vendors here - those are affected products,
+            # not the CNA that assigned the CVE. CPE vendors are tracked separately
+            # in extract_cpe_vendor_info() and cpe_vendors field.
+
+        except (KeyError, TypeError, AttributeError):
+            # Best-effort only
+            pass
+
+        return list(vendors)
+
+    def count_excluded_pre_1999(self) -> int:
+        """Count non-rejected CVEs whose publication date predates the CVE program.
+
+        These are legacy CVEs backdated to their original 1988-1998 disclosure
+        (e.g. CVE-1999-0001, published 1997-12-01). ``cve_all.json`` is assembled
+        from the 1999+ year files, so these records are dropped there, while
+        ``cna_analysis.json`` counts every non-rejected V5 record regardless of
+        date. Reporting the number lets validation subtract a *known* offset
+        instead of absorbing it into a tolerance. See docs/COUNTING.md.
+        """
+        self._ensure_year_buckets()
+        return sum(len(bucket) for year, bucket in self.year_cve_buckets.items() if year < 1999)
+
+    def get_year_data(self, year: int) -> dict[str, Any]:
+        """Main method to get processed data for a specific year"""
+        current_year = datetime.now().year
+
+        if year < 1999 or year > current_year:
+            raise ValueError(f"Year {year} is outside valid range (1999-{current_year})")
+
+        return self.process_year_data(year)
+
+    def get_all_years_data(self) -> dict[int, dict[str, Any]]:
+        """Get data for all available years"""
+        current_year = datetime.now().year
+        all_data: dict[int, dict[str, Any]] = {}
+
+        logger.info(f"📊 Processing all years (1999-{current_year})...")
+
+        for year in range(1999, current_year + 1):
+            try:
+                all_data[year] = self.get_year_data(year)
+            except (ValueError, KeyError, json.JSONDecodeError, OSError) as e:
+                logger.warning(f"⚠️  Failed to process {year}: {e}")
+                # Create empty data structure for failed years
+                all_data[year] = {
+                    "year": year,
+                    "total_cves": 0,
+                    "monthly_counts": [0] * 12,
+                    "severity_distribution": {},
+                    "top_vendors": [],
+                    "top_cwes": [],
+                    "error": str(e),
+                }
+
+        return all_data
+
+    def generate_summary_stats(self) -> dict[str, Any]:
+        """Generate overall summary statistics"""
+        self.ensure_data_loaded()
+
+        logger.info("📊 Generating summary statistics...")
+
+        total_cves = 0
+        year_counts: Counter[int] = Counter()
+        severity_counts: Counter[str] = Counter()
+
+        if self.data_file is None:
+            return {}
+
+        with open(self.data_file, encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+
+                try:
+                    cve_data = json.loads(line)
+                    cve_id = cve_data.get("cve", {}).get("CVE_data_meta", {}).get("ID", "")
+
+                    if cve_id.startswith("CVE-"):
+                        total_cves += 1
+
+                        # Count by year
+                        pub_date = self.parse_cve_date(cve_data)
+                        if pub_date:
+                            year_counts[pub_date.year] += 1
+                        else:
+                            # Fallback to CVE ID year
+                            year = int(cve_id.split("-")[1])
+                            year_counts[year] += 1
+
+                        # Count by severity
+                        severity_info = self.extract_severity_info(cve_data)
+                        severity_counts[severity_info["severity"]] += 1
+
+                except (json.JSONDecodeError, KeyError, ValueError, IndexError):
+                    continue
+
+        return {
+            "total_cves": total_cves,
+            "year_range": (min(year_counts.keys()), max(year_counts.keys())),
+            "years_covered": len(year_counts),
+            "year_distribution": dict(sorted(year_counts.items())),
+            "severity_distribution": dict(severity_counts.most_common()),
+            "generated_at": datetime.now().isoformat(),
+        }
+
+
+def main() -> None:
+    """Main entry point for standalone testing"""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Analyze CVE data by year")
+    parser.add_argument("--year", type=int, help="Analyze specific year")
+    parser.add_argument("--summary", action="store_true", help="Generate summary statistics")
+    parser.add_argument("--all-years", action="store_true", help="Process all years")
+
+    args = parser.parse_args()
+
+    analyzer = CVEYearsAnalyzer()
+
+    if args.summary:
+        stats = analyzer.generate_summary_stats()
+        print(json.dumps(stats, indent=2))
+    elif args.year:
+        year_data = analyzer.get_year_data(args.year)
+        print(json.dumps(year_data, indent=2, default=str))
+    elif args.all_years:
+        all_data = analyzer.get_all_years_data()
+        print(f"Processed {len(all_data)} years")
+        for year, data in sorted(all_data.items()):
+            print(f"  {year}: {data['total_cves']} CVEs")
+    else:
+        print("Please specify --year, --summary, or --all-years")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/src/cvedb/analysis/cvss.py b/data/cvss_analysis.py
similarity index 52%
rename from src/cvedb/analysis/cvss.py
rename to data/cvss_analysis.py
index a9e52cbca6c..096afd916eb 100644
--- a/src/cvedb/analysis/cvss.py
+++ b/data/cvss_analysis.py
@@ -4,93 +4,106 @@
 Handles all CVSS (Common Vulnerability Scoring System) related data processing and analysis
 """
 
+from __future__ import annotations
+
 import json
-from pathlib import Path
+from dataclasses import dataclass, field
 from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
 
 
+@dataclass
 class CVSSAnalyzer:
     """Handles CVSS-specific analysis and data processing"""
-    
-    def __init__(self, base_dir, cache_dir, data_dir, quiet=False):
-        self.quiet = quiet
-        self.base_dir = Path(base_dir)
-        self.cache_dir = Path(cache_dir)
-        self.data_dir = Path(data_dir)
-        self.current_year = datetime.now().year
-    
-    def generate_cvss_analysis(self, all_year_data):
+
+    base_dir: Path
+    cache_dir: Path
+    data_dir: Path
+    quiet: bool = False
+    current_year: int = field(default_factory=lambda: datetime.now().year)
+
+    def __post_init__(self) -> None:
+        """Convert path arguments to Path objects if needed."""
+        self.base_dir = Path(self.base_dir)
+        self.cache_dir = Path(self.cache_dir)
+        self.data_dir = Path(self.data_dir)
+
+    def generate_cvss_analysis(self, all_year_data: list[dict[str, Any]]) -> dict[str, Any]:
         """Generate comprehensive CVSS analysis from all years data"""
         if not self.quiet:
-            print("  📊 Generating CVSS analysis...")
-        
+            logger.info("  📊 Generating CVSS analysis...")
+
         # Initialize combined CVSS data structure for available versions
-        combined_cvss = {
-            'v2.0': {'severity': {}, 'scores': {}},
-            'v3.0': {'severity': {}, 'scores': {}},
-            'v3.1': {'severity': {}, 'scores': {}},
-            'v4.0': {'severity': {}, 'scores': {}}
+        combined_cvss: dict[str, dict[str, dict[str, Any]]] = {
+            "v2.0": {"severity": {}, "scores": {}},
+            "v3.0": {"severity": {}, "scores": {}},
+            "v3.1": {"severity": {}, "scores": {}},
+            "v4.0": {"severity": {}, "scores": {}},
         }
-        
+
         # Initialize temporal data for line chart
         temporal_data = {}
 
         # EPSS-aware aggregates (summary only, no per-CVE payloads)
         epss_global_buckets = {
-            'epss_gt_0_1': 0,
-            'epss_gt_0_5': 0,
-            'epss_gt_0_9': 0,
+            "epss_gt_0_1": 0,
+            "epss_gt_0_5": 0,
+            "epss_gt_0_9": 0,
         }
         epss_by_year = {}
 
         # CISA KEV aggregates (summary only)
         kev_global_count = 0
         kev_by_year = {}
-        
+
         total_cves_with_cvss = 0
-        
+
         # Aggregate data from all years
         for year_data in all_year_data:
-            year = year_data.get('year', 'Unknown')
-            
-            if 'cvss' in year_data:
-                cvss_data = year_data['cvss']
-                
+            year = year_data.get("year", "Unknown")
+
+            if "cvss" in year_data:
+                cvss_data = year_data["cvss"]
+
                 # Initialize temporal data for this year
                 if year not in temporal_data:
-                    temporal_data[year] = {
-                        'v2.0': 0,
-                        'v3.0': 0,
-                        'v3.1': 0,
-                        'v4.0': 0
-                    }
-                
+                    temporal_data[year] = {"v2.0": 0, "v3.0": 0, "v3.1": 0, "v4.0": 0}
+
                 # Process each CVSS version that exists in the data
-                for version in cvss_data.keys():
+                for version in cvss_data:
                     if version in combined_cvss:  # Only process known versions
                         version_data = cvss_data[version]
-                        
+
                         # Add to temporal data (count of CVEs with this version)
-                        if 'total' in version_data:
-                            temporal_data[year][version] = version_data['total']
-                        
+                        if "total" in version_data:
+                            temporal_data[year][version] = version_data["total"]
+
                         # Add to total CVEs with CVSS (use total field from version data)
-                        if 'total' in version_data:
-                            total_cves_with_cvss += version_data['total']
-                        
+                        if "total" in version_data:
+                            total_cves_with_cvss += version_data["total"]
+
                         # Aggregate severity distributions (use correct field name)
-                        if 'severity_distribution' in version_data:
-                            for severity, count in version_data['severity_distribution'].items():
-                                if severity not in combined_cvss[version]['severity']:
-                                    combined_cvss[version]['severity'][severity] = 0
-                                combined_cvss[version]['severity'][severity] += count
-                        
+                        if "severity_distribution" in version_data:
+                            for severity, count in version_data["severity_distribution"].items():
+                                if severity not in combined_cvss[version]["severity"]:
+                                    combined_cvss[version]["severity"][severity] = 0
+                                combined_cvss[version]["severity"][severity] += count
+
                         # Aggregate score distributions (use correct field name)
-                        if 'score_distribution' in version_data:
-                            for score, count in version_data['score_distribution'].items():
-                                if score not in combined_cvss[version]['scores']:
-                                    combined_cvss[version]['scores'][score] = 0
-                                combined_cvss[version]['scores'][score] += count
+                        if "score_distribution" in version_data:
+                            for score, count in version_data["score_distribution"].items():
+                                if score not in combined_cvss[version]["scores"]:
+                                    combined_cvss[version]["scores"][score] = 0
+                                combined_cvss[version]["scores"][score] += count
 
                 # EPSS-aware metrics, if present at year summary level
                 # Expected optional structure on year_data['cvss']:
@@ -99,36 +112,35 @@ def generate_cvss_analysis(self, all_year_data):
                 #       'epss_gt_0_5': int,
                 #       'epss_gt_0_9': int
                 #   }
-                epss_summary = cvss_data.get('epss_summary')
-                if epss_summary:
+                if epss_summary := cvss_data.get("epss_summary"):
                     year_epss = {
-                        'epss_gt_0_1': int(epss_summary.get('epss_gt_0_1', 0)),
-                        'epss_gt_0_5': int(epss_summary.get('epss_gt_0_5', 0)),
-                        'epss_gt_0_9': int(epss_summary.get('epss_gt_0_9', 0)),
+                        "epss_gt_0_1": int(epss_summary.get("epss_gt_0_1", 0)),
+                        "epss_gt_0_5": int(epss_summary.get("epss_gt_0_5", 0)),
+                        "epss_gt_0_9": int(epss_summary.get("epss_gt_0_9", 0)),
                     }
                     epss_by_year[year] = year_epss
                     for k, v in year_epss.items():
                         epss_global_buckets[k] += v
 
             # KEV-aware metrics, if present at year level
-            kev_info = year_data.get('kev') or {}
-            kev_count = int(kev_info.get('kev_count', 0))
+            kev_info = year_data.get("kev") or {}
+            kev_count = int(kev_info.get("kev_count", 0))
             kev_by_year[year] = kev_count
             kev_global_count += kev_count
-        
+
         # Create binned score distributions (0-0.99, 1-1.99, etc.)
-        binned_scores = {}
-        for version in ['v2.0', 'v3.0', 'v3.1', 'v4.0']:
+        binned_scores: dict[str, dict[str, int]] = {}
+        for version in ["v2.0", "v3.0", "v3.1", "v4.0"]:
             binned_scores[version] = {}
-            
+
             # Initialize bins
             for i in range(10):
                 bin_key = f"{i}-{i}.99"
                 binned_scores[version][bin_key] = 0
             binned_scores[version]["10.0"] = 0  # Special case for perfect 10.0
-            
+
             # Aggregate scores into bins
-            for score_str, count in combined_cvss[version]['scores'].items():
+            for score_str, count in combined_cvss[version]["scores"].items():
                 try:
                     score = float(score_str)
                     if score == 10.0:
@@ -140,76 +152,76 @@ def generate_cvss_analysis(self, all_year_data):
                             binned_scores[version][bin_key] += count
                 except (ValueError, KeyError):
                     continue
-        
+
         # Remove empty bins
         for version in binned_scores:
             binned_scores[version] = {k: v for k, v in binned_scores[version].items() if v > 0}
-        
+
         # Calculate overall statistics
         total_by_version = {}
-        for version in ['v2.0', 'v3.0', 'v3.1', 'v4.0']:
-            total_by_version[version] = sum(combined_cvss[version]['severity'].values())
-        
+        for version in ["v2.0", "v3.0", "v3.1", "v4.0"]:
+            total_by_version[version] = sum(combined_cvss[version]["severity"].values())
+
         # Sort temporal data by year for consistent ordering
         sorted_temporal_data = dict(sorted(temporal_data.items()))
-        
+
         cvss_analysis = {
-            'generated_at': datetime.now().isoformat(),
-            'total_cves_with_cvss': total_cves_with_cvss,
-            'total_by_version': total_by_version,
-            'severity_distribution': {version: data['severity'] for version, data in combined_cvss.items()},
-            'score_distribution': {version: data['scores'] for version, data in combined_cvss.items()},
-            'binned_score_distribution': binned_scores,
-            'temporal_data': sorted_temporal_data,
+            "generated_at": datetime.now().isoformat(),
+            "total_cves_with_cvss": total_cves_with_cvss,
+            "total_by_version": total_by_version,
+            "severity_distribution": {version: data["severity"] for version, data in combined_cvss.items()},
+            "score_distribution": {version: data["scores"] for version, data in combined_cvss.items()},
+            "binned_score_distribution": binned_scores,
+            "temporal_data": sorted_temporal_data,
             # EPSS-only aggregate metrics for risk-focused visualizations
-            'epss_global_buckets': epss_global_buckets,
-            'epss_by_year': epss_by_year,
+            "epss_global_buckets": epss_global_buckets,
+            "epss_by_year": epss_by_year,
             # KEV aggregate metrics
-            'kev_global_count': kev_global_count,
-            'kev_by_year': kev_by_year,
+            "kev_global_count": kev_global_count,
+            "kev_by_year": kev_by_year,
         }
-        
+
         # Save to file
-        output_file = self.data_dir / 'cvss_analysis.json'
-        with open(output_file, 'w') as f:
+        output_file = self.data_dir / "cvss_analysis.json"
+        with open(output_file, "w") as f:
             json.dump(cvss_analysis, f, indent=2)
-        
+
         if not self.quiet:
-            print(f"  ✅ Generated CVSS analysis with {total_cves_with_cvss:,} CVEs across all versions")
+            logger.info(f"  ✅ Generated CVSS analysis with {total_cves_with_cvss:,} CVEs across all versions")
         return cvss_analysis
-    
-    def generate_current_year_cvss_analysis(self, current_year_data):
+
+    def generate_current_year_cvss_analysis(self, current_year_data: dict[str, Any]) -> dict[str, Any]:
         """Generate current year CVSS analysis"""
         if not self.quiet:
-            print(f"    📊 Generating current year CVSS analysis...")
-        
+            logger.info("    📊 Generating current year CVSS analysis...")
+
         # Extract CVSS data from current year
-        cvss_data = current_year_data.get('cvss', {})
-        
+        cvss_data = current_year_data.get("cvss", {})
+
         if not cvss_data:
-            print(f"    ⚠️  No CVSS data found for {self.current_year}")
+            logger.warning(f"    ⚠️  No CVSS data found for {self.current_year}")
             return {}
-        
+
         # Create binned score distributions for current year
-        binned_scores = {}
+        binned_scores: dict[str, dict[str, int]] = {}
         total_cves_with_cvss = 0
-        
-        for version in ['v2.0', 'v3.0', 'v3.1', 'v4.0']:
-            if version in cvss_data and 'score_distribution' in cvss_data[version]:
+
+        for version in ["v2.0", "v3.0", "v3.1", "v4.0"]:
+            if version in cvss_data and "score_distribution" in cvss_data[version]:
                 binned_scores[version] = {}
-                
+
                 # Add to total CVEs with CVSS
-                if 'total' in cvss_data[version]:
-                    total_cves_with_cvss += cvss_data[version]['total']
-                
+                if "total" in cvss_data[version]:
+                    total_cves_with_cvss += cvss_data[version]["total"]
+
                 # Initialize bins
                 for i in range(10):
                     bin_key = f"{i}-{i}.99"
                     binned_scores[version][bin_key] = 0
                 binned_scores[version]["10.0"] = 0
-                
+
                 # Aggregate scores into bins
-                for score_str, count in cvss_data[version]['score_distribution'].items():
+                for score_str, count in cvss_data[version]["score_distribution"].items():
                     try:
                         score = float(score_str)
                         if score == 10.0:
@@ -221,33 +233,39 @@ def generate_current_year_cvss_analysis(self, current_year_data):
                                 binned_scores[version][bin_key] += count
                     except (ValueError, KeyError):
                         continue
-                
+
                 # Remove empty bins
                 binned_scores[version] = {k: v for k, v in binned_scores[version].items() if v > 0}
-        
+
         # Calculate totals by version
         total_by_version = {}
-        for version in ['v2.0', 'v3.0', 'v3.1', 'v4.0']:
-            if version in cvss_data and 'severity_distribution' in cvss_data[version]:
-                total_by_version[version] = sum(cvss_data[version]['severity_distribution'].values())
+        for version in ["v2.0", "v3.0", "v3.1", "v4.0"]:
+            if version in cvss_data and "severity_distribution" in cvss_data[version]:
+                total_by_version[version] = sum(cvss_data[version]["severity_distribution"].values())
             else:
                 total_by_version[version] = 0
-        
+
         current_year_cvss_analysis = {
-            'generated_at': datetime.now().isoformat(),
-            'year': self.current_year,
-            'total_cves_with_cvss': total_cves_with_cvss,
-            'total_by_version': total_by_version,
-            'severity_distribution': {version: cvss_data.get(version, {}).get('severity_distribution', {}) for version in ['v2.0', 'v3.0', 'v3.1', 'v4.0']},
-            'score_distribution': {version: cvss_data.get(version, {}).get('score_distribution', {}) for version in ['v2.0', 'v3.0', 'v3.1', 'v4.0']},
-            'binned_score_distribution': binned_scores
+            "generated_at": datetime.now().isoformat(),
+            "year": self.current_year,
+            "total_cves_with_cvss": total_cves_with_cvss,
+            "total_by_version": total_by_version,
+            "severity_distribution": {
+                version: cvss_data.get(version, {}).get("severity_distribution", {})
+                for version in ["v2.0", "v3.0", "v3.1", "v4.0"]
+            },
+            "score_distribution": {
+                version: cvss_data.get(version, {}).get("score_distribution", {})
+                for version in ["v2.0", "v3.0", "v3.1", "v4.0"]
+            },
+            "binned_score_distribution": binned_scores,
         }
-        
+
         # Save current year analysis
-        current_year_file = self.data_dir / 'cvss_analysis_current_year.json'
-        with open(current_year_file, 'w') as f:
+        current_year_file = self.data_dir / "cvss_analysis_current_year.json"
+        with open(current_year_file, "w") as f:
             json.dump(current_year_cvss_analysis, f, indent=2)
-        
+
         if not self.quiet:
-            print(f"    ✅ Generated current year CVSS analysis")
+            logger.info("    ✅ Generated current year CVSS analysis")
         return current_year_cvss_analysis
diff --git a/data/cwe_analysis.py b/data/cwe_analysis.py
new file mode 100644
index 00000000000..27f0a83429f
--- /dev/null
+++ b/data/cwe_analysis.py
@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""
+CWE Analysis Module
+Handles all CWE (Common Weakness Enumeration) related data processing and analysis
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class CWEAnalyzer:
+    """Handles CWE-specific analysis and data processing"""
+
+    base_dir: Path
+    cache_dir: Path
+    data_dir: Path
+    quiet: bool = False
+    current_year: int = field(default_factory=lambda: datetime.now().year)
+
+    def __post_init__(self) -> None:
+        """Convert path arguments to Path objects if needed."""
+        self.base_dir = Path(self.base_dir)
+        self.cache_dir = Path(self.cache_dir)
+        self.data_dir = Path(self.data_dir)
+
+    def generate_cwe_analysis(self, all_year_data: list[dict[str, Any]]) -> dict[str, Any]:
+        """Generate CWE analysis across all years"""
+        if not self.quiet:
+            logger.info("  🔍 Generating CWE analysis...")
+
+        # Aggregate CWE data from all years
+        combined_cwe = {}
+
+        for year_data in all_year_data:
+            if "cwe" in year_data and "top_cwes" in year_data["cwe"]:
+                # Aggregate CWE counts
+                for cwe_entry in year_data["cwe"]["top_cwes"]:
+                    cwe_full = cwe_entry["cwe"]  # e.g., "CWE-79"
+                    cwe_id = cwe_full.replace("CWE-", "") if cwe_full.startswith("CWE-") else cwe_full
+                    count = cwe_entry["count"]
+
+                    if cwe_id not in combined_cwe:
+                        combined_cwe[cwe_id] = {
+                            "id": cwe_id,
+                            "name": cwe_entry.get("name", f"CWE-{cwe_id}"),
+                            "count": 0,
+                        }
+
+                    combined_cwe[cwe_id]["count"] += count
+
+        # Sort by count and get top CWEs
+        top_cwes = sorted(combined_cwe.values(), key=lambda x: x["count"], reverse=True)
+
+        # Calculate total CVEs with CWE from aggregated counts
+        total_cves_with_cwe = sum(cwe["count"] for cwe in combined_cwe.values())
+
+        # Add common CWE descriptions for better understanding
+        cwe_descriptions = {
+            "79": "Cross-site Scripting (XSS)",
+            "89": "SQL Injection",
+            "20": "Improper Input Validation",
+            "22": "Path Traversal",
+            "352": "Cross-Site Request Forgery (CSRF)",
+            "78": "OS Command Injection",
+            "190": "Integer Overflow",
+            "476": "NULL Pointer Dereference",
+            "94": "Code Injection",
+            "119": "Buffer Overflow",
+            "125": "Out-of-bounds Read",
+            "787": "Out-of-bounds Write",
+            "416": "Use After Free",
+            "200": "Information Exposure",
+            "434": "Unrestricted Upload of File",
+            "862": "Missing Authorization",
+            "863": "Incorrect Authorization",
+            "269": "Improper Privilege Management",
+            "287": "Improper Authentication",
+            "295": "Improper Certificate Validation",
+        }
+
+        # Enhance CWE entries with descriptions
+        for cwe in top_cwes:
+            cwe_id = cwe["id"]
+            if cwe_id in cwe_descriptions:
+                cwe["description"] = cwe_descriptions[cwe_id]
+                cwe["name"] = f"CWE-{cwe_id}: {cwe_descriptions[cwe_id]}"
+            else:
+                cwe["description"] = f"CWE-{cwe_id}"
+
+        cwe_analysis = {
+            "generated_at": datetime.now().isoformat(),
+            "total_cves_with_cwe": total_cves_with_cwe,
+            "total_unique_cwes": len(combined_cwe),
+            "top_cwes": top_cwes,  # All CWEs
+            "top_cwes_limited": top_cwes[:20],  # Top 20 for charts
+        }
+
+        # Save to file
+        output_file = self.data_dir / "cwe_analysis.json"
+        with open(output_file, "w") as f:
+            json.dump(cwe_analysis, f, indent=2)
+
+        if not self.quiet:
+            logger.info(f"  ✅ Generated CWE analysis with {len(combined_cwe):,} unique CWEs")
+        return cwe_analysis
+
+    def generate_current_year_cwe_analysis(self, current_year_data: dict[str, Any]) -> dict[str, Any]:
+        """Generate current year CWE analysis"""
+        if not self.quiet:
+            logger.info("    🔍 Generating current year CWE analysis...")
+
+        # Extract CWE data from current year
+        cwe_data = current_year_data.get("cwe", {})
+
+        if not cwe_data or "top_cwes" not in cwe_data:
+            logger.warning(f"    ⚠️  No CWE data found for {self.current_year}")
+            return {}
+
+        # Get current year CWEs
+        current_year_cwes = cwe_data["top_cwes"]
+
+        # Add descriptions to current year CWEs
+        cwe_descriptions = {
+            "79": "Cross-site Scripting (XSS)",
+            "89": "SQL Injection",
+            "20": "Improper Input Validation",
+            "22": "Path Traversal",
+            "352": "Cross-Site Request Forgery (CSRF)",
+            "78": "OS Command Injection",
+            "190": "Integer Overflow",
+            "476": "NULL Pointer Dereference",
+            "94": "Code Injection",
+            "119": "Buffer Overflow",
+            "125": "Out-of-bounds Read",
+            "787": "Out-of-bounds Write",
+            "416": "Use After Free",
+            "200": "Information Exposure",
+            "434": "Unrestricted Upload of File",
+            "862": "Missing Authorization",
+            "863": "Incorrect Authorization",
+            "269": "Improper Privilege Management",
+            "287": "Improper Authentication",
+            "295": "Improper Certificate Validation",
+        }
+
+        # Enhance CWE entries with descriptions
+        enhanced_cwes = []
+        for cwe in current_year_cwes:
+            cwe_full = cwe["cwe"]  # e.g., "CWE-79"
+            cwe_id = cwe_full.replace("CWE-", "") if cwe_full.startswith("CWE-") else cwe_full
+            enhanced_cwe = cwe.copy()
+            enhanced_cwe["id"] = cwe_id  # Add id field for consistency
+
+            if cwe_id in cwe_descriptions:
+                enhanced_cwe["description"] = cwe_descriptions[cwe_id]
+                enhanced_cwe["name"] = f"CWE-{cwe_id}: {cwe_descriptions[cwe_id]}"
+            else:
+                enhanced_cwe["description"] = f"CWE-{cwe_id}"
+                enhanced_cwe["name"] = f"CWE-{cwe_id}"
+
+            enhanced_cwes.append(enhanced_cwe)
+
+        # Calculate total CVEs with CWE from individual counts
+        total_cves_with_cwe = sum(cwe["count"] for cwe in current_year_cwes)
+
+        current_year_cwe_analysis = {
+            "generated_at": datetime.now().isoformat(),
+            "year": self.current_year,
+            "total_cves_with_cwe": total_cves_with_cwe,
+            "total_unique_cwes": len(current_year_cwes),
+            "top_cwes": enhanced_cwes,  # All CWEs
+            "top_cwes_limited": enhanced_cwes[:20],  # Top 20 for charts
+        }
+
+        # Save current year analysis
+        current_year_file = self.data_dir / "cwe_analysis_current_year.json"
+        with open(current_year_file, "w") as f:
+            json.dump(current_year_cwe_analysis, f, indent=2)
+
+        if not self.quiet:
+            logger.info(f"    ✅ Generated current year CWE analysis with {len(current_year_cwes)} CWEs")
+        return current_year_cwe_analysis
diff --git a/data/download_cve_data.py b/data/download_cve_data.py
new file mode 100644
index 00000000000..fd5354e6fd7
--- /dev/null
+++ b/data/download_cve_data.py
@@ -0,0 +1,1047 @@
+#!/usr/bin/env python3
+"""
+CVE Data Download Script
+Downloads and caches CVE data from NVD source for processing
+Replaces the wget step from GitHub Actions with proper Python error handling
+"""
+
+from __future__ import annotations
+
+import csv
+import gzip
+import hashlib
+import json
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+import requests
+from protocols import (
+    DataReader,
+    DataWriter,
+    FileSystemDataReader,
+    FileSystemDataWriter,
+    HttpClient,
+    RequestsHttpClient,
+)
+
+
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+# Sanity floors for the small feeds. Both endpoints answer 200 with a body, so
+# raise_for_status() cannot tell a good download from a truncated or empty one -
+# and both used to be written straight over the cache, so a bad response
+# destroyed the last good copy and surfaced later as a quietly shrinking count
+# rather than an error. Downloads now land in a temp file, are checked, and only
+# then replace the cache.
+MIN_EPSS_BYTES = 500_000  # the real file is ~2.6 MB gzipped
+MIN_EPSS_ROWS = 100_000  # the real feed carries ~377k rows
+MIN_KEV_BYTES = 200_000  # the real catalog is ~2.2 MB
+MIN_KEV_ENTRIES = 500  # the real catalog holds ~1,700
+# A new download may legitimately shrink a little, but not collapse. Reject
+# anything below this fraction of what we already had.
+MIN_RETAINED_FRACTION = 0.6
+
+
+class CVEDataDownloader:
+    """Downloads and manages CVE data from NVD source.
+
+    Supports dependency injection for testability:
+    - http_client: HttpClient protocol for HTTP requests
+    - data_reader: DataReader protocol for file reading
+    - data_writer: DataWriter protocol for file writing
+
+    When dependencies are not provided, uses default implementations
+    (requests for HTTP, filesystem for files).
+    """
+
+    def __init__(
+        self,
+        cache_dir: Path | str | None = None,
+        quiet: bool = False,
+        *,
+        http_client: HttpClient | None = None,
+        data_reader: DataReader | None = None,
+        data_writer: DataWriter | None = None,
+    ) -> None:
+        self.quiet: bool = quiet
+        self.base_dir: Path = Path(__file__).parent
+        self.cache_dir: Path = Path(cache_dir) if cache_dir else (self.base_dir / "cache")
+
+        # Dependency injection with defaults
+        self._http_client = http_client or RequestsHttpClient()
+        self._data_reader = data_reader or FileSystemDataReader()
+        self._data_writer = data_writer or FileSystemDataWriter()
+
+        # Create cache directory using writer
+        self._data_writer.mkdir(self.cache_dir)
+
+        # Data source configuration
+        self.nvd_url: str = "https://nvd.handsonhacking.org/nvd.json"
+        self.cache_file: Path = self.cache_dir / "nvd.json"
+        self.cache_info_file: Path = self.cache_dir / "cache_info.json"
+        # Must stay below the build interval or runs re-use the cache and fetch
+        # nothing. Build is hourly, so this expires comfortably inside the hour.
+        self.cache_duration: timedelta = timedelta(minutes=50)
+        # EPSS republishes once a day and KEV a few times a week; re-fetching
+        # either every hour is wasted traffic against FIRST and CISA.
+        self.epss_cache_duration: timedelta = timedelta(hours=6)
+        self.kev_cache_duration: timedelta = timedelta(hours=6)
+
+        # Producer-published manifest describing the snapshot behind nvd.json.
+        # Small (~2KB), no-cache, and written *after* the data object, so a
+        # manifest that names a snapshot implies that snapshot is fully uploaded.
+        self.manifest_url: str = "https://nvd.handsonhacking.org/metadata.json"
+        # The last manifest we accepted, republished with the site so the next
+        # build has a baseline without needing repo state. See docs in
+        # verify_manifest_not_regressed().
+        self.manifest_baseline_url: str = "https://cvedb.github.io/data/source_manifest.json"
+        self.manifest_file: Path = self.cache_dir / "source_manifest.json"
+        # The manifest the bytes on disk actually match. Usually the one we
+        # fetched before downloading, but a publish landing mid-download
+        # leaves us holding the next snapshot instead. Callers persist this
+        # rather than what they asked for, so the baseline we republish can
+        # never name a snapshot we do not have.
+        self.accepted_manifest: dict[str, Any] | None = None
+        # Producer reports its own completeness_ratio. This is a catastrophe
+        # backstop only, NOT the primary defence: the regression check against
+        # the last accepted manifest is. Calibration caveat: the only healthy
+        # value observed so far is 0.9992, so the normal variance of this field
+        # is unknown and the threshold is deliberately loose. Tighten it once
+        # there is a distribution to set it from, rather than from one sample.
+        self.min_completeness_ratio: float = 0.995
+
+        # CNA mapping files for proper name resolution
+        self.cna_list_url: str = (
+            "https://raw.githubusercontent.com/CVEProject/cve-website/dev/src/assets/data/CNAsList.json"
+        )
+        self.cna_name_map_url: str = "https://www.cve.org/cve-partner-name-map.json"
+        self.cna_list_file: Path = self.cache_dir / "cna_list.json"
+        self.cna_name_map_file: Path = self.cache_dir / "cna_name_map.json"
+
+        # EPSS data (Exploit Prediction Scoring System)
+        # Current snapshot feed documented at https://www.first.org/epss/
+        # Note: EPSS moved from cyentia.com to empiricalsecurity.com in late 2025
+        self.epss_url: str = "https://epss.empiricalsecurity.com/epss_scores-current.csv.gz"
+        self.epss_cache_file: Path = self.cache_dir / "epss_scores-current.csv.gz"
+        self.epss_parsed_file: Path = self.cache_dir / "epss_scores-current.json"
+
+        # CISA Known Exploited Vulnerabilities (KEV) catalog
+        # Official catalog: https://www.cisa.gov/known-exploited-vulnerabilities-catalog
+        # JSON feed: a list of objects with a cveID field.
+        self.kev_url: str = "https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json"
+        self.kev_cache_file: Path = self.cache_dir / "known_exploited_vulnerabilities.json"
+        self.kev_parsed_file: Path = self.cache_dir / "known_exploited_vulnerabilities_parsed.json"
+
+        if not self.quiet:
+            logger.info("🔽 CVE Data Downloader Initialized")
+            logger.info(f"📁 Cache directory: {self.cache_dir}")
+            logger.info(f"🌐 Data source: {self.nvd_url}")
+
+    def is_cache_valid(self) -> bool:
+        """Check if cached data is still valid"""
+        if not self._data_reader.exists(self.cache_file) or not self._data_reader.exists(self.cache_info_file):
+            return False
+
+        try:
+            cache_info = self._data_reader.read_json(self.cache_info_file)
+
+            cache_time = datetime.fromisoformat(cache_info["download_time"])
+            # Older cache_info files carry a naive local timestamp; treat those
+            # as UTC so the comparison below stays valid across the format change.
+            if cache_time.tzinfo is None:
+                cache_time = cache_time.replace(tzinfo=UTC)
+            if datetime.now(UTC) - cache_time > self.cache_duration:
+                if not self.quiet:
+                    logger.info(f"⏰ Cache expired (older than {self.cache_duration})")
+                return False
+
+            if not self.quiet:
+                logger.info(f"✅ Cache is valid (downloaded {cache_time.strftime('%Y-%m-%d %H:%M:%S')})")
+            return True
+
+        except (json.JSONDecodeError, KeyError, ValueError) as e:
+            if not self.quiet:
+                logger.warning(f"⚠️  Cache info corrupted: {e}")
+            return False
+
+    def download_data(self, force: bool = False, manifest: dict[str, Any] | None = None) -> Path:
+        """Download CVE data from NVD source.
+
+        Args:
+            force: bypass the local cache-validity check.
+            manifest: producer manifest for this snapshot. When it carries
+                'bytes' or 'sha256', the downloaded object is verified against
+                them before being accepted.
+        """
+        if not force and self.is_cache_valid():
+            if not self.quiet:
+                logger.info("📋 Using cached data")
+            self.accepted_manifest = manifest
+            return self.cache_file
+
+        if not self.quiet:
+            logger.info(f"🔽 Downloading CVE data from {self.nvd_url}")
+
+        try:
+            # Start download with progress tracking (use injected HTTP client)
+            response = self._http_client.get(self.nvd_url, stream=True)
+            response.raise_for_status()
+
+            # Get file size for progress tracking
+            total_size = int(response.headers.get("content-length", 0))
+            downloaded_size = 0
+
+            # Download with progress updates - collect chunks then write
+            chunks: list[bytes] = []
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    chunks.append(chunk)
+                    downloaded_size += len(chunk)
+
+                    # Show progress every 10MB
+                    if downloaded_size % (10 * 1024 * 1024) == 0 or downloaded_size == total_size:
+                        if total_size > 0:
+                            progress = (downloaded_size / total_size) * 100
+                            logger.debug(
+                                f"  📥 Downloaded {downloaded_size // (1024 * 1024)}MB / {total_size // (1024 * 1024)}MB ({progress:.1f}%)"
+                            )
+
+            # A dropped connection previously produced a short file that was
+            # written and reported as a success. content-length is advisory,
+            # but when the server sends one, a mismatch means truncation.
+            if total_size and downloaded_size != total_size:
+                raise OSError(
+                    f"Truncated download: received {downloaded_size:,} of "
+                    f"{total_size:,} bytes declared by content-length"
+                )
+
+            # Write using data writer
+            self._data_writer.write_bytes(self.cache_file, b"".join(chunks))
+
+            # Hash once. Both the manifest check below and cache_info need the
+            # digest, and a second streaming pass over ~1.8GB is not free on a
+            # CI runner.
+            file_hash = self.calculate_file_hash_streaming(self.cache_file)
+
+            # Verify the object against the producer's manifest before we treat
+            # it as usable. Returns the manifest the bytes actually match, which
+            # is a newer one when we raced a publish. Raises on a real mismatch.
+            manifest = self.verify_download_against_manifest(manifest, downloaded_size, file_hash)
+            self.accepted_manifest = manifest
+
+            # Save cache info using data writer
+            cache_info = {
+                # UTC: this value is compared against build time to derive data
+                # age, and a naive local timestamp made that comparison wrong.
+                "download_time": datetime.now(UTC).isoformat(),
+                "file_size": downloaded_size,
+                "file_hash": file_hash,
+                "source_url": self.nvd_url,
+                "source_last_run": (manifest or {}).get("last_run_iso"),
+                "source_cve_count": (manifest or {}).get("cve_count"),
+                "source_commit_sha": (manifest or {}).get("commit_sha"),
+            }
+
+            self._data_writer.write_json(self.cache_info_file, cache_info)
+
+            logger.info("✅ Download completed successfully")
+            logger.info(f"📊 File size: {downloaded_size // (1024 * 1024)}MB")
+            logger.debug(f"🔐 File hash: {file_hash[:16]}...")
+
+            return self.cache_file
+
+        except requests.RequestException as e:
+            logger.error(f"❌ Download failed: {e}")
+            # Try to use cached data if available, even if expired
+            if self._data_reader.exists(self.cache_file):
+                logger.warning("⚠️  Using expired cached data as fallback")
+                return self.cache_file
+            raise
+
+        except (OSError, json.JSONDecodeError) as e:
+            logger.error(f"❌ File or JSON error during download: {e}")
+            raise
+
+    def download_cna_mapping_files(self) -> None:
+        """Download CNA mapping files for proper name resolution"""
+        logger.info("🔽 Downloading CNA mapping files...")
+
+        try:
+            # Download CNA list (use injected HTTP client)
+            logger.debug("  📥 Downloading CNA list from CVE.org...")
+            response = self._http_client.get(self.cna_list_url, timeout=30)
+            response.raise_for_status()
+
+            self._data_writer.write_json(self.cna_list_file, response.json())
+            logger.debug(f"  ✅ CNA list saved to {self.cna_list_file.name}")
+
+            # Download CNA name mapping (use injected HTTP client)
+            logger.debug("  📥 Downloading CNA name mapping from CVE.org...")
+            response = self._http_client.get(self.cna_name_map_url, timeout=30)
+            response.raise_for_status()
+
+            self._data_writer.write_json(self.cna_name_map_file, response.json())
+            logger.debug(f"  ✅ CNA name mapping saved to {self.cna_name_map_file.name}")
+
+            logger.info("✅ CNA mapping files downloaded successfully")
+
+        except requests.RequestException as e:
+            logger.warning(f"⚠️  Warning: Could not download CNA mapping files: {e}")
+            logger.warning("  📝 Will use raw sourceIdentifier values as fallback")
+        except (OSError, json.JSONDecodeError) as e:
+            logger.warning(f"⚠️  Warning: File or JSON error downloading CNA files: {e}")
+
+    # ------------------------------------------------------------------
+    # Source manifest handling
+    #
+    # The producer publishes metadata.json alongside nvd.json describing the
+    # snapshot it just uploaded. Checking it before pulling the ~1.8GB object
+    # turns several count heuristics into exact checks, and catches a short
+    # snapshot before we spend the bandwidth on it.
+    #
+    # Keying note: manifest year_counts are keyed by CVE-ID year, while this
+    # site buckets by publication date. The two are different partitions of
+    # the same data (year 1999 is 1,579 by ID and 923 by publication date), so
+    # manifest counts are only ever compared to *previous manifest* counts,
+    # never to our own per-year outputs.
+    # ------------------------------------------------------------------
+
+    def fetch_source_manifest(self) -> dict[str, Any] | None:
+        """Fetch the producer's manifest for the current snapshot.
+
+        Returns None when the manifest cannot be retrieved or parsed, which
+        callers treat as "unverified" rather than as a failure, so a producer
+        that has not yet deployed the manifest does not break the build.
+        """
+        try:
+            response = self._http_client.get(self.manifest_url, timeout=30)
+            status = getattr(response, "status_code", 200)
+            if status >= 400:
+                logger.warning(f"⚠️  Source manifest returned HTTP {status}")
+                return None
+            manifest = response.json()
+        except (requests.RequestException, ValueError, json.JSONDecodeError, OSError) as e:
+            logger.warning(f"⚠️  Could not fetch source manifest: {e}")
+            return None
+
+        if not isinstance(manifest, dict) or "cve_count" not in manifest:
+            logger.warning("⚠️  Source manifest is malformed; ignoring")
+            return None
+
+        logger.info(
+            f"📄 Source manifest: {manifest['cve_count']:,} CVEs, run {manifest.get('last_run_iso', 'unknown')}"
+        )
+        return manifest
+
+    def fetch_baseline_manifest(self) -> dict[str, Any] | None:
+        """Fetch the last manifest we accepted, as republished with the site."""
+        try:
+            response = self._http_client.get(self.manifest_baseline_url, timeout=30)
+            status = getattr(response, "status_code", 200)
+            if status == 404:
+                logger.info("📄 No published baseline manifest yet (first run)")
+                return None
+            if status >= 400:
+                logger.warning(f"⚠️  Baseline manifest returned HTTP {status}")
+                return None
+            baseline = response.json()
+        except (requests.RequestException, ValueError, json.JSONDecodeError, OSError) as e:
+            logger.warning(f"⚠️  Could not fetch baseline manifest: {e}")
+            return None
+
+        if not isinstance(baseline, dict) or "cve_count" not in baseline:
+            logger.warning("⚠️  Baseline manifest is malformed; ignoring")
+            return None
+        return baseline
+
+    def verify_manifest_healthy(self, manifest: dict[str, Any]) -> None:
+        """Reject a snapshot the producer itself reports as incomplete.
+
+        Raises:
+            ValueError: if the run was degraded, fell back to the API for any
+                year, or came in under the completeness threshold.
+        """
+        if manifest.get("degraded"):
+            raise ValueError(
+                f"Producer reported a degraded run (last_run_iso={manifest.get('last_run_iso')}). Refusing to ingest."
+            )
+
+        years_via_api = manifest.get("years_via_api") or []
+        if years_via_api:
+            raise ValueError(
+                f"Producer fell back to the REST API for year(s) {years_via_api}. "
+                "That fallback drops records whose CVE-ID year and publication "
+                "year differ. Refusing to ingest."
+            )
+
+        ratio = manifest.get("completeness_ratio")
+        if ratio is not None and ratio < self.min_completeness_ratio:
+            raise ValueError(
+                f"Producer completeness_ratio {ratio} is below "
+                f"{self.min_completeness_ratio} "
+                f"({manifest.get('cve_count'):,} of an expected "
+                f"{manifest.get('expected_total')}). Refusing to ingest."
+            )
+
+    def verify_manifest_not_regressed(
+        self,
+        manifest: dict[str, Any],
+        baseline: dict[str, Any] | None,
+    ) -> None:
+        """Reject a snapshot smaller than the last one we accepted.
+
+        Both sides are CVE-ID keyed, so this is a like-for-like comparison.
+        CVEs are withdrawn occasionally, but a genuine withdrawal is a handful
+        of records; every regression observed in this feed's history has been a
+        producer-side fault of hundreds to thousands.
+
+        Raises:
+            ValueError: on any decrease in the total or in any per-year count.
+        """
+        if baseline is None:
+            logger.info("📄 No baseline to compare against; accepting manifest")
+            return
+
+        problems: list[str] = []
+
+        prev_total = baseline.get("cve_count", 0)
+        new_total = manifest.get("cve_count", 0)
+        if new_total < prev_total:
+            problems.append(f"total {prev_total:,} -> {new_total:,} ({new_total - prev_total:,})")
+
+        new_years = manifest.get("year_counts") or {}
+        for year, prev_count in sorted((baseline.get("year_counts") or {}).items()):
+            new_count = new_years.get(year, 0)
+            if new_count < prev_count:
+                problems.append(f"year {year} {prev_count:,} -> {new_count:,} ({new_count - prev_count:,})")
+
+        if problems:
+            raise ValueError(
+                "Source manifest regressed against the last accepted snapshot:\n  "
+                + "\n  ".join(problems)
+                + "\nRefusing to ingest. Re-run once the producer publishes a "
+                "complete snapshot, or pass --accept-baseline to override."
+            )
+
+        logger.info(f"✅ Manifest not regressed (total {prev_total:,} -> {new_total:,})")
+
+    def describe_manifest_mismatch(
+        self,
+        manifest: dict[str, Any],
+        downloaded_size: int,
+        actual_sha: str | None = None,
+    ) -> str | None:
+        """Describe how the downloaded bytes differ from the manifest.
+
+        Returns None when they match. Both manifest fields are optional: they
+        appear only from the first producer run after the integrity work
+        landed, so their absence is logged and skipped, not treated as a
+        mismatch. actual_sha lets the caller reuse a digest it already has
+        rather than re-reading ~1.8GB.
+        """
+        expected_bytes = manifest.get("bytes")
+        if expected_bytes is None:
+            logger.warning("⚠️  Manifest has no 'bytes' field; skipping size verification")
+        elif downloaded_size != expected_bytes:
+            return f"Size mismatch: downloaded {downloaded_size:,} bytes, manifest declares {expected_bytes:,}."
+
+        expected_sha = manifest.get("sha256")
+        if expected_sha is None:
+            logger.warning("⚠️  Manifest has no 'sha256' field; skipping digest verification")
+            return None
+
+        if actual_sha is None:
+            actual_sha = self.calculate_file_hash_streaming(self.cache_file)
+        if actual_sha != expected_sha:
+            return f"SHA-256 mismatch: computed {actual_sha}, manifest declares {expected_sha}."
+        return None
+
+    def verify_download_against_manifest(
+        self,
+        manifest: dict[str, Any] | None,
+        downloaded_size: int,
+        actual_sha: str | None = None,
+    ) -> dict[str, Any] | None:
+        """Verify the downloaded object against the manifest, tolerating a race.
+
+        A mismatch is not automatically corruption. The producer uploads
+        nvd.json and then metadata.json, so between those two writes the data
+        object is already the new snapshot while the manifest still describes
+        the old one; a download straddling the swap lands in the same state.
+        That used to fail the build outright, under the misleading message
+        "Snapshot is incomplete" — the snapshot is complete, it just moved.
+        The producer went from a 3-hourly to an hourly cadence on 2026-09-22,
+        so this window is hit more often than it was.
+
+        Re-read the manifest once when the bytes disagree. If they match the
+        newer snapshot, we raced a publish and the data is good. A manifest
+        that has not moved means the bytes really are bad, which still fails.
+
+        Returns:
+            The manifest the downloaded bytes actually match, so the caller
+            records the snapshot it has rather than the one it asked for.
+            None when there was no manifest to verify against.
+
+        Raises:
+            OSError: when the bytes match neither the original manifest nor a
+                freshly fetched one.
+            ValueError: when the snapshot we raced into is itself unhealthy.
+        """
+        if not manifest:
+            return None
+
+        mismatch = self.describe_manifest_mismatch(manifest, downloaded_size, actual_sha)
+        if mismatch is None:
+            logger.info(f"✅ Verified against manifest ({downloaded_size:,} bytes)")
+            return manifest
+
+        logger.warning(f"⚠️  {mismatch}")
+        logger.warning("⚠️  Re-reading the manifest in case a publish landed mid-download")
+
+        fresh = self.fetch_source_manifest()
+        if fresh is None:
+            raise OSError(f"{mismatch} Could not re-read the manifest to rule out a concurrent publish.")
+
+        if fresh.get("sha256") == manifest.get("sha256") and fresh.get("bytes") == manifest.get("bytes"):
+            raise OSError(f"{mismatch} The manifest has not moved, so this is a bad download, not a publish.")
+
+        second = self.describe_manifest_mismatch(fresh, downloaded_size, actual_sha)
+        if second is not None:
+            raise OSError(f"{second} The manifest moved mid-download and the bytes match neither snapshot.")
+
+        # We are about to accept a snapshot the caller never gated, so re-run
+        # the producer-health check on it here. The regression check needs a
+        # baseline fetch and a caller-held override flag, so it stays with the
+        # caller, which compares against self.accepted_manifest.
+        self.verify_manifest_healthy(fresh)
+
+        logger.info(f"✅ Raced a publish; bytes match the newer snapshot (run {fresh.get('last_run_iso', 'unknown')})")
+        return fresh
+
+    def persist_accepted_manifest(self, manifest: dict[str, Any]) -> None:
+        """Record the manifest we accepted so the site can republish it."""
+        self._data_writer.write_json(self.manifest_file, manifest)
+        logger.debug(f"  📄 Accepted manifest saved to {self.manifest_file.name}")
+
+    def calculate_file_hash_streaming(self, file_path: Path, chunk_size: int = 8 * 1024 * 1024) -> str:
+        """SHA-256 a file without loading it into memory.
+
+        calculate_file_hash() reads the whole file, which is not viable for the
+        ~1.8GB snapshot on a CI runner.
+        """
+        hash_sha256 = hashlib.sha256()
+        with open(file_path, "rb") as fh:
+            for chunk in iter(lambda: fh.read(chunk_size), b""):
+                hash_sha256.update(chunk)
+        return hash_sha256.hexdigest()
+
+    def calculate_file_hash(self, file_path: Path) -> str:
+        """Calculate SHA256 hash of file for integrity checking"""
+        hash_sha256 = hashlib.sha256()
+        content = self._data_reader.read_bytes(file_path)
+        hash_sha256.update(content)
+        return hash_sha256.hexdigest()
+
+    def validate_json_format(self, file_path: Path) -> bool:
+        """Validate that the downloaded file contains valid CVE data (JSON array format)"""
+        try:
+            logger.info("🔍 Validating JSON format...")
+
+            try:
+                # Try to load as JSON array using data reader
+                cve_data = self._data_reader.read_json(file_path)
+
+                if not isinstance(cve_data, list):
+                    raise ValueError("Expected JSON array format")
+
+                total_records = len(cve_data)
+                valid_cve_count = 0
+
+                logger.debug(f"  📊 Found {total_records:,} records in JSON array")
+
+                # Validate a sample of records
+                sample_size = min(1000, total_records)
+                for i in range(0, total_records, max(1, total_records // sample_size)):
+                    if i >= total_records:
+                        break
+
+                    record = cve_data[i]
+                    if isinstance(record, dict) and "cve" in record:
+                        cve_id = record.get("cve", {}).get("id", "")
+                        if cve_id.startswith("CVE-"):
+                            valid_cve_count += 1
+
+                logger.info("✅ Validation complete:")
+                logger.info(f"  📊 Total records: {total_records:,}")
+                logger.debug(f"  ✅ Valid CVEs (sampled): {valid_cve_count}/{sample_size}")
+                logger.debug(f"  📈 Success rate: {(valid_cve_count / sample_size) * 100:.1f}%")
+
+                if valid_cve_count == 0:
+                    raise ValueError("No valid CVE records found in downloaded data")
+
+                return True
+
+            except json.JSONDecodeError as e:
+                logger.error(f"❌ Failed to parse JSON: {e}")
+                return False
+
+        except (json.JSONDecodeError, KeyError, ValueError, OSError) as e:
+            logger.error(f"❌ Validation failed: {e}")
+            return False
+
+    def get_data_stats(self) -> dict[str, Any] | None:
+        """Get statistics about the cached data (JSON array format)"""
+        if not self._data_reader.exists(self.cache_file):
+            return None
+
+        try:
+            cache_info = self._data_reader.read_json(self.cache_info_file)
+
+            # Load and process JSON array
+            with open(self.cache_file, encoding="utf-8") as f:
+                cve_data_array = json.load(f)
+
+            # Quick scan for year distribution
+            year_counts: dict[int, int] = {}
+            total_cves = 0
+
+            # Sample every 100th record for performance (still gives accurate stats)
+            sample_size = max(1, len(cve_data_array) // 100)
+            for i in range(0, len(cve_data_array), sample_size):
+                try:
+                    cve_record = cve_data_array[i]
+                    cve_id = cve_record.get("cve", {}).get("id", "")
+
+                    if cve_id.startswith("CVE-"):
+                        # Extract year from CVE-YYYY-NNNN format
+                        year = int(cve_id.split("-")[1])
+                        year_counts[year] = year_counts.get(year, 0) + sample_size
+                        total_cves += sample_size
+
+                except (KeyError, ValueError, IndexError):
+                    continue
+
+            # Adjust for sampling
+            actual_total = len(cve_data_array)
+
+            return {
+                "cache_info": cache_info,
+                "total_cves": actual_total,
+                "year_range": (min(year_counts.keys()), max(year_counts.keys())) if year_counts else (None, None),
+                "year_counts": dict(sorted(year_counts.items())),
+            }
+
+        except (json.JSONDecodeError, KeyError, ValueError, OSError) as e:
+            logger.warning(f"⚠️  Could not get data stats: {e}")
+            return None
+
+    def ensure_data_available(self, force_download: bool = False, accept_baseline: bool = False) -> Path:
+        """Main method to ensure CVE data is available and valid.
+
+        Args:
+            force_download: bypass the local cache-validity check.
+            accept_baseline: skip the manifest regression check. For the rare
+                case where the producer legitimately publishes a smaller
+                snapshot (a genuine mass withdrawal) and a human has confirmed it.
+        """
+        logger.info("\n🔽 Ensuring CVE data is available...")
+        logger.info("=" * 50)
+
+        try:
+            # Check the producer's manifest before pulling ~1.8GB. A degraded or
+            # regressed snapshot is rejected here, at zero bandwidth cost.
+            manifest = self.fetch_source_manifest()
+            if manifest is not None:
+                if accept_baseline:
+                    logger.warning("⚠️  --accept-baseline: skipping manifest regression check")
+                else:
+                    self.verify_manifest_healthy(manifest)
+                    self.verify_manifest_not_regressed(manifest, self.fetch_baseline_manifest())
+            else:
+                logger.warning("⚠️  Proceeding without manifest verification (producer manifest unavailable)")
+
+            # Download data if needed
+            data_file = self.download_data(force=force_download, manifest=manifest)
+
+            # download_data resolves which snapshot the bytes actually are,
+            # which is not the one gated above when a publish landed mid-download.
+            # Re-run the regression gate on what we really have, so racing a
+            # publish cannot become a way past it.
+            accepted = self.accepted_manifest
+            if accepted is not None and accepted is not manifest:
+                if accept_baseline:
+                    logger.warning("⚠️  --accept-baseline: skipping regression check on the raced snapshot")
+                else:
+                    logger.info("🔁 Re-checking the snapshot we actually downloaded")
+                    self.verify_manifest_not_regressed(accepted, self.fetch_baseline_manifest())
+
+            # Only record the manifest once the object it describes has been
+            # downloaded and verified, so the published baseline can never name
+            # a snapshot we did not actually accept.
+            if accepted is not None:
+                self.persist_accepted_manifest(accepted)
+
+            # Download CNA mapping files
+            self.download_cna_mapping_files()
+
+            # Validate format
+            if not self.validate_json_format(data_file):
+                raise ValueError("Downloaded data failed validation")
+
+            # Show statistics
+            stats = self.get_data_stats()
+            if stats:
+                logger.info("\n📊 Data Statistics:")
+                logger.info(f"  📅 Downloaded: {stats['cache_info']['download_time']}")
+                logger.info(f"  📊 Total CVEs: {stats['total_cves']:,}")
+                if stats["year_range"][0]:
+                    logger.info(f"  📅 Year range: {stats['year_range'][0]}-{stats['year_range'][1]}")
+                    logger.debug(f"  📈 Years covered: {len(stats['year_counts'])}")
+
+            logger.info("\n" + "=" * 50)
+            logger.info("✅ CVE data is ready for processing!")
+
+            return data_file
+
+        except (ValueError, requests.RequestException, OSError) as e:
+            logger.error(f"\n❌ Failed to ensure data availability: {e}")
+            raise
+
+    # ------------------------------------------------------------------
+    # EPSS data helpers
+    # ------------------------------------------------------------------
+
+    def download_epss_data(self, force: bool = False) -> Path | None:
+        """Download and cache the EPSS scores CSV.
+
+        Returns the path to the gzipped CSV file, or None on failure.
+        Uses a similar cache duration to the main NVD data so GitHub
+        Actions runs don't redownload unnecessarily.
+        """
+
+        if self.epss_cache_file.exists() and not force:
+            # Basic age check: reuse if within cache_duration
+            mtime = datetime.fromtimestamp(self.epss_cache_file.stat().st_mtime)
+            if datetime.now() - mtime < self.epss_cache_duration:
+                if not self.quiet:
+                    logger.info("✅ Using cached EPSS data")
+                return self.epss_cache_file
+
+        if not self.quiet:
+            logger.info(f"🔽 Downloading EPSS data from {self.epss_url}")
+
+        tmp = self.epss_cache_file.with_suffix(self.epss_cache_file.suffix + ".part")
+        try:
+            response = requests.get(self.epss_url, stream=True, timeout=120)
+            response.raise_for_status()
+
+            with open(tmp, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    if chunk:
+                        f.write(chunk)
+
+            problem = self._epss_download_problem(tmp)
+            if problem:
+                logger.error(f"❌ Rejecting EPSS download: {problem}")
+                tmp.unlink(missing_ok=True)
+                if self.epss_cache_file.exists():
+                    logger.warning("  📝 Keeping the previous EPSS cache")
+                    return self.epss_cache_file
+                return None
+
+            tmp.replace(self.epss_cache_file)
+            if not self.quiet:
+                size_mb = self.epss_cache_file.stat().st_size / (1024 * 1024)
+                logger.info(f"✅ EPSS download complete ({size_mb:.2f} MB)")
+
+            return self.epss_cache_file
+
+        except requests.RequestException as e:
+            logger.warning(f"⚠️  Warning: EPSS download failed: {e}")
+            tmp.unlink(missing_ok=True)
+            if self.epss_cache_file.exists():
+                logger.warning("  📝 Using stale EPSS cache as fallback")
+                return self.epss_cache_file
+            return None
+
+    def _epss_download_problem(self, path: Path) -> str | None:
+        """Why this EPSS download should not replace the cache, or None if it is fine.
+
+        The feed redirects to a dated filename, so a client that does not follow
+        redirects gets a 200 with an empty body. That is the case this catches.
+        """
+        size = path.stat().st_size if path.exists() else 0
+        if size < MIN_EPSS_BYTES:
+            return f"{size:,} bytes, below the {MIN_EPSS_BYTES:,} floor (empty or truncated response)"
+
+        try:
+            with gzip.open(path, mode="rt", encoding="utf-8") as f:
+                rows = sum(1 for line in f if line.strip() and not line.startswith("#"))
+        except (gzip.BadGzipFile, OSError, UnicodeDecodeError) as e:
+            return f"not readable as gzipped CSV ({e})"
+
+        rows = max(0, rows - 1)  # drop the header
+        if rows < MIN_EPSS_ROWS:
+            return f"{rows:,} rows, below the {MIN_EPSS_ROWS:,} floor"
+
+        previous = self._parsed_entry_count(self.epss_parsed_file)
+        if previous and rows < previous * MIN_RETAINED_FRACTION:
+            return (
+                f"{rows:,} rows against {previous:,} previously - a drop that large "
+                "is more likely a bad download than a real change"
+            )
+        return None
+
+    @staticmethod
+    def _parsed_entry_count(path: Path) -> int:
+        """How many entries the last good parse held, or 0 if unknown."""
+        try:
+            with open(path, encoding="utf-8") as f:
+                return len(json.load(f))
+        except (OSError, json.JSONDecodeError, TypeError):
+            return 0
+
+    def parse_epss_csv(self) -> Path | None:
+        """Parse the cached EPSS CSV into a compact JSON mapping.
+
+        Output format (written to self.epss_parsed_file):
+
+        {
+          "CVE-2024-12345": {"epss_score": 0.1234, "epss_percentile": 0.9876},
+          ...
+        }
+        """
+
+        epss_csv_gz = self.download_epss_data()
+        if not epss_csv_gz or not epss_csv_gz.exists():
+            logger.warning("⚠️  Warning: No EPSS CSV available to parse")
+            return None
+
+        if not self.quiet:
+            logger.info("🔍 Parsing EPSS CSV into JSON mapping...")
+
+        mapping = {}
+        try:
+            with gzip.open(epss_csv_gz, mode="rt", encoding="utf-8") as f:
+                # Skip comment lines (start with #)
+                lines = (line for line in f if not line.startswith("#"))
+                reader = csv.DictReader(lines)
+                for row in reader:
+                    cve_id = row.get("cve") or row.get("CVE")
+                    if not cve_id:
+                        continue
+                    try:
+                        score = float(row.get("epss", "0") or 0)
+                    except ValueError:
+                        score = 0.0
+                    try:
+                        percentile = float(row.get("percentile", "0") or 0)
+                    except ValueError:
+                        percentile = 0.0
+                    mapping[cve_id.strip()] = {
+                        "epss_score": score,
+                        "epss_percentile": percentile,
+                    }
+
+            previous = self._parsed_entry_count(self.epss_parsed_file)
+            if len(mapping) < MIN_EPSS_ROWS or (previous and len(mapping) < previous * MIN_RETAINED_FRACTION):
+                logger.error(
+                    f"❌ Refusing to write an EPSS mapping of {len(mapping):,} CVEs "
+                    f"(previous {previous:,}, floor {MIN_EPSS_ROWS:,}) - keeping the last good parse"
+                )
+                return self.epss_parsed_file if self.epss_parsed_file.exists() else None
+
+            with open(self.epss_parsed_file, "w", encoding="utf-8") as out:
+                json.dump(mapping, out)
+
+            if not self.quiet:
+                logger.info(f"✅ EPSS mapping written to {self.epss_parsed_file.name} ({len(mapping):,} CVEs)")
+
+            return self.epss_parsed_file
+
+        except (gzip.BadGzipFile, csv.Error, OSError, json.JSONDecodeError) as e:
+            logger.warning(f"⚠️  Warning: Failed to parse EPSS CSV: {e}")
+            return None
+
+    # ------------------------------------------------------------------
+    # CISA KEV helpers
+    # ------------------------------------------------------------------
+
+    def download_kev_data(self, force: bool = False) -> Path | None:
+        """Download and cache the CISA Known Exploited Vulnerabilities catalog.
+
+        Returns the path to the JSON file, or None on failure. Best-effort only:
+        if download fails but a stale cache exists, we will reuse it.
+        """
+
+        if self.kev_cache_file.exists() and not force:
+            # Basic age check similar to NVD cache
+            mtime = datetime.fromtimestamp(self.kev_cache_file.stat().st_mtime)
+            if datetime.now() - mtime < self.kev_cache_duration:
+                if not self.quiet:
+                    logger.info("✅ Using cached KEV data")
+                return self.kev_cache_file
+
+        if not self.quiet:
+            logger.info(f"🔽 Downloading KEV data from {self.kev_url}")
+
+        tmp = self.kev_cache_file.with_suffix(".part")
+        try:
+            response = requests.get(self.kev_url, timeout=60)
+            response.raise_for_status()
+
+            with open(tmp, "w", encoding="utf-8") as f:
+                f.write(response.text)
+
+            problem = self._kev_download_problem(tmp)
+            if problem:
+                logger.error(f"❌ Rejecting KEV download: {problem}")
+                tmp.unlink(missing_ok=True)
+                if self.kev_cache_file.exists():
+                    logger.warning("  📝 Keeping the previous KEV cache")
+                    return self.kev_cache_file
+                return None
+
+            tmp.replace(self.kev_cache_file)
+            if not self.quiet:
+                size_kb = self.kev_cache_file.stat().st_size / 1024
+                logger.info(f"✅ KEV download complete ({size_kb:.1f} KB)")
+
+            return self.kev_cache_file
+
+        except requests.RequestException as e:
+            logger.warning(f"⚠️  Warning: KEV download failed: {e}")
+            tmp.unlink(missing_ok=True)
+            if self.kev_cache_file.exists():
+                logger.warning("  📝 Using stale KEV cache as fallback")
+                return self.kev_cache_file
+            return None
+
+    def _kev_download_problem(self, path: Path) -> str | None:
+        """Why this KEV download should not replace the cache, or None if it is fine."""
+        size = path.stat().st_size if path.exists() else 0
+        if size < MIN_KEV_BYTES:
+            return f"{size:,} bytes, below the {MIN_KEV_BYTES:,} floor (empty or truncated response)"
+
+        try:
+            with open(path, encoding="utf-8") as f:
+                catalog = json.load(f)
+        except (OSError, json.JSONDecodeError) as e:
+            return f"not readable as JSON ({e})"
+
+        entries = catalog.get("vulnerabilities")
+        if not isinstance(entries, list):
+            return "no vulnerabilities array"
+        if len(entries) < MIN_KEV_ENTRIES:
+            return f"{len(entries):,} entries, below the {MIN_KEV_ENTRIES:,} floor"
+
+        # The catalog states its own length; a mismatch means a partial body.
+        declared = catalog.get("count")
+        if isinstance(declared, int) and declared != len(entries):
+            return f"catalog declares {declared:,} entries but carries {len(entries):,}"
+
+        previous = self._parsed_entry_count(self.kev_parsed_file)
+        if previous and len(entries) < previous * MIN_RETAINED_FRACTION:
+            return (
+                f"{len(entries):,} entries against {previous:,} previously - a drop that "
+                "large is more likely a bad download than a real change"
+            )
+        return None
+
+    def parse_kev_json(self) -> Path | None:
+        """Parse the KEV JSON into a compact mapping.
+
+        Expected feed shape (subject to CISA changes):
+
+        {
+          "vulnerabilities": [
+            { "cveID": "CVE-2024-12345", ... },
+            ...
+          ]
+        }
+
+        We persist a simplified structure for fast lookup:
+
+        {
+          "CVE-2024-12345": true,
+          ...
+        }
+        """
+
+        kev_json = self.download_kev_data()
+        if not kev_json or not kev_json.exists():
+            logger.warning("⚠️  Warning: No KEV JSON available to parse")
+            return None
+
+        if not self.quiet:
+            logger.info("🔍 Parsing KEV JSON into CVE mapping...")
+
+        try:
+            with open(kev_json, encoding="utf-8") as f:
+                raw = json.load(f)
+
+            # CISA’s feed wraps the list in a top-level key in most formats
+            vulnerabilities = raw.get("vulnerabilities")
+            if vulnerabilities is None and isinstance(raw, list):
+                vulnerabilities = raw
+
+            mapping = {
+                cve_id.strip(): True
+                for entry in (vulnerabilities if isinstance(vulnerabilities, list) else [])
+                if (cve_id := entry.get("cveID") or entry.get("cveId") or entry.get("cve"))
+                and isinstance(cve_id, str)
+                and cve_id.startswith("CVE-")
+            }
+
+            with open(self.kev_parsed_file, "w", encoding="utf-8") as out:
+                json.dump(mapping, out)
+
+            if not self.quiet:
+                logger.info(f"✅ KEV mapping written to {self.kev_parsed_file.name} ({len(mapping):,} CVEs)")
+
+            return self.kev_parsed_file
+
+        except (json.JSONDecodeError, KeyError, OSError) as e:
+            logger.warning(f"⚠️  Warning: Failed to parse KEV JSON: {e}")
+            return None
+
+
+def main() -> None:
+    """Main entry point for standalone execution"""
+    import argparse
+
+    from data.logging_config import setup_logging
+
+    parser = argparse.ArgumentParser(description="Download and cache CVE data")
+    parser.add_argument("--force", action="store_true", help="Force download even if cache is valid")
+    parser.add_argument("--stats", action="store_true", help="Show data statistics only")
+    parser.add_argument("--cache-dir", help="Custom cache directory")
+    parser.add_argument(
+        "--log-level", choices=["DEBUG", "INFO", "WARNING", "ERROR"], default="INFO", help="Logging level"
+    )
+
+    args = parser.parse_args()
+
+    setup_logging(level=args.log_level)
+
+    downloader = CVEDataDownloader(cache_dir=args.cache_dir)
+
+    if args.stats:
+        stats = downloader.get_data_stats()
+        if stats:
+            print(json.dumps(stats, indent=2, default=str))
+        else:
+            logger.warning("No cached data available")
+    else:
+        downloader.ensure_data_available(force_download=args.force)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data/logging_config.py b/data/logging_config.py
new file mode 100644
index 00000000000..57530115edf
--- /dev/null
+++ b/data/logging_config.py
@@ -0,0 +1,153 @@
+"""
+Logging configuration for CVEDB.
+
+This module provides a centralized logging setup that replaces print()
+statements throughout the codebase with proper logging capabilities.
+
+Usage:
+    from data.logging_config import setup_logging, get_logger
+
+    # In entry point (build.py):
+    setup_logging(level="INFO")
+
+    # In any module:
+    logger = get_logger(__name__)
+    logger.info("Processing data...")
+    logger.debug("Detailed info: %s", data)
+    logger.warning("Missing optional data")
+    logger.error("Failed to process: %s", error)
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+from typing import Literal
+
+
+LogLevel = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+
+# Default format includes emoji-style indicators for visual scanning
+DEFAULT_FORMAT = "%(message)s"
+DETAILED_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+MINIMAL_FORMAT = "%(levelname)s: %(message)s"
+
+# Track if logging has been configured
+_configured = False
+
+
+def setup_logging(
+    level: LogLevel = "INFO",
+    log_file: Path | None = None,
+    format_style: Literal["default", "detailed", "minimal"] = "default",
+    force: bool = False,
+) -> logging.Logger:
+    """
+    Configure logging for the CVEDB application.
+
+    Args:
+        level: Minimum log level to display (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        log_file: Optional path to write logs to a file
+        format_style: Log format - 'default' (messages only), 'detailed' (with timestamps),
+                      or 'minimal' (level prefix only)
+        force: If True, reconfigure even if already configured
+
+    Returns:
+        The root 'cve_icu' logger instance
+
+    Example:
+        # Basic usage
+        setup_logging(level="INFO")
+
+        # Verbose mode with file output
+        setup_logging(level="DEBUG", log_file=Path("build.log"), format_style="detailed")
+
+        # Quiet mode (warnings and errors only)
+        setup_logging(level="WARNING")
+    """
+    global _configured
+
+    if _configured and not force:
+        return logging.getLogger("cve_icu")
+
+    # Select format
+    formats = {
+        "default": DEFAULT_FORMAT,
+        "detailed": DETAILED_FORMAT,
+        "minimal": MINIMAL_FORMAT,
+    }
+    log_format = formats.get(format_style, DEFAULT_FORMAT)
+
+    # Create handlers
+    handlers: list[logging.Handler] = []
+
+    # Console handler (always present)
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setFormatter(logging.Formatter(log_format))
+    handlers.append(console_handler)
+
+    # File handler (optional)
+    if log_file:
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setFormatter(logging.Formatter(DETAILED_FORMAT))
+        handlers.append(file_handler)
+
+    # Configure root cve_icu logger
+    root_logger = logging.getLogger("cve_icu")
+    root_logger.setLevel(getattr(logging, level))
+
+    # Remove existing handlers to avoid duplicates
+    root_logger.handlers.clear()
+
+    for handler in handlers:
+        root_logger.addHandler(handler)
+
+    # Prevent propagation to root logger (avoids duplicate messages)
+    root_logger.propagate = False
+
+    _configured = True
+    return root_logger
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger instance for a module.
+
+    The logger will be a child of the 'cve_icu' root logger, inheriting
+    its configuration.
+
+    Args:
+        name: Module name, typically __name__
+
+    Returns:
+        Logger instance configured as child of cve_icu
+
+    Example:
+        # In data/cve_years.py
+        logger = get_logger(__name__)  # Creates 'cve_icu.data.cve_years'
+        logger.info("Processing year data")
+    """
+    # Strip common prefixes to create cleaner logger names
+    clean_name = name.replace("data.", "").replace("data.scripts.", "scripts.")
+    return logging.getLogger(f"cve_icu.{clean_name}")
+
+
+def silence_for_tests() -> None:
+    """
+    Silence all logging output for test runs.
+
+    Call this in conftest.py to prevent log spam during tests.
+    """
+    logging.getLogger("cve_icu").setLevel(logging.CRITICAL + 1)
+
+
+def restore_logging(level: LogLevel = "INFO") -> None:
+    """
+    Restore logging after silencing for tests.
+
+    Args:
+        level: Level to restore to
+    """
+    logging.getLogger("cve_icu").setLevel(getattr(logging, level))
diff --git a/data/protocols.py b/data/protocols.py
new file mode 100644
index 00000000000..758215f6191
--- /dev/null
+++ b/data/protocols.py
@@ -0,0 +1,394 @@
+#!/usr/bin/env python3
+"""
+Protocol definitions for CVEDB
+
+Defines abstract interfaces using typing.Protocol for dependency injection
+and testability. These protocols enable mocking external dependencies like
+HTTP requests and file system operations in unit tests.
+
+Python 3.8+ Protocol classes provide structural subtyping - any class that
+implements the required methods is considered a valid implementation without
+explicit inheritance.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class HttpClient(Protocol):
+    """Protocol for HTTP client operations.
+
+    Abstracts HTTP GET requests to enable mocking in tests.
+    Real implementation: requests.Session or httpx.Client
+    Test implementation: FakeHttpClient with predefined responses
+    """
+
+    def get(self, url: str, *, timeout: int | None = None, stream: bool = False) -> HttpResponse:
+        """Perform HTTP GET request.
+
+        Args:
+            url: The URL to fetch
+            timeout: Request timeout in seconds
+            stream: Whether to stream the response
+
+        Returns:
+            HttpResponse object with status_code, content, headers
+        """
+        ...
+
+
+@runtime_checkable
+class HttpResponse(Protocol):
+    """Protocol for HTTP response objects.
+
+    Matches the interface of requests.Response for compatibility.
+    """
+
+    @property
+    def status_code(self) -> int:
+        """HTTP status code (e.g., 200, 404, 500)"""
+        ...
+
+    @property
+    def content(self) -> bytes:
+        """Raw response content as bytes"""
+        ...
+
+    @property
+    def text(self) -> str:
+        """Response content decoded as text"""
+        ...
+
+    @property
+    def headers(self) -> dict[str, str]:
+        """Response headers"""
+        ...
+
+    def json(self) -> Any:
+        """Parse response as JSON"""
+        ...
+
+    def raise_for_status(self) -> None:
+        """Raise exception if status code indicates error"""
+        ...
+
+    def iter_content(self, chunk_size: int = 1) -> Any:
+        """Iterate over response content in chunks"""
+        ...
+
+
+@runtime_checkable
+class DataReader(Protocol):
+    """Protocol for reading data from various sources.
+
+    Abstracts file and data reading to enable testing without
+    actual file system access.
+    """
+
+    def read_json(self, path: Path) -> Any:
+        """Read and parse JSON from file.
+
+        Args:
+            path: Path to JSON file
+
+        Returns:
+            Parsed JSON data (dict, list, etc.)
+        """
+        ...
+
+    def read_text(self, path: Path) -> str:
+        """Read text content from file.
+
+        Args:
+            path: Path to text file
+
+        Returns:
+            File contents as string
+        """
+        ...
+
+    def read_bytes(self, path: Path) -> bytes:
+        """Read binary content from file.
+
+        Args:
+            path: Path to binary file
+
+        Returns:
+            File contents as bytes
+        """
+        ...
+
+    def exists(self, path: Path) -> bool:
+        """Check if path exists.
+
+        Args:
+            path: Path to check
+
+        Returns:
+            True if path exists, False otherwise
+        """
+        ...
+
+    def list_dir(self, path: Path) -> list[Path]:
+        """List directory contents.
+
+        Args:
+            path: Directory path
+
+        Returns:
+            List of paths in directory
+        """
+        ...
+
+
+@runtime_checkable
+class DataWriter(Protocol):
+    """Protocol for writing data to various destinations.
+
+    Abstracts file writing to enable testing without
+    actual file system modifications.
+    """
+
+    def write_json(self, path: Path, data: Any, indent: int = 2) -> None:
+        """Write data as JSON to file.
+
+        Args:
+            path: Path to write to
+            data: Data to serialize as JSON
+            indent: JSON indentation level
+        """
+        ...
+
+    def write_text(self, path: Path, content: str) -> None:
+        """Write text content to file.
+
+        Args:
+            path: Path to write to
+            content: Text content to write
+        """
+        ...
+
+    def write_bytes(self, path: Path, content: bytes) -> None:
+        """Write binary content to file.
+
+        Args:
+            path: Path to write to
+            content: Binary content to write
+        """
+        ...
+
+    def mkdir(self, path: Path, parents: bool = True, exist_ok: bool = True) -> None:
+        """Create directory.
+
+        Args:
+            path: Directory path to create
+            parents: Create parent directories if needed
+            exist_ok: Don't raise error if directory exists
+        """
+        ...
+
+
+@runtime_checkable
+class CacheManager(Protocol):
+    """Protocol for cache management operations.
+
+    Abstracts caching logic for data downloads and processing results.
+    """
+
+    def is_valid(self, key: str) -> bool:
+        """Check if cache entry is valid and not expired.
+
+        Args:
+            key: Cache key to check
+
+        Returns:
+            True if cache is valid, False if expired or missing
+        """
+        ...
+
+    def get(self, key: str) -> Any | None:
+        """Get cached value.
+
+        Args:
+            key: Cache key
+
+        Returns:
+            Cached value or None if not found
+        """
+        ...
+
+    def set(self, key: str, value: Any, ttl_seconds: int | None = None) -> None:
+        """Set cache value.
+
+        Args:
+            key: Cache key
+            value: Value to cache
+            ttl_seconds: Time-to-live in seconds (None for default)
+        """
+        ...
+
+    def invalidate(self, key: str) -> None:
+        """Invalidate cache entry.
+
+        Args:
+            key: Cache key to invalidate
+        """
+        ...
+
+
+# =============================================================================
+# Default implementations for production use
+# =============================================================================
+
+
+class FileSystemDataReader:
+    """Default DataReader implementation using the file system."""
+
+    def read_json(self, path: Path) -> Any:
+        """Read and parse JSON from file."""
+        import json
+
+        with open(path, encoding="utf-8") as f:
+            return json.load(f)
+
+    def read_text(self, path: Path) -> str:
+        """Read text content from file."""
+        with open(path, encoding="utf-8") as f:
+            return f.read()
+
+    def read_bytes(self, path: Path) -> bytes:
+        """Read binary content from file."""
+        with open(path, "rb") as f:
+            return f.read()
+
+    def exists(self, path: Path) -> bool:
+        """Check if path exists."""
+        return path.exists()
+
+    def list_dir(self, path: Path) -> list[Path]:
+        """List directory contents."""
+        return list(path.iterdir()) if path.is_dir() else []
+
+
+class FileSystemDataWriter:
+    """Default DataWriter implementation using the file system."""
+
+    def write_json(self, path: Path, data: Any, indent: int = 2) -> None:
+        """Write data as JSON to file."""
+        import json
+
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=indent)
+
+    def write_text(self, path: Path, content: str) -> None:
+        """Write text content to file."""
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+    def write_bytes(self, path: Path, content: bytes) -> None:
+        """Write binary content to file."""
+        with open(path, "wb") as f:
+            f.write(content)
+
+    def mkdir(self, path: Path, parents: bool = True, exist_ok: bool = True) -> None:
+        """Create directory."""
+        path.mkdir(parents=parents, exist_ok=exist_ok)
+
+
+class RequestsHttpClient:
+    """Default HttpClient implementation using requests library."""
+
+    def __init__(self, session: Any | None = None) -> None:
+        """Initialize with optional requests.Session."""
+        import requests
+
+        self._session = session or requests.Session()
+
+    def get(self, url: str, *, timeout: int | None = None, stream: bool = False) -> Any:
+        """Perform HTTP GET request."""
+        return self._session.get(url, timeout=timeout, stream=stream)
+
+
+# =============================================================================
+# Async Protocol and Implementation for Parallel Downloads
+# =============================================================================
+
+
+@runtime_checkable
+class AsyncHttpClient(Protocol):
+    """Protocol for async HTTP client operations.
+
+    Enables parallel HTTP requests using asyncio.
+    Real implementation: httpx.AsyncClient
+    Test implementation: FakeAsyncHttpClient
+    """
+
+    async def get(
+        self,
+        url: str,
+        *,
+        timeout: int | None = None,
+    ) -> HttpResponse:
+        """Perform async HTTP GET request.
+
+        Args:
+            url: The URL to fetch
+            timeout: Request timeout in seconds
+
+        Returns:
+            HttpResponse object with status_code, content, headers
+        """
+        ...
+
+    async def __aenter__(self) -> AsyncHttpClient:
+        """Async context manager entry."""
+        ...
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Async context manager exit."""
+        ...
+
+
+class HttpxAsyncClient:
+    """Async HTTP client implementation using httpx library.
+
+    Supports parallel downloads via asyncio.gather().
+
+    Example:
+        async with HttpxAsyncClient() as client:
+            responses = await asyncio.gather(
+                client.get('https://api1.example.com'),
+                client.get('https://api2.example.com'),
+            )
+    """
+
+    def __init__(self, timeout: int = 120) -> None:
+        """Initialize with default timeout."""
+        self._timeout = timeout
+        self._client: Any = None
+
+    async def __aenter__(self) -> HttpxAsyncClient:
+        """Create httpx.AsyncClient on context entry."""
+        import httpx
+
+        self._client = httpx.AsyncClient(timeout=self._timeout)
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Close httpx.AsyncClient on context exit."""
+        if self._client:
+            await self._client.aclose()
+
+    async def get(
+        self,
+        url: str,
+        *,
+        timeout: int | None = None,
+    ) -> Any:
+        """Perform async HTTP GET request."""
+        if self._client is None:
+            raise RuntimeError("Client not initialized. Use 'async with' context manager.")
+        return await self._client.get(url, timeout=timeout or self._timeout)
diff --git a/data/scoring_analysis.py b/data/scoring_analysis.py
new file mode 100644
index 00000000000..1688e9a3e7c
--- /dev/null
+++ b/data/scoring_analysis.py
@@ -0,0 +1,676 @@
+#!/usr/bin/env python3
+"""
+Scoring Analysis Module for CVEDB
+Generates analysis files for the Scoring Hub: EPSS, KEV, and Risk Matrix data
+"""
+
+from __future__ import annotations
+
+import json
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class ScoringAnalyzer:
+    """Generates scoring-related analysis files for the Scoring Hub"""
+
+    base_dir: Path | None = None
+    cache_dir: Path | None = None
+    output_dir: Path | None = None
+    epss_file: Path = field(init=False)
+    kev_file: Path = field(init=False)
+    nvd_file: Path = field(init=False)
+    # CVE ID -> publication year. Populated on first use, or as a side effect of
+    # the risk matrix pass, so nvd.json is read once per build.
+    _pub_years: dict[str, int] = field(init=False, default_factory=dict)
+
+    def __post_init__(self) -> None:
+        """Set up paths with defaults if not provided."""
+        if self.base_dir is None:
+            self.base_dir = Path(__file__).parent.parent
+        else:
+            self.base_dir = Path(self.base_dir)
+
+        if self.cache_dir is None:
+            self.cache_dir = self.base_dir / "data" / "cache"
+        else:
+            self.cache_dir = Path(self.cache_dir)
+
+        if self.output_dir is None:
+            self.output_dir = self.base_dir / "web" / "data"
+        else:
+            self.output_dir = Path(self.output_dir)
+
+        # Source files
+        self.epss_file = self.cache_dir / "epss_scores-current.json"
+        self.kev_file = self.cache_dir / "known_exploited_vulnerabilities.json"
+        self.nvd_file = self.cache_dir / "nvd.json"
+
+    @staticmethod
+    def _published_year(cve_info: dict[str, Any]) -> int | None:
+        """Publication year for one NVD record, or None if the site does not count it.
+
+        Mirrors the filter in cve_years.py so EPSS coverage lands on exactly the
+        same population as the yearly totals: a CVE- identifier, not rejected, a
+        parseable published date, and 1999 or later. Anything else returns None
+        rather than being attributed to a year it does not belong in.
+        """
+        cve_id = cve_info.get("id", "")
+        if not cve_id.startswith("CVE-"):
+            return None
+        if "Rejected" in (cve_info.get("vulnStatus") or ""):
+            return None
+
+        published = cve_info.get("published")
+        if isinstance(published, str) and len(published) >= 4:
+            try:
+                year = int(published[:4])
+            except ValueError:
+                return None
+            return year if year >= 1999 else None
+        return None
+
+    def published_year_map(self) -> dict[str, int]:
+        """CVE ID -> publication year, read from NVD once and cached."""
+        if self._pub_years:
+            return self._pub_years
+        if not self.nvd_file.exists():
+            logger.warning("  ⚠️  NVD file not found; EPSS coverage falls back to CVE ID year")
+            return {}
+        logger.info("  📂 Indexing CVE publication dates...")
+        with open(self.nvd_file) as f:
+            for record in json.load(f):
+                cve_info = record.get("cve", {})
+                cve_id = cve_info.get("id", "")
+                year = self._published_year(cve_info)
+                if cve_id and year:
+                    self._pub_years[cve_id] = year
+        logger.info(f"     Indexed {len(self._pub_years):,} publication dates")
+        return self._pub_years
+
+    def load_epss_data(self) -> dict[str, dict[str, float]]:
+        """Load EPSS scores from parsed JSON"""
+        if not self.epss_file.exists():
+            logger.warning(f"⚠️  EPSS file not found: {self.epss_file}")
+            return {}
+
+        with open(self.epss_file) as f:
+            return json.load(f)
+
+    def load_nvd_publication_dates(self) -> dict[str, str]:
+        """Load CVE publication dates from NVD data.
+
+        Returns a dict mapping CVE ID -> publication year (e.g., "2024")
+        """
+        if not self.nvd_file.exists():
+            logger.warning(f"⚠️  NVD file not found: {self.nvd_file}")
+            return {}
+
+        logger.debug("  📂 Loading NVD publication dates...")
+        pub_dates: dict[str, str] = {}
+
+        try:
+            with open(self.nvd_file) as f:
+                nvd_data = json.load(f)
+
+            # NVD data is a list of items with 'cve' key
+            if isinstance(nvd_data, list):
+                for item in nvd_data:
+                    cve = item.get("cve", {})
+                    cve_id = cve.get("id", "")
+                    published = cve.get("published", "")
+                    if cve_id and published:
+                        # Extract year from ISO date like "2024-01-15T04:00:00.000"
+                        try:
+                            pub_year = published[:4]
+                            if pub_year.isdigit():
+                                pub_dates[cve_id] = pub_year
+                        except (IndexError, ValueError):
+                            pass
+
+            logger.debug(f"  ✅ Loaded publication dates for {len(pub_dates):,} CVEs")
+            return pub_dates
+
+        except (json.JSONDecodeError, OSError) as e:
+            logger.warning(f"⚠️  Error loading NVD data: {e}")
+            return {}
+
+    def load_kev_data(self) -> dict[str, Any]:
+        """Load KEV data from CISA JSON"""
+        if not self.kev_file.exists():
+            logger.warning(f"⚠️  KEV file not found: {self.kev_file}")
+            return {"vulnerabilities": []}
+
+        with open(self.kev_file) as f:
+            return json.load(f)
+
+    def load_cvss_data(self) -> dict[str, Any]:
+        """Load CVSS data from existing analysis file or count from NVD"""
+        cvss_file = self.output_dir / "cvss_analysis.json"
+        if cvss_file.exists():
+            with open(cvss_file) as f:
+                return json.load(f)
+
+        # Fallback: count CVSS from NVD data directly
+        logger.warning(f"⚠️  CVSS analysis file not found: {cvss_file}")
+        logger.info("    📂 Counting CVSS from NVD data directly...")
+
+        if not self.nvd_file.exists():
+            return {"total_cves_with_cvss": 0}
+
+        try:
+            with open(self.nvd_file) as f:
+                nvd_data = json.load(f)
+
+            count = 0
+            # NVD data is a list of items with 'cve' key
+            if isinstance(nvd_data, list):
+                for item in nvd_data:
+                    cve = item.get("cve", {})
+                    metrics = cve.get("metrics", {})
+                    if metrics.get("cvssMetricV31") or metrics.get("cvssMetricV30") or metrics.get("cvssMetricV2"):
+                        count += 1
+            else:
+                # Old format: dict keyed by CVE ID
+                for cve_data in nvd_data.values():
+                    if cve_data.get("cvss_v3") or cve_data.get("cvss_v2"):
+                        count += 1
+
+            logger.info(f"    ✅ Found {count:,} CVEs with CVSS scores")
+            return {"total_cves_with_cvss": count}
+        except (FileNotFoundError, json.JSONDecodeError, KeyError, OSError) as e:
+            logger.error(f"    ❌ Error loading NVD data: {e}")
+            return {"total_cves_with_cvss": 0}
+
+    def generate_epss_analysis(self) -> dict[str, Any] | None:
+        """Generate EPSS-focused analysis JSON"""
+        logger.info("📊 Generating EPSS analysis...")
+
+        epss_data = self.load_epss_data()
+        if not epss_data:
+            logger.warning("  ⚠️  No EPSS data available")
+            return None
+
+        # Calculate distributions
+        buckets = {
+            "very_low": 0,  # 0 - 0.01
+            "low": 0,  # 0.01 - 0.1
+            "medium": 0,  # 0.1 - 0.3
+            "high": 0,  # 0.3 - 0.5
+            "very_high": 0,  # 0.5 - 0.7
+            "critical": 0,  # 0.7+
+        }
+
+        percentile_buckets = defaultdict(int)  # 0-10, 10-20, etc.
+        year_coverage = defaultdict(lambda: {"total": 0, "with_epss": 0})
+        high_risk_cves = []  # EPSS > 0.5
+
+        # Bucket by PUBLICATION year, the same basis the rest of the site counts on.
+        # Keying by CVE ID year instead made EPSS coverage incomparable with the
+        # yearly totals - a CVE-2016 published in 2020 landed in different years on
+        # different pages, and the site's own total could be exceeded.
+        pub_years = self.published_year_map()
+        unmatched_epss = 0
+
+        for cve_id in pub_years:
+            year = str(pub_years[cve_id])
+            year_coverage[year]["total"] += 1
+
+        for cve_id, scores in epss_data.items():
+            score = scores.get("epss_score", 0)
+            percentile = scores.get("epss_percentile", 0)
+
+            published = pub_years.get(cve_id)
+            if published is not None:
+                year_coverage[str(published)]["with_epss"] += 1
+            else:
+                # EPSS scores CVE IDs this site has no published record for.
+                # Counted separately rather than silently attributed to a year.
+                unmatched_epss += 1
+
+            # Score buckets using match/case with guard patterns
+            match score:
+                case s if s < 0.01:
+                    buckets["very_low"] += 1
+                case s if s < 0.1:
+                    buckets["low"] += 1
+                case s if s < 0.3:
+                    buckets["medium"] += 1
+                case s if s < 0.5:
+                    buckets["high"] += 1
+                case s if s < 0.7:
+                    buckets["very_high"] += 1
+                case _:
+                    buckets["critical"] += 1
+
+            # Percentile buckets (for histogram)
+            bucket_idx = min(int(percentile * 10), 9)  # 0-9
+            percentile_buckets[bucket_idx] += 1
+
+            # High risk list (top by EPSS)
+            if score >= 0.5:
+                high_risk_cves.append({"cve_id": cve_id, "epss_score": score, "epss_percentile": percentile})
+
+        # Sort high risk by score descending, limit to top 100
+        high_risk_cves.sort(key=lambda x: x["epss_score"], reverse=True)
+        high_risk_cves = high_risk_cves[:100]
+
+        # Calculate statistics
+        all_scores = [s["epss_score"] for s in epss_data.values()]
+        avg_score = sum(all_scores) / len(all_scores) if all_scores else 0
+
+        # Threshold counts
+        gt_01 = sum(1 for s in all_scores if s > 0.1)
+        gt_03 = sum(1 for s in all_scores if s > 0.3)
+        gt_05 = sum(1 for s in all_scores if s > 0.5)
+        gt_07 = sum(1 for s in all_scores if s > 0.7)
+        gt_09 = sum(1 for s in all_scores if s > 0.9)
+
+        analysis = {
+            "generated_at": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+            "total_cves_with_epss": len(epss_data),
+            "statistics": {
+                "average_score": round(avg_score, 6),
+                "gt_0_1": gt_01,
+                "gt_0_3": gt_03,
+                "gt_0_5": gt_05,
+                "gt_0_7": gt_07,
+                "gt_0_9": gt_09,
+            },
+            "score_buckets": buckets,
+            "percentile_distribution": dict(sorted(percentile_buckets.items())),
+            "year_coverage": dict(sorted(year_coverage.items())),
+            # EPSS entries with no published CVE record here - they are real EPSS
+            # rows, but cannot be placed on this site's publication timeline.
+            "epss_without_published_record": unmatched_epss,
+            # The comparable figure: EPSS rows that match a CVE this site counts.
+            "total_cves_with_epss_matched": len(epss_data) - unmatched_epss,
+            "high_risk_cves": high_risk_cves,
+        }
+
+        output_file = self.output_dir / "epss_analysis.json"
+        with open(output_file, "w") as f:
+            json.dump(analysis, f, indent=2)
+
+        logger.info(f"  ✅ Generated {output_file.name}")
+        logger.info(f"     Total CVEs with EPSS: {len(epss_data):,}")
+        logger.info(f"     High risk (>0.5): {gt_05:,}")
+
+        return analysis
+
+    def generate_kev_analysis(self) -> dict[str, Any] | None:
+        """Generate KEV-focused analysis JSON"""
+        logger.info("📊 Generating KEV analysis...")
+
+        kev_data = self.load_kev_data()
+        vulnerabilities = kev_data.get("vulnerabilities", [])
+
+        if not vulnerabilities:
+            logger.warning("  ⚠️  No KEV data available")
+            return None
+
+        # Load NVD publication dates for accurate published year
+        nvd_pub_dates = self.load_nvd_publication_dates()
+
+        # Aggregations
+        by_year_added = defaultdict(int)
+        by_year_cve = defaultdict(int)  # Year from CVE ID (CVE-YYYY-NNNN)
+        by_year_published = defaultdict(int)  # Actual NVD publication year
+        by_vendor = defaultdict(int)
+        by_product = defaultdict(int)
+        by_cwe = defaultdict(int)
+        ransomware_count = 0
+
+        recent_30_days = []
+        recent_90_days = []
+        now = datetime.now(UTC)
+
+        timeline = defaultdict(int)  # Monthly additions
+
+        for vuln in vulnerabilities:
+            cve_id = vuln.get("cveID", "")
+            vendor = vuln.get("vendorProject", "Unknown")
+            product = vuln.get("product", "Unknown")
+            date_added = vuln.get("dateAdded", "")
+            cwes = vuln.get("cwes", [])
+            ransomware = vuln.get("knownRansomwareCampaignUse", "Unknown")
+
+            # Year from CVE ID (CVE-YYYY-NNNN) - not reliable for publication date
+            try:
+                cve_year = cve_id.split("-")[1]
+                by_year_cve[cve_year] += 1
+            except (IndexError, ValueError):
+                pass
+
+            # Actual publication year from NVD
+            if cve_id in nvd_pub_dates:
+                by_year_published[nvd_pub_dates[cve_id]] += 1
+
+            # Year added to KEV
+            if date_added:
+                try:
+                    added_date = datetime.strptime(date_added, "%Y-%m-%d").replace(tzinfo=UTC)
+                    by_year_added[str(added_date.year)] += 1
+
+                    # Monthly timeline
+                    month_key = added_date.strftime("%Y-%m")
+                    timeline[month_key] += 1
+
+                    # Recent additions
+                    days_ago = (now - added_date).days
+                    if days_ago <= 30:
+                        recent_30_days.append(
+                            {
+                                "cve_id": cve_id,
+                                "vendor": vendor,
+                                "product": product,
+                                "date_added": date_added,
+                                "due_date": vuln.get("dueDate", ""),
+                                "ransomware": ransomware,
+                            }
+                        )
+                    if days_ago <= 90:
+                        recent_90_days.append(
+                            {"cve_id": cve_id, "vendor": vendor, "product": product, "date_added": date_added}
+                        )
+                except ValueError:
+                    pass
+
+            # Vendor and product
+            by_vendor[vendor] += 1
+            by_product[f"{vendor} - {product}"] += 1
+
+            # CWEs
+            for cwe in cwes:
+                by_cwe[cwe] += 1
+
+            # Ransomware
+            if ransomware and ransomware.lower() not in ["unknown", "no"]:
+                ransomware_count += 1
+
+        # Sort and limit top lists
+        top_vendors = sorted(by_vendor.items(), key=lambda x: x[1], reverse=True)[:20]
+        top_products = sorted(by_product.items(), key=lambda x: x[1], reverse=True)[:20]
+        top_cwes = sorted(by_cwe.items(), key=lambda x: x[1], reverse=True)[:20]
+
+        # Sort recent by date
+        recent_30_days.sort(key=lambda x: x["date_added"], reverse=True)
+        recent_90_days.sort(key=lambda x: x["date_added"], reverse=True)
+
+        analysis = {
+            "generated_at": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+            "catalog_version": kev_data.get("catalogVersion", ""),
+            "total_kev_cves": len(vulnerabilities),
+            "statistics": {
+                "added_last_30_days": len(recent_30_days),
+                "added_last_90_days": len(recent_90_days),
+                "ransomware_associated": ransomware_count,
+            },
+            "by_year_added": dict(sorted(by_year_added.items())),
+            "by_year_cve": dict(sorted(by_year_cve.items())),
+            "by_year_published": dict(sorted(by_year_published.items())),
+            "timeline": dict(sorted(timeline.items())),
+            "top_vendors": top_vendors,
+            "top_products": top_products,
+            "top_cwes": top_cwes,
+            "recent_additions": recent_30_days[:20],  # Last 20 for display
+        }
+
+        output_file = self.output_dir / "kev_analysis.json"
+        with open(output_file, "w") as f:
+            json.dump(analysis, f, indent=2)
+
+        logger.info(f"  ✅ Generated {output_file.name}")
+        logger.info(f"     Total KEV CVEs: {len(vulnerabilities):,}")
+        logger.info(f"     Added last 30 days: {len(recent_30_days)}")
+
+        return analysis
+
+    def generate_risk_matrix(self) -> dict[str, Any]:
+        """Generate bucketed CVSS × EPSS risk matrix data"""
+        logger.info("📊 Generating risk matrix...")
+
+        epss_data = self.load_epss_data()
+        self.load_cvss_data()
+        kev_data = self.load_kev_data()
+
+        # Build KEV set for quick lookup using set comprehension with walrus
+        kev_set = {cve_id for vuln in kev_data.get("vulnerabilities", []) if (cve_id := vuln.get("cveID", ""))}
+
+        # CVSS severity bands
+        severity_bands = ["NONE", "LOW", "MEDIUM", "HIGH", "CRITICAL"]
+
+        # EPSS buckets
+        epss_buckets = ["0-0.1", "0.1-0.3", "0.3-0.5", "0.5-0.7", "0.7+"]
+
+        def get_epss_bucket(score):
+            match score:
+                case s if s < 0.1:
+                    return "0-0.1"
+                case s if s < 0.3:
+                    return "0.1-0.3"
+                case s if s < 0.5:
+                    return "0.3-0.5"
+                case s if s < 0.7:
+                    return "0.5-0.7"
+                case _:
+                    return "0.7+"
+
+        def get_severity_from_score(score):
+            match score:
+                case 0:
+                    return "NONE"
+                case s if s < 4.0:
+                    return "LOW"
+                case s if s < 7.0:
+                    return "MEDIUM"
+                case s if s < 9.0:
+                    return "HIGH"
+                case _:
+                    return "CRITICAL"
+
+        # Initialize matrix
+        matrix = {}
+        for severity in severity_bands:
+            for epss_bucket in epss_buckets:
+                key = f"{severity}_{epss_bucket}"
+                matrix[key] = {"severity": severity, "epss_bucket": epss_bucket, "count": 0, "kev_count": 0}
+
+        # We need to correlate EPSS with CVSS scores
+        # Load yearly files to get CVSS scores per CVE
+        # For now, use the severity distribution from cvss_analysis
+        # This is a simplified approach - in production we'd scan nvd.json
+
+        # For the matrix, we'll estimate based on overall distributions
+        # and the EPSS data we have
+
+        # Actually, let's load the NVD data to get proper CVSS scores
+        if self.nvd_file.exists():
+            logger.info("  📂 Loading NVD data for CVSS correlation...")
+            with open(self.nvd_file) as f:
+                nvd_data = json.load(f)
+
+            for record in nvd_data:
+                cve_info = record.get("cve", {})
+                cve_id = cve_info.get("id", "")
+
+                # Populate the shared publication-year map while we are here.
+                year = self._published_year(cve_info)
+                if cve_id and year:
+                    self._pub_years[cve_id] = year
+
+                if cve_id not in epss_data:
+                    continue
+
+                epss_score = epss_data[cve_id].get("epss_score", 0)
+                epss_bucket = get_epss_bucket(epss_score)
+
+                # Get CVSS score - try v3.1, v3.0, v2.0, v4.0
+                cvss_score = None
+                metrics = cve_info.get("metrics", {})
+
+                for version in ["cvssMetricV31", "cvssMetricV30", "cvssMetricV40", "cvssMetricV2"]:
+                    if version in metrics and metrics[version]:
+                        metric = metrics[version][0]
+                        cvss_data_inner = metric.get("cvssData", {})
+                        if cvss_score := cvss_data_inner.get("baseScore"):
+                            break
+
+                if cvss_score is None:
+                    continue
+
+                severity = get_severity_from_score(cvss_score)
+                key = f"{severity}_{epss_bucket}"
+
+                matrix[key]["count"] += 1
+                if cve_id in kev_set:
+                    matrix[key]["kev_count"] += 1
+        else:
+            logger.warning("  ⚠️  NVD file not found, using estimated data")
+
+        # Convert to list format for easier charting
+        matrix_list = list(matrix.values())
+
+        # Calculate totals
+        total_in_matrix = sum(m["count"] for m in matrix_list)
+        total_kev_in_matrix = sum(m["kev_count"] for m in matrix_list)
+
+        analysis = {
+            "generated_at": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+            "severity_bands": severity_bands,
+            "epss_buckets": epss_buckets,
+            "matrix": matrix_list,
+            "totals": {"cves_in_matrix": total_in_matrix, "kev_in_matrix": total_kev_in_matrix},
+        }
+
+        output_file = self.output_dir / "risk_matrix.json"
+        with open(output_file, "w") as f:
+            json.dump(analysis, f, indent=2)
+
+        logger.info(f"  ✅ Generated {output_file.name}")
+        logger.info(f"     CVEs in matrix: {total_in_matrix:,}")
+        logger.info(f"     KEV in matrix: {total_kev_in_matrix:,}")
+
+        return analysis
+
+    def generate_scoring_comparison(self) -> dict[str, Any]:
+        """Generate comparison data for the Scoring Hub landing page"""
+        logger.info("📊 Generating scoring comparison...")
+
+        epss_data = self.load_epss_data()
+        kev_data = self.load_kev_data()
+        cvss_data = self.load_cvss_data()
+
+        kev_vulnerabilities = kev_data.get("vulnerabilities", [])
+        kev_set = {v.get("cveID", "") for v in kev_vulnerabilities}
+
+        # Count overlaps
+        epss_and_kev = sum(1 for cve_id in epss_data if cve_id in kev_set)
+
+        # High EPSS in KEV
+        high_epss_in_kev = sum(
+            1 for cve_id, scores in epss_data.items() if cve_id in kev_set and scores.get("epss_score", 0) > 0.5
+        )
+
+        comparison = {
+            "generated_at": datetime.now(UTC).isoformat().replace("+00:00", "Z"),
+            "systems": {
+                "cvss": {
+                    "name": "CVSS",
+                    "full_name": "Common Vulnerability Scoring System",
+                    "description": "Measures severity/impact of vulnerabilities",
+                    "question": "How bad is it?",
+                    "total_scored": cvss_data.get("total_cves_with_cvss", 0),
+                    "source": "NVD / Vendors",
+                    "update_frequency": "Per CVE publication",
+                },
+                "epss": {
+                    "name": "EPSS",
+                    "full_name": "Exploit Prediction Scoring System",
+                    "description": "Predicts likelihood of exploitation in 30 days",
+                    "question": "Will it be exploited?",
+                    "total_scored": len(epss_data),
+                    "source": "FIRST.org",
+                    "update_frequency": "Daily",
+                },
+                "kev": {
+                    "name": "KEV",
+                    "full_name": "Known Exploited Vulnerabilities",
+                    "description": "Confirmed actively exploited vulnerabilities",
+                    "question": "Is it being exploited?",
+                    "total_scored": len(kev_vulnerabilities),
+                    "source": "CISA",
+                    "update_frequency": "As exploits are confirmed",
+                },
+            },
+            "overlaps": {
+                "epss_and_kev": epss_and_kev,
+                "high_epss_in_kev": high_epss_in_kev,
+                "kev_coverage_by_epss": round(epss_and_kev / len(kev_vulnerabilities) * 100, 1)
+                if kev_vulnerabilities
+                else 0,
+            },
+            "insights": {
+                "epss_gt_05_not_kev": sum(
+                    1
+                    for cve_id, scores in epss_data.items()
+                    if scores.get("epss_score", 0) > 0.5 and cve_id not in kev_set
+                ),
+                "kev_with_low_epss": sum(
+                    1 for cve_id in kev_set if cve_id in epss_data and epss_data[cve_id].get("epss_score", 0) < 0.1
+                ),
+            },
+        }
+
+        output_file = self.output_dir / "scoring_comparison.json"
+        with open(output_file, "w") as f:
+            json.dump(comparison, f, indent=2)
+
+        logger.info(f"  ✅ Generated {output_file.name}")
+        logger.info(f"     EPSS ∩ KEV: {epss_and_kev:,}")
+
+        return comparison
+
+    def generate_all(self) -> dict[str, Any]:
+        """Generate all scoring analysis files"""
+        logger.info("\n📊 Generating Scoring Hub Analysis Files")
+        logger.info("=" * 50)
+
+        results = {}
+        # The risk matrix already walks every NVD record, so running it first
+        # populates the publication-year map EPSS needs - one read, not two.
+        results["risk_matrix"] = self.generate_risk_matrix()
+        results["epss"] = self.generate_epss_analysis()
+        results["kev"] = self.generate_kev_analysis()
+        results["comparison"] = self.generate_scoring_comparison()
+
+        logger.info("=" * 50)
+        logger.info("✅ All scoring analysis files generated!")
+
+        return results
+
+    def generate_all_scoring_analysis(self) -> dict[str, Any]:
+        """Alias for generate_all() - used by build.py"""
+        return self.generate_all()
+
+
+def main() -> None:
+    """Main entry point"""
+    analyzer = ScoringAnalyzer()
+    analyzer.generate_all()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data/scripts/cna_mapping_restart.py b/data/scripts/cna_mapping_restart.py
new file mode 100644
index 00000000000..bf4a1e75e15
--- /dev/null
+++ b/data/scripts/cna_mapping_restart.py
@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""
+CNA Mapping Restart Script
+
+Maps every CVE to either an official or unofficial CNA using:
+1. UUID/official CNA mapping (cna_name_map.json)
+2. Reporting email/domain mapping (cna_list.json contact emails)
+3. Fallback to edge-case/unknown (creates 'Unofficial CNA' if needed)
+
+- 100% of CVEs will be mapped
+- Official status uses UUID first, then fuzzy name match
+- Years active is calculated from cnaID, not CVE publication
+"""
+
+import json
+import re
+import sys
+from collections import defaultdict
+from datetime import datetime
+from pathlib import Path
+
+
+# Logging setup, matching the sibling rebuild scripts.
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+# Utility: Normalize CNA names for fuzzy matching
+
+
+def normalize_name(name):
+    if not name:
+        return ""
+    return (
+        name.lower()
+        .replace(",", "")
+        .replace(".", "")
+        .replace("incorporated", "inc")
+        .replace("corporation", "corp")
+        .replace("limited", "ltd")
+        .replace("llc", "")
+        .replace("inc", "")
+        .replace("corp", "")
+        .replace("ltd", "")
+        .replace("the ", "")
+        .replace("&", "and")
+        .replace("  ", " ")
+        .strip()
+    )
+
+
+def extract_designation_year(cna_id):
+    match = re.match(r"CNA-(\d{4})-", cna_id or "")
+    return int(match.group(1)) if match else None
+
+
+# Load all reference data
+cache_dir = Path(__file__).parent / "cache"
+with open(cache_dir / "nvd.json") as f:
+    cve_data = [json.loads(line) for line in f if line.strip()]
+with open(cache_dir / "cna_name_map.json") as f:
+    uuid_map = json.load(f)  # uuid: org_name
+with open(cache_dir / "cna_list.json") as f:
+    cna_list_raw = json.load(f)
+    cna_list = cna_list_raw["data"] if isinstance(cna_list_raw, dict) and "data" in cna_list_raw else cna_list_raw
+
+# Build official CNA lookup by UUID and normalized name
+uuid_to_name = dict(uuid_map)
+official_names = {normalize_name(name): uuid for uuid, name in uuid_map.items()}
+# Build contact email and domain lookup from cna_list.json
+email_to_cna = {}
+domain_to_cna = {}
+cnaid_to_year = {}
+for cna in cna_list:
+    org_name = cna.get("organizationName", "")
+    cna_id = cna.get("cnaID", "")
+    if cna_id:
+        cnaid_to_year[org_name] = extract_designation_year(cna_id)
+    # Contact emails
+    for contact in cna.get("contact", []):
+        for email in contact.get("email", []):
+            email_addr = email.get("emailAddr", "").lower()
+            if email_addr:
+                email_to_cna[email_addr] = org_name
+                domain = email_addr.split("@")[-1]
+                if domain:
+                    domain_to_cna[domain] = org_name
+
+# Main mapping pass
+cna_stats = defaultdict(
+    lambda: {
+        "count": 0,
+        "cve_ids": [],
+        "first_cve_year": None,
+        "last_cve_year": None,
+        "designation_year": None,
+        "official": False,
+        "source": set(),
+    }
+)
+unknown_cnas = set()
+for cve in cve_data:
+    # 1. Try UUID/official CNA mapping
+    cna_uuid = cve.get("cna", "")
+    cna_name = uuid_to_name.get(cna_uuid, "")
+    if cna_name:
+        mapped_name = cna_name
+        official = True
+        designation_year = cnaid_to_year.get(cna_name)
+        source = "uuid"
+    else:
+        # 2. Try reporting email(s)
+        emails = set()
+        # NVD v2: sourceIdentifier or assigner field, and any emails in references
+        assigner = cve.get("assigner", "")
+        if assigner and "@" in assigner:
+            emails.add(assigner.lower())
+        # Try references
+        for ref in cve.get("references", []):
+            url = ref.get("url", "")
+            if "@" in url:
+                emails.add(url.lower())
+        # Try description for emails
+        desc = cve.get("description", "")
+        for match in re.findall(r"[\w\.-]+@[\w\.-]+", desc):
+            emails.add(match.lower())
+        mapped_name = ""
+        official = False
+        designation_year = None
+        source = ""
+        for email in emails:
+            # Direct email match
+            if email in email_to_cna:
+                mapped_name = email_to_cna[email]
+                official = normalize_name(mapped_name) in official_names
+                designation_year = cnaid_to_year.get(mapped_name)
+                source = "email"
+                break
+            # Domain match
+            domain = email.split("@")[-1]
+            if domain in domain_to_cna:
+                mapped_name = domain_to_cna[domain]
+                official = normalize_name(mapped_name) in official_names
+                designation_year = cnaid_to_year.get(mapped_name)
+                source = "domain"
+                break
+        # 3. Fallback: fuzzy name from assigner
+        if not mapped_name and assigner:
+            normalized = normalize_name(assigner)
+            if normalized in official_names:
+                mapped_name = uuid_to_name[official_names[normalized]]
+                official = True
+                designation_year = cnaid_to_year.get(mapped_name)
+                source = "fuzzy-assigner"
+        # 4. Edge: fallback to email or domain as "Unofficial CNA"
+        if not mapped_name and emails:
+            mapped_name = sorted(emails)[0]  # Use first email as CNA name
+            official = False
+            designation_year = None
+            source = "unofficial-email"
+        if not mapped_name:
+            mapped_name = "Unknown CNA"
+            official = False
+            designation_year = None
+            source = "unknown"
+    # Update stats
+    cna_stats[mapped_name]["count"] += 1
+    cna_stats[mapped_name]["cve_ids"].append(cve.get("id", ""))
+    year = int(cve.get("published", "1970")[:4]) if "published" in cve else None
+    if year:
+        if not cna_stats[mapped_name]["first_cve_year"] or year < cna_stats[mapped_name]["first_cve_year"]:
+            cna_stats[mapped_name]["first_cve_year"] = year
+        if not cna_stats[mapped_name]["last_cve_year"] or year > cna_stats[mapped_name]["last_cve_year"]:
+            cna_stats[mapped_name]["last_cve_year"] = year
+    if designation_year:
+        cna_stats[mapped_name]["designation_year"] = designation_year
+    cna_stats[mapped_name]["official"] = official
+    cna_stats[mapped_name]["source"].add(source)
+
+# Output summary
+summary = []
+current_year = datetime.now().year
+for name, stats in cna_stats.items():
+    years_active = None
+    if stats["designation_year"]:
+        years_active = current_year - stats["designation_year"]
+    summary.append(
+        {
+            "name": name,
+            "count": stats["count"],
+            "official": stats["official"],
+            "years_active": years_active,
+            "first_cve_year": stats["first_cve_year"],
+            "last_cve_year": stats["last_cve_year"],
+            "sources": sorted(stats["source"]),
+        }
+    )
+summary.sort(key=lambda x: x["count"], reverse=True)
+
+with open("../web/data/cna_analysis_restart.json", "w") as f:
+    json.dump(summary, f, indent=2)
+
+logger.info(f"CNA mapping complete. {len(summary)} CNAs found. Output: web/data/cna_analysis_restart.json")
diff --git a/data/scripts/generate_cna_analysis.py b/data/scripts/generate_cna_analysis.py
new file mode 100644
index 00000000000..663ca23fc9b
--- /dev/null
+++ b/data/scripts/generate_cna_analysis.py
@@ -0,0 +1,583 @@
+#!/usr/bin/env python3
+"""
+Comprehensive CNA Analysis Generator
+Processes all CVE data to generate complete CNA statistics including ALL active CNAs
+"""
+
+import json
+import sys
+from collections import Counter, defaultdict
+from datetime import datetime
+from pathlib import Path
+
+
+# Logging setup
+sys.path.insert(0, str(Path(__file__).parent.parent))
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+from download_cve_data import CVEDataDownloader  # noqa: E402 - requires the
+
+
+# sys.path entry added above, so it cannot move to the top of the file.
+
+
+class ComprehensiveCNAAnalyzer:
+    """Generates comprehensive CNA analysis with all active CNAs"""
+
+    def __init__(self):
+        self.base_dir = Path(__file__).parent
+        self.downloader = CVEDataDownloader()
+        self.data_file = None
+
+        # CNA mapping data for proper name resolution
+        self.cna_list = {}
+        self.cna_name_map = {}
+
+        logger.info("Comprehensive CNA Analyzer Initialized")
+        logger.info("Will process ALL CVE data to find every active CNA")
+
+    def ensure_data_loaded(self):
+        """Ensure CVE data is downloaded and available"""
+        if self.data_file is None:
+            if not self.quiet:
+                logger.info("Loading CVE data...")
+            self.data_file = self.downloader.ensure_data_available()
+            if not self.quiet:
+                logger.info(f"Data loaded from: {self.data_file}")
+
+            # Load CNA mapping data
+            self.load_cna_mappings()
+
+    def load_cna_mappings(self):
+        """Load CNA mapping files for proper name resolution"""
+        try:
+            # Load CNA list
+            cna_list_file = self.downloader.cache_dir / "cna_list.json"
+            if cna_list_file.exists():
+                with open(cna_list_file, encoding="utf-8") as f:
+                    cna_data = json.load(f)
+
+                    # Handle different data structure formats
+                    cna_entries = []
+                    if isinstance(cna_data, dict) and "data" in cna_data:
+                        cna_entries = cna_data["data"]
+                    elif isinstance(cna_data, list):
+                        cna_entries = cna_data
+                    elif isinstance(cna_data, dict):
+                        # Sometimes the data is directly in the root
+                        cna_entries = [cna_data] if "sourceIdentifier" in cna_data else []
+
+                    # Convert to lookup dict by sourceIdentifier
+                    for cna in cna_entries:
+                        if isinstance(cna, dict):
+                            source_id = cna.get("sourceIdentifier", "")
+                            if source_id:
+                                self.cna_list[source_id] = cna
+
+                logger.info(f"Loaded {len(self.cna_list)} CNA entries")
+
+            # Load CNA name mapping
+            cna_name_map_file = self.downloader.cache_dir / "cna_name_map.json"
+            if cna_name_map_file.exists():
+                with open(cna_name_map_file, encoding="utf-8") as f:
+                    self.cna_name_map = json.load(f)
+                logger.info(f"Loaded CNA name mappings for {len(self.cna_name_map)} entries")
+
+        except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+            logger.warning(f"Could not load CNA mappings: {e}")
+            logger.info("Will use raw sourceIdentifier values as fallback")
+
+    def resolve_cna_name(self, source_identifier):
+        """Resolve CNA sourceIdentifier to proper organization name using comprehensive mapping"""
+        try:
+            # Handle special cases first
+            if source_identifier == "416baaa9-dc9f-4396-8d5f-8c081fb06d67":
+                return "Linux Kernel Organization"
+
+            # First try the official UUID-based name mapping file (most authoritative)
+            if source_identifier in self.cna_name_map:
+                resolved_name = self.cna_name_map[source_identifier]
+                logger.debug(f"Resolved UUID {source_identifier} to: {resolved_name}")
+                return resolved_name
+
+            # Create comprehensive domain-to-organization mapping
+            domain_mappings = {
+                "mitre.org": "MITRE Corporation",
+                "oracle.com": "Oracle Corporation",
+                "adobe.com": "Adobe Inc.",
+                "redhat.com": "Red Hat, Inc.",
+                "microsoft.com": "Microsoft Corporation",
+                "google.com": "Google LLC",
+                "github.com": "GitHub, Inc.",
+                "cisco.com": "Cisco Systems, Inc.",
+                "ibm.com": "IBM Corporation",
+                "apple.com": "Apple Inc.",
+                "intel.com": "Intel Corporation",
+                "mozilla.org": "Mozilla Foundation",
+                "canonical.com": "Canonical Ltd.",
+                "debian.org": "Debian Project",
+                "apache.org": "Apache Software Foundation",
+                "kernel.org": "Linux Kernel Organization",
+                "suse.com": "SUSE LLC",
+                "ubuntu.com": "Canonical Ltd.",
+                "fedoraproject.org": "Red Hat, Inc.",
+                "centos.org": "Red Hat, Inc.",
+                "php.net": "PHP Group",
+                "python.org": "Python Software Foundation",
+                "nodejs.org": "Node.js Foundation",
+                "ruby-lang.org": "Ruby Association",
+                "perl.org": "Perl Foundation",
+                "golang.org": "Google LLC",
+                "rust-lang.org": "Rust Foundation",
+                "jenkins.io": "Jenkins Project",
+                "docker.com": "Docker Inc.",
+                "kubernetes.io": "Cloud Native Computing Foundation",
+                "openssl.org": "OpenSSL Software Foundation",
+                "nginx.org": "Nginx Inc.",
+                "eclipse.org": "Eclipse Foundation",
+                "qt.io": "The Qt Company",
+                "gnome.org": "GNOME Foundation",
+                "kde.org": "KDE e.V.",
+                "freedesktop.org": "freedesktop.org",
+                "x.org": "X.Org Foundation",
+                "videolan.org": "VideoLAN",
+                "ffmpeg.org": "FFmpeg Project",
+                "imagemagick.org": "ImageMagick Studio LLC",
+                "gimp.org": "GIMP Team",
+                "blender.org": "Blender Foundation",
+                "libreoffice.org": "The Document Foundation",
+                "wordpress.org": "WordPress Foundation",
+                "drupal.org": "Drupal Association",
+                "joomla.org": "Open Source Matters",
+                "magento.com": "Adobe Inc.",
+                "shopify.com": "Shopify Inc.",
+                "salesforce.com": "Salesforce.com, Inc.",
+                "atlassian.com": "Atlassian Corporation",
+                "jetbrains.com": "JetBrains s.r.o.",
+                "vmware.com": "VMware, Inc.",
+                "citrix.com": "Citrix Systems, Inc.",
+                "hp.com": "HP Inc.",
+                "dell.com": "Dell Technologies Inc.",
+                "lenovo.com": "Lenovo Group Limited",
+                "asus.com": "ASUSTeK Computer Inc.",
+                "acer.com": "Acer Inc.",
+                "samsung.com": "Samsung Electronics Co., Ltd.",
+                "lg.com": "LG Electronics Inc.",
+                "sony.com": "Sony Corporation",
+                "panasonic.com": "Panasonic Corporation",
+                "toshiba.com": "Toshiba Corporation",
+                "fujitsu.com": "Fujitsu Limited",
+                "hitachi.com": "Hitachi, Ltd.",
+                "nec.com": "NEC Corporation",
+                "huawei.com": "Huawei Technologies Co., Ltd.",
+                "xiaomi.com": "Xiaomi Inc.",
+                "oppo.com": "OPPO Electronics Corp.",
+                "vivo.com": "Vivo Communication Technology Co. Ltd.",
+                "oneplus.com": "OnePlus Technology (Shenzhen) Co., Ltd.",
+                "realme.com": "Realme Chongqing Mobile Telecommunications Corp., Ltd.",
+                "qualcomm.com": "QUALCOMM Incorporated",
+                "mediatek.com": "MediaTek Inc.",
+                "broadcom.com": "Broadcom Inc.",
+                "marvell.com": "Marvell Technology Group Ltd.",
+                "nvidia.com": "NVIDIA Corporation",
+                "amd.com": "Advanced Micro Devices, Inc.",
+                "arm.com": "Arm Limited",
+                "xilinx.com": "Xilinx, Inc.",
+                "altera.com": "Intel Corporation",
+                "ti.com": "Texas Instruments Incorporated",
+                "analog.com": "Analog Devices, Inc.",
+                "maxim-ic.com": "Maxim Integrated Products, Inc.",
+                "microchip.com": "Microchip Technology Inc.",
+                "st.com": "STMicroelectronics N.V.",
+                "nxp.com": "NXP Semiconductors N.V.",
+                "infineon.com": "Infineon Technologies AG",
+                "renesas.com": "Renesas Electronics Corporation",
+                "rohm.com": "ROHM Co., Ltd.",
+                "onsemi.com": "ON Semiconductor Corporation",
+                "cypress.com": "Cypress Semiconductor Corporation",
+                "lattice.com": "Lattice Semiconductor Corporation",
+                "microsemi.com": "Microsemi Corporation",
+                "actel.com": "Microsemi Corporation",
+                "patchstack.com": "patchstack.com",
+                "vuldb.com": "vuldb.com",
+                "wordfence.com": "wordfence.com",
+                "wpscan.com": "wpscan.com",
+                "trendmicro.com": "trendmicro.com",
+                "huntr.dev": "huntr.dev",
+                "snyk.io": "snyk.io",
+                "bress.net": "bress.net",
+                "flexerasoftware.com": "flexerasoftware.com",
+                "hpe.com": "hpe.com",
+                "incibe.es": "incibe.es",
+                "sap.com": "sap.com",
+                "unisoc.com": "unisoc.com",
+                "freebsd.org": "freebsd.org",
+                "netbsd.org": "NetBSD Foundation",
+                "openbsd.org": "OpenBSD Project",
+                "dragonflybsd.org": "DragonFly BSD Project",
+                "gentoo.org": "Gentoo Foundation",
+                "archlinux.org": "Arch Linux",
+                "slackware.com": "Slackware Linux, Inc.",
+                "opensuse.org": "openSUSE Project",
+                "mandriva.com": "Mandriva S.A.",
+                "mageia.org": "Mageia.Org",
+                "pclinuxos.com": "PCLinuxOS",
+                "puppy.com": "Puppy Linux",
+                "tinycore.net": "Tiny Core Linux",
+                "alpinelinux.org": "Alpine Linux",
+                "voidlinux.org": "Void Linux",
+                "nixos.org": "NixOS Foundation",
+                "guix.gnu.org": "GNU Project",
+            }
+
+            # Try domain mapping for email-like identifiers
+            if "@" in source_identifier:
+                domain = source_identifier.split("@")[-1].lower()
+                if domain in domain_mappings:
+                    return domain_mappings[domain]
+                else:
+                    # Return cleaned domain name
+                    return domain
+
+            # Try direct domain lookup
+            if source_identifier.lower() in domain_mappings:
+                return domain_mappings[source_identifier.lower()]
+
+            # For other formats, try to extract meaningful name
+            if "." in source_identifier:
+                # Looks like a domain
+                domain = source_identifier.lower()
+                if domain in domain_mappings:
+                    return domain_mappings[domain]
+                else:
+                    return source_identifier
+
+            # If it looks like a UUID but wasn't found in mapping, keep as-is for now
+            if len(source_identifier) == 36 and source_identifier.count("-") == 4:
+                logger.warning(f"UUID {source_identifier} not found in official mapping")
+                return source_identifier
+
+            # Return as-is if no mapping found
+            return source_identifier
+
+        except (KeyError, TypeError, AttributeError) as e:
+            logger.warning(f"Error resolving CNA name for '{source_identifier}': {e}")
+            return source_identifier
+
+    def generate_comprehensive_cna_analysis(self):
+        """Generate comprehensive CNA analysis with ALL active CNAs"""
+        self.ensure_data_loaded()
+
+        logger.info("Generating comprehensive CNA analysis...")
+        logger.info("Processing all CVE data to find every active CNA...")
+
+        # Track all CNAs and their statistics
+        cna_stats = defaultdict(
+            lambda: {
+                "count": 0,
+                "years_active": set(),
+                "first_cve": None,
+                "last_cve": None,
+                "severity_distribution": Counter(),
+                "cwe_types": Counter(),
+            }
+        )
+
+        total_cves_processed = 0
+        cves_with_cna = 0
+
+        logger.info("Loading JSON array from file...")
+        try:
+            with open(self.data_file, encoding="utf-8") as f:
+                cve_array = json.load(f)
+
+            if not isinstance(cve_array, list):
+                raise ValueError(f"Expected JSON array, got {type(cve_array)}")
+
+            logger.info(f"Loaded JSON array with {len(cve_array):,} entries")
+
+        except (FileNotFoundError, json.JSONDecodeError, ValueError, OSError) as e:
+            logger.error(f"Error loading JSON array: {e}")
+            return {}
+
+        # Process each CVE entry in the array
+        for entry_num, cve_data in enumerate(cve_array, 1):
+            try:
+                # Skip if data is not a dictionary
+                if not isinstance(cve_data, dict):
+                    continue
+
+                # Extract CVE ID with robust error handling
+                cve_id = ""
+                try:
+                    cve_section = cve_data.get("cve", {})
+                    if isinstance(cve_section, dict):
+                        cve_meta = cve_section.get("CVE_data_meta", {})
+                        if isinstance(cve_meta, dict):
+                            cve_id = cve_meta.get("ID", "")
+                except (AttributeError, TypeError):
+                    continue
+
+                if not cve_id or not cve_id.startswith("CVE-"):
+                    continue
+
+                total_cves_processed += 1
+
+                # Extract CNA information
+                source_identifier = cve_data.get("cve", {}).get("sourceIdentifier", "")
+                if source_identifier:
+                    cves_with_cna += 1
+
+                    # Resolve CNA name
+                    cna_name = self.resolve_cna_name(source_identifier)
+
+                    # Update CNA statistics
+                    cna_stats[cna_name]["count"] += 1
+
+                    # Extract year from CVE ID or publication date
+                    try:
+                        # Try to get publication date first
+                        pub_date = None
+                        date_fields = [
+                            ["publishedDate"],
+                            ["lastModifiedDate"],
+                            ["cve", "published"],
+                            ["cve", "lastModified"],
+                        ]
+
+                        for field_path in date_fields:
+                            try:
+                                value = cve_data
+                                for field in field_path:
+                                    value = value[field]
+                                if value:
+                                    if isinstance(value, str):
+                                        if "T" in value:
+                                            pub_date = datetime.fromisoformat(value.replace("Z", "+00:00"))
+                                            break
+                            except (KeyError, TypeError, ValueError):
+                                continue
+
+                        # Fallback to CVE ID year
+                        if not pub_date:
+                            year = int(cve_id.split("-")[1])
+                            pub_date = datetime(year, 1, 1)
+
+                        cna_stats[cna_name]["years_active"].add(pub_date.year)
+
+                        # Track first and last CVE dates
+                        if not cna_stats[cna_name]["first_cve"] or pub_date < cna_stats[cna_name]["first_cve"]:
+                            cna_stats[cna_name]["first_cve"] = pub_date
+                        if not cna_stats[cna_name]["last_cve"] or pub_date > cna_stats[cna_name]["last_cve"]:
+                            cna_stats[cna_name]["last_cve"] = pub_date
+
+                    except (ValueError, IndexError):
+                        pass
+
+                    # Extract severity information
+                    try:
+                        metrics = cve_data.get("cve", {}).get("metrics", {})
+                        severity = "UNKNOWN"
+
+                        # Try different CVSS versions
+                        for version_key in ["cvssMetricV40", "cvssMetricV31", "cvssMetricV30", "cvssMetricV2"]:
+                            if version_key in metrics:
+                                cvss_metrics = metrics[version_key]
+                                if isinstance(cvss_metrics, list) and len(cvss_metrics) > 0:
+                                    if version_key == "cvssMetricV2":
+                                        severity = cvss_metrics[0].get("baseSeverity", "UNKNOWN")
+                                    else:
+                                        cvss_data = cvss_metrics[0].get("cvssData", {})
+                                        severity = cvss_data.get("baseSeverity", "UNKNOWN")
+                                    break
+
+                        cna_stats[cna_name]["severity_distribution"][severity] += 1
+                    except (KeyError, TypeError, IndexError):
+                        cna_stats[cna_name]["severity_distribution"]["UNKNOWN"] += 1
+
+                    # Extract CWE information
+                    try:
+                        weaknesses = cve_data.get("cve", {}).get("weaknesses", [])
+                        for weakness in weaknesses:
+                            descriptions = weakness.get("description", [])
+                            for desc in descriptions:
+                                if desc.get("lang") == "en":
+                                    cwe_value = desc.get("value", "")
+                                    if cwe_value and cwe_value.startswith("CWE-") and "Missing_" not in cwe_value:
+                                        cna_stats[cna_name]["cwe_types"][cwe_value] += 1
+                    except (KeyError, TypeError):
+                        pass
+
+                # Progress indicator
+                if entry_num % 10000 == 0 and entry_num > 0 and not self.quiet:
+                    logger.debug(f"Processed {entry_num:,} entries, found {len(cna_stats)} unique CNAs so far...")
+
+            except (KeyError, ValueError, TypeError):
+                continue
+
+        logger.info("Processing complete!")
+        logger.info(f"Total CVEs processed: {total_cves_processed:,}")
+        logger.info(f"CVEs with CNA information: {cves_with_cna:,}")
+        logger.info(f"Unique CNAs found: {len(cna_stats):,}")
+
+        # Convert to final format with activity status
+        current_date = datetime.now()
+        twelve_months_ago = current_date.replace(year=current_date.year - 1)
+
+        cna_list = []
+        active_cnas = 0
+        inactive_cnas = 0
+
+        for cna_name, stats in cna_stats.items():
+            # Determine activity status based on last CVE publication
+            is_active = stats["last_cve"] and stats["last_cve"] >= twelve_months_ago
+            if is_active:
+                active_cnas += 1
+            else:
+                inactive_cnas += 1
+
+            cna_entry = {
+                "name": cna_name,
+                "count": stats["count"],
+                "years_active": len(stats["years_active"]),
+                "first_cve_year": stats["first_cve"].year if stats["first_cve"] else None,
+                "last_cve_year": stats["last_cve"].year if stats["last_cve"] else None,
+                "last_cve_date": stats["last_cve"].isoformat() if stats["last_cve"] else None,
+                "days_since_last_cve": (current_date - stats["last_cve"]).days if stats["last_cve"] else None,
+                "activity_status": "Active" if is_active else "Inactive",
+                "activity_level": self.categorize_activity_level(stats["count"]),
+                "top_severities": dict(stats["severity_distribution"].most_common(3)),
+                "top_cwes": dict(stats["cwe_types"].most_common(5)),
+            }
+            cna_list.append(cna_entry)
+
+        # Sort by CVE count (descending)
+        cna_list.sort(key=lambda x: x["count"], reverse=True)
+
+        # Generate analysis
+        total_cves = sum(stats["count"] for stats in cna_stats.values())
+
+        analysis = {
+            "top_cna_assigners_all_time": [{"name": cna["name"], "count": cna["count"]} for cna in cna_list],
+            "active_cna_assigners": [
+                {"name": cna["name"], "count": cna["count"], "last_cve_date": cna["last_cve_date"]}
+                for cna in cna_list
+                if cna["activity_status"] == "Active"
+            ],
+            "detailed_cna_stats": cna_list,
+            "summary_statistics": {
+                "total_unique_cnas": len(cna_list),
+                "active_cnas": active_cnas,
+                "inactive_cnas": inactive_cnas,
+                "activity_rate": round(active_cnas / len(cna_list) * 100, 1) if cna_list else 0,
+                "total_cves_assigned": total_cves,
+                "cves_by_active_cnas": sum(cna["count"] for cna in cna_list if cna["activity_status"] == "Active"),
+                "average_cves_per_cna": round(total_cves / len(cna_list)) if cna_list else 0,
+                "average_cves_per_active_cna": round(
+                    sum(cna["count"] for cna in cna_list if cna["activity_status"] == "Active") / active_cnas
+                )
+                if active_cnas > 0
+                else 0,
+                "top_10_share": sum(cna["count"] for cna in cna_list[:10]) / total_cves * 100 if total_cves > 0 else 0,
+                "activity_distribution": self.get_activity_distribution(cna_list),
+                "status_distribution": self.get_status_distribution(cna_list),
+                "coverage_years": self.get_coverage_years(cna_list),
+                "activity_threshold_date": twelve_months_ago.isoformat(),
+            },
+            "processing_stats": {
+                "processed_at": datetime.now().isoformat(),
+                "total_cves_processed": total_cves_processed,
+                "cves_with_cna_info": cves_with_cna,
+                "data_source": "comprehensive_nvd_jsonl_analysis",
+            },
+        }
+
+        return analysis
+
+    def categorize_activity_level(self, count):
+        """Categorize CNA activity level based on CVE count"""
+        if count >= 10000:
+            return "Very High"
+        elif count >= 1000:
+            return "High"
+        elif count >= 100:
+            return "Medium"
+        elif count >= 10:
+            return "Low"
+        else:
+            return "Minimal"
+
+    def get_activity_distribution(self, cna_list):
+        """Get distribution of CNAs by activity level"""
+        distribution = Counter()
+        for cna in cna_list:
+            distribution[cna["activity_level"]] += 1
+        return dict(distribution)
+
+    def get_status_distribution(self, cna_list):
+        """Get distribution of CNAs by activity status"""
+        distribution = Counter()
+        for cna in cna_list:
+            distribution[cna["activity_status"]] += 1
+        return dict(distribution)
+
+    def get_coverage_years(self, cna_list):
+        """Get coverage years with safe handling of empty data"""
+        try:
+            # Get all valid first and last CVE years
+            first_years = [cna["first_cve_year"] for cna in cna_list if cna["first_cve_year"] is not None]
+            last_years = [cna["last_cve_year"] for cna in cna_list if cna["last_cve_year"] is not None]
+
+            if first_years and last_years:
+                return {"earliest": min(first_years), "latest": max(last_years)}
+            else:
+                # Fallback if no valid years found
+                current_year = datetime.now().year
+                return {
+                    "earliest": 1999,  # CVE program started in 1999
+                    "latest": current_year,
+                }
+        except (ValueError, TypeError) as e:
+            logger.warning(f"Error calculating coverage years: {e}")
+            current_year = datetime.now().year
+            return {"earliest": 1999, "latest": current_year}
+
+    def save_analysis(self, analysis, output_file):
+        """Save analysis to JSON file"""
+        output_path = Path(output_file)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(output_path, "w", encoding="utf-8") as f:
+            json.dump(analysis, f, indent=2, ensure_ascii=False)
+
+        logger.info(f"Comprehensive CNA analysis saved to: {output_path}")
+        logger.info(f"Found {analysis['summary_statistics']['total_unique_cnas']:,} unique CNAs")
+        logger.info(f"Total CVEs assigned: {analysis['summary_statistics']['total_cves_assigned']:,}")
+
+
+def main():
+    """Main entry point"""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Generate comprehensive CNA analysis")
+    parser.add_argument(
+        "--output",
+        "-o",
+        default="../web/data/cna_analysis.json",
+        help="Output file path (default: ../web/data/cna_analysis.json)",
+    )
+
+    args = parser.parse_args()
+
+    analyzer = ComprehensiveCNAAnalyzer()
+    analysis = analyzer.generate_comprehensive_cna_analysis()
+    analyzer.save_analysis(analysis, args.output)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data/scripts/quick_build.py b/data/scripts/quick_build.py
new file mode 100644
index 00000000000..b220da99644
--- /dev/null
+++ b/data/scripts/quick_build.py
@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""
+CVEDB Quick Template Builder
+Fast template-only rebuild for development - skips data processing
+"""
+
+from __future__ import annotations
+
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import jinja2
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+
+class CVEQuickBuilder:
+    """Fast template-only builder for development"""
+
+    def __init__(self) -> None:
+        self.current_year: int = datetime.now().year
+        self.available_years: list[int] = list(range(1999, self.current_year + 1))
+        # Go up two levels: scripts -> data -> project root
+        self.project_root = Path(__file__).parent.parent.parent
+        self.templates_dir = self.project_root / "templates"
+        self.web_dir = self.project_root / "web"
+        self.static_dir = self.web_dir / "static"
+        self.data_dir = self.web_dir / "data"
+
+        # Set up Jinja2 environment
+        self.jinja_env = Environment(
+            loader=FileSystemLoader(self.templates_dir), autoescape=select_autoescape(["html", "xml"])
+        )
+
+        # Add custom filters and globals
+        self.jinja_env.globals["current_year"] = self.current_year
+        self.jinja_env.globals["available_years"] = self.available_years
+        self.jinja_env.filters["format_number"] = self.format_number
+
+        print("⚡ CVEDB Quick Template Builder")
+        print(f"📅 Current Year: {self.current_year}")
+        print(f"📂 Templates: {self.templates_dir}")
+        print(f"🌐 Web output: {self.web_dir}")
+
+    def format_number(self, num: Any) -> str:
+        """Format numbers with commas"""
+        if isinstance(num, (int, float)):
+            return f"{num:,}"
+        return str(num)
+
+    def copy_static_assets(self) -> None:
+        """Copy static assets (CSS, JS, images) if they don't exist"""
+        print("📁 Checking static assets...")
+
+        # Only copy if static directory doesn't exist or is empty
+        if not self.static_dir.exists() or not any(self.static_dir.iterdir()):
+            print("  📁 Copying static assets...")
+
+            # Copy from project root static if it exists
+            template_static = self.project_root / "static"
+            if template_static.exists():
+                if self.static_dir.exists():
+                    shutil.rmtree(self.static_dir)
+                shutil.copytree(template_static, self.static_dir)
+                print("  ✅ Static assets copied")
+            else:
+                print("  ⚠️  No static assets found to copy")
+        else:
+            print("  ✅ Static assets already exist")
+
+    def generate_html_pages(self) -> None:
+        """Generate HTML pages from templates"""
+        print("📄 Generating HTML pages...")
+
+        # Define pages to generate
+        pages = [
+            ("index.html", "CVEDB - Vulnerability Intelligence Platform"),
+            ("years.html", "Yearly Analysis - CVEDB"),
+            ("cna-hub.html", "CNA Intelligence Hub - CVEDB"),
+            ("cna.html", "CNA Analysis - CVEDB"),
+            ("cpe.html", "CPE Analysis - CVEDB"),
+            ("cvss.html", "CVSS Analysis - CVEDB"),
+            ("cwe.html", "CWE Analysis - CVEDB"),
+            ("calendar.html", "Calendar View - CVEDB"),
+            ("growth.html", "Growth Trends - CVEDB"),
+            ("about.html", "About CVEDB - Vulnerability Intelligence Platform"),
+            ("scoring.html", "Scoring Hub - CVEDB"),
+            ("epss.html", "EPSS Analysis - CVEDB"),
+            ("kev.html", "KEV Dashboard - CVEDB"),
+            ("data-quality.html", "CNA Name Matching - CVEDB"),
+        ]
+
+        for template_name, title in pages:
+            try:
+                template = self.jinja_env.get_template(template_name)
+
+                # Basic context for all pages
+                context = {
+                    "title": title,
+                    "current_year": self.current_year,
+                    "available_years": self.available_years,
+                }
+
+                # Add page-specific context
+                if template_name == "cna.html":
+                    context.update(
+                        {
+                            "cna_data": [],  # Empty for now - will be populated by JavaScript
+                            "total_cna_cves": 0,
+                            "active_cnas": 0,
+                            "avg_cves_per_cna": 0,
+                        }
+                    )
+
+                html_content = template.render(**context)
+
+                output_path = self.web_dir / template_name
+                with open(output_path, "w", encoding="utf-8") as f:
+                    f.write(html_content)
+
+                print(f"  📄 Generated {template_name}")
+
+            except (jinja2.TemplateError, OSError) as e:
+                print(f"  ❌ Error generating {template_name}: {e}")
+                continue
+
+        print("✅ HTML pages generated successfully")
+
+    def build(self) -> None:
+        """Main build method - templates only"""
+        print("\n🏗️  Starting quick template build...")
+        print("=" * 50)
+
+        # Ensure web directory exists
+        self.web_dir.mkdir(exist_ok=True)
+
+        # Copy static assets if needed
+        self.copy_static_assets()
+
+        # Generate HTML pages
+        self.generate_html_pages()
+
+        print("\n" + "=" * 50)
+        print("✅ Quick build completed!")
+        print(f"📁 Site ready in: {self.web_dir}")
+        print("🌐 Templates updated - data files unchanged")
+        print("⚡ Build time: ~1 second vs ~5 minutes")
+
+
+def main() -> None:
+    """Main entry point"""
+    builder = CVEQuickBuilder()
+    builder.build()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data/scripts/rebuild_cna.py b/data/scripts/rebuild_cna.py
new file mode 100755
index 00000000000..672dccb56a5
--- /dev/null
+++ b/data/scripts/rebuild_cna.py
@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""
+CNA Analysis Rebuild Script
+Quick rebuild script for CNA analysis only - much faster than full site rebuild
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from cve_v5_processor import CVEV5Processor
+from scripts.utils import print_header, setup_paths
+
+
+# Logging setup
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+def main() -> bool:
+    """Rebuild CNA analysis only"""
+    print_header("CNA Analysis Quick Rebuild", "🏢")
+
+    # Set up paths
+    project_root, cache_dir, data_dir = setup_paths()
+
+    # Initialize CVE V5 processor
+    v5_processor = CVEV5Processor(project_root, cache_dir, data_dir)
+
+    try:
+        # Generate comprehensive CNA analysis using CVE V5 data
+        logger.info("Generating comprehensive CNA analysis (CVE V5 authoritative)...")
+        cna_analysis = v5_processor.generate_comprehensive_cna_analysis()
+
+        # Generate current year CNA analysis with new publication date logic
+        logger.info(f"Generating {v5_processor.current_year} CNA analysis (by publication date)...")
+        current_cna_analysis = v5_processor.generate_current_year_analysis()
+
+        logger.info("=" * 40)
+        logger.info("CNA analysis rebuild completed!")
+        logger.info(f"Total CNAs: {cna_analysis.get('total_cnas', 0)}")
+        logger.info(f"Active CNAs: {cna_analysis.get('active_cnas', 0)}")
+        logger.info(f"Current year CNAs: {current_cna_analysis.get('total_cnas', 0)}")
+        logger.info("Files updated:")
+        logger.info("   - web/data/cna_analysis.json")
+        logger.info("   - web/data/cna_analysis_current_year.json")
+
+        return True
+
+    except (ImportError, json.JSONDecodeError, OSError) as e:
+        logger.error(f"CNA analysis rebuild failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)
diff --git a/data/scripts/rebuild_cpe.py b/data/scripts/rebuild_cpe.py
new file mode 100644
index 00000000000..b7056762e51
--- /dev/null
+++ b/data/scripts/rebuild_cpe.py
@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""
+CPE Analysis Rebuild Script
+Quick rebuild script for CPE analysis only - much faster than full site rebuild
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import jinja2
+
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from cpe_analysis import CPEAnalyzer
+from scripts.utils import load_all_year_data, print_header, setup_paths
+
+
+# Logging setup
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+def main() -> bool:
+    """Main rebuild function"""
+    print_header("CPE Analysis Quick Rebuild", "🔍")
+
+    # Setup paths
+    project_root, cache_dir, data_dir = setup_paths()
+
+    # Initialize CPE analyzer
+    logger.info("Initializing CPE analyzer...")
+    cpe_analyzer = CPEAnalyzer(project_root, cache_dir, data_dir)
+
+    # Load existing year data for context (if available)
+    logger.info("Loading existing year data...")
+    all_year_data = load_all_year_data(data_dir)
+
+    if all_year_data:
+        logger.info(f"Loaded {len(all_year_data)} existing year data files")
+    else:
+        logger.warning("No existing year data found - CPE analysis will use raw data only")
+
+    # Generate comprehensive CPE analysis
+    logger.info("Generating comprehensive CPE analysis...")
+    try:
+        cpe_analysis = cpe_analyzer.generate_cpe_analysis(all_year_data)
+
+        if cpe_analysis and cpe_analysis.get("total_unique_cpes", 0) > 0:
+            logger.info(f"Generated comprehensive CPE analysis with {cpe_analysis['total_unique_cpes']:,} unique CPEs")
+            logger.info(f"Covers {cpe_analysis['total_cves_with_cpes']:,} CVEs with CPE data")
+            logger.info(f"Includes {cpe_analysis['total_unique_vendors']:,} unique vendors")
+        else:
+            logger.error("CPE analysis failed or returned no data")
+            return 1
+
+    except (ImportError, json.JSONDecodeError, OSError) as e:
+        logger.error(f"Error generating comprehensive CPE analysis: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return 1
+
+    # Generate current year CPE analysis
+    logger.info("Generating current year CPE analysis...")
+    try:
+        current_year = datetime.now().year
+        current_year_data = next((data for data in all_year_data if data.get("year") == current_year), {})
+
+        current_cpe_analysis = cpe_analyzer.generate_current_year_cpe_analysis(current_year_data)
+
+        if current_cpe_analysis and current_cpe_analysis.get("total_unique_cpes", 0) > 0:
+            logger.info(
+                f"Generated current year CPE analysis with {current_cpe_analysis['total_unique_cpes']:,} unique CPEs"
+            )
+            logger.info(f"Covers {current_cpe_analysis['total_cves_with_cpes']:,} CVEs for {current_year}")
+        else:
+            logger.warning(f"Current year CPE analysis returned minimal data for {current_year}")
+
+    except (ImportError, json.JSONDecodeError, OSError, KeyError) as e:
+        logger.error(f"Error generating current year CPE analysis: {e}")
+        import traceback
+
+        traceback.print_exc()
+        logger.warning("Current year analysis will be missing")
+
+    # Generate CPE page HTML
+    logger.info("Generating CPE page HTML...")
+    try:
+        from jinja2 import Environment, FileSystemLoader
+
+        # Setup Jinja2 environment
+        template_dir = project_root / "templates"
+        env = Environment(loader=FileSystemLoader(template_dir))
+
+        # Load CPE template
+        template = env.get_template("cpe.html")
+
+        # Render CPE page
+        html_content = template.render(title="CPE Analysis - CVEDB", current_year=datetime.now().year)
+
+        # Save CPE page
+        output_file = project_root / "web" / "cpe.html"
+        with open(output_file, "w", encoding="utf-8") as f:
+            f.write(html_content)
+
+        logger.info(f"Generated CPE page: {output_file}")
+
+    except (ImportError, OSError, jinja2.TemplateError) as e:
+        logger.error(f"Error generating CPE page HTML: {e}")
+        import traceback
+
+        traceback.print_exc()
+        logger.warning("CPE page HTML generation failed")
+
+    logger.info("=" * 50)
+    logger.info("CPE Analysis Rebuild Complete!")
+    logger.info("Files generated:")
+    logger.info(f"  {data_dir}/cpe_analysis.json")
+    logger.info(f"  {data_dir}/cpe_analysis_current_year.json")
+    logger.info(f"  {project_root}/web/cpe.html")
+    logger.info("You can now view the CPE analysis page in your browser.")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/data/scripts/rebuild_cvss.py b/data/scripts/rebuild_cvss.py
new file mode 100755
index 00000000000..4f5d097bc69
--- /dev/null
+++ b/data/scripts/rebuild_cvss.py
@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""
+CVSS Analysis Rebuild Script
+Quick rebuild script for CVSS analysis only - much faster than full site rebuild
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from cvss_analysis import CVSSAnalyzer
+from scripts.utils import load_all_year_data, print_header, setup_paths
+
+
+# Logging setup
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+def main() -> bool:
+    """Rebuild CVSS analysis only"""
+    print_header("CVSS Analysis Quick Rebuild", "📊")
+
+    # Set up paths
+    project_root, cache_dir, data_dir = setup_paths()
+
+    # Initialize CVSS analyzer
+    cvss_analyzer = CVSSAnalyzer(project_root, cache_dir, data_dir)
+
+    try:
+        # Load existing year data
+        logger.info("Loading existing year data...")
+        all_year_data = load_all_year_data(data_dir)
+        logger.info(f"Loaded {len(all_year_data)} year data files")
+
+        if not all_year_data:
+            logger.error("No year data found. Run full build first.")
+            return False
+
+        # Generate comprehensive CVSS analysis
+        logger.info("Generating comprehensive CVSS analysis...")
+        cvss_analysis = cvss_analyzer.generate_cvss_analysis(all_year_data)
+
+        # Generate current year CVSS analysis
+        current_year = datetime.now().year
+        current_year_data = next((year for year in all_year_data if year["year"] == current_year), {})
+
+        if current_year_data:
+            logger.info(f"Generating {current_year} CVSS analysis...")
+            current_cvss_analysis = cvss_analyzer.generate_current_year_cvss_analysis(current_year_data)
+        else:
+            logger.warning(f"No {current_year} data found for current year analysis")
+            current_cvss_analysis = {}
+
+        logger.info("=" * 40)
+        logger.info("CVSS analysis rebuild completed!")
+        logger.info(f"Total CVEs with CVSS: {cvss_analysis.get('total_cves_with_cvss', 0):,}")
+        logger.info(f"CVSS v2.0: {cvss_analysis.get('total_by_version', {}).get('v2.0', 0):,}")
+        logger.info(f"CVSS v3.0: {cvss_analysis.get('total_by_version', {}).get('v3.0', 0):,}")
+        logger.info(f"CVSS v3.1: {cvss_analysis.get('total_by_version', {}).get('v3.1', 0):,}")
+        logger.info(f"CVSS v4.0: {cvss_analysis.get('total_by_version', {}).get('v4.0', 0):,}")
+        logger.info("Files updated:")
+        logger.info("   - web/data/cvss_analysis.json")
+        if current_cvss_analysis:
+            logger.info("   - web/data/cvss_analysis_current_year.json")
+
+        return True
+
+    except (ImportError, json.JSONDecodeError, OSError) as e:
+        logger.error(f"CVSS analysis rebuild failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)
diff --git a/data/scripts/rebuild_cwe.py b/data/scripts/rebuild_cwe.py
new file mode 100755
index 00000000000..7318a12a8c6
--- /dev/null
+++ b/data/scripts/rebuild_cwe.py
@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+CWE Analysis Rebuild Script
+Quick rebuild script for CWE analysis only - much faster than full site rebuild
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from cwe_analysis import CWEAnalyzer
+from scripts.utils import load_all_year_data, print_header, setup_paths
+
+
+# Logging setup
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+def main() -> bool:
+    """Rebuild CWE analysis only"""
+    print_header("CWE Analysis Quick Rebuild", "🔍")
+
+    # Set up paths
+    project_root, cache_dir, data_dir = setup_paths()
+
+    # Initialize CWE analyzer
+    cwe_analyzer = CWEAnalyzer(project_root, cache_dir, data_dir)
+
+    try:
+        # Load existing year data
+        logger.info("Loading existing year data...")
+        all_year_data = load_all_year_data(data_dir)
+        logger.info(f"Loaded {len(all_year_data)} year data files")
+
+        if not all_year_data:
+            logger.error("No year data found. Run full build first.")
+            return False
+
+        # Generate comprehensive CWE analysis
+        logger.info("Generating comprehensive CWE analysis...")
+        cwe_analysis = cwe_analyzer.generate_cwe_analysis(all_year_data)
+
+        # Generate current year CWE analysis
+        current_year = datetime.now().year
+        current_year_data = next((year for year in all_year_data if year["year"] == current_year), {})
+
+        if current_year_data:
+            logger.info(f"Generating {current_year} CWE analysis...")
+            current_cwe_analysis = cwe_analyzer.generate_current_year_cwe_analysis(current_year_data)
+        else:
+            logger.warning(f"No {current_year} data found for current year analysis")
+            current_cwe_analysis = {}
+
+        logger.info("=" * 40)
+        logger.info("CWE analysis rebuild completed!")
+        logger.info(f"Total CVEs with CWE: {cwe_analysis.get('total_cves_with_cwe', 0):,}")
+        logger.info(f"Unique CWEs: {cwe_analysis.get('total_unique_cwes', 0):,}")
+        logger.info(f"Top CWEs available: {len(cwe_analysis.get('top_cwes', []))}")
+        logger.info("Files updated:")
+        logger.info("   - web/data/cwe_analysis.json")
+        if current_cwe_analysis:
+            logger.info("   - web/data/cwe_analysis_current_year.json")
+
+        return True
+
+    except (ImportError, json.JSONDecodeError, OSError) as e:
+        logger.error(f"CWE analysis rebuild failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)
diff --git a/data/scripts/rebuild_data_quality.py b/data/scripts/rebuild_data_quality.py
new file mode 100644
index 00000000000..9e729b0f282
--- /dev/null
+++ b/data/scripts/rebuild_data_quality.py
@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+"""
+Rebuild data quality JSON with CNAScorecard-style name matching.
+
+This script implements sophisticated name matching to identify:
+1. Truly unmatched CNAs (not in official registry)
+2. Unofficial CNAs (matched but using non-standard names)
+3. Official CNAs (properly matched)
+
+Matching strategies (in order):
+1. Exact match
+2. Case-insensitive match
+3. Normalized match (remove spaces, hyphens, underscores)
+4. Partial match (substring containment)
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+
+# Logging setup
+SCRIPT_DIR = Path(__file__).parent
+DATA_DIR = SCRIPT_DIR.parent
+sys.path.insert(0, str(DATA_DIR))
+
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+# Get the data directory (override-able for staged builds)
+WEB_DATA_DIR = Path(os.environ.get("CVE_OUTPUT_DATA_DIR", str(DATA_DIR.parent / "web" / "data")))
+CACHE_DIR = DATA_DIR / "cache"
+
+
+def load_json(filepath: Path | str) -> Any:
+    """Load JSON file."""
+    with open(filepath, encoding="utf-8") as f:
+        return json.load(f)
+
+
+def save_json(filepath: Path | str, data: Any) -> None:
+    """Save JSON file."""
+    with open(filepath, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+
+
+def normalize_name(name: str) -> str:
+    """Normalize a name by removing spaces, hyphens, underscores and lowercasing."""
+    if not name:
+        return ""
+    return name.lower().replace(" ", "").replace("-", "").replace("_", "").replace(".", "")
+
+
+def build_official_cna_lookups(
+    cna_list: list[dict[str, Any]],
+) -> tuple[dict[str, dict], dict[str, dict], set[str], dict[str, dict]]:
+    """
+    Build lookup dictionaries for official CNAs.
+
+    Returns:
+        - short_name_map: shortName -> official entry
+        - org_name_map: organizationName -> official entry
+        - all_official_names: set of all names (short + org)
+        - normalized_map: normalized_name -> official entry
+    """
+    short_name_map = {}
+    org_name_map = {}
+    all_official_names = set()
+    normalized_map = {}
+
+    for cna in cna_list:
+        short_name = cna.get("shortName", "")
+        org_name = cna.get("organizationName", "")
+
+        if short_name:
+            short_name_map[short_name] = cna
+            short_name_map[short_name.lower()] = cna  # Also store lowercase
+            all_official_names.add(short_name)
+            all_official_names.add(short_name.lower())
+
+            # Normalized version
+            norm = normalize_name(short_name)
+            if norm:
+                normalized_map[norm] = cna
+
+        if org_name:
+            org_name_map[org_name] = cna
+            org_name_map[org_name.lower()] = cna
+            all_official_names.add(org_name)
+            all_official_names.add(org_name.lower())
+
+            # Normalized version
+            norm = normalize_name(org_name)
+            if norm:
+                normalized_map[norm] = cna
+
+    return short_name_map, org_name_map, all_official_names, normalized_map
+
+
+def map_cve_name_to_official(
+    cve_name: str,
+    short_name_map: dict[str, dict],
+    org_name_map: dict[str, dict],
+    normalized_map: dict[str, dict],
+    cna_list: list[dict[str, Any]],
+) -> tuple[dict | None, str | None, str | None]:
+    """
+    Attempt to match a CVE CNA name to an official CNA entry.
+
+    Matching strategies (in order of preference):
+    1. Exact match on shortName
+    2. Case-insensitive match on shortName
+    3. Exact match on organizationName
+    4. Case-insensitive match on organizationName
+    5. Normalized match (remove spaces, hyphens, underscores)
+    6. Partial match (substring containment with min length)
+
+    Returns:
+        tuple: (matched_official_entry or None, match_type, confidence)
+        match_type: 'exact_short', 'case_short', 'exact_org', 'case_org', 'normalized', 'partial', None
+        confidence: 'high', 'medium', 'low', None
+    """
+    if not cve_name:
+        return None, None, None
+
+    # 1. Exact match on shortName
+    if cve_name in short_name_map:
+        return short_name_map[cve_name], "exact_short", "high"
+
+    # 2. Case-insensitive match on shortName
+    cve_lower = cve_name.lower()
+    if cve_lower in short_name_map:
+        return short_name_map[cve_lower], "case_short", "high"
+
+    # 3. Exact match on organizationName
+    if cve_name in org_name_map:
+        return org_name_map[cve_name], "exact_org", "high"
+
+    # 4. Case-insensitive match on organizationName
+    if cve_lower in org_name_map:
+        return org_name_map[cve_lower], "case_org", "high"
+
+    # 5. Normalized match
+    normalized_cve = normalize_name(cve_name)
+    if normalized_cve and normalized_cve in normalized_map:
+        return normalized_map[normalized_cve], "normalized", "medium"
+
+    # 6. Partial matching (substring containment)
+    # Only for names with reasonable length to avoid false positives
+    if len(cve_name) > 3:
+        for cna in cna_list:
+            short = cna.get("shortName", "").lower()
+            org = cna.get("organizationName", "").lower()
+
+            # Check if CVE name contains official name or vice versa
+            if short and len(short) > 3:
+                if cve_lower in short or short in cve_lower:
+                    return cna, "partial", "low"
+
+            if org and len(org) > 5:
+                if cve_lower in org or org in cve_lower:
+                    return cna, "partial", "low"
+
+    return None, None, None
+
+
+def analyze_cna_names(cna_analysis: dict[str, Any], official_cna_list: list[dict[str, Any]]) -> dict[str, Any]:
+    """
+    Analyze all CNA names from our analysis against the official registry.
+
+    Returns categorized results with match information.
+    """
+    # Build lookup structures
+    short_name_map, org_name_map, all_official_names, normalized_map = build_official_cna_lookups(official_cna_list)
+
+    # Results
+    exact_matches = []  # Exact shortName match - official and correct
+    case_matches = []  # Case mismatch - should standardize
+    org_matches = []  # Matched via organizationName - should use shortName
+    normalized_matches = []  # Matched via normalization - naming inconsistency
+    partial_matches = []  # Partial match - likely the same but different naming
+    unmatched = []  # No match found - potentially not a registered CNA
+
+    # Also track the match details
+    match_details = {}
+
+    for cna_name, cna_data in cna_analysis.items():
+        official, match_type, confidence = map_cve_name_to_official(
+            cna_name, short_name_map, org_name_map, normalized_map, official_cna_list
+        )
+
+        result = {
+            "cna_name": cna_name,
+            "cve_count": cna_data.get("count", 0),
+            "kev_count": cna_data.get("kev_count", 0),
+            "epss_high_count": cna_data.get("epss_high_count", 0),
+        }
+
+        if official:
+            result["official_short_name"] = official.get("shortName", "")
+            result["official_org_name"] = official.get("organizationName", "")
+            result["official_id"] = official.get("cnaID", "")
+            result["match_type"] = match_type
+            result["confidence"] = confidence
+
+            match match_type:
+                case "exact_short":
+                    exact_matches.append(result)
+                case "case_short":
+                    case_matches.append(result)
+                case "exact_org" | "case_org":
+                    org_matches.append(result)
+                case "normalized":
+                    normalized_matches.append(result)
+                case "partial":
+                    partial_matches.append(result)
+        else:
+            result["match_type"] = None
+            result["confidence"] = None
+            unmatched.append(result)
+
+        match_details[cna_name] = result
+
+    # Sort by CVE count descending
+    for lst in [exact_matches, case_matches, org_matches, normalized_matches, partial_matches, unmatched]:
+        lst.sort(key=lambda x: x["cve_count"], reverse=True)
+
+    return {
+        "exact_matches": exact_matches,
+        "case_matches": case_matches,
+        "org_matches": org_matches,
+        "normalized_matches": normalized_matches,
+        "partial_matches": partial_matches,
+        "unmatched": unmatched,
+        "match_details": match_details,
+    }
+
+
+def main() -> None:
+    """Main entry point."""
+    logger.info("Rebuilding data quality analysis with CNAScorecard-style name matching...")
+
+    # Load official CNA list
+    cna_list_path = CACHE_DIR / "cna_list.json"
+    if not cna_list_path.exists():
+        logger.error(f"Official CNA list not found at {cna_list_path}")
+        sys.exit(1)
+
+    official_cna_list = load_json(cna_list_path)
+    logger.info(f"Loaded {len(official_cna_list)} official CNAs from registry")
+
+    # Load our CNA analysis
+    cna_analysis_path = WEB_DATA_DIR / "cna_analysis.json"
+    if not cna_analysis_path.exists():
+        logger.error(f"CNA analysis not found at {cna_analysis_path}")
+        sys.exit(1)
+
+    cna_analysis = load_json(cna_analysis_path)
+    # Convert cna_list array to dict keyed by name for analysis
+    cna_list_data = cna_analysis.get("cna_list", [])
+    cna_data = {item["name"]: item for item in cna_list_data if "name" in item}
+    logger.info(f"Loaded {len(cna_data)} CNAs from analysis")
+
+    # Analyze names
+    results = analyze_cna_names(cna_data, official_cna_list)
+
+    # Calculate statistics
+    stats = {
+        "total_cnas_in_analysis": len(cna_data),
+        "official_cna_registry_count": len(official_cna_list),
+        "exact_matches": len(results["exact_matches"]),
+        "case_mismatches": len(results["case_matches"]),
+        "org_name_matches": len(results["org_matches"]),
+        "normalized_matches": len(results["normalized_matches"]),
+        "partial_matches": len(results["partial_matches"]),
+        "unmatched": len(results["unmatched"]),
+    }
+
+    # Total CVEs in each category
+    stats["exact_match_cves"] = sum(x["cve_count"] for x in results["exact_matches"])
+    stats["case_mismatch_cves"] = sum(x["cve_count"] for x in results["case_matches"])
+    stats["org_name_match_cves"] = sum(x["cve_count"] for x in results["org_matches"])
+    stats["normalized_match_cves"] = sum(x["cve_count"] for x in results["normalized_matches"])
+    stats["partial_match_cves"] = sum(x["cve_count"] for x in results["partial_matches"])
+    stats["unmatched_cves"] = sum(x["cve_count"] for x in results["unmatched"])
+
+    # Calculate percentages
+    total_cves = sum(
+        [
+            stats["exact_match_cves"],
+            stats["case_mismatch_cves"],
+            stats["org_name_match_cves"],
+            stats["normalized_match_cves"],
+            stats["partial_match_cves"],
+            stats["unmatched_cves"],
+        ]
+    )
+
+    if total_cves > 0:
+        stats["exact_match_pct"] = round(stats["exact_match_cves"] / total_cves * 100, 2)
+        stats["issues_pct"] = round((total_cves - stats["exact_match_cves"]) / total_cves * 100, 2)
+
+    logger.info("=== Data Quality Summary ===")
+    logger.info(f"Total CNAs analyzed: {stats['total_cnas_in_analysis']}")
+    logger.info(f"Official registry size: {stats['official_cna_registry_count']}")
+    logger.info("Matching Results:")
+    logger.info(f"  Exact matches: {stats['exact_matches']} CNAs ({stats['exact_match_cves']:,} CVEs)")
+    logger.info(f"  Case mismatches: {stats['case_mismatches']} CNAs ({stats['case_mismatch_cves']:,} CVEs)")
+    logger.info(f"  Org name matches: {stats['org_name_matches']} CNAs ({stats['org_name_match_cves']:,} CVEs)")
+    logger.info(f"  Normalized matches: {stats['normalized_matches']} CNAs ({stats['normalized_match_cves']:,} CVEs)")
+    logger.info(f"  Partial matches: {stats['partial_matches']} CNAs ({stats['partial_match_cves']:,} CVEs)")
+    logger.info(f"  Unmatched: {stats['unmatched']} CNAs ({stats['unmatched_cves']:,} CVEs)")
+
+    # Build output
+    output = {
+        "stats": stats,
+        "exact_matches": results["exact_matches"][:50],  # Top 50 only
+        "case_mismatches": results["case_matches"],
+        "org_name_matches": results["org_matches"],
+        "normalized_matches": results["normalized_matches"],
+        "partial_matches": results["partial_matches"],
+        "unmatched": results["unmatched"],
+    }
+
+    # Save to web data directory
+    output_path = WEB_DATA_DIR / "data_quality.json"
+    save_json(output_path, output)
+    logger.info(f"Saved data quality analysis to {output_path}")
+
+    # Also print top unmatched for review
+    if results["unmatched"]:
+        logger.info("=== Top 10 Unmatched CNAs ===")
+        for item in results["unmatched"][:10]:
+            logger.info(f"  {item['cna_name']}: {item['cve_count']:,} CVEs")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/data/scripts/rebuild_growth.py b/data/scripts/rebuild_growth.py
new file mode 100644
index 00000000000..7c2e1829b98
--- /dev/null
+++ b/data/scripts/rebuild_growth.py
@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""
+Growth Analysis Rebuild Script
+Standalone script to rebuild growth analysis data and regenerate the Growth Intelligence Dashboard
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from scripts.utils import print_header, setup_paths
+from yearly_analysis import YearlyAnalyzer
+
+
+# Logging setup
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+def main() -> bool:
+    """Main function to rebuild growth analysis"""
+    print_header("Growth Analysis Rebuild", "🚀")
+
+    try:
+        # Initialize paths
+        project_root, cache_dir, _ = setup_paths()
+        data_dir = project_root / "data"  # Growth analysis uses data/ not web/data/
+
+        logger.info(f"Base directory: {project_root}")
+        logger.info(f"Cache directory: {cache_dir}")
+        logger.info(f"Data directory: {data_dir}")
+
+        # Initialize analyzer
+        logger.info("Initializing Growth Analyzer...")
+        analyzer = YearlyAnalyzer(project_root, cache_dir, data_dir)
+
+        # Generate year data first (required for growth analysis)
+        logger.info("Generating year data...")
+        all_year_data = analyzer.generate_year_data_json()
+
+        if not all_year_data:
+            logger.error("No year data available for growth analysis")
+            return False
+
+        logger.info(f"Generated data for {len(all_year_data)} years")
+
+        # Generate comprehensive growth analysis
+        logger.info("Generating comprehensive growth analysis...")
+        growth_analysis = analyzer.generate_growth_analysis(all_year_data)
+
+        if growth_analysis:
+            logger.info("Comprehensive growth analysis generated successfully")
+
+            # Display key statistics
+            growth_data = growth_analysis.get("growth_data", [])
+            if growth_data:
+                latest_year = growth_data[-1]
+                logger.info(f"Latest year: {latest_year['year']} with {latest_year['cves']:,} CVEs")
+                logger.info(f"Average annual growth: {growth_analysis.get('avg_annual_growth', 0)}%")
+
+                highest_growth = growth_analysis.get("highest_growth_year")
+                if highest_growth:
+                    logger.info(f"Peak growth: {highest_growth['year']} ({highest_growth['growth_rate']}%)")
+        else:
+            logger.error("Failed to generate comprehensive growth analysis")
+            return False
+
+        # Generate current year growth analysis
+        logger.info("Generating current year growth analysis...")
+        try:
+            current_year = analyzer.current_year
+            current_year_data = next((d for d in all_year_data if d.get("year") == current_year), None)
+
+            if current_year_data:
+                # Create simplified current year growth analysis
+                current_year_growth = {
+                    "generated_at": growth_analysis["generated_at"],
+                    "year": current_year,
+                    "growth_data": [d for d in growth_data if d["year"] == current_year],
+                    "avg_annual_growth": 0,  # Not applicable for single year
+                    "highest_growth_year": None,  # Not applicable for single year
+                    "lowest_growth_year": None,  # Not applicable for single year
+                }
+
+                # Save current year analysis
+                current_year_file = data_dir / "growth_analysis_current_year.json"
+                with open(current_year_file, "w") as f:
+                    json.dump(current_year_growth, f, indent=2)
+
+                logger.info(f"Current year ({current_year}) growth analysis generated")
+            else:
+                logger.warning(f"No data found for current year {current_year}")
+
+        except (KeyError, json.JSONDecodeError, OSError) as e:
+            logger.error(f"Error generating current year growth analysis: {e}")
+
+        logger.info("Growth analysis rebuild completed successfully!")
+        logger.info("Files generated:")
+        logger.info("  • growth_analysis.json (comprehensive)")
+        logger.info("  • growth_analysis_current_year.json (current year)")
+
+        return True
+
+    except ImportError as e:
+        logger.error(f"Import error: {e}")
+        logger.info("Make sure all required modules are available")
+        return False
+    except (OSError, json.JSONDecodeError, KeyError) as e:
+        logger.error(f"File or data error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)
diff --git a/data/scripts/rebuild_templates.py b/data/scripts/rebuild_templates.py
new file mode 100644
index 00000000000..e069543388e
--- /dev/null
+++ b/data/scripts/rebuild_templates.py
@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""
+Quick template rebuild script - regenerates HTML pages without reprocessing data
+"""
+
+from __future__ import annotations
+
+import sys
+from datetime import datetime
+from pathlib import Path
+
+from jinja2 import Environment, FileSystemLoader
+
+
+# Get project root (scripts -> data -> project root)
+project_root = Path(__file__).parent.parent.parent
+template_dir = project_root / "templates"
+web_dir = project_root / "web"
+
+# Logging setup
+sys.path.insert(0, str(project_root / "data"))
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+# Initialize Jinja2 environment
+env = Environment(loader=FileSystemLoader(str(template_dir)))
+
+# Get current year
+current_year = datetime.now().year
+
+logger.info("Rebuilding HTML templates...")
+
+# Rebuild index.html
+logger.info("Rebuilding index.html...")
+template = env.get_template("index.html")
+output = template.render(current_year=current_year, available_years=list(range(1999, current_year + 1)))
+with open(web_dir / "index.html", "w") as f:
+    f.write(output)
+
+# Rebuild growth.html
+logger.info("Rebuilding growth.html...")
+template = env.get_template("growth.html")
+output = template.render(title="Growth Intelligence Dashboard", current_year=current_year)
+with open(web_dir / "growth.html", "w") as f:
+    f.write(output)
+
+logger.info("Templates rebuilt successfully!")
+logger.info(f"View at: file://{web_dir / 'index.html'}")
diff --git a/data/unmatched_cnas_analysis.json b/data/scripts/unmatched_cnas_analysis.json
similarity index 100%
rename from data/unmatched_cnas_analysis.json
rename to data/scripts/unmatched_cnas_analysis.json
diff --git a/data/unofficial_cna_analysis.json b/data/scripts/unofficial_cna_analysis.json
similarity index 100%
rename from data/unofficial_cna_analysis.json
rename to data/scripts/unofficial_cna_analysis.json
diff --git a/src/cvedb/utils/legacy.py b/data/scripts/utils.py
similarity index 50%
rename from src/cvedb/utils/legacy.py
rename to data/scripts/utils.py
index 14d7da9612b..1f9079dd49d 100644
--- a/src/cvedb/utils/legacy.py
+++ b/data/scripts/utils.py
@@ -3,16 +3,35 @@
 Shared utilities for rebuild scripts
 """
 
+from __future__ import annotations
+
 import json
 import sys
 from datetime import datetime
 from pathlib import Path
 
 
-def setup_paths():
+# Logging setup
+try:
+    from data.logging_config import get_logger
+except ImportError:
+    try:
+        from logging_config import get_logger
+    except ImportError:
+        # Fallback: scripts/ -> data/ path setup may not be done yet
+        scripts_dir = Path(__file__).parent
+        data_module_dir = scripts_dir.parent
+        if str(data_module_dir) not in sys.path:
+            sys.path.insert(0, str(data_module_dir))
+        from logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+def setup_paths() -> tuple[Path, Path, Path]:
     """
     Set up paths and ensure parent modules are importable.
-    
+
     Returns:
         tuple: (project_root, cache_dir, data_dir)
     """
@@ -20,57 +39,57 @@ def setup_paths():
     scripts_dir = Path(__file__).parent
     data_module_dir = scripts_dir.parent
     project_root = data_module_dir.parent
-    
+
     # Add data/ to path for importing analysis modules
     if str(data_module_dir) not in sys.path:
         sys.path.insert(0, str(data_module_dir))
-    
-    cache_dir = data_module_dir / 'cache'
-    web_data_dir = project_root / 'web' / 'data'
-    
+
+    cache_dir = data_module_dir / "cache"
+    web_data_dir = project_root / "web" / "data"
+
     # Ensure directories exist
     web_data_dir.mkdir(parents=True, exist_ok=True)
-    
+
     return project_root, cache_dir, web_data_dir
 
 
-def load_all_year_data(data_dir: Path) -> list:
+def load_all_year_data(data_dir: Path) -> list[dict]:
     """
     Load all existing year data files.
-    
+
     Args:
         data_dir: Path to web/data directory containing cve_YYYY.json files
-        
+
     Returns:
         List of year data dictionaries
     """
-    all_year_data = []
+    all_year_data: list[dict] = []
     current_year = datetime.now().year
-    
+
     for year in range(1999, current_year + 1):
-        year_file = data_dir / f'cve_{year}.json'
+        year_file = data_dir / f"cve_{year}.json"
         if year_file.exists():
             try:
-                with open(year_file, 'r') as f:
+                with open(year_file) as f:
                     year_data = json.load(f)
                 all_year_data.append(year_data)
-            except Exception as e:
-                print(f"  ⚠️  Error loading {year_file}: {e}")
-    
+            except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
+                logger.warning(f"Error loading {year_file}: {e}")
+
     return all_year_data
 
 
-def print_header(title: str, emoji: str = "🔄"):
+def print_header(title: str, emoji: str = "🔄") -> None:
     """Print a consistent header for rebuild scripts."""
-    print(f"{emoji} CVEDB {title}")
-    print("=" * 40)
+    logger.info(f"CVEDB {title}")
+    logger.info("=" * 40)
 
 
-def print_success(message: str):
+def print_success(message: str) -> None:
     """Print a success message."""
-    print(f"✅ {message}")
+    logger.info(message)
 
 
-def print_error(message: str):
+def print_error(message: str) -> None:
     """Print an error message."""
-    print(f"❌ {message}")
+    logger.error(message)
diff --git a/data/vendor_analysis.py b/data/vendor_analysis.py
new file mode 100644
index 00000000000..9cc66e3eb23
--- /dev/null
+++ b/data/vendor_analysis.py
@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+"""
+Vendor Analysis Module
+Handles all vendor/CPE (Common Platform Enumeration) related data processing and analysis
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class VendorAnalyzer:
+    """Handles vendor/CPE-specific analysis and data processing"""
+
+    base_dir: Path
+    cache_dir: Path
+    data_dir: Path
+    current_year: int = field(default_factory=lambda: datetime.now().year)
+
+    def __post_init__(self) -> None:
+        """Convert path arguments to Path objects if needed."""
+        self.base_dir = Path(self.base_dir)
+        self.cache_dir = Path(self.cache_dir)
+        self.data_dir = Path(self.data_dir)
+
+    def generate_vendor_analysis(self, all_year_data: list[dict[str, Any]]) -> dict[str, Any]:
+        """Generate CPE vendor analysis across all years"""
+        logger.info("  🏢 Generating vendor/CPE analysis...")
+
+        # Aggregate vendor data from all years
+        combined_vendors = {}
+        total_cves_with_vendors = 0
+
+        for year_data in all_year_data:
+            if "vendors" in year_data and "cpe_vendors" in year_data["vendors"]:
+                total_cves_with_vendors += year_data["vendors"].get("total_cves_with_vendors", 0)
+
+                # Aggregate vendor counts
+                for vendor_entry in year_data["vendors"]["cpe_vendors"]:
+                    vendor_name = vendor_entry["name"]
+                    count = vendor_entry["count"]
+
+                    if vendor_name not in combined_vendors:
+                        combined_vendors[vendor_name] = {"name": vendor_name, "count": 0}
+
+                    combined_vendors[vendor_name]["count"] += count
+
+        # Sort by count and get top vendors
+        top_vendors = sorted(combined_vendors.values(), key=lambda x: x["count"], reverse=True)
+
+        vendor_analysis = {
+            "generated_at": datetime.now().isoformat(),
+            "total_cves_with_vendors": total_cves_with_vendors,
+            "total_unique_vendors": len(combined_vendors),
+            "top_vendors": top_vendors[:100],  # Top 100 vendors
+            "top_vendors_limited": top_vendors[:20],  # Top 20 for charts
+        }
+
+        # Save to file
+        output_file = self.data_dir / "vendor_analysis.json"
+        with open(output_file, "w") as f:
+            json.dump(vendor_analysis, f, indent=2)
+
+        logger.info(f"  ✅ Generated vendor analysis with {len(combined_vendors):,} unique vendors")
+        return vendor_analysis
+
+    def generate_current_year_vendor_analysis(self, current_year_data: dict[str, Any]) -> dict[str, Any]:
+        """Generate current year vendor analysis"""
+        logger.info("    🏢 Generating current year vendor analysis...")
+
+        # Extract vendor data from current year
+        vendor_data = current_year_data.get("vendors", {})
+
+        if not vendor_data or "cpe_vendors" not in vendor_data:
+            logger.warning(f"    ⚠️  No vendor data found for {self.current_year}")
+            return {}
+
+        # Get current year vendors
+        current_year_vendors = vendor_data["cpe_vendors"]
+
+        current_year_vendor_analysis = {
+            "generated_at": datetime.now().isoformat(),
+            "year": self.current_year,
+            "total_cves_with_vendors": vendor_data.get("total_cves_with_vendors", 0),
+            "total_unique_vendors": len(current_year_vendors),
+            "top_vendors": current_year_vendors[:100],  # Top 100 vendors
+            "top_vendors_limited": current_year_vendors[:20],  # Top 20 for charts
+        }
+
+        # Save current year analysis
+        current_year_file = self.data_dir / "vendor_analysis_current_year.json"
+        with open(current_year_file, "w") as f:
+            json.dump(current_year_vendor_analysis, f, indent=2)
+
+        logger.info(f"    ✅ Generated current year vendor analysis with {len(current_year_vendors)} vendors")
+        return current_year_vendor_analysis
diff --git a/data/yearly_analysis.py b/data/yearly_analysis.py
new file mode 100644
index 00000000000..c0bd02d643a
--- /dev/null
+++ b/data/yearly_analysis.py
@@ -0,0 +1,395 @@
+#!/usr/bin/env python3
+"""
+Yearly Analysis Module
+Handles year-by-year data processing and aggregation
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Any
+
+
+# Logging setup
+try:
+    from data.logging_config import get_logger
+except ImportError:  # pragma: no cover - depends on how the module is imported
+    from logging_config import get_logger  # type: ignore[no-redef]
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class YearlyAnalyzer:
+    """Handles yearly data processing and aggregation"""
+
+    base_dir: Path
+    cache_dir: Path
+    data_dir: Path
+    quiet: bool = False
+    current_year: int = field(default_factory=lambda: datetime.now().year)
+    available_years: list[int] = field(init=False)
+
+    def __post_init__(self) -> None:
+        """Convert path arguments and set up derived attributes."""
+        self.base_dir = Path(self.base_dir)
+        self.cache_dir = Path(self.cache_dir)
+        self.data_dir = Path(self.data_dir)
+        self.available_years = list(range(1999, self.current_year + 1))
+
+    def calculate_actual_ytd_count(self, year: int, day_of_year: int) -> int:
+        """Calculate actual YTD CVE count for a given year up to specific day of year"""
+        try:
+            # Use the already-generated year data file which contains daily counts
+            year_file = self.data_dir / f"cve_{year}.json"
+
+            if not year_file.exists():
+                if not self.quiet:
+                    print(f"⚠️  Warning: Year file for {year} not found")
+                return 0
+
+            import json
+
+            with open(year_file) as f:
+                year_data = json.load(f)
+
+            # Get daily counts from the pre-processed data
+            daily_counts = year_data.get("date_data", {}).get("daily_analysis", {}).get("daily_counts", {})
+
+            # Sum up CVEs from Jan 1 to the target day of year
+            ytd_count = 0
+            for day_num in range(1, day_of_year + 1):
+                date_key = (datetime(year, 1, 1) + timedelta(days=day_num - 1)).strftime("%Y-%m-%d")
+                ytd_count += daily_counts.get(date_key, 0)
+
+            return ytd_count
+
+        except (FileNotFoundError, json.JSONDecodeError, OSError, ImportError) as e:
+            if not self.quiet:
+                print(f"⚠️  Warning: Could not calculate actual YTD for {year}: {e}")
+            # Fallback: try to use uniform distribution if we have the year data file
+            try:
+                year_file = self.data_dir / f"cve_{year}.json"
+                if year_file.exists():
+                    import json
+
+                    with open(year_file) as f:
+                        year_data = json.load(f)
+                    total_cves = year_data.get("total_cves", 0)
+                    days_in_year = 366 if year % 4 == 0 else 365
+                    return int((total_cves / days_in_year) * day_of_year)
+            except (OSError, json.JSONDecodeError, TypeError, ValueError):
+                pass
+            return 0
+
+    def generate_year_data_json(self) -> list[dict[str, Any]]:
+        """Generate JSON data files for all available years"""
+        if not self.quiet:
+            logger.info("Generating year data JSON files...")
+
+        try:
+            # Import the years analyzer
+            from cve_years import CVEYearsAnalyzer
+
+            if not self.quiet:
+                logger.info("Initializing CVE data processing...")
+            analyzer = CVEYearsAnalyzer(quiet=self.quiet)
+
+            # Generate data for all years
+            all_year_data = []
+
+            for year in self.available_years:
+                logger.debug(f"Processing {year}...")
+
+                try:
+                    year_data = analyzer.get_year_data(year)
+
+                    if year_data:
+                        # Save individual year file
+                        year_file = self.data_dir / f"cve_{year}.json"
+                        with open(year_file, "w") as f:
+                            json.dump(year_data, f, indent=2)
+
+                        all_year_data.append(year_data)
+                        logger.info(f"Generated cve_{year}.json ({year_data.get('total_cves', 0):,} CVEs)")
+                    else:
+                        logger.warning(f"No data available for {year}")
+
+                except (KeyError, json.JSONDecodeError, OSError) as e:
+                    logger.error(f"Failed to process {year}: {e}")
+                    continue
+
+            logger.info(f"Generated {len(all_year_data)} year data files")
+            return all_year_data
+
+        except ImportError as e:
+            logger.error(f"Failed to import CVE years analyzer: {e}")
+            logger.info("Creating placeholder data for development...")
+            return self.create_placeholder_year_data()
+        except (json.JSONDecodeError, OSError, KeyError) as e:
+            logger.error(f"Error generating year data: {e}")
+            return []
+
+    def create_placeholder_year_data(self) -> list[dict[str, Any]]:
+        """Create placeholder year data for development/testing"""
+        logger.info("Creating placeholder year data...")
+
+        all_year_data = []
+
+        for year in self.available_years:
+            # Create basic placeholder data structure
+            year_data = {
+                "year": year,
+                "total_cves": max(100, (year - 1999) * 500),  # Increasing trend
+                "date_data": {
+                    "monthly_distribution": {str(i): max(10, (year - 1999) * 5) for i in range(1, 13)},
+                    "daily_analysis": {
+                        "total_days": 365,
+                        "days_with_cves": min(365, max(50, (year - 1999) * 10)),
+                        "avg_cves_per_day": max(1, (year - 1999) * 1.5),
+                        "max_cves_in_day": max(5, (year - 1999) * 3),
+                        "daily_counts": {},
+                    },
+                },
+                "vendors": {
+                    "total_cves_with_vendors": max(80, (year - 1999) * 400),
+                    "cpe_vendors": [
+                        {"name": "Microsoft Corporation", "count": max(20, (year - 1999) * 50)},
+                        {"name": "Adobe Inc.", "count": max(15, (year - 1999) * 30)},
+                        {"name": "Oracle Corporation", "count": max(10, (year - 1999) * 25)},
+                        {"name": "Google LLC", "count": max(8, (year - 1999) * 20)},
+                        {"name": "Apple Inc.", "count": max(5, (year - 1999) * 15)},
+                    ],
+                    "cna_assigners": [
+                        {"name": "MITRE Corporation", "count": max(50, (year - 1999) * 100)},
+                        {"name": "Patchstack", "count": max(20, (year - 1999) * 40)},
+                        {"name": "Microsoft Corporation", "count": max(15, (year - 1999) * 30)},
+                        {"name": "Adobe Inc.", "count": max(10, (year - 1999) * 25)},
+                        {"name": "Wordfence", "count": max(8, (year - 1999) * 20)},
+                    ],
+                },
+                "cvss": {
+                    "total_cves_with_cvss": max(70, (year - 1999) * 350),
+                    "v2.0": {
+                        "severity": {"LOW": 10, "MEDIUM": 30, "HIGH": 20},
+                        "scores": {"2.1": 5, "5.0": 15, "7.5": 10, "9.3": 8},
+                    },
+                    "v3.0": {
+                        "severity": {"LOW": 15, "MEDIUM": 40, "HIGH": 25, "CRITICAL": 10},
+                        "scores": {"3.1": 8, "5.4": 20, "7.8": 15, "9.8": 12},
+                    },
+                    "v3.1": {
+                        "severity": {"LOW": 20, "MEDIUM": 50, "HIGH": 30, "CRITICAL": 15},
+                        "scores": {"2.7": 10, "5.9": 25, "8.1": 18, "9.9": 15},
+                    },
+                },
+                "cwe": {
+                    "total_cves_with_cwe": max(60, (year - 1999) * 300),
+                    "top_cwes": [
+                        {"id": "79", "name": "Cross-site Scripting (XSS)", "count": max(10, (year - 1999) * 20)},
+                        {"id": "89", "name": "SQL Injection", "count": max(8, (year - 1999) * 15)},
+                        {"id": "20", "name": "Improper Input Validation", "count": max(6, (year - 1999) * 12)},
+                        {"id": "22", "name": "Path Traversal", "count": max(5, (year - 1999) * 10)},
+                        {"id": "352", "name": "Cross-Site Request Forgery (CSRF)", "count": max(4, (year - 1999) * 8)},
+                    ],
+                },
+            }
+
+            # Save individual year file
+            year_file = self.data_dir / f"cve_{year}.json"
+            with open(year_file, "w") as f:
+                json.dump(year_data, f, indent=2)
+
+            all_year_data.append(year_data)
+            logger.debug(f"Created placeholder cve_{year}.json")
+
+        logger.info(f"Created {len(all_year_data)} placeholder year files")
+        return all_year_data
+
+    def generate_cve_all_json(self, all_year_data: list[dict[str, Any]]) -> dict[str, Any]:
+        """Generate overall CVE statistics across all years"""
+        logger.info("Generating overall CVE statistics...")
+
+        # Calculate totals and trends
+        total_cves = sum(year["total_cves"] for year in all_year_data)
+        years_with_data = len(all_year_data)
+
+        # Find peak year
+        peak_year_data = max(all_year_data, key=lambda x: x["total_cves"])
+        peak_year = peak_year_data["year"]
+        peak_count = peak_year_data["total_cves"]
+
+        # Calculate current year stats
+        current_year_data = next((year for year in all_year_data if year["year"] == self.current_year), None)
+        current_year_count = current_year_data["total_cves"] if current_year_data else 0
+
+        # Calculate YoY growth (current vs previous year)
+        previous_year_data = next((year for year in all_year_data if year["year"] == self.current_year - 1), None)
+        previous_year_count = previous_year_data["total_cves"] if previous_year_data else 0
+
+        yoy_growth: float = 0.0
+        if previous_year_count > 0:
+            yoy_growth = ((current_year_count - previous_year_count) / previous_year_count) * 100
+
+        # Calculate average CVEs per day for current year
+        avg_cves_per_day: float = 0.0
+        if current_year_data:
+            days_elapsed = datetime.now().timetuple().tm_yday
+            avg_cves_per_day = current_year_count / days_elapsed if days_elapsed > 0 else 0
+
+        # Create yearly trend data for charts
+        yearly_data = []
+        for year_data in sorted(all_year_data, key=lambda x: x["year"]):
+            yearly_data.append({"year": year_data["year"], "count": year_data["total_cves"]})
+
+        cve_all_data = {
+            "generated_at": datetime.now().isoformat(),
+            "total_cves": total_cves,
+            "years_covered": years_with_data,
+            "current_year": self.current_year,
+            "current_year_cves": current_year_count,
+            "peak_year": peak_year,
+            "peak_count": peak_count,
+            "yoy_growth_rate": round(yoy_growth, 1),
+            "avg_cves_per_day": round(avg_cves_per_day, 1),
+            "yearly_trend": yearly_data,
+        }
+
+        # Save to file
+        output_file = self.data_dir / "cve_all.json"
+        with open(output_file, "w") as f:
+            json.dump(cve_all_data, f, indent=2)
+
+        logger.info(f"Generated cve_all.json with {total_cves:,} total CVEs")
+        return cve_all_data
+
+    def generate_growth_analysis(self, all_year_data: list[dict[str, Any]]) -> dict[str, Any]:
+        """Generate growth trend analysis across all years"""
+        logger.info("Generating growth trend analysis...")
+
+        # Get current date for year-to-date calculations
+        current_date = datetime.now()
+        current_year = current_date.year
+        day_of_year = current_date.timetuple().tm_yday
+
+        # Calculate year-over-year growth rates
+        growth_data = []
+
+        for i, year_data in enumerate(sorted(all_year_data, key=lambda x: x["year"])):
+            if i == 0:
+                # First year, no previous data for comparison
+                growth_data.append(
+                    {
+                        "year": year_data["year"],
+                        "cves": year_data["total_cves"],
+                        "growth_rate": 0,
+                        "growth_absolute": 0,
+                        "is_ytd": year_data["year"] == current_year,
+                    }
+                )
+            else:
+                prev_year_data = sorted(all_year_data, key=lambda x: x["year"])[i - 1]
+                prev_count = prev_year_data["total_cves"]
+                current_count = year_data["total_cves"]
+
+                # For current year, we need to calculate YTD comparison
+                if year_data["year"] == current_year:
+                    # Calculate proper YTD comparison: current YTD vs same period last year
+                    # We need to get CVEs from previous year up to the same day of year
+
+                    # First, calculate projected full year for growth rate
+                    days_in_year = 366 if current_year % 4 == 0 else 365
+                    projected_full_year = (current_count / day_of_year) * days_in_year
+
+                    # Calculate ACTUAL YTD count for previous year using same date filtering
+                    # This fixes the major bug of using uniform distribution assumption
+                    prev_year_ytd_actual = self.calculate_actual_ytd_count(current_year - 1, day_of_year)
+
+                    # Calculate true YTD comparison (current YTD vs previous year actual same period)
+                    # This should be the PRIMARY growth rate for YTD data
+                    ytd_comparison = 0
+                    if prev_year_ytd_actual > 0:
+                        ytd_comparison = ((current_count - prev_year_ytd_actual) / prev_year_ytd_actual) * 100
+
+                    # Calculate projected full year for reference but don't use as main growth rate
+                    projected_full_year = (current_count / day_of_year) * days_in_year
+
+                    growth_data.append(
+                        {
+                            "year": year_data["year"],
+                            "cves": current_count,
+                            "growth_rate": round(ytd_comparison, 1),  # Use YTD comparison as main growth rate!
+                            "growth_absolute": int(current_count - prev_year_ytd_actual),  # YTD absolute change
+                            "is_ytd": True,
+                            "projected_full_year": int(projected_full_year),
+                            "ytd_vs_prev_full": round(((current_count - prev_count) / prev_count) * 100, 1)
+                            if prev_count > 0
+                            else 0,
+                            "ytd_vs_prev_ytd": round(ytd_comparison, 1),
+                            "prev_year_ytd_actual": int(prev_year_ytd_actual),
+                        }
+                    )
+                else:
+                    # Normal year-over-year calculation for completed years
+                    growth_rate = 0
+                    if prev_count > 0:
+                        growth_rate = ((current_count - prev_count) / prev_count) * 100
+
+                    growth_data.append(
+                        {
+                            "year": year_data["year"],
+                            "cves": current_count,
+                            "growth_rate": round(growth_rate, 1),
+                            "growth_absolute": current_count - prev_count,
+                            "is_ytd": False,
+                        }
+                    )
+
+        # Calculate moving averages (exclude current year from averages since it's YTD)
+        window_size = 3
+        for i, entry in enumerate(growth_data):
+            if entry.get("is_ytd", False):
+                # For YTD data, don't calculate moving average
+                entry["growth_rate_3yr_avg"] = entry["growth_rate"]
+            elif i >= window_size - 1:
+                # Only include completed years in moving average
+                window_rates = [
+                    growth_data[j]["growth_rate"]
+                    for j in range(i - window_size + 1, i + 1)
+                    if not growth_data[j].get("is_ytd", False)
+                ]
+                if window_rates:
+                    entry["growth_rate_3yr_avg"] = round(sum(window_rates) / len(window_rates), 1)
+                else:
+                    entry["growth_rate_3yr_avg"] = entry["growth_rate"]
+            else:
+                entry["growth_rate_3yr_avg"] = entry["growth_rate"]
+
+        # Filter out YTD data for aggregate statistics since it's not comparable
+        completed_years = [entry for entry in growth_data[1:] if not entry.get("is_ytd", False)]
+
+        # Get current year data for YTD comparison
+        current_year_data = next((entry for entry in growth_data if entry.get("is_ytd", False)), None)
+
+        growth_analysis = {
+            "generated_at": datetime.now().isoformat(),
+            "growth_data": growth_data,
+            "avg_annual_growth": round(sum(entry["growth_rate"] for entry in completed_years) / len(completed_years), 1)
+            if completed_years
+            else 0,
+            "highest_growth_year": max(completed_years, key=lambda x: x["growth_rate"]) if completed_years else None,
+            "lowest_growth_year": min(completed_years, key=lambda x: x["growth_rate"]) if completed_years else None,
+            "current_year_ytd": current_year_data,
+        }
+
+        # Save to file
+        output_file = self.data_dir / "growth_analysis.json"
+        with open(output_file, "w") as f:
+            json.dump(growth_analysis, f, indent=2)
+
+        if not self.quiet:
+            logger.info(f"Generated growth analysis with {len(growth_data)} years of data")
+        return growth_analysis
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index f8dec7e4ec6..f2d2dc4d135 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -124,6 +124,7 @@ def analyze(nvd_data, current_year_only=False):
     # Process data
     # Return analysis dict
 
+
 def main():
     """Command-line entry point."""
     # Load cache
@@ -168,7 +169,6 @@ cvedb.github.io/
 │   ├── scripts/            # Utility scripts
 │   └── *_analysis.py       # Analysis modules
 ├── docs/
-│   ├── ROADMAP.md          # Development roadmap
 │   └── ARCHITECTURE.md     # This file
 ├── templates/              # Jinja2 HTML templates
 ├── tests/                  # pytest test suite
@@ -197,7 +197,7 @@ Run with: `pytest tests/ -v`
 
 The `--validate` flag checks data consistency:
 
-- CNA total ≈ cve_all total (within 1000)
+- CNA total ≈ cve_all total (within max(1000, 0.5% of cve_all))
 - Year totals sum correctly
 - No duplicate CVE IDs
 
diff --git a/docs/COUNTING.md b/docs/COUNTING.md
index 3e70d2a8bc6..52df4bad237 100644
--- a/docs/COUNTING.md
+++ b/docs/COUNTING.md
@@ -86,19 +86,40 @@ Total V5 files:       319,485
 
 ### CNA Total vs cve_all Total
 
-The CNA analysis and cve_all.json have a small difference (~728 CVEs). This is expected due to:
+`cna_analysis.json` (V5) always runs ahead of `cve_all.json` (NVD, 1999+). The gap is
+**two independent terms**, and they behave completely differently:
 
 ```text
-CNA total (V5):       ~303,297  (V5 repo, no rejected)
-cve_all total (NVD):  ~302,569  (NVD, no rejected, 1999+)
-Difference:               ~728
-
-Breakdown:
-- Pre-1999 CVEs:          ~679  (excluded from NVD year files)
-- Source variance:         ~49  (minor V5 vs NVD timing diff)
+gap = pre_1999_offset + nvd_ingestion_lag
 ```
 
-Both sources now consistently exclude REJECTED CVEs (~16,188).
+| Term | Size | Behaviour |
+|------|------|-----------|
+| **Pre-1999 offset** | 679 (measured 2026-08-26) | **Frozen.** Legacy CVEs backdated to their original 1988-1998 disclosure date (1997: 252, 1998: 246). `cve_all.json` is assembled from the 1999+ year files, so they are dropped there; `cna_analysis.json` counts every non-rejected V5 record. Does not grow with the corpus. |
+| **NVD ingestion lag** | 100-1,500, spiky | **Varies with _daily publication volume_, not corpus size.** cvelistV5 has a CVE the instant the CNA publishes; NVD ingests behind. One Oracle CPU day lands 1,100-1,400 CVEs at once. |
+
+Both sources consistently exclude REJECTED CVEs.
+
+The build measures the pre-1999 term rather than assuming it, and publishes it as
+`cve_all.json:excluded_pre_1999`. `reconcile_cna_vs_year_totals()` in `build.py`
+subtracts it and bounds only the lag term, in both directions:
+
+- **Lag > `MAX_INGESTION_LAG` (3,000)** — two heavy publication days with no ingestion.
+  The NVD feed has stalled. Fails the build.
+- **Lag < `-MAX_NVD_LEAD` (-100)** — NVD is *ahead* of cvelistV5, which cannot legitimately
+  happen. One of the feeds is wrong. Fails the build.
+
+#### Why not a single tolerance?
+
+This check previously compared `abs(CNA - cve_all)` against a flat `< 1000`, which measured
+both terms together. The fixed 679-record offset consumed two thirds of the budget, leaving
+only ~321 CVEs of headroom for the term that actually moves. On **2026-08-25** a busy but
+unremarkable publication day (787 CVEs, 327 of them one Chrome batch) pushed the gap to
+1,196 and failed the scheduled deploy.
+
+Widening the tolerance to a percentage of corpus size does not fix this — it scales the
+budget against a number that has no relationship to either term. Subtracting the known
+offset is what restores the full budget to the lag.
 
 ## Validation
 
diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md
deleted file mode 100644
index 7e4edb691e3..00000000000
--- a/docs/ROADMAP.md
+++ /dev/null
@@ -1,66 +0,0 @@
-# CVEDB Strategic Roadmap (2026)
-
-> Living implementation plan based on the 2026 architectural audit. Focus: Modularization, maintainability, and professionalization of the codebase.
-
-## 1. Guiding Objectives
-
-- **Architecture First**: Clean separation of concerns (Source vs. Data vs. Artifacts).
-- **Package-Based**: Move away from script soup to a proper Python package (`src/cvedb`).
-- **Testable**: Ensure all logic is verifiable via standard test suites.
-- **Maintainable**: Clear entry points, standardized build commands, and CI/CD integration.
-
----
-
-## 2. Phase 10 – Project Reorganization (Q1 2026) ✅ Complete
-
-**Goal:** Refactor the codebase to separate source code, data, and build artifacts.
-
-### 2.1. Directory Structure Restructure ✅
-- [x] **Create `src/cvedb` package**
-  - Moved analysis logic to `src/cvedb/analysis`
-  - Moved CNA pipeline to `src/cvedb/cna`
-  - Moved ingest logic to `src/cvedb/ingest`
-- [x] **Clean Data Directory**
-  - `data/` now only contains config and raw cache.
-  - Removed all executable Python scripts from `data/`.
-- [x] **Unified Frontend**
-  - Merged `cna/templates` into `templates/`
-  - Centralized static assets in `static/`
-- [x] **Standardize Scripts**
-  - `scripts/build.py` updated to use the package structure.
-  - `Makefile` updated to support `install`, `build`, `serve` commands.
-
-### 2.2. Package Distribution ✅
-- [x] **`pyproject.toml`**
-  - usage of standard `setuptools` build backend.
-  - `pip install -e .` installation support.
-
----
-
-## 3. Phase 11 – Test Suite Modernization (Q1 2026) ✅ Complete
-
-**Goal:** Ensure the test suite works with the new package structure and covers critical paths.
-
-### 3.1. Test Refactoring ✅
-- [x] **Update Import Paths**
-  - Tests now import from `cvedb` package instead of using `sys.path` hacks.
-- [x] **Update Test Data Paths**
-  - `test_build.py` verifies `dist/` instead of `web/`.
-  - `test_schemas.py` validates `dist/data/` JSON outputs.
-
-### 3.2. CI/CD Pipeline Update ✅
-- [x] **`deploy.yml` Update**
-  - Workflow now installs the package before testing.
-  - Deploys from the new `dist/` directory.
-
----
-
-## 4. Future Phases (Q2 2026+)
-
-### 4.1. Performance & caching
-- [ ] Implement incremental builds (only rebuild year files for changed data).
-- [ ] Parallelize downloads in `ingest` module.
-
-### 4.2. Analysis Enhancements
-- [ ] Migrate legacy `rebuild_*.py` scripts to use the `cvedb` package API.
-- [ ] Add type hinting (mypy) to the core package.
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index dbbed56d034..4c96ae0b3e0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,22 +1,219 @@
-[build-system]
-requires = ["setuptools>=61.0"]
-build-backend = "setuptools.build_meta"
+# pyproject.toml - Python project configuration
+# CVEDB Static Site Generator
 
 [project]
-name = "cvedb"
-version = "0.1.0"
-description = "CVE Database Analysis and CNA Scorecard Tools"
+name = "cve-icu"
+version = "1.0.0"
+description = "CVEDB - Vulnerability Intelligence Static Site Generator"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.12"
+license = {text = "MIT"}
+keywords = ["cve", "vulnerability", "security", "nvd", "cna"]
+authors = [
+    {name = "CVEDB Team"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Security",
+]
+
 dependencies = [
-    "jinja2",
-    "requests",
-    "pandas",
-    "fsspec"
+    "aiofiles>=24.1.0",
+    "aiohttp>=3.11.0",
+    "jinja2>=3.1.4",
+    "requests>=2.32.0",
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.21.0",
+    "pytest-cov>=4.0.0",
+    "mypy>=1.0.0",
+    "ruff>=0.1.0",
+    "pre-commit>=3.0.0",
+    "types-requests",
+    "types-aiofiles",
 ]
 
 [project.scripts]
-cvedb-build = "scripts.build:main"
+cve-icu = "build:main"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+# ============================================================================
+# Ruff Configuration
+# Fast Python linter and formatter (replaces flake8, black, isort)
+# ============================================================================
+[tool.ruff]
+target-version = "py312"
+line-length = 120
+indent-width = 4
+
+# Exclude directories
+exclude = [
+    ".git",
+    ".github",
+    ".mypy_cache",
+    ".ruff_cache",
+    ".venv",
+    "__pycache__",
+    "data/cache",
+    "web",
+    "*.json",
+]
+
+[tool.ruff.lint]
+# Enable recommended rules
+select = [
+    "E",      # pycodestyle errors
+    "W",      # pycodestyle warnings
+    "F",      # Pyflakes
+    "I",      # isort
+    "B",      # flake8-bugbear
+    "C4",     # flake8-comprehensions
+    "UP",     # pyupgrade
+    "ARG",    # flake8-unused-arguments
+    "SIM",    # flake8-simplify
+    "TCH",    # flake8-type-checking
+    "PTH",    # flake8-use-pathlib
+]
+
+# Ignore specific rules
+ignore = [
+    "E501",   # Line too long (handled by formatter)
+    "B008",   # Do not perform function calls in argument defaults
+    "B905",   # zip without explicit strict parameter
+    "SIM108", # Use ternary operator (not always clearer)
+    "SIM117", # Multiple with statements (sometimes clearer separated)
+    "ARG001", # Unused function argument (needed for callbacks)
+    "ARG002", # Unused method argument
+    "PTH123", # open() should use Path.open()
+    # The rules below are style preferences this codebase deliberately does not
+    # follow. They are listed explicitly rather than suppressed at the command
+    # line, so that `ruff check` can fail on everything else.
+    "SIM102", # Nested ifs are often clearer than one compound condition here,
+              # since the branches carry separate explanatory comments.
+    "SIM105", # try/except/pass reads more plainly than contextlib.suppress.
+    "TC003",  # Moving stdlib imports into TYPE_CHECKING blocks is ceremony
+              # that costs more readability than the import time it saves.
+]
+
+# Allow autofix for all enabled rules
+fixable = ["ALL"]
+unfixable = []
+
+[tool.ruff.lint.per-file-ignores]
+# Tests can use assert and have unused variables
+"tests/**/*.py" = ["S101", "ARG", "PLR2004"]
+# Scripts may have unused imports for side effects
+"data/scripts/**/*.py" = ["F401"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["data"]
+force-single-line = false
+lines-after-imports = 2
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+docstring-code-format = true
+
+# ============================================================================
+# MyPy Configuration
+# Static type checker for Python
+# ============================================================================
+[tool.mypy]
+python_version = "3.12"
+warn_return_any = true
+warn_unused_configs = true
+ignore_missing_imports = true
+# Without this, mypy aborts with "Source file found twice under different module
+# names" because data/ is importable both as `data.x` and as bare `x`. It was
+# failing that way before it checked anything, so the CI job never type-checked.
+explicit_package_bases = true
+exclude = [
+    "data/cache/",
+    "web/",
+    "tests/",
+]
+
+# Ratchet list. These three modules carry 123 of the errors between them and are
+# exempt so the rest of the tree can be gated now rather than never. Remove an
+# entry once its module is clean; do not add to this list.
+[[tool.mypy.overrides]]
+module = [
+    "cve_v5_processor",
+    "cve_years",
+    "scoring_analysis",
+    "data.cve_v5_processor",
+    "data.cve_years",
+    "data.scoring_analysis",
+]
+ignore_errors = true
+
+# ============================================================================
+# Pytest Configuration
+# ============================================================================
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]
+python_classes = ["Test*"]
+addopts = [
+    "-v",
+    "--tb=short",
+    "-ra",  # Show extra test summary
+]
+filterwarnings = [
+    "ignore::DeprecationWarning",
+]
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+    "integration: marks tests as integration tests",
+]
+# Without this, pytest-asyncio leaves async tests unrecognised and they error
+# out on a clean checkout, which trains everyone to ignore a red suite.
+asyncio_mode = "auto"
+
+# ============================================================================
+# Coverage Configuration
+# ============================================================================
+[tool.coverage.run]
+branch = true
+source = ["."]
+omit = [
+    "tests/*",
+    "data/cache/*",
+    "web/*",
+    ".venv/*",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+]
+show_missing = true
 
-[tool.setuptools.packages.find]
-where = ["src"]
+# ============================================================================
+# Bandit Configuration (Security Scanner)
+# ============================================================================
+[tool.bandit]
+exclude_dirs = ["tests", "data/cache", "web", ".venv"]
+skips = ["B101", "B311"]  # Skip assert_used and random warnings
diff --git a/requirements.txt b/requirements.txt
index c89fff4ba10..588c6c6f54a 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -7,10 +7,15 @@ jinja2>=3.1.0
 
 # HTTP requests and data fetching (required for CVE data download)
 requests>=2.28.0
+httpx>=0.27.0  # Async HTTP client for parallel downloads
 
 # Date and time handling
 python-dateutil>=2.8.0
 
+# Performance optimizations (optional but recommended)
+orjson>=3.9.0  # 5x faster JSON parsing (Rust-based)
+# ijson>=3.2.0  # Streaming JSON for very large files (optional)
+
 # JSON handling (built-in, but explicit for clarity)
 # json - built-in
 
@@ -28,7 +33,22 @@ jsonschema>=4.17.0
 
 # For potential future database connections
 
-# Development and testing (optional)
+# CLI framework
+typer>=0.9.0
+rich>=13.0.0  # For rich terminal output with Typer
+
+# Development and testing
 pytest>=7.0.0
-black>=23.0.0
-flake8>=6.0.0
+pytest-asyncio>=0.21.0  # For async test support
+pytest-cov>=4.0.0  # For coverage reports
+
+# Code quality
+# Upper bounds matter here: ruff check and ruff format now gate CI, and both
+# tools change their rules between minor releases. Without a ceiling, a new
+# release turns main red with no change on our side. Raise these deliberately.
+mypy>=1.0.0,<3.0.0  # Type checking
+types-requests>=2.31.0  # Stubs so mypy can check requests call sites
+ruff>=0.16.0,<0.17.0  # Fast Python linter (replaces flake8, black, isort)
+
+# Pre-commit hooks
+pre-commit>=3.0.0
diff --git a/scripts/build.py b/scripts/build.py
deleted file mode 100644
index 06a57e7e679..00000000000
--- a/scripts/build.py
+++ /dev/null
@@ -1,382 +0,0 @@
-#!/usr/bin/env python3
-"""
-CVEDB Static Site Generator
-Fixed build system that works with existing code structure
-"""
-
-import argparse
-import json
-import os
-import shutil
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-# Add src to path
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(PROJECT_ROOT / 'src'))
-
-from jinja2 import Environment, FileSystemLoader, select_autoescape
-
-# Import from package
-try:
-    from cvedb.analysis.years import CVEYearsAnalyzer
-    from cvedb.analysis.cpe import CPEAnalyzer
-    from cvedb.analysis.cvss import CVSSAnalyzer
-    from cvedb.analysis.cwe import CWEAnalyzer
-    from cvedb.analysis.calendar import CalendarAnalyzer
-    from cvedb.analysis.yearly import YearlyAnalyzer
-    from cvedb.analysis.scoring import ScoringAnalyzer
-    from cvedb.cna.v5_processor import CVEV5Processor
-    from cvedb.cna.data_quality import main as generate_data_quality
-except ImportError as e:
-    print(f"❌ Critical Import Error: {e}")
-    print("Ensure you have run 'pip install -e .' or that src/ is in your PYTHONPATH.")
-    sys.exit(1)
-
-
-class CVESiteBuilder:
-    """Main class for building the CVEDB static site"""
-    
-    def __init__(self, quiet=False):
-        self.quiet = quiet or os.getenv('CVE_BUILD_QUIET', '').lower() in ('1', 'true', 'yes')
-        self.current_year = datetime.now().year
-        self.available_years = list(range(1999, self.current_year + 1))
-        
-        # Define paths based on new structure
-        self.base_dir = PROJECT_ROOT
-        self.templates_dir = self.base_dir / 'templates'
-        self.web_dir = self.base_dir / 'dist'  # Output directory
-        self.static_source_dir = self.base_dir / 'static'
-        
-        # Output paths in dist/
-        self.static_output_dir = self.web_dir / 'static' # Often dist/assets or dist/static
-        self.data_dir = self.web_dir / 'data'
-        
-        # Source data paths
-        self.source_data_dir = self.base_dir / 'data'
-        self.cache_dir = self.source_data_dir / 'raw'
-        
-        # Ensure raw directory exists for cache
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-        
-        # Set up Jinja2 environment
-        # We look in templates/ and templates/cna/ for convenience, but unified templates/ is enough if paths are relative
-        self.jinja_env = Environment(
-            loader=FileSystemLoader([str(self.templates_dir), str(self.templates_dir / 'cna')]),
-            autoescape=select_autoescape(['html', 'xml'])
-        )
-        
-        # Add custom filters and globals
-        self.jinja_env.globals['current_year'] = self.current_year
-        self.jinja_env.globals['available_years'] = self.available_years
-        self.jinja_env.filters['format_number'] = self.format_number
-        
-        if not self.quiet:
-            print(f"🚀 CVEDB Build System Initialized")
-            print(f"📅 Current Year: {self.current_year}")
-            print(f"📊 Coverage: 1999-{self.current_year} ({len(self.available_years)} years)")
-            print(f"🌐 Web output: {self.web_dir}")
-            print(f"📁 Source Data: {self.source_data_dir}")
-    
-    def print_verbose(self, message):
-        """Print message only if not in quiet mode"""
-        if not self.quiet:
-            print(message)
-    
-    def print_always(self, message):
-        """Print message regardless of quiet mode"""
-        print(message)
-    
-    def format_number(self, num):
-        """Format numbers for display (e.g., 1000 -> 1K)"""
-        if num >= 1000000:
-            return f"{num / 1000000:.1f}M"
-        elif num >= 1000:
-            return f"{num / 1000:.1f}K"
-        return str(num)
-    
-    def clean_build(self):
-        """Clean and recreate the web directory"""
-        self.print_verbose("🧹 Cleaning dist directory...")
-        
-        if self.web_dir.exists():
-            shutil.rmtree(self.web_dir)
-        
-        self.web_dir.mkdir(parents=True, exist_ok=True)
-        self.data_dir.mkdir(exist_ok=True)
-        
-        self.print_verbose("✅ Dist directory cleaned and recreated")
-    
-    def ensure_static_assets(self):
-        """Copy static assets from src/static to dist/static"""
-        self.print_verbose("📁 Copying static assets...")
-        
-        if self.static_source_dir.exists():
-            # Copy everything from static_source_dir to static_output_dir
-            # We want dist/static/css, dist/static/js, etc.
-            # OR dist/css, dist/js depending on preference.
-            # Old code expected `web/static/css`.
-            # So lets copy to self.static_output_dir (dist/static)
-            
-            # Use copytree
-            shutil.copytree(self.static_source_dir, self.static_output_dir, dirs_exist_ok=True)
-            self.print_verbose(f"  ✅ Copied static assets from {self.static_source_dir}")
-        else:
-            self.print_verbose(f"  ⚠️  Static source directory {self.static_source_dir} not found")
-
-        # Check for required files (sanity check)
-        required_files = ['css/style.css', 'js/chart.min.js'] 
-        # Note: filenames might have changed, this is legacy check
-        
-        self.print_verbose("✅ Static assets check complete")
-    
-    def generate_year_data_json(self, force=False):
-        """Generate JSON file for each year's data"""
-        self.print_always("📅 Generating yearly CVE data files...")
-        
-        try:
-            analyzer = CVEYearsAnalyzer(cache_dir=self.cache_dir, quiet=self.quiet)
-            
-            # Use mtime of the cached NVD data to determine if we need to rebuild
-            source_file = self.cache_dir / 'nvd.json'
-            source_mtime = source_file.stat().st_mtime if source_file.exists() else 0
-            
-            all_year_data = []
-            
-            # Separate years into those to process and those to skip
-            years_to_process = []
-            for year in self.available_years:
-                year_file = self.data_dir / f'cve_{year}.json'
-                if not force and year_file.exists() and year_file.stat().st_mtime > source_mtime:
-                    try:
-                        with open(year_file, 'r') as f:
-                            all_year_data.append(json.load(f))
-                        continue
-                    except (json.JSONDecodeError, IOError):
-                        pass
-                years_to_process.append(year)
-
-            if years_to_process:
-                self.print_verbose(f"  📝 Processing {len(years_to_process)} years in a single pass...")
-                # Process all missing years in one pass
-                processed_results = analyzer.process_years(years_to_process)
-                
-                for year in years_to_process:
-                    year_data = processed_results.get(year)
-                    if year_data:
-                        year_file = self.data_dir / f'cve_{year}.json'
-                        with open(year_file, 'w') as f:
-                            json.dump(year_data, f, indent=2, default=str)
-                        all_year_data.append(year_data)
-                    else:
-                        self.print_always(f"  ⚠️  No data found for year {year}")
-            else:
-                self.print_always("  ✅ All year data files are up to date.")
-            
-            # Sort all_year_data by year to ensure consistency
-            all_year_data.sort(key=lambda x: x.get('year', 0))
-            
-            self.print_always(f"✅ Prepared {len(all_year_data)} year data objects")
-            return all_year_data
-            
-        except Exception as e:
-            self.print_always(f"❌ Error generating year data: {e}")
-            self.print_verbose("📝 Creating minimal data as fallback...")
-            return self.create_minimal_year_data()
-    
-    def create_minimal_year_data(self):
-        """Create minimal year data for basic functionality"""
-        self.print_verbose("📝 Creating minimal year data...")
-        all_year_data = []
-        for year in self.available_years:
-            year_data = {'year': year, 'total_cves': 0, 'date_data': {}}
-            year_file = self.data_dir / f'cve_{year}.json'
-            with open(year_file, 'w') as f:
-                json.dump(year_data, f, indent=2)
-            all_year_data.append(year_data)
-        return all_year_data
-
-    def generate_combined_analysis_json(self, all_year_data):
-        print("📊 Generating combined analysis JSON files...")
-        
-        # CVE V5 Analysis
-        try:
-            if not self.quiet: print("  🏢 Generating CVE V5 CNA analysis...")
-            # CVEV5Processor(base_dir, cache_dir, data_dir, quiet, force)
-            v5_processor = CVEV5Processor(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet, force=self.force)
-            v5_processor.generate_comprehensive_cna_analysis()
-            v5_processor.generate_current_year_analysis()
-        except Exception as e:
-            print(f"  ❌ Error generating CVE V5 analysis: {e}")
-
-        # CPE Analysis
-        try:
-            if not self.quiet: print("  🔍 Generating CPE analysis...")
-            cpe_analyzer = CPEAnalyzer(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet)
-            cpe_analyzer.generate_cpe_analysis(all_year_data)
-            
-            current_year_data = next((d for d in all_year_data if d.get('year') == datetime.now().year), {})
-            cpe_analyzer.generate_current_year_cpe_analysis(current_year_data)
-        except Exception as e:
-            print(f"  ❌ Error generating CPE analysis: {e}")
-
-        # CVSS Analysis
-        try:
-            if not self.quiet: print("  📊 Generating CVSS analysis...")
-            cvss_analyzer = CVSSAnalyzer(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet)
-            cvss_analyzer.generate_cvss_analysis(all_year_data)
-            current_year_data = next((d for d in all_year_data if d.get('year') == self.current_year), None)
-            if current_year_data:
-                cvss_analyzer.generate_current_year_cvss_analysis(current_year_data)
-        except Exception as e:
-            print(f"  ❌ Error generating CVSS analysis: {e}")
-
-        # CWE Analysis
-        try:
-            if not self.quiet: print("  🔍 Generating CWE analysis...")
-            cwe_analyzer = CWEAnalyzer(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet)
-            cwe_analyzer.generate_cwe_analysis(all_year_data)
-            current_year_data = next((d for d in all_year_data if d.get('year') == self.current_year), None)
-            if current_year_data:
-                cwe_analyzer.generate_current_year_cwe_analysis(current_year_data)
-        except Exception as e:
-            print(f"  ❌ Error generating CWE analysis: {e}")
-
-        # Calendar Analysis
-        try:
-            if not self.quiet: print("  📅 Generating calendar analysis...")
-            calendar_analyzer = CalendarAnalyzer(self.base_dir, self.cache_dir, self.data_dir, quiet=self.quiet)
-            calendar_analyzer.generate_calendar_analysis()
-            calendar_analyzer.generate_current_year_calendar_analysis()
-        except Exception as e:
-            print(f"  ❌ Error generating calendar analysis: {e}")
-
-        # Growth Analysis
-        try:
-            print("  📈 Generating growth analysis...")
-            yearly_analyzer = YearlyAnalyzer(self.base_dir, self.cache_dir, self.data_dir)
-            yearly_analyzer.generate_growth_analysis(all_year_data)
-        except Exception as e:
-            print(f"  ❌ Error generating growth analysis: {e}")
-
-        # Scoring Analysis
-        try:
-            print("  🎯 Generating scoring analysis...")
-            scoring_analyzer = ScoringAnalyzer(self.base_dir, self.cache_dir, self.data_dir)
-            scoring_analyzer.generate_all_scoring_analysis()
-        except Exception as e:
-            print(f"  ❌ Error generating scoring analysis: {e}")
-
-        # cve_all.json
-        self.generate_cve_all_json(all_year_data)
-        
-        return {'status': 'completed'}
-
-    def generate_cve_all_json(self, all_year_data):
-        """Generate overall CVE statistics"""
-        print("  📊 Generating cve_all.json...")
-        if not all_year_data: return
-        
-        total_cves = sum(y.get('total_cves', 0) for y in all_year_data)
-        
-        cve_all_data = {
-            'generated_at': datetime.now(timezone.utc).isoformat(),
-            'total_cves': total_cves,
-            'current_year': self.current_year
-            # ... abbreviated for brevity, but should include minimal fields
-        }
-        
-        with open(self.data_dir / 'cve_all.json', 'w') as f:
-            json.dump(cve_all_data, f, indent=2)
-            
-        self.generate_yearly_summary_json(all_year_data)
-
-    def generate_yearly_summary_json(self, all_year_data):
-        print("  📊 Generating yearly_summary.json...")
-        if not all_year_data: return
-        
-        summary = {'years': {}}
-        for year_data in all_year_data:
-            y = year_data.get('year')
-            if y: summary['years'][y] = year_data
-            
-        with open(self.data_dir / 'yearly_summary.json', 'w') as f:
-            json.dump(summary, f)
-
-    def generate_data_quality_json(self):
-        """Generate data quality analysis"""
-        print("🔍 Generating data quality analysis...")
-        try:
-            generate_data_quality()
-            print("  ✅ Data quality analysis generated")
-        except Exception as e:
-            print(f"  ⚠️  Error generating data quality: {e}")
-
-    def generate_html_pages(self):
-        """Generate HTML pages from templates"""
-        self.print_verbose("📄 Generating HTML pages...")
-        
-        # Standard pages
-        pages = [
-            {'template': 'index.html', 'output': 'index.html', 'title': 'CVE Intelligence Dashboard'},
-            {'template': 'years.html', 'output': 'years.html', 'title': 'Yearly Analysis'},
-            # CNA pages (now in templates/cna/)
-            # If template name is 'cna/cna.html', output 'cna.html'? 
-            # Or if templates are flat in loader...
-            # We added 'templates/cna' to loader, so 'cna.html' resolves if in templates/cna/cna.html
-            {'template': 'cna-hub.html', 'output': 'cna-hub.html', 'title': 'CNA Hub'}, 
-            {'template': 'cna.html', 'output': 'cna.html', 'title': 'CNA Dashboard'},
-            {'template': 'cpe.html', 'output': 'cpe.html', 'title': 'CPE Analysis'},
-            {'template': 'cvss.html', 'output': 'cvss.html', 'title': 'CVSS Analysis'},
-            {'template': 'cwe.html', 'output': 'cwe.html', 'title': 'CWE Analysis'},
-            {'template': 'calendar.html', 'output': 'calendar.html', 'title': 'Calendar'},
-            {'template': 'growth.html', 'output': 'growth.html', 'title': 'Growth'},
-            {'template': 'scoring.html', 'output': 'scoring.html', 'title': 'Scoring'},
-            {'template': 'epss.html', 'output': 'epss.html', 'title': 'EPSS'},
-            {'template': 'kev.html', 'output': 'kev.html', 'title': 'KEV'},
-            {'template': 'data-quality.html', 'output': 'data-quality.html', 'title': 'Data Quality'},
-            {'template': 'about.html', 'output': 'about.html', 'title': 'About'}
-        ]
-        
-        for page in pages:
-            try:
-                template = self.jinja_env.get_template(page['template'])
-                context = {
-                    'title': f"{page['title']} - CVEDB",
-                    'current_year': self.current_year,
-                    'available_years': self.available_years
-                }
-                html_content = template.render(**context)
-                with open(self.web_dir / page['output'], 'w') as f:
-                    f.write(html_content)
-                self.print_verbose(f"  📄 Generated {page['output']}")
-            except Exception as e:
-                self.print_always(f"  ❌ Error generating {page['output']}: {e}")
-
-    def build_site(self, force=False, clean=True):
-        self.force = force
-        if clean:
-            self.clean_build()
-        self.ensure_static_assets()
-        all_year_data = self.generate_year_data_json(force=force)
-        if not all_year_data: return False
-        self.generate_combined_analysis_json(all_year_data)
-        self.generate_data_quality_json()
-        self.generate_html_pages()
-        self.print_always(f"✅ Build completed! Output: {self.web_dir}")
-        return True
-
-def main():
-    parser = argparse.ArgumentParser(description='CVEDB Generator')
-    parser.add_argument('--quiet', '-q', action='store_true', help='Quiet mode')
-    parser.add_argument('--force', '-f', action='store_true', help='Force rebuild all files')
-    parser.add_argument('--no-clean', action='store_false', dest='clean', help='Do not clean dist directory before build')
-    parser.set_defaults(clean=True)
-    args = parser.parse_args()
-    
-    builder = CVESiteBuilder(quiet=args.quiet)
-    builder.build_site(force=args.force, clean=args.clean)
-
-if __name__ == '__main__':
-    main()
diff --git a/scripts/cna_mapping_restart.py b/scripts/cna_mapping_restart.py
deleted file mode 100644
index c2c769eedf2..00000000000
--- a/scripts/cna_mapping_restart.py
+++ /dev/null
@@ -1,225 +0,0 @@
-#!/usr/bin/env python3
-"""
-CNA Mapping Restart Script
-Maps every CVE to either an official or unofficial CNA using:
-1. UUID/official CNA mapping (cna_name_map.json)
-2. Reporting email/domain mapping (cna_list.json contact emails)
-3. Fallback to edge-case/unknown (creates 'Unofficial CNA' if needed)
-
-Refactored to use the new project structure.
-"""
-
-import json
-import re
-import sys
-from pathlib import Path
-from collections import defaultdict
-
-# Add src to path
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(PROJECT_ROOT / 'src'))
-
-def normalize_name(name):
-    """Normalize CNA names for fuzzy matching"""
-    if not name:
-        return ''
-    return (
-        name.lower()
-        .replace(',', '')
-        .replace('.', '')
-        .replace('incorporated', 'inc')
-        .replace('corporation', 'corp')
-        .replace('limited', 'ltd')
-        .replace('llc', '')
-        .replace('inc', '')
-        .replace('corp', '')
-        .replace('ltd', '')
-        .replace('the ', '')
-        .replace('&', 'and')
-        .replace('  ', ' ')
-        .strip()
-    )
-
-def extract_designation_year(cna_id):
-    """Extract designation year from CNA ID (e.g., CNA-2005-0001)"""
-    match = re.match(r"CNA-(\d{4})-", cna_id or "")
-    return int(match.group(1)) if match else None
-
-def main():
-    cache_dir = PROJECT_ROOT / 'data' / 'raw'
-    data_output_dir = PROJECT_ROOT / 'dist' / 'data'
-    
-    nvd_file = cache_dir / 'nvd.json'
-    if not nvd_file.exists():
-        print(f"❌ Error: {nvd_file} not found. Run full build first.")
-        return 1
-        
-    print("🔄 Restarting CNA mapping...")
-    
-    # Load support files
-    try:
-        with open(cache_dir / 'cna_name_map.json', 'r') as f:
-            uuid_map = json.load(f)
-        with open(cache_dir / 'cna_list.json', 'r') as f:
-            cna_list_raw = json.load(f)
-            cna_list = cna_list_raw['data'] if isinstance(cna_list_raw, dict) and 'data' in cna_list_raw else cna_list_raw
-    except FileNotFoundError as e:
-        print(f"❌ Error: Required support file missing: {e}")
-        return 1
-
-    # Build official CNA lookup by UUID and normalized name
-    uuid_to_name = {uuid: name for uuid, name in uuid_map.items()}
-    official_names = {normalize_name(name): uuid for uuid, name in uuid_map.items()}
-    
-    # Build contact email and domain lookup from cna_list.json
-    email_to_cna = {}
-    domain_to_cna = {}
-    cnaid_to_year = {}
-    
-    for cna in cna_list:
-        org_name = cna.get('organizationName', '')
-        cna_id = cna.get('cnaID', '')
-        if cna_id:
-            cnaid_to_year[org_name] = extract_designation_year(cna_id)
-        
-        # Contact emails
-        for contact in cna.get('contact', []):
-            for email in contact.get('email', []):
-                email_addr = email.get('emailAddr', '').lower()
-                if email_addr:
-                    email_to_cna[email_addr] = org_name
-                    domain = email_addr.split('@')[-1]
-                    if domain:
-                        domain_to_cna[domain] = org_name
-
-    # Main mapping pass
-    print("📊 Processing NVD data...")
-    cna_stats = defaultdict(lambda: {
-        'count': 0, 
-        'first_cve_year': None, 
-        'last_cve_year': None, 
-        'designation_year': None, 
-        'official': False, 
-        'source': set()
-    })
-    
-    with open(nvd_file, 'r') as f:
-        # Check if it's a JSON array or line-delimited
-        content = f.read(1)
-        f.seek(0)
-        if content == '[':
-            cve_data = json.load(f)
-        else:
-            cve_data = [json.loads(line) for line in f if line.strip()]
-
-    for cve_entry in cve_data:
-        cve = cve_entry.get('cve', {}) if 'cve' in cve_entry else cve_entry
-        
-        # 1. Try UUID/official CNA mapping
-        source_id = cve.get('sourceIdentifier', '')
-        cna_name = uuid_to_name.get(source_id, '')
-        
-        if cna_name:
-            mapped_name = cna_name
-            official = True
-            designation_year = cnaid_to_year.get(cna_name)
-            source = 'uuid'
-        else:
-            # 2. Try reporting email(s)
-            emails = set()
-            assigner = cve.get('assigner', '')
-            if assigner and '@' in assigner:
-                emails.add(assigner.lower())
-                
-            for ref in cve.get('references', []):
-                url = ref.get('url', '')
-                if '@' in url:
-                    emails.add(url.lower())
-            
-            mapped_name = ''
-            official = False
-            designation_year = None
-            source = ''
-            
-            for email in emails:
-                if email in email_to_cna:
-                    mapped_name = email_to_cna[email]
-                    official = normalize_name(mapped_name) in official_names
-                    designation_year = cnaid_to_year.get(mapped_name)
-                    source = 'email'
-                    break
-                
-                domain = email.split('@')[-1]
-                if domain in domain_to_cna:
-                    mapped_name = domain_to_cna[domain]
-                    official = normalize_name(mapped_name) in official_names
-                    designation_year = cnaid_to_year.get(mapped_name)
-                    source = 'domain'
-                    break
-            
-            # 3. Fallback: fuzzy match on assigner
-            if not mapped_name and assigner:
-                normalized = normalize_name(assigner)
-                if normalized in official_names:
-                    mapped_name = uuid_to_name[official_names[normalized]]
-                    official = True
-                    designation_year = cnaid_to_year.get(mapped_name)
-                    source = 'fuzzy-assigner'
-            
-            # 4. Edge: fallback to email
-            if not mapped_name and emails:
-                mapped_name = sorted(emails)[0]
-                official = False
-                source = 'unofficial-email'
-                
-            if not mapped_name:
-                mapped_name = 'Unknown CNA'
-                official = False
-                source = 'unknown'
-
-        # Update stats
-        cna_stats[mapped_name]['count'] += 1
-        pub_date = cve.get('published', '')
-        year = int(pub_date[:4]) if pub_date and pub_date[:4].isdigit() else None
-        
-        if year:
-            if not cna_stats[mapped_name]['first_cve_year'] or year < cna_stats[mapped_name]['first_cve_year']:
-                cna_stats[mapped_name]['first_cve_year'] = year
-            if not cna_stats[mapped_name]['last_cve_year'] or year > cna_stats[mapped_name]['last_cve_year']:
-                cna_stats[mapped_name]['last_cve_year'] = year
-        
-        if designation_year:
-            cna_stats[mapped_name]['designation_year'] = designation_year
-        cna_stats[mapped_name]['official'] = official
-        cna_stats[mapped_name]['source'].add(source)
-
-    # Output summary
-    summary = []
-    current_year = 2026 # As per local time
-    for name, stats in cna_stats.items():
-        years_active = None
-        if stats['designation_year']:
-            years_active = current_year - stats['designation_year']
-        
-        summary.append({
-            'name': name,
-            'count': stats['count'],
-            'official': stats['official'],
-            'years_active': years_active,
-            'first_cve_year': stats['first_cve_year'],
-            'last_cve_year': stats['last_cve_year'],
-            'sources': sorted(list(stats['source'])),
-        })
-    
-    summary.sort(key=lambda x: x['count'], reverse=True)
-    
-    output_file = data_output_dir / 'cna_analysis_restart.json'
-    with open(output_file, 'w') as f:
-        json.dump(summary, f, indent=2)
-        
-    print(f"✅ CNA mapping complete. {len(summary)} CNAs found.")
-    print(f"📁 Output: {output_file}")
-    return 0
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/scripts/generate_cna_analysis.py b/scripts/generate_cna_analysis.py
deleted file mode 100644
index 0a769d7414c..00000000000
--- a/scripts/generate_cna_analysis.py
+++ /dev/null
@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-"""
-Comprehensive CNA Analysis Generator (Wrapper)
-Migrated to use the cvedb package.
-"""
-
-import sys
-from pathlib import Path
-
-# Add src to path
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(PROJECT_ROOT / 'src'))
-
-try:
-    from cvedb.cna.v5_processor import CVEV5Processor
-except ImportError:
-    print("❌ Error: Could not import cvedb.cna.v5_processor")
-    sys.exit(1)
-
-def main():
-    """Main entry point"""
-    cache_dir = PROJECT_ROOT / 'data' / 'raw'
-    data_output_dir = PROJECT_ROOT / 'dist' / 'data'
-    
-    # Ensure output exists
-    data_output_dir.mkdir(parents=True, exist_ok=True)
-    
-    print("🏢 Generating comprehensive CNA analysis...")
-    v5_processor = CVEV5Processor(PROJECT_ROOT, cache_dir, data_output_dir)
-    
-    try:
-        # This generates both comprehensive and current year analysis
-        v5_processor.generate_comprehensive_cna_analysis()
-        v5_processor.generate_current_year_analysis()
-        print("✅ CNA analysis complete.")
-        return 0
-    except Exception as e:
-        print(f"❌ Error during CNA analysis: {e}")
-        return 1
-
-if __name__ == '__main__':
-    sys.exit(main())
diff --git a/scripts/quick_build.py b/scripts/quick_build.py
deleted file mode 100644
index 8457dcf11df..00000000000
--- a/scripts/quick_build.py
+++ /dev/null
@@ -1,133 +0,0 @@
-#!/usr/bin/env python3
-"""
-CVEDB Quick Template Builder
-Fast template-only rebuild for development - skips data processing
-"""
-
-import shutil
-from datetime import datetime
-from pathlib import Path
-from jinja2 import Environment, FileSystemLoader, select_autoescape
-
-class CVEQuickBuilder:
-    """Fast template-only builder for development"""
-    
-    def __init__(self):
-        self.current_year = datetime.now().year
-        self.available_years = list(range(1999, self.current_year + 1))
-        # scripts/quick_build.py -> parent is scripts/ -> parent is project root
-        self.project_root = Path(__file__).parent.parent.resolve()
-        self.templates_dir = self.project_root / 'templates'
-        self.web_dir = self.project_root / 'dist'
-        self.static_source_dir = self.project_root / 'static'
-        self.static_output_dir = self.web_dir / 'static'
-        
-        # Set up Jinja2 environment
-        # Include templates/ and templates/cna for resolution
-        self.jinja_env = Environment(
-            loader=FileSystemLoader([str(self.templates_dir), str(self.templates_dir / 'cna')]),
-            autoescape=select_autoescape(['html', 'xml'])
-        )
-        
-        # Add custom filters and globals
-        self.jinja_env.globals['current_year'] = self.current_year
-        self.jinja_env.globals['available_years'] = self.available_years
-        self.jinja_env.filters['format_number'] = self.format_number
-        
-        print(f"⚡ CVEDB Quick Template Builder")
-        print(f"📅 Current Year: {self.current_year}")
-        print(f"📂 Templates: {self.templates_dir}")
-        print(f"🌐 Web output: {self.web_dir}")
-    
-    def format_number(self, num):
-        """Format numbers with commas"""
-        if isinstance(num, (int, float)):
-            return f"{num:,}"
-        return str(num)
-    
-    def copy_static_assets(self):
-        """Copy static assets (CSS, JS, images) from static/ to dist/static/"""
-        print("📁 Synchronizing static assets...")
-        
-        if self.static_source_dir.exists():
-            # Ensure static output dir exists
-            self.static_output_dir.mkdir(parents=True, exist_ok=True)
-            # Copy everything from static_source_dir to static_output_dir
-            shutil.copytree(self.static_source_dir, self.static_output_dir, dirs_exist_ok=True)
-            print(f"  ✅ Static assets copied to {self.static_output_dir}")
-        else:
-            print(f"  ⚠️  No static source assets found at {self.static_source_dir}")
-    
-    def generate_html_pages(self):
-        """Generate HTML pages from templates"""
-        print("📄 Generating HTML pages...")
-        
-        # Define pages to generate
-        pages = [
-            ('index.html', 'CVEDB - Vulnerability Intelligence Platform'),
-            ('years.html', 'Yearly Analysis - CVEDB'),
-            ('cna-hub.html', 'CNA Intelligence Hub - CVEDB'),
-            ('cna.html', 'CNA Analysis - CVEDB'),
-            ('cpe.html', 'CPE Analysis - CVEDB'),
-            ('cvss.html', 'CVSS Analysis - CVEDB'),
-            ('cwe.html', 'CWE Analysis - CVEDB'),
-            ('calendar.html', 'Calendar View - CVEDB'),
-            ('growth.html', 'Growth Trends - CVEDB'),
-            ('about.html', 'About CVEDB'),
-            ('scoring.html', 'Scoring Hub - CVEDB'),
-            ('epss.html', 'EPSS Analysis - CVEDB'),
-            ('kev.html', 'KEV Dashboard - CVEDB'),
-            ('data-quality.html', 'CNA Name Matching - CVEDB'),
-        ]
-        
-        for template_name, title in pages:
-            try:
-                template = self.jinja_env.get_template(template_name)
-                
-                context = {
-                    'title': title,
-                    'current_year': self.current_year,
-                    'available_years': self.available_years,
-                }
-                
-                html_content = template.render(**context)
-                
-                output_path = self.web_dir / template_name
-                with open(output_path, 'w', encoding='utf-8') as f:
-                    f.write(html_content)
-                
-                print(f"  📄 Generated {template_name}")
-                
-            except Exception as e:
-                print(f"  ❌ Error generating {template_name}: {e}")
-                continue
-        
-        print("✅ HTML pages generated successfully")
-    
-    def build(self):
-        """Main build method - templates only"""
-        print("\n🏗️  Starting quick template build...")
-        print("=" * 50)
-        
-        # Ensure web directory exists
-        self.web_dir.mkdir(parents=True, exist_ok=True)
-        (self.web_dir / 'data').mkdir(exist_ok=True)
-        
-        # Copy static assets
-        self.copy_static_assets()
-        
-        # Generate HTML pages
-        self.generate_html_pages()
-        
-        print("\n" + "=" * 50)
-        print("✅ Quick build completed!")
-        print(f"📁 Site ready in: {self.web_dir}")
-        print("⚡ Data files remain unchanged or missing (use full build for data)")
-
-def main():
-    """Main entry point"""
-    builder = CVEQuickBuilder()
-    builder.build()
-
-if __name__ == "__main__":
-    main()
diff --git a/scripts/rebuild_cna.py b/scripts/rebuild_cna.py
deleted file mode 100755
index 66044bfa26e..00000000000
--- a/scripts/rebuild_cna.py
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-"""
-CNA Analysis Rebuild Script
-Quick rebuild script for CNA analysis only - much faster than full site rebuild
-"""
-
-import sys
-import os
-from pathlib import Path
-
-# Add src to path if not installed
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(PROJECT_ROOT / 'src'))
-
-try:
-    from cvedb.cna.v5_processor import CVEV5Processor
-except ImportError:
-    print("❌ Error: Could not import cvedb.cna.v5_processor")
-    print("Please run 'make install' or ensuring src/ is in PYTHONPATH")
-    sys.exit(1)
-
-def main():
-    """Rebuild CNA analysis only"""
-    print("🏢 CNA Analysis Quick Rebuild")
-    print("=" * 40)
-    
-    # Set up paths
-    cache_dir = PROJECT_ROOT / 'data' / 'raw'
-    data_output_dir = PROJECT_ROOT / 'dist' / 'data'
-    
-    # Ensure output exists
-    data_output_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Initialize CVE V5 processor
-    v5_processor = CVEV5Processor(PROJECT_ROOT, cache_dir, data_output_dir)
-    
-    try:
-        # Generate comprehensive CNA analysis using CVE V5 data
-        print("\n🔄 Generating comprehensive CNA analysis (CVE V5 authoritative)...")
-        cna_analysis = v5_processor.generate_comprehensive_cna_analysis()
-        
-        # Generate current year CNA analysis
-        print(f"\n🗓️  Generating current year CNA analysis...")
-        current_cna_analysis = v5_processor.generate_current_year_analysis()
-        
-        print("\n" + "=" * 40)
-        print("✅ CNA analysis rebuild completed!")
-        print(f"📁 Files updated in: {data_output_dir}")
-        return True
-        
-    except Exception as e:
-        print(f"\n❌ CNA analysis rebuild failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == '__main__':
-    success = main()
-    sys.exit(0 if success else 1)
diff --git a/scripts/rebuild_cpe.py b/scripts/rebuild_cpe.py
deleted file mode 100644
index d5ee4aaeda1..00000000000
--- a/scripts/rebuild_cpe.py
+++ /dev/null
@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-"""
-CPE Analysis Rebuild Script
-Quick rebuild script for CPE analysis only - much faster than full site rebuild
-"""
-
-import sys
-import json
-from datetime import datetime
-from pathlib import Path
-
-# Add src to path if not installed
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(PROJECT_ROOT / 'src'))
-
-try:
-    from cvedb.analysis.cpe import CPEAnalyzer
-except ImportError:
-    print("❌ Error: Could not import cvedb.analysis.cpe")
-    sys.exit(1)
-
-def load_all_year_data(data_dir):
-    """Load existing year data files"""
-    all_year_data = []
-    for year_file in sorted(data_dir.glob('cve_*.json')):
-        try:
-            with open(year_file, 'r') as f:
-                all_year_data.append(json.load(f))
-        except Exception:
-            continue
-    return all_year_data
-
-def main():
-    """Main rebuild function"""
-    print("🔍 CPE Analysis Quick Rebuild")
-    print("=" * 40)
-    
-    # Setup paths
-    cache_dir = PROJECT_ROOT / 'data' / 'raw'
-    data_dir = PROJECT_ROOT / 'dist' / 'data'
-    
-    # Initialize CPE analyzer
-    print("📊 Initializing CPE analyzer...")
-    cpe_analyzer = CPEAnalyzer(PROJECT_ROOT, cache_dir, data_dir)
-    
-    # Load existing year data for context (if available)
-    print("📂 Loading existing year data...")
-    all_year_data = load_all_year_data(data_dir)
-    
-    # Generate comprehensive CPE analysis
-    print("\n🔍 Generating comprehensive CPE analysis...")
-    try:
-        cpe_analyzer.generate_cpe_analysis(all_year_data)
-        print("  ✅ Comprehensive CPE analysis generated")
-    except Exception as e:
-        print(f"  ❌ Error generating comprehensive CPE analysis: {e}")
-        return 1
-    
-    # Generate current year CPE analysis
-    print("\n📅 Generating current year CPE analysis...")
-    try:
-        current_year = datetime.now().year
-        current_year_data = next((data for data in all_year_data if str(data.get('year')) == str(current_year)), {})
-        cpe_analyzer.generate_current_year_cpe_analysis(current_year_data)
-        print("  ✅ Current year CPE analysis generated")
-    except Exception as e:
-        print(f"  ❌ Error generating current year CPE analysis: {e}")
-    
-    print("\n" + "=" * 40)
-    print("🎉 CPE Analysis Rebuild Complete!")
-    print(f"📁 Files updated in: {data_dir}")
-    return 0
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/scripts/rebuild_cvss.py b/scripts/rebuild_cvss.py
deleted file mode 100755
index 5f49a40305b..00000000000
--- a/scripts/rebuild_cvss.py
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/usr/bin/env python3
-"""
-CVSS Analysis Rebuild Script
-Quick rebuild script for CVSS analysis only - much faster than full site rebuild
-"""
-
-import sys
-import json
-from datetime import datetime
-from pathlib import Path
-
-# Add src to path if not installed
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(PROJECT_ROOT / 'src'))
-
-try:
-    from cvedb.analysis.cvss import CVSSAnalyzer
-except ImportError:
-    print("❌ Error: Could not import cvedb.analysis.cvss")
-    sys.exit(1)
-
-def load_all_year_data(data_dir):
-    """Load existing year data files"""
-    all_year_data = []
-    for year_file in sorted(data_dir.glob('cve_*.json')):
-        try:
-            with open(year_file, 'r') as f:
-                all_year_data.append(json.load(f))
-        except Exception:
-            continue
-    return all_year_data
-
-def main():
-    """Rebuild CVSS analysis only"""
-    print("📊 CVSS Analysis Quick Rebuild")
-    print("=" * 40)
-    
-    # Set up paths
-    cache_dir = PROJECT_ROOT / 'data' / 'raw'
-    data_dir = PROJECT_ROOT / 'dist' / 'data'
-    
-    # Initialize CVSS analyzer
-    cvss_analyzer = CVSSAnalyzer(PROJECT_ROOT, cache_dir, data_dir)
-    
-    try:
-        # Load existing year data
-        print("📂 Loading existing year data...")
-        all_year_data = load_all_year_data(data_dir)
-        print(f"✅ Loaded {len(all_year_data)} year data files")
-        
-        if not all_year_data:
-            print("⚠️ No year data found in dist/data. Use full build first if needed.")
-            # We don't exit 1 here, maybe they want to build from scratch
-        
-        # Generate comprehensive CVSS analysis
-        print("\n🔄 Generating comprehensive CVSS analysis...")
-        cvss_analyzer.generate_cvss_analysis(all_year_data)
-        
-        # Generate current year CVSS analysis
-        current_year = datetime.now().year
-        current_year_data = next((year for year in all_year_data if str(year.get('year')) == str(current_year)), {})
-        
-        if current_year_data:
-            print(f"\n🗓️  Generating {current_year} CVSS analysis...")
-            cvss_analyzer.generate_current_year_cvss_analysis(current_year_data)
-        
-        print("\n" + "=" * 40)
-        print("✅ CVSS analysis rebuild completed!")
-        print(f"📁 Files updated in: {data_dir}")
-        return True
-        
-    except Exception as e:
-        print(f"\n❌ CVSS analysis rebuild failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == '__main__':
-    success = main()
-    sys.exit(0 if success else 1)
diff --git a/scripts/rebuild_cwe.py b/scripts/rebuild_cwe.py
deleted file mode 100755
index 7fca48fdc31..00000000000
--- a/scripts/rebuild_cwe.py
+++ /dev/null
@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-"""
-CWE Analysis Rebuild Script
-Quick rebuild script for CWE analysis only - much faster than full site rebuild
-"""
-
-import sys
-import json
-from datetime import datetime
-from pathlib import Path
-
-# Add src to path if not installed
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(PROJECT_ROOT / 'src'))
-
-try:
-    from cvedb.analysis.cwe import CWEAnalyzer
-except ImportError:
-    print("❌ Error: Could not import cvedb.analysis.cwe")
-    sys.exit(1)
-
-def load_all_year_data(data_dir):
-    """Load existing year data files"""
-    all_year_data = []
-    for year_file in sorted(data_dir.glob('cve_*.json')):
-        try:
-            with open(year_file, 'r') as f:
-                all_year_data.append(json.load(f))
-        except Exception:
-            continue
-    return all_year_data
-
-def main():
-    """Rebuild CWE analysis only"""
-    print("🔍 CWE Analysis Quick Rebuild")
-    print("=" * 40)
-    
-    # Set up paths
-    cache_dir = PROJECT_ROOT / 'data' / 'raw'
-    data_dir = PROJECT_ROOT / 'dist' / 'data'
-    
-    # Initialize CWE analyzer
-    cwe_analyzer = CWEAnalyzer(PROJECT_ROOT, cache_dir, data_dir)
-    
-    try:
-        # Load existing year data
-        print("📂 Loading existing year data...")
-        all_year_data = load_all_year_data(data_dir)
-        print(f"✅ Loaded {len(all_year_data)} year data files")
-        
-        if not all_year_data:
-            print("⚠️ No year data found in dist/data.")
-        
-        # Generate comprehensive CWE analysis
-        print("\n🔄 Generating comprehensive CWE analysis...")
-        cwe_analyzer.generate_cwe_analysis(all_year_data)
-        
-        # Generate current year CWE analysis
-        current_year = datetime.now().year
-        current_year_data = next((year for year in all_year_data if str(year.get('year')) == str(current_year)), {})
-        
-        if current_year_data:
-            print(f"\n🗓️  Generating {current_year} CWE analysis...")
-            cwe_analyzer.generate_current_year_cwe_analysis(current_year_data)
-        
-        print("\n" + "=" * 40)
-        print("✅ CWE analysis rebuild completed!")
-        print(f"📁 Files updated in: {data_dir}")
-        return True
-        
-    except Exception as e:
-        print(f"\n❌ CWE analysis rebuild failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == '__main__':
-    success = main()
-    sys.exit(0 if success else 1)
diff --git a/scripts/rebuild_growth.py b/scripts/rebuild_growth.py
deleted file mode 100644
index cb3f8625080..00000000000
--- a/scripts/rebuild_growth.py
+++ /dev/null
@@ -1,63 +0,0 @@
-#!/usr/bin/env python3
-"""
-Growth Analysis Rebuild Script
-Standalone script to rebuild growth analysis data and regenerate the Growth Intelligence Dashboard
-"""
-
-import json
-import sys
-from pathlib import Path
-
-# Add src to path if not installed
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-sys.path.insert(0, str(PROJECT_ROOT / 'src'))
-
-try:
-    from cvedb.analysis.yearly import YearlyAnalyzer
-except ImportError:
-    print("❌ Error: Could not import cvedb.analysis.yearly")
-    sys.exit(1)
-
-def main():
-    """Main function to rebuild growth analysis"""
-    print("🚀 Growth Analysis Rebuild")
-    print("=" * 40)
-    
-    # Initialize paths
-    cache_dir = PROJECT_ROOT / 'data' / 'raw'
-    data_output_dir = PROJECT_ROOT / 'dist' / 'data'
-    
-    # Ensure output exists
-    data_output_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Initialize analyzer
-    print("\n🔧 Initializing Yearly Analyzer...")
-    analyzer = YearlyAnalyzer(cache_dir=cache_dir)
-    
-    # Generate year data first (required for growth analysis)
-    print("\n📅 Generating year data...")
-    all_year_data = analyzer.generate_year_data_json(data_output_dir)
-    
-    if not all_year_data:
-        print("❌ No year data available for growth analysis")
-        return False
-        
-    print(f"✅ Generated data for {len(all_year_data)} years")
-    
-    # Generate comprehensive growth analysis
-    print("\n📈 Generating comprehensive growth analysis...")
-    growth_analysis = analyzer.generate_growth_analysis(all_year_data, data_output_dir)
-    
-    if growth_analysis:
-        print("✅ Comprehensive growth analysis generated successfully")
-    else:
-        print("❌ Failed to generate comprehensive growth analysis")
-        return False
-        
-    print("\n🎉 Growth analysis rebuild completed successfullly!")
-    print(f"📁 Files updated in: {data_output_dir}")
-    return True
-
-if __name__ == '__main__':
-    success = main()
-    sys.exit(0 if success else 1)
diff --git a/scripts/rebuild_templates.py b/scripts/rebuild_templates.py
deleted file mode 100644
index 5e710403659..00000000000
--- a/scripts/rebuild_templates.py
+++ /dev/null
@@ -1,26 +0,0 @@
-#!/usr/bin/env python3
-"""
-Quick template rebuild script - regenerates HTML pages without reprocessing data
-Refactored to use quick_build.py logic
-"""
-
-import sys
-from pathlib import Path
-
-# Add scripts to path to import CVEQuickBuilder
-SCRIPTS_DIR = Path(__file__).resolve().parent
-sys.path.insert(0, str(SCRIPTS_DIR))
-
-try:
-    from quick_build import CVEQuickBuilder
-except ImportError:
-    print("❌ Error: Could not import CVEQuickBuilder from quick_build.py")
-    sys.exit(1)
-
-def main():
-    """Run the quick builder"""
-    builder = CVEQuickBuilder()
-    builder.build()
-
-if __name__ == "__main__":
-    main()
diff --git a/src/cvedb/__init__.py b/src/cvedb/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/src/cvedb/analysis/__init__.py b/src/cvedb/analysis/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/src/cvedb/analysis/calendar.py b/src/cvedb/analysis/calendar.py
deleted file mode 100644
index 9269e2f0c01..00000000000
--- a/src/cvedb/analysis/calendar.py
+++ /dev/null
@@ -1,317 +0,0 @@
-#!/usr/bin/env python3
-"""
-Calendar Analysis Module for CVEDB
-Generates daily CVE publication data for calendar heatmap visualization
-"""
-
-import json
-from datetime import datetime
-from pathlib import Path
-import numpy as np
-from collections import defaultdict
-
-
-class CalendarAnalyzer:
-    """Analyzer for generating calendar-based CVE publication data"""
-    
-    def __init__(self, base_dir, cache_dir, data_dir, quiet=False):
-        self.quiet = quiet
-        self.base_dir = Path(base_dir)
-        self.cache_dir = Path(cache_dir)
-        self.data_dir = Path(data_dir)
-        self.nvd_file = self.cache_dir / 'nvd.json'
-        
-    def load_nvd_data(self):
-        """Load and parse NVD data from JSONL file"""
-        if not self.quiet:
-            print("    📂 Loading NVD data for calendar analysis...")
-        
-        if not self.nvd_file.exists():
-            print(f"    ❌ NVD file not found: {self.nvd_file}")
-            return []
-        
-        cve_records = []
-        try:
-            with open(self.nvd_file, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-                
-            if not self.quiet:
-                print(f"    📊 Processing {len(data):,} CVE records for calendar analysis...")
-            
-            for entry in data:
-                try:
-                    cve_id = entry.get('cve', {}).get('id', '')
-                    published = entry.get('cve', {}).get('published', '')
-                    
-                    # Extract CVSS score (try v3.1 first, then v3.0, then v2.0)
-                    cvss_score = None
-                    metrics = entry.get('cve', {}).get('metrics', {})
-                    
-                    if 'cvssMetricV31' in metrics and metrics['cvssMetricV31']:
-                        cvss_score = metrics['cvssMetricV31'][0].get('cvssData', {}).get('baseScore')
-                    elif 'cvssMetricV30' in metrics and metrics['cvssMetricV30']:
-                        cvss_score = metrics['cvssMetricV30'][0].get('cvssData', {}).get('baseScore')
-                    elif 'cvssMetricV2' in metrics and metrics['cvssMetricV2']:
-                        cvss_score = metrics['cvssMetricV2'][0].get('cvssData', {}).get('baseScore')
-                    
-                    # Skip rejected CVEs
-                    status = entry.get('cve', {}).get('vulnStatus', '')
-                    if 'Rejected' in status:
-                        continue
-                    
-                    if cve_id and published:
-                        cve_records.append({
-                            'cve_id': cve_id,
-                            'published': published,
-                            'cvss_score': cvss_score
-                        })
-                        
-                except Exception:
-                    continue  # Skip malformed entries
-                    
-            if not self.quiet:
-                print(f"    ✅ Loaded {len(cve_records):,} valid CVE records")
-            return cve_records
-            
-        except Exception as e:
-            print(f"    ❌ Error loading NVD data: {e}")
-            return []
-    
-    def process_daily_data(self, cve_records):
-        """Process CVE records into daily publication counts"""
-        if not self.quiet:
-            print("    📅 Processing daily CVE publication data...")
-        
-        daily_counts = defaultdict(int)
-        daily_scores = defaultdict(list)
-        
-        for record in cve_records:
-            try:
-                # Parse publication date
-                pub_date = datetime.fromisoformat(record['published'].replace('Z', '+00:00'))
-                date_key = pub_date.strftime('%Y-%m-%d')
-                
-                daily_counts[date_key] += 1
-                
-                if record['cvss_score'] is not None:
-                    daily_scores[date_key].append(record['cvss_score'])
-                    
-            except Exception:
-                continue  # Skip invalid dates
-        
-        # Calculate daily averages
-        daily_data = {}
-        for date_key, count in daily_counts.items():
-            scores = daily_scores.get(date_key, [])
-            avg_score = np.mean(scores) if scores else None
-            
-            daily_data[date_key] = {
-                'date': date_key,
-                'count': count,
-                'avg_cvss_score': round(avg_score, 2) if avg_score else None,
-                'cvss_count': len(scores)
-            }
-        
-        if not self.quiet:
-            print(f"    ✅ Processed {len(daily_data):,} days of CVE data")
-        return daily_data
-    
-    def calculate_statistics(self, daily_data, cve_records):
-        """Calculate overall statistics for the calendar analysis"""
-        if not self.quiet:
-            print("    📊 Calculating calendar statistics...")
-        
-        total_cves = len(cve_records)
-        total_days = len(daily_data)
-        
-        # Calculate date range
-        dates = [datetime.strptime(date_key, '%Y-%m-%d') for date_key in daily_data.keys()]
-        start_date = min(dates) if dates else datetime.now()
-        end_date = max(dates) if dates else datetime.now()
-        
-        # Calculate averages
-        daily_counts = [data['count'] for data in daily_data.values()]
-        avg_per_day = np.mean(daily_counts) if daily_counts else 0
-        max_per_day = max(daily_counts) if daily_counts else 0
-        min_per_day = min(daily_counts) if daily_counts else 0
-        
-        # Find peak day
-        peak_day_data = max(daily_data.values(), key=lambda x: x['count']) if daily_data else None
-        
-        # Calculate CVSS statistics
-        cvss_scores = [record['cvss_score'] for record in cve_records if record['cvss_score'] is not None]
-        avg_cvss = np.mean(cvss_scores) if cvss_scores else None
-        
-        # Calculate current year statistics
-        current_year = datetime.now().year
-        current_year_data = {k: v for k, v in daily_data.items() if k.startswith(str(current_year))}
-        current_year_cves = sum(data['count'] for data in current_year_data.values())
-        
-        statistics = {
-            'total_cves': total_cves,
-            'total_days_with_data': total_days,
-            'date_range': {
-                'start': start_date.strftime('%Y-%m-%d'),
-                'end': end_date.strftime('%Y-%m-%d')
-            },
-            'daily_stats': {
-                'average_per_day': round(avg_per_day, 2),
-                'max_per_day': max_per_day,
-                'min_per_day': min_per_day,
-                'peak_day': {
-                    'date': peak_day_data['date'] if peak_day_data else None,
-                    'count': peak_day_data['count'] if peak_day_data else 0
-                }
-            },
-            'cvss_stats': {
-                'average_score': round(avg_cvss, 2) if avg_cvss else None,
-                'total_with_scores': len(cvss_scores)
-            },
-            'current_year': {
-                'year': current_year,
-                'total_cves': current_year_cves,
-                'days_with_data': len(current_year_data)
-            }
-        }
-        
-        return statistics
-    
-    def generate_calendar_analysis(self):
-        """Generate comprehensive calendar analysis"""
-        print("  📅 Generating calendar analysis...")
-        
-        # Load CVE data
-        cve_records = self.load_nvd_data()
-        if not cve_records:
-            print("  ❌ No CVE data available for calendar analysis")
-            return None
-        
-        # Process daily data
-        daily_data = self.process_daily_data(cve_records)
-        if not daily_data:
-            print("  ❌ No daily data generated")
-            return None
-        
-        # Calculate statistics
-        statistics = self.calculate_statistics(daily_data, cve_records)
-        
-        # Prepare calendar data for frontend
-        calendar_data = []
-        for date_key, data in daily_data.items():
-            calendar_data.append({
-                'date': date_key,
-                'value': data['count'],
-                'avg_cvss': data['avg_cvss_score'],
-                'cvss_count': data['cvss_count']
-            })
-        
-        # Sort by date
-        calendar_data.sort(key=lambda x: x['date'])
-        
-        analysis_result = {
-            'generated_at': datetime.now().isoformat(),
-            'statistics': statistics,
-            'daily_data': calendar_data,
-            'metadata': {
-                'total_records': len(cve_records),
-                'total_days': len(daily_data),
-                'data_source': 'NVD JSONL',
-                'analysis_type': 'calendar_heatmap'
-            }
-        }
-        
-        # Save to file
-        output_file = self.data_dir / 'calendar_analysis.json'
-        with open(output_file, 'w') as f:
-            json.dump(analysis_result, f, indent=2)
-        
-        if not self.quiet:
-            print(f"  ✅ Generated calendar analysis with {len(calendar_data):,} days of data")
-        return analysis_result
-    
-    def generate_current_year_calendar_analysis(self):
-        """Generate current year specific calendar analysis"""
-        print("  📅 Generating current year calendar analysis...")
-        
-        # Load full analysis first
-        full_analysis = self.generate_calendar_analysis()
-        if not full_analysis:
-            return None
-        
-        current_year = datetime.now().year
-        
-        # Filter for current year data
-        current_year_daily = [
-            data for data in full_analysis['daily_data'] 
-            if data['date'].startswith(str(current_year))
-        ]
-        
-        # Calculate current year statistics
-        if current_year_daily:
-            total_cves = sum(data['value'] for data in current_year_daily)
-            avg_per_day = total_cves / len(current_year_daily) if current_year_daily else 0
-            max_day = max(current_year_daily, key=lambda x: x['value']) if current_year_daily else None
-            
-            # Calculate CVSS average for current year
-            cvss_scores = [data['avg_cvss'] for data in current_year_daily if data['avg_cvss'] is not None]
-            avg_cvss = np.mean(cvss_scores) if cvss_scores else None
-            
-            current_year_stats = {
-                'year': current_year,
-                'total_cves': total_cves,
-                'total_days_with_data': len(current_year_daily),
-                'average_per_day': round(avg_per_day, 2),
-                'peak_day': {
-                    'date': max_day['date'] if max_day else None,
-                    'count': max_day['value'] if max_day else 0
-                },
-                'average_cvss': round(avg_cvss, 2) if avg_cvss else None
-            }
-        else:
-            current_year_stats = {
-                'year': current_year,
-                'total_cves': 0,
-                'total_days_with_data': 0,
-                'average_per_day': 0,
-                'peak_day': {'date': None, 'count': 0},
-                'average_cvss': None
-            }
-        
-        current_year_analysis = {
-            'generated_at': datetime.now().isoformat(),
-            'statistics': current_year_stats,
-            'daily_data': current_year_daily,
-            'metadata': {
-                'year': current_year,
-                'total_days': len(current_year_daily),
-                'data_source': 'NVD JSONL',
-                'analysis_type': 'current_year_calendar'
-            }
-        }
-        
-        # Save to file
-        output_file = self.data_dir / 'calendar_analysis_current_year.json'
-        with open(output_file, 'w') as f:
-            json.dump(current_year_analysis, f, indent=2)
-        
-        if not self.quiet:
-            print(f"  ✅ Generated current year calendar analysis with {len(current_year_daily):,} days")
-        return current_year_analysis
-
-
-if __name__ == "__main__":
-    # Test the analyzer
-    base_dir = Path(__file__).parent.parent
-    cache_dir = base_dir / 'data' / 'cache'
-    data_dir = base_dir / 'web' / 'data'
-    
-    analyzer = CalendarAnalyzer(base_dir, cache_dir, data_dir)
-    
-    print("🗓️  Testing Calendar Analysis...")
-    comprehensive_analysis = analyzer.generate_calendar_analysis()
-    current_year_analysis = analyzer.generate_current_year_calendar_analysis()
-    
-    if comprehensive_analysis and current_year_analysis:
-        print("✅ Calendar analysis test completed successfully!")
-    else:
-        print("❌ Calendar analysis test failed!")
diff --git a/src/cvedb/analysis/cpe.py b/src/cvedb/analysis/cpe.py
deleted file mode 100644
index 1740dbfcb9d..00000000000
--- a/src/cvedb/analysis/cpe.py
+++ /dev/null
@@ -1,409 +0,0 @@
-#!/usr/bin/env python3
-"""
-CPE Analysis Module
-Handles all CPE (Common Platform Enumeration) related data processing and analysis
-"""
-
-import json
-from pathlib import Path
-from datetime import datetime
-from collections import Counter
-
-
-class CPEAnalyzer:
-    """Handles CPE-specific analysis and data processing"""
-    
-    def __init__(self, base_dir, cache_dir, data_dir, quiet=False):
-        self.quiet = quiet
-        self.base_dir = Path(base_dir)
-        self.cache_dir = Path(cache_dir)
-        self.data_dir = Path(data_dir)
-        self.current_year = datetime.now().year
-    
-    def extract_cpe_vendor(self, cpe_string):
-        """Extract vendor from CPE string (cpe:2.3:a:vendor:product:...)"""
-        try:
-            parts = cpe_string.split(':')
-            if len(parts) >= 4:
-                return parts[3]  # vendor is at index 3
-            return 'unknown'
-        except:
-            return 'unknown'
-    
-    def extract_cpe_product(self, cpe_string):
-        """Extract product from CPE string (cpe:2.3:a:vendor:product:...)"""
-        try:
-            parts = cpe_string.split(':')
-            if len(parts) >= 5:
-                return parts[4]  # product is at index 4
-            return 'unknown'
-        except:
-            return 'unknown'
-    
-    def extract_cpe_type(self, cpe_string):
-        """Extract CPE type from CPE string (a=application, o=operating_system, h=hardware)"""
-        try:
-            parts = cpe_string.split(':')
-            if len(parts) >= 3:
-                cpe_type = parts[2]
-                type_map = {
-                    'a': 'Application',
-                    'o': 'Operating System', 
-                    'h': 'Hardware'
-                }
-                return type_map.get(cpe_type, 'Unknown')
-            return 'Unknown'
-        except:
-            return 'Unknown'
-    
-    def generate_cpe_analysis(self, all_year_data):
-        """Generate CPE analysis across all years"""
-        if not self.quiet:
-            print(f"  🔍 Generating CPE analysis...")
-        
-        # Process raw CVE data to extract CPE information
-        cpe_data = self._process_cpe_data_from_cache()
-        
-        if not cpe_data:
-            print("  ⚠️  No CPE data found, generating minimal analysis")
-            return self._generate_minimal_cpe_analysis()
-        
-        # Analyze CPE patterns
-        cpe_counts = Counter(cpe_data['cpe_list'])
-        vendor_counts = Counter(cpe_data['vendor_list'])
-        product_counts = Counter(cpe_data['product_list'])
-        type_counts = Counter(cpe_data['type_list'])
-        
-        # Get top CPEs
-        top_cpes = []
-        for cpe, count in cpe_counts.most_common(50):
-            vendor = self.extract_cpe_vendor(cpe)
-            product = self.extract_cpe_product(cpe)
-            cpe_type = self.extract_cpe_type(cpe)
-            
-            top_cpes.append({
-                'cpe': cpe,
-                'count': count,
-                'vendor': vendor,
-                'product': product,
-                'type': cpe_type
-            })
-        
-        # Get top vendors
-        top_vendors = [{'vendor': vendor, 'count': count} 
-                      for vendor, count in vendor_counts.most_common(20)]
-        
-        # Get top products
-        top_products = [{'product': product, 'count': count} 
-                       for product, count in product_counts.most_common(20)]
-        
-        # CPE type distribution
-        cpe_type_distribution = [{'type': cpe_type, 'count': count, 'percentage': round(count / len(cpe_data['type_list']) * 100, 1)} 
-                                for cpe_type, count in type_counts.most_common()]
-        
-        # Calculate CVEs with most CPEs
-        cve_cpe_counts = Counter(cpe_data['cve_list'])
-        cves_with_most_cpes = []
-        for cve, cpe_count in cve_cpe_counts.most_common(20):
-            cves_with_most_cpes.append({
-                'cve': cve,
-                'cpe_count': cpe_count
-            })
-        
-        cpe_analysis = {
-            'generated_at': datetime.now().isoformat(),
-            'total_unique_cpes': len(cpe_counts),
-            'total_cpe_entries': len(cpe_data['cpe_list']),
-            'total_cves_with_cpes': len(set(cpe_data['cve_list'])),
-            'total_unique_vendors': len(vendor_counts),
-            'total_unique_products': len(product_counts),
-            'top_cpes': top_cpes,
-            'top_vendors': top_vendors,
-            'top_products': top_products,
-            'cpe_type_distribution': cpe_type_distribution,
-            'cves_with_most_cpes': cves_with_most_cpes,
-            'average_cpes_per_cve': round(len(cpe_data['cpe_list']) / len(set(cpe_data['cve_list'])), 1) if cpe_data['cve_list'] else 0
-        }
-        
-        # Save to file
-        output_file = self.data_dir / 'cpe_analysis.json'
-        with open(output_file, 'w') as f:
-            json.dump(cpe_analysis, f, indent=2)
-        
-        print(f"  ✅ Generated CPE analysis with {len(cpe_counts):,} unique CPEs")
-        return cpe_analysis
-    
-    def generate_current_year_cpe_analysis(self, current_year_data):
-        """Generate current year CPE analysis"""
-        print(f"    🔍 Generating current year CPE analysis...")
-        
-        # Process current year CPE data from cache
-        current_year_cpe_data = self._process_current_year_cpe_data()
-        
-        if not current_year_cpe_data:
-            print(f"    ⚠️  No CPE data found for {self.current_year}")
-            return {}
-        
-        # Analyze current year CPE patterns
-        cpe_counts = Counter(current_year_cpe_data['cpe_list'])
-        vendor_counts = Counter(current_year_cpe_data['vendor_list'])
-        product_counts = Counter(current_year_cpe_data['product_list'])
-        type_counts = Counter(current_year_cpe_data['type_list'])
-        
-        # Get top CPEs for current year
-        top_cpes = []
-        for cpe, count in cpe_counts.most_common(30):
-            vendor = self.extract_cpe_vendor(cpe)
-            product = self.extract_cpe_product(cpe)
-            cpe_type = self.extract_cpe_type(cpe)
-            
-            top_cpes.append({
-                'cpe': cpe,
-                'count': count,
-                'vendor': vendor,
-                'product': product,
-                'type': cpe_type
-            })
-        
-        # Get top vendors for current year
-        top_vendors = [{'vendor': vendor, 'count': count} 
-                      for vendor, count in vendor_counts.most_common(15)]
-        
-        # Get top products for current year
-        top_products = [{'product': product, 'count': count} 
-                       for product, count in product_counts.most_common(15)]
-        
-        # CPE type distribution for current year
-        cpe_type_distribution = [{'type': cpe_type, 'count': count, 'percentage': round(count / len(current_year_cpe_data['type_list']) * 100, 1)} 
-                                for cpe_type, count in type_counts.most_common()]
-        
-        # Calculate CVEs with most CPEs for current year
-        cve_cpe_counts = Counter(current_year_cpe_data['cve_list'])
-        cves_with_most_cpes = []
-        for cve, cpe_count in cve_cpe_counts.most_common(20):
-            cves_with_most_cpes.append({
-                'cve': cve,
-                'cpe_count': cpe_count
-            })
-        
-        current_year_cpe_analysis = {
-            'generated_at': datetime.now().isoformat(),
-            'year': self.current_year,
-            'total_unique_cpes': len(cpe_counts),
-            'total_cpe_entries': len(current_year_cpe_data['cpe_list']),
-            'total_cves_with_cpes': len(set(current_year_cpe_data['cve_list'])),
-            'total_unique_vendors': len(vendor_counts),
-            'total_unique_products': len(product_counts),
-            'top_cpes': top_cpes,
-            'top_vendors': top_vendors,
-            'top_products': top_products,
-            'cpe_type_distribution': cpe_type_distribution,
-            'cves_with_most_cpes': cves_with_most_cpes,
-            'average_cpes_per_cve': round(len(current_year_cpe_data['cpe_list']) / len(set(current_year_cpe_data['cve_list'])), 1) if current_year_cpe_data['cve_list'] else 0
-        }
-        
-        # Save current year analysis
-        current_year_file = self.data_dir / 'cpe_analysis_current_year.json'
-        with open(current_year_file, 'w') as f:
-            json.dump(current_year_cpe_analysis, f, indent=2)
-        
-        print(f"    ✅ Generated current year CPE analysis with {len(cpe_counts)} unique CPEs")
-        return current_year_cpe_analysis
-    
-    def _process_cpe_data_from_cache(self):
-        """Process CPE data from cached nvd.json file"""
-        nvd_file = self.cache_dir / 'nvd.json'
-        
-        if not nvd_file.exists():
-            print(f"    ⚠️  NVD cache file not found: {nvd_file}")
-            return None
-        
-        if not self.quiet:
-            print(f"    📂 Processing CPE data from {nvd_file}")
-        
-        cpe_list = []
-        vendor_list = []
-        product_list = []
-        type_list = []
-        cve_list = []
-        
-        try:
-            with open(nvd_file, 'r', encoding='utf-8') as f:
-                if not self.quiet:
-                    print(f"    📂 Loading NVD data from {nvd_file}...")
-                nvd_data = json.load(f)
-                
-                # Handle different possible data structures
-                cve_items = []
-                if isinstance(nvd_data, list):
-                    cve_items = nvd_data
-                elif isinstance(nvd_data, dict):
-                    # Check for common NVD data structure patterns
-                    if 'CVE_Items' in nvd_data:
-                        cve_items = nvd_data['CVE_Items']
-                    elif 'vulnerabilities' in nvd_data:
-                        cve_items = nvd_data['vulnerabilities']
-                    else:
-                        # Assume it's a single CVE item
-                        cve_items = [nvd_data]
-                
-                if not self.quiet:
-                    print(f"    📊 Processing {len(cve_items):,} CVE records...")
-                
-                for idx, cve_item in enumerate(cve_items):
-                    if idx % 50000 == 0 and idx > 0 and not self.quiet:
-                        print(f"    📊 Processed {idx:,} CVE records...")
-                    
-                    try:
-                        # Handle different CVE data structures
-                        cve_data = cve_item
-                        if 'cve' in cve_item:
-                            cve_data = cve_item['cve']
-                        
-                        cve_id = cve_data.get('id', cve_data.get('CVE_data_meta', {}).get('ID', ''))
-                        
-                        # Extract CPE data from configurations
-                        configurations = cve_data.get('configurations', [])
-                        if not configurations and 'configurations' in cve_item:
-                            configurations = cve_item['configurations']
-                        
-                        for config in configurations:
-                            for node in config.get('nodes', []):
-                                if 'cpeMatch' in node:
-                                    for cpe_match in node['cpeMatch']:
-                                        if cpe_match.get('vulnerable', False):
-                                            cpe_string = cpe_match.get('criteria', '')
-                                            if cpe_string:
-                                                cpe_list.append(cpe_string)
-                                                cve_list.append(cve_id)
-                                                vendor_list.append(self.extract_cpe_vendor(cpe_string))
-                                                product_list.append(self.extract_cpe_product(cpe_string))
-                                                type_list.append(self.extract_cpe_type(cpe_string))
-                    
-                    except Exception:
-                        continue
-        
-        except Exception as e:
-            print(f"    ❌ Error processing NVD file: {e}")
-            return None
-        
-        if not self.quiet:
-            print(f"    ✅ Processed {len(cpe_list):,} CPE entries from {len(set(cve_list)):,} CVEs")
-        
-        return {
-            'cpe_list': cpe_list,
-            'vendor_list': vendor_list,
-            'product_list': product_list,
-            'type_list': type_list,
-            'cve_list': cve_list
-        }
-    
-    def _process_current_year_cpe_data(self):
-        """Process CPE data for current year only"""
-        nvd_file = self.cache_dir / 'nvd.json'
-        
-        if not nvd_file.exists():
-            print(f"    ⚠️  NVD cache file not found: {nvd_file}")
-            return None
-        
-        if not self.quiet:
-            print(f"    📂 Processing current year CPE data from {nvd_file}")
-        
-        cpe_list = []
-        vendor_list = []
-        product_list = []
-        type_list = []
-        cve_list = []
-        
-        try:
-            with open(nvd_file, 'r', encoding='utf-8') as f:
-                if not self.quiet:
-                    print(f"    📂 Loading NVD data for current year from {nvd_file}...")
-                nvd_data = json.load(f)
-                
-                # Handle different possible data structures
-                cve_items = []
-                if isinstance(nvd_data, list):
-                    cve_items = nvd_data
-                elif isinstance(nvd_data, dict):
-                    # Check for common NVD data structure patterns
-                    if 'CVE_Items' in nvd_data:
-                        cve_items = nvd_data['CVE_Items']
-                    elif 'vulnerabilities' in nvd_data:
-                        cve_items = nvd_data['vulnerabilities']
-                    else:
-                        # Assume it's a single CVE item
-                        cve_items = [nvd_data]
-                
-                if not self.quiet:
-                    print(f"    📊 Processing {len(cve_items):,} CVE records for current year...")
-                
-                for idx, cve_item in enumerate(cve_items):
-                    if idx % 50000 == 0 and idx > 0 and not self.quiet:
-                        print(f"    📊 Processed {idx:,} CVE records for current year...")
-                    
-                    try:
-                        # Handle different CVE data structures
-                        cve_data = cve_item
-                        if 'cve' in cve_item:
-                            cve_data = cve_item['cve']
-                        
-                        cve_id = cve_data.get('id', cve_data.get('CVE_data_meta', {}).get('ID', ''))
-                        
-                        # Check if CVE is from current year
-                        published_date = cve_data.get('published', cve_data.get('publishedDate', ''))
-                        if not published_date.startswith(str(self.current_year)):
-                            continue
-                        
-                        # Extract CPE data from configurations
-                        configurations = cve_data.get('configurations', [])
-                        if not configurations and 'configurations' in cve_item:
-                            configurations = cve_item['configurations']
-                        
-                        for config in configurations:
-                            for node in config.get('nodes', []):
-                                if 'cpeMatch' in node:
-                                    for cpe_match in node['cpeMatch']:
-                                        if cpe_match.get('vulnerable', False):
-                                            cpe_string = cpe_match.get('criteria', '')
-                                            if cpe_string:
-                                                cpe_list.append(cpe_string)
-                                                cve_list.append(cve_id)
-                                                vendor_list.append(self.extract_cpe_vendor(cpe_string))
-                                                product_list.append(self.extract_cpe_product(cpe_string))
-                                                type_list.append(self.extract_cpe_type(cpe_string))
-                    
-                    except Exception:
-                        continue
-        
-        except Exception as e:
-            print(f"    ❌ Error processing NVD file for current year: {e}")
-            return None
-        
-        if not self.quiet:
-            print(f"    ✅ Processed {len(cpe_list):,} CPE entries from {len(set(cve_list)):,} CVEs for {self.current_year}")
-        
-        return {
-            'cpe_list': cpe_list,
-            'vendor_list': vendor_list,
-            'product_list': product_list,
-            'type_list': type_list,
-            'cve_list': cve_list
-        }
-    
-    def _generate_minimal_cpe_analysis(self):
-        """Generate minimal CPE analysis when no data is available"""
-        return {
-            'generated_at': datetime.now().isoformat(),
-            'total_unique_cpes': 0,
-            'total_cpe_entries': 0,
-            'total_cves_with_cpes': 0,
-            'total_unique_vendors': 0,
-            'total_unique_products': 0,
-            'top_cpes': [],
-            'top_vendors': [],
-            'top_products': [],
-            'cpe_type_distribution': [],
-            'cves_with_most_cpes': [],
-            'average_cpes_per_cve': 0
-        }
diff --git a/src/cvedb/analysis/cwe.py b/src/cvedb/analysis/cwe.py
deleted file mode 100644
index cc4ea33c65d..00000000000
--- a/src/cvedb/analysis/cwe.py
+++ /dev/null
@@ -1,178 +0,0 @@
-#!/usr/bin/env python3
-"""
-CWE Analysis Module
-Handles all CWE (Common Weakness Enumeration) related data processing and analysis
-"""
-
-import json
-from pathlib import Path
-from datetime import datetime
-
-
-class CWEAnalyzer:
-    """Handles CWE-specific analysis and data processing"""
-    
-    def __init__(self, base_dir, cache_dir, data_dir, quiet=False):
-        self.quiet = quiet
-        self.base_dir = Path(base_dir)
-        self.cache_dir = Path(cache_dir)
-        self.data_dir = Path(data_dir)
-        self.current_year = datetime.now().year
-    
-    def generate_cwe_analysis(self, all_year_data):
-        """Generate CWE analysis across all years"""
-        if not self.quiet:
-            print(f"  🔍 Generating CWE analysis...")
-        
-        # Aggregate CWE data from all years
-        combined_cwe = {}
-        
-        for year_data in all_year_data:
-            if 'cwe' in year_data and 'top_cwes' in year_data['cwe']:
-                # Aggregate CWE counts
-                for cwe_entry in year_data['cwe']['top_cwes']:
-                    cwe_full = cwe_entry['cwe']  # e.g., "CWE-79"
-                    cwe_id = cwe_full.replace('CWE-', '') if cwe_full.startswith('CWE-') else cwe_full
-                    count = cwe_entry['count']
-                    
-                    if cwe_id not in combined_cwe:
-                        combined_cwe[cwe_id] = {
-                            'id': cwe_id,
-                            'name': cwe_entry.get('name', f'CWE-{cwe_id}'),
-                            'count': 0
-                        }
-                    
-                    combined_cwe[cwe_id]['count'] += count
-        
-        # Sort by count and get top CWEs
-        top_cwes = sorted(combined_cwe.values(), key=lambda x: x['count'], reverse=True)
-        
-        # Calculate total CVEs with CWE from aggregated counts
-        total_cves_with_cwe = sum(cwe['count'] for cwe in combined_cwe.values())
-        
-        # Add common CWE descriptions for better understanding
-        cwe_descriptions = {
-            '79': 'Cross-site Scripting (XSS)',
-            '89': 'SQL Injection',
-            '20': 'Improper Input Validation',
-            '22': 'Path Traversal',
-            '352': 'Cross-Site Request Forgery (CSRF)',
-            '78': 'OS Command Injection',
-            '190': 'Integer Overflow',
-            '476': 'NULL Pointer Dereference',
-            '94': 'Code Injection',
-            '119': 'Buffer Overflow',
-            '125': 'Out-of-bounds Read',
-            '787': 'Out-of-bounds Write',
-            '416': 'Use After Free',
-            '200': 'Information Exposure',
-            '434': 'Unrestricted Upload of File',
-            '862': 'Missing Authorization',
-            '863': 'Incorrect Authorization',
-            '269': 'Improper Privilege Management',
-            '287': 'Improper Authentication',
-            '295': 'Improper Certificate Validation'
-        }
-        
-        # Enhance CWE entries with descriptions
-        for cwe in top_cwes:
-            cwe_id = cwe['id']
-            if cwe_id in cwe_descriptions:
-                cwe['description'] = cwe_descriptions[cwe_id]
-                cwe['name'] = f"CWE-{cwe_id}: {cwe_descriptions[cwe_id]}"
-            else:
-                cwe['description'] = f"CWE-{cwe_id}"
-        
-        cwe_analysis = {
-            'generated_at': datetime.now().isoformat(),
-            'total_cves_with_cwe': total_cves_with_cwe,
-            'total_unique_cwes': len(combined_cwe),
-            'top_cwes': top_cwes,  # All CWEs
-            'top_cwes_limited': top_cwes[:20]  # Top 20 for charts
-        }
-        
-        # Save to file
-        output_file = self.data_dir / 'cwe_analysis.json'
-        with open(output_file, 'w') as f:
-            json.dump(cwe_analysis, f, indent=2)
-        
-        if not self.quiet:
-            print(f"  ✅ Generated CWE analysis with {len(combined_cwe):,} unique CWEs")
-        return cwe_analysis
-    
-    def generate_current_year_cwe_analysis(self, current_year_data):
-        """Generate current year CWE analysis"""
-        if not self.quiet:
-            print(f"    🔍 Generating current year CWE analysis...")
-        
-        # Extract CWE data from current year
-        cwe_data = current_year_data.get('cwe', {})
-        
-        if not cwe_data or 'top_cwes' not in cwe_data:
-            print(f"    ⚠️  No CWE data found for {self.current_year}")
-            return {}
-        
-        # Get current year CWEs
-        current_year_cwes = cwe_data['top_cwes']
-        
-        # Add descriptions to current year CWEs
-        cwe_descriptions = {
-            '79': 'Cross-site Scripting (XSS)',
-            '89': 'SQL Injection',
-            '20': 'Improper Input Validation',
-            '22': 'Path Traversal',
-            '352': 'Cross-Site Request Forgery (CSRF)',
-            '78': 'OS Command Injection',
-            '190': 'Integer Overflow',
-            '476': 'NULL Pointer Dereference',
-            '94': 'Code Injection',
-            '119': 'Buffer Overflow',
-            '125': 'Out-of-bounds Read',
-            '787': 'Out-of-bounds Write',
-            '416': 'Use After Free',
-            '200': 'Information Exposure',
-            '434': 'Unrestricted Upload of File',
-            '862': 'Missing Authorization',
-            '863': 'Incorrect Authorization',
-            '269': 'Improper Privilege Management',
-            '287': 'Improper Authentication',
-            '295': 'Improper Certificate Validation'
-        }
-        
-        # Enhance CWE entries with descriptions
-        enhanced_cwes = []
-        for cwe in current_year_cwes:
-            cwe_full = cwe['cwe']  # e.g., "CWE-79"
-            cwe_id = cwe_full.replace('CWE-', '') if cwe_full.startswith('CWE-') else cwe_full
-            enhanced_cwe = cwe.copy()
-            enhanced_cwe['id'] = cwe_id  # Add id field for consistency
-            
-            if cwe_id in cwe_descriptions:
-                enhanced_cwe['description'] = cwe_descriptions[cwe_id]
-                enhanced_cwe['name'] = f"CWE-{cwe_id}: {cwe_descriptions[cwe_id]}"
-            else:
-                enhanced_cwe['description'] = f"CWE-{cwe_id}"
-                enhanced_cwe['name'] = f"CWE-{cwe_id}"
-            
-            enhanced_cwes.append(enhanced_cwe)
-        
-        # Calculate total CVEs with CWE from individual counts
-        total_cves_with_cwe = sum(cwe['count'] for cwe in current_year_cwes)
-        
-        current_year_cwe_analysis = {
-            'generated_at': datetime.now().isoformat(),
-            'year': self.current_year,
-            'total_cves_with_cwe': total_cves_with_cwe,
-            'total_unique_cwes': len(current_year_cwes),
-            'top_cwes': enhanced_cwes,  # All CWEs
-            'top_cwes_limited': enhanced_cwes[:20]  # Top 20 for charts
-        }
-        
-        # Save current year analysis
-        current_year_file = self.data_dir / 'cwe_analysis_current_year.json'
-        with open(current_year_file, 'w') as f:
-            json.dump(current_year_cwe_analysis, f, indent=2)
-        
-        if not self.quiet:
-            print(f"    ✅ Generated current year CWE analysis with {len(current_year_cwes)} CWEs")
-        return current_year_cwe_analysis
diff --git a/src/cvedb/analysis/scoring.py b/src/cvedb/analysis/scoring.py
deleted file mode 100644
index e3860ae9322..00000000000
--- a/src/cvedb/analysis/scoring.py
+++ /dev/null
@@ -1,542 +0,0 @@
-#!/usr/bin/env python3
-"""
-Scoring Analysis Module for CVEDB
-Generates analysis files for the Scoring Hub: EPSS, KEV, and Risk Matrix data
-"""
-
-import json
-from collections import defaultdict
-from datetime import datetime, timezone
-from pathlib import Path
-
-
-class ScoringAnalyzer:
-    """Generates scoring-related analysis files for the Scoring Hub"""
-    
-    def __init__(self, base_dir=None, cache_dir=None, output_dir=None):
-        self.base_dir = Path(base_dir) if base_dir else Path(__file__).parent.parent
-        self.cache_dir = Path(cache_dir) if cache_dir else self.base_dir / 'data' / 'cache'
-        self.output_dir = Path(output_dir) if output_dir else self.base_dir / 'web' / 'data'
-        
-        # Source files
-        self.epss_file = self.cache_dir / 'epss_scores-current.json'
-        self.kev_file = self.cache_dir / 'known_exploited_vulnerabilities.json'
-        self.nvd_file = self.cache_dir / 'nvd.json'
-        
-    def load_epss_data(self):
-        """Load EPSS scores from parsed JSON"""
-        if not self.epss_file.exists():
-            print(f"⚠️  EPSS file not found: {self.epss_file}")
-            return {}
-        
-        with open(self.epss_file, 'r') as f:
-            return json.load(f)
-    
-    def load_kev_data(self):
-        """Load KEV data from CISA JSON"""
-        if not self.kev_file.exists():
-            print(f"⚠️  KEV file not found: {self.kev_file}")
-            return {'vulnerabilities': []}
-        
-        with open(self.kev_file, 'r') as f:
-            return json.load(f)
-    
-    def load_cvss_data(self):
-        """Load CVSS data from existing analysis file or count from NVD"""
-        cvss_file = self.output_dir / 'cvss_analysis.json'
-        if cvss_file.exists():
-            with open(cvss_file, 'r') as f:
-                return json.load(f)
-        
-        # Fallback: count CVSS from NVD data directly
-        print(f"⚠️  CVSS analysis file not found: {cvss_file}")
-        print(f"    📂 Counting CVSS from NVD data directly...")
-        
-        if not self.nvd_file.exists():
-            return {'total_cves_with_cvss': 0}
-        
-        try:
-            with open(self.nvd_file, 'r') as f:
-                nvd_data = json.load(f)
-            
-            count = 0
-            # NVD data is a list of items with 'cve' key
-            if isinstance(nvd_data, list):
-                for item in nvd_data:
-                    cve = item.get('cve', {})
-                    metrics = cve.get('metrics', {})
-                    if metrics.get('cvssMetricV31') or metrics.get('cvssMetricV30') or metrics.get('cvssMetricV2'):
-                        count += 1
-            else:
-                # Old format: dict keyed by CVE ID
-                for cve_id, cve_data in nvd_data.items():
-                    if cve_data.get('cvss_v3') or cve_data.get('cvss_v2'):
-                        count += 1
-            
-            print(f"    ✅ Found {count:,} CVEs with CVSS scores")
-            return {'total_cves_with_cvss': count}
-        except Exception as e:
-            print(f"    ❌ Error loading NVD data: {e}")
-            return {'total_cves_with_cvss': 0}
-    
-    def generate_epss_analysis(self):
-        """Generate EPSS-focused analysis JSON"""
-        print("📊 Generating EPSS analysis...")
-        
-        epss_data = self.load_epss_data()
-        if not epss_data:
-            print("  ⚠️  No EPSS data available")
-            return None
-        
-        # Calculate distributions
-        buckets = {
-            'very_low': 0,      # 0 - 0.01
-            'low': 0,           # 0.01 - 0.1
-            'medium': 0,        # 0.1 - 0.3
-            'high': 0,          # 0.3 - 0.5
-            'very_high': 0,     # 0.5 - 0.7
-            'critical': 0       # 0.7+
-        }
-        
-        percentile_buckets = defaultdict(int)  # 0-10, 10-20, etc.
-        year_coverage = defaultdict(lambda: {'total': 0, 'with_epss': 0})
-        high_risk_cves = []  # EPSS > 0.5
-        
-        for cve_id, scores in epss_data.items():
-            score = scores.get('epss_score', 0)
-            percentile = scores.get('epss_percentile', 0)
-            
-            # Extract year from CVE ID
-            try:
-                year = cve_id.split('-')[1]
-                year_coverage[year]['with_epss'] += 1
-            except (IndexError, ValueError):
-                pass
-            
-            # Score buckets
-            if score < 0.01:
-                buckets['very_low'] += 1
-            elif score < 0.1:
-                buckets['low'] += 1
-            elif score < 0.3:
-                buckets['medium'] += 1
-            elif score < 0.5:
-                buckets['high'] += 1
-            elif score < 0.7:
-                buckets['very_high'] += 1
-            else:
-                buckets['critical'] += 1
-            
-            # Percentile buckets (for histogram)
-            bucket_idx = min(int(percentile * 10), 9)  # 0-9
-            percentile_buckets[bucket_idx] += 1
-            
-            # High risk list (top by EPSS)
-            if score >= 0.5:
-                high_risk_cves.append({
-                    'cve_id': cve_id,
-                    'epss_score': score,
-                    'epss_percentile': percentile
-                })
-        
-        # Sort high risk by score descending, limit to top 100
-        high_risk_cves.sort(key=lambda x: x['epss_score'], reverse=True)
-        high_risk_cves = high_risk_cves[:100]
-        
-        # Calculate statistics
-        all_scores = [s['epss_score'] for s in epss_data.values()]
-        avg_score = sum(all_scores) / len(all_scores) if all_scores else 0
-        
-        # Threshold counts
-        gt_01 = sum(1 for s in all_scores if s > 0.1)
-        gt_03 = sum(1 for s in all_scores if s > 0.3)
-        gt_05 = sum(1 for s in all_scores if s > 0.5)
-        gt_07 = sum(1 for s in all_scores if s > 0.7)
-        gt_09 = sum(1 for s in all_scores if s > 0.9)
-        
-        analysis = {
-            'generated_at': datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z'),
-            'total_cves_with_epss': len(epss_data),
-            'statistics': {
-                'average_score': round(avg_score, 6),
-                'gt_0_1': gt_01,
-                'gt_0_3': gt_03,
-                'gt_0_5': gt_05,
-                'gt_0_7': gt_07,
-                'gt_0_9': gt_09
-            },
-            'score_buckets': buckets,
-            'percentile_distribution': dict(sorted(percentile_buckets.items())),
-            'year_coverage': dict(sorted(year_coverage.items())),
-            'high_risk_cves': high_risk_cves
-        }
-        
-        output_file = self.output_dir / 'epss_analysis.json'
-        with open(output_file, 'w') as f:
-            json.dump(analysis, f, indent=2)
-        
-        print(f"  ✅ Generated {output_file.name}")
-        print(f"     Total CVEs with EPSS: {len(epss_data):,}")
-        print(f"     High risk (>0.5): {gt_05:,}")
-        
-        return analysis
-    
-    def generate_kev_analysis(self):
-        """Generate KEV-focused analysis JSON"""
-        print("📊 Generating KEV analysis...")
-        
-        kev_data = self.load_kev_data()
-        vulnerabilities = kev_data.get('vulnerabilities', [])
-        
-        if not vulnerabilities:
-            print("  ⚠️  No KEV data available")
-            return None
-        
-        # Aggregations
-        by_year_added = defaultdict(int)
-        by_year_cve = defaultdict(int)  # Year the CVE was published
-        by_vendor = defaultdict(int)
-        by_product = defaultdict(int)
-        by_cwe = defaultdict(int)
-        ransomware_count = 0
-        
-        recent_30_days = []
-        recent_90_days = []
-        now = datetime.now(timezone.utc)
-        
-        timeline = defaultdict(int)  # Monthly additions
-        
-        for vuln in vulnerabilities:
-            cve_id = vuln.get('cveID', '')
-            vendor = vuln.get('vendorProject', 'Unknown')
-            product = vuln.get('product', 'Unknown')
-            date_added = vuln.get('dateAdded', '')
-            cwes = vuln.get('cwes', [])
-            ransomware = vuln.get('knownRansomwareCampaignUse', 'Unknown')
-            
-            # Year CVE was published
-            try:
-                cve_year = cve_id.split('-')[1]
-                by_year_cve[cve_year] += 1
-            except (IndexError, ValueError):
-                pass
-            
-            # Year added to KEV
-            if date_added:
-                try:
-                    added_date = datetime.strptime(date_added, '%Y-%m-%d').replace(tzinfo=timezone.utc)
-                    by_year_added[str(added_date.year)] += 1
-                    
-                    # Monthly timeline
-                    month_key = added_date.strftime('%Y-%m')
-                    timeline[month_key] += 1
-                    
-                    # Recent additions
-                    days_ago = (now - added_date).days
-                    if days_ago <= 30:
-                        recent_30_days.append({
-                            'cve_id': cve_id,
-                            'vendor': vendor,
-                            'product': product,
-                            'date_added': date_added,
-                            'due_date': vuln.get('dueDate', ''),
-                            'ransomware': ransomware
-                        })
-                    if days_ago <= 90:
-                        recent_90_days.append({
-                            'cve_id': cve_id,
-                            'vendor': vendor,
-                            'product': product,
-                            'date_added': date_added
-                        })
-                except ValueError:
-                    pass
-            
-            # Vendor and product
-            by_vendor[vendor] += 1
-            by_product[f"{vendor} - {product}"] += 1
-            
-            # CWEs
-            for cwe in cwes:
-                by_cwe[cwe] += 1
-            
-            # Ransomware
-            if ransomware and ransomware.lower() not in ['unknown', 'no']:
-                ransomware_count += 1
-        
-        # Sort and limit top lists
-        top_vendors = sorted(by_vendor.items(), key=lambda x: x[1], reverse=True)[:20]
-        top_products = sorted(by_product.items(), key=lambda x: x[1], reverse=True)[:20]
-        top_cwes = sorted(by_cwe.items(), key=lambda x: x[1], reverse=True)[:20]
-        
-        # Sort recent by date
-        recent_30_days.sort(key=lambda x: x['date_added'], reverse=True)
-        recent_90_days.sort(key=lambda x: x['date_added'], reverse=True)
-        
-        analysis = {
-            'generated_at': datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z'),
-            'catalog_version': kev_data.get('catalogVersion', ''),
-            'total_kev_cves': len(vulnerabilities),
-            'statistics': {
-                'added_last_30_days': len(recent_30_days),
-                'added_last_90_days': len(recent_90_days),
-                'ransomware_associated': ransomware_count
-            },
-            'by_year_added': dict(sorted(by_year_added.items())),
-            'by_year_cve': dict(sorted(by_year_cve.items())),
-            'timeline': dict(sorted(timeline.items())),
-            'top_vendors': top_vendors,
-            'top_products': top_products,
-            'top_cwes': top_cwes,
-            'recent_additions': recent_30_days[:20]  # Last 20 for display
-        }
-        
-        output_file = self.output_dir / 'kev_analysis.json'
-        with open(output_file, 'w') as f:
-            json.dump(analysis, f, indent=2)
-        
-        print(f"  ✅ Generated {output_file.name}")
-        print(f"     Total KEV CVEs: {len(vulnerabilities):,}")
-        print(f"     Added last 30 days: {len(recent_30_days)}")
-        
-        return analysis
-    
-    def generate_risk_matrix(self):
-        """Generate bucketed CVSS × EPSS risk matrix data"""
-        print("📊 Generating risk matrix...")
-        
-        epss_data = self.load_epss_data()
-        self.load_cvss_data()
-        kev_data = self.load_kev_data()
-        
-        # Build KEV set for quick lookup
-        kev_set = set()
-        for vuln in kev_data.get('vulnerabilities', []):
-            cve_id = vuln.get('cveID', '')
-            if cve_id:
-                kev_set.add(cve_id)
-        
-        # CVSS severity bands
-        severity_bands = ['NONE', 'LOW', 'MEDIUM', 'HIGH', 'CRITICAL']
-        
-        # EPSS buckets
-        epss_buckets = ['0-0.1', '0.1-0.3', '0.3-0.5', '0.5-0.7', '0.7+']
-        
-        def get_epss_bucket(score):
-            if score < 0.1:
-                return '0-0.1'
-            elif score < 0.3:
-                return '0.1-0.3'
-            elif score < 0.5:
-                return '0.3-0.5'
-            elif score < 0.7:
-                return '0.5-0.7'
-            else:
-                return '0.7+'
-        
-        def get_severity_from_score(score):
-            if score == 0:
-                return 'NONE'
-            elif score < 4.0:
-                return 'LOW'
-            elif score < 7.0:
-                return 'MEDIUM'
-            elif score < 9.0:
-                return 'HIGH'
-            else:
-                return 'CRITICAL'
-        
-        # Initialize matrix
-        matrix = {}
-        for severity in severity_bands:
-            for epss_bucket in epss_buckets:
-                key = f"{severity}_{epss_bucket}"
-                matrix[key] = {
-                    'severity': severity,
-                    'epss_bucket': epss_bucket,
-                    'count': 0,
-                    'kev_count': 0
-                }
-        
-        # We need to correlate EPSS with CVSS scores
-        # Load yearly files to get CVSS scores per CVE
-        # For now, use the severity distribution from cvss_analysis
-        # This is a simplified approach - in production we'd scan nvd.json
-        
-        # For the matrix, we'll estimate based on overall distributions
-        # and the EPSS data we have
-        
-        # Actually, let's load the NVD data to get proper CVSS scores
-        if self.nvd_file.exists():
-            print("  📂 Loading NVD data for CVSS correlation...")
-            with open(self.nvd_file, 'r') as f:
-                nvd_data = json.load(f)
-            
-            for record in nvd_data:
-                cve_info = record.get('cve', {})
-                cve_id = cve_info.get('id', '')
-                
-                if cve_id not in epss_data:
-                    continue
-                
-                epss_score = epss_data[cve_id].get('epss_score', 0)
-                epss_bucket = get_epss_bucket(epss_score)
-                
-                # Get CVSS score - try v3.1, v3.0, v2.0, v4.0
-                cvss_score = None
-                metrics = cve_info.get('metrics', {})
-                
-                for version in ['cvssMetricV31', 'cvssMetricV30', 'cvssMetricV40', 'cvssMetricV2']:
-                    if version in metrics and metrics[version]:
-                        metric = metrics[version][0]
-                        cvss_data_inner = metric.get('cvssData', {})
-                        cvss_score = cvss_data_inner.get('baseScore')
-                        if cvss_score:
-                            break
-                
-                if cvss_score is None:
-                    continue
-                
-                severity = get_severity_from_score(cvss_score)
-                key = f"{severity}_{epss_bucket}"
-                
-                matrix[key]['count'] += 1
-                if cve_id in kev_set:
-                    matrix[key]['kev_count'] += 1
-        else:
-            print("  ⚠️  NVD file not found, using estimated data")
-        
-        # Convert to list format for easier charting
-        matrix_list = list(matrix.values())
-        
-        # Calculate totals
-        total_in_matrix = sum(m['count'] for m in matrix_list)
-        total_kev_in_matrix = sum(m['kev_count'] for m in matrix_list)
-        
-        analysis = {
-            'generated_at': datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z'),
-            'severity_bands': severity_bands,
-            'epss_buckets': epss_buckets,
-            'matrix': matrix_list,
-            'totals': {
-                'cves_in_matrix': total_in_matrix,
-                'kev_in_matrix': total_kev_in_matrix
-            }
-        }
-        
-        output_file = self.output_dir / 'risk_matrix.json'
-        with open(output_file, 'w') as f:
-            json.dump(analysis, f, indent=2)
-        
-        print(f"  ✅ Generated {output_file.name}")
-        print(f"     CVEs in matrix: {total_in_matrix:,}")
-        print(f"     KEV in matrix: {total_kev_in_matrix:,}")
-        
-        return analysis
-    
-    def generate_scoring_comparison(self):
-        """Generate comparison data for the Scoring Hub landing page"""
-        print("📊 Generating scoring comparison...")
-        
-        epss_data = self.load_epss_data()
-        kev_data = self.load_kev_data()
-        cvss_data = self.load_cvss_data()
-        
-        kev_vulnerabilities = kev_data.get('vulnerabilities', [])
-        kev_set = {v.get('cveID', '') for v in kev_vulnerabilities}
-        
-        # Count overlaps
-        epss_and_kev = sum(1 for cve_id in epss_data if cve_id in kev_set)
-        
-        # High EPSS in KEV
-        high_epss_in_kev = sum(
-            1 for cve_id, scores in epss_data.items() 
-            if cve_id in kev_set and scores.get('epss_score', 0) > 0.5
-        )
-        
-        comparison = {
-            'generated_at': datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z'),
-            'systems': {
-                'cvss': {
-                    'name': 'CVSS',
-                    'full_name': 'Common Vulnerability Scoring System',
-                    'description': 'Measures severity/impact of vulnerabilities',
-                    'question': 'How bad is it?',
-                    'total_scored': cvss_data.get('total_cves_with_cvss', 0),
-                    'source': 'NVD / Vendors',
-                    'update_frequency': 'Per CVE publication'
-                },
-                'epss': {
-                    'name': 'EPSS',
-                    'full_name': 'Exploit Prediction Scoring System',
-                    'description': 'Predicts likelihood of exploitation in 30 days',
-                    'question': 'Will it be exploited?',
-                    'total_scored': len(epss_data),
-                    'source': 'FIRST.org',
-                    'update_frequency': 'Daily'
-                },
-                'kev': {
-                    'name': 'KEV',
-                    'full_name': 'Known Exploited Vulnerabilities',
-                    'description': 'Confirmed actively exploited vulnerabilities',
-                    'question': 'Is it being exploited?',
-                    'total_scored': len(kev_vulnerabilities),
-                    'source': 'CISA',
-                    'update_frequency': 'As exploits are confirmed'
-                }
-            },
-            'overlaps': {
-                'epss_and_kev': epss_and_kev,
-                'high_epss_in_kev': high_epss_in_kev,
-                'kev_coverage_by_epss': round(epss_and_kev / len(kev_vulnerabilities) * 100, 1) if kev_vulnerabilities else 0
-            },
-            'insights': {
-                'epss_gt_05_not_kev': sum(
-                    1 for cve_id, scores in epss_data.items()
-                    if scores.get('epss_score', 0) > 0.5 and cve_id not in kev_set
-                ),
-                'kev_with_low_epss': sum(
-                    1 for cve_id in kev_set
-                    if cve_id in epss_data and epss_data[cve_id].get('epss_score', 0) < 0.1
-                )
-            }
-        }
-        
-        output_file = self.output_dir / 'scoring_comparison.json'
-        with open(output_file, 'w') as f:
-            json.dump(comparison, f, indent=2)
-        
-        print(f"  ✅ Generated {output_file.name}")
-        print(f"     EPSS ∩ KEV: {epss_and_kev:,}")
-        
-        return comparison
-    
-    def generate_all(self):
-        """Generate all scoring analysis files"""
-        print("\n📊 Generating Scoring Hub Analysis Files")
-        print("=" * 50)
-        
-        results = {}
-        results['epss'] = self.generate_epss_analysis()
-        results['kev'] = self.generate_kev_analysis()
-        results['risk_matrix'] = self.generate_risk_matrix()
-        results['comparison'] = self.generate_scoring_comparison()
-        
-        print("=" * 50)
-        print("✅ All scoring analysis files generated!")
-        
-        return results
-    
-    def generate_all_scoring_analysis(self):
-        """Alias for generate_all() - used by build.py"""
-        return self.generate_all()
-
-
-def main():
-    """Main entry point"""
-    analyzer = ScoringAnalyzer()
-    analyzer.generate_all()
-
-
-if __name__ == '__main__':
-    main()
diff --git a/src/cvedb/analysis/vendor.py b/src/cvedb/analysis/vendor.py
deleted file mode 100644
index fbd234c136c..00000000000
--- a/src/cvedb/analysis/vendor.py
+++ /dev/null
@@ -1,94 +0,0 @@
-#!/usr/bin/env python3
-"""
-Vendor Analysis Module
-Handles all vendor/CPE (Common Platform Enumeration) related data processing and analysis
-"""
-
-import json
-from pathlib import Path
-from datetime import datetime
-
-
-class VendorAnalyzer:
-    """Handles vendor/CPE-specific analysis and data processing"""
-    
-    def __init__(self, base_dir, cache_dir, data_dir):
-        self.base_dir = Path(base_dir)
-        self.cache_dir = Path(cache_dir)
-        self.data_dir = Path(data_dir)
-        self.current_year = datetime.now().year
-    
-    def generate_vendor_analysis(self, all_year_data):
-        """Generate CPE vendor analysis across all years"""
-        print(f"  🏢 Generating vendor/CPE analysis...")
-        
-        # Aggregate vendor data from all years
-        combined_vendors = {}
-        total_cves_with_vendors = 0
-        
-        for year_data in all_year_data:
-            if 'vendors' in year_data and 'cpe_vendors' in year_data['vendors']:
-                total_cves_with_vendors += year_data['vendors'].get('total_cves_with_vendors', 0)
-                
-                # Aggregate vendor counts
-                for vendor_entry in year_data['vendors']['cpe_vendors']:
-                    vendor_name = vendor_entry['name']
-                    count = vendor_entry['count']
-                    
-                    if vendor_name not in combined_vendors:
-                        combined_vendors[vendor_name] = {
-                            'name': vendor_name,
-                            'count': 0
-                        }
-                    
-                    combined_vendors[vendor_name]['count'] += count
-        
-        # Sort by count and get top vendors
-        top_vendors = sorted(combined_vendors.values(), key=lambda x: x['count'], reverse=True)
-        
-        vendor_analysis = {
-            'generated_at': datetime.now().isoformat(),
-            'total_cves_with_vendors': total_cves_with_vendors,
-            'total_unique_vendors': len(combined_vendors),
-            'top_vendors': top_vendors[:100],  # Top 100 vendors
-            'top_vendors_limited': top_vendors[:20]  # Top 20 for charts
-        }
-        
-        # Save to file
-        output_file = self.data_dir / 'vendor_analysis.json'
-        with open(output_file, 'w') as f:
-            json.dump(vendor_analysis, f, indent=2)
-        
-        print(f"  ✅ Generated vendor analysis with {len(combined_vendors):,} unique vendors")
-        return vendor_analysis
-    
-    def generate_current_year_vendor_analysis(self, current_year_data):
-        """Generate current year vendor analysis"""
-        print(f"    🏢 Generating current year vendor analysis...")
-        
-        # Extract vendor data from current year
-        vendor_data = current_year_data.get('vendors', {})
-        
-        if not vendor_data or 'cpe_vendors' not in vendor_data:
-            print(f"    ⚠️  No vendor data found for {self.current_year}")
-            return {}
-        
-        # Get current year vendors
-        current_year_vendors = vendor_data['cpe_vendors']
-        
-        current_year_vendor_analysis = {
-            'generated_at': datetime.now().isoformat(),
-            'year': self.current_year,
-            'total_cves_with_vendors': vendor_data.get('total_cves_with_vendors', 0),
-            'total_unique_vendors': len(current_year_vendors),
-            'top_vendors': current_year_vendors[:100],  # Top 100 vendors
-            'top_vendors_limited': current_year_vendors[:20]  # Top 20 for charts
-        }
-        
-        # Save current year analysis
-        current_year_file = self.data_dir / 'vendor_analysis_current_year.json'
-        with open(current_year_file, 'w') as f:
-            json.dump(current_year_vendor_analysis, f, indent=2)
-        
-        print(f"    ✅ Generated current year vendor analysis with {len(current_year_vendors)} vendors")
-        return current_year_vendor_analysis
diff --git a/src/cvedb/analysis/yearly.py b/src/cvedb/analysis/yearly.py
deleted file mode 100644
index 097e1ea5141..00000000000
--- a/src/cvedb/analysis/yearly.py
+++ /dev/null
@@ -1,371 +0,0 @@
-#!/usr/bin/env python3
-"""
-Yearly Analysis Module
-Handles year-by-year data processing and aggregation
-"""
-
-import json
-from pathlib import Path
-from datetime import datetime, timedelta
-
-
-class YearlyAnalyzer:
-    """Handles yearly data processing and aggregation"""
-    
-    def __init__(self, base_dir, cache_dir, data_dir, quiet=False):
-        self.quiet = quiet
-        self.base_dir = Path(base_dir)
-        self.cache_dir = Path(cache_dir)
-        self.data_dir = Path(data_dir)
-        self.current_year = datetime.now().year
-        self.available_years = list(range(1999, self.current_year + 1))
-    
-    def calculate_actual_ytd_count(self, year, day_of_year):
-        """Calculate actual YTD CVE count for a given year up to specific day of year"""
-        try:
-            # Import the CVE analyzer
-            from cve_years import CVEYearsAnalyzer
-            
-            # Load the raw CVE data
-            analyzer = CVEYearsAnalyzer(quiet=True)
-            analyzer.ensure_data_loaded()
-            
-            # Count CVEs published in the specified year up to the given day
-            ytd_count = 0
-            target_date = datetime(self.current_year, 1, 1) + timedelta(days=day_of_year - 1)
-            
-            # Load and process the JSON data
-            import json
-            with open(analyzer.data_file, 'r', encoding='utf-8') as f:
-                all_cves = json.load(f)
-            
-            for cve_data in all_cves:
-                try:
-                    # Check CVE status and skip rejected CVEs (same as fixed logic)
-                    vuln_status = cve_data.get('cve', {}).get('vulnStatus', '')
-                    if 'Rejected' in vuln_status:
-                        continue
-                    
-                    # Parse the published date (using same logic as cve_years.py)
-                    pub_date = analyzer.parse_cve_date(cve_data)
-                    if not pub_date:
-                        continue
-                    
-                    # Check if this CVE belongs to the target year and is within YTD period
-                    if (pub_date.year == year and 
-                        pub_date.replace(year=self.current_year) <= target_date):
-                        ytd_count += 1
-                        
-                except (KeyError, ValueError, TypeError):
-                    continue
-            
-            return ytd_count
-            
-        except Exception as e:
-            if not self.quiet:
-                print(f"⚠️  Warning: Could not calculate actual YTD for {year}: {e}")
-            # Fallback to the old flawed method as last resort
-            year_data = next((d for d in self.all_year_data if d.get('year') == year), None)
-            if year_data:
-                days_in_year = 366 if year % 4 == 0 else 365
-                return int((year_data['total_cves'] / days_in_year) * day_of_year)
-            return 0
-    
-    def generate_year_data_json(self):
-        """Generate JSON data files for all available years"""
-        if not self.quiet:
-            print("📊 Generating year data JSON files...")
-        
-        try:
-            # Import the years analyzer
-            from cve_years import CVEYearsAnalyzer
-            
-            if not self.quiet:
-                print("🔽 Initializing CVE data processing...")
-            analyzer = CVEYearsAnalyzer(quiet=self.quiet)
-            
-            # Generate data for all years
-            all_year_data = []
-            
-            for year in self.available_years:
-                print(f"  📅 Processing {year}...")
-                
-                try:
-                    year_data = analyzer.get_year_data(year)
-                    
-                    if year_data:
-                        # Save individual year file
-                        year_file = self.data_dir / f'cve_{year}.json'
-                        with open(year_file, 'w') as f:
-                            json.dump(year_data, f, indent=2)
-                        
-                        all_year_data.append(year_data)
-                        print(f"  ✅ Generated cve_{year}.json ({year_data.get('total_cves', 0):,} CVEs)")
-                    else:
-                        print(f"  ⚠️  No data available for {year}")
-                        
-                except Exception as e:
-                    print(f"  ❌ Failed to process {year}: {e}")
-                    continue
-            
-            print(f"✅ Generated {len(all_year_data)} year data files")
-            return all_year_data
-            
-        except ImportError as e:
-            print(f"❌ Failed to import CVE years analyzer: {e}")
-            print("📝 Creating placeholder data for development...")
-            return self.create_placeholder_year_data()
-        except Exception as e:
-            print(f"❌ Error generating year data: {e}")
-            return []
-    
-    def create_placeholder_year_data(self):
-        """Create placeholder year data for development/testing"""
-        print("📝 Creating placeholder year data...")
-        
-        all_year_data = []
-        
-        for year in self.available_years:
-            # Create basic placeholder data structure
-            year_data = {
-                'year': year,
-                'total_cves': max(100, (year - 1999) * 500),  # Increasing trend
-                'date_data': {
-                    'monthly_distribution': {str(i): max(10, (year - 1999) * 5) for i in range(1, 13)},
-                    'daily_analysis': {
-                        'total_days': 365,
-                        'days_with_cves': min(365, max(50, (year - 1999) * 10)),
-                        'avg_cves_per_day': max(1, (year - 1999) * 1.5),
-                        'max_cves_in_day': max(5, (year - 1999) * 3),
-                        'daily_counts': {}
-                    }
-                },
-                'vendors': {
-                    'total_cves_with_vendors': max(80, (year - 1999) * 400),
-                    'cpe_vendors': [
-                        {'name': 'Microsoft Corporation', 'count': max(20, (year - 1999) * 50)},
-                        {'name': 'Adobe Inc.', 'count': max(15, (year - 1999) * 30)},
-                        {'name': 'Oracle Corporation', 'count': max(10, (year - 1999) * 25)},
-                        {'name': 'Google LLC', 'count': max(8, (year - 1999) * 20)},
-                        {'name': 'Apple Inc.', 'count': max(5, (year - 1999) * 15)}
-                    ],
-                    'cna_assigners': [
-                        {'name': 'MITRE Corporation', 'count': max(50, (year - 1999) * 100)},
-                        {'name': 'Patchstack', 'count': max(20, (year - 1999) * 40)},
-                        {'name': 'Microsoft Corporation', 'count': max(15, (year - 1999) * 30)},
-                        {'name': 'Adobe Inc.', 'count': max(10, (year - 1999) * 25)},
-                        {'name': 'Wordfence', 'count': max(8, (year - 1999) * 20)}
-                    ]
-                },
-                'cvss': {
-                    'total_cves_with_cvss': max(70, (year - 1999) * 350),
-                    'v2.0': {
-                        'severity': {'LOW': 10, 'MEDIUM': 30, 'HIGH': 20},
-                        'scores': {'2.1': 5, '5.0': 15, '7.5': 10, '9.3': 8}
-                    },
-                    'v3.0': {
-                        'severity': {'LOW': 15, 'MEDIUM': 40, 'HIGH': 25, 'CRITICAL': 10},
-                        'scores': {'3.1': 8, '5.4': 20, '7.8': 15, '9.8': 12}
-                    },
-                    'v3.1': {
-                        'severity': {'LOW': 20, 'MEDIUM': 50, 'HIGH': 30, 'CRITICAL': 15},
-                        'scores': {'2.7': 10, '5.9': 25, '8.1': 18, '9.9': 15}
-                    }
-                },
-                'cwe': {
-                    'total_cves_with_cwe': max(60, (year - 1999) * 300),
-                    'top_cwes': [
-                        {'id': '79', 'name': 'Cross-site Scripting (XSS)', 'count': max(10, (year - 1999) * 20)},
-                        {'id': '89', 'name': 'SQL Injection', 'count': max(8, (year - 1999) * 15)},
-                        {'id': '20', 'name': 'Improper Input Validation', 'count': max(6, (year - 1999) * 12)},
-                        {'id': '22', 'name': 'Path Traversal', 'count': max(5, (year - 1999) * 10)},
-                        {'id': '352', 'name': 'Cross-Site Request Forgery (CSRF)', 'count': max(4, (year - 1999) * 8)}
-                    ]
-                }
-            }
-            
-            # Save individual year file
-            year_file = self.data_dir / f'cve_{year}.json'
-            with open(year_file, 'w') as f:
-                json.dump(year_data, f, indent=2)
-            
-            all_year_data.append(year_data)
-            print(f"  📝 Created placeholder cve_{year}.json")
-        
-        print(f"✅ Created {len(all_year_data)} placeholder year files")
-        return all_year_data
-    
-    def generate_cve_all_json(self, all_year_data):
-        """Generate overall CVE statistics across all years"""
-        print("  📊 Generating overall CVE statistics...")
-        
-        # Calculate totals and trends
-        total_cves = sum(year['total_cves'] for year in all_year_data)
-        years_with_data = len(all_year_data)
-        
-        # Find peak year
-        peak_year_data = max(all_year_data, key=lambda x: x['total_cves'])
-        peak_year = peak_year_data['year']
-        peak_count = peak_year_data['total_cves']
-        
-        # Calculate current year stats
-        current_year_data = next((year for year in all_year_data if year['year'] == self.current_year), None)
-        current_year_count = current_year_data['total_cves'] if current_year_data else 0
-        
-        # Calculate YoY growth (current vs previous year)
-        previous_year_data = next((year for year in all_year_data if year['year'] == self.current_year - 1), None)
-        previous_year_count = previous_year_data['total_cves'] if previous_year_data else 0
-        
-        yoy_growth = 0
-        if previous_year_count > 0:
-            yoy_growth = ((current_year_count - previous_year_count) / previous_year_count) * 100
-        
-        # Calculate average CVEs per day for current year
-        avg_cves_per_day = 0
-        if current_year_data:
-            days_elapsed = datetime.now().timetuple().tm_yday
-            avg_cves_per_day = current_year_count / days_elapsed if days_elapsed > 0 else 0
-        
-        # Create yearly trend data for charts
-        yearly_data = []
-        for year_data in sorted(all_year_data, key=lambda x: x['year']):
-            yearly_data.append({
-                'year': year_data['year'],
-                'count': year_data['total_cves']
-            })
-        
-        cve_all_data = {
-            'generated_at': datetime.now().isoformat(),
-            'total_cves': total_cves,
-            'years_covered': years_with_data,
-            'current_year': self.current_year,
-            'current_year_cves': current_year_count,
-            'peak_year': peak_year,
-            'peak_count': peak_count,
-            'yoy_growth_rate': round(yoy_growth, 1),
-            'avg_cves_per_day': round(avg_cves_per_day, 1),
-            'yearly_trend': yearly_data
-        }
-        
-        # Save to file
-        output_file = self.data_dir / 'cve_all.json'
-        with open(output_file, 'w') as f:
-            json.dump(cve_all_data, f, indent=2)
-        
-        print(f"  ✅ Generated cve_all.json with {total_cves:,} total CVEs")
-        return cve_all_data
-    
-    def generate_growth_analysis(self, all_year_data):
-        """Generate growth trend analysis across all years"""
-        print(f"  📈 Generating growth trend analysis...")
-        
-        # Get current date for year-to-date calculations
-        current_date = datetime.now()
-        current_year = current_date.year
-        day_of_year = current_date.timetuple().tm_yday
-        
-        # Calculate year-over-year growth rates
-        growth_data = []
-        
-        for i, year_data in enumerate(sorted(all_year_data, key=lambda x: x['year'])):
-            if i == 0:
-                # First year, no previous data for comparison
-                growth_data.append({
-                    'year': year_data['year'],
-                    'cves': year_data['total_cves'],
-                    'growth_rate': 0,
-                    'growth_absolute': 0,
-                    'is_ytd': year_data['year'] == current_year
-                })
-            else:
-                prev_year_data = sorted(all_year_data, key=lambda x: x['year'])[i-1]
-                prev_count = prev_year_data['total_cves']
-                current_count = year_data['total_cves']
-                
-                # For current year, we need to calculate YTD comparison
-                if year_data['year'] == current_year:
-                    # Calculate proper YTD comparison: current YTD vs same period last year
-                    # We need to get CVEs from previous year up to the same day of year
-                    
-                    # First, calculate projected full year for growth rate
-                    days_in_year = 366 if current_year % 4 == 0 else 365
-                    projected_full_year = (current_count / day_of_year) * days_in_year
-                    
-                    # Calculate ACTUAL YTD count for previous year using same date filtering
-                    # This fixes the major bug of using uniform distribution assumption
-                    prev_year_ytd_actual = self.calculate_actual_ytd_count(current_year - 1, day_of_year)
-                    
-                    # Calculate true YTD comparison (current YTD vs previous year actual same period)
-                    # This should be the PRIMARY growth rate for YTD data
-                    ytd_comparison = 0
-                    if prev_year_ytd_actual > 0:
-                        ytd_comparison = ((current_count - prev_year_ytd_actual) / prev_year_ytd_actual) * 100
-                    
-                    # Calculate projected full year for reference but don't use as main growth rate
-                    projected_full_year = (current_count / day_of_year) * days_in_year
-                    
-                    growth_data.append({
-                        'year': year_data['year'],
-                        'cves': current_count,
-                        'growth_rate': round(ytd_comparison, 1),  # Use YTD comparison as main growth rate!
-                        'growth_absolute': int(current_count - prev_year_ytd_actual),  # YTD absolute change
-                        'is_ytd': True,
-                        'projected_full_year': int(projected_full_year),
-                        'ytd_vs_prev_full': round(((current_count - prev_count) / prev_count) * 100, 1) if prev_count > 0 else 0,
-                        'ytd_vs_prev_ytd': round(ytd_comparison, 1),
-                        'prev_year_ytd_actual': int(prev_year_ytd_actual)
-                    })
-                else:
-                    # Normal year-over-year calculation for completed years
-                    growth_rate = 0
-                    if prev_count > 0:
-                        growth_rate = ((current_count - prev_count) / prev_count) * 100
-                    
-                    growth_data.append({
-                        'year': year_data['year'],
-                        'cves': current_count,
-                        'growth_rate': round(growth_rate, 1),
-                        'growth_absolute': current_count - prev_count,
-                        'is_ytd': False
-                    })
-        
-        # Calculate moving averages (exclude current year from averages since it's YTD)
-        window_size = 3
-        for i, entry in enumerate(growth_data):
-            if entry.get('is_ytd', False):
-                # For YTD data, don't calculate moving average
-                entry['growth_rate_3yr_avg'] = entry['growth_rate']
-            elif i >= window_size - 1:
-                # Only include completed years in moving average
-                window_rates = [growth_data[j]['growth_rate'] for j in range(i - window_size + 1, i + 1) 
-                               if not growth_data[j].get('is_ytd', False)]
-                if window_rates:
-                    entry['growth_rate_3yr_avg'] = round(sum(window_rates) / len(window_rates), 1)
-                else:
-                    entry['growth_rate_3yr_avg'] = entry['growth_rate']
-            else:
-                entry['growth_rate_3yr_avg'] = entry['growth_rate']
-        
-        # Filter out YTD data for aggregate statistics since it's not comparable
-        completed_years = [entry for entry in growth_data[1:] if not entry.get('is_ytd', False)]
-        
-        # Get current year data for YTD comparison
-        current_year_data = next((entry for entry in growth_data if entry.get('is_ytd', False)), None)
-        
-        growth_analysis = {
-            'generated_at': datetime.now().isoformat(),
-            'growth_data': growth_data,
-            'avg_annual_growth': round(sum(entry['growth_rate'] for entry in completed_years) / len(completed_years), 1) if completed_years else 0,
-            'highest_growth_year': max(completed_years, key=lambda x: x['growth_rate']) if completed_years else None,
-            'lowest_growth_year': min(completed_years, key=lambda x: x['growth_rate']) if completed_years else None,
-            'current_year_ytd': current_year_data
-        }
-        
-        # Save to file
-        output_file = self.data_dir / 'growth_analysis.json'
-        with open(output_file, 'w') as f:
-            json.dump(growth_analysis, f, indent=2)
-        
-        if not self.quiet:
-            print(f"  ✅ Generated growth analysis with {len(growth_data)} years of data")
-        return growth_analysis
diff --git a/src/cvedb/analysis/years.py b/src/cvedb/analysis/years.py
deleted file mode 100644
index 3c2c98c6d47..00000000000
--- a/src/cvedb/analysis/years.py
+++ /dev/null
@@ -1,653 +0,0 @@
-#!/usr/bin/env python3
-"""
-CVE Years Analyzer
-Processes CVE data from JSONL file and generates yearly analysis data
-Handles historical data (1999-2016) and individual years (2017-present)
-"""
-
-import json
-from datetime import datetime, timedelta
-from pathlib import Path
-from collections import Counter, defaultdict
-from urllib.parse import urlparse
-from cvedb.ingest.download_cve_data import CVEDataDownloader
-
-class CVEYearsAnalyzer:
-    """Analyzes CVE data by year and generates structured data for visualization"""
-    
-    def __init__(self, cache_dir=None, quiet=False):
-        self.quiet = quiet
-        self.base_dir = Path(__file__).parent
-        self.downloader = CVEDataDownloader(cache_dir=cache_dir, quiet=quiet)
-        self.data_file = None
-        self.year_data_cache = {}
-        
-        # CNA mapping data for proper name resolution
-        self.cna_list = {}
-        self.cna_name_map = {}
-        
-        if not self.quiet:
-            print(f"📊 CVE Years Analyzer Initialized")
-            print(f"📅 Target coverage: 1999-{datetime.now().year}")
-
-    def extract_severity_info(self, cve_data):
-        """Extract normalized CVSS severity and score from a CVE record.
-
-        This is intentionally conservative and mirrors the original notebook
-        logic: prefer v3.1, then v3.0, then v2.0, and fall back to
-        "UNKNOWN"/0.0 when nothing is available.
-        """
-
-        def _normalize(severity):
-            if not severity:
-                return "UNKNOWN"
-            sev = str(severity).strip().upper()
-            # Common variants across NVD data
-            if sev in {"CRITICAL", "CRIT"}:
-                return "CRITICAL"
-            if sev in {"HIGH", "H"}:
-                return "HIGH"
-            if sev in {"MEDIUM", "MED"}:
-                return "MEDIUM"
-            if sev in {"LOW", "L"}:
-                return "LOW"
-            if sev in {"NONE", "N"}:
-                return "NONE"
-            return sev or "UNKNOWN"
-
-        # NVD 1.1+ style: metrics are under cve.metrics
-        metrics = cve_data.get("cve", {}).get("metrics", {})
-
-        # Helper to extract from a metrics list by key
-        def _from_metrics(key, version_label):
-            entries = metrics.get(key) or []
-            if not entries:
-                return None
-            # Take the first entry as representative
-            metric = entries[0].get("cvssData") or {}
-            score = metric.get("baseScore")
-            severity = metric.get("baseSeverity")
-            try:
-                score_val = float(score)
-            except Exception:
-                score_val = 0.0
-            return {
-                "version": version_label,
-                "severity": _normalize(severity),
-                "score": score_val,
-            }
-
-        # Preference order: v4.0 (if present), then v3.1, v3.0, v2.0
-        for key, label in (
-            ("cvssMetricV40", "v4.0"),
-            ("cvssMetricV31", "v3.1"),
-            ("cvssMetricV30", "v3.0"),
-            ("cvssMetricV2", "v2.0"),
-        ):
-            info = _from_metrics(key, label)
-            if info is not None:
-                return info
-
-        # Fallback: some legacy records may expose a flatter shape; be lenient
-        try:
-            base_metric = (
-                cve_data.get("impact", {})
-                .get("baseMetricV3", {})
-                .get("cvssV3", {})
-            )
-            if base_metric:
-                score = base_metric.get("baseScore", 0.0)
-                severity = base_metric.get("baseSeverity", "UNKNOWN")
-                return {
-                    "version": "v3.0",
-                    "severity": _normalize(severity),
-                    "score": float(score) if score is not None else 0.0,
-                }
-        except Exception:
-            pass
-
-        # Ultimate fallback
-        return {"version": "unknown", "severity": "UNKNOWN", "score": 0.0}
-
-    def parse_cve_date(self, cve_data):
-        """Extract a publication date for a CVE record.
-
-        Tries multiple known NVD-style shapes and falls back to lastModified or
-        the year embedded in the CVE ID if necessary.
-        """
-
-        # Prioritize cve['published'] and similar keys (NVD JSONL structure)
-        for key in ("published", "publishedDate", "publishDate"):
-            date_str = cve_data.get("cve", {}).get(key)
-            if not date_str:
-                date_str = cve_data.get(key)
-            if date_str:
-                try:
-                    # Handle ISO8601 with or without fractional seconds
-                    return datetime.fromisoformat(date_str.replace("Z", "+00:00"))
-                except Exception:
-                    pass
-
-        # Try lastModified style keys as a fallback
-        for key in ("lastModified", "lastModifiedDate"):
-            date_str = cve_data.get(key)
-            if not date_str:
-                date_str = cve_data.get("cve", {}).get(key)
-            if date_str:
-                try:
-                    return datetime.fromisoformat(date_str.replace("Z", "+00:00"))
-                except Exception:
-                    pass
-
-        # Legacy / alternative layouts: sometimes dates are nested under cve
-        # metadata or configurations – keep this best-effort and very defensive.
-        try:
-            meta = cve_data.get("cve", {}).get("CVE_data_meta", {})
-            # Some feeds include date in a "DATE_PUBLIC"-style field; rarely used.
-            for key in ("DATE_PUBLIC", "date_public", "date"):
-                date_str = meta.get(key)
-                if date_str:
-                    try:
-                        return datetime.fromisoformat(date_str.replace("Z", "+00:00"))
-                    except Exception:
-                        pass
-        except Exception:
-            pass
-
-        # As a last resort, derive a year from the CVE ID itself; this at least
-        # lets us bucket by year when no explicit published date is available.
-        try:
-            cve_id = cve_data.get("cve", {}).get("id") or \
-                     cve_data.get("cve", {}).get("CVE_data_meta", {}).get("ID", "")
-            if isinstance(cve_id, str) and cve_id.startswith("CVE-"):
-                parts = cve_id.split("-")
-                if len(parts) >= 3:
-                    year = int(parts[1])
-                    # Use January 1st of that year as a synthetic publication date
-                    return datetime(year, 1, 1)
-        except Exception:
-            pass
-
-        # If everything fails, return None so callers can skip this CVE
-        return None
-    
-    def ensure_data_loaded(self):
-        """Ensure CVE data is downloaded and available"""
-        if self.data_file is None:
-            if not self.quiet:
-                print("🔽 Ensuring CVE data source is available...")
-            self.data_file = self.downloader.ensure_data_available()
-            if not self.quiet:
-                print(f"✅ Data source ready: {self.data_file}")
-        
-        if not hasattr(self, 'all_cves') or self.all_cves is None:
-            if not self.quiet:
-                print("  📊 Reading NVD JSON data into memory...")
-            with open(self.data_file, 'r', encoding='utf-8') as f:
-                try:
-                    self.all_cves = json.load(f)
-                    if not self.quiet:
-                        print(f"  ✅ Loaded {len(self.all_cves):,} CVE records")
-                except json.JSONDecodeError as e:
-                    print(f"  ❌ Failed to parse JSON: {e}")
-                    self.all_cves = []
-
-        # Lazy-load EPSS mapping (best-effort)
-        if not hasattr(self, 'epss_mapping'):
-            try:
-                epss_json = self.downloader.epss_parsed_file
-                if not epss_json.exists():
-                    epss_json = self.downloader.parse_epss_csv()
-                if epss_json and Path(epss_json).exists():
-                    with open(epss_json, 'r', encoding='utf-8') as ef:
-                        self.epss_mapping = json.load(ef)
-                else:
-                    self.epss_mapping = {}
-            except Exception:
-                self.epss_mapping = {}
-
-        # Lazy-load KEV mapping (best-effort)
-        if not hasattr(self, 'kev_mapping'):
-            try:
-                kev_json = self.downloader.kev_parsed_file
-                if not kev_json.exists():
-                    kev_json = self.downloader.parse_kev_json()
-                if kev_json and Path(kev_json).exists():
-                    with open(kev_json, 'r', encoding='utf-8') as kf:
-                        raw = json.load(kf)
-                        self.kev_mapping = {k: bool(v) for k, v in raw.items()}
-                else:
-                    self.kev_mapping = {}
-            except Exception:
-                self.kev_mapping = {}
-
-    def _init_year_stats(self):
-        """Initialize statistics counters for a year"""
-        return {
-            'monthly_counts': [0] * 12,
-            'daily_counts': {},
-            'cvss_data': {
-                'v2.0': {'severity_counts': Counter(), 'score_distribution': Counter(), 'total': 0},
-                'v3.0': {'severity_counts': Counter(), 'score_distribution': Counter(), 'total': 0},
-                'v3.1': {'severity_counts': Counter(), 'score_distribution': Counter(), 'total': 0},
-                'v4.0': {'severity_counts': Counter(), 'score_distribution': Counter(), 'total': 0},
-                'unknown': {'severity_counts': Counter(), 'score_distribution': Counter(), 'total': 0}
-            },
-            'vendor_counts': Counter(),
-            'cwe_counts': Counter(),
-            'status_counts': Counter(),
-            'tag_counts': Counter(),
-            'reference_tag_counts': Counter(),
-            'cpe_vendor_counts': Counter(),
-            'epss_buckets': {'epss_gt_0_1': 0, 'epss_gt_0_5': 0, 'epss_gt_0_9': 0},
-            'kev_count': 0,
-            'total_cves': 0
-        }
-
-    def _update_year_stats(self, stats, cve_data, pub_date):
-        """Update year statistics with data from a single CVE"""
-        cve_id = cve_data.get('cve', {}).get('id', '')
-        vuln_status = cve_data.get('cve', {}).get('vulnStatus', '')
-        
-        stats['total_cves'] += 1
-        
-        # Monthly/Daily distribution
-        month_idx = pub_date.month - 1
-        stats['monthly_counts'][month_idx] += 1
-        date_str = pub_date.strftime('%Y-%m-%d')
-        stats['daily_counts'][date_str] = stats['daily_counts'].get(date_str, 0) + 1
-        
-        # CVSS data
-        severity_info = self.extract_severity_info(cve_data)
-        cvss_version = severity_info['version']
-        severity = severity_info['severity']
-        score = severity_info['score']
-        
-        cvss_target = stats['cvss_data'].get(cvss_version, stats['cvss_data']['unknown'])
-        cvss_target['severity_counts'][severity] += 1
-        score_key = round(float(score), 1) if score > 0 else 0.0
-        cvss_target['score_distribution'][score_key] += 1
-        cvss_target['total'] += 1
-        
-        # EPSS
-        if hasattr(self, 'epss_mapping'):
-            epss = self.epss_mapping.get(cve_id)
-            if epss:
-                epss_score = float(epss.get('epss_score') or 0.0)
-                if epss_score > 0.1: stats['epss_buckets']['epss_gt_0_1'] += 1
-                if epss_score > 0.5: stats['epss_buckets']['epss_gt_0_5'] += 1
-                if epss_score > 0.9: stats['epss_buckets']['epss_gt_0_9'] += 1
-
-        # KEV
-        if hasattr(self, 'kev_mapping') and self.kev_mapping.get(cve_id):
-            stats['kev_count'] += 1
-            
-        # Additional metadata
-        stats['status_counts'][vuln_status] += 1
-        
-        for tag in cve_data.get('cve', {}).get('cveTags', []):
-            tag_name = tag if isinstance(tag, str) else tag.get('tag')
-            if tag_name: stats['tag_counts'][tag_name] += 1
-            
-        for ref in cve_data.get('cve', {}).get('references', []):
-            for tag in ref.get('tags', []):
-                stats['reference_tag_counts'][tag] += 1
-                
-        for vendor in self.extract_cpe_vendor_info(cve_data):
-            stats['cpe_vendor_counts'][vendor] += 1
-            
-        for vendor in self.extract_vendor_info(cve_data):
-            stats['vendor_counts'][vendor] += 1
-            
-        for cwe in self.extract_cwe_info(cve_data):
-            stats['cwe_counts'][cwe] += 1
-
-    def _finalize_year_data(self, year, stats):
-        """Finalize year statistics into the final JSON structure"""
-        daily_analysis = {
-            'total_days': 0, 'avg_per_day': 0,
-            'highest_day': {'date': '', 'count': 0},
-            'lowest_day': {'date': '', 'count': 0},
-            'daily_counts': self.create_complete_daily_array(stats['daily_counts'], year)
-        }
-        
-        non_zero_days = {k: v for k, v in daily_analysis['daily_counts'].items() if v > 0}
-        if non_zero_days:
-            values = list(non_zero_days.values())
-            daily_analysis.update({
-                'total_days': len(non_zero_days),
-                'avg_per_day': round(sum(values) / len(values), 2),
-                'highest_day': {'date': max(non_zero_days, key=non_zero_days.get), 'count': max(values)},
-                'lowest_day': {'date': min(non_zero_days, key=non_zero_days.get), 'count': min(values)}
-            })
-
-        return {
-            'year': year,
-            'total_cves': stats['total_cves'],
-            'date_data': {
-                'monthly_distribution': {str(i+1): stats['monthly_counts'][i] for i in range(12)},
-                'daily_analysis': daily_analysis
-            },
-            'cvss': {
-                **{v: {'total': d['total'], 'severity_distribution': dict(d['severity_counts']), 
-                       'score_distribution': dict(d['score_distribution'])}
-                   for v, d in stats['cvss_data'].items() if d['total'] > 0},
-                'epss_summary': stats['epss_buckets']
-            },
-            'kev': {'kev_count': stats['kev_count']},
-            'vendors': {
-                'cna_assigners': [{'name': v, 'count': c} for v, c in stats['vendor_counts'].most_common(20)],
-                'cpe_vendors': [{'name': v, 'count': c} for v, c in stats['cpe_vendor_counts'].most_common(20)]
-            },
-            'cwe': {'top_cwes': [{'cwe': c, 'count': count} for c, count in stats['cwe_counts'].most_common(20)]},
-            'metadata': {
-                'vulnerability_status': [{'status': s, 'count': c} for s, c in stats['status_counts'].most_common(10)],
-                'cve_tags': [{'tag': t, 'count': c} for t, c in stats['tag_counts'].most_common(10)],
-                'reference_tags': [{'tag': t, 'count': c} for t, c in stats['reference_tag_counts'].most_common(20)]
-            },
-            'processing_stats': {
-                'processed_at': datetime.now().isoformat(),
-                'data_source': str(self.data_file)
-            }
-        }
-
-    def process_years(self, years):
-        """Process multiple years in a single pass over the CVE data"""
-        self.ensure_data_loaded()
-        if not self.all_cves:
-            return {year: self.create_empty_year_data(year) for year in years}
-
-        target_years = set(years)
-        year_stats = {year: self._init_year_stats() for year in target_years}
-        
-        if not self.quiet:
-            print(f"📊 Processing {len(target_years)} years in a single pass...")
-
-        for idx, cve_data in enumerate(self.all_cves):
-            if not self.quiet and idx % 25000 == 0 and idx > 0:
-                print(f"  🔍 Scanning CVEs: {idx:,} / {len(self.all_cves):,}")
-            
-            pub_date = self.parse_cve_date(cve_data)
-            if not pub_date: continue
-            
-            year = pub_date.year
-            if year in target_years:
-                vuln_status = cve_data.get('cve', {}).get('vulnStatus', '')
-                if 'Rejected' not in vuln_status:
-                    self._update_year_stats(year_stats[year], cve_data, pub_date)
-
-        for year in target_years:
-            self.year_data_cache[year] = self._finalize_year_data(year, year_stats[year])
-        
-        return self.year_data_cache
-
-    def process_year_data(self, year):
-        """Process CVE data for a specific year"""
-        if year in self.year_data_cache:
-            return self.year_data_cache[year]
-        return self.process_years([year])[year]
-
-    def create_complete_daily_array(self, daily_counts, year):
-        """Create complete daily array with zeros for missing dates to prevent UI issues"""
-        try:
-            # Create date range for the entire year
-            start_date = datetime(year, 1, 1)
-            if year == datetime.now().year:
-                # For current year, only go up to today
-                end_date = datetime.now().date()
-            else:
-                # For past years, include the entire year
-                end_date = datetime(year, 12, 31).date()
-            
-            complete_daily_counts = {}
-            current_date = start_date.date()
-            
-            while current_date <= end_date:
-                date_str = current_date.strftime('%Y-%m-%d')
-                complete_daily_counts[date_str] = daily_counts.get(date_str, 0)
-                current_date += timedelta(days=1)
-            
-            return complete_daily_counts
-            
-        except Exception as e:
-            print(f"⚠️  Warning: Could not create complete daily array: {e}")
-            return daily_counts
-    
-    def extract_cwe_info(self, cve_data):
-        """Extract CWE (Common Weakness Enumeration) information from CVE data"""
-        cwes = []
-        try:
-            # Look for CWE information in the weaknesses section
-            weaknesses = cve_data.get('cve', {}).get('weaknesses', [])
-            
-            for weakness in weaknesses:
-                descriptions = weakness.get('description', [])
-                for desc in descriptions:
-                    if desc.get('lang') == 'en':  # English descriptions only
-                        cwe_value = desc.get('value', '')
-                        if cwe_value and cwe_value.startswith('CWE-'):
-                            # Filter out "Missing" CWEs as per original notebook
-                            if 'Missing_' not in cwe_value:
-                                cwes.append(cwe_value)
-            
-            return cwes
-            
-        except Exception:
-            return []
-    
-    def extract_identifier_info(self, cve_data):
-        """Extract CVE identifiers and references information (secure hostname check)"""
-        identifiers = []
-        try:
-            # Extract references/identifiers from the CVE data
-            references = cve_data.get('cve', {}).get('references', [])
-            for ref in references:
-                url = ref.get('url', '')
-                if url:
-                    try:
-                        parsed = urlparse(url)
-                        hostname = parsed.hostname or ''
-                        if hostname == 'github.com' or hostname.endswith('.github.com'):
-                            identifiers.append('GitHub')
-                        elif hostname == 'nvd.nist.gov':
-                            identifiers.append('NVD')
-                        elif hostname == 'cve.mitre.org':
-                            identifiers.append('MITRE')
-                        elif hostname == 'security-tracker.debian.org':
-                            identifiers.append('Debian')
-                        elif hostname == 'access.redhat.com':
-                            identifiers.append('Red Hat')
-                        elif hostname == 'ubuntu.com' or hostname.endswith('.ubuntu.com'):
-                            identifiers.append('Ubuntu')
-                        elif 'bugzilla' in hostname:
-                            identifiers.append('Bugzilla')
-                        elif hostname == 'exploit-db.com' or hostname == 'www.exploit-db.com':
-                            identifiers.append('Exploit-DB')
-                        else:
-                            if hostname:
-                                identifiers.append(hostname)
-                    except Exception:
-                        pass
-            return identifiers
-        except Exception:
-            return []
-    
-    def extract_cpe_vendor_info(self, cve_data):
-        """Extract vendor information from CPE (Common Platform Enumeration) data"""
-        vendors = []
-        try:
-            # Look in cve.configurations for CPE data (it's a list, not dict with nodes)
-            configurations = cve_data.get('cve', {}).get('configurations', [])
-            
-            # configurations is a list of configuration objects
-            for config in configurations:
-                # Each config has nodes
-                nodes = config.get('nodes', [])
-                for node in nodes:
-                    cpe_matches = node.get('cpeMatch', [])
-                    for cpe in cpe_matches:
-                        # The CPE URI is in 'criteria' field, not 'cpe23Uri'
-                        cpe_uri = cpe.get('criteria', '')
-                        if not cpe_uri:
-                            # Fallback to cpe23Uri if criteria is empty
-                            cpe_uri = cpe.get('cpe23Uri', '')
-                        
-                        if cpe_uri and cpe_uri.startswith('cpe:2.3:'):
-                            # Parse CPE format: cpe:2.3:part:vendor:product:version:...
-                            parts = cpe_uri.split(':')
-                            if len(parts) > 3:
-                                vendor = parts[3].replace('_', ' ').title()
-                                if vendor and vendor.lower() not in ['*', 'n/a', 'unknown', '-', '']:
-                                    vendors.append(vendor)
-            
-            return list(set(vendors))  # Remove duplicates
-            
-        except Exception:
-            return []
-
-    def extract_vendor_info(self, cve_data):
-        """Extract CNA (CVE Numbering Authority) information for this CVE.
-
-        This extracts only the actual CNA that assigned the CVE ID, not the
-        affected vendors/products (which are in CPE data).
-        """
-        vendors = set()
-
-        try:
-            cve = cve_data.get("cve", {})
-
-            # Preferred: CNA/container shortName or name
-            cna_container = cve.get("cnaContainer", {})
-            provider = cna_container.get("providerMetadata", {})
-            for key in ("shortName", "name"):
-                name = provider.get(key)
-                if isinstance(name, str) and name.strip():
-                    vendors.add(name.strip())
-
-            # Legacy / alternate fields
-            for key in ("assignerShortName", "assigner"):
-                name = cve.get(key)
-                if isinstance(name, str) and name.strip():
-                    vendors.add(name.strip())
-
-            # NOTE: Do NOT include CPE vendors here - those are affected products,
-            # not the CNA that assigned the CVE. CPE vendors are tracked separately
-            # in extract_cpe_vendor_info() and cpe_vendors field.
-
-        except Exception:
-            # Best-effort only
-            pass
-
-        return list(vendors)
-    
-    def get_year_data(self, year):
-        """Main method to get processed data for a specific year"""
-        current_year = datetime.now().year
-        
-        if year < 1999 or year > current_year:
-            raise ValueError(f"Year {year} is outside valid range (1999-{current_year})")
-        
-        return self.process_year_data(year)
-    
-    def get_all_years_data(self):
-        """Get data for all available years"""
-        current_year = datetime.now().year
-        all_data = {}
-        
-        print(f"📊 Processing all years (1999-{current_year})...")
-        
-        for year in range(1999, current_year + 1):
-            try:
-                all_data[year] = self.get_year_data(year)
-            except Exception as e:
-                print(f"⚠️  Failed to process {year}: {e}")
-                # Create empty data structure for failed years
-                all_data[year] = {
-                    'year': year,
-                    'total_cves': 0,
-                    'monthly_counts': [0] * 12,
-                    'severity_distribution': {},
-                    'top_vendors': [],
-                    'top_cwes': [],
-                    'error': str(e)
-                }
-        
-        return all_data
-    
-    def generate_summary_stats(self):
-        """Generate overall summary statistics"""
-        self.ensure_data_loaded()
-        
-        print("📊 Generating summary statistics...")
-        
-        total_cves = 0
-        year_counts = Counter()
-        severity_counts = Counter()
-        
-        with open(self.data_file, 'r', encoding='utf-8') as f:
-            for line in f:
-                line = line.strip()
-                if not line:
-                    continue
-                
-                try:
-                    cve_data = json.loads(line)
-                    cve_id = cve_data.get('cve', {}).get('CVE_data_meta', {}).get('ID', '')
-                    
-                    if cve_id.startswith('CVE-'):
-                        total_cves += 1
-                        
-                        # Count by year
-                        pub_date = self.parse_cve_date(cve_data)
-                        if pub_date:
-                            year_counts[pub_date.year] += 1
-                        else:
-                            # Fallback to CVE ID year
-                            year = int(cve_id.split('-')[1])
-                            year_counts[year] += 1
-                        
-                        # Count by severity
-                        severity_info = self.extract_severity_info(cve_data)
-                        severity_counts[severity_info['severity']] += 1
-                
-                except (json.JSONDecodeError, KeyError, ValueError, IndexError):
-                    continue
-        
-        return {
-            'total_cves': total_cves,
-            'year_range': (min(year_counts.keys()), max(year_counts.keys())),
-            'years_covered': len(year_counts),
-            'year_distribution': dict(sorted(year_counts.items())),
-            'severity_distribution': dict(severity_counts.most_common()),
-            'generated_at': datetime.now().isoformat()
-        }
-
-def main():
-    """Main entry point for standalone testing"""
-    import argparse
-    
-    parser = argparse.ArgumentParser(description="Analyze CVE data by year")
-    parser.add_argument('--year', type=int, help='Analyze specific year')
-    parser.add_argument('--summary', action='store_true', help='Generate summary statistics')
-    parser.add_argument('--all-years', action='store_true', help='Process all years')
-    
-    args = parser.parse_args()
-    
-    analyzer = CVEYearsAnalyzer()
-    
-    if args.summary:
-        stats = analyzer.generate_summary_stats()
-        print(json.dumps(stats, indent=2))
-    elif args.year:
-        year_data = analyzer.get_year_data(args.year)
-        print(json.dumps(year_data, indent=2, default=str))
-    elif args.all_years:
-        all_data = analyzer.get_all_years_data()
-        print(f"Processed {len(all_data)} years")
-        for year, data in sorted(all_data.items()):
-            print(f"  {year}: {data['total_cves']} CVEs")
-    else:
-        print("Please specify --year, --summary, or --all-years")
-
-if __name__ == '__main__':
-    main()
diff --git a/src/cvedb/cna/README.md b/src/cvedb/cna/README.md
deleted file mode 100644
index fad1e6adc8e..00000000000
--- a/src/cvedb/cna/README.md
+++ /dev/null
@@ -1,401 +0,0 @@
-# CNA Scorecard Pipeline
-
-A modern, production-ready Python pipeline for analyzing CVE data quality and generating CNA (CVE Numbering Authority) performance scorecards.
-
-## Overview
-
-The CNA Scorecard Pipeline processes CVE (Common Vulnerabilities and Exposures) data to evaluate how well CNAs provide complete and useful vulnerability information. It generates comprehensive reports, rankings, and visualizations to help improve CVE data quality across the ecosystem.
-
-### Key Features
-
-- **Modular Architecture**: Clean separation of concerns with dedicated modules for ingestion, scoring, aggregation, and output
-- **Comprehensive Scoring**: Multi-category scoring system evaluating foundational completeness, root cause analysis, software identification, severity context, and patch information
-- **Flexible Configuration**: Centralized configuration management with customizable scoring rules and field mappings
-- **Robust Error Handling**: Graceful error handling with detailed logging and recovery mechanisms
-- **CI/CD Ready**: Single-command execution with comprehensive testing and validation
-- **Production Quality**: Type hints, comprehensive documentation, and modern Python best practices
-
-## Quick Start
-
-### Prerequisites
-
-- Python 3.8 or higher
-- CVE data files in JSON format (typically from the CVE Project repository)
-
-### Installation
-
-1. Clone the repository and navigate to the pipeline directory:
-```bash
-cd cnascorecard_pipeline
-```
-
-2. Install dependencies:
-```bash
-pip install -r requirements.txt
-```
-
-3. Verify installation by running tests:
-```bash
-pytest
-```
-
-### Basic Usage
-
-Run the pipeline with default settings (analyzes last 6 months):
-```bash
-python pipeline.py
-```
-
-Run with custom date range:
-```bash
-python pipeline.py --start-date 2024-01-01 --end-date 2024-06-30
-```
-
-Run with custom output directory:
-```bash
-python pipeline.py --output-dir /path/to/output
-```
-
-## Architecture
-
-### Core Modules
-
-#### `pipeline.py` - Main Orchestration
-The primary entry point that coordinates all pipeline stages:
-- **CNAScoreCardPipeline**: Main pipeline class with modular execution stages
-- **Command-line interface**: Supports date ranges, output directories, and logging levels
-- **Error handling**: Comprehensive error handling with custom `PipelineError` exception
-- **Progress tracking**: Detailed logging and execution summaries
-
-#### `config.py` - Configuration Management
-Centralized configuration for all pipeline components:
-- **File paths**: Configurable input/output directories
-- **Scoring rules**: Loaded from `rules.json` with validation
-- **Field mappings**: CVE schema field definitions and importance levels
-- **Logging configuration**: Structured logging setup
-
-#### `ingest.py` - Data Loading
-CVE data ingestion and preprocessing:
-- **`load_cve_records()`**: Loads CVE JSON files with optional date filtering
-- **`extract_cna_short_names()`**: Extracts unique CNA identifiers from CVE data
-- **Date filtering**: Efficient filtering by publication date ranges
-- **Validation**: CVE record structure validation and error handling
-
-#### `scoring.py` - CVE Scoring
-Multi-category scoring system for CVE records:
-- **`score_cve_record()`**: Scores individual CVE records across all categories
-- **`score_multiple_cves()`**: Batch scoring with progress tracking
-- **Category functions**: Dedicated scoring functions for each category
-- **Configurable rules**: Uses scoring rules from configuration
-
-#### `aggregation.py` - CNA Analysis
-Aggregates scored CVEs by CNA and generates summaries:
-- **`aggregate_cna_scores()`**: Groups CVEs by CNA and calculates statistics
-- **Trend analysis**: Compares current performance with historical data
-- **Ranking system**: Generates CNA rankings with percentiles
-- **Metadata integration**: Enriches CNA data with official metadata
-
-#### `completeness.py` - Field Analysis
-Analyzes CVE field utilization and completeness:
-- **`compute_field_utilization()`**: Calculates field usage statistics across all CVEs
-- **`compute_individual_cna_field_utilization()`**: Per-CNA field utilization analysis
-- **Schema mapping**: Maps CVE fields to importance categories
-- **Nested field support**: Handles complex nested JSON structures
-
-#### `utils.py` - Utilities
-Common utilities and helper functions:
-- **Logging setup**: Configures structured logging with timestamps
-- **File operations**: JSON file reading/writing with error handling
-- **Data validation**: CVE record validation and sanitization
-- **Progress tracking**: Progress bar utilities for long-running operations
-
-### Data Flow
-
-```
-CVE JSON Files → Ingest → Filter by Date → Score Records → Aggregate by CNA → Generate Outputs
-                    ↓
-                Configuration ← Rules & Field Mappings
-                    ↓
-                Completeness Analysis → Field Utilization Reports
-```
-
-## Configuration
-
-### Main Configuration (`config.py`)
-
-The pipeline uses centralized configuration loaded from `config.py`:
-
-```python
-# Example configuration structure
-CONFIG = {
-    'directories': {
-        'cve_data': '../cve_data',
-        'web_data': '../web/data',
-        'completeness': '../web/data/completeness',
-        'cna_data': '../web/data/cna'
-    },
-    'scoring': {
-        'rules_file': 'rules.json',
-        'cwe_ids_file': 'cwe_ids.json'
-    },
-    'analysis': {
-        'default_period_months': 6,
-        'trend_periods': 3
-    }
-}
-```
-
-### Scoring Rules (`rules.json`)
-
-Defines scoring weights and criteria for each category:
-
-```json
-{
-  "foundationalCompleteness": {
-    "weight": 50,
-    "fields": ["descriptions", "affected", "references"],
-    "requirements": {
-      "descriptions": {"min_length": 50},
-      "affected": {"required": true},
-      "references": {"min_count": 1}
-    }
-  }
-}
-```
-
-### Field Mappings
-
-CVE schema fields are mapped to scoring categories and importance levels:
-
-```python
-CANONICAL_FIELDS = [
-    {
-        'field': 'containers.cna.descriptions',
-        'importance': 'High',
-        'description': 'Vulnerability descriptions',
-        'cna_scorecard_category': 'foundationalCompleteness'
-    }
-]
-```
-
-## Output Files
-
-The pipeline generates several output files for web interface consumption:
-
-### Individual CNA Files (`/web/data/cna/{cna_name}.json`)
-Detailed information for each CNA:
-```json
-{
-  "cna_info": [{
-    "shortName": "example-cna",
-    "organizationName": "Example Organization",
-    "total_cves": 150,
-    "rank": 5,
-    "percentile": 85.2
-  }],
-  "cna_scoring": [{
-    "overall_average_score": 78.5,
-    "average_foundational_completeness": 45.2,
-    "trend_direction": "improving"
-  }],
-  "cve_scoring": [
-    {
-      "cveId": "CVE-2024-0001",
-      "totalCveScore": 85,
-      "scoreBreakdown": {...}
-    }
-  ]
-}
-```
-
-### Summary Files
-- **`cna_combined.json`**: Combined CNA rankings and metadata
-- **`completeness_summary.json`**: Overall field utilization statistics
-
-### Completeness Files (`/web/data/completeness/`)
-- **`field_utilization.json`**: Field usage statistics across all CNAs
-- **`{cna_name}.json`**: Per-CNA field utilization details
-
-## Testing
-
-### Test Structure
-
-The pipeline includes comprehensive unit tests:
-
-```
-tests/
-├── __init__.py
-├── test_scoring.py      # Scoring logic tests
-├── test_aggregation.py  # CNA aggregation tests  
-├── test_ingest.py       # Data loading tests
-└── test_pipeline.py     # Integration tests
-```
-
-### Running Tests
-
-Run all tests:
-```bash
-pytest
-```
-
-Run with coverage:
-```bash
-pytest --cov=. --cov-report=html
-```
-
-Run specific test file:
-```bash
-pytest tests/test_scoring.py -v
-```
-
-### Test Features
-
-- **Mock data fixtures**: Tests use synthetic data, not production files
-- **Comprehensive coverage**: Tests cover normal operations, edge cases, and error conditions
-- **Integration tests**: Full pipeline execution testing
-- **Performance tests**: Validates pipeline performance with large datasets
-
-## Development
-
-### Code Quality
-
-The pipeline follows modern Python development practices:
-
-- **Type hints**: All functions include comprehensive type annotations
-- **Documentation**: Google-style docstrings for all public functions
-- **Code formatting**: Black code formatter with 88-character line length
-- **Linting**: Flake8 for code quality checks
-- **Import sorting**: isort for consistent import organization
-
-### Development Tools
-
-Install development dependencies:
-```bash
-pip install -r requirements.txt  # Includes dev tools
-```
-
-Format code:
-```bash
-black .
-isort .
-```
-
-Run linting:
-```bash
-flake8 .
-mypy .
-```
-
-### Adding New Features
-
-1. **Scoring Categories**: Add new scoring functions to `scoring.py` and update `rules.json`
-2. **Output Formats**: Extend output generation in `pipeline.py`
-3. **Data Sources**: Modify ingestion logic in `ingest.py`
-4. **Analysis Types**: Add new analysis functions to `completeness.py` or `aggregation.py`
-
-## Deployment
-
-### CI/CD Integration
-
-The pipeline is designed for automated execution:
-
-```yaml
-# Example GitHub Actions workflow
-- name: Run CNA Scorecard Pipeline
-  run: |
-    cd cnascorecard_pipeline
-    python pipeline.py --log-level INFO
-    
-- name: Validate Output
-  run: |
-    cd cnascorecard_pipeline
-    pytest tests/test_pipeline.py::TestPipelineOutputs
-```
-
-### Production Considerations
-
-- **Resource Requirements**: Pipeline processes ~300K CVE records, requires ~2GB RAM
-- **Execution Time**: Full pipeline run takes 5-15 minutes depending on data size
-- **Storage**: Output files require ~50MB for typical 6-month analysis
-- **Monitoring**: Comprehensive logging enables production monitoring
-
-### Environment Variables
-
-Optional environment variables for production deployment:
-
-```bash
-export CVE_DATA_DIR="/path/to/cve/data"
-export WEB_OUTPUT_DIR="/path/to/web/data"
-export LOG_LEVEL="INFO"
-export CONFIG_FILE="/path/to/custom/config.py"
-```
-
-## Troubleshooting
-
-### Common Issues
-
-**No CVE records found**
-- Verify CVE data directory exists and contains JSON files
-- Check date range parameters
-- Ensure CVE files follow expected naming convention
-
-**Scoring errors**
-- Validate `rules.json` format
-- Check `cwe_ids.json` for required CWE identifiers
-- Review CVE record structure for required fields
-
-**Memory issues**
-- Reduce date range for analysis
-- Increase system memory allocation
-- Consider processing in smaller batches
-
-### Debug Mode
-
-Enable detailed debugging:
-```bash
-python pipeline.py --log-level DEBUG
-```
-
-This provides extensive logging including:
-- CVE record processing details
-- Scoring calculations for each category
-- CNA aggregation statistics
-- File I/O operations
-
-### Performance Optimization
-
-For large datasets:
-- Use date filtering to reduce CVE record count
-- Enable progress tracking for long operations
-- Consider parallel processing for scoring (future enhancement)
-
-## Contributing
-
-### Development Setup
-
-1. Fork the repository
-2. Create a feature branch
-3. Install development dependencies
-4. Make changes with tests
-5. Run quality checks
-6. Submit pull request
-
-### Code Standards
-
-- Follow PEP 8 style guidelines
-- Add type hints to all functions
-- Include comprehensive docstrings
-- Write tests for new functionality
-- Update documentation as needed
-
-## License
-
-This project is part of the CNA Scorecard initiative to improve CVE data quality across the cybersecurity ecosystem.
-
-## Support
-
-For questions or issues:
-- Review this documentation
-- Check existing GitHub issues
-- Run tests to validate setup
-- Enable debug logging for troubleshooting
diff --git a/src/cvedb/cna/__init__.py b/src/cvedb/cna/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/src/cvedb/cna/aggregation.py b/src/cvedb/cna/aggregation.py
deleted file mode 100644
index fdc5d481d0f..00000000000
--- a/src/cvedb/cna/aggregation.py
+++ /dev/null
@@ -1,273 +0,0 @@
-"""
-aggregation.py: CNA-level aggregation and trend logic for CNA Scorecard pipeline.
-"""
-import os
-import json
-from typing import List, Dict, Tuple, Any
-from datetime import datetime
-
-def aggregate_cna_scores(scored_cves: List[Dict], periods: List[Tuple[datetime, datetime]]) -> Dict[str, Any]:
-    """
-    Groups scored CVEs by CNA and by period (e.g., month or 6-month window).
-    Returns per-CNA dict with scoring, monthly trends, and all aggregation fields needed for output.
-    Output matches new schema.
-    
-    IMPORTANT: This function now ensures ALL official CNAs get entries in the output,
-    even if they have no CVE data, to prevent missing individual JSON files.
-    """
-    from collections import defaultdict
-    # Simple trend calculation functions (replacing moved trend.py)
-    def calculate_monthly_trend(cves, months=6):
-        """Simple placeholder for monthly trend calculation."""
-        return []
-    
-    def summarize_trend(monthly_trends):
-        """Simple placeholder for trend summary."""
-        return {
-            'trend_direction': 'steady',
-            'trend_description': 'No significant change'
-        }
-
-    # Group CVEs by assigningCna
-    cna_cves = defaultdict(list)
-    for cve in scored_cves:
-        # Skip invalid CVE data
-        if not cve or not isinstance(cve, dict):
-            continue
-        cna = cve.get('assigningCna', 'Unknown')
-        cna_cves[cna].append(cve)
-
-    # Load enhanced CNA metadata - this is our authoritative source
-    import os, json
-    cna_list_path = os.path.join(os.path.dirname(__file__), '..', 'web', 'data', 'cna_list.json')
-    cna_metadata_map = {}
-    official_cna_names = set()
-    
-    if os.path.exists(cna_list_path):
-        try:
-            with open(cna_list_path, 'r') as f:
-                cna_list_data = json.load(f)
-                for entry in cna_list_data:
-                    short_name = entry.get('shortName', '')
-                    if short_name:
-                        cna_metadata_map[short_name.lower()] = entry
-                        official_cna_names.add(short_name)
-        except (IOError, OSError, ValueError, json.JSONDecodeError) as e:
-            print(f"[WARNING] Error reading CNA metadata file: {e}")
-            # Continue with empty metadata - function should still work
-    
-    print(f"[DEBUG] Loaded {len(official_cna_names)} official CNAs from metadata")
-    print(f"[DEBUG] Found CVE data for {len(cna_cves)} CNAs")
-
-    # Create name mapping function to match CVE assigningCna to official CNA names
-    def map_cve_name_to_official(cve_name, official_names, metadata_map):
-        """Map CVE assigningCna name to official CNA name using various strategies"""
-        if not cve_name or cve_name == 'Unknown':
-            return None
-            
-        # Try exact match first
-        if cve_name in official_names:
-            return cve_name
-            
-        # Try case-insensitive match
-        for official_name in official_names:
-            if official_name.lower() == cve_name.lower():
-                return official_name
-                
-        # Try normalized matching (remove spaces, hyphens, underscores)
-        normalized_cve = cve_name.lower().replace(' ', '').replace('-', '').replace('_', '')
-        for official_name in official_names:
-            normalized_official = official_name.lower().replace(' ', '').replace('-', '').replace('_', '')
-            if normalized_official == normalized_cve:
-                return official_name
-                
-        # Try partial matching for complex cases
-        cve_lower = cve_name.lower()
-        for official_name in official_names:
-            official_lower = official_name.lower()
-            if (cve_lower in official_lower or official_lower in cve_lower) and len(cve_lower) > 2:
-                return official_name
-                
-        return None
-    
-    # Map CVE data to official CNA names
-    official_cna_cves = defaultdict(list)
-    unmapped_cves = defaultdict(list)
-    
-    for cve_cna_name, cves in cna_cves.items():
-        official_name = map_cve_name_to_official(cve_cna_name, official_cna_names, cna_metadata_map)
-        if official_name:
-            official_cna_cves[official_name].extend(cves)
-        else:
-            unmapped_cves[cve_cna_name].extend(cves)
-    
-    print(f"[DEBUG] Mapped CVE data to {len(official_cna_cves)} official CNAs")
-    if unmapped_cves:
-        print(f"[DEBUG] {len(unmapped_cves)} CVE groups could not be mapped to official CNAs:")
-        for unmapped_name in list(unmapped_cves.keys())[:5]:  # Show first 5
-            print(f"[DEBUG]   - {unmapped_name} ({len(unmapped_cves[unmapped_name])} CVEs)")
-    
-    cna_outputs = {}
-    
-    # Process ALL official CNAs, ensuring each gets an entry
-    for official_cna_name in official_cna_names:
-        cves = official_cna_cves.get(official_cna_name, [])
-        # Use only the actual recent_cves for all scoring and output
-        recent_cves = [cve for cve in cves if cve.get('recent', True)]
-        # Get official metadata for this CNA
-        meta = cna_metadata_map.get(official_cna_name.lower(), {})
-        
-        # Defensive: if recent_cves is empty, still create entry with metadata
-        if not recent_cves:
-            # Create cna_info with metadata even for CNAs with no CVEs
-            cna_info = {
-                'cna': official_cna_name,
-                'total_cves': len(cves),
-                'total_cves_scored': 0,
-                'organizationName': meta.get('organizationName', ''),
-                'scope': meta.get('scope', ''),
-                'advisories': meta.get('advisories', []),
-                'email': meta.get('email', []),
-                'officialCnaID': meta.get('cnaID', ''),
-                'cnaTypes': meta.get('type', []),
-                'country': meta.get('country', ''),
-                'disclosurePolicy': meta.get('disclosurePolicy', []),
-                'rootCnaInfo': meta.get('rootCnaInfo', {}),
-                'rank': 0,
-                'active_cna_count': 0,
-                'percentile': 0.0
-            }
-            
-            cna_outputs[official_cna_name] = {
-                'cna_info': [cna_info],
-                'cna_scoring': [{
-                    'total_cves': len(cves),
-                    'total_cves_scored': 0,
-                    'recent_cves_count': 0,  # Add missing recent CVEs count for inactive CNAs
-                    'overall_average_score': 0.0,
-                    'average_foundational_completeness': 0.0,
-                    'average_root_cause_analysis': 0.0,
-                    'average_software_identification': 0.0,
-                    'average_severity_context': 0.0,
-                    'average_patchinfo': 0.0,
-                    'percent_foundational_completeness': 0.0,
-                    'percent_root_cause_analysis': 0.0,
-                    'percent_software_identification': 0.0,
-                    'percent_severity_and_impact': 0.0,
-                    'percent_patchinfo': 0.0,
-                    'trend_direction': 'N/A',
-                    'trend_description': 'No recent CVE data available',
-                    'monthly_trends': []
-                }],
-                'cve_scoring': []
-            }
-            continue
-
-        # Calculate monthly trends
-        monthly_trends = calculate_monthly_trend(recent_cves, months=6)
-        trend_summary = summarize_trend(monthly_trends)
-
-        # Aggregate CNA-level scoring (over recent CVEs only)
-        overall_avg = 0.0
-        if recent_cves:
-            total_score_sum = sum(cve.get('totalScore', 0) for cve in recent_cves)
-            overall_avg = round(total_score_sum / len(recent_cves), 2) if total_score_sum != 0 else 0.0
-        cat_sums = defaultdict(float)
-        cat_counts = defaultdict(int)
-        for cve in recent_cves:
-            breakdown = cve.get('scoreBreakdown', {})
-            for k, v in breakdown.items():
-                cat_sums[k] += v
-                # Count as 'present' if the score for this category is nonzero
-                if v and v > 0:
-                    cat_counts[k] += 1
-        cat_avgs = {}
-        for k, v in cat_sums.items():
-            avg = round(v / len(recent_cves), 2) if recent_cves and v != 0 else 0.0
-            cat_avgs[k] = avg
-        # Calculate percent-of-CVEs-with-data for each category
-        percent_fields = {}
-        for k in ['foundationalCompleteness', 'rootCauseAnalysis', 'softwareIdentification', 'severityAndImpactContext', 'patchinfo']:
-            percent = round(100.0 * cat_counts.get(k, 0) / len(recent_cves), 2) if recent_cves else 0.0
-            percent_fields[f'percent_{k}'] = percent
-
-        # Use metadata already retrieved above
-        # meta is already set from cna_metadata_map.get(official_cna_name.lower(), {})
-        # Explicitly construct cna_info with only allowed fields
-        cna_info = {
-            'cna': official_cna_name,
-            'total_cves': len(cves),
-            'total_cves_scored': sum(1 for cve in cves if cve.get('totalScore', 0) > 0),
-            'organizationName': meta.get('organizationName', ''),
-            'scope': meta.get('scope', ''),
-            'advisories': meta.get('advisories', []),
-            'email': meta.get('email', []),
-            'officialCnaID': meta.get('cnaID', ''),
-            'cnaTypes': meta.get('type', []),
-            'country': meta.get('country', ''),
-            'disclosurePolicy': meta.get('disclosurePolicy', []),
-            'rootCnaInfo': meta.get('rootCnaInfo', {}),
-            'rank': 0,
-            'active_cna_count': 0,
-            'percentile': 0.0
-        }
-        # FINAL FILTER: forcibly remove any average/overall fields from cna_info
-        for k in [
-            'overall_average_score',
-            'average_foundational_completeness',
-            'average_root_cause_analysis',
-            'average_software_identification',
-            'average_severity_context',
-            'average_patchinfo']:
-            cna_info.pop(k, None)
-
-        # DEBUG: Print patchinfo average for Fortinet
-        if official_cna_name.lower() == 'fortinet':
-            print(f"[DEBUG] Fortinet patchinfo avg: {cat_avgs.get('patchinfo', 0)} (sum: {cat_sums.get('patchinfo', 0)}, count: {len(recent_cves)})")
-        # CNA scoring (ensure all expected fields are present)
-        total_cves = len(cves)
-        total_cves_scored = sum(1 for cve in cves if cve.get('totalScore', 0) > 0)
-        cna_scoring = {
-            'total_cves': total_cves,
-            'total_cves_scored': total_cves_scored,
-            'recent_cves_count': len(recent_cves),  # Add missing recent CVEs count
-            'overall_average_score': overall_avg,
-            'average_foundational_completeness': cat_avgs.get('foundationalCompleteness', 0),
-            'average_root_cause_analysis': cat_avgs.get('rootCauseAnalysis', 0),
-            'average_software_identification': cat_avgs.get('softwareIdentification', 0),
-            'average_severity_context': cat_avgs.get('severityAndImpactContext', 0),
-            'average_patchinfo': cat_avgs.get('patchinfo', 0),
-            # New percent-of-CVEs-with-data fields:
-            'percent_foundational_completeness': percent_fields.get('percent_foundationalCompleteness', 0.0),
-            'percent_root_cause_analysis': percent_fields.get('percent_rootCauseAnalysis', 0.0),
-            'percent_software_identification': percent_fields.get('percent_softwareIdentification', 0.0),
-            'percent_severity_and_impact': percent_fields.get('percent_severityAndImpactContext', 0.0),
-            'percent_patchinfo': percent_fields.get('percent_patchinfo', 0.0),
-            'trend_direction': trend_summary.get('trend_direction', 'N/A'),
-            'trend_description': trend_summary.get('trend_description', ''),
-            'monthly_trends': monthly_trends
-        }
-        # CVE scoring (ensure all expected fields are present)
-        cve_scoring = []
-        for cve in cves:
-            breakdown = cve.get('scoreBreakdown', {})
-            cve_scoring.append({
-                'cveId': cve.get('cveId', ''),
-                'assigningCna': official_cna_name,  # Use official name consistently
-                'datePublished': cve.get('datePublished', ''),
-                'totalCveScore': cve.get('totalScore', 0),
-                'scoreBreakdown': {
-                    'foundationalCompleteness': breakdown.get('foundationalCompleteness', 0),
-                    'rootCauseAnalysis': breakdown.get('rootCauseAnalysis', 0),
-                    'softwareIdentification': breakdown.get('softwareIdentification', 0),
-                    'severityAndImpactContext': breakdown.get('severityAndImpactContext', 0),
-                    'patchinfo': breakdown.get('patchinfo', 0)
-                }
-            })
-        cna_outputs[official_cna_name] = {
-            'cna_info': [cna_info],
-            'cna_scoring': [cna_scoring],
-            'cve_scoring': cve_scoring
-        }
-    return cna_outputs
-
diff --git a/src/cvedb/cna/badge_generator.py b/src/cvedb/cna/badge_generator.py
deleted file mode 100644
index cc334c0698a..00000000000
--- a/src/cvedb/cna/badge_generator.py
+++ /dev/null
@@ -1,318 +0,0 @@
-"""
-CNA Scorecard Badge Generator.
-
-This module generates SVG badges for CNAs to display on their homepages,
-showing their current CNA Scorecard rank and score.
-"""
-import logging
-from typing import Dict, Optional
-from pathlib import Path
-
-logger = logging.getLogger('cnascorecard.badge_generator')
-
-
-def get_color_from_score(score: float) -> str:
-    """
-    Get color based on score.
-    
-    Args:
-        score: Numerical score (0-100)
-        
-    Returns:
-        Hex color code
-    """
-    if score >= 90:
-        return "#00A86B"  # Emerald green for excellent
-    elif score >= 80:
-        return "#10B981"  # Green for very good
-    elif score >= 70:
-        return "#60A5FA"  # Blue for good
-    elif score >= 60:
-        return "#FBBF24"  # Yellow for fair
-    else:
-        return "#EF4444"  # Red for needs improvement
-
-
-def generate_badge_svg(
-    cna_name: str,
-    score: float,
-    rank: int,
-    badge_style: str = "rank"
-) -> str:
-    """
-    Generate SVG badge for a CNA.
-    
-    Args:
-        cna_name: Name of the CNA
-        score: CNA's overall average score (0-100)
-        rank: CNA's rank position
-        badge_style: Style of badge - "rank", "score", or "both"
-        
-    Returns:
-        SVG badge as string
-    """
-    color = get_color_from_score(score)
-    
-    if badge_style == "rank":
-        return _generate_rank_badge(rank, color)
-    elif badge_style == "score":
-        return _generate_score_badge(score, color)
-    elif badge_style == "both":
-        return _generate_combined_badge(score, rank, color)
-    else:
-        return _generate_rank_badge(rank, color)
-
-
-def _generate_rank_badge(rank: int, color: str) -> str:
-    """Generate rank-only badge."""
-    rank_str = f"#{rank}"
-    # Calculate text length based on rank string length
-    text_length = len(rank_str) * 70
-    badge_width = 145 + (text_length / 10 + 10)
-    rect_x = 145
-    text_x = rect_x + (text_length / 20 + 5)
-    
-    return f'''<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{int(badge_width)}" height="20" role="img" aria-label="CNAScorecard Rank: {rank_str}">
-    <title>CNAScorecard Rank: {rank_str}</title>
-    <linearGradient id="s" x2="0" y2="100%">
-        <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
-        <stop offset="1" stop-opacity=".1"/>
-    </linearGradient>
-    <clipPath id="r">
-        <rect width="{int(badge_width)}" height="20" rx="3" fill="#fff"/>
-    </clipPath>
-    <g clip-path="url(#r)">
-        <rect width="145" height="20" fill="#555"/>
-        <rect x="145" width="{int(badge_width - 145)}" height="20" fill="{color}"/>
-        <rect width="{int(badge_width)}" height="20" fill="url(#s)"/>
-    </g>
-    <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110">
-        <text aria-hidden="true" x="735" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="1350">CNAScorecard Rank</text>
-        <text x="735" y="140" transform="scale(.1)" fill="#fff" textLength="1350">CNAScorecard Rank</text>
-        <text aria-hidden="true" x="{int(text_x * 10)}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="{text_length}">{rank_str}</text>
-        <text x="{int(text_x * 10)}" y="140" transform="scale(.1)" fill="#fff" textLength="{text_length}">{rank_str}</text>
-    </g>
-</svg>'''
-
-
-def _generate_score_badge(score: float, color: str) -> str:
-    """Generate score-only badge."""
-    score_str = f"{score:.1f}%"
-    # Calculate text length based on score string length
-    text_length = len(score_str) * 60
-    badge_width = 145 + (text_length / 10 + 10)
-    rect_x = 145
-    text_x = rect_x + (text_length / 20 + 5)
-    
-    return f'''<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{int(badge_width)}" height="20" role="img" aria-label="CNAScorecard Score: {score_str}">
-    <title>CNAScorecard Score: {score_str}</title>
-    <linearGradient id="s" x2="0" y2="100%">
-        <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
-        <stop offset="1" stop-opacity=".1"/>
-    </linearGradient>
-    <clipPath id="r">
-        <rect width="{int(badge_width)}" height="20" rx="3" fill="#fff"/>
-    </clipPath>
-    <g clip-path="url(#r)">
-        <rect width="145" height="20" fill="#555"/>
-        <rect x="145" width="{int(badge_width - 145)}" height="20" fill="{color}"/>
-        <rect width="{int(badge_width)}" height="20" fill="url(#s)"/>
-    </g>
-    <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110">
-        <text aria-hidden="true" x="735" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="1350">CNAScorecard Score</text>
-        <text x="735" y="140" transform="scale(.1)" fill="#fff" textLength="1350">CNAScorecard Score</text>
-        <text aria-hidden="true" x="{int(text_x * 10)}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="{text_length}">{score_str}</text>
-        <text x="{int(text_x * 10)}" y="140" transform="scale(.1)" fill="#fff" textLength="{text_length}">{score_str}</text>
-    </g>
-</svg>'''
-
-
-def _generate_combined_badge(score: float, rank: int, color: str) -> str:
-    """Generate combined rank and score badge."""
-    badge_str = f"#{rank} - {score:.1f}%"
-    text_length = len(badge_str) * 55
-    badge_width = 145 + (text_length / 10 + 15)
-    rect_x = 145
-    text_x = rect_x + (text_length / 20 + 7.5)
-    
-    return f'''<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="{int(badge_width)}" height="20" role="img" aria-label="CNAScorecard: {badge_str}">
-    <title>CNAScorecard: {badge_str}</title>
-    <linearGradient id="s" x2="0" y2="100%">
-        <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
-        <stop offset="1" stop-opacity=".1"/>
-    </linearGradient>
-    <clipPath id="r">
-        <rect width="{int(badge_width)}" height="20" rx="3" fill="#fff"/>
-    </clipPath>
-    <g clip-path="url(#r)">
-        <rect width="145" height="20" fill="#555"/>
-        <rect x="145" width="{int(badge_width - 145)}" height="20" fill="{color}"/>
-        <rect width="{int(badge_width)}" height="20" fill="url(#s)"/>
-    </g>
-    <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110">
-        <text aria-hidden="true" x="735" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="1350">CNAScorecard</text>
-        <text x="735" y="140" transform="scale(.1)" fill="#fff" textLength="1350">CNAScorecard</text>
-        <text aria-hidden="true" x="{int(text_x * 10)}" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="{text_length}">{badge_str}</text>
-        <text x="{int(text_x * 10)}" y="140" transform="scale(.1)" fill="#fff" textLength="{text_length}">{badge_str}</text>
-    </g>
-</svg>'''
-
-
-def generate_cna_badges(
-    cna_outputs: Dict[str, Dict],
-    output_dir: Path
-) -> Dict[str, str]:
-    """
-    Generate SVG badges for all CNAs.
-    
-    Args:
-        cna_outputs: Dictionary of CNA data from aggregation
-        output_dir: Base output directory (web/data)
-        
-    Returns:
-        Dictionary mapping badge types to file paths
-    """
-    logger.info("Generating CNA badges")
-    
-    # Create badges directory
-    badges_dir = output_dir.parent / 'badges'
-    badges_dir.mkdir(parents=True, exist_ok=True)
-    
-    badge_files = {}
-    generated_count = 0
-    
-    for cna_name, cna_data in cna_outputs.items():
-        if not cna_data.get('cna_scoring'):
-            continue
-            
-        cna_scoring = cna_data['cna_scoring'][0]
-        score = cna_scoring.get('overall_average_score', 0)
-        rank = cna_data.get('rank', 999)  # Get rank from cna_data
-        
-        # Only generate badges for active CNAs with scores
-        if score <= 0:
-            continue
-        
-        # Create safe filename
-        safe_name = cna_name.replace('/', '_').replace('\\', '_')
-        
-        # Generate all three badge styles
-        for badge_style in ['rank', 'score', 'both']:
-            svg_content = generate_badge_svg(cna_name, score, rank, badge_style)
-            filename = f"{safe_name}-{badge_style}.svg"
-            filepath = badges_dir / filename
-            
-            # Write SVG file
-            with open(filepath, 'w', encoding='utf-8') as f:
-                f.write(svg_content)
-            
-            badge_key = f"{safe_name}_{badge_style}"
-            badge_files[badge_key] = str(filepath)
-        
-        generated_count += 1
-    
-    logger.info(f"Generated badges for {generated_count} CNAs (3 styles each)")
-    return badge_files
-
-
-def generate_badge_documentation(output_dir: Path, base_url: str = "https://cvedb.github.io") -> str:
-    """
-    Generate README documentation for using badges.
-    
-    Args:
-        output_dir: Output directory for README
-        base_url: Base URL for the CNA Scorecard website
-        
-    Returns:
-        Path to generated README file
-    """
-    badges_dir = output_dir.parent / 'badges'
-    readme_path = badges_dir / 'README.md'
-    
-    readme_content = f'''# CNA Scorecard Badges
-
-Display your CNA Scorecard rating on your website, README, or documentation!
-
-## Badge Styles
-
-We provide three badge styles for each CNA:
-
-1. **Rank Badge** - Shows your CNA rank (e.g., #1, #5, #42)
-2. **Score Badge** - Shows numerical score percentage
-3. **Combined Badge** - Shows both rank and score
-
-## Usage
-
-### Markdown
-
-Replace `{{CNA_NAME}}` with your CNA shortName (e.g., `Microsoft`, `Cisco`, `Linux`):
-
-**Rank Badge:**
-```markdown
-![CNA Scorecard]({{base_url}}/badges/{{{{CNA_NAME}}}}-rank.svg)
-```
-
-**Score Badge:**
-```markdown
-![CNA Scorecard]({{base_url}}/badges/{{{{CNA_NAME}}}}-score.svg)
-```
-
-**Combined Badge:**
-```markdown
-![CNA Scorecard]({{base_url}}/badges/{{{{CNA_NAME}}}}-both.svg)
-```
-
-### HTML
-
-```html
-<img src="{{base_url}}/badges/{{{{CNA_NAME}}}}-rank.svg" alt="CNA Scorecard">
-```
-
-### Examples
-
-**Microsoft (Rank):**
-```markdown
-![CNA Scorecard]({{base_url}}/badges/Microsoft-rank.svg)
-```
-
-**Linux (Score):**
-```markdown
-![CNA Scorecard]({{base_url}}/badges/Linux-score.svg)
-```
-
-**Cisco (Combined):**
-```markdown
-![CNA Scorecard]({{base_url}}/badges/Cisco-both.svg)
-```
-
-## Linking to Your CNA Page
-
-Make your badge clickable by wrapping it in a link:
-
-```markdown
-[![CNA Scorecard]({{base_url}}/badges/{{{{CNA_NAME}}}}-rank.svg)]({{base_url}}/cna/cna-detail.html?shortName={{{{CNA_NAME}}}})
-```
-
-## Badge Updates
-
-Badges are automatically regenerated every time the CNA Scorecard pipeline runs (typically every 6 hours). Your badge will always reflect your latest rank and score!
-
-## Color Scheme
-
-Badges are color-coded based on score:
-- **90-100%**: Green (Excellent)
-- **80-89%**: Light Green (Very Good)
-- **70-79%**: Blue (Good)
-- **60-69%**: Yellow (Fair)
-- **Below 60%**: Red (Needs Improvement)
-
-## Questions?
-
-Visit [CNA Scorecard]({base_url}) or open an issue on [GitHub](https://github.com/CVEDB/cvedb.github.io).
-'''
-    
-    with open(readme_path, 'w', encoding='utf-8') as f:
-        f.write(readme_content)
-    
-    logger.info(f"Generated badge documentation at {readme_path}")
-    return str(readme_path)
diff --git a/src/cvedb/cna/cache.py b/src/cvedb/cna/cache.py
deleted file mode 100644
index 848500d3b91..00000000000
--- a/src/cvedb/cna/cache.py
+++ /dev/null
@@ -1,353 +0,0 @@
-"""
-cache.py: Caching layer for computed CVE scores.
-
-This module provides caching functionality to avoid recomputing scores
-for CVEs that haven't changed, significantly improving pipeline performance
-for incremental runs.
-"""
-import hashlib
-import json
-import logging
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Dict, Any, Optional, List, Tuple
-
-from .config import WEB_DATA_DIR
-
-logger = logging.getLogger('cnascorecard.cache')
-
-# Default cache directory
-CACHE_DIR = WEB_DATA_DIR / ".cache" / "scores"
-
-
-class ScoreCache:
-    """
-    Cache for computed CVE scores.
-    
-    The cache stores scores indexed by CVE ID and a hash of the CVE content.
-    When a CVE's content changes, its hash changes, invalidating the cache.
-    
-    Example:
-        >>> cache = ScoreCache()
-        >>> 
-        >>> # Check if score is cached
-        >>> cached_score = cache.get(cve_id, cve_data)
-        >>> if cached_score:
-        ...     score = cached_score
-        ... else:
-        ...     score = compute_score(cve_data)
-        ...     cache.set(cve_id, cve_data, score)
-    """
-    
-    def __init__(self, cache_dir: Optional[Path] = None):
-        """
-        Initialize the score cache.
-        
-        Args:
-            cache_dir: Directory to store cache files (defaults to CACHE_DIR)
-        """
-        self.cache_dir = Path(cache_dir) if cache_dir else CACHE_DIR
-        self._memory_cache: Dict[str, Dict[str, Any]] = {}
-        self._hits = 0
-        self._misses = 0
-        self._initialized = False
-    
-    def _ensure_initialized(self) -> None:
-        """Ensure cache directory exists."""
-        if not self._initialized:
-            self.cache_dir.mkdir(parents=True, exist_ok=True)
-            self._initialized = True
-    
-    @staticmethod
-    def compute_hash(cve_data: Dict[str, Any]) -> str:
-        """
-        Compute a hash of CVE data for cache validation.
-        
-        The hash is computed from the JSON-serialized CVE data, ensuring
-        that any change to the CVE invalidates the cache.
-        
-        Args:
-            cve_data: CVE record dictionary
-            
-        Returns:
-            SHA256 hash of the CVE data (first 16 chars)
-        """
-        # Sort keys for consistent ordering
-        json_str = json.dumps(cve_data, sort_keys=True, separators=(',', ':'))
-        return hashlib.sha256(json_str.encode()).hexdigest()[:16]
-    
-    def get(self, cve_id: str, cve_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        """
-        Retrieve a cached score if the CVE hasn't changed.
-        
-        Args:
-            cve_id: CVE identifier (e.g., "CVE-2025-10150")
-            cve_data: Current CVE record data
-            
-        Returns:
-            Cached score dictionary if valid, None if cache miss
-        """
-        current_hash = self.compute_hash(cve_data)
-        
-        # Check memory cache first
-        if cve_id in self._memory_cache:
-            cached = self._memory_cache[cve_id]
-            if cached.get("hash") == current_hash:
-                self._hits += 1
-                return cached.get("score")
-        
-        # Check disk cache
-        cache_file = self._get_cache_path(cve_id)
-        if cache_file.exists():
-            try:
-                with open(cache_file, 'r') as f:
-                    cached = json.load(f)
-                
-                if cached.get("hash") == current_hash:
-                    # Load into memory cache for faster subsequent access
-                    self._memory_cache[cve_id] = cached
-                    self._hits += 1
-                    return cached.get("score")
-            except (json.JSONDecodeError, IOError) as e:
-                logger.debug(f"Error reading cache for {cve_id}: {e}")
-        
-        self._misses += 1
-        return None
-    
-    def set(self, cve_id: str, cve_data: Dict[str, Any], score: Dict[str, Any]) -> None:
-        """
-        Store a computed score in the cache.
-        
-        Args:
-            cve_id: CVE identifier
-            cve_data: CVE record data (used to compute hash)
-            score: Computed score to cache
-        """
-        self._ensure_initialized()
-        
-        cached = {
-            "cve_id": cve_id,
-            "hash": self.compute_hash(cve_data),
-            "score": score,
-            "cached_at": datetime.now(timezone.utc).isoformat()
-        }
-        
-        # Update memory cache
-        self._memory_cache[cve_id] = cached
-        
-        # Write to disk
-        cache_file = self._get_cache_path(cve_id)
-        try:
-            cache_file.parent.mkdir(parents=True, exist_ok=True)
-            with open(cache_file, 'w') as f:
-                json.dump(cached, f)
-        except IOError as e:
-            logger.warning(f"Error writing cache for {cve_id}: {e}")
-    
-    def get_batch(
-        self, 
-        cve_records: List[Dict[str, Any]]
-    ) -> Tuple[Dict[str, Dict[str, Any]], List[Dict[str, Any]]]:
-        """
-        Get cached scores for a batch of CVEs, returning hits and misses.
-        
-        This is more efficient than individual get() calls when processing
-        many CVEs.
-        
-        Args:
-            cve_records: List of CVE record dictionaries
-            
-        Returns:
-            Tuple of:
-            - Dict mapping CVE IDs to cached scores
-            - List of CVE records that need scoring (cache misses)
-        """
-        cached_scores = {}
-        uncached_cves = []
-        
-        for cve in cve_records:
-            cve_id = cve.get("cveMetadata", {}).get("cveId")
-            if not cve_id:
-                uncached_cves.append(cve)
-                continue
-            
-            cached = self.get(cve_id, cve)
-            if cached:
-                cached_scores[cve_id] = cached
-            else:
-                uncached_cves.append(cve)
-        
-        logger.info(f"Cache batch: {len(cached_scores)} hits, {len(uncached_cves)} misses")
-        return cached_scores, uncached_cves
-    
-    def set_batch(
-        self, 
-        scores: List[Dict[str, Any]], 
-        cve_lookup: Dict[str, Dict[str, Any]]
-    ) -> None:
-        """
-        Store multiple scores in the cache.
-        
-        Args:
-            scores: List of score dictionaries (must contain 'cveId')
-            cve_lookup: Dict mapping CVE IDs to their record data
-        """
-        for score in scores:
-            cve_id = score.get("cveId")
-            if cve_id and cve_id in cve_lookup:
-                self.set(cve_id, cve_lookup[cve_id], score)
-    
-    def _get_cache_path(self, cve_id: str) -> Path:
-        """
-        Get the cache file path for a CVE ID.
-        
-        Cache files are organized by year to avoid too many files in one directory.
-        
-        Args:
-            cve_id: CVE identifier
-            
-        Returns:
-            Path to cache file
-        """
-        # Extract year from CVE ID (CVE-YYYY-NNNNN)
-        parts = cve_id.split("-")
-        year = parts[1] if len(parts) >= 2 else "unknown"
-        
-        return self.cache_dir / year / f"{cve_id}.json"
-    
-    def clear(self, older_than_days: Optional[int] = None) -> int:
-        """
-        Clear cached scores.
-        
-        Args:
-            older_than_days: If provided, only clear entries older than this many days.
-                            If None, clears all entries.
-                            
-        Returns:
-            Number of cache entries cleared
-        """
-        self._memory_cache.clear()
-        cleared = 0
-        
-        if not self.cache_dir.exists():
-            return 0
-        
-        cutoff = None
-        if older_than_days:
-            from datetime import timedelta
-            cutoff = datetime.now(timezone.utc) - timedelta(days=older_than_days)
-        
-        for cache_file in self.cache_dir.rglob("CVE-*.json"):
-            try:
-                if cutoff:
-                    with open(cache_file, 'r') as f:
-                        cached = json.load(f)
-                    cached_at = datetime.fromisoformat(cached.get("cached_at", ""))
-                    if cached_at > cutoff:
-                        continue
-                
-                cache_file.unlink()
-                cleared += 1
-            except Exception as e:
-                logger.debug(f"Error clearing cache file {cache_file}: {e}")
-        
-        logger.info(f"Cleared {cleared} cache entries")
-        return cleared
-    
-    def stats(self) -> Dict[str, Any]:
-        """
-        Get cache statistics.
-        
-        Returns:
-            Dict with hits, misses, hit_rate, and memory_entries
-        """
-        total = self._hits + self._misses
-        hit_rate = (self._hits / total * 100) if total > 0 else 0
-        
-        return {
-            "hits": self._hits,
-            "misses": self._misses,
-            "hit_rate": f"{hit_rate:.1f}%",
-            "memory_entries": len(self._memory_cache)
-        }
-    
-    def __repr__(self) -> str:
-        stats = self.stats()
-        return f"ScoreCache(hits={stats['hits']}, misses={stats['misses']}, rate={stats['hit_rate']})"
-
-
-# Global cache instance
-_global_cache: Optional[ScoreCache] = None
-
-
-def get_cache(cache_dir: Optional[Path] = None) -> ScoreCache:
-    """
-    Get the global score cache instance.
-    
-    Args:
-        cache_dir: Optional cache directory (only used on first call)
-        
-    Returns:
-        ScoreCache instance
-    """
-    global _global_cache
-    if _global_cache is None:
-        _global_cache = ScoreCache(cache_dir)
-    return _global_cache
-
-
-def reset_cache() -> None:
-    """Reset the global cache instance."""
-    global _global_cache
-    _global_cache = None
-
-
-def score_with_cache(
-    cve_records: List[Dict[str, Any]],
-    scoring_func,
-    cache: Optional[ScoreCache] = None
-) -> List[Dict[str, Any]]:
-    """
-    Score CVE records using cache for efficiency.
-    
-    This is a convenience function that wraps the caching logic around
-    any scoring function.
-    
-    Args:
-        cve_records: List of CVE record dictionaries
-        scoring_func: Function that takes a CVE record and returns a score dict
-        cache: ScoreCache instance (uses global cache if not provided)
-        
-    Returns:
-        List of score dictionaries
-    """
-    if cache is None:
-        cache = get_cache()
-    
-    # Check cache for existing scores
-    cached_scores, uncached_cves = cache.get_batch(cve_records)
-    
-    # Score uncached CVEs
-    new_scores = []
-    cve_lookup = {}
-    
-    for cve in uncached_cves:
-        cve_id = cve.get("cveMetadata", {}).get("cveId")
-        if cve_id:
-            cve_lookup[cve_id] = cve
-        
-        try:
-            score = scoring_func(cve)
-            if score:
-                new_scores.append(score)
-        except Exception as e:
-            logger.debug(f"Error scoring CVE: {e}")
-    
-    # Cache the new scores
-    cache.set_batch(new_scores, cve_lookup)
-    
-    # Combine cached and new scores
-    all_scores = list(cached_scores.values()) + new_scores
-    
-    logger.info(f"Scoring complete: {len(cached_scores)} cached, {len(new_scores)} computed")
-    return all_scores
diff --git a/src/cvedb/cna/chunking.py b/src/cvedb/cna/chunking.py
deleted file mode 100644
index af40115881b..00000000000
--- a/src/cvedb/cna/chunking.py
+++ /dev/null
@@ -1,307 +0,0 @@
-"""
-chunking.py: Data chunking for web lazy loading.
-
-This module provides functionality to split large JSON data files into
-smaller chunks for efficient client-side lazy loading on the static site.
-"""
-import json
-import logging
-from pathlib import Path
-from typing import Dict, Any, List, Optional
-
-from .utils import write_json_file, ensure_directory_exists
-
-logger = logging.getLogger('cnascorecard.chunking')
-
-
-def write_chunked_cna_data(
-    cna_list: List[Dict[str, Any]], 
-    output_dir: Path,
-    chunk_size: int = 50
-) -> Dict[str, Any]:
-    """
-    Split CNA data into static chunks for lazy loading.
-    
-    This creates multiple JSON files that can be loaded on-demand by the
-    web interface, improving initial page load time for large datasets.
-    
-    Args:
-        cna_list: List of CNA data dictionaries (sorted by desired order)
-        output_dir: Base output directory (chunks go in output_dir/chunks/)
-        chunk_size: Number of CNAs per chunk (default 50)
-        
-    Returns:
-        Manifest dictionary with chunking metadata
-        
-    Example:
-        >>> manifest = write_chunked_cna_data(cna_list, Path("web/data"))
-        >>> print(f"Created {manifest['totalChunks']} chunks")
-    """
-    chunks_dir = output_dir / "chunks"
-    ensure_directory_exists(chunks_dir)
-    
-    total_cnas = len(cna_list)
-    total_chunks = (total_cnas + chunk_size - 1) // chunk_size
-    
-    logger.info(f"Creating {total_chunks} CNA chunks of ~{chunk_size} items each")
-    
-    chunk_files = []
-    
-    for i in range(0, total_cnas, chunk_size):
-        chunk_index = i // chunk_size
-        chunk = cna_list[i:i + chunk_size]
-        chunk_file = f"cna_chunk_{chunk_index}.json"
-        chunk_path = chunks_dir / chunk_file
-        
-        # Write chunk with metadata
-        chunk_data = {
-            "chunkIndex": chunk_index,
-            "startIndex": i,
-            "endIndex": min(i + chunk_size, total_cnas),
-            "count": len(chunk),
-            "items": chunk
-        }
-        
-        write_json_file(chunk_data, chunk_path)
-        chunk_files.append(chunk_file)
-        
-        logger.debug(f"Wrote chunk {chunk_index}: {len(chunk)} CNAs")
-    
-    # Write manifest for client-side loader
-    manifest = {
-        "totalCNAs": total_cnas,
-        "chunkSize": chunk_size,
-        "totalChunks": total_chunks,
-        "chunks": chunk_files,
-        "generatedAt": _get_timestamp()
-    }
-    
-    manifest_path = chunks_dir / "manifest.json"
-    write_json_file(manifest, manifest_path)
-    
-    logger.info(f"Created chunk manifest at {manifest_path}")
-    
-    return manifest
-
-
-def write_chunked_completeness_data(
-    completeness_list: List[Dict[str, Any]],
-    output_dir: Path,
-    chunk_size: int = 100
-) -> Dict[str, Any]:
-    """
-    Split completeness data into chunks for lazy loading.
-    
-    Args:
-        completeness_list: List of CNA completeness data
-        output_dir: Base output directory
-        chunk_size: Number of items per chunk
-        
-    Returns:
-        Manifest dictionary
-    """
-    chunks_dir = output_dir / "completeness" / "chunks"
-    ensure_directory_exists(chunks_dir)
-    
-    total_items = len(completeness_list)
-    total_chunks = (total_items + chunk_size - 1) // chunk_size
-    
-    chunk_files = []
-    
-    for i in range(0, total_items, chunk_size):
-        chunk_index = i // chunk_size
-        chunk = completeness_list[i:i + chunk_size]
-        chunk_file = f"completeness_chunk_{chunk_index}.json"
-        chunk_path = chunks_dir / chunk_file
-        
-        chunk_data = {
-            "chunkIndex": chunk_index,
-            "startIndex": i,
-            "endIndex": min(i + chunk_size, total_items),
-            "count": len(chunk),
-            "items": chunk
-        }
-        
-        write_json_file(chunk_data, chunk_path)
-        chunk_files.append(chunk_file)
-    
-    manifest = {
-        "totalItems": total_items,
-        "chunkSize": chunk_size,
-        "totalChunks": total_chunks,
-        "chunks": chunk_files,
-        "generatedAt": _get_timestamp()
-    }
-    
-    manifest_path = chunks_dir / "manifest.json"
-    write_json_file(manifest, manifest_path)
-    
-    return manifest
-
-
-def generate_search_index(
-    cna_list: List[Dict[str, Any]],
-    output_dir: Path
-) -> Dict[str, Any]:
-    """
-    Generate a search index for client-side filtering.
-    
-    This creates a lightweight index that can be loaded once and used
-    for instant filtering without fetching all data chunks.
-    
-    Args:
-        cna_list: List of CNA data dictionaries
-        output_dir: Output directory for the index file
-        
-    Returns:
-        Search index dictionary
-    """
-    logger.info("Generating search index")
-    
-    # Extract searchable fields
-    cna_names = []
-    cna_ids = []
-    types = set()
-    grades = set()
-    countries = set()
-    
-    for cna in cna_list:
-        short_name = cna.get("shortName", "")
-        if short_name:
-            cna_names.append(short_name)
-        
-        cna_id = cna.get("cnaId", "")
-        if cna_id:
-            cna_ids.append(cna_id)
-        
-        cna_type = cna.get("type", "")
-        if cna_type:
-            types.add(cna_type)
-        
-        grade = cna.get("grade", "")
-        if grade:
-            grades.add(grade)
-        
-        country = cna.get("country", "")
-        if country:
-            countries.add(country)
-    
-    search_index = {
-        "cnaNames": sorted(cna_names),
-        "cnaIds": cna_ids,
-        "types": sorted(types),
-        "grades": sorted(grades, key=_grade_sort_key),
-        "countries": sorted(countries),
-        "totalCNAs": len(cna_list),
-        "generatedAt": _get_timestamp()
-    }
-    
-    index_path = output_dir / "search_index.json"
-    write_json_file(search_index, index_path)
-    
-    logger.info(f"Generated search index with {len(cna_names)} CNAs")
-    
-    return search_index
-
-
-def generate_summary_stats(
-    cna_list: List[Dict[str, Any]],
-    output_dir: Path
-) -> Dict[str, Any]:
-    """
-    Generate summary statistics for dashboard cards.
-    
-    This creates a small file with aggregate stats that can be loaded
-    instantly for the main dashboard.
-    
-    Args:
-        cna_list: List of CNA data dictionaries
-        output_dir: Output directory
-        
-    Returns:
-        Summary statistics dictionary
-    """
-    total_cnas = len(cna_list)
-    total_cves = sum(cna.get("cveCount", 0) for cna in cna_list)
-    
-    # Grade distribution
-    grade_counts = {"A": 0, "B": 0, "C": 0, "D": 0, "F": 0}
-    for cna in cna_list:
-        grade = cna.get("grade", "F")
-        if grade in grade_counts:
-            grade_counts[grade] += 1
-    
-    # Score distribution
-    scores = [cna.get("overallScore", 0) for cna in cna_list if cna.get("overallScore")]
-    avg_score = sum(scores) / len(scores) if scores else 0
-    
-    # Type distribution
-    type_counts = {}
-    for cna in cna_list:
-        cna_type = cna.get("type", "Unknown")
-        type_counts[cna_type] = type_counts.get(cna_type, 0) + 1
-    
-    # Trend summary
-    trend_counts = {"up": 0, "down": 0, "steady": 0}
-    for cna in cna_list:
-        trend = cna.get("trend", "steady")
-        if trend in trend_counts:
-            trend_counts[trend] += 1
-    
-    stats = {
-        "totalCNAs": total_cnas,
-        "totalCVEs": total_cves,
-        "averageScore": round(avg_score, 1),
-        "gradeDistribution": grade_counts,
-        "typeDistribution": type_counts,
-        "trendDistribution": trend_counts,
-        "generatedAt": _get_timestamp()
-    }
-    
-    stats_path = output_dir / "summary_stats.json"
-    write_json_file(stats, stats_path)
-    
-    logger.info(f"Generated summary stats: {total_cnas} CNAs, {total_cves} CVEs")
-    
-    return stats
-
-
-def cleanup_old_chunks(chunks_dir: Path, keep_latest: int = 1) -> int:
-    """
-    Clean up old chunk files.
-    
-    Args:
-        chunks_dir: Directory containing chunk files
-        keep_latest: Number of generations to keep (default 1)
-        
-    Returns:
-        Number of files removed
-    """
-    if not chunks_dir.exists():
-        return 0
-    
-    # For now, just remove all chunk files (they get regenerated each run)
-    removed = 0
-    for chunk_file in chunks_dir.glob("*_chunk_*.json"):
-        try:
-            chunk_file.unlink()
-            removed += 1
-        except OSError:
-            pass
-    
-    if removed > 0:
-        logger.debug(f"Cleaned up {removed} old chunk files")
-    
-    return removed
-
-
-def _get_timestamp() -> str:
-    """Get current UTC timestamp in ISO format."""
-    from datetime import datetime, timezone
-    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-
-def _grade_sort_key(grade: str) -> int:
-    """Sort key for grades (A=0, B=1, etc)."""
-    order = {"A": 0, "B": 1, "C": 2, "D": 3, "F": 4}
-    return order.get(grade, 5)
diff --git a/src/cvedb/cna/completeness.py b/src/cvedb/cna/completeness.py
deleted file mode 100644
index bb29842055a..00000000000
--- a/src/cvedb/cna/completeness.py
+++ /dev/null
@@ -1,386 +0,0 @@
-"""
-completeness.py: Calculate field utilization/completeness for all schema fields
-using a robust, schema-driven approach with full parity to the V.01 analyzer.
-"""
-from collections import defaultdict
-from typing import Dict, Any, List
-
-def _get_schema_fields() -> Dict[str, Dict]:
-    """Defines the key CVE schema fields for completeness analysis, matching the legacy field insights page."""
-    return {
-        # Auto-added fields (now included for full parity)
-        "dataType": {"path": ["dataType"]},
-        "dataVersion": {"path": ["dataVersion"]},
-        "cveMetadata.cveId": {"path": ["cveMetadata", "cveId"]},
-        "cveMetadata.assignerOrgId": {"path": ["cveMetadata", "assignerOrgId"]},
-        "cveMetadata.state": {"path": ["cveMetadata", "state"]},
-        "containers.cna.providerMetadata": {"path": ["containers", "cna", "providerMetadata"]},
-        "cveMetadata.assignerShortName": {"path": ["cveMetadata", "assignerShortName"]},
-        "cveMetadata.dateUpdated": {"path": ["cveMetadata", "dateUpdated"]},
-        "cveMetadata.datePublished": {"path": ["cveMetadata", "datePublished"]},
-        "cveMetadata.dateReserved": {"path": ["cveMetadata", "dateReserved"]},
-
-        # CVE Metadata
-        "cveMetadata.serial": {"path": ["cveMetadata", "serial"]},
-
-        # CNA Container fields
-        "containers.cna.title": {"path": ["containers", "cna", "title"]},
-        "containers.cna.descriptions": {"path": ["containers", "cna", "descriptions"]},
-        "containers.cna.affected": {"path": ["containers", "cna", "affected"]},
-        "containers.cna.references": {"path": ["containers", "cna", "references"]},
-        "containers.cna.problemTypes": {"path": ["containers", "cna", "problemTypes"]},
-        "containers.cna.metrics": {"path": ["containers", "cna", "metrics"]},
-        "containers.cna.impacts": {"path": ["containers", "cna", "impacts"]},
-        "containers.cna.configurations": {"path": ["containers", "cna", "configurations"]},
-        "containers.cna.workarounds": {"path": ["containers", "cna", "workarounds"]},
-        "containers.cna.solutions": {"path": ["containers", "cna", "solutions"]},
-        "containers.cna.exploits": {"path": ["containers", "cna", "exploits"]},
-        "containers.cna.dateAssigned": {"path": ["containers", "cna", "dateAssigned"]},
-        "containers.cna.datePublic": {"path": ["containers", "cna", "datePublic"]},
-        "containers.cna.timeline": {"path": ["containers", "cna", "timeline"]},
-        "containers.cna.credits": {"path": ["containers", "cna", "credits"]},
-        "containers.cna.source": {"path": ["containers", "cna", "source"]},
-        "containers.cna.tags": {"path": ["containers", "cna", "tags"]},
-        "containers.cna.taxonomyMappings": {"path": ["containers", "cna", "taxonomyMappings"]},
-        "containers.cna.cpeApplicability": {"path": ["containers", "cna", "cpeApplicability"]},
-        
-        # ADP Container
-        "containers.adp": {"path": ["containers", "adp"]},
-        # Descriptions
-        "descriptions.english": {"path": ["containers", "cna", "descriptions"], "check": "english_description"},
-        "descriptions.multiple_languages": {"path": ["containers", "cna", "descriptions"], "check": "multiple_languages"},
-        "descriptions.supporting_media": {"path": ["containers", "cna", "descriptions"], "check": "supporting_media"},
-        # Affected
-        "affected.vendor": {"path": ["containers", "cna", "affected"], "check": "has_vendor"},
-        "affected.product": {"path": ["containers", "cna", "affected"], "check": "has_product"},
-        "affected.versions": {"path": ["containers", "cna", "affected"], "check": "has_versions"},
-        "affected.defaultStatus": {"path": ["containers", "cna", "affected"], "check": "has_default_status"},
-        "affected.cpes": {"path": ["containers", "cna", "affected"], "check": "has_cpes"},
-        "affected.modules": {"path": ["containers", "cna", "affected"], "check": "has_modules"},
-        "affected.programFiles": {"path": ["containers", "cna", "affected"], "check": "has_program_files"},
-        "affected.programRoutines": {"path": ["containers", "cna", "affected"], "check": "has_program_routines"},
-        "affected.platforms": {"path": ["containers", "cna", "affected"], "check": "has_platforms"},
-        "affected.repo": {"path": ["containers", "cna", "affected"], "check": "has_repo"},
-        # ProblemTypes
-        "problemTypes.cwe": {"path": ["containers", "cna", "problemTypes"], "check": "has_cwe"},
-        "problemTypes.type": {"path": ["containers", "cna", "problemTypes"], "check": "has_type"},
-        "problemTypes.references": {"path": ["containers", "cna", "problemTypes"], "check": "has_pt_references"},
-        # References
-        "references.advisory": {"path": ["containers", "cna", "references"], "check": "has_advisory_ref"},
-        "references.patch": {"path": ["containers", "cna", "references"], "check": "has_patch_ref"},
-        "references.exploit": {"path": ["containers", "cna", "references"], "check": "has_exploit_ref"},
-        "references.technical": {"path": ["containers", "cna", "references"], "check": "has_technical_ref"},
-        "references.vendor": {"path": ["containers", "cna", "references"], "check": "has_vendor_ref"},
-        "references.named": {"path": ["containers", "cna", "references"], "check": "has_named_ref"},
-        # Metrics
-        "metrics.cvssV4_0": {"path": ["containers", "cna", "metrics"], "check": "has_cvss_v4"},
-        "metrics.cvssV3_1": {"path": ["containers", "cna", "metrics"], "check": "has_cvss_v3_1"},
-        "metrics.cvssV3_0": {"path": ["containers", "cna", "metrics"], "check": "has_cvss_v3_0"},
-        "metrics.cvssV2_0": {"path": ["containers", "cna", "metrics"], "check": "has_cvss_v2"},
-        "metrics.other": {"path": ["containers", "cna", "metrics"], "check": "has_other_metrics"},
-        "metrics.scenarios": {"path": ["containers", "cna", "metrics"], "check": "has_scenarios"},
-    }
-
-def _get_nested_value(data: Dict[str, Any], path: List[str]) -> Any:
-    current = data
-    for key in path:
-        if isinstance(current, dict) and key in current:
-            current = current[key]
-        else:
-            return None
-    return current
-
-def _custom_check(data: Any, check_type: str) -> bool:
-    """Custom check logic ported from legacy completeness_analyzer.py for 100% parity."""
-    if not data:
-        return False
-
-    # Descriptions
-    if check_type == "english_description":
-        if isinstance(data, list):
-            return any(desc.get("lang", "").lower().startswith("en") for desc in data if isinstance(desc, dict))
-        return False
-    if check_type == "multiple_languages":
-        if isinstance(data, list):
-            languages = set(desc.get("lang", "") for desc in data if isinstance(desc, dict))
-            return len(languages) > 1
-        return False
-    if check_type == "supporting_media":
-        if isinstance(data, list):
-            return any(desc.get("media") for desc in data if isinstance(desc, dict))
-        return False
-
-    # Affected
-    if check_type == "has_vendor":
-        if isinstance(data, list):
-            return any("vendor" in item for item in data if isinstance(item, dict))
-        return False
-    if check_type == "has_product":
-        if isinstance(data, list):
-            return any("product" in item for item in data if isinstance(item, dict))
-        return False
-    if check_type == "has_versions":
-        if isinstance(data, list):
-            return any(item.get("versions") for item in data if isinstance(item, dict))
-        return False
-    if check_type == "has_default_status":
-        if isinstance(data, list):
-            return any("defaultStatus" in item for item in data if isinstance(item, dict))
-        return False
-    if check_type == "has_cpes":
-        if isinstance(data, list):
-            return any(item.get("cpes") for item in data if isinstance(item, dict))
-        return False
-    if check_type == "has_modules":
-        if isinstance(data, list):
-            return any(item.get("modules") for item in data if isinstance(item, dict))
-        return False
-    if check_type == "has_program_files":
-        if isinstance(data, list):
-            return any(item.get("programFiles") for item in data if isinstance(item, dict))
-        return False
-    if check_type == "has_program_routines":
-        if isinstance(data, list):
-            return any(item.get("programRoutines") for item in data if isinstance(item, dict))
-        return False
-    if check_type == "has_platforms":
-        if isinstance(data, list):
-            return any(item.get("platforms") for item in data if isinstance(item, dict))
-        return False
-    if check_type == "has_repo":
-        if isinstance(data, list):
-            return any(item.get("repo") for item in data if isinstance(item, dict))
-        return False
-
-    # ProblemTypes
-    if check_type == "has_cwe":
-        if isinstance(data, list):
-            import re
-            cwe_pattern = re.compile(r'CWE-\d+', re.IGNORECASE)
-            
-            for pt in data:
-                if not isinstance(pt, dict):
-                    continue
-                
-                descriptions = pt.get("descriptions", [])
-                for desc in descriptions:
-                    if not isinstance(desc, dict):
-                        continue
-                    
-                    # Check for explicit cweId field (existing logic)
-                    if "cweId" in desc:
-                        return True
-                    
-                    # Check for CWE ID embedded in description text (new logic)
-                    desc_text = desc.get("description", "")
-                    if desc_text and cwe_pattern.search(desc_text):
-                        return True
-            
-            return False
-        return False
-    if check_type == "has_type":
-        if isinstance(data, list):
-            return any(pt.get("type") for pt in data if isinstance(pt, dict))
-        return False
-    if check_type == "has_pt_references":
-        if isinstance(data, list):
-            return any(pt.get("references") for pt in data if isinstance(pt, dict))
-        return False
-
-    # References
-    if check_type == "has_advisory_ref":
-        if isinstance(data, list):
-            return any(ref.get("tags") and any("advisory" in str(tag).lower() for tag in ref["tags"])
-                       for ref in data if isinstance(ref, dict))
-        return False
-    if check_type == "has_patch_ref":
-        if isinstance(data, list):
-            return any(ref.get("tags") and any("patch" in str(tag).lower() for tag in ref["tags"])
-                       for ref in data if isinstance(ref, dict))
-        return False
-    if check_type == "has_exploit_ref":
-        if isinstance(data, list):
-            return any(ref.get("tags") and any("exploit" in str(tag).lower() for tag in ref["tags"])
-                       for ref in data if isinstance(ref, dict))
-        return False
-    if check_type == "has_technical_ref":
-        if isinstance(data, list):
-            return any(ref.get("tags") and any("technical" in str(tag).lower() for tag in ref["tags"])
-                       for ref in data if isinstance(ref, dict))
-        return False
-    if check_type == "has_vendor_ref":
-        if isinstance(data, list):
-            return any(ref.get("tags") and any("vendor" in str(tag).lower() for tag in ref["tags"])
-                       for ref in data if isinstance(ref, dict))
-        return False
-    if check_type == "has_named_ref":
-        if isinstance(data, list):
-            return any(ref.get("name") for ref in data if isinstance(ref, dict))
-        return False
-
-    # Metrics - handle as array of metric objects
-    if check_type == "has_cvss_v4":
-        if isinstance(data, list):
-            return any("cvssV4_0" in metric for metric in data if isinstance(metric, dict))
-        return False
-    if check_type == "has_cvss_v3_1":
-        if isinstance(data, list):
-            return any("cvssV3_1" in metric for metric in data if isinstance(metric, dict))
-        return False
-    if check_type == "has_cvss_v3_0":
-        if isinstance(data, list):
-            return any("cvssV3_0" in metric for metric in data if isinstance(metric, dict))
-        return False
-    if check_type == "has_cvss_v2":
-        if isinstance(data, list):
-            return any("cvssV2_0" in metric for metric in data if isinstance(metric, dict))
-        return False
-    if check_type == "has_other_metrics":
-        if isinstance(data, list):
-            return any(
-                any(k not in ("cvssV4_0", "cvssV3_1", "cvssV3_0", "cvssV2_0") for k in metric.keys())
-                for metric in data if isinstance(metric, dict)
-            )
-        return False
-    if check_type == "has_scenarios":
-        if isinstance(data, list):
-            return any("scenarios" in metric for metric in data if isinstance(metric, dict))
-        return False
-
-    return False
-
-
-def compute_field_utilization(cve_records, field_list):
-    """
-    Calculates the percentage of CNAs that have used each field.
-    """
-    schema_fields = _get_schema_fields()
-    cna_field_usage = defaultdict(set)
-    all_cnas = set()
-
-    for cve in cve_records:
-        cna_id = _get_nested_value(cve, ["cveMetadata", "assignerOrgId"])
-        if not cna_id:
-            continue
-        all_cnas.add(cna_id)
-
-        for field_name in field_list:
-            if field_name not in schema_fields:
-                continue
-            
-            field_info = schema_fields[field_name]
-            path = field_info["path"]
-            check_type = field_info.get("check")
-            
-            value = _get_nested_value(cve, path)
-            
-            is_present = False
-            if check_type:
-                is_present = _custom_check(value, check_type)
-            elif value is not None and value != []:
-                is_present = True
-            
-            if is_present:
-                cna_field_usage[field_name].add(cna_id)
-
-    total_cnas = len(all_cnas)
-    utilization = []
-    for field in field_list:
-        unique_cnas = len(cna_field_usage[field])
-        cna_percent = round(100 * unique_cnas / total_cnas, 1) if total_cnas else 0
-        utilization.append({
-            "field": field,
-            "unique_cnas": unique_cnas,
-            "cna_percent": cna_percent
-        })
-    # Sort by cna_percent descending, then field name ascending
-    utilization.sort(key=lambda x: (-x['cna_percent'], x['field']))
-    return utilization
-
-
-def compute_individual_cna_field_utilization(cve_records, field_list):
-    """
-    Calculates field utilization for each individual CNA.
-    Returns a dictionary mapping CNA shortName to their field utilization data.
-    """
-    from collections import defaultdict
-    import json
-    import os
-    
-    # No need for external mapping - we'll extract shortName directly from CVE records
-    # This matches the approach used in ingest.py load_cna_list function
-    
-    schema_fields = _get_schema_fields()
-    
-    # Track field usage per CNA using shortName as key
-    cna_field_data = defaultdict(lambda: defaultdict(int))  # shortName -> field -> count
-    cna_total_cves = defaultdict(int)  # shortName -> total CVE count
-    
-    for cve in cve_records:
-        # Extract shortName directly from CVE record (matches ingest.py approach)
-        containers = cve.get("containers", {})
-        cna = containers.get("cna", {})
-        provider = cna.get("providerMetadata", {})
-        short_name = provider.get("shortName")
-        
-        if not short_name:
-            continue
-        
-        cna_total_cves[short_name] += 1
-        
-        for field_name in field_list:
-            if field_name not in schema_fields:
-                continue
-            
-            field_info = schema_fields[field_name]
-            path = field_info["path"]
-            check_type = field_info.get("check")
-            
-            value = _get_nested_value(cve, path)
-            
-            is_present = False
-            if check_type:
-                is_present = _custom_check(value, check_type)
-            elif value is not None and value != []:
-                is_present = True
-            
-            if is_present:
-                cna_field_data[short_name][field_name] += 1
-    
-    # Get field metadata from CANONICAL_FIELDS
-    field_metadata = {}
-    try:
-        from run_pipeline import CANONICAL_FIELDS
-        field_metadata = {f['field']: f for f in CANONICAL_FIELDS}
-    except ImportError:
-        print("Warning: Could not import CANONICAL_FIELDS for field metadata")
-    
-    # Generate individual CNA field utilization data
-    cna_utilization_data = {}
-    
-    for short_name, field_counts in cna_field_data.items():
-        total_cves = cna_total_cves[short_name]
-        utilization = []
-        
-        for field in field_list:
-            field_count = field_counts.get(field, 0)
-            percent = round(100 * field_count / total_cves, 1) if total_cves > 0 else 0.0
-            
-            # Get field metadata
-            field_meta = field_metadata.get(field, {})
-            
-            utilization.append({
-                "field": field,
-                "percent": percent,
-                "cve_count": field_count,
-                "total_cves": total_cves,
-                "importance": field_meta.get('importance', 'Medium'),
-                "description": field_meta.get('description', ''),
-                "cna_scorecard_category": field_meta.get('cna_scorecard_category')
-            })
-        
-        # Sort by percent descending, then field name ascending
-        utilization.sort(key=lambda x: (-x['percent'], x['field']))
-        cna_utilization_data[short_name] = utilization
-    
-    return cna_utilization_data
diff --git a/src/cvedb/cna/config.py b/src/cvedb/cna/config.py
deleted file mode 100644
index 350296e169e..00000000000
--- a/src/cvedb/cna/config.py
+++ /dev/null
@@ -1,233 +0,0 @@
-"""
-Configuration management for CNA Scorecard Pipeline.
-
-This module centralizes all configuration values, file paths, and scoring rules
-to improve maintainability and make the pipeline more configurable.
-"""
-import os
-import json
-from typing import Dict, Any, List
-from pathlib import Path
-
-# Base directories
-PIPELINE_DIR = Path(__file__).parent
-PROJECT_ROOT = PIPELINE_DIR.parent
-CVE_DATA_DIR = PROJECT_ROOT / "cve_data"
-WEB_DATA_DIR = PROJECT_ROOT / "web" / "data"
-
-# Configuration file paths
-RULES_FILE = PIPELINE_DIR / "rules.json"
-CWE_IDS_FILE = PIPELINE_DIR / "cwe_ids.json"
-CNA_LIST_FILE = WEB_DATA_DIR / "cna_list.json"
-
-# Output directories
-COMPLETENESS_DIR = WEB_DATA_DIR / "completeness"
-CNA_DATA_DIR = WEB_DATA_DIR / "cna"
-
-# Date configuration
-DATE_FORMAT = "%Y-%m-%d"
-ANALYSIS_PERIOD_MONTHS = 6
-
-# CVE Schema version configuration
-CVE_SCHEMA_VERSION = "5.1"  # Current default version
-SUPPORTED_SCHEMA_VERSIONS = ["5.0", "5.1", "5.2"]  # All versions we can process
-
-# Scoring configuration
-class ScoringConfig:
-    """Configuration for CVE scoring logic."""
-    
-    def __init__(self):
-        self._rules = self._load_scoring_rules()
-        self._valid_cwe_ids = self._load_valid_cwe_ids()
-    
-    def _load_scoring_rules(self) -> Dict[str, Any]:
-        """Load scoring rules from rules.json."""
-        try:
-            with open(RULES_FILE, 'r') as f:
-                return json.load(f)
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Scoring rules file not found: {RULES_FILE}")
-        except json.JSONDecodeError as e:
-            raise ValueError(f"Invalid JSON in scoring rules file: {e}")
-    
-    def _load_valid_cwe_ids(self) -> set:
-        """Load valid CWE IDs from cwe_ids.json."""
-        try:
-            with open(CWE_IDS_FILE, 'r') as f:
-                return set(json.load(f))
-        except FileNotFoundError:
-            raise FileNotFoundError(f"CWE IDs file not found: {CWE_IDS_FILE}")
-        except json.JSONDecodeError as e:
-            raise ValueError(f"Invalid JSON in CWE IDs file: {e}")
-    
-    @property
-    def rules(self) -> Dict[str, Any]:
-        """Get scoring rules."""
-        return self._rules
-    
-    @property
-    def valid_cwe_ids(self) -> set:
-        """Get valid CWE IDs."""
-        return self._valid_cwe_ids
-    
-    def get_category_weight(self, category: str) -> int:
-        """Get weight for a scoring category."""
-        return self._rules.get(category, {}).get('weight', 0)
-    
-    def get_category_criteria(self, category: str) -> List[str]:
-        """Get criteria for a scoring category."""
-        return self._rules.get(category, {}).get('criteria', [])
-
-# Field mapping for CNA Scorecard categories
-CNA_SCORECARD_FIELDS = {
-    # Foundational Completeness (50% weight)
-    'containers.cna.descriptions': 'foundationalCompleteness',
-    'containers.cna.affected': 'foundationalCompleteness',
-    'containers.cna.references': 'foundationalCompleteness',
-    
-    # Root Cause Analysis (15% weight)
-    'problemTypes.cwe': 'rootCauseAnalysis',
-    
-    # Severity and Impact Context (15% weight)
-    'metrics.cvssV3_0': 'severityAndImpactContext',
-    'metrics.cvssV3_1': 'severityAndImpactContext',
-    'metrics.cvssV4_0': 'severityAndImpactContext',
-    
-    # Software Identification (10% weight)
-    'affected.cpes': 'softwareIdentification',
-    
-    # Patch Information (10% weight)
-    'references.patch': 'patchinfo',
-}
-
-# Canonical fields for completeness analysis
-CANONICAL_FIELDS = [
-    # CNA ScoreCard Measured Fields (High-Level Criteria Only)
-    {"field": "containers.cna.descriptions", "importance": "High", "description": "Vulnerability descriptions", "cna_scorecard_category": "foundationalCompleteness"},
-    {"field": "containers.cna.affected", "importance": "High", "description": "Affected products and versions", "cna_scorecard_category": "foundationalCompleteness"},
-    {"field": "containers.cna.references", "importance": "High", "description": "Patch Info URLs and documentation", "cna_scorecard_category": "foundationalCompleteness"},
-    {"field": "problemTypes.cwe", "importance": "High", "description": "Common Weakness Enumeration identifiers", "cna_scorecard_category": "rootCauseAnalysis"},
-    {"field": "metrics.cvssV3_1", "importance": "High", "description": "CVSS v3.1 metrics", "cna_scorecard_category": "severityAndImpactContext"},
-    {"field": "metrics.cvssV3_0", "importance": "High", "description": "CVSS v3.0 metrics", "cna_scorecard_category": "severityAndImpactContext"},
-    {"field": "metrics.cvssV4_0", "importance": "High", "description": "CVSS v4.0 metrics", "cna_scorecard_category": "severityAndImpactContext"},
-    {"field": "affected.cpes", "importance": "High", "description": "Common Platform Enumeration identifiers", "cna_scorecard_category": "softwareIdentification"},
-    {"field": "references.patch", "importance": "High", "description": "Patch references", "cna_scorecard_category": "patchinfo"},
-    
-    # Non-measured fields (no cna_scorecard_category)
-    {"field": "descriptions.english", "importance": "Medium", "description": "At least one English description"},
-    {"field": "affected.vendor", "importance": "Medium", "description": "Vendor information in affected products"},
-    {"field": "affected.product", "importance": "Medium", "description": "Product information in affected products"},
-    {"field": "affected.versions", "importance": "Medium", "description": "Version information"},
-    {"field": "containers.cna.title", "importance": "Medium", "description": "Brief title or headline"},
-    {"field": "problemTypes.type", "importance": "Medium", "description": "Problem type classification"},
-    {"field": "containers.cna.problemTypes", "importance": "High", "description": "Problem type information (CWE, etc.)"},
-    
-    # CVSS and metrics (non-measured - cvssV3_0, cvssV3_1, cvssV4 are measured above)
-    {"field": "metrics.cvssV2_0", "importance": "Medium", "description": "CVSS v2.0 metrics"},
-    {"field": "metrics.scenarios", "importance": "Medium", "description": "Metric scenarios"},
-    {"field": "metrics.other", "importance": "Medium", "description": "Other metric formats"},
-    {"field": "containers.cna.metrics", "importance": "High", "description": "Impact metrics (CVSS scores)"},
-    
-    # Reference types (non-measured - only patch/advisory are measured above)
-    {"field": "references.advisory", "importance": "Medium", "description": "Advisory references"},
-    {"field": "references.article", "importance": "Medium", "description": "Article references"},
-    {"field": "references.report", "importance": "Medium", "description": "Report references"},
-    {"field": "references.web", "importance": "Medium", "description": "Web references"},
-    {"field": "references.mailing-list", "importance": "Medium", "description": "Mailing list references"},
-    
-    # Affected product details
-    {"field": "affected.defaultStatus", "importance": "Medium", "description": "Default status for affected products"},
-    {"field": "affected.modules", "importance": "Medium", "description": "Affected modules or components"},
-    {"field": "affected.programFiles", "importance": "Medium", "description": "Affected program files"},
-    {"field": "affected.programRoutines", "importance": "Medium", "description": "Affected functions or methods"},
-    {"field": "affected.repo", "importance": "Medium", "description": "Source code repository URL"},
-    
-    # Additional CNA-provided content
-    {"field": "containers.cna.impacts", "importance": "Medium", "description": "Impact descriptions"},
-    {"field": "containers.cna.solutions", "importance": "Medium", "description": "Solutions and remediations"},
-    {"field": "containers.cna.workarounds", "importance": "Medium", "description": "Workaround information"},
-    {"field": "containers.cna.exploits", "importance": "Medium", "description": "Exploit information"},
-    {"field": "containers.cna.timeline", "importance": "Medium", "description": "Vulnerability timeline"},
-    {"field": "containers.cna.credits", "importance": "Medium", "description": "Credit information"},
-    {"field": "containers.cna.source", "importance": "Medium", "description": "Source information"},
-    {"field": "containers.cna.configurations", "importance": "Medium", "description": "Configuration requirements"},
-    {"field": "containers.cna.tags", "importance": "Low", "description": "CNA-provided tags"},
-    {"field": "containers.cna.datePublic", "importance": "Low", "description": "Date the vulnerability was disclosed publicly"},
-    {"field": "containers.cna.dateAssigned", "importance": "Low", "description": "Date the CVE ID was assigned"},
-    
-    # Enhanced descriptions (matching deployed field names) - NOT measured by CNA ScoreCard
-    {"field": "descriptions.multiple_languages", "importance": "Low", "description": "Multiple language descriptions"},
-    {"field": "descriptions.supporting_media", "importance": "Low", "description": "Supporting media in descriptions"},
-    
-    # ADP Container (included in deployed version)
-    {"field": "containers.adp", "importance": "Low", "description": "Authorized Data Publisher container"},
-]
-
-# Field list for completeness analysis
-FIELD_LIST = [f["field"] for f in CANONICAL_FIELDS]
-
-# Logging configuration
-LOGGING_CONFIG = {
-    'version': 1,
-    'disable_existing_loggers': False,
-    'formatters': {
-        'standard': {
-            'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
-        },
-        'detailed': {
-            'format': '%(asctime)s [%(levelname)s] %(name)s:%(lineno)d: %(message)s'
-        }
-    },
-    'handlers': {
-        'console': {
-            'level': 'INFO',
-            'class': 'logging.StreamHandler',
-            'formatter': 'standard'
-        },
-        'file': {
-            'level': 'DEBUG',
-            'class': 'logging.FileHandler',
-            'filename': 'pipeline.log',
-            'formatter': 'detailed'
-        }
-    },
-    'loggers': {
-        'cnascorecard': {
-            'handlers': ['console', 'file'],
-            'level': 'DEBUG',
-            'propagate': False
-        }
-    },
-    'root': {
-        'level': 'INFO',
-        'handlers': ['console']
-    }
-}
-
-def get_config() -> Dict[str, Any]:
-    """Get complete configuration dictionary."""
-    return {
-        'directories': {
-            'pipeline': str(PIPELINE_DIR),
-            'project_root': str(PROJECT_ROOT),
-            'cve_data': str(CVE_DATA_DIR),
-            'web_data': str(WEB_DATA_DIR),
-            'completeness': str(COMPLETENESS_DIR),
-            'cna_data': str(CNA_DATA_DIR),
-        },
-        'files': {
-            'rules': str(RULES_FILE),
-            'cwe_ids': str(CWE_IDS_FILE),
-            'cna_list': str(CNA_LIST_FILE),
-        },
-        'analysis': {
-            'date_format': DATE_FORMAT,
-            'period_months': ANALYSIS_PERIOD_MONTHS,
-        },
-        'fields': {
-            'scorecard_mapping': CNA_SCORECARD_FIELDS,
-            'canonical_fields': CANONICAL_FIELDS,
-            'field_list': FIELD_LIST,
-        },
-        'logging': LOGGING_CONFIG,
-    }
diff --git a/src/cvedb/cna/cwe_ids.json b/src/cvedb/cna/cwe_ids.json
deleted file mode 100644
index b94177244b8..00000000000
--- a/src/cvedb/cna/cwe_ids.json
+++ /dev/null
@@ -1,3 +0,0 @@
-[
-  "5","6","7","8","9","11","12","13","14","15","20","22","23","24","25","26","27","28","29","30","31","32","33","34","35","36","37","38","39","40","41","42","43","44","45","46","47","48","49","50","51","52","53","54","55","56","57","58","59","61","62","64","65","66","67","69","71","72","73","74","75","76","77","78","79","80","81","82","83","84","85","86","87","88","89","90","91","92","93","94","95","96","97","98","99","102","103","104","105","106","107","108","109","110","111","112","113","114","115","116","117","118","119","120","121","122","123","124","125","126","127","128","129","130","131","132","134","135","138","140","141","142","143","144","145","146","147","148","149","150","151","152","153","154","155","156","157","158","159","160","161","162","163","164","165","166","167","168","170","172","173","174","175","176","177","178","179","180","181","182","183","184","185","186","187","188","190","191","192","193","194","195","196","197","198","200","201","202","203","204","205","206","207","208","209","210","211","212","213","214","215","216","217","218","219","220","221","222","223","224","225","226","228","229","230","231","232","233","234","235","236","237","238","239","240","241","242","243","244","245","246","247","248","249","250","252","253","256","257","258","259","260","261","262","263","266","267","268","269","270","271","272","273","274","276","277","278","279","280","281","282","283","284","285","286","287","288","289","290","291","292","293","294","295","296","297","298","299","300","301","302","303","304","305","306","307","308","309","311","312","313","314","315","316","317","318","319","321","322","323","324","325","326","327","328","329","330","331","332","333","334","335","336","337","338","339","340","341","342","343","344","345","346","347","348","349","350","351","352","353","354","356","357","358","359","360","362","363","364","365","366","367","368","369","370","372","373","374","375","377","378","379","382","383","384","385","386","390","391","392","393","394","395","396","397","400","401","402","403","404","405","406","407","408","409","410","412","413","414","415","416","419","420","421","422","423","424","425","426","427","428","430","431","432","433","434","435","436","437","439","440","441","443","444","446","447","448","449","450","451","453","454","455","456","457","458","459","460","462","463","464","466","467","468","469","470","471","472","473","474","475","476","477","478","479","480","481","482","483","484","486","487","488","489","491","492","493","494","495","496","497","498","499","500","501","502","506","507","508","509","510","511","512","514","515","516","520","521","522","523","524","525","526","527","528","529","530","531","532","533","534","535","536","537","538","539","540","541","542","543","544","545","546","547","548","549","550","551","552","553","554","555","556","558","560","561","562","563","564","565","566","567","568","570","571","572","573","574","575","576","577","578","579","580","581","582","583","584","585","586","587","588","589","590","591","592","593","594","595","596","597","598","599","600","601","602","603","605","606","607","608","609","610","611","612","613","614","615","616","617","618","619","620","621","622","623","624","625","626","627","628","636","637","638","639","640","641","642","643","644","645","646","647","648","649","650","651","652","653","654","655","656","657","662","663","664","665","666","667","668","669","670","671","672","673","674","675","676","680","681","682","683","684","685","686","687","688","689","690","691","692","693","694","695","696","697","698","703","704","705","706","707","708","710","732","733","749","754","755","756","757","758","759","760","761","762","763","764","765","766","767","768","769","770","771","772","773","774","775","776","777","778","779","780","781","782","783","784","785","786","787","788","789","790","791","792","793","794","795","796","797","798","799","804","805","806","807","820","821","822","823","824","825","826","827","828","829","830","831","832","833","834","835","836","837","838","839","841","842","843","862","863","908","909","910","911","912","913","914","915","916","917","918","920","921","922","923","924","925","926","927","939","940","941","942","943","1004","1007","1021","1022","1023","1024","1025","1037","1038","1039","1041","1042","1043","1044","1045","1046","1047","1048","1049","1050","1051","1052","1053","1054","1055","1056","1057","1058","1059","1060","1061","1062","1063","1064","1065","1066","1067","1068","1069","1070","1071","1072","1073","1074","1075","1076","1077","1078","1079","1080","1082","1083","1084","1085","1086","1087","1088","1089","1090","1091","1092","1093","1094","1095","1096","1097","1098","1099","1100","1101","1102","1103","1104","1105","1106","1107","1108","1109","1110","1111","1112","1113","1114","1115","1116","1117","1118","1119","1120","1121","1122","1123","1124","1125","1126","1127","1164","1173","1174","1176","1177","1187","1188","1189","1190","1191","1192","1193","1204","1209","1220","1221","1222","1223","1224","1229","1230","1231","1232","1233","1234","1235","1236","1239","1240","1241","1242","1243","1244","1245","1246","1247","1248","1249","1250","1251","1252","1253","1254","1255","1256","1257","1258","1259","1260","1261","1262","1263","1264","1265","1266","1267","1268","1269","1270","1271","1272","1273","1274","1275","1276","1277","1278","1279","1280","1281","1282","1283","1284","1285","1286","1287","1288","1289","1290","1291","1292","1293","1294","1295","1296","1297","1298","1299","1300","1301","1302","1303","1304","1310","1311","1312","1313","1314","1315","1316","1317","1318","1319","1320","1321","1322","1323","1324","1325","1326","1327","1328","1329","1330","1331","1332","1333","1334","1335","1336","1338","1339","1341","1342","1351","1357","1384","1385","1386","1389","1390","1391","1392","1393","1394","1395","1419","1420","1421","1422","1423","1426","1427","1428","1429","1431"
-]
diff --git a/src/cvedb/cna/data_quality.py b/src/cvedb/cna/data_quality.py
deleted file mode 100644
index 9f5808b13ea..00000000000
--- a/src/cvedb/cna/data_quality.py
+++ /dev/null
@@ -1,320 +0,0 @@
-#!/usr/bin/env python3
-"""
-Rebuild data quality JSON with CNAScorecard-style name matching.
-
-This script implements sophisticated name matching to identify:
-1. Truly unmatched CNAs (not in official registry)
-2. Unofficial CNAs (matched but using non-standard names)
-3. Official CNAs (properly matched)
-
-Matching strategies (in order):
-1. Exact match
-2. Case-insensitive match
-3. Normalized match (remove spaces, hyphens, underscores)
-4. Partial match (substring containment)
-"""
-
-import json
-import sys
-from pathlib import Path
-
-# Get the data directory
-# Get the data directory
-# Get the project root
-SCRIPT_DIR = Path(__file__).parent.resolve()
-PROJECT_ROOT = SCRIPT_DIR.parent.parent.parent
-DATA_DIR = PROJECT_ROOT / "data"
-WEB_DATA_DIR = PROJECT_ROOT / "dist" / "data"
-CACHE_DIR = DATA_DIR / "raw"
-
-
-def load_json(filepath):
-    """Load JSON file."""
-    with open(filepath, 'r', encoding='utf-8') as f:
-        return json.load(f)
-
-
-def save_json(filepath, data):
-    """Save JSON file."""
-    with open(filepath, 'w', encoding='utf-8') as f:
-        json.dump(data, f, indent=2)
-
-
-def normalize_name(name):
-    """Normalize a name by removing spaces, hyphens, underscores and lowercasing."""
-    if not name:
-        return ""
-    return name.lower().replace(' ', '').replace('-', '').replace('_', '').replace('.', '')
-
-
-def build_official_cna_lookups(cna_list):
-    """
-    Build lookup dictionaries for official CNAs.
-    
-    Returns:
-        - short_name_map: shortName -> official entry
-        - org_name_map: organizationName -> official entry  
-        - all_official_names: set of all names (short + org)
-        - normalized_map: normalized_name -> official entry
-    """
-    short_name_map = {}
-    org_name_map = {}
-    all_official_names = set()
-    normalized_map = {}
-    
-    for cna in cna_list:
-        short_name = cna.get('shortName', '')
-        org_name = cna.get('organizationName', '')
-        
-        if short_name:
-            short_name_map[short_name] = cna
-            short_name_map[short_name.lower()] = cna  # Also store lowercase
-            all_official_names.add(short_name)
-            all_official_names.add(short_name.lower())
-            
-            # Normalized version
-            norm = normalize_name(short_name)
-            if norm:
-                normalized_map[norm] = cna
-        
-        if org_name:
-            org_name_map[org_name] = cna
-            org_name_map[org_name.lower()] = cna
-            all_official_names.add(org_name)
-            all_official_names.add(org_name.lower())
-            
-            # Normalized version
-            norm = normalize_name(org_name)
-            if norm:
-                normalized_map[norm] = cna
-    
-    return short_name_map, org_name_map, all_official_names, normalized_map
-
-
-def map_cve_name_to_official(cve_name, short_name_map, org_name_map, normalized_map, cna_list):
-    """
-    Attempt to match a CVE CNA name to an official CNA entry.
-    
-    Matching strategies (in order of preference):
-    1. Exact match on shortName
-    2. Case-insensitive match on shortName
-    3. Exact match on organizationName
-    4. Case-insensitive match on organizationName
-    5. Normalized match (remove spaces, hyphens, underscores)
-    6. Partial match (substring containment with min length)
-    
-    Returns:
-        tuple: (matched_official_entry or None, match_type, confidence)
-        match_type: 'exact_short', 'case_short', 'exact_org', 'case_org', 'normalized', 'partial', None
-        confidence: 'high', 'medium', 'low', None
-    """
-    if not cve_name:
-        return None, None, None
-    
-    # 1. Exact match on shortName
-    if cve_name in short_name_map:
-        return short_name_map[cve_name], 'exact_short', 'high'
-    
-    # 2. Case-insensitive match on shortName
-    cve_lower = cve_name.lower()
-    if cve_lower in short_name_map:
-        return short_name_map[cve_lower], 'case_short', 'high'
-    
-    # 3. Exact match on organizationName
-    if cve_name in org_name_map:
-        return org_name_map[cve_name], 'exact_org', 'high'
-    
-    # 4. Case-insensitive match on organizationName
-    if cve_lower in org_name_map:
-        return org_name_map[cve_lower], 'case_org', 'high'
-    
-    # 5. Normalized match
-    normalized_cve = normalize_name(cve_name)
-    if normalized_cve and normalized_cve in normalized_map:
-        return normalized_map[normalized_cve], 'normalized', 'medium'
-    
-    # 6. Partial matching (substring containment)
-    # Only for names with reasonable length to avoid false positives
-    if len(cve_name) > 3:
-        for cna in cna_list:
-            short = cna.get('shortName', '').lower()
-            org = cna.get('organizationName', '').lower()
-            
-            # Check if CVE name contains official name or vice versa
-            if short and len(short) > 3:
-                if cve_lower in short or short in cve_lower:
-                    return cna, 'partial', 'low'
-            
-            if org and len(org) > 5:
-                if cve_lower in org or org in cve_lower:
-                    return cna, 'partial', 'low'
-    
-    return None, None, None
-
-
-def analyze_cna_names(cna_analysis, official_cna_list):
-    """
-    Analyze all CNA names from our analysis against the official registry.
-    
-    Returns categorized results with match information.
-    """
-    # Build lookup structures
-    short_name_map, org_name_map, all_official_names, normalized_map = build_official_cna_lookups(official_cna_list)
-    
-    # Results
-    exact_matches = []      # Exact shortName match - official and correct
-    case_matches = []       # Case mismatch - should standardize
-    org_matches = []        # Matched via organizationName - should use shortName
-    normalized_matches = [] # Matched via normalization - naming inconsistency
-    partial_matches = []    # Partial match - likely the same but different naming
-    unmatched = []          # No match found - potentially not a registered CNA
-    
-    # Also track the match details
-    match_details = {}
-    
-    for cna_name, cna_data in cna_analysis.items():
-        official, match_type, confidence = map_cve_name_to_official(
-            cna_name, short_name_map, org_name_map, normalized_map, official_cna_list
-        )
-        
-        result = {
-            'cna_name': cna_name,
-            'cve_count': cna_data.get('count', 0),
-            'kev_count': cna_data.get('kev_count', 0),
-            'epss_high_count': cna_data.get('epss_high_count', 0),
-        }
-        
-        if official:
-            result['official_short_name'] = official.get('shortName', '')
-            result['official_org_name'] = official.get('organizationName', '')
-            result['official_id'] = official.get('cnaID', '')
-            result['match_type'] = match_type
-            result['confidence'] = confidence
-            
-            if match_type == 'exact_short':
-                exact_matches.append(result)
-            elif match_type == 'case_short':
-                case_matches.append(result)
-            elif match_type in ('exact_org', 'case_org'):
-                org_matches.append(result)
-            elif match_type == 'normalized':
-                normalized_matches.append(result)
-            elif match_type == 'partial':
-                partial_matches.append(result)
-        else:
-            result['match_type'] = None
-            result['confidence'] = None
-            unmatched.append(result)
-        
-        match_details[cna_name] = result
-    
-    # Sort by CVE count descending
-    for lst in [exact_matches, case_matches, org_matches, normalized_matches, partial_matches, unmatched]:
-        lst.sort(key=lambda x: x['cve_count'], reverse=True)
-    
-    return {
-        'exact_matches': exact_matches,
-        'case_matches': case_matches,
-        'org_matches': org_matches,
-        'normalized_matches': normalized_matches,
-        'partial_matches': partial_matches,
-        'unmatched': unmatched,
-        'match_details': match_details
-    }
-
-
-def main():
-    """Main entry point."""
-    print("Rebuilding data quality analysis with CNAScorecard-style name matching...")
-    
-    # Load official CNA list
-    cna_list_path = CACHE_DIR / "cna_list.json"
-    if not cna_list_path.exists():
-        print(f"ERROR: Official CNA list not found at {cna_list_path}")
-        sys.exit(1)
-    
-    official_cna_list = load_json(cna_list_path)
-    print(f"Loaded {len(official_cna_list)} official CNAs from registry")
-    
-    # Load our CNA analysis
-    cna_analysis_path = WEB_DATA_DIR / "cna_analysis.json"
-    if not cna_analysis_path.exists():
-        print(f"ERROR: CNA analysis not found at {cna_analysis_path}")
-        sys.exit(1)
-    
-    cna_analysis = load_json(cna_analysis_path)
-    # Convert cna_list array to dict keyed by name for analysis
-    cna_list_data = cna_analysis.get('cna_list', [])
-    cna_data = {item['name']: item for item in cna_list_data if 'name' in item}
-    print(f"Loaded {len(cna_data)} CNAs from analysis")
-    
-    # Analyze names
-    results = analyze_cna_names(cna_data, official_cna_list)
-    
-    # Calculate statistics
-    stats = {
-        'total_cnas_in_analysis': len(cna_data),
-        'official_cna_registry_count': len(official_cna_list),
-        'exact_matches': len(results['exact_matches']),
-        'case_mismatches': len(results['case_matches']),
-        'org_name_matches': len(results['org_matches']),
-        'normalized_matches': len(results['normalized_matches']),
-        'partial_matches': len(results['partial_matches']),
-        'unmatched': len(results['unmatched']),
-    }
-    
-    # Total CVEs in each category
-    stats['exact_match_cves'] = sum(x['cve_count'] for x in results['exact_matches'])
-    stats['case_mismatch_cves'] = sum(x['cve_count'] for x in results['case_matches'])
-    stats['org_name_match_cves'] = sum(x['cve_count'] for x in results['org_matches'])
-    stats['normalized_match_cves'] = sum(x['cve_count'] for x in results['normalized_matches'])
-    stats['partial_match_cves'] = sum(x['cve_count'] for x in results['partial_matches'])
-    stats['unmatched_cves'] = sum(x['cve_count'] for x in results['unmatched'])
-    
-    # Calculate percentages
-    total_cves = sum([
-        stats['exact_match_cves'], stats['case_mismatch_cves'], 
-        stats['org_name_match_cves'], stats['normalized_match_cves'],
-        stats['partial_match_cves'], stats['unmatched_cves']
-    ])
-    
-    if total_cves > 0:
-        stats['exact_match_pct'] = round(stats['exact_match_cves'] / total_cves * 100, 2)
-        stats['issues_pct'] = round((total_cves - stats['exact_match_cves']) / total_cves * 100, 2)
-    
-    print(f"\n=== Data Quality Summary ===")
-    print(f"Total CNAs analyzed: {stats['total_cnas_in_analysis']}")
-    print(f"Official registry size: {stats['official_cna_registry_count']}")
-    print(f"\nMatching Results:")
-    print(f"  Exact matches: {stats['exact_matches']} CNAs ({stats['exact_match_cves']:,} CVEs)")
-    print(f"  Case mismatches: {stats['case_mismatches']} CNAs ({stats['case_mismatch_cves']:,} CVEs)")
-    print(f"  Org name matches: {stats['org_name_matches']} CNAs ({stats['org_name_match_cves']:,} CVEs)")
-    print(f"  Normalized matches: {stats['normalized_matches']} CNAs ({stats['normalized_match_cves']:,} CVEs)")
-    print(f"  Partial matches: {stats['partial_matches']} CNAs ({stats['partial_match_cves']:,} CVEs)")
-    print(f"  Unmatched: {stats['unmatched']} CNAs ({stats['unmatched_cves']:,} CVEs)")
-    
-    # Build output
-    output = {
-        'stats': stats,
-        'exact_matches': results['exact_matches'][:50],  # Top 50 only
-        'case_mismatches': results['case_matches'],
-        'org_name_matches': results['org_matches'],
-        'normalized_matches': results['normalized_matches'],
-        'partial_matches': results['partial_matches'],
-        'unmatched': results['unmatched'],
-    }
-    
-    # Save to web data directory
-    output_path = WEB_DATA_DIR / "data_quality.json"
-    save_json(output_path, output)
-    print(f"\nSaved data quality analysis to {output_path}")
-    
-    # Also print top unmatched for review
-    if results['unmatched']:
-        print(f"\n=== Top 10 Unmatched CNAs ===")
-        for item in results['unmatched'][:10]:
-            print(f"  {item['cna_name']}: {item['cve_count']:,} CVEs")
-
-
-if __name__ == '__main__':
-    main()
diff --git a/src/cvedb/cna/ingest.py b/src/cvedb/cna/ingest.py
deleted file mode 100644
index 77db5e1e7ff..00000000000
--- a/src/cvedb/cna/ingest.py
+++ /dev/null
@@ -1,800 +0,0 @@
-"""
-ingest.py: Load CVE and CNA data from cve_data directory (CVE5 format).
-
-This module provides functions to load and validate CVE records from the filesystem,
-with support for date filtering, CNA extraction, and parallel processing.
-"""
-import logging
-from datetime import datetime
-from pathlib import Path
-from typing import List, Dict, Any, Optional, Tuple
-from glob import glob
-from concurrent.futures import ProcessPoolExecutor, as_completed
-import multiprocessing
-import os
-
-from .config import CVE_DATA_DIR, DATE_FORMAT
-from .utils import load_json_file, validate_cve_record, extract_cna_short_name, ProgressTracker
-
-# Initialize logging
-logger = logging.getLogger('cnascorecard.ingest')
-
-def load_cve_records(
-    cve_dir: Optional[str] = None, 
-    start_date: Optional[str] = None, 
-    end_date: Optional[str] = None
-) -> List[Dict[str, Any]]:
-    """
-    Load CVE JSON records from the cve_data directory, optionally filtering by datePublished.
-    
-    Args:
-        cve_dir: Path to CVE data directory (defaults to config value)
-        start_date: Start date filter in 'YYYY-MM-DD' format
-        end_date: End date filter in 'YYYY-MM-DD' format
-        
-    Returns:
-        List of CVE record dictionaries
-        
-    Note:
-        When date filtering is provided, searches all year folders since CVEs can be published
-        in any year regardless of their CVE identifier year (e.g., CVE-2015 published in 2025).
-    """
-    if cve_dir is None:
-        cve_dir = str(CVE_DATA_DIR)
-    
-    logger.info(f"Loading CVE records from {cve_dir}")
-    if start_date or end_date:
-        logger.info(f"Date filtering: {start_date} to {end_date}")
-    
-    # Get list of CVE files to process
-    cve_files = _get_cve_file_list(cve_dir, start_date, end_date)
-    
-    if not cve_files:
-        logger.warning("No CVE files found to process")
-        return []
-    
-    logger.info(f"Processing {len(cve_files)} CVE files")
-    
-    # Load and filter CVE records
-    records = _load_and_filter_cves(cve_files, start_date, end_date)
-    
-    logger.info(f"Successfully loaded {len(records)} CVE records")
-    return records
-
-
-def _get_cve_file_list(
-    cve_dir: str, 
-    start_date: Optional[str], 
-    end_date: Optional[str]
-) -> List[str]:
-    """
-    Get list of CVE files to process based on filtering requirements.
-    
-    Args:
-        cve_dir: Path to CVE data directory
-        start_date: Start date filter
-        end_date: End date filter
-        
-    Returns:
-        List of CVE file paths
-    """
-    cve_files = []
-    cves_dir = Path(cve_dir) / "cves"
-    
-    if not cves_dir.exists():
-        logger.error(f"CVE directory not found: {cves_dir}")
-        return []
-    
-    if start_date or end_date:
-        # When date filtering is needed, check all year folders
-        logger.info("Date filtering requested - scanning all CVE year folders")
-        year_dirs = _get_year_directories(cves_dir)
-        
-        for year in year_dirs:
-            year_files = _get_year_files(cves_dir, year)
-            cve_files.extend(year_files)
-            logger.debug(f"Found {len(year_files)} CVE files in {year}")
-    else:
-        # When no date filtering, optimize by only loading recent years
-        logger.info("No date filtering - optimizing by loading recent years only")
-        recent_years = ['2024', '2025']
-        
-        for year in recent_years:
-            if (cves_dir / year).exists():
-                year_files = _get_year_files(cves_dir, year)
-                cve_files.extend(year_files)
-                logger.debug(f"Found {len(year_files)} CVE files in {year}")
-    
-    return cve_files
-
-
-def _get_year_directories(cves_dir: Path) -> List[str]:
-    """
-    Get sorted list of year directories in CVE data directory.
-    
-    Args:
-        cves_dir: Path to cves directory
-        
-    Returns:
-        Sorted list of year directory names
-    """
-    try:
-        year_dirs = [
-            d.name for d in cves_dir.iterdir() 
-            if d.is_dir() and d.name.isdigit()
-        ]
-        return sorted(year_dirs)
-    except OSError as e:
-        logger.error(f"Error reading year directories from {cves_dir}: {e}")
-        return []
-
-
-def _get_year_files(cves_dir: Path, year: str) -> List[str]:
-    """
-    Get all CVE files for a specific year.
-    
-    Args:
-        cves_dir: Path to cves directory
-        year: Year directory name
-        
-    Returns:
-        List of CVE file paths for the year
-    """
-    year_pattern = str(cves_dir / year / "**" / "CVE-*.json")
-    return glob(year_pattern, recursive=True)
-
-
-def _load_and_filter_cves(
-    cve_files: List[str], 
-    start_date: Optional[str], 
-    end_date: Optional[str],
-    use_parallel: bool = True,
-    max_workers: Optional[int] = None
-) -> List[Dict[str, Any]]:
-    """
-    Load CVE files and apply date filtering.
-    
-    Args:
-        cve_files: List of CVE file paths
-        start_date: Start date filter
-        end_date: End date filter
-        use_parallel: Whether to use parallel processing (default True)
-        max_workers: Number of worker processes (default: CPU count, max 8)
-        
-    Returns:
-        List of filtered CVE records
-    """
-    # Parse date filters
-    start_dt = None
-    end_dt = None
-    
-    if start_date:
-        try:
-            start_dt = datetime.strptime(start_date, DATE_FORMAT)
-        except ValueError as e:
-            logger.error(f"Invalid start date format '{start_date}': {e}")
-            return []
-    
-    if end_date:
-        try:
-            end_dt = datetime.strptime(end_date, DATE_FORMAT)
-        except ValueError as e:
-            logger.error(f"Invalid end date format '{end_date}': {e}")
-            return []
-    
-    # Choose parallel or sequential processing
-    if use_parallel and len(cve_files) > 100:
-        return _load_cves_parallel(cve_files, start_dt, end_dt, max_workers)
-    else:
-        return _load_cves_sequential(cve_files, start_dt, end_dt)
-
-
-def _load_cves_sequential(
-    cve_files: List[str],
-    start_dt: Optional[datetime],
-    end_dt: Optional[datetime]
-) -> List[Dict[str, Any]]:
-    """Load CVE files sequentially (original method)."""
-    progress = ProgressTracker(len(cve_files), "Loading CVE files")
-    records = []
-    
-    for file_path in cve_files:
-        try:
-            cve_record = _load_single_cve_file(file_path)
-            if cve_record and _passes_date_filter(cve_record, start_dt, end_dt):
-                records.append(cve_record)
-        except Exception as e:
-            logger.debug(f"Skipping file {file_path}: {e}")
-        finally:
-            progress.update()
-    
-    progress.finish()
-    return records
-
-
-def _load_cves_parallel(
-    cve_files: List[str],
-    start_dt: Optional[datetime],
-    end_dt: Optional[datetime],
-    max_workers: Optional[int] = None
-) -> List[Dict[str, Any]]:
-    """
-    Load CVE files using parallel processing for improved performance.
-    
-    Args:
-        cve_files: List of CVE file paths
-        start_dt: Start date filter (datetime object)
-        end_dt: End date filter (datetime object)
-        max_workers: Number of worker processes
-        
-    Returns:
-        List of filtered CVE records
-    """
-    if max_workers is None:
-        max_workers = min(multiprocessing.cpu_count(), 8)
-    
-    logger.info(f"Loading {len(cve_files)} CVE files using {max_workers} workers")
-    
-    # Convert datetime to string for pickling across processes
-    start_str = start_dt.strftime(DATE_FORMAT) if start_dt else None
-    end_str = end_dt.strftime(DATE_FORMAT) if end_dt else None
-    
-    records = []
-    failed_count = 0
-    
-    # Process files in batches to reduce overhead
-    batch_size = max(100, len(cve_files) // (max_workers * 4))
-    batches = [cve_files[i:i + batch_size] for i in range(0, len(cve_files), batch_size)]
-    
-    logger.info(f"Processing in {len(batches)} batches of ~{batch_size} files each")
-    
-    with ProcessPoolExecutor(max_workers=max_workers) as executor:
-        futures = {
-            executor.submit(_load_cve_batch, batch, start_str, end_str): i 
-            for i, batch in enumerate(batches)
-        }
-        
-        for future in as_completed(futures):
-            try:
-                batch_records, batch_failed = future.result()
-                records.extend(batch_records)
-                failed_count += batch_failed
-            except Exception as e:
-                logger.error(f"Batch processing error: {e}")
-    
-    logger.info(f"Parallel loading complete: {len(records)} records loaded, {failed_count} files skipped")
-    return records
-
-
-def _load_cve_batch(
-    file_paths: List[str],
-    start_date_str: Optional[str],
-    end_date_str: Optional[str]
-) -> Tuple[List[Dict[str, Any]], int]:
-    """
-    Load a batch of CVE files (designed to run in a worker process).
-    
-    Args:
-        file_paths: List of CVE file paths to load
-        start_date_str: Start date filter string (YYYY-MM-DD)
-        end_date_str: End date filter string (YYYY-MM-DD)
-        
-    Returns:
-        Tuple of (list of valid CVE records, count of failed files)
-    """
-    # Import inside function to avoid pickling issues
-    import json
-    from datetime import datetime
-    
-    DATE_FMT = "%Y-%m-%d"
-    
-    # Parse dates in worker process
-    start_dt = datetime.strptime(start_date_str, DATE_FMT) if start_date_str else None
-    end_dt = datetime.strptime(end_date_str, DATE_FMT) if end_date_str else None
-    
-    records = []
-    failed = 0
-    
-    for file_path in file_paths:
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-            
-            # Basic validation
-            if not isinstance(data, dict):
-                failed += 1
-                continue
-                
-            if "cveMetadata" not in data or "containers" not in data:
-                failed += 1
-                continue
-            
-            # Skip rejected CVEs
-            if data.get("cveMetadata", {}).get("state") == "REJECTED":
-                continue
-            
-            # Date filtering
-            pub_date_str = data.get("cveMetadata", {}).get("datePublished")
-            if pub_date_str:
-                pub_date_clean = pub_date_str[:10]
-                try:
-                    pub_dt = datetime.strptime(pub_date_clean, DATE_FMT)
-                    
-                    if start_dt and pub_dt < start_dt:
-                        continue
-                    if end_dt and pub_dt > end_dt:
-                        continue
-                except ValueError:
-                    # If date parsing fails, include the record
-                    pass
-            elif start_dt or end_dt:
-                # No publication date but filter requested - skip
-                continue
-            
-            records.append(data)
-            
-        except Exception:
-            failed += 1
-    
-    return records, failed
-
-
-def _load_single_cve_file(file_path: str) -> Optional[Dict[str, Any]]:
-    """
-    Load and validate a single CVE file with comprehensive error handling.
-    
-    Args:
-        file_path: Path to CVE file
-        
-    Returns:
-        CVE record dictionary if valid, None otherwise
-        
-    Note:
-        This function gracefully handles various error conditions:
-        - File not found or permissions errors
-        - Invalid JSON syntax
-        - Missing required CVE fields (cveMetadata, containers)
-        - Rejected CVE state
-        - Unsupported schema versions (logs warning but still loads)
-    """
-    try:
-        data = load_json_file(Path(file_path))
-        
-        # Validate CVE record structure
-        if not validate_cve_record(data):
-            logger.debug(f"Invalid CVE structure in {file_path}")
-            return None
-        
-        # Filter out rejected CVEs
-        cve_state = data.get("cveMetadata", {}).get("state")
-        if cve_state == "REJECTED":
-            return None
-        
-        # Check schema version (informational, don't reject)
-        data_version = data.get("dataVersion", "unknown")
-        from config import SUPPORTED_SCHEMA_VERSIONS
-        if data_version not in SUPPORTED_SCHEMA_VERSIONS:
-            cve_id = data.get("cveMetadata", {}).get("cveId", "unknown")
-            logger.warning(f"CVE {cve_id} uses unsupported schema version: {data_version}")
-        
-        return data
-        
-    except FileNotFoundError:
-        logger.debug(f"CVE file not found: {file_path}")
-        return None
-    except PermissionError:
-        logger.warning(f"Permission denied reading CVE file: {file_path}")
-        return None
-    except ValueError as e:
-        # Invalid JSON
-        logger.debug(f"Invalid JSON in CVE file {file_path}: {e}")
-        return None
-    except Exception as e:
-        logger.debug(f"Unexpected error loading CVE file {file_path}: {type(e).__name__}: {e}")
-        return None
-
-
-def _passes_date_filter(
-    cve: Dict[str, Any], 
-    start_dt: Optional[datetime], 
-    end_dt: Optional[datetime]
-) -> bool:
-    """
-    Check if CVE record passes date filtering criteria.
-    
-    Args:
-        cve: CVE record dictionary
-        start_dt: Start date filter
-        end_dt: End date filter
-        
-    Returns:
-        True if CVE passes date filter, False otherwise
-    """
-    if not start_dt and not end_dt:
-        return True
-    
-    pub_date_str = cve.get("cveMetadata", {}).get("datePublished")
-    if not pub_date_str:
-        return False
-    
-    try:
-        # Handle ISO format dates
-        pub_date_clean = pub_date_str[:10]  # Take YYYY-MM-DD part
-        pub_dt = datetime.strptime(pub_date_clean, DATE_FORMAT)
-        
-        if start_dt and pub_dt < start_dt:
-            return False
-        
-        if end_dt and pub_dt > end_dt:
-            return False
-        
-        return True
-        
-    except ValueError as e:
-        logger.debug(f"Invalid date format in CVE {cve.get('cveId', 'unknown')}: {pub_date_str}")
-        return False
-
-def load_cna_list(cve_records: List[Dict[str, Any]]) -> List[Dict[str, str]]:
-    """
-    Extract unique CNA shortNames from CVE records.
-    
-    Args:
-        cve_records: List of CVE record dictionaries
-        
-    Returns:
-        List of CNA dictionaries with shortName field
-    """
-    if not cve_records:
-        logger.warning("No CVE records provided for CNA extraction")
-        return []
-    
-    logger.info(f"Extracting CNA information from {len(cve_records)} CVE records")
-    
-    cna_set = set()
-    for cve in cve_records:
-        short_name = extract_cna_short_name(cve)
-        if short_name:
-            cna_set.add(short_name)
-    
-    cna_list = [{"shortName": name} for name in sorted(cna_set)]
-    logger.info(f"Found {len(cna_list)} unique CNAs")
-    
-    return cna_list
-
-
-def get_date_range_for_period(months_back: int = 6) -> Tuple[str, str]:
-    """
-    Get date range for a specific period back from current date.
-    
-    Args:
-        months_back: Number of months to go back from current date
-        
-    Returns:
-        Tuple of (start_date, end_date) in YYYY-MM-DD format
-    """
-    from datetime import date, timedelta
-    from dateutil.relativedelta import relativedelta
-    
-    end_date = date.today()
-    start_date = end_date - relativedelta(months=months_back)
-    
-    return start_date.strftime(DATE_FORMAT), end_date.strftime(DATE_FORMAT)
-
-
-def validate_date_range(start_date: str, end_date: str) -> bool:
-    """
-    Validate that date range is properly formatted and logical.
-    
-    Args:
-        start_date: Start date in YYYY-MM-DD format
-        end_date: End date in YYYY-MM-DD format
-        
-    Returns:
-        True if date range is valid, False otherwise
-    """
-    try:
-        start_dt = datetime.strptime(start_date, DATE_FORMAT)
-        end_dt = datetime.strptime(end_date, DATE_FORMAT)
-        
-        if start_dt > end_dt:
-            logger.error(f"Start date {start_date} is after end date {end_date}")
-            return False
-        
-        return True
-        
-    except ValueError as e:
-        logger.error(f"Invalid date format: {e}")
-        return False
-
-# =============================================================================
-# Delta Processing Functions
-# =============================================================================
-
-def load_delta_cves(
-    cve_dir: Optional[str] = None,
-    since: Optional[str] = None
-) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]], Dict[str, Any]]:
-    """
-    Load only new and updated CVEs from delta files.
-    
-    This function uses the delta.json and deltaLog.json files to identify
-    CVEs that have changed since the last run, enabling incremental processing.
-    
-    Args:
-        cve_dir: Path to CVE data directory (defaults to config value)
-        since: ISO timestamp to filter changes after (e.g., "2025-10-28T00:00:00Z")
-               If None, only the latest delta.json is used.
-        
-    Returns:
-        Tuple of:
-        - List of new CVE records
-        - List of updated CVE records
-        - Metadata dict with fetchTime, numberOfChanges, errors
-        
-    Example:
-        >>> new_cves, updated_cves, meta = load_delta_cves()
-        >>> print(f"Found {len(new_cves)} new, {len(updated_cves)} updated")
-    """
-    if cve_dir is None:
-        cve_dir = str(CVE_DATA_DIR)
-    
-    cves_dir = Path(cve_dir) / "cves"
-    delta_file = cves_dir / "delta.json"
-    delta_log_file = cves_dir / "deltaLog.json"
-    
-    new_records = []
-    updated_records = []
-    metadata = {
-        "fetchTime": None,
-        "numberOfChanges": 0,
-        "errors": []
-    }
-    
-    # Collect delta entries to process
-    delta_entries = []
-    
-    if since:
-        # Load from deltaLog for historical changes
-        delta_entries = _get_delta_entries_since(delta_log_file, since)
-        logger.info(f"Found {len(delta_entries)} delta entries since {since}")
-    else:
-        # Just use latest delta.json
-        if delta_file.exists():
-            try:
-                delta_data = load_json_file(delta_file)
-                delta_entries = [delta_data]
-                logger.info(f"Loaded latest delta with {delta_data.get('numberOfChanges', 0)} changes")
-            except Exception as e:
-                logger.error(f"Error loading delta.json: {e}")
-                metadata["errors"].append(str(e))
-    
-    if not delta_entries:
-        logger.warning("No delta entries found to process")
-        return new_records, updated_records, metadata
-    
-    # Process each delta entry
-    all_new_cve_ids = set()
-    all_updated_cve_ids = set()
-    
-    for delta in delta_entries:
-        fetch_time = delta.get("fetchTime")
-        if metadata["fetchTime"] is None:
-            metadata["fetchTime"] = fetch_time
-        
-        # Collect CVE IDs
-        for cve_entry in delta.get("new", []):
-            all_new_cve_ids.add(cve_entry.get("cveId"))
-        
-        for cve_entry in delta.get("updated", []):
-            all_updated_cve_ids.add(cve_entry.get("cveId"))
-        
-        # Track errors
-        for error in delta.get("error", []):
-            metadata["errors"].append(error)
-    
-    # Remove any CVE from "new" if it also appears in "updated" (was updated after creation)
-    all_new_cve_ids -= all_updated_cve_ids
-    
-    logger.info(f"Processing {len(all_new_cve_ids)} new CVEs and {len(all_updated_cve_ids)} updated CVEs")
-    
-    # Load the actual CVE records
-    new_records = _load_cves_by_id(cves_dir, list(all_new_cve_ids))
-    updated_records = _load_cves_by_id(cves_dir, list(all_updated_cve_ids))
-    
-    metadata["numberOfChanges"] = len(new_records) + len(updated_records)
-    
-    return new_records, updated_records, metadata
-
-
-def _get_delta_entries_since(delta_log_file: Path, since: str) -> List[Dict[str, Any]]:
-    """
-    Get delta entries from deltaLog.json since a specific timestamp.
-    
-    Args:
-        delta_log_file: Path to deltaLog.json
-        since: ISO timestamp to filter from
-        
-    Returns:
-        List of delta entries with fetchTime >= since
-    """
-    if not delta_log_file.exists():
-        logger.warning(f"Delta log file not found: {delta_log_file}")
-        return []
-    
-    try:
-        since_dt = datetime.fromisoformat(since.replace('Z', '+00:00'))
-    except ValueError as e:
-        logger.error(f"Invalid 'since' timestamp format: {since}")
-        return []
-    
-    entries = []
-    try:
-        delta_log = load_json_file(delta_log_file)
-        
-        if not isinstance(delta_log, list):
-            logger.error("deltaLog.json is not a list")
-            return []
-        
-        for entry in delta_log:
-            fetch_time_str = entry.get("fetchTime")
-            if fetch_time_str:
-                try:
-                    fetch_dt = datetime.fromisoformat(fetch_time_str.replace('Z', '+00:00'))
-                    if fetch_dt >= since_dt:
-                        entries.append(entry)
-                except ValueError:
-                    continue
-        
-        return entries
-        
-    except Exception as e:
-        logger.error(f"Error reading deltaLog.json: {e}")
-        return []
-
-
-def _load_cves_by_id(cves_dir: Path, cve_ids: List[str]) -> List[Dict[str, Any]]:
-    """
-    Load CVE records by their CVE IDs.
-    
-    Args:
-        cves_dir: Path to cves directory
-        cve_ids: List of CVE IDs to load (e.g., ["CVE-2025-10150", "CVE-2025-10151"])
-        
-    Returns:
-        List of loaded CVE records
-    """
-    records = []
-    
-    for cve_id in cve_ids:
-        if not cve_id:
-            continue
-            
-        file_path = _cve_id_to_path(cves_dir, cve_id)
-        if file_path and file_path.exists():
-            record = _load_single_cve_file(str(file_path))
-            if record:
-                records.append(record)
-        else:
-            logger.debug(f"CVE file not found for {cve_id}")
-    
-    return records
-
-
-def _cve_id_to_path(cves_dir: Path, cve_id: str) -> Optional[Path]:
-    """
-    Convert a CVE ID to its file path.
-    
-    CVE IDs follow the pattern CVE-YYYY-NNNNN where:
-    - YYYY is the year
-    - NNNNN is a sequence number (variable length)
-    
-    Files are organized as: cves/YYYY/Nxxx/CVE-YYYY-NNNNN.json
-    
-    Args:
-        cves_dir: Path to cves directory
-        cve_id: CVE ID (e.g., "CVE-2025-10150")
-        
-    Returns:
-        Path to CVE file, or None if invalid ID
-    """
-    if not cve_id or not cve_id.startswith("CVE-"):
-        return None
-    
-    parts = cve_id.split("-")
-    if len(parts) != 3:
-        return None
-    
-    try:
-        year = parts[1]
-        seq_num = parts[2]
-        
-        # Determine the subdirectory (e.g., "10xxx" for 10150)
-        if len(seq_num) <= 4:
-            subdir = f"{seq_num[0]}xxx"
-        else:
-            # For longer sequence numbers (e.g., 10150 -> 10xxx)
-            subdir = f"{seq_num[:-3]}xxx"
-        
-        return cves_dir / year / subdir / f"{cve_id}.json"
-        
-    except (IndexError, ValueError) as e:
-        logger.debug(f"Invalid CVE ID format: {cve_id}")
-        return None
-
-
-def get_last_run_timestamp(state_file: Path) -> Optional[str]:
-    """
-    Get the timestamp of the last successful pipeline run.
-    
-    Args:
-        state_file: Path to state file storing last run info
-        
-    Returns:
-        ISO timestamp string of last run, or None if no previous run
-    """
-    if not state_file.exists():
-        return None
-    
-    try:
-        state = load_json_file(state_file)
-        return state.get("last_run_timestamp")
-    except Exception as e:
-        logger.warning(f"Error reading state file: {e}")
-        return None
-
-
-def save_run_timestamp(state_file: Path, timestamp: Optional[str] = None) -> None:
-    """
-    Save the current timestamp as the last run time.
-    
-    Args:
-        state_file: Path to state file
-        timestamp: ISO timestamp to save (defaults to current time)
-    """
-    import json
-    
-    if timestamp is None:
-        timestamp = datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.%fZ")
-    
-    state = {
-        "last_run_timestamp": timestamp,
-        "updated_at": datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%S.%fZ")
-    }
-    
-    try:
-        state_file.parent.mkdir(parents=True, exist_ok=True)
-        with open(state_file, 'w') as f:
-            json.dump(state, f, indent=2)
-        logger.info(f"Saved run timestamp: {timestamp}")
-    except Exception as e:
-        logger.error(f"Error saving state file: {e}")
-
-
-def main() -> None:
-    """
-    Main function for testing ingest functionality.
-    """
-    from utils import setup_logging
-    
-    # Setup logging for testing
-    setup_logging("INFO")
-    
-    # Test basic loading
-    logger.info("Testing CVE record loading...")
-    records = load_cve_records()
-    logger.info(f"Loaded {len(records)} CVE records")
-    
-    # Test CNA extraction
-    cna_list = load_cna_list(records)
-    logger.info(f"Found {len(cna_list)} unique CNAs")
-    
-    # Test date filtering
-    start_date, end_date = get_date_range_for_period(6)
-    logger.info(f"Testing date filtering for period: {start_date} to {end_date}")
-    
-    filtered_records = load_cve_records(start_date=start_date, end_date=end_date)
-    logger.info(f"Loaded {len(filtered_records)} CVE records with date filtering")
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/cvedb/cna/pipeline.py b/src/cvedb/cna/pipeline.py
deleted file mode 100644
index e16a2a7cb64..00000000000
--- a/src/cvedb/cna/pipeline.py
+++ /dev/null
@@ -1,875 +0,0 @@
-"""
-CNA Scorecard Pipeline - Main Orchestration Module.
-
-This module provides the main entry point for the CNA Scorecard data pipeline,
-orchestrating the entire process from data ingestion to output generation.
-"""
-import logging
-from datetime import datetime, timedelta
-from typing import Dict, Any, List, Tuple, Optional
-from pathlib import Path
-
-from .config import get_config, ANALYSIS_PERIOD_MONTHS
-from .utils import setup_logging, ensure_directory_exists, write_json_file, ProgressTracker
-from .ingest import load_cve_records, load_cna_list, get_date_range_for_period, validate_date_range, load_delta_cves
-from .scoring import score_multiple_cves
-from .completeness import compute_field_utilization, compute_individual_cna_field_utilization
-from .aggregation import aggregate_cna_scores
-from .trends import calculate_daily_trends, calculate_top_improvers
-from .chunking import write_chunked_cna_data, generate_search_index
-
-from .sync_cna_list import sync_cna_list
-from .badge_generator import generate_cna_badges, generate_badge_documentation
-
-# Initialize logging
-logger = logging.getLogger('cnascorecard.pipeline')
-
-
-class PipelineError(Exception):
-    """Custom exception for pipeline errors."""
-    pass
-
-
-class CNAScoreCardPipeline:
-    """
-    Main pipeline class for CNA Scorecard data processing.
-    
-    This class orchestrates the entire pipeline from data loading to output generation,
-    providing a clean interface for running the complete analysis.
-    """
-    
-    def __init__(self, config: Optional[Dict[str, Any]] = None):
-        """
-        Initialize the pipeline with configuration.
-        
-        Args:
-            config: Optional configuration dictionary. If None, uses default config.
-        """
-        self.config = config or get_config()
-        self.logger = logging.getLogger('cnascorecard.pipeline')
-        
-        # Initialize pipeline state
-        self.cve_records: List[Dict[str, Any]] = []
-        self.filtered_cve_records: List[Dict[str, Any]] = []
-        self.scored_cves: List[Dict[str, Any]] = []
-        self.cna_outputs: Dict[str, Any] = {}
-        self.analysis_periods: Dict[str, Tuple[str, str]] = {}
-        
-        self.logger.info("CNA Scorecard Pipeline initialized")
-    
-    def run(
-        self, 
-        start_date: Optional[str] = None, 
-        end_date: Optional[str] = None,
-        output_dir: Optional[str] = None,
-        use_delta: bool = False,
-        use_cache: bool = True
-    ) -> Dict[str, Any]:
-        """
-        Run the complete CNA Scorecard pipeline.
-        
-        Args:
-            start_date: Start date for analysis in YYYY-MM-DD format
-            end_date: End date for analysis in YYYY-MM-DD format
-            output_dir: Output directory for generated files
-            use_delta: If True, only process changed CVEs from delta files
-            use_cache: If True, use score caching for faster processing
-            
-        Returns:
-            Dictionary containing pipeline execution summary
-            
-        Raises:
-            PipelineError: If pipeline execution fails
-        """
-        try:
-            self.logger.info("Starting CNA Scorecard Pipeline execution")
-            self.logger.info(f"Options: delta={use_delta}, cache={use_cache}")
-            start_time = datetime.now()
-            
-            # Step 1: Setup analysis periods
-            self._setup_analysis_periods(start_date, end_date)
-            
-            # Step 2: Sync CNA metadata
-            self._sync_cna_metadata()
-            
-            # Step 3: Load CVE data (full or delta mode)
-            if use_delta:
-                self._load_cve_data_delta()
-            else:
-                self._load_cve_data()
-            
-            # Step 4: Score CVE records (with optional caching)
-            self._score_cve_records(use_cache=use_cache)
-            
-            # Step 5: Aggregate CNA scores
-            self._aggregate_cna_scores()
-            
-            # Step 6: Generate completeness analysis
-            self._generate_completeness_analysis()
-            
-            # Step 7: Generate performance trends analysis
-            self._generate_trends_analysis()
-            
-            # Step 8: Generate output files
-            output_summary = self._generate_output_files(output_dir)
-            
-            # Calculate execution time
-            execution_time = datetime.now() - start_time
-            
-            # Create execution summary
-            summary = {
-                'execution_time': str(execution_time),
-                'analysis_period': self.analysis_periods['current'],
-                'total_cves_processed': len(self.cve_records),
-                'filtered_cves_count': len(self.filtered_cve_records),
-                'scored_cves_count': len(self.scored_cves),
-                'cnas_processed': len(self.cna_outputs),
-                'output_files': output_summary,
-                'mode': 'delta' if use_delta else 'full',
-                'cache_enabled': use_cache,
-                'status': 'success'
-            }
-            
-            self.logger.info(f"Pipeline execution completed successfully in {execution_time}")
-            return summary
-            
-        except Exception as e:
-            self.logger.error(f"Pipeline execution failed: {e}")
-            raise PipelineError(f"Pipeline execution failed: {e}") from e
-    
-    def _setup_analysis_periods(
-        self, 
-        start_date: Optional[str], 
-        end_date: Optional[str]
-    ) -> None:
-        """
-        Setup analysis periods for current and previous periods.
-        
-        Args:
-            start_date: Optional start date override
-            end_date: Optional end date override
-        """
-        self.logger.info("Setting up analysis periods")
-        
-        if start_date and end_date:
-            # Use provided dates
-            if not validate_date_range(start_date, end_date):
-                raise PipelineError(f"Invalid date range: {start_date} to {end_date}")
-            
-            current_start, current_end = start_date, end_date
-        else:
-            # Use default period (last 6 months)
-            current_start, current_end = get_date_range_for_period(ANALYSIS_PERIOD_MONTHS)
-        
-        # Calculate previous period for trend analysis
-        start_dt = datetime.strptime(current_start, "%Y-%m-%d")
-        end_dt = datetime.strptime(current_end, "%Y-%m-%d")
-        period_length = end_dt - start_dt
-        
-        previous_end = start_dt - timedelta(days=1)
-        previous_start = previous_end - period_length
-        
-        self.analysis_periods = {
-            'current': (current_start, current_end),
-            'previous': (
-                previous_start.strftime("%Y-%m-%d"),
-                previous_end.strftime("%Y-%m-%d")
-            )
-        }
-        
-        self.logger.info(f"Current analysis period: {current_start} to {current_end}")
-        self.logger.info(f"Previous analysis period: {previous_start.strftime('%Y-%m-%d')} to {previous_end.strftime('%Y-%m-%d')}")
-    
-    def _sync_cna_metadata(self) -> None:
-        """
-        Sync CNA metadata from official CVE Project repository.
-        
-        This ensures we have the latest official CNA list for proper
-        name mapping and metadata enrichment.
-        """
-        self.logger.info("Syncing CNA metadata from official CVE Project repository")
-        
-        try:
-            sync_success = sync_cna_list()
-            if sync_success:
-                self.logger.info("Successfully synced CNA metadata")
-            else:
-                self.logger.warning("CNA metadata sync failed, continuing with existing data")
-        except Exception as e:
-            self.logger.warning(f"CNA metadata sync failed: {e}, continuing with existing data")
-    
-    def _load_cve_data(self) -> None:
-        """Load CVE data for analysis (full mode)."""
-        self.logger.info("Loading CVE data (full mode)")
-        
-        # Load all CVE records (needed for trend analysis)
-        self.cve_records = load_cve_records()
-        self.logger.info(f"Loaded {len(self.cve_records)} total CVE records")
-        
-        # Filter CVE records for current analysis period
-        current_start, current_end = self.analysis_periods['current']
-        self.filtered_cve_records = load_cve_records(
-            start_date=current_start,
-            end_date=current_end
-        )
-        self.logger.info(f"Filtered to {len(self.filtered_cve_records)} CVE records for current period")
-        
-        if not self.filtered_cve_records:
-            raise PipelineError("No CVE records found for the specified analysis period")
-    
-    def _load_cve_data_delta(self) -> None:
-        """Load only changed CVE data using delta files (incremental mode)."""
-        self.logger.info("Loading CVE data (delta mode)")
-        
-        # Load delta CVEs (new and updated)
-        new_cves, updated_cves, delta_meta = load_delta_cves()
-        
-        delta_cves = new_cves + updated_cves
-        self.logger.info(f"Delta: {len(new_cves)} new, {len(updated_cves)} updated CVEs")
-        
-        if delta_meta.get("errors"):
-            for error in delta_meta["errors"]:
-                self.logger.warning(f"Delta error: {error}")
-        
-        if not delta_cves:
-            self.logger.warning("No delta CVEs found, falling back to full load")
-            return self._load_cve_data()
-        
-        # For delta mode, we still need full CVE records for trends
-        # but only score the delta CVEs
-        self.cve_records = load_cve_records()
-        self.logger.info(f"Loaded {len(self.cve_records)} total CVE records for trends")
-        
-        # Filter delta CVEs to current analysis period
-        current_start, current_end = self.analysis_periods['current']
-        start_dt = datetime.strptime(current_start, "%Y-%m-%d")
-        end_dt = datetime.strptime(current_end, "%Y-%m-%d")
-        
-        self.filtered_cve_records = []
-        for cve in delta_cves:
-            date_str = cve.get("cveMetadata", {}).get("datePublished", "")
-            if date_str:
-                try:
-                    # Handle various date formats
-                    if "T" in date_str:
-                        cve_date = datetime.fromisoformat(date_str.replace("Z", "+00:00"))
-                    else:
-                        cve_date = datetime.strptime(date_str[:10], "%Y-%m-%d")
-                    
-                    if start_dt <= cve_date.replace(tzinfo=None) <= end_dt:
-                        self.filtered_cve_records.append(cve)
-                except ValueError:
-                    # Include if date can't be parsed
-                    self.filtered_cve_records.append(cve)
-            else:
-                # Include if no date
-                self.filtered_cve_records.append(cve)
-        
-        self.logger.info(f"Filtered to {len(self.filtered_cve_records)} delta CVEs for current period")
-        
-        if not self.filtered_cve_records:
-            self.logger.warning("No delta CVEs in analysis period, may need full rebuild")
-    
-    def _score_cve_records(self, use_cache: bool = True) -> None:
-        """Score CVE records using the CNA Scorecard methodology."""
-        self.logger.info(f"Scoring CVE records (cache={'enabled' if use_cache else 'disabled'})")
-        
-        self.scored_cves = score_multiple_cves(self.filtered_cve_records, use_cache=use_cache)
-        
-        if not self.scored_cves:
-            raise PipelineError("No CVE records could be scored")
-        
-        # Log scoring statistics
-        total_score = sum(cve['totalScore'] for cve in self.scored_cves)
-        avg_score = total_score / len(self.scored_cves) if self.scored_cves else 0
-        
-        self.logger.info(f"Scored {len(self.scored_cves)} CVE records")
-        self.logger.info(f"Average CVE score: {avg_score:.2f}/100")
-    
-    def _aggregate_cna_scores(self) -> None:
-        """Aggregate scores by CNA and calculate trends."""
-        self.logger.info("Aggregating CNA scores")
-        
-        # Create period tuples for aggregation
-        current_period = tuple(
-            datetime.strptime(date, "%Y-%m-%d") 
-            for date in self.analysis_periods['current']
-        )
-        previous_period = tuple(
-            datetime.strptime(date, "%Y-%m-%d") 
-            for date in self.analysis_periods['previous']
-        )
-        
-        periods = [current_period, previous_period]
-        
-        self.cna_outputs = aggregate_cna_scores(self.scored_cves, periods)
-        
-        self.logger.info(f"Aggregated scores for {len(self.cna_outputs)} CNAs")
-    
-    def _generate_completeness_analysis(self) -> None:
-        """Generate field completeness analysis."""
-        self.logger.info("Generating completeness analysis")
-        
-        # Generate overall field utilization
-        field_list = self.config['fields']['field_list']
-        self.field_utilization = compute_field_utilization(
-            self.filtered_cve_records, 
-            field_list
-        )
-        
-        # Generate individual CNA field utilization
-        self.individual_cna_utilization = compute_individual_cna_field_utilization(
-            self.filtered_cve_records,
-            field_list
-        )
-        
-        self.logger.info(f"Generated completeness analysis for {len(field_list)} fields")
-        self.logger.info(f"Generated individual analysis for {len(self.individual_cna_utilization)} CNAs")
-    
-    def _generate_trends_analysis(self) -> None:
-        """Generate performance trends analysis for the dashboard."""
-        self.logger.info("Generating performance trends analysis...")
-        
-        # Calculate daily trends with 7-day rolling averages
-        # Note: Use all CVE records, not filtered, to get full 180-day history
-        self.trends_data = calculate_daily_trends(
-            self.cve_records,
-            Path(self.config['directories']['web_data']),
-            analysis_days=180  # 6 months
-        )
-        
-        # Calculate top improving CNAs
-        # Note: Use all CVE records to identify improvements over time
-        self.top_improvers = calculate_top_improvers(
-            self.cve_records,
-            Path(self.config['directories']['web_data']),
-            top_n=10
-        )
-        
-        self.logger.info(f"Generated trends analysis with {len(self.trends_data['rolling_trends'])} data points")
-        self.logger.info(f"Identified {len(self.top_improvers)} improving CNAs")
-    
-    def _generate_output_files(self, output_dir: Optional[str] = None) -> Dict[str, str]:
-        """
-        Generate all output files.
-        
-        Args:
-            output_dir: Optional output directory override
-            
-        Returns:
-            Dictionary mapping output type to file path
-        """
-        self.logger.info("Generating output files")
-        
-        if output_dir:
-            web_data_dir = Path(output_dir)
-        else:
-            web_data_dir = Path(self.config['directories']['web_data'])
-        
-        ensure_directory_exists(web_data_dir)
-        
-        output_files = {}
-        
-        # Generate individual CNA JSON files
-        output_files.update(self._generate_individual_cna_files(web_data_dir))
-        
-        # Generate summary files
-        output_files.update(self._generate_summary_files(web_data_dir))
-        
-        # Generate completeness files
-        output_files.update(self._generate_completeness_files(web_data_dir))
-        
-        # Generate CNA badges
-        output_files.update(self._generate_cna_badges(web_data_dir))
-        
-        self.logger.info(f"Generated {len(output_files)} output files")
-        return output_files
-    
-    def _generate_individual_cna_files(self, output_dir: Path) -> Dict[str, str]:
-        """Generate individual CNA JSON files matching original format exactly."""
-        self.logger.info("Generating individual CNA files")
-        
-        # Load official CNA metadata for proper formatting
-        import os, json
-        cna_list_path = output_dir / 'cna_list.json'
-        official_cna_metadata = {}
-        if os.path.exists(cna_list_path):
-            with open(cna_list_path, 'r') as f:
-                cna_list_data = json.load(f)
-                official_cna_metadata = {meta.get('shortName'): meta for meta in cna_list_data if meta.get('shortName')}
-        
-        cna_dir = output_dir / "cna"
-        ensure_directory_exists(cna_dir)
-        
-        output_files = {}
-        progress = ProgressTracker(len(self.cna_outputs), "Generating CNA files")
-        
-        # Calculate active CNA count for ranking
-        active_cna_count = sum(1 for cna_data in self.cna_outputs.values() 
-                              if cna_data['cna_scoring'][0].get('recent_cves_count', 0) > 0)
-        
-        # Sort CNAs by score for ranking
-        sorted_cnas = []
-        for cna_name, cna_data in self.cna_outputs.items():
-            if cna_data['cna_info'] and cna_data['cna_scoring']:
-                cna_scoring = cna_data['cna_scoring'][0]
-                recent_cves = cna_scoring.get('recent_cves_count', 0)
-                if recent_cves > 0:  # Only include active CNAs
-                    sorted_cnas.append((cna_name, cna_data, cna_scoring.get('overall_average_score', 0.0)))
-        
-        # Sort by score descending for ranking
-        sorted_cnas.sort(key=lambda x: x[2], reverse=True)
-        
-        # Create rank mapping and store in cna_outputs
-        rank_mapping = {}
-        current_rank = 1
-        for i, (cna_name, _, score) in enumerate(sorted_cnas):
-            if i > 0 and sorted_cnas[i-1][2] != score:
-                current_rank = i + 1
-            rank_mapping[cna_name] = current_rank
-        
-        # Store ranks in cna_outputs for badge generation
-        for cna_name in self.cna_outputs.keys():
-            self.cna_outputs[cna_name]['rank'] = rank_mapping.get(cna_name, 999)
-        
-        for cna_name, cna_data in self.cna_outputs.items():
-            try:
-                # Create safe filename
-                safe_filename = ''.join(
-                    c for c in cna_name 
-                    if c.isalnum() or c in ('-', '_', '.')
-                ).rstrip()
-                
-                if not safe_filename:
-                    safe_filename = "unknown_cna"
-                
-                filename = f"{safe_filename}.json"
-                filepath = cna_dir / filename
-                
-                # Get official metadata
-                official_meta = official_cna_metadata.get(cna_name, {})
-                
-                # Get CNA info and scoring data
-                cna_info = cna_data['cna_info'][0] if cna_data['cna_info'] else {}
-                cna_scoring = cna_data['cna_scoring'][0] if cna_data['cna_scoring'] else {}
-                
-                # Calculate rank and percentile
-                cna_rank = rank_mapping.get(cna_name, 0)
-                percentile = ((active_cna_count - cna_rank + 1) / active_cna_count) * 100.0 if cna_rank > 0 else 0.0
-                
-                # Get recent CVEs with proper scoring details from cve_scoring data
-                recent_cves = []
-                if 'cve_scoring' in cna_data and cna_data['cve_scoring']:
-                    for cve_data in cna_data['cve_scoring']:
-                        # Create properly formatted CVE entry matching original structure
-                        recent_cve = {
-                            "cveId": cve_data.get('cveId', ''),
-                            "assigningCna": cve_data.get('assigningCna', cna_name),
-                            "datePublished": cve_data.get('datePublished', ''),
-                            "totalCveScore": cve_data.get('totalCveScore', 0),
-                            "scoreBreakdown": {
-                                "foundationalCompleteness": cve_data.get('scoreBreakdown', {}).get('foundationalCompleteness', 0),
-                                "rootCauseAnalysis": cve_data.get('scoreBreakdown', {}).get('rootCauseAnalysis', 0),
-                                "severityAndImpactContext": cve_data.get('scoreBreakdown', {}).get('severityAndImpactContext', 0),
-                                "softwareIdentification": cve_data.get('scoreBreakdown', {}).get('softwareIdentification', 0),
-                                "patchinfo": cve_data.get('scoreBreakdown', {}).get('patchinfo', 0)
-                            }
-                        }
-                        recent_cves.append(recent_cve)
-                
-                # Format individual CNA file in original structure
-                individual_cna_data = {
-                    "cna_info": {
-                        "cna": cna_name,
-                        "total_cves": cna_info.get('total_cves', 0),
-                        "total_cves_scored": cna_scoring.get('total_cves_scored', 0),
-                        "organizationName": official_meta.get('organizationName', cna_name),
-                        "scope": official_meta.get('scope', ''),
-                        "advisories": official_meta.get('advisories', []),
-                        "email": official_meta.get('email', []),
-                        "officialCnaID": official_meta.get('cnaID', ''),
-                        "cnaTypes": official_meta.get('type', ['Unknown']),
-                        "country": official_meta.get('country', ''),
-                        "disclosurePolicy": official_meta.get('disclosurePolicy', []),
-                        "rootCnaInfo": {}
-                    },
-                    "trend_direction": cna_scoring.get('trend_direction', 'steady'),
-                    "trend_description": cna_scoring.get('trend_description', 'No trend data available'),
-                    "rank": cna_rank,
-                    "active_cna_count": active_cna_count,
-                    "percentile": round(percentile, 1),
-                    "cna_scoring": [cna_scoring],
-                    "recent_cves": recent_cves
-                }
-                
-                # Write CNA data to file
-                write_json_file(individual_cna_data, filepath)
-                output_files[f"cna_{safe_filename}"] = str(filepath)
-                
-            except Exception as e:
-                self.logger.error(f"Failed to generate file for CNA {cna_name}: {e}")
-            finally:
-                progress.update()
-        return output_files
-    
-    def _generate_summary_files(self, output_dir: Path) -> Dict[str, str]:
-        """
-        Generate summary files for web interface matching original format exactly.
-        
-        Args:
-            output_dir: Output directory path
-            
-        Returns:
-            Dictionary mapping file types to file paths
-        """
-        output_files = {}
-        
-        # Load official CNA metadata for proper formatting
-        import os, json
-        cna_list_path = output_dir / 'cna_list.json'
-        official_cna_metadata = {}
-        if os.path.exists(cna_list_path):
-            with open(cna_list_path, 'r') as f:
-                cna_list_data = json.load(f)
-                official_cna_metadata = {meta.get('shortName'): meta for meta in cna_list_data if meta.get('shortName')}
-        
-        # Generate CNA combined rankings file in original format
-        web_formatted_cnas = []
-        active_cna_count = sum(1 for cna_data in self.cna_outputs.values() 
-                              if cna_data['cna_scoring'][0].get('recent_cves_count', 0) > 0)
-        
-        # Sort CNAs by score for ranking
-        sorted_cnas = []
-        for cna_name, cna_data in self.cna_outputs.items():
-            if cna_data['cna_info'] and cna_data['cna_scoring']:
-                cna_info = cna_data['cna_info'][0]
-                cna_scoring = cna_data['cna_scoring'][0]
-                recent_cves = cna_scoring.get('recent_cves_count', 0)
-                if recent_cves > 0:  # Only include active CNAs
-                    sorted_cnas.append((cna_name, cna_data, cna_scoring.get('overall_average_score', 0.0)))
-        
-        # Sort by score descending
-        sorted_cnas.sort(key=lambda x: x[2], reverse=True)
-        
-        # Calculate ranks with proper tie handling
-        current_rank = 1
-        for i, (cna_name, cna_data, score) in enumerate(sorted_cnas):
-            # Handle tied rankings
-            if i > 0 and sorted_cnas[i-1][2] != score:
-                current_rank = i + 1
-            
-            cna_info = cna_data['cna_info'][0]
-            cna_scoring = cna_data['cna_scoring'][0]
-            
-            # Get official metadata
-            official_meta = official_cna_metadata.get(cna_name, {})
-            
-            # Determine CNA type
-            types = official_meta.get('type', [])
-            if types and len(types) > 0:
-                valid_types = [t for t in types if t and t.strip() and t.strip().upper() != 'N/A']
-                if valid_types:
-                    primary_type, types_array = valid_types[0], valid_types
-                else:
-                    primary_type, types_array = 'Unknown', ['Unknown']
-            else:
-                primary_type, types_array = 'Unknown', ['Unknown']
-            
-            # Calculate percentile
-            percentile = ((active_cna_count - current_rank + 1) / active_cna_count) * 100.0
-            
-            web_cna = {
-                "shortName": cna_name,
-                "organizationName": official_meta.get('organizationName', cna_name),
-                "cnaType": primary_type,
-                "cnaTypes": types_array,
-                "rank": current_rank,
-                "active_cna_count": active_cna_count,
-                "percentile": round(percentile, 1),
-                "total_cves": cna_info.get('total_cves', 0),
-                "recent_cves": cna_scoring.get('recent_cves_count', 0),
-                "is_active": True,
-                "scores": {
-                    "overall_average_score": cna_scoring.get('overall_average_score', 0),
-                    "foundational_completeness": cna_scoring.get('percent_foundational_completeness', 0),
-                    "root_cause_analysis": cna_scoring.get('percent_root_cause_analysis', 0),
-                    "software_identification": cna_scoring.get('percent_software_identification', 0),
-                    "severity_and_impact": cna_scoring.get('percent_severity_and_impact', 0),
-                    "patchinfo": cna_scoring.get('percent_patchinfo', 0)
-                },
-                "trend": {
-                    "direction": cna_scoring.get('trend_direction', 'steady'),
-                    "description": cna_scoring.get('trend_description', 'No trend data available'),
-                    "monthly_data": cna_scoring.get('monthly_trends', [])
-                },
-                "scope": official_meta.get('scope', ''),
-                "advisories": official_meta.get('advisories', []),
-                "officialCnaID": official_meta.get('cnaID', ''),
-                "country": official_meta.get('country', ''),
-                "disclosurePolicy": official_meta.get('disclosurePolicy', [])
-            }
-            
-            web_formatted_cnas.append(web_cna)
-        
-        cna_combined_path = output_dir / 'cna_combined.json'
-        write_json_file(web_formatted_cnas, cna_combined_path)
-        output_files['cna_combined'] = str(cna_combined_path)
-        
-        # Generate chunked data for lazy loading
-        # Sort by rank for consistent chunk ordering
-        sorted_for_chunks = sorted(web_formatted_cnas, key=lambda x: x.get('rank', 999))
-        chunk_manifest = write_chunked_cna_data(sorted_for_chunks, output_dir, chunk_size=50)
-        output_files['chunk_manifest'] = str(output_dir / 'chunks' / 'manifest.json')
-        self.logger.info(f"Generated {chunk_manifest['totalChunks']} CNA chunks for lazy loading")
-        
-        # Generate search index for client-side filtering
-        search_index = generate_search_index(sorted_for_chunks, output_dir)
-        output_files['search_index'] = str(output_dir / 'search_index.json')
-        self.logger.info(f"Generated search index with {search_index['totalCNAs']} CNAs")
-        
-        # Generate cna_summary.json for completeness page
-        cna_summary_list = []
-        for cna_name, cna_data in self.cna_outputs.items():
-            if cna_data['cna_info'] and cna_data['cna_scoring']:
-                cna_info = cna_data['cna_info'][0]
-                cna_scoring = cna_data['cna_scoring'][0]
-                official_meta = official_cna_metadata.get(cna_name, {})
-                
-                summary_entry = {
-                    "cnaId": official_meta.get('cnaID', ''),
-                    "shortName": cna_name,
-                    "overallScore": cna_scoring.get('overall_average_score', 0),
-                    "grade": self._calculate_grade(cna_scoring.get('overall_average_score', 0)),
-                    "previousPeriodCveCount": 0,  # Placeholder for trend data
-                    "cveCount": cna_scoring.get('recent_cves_count', 0),
-                    "type": official_meta.get('type', ['Unknown'])[0] if official_meta.get('type') else 'Unknown',
-                    "trend": cna_scoring.get('trend_direction', 'steady')
-                }
-                cna_summary_list.append(summary_entry)
-        
-        # Sort by overall score descending
-        cna_summary_list.sort(key=lambda x: x['overallScore'], reverse=True)
-        
-        cna_summary_path = output_dir / 'cna_summary.json'
-        write_json_file(cna_summary_list, cna_summary_path)
-        output_files['cna_summary'] = str(cna_summary_path)
-        
-        # Generate completeness summary
-        completeness_summary = {
-            'analysis_period': f"{self.analysis_periods['current'][0]} to {self.analysis_periods['current'][1]}",
-            'total_cves_analyzed': len(self.filtered_cve_records),
-            'total_fields_analyzed': len(self.field_utilization) if hasattr(self, 'field_utilization') else 0
-        }
-        
-        summary_path = output_dir / 'completeness_summary.json'
-        write_json_file(completeness_summary, summary_path)
-        output_files['completeness_summary'] = str(summary_path)
-        
-        return output_files
-    
-    def _generate_completeness_files(self, output_dir: Path) -> Dict[str, str]:
-        """Generate completeness analysis files."""
-        self.logger.info("Generating completeness files")
-        
-        output_files = {}
-        
-        # Generate enhanced field utilization data
-        canonical_fields = self.config['fields']['canonical_fields']
-        enhanced_field_data = []
-        
-        for field_data in self.field_utilization:
-            field_name = field_data['field']
-            field_metadata = next(
-                (f for f in canonical_fields if f['field'] == field_name), 
-                {}
-            )
-            
-            enhanced_entry = {
-                'field': field_name,
-                'percent': field_data['cna_percent'],
-                'unique_cnas': field_data['unique_cnas'],
-                'importance': field_metadata.get('importance', 'Medium'),
-                'description': field_metadata.get('description', ''),
-                'cna_scorecard_category': field_metadata.get('cna_scorecard_category')
-            }
-            enhanced_field_data.append(enhanced_entry)
-        
-        # Write field utilization file
-        field_util_path = output_dir / "field_utilization.json"
-        write_json_file(enhanced_field_data, field_util_path)
-        output_files['field_utilization'] = str(field_util_path)
-        
-        # Generate individual CNA completeness files
-        completeness_dir = output_dir / "completeness"
-        ensure_directory_exists(completeness_dir)
-        
-        for cna_name, utilization_data in self.individual_cna_utilization.items():
-            safe_filename = "".join(
-                c for c in cna_name 
-                if c.isalnum() or c in ('-', '_', '.')
-            ).rstrip()
-            
-            if not safe_filename:
-                safe_filename = "unknown_cna"
-            
-            filename = f"{safe_filename}_completeness.json"
-            filepath = completeness_dir / filename
-            
-            write_json_file(utilization_data, filepath)
-            output_files[f"completeness_{safe_filename}"] = str(filepath)
-        
-        return output_files
-    
-    def _generate_cna_badges(self, output_dir: Path) -> Dict[str, str]:
-        """
-        Generate SVG badges for all CNAs.
-        
-        Args:
-            output_dir: Output directory path (web/data)
-            
-        Returns:
-            Dictionary mapping badge identifiers to file paths
-        """
-        self.logger.info("Generating CNA badges")
-        
-        # Generate badges for all CNAs
-        badge_files = generate_cna_badges(self.cna_outputs, output_dir)
-        
-        # Generate badge documentation
-        base_url = self.config.get('website', {}).get('base_url', 'https://cvedb.github.io')
-        generate_badge_documentation(output_dir, base_url)
-        
-        self.logger.info(f"Generated {len(badge_files)} badge files")
-        return badge_files
-    
-    def _calculate_grade(self, score: float) -> str:
-        """
-        Calculate letter grade from numerical score.
-        
-        Args:
-            score: Numerical score (0-100)
-            
-        Returns:
-            Letter grade (A+, A, B+, etc.)
-        """
-        if score >= 95:
-            return "A+"
-        elif score >= 90:
-            return "A"
-        elif score >= 85:
-            return "B+"
-        elif score >= 80:
-            return "B"
-        elif score >= 75:
-            return "C+"
-        elif score >= 70:
-            return "C"
-        elif score >= 65:
-            return "D+"
-        elif score >= 60:
-            return "D"
-        else:
-            return "F"
-
-
-def main() -> None:
-    """
-    Main entry point for the CNA Scorecard Pipeline.
-    
-    This function sets up logging and runs the complete pipeline.
-    """
-    import argparse
-    
-    # Setup command line arguments
-    parser = argparse.ArgumentParser(
-        description="CNA Scorecard Data Pipeline",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  python pipeline.py                           # Run with default 6-month period
-  python pipeline.py --start 2024-01-01 --end 2024-12-31  # Custom date range
-  python pipeline.py --output /custom/output   # Custom output directory
-  python pipeline.py --log-level DEBUG         # Enable debug logging
-  python pipeline.py --delta                   # Incremental mode using delta files
-  python pipeline.py --no-cache                # Disable score caching
-        """
-    )
-    
-    parser.add_argument(
-        '--start-date', 
-        help='Start date for analysis (YYYY-MM-DD format)'
-    )
-    parser.add_argument(
-        '--end-date', 
-        help='End date for analysis (YYYY-MM-DD format)'
-    )
-    parser.add_argument(
-        '--output-dir', 
-        help='Output directory for generated files'
-    )
-    parser.add_argument(
-        '--log-level', 
-        choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
-        default='INFO',
-        help='Logging level (default: INFO)'
-    )
-    parser.add_argument(
-        '--config-file',
-        help='Path to custom configuration file'
-    )
-    parser.add_argument(
-        '--delta',
-        action='store_true',
-        help='Use delta mode for incremental processing (only process changed CVEs)'
-    )
-    parser.add_argument(
-        '--no-cache',
-        action='store_true',
-        help='Disable score caching (useful for debugging)'
-    )
-    
-    args = parser.parse_args()
-    
-    # Setup logging
-    logger = setup_logging(args.log_level)
-    
-    try:
-        # Load configuration
-        config = None
-        if args.config_file:
-            from utils import load_json_file
-            config = load_json_file(Path(args.config_file))
-        
-        # Initialize and run pipeline
-        pipeline = CNAScoreCardPipeline(config)
-        
-        summary = pipeline.run(
-            start_date=args.start_date,
-            end_date=args.end_date,
-            output_dir=args.output_dir,
-            use_delta=args.delta,
-            use_cache=not args.no_cache
-        )
-        
-        # Print execution summary
-        logger.info("Pipeline Execution Summary:")
-        logger.info(f"  Status: {summary['status']}")
-        logger.info(f"  Mode: {summary.get('mode', 'full')}")
-        logger.info(f"  Cache: {'enabled' if summary.get('cache_enabled', True) else 'disabled'}")
-        logger.info(f"  Execution Time: {summary['execution_time']}")
-        logger.info(f"  Analysis Period: {summary['analysis_period'][0]} to {summary['analysis_period'][1]}")
-        logger.info(f"  CVEs Processed: {summary['total_cves_processed']}")
-        logger.info(f"  CVEs in Analysis Period: {summary['filtered_cves_count']}")
-        logger.info(f"  CVEs Scored: {summary['scored_cves_count']}")
-        logger.info(f"  CNAs Processed: {summary['cnas_processed']}")
-        logger.info(f"  Output Files Generated: {len(summary['output_files'])}")
-        
-        logger.info("CNA Scorecard Pipeline completed successfully!")
-        
-    except Exception as e:
-        logger.error(f"Pipeline failed: {e}")
-        raise
-
-
-if __name__ == "__main__":
-    main()
diff --git a/src/cvedb/cna/pytest.ini b/src/cvedb/cna/pytest.ini
deleted file mode 100644
index 432e52487a4..00000000000
--- a/src/cvedb/cna/pytest.ini
+++ /dev/null
@@ -1,21 +0,0 @@
-[tool:pytest]
-testpaths = tests
-python_files = test_*.py
-python_classes = Test*
-python_functions = test_*
-addopts = 
-    -v
-    --tb=short
-    --strict-markers
-    --disable-warnings
-    --cov=.
-    --cov-report=term-missing
-    --cov-report=html:htmlcov
-    --cov-exclude=tests/*
-markers =
-    unit: Unit tests
-    integration: Integration tests
-    slow: Slow running tests
-filterwarnings =
-    ignore::DeprecationWarning
-    ignore::PendingDeprecationWarning
diff --git a/src/cvedb/cna/rules.json b/src/cvedb/cna/rules.json
deleted file mode 100644
index d146d87e197..00000000000
--- a/src/cvedb/cna/rules.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-  "foundationalCompleteness": {
-    "weight": 50,
-    "criteria": ["descriptions", "affected", "references"],
-    "binary": true
-  },
-  "rootCauseAnalysis": {
-    "weight": 15,
-    "criteria": ["validCWE"],
-    "binary": true
-  },
-  "severityAndImpactContext": {
-    "weight": 15,
-    "criteria": ["cvssV3or4", "validVector"],
-    "binary": true
-  },
-  "softwareIdentification": {
-    "weight": 10,
-    "criteria": ["validCPE"],
-    "binary": true
-  },
-  "patchinfo": {
-    "weight": 10,
-    "criteria": ["patchRef"],
-    "binary": true
-  }
-}
diff --git a/src/cvedb/cna/scoring.py b/src/cvedb/cna/scoring.py
deleted file mode 100644
index 7a36db0f54f..00000000000
--- a/src/cvedb/cna/scoring.py
+++ /dev/null
@@ -1,526 +0,0 @@
-"""
-scoring.py: Compute category scores for each CVE record according to CNA Scorecard methodology.
-
-This module provides functions to score individual CVE records based on completeness
-of key data fields across five categories: foundational completeness, root cause analysis,
-severity & impact context, software identification, and patch information.
-"""
-import logging
-from typing import Dict, Any, Optional, List
-
-from .config import ScoringConfig
-from .utils import extract_cna_short_name, format_date_string
-
-# Initialize logging and configuration
-logger = logging.getLogger('cnascorecard.scoring')
-scoring_config = ScoringConfig()
-
-def score_cve_record(cve: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Compute category-based score for a CVE record according to CNA Scorecard methodology.
-
-    Categories and weights (max points):
-    - Foundational Completeness (50): problemTypes, affected products, references, descriptions
-    - Root Cause Analysis (15): valid CWE ID, specific CWE
-    - Severity & Impact Context (15): CVSS v3/v4 metrics, valid CVSS vector string
-    - Software Identification (10): valid CPE in affected
-    - Patch Info (10): Patch/Vendor Advisory in references
-
-    Args:
-        cve: CVE record dictionary containing vulnerability data
-
-    Returns:
-        Dictionary containing:
-        - cveId: CVE identifier
-        - datePublished: Publication date
-        - assigningCna: CNA that assigned the CVE
-        - totalScore: Sum of all category scores
-        - scoreBreakdown: Individual category scores
-    """
-    try:
-        containers = cve.get("containers", {})
-        cna = containers.get("cna", {})
-        
-        # Extract CNA information
-        assigning_cna = extract_cna_short_name(cve) or "Unknown"
-        
-        # Calculate category scores
-        foundational_score = _calculate_foundational_completeness(cve, cna)
-        root_cause_score = _calculate_root_cause_analysis(cve, cna)
-        severity_score = _calculate_severity_context(cve, cna)
-        software_id_score = _calculate_software_identification(cve, cna)
-        actionable_score = _calculate_actionable_intelligence(cve, cna)
-
-        score_breakdown = {
-            "foundationalCompleteness": foundational_score,
-            "rootCauseAnalysis": root_cause_score,
-            "severityAndImpactContext": severity_score,
-            "softwareIdentification": software_id_score,
-            "patchinfo": actionable_score
-        }
-        total_score = sum(score_breakdown.values())
-
-        # Extract CVE metadata
-        cve_id = cve.get("cveId") or cve.get("cveMetadata", {}).get("cveId", "")
-        date_published = cve.get("datePublished") or cve.get("cveMetadata", {}).get("datePublished", "")
-        
-        result = {
-            "cveId": cve_id,
-            "datePublished": format_date_string(date_published),
-            "assigningCna": assigning_cna,
-            "totalScore": total_score,
-            "scoreBreakdown": score_breakdown
-        }
-        
-        logger.debug(f"Scored CVE {cve_id}: {total_score}/100 points (CNA: {assigning_cna})")
-        return result
-        
-    except Exception as e:
-        cve_id = cve.get("cveId", "unknown")
-        logger.error(f"Error scoring CVE {cve_id}: {e}")
-        # Return zero score for failed records
-        return {
-            "cveId": cve_id,
-            "datePublished": "",
-            "assigningCna": "Unknown",
-            "totalScore": 0,
-            "scoreBreakdown": {
-                "foundationalCompleteness": 0,
-                "rootCauseAnalysis": 0,
-                "severityAndImpactContext": 0,
-                "softwareIdentification": 0,
-                "patchinfo": 0
-            }
-        }
-
-
-def _calculate_foundational_completeness(cve: Dict[str, Any], cna: Dict[str, Any]) -> int:
-    """
-    Calculate foundational completeness score based on presence of core fields.
-    
-    Args:
-        cve: Full CVE record
-        cna: CNA container from CVE record
-        
-    Returns:
-        Score for foundational completeness (0 or weight value)
-    """
-    rule = scoring_config.rules['foundationalCompleteness']
-    criteria = rule['criteria']
-    
-    # Check if all required fields are present and non-empty
-    has_all_fields = all(bool(cna.get(field, [])) for field in criteria)
-    
-    score = rule['weight'] if has_all_fields else 0
-    logger.debug(f"Foundational completeness: {score}/{rule['weight']} (criteria: {criteria})")
-    
-    return score
-
-def _calculate_root_cause_analysis(cve: Dict[str, Any], cna: Dict[str, Any]) -> int:
-    """
-    Calculate root cause analysis score based on presence of valid CWE identifiers.
-    
-    Args:
-        cve: Full CVE record
-        cna: CNA container from CVE record
-        
-    Returns:
-        Score for root cause analysis (0 or weight value)
-    """
-    rule = scoring_config.rules['rootCauseAnalysis']
-    
-    # Try multiple locations for problem types
-    problem_types = (
-        cna.get('problemTypes')
-        or cve.get('containers', {}).get('cna', {}).get('problemTypes')
-        or cve.get('problemTypes', [])
-    )
-    
-    valid_cwe_found = _find_valid_cwe(problem_types)
-    score = rule['weight'] if valid_cwe_found else 0
-    
-    logger.debug(f"Root cause analysis: {score}/{rule['weight']} (valid CWE: {valid_cwe_found})")
-    return score
-
-
-def _find_valid_cwe(problem_types: List[Dict[str, Any]]) -> bool:
-    """
-    Search for valid CWE identifiers in problem types.
-    
-    Args:
-        problem_types: List of problem type dictionaries
-        
-    Returns:
-        True if valid CWE found, False otherwise
-    """
-    if not problem_types:
-        return False
-        
-    import re
-    cwe_pattern = re.compile(r'CWE-\d+', re.IGNORECASE)
-        
-    for pt in problem_types:
-        if not isinstance(pt, dict):
-            continue
-            
-        for cwe in pt.get('descriptions', []):
-            if not isinstance(cwe, dict):
-                continue
-                
-            # Check for explicit cweId field first (existing logic)
-            if "cweId" in cwe:
-                cwe_raw = cwe.get('cweId')
-                if cwe_raw and _is_valid_cwe_id(str(cwe_raw)):
-                    return True
-            
-            # Check for CWE ID embedded in description text (new logic)
-            desc_text = cwe.get('description', '')
-            if desc_text:
-                cwe_match = cwe_pattern.search(desc_text)
-                if cwe_match:
-                    extracted_cwe = cwe_match.group(0)
-                    if _is_valid_cwe_id(extracted_cwe):
-                        return True
-            
-            # Fallback to value field
-            cwe_raw = cwe.get('value')
-            if cwe_raw and _is_valid_cwe_id(str(cwe_raw)):
-                return True
-                
-    return False
-
-
-def _is_valid_cwe_id(cwe_raw: str) -> bool:
-    """
-    Check if a CWE identifier is valid.
-    
-    Args:
-        cwe_raw: Raw CWE identifier string
-        
-    Returns:
-        True if valid CWE ID, False otherwise
-    """
-    if not cwe_raw:
-        return False
-        
-    # Extract numeric part from CWE-XXX format
-    if cwe_raw.startswith('CWE-'):
-        cwe_num = cwe_raw[4:]
-    else:
-        cwe_num = cwe_raw
-        
-    return cwe_num in scoring_config.valid_cwe_ids
-
-def _calculate_severity_context(cve: Dict[str, Any], cna: Dict[str, Any]) -> int:
-    """
-    Calculate severity and impact context score based on CVSS metrics.
-    
-    Args:
-        cve: Full CVE record
-        cna: CNA container from CVE record
-        
-    Returns:
-        Score for severity and impact context (0 or weight value)
-    """
-    rule = scoring_config.rules['severityAndImpactContext']
-    metrics = cna.get('metrics', [])
-    
-    if not isinstance(metrics, list):
-        logger.debug("Severity context: 0 (no metrics list found)")
-        return 0
-    
-    has_cvss = _has_cvss_metrics(metrics)
-    valid_vector = _has_valid_cvss_vector(metrics)
-    
-    score = rule['weight'] if (has_cvss and valid_vector) else 0
-    logger.debug(f"Severity context: {score}/{rule['weight']} (CVSS: {has_cvss}, vector: {valid_vector})")
-    
-    return score
-
-
-def _has_cvss_metrics(metrics: List[Dict[str, Any]]) -> bool:
-    """
-    Check if metrics contain CVSS data.
-    
-    Args:
-        metrics: List of metric dictionaries
-        
-    Returns:
-        True if CVSS metrics found, False otherwise
-    """
-    cvss_versions = ["cvssV4_0", "cvssV3_1", "cvssV3_0"]
-    
-    for metric in metrics:
-        if not isinstance(metric, dict):
-            continue
-            
-        if any(version in metric for version in cvss_versions):
-            return True
-            
-    return False
-
-
-def _has_valid_cvss_vector(metrics: List[Dict[str, Any]]) -> bool:
-    """
-    Check if metrics contain valid CVSS vector strings.
-    
-    Args:
-        metrics: List of metric dictionaries
-        
-    Returns:
-        True if valid vector string found, False otherwise
-    """
-    cvss_versions = ["cvssV4_0", "cvssV3_1", "cvssV3_0"]
-    
-    for metric in metrics:
-        if not isinstance(metric, dict):
-            continue
-            
-        for version in cvss_versions:
-            if version in metric:
-                cvss_data = metric[version]
-                if isinstance(cvss_data, dict) and cvss_data.get("vectorString"):
-                    return True
-                    
-    return False
-
-def _calculate_software_identification(cve: Dict[str, Any], cna: Dict[str, Any]) -> int:
-    """
-    Calculate software identification score based on presence of CPE identifiers.
-    Checks both traditional affected[].cpes and CVE 5.1 cpeApplicability fields.
-    
-    Args:
-        cve: Full CVE record
-        cna: CNA container from CVE record
-        
-    Returns:
-        Score for software identification (0 or weight value)
-    """
-    rule = scoring_config.rules['softwareIdentification']
-    
-    # Check traditional affected[].cpes field
-    affected = cna.get('affected', [])
-    if isinstance(affected, list):
-        has_cpe_in_affected = _has_cpe_identifiers(affected)
-        if has_cpe_in_affected:
-            logger.debug(f"Software identification: {rule['weight']}/{rule['weight']} (CPE found in affected[].cpes)")
-            return rule['weight']
-    
-    # Check CVE 5.1 cpeApplicability field
-    has_cpe_applicability = _has_cpe_applicability(cna)
-    if has_cpe_applicability:
-        logger.debug(f"Software identification: {rule['weight']}/{rule['weight']} (CPE found in cpeApplicability)")
-        return rule['weight']
-    
-    logger.debug("Software identification: 0 (no CPE identifiers found in either field)")
-    return 0
-
-
-def _has_cpe_identifiers(affected: List[Dict[str, Any]]) -> bool:
-    """
-    Check if affected products contain CPE identifiers in traditional affected[].cpes field.
-    
-    Args:
-        affected: List of affected product dictionaries
-        
-    Returns:
-        True if CPE identifiers found, False otherwise
-    """
-    for product in affected:
-        if not isinstance(product, dict):
-            continue
-            
-        cpes = product.get('cpes')
-        if isinstance(cpes, list) and len(cpes) > 0:
-            return True
-            
-    return False
-
-
-def _has_cpe_applicability(cna: Dict[str, Any]) -> bool:
-    """
-    Check if CNA container has cpeApplicability field with valid CPE data (CVE 5.1 schema).
-    
-    The cpeApplicability field provides NVD-style CPE matching with operators and version ranges.
-    This is different from the simpler affected[].cpes field.
-    
-    Args:
-        cna: CNA container from CVE record
-        
-    Returns:
-        True if cpeApplicability with CPE match data found, False otherwise
-    """
-    cpe_applicability = cna.get('cpeApplicability')
-    
-    if not isinstance(cpe_applicability, list) or len(cpe_applicability) == 0:
-        return False
-    
-    # Check if any node contains CPE match data
-    for item in cpe_applicability:
-        if not isinstance(item, dict):
-            continue
-            
-        nodes = item.get('nodes', [])
-        if not isinstance(nodes, list):
-            continue
-            
-        for node in nodes:
-            if not isinstance(node, dict):
-                continue
-                
-            cpe_match = node.get('cpeMatch', [])
-            if isinstance(cpe_match, list) and len(cpe_match) > 0:
-                # Found at least one CPE match entry with criteria
-                for match in cpe_match:
-                    if isinstance(match, dict) and match.get('criteria'):
-                        return True
-    
-    return False
-
-
-def _calculate_actionable_intelligence(cve: Dict[str, Any], cna: Dict[str, Any]) -> int:
-    """
-    Calculate actionable intelligence score based on presence of patch references.
-    
-    Args:
-        cve: Full CVE record
-        cna: CNA container from CVE record
-        
-    Returns:
-        Score for actionable intelligence/patch info (0 or weight value)
-    """
-    rule = scoring_config.rules['patchinfo']
-    references = cna.get('references', [])
-    
-    if not isinstance(references, list):
-        logger.debug("Actionable intelligence: 0 (no references list)")
-        return 0
-    
-    has_patch_ref = _has_patch_references(references)
-    score = rule['weight'] if has_patch_ref else 0
-    
-    logger.debug(f"Actionable intelligence: {score}/{rule['weight']} (patch ref: {has_patch_ref})")
-    return score
-
-
-def _has_patch_references(references: List[Dict[str, Any]]) -> bool:
-    """
-    Check if references contain patch-related tags.
-    
-    Args:
-        references: List of reference dictionaries
-        
-    Returns:
-        True if patch references found, False otherwise
-    """
-    for ref in references:
-        if not isinstance(ref, dict):
-            continue
-            
-        tags = ref.get('tags', [])
-        if not isinstance(tags, list):
-            continue
-            
-        # Check for patch-related tags (case-insensitive)
-        for tag in tags:
-            if isinstance(tag, str) and 'patch' in tag.lower():
-                return True
-                
-    return False
-
-
-def score_multiple_cves(cves: List[Dict[str, Any]], use_cache: bool = True) -> List[Dict[str, Any]]:
-    """
-    Score multiple CVE records with progress tracking and optional caching.
-    
-    When caching is enabled, scores for unchanged CVEs are retrieved from cache,
-    significantly improving performance for incremental runs.
-    
-    Args:
-        cves: List of CVE record dictionaries
-        use_cache: Whether to use score caching (default: True)
-        
-    Returns:
-        List of scored CVE records (preserves input order and duplicates)
-    """
-    from utils import ProgressTracker
-    
-    if not cves:
-        logger.warning("No CVEs provided for scoring")
-        return []
-    
-    logger.info(f"Starting to score {len(cves)} CVE records (cache={'enabled' if use_cache else 'disabled'})")
-    
-    # Initialize cache if enabled
-    cache = None
-    if use_cache:
-        try:
-            from cache import get_cache
-            cache = get_cache()
-        except ImportError:
-            logger.debug("Cache module not available, scoring all CVEs")
-        except Exception as e:
-            logger.warning(f"Cache initialization error: {e}")
-    
-    progress = ProgressTracker(len(cves), "Scoring CVEs")
-    scored_cves = []
-    cache_hits = 0
-    cache_misses = 0
-    
-    for cve in cves:
-        try:
-            cve_id = cve.get("cveMetadata", {}).get("cveId")
-            cached_score = None
-            
-            # Try to get from cache
-            if cache and cve_id:
-                cached_score = cache.get(cve_id, cve)
-                if cached_score:
-                    cache_hits += 1
-                    scored_cves.append(cached_score)
-                    progress.update()
-                    continue
-                else:
-                    cache_misses += 1
-            
-            # Score the CVE
-            scored_cve = score_cve_record(cve)
-            scored_cves.append(scored_cve)
-            
-            # Cache the result
-            if cache and cve_id:
-                try:
-                    cache.set(cve_id, cve, scored_cve)
-                except Exception as e:
-                    logger.debug(f"Failed to cache score for {cve_id}: {e}")
-                    
-        except Exception as e:
-            cve_id = cve.get("cveId", cve.get("cveMetadata", {}).get("cveId", "unknown"))
-            logger.error(f"Failed to score CVE {cve_id}: {e}")
-            # Still add a zeroed score for consistency
-            scored_cves.append({
-                "cveId": cve_id if cve_id != "unknown" else "",
-                "datePublished": "",
-                "assigningCna": "Unknown",
-                "totalScore": 0,
-                "scoreBreakdown": {
-                    "foundationalCompleteness": 0,
-                    "rootCauseAnalysis": 0,
-                    "severityAndImpactContext": 0,
-                    "softwareIdentification": 0,
-                    "patchinfo": 0
-                }
-            })
-        finally:
-            progress.update()
-    
-    progress.finish()
-    
-    if cache_hits > 0:
-        logger.info(f"Cache: {cache_hits} hits, {cache_misses} misses")
-    
-    logger.info(f"Successfully scored {len(scored_cves)} out of {len(cves)} CVE records")
-    
-    return scored_cves
-    
-    return scored_cves
diff --git a/src/cvedb/cna/sync_cna_list.py b/src/cvedb/cna/sync_cna_list.py
deleted file mode 100644
index 6f66d094df8..00000000000
--- a/src/cvedb/cna/sync_cna_list.py
+++ /dev/null
@@ -1,200 +0,0 @@
-"""
-sync_cna_list.py: Download and sync official CNAs list from CVE Project GitHub repository.
-Ensures web/data/cna_list.json stays current with daily updates.
-"""
-
-import json
-import logging
-import os
-import requests
-from typing import Dict, List, Any
-from pathlib import Path
-
-
-def download_official_cnas_list() -> List[Dict[str, Any]]:
-    """Download the official CNAs list from CVE Project GitHub repository."""
-    url = "https://raw.githubusercontent.com/CVEProject/cve-website/dev/src/assets/data/CNAsList.json"
-    
-    try:
-        logging.info(f"Downloading official CNAs list from: {url}")
-        response = requests.get(url, timeout=30)
-        response.raise_for_status()
-        
-        data = response.json()
-        logging.info(f"Successfully downloaded {len(data)} CNAs from official list")
-        return data
-        
-    except requests.RequestException as e:
-        logging.error(f"Failed to download CNAs list: {e}")
-        raise
-    except json.JSONDecodeError as e:
-        logging.error(f"Failed to parse CNAs list JSON: {e}")
-        raise
-
-
-def create_enhanced_cna_list(official_cnas: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
-    """Create enhanced CNA list with essential metadata for frontend use."""
-    enhanced_cnas = []
-    
-    for cna in official_cnas:
-        # Robust shortName extraction
-        short_name = cna.get('shortName') or cna.get('ShortName') or cna.get('cnaShortName')
-        if not short_name:
-            # Fallback: try to construct from organizationName or cnaID
-            if 'organizationName' in cna:
-                short_name = cna['organizationName'].replace(' ', '_').lower()
-            elif 'cnaID' in cna:
-                short_name = cna['cnaID']
-            else:
-                logging.warning(f"Skipping CNA with no shortName or fallback: {cna}")
-                continue
-        root_cna_info = {}
-        if 'CNA' in cna and 'root' in cna['CNA']:
-            # Only use if not a placeholder
-            if cna['CNA']['root'].get('shortName', '').lower() != 'n/a':
-                root_cna_info = cna['CNA']['root']
-            elif 'rootCnaInfo' in cna:
-                root_cna_info = cna['rootCnaInfo']
-        elif 'rootCnaInfo' in cna:
-            root_cna_info = cna['rootCnaInfo']
-        if not root_cna_info:
-            root_cna_info = {}
-        # Robustly extract cnaID and type from any possible location
-        cna_id = cna.get('cnaID', '')
-        cna_types = cna.get('type', [])
-        if 'CNA' in cna:
-            cna_id = cna['CNA'].get('cnaID', '') or cna_id
-            cna_types = cna['CNA'].get('type', cna_types)
-        # Ensure cna_types is always a list
-        if isinstance(cna_types, str):
-            cna_types = [cna_types]
-        elif not isinstance(cna_types, list):
-            cna_types = []
-        enhanced_cna = {
-            'shortName': short_name,
-            'organizationName': cna.get('organizationName', short_name),
-            'scope': cna.get('scope', ''),
-            'cnaID': cna_id,
-            'type': cna_types,
-            'advisories': [],
-            'email': [],
-            'country': cna.get('country', ''),
-            'disclosurePolicy': cna.get('disclosurePolicy', []),
-            'rootCnaInfo': root_cna_info
-        }
-        if 'CNA' in cna and 'root' in cna['CNA']:
-            # Only use if not a placeholder
-            if cna['CNA']['root'].get('shortName', '').lower() != 'n/a':
-                root_cna_info = cna['CNA']['root']
-            elif 'rootCnaInfo' in cna:
-                root_cna_info = cna['rootCnaInfo']
-        elif 'rootCnaInfo' in cna:
-            root_cna_info = cna['rootCnaInfo']
-        # If still empty, set to empty dict
-        if not root_cna_info:
-            root_cna_info = {}
-        # Robustly extract cnaID and type
-        cna_id = ''
-        cna_types = []
-        if 'CNA' in cna:
-            cna_id = cna['CNA'].get('cnaID', '') or cna.get('cnaID', '')
-            cna_types = cna['CNA'].get('type', [])
-        else:
-            cna_id = cna.get('cnaID', '')
-            cna_types = cna.get('type', [])
-        # Ensure cna_types is always a list
-        if isinstance(cna_types, str):
-            cna_types = [cna_types]
-        elif not isinstance(cna_types, list):
-            cna_types = []
-        enhanced_cna = {
-            'shortName': cna['shortName'],
-            'organizationName': cna.get('organizationName', cna['shortName']),
-            'scope': cna.get('scope', ''),
-            'cnaID': cna_id,
-            'type': cna_types,
-            'advisories': [],
-            'email': [],
-            'country': cna.get('country', ''),
-            'disclosurePolicy': cna.get('disclosurePolicy', []),
-            'rootCnaInfo': root_cna_info
-        }
-        
-        # Extract CNA type
-        if 'CNA' in cna and 'type' in cna['CNA']:
-            enhanced_cna['type'] = cna['CNA']['type']
-        
-        # Extract advisories
-        if 'securityAdvisories' in cna and 'advisories' in cna['securityAdvisories']:
-            enhanced_cna['advisories'] = cna['securityAdvisories']['advisories']
-        
-        # Extract email contacts
-        if 'contact' in cna:
-            for contact in cna['contact']:
-                if 'email' in contact:
-                    enhanced_cna['email'].extend(contact['email'])
-        
-        enhanced_cnas.append(enhanced_cna)
-    
-    # Sort by organization name for consistent ordering
-    enhanced_cnas.sort(key=lambda x: x['organizationName'].lower())
-    
-    logging.info(f"Created enhanced CNA list with {len(enhanced_cnas)} entries")
-    return enhanced_cnas
-
-
-def save_cna_lists(official_cnas: List[Dict[str, Any]], enhanced_cnas: List[Dict[str, Any]]) -> None:
-    """Save CNA list files needed for pipeline operation.
-    
-    Note: While these files are not used by web pages, cna_list.json is required
-    internally by the pipeline for CNA metadata. We only skip official_cnas_list.json
-    which is truly unused.
-    """
-    
-    # Determine the web/data directory path
-    current_dir = Path(__file__).parent
-    web_data_dir = current_dir.parent / 'web' / 'data'
-    web_data_dir.mkdir(parents=True, exist_ok=True)
-    
-    # Skip raw official CNAs list (truly unused)
-    logging.info("Skipping official_cnas_list.json generation - not used by web interface or pipeline")
-    
-    # Save enhanced CNA list for pipeline internal use (required for CNA metadata)
-    enhanced_file = web_data_dir / 'cna_list.json'
-    with open(enhanced_file, 'w', encoding='utf-8') as f:
-        json.dump(enhanced_cnas, f, indent=2, ensure_ascii=False)
-    logging.info(f"Saved enhanced CNA list to: {enhanced_file} (required for pipeline operation)")
-
-
-def sync_cna_list() -> bool:
-    """Main function to sync the CNAs list. Returns True if successful."""
-    try:
-        logging.info("Starting CNAs list sync...")
-        
-        # Download official CNAs list
-        official_cnas = download_official_cnas_list()
-        
-        # Create enhanced version for frontend
-        enhanced_cnas = create_enhanced_cna_list(official_cnas)
-        
-        # Save both versions
-        save_cna_lists(official_cnas, enhanced_cnas)
-        
-        logging.info("CNAs list sync completed successfully")
-        return True
-        
-    except Exception as e:
-        logging.error(f"CNAs list sync failed: {e}")
-        return False
-
-
-if __name__ == "__main__":
-    # Set up logging
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(levelname)s - %(message)s'
-    )
-    
-    # Run the sync
-    success = sync_cna_list()
-    exit(0 if success else 1)
diff --git a/src/cvedb/cna/test_cpe_applicability.py b/src/cvedb/cna/test_cpe_applicability.py
deleted file mode 100644
index a532f24f523..00000000000
--- a/src/cvedb/cna/test_cpe_applicability.py
+++ /dev/null
@@ -1,175 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script to validate CPE applicability detection fix.
-
-Tests three scenarios:
-1. CVE with traditional affected[].cpes field (IBM CVE-2025-0163)
-2. CVE with new cpeApplicability field (Lenovo CVE-2025-2502)
-3. CVE with no CPE data (should score 0)
-"""
-
-import json
-import sys
-from pathlib import Path
-
-# Add parent directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent))
-
-from .scoring import score_cve_record
-
-
-def test_traditional_cpes():
-    """Test CVE with traditional affected[].cpes field - IBM example"""
-    print("\n" + "="*70)
-    print("TEST 1: Traditional affected[].cpes field")
-    print("="*70)
-    
-    cve_path = Path(__file__).parent.parent / 'cve_data' / 'cves' / '2025' / '0xxx' / 'CVE-2025-0163.json'
-    
-    if not cve_path.exists():
-        print(f"⚠️  WARNING: Test CVE not found at {cve_path}")
-        print("   Skipping test - file may not be available")
-        return True
-    
-    with open(cve_path) as f:
-        cve = json.load(f)
-    
-    print(f"CVE ID: {cve.get('cveMetadata', {}).get('cveId', 'Unknown')}")
-    print(f"CNA: {cve.get('containers', {}).get('cna', {}).get('providerMetadata', {}).get('shortName', 'Unknown')}")
-    
-    result = score_cve_record(cve)
-    software_score = result['scoreBreakdown']['softwareIdentification']
-    
-    print(f"\nSoftware Identification Score: {software_score}/10")
-    
-    if software_score == 10:
-        print("✅ PASS: Traditional cpes field correctly detected")
-        return True
-    else:
-        print(f"❌ FAIL: Expected 10 points for traditional CPEs, got {software_score}")
-        return False
-
-
-def test_cpe_applicability():
-    """Test CVE with cpeApplicability field - Lenovo example"""
-    print("\n" + "="*70)
-    print("TEST 2: CVE 5.1 cpeApplicability field")
-    print("="*70)
-    
-    cve_path = Path(__file__).parent.parent / 'cve_data' / 'cves' / '2025' / '2xxx' / 'CVE-2025-2502.json'
-    
-    if not cve_path.exists():
-        print(f"⚠️  WARNING: Test CVE not found at {cve_path}")
-        print("   Skipping test - file may not be available")
-        return True
-    
-    with open(cve_path) as f:
-        cve = json.load(f)
-    
-    print(f"CVE ID: {cve.get('cveMetadata', {}).get('cveId', 'Unknown')}")
-    print(f"CNA: {cve.get('containers', {}).get('cna', {}).get('providerMetadata', {}).get('shortName', 'Unknown')}")
-    
-    # Check if cpeApplicability exists
-    has_cpe_app = bool(cve.get('containers', {}).get('cna', {}).get('cpeApplicability'))
-    print(f"Has cpeApplicability field: {has_cpe_app}")
-    
-    result = score_cve_record(cve)
-    software_score = result['scoreBreakdown']['softwareIdentification']
-    
-    print(f"\nSoftware Identification Score: {software_score}/10")
-    
-    if software_score == 10:
-        print("✅ PASS: cpeApplicability field correctly detected")
-        return True
-    else:
-        print(f"❌ FAIL: Expected 10 points for cpeApplicability, got {software_score}")
-        print("   This is the bug we're fixing!")
-        return False
-
-
-def test_no_cpes():
-    """Test CVE with no CPE data - should score 0"""
-    print("\n" + "="*70)
-    print("TEST 3: CVE with no CPE data")
-    print("="*70)
-    
-    # Create minimal CVE without CPE data
-    cve = {
-        "cveId": "CVE-TEST-0001",
-        "cveMetadata": {
-            "cveId": "CVE-TEST-0001",
-            "assignerOrgId": "test-org",
-            "state": "PUBLISHED",
-            "datePublished": "2025-01-01T00:00:00.000Z"
-        },
-        "containers": {
-            "cna": {
-                "descriptions": [{"lang": "en", "value": "Test CVE without CPE data"}],
-                "affected": [{"vendor": "Test", "product": "Test"}],
-                "references": [{"url": "http://test.com"}],
-                "providerMetadata": {
-                    "orgId": "test-org",
-                    "shortName": "test"
-                }
-            }
-        }
-    }
-    
-    print(f"CVE ID: {cve['cveMetadata']['cveId']}")
-    print(f"CNA: test (synthetic test case)")
-    
-    result = score_cve_record(cve)
-    software_score = result['scoreBreakdown']['softwareIdentification']
-    
-    print(f"\nSoftware Identification Score: {software_score}/10")
-    
-    if software_score == 0:
-        print("✅ PASS: Correctly scored 0 for missing CPE data")
-        return True
-    else:
-        print(f"❌ FAIL: Expected 0 points for no CPEs, got {software_score}")
-        return False
-
-
-def main():
-    """Run all tests and report results"""
-    print("\n" + "="*70)
-    print("CPE APPLICABILITY DETECTION TEST SUITE")
-    print("="*70)
-    print("\nThis test validates the fix for detecting CPE data in both:")
-    print("  1. Traditional affected[].cpes field")
-    print("  2. New CVE 5.1 cpeApplicability field")
-    
-    results = []
-    
-    # Run tests
-    results.append(("Traditional cpes", test_traditional_cpes()))
-    results.append(("cpeApplicability", test_cpe_applicability()))
-    results.append(("No CPE data", test_no_cpes()))
-    
-    # Summary
-    print("\n" + "="*70)
-    print("TEST SUMMARY")
-    print("="*70)
-    
-    passed = sum(1 for _, result in results if result)
-    total = len(results)
-    
-    for test_name, result in results:
-        status = "✅ PASS" if result else "❌ FAIL"
-        print(f"{status}: {test_name}")
-    
-    print(f"\nResults: {passed}/{total} tests passed")
-    
-    if passed == total:
-        print("\n🎉 SUCCESS: All CPE detection tests passed!")
-        print("   The fix is working correctly for both CPE field types.")
-        return 0
-    else:
-        print(f"\n⚠️  FAILURE: {total - passed} test(s) failed")
-        print("   Review the output above for details.")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())
diff --git a/src/cvedb/cna/tests/__init__.py b/src/cvedb/cna/tests/__init__.py
deleted file mode 100644
index 94e38570c1d..00000000000
--- a/src/cvedb/cna/tests/__init__.py
+++ /dev/null
@@ -1,6 +0,0 @@
-"""
-Test package for CNA Scorecard Pipeline.
-
-This package contains unit tests for all pipeline modules to ensure
-correctness of data transformations and prevent regressions.
-"""
diff --git a/src/cvedb/cna/tests/test_aggregation.py b/src/cvedb/cna/tests/test_aggregation.py
deleted file mode 100644
index d0420f0ea98..00000000000
--- a/src/cvedb/cna/tests/test_aggregation.py
+++ /dev/null
@@ -1,525 +0,0 @@
-"""
-Unit tests for aggregation module.
-
-This module tests the CNA-level aggregation logic to ensure correct
-calculation of summary statistics and trend analysis.
-"""
-import pytest
-from unittest.mock import patch, MagicMock, mock_open
-from typing import Dict, Any, List
-from datetime import datetime
-
-# Import the module under test
-import sys
-from pathlib import Path
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from aggregation import aggregate_cna_scores
-
-
-class TestAggregationFixtures:
-    """Test fixtures for aggregation tests."""
-    
-    @pytest.fixture
-    def sample_scored_cves(self) -> List[Dict[str, Any]]:
-        """Sample scored CVE records for testing."""
-        return [
-            {
-                "cveId": "CVE-2024-0001",
-                "assigningCna": "TestCNA1",
-                "datePublished": "2024-01-15",
-                "totalScore": 85,
-                "scoreBreakdown": {
-                    "foundationalCompleteness": 50,
-                    "rootCauseAnalysis": 15,
-                    "severityAndImpactContext": 15,
-                    "softwareIdentification": 5,
-                    "patchinfo": 0
-                }
-            },
-            {
-                "cveId": "CVE-2024-0002",
-                "assigningCna": "TestCNA1",
-                "datePublished": "2024-01-20",
-                "totalScore": 75,
-                "scoreBreakdown": {
-                    "foundationalCompleteness": 50,
-                    "rootCauseAnalysis": 0,
-                    "severityAndImpactContext": 15,
-                    "softwareIdentification": 10,
-                    "patchinfo": 0
-                }
-            },
-            {
-                "cveId": "CVE-2024-0003",
-                "assigningCna": "TestCNA2",
-                "datePublished": "2024-01-25",
-                "totalScore": 100,
-                "scoreBreakdown": {
-                    "foundationalCompleteness": 50,
-                    "rootCauseAnalysis": 15,
-                    "severityAndImpactContext": 15,
-                    "softwareIdentification": 10,
-                    "patchinfo": 10
-                }
-            },
-            {
-                "cveId": "CVE-2024-0004",
-                "assigningCna": "TestCNA2",
-                "datePublished": "2024-02-01",
-                "totalScore": 90,
-                "scoreBreakdown": {
-                    "foundationalCompleteness": 50,
-                    "rootCauseAnalysis": 15,
-                    "severityAndImpactContext": 15,
-                    "softwareIdentification": 10,
-                    "patchinfo": 0
-                }
-            }
-        ]
-    
-    @pytest.fixture
-    def sample_periods(self):
-        """Sample time periods for trend analysis."""
-        return [
-            (datetime(2024, 1, 1), datetime(2024, 1, 31)),
-            (datetime(2024, 2, 1), datetime(2024, 2, 29))
-        ]
-    
-    @pytest.fixture
-    def mock_cna_metadata(self):
-        """Mock CNA metadata for testing."""
-        return {
-            "testcna1": {
-                "shortName": "TestCNA1",
-                "organizationName": "Test Organization 1",
-                "scope": "Test scope 1",
-                "type": ["vendor"],
-                "country": "US"
-            },
-            "testcna2": {
-                "shortName": "TestCNA2", 
-                "organizationName": "Test Organization 2",
-                "scope": "Test scope 2",
-                "type": ["coordinator"],
-                "country": "CA"
-            }
-        }
-
-
-class TestAggregateCnaScores(TestAggregationFixtures):
-    """Test the main aggregate_cna_scores function."""
-    
-    @patch('aggregation.os.path.exists')
-    @patch('builtins.open', new_callable=mock_open)
-    @patch('json.load')
-    @patch('os.path.exists')
-    def test_aggregate_basic_functionality(
-        self, 
-        mock_exists, 
-        mock_json_load,
-        mock_file_open,
-        sample_scored_cves,
-        sample_periods,
-        mock_cna_metadata
-    ):
-        """Test basic aggregation functionality."""
-        # Setup mocks
-        mock_exists.return_value = True
-        mock_json_load.return_value = [
-            {
-                "shortName": "TestCNA1",
-                "organizationName": "Test Organization 1",
-                "scope": "Test scope 1",
-                "type": ["vendor"],
-                "country": "US"
-            },
-            {
-                "shortName": "TestCNA2",
-                "organizationName": "Test Organization 2", 
-                "scope": "Test scope 2",
-                "type": ["coordinator"],
-                "country": "CA"
-            }
-        ]
-        
-        # Use actual CVE data instead of mock
-        actual_cves = [
-            {
-                "cveId": "CVE-2024-0001",
-                "assigningCna": "TestCNA1",
-                "datePublished": "2024-01-15",
-                "totalScore": 85,
-                "scoreBreakdown": {
-                    "foundationalCompleteness": 50,
-                    "rootCauseAnalysis": 15,
-                    "severityAndImpactContext": 15,
-                    "softwareIdentification": 5,
-                    "patchinfo": 0
-                }
-            },
-            {
-                "cveId": "CVE-2024-0002",
-                "assigningCna": "TestCNA1",
-                "datePublished": "2024-01-20",
-                "totalScore": 75,
-                "scoreBreakdown": {
-                    "foundationalCompleteness": 50,
-                    "rootCauseAnalysis": 0,
-                    "severityAndImpactContext": 15,
-                    "softwareIdentification": 10,
-                    "patchinfo": 0
-                }
-            }
-        ]
-        
-        result = aggregate_cna_scores(actual_cves, sample_periods)
-        
-        # Verify structure
-        assert isinstance(result, dict)
-        # The function should return results for all official CNAs, even if no CVE data
-        assert len(result) >= 2
-        
-        # Check that we have CNA info structure
-        for cna_name, cna_result in result.items():
-            assert "cna_info" in cna_result
-            assert "cna_scoring" in cna_result
-            assert "cve_scoring" in cna_result
-        
-        # Verify CNA scoring structure (if TestCNA1 exists)
-        if "TestCNA1" in result:
-            cna1_scoring = result["TestCNA1"]["cna_scoring"][0]
-            # Note: assertions may need adjustment based on actual function behavior
-            assert "total_cves" in cna1_scoring
-            assert "overall_average_score" in cna1_scoring
-            
-            # Verify CVE scoring structure
-            cna1_cve_scoring = result["TestCNA1"]["cve_scoring"]
-            assert isinstance(cna1_cve_scoring, list)
-    
-    @patch('os.path.exists')
-    def test_aggregate_no_metadata_file(self, mock_exists, sample_scored_cves, sample_periods):
-        """Test aggregation when CNA metadata file doesn't exist."""
-        mock_exists.return_value = False
-        
-        result = aggregate_cna_scores(sample_scored_cves, sample_periods)
-        
-        # Should still work but with limited metadata
-        assert isinstance(result, dict)
-        assert len(result) >= 0  # May be empty if no official CNAs match
-    
-    def test_aggregate_empty_cves(self, sample_periods):
-        """Test aggregation with empty CVE list."""
-        with patch('aggregation.os.path.exists', return_value=False):
-            result = aggregate_cna_scores([], sample_periods)
-            assert isinstance(result, dict)
-    
-    @patch('aggregation.os.path.exists')
-    @patch('builtins.open', new_callable=mock_open)
-    @patch('json.load')
-    @patch('os.path.exists')
-    def test_aggregate_score_calculations(
-        self,
-        mock_exists,
-        mock_json_load,
-        mock_file_open,
-        sample_scored_cves,
-        sample_periods
-    ):
-        """Test that score calculations are correct."""
-        # Setup mocks
-        mock_exists.return_value = True
-        mock_json_load.return_value = [
-            {"shortName": "TestCNA1"},
-            {"shortName": "TestCNA2"}
-        ]
-        
-        # Use actual CVE data for testing calculations
-        actual_cves = [
-            {
-                "cveId": "CVE-2024-0001",
-                "assigningCna": "TestCNA1",
-                "datePublished": "2024-01-15",
-                "totalScore": 85,
-                "scoreBreakdown": {
-                    "foundationalCompleteness": 50,
-                    "rootCauseAnalysis": 15,
-                    "severityAndImpactContext": 15,
-                    "softwareIdentification": 5,
-                    "patchinfo": 0
-                }
-            },
-            {
-                "cveId": "CVE-2024-0002",
-                "assigningCna": "TestCNA1",
-                "datePublished": "2024-01-20",
-                "totalScore": 75,
-                "scoreBreakdown": {
-                    "foundationalCompleteness": 50,
-                    "rootCauseAnalysis": 0,
-                    "severityAndImpactContext": 15,
-                    "softwareIdentification": 10,
-                    "patchinfo": 0
-                }
-            }
-        ]
-        
-        result = aggregate_cna_scores(actual_cves, sample_periods)
-        
-        # Check that we have results and basic structure
-        assert isinstance(result, dict)
-        assert len(result) >= 1
-        
-        # Check that CNA scoring structure exists and has valid data
-        for cna_name, cna_result in result.items():
-            assert "cna_scoring" in cna_result
-            if cna_result["cna_scoring"]:
-                cna_scoring = cna_result["cna_scoring"][0]
-                assert "overall_average_score" in cna_scoring
-                assert isinstance(cna_scoring["overall_average_score"], (int, float))
-    
-    @patch('aggregation.os.path.exists')
-    @patch('builtins.open', new_callable=mock_open)
-    @patch('json.load')
-    @patch('os.path.exists')
-    def test_aggregate_percentage_calculations(
-        self,
-        mock_exists,
-        mock_json_load,
-        mock_file_open,
-        sample_periods
-    ):
-        """Test percentage-based calculations for category completeness."""
-        # Setup mocks
-        mock_exists.return_value = True
-        mock_json_load.return_value = [{"shortName": "TestCNA"}]
-        
-        # Create test data where some CVEs have certain categories, others don't
-        test_cves = [
-            {
-                "cveId": "CVE-2024-0001",
-                "assigningCna": "TestCNA",
-                "datePublished": "2024-01-15",
-                "totalScore": 50,
-                "scoreBreakdown": {
-                    "foundationalCompleteness": 50,  # Has this
-                    "rootCauseAnalysis": 0,          # Missing this
-                    "severityAndImpactContext": 0,   # Missing this
-                    "softwareIdentification": 0,     # Missing this
-                    "patchinfo": 0                   # Missing this
-                }
-            },
-            {
-                "cveId": "CVE-2024-0002",
-                "assigningCna": "TestCNA",
-                "datePublished": "2024-01-20",
-                "totalScore": 65,
-                "scoreBreakdown": {
-                    "foundationalCompleteness": 50,  # Has this
-                    "rootCauseAnalysis": 15,         # Has this
-                    "severityAndImpactContext": 0,   # Missing this
-                    "softwareIdentification": 0,     # Missing this
-                    "patchinfo": 0                   # Missing this
-                }
-            }
-        ]
-        
-        result = aggregate_cna_scores(test_cves, sample_periods)
-        
-        if "TestCNA" in result:
-            scoring = result["TestCNA"]["cna_scoring"][0]
-            # 100% of CVEs have foundational completeness (2/2)
-            assert scoring.get("percent_foundational_completeness", 0) == 100.0
-            # 50% of CVEs have root cause analysis (1/2)
-            assert scoring.get("percent_root_cause_analysis", 0) == 50.0
-            # 0% have the others
-            assert scoring.get("percent_severity_and_impact", 0) == 0.0
-
-
-class TestCnaNameMapping:
-    """Test CNA name mapping functionality."""
-    
-    def test_exact_name_match(self):
-        """Test exact CNA name matching."""
-        from aggregation import aggregate_cna_scores
-        
-        # This is testing the internal mapping logic
-        # We'd need to extract the mapping function to test it properly
-        # For now, we test it through the main function
-        pass
-    
-    def test_case_insensitive_match(self):
-        """Test case-insensitive CNA name matching."""
-        pass
-    
-    def test_normalized_name_match(self):
-        """Test normalized CNA name matching (removing spaces, hyphens)."""
-        pass
-
-
-class TestTrendCalculations:
-    """Test trend calculation functionality."""
-    
-    def test_trend_calculation_called(self):
-        """Test that aggregation function works with empty data."""
-        # Create sample periods directly
-        from datetime import datetime
-        sample_periods = [
-            (datetime(2024, 1, 1), datetime(2024, 1, 31)),
-            (datetime(2024, 2, 1), datetime(2024, 2, 29))
-        ]
-        
-        with patch('aggregation.os.path.exists', return_value=False):
-            result = aggregate_cna_scores([], sample_periods)
-            
-        # Just verify the function returns a valid result
-        assert isinstance(result, dict)
-        
-        # Verify trend functions would be called for CNAs with data
-        # (They won't be called with empty CVE list, but structure should be there)
-        assert isinstance(result, dict)
-
-
-class TestErrorHandling:
-    """Test error handling in aggregation."""
-    
-    @patch('aggregation.os.path.exists')
-    @patch('aggregation.open', side_effect=IOError("File read error"))
-    def test_file_read_error(self, mock_file, mock_exists):
-        """Test handling of file read errors."""
-        mock_exists.return_value = True
-        
-        # Create sample periods directly
-        from datetime import datetime
-        sample_periods = [
-            (datetime(2024, 1, 1), datetime(2024, 1, 31)),
-            (datetime(2024, 2, 1), datetime(2024, 2, 29))
-        ]
-        
-        # Should handle file read errors gracefully
-        result = aggregate_cna_scores([], sample_periods)
-        assert isinstance(result, dict)
-    
-    @patch('aggregation.os.path.exists')
-    @patch('aggregation.open', new_callable=mock_open, read_data='invalid json')
-    @patch('aggregation.json.load', side_effect=ValueError("Invalid JSON"))
-    def test_json_parse_error(self, mock_json, mock_file, mock_exists):
-        """Test handling of JSON parse errors."""
-        mock_exists.return_value = True
-        
-        # Create sample periods directly
-        from datetime import datetime
-        sample_periods = [
-            (datetime(2024, 1, 1), datetime(2024, 1, 31)),
-            (datetime(2024, 2, 1), datetime(2024, 2, 29))
-        ]
-        
-        # Should handle JSON parse errors gracefully
-        result = aggregate_cna_scores([], sample_periods)
-        assert isinstance(result, dict)
-    
-    def test_invalid_cve_data(self):
-        """Test handling of invalid CVE data structures."""
-        # Create sample periods directly
-        from datetime import datetime
-        sample_periods = [
-            (datetime(2024, 1, 1), datetime(2024, 1, 31)),
-            (datetime(2024, 2, 1), datetime(2024, 2, 29))
-        ]
-        
-        invalid_cves = [
-            {"invalid": "structure"},
-            {"cveId": "CVE-2024-0001"},  # Missing required fields
-            None  # Completely invalid
-        ]
-        
-        # Should handle invalid CVE data gracefully
-        result = aggregate_cna_scores(invalid_cves, sample_periods)
-        assert isinstance(result, dict)
-
-
-class TestDataStructureValidation:
-    """Test output data structure validation."""
-    
-    @patch('aggregation.os.path.exists')
-    @patch('aggregation.open', new_callable=mock_open)
-    @patch('aggregation.json.load')
-    def test_output_structure_completeness(
-        self,
-        mock_json_load,
-        mock_file,
-        mock_exists
-    ):
-        """Test that output structure contains all required fields."""
-        mock_exists.return_value = True
-        mock_json_load.return_value = [{"shortName": "TestCNA"}]
-        
-        # Create sample periods directly
-        from datetime import datetime
-        sample_periods = [
-            (datetime(2024, 1, 1), datetime(2024, 1, 31)),
-            (datetime(2024, 2, 1), datetime(2024, 2, 29))
-        ]
-        
-        test_cve = {
-            "cveId": "CVE-2024-0001",
-            "assigningCna": "TestCNA",
-            "datePublished": "2024-01-15",
-            "totalScore": 85,
-            "scoreBreakdown": {
-                "foundationalCompleteness": 50,
-                "rootCauseAnalysis": 15,
-                "severityAndImpactContext": 15,
-                "softwareIdentification": 5,
-                "patchinfo": 0
-            }
-        }
-        
-        result = aggregate_cna_scores([test_cve], sample_periods)
-        
-        if "TestCNA" in result:
-            cna_result = result["TestCNA"]
-            
-            # Check top-level structure
-            assert "cna_info" in cna_result
-            assert "cna_scoring" in cna_result
-            assert "cve_scoring" in cna_result
-            
-            # Check cna_info required fields
-            cna_info = cna_result["cna_info"][0]
-            required_info_fields = [
-                "cna", "total_cves", "total_cves_scored",
-                "organizationName", "scope", "advisories", "email",
-                "officialCnaID", "cnaTypes", "country", "disclosurePolicy",
-                "rootCnaInfo", "rank", "active_cna_count", "percentile"
-            ]
-            for field in required_info_fields:
-                assert field in cna_info
-            
-            # Check cna_scoring required fields
-            cna_scoring = cna_result["cna_scoring"][0]
-            required_scoring_fields = [
-                "total_cves", "total_cves_scored", "recent_cves_count",
-                "overall_average_score", "average_foundational_completeness",
-                "average_root_cause_analysis", "average_software_identification",
-                "average_severity_context", "average_patchinfo",
-                "percent_foundational_completeness", "percent_root_cause_analysis",
-                "percent_software_identification", "percent_severity_and_impact",
-                "percent_patchinfo", "trend_direction", "trend_description",
-                "monthly_trends"
-            ]
-            for field in required_scoring_fields:
-                assert field in cna_scoring
-            
-            # Check cve_scoring structure
-            cve_scoring = cna_result["cve_scoring"][0]
-            required_cve_fields = [
-                "cveId", "assigningCna", "datePublished", 
-                "totalCveScore", "scoreBreakdown"
-            ]
-            for field in required_cve_fields:
-                assert field in cve_scoring
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])
diff --git a/src/cvedb/cna/tests/test_cache.py b/src/cvedb/cna/tests/test_cache.py
deleted file mode 100644
index c6ce91d8e97..00000000000
--- a/src/cvedb/cna/tests/test_cache.py
+++ /dev/null
@@ -1,324 +0,0 @@
-"""
-Tests for cache.py - Score caching for CVE data.
-"""
-import json
-import pytest
-from pathlib import Path
-from datetime import datetime, timezone, timedelta
-
-from cache import ScoreCache, get_cache, reset_cache
-
-
-class TestScoreCacheInit:
-    """Tests for ScoreCache initialization."""
-    
-    def test_default_cache_dir(self, tmp_path, monkeypatch):
-        """Should use default cache directory."""
-        cache = ScoreCache(cache_dir=tmp_path)
-        assert cache.cache_dir == tmp_path
-    
-    def test_custom_cache_dir(self, tmp_path):
-        """Should accept custom cache directory."""
-        custom_dir = tmp_path / "custom_cache"
-        cache = ScoreCache(cache_dir=custom_dir)
-        assert cache.cache_dir == custom_dir
-    
-    def test_creates_directory_on_first_write(self, tmp_path):
-        """Should create cache directory when needed."""
-        cache_dir = tmp_path / "new_cache"
-        cache = ScoreCache(cache_dir=cache_dir)
-        
-        # Directory shouldn't exist yet
-        assert not cache_dir.exists()
-        
-        # Trigger initialization
-        cache.set("CVE-2024-0001", {"data": "test"}, {"score": 50})
-        
-        # Now it should exist
-        assert cache_dir.exists()
-
-
-class TestComputeHash:
-    """Tests for ScoreCache.compute_hash static method."""
-    
-    def test_consistent_hash(self):
-        """Same data should produce same hash."""
-        data = {"key": "value", "nested": {"a": 1}}
-        hash1 = ScoreCache.compute_hash(data)
-        hash2 = ScoreCache.compute_hash(data)
-        assert hash1 == hash2
-    
-    def test_different_data_different_hash(self):
-        """Different data should produce different hash."""
-        data1 = {"key": "value1"}
-        data2 = {"key": "value2"}
-        assert ScoreCache.compute_hash(data1) != ScoreCache.compute_hash(data2)
-    
-    def test_order_independent(self):
-        """Key order shouldn't affect hash."""
-        data1 = {"a": 1, "b": 2}
-        data2 = {"b": 2, "a": 1}
-        assert ScoreCache.compute_hash(data1) == ScoreCache.compute_hash(data2)
-    
-    def test_hash_length(self):
-        """Hash should be 16 characters."""
-        data = {"test": "data"}
-        hash_val = ScoreCache.compute_hash(data)
-        assert len(hash_val) == 16
-    
-    def test_hash_is_hex(self):
-        """Hash should be hexadecimal."""
-        data = {"test": "data"}
-        hash_val = ScoreCache.compute_hash(data)
-        int(hash_val, 16)  # Should not raise
-
-
-class TestScoreCacheGetSet:
-    """Tests for ScoreCache get and set methods."""
-    
-    @pytest.fixture
-    def cache(self, tmp_path):
-        """Create a cache instance for testing."""
-        return ScoreCache(cache_dir=tmp_path)
-    
-    @pytest.fixture
-    def sample_cve_data(self):
-        """Sample CVE data for testing."""
-        return {
-            "cveMetadata": {"cveId": "CVE-2024-0001"},
-            "containers": {"cna": {"descriptions": [{"value": "test"}]}}
-        }
-    
-    @pytest.fixture
-    def sample_score(self):
-        """Sample score data for testing."""
-        return {
-            "cveId": "CVE-2024-0001",
-            "totalScore": 75,
-            "scoreBreakdown": {"foundational": 40, "rootCause": 10}
-        }
-    
-    def test_set_and_get(self, cache, sample_cve_data, sample_score):
-        """Should store and retrieve scores."""
-        cve_id = "CVE-2024-0001"
-        cache.set(cve_id, sample_cve_data, sample_score)
-        
-        retrieved = cache.get(cve_id, sample_cve_data)
-        assert retrieved == sample_score
-    
-    def test_get_miss(self, cache, sample_cve_data):
-        """Should return None for cache miss."""
-        result = cache.get("CVE-2024-9999", sample_cve_data)
-        assert result is None
-    
-    def test_get_stale_cache(self, cache, sample_cve_data, sample_score):
-        """Should return None if CVE data changed."""
-        cve_id = "CVE-2024-0001"
-        cache.set(cve_id, sample_cve_data, sample_score)
-        
-        # Modify the CVE data
-        modified_data = sample_cve_data.copy()
-        modified_data["containers"] = {"cna": {"descriptions": [{"value": "modified"}]}}
-        
-        # Should return None because hash doesn't match
-        result = cache.get(cve_id, modified_data)
-        assert result is None
-    
-    def test_cache_persists_to_disk(self, tmp_path, sample_cve_data, sample_score):
-        """Cache should persist to disk."""
-        cve_id = "CVE-2024-0001"
-        
-        # Create cache and set value
-        cache1 = ScoreCache(cache_dir=tmp_path)
-        cache1.set(cve_id, sample_cve_data, sample_score)
-        
-        # Create new cache instance (simulating restart)
-        cache2 = ScoreCache(cache_dir=tmp_path)
-        
-        # Should still retrieve from disk
-        retrieved = cache2.get(cve_id, sample_cve_data)
-        assert retrieved == sample_score
-
-
-class TestScoreCacheBatch:
-    """Tests for batch cache operations."""
-    
-    @pytest.fixture
-    def cache(self, tmp_path):
-        """Create a cache instance for testing."""
-        return ScoreCache(cache_dir=tmp_path)
-    
-    @pytest.fixture
-    def sample_cve_records(self):
-        """Sample CVE records for batch testing."""
-        return [
-            {"cveMetadata": {"cveId": "CVE-2024-0001"}, "data": "cve1"},
-            {"cveMetadata": {"cveId": "CVE-2024-0002"}, "data": "cve2"},
-            {"cveMetadata": {"cveId": "CVE-2024-0003"}, "data": "cve3"}
-        ]
-    
-    def test_get_batch_all_misses(self, cache, sample_cve_records):
-        """Should return all as misses when cache is empty."""
-        cached, uncached = cache.get_batch(sample_cve_records)
-        
-        assert len(cached) == 0
-        assert len(uncached) == 3
-    
-    def test_get_batch_partial_hits(self, cache, sample_cve_records):
-        """Should return mix of hits and misses."""
-        # Cache first CVE
-        cache.set("CVE-2024-0001", sample_cve_records[0], {"score": 50})
-        
-        cached, uncached = cache.get_batch(sample_cve_records)
-        
-        assert len(cached) == 1
-        assert "CVE-2024-0001" in cached
-        assert len(uncached) == 2
-    
-    def test_get_batch_handles_missing_cve_id(self, cache):
-        """Should handle records without CVE ID."""
-        records = [
-            {"data": "no_cve_id"},
-            {"cveMetadata": {"cveId": "CVE-2024-0001"}, "data": "has_id"}
-        ]
-        
-        cached, uncached = cache.get_batch(records)
-        
-        assert len(uncached) == 2  # Both should be uncached
-    
-    def test_set_batch(self, cache, sample_cve_records):
-        """Should cache multiple scores."""
-        scores = [
-            {"cveId": "CVE-2024-0001", "score": 50},
-            {"cveId": "CVE-2024-0002", "score": 60}
-        ]
-        cve_lookup = {
-            "CVE-2024-0001": sample_cve_records[0],
-            "CVE-2024-0002": sample_cve_records[1]
-        }
-        
-        cache.set_batch(scores, cve_lookup)
-        
-        # Verify both were cached
-        assert cache.get("CVE-2024-0001", sample_cve_records[0]) == scores[0]
-        assert cache.get("CVE-2024-0002", sample_cve_records[1]) == scores[1]
-
-
-class TestScoreCacheClear:
-    """Tests for cache clearing."""
-    
-    @pytest.fixture
-    def cache(self, tmp_path):
-        """Create a cache instance for testing."""
-        return ScoreCache(cache_dir=tmp_path)
-    
-    def test_clear_all(self, cache):
-        """Should clear all cache entries."""
-        # Add some entries
-        cache.set("CVE-2024-0001", {"data": "1"}, {"score": 50})
-        cache.set("CVE-2024-0002", {"data": "2"}, {"score": 60})
-        
-        cleared = cache.clear()
-        
-        assert cleared == 2
-        assert cache.get("CVE-2024-0001", {"data": "1"}) is None
-        assert cache.get("CVE-2024-0002", {"data": "2"}) is None
-    
-    def test_clear_empty_cache(self, cache):
-        """Should handle clearing empty cache."""
-        cleared = cache.clear()
-        assert cleared == 0
-
-
-class TestScoreCacheStats:
-    """Tests for cache statistics."""
-    
-    @pytest.fixture
-    def cache(self, tmp_path):
-        """Create a cache instance for testing."""
-        return ScoreCache(cache_dir=tmp_path)
-    
-    def test_initial_stats(self, cache):
-        """Should start with zero stats."""
-        stats = cache.stats()
-        
-        assert stats["hits"] == 0
-        assert stats["misses"] == 0
-        assert stats["hit_rate"] == "0.0%"
-        assert stats["memory_entries"] == 0
-    
-    def test_stats_after_operations(self, cache):
-        """Should track hits and misses."""
-        cve_data = {"data": "test"}
-        
-        # Miss (first access)
-        cache.get("CVE-2024-0001", cve_data)
-        
-        # Set the value
-        cache.set("CVE-2024-0001", cve_data, {"score": 50})
-        
-        # Hit (cached access)
-        cache.get("CVE-2024-0001", cve_data)
-        
-        stats = cache.stats()
-        assert stats["hits"] == 1
-        assert stats["misses"] == 1
-        assert stats["hit_rate"] == "50.0%"
-        assert stats["memory_entries"] == 1
-    
-    def test_repr(self, cache):
-        """Should have useful repr."""
-        repr_str = repr(cache)
-        assert "ScoreCache" in repr_str
-        assert "hits=" in repr_str
-        assert "misses=" in repr_str
-
-
-class TestScoreCachePath:
-    """Tests for cache path organization."""
-    
-    @pytest.fixture
-    def cache(self, tmp_path):
-        """Create a cache instance for testing."""
-        return ScoreCache(cache_dir=tmp_path)
-    
-    def test_organizes_by_year(self, cache, tmp_path):
-        """Should organize cache files by year."""
-        cache.set("CVE-2024-0001", {"data": "1"}, {"score": 50})
-        cache.set("CVE-2023-0001", {"data": "2"}, {"score": 60})
-        
-        # Check directory structure
-        assert (tmp_path / "2024" / "CVE-2024-0001.json").exists()
-        assert (tmp_path / "2023" / "CVE-2023-0001.json").exists()
-
-
-class TestGlobalCache:
-    """Tests for global cache functions."""
-    
-    def test_get_cache_returns_instance(self, tmp_path, monkeypatch):
-        """get_cache should return a ScoreCache instance."""
-        # Clear any existing global cache
-        reset_cache()
-        
-        cache = get_cache(cache_dir=tmp_path)
-        assert isinstance(cache, ScoreCache)
-    
-    def test_get_cache_returns_same_instance(self, tmp_path):
-        """get_cache should return same instance on subsequent calls."""
-        reset_cache()
-        
-        cache1 = get_cache(cache_dir=tmp_path)
-        cache2 = get_cache(cache_dir=tmp_path)
-        
-        assert cache1 is cache2
-    
-    def test_reset_cache(self, tmp_path):
-        """reset_cache should reset the global instance."""
-        reset_cache()
-        cache1 = get_cache(cache_dir=tmp_path)
-        
-        reset_cache()
-        cache2 = get_cache(cache_dir=tmp_path)
-        
-        # Should be different instances after reset
-        assert cache1 is not cache2
diff --git a/src/cvedb/cna/tests/test_chunking.py b/src/cvedb/cna/tests/test_chunking.py
deleted file mode 100644
index b8fa0de5bac..00000000000
--- a/src/cvedb/cna/tests/test_chunking.py
+++ /dev/null
@@ -1,323 +0,0 @@
-"""
-Tests for chunking.py - Data chunking for web lazy loading.
-"""
-import json
-import pytest
-from pathlib import Path
-from unittest.mock import patch, MagicMock
-
-from chunking import (
-    write_chunked_cna_data,
-    write_chunked_completeness_data,
-    generate_search_index,
-    generate_summary_stats,
-    cleanup_old_chunks,
-    _get_timestamp,
-    _grade_sort_key
-)
-
-
-class TestWriteChunkedCNAData:
-    """Tests for write_chunked_cna_data function."""
-    
-    @pytest.fixture
-    def sample_cna_list(self):
-        """Sample CNA data for testing."""
-        return [
-            {"shortName": f"CNA_{i}", "cnaId": f"id_{i}", "grade": "A" if i % 2 == 0 else "B"}
-            for i in range(125)
-        ]
-    
-    def test_creates_chunks(self, sample_cna_list, tmp_path):
-        """Should create chunk files."""
-        manifest = write_chunked_cna_data(sample_cna_list, tmp_path, chunk_size=50)
-        
-        chunks_dir = tmp_path / "chunks"
-        assert chunks_dir.exists()
-        assert (chunks_dir / "manifest.json").exists()
-        
-        # 125 items / 50 per chunk = 3 chunks
-        assert manifest["totalChunks"] == 3
-        assert manifest["totalCNAs"] == 125
-        assert manifest["chunkSize"] == 50
-    
-    def test_chunk_file_contents(self, sample_cna_list, tmp_path):
-        """Chunk files should contain correct data."""
-        write_chunked_cna_data(sample_cna_list, tmp_path, chunk_size=50)
-        
-        # Check first chunk
-        chunk_0_path = tmp_path / "chunks" / "cna_chunk_0.json"
-        with open(chunk_0_path) as f:
-            chunk_0 = json.load(f)
-        
-        assert chunk_0["chunkIndex"] == 0
-        assert chunk_0["startIndex"] == 0
-        assert chunk_0["endIndex"] == 50
-        assert chunk_0["count"] == 50
-        assert len(chunk_0["items"]) == 50
-    
-    def test_last_chunk_partial(self, sample_cna_list, tmp_path):
-        """Last chunk should have remaining items."""
-        write_chunked_cna_data(sample_cna_list, tmp_path, chunk_size=50)
-        
-        # Last chunk has 125 - 100 = 25 items
-        chunk_2_path = tmp_path / "chunks" / "cna_chunk_2.json"
-        with open(chunk_2_path) as f:
-            chunk_2 = json.load(f)
-        
-        assert chunk_2["count"] == 25
-        assert len(chunk_2["items"]) == 25
-    
-    def test_manifest_lists_all_chunks(self, sample_cna_list, tmp_path):
-        """Manifest should list all chunk files."""
-        manifest = write_chunked_cna_data(sample_cna_list, tmp_path, chunk_size=50)
-        
-        assert len(manifest["chunks"]) == 3
-        assert "cna_chunk_0.json" in manifest["chunks"]
-        assert "cna_chunk_1.json" in manifest["chunks"]
-        assert "cna_chunk_2.json" in manifest["chunks"]
-    
-    def test_empty_list(self, tmp_path):
-        """Should handle empty CNA list."""
-        manifest = write_chunked_cna_data([], tmp_path, chunk_size=50)
-        
-        assert manifest["totalCNAs"] == 0
-        assert manifest["totalChunks"] == 0
-        assert manifest["chunks"] == []
-    
-    def test_small_list_single_chunk(self, tmp_path):
-        """List smaller than chunk_size should create one chunk."""
-        small_list = [{"shortName": f"CNA_{i}"} for i in range(10)]
-        manifest = write_chunked_cna_data(small_list, tmp_path, chunk_size=50)
-        
-        assert manifest["totalChunks"] == 1
-        assert manifest["totalCNAs"] == 10
-    
-    def test_custom_chunk_size(self, sample_cna_list, tmp_path):
-        """Should respect custom chunk size."""
-        manifest = write_chunked_cna_data(sample_cna_list, tmp_path, chunk_size=25)
-        
-        # 125 / 25 = 5 chunks
-        assert manifest["totalChunks"] == 5
-        assert manifest["chunkSize"] == 25
-
-
-class TestWriteChunkedCompletenessData:
-    """Tests for write_chunked_completeness_data function."""
-    
-    @pytest.fixture
-    def sample_completeness_list(self):
-        """Sample completeness data for testing."""
-        return [
-            {"cnaName": f"CNA_{i}", "completeness": 75.0 + i}
-            for i in range(150)
-        ]
-    
-    def test_creates_completeness_chunks(self, sample_completeness_list, tmp_path):
-        """Should create completeness chunk files."""
-        manifest = write_chunked_completeness_data(sample_completeness_list, tmp_path, chunk_size=100)
-        
-        chunks_dir = tmp_path / "completeness" / "chunks"
-        assert chunks_dir.exists()
-        assert (chunks_dir / "manifest.json").exists()
-        
-        # 150 / 100 = 2 chunks
-        assert manifest["totalChunks"] == 2
-        assert manifest["totalItems"] == 150
-    
-    def test_completeness_chunk_files_created(self, sample_completeness_list, tmp_path):
-        """Should create properly named chunk files."""
-        write_chunked_completeness_data(sample_completeness_list, tmp_path, chunk_size=100)
-        
-        chunks_dir = tmp_path / "completeness" / "chunks"
-        assert (chunks_dir / "completeness_chunk_0.json").exists()
-        assert (chunks_dir / "completeness_chunk_1.json").exists()
-
-
-class TestGenerateSearchIndex:
-    """Tests for generate_search_index function."""
-    
-    @pytest.fixture
-    def sample_cna_list(self):
-        """Sample CNA data for search index."""
-        return [
-            {"shortName": "Microsoft", "cnaId": "msft-001", "type": "Vendor", "grade": "A", "country": "US"},
-            {"shortName": "Google", "cnaId": "goog-001", "type": "Vendor", "grade": "B", "country": "US"},
-            {"shortName": "RedHat", "cnaId": "rh-001", "type": "Vendor", "grade": "A", "country": "US"},
-            {"shortName": "CERT/CC", "cnaId": "cert-001", "type": "Coordinator", "grade": "A", "country": "US"}
-        ]
-    
-    def test_creates_search_index(self, sample_cna_list, tmp_path):
-        """Should create search index file."""
-        search_index = generate_search_index(sample_cna_list, tmp_path)
-        
-        assert (tmp_path / "search_index.json").exists()
-        assert search_index["totalCNAs"] == 4
-    
-    def test_extracts_cna_names(self, sample_cna_list, tmp_path):
-        """Should extract CNA names."""
-        search_index = generate_search_index(sample_cna_list, tmp_path)
-        
-        assert "Microsoft" in search_index["cnaNames"]
-        assert "Google" in search_index["cnaNames"]
-        assert len(search_index["cnaNames"]) == 4
-    
-    def test_extracts_cna_ids(self, sample_cna_list, tmp_path):
-        """Should extract CNA IDs."""
-        search_index = generate_search_index(sample_cna_list, tmp_path)
-        
-        assert "msft-001" in search_index["cnaIds"]
-        assert len(search_index["cnaIds"]) == 4
-    
-    def test_extracts_unique_types(self, sample_cna_list, tmp_path):
-        """Should extract unique CNA types."""
-        search_index = generate_search_index(sample_cna_list, tmp_path)
-        
-        assert "Vendor" in search_index["types"]
-        assert "Coordinator" in search_index["types"]
-        assert len(search_index["types"]) == 2
-    
-    def test_extracts_unique_grades(self, sample_cna_list, tmp_path):
-        """Should extract unique grades sorted properly."""
-        search_index = generate_search_index(sample_cna_list, tmp_path)
-        
-        assert "A" in search_index["grades"]
-        assert "B" in search_index["grades"]
-        # Grades should be sorted A, B
-        assert search_index["grades"] == ["A", "B"]
-    
-    def test_extracts_unique_countries(self, sample_cna_list, tmp_path):
-        """Should extract unique countries."""
-        search_index = generate_search_index(sample_cna_list, tmp_path)
-        
-        assert "US" in search_index["countries"]
-    
-    def test_handles_missing_fields(self, tmp_path):
-        """Should handle CNAs with missing fields."""
-        cna_list = [
-            {"shortName": "CNA1"},  # Missing most fields
-            {"cnaId": "id-only"}    # Missing shortName
-        ]
-        search_index = generate_search_index(cna_list, tmp_path)
-        
-        assert "CNA1" in search_index["cnaNames"]
-        assert "id-only" in search_index["cnaIds"]
-        assert search_index["totalCNAs"] == 2
-
-
-class TestGenerateSummaryStats:
-    """Tests for generate_summary_stats function."""
-    
-    @pytest.fixture
-    def sample_cna_list(self):
-        """Sample CNA data for summary stats."""
-        return [
-            {"shortName": "CNA1", "cveCount": 100, "overallScore": 85, "grade": "A", "type": "Vendor", "trend": "up"},
-            {"shortName": "CNA2", "cveCount": 50, "overallScore": 75, "grade": "B", "type": "Vendor", "trend": "steady"},
-            {"shortName": "CNA3", "cveCount": 25, "overallScore": 60, "grade": "C", "type": "Coordinator", "trend": "down"}
-        ]
-    
-    def test_creates_summary_stats(self, sample_cna_list, tmp_path):
-        """Should create summary stats file."""
-        stats = generate_summary_stats(sample_cna_list, tmp_path)
-        
-        assert (tmp_path / "summary_stats.json").exists()
-    
-    def test_total_cnas(self, sample_cna_list, tmp_path):
-        """Should count total CNAs."""
-        stats = generate_summary_stats(sample_cna_list, tmp_path)
-        assert stats["totalCNAs"] == 3
-    
-    def test_total_cves(self, sample_cna_list, tmp_path):
-        """Should sum total CVEs."""
-        stats = generate_summary_stats(sample_cna_list, tmp_path)
-        assert stats["totalCVEs"] == 175  # 100 + 50 + 25
-    
-    def test_average_score(self, sample_cna_list, tmp_path):
-        """Should calculate average score."""
-        stats = generate_summary_stats(sample_cna_list, tmp_path)
-        # (85 + 75 + 60) / 3 = 73.33...
-        assert stats["averageScore"] == 73.3
-    
-    def test_grade_distribution(self, sample_cna_list, tmp_path):
-        """Should count grades."""
-        stats = generate_summary_stats(sample_cna_list, tmp_path)
-        
-        assert stats["gradeDistribution"]["A"] == 1
-        assert stats["gradeDistribution"]["B"] == 1
-        assert stats["gradeDistribution"]["C"] == 1
-        assert stats["gradeDistribution"]["D"] == 0
-        assert stats["gradeDistribution"]["F"] == 0
-    
-    def test_type_distribution(self, sample_cna_list, tmp_path):
-        """Should count types."""
-        stats = generate_summary_stats(sample_cna_list, tmp_path)
-        
-        assert stats["typeDistribution"]["Vendor"] == 2
-        assert stats["typeDistribution"]["Coordinator"] == 1
-    
-    def test_trend_distribution(self, sample_cna_list, tmp_path):
-        """Should count trends."""
-        stats = generate_summary_stats(sample_cna_list, tmp_path)
-        
-        assert stats["trendDistribution"]["up"] == 1
-        assert stats["trendDistribution"]["steady"] == 1
-        assert stats["trendDistribution"]["down"] == 1
-
-
-class TestCleanupOldChunks:
-    """Tests for cleanup_old_chunks function."""
-    
-    def test_removes_chunk_files(self, tmp_path):
-        """Should remove chunk files."""
-        chunks_dir = tmp_path / "chunks"
-        chunks_dir.mkdir()
-        
-        # Create some chunk files
-        (chunks_dir / "cna_chunk_0.json").write_text("{}")
-        (chunks_dir / "cna_chunk_1.json").write_text("{}")
-        (chunks_dir / "completeness_chunk_0.json").write_text("{}")
-        
-        removed = cleanup_old_chunks(chunks_dir)
-        
-        assert removed == 3
-        assert not (chunks_dir / "cna_chunk_0.json").exists()
-    
-    def test_nonexistent_directory(self, tmp_path):
-        """Should handle non-existent directory."""
-        removed = cleanup_old_chunks(tmp_path / "nonexistent")
-        assert removed == 0
-    
-    def test_empty_directory(self, tmp_path):
-        """Should handle empty directory."""
-        chunks_dir = tmp_path / "chunks"
-        chunks_dir.mkdir()
-        
-        removed = cleanup_old_chunks(chunks_dir)
-        assert removed == 0
-
-
-class TestHelperFunctions:
-    """Tests for helper functions."""
-    
-    def test_get_timestamp_format(self):
-        """Should return ISO format timestamp."""
-        timestamp = _get_timestamp()
-        
-        # Should match format like 2024-01-15T10:30:00Z
-        assert "T" in timestamp
-        assert timestamp.endswith("Z")
-        assert len(timestamp) == 20
-    
-    def test_grade_sort_key_order(self):
-        """Should return correct sort order for grades."""
-        assert _grade_sort_key("A") == 0
-        assert _grade_sort_key("B") == 1
-        assert _grade_sort_key("C") == 2
-        assert _grade_sort_key("D") == 3
-        assert _grade_sort_key("F") == 4
-    
-    def test_grade_sort_key_unknown(self):
-        """Should handle unknown grades."""
-        assert _grade_sort_key("X") == 5
-        assert _grade_sort_key("") == 5
diff --git a/src/cvedb/cna/tests/test_completeness.py b/src/cvedb/cna/tests/test_completeness.py
deleted file mode 100644
index 844726c8dad..00000000000
--- a/src/cvedb/cna/tests/test_completeness.py
+++ /dev/null
@@ -1,493 +0,0 @@
-"""
-Tests for completeness.py - Field utilization and completeness analysis.
-"""
-import pytest
-from completeness import (
-    _get_schema_fields,
-    _get_nested_value,
-    _custom_check,
-    compute_field_utilization,
-    compute_individual_cna_field_utilization
-)
-
-
-class TestGetSchemaFields:
-    """Tests for _get_schema_fields function."""
-    
-    def test_returns_dict(self):
-        """Should return a dictionary of field definitions."""
-        fields = _get_schema_fields()
-        assert isinstance(fields, dict)
-    
-    def test_contains_expected_fields(self):
-        """Should contain key CVE schema fields."""
-        fields = _get_schema_fields()
-        expected_fields = [
-            "dataType",
-            "dataVersion", 
-            "cveMetadata.cveId",
-            "containers.cna.descriptions",
-            "containers.cna.affected",
-            "containers.cna.references",
-            "containers.cna.metrics"
-        ]
-        for field in expected_fields:
-            assert field in fields
-    
-    def test_field_has_path(self):
-        """Each field should have a path key."""
-        fields = _get_schema_fields()
-        for name, info in fields.items():
-            assert "path" in info, f"Field {name} missing 'path'"
-            assert isinstance(info["path"], list)
-
-
-class TestGetNestedValue:
-    """Tests for _get_nested_value function."""
-    
-    def test_simple_path(self):
-        """Should retrieve value at simple path."""
-        data = {"key": "value"}
-        assert _get_nested_value(data, ["key"]) == "value"
-    
-    def test_nested_path(self):
-        """Should retrieve value at nested path."""
-        data = {"level1": {"level2": {"level3": "deep_value"}}}
-        assert _get_nested_value(data, ["level1", "level2", "level3"]) == "deep_value"
-    
-    def test_missing_key_returns_none(self):
-        """Should return None if key is missing."""
-        data = {"key": "value"}
-        assert _get_nested_value(data, ["missing"]) is None
-    
-    def test_missing_nested_key_returns_none(self):
-        """Should return None if nested key is missing."""
-        data = {"level1": {"level2": "value"}}
-        assert _get_nested_value(data, ["level1", "missing", "key"]) is None
-    
-    def test_empty_path(self):
-        """Should return the data itself for empty path."""
-        data = {"key": "value"}
-        assert _get_nested_value(data, []) == data
-    
-    def test_cve_metadata_path(self):
-        """Should work with CVE metadata paths."""
-        cve = {
-            "cveMetadata": {
-                "cveId": "CVE-2024-1234",
-                "assignerOrgId": "org-123"
-            }
-        }
-        assert _get_nested_value(cve, ["cveMetadata", "cveId"]) == "CVE-2024-1234"
-
-
-class TestCustomCheckDescriptions:
-    """Tests for _custom_check with description checks."""
-    
-    def test_english_description_present(self):
-        """Should detect English description."""
-        data = [{"lang": "en", "value": "A vulnerability..."}]
-        assert _custom_check(data, "english_description") is True
-    
-    def test_english_description_us_variant(self):
-        """Should detect en-US as English."""
-        data = [{"lang": "en-US", "value": "A vulnerability..."}]
-        assert _custom_check(data, "english_description") is True
-    
-    def test_english_description_missing(self):
-        """Should return False when no English description."""
-        data = [{"lang": "es", "value": "Una vulnerabilidad..."}]
-        assert _custom_check(data, "english_description") is False
-    
-    def test_multiple_languages_true(self):
-        """Should detect multiple languages."""
-        data = [
-            {"lang": "en", "value": "English"},
-            {"lang": "es", "value": "Spanish"}
-        ]
-        assert _custom_check(data, "multiple_languages") is True
-    
-    def test_multiple_languages_false(self):
-        """Should return False for single language."""
-        data = [{"lang": "en", "value": "English only"}]
-        assert _custom_check(data, "multiple_languages") is False
-    
-    def test_supporting_media_present(self):
-        """Should detect supporting media."""
-        data = [{"lang": "en", "value": "text", "media": "image/png"}]
-        assert _custom_check(data, "supporting_media") is True
-    
-    def test_supporting_media_missing(self):
-        """Should return False when no media."""
-        data = [{"lang": "en", "value": "text only"}]
-        assert _custom_check(data, "supporting_media") is False
-
-
-class TestCustomCheckAffected:
-    """Tests for _custom_check with affected product checks."""
-    
-    def test_has_vendor(self):
-        """Should detect vendor field."""
-        data = [{"vendor": "Microsoft", "product": "Windows"}]
-        assert _custom_check(data, "has_vendor") is True
-    
-    def test_has_vendor_missing(self):
-        """Should return False when no vendor."""
-        data = [{"product": "Unknown"}]
-        assert _custom_check(data, "has_vendor") is False
-    
-    def test_has_product(self):
-        """Should detect product field."""
-        data = [{"product": "Firefox"}]
-        assert _custom_check(data, "has_product") is True
-    
-    def test_has_versions(self):
-        """Should detect versions field."""
-        data = [{"product": "Chrome", "versions": [{"version": "1.0"}]}]
-        assert _custom_check(data, "has_versions") is True
-    
-    def test_has_versions_empty(self):
-        """Should return False for empty versions."""
-        data = [{"product": "Chrome", "versions": []}]
-        assert _custom_check(data, "has_versions") is False
-    
-    def test_has_default_status(self):
-        """Should detect defaultStatus field."""
-        data = [{"defaultStatus": "affected"}]
-        assert _custom_check(data, "has_default_status") is True
-    
-    def test_has_cpes(self):
-        """Should detect CPEs."""
-        data = [{"cpes": ["cpe:2.3:a:vendor:product:*"]}]
-        assert _custom_check(data, "has_cpes") is True
-    
-    def test_has_modules(self):
-        """Should detect modules."""
-        data = [{"modules": ["core", "auth"]}]
-        assert _custom_check(data, "has_modules") is True
-    
-    def test_has_program_files(self):
-        """Should detect programFiles."""
-        data = [{"programFiles": ["/usr/bin/app"]}]
-        assert _custom_check(data, "has_program_files") is True
-    
-    def test_has_program_routines(self):
-        """Should detect programRoutines."""
-        data = [{"programRoutines": [{"name": "main"}]}]
-        assert _custom_check(data, "has_program_routines") is True
-    
-    def test_has_platforms(self):
-        """Should detect platforms."""
-        data = [{"platforms": ["Windows", "Linux"]}]
-        assert _custom_check(data, "has_platforms") is True
-    
-    def test_has_repo(self):
-        """Should detect repo."""
-        data = [{"repo": "https://github.com/example/repo"}]
-        assert _custom_check(data, "has_repo") is True
-
-
-class TestCustomCheckProblemTypes:
-    """Tests for _custom_check with problemTypes checks."""
-    
-    def test_has_cwe_explicit(self):
-        """Should detect explicit CWE ID."""
-        data = [{"descriptions": [{"cweId": "CWE-79", "description": "XSS"}]}]
-        assert _custom_check(data, "has_cwe") is True
-    
-    def test_has_cwe_in_description(self):
-        """Should detect CWE ID in description text."""
-        data = [{"descriptions": [{"description": "CWE-79: Cross-site scripting"}]}]
-        assert _custom_check(data, "has_cwe") is True
-    
-    def test_has_cwe_missing(self):
-        """Should return False when no CWE."""
-        data = [{"descriptions": [{"description": "Generic vulnerability"}]}]
-        assert _custom_check(data, "has_cwe") is False
-    
-    def test_has_type(self):
-        """Should detect type field."""
-        data = [{"type": "primary"}]
-        assert _custom_check(data, "has_type") is True
-    
-    def test_has_pt_references(self):
-        """Should detect references in problemTypes."""
-        data = [{"references": [{"url": "https://example.com"}]}]
-        assert _custom_check(data, "has_pt_references") is True
-
-
-class TestCustomCheckReferences:
-    """Tests for _custom_check with reference checks."""
-    
-    def test_has_advisory_ref(self):
-        """Should detect advisory reference."""
-        data = [{"url": "https://example.com", "tags": ["vendor-advisory"]}]
-        assert _custom_check(data, "has_advisory_ref") is True
-    
-    def test_has_patch_ref(self):
-        """Should detect patch reference."""
-        data = [{"url": "https://example.com", "tags": ["patch"]}]
-        assert _custom_check(data, "has_patch_ref") is True
-    
-    def test_has_exploit_ref(self):
-        """Should detect exploit reference."""
-        data = [{"url": "https://example.com", "tags": ["exploit"]}]
-        assert _custom_check(data, "has_exploit_ref") is True
-    
-    def test_has_technical_ref(self):
-        """Should detect technical reference."""
-        data = [{"url": "https://example.com", "tags": ["technical-description"]}]
-        assert _custom_check(data, "has_technical_ref") is True
-    
-    def test_has_vendor_ref(self):
-        """Should detect vendor reference."""
-        data = [{"url": "https://example.com", "tags": ["vendor-advisory"]}]
-        assert _custom_check(data, "has_vendor_ref") is True
-    
-    def test_has_named_ref(self):
-        """Should detect named reference."""
-        data = [{"url": "https://example.com", "name": "Security Advisory SA-2024-001"}]
-        assert _custom_check(data, "has_named_ref") is True
-    
-    def test_reference_no_tags(self):
-        """Should return False when no tags."""
-        data = [{"url": "https://example.com"}]
-        assert _custom_check(data, "has_patch_ref") is False
-
-
-class TestCustomCheckMetrics:
-    """Tests for _custom_check with metrics checks."""
-    
-    def test_has_cvss_v4(self):
-        """Should detect CVSS v4.0."""
-        data = [{"cvssV4_0": {"baseScore": 7.5}}]
-        assert _custom_check(data, "has_cvss_v4") is True
-    
-    def test_has_cvss_v3_1(self):
-        """Should detect CVSS v3.1."""
-        data = [{"cvssV3_1": {"baseScore": 7.5}}]
-        assert _custom_check(data, "has_cvss_v3_1") is True
-    
-    def test_has_cvss_v3_0(self):
-        """Should detect CVSS v3.0."""
-        data = [{"cvssV3_0": {"baseScore": 7.5}}]
-        assert _custom_check(data, "has_cvss_v3_0") is True
-    
-    def test_has_cvss_v2(self):
-        """Should detect CVSS v2.0."""
-        data = [{"cvssV2_0": {"baseScore": 7.5}}]
-        assert _custom_check(data, "has_cvss_v2") is True
-    
-    def test_has_other_metrics(self):
-        """Should detect other metrics (SSVC, KEV, etc)."""
-        data = [{"other": {"type": "ssvc", "content": {}}}]
-        assert _custom_check(data, "has_other_metrics") is True
-    
-    def test_has_scenarios(self):
-        """Should detect scenarios."""
-        data = [{"scenarios": [{"lang": "en", "value": "default"}]}]
-        assert _custom_check(data, "has_scenarios") is True
-
-
-class TestCustomCheckEdgeCases:
-    """Edge case tests for _custom_check."""
-    
-    def test_none_data(self):
-        """Should handle None data."""
-        assert _custom_check(None, "has_vendor") is False
-    
-    def test_empty_list(self):
-        """Should handle empty list."""
-        assert _custom_check([], "has_vendor") is False
-    
-    def test_non_list_data(self):
-        """Should handle non-list data."""
-        assert _custom_check("not a list", "has_vendor") is False
-    
-    def test_unknown_check_type(self):
-        """Should return False for unknown check type."""
-        assert _custom_check([{"data": "value"}], "unknown_check") is False
-    
-    def test_list_with_non_dict_items(self):
-        """Should handle list with non-dict items."""
-        data = [{"vendor": "Microsoft"}, "not a dict", None]
-        assert _custom_check(data, "has_vendor") is True
-
-
-class TestComputeFieldUtilization:
-    """Tests for compute_field_utilization function."""
-    
-    @pytest.fixture
-    def sample_cve_records(self):
-        """Sample CVE records for testing."""
-        return [
-            {
-                "dataType": "CVE_RECORD",
-                "dataVersion": "5.1",
-                "cveMetadata": {
-                    "cveId": "CVE-2024-0001",
-                    "assignerOrgId": "org-1"
-                },
-                "containers": {
-                    "cna": {
-                        "descriptions": [{"lang": "en", "value": "Test"}],
-                        "affected": [{"vendor": "Vendor1", "product": "Product1"}],
-                        "references": [{"url": "https://example.com", "tags": ["patch"]}]
-                    }
-                }
-            },
-            {
-                "dataType": "CVE_RECORD",
-                "dataVersion": "5.1",
-                "cveMetadata": {
-                    "cveId": "CVE-2024-0002",
-                    "assignerOrgId": "org-2"
-                },
-                "containers": {
-                    "cna": {
-                        "descriptions": [{"lang": "en", "value": "Test 2"}],
-                        "affected": [{"vendor": "Vendor2"}]
-                    }
-                }
-            }
-        ]
-    
-    def test_basic_utilization(self, sample_cve_records):
-        """Should compute basic field utilization."""
-        field_list = ["dataType", "containers.cna.descriptions"]
-        result = compute_field_utilization(sample_cve_records, field_list)
-        
-        assert len(result) == 2
-        assert any(f["field"] == "dataType" for f in result)
-        assert any(f["field"] == "containers.cna.descriptions" for f in result)
-    
-    def test_utilization_percentages(self, sample_cve_records):
-        """Should calculate correct percentages."""
-        field_list = ["dataType"]
-        result = compute_field_utilization(sample_cve_records, field_list)
-        
-        data_type_result = next(f for f in result if f["field"] == "dataType")
-        assert data_type_result["cna_percent"] == 100.0
-        assert data_type_result["unique_cnas"] == 2
-    
-    def test_partial_utilization(self, sample_cve_records):
-        """Should handle fields not present in all records."""
-        field_list = ["references.patch"]
-        result = compute_field_utilization(sample_cve_records, field_list)
-        
-        patch_result = next(f for f in result if f["field"] == "references.patch")
-        # Only org-1 has patch references
-        assert patch_result["cna_percent"] == 50.0
-        assert patch_result["unique_cnas"] == 1
-    
-    def test_empty_records(self):
-        """Should handle empty record list."""
-        result = compute_field_utilization([], ["dataType"])
-        assert len(result) == 1
-        assert result[0]["cna_percent"] == 0
-        assert result[0]["unique_cnas"] == 0
-    
-    def test_unknown_field(self, sample_cve_records):
-        """Should handle unknown fields gracefully."""
-        field_list = ["unknown.field", "dataType"]
-        result = compute_field_utilization(sample_cve_records, field_list)
-        # Should still return results, unknown field just won't match
-        assert len(result) == 2
-    
-    def test_sorted_by_percent(self, sample_cve_records):
-        """Results should be sorted by percent descending."""
-        field_list = ["dataType", "references.patch"]
-        result = compute_field_utilization(sample_cve_records, field_list)
-        
-        # dataType (100%) should come before references.patch (50%)
-        assert result[0]["cna_percent"] >= result[1]["cna_percent"]
-
-
-class TestComputeIndividualCNAFieldUtilization:
-    """Tests for compute_individual_cna_field_utilization function."""
-    
-    @pytest.fixture
-    def sample_cve_records_with_shortname(self):
-        """Sample CVE records with providerMetadata shortName."""
-        return [
-            {
-                "cveMetadata": {"cveId": "CVE-2024-0001"},
-                "containers": {
-                    "cna": {
-                        "providerMetadata": {"shortName": "TestCNA"},
-                        "descriptions": [{"lang": "en", "value": "Test"}],
-                        "affected": [{"vendor": "V1", "product": "P1"}]
-                    }
-                }
-            },
-            {
-                "cveMetadata": {"cveId": "CVE-2024-0002"},
-                "containers": {
-                    "cna": {
-                        "providerMetadata": {"shortName": "TestCNA"},
-                        "descriptions": [{"lang": "en", "value": "Test 2"}]
-                    }
-                }
-            },
-            {
-                "cveMetadata": {"cveId": "CVE-2024-0003"},
-                "containers": {
-                    "cna": {
-                        "providerMetadata": {"shortName": "OtherCNA"},
-                        "descriptions": [{"lang": "en", "value": "Other"}],
-                        "affected": [{"vendor": "V2"}]
-                    }
-                }
-            }
-        ]
-    
-    def test_basic_individual_utilization(self, sample_cve_records_with_shortname):
-        """Should compute utilization per CNA."""
-        field_list = ["descriptions.english", "affected.vendor"]
-        result = compute_individual_cna_field_utilization(
-            sample_cve_records_with_shortname, field_list
-        )
-        
-        assert "TestCNA" in result
-        assert "OtherCNA" in result
-    
-    def test_utilization_per_cna(self, sample_cve_records_with_shortname):
-        """Should track field usage per CNA correctly."""
-        field_list = ["affected.vendor"]
-        result = compute_individual_cna_field_utilization(
-            sample_cve_records_with_shortname, field_list
-        )
-        
-        # TestCNA: 1/2 CVEs have affected.vendor = 50%
-        test_cna = result["TestCNA"]
-        vendor_field = next(f for f in test_cna if f["field"] == "affected.vendor")
-        assert vendor_field["percent"] == 50.0
-        assert vendor_field["cve_count"] == 1
-        assert vendor_field["total_cves"] == 2
-        
-        # OtherCNA: 1/1 CVEs have affected.vendor = 100%
-        other_cna = result["OtherCNA"]
-        vendor_field = next(f for f in other_cna if f["field"] == "affected.vendor")
-        assert vendor_field["percent"] == 100.0
-        assert vendor_field["cve_count"] == 1
-        assert vendor_field["total_cves"] == 1
-    
-    def test_empty_records(self):
-        """Should handle empty record list."""
-        result = compute_individual_cna_field_utilization([], ["dataType"])
-        assert result == {}
-    
-    def test_records_without_shortname(self):
-        """Should skip records without shortName."""
-        records = [
-            {
-                "cveMetadata": {"cveId": "CVE-2024-0001"},
-                "containers": {
-                    "cna": {
-                        "descriptions": [{"lang": "en", "value": "No shortName"}]
-                    }
-                }
-            }
-        ]
-        result = compute_individual_cna_field_utilization(records, ["dataType"])
-        assert result == {}
diff --git a/src/cvedb/cna/tests/test_ingest.py b/src/cvedb/cna/tests/test_ingest.py
deleted file mode 100644
index e87da55fe6c..00000000000
--- a/src/cvedb/cna/tests/test_ingest.py
+++ /dev/null
@@ -1,597 +0,0 @@
-"""
-Unit tests for ingest module.
-
-This module tests the CVE data loading and CNA extraction functionality
-to ensure correct data ingestion from the filesystem.
-"""
-import pytest
-from unittest.mock import patch, MagicMock, mock_open
-from pathlib import Path
-from datetime import datetime
-from typing import Dict, Any, List
-
-# Import the module under test
-import sys
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from ingest import (
-    load_cve_records,
-    load_cna_list,
-    get_date_range_for_period,
-    validate_date_range,
-    _get_cve_file_list,
-    _get_year_directories,
-    _get_year_files,
-    _load_and_filter_cves,
-    _load_single_cve_file,
-    _passes_date_filter
-)
-
-
-class TestIngestFixtures:
-    """Test fixtures for ingest tests."""
-    
-    @pytest.fixture
-    def sample_cve_valid(self) -> Dict[str, Any]:
-        """Valid CVE record for testing."""
-        return {
-            "cveId": "CVE-2024-12345",
-            "cveMetadata": {
-                "cveId": "CVE-2024-12345",
-                "datePublished": "2024-01-15T10:00:00.000Z",
-                "state": "PUBLISHED"
-            },
-            "containers": {
-                "cna": {
-                    "providerMetadata": {
-                        "shortName": "TestCNA"
-                    },
-                    "descriptions": [
-                        {
-                            "lang": "en",
-                            "value": "Test vulnerability description"
-                        }
-                    ]
-                }
-            }
-        }
-    
-    @pytest.fixture
-    def sample_cve_rejected(self) -> Dict[str, Any]:
-        """Rejected CVE record for testing."""
-        return {
-            "cveId": "CVE-2024-67890",
-            "cveMetadata": {
-                "cveId": "CVE-2024-67890",
-                "datePublished": "2024-01-15T10:00:00.000Z",
-                "state": "REJECTED"
-            },
-            "containers": {
-                "cna": {
-                    "providerMetadata": {
-                        "shortName": "TestCNA"
-                    }
-                }
-            }
-        }
-    
-    @pytest.fixture
-    def sample_cve_invalid(self) -> Dict[str, Any]:
-        """Invalid CVE record for testing."""
-        return {
-            "invalid": "data",
-            "no_metadata": True
-        }
-    
-    @pytest.fixture
-    def mock_cve_files(self):
-        """Mock CVE file paths."""
-        return [
-            "/path/to/cves/2024/CVE-2024-0001.json",
-            "/path/to/cves/2024/CVE-2024-0002.json",
-            "/path/to/cves/2025/CVE-2025-0001.json"
-        ]
-
-
-class TestLoadCveRecords(TestIngestFixtures):
-    """Test the main load_cve_records function."""
-    
-    @patch('ingest._load_and_filter_cves')
-    @patch('ingest._get_cve_file_list')
-    def test_load_cve_records_basic(
-        self, 
-        mock_get_files, 
-        mock_load_filter,
-        mock_cve_files,
-        sample_cve_valid
-    ):
-        """Test basic CVE record loading."""
-        mock_get_files.return_value = mock_cve_files
-        mock_load_filter.return_value = [sample_cve_valid]
-        
-        result = load_cve_records()
-        
-        assert len(result) == 1
-        assert result[0]["cveId"] == "CVE-2024-12345"
-        mock_get_files.assert_called_once()
-        mock_load_filter.assert_called_once()
-    
-    @patch('ingest._load_and_filter_cves')
-    @patch('ingest._get_cve_file_list')
-    def test_load_cve_records_with_dates(
-        self, 
-        mock_get_files, 
-        mock_load_filter,
-        mock_cve_files,
-        sample_cve_valid
-    ):
-        """Test CVE record loading with date filtering."""
-        mock_get_files.return_value = mock_cve_files
-        mock_load_filter.return_value = [sample_cve_valid]
-        
-        result = load_cve_records(
-            start_date="2024-01-01", 
-            end_date="2024-12-31"
-        )
-        
-        assert len(result) == 1
-        mock_get_files.assert_called_with(
-            str(Path(__file__).parent.parent.parent / "cve_data"),
-            "2024-01-01",
-            "2024-12-31"
-        )
-    
-    @patch('ingest._get_cve_file_list')
-    def test_load_cve_records_no_files(self, mock_get_files):
-        """Test loading when no CVE files found."""
-        mock_get_files.return_value = []
-        
-        result = load_cve_records()
-        
-        assert result == []
-    
-    @patch('ingest._load_and_filter_cves')
-    @patch('ingest._get_cve_file_list')
-    def test_load_cve_records_custom_dir(
-        self, 
-        mock_get_files, 
-        mock_load_filter,
-        sample_cve_valid
-    ):
-        """Test loading from custom directory."""
-        custom_dir = "/custom/cve/path"
-        mock_get_files.return_value = ["/custom/file.json"]
-        mock_load_filter.return_value = [sample_cve_valid]
-        
-        result = load_cve_records(cve_dir=custom_dir)
-        
-        assert len(result) == 1
-        mock_get_files.assert_called_with(custom_dir, None, None)
-
-
-class TestGetCveFileList(TestIngestFixtures):
-    """Test CVE file list generation."""
-    
-    @patch('ingest._get_year_files')
-    @patch('ingest._get_year_directories')
-    @patch('pathlib.Path.exists')
-    def test_get_cve_file_list_with_dates(
-        self, 
-        mock_exists, 
-        mock_year_dirs, 
-        mock_year_files
-    ):
-        """Test file list generation with date filtering."""
-        mock_exists.return_value = True
-        mock_year_dirs.return_value = ['2023', '2024', '2025']
-        mock_year_files.return_value = ['/path/file1.json', '/path/file2.json']
-        
-        result = _get_cve_file_list("/test/dir", "2024-01-01", "2024-12-31")
-        
-        # Should get files from all years when date filtering
-        assert len(result) == 6  # 3 years × 2 files each
-        mock_year_dirs.assert_called_once()
-        assert mock_year_files.call_count == 3
-    
-    @patch('ingest._get_year_files')
-    @patch('pathlib.Path.exists')
-    def test_get_cve_file_list_no_dates(self, mock_exists, mock_year_files):
-        """Test file list generation without date filtering."""
-        mock_exists.return_value = True
-        mock_year_files.return_value = ['/path/file.json']
-        
-        result = _get_cve_file_list("/test/dir", None, None)
-        
-        # Should only check recent years (2024, 2025)
-        assert len(result) == 2  # 2 recent years × 1 file each
-        assert mock_year_files.call_count == 2
-    
-    @patch('pathlib.Path.exists')
-    def test_get_cve_file_list_no_directory(self, mock_exists):
-        """Test file list generation when directory doesn't exist."""
-        mock_exists.return_value = False
-        
-        result = _get_cve_file_list("/nonexistent/dir", None, None)
-        
-        assert result == []
-
-
-class TestGetYearDirectories:
-    """Test year directory listing."""
-    
-    @patch('pathlib.Path.iterdir')
-    def test_get_year_directories_success(self, mock_iterdir):
-        """Test successful year directory listing."""
-        # Create mock directories with proper name attributes
-        mock_2023 = MagicMock()
-        mock_2023.name = '2023'
-        mock_2023.is_dir.return_value = True
-        
-        mock_2024 = MagicMock()
-        mock_2024.name = '2024'
-        mock_2024.is_dir.return_value = True
-        
-        mock_invalid = MagicMock()
-        mock_invalid.name = 'invalid'
-        mock_invalid.is_dir.return_value = True
-        
-        mock_2025 = MagicMock()
-        mock_2025.name = '2025'
-        mock_2025.is_dir.return_value = True
-        
-        mock_file = MagicMock()
-        mock_file.name = 'file.txt'
-        mock_file.is_dir.return_value = False
-        
-        mock_dirs = [mock_2023, mock_2024, mock_invalid, mock_2025, mock_file]
-        mock_iterdir.return_value = mock_dirs
-        
-        result = _get_year_directories(Path("/test"))
-        
-        # Should only return numeric directory names, sorted
-        assert result == ['2023', '2024', '2025']
-    
-    @patch('pathlib.Path.iterdir')
-    def test_get_year_directories_error(self, mock_iterdir):
-        """Test year directory listing with OS error."""
-        mock_iterdir.side_effect = OSError("Permission denied")
-        
-        result = _get_year_directories(Path("/test"))
-        
-        assert result == []
-
-
-class TestGetYearFiles:
-    """Test year file listing."""
-    
-    @patch('ingest.glob')
-    def test_get_year_files_success(self, mock_glob):
-        """Test successful year file listing."""
-        expected_files = ['/path/CVE-2024-0001.json', '/path/CVE-2024-0002.json']
-        mock_glob.return_value = expected_files
-        
-        result = _get_year_files(Path("/cves"), "2024")
-        
-        assert result == expected_files
-        mock_glob.assert_called_once_with('/cves/2024/**/CVE-*.json', recursive=True)
-
-
-class TestLoadAndFilterCves(TestIngestFixtures):
-    """Test CVE loading and filtering."""
-    
-    @patch('ingest._load_single_cve_file')
-    @patch('ingest._passes_date_filter')
-    def test_load_and_filter_cves_success(
-        self, 
-        mock_date_filter, 
-        mock_load_file,
-        sample_cve_valid
-    ):
-        """Test successful CVE loading and filtering."""
-        mock_load_file.return_value = sample_cve_valid
-        mock_date_filter.return_value = True
-        
-        files = ['/path/file1.json', '/path/file2.json']
-        result = _load_and_filter_cves(files, "2024-01-01", "2024-12-31")
-        
-        assert len(result) == 2
-        assert mock_load_file.call_count == 2
-        assert mock_date_filter.call_count == 2
-    
-    @patch('ingest._load_single_cve_file')
-    def test_load_and_filter_cves_invalid_dates(self, mock_load_file):
-        """Test CVE loading with invalid date formats."""
-        mock_load_file.return_value = {}
-        
-        files = ['/path/file.json']
-        result = _load_and_filter_cves(files, "invalid-date", "2024-12-31")
-        
-        assert result == []
-    
-    @patch('ingest._load_single_cve_file')
-    @patch('ingest._passes_date_filter')
-    def test_load_and_filter_cves_with_failures(
-        self, 
-        mock_date_filter, 
-        mock_load_file,
-        sample_cve_valid
-    ):
-        """Test CVE loading with some file failures."""
-        # First file succeeds, second fails, third succeeds
-        mock_load_file.side_effect = [sample_cve_valid, None, sample_cve_valid]
-        mock_date_filter.return_value = True
-        
-        files = ['/path/file1.json', '/path/file2.json', '/path/file3.json']
-        result = _load_and_filter_cves(files, None, None)
-        
-        assert len(result) == 2  # Only successful loads
-
-
-class TestLoadSingleCveFile(TestIngestFixtures):
-    """Test single CVE file loading."""
-    
-    @patch('ingest.load_json_file')
-    @patch('ingest.validate_cve_record')
-    def test_load_single_cve_file_success(
-        self, 
-        mock_validate, 
-        mock_load_json,
-        sample_cve_valid
-    ):
-        """Test successful single CVE file loading."""
-        mock_load_json.return_value = sample_cve_valid
-        mock_validate.return_value = True
-        
-        result = _load_single_cve_file('/path/file.json')
-        
-        assert result == sample_cve_valid
-        mock_validate.assert_called_once_with(sample_cve_valid)
-    
-    @patch('ingest.load_json_file')
-    @patch('ingest.validate_cve_record')
-    def test_load_single_cve_file_invalid(
-        self, 
-        mock_validate, 
-        mock_load_json,
-        sample_cve_invalid
-    ):
-        """Test loading invalid CVE file."""
-        mock_load_json.return_value = sample_cve_invalid
-        mock_validate.return_value = False
-        
-        result = _load_single_cve_file('/path/file.json')
-        
-        assert result is None
-    
-    @patch('ingest.load_json_file')
-    @patch('ingest.validate_cve_record')
-    def test_load_single_cve_file_rejected(
-        self, 
-        mock_validate, 
-        mock_load_json,
-        sample_cve_rejected
-    ):
-        """Test loading rejected CVE file."""
-        mock_load_json.return_value = sample_cve_rejected
-        mock_validate.return_value = True
-        
-        result = _load_single_cve_file('/path/file.json')
-        
-        assert result is None  # Rejected CVEs should be filtered out
-    
-    @patch('ingest.load_json_file')
-    def test_load_single_cve_file_error(self, mock_load_json):
-        """Test loading CVE file with error."""
-        mock_load_json.side_effect = Exception("File error")
-        
-        result = _load_single_cve_file('/path/file.json')
-        
-        assert result is None
-
-
-class TestPassesDateFilter(TestIngestFixtures):
-    """Test date filtering logic."""
-    
-    def test_passes_date_filter_no_filters(self, sample_cve_valid):
-        """Test date filtering with no filters."""
-        result = _passes_date_filter(sample_cve_valid, None, None)
-        assert result is True
-    
-    def test_passes_date_filter_within_range(self, sample_cve_valid):
-        """Test CVE within date range."""
-        start_dt = datetime(2024, 1, 1)
-        end_dt = datetime(2024, 12, 31)
-        
-        result = _passes_date_filter(sample_cve_valid, start_dt, end_dt)
-        assert result is True
-    
-    def test_passes_date_filter_before_range(self, sample_cve_valid):
-        """Test CVE before date range."""
-        start_dt = datetime(2024, 2, 1)
-        end_dt = datetime(2024, 12, 31)
-        
-        result = _passes_date_filter(sample_cve_valid, start_dt, end_dt)
-        assert result is False
-    
-    def test_passes_date_filter_after_range(self, sample_cve_valid):
-        """Test CVE after date range."""
-        start_dt = datetime(2023, 1, 1)
-        end_dt = datetime(2023, 12, 31)
-        
-        result = _passes_date_filter(sample_cve_valid, start_dt, end_dt)
-        assert result is False
-    
-    def test_passes_date_filter_no_date(self):
-        """Test CVE with no publication date."""
-        cve_no_date = {
-            "cveMetadata": {}
-        }
-        
-        start_dt = datetime(2024, 1, 1)
-        end_dt = datetime(2024, 12, 31)
-        
-        result = _passes_date_filter(cve_no_date, start_dt, end_dt)
-        assert result is False
-    
-    def test_passes_date_filter_invalid_date(self):
-        """Test CVE with invalid date format."""
-        cve_invalid_date = {
-            "cveMetadata": {
-                "datePublished": "invalid-date-format"
-            }
-        }
-        
-        start_dt = datetime(2024, 1, 1)
-        end_dt = datetime(2024, 12, 31)
-        
-        result = _passes_date_filter(cve_invalid_date, start_dt, end_dt)
-        assert result is False
-
-
-class TestLoadCnaList(TestIngestFixtures):
-    """Test CNA list extraction."""
-    
-    def test_load_cna_list_success(self, sample_cve_valid):
-        """Test successful CNA list extraction."""
-        cves = [sample_cve_valid]
-        
-        result = load_cna_list(cves)
-        
-        assert len(result) == 1
-        assert result[0]["shortName"] == "TestCNA"
-    
-    def test_load_cna_list_multiple_cnas(self):
-        """Test CNA list extraction with multiple CNAs."""
-        cves = [
-            {
-                "containers": {
-                    "cna": {
-                        "providerMetadata": {"shortName": "CNA1"}
-                    }
-                }
-            },
-            {
-                "containers": {
-                    "cna": {
-                        "providerMetadata": {"shortName": "CNA2"}
-                    }
-                }
-            },
-            {
-                "containers": {
-                    "cna": {
-                        "providerMetadata": {"shortName": "CNA1"}  # Duplicate
-                    }
-                }
-            }
-        ]
-        
-        result = load_cna_list(cves)
-        
-        assert len(result) == 2  # Duplicates should be removed
-        assert {"shortName": "CNA1"} in result
-        assert {"shortName": "CNA2"} in result
-    
-    def test_load_cna_list_empty(self):
-        """Test CNA list extraction with empty input."""
-        result = load_cna_list([])
-        assert result == []
-    
-    def test_load_cna_list_invalid_cves(self):
-        """Test CNA list extraction with invalid CVEs."""
-        invalid_cves = [
-            {"invalid": "data"},
-            {"containers": {}},
-            {"containers": {"cna": {}}},
-            {"containers": {"cna": {"providerMetadata": {}}}}
-        ]
-        
-        result = load_cna_list(invalid_cves)
-        assert result == []
-
-
-class TestDateUtilities:
-    """Test date utility functions."""
-    
-    def test_get_date_range_for_period(self):
-        """Test date range calculation."""
-        # Use a simple test that doesn't rely on mocking current date
-        start_date, end_date = get_date_range_for_period(6)
-        
-        # Just verify the format and that start_date is before end_date
-        assert len(start_date) == 10  # YYYY-MM-DD format
-        assert len(end_date) == 10    # YYYY-MM-DD format
-        assert start_date < end_date  # Start should be before end
-        assert "-" in start_date and "-" in end_date  # Contains dashes
-    
-    def test_validate_date_range_valid(self):
-        """Test valid date range validation."""
-        result = validate_date_range("2024-01-01", "2024-12-31")
-        assert result is True
-    
-    def test_validate_date_range_invalid_order(self):
-        """Test invalid date range validation (start after end)."""
-        result = validate_date_range("2024-12-31", "2024-01-01")
-        assert result is False
-    
-    def test_validate_date_range_invalid_format(self):
-        """Test invalid date format validation."""
-        result = validate_date_range("invalid-date", "2024-12-31")
-        assert result is False
-
-
-class TestIngestIntegration:
-    """Integration tests for ingest module."""
-    
-    @patch('ingest.Path.exists')
-    @patch('ingest.Path.iterdir')
-    @patch('ingest.glob')
-    @patch('ingest.open', new_callable=mock_open)
-    @patch('ingest.load_json_file')
-    def test_full_integration(
-        self, 
-        mock_load_json, 
-        mock_file, 
-        mock_glob, 
-        mock_iterdir, 
-        mock_exists
-    ):
-        """Test full integration of ingest functionality."""
-        # Setup mocks
-        mock_exists.return_value = True
-        mock_iterdir.return_value = [
-            MagicMock(name='2024', is_dir=lambda: True)
-        ]
-        mock_glob.return_value = ['/path/CVE-2024-0001.json']
-        mock_load_json.return_value = {
-            "cveId": "CVE-2024-0001",
-            "cveMetadata": {
-                "cveId": "CVE-2024-0001",
-                "datePublished": "2024-01-15T10:00:00.000Z",
-                "state": "PUBLISHED"
-            },
-            "containers": {
-                "cna": {
-                    "providerMetadata": {"shortName": "TestCNA"}
-                }
-            }
-        }
-        
-        # Test the full flow
-        records = load_cve_records(
-            cve_dir="/test/dir",
-            start_date="2024-01-01",
-            end_date="2024-12-31"
-        )
-        
-        assert len(records) == 1
-        assert records[0]["cveId"] == "CVE-2024-0001"
-        
-        # Test CNA extraction
-        cna_list = load_cna_list(records)
-        assert len(cna_list) == 1
-        assert cna_list[0]["shortName"] == "TestCNA"
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])
diff --git a/src/cvedb/cna/tests/test_pipeline.py b/src/cvedb/cna/tests/test_pipeline.py
deleted file mode 100644
index e6eb0ce3aec..00000000000
--- a/src/cvedb/cna/tests/test_pipeline.py
+++ /dev/null
@@ -1,530 +0,0 @@
-"""
-Integration tests for the main pipeline orchestration.
-
-This module tests the complete pipeline execution to ensure all components
-work together correctly and produce expected outputs.
-"""
-import pytest
-from unittest.mock import patch, MagicMock, mock_open
-from pathlib import Path
-from datetime import datetime
-from typing import Dict, Any, List
-
-# Import the module under test
-import sys
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from pipeline import CNAScoreCardPipeline, PipelineError, main
-
-
-class TestPipelineFixtures:
-    """Test fixtures for pipeline tests."""
-    
-    @pytest.fixture
-    def sample_config(self) -> Dict[str, Any]:
-        """Sample configuration for testing."""
-        return {
-            'directories': {
-                'web_data': '/test/web/data',
-                'completeness': '/test/web/data/completeness',
-                'cna_data': '/test/web/data/cna'
-            },
-            'fields': {
-                'field_list': ['containers.cna.descriptions', 'containers.cna.affected'],
-                'canonical_fields': [
-                    {
-                        'field': 'containers.cna.descriptions',
-                        'importance': 'High',
-                        'description': 'Vulnerability descriptions',
-                        'cna_scorecard_category': 'foundationalCompleteness'
-                    }
-                ]
-            }
-        }
-    
-    @pytest.fixture
-    def sample_cve_records(self) -> List[Dict[str, Any]]:
-        """Sample CVE records for testing."""
-        return [
-            {
-                "cveId": "CVE-2024-0001",
-                "cveMetadata": {
-                    "datePublished": "2024-01-15T10:00:00.000Z"
-                },
-                "containers": {
-                    "cna": {
-                        "providerMetadata": {"shortName": "TestCNA1"}
-                    }
-                }
-            },
-            {
-                "cveId": "CVE-2024-0002", 
-                "cveMetadata": {
-                    "datePublished": "2024-01-20T10:00:00.000Z"
-                },
-                "containers": {
-                    "cna": {
-                        "providerMetadata": {"shortName": "TestCNA2"}
-                    }
-                }
-            }
-        ]
-    
-    @pytest.fixture
-    def sample_scored_cves(self) -> List[Dict[str, Any]]:
-        """Sample scored CVE records for testing."""
-        return [
-            {
-                "cveId": "CVE-2024-0001",
-                "assigningCna": "TestCNA1",
-                "datePublished": "2024-01-15",
-                "totalScore": 85,
-                "scoreBreakdown": {
-                    "foundationalCompleteness": 50,
-                    "rootCauseAnalysis": 15,
-                    "severityAndImpactContext": 15,
-                    "softwareIdentification": 5,
-                    "patchinfo": 0
-                }
-            }
-        ]
-    
-    @pytest.fixture
-    def sample_cna_outputs(self) -> Dict[str, Any]:
-        """Sample CNA aggregation outputs for testing."""
-        return {
-            "TestCNA1": {
-                "cna_info": [{
-                    "shortName": "TestCNA1",
-                    "total_cves": 1,
-                    "total_cves_scored": 1,
-                    "organizationName": "Test Organization",
-                    "scope": "Test scope",
-                    "advisories": [],
-                    "email": [],
-                    "officialCnaID": "test-cna-1",
-                    "cnaTypes": ["vendor"],
-                    "country": "US",
-                    "disclosurePolicy": [],
-                    "rootCnaInfo": {},
-                    "rank": 1,
-                    "active_cna_count": 1,
-                    "percentile": 100.0
-                }],
-                "cna_scoring": [{
-                    "total_cves": 1,
-                    "total_cves_scored": 1,
-                    "recent_cves_count": 1,
-                    "overall_average_score": 85.0,
-                    "average_foundational_completeness": 50.0,
-                    "average_root_cause_analysis": 15.0,
-                    "average_software_identification": 5.0,
-                    "average_severity_context": 15.0,
-                    "average_patchinfo": 0.0,
-                    "percent_foundational_completeness": 100.0,
-                    "percent_root_cause_analysis": 100.0,
-                    "percent_software_identification": 100.0,
-                    "percent_severity_and_impact": 100.0,
-                    "percent_patchinfo": 0.0,
-                    "trend_direction": "steady",
-                    "trend_description": "No significant change",
-                    "monthly_trends": []
-                }],
-                "cve_scoring": [{
-                    "cveId": "CVE-2024-0001",
-                    "assigningCna": "TestCNA1",
-                    "datePublished": "2024-01-15",
-                    "totalCveScore": 85,
-                    "scoreBreakdown": {
-                        "foundationalCompleteness": 50,
-                        "rootCauseAnalysis": 15,
-                        "severityAndImpactContext": 15,
-                        "softwareIdentification": 5,
-                        "patchinfo": 0
-                    }
-                }]
-            }
-        }
-
-
-class TestCNAScoreCardPipeline(TestPipelineFixtures):
-    """Test the main CNAScoreCardPipeline class."""
-    
-    def test_pipeline_initialization(self, sample_config):
-        """Test pipeline initialization."""
-        pipeline = CNAScoreCardPipeline(sample_config)
-        
-        assert pipeline.config == sample_config
-        assert pipeline.cve_records == []
-        assert pipeline.filtered_cve_records == []
-        assert pipeline.scored_cves == []
-        assert pipeline.cna_outputs == {}
-        assert pipeline.analysis_periods == {}
-    
-    def test_pipeline_initialization_default_config(self):
-        """Test pipeline initialization with default config."""
-        with patch('pipeline.get_config') as mock_get_config:
-            mock_get_config.return_value = {'test': 'config'}
-            
-            pipeline = CNAScoreCardPipeline()
-            
-            assert pipeline.config == {'test': 'config'}
-            mock_get_config.assert_called_once()
-    
-    @patch('pipeline.CNAScoreCardPipeline._generate_output_files')
-    @patch('pipeline.CNAScoreCardPipeline._generate_trends_analysis')
-    @patch('pipeline.CNAScoreCardPipeline._generate_completeness_analysis')
-    @patch('pipeline.CNAScoreCardPipeline._aggregate_cna_scores')
-    @patch('pipeline.CNAScoreCardPipeline._score_cve_records')
-    @patch('pipeline.CNAScoreCardPipeline._load_cve_data')
-    @patch('pipeline.CNAScoreCardPipeline._sync_cna_metadata')
-    @patch('pipeline.CNAScoreCardPipeline._setup_analysis_periods')
-    def test_pipeline_run_success(
-        self,
-        mock_setup_periods,
-        mock_sync_metadata,
-        mock_load_data,
-        mock_score_cves,
-        mock_aggregate,
-        mock_completeness,
-        mock_trends,
-        mock_output,
-        sample_config
-    ):
-        """Test successful pipeline execution."""
-        # Setup mocks
-        mock_output.return_value = {'test_file': '/path/to/file.json'}
-        
-        pipeline = CNAScoreCardPipeline(sample_config)
-        pipeline.cve_records = [{'test': 'cve'}]
-        pipeline.filtered_cve_records = [{'test': 'filtered_cve'}]
-        pipeline.scored_cves = [{'test': 'scored_cve'}]
-        pipeline.cna_outputs = {'TestCNA': {'test': 'output'}}
-        pipeline.analysis_periods = {
-            'current': ('2024-01-01', '2024-06-30'),
-            'previous': ('2023-07-01', '2023-12-31')
-        }
-        
-        result = pipeline.run()
-        
-        # Verify all steps were called
-        mock_setup_periods.assert_called_once_with(None, None)
-        mock_sync_metadata.assert_called_once()
-        mock_load_data.assert_called_once()
-        mock_score_cves.assert_called_once_with(use_cache=True)
-        mock_aggregate.assert_called_once()
-        mock_completeness.assert_called_once()
-        mock_trends.assert_called_once()
-        mock_output.assert_called_once_with(None)
-        
-        # Verify result structure
-        assert result['status'] == 'success'
-        assert result['mode'] == 'full'
-        assert result['cache_enabled'] == True
-        assert 'execution_time' in result
-        assert result['analysis_period'] == ('2024-01-01', '2024-06-30')
-        assert result['total_cves_processed'] == 1
-        assert result['filtered_cves_count'] == 1
-        assert result['scored_cves_count'] == 1
-        assert result['cnas_processed'] == 1
-        assert result['output_files'] == {'test_file': '/path/to/file.json'}
-    
-    @patch('pipeline.CNAScoreCardPipeline._setup_analysis_periods')
-    def test_pipeline_run_failure(self, mock_setup_periods, sample_config):
-        """Test pipeline execution failure."""
-        mock_setup_periods.side_effect = Exception("Test error")
-        
-        pipeline = CNAScoreCardPipeline(sample_config)
-        
-        with pytest.raises(PipelineError, match="Pipeline execution failed: Test error"):
-            pipeline.run()
-    
-    def test_setup_analysis_periods_custom_dates(self, sample_config):
-        """Test analysis period setup with custom dates."""
-        pipeline = CNAScoreCardPipeline(sample_config)
-        
-        pipeline._setup_analysis_periods("2024-01-01", "2024-06-30")
-        
-        assert pipeline.analysis_periods['current'] == ("2024-01-01", "2024-06-30")
-        assert pipeline.analysis_periods['previous'] == ("2023-07-03", "2023-12-31")
-    
-    @patch('pipeline.get_date_range_for_period')
-    def test_setup_analysis_periods_default(self, mock_get_range, sample_config):
-        """Test analysis period setup with default dates."""
-        mock_get_range.return_value = ("2024-01-01", "2024-06-30")
-        
-        pipeline = CNAScoreCardPipeline(sample_config)
-        pipeline._setup_analysis_periods(None, None)
-        
-        assert pipeline.analysis_periods['current'] == ("2024-01-01", "2024-06-30")
-        mock_get_range.assert_called_once()
-    
-    def test_setup_analysis_periods_invalid_range(self, sample_config):
-        """Test analysis period setup with invalid date range."""
-        pipeline = CNAScoreCardPipeline(sample_config)
-        
-        with pytest.raises(PipelineError, match="Invalid date range"):
-            pipeline._setup_analysis_periods("2024-06-30", "2024-01-01")
-    
-    @patch('pipeline.load_cve_records')
-    def test_load_cve_data_success(self, mock_load_cves, sample_config, sample_cve_records):
-        """Test successful CVE data loading."""
-        mock_load_cves.side_effect = [sample_cve_records, [sample_cve_records[0]]]
-        
-        pipeline = CNAScoreCardPipeline(sample_config)
-        pipeline.analysis_periods = {'current': ('2024-01-01', '2024-06-30')}
-        
-        pipeline._load_cve_data()
-        
-        assert len(pipeline.cve_records) == 2
-        assert len(pipeline.filtered_cve_records) == 1
-        assert mock_load_cves.call_count == 2
-    
-    @patch('pipeline.load_cve_records')
-    def test_load_cve_data_no_filtered_records(self, mock_load_cves, sample_config):
-        """Test CVE data loading with no filtered records."""
-        mock_load_cves.side_effect = [['some_cve'], []]  # No filtered records
-        
-        pipeline = CNAScoreCardPipeline(sample_config)
-        pipeline.analysis_periods = {'current': ('2024-01-01', '2024-06-30')}
-        
-        with pytest.raises(PipelineError, match="No CVE records found"):
-            pipeline._load_cve_data()
-    
-    @patch('pipeline.score_multiple_cves')
-    def test_score_cve_records_success(self, mock_score, sample_config, sample_scored_cves):
-        """Test successful CVE scoring."""
-        mock_score.return_value = sample_scored_cves
-        
-        pipeline = CNAScoreCardPipeline(sample_config)
-        pipeline.filtered_cve_records = [{'test': 'cve'}]
-        
-        pipeline._score_cve_records()
-        
-        assert pipeline.scored_cves == sample_scored_cves
-        mock_score.assert_called_once_with([{'test': 'cve'}], use_cache=True)
-    
-    @patch('pipeline.score_multiple_cves')
-    def test_score_cve_records_no_scores(self, mock_score, sample_config):
-        """Test CVE scoring with no successful scores."""
-        mock_score.return_value = []
-        
-        pipeline = CNAScoreCardPipeline(sample_config)
-        pipeline.filtered_cve_records = [{'test': 'cve'}]
-        
-        with pytest.raises(PipelineError, match="No CVE records could be scored"):
-            pipeline._score_cve_records()
-    
-    @patch('pipeline.aggregate_cna_scores')
-    def test_aggregate_cna_scores_success(self, mock_aggregate, sample_config, sample_cna_outputs):
-        """Test successful CNA score aggregation."""
-        mock_aggregate.return_value = sample_cna_outputs
-        
-        pipeline = CNAScoreCardPipeline(sample_config)
-        pipeline.scored_cves = [{'test': 'scored_cve'}]
-        pipeline.analysis_periods = {
-            'current': ('2024-01-01', '2024-06-30'),
-            'previous': ('2023-07-01', '2023-12-31')
-        }
-        
-        pipeline._aggregate_cna_scores()
-        
-        assert pipeline.cna_outputs == sample_cna_outputs
-        mock_aggregate.assert_called_once()
-    
-    @patch('pipeline.compute_individual_cna_field_utilization')
-    @patch('pipeline.compute_field_utilization')
-    def test_generate_completeness_analysis(
-        self, 
-        mock_field_util, 
-        mock_individual_util,
-        sample_config
-    ):
-        """Test completeness analysis generation."""
-        mock_field_util.return_value = [{'field': 'test', 'cna_percent': 50.0}]
-        mock_individual_util.return_value = {'TestCNA': [{'field': 'test', 'percent': 100.0}]}
-        
-        pipeline = CNAScoreCardPipeline(sample_config)
-        pipeline.filtered_cve_records = [{'test': 'cve'}]
-        
-        pipeline._generate_completeness_analysis()
-        
-        assert pipeline.field_utilization == [{'field': 'test', 'cna_percent': 50.0}]
-        assert pipeline.individual_cna_utilization == {'TestCNA': [{'field': 'test', 'percent': 100.0}]}
-    
-    def test_calculate_grade(self, sample_config):
-        """Test grade calculation."""
-        pipeline = CNAScoreCardPipeline(sample_config)
-        
-        assert pipeline._calculate_grade(98) == "A+"
-        assert pipeline._calculate_grade(92) == "A"
-        assert pipeline._calculate_grade(87) == "B+"
-        assert pipeline._calculate_grade(82) == "B"
-        assert pipeline._calculate_grade(77) == "C+"
-        assert pipeline._calculate_grade(72) == "C"
-        assert pipeline._calculate_grade(67) == "D+"
-        assert pipeline._calculate_grade(62) == "D"
-        assert pipeline._calculate_grade(50) == "F"
-
-
-class TestPipelineOutputGeneration(TestPipelineFixtures):
-    """Test pipeline output file generation."""
-    
-    @patch('pipeline.write_json_file')
-    @patch('pipeline.ensure_directory_exists')
-    def test_generate_individual_cna_files(
-        self, 
-        mock_ensure_dir, 
-        mock_write_json,
-        sample_config,
-        sample_cna_outputs
-    ):
-        """Test individual CNA file generation."""
-        pipeline = CNAScoreCardPipeline(sample_config)
-        pipeline.cna_outputs = sample_cna_outputs
-        
-        result = pipeline._generate_individual_cna_files(Path('/test/output'))
-        
-        assert 'cna_TestCNA1' in result
-        assert result['cna_TestCNA1'] == '/test/output/cna/TestCNA1.json'
-        mock_write_json.assert_called()
-        mock_ensure_dir.assert_called()
-    
-    @patch('pipeline.write_json_file')
-    @patch('pipeline.write_chunked_cna_data')
-    @patch('pipeline.generate_search_index')
-    def test_generate_summary_files(
-        self, 
-        mock_search_index,
-        mock_chunked_data,
-        mock_write_json,
-        sample_config,
-        sample_cna_outputs
-    ):
-        """Test summary file generation."""
-        # Mock chunking functions
-        mock_chunked_data.return_value = {'totalChunks': 1, 'totalCNAs': 1}
-        mock_search_index.return_value = {'totalCNAs': 1}
-        
-        pipeline = CNAScoreCardPipeline(sample_config)
-        pipeline.cna_outputs = sample_cna_outputs
-        pipeline.analysis_periods = {'current': ('2024-01-01', '2024-06-30')}
-        pipeline.filtered_cve_records = [{'test': 'cve'}]
-        
-        result = pipeline._generate_summary_files(Path('/test/output'))
-        
-        assert 'cna_combined' in result
-        assert 'cna_summary' in result
-        assert 'completeness_summary' in result
-        assert 'chunk_manifest' in result
-        assert 'search_index' in result
-        assert mock_write_json.call_count == 3
-        mock_chunked_data.assert_called_once()
-        mock_search_index.assert_called_once()
-    
-    @patch('pipeline.write_json_file')
-    @patch('pipeline.ensure_directory_exists')
-    def test_generate_completeness_files(
-        self, 
-        mock_ensure_dir,
-        mock_write_json,
-        sample_config
-    ):
-        """Test completeness file generation."""
-        pipeline = CNAScoreCardPipeline(sample_config)
-        pipeline.field_utilization = [
-            {'field': 'test_field', 'cna_percent': 75.0, 'unique_cnas': 10}
-        ]
-        pipeline.individual_cna_utilization = {
-            'TestCNA': [{'field': 'test_field', 'percent': 100.0}]
-        }
-        
-        result = pipeline._generate_completeness_files(Path('/test/output'))
-        
-        assert 'field_utilization' in result
-        assert 'completeness_TestCNA' in result
-        mock_ensure_dir.assert_called()
-        assert mock_write_json.call_count >= 2
-
-
-class TestPipelineMain:
-    """Test the main function and CLI interface."""
-    
-    @patch('pipeline.CNAScoreCardPipeline')
-    @patch('pipeline.setup_logging')
-    @patch('sys.argv', ['pipeline.py', '--log-level', 'DEBUG'])
-    def test_main_function_success(self, mock_setup_logging, mock_pipeline_class):
-        """Test successful main function execution."""
-        mock_logger = MagicMock()
-        mock_setup_logging.return_value = mock_logger
-        
-        mock_pipeline = MagicMock()
-        mock_pipeline.run.return_value = {
-            'status': 'success',
-            'execution_time': '0:01:30',
-            'analysis_period': ('2024-01-01', '2024-06-30'),
-            'total_cves_processed': 1000,
-            'filtered_cves_count': 500,
-            'scored_cves_count': 500,
-            'cnas_processed': 50,
-            'output_files': {'test': 'file.json'}
-        }
-        mock_pipeline_class.return_value = mock_pipeline
-        
-        # Should not raise an exception
-        main()
-        
-        mock_setup_logging.assert_called_once_with('DEBUG')
-        mock_pipeline_class.assert_called_once()
-        mock_pipeline.run.assert_called_once()
-    
-    @patch('pipeline.CNAScoreCardPipeline')
-    @patch('pipeline.setup_logging')
-    @patch('sys.argv', ['pipeline.py'])
-    def test_main_function_failure(self, mock_setup_logging, mock_pipeline_class):
-        """Test main function with pipeline failure."""
-        mock_logger = MagicMock()
-        mock_setup_logging.return_value = mock_logger
-        
-        mock_pipeline = MagicMock()
-        mock_pipeline.run.side_effect = Exception("Pipeline failed")
-        mock_pipeline_class.return_value = mock_pipeline
-        
-        with pytest.raises(Exception, match="Pipeline failed"):
-            main()
-
-
-class TestPipelineErrorHandling:
-    """Test error handling throughout the pipeline."""
-    
-    def test_pipeline_error_creation(self):
-        """Test PipelineError exception creation."""
-        error = PipelineError("Test error message")
-        assert str(error) == "Test error message"
-        assert isinstance(error, Exception)
-    
-    @patch('pipeline.CNAScoreCardPipeline._load_cve_data')
-    def test_pipeline_error_propagation(self, mock_load_data):
-        """Test that errors are properly propagated as PipelineError."""
-        mock_load_data.side_effect = ValueError("Data loading failed")
-        
-        # Create sample config directly
-        from pathlib import Path
-        sample_config = {
-            'cve_data_dir': Path('/test/cve_data'),
-            'output_dir': Path('/test/output'),
-            'start_date': '2024-01-01',
-            'end_date': '2024-06-30'
-        }
-        
-        pipeline = CNAScoreCardPipeline(sample_config)
-        
-        with pytest.raises(PipelineError) as exc_info:
-            pipeline.run()
-        
-        assert "Pipeline execution failed" in str(exc_info.value)
-        assert "Data loading failed" in str(exc_info.value)
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])
diff --git a/src/cvedb/cna/tests/test_scoring.py b/src/cvedb/cna/tests/test_scoring.py
deleted file mode 100644
index 978dc269c44..00000000000
--- a/src/cvedb/cna/tests/test_scoring.py
+++ /dev/null
@@ -1,546 +0,0 @@
-"""
-Unit tests for scoring module.
-
-This module tests the CVE scoring logic to ensure correct calculation
-of category scores based on the CNA Scorecard methodology.
-"""
-import pytest
-from unittest.mock import patch, MagicMock
-from typing import Dict, Any
-
-# Import the module under test
-import sys
-from pathlib import Path
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from scoring import (
-    score_cve_record,
-    score_multiple_cves,
-    _calculate_foundational_completeness,
-    _calculate_root_cause_analysis,
-    _calculate_severity_context,
-    _calculate_software_identification,
-    _calculate_actionable_intelligence,
-    _find_valid_cwe,
-    _is_valid_cwe_id,
-    _has_cvss_metrics,
-    _has_valid_cvss_vector,
-    _has_cpe_identifiers,
-    _has_patch_references
-)
-
-
-class TestScoringFixtures:
-    """Test fixtures for CVE scoring tests."""
-    
-    @pytest.fixture
-    def sample_cve_complete(self) -> Dict[str, Any]:
-        """Complete CVE record with all scoring fields present."""
-        return {
-            "cveId": "CVE-2024-12345",
-            "cveMetadata": {
-                "cveId": "CVE-2024-12345",
-                "datePublished": "2024-01-15T10:00:00.000Z",
-                "state": "PUBLISHED"
-            },
-            "containers": {
-                "cna": {
-                    "providerMetadata": {
-                        "shortName": "TestCNA"
-                    },
-                    "descriptions": [
-                        {
-                            "lang": "en",
-                            "value": "A vulnerability in the test application allows remote code execution."
-                        }
-                    ],
-                    "affected": [
-                        {
-                            "vendor": "TestVendor",
-                            "product": "TestProduct",
-                            "versions": [
-                                {
-                                    "version": "1.0.0",
-                                    "status": "affected"
-                                }
-                            ],
-                            "cpes": ["cpe:2.3:a:testvendor:testproduct:1.0.0:*:*:*:*:*:*:*"]
-                        }
-                    ],
-                    "references": [
-                        {
-                            "url": "https://example.com/patch",
-                            "tags": ["patch"]
-                        },
-                        {
-                            "url": "https://example.com/advisory",
-                            "tags": ["vendor-advisory"]
-                        }
-                    ],
-                    "problemTypes": [
-                        {
-                            "descriptions": [
-                                {
-                                    "cweId": "CWE-78",
-                                    "description": "OS Command Injection"
-                                }
-                            ]
-                        }
-                    ],
-                    "metrics": [
-                        {
-                            "cvssV3_1": {
-                                "vectorString": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
-                                "baseScore": 9.8,
-                                "baseSeverity": "CRITICAL"
-                            }
-                        }
-                    ]
-                }
-            }
-        }
-    
-    @pytest.fixture
-    def sample_cve_minimal(self) -> Dict[str, Any]:
-        """Minimal CVE record with no scoring fields."""
-        return {
-            "cveId": "CVE-2024-67890",
-            "cveMetadata": {
-                "cveId": "CVE-2024-67890",
-                "datePublished": "2024-01-15T10:00:00.000Z",
-                "state": "PUBLISHED"
-            },
-            "containers": {
-                "cna": {
-                    "providerMetadata": {
-                        "shortName": "MinimalCNA"
-                    }
-                }
-            }
-        }
-    
-    @pytest.fixture
-    def sample_cve_partial(self) -> Dict[str, Any]:
-        """Partially complete CVE record."""
-        return {
-            "cveId": "CVE-2024-11111",
-            "cveMetadata": {
-                "cveId": "CVE-2024-11111",
-                "datePublished": "2024-01-15T10:00:00.000Z",
-                "state": "PUBLISHED"
-            },
-            "containers": {
-                "cna": {
-                    "providerMetadata": {
-                        "shortName": "PartialCNA"
-                    },
-                    "descriptions": [
-                        {
-                            "lang": "en",
-                            "value": "A vulnerability exists."
-                        }
-                    ],
-                    "affected": [
-                        {
-                            "vendor": "TestVendor",
-                            "product": "TestProduct"
-                        }
-                    ],
-                    "references": [
-                        {
-                            "url": "https://example.com/info",
-                            "tags": ["vendor-advisory"]
-                        }
-                    ]
-                }
-            }
-        }
-
-
-class TestScoreCveRecord(TestScoringFixtures):
-    """Test the main score_cve_record function."""
-    
-    def test_score_complete_cve(self, sample_cve_complete):
-        """Test scoring a complete CVE record."""
-        result = score_cve_record(sample_cve_complete)
-        
-        assert result["cveId"] == "CVE-2024-12345"
-        assert result["assigningCna"] == "TestCNA"
-        assert result["datePublished"] == "2024-01-15"
-        assert result["totalScore"] == 100  # All categories should score full points
-        
-        breakdown = result["scoreBreakdown"]
-        assert breakdown["foundationalCompleteness"] == 50
-        assert breakdown["rootCauseAnalysis"] == 15
-        assert breakdown["severityAndImpactContext"] == 15
-        assert breakdown["softwareIdentification"] == 10
-        assert breakdown["patchinfo"] == 10
-    
-    def test_score_minimal_cve(self, sample_cve_minimal):
-        """Test scoring a minimal CVE record."""
-        result = score_cve_record(sample_cve_minimal)
-        
-        assert result["cveId"] == "CVE-2024-67890"
-        assert result["assigningCna"] == "MinimalCNA"
-        assert result["totalScore"] == 0  # No scoring fields present
-        
-        breakdown = result["scoreBreakdown"]
-        assert all(score == 0 for score in breakdown.values())
-    
-    def test_score_partial_cve(self, sample_cve_partial):
-        """Test scoring a partially complete CVE record."""
-        result = score_cve_record(sample_cve_partial)
-        
-        assert result["cveId"] == "CVE-2024-11111"
-        assert result["assigningCna"] == "PartialCNA"
-        assert result["totalScore"] == 50  # Only foundational completeness
-        
-        breakdown = result["scoreBreakdown"]
-        assert breakdown["foundationalCompleteness"] == 50
-        assert breakdown["rootCauseAnalysis"] == 0
-        assert breakdown["severityAndImpactContext"] == 0
-        assert breakdown["softwareIdentification"] == 0
-        assert breakdown["patchinfo"] == 0
-    
-    def test_score_invalid_cve(self):
-        """Test scoring an invalid CVE record."""
-        invalid_cve = {"invalid": "data"}
-        result = score_cve_record(invalid_cve)
-        
-        assert result["totalScore"] == 0
-        assert result["assigningCna"] == "Unknown"
-        assert all(score == 0 for score in result["scoreBreakdown"].values())
-    
-    def test_score_cve_missing_metadata(self):
-        """Test scoring CVE with missing metadata."""
-        cve_no_metadata = {
-            "containers": {
-                "cna": {
-                    "providerMetadata": {
-                        "shortName": "TestCNA"
-                    }
-                }
-            }
-        }
-        result = score_cve_record(cve_no_metadata)
-        
-        assert result["cveId"] == ""
-        assert result["datePublished"] == ""
-        assert result["assigningCna"] == "TestCNA"
-
-
-class TestFoundationalCompleteness(TestScoringFixtures):
-    """Test foundational completeness scoring."""
-    
-    def test_complete_foundational_fields(self, sample_cve_complete):
-        """Test with all foundational fields present."""
-        cna = sample_cve_complete["containers"]["cna"]
-        score = _calculate_foundational_completeness(sample_cve_complete, cna)
-        assert score == 50
-    
-    def test_missing_foundational_fields(self):
-        """Test with missing foundational fields."""
-        cve = {}
-        cna = {
-            "descriptions": ["test"],
-            "affected": ["test"]
-            # Missing references
-        }
-        score = _calculate_foundational_completeness(cve, cna)
-        assert score == 0
-    
-    def test_empty_foundational_fields(self):
-        """Test with empty foundational fields."""
-        cve = {}
-        cna = {
-            "descriptions": [],
-            "affected": [],
-            "references": []
-        }
-        score = _calculate_foundational_completeness(cve, cna)
-        assert score == 0
-
-
-class TestRootCauseAnalysis(TestScoringFixtures):
-    """Test root cause analysis scoring."""
-    
-    def test_valid_cwe_scoring(self, sample_cve_complete):
-        """Test with valid CWE identifier."""
-        cna = sample_cve_complete["containers"]["cna"]
-        score = _calculate_root_cause_analysis(sample_cve_complete, cna)
-        assert score == 15
-    
-    def test_invalid_cwe_scoring(self):
-        """Test with invalid CWE identifier."""
-        cve = {}
-        cna = {
-            "problemTypes": [
-                {
-                    "descriptions": [
-                        {
-                            "cweId": "CWE-99999",  # Invalid CWE
-                            "description": "Invalid CWE"
-                        }
-                    ]
-                }
-            ]
-        }
-        score = _calculate_root_cause_analysis(cve, cna)
-        assert score == 0
-    
-    def test_no_problem_types(self):
-        """Test with no problem types."""
-        cve = {}
-        cna = {}
-        score = _calculate_root_cause_analysis(cve, cna)
-        assert score == 0
-    
-    def test_find_valid_cwe_success(self):
-        """Test finding valid CWE in problem types."""
-        problem_types = [
-            {
-                "descriptions": [
-                    {
-                        "cweId": "CWE-78",
-                        "description": "OS Command Injection"
-                    }
-                ]
-            }
-        ]
-        assert _find_valid_cwe(problem_types) is True
-    
-    def test_find_valid_cwe_failure(self):
-        """Test not finding valid CWE in problem types."""
-        problem_types = [
-            {
-                "descriptions": [
-                    {
-                        "description": "Some vulnerability"
-                    }
-                ]
-            }
-        ]
-        assert _find_valid_cwe(problem_types) is False
-    
-    def test_is_valid_cwe_id_formats(self):
-        """Test CWE ID validation with different formats."""
-        assert _is_valid_cwe_id("CWE-78") is True
-        assert _is_valid_cwe_id("78") is True
-        assert _is_valid_cwe_id("CWE-99999") is False
-        assert _is_valid_cwe_id("") is False
-        assert _is_valid_cwe_id("invalid") is False
-
-
-class TestSeverityContext(TestScoringFixtures):
-    """Test severity and impact context scoring."""
-    
-    def test_valid_cvss_scoring(self, sample_cve_complete):
-        """Test with valid CVSS metrics."""
-        cna = sample_cve_complete["containers"]["cna"]
-        score = _calculate_severity_context(sample_cve_complete, cna)
-        assert score == 15
-    
-    def test_no_metrics(self):
-        """Test with no metrics."""
-        cve = {}
-        cna = {}
-        score = _calculate_severity_context(cve, cna)
-        assert score == 0
-    
-    def test_cvss_without_vector(self):
-        """Test CVSS metrics without vector string."""
-        cve = {}
-        cna = {
-            "metrics": [
-                {
-                    "cvssV3_1": {
-                        "baseScore": 9.8
-                        # Missing vectorString
-                    }
-                }
-            ]
-        }
-        score = _calculate_severity_context(cve, cna)
-        assert score == 0
-    
-    def test_has_cvss_metrics_detection(self):
-        """Test CVSS metrics detection."""
-        metrics_with_cvss = [
-            {"cvssV3_1": {"baseScore": 9.8}}
-        ]
-        metrics_without_cvss = [
-            {"other": "data"}
-        ]
-        
-        assert _has_cvss_metrics(metrics_with_cvss) is True
-        assert _has_cvss_metrics(metrics_without_cvss) is False
-        assert _has_cvss_metrics([]) is False
-    
-    def test_has_valid_cvss_vector_detection(self):
-        """Test CVSS vector string detection."""
-        metrics_with_vector = [
-            {
-                "cvssV3_1": {
-                    "vectorString": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H"
-                }
-            }
-        ]
-        metrics_without_vector = [
-            {
-                "cvssV3_1": {
-                    "baseScore": 9.8
-                }
-            }
-        ]
-        
-        assert _has_valid_cvss_vector(metrics_with_vector) is True
-        assert _has_valid_cvss_vector(metrics_without_vector) is False
-
-
-class TestSoftwareIdentification(TestScoringFixtures):
-    """Test software identification scoring."""
-    
-    def test_valid_cpe_scoring(self, sample_cve_complete):
-        """Test with valid CPE identifiers."""
-        cna = sample_cve_complete["containers"]["cna"]
-        score = _calculate_software_identification(sample_cve_complete, cna)
-        assert score == 10
-    
-    def test_no_affected_products(self):
-        """Test with no affected products."""
-        cve = {}
-        cna = {}
-        score = _calculate_software_identification(cve, cna)
-        assert score == 0
-    
-    def test_affected_without_cpes(self):
-        """Test affected products without CPEs."""
-        cve = {}
-        cna = {
-            "affected": [
-                {
-                    "vendor": "TestVendor",
-                    "product": "TestProduct"
-                    # Missing cpes
-                }
-            ]
-        }
-        score = _calculate_software_identification(cve, cna)
-        assert score == 0
-    
-    def test_has_cpe_identifiers_detection(self):
-        """Test CPE identifier detection."""
-        affected_with_cpes = [
-            {
-                "cpes": ["cpe:2.3:a:vendor:product:1.0:*:*:*:*:*:*:*"]
-            }
-        ]
-        affected_without_cpes = [
-            {
-                "vendor": "TestVendor"
-            }
-        ]
-        
-        assert _has_cpe_identifiers(affected_with_cpes) is True
-        assert _has_cpe_identifiers(affected_without_cpes) is False
-        assert _has_cpe_identifiers([]) is False
-
-
-class TestActionableIntelligence(TestScoringFixtures):
-    """Test actionable intelligence/patch info scoring."""
-    
-    def test_valid_patch_reference_scoring(self, sample_cve_complete):
-        """Test with valid patch references."""
-        cna = sample_cve_complete["containers"]["cna"]
-        score = _calculate_actionable_intelligence(sample_cve_complete, cna)
-        assert score == 10
-    
-    def test_no_references(self):
-        """Test with no references."""
-        cve = {}
-        cna = {}
-        score = _calculate_actionable_intelligence(cve, cna)
-        assert score == 0
-    
-    def test_references_without_patch_tags(self):
-        """Test references without patch tags."""
-        cve = {}
-        cna = {
-            "references": [
-                {
-                    "url": "https://example.com/info",
-                    "tags": ["vendor-advisory"]
-                }
-            ]
-        }
-        score = _calculate_actionable_intelligence(cve, cna)
-        assert score == 0
-    
-    def test_has_patch_references_detection(self):
-        """Test patch reference detection."""
-        refs_with_patch = [
-            {
-                "tags": ["patch", "vendor-advisory"]
-            }
-        ]
-        refs_without_patch = [
-            {
-                "tags": ["vendor-advisory"]
-            }
-        ]
-        
-        assert _has_patch_references(refs_with_patch) is True
-        assert _has_patch_references(refs_without_patch) is False
-        assert _has_patch_references([]) is False
-
-
-class TestScoreMultipleCves(TestScoringFixtures):
-    """Test batch scoring functionality."""
-    
-    def test_score_multiple_cves_success(self, sample_cve_complete, sample_cve_minimal):
-        """Test scoring multiple CVEs successfully."""
-        cves = [sample_cve_complete, sample_cve_minimal]
-        results = score_multiple_cves(cves)
-        
-        assert len(results) == 2
-        assert results[0]["totalScore"] == 100
-        assert results[1]["totalScore"] == 0
-    
-    def test_score_empty_list(self):
-        """Test scoring empty CVE list."""
-        results = score_multiple_cves([])
-        assert results == []
-    
-    def test_score_with_failures(self, sample_cve_complete):
-        """Test scoring with some failures."""
-        cves = [sample_cve_complete, {"invalid": "data"}, sample_cve_complete]
-        results = score_multiple_cves(cves)
-        
-        # Should handle invalid CVE gracefully
-        assert len(results) == 3
-        assert results[0]["totalScore"] == 100
-        assert results[1]["totalScore"] == 0  # Invalid CVE gets zero score
-        assert results[2]["totalScore"] == 100
-
-
-class TestScoringConfiguration:
-    """Test scoring configuration and setup."""
-    
-    def test_scoring_config_usage(self):
-        """Test that scoring functions use configuration properly."""
-        # Test with actual config instead of mocking
-        cve = {}
-        cna = {
-            "descriptions": ["test"],
-            "affected": ["test"],
-            "references": ["test"]
-        }
-        
-        score = _calculate_foundational_completeness(cve, cna)
-        # Just verify that the function returns a valid score
-        assert isinstance(score, (int, float))
-        assert score >= 0
-
-
-if __name__ == "__main__":
-    pytest.main([__file__, "-v"])
diff --git a/src/cvedb/cna/tests/test_utils.py b/src/cvedb/cna/tests/test_utils.py
deleted file mode 100644
index 6f44213a877..00000000000
--- a/src/cvedb/cna/tests/test_utils.py
+++ /dev/null
@@ -1,336 +0,0 @@
-"""
-Tests for utils.py - Utility functions for the CNA Scorecard pipeline.
-"""
-import json
-import pytest
-from pathlib import Path
-from unittest.mock import patch, MagicMock
-
-from utils import (
-    setup_logging,
-    ensure_directory_exists,
-    load_json_file,
-    write_json_file,
-    sanitize_filename,
-    validate_cve_record,
-    extract_cna_short_name,
-    get_nested_value,
-    calculate_percentage,
-    format_date_string,
-    ProgressTracker
-)
-
-
-class TestSetupLogging:
-    """Tests for setup_logging function."""
-    
-    def test_returns_logger(self):
-        """Should return a logger instance."""
-        logger = setup_logging()
-        assert logger is not None
-    
-    def test_custom_log_level(self):
-        """Should accept custom log level."""
-        logger = setup_logging(log_level="DEBUG")
-        assert logger is not None
-
-
-class TestEnsureDirectoryExists:
-    """Tests for ensure_directory_exists function."""
-    
-    def test_creates_directory(self, tmp_path):
-        """Should create directory if it doesn't exist."""
-        new_dir = tmp_path / "new_dir"
-        assert not new_dir.exists()
-        
-        ensure_directory_exists(new_dir)
-        
-        assert new_dir.exists()
-        assert new_dir.is_dir()
-    
-    def test_creates_nested_directories(self, tmp_path):
-        """Should create nested directories."""
-        nested_dir = tmp_path / "level1" / "level2" / "level3"
-        
-        ensure_directory_exists(nested_dir)
-        
-        assert nested_dir.exists()
-    
-    def test_handles_existing_directory(self, tmp_path):
-        """Should not raise if directory exists."""
-        existing_dir = tmp_path / "existing"
-        existing_dir.mkdir()
-        
-        # Should not raise
-        ensure_directory_exists(existing_dir)
-        assert existing_dir.exists()
-
-
-class TestLoadJsonFile:
-    """Tests for load_json_file function."""
-    
-    def test_loads_valid_json(self, tmp_path):
-        """Should load valid JSON file."""
-        json_file = tmp_path / "test.json"
-        test_data = {"key": "value", "number": 42}
-        json_file.write_text(json.dumps(test_data))
-        
-        loaded = load_json_file(json_file)
-        
-        assert loaded == test_data
-    
-    def test_raises_on_invalid_json(self, tmp_path):
-        """Should raise on invalid JSON."""
-        json_file = tmp_path / "invalid.json"
-        json_file.write_text("not valid json {")
-        
-        with pytest.raises(Exception):
-            load_json_file(json_file)
-    
-    def test_raises_on_missing_file(self, tmp_path):
-        """Should raise on missing file."""
-        missing_file = tmp_path / "missing.json"
-        
-        with pytest.raises(Exception):
-            load_json_file(missing_file)
-
-
-class TestWriteJsonFile:
-    """Tests for write_json_file function."""
-    
-    def test_writes_json(self, tmp_path):
-        """Should write JSON file."""
-        json_file = tmp_path / "output.json"
-        test_data = {"key": "value"}
-        
-        write_json_file(test_data, json_file)
-        
-        assert json_file.exists()
-        loaded = json.loads(json_file.read_text())
-        assert loaded == test_data
-    
-    def test_custom_indent(self, tmp_path):
-        """Should respect custom indent."""
-        json_file = tmp_path / "output.json"
-        
-        write_json_file({"key": "value"}, json_file, indent=4)
-        
-        content = json_file.read_text()
-        assert "    " in content  # 4-space indent
-    
-    def test_creates_parent_directories(self, tmp_path):
-        """Should create parent directories."""
-        nested_file = tmp_path / "nested" / "dir" / "output.json"
-        
-        write_json_file({"key": "value"}, nested_file)
-        
-        assert nested_file.exists()
-
-
-class TestSanitizeFilename:
-    """Tests for sanitize_filename function."""
-    
-    def test_replaces_special_chars(self):
-        """Should replace special characters with underscore."""
-        # sanitize_filename replaces unsafe chars with underscore
-        assert sanitize_filename("file/name") == "file_name"
-        assert sanitize_filename("file:name") == "file_name"
-    
-    def test_keeps_alphanumeric(self):
-        """Should keep alphanumeric characters."""
-        assert sanitize_filename("ABC123") == "ABC123"
-    
-    def test_keeps_safe_chars(self):
-        """Should keep safe characters like - _ ."""
-        assert sanitize_filename("file-name_v1.txt") == "file-name_v1.txt"
-    
-    def test_handles_special_input(self):
-        """Should handle various special inputs."""
-        result = sanitize_filename("///")
-        assert result is not None  # Implementation-dependent
-
-
-class TestValidateCveRecord:
-    """Tests for validate_cve_record function."""
-    
-    def test_valid_record(self):
-        """Should return True for valid CVE record."""
-        cve = {
-            "cveMetadata": {
-                "cveId": "CVE-2024-0001",
-                "state": "PUBLISHED"
-            },
-            "containers": {
-                "cna": {
-                    "descriptions": [{"lang": "en", "value": "Test"}]
-                }
-            }
-        }
-        assert validate_cve_record(cve) is True
-    
-    def test_missing_cve_id(self):
-        """Should return False for missing CVE ID."""
-        cve = {
-            "cveMetadata": {"state": "PUBLISHED"},
-            "containers": {"cna": {}}
-        }
-        assert validate_cve_record(cve) is False
-    
-    def test_with_containers(self):
-        """Should return True when containers present."""
-        cve = {
-            "cveMetadata": {"cveId": "CVE-2024-0001"},
-            "containers": {"cna": {}}
-        }
-        # Based on actual implementation, this may be valid
-        assert validate_cve_record(cve) is True
-    
-    def test_various_states(self):
-        """Test behavior with different states."""
-        cve = {
-            "cveMetadata": {
-                "cveId": "CVE-2024-0001",
-                "state": "REJECTED"
-            },
-            "containers": {"cna": {}}
-        }
-        # Actual behavior depends on implementation
-        result = validate_cve_record(cve)
-        assert isinstance(result, bool)
-
-
-class TestExtractCnaShortName:
-    """Tests for extract_cna_short_name function."""
-    
-    def test_extracts_from_provider_metadata(self):
-        """Should extract from providerMetadata.shortName."""
-        cve = {
-            "containers": {
-                "cna": {
-                    "providerMetadata": {
-                        "shortName": "microsoft"
-                    }
-                }
-            }
-        }
-        assert extract_cna_short_name(cve) == "microsoft"
-    
-    def test_prefers_provider_metadata(self):
-        """Should prefer providerMetadata when available."""
-        cve = {
-            "cveMetadata": {
-                "assignerShortName": "fallback"
-            },
-            "containers": {
-                "cna": {
-                    "providerMetadata": {
-                        "shortName": "preferred"
-                    }
-                }
-            }
-        }
-        assert extract_cna_short_name(cve) == "preferred"
-    
-    def test_returns_none_when_missing(self):
-        """Should return None when no short name available."""
-        cve = {
-            "cveMetadata": {},
-            "containers": {"cna": {}}
-        }
-        assert extract_cna_short_name(cve) is None
-    
-    def test_empty_record(self):
-        """Should handle empty record."""
-        cve = {}
-        result = extract_cna_short_name(cve)
-        assert result is None
-
-
-class TestGetNestedValue:
-    """Tests for get_nested_value function."""
-    
-    def test_simple_path(self):
-        """Should retrieve value at simple path."""
-        data = {"key": "value"}
-        assert get_nested_value(data, ["key"]) == "value"
-    
-    def test_nested_path(self):
-        """Should retrieve value at nested path."""
-        data = {"level1": {"level2": "deep_value"}}
-        assert get_nested_value(data, ["level1", "level2"]) == "deep_value"
-    
-    def test_missing_key(self):
-        """Should return None for missing key."""
-        data = {"key": "value"}
-        assert get_nested_value(data, ["missing"]) is None
-    
-    def test_empty_path(self):
-        """Should return data for empty path."""
-        data = {"key": "value"}
-        assert get_nested_value(data, []) == data
-
-
-class TestCalculatePercentage:
-    """Tests for calculate_percentage function."""
-    
-    def test_normal_calculation(self):
-        """Should calculate percentage correctly."""
-        assert calculate_percentage(50, 100) == 50.0
-        assert calculate_percentage(1, 4) == 25.0
-    
-    def test_decimal_places(self):
-        """Should respect decimal places."""
-        assert calculate_percentage(1, 3, decimal_places=2) == 33.33
-        assert calculate_percentage(1, 3, decimal_places=0) == 33.0
-    
-    def test_zero_denominator(self):
-        """Should handle zero denominator."""
-        assert calculate_percentage(50, 0) == 0.0
-    
-    def test_zero_numerator(self):
-        """Should handle zero numerator."""
-        assert calculate_percentage(0, 100) == 0.0
-
-
-class TestFormatDateString:
-    """Tests for format_date_string function."""
-    
-    def test_iso_format(self):
-        """Should format ISO date string."""
-        result = format_date_string("2024-01-15T10:30:00.000Z")
-        assert "2024" in result
-        assert "01" in result or "Jan" in result
-    
-    def test_invalid_date(self):
-        """Should handle invalid date."""
-        result = format_date_string("not-a-date")
-        # Should return original or formatted error
-        assert result is not None
-    
-    def test_empty_string(self):
-        """Should handle empty string."""
-        result = format_date_string("")
-        assert result is not None
-
-
-class TestProgressTracker:
-    """Tests for ProgressTracker class."""
-    
-    def test_initialization(self):
-        """Should initialize with total."""
-        tracker = ProgressTracker(total=100, description="Test")
-        assert tracker is not None
-    
-    def test_update(self):
-        """Should update progress."""
-        tracker = ProgressTracker(total=100, description="Test")
-        tracker.update(10)
-        # Should not raise
-    
-    def test_multiple_updates(self):
-        """Should handle multiple updates."""
-        tracker = ProgressTracker(total=100, description="Test")
-        tracker.update(10)
-        tracker.update(20)
-        tracker.update(30)
-        # Should not raise
diff --git a/src/cvedb/cna/trends.py b/src/cvedb/cna/trends.py
deleted file mode 100644
index 61f7056d0fb..00000000000
--- a/src/cvedb/cna/trends.py
+++ /dev/null
@@ -1,369 +0,0 @@
-"""
-trends.py: Calculate and track performance trends for CNA Scorecard dashboard.
-
-This module processes CVE data to generate daily performance trends and identify
-top-improving CNAs over time for the Performance Trends dashboard.
-"""
-import json
-import logging
-from collections import defaultdict
-from datetime import datetime, timedelta
-from typing import Dict, List, Any, Optional, Tuple
-from pathlib import Path
-
-from .config import ScoringConfig
-from .utils import format_date_string
-from .scoring import score_cve_record
-
-logger = logging.getLogger('cnascorecard.trends')
-config = ScoringConfig()
-
-def calculate_daily_trends(cve_records: List[Dict[str, Any]], 
-                          output_dir: Path,
-                          analysis_days: int = 180) -> Dict[str, Any]:
-    """
-    Calculate daily performance trends for the last N days.
-    
-    Args:
-        cve_records: List of CVE records to analyze
-        output_dir: Directory to save trends data
-        analysis_days: Number of days to analyze (default: 180 = ~6 months)
-        
-    Returns:
-        Dictionary containing trends data
-    """
-    logger.info(f"Calculating daily trends for last {analysis_days} days...")
-    
-    # Calculate date range (ensure timezone-aware for comparison)
-    end_date = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)
-    start_date = end_date - timedelta(days=analysis_days)
-    
-    # Group CVEs by publication date
-    daily_cves = defaultdict(list)
-    
-    logger.info(f"Processing {len(cve_records)} CVE records for trends analysis")
-    logger.info(f"Analysis window: {start_date} to {end_date}")
-    
-    parsed_count = 0
-    valid_date_count = 0
-    in_window_count = 0
-    
-    for cve in cve_records:
-        try:
-            # Extract publication date
-            date_published = cve.get('cveMetadata', {}).get('datePublished', '')
-            if not date_published:
-                continue
-                
-            parsed_count += 1
-            
-            # Parse date (handle various formats) and make timezone-naive for comparison
-            pub_date = datetime.fromisoformat(date_published.replace('Z', '+00:00'))
-            pub_date = pub_date.replace(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)
-            
-            valid_date_count += 1
-            
-            # Debug first few dates
-            if valid_date_count <= 5:
-                logger.info(f"Sample CVE date: {date_published} -> parsed: {pub_date}")
-            
-            # Only include CVEs within our analysis window
-            if start_date <= pub_date <= end_date:
-                daily_cves[pub_date.strftime('%Y-%m-%d')].append(cve)
-                in_window_count += 1
-                
-        except (ValueError, TypeError) as e:
-            logger.debug(f"Skipping CVE with invalid date: {e}")
-            continue
-    
-    logger.info(f"Trends analysis stats: {parsed_count} had dates, {valid_date_count} parsed successfully, {in_window_count} within analysis window")
-    
-    logger.info(f"Found CVEs across {len(daily_cves)} days")
-    
-    # Calculate daily averages for each category
-    daily_trends = {}
-    
-    current_date = start_date
-    while current_date <= end_date:
-        date_str = current_date.strftime('%Y-%m-%d')
-        
-        if date_str in daily_cves:
-            day_scores = _calculate_daily_category_averages(daily_cves[date_str])
-        else:
-            # No CVEs on this date - use None values
-            day_scores = {
-                'root_cause_analysis': None,
-                'severity_and_impact': None, 
-                'software_identification': None,
-                'patch_information': None,
-                'total_cves': 0
-            }
-        
-        daily_trends[date_str] = day_scores
-        current_date += timedelta(days=1)
-    
-    # Calculate 7-day rolling averages
-    rolling_trends = _calculate_rolling_averages(daily_trends, window_days=7)
-    
-    # Save trends data
-    trends_data = {
-        'daily_trends': daily_trends,
-        'rolling_trends': rolling_trends,
-        'analysis_period': {
-            'start_date': start_date.strftime('%Y-%m-%d'),
-            'end_date': end_date.strftime('%Y-%m-%d'),
-            'total_days': analysis_days
-        },
-        'generated_at': datetime.now().isoformat()
-    }
-    
-    # Ensure output directory exists
-    output_dir.mkdir(parents=True, exist_ok=True)
-    
-    output_file = output_dir / 'performance_trends.json'
-    with open(output_file, 'w') as f:
-        json.dump(trends_data, f, indent=2)
-    
-    logger.info(f"Generated trends data: {output_file}")
-    return trends_data
-
-def calculate_top_improvers(cve_records: List[Dict[str, Any]], 
-                           output_dir: Path,
-                           top_n: int = 10) -> List[Dict[str, Any]]:
-    """
-    Identify CNAs with the most improvement over the analysis period.
-    
-    Args:
-        cve_records: List of CVE records to analyze
-        output_dir: Directory to save improvers data  
-        top_n: Number of top improvers to return
-        
-    Returns:
-        List of top improving CNAs with improvement metrics
-    """
-    logger.info("Calculating top improving CNAs...")
-    
-    # Group CVEs by CNA and date
-    cna_daily_scores = defaultdict(lambda: defaultdict(list))
-    
-    for cve in cve_records:
-        try:
-            # Score the CVE
-            scored_cve = score_cve_record(cve)
-            if not scored_cve:
-                continue
-                
-            cna_name = scored_cve.get('assigningCna', 'Unknown')
-            if cna_name == 'Unknown':
-                continue
-                
-            date_published = scored_cve.get('datePublished', '')
-            if not date_published:
-                continue
-                
-            # Parse date
-            pub_date = datetime.fromisoformat(date_published.replace('Z', '+00:00'))
-            date_str = pub_date.strftime('%Y-%m-%d')
-            
-            # Store scores by CNA and date
-            cna_daily_scores[cna_name][date_str].append(scored_cve['scoreBreakdown'])
-            
-        except (ValueError, TypeError) as e:
-            logger.debug(f"Skipping CVE in improvers analysis: {e}")
-            continue
-    
-    # Calculate improvement for each CNA
-    improvements = []
-    
-    for cna_name, daily_data in cna_daily_scores.items():
-        if len(daily_data) < 2:  # Need at least 2 data points
-            continue
-            
-        # Get sorted dates
-        sorted_dates = sorted(daily_data.keys())
-        
-        # Calculate averages for first and last periods (using 7-day windows)
-        first_period_scores = _get_period_average_scores(daily_data, sorted_dates[:7])
-        last_period_scores = _get_period_average_scores(daily_data, sorted_dates[-7:])
-        
-        if not first_period_scores or not last_period_scores:
-            continue
-            
-        # Calculate improvement in each category
-        category_improvements = {}
-        total_improvement = 0
-        
-        for category in ['root_cause_analysis', 'severity_and_impact', 
-                        'software_identification', 'patch_information']:
-            first_avg = first_period_scores.get(category, 0)
-            last_avg = last_period_scores.get(category, 0)
-            improvement = last_avg - first_avg
-            
-            category_improvements[category] = {
-                'first_period': first_avg,
-                'last_period': last_avg, 
-                'improvement': improvement
-            }
-            total_improvement += improvement
-        
-        # Only include CNAs with meaningful data volume
-        total_cves = sum(len(scores) for scores in daily_data.values())
-        if total_cves >= 5:  # Minimum threshold
-            improvements.append({
-                'cna_name': cna_name,
-                'total_improvement': total_improvement,
-                'category_improvements': category_improvements,
-                'total_cves_analyzed': total_cves,
-                'analysis_days': len(sorted_dates)
-            })
-    
-    # Sort by total improvement (descending)
-    improvements.sort(key=lambda x: x['total_improvement'], reverse=True)
-    top_improvers = improvements[:top_n]
-    
-    # Save improvers data
-    improvers_data = {
-        'top_improvers': top_improvers,
-        'generated_at': datetime.now().isoformat(),
-        'analysis_criteria': {
-            'minimum_cves': 5,
-            'top_n_count': top_n
-        }
-    }
-    
-    # Ensure output directory exists
-    output_dir.mkdir(parents=True, exist_ok=True)
-    
-    output_file = output_dir / 'top_improvers.json'
-    with open(output_file, 'w') as f:
-        json.dump(improvers_data, f, indent=2)
-    
-    logger.info(f"Generated top improvers data: {output_file}")
-    return top_improvers
-
-def _calculate_daily_category_averages(day_cves: List[Dict[str, Any]]) -> Dict[str, float]:
-    """Calculate average scores for each category for a single day's CVEs."""
-    if not day_cves:
-        return {
-            'root_cause_analysis': None,
-            'severity_and_impact': None,
-            'software_identification': None, 
-            'patch_information': None,
-            'total_cves': 0
-        }
-    
-    # Score all CVEs for this day
-    scored_cves = []
-    for cve in day_cves:
-        scored = score_cve_record(cve)
-        if scored and scored.get('scoreBreakdown'):
-            scored_cves.append(scored['scoreBreakdown'])
-    
-    if not scored_cves:
-        return {
-            'root_cause_analysis': None,
-            'severity_and_impact': None,
-            'software_identification': None,
-            'patch_information': None,
-            'total_cves': len(day_cves)
-        }
-    
-    # Calculate averages (convert to percentages)
-    averages = {}
-    for category in ['rootCauseAnalysis', 'severityAndImpactContext', 
-                     'softwareIdentification', 'patchinfo']:
-        scores = [score.get(category, 0) for score in scored_cves]
-        avg_score = sum(scores) / len(scores) if scores else 0
-        
-        # Convert to percentage based on max points
-        if category == 'rootCauseAnalysis':
-            avg_percentage = (avg_score / 15) * 100
-            key = 'root_cause_analysis'
-        elif category == 'severityAndImpactContext':
-            avg_percentage = (avg_score / 15) * 100  
-            key = 'severity_and_impact'
-        elif category == 'softwareIdentification':
-            avg_percentage = (avg_score / 10) * 100
-            key = 'software_identification'
-        else:  # patchinfo
-            avg_percentage = (avg_score / 10) * 100
-            key = 'patch_information'
-            
-        averages[key] = round(avg_percentage, 2)
-    
-    averages['total_cves'] = len(day_cves)
-    return averages
-
-def _calculate_rolling_averages(daily_trends: Dict[str, Dict], 
-                               window_days: int = 7) -> Dict[str, Dict]:
-    """Calculate rolling N-day averages from daily trends."""
-    rolling_data = {}
-    
-    sorted_dates = sorted(daily_trends.keys())
-    
-    for i, date in enumerate(sorted_dates):
-        if i < window_days - 1:
-            # Not enough data for full window
-            rolling_data[date] = None
-            continue
-        
-        # Get data for the window
-        window_dates = sorted_dates[i - window_days + 1:i + 1]
-        window_data = []
-        
-        for window_date in window_dates:
-            day_data = daily_trends[window_date]
-            if day_data and any(v is not None for k, v in day_data.items() if k != 'total_cves'):
-                window_data.append(day_data)
-        
-        if not window_data:
-            rolling_data[date] = None
-            continue
-        
-        # Calculate rolling averages
-        rolling_averages = {}
-        for category in ['root_cause_analysis', 'severity_and_impact',
-                        'software_identification', 'patch_information']:
-            values = [d[category] for d in window_data if d[category] is not None]
-            if values:
-                rolling_averages[category] = round(sum(values) / len(values), 2)
-            else:
-                rolling_averages[category] = None
-        
-        rolling_averages['total_cves'] = sum(d['total_cves'] for d in window_data)
-        rolling_averages['days_in_average'] = len(window_data)
-        
-        rolling_data[date] = rolling_averages
-    
-    return rolling_data
-
-def _get_period_average_scores(daily_data: Dict[str, List], 
-                              date_list: List[str]) -> Optional[Dict[str, float]]:
-    """Calculate average scores for a period (list of dates)."""
-    all_scores = []
-    
-    for date in date_list:
-        if date in daily_data:
-            all_scores.extend(daily_data[date])
-    
-    if not all_scores:
-        return None
-    
-    # Calculate averages for each category
-    averages = {}
-    for category in ['rootCauseAnalysis', 'severityAndImpactContext',
-                     'softwareIdentification', 'patchinfo']:
-        scores = [score.get(category, 0) for score in all_scores]
-        avg_score = sum(scores) / len(scores) if scores else 0
-        
-        # Map to standard names and convert to percentages
-        if category == 'rootCauseAnalysis':
-            averages['root_cause_analysis'] = (avg_score / 15) * 100
-        elif category == 'severityAndImpactContext':
-            averages['severity_and_impact'] = (avg_score / 15) * 100
-        elif category == 'softwareIdentification':
-            averages['software_identification'] = (avg_score / 10) * 100
-        else:  # patchinfo
-            averages['patch_information'] = (avg_score / 10) * 100
-    
-    return averages
diff --git a/src/cvedb/cna/utils.py b/src/cvedb/cna/utils.py
deleted file mode 100644
index f41b5d7586c..00000000000
--- a/src/cvedb/cna/utils.py
+++ /dev/null
@@ -1,266 +0,0 @@
-"""
-Utility functions for CNA Scorecard Pipeline.
-
-This module provides common utility functions including logging setup,
-file operations, and data validation helpers.
-"""
-import logging
-import logging.config
-from typing import Any, Dict, Optional
-from pathlib import Path
-import json
-import os
-
-from .config import LOGGING_CONFIG
-
-
-def setup_logging(log_level: str = "INFO") -> logging.Logger:
-    """
-    Set up logging configuration for the pipeline.
-    
-    Args:
-        log_level: Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
-        
-    Returns:
-        Configured logger instance
-    """
-    # Update log level in config
-    config = LOGGING_CONFIG.copy()
-    config['handlers']['console']['level'] = log_level
-    
-    # Configure logging
-    logging.config.dictConfig(config)
-    
-    # Return logger for the pipeline
-    return logging.getLogger('cnascorecard')
-
-
-def ensure_directory_exists(directory_path: Path) -> None:
-    """
-    Ensure a directory exists, creating it if necessary.
-    
-    Args:
-        directory_path: Path to the directory
-        
-    Raises:
-        OSError: If directory cannot be created
-    """
-    try:
-        directory_path.mkdir(parents=True, exist_ok=True)
-    except OSError as e:
-        raise OSError(f"Failed to create directory {directory_path}: {e}")
-
-
-def load_json_file(file_path: Path) -> Dict[str, Any]:
-    """
-    Load and parse a JSON file with proper error handling.
-    
-    Args:
-        file_path: Path to the JSON file
-        
-    Returns:
-        Parsed JSON data
-        
-    Raises:
-        FileNotFoundError: If file doesn't exist
-        ValueError: If JSON is invalid
-    """
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            return json.load(f)
-    except FileNotFoundError:
-        raise FileNotFoundError(f"JSON file not found: {file_path}")
-    except json.JSONDecodeError as e:
-        raise ValueError(f"Invalid JSON in file {file_path}: {e}")
-
-
-def write_json_file(data: Any, file_path: Path, indent: int = 2) -> None:
-    """
-    Write data to a JSON file with proper error handling.
-    
-    Args:
-        data: Data to write
-        file_path: Path to the output file
-        indent: JSON indentation level
-        
-    Raises:
-        OSError: If file cannot be written
-    """
-    try:
-        # Ensure parent directory exists
-        ensure_directory_exists(file_path.parent)
-        
-        with open(file_path, 'w', encoding='utf-8') as f:
-            json.dump(data, f, indent=indent, ensure_ascii=False)
-    except OSError as e:
-        raise OSError(f"Failed to write JSON file {file_path}: {e}")
-
-
-def sanitize_filename(filename: str) -> str:
-    """
-    Sanitize a filename by replacing invalid characters.
-    
-    Args:
-        filename: Original filename
-        
-    Returns:
-        Sanitized filename safe for filesystem use
-    """
-    # Replace invalid characters with underscores
-    invalid_chars = '<>:"/\\|?*'
-    sanitized = filename
-    for char in invalid_chars:
-        sanitized = sanitized.replace(char, '_')
-    
-    # Remove leading/trailing whitespace and dots
-    sanitized = sanitized.strip(' .')
-    
-    # Ensure filename is not empty
-    if not sanitized:
-        sanitized = "unknown"
-    
-    # Limit length to 255 characters (common filesystem limit)
-    if len(sanitized) > 255:
-        sanitized = sanitized[:255]
-    
-    return sanitized
-
-
-def validate_cve_record(cve: Dict[str, Any]) -> bool:
-    """
-    Validate that a CVE record has the minimum required structure.
-    
-    Args:
-        cve: CVE record dictionary
-        
-    Returns:
-        True if valid, False otherwise
-    """
-    if not isinstance(cve, dict):
-        return False
-    
-    # Check for required top-level structure
-    if "cveMetadata" not in cve:
-        return False
-    
-    cve_metadata = cve.get("cveMetadata", {})
-    if not isinstance(cve_metadata, dict):
-        return False
-    
-    # Check for required metadata fields
-    if "cveId" not in cve_metadata:
-        return False
-    
-    # Check for CNA container
-    containers = cve.get("containers", {})
-    if not isinstance(containers, dict):
-        return False
-    
-    cna = containers.get("cna", {})
-    if not isinstance(cna, dict):
-        return False
-    
-    return True
-
-
-def extract_cna_short_name(cve: Dict[str, Any]) -> Optional[str]:
-    """
-    Extract CNA short name from a CVE record.
-    
-    Args:
-        cve: CVE record dictionary
-        
-    Returns:
-        CNA short name if found, None otherwise
-    """
-    try:
-        containers = cve.get("containers", {})
-        cna = containers.get("cna", {})
-        provider = cna.get("providerMetadata", {})
-        return provider.get("shortName")
-    except (AttributeError, TypeError):
-        return None
-
-
-def get_nested_value(data: Dict[str, Any], path: list) -> Any:
-    """
-    Get a nested value from a dictionary using a path list.
-    
-    Args:
-        data: Dictionary to search
-        path: List of keys representing the path
-        
-    Returns:
-        Value at the path, or None if not found
-    """
-    current = data
-    try:
-        for key in path:
-            if isinstance(current, dict) and key in current:
-                current = current[key]
-            else:
-                return None
-        return current
-    except (TypeError, KeyError):
-        return None
-
-
-def calculate_percentage(numerator: int, denominator: int, decimal_places: int = 1) -> float:
-    """
-    Calculate percentage with proper handling of division by zero.
-    
-    Args:
-        numerator: Numerator value
-        denominator: Denominator value
-        decimal_places: Number of decimal places to round to
-        
-    Returns:
-        Percentage value, 0.0 if denominator is zero
-    """
-    if denominator == 0:
-        return 0.0
-    
-    percentage = (numerator / denominator) * 100
-    return round(percentage, decimal_places)
-
-
-def format_date_string(date_str: str) -> str:
-    """
-    Format a date string to ensure consistent format.
-    
-    Args:
-        date_str: Date string in various formats
-        
-    Returns:
-        Formatted date string in YYYY-MM-DD format, or original if parsing fails
-    """
-    if not date_str:
-        return ""
-    
-    # Handle ISO format with timezone
-    if 'T' in date_str:
-        date_str = date_str.split('T')[0]
-    
-    # Return first 10 characters (YYYY-MM-DD)
-    return date_str[:10] if len(date_str) >= 10 else date_str
-
-
-class ProgressTracker:
-    """Simple progress tracker for long-running operations."""
-    
-    def __init__(self, total: int, description: str = "Processing"):
-        self.total = total
-        self.current = 0
-        self.description = description
-        self.logger = logging.getLogger('cnascorecard.progress')
-    
-    def update(self, increment: int = 1) -> None:
-        """Update progress counter."""
-        self.current += increment
-        if self.current % max(1, self.total // 10) == 0 or self.current == self.total:
-            percentage = (self.current / self.total) * 100
-            self.logger.info(f"{self.description}: {self.current}/{self.total} ({percentage:.1f}%)")
-    
-    def finish(self) -> None:
-        """Mark progress as complete."""
-        self.logger.info(f"{self.description}: Complete ({self.total} items processed)")
diff --git a/src/cvedb/cna/v5_processor.py b/src/cvedb/cna/v5_processor.py
deleted file mode 100644
index 6d00f6214a0..00000000000
--- a/src/cvedb/cna/v5_processor.py
+++ /dev/null
@@ -1,827 +0,0 @@
-#!/usr/bin/env python3
-"""
-CVE V5 Processor Module
-Handles CVE V5 list data processing as the single source of truth for CNA analysis
-"""
-
-import json
-import subprocess
-import shutil
-from pathlib import Path
-from datetime import datetime
-from collections import defaultdict
-import sys
-from concurrent.futures import ProcessPoolExecutor
-from multiprocessing import cpu_count
-
-# Add data folder to path for imports
-sys.path.append(str(Path(__file__).parent.parent.parent / 'data'))
-
-from cvedb.ingest.download_cve_data import CVEDataDownloader
-
-
-class CVEV5Processor:
-    """Processes CVE V5 list data for authoritative CNA analysis"""
-    
-    def __init__(self, base_dir, cache_dir, data_dir, quiet=False, force=False):
-        self.quiet = quiet
-        self.force = force
-        self.base_dir = Path(base_dir)
-        self.cache_dir = Path(cache_dir)
-        self.data_dir = Path(data_dir)
-        self.current_year = datetime.now().year
-        self.v5_cache_dir = self.cache_dir / 'cvelistV5'
-        # Optional EPSS enrichment mapping, keyed by CVE ID
-        self.epss_mapping = {}
-        # KEV CVE set for threat intelligence tracking
-        self.kev_cve_set = set()
-        # Load threat intelligence data
-        self._load_epss_mapping()
-        self._load_kev_set()
-
-    def get_current_commit(self):
-        """Get the current commit hash of the CVE V5 repository"""
-        if not self.v5_cache_dir.exists():
-            return None
-        try:
-            result = subprocess.run(
-                ['git', 'rev-parse', 'HEAD'],
-                cwd=self.v5_cache_dir,
-                capture_output=True,
-                text=True,
-                timeout=10
-            )
-            if result.returncode == 0:
-                return result.stdout.strip()
-        except: pass
-        return None
-
-    def _load_epss_mapping(self):
-        """Load EPSS mapping from cache if available.
-
-        Uses the same cache directory as CVEDataDownloader to avoid
-        duplicate downloads. If EPSS data is unavailable or parsing
-        fails, this method leaves epss_mapping empty and continues
-        silently so that CNA analysis is not blocked.
-        """
-        try:
-            downloader = CVEDataDownloader(cache_dir=self.cache_dir, quiet=True)
-            epss_json_path = downloader.epss_parsed_file
-            # If parsed file does not exist yet, attempt to parse from CSV
-            if not epss_json_path.exists():
-                epss_json_path = downloader.parse_epss_csv()
-
-            if epss_json_path and Path(epss_json_path).exists():
-                with open(epss_json_path, 'r', encoding='utf-8') as f:
-                    self.epss_mapping = json.load(f)
-                if not self.quiet:
-                    print(f"  ✅ Loaded EPSS mapping for {len(self.epss_mapping):,} CVEs")
-            else:
-                if not self.quiet:
-                    print("  ⚠️  EPSS mapping not available; proceeding without enrichment")
-        except Exception as e:
-            if not self.quiet:
-                print(f"  ⚠️  Could not load EPSS mapping: {e}")
-            self.epss_mapping = {}
-
-    def _load_kev_set(self):
-        """Load KEV CVE IDs into a set for fast lookup"""
-        kev_file = self.cache_dir / 'known_exploited_vulnerabilities_parsed.json'
-        if kev_file.exists():
-            try:
-                with open(kev_file, 'r') as f:
-                    kev_data = json.load(f)
-                self.kev_cve_set = set(kev_data.keys())
-                if not self.quiet:
-                    print(f"  ✅ Loaded KEV set with {len(self.kev_cve_set):,} CVEs")
-            except Exception as e:
-                if not self.quiet:
-                    print(f"  ⚠️  Could not load KEV data: {e}")
-                self.kev_cve_set = set()
-        else:
-            if not self.quiet:
-                print("  ⚠️  KEV data not available; proceeding without KEV enrichment")
-
-        # CNA type classification patterns
-        self.cna_type_patterns = {
-            'Vendor': [
-                'microsoft', 'apple', 'google', 'oracle', 'cisco', 'adobe', 'ibm',
-                'redhat', 'canonical', 'suse', 'debian', 'ubuntu', 'mozilla',
-                'vmware', 'intel', 'amd', 'nvidia', 'qualcomm', 'samsung',
-                'huawei', 'lenovo', 'hp', 'dell', 'netapp', 'citrix'
-            ],
-            'Security Researcher': [
-                'patchstack', 'wordfence', 'vuldb', 'zerodayinitiative', 'trendmicro',
-                'rapid7', 'tenable', 'qualys', 'checkmarx', 'veracode'
-            ],
-            'CERT': [
-                'cert', 'cisa', 'ncsc', 'jpcert', 'kr-cert', 'au-cert',
-                'ca-cert', 'de-cert', 'fr-cert', 'nl-cert'
-            ],
-            'Government': [
-                'cisa', 'nist', 'dhs', 'gov', 'mil', 'defense',
-                'homeland', 'treasury', 'energy', 'state'
-            ],
-            'Academic': [
-                'edu', 'university', 'college', 'research', 'institute',
-                'academic', 'school', 'campus'
-            ],
-            'Open Source': [
-                'github', 'gitlab', 'apache', 'eclipse', 'linux', 'kernel',
-                'gnu', 'fsf', 'oss', 'opensource'
-            ]
-        }
-        
-    def clone_or_update_cve_v5_repo(self):
-        """Clone or update the CVE V5 repository with shallow clone"""
-        print(f"  📥 Setting up CVE V5 repository...")
-        
-        if self.v5_cache_dir.exists():
-            # Check if it's a valid git repository
-            git_dir = self.v5_cache_dir / '.git'
-            if not git_dir.exists():
-                print(f"    ⚠️ Invalid git repository, re-cloning...")
-                shutil.rmtree(self.v5_cache_dir)
-                return self._clone_fresh_repo()
-            
-            print(f"    🔄 Updating existing CVE V5 repository...")
-            try:
-                # First try a simple git pull (no --depth flag for existing repos)
-                result = subprocess.run(
-                    ['git', 'pull', 'origin', 'main'],
-                    cwd=self.v5_cache_dir,
-                    capture_output=True,
-                    text=True,
-                    timeout=300
-                )
-                if result.returncode == 0:
-                    print(f"    ✅ Successfully updated CVE V5 repository")
-                    return True
-                else:
-                    # Try to reset and pull if there are conflicts
-                    print(f"    🔄 Pull failed, trying reset and pull...")
-                    reset_result = subprocess.run(
-                        ['git', 'reset', '--hard', 'origin/main'],
-                        cwd=self.v5_cache_dir,
-                        capture_output=True,
-                        text=True,
-                        timeout=60
-                    )
-                    if reset_result.returncode == 0:
-                        pull_result = subprocess.run(
-                            ['git', 'pull', 'origin', 'main'],
-                            cwd=self.v5_cache_dir,
-                            capture_output=True,
-                            text=True,
-                            timeout=300
-                        )
-                        if pull_result.returncode == 0:
-                            print(f"    ✅ Successfully updated CVE V5 repository after reset")
-                            return True
-                    
-                    # Only re-clone as last resort
-                    print(f"    ⚠️ All update attempts failed, re-cloning as last resort...")
-                    print(f"    📝 Git pull error: {result.stderr}")
-                    shutil.rmtree(self.v5_cache_dir)
-                    return self._clone_fresh_repo()
-                    
-            except subprocess.TimeoutExpired:
-                print(f"    ⏰ Git pull timed out, repository may be up to date")
-                return True  # Don't re-clone on timeout, assume it's working
-            except Exception as e:
-                print(f"    ⚠️ Update failed with exception: {e}")
-                # Only re-clone if it's a critical error
-                if "not a git repository" in str(e).lower():
-                    shutil.rmtree(self.v5_cache_dir)
-                    return self._clone_fresh_repo()
-                else:
-                    print(f"    📝 Assuming repository is usable despite error")
-                    return True
-        else:
-            return self._clone_fresh_repo()
-    
-    def _clone_fresh_repo(self):
-        """Clone fresh CVE V5 repository"""
-        print(f"    📦 Cloning CVE V5 repository (shallow clone)...")
-        try:
-            # Ensure cache directory exists
-            self.cache_dir.mkdir(parents=True, exist_ok=True)
-            
-            # Shallow clone with depth=1 to minimize data transfer
-            result = subprocess.run([
-                'git', 'clone', 
-                '--depth=1',
-                '--single-branch',
-                'https://github.com/CVEProject/cvelistV5.git',
-                str(self.v5_cache_dir)
-            ], capture_output=True, text=True, timeout=600)
-            
-            if result.returncode == 0:
-                print(f"    ✅ Successfully cloned CVE V5 repository")
-                return True
-            else:
-                print(f"    ❌ Failed to clone CVE V5 repository: {result.stderr}")
-                return False
-                
-        except subprocess.TimeoutExpired:
-            print(f"    ❌ Clone operation timed out")
-            return False
-        except Exception as e:
-            print(f"    ❌ Clone failed: {e}")
-            return False
-    
-    def get_repo_stats(self):
-        """Get basic statistics about the cloned repository"""
-        if not self.v5_cache_dir.exists():
-            return None
-            
-        cves_dir = self.v5_cache_dir / 'cves'
-        if not cves_dir.exists():
-            return None
-            
-        stats = {
-            'total_years': 0,
-            'total_cves': 0,
-            'years_available': []
-        }
-        
-        for year_dir in sorted(cves_dir.iterdir()):
-            if year_dir.is_dir() and year_dir.name.isdigit():
-                year = int(year_dir.name)
-                stats['years_available'].append(year)
-                stats['total_years'] += 1
-                
-                # Count CVE files in this year (handle nested structure)
-                year_cve_count = 0
-                for subdir in year_dir.iterdir():
-                    if subdir.is_dir():
-                        cve_files = list(subdir.glob('CVE-*.json'))
-                        year_cve_count += len(cve_files)
-                stats['total_cves'] += year_cve_count
-        
-        return stats
-    
-    def classify_cna_type(self, org_id, short_name):
-        """Classify CNA type based on organization ID and short name"""
-        # Combine org_id and short_name for pattern matching
-        search_text = f"{org_id} {short_name}".lower()
-        
-        # Special cases first
-        if 'mitre' in search_text:
-            return ['Program']  # MITRE is the CVE Program
-        
-        # Check patterns for each type
-        matched_types = []
-        for cna_type, patterns in self.cna_type_patterns.items():
-            for pattern in patterns:
-                if pattern in search_text:
-                    matched_types.append(cna_type)
-                    break  # Only add each type once
-        
-        # If no specific type matched, use comprehensive inference patterns
-        if not matched_types:
-            # Academic institutions
-            if any(domain in search_text for domain in ['.edu', 'university', 'college', 'institut', 'research', 'academic', 'school']):
-                matched_types.append('Academic')
-            # Government and military
-            elif any(gov in search_text for gov in ['.gov', '.mil', 'government', 'cisa', 'nist', 'dhs', 'defense', 'homeland']):
-                matched_types.append('Government')
-            # CERT and security organizations
-            elif any(cert in search_text for cert in ['cert', 'csirt', 'security', 'cyber']):
-                matched_types.append('CERT')
-            # Open source projects and repositories
-            elif any(oss in search_text for oss in ['github', 'gitlab', 'apache', 'linux', 'kernel', 'gnu', 'eclipse', 'mozilla', 'debian', 'ubuntu', 'redhat', 'canonical', 'suse']):
-                matched_types.append('Open Source')
-            # Security researchers and vulnerability research
-            elif any(sec in search_text for sec in ['vulnerability', 'exploit', 'security', 'research', 'bug', 'bounty', 'pentest', 'audit']):
-                matched_types.append('Security Researcher')
-            # Technology vendors (broad patterns)
-            elif any(vendor in search_text for vendor in ['corp', 'inc', 'ltd', 'llc', 'gmbh', 'co', 'company', 'tech', 'software', 'systems', 'solutions', 'technologies']):
-                matched_types.append('Vendor')
-            # Email domain-based classification
-            elif '@' in search_text:
-                domain = search_text.split('@')[-1] if '@' in search_text else ''
-                if '.edu' in domain or 'university' in domain:
-                    matched_types.append('Academic')
-                elif '.gov' in domain or '.mil' in domain:
-                    matched_types.append('Government')
-                elif any(tech in domain for tech in ['.com', '.org', '.net', 'tech', 'software', 'systems']):
-                    matched_types.append('Vendor')
-                else:
-                    matched_types.append('Other')
-            else:
-                # Final fallback - assume most are vendors/organizations
-                matched_types.append('Vendor')
-        
-        return matched_types if matched_types else ['Vendor']
-    
-    def calculate_enhanced_statistics(self, cna_list):
-        """Calculate enhanced statistics for CNA analysis"""
-        if not cna_list:
-            return {}
-        
-        total_cves = sum(cna['count'] for cna in cna_list)
-        total_cnas = len(cna_list)
-        
-        # Market concentration (top 5 CNAs)
-        top_5_cves = sum(cna['count'] for cna in cna_list[:5])
-        market_concentration = (top_5_cves / total_cves * 100) if total_cves > 0 else 0
-        
-        # High volume CNAs (1000+ CVEs)
-        high_volume_cnas = len([cna for cna in cna_list if cna['count'] >= 1000])
-        
-        # Activity statistics
-        active_cnas = len([cna for cna in cna_list if cna['activity_status'] == 'Active'])
-        inactive_cnas = total_cnas - active_cnas
-        
-        # Years active statistics
-        years_active_list = [cna['years_active'] for cna in cna_list if cna.get('years_active', 0) > 0]
-        median_years_active = 0
-        if years_active_list:
-            years_active_list.sort()
-            n = len(years_active_list)
-            median_years_active = years_active_list[n // 2] if n % 2 == 1 else (years_active_list[n // 2 - 1] + years_active_list[n // 2]) / 2
-        
-        # Type distribution
-        type_counts = defaultdict(int)
-        for cna in cna_list:
-            cna_types = cna.get('cna_types', ['Other'])
-            for cna_type in cna_types:
-                type_counts[cna_type] += 1
-        
-        # Convert to format expected by JavaScript
-        # JavaScript expects: type_distribution.sorted_types and type_distribution.type_percentages
-        sorted_types = []
-        type_percentages = {}
-        
-        # Sort by count (descending)
-        sorted_type_items = sorted(type_counts.items(), key=lambda x: x[1], reverse=True)
-        
-        for cna_type, count in sorted_type_items:
-            percentage = (count / total_cnas * 100) if total_cnas > 0 else 0
-            sorted_types.append([cna_type, count])  # JavaScript expects [type, count] pairs
-            type_percentages[cna_type] = round(percentage, 1)
-        
-        # Create the structure expected by JavaScript
-        type_distribution = {
-            'sorted_types': sorted_types,
-            'type_percentages': type_percentages
-        }
-        
-        return {
-            'total_cves': total_cves,
-            'total_cnas': total_cnas,
-            'active_cnas': active_cnas,
-            'inactive_cnas': inactive_cnas,
-            'high_volume_cnas': high_volume_cnas,
-            'market_concentration': round(market_concentration, 1),
-            'median_years_active': round(median_years_active, 1),
-            'type_distribution': type_distribution
-        }
-    
-    def parse_cve_v5_record(self, cve_file_path):
-        """Parse a single CVE V5 record and extract CNA information and metrics"""
-        try:
-            with open(cve_file_path, 'r', encoding='utf-8') as f:
-                cve_data = json.load(f)
-            
-            # Extract CVE metadata
-            cve_metadata = cve_data.get('cveMetadata', {})
-            cve_id = cve_metadata.get('cveId', '')
-            state = cve_metadata.get('state', '')
-            
-            # Skip REJECTED CVEs
-            if state == 'REJECTED':
-                return None
-            
-            # Extract CNA information from V5 format
-            assigner_org_id = cve_metadata.get('assignerOrgId', '')
-            assigner_short_name = cve_metadata.get('assignerShortName', '')
-            date_published = cve_metadata.get('datePublished', '')
-            date_updated = cve_metadata.get('dateUpdated', '')
-            pub_date = date_published if date_published else date_updated
-            
-            # Extract metrics (CVSS) and CWE from CNA container
-            cna_container = cve_data.get('containers', {}).get('cna', {})
-            metrics = cna_container.get('metrics', [])
-            cwes = []
-            for weakness in cna_container.get('weaknesses', []):
-                for desc in weakness.get('description', []):
-                    if desc.get('lang') == 'en':
-                        cwes.append(desc.get('value'))
-            
-            record = {
-                'cve_id': cve_id,
-                'assigner_org_id': assigner_org_id,
-                'assigner_short_name': assigner_short_name,
-                'publication_date': pub_date,
-                'year': int(cve_id.split('-')[1]) if cve_id.startswith('CVE-') else None,
-                'metrics': metrics,
-                'cwes': [c for c in cwes if c and c.startswith('CWE-')]
-            }
-
-            # EPSS enrichment
-            if cve_id and self.epss_mapping:
-                epss = self.epss_mapping.get(cve_id)
-                if epss:
-                    record['epss_score'] = epss.get('epss_score')
-                    record['epss_percentile'] = epss.get('epss_percentile')
-
-            return record
-            
-        except Exception as e:
-            if not self.quiet:
-                print(f"    ⚠️ Error parsing {cve_file_path}: {e}")
-            return None
-    
-    def process_all_cves_single_pass(self):
-        """Process ALL CVE records in a single pass using multi-processing."""
-        print(f"  📊 Processing all CVE files in parallel...")
-        
-        cves_dir = self.v5_cache_dir / 'cves'
-        all_cve_files = []
-        for year_dir in sorted(cves_dir.iterdir()):
-            if year_dir.is_dir() and year_dir.name.isdigit():
-                for subdir in year_dir.iterdir():
-                    if subdir.is_dir():
-                        all_cve_files.extend([str(p) for p in subdir.glob('CVE-*.json')])
-        
-        total_files = len(all_cve_files)
-        print(f"  📊 Found {total_files:,} total CVE files to process")
-        
-        # Initialize CNA stats
-        all_cna_stats = defaultdict(lambda: {
-            'count': 0, 'cves': [],
-            'first_date': None, 'last_date': None,
-            'first_year': None, 'last_year': None,
-            'assigner_org_id': '', 'assigner_short_name': '',
-            'cves_by_pub_year': defaultdict(int),
-            'kev_count': 0, 'epss_high_count': 0, 'epss_elevated_count': 0,
-            'year_stats': defaultdict(lambda: {
-                'count': 0, 'kev_count': 0, 'epss_high_count': 0,
-                'severity_counts': defaultdict(int), 'cwe_counts': defaultdict(int),
-                'cves': []
-            })
-        })
-
-        # Process in parallel using a generator to keep memory usage low
-        # Note: We pass strings to avoid large pickle objects
-        num_workers = max(1, cpu_count() - 1)
-        print(f"    🚀 Using {num_workers} worker processes")
-        
-        processed = 0
-        with ProcessPoolExecutor(max_workers=num_workers) as executor:
-            # Map parse_cve_v5_record to all files
-            # Note: We use a larger chunksize for small JSON files
-            for cve_record in executor.map(self.parse_cve_v5_record, all_cve_files, chunksize=500):
-                processed += 1
-                if processed % 25000 == 0:
-                    print(f"    📈 Parsed {processed:,}/{total_files:,} files...")
-                
-                if not cve_record or not cve_record.get('assigner_org_id'):
-                    continue
-                    
-                org_id = cve_record['assigner_org_id']
-                cve_id = cve_record['cve_id']
-                pub_date = cve_record['publication_date']
-                pub_year = None
-                if pub_date:
-                    try:
-                        pub_year = datetime.fromisoformat(pub_date.replace('Z', '+00:00')).year
-                    except: pass
-                
-                stats = all_cna_stats[org_id]
-                stats['count'] += 1
-                stats['assigner_org_id'] = org_id
-                stats['assigner_short_name'] = cve_record['assigner_short_name']
-                
-                if pub_year:
-                    stats['cves_by_pub_year'][pub_year] += 1
-                    y_stats = stats['year_stats'][pub_year]
-                    y_stats['count'] += 1
-                    y_stats['cves'].append(cve_id)
-                    
-                    for metric in cve_record.get('metrics', []):
-                        cvss = metric.get('cvssData', {})
-                        severity = cvss.get('baseSeverity') or cvss.get('severity')
-                        if severity:
-                            y_stats['severity_counts'][severity.upper()] += 1
-                    
-                    for cwe in cve_record.get('cwes', []):
-                        y_stats['cwe_counts'][cwe] += 1
-                
-                if pub_date:
-                    if not stats['first_date'] or pub_date < stats['first_date']:
-                        stats['first_date'] = pub_date
-                        stats['first_year'] = pub_year
-                    if not stats['last_date'] or pub_date > stats['last_date']:
-                        stats['last_date'] = pub_date
-                        stats['last_year'] = pub_year
-                
-                if cve_id in self.kev_cve_set:
-                    stats['kev_count'] += 1
-                    if pub_year: stats['year_stats'][pub_year]['kev_count'] += 1
-                
-                epss_score = cve_record.get('epss_score', 0)
-                if epss_score > 0.5:
-                    stats['epss_high_count'] += 1
-                    if pub_year: stats['year_stats'][pub_year]['epss_high_count'] += 1
-                if epss_score > 0.1:
-                    stats['epss_elevated_count'] += 1
-
-        print(f"  ✅ Processed {processed:,}({total_files:,}) files, found {len(all_cna_stats):,} unique CNAs")
-        return dict(all_cna_stats)
-
-    def process_year_data(self, year):
-        """Process all CVE records for a specific year"""
-        print(f"    📅 Processing CVE data for year {year}...")
-        
-        year_dir = self.v5_cache_dir / 'cves' / str(year)
-        if not year_dir.exists():
-            print(f"    ⚠️ No data found for year {year}")
-            return {}
-        
-        cna_stats = defaultdict(lambda: {
-            'count': 0,
-            'cves': [],
-            'first_date': None,
-            'last_date': None,
-            'assigner_org_id': '',
-            'assigner_short_name': ''
-        })
-        
-        # CVE V5 has nested directory structure (0xxx, 1xxx, etc.)
-        cve_files = []
-        for subdir in year_dir.iterdir():
-            if subdir.is_dir():
-                cve_files.extend(subdir.glob('CVE-*.json'))
-        
-        total_files = len(cve_files)
-        processed = 0
-        
-        if not self.quiet:
-            print(f"    📊 Found {total_files} CVE files for {year}")
-        
-        for cve_file in cve_files:
-            cve_record = self.parse_cve_v5_record(cve_file)
-            if cve_record and cve_record['assigner_org_id']:
-                org_id = cve_record['assigner_org_id']
-                
-                # Update CNA statistics
-                cna_stats[org_id]['count'] += 1
-                cna_stats[org_id]['cves'].append(cve_record['cve_id'])
-                cna_stats[org_id]['assigner_org_id'] = org_id
-                cna_stats[org_id]['assigner_short_name'] = cve_record['assigner_short_name']
-                
-                # Track date ranges
-                pub_date = cve_record['publication_date']
-                if pub_date:
-                    if not cna_stats[org_id]['first_date'] or pub_date < cna_stats[org_id]['first_date']:
-                        cna_stats[org_id]['first_date'] = pub_date
-                    if not cna_stats[org_id]['last_date'] or pub_date > cna_stats[org_id]['last_date']:
-                        cna_stats[org_id]['last_date'] = pub_date
-            
-            processed += 1
-            if processed % 1000 == 0 and not self.quiet:
-                print(f"    📈 Processed {processed}/{total_files} files...")
-        
-        if not self.quiet:
-            print(f"    ✅ Processed {processed} CVE files, found {len(cna_stats)} CNAs for {year}")
-        return dict(cna_stats)
-    
-    def generate_comprehensive_cna_analysis(self):
-        """Generate comprehensive and current year CNA analysis in a single pass"""
-        print(f"  🏢 Starting single-pass CNA analysis...")
-        
-        if not self.clone_or_update_cve_v5_repo():
-            return None
-        
-        # Check if we need to rebuild
-        commit_file = self.cache_dir / 'cvelistV5_commit.txt'
-        current_commit = self.get_current_commit()
-        output_file = self.data_dir / 'cna_analysis.json'
-        stats_cache = self.cache_dir / 'cna_stats_cache.pkl'
-        
-        if not self.force and current_commit and commit_file.exists() and output_file.exists():
-            with open(commit_file, 'r') as f:
-                last_commit = f.read().strip()
-            if last_commit == current_commit:
-                print(f"  ✅ CNA analysis is up to date (commit {current_commit[:8]})")
-                if stats_cache.exists():
-                    try:
-                        import pickle
-                        with open(stats_cache, 'rb') as f:
-                            self.all_cna_stats = pickle.load(f)
-                    except: pass
-                
-                with open(output_file, 'r') as f:
-                    return json.load(f)
-
-        repo_stats = self.get_repo_stats()
-        if not repo_stats: return None
-            
-        all_cna_stats = self.process_all_cves_single_pass()
-        self.all_cna_stats = all_cna_stats  # Store for use by current year generator
-        
-        # Cache the stats for incremental runs
-        try:
-            import pickle
-            with open(stats_cache, 'wb') as f:
-                pickle.dump(dict(all_cna_stats), f)
-        except: pass
-
-        cna_list = []
-        for org_id, stats in all_cna_stats.items():
-            first_year = stats['first_year']
-            last_year = stats['last_year']
-            years_active = max(1, (last_year - first_year + 1)) if first_year and last_year else 1
-            
-            days_since_last = 365
-            if stats['last_date']:
-                try:
-                    last_date = datetime.fromisoformat(stats['last_date'].replace('Z', '+00:00'))
-                    days_since_last = (datetime.now(last_date.tzinfo) - last_date).days
-                except: pass
-
-            cna_list.append({
-                'name': stats['assigner_short_name'] or org_id,
-                'assigner_org_id': org_id,
-                'count': stats['count'],
-                'years_active': years_active,
-                'first_cve_year': first_year,
-                'last_cve_year': last_year,
-                'first_cve_date': stats['first_date'],
-                'last_cve_date': stats['last_date'],
-                'days_since_last_cve': days_since_last,
-                'activity_status': 'Active' if days_since_last < 365 else 'Inactive',
-                'is_official': True,
-                'cna_types': self.classify_cna_type(org_id, stats['assigner_short_name']),
-                'cves_by_year': dict(stats['cves_by_pub_year']),
-                'kev_count': stats['kev_count'],
-                'epss_high_count': stats['epss_high_count'],
-                'epss_elevated_count': stats['epss_elevated_count'],
-                'severity_distribution': {}, 'top_cwe_types': {}, 'top_cwes': []
-            })
-        
-        cna_list.sort(key=lambda x: x['count'], reverse=True)
-        for i, cna in enumerate(cna_list): cna['rank'] = i + 1
-        
-        enhanced_stats = self.calculate_enhanced_statistics(cna_list)
-        repo_stats['total_cves'] = sum(cna['count'] for cna in cna_list)
-        
-        comprehensive_data = {
-            'generated_at': datetime.now().isoformat(),
-            'source': 'CVE V5 List (Authoritative)',
-            'repository_stats': repo_stats,
-            'total_cnas': len(cna_list),
-            'active_cnas': enhanced_stats.get('active_cnas', 0),
-            'inactive_cnas': enhanced_stats.get('inactive_cnas', 0),
-            'official_cnas': len(cna_list),
-            'unofficial_cnas': 0,
-            'high_volume_cnas': enhanced_stats.get('high_volume_cnas', 0),
-            'market_concentration': enhanced_stats.get('market_concentration', 0),
-            'median_years_active': enhanced_stats.get('median_years_active', 0),
-            'type_distribution': enhanced_stats.get('type_distribution', []),
-            'cna_list': cna_list,
-            'cna_assigners': cna_list
-        }
-        
-        output_file = self.data_dir / 'cna_analysis.json'
-        with open(output_file, 'w') as f:
-            json.dump(comprehensive_data, f, indent=2)
-        
-        # Update commit hash after success
-        if current_commit:
-            commit_file = self.cache_dir / 'cvelistV5_commit.txt'
-            with open(commit_file, 'w') as f:
-                f.write(current_commit)
-        
-        print(f"  📄 Generated comprehensive CNA analysis with {len(cna_list)} CNAs")
-        return comprehensive_data
-    
-    def process_current_year_by_publication_date(self):
-        """Process CVEs from ALL years, filtering by current year publication date"""
-        print(f"    🔍 Scanning all CVE years for {self.current_year} publications...")
-        
-        cves_dir = self.v5_cache_dir / 'cves'
-        if not cves_dir.exists():
-            print(f"    ❌ CVEs directory not found")
-            return {}
-        
-        cna_stats = defaultdict(lambda: {
-            'count': 0,
-            'cves': [],
-            'first_date': None,
-            'last_date': None,
-            'assigner_org_id': '',
-            'assigner_short_name': ''
-        })
-        
-        total_processed = 0
-        current_year_cves = 0
-        
-        # Scan all year directories
-        for year_dir in sorted(cves_dir.iterdir()):
-            if not year_dir.is_dir() or not year_dir.name.isdigit():
-                continue
-                
-            year = int(year_dir.name)
-            if not self.quiet:
-                print(f"    📂 Scanning CVE-{year}-* files for {self.current_year} publications...")
-            
-            # Get all CVE files in this year directory (handle nested structure)
-            cve_files = []
-            for subdir in year_dir.iterdir():
-                if subdir.is_dir():
-                    cve_files.extend(subdir.glob('CVE-*.json'))
-            
-            year_current_cves = 0
-            for cve_file in cve_files:
-                cve_record = self.parse_cve_v5_record(cve_file)
-                if cve_record and cve_record['assigner_org_id']:
-                    # Check if this CVE was published in the current year
-                    pub_date = cve_record['publication_date']
-                    if pub_date:
-                        try:
-                            pub_year = datetime.fromisoformat(pub_date.replace('Z', '+00:00')).year
-                            if pub_year == self.current_year:
-                                # This CVE was published in current year
-                                org_id = cve_record['assigner_org_id']
-                                
-                                # Update CNA statistics
-                                cna_stats[org_id]['count'] += 1
-                                cna_stats[org_id]['cves'].append(cve_record['cve_id'])
-                                cna_stats[org_id]['assigner_org_id'] = org_id
-                                cna_stats[org_id]['assigner_short_name'] = cve_record['assigner_short_name']
-                                
-                                # Track date ranges
-                                if not cna_stats[org_id]['first_date'] or pub_date < cna_stats[org_id]['first_date']:
-                                    cna_stats[org_id]['first_date'] = pub_date
-                                if not cna_stats[org_id]['last_date'] or pub_date > cna_stats[org_id]['last_date']:
-                                    cna_stats[org_id]['last_date'] = pub_date
-                                
-                                year_current_cves += 1
-                                current_year_cves += 1
-                        except Exception:
-                            # Skip CVEs with invalid dates
-                            pass
-                
-                total_processed += 1
-                if total_processed % 5000 == 0 and not self.quiet:
-                    print(f"    📈 Processed {total_processed} files, found {current_year_cves} {self.current_year} publications...")
-            
-            if year_current_cves > 0 and not self.quiet:
-                print(f"    ✅ Found {year_current_cves} CVEs published in {self.current_year} from CVE-{year}-* files")
-        
-        if not self.quiet:
-            print(f"    🎯 Total: {current_year_cves} CVEs published in {self.current_year}, from {len(cna_stats)} CNAs")
-        return dict(cna_stats)
-    
-    def generate_current_year_analysis(self):
-        """Generate current year CNA analysis from already processed single-pass data"""
-        print(f"  📅 Generating {self.current_year} CNA analysis from single-pass data...")
-        
-        if not hasattr(self, 'all_cna_stats'):
-            print("  ⚠️ No processed data found; performing full analysis...")
-            self.generate_comprehensive_cna_analysis()
-            
-        current_year_cnas = []
-        for org_id, stats in self.all_cna_stats.items():
-            y_stats = stats['year_stats'].get(self.current_year)
-            if not y_stats or y_stats['count'] == 0:
-                continue
-                
-            y_cna = {
-                'name': stats['assigner_short_name'] or org_id,
-                'assigner_org_id': org_id,
-                'count': y_stats['count'],
-                'years_active': max(1, (stats['last_year'] - stats['first_year'] + 1)) if stats['first_year'] else 1,
-                'kev_count': y_stats['kev_count'],
-                'epss_high_count': y_stats['epss_high_count'],
-                'severity_distribution': dict(y_stats['severity_counts']),
-                'top_cwe_types': dict(sorted(y_stats['cwe_counts'].items(), key=lambda x: x[1], reverse=True)[:10]),
-                'top_cwes': sorted(y_stats['cwe_counts'].items(), key=lambda x: x[1], reverse=True)[:5],
-                'cna_types': self.classify_cna_type(org_id, stats['assigner_short_name']),
-                'first_cve_year': stats['first_year'],
-                'last_cve_year': stats['last_year']
-            }
-            current_year_cnas.append(y_cna)
-            
-        current_year_cnas.sort(key=lambda x: x['count'], reverse=True)
-        for i, cna in enumerate(current_year_cnas): cna['rank'] = i + 1
-        
-        current_year_data = {
-            'generated_at': datetime.now().isoformat(),
-            'year': self.current_year,
-            'total_cnas': len(current_year_cnas),
-            'total_cves': sum(cna['count'] for cna in current_year_cnas),
-            'cna_list': current_year_cnas,
-            'cna_assigners': current_year_cnas
-        }
-        
-        output_file = self.data_dir / f'cna_analysis_{self.current_year}.json'
-        with open(output_file, 'w') as f:
-            json.dump(current_year_data, f, indent=2)
-            
-        print(f"  📄 Generated {self.current_year} CNA analysis with {len(current_year_cnas)} CNAs")
-        return current_year_data
diff --git a/src/cvedb/ingest/__init__.py b/src/cvedb/ingest/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/src/cvedb/ingest/download_cve_data.py b/src/cvedb/ingest/download_cve_data.py
deleted file mode 100644
index c884cc46f16..00000000000
--- a/src/cvedb/ingest/download_cve_data.py
+++ /dev/null
@@ -1,556 +0,0 @@
-#!/usr/bin/env python3
-"""
-CVE Data Download Script
-Downloads and caches CVE data from NVD source for processing
-Replaces the wget step from GitHub Actions with proper Python error handling
-"""
-
-import requests
-import json
-import gzip
-from pathlib import Path
-from datetime import datetime, timedelta
-import hashlib
-import csv
-from concurrent.futures import ThreadPoolExecutor
-
-class CVEDataDownloader:
-    """Downloads and manages CVE data from NVD source"""
-    
-    def __init__(self, cache_dir=None, quiet=False):
-        self.quiet = quiet
-        self.base_dir = Path(__file__).parent
-        self.cache_dir = cache_dir or (self.base_dir / 'cache')
-        self.cache_dir.mkdir(exist_ok=True)
-        
-        # Data source configuration
-        self.nvd_url = "https://nvd.handsonhacking.org/nvd.json"
-        self.cache_file = self.cache_dir / "nvd.json"
-        self.cache_info_file = self.cache_dir / "cache_info.json"
-        self.cache_duration = timedelta(hours=4)  # Cache for 4 hours to match build schedule
-        
-        # CNA mapping files for proper name resolution
-        self.cna_list_url = "https://raw.githubusercontent.com/CVEProject/cve-website/dev/src/assets/data/CNAsList.json"
-        self.cna_name_map_url = "https://www.cve.org/cve-partner-name-map.json"
-        self.cna_list_file = self.cache_dir / "cna_list.json"
-        self.cna_name_map_file = self.cache_dir / "cna_name_map.json"
-
-        # EPSS data (Exploit Prediction Scoring System)
-        # Current snapshot feed documented at https://www.first.org/epss/
-        # Note: EPSS moved from cyentia.com to empiricalsecurity.com in late 2025
-        self.epss_url = "https://epss.empiricalsecurity.com/epss_scores-current.csv.gz"
-        self.epss_cache_file = self.cache_dir / "epss_scores-current.csv.gz"
-        self.epss_parsed_file = self.cache_dir / "epss_scores-current.json"
-
-        # CISA Known Exploited Vulnerabilities (KEV) catalog
-        # Official catalog: https://www.cisa.gov/known-exploited-vulnerabilities-catalog
-        # JSON feed: a list of objects with a cveID field.
-        self.kev_url = "https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json"
-        self.kev_cache_file = self.cache_dir / "known_exploited_vulnerabilities.json"
-        self.kev_parsed_file = self.cache_dir / "known_exploited_vulnerabilities_parsed.json"
-
-        if not self.quiet:
-            print(f"🔽 CVE Data Downloader Initialized")
-            print(f"📁 Cache directory: {self.cache_dir}")
-            print(f"🌐 Data source: {self.nvd_url}")
-    
-    def is_cache_valid(self):
-        """Check if cached data is still valid"""
-        if not self.cache_file.exists() or not self.cache_info_file.exists():
-            return False
-        
-        try:
-            with open(self.cache_info_file, 'r') as f:
-                cache_info = json.load(f)
-            
-            cache_time = datetime.fromisoformat(cache_info['download_time'])
-            if datetime.now() - cache_time > self.cache_duration:
-                if not self.quiet:
-                    print(f"⏰ Cache expired (older than {self.cache_duration})")
-                return False
-            
-            if not self.quiet:
-                print(f"✅ Cache is valid (downloaded {cache_time.strftime('%Y-%m-%d %H:%M:%S')})")
-            return True
-            
-        except (json.JSONDecodeError, KeyError, ValueError) as e:
-            if not self.quiet:
-                print(f"⚠️  Cache info corrupted: {e}")
-            return False
-    
-    def download_data(self, force=False):
-        """Download CVE data from NVD source"""
-        if not force and self.is_cache_valid():
-            if not self.quiet:
-                print("📋 Using cached data")
-            return self.cache_file
-        
-        if not self.quiet:
-            print(f"🔽 Downloading CVE data from {self.nvd_url}")
-        
-        try:
-            # Start download with progress tracking
-            response = requests.get(self.nvd_url, stream=True)
-            response.raise_for_status()
-            
-            # Get file size for progress tracking
-            total_size = int(response.headers.get('content-length', 0))
-            downloaded_size = 0
-            
-            # Download with progress updates
-            with open(self.cache_file, 'wb') as f:
-                for chunk in response.iter_content(chunk_size=8192):
-                    if chunk:
-                        f.write(chunk)
-                        downloaded_size += len(chunk)
-                        
-                        # Show progress every 10MB
-                        if downloaded_size % (10 * 1024 * 1024) == 0 or downloaded_size == total_size:
-                            if total_size > 0:
-                                progress = (downloaded_size / total_size) * 100
-                                print(f"  📥 Downloaded {downloaded_size // (1024*1024)}MB / {total_size // (1024*1024)}MB ({progress:.1f}%)")
-            
-            # Calculate file hash for integrity check
-            file_hash = self.calculate_file_hash(self.cache_file)
-            
-            # Save cache info
-            cache_info = {
-                'download_time': datetime.now().isoformat(),
-                'file_size': downloaded_size,
-                'file_hash': file_hash,
-                'source_url': self.nvd_url
-            }
-            
-            with open(self.cache_info_file, 'w') as f:
-                json.dump(cache_info, f, indent=2)
-            
-            print(f"✅ Download completed successfully")
-            print(f"📊 File size: {downloaded_size // (1024*1024)}MB")
-            print(f"🔐 File hash: {file_hash[:16]}...")
-            
-            return self.cache_file
-            
-        except requests.RequestException as e:
-            print(f"❌ Download failed: {e}")
-            # Try to use cached data if available, even if expired
-            if self.cache_file.exists():
-                print("⚠️  Using expired cached data as fallback")
-                return self.cache_file
-            raise
-        
-        except Exception as e:
-            print(f"❌ Unexpected error during download: {e}")
-            raise
-    
-    def download_cna_mapping_files(self):
-        """Download CNA mapping files for proper name resolution"""
-        print("🔽 Downloading CNA mapping files...")
-        
-        try:
-            # Download CNA list
-            print(f"  📥 Downloading CNA list from CVE.org...")
-            response = requests.get(self.cna_list_url, timeout=30)
-            response.raise_for_status()
-            
-            with open(self.cna_list_file, 'w', encoding='utf-8') as f:
-                json.dump(response.json(), f, indent=2)
-            print(f"  ✅ CNA list saved to {self.cna_list_file.name}")
-            
-            # Download CNA name mapping
-            print(f"  📥 Downloading CNA name mapping from CVE.org...")
-            response = requests.get(self.cna_name_map_url, timeout=30)
-            response.raise_for_status()
-            
-            with open(self.cna_name_map_file, 'w', encoding='utf-8') as f:
-                json.dump(response.json(), f, indent=2)
-            print(f"  ✅ CNA name mapping saved to {self.cna_name_map_file.name}")
-            
-            print("✅ CNA mapping files downloaded successfully")
-            
-        except requests.RequestException as e:
-            print(f"⚠️  Warning: Could not download CNA mapping files: {e}")
-            print("  📝 Will use raw sourceIdentifier values as fallback")
-        except Exception as e:
-            print(f"⚠️  Warning: Unexpected error downloading CNA files: {e}")
-    
-    def calculate_file_hash(self, file_path):
-        """Calculate SHA256 hash of file for integrity checking"""
-        hash_sha256 = hashlib.sha256()
-        with open(file_path, "rb") as f:
-            for chunk in iter(lambda: f.read(4096), b""):
-                hash_sha256.update(chunk)
-        return hash_sha256.hexdigest()
-    
-    def validate_json_format(self, file_path):
-        """Validate that the downloaded file contains valid CVE data (JSON array format)"""
-        try:
-            print("🔍 Validating JSON format...")
-            
-            with open(file_path, 'r', encoding='utf-8') as f:
-                try:
-                    # Try to load as JSON array
-                    cve_data = json.load(f)
-                    
-                    if not isinstance(cve_data, list):
-                        raise ValueError("Expected JSON array format")
-                    
-                    total_records = len(cve_data)
-                    valid_cve_count = 0
-                    
-                    print(f"  📊 Found {total_records:,} records in JSON array")
-                    
-                    # Validate a sample of records
-                    sample_size = min(1000, total_records)
-                    for i in range(0, total_records, max(1, total_records // sample_size)):
-                        if i >= total_records:
-                            break
-                            
-                        record = cve_data[i]
-                        if isinstance(record, dict) and 'cve' in record:
-                            cve_id = record.get('cve', {}).get('id', '')
-                            if cve_id.startswith('CVE-'):
-                                valid_cve_count += 1
-                    
-                    print(f"✅ Validation complete:")
-                    print(f"  📊 Total records: {total_records:,}")
-                    print(f"  ✅ Valid CVEs (sampled): {valid_cve_count}/{sample_size}")
-                    print(f"  📈 Success rate: {(valid_cve_count/sample_size)*100:.1f}%")
-                    
-                    if valid_cve_count == 0:
-                        raise ValueError("No valid CVE records found in downloaded data")
-                    
-                    return True
-                    
-                except json.JSONDecodeError as e:
-                    print(f"❌ Failed to parse JSON: {e}")
-                    return False
-            
-        except Exception as e:
-            print(f"❌ Validation failed: {e}")
-            return False
-    
-    def get_data_stats(self):
-        """Get statistics about the cached data (JSON array format)"""
-        if not self.cache_file.exists():
-            return None
-        
-        try:
-            with open(self.cache_info_file, 'r') as f:
-                cache_info = json.load(f)
-            
-            # Load and process JSON array
-            with open(self.cache_file, 'r', encoding='utf-8') as f:
-                cve_data_array = json.load(f)
-            
-            # Quick scan for year distribution
-            year_counts = {}
-            total_cves = 0
-            
-            # Sample every 100th record for performance (still gives accurate stats)
-            sample_size = max(1, len(cve_data_array) // 100)
-            for i in range(0, len(cve_data_array), sample_size):
-                try:
-                    cve_record = cve_data_array[i]
-                    cve_id = cve_record.get('cve', {}).get('id', '')
-                    
-                    if cve_id.startswith('CVE-'):
-                        # Extract year from CVE-YYYY-NNNN format
-                        year = int(cve_id.split('-')[1])
-                        year_counts[year] = year_counts.get(year, 0) + sample_size
-                        total_cves += sample_size
-                
-                except (KeyError, ValueError, IndexError):
-                    continue
-            
-            # Adjust for sampling
-            actual_total = len(cve_data_array)
-            
-            return {
-                'cache_info': cache_info,
-                'total_cves': actual_total,
-                'year_range': (min(year_counts.keys()), max(year_counts.keys())) if year_counts else (None, None),
-                'year_counts': dict(sorted(year_counts.items()))
-            }
-            
-        except Exception as e:
-            print(f"⚠️  Could not get data stats: {e}")
-            return None
-    
-    def ensure_data_available(self, force_download=False):
-        """Main method to ensure CVE data is available and valid (Parallel version)"""
-        print("\n🔽 Ensuring CVE data is available (Parallelized)...")
-        print("=" * 50)
-        
-        try:
-            tasks = []
-            with ThreadPoolExecutor(max_workers=4) as executor:
-                # 1. Download main NVD data
-                tasks.append(executor.submit(self.download_data, force=force_download))
-                
-                # 2. Download CNA mapping files
-                tasks.append(executor.submit(self.download_cna_mapping_files))
-                
-                # 3. Download EPSS data
-                tasks.append(executor.submit(self.download_epss_data, force=force_download))
-                
-                # 4. Download KEV data
-                tasks.append(executor.submit(self.download_kev_data, force=force_download))
-            
-            # Wait for all tasks and ensure they completed successfully
-            data_file = tasks[0].result()
-            
-            # Post-download processing (Sequential because they are CPU intensive/file dependent)
-            # 1. Parse EPSS if downloaded
-            self.parse_epss_csv()
-            
-            # 2. Parse KEV if downloaded
-            self.parse_kev_json()
-            
-            # 3. Validate NVD JSON format (only if new download or force)
-            is_valid_cache = self.is_cache_valid()
-            if force_download or not is_valid_cache:
-                if not self.validate_json_format(data_file):
-                    raise ValueError("Downloaded data failed validation")
-            elif not self.quiet:
-                print("✅ Skipping validation (using existing valid cache)")
-            
-            # Show statistics
-            stats = self.get_data_stats()
-            if stats:
-                print(f"\n📊 Data Statistics:")
-                print(f"  📅 Downloaded: {stats['cache_info']['download_time']}")
-                print(f"  📊 Total CVEs: {stats['total_cves']:,}")
-                if stats['year_range'][0]:
-                    print(f"  📅 Year range: {stats['year_range'][0]}-{stats['year_range'][1]}")
-                    print(f"  📈 Years covered: {len(stats['year_counts'])}")
-            
-            print("\n" + "=" * 50)
-            print("✅ CVE data is ready for processing!")
-            
-            return data_file
-            
-        except Exception as e:
-            print(f"\n❌ Failed to ensure data availability: {e}")
-            raise
-
-    # ------------------------------------------------------------------
-    # EPSS data helpers
-    # ------------------------------------------------------------------
-
-    def download_epss_data(self, force: bool = False):
-        """Download and cache the EPSS scores CSV.
-
-        Returns the path to the gzipped CSV file, or None on failure.
-        Uses a similar cache duration to the main NVD data so GitHub
-        Actions runs don't redownload unnecessarily.
-        """
-
-        if self.epss_cache_file.exists() and not force:
-            # Basic age check: reuse if within cache_duration
-            mtime = datetime.fromtimestamp(self.epss_cache_file.stat().st_mtime)
-            if datetime.now() - mtime < self.cache_duration:
-                if not self.quiet:
-                    print("✅ Using cached EPSS data")
-                return self.epss_cache_file
-
-        if not self.quiet:
-            print(f"🔽 Downloading EPSS data from {self.epss_url}")
-
-        try:
-            response = requests.get(self.epss_url, stream=True, timeout=120)
-            response.raise_for_status()
-
-            with open(self.epss_cache_file, "wb") as f:
-                for chunk in response.iter_content(chunk_size=8192):
-                    if chunk:
-                        f.write(chunk)
-
-            if not self.quiet:
-                size_mb = self.epss_cache_file.stat().st_size / (1024 * 1024)
-                print(f"✅ EPSS download complete ({size_mb:.2f} MB)")
-
-            return self.epss_cache_file
-
-        except requests.RequestException as e:
-            print(f"⚠️  Warning: EPSS download failed: {e}")
-            if self.epss_cache_file.exists():
-                print("  📝 Using stale EPSS cache as fallback")
-                return self.epss_cache_file
-            return None
-
-    def parse_epss_csv(self):
-        """Parse the cached EPSS CSV into a compact JSON mapping.
-
-        Output format (written to self.epss_parsed_file):
-
-        {
-          "CVE-2024-12345": {"epss_score": 0.1234, "epss_percentile": 0.9876},
-          ...
-        }
-        """
-
-        epss_csv_gz = self.download_epss_data()
-        if not epss_csv_gz or not epss_csv_gz.exists():
-            print("⚠️  Warning: No EPSS CSV available to parse")
-            return None
-
-        if not self.quiet:
-            print("🔍 Parsing EPSS CSV into JSON mapping...")
-
-        mapping = {}
-        try:
-            with gzip.open(epss_csv_gz, mode="rt", encoding="utf-8") as f:
-                # Skip comment lines (start with #)
-                lines = (line for line in f if not line.startswith('#'))
-                reader = csv.DictReader(lines)
-                for row in reader:
-                    cve_id = row.get("cve") or row.get("CVE")
-                    if not cve_id:
-                        continue
-                    try:
-                        score = float(row.get("epss", "0") or 0)
-                    except ValueError:
-                        score = 0.0
-                    try:
-                        percentile = float(row.get("percentile", "0") or 0)
-                    except ValueError:
-                        percentile = 0.0
-                    mapping[cve_id.strip()] = {
-                        "epss_score": score,
-                        "epss_percentile": percentile,
-                    }
-
-            with open(self.epss_parsed_file, "w", encoding="utf-8") as out:
-                json.dump(mapping, out)
-
-            if not self.quiet:
-                print(f"✅ EPSS mapping written to {self.epss_parsed_file.name} ({len(mapping):,} CVEs)")
-
-            return self.epss_parsed_file
-
-        except Exception as e:
-            print(f"⚠️  Warning: Failed to parse EPSS CSV: {e}")
-            return None
-
-    # ------------------------------------------------------------------
-    # CISA KEV helpers
-    # ------------------------------------------------------------------
-
-    def download_kev_data(self, force: bool = False):
-        """Download and cache the CISA Known Exploited Vulnerabilities catalog.
-
-        Returns the path to the JSON file, or None on failure. Best-effort only:
-        if download fails but a stale cache exists, we will reuse it.
-        """
-
-        if self.kev_cache_file.exists() and not force:
-            # Basic age check similar to NVD cache
-            mtime = datetime.fromtimestamp(self.kev_cache_file.stat().st_mtime)
-            if datetime.now() - mtime < self.cache_duration:
-                if not self.quiet:
-                    print("✅ Using cached KEV data")
-                return self.kev_cache_file
-
-        if not self.quiet:
-            print(f"🔽 Downloading KEV data from {self.kev_url}")
-
-        try:
-            response = requests.get(self.kev_url, timeout=60)
-            response.raise_for_status()
-
-            with open(self.kev_cache_file, "w", encoding="utf-8") as f:
-                f.write(response.text)
-
-            if not self.quiet:
-                size_kb = self.kev_cache_file.stat().st_size / 1024
-                print(f"✅ KEV download complete ({size_kb:.1f} KB)")
-
-            return self.kev_cache_file
-
-        except requests.RequestException as e:
-            print(f"⚠️  Warning: KEV download failed: {e}")
-            if self.kev_cache_file.exists():
-                print("  📝 Using stale KEV cache as fallback")
-                return self.kev_cache_file
-            return None
-
-    def parse_kev_json(self):
-        """Parse the KEV JSON into a compact mapping.
-
-        Expected feed shape (subject to CISA changes):
-
-        {
-          "vulnerabilities": [
-            { "cveID": "CVE-2024-12345", ... },
-            ...
-          ]
-        }
-
-        We persist a simplified structure for fast lookup:
-
-        {
-          "CVE-2024-12345": true,
-          ...
-        }
-        """
-
-        kev_json = self.download_kev_data()
-        if not kev_json or not kev_json.exists():
-            print("⚠️  Warning: No KEV JSON available to parse")
-            return None
-
-        if not self.quiet:
-            print("🔍 Parsing KEV JSON into CVE mapping...")
-
-        try:
-            with open(kev_json, "r", encoding="utf-8") as f:
-                raw = json.load(f)
-
-            # CISA’s feed wraps the list in a top-level key in most formats
-            vulnerabilities = raw.get("vulnerabilities")
-            if vulnerabilities is None and isinstance(raw, list):
-                vulnerabilities = raw
-
-            mapping = {}
-            if isinstance(vulnerabilities, list):
-                for entry in vulnerabilities:
-                    cve_id = entry.get("cveID") or entry.get("cveId") or entry.get("cve")
-                    if isinstance(cve_id, str) and cve_id.startswith("CVE-"):
-                        mapping[cve_id.strip()] = True
-
-            with open(self.kev_parsed_file, "w", encoding="utf-8") as out:
-                json.dump(mapping, out)
-
-            if not self.quiet:
-                print(f"✅ KEV mapping written to {self.kev_parsed_file.name} ({len(mapping):,} CVEs)")
-
-            return self.kev_parsed_file
-
-        except Exception as e:
-            print(f"⚠️  Warning: Failed to parse KEV JSON: {e}")
-            return None
-
-def main():
-    """Main entry point for standalone execution"""
-    import argparse
-    
-    parser = argparse.ArgumentParser(description="Download and cache CVE data")
-    parser.add_argument('--force', action='store_true', help='Force download even if cache is valid')
-    parser.add_argument('--stats', action='store_true', help='Show data statistics only')
-    parser.add_argument('--cache-dir', help='Custom cache directory')
-    
-    args = parser.parse_args()
-    
-    downloader = CVEDataDownloader(cache_dir=args.cache_dir)
-    
-    if args.stats:
-        stats = downloader.get_data_stats()
-        if stats:
-            print(json.dumps(stats, indent=2, default=str))
-        else:
-            print("No cached data available")
-    else:
-        downloader.ensure_data_available(force_download=args.force)
-
-if __name__ == '__main__':
-    main()
diff --git a/src/cvedb/utils/__init__.py b/src/cvedb/utils/__init__.py
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/static/css/style.css b/static/css/style.css
deleted file mode 100644
index 71e283eeb57..00000000000
--- a/static/css/style.css
+++ /dev/null
@@ -1,1993 +0,0 @@
-/* CVEDB Design System - Matching cnascorecard.org */
-
-/* CSS Reset and Base Styles */
-* {
-    margin: 0;
-    padding: 0;
-    box-sizing: border-box;
-}
-
-/* Root Variables - Design System Colors */
-:root {
-    /* Base Colors */
-    --color-bg-primary: #f8f9fa;
-    --color-bg-secondary: #e9ecef;
-    --color-bg-content: #ffffff;
-    --color-bg-hover: #f8f9fa;
-    --color-text: #212529;
-    --color-text-primary: #212529;
-    --color-text-secondary: #6c757d;
-    --color-text-muted: #adb5bd;
-    --color-primary: #0d6efd;
-    --color-primary-light: rgba(13, 110, 253, 0.1);
-    --color-accent: #0d6efd;
-    --color-border: #dee2e6;
-    --color-border-light: #f1f3f4;
-    --color-success: #198754;
-    --color-warning: #ffc107;
-    --color-danger: #dc3545;
-
-    /* Light Blue to Light Grey Visualization Palette */
-    --viz-color-1: #e3f2fd;
-    /* Very light blue */
-    --viz-color-2: #bbdefb;
-    /* Light blue */
-    --viz-color-3: #90caf9;
-    /* Medium light blue */
-    --viz-color-4: #64b5f6;
-    /* Medium blue */
-    --viz-color-5: #42a5f5;
-    /* Blue */
-    --viz-color-6: #2196f3;
-    /* Primary blue */
-    --viz-color-7: #1e88e5;
-    /* Darker blue */
-    --viz-color-8: #1976d2;
-    /* Dark blue */
-    --viz-color-9: #9e9e9e;
-    /* Medium grey */
-    --viz-color-10: #757575;
-    /* Dark grey */
-
-    /* Chart Color Palette - Light Blue to Grey Gradient */
-    --chart-primary: #2196f3;
-    --chart-secondary: #64b5f6;
-    --chart-tertiary: #90caf9;
-    --chart-quaternary: #bbdefb;
-    --chart-accent-1: #81c784;
-    --chart-accent-2: #ffb74d;
-    --chart-accent-3: #f06292;
-    --chart-grey-light: #e0e0e0;
-    --chart-grey-medium: #9e9e9e;
-    --chart-grey-dark: #616161;
-
-    /* Semantic Colors */
-    --color-info: #17a2b8;
-    --color-light: #f8f9fa;
-    --color-dark: #343a40;
-
-    /* Spacing */
-    --spacing-xs: 0.25rem;
-    --spacing-sm: 0.5rem;
-    --spacing-md: 1rem;
-    --spacing-lg: 1.5rem;
-    --spacing-xl: 2rem;
-    --spacing-xxl: 3rem;
-
-    /* Typography */
-    --font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-    --font-size-base: 16px;
-    --font-weight-normal: 400;
-    --font-weight-medium: 500;
-    --font-weight-semibold: 600;
-    --font-weight-bold: 700;
-
-    /* Layout */
-    --container-max-width: 1200px;
-    --border-radius: 0.5rem;
-    --border-radius-lg: 0.75rem;
-    --box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075);
-    --box-shadow-lg: 0 0.5rem 1rem rgba(0, 0, 0, 0.15);
-}
-
-/* Base Typography */
-body {
-    font-family: var(--font-family);
-    font-size: var(--font-size-base);
-    line-height: 1.6;
-    color: var(--color-text-primary);
-    background-color: var(--color-bg-primary);
-    -webkit-font-smoothing: antialiased;
-    -moz-osx-font-smoothing: grayscale;
-}
-
-/* Headings */
-h1,
-h2,
-h3,
-h4,
-h5,
-h6 {
-    font-weight: var(--font-weight-semibold);
-    line-height: 1.2;
-    margin-bottom: var(--spacing-md);
-    color: var(--color-text-primary);
-}
-
-h1 {
-    font-size: 2.5rem;
-    font-weight: var(--font-weight-bold);
-}
-
-h2 {
-    font-size: 2rem;
-}
-
-h3 {
-    font-size: 1.5rem;
-}
-
-h4 {
-    font-size: 1.25rem;
-}
-
-/* Links */
-a {
-    color: var(--color-accent);
-    text-decoration: none;
-    transition: color 0.15s ease-in-out;
-}
-
-a:hover {
-    color: #0a58ca;
-    text-decoration: underline;
-}
-
-/* Container */
-.container {
-    max-width: var(--container-max-width);
-    margin: 0 auto;
-    padding: 0 var(--spacing-lg);
-}
-
-/* Header and Navigation */
-.header {
-    background-color: var(--color-bg-content);
-    border-bottom: 1px solid var(--color-border);
-    position: sticky;
-    top: 0;
-    z-index: 1000;
-    box-shadow: var(--box-shadow);
-}
-
-.nav-container {
-    max-width: var(--container-max-width);
-    margin: 0 auto;
-    padding: 0 var(--spacing-lg);
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    height: 4rem;
-}
-
-.logo {
-    display: flex;
-    align-items: center;
-    gap: var(--spacing-sm);
-    font-weight: var(--font-weight-bold);
-    font-size: 1.25rem;
-    color: var(--color-text-primary);
-    text-decoration: none;
-}
-
-.logo:hover {
-    text-decoration: none;
-    color: var(--color-accent);
-}
-
-.logo img {
-    width: 2rem;
-    height: 2rem;
-    object-fit: contain;
-}
-
-.nav {
-    display: flex;
-    align-items: center;
-}
-
-.nav-menu {
-    display: flex;
-    list-style: none;
-    gap: var(--spacing-lg);
-    margin: 0;
-    padding: 0;
-}
-
-.nav-menu a {
-    color: var(--color-text-secondary);
-    font-weight: var(--font-weight-medium);
-    padding: var(--spacing-sm) var(--spacing-md);
-    border-radius: var(--border-radius);
-    transition: all 0.15s ease-in-out;
-    border: 2px solid transparent;
-}
-
-.nav-menu a:hover {
-    color: var(--color-accent);
-    background-color: rgba(13, 110, 253, 0.1);
-    border-color: var(--color-accent);
-    text-decoration: none;
-}
-
-.nav-menu a.active {
-    color: var(--color-accent);
-    background-color: rgba(13, 110, 253, 0.1);
-    border-color: var(--color-accent);
-    font-weight: var(--font-weight-semibold);
-}
-
-/* Navigation Dropdown */
-.nav-dropdown {
-    position: relative;
-}
-
-.nav-dropdown .dropdown-menu {
-    position: absolute;
-    top: 100%;
-    left: 0;
-    min-width: 150px;
-    background: var(--color-bg-content);
-    border: 1px solid var(--color-border);
-    border-radius: var(--border-radius);
-    box-shadow: var(--box-shadow-lg);
-    padding: var(--spacing-xs) 0;
-    margin-top: var(--spacing-xs);
-    list-style: none;
-    opacity: 0;
-    visibility: hidden;
-    transform: translateY(-10px);
-    transition: all 0.2s ease;
-    z-index: 1001;
-}
-
-.nav-dropdown:hover .dropdown-menu {
-    opacity: 1;
-    visibility: visible;
-    transform: translateY(0);
-}
-
-.nav-dropdown .dropdown-menu li {
-    margin: 0;
-}
-
-.nav-dropdown .dropdown-menu a {
-    display: block;
-    padding: var(--spacing-sm) var(--spacing-md);
-    color: var(--color-text-secondary);
-    font-weight: var(--font-weight-medium);
-    border: none;
-    border-radius: 0;
-    white-space: nowrap;
-}
-
-.nav-dropdown .dropdown-menu a:hover {
-    background-color: rgba(13, 110, 253, 0.1);
-    color: var(--color-accent);
-    border: none;
-}
-
-.nav-toggle {
-    display: none;
-    flex-direction: column;
-    background: none;
-    border: none;
-    cursor: pointer;
-    padding: var(--spacing-sm);
-}
-
-.nav-toggle span {
-    width: 1.5rem;
-    height: 2px;
-    background-color: var(--color-text-primary);
-    margin: 2px 0;
-    transition: 0.3s;
-}
-
-/* Main Content */
-main {
-    min-height: calc(100vh - 8rem);
-    padding: var(--spacing-xl) 0;
-}
-
-/* Professional Page Header Styling */
-.page-header {
-    background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);
-    border: 1px solid var(--color-border);
-    border-radius: var(--border-radius-lg);
-    box-shadow: var(--box-shadow);
-    padding: var(--spacing-xl) var(--spacing-lg);
-    margin-top: var(--spacing-lg);
-    margin-bottom: var(--spacing-xl);
-    position: relative;
-    overflow: hidden;
-}
-
-.page-header::before {
-    content: '';
-    position: absolute;
-    top: 0;
-    left: 0;
-    right: 0;
-    height: 3px;
-    background: linear-gradient(90deg, #2196f3, #64b5f6, #90caf9);
-    border-radius: var(--border-radius-lg) var(--border-radius-lg) 0 0;
-}
-
-.page-header h1 {
-    color: var(--color-text-primary);
-    font-weight: var(--font-weight-bold);
-    margin-bottom: var(--spacing-sm);
-    text-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
-}
-
-.page-header small {
-    color: var(--color-text-secondary);
-    font-size: 1rem;
-    line-height: 1.5;
-    font-weight: var(--font-weight-medium);
-}
-
-/* Page header buttons - ensure proper contrast against gradient background */
-.page-header button {
-    background-color: #ffffff !important;
-    border: 2px solid var(--color-border) !important;
-    color: var(--color-text-primary) !important;
-    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1) !important;
-}
-
-.page-header button:hover {
-    background-color: #f8f9fa !important;
-    border-color: var(--color-primary) !important;
-    color: var(--color-primary) !important;
-    box-shadow: 0 4px 8px rgba(0, 0, 0, 0.15) !important;
-}
-
-.page-header button:active,
-.page-header button.active {
-    background-color: var(--color-primary) !important;
-    border-color: var(--color-primary) !important;
-    color: #ffffff !important;
-}
-
-/* Responsive page header */
-@media (max-width: 768px) {
-    .page-header {
-        padding: var(--spacing-lg) var(--spacing-md);
-        margin-top: var(--spacing-md);
-    }
-
-    .page-header h1 {
-        font-size: 2rem;
-    }
-
-    .page-header small {
-        font-size: 0.9rem;
-    }
-}
-
-/* Cards */
-.card {
-    background-color: var(--color-bg-content);
-    border: 1px solid var(--color-border);
-    border-radius: var(--border-radius);
-    box-shadow: var(--box-shadow);
-    padding: var(--spacing-lg);
-    margin-bottom: var(--spacing-lg);
-}
-
-.card-header {
-    margin-bottom: var(--spacing-lg);
-    padding-bottom: var(--spacing-md);
-    border-bottom: 1px solid var(--color-border);
-}
-
-.card-title {
-    font-size: 1.25rem;
-    font-weight: var(--font-weight-semibold);
-    margin-bottom: var(--spacing-sm);
-}
-
-.card-body {
-    padding: 0;
-}
-
-/* Professional Stats Cards Design System */
-.stats-grid {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-    gap: 1.5rem;
-    margin-bottom: 2rem;
-}
-
-/* Responsive grid for smaller screens */
-@media (max-width: 992px) {
-    .stats-grid {
-        grid-template-columns: repeat(2, 1fr);
-        gap: 1rem;
-    }
-}
-
-@media (max-width: 576px) {
-    .stats-grid {
-        grid-template-columns: 1fr;
-        gap: 1rem;
-    }
-}
-
-.stat-card {
-    position: relative;
-    background: linear-gradient(135deg, #ffffff 0%, #f8fafc 100%);
-    border: 1px solid rgba(226, 232, 240, 0.8);
-    border-radius: 16px;
-    padding: 2rem 1.5rem;
-    text-align: center;
-    transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
-    box-shadow:
-        0 1px 3px rgba(0, 0, 0, 0.05),
-        0 1px 2px rgba(0, 0, 0, 0.1);
-    overflow: hidden;
-}
-
-.stat-card::before {
-    content: '';
-    position: absolute;
-    top: 0;
-    left: 0;
-    right: 0;
-    height: 4px;
-    background: linear-gradient(90deg,
-            var(--chart-primary) 0%,
-            var(--chart-secondary) 50%,
-            var(--chart-tertiary) 100%);
-    opacity: 0.8;
-}
-
-.stat-card:hover {
-    transform: translateY(-4px) scale(1.02);
-    box-shadow:
-        0 10px 25px rgba(0, 0, 0, 0.1),
-        0 6px 10px rgba(0, 0, 0, 0.05);
-    border-color: rgba(59, 130, 246, 0.3);
-}
-
-.stat-card:hover::before {
-    height: 6px;
-    opacity: 1;
-}
-
-.stat-icon {
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    width: 56px;
-    height: 56px;
-    background: linear-gradient(135deg,
-            rgba(59, 130, 246, 0.1) 0%,
-            rgba(147, 197, 253, 0.1) 100%);
-    border-radius: 16px;
-    margin-bottom: 1.5rem;
-    font-size: 1.5rem;
-    color: var(--chart-primary);
-    transition: all 0.3s ease;
-}
-
-.stat-card:hover .stat-icon {
-    transform: scale(1.1);
-    background: linear-gradient(135deg,
-            rgba(59, 130, 246, 0.15) 0%,
-            rgba(147, 197, 253, 0.15) 100%);
-}
-
-.stat-content {
-    text-align: left;
-}
-
-.stat-number {
-    font-size: 2.5rem;
-    font-weight: 700;
-    line-height: 1;
-    color: var(--color-text-primary);
-    margin-bottom: 0.5rem;
-}
-
-.stat-label {
-    font-size: 0.875rem;
-    font-weight: 600;
-    color: var(--color-text-primary);
-    margin-bottom: 0.25rem;
-    letter-spacing: -0.025em;
-}
-
-.stat-sublabel {
-    font-size: 0.75rem;
-    color: var(--color-text-secondary);
-    line-height: 1.4;
-    font-weight: 500;
-}
-
-/* Enhanced stats cards for specific use cases */
-.stat-card.highlight {
-    background: linear-gradient(135deg,
-            rgba(59, 130, 246, 0.02) 0%,
-            rgba(147, 197, 253, 0.02) 100%);
-    border-color: rgba(59, 130, 246, 0.2);
-}
-
-.stat-card.highlight::before {
-    background: linear-gradient(90deg,
-            var(--chart-primary) 0%,
-            var(--color-success) 100%);
-}
-
-/* Growth/trend indicators */
-.stat-trend {
-    display: inline-flex;
-    align-items: center;
-    gap: 0.25rem;
-    font-size: 0.75rem;
-    font-weight: 600;
-    margin-top: 0.5rem;
-    padding: 0.25rem 0.5rem;
-    border-radius: 6px;
-}
-
-.stat-trend.positive {
-    color: var(--color-success);
-    background: rgba(16, 185, 129, 0.1);
-}
-
-.stat-trend.negative {
-    color: var(--color-danger);
-    background: rgba(239, 68, 68, 0.1);
-}
-
-.stat-trend.neutral {
-    color: var(--color-text-secondary);
-    background: rgba(156, 163, 175, 0.1);
-}
-
-/* Additional responsive adjustments for card content */
-@media (max-width: 768px) {
-    .stat-card {
-        padding: 1.5rem 1.25rem;
-    }
-
-    .stat-number {
-        font-size: 2rem;
-    }
-
-    .stat-icon {
-        width: 48px;
-        height: 48px;
-        font-size: 1.25rem;
-        margin-bottom: 1rem;
-    }
-}
-
-@media (max-width: 480px) {
-    .stat-card {
-        padding: 1.25rem 1rem;
-    }
-
-    .stat-number {
-        font-size: 1.75rem;
-    }
-}
-
-/* Legacy support for existing stat-cards class */
-.stat-cards {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
-    gap: 1.5rem;
-    margin-bottom: 2rem;
-}
-
-/* Legacy stat-value, stat-label, stat-detail classes */
-.stat-value {
-    font-size: 2.5rem;
-    font-weight: 700;
-    line-height: 1;
-    color: var(--color-text-primary);
-    margin-bottom: 0.5rem;
-}
-
-.stat-detail {
-    font-size: 0.75rem;
-    color: var(--color-text-secondary);
-    margin-top: 0.5rem;
-    line-height: 1.4;
-    font-weight: 500;
-}
-
-/* Year Grid Selector - Compact Version */
-.year-grid {
-    display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(60px, 1fr));
-    gap: var(--spacing-xs);
-    margin-top: var(--spacing-sm);
-    margin-bottom: var(--spacing-md);
-}
-
-.year-item {
-    display: block;
-    position: relative;
-    cursor: pointer;
-    transition: all 0.2s ease;
-}
-
-.year-item input[type="checkbox"] {
-    position: absolute;
-    opacity: 0;
-    width: 0;
-    height: 0;
-}
-
-.year-item .year-label {
-    display: block;
-    padding: var(--spacing-xs) var(--spacing-sm);
-    text-align: center;
-    background-color: var(--color-bg-content);
-    border: 1px solid var(--color-border);
-    border-radius: var(--border-radius);
-    font-weight: var(--font-weight-medium);
-    font-size: 0.8rem;
-    transition: all 0.2s ease;
-    user-select: none;
-    min-height: 32px;
-    display: flex;
-    align-items: center;
-    justify-content: center;
-}
-
-.year-item:hover .year-label {
-    border-color: var(--color-primary);
-    background-color: var(--color-primary-light);
-}
-
-.year-item input[type="checkbox"]:checked+.year-label {
-    background-color: var(--color-primary);
-    border-color: var(--color-primary);
-    color: white;
-    font-weight: var(--font-weight-semibold);
-}
-
-.year-item input[type="checkbox"]:focus+.year-label {
-    outline: 2px solid var(--color-primary);
-    outline-offset: 2px;
-}
-
-/* Compact Quick Selection Buttons */
-.quick-select-buttons {
-    display: flex;
-    flex-wrap: wrap;
-    gap: var(--spacing-xs);
-    margin-bottom: var(--spacing-md);
-    justify-content: center;
-    align-items: center;
-}
-
-.quick-select-btn {
-    padding: var(--spacing-xs) var(--spacing-sm);
-    border: 1px solid var(--color-border);
-    border-radius: var(--border-radius);
-    background-color: var(--color-bg-content);
-    color: var(--color-text);
-    font-weight: var(--font-weight-medium);
-    font-size: 0.75rem;
-    cursor: pointer;
-    transition: all 0.2s ease;
-    text-decoration: none;
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    min-width: 80px;
-    user-select: none;
-    height: 28px;
-}
-
-.quick-select-btn:hover {
-    border-color: var(--color-primary);
-    background-color: var(--color-primary-light);
-    transform: translateY(-1px);
-    box-shadow: 0 2px 8px rgba(13, 110, 253, 0.15);
-}
-
-.quick-select-btn:active {
-    transform: translateY(0);
-    box-shadow: 0 1px 4px rgba(13, 110, 253, 0.2);
-}
-
-.quick-select-btn.primary {
-    color: var(--color-text-secondary);
-}
-
-.quick-select-btn.secondary:hover {
-    border-color: var(--color-text);
-    color: var(--color-text);
-    background-color: var(--color-bg-hover);
-}
-
-/* Tables */
-.table-container {
-    overflow-x: auto;
-    border-radius: var(--border-radius);
-    border: 1px solid var(--color-border);
-}
-
-table {
-    width: 100%;
-    border-collapse: collapse;
-    font-size: 0.875rem;
-}
-
-th {
-    background-color: var(--color-bg-primary);
-    color: var(--color-text-primary);
-    font-weight: var(--font-weight-semibold);
-    padding: var(--spacing-md);
-    text-align: left;
-    border-bottom: 2px solid var(--color-border);
-    position: sticky;
-    top: 0;
-    z-index: 10;
-}
-
-td {
-    padding: var(--spacing-md);
-    border-bottom: 1px solid var(--color-border);
-    vertical-align: top;
-}
-
-tbody tr:nth-child(even) {
-    background-color: rgba(248, 249, 250, 0.5);
-}
-
-tbody tr:hover {
-    background-color: rgba(13, 110, 253, 0.05);
-}
-
-/* Chart Container */
-.chart-container {
-    position: relative;
-    height: 400px;
-    width: 100%;
-}
-
-/* Homepage Chart Structure - Bulletproof Width Consistency */
-.homepage-chart-section,
-.homepage-preview-section {
-    width: 100%;
-    margin: 0;
-    padding: 0;
-}
-
-.homepage-chart-card {
-    background-color: var(--color-bg-content);
-    border: 1px solid var(--color-border);
-    border-radius: var(--border-radius);
-    box-shadow: var(--box-shadow);
-    margin-bottom: var(--spacing-lg);
-    width: 100%;
-    max-width: none;
-}
-
-.homepage-chart-header {
-    padding: var(--spacing-lg);
-    padding-bottom: var(--spacing-md);
-    border-bottom: 1px solid var(--color-border);
-}
-
-.homepage-chart-title {
-    font-weight: var(--font-weight-semibold);
-    color: var(--color-text-primary);
-    margin: 0;
-    margin-bottom: var(--spacing-xs);
-}
-
-.homepage-chart-subtitle {
-    color: var(--color-text-muted);
-    font-size: 0.875rem;
-    display: block;
-}
-
-.homepage-chart-body {
-    padding: var(--spacing-lg);
-    width: 100%;
-}
-
-.homepage-chart-container {
-    position: relative;
-    width: 100%;
-    height: 400px;
-    margin: 0;
-    padding: 0;
-    background: none;
-    border: none;
-    box-shadow: none;
-}
-
-.homepage-preview-container {
-    height: 400px;
-}
-
-.homepage-chart-footer {
-    margin-top: var(--spacing-lg);
-    text-align: center;
-}
-
-.chart-container canvas {
-    max-height: 100%;
-}
-
-/* Chart Title Styling */
-.chart-title {
-    font-size: 1.1rem;
-    font-weight: var(--font-weight-semibold);
-    color: var(--color-text-primary);
-    margin-bottom: var(--spacing-md);
-    text-align: center;
-}
-
-/* Visualization Components */
-.viz-card {
-    background-color: var(--color-bg-content);
-    border: 1px solid var(--color-border);
-    border-radius: var(--border-radius);
-    padding: var(--spacing-lg);
-    margin-bottom: var(--spacing-lg);
-    box-shadow: var(--box-shadow);
-    transition: all 0.2s ease;
-}
-
-.viz-card:hover {
-    transform: translateY(-1px);
-    box-shadow: var(--box-shadow-lg);
-    border-color: var(--color-primary-light);
-}
-
-.viz-header {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    margin-bottom: var(--spacing-md);
-    padding-bottom: var(--spacing-sm);
-    border-bottom: 1px solid var(--color-border-light);
-}
-
-.viz-title {
-    font-size: 1.25rem;
-    font-weight: var(--font-weight-semibold);
-    color: var(--color-text-primary);
-    margin: 0;
-}
-
-.viz-subtitle {
-    font-size: 0.9rem;
-    color: var(--color-text-secondary);
-    margin: var(--spacing-xs) 0 0 0;
-}
-
-/* Chart Legend Styling */
-.chart-legend {
-    display: flex;
-    flex-wrap: wrap;
-    gap: var(--spacing-md);
-    justify-content: center;
-    margin-top: var(--spacing-md);
-    padding-top: var(--spacing-md);
-    border-top: 1px solid var(--color-border-light);
-}
-
-.legend-item {
-    display: flex;
-    align-items: center;
-    gap: var(--spacing-xs);
-    font-size: 0.85rem;
-    color: var(--color-text-secondary);
-}
-
-.legend-color {
-    width: 12px;
-    height: 12px;
-    border-radius: 2px;
-    flex-shrink: 0;
-}
-
-/* Data Table Styling for Charts */
-.data-table {
-    width: 100%;
-    border-collapse: collapse;
-    margin-top: var(--spacing-md);
-    font-size: 0.9rem;
-}
-
-.data-table th,
-.data-table td {
-    padding: var(--spacing-sm) var(--spacing-md);
-    text-align: left;
-    border-bottom: 1px solid var(--color-border-light);
-}
-
-.data-table th {
-    background-color: var(--color-bg-secondary);
-    font-weight: var(--font-weight-semibold);
-    color: var(--color-text-primary);
-    position: sticky;
-    top: 0;
-}
-
-.data-table tr:hover {
-    background-color: var(--color-bg-hover);
-}
-
-/* Metric Cards for Visualizations */
-.metric-grid {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-    gap: var(--spacing-md);
-    margin-bottom: var(--spacing-lg);
-}
-
-.metric-card {
-    background: linear-gradient(135deg, var(--viz-color-1), var(--viz-color-2));
-    border: 1px solid var(--color-border-light);
-    border-radius: var(--border-radius);
-    padding: var(--spacing-lg);
-    text-align: center;
-    transition: all 0.2s ease;
-    position: relative;
-    overflow: hidden;
-}
-
-.metric-card::before {
-    content: '';
-    position: absolute;
-    top: 0;
-    left: 0;
-    right: 0;
-    height: 3px;
-    background: linear-gradient(90deg, var(--chart-primary), var(--chart-secondary));
-}
-
-.metric-card:hover {
-    transform: translateY(-2px);
-    box-shadow: 0 4px 12px rgba(33, 150, 243, 0.15);
-}
-
-.metric-value {
-    font-size: 2rem;
-    font-weight: var(--font-weight-bold);
-    color: var(--chart-primary);
-    margin-bottom: var(--spacing-xs);
-    line-height: 1;
-}
-
-.metric-label {
-    font-size: 0.9rem;
-    color: var(--color-text-secondary);
-    font-weight: var(--font-weight-medium);
-    margin-bottom: var(--spacing-xs);
-}
-
-.metric-change {
-    font-size: 0.8rem;
-    font-weight: var(--font-weight-medium);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    gap: var(--spacing-xs);
-}
-
-.metric-change.positive {
-    color: var(--color-success);
-}
-
-.metric-change.negative {
-    color: var(--color-danger);
-}
-
-.metric-change.neutral {
-    color: var(--color-text-muted);
-}
-
-/* Loading States */
-.loading {
-    display: flex;
-    flex-direction: column;
-    align-items: center;
-    justify-content: center;
-    padding: var(--spacing-xxl);
-    color: var(--color-text-secondary);
-}
-
-.spinner {
-    width: 2rem;
-    height: 2rem;
-    border: 3px solid var(--color-border);
-    border-top: 3px solid var(--color-accent);
-    border-radius: 50%;
-    animation: spin 1s linear infinite;
-    margin-bottom: var(--spacing-md);
-}
-
-@keyframes spin {
-    0% {
-        transform: rotate(0deg);
-    }
-
-    100% {
-        transform: rotate(360deg);
-    }
-}
-
-/* Utility Classes */
-.text-center {
-    text-align: center;
-}
-
-.text-left {
-    text-align: left;
-}
-
-.text-right {
-    text-align: right;
-}
-
-.text-muted {
-    color: var(--color-text-secondary);
-}
-
-.text-primary {
-    color: var(--color-accent);
-}
-
-.text-success {
-    color: var(--color-success);
-}
-
-.text-warning {
-    color: var(--color-warning);
-}
-
-.text-danger {
-    color: var(--color-danger);
-}
-
-.mb-0 {
-    margin-bottom: 0;
-}
-
-.mb-1 {
-    margin-bottom: var(--spacing-xs);
-}
-
-.mb-2 {
-    margin-bottom: var(--spacing-sm);
-}
-
-.mb-3 {
-    margin-bottom: var(--spacing-md);
-}
-
-.mb-4 {
-    margin-bottom: var(--spacing-lg);
-}
-
-.mb-5 {
-    margin-bottom: var(--spacing-xl);
-}
-
-.mt-0 {
-    margin-top: 0;
-}
-
-.mt-1 {
-    margin-top: var(--spacing-xs);
-}
-
-.mt-2 {
-    margin-top: var(--spacing-sm);
-}
-
-.mt-3 {
-    margin-top: var(--spacing-md);
-}
-
-.mt-4 {
-    margin-top: var(--spacing-lg);
-}
-
-.mt-5 {
-    margin-top: var(--spacing-xl);
-}
-
-/* Footer */
-.footer {
-    background-color: var(--color-bg-content);
-    border-top: 1px solid var(--color-border);
-    padding: var(--spacing-xl) 0;
-    margin-top: auto;
-    color: var(--color-text-secondary);
-    font-size: 0.875rem;
-}
-
-.footer p {
-    margin-bottom: var(--spacing-sm);
-}
-
-.footer a {
-    color: var(--color-text-secondary);
-}
-
-/* Smart Insights Panel */
-.insight-card {
-    display: flex;
-    align-items: center;
-    padding: var(--spacing-md);
-    background: linear-gradient(135deg, #f8f9fa 0%, #ffffff 100%);
-    border: 1px solid var(--color-border);
-    border-radius: var(--border-radius);
-    transition: all 0.3s ease;
-    height: 100%;
-}
-
-.insight-card:hover {
-    transform: translateY(-2px);
-    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
-    border-color: var(--color-primary);
-}
-
-.insight-icon {
-    font-size: 2rem;
-    margin-right: var(--spacing-md);
-    opacity: 0.8;
-}
-
-.insight-content {
-    flex: 1;
-}
-
-.insight-title {
-    font-size: 0.9rem;
-    font-weight: var(--font-weight-semibold);
-    color: var(--color-text);
-    margin: 0 0 var(--spacing-xs) 0;
-}
-
-.insight-text {
-    font-size: 0.8rem;
-    color: var(--color-text-secondary);
-    margin: 0;
-    line-height: 1.4;
-}
-
-/* Export Buttons */
-.export-buttons {
-    display: flex;
-    flex-wrap: wrap;
-    gap: var(--spacing-sm);
-    align-items: center;
-}
-
-.export-buttons .btn {
-    font-size: 0.8rem;
-    padding: var(--spacing-xs) var(--spacing-sm);
-    border-radius: var(--border-radius);
-    transition: all 0.2s ease;
-    border: 1px solid var(--color-border);
-    background-color: var(--color-bg-content);
-    color: var(--color-text);
-    cursor: pointer;
-    text-decoration: none;
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-}
-
-.export-buttons .btn:hover {
-    transform: translateY(-1px);
-    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
-    border-color: var(--color-primary);
-    background-color: var(--color-primary-light);
-}
-
-.export-buttons .btn-primary {
-    background-color: var(--color-primary);
-    border-color: var(--color-primary);
-    color: white;
-}
-
-.export-buttons .btn-primary:hover {
-    background-color: #0b5ed7;
-    border-color: #0b5ed7;
-}
-
-.export-buttons .btn-secondary {
-    background-color: #6c757d;
-    border-color: #6c757d;
-    color: white;
-}
-
-.export-buttons .btn-secondary:hover {
-    background-color: #5c636a;
-    border-color: #5c636a;
-}
-
-.permalink-result {
-    background-color: var(--color-bg-secondary);
-    padding: var(--spacing-sm);
-    border-radius: var(--border-radius);
-    border: 1px solid var(--color-border);
-}
-
-.permalink-result input {
-    font-size: 0.8rem;
-    font-family: monospace;
-    width: 100%;
-    padding: var(--spacing-xs);
-    border: 1px solid var(--color-border);
-    border-radius: var(--border-radius);
-    background-color: var(--color-bg-content);
-}
-
-/* Enhanced Stat Cards */
-.stat-card {
-    position: relative;
-    overflow: hidden;
-}
-
-.stat-card::before {
-    content: '';
-    position: absolute;
-    top: 0;
-    left: 0;
-    right: 0;
-    height: 3px;
-    background: linear-gradient(90deg, var(--color-primary), var(--color-primary-light));
-    opacity: 0;
-    transition: opacity 0.3s ease;
-}
-
-.stat-card:hover::before {
-    opacity: 1;
-}
-
-.stat-trend {
-    font-size: 0.7rem;
-    font-weight: var(--font-weight-medium);
-    margin-top: var(--spacing-xs);
-    display: flex;
-    align-items: center;
-    gap: var(--spacing-xs);
-}
-
-.stat-trend.positive {
-    color: #198754;
-}
-
-.stat-trend.negative {
-    color: #dc3545;
-}
-
-.stat-trend.neutral {
-    color: var(--color-text-secondary);
-}
-
-.stat-percentage {
-    font-size: 0.7rem;
-    color: var(--color-text-secondary);
-    margin-top: 2px;
-}
-
-/* Responsive adjustments for visualizations */
-@media (max-width: 768px) {
-    .insight-card {
-        flex-direction: column;
-        text-align: center;
-        padding: var(--spacing-sm);
-    }
-
-    .insight-icon {
-        margin-right: 0;
-        margin-bottom: var(--spacing-xs);
-        font-size: 1.5rem;
-    }
-
-    .export-buttons {
-        justify-content: center;
-    }
-
-    .export-buttons .btn {
-        flex: 1;
-        min-width: 120px;
-    }
-
-    .metric-grid {
-        grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
-        gap: var(--spacing-sm);
-    }
-
-    .metric-card {
-        padding: var(--spacing-md);
-    }
-
-    .metric-value {
-        font-size: 1.5rem;
-    }
-
-    .chart-container {
-        height: 300px;
-        padding: var(--spacing-sm);
-    }
-
-    .viz-card {
-        padding: var(--spacing-md);
-    }
-
-    .chart-legend {
-        flex-direction: column;
-        align-items: center;
-        gap: var(--spacing-sm);
-    }
-
-    .data-table {
-        font-size: 0.8rem;
-    }
-
-    .data-table th,
-    .data-table td {
-        padding: var(--spacing-xs) var(--spacing-sm);
-    }
-}
-
-.footer a:hover {
-    color: var(--color-accent);
-}
-
-/* Responsive Design */
-@media (max-width: 768px) {
-    .nav-menu {
-        display: none;
-        position: absolute;
-        top: 100%;
-        left: 0;
-        right: 0;
-        background-color: var(--color-bg-content);
-        border-top: 1px solid var(--color-border);
-        flex-direction: column;
-        padding: var(--spacing-md);
-        box-shadow: var(--box-shadow-lg);
-    }
-
-    .nav-menu.active {
-        display: flex;
-    }
-
-    .nav-toggle {
-        display: flex;
-    }
-
-    /* Mobile dropdown styling */
-    .nav-dropdown {
-        position: static;
-    }
-
-    .nav-dropdown .dropdown-menu {
-        position: static;
-        opacity: 1;
-        visibility: visible;
-        transform: none;
-        box-shadow: none;
-        border: none;
-        background: transparent;
-        padding: 0;
-        margin: 0;
-        padding-left: var(--spacing-md);
-        border-left: 2px solid var(--color-border);
-        margin-left: var(--spacing-sm);
-        margin-top: var(--spacing-xs);
-    }
-
-    .nav-dropdown .dropdown-menu a {
-        padding: var(--spacing-xs) var(--spacing-sm);
-        font-size: 0.9rem;
-    }
-
-    .nav-dropdown>a::after {
-        content: ' ▾';
-        font-size: 0.7rem;
-        opacity: 0.6;
-    }
-
-    .stats-grid {
-        grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-        gap: var(--spacing-md);
-    }
-
-    .stat-number {
-        font-size: 2rem;
-    }
-
-    h1 {
-        font-size: 2rem;
-    }
-
-    h2 {
-        font-size: 1.5rem;
-    }
-
-    .container {
-        padding: 0 var(--spacing-md);
-    }
-
-    .nav-container {
-        padding: 0 var(--spacing-md);
-    }
-
-    .chart-container {
-        height: 300px;
-    }
-}
-
-@media (max-width: 480px) {
-    .stats-grid {
-        grid-template-columns: 1fr;
-    }
-
-    .stat-number {
-        font-size: 1.75rem;
-    }
-
-    .card {
-        padding: var(--spacing-md);
-    }
-
-    th,
-    td {
-        padding: var(--spacing-sm);
-    }
-
-    .chart-container {
-        height: 250px;
-        padding: var(--spacing-xs);
-    }
-
-    .metric-grid {
-        grid-template-columns: 1fr;
-    }
-
-    .metric-value {
-        font-size: 1.25rem;
-    }
-
-    .viz-title {
-        font-size: 1.1rem;
-    }
-
-    .chart-legend {
-        gap: var(--spacing-xs);
-    }
-
-    .legend-item {
-        font-size: 0.75rem;
-    }
-}
-
-/* ========================================
-   COMPREHENSIVE MOBILE ENHANCEMENTS
-   ======================================== */
-
-/* Touch-friendly minimum sizes for mobile */
-@media (max-width: 768px) {
-
-    /* Improved touch targets (minimum 44px) */
-    button,
-    .btn,
-    .quick-select-btn,
-    .nav-menu a,
-    .year-label {
-        min-height: 44px;
-        min-width: 44px;
-        padding: 0.75rem 1rem;
-    }
-
-    /* Better button group layouts */
-    .quick-select-buttons {
-        display: grid;
-        grid-template-columns: repeat(2, 1fr);
-        gap: 0.5rem;
-        width: 100%;
-    }
-
-    .quick-select-buttons .quick-select-btn {
-        width: 100%;
-        min-width: unset;
-    }
-
-    /* Mobile-optimized year grid */
-    .year-grid {
-        grid-template-columns: repeat(4, 1fr);
-        gap: 0.5rem;
-    }
-
-    .year-label {
-        font-size: 0.875rem;
-        padding: 0.5rem 0.25rem;
-    }
-
-    /* Improved table handling on mobile */
-    .table-container {
-        -webkit-overflow-scrolling: touch;
-        position: relative;
-    }
-
-    table {
-        min-width: 600px;
-        font-size: 0.8rem;
-    }
-
-    th,
-    td {
-        white-space: nowrap;
-        padding: 0.5rem;
-    }
-
-    /* Sticky first column for data tables */
-    .data-table th:first-child,
-    .data-table td:first-child {
-        position: sticky;
-        left: 0;
-        background-color: var(--color-bg-content);
-        z-index: 10;
-        box-shadow: 2px 0 4px rgba(0, 0, 0, 0.1);
-    }
-
-    /* Better card layouts */
-    .row {
-        margin-left: 0;
-        margin-right: 0;
-    }
-
-    .row>[class*='col-'] {
-        padding-left: 0;
-        padding-right: 0;
-        margin-bottom: 1rem;
-    }
-
-    /* Mobile-friendly navigation */
-    .nav-container {
-        height: auto;
-        min-height: 4rem;
-        padding: 0.5rem 1rem;
-    }
-
-    .logo {
-        font-size: 1.1rem;
-    }
-
-    .logo img {
-        width: 1.75rem;
-        height: 1.75rem;
-    }
-
-    /* Full-width mobile menu */
-    .nav-menu {
-        position: fixed;
-        top: 4rem;
-        left: 0;
-        right: 0;
-        max-height: calc(100vh - 4rem);
-        overflow-y: auto;
-        -webkit-overflow-scrolling: touch;
-    }
-
-    .nav-menu li {
-        width: 100%;
-        border-bottom: 1px solid var(--color-border);
-    }
-
-    .nav-menu a {
-        display: block;
-        width: 100%;
-        padding: 1rem 1.5rem;
-        text-align: left;
-    }
-
-    /* Improved chart responsiveness */
-    .chart-container,
-    .homepage-chart-container {
-        height: 250px !important;
-        min-height: 250px;
-    }
-
-    .homepage-preview-container {
-        height: 200px !important;
-    }
-
-    /* Better card spacing */
-    .card {
-        margin-bottom: 1rem;
-        border-radius: 0.5rem;
-    }
-
-    .card-header,
-    .card-body {
-        padding: 1rem;
-    }
-
-    /* Improved stats cards for mobile */
-    .stats-grid {
-        gap: 0.75rem;
-        margin-bottom: 1rem;
-    }
-
-    .stat-card {
-        padding: 1.25rem 1rem;
-    }
-
-    .stat-number {
-        font-size: 1.75rem;
-        margin-bottom: 0.25rem;
-    }
-
-    .stat-label {
-        font-size: 0.8rem;
-    }
-
-    .stat-sublabel,
-    .stat-detail {
-        font-size: 0.7rem;
-    }
-
-    /* Page header mobile optimization */
-    .page-header {
-        padding: 1rem;
-        margin-bottom: 1rem;
-    }
-
-    .page-header h1 {
-        font-size: 1.75rem;
-    }
-
-    .page-header .display-4 {
-        font-size: 1.75rem;
-    }
-
-    .page-header small {
-        font-size: 0.85rem;
-        line-height: 1.4;
-    }
-
-    /* Better form controls */
-    input[type="checkbox"],
-    input[type="radio"] {
-        transform: scale(1.2);
-    }
-
-    /* Improved footer for mobile */
-    .footer {
-        padding: 1.5rem 0;
-        font-size: 0.8rem;
-    }
-
-    .footer>div>div {
-        flex-direction: column;
-        gap: 1rem;
-        text-align: center !important;
-    }
-
-    .footer>div>div>div {
-        text-align: center !important;
-    }
-
-    /* Export and control buttons */
-    .export-buttons {
-        flex-direction: column;
-        width: 100%;
-    }
-
-    .export-buttons .btn {
-        width: 100%;
-        margin-bottom: 0.5rem;
-    }
-
-    /* Insight cards mobile layout */
-    .insight-card {
-        flex-direction: column;
-        text-align: center;
-        padding: 1rem;
-    }
-
-    .insight-icon {
-        margin-right: 0;
-        margin-bottom: 0.5rem;
-    }
-
-    /* Better viz card headers */
-    .viz-header {
-        flex-direction: column;
-        align-items: flex-start;
-        gap: 0.5rem;
-    }
-
-    /* Improved homepage sections */
-    .homepage-chart-section,
-    .homepage-preview-section {
-        padding: 0;
-    }
-
-    .homepage-chart-card {
-        margin-bottom: 1rem;
-        border-radius: 0.5rem;
-    }
-
-    .homepage-chart-header,
-    .homepage-chart-body {
-        padding: 1rem;
-    }
-
-    .homepage-chart-title {
-        font-size: 1.1rem;
-    }
-
-    .homepage-chart-subtitle {
-        font-size: 0.8rem;
-    }
-
-    /* Mobile table scroll indicator */
-    .table-container::after {
-        content: '← Scroll to view more →';
-        display: block;
-        text-align: center;
-        padding: 0.5rem;
-        background: var(--color-bg-secondary);
-        color: var(--color-text-secondary);
-        font-size: 0.75rem;
-        border-top: 1px solid var(--color-border);
-    }
-}
-
-/* Extra small devices (320px - 480px) */
-@media (max-width: 480px) {
-
-    /* Even more compact layouts */
-    body {
-        font-size: 14px;
-    }
-
-    .container {
-        padding: 0 0.75rem;
-    }
-
-    /* Single column year grid */
-    .year-grid {
-        grid-template-columns: repeat(3, 1fr);
-    }
-
-    /* Smaller headings */
-    h1,
-    .display-4 {
-        font-size: 1.5rem !important;
-    }
-
-    h2 {
-        font-size: 1.25rem;
-    }
-
-    h3 {
-        font-size: 1.1rem;
-    }
-
-    /* Ultra-compact stats */
-    .stat-number {
-        font-size: 1.5rem;
-    }
-
-    .stat-label {
-        font-size: 0.75rem;
-    }
-
-    /* Smaller charts */
-    .chart-container,
-    .homepage-chart-container {
-        height: 200px !important;
-    }
-
-    .homepage-preview-container {
-        height: 180px !important;
-    }
-
-    /* Stack button groups vertically */
-    .quick-select-buttons {
-        grid-template-columns: 1fr;
-    }
-
-    /* Compact cards */
-    .card {
-        padding: 0.75rem;
-    }
-
-    .card-header,
-    .card-body {
-        padding: 0.75rem;
-    }
-
-    /* Smaller navigation */
-    .nav-container {
-        padding: 0.5rem 0.75rem;
-    }
-
-    .logo {
-        font-size: 1rem;
-    }
-
-    /* Better logo and text layout */
-    .page-header .btn {
-        font-size: 0.75rem;
-        padding: 0.5rem 0.75rem;
-    }
-}
-
-/* Landscape mobile devices */
-@media (max-width: 900px) and (orientation: landscape) {
-
-    .chart-container,
-    .homepage-chart-container {
-        height: 200px !important;
-    }
-
-    .stats-grid {
-        grid-template-columns: repeat(2, 1fr);
-    }
-
-    .page-header {
-        padding: 0.75rem 1rem;
-    }
-
-    .page-header h1 {
-        font-size: 1.5rem;
-    }
-}
-
-/* Tablet devices (768px - 1024px) */
-@media (min-width: 769px) and (max-width: 1024px) {
-    .stats-grid {
-        grid-template-columns: repeat(2, 1fr);
-    }
-
-    .year-grid {
-        grid-template-columns: repeat(6, 1fr);
-    }
-
-    .container {
-        padding: 0 1.5rem;
-    }
-
-    .chart-container {
-        height: 350px;
-    }
-}
-
-/* Mobile table scroll shadows */
-.table-container {
-    position: relative;
-}
-
-.table-container.scrolled-left::before,
-.table-container.scrolled-right::after {
-    content: '';
-    position: absolute;
-    top: 0;
-    bottom: 0;
-    width: 20px;
-    pointer-events: none;
-    z-index: 2;
-}
-
-.table-container.scrolled-left::before {
-    left: 0;
-    background: linear-gradient(to right, rgba(0, 0, 0, 0.1), transparent);
-}
-
-.table-container.scrolled-right::after {
-    right: 0;
-    background: linear-gradient(to left, rgba(0, 0, 0, 0.1), transparent);
-}
-
-/* Mobile viewport height fix for iOS */
-@supports (-webkit-touch-callout: none) {
-
-    .chart-container,
-    .homepage-chart-container {
-        min-height: -webkit-fill-available;
-    }
-}
-
-/* Improved touch scrolling for all mobile devices */
-* {
-    -webkit-overflow-scrolling: touch;
-}
-
-/* Prevent zoom on input focus (mobile Safari) */
-@media (max-width: 768px) {
-
-    input[type="text"],
-    input[type="email"],
-    input[type="search"],
-    select,
-    textarea {
-        font-size: 16px !important;
-    }
-}
-
-/* Mobile-friendly hover states (disable on touch devices) */
-@media (hover: none) and (pointer: coarse) {
-
-    .card:hover,
-    .stat-card:hover,
-    .viz-card:hover {
-        transform: none;
-        box-shadow: var(--box-shadow);
-    }
-
-    .nav-menu a:hover {
-        background-color: transparent;
-    }
-}
-
-/* Safe area insets for notched devices (iPhone X+) */
-@supports (padding: max(0px)) {
-    body {
-        padding-left: max(0px, env(safe-area-inset-left));
-        padding-right: max(0px, env(safe-area-inset-right));
-    }
-
-    .header {
-        padding-left: max(0px, env(safe-area-inset-left));
-        padding-right: max(0px, env(safe-area-inset-right));
-    }
-
-    .footer {
-        padding-left: max(0px, env(safe-area-inset-left));
-        padding-right: max(0px, env(safe-area-inset-right));
-        padding-bottom: max(1.5rem, env(safe-area-inset-bottom));
-    }
-}
-
-/* Print styles */
-@media print {
-
-    .header,
-    .footer,
-    .nav-toggle,
-    .quick-select-buttons,
-    .export-buttons,
-    .btn {
-        display: none !important;
-    }
-
-    .container {
-        max-width: 100%;
-        padding: 0;
-    }
-
-    .card {
-        break-inside: avoid;
-        page-break-inside: avoid;
-    }
-
-    body {
-        background: white;
-    }
-}
\ No newline at end of file
diff --git a/static/js/chart.min.js b/static/js/chart.min.js
deleted file mode 100644
index db52cc9178f..00000000000
--- a/static/js/chart.min.js
+++ /dev/null
@@ -1,14 +0,0 @@
-/**
- * Minified by jsDelivr using Terser v5.19.2.
- * Original file: /npm/chart.js@4.4.0/dist/chart.js
- *
- * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files
- */
-/*!
- * Chart.js v4.4.0
- * https://www.chartjs.org
- * (c) 2023 Chart.js Contributors
- * Released under the MIT License
- */
-import{r as requestAnimFrame,a as resolve,e as effects,c as color,i as isObject,d as defaults,b as isArray,v as valueOrDefault,u as unlistenArrayEvents,l as listenArrayEvents,f as resolveObjectKey,g as isNumberFinite,h as defined,s as sign,j as createContext,k as isNullOrUndef,_ as _arrayUnique,t as toRadians,m as toPercentage,n as toDimension,T as TAU,o as formatNumber,p as _angleBetween,H as HALF_PI,P as PI,q as _getStartAndCountOfVisiblePoints,w as _scaleRangesChanged,x as isNumber,y as _parseObjectDataRadialScale,z as getRelativePosition,A as _rlookupByKey,B as _lookupByKey,C as _isPointInArea,D as getAngleFromPoint,E as toPadding,F as each,G as getMaximumSize,I as _getParentNode,J as readUsedSize,K as supportsEventListenerOptions,L as throttled,M as _isDomSupported,N as _factorize,O as finiteOrDefault,Q as callback,R as _addGrace,S as _limitValue,U as toDegrees,V as _measureText,W as _int16Range,X as _alignPixel,Y as clipArea,Z as renderText,$ as unclipArea,a0 as toFont,a1 as _toLeftRightCenter,a2 as _alignStartEnd,a3 as overrides,a4 as merge,a5 as _capitalize,a6 as descriptors,a7 as isFunction,a8 as _attachContext,a9 as _createResolver,aa as _descriptors,ab as mergeIf,ac as uid,ad as debounce,ae as retinaScale,af as clearCanvas,ag as setsEqual,ah as _elementsEqual,ai as _isClickEvent,aj as _isBetween,ak as _readValueToProps,al as _updateBezierControlPoints,am as _computeSegments,an as _boundSegments,ao as _steppedInterpolation,ap as _bezierInterpolation,aq as _pointInLine,ar as _steppedLineTo,as as _bezierCurveTo,at as drawPoint,au as addRoundedRectPath,av as toTRBL,aw as toTRBLCorners,ax as _boundSegment,ay as _normalizeAngle,az as getRtlAdapter,aA as overrideTextDirection,aB as _textX,aC as restoreTextDirection,aD as drawPointLegend,aE as distanceBetweenPoints,aF as noop,aG as _setMinAndMaxByKey,aH as niceNum,aI as almostWhole,aJ as almostEquals,aK as _decimalPlaces,aL as Ticks,aM as log10,aN as _longestText,aO as _filterBetween,aP as _lookup}from"./chunks/helpers.segment.js";import"@kurkle/color";class Animator{constructor(){this._request=null,this._charts=new Map,this._running=!1,this._lastDate=void 0}_notify(t,e,i,s){const n=e.listeners[s],a=e.duration;n.forEach((s=>s({chart:t,initial:e.initial,numSteps:a,currentStep:Math.min(i-e.start,a)})))}_refresh(){this._request||(this._running=!0,this._request=requestAnimFrame.call(window,(()=>{this._update(),this._request=null,this._running&&this._refresh()})))}_update(t=Date.now()){let e=0;this._charts.forEach(((i,s)=>{if(!i.running||!i.items.length)return;const n=i.items;let a,o=n.length-1,r=!1;for(;o>=0;--o)a=n[o],a._active?(a._total>i.duration&&(i.duration=a._total),a.tick(t),r=!0):(n[o]=n[n.length-1],n.pop());r&&(s.draw(),this._notify(s,i,t,"progress")),n.length||(i.running=!1,this._notify(s,i,t,"complete"),i.initial=!1),e+=n.length})),this._lastDate=t,0===e&&(this._running=!1)}_getAnims(t){const e=this._charts;let i=e.get(t);return i||(i={running:!1,initial:!0,items:[],listeners:{complete:[],progress:[]}},e.set(t,i)),i}listen(t,e,i){this._getAnims(t).listeners[e].push(i)}add(t,e){e&&e.length&&this._getAnims(t).items.push(...e)}has(t){return this._getAnims(t).items.length>0}start(t){const e=this._charts.get(t);e&&(e.running=!0,e.start=Date.now(),e.duration=e.items.reduce(((t,e)=>Math.max(t,e._duration)),0),this._refresh())}running(t){if(!this._running)return!1;const e=this._charts.get(t);return!!(e&&e.running&&e.items.length)}stop(t){const e=this._charts.get(t);if(!e||!e.items.length)return;const i=e.items;let s=i.length-1;for(;s>=0;--s)i[s].cancel();e.items=[],this._notify(t,e,Date.now(),"complete")}remove(t){return this._charts.delete(t)}}var animator=new Animator;const transparent="transparent",interpolators={boolean:(t,e,i)=>i>.5?e:t,color(t,e,i){const s=color(t||transparent),n=s.valid&&color(e||transparent);return n&&n.valid?n.mix(s,i).hexString():e},number:(t,e,i)=>t+(e-t)*i};class Animation{constructor(t,e,i,s){const n=e[i];s=resolve([t.to,s,n,t.from]);const a=resolve([t.from,n,s]);this._active=!0,this._fn=t.fn||interpolators[t.type||typeof a],this._easing=effects[t.easing]||effects.linear,this._start=Math.floor(Date.now()+(t.delay||0)),this._duration=this._total=Math.floor(t.duration),this._loop=!!t.loop,this._target=e,this._prop=i,this._from=a,this._to=s,this._promises=void 0}active(){return this._active}update(t,e,i){if(this._active){this._notify(!1);const s=this._target[this._prop],n=i-this._start,a=this._duration-n;this._start=i,this._duration=Math.floor(Math.max(a,t.duration)),this._total+=n,this._loop=!!t.loop,this._to=resolve([t.to,e,s,t.from]),this._from=resolve([t.from,s,e])}}cancel(){this._active&&(this.tick(Date.now()),this._active=!1,this._notify(!1))}tick(t){const e=t-this._start,i=this._duration,s=this._prop,n=this._from,a=this._loop,o=this._to;let r;if(this._active=n!==o&&(a||e<i),!this._active)return this._target[s]=o,void this._notify(!0);e<0?this._target[s]=n:(r=e/i%2,r=a&&r>1?2-r:r,r=this._easing(Math.min(1,Math.max(0,r))),this._target[s]=this._fn(n,o,r))}wait(){const t=this._promises||(this._promises=[]);return new Promise(((e,i)=>{t.push({res:e,rej:i})}))}_notify(t){const e=t?"res":"rej",i=this._promises||[];for(let t=0;t<i.length;t++)i[t][e]()}}class Animations{constructor(t,e){this._chart=t,this._properties=new Map,this.configure(e)}configure(t){if(!isObject(t))return;const e=Object.keys(defaults.animation),i=this._properties;Object.getOwnPropertyNames(t).forEach((s=>{const n=t[s];if(!isObject(n))return;const a={};for(const t of e)a[t]=n[t];(isArray(n.properties)&&n.properties||[s]).forEach((t=>{t!==s&&i.has(t)||i.set(t,a)}))}))}_animateOptions(t,e){const i=e.options,s=resolveTargetOptions(t,i);if(!s)return[];const n=this._createAnimations(s,i);return i.$shared&&awaitAll(t.options.$animations,i).then((()=>{t.options=i}),(()=>{})),n}_createAnimations(t,e){const i=this._properties,s=[],n=t.$animations||(t.$animations={}),a=Object.keys(e),o=Date.now();let r;for(r=a.length-1;r>=0;--r){const l=a[r];if("$"===l.charAt(0))continue;if("options"===l){s.push(...this._animateOptions(t,e));continue}const h=e[l];let c=n[l];const d=i.get(l);if(c){if(d&&c.active()){c.update(d,h,o);continue}c.cancel()}d&&d.duration?(n[l]=c=new Animation(d,t,l,h),s.push(c)):t[l]=h}return s}update(t,e){if(0===this._properties.size)return void Object.assign(t,e);const i=this._createAnimations(t,e);return i.length?(animator.add(this._chart,i),!0):void 0}}function awaitAll(t,e){const i=[],s=Object.keys(e);for(let e=0;e<s.length;e++){const n=t[s[e]];n&&n.active()&&i.push(n.wait())}return Promise.all(i)}function resolveTargetOptions(t,e){if(!e)return;let i=t.options;if(i)return i.$shared&&(t.options=i=Object.assign({},i,{$shared:!1,$animations:{}})),i;t.options=e}function scaleClip(t,e){const i=t&&t.options||{},s=i.reverse,n=void 0===i.min?e:0,a=void 0===i.max?e:0;return{start:s?a:n,end:s?n:a}}function defaultClip(t,e,i){if(!1===i)return!1;const s=scaleClip(t,i),n=scaleClip(e,i);return{top:n.end,right:s.end,bottom:n.start,left:s.start}}function toClip(t){let e,i,s,n;return isObject(t)?(e=t.top,i=t.right,s=t.bottom,n=t.left):e=i=s=n=t,{top:e,right:i,bottom:s,left:n,disabled:!1===t}}function getSortedDatasetIndices(t,e){const i=[],s=t._getSortedDatasetMetas(e);let n,a;for(n=0,a=s.length;n<a;++n)i.push(s[n].index);return i}function applyStack(t,e,i,s={}){const n=t.keys,a="single"===s.mode;let o,r,l,h;if(null!==e){for(o=0,r=n.length;o<r;++o){if(l=+n[o],l===i){if(s.all)continue;break}h=t.values[l],isNumberFinite(h)&&(a||0===e||sign(e)===sign(h))&&(e+=h)}return e}}function convertObjectDataToArray(t){const e=Object.keys(t),i=new Array(e.length);let s,n,a;for(s=0,n=e.length;s<n;++s)a=e[s],i[s]={x:a,y:t[a]};return i}function isStacked(t,e){const i=t&&t.options.stacked;return i||void 0===i&&void 0!==e.stack}function getStackKey(t,e,i){return`${t.id}.${e.id}.${i.stack||i.type}`}function getUserBounds(t){const{min:e,max:i,minDefined:s,maxDefined:n}=t.getUserBounds();return{min:s?e:Number.NEGATIVE_INFINITY,max:n?i:Number.POSITIVE_INFINITY}}function getOrCreateStack(t,e,i){const s=t[e]||(t[e]={});return s[i]||(s[i]={})}function getLastIndexInStack(t,e,i,s){for(const n of e.getMatchingVisibleMetas(s).reverse()){const e=t[n.index];if(i&&e>0||!i&&e<0)return n.index}return null}function updateStacks(t,e){const{chart:i,_cachedMeta:s}=t,n=i._stacks||(i._stacks={}),{iScale:a,vScale:o,index:r}=s,l=a.axis,h=o.axis,c=getStackKey(a,o,s),d=e.length;let u;for(let t=0;t<d;++t){const i=e[t],{[l]:a,[h]:d}=i;u=(i._stacks||(i._stacks={}))[h]=getOrCreateStack(n,c,a),u[r]=d,u._top=getLastIndexInStack(u,o,!0,s.type),u._bottom=getLastIndexInStack(u,o,!1,s.type);(u._visualValues||(u._visualValues={}))[r]=d}}function getFirstScaleId(t,e){const i=t.scales;return Object.keys(i).filter((t=>i[t].axis===e)).shift()}function createDatasetContext(t,e){return createContext(t,{active:!1,dataset:void 0,datasetIndex:e,index:e,mode:"default",type:"dataset"})}function createDataContext(t,e,i){return createContext(t,{active:!1,dataIndex:e,parsed:void 0,raw:void 0,element:i,index:e,mode:"default",type:"data"})}function clearStacks(t,e){const i=t.controller.index,s=t.vScale&&t.vScale.axis;if(s){e=e||t._parsed;for(const t of e){const e=t._stacks;if(!e||void 0===e[s]||void 0===e[s][i])return;delete e[s][i],void 0!==e[s]._visualValues&&void 0!==e[s]._visualValues[i]&&delete e[s]._visualValues[i]}}}const isDirectUpdateMode=t=>"reset"===t||"none"===t,cloneIfNotShared=(t,e)=>e?t:Object.assign({},t),createStack=(t,e,i)=>t&&!e.hidden&&e._stacked&&{keys:getSortedDatasetIndices(i,!0),values:null};class DatasetController{static defaults={};static datasetElementType=null;static dataElementType=null;constructor(t,e){this.chart=t,this._ctx=t.ctx,this.index=e,this._cachedDataOpts={},this._cachedMeta=this.getMeta(),this._type=this._cachedMeta.type,this.options=void 0,this._parsing=!1,this._data=void 0,this._objectData=void 0,this._sharedOptions=void 0,this._drawStart=void 0,this._drawCount=void 0,this.enableOptionSharing=!1,this.supportsDecimation=!1,this.$context=void 0,this._syncList=[],this.datasetElementType=new.target.datasetElementType,this.dataElementType=new.target.dataElementType,this.initialize()}initialize(){const t=this._cachedMeta;this.configure(),this.linkScales(),t._stacked=isStacked(t.vScale,t),this.addElements(),this.options.fill&&!this.chart.isPluginEnabled("filler")&&console.warn("Tried to use the 'fill' option without the 'Filler' plugin enabled. Please import and register the 'Filler' plugin and make sure it is not disabled in the options")}updateIndex(t){this.index!==t&&clearStacks(this._cachedMeta),this.index=t}linkScales(){const t=this.chart,e=this._cachedMeta,i=this.getDataset(),s=(t,e,i,s)=>"x"===t?e:"r"===t?s:i,n=e.xAxisID=valueOrDefault(i.xAxisID,getFirstScaleId(t,"x")),a=e.yAxisID=valueOrDefault(i.yAxisID,getFirstScaleId(t,"y")),o=e.rAxisID=valueOrDefault(i.rAxisID,getFirstScaleId(t,"r")),r=e.indexAxis,l=e.iAxisID=s(r,n,a,o),h=e.vAxisID=s(r,a,n,o);e.xScale=this.getScaleForId(n),e.yScale=this.getScaleForId(a),e.rScale=this.getScaleForId(o),e.iScale=this.getScaleForId(l),e.vScale=this.getScaleForId(h)}getDataset(){return this.chart.data.datasets[this.index]}getMeta(){return this.chart.getDatasetMeta(this.index)}getScaleForId(t){return this.chart.scales[t]}_getOtherScale(t){const e=this._cachedMeta;return t===e.iScale?e.vScale:e.iScale}reset(){this._update("reset")}_destroy(){const t=this._cachedMeta;this._data&&unlistenArrayEvents(this._data,this),t._stacked&&clearStacks(t)}_dataCheck(){const t=this.getDataset(),e=t.data||(t.data=[]),i=this._data;if(isObject(e))this._data=convertObjectDataToArray(e);else if(i!==e){if(i){unlistenArrayEvents(i,this);const t=this._cachedMeta;clearStacks(t),t._parsed=[]}e&&Object.isExtensible(e)&&listenArrayEvents(e,this),this._syncList=[],this._data=e}}addElements(){const t=this._cachedMeta;this._dataCheck(),this.datasetElementType&&(t.dataset=new this.datasetElementType)}buildOrUpdateElements(t){const e=this._cachedMeta,i=this.getDataset();let s=!1;this._dataCheck();const n=e._stacked;e._stacked=isStacked(e.vScale,e),e.stack!==i.stack&&(s=!0,clearStacks(e),e.stack=i.stack),this._resyncElements(t),(s||n!==e._stacked)&&updateStacks(this,e._parsed)}configure(){const t=this.chart.config,e=t.datasetScopeKeys(this._type),i=t.getOptionScopes(this.getDataset(),e,!0);this.options=t.createResolver(i,this.getContext()),this._parsing=this.options.parsing,this._cachedDataOpts={}}parse(t,e){const{_cachedMeta:i,_data:s}=this,{iScale:n,_stacked:a}=i,o=n.axis;let r,l,h,c=0===t&&e===s.length||i._sorted,d=t>0&&i._parsed[t-1];if(!1===this._parsing)i._parsed=s,i._sorted=!0,h=s;else{h=isArray(s[t])?this.parseArrayData(i,s,t,e):isObject(s[t])?this.parseObjectData(i,s,t,e):this.parsePrimitiveData(i,s,t,e);const n=()=>null===l[o]||d&&l[o]<d[o];for(r=0;r<e;++r)i._parsed[r+t]=l=h[r],c&&(n()&&(c=!1),d=l);i._sorted=c}a&&updateStacks(this,h)}parsePrimitiveData(t,e,i,s){const{iScale:n,vScale:a}=t,o=n.axis,r=a.axis,l=n.getLabels(),h=n===a,c=new Array(s);let d,u,g;for(d=0,u=s;d<u;++d)g=d+i,c[d]={[o]:h||n.parse(l[g],g),[r]:a.parse(e[g],g)};return c}parseArrayData(t,e,i,s){const{xScale:n,yScale:a}=t,o=new Array(s);let r,l,h,c;for(r=0,l=s;r<l;++r)h=r+i,c=e[h],o[r]={x:n.parse(c[0],h),y:a.parse(c[1],h)};return o}parseObjectData(t,e,i,s){const{xScale:n,yScale:a}=t,{xAxisKey:o="x",yAxisKey:r="y"}=this._parsing,l=new Array(s);let h,c,d,u;for(h=0,c=s;h<c;++h)d=h+i,u=e[d],l[h]={x:n.parse(resolveObjectKey(u,o),d),y:a.parse(resolveObjectKey(u,r),d)};return l}getParsed(t){return this._cachedMeta._parsed[t]}getDataElement(t){return this._cachedMeta.data[t]}applyStack(t,e,i){const s=this.chart,n=this._cachedMeta,a=e[t.axis];return applyStack({keys:getSortedDatasetIndices(s,!0),values:e._stacks[t.axis]._visualValues},a,n.index,{mode:i})}updateRangeFromParsed(t,e,i,s){const n=i[e.axis];let a=null===n?NaN:n;const o=s&&i._stacks[e.axis];s&&o&&(s.values=o,a=applyStack(s,n,this._cachedMeta.index)),t.min=Math.min(t.min,a),t.max=Math.max(t.max,a)}getMinMax(t,e){const i=this._cachedMeta,s=i._parsed,n=i._sorted&&t===i.iScale,a=s.length,o=this._getOtherScale(t),r=createStack(e,i,this.chart),l={min:Number.POSITIVE_INFINITY,max:Number.NEGATIVE_INFINITY},{min:h,max:c}=getUserBounds(o);let d,u;function g(){u=s[d];const e=u[o.axis];return!isNumberFinite(u[t.axis])||h>e||c<e}for(d=0;d<a&&(g()||(this.updateRangeFromParsed(l,t,u,r),!n));++d);if(n)for(d=a-1;d>=0;--d)if(!g()){this.updateRangeFromParsed(l,t,u,r);break}return l}getAllParsedValues(t){const e=this._cachedMeta._parsed,i=[];let s,n,a;for(s=0,n=e.length;s<n;++s)a=e[s][t.axis],isNumberFinite(a)&&i.push(a);return i}getMaxOverflow(){return!1}getLabelAndValue(t){const e=this._cachedMeta,i=e.iScale,s=e.vScale,n=this.getParsed(t);return{label:i?""+i.getLabelForValue(n[i.axis]):"",value:s?""+s.getLabelForValue(n[s.axis]):""}}_update(t){const e=this._cachedMeta;this.update(t||"default"),e._clip=toClip(valueOrDefault(this.options.clip,defaultClip(e.xScale,e.yScale,this.getMaxOverflow())))}update(t){}draw(){const t=this._ctx,e=this.chart,i=this._cachedMeta,s=i.data||[],n=e.chartArea,a=[],o=this._drawStart||0,r=this._drawCount||s.length-o,l=this.options.drawActiveElementsOnTop;let h;for(i.dataset&&i.dataset.draw(t,n,o,r),h=o;h<o+r;++h){const e=s[h];e.hidden||(e.active&&l?a.push(e):e.draw(t,n))}for(h=0;h<a.length;++h)a[h].draw(t,n)}getStyle(t,e){const i=e?"active":"default";return void 0===t&&this._cachedMeta.dataset?this.resolveDatasetElementOptions(i):this.resolveDataElementOptions(t||0,i)}getContext(t,e,i){const s=this.getDataset();let n;if(t>=0&&t<this._cachedMeta.data.length){const e=this._cachedMeta.data[t];n=e.$context||(e.$context=createDataContext(this.getContext(),t,e)),n.parsed=this.getParsed(t),n.raw=s.data[t],n.index=n.dataIndex=t}else n=this.$context||(this.$context=createDatasetContext(this.chart.getContext(),this.index)),n.dataset=s,n.index=n.datasetIndex=this.index;return n.active=!!e,n.mode=i,n}resolveDatasetElementOptions(t){return this._resolveElementOptions(this.datasetElementType.id,t)}resolveDataElementOptions(t,e){return this._resolveElementOptions(this.dataElementType.id,e,t)}_resolveElementOptions(t,e="default",i){const s="active"===e,n=this._cachedDataOpts,a=t+"-"+e,o=n[a],r=this.enableOptionSharing&&defined(i);if(o)return cloneIfNotShared(o,r);const l=this.chart.config,h=l.datasetElementScopeKeys(this._type,t),c=s?[`${t}Hover`,"hover",t,""]:[t,""],d=l.getOptionScopes(this.getDataset(),h),u=Object.keys(defaults.elements[t]),g=l.resolveNamedOptions(d,u,(()=>this.getContext(i,s,e)),c);return g.$shared&&(g.$shared=r,n[a]=Object.freeze(cloneIfNotShared(g,r))),g}_resolveAnimations(t,e,i){const s=this.chart,n=this._cachedDataOpts,a=`animation-${e}`,o=n[a];if(o)return o;let r;if(!1!==s.options.animation){const s=this.chart.config,n=s.datasetAnimationScopeKeys(this._type,e),a=s.getOptionScopes(this.getDataset(),n);r=s.createResolver(a,this.getContext(t,i,e))}const l=new Animations(s,r&&r.animations);return r&&r._cacheable&&(n[a]=Object.freeze(l)),l}getSharedOptions(t){if(t.$shared)return this._sharedOptions||(this._sharedOptions=Object.assign({},t))}includeOptions(t,e){return!e||isDirectUpdateMode(t)||this.chart._animationsDisabled}_getSharedOptions(t,e){const i=this.resolveDataElementOptions(t,e),s=this._sharedOptions,n=this.getSharedOptions(i),a=this.includeOptions(e,n)||n!==s;return this.updateSharedOptions(n,e,i),{sharedOptions:n,includeOptions:a}}updateElement(t,e,i,s){isDirectUpdateMode(s)?Object.assign(t,i):this._resolveAnimations(e,s).update(t,i)}updateSharedOptions(t,e,i){t&&!isDirectUpdateMode(e)&&this._resolveAnimations(void 0,e).update(t,i)}_setStyle(t,e,i,s){t.active=s;const n=this.getStyle(e,s);this._resolveAnimations(e,i,s).update(t,{options:!s&&this.getSharedOptions(n)||n})}removeHoverStyle(t,e,i){this._setStyle(t,i,"active",!1)}setHoverStyle(t,e,i){this._setStyle(t,i,"active",!0)}_removeDatasetHoverStyle(){const t=this._cachedMeta.dataset;t&&this._setStyle(t,void 0,"active",!1)}_setDatasetHoverStyle(){const t=this._cachedMeta.dataset;t&&this._setStyle(t,void 0,"active",!0)}_resyncElements(t){const e=this._data,i=this._cachedMeta.data;for(const[t,e,i]of this._syncList)this[t](e,i);this._syncList=[];const s=i.length,n=e.length,a=Math.min(n,s);a&&this.parse(0,a),n>s?this._insertElements(s,n-s,t):n<s&&this._removeElements(n,s-n)}_insertElements(t,e,i=!0){const s=this._cachedMeta,n=s.data,a=t+e;let o;const r=t=>{for(t.length+=e,o=t.length-1;o>=a;o--)t[o]=t[o-e]};for(r(n),o=t;o<a;++o)n[o]=new this.dataElementType;this._parsing&&r(s._parsed),this.parse(t,e),i&&this.updateElements(n,t,e,"reset")}updateElements(t,e,i,s){}_removeElements(t,e){const i=this._cachedMeta;if(this._parsing){const s=i._parsed.splice(t,e);i._stacked&&clearStacks(i,s)}i.data.splice(t,e)}_sync(t){if(this._parsing)this._syncList.push(t);else{const[e,i,s]=t;this[e](i,s)}this.chart._dataChanges.push([this.index,...t])}_onDataPush(){const t=arguments.length;this._sync(["_insertElements",this.getDataset().data.length-t,t])}_onDataPop(){this._sync(["_removeElements",this._cachedMeta.data.length-1,1])}_onDataShift(){this._sync(["_removeElements",0,1])}_onDataSplice(t,e){e&&this._sync(["_removeElements",t,e]);const i=arguments.length-2;i&&this._sync(["_insertElements",t,i])}_onDataUnshift(){this._sync(["_insertElements",0,arguments.length])}}function getAllScaleValues(t,e){if(!t._cache.$bar){const i=t.getMatchingVisibleMetas(e);let s=[];for(let e=0,n=i.length;e<n;e++)s=s.concat(i[e].controller.getAllParsedValues(t));t._cache.$bar=_arrayUnique(s.sort(((t,e)=>t-e)))}return t._cache.$bar}function computeMinSampleSize(t){const e=t.iScale,i=getAllScaleValues(e,t.type);let s,n,a,o,r=e._length;const l=()=>{32767!==a&&-32768!==a&&(defined(o)&&(r=Math.min(r,Math.abs(a-o)||r)),o=a)};for(s=0,n=i.length;s<n;++s)a=e.getPixelForValue(i[s]),l();for(o=void 0,s=0,n=e.ticks.length;s<n;++s)a=e.getPixelForTick(s),l();return r}function computeFitCategoryTraits(t,e,i,s){const n=i.barThickness;let a,o;return isNullOrUndef(n)?(a=e.min*i.categoryPercentage,o=i.barPercentage):(a=n*s,o=1),{chunk:a/s,ratio:o,start:e.pixels[t]-a/2}}function computeFlexCategoryTraits(t,e,i,s){const n=e.pixels,a=n[t];let o=t>0?n[t-1]:null,r=t<n.length-1?n[t+1]:null;const l=i.categoryPercentage;null===o&&(o=a-(null===r?e.end-e.start:r-a)),null===r&&(r=a+a-o);const h=a-(a-Math.min(o,r))/2*l;return{chunk:Math.abs(r-o)/2*l/s,ratio:i.barPercentage,start:h}}function parseFloatBar(t,e,i,s){const n=i.parse(t[0],s),a=i.parse(t[1],s),o=Math.min(n,a),r=Math.max(n,a);let l=o,h=r;Math.abs(o)>Math.abs(r)&&(l=r,h=o),e[i.axis]=h,e._custom={barStart:l,barEnd:h,start:n,end:a,min:o,max:r}}function parseValue(t,e,i,s){return isArray(t)?parseFloatBar(t,e,i,s):e[i.axis]=i.parse(t,s),e}function parseArrayOrPrimitive(t,e,i,s){const n=t.iScale,a=t.vScale,o=n.getLabels(),r=n===a,l=[];let h,c,d,u;for(h=i,c=i+s;h<c;++h)u=e[h],d={},d[n.axis]=r||n.parse(o[h],h),l.push(parseValue(u,d,a,h));return l}function isFloatBar(t){return t&&void 0!==t.barStart&&void 0!==t.barEnd}function barSign(t,e,i){return 0!==t?sign(t):(e.isHorizontal()?1:-1)*(e.min>=i?1:-1)}function borderProps(t){let e,i,s,n,a;return t.horizontal?(e=t.base>t.x,i="left",s="right"):(e=t.base<t.y,i="bottom",s="top"),e?(n="end",a="start"):(n="start",a="end"),{start:i,end:s,reverse:e,top:n,bottom:a}}function setBorderSkipped(t,e,i,s){let n=e.borderSkipped;const a={};if(!n)return void(t.borderSkipped=a);if(!0===n)return void(t.borderSkipped={top:!0,right:!0,bottom:!0,left:!0});const{start:o,end:r,reverse:l,top:h,bottom:c}=borderProps(t);"middle"===n&&i&&(t.enableBorderRadius=!0,(i._top||0)===s?n=h:(i._bottom||0)===s?n=c:(a[parseEdge(c,o,r,l)]=!0,n=h)),a[parseEdge(n,o,r,l)]=!0,t.borderSkipped=a}function parseEdge(t,e,i,s){return t=s?startEnd(t=swap(t,e,i),i,e):startEnd(t,e,i)}function swap(t,e,i){return t===e?i:t===i?e:t}function startEnd(t,e,i){return"start"===t?e:"end"===t?i:t}function setInflateAmount(t,{inflateAmount:e},i){t.inflateAmount="auto"===e?1===i?.33:0:e}class BarController extends DatasetController{static id="bar";static defaults={datasetElementType:!1,dataElementType:"bar",categoryPercentage:.8,barPercentage:.9,grouped:!0,animations:{numbers:{type:"number",properties:["x","y","base","width","height"]}}};static overrides={scales:{_index_:{type:"category",offset:!0,grid:{offset:!0}},_value_:{type:"linear",beginAtZero:!0}}};parsePrimitiveData(t,e,i,s){return parseArrayOrPrimitive(t,e,i,s)}parseArrayData(t,e,i,s){return parseArrayOrPrimitive(t,e,i,s)}parseObjectData(t,e,i,s){const{iScale:n,vScale:a}=t,{xAxisKey:o="x",yAxisKey:r="y"}=this._parsing,l="x"===n.axis?o:r,h="x"===a.axis?o:r,c=[];let d,u,g,p;for(d=i,u=i+s;d<u;++d)p=e[d],g={},g[n.axis]=n.parse(resolveObjectKey(p,l),d),c.push(parseValue(resolveObjectKey(p,h),g,a,d));return c}updateRangeFromParsed(t,e,i,s){super.updateRangeFromParsed(t,e,i,s);const n=i._custom;n&&e===this._cachedMeta.vScale&&(t.min=Math.min(t.min,n.min),t.max=Math.max(t.max,n.max))}getMaxOverflow(){return 0}getLabelAndValue(t){const e=this._cachedMeta,{iScale:i,vScale:s}=e,n=this.getParsed(t),a=n._custom,o=isFloatBar(a)?"["+a.start+", "+a.end+"]":""+s.getLabelForValue(n[s.axis]);return{label:""+i.getLabelForValue(n[i.axis]),value:o}}initialize(){this.enableOptionSharing=!0,super.initialize();this._cachedMeta.stack=this.getDataset().stack}update(t){const e=this._cachedMeta;this.updateElements(e.data,0,e.data.length,t)}updateElements(t,e,i,s){const n="reset"===s,{index:a,_cachedMeta:{vScale:o}}=this,r=o.getBasePixel(),l=o.isHorizontal(),h=this._getRuler(),{sharedOptions:c,includeOptions:d}=this._getSharedOptions(e,s);for(let u=e;u<e+i;u++){const e=this.getParsed(u),i=n||isNullOrUndef(e[o.axis])?{base:r,head:r}:this._calculateBarValuePixels(u),g=this._calculateBarIndexPixels(u,h),p=(e._stacks||{})[o.axis],f={horizontal:l,base:i.base,enableBorderRadius:!p||isFloatBar(e._custom)||a===p._top||a===p._bottom,x:l?i.head:g.center,y:l?g.center:i.head,height:l?g.size:Math.abs(i.size),width:l?Math.abs(i.size):g.size};d&&(f.options=c||this.resolveDataElementOptions(u,t[u].active?"active":s));const m=f.options||t[u].options;setBorderSkipped(f,m,p,a),setInflateAmount(f,m,h.ratio),this.updateElement(t[u],u,f,s)}}_getStacks(t,e){const{iScale:i}=this._cachedMeta,s=i.getMatchingVisibleMetas(this._type).filter((t=>t.controller.options.grouped)),n=i.options.stacked,a=[],o=t=>{const i=t.controller.getParsed(e),s=i&&i[t.vScale.axis];if(isNullOrUndef(s)||isNaN(s))return!0};for(const i of s)if((void 0===e||!o(i))&&((!1===n||-1===a.indexOf(i.stack)||void 0===n&&void 0===i.stack)&&a.push(i.stack),i.index===t))break;return a.length||a.push(void 0),a}_getStackCount(t){return this._getStacks(void 0,t).length}_getStackIndex(t,e,i){const s=this._getStacks(t,i),n=void 0!==e?s.indexOf(e):-1;return-1===n?s.length-1:n}_getRuler(){const t=this.options,e=this._cachedMeta,i=e.iScale,s=[];let n,a;for(n=0,a=e.data.length;n<a;++n)s.push(i.getPixelForValue(this.getParsed(n)[i.axis],n));const o=t.barThickness;return{min:o||computeMinSampleSize(e),pixels:s,start:i._startPixel,end:i._endPixel,stackCount:this._getStackCount(),scale:i,grouped:t.grouped,ratio:o?1:t.categoryPercentage*t.barPercentage}}_calculateBarValuePixels(t){const{_cachedMeta:{vScale:e,_stacked:i,index:s},options:{base:n,minBarLength:a}}=this,o=n||0,r=this.getParsed(t),l=r._custom,h=isFloatBar(l);let c,d,u=r[e.axis],g=0,p=i?this.applyStack(e,r,i):u;p!==u&&(g=p-u,p=u),h&&(u=l.barStart,p=l.barEnd-l.barStart,0!==u&&sign(u)!==sign(l.barEnd)&&(g=0),g+=u);const f=isNullOrUndef(n)||h?g:n;let m=e.getPixelForValue(f);if(c=this.chart.getDataVisibility(t)?e.getPixelForValue(g+p):m,d=c-m,Math.abs(d)<a){d=barSign(d,e,o)*a,u===o&&(m-=d/2);const t=e.getPixelForDecimal(0),n=e.getPixelForDecimal(1),l=Math.min(t,n),g=Math.max(t,n);m=Math.max(Math.min(m,g),l),c=m+d,i&&!h&&(r._stacks[e.axis]._visualValues[s]=e.getValueForPixel(c)-e.getValueForPixel(m))}if(m===e.getPixelForValue(o)){const t=sign(d)*e.getLineWidthForValue(o)/2;m+=t,d-=t}return{size:d,base:m,head:c,center:c+d/2}}_calculateBarIndexPixels(t,e){const i=e.scale,s=this.options,n=s.skipNull,a=valueOrDefault(s.maxBarThickness,1/0);let o,r;if(e.grouped){const i=n?this._getStackCount(t):e.stackCount,l="flex"===s.barThickness?computeFlexCategoryTraits(t,e,s,i):computeFitCategoryTraits(t,e,s,i),h=this._getStackIndex(this.index,this._cachedMeta.stack,n?t:void 0);o=l.start+l.chunk*h+l.chunk/2,r=Math.min(a,l.chunk*l.ratio)}else o=i.getPixelForValue(this.getParsed(t)[i.axis],t),r=Math.min(a,e.min*e.ratio);return{base:o-r/2,head:o+r/2,center:o,size:r}}draw(){const t=this._cachedMeta,e=t.vScale,i=t.data,s=i.length;let n=0;for(;n<s;++n)null!==this.getParsed(n)[e.axis]&&i[n].draw(this._ctx)}}class BubbleController extends DatasetController{static id="bubble";static defaults={datasetElementType:!1,dataElementType:"point",animations:{numbers:{type:"number",properties:["x","y","borderWidth","radius"]}}};static overrides={scales:{x:{type:"linear"},y:{type:"linear"}}};initialize(){this.enableOptionSharing=!0,super.initialize()}parsePrimitiveData(t,e,i,s){const n=super.parsePrimitiveData(t,e,i,s);for(let t=0;t<n.length;t++)n[t]._custom=this.resolveDataElementOptions(t+i).radius;return n}parseArrayData(t,e,i,s){const n=super.parseArrayData(t,e,i,s);for(let t=0;t<n.length;t++){const s=e[i+t];n[t]._custom=valueOrDefault(s[2],this.resolveDataElementOptions(t+i).radius)}return n}parseObjectData(t,e,i,s){const n=super.parseObjectData(t,e,i,s);for(let t=0;t<n.length;t++){const s=e[i+t];n[t]._custom=valueOrDefault(s&&s.r&&+s.r,this.resolveDataElementOptions(t+i).radius)}return n}getMaxOverflow(){const t=this._cachedMeta.data;let e=0;for(let i=t.length-1;i>=0;--i)e=Math.max(e,t[i].size(this.resolveDataElementOptions(i))/2);return e>0&&e}getLabelAndValue(t){const e=this._cachedMeta,i=this.chart.data.labels||[],{xScale:s,yScale:n}=e,a=this.getParsed(t),o=s.getLabelForValue(a.x),r=n.getLabelForValue(a.y),l=a._custom;return{label:i[t]||"",value:"("+o+", "+r+(l?", "+l:"")+")"}}update(t){const e=this._cachedMeta.data;this.updateElements(e,0,e.length,t)}updateElements(t,e,i,s){const n="reset"===s,{iScale:a,vScale:o}=this._cachedMeta,{sharedOptions:r,includeOptions:l}=this._getSharedOptions(e,s),h=a.axis,c=o.axis;for(let d=e;d<e+i;d++){const e=t[d],i=!n&&this.getParsed(d),u={},g=u[h]=n?a.getPixelForDecimal(.5):a.getPixelForValue(i[h]),p=u[c]=n?o.getBasePixel():o.getPixelForValue(i[c]);u.skip=isNaN(g)||isNaN(p),l&&(u.options=r||this.resolveDataElementOptions(d,e.active?"active":s),n&&(u.options.radius=0)),this.updateElement(e,d,u,s)}}resolveDataElementOptions(t,e){const i=this.getParsed(t);let s=super.resolveDataElementOptions(t,e);s.$shared&&(s=Object.assign({},s,{$shared:!1}));const n=s.radius;return"active"!==e&&(s.radius=0),s.radius+=valueOrDefault(i&&i._custom,n),s}}function getRatioAndOffset(t,e,i){let s=1,n=1,a=0,o=0;if(e<TAU){const r=t,l=r+e,h=Math.cos(r),c=Math.sin(r),d=Math.cos(l),u=Math.sin(l),g=(t,e,s)=>_angleBetween(t,r,l,!0)?1:Math.max(e,e*i,s,s*i),p=(t,e,s)=>_angleBetween(t,r,l,!0)?-1:Math.min(e,e*i,s,s*i),f=g(0,h,d),m=g(HALF_PI,c,u),x=p(PI,h,d),b=p(PI+HALF_PI,c,u);s=(f-x)/2,n=(m-b)/2,a=-(f+x)/2,o=-(m+b)/2}return{ratioX:s,ratioY:n,offsetX:a,offsetY:o}}class DoughnutController extends DatasetController{static id="doughnut";static defaults={datasetElementType:!1,dataElementType:"arc",animation:{animateRotate:!0,animateScale:!1},animations:{numbers:{type:"number",properties:["circumference","endAngle","innerRadius","outerRadius","startAngle","x","y","offset","borderWidth","spacing"]}},cutout:"50%",rotation:0,circumference:360,radius:"100%",spacing:0,indexAxis:"r"};static descriptors={_scriptable:t=>"spacing"!==t,_indexable:t=>"spacing"!==t&&!t.startsWith("borderDash")&&!t.startsWith("hoverBorderDash")};static overrides={aspectRatio:1,plugins:{legend:{labels:{generateLabels(t){const e=t.data;if(e.labels.length&&e.datasets.length){const{labels:{pointStyle:i,color:s}}=t.legend.options;return e.labels.map(((e,n)=>{const a=t.getDatasetMeta(0).controller.getStyle(n);return{text:e,fillStyle:a.backgroundColor,strokeStyle:a.borderColor,fontColor:s,lineWidth:a.borderWidth,pointStyle:i,hidden:!t.getDataVisibility(n),index:n}}))}return[]}},onClick(t,e,i){i.chart.toggleDataVisibility(e.index),i.chart.update()}}}};constructor(t,e){super(t,e),this.enableOptionSharing=!0,this.innerRadius=void 0,this.outerRadius=void 0,this.offsetX=void 0,this.offsetY=void 0}linkScales(){}parse(t,e){const i=this.getDataset().data,s=this._cachedMeta;if(!1===this._parsing)s._parsed=i;else{let n,a,o=t=>+i[t];if(isObject(i[t])){const{key:t="value"}=this._parsing;o=e=>+resolveObjectKey(i[e],t)}for(n=t,a=t+e;n<a;++n)s._parsed[n]=o(n)}}_getRotation(){return toRadians(this.options.rotation-90)}_getCircumference(){return toRadians(this.options.circumference)}_getRotationExtents(){let t=TAU,e=-TAU;for(let i=0;i<this.chart.data.datasets.length;++i)if(this.chart.isDatasetVisible(i)&&this.chart.getDatasetMeta(i).type===this._type){const s=this.chart.getDatasetMeta(i).controller,n=s._getRotation(),a=s._getCircumference();t=Math.min(t,n),e=Math.max(e,n+a)}return{rotation:t,circumference:e-t}}update(t){const e=this.chart,{chartArea:i}=e,s=this._cachedMeta,n=s.data,a=this.getMaxBorderWidth()+this.getMaxOffset(n)+this.options.spacing,o=Math.max((Math.min(i.width,i.height)-a)/2,0),r=Math.min(toPercentage(this.options.cutout,o),1),l=this._getRingWeight(this.index),{circumference:h,rotation:c}=this._getRotationExtents(),{ratioX:d,ratioY:u,offsetX:g,offsetY:p}=getRatioAndOffset(c,h,r),f=(i.width-a)/d,m=(i.height-a)/u,x=Math.max(Math.min(f,m)/2,0),b=toDimension(this.options.radius,x),_=(b-Math.max(b*r,0))/this._getVisibleDatasetWeightTotal();this.offsetX=g*b,this.offsetY=p*b,s.total=this.calculateTotal(),this.outerRadius=b-_*this._getRingWeightOffset(this.index),this.innerRadius=Math.max(this.outerRadius-_*l,0),this.updateElements(n,0,n.length,t)}_circumference(t,e){const i=this.options,s=this._cachedMeta,n=this._getCircumference();return e&&i.animation.animateRotate||!this.chart.getDataVisibility(t)||null===s._parsed[t]||s.data[t].hidden?0:this.calculateCircumference(s._parsed[t]*n/TAU)}updateElements(t,e,i,s){const n="reset"===s,a=this.chart,o=a.chartArea,r=a.options.animation,l=(o.left+o.right)/2,h=(o.top+o.bottom)/2,c=n&&r.animateScale,d=c?0:this.innerRadius,u=c?0:this.outerRadius,{sharedOptions:g,includeOptions:p}=this._getSharedOptions(e,s);let f,m=this._getRotation();for(f=0;f<e;++f)m+=this._circumference(f,n);for(f=e;f<e+i;++f){const e=this._circumference(f,n),i=t[f],a={x:l+this.offsetX,y:h+this.offsetY,startAngle:m,endAngle:m+e,circumference:e,outerRadius:u,innerRadius:d};p&&(a.options=g||this.resolveDataElementOptions(f,i.active?"active":s)),m+=e,this.updateElement(i,f,a,s)}}calculateTotal(){const t=this._cachedMeta,e=t.data;let i,s=0;for(i=0;i<e.length;i++){const n=t._parsed[i];null===n||isNaN(n)||!this.chart.getDataVisibility(i)||e[i].hidden||(s+=Math.abs(n))}return s}calculateCircumference(t){const e=this._cachedMeta.total;return e>0&&!isNaN(t)?TAU*(Math.abs(t)/e):0}getLabelAndValue(t){const e=this._cachedMeta,i=this.chart,s=i.data.labels||[],n=formatNumber(e._parsed[t],i.options.locale);return{label:s[t]||"",value:n}}getMaxBorderWidth(t){let e=0;const i=this.chart;let s,n,a,o,r;if(!t)for(s=0,n=i.data.datasets.length;s<n;++s)if(i.isDatasetVisible(s)){a=i.getDatasetMeta(s),t=a.data,o=a.controller;break}if(!t)return 0;for(s=0,n=t.length;s<n;++s)r=o.resolveDataElementOptions(s),"inner"!==r.borderAlign&&(e=Math.max(e,r.borderWidth||0,r.hoverBorderWidth||0));return e}getMaxOffset(t){let e=0;for(let i=0,s=t.length;i<s;++i){const t=this.resolveDataElementOptions(i);e=Math.max(e,t.offset||0,t.hoverOffset||0)}return e}_getRingWeightOffset(t){let e=0;for(let i=0;i<t;++i)this.chart.isDatasetVisible(i)&&(e+=this._getRingWeight(i));return e}_getRingWeight(t){return Math.max(valueOrDefault(this.chart.data.datasets[t].weight,1),0)}_getVisibleDatasetWeightTotal(){return this._getRingWeightOffset(this.chart.data.datasets.length)||1}}class LineController extends DatasetController{static id="line";static defaults={datasetElementType:"line",dataElementType:"point",showLine:!0,spanGaps:!1};static overrides={scales:{_index_:{type:"category"},_value_:{type:"linear"}}};initialize(){this.enableOptionSharing=!0,this.supportsDecimation=!0,super.initialize()}update(t){const e=this._cachedMeta,{dataset:i,data:s=[],_dataset:n}=e,a=this.chart._animationsDisabled;let{start:o,count:r}=_getStartAndCountOfVisiblePoints(e,s,a);this._drawStart=o,this._drawCount=r,_scaleRangesChanged(e)&&(o=0,r=s.length),i._chart=this.chart,i._datasetIndex=this.index,i._decimated=!!n._decimated,i.points=s;const l=this.resolveDatasetElementOptions(t);this.options.showLine||(l.borderWidth=0),l.segment=this.options.segment,this.updateElement(i,void 0,{animated:!a,options:l},t),this.updateElements(s,o,r,t)}updateElements(t,e,i,s){const n="reset"===s,{iScale:a,vScale:o,_stacked:r,_dataset:l}=this._cachedMeta,{sharedOptions:h,includeOptions:c}=this._getSharedOptions(e,s),d=a.axis,u=o.axis,{spanGaps:g,segment:p}=this.options,f=isNumber(g)?g:Number.POSITIVE_INFINITY,m=this.chart._animationsDisabled||n||"none"===s,x=e+i,b=t.length;let _=e>0&&this.getParsed(e-1);for(let i=0;i<b;++i){const g=t[i],b=m?g:{};if(i<e||i>=x){b.skip=!0;continue}const y=this.getParsed(i),v=isNullOrUndef(y[u]),k=b[d]=a.getPixelForValue(y[d],i),S=b[u]=n||v?o.getBasePixel():o.getPixelForValue(r?this.applyStack(o,y,r):y[u],i);b.skip=isNaN(k)||isNaN(S)||v,b.stop=i>0&&Math.abs(y[d]-_[d])>f,p&&(b.parsed=y,b.raw=l.data[i]),c&&(b.options=h||this.resolveDataElementOptions(i,g.active?"active":s)),m||this.updateElement(g,i,b,s),_=y}}getMaxOverflow(){const t=this._cachedMeta,e=t.dataset,i=e.options&&e.options.borderWidth||0,s=t.data||[];if(!s.length)return i;const n=s[0].size(this.resolveDataElementOptions(0)),a=s[s.length-1].size(this.resolveDataElementOptions(s.length-1));return Math.max(i,n,a)/2}draw(){const t=this._cachedMeta;t.dataset.updateControlPoints(this.chart.chartArea,t.iScale.axis),super.draw()}}class PolarAreaController extends DatasetController{static id="polarArea";static defaults={dataElementType:"arc",animation:{animateRotate:!0,animateScale:!0},animations:{numbers:{type:"number",properties:["x","y","startAngle","endAngle","innerRadius","outerRadius"]}},indexAxis:"r",startAngle:0};static overrides={aspectRatio:1,plugins:{legend:{labels:{generateLabels(t){const e=t.data;if(e.labels.length&&e.datasets.length){const{labels:{pointStyle:i,color:s}}=t.legend.options;return e.labels.map(((e,n)=>{const a=t.getDatasetMeta(0).controller.getStyle(n);return{text:e,fillStyle:a.backgroundColor,strokeStyle:a.borderColor,fontColor:s,lineWidth:a.borderWidth,pointStyle:i,hidden:!t.getDataVisibility(n),index:n}}))}return[]}},onClick(t,e,i){i.chart.toggleDataVisibility(e.index),i.chart.update()}}},scales:{r:{type:"radialLinear",angleLines:{display:!1},beginAtZero:!0,grid:{circular:!0},pointLabels:{display:!1},startAngle:0}}};constructor(t,e){super(t,e),this.innerRadius=void 0,this.outerRadius=void 0}getLabelAndValue(t){const e=this._cachedMeta,i=this.chart,s=i.data.labels||[],n=formatNumber(e._parsed[t].r,i.options.locale);return{label:s[t]||"",value:n}}parseObjectData(t,e,i,s){return _parseObjectDataRadialScale.bind(this)(t,e,i,s)}update(t){const e=this._cachedMeta.data;this._updateRadius(),this.updateElements(e,0,e.length,t)}getMinMax(){const t=this._cachedMeta,e={min:Number.POSITIVE_INFINITY,max:Number.NEGATIVE_INFINITY};return t.data.forEach(((t,i)=>{const s=this.getParsed(i).r;!isNaN(s)&&this.chart.getDataVisibility(i)&&(s<e.min&&(e.min=s),s>e.max&&(e.max=s))})),e}_updateRadius(){const t=this.chart,e=t.chartArea,i=t.options,s=Math.min(e.right-e.left,e.bottom-e.top),n=Math.max(s/2,0),a=(n-Math.max(i.cutoutPercentage?n/100*i.cutoutPercentage:1,0))/t.getVisibleDatasetCount();this.outerRadius=n-a*this.index,this.innerRadius=this.outerRadius-a}updateElements(t,e,i,s){const n="reset"===s,a=this.chart,o=a.options.animation,r=this._cachedMeta.rScale,l=r.xCenter,h=r.yCenter,c=r.getIndexAngle(0)-.5*PI;let d,u=c;const g=360/this.countVisibleElements();for(d=0;d<e;++d)u+=this._computeAngle(d,s,g);for(d=e;d<e+i;d++){const e=t[d];let i=u,p=u+this._computeAngle(d,s,g),f=a.getDataVisibility(d)?r.getDistanceFromCenterForValue(this.getParsed(d).r):0;u=p,n&&(o.animateScale&&(f=0),o.animateRotate&&(i=p=c));const m={x:l,y:h,innerRadius:0,outerRadius:f,startAngle:i,endAngle:p,options:this.resolveDataElementOptions(d,e.active?"active":s)};this.updateElement(e,d,m,s)}}countVisibleElements(){const t=this._cachedMeta;let e=0;return t.data.forEach(((t,i)=>{!isNaN(this.getParsed(i).r)&&this.chart.getDataVisibility(i)&&e++})),e}_computeAngle(t,e,i){return this.chart.getDataVisibility(t)?toRadians(this.resolveDataElementOptions(t,e).angle||i):0}}class PieController extends DoughnutController{static id="pie";static defaults={cutout:0,rotation:0,circumference:360,radius:"100%"}}class RadarController extends DatasetController{static id="radar";static defaults={datasetElementType:"line",dataElementType:"point",indexAxis:"r",showLine:!0,elements:{line:{fill:"start"}}};static overrides={aspectRatio:1,scales:{r:{type:"radialLinear"}}};getLabelAndValue(t){const e=this._cachedMeta.vScale,i=this.getParsed(t);return{label:e.getLabels()[t],value:""+e.getLabelForValue(i[e.axis])}}parseObjectData(t,e,i,s){return _parseObjectDataRadialScale.bind(this)(t,e,i,s)}update(t){const e=this._cachedMeta,i=e.dataset,s=e.data||[],n=e.iScale.getLabels();if(i.points=s,"resize"!==t){const e=this.resolveDatasetElementOptions(t);this.options.showLine||(e.borderWidth=0);const a={_loop:!0,_fullLoop:n.length===s.length,options:e};this.updateElement(i,void 0,a,t)}this.updateElements(s,0,s.length,t)}updateElements(t,e,i,s){const n=this._cachedMeta.rScale,a="reset"===s;for(let o=e;o<e+i;o++){const e=t[o],i=this.resolveDataElementOptions(o,e.active?"active":s),r=n.getPointPositionForValue(o,this.getParsed(o).r),l=a?n.xCenter:r.x,h=a?n.yCenter:r.y,c={x:l,y:h,angle:r.angle,skip:isNaN(l)||isNaN(h),options:i};this.updateElement(e,o,c,s)}}}class ScatterController extends DatasetController{static id="scatter";static defaults={datasetElementType:!1,dataElementType:"point",showLine:!1,fill:!1};static overrides={interaction:{mode:"point"},scales:{x:{type:"linear"},y:{type:"linear"}}};getLabelAndValue(t){const e=this._cachedMeta,i=this.chart.data.labels||[],{xScale:s,yScale:n}=e,a=this.getParsed(t),o=s.getLabelForValue(a.x),r=n.getLabelForValue(a.y);return{label:i[t]||"",value:"("+o+", "+r+")"}}update(t){const e=this._cachedMeta,{data:i=[]}=e,s=this.chart._animationsDisabled;let{start:n,count:a}=_getStartAndCountOfVisiblePoints(e,i,s);if(this._drawStart=n,this._drawCount=a,_scaleRangesChanged(e)&&(n=0,a=i.length),this.options.showLine){this.datasetElementType||this.addElements();const{dataset:n,_dataset:a}=e;n._chart=this.chart,n._datasetIndex=this.index,n._decimated=!!a._decimated,n.points=i;const o=this.resolveDatasetElementOptions(t);o.segment=this.options.segment,this.updateElement(n,void 0,{animated:!s,options:o},t)}else this.datasetElementType&&(delete e.dataset,this.datasetElementType=!1);this.updateElements(i,n,a,t)}addElements(){const{showLine:t}=this.options;!this.datasetElementType&&t&&(this.datasetElementType=this.chart.registry.getElement("line")),super.addElements()}updateElements(t,e,i,s){const n="reset"===s,{iScale:a,vScale:o,_stacked:r,_dataset:l}=this._cachedMeta,h=this.resolveDataElementOptions(e,s),c=this.getSharedOptions(h),d=this.includeOptions(s,c),u=a.axis,g=o.axis,{spanGaps:p,segment:f}=this.options,m=isNumber(p)?p:Number.POSITIVE_INFINITY,x=this.chart._animationsDisabled||n||"none"===s;let b=e>0&&this.getParsed(e-1);for(let h=e;h<e+i;++h){const e=t[h],i=this.getParsed(h),p=x?e:{},_=isNullOrUndef(i[g]),y=p[u]=a.getPixelForValue(i[u],h),v=p[g]=n||_?o.getBasePixel():o.getPixelForValue(r?this.applyStack(o,i,r):i[g],h);p.skip=isNaN(y)||isNaN(v)||_,p.stop=h>0&&Math.abs(i[u]-b[u])>m,f&&(p.parsed=i,p.raw=l.data[h]),d&&(p.options=c||this.resolveDataElementOptions(h,e.active?"active":s)),x||this.updateElement(e,h,p,s),b=i}this.updateSharedOptions(c,s,h)}getMaxOverflow(){const t=this._cachedMeta,e=t.data||[];if(!this.options.showLine){let t=0;for(let i=e.length-1;i>=0;--i)t=Math.max(t,e[i].size(this.resolveDataElementOptions(i))/2);return t>0&&t}const i=t.dataset,s=i.options&&i.options.borderWidth||0;if(!e.length)return s;const n=e[0].size(this.resolveDataElementOptions(0)),a=e[e.length-1].size(this.resolveDataElementOptions(e.length-1));return Math.max(s,n,a)/2}}var controllers=Object.freeze({__proto__:null,BarController:BarController,BubbleController:BubbleController,DoughnutController:DoughnutController,LineController:LineController,PieController:PieController,PolarAreaController:PolarAreaController,RadarController:RadarController,ScatterController:ScatterController});function abstract(){throw new Error("This method is not implemented: Check that a complete date adapter is provided.")}class DateAdapterBase{static override(t){Object.assign(DateAdapterBase.prototype,t)}options;constructor(t){this.options=t||{}}init(){}formats(){return abstract()}parse(){return abstract()}format(){return abstract()}add(){return abstract()}diff(){return abstract()}startOf(){return abstract()}endOf(){return abstract()}}var adapters={_date:DateAdapterBase};function binarySearch(t,e,i,s){const{controller:n,data:a,_sorted:o}=t,r=n._cachedMeta.iScale;if(r&&e===r.axis&&"r"!==e&&o&&a.length){const t=r._reversePixels?_rlookupByKey:_lookupByKey;if(!s)return t(a,e,i);if(n._sharedOptions){const s=a[0],n="function"==typeof s.getRange&&s.getRange(e);if(n){const s=t(a,e,i-n),o=t(a,e,i+n);return{lo:s.lo,hi:o.hi}}}}return{lo:0,hi:a.length-1}}function evaluateInteractionItems(t,e,i,s,n){const a=t.getSortedVisibleDatasetMetas(),o=i[e];for(let t=0,i=a.length;t<i;++t){const{index:i,data:r}=a[t],{lo:l,hi:h}=binarySearch(a[t],e,o,n);for(let t=l;t<=h;++t){const e=r[t];e.skip||s(e,i,t)}}}function getDistanceMetricForAxis(t){const e=-1!==t.indexOf("x"),i=-1!==t.indexOf("y");return function(t,s){const n=e?Math.abs(t.x-s.x):0,a=i?Math.abs(t.y-s.y):0;return Math.sqrt(Math.pow(n,2)+Math.pow(a,2))}}function getIntersectItems(t,e,i,s,n){const a=[];if(!n&&!t.isPointInArea(e))return a;return evaluateInteractionItems(t,i,e,(function(i,o,r){(n||_isPointInArea(i,t.chartArea,0))&&i.inRange(e.x,e.y,s)&&a.push({element:i,datasetIndex:o,index:r})}),!0),a}function getNearestRadialItems(t,e,i,s){let n=[];return evaluateInteractionItems(t,i,e,(function(t,i,a){const{startAngle:o,endAngle:r}=t.getProps(["startAngle","endAngle"],s),{angle:l}=getAngleFromPoint(t,{x:e.x,y:e.y});_angleBetween(l,o,r)&&n.push({element:t,datasetIndex:i,index:a})})),n}function getNearestCartesianItems(t,e,i,s,n,a){let o=[];const r=getDistanceMetricForAxis(i);let l=Number.POSITIVE_INFINITY;return evaluateInteractionItems(t,i,e,(function(i,h,c){const d=i.inRange(e.x,e.y,n);if(s&&!d)return;const u=i.getCenterPoint(n);if(!(!!a||t.isPointInArea(u))&&!d)return;const g=r(e,u);g<l?(o=[{element:i,datasetIndex:h,index:c}],l=g):g===l&&o.push({element:i,datasetIndex:h,index:c})})),o}function getNearestItems(t,e,i,s,n,a){return a||t.isPointInArea(e)?"r"!==i||s?getNearestCartesianItems(t,e,i,s,n,a):getNearestRadialItems(t,e,i,n):[]}function getAxisItems(t,e,i,s,n){const a=[],o="x"===i?"inXRange":"inYRange";let r=!1;return evaluateInteractionItems(t,i,e,((t,s,l)=>{t[o](e[i],n)&&(a.push({element:t,datasetIndex:s,index:l}),r=r||t.inRange(e.x,e.y,n))})),s&&!r?[]:a}var Interaction={evaluateInteractionItems:evaluateInteractionItems,modes:{index(t,e,i,s){const n=getRelativePosition(e,t),a=i.axis||"x",o=i.includeInvisible||!1,r=i.intersect?getIntersectItems(t,n,a,s,o):getNearestItems(t,n,a,!1,s,o),l=[];return r.length?(t.getSortedVisibleDatasetMetas().forEach((t=>{const e=r[0].index,i=t.data[e];i&&!i.skip&&l.push({element:i,datasetIndex:t.index,index:e})})),l):[]},dataset(t,e,i,s){const n=getRelativePosition(e,t),a=i.axis||"xy",o=i.includeInvisible||!1;let r=i.intersect?getIntersectItems(t,n,a,s,o):getNearestItems(t,n,a,!1,s,o);if(r.length>0){const e=r[0].datasetIndex,i=t.getDatasetMeta(e).data;r=[];for(let t=0;t<i.length;++t)r.push({element:i[t],datasetIndex:e,index:t})}return r},point:(t,e,i,s)=>getIntersectItems(t,getRelativePosition(e,t),i.axis||"xy",s,i.includeInvisible||!1),nearest(t,e,i,s){const n=getRelativePosition(e,t),a=i.axis||"xy",o=i.includeInvisible||!1;return getNearestItems(t,n,a,i.intersect,s,o)},x:(t,e,i,s)=>getAxisItems(t,getRelativePosition(e,t),"x",i.intersect,s),y:(t,e,i,s)=>getAxisItems(t,getRelativePosition(e,t),"y",i.intersect,s)}};const STATIC_POSITIONS=["left","top","right","bottom"];function filterByPosition(t,e){return t.filter((t=>t.pos===e))}function filterDynamicPositionByAxis(t,e){return t.filter((t=>-1===STATIC_POSITIONS.indexOf(t.pos)&&t.box.axis===e))}function sortByWeight(t,e){return t.sort(((t,i)=>{const s=e?i:t,n=e?t:i;return s.weight===n.weight?s.index-n.index:s.weight-n.weight}))}function wrapBoxes(t){const e=[];let i,s,n,a,o,r;for(i=0,s=(t||[]).length;i<s;++i)n=t[i],({position:a,options:{stack:o,stackWeight:r=1}}=n),e.push({index:i,box:n,pos:a,horizontal:n.isHorizontal(),weight:n.weight,stack:o&&a+o,stackWeight:r});return e}function buildStacks(t){const e={};for(const i of t){const{stack:t,pos:s,stackWeight:n}=i;if(!t||!STATIC_POSITIONS.includes(s))continue;const a=e[t]||(e[t]={count:0,placed:0,weight:0,size:0});a.count++,a.weight+=n}return e}function setLayoutDims(t,e){const i=buildStacks(t),{vBoxMaxWidth:s,hBoxMaxHeight:n}=e;let a,o,r;for(a=0,o=t.length;a<o;++a){r=t[a];const{fullSize:o}=r.box,l=i[r.stack],h=l&&r.stackWeight/l.weight;r.horizontal?(r.width=h?h*s:o&&e.availableWidth,r.height=n):(r.width=s,r.height=h?h*n:o&&e.availableHeight)}return i}function buildLayoutBoxes(t){const e=wrapBoxes(t),i=sortByWeight(e.filter((t=>t.box.fullSize)),!0),s=sortByWeight(filterByPosition(e,"left"),!0),n=sortByWeight(filterByPosition(e,"right")),a=sortByWeight(filterByPosition(e,"top"),!0),o=sortByWeight(filterByPosition(e,"bottom")),r=filterDynamicPositionByAxis(e,"x"),l=filterDynamicPositionByAxis(e,"y");return{fullSize:i,leftAndTop:s.concat(a),rightAndBottom:n.concat(l).concat(o).concat(r),chartArea:filterByPosition(e,"chartArea"),vertical:s.concat(n).concat(l),horizontal:a.concat(o).concat(r)}}function getCombinedMax(t,e,i,s){return Math.max(t[i],e[i])+Math.max(t[s],e[s])}function updateMaxPadding(t,e){t.top=Math.max(t.top,e.top),t.left=Math.max(t.left,e.left),t.bottom=Math.max(t.bottom,e.bottom),t.right=Math.max(t.right,e.right)}function updateDims(t,e,i,s){const{pos:n,box:a}=i,o=t.maxPadding;if(!isObject(n)){i.size&&(t[n]-=i.size);const e=s[i.stack]||{size:0,count:1};e.size=Math.max(e.size,i.horizontal?a.height:a.width),i.size=e.size/e.count,t[n]+=i.size}a.getPadding&&updateMaxPadding(o,a.getPadding());const r=Math.max(0,e.outerWidth-getCombinedMax(o,t,"left","right")),l=Math.max(0,e.outerHeight-getCombinedMax(o,t,"top","bottom")),h=r!==t.w,c=l!==t.h;return t.w=r,t.h=l,i.horizontal?{same:h,other:c}:{same:c,other:h}}function handleMaxPadding(t){const e=t.maxPadding;function i(i){const s=Math.max(e[i]-t[i],0);return t[i]+=s,s}t.y+=i("top"),t.x+=i("left"),i("right"),i("bottom")}function getMargins(t,e){const i=e.maxPadding;function s(t){const s={left:0,top:0,right:0,bottom:0};return t.forEach((t=>{s[t]=Math.max(e[t],i[t])})),s}return s(t?["left","right"]:["top","bottom"])}function fitBoxes(t,e,i,s){const n=[];let a,o,r,l,h,c;for(a=0,o=t.length,h=0;a<o;++a){r=t[a],l=r.box,l.update(r.width||e.w,r.height||e.h,getMargins(r.horizontal,e));const{same:o,other:d}=updateDims(e,i,r,s);h|=o&&n.length,c=c||d,l.fullSize||n.push(r)}return h&&fitBoxes(n,e,i,s)||c}function setBoxDims(t,e,i,s,n){t.top=i,t.left=e,t.right=e+s,t.bottom=i+n,t.width=s,t.height=n}function placeBoxes(t,e,i,s){const n=i.padding;let{x:a,y:o}=e;for(const r of t){const t=r.box,l=s[r.stack]||{count:1,placed:0,weight:1},h=r.stackWeight/l.weight||1;if(r.horizontal){const s=e.w*h,a=l.size||t.height;defined(l.start)&&(o=l.start),t.fullSize?setBoxDims(t,n.left,o,i.outerWidth-n.right-n.left,a):setBoxDims(t,e.left+l.placed,o,s,a),l.start=o,l.placed+=s,o=t.bottom}else{const s=e.h*h,o=l.size||t.width;defined(l.start)&&(a=l.start),t.fullSize?setBoxDims(t,a,n.top,o,i.outerHeight-n.bottom-n.top):setBoxDims(t,a,e.top+l.placed,o,s),l.start=a,l.placed+=s,a=t.right}}e.x=a,e.y=o}var layouts={addBox(t,e){t.boxes||(t.boxes=[]),e.fullSize=e.fullSize||!1,e.position=e.position||"top",e.weight=e.weight||0,e._layers=e._layers||function(){return[{z:0,draw(t){e.draw(t)}}]},t.boxes.push(e)},removeBox(t,e){const i=t.boxes?t.boxes.indexOf(e):-1;-1!==i&&t.boxes.splice(i,1)},configure(t,e,i){e.fullSize=i.fullSize,e.position=i.position,e.weight=i.weight},update(t,e,i,s){if(!t)return;const n=toPadding(t.options.layout.padding),a=Math.max(e-n.width,0),o=Math.max(i-n.height,0),r=buildLayoutBoxes(t.boxes),l=r.vertical,h=r.horizontal;each(t.boxes,(t=>{"function"==typeof t.beforeLayout&&t.beforeLayout()}));const c=l.reduce(((t,e)=>e.box.options&&!1===e.box.options.display?t:t+1),0)||1,d=Object.freeze({outerWidth:e,outerHeight:i,padding:n,availableWidth:a,availableHeight:o,vBoxMaxWidth:a/2/c,hBoxMaxHeight:o/2}),u=Object.assign({},n);updateMaxPadding(u,toPadding(s));const g=Object.assign({maxPadding:u,w:a,h:o,x:n.left,y:n.top},n),p=setLayoutDims(l.concat(h),d);fitBoxes(r.fullSize,g,d,p),fitBoxes(l,g,d,p),fitBoxes(h,g,d,p)&&fitBoxes(l,g,d,p),handleMaxPadding(g),placeBoxes(r.leftAndTop,g,d,p),g.x+=g.w,g.y+=g.h,placeBoxes(r.rightAndBottom,g,d,p),t.chartArea={left:g.left,top:g.top,right:g.left+g.w,bottom:g.top+g.h,height:g.h,width:g.w},each(r.chartArea,(e=>{const i=e.box;Object.assign(i,t.chartArea),i.update(g.w,g.h,{left:0,top:0,right:0,bottom:0})}))}};class BasePlatform{acquireContext(t,e){}releaseContext(t){return!1}addEventListener(t,e,i){}removeEventListener(t,e,i){}getDevicePixelRatio(){return 1}getMaximumSize(t,e,i,s){return e=Math.max(0,e||t.width),i=i||t.height,{width:e,height:Math.max(0,s?Math.floor(e/s):i)}}isAttached(t){return!0}updateConfig(t){}}class BasicPlatform extends BasePlatform{acquireContext(t){return t&&t.getContext&&t.getContext("2d")||null}updateConfig(t){t.options.animation=!1}}const EXPANDO_KEY="$chartjs",EVENT_TYPES={touchstart:"mousedown",touchmove:"mousemove",touchend:"mouseup",pointerenter:"mouseenter",pointerdown:"mousedown",pointermove:"mousemove",pointerup:"mouseup",pointerleave:"mouseout",pointerout:"mouseout"},isNullOrEmpty=t=>null===t||""===t;function initCanvas(t,e){const i=t.style,s=t.getAttribute("height"),n=t.getAttribute("width");if(t.$chartjs={initial:{height:s,width:n,style:{display:i.display,height:i.height,width:i.width}}},i.display=i.display||"block",i.boxSizing=i.boxSizing||"border-box",isNullOrEmpty(n)){const e=readUsedSize(t,"width");void 0!==e&&(t.width=e)}if(isNullOrEmpty(s))if(""===t.style.height)t.height=t.width/(e||2);else{const e=readUsedSize(t,"height");void 0!==e&&(t.height=e)}return t}const eventListenerOptions=!!supportsEventListenerOptions&&{passive:!0};function addListener(t,e,i){t.addEventListener(e,i,eventListenerOptions)}function removeListener(t,e,i){t.canvas.removeEventListener(e,i,eventListenerOptions)}function fromNativeEvent(t,e){const i=EVENT_TYPES[t.type]||t.type,{x:s,y:n}=getRelativePosition(t,e);return{type:i,chart:e,native:t,x:void 0!==s?s:null,y:void 0!==n?n:null}}function nodeListContains(t,e){for(const i of t)if(i===e||i.contains(e))return!0}function createAttachObserver(t,e,i){const s=t.canvas,n=new MutationObserver((t=>{let e=!1;for(const i of t)e=e||nodeListContains(i.addedNodes,s),e=e&&!nodeListContains(i.removedNodes,s);e&&i()}));return n.observe(document,{childList:!0,subtree:!0}),n}function createDetachObserver(t,e,i){const s=t.canvas,n=new MutationObserver((t=>{let e=!1;for(const i of t)e=e||nodeListContains(i.removedNodes,s),e=e&&!nodeListContains(i.addedNodes,s);e&&i()}));return n.observe(document,{childList:!0,subtree:!0}),n}const drpListeningCharts=new Map;let oldDevicePixelRatio=0;function onWindowResize(){const t=window.devicePixelRatio;t!==oldDevicePixelRatio&&(oldDevicePixelRatio=t,drpListeningCharts.forEach(((e,i)=>{i.currentDevicePixelRatio!==t&&e()})))}function listenDevicePixelRatioChanges(t,e){drpListeningCharts.size||window.addEventListener("resize",onWindowResize),drpListeningCharts.set(t,e)}function unlistenDevicePixelRatioChanges(t){drpListeningCharts.delete(t),drpListeningCharts.size||window.removeEventListener("resize",onWindowResize)}function createResizeObserver(t,e,i){const s=t.canvas,n=s&&_getParentNode(s);if(!n)return;const a=throttled(((t,e)=>{const s=n.clientWidth;i(t,e),s<n.clientWidth&&i()}),window),o=new ResizeObserver((t=>{const e=t[0],i=e.contentRect.width,s=e.contentRect.height;0===i&&0===s||a(i,s)}));return o.observe(n),listenDevicePixelRatioChanges(t,a),o}function releaseObserver(t,e,i){i&&i.disconnect(),"resize"===e&&unlistenDevicePixelRatioChanges(t)}function createProxyAndListen(t,e,i){const s=t.canvas,n=throttled((e=>{null!==t.ctx&&i(fromNativeEvent(e,t))}),t);return addListener(s,e,n),n}class DomPlatform extends BasePlatform{acquireContext(t,e){const i=t&&t.getContext&&t.getContext("2d");return i&&i.canvas===t?(initCanvas(t,e),i):null}releaseContext(t){const e=t.canvas;if(!e.$chartjs)return!1;const i=e.$chartjs.initial;["height","width"].forEach((t=>{const s=i[t];isNullOrUndef(s)?e.removeAttribute(t):e.setAttribute(t,s)}));const s=i.style||{};return Object.keys(s).forEach((t=>{e.style[t]=s[t]})),e.width=e.width,delete e.$chartjs,!0}addEventListener(t,e,i){this.removeEventListener(t,e);const s=t.$proxies||(t.$proxies={}),n={attach:createAttachObserver,detach:createDetachObserver,resize:createResizeObserver}[e]||createProxyAndListen;s[e]=n(t,e,i)}removeEventListener(t,e){const i=t.$proxies||(t.$proxies={}),s=i[e];if(!s)return;({attach:releaseObserver,detach:releaseObserver,resize:releaseObserver}[e]||removeListener)(t,e,s),i[e]=void 0}getDevicePixelRatio(){return window.devicePixelRatio}getMaximumSize(t,e,i,s){return getMaximumSize(t,e,i,s)}isAttached(t){const e=_getParentNode(t);return!(!e||!e.isConnected)}}function _detectPlatform(t){return!_isDomSupported()||"undefined"!=typeof OffscreenCanvas&&t instanceof OffscreenCanvas?BasicPlatform:DomPlatform}class Element{static defaults={};static defaultRoutes=void 0;x;y;active=!1;options;$animations;tooltipPosition(t){const{x:e,y:i}=this.getProps(["x","y"],t);return{x:e,y:i}}hasValue(){return isNumber(this.x)&&isNumber(this.y)}getProps(t,e){const i=this.$animations;if(!e||!i)return this;const s={};return t.forEach((t=>{s[t]=i[t]&&i[t].active()?i[t]._to:this[t]})),s}}function autoSkip(t,e){const i=t.options.ticks,s=determineMaxTicks(t),n=Math.min(i.maxTicksLimit||s,s),a=i.major.enabled?getMajorIndices(e):[],o=a.length,r=a[0],l=a[o-1],h=[];if(o>n)return skipMajors(e,h,a,o/n),h;const c=calculateSpacing(a,e,n);if(o>0){let t,i;const s=o>1?Math.round((l-r)/(o-1)):null;for(skip(e,h,c,isNullOrUndef(s)?0:r-s,r),t=0,i=o-1;t<i;t++)skip(e,h,c,a[t],a[t+1]);return skip(e,h,c,l,isNullOrUndef(s)?e.length:l+s),h}return skip(e,h,c),h}function determineMaxTicks(t){const e=t.options.offset,i=t._tickSize(),s=t._length/i+(e?0:1),n=t._maxLength/i;return Math.floor(Math.min(s,n))}function calculateSpacing(t,e,i){const s=getEvenSpacing(t),n=e.length/i;if(!s)return Math.max(n,1);const a=_factorize(s);for(let t=0,e=a.length-1;t<e;t++){const e=a[t];if(e>n)return e}return Math.max(n,1)}function getMajorIndices(t){const e=[];let i,s;for(i=0,s=t.length;i<s;i++)t[i].major&&e.push(i);return e}function skipMajors(t,e,i,s){let n,a=0,o=i[0];for(s=Math.ceil(s),n=0;n<t.length;n++)n===o&&(e.push(t[n]),a++,o=i[a*s])}function skip(t,e,i,s,n){const a=valueOrDefault(s,0),o=Math.min(valueOrDefault(n,t.length),t.length);let r,l,h,c=0;for(i=Math.ceil(i),n&&(r=n-s,i=r/Math.floor(r/i)),h=a;h<0;)c++,h=Math.round(a+c*i);for(l=Math.max(a,0);l<o;l++)l===h&&(e.push(t[l]),c++,h=Math.round(a+c*i))}function getEvenSpacing(t){const e=t.length;let i,s;if(e<2)return!1;for(s=t[0],i=1;i<e;++i)if(t[i]-t[i-1]!==s)return!1;return s}const reverseAlign=t=>"left"===t?"right":"right"===t?"left":t,offsetFromEdge=(t,e,i)=>"top"===e||"left"===e?t[e]+i:t[e]-i,getTicksLimit=(t,e)=>Math.min(e||t,t);function sample(t,e){const i=[],s=t.length/e,n=t.length;let a=0;for(;a<n;a+=s)i.push(t[Math.floor(a)]);return i}function getPixelForGridLine(t,e,i){const s=t.ticks.length,n=Math.min(e,s-1),a=t._startPixel,o=t._endPixel,r=1e-6;let l,h=t.getPixelForTick(n);if(!(i&&(l=1===s?Math.max(h-a,o-h):0===e?(t.getPixelForTick(1)-h)/2:(h-t.getPixelForTick(n-1))/2,h+=n<e?l:-l,h<a-r||h>o+r)))return h}function garbageCollect(t,e){each(t,(t=>{const i=t.gc,s=i.length/2;let n;if(s>e){for(n=0;n<s;++n)delete t.data[i[n]];i.splice(0,s)}}))}function getTickMarkLength(t){return t.drawTicks?t.tickLength:0}function getTitleHeight(t,e){if(!t.display)return 0;const i=toFont(t.font,e),s=toPadding(t.padding);return(isArray(t.text)?t.text.length:1)*i.lineHeight+s.height}function createScaleContext(t,e){return createContext(t,{scale:e,type:"scale"})}function createTickContext(t,e,i){return createContext(t,{tick:i,index:e,type:"tick"})}function titleAlign(t,e,i){let s=_toLeftRightCenter(t);return(i&&"right"!==e||!i&&"right"===e)&&(s=reverseAlign(s)),s}function titleArgs(t,e,i,s){const{top:n,left:a,bottom:o,right:r,chart:l}=t,{chartArea:h,scales:c}=l;let d,u,g,p=0;const f=o-n,m=r-a;if(t.isHorizontal()){if(u=_alignStartEnd(s,a,r),isObject(i)){const t=Object.keys(i)[0],s=i[t];g=c[t].getPixelForValue(s)+f-e}else g="center"===i?(h.bottom+h.top)/2+f-e:offsetFromEdge(t,i,e);d=r-a}else{if(isObject(i)){const t=Object.keys(i)[0],s=i[t];u=c[t].getPixelForValue(s)-m+e}else u="center"===i?(h.left+h.right)/2-m+e:offsetFromEdge(t,i,e);g=_alignStartEnd(s,o,n),p="left"===i?-HALF_PI:HALF_PI}return{titleX:u,titleY:g,maxWidth:d,rotation:p}}class Scale extends Element{constructor(t){super(),this.id=t.id,this.type=t.type,this.options=void 0,this.ctx=t.ctx,this.chart=t.chart,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.width=void 0,this.height=void 0,this._margins={left:0,right:0,top:0,bottom:0},this.maxWidth=void 0,this.maxHeight=void 0,this.paddingTop=void 0,this.paddingBottom=void 0,this.paddingLeft=void 0,this.paddingRight=void 0,this.axis=void 0,this.labelRotation=void 0,this.min=void 0,this.max=void 0,this._range=void 0,this.ticks=[],this._gridLineItems=null,this._labelItems=null,this._labelSizes=null,this._length=0,this._maxLength=0,this._longestTextCache={},this._startPixel=void 0,this._endPixel=void 0,this._reversePixels=!1,this._userMax=void 0,this._userMin=void 0,this._suggestedMax=void 0,this._suggestedMin=void 0,this._ticksLength=0,this._borderValue=0,this._cache={},this._dataLimitsCached=!1,this.$context=void 0}init(t){this.options=t.setContext(this.getContext()),this.axis=t.axis,this._userMin=this.parse(t.min),this._userMax=this.parse(t.max),this._suggestedMin=this.parse(t.suggestedMin),this._suggestedMax=this.parse(t.suggestedMax)}parse(t,e){return t}getUserBounds(){let{_userMin:t,_userMax:e,_suggestedMin:i,_suggestedMax:s}=this;return t=finiteOrDefault(t,Number.POSITIVE_INFINITY),e=finiteOrDefault(e,Number.NEGATIVE_INFINITY),i=finiteOrDefault(i,Number.POSITIVE_INFINITY),s=finiteOrDefault(s,Number.NEGATIVE_INFINITY),{min:finiteOrDefault(t,i),max:finiteOrDefault(e,s),minDefined:isNumberFinite(t),maxDefined:isNumberFinite(e)}}getMinMax(t){let e,{min:i,max:s,minDefined:n,maxDefined:a}=this.getUserBounds();if(n&&a)return{min:i,max:s};const o=this.getMatchingVisibleMetas();for(let r=0,l=o.length;r<l;++r)e=o[r].controller.getMinMax(this,t),n||(i=Math.min(i,e.min)),a||(s=Math.max(s,e.max));return i=a&&i>s?s:i,s=n&&i>s?i:s,{min:finiteOrDefault(i,finiteOrDefault(s,i)),max:finiteOrDefault(s,finiteOrDefault(i,s))}}getPadding(){return{left:this.paddingLeft||0,top:this.paddingTop||0,right:this.paddingRight||0,bottom:this.paddingBottom||0}}getTicks(){return this.ticks}getLabels(){const t=this.chart.data;return this.options.labels||(this.isHorizontal()?t.xLabels:t.yLabels)||t.labels||[]}getLabelItems(t=this.chart.chartArea){return this._labelItems||(this._labelItems=this._computeLabelItems(t))}beforeLayout(){this._cache={},this._dataLimitsCached=!1}beforeUpdate(){callback(this.options.beforeUpdate,[this])}update(t,e,i){const{beginAtZero:s,grace:n,ticks:a}=this.options,o=a.sampleSize;this.beforeUpdate(),this.maxWidth=t,this.maxHeight=e,this._margins=i=Object.assign({left:0,right:0,top:0,bottom:0},i),this.ticks=null,this._labelSizes=null,this._gridLineItems=null,this._labelItems=null,this.beforeSetDimensions(),this.setDimensions(),this.afterSetDimensions(),this._maxLength=this.isHorizontal()?this.width+i.left+i.right:this.height+i.top+i.bottom,this._dataLimitsCached||(this.beforeDataLimits(),this.determineDataLimits(),this.afterDataLimits(),this._range=_addGrace(this,n,s),this._dataLimitsCached=!0),this.beforeBuildTicks(),this.ticks=this.buildTicks()||[],this.afterBuildTicks();const r=o<this.ticks.length;this._convertTicksToLabels(r?sample(this.ticks,o):this.ticks),this.configure(),this.beforeCalculateLabelRotation(),this.calculateLabelRotation(),this.afterCalculateLabelRotation(),a.display&&(a.autoSkip||"auto"===a.source)&&(this.ticks=autoSkip(this,this.ticks),this._labelSizes=null,this.afterAutoSkip()),r&&this._convertTicksToLabels(this.ticks),this.beforeFit(),this.fit(),this.afterFit(),this.afterUpdate()}configure(){let t,e,i=this.options.reverse;this.isHorizontal()?(t=this.left,e=this.right):(t=this.top,e=this.bottom,i=!i),this._startPixel=t,this._endPixel=e,this._reversePixels=i,this._length=e-t,this._alignToPixels=this.options.alignToPixels}afterUpdate(){callback(this.options.afterUpdate,[this])}beforeSetDimensions(){callback(this.options.beforeSetDimensions,[this])}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=0,this.right=this.width):(this.height=this.maxHeight,this.top=0,this.bottom=this.height),this.paddingLeft=0,this.paddingTop=0,this.paddingRight=0,this.paddingBottom=0}afterSetDimensions(){callback(this.options.afterSetDimensions,[this])}_callHooks(t){this.chart.notifyPlugins(t,this.getContext()),callback(this.options[t],[this])}beforeDataLimits(){this._callHooks("beforeDataLimits")}determineDataLimits(){}afterDataLimits(){this._callHooks("afterDataLimits")}beforeBuildTicks(){this._callHooks("beforeBuildTicks")}buildTicks(){return[]}afterBuildTicks(){this._callHooks("afterBuildTicks")}beforeTickToLabelConversion(){callback(this.options.beforeTickToLabelConversion,[this])}generateTickLabels(t){const e=this.options.ticks;let i,s,n;for(i=0,s=t.length;i<s;i++)n=t[i],n.label=callback(e.callback,[n.value,i,t],this)}afterTickToLabelConversion(){callback(this.options.afterTickToLabelConversion,[this])}beforeCalculateLabelRotation(){callback(this.options.beforeCalculateLabelRotation,[this])}calculateLabelRotation(){const t=this.options,e=t.ticks,i=getTicksLimit(this.ticks.length,t.ticks.maxTicksLimit),s=e.minRotation||0,n=e.maxRotation;let a,o,r,l=s;if(!this._isVisible()||!e.display||s>=n||i<=1||!this.isHorizontal())return void(this.labelRotation=s);const h=this._getLabelSizes(),c=h.widest.width,d=h.highest.height,u=_limitValue(this.chart.width-c,0,this.maxWidth);a=t.offset?this.maxWidth/i:u/(i-1),c+6>a&&(a=u/(i-(t.offset?.5:1)),o=this.maxHeight-getTickMarkLength(t.grid)-e.padding-getTitleHeight(t.title,this.chart.options.font),r=Math.sqrt(c*c+d*d),l=toDegrees(Math.min(Math.asin(_limitValue((h.highest.height+6)/a,-1,1)),Math.asin(_limitValue(o/r,-1,1))-Math.asin(_limitValue(d/r,-1,1)))),l=Math.max(s,Math.min(n,l))),this.labelRotation=l}afterCalculateLabelRotation(){callback(this.options.afterCalculateLabelRotation,[this])}afterAutoSkip(){}beforeFit(){callback(this.options.beforeFit,[this])}fit(){const t={width:0,height:0},{chart:e,options:{ticks:i,title:s,grid:n}}=this,a=this._isVisible(),o=this.isHorizontal();if(a){const a=getTitleHeight(s,e.options.font);if(o?(t.width=this.maxWidth,t.height=getTickMarkLength(n)+a):(t.height=this.maxHeight,t.width=getTickMarkLength(n)+a),i.display&&this.ticks.length){const{first:e,last:s,widest:n,highest:a}=this._getLabelSizes(),r=2*i.padding,l=toRadians(this.labelRotation),h=Math.cos(l),c=Math.sin(l);if(o){const e=i.mirror?0:c*n.width+h*a.height;t.height=Math.min(this.maxHeight,t.height+e+r)}else{const e=i.mirror?0:h*n.width+c*a.height;t.width=Math.min(this.maxWidth,t.width+e+r)}this._calculatePadding(e,s,c,h)}}this._handleMargins(),o?(this.width=this._length=e.width-this._margins.left-this._margins.right,this.height=t.height):(this.width=t.width,this.height=this._length=e.height-this._margins.top-this._margins.bottom)}_calculatePadding(t,e,i,s){const{ticks:{align:n,padding:a},position:o}=this.options,r=0!==this.labelRotation,l="top"!==o&&"x"===this.axis;if(this.isHorizontal()){const o=this.getPixelForTick(0)-this.left,h=this.right-this.getPixelForTick(this.ticks.length-1);let c=0,d=0;r?l?(c=s*t.width,d=i*e.height):(c=i*t.height,d=s*e.width):"start"===n?d=e.width:"end"===n?c=t.width:"inner"!==n&&(c=t.width/2,d=e.width/2),this.paddingLeft=Math.max((c-o+a)*this.width/(this.width-o),0),this.paddingRight=Math.max((d-h+a)*this.width/(this.width-h),0)}else{let i=e.height/2,s=t.height/2;"start"===n?(i=0,s=t.height):"end"===n&&(i=e.height,s=0),this.paddingTop=i+a,this.paddingBottom=s+a}}_handleMargins(){this._margins&&(this._margins.left=Math.max(this.paddingLeft,this._margins.left),this._margins.top=Math.max(this.paddingTop,this._margins.top),this._margins.right=Math.max(this.paddingRight,this._margins.right),this._margins.bottom=Math.max(this.paddingBottom,this._margins.bottom))}afterFit(){callback(this.options.afterFit,[this])}isHorizontal(){const{axis:t,position:e}=this.options;return"top"===e||"bottom"===e||"x"===t}isFullSize(){return this.options.fullSize}_convertTicksToLabels(t){let e,i;for(this.beforeTickToLabelConversion(),this.generateTickLabels(t),e=0,i=t.length;e<i;e++)isNullOrUndef(t[e].label)&&(t.splice(e,1),i--,e--);this.afterTickToLabelConversion()}_getLabelSizes(){let t=this._labelSizes;if(!t){const e=this.options.ticks.sampleSize;let i=this.ticks;e<i.length&&(i=sample(i,e)),this._labelSizes=t=this._computeLabelSizes(i,i.length,this.options.ticks.maxTicksLimit)}return t}_computeLabelSizes(t,e,i){const{ctx:s,_longestTextCache:n}=this,a=[],o=[],r=Math.floor(e/getTicksLimit(e,i));let l,h,c,d,u,g,p,f,m,x,b,_=0,y=0;for(l=0;l<e;l+=r){if(d=t[l].label,u=this._resolveTickFontOptions(l),s.font=g=u.string,p=n[g]=n[g]||{data:{},gc:[]},f=u.lineHeight,m=x=0,isNullOrUndef(d)||isArray(d)){if(isArray(d))for(h=0,c=d.length;h<c;++h)b=d[h],isNullOrUndef(b)||isArray(b)||(m=_measureText(s,p.data,p.gc,m,b),x+=f)}else m=_measureText(s,p.data,p.gc,m,d),x=f;a.push(m),o.push(x),_=Math.max(m,_),y=Math.max(x,y)}garbageCollect(n,e);const v=a.indexOf(_),k=o.indexOf(y),S=t=>({width:a[t]||0,height:o[t]||0});return{first:S(0),last:S(e-1),widest:S(v),highest:S(k),widths:a,heights:o}}getLabelForValue(t){return t}getPixelForValue(t,e){return NaN}getValueForPixel(t){}getPixelForTick(t){const e=this.ticks;return t<0||t>e.length-1?null:this.getPixelForValue(e[t].value)}getPixelForDecimal(t){this._reversePixels&&(t=1-t);const e=this._startPixel+t*this._length;return _int16Range(this._alignToPixels?_alignPixel(this.chart,e,0):e)}getDecimalForPixel(t){const e=(t-this._startPixel)/this._length;return this._reversePixels?1-e:e}getBasePixel(){return this.getPixelForValue(this.getBaseValue())}getBaseValue(){const{min:t,max:e}=this;return t<0&&e<0?e:t>0&&e>0?t:0}getContext(t){const e=this.ticks||[];if(t>=0&&t<e.length){const i=e[t];return i.$context||(i.$context=createTickContext(this.getContext(),t,i))}return this.$context||(this.$context=createScaleContext(this.chart.getContext(),this))}_tickSize(){const t=this.options.ticks,e=toRadians(this.labelRotation),i=Math.abs(Math.cos(e)),s=Math.abs(Math.sin(e)),n=this._getLabelSizes(),a=t.autoSkipPadding||0,o=n?n.widest.width+a:0,r=n?n.highest.height+a:0;return this.isHorizontal()?r*i>o*s?o/i:r/s:r*s<o*i?r/i:o/s}_isVisible(){const t=this.options.display;return"auto"!==t?!!t:this.getMatchingVisibleMetas().length>0}_computeGridLineItems(t){const e=this.axis,i=this.chart,s=this.options,{grid:n,position:a,border:o}=s,r=n.offset,l=this.isHorizontal(),h=this.ticks.length+(r?1:0),c=getTickMarkLength(n),d=[],u=o.setContext(this.getContext()),g=u.display?u.width:0,p=g/2,f=function(t){return _alignPixel(i,t,g)};let m,x,b,_,y,v,k,S,D,M,P,w;if("top"===a)m=f(this.bottom),v=this.bottom-c,S=m-p,M=f(t.top)+p,w=t.bottom;else if("bottom"===a)m=f(this.top),M=t.top,w=f(t.bottom)-p,v=m+p,S=this.top+c;else if("left"===a)m=f(this.right),y=this.right-c,k=m-p,D=f(t.left)+p,P=t.right;else if("right"===a)m=f(this.left),D=t.left,P=f(t.right)-p,y=m+p,k=this.left+c;else if("x"===e){if("center"===a)m=f((t.top+t.bottom)/2+.5);else if(isObject(a)){const t=Object.keys(a)[0],e=a[t];m=f(this.chart.scales[t].getPixelForValue(e))}M=t.top,w=t.bottom,v=m+p,S=v+c}else if("y"===e){if("center"===a)m=f((t.left+t.right)/2);else if(isObject(a)){const t=Object.keys(a)[0],e=a[t];m=f(this.chart.scales[t].getPixelForValue(e))}y=m-p,k=y-c,D=t.left,P=t.right}const C=valueOrDefault(s.ticks.maxTicksLimit,h),A=Math.max(1,Math.ceil(h/C));for(x=0;x<h;x+=A){const t=this.getContext(x),e=n.setContext(t),s=o.setContext(t),a=e.lineWidth,h=e.color,c=s.dash||[],u=s.dashOffset,g=e.tickWidth,p=e.tickColor,f=e.tickBorderDash||[],m=e.tickBorderDashOffset;b=getPixelForGridLine(this,x,r),void 0!==b&&(_=_alignPixel(i,b,a),l?y=k=D=P=_:v=S=M=w=_,d.push({tx1:y,ty1:v,tx2:k,ty2:S,x1:D,y1:M,x2:P,y2:w,width:a,color:h,borderDash:c,borderDashOffset:u,tickWidth:g,tickColor:p,tickBorderDash:f,tickBorderDashOffset:m}))}return this._ticksLength=h,this._borderValue=m,d}_computeLabelItems(t){const e=this.axis,i=this.options,{position:s,ticks:n}=i,a=this.isHorizontal(),o=this.ticks,{align:r,crossAlign:l,padding:h,mirror:c}=n,d=getTickMarkLength(i.grid),u=d+h,g=c?-h:u,p=-toRadians(this.labelRotation),f=[];let m,x,b,_,y,v,k,S,D,M,P,w,C="middle";if("top"===s)v=this.bottom-g,k=this._getXAxisLabelAlignment();else if("bottom"===s)v=this.top+g,k=this._getXAxisLabelAlignment();else if("left"===s){const t=this._getYAxisLabelAlignment(d);k=t.textAlign,y=t.x}else if("right"===s){const t=this._getYAxisLabelAlignment(d);k=t.textAlign,y=t.x}else if("x"===e){if("center"===s)v=(t.top+t.bottom)/2+u;else if(isObject(s)){const t=Object.keys(s)[0],e=s[t];v=this.chart.scales[t].getPixelForValue(e)+u}k=this._getXAxisLabelAlignment()}else if("y"===e){if("center"===s)y=(t.left+t.right)/2-u;else if(isObject(s)){const t=Object.keys(s)[0],e=s[t];y=this.chart.scales[t].getPixelForValue(e)}k=this._getYAxisLabelAlignment(d).textAlign}"y"===e&&("start"===r?C="top":"end"===r&&(C="bottom"));const A=this._getLabelSizes();for(m=0,x=o.length;m<x;++m){b=o[m],_=b.label;const t=n.setContext(this.getContext(m));S=this.getPixelForTick(m)+n.labelOffset,D=this._resolveTickFontOptions(m),M=D.lineHeight,P=isArray(_)?_.length:1;const e=P/2,i=t.color,r=t.textStrokeColor,h=t.textStrokeWidth;let d,u=k;if(a?(y=S,"inner"===k&&(u=m===x-1?this.options.reverse?"left":"right":0===m?this.options.reverse?"right":"left":"center"),w="top"===s?"near"===l||0!==p?-P*M+M/2:"center"===l?-A.highest.height/2-e*M+M:-A.highest.height+M/2:"near"===l||0!==p?M/2:"center"===l?A.highest.height/2-e*M:A.highest.height-P*M,c&&(w*=-1),0===p||t.showLabelBackdrop||(y+=M/2*Math.sin(p))):(v=S,w=(1-P)*M/2),t.showLabelBackdrop){const e=toPadding(t.backdropPadding),i=A.heights[m],s=A.widths[m];let n=w-e.top,a=0-e.left;switch(C){case"middle":n-=i/2;break;case"bottom":n-=i}switch(k){case"center":a-=s/2;break;case"right":a-=s}d={left:a,top:n,width:s+e.width,height:i+e.height,color:t.backdropColor}}f.push({label:_,font:D,textOffset:w,options:{rotation:p,color:i,strokeColor:r,strokeWidth:h,textAlign:u,textBaseline:C,translation:[y,v],backdrop:d}})}return f}_getXAxisLabelAlignment(){const{position:t,ticks:e}=this.options;if(-toRadians(this.labelRotation))return"top"===t?"left":"right";let i="center";return"start"===e.align?i="left":"end"===e.align?i="right":"inner"===e.align&&(i="inner"),i}_getYAxisLabelAlignment(t){const{position:e,ticks:{crossAlign:i,mirror:s,padding:n}}=this.options,a=t+n,o=this._getLabelSizes().widest.width;let r,l;return"left"===e?s?(l=this.right+n,"near"===i?r="left":"center"===i?(r="center",l+=o/2):(r="right",l+=o)):(l=this.right-a,"near"===i?r="right":"center"===i?(r="center",l-=o/2):(r="left",l=this.left)):"right"===e?s?(l=this.left+n,"near"===i?r="right":"center"===i?(r="center",l-=o/2):(r="left",l-=o)):(l=this.left+a,"near"===i?r="left":"center"===i?(r="center",l+=o/2):(r="right",l=this.right)):r="right",{textAlign:r,x:l}}_computeLabelArea(){if(this.options.ticks.mirror)return;const t=this.chart,e=this.options.position;return"left"===e||"right"===e?{top:0,left:this.left,bottom:t.height,right:this.right}:"top"===e||"bottom"===e?{top:this.top,left:0,bottom:this.bottom,right:t.width}:void 0}drawBackground(){const{ctx:t,options:{backgroundColor:e},left:i,top:s,width:n,height:a}=this;e&&(t.save(),t.fillStyle=e,t.fillRect(i,s,n,a),t.restore())}getLineWidthForValue(t){const e=this.options.grid;if(!this._isVisible()||!e.display)return 0;const i=this.ticks.findIndex((e=>e.value===t));if(i>=0){return e.setContext(this.getContext(i)).lineWidth}return 0}drawGrid(t){const e=this.options.grid,i=this.ctx,s=this._gridLineItems||(this._gridLineItems=this._computeGridLineItems(t));let n,a;const o=(t,e,s)=>{s.width&&s.color&&(i.save(),i.lineWidth=s.width,i.strokeStyle=s.color,i.setLineDash(s.borderDash||[]),i.lineDashOffset=s.borderDashOffset,i.beginPath(),i.moveTo(t.x,t.y),i.lineTo(e.x,e.y),i.stroke(),i.restore())};if(e.display)for(n=0,a=s.length;n<a;++n){const t=s[n];e.drawOnChartArea&&o({x:t.x1,y:t.y1},{x:t.x2,y:t.y2},t),e.drawTicks&&o({x:t.tx1,y:t.ty1},{x:t.tx2,y:t.ty2},{color:t.tickColor,width:t.tickWidth,borderDash:t.tickBorderDash,borderDashOffset:t.tickBorderDashOffset})}}drawBorder(){const{chart:t,ctx:e,options:{border:i,grid:s}}=this,n=i.setContext(this.getContext()),a=i.display?n.width:0;if(!a)return;const o=s.setContext(this.getContext(0)).lineWidth,r=this._borderValue;let l,h,c,d;this.isHorizontal()?(l=_alignPixel(t,this.left,a)-a/2,h=_alignPixel(t,this.right,o)+o/2,c=d=r):(c=_alignPixel(t,this.top,a)-a/2,d=_alignPixel(t,this.bottom,o)+o/2,l=h=r),e.save(),e.lineWidth=n.width,e.strokeStyle=n.color,e.beginPath(),e.moveTo(l,c),e.lineTo(h,d),e.stroke(),e.restore()}drawLabels(t){if(!this.options.ticks.display)return;const e=this.ctx,i=this._computeLabelArea();i&&clipArea(e,i);const s=this.getLabelItems(t);for(const t of s){const i=t.options,s=t.font,n=t.label,a=t.textOffset;renderText(e,n,0,a,s,i)}i&&unclipArea(e)}drawTitle(){const{ctx:t,options:{position:e,title:i,reverse:s}}=this;if(!i.display)return;const n=toFont(i.font),a=toPadding(i.padding),o=i.align;let r=n.lineHeight/2;"bottom"===e||"center"===e||isObject(e)?(r+=a.bottom,isArray(i.text)&&(r+=n.lineHeight*(i.text.length-1))):r+=a.top;const{titleX:l,titleY:h,maxWidth:c,rotation:d}=titleArgs(this,r,e,o);renderText(t,i.text,0,0,n,{color:i.color,maxWidth:c,rotation:d,textAlign:titleAlign(o,e,s),textBaseline:"middle",translation:[l,h]})}draw(t){this._isVisible()&&(this.drawBackground(),this.drawGrid(t),this.drawBorder(),this.drawTitle(),this.drawLabels(t))}_layers(){const t=this.options,e=t.ticks&&t.ticks.z||0,i=valueOrDefault(t.grid&&t.grid.z,-1),s=valueOrDefault(t.border&&t.border.z,0);return this._isVisible()&&this.draw===Scale.prototype.draw?[{z:i,draw:t=>{this.drawBackground(),this.drawGrid(t),this.drawTitle()}},{z:s,draw:()=>{this.drawBorder()}},{z:e,draw:t=>{this.drawLabels(t)}}]:[{z:e,draw:t=>{this.draw(t)}}]}getMatchingVisibleMetas(t){const e=this.chart.getSortedVisibleDatasetMetas(),i=this.axis+"AxisID",s=[];let n,a;for(n=0,a=e.length;n<a;++n){const a=e[n];a[i]!==this.id||t&&a.type!==t||s.push(a)}return s}_resolveTickFontOptions(t){const e=this.options.ticks.setContext(this.getContext(t));return toFont(e.font)}_maxDigits(){const t=this._resolveTickFontOptions(0).lineHeight;return(this.isHorizontal()?this.width:this.height)/t}}class TypedRegistry{constructor(t,e,i){this.type=t,this.scope=e,this.override=i,this.items=Object.create(null)}isForType(t){return Object.prototype.isPrototypeOf.call(this.type.prototype,t.prototype)}register(t){const e=Object.getPrototypeOf(t);let i;isIChartComponent(e)&&(i=this.register(e));const s=this.items,n=t.id,a=this.scope+"."+n;if(!n)throw new Error("class does not have id: "+t);return n in s||(s[n]=t,registerDefaults(t,a,i),this.override&&defaults.override(t.id,t.overrides)),a}get(t){return this.items[t]}unregister(t){const e=this.items,i=t.id,s=this.scope;i in e&&delete e[i],s&&i in defaults[s]&&(delete defaults[s][i],this.override&&delete overrides[i])}}function registerDefaults(t,e,i){const s=merge(Object.create(null),[i?defaults.get(i):{},defaults.get(e),t.defaults]);defaults.set(e,s),t.defaultRoutes&&routeDefaults(e,t.defaultRoutes),t.descriptors&&defaults.describe(e,t.descriptors)}function routeDefaults(t,e){Object.keys(e).forEach((i=>{const s=i.split("."),n=s.pop(),a=[t].concat(s).join("."),o=e[i].split("."),r=o.pop(),l=o.join(".");defaults.route(a,n,l,r)}))}function isIChartComponent(t){return"id"in t&&"defaults"in t}class Registry{constructor(){this.controllers=new TypedRegistry(DatasetController,"datasets",!0),this.elements=new TypedRegistry(Element,"elements"),this.plugins=new TypedRegistry(Object,"plugins"),this.scales=new TypedRegistry(Scale,"scales"),this._typedRegistries=[this.controllers,this.scales,this.elements]}add(...t){this._each("register",t)}remove(...t){this._each("unregister",t)}addControllers(...t){this._each("register",t,this.controllers)}addElements(...t){this._each("register",t,this.elements)}addPlugins(...t){this._each("register",t,this.plugins)}addScales(...t){this._each("register",t,this.scales)}getController(t){return this._get(t,this.controllers,"controller")}getElement(t){return this._get(t,this.elements,"element")}getPlugin(t){return this._get(t,this.plugins,"plugin")}getScale(t){return this._get(t,this.scales,"scale")}removeControllers(...t){this._each("unregister",t,this.controllers)}removeElements(...t){this._each("unregister",t,this.elements)}removePlugins(...t){this._each("unregister",t,this.plugins)}removeScales(...t){this._each("unregister",t,this.scales)}_each(t,e,i){[...e].forEach((e=>{const s=i||this._getRegistryForType(e);i||s.isForType(e)||s===this.plugins&&e.id?this._exec(t,s,e):each(e,(e=>{const s=i||this._getRegistryForType(e);this._exec(t,s,e)}))}))}_exec(t,e,i){const s=_capitalize(t);callback(i["before"+s],[],i),e[t](i),callback(i["after"+s],[],i)}_getRegistryForType(t){for(let e=0;e<this._typedRegistries.length;e++){const i=this._typedRegistries[e];if(i.isForType(t))return i}return this.plugins}_get(t,e,i){const s=e.get(t);if(void 0===s)throw new Error('"'+t+'" is not a registered '+i+".");return s}}var registry=new Registry;class PluginService{constructor(){this._init=[]}notify(t,e,i,s){"beforeInit"===e&&(this._init=this._createDescriptors(t,!0),this._notify(this._init,t,"install"));const n=s?this._descriptors(t).filter(s):this._descriptors(t),a=this._notify(n,t,e,i);return"afterDestroy"===e&&(this._notify(n,t,"stop"),this._notify(this._init,t,"uninstall")),a}_notify(t,e,i,s){s=s||{};for(const n of t){const t=n.plugin,a=t[i],o=[e,s,n.options];if(!1===callback(a,o,t)&&s.cancelable)return!1}return!0}invalidate(){isNullOrUndef(this._cache)||(this._oldCache=this._cache,this._cache=void 0)}_descriptors(t){if(this._cache)return this._cache;const e=this._cache=this._createDescriptors(t);return this._notifyStateChanges(t),e}_createDescriptors(t,e){const i=t&&t.config,s=valueOrDefault(i.options&&i.options.plugins,{}),n=allPlugins(i);return!1!==s||e?createDescriptors(t,n,s,e):[]}_notifyStateChanges(t){const e=this._oldCache||[],i=this._cache,s=(t,e)=>t.filter((t=>!e.some((e=>t.plugin.id===e.plugin.id))));this._notify(s(e,i),t,"stop"),this._notify(s(i,e),t,"start")}}function allPlugins(t){const e={},i=[],s=Object.keys(registry.plugins.items);for(let t=0;t<s.length;t++)i.push(registry.getPlugin(s[t]));const n=t.plugins||[];for(let t=0;t<n.length;t++){const s=n[t];-1===i.indexOf(s)&&(i.push(s),e[s.id]=!0)}return{plugins:i,localIds:e}}function getOpts(t,e){return e||!1!==t?!0===t?{}:t:null}function createDescriptors(t,{plugins:e,localIds:i},s,n){const a=[],o=t.getContext();for(const r of e){const e=r.id,l=getOpts(s[e],n);null!==l&&a.push({plugin:r,options:pluginOpts(t.config,{plugin:r,local:i[e]},l,o)})}return a}function pluginOpts(t,{plugin:e,local:i},s,n){const a=t.pluginScopeKeys(e),o=t.getOptionScopes(s,a);return i&&e.defaults&&o.push(e.defaults),t.createResolver(o,n,[""],{scriptable:!1,indexable:!1,allKeys:!0})}function getIndexAxis(t,e){const i=defaults.datasets[t]||{};return((e.datasets||{})[t]||{}).indexAxis||e.indexAxis||i.indexAxis||"x"}function getAxisFromDefaultScaleID(t,e){let i=t;return"_index_"===t?i=e:"_value_"===t&&(i="x"===e?"y":"x"),i}function getDefaultScaleIDFromAxis(t,e){return t===e?"_index_":"_value_"}function idMatchesAxis(t){if("x"===t||"y"===t||"r"===t)return t}function axisFromPosition(t){return"top"===t||"bottom"===t?"x":"left"===t||"right"===t?"y":void 0}function determineAxis(t,...e){if(idMatchesAxis(t))return t;for(const i of e){const e=i.axis||axisFromPosition(i.position)||t.length>1&&idMatchesAxis(t[0].toLowerCase());if(e)return e}throw new Error(`Cannot determine type of '${t}' axis. Please provide 'axis' or 'position' option.`)}function getAxisFromDataset(t,e,i){if(i[e+"AxisID"]===t)return{axis:e}}function retrieveAxisFromDatasets(t,e){if(e.data&&e.data.datasets){const i=e.data.datasets.filter((e=>e.xAxisID===t||e.yAxisID===t));if(i.length)return getAxisFromDataset(t,"x",i[0])||getAxisFromDataset(t,"y",i[0])}return{}}function mergeScaleConfig(t,e){const i=overrides[t.type]||{scales:{}},s=e.scales||{},n=getIndexAxis(t.type,e),a=Object.create(null);return Object.keys(s).forEach((e=>{const o=s[e];if(!isObject(o))return console.error(`Invalid scale configuration for scale: ${e}`);if(o._proxy)return console.warn(`Ignoring resolver passed as options for scale: ${e}`);const r=determineAxis(e,o,retrieveAxisFromDatasets(e,t),defaults.scales[o.type]),l=getDefaultScaleIDFromAxis(r,n),h=i.scales||{};a[e]=mergeIf(Object.create(null),[{axis:r},o,h[r],h[l]])})),t.data.datasets.forEach((i=>{const n=i.type||t.type,o=i.indexAxis||getIndexAxis(n,e),r=(overrides[n]||{}).scales||{};Object.keys(r).forEach((t=>{const e=getAxisFromDefaultScaleID(t,o),n=i[e+"AxisID"]||e;a[n]=a[n]||Object.create(null),mergeIf(a[n],[{axis:e},s[n],r[t]])}))})),Object.keys(a).forEach((t=>{const e=a[t];mergeIf(e,[defaults.scales[e.type],defaults.scale])})),a}function initOptions(t){const e=t.options||(t.options={});e.plugins=valueOrDefault(e.plugins,{}),e.scales=mergeScaleConfig(t,e)}function initData(t){return(t=t||{}).datasets=t.datasets||[],t.labels=t.labels||[],t}function initConfig(t){return(t=t||{}).data=initData(t.data),initOptions(t),t}const keyCache=new Map,keysCached=new Set;function cachedKeys(t,e){let i=keyCache.get(t);return i||(i=e(),keyCache.set(t,i),keysCached.add(i)),i}const addIfFound=(t,e,i)=>{const s=resolveObjectKey(e,i);void 0!==s&&t.add(s)};class Config{constructor(t){this._config=initConfig(t),this._scopeCache=new Map,this._resolverCache=new Map}get platform(){return this._config.platform}get type(){return this._config.type}set type(t){this._config.type=t}get data(){return this._config.data}set data(t){this._config.data=initData(t)}get options(){return this._config.options}set options(t){this._config.options=t}get plugins(){return this._config.plugins}update(){const t=this._config;this.clearCache(),initOptions(t)}clearCache(){this._scopeCache.clear(),this._resolverCache.clear()}datasetScopeKeys(t){return cachedKeys(t,(()=>[[`datasets.${t}`,""]]))}datasetAnimationScopeKeys(t,e){return cachedKeys(`${t}.transition.${e}`,(()=>[[`datasets.${t}.transitions.${e}`,`transitions.${e}`],[`datasets.${t}`,""]]))}datasetElementScopeKeys(t,e){return cachedKeys(`${t}-${e}`,(()=>[[`datasets.${t}.elements.${e}`,`datasets.${t}`,`elements.${e}`,""]]))}pluginScopeKeys(t){const e=t.id;return cachedKeys(`${this.type}-plugin-${e}`,(()=>[[`plugins.${e}`,...t.additionalOptionScopes||[]]]))}_cachedScopes(t,e){const i=this._scopeCache;let s=i.get(t);return s&&!e||(s=new Map,i.set(t,s)),s}getOptionScopes(t,e,i){const{options:s,type:n}=this,a=this._cachedScopes(t,i),o=a.get(e);if(o)return o;const r=new Set;e.forEach((e=>{t&&(r.add(t),e.forEach((e=>addIfFound(r,t,e)))),e.forEach((t=>addIfFound(r,s,t))),e.forEach((t=>addIfFound(r,overrides[n]||{},t))),e.forEach((t=>addIfFound(r,defaults,t))),e.forEach((t=>addIfFound(r,descriptors,t)))}));const l=Array.from(r);return 0===l.length&&l.push(Object.create(null)),keysCached.has(e)&&a.set(e,l),l}chartOptionScopes(){const{options:t,type:e}=this;return[t,overrides[e]||{},defaults.datasets[e]||{},{type:e},defaults,descriptors]}resolveNamedOptions(t,e,i,s=[""]){const n={$shared:!0},{resolver:a,subPrefixes:o}=getResolver(this._resolverCache,t,s);let r=a;if(needContext(a,e)){n.$shared=!1,i=isFunction(i)?i():i;const e=this.createResolver(t,i,o);r=_attachContext(a,i,e)}for(const t of e)n[t]=r[t];return n}createResolver(t,e,i=[""],s){const{resolver:n}=getResolver(this._resolverCache,t,i);return isObject(e)?_attachContext(n,e,void 0,s):n}}function getResolver(t,e,i){let s=t.get(e);s||(s=new Map,t.set(e,s));const n=i.join();let a=s.get(n);if(!a){a={resolver:_createResolver(e,i),subPrefixes:i.filter((t=>!t.toLowerCase().includes("hover")))},s.set(n,a)}return a}const hasFunction=t=>isObject(t)&&Object.getOwnPropertyNames(t).reduce(((e,i)=>e||isFunction(t[i])),!1);function needContext(t,e){const{isScriptable:i,isIndexable:s}=_descriptors(t);for(const n of e){const e=i(n),a=s(n),o=(a||e)&&t[n];if(e&&(isFunction(o)||hasFunction(o))||a&&isArray(o))return!0}return!1}var version="4.4.0";const KNOWN_POSITIONS=["top","bottom","left","right","chartArea"];function positionIsHorizontal(t,e){return"top"===t||"bottom"===t||-1===KNOWN_POSITIONS.indexOf(t)&&"x"===e}function compare2Level(t,e){return function(i,s){return i[t]===s[t]?i[e]-s[e]:i[t]-s[t]}}function onAnimationsComplete(t){const e=t.chart,i=e.options.animation;e.notifyPlugins("afterRender"),callback(i&&i.onComplete,[t],e)}function onAnimationProgress(t){const e=t.chart,i=e.options.animation;callback(i&&i.onProgress,[t],e)}function getCanvas(t){return _isDomSupported()&&"string"==typeof t?t=document.getElementById(t):t&&t.length&&(t=t[0]),t&&t.canvas&&(t=t.canvas),t}const instances={},getChart=t=>{const e=getCanvas(t);return Object.values(instances).filter((t=>t.canvas===e)).pop()};function moveNumericKeys(t,e,i){const s=Object.keys(t);for(const n of s){const s=+n;if(s>=e){const a=t[n];delete t[n],(i>0||s>e)&&(t[s+i]=a)}}}function determineLastEvent(t,e,i,s){return i&&"mouseout"!==t.type?s?e:t:null}function getSizeForArea(t,e,i){return t.options.clip?t[i]:e[i]}function getDatasetArea(t,e){const{xScale:i,yScale:s}=t;return i&&s?{left:getSizeForArea(i,e,"left"),right:getSizeForArea(i,e,"right"),top:getSizeForArea(s,e,"top"),bottom:getSizeForArea(s,e,"bottom")}:e}class Chart{static defaults=defaults;static instances=instances;static overrides=overrides;static registry=registry;static version=version;static getChart=getChart;static register(...t){registry.add(...t),invalidatePlugins()}static unregister(...t){registry.remove(...t),invalidatePlugins()}constructor(t,e){const i=this.config=new Config(e),s=getCanvas(t),n=getChart(s);if(n)throw new Error("Canvas is already in use. Chart with ID '"+n.id+"' must be destroyed before the canvas with ID '"+n.canvas.id+"' can be reused.");const a=i.createResolver(i.chartOptionScopes(),this.getContext());this.platform=new(i.platform||_detectPlatform(s)),this.platform.updateConfig(i);const o=this.platform.acquireContext(s,a.aspectRatio),r=o&&o.canvas,l=r&&r.height,h=r&&r.width;this.id=uid(),this.ctx=o,this.canvas=r,this.width=h,this.height=l,this._options=a,this._aspectRatio=this.aspectRatio,this._layers=[],this._metasets=[],this._stacks=void 0,this.boxes=[],this.currentDevicePixelRatio=void 0,this.chartArea=void 0,this._active=[],this._lastEvent=void 0,this._listeners={},this._responsiveListeners=void 0,this._sortedMetasets=[],this.scales={},this._plugins=new PluginService,this.$proxies={},this._hiddenIndices={},this.attached=!1,this._animationsDisabled=void 0,this.$context=void 0,this._doResize=debounce((t=>this.update(t)),a.resizeDelay||0),this._dataChanges=[],instances[this.id]=this,o&&r?(animator.listen(this,"complete",onAnimationsComplete),animator.listen(this,"progress",onAnimationProgress),this._initialize(),this.attached&&this.update()):console.error("Failed to create chart: can't acquire context from the given item")}get aspectRatio(){const{options:{aspectRatio:t,maintainAspectRatio:e},width:i,height:s,_aspectRatio:n}=this;return isNullOrUndef(t)?e&&n?n:s?i/s:null:t}get data(){return this.config.data}set data(t){this.config.data=t}get options(){return this._options}set options(t){this.config.options=t}get registry(){return registry}_initialize(){return this.notifyPlugins("beforeInit"),this.options.responsive?this.resize():retinaScale(this,this.options.devicePixelRatio),this.bindEvents(),this.notifyPlugins("afterInit"),this}clear(){return clearCanvas(this.canvas,this.ctx),this}stop(){return animator.stop(this),this}resize(t,e){animator.running(this)?this._resizeBeforeDraw={width:t,height:e}:this._resize(t,e)}_resize(t,e){const i=this.options,s=this.canvas,n=i.maintainAspectRatio&&this.aspectRatio,a=this.platform.getMaximumSize(s,t,e,n),o=i.devicePixelRatio||this.platform.getDevicePixelRatio(),r=this.width?"resize":"attach";this.width=a.width,this.height=a.height,this._aspectRatio=this.aspectRatio,retinaScale(this,o,!0)&&(this.notifyPlugins("resize",{size:a}),callback(i.onResize,[this,a],this),this.attached&&this._doResize(r)&&this.render())}ensureScalesHaveIDs(){const t=this.options.scales||{};each(t,((t,e)=>{t.id=e}))}buildOrUpdateScales(){const t=this.options,e=t.scales,i=this.scales,s=Object.keys(i).reduce(((t,e)=>(t[e]=!1,t)),{});let n=[];e&&(n=n.concat(Object.keys(e).map((t=>{const i=e[t],s=determineAxis(t,i),n="r"===s,a="x"===s;return{options:i,dposition:n?"chartArea":a?"bottom":"left",dtype:n?"radialLinear":a?"category":"linear"}})))),each(n,(e=>{const n=e.options,a=n.id,o=determineAxis(a,n),r=valueOrDefault(n.type,e.dtype);void 0!==n.position&&positionIsHorizontal(n.position,o)===positionIsHorizontal(e.dposition)||(n.position=e.dposition),s[a]=!0;let l=null;if(a in i&&i[a].type===r)l=i[a];else{l=new(registry.getScale(r))({id:a,type:r,ctx:this.ctx,chart:this}),i[l.id]=l}l.init(n,t)})),each(s,((t,e)=>{t||delete i[e]})),each(i,(t=>{layouts.configure(this,t,t.options),layouts.addBox(this,t)}))}_updateMetasets(){const t=this._metasets,e=this.data.datasets.length,i=t.length;if(t.sort(((t,e)=>t.index-e.index)),i>e){for(let t=e;t<i;++t)this._destroyDatasetMeta(t);t.splice(e,i-e)}this._sortedMetasets=t.slice(0).sort(compare2Level("order","index"))}_removeUnreferencedMetasets(){const{_metasets:t,data:{datasets:e}}=this;t.length>e.length&&delete this._stacks,t.forEach(((t,i)=>{0===e.filter((e=>e===t._dataset)).length&&this._destroyDatasetMeta(i)}))}buildOrUpdateControllers(){const t=[],e=this.data.datasets;let i,s;for(this._removeUnreferencedMetasets(),i=0,s=e.length;i<s;i++){const s=e[i];let n=this.getDatasetMeta(i);const a=s.type||this.config.type;if(n.type&&n.type!==a&&(this._destroyDatasetMeta(i),n=this.getDatasetMeta(i)),n.type=a,n.indexAxis=s.indexAxis||getIndexAxis(a,this.options),n.order=s.order||0,n.index=i,n.label=""+s.label,n.visible=this.isDatasetVisible(i),n.controller)n.controller.updateIndex(i),n.controller.linkScales();else{const e=registry.getController(a),{datasetElementType:s,dataElementType:o}=defaults.datasets[a];Object.assign(e,{dataElementType:registry.getElement(o),datasetElementType:s&&registry.getElement(s)}),n.controller=new e(this,i),t.push(n.controller)}}return this._updateMetasets(),t}_resetElements(){each(this.data.datasets,((t,e)=>{this.getDatasetMeta(e).controller.reset()}),this)}reset(){this._resetElements(),this.notifyPlugins("reset")}update(t){const e=this.config;e.update();const i=this._options=e.createResolver(e.chartOptionScopes(),this.getContext()),s=this._animationsDisabled=!i.animation;if(this._updateScales(),this._checkEventBindings(),this._updateHiddenIndices(),this._plugins.invalidate(),!1===this.notifyPlugins("beforeUpdate",{mode:t,cancelable:!0}))return;const n=this.buildOrUpdateControllers();this.notifyPlugins("beforeElementsUpdate");let a=0;for(let t=0,e=this.data.datasets.length;t<e;t++){const{controller:e}=this.getDatasetMeta(t),i=!s&&-1===n.indexOf(e);e.buildOrUpdateElements(i),a=Math.max(+e.getMaxOverflow(),a)}a=this._minPadding=i.layout.autoPadding?a:0,this._updateLayout(a),s||each(n,(t=>{t.reset()})),this._updateDatasets(t),this.notifyPlugins("afterUpdate",{mode:t}),this._layers.sort(compare2Level("z","_idx"));const{_active:o,_lastEvent:r}=this;r?this._eventHandler(r,!0):o.length&&this._updateHoverStyles(o,o,!0),this.render()}_updateScales(){each(this.scales,(t=>{layouts.removeBox(this,t)})),this.ensureScalesHaveIDs(),this.buildOrUpdateScales()}_checkEventBindings(){const t=this.options,e=new Set(Object.keys(this._listeners)),i=new Set(t.events);setsEqual(e,i)&&!!this._responsiveListeners===t.responsive||(this.unbindEvents(),this.bindEvents())}_updateHiddenIndices(){const{_hiddenIndices:t}=this,e=this._getUniformDataChanges()||[];for(const{method:i,start:s,count:n}of e){moveNumericKeys(t,s,"_removeElements"===i?-n:n)}}_getUniformDataChanges(){const t=this._dataChanges;if(!t||!t.length)return;this._dataChanges=[];const e=this.data.datasets.length,i=e=>new Set(t.filter((t=>t[0]===e)).map(((t,e)=>e+","+t.splice(1).join(",")))),s=i(0);for(let t=1;t<e;t++)if(!setsEqual(s,i(t)))return;return Array.from(s).map((t=>t.split(","))).map((t=>({method:t[1],start:+t[2],count:+t[3]})))}_updateLayout(t){if(!1===this.notifyPlugins("beforeLayout",{cancelable:!0}))return;layouts.update(this,this.width,this.height,t);const e=this.chartArea,i=e.width<=0||e.height<=0;this._layers=[],each(this.boxes,(t=>{i&&"chartArea"===t.position||(t.configure&&t.configure(),this._layers.push(...t._layers()))}),this),this._layers.forEach(((t,e)=>{t._idx=e})),this.notifyPlugins("afterLayout")}_updateDatasets(t){if(!1!==this.notifyPlugins("beforeDatasetsUpdate",{mode:t,cancelable:!0})){for(let t=0,e=this.data.datasets.length;t<e;++t)this.getDatasetMeta(t).controller.configure();for(let e=0,i=this.data.datasets.length;e<i;++e)this._updateDataset(e,isFunction(t)?t({datasetIndex:e}):t);this.notifyPlugins("afterDatasetsUpdate",{mode:t})}}_updateDataset(t,e){const i=this.getDatasetMeta(t),s={meta:i,index:t,mode:e,cancelable:!0};!1!==this.notifyPlugins("beforeDatasetUpdate",s)&&(i.controller._update(e),s.cancelable=!1,this.notifyPlugins("afterDatasetUpdate",s))}render(){!1!==this.notifyPlugins("beforeRender",{cancelable:!0})&&(animator.has(this)?this.attached&&!animator.running(this)&&animator.start(this):(this.draw(),onAnimationsComplete({chart:this})))}draw(){let t;if(this._resizeBeforeDraw){const{width:t,height:e}=this._resizeBeforeDraw;this._resize(t,e),this._resizeBeforeDraw=null}if(this.clear(),this.width<=0||this.height<=0)return;if(!1===this.notifyPlugins("beforeDraw",{cancelable:!0}))return;const e=this._layers;for(t=0;t<e.length&&e[t].z<=0;++t)e[t].draw(this.chartArea);for(this._drawDatasets();t<e.length;++t)e[t].draw(this.chartArea);this.notifyPlugins("afterDraw")}_getSortedDatasetMetas(t){const e=this._sortedMetasets,i=[];let s,n;for(s=0,n=e.length;s<n;++s){const n=e[s];t&&!n.visible||i.push(n)}return i}getSortedVisibleDatasetMetas(){return this._getSortedDatasetMetas(!0)}_drawDatasets(){if(!1===this.notifyPlugins("beforeDatasetsDraw",{cancelable:!0}))return;const t=this.getSortedVisibleDatasetMetas();for(let e=t.length-1;e>=0;--e)this._drawDataset(t[e]);this.notifyPlugins("afterDatasetsDraw")}_drawDataset(t){const e=this.ctx,i=t._clip,s=!i.disabled,n=getDatasetArea(t,this.chartArea),a={meta:t,index:t.index,cancelable:!0};!1!==this.notifyPlugins("beforeDatasetDraw",a)&&(s&&clipArea(e,{left:!1===i.left?0:n.left-i.left,right:!1===i.right?this.width:n.right+i.right,top:!1===i.top?0:n.top-i.top,bottom:!1===i.bottom?this.height:n.bottom+i.bottom}),t.controller.draw(),s&&unclipArea(e),a.cancelable=!1,this.notifyPlugins("afterDatasetDraw",a))}isPointInArea(t){return _isPointInArea(t,this.chartArea,this._minPadding)}getElementsAtEventForMode(t,e,i,s){const n=Interaction.modes[e];return"function"==typeof n?n(this,t,i,s):[]}getDatasetMeta(t){const e=this.data.datasets[t],i=this._metasets;let s=i.filter((t=>t&&t._dataset===e)).pop();return s||(s={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null,order:e&&e.order||0,index:t,_dataset:e,_parsed:[],_sorted:!1},i.push(s)),s}getContext(){return this.$context||(this.$context=createContext(null,{chart:this,type:"chart"}))}getVisibleDatasetCount(){return this.getSortedVisibleDatasetMetas().length}isDatasetVisible(t){const e=this.data.datasets[t];if(!e)return!1;const i=this.getDatasetMeta(t);return"boolean"==typeof i.hidden?!i.hidden:!e.hidden}setDatasetVisibility(t,e){this.getDatasetMeta(t).hidden=!e}toggleDataVisibility(t){this._hiddenIndices[t]=!this._hiddenIndices[t]}getDataVisibility(t){return!this._hiddenIndices[t]}_updateVisibility(t,e,i){const s=i?"show":"hide",n=this.getDatasetMeta(t),a=n.controller._resolveAnimations(void 0,s);defined(e)?(n.data[e].hidden=!i,this.update()):(this.setDatasetVisibility(t,i),a.update(n,{visible:i}),this.update((e=>e.datasetIndex===t?s:void 0)))}hide(t,e){this._updateVisibility(t,e,!1)}show(t,e){this._updateVisibility(t,e,!0)}_destroyDatasetMeta(t){const e=this._metasets[t];e&&e.controller&&e.controller._destroy(),delete this._metasets[t]}_stop(){let t,e;for(this.stop(),animator.remove(this),t=0,e=this.data.datasets.length;t<e;++t)this._destroyDatasetMeta(t)}destroy(){this.notifyPlugins("beforeDestroy");const{canvas:t,ctx:e}=this;this._stop(),this.config.clearCache(),t&&(this.unbindEvents(),clearCanvas(t,e),this.platform.releaseContext(e),this.canvas=null,this.ctx=null),delete instances[this.id],this.notifyPlugins("afterDestroy")}toBase64Image(...t){return this.canvas.toDataURL(...t)}bindEvents(){this.bindUserEvents(),this.options.responsive?this.bindResponsiveEvents():this.attached=!0}bindUserEvents(){const t=this._listeners,e=this.platform,i=(i,s)=>{e.addEventListener(this,i,s),t[i]=s},s=(t,e,i)=>{t.offsetX=e,t.offsetY=i,this._eventHandler(t)};each(this.options.events,(t=>i(t,s)))}bindResponsiveEvents(){this._responsiveListeners||(this._responsiveListeners={});const t=this._responsiveListeners,e=this.platform,i=(i,s)=>{e.addEventListener(this,i,s),t[i]=s},s=(i,s)=>{t[i]&&(e.removeEventListener(this,i,s),delete t[i])},n=(t,e)=>{this.canvas&&this.resize(t,e)};let a;const o=()=>{s("attach",o),this.attached=!0,this.resize(),i("resize",n),i("detach",a)};a=()=>{this.attached=!1,s("resize",n),this._stop(),this._resize(0,0),i("attach",o)},e.isAttached(this.canvas)?o():a()}unbindEvents(){each(this._listeners,((t,e)=>{this.platform.removeEventListener(this,e,t)})),this._listeners={},each(this._responsiveListeners,((t,e)=>{this.platform.removeEventListener(this,e,t)})),this._responsiveListeners=void 0}updateHoverStyle(t,e,i){const s=i?"set":"remove";let n,a,o,r;for("dataset"===e&&(n=this.getDatasetMeta(t[0].datasetIndex),n.controller["_"+s+"DatasetHoverStyle"]()),o=0,r=t.length;o<r;++o){a=t[o];const e=a&&this.getDatasetMeta(a.datasetIndex).controller;e&&e[s+"HoverStyle"](a.element,a.datasetIndex,a.index)}}getActiveElements(){return this._active||[]}setActiveElements(t){const e=this._active||[],i=t.map((({datasetIndex:t,index:e})=>{const i=this.getDatasetMeta(t);if(!i)throw new Error("No dataset found at index "+t);return{datasetIndex:t,element:i.data[e],index:e}}));!_elementsEqual(i,e)&&(this._active=i,this._lastEvent=null,this._updateHoverStyles(i,e))}notifyPlugins(t,e,i){return this._plugins.notify(this,t,e,i)}isPluginEnabled(t){return 1===this._plugins._cache.filter((e=>e.plugin.id===t)).length}_updateHoverStyles(t,e,i){const s=this.options.hover,n=(t,e)=>t.filter((t=>!e.some((e=>t.datasetIndex===e.datasetIndex&&t.index===e.index)))),a=n(e,t),o=i?t:n(t,e);a.length&&this.updateHoverStyle(a,s.mode,!1),o.length&&s.mode&&this.updateHoverStyle(o,s.mode,!0)}_eventHandler(t,e){const i={event:t,replay:e,cancelable:!0,inChartArea:this.isPointInArea(t)},s=e=>(e.options.events||this.options.events).includes(t.native.type);if(!1===this.notifyPlugins("beforeEvent",i,s))return;const n=this._handleEvent(t,e,i.inChartArea);return i.cancelable=!1,this.notifyPlugins("afterEvent",i,s),(n||i.changed)&&this.render(),this}_handleEvent(t,e,i){const{_active:s=[],options:n}=this,a=e,o=this._getActiveElements(t,s,i,a),r=_isClickEvent(t),l=determineLastEvent(t,this._lastEvent,i,r);i&&(this._lastEvent=null,callback(n.onHover,[t,o,this],this),r&&callback(n.onClick,[t,o,this],this));const h=!_elementsEqual(o,s);return(h||e)&&(this._active=o,this._updateHoverStyles(o,s,e)),this._lastEvent=l,h}_getActiveElements(t,e,i,s){if("mouseout"===t.type)return[];if(!i)return e;const n=this.options.hover;return this.getElementsAtEventForMode(t,n.mode,n,s)}}function invalidatePlugins(){return each(Chart.instances,(t=>t._plugins.invalidate()))}function clipArc(t,e,i){const{startAngle:s,pixelMargin:n,x:a,y:o,outerRadius:r,innerRadius:l}=e;let h=n/r;t.beginPath(),t.arc(a,o,r,s-h,i+h),l>n?(h=n/l,t.arc(a,o,l,i+h,s-h,!0)):t.arc(a,o,n,i+HALF_PI,s-HALF_PI),t.closePath(),t.clip()}function toRadiusCorners(t){return _readValueToProps(t,["outerStart","outerEnd","innerStart","innerEnd"])}function parseBorderRadius$1(t,e,i,s){const n=toRadiusCorners(t.options.borderRadius),a=(i-e)/2,o=Math.min(a,s*e/2),r=t=>{const e=(i-Math.min(a,t))*s/2;return _limitValue(t,0,Math.min(a,e))};return{outerStart:r(n.outerStart),outerEnd:r(n.outerEnd),innerStart:_limitValue(n.innerStart,0,o),innerEnd:_limitValue(n.innerEnd,0,o)}}function rThetaToXY(t,e,i,s){return{x:i+t*Math.cos(e),y:s+t*Math.sin(e)}}function pathArc(t,e,i,s,n,a){const{x:o,y:r,startAngle:l,pixelMargin:h,innerRadius:c}=e,d=Math.max(e.outerRadius+s+i-h,0),u=c>0?c+s+i+h:0;let g=0;const p=n-l;if(s){const t=((c>0?c-s:0)+(d>0?d-s:0))/2;g=(p-(0!==t?p*t/(t+s):p))/2}const f=(p-Math.max(.001,p*d-i/PI)/d)/2,m=l+f+g,x=n-f-g,{outerStart:b,outerEnd:_,innerStart:y,innerEnd:v}=parseBorderRadius$1(e,u,d,x-m),k=d-b,S=d-_,D=m+b/k,M=x-_/S,P=u+y,w=u+v,C=m+y/P,A=x-v/w;if(t.beginPath(),a){const e=(D+M)/2;if(t.arc(o,r,d,D,e),t.arc(o,r,d,e,M),_>0){const e=rThetaToXY(S,M,o,r);t.arc(e.x,e.y,_,M,x+HALF_PI)}const i=rThetaToXY(w,x,o,r);if(t.lineTo(i.x,i.y),v>0){const e=rThetaToXY(w,A,o,r);t.arc(e.x,e.y,v,x+HALF_PI,A+Math.PI)}const s=(x-v/u+(m+y/u))/2;if(t.arc(o,r,u,x-v/u,s,!0),t.arc(o,r,u,s,m+y/u,!0),y>0){const e=rThetaToXY(P,C,o,r);t.arc(e.x,e.y,y,C+Math.PI,m-HALF_PI)}const n=rThetaToXY(k,m,o,r);if(t.lineTo(n.x,n.y),b>0){const e=rThetaToXY(k,D,o,r);t.arc(e.x,e.y,b,m-HALF_PI,D)}}else{t.moveTo(o,r);const e=Math.cos(D)*d+o,i=Math.sin(D)*d+r;t.lineTo(e,i);const s=Math.cos(M)*d+o,n=Math.sin(M)*d+r;t.lineTo(s,n)}t.closePath()}function drawArc(t,e,i,s,n){const{fullCircles:a,startAngle:o,circumference:r}=e;let l=e.endAngle;if(a){pathArc(t,e,i,s,l,n);for(let e=0;e<a;++e)t.fill();isNaN(r)||(l=o+(r%TAU||TAU))}return pathArc(t,e,i,s,l,n),t.fill(),l}function drawBorder(t,e,i,s,n){const{fullCircles:a,startAngle:o,circumference:r,options:l}=e,{borderWidth:h,borderJoinStyle:c,borderDash:d,borderDashOffset:u}=l,g="inner"===l.borderAlign;if(!h)return;t.setLineDash(d||[]),t.lineDashOffset=u,g?(t.lineWidth=2*h,t.lineJoin=c||"round"):(t.lineWidth=h,t.lineJoin=c||"bevel");let p=e.endAngle;if(a){pathArc(t,e,i,s,p,n);for(let e=0;e<a;++e)t.stroke();isNaN(r)||(p=o+(r%TAU||TAU))}g&&clipArc(t,e,p),a||(pathArc(t,e,i,s,p,n),t.stroke())}class ArcElement extends Element{static id="arc";static defaults={borderAlign:"center",borderColor:"#fff",borderDash:[],borderDashOffset:0,borderJoinStyle:void 0,borderRadius:0,borderWidth:2,offset:0,spacing:0,angle:void 0,circular:!0};static defaultRoutes={backgroundColor:"backgroundColor"};static descriptors={_scriptable:!0,_indexable:t=>"borderDash"!==t};circumference;endAngle;fullCircles;innerRadius;outerRadius;pixelMargin;startAngle;constructor(t){super(),this.options=void 0,this.circumference=void 0,this.startAngle=void 0,this.endAngle=void 0,this.innerRadius=void 0,this.outerRadius=void 0,this.pixelMargin=0,this.fullCircles=0,t&&Object.assign(this,t)}inRange(t,e,i){const s=this.getProps(["x","y"],i),{angle:n,distance:a}=getAngleFromPoint(s,{x:t,y:e}),{startAngle:o,endAngle:r,innerRadius:l,outerRadius:h,circumference:c}=this.getProps(["startAngle","endAngle","innerRadius","outerRadius","circumference"],i),d=(this.options.spacing+this.options.borderWidth)/2,u=valueOrDefault(c,r-o)>=TAU||_angleBetween(n,o,r),g=_isBetween(a,l+d,h+d);return u&&g}getCenterPoint(t){const{x:e,y:i,startAngle:s,endAngle:n,innerRadius:a,outerRadius:o}=this.getProps(["x","y","startAngle","endAngle","innerRadius","outerRadius"],t),{offset:r,spacing:l}=this.options,h=(s+n)/2,c=(a+o+l+r)/2;return{x:e+Math.cos(h)*c,y:i+Math.sin(h)*c}}tooltipPosition(t){return this.getCenterPoint(t)}draw(t){const{options:e,circumference:i}=this,s=(e.offset||0)/4,n=(e.spacing||0)/2,a=e.circular;if(this.pixelMargin="inner"===e.borderAlign?.33:0,this.fullCircles=i>TAU?Math.floor(i/TAU):0,0===i||this.innerRadius<0||this.outerRadius<0)return;t.save();const o=(this.startAngle+this.endAngle)/2;t.translate(Math.cos(o)*s,Math.sin(o)*s);const r=s*(1-Math.sin(Math.min(PI,i||0)));t.fillStyle=e.backgroundColor,t.strokeStyle=e.borderColor,drawArc(t,this,r,n,a),drawBorder(t,this,r,n,a),t.restore()}}function setStyle(t,e,i=e){t.lineCap=valueOrDefault(i.borderCapStyle,e.borderCapStyle),t.setLineDash(valueOrDefault(i.borderDash,e.borderDash)),t.lineDashOffset=valueOrDefault(i.borderDashOffset,e.borderDashOffset),t.lineJoin=valueOrDefault(i.borderJoinStyle,e.borderJoinStyle),t.lineWidth=valueOrDefault(i.borderWidth,e.borderWidth),t.strokeStyle=valueOrDefault(i.borderColor,e.borderColor)}function lineTo(t,e,i){t.lineTo(i.x,i.y)}function getLineMethod(t){return t.stepped?_steppedLineTo:t.tension||"monotone"===t.cubicInterpolationMode?_bezierCurveTo:lineTo}function pathVars(t,e,i={}){const s=t.length,{start:n=0,end:a=s-1}=i,{start:o,end:r}=e,l=Math.max(n,o),h=Math.min(a,r),c=n<o&&a<o||n>r&&a>r;return{count:s,start:l,loop:e.loop,ilen:h<l&&!c?s+h-l:h-l}}function pathSegment(t,e,i,s){const{points:n,options:a}=e,{count:o,start:r,loop:l,ilen:h}=pathVars(n,i,s),c=getLineMethod(a);let d,u,g,{move:p=!0,reverse:f}=s||{};for(d=0;d<=h;++d)u=n[(r+(f?h-d:d))%o],u.skip||(p?(t.moveTo(u.x,u.y),p=!1):c(t,g,u,f,a.stepped),g=u);return l&&(u=n[(r+(f?h:0))%o],c(t,g,u,f,a.stepped)),!!l}function fastPathSegment(t,e,i,s){const n=e.points,{count:a,start:o,ilen:r}=pathVars(n,i,s),{move:l=!0,reverse:h}=s||{};let c,d,u,g,p,f,m=0,x=0;const b=t=>(o+(h?r-t:t))%a,_=()=>{g!==p&&(t.lineTo(m,p),t.lineTo(m,g),t.lineTo(m,f))};for(l&&(d=n[b(0)],t.moveTo(d.x,d.y)),c=0;c<=r;++c){if(d=n[b(c)],d.skip)continue;const e=d.x,i=d.y,s=0|e;s===u?(i<g?g=i:i>p&&(p=i),m=(x*m+e)/++x):(_(),t.lineTo(e,i),u=s,x=0,g=p=i),f=i}_()}function _getSegmentMethod(t){const e=t.options,i=e.borderDash&&e.borderDash.length;return!(t._decimated||t._loop||e.tension||"monotone"===e.cubicInterpolationMode||e.stepped||i)?fastPathSegment:pathSegment}function _getInterpolationMethod(t){return t.stepped?_steppedInterpolation:t.tension||"monotone"===t.cubicInterpolationMode?_bezierInterpolation:_pointInLine}function strokePathWithCache(t,e,i,s){let n=e._path;n||(n=e._path=new Path2D,e.path(n,i,s)&&n.closePath()),setStyle(t,e.options),t.stroke(n)}function strokePathDirect(t,e,i,s){const{segments:n,options:a}=e,o=_getSegmentMethod(e);for(const r of n)setStyle(t,a,r.style),t.beginPath(),o(t,e,r,{start:i,end:i+s-1})&&t.closePath(),t.stroke()}const usePath2D="function"==typeof Path2D;function draw(t,e,i,s){usePath2D&&!e.options.segment?strokePathWithCache(t,e,i,s):strokePathDirect(t,e,i,s)}class LineElement extends Element{static id="line";static defaults={borderCapStyle:"butt",borderDash:[],borderDashOffset:0,borderJoinStyle:"miter",borderWidth:3,capBezierPoints:!0,cubicInterpolationMode:"default",fill:!1,spanGaps:!1,stepped:!1,tension:0};static defaultRoutes={backgroundColor:"backgroundColor",borderColor:"borderColor"};static descriptors={_scriptable:!0,_indexable:t=>"borderDash"!==t&&"fill"!==t};constructor(t){super(),this.animated=!0,this.options=void 0,this._chart=void 0,this._loop=void 0,this._fullLoop=void 0,this._path=void 0,this._points=void 0,this._segments=void 0,this._decimated=!1,this._pointsUpdated=!1,this._datasetIndex=void 0,t&&Object.assign(this,t)}updateControlPoints(t,e){const i=this.options;if((i.tension||"monotone"===i.cubicInterpolationMode)&&!i.stepped&&!this._pointsUpdated){const s=i.spanGaps?this._loop:this._fullLoop;_updateBezierControlPoints(this._points,i,t,s,e),this._pointsUpdated=!0}}set points(t){this._points=t,delete this._segments,delete this._path,this._pointsUpdated=!1}get points(){return this._points}get segments(){return this._segments||(this._segments=_computeSegments(this,this.options.segment))}first(){const t=this.segments,e=this.points;return t.length&&e[t[0].start]}last(){const t=this.segments,e=this.points,i=t.length;return i&&e[t[i-1].end]}interpolate(t,e){const i=this.options,s=t[e],n=this.points,a=_boundSegments(this,{property:e,start:s,end:s});if(!a.length)return;const o=[],r=_getInterpolationMethod(i);let l,h;for(l=0,h=a.length;l<h;++l){const{start:h,end:c}=a[l],d=n[h],u=n[c];if(d===u){o.push(d);continue}const g=r(d,u,Math.abs((s-d[e])/(u[e]-d[e])),i.stepped);g[e]=t[e],o.push(g)}return 1===o.length?o[0]:o}pathSegment(t,e,i){return _getSegmentMethod(this)(t,this,e,i)}path(t,e,i){const s=this.segments,n=_getSegmentMethod(this);let a=this._loop;e=e||0,i=i||this.points.length-e;for(const o of s)a&=n(t,this,o,{start:e,end:e+i-1});return!!a}draw(t,e,i,s){const n=this.options||{};(this.points||[]).length&&n.borderWidth&&(t.save(),draw(t,this,i,s),t.restore()),this.animated&&(this._pointsUpdated=!1,this._path=void 0)}}function inRange$1(t,e,i,s){const n=t.options,{[i]:a}=t.getProps([i],s);return Math.abs(e-a)<n.radius+n.hitRadius}class PointElement extends Element{static id="point";parsed;skip;stop;static defaults={borderWidth:1,hitRadius:1,hoverBorderWidth:1,hoverRadius:4,pointStyle:"circle",radius:3,rotation:0};static defaultRoutes={backgroundColor:"backgroundColor",borderColor:"borderColor"};constructor(t){super(),this.options=void 0,this.parsed=void 0,this.skip=void 0,this.stop=void 0,t&&Object.assign(this,t)}inRange(t,e,i){const s=this.options,{x:n,y:a}=this.getProps(["x","y"],i);return Math.pow(t-n,2)+Math.pow(e-a,2)<Math.pow(s.hitRadius+s.radius,2)}inXRange(t,e){return inRange$1(this,t,"x",e)}inYRange(t,e){return inRange$1(this,t,"y",e)}getCenterPoint(t){const{x:e,y:i}=this.getProps(["x","y"],t);return{x:e,y:i}}size(t){let e=(t=t||this.options||{}).radius||0;e=Math.max(e,e&&t.hoverRadius||0);return 2*(e+(e&&t.borderWidth||0))}draw(t,e){const i=this.options;this.skip||i.radius<.1||!_isPointInArea(this,e,this.size(i)/2)||(t.strokeStyle=i.borderColor,t.lineWidth=i.borderWidth,t.fillStyle=i.backgroundColor,drawPoint(t,i,this.x,this.y))}getRange(){const t=this.options||{};return t.radius+t.hitRadius}}function getBarBounds(t,e){const{x:i,y:s,base:n,width:a,height:o}=t.getProps(["x","y","base","width","height"],e);let r,l,h,c,d;return t.horizontal?(d=o/2,r=Math.min(i,n),l=Math.max(i,n),h=s-d,c=s+d):(d=a/2,r=i-d,l=i+d,h=Math.min(s,n),c=Math.max(s,n)),{left:r,top:h,right:l,bottom:c}}function skipOrLimit(t,e,i,s){return t?0:_limitValue(e,i,s)}function parseBorderWidth(t,e,i){const s=t.options.borderWidth,n=t.borderSkipped,a=toTRBL(s);return{t:skipOrLimit(n.top,a.top,0,i),r:skipOrLimit(n.right,a.right,0,e),b:skipOrLimit(n.bottom,a.bottom,0,i),l:skipOrLimit(n.left,a.left,0,e)}}function parseBorderRadius(t,e,i){const{enableBorderRadius:s}=t.getProps(["enableBorderRadius"]),n=t.options.borderRadius,a=toTRBLCorners(n),o=Math.min(e,i),r=t.borderSkipped,l=s||isObject(n);return{topLeft:skipOrLimit(!l||r.top||r.left,a.topLeft,0,o),topRight:skipOrLimit(!l||r.top||r.right,a.topRight,0,o),bottomLeft:skipOrLimit(!l||r.bottom||r.left,a.bottomLeft,0,o),bottomRight:skipOrLimit(!l||r.bottom||r.right,a.bottomRight,0,o)}}function boundingRects(t){const e=getBarBounds(t),i=e.right-e.left,s=e.bottom-e.top,n=parseBorderWidth(t,i/2,s/2),a=parseBorderRadius(t,i/2,s/2);return{outer:{x:e.left,y:e.top,w:i,h:s,radius:a},inner:{x:e.left+n.l,y:e.top+n.t,w:i-n.l-n.r,h:s-n.t-n.b,radius:{topLeft:Math.max(0,a.topLeft-Math.max(n.t,n.l)),topRight:Math.max(0,a.topRight-Math.max(n.t,n.r)),bottomLeft:Math.max(0,a.bottomLeft-Math.max(n.b,n.l)),bottomRight:Math.max(0,a.bottomRight-Math.max(n.b,n.r))}}}}function inRange(t,e,i,s){const n=null===e,a=null===i,o=t&&!(n&&a)&&getBarBounds(t,s);return o&&(n||_isBetween(e,o.left,o.right))&&(a||_isBetween(i,o.top,o.bottom))}function hasRadius(t){return t.topLeft||t.topRight||t.bottomLeft||t.bottomRight}function addNormalRectPath(t,e){t.rect(e.x,e.y,e.w,e.h)}function inflateRect(t,e,i={}){const s=t.x!==i.x?-e:0,n=t.y!==i.y?-e:0,a=(t.x+t.w!==i.x+i.w?e:0)-s,o=(t.y+t.h!==i.y+i.h?e:0)-n;return{x:t.x+s,y:t.y+n,w:t.w+a,h:t.h+o,radius:t.radius}}class BarElement extends Element{static id="bar";static defaults={borderSkipped:"start",borderWidth:0,borderRadius:0,inflateAmount:"auto",pointStyle:void 0};static defaultRoutes={backgroundColor:"backgroundColor",borderColor:"borderColor"};constructor(t){super(),this.options=void 0,this.horizontal=void 0,this.base=void 0,this.width=void 0,this.height=void 0,this.inflateAmount=void 0,t&&Object.assign(this,t)}draw(t){const{inflateAmount:e,options:{borderColor:i,backgroundColor:s}}=this,{inner:n,outer:a}=boundingRects(this),o=hasRadius(a.radius)?addRoundedRectPath:addNormalRectPath;t.save(),a.w===n.w&&a.h===n.h||(t.beginPath(),o(t,inflateRect(a,e,n)),t.clip(),o(t,inflateRect(n,-e,a)),t.fillStyle=i,t.fill("evenodd")),t.beginPath(),o(t,inflateRect(n,e)),t.fillStyle=s,t.fill(),t.restore()}inRange(t,e,i){return inRange(this,t,e,i)}inXRange(t,e){return inRange(this,t,null,e)}inYRange(t,e){return inRange(this,null,t,e)}getCenterPoint(t){const{x:e,y:i,base:s,horizontal:n}=this.getProps(["x","y","base","horizontal"],t);return{x:n?(e+s)/2:e,y:n?i:(i+s)/2}}getRange(t){return"x"===t?this.width/2:this.height/2}}var elements=Object.freeze({__proto__:null,ArcElement:ArcElement,BarElement:BarElement,LineElement:LineElement,PointElement:PointElement});const BORDER_COLORS=["rgb(54, 162, 235)","rgb(255, 99, 132)","rgb(255, 159, 64)","rgb(255, 205, 86)","rgb(75, 192, 192)","rgb(153, 102, 255)","rgb(201, 203, 207)"],BACKGROUND_COLORS=BORDER_COLORS.map((t=>t.replace("rgb(","rgba(").replace(")",", 0.5)")));function getBorderColor(t){return BORDER_COLORS[t%BORDER_COLORS.length]}function getBackgroundColor(t){return BACKGROUND_COLORS[t%BACKGROUND_COLORS.length]}function colorizeDefaultDataset(t,e){return t.borderColor=getBorderColor(e),t.backgroundColor=getBackgroundColor(e),++e}function colorizeDoughnutDataset(t,e){return t.backgroundColor=t.data.map((()=>getBorderColor(e++))),e}function colorizePolarAreaDataset(t,e){return t.backgroundColor=t.data.map((()=>getBackgroundColor(e++))),e}function getColorizer(t){let e=0;return(i,s)=>{const n=t.getDatasetMeta(s).controller;n instanceof DoughnutController?e=colorizeDoughnutDataset(i,e):n instanceof PolarAreaController?e=colorizePolarAreaDataset(i,e):n&&(e=colorizeDefaultDataset(i,e))}}function containsColorsDefinitions(t){let e;for(e in t)if(t[e].borderColor||t[e].backgroundColor)return!0;return!1}function containsColorsDefinition(t){return t&&(t.borderColor||t.backgroundColor)}var plugin_colors={id:"colors",defaults:{enabled:!0,forceOverride:!1},beforeLayout(t,e,i){if(!i.enabled)return;const{data:{datasets:s},options:n}=t.config,{elements:a}=n;if(!i.forceOverride&&(containsColorsDefinitions(s)||containsColorsDefinition(n)||a&&containsColorsDefinitions(a)))return;const o=getColorizer(t);s.forEach(o)}};function lttbDecimation(t,e,i,s,n){const a=n.samples||s;if(a>=i)return t.slice(e,e+i);const o=[],r=(i-2)/(a-2);let l=0;const h=e+i-1;let c,d,u,g,p,f=e;for(o[l++]=t[f],c=0;c<a-2;c++){let s,n=0,a=0;const h=Math.floor((c+1)*r)+1+e,m=Math.min(Math.floor((c+2)*r)+1,i)+e,x=m-h;for(s=h;s<m;s++)n+=t[s].x,a+=t[s].y;n/=x,a/=x;const b=Math.floor(c*r)+1+e,_=Math.min(Math.floor((c+1)*r)+1,i)+e,{x:y,y:v}=t[f];for(u=g=-1,s=b;s<_;s++)g=.5*Math.abs((y-n)*(t[s].y-v)-(y-t[s].x)*(a-v)),g>u&&(u=g,d=t[s],p=s);o[l++]=d,f=p}return o[l++]=t[h],o}function minMaxDecimation(t,e,i,s){let n,a,o,r,l,h,c,d,u,g,p=0,f=0;const m=[],x=e+i-1,b=t[e].x,_=t[x].x-b;for(n=e;n<e+i;++n){a=t[n],o=(a.x-b)/_*s,r=a.y;const e=0|o;if(e===l)r<u?(u=r,h=n):r>g&&(g=r,c=n),p=(f*p+a.x)/++f;else{const i=n-1;if(!isNullOrUndef(h)&&!isNullOrUndef(c)){const e=Math.min(h,c),s=Math.max(h,c);e!==d&&e!==i&&m.push({...t[e],x:p}),s!==d&&s!==i&&m.push({...t[s],x:p})}n>0&&i!==d&&m.push(t[i]),m.push(a),l=e,f=0,u=g=r,h=c=d=n}}return m}function cleanDecimatedDataset(t){if(t._decimated){const e=t._data;delete t._decimated,delete t._data,Object.defineProperty(t,"data",{configurable:!0,enumerable:!0,writable:!0,value:e})}}function cleanDecimatedData(t){t.data.datasets.forEach((t=>{cleanDecimatedDataset(t)}))}function getStartAndCountOfVisiblePointsSimplified(t,e){const i=e.length;let s,n=0;const{iScale:a}=t,{min:o,max:r,minDefined:l,maxDefined:h}=a.getUserBounds();return l&&(n=_limitValue(_lookupByKey(e,a.axis,o).lo,0,i-1)),s=h?_limitValue(_lookupByKey(e,a.axis,r).hi+1,n,i)-n:i-n,{start:n,count:s}}var plugin_decimation={id:"decimation",defaults:{algorithm:"min-max",enabled:!1},beforeElementsUpdate:(t,e,i)=>{if(!i.enabled)return void cleanDecimatedData(t);const s=t.width;t.data.datasets.forEach(((e,n)=>{const{_data:a,indexAxis:o}=e,r=t.getDatasetMeta(n),l=a||e.data;if("y"===resolve([o,t.options.indexAxis]))return;if(!r.controller.supportsDecimation)return;const h=t.scales[r.xAxisID];if("linear"!==h.type&&"time"!==h.type)return;if(t.options.parsing)return;let{start:c,count:d}=getStartAndCountOfVisiblePointsSimplified(r,l);if(d<=(i.threshold||4*s))return void cleanDecimatedDataset(e);let u;switch(isNullOrUndef(a)&&(e._data=l,delete e.data,Object.defineProperty(e,"data",{configurable:!0,enumerable:!0,get:function(){return this._decimated},set:function(t){this._data=t}})),i.algorithm){case"lttb":u=lttbDecimation(l,c,d,s,i);break;case"min-max":u=minMaxDecimation(l,c,d,s);break;default:throw new Error(`Unsupported decimation algorithm '${i.algorithm}'`)}e._decimated=u}))},destroy(t){cleanDecimatedData(t)}};function _segments(t,e,i){const s=t.segments,n=t.points,a=e.points,o=[];for(const t of s){let{start:s,end:r}=t;r=_findSegmentEnd(s,r,n);const l=_getBounds(i,n[s],n[r],t.loop);if(!e.segments){o.push({source:t,target:l,start:n[s],end:n[r]});continue}const h=_boundSegments(e,l);for(const e of h){const s=_getBounds(i,a[e.start],a[e.end],e.loop),r=_boundSegment(t,n,s);for(const t of r)o.push({source:t,target:e,start:{[i]:_getEdge(l,s,"start",Math.max)},end:{[i]:_getEdge(l,s,"end",Math.min)}})}}return o}function _getBounds(t,e,i,s){if(s)return;let n=e[t],a=i[t];return"angle"===t&&(n=_normalizeAngle(n),a=_normalizeAngle(a)),{property:t,start:n,end:a}}function _pointsFromSegments(t,e){const{x:i=null,y:s=null}=t||{},n=e.points,a=[];return e.segments.forEach((({start:t,end:e})=>{e=_findSegmentEnd(t,e,n);const o=n[t],r=n[e];null!==s?(a.push({x:o.x,y:s}),a.push({x:r.x,y:s})):null!==i&&(a.push({x:i,y:o.y}),a.push({x:i,y:r.y}))})),a}function _findSegmentEnd(t,e,i){for(;e>t;e--){const t=i[e];if(!isNaN(t.x)&&!isNaN(t.y))break}return e}function _getEdge(t,e,i,s){return t&&e?s(t[i],e[i]):t?t[i]:e?e[i]:0}function _createBoundaryLine(t,e){let i=[],s=!1;return isArray(t)?(s=!0,i=t):i=_pointsFromSegments(t,e),i.length?new LineElement({points:i,options:{tension:0},_loop:s,_fullLoop:s}):null}function _shouldApplyFill(t){return t&&!1!==t.fill}function _resolveTarget(t,e,i){let s=t[e].fill;const n=[e];let a;if(!i)return s;for(;!1!==s&&-1===n.indexOf(s);){if(!isNumberFinite(s))return s;if(a=t[s],!a)return!1;if(a.visible)return s;n.push(s),s=a.fill}return!1}function _decodeFill(t,e,i){const s=parseFillOption(t);if(isObject(s))return!isNaN(s.value)&&s;let n=parseFloat(s);return isNumberFinite(n)&&Math.floor(n)===n?decodeTargetIndex(s[0],e,n,i):["origin","start","end","stack","shape"].indexOf(s)>=0&&s}function decodeTargetIndex(t,e,i,s){return"-"!==t&&"+"!==t||(i=e+i),!(i===e||i<0||i>=s)&&i}function _getTargetPixel(t,e){let i=null;return"start"===t?i=e.bottom:"end"===t?i=e.top:isObject(t)?i=e.getPixelForValue(t.value):e.getBasePixel&&(i=e.getBasePixel()),i}function _getTargetValue(t,e,i){let s;return s="start"===t?i:"end"===t?e.options.reverse?e.min:e.max:isObject(t)?t.value:e.getBaseValue(),s}function parseFillOption(t){const e=t.options,i=e.fill;let s=valueOrDefault(i&&i.target,i);return void 0===s&&(s=!!e.backgroundColor),!1!==s&&null!==s&&(!0===s?"origin":s)}function _buildStackLine(t){const{scale:e,index:i,line:s}=t,n=[],a=s.segments,o=s.points,r=getLinesBelow(e,i);r.push(_createBoundaryLine({x:null,y:e.bottom},s));for(let t=0;t<a.length;t++){const e=a[t];for(let t=e.start;t<=e.end;t++)addPointsBelow(n,o[t],r)}return new LineElement({points:n,options:{}})}function getLinesBelow(t,e){const i=[],s=t.getMatchingVisibleMetas("line");for(let t=0;t<s.length;t++){const n=s[t];if(n.index===e)break;n.hidden||i.unshift(n.dataset)}return i}function addPointsBelow(t,e,i){const s=[];for(let n=0;n<i.length;n++){const a=i[n],{first:o,last:r,point:l}=findPoint(a,e,"x");if(!(!l||o&&r))if(o)s.unshift(l);else if(t.push(l),!r)break}t.push(...s)}function findPoint(t,e,i){const s=t.interpolate(e,i);if(!s)return{};const n=s[i],a=t.segments,o=t.points;let r=!1,l=!1;for(let t=0;t<a.length;t++){const e=a[t],s=o[e.start][i],h=o[e.end][i];if(_isBetween(n,s,h)){r=n===s,l=n===h;break}}return{first:r,last:l,point:s}}class simpleArc{constructor(t){this.x=t.x,this.y=t.y,this.radius=t.radius}pathSegment(t,e,i){const{x:s,y:n,radius:a}=this;return e=e||{start:0,end:TAU},t.arc(s,n,a,e.end,e.start,!0),!i.bounds}interpolate(t){const{x:e,y:i,radius:s}=this,n=t.angle;return{x:e+Math.cos(n)*s,y:i+Math.sin(n)*s,angle:n}}}function _getTarget(t){const{chart:e,fill:i,line:s}=t;if(isNumberFinite(i))return getLineByIndex(e,i);if("stack"===i)return _buildStackLine(t);if("shape"===i)return!0;const n=computeBoundary(t);return n instanceof simpleArc?n:_createBoundaryLine(n,s)}function getLineByIndex(t,e){const i=t.getDatasetMeta(e);return i&&t.isDatasetVisible(e)?i.dataset:null}function computeBoundary(t){return(t.scale||{}).getPointPositionForValue?computeCircularBoundary(t):computeLinearBoundary(t)}function computeLinearBoundary(t){const{scale:e={},fill:i}=t,s=_getTargetPixel(i,e);if(isNumberFinite(s)){const t=e.isHorizontal();return{x:t?s:null,y:t?null:s}}return null}function computeCircularBoundary(t){const{scale:e,fill:i}=t,s=e.options,n=e.getLabels().length,a=s.reverse?e.max:e.min,o=_getTargetValue(i,e,a),r=[];if(s.grid.circular){const t=e.getPointPositionForValue(0,a);return new simpleArc({x:t.x,y:t.y,radius:e.getDistanceFromCenterForValue(o)})}for(let t=0;t<n;++t)r.push(e.getPointPositionForValue(t,o));return r}function _drawfill(t,e,i){const s=_getTarget(e),{line:n,scale:a,axis:o}=e,r=n.options,l=r.fill,h=r.backgroundColor,{above:c=h,below:d=h}=l||{};s&&n.points.length&&(clipArea(t,i),doFill(t,{line:n,target:s,above:c,below:d,area:i,scale:a,axis:o}),unclipArea(t))}function doFill(t,e){const{line:i,target:s,above:n,below:a,area:o,scale:r}=e,l=i._loop?"angle":e.axis;t.save(),"x"===l&&a!==n&&(clipVertical(t,s,o.top),fill(t,{line:i,target:s,color:n,scale:r,property:l}),t.restore(),t.save(),clipVertical(t,s,o.bottom)),fill(t,{line:i,target:s,color:a,scale:r,property:l}),t.restore()}function clipVertical(t,e,i){const{segments:s,points:n}=e;let a=!0,o=!1;t.beginPath();for(const r of s){const{start:s,end:l}=r,h=n[s],c=n[_findSegmentEnd(s,l,n)];a?(t.moveTo(h.x,h.y),a=!1):(t.lineTo(h.x,i),t.lineTo(h.x,h.y)),o=!!e.pathSegment(t,r,{move:o}),o?t.closePath():t.lineTo(c.x,i)}t.lineTo(e.first().x,i),t.closePath(),t.clip()}function fill(t,e){const{line:i,target:s,property:n,color:a,scale:o}=e,r=_segments(i,s,n);for(const{source:e,target:l,start:h,end:c}of r){const{style:{backgroundColor:r=a}={}}=e,d=!0!==s;t.save(),t.fillStyle=r,clipBounds(t,o,d&&_getBounds(n,h,c)),t.beginPath();const u=!!i.pathSegment(t,e);let g;if(d){u?t.closePath():interpolatedLineTo(t,s,c,n);const e=!!s.pathSegment(t,l,{move:u,reverse:!0});g=u&&e,g||interpolatedLineTo(t,s,h,n)}t.closePath(),t.fill(g?"evenodd":"nonzero"),t.restore()}}function clipBounds(t,e,i){const{top:s,bottom:n}=e.chart.chartArea,{property:a,start:o,end:r}=i||{};"x"===a&&(t.beginPath(),t.rect(o,s,r-o,n-s),t.clip())}function interpolatedLineTo(t,e,i,s){const n=e.interpolate(i,s);n&&t.lineTo(n.x,n.y)}var index={id:"filler",afterDatasetsUpdate(t,e,i){const s=(t.data.datasets||[]).length,n=[];let a,o,r,l;for(o=0;o<s;++o)a=t.getDatasetMeta(o),r=a.dataset,l=null,r&&r.options&&r instanceof LineElement&&(l={visible:t.isDatasetVisible(o),index:o,fill:_decodeFill(r,o,s),chart:t,axis:a.controller.options.indexAxis,scale:a.vScale,line:r}),a.$filler=l,n.push(l);for(o=0;o<s;++o)l=n[o],l&&!1!==l.fill&&(l.fill=_resolveTarget(n,o,i.propagate))},beforeDraw(t,e,i){const s="beforeDraw"===i.drawTime,n=t.getSortedVisibleDatasetMetas(),a=t.chartArea;for(let e=n.length-1;e>=0;--e){const i=n[e].$filler;i&&(i.line.updateControlPoints(a,i.axis),s&&i.fill&&_drawfill(t.ctx,i,a))}},beforeDatasetsDraw(t,e,i){if("beforeDatasetsDraw"!==i.drawTime)return;const s=t.getSortedVisibleDatasetMetas();for(let e=s.length-1;e>=0;--e){const i=s[e].$filler;_shouldApplyFill(i)&&_drawfill(t.ctx,i,t.chartArea)}},beforeDatasetDraw(t,e,i){const s=e.meta.$filler;_shouldApplyFill(s)&&"beforeDatasetDraw"===i.drawTime&&_drawfill(t.ctx,s,t.chartArea)},defaults:{propagate:!0,drawTime:"beforeDatasetDraw"}};const getBoxSize=(t,e)=>{let{boxHeight:i=e,boxWidth:s=e}=t;return t.usePointStyle&&(i=Math.min(i,e),s=t.pointStyleWidth||Math.min(s,e)),{boxWidth:s,boxHeight:i,itemHeight:Math.max(e,i)}},itemsEqual=(t,e)=>null!==t&&null!==e&&t.datasetIndex===e.datasetIndex&&t.index===e.index;class Legend extends Element{constructor(t){super(),this._added=!1,this.legendHitBoxes=[],this._hoveredItem=null,this.doughnutMode=!1,this.chart=t.chart,this.options=t.options,this.ctx=t.ctx,this.legendItems=void 0,this.columnSizes=void 0,this.lineWidths=void 0,this.maxHeight=void 0,this.maxWidth=void 0,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.height=void 0,this.width=void 0,this._margins=void 0,this.position=void 0,this.weight=void 0,this.fullSize=void 0}update(t,e,i){this.maxWidth=t,this.maxHeight=e,this._margins=i,this.setDimensions(),this.buildLabels(),this.fit()}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=this._margins.left,this.right=this.width):(this.height=this.maxHeight,this.top=this._margins.top,this.bottom=this.height)}buildLabels(){const t=this.options.labels||{};let e=callback(t.generateLabels,[this.chart],this)||[];t.filter&&(e=e.filter((e=>t.filter(e,this.chart.data)))),t.sort&&(e=e.sort(((e,i)=>t.sort(e,i,this.chart.data)))),this.options.reverse&&e.reverse(),this.legendItems=e}fit(){const{options:t,ctx:e}=this;if(!t.display)return void(this.width=this.height=0);const i=t.labels,s=toFont(i.font),n=s.size,a=this._computeTitleHeight(),{boxWidth:o,itemHeight:r}=getBoxSize(i,n);let l,h;e.font=s.string,this.isHorizontal()?(l=this.maxWidth,h=this._fitRows(a,n,o,r)+10):(h=this.maxHeight,l=this._fitCols(a,s,o,r)+10),this.width=Math.min(l,t.maxWidth||this.maxWidth),this.height=Math.min(h,t.maxHeight||this.maxHeight)}_fitRows(t,e,i,s){const{ctx:n,maxWidth:a,options:{labels:{padding:o}}}=this,r=this.legendHitBoxes=[],l=this.lineWidths=[0],h=s+o;let c=t;n.textAlign="left",n.textBaseline="middle";let d=-1,u=-h;return this.legendItems.forEach(((t,g)=>{const p=i+e/2+n.measureText(t.text).width;(0===g||l[l.length-1]+p+2*o>a)&&(c+=h,l[l.length-(g>0?0:1)]=0,u+=h,d++),r[g]={left:0,top:u,row:d,width:p,height:s},l[l.length-1]+=p+o})),c}_fitCols(t,e,i,s){const{ctx:n,maxHeight:a,options:{labels:{padding:o}}}=this,r=this.legendHitBoxes=[],l=this.columnSizes=[],h=a-t;let c=o,d=0,u=0,g=0,p=0;return this.legendItems.forEach(((t,a)=>{const{itemWidth:f,itemHeight:m}=calculateItemSize(i,e,n,t,s);a>0&&u+m+2*o>h&&(c+=d+o,l.push({width:d,height:u}),g+=d+o,p++,d=u=0),r[a]={left:g,top:u,col:p,width:f,height:m},d=Math.max(d,f),u+=m+o})),c+=d,l.push({width:d,height:u}),c}adjustHitBoxes(){if(!this.options.display)return;const t=this._computeTitleHeight(),{legendHitBoxes:e,options:{align:i,labels:{padding:s},rtl:n}}=this,a=getRtlAdapter(n,this.left,this.width);if(this.isHorizontal()){let n=0,o=_alignStartEnd(i,this.left+s,this.right-this.lineWidths[n]);for(const r of e)n!==r.row&&(n=r.row,o=_alignStartEnd(i,this.left+s,this.right-this.lineWidths[n])),r.top+=this.top+t+s,r.left=a.leftForLtr(a.x(o),r.width),o+=r.width+s}else{let n=0,o=_alignStartEnd(i,this.top+t+s,this.bottom-this.columnSizes[n].height);for(const r of e)r.col!==n&&(n=r.col,o=_alignStartEnd(i,this.top+t+s,this.bottom-this.columnSizes[n].height)),r.top=o,r.left+=this.left+s,r.left=a.leftForLtr(a.x(r.left),r.width),o+=r.height+s}}isHorizontal(){return"top"===this.options.position||"bottom"===this.options.position}draw(){if(this.options.display){const t=this.ctx;clipArea(t,this),this._draw(),unclipArea(t)}}_draw(){const{options:t,columnSizes:e,lineWidths:i,ctx:s}=this,{align:n,labels:a}=t,o=defaults.color,r=getRtlAdapter(t.rtl,this.left,this.width),l=toFont(a.font),{padding:h}=a,c=l.size,d=c/2;let u;this.drawTitle(),s.textAlign=r.textAlign("left"),s.textBaseline="middle",s.lineWidth=.5,s.font=l.string;const{boxWidth:g,boxHeight:p,itemHeight:f}=getBoxSize(a,c),m=this.isHorizontal(),x=this._computeTitleHeight();u=m?{x:_alignStartEnd(n,this.left+h,this.right-i[0]),y:this.top+h+x,line:0}:{x:this.left+h,y:_alignStartEnd(n,this.top+x+h,this.bottom-e[0].height),line:0},overrideTextDirection(this.ctx,t.textDirection);const b=f+h;this.legendItems.forEach(((_,y)=>{s.strokeStyle=_.fontColor,s.fillStyle=_.fontColor;const v=s.measureText(_.text).width,k=r.textAlign(_.textAlign||(_.textAlign=a.textAlign)),S=g+d+v;let D=u.x,M=u.y;r.setWidth(this.width),m?y>0&&D+S+h>this.right&&(M=u.y+=b,u.line++,D=u.x=_alignStartEnd(n,this.left+h,this.right-i[u.line])):y>0&&M+b>this.bottom&&(D=u.x=D+e[u.line].width+h,u.line++,M=u.y=_alignStartEnd(n,this.top+x+h,this.bottom-e[u.line].height));if(function(t,e,i){if(isNaN(g)||g<=0||isNaN(p)||p<0)return;s.save();const n=valueOrDefault(i.lineWidth,1);if(s.fillStyle=valueOrDefault(i.fillStyle,o),s.lineCap=valueOrDefault(i.lineCap,"butt"),s.lineDashOffset=valueOrDefault(i.lineDashOffset,0),s.lineJoin=valueOrDefault(i.lineJoin,"miter"),s.lineWidth=n,s.strokeStyle=valueOrDefault(i.strokeStyle,o),s.setLineDash(valueOrDefault(i.lineDash,[])),a.usePointStyle){const o={radius:p*Math.SQRT2/2,pointStyle:i.pointStyle,rotation:i.rotation,borderWidth:n},l=r.xPlus(t,g/2);drawPointLegend(s,o,l,e+d,a.pointStyleWidth&&g)}else{const a=e+Math.max((c-p)/2,0),o=r.leftForLtr(t,g),l=toTRBLCorners(i.borderRadius);s.beginPath(),Object.values(l).some((t=>0!==t))?addRoundedRectPath(s,{x:o,y:a,w:g,h:p,radius:l}):s.rect(o,a,g,p),s.fill(),0!==n&&s.stroke()}s.restore()}(r.x(D),M,_),D=_textX(k,D+g+d,m?D+S:this.right,t.rtl),function(t,e,i){renderText(s,i.text,t,e+f/2,l,{strikethrough:i.hidden,textAlign:r.textAlign(i.textAlign)})}(r.x(D),M,_),m)u.x+=S+h;else if("string"!=typeof _.text){const t=l.lineHeight;u.y+=calculateLegendItemHeight(_,t)+h}else u.y+=b})),restoreTextDirection(this.ctx,t.textDirection)}drawTitle(){const t=this.options,e=t.title,i=toFont(e.font),s=toPadding(e.padding);if(!e.display)return;const n=getRtlAdapter(t.rtl,this.left,this.width),a=this.ctx,o=e.position,r=i.size/2,l=s.top+r;let h,c=this.left,d=this.width;if(this.isHorizontal())d=Math.max(...this.lineWidths),h=this.top+l,c=_alignStartEnd(t.align,c,this.right-d);else{const e=this.columnSizes.reduce(((t,e)=>Math.max(t,e.height)),0);h=l+_alignStartEnd(t.align,this.top,this.bottom-e-t.labels.padding-this._computeTitleHeight())}const u=_alignStartEnd(o,c,c+d);a.textAlign=n.textAlign(_toLeftRightCenter(o)),a.textBaseline="middle",a.strokeStyle=e.color,a.fillStyle=e.color,a.font=i.string,renderText(a,e.text,u,h,i)}_computeTitleHeight(){const t=this.options.title,e=toFont(t.font),i=toPadding(t.padding);return t.display?e.lineHeight+i.height:0}_getLegendItemAt(t,e){let i,s,n;if(_isBetween(t,this.left,this.right)&&_isBetween(e,this.top,this.bottom))for(n=this.legendHitBoxes,i=0;i<n.length;++i)if(s=n[i],_isBetween(t,s.left,s.left+s.width)&&_isBetween(e,s.top,s.top+s.height))return this.legendItems[i];return null}handleEvent(t){const e=this.options;if(!isListened(t.type,e))return;const i=this._getLegendItemAt(t.x,t.y);if("mousemove"===t.type||"mouseout"===t.type){const a=this._hoveredItem,o=(n=i,null!==(s=a)&&null!==n&&s.datasetIndex===n.datasetIndex&&s.index===n.index);a&&!o&&callback(e.onLeave,[t,a,this],this),this._hoveredItem=i,i&&!o&&callback(e.onHover,[t,i,this],this)}else i&&callback(e.onClick,[t,i,this],this);var s,n}}function calculateItemSize(t,e,i,s,n){return{itemWidth:calculateItemWidth(s,t,e,i),itemHeight:calculateItemHeight(n,s,e.lineHeight)}}function calculateItemWidth(t,e,i,s){let n=t.text;return n&&"string"!=typeof n&&(n=n.reduce(((t,e)=>t.length>e.length?t:e))),e+i.size/2+s.measureText(n).width}function calculateItemHeight(t,e,i){let s=t;return"string"!=typeof e.text&&(s=calculateLegendItemHeight(e,i)),s}function calculateLegendItemHeight(t,e){return e*(t.text?t.text.length:0)}function isListened(t,e){return!("mousemove"!==t&&"mouseout"!==t||!e.onHover&&!e.onLeave)||!(!e.onClick||"click"!==t&&"mouseup"!==t)}var plugin_legend={id:"legend",_element:Legend,start(t,e,i){const s=t.legend=new Legend({ctx:t.ctx,options:i,chart:t});layouts.configure(t,s,i),layouts.addBox(t,s)},stop(t){layouts.removeBox(t,t.legend),delete t.legend},beforeUpdate(t,e,i){const s=t.legend;layouts.configure(t,s,i),s.options=i},afterUpdate(t){const e=t.legend;e.buildLabels(),e.adjustHitBoxes()},afterEvent(t,e){e.replay||t.legend.handleEvent(e.event)},defaults:{display:!0,position:"top",align:"center",fullSize:!0,reverse:!1,weight:1e3,onClick(t,e,i){const s=e.datasetIndex,n=i.chart;n.isDatasetVisible(s)?(n.hide(s),e.hidden=!0):(n.show(s),e.hidden=!1)},onHover:null,onLeave:null,labels:{color:t=>t.chart.options.color,boxWidth:40,padding:10,generateLabels(t){const e=t.data.datasets,{labels:{usePointStyle:i,pointStyle:s,textAlign:n,color:a,useBorderRadius:o,borderRadius:r}}=t.legend.options;return t._getSortedDatasetMetas().map((t=>{const l=t.controller.getStyle(i?0:void 0),h=toPadding(l.borderWidth);return{text:e[t.index].label,fillStyle:l.backgroundColor,fontColor:a,hidden:!t.visible,lineCap:l.borderCapStyle,lineDash:l.borderDash,lineDashOffset:l.borderDashOffset,lineJoin:l.borderJoinStyle,lineWidth:(h.width+h.height)/4,strokeStyle:l.borderColor,pointStyle:s||l.pointStyle,rotation:l.rotation,textAlign:n||l.textAlign,borderRadius:o&&(r||l.borderRadius),datasetIndex:t.index}}),this)}},title:{color:t=>t.chart.options.color,display:!1,position:"center",text:""}},descriptors:{_scriptable:t=>!t.startsWith("on"),labels:{_scriptable:t=>!["generateLabels","filter","sort"].includes(t)}}};class Title extends Element{constructor(t){super(),this.chart=t.chart,this.options=t.options,this.ctx=t.ctx,this._padding=void 0,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.width=void 0,this.height=void 0,this.position=void 0,this.weight=void 0,this.fullSize=void 0}update(t,e){const i=this.options;if(this.left=0,this.top=0,!i.display)return void(this.width=this.height=this.right=this.bottom=0);this.width=this.right=t,this.height=this.bottom=e;const s=isArray(i.text)?i.text.length:1;this._padding=toPadding(i.padding);const n=s*toFont(i.font).lineHeight+this._padding.height;this.isHorizontal()?this.height=n:this.width=n}isHorizontal(){const t=this.options.position;return"top"===t||"bottom"===t}_drawArgs(t){const{top:e,left:i,bottom:s,right:n,options:a}=this,o=a.align;let r,l,h,c=0;return this.isHorizontal()?(l=_alignStartEnd(o,i,n),h=e+t,r=n-i):("left"===a.position?(l=i+t,h=_alignStartEnd(o,s,e),c=-.5*PI):(l=n-t,h=_alignStartEnd(o,e,s),c=.5*PI),r=s-e),{titleX:l,titleY:h,maxWidth:r,rotation:c}}draw(){const t=this.ctx,e=this.options;if(!e.display)return;const i=toFont(e.font),s=i.lineHeight/2+this._padding.top,{titleX:n,titleY:a,maxWidth:o,rotation:r}=this._drawArgs(s);renderText(t,e.text,0,0,i,{color:e.color,maxWidth:o,rotation:r,textAlign:_toLeftRightCenter(e.align),textBaseline:"middle",translation:[n,a]})}}function createTitle(t,e){const i=new Title({ctx:t.ctx,options:e,chart:t});layouts.configure(t,i,e),layouts.addBox(t,i),t.titleBlock=i}var plugin_title={id:"title",_element:Title,start(t,e,i){createTitle(t,i)},stop(t){const e=t.titleBlock;layouts.removeBox(t,e),delete t.titleBlock},beforeUpdate(t,e,i){const s=t.titleBlock;layouts.configure(t,s,i),s.options=i},defaults:{align:"center",display:!1,font:{weight:"bold"},fullSize:!0,padding:10,position:"top",text:"",weight:2e3},defaultRoutes:{color:"color"},descriptors:{_scriptable:!0,_indexable:!1}};const map=new WeakMap;var plugin_subtitle={id:"subtitle",start(t,e,i){const s=new Title({ctx:t.ctx,options:i,chart:t});layouts.configure(t,s,i),layouts.addBox(t,s),map.set(t,s)},stop(t){layouts.removeBox(t,map.get(t)),map.delete(t)},beforeUpdate(t,e,i){const s=map.get(t);layouts.configure(t,s,i),s.options=i},defaults:{align:"center",display:!1,font:{weight:"normal"},fullSize:!0,padding:0,position:"top",text:"",weight:1500},defaultRoutes:{color:"color"},descriptors:{_scriptable:!0,_indexable:!1}};const positioners={average(t){if(!t.length)return!1;let e,i,s=0,n=0,a=0;for(e=0,i=t.length;e<i;++e){const i=t[e].element;if(i&&i.hasValue()){const t=i.tooltipPosition();s+=t.x,n+=t.y,++a}}return{x:s/a,y:n/a}},nearest(t,e){if(!t.length)return!1;let i,s,n,a=e.x,o=e.y,r=Number.POSITIVE_INFINITY;for(i=0,s=t.length;i<s;++i){const s=t[i].element;if(s&&s.hasValue()){const t=s.getCenterPoint(),i=distanceBetweenPoints(e,t);i<r&&(r=i,n=s)}}if(n){const t=n.tooltipPosition();a=t.x,o=t.y}return{x:a,y:o}}};function pushOrConcat(t,e){return e&&(isArray(e)?Array.prototype.push.apply(t,e):t.push(e)),t}function splitNewlines(t){return("string"==typeof t||t instanceof String)&&t.indexOf("\n")>-1?t.split("\n"):t}function createTooltipItem(t,e){const{element:i,datasetIndex:s,index:n}=e,a=t.getDatasetMeta(s).controller,{label:o,value:r}=a.getLabelAndValue(n);return{chart:t,label:o,parsed:a.getParsed(n),raw:t.data.datasets[s].data[n],formattedValue:r,dataset:a.getDataset(),dataIndex:n,datasetIndex:s,element:i}}function getTooltipSize(t,e){const i=t.chart.ctx,{body:s,footer:n,title:a}=t,{boxWidth:o,boxHeight:r}=e,l=toFont(e.bodyFont),h=toFont(e.titleFont),c=toFont(e.footerFont),d=a.length,u=n.length,g=s.length,p=toPadding(e.padding);let f=p.height,m=0,x=s.reduce(((t,e)=>t+e.before.length+e.lines.length+e.after.length),0);if(x+=t.beforeBody.length+t.afterBody.length,d&&(f+=d*h.lineHeight+(d-1)*e.titleSpacing+e.titleMarginBottom),x){f+=g*(e.displayColors?Math.max(r,l.lineHeight):l.lineHeight)+(x-g)*l.lineHeight+(x-1)*e.bodySpacing}u&&(f+=e.footerMarginTop+u*c.lineHeight+(u-1)*e.footerSpacing);let b=0;const _=function(t){m=Math.max(m,i.measureText(t).width+b)};return i.save(),i.font=h.string,each(t.title,_),i.font=l.string,each(t.beforeBody.concat(t.afterBody),_),b=e.displayColors?o+2+e.boxPadding:0,each(s,(t=>{each(t.before,_),each(t.lines,_),each(t.after,_)})),b=0,i.font=c.string,each(t.footer,_),i.restore(),m+=p.width,{width:m,height:f}}function determineYAlign(t,e){const{y:i,height:s}=e;return i<s/2?"top":i>t.height-s/2?"bottom":"center"}function doesNotFitWithAlign(t,e,i,s){const{x:n,width:a}=s,o=i.caretSize+i.caretPadding;return"left"===t&&n+a+o>e.width||("right"===t&&n-a-o<0||void 0)}function determineXAlign(t,e,i,s){const{x:n,width:a}=i,{width:o,chartArea:{left:r,right:l}}=t;let h="center";return"center"===s?h=n<=(r+l)/2?"left":"right":n<=a/2?h="left":n>=o-a/2&&(h="right"),doesNotFitWithAlign(h,t,e,i)&&(h="center"),h}function determineAlignment(t,e,i){const s=i.yAlign||e.yAlign||determineYAlign(t,i);return{xAlign:i.xAlign||e.xAlign||determineXAlign(t,e,i,s),yAlign:s}}function alignX(t,e){let{x:i,width:s}=t;return"right"===e?i-=s:"center"===e&&(i-=s/2),i}function alignY(t,e,i){let{y:s,height:n}=t;return"top"===e?s+=i:s-="bottom"===e?n+i:n/2,s}function getBackgroundPoint(t,e,i,s){const{caretSize:n,caretPadding:a,cornerRadius:o}=t,{xAlign:r,yAlign:l}=i,h=n+a,{topLeft:c,topRight:d,bottomLeft:u,bottomRight:g}=toTRBLCorners(o);let p=alignX(e,r);const f=alignY(e,l,h);return"center"===l?"left"===r?p+=h:"right"===r&&(p-=h):"left"===r?p-=Math.max(c,u)+n:"right"===r&&(p+=Math.max(d,g)+n),{x:_limitValue(p,0,s.width-e.width),y:_limitValue(f,0,s.height-e.height)}}function getAlignedX(t,e,i){const s=toPadding(i.padding);return"center"===e?t.x+t.width/2:"right"===e?t.x+t.width-s.right:t.x+s.left}function getBeforeAfterBodyLines(t){return pushOrConcat([],splitNewlines(t))}function createTooltipContext(t,e,i){return createContext(t,{tooltip:e,tooltipItems:i,type:"tooltip"})}function overrideCallbacks(t,e){const i=e&&e.dataset&&e.dataset.tooltip&&e.dataset.tooltip.callbacks;return i?t.override(i):t}const defaultCallbacks={beforeTitle:noop,title(t){if(t.length>0){const e=t[0],i=e.chart.data.labels,s=i?i.length:0;if(this&&this.options&&"dataset"===this.options.mode)return e.dataset.label||"";if(e.label)return e.label;if(s>0&&e.dataIndex<s)return i[e.dataIndex]}return""},afterTitle:noop,beforeBody:noop,beforeLabel:noop,label(t){if(this&&this.options&&"dataset"===this.options.mode)return t.label+": "+t.formattedValue||t.formattedValue;let e=t.dataset.label||"";e&&(e+=": ");const i=t.formattedValue;return isNullOrUndef(i)||(e+=i),e},labelColor(t){const e=t.chart.getDatasetMeta(t.datasetIndex).controller.getStyle(t.dataIndex);return{borderColor:e.borderColor,backgroundColor:e.backgroundColor,borderWidth:e.borderWidth,borderDash:e.borderDash,borderDashOffset:e.borderDashOffset,borderRadius:0}},labelTextColor(){return this.options.bodyColor},labelPointStyle(t){const e=t.chart.getDatasetMeta(t.datasetIndex).controller.getStyle(t.dataIndex);return{pointStyle:e.pointStyle,rotation:e.rotation}},afterLabel:noop,afterBody:noop,beforeFooter:noop,footer:noop,afterFooter:noop};function invokeCallbackWithFallback(t,e,i,s){const n=t[e].call(i,s);return void 0===n?defaultCallbacks[e].call(i,s):n}class Tooltip extends Element{static positioners=positioners;constructor(t){super(),this.opacity=0,this._active=[],this._eventPosition=void 0,this._size=void 0,this._cachedAnimations=void 0,this._tooltipItems=[],this.$animations=void 0,this.$context=void 0,this.chart=t.chart,this.options=t.options,this.dataPoints=void 0,this.title=void 0,this.beforeBody=void 0,this.body=void 0,this.afterBody=void 0,this.footer=void 0,this.xAlign=void 0,this.yAlign=void 0,this.x=void 0,this.y=void 0,this.height=void 0,this.width=void 0,this.caretX=void 0,this.caretY=void 0,this.labelColors=void 0,this.labelPointStyles=void 0,this.labelTextColors=void 0}initialize(t){this.options=t,this._cachedAnimations=void 0,this.$context=void 0}_resolveAnimations(){const t=this._cachedAnimations;if(t)return t;const e=this.chart,i=this.options.setContext(this.getContext()),s=i.enabled&&e.options.animation&&i.animations,n=new Animations(this.chart,s);return s._cacheable&&(this._cachedAnimations=Object.freeze(n)),n}getContext(){return this.$context||(this.$context=createTooltipContext(this.chart.getContext(),this,this._tooltipItems))}getTitle(t,e){const{callbacks:i}=e,s=invokeCallbackWithFallback(i,"beforeTitle",this,t),n=invokeCallbackWithFallback(i,"title",this,t),a=invokeCallbackWithFallback(i,"afterTitle",this,t);let o=[];return o=pushOrConcat(o,splitNewlines(s)),o=pushOrConcat(o,splitNewlines(n)),o=pushOrConcat(o,splitNewlines(a)),o}getBeforeBody(t,e){return getBeforeAfterBodyLines(invokeCallbackWithFallback(e.callbacks,"beforeBody",this,t))}getBody(t,e){const{callbacks:i}=e,s=[];return each(t,(t=>{const e={before:[],lines:[],after:[]},n=overrideCallbacks(i,t);pushOrConcat(e.before,splitNewlines(invokeCallbackWithFallback(n,"beforeLabel",this,t))),pushOrConcat(e.lines,invokeCallbackWithFallback(n,"label",this,t)),pushOrConcat(e.after,splitNewlines(invokeCallbackWithFallback(n,"afterLabel",this,t))),s.push(e)})),s}getAfterBody(t,e){return getBeforeAfterBodyLines(invokeCallbackWithFallback(e.callbacks,"afterBody",this,t))}getFooter(t,e){const{callbacks:i}=e,s=invokeCallbackWithFallback(i,"beforeFooter",this,t),n=invokeCallbackWithFallback(i,"footer",this,t),a=invokeCallbackWithFallback(i,"afterFooter",this,t);let o=[];return o=pushOrConcat(o,splitNewlines(s)),o=pushOrConcat(o,splitNewlines(n)),o=pushOrConcat(o,splitNewlines(a)),o}_createItems(t){const e=this._active,i=this.chart.data,s=[],n=[],a=[];let o,r,l=[];for(o=0,r=e.length;o<r;++o)l.push(createTooltipItem(this.chart,e[o]));return t.filter&&(l=l.filter(((e,s,n)=>t.filter(e,s,n,i)))),t.itemSort&&(l=l.sort(((e,s)=>t.itemSort(e,s,i)))),each(l,(e=>{const i=overrideCallbacks(t.callbacks,e);s.push(invokeCallbackWithFallback(i,"labelColor",this,e)),n.push(invokeCallbackWithFallback(i,"labelPointStyle",this,e)),a.push(invokeCallbackWithFallback(i,"labelTextColor",this,e))})),this.labelColors=s,this.labelPointStyles=n,this.labelTextColors=a,this.dataPoints=l,l}update(t,e){const i=this.options.setContext(this.getContext()),s=this._active;let n,a=[];if(s.length){const t=positioners[i.position].call(this,s,this._eventPosition);a=this._createItems(i),this.title=this.getTitle(a,i),this.beforeBody=this.getBeforeBody(a,i),this.body=this.getBody(a,i),this.afterBody=this.getAfterBody(a,i),this.footer=this.getFooter(a,i);const e=this._size=getTooltipSize(this,i),o=Object.assign({},t,e),r=determineAlignment(this.chart,i,o),l=getBackgroundPoint(i,o,r,this.chart);this.xAlign=r.xAlign,this.yAlign=r.yAlign,n={opacity:1,x:l.x,y:l.y,width:e.width,height:e.height,caretX:t.x,caretY:t.y}}else 0!==this.opacity&&(n={opacity:0});this._tooltipItems=a,this.$context=void 0,n&&this._resolveAnimations().update(this,n),t&&i.external&&i.external.call(this,{chart:this.chart,tooltip:this,replay:e})}drawCaret(t,e,i,s){const n=this.getCaretPosition(t,i,s);e.lineTo(n.x1,n.y1),e.lineTo(n.x2,n.y2),e.lineTo(n.x3,n.y3)}getCaretPosition(t,e,i){const{xAlign:s,yAlign:n}=this,{caretSize:a,cornerRadius:o}=i,{topLeft:r,topRight:l,bottomLeft:h,bottomRight:c}=toTRBLCorners(o),{x:d,y:u}=t,{width:g,height:p}=e;let f,m,x,b,_,y;return"center"===n?(_=u+p/2,"left"===s?(f=d,m=f-a,b=_+a,y=_-a):(f=d+g,m=f+a,b=_-a,y=_+a),x=f):(m="left"===s?d+Math.max(r,h)+a:"right"===s?d+g-Math.max(l,c)-a:this.caretX,"top"===n?(b=u,_=b-a,f=m-a,x=m+a):(b=u+p,_=b+a,f=m+a,x=m-a),y=b),{x1:f,x2:m,x3:x,y1:b,y2:_,y3:y}}drawTitle(t,e,i){const s=this.title,n=s.length;let a,o,r;if(n){const l=getRtlAdapter(i.rtl,this.x,this.width);for(t.x=getAlignedX(this,i.titleAlign,i),e.textAlign=l.textAlign(i.titleAlign),e.textBaseline="middle",a=toFont(i.titleFont),o=i.titleSpacing,e.fillStyle=i.titleColor,e.font=a.string,r=0;r<n;++r)e.fillText(s[r],l.x(t.x),t.y+a.lineHeight/2),t.y+=a.lineHeight+o,r+1===n&&(t.y+=i.titleMarginBottom-o)}}_drawColorBox(t,e,i,s,n){const a=this.labelColors[i],o=this.labelPointStyles[i],{boxHeight:r,boxWidth:l}=n,h=toFont(n.bodyFont),c=getAlignedX(this,"left",n),d=s.x(c),u=r<h.lineHeight?(h.lineHeight-r)/2:0,g=e.y+u;if(n.usePointStyle){const e={radius:Math.min(l,r)/2,pointStyle:o.pointStyle,rotation:o.rotation,borderWidth:1},i=s.leftForLtr(d,l)+l/2,h=g+r/2;t.strokeStyle=n.multiKeyBackground,t.fillStyle=n.multiKeyBackground,drawPoint(t,e,i,h),t.strokeStyle=a.borderColor,t.fillStyle=a.backgroundColor,drawPoint(t,e,i,h)}else{t.lineWidth=isObject(a.borderWidth)?Math.max(...Object.values(a.borderWidth)):a.borderWidth||1,t.strokeStyle=a.borderColor,t.setLineDash(a.borderDash||[]),t.lineDashOffset=a.borderDashOffset||0;const e=s.leftForLtr(d,l),i=s.leftForLtr(s.xPlus(d,1),l-2),o=toTRBLCorners(a.borderRadius);Object.values(o).some((t=>0!==t))?(t.beginPath(),t.fillStyle=n.multiKeyBackground,addRoundedRectPath(t,{x:e,y:g,w:l,h:r,radius:o}),t.fill(),t.stroke(),t.fillStyle=a.backgroundColor,t.beginPath(),addRoundedRectPath(t,{x:i,y:g+1,w:l-2,h:r-2,radius:o}),t.fill()):(t.fillStyle=n.multiKeyBackground,t.fillRect(e,g,l,r),t.strokeRect(e,g,l,r),t.fillStyle=a.backgroundColor,t.fillRect(i,g+1,l-2,r-2))}t.fillStyle=this.labelTextColors[i]}drawBody(t,e,i){const{body:s}=this,{bodySpacing:n,bodyAlign:a,displayColors:o,boxHeight:r,boxWidth:l,boxPadding:h}=i,c=toFont(i.bodyFont);let d=c.lineHeight,u=0;const g=getRtlAdapter(i.rtl,this.x,this.width),p=function(i){e.fillText(i,g.x(t.x+u),t.y+d/2),t.y+=d+n},f=g.textAlign(a);let m,x,b,_,y,v,k;for(e.textAlign=a,e.textBaseline="middle",e.font=c.string,t.x=getAlignedX(this,f,i),e.fillStyle=i.bodyColor,each(this.beforeBody,p),u=o&&"right"!==f?"center"===a?l/2+h:l+2+h:0,_=0,v=s.length;_<v;++_){for(m=s[_],x=this.labelTextColors[_],e.fillStyle=x,each(m.before,p),b=m.lines,o&&b.length&&(this._drawColorBox(e,t,_,g,i),d=Math.max(c.lineHeight,r)),y=0,k=b.length;y<k;++y)p(b[y]),d=c.lineHeight;each(m.after,p)}u=0,d=c.lineHeight,each(this.afterBody,p),t.y-=n}drawFooter(t,e,i){const s=this.footer,n=s.length;let a,o;if(n){const r=getRtlAdapter(i.rtl,this.x,this.width);for(t.x=getAlignedX(this,i.footerAlign,i),t.y+=i.footerMarginTop,e.textAlign=r.textAlign(i.footerAlign),e.textBaseline="middle",a=toFont(i.footerFont),e.fillStyle=i.footerColor,e.font=a.string,o=0;o<n;++o)e.fillText(s[o],r.x(t.x),t.y+a.lineHeight/2),t.y+=a.lineHeight+i.footerSpacing}}drawBackground(t,e,i,s){const{xAlign:n,yAlign:a}=this,{x:o,y:r}=t,{width:l,height:h}=i,{topLeft:c,topRight:d,bottomLeft:u,bottomRight:g}=toTRBLCorners(s.cornerRadius);e.fillStyle=s.backgroundColor,e.strokeStyle=s.borderColor,e.lineWidth=s.borderWidth,e.beginPath(),e.moveTo(o+c,r),"top"===a&&this.drawCaret(t,e,i,s),e.lineTo(o+l-d,r),e.quadraticCurveTo(o+l,r,o+l,r+d),"center"===a&&"right"===n&&this.drawCaret(t,e,i,s),e.lineTo(o+l,r+h-g),e.quadraticCurveTo(o+l,r+h,o+l-g,r+h),"bottom"===a&&this.drawCaret(t,e,i,s),e.lineTo(o+u,r+h),e.quadraticCurveTo(o,r+h,o,r+h-u),"center"===a&&"left"===n&&this.drawCaret(t,e,i,s),e.lineTo(o,r+c),e.quadraticCurveTo(o,r,o+c,r),e.closePath(),e.fill(),s.borderWidth>0&&e.stroke()}_updateAnimationTarget(t){const e=this.chart,i=this.$animations,s=i&&i.x,n=i&&i.y;if(s||n){const i=positioners[t.position].call(this,this._active,this._eventPosition);if(!i)return;const a=this._size=getTooltipSize(this,t),o=Object.assign({},i,this._size),r=determineAlignment(e,t,o),l=getBackgroundPoint(t,o,r,e);s._to===l.x&&n._to===l.y||(this.xAlign=r.xAlign,this.yAlign=r.yAlign,this.width=a.width,this.height=a.height,this.caretX=i.x,this.caretY=i.y,this._resolveAnimations().update(this,l))}}_willRender(){return!!this.opacity}draw(t){const e=this.options.setContext(this.getContext());let i=this.opacity;if(!i)return;this._updateAnimationTarget(e);const s={width:this.width,height:this.height},n={x:this.x,y:this.y};i=Math.abs(i)<.001?0:i;const a=toPadding(e.padding),o=this.title.length||this.beforeBody.length||this.body.length||this.afterBody.length||this.footer.length;e.enabled&&o&&(t.save(),t.globalAlpha=i,this.drawBackground(n,t,s,e),overrideTextDirection(t,e.textDirection),n.y+=a.top,this.drawTitle(n,t,e),this.drawBody(n,t,e),this.drawFooter(n,t,e),restoreTextDirection(t,e.textDirection),t.restore())}getActiveElements(){return this._active||[]}setActiveElements(t,e){const i=this._active,s=t.map((({datasetIndex:t,index:e})=>{const i=this.chart.getDatasetMeta(t);if(!i)throw new Error("Cannot find a dataset at index "+t);return{datasetIndex:t,element:i.data[e],index:e}})),n=!_elementsEqual(i,s),a=this._positionChanged(s,e);(n||a)&&(this._active=s,this._eventPosition=e,this._ignoreReplayEvents=!0,this.update(!0))}handleEvent(t,e,i=!0){if(e&&this._ignoreReplayEvents)return!1;this._ignoreReplayEvents=!1;const s=this.options,n=this._active||[],a=this._getActiveElements(t,n,e,i),o=this._positionChanged(a,t),r=e||!_elementsEqual(a,n)||o;return r&&(this._active=a,(s.enabled||s.external)&&(this._eventPosition={x:t.x,y:t.y},this.update(!0,e))),r}_getActiveElements(t,e,i,s){const n=this.options;if("mouseout"===t.type)return[];if(!s)return e;const a=this.chart.getElementsAtEventForMode(t,n.mode,n,i);return n.reverse&&a.reverse(),a}_positionChanged(t,e){const{caretX:i,caretY:s,options:n}=this,a=positioners[n.position].call(this,t,e);return!1!==a&&(i!==a.x||s!==a.y)}}var plugin_tooltip={id:"tooltip",_element:Tooltip,positioners:positioners,afterInit(t,e,i){i&&(t.tooltip=new Tooltip({chart:t,options:i}))},beforeUpdate(t,e,i){t.tooltip&&t.tooltip.initialize(i)},reset(t,e,i){t.tooltip&&t.tooltip.initialize(i)},afterDraw(t){const e=t.tooltip;if(e&&e._willRender()){const i={tooltip:e};if(!1===t.notifyPlugins("beforeTooltipDraw",{...i,cancelable:!0}))return;e.draw(t.ctx),t.notifyPlugins("afterTooltipDraw",i)}},afterEvent(t,e){if(t.tooltip){const i=e.replay;t.tooltip.handleEvent(e.event,i,e.inChartArea)&&(e.changed=!0)}},defaults:{enabled:!0,external:null,position:"average",backgroundColor:"rgba(0,0,0,0.8)",titleColor:"#fff",titleFont:{weight:"bold"},titleSpacing:2,titleMarginBottom:6,titleAlign:"left",bodyColor:"#fff",bodySpacing:2,bodyFont:{},bodyAlign:"left",footerColor:"#fff",footerSpacing:2,footerMarginTop:6,footerFont:{weight:"bold"},footerAlign:"left",padding:6,caretPadding:2,caretSize:5,cornerRadius:6,boxHeight:(t,e)=>e.bodyFont.size,boxWidth:(t,e)=>e.bodyFont.size,multiKeyBackground:"#fff",displayColors:!0,boxPadding:0,borderColor:"rgba(0,0,0,0)",borderWidth:0,animation:{duration:400,easing:"easeOutQuart"},animations:{numbers:{type:"number",properties:["x","y","width","height","caretX","caretY"]},opacity:{easing:"linear",duration:200}},callbacks:defaultCallbacks},defaultRoutes:{bodyFont:"font",footerFont:"font",titleFont:"font"},descriptors:{_scriptable:t=>"filter"!==t&&"itemSort"!==t&&"external"!==t,_indexable:!1,callbacks:{_scriptable:!1,_indexable:!1},animation:{_fallback:!1},animations:{_fallback:"animation"}},additionalOptionScopes:["interaction"]},plugins=Object.freeze({__proto__:null,Colors:plugin_colors,Decimation:plugin_decimation,Filler:index,Legend:plugin_legend,SubTitle:plugin_subtitle,Title:plugin_title,Tooltip:plugin_tooltip});const addIfString=(t,e,i,s)=>("string"==typeof e?(i=t.push(e)-1,s.unshift({index:i,label:e})):isNaN(e)&&(i=null),i);function findOrAddLabel(t,e,i,s){const n=t.indexOf(e);if(-1===n)return addIfString(t,e,i,s);return n!==t.lastIndexOf(e)?i:n}const validIndex=(t,e)=>null===t?null:_limitValue(Math.round(t),0,e);function _getLabelForValue(t){const e=this.getLabels();return t>=0&&t<e.length?e[t]:t}class CategoryScale extends Scale{static id="category";static defaults={ticks:{callback:_getLabelForValue}};constructor(t){super(t),this._startValue=void 0,this._valueRange=0,this._addedLabels=[]}init(t){const e=this._addedLabels;if(e.length){const t=this.getLabels();for(const{index:i,label:s}of e)t[i]===s&&t.splice(i,1);this._addedLabels=[]}super.init(t)}parse(t,e){if(isNullOrUndef(t))return null;const i=this.getLabels();return e=isFinite(e)&&i[e]===t?e:findOrAddLabel(i,t,valueOrDefault(e,t),this._addedLabels),validIndex(e,i.length-1)}determineDataLimits(){const{minDefined:t,maxDefined:e}=this.getUserBounds();let{min:i,max:s}=this.getMinMax(!0);"ticks"===this.options.bounds&&(t||(i=0),e||(s=this.getLabels().length-1)),this.min=i,this.max=s}buildTicks(){const t=this.min,e=this.max,i=this.options.offset,s=[];let n=this.getLabels();n=0===t&&e===n.length-1?n:n.slice(t,e+1),this._valueRange=Math.max(n.length-(i?0:1),1),this._startValue=this.min-(i?.5:0);for(let i=t;i<=e;i++)s.push({value:i});return s}getLabelForValue(t){return _getLabelForValue.call(this,t)}configure(){super.configure(),this.isHorizontal()||(this._reversePixels=!this._reversePixels)}getPixelForValue(t){return"number"!=typeof t&&(t=this.parse(t)),null===t?NaN:this.getPixelForDecimal((t-this._startValue)/this._valueRange)}getPixelForTick(t){const e=this.ticks;return t<0||t>e.length-1?null:this.getPixelForValue(e[t].value)}getValueForPixel(t){return Math.round(this._startValue+this.getDecimalForPixel(t)*this._valueRange)}getBasePixel(){return this.bottom}}function generateTicks$1(t,e){const i=[],{bounds:s,step:n,min:a,max:o,precision:r,count:l,maxTicks:h,maxDigits:c,includeBounds:d}=t,u=n||1,g=h-1,{min:p,max:f}=e,m=!isNullOrUndef(a),x=!isNullOrUndef(o),b=!isNullOrUndef(l),_=(f-p)/(c+1);let y,v,k,S,D=niceNum((f-p)/g/u)*u;if(D<1e-14&&!m&&!x)return[{value:p},{value:f}];S=Math.ceil(f/D)-Math.floor(p/D),S>g&&(D=niceNum(S*D/g/u)*u),isNullOrUndef(r)||(y=Math.pow(10,r),D=Math.ceil(D*y)/y),"ticks"===s?(v=Math.floor(p/D)*D,k=Math.ceil(f/D)*D):(v=p,k=f),m&&x&&n&&almostWhole((o-a)/n,D/1e3)?(S=Math.round(Math.min((o-a)/D,h)),D=(o-a)/S,v=a,k=o):b?(v=m?a:v,k=x?o:k,S=l-1,D=(k-v)/S):(S=(k-v)/D,S=almostEquals(S,Math.round(S),D/1e3)?Math.round(S):Math.ceil(S));const M=Math.max(_decimalPlaces(D),_decimalPlaces(v));y=Math.pow(10,isNullOrUndef(r)?M:r),v=Math.round(v*y)/y,k=Math.round(k*y)/y;let P=0;for(m&&(d&&v!==a?(i.push({value:a}),v<a&&P++,almostEquals(Math.round((v+P*D)*y)/y,a,relativeLabelSize(a,_,t))&&P++):v<a&&P++);P<S;++P){const t=Math.round((v+P*D)*y)/y;if(x&&t>o)break;i.push({value:t})}return x&&d&&k!==o?i.length&&almostEquals(i[i.length-1].value,o,relativeLabelSize(o,_,t))?i[i.length-1].value=o:i.push({value:o}):x&&k!==o||i.push({value:k}),i}function relativeLabelSize(t,e,{horizontal:i,minRotation:s}){const n=toRadians(s),a=(i?Math.sin(n):Math.cos(n))||.001,o=.75*e*(""+t).length;return Math.min(e/a,o)}class LinearScaleBase extends Scale{constructor(t){super(t),this.start=void 0,this.end=void 0,this._startValue=void 0,this._endValue=void 0,this._valueRange=0}parse(t,e){return isNullOrUndef(t)||("number"==typeof t||t instanceof Number)&&!isFinite(+t)?null:+t}handleTickRangeOptions(){const{beginAtZero:t}=this.options,{minDefined:e,maxDefined:i}=this.getUserBounds();let{min:s,max:n}=this;const a=t=>s=e?s:t,o=t=>n=i?n:t;if(t){const t=sign(s),e=sign(n);t<0&&e<0?o(0):t>0&&e>0&&a(0)}if(s===n){let e=0===n?1:Math.abs(.05*n);o(n+e),t||a(s-e)}this.min=s,this.max=n}getTickLimit(){const t=this.options.ticks;let e,{maxTicksLimit:i,stepSize:s}=t;return s?(e=Math.ceil(this.max/s)-Math.floor(this.min/s)+1,e>1e3&&(console.warn(`scales.${this.id}.ticks.stepSize: ${s} would result generating up to ${e} ticks. Limiting to 1000.`),e=1e3)):(e=this.computeTickLimit(),i=i||11),i&&(e=Math.min(i,e)),e}computeTickLimit(){return Number.POSITIVE_INFINITY}buildTicks(){const t=this.options,e=t.ticks;let i=this.getTickLimit();i=Math.max(2,i);const s=generateTicks$1({maxTicks:i,bounds:t.bounds,min:t.min,max:t.max,precision:e.precision,step:e.stepSize,count:e.count,maxDigits:this._maxDigits(),horizontal:this.isHorizontal(),minRotation:e.minRotation||0,includeBounds:!1!==e.includeBounds},this._range||this);return"ticks"===t.bounds&&_setMinAndMaxByKey(s,this,"value"),t.reverse?(s.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),s}configure(){const t=this.ticks;let e=this.min,i=this.max;if(super.configure(),this.options.offset&&t.length){const s=(i-e)/Math.max(t.length-1,1)/2;e-=s,i+=s}this._startValue=e,this._endValue=i,this._valueRange=i-e}getLabelForValue(t){return formatNumber(t,this.chart.options.locale,this.options.ticks.format)}}class LinearScale extends LinearScaleBase{static id="linear";static defaults={ticks:{callback:Ticks.formatters.numeric}};determineDataLimits(){const{min:t,max:e}=this.getMinMax(!0);this.min=isNumberFinite(t)?t:0,this.max=isNumberFinite(e)?e:1,this.handleTickRangeOptions()}computeTickLimit(){const t=this.isHorizontal(),e=t?this.width:this.height,i=toRadians(this.options.ticks.minRotation),s=(t?Math.sin(i):Math.cos(i))||.001,n=this._resolveTickFontOptions(0);return Math.ceil(e/Math.min(40,n.lineHeight/s))}getPixelForValue(t){return null===t?NaN:this.getPixelForDecimal((t-this._startValue)/this._valueRange)}getValueForPixel(t){return this._startValue+this.getDecimalForPixel(t)*this._valueRange}}const log10Floor=t=>Math.floor(log10(t)),changeExponent=(t,e)=>Math.pow(10,log10Floor(t)+e);function isMajor(t){return 1===t/Math.pow(10,log10Floor(t))}function steps(t,e,i){const s=Math.pow(10,i),n=Math.floor(t/s);return Math.ceil(e/s)-n}function startExp(t,e){let i=log10Floor(e-t);for(;steps(t,e,i)>10;)i++;for(;steps(t,e,i)<10;)i--;return Math.min(i,log10Floor(t))}function generateTicks(t,{min:e,max:i}){e=finiteOrDefault(t.min,e);const s=[],n=log10Floor(e);let a=startExp(e,i),o=a<0?Math.pow(10,Math.abs(a)):1;const r=Math.pow(10,a),l=n>a?Math.pow(10,n):0,h=Math.round((e-l)*o)/o,c=Math.floor((e-l)/r/10)*r*10;let d=Math.floor((h-c)/Math.pow(10,a)),u=finiteOrDefault(t.min,Math.round((l+c+d*Math.pow(10,a))*o)/o);for(;u<i;)s.push({value:u,major:isMajor(u),significand:d}),d>=10?d=d<15?15:20:d++,d>=20&&(a++,d=2,o=a>=0?1:o),u=Math.round((l+c+d*Math.pow(10,a))*o)/o;const g=finiteOrDefault(t.max,u);return s.push({value:g,major:isMajor(g),significand:d}),s}class LogarithmicScale extends Scale{static id="logarithmic";static defaults={ticks:{callback:Ticks.formatters.logarithmic,major:{enabled:!0}}};constructor(t){super(t),this.start=void 0,this.end=void 0,this._startValue=void 0,this._valueRange=0}parse(t,e){const i=LinearScaleBase.prototype.parse.apply(this,[t,e]);if(0!==i)return isNumberFinite(i)&&i>0?i:null;this._zero=!0}determineDataLimits(){const{min:t,max:e}=this.getMinMax(!0);this.min=isNumberFinite(t)?Math.max(0,t):null,this.max=isNumberFinite(e)?Math.max(0,e):null,this.options.beginAtZero&&(this._zero=!0),this._zero&&this.min!==this._suggestedMin&&!isNumberFinite(this._userMin)&&(this.min=t===changeExponent(this.min,0)?changeExponent(this.min,-1):changeExponent(this.min,0)),this.handleTickRangeOptions()}handleTickRangeOptions(){const{minDefined:t,maxDefined:e}=this.getUserBounds();let i=this.min,s=this.max;const n=e=>i=t?i:e,a=t=>s=e?s:t;i===s&&(i<=0?(n(1),a(10)):(n(changeExponent(i,-1)),a(changeExponent(s,1)))),i<=0&&n(changeExponent(s,-1)),s<=0&&a(changeExponent(i,1)),this.min=i,this.max=s}buildTicks(){const t=this.options,e=generateTicks({min:this._userMin,max:this._userMax},this);return"ticks"===t.bounds&&_setMinAndMaxByKey(e,this,"value"),t.reverse?(e.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),e}getLabelForValue(t){return void 0===t?"0":formatNumber(t,this.chart.options.locale,this.options.ticks.format)}configure(){const t=this.min;super.configure(),this._startValue=log10(t),this._valueRange=log10(this.max)-log10(t)}getPixelForValue(t){return void 0!==t&&0!==t||(t=this.min),null===t||isNaN(t)?NaN:this.getPixelForDecimal(t===this.min?0:(log10(t)-this._startValue)/this._valueRange)}getValueForPixel(t){const e=this.getDecimalForPixel(t);return Math.pow(10,this._startValue+e*this._valueRange)}}function getTickBackdropHeight(t){const e=t.ticks;if(e.display&&t.display){const t=toPadding(e.backdropPadding);return valueOrDefault(e.font&&e.font.size,defaults.font.size)+t.height}return 0}function measureLabelSize(t,e,i){return i=isArray(i)?i:[i],{w:_longestText(t,e.string,i),h:i.length*e.lineHeight}}function determineLimits(t,e,i,s,n){return t===s||t===n?{start:e-i/2,end:e+i/2}:t<s||t>n?{start:e-i,end:e}:{start:e,end:e+i}}function fitWithPointLabels(t){const e={l:t.left+t._padding.left,r:t.right-t._padding.right,t:t.top+t._padding.top,b:t.bottom-t._padding.bottom},i=Object.assign({},e),s=[],n=[],a=t._pointLabels.length,o=t.options.pointLabels,r=o.centerPointLabels?PI/a:0;for(let l=0;l<a;l++){const a=o.setContext(t.getPointLabelContext(l));n[l]=a.padding;const h=t.getPointPosition(l,t.drawingArea+n[l],r),c=toFont(a.font),d=measureLabelSize(t.ctx,c,t._pointLabels[l]);s[l]=d;const u=_normalizeAngle(t.getIndexAngle(l)+r),g=Math.round(toDegrees(u));updateLimits(i,e,u,determineLimits(g,h.x,d.w,0,180),determineLimits(g,h.y,d.h,90,270))}t.setCenterPoint(e.l-i.l,i.r-e.r,e.t-i.t,i.b-e.b),t._pointLabelItems=buildPointLabelItems(t,s,n)}function updateLimits(t,e,i,s,n){const a=Math.abs(Math.sin(i)),o=Math.abs(Math.cos(i));let r=0,l=0;s.start<e.l?(r=(e.l-s.start)/a,t.l=Math.min(t.l,e.l-r)):s.end>e.r&&(r=(s.end-e.r)/a,t.r=Math.max(t.r,e.r+r)),n.start<e.t?(l=(e.t-n.start)/o,t.t=Math.min(t.t,e.t-l)):n.end>e.b&&(l=(n.end-e.b)/o,t.b=Math.max(t.b,e.b+l))}function createPointLabelItem(t,e,i){const s=t.drawingArea,{extra:n,additionalAngle:a,padding:o,size:r}=i,l=t.getPointPosition(e,s+n+o,a),h=Math.round(toDegrees(_normalizeAngle(l.angle+HALF_PI))),c=yForAngle(l.y,r.h,h),d=getTextAlignForAngle(h),u=leftForTextAlign(l.x,r.w,d);return{visible:!0,x:l.x,y:c,textAlign:d,left:u,top:c,right:u+r.w,bottom:c+r.h}}function isNotOverlapped(t,e){if(!e)return!0;const{left:i,top:s,right:n,bottom:a}=t;return!(_isPointInArea({x:i,y:s},e)||_isPointInArea({x:i,y:a},e)||_isPointInArea({x:n,y:s},e)||_isPointInArea({x:n,y:a},e))}function buildPointLabelItems(t,e,i){const s=[],n=t._pointLabels.length,a=t.options,{centerPointLabels:o,display:r}=a.pointLabels,l={extra:getTickBackdropHeight(a)/2,additionalAngle:o?PI/n:0};let h;for(let a=0;a<n;a++){l.padding=i[a],l.size=e[a];const n=createPointLabelItem(t,a,l);s.push(n),"auto"===r&&(n.visible=isNotOverlapped(n,h),n.visible&&(h=n))}return s}function getTextAlignForAngle(t){return 0===t||180===t?"center":t<180?"left":"right"}function leftForTextAlign(t,e,i){return"right"===i?t-=e:"center"===i&&(t-=e/2),t}function yForAngle(t,e,i){return 90===i||270===i?t-=e/2:(i>270||i<90)&&(t-=e),t}function drawPointLabelBox(t,e,i){const{left:s,top:n,right:a,bottom:o}=i,{backdropColor:r}=e;if(!isNullOrUndef(r)){const i=toTRBLCorners(e.borderRadius),l=toPadding(e.backdropPadding);t.fillStyle=r;const h=s-l.left,c=n-l.top,d=a-s+l.width,u=o-n+l.height;Object.values(i).some((t=>0!==t))?(t.beginPath(),addRoundedRectPath(t,{x:h,y:c,w:d,h:u,radius:i}),t.fill()):t.fillRect(h,c,d,u)}}function drawPointLabels(t,e){const{ctx:i,options:{pointLabels:s}}=t;for(let n=e-1;n>=0;n--){const e=t._pointLabelItems[n];if(!e.visible)continue;const a=s.setContext(t.getPointLabelContext(n));drawPointLabelBox(i,a,e);const o=toFont(a.font),{x:r,y:l,textAlign:h}=e;renderText(i,t._pointLabels[n],r,l+o.lineHeight/2,o,{color:a.color,textAlign:h,textBaseline:"middle"})}}function pathRadiusLine(t,e,i,s){const{ctx:n}=t;if(i)n.arc(t.xCenter,t.yCenter,e,0,TAU);else{let i=t.getPointPosition(0,e);n.moveTo(i.x,i.y);for(let a=1;a<s;a++)i=t.getPointPosition(a,e),n.lineTo(i.x,i.y)}}function drawRadiusLine(t,e,i,s,n){const a=t.ctx,o=e.circular,{color:r,lineWidth:l}=e;!o&&!s||!r||!l||i<0||(a.save(),a.strokeStyle=r,a.lineWidth=l,a.setLineDash(n.dash),a.lineDashOffset=n.dashOffset,a.beginPath(),pathRadiusLine(t,i,o,s),a.closePath(),a.stroke(),a.restore())}function createPointLabelContext(t,e,i){return createContext(t,{label:i,index:e,type:"pointLabel"})}class RadialLinearScale extends LinearScaleBase{static id="radialLinear";static defaults={display:!0,animate:!0,position:"chartArea",angleLines:{display:!0,lineWidth:1,borderDash:[],borderDashOffset:0},grid:{circular:!1},startAngle:0,ticks:{showLabelBackdrop:!0,callback:Ticks.formatters.numeric},pointLabels:{backdropColor:void 0,backdropPadding:2,display:!0,font:{size:10},callback:t=>t,padding:5,centerPointLabels:!1}};static defaultRoutes={"angleLines.color":"borderColor","pointLabels.color":"color","ticks.color":"color"};static descriptors={angleLines:{_fallback:"grid"}};constructor(t){super(t),this.xCenter=void 0,this.yCenter=void 0,this.drawingArea=void 0,this._pointLabels=[],this._pointLabelItems=[]}setDimensions(){const t=this._padding=toPadding(getTickBackdropHeight(this.options)/2),e=this.width=this.maxWidth-t.width,i=this.height=this.maxHeight-t.height;this.xCenter=Math.floor(this.left+e/2+t.left),this.yCenter=Math.floor(this.top+i/2+t.top),this.drawingArea=Math.floor(Math.min(e,i)/2)}determineDataLimits(){const{min:t,max:e}=this.getMinMax(!1);this.min=isNumberFinite(t)&&!isNaN(t)?t:0,this.max=isNumberFinite(e)&&!isNaN(e)?e:0,this.handleTickRangeOptions()}computeTickLimit(){return Math.ceil(this.drawingArea/getTickBackdropHeight(this.options))}generateTickLabels(t){LinearScaleBase.prototype.generateTickLabels.call(this,t),this._pointLabels=this.getLabels().map(((t,e)=>{const i=callback(this.options.pointLabels.callback,[t,e],this);return i||0===i?i:""})).filter(((t,e)=>this.chart.getDataVisibility(e)))}fit(){const t=this.options;t.display&&t.pointLabels.display?fitWithPointLabels(this):this.setCenterPoint(0,0,0,0)}setCenterPoint(t,e,i,s){this.xCenter+=Math.floor((t-e)/2),this.yCenter+=Math.floor((i-s)/2),this.drawingArea-=Math.min(this.drawingArea/2,Math.max(t,e,i,s))}getIndexAngle(t){const e=TAU/(this._pointLabels.length||1),i=this.options.startAngle||0;return _normalizeAngle(t*e+toRadians(i))}getDistanceFromCenterForValue(t){if(isNullOrUndef(t))return NaN;const e=this.drawingArea/(this.max-this.min);return this.options.reverse?(this.max-t)*e:(t-this.min)*e}getValueForDistanceFromCenter(t){if(isNullOrUndef(t))return NaN;const e=t/(this.drawingArea/(this.max-this.min));return this.options.reverse?this.max-e:this.min+e}getPointLabelContext(t){const e=this._pointLabels||[];if(t>=0&&t<e.length){const i=e[t];return createPointLabelContext(this.getContext(),t,i)}}getPointPosition(t,e,i=0){const s=this.getIndexAngle(t)-HALF_PI+i;return{x:Math.cos(s)*e+this.xCenter,y:Math.sin(s)*e+this.yCenter,angle:s}}getPointPositionForValue(t,e){return this.getPointPosition(t,this.getDistanceFromCenterForValue(e))}getBasePosition(t){return this.getPointPositionForValue(t||0,this.getBaseValue())}getPointLabelPosition(t){const{left:e,top:i,right:s,bottom:n}=this._pointLabelItems[t];return{left:e,top:i,right:s,bottom:n}}drawBackground(){const{backgroundColor:t,grid:{circular:e}}=this.options;if(t){const i=this.ctx;i.save(),i.beginPath(),pathRadiusLine(this,this.getDistanceFromCenterForValue(this._endValue),e,this._pointLabels.length),i.closePath(),i.fillStyle=t,i.fill(),i.restore()}}drawGrid(){const t=this.ctx,e=this.options,{angleLines:i,grid:s,border:n}=e,a=this._pointLabels.length;let o,r,l;if(e.pointLabels.display&&drawPointLabels(this,a),s.display&&this.ticks.forEach(((t,e)=>{if(0!==e){r=this.getDistanceFromCenterForValue(t.value);const i=this.getContext(e),o=s.setContext(i),l=n.setContext(i);drawRadiusLine(this,o,r,a,l)}})),i.display){for(t.save(),o=a-1;o>=0;o--){const s=i.setContext(this.getPointLabelContext(o)),{color:n,lineWidth:a}=s;a&&n&&(t.lineWidth=a,t.strokeStyle=n,t.setLineDash(s.borderDash),t.lineDashOffset=s.borderDashOffset,r=this.getDistanceFromCenterForValue(e.ticks.reverse?this.min:this.max),l=this.getPointPosition(o,r),t.beginPath(),t.moveTo(this.xCenter,this.yCenter),t.lineTo(l.x,l.y),t.stroke())}t.restore()}}drawBorder(){}drawLabels(){const t=this.ctx,e=this.options,i=e.ticks;if(!i.display)return;const s=this.getIndexAngle(0);let n,a;t.save(),t.translate(this.xCenter,this.yCenter),t.rotate(s),t.textAlign="center",t.textBaseline="middle",this.ticks.forEach(((s,o)=>{if(0===o&&!e.reverse)return;const r=i.setContext(this.getContext(o)),l=toFont(r.font);if(n=this.getDistanceFromCenterForValue(this.ticks[o].value),r.showLabelBackdrop){t.font=l.string,a=t.measureText(s.label).width,t.fillStyle=r.backdropColor;const e=toPadding(r.backdropPadding);t.fillRect(-a/2-e.left,-n-l.size/2-e.top,a+e.width,l.size+e.height)}renderText(t,s.label,0,-n,l,{color:r.color,strokeColor:r.textStrokeColor,strokeWidth:r.textStrokeWidth})})),t.restore()}drawTitle(){}}const INTERVALS={millisecond:{common:!0,size:1,steps:1e3},second:{common:!0,size:1e3,steps:60},minute:{common:!0,size:6e4,steps:60},hour:{common:!0,size:36e5,steps:24},day:{common:!0,size:864e5,steps:30},week:{common:!1,size:6048e5,steps:4},month:{common:!0,size:2628e6,steps:12},quarter:{common:!1,size:7884e6,steps:4},year:{common:!0,size:3154e7}},UNITS=Object.keys(INTERVALS);function sorter(t,e){return t-e}function parse(t,e){if(isNullOrUndef(e))return null;const i=t._adapter,{parser:s,round:n,isoWeekday:a}=t._parseOpts;let o=e;return"function"==typeof s&&(o=s(o)),isNumberFinite(o)||(o="string"==typeof s?i.parse(o,s):i.parse(o)),null===o?null:(n&&(o="week"!==n||!isNumber(a)&&!0!==a?i.startOf(o,n):i.startOf(o,"isoWeek",a)),+o)}function determineUnitForAutoTicks(t,e,i,s){const n=UNITS.length;for(let a=UNITS.indexOf(t);a<n-1;++a){const t=INTERVALS[UNITS[a]],n=t.steps?t.steps:Number.MAX_SAFE_INTEGER;if(t.common&&Math.ceil((i-e)/(n*t.size))<=s)return UNITS[a]}return UNITS[n-1]}function determineUnitForFormatting(t,e,i,s,n){for(let a=UNITS.length-1;a>=UNITS.indexOf(i);a--){const i=UNITS[a];if(INTERVALS[i].common&&t._adapter.diff(n,s,i)>=e-1)return i}return UNITS[i?UNITS.indexOf(i):0]}function determineMajorUnit(t){for(let e=UNITS.indexOf(t)+1,i=UNITS.length;e<i;++e)if(INTERVALS[UNITS[e]].common)return UNITS[e]}function addTick(t,e,i){if(i){if(i.length){const{lo:s,hi:n}=_lookup(i,e);t[i[s]>=e?i[s]:i[n]]=!0}}else t[e]=!0}function setMajorTicks(t,e,i,s){const n=t._adapter,a=+n.startOf(e[0].value,s),o=e[e.length-1].value;let r,l;for(r=a;r<=o;r=+n.add(r,1,s))l=i[r],l>=0&&(e[l].major=!0);return e}function ticksFromTimestamps(t,e,i){const s=[],n={},a=e.length;let o,r;for(o=0;o<a;++o)r=e[o],n[r]=o,s.push({value:r,major:!1});return 0!==a&&i?setMajorTicks(t,s,n,i):s}class TimeScale extends Scale{static id="time";static defaults={bounds:"data",adapters:{},time:{parser:!1,unit:!1,round:!1,isoWeekday:!1,minUnit:"millisecond",displayFormats:{}},ticks:{source:"auto",callback:!1,major:{enabled:!1}}};constructor(t){super(t),this._cache={data:[],labels:[],all:[]},this._unit="day",this._majorUnit=void 0,this._offsets={},this._normalized=!1,this._parseOpts=void 0}init(t,e={}){const i=t.time||(t.time={}),s=this._adapter=new adapters._date(t.adapters.date);s.init(e),mergeIf(i.displayFormats,s.formats()),this._parseOpts={parser:i.parser,round:i.round,isoWeekday:i.isoWeekday},super.init(t),this._normalized=e.normalized}parse(t,e){return void 0===t?null:parse(this,t)}beforeLayout(){super.beforeLayout(),this._cache={data:[],labels:[],all:[]}}determineDataLimits(){const t=this.options,e=this._adapter,i=t.time.unit||"day";let{min:s,max:n,minDefined:a,maxDefined:o}=this.getUserBounds();function r(t){a||isNaN(t.min)||(s=Math.min(s,t.min)),o||isNaN(t.max)||(n=Math.max(n,t.max))}a&&o||(r(this._getLabelBounds()),"ticks"===t.bounds&&"labels"===t.ticks.source||r(this.getMinMax(!1))),s=isNumberFinite(s)&&!isNaN(s)?s:+e.startOf(Date.now(),i),n=isNumberFinite(n)&&!isNaN(n)?n:+e.endOf(Date.now(),i)+1,this.min=Math.min(s,n-1),this.max=Math.max(s+1,n)}_getLabelBounds(){const t=this.getLabelTimestamps();let e=Number.POSITIVE_INFINITY,i=Number.NEGATIVE_INFINITY;return t.length&&(e=t[0],i=t[t.length-1]),{min:e,max:i}}buildTicks(){const t=this.options,e=t.time,i=t.ticks,s="labels"===i.source?this.getLabelTimestamps():this._generate();"ticks"===t.bounds&&s.length&&(this.min=this._userMin||s[0],this.max=this._userMax||s[s.length-1]);const n=this.min,a=this.max,o=_filterBetween(s,n,a);return this._unit=e.unit||(i.autoSkip?determineUnitForAutoTicks(e.minUnit,this.min,this.max,this._getLabelCapacity(n)):determineUnitForFormatting(this,o.length,e.minUnit,this.min,this.max)),this._majorUnit=i.major.enabled&&"year"!==this._unit?determineMajorUnit(this._unit):void 0,this.initOffsets(s),t.reverse&&o.reverse(),ticksFromTimestamps(this,o,this._majorUnit)}afterAutoSkip(){this.options.offsetAfterAutoskip&&this.initOffsets(this.ticks.map((t=>+t.value)))}initOffsets(t=[]){let e,i,s=0,n=0;this.options.offset&&t.length&&(e=this.getDecimalForValue(t[0]),s=1===t.length?1-e:(this.getDecimalForValue(t[1])-e)/2,i=this.getDecimalForValue(t[t.length-1]),n=1===t.length?i:(i-this.getDecimalForValue(t[t.length-2]))/2);const a=t.length<3?.5:.25;s=_limitValue(s,0,a),n=_limitValue(n,0,a),this._offsets={start:s,end:n,factor:1/(s+1+n)}}_generate(){const t=this._adapter,e=this.min,i=this.max,s=this.options,n=s.time,a=n.unit||determineUnitForAutoTicks(n.minUnit,e,i,this._getLabelCapacity(e)),o=valueOrDefault(s.ticks.stepSize,1),r="week"===a&&n.isoWeekday,l=isNumber(r)||!0===r,h={};let c,d,u=e;if(l&&(u=+t.startOf(u,"isoWeek",r)),u=+t.startOf(u,l?"day":a),t.diff(i,e,a)>1e5*o)throw new Error(e+" and "+i+" are too far apart with stepSize of "+o+" "+a);const g="data"===s.ticks.source&&this.getDataTimestamps();for(c=u,d=0;c<i;c=+t.add(c,o,a),d++)addTick(h,c,g);return c!==i&&"ticks"!==s.bounds&&1!==d||addTick(h,c,g),Object.keys(h).sort(sorter).map((t=>+t))}getLabelForValue(t){const e=this._adapter,i=this.options.time;return i.tooltipFormat?e.format(t,i.tooltipFormat):e.format(t,i.displayFormats.datetime)}format(t,e){const i=this.options.time.displayFormats,s=this._unit,n=e||i[s];return this._adapter.format(t,n)}_tickFormatFunction(t,e,i,s){const n=this.options,a=n.ticks.callback;if(a)return callback(a,[t,e,i],this);const o=n.time.displayFormats,r=this._unit,l=this._majorUnit,h=r&&o[r],c=l&&o[l],d=i[e],u=l&&c&&d&&d.major;return this._adapter.format(t,s||(u?c:h))}generateTickLabels(t){let e,i,s;for(e=0,i=t.length;e<i;++e)s=t[e],s.label=this._tickFormatFunction(s.value,e,t)}getDecimalForValue(t){return null===t?NaN:(t-this.min)/(this.max-this.min)}getPixelForValue(t){const e=this._offsets,i=this.getDecimalForValue(t);return this.getPixelForDecimal((e.start+i)*e.factor)}getValueForPixel(t){const e=this._offsets,i=this.getDecimalForPixel(t)/e.factor-e.end;return this.min+i*(this.max-this.min)}_getLabelSize(t){const e=this.options.ticks,i=this.ctx.measureText(t).width,s=toRadians(this.isHorizontal()?e.maxRotation:e.minRotation),n=Math.cos(s),a=Math.sin(s),o=this._resolveTickFontOptions(0).size;return{w:i*n+o*a,h:i*a+o*n}}_getLabelCapacity(t){const e=this.options.time,i=e.displayFormats,s=i[e.unit]||i.millisecond,n=this._tickFormatFunction(t,0,ticksFromTimestamps(this,[t],this._majorUnit),s),a=this._getLabelSize(n),o=Math.floor(this.isHorizontal()?this.width/a.w:this.height/a.h)-1;return o>0?o:1}getDataTimestamps(){let t,e,i=this._cache.data||[];if(i.length)return i;const s=this.getMatchingVisibleMetas();if(this._normalized&&s.length)return this._cache.data=s[0].controller.getAllParsedValues(this);for(t=0,e=s.length;t<e;++t)i=i.concat(s[t].controller.getAllParsedValues(this));return this._cache.data=this.normalize(i)}getLabelTimestamps(){const t=this._cache.labels||[];let e,i;if(t.length)return t;const s=this.getLabels();for(e=0,i=s.length;e<i;++e)t.push(parse(this,s[e]));return this._cache.labels=this._normalized?t:this.normalize(t)}normalize(t){return _arrayUnique(t.sort(sorter))}}function interpolate(t,e,i){let s,n,a,o,r=0,l=t.length-1;i?(e>=t[r].pos&&e<=t[l].pos&&({lo:r,hi:l}=_lookupByKey(t,"pos",e)),({pos:s,time:a}=t[r]),({pos:n,time:o}=t[l])):(e>=t[r].time&&e<=t[l].time&&({lo:r,hi:l}=_lookupByKey(t,"time",e)),({time:s,pos:a}=t[r]),({time:n,pos:o}=t[l]));const h=n-s;return h?a+(o-a)*(e-s)/h:a}class TimeSeriesScale extends TimeScale{static id="timeseries";static defaults=TimeScale.defaults;constructor(t){super(t),this._table=[],this._minPos=void 0,this._tableRange=void 0}initOffsets(){const t=this._getTimestampsForTable(),e=this._table=this.buildLookupTable(t);this._minPos=interpolate(e,this.min),this._tableRange=interpolate(e,this.max)-this._minPos,super.initOffsets(t)}buildLookupTable(t){const{min:e,max:i}=this,s=[],n=[];let a,o,r,l,h;for(a=0,o=t.length;a<o;++a)l=t[a],l>=e&&l<=i&&s.push(l);if(s.length<2)return[{time:e,pos:0},{time:i,pos:1}];for(a=0,o=s.length;a<o;++a)h=s[a+1],r=s[a-1],l=s[a],Math.round((h+r)/2)!==l&&n.push({time:l,pos:a/(o-1)});return n}_generate(){const t=this.min,e=this.max;let i=super.getDataTimestamps();return i.includes(t)&&i.length||i.splice(0,0,t),i.includes(e)&&1!==i.length||i.push(e),i.sort(((t,e)=>t-e))}_getTimestampsForTable(){let t=this._cache.all||[];if(t.length)return t;const e=this.getDataTimestamps(),i=this.getLabelTimestamps();return t=e.length&&i.length?this.normalize(e.concat(i)):e.length?e:i,t=this._cache.all=t,t}getDecimalForValue(t){return(interpolate(this._table,t)-this._minPos)/this._tableRange}getValueForPixel(t){const e=this._offsets,i=this.getDecimalForPixel(t)/e.factor-e.end;return interpolate(this._table,i*this._tableRange+this._minPos,!0)}}var scales=Object.freeze({__proto__:null,CategoryScale:CategoryScale,LinearScale:LinearScale,LogarithmicScale:LogarithmicScale,RadialLinearScale:RadialLinearScale,TimeScale:TimeScale,TimeSeriesScale:TimeSeriesScale});const registerables=[controllers,elements,plugins,scales];export{Animation,Animations,ArcElement,BarController,BarElement,BasePlatform,BasicPlatform,BubbleController,CategoryScale,Chart,plugin_colors as Colors,DatasetController,plugin_decimation as Decimation,DomPlatform,DoughnutController,Element,index as Filler,Interaction,plugin_legend as Legend,LineController,LineElement,LinearScale,LogarithmicScale,PieController,PointElement,PolarAreaController,RadarController,RadialLinearScale,Scale,ScatterController,plugin_subtitle as SubTitle,Ticks,TimeScale,TimeSeriesScale,plugin_title as Title,plugin_tooltip as Tooltip,adapters as _adapters,_detectPlatform,animator,controllers,defaults,elements,layouts,plugins,registerables,registry,scales};
-//# sourceMappingURL=/sm/880a95df2a2d105eb46fc68c4780cc7a6d72b4b4f59413053a0c3e2556ebe25c.map
\ No newline at end of file
diff --git a/templates/about.html b/templates/about.html
index 260675f99c7..6cf8a5ee41a 100644
--- a/templates/about.html
+++ b/templates/about.html
@@ -1,792 +1,115 @@
 {% extends "base.html" %}
-
-{% block title %}About CVEDB - Vulnerability Intelligence Platform{% endblock %}
+{% set nav = 'about' %}
+{% block title %}About &mdash; CVEDB{% endblock %}
+{% block description %}What CVEDB counts, where the data comes from, and how often it updates.{% endblock %}
 
 {% block content %}
-<style>
-    /* About page specific styling */
-    .hero-section {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        color: white;
-        padding: 4rem 0;
-        margin-bottom: 2rem;
-        border-radius: 1rem;
-    }
-
-    .feature-card {
-        border: none;
-        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-        transition: transform 0.2s ease, box-shadow 0.2s ease;
-        height: 100%;
-    }
-
-    .feature-card:hover {
-        transform: translateY(-2px);
-        box-shadow: 0 8px 15px rgba(0, 0, 0, 0.15);
-    }
-
-    .feature-icon {
-        font-size: 2.5rem;
-        margin-bottom: 1rem;
-        display: block;
-    }
-
-    .stats-highlight {
-        background: linear-gradient(45deg, #f8f9fa, #e9ecef);
-        border-left: 4px solid #0d6efd;
-        padding: 1.5rem;
-        border-radius: 0.5rem;
-        margin: 1rem 0;
-    }
-
-    .tech-badge {
-        display: inline-block;
-        background: #e7f3ff;
-        color: #0d6efd;
-        padding: 0.25rem 0.75rem;
-        border-radius: 1rem;
-        font-size: 0.875rem;
-        font-weight: 500;
-        margin: 0.25rem 0.25rem 0.25rem 0;
-    }
-
-    .section-divider {
-        height: 2px;
-        background: linear-gradient(90deg, transparent, #dee2e6, transparent);
-        margin: 3rem 0;
-        border: none;
-    }
-</style>
-
-<!-- Page Header -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">About CVEDB</h1>
-    <span class="text-muted d-block mb-3">Technical documentation and platform architecture</span>
-</div>
-
-<!-- Platform Overview -->
-<div class="card feature-card mb-5">
-    <div class="card-header bg-primary text-white">
-        <h3 class="card-title mb-0">🌐 Platform Mission & Capabilities</h3>
-    </div>
-    <div class="card-body">
-        <div class="alert alert-info"
-            style="background-color: rgba(13, 110, 253, 0.1); border: 1px solid rgba(13, 110, 253, 0.2); border-radius: 1rem; padding: 2rem; margin-bottom: 2rem;">
-            <div class="text-center mb-4">
-                <h3 class="display-6 fw-bold mb-3" style="color: #0d6efd;">🎯 Where Vulnerability Chaos Meets Clarity
-                </h3>
-                <div style="width: 60px; height: 3px; background: #0d6efd; margin: 0 auto; border-radius: 2px;"></div>
-            </div>
-            <p class="lead mb-4" style="font-size: 1.1rem; line-height: 1.7; color: #495057; font-weight: 400;">CVEDB
-                embodies <a href="https://cvedb.github.io" target="_blank" class="fw-bold text-decoration-none"
-                    style="color: #0d6efd;">CVEDB'</a> core mission of transforming overwhelming vulnerability data
-                into clear, actionable intelligence that security teams can actually use.</p>
-            <p class="mb-0" style="font-size: 1rem; line-height: 1.6; color: #6c757d;">Built on the principle that the
-                best security happens when practical tools are shared freely with the community, this platform cuts
-                through the noise of endless CVE feeds to help security professionals <strong
-                    style="color: #495057;">perceive what matters</strong>, <strong style="color: #495057;">prioritize
-                    what's critical</strong>, and <strong style="color: #495057;">protect what counts</strong>. No
-                vendor lock-in, no hidden costs—just effective, open-source vulnerability intelligence for everyone.</p>
-        </div>
-
-        <div class="row mb-4">
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light text-center">
-                    <div class="card-body">
-                        <span class="feature-icon">📊</span>
-                        <h5 class="card-title">Real-Time Analytics</h5>
-                        <p class="card-text">Live vulnerability intelligence with automated 6-hour refresh cycles and
-                            comprehensive statistical analysis.</p>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light text-center">
-                    <div class="card-body">
-                        <span class="feature-icon">🔍</span>
-                        <h5 class="card-title">Deep Insights</h5>
-                        <p class="card-text">Advanced CVSS analysis, CNA intelligence, CWE patterns, and growth trend
-                            identification across 27 years of data.</p>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light text-center">
-                    <div class="card-body">
-                        <span class="feature-icon">🚀</span>
-                        <h5 class="card-title">Free & Open</h5>
-                        <p class="card-text">Completely free platform democratizing cybersecurity intelligence for
-                            professionals, researchers, and organizations.</p>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<hr class="section-divider">
-
-<!-- Technical Architecture -->
-<div class="card feature-card mb-5">
-    <div class="card-header bg-primary text-white">
-        <h3 class="card-title mb-0">🏗️ Technical Architecture</h3>
-    </div>
-    <div class="card-body">
-        <div class="stats-highlight mb-4">
-            <h5 class="mb-3">🔧 Core Technology Stack</h5>
-            <div class="mb-3">
-                <span class="tech-badge">Python 3.9+</span>
-                <span class="tech-badge">Pandas</span>
-                <span class="tech-badge">NumPy</span>
-                <span class="tech-badge">Bootstrap 5</span>
-                <span class="tech-badge">Chart.js</span>
-                <span class="tech-badge">D3.js</span>
-                <span class="tech-badge">Jinja2</span>
-                <span class="tech-badge">GitHub Pages</span>
-            </div>
-        </div>
-
-        <div class="row mb-4">
-            <div class="col-lg-6 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">📊 Data Sources</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Primary:</strong> NIST National Vulnerability Database (NVD)</li>
-                            <li class="mb-2"><strong>Secondary:</strong> CVE Project V5 Repository</li>
-                            <li class="mb-2"><strong>Risk Signals:</strong> CISA Known Exploited Vulnerabilities (KEV)
-                                catalog</li>
-                            <li class="mb-2"><strong>Likelihood:</strong> FIRST Exploit Prediction Scoring System (EPSS)
-                            </li>
-                            <li class="mb-2"><strong>Coverage:</strong> 287,800+ CVEs across 27 years</li>
-                            <li class="mb-0"><strong>Validation:</strong> Multi-source cross-verification</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-6 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">⚙️ Processing Engine</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Architecture:</strong> Static site generation</li>
-                            <li class="mb-2"><strong>Analytics:</strong> Advanced statistical computation</li>
-                            <li class="mb-2"><strong>Storage:</strong> Optimized JSON serialization</li>
-                            <li class="mb-0"><strong>Updates:</strong> Automated 6-hour refresh cycles</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-        </div>
-
-        <div class="stats-highlight">
-            <h5 class="mb-3">📈 Statistical Analysis Framework</h5>
-            <div class="row">
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>Temporal Analysis:</strong> Time-series decomposition and trend
-                            identification</li>
-                        <li class="mb-2">✓ <strong>Distribution Analysis:</strong> CVSS score distributions and outlier
-                            detection</li>
-                    </ul>
-                </div>
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>Correlation Analysis:</strong> CWE-CVSS relationships and
-                            vulnerability clustering</li>
-                        <li class="mb-2">✓ <strong>Predictive Modeling:</strong> Growth forecasting and pattern
-                            prediction</li>
-                    </ul>
-                </div>
-            </div>
-        </div>
-    </div>
+<div class="ph"><h1>About</h1><span class="note">what this counts, and what it does not</span></div>
+<p class="lede">CVEDB counts CVEs. That is the whole product: how many were published this year,
+how many all time, and how those break down by publisher, product and weakness type. Nothing
+here is weighted, scored or prioritised by us.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Where the numbers come from</h2>
+<div class="panel"><div id="src-table"></div></div>
+
+<h2>How counting works</h2>
+<div class="cols c2">
+  <div class="panel">
+    <div class="panel-h">Counts that add up</div>
+    <div class="panel-b muted" style="font-size:13.5px;line-height:1.65">
+      <p>Each CVE is published by exactly one authority and belongs to exactly one year, so
+      <a href="years.html" style="color:var(--accent)">yearly</a> and
+      <a href="cna.html" style="color:var(--accent)">publisher</a> counts sum to the total.</p>
+      <p style="margin-top:9px">A day's count is the CVEs published that day. Publication is
+      bursty: a single publisher can file thousands at once, so daily figures swing hard.</p>
+    </div>
+  </div>
+  <div class="panel">
+    <div class="panel-h">Counts that do not</div>
+    <div class="panel-b muted" style="font-size:13.5px;line-height:1.65">
+      <p>A CVE can name many affected <a href="cpe.html" style="color:var(--accent)">products</a>,
+      so product counts sum to far more than the number of CVEs.</p>
+      <p style="margin-top:9px">A CVE can also hold a <a href="cvss.html" style="color:var(--accent)">CVSS</a>
+      score under several metric versions at once. The total scored figure counts scores, not
+      CVEs, which is why it can exceed the number of CVEs that exist.</p>
+      <p style="margin-top:9px">Not every CVE carries a
+      <a href="cwe.html" style="color:var(--accent)">weakness type</a>, so those counts cover a
+      subset.</p>
+    </div>
+  </div>
 </div>
 
-<!-- Data Quality & Coverage -->
-<div class="card feature-card mb-5">
-    <div class="card-header bg-success text-white">
-        <h3 class="card-title mb-0">📊 Data Quality & Coverage</h3>
-    </div>
-    <div class="card-body">
-        <div class="stats-highlight mb-4">
-            <h5 class="mb-3">📈 Coverage Statistics</h5>
-            <div class="row">
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>{{ total_cves|default('287,800+') }} CVE entries</strong> across {{
-                            available_years|length if available_years else '27' }} years (1999-{{ current_year if
-                            current_year else '2025' }})</li>
-                        <li class="mb-2">✓ <strong>{{ cvss_coverage|default('284,181') }} CVSS scored</strong>
-                            vulnerabilities</li>
-                    </ul>
-                </div>
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>{{ cwe_coverage|default('206,053') }} CWE classified</strong>
-                            weaknesses</li>
-                        <li class="mb-2">✓ <strong>{{ kev_coverage|default('1,463') }} known exploited CVEs</strong> in
-                            the CISA KEV catalog</li>
-                        <li class="mb-2">✓ <strong>{{ total_cnas|default('290') }} active CNAs</strong> with attribution
-                            data</li>
-                    </ul>
-                </div>
-            </div>
-        </div>
-
-        <div class="row mb-4">
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🎯 Dataset Completeness</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Comprehensive:</strong> Complete historical dataset</li>
-                            <li class="mb-2"><strong>Current:</strong> Real-time updates every 6 hours</li>
-                            <li class="mb-2"><strong>Validated:</strong> Multi-source cross-verification</li>
-                            <li class="mb-0"><strong>Accurate:</strong> 100% CNA classification accuracy</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🔍 Data Validation</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Integrity:</strong> Automated consistency checks</li>
-                            <li class="mb-2"><strong>Quality:</strong> Real-time freshness indicators</li>
-                            <li class="mb-2"><strong>Reliability:</strong> Graceful error handling</li>
-                            <li class="mb-0"><strong>Precision:</strong> Statistical accuracy controls</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">⚡ Processing Speed</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Optimized:</strong> High-performance data structures</li>
-                            <li class="mb-2"><strong>Cached:</strong> Smart caching mechanisms</li>
-                            <li class="mb-2"><strong>Scalable:</strong> Modular analysis pipeline</li>
-                            <li class="mb-0"><strong>Efficient:</strong> Compressed JSON serialization</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
+<h2>Freshness</h2>
+<div class="note-box" id="fresh-box">
+  The site rebuilds <b>hourly</b>. Its data comes from an upstream mirror of the NVD and CVE
+  Program records, so the site can never be fresher than that feed &mdash; both timestamps are
+  shown below and in the header.
 </div>
+<div class="grid g3" style="margin-top:12px" id="fresh-tiles"></div>
 
-<hr class="section-divider">
-
-<!-- Technical Implementation -->
-<div class="card feature-card mb-5">
-    <div class="card-header bg-info text-white">
-        <h3 class="card-title mb-0">⚙️ Technical Implementation</h3>
-    </div>
-    <div class="card-body">
-        <div class="stats-highlight mb-4">
-            <h5 class="mb-3">🏗️ Architecture Overview</h5>
-            <div class="row">
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>Static Site Generation</strong> with Python 3.9+ backend</li>
-                        <li class="mb-2">✓ <strong>7 Analysis Modules</strong> for comprehensive intelligence</li>
-                    </ul>
-                </div>
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>6 Intelligence Dashboards</strong> with interactive visualizations
-                        </li>
-                        <li class="mb-2">✓ <strong>Automated 6-hour</strong> refresh cycles</li>
-                    </ul>
-                </div>
-            </div>
-        </div>
-
-        <div class="row mb-4">
-            <div class="col-lg-6 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🐍 Backend Architecture</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Python 3.9+:</strong> Type hints and modern features</li>
-                            <li class="mb-2"><strong>Pandas/NumPy:</strong> Statistical computation engine</li>
-                            <li class="mb-2"><strong>Modular Pipeline:</strong> Dependency-managed analysis</li>
-                            <li class="mb-0"><strong>Performance:</strong> Optimized data structures</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-6 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🎨 Frontend Technology</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Bootstrap 5:</strong> Responsive design system</li>
-                            <li class="mb-2"><strong>Chart.js/D3.js:</strong> Interactive visualizations</li>
-                            <li class="mb-2"><strong>Vanilla JS:</strong> Modern ES6+ features</li>
-                            <li class="mb-0"><strong>Mobile-First:</strong> Responsive breakpoints</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<hr class="section-divider">
-
-<!-- Intelligence Dashboard Specifications -->
-<div class="card feature-card mb-5">
-    <div class="card-header bg-warning text-dark">
-        <h3 class="card-title mb-0">🎛️ Intelligence Dashboard Suite</h3>
-    </div>
-    <div class="card-body">
-        <div class="stats-highlight mb-4">
-            <h5 class="mb-3">📊 Dashboard Overview</h5>
-            <p class="mb-3">CVEDB provides six specialized intelligence dashboards, each implementing advanced
-                analytical methodologies for comprehensive vulnerability intelligence:</p>
-            <div class="row">
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>CNA Intelligence:</strong> 290 active numbering authorities</li>
-                        <li class="mb-2">✓ <strong>CVSS Analysis:</strong> Multi-version score distribution</li>
-                        <li class="mb-2">✓ <strong>CWE Classification:</strong> 68 unique weakness types</li>
-                    </ul>
-                </div>
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>CPE Technology:</strong> Vendor and platform analysis</li>
-                        <li class="mb-2">✓ <strong>Growth Intelligence:</strong> 27 years of trend analysis</li>
-                        <li class="mb-2">✓ <strong>Calendar Heatmap:</strong> Daily publication patterns</li>
-                    </ul>
-                </div>
-            </div>
-        </div>
-
-        <div class="row mb-4">
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🏢 <a href="/cna.html" class="text-decoration-none">CNA Intelligence</a>
-                        </h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Source:</strong> CVE Project V5 Repository</li>
-                            <li class="mb-2"><strong>Accuracy:</strong> 100% classification via authoritative data</li>
-                            <li class="mb-0"><strong>Analysis:</strong> Activity patterns and quality metrics</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🎯 <a href="/cvss.html" class="text-decoration-none">CVSS Analysis</a>
-                        </h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Versions:</strong> v2.0, v3.0, v3.1, v4.0 support</li>
-                            <li class="mb-2"><strong>Precision:</strong> 0.1-point score accuracy</li>
-                            <li class="mb-0"><strong>Coverage:</strong> 284,181 scored vulnerabilities</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🔍 <a href="/cwe.html" class="text-decoration-none">CWE Intelligence</a>
-                        </h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Taxonomy:</strong> MITRE CWE classification</li>
-                            <li class="mb-2"><strong>Coverage:</strong> 206,053 classified CVEs</li>
-                            <li class="mb-0"><strong>Analysis:</strong> Weakness pattern identification</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-        </div>
-
-        <div class="row mb-4">
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">💻 <a href="/cpe.html" class="text-decoration-none">CPE Technology</a>
-                        </h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Format:</strong> CPE 2.3 platform identifiers</li>
-                            <li class="mb-2"><strong>Analysis:</strong> Vendor risk assessment</li>
-                            <li class="mb-0"><strong>Impact:</strong> Technology vulnerability density</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">📈 <a href="/growth.html" class="text-decoration-none">Growth
-                                Intelligence</a></h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Modeling:</strong> Year-over-year growth analysis</li>
-                            <li class="mb-2"><strong>Methods:</strong> 3-year moving averages</li>
-                            <li class="mb-0"><strong>Precision:</strong> Day-of-year YTD calculations</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">📅 <a href="/calendar.html" class="text-decoration-none">Calendar
-                                Heatmap</a></h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Engine:</strong> Custom D3.js visualization</li>
-                            <li class="mb-2"><strong>Data:</strong> 7,658 days of historical data</li>
-                            <li class="mb-0"><strong>Features:</strong> Interactive year navigation</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<hr class="section-divider">
-
-<!-- Data Access & Export Capabilities -->
-<div class="card feature-card mb-5">
-    <div class="card-header bg-secondary text-white">
-        <h3 class="card-title mb-0">📡 Data Access & Export Capabilities</h3>
-    </div>
-    <div class="card-body">
-        <div class="stats-highlight mb-4">
-            <h5 class="mb-3">📊 Export & Integration</h5>
-            <div class="row">
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>CSV/JSON Export:</strong> Multiple format support with UTF-8 encoding
-                        </li>
-                        <li class="mb-2">✓ <strong>Real-time Access:</strong> Direct JSON endpoint integration</li>
-                    </ul>
-                </div>
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>6-hour Updates:</strong> Automated refresh cycles with timestamps
-                        </li>
-                        <li class="mb-2">✓ <strong>99.9% Uptime:</strong> Enterprise-grade availability</li>
-                    </ul>
-                </div>
-            </div>
-        </div>
-
-        <div class="row mb-4">
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">📊 Export Formats</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>CSV:</strong> Tabular data with proper delimiters</li>
-                            <li class="mb-2"><strong>JSON:</strong> Structured data with nested objects</li>
-                            <li class="mb-2"><strong>Bulk Downloads:</strong> Complete dataset exports</li>
-                            <li class="mb-0"><strong>Filtered:</strong> Subset data extraction</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🔄 Data Freshness</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Updates:</strong> 6-hour automated cycles</li>
-                            <li class="mb-2"><strong>Timestamps:</strong> Precise freshness indicators</li>
-                            <li class="mb-2"><strong>Detection:</strong> Incremental delta processing</li>
-                            <li class="mb-0"><strong>Validation:</strong> Automated consistency checks</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🔗 Integration</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>REST-like:</strong> Direct JSON file access</li>
-                            <li class="mb-2"><strong>CORS:</strong> Cross-origin resource sharing</li>
-                            <li class="mb-2"><strong>Caching:</strong> HTTP optimization headers</li>
-                            <li class="mb-0"><strong>Security:</strong> HTTPS-only with headers</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<hr class="section-divider">
-
-<!-- Statistical Methodology & Scoring -->
-<div class="card feature-card mb-5">
-    <div class="card-header bg-dark text-white">
-        <h3 class="card-title mb-0">🧮 Statistical Methodology & Scoring</h3>
-    </div>
-    <div class="card-body">
-        <div class="stats-highlight mb-4">
-            <h5 class="mb-3">📊 Analytical Rigor</h5>
-            <div class="row">
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>Advanced Statistics:</strong> Descriptive and inferential analysis
-                        </li>
-                        <li class="mb-2">✓ <strong>Multi-version CVSS:</strong> Precision score extraction and mapping
-                        </li>
-                    </ul>
-                </div>
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>Validation Framework:</strong> Cross-source integrity checks</li>
-                        <li class="mb-2">✓ <strong>Transparency:</strong> Reproducible methodologies</li>
-                    </ul>
-                </div>
-            </div>
-        </div>
-
-        <div class="row mb-4">
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">📊 Statistical Methods</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Descriptive:</strong> Mean, median, standard deviation</li>
-                            <li class="mb-2"><strong>Distribution:</strong> Histogram binning, percentiles</li>
-                            <li class="mb-2"><strong>Trend Analysis:</strong> Regression, moving averages</li>
-                            <li class="mb-0"><strong>Time Series:</strong> Pattern identification</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🎯 Scoring Algorithms</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>CVSS Parsing:</strong> Multi-version extraction</li>
-                            <li class="mb-2"><strong>Severity Mapping:</strong> Version-specific thresholds</li>
-                            <li class="mb-2"><strong>Normalization:</strong> Cross-version standardization</li>
-                            <li class="mb-0"><strong>Quality Metrics:</strong> Completeness indicators</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-4 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">✓ Validation Framework</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Data Integrity:</strong> Cross-source validation</li>
-                            <li class="mb-2"><strong>Statistical:</strong> Outlier detection</li>
-                            <li class="mb-2"><strong>Temporal:</strong> Chronological consistency</li>
-                            <li class="mb-0"><strong>Quality Scoring:</strong> Confidence intervals</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-        </div>
-
-        <div class="alert alert-info">
-            <h6><strong>Transparency Note:</strong></h6>
-            <p class="mb-0">All statistical calculations, data processing methodologies, and scoring algorithms used in
-                CVEDB are designed for transparency and reproducibility. The platform prioritizes accuracy,
-                consistency, and scientific rigor in vulnerability intelligence analysis.</p>
-        </div>
-    </div>
-</div>
-</ul>
-</div>
-</div>
-</div>
-<div class="col-md-6">
-    <div class="card h-100">
-        <div class="card-header">
-            <h4 class="card-title mb-0">🚀 Performance & Scalability</h4>
-        </div>
-        <div class="card-body">
-            <ul class="list-unstyled">
-                <li class="mb-2"><strong>⚡ Fast Loading:</strong> Optimized static assets and caching</li>
-                <li class="mb-2"><strong>📊 Efficient Processing:</strong> Incremental data updates</li>
-                <li class="mb-2"><strong>🔄 Auto-Scaling:</strong> Self-expanding system architecture</li>
-                <li class="mb-2"><strong>💾 Data Optimization:</strong> Compressed JSON data delivery</li>
-                <li class="mb-2"><strong>🌐 CDN Ready:</strong> Static site deployment optimized</li>
-                <li class="mb-2"><strong>📱 Cross-Platform:</strong> Universal browser compatibility</li>
-            </ul>
-        </div>
-    </div>
-</div>
-</div>
-
-<hr class="section-divider">
-
-<!-- Use Cases & Applications -->
-<div class="card feature-card mb-5">
-    <div class="card-header bg-success text-white">
-        <h3 class="card-title mb-0">🎯 Use Cases & Applications</h3>
-    </div>
-    <div class="card-body">
-        <div class="stats-highlight mb-4">
-            <h5 class="mb-3">👥 Target Audiences</h5>
-            <div class="row">
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>Security Teams:</strong> Threat landscape analysis and risk
-                            assessment</li>
-                        <li class="mb-2">✓ <strong>Researchers:</strong> Academic studies and statistical analysis</li>
-                    </ul>
-                </div>
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>Organizations:</strong> Enterprise risk management and compliance
-                        </li>
-                        <li class="mb-2">✓ <strong>Analysts:</strong> Market intelligence and trend reporting</li>
-                    </ul>
-                </div>
-            </div>
-        </div>
-
-        <div class="row mb-4">
-            <div class="col-lg-3 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🛡️ Security Teams</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Threat Analysis:</strong> Landscape monitoring</li>
-                            <li class="mb-2"><strong>Risk Assessment:</strong> Vulnerability trends</li>
-                            <li class="mb-0"><strong>Posture Evaluation:</strong> Security metrics</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-3 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🔬 Researchers</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Academic Research:</strong> Vulnerability studies</li>
-                            <li class="mb-2"><strong>Statistical Analysis:</strong> Data projects</li>
-                            <li class="mb-0"><strong>Publications:</strong> Data sourcing</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-3 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🏢 Organizations</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Risk Management:</strong> Enterprise security</li>
-                            <li class="mb-2"><strong>Compliance:</strong> Reporting requirements</li>
-                            <li class="mb-0"><strong>Vendor Assessment:</strong> Technology analysis</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-3 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">📊 Analysts</h5>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Market Intelligence:</strong> Industry insights</li>
-                            <li class="mb-2"><strong>Competitive Analysis:</strong> Trend reporting</li>
-                            <li class="mb-0"><strong>Data-Driven:</strong> Strategic insights</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-
-
-<!-- Contact & Support -->
-<div class="card feature-card mb-5">
-    <div class="card-header bg-primary text-white">
-        <h3 class="card-title mb-0">📞 Contact & Support</h3>
-    </div>
-    <div class="card-body">
-        <div class="stats-highlight mb-4">
-            <h5 class="mb-3">🌐 Community Platform</h5>
-            <div class="row">
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>Open Platform:</strong> Serving the cybersecurity community</li>
-                        <li class="mb-2">✓ <strong>Operational Status:</strong> Continuously updated</li>
-                    </ul>
-                </div>
-                <div class="col-md-6">
-                    <ul class="list-unstyled">
-                        <li class="mb-2">✓ <strong>6-hour Updates:</strong> Fresh data every cycle</li>
-                        <li class="mb-2">✓ <strong>Community Driven:</strong> Feedback welcome</li>
-                    </ul>
-                </div>
-            </div>
-        </div>
-
-        <div class="row mb-4">
-            <div class="col-lg-6 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">💬 Community & Support</h5>
-                        <p class="mb-3">CVEDB is an open platform designed to serve the cybersecurity community. The
-                            platform welcomes feedback, suggestions, and collaboration opportunities.</p>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>GitHub Repository:</strong> <a
-                                    href="https://github.com/cvedb/cvedb.github.io" target="_blank"
-                                    class="text-decoration-none">cvedb/cvedb.github.io</a></li>
-                            <li class="mb-2"><strong>Issues & Feedback:</strong> <a
-                                    href="https://github.com/cvedb/cvedb.github.io/issues" target="_blank"
-                                    class="text-decoration-none">Report Issues</a></li>
-                            <li class="mb-0"><strong>Status:</strong> Operational with 6-hour updates</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-            <div class="col-lg-6 mb-4">
-                <div class="card h-100 border-0 bg-light">
-                    <div class="card-body">
-                        <h5 class="card-title">🤝 Contributing</h5>
-                        <p class="mb-3">Interested in contributing to CVEDB? The platform continuously seeks ways to
-                            improve functionality and expand analytical capabilities.</p>
-                        <ul class="list-unstyled">
-                            <li class="mb-2"><strong>Pull Requests:</strong> <a
-                                    href="https://github.com/cvedb/cvedb.github.io/pulls" target="_blank"
-                                    class="text-decoration-none">Submit PRs</a></li>
-                            <li class="mb-2"><strong>Discussions:</strong> <a
-                                    href="https://github.com/cvedb/cvedb.github.io/discussions" target="_blank"
-                                    class="text-decoration-none">Join Discussions</a></li>
-                            <li class="mb-2"><strong>Documentation:</strong> <a
-                                    href="https://github.com/cvedb/cvedb.github.io/blob/main/README.md" target="_blank"
-                                    class="text-decoration-none">View README</a></li>
-                            <li class="mb-0"><strong>License:</strong> <a
-                                    href="https://github.com/cvedb/cvedb.github.io/blob/main/LICENSE" target="_blank"
-                                    class="text-decoration-none">Open Source</a></li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-        </div>
-
-        <div class="alert alert-info mt-4"
-            style="background-color: rgba(13, 110, 253, 0.1); border: 1px solid rgba(13, 110, 253, 0.2); border-radius: 0.5rem;">
-            <h6 class="alert-heading">🚀 Automated Intelligence Platform</h6>
-            <p class="mb-0">CVEDB operates on a fully automated infrastructure that ensures continuous data
-                availability and seamless expansion. The system is engineered to automatically incorporate new
-                vulnerability data as it becomes available, requiring zero manual intervention for ongoing operations.
-            </p>
-        </div>
-    </div>
+<h2>Using the data</h2>
+<div class="note-box">
+  Every number on this site is read from a JSON file you can fetch directly at
+  <code>cvedb.github.io/data/</code>. No key, no rate limit, no registration. If you want the counts
+  rather than the pages, start there.
 </div>
 
-<!-- Add bottom spacing -->
-<div class="mb-5"></div>
-{% endblock %}
\ No newline at end of file
+<h2>Built with</h2>
+<div class="panel"><div class="panel-b muted" style="font-size:13.5px;line-height:1.7">
+  Python builds the data and renders static pages with Jinja. The pages ship no charting
+  library &mdash; the charts here are counts, and counts draw fine with SVG and CSS.
+  Hosted on GitHub Pages. Source is on
+  <a href="https://github.com/cvedb/cvedb.github.io" style="color:var(--accent)" rel="noopener">GitHub</a>.
+</div></div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+CVE.page(async (S) => {
+  const { fmt, el, table } = CVE;
+  const years = Object.values(S.yearly_summary.years);
+  const total = years.reduce((s, y) => s + y.total_cves, 0);
+  const YR = {{ current_year }};
+  const ytd = (years.find(y => y.year === YR) || {}).total_cves || 0;
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'CVEs counted', v: fmt.n(total),
+      sub: `across <b>${years.length}</b> years, 1999&ndash;${YR}` },
+    { lbl: `Published in ${YR}`, v: fmt.n(ytd), sub: 'so far this year' },
+    { lbl: 'Publishers', v: fmt.n(S.cna_analysis.total_cnas),
+      sub: `<b>${fmt.n(S.cna_analysis.active_cnas)}</b> active` },
+    { lbl: 'In the KEV catalog', v: fmt.n(S.cvss_analysis.kev_global_count),
+      sub: `<b>${fmt.share(S.cvss_analysis.kev_global_count, total, 2)}</b> of all CVEs` }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  table('#src-table', [
+    { what: 'CVE records', who: 'CVE Program / NVD', how: 'every count on the site',
+      freq: 'continuous' },
+    { what: 'EPSS scores', who: 'FIRST.org', how: 'exploit probability bands',
+      freq: 'daily' },
+    { what: 'KEV catalog', who: 'CISA', how: 'known-exploited counts',
+      freq: 'a few times a week' },
+    { what: 'CNA registry', who: 'CVE Program', how: 'publisher name matching',
+      freq: 'occasional' }
+  ], [
+    { key: 'what', label: 'Data' },
+    { key: 'who', label: 'Source' },
+    { key: 'how', label: 'Used for' },
+    { key: 'freq', label: 'Updated' }
+  ], { sort: { key: 'what', dir: 1 }, name: 'cve-icu-data-sources' });
+
+  el('#fresh-tiles').innerHTML = [
+    { lbl: 'Data as of', v: `<span data-asof>&mdash;</span>`, sub: 'newest record in this build' },
+    { lbl: 'Rebuilt', v: '<span data-built>&mdash;</span>', sub: 'when this build last ran' },
+    { lbl: 'Upstream feed ran', v: '<span data-srcrun>&mdash;</span>',
+      sub: 'the ceiling on freshness' }
+  ].map(t => `<div class="c"><div class="lbl">${t.lbl}</div>
+      <div class="v" style="font-size:20px;font-family:var(--sans);font-weight:650">${t.v}</div>
+      <div class="sub">${t.sub}</div></div>`).join('');
+  CVE.freshness(S);
+});
+</script>
+{% endblock %}
diff --git a/templates/base.html b/templates/base.html
index 1a498ae7fdb..259179733c4 100644
--- a/templates/base.html
+++ b/templates/base.html
@@ -1,456 +1,120 @@
 <!DOCTYPE html>
 <html lang="en">
-
 <head>
-    <meta charset="UTF-8">
-    <meta name="viewport"
-        content="width=device-width, initial-scale=1.0, maximum-scale=5.0, user-scalable=yes, viewport-fit=cover">
-    <title>{% block title %}CVEDB - CVE Analysis Dashboard{% endblock %}</title>
-
-    <!-- Google tag (gtag.js) -->
-    <script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
-    <script>
-        window.dataLayer = window.dataLayer || [];
-        function gtag() { dataLayer.push(arguments); }
-        gtag('js', new Date());
-
-        gtag('config', 'G-W0CE61HN2F');
-    </script>
-
-    <!-- Google Fonts - Inter -->
-    <link rel="preconnect" href="https://fonts.googleapis.com">
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
-
-    <!-- Favicon -->
-    <link rel="icon" type="image/x-icon" href="static/images/logo.png">
-
-    <!-- Stylesheet -->
-    <link rel="stylesheet" href="static/css/style.css">
-
-    <!-- Meta tags for SEO -->
-    <meta name="description"
-        content="{% block description %}CVEDB provides comprehensive analysis and visualization of Common Vulnerabilities and Exposures (CVE) data from 1999 to present.{% endblock %}">
-    <meta name="keywords" content="CVE, vulnerabilities, security, analysis, dashboard, cybersecurity">
-    <meta name="author" content="CVEDB">
-
-    <!-- Mobile-specific meta tags -->
-    <meta name="theme-color" content="#0d6efd">
-    <meta name="apple-mobile-web-app-capable" content="yes">
-    <meta name="apple-mobile-web-app-status-bar-style" content="default">
-    <meta name="apple-mobile-web-app-title" content="CVEDB">
-    <meta name="format-detection" content="telephone=no">
-
-    <!-- Open Graph tags -->
-    <meta property="og:title" content="{% block og_title %}CVEDB - CVE Analysis Dashboard{% endblock %}">
-    <meta property="og:description"
-        content="{% block og_description %}Comprehensive CVE analysis and visualization from 1999 to present{% endblock %}">
-    <meta property="og:type" content="website">
-    <meta property="og:url" content="https://cvedb.github.io">
-    <meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>{% block title %}CVEDB{% endblock %}</title>
+
+<meta name="description" content="{% block description %}Counts and statistics for every CVE published from 1999 to {{ current_year }}. Updated hourly.{% endblock %}">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="{% block og_title %}CVEDB{% endblock %}">
+<meta property="og:description" content="{% block og_description %}Counts and statistics for every CVE published from 1999 to {{ current_year }}.{% endblock %}">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v={{ asset_version }}">
+
+<!-- Page-specific head content (styles, preloads) -->
+{% block head %}{% endblock %}
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
 </head>
-
 <body>
-    <!-- Header and Navigation -->
-    <header class="header">
-        <div class="nav-container">
-            <a href="index.html" class="logo">
-                <img src="static/images/logo.png" alt="CVEDB Logo">
-                CVEDB
-            </a>
-
-            <nav class="nav">
-                <ul class="nav-menu">
-                    <li><a href="index.html">Home</a></li>
-                    <li><a href="years.html">Yearly Analysis</a></li>
-                    <li class="nav-dropdown">
-                        <a href="cna-hub.html" class="dropdown-toggle">CNA</a>
-                        <ul class="dropdown-menu">
-                            <li><a href="cna.html">CNA Intelligence</a></li>
-                            <li><a href="data-quality.html">Name Matching</a></li>
-                        </ul>
-                    </li>
-                    <li><a href="cpe.html">CPE</a></li>
-                    <li><a href="cwe.html">CWE</a></li>
-                    <li class="nav-dropdown">
-                        <a href="scoring.html" class="dropdown-toggle">Scoring</a>
-                        <ul class="dropdown-menu">
-                            <li><a href="cvss.html">CVSS</a></li>
-                            <li><a href="epss.html">EPSS</a></li>
-                            <li><a href="kev.html">KEV</a></li>
-                        </ul>
-                    </li>
-                    <li><a href="growth.html">Growth</a></li>
-                    <li><a href="calendar.html">Calendar</a></li>
-                </ul>
-                <button class="nav-toggle" aria-label="Toggle navigation">
-                    <span></span>
-                    <span></span>
-                    <span></span>
-                </button>
-            </nav>
-        </div>
-    </header>
-
-    <!-- Main Content -->
-    <main class="container">
-        {% block content %}
-        <!-- Page-specific content will be inserted here -->
-        {% endblock %}
-    </main>
-
-    <!-- Footer -->
-    <footer class="footer">
-        <div class="container">
-            <div style="display: flex; flex-wrap: wrap; gap: 2rem; justify-content: space-between;">
-                <div style="flex: 1; min-width: 200px;">
-                    <p class="mb-1"><strong>Data Sources:</strong></p>
-                    <p class="text-muted small mb-0">
-                        <a href="https://nvd.nist.gov/" target="_blank" class="text-decoration-none">National
-                            Vulnerability Database (NVD)</a><br>
-                        <a href="https://cve.org/" target="_blank" class="text-decoration-none">CVE Program</a><br>
-                        Last updated: <span id="lastUpdated">{{ last_updated if last_updated else 'Loading...' }}</span>
-                    </p>
-                </div>
-                <div style="flex: 1; min-width: 200px; text-align: right;">
-                    <p class="mb-1"><strong>Platform Links:</strong></p>
-                    <p class="text-muted small mb-0">
-                        <a href="about.html" class="text-decoration-none">About CVEDB</a><br>
-                        <a href="https://cvedb.github.io" target="_blank" class="text-decoration-none">CNA
-                            Scorecard</a><br>
-                        <a href="https://cveforecast.org" target="_blank" class="text-decoration-none">CVE
-                            Forecast</a><br>
-                        <a href="https://github.com/cvedb/cvedb.github.io" target="_blank"
-                            class="text-decoration-none">GitHub Repository</a>
-                    </p>
-                </div>
-            </div>
-            <hr class="my-2">
-            <div class="text-center">
-                <small class="text-muted">
-                    &copy; {{ current_year if current_year else '2025' }} CVEDB • Built by <a
-                        href="https://cvedb.github.io" target="_blank" class="text-decoration-none">CVEDB</a><br>
-                    Data updated every 6 hours • CVE coverage: 1999-{{ current_year if current_year else '2025' }}
-                </small>
-            </div>
-        </div>
-    </footer>
-
-    <!-- Chart.js Library (UMD version) -->
-    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
-
-    <!-- D3.js for advanced visualizations -->
-    <script src="https://d3js.org/d3.v7.min.js"></script>
-
-    <!-- Universal timestamp loader -->
-    <script>
-        // Universal function to load and display the last updated timestamp
-        // Uses cve_all.json as the single source of truth for all pages
-        function loadUniversalTimestamp() {
-            const lastUpdatedElement = document.getElementById('lastUpdated');
-            if (!lastUpdatedElement) return;
-
-            fetch('data/cve_all.json?v=' + new Date().getTime())
-                .then(response => response.json())
-                .then(data => {
-                    if (data.generated_at) {
-                        const date = new Date(data.generated_at);
-                        const options = {
-                            year: 'numeric',
-                            month: 'short',
-                            day: 'numeric',
-                            hour: '2-digit',
-                            minute: '2-digit',
-                            hour12: false, // Use 24-hour clock
-                            timeZone: 'UTC', // Always show UTC
-                            timeZoneName: 'short'
-                        };
-                        const formattedDate = date.toLocaleString('en-US', options);
-                        lastUpdatedElement.textContent = formattedDate;
-                    } else {
-                        lastUpdatedElement.textContent = 'Unknown';
-                    }
-                })
-                .catch(error => {
-                    console.error('Error loading timestamp:', error);
-                    lastUpdatedElement.textContent = 'Error loading timestamp';
-                });
-        }
-
-        // Load timestamp when DOM is ready
-        document.addEventListener('DOMContentLoaded', function () {
-            loadUniversalTimestamp();
-        });
-    </script>
-
-    <!-- Mobile Navigation Enhancement -->
-    <script>
-        // Enhanced mobile navigation toggle
-        document.addEventListener('DOMContentLoaded', function () {
-            const navToggle = document.querySelector('.nav-toggle');
-            const navMenu = document.querySelector('.nav-menu');
-
-            if (navToggle && navMenu) {
-                navToggle.addEventListener('click', function () {
-                    navMenu.classList.toggle('active');
-
-                    // Prevent body scroll when menu is open
-                    if (navMenu.classList.contains('active')) {
-                        document.body.style.overflow = 'hidden';
-                    } else {
-                        document.body.style.overflow = '';
-                    }
-                });
-
-                // Close menu when clicking outside
-                document.addEventListener('click', function (event) {
-                    const isClickInside = navToggle.contains(event.target) || navMenu.contains(event.target);
-
-                    if (!isClickInside && navMenu.classList.contains('active')) {
-                        navMenu.classList.remove('active');
-                        document.body.style.overflow = '';
-                    }
-                });
-
-                // Close menu when a nav link is clicked
-                const navLinks = navMenu.querySelectorAll('a');
-                navLinks.forEach(link => {
-                    link.addEventListener('click', function () {
-                        navMenu.classList.remove('active');
-                        document.body.style.overflow = '';
-                    });
-                });
-            }
-        });
-    </script>
-
-    <!-- Custom JavaScript -->
-    <script>
-        // Wait for Chart.js to load before configuring
-        document.addEventListener('DOMContentLoaded', function () {
-            if (typeof Chart !== 'undefined') {
-                // Global configuration for Chart.js with design system
-                Chart.defaults.responsive = true;
-                Chart.defaults.maintainAspectRatio = false;
-                Chart.defaults.plugins.legend.position = 'top';
-                Chart.defaults.plugins.legend.labels.usePointStyle = true;
-                Chart.defaults.plugins.legend.labels.padding = 20;
-                Chart.defaults.plugins.legend.labels.font = {
-                    family: 'Inter, sans-serif',
-                    size: 12,
-                    weight: '500'
-                };
-                Chart.defaults.plugins.title.display = true;
-                Chart.defaults.plugins.title.font = {
-                    family: 'Inter, sans-serif',
-                    size: 16,
-                    weight: '600'
-                };
-                Chart.defaults.plugins.title.color = '#212529';
-                Chart.defaults.plugins.tooltip.backgroundColor = 'rgba(255, 255, 255, 0.95)';
-                Chart.defaults.plugins.tooltip.titleColor = '#212529';
-                Chart.defaults.plugins.tooltip.bodyColor = '#6c757d';
-                Chart.defaults.plugins.tooltip.borderColor = '#dee2e6';
-                Chart.defaults.plugins.tooltip.borderWidth = 1;
-                Chart.defaults.plugins.tooltip.cornerRadius = 8;
-                Chart.defaults.plugins.tooltip.titleFont = {
-                    family: 'Inter, sans-serif',
-                    size: 13,
-                    weight: '600'
-                };
-                Chart.defaults.plugins.tooltip.bodyFont = {
-                    family: 'Inter, sans-serif',
-                    size: 12,
-                    weight: '400'
-                };
-                // Chart.js v4 scale configuration
-                Chart.defaults.elements.point.backgroundColor = '#2196f3';
-                Chart.defaults.elements.point.borderColor = '#2196f3';
-                Chart.defaults.elements.line.borderColor = '#2196f3';
-                Chart.defaults.elements.bar.backgroundColor = '#2196f3';
-
-                // Note: Scale-specific defaults are set per chart type in Chart.js v4
-                // Global scale defaults are handled differently
-            }
-
-            // Add active class to current page navigation link
-            const currentPage = window.location.pathname.split('/').pop() || 'index.html';
-            const navLinks = document.querySelectorAll('.nav-menu a');
-
-            navLinks.forEach(link => {
-                const href = link.getAttribute('href');
-                if (href === currentPage || (currentPage === '' && href === 'index.html')) {
-                    link.classList.add('active');
-                }
-            });
-        });
-
-        // Enhanced Color palette for consistent styling (Light Blue to Grey)
-        window.CVE_COLORS = window.CVE_COLORS || {
-            primary: '#2196f3',
-            secondary: '#64b5f6',
-            success: '#81c784',
-            warning: '#ffb74d',
-            danger: '#f06292',
-            light: '#f8f9fa',
-            dark: '#212529',
-
-            // Light Blue to Grey Visualization Palette
-            vizColors: [
-                '#e3f2fd', // Very light blue
-                '#bbdefb', // Light blue
-                '#90caf9', // Medium light blue
-                '#64b5f6', // Medium blue
-                '#42a5f5', // Blue
-                '#2196f3', // Primary blue
-                '#1e88e5', // Darker blue
-                '#1976d2', // Dark blue
-                '#9e9e9e', // Medium grey
-                '#757575'  // Dark grey
-            ],
-
-            // Chart-specific colors
-            chartColors: [
-                '#2196f3', // Primary blue
-                '#64b5f6', // Secondary blue
-                '#90caf9', // Tertiary blue
-                '#bbdefb', // Quaternary blue
-                '#81c784', // Accent green
-                '#ffb74d', // Accent orange
-                '#f06292', // Accent pink
-                '#e0e0e0', // Light grey
-                '#9e9e9e', // Medium grey
-                '#616161'  // Dark grey
-            ],
-
-            // Gradient colors for backgrounds
-            gradients: {
-                primary: 'linear-gradient(135deg, #e3f2fd, #bbdefb)',
-                secondary: 'linear-gradient(135deg, #bbdefb, #90caf9)',
-                tertiary: 'linear-gradient(135deg, #90caf9, #64b5f6)'
-            }
-        };
-
-        // Enhanced utility function to generate colors for charts
-        function getChartColors(count, type = 'chart') {
-            const colors = [];
-            const palette = type === 'viz' ? CVE_COLORS.vizColors : CVE_COLORS.chartColors;
-
-            for (let i = 0; i < count; i++) {
-                colors.push(palette[i % palette.length]);
-            }
-            return colors;
-        }
-
-        // Generate light blue to grey gradient colors
-        function getGradientColors(count) {
-            const colors = [];
-            for (let i = 0; i < count; i++) {
-                const ratio = i / Math.max(count - 1, 1);
-                // Interpolate between light blue and grey
-                const r = Math.round(227 + (158 - 227) * ratio); // e3 to 9e
-                const g = Math.round(242 + (158 - 242) * ratio); // f2 to 9e
-                const b = Math.round(253 + (158 - 253) * ratio); // fd to 9e
-                colors.push(`rgb(${r}, ${g}, ${b})`);
-            }
-            return colors;
-        }
-
-        // Get color with opacity
-        function getColorWithOpacity(color, opacity = 0.8) {
-            if (color.startsWith('#')) {
-                const r = parseInt(color.slice(1, 3), 16);
-                const g = parseInt(color.slice(3, 5), 16);
-                const b = parseInt(color.slice(5, 7), 16);
-                return `rgba(${r}, ${g}, ${b}, ${opacity})`;
-            }
-            return color;
-        }
-
-        // Utility function to format numbers
-        function formatNumber(num) {
-            if (num >= 1000000) {
-                return (num / 1000000).toFixed(1) + 'M';
-            } else if (num >= 1000) {
-                return (num / 1000).toFixed(1) + 'K';
-            }
-            return num.toString();
-        }
-
-        // Utility function to show loading state
-        function showLoading(containerId) {
-            const container = document.getElementById(containerId);
-            if (container) {
-                container.innerHTML = '<div class="loading"><div class="spinner"></div>Loading data...</div>';
-            }
-        }
-
-        // Utility function to hide loading state
-        function hideLoading(containerId) {
-            const container = document.getElementById(containerId);
-            if (container) {
-                const loading = container.querySelector('.loading');
-                if (loading) {
-                    loading.remove();
-                }
-            }
-        }
-
-        // Get current year for dynamic functionality
-        const CURRENT_YEAR = new Date().getFullYear();
-        const AVAILABLE_YEARS = [];
-        for (let year = 1999; year <= CURRENT_YEAR; year++) {
-            AVAILABLE_YEARS.push(year);
-        }
-
-        // Mobile table enhancement - add touch scroll indicators
-        function enhanceMobileTable(tableContainer) {
-            if (window.innerWidth <= 768 && tableContainer) {
-                const table = tableContainer.querySelector('table');
-                if (table && table.scrollWidth > tableContainer.clientWidth) {
-                    tableContainer.style.overflowX = 'auto';
-                    tableContainer.style.webkitOverflowScrolling = 'touch';
-
-                    // Add scroll shadow indicators
-                    tableContainer.addEventListener('scroll', function () {
-                        const scrollLeft = this.scrollLeft;
-                        const maxScroll = this.scrollWidth - this.clientWidth;
-
-                        if (scrollLeft > 0) {
-                            this.classList.add('scrolled-left');
-                        } else {
-                            this.classList.remove('scrolled-left');
-                        }
-
-                        if (scrollLeft < maxScroll - 1) {
-                            this.classList.add('scrolled-right');
-                        } else {
-                            this.classList.remove('scrolled-right');
-                        }
-                    });
-                }
-            }
-        }
-
-        // Apply mobile table enhancements on load
-        document.addEventListener('DOMContentLoaded', function () {
-            const tableContainers = document.querySelectorAll('.table-container');
-            tableContainers.forEach(enhanceMobileTable);
-
-            // Re-apply on window resize
-            let resizeTimer;
-            window.addEventListener('resize', function () {
-                clearTimeout(resizeTimer);
-                resizeTimer = setTimeout(function () {
-                    tableContainers.forEach(enhanceMobileTable);
-                }, 250);
-            });
-        });
-    </script>
-
-    {% block scripts %}
-    <!-- Page-specific JavaScript will be inserted here -->
-    {% endblock %}
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    {% if nav == 'home'    %}class="on" aria-current="page"{% endif %}>Home</a></li>
+    <li><a href="years.html"    {% if nav == 'years'   %}class="on" aria-current="page"{% endif %}>Years</a></li>
+    <li><a href="calendar.html" {% if nav == 'calendar'%}class="on" aria-current="page"{% endif %}>Calendar</a></li>
+    <li><a href="cna.html"      {% if nav == 'cna'     %}class="on" aria-current="page"{% endif %}>Publishers</a></li>
+    <li><a href="cpe.html"      {% if nav == 'cpe'     %}class="on" aria-current="page"{% endif %}>Products</a></li>
+    <li><a href="cwe.html"      {% if nav == 'cwe'     %}class="on" aria-current="page"{% endif %}>Weaknesses</a></li>
+    <li><a href="scoring.html"  {% if nav == 'scoring' %}class="on" aria-current="page"{% endif %}>Scoring</a></li>
+    <li><a href="about.html"    {% if nav == 'about'   %}class="on" aria-current="page"{% endif %}>About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+{% block content %}{% endblock %}
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; {{ current_year }}
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v={{ asset_version }}"></script>
+{% block scripts %}{% endblock %}
 </body>
-
-</html>
\ No newline at end of file
+</html>
diff --git a/templates/calendar.html b/templates/calendar.html
index 248faae345b..bd07c42c759 100644
--- a/templates/calendar.html
+++ b/templates/calendar.html
@@ -1,961 +1,85 @@
 {% extends "base.html" %}
-
-{% block title %}{{ title }}{% endblock %}
-
-{% block head %}
-<!-- Custom Calendar Heatmap CSS -->
-<style>
-/* Calendar-specific styles */
-.calendar-container {
-    background: white;
-    border-radius: 12px;
-    padding: 2rem;
-    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
-    margin-bottom: 2rem;
-}
-
-.calendar-header {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    margin-bottom: 1.5rem;
-    flex-wrap: wrap;
-    gap: 1rem;
-}
-
-.calendar-title {
-    font-size: 1.5rem;
-    font-weight: 600;
-    color: var(--color-text-primary);
-    margin: 0;
-}
-
-.calendar-controls {
-    display: flex;
-    gap: 0.5rem;
-    align-items: center;
-}
-
-.calendar-nav-btn {
-    background: var(--color-primary);
-    color: white;
-    border: none;
-    border-radius: 6px;
-    padding: 0.5rem 1rem;
-    font-size: 0.875rem;
-    cursor: pointer;
-    transition: all 0.2s;
-}
-
-.calendar-nav-btn:hover {
-    background: var(--color-primary-dark);
-    transform: translateY(-1px);
-}
-
-.calendar-nav-btn:disabled {
-    background: #ccc;
-    cursor: not-allowed;
-    transform: none;
-}
-
-.year-selector {
-    background: white;
-    border: 2px solid var(--color-border);
-    border-radius: 6px;
-    padding: 0.5rem;
-    font-size: 0.875rem;
-    color: var(--color-text-primary);
-}
-
-.calendar-legend {
-    display: flex;
-    align-items: center;
-    gap: 1rem;
-    margin-top: 1rem;
-    font-size: 0.875rem;
-    color: var(--color-text-secondary);
-}
-
-.legend-scale {
-    display: flex;
-    align-items: center;
-    gap: 0.5rem;
-}
-
-.legend-item {
-    width: 12px;
-    height: 12px;
-    border-radius: 2px;
-}
-
-/* Custom D3 Calendar Heatmap Styles */
-.calendar-heatmap {
-    font-family: var(--font-family);
-}
-
-.calendar-heatmap .month {
-    fill: none;
-    stroke: #fff;
-    stroke-width: 1px;
-}
-
-.calendar-heatmap .day {
-    fill: #ebedf0;
-    stroke: #fff;
-    stroke-width: 1px;
-    cursor: pointer;
-}
-
-.calendar-heatmap .day:hover {
-    stroke: #333;
-    stroke-width: 2px;
-}
-
-.calendar-heatmap .month-label {
-    fill: var(--color-text-primary);
-    font-size: 12px;
-    font-weight: 500;
-}
-
-.calendar-heatmap .day-label {
-    fill: var(--color-text-secondary);
-    font-size: 10px;
-}
-
-/* Tooltip styling */
-.calendar-tooltip {
-    position: absolute;
-    background: rgba(0, 0, 0, 0.8);
-    color: white;
-    padding: 8px 12px;
-    border-radius: 4px;
-    font-size: 12px;
-    pointer-events: none;
-    opacity: 0;
-    transition: opacity 0.2s;
-    z-index: 1000;
-}
-
-.calendar-tooltip.show {
-    opacity: 1;
-}
-
-.calendar-legend {
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    margin-top: 20px;
-}
-
-.legend-container {
-    display: flex;
-    align-items: center;
-    gap: 8px;
-}
-
-.legend-colors {
-    display: flex;
-    gap: 2px;
-}
-
-.legend-color {
-    width: 12px;
-    height: 12px;
-    border-radius: 2px;
-    border: 1px solid #d1d5db;
-}
-
-.legend-label {
-    font-size: 12px;
-    color: var(--color-text-secondary);
-}
-
-/* Calendar container styling */
-#calendar {
-    width: 100%;
-    overflow-x: auto;
-    margin: 0;
-}
-
-.calendar-heatmap {
-    width: 100%;
-    max-width: none;
-}
-
-#calendarContainer {
-    width: 100%;
-    padding: 0;
-    margin: 0;
-}
-
-/* Loading state */
-.calendar-loading {
-    display: flex;
-    justify-content: center;
-    align-items: center;
-    height: 400px;
-    color: var(--color-text-secondary);
-    font-size: 1.1rem;
-}
-
-.loading-spinner {
-    width: 24px;
-    height: 24px;
-    border: 3px solid #f3f3f3;
-    border-top: 3px solid var(--color-primary);
-    border-radius: 50%;
-    animation: spin 1s linear infinite;
-    margin-right: 0.75rem;
-}
-
-@keyframes spin {
-    0% { transform: rotate(0deg); }
-    100% { transform: rotate(360deg); }
-}
-
-/* Responsive design */
-@media (max-width: 768px) {
-    .calendar-header {
-        flex-direction: column;
-        align-items: stretch;
-    }
-    
-    .calendar-controls {
-        justify-content: center;
-    }
-    
-    .calendar-container {
-        padding: 1rem;
-    }
-}
-</style>
-{% endblock %}
+{% set nav = 'calendar' %}
+{% block title %}CVEs by day &mdash; CVEDB{% endblock %}
+{% block description %}Daily CVE publication counts, every day on record.{% endblock %}
 
 {% block content %}
-<!-- Hero Section -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">Calendar Intelligence Dashboard</h1>
-    <small class="text-muted d-block mb-3">
-        Daily CVE publication patterns and temporal analysis
-    </small>
+<div class="ph">
+  <h1>CVEs by day</h1>
+  <span class="note" id="span-note"></span>
+  <span style="margin-left:auto"><span class="seg" id="yearsel"></span></span>
 </div>
+<p class="lede">One square per day. Publication is bursty &mdash; large batches from a single
+publisher can land on one day, so daily counts swing far more than yearly ones.</p>
 
-<!-- Statistics Cards -->
-<div class="stats-grid mb-4">
-    <div class="stat-card">
-        <div class="stat-number" id="peakMonth">Loading...</div>
-        <div class="stat-label">Peak Month</div>
-        <small class="text-muted" id="peakMonthCount" style="font-size: 0.75rem;">📅 Highest monthly total</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="peakDay">Loading...</div>
-        <div class="stat-label">Peak Day</div>
-        <small class="text-muted" id="peakDayDate" style="font-size: 0.75rem;">🔥 Highest single day</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="avgPerDay">Loading...</div>
-        <div class="stat-label">Average Per Day</div>
-        <small class="text-muted" style="font-size: 0.75rem;">📈 Daily publication rate</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="totalCVEs">Loading...</div>
-        <div class="stat-label">Total CVEs</div>
-        <small class="text-muted" style="font-size: 0.75rem;">📊 All published vulnerabilities</small>
-    </div>
-</div>
+<div class="grid" id="tiles"></div>
 
-<!-- Calendar Heatmap -->
-<div class="card">
-    <div class="card-header">
-        <div class="calendar-header">
-            <h3 class="calendar-title">Daily CVE Publication Calendar</h3>
-        </div>
-    </div>
-    <div class="card-body" style="padding: 1rem 0.5rem;">
-        <div id="calendarLoading" class="text-center py-5">
-            <div class="spinner-border text-primary" role="status">
-                <span class="sr-only">Loading...</span>
-            </div>
-            <p class="mt-3 text-muted">Loading calendar data...</p>
-        </div>
-        
-        <div id="calendarContainer" style="display: none;">
-            <div id="calendar" style="margin: 0 auto; max-width: 100%; overflow-x: auto;"></div>
-        
-        <!-- Simplified Year Navigation -->
-        <div class="mt-3 text-center">
-            <div id="yearNavigationContainer" style="display:flex; justify-content:center; align-items:center; margin:20px 0; font-size:1.2rem;">
-                <!-- Simple year navigation will be generated here -->
-            </div>
-        </div>
-        </div>
-    </div>
-</div>
+<h2>Heatmap <span class="side" id="heat-year"></span></h2>
+<div class="panel"><div class="panel-b"><div id="heat"></div></div></div>
 
-<!-- Calendar Insights -->
-<div class="card">
-    <div class="card-header">
-        <h3>Calendar Insights</h3>
-    </div>
-    <div class="card-body">
-        <div class="row">
-            <div class="col-md-6">
-                <div class="insight-card">
-                    <div class="insight-icon">📅</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Publication Patterns</div>
-                        <div class="insight-text" id="publicationPatterns">Loading insights...</div>
-                    </div>
-                </div>
-            </div>
-            <div class="col-md-6">
-                <div class="insight-card">
-                    <div class="insight-icon">📊</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Temporal Trends</div>
-                        <div class="insight-text" id="temporalTrends">Loading insights...</div>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
+<h2>Daily counts</h2>
+<div class="panel">
+  <div class="panel-h">Every day in the selected year</div>
+  <div class="panel-b"><div id="chart-days"></div></div>
 </div>
 
-<!-- Export and Share Panel -->
-<div class="card mb-3">
-    <div class="card-header py-2">
-        <h2 class="card-title mb-0" style="font-size: 1.1rem;">📤 Export & Share</h2>
-    </div>
-    <div class="card-body py-3">
-        <div class="export-buttons">
-            <button class="btn btn-primary btn-sm" onclick="exportCalendarData('csv')">📊 Export CSV</button>
-            <button class="btn btn-primary btn-sm" onclick="exportCalendarData('json')">📋 Export JSON</button>
-            <button class="btn btn-secondary btn-sm" onclick="generatePermalink()">🔗 Share Link</button>
-            <button class="btn btn-secondary btn-sm" onclick="window.print()">🖨️ Print Report</button>
-        </div>
-        <div class="permalink-result mt-2" id="permalinkResult" style="display: none;">
-            <input type="text" class="form-control" id="permalinkInput" readonly>
-            <button class="btn btn-outline-primary btn-sm mt-1" onclick="copyPermalink()">Copy Link</button>
-        </div>
-    </div>
-</div>
+<h2>Busiest days</h2>
+<div class="panel"><div class="rows" id="busiest"></div></div>
 {% endblock %}
 
 {% block scripts %}
-<!-- D3.js dependency -->
-<script src="https://d3js.org/d3.v7.min.js"></script>
-
 <script>
-// Calendar Intelligence Dashboard JavaScript
-let calendarData = null;
-let currentYear = new Date().getFullYear();
-let selectedYear = currentYear;
-let tooltip = null;
-
-// Color palette for calendar heatmap (Blue theme)
-const colorPalette = {
-    empty: '#ebedf0',
-    scale: ['#ebedf0', '#c6e7ff', '#7cc7ff', '#3b9eff', '#0969da']
-};
-
-// Color scale function
-function getColor(value) {
-    if (!value || value === 0) return colorPalette.empty;
-    if (value <= 5) return colorPalette.scale[1];
-    if (value <= 15) return colorPalette.scale[2];
-    if (value <= 30) return colorPalette.scale[3];
-    return colorPalette.scale[4];
-}
-
-document.addEventListener('DOMContentLoaded', async function() {
-    await loadCalendarData();
+CVE.page(async (S) => {
+  const { fmt, chart, el } = CVE;
+  const YR = {{ current_year }};
+  const cal = await CVE.json('calendar_analysis.json');
+  const all = (cal.daily_data || []).slice().sort((a, b) => a.date.localeCompare(b.date));
+  const yearsAvail = [...new Set(all.map(d => d.date.slice(0, 4)))].sort().reverse().slice(0, 6);
+  let year = String(YR);
+
+  el('#yearsel').innerHTML = yearsAvail.map(y =>
+    `<button data-y="${y}" class="${y === year ? 'on' : ''}">${y}</button>`).join('');
+  el('#span-note').textContent = all.length
+    ? `${all[0].date} to ${all[all.length - 1].date}` : '';
+
+  function render() {
+    const days = all.filter(d => d.date.startsWith(year));
+    const total = days.reduce((s, d) => s + (d.value || 0), 0);
+    const active = days.filter(d => d.value > 0).length;
+    const peak = days.reduce((m, d) => (d.value || 0) > (m.value || 0) ? d : m, { value: 0 });
+    const quiet = days.filter(d => d.value > 0)
+      .reduce((m, d) => (d.value || 0) < (m.value || 0) ? d : m, { value: Infinity });
+
+    el('#tiles').innerHTML = [
+      { lead: 1, lbl: `Published in ${year}`, v: fmt.n(total),
+        sub: `across <b>${fmt.n(active)}</b> days with at least one CVE` },
+      { lbl: 'Average per active day', v: fmt.n(active ? Math.round(total / active) : 0),
+        sub: `${fmt.n(days.length)} days in range` },
+      { lbl: 'Busiest day', v: fmt.n(peak.value), sub: peak.date || '&mdash;' },
+      { lbl: 'Quietest active day', v: fmt.n(quiet.value === Infinity ? 0 : quiet.value),
+        sub: quiet.date || '&mdash;' }
+    ].map(t => `<div class="c ${t.lead ? 'lead' : ''}">
+        <div class="lbl">${t.lbl}</div><div class="v">${t.v}</div>
+        <div class="sub">${t.sub}</div></div>`).join('');
+
+    el('#heat-year').textContent = year;
+    chart.heat('#heat', days, { name: 'cve-icu-daily-heatmap' });
+
+    chart.bars('#chart-days', days.map(d => ({
+      label: d.date, value: d.value || 0
+    })), { tall: true, ticks: days.length ? [fmt.day(days[0].date), fmt.day(days[days.length - 1].date)] : [] , name: 'cve-icu-daily-counts' });
+
+    chart.rank('#busiest', days.slice().sort((a, b) => b.value - a.value).slice(0, 10)
+      .map(d => ({ label: fmt.day(d.date), sub: d.date, value: d.value })), { name: 'cve-icu-busiest-days' });
+  }
+  render();
+
+  el('#yearsel').addEventListener('click', e => {
+    const b = e.target.closest('button[data-y]'); if (!b) return;
+    year = b.dataset.y;
+    CVE.all('#yearsel button').forEach(x => x.classList.toggle('on', x === b));
+    render();
+  });
 });
-
-async function loadCalendarData() {
-    try {
-        const response = await fetch('/data/calendar_analysis.json');
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        
-        calendarData = await response.json();
-        
-        initializeCalendar();
-        updateLastUpdated();
-        
-    } catch (error) {
-        console.error('Error loading calendar data:', error);
-        showErrorState();
-    }
-}
-
-// Initialize calendar when data is loaded
-function initializeCalendar() {
-    // Set current year to latest year in data
-    const years = [...new Set(calendarData.daily_data.map(d => new Date(d.date).getFullYear()))];
-    currentYear = Math.max(...years);
-    
-    // Create initial calendar
-    createCalendarHeatmap();
-    updateStatsCards();
-    updateInsights();
-    updateLastUpdated();
-    
-    // Show calendar container
-    document.getElementById('calendarContainer').style.display = 'block';
-    document.getElementById('calendarLoading').style.display = 'none';
-    
-    // Initialize simple year navigation
-    initializeYearNavigation();
-}
-
-function initializeYearNavigation() {
-    renderYearNavigation();
-}
-
-// Render simple year navigation in << Year >> format
-function renderYearNavigation() {
-    const container = document.getElementById('yearNavigationContainer');
-    
-    if (!container) {
-        console.error('Year navigation container not found');
-        return;
-    }
-    
-    // Get sorted years from daily data (newest first)
-    const years = [...new Set(calendarData.daily_data.map(d => new Date(d.date).getFullYear()))].sort((a, b) => b - a);
-    const currentIndex = years.indexOf(currentYear);
-    
-    // Clear container
-    container.innerHTML = '';
-    
-    // Create navigation elements
-    const navDiv = document.createElement('div');
-    navDiv.style.cssText = 'display: flex; align-items: center; gap: 15px; font-weight: 500;';
-    
-    // Left arrow
-    const leftArrow = document.createElement('span');
-    leftArrow.innerHTML = '&laquo;';
-    leftArrow.style.cssText = `
-        cursor: ${currentIndex >= years.length - 1 ? 'not-allowed' : 'pointer'};
-        color: ${currentIndex >= years.length - 1 ? '#ccc' : '#007bff'};
-        font-size: 1.5rem;
-        user-select: none;
-        transition: color 0.2s;
-    `;
-    
-    if (currentIndex < years.length - 1) {
-        leftArrow.onclick = () => {
-            currentYear = years[currentIndex + 1];
-            createCalendarHeatmap();
-            renderYearNavigation();
-        };
-        leftArrow.onmouseover = () => leftArrow.style.color = '#0056b3';
-        leftArrow.onmouseout = () => leftArrow.style.color = '#007bff';
-    }
-    
-    // Current year display
-    const yearDisplay = document.createElement('span');
-    yearDisplay.textContent = currentYear;
-    yearDisplay.style.cssText = 'font-size: 1.3rem; font-weight: 600; color: #333; min-width: 60px; text-align: center;';
-    
-    // Right arrow
-    const rightArrow = document.createElement('span');
-    rightArrow.innerHTML = '&raquo;';
-    rightArrow.style.cssText = `
-        cursor: ${currentIndex <= 0 ? 'not-allowed' : 'pointer'};
-        color: ${currentIndex <= 0 ? '#ccc' : '#007bff'};
-        font-size: 1.5rem;
-        user-select: none;
-        transition: color 0.2s;
-    `;
-    
-    if (currentIndex > 0) {
-        rightArrow.onclick = () => {
-            currentYear = years[currentIndex - 1];
-            createCalendarHeatmap();
-            renderYearNavigation();
-        };
-        rightArrow.onmouseover = () => rightArrow.style.color = '#0056b3';
-        rightArrow.onmouseout = () => rightArrow.style.color = '#007bff';
-    }
-    
-    // Assemble navigation
-    navDiv.appendChild(leftArrow);
-    navDiv.appendChild(yearDisplay);
-    navDiv.appendChild(rightArrow);
-    
-    container.appendChild(navDiv);
-}
-
-function calculatePeakMonth() {
-    if (!calendarData?.daily_data) {
-        return { month: 'N/A', count: 0 };
-    }
-    
-    // Group daily data by month
-    const monthTotals = {};
-    
-    calendarData.daily_data.forEach(day => {
-        const date = new Date(day.date);
-        const monthKey = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`;
-        const monthName = date.toLocaleDateString('en-US', { month: 'long', year: 'numeric' });
-        
-        if (!monthTotals[monthKey]) {
-            monthTotals[monthKey] = {
-                name: monthName,
-                count: 0
-            };
-        }
-        monthTotals[monthKey].count += day.value || 0;
-    });
-    
-    // Find the month with the highest total
-    let peakMonth = { month: 'N/A', count: 0 };
-    Object.values(monthTotals).forEach(month => {
-        if (month.count > peakMonth.count) {
-            peakMonth = {
-                month: month.name,
-                count: month.count
-            };
-        }
-    });
-    
-    return peakMonth;
-}
-
-function updateStatsCards() {
-    const stats = calendarData.statistics;
-    
-    // Update stats cards
-    document.getElementById('totalCVEs').textContent = stats.total_cves?.toLocaleString() || '0';
-    document.getElementById('avgPerDay').textContent = stats.daily_stats?.average_per_day || '0';
-    document.getElementById('peakDay').textContent = stats.daily_stats?.max_per_day?.toLocaleString() || '0';
-    // Calculate peak month from daily data
-    const peakMonthData = calculatePeakMonth();
-    document.getElementById('peakMonth').textContent = peakMonthData.month || 'N/A';
-    document.getElementById('peakMonthCount').textContent = `📅 ${peakMonthData.count?.toLocaleString() || '0'} CVEs`;
-    
-    // Update peak day date
-    const peakDate = stats.daily_stats?.peak_day?.date;
-    if (peakDate) {
-        const formattedDate = new Date(peakDate).toLocaleDateString('en-US', {
-            month: 'short',
-            day: 'numeric',
-            year: 'numeric'
-        });
-        document.getElementById('peakDayDate').textContent = `🔥 ${formattedDate}`;
-    }
-
-    // Best-effort KEV count for this year using per-year CVE summary
-    const kevCountEl = document.getElementById('kevCount');
-    const kevSubtextEl = document.getElementById('kevSubtext');
-    if (kevCountEl && kevSubtextEl) {
-        kevCountEl.textContent = '…';
-        kevSubtextEl.textContent = '⚠️ Loading KEV data…';
-        fetch(`data/cve_${currentYear}.json`)
-            .then(r => r.json())
-            .then(yearData => {
-                const kevCount = yearData.kev && typeof yearData.kev.kev_count === 'number'
-                    ? yearData.kev.kev_count
-                    : 0;
-                kevCountEl.textContent = kevCount.toLocaleString();
-                kevSubtextEl.textContent = kevCount > 0
-                    ? `⚠️ Known exploited CVEs in ${currentYear}`
-                    : `⚠️ No KEV-listed CVEs in ${currentYear}`;
-            })
-            .catch(err => {
-                console.error('Failed to load KEV year data for calendar view:', err);
-                kevCountEl.textContent = 'N/A';
-                kevSubtextEl.textContent = '⚠️ KEV data unavailable';
-            });
-    }
-}
-
-function updateInsights() {
-    const stats = calendarData.statistics;
-    
-    // Publication patterns insight
-    const totalDays = stats.total_days_with_data || 0;
-    const avgPerDay = stats.daily_stats?.average_per_day || 0;
-    const patternsText = `CVE publications span ${totalDays.toLocaleString()} days with an average of ${avgPerDay} CVEs per day. Peak activity reached ${stats.daily_stats?.max_per_day || 0} CVEs in a single day.`;
-    document.getElementById('publicationPatterns').textContent = patternsText;
-    
-    // Temporal trends insight
-    const dateRange = stats.date_range;
-    const trendsText = `Data coverage spans from ${new Date(dateRange?.start).getFullYear()} to ${new Date(dateRange?.end).getFullYear()}, showing the evolution of vulnerability disclosure patterns over time.`;
-    document.getElementById('temporalTrends').textContent = trendsText;
-}
-
-function updateLastUpdated() {
-    if (calendarData.generated_at) {
-        const date = new Date(calendarData.generated_at);
-        const formatted = date.toLocaleString('en-US', {
-            month: 'short',
-            day: 'numeric',
-            year: 'numeric',
-            hour: 'numeric',
-            minute: '2-digit',
-            timeZoneName: 'short'
-        });
-        document.getElementById('lastUpdated').textContent = formatted;
-    }
-}
-
-function exportCalendarData(format) {
-    if (format === 'csv') {
-        const csv = convertToCSV(calendarData.daily_data);
-        downloadFile(csv, 'calendar_data.csv', 'text/csv');
-    } else if (format === 'json') {
-        const json = JSON.stringify(calendarData, null, 2);
-        downloadFile(json, 'calendar_data.json', 'application/json');
-    }
-}
-
-function convertToCSV(data) {
-    const headers = ['Date', 'CVE Count', 'Average CVSS', 'CVEs with CVSS'];
-    const rows = data.map(item => [
-        item.date,
-        item.value,
-        item.avg_cvss || '',
-        item.cvss_count || ''
-    ]);
-    
-    return [headers, ...rows].map(row => row.join(',')).join('\n');
-}
-
-function downloadFile(content, filename, contentType) {
-    const blob = new Blob([content], { type: contentType });
-    const url = URL.createObjectURL(blob);
-    const link = document.createElement('a');
-    link.href = url;
-    link.download = filename;
-    link.click();
-    URL.revokeObjectURL(url);
-}
-
-function createCalendarHeatmap() {
-    const data = calendarData;
-    
-    // Clear existing calendar
-    d3.select('#calendar').selectAll('*').remove();
-    
-    // Create tooltip if it doesn't exist
-    if (!tooltip) {
-        tooltip = d3.select('body').append('div')
-            .attr('class', 'calendar-tooltip');
-    }
-    
-    // Prepare data map
-    const dataMap = new Map();
-    data.daily_data.forEach(item => {
-        dataMap.set(item.date, {
-            count: item.value,
-            avgCvss: item.avg_cvss,
-            cvssCount: item.cvss_count
-        });
-    });
-    
-    // Calendar dimensions for 3x4 month grid - maximize card space for better readability
-    const containerElement = document.getElementById('calendar').parentElement;
-    const containerWidth = containerElement ? containerElement.clientWidth - 10 : 1400;
-    const maxWidth = Math.max(1200, containerWidth);
-    const cellSize = 26; // Even larger cells for 3-digit numbers
-    const cellPadding = 3; // More padding between cells
-    const monthWidth = Math.max(250, Math.floor((maxWidth - 60) / 4) - 12); // 4 columns for better fit
-    const monthHeight = Math.max(180, Math.floor(monthWidth * 0.75)); // Proportional height
-    const monthPadding = 8; // Much tighter spacing
-    const gridCols = 4; // 4 columns for better fit
-    const gridRows = 3; // 3 rows
-    const width = maxWidth;
-    const height = gridRows * (monthHeight + monthPadding) + 100; // More space for year title
-    
-    // Create SVG
-    const svg = d3.select('#calendar')
-        .append('svg')
-        .attr('width', width)
-        .attr('height', height)
-        .attr('class', 'calendar-heatmap');
-    
-    // Create month data for current year
-    const months = [];
-    for (let month = 0; month < 12; month++) {
-        const startDate = new Date(currentYear, month, 1);
-        months.push({
-            month: month,
-            name: d3.timeFormat('%B')(startDate)
-        });
-    }
-    
-    // Add prominent year title - centered over the actual calendar grid
-    const calendarGridWidth = gridCols * (monthWidth + monthPadding) - monthPadding;
-    const calendarCenterX = 20 + (calendarGridWidth / 2);
-    
-    svg.append('text')
-        .attr('class', 'year-title')
-        .attr('x', calendarCenterX)
-        .attr('y', 30)
-        .attr('text-anchor', 'middle')
-        .style('font-size', '26px')
-        .style('font-weight', 'bold')
-        .style('fill', 'var(--color-text-primary)')
-        .text(currentYear);
-    
-    // Create month groups in 4x3 grid
-    const monthGroups = svg.selectAll('.month-group')
-        .data(months)
-        .enter().append('g')
-        .attr('class', 'month-group')
-        .attr('transform', (d, i) => {
-            const col = i % gridCols;
-            const row = Math.floor(i / gridCols);
-            const x = col * (monthWidth + monthPadding) + 20;
-            const y = row * (monthHeight + monthPadding) + 80; // Even more space from year title
-            return `translate(${x}, ${y})`;
-        });
-    
-    // Add month labels - centered over the calendar grid
-    monthGroups.append('text')
-        .attr('class', 'month-title')
-        .attr('x', (7 * (cellSize + cellPadding) - cellPadding) / 2) // Center over 7-day grid
-        .attr('y', -8)
-        .attr('text-anchor', 'middle')
-        .style('font-size', '18px')
-        .style('font-weight', 'bold')
-        .style('fill', 'var(--color-text-primary)')
-        .text(d => d.name);
-    
-    // Add day labels (Sun, Mon, etc.) for each month
-    const dayLabels = ['S', 'M', 'T', 'W', 'T', 'F', 'S'];
-    monthGroups.each(function() {
-        const monthGroup = d3.select(this);
-        monthGroup.selectAll('.day-label')
-            .data(dayLabels)
-            .enter().append('text')
-            .attr('class', 'day-label')
-            .attr('x', (d, i) => i * (cellSize + cellPadding) + cellSize / 2)
-            .attr('y', 12)
-            .attr('text-anchor', 'middle')
-            .style('font-size', '13px')
-            .style('font-weight', '600')
-            .style('fill', 'var(--color-text-secondary)')
-            .text(d => d);
-    });
-    
-    // Add calendar days for each month with proper weekly grid layout
-    monthGroups.each(function(monthData) {
-        const monthGroup = d3.select(this);
-        const month = monthData.month;
-        
-        // Create proper calendar grid with weeks as rows
-        const firstDay = new Date(currentYear, month, 1);
-        const firstDayOfWeek = firstDay.getDay(); // 0 = Sunday, 6 = Saturday
-        const daysInMonth = new Date(currentYear, month + 1, 0).getDate();
-        
-        // Create all calendar positions (6 weeks × 7 days = 42 positions)
-        const calendarPositions = [];
-        for (let week = 0; week < 6; week++) {
-            for (let day = 0; day < 7; day++) {
-                const dayNumber = (week * 7 + day) - firstDayOfWeek + 1;
-                calendarPositions.push({
-                    week: week,
-                    dayOfWeek: day,
-                    dayNumber: dayNumber,
-                    isValidDay: dayNumber >= 1 && dayNumber <= daysInMonth,
-                    date: dayNumber >= 1 && dayNumber <= daysInMonth ? 
-                          new Date(currentYear, month, dayNumber) : null
-                });
-            }
-        }
-        
-        // Create day cells for all positions
-        const dayGroups = monthGroup.selectAll('.day-group')
-            .data(calendarPositions)
-            .enter().append('g')
-            .attr('class', 'day-group')
-            .attr('transform', d => {
-                const x = d.dayOfWeek * (cellSize + cellPadding);
-                const y = d.week * (cellSize + cellPadding) + 25;
-                return `translate(${x}, ${y})`;
-            });
-        
-        dayGroups.each(function(d) {
-            const dayGroup = d3.select(this);
-            
-            if (d.isValidDay) {
-                const dateStr = d3.timeFormat('%Y-%m-%d')(d.date);
-                const dayData = dataMap.get(dateStr);
-                const count = dayData ? dayData.count : 0;
-                
-                // Add day cell
-                dayGroup.append('rect')
-                    .attr('class', 'day')
-                    .attr('width', cellSize)
-                    .attr('height', cellSize)
-                    .attr('fill', getColor(count))
-                    .attr('stroke', '#fff')
-                    .attr('stroke-width', 0.5)
-                    .attr('rx', 2);
-                
-                // Add CVE count text if count > 0
-                if (count > 0) {
-                    dayGroup.append('text')
-                        .attr('x', cellSize / 2)
-                        .attr('y', cellSize / 2)
-                        .attr('dy', '0.35em')
-                        .attr('text-anchor', 'middle')
-                        .style('font-size', count > 99 ? '14px' : count > 9 ? '16px' : '18px')
-                        .style('font-weight', 'bold')
-                        .style('fill', 'white')
-                        .style('pointer-events', 'none')
-                        .text(count);
-                }
-                
-                // Add hover tooltip
-                dayGroup
-                    .style('cursor', 'pointer')
-                    .on('mouseover', function(event) {
-                        const avgCvss = dayData ? dayData.avgCvss : 0;
-                        const cvssCount = dayData ? dayData.cvssCount : 0;
-                        
-                        tooltip.transition().duration(200).style('opacity', .9);
-                        tooltip.html(`
-                            <strong>${d3.timeFormat('%B %d, %Y')(d.date)}</strong><br/>
-                            CVEs: ${count}<br/>
-                            ${avgCvss > 0 ? `Avg CVSS: ${avgCvss.toFixed(1)} (${cvssCount} scored)` : 'No CVSS scores'}
-                        `)
-                        .style('left', (event.pageX + 10) + 'px')
-                        .style('top', (event.pageY - 28) + 'px');
-                    })
-                    .on('mouseout', function() {
-                        tooltip.transition().duration(500).style('opacity', 0);
-                    });
-            }
-        });
-    });
-    
-    console.log(`Calendar heatmap rendered for ${currentYear} with 12-month grid layout`);
-}
-
-function updateCalendarView() {
-    createCalendarHeatmap();
-}
-
-function updateStatsCards() {
-    const stats = calendarData.statistics;
-    
-    // Update stats cards
-    document.getElementById('totalCVEs').textContent = stats.total_cves?.toLocaleString() || '0';
-    document.getElementById('avgPerDay').textContent = stats.daily_stats?.average_per_day || '0';
-    document.getElementById('peakDay').textContent = stats.daily_stats?.max_per_day?.toLocaleString() || '0';
-    // Calculate peak month from daily data
-    const peakMonthData = calculatePeakMonth();
-    document.getElementById('peakMonth').textContent = peakMonthData.month || 'N/A';
-    document.getElementById('peakMonthCount').textContent = `📅 ${peakMonthData.count?.toLocaleString() || '0'} CVEs`;
-    
-    // Update peak day date
-    const peakDate = stats.daily_stats?.peak_day?.date;
-    if (peakDate) {
-        const formattedDate = new Date(peakDate).toLocaleDateString('en-US', {
-            month: 'short',
-            day: 'numeric',
-            year: 'numeric'
-        });
-        document.getElementById('peakDayDate').textContent = `🔥 ${formattedDate}`;
-    }
-}
-
-function updateInsights() {
-    const stats = calendarData.statistics;
-    
-    // Publication patterns insight
-    const totalDays = stats.total_days_with_data || 0;
-    const avgPerDay = stats.daily_stats?.average_per_day || 0;
-    const patternsText = `CVE publications span ${totalDays.toLocaleString()} days with an average of ${avgPerDay} CVEs per day. Peak activity reached ${stats.daily_stats?.max_per_day || 0} CVEs in a single day.`;
-    document.getElementById('publicationPatterns').textContent = patternsText;
-    
-    // Temporal trends insight
-    const dateRange = stats.date_range;
-    const trendsText = `Data coverage spans from ${new Date(dateRange?.start).getFullYear()} to ${new Date(dateRange?.end).getFullYear()}, showing the evolution of vulnerability disclosure patterns over time.`;
-    document.getElementById('temporalTrends').textContent = trendsText;
-}
-
-function updateLastUpdated() {
-    if (calendarData.generated_at) {
-        const date = new Date(calendarData.generated_at);
-        const formatted = date.toLocaleString('en-US', {
-            month: 'short',
-            day: 'numeric',
-            year: 'numeric',
-            hour: 'numeric',
-            minute: '2-digit',
-            timeZoneName: 'short'
-        });
-        document.getElementById('lastUpdated').textContent = formatted;
-    }
-}
-
-function exportCalendarData(format) {
-    if (format === 'csv') {
-        const csv = convertToCSV(calendarData.daily_data);
-        downloadFile(csv, 'calendar_data.csv', 'text/csv');
-    } else if (format === 'json') {
-        const json = JSON.stringify(calendarData, null, 2);
-        downloadFile(json, 'calendar_data.json', 'application/json');
-    }
-}
-
-function convertToCSV(data) {
-    const headers = ['Date', 'CVE Count', 'Average CVSS', 'CVEs with CVSS'];
-    const rows = data.map(item => [
-        item.date,
-        item.value,
-        item.avg_cvss || '',
-        item.cvss_count || ''
-    ]);
-    
-    return [headers, ...rows].map(row => row.join(',')).join('\n');
-}
-
-function downloadFile(content, filename, contentType) {
-    const blob = new Blob([content], { type: contentType });
-    const url = URL.createObjectURL(blob);
-    const link = document.createElement('a');
-    link.href = url;
-    link.download = filename;
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-    URL.revokeObjectURL(url);
-}
-
-function copyPermalink() {
-    const url = new URL(window.location);
-    url.searchParams.set('year', selectedYear);
-    
-    navigator.clipboard.writeText(url.toString()).then(() => {
-        // Show temporary success message
-        const btn = event.target;
-        const originalText = btn.textContent;
-        btn.textContent = '✅ Copied!';
-        setTimeout(() => {
-            btn.textContent = originalText;
-        }, 2000);
-    });
-}
-
-function showErrorState() {
-    document.getElementById('calendarLoading').innerHTML = `
-        <div style="text-align: center; color: #dc3545;">
-            <h4>⚠️ Error Loading Calendar Data</h4>
-            <p>Unable to load calendar analysis data. Please try refreshing the page.</p>
-        </div>
-    `;
-    
-    // Show error in stats cards
-    ['totalCVEs', 'avgPerDay', 'peakDay', 'avgCVSS'].forEach(id => {
-        document.getElementById(id).textContent = 'Error';
-    });
-}
 </script>
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/templates/cna-hub.html b/templates/cna-hub.html
new file mode 100644
index 00000000000..b81b666fe8c
--- /dev/null
+++ b/templates/cna-hub.html
@@ -0,0 +1,58 @@
+{% extends "base.html" %}
+{% set nav = 'cna' %}
+{% block title %}Publishers &mdash; CVEDB{% endblock %}
+{% block description %}Overview of CVE Numbering Authority counts and name matching.{% endblock %}
+
+{% block content %}
+<div class="ph"><h1>Publishers</h1><span class="note">CVE Numbering Authorities</span></div>
+<p class="lede">Two views of the same set of organisations: how many CVEs each has published,
+and how well their names line up with the official registry.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Where to go</h2>
+<div class="cols c2">
+  <a class="panel" href="cna.html" style="display:block">
+    <div class="panel-h">Counts by publisher <span class="side">&rarr;</span></div>
+    <div class="panel-b muted" style="font-size:13.5px">
+      Every authority with its count for this year and all time, how long it has been
+      publishing, and how many of its CVEs are in the KEV catalog. Sortable.
+    </div>
+  </a>
+  <a class="panel" href="data-quality.html" style="display:block">
+    <div class="panel-h">Name matching <span class="side">&rarr;</span></div>
+    <div class="panel-b muted" style="font-size:13.5px">
+      How the publisher names in the CVE record line up with the official CNA registry:
+      exact matches, case differences, and the ones that do not match at all.
+    </div>
+  </a>
+</div>
+
+<h2>Largest publishers</h2>
+<div class="panel"><div class="rows" id="top"></div></div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+CVE.page(async () => {
+  const { fmt, chart, el } = CVE;
+  const YR = {{ current_year }};
+  const d = await CVE.json('cna_analysis.json');
+  const list = d.cna_list || [];
+  const total = list.reduce((s, c) => s + c.count, 0);
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'Publishers on record', v: fmt.n(d.total_cnas),
+      sub: `<b>${fmt.n(d.active_cnas)}</b> active &middot; <b>${fmt.n(d.inactive_cnas)}</b> inactive` },
+    { lbl: 'CVEs attributed', v: fmt.compact(total), sub: 'across all publishers' },
+    { lbl: 'High-volume publishers', v: fmt.n(d.high_volume_cnas), sub: 'more than 1,000 CVEs' },
+    { lbl: 'Median years active', v: String(d.median_years_active ?? '—'), sub: 'across all publishers' }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  chart.rank('#top', list.slice().sort((a, b) => b.count - a.count).slice(0, 12)
+    .map(c => ({ label: c.name, sub: `since ${c.first_cve_year || '?'}`, value: c.count })),
+    { compact: true, name: 'cve-icu-largest-publishers' });
+});
+</script>
+{% endblock %}
diff --git a/templates/cna.html b/templates/cna.html
new file mode 100644
index 00000000000..5d6b1ede683
--- /dev/null
+++ b/templates/cna.html
@@ -0,0 +1,158 @@
+{% extends "base.html" %}
+{% set nav = 'cna' %}
+{% block title %}CVEs by publisher &mdash; CVEDB{% endblock %}
+{% block description %}How many CVEs each CVE Numbering Authority has published, this year and all time.{% endblock %}
+
+{% block content %}
+<div class="ph">
+  <h1>CVEs by publisher</h1>
+  <span class="note">CVE Numbering Authorities</span>
+  <span style="margin-left:auto"><span class="seg" id="scope">
+    <button data-scope="year" class="on">{{ current_year }}</button>
+    <button data-scope="all">All time</button>
+  </span></span>
+</div>
+<p class="lede">Each CVE is assigned by exactly one authority. These are counts of what each
+publisher is credited with in the CVE record, which can differ by a few dozen from the
+<a href="years.html" style="color:var(--accent)">yearly totals</a> as records are reassigned.
+<a href="data-quality.html" style="color:var(--accent)">Name matching</a> covers how these
+names line up with the official registry.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Largest publishers <span class="side" id="scope-side"></span></h2>
+<div class="panel"><div class="panel-b"><div id="chart-cna"></div></div></div>
+
+<h2>Activity</h2>
+<div class="cols c2">
+  <div class="panel"><div class="panel-h">Publishers by first year <span class="side">when they started</span></div>
+    <div class="panel-b"><div id="chart-first"></div></div></div>
+  <div class="panel"><div class="panel-h">Status</div><div class="rows" id="status"></div></div>
+</div>
+
+<h2>Every publisher <span class="side" id="filter-count"></span></h2>
+<div class="panel">
+  <div class="panel-h" style="gap:12px;flex-wrap:wrap">
+    <label class="fl">Status
+      <select id="f-status"><option value="">Any</option></select></label>
+    <label class="fl">Type
+      <select id="f-type"><option value="">Any</option></select></label>
+    <label class="fl">Name
+      <input id="f-name" type="search" placeholder="filter&hellip;" autocomplete="off"></label>
+    <button class="exp-btn" id="f-reset">Reset</button>
+    <span class="side" id="f-note"></span>
+  </div>
+  <div id="cna-table"></div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+CVE.page(async () => {
+  const { fmt, chart, el, table } = CVE;
+  const YR = {{ current_year }};
+  const d = await CVE.json('cna_analysis.json');
+  const list = d.cna_list || [];
+  let scope = 'year';
+  const yearCount = c => (c.cves_by_year || {})[YR] || 0;
+
+  function render() {
+    const val = c => scope === 'year' ? yearCount(c) : c.count;
+    const activeNow = list.filter(c => yearCount(c) > 0);
+    const totalScope = list.reduce((s, c) => s + val(c), 0);
+    const ranked = list.slice().sort((a, b) => val(b) - val(a));
+    const top5 = ranked.slice(0, 5).reduce((s, c) => s + val(c), 0);
+
+    el('#tiles').innerHTML = [
+      { lead: 1, lbl: scope === 'year' ? `Attributed in ${YR}` : 'Attributed since 1999',
+        v: fmt.n(totalScope),
+        sub: `by <b>${fmt.n(scope === 'year' ? activeNow.length : list.length)}</b> publishers` },
+      { lbl: 'Publishers on record', v: fmt.n(d.total_cnas),
+        sub: `<b>${fmt.n(d.active_cnas)}</b> currently active` },
+      { lbl: 'Largest publisher', v: fmt.compact(val(ranked[0] || {})),
+        sub: `<b>${CVE.esc((ranked[0] || {}).name || '')}</b>` },
+      { lbl: 'Top 5 share', v: fmt.share(top5, totalScope, 0),
+        sub: 'of the CVEs in this view' }
+    ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+        <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+    chart.hbars('#chart-cna', ranked.slice(0, 15).filter(c => val(c) > 0)
+      .map(c => ({ label: c.name, value: val(c) })), { name: 'cve-icu-publishers' });
+    el('#scope-side').textContent = scope === 'year' ? `in ${YR}` : 'all time';
+
+    const byFirst = {};
+    list.forEach(c => { const y = c.first_cve_year; if (y) byFirst[y] = (byFirst[y] || 0) + 1; });
+    const firstYears = Object.keys(byFirst).sort();
+    chart.bars('#chart-first', firstYears.map(y => ({
+      label: y, value: byFirst[y], current: +y === YR
+    })), { ticks: [firstYears[0], firstYears[firstYears.length - 1]] , name: 'cve-icu-publishers-by-first-year' });
+
+    const byStatus = {};
+    list.forEach(c => { const s = c.activity_status || 'Unknown';
+      byStatus[s] = (byStatus[s] || 0) + 1; });
+    chart.rank('#status', Object.entries(byStatus)
+      .map(([k, v]) => ({ label: k, value: v })).sort((a, b) => b.value - a.value), { name: 'cve-icu-publisher-status' });
+
+    const statuses = [...new Set(list.map(c => c.activity_status).filter(Boolean))].sort();
+    const types = [...new Set(list.flatMap(c => c.cna_types || []).filter(Boolean))].sort();
+    const fill = (sel, vals) => {
+      const e = el(sel), keep = e.value;
+      e.innerHTML = '<option value="">Any</option>' +
+        vals.map(v => `<option value="${CVE.esc(v)}">${CVE.esc(v)}</option>`).join('');
+      e.value = keep;
+    };
+    fill('#f-status', statuses);
+    fill('#f-type', types);
+
+    const fStatus = el('#f-status').value;
+    const fType = el('#f-type').value;
+    const fName = (el('#f-name').value || '').trim().toLowerCase();
+    const filtered = list.filter(c =>
+      (!fStatus || c.activity_status === fStatus) &&
+      (!fType || (c.cna_types || []).includes(fType)) &&
+      (!fName || c.name.toLowerCase().includes(fName)));
+
+    el('#filter-count').textContent = filtered.length === list.length
+      ? `all ${fmt.n(list.length)}` : `${fmt.n(filtered.length)} of ${fmt.n(list.length)}`;
+    el('#f-note').textContent = filtered.length === list.length ? '' : 'filtered';
+
+    table('#cna-table', filtered.map(c => ({
+      name: c.name,
+      year: yearCount(c),
+      all: c.count,
+      kev: c.kev_count || 0,
+      since: c.first_cve_year || null,
+      active: c.years_active || 0,
+      status: c.activity_status || '—'
+    })), [
+      { key: 'name', label: 'Publisher' },
+      { key: 'year', label: String(YR), num: true, bar: true },
+      { key: 'all', label: 'All time', num: true, bar: true },
+      { key: 'kev', label: 'In KEV', num: true },
+      { key: 'since', label: 'Since', num: true, raw: true,
+        fmt: v => v == null ? '<span class="faint">&mdash;</span>' : String(v) },
+      { key: 'active', label: 'Years active', num: true, raw: true },
+      { key: 'status', label: 'Status',
+        fmt: v => `<span class="pill ${v === 'Active' ? 'live' : ''}">${CVE.esc(v)}</span>` }
+    ], { sort: { key: scope === 'year' ? 'year' : 'all', dir: -1 } });
+  }
+  render();
+
+  ['#f-status', '#f-type'].forEach(sel =>
+    el(sel).addEventListener('change', render));
+  let t;
+  el('#f-name').addEventListener('input', () => { clearTimeout(t); t = setTimeout(render, 160); });
+  el('#f-reset').addEventListener('click', () => {
+    el('#f-status').value = ''; el('#f-type').value = ''; el('#f-name').value = '';
+    render();
+  });
+
+  el('#scope').addEventListener('click', e => {
+    const b = e.target.closest('button[data-scope]'); if (!b) return;
+    scope = b.dataset.scope;
+    CVE.all('#scope button').forEach(x => x.classList.toggle('on', x === b));
+    render();
+  });
+});
+</script>
+{% endblock %}
diff --git a/templates/cna/badges.html b/templates/cna/badges.html
deleted file mode 100644
index 4edadcae23b..00000000000
--- a/templates/cna/badges.html
+++ /dev/null
@@ -1,489 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-  <!-- Google tag (gtag.js) -->
-  <script async src="https://www.googletagmanager.com/gtag/js?id=G-MQJ07VQQQN"></script>
-  <script>
-    window.dataLayer = window.dataLayer || [];
-    function gtag() { dataLayer.push(arguments); }
-    gtag('js', new Date());
-
-    gtag('config', 'G-MQJ07VQQQN');
-  </script>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>CNA Scorecard Badges</title>
-  <link rel="icon" type="image/svg+xml" href="assets/logo.svg">
-  <link rel="stylesheet" href="assets/theme.css">
-  <link rel="stylesheet" href="shared/shared.css">
-  <style>
-    .container {
-      max-width: 1200px;
-      margin: 0 auto;
-      padding: 2rem 1rem;
-    }
-
-    .page-header {
-      background-color: var(--card-bg);
-      border-radius: 12px;
-      padding: 2rem;
-      margin-bottom: 2rem;
-      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
-      text-align: center;
-    }
-
-    .page-title {
-      font-size: 2.5rem;
-      color: var(--primary-color);
-      margin-bottom: 1rem;
-      font-weight: 600;
-    }
-
-    .page-subtitle {
-      color: var(--text-secondary);
-      font-size: 1.1rem;
-      line-height: 1.6;
-    }
-
-    .search-section {
-      background-color: var(--card-bg);
-      border-radius: 12px;
-      padding: 2rem;
-      margin-bottom: 2rem;
-      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
-    }
-
-    .search-input {
-      width: 100%;
-      padding: 1rem;
-      font-size: 1.1rem;
-      border: 2px solid var(--border-color);
-      border-radius: 8px;
-      transition: border-color 0.3s;
-    }
-
-    .search-input:focus {
-      outline: none;
-      border-color: var(--primary-color);
-      box-shadow: 0 0 0 3px rgba(0, 82, 163, 0.1);
-    }
-
-    .search-results {
-      display: none;
-      position: absolute;
-      top: 100%;
-      left: 0;
-      right: 0;
-      background: white;
-      border: 1px solid var(--border-color);
-      border-radius: 8px;
-      margin-top: 0.5rem;
-      max-height: 300px;
-      overflow-y: auto;
-      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
-      z-index: 1000;
-    }
-
-    .search-results.active {
-      display: block;
-    }
-
-    .search-result-item {
-      padding: 1rem 1.5rem;
-      cursor: pointer;
-      border-bottom: 1px solid var(--border-color);
-      transition: background 0.2s;
-    }
-
-    .search-result-item:last-child {
-      border-bottom: none;
-    }
-
-    .search-result-item:hover {
-      background: #f0f7ff;
-    }
-
-    .search-result-name {
-      font-weight: 600;
-      color: var(--text-primary);
-      margin-bottom: 0.25rem;
-    }
-
-    .search-result-org {
-      font-size: 0.9rem;
-      color: var(--text-secondary);
-    }
-
-    .search-section {
-      position: relative;
-    }
-
-    .badge-container {
-      display: none;
-      background-color: var(--card-bg);
-      border-radius: 12px;
-      padding: 2rem;
-      margin-bottom: 2rem;
-      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
-    }
-
-    .badge-container.active {
-      display: block;
-    }
-
-    .cna-name-display {
-      font-size: 1.5rem;
-      font-weight: 600;
-      color: var(--primary-color);
-      margin-bottom: 1.5rem;
-    }
-
-    .badge-grid {
-      display: grid;
-      grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-      gap: 2rem;
-      margin-bottom: 2rem;
-    }
-
-    .badge-item {
-      border: 1px solid var(--border-color);
-      border-radius: 8px;
-      padding: 1.5rem;
-      background-color: #fafafa;
-    }
-
-    .badge-title {
-      font-weight: 600;
-      margin-bottom: 1rem;
-      color: var(--text-primary);
-    }
-
-    .badge-preview {
-      margin-bottom: 1rem;
-      padding: 1rem;
-      background: white;
-      border-radius: 4px;
-      text-align: center;
-    }
-
-    .badge-code {
-      background: #f5f5f5;
-      border: 1px solid var(--border-color);
-      border-radius: 4px;
-      padding: 1rem;
-      font-family: 'Monaco', 'Menlo', monospace;
-      font-size: 0.9rem;
-      overflow-x: auto;
-      position: relative;
-    }
-
-    .copy-button {
-      position: absolute;
-      top: 0.5rem;
-      right: 0.5rem;
-      background: var(--primary-color);
-      color: white;
-      border: none;
-      padding: 0.5rem 1rem;
-      border-radius: 4px;
-      cursor: pointer;
-      font-size: 0.85rem;
-      transition: background 0.3s;
-    }
-
-    .copy-button:hover {
-      background: #0052a3;
-    }
-
-    .copy-button.copied {
-      background: #10B981;
-    }
-
-    .instructions {
-      background-color: var(--card-bg);
-      border-radius: 12px;
-      padding: 2rem;
-      margin-bottom: 2rem;
-      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
-    }
-
-    .instructions h2 {
-      color: var(--primary-color);
-      margin-bottom: 1rem;
-    }
-
-    .instructions code {
-      background: #f5f5f5;
-      padding: 0.2rem 0.5rem;
-      border-radius: 3px;
-      font-family: 'Monaco', 'Menlo', monospace;
-      font-size: 0.9rem;
-    }
-
-    .grading-scale {
-      background-color: var(--card-bg);
-      border-radius: 12px;
-      padding: 2rem;
-      margin-bottom: 2rem;
-      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
-    }
-
-    .grading-scale h2 {
-      color: var(--primary-color);
-      margin-bottom: 1rem;
-    }
-
-    .grade-list {
-      display: grid;
-      grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
-      gap: 1rem;
-    }
-
-    .grade-item {
-      padding: 1rem;
-      border-radius: 6px;
-      text-align: center;
-      color: white;
-      font-weight: 600;
-    }
-
-    @media (max-width: 768px) {
-      .page-title {
-        font-size: 2rem;
-      }
-
-      .badge-grid {
-        grid-template-columns: 1fr;
-      }
-    }
-  </style>
-</head>
-
-<body>
-  <!-- Skip Link for Accessibility -->
-  <a href="#main-content" class="skip-link">Skip to main content</a>
-
-  <!-- Navigation Bar -->
-  <nav class="navbar" role="navigation" aria-label="Main Navigation">
-    <img src="assets/logo.svg" alt="CNA Scorecard Logo" class="navbar-logo">
-    <div class="navbar-links">
-      <a href="index.html">Home</a>
-      <a href="cna/index.html">CNAs</a>
-      <a href="completeness/index.html">Record Completeness</a>
-      <a href="trends.html">Performance Trends</a>
-      <a href="scoring.html">Methodology</a>
-    </div>
-  </nav>
-
-  <main class="container" id="main-content">
-    <!-- Page Header -->
-    <section class="page-header">
-      <h1 class="page-title">CNA Scorecard Badges</h1>
-      <p class="page-subtitle">
-        Display your CNA Scorecard rating on your website, README, or documentation!
-        Choose from three badge styles and copy the code to embed in your content.
-      </p>
-    </section>
-
-    <!-- Search Section -->
-    <section class="search-section">
-      <label for="cna-search" style="display: block; margin-bottom: 0.5rem; font-weight: 600;">Search for your
-        CNA:</label>
-      <input type="text" id="cna-search" placeholder="Enter CNA name (e.g., Microsoft, Cisco, Linux)..."
-        class="search-input">
-      <div id="search-results" class="search-results"></div>
-    </section>
-
-    <!-- Badge Display Section -->
-    <section id="badge-container" class="badge-container">
-      <h2 class="cna-name-display" id="cna-name-display"></h2>
-      <div class="badge-grid" id="badge-grid"></div>
-    </section>
-
-    <!-- Instructions -->
-    <section class="instructions">
-      <h2>How to Use</h2>
-      <ol style="line-height: 1.8;">
-        <li>Search for your CNA name above</li>
-        <li>Choose your preferred badge style (Rank, Score, or Combined)</li>
-        <li>Click the "Copy" button to copy the badge code</li>
-        <li>Paste the code into your README, website, or documentation</li>
-      </ol>
-      <p style="margin-top: 1.5rem; color: var(--text-secondary);">
-        <strong>Note:</strong> Badges are automatically updated every time the CNA Scorecard pipeline runs,
-        so your badge will always reflect your latest score!
-      </p>
-    </section>
-
-    <!-- Color Scheme -->
-    <section class="grading-scale">
-      <h2>Badge Color Scheme</h2>
-      <p style="color: var(--text-secondary); margin-bottom: 1.5rem;">
-        Badge colors are determined by CNA scores to provide quick visual feedback on performance.
-      </p>
-      <div class="grade-list">
-        <div class="grade-item" style="background-color: #00A86B;">Excellent<br>90-100%</div>
-        <div class="grade-item" style="background-color: #10B981;">Very Good<br>80-89%</div>
-        <div class="grade-item" style="background-color: #60A5FA;">Good<br>70-79%</div>
-        <div class="grade-item" style="background-color: #FBBF24;">Fair<br>60-69%</div>
-        <div class="grade-item" style="background-color: #EF4444;">Needs Improvement<br>Below 60%</div>
-      </div>
-    </section>
-  </main>
-
-  <!-- Footer -->
-  <footer class="footer">
-    <div class="footer-main">
-      <div class="footer-brand">
-        <img src="assets/logo.svg" alt="CNA Scorecard Logo" class="footer-logo">
-        <span class="footer-title">CNA Scorecard</span>
-      </div>
-      <div class="footer-links">
-        <a href="https://github.com/CVEDB/cvedb.github.io" target="_blank">GitHub</a>
-        <a href="https://cvedb.github.io" target="_blank">CVEDB</a>
-        <a href="https://patchthis.app" target="_blank">PatchThis</a>
-        <a href="https://cveforecast.org" target="_blank">CVEForecast</a>
-        <a href="https://cvedb.github.io" target="_blank">CVEDB</a>
-      </div>
-    </div>
-    <div class="footer-meta">&copy; 2025 CVEDB. All rights reserved.</div>
-  </footer>
-
-  <!-- JavaScript -->
-  <script>
-    const baseUrl = window.location.origin;
-    let cnaData = [];
-
-    // Load CNA data
-    async function loadCNAData() {
-      try {
-        const response = await fetch('./data/cna_combined.json');
-        cnaData = await response.json();
-      } catch (error) {
-        console.error('Error loading CNA data:', error);
-      }
-    }
-
-    // Search functionality
-    const searchInput = document.getElementById('cna-search');
-    const searchResults = document.getElementById('search-results');
-    const badgeContainer = document.getElementById('badge-container');
-    const cnaNameDisplay = document.getElementById('cna-name-display');
-    const badgeGrid = document.getElementById('badge-grid');
-
-    searchInput.addEventListener('input', (e) => {
-      const searchTerm = e.target.value.toLowerCase().trim();
-
-      if (searchTerm.length < 2) {
-        searchResults.classList.remove('active');
-        badgeContainer.classList.remove('active');
-        return;
-      }
-
-      const matchedCNAs = cnaData.filter(cna =>
-        cna.shortName.toLowerCase().includes(searchTerm) ||
-        cna.organizationName.toLowerCase().includes(searchTerm)
-      );
-
-      if (matchedCNAs.length > 0) {
-        displaySearchResults(matchedCNAs);
-      } else {
-        searchResults.classList.remove('active');
-        badgeContainer.classList.remove('active');
-      }
-    });
-
-    // Close search results when clicking outside
-    document.addEventListener('click', (e) => {
-      if (!searchResults.contains(e.target) && e.target !== searchInput) {
-        searchResults.classList.remove('active');
-      }
-    });
-
-    function displaySearchResults(cnas) {
-      searchResults.innerHTML = cnas.map(cna => `
-        <div class="search-result-item" onclick="selectCNA('${cna.shortName.replace(/'/g, "\\'")}')">
-          <div class="search-result-name">${cna.shortName}</div>
-          <div class="search-result-org">${cna.organizationName}</div>
-        </div>
-      `).join('');
-      searchResults.classList.add('active');
-    }
-
-    window.selectCNA = function (shortName) {
-      const cna = cnaData.find(c => c.shortName === shortName);
-      if (cna) {
-        displayBadges(cna);
-        searchInput.value = cna.shortName;
-        searchResults.classList.remove('active');
-      }
-    }
-
-    function displayBadges(cna) {
-      const safeName = cna.shortName.replace(/\//g, '_').replace(/\\/g, '_');
-      const score = cna.scores.overall_average_score.toFixed(1);
-
-      cnaNameDisplay.textContent = `${cna.organizationName} (${cna.shortName})`;
-
-      const badges = [
-        {
-          title: 'Rank Badge',
-          style: 'rank',
-          description: 'Shows CNA rank only'
-        },
-        {
-          title: 'Score Badge',
-          style: 'score',
-          description: 'Shows percentage score only'
-        },
-        {
-          title: 'Combined Badge',
-          style: 'both',
-          description: 'Shows both rank and score'
-        }
-      ];
-
-      badgeGrid.innerHTML = badges.map(badge => `
-        <div class="badge-item">
-          <div class="badge-title">${badge.title}</div>
-          <div style="color: var(--text-secondary); font-size: 0.9rem; margin-bottom: 1rem;">
-            ${badge.description}
-          </div>
-          <div class="badge-preview">
-            <img src="${baseUrl}/badges/${safeName}-${badge.style}.svg" alt="${cna.shortName} CNA Scorecard">
-          </div>
-          <div class="badge-code" id="code-${badge.style}">
-            <button class="copy-button" onclick="copyCode('${badge.style}', '${safeName}', '${cna.shortName}')">
-              Copy
-            </button>
-            <div style="padding-right: 70px;">![CNA Scorecard](${baseUrl}/badges/${safeName}-${badge.style}.svg)</div>
-          </div>
-        </div>
-      `).join('');
-
-      badgeContainer.classList.add('active');
-    }
-
-    function copyCode(style, safeName, cnaName) {
-      const code = `![CNA Scorecard](${baseUrl}/badges/${safeName}-${style}.svg)`;
-
-      navigator.clipboard.writeText(code).then(() => {
-        const button = event.target;
-        const originalText = button.textContent;
-        button.textContent = 'Copied!';
-        button.classList.add('copied');
-
-        setTimeout(() => {
-          button.textContent = originalText;
-          button.classList.remove('copied');
-        }, 2000);
-      });
-    }
-
-    // Initialize
-    document.addEventListener('DOMContentLoaded', loadCNAData);
-  </script>
-</body>
-
-</html>
\ No newline at end of file
diff --git a/templates/cna/cna-hub.html b/templates/cna/cna-hub.html
deleted file mode 100644
index 9c484e18c58..00000000000
--- a/templates/cna/cna-hub.html
+++ /dev/null
@@ -1,283 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}CNA Intelligence Hub - CVEDB{% endblock %}
-
-{% block content %}
-<style>
-    .cna-stats-grid {
-        display: grid;
-        grid-template-columns: repeat(2, 1fr);
-        gap: 1.5rem;
-        margin-bottom: 2rem;
-    }
-
-    @media (max-width: 768px) {
-        .cna-stats-grid {
-            grid-template-columns: 1fr;
-        }
-    }
-
-    .cna-card {
-        background: var(--color-bg-content);
-        border: 1px solid var(--color-border);
-        border-radius: var(--border-radius-lg);
-        padding: 1.5rem;
-        transition: transform 0.2s, box-shadow 0.2s;
-        height: 100%;
-        display: flex;
-        flex-direction: column;
-    }
-
-    .cna-card:hover {
-        transform: translateY(-2px);
-        box-shadow: var(--box-shadow-lg);
-    }
-
-    .cna-card h3 {
-        font-size: 1.25rem;
-        font-weight: var(--font-weight-semibold);
-        margin-bottom: 0;
-        color: var(--color-text-primary);
-    }
-
-    .cna-card .badge {
-        font-size: 0.75rem;
-        padding: 0.25rem 0.5rem;
-        font-weight: var(--font-weight-medium);
-    }
-
-    .cna-card .big-number {
-        font-size: 2.5rem;
-        font-weight: var(--font-weight-bold);
-        color: var(--color-primary);
-        line-height: 1.2;
-        margin: 0.5rem 0 0.25rem 0;
-    }
-
-    .cna-card .stat-label {
-        font-size: 0.9rem;
-        color: var(--color-text-secondary);
-        margin-bottom: 0.75rem;
-    }
-
-    .cna-card .description {
-        color: var(--color-text-secondary);
-        font-size: 0.9rem;
-        margin: 0.75rem 0;
-        line-height: 1.5;
-        flex-grow: 1;
-    }
-
-    .cna-card .question {
-        font-style: italic;
-        color: var(--color-text-secondary);
-        font-size: 0.85rem;
-        padding: 0.75rem;
-        background: var(--color-bg-secondary);
-        border-radius: var(--border-radius);
-        margin-top: auto;
-    }
-
-    .nav-card {
-        display: block;
-        text-decoration: none;
-        color: inherit;
-    }
-
-    .nav-card:hover {
-        text-decoration: none;
-        color: inherit;
-    }
-
-    .cna-summary-grid {
-        display: grid;
-        grid-template-columns: repeat(4, 1fr);
-        gap: 1rem;
-        margin-bottom: 2rem;
-    }
-
-    @media (max-width: 992px) {
-        .cna-summary-grid {
-            grid-template-columns: repeat(2, 1fr);
-        }
-    }
-
-    @media (max-width: 576px) {
-        .cna-summary-grid {
-            grid-template-columns: 1fr;
-        }
-    }
-
-    .summary-stat {
-        background: var(--color-bg-content);
-        border: 1px solid var(--color-border);
-        border-radius: var(--border-radius);
-        padding: 1rem;
-        text-align: center;
-    }
-
-    .summary-stat .number {
-        font-size: 1.75rem;
-        font-weight: var(--font-weight-bold);
-        color: var(--color-primary);
-    }
-
-    .summary-stat .label {
-        font-size: 0.85rem;
-        color: var(--color-text-secondary);
-    }
-</style>
-
-<!-- Hero Section -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">CNA Intelligence Hub</h1>
-    <p class="text-muted">
-        Analyze CVE Numbering Authorities: activity metrics, quality insights, and attribution data
-    </p>
-</div>
-
-<!-- Quick Stats -->
-<div class="cna-summary-grid">
-    <div class="summary-stat">
-        <div class="number" id="totalCnas">-</div>
-        <div class="label">Total CNAs</div>
-    </div>
-    <div class="summary-stat">
-        <div class="number" id="activeCnas">-</div>
-        <div class="label">Active CNAs</div>
-    </div>
-    <div class="summary-stat">
-        <div class="number" id="matchRate">-</div>
-        <div class="label">Name Match Rate</div>
-    </div>
-    <div class="summary-stat">
-        <div class="number" id="totalCves">-</div>
-        <div class="label">Total CVEs</div>
-    </div>
-</div>
-
-<!-- Main CNA Analysis Cards -->
-<div class="cna-stats-grid">
-    <!-- CNA Intelligence Card -->
-    <a href="cna.html" class="nav-card">
-        <div class="cna-card">
-            <div class="d-flex justify-content-between align-items-start mb-2">
-                <h3>CNA Intelligence</h3>
-                <span class="badge bg-primary">Analytics</span>
-            </div>
-            <div class="big-number" id="cnaCount">-</div>
-            <div class="stat-label">Active CVE Assigners</div>
-            <p class="description">
-                Comprehensive analysis of all CVE Numbering Authorities including <strong>activity metrics,
-                    KEV/EPSS correlations, volume trends</strong>, and links to CNAScorecard.
-            </p>
-            <div class="question">
-                💡 "Which CNAs are most active? Which have the most exploited CVEs?"
-            </div>
-        </div>
-    </a>
-
-    <!-- Name Matching Quality Card -->
-    <a href="data-quality.html" class="nav-card">
-        <div class="cna-card">
-            <div class="d-flex justify-content-between align-items-start mb-2">
-                <h3>Name Matching</h3>
-                <span class="badge bg-secondary">Quality</span>
-            </div>
-            <div class="big-number" id="unmatchedCount">-</div>
-            <div class="stat-label">Unmatched CNAs</div>
-            <p class="description">
-                CNAScorecard-style name matching analysis showing how CVE assigner names
-                <strong>align with the official CNA registry</strong>. Identifies naming inconsistencies.
-            </p>
-            <div class="question">
-                💡 "Are CVE attributions accurate? Which names don't match the registry?"
-            </div>
-        </div>
-    </a>
-</div>
-
-<!-- About CNAs Section -->
-<div class="card mb-4">
-    <div class="card-header">
-        <h3 class="card-title mb-0">What is a CNA?</h3>
-    </div>
-    <div class="card-body">
-        <p>
-            <strong>CVE Numbering Authorities (CNAs)</strong> are organizations authorized by the CVE Program
-            to assign CVE IDs to vulnerabilities in their scope. CNAs include:
-        </p>
-        <div class="row mt-3">
-            <div class="col-md-4 mb-3">
-                <h5>Vendors</h5>
-                <p class="text-muted small">
-                    Software companies assigning CVEs for their own products (Microsoft, Google, Apple, etc.)
-                </p>
-            </div>
-            <div class="col-md-4 mb-3">
-                <h5>Researchers</h5>
-                <p class="text-muted small">
-                    Security research organizations and bug bounty programs (HackerOne, Bugcrowd, etc.)
-                </p>
-            </div>
-            <div class="col-md-4 mb-3">
-                <h5>Coordinators</h5>
-                <p class="text-muted small">
-                    National CERTs and coordination centers (MITRE, CISA, CERT/CC, etc.)
-                </p>
-            </div>
-        </div>
-        <p class="text-muted small mb-0">
-            <a href="https://www.cve.org/PartnerInformation/ListofPartners" target="_blank" rel="noopener">
-                View the official CNA list on CVE.org →
-            </a>
-        </p>
-    </div>
-</div>
-
-{% endblock %}
-
-{% block scripts %}
-<script>
-    async function loadCnaHubData() {
-        try {
-            // Load CNA analysis
-            const cnaResponse = await fetch('data/cna_analysis.json');
-            const cnaData = await cnaResponse.json();
-
-            document.getElementById('totalCnas').textContent = cnaData.total_cnas?.toLocaleString() || '-';
-            document.getElementById('activeCnas').textContent = cnaData.active_cnas?.toLocaleString() || '-';
-            document.getElementById('cnaCount').textContent = cnaData.active_cnas?.toLocaleString() || '-';
-
-            // Calculate total CVEs from repository_stats
-            const totalCves = cnaData.repository_stats?.total_cves || 0;
-            document.getElementById('totalCves').textContent = totalCves.toLocaleString();
-
-        } catch (error) {
-            console.error('Error loading CNA data:', error);
-        }
-
-        try {
-            // Load data quality
-            const qualityResponse = await fetch('data/data_quality.json');
-            const qualityData = await qualityResponse.json();
-
-            const stats = qualityData.stats;
-            document.getElementById('unmatchedCount').textContent = stats.unmatched?.toLocaleString() || '-';
-
-            // Calculate match rate
-            const total = stats.total_cnas_in_analysis || 0;
-            const matched = total - (stats.unmatched || 0);
-            const rate = total > 0 ? ((matched / total) * 100).toFixed(1) + '%' : '-';
-            document.getElementById('matchRate').textContent = rate;
-
-        } catch (error) {
-            console.error('Error loading quality data:', error);
-            document.getElementById('unmatchedCount').textContent = '-';
-            document.getElementById('matchRate').textContent = '-';
-        }
-    }
-
-    document.addEventListener('DOMContentLoaded', loadCnaHubData);
-</script>
-{% endblock %}
\ No newline at end of file
diff --git a/templates/cna/cna.html b/templates/cna/cna.html
deleted file mode 100644
index b6b08a6cec4..00000000000
--- a/templates/cna/cna.html
+++ /dev/null
@@ -1,1918 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}CNA Analysis - CVEDB{% endblock %}
-
-{% block content %}
-<!-- Hero Section -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">CNA Intelligence Dashboard</h1>
-    <small class="text-muted d-block mb-3" id="pageSubtitle">
-        Showing comprehensive analysis across all years (1999-2025)
-    </small>
-
-    <!-- Data Mode Toggle -->
-    <div class="d-flex justify-content-center mb-3">
-        <button type="button" id="dataToggleBtn" onclick="toggleDataMode()" style="
-            color: var(--color-text-secondary);
-            font-weight: var(--font-weight-medium);
-            padding: var(--spacing-sm) var(--spacing-md);
-            border-radius: var(--border-radius);
-            transition: all 0.15s ease-in-out;
-            background: none;
-            border: 2px solid var(--color-border);
-            cursor: pointer;
-            font-size: inherit;
-        " onmouseover="this.style.color='var(--color-accent)'; this.style.backgroundColor='rgba(13, 110, 253, 0.1)'; this.style.borderColor='var(--color-accent)'"
-            onmouseout="this.style.color='var(--color-text-secondary)'; this.style.backgroundColor='transparent'; this.style.borderColor='var(--color-border)'">
-            <span id="toggleText">Switch to 2025 Only</span>
-        </button>
-    </div>
-</div>
-
-<!-- Statistics Cards -->
-<div class="stats-grid mb-4">
-    <div class="stat-card">
-        <div class="stat-number" id="activeCnas">Loading...</div>
-        <div class="stat-label">Active CNAs</div>
-        <small class="text-muted" style="font-size: 0.75rem;">📈 Currently publishing</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="highVolumeCnas">Loading...</div>
-        <div class="stat-label">High-Volume CNAs</div>
-        <small class="text-muted" style="font-size: 0.75rem;">🚀 CNAs with 1000+ CVEs</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="medianYearsActive">Loading...</div>
-        <div class="stat-label">Median Years Active</div>
-        <small class="text-muted" style="font-size: 0.75rem;">📊 Typical CNA lifespan</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="marketConcentration">Loading...</div>
-        <div class="stat-label">Top 5 CNA Share</div>
-        <small class="text-muted" style="font-size: 0.75rem;">📊 Concentration of assignments</small>
-    </div>
-</div>
-
-<!-- Top CNAs and CNA Type Distribution -->
-<div class="row mb-4">
-    <div class="col-lg-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">Top CNAs by Volume</h3>
-                <small class="text-muted">Leading CVE Numbering Authorities by total assignments</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="topCnasChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <div class="col-lg-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">CNA Type Distribution</h3>
-                <small class="text-muted">CNAs by organization type</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="cnaTypeChart"></canvas>
-                </div>
-                <small class="text-muted mt-2 d-block">
-                    <i class="fas fa-info-circle me-1"></i>
-                    Note: CNAs can and often have multiple types (e.g., Vendor + Researcher).
-                </small>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- CNA Activity Analysis -->
-<div class="row mb-4">
-    <div class="col-lg-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">CNA Lifecycle Stages</h3>
-                <small class="text-muted">CNAs categorized by years of activity</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="cnaActivityChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <div class="col-lg-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">🎯 Top CNAs by KEV Count</h3>
-                <small class="text-muted">CNAs with most known exploited vulnerabilities</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="cnaKevChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- Additional Analysis Charts -->
-<div class="row mb-4">
-    <div class="col-lg-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">CNA Assignment Volume</h3>
-                <small class="text-muted">CNAs categorized by total CVE assignments</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="cnaVolumeChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <div class="col-lg-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">📈 CNA Growth Leaders</h3>
-                <small class="text-muted">Most active CNAs in the current year</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="cnaGrowthChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- Smart Insights Panel -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">🔍 CNA Intelligence Insights</h3>
-    </div>
-    <div class="card-body py-3">
-        <div class="row" id="cnaInsights">
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">🏆</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Top CNA</div>
-                        <div class="insight-text" id="marketLeaderInsight">Loading...</div>
-                    </div>
-                </div>
-            </div>
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">📊</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Activity Status</div>
-                        <div class="insight-text" id="activityInsight">Loading...</div>
-                    </div>
-                </div>
-            </div>
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">🏢</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Years Active</div>
-                        <div class="insight-text" id="orgTypeInsight">Loading...</div>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- Detailed CNA Table -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">📋 Comprehensive CNA Directory</h3>
-        <small class="text-muted">All CVE Numbering Authorities with assignment statistics - Click column headers to
-            sort</small>
-    </div>
-    <div class="card-body py-3">
-        <!-- Filter Controls -->
-        <div class="filter-bar mb-3" id="filterBar">
-            <div class="d-flex flex-wrap gap-2 align-items-center">
-                <div class="filter-group">
-                    <label class="filter-label">Type:</label>
-                    <select id="filterType" class="filter-select" onchange="applyFilters()">
-                        <option value="">All Types</option>
-                        <option value="Vendor">Vendor</option>
-                        <option value="CERT">CERT</option>
-                        <option value="Security Researcher">Security Researcher</option>
-                        <option value="Open Source">Open Source</option>
-                        <option value="Government">Government</option>
-                        <option value="Program">Program</option>
-                        <option value="Academic">Academic</option>
-                        <option value="Other">Other</option>
-                    </select>
-                </div>
-                <div class="filter-group">
-                    <label class="filter-label">Status:</label>
-                    <select id="filterStatus" class="filter-select" onchange="applyFilters()">
-                        <option value="">All</option>
-                        <option value="Active">Active</option>
-                        <option value="Inactive">Inactive</option>
-                    </select>
-                </div>
-                <div class="filter-group">
-                    <label class="filter-label">
-                        <input type="checkbox" id="filterKev" onchange="applyFilters()">
-                        Has KEV CVEs
-                    </label>
-                </div>
-                <div class="filter-group">
-                    <label class="filter-label">
-                        <input type="checkbox" id="filterHighVolume" onchange="applyFilters()">
-                        High Volume (1000+)
-                    </label>
-                </div>
-                <div class="filter-group ms-auto">
-                    <button class="btn btn-sm btn-outline-secondary" onclick="resetFilters()">Reset Filters</button>
-                </div>
-            </div>
-            <div class="filter-summary mt-2" id="filterSummary" style="display: none;">
-                <small class="text-muted"><span id="filteredCount">0</span> CNAs match current filters</small>
-            </div>
-        </div>
-
-        <div class="table-responsive">
-            <table class="table table-hover" id="cnaTable">
-                <thead>
-                    <tr>
-                        <th class="sortable" data-sort="rank" style="width: 80px;">Rank <span
-                                class="sort-indicator">▼</span></th>
-                        <th class="sortable" data-sort="name" style="width: 280px;">CNA Name <span
-                                class="sort-indicator"></span></th>
-                        <th class="sortable" data-sort="count" style="width: 130px;">CVEs Assigned <span
-                                class="sort-indicator"></span></th>
-                        <th class="sortable" data-sort="years_active" style="width: 120px;">Years Active <span
-                                class="sort-indicator"></span></th>
-                        <th class="sortable" data-sort="last_cve_date" style="width: 140px;">Last CVE Date <span
-                                class="sort-indicator"></span></th>
-                        <th class="sortable" data-sort="activity_status" style="width: 100px;">Status <span
-                                class="sort-indicator"></span></th>
-                        <th style="width: 80px;">Scorecard</th>
-                    </tr>
-                </thead>
-                <tbody id="cnaTableBody">
-                    <tr>
-                        <td colspan="7" class="text-center text-muted">Loading CNA data...</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-
-        <!-- Pagination Controls -->
-        <div class="mt-3 text-center">
-            <div class="text-muted mb-2" id="paginationInfo">
-                Showing 1-25 of 0 CNAs
-            </div>
-            <nav aria-label="CNA table pagination" class="d-inline-block">
-                <ul class="pagination pagination-sm mb-0" id="paginationControls">
-                    <!-- Pagination will be dynamically generated -->
-                </ul>
-            </nav>
-        </div>
-    </div>
-</div>
-
-<!-- Export and Share Panel -->
-<div class="card mb-3">
-    <div class="card-header py-2">
-        <h2 class="card-title mb-0" style="font-size: 1.1rem;">📤 Export & Share</h2>
-    </div>
-    <div class="card-body py-3">
-        <div class="export-buttons">
-            <button class="btn btn-primary btn-sm" onclick="exportCnaCSV()">📊 Export CSV</button>
-            <button class="btn btn-primary btn-sm" onclick="exportCnaJSON()">📋 Export JSON</button>
-            <button class="btn btn-secondary btn-sm" onclick="generatePermalink()">🔗 Share Link</button>
-            <button class="btn btn-secondary btn-sm" onclick="window.print()">🖨️ Print Report</button>
-        </div>
-        <div class="permalink-result mt-2" id="permalinkResult" style="display: none;">
-            <input type="text" class="form-control" id="permalinkInput" readonly>
-            <button class="btn btn-outline-primary btn-sm mt-1" onclick="copyPermalink()">Copy Link</button>
-        </div>
-    </div>
-</div>
-
-<!-- Data Source Note -->
-
-
-{% endblock %}
-
-{% block scripts %}
-<script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.js"></script>
-<style>
-    .sortable {
-        cursor: pointer;
-        user-select: none;
-        position: relative;
-    }
-
-    .sortable:hover {
-        background-color: #f8f9fa;
-    }
-
-    .sort-indicator {
-        font-size: 0.8em;
-        margin-left: 5px;
-        color: #6c757d;
-    }
-
-    .pagination {
-        display: flex;
-        list-style: none;
-        margin: 0 auto;
-        padding: 0;
-        justify-content: center;
-    }
-
-    .pagination .page-item {
-        display: inline-block;
-    }
-
-    .pagination .page-link {
-        color: #0d6efd;
-        padding: 0.375rem 0.75rem;
-        margin-left: -1px;
-        line-height: 1.25;
-        text-decoration: none;
-        background-color: #fff;
-        border: 1px solid #dee2e6;
-        display: block;
-    }
-
-    .pagination .page-link:hover {
-        color: #0a58ca;
-        background-color: #e9ecef;
-        border-color: #dee2e6;
-    }
-
-    .pagination .page-item.active .page-link {
-        background-color: #0d6efd;
-        border-color: #0d6efd;
-        color: #fff;
-    }
-
-    .pagination .page-item.disabled .page-link {
-        color: #6c757d;
-        background-color: #fff;
-        border-color: #dee2e6;
-        cursor: not-allowed;
-    }
-
-    .pagination .page-item:first-child .page-link {
-        margin-left: 0;
-        border-top-left-radius: 0.25rem;
-        border-bottom-left-radius: 0.25rem;
-    }
-
-    .pagination .page-item:last-child .page-link {
-        border-top-right-radius: 0.25rem;
-        border-bottom-right-radius: 0.25rem;
-    }
-
-    .scorecard-link {
-        display: inline-flex;
-        align-items: center;
-        justify-content: center;
-        text-decoration: none;
-        font-size: 1.1rem;
-        opacity: 0.7;
-        transition: opacity 0.15s ease-in-out, transform 0.15s ease-in-out;
-    }
-
-    .scorecard-link:hover {
-        opacity: 1;
-        transform: scale(1.1);
-    }
-
-    .filter-bar {
-        padding: var(--spacing-sm) var(--spacing-md);
-        background: var(--color-surface);
-        border-radius: var(--border-radius);
-        border: 1px solid var(--color-border);
-    }
-
-    .filter-group {
-        display: flex;
-        align-items: center;
-        gap: 0.5rem;
-    }
-
-    .filter-label {
-        font-size: 0.85rem;
-        color: var(--color-text-secondary);
-        margin: 0;
-        white-space: nowrap;
-    }
-
-    .filter-select {
-        padding: 0.25rem 0.5rem;
-        border-radius: 4px;
-        border: 1px solid var(--color-border);
-        background: var(--color-background);
-        color: var(--color-text-primary);
-        font-size: 0.85rem;
-        cursor: pointer;
-    }
-
-    .filter-select:focus {
-        outline: none;
-        border-color: var(--color-accent);
-    }
-
-    .filter-label input[type="checkbox"] {
-        margin-right: 0.25rem;
-        cursor: pointer;
-    }
-
-    .filter-summary {
-        font-size: 0.85rem;
-    }
-</style>
-
-<script>
-    // Global variables
-    let cnaData = null;
-    let currentYearData = null;
-    let charts = {};
-    let currentDataMode = 'all'; // 'all' or 'current'
-
-    // Global state management
-    window.CNA_STATE = {
-        dataMode: 'all',
-        cnaData: null,
-        currentYearData: null,
-        charts: {}
-    };
-
-    // Initialize page
-    document.addEventListener('DOMContentLoaded', function () {
-        loadCnaData();
-        loadCurrentYearData();
-    });
-
-    // Load CNA data
-    function loadCnaData() {
-        fetch('/data/cna_analysis.json')
-            .then(response => {
-                if (!response.ok) {
-                    throw new Error(`HTTP error! status: ${response.status}`);
-                }
-                return response.json();
-            })
-            .then(data => {
-                cnaData = data;
-                window.CNA_STATE.cnaData = data;
-                if (currentYearData || !currentYearData) {
-                    initializePage();
-                }
-            })
-            .catch(error => {
-                console.error('Error loading CNA data:', error);
-                showErrorState();
-            });
-    }
-
-    // Load current year data
-    function loadCurrentYearData() {
-        fetch('/data/cna_analysis_current_year.json')
-            .then(response => response.json())
-            .then(data => {
-                currentYearData = data;
-                window.CNA_STATE.currentYearData = data;
-                if (cnaData) {
-                    initializePage();
-                }
-            })
-            .catch(error => {
-                console.error('Error loading current year CNA data:', error);
-                showErrorState();
-            });
-    }
-
-    // Initialize page after data is loaded
-    function initializePage() {
-        updateStatistics();
-        createCharts();
-        generateInsights();
-        populateTable(); // This calls renderTable() internally
-    }
-
-    // Get current data source based on mode
-    function getCurrentDataSource() {
-        const mode = currentDataMode || window.CNA_STATE.dataMode;
-        const result = mode === 'all' ? (cnaData || window.CNA_STATE.cnaData) : (currentYearData || window.CNA_STATE.currentYearData);
-        return result;
-    }
-
-    // Process current year type distribution
-    function processCurrentYearTypeDistribution(yearData) {
-        // For current year, we need to map CNA assigners to their types from the main data
-        const typeDistribution = [];
-
-        if (!yearData.cna_list || !cnaData.cna_list) {
-            return typeDistribution;
-        }
-
-        const typeCounts = {};
-        const totalCnas = yearData.cna_list.length;
-
-        // Map current year CNAs to their types from the comprehensive data
-        yearData.cna_list.forEach(cna => {
-            const fullCnaInfo = cnaData.cna_list.find(c => c.name === cna.name);
-            if (fullCnaInfo && fullCnaInfo.cna_types) {
-                fullCnaInfo.cna_types.forEach(type => {
-                    typeCounts[type] = (typeCounts[type] || 0) + 1;
-                });
-            }
-        });
-
-        // Convert to percentage format
-        Object.entries(typeCounts).forEach(([type, count]) => {
-            const percentage = totalCnas > 0 ? (count / totalCnas) * 100 : 0;
-            typeDistribution.push({
-                type: type,
-                count: count,
-                percentage: Math.round(percentage * 10) / 10
-            });
-        });
-
-        return typeDistribution.sort((a, b) => b.percentage - a.percentage);
-    }
-
-    // Generate color gradient
-    function generateColorGradient(startColor, endColor, steps) {
-        const colors = [];
-        const start = hexToRgb(startColor);
-        const end = hexToRgb(endColor);
-
-        for (let i = 0; i < steps; i++) {
-            const ratio = i / (steps - 1);
-            const r = Math.round(start.r + ratio * (end.r - start.r));
-            const g = Math.round(start.g + ratio * (end.g - start.g));
-            const b = Math.round(start.b + ratio * (end.b - start.b));
-            colors.push(`rgb(${r}, ${g}, ${b})`);
-        }
-
-        return colors;
-    }
-
-    // Convert hex to RGB
-    function hexToRgb(hex) {
-        const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-        return result ? {
-            r: parseInt(result[1], 16),
-            g: parseInt(result[2], 16),
-            b: parseInt(result[3], 16)
-        } : null;
-    }
-
-    // Set data mode
-    function setDataMode(mode) {
-        // Update both global variables and window state
-        currentDataMode = mode;
-        window.CNA_STATE.dataMode = mode;
-
-        updateToggleUI();
-
-        // Show/hide CNA Activity Status chart based on data mode
-        const activityStatusContainer = document.getElementById('cnaActivityStatusContainer');
-        if (activityStatusContainer) {
-            if (currentDataMode === 'current') {
-                // Hide in current year mode since all CNAs are active by definition
-                activityStatusContainer.style.display = 'none';
-            } else {
-                // Show in all-time mode where active/inactive distinction is meaningful
-                activityStatusContainer.style.display = 'block';
-            }
-        }
-
-        // Refresh all visualizations with new data mode
-        updateStatistics();
-        createCharts();
-        generateInsights();
-        populateTable(); // This calls renderTable() internally
-    }
-
-    // Update toggle UI elements
-    function updateToggleUI() {
-        const toggleText = document.getElementById('toggleText');
-        const pageSubtitle = document.getElementById('pageSubtitle');
-
-        if (currentDataMode === 'all') {
-            toggleText.textContent = 'Switch to 2025 Only';
-            pageSubtitle.textContent = 'Showing comprehensive analysis across all years (1999-2025)';
-        } else {
-            toggleText.textContent = 'Switch to All-Time';
-            pageSubtitle.textContent = 'Showing analysis for 2025 data only';
-        }
-    }
-
-    // Legacy functions for backward compatibility
-    function toggleDataMode() {
-        const newMode = currentDataMode === 'all' ? 'current' : 'all';
-        setDataMode(newMode);
-    }
-
-    function switchDataMode(mode) {
-        setDataMode(mode);
-    }
-
-    // Update statistics cards
-    function updateStatistics() {
-        const currentData = getCurrentDataSource();
-        if (!currentData) return;
-
-        let activeCnas, highVolumeCnas, totalCves, medianYearsActive, marketConcentration;
-
-        if (currentDataMode === 'all') {
-            // All-time data from comprehensive analysis
-            if (!currentData.cna_list) return;
-
-            activeCnas = currentData.cna_list.filter(cna => cna.activity_status === 'Active').length;
-            highVolumeCnas = currentData.cna_list.filter(cna => cna.count >= 1000).length;
-            totalCves = currentData.cna_list.reduce((sum, cna) => sum + cna.count, 0);
-
-            // Calculate median years active
-            const yearsActive = currentData.cna_list.map(cna => cna.years_active).sort((a, b) => a - b);
-            const medianIndex = Math.floor(yearsActive.length / 2);
-            medianYearsActive = yearsActive.length % 2 === 0
-                ? Math.round((yearsActive[medianIndex - 1] + yearsActive[medianIndex]) / 2)
-                : yearsActive[medianIndex];
-
-            // Calculate market concentration (top 5 CNAs' share)
-            const top5Cves = currentData.cna_list.slice(0, 5).reduce((sum, cna) => sum + cna.count, 0);
-            marketConcentration = ((top5Cves / totalCves) * 100).toFixed(1);
-        } else {
-            // Current year data
-            if (!currentData.cna_list) return;
-
-            activeCnas = currentData.cna_list.length;
-            highVolumeCnas = currentData.cna_list.filter(cna => cna.count >= 1000).length;
-            totalCves = currentData.total_cves || currentData.cna_list.reduce((sum, cna) => sum + cna.count, 0);
-
-            // For current year, years active is always 1
-            medianYearsActive = 1;
-
-            // Calculate market concentration for current year
-            const sortedCnas = currentData.cna_list.slice().sort((a, b) => b.count - a.count);
-            const top5Cves = sortedCnas.slice(0, 5).reduce((sum, cna) => sum + cna.count, 0);
-            marketConcentration = totalCves > 0 ? ((top5Cves / totalCves) * 100).toFixed(1) : '0.0';
-        }
-
-        document.getElementById('activeCnas').textContent = activeCnas.toLocaleString();
-        document.getElementById('highVolumeCnas').textContent = highVolumeCnas.toLocaleString();
-        document.getElementById('medianYearsActive').textContent = `${medianYearsActive} year${medianYearsActive !== 1 ? 's' : ''}`;
-        document.getElementById('marketConcentration').textContent = `${marketConcentration}%`;
-    }
-
-    // Destroy existing charts
-    function destroyCharts() {
-        Object.keys(charts).forEach(chartKey => {
-            if (charts[chartKey]) {
-                charts[chartKey].destroy();
-                delete charts[chartKey];
-            }
-        });
-    }
-
-    // Create all charts
-    function createCharts() {
-        // Destroy existing charts first
-        destroyCharts();
-
-        // Create new charts
-        createTopCnasChart();
-        createActivityChart();
-        // createRecencyChart(); // Temporarily disabled
-        createTypeChart();
-        createVolumeChart();
-        createKevChart();
-        createGrowthChart();
-    }
-
-    // Top CNAs horizontal bar chart
-    function createTopCnasChart() {
-        const ctx = document.getElementById('topCnasChart').getContext('2d');
-
-        const currentData = getCurrentDataSource();
-        if (!currentData) return;
-
-        let topCnas, labels, data;
-
-        if (currentDataMode === 'all') {
-            if (!currentData.cna_list) return;
-            topCnas = currentData.cna_list.slice(0, 15);
-            labels = topCnas.map(cna => cna.name);
-            data = topCnas.map(cna => cna.count);
-        } else {
-            if (!currentData.cna_list) return;
-            // Sort current year CNAs by count and take top 15
-            topCnas = currentData.cna_list
-                .slice().sort((a, b) => b.count - a.count)
-                .slice(0, 15);
-            labels = topCnas.map(cna => cna.name);
-            data = topCnas.map(cna => cna.count);
-        }
-
-        // Update chart subtitle to show current mode
-        const subtitle = document.getElementById('topCnasSubtitle');
-        if (subtitle) {
-            if (currentDataMode === 'all') {
-                subtitle.textContent = 'Showing top 15 CNAs by total CVE assignments (All-Time Data)';
-            } else {
-                subtitle.textContent = 'Showing top 15 CNAs by CVE assignments in 2025 only';
-            }
-        }
-
-        charts.topCnas = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: labels,
-                datasets: [{
-                    label: 'CVEs Assigned',
-                    data: data,
-                    backgroundColor: '#60a5fa',
-                    borderColor: '#3b82f6',
-                    borderWidth: 1
-                }]
-            },
-            options: {
-                indexAxis: 'y',
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        display: false
-                    },
-                    tooltip: {
-                        callbacks: {
-                            title: function (context) {
-                                return context[0].label;
-                            },
-                            label: function (context) {
-                                const cna = topCnas[context.dataIndex];
-                                return [
-                                    `CVEs: ${context.parsed.x.toLocaleString()}`,
-                                    `Years Active: ${cna.years_active}`,
-                                    `Status: ${cna.activity_status}`
-                                ];
-                            }
-                        }
-                    }
-                },
-                scales: {
-                    x: {
-                        beginAtZero: true,
-                        ticks: {
-                            callback: function (value) {
-                                return value.toLocaleString();
-                            }
-                        }
-                    },
-                    y: {
-                        ticks: {
-                            autoSkip: false // Show all CNA labels
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-
-
-    // CNA lifecycle stages chart
-    function createActivityChart() {
-        const ctx = document.getElementById('cnaActivityChart').getContext('2d');
-
-        const currentData = getCurrentDataSource();
-        if (!currentData) return;
-
-        let cnas;
-        if (currentDataMode === 'all') {
-            if (!currentData.cna_list) return;
-            cnas = currentData.cna_list;
-        } else {
-            if (!currentData.cna_list) return;
-            // Use the actual years_active values from current year data (now includes full history)
-            cnas = currentData.cna_list;
-        }
-
-        const categories = {
-            'Established (10+ years)': cnas.filter(cna => cna.years_active >= 10).length,
-            'Mature (5-10 years)': cnas.filter(cna => cna.years_active >= 5 && cna.years_active < 10).length,
-            'Growing (2-5 years)': cnas.filter(cna => cna.years_active >= 2 && cna.years_active < 5).length,
-            'New (0-2 years)': cnas.filter(cna => cna.years_active < 2).length
-        };
-
-        const labels = Object.keys(categories);
-        const data = Object.values(categories);
-
-        // Blue gradient from dark to light
-        const colors = ['#1e40af', '#3b82f6', '#60a5fa', '#93c5fd'];
-
-        charts.activity = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: labels,
-                datasets: [{
-                    label: 'Number of CNAs',
-                    data: data,
-                    backgroundColor: colors,
-                    borderWidth: 1
-                }]
-            },
-            options: {
-                indexAxis: 'y',
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        display: false
-                    },
-                    tooltip: {
-                        callbacks: {
-                            label: function (context) {
-                                const total = context.dataset.data.reduce((a, b) => a + b, 0);
-                                const percentage = ((context.parsed.x / total) * 100).toFixed(1);
-                                return `${context.parsed.x} CNAs (${percentage}%)`;
-                            }
-                        }
-                    }
-                },
-                scales: {
-                    x: {
-                        beginAtZero: true,
-                        ticks: {
-                            stepSize: 1
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // Activity Recency Distribution chart
-    function createRecencyChart() {
-        const canvasElement = document.getElementById('cnaRecencyChart');
-        if (!canvasElement) {
-            console.error('Canvas element cnaRecencyChart not found!');
-            return;
-        }
-        const ctx = canvasElement.getContext('2d');
-
-        const currentData = getCurrentDataSource();
-        if (!currentData) {
-            console.error('No currentData available for recency chart');
-            return;
-        }
-
-        let cnas;
-        if (currentDataMode === 'all') {
-            console.log('createRecencyChart: all-time mode, cna_list length:', currentData.cna_list ? currentData.cna_list.length : 'undefined');
-            if (!currentData.cna_list) {
-                console.error('No cna_list available for all-time mode');
-                return;
-            }
-            cnas = currentData.cna_list;
-        } else {
-            console.log('createRecencyChart: current year mode, cna_list length:', currentData.cna_list ? currentData.cna_list.length : 'undefined');
-            if (!currentData.cna_list) {
-                console.error('No cna_list available for current year mode');
-                return;
-            }
-            // For current year, all CNAs are "Very Active" since they published in current year
-            cnas = currentData.cna_list.map(cna => ({
-                ...cna,
-                days_since_last_cve: 0 // Current year CNAs are treated as very recent
-            }));
-        }
-
-        console.log('createRecencyChart: processing', cnas.length, 'CNAs');
-        console.log('Sample CNA for debugging:', cnas[0]);
-
-        const categories = {
-            'Very Active (0-30 days)': cnas.filter(cna => cna.days_since_last_cve <= 30).length,
-            'Active (31-180 days)': cnas.filter(cna => cna.days_since_last_cve > 30 && cna.days_since_last_cve <= 180).length,
-            'Moderate (181-365 days)': cnas.filter(cna => cna.days_since_last_cve > 180 && cna.days_since_last_cve <= 365).length,
-            'Inactive (365+ days)': cnas.filter(cna => cna.days_since_last_cve > 365).length
-        };
-
-        const labels = Object.keys(categories);
-        const data = Object.values(categories);
-
-        // Activity-based color gradient (blue to grey)
-        const colors = ['#1e40af', '#3b82f6', '#60a5fa', '#6b7280'];
-
-        charts.recency = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: labels,
-                datasets: [{
-                    label: 'Number of CNAs',
-                    data: data,
-                    backgroundColor: colors,
-                    borderWidth: 1
-                }]
-            },
-            options: {
-                indexAxis: 'y',
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        display: false
-                    },
-                    tooltip: {
-                        callbacks: {
-                            label: function (context) {
-                                const total = context.dataset.data.reduce((a, b) => a + b, 0);
-                                const percentage = ((context.parsed.x / total) * 100).toFixed(1);
-                                return `${context.parsed.x} CNAs (${percentage}%)`;
-                            }
-                        }
-                    }
-                },
-                scales: {
-                    x: {
-                        beginAtZero: true,
-                        ticks: {
-                            stepSize: 1
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // CNA type distribution chart
-    function createTypeChart() {
-        const ctx = document.getElementById('cnaTypeChart').getContext('2d');
-
-        const currentData = getCurrentDataSource();
-        if (!currentData) return;
-
-        let typeDistribution = [];
-
-        if (currentDataMode === 'all') {
-            // Use real type distribution data from comprehensive analysis
-            if (currentData.type_distribution && currentData.type_distribution.sorted_types) {
-                // Convert backend format to chart format
-                typeDistribution = currentData.type_distribution.sorted_types.map(([type, count]) => ({
-                    type: type,
-                    count: count,
-                    percentage: currentData.type_distribution.type_percentages[type] || 0
-                }));
-                console.log('Loaded CNA type distribution:', typeDistribution);
-            } else {
-                console.log('No type distribution data available in all-time data');
-                return;
-            }
-        } else {
-            // For current year, calculate type distribution from individual CNA data
-            if (!currentData.cna_list || currentData.cna_list.length === 0) {
-                console.warn('No CNA data available for current year');
-                return;
-            }
-
-            // Calculate type distribution from current year CNAs
-            const typeCounts = {};
-            const totalCnas = currentData.cna_list.length;
-
-            currentData.cna_list.forEach(cna => {
-                if (cna.cna_types && cna.cna_types.length > 0) {
-                    cna.cna_types.forEach(type => {
-                        typeCounts[type] = (typeCounts[type] || 0) + 1;
-                    });
-                } else {
-                    // Fallback for CNAs without type info
-                    typeCounts['Other'] = (typeCounts['Other'] || 0) + 1;
-                }
-            });
-
-            // Convert to type distribution format and sort by count
-            typeDistribution = Object.entries(typeCounts)
-                .map(([type, count]) => ({
-                    type: type,
-                    count: count,
-                    percentage: parseFloat(((count / totalCnas) * 100).toFixed(1))
-                }))
-                .sort((a, b) => b.count - a.count);
-
-            console.log('Calculated current year type distribution:', typeDistribution);
-
-            if (typeDistribution.length === 0) {
-                console.warn('No type distribution data calculated for current year');
-                return;
-            }
-        }
-
-        // Filter out N/A entries and prepare data
-        const filteredDistribution = typeDistribution.filter(item => item.type !== 'N/A');
-        const labels = filteredDistribution.map(item => item.type);
-        const data = filteredDistribution.map(item => parseFloat(item.percentage.toFixed(1))); // Fix precision
-
-        // Generate blue/grey color scheme to match site theme
-        const colorPalette = [
-            '#3b82f6', // Primary blue - Vendor (largest category)
-            '#60a5fa', // Light blue - CERT
-            '#93c5fd', // Lighter blue - Security Researcher
-            '#bfdbfe', // Very light blue - Open Source
-            '#6b7280', // Medium grey - Government
-            '#9ca3af', // Light grey - Program
-            '#d1d5db', // Very light grey - Other
-            '#e5e7eb'  // Lightest grey - Academic
-        ];
-        const colors = colorPalette.slice(0, labels.length);
-
-        charts.types = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: labels,
-                datasets: [{
-                    label: 'Percentage of CNAs',
-                    data: data,
-                    backgroundColor: colors.map(color => color + '90'), // Add transparency
-                    borderColor: colors,
-                    borderWidth: 2,
-                    borderRadius: 4, // Rounded corners
-                    borderSkipped: false
-                }]
-            },
-            options: {
-                indexAxis: 'y',
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        display: false
-                    },
-                    tooltip: {
-                        backgroundColor: 'rgba(0, 0, 0, 0.8)',
-                        titleColor: '#ffffff',
-                        bodyColor: '#ffffff',
-                        borderColor: '#374151',
-                        borderWidth: 1,
-                        cornerRadius: 8,
-                        displayColors: true,
-                        callbacks: {
-                            title: function (context) {
-                                return `CNA Type: ${context[0].label}`;
-                            },
-                            label: function (context) {
-                                const item = filteredDistribution[context.dataIndex];
-                                return [
-                                    `Percentage: ${item.percentage}%`,
-                                    `Count: ${item.count.toLocaleString()} CNAs`
-                                ];
-                            }
-                        }
-                    }
-                },
-                scales: {
-                    x: {
-                        beginAtZero: true,
-                        max: 100, // Fixed scale to 100% for better readability
-                        ticks: {
-                            stepSize: 10, // Show ticks every 10%
-                            callback: function (value) {
-                                return Math.round(value) + '%'; // Round to avoid precision issues
-                            },
-                            font: {
-                                size: 12
-                            }
-                        },
-                        title: {
-                            display: true,
-                            text: 'Percentage of CNAs',
-                            font: {
-                                size: 13,
-                                weight: 'bold'
-                            }
-                        },
-                        grid: {
-                            color: '#e5e7eb',
-                            lineWidth: 1
-                        }
-                    },
-                    y: {
-                        ticks: {
-                            font: {
-                                size: 12,
-                                weight: '500'
-                            },
-                            color: '#374151'
-                        },
-                        grid: {
-                            display: false // Remove horizontal grid lines for cleaner look
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // CNA Performance Tiers (Volume) chart
-    function createVolumeChart() {
-        const ctx = document.getElementById('cnaVolumeChart').getContext('2d');
-
-        const currentData = getCurrentDataSource();
-        if (!currentData) return;
-
-        let cnas;
-        if (currentDataMode === 'all') {
-            if (!currentData.cna_list) return;
-            cnas = currentData.cna_list;
-        } else {
-            if (!currentData.cna_list) return;
-            cnas = currentData.cna_list;
-        }
-
-        const categories = {
-            'High Volume (1000+ CVEs)': cnas.filter(cna => cna.count >= 1000).length,
-            'Medium Volume (100-999 CVEs)': cnas.filter(cna => cna.count >= 100 && cna.count < 1000).length,
-            'Low Volume (10-99 CVEs)': cnas.filter(cna => cna.count >= 10 && cna.count < 100).length,
-            'Minimal Volume (1-9 CVEs)': cnas.filter(cna => cna.count >= 1 && cna.count < 10).length
-        };
-
-        const labels = Object.keys(categories);
-        const data = Object.values(categories);
-
-        // Performance-based color gradient (dark to light blue)
-        const colors = ['#1e40af', '#3b82f6', '#60a5fa', '#93c5fd'];
-
-        charts.volume = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: labels,
-                datasets: [{
-                    label: 'Number of CNAs',
-                    data: data,
-                    backgroundColor: colors,
-                    borderWidth: 1
-                }]
-            },
-            options: {
-                indexAxis: 'y',
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        display: false
-                    },
-                    tooltip: {
-                        callbacks: {
-                            label: function (context) {
-                                const total = context.dataset.data.reduce((a, b) => a + b, 0);
-                                const percentage = ((context.parsed.x / total) * 100).toFixed(1);
-                                return `${context.parsed.x} CNAs (${percentage}%)`;
-                            }
-                        }
-                    }
-                },
-                scales: {
-                    x: {
-                        beginAtZero: true,
-                        ticks: {
-                            stepSize: 1
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // CNA KEV Chart - Top CNAs by Known Exploited Vulnerabilities
-    function createKevChart() {
-        const ctx = document.getElementById('cnaKevChart');
-        if (!ctx) return;
-
-        // Use the CNA analysis data which now has kev_count per CNA
-        fetch('data/cna_analysis.json')
-            .then(r => r.json())
-            .then(data => {
-                const cnaList = data.cna_list || [];
-
-                // Filter CNAs with KEV CVEs and sort by kev_count
-                const cnasWithKev = cnaList
-                    .filter(cna => cna.kev_count > 0)
-                    .sort((a, b) => b.kev_count - a.kev_count);
-
-                if (cnasWithKev.length === 0) {
-                    ctx.parentElement.innerHTML = '<div class="text-center text-muted py-5"><small>No KEV data available</small></div>';
-                    return;
-                }
-
-                const top10 = cnasWithKev.slice(0, 10);
-                const labels = top10.map(cna => {
-                    return cna.name.length > 15 ? cna.name.substring(0, 15) + '...' : cna.name;
-                });
-                const dataValues = top10.map(cna => cna.kev_count);
-
-                // Blue gradient matching site design
-                const colors = ['#1e40af', '#2563eb', '#3b82f6', '#60a5fa', '#93c5fd',
-                    '#a8c8ec', '#9bc7e1', '#8cbfdc', '#7db7d7', '#6eafd2'];
-
-                charts.kev = new Chart(ctx, {
-                    type: 'bar',
-                    data: {
-                        labels: labels,
-                        datasets: [{
-                            label: 'KEV CVEs',
-                            data: dataValues,
-                            backgroundColor: colors,
-                            borderColor: '#3b82f6',
-                            borderWidth: 1
-                        }]
-                    },
-                    options: {
-                        indexAxis: 'y',
-                        responsive: true,
-                        maintainAspectRatio: false,
-                        plugins: {
-                            legend: { display: false },
-                            tooltip: {
-                                callbacks: {
-                                    title: function (context) {
-                                        const idx = context[0].dataIndex;
-                                        return top10[idx].name;
-                                    },
-                                    label: function (context) {
-                                        const idx = context.dataIndex;
-                                        const cna = top10[idx];
-                                        const kevRate = ((cna.kev_count / cna.count) * 100).toFixed(2);
-                                        return [
-                                            `${context.parsed.x} known exploited CVEs`,
-                                            `${kevRate}% of ${cna.count.toLocaleString()} total CVEs`
-                                        ];
-                                    }
-                                }
-                            }
-                        },
-                        scales: {
-                            x: {
-                                beginAtZero: true,
-                                title: {
-                                    display: true,
-                                    text: 'KEV CVE Count'
-                                }
-                            },
-                            y: {
-                                grid: { display: false }
-                            }
-                        }
-                    }
-                });
-            })
-            .catch(error => {
-                console.error('KEV chart error:', error);
-                ctx.parentElement.innerHTML = '<div class="text-center text-muted py-5"><small>Chart unavailable</small></div>';
-            });
-    }
-
-    // CNA Growth Leaders - Most active CNAs in current year
-    function createGrowthChart() {
-        const ctx = document.getElementById('cnaGrowthChart');
-        if (!ctx) return;
-
-        // Load current year CNA data
-        fetch('data/cna_analysis_current_year.json')
-            .then(r => r.json())
-            .then(data => {
-                const cnaList = data.cna_list || [];
-
-                if (cnaList.length === 0) {
-                    ctx.parentElement.innerHTML = '<div class="text-center text-muted py-5"><small>No current year data available</small></div>';
-                    return;
-                }
-
-                // Sort by count and get top 10
-                const top10 = cnaList.slice(0, 10);
-                const labels = top10.map(cna => cna.name.length > 15 ? cna.name.substring(0, 15) + '...' : cna.name);
-                const dataValues = top10.map(cna => cna.count);
-
-                // Blue gradient matching site design
-                const colors = ['#1e40af', '#2563eb', '#3b82f6', '#60a5fa', '#93c5fd',
-                    '#a8c8ec', '#9bc7e1', '#8cbfdc', '#7db7d7', '#6eafd2'];
-
-                charts.growth = new Chart(ctx, {
-                    type: 'bar',
-                    data: {
-                        labels: labels,
-                        datasets: [{
-                            label: 'CVEs in ' + new Date().getFullYear(),
-                            data: dataValues,
-                            backgroundColor: colors,
-                            borderColor: '#3b82f6',
-                            borderWidth: 1
-                        }]
-                    },
-                    options: {
-                        indexAxis: 'y',
-                        responsive: true,
-                        maintainAspectRatio: false,
-                        plugins: {
-                            legend: { display: false },
-                            tooltip: {
-                                callbacks: {
-                                    title: function (context) {
-                                        const idx = context[0].dataIndex;
-                                        return top10[idx].name;
-                                    },
-                                    label: function (context) {
-                                        return `${context.parsed.x.toLocaleString()} CVEs in ${new Date().getFullYear()}`;
-                                    }
-                                }
-                            }
-                        },
-                        scales: {
-                            x: {
-                                beginAtZero: true,
-                                title: {
-                                    display: true,
-                                    text: `CVEs (${new Date().getFullYear()})`
-                                }
-                            },
-                            y: {
-                                grid: { display: false }
-                            }
-                        }
-                    }
-                });
-            })
-            .catch(error => {
-                console.error('Growth chart error:', error);
-                ctx.parentElement.innerHTML = '<div class="text-center text-muted py-5"><small>Chart unavailable</small></div>';
-            });
-    }
-
-    // Generate smart insights
-    function generateInsights() {
-        const currentData = getCurrentDataSource();
-
-        // Update total CNAs count in CVE V5 data source card
-        const totalCnasElement = document.getElementById('totalCnasCount');
-        if (totalCnasElement && currentData) {
-            let totalCount = 0;
-            if (currentDataMode === 'all' && currentData.cna_list) {
-                totalCount = currentData.cna_list.length;
-            } else if (currentDataMode === 'current' && currentData.cna_list) {
-                totalCount = currentData.cna_list.length;
-            }
-            totalCnasElement.textContent = totalCount.toLocaleString();
-        }
-
-        if (!currentData) {
-            console.error('generateInsights: No currentData available');
-            return;
-        }
-
-        let cnas = [];
-        if (currentDataMode === 'all' && currentData.cna_list) {
-            cnas = currentData.cna_list;
-        } else if (currentDataMode === 'current' && currentData.cna_list) {
-            cnas = currentData.cna_list;
-        }
-
-        if (cnas.length === 0) {
-            console.error('generateInsights: No CNAs available');
-            return;
-        }
-
-        const totalCves = cnas.reduce((sum, cna) => sum + cna.count, 0);
-        const topCna = cnas[0];
-
-        if (currentDataMode === 'current') {
-            // Current year specific insights (2025)
-            const currentYear = new Date().getFullYear();
-            const topCnaShare = ((topCna.count / totalCves) * 100).toFixed(1);
-
-            // Top 2025 CNA insight
-            document.getElementById('marketLeaderInsight').innerHTML = `
-            <strong>${topCna.name}</strong> leads ${currentYear} with <strong>${topCna.count.toLocaleString()}</strong> CVEs published (<strong>${topCnaShare}%</strong> of ${currentYear} volume)
-        `;
-
-            // 2025 publication volume insight
-            document.getElementById('activityInsight').innerHTML = `
-            <strong>${totalCves.toLocaleString()}</strong> CVEs published in ${currentYear} by <strong>${cnas.length}</strong> active CNAs (averaging <strong>${Math.round(totalCves / cnas.length)}</strong> CVEs per CNA)
-        `;
-
-            // Experience mix insight - veteran vs new CNAs
-            const veteranCnas = cnas.filter(cna => cna.years_active >= 10).length;
-            const newCnas = cnas.filter(cna => cna.years_active <= 2).length;
-            const longestActive = Math.max(...cnas.map(cna => cna.years_active));
-
-            document.getElementById('orgTypeInsight').innerHTML = `
-            <strong>${veteranCnas}</strong> veteran CNAs (10+ years) and <strong>${newCnas}</strong> newer CNAs (≤2 years) published in ${currentYear}, with <strong>${longestActive}</strong> years max experience
-        `;
-        } else {
-            // All-time insights (original logic)
-            const activeCnas = cnas.filter(cna => cna.activity_status === 'Active');
-            const topCnaShare = ((topCna.count / totalCves) * 100).toFixed(1);
-
-            // Top CNA insight
-            document.getElementById('marketLeaderInsight').innerHTML = `
-            <strong>${topCna.name}</strong> has assigned the most CVEs with <strong>${topCna.count.toLocaleString()}</strong> total assignments (<strong>${topCnaShare}%</strong> of all CVEs)
-        `;
-
-            // Activity status insight
-            const activePercentage = ((activeCnas.length / cnas.length) * 100).toFixed(1);
-            document.getElementById('activityInsight').innerHTML = `
-            <strong>${activeCnas.length}</strong> of <strong>${cnas.length}</strong> CNAs are currently active (<strong>${activePercentage}%</strong>), having published CVEs within the last 12 months
-        `;
-
-            // Years active insight
-            const avgYearsActive = Math.round(cnas.reduce((sum, cna) => sum + cna.years_active, 0) / cnas.length);
-            const longestActive = Math.max(...cnas.map(cna => cna.years_active));
-
-            document.getElementById('orgTypeInsight').innerHTML = `
-            CNAs have been active for an average of <strong>${avgYearsActive} years</strong>, with the longest-running CNA active for <strong>${longestActive} years</strong>
-        `;
-        }
-    }
-
-    // Table pagination and sorting variables
-    let currentPage = 1;
-    let itemsPerPage = 25;
-    let currentSort = { field: 'last_cve_date', direction: 'desc' };
-    let sortedData = [];
-    let unfilteredData = []; // Original data before filters
-
-    // Filter state
-    let activeFilters = {
-        type: '',
-        status: '',
-        hasKev: false,
-        highVolume: false
-    };
-
-    // Apply filters to the CNA data
-    function applyFilters() {
-        activeFilters = {
-            type: document.getElementById('filterType').value,
-            status: document.getElementById('filterStatus').value,
-            hasKev: document.getElementById('filterKev').checked,
-            highVolume: document.getElementById('filterHighVolume').checked
-        };
-
-        // Filter the unfiltered data
-        let filtered = unfilteredData.filter(cna => {
-            // Type filter
-            if (activeFilters.type && (!cna.cna_types || !cna.cna_types.includes(activeFilters.type))) {
-                return false;
-            }
-            // Status filter
-            if (activeFilters.status && cna.activity_status !== activeFilters.status) {
-                return false;
-            }
-            // KEV filter
-            if (activeFilters.hasKev && (!cna.kev_count || cna.kev_count === 0)) {
-                return false;
-            }
-            // High volume filter
-            if (activeFilters.highVolume && cna.count < 1000) {
-                return false;
-            }
-            return true;
-        });
-
-        // Apply current sort to filtered data
-        sortedData = [...filtered].sort((a, b) => {
-            let aVal, bVal;
-
-            // Handle rank specially - use the rank property
-            if (currentSort.field === 'rank') {
-                aVal = a.rank || 999;
-                bVal = b.rank || 999;
-                return currentSort.direction === 'asc' ? aVal - bVal : bVal - aVal;
-            }
-
-            aVal = a[currentSort.field];
-            bVal = b[currentSort.field];
-
-            if (currentSort.field === 'last_cve_date') {
-                const aDate = new Date(aVal);
-                const bDate = new Date(bVal);
-                return currentSort.direction === 'asc' ? aDate - bDate : bDate - aDate;
-            }
-
-            if (currentSort.field === 'name') {
-                aVal = (aVal || '').toLowerCase();
-                bVal = (bVal || '').toLowerCase();
-            }
-
-            if (typeof aVal === 'string') {
-                return currentSort.direction === 'asc'
-                    ? aVal.localeCompare(bVal)
-                    : bVal.localeCompare(aVal);
-            }
-
-            return currentSort.direction === 'asc' ? aVal - bVal : bVal - aVal;
-        });
-
-        // Reset to first page when filters change
-        currentPage = 1;
-
-        // Update filter summary
-        const hasActiveFilters = activeFilters.type || activeFilters.status || activeFilters.hasKev || activeFilters.highVolume;
-        const filterSummary = document.getElementById('filterSummary');
-        if (hasActiveFilters) {
-            filterSummary.style.display = 'block';
-            document.getElementById('filteredCount').textContent = sortedData.length;
-        } else {
-            filterSummary.style.display = 'none';
-        }
-
-        renderTable();
-    }
-
-    // Reset all filters
-    function resetFilters() {
-        document.getElementById('filterType').value = '';
-        document.getElementById('filterStatus').value = '';
-        document.getElementById('filterKev').checked = false;
-        document.getElementById('filterHighVolume').checked = false;
-        applyFilters();
-    }
-
-    // Populate CNA table with pagination and sorting
-    function populateTable() {
-        const currentData = getCurrentDataSource();
-        if (!currentData) {
-            console.error('populateTable: No currentData available');
-            return;
-        }
-
-        let dataToSort;
-
-        if (currentDataMode === 'all') {
-            console.log('populateTable: all-time mode');
-            if (!currentData.cna_list) {
-                console.error('populateTable: No cna_list in all-time data');
-                return;
-            }
-            dataToSort = currentData.cna_list;
-            console.log('populateTable: dataToSort length (all-time):', dataToSort.length);
-        } else {
-            console.log('populateTable: current year mode');
-            if (!currentData.cna_list) {
-                console.error('populateTable: No cna_list in current year data');
-                return;
-            }
-            // Use real CVE dates from backend data - no hardcoded overrides
-            dataToSort = currentData.cna_list.map(cna => ({
-                ...cna,
-                // Keep the real last_cve_date from backend data
-                activity_status: 'Active' // All current year CNAs are active
-            }));
-            console.log('populateTable: dataToSort length (current year):', dataToSort.length);
-        }
-
-        // Store unfiltered data for filter operations
-        unfilteredData = [...dataToSort];
-
-        // Set initial sort state to match default (rank ascending)
-        currentSort = {
-            field: 'rank',
-            direction: 'asc'
-        };
-
-        // Apply filters (this also handles sorting and rendering)
-        applyFilters();
-
-        setupSortingHandlers();
-        updateSortIndicators(); // Show correct default sort indicator
-    }
-
-    // Render table with current page and sorting
-    function renderTable() {
-        const tbody = document.getElementById('cnaTableBody');
-        const startIndex = (currentPage - 1) * itemsPerPage;
-        const endIndex = startIndex + itemsPerPage;
-        const pageData = sortedData.slice(startIndex, endIndex);
-
-        const rows = pageData.map((cna, index) => {
-            let formattedDate = 'Invalid Date';
-            if (cna.last_cve_date) {
-                const lastCveDate = new Date(cna.last_cve_date);
-                if (!isNaN(lastCveDate.getTime())) {
-                    formattedDate = lastCveDate.toLocaleDateString('en-US', {
-                        year: 'numeric',
-                        month: 'short',
-                        day: 'numeric'
-                    });
-                } else {
-                    console.error('Invalid date for CNA:', cna.name, 'date:', cna.last_cve_date);
-                    formattedDate = 'Invalid Date';
-                }
-            }
-            const statusColor = cna.activity_status === 'Active' ? '#10b981' : '#ef4444';
-            const statusIcon = cna.activity_status === 'Active' ? '✅' : '❌';
-            // Use rank from JSON data, not recalculated
-            let displayRank = cna.rank || (index + 1);
-            // Generate CNAScorecard link
-            const scorecardUrl = `https://cvedb.github.io/cna/cna-detail.html?shortName=${encodeURIComponent(cna.name)}`;
-            return `
-            <tr>
-                <td><strong>#${displayRank}</strong></td>
-                <td>${cna.name}</td>
-                <td>${cna.count.toLocaleString()}</td>
-                <td>${cna.years_active} years</td>
-                <td>${formattedDate}</td>
-                <td><span style="color: ${statusColor}; font-weight: bold;">${statusIcon} ${cna.activity_status}</span></td>
-                <td><a href="${scorecardUrl}" target="_blank" rel="noopener noreferrer" title="View on CNAScorecard" class="scorecard-link">📊</a></td>
-            </tr>
-        `;
-        }).join('');
-
-        tbody.innerHTML = rows;
-        updatePaginationInfo();
-        updatePaginationControls();
-    }
-
-    // Update pagination info text
-    function updatePaginationInfo() {
-        const startIndex = (currentPage - 1) * itemsPerPage + 1;
-        const endIndex = Math.min(currentPage * itemsPerPage, sortedData.length);
-        const totalItems = sortedData.length;
-
-        document.getElementById('paginationInfo').textContent =
-            `Showing ${startIndex}-${endIndex} of ${totalItems} CNAs`;
-    }
-
-    // Update pagination controls
-    function updatePaginationControls() {
-        const totalPages = Math.ceil(sortedData.length / itemsPerPage);
-        const paginationControls = document.getElementById('paginationControls');
-
-        if (totalPages <= 1) {
-            paginationControls.innerHTML = '';
-            return;
-        }
-
-        let paginationHTML = '';
-
-        // Previous button
-        const prevDisabled = currentPage === 1 ? 'disabled' : '';
-        paginationHTML += `<li class="page-item ${prevDisabled}"><a class="page-link" href="#" id="prevPage">&laquo;</a></li>`;
-
-        // Always show first page
-        if (currentPage > 3) {
-            paginationHTML += `<li class="page-item"><a class="page-link" href="#" data-page="1">1</a></li>`;
-            if (currentPage > 4) {
-                paginationHTML += `<li class="page-item disabled"><span class="page-link">...</span></li>`;
-            }
-        }
-
-        // Show pages around current page
-        const startPage = Math.max(1, currentPage - 1);
-        const endPage = Math.min(totalPages, currentPage + 1);
-
-        for (let i = startPage; i <= endPage; i++) {
-            const active = i === currentPage ? 'active' : '';
-            paginationHTML += `<li class="page-item ${active}"><a class="page-link" href="#" data-page="${i}">${i}</a></li>`;
-        }
-
-        // Always show last page
-        if (currentPage < totalPages - 2) {
-            if (currentPage < totalPages - 3) {
-                paginationHTML += `<li class="page-item disabled"><span class="page-link">...</span></li>`;
-            }
-            paginationHTML += `<li class="page-item"><a class="page-link" href="#" data-page="${totalPages}">${totalPages}</a></li>`;
-        }
-
-        // Next button
-        const nextDisabled = currentPage === totalPages ? 'disabled' : '';
-        paginationHTML += `<li class="page-item ${nextDisabled}"><a class="page-link" href="#" id="nextPage">&raquo;</a></li>`;
-
-        paginationControls.innerHTML = paginationHTML;
-
-        // Add event listeners for pagination
-        setupPaginationHandlers();
-    }
-
-    // Setup pagination event handlers
-    function setupPaginationHandlers() {
-        const paginationControls = document.getElementById('paginationControls');
-        // Remove all previous listeners by replacing the element
-        const newControls = paginationControls.cloneNode(true);
-        paginationControls.parentNode.replaceChild(newControls, paginationControls);
-        newControls.addEventListener('click', (e) => {
-            e.preventDefault();
-            const target = e.target;
-            if (!target.classList.contains('page-link')) return;
-            if (target.id === 'prevPage') {
-                if (currentPage > 1) {
-                    currentPage--;
-                    renderTable();
-                }
-                return;
-            }
-            if (target.id === 'nextPage') {
-                const totalPages = Math.ceil(sortedData.length / itemsPerPage);
-                if (currentPage < totalPages) {
-                    currentPage++;
-                    renderTable();
-                }
-                return;
-            }
-            const page = parseInt(target.getAttribute('data-page'));
-            if (page && page !== currentPage) {
-                currentPage = page;
-                renderTable();
-            }
-        });
-    }
-
-    // Track if handlers are already set up to prevent duplicates
-    let sortHandlersSetup = false;
-
-    // Setup sorting event handlers
-    function setupSortingHandlers() {
-        // Only set up handlers once
-        if (sortHandlersSetup) {
-            return;
-        }
-
-        document.querySelectorAll('.sortable').forEach(header => {
-            header.addEventListener('click', () => {
-                const sortField = header.getAttribute('data-sort');
-
-                // Toggle direction if same field, otherwise default to ascending
-                if (currentSort.field === sortField) {
-                    currentSort.direction = currentSort.direction === 'asc' ? 'desc' : 'asc';
-                } else {
-                    currentSort.field = sortField;
-                    currentSort.direction = sortField === 'last_cve_date' ? 'desc' : 'asc';
-                }
-
-                // Use applyFilters which handles both filtering and sorting
-                applyFilters();
-                updateSortIndicators();
-            });
-        });
-
-        sortHandlersSetup = true;
-    }
-
-    // Sort data based on current sort settings
-    function sortData() {
-        sortedData.sort((a, b) => {
-            let valueA, valueB;
-
-            switch (currentSort.field) {
-                case 'rank':
-                    valueA = cnaData.cna_list.findIndex(original => original.name === a.name) + 1;
-                    valueB = cnaData.cna_list.findIndex(original => original.name === b.name) + 1;
-                    break;
-                case 'name':
-                    valueA = a.name.toLowerCase();
-                    valueB = b.name.toLowerCase();
-                    break;
-                case 'count':
-                    valueA = a.count;
-                    valueB = b.count;
-                    break;
-                case 'years_active':
-                    valueA = a.years_active;
-                    valueB = b.years_active;
-                    break;
-                case 'last_cve_date':
-                    valueA = new Date(a.last_cve_date);
-                    valueB = new Date(b.last_cve_date);
-                    break;
-                case 'activity_status':
-                    valueA = a.activity_status;
-                    valueB = b.activity_status;
-                    break;
-                default:
-                    return 0;
-            }
-
-            let comparison = 0;
-            if (valueA > valueB) comparison = 1;
-            if (valueA < valueB) comparison = -1;
-
-            return currentSort.direction === 'desc' ? -comparison : comparison;
-        });
-    }
-
-    // Update sort indicators in table headers
-    function updateSortIndicators() {
-        document.querySelectorAll('.sort-indicator').forEach(indicator => {
-            indicator.textContent = '';
-        });
-        const activeHeader = document.querySelector(`[data-sort="${currentSort.field}"] .sort-indicator`);
-        if (activeHeader) {
-            activeHeader.textContent = currentSort.direction === 'asc' ? '▲' : '▼';
-        }
-    }
-
-    // Permalink functionality
-    function generatePermalink() {
-        const permalink = `${window.location.origin}${window.location.pathname}`;
-
-        const resultDiv = document.getElementById('permalinkResult');
-        const input = document.getElementById('permalinkInput');
-
-        input.value = permalink;
-        resultDiv.style.display = 'block';
-    }
-
-    function copyPermalink() {
-        const input = document.getElementById('permalinkInput');
-        input.select();
-        document.execCommand('copy');
-
-        const button = event.target;
-        const originalText = button.textContent;
-        button.textContent = 'Copied!';
-        button.style.backgroundColor = '#198754';
-
-        setTimeout(() => {
-            button.textContent = originalText;
-            button.style.backgroundColor = '';
-        }, 2000);
-    }
-
-    // Export functions
-    function exportCnaCSV() {
-        if (!cnaData || !cnaData.cna_list) {
-            alert('No data available for export');
-            return;
-        }
-
-        const totalCves = cnaData.cna_list.reduce((sum, cna) => sum + cna.count, 0);
-        const activeCnas = cnaData.cna_list.filter(cna => cna.activity_status === 'Active').length;
-
-        let csv = 'CNA Intelligence Dashboard Export\n\n';
-        csv += 'Rank,CNA Name,Official Status,CVEs Assigned,Years Active,Last CVE Date,Activity Status\n';
-
-        cnaData.cna_list.forEach((cna, index) => {
-            const lastCveDate = new Date(cna.last_cve_date).toLocaleDateString('en-US');
-            const officialStatus = cna.is_official !== false ? 'Official' : 'Unofficial';
-            csv += `${index + 1},"${cna.name}",${officialStatus},${cna.count},${cna.years_active},${lastCveDate},${cna.activity_status}\n`;
-        });
-
-        csv += '\n\nSummary Statistics\n';
-        csv += `Total CNAs,${cnaData.cna_list.length}\n`;
-        csv += `Active CNAs,${activeCnas}\n`;
-        csv += `Inactive CNAs,${cnaData.cna_list.length - activeCnas}\n`;
-        csv += `Total CVEs Assigned,${totalCves.toLocaleString()}\n`;
-        csv += `Average CVEs per CNA,${Math.round(totalCves / cnaData.cna_list.length)}\n`;
-
-        downloadFile(csv, 'cna-comprehensive-analysis.csv', 'text/csv');
-    }
-
-    function exportCnaJSON() {
-        if (!cnaData) {
-            alert('No data available for export');
-            return;
-        }
-        const totalCves = cnaData.cna_list.reduce((sum, cna) => sum + cna.count, 0);
-        const activeCnas = cnaData.cna_list.filter(cna => cna.activity_status === 'Active').length;
-        const exportData = {
-            metadata: {
-                averageCvesPerCna: Math.round(totalCves / cnaData.cna_list.length),
-                totalCnas: cnaData.cna_list.length,
-                activeCnas: activeCnas,
-                inactiveCnas: cnaData.cna_list.length - activeCnas,
-                totalCves: totalCves
-            }
-        };
-        const jsonStr = JSON.stringify(exportData, null, 2);
-        downloadFile(jsonStr, 'cna-comprehensive-analysis.json', 'application/json');
-    }
-
-    function downloadFile(content, filename, contentType) {
-        const blob = new Blob([content], { type: contentType });
-        const url = window.URL.createObjectURL(blob);
-        const a = document.createElement('a');
-        a.href = url;
-        a.download = filename;
-        document.body.appendChild(a);
-        a.click();
-        document.body.removeChild(a);
-        window.URL.revokeObjectURL(url);
-    }
-
-    // Error state
-    function showErrorState() {
-        document.getElementById('activeCnas').textContent = 'Error';
-        document.getElementById('highVolumeCnas').textContent = 'Error';
-        document.getElementById('medianYearsActive').textContent = 'Error';
-        document.getElementById('marketConcentration').textContent = 'Error';
-        document.getElementById('cnaTableBody').innerHTML = '<tr><td colspan="7" class="text-center text-danger">Error loading CNA data. Please refresh the page.</td></tr>';
-    }
-</script>
-{% endblock %}
\ No newline at end of file
diff --git a/templates/cna/data-quality.html b/templates/cna/data-quality.html
deleted file mode 100644
index ac6006ae93d..00000000000
--- a/templates/cna/data-quality.html
+++ /dev/null
@@ -1,479 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}CNA Name Matching Quality - CVEDB{% endblock %}
-
-{% block content %}
-<!-- Hero Section -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">CNA Name Matching Quality</h1>
-    <small class="text-muted d-block mb-3">
-        How well CVE assigner names match the official CNA registry
-    </small>
-</div>
-
-<!-- Summary Stats -->
-<div class="stats-grid mb-4">
-    <div class="stat-card">
-        <div class="stat-number" id="exactMatches" style="color: #1e3a5f;">Loading...</div>
-        <div class="stat-label">Exact Matches</div>
-        <small class="text-muted" style="font-size: 0.75rem;">Perfect shortName match</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="fuzzyMatches" style="color: #3b82f6;">Loading...</div>
-        <div class="stat-label">Fuzzy Matches</div>
-        <small class="text-muted" style="font-size: 0.75rem;">Matched via normalization</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="unmatchedCount" style="color: #94a3b8;">Loading...</div>
-        <div class="stat-label">Unmatched</div>
-        <small class="text-muted" style="font-size: 0.75rem;">No registry match found</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="matchRate">Loading...</div>
-        <div class="stat-label">Match Rate</div>
-        <small class="text-muted" style="font-size: 0.75rem;">Overall matching success</small>
-    </div>
-</div>
-
-<!-- Explanation Card -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">How Name Matching Works</h3>
-    </div>
-    <div class="card-body py-3">
-        <p class="mb-2">
-            This analysis uses <strong>CNAScorecard-style name matching</strong> to reconcile CVE assigner names
-            with the official CNA registry. The matching process uses progressively relaxed strategies:
-        </p>
-        <div class="row">
-            <div class="col-md-6">
-                <ul class="mb-2" style="font-size: 0.9rem;">
-                    <li><strong>Exact Match:</strong> Direct shortName comparison</li>
-                    <li><strong>Case-Insensitive:</strong> Ignore letter casing differences</li>
-                    <li><strong>Organization Name:</strong> Match via full organization name</li>
-                </ul>
-            </div>
-            <div class="col-md-6">
-                <ul class="mb-2" style="font-size: 0.9rem;">
-                    <li><strong>Normalized:</strong> Remove spaces, hyphens, underscores</li>
-                    <li><strong>Partial:</strong> Substring containment check</li>
-                </ul>
-            </div>
-        </div>
-        <p class="mb-0 text-muted" style="font-size: 0.85rem;">
-            <em>Unmatched CNAs may be historical assigners, deprecated organizations, or name variations not yet
-                mapped.</em>
-        </p>
-    </div>
-</div>
-
-<!-- Match Quality Breakdown -->
-<div class="row mb-4">
-    <div class="col-lg-6 mb-4">
-        <div class="card h-100">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">Match Quality Distribution</h3>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 250px;">
-                    <canvas id="matchQualityChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-    <div class="col-lg-6 mb-4">
-        <div class="card h-100">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">CVEs by Match Type</h3>
-                <small class="text-muted">Excluding exact matches for scale</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 250px;">
-                    <canvas id="cveMatchChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- Case Mismatches -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">Case Mismatches</h3>
-        <small class="text-muted">CNAs using different letter casing than official registry</small>
-    </div>
-    <div class="card-body py-3">
-        <div class="table-responsive">
-            <table class="table table-hover" id="caseMismatchTable">
-                <thead>
-                    <tr>
-                        <th style="width: 200px;">Name Used</th>
-                        <th style="width: 200px;">Official Name</th>
-                        <th style="width: 100px;">CVEs</th>
-                        <th style="width: 80px;">KEVs</th>
-                    </tr>
-                </thead>
-                <tbody id="caseMismatchBody">
-                    <tr>
-                        <td colspan="4" class="text-center text-muted">Loading...</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-    </div>
-</div>
-
-<!-- Organization Name Matches -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">Organization Name Matches</h3>
-        <small class="text-muted">CNAs matched via organization name instead of shortName</small>
-    </div>
-    <div class="card-body py-3">
-        <div class="table-responsive">
-            <table class="table table-hover" id="orgMatchTable">
-                <thead>
-                    <tr>
-                        <th style="width: 200px;">Name Used</th>
-                        <th style="width: 200px;">Official ShortName</th>
-                        <th style="width: 100px;">CVEs</th>
-                        <th style="width: 80px;">KEVs</th>
-                    </tr>
-                </thead>
-                <tbody id="orgMatchBody">
-                    <tr>
-                        <td colspan="4" class="text-center text-muted">Loading...</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-    </div>
-</div>
-
-<!-- Normalized Matches -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">Normalized Matches</h3>
-        <small class="text-muted">CNAs matched after removing spaces, hyphens, and underscores</small>
-    </div>
-    <div class="card-body py-3">
-        <div class="table-responsive">
-            <table class="table table-hover" id="normalizedMatchTable">
-                <thead>
-                    <tr>
-                        <th style="width: 200px;">Name Used</th>
-                        <th style="width: 200px;">Official Name</th>
-                        <th style="width: 100px;">CVEs</th>
-                        <th style="width: 80px;">KEVs</th>
-                    </tr>
-                </thead>
-                <tbody id="normalizedMatchBody">
-                    <tr>
-                        <td colspan="4" class="text-center text-muted">Loading...</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-    </div>
-</div>
-
-<!-- Partial Matches -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">Partial Matches</h3>
-        <small class="text-muted">CNAs matched via substring containment (lower confidence)</small>
-    </div>
-    <div class="card-body py-3">
-        <div class="table-responsive">
-            <table class="table table-hover" id="partialMatchTable">
-                <thead>
-                    <tr>
-                        <th style="width: 200px;">Name Used</th>
-                        <th style="width: 200px;">Possible Match</th>
-                        <th style="width: 100px;">CVEs</th>
-                        <th style="width: 100px;">Confidence</th>
-                    </tr>
-                </thead>
-                <tbody id="partialMatchBody">
-                    <tr>
-                        <td colspan="4" class="text-center text-muted">Loading...</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-    </div>
-</div>
-
-<!-- Truly Unmatched -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">Unmatched CNAs</h3>
-        <small class="text-muted">CVE assigners with no match found in official CNA registry</small>
-    </div>
-    <div class="card-body py-3">
-        <div class="table-responsive">
-            <table class="table table-hover" id="unmatchedTable">
-                <thead>
-                    <tr>
-                        <th style="width: 200px;">Name</th>
-                        <th style="width: 100px;">CVEs</th>
-                        <th style="width: 80px;">KEVs</th>
-                        <th style="width: 100px;">EPSS High</th>
-                        <th>Notes</th>
-                    </tr>
-                </thead>
-                <tbody id="unmatchedBody">
-                    <tr>
-                        <td colspan="5" class="text-center text-muted">Loading...</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-    </div>
-</div>
-
-{% endblock %}
-
-{% block scripts %}
-<script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.umd.js"></script>
-<style>
-    .confidence-high {
-        color: #1e3a5f;
-        font-weight: 600;
-    }
-
-    .confidence-medium {
-        color: #3b82f6;
-        font-weight: 600;
-    }
-
-    .confidence-low {
-        color: #94a3b8;
-        font-weight: 600;
-    }
-
-    .match-badge {
-        display: inline-block;
-        padding: 0.2rem 0.5rem;
-        border-radius: 4px;
-        font-size: 0.75rem;
-        font-weight: 500;
-    }
-
-    .match-exact {
-        background: #1e3a5f;
-        color: #fff;
-    }
-
-    .match-case {
-        background: #2563eb;
-        color: #fff;
-    }
-
-    .match-org {
-        background: #3b82f6;
-        color: #fff;
-    }
-
-    .match-normalized {
-        background: #60a5fa;
-        color: #1e3a5f;
-    }
-
-    .match-partial {
-        background: #93c5fd;
-        color: #1e3a5f;
-    }
-</style>
-
-<script>
-    let dataQuality = null;
-    let charts = {};
-
-    async function loadDataQuality() {
-        try {
-            const response = await fetch('data/data_quality.json');
-            dataQuality = await response.json();
-
-            updateSummaryStats();
-            populateTables();
-            createCharts();
-
-        } catch (error) {
-            console.error('Error loading data quality:', error);
-            document.querySelectorAll('tbody').forEach(tbody => {
-                tbody.innerHTML = '<tr><td colspan="5" class="text-center text-danger">Error loading data</td></tr>';
-            });
-        }
-    }
-
-    function updateSummaryStats() {
-        const stats = dataQuality.stats;
-
-        document.getElementById('exactMatches').textContent = stats.exact_matches.toLocaleString();
-
-        // Fuzzy = case + org + normalized + partial
-        const fuzzy = stats.case_mismatches + stats.org_name_matches + stats.normalized_matches + stats.partial_matches;
-        document.getElementById('fuzzyMatches').textContent = fuzzy.toLocaleString();
-
-        document.getElementById('unmatchedCount').textContent = stats.unmatched.toLocaleString();
-
-        // Match rate
-        const total = stats.total_cnas_in_analysis;
-        const matched = total - stats.unmatched;
-        const rate = total > 0 ? ((matched / total) * 100).toFixed(1) : 0;
-        document.getElementById('matchRate').textContent = rate + '%';
-    }
-
-    function populateTables() {
-        // Case mismatches
-        populateTable('caseMismatchBody', dataQuality.case_mismatches, (item) => `
-        <tr>
-            <td><strong>${escapeHtml(item.cna_name)}</strong></td>
-            <td><code>${escapeHtml(item.official_short_name)}</code></td>
-            <td>${item.cve_count.toLocaleString()}</td>
-            <td>${item.kev_count || 0}</td>
-        </tr>
-    `);
-
-        // Organization name matches
-        populateTable('orgMatchBody', dataQuality.org_name_matches, (item) => `
-        <tr>
-            <td><strong>${escapeHtml(item.cna_name)}</strong></td>
-            <td><code>${escapeHtml(item.official_short_name)}</code></td>
-            <td>${item.cve_count.toLocaleString()}</td>
-            <td>${item.kev_count || 0}</td>
-        </tr>
-    `);
-
-        // Normalized matches
-        populateTable('normalizedMatchBody', dataQuality.normalized_matches, (item) => `
-        <tr>
-            <td><strong>${escapeHtml(item.cna_name)}</strong></td>
-            <td><code>${escapeHtml(item.official_short_name)}</code></td>
-            <td>${item.cve_count.toLocaleString()}</td>
-            <td>${item.kev_count || 0}</td>
-        </tr>
-    `);
-
-        // Partial matches
-        populateTable('partialMatchBody', dataQuality.partial_matches, (item) => `
-        <tr>
-            <td><strong>${escapeHtml(item.cna_name)}</strong></td>
-            <td><code>${escapeHtml(item.official_short_name)}</code></td>
-            <td>${item.cve_count.toLocaleString()}</td>
-            <td><span class="confidence-low">Low</span></td>
-        </tr>
-    `);
-
-        // Unmatched
-        populateTable('unmatchedBody', dataQuality.unmatched, (item) => `
-        <tr>
-            <td><strong>${escapeHtml(item.cna_name)}</strong></td>
-            <td>${item.cve_count.toLocaleString()}</td>
-            <td>${item.kev_count || 0}</td>
-            <td>${item.epss_high_count || 0}</td>
-            <td class="text-muted" style="font-size: 0.85rem;">Not found in official registry</td>
-        </tr>
-    `);
-    }
-
-    function populateTable(bodyId, data, rowFn) {
-        const tbody = document.getElementById(bodyId);
-        if (!data || data.length === 0) {
-            tbody.innerHTML = '<tr><td colspan="5" class="text-center text-muted">None found</td></tr>';
-            return;
-        }
-        tbody.innerHTML = data.map(rowFn).join('');
-    }
-
-    function createCharts() {
-        const stats = dataQuality.stats;
-
-        // Match quality distribution (CNA count)
-        const qualityCtx = document.getElementById('matchQualityChart').getContext('2d');
-        charts.quality = new Chart(qualityCtx, {
-            type: 'doughnut',
-            data: {
-                labels: ['Exact', 'Case', 'Org Name', 'Normalized', 'Partial', 'Unmatched'],
-                datasets: [{
-                    data: [
-                        stats.exact_matches,
-                        stats.case_mismatches,
-                        stats.org_name_matches,
-                        stats.normalized_matches,
-                        stats.partial_matches,
-                        stats.unmatched
-                    ],
-                    backgroundColor: ['#1e3a5f', '#2563eb', '#3b82f6', '#60a5fa', '#93c5fd', '#cbd5e1'],
-                    borderWidth: 0
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        position: 'bottom',
-                        labels: { color: '#64748b', font: { size: 10 } }
-                    },
-                    title: {
-                        display: true,
-                        text: 'CNAs by Match Type',
-                        color: '#64748b'
-                    }
-                }
-            }
-        });
-
-        // CVE distribution by match type (excluding exact for scale)
-        const cveCtx = document.getElementById('cveMatchChart').getContext('2d');
-        charts.cve = new Chart(cveCtx, {
-            type: 'bar',
-            data: {
-                labels: ['Case', 'Org Name', 'Normalized', 'Partial', 'Unmatched'],
-                datasets: [{
-                    label: 'CVEs',
-                    data: [
-                        stats.case_mismatch_cves,
-                        stats.org_name_match_cves,
-                        stats.normalized_match_cves,
-                        stats.partial_match_cves,
-                        stats.unmatched_cves
-                    ],
-                    backgroundColor: ['#2563eb', '#3b82f6', '#60a5fa', '#93c5fd', '#cbd5e1'],
-                    borderWidth: 0,
-                    borderRadius: 4
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: { display: false }
-                },
-                scales: {
-                    y: {
-                        beginAtZero: true,
-                        grid: { color: 'rgba(0,0,0,0.05)' },
-                        ticks: { color: '#64748b' }
-                    },
-                    x: {
-                        grid: { display: false },
-                        ticks: { color: '#64748b', font: { size: 9 } }
-                    }
-                }
-            }
-        });
-    }
-
-    function escapeHtml(text) {
-        if (!text) return '';
-        const div = document.createElement('div');
-        div.textContent = text;
-        return div.innerHTML;
-    }
-
-    document.addEventListener('DOMContentLoaded', loadDataQuality);
-</script>
-{% endblock %}
\ No newline at end of file
diff --git a/templates/cna/index.html b/templates/cna/index.html
deleted file mode 100644
index 26ebd9d1776..00000000000
--- a/templates/cna/index.html
+++ /dev/null
@@ -1,720 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-  <!-- Google tag (gtag.js) -->
-  <script async src="https://www.googletagmanager.com/gtag/js?id=G-MQJ07VQQQN"></script>
-  <script>
-    window.dataLayer = window.dataLayer || [];
-    function gtag() { dataLayer.push(arguments); }
-    gtag('js', new Date());
-
-    gtag('config', 'G-MQJ07VQQQN');
-  </script>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>CNA Scorecard</title>
-  <link rel="icon" type="image/svg+xml" href="assets/logo.svg">
-  <link rel="icon" type="image/png" href="assets/logo.svg">
-  <link rel="stylesheet" href="assets/theme.css">
-  <link rel="stylesheet" href="shared/shared.css">
-  <script src="https://cdn.jsdelivr.net/npm/chart.js" async></script>
-  <style>
-    /* Homepage-specific styles */
-    .container {
-      max-width: 1200px;
-      margin: 0 auto;
-      padding: 2rem 1rem;
-    }
-
-    .page-header {
-      background-color: var(--card-bg);
-      border-radius: 12px;
-      padding: 2rem;
-      margin-bottom: 2rem;
-      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
-      text-align: center;
-    }
-
-    .page-title {
-      font-size: 2.5rem;
-      color: var(--primary-color);
-      margin-bottom: 1rem;
-      font-weight: 600;
-    }
-
-    .page-subtitle {
-      color: var(--text-secondary);
-      font-size: 1.1rem;
-      margin: 0 auto 2rem;
-      line-height: 1.6;
-      max-width: 900px;
-    }
-
-    .cta-buttons {
-      display: flex;
-      gap: 1rem;
-      justify-content: center;
-      flex-wrap: wrap;
-    }
-
-    .cta-button {
-      padding: 1rem 2rem;
-      border-radius: 8px;
-      text-decoration: none;
-      font-weight: 600;
-      transition: all 0.3s ease;
-      display: inline-flex;
-      align-items: center;
-      gap: 0.5rem;
-    }
-
-    .cta-button.primary {
-      background: var(--primary-color);
-      color: white;
-    }
-
-    .cta-button.secondary {
-      background: var(--card-bg);
-      color: var(--text-primary);
-      border: 1px solid var(--border-color);
-    }
-
-    .cta-button:hover {
-      transform: translateY(-2px);
-      box-shadow: 0 8px 25px rgba(0, 0, 0, 0.2);
-    }
-
-    .stats-grid {
-      display: grid;
-      grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
-      gap: 1.5rem;
-    }
-
-    .stat-card {
-      background: var(--card-bg);
-      padding: 1.5rem;
-      border-radius: 8px;
-      border: 1px solid var(--border-color);
-      text-align: center;
-      transition: transform 0.2s ease, box-shadow 0.2s ease;
-    }
-
-    .stat-card:hover {
-      transform: translateY(-2px);
-      box-shadow: 0 6px 20px rgba(0, 0, 0, 0.1);
-    }
-
-    .stat-value {
-      font-size: 2.5rem;
-      font-weight: 700;
-      color: var(--primary-color);
-      margin-bottom: 0.5rem;
-    }
-
-    .stat-label {
-      color: var(--text-secondary);
-      font-size: 0.9rem;
-      text-transform: uppercase;
-      letter-spacing: 0.5px;
-    }
-
-    /* Date range styling */
-    .date-separator {
-      color: #ccc;
-      margin: 0 0.5rem;
-      font-weight: 300;
-      font-size: 0.9em;
-    }
-
-    .date-start,
-    .date-end {
-      display: inline-block;
-    }
-
-    .section {
-      background-color: var(--card-bg);
-      border-radius: 12px;
-      padding: 2rem;
-      margin-bottom: 2rem;
-      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
-    }
-
-    .section-title {
-      font-size: 1.75rem;
-      font-weight: 600;
-      margin-bottom: 1.5rem;
-      text-align: center;
-      color: var(--primary-color);
-    }
-
-    .two-column {
-      display: grid;
-      grid-template-columns: 1fr 1fr;
-      gap: 3rem;
-      align-items: center;
-    }
-
-    .chart-container {
-      background: var(--card-bg);
-      padding: 2rem;
-      border-radius: 12px;
-      border: 1px solid var(--border-color);
-    }
-
-    .chart-canvas {
-      width: 100%;
-      height: 400px;
-    }
-
-    .performance-columns {
-      display: grid;
-      grid-template-columns: 1fr 1fr;
-      gap: 1.5rem;
-    }
-
-    .performance-column {
-      background: var(--card-bg);
-      padding: 1.5rem;
-      border-radius: 8px;
-      border: 1px solid var(--border-color);
-    }
-
-    .performance-column h3 {
-      margin-bottom: 1.5rem;
-      color: var(--text-primary);
-      font-size: 1.25rem;
-    }
-
-    .cna-item {
-      display: flex;
-      justify-content: space-between;
-      align-items: center;
-      padding: 0.75rem 0;
-      border-bottom: 1px solid var(--border-color);
-    }
-
-    .cna-item:last-child {
-      border-bottom: none;
-    }
-
-    .cna-name {
-      color: var(--primary-color);
-      text-decoration: none;
-      font-weight: 500;
-    }
-
-    .cna-name:hover {
-      text-decoration: underline;
-    }
-
-    .cna-score {
-      font-weight: 600;
-      color: var(--text-secondary);
-    }
-
-    .centered-cta {
-      text-align: center;
-      margin-top: 2rem;
-    }
-
-    .category-grid {
-      display: grid;
-      grid-template-columns: repeat(6, 1fr);
-      gap: 2rem;
-      margin-top: 2rem;
-    }
-
-    .category-grid .category-card:nth-child(1) {
-      grid-column: 1 / 3;
-    }
-
-    .category-grid .category-card:nth-child(2) {
-      grid-column: 3 / 5;
-    }
-
-    .category-grid .category-card:nth-child(3) {
-      grid-column: 5 / 7;
-    }
-
-    .category-grid .category-card:nth-child(4) {
-      grid-column: 2 / 4;
-      grid-row: 2;
-    }
-
-    .category-grid .category-card:nth-child(5) {
-      grid-column: 4 / 6;
-      grid-row: 2;
-    }
-
-    @media (max-width: 1024px) {
-      .category-grid {
-        grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-      }
-
-      .category-grid .category-card:nth-child(1),
-      .category-grid .category-card:nth-child(2),
-      .category-grid .category-card:nth-child(3),
-      .category-grid .category-card:nth-child(4),
-      .category-grid .category-card:nth-child(5) {
-        grid-column: unset;
-        grid-row: unset;
-      }
-    }
-
-    .category-card {
-      background: var(--card-bg);
-      padding: 2rem 1.5rem;
-      border-radius: 8px;
-      border: 1px solid var(--border-color);
-      text-align: center;
-      transition: transform 0.2s ease, box-shadow 0.2s ease;
-      position: relative;
-      overflow: hidden;
-    }
-
-    .category-card::before {
-      content: '';
-      position: absolute;
-      top: 0;
-      left: 0;
-      right: 0;
-      height: 4px;
-      background: linear-gradient(90deg, var(--primary-color), var(--accent-color));
-    }
-
-    .category-card:hover {
-      transform: translateY(-3px);
-      box-shadow: 0 8px 25px rgba(0, 0, 0, 0.12);
-    }
-
-    .category-score {
-      font-size: 3rem;
-      font-weight: 700;
-      color: var(--primary-color);
-      margin-bottom: 0.75rem;
-      text-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
-    }
-
-    .category-name {
-      font-size: 1.2rem;
-      font-weight: 600;
-      color: var(--text-primary);
-      margin-bottom: 0.75rem;
-      line-height: 1.3;
-    }
-
-    .category-description {
-      font-size: 0.95rem;
-      color: var(--text-secondary);
-      margin-bottom: 1.25rem;
-      line-height: 1.5;
-      font-weight: 500;
-    }
-
-    .category-importance {
-      font-size: 0.9rem;
-      color: var(--text-secondary);
-      font-style: italic;
-      line-height: 1.4;
-      padding-top: 0.75rem;
-      border-top: 1px solid var(--border-color);
-      opacity: 0.9;
-    }
-
-    @media (max-width: 768px) {
-      .page-title {
-        font-size: 2rem;
-      }
-
-      .two-column,
-      .performance-columns {
-        grid-template-columns: 1fr;
-        gap: 2rem;
-      }
-
-      .category-grid {
-        grid-template-columns: 1fr;
-        gap: 1.5rem;
-      }
-
-      .category-score {
-        font-size: 2.5rem;
-      }
-
-      .cta-buttons {
-        flex-direction: column;
-        align-items: center;
-        padding: 0 1rem;
-        width: 100%;
-        box-sizing: border-box;
-      }
-
-      .cta-button {
-        width: 100%;
-        max-width: 280px;
-        justify-content: center;
-        padding: 0.875rem 1.5rem;
-        font-size: 0.95rem;
-        box-sizing: border-box;
-      }
-
-      .page-header {
-        padding: 1.5rem 1rem;
-        margin: 0 0.5rem 1.5rem 0.5rem;
-      }
-
-      .page-title {
-        font-size: 1.5rem;
-      }
-
-      .page-subtitle {
-        font-size: 0.95rem;
-        margin-bottom: 1.5rem;
-      }
-    }
-
-    @media (max-width: 400px) {
-      .page-header {
-        margin: 0 0.25rem 1rem 0.25rem;
-        padding: 1rem 0.75rem;
-      }
-
-      .cta-button {
-        padding: 0.75rem 1rem;
-        font-size: 0.9rem;
-      }
-
-      .page-title {
-        font-size: 1.3rem;
-      }
-    }
-  </style>
-</head>
-
-<body>
-  <!-- Skip Link for Accessibility -->
-  <a href="#main-content" class="skip-link">Skip to main content</a>
-
-  <!-- Navigation Bar -->
-  <nav class="navbar" role="navigation" aria-label="Main Navigation">
-    <img src="assets/logo.svg" alt="CNA Scorecard Logo" class="navbar-logo">
-    <div class="navbar-links">
-      <a href="index.html" class="active">Home</a>
-      <a href="cna/index.html">CNAs</a>
-      <a href="completeness/index.html">Record Completeness</a>
-      <a href="trends.html">Performance Trends</a>
-      <a href="scoring.html">Methodology</a>
-    </div>
-  </nav>
-
-  <main class="container" id="main-content">
-    <!-- Page Header -->
-    <section class="page-header">
-      <h1 class="page-title">CNA Scorecard: Tracking CVE Data Completeness</h1>
-      <p class="page-subtitle">
-        Tracks how thoroughly CVE Numbering Authorities populate vulnerability records with actionable intelligence over
-        the last 6 months,
-        helping users of their products better understand, prioritize, and respond to security threats.
-      </p>
-      <div class="cta-buttons">
-        <a href="cna/index.html" class="cta-button primary">Explore CNA Scores</a>
-        <a href="completeness/index.html" class="cta-button secondary">View Completeness Report</a>
-      </div>
-    </section>
-
-    <!-- Category Breakdown Section -->
-    <section class="section">
-      <h2 class="section-title">Understanding CVE Data Completeness: Five Key Categories</h2>
-      <p
-        style="color: var(--text-secondary); line-height: 1.6; font-size: 1.1rem; text-align: center; max-width: 1000px; margin: 0 auto 3rem;">
-        Complete data in vulnerability records helps security teams make informed decisions and respond effectively to
-        threats.
-        The CNA Scorecard evaluates how thoroughly CVE Numbering Authorities populate five essential categories over the
-        last 6 months,
-        with the percentages below showing average completeness scores across all CNAs during this period.
-      </p>
-      <div class="category-grid" id="categoryGrid">
-        <!-- Category cards will be populated by JavaScript -->
-      </div>
-    </section>
-
-    <!-- CNA Performance Snapshot -->
-    <section class="section">
-      <h2 class="section-title">CNA Performance Snapshot</h2>
-      <div class="performance-columns" id="performanceColumns">
-        <!-- Performance columns will be populated by JavaScript -->
-      </div>
-      <div class="centered-cta">
-        <a href="cna/index.html" class="cta-button primary">View Full Leaderboard</a>
-      </div>
-    </section>
-
-    <!-- Key Statistics Section -->
-    <section class="section">
-      <h2 class="section-title">Key Statistics</h2>
-      <div class="stats-grid" id="statsGrid">
-        <!-- Statistics cards will be populated by JavaScript -->
-      </div>
-    </section>
-  </main>
-
-  <!-- Footer -->
-  <footer class="footer">
-    <div class="footer-main">
-      <div class="footer-brand">
-        <img src="assets/logo.svg" alt="CNA Scorecard Logo" class="footer-logo">
-        <span class="footer-title">CNA Scorecard</span>
-      </div>
-      <div class="footer-links">
-        <a href="https://github.com/CVEDB/cvedb.github.io" target="_blank">GitHub</a>
-        <a href="https://cvedb.github.io" target="_blank">CVEDB</a>
-        <a href="https://patchthis.app" target="_blank">PatchThis</a>
-        <a href="https://cveforecast.org" target="_blank">CVEForecast</a>
-        <a href="https://cvedb.github.io" target="_blank">CVEDB</a>
-      </div>
-    </div>
-    <div class="footer-meta">&copy; 2025 CVEDB. All rights reserved.</div>
-  </footer>
-
-  <!-- JavaScript -->
-  <script type="module">
-    import { createHorizontalBarChart } from './shared/charts.js';
-
-    // Utility function for number formatting
-    function formatNumber(num) {
-      if (num >= 1000000) {
-        return (num / 1000000).toFixed(1) + 'M';
-      } else if (num >= 1000) {
-        return (num / 1000).toFixed(1) + 'K';
-      }
-      return num.toString();
-    }
-
-    // Utility function for date formatting
-    function formatDateRange(dateRangeString) {
-      try {
-        // Parse the date range string (e.g., "2025-01-23 to 2025-07-23")
-        const parts = dateRangeString.split(' to ');
-        if (parts.length !== 2) return dateRangeString;
-
-        // Parse as UTC to avoid timezone conversion issues
-        const startDate = new Date(parts[0] + 'T12:00:00Z');
-        const endDate = new Date(parts[1] + 'T12:00:00Z');
-
-        const formatDate = (date) => {
-          const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
-            'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-
-          const day = date.getDate();
-          const month = months[date.getMonth()];
-          const year = date.getFullYear();
-
-          // Add ordinal suffix (st, nd, rd, th)
-          const getOrdinal = (n) => {
-            const s = ['th', 'st', 'nd', 'rd'];
-            const v = n % 100;
-            return n + (s[(v - 20) % 10] || s[v] || s[0]);
-          };
-
-          return `${month} ${getOrdinal(day)}, ${year}`;
-        };
-
-        return `<span class="date-start">${formatDate(startDate)}</span><span class="date-separator">–</span><span class="date-end">${formatDate(endDate)}</span>`;
-      } catch (error) {
-        console.error('Error formatting date range:', error);
-        return dateRangeString; // Return original if formatting fails
-      }
-    }
-
-    // Load and display key statistics
-    async function loadKeyStatistics() {
-      try {
-        const [cnaResponse, completenessResponse] = await Promise.all([
-          fetch('./data/cna_combined.json'),
-          fetch('./data/completeness_summary.json')
-        ]);
-
-        const cnaData = await cnaResponse.json();
-        const completenessData = await completenessResponse.json();
-
-        // Calculate statistics from the data
-        const totalCNAs = cnaData.length;
-        const totalCVEs = completenessData.total_cves_analyzed || 0;
-        const rawAnalysisPeriod = completenessData.analysis_period || 'Not available';
-        const analysisPeriod = rawAnalysisPeriod !== 'Not available' ? formatDateRange(rawAnalysisPeriod) : rawAnalysisPeriod;
-
-        // Calculate average overall score from CNAs with valid scores
-        const cnasWithScores = cnaData.filter(cna => cna.scores && cna.scores.overall_average_score > 0);
-        const avgScore = cnasWithScores.length > 0
-          ? (cnasWithScores.reduce((sum, cna) => sum + cna.scores.overall_average_score, 0) / cnasWithScores.length).toFixed(1)
-          : '0.0';
-
-        // Calculate active CNAs (CNAs that have contributed recent CVEs)
-        const activeCNAs = cnaData.filter(cna => cna.recent_cves && cna.recent_cves > 0).length;
-
-        const statsGrid = document.getElementById('statsGrid');
-        statsGrid.innerHTML = `
-          <div class="stat-card">
-            <div class="stat-label">Total CVEs Analyzed</div>
-            <div class="stat-value">${formatNumber(totalCVEs)}</div>
-          </div>
-          <div class="stat-card">
-            <div class="stat-label">Average Overall Score</div>
-            <div class="stat-value">${avgScore}%</div>
-          </div>
-          <div class="stat-card">
-            <div class="stat-label">Active CNAs</div>
-            <div class="stat-value">${formatNumber(activeCNAs)}</div>
-          </div>
-          <div class="stat-card">
-            <div class="stat-label">Analysis Period</div>
-            <div class="stat-value" style="font-size: 1.8rem;">${analysisPeriod}</div>
-          </div>
-        `;
-      } catch (error) {
-        console.error('Error loading key statistics:', error);
-        document.getElementById('statsGrid').innerHTML = '<p>Error loading statistics</p>';
-      }
-    }
-
-    // Load and display category breakdown
-    async function loadCategoryBreakdown() {
-      try {
-        const response = await fetch('./data/cna_combined.json');
-        const data = await response.json();
-
-        // Filter CNAs with valid scores
-        const cnasWithScores = data.filter(cna => cna.scores && cna.scores.overall_average_score > 0);
-
-        if (cnasWithScores.length === 0) {
-          document.getElementById('categoryGrid').innerHTML = '<p>No scoring data available</p>';
-          return;
-        }
-
-        // Calculate average scores for each category
-        const categories = [
-          {
-            key: 'foundational_completeness',
-            label: 'Foundational Completeness',
-            description: 'Essential CVE fields like ID, description, and affected products',
-            importance: 'The essential building blocks of every CVE record, required for publication and providing basic context needed to understand any vulnerability'
-          },
-          {
-            key: 'root_cause_analysis',
-            label: 'Root Cause Analysis',
-            description: 'Common Weakness Enumeration (CWE)',
-            importance: 'Understanding the "why" behind vulnerabilities helps development teams recognize common weakness patterns and implement preventive measures'
-          },
-          {
-            key: 'software_identification',
-            label: 'Software Identification',
-            description: 'Common Platform Enumeration (CPE)',
-            importance: 'Enabling precise vulnerability detection by allowing security tools to accurately match vulnerabilities to specific software versions'
-          },
-          {
-            key: 'severity_and_impact',
-            label: 'Severity & Impact',
-            description: 'Common Vulnerability Scoring System (CVSS)',
-            importance: 'Supporting informed risk decisions by helping organizations prioritize their response based on potential business impact'
-          },
-          {
-            key: 'patchinfo',
-            label: 'Patch Information',
-            description: 'Links to patches, fixes, or mitigation information',
-            importance: 'Connecting problems to solutions by providing links to patches, fixes, and mitigation guidance for faster remediation'
-          }
-        ];
-
-        // Calculate averages and create cards
-        const categoryCards = categories.map(category => {
-          const average = cnasWithScores.reduce((sum, cna) => {
-            return sum + (cna.scores[category.key] || 0);
-          }, 0) / cnasWithScores.length;
-
-          return `
-            <div class="category-card">
-              <div class="category-score" style="color: var(--primary-color)">${average.toFixed(1)}%</div>
-              <div class="category-name">${category.label}</div>
-              <div class="category-description">${category.description}</div>
-              <div class="category-importance">${category.importance}</div>
-            </div>
-          `;
-        }).join('');
-
-        document.getElementById('categoryGrid').innerHTML = categoryCards;
-
-      } catch (error) {
-        console.error('Error loading category breakdown data:', error);
-        document.getElementById('categoryGrid').innerHTML = '<p>Error loading category data</p>';
-      }
-    }
-
-    // Load and display CNA performance snapshot
-    async function loadCNAPerformanceSnapshot() {
-      try {
-        const response = await fetch('./data/cna_combined.json');
-        const data = await response.json();
-
-        // Filter CNAs with valid scores and sort by overall average score
-        const validCNAs = data
-          .filter(cna => cna.scores && cna.scores.overall_average_score > 0)
-          .sort((a, b) => b.scores.overall_average_score - a.scores.overall_average_score);
-
-        const top5 = validCNAs.slice(0, 5);
-
-        // Find most active CNAs (highest recent CVE count) that aren't in top 5
-        const mostActive = data
-          .filter(cna => cna.scores && cna.scores.overall_average_score > 0 &&
-            cna.recent_cves && cna.recent_cves > 0 &&
-            !top5.some(top => top.shortName === cna.shortName))
-          .sort((a, b) => b.recent_cves - a.recent_cves)
-          .slice(0, 5);
-
-        const performanceColumns = document.getElementById('performanceColumns');
-        performanceColumns.innerHTML = `
-          <div class="performance-column">
-            <h3>Top 5 Scoring CNAs</h3>
-            ${top5.map(cna => `
-              <div class="cna-item">
-                <a href="cna/cna-detail.html?shortName=${encodeURIComponent(cna.shortName)}" class="cna-name">
-                  ${cna.shortName}
-                </a>
-                <span class="cna-score">${cna.scores.overall_average_score.toFixed(1)}%</span>
-              </div>
-            `).join('')}
-          </div>
-          <div class="performance-column">
-            <h3>Most Active CNAs</h3>
-            ${mostActive.map(cna => `
-              <div class="cna-item">
-                <a href="cna/cna-detail.html?shortName=${encodeURIComponent(cna.shortName)}" class="cna-name">
-                  ${cna.shortName}
-                </a>
-                <span class="cna-score">${cna.recent_cves} CVEs</span>
-              </div>
-            `).join('')}
-          </div>
-        `;
-      } catch (error) {
-        console.error('Error loading CNA performance data:', error);
-        document.getElementById('performanceColumns').innerHTML = '<p>Error loading performance data</p>';
-      }
-    }
-
-    // Initialize the homepage
-    async function initializeHomepage() {
-      await Promise.all([
-        loadKeyStatistics(),
-        loadCategoryBreakdown(),
-        loadCNAPerformanceSnapshot()
-      ]);
-    }
-
-    // Load everything when the DOM is ready
-    document.addEventListener('DOMContentLoaded', initializeHomepage);
-  </script>
-  <script src="shared/mobile-nav.js"></script>
-</body>
-
-</html>
\ No newline at end of file
diff --git a/templates/cna/scoring.html b/templates/cna/scoring.html
deleted file mode 100644
index 60aed4d52b9..00000000000
--- a/templates/cna/scoring.html
+++ /dev/null
@@ -1,803 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-  <!-- Google tag (gtag.js) -->
-  <script async src="https://www.googletagmanager.com/gtag/js?id=G-MQJ07VQQQN"></script>
-  <script>
-    window.dataLayer = window.dataLayer || [];
-    function gtag() { dataLayer.push(arguments); }
-    gtag('js', new Date());
-
-    gtag('config', 'G-MQJ07VQQQN');
-  </script>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>CNA Scorecard</title>
-  <link rel="icon" type="image/svg+xml" href="assets/logo.svg">
-  <link rel="icon" type="image/png" href="assets/logo.svg">
-  <link rel="stylesheet" href="assets/theme.css">
-  <link rel="stylesheet" href="shared/shared.css">
-  <link rel="stylesheet" href="scoring.css">
-</head>
-
-<body>
-  <!-- Skip Link for Accessibility -->
-  <a href="#main-content" class="skip-link">Skip to main content</a>
-
-  <nav class="navbar" role="navigation" aria-label="Main Navigation">
-    <img src="assets/logo.svg" alt="CNA Scorecard Logo" class="navbar-logo">
-    <div class="navbar-links">
-      <a href="index.html">Home</a>
-      <a href="cna/index.html">CNAs</a>
-      <a href="completeness/index.html">Record Completeness</a>
-      <a href="trends.html">Performance Trends</a>
-      <a href="scoring.html" class="active">Methodology</a>
-    </div>
-  </nav>
-  <main class="container scoring-cards-container" id="main-content">
-    <!-- Introduction Section -->
-    <section class="scoring-summary-card card">
-      <h1 class="scoring-title">Scoring Methodology</h1>
-      <p class="main-description">
-        The CNA Scorecard promotes transparency and accountability in vulnerability reporting by measuring how
-        completely
-        CVE Numbering Authorities populate essential data fields. The scoring philosophy is simple: complete, actionable
-        vulnerability data leads to better security outcomes for everyone.
-      </p>
-    </section>
-
-    <!-- Scoring Window Section -->
-    <section class="scoring-window-card card">
-      <h2>Scoring Window</h2>
-      <div class="window-info">
-        <div class="current-period">
-          <h3>Current Analysis Period</h3>
-          <p class="period-dates" id="currentPeriod">Loading...</p>
-          <p class="period-description">
-            All CNA scores are based on CVE records published during this 6-month window. This ensures
-            scores reflect recent performance and current data quality practices.
-          </p>
-        </div>
-
-        <div class="window-details">
-          <h3>How the Scoring Window Works</h3>
-          <ul class="window-features">
-            <li><strong>Rolling 6-Month Window:</strong> The analysis period automatically updates to always cover the
-              most recent 6 months of CVE data.</li>
-            <li><strong>Fresh Data:</strong> Scores are recalculated regularly using only CVEs published within the
-              current window, ensuring relevance and accuracy.</li>
-            <li><strong>Trend Analysis:</strong> Performance trends compare the current 6-month period against the
-              previous 6-month period to show improvement or decline.</li>
-            <li><strong>Fair Comparison:</strong> All CNAs are evaluated using the same time window, creating consistent
-              and comparable scoring across organizations.</li>
-          </ul>
-        </div>
-      </div>
-    </section>
-
-    <!-- Scoring Categories Section -->
-    <section class="scoring-categories-card card">
-      <h2>Scoring Categories</h2>
-      <p class="categories-intro">
-        The scoring system evaluates CVE records across five essential categories, with points allocated based on
-        the relative importance of each type of information for security decision-making.
-      </p>
-
-      <div class="category-detail">
-        <h3><span class="category-points">50 points</span> Foundational Completeness</h3>
-        <p class="category-what"><strong>What it is:</strong> The essential building blocks of every CVE record,
-          including problem types, affected products, references, and descriptions.</p>
-        <p class="category-why"><strong>Why it matters:</strong> These are the minimum fields required for CVE
-          publication and provide the basic context needed to understand any vulnerability. Without complete
-          foundational data, security teams cannot properly identify or assess threats.</p>
-        <p class="category-how"><strong>How points are awarded:</strong> Points are earned for including comprehensive
-          problem type classifications, detailed affected product information, relevant reference links, and clear
-          vulnerability descriptions.</p>
-      </div>
-
-      <div class="category-detail">
-        <h3><span class="category-points">15 points</span> Root Cause Analysis</h3>
-        <p class="category-what"><strong>What it is:</strong> Information about the underlying weakness that caused the
-          vulnerability, typically expressed as a CWE (Common Weakness Enumeration) identifier.</p>
-        <p class="category-why"><strong>Why it matters:</strong> CWE data helps development teams understand patterns in
-          security flaws and implement preventive measures. It's like knowing that a house fire was caused by faulty
-          wiring versus a gas leak—the root cause determines the best prevention strategy.</p>
-        <p class="category-how"><strong>How points are awarded:</strong> Points are earned for including valid CWE
-          identifiers that accurately describe the specific type of weakness, rather than generic classifications.</p>
-      </div>
-
-      <div class="category-detail">
-        <h3><span class="category-points">15 points</span> Severity & Impact Context</h3>
-        <p class="category-what"><strong>What it is:</strong> Standardized severity ratings using CVSS (Common
-          Vulnerability Scoring System) metrics, which provide numerical scores from 0-10 indicating how serious a
-          vulnerability is.</p>
-        <p class="category-why"><strong>Why it matters:</strong> CVSS scores help organizations prioritize which
-          vulnerabilities to fix first based on potential impact. A CVSS score of 9.8 demands immediate attention, while
-          a 3.1 might be scheduled for routine patching.</p>
-        <p class="category-how"><strong>How points are awarded:</strong> Points are earned for including complete CVSS
-          v3 or v4 metrics with valid vector strings that accurately reflect the vulnerability's exploitability and
-          impact.</p>
-      </div>
-
-      <div class="category-detail">
-        <h3><span class="category-points">10 points</span> Software Identification</h3>
-        <p class="category-what"><strong>What it is:</strong> Precise identification of affected software using CPE
-          (Common Platform Enumeration) format, which provides standardized names for software products and versions.
-          CPE data can be provided in either the traditional <code>affected[].cpes</code> field or the advanced CVE 5.1
-          <code>cpeApplicability</code> field.
-        </p>
-        <p class="category-why"><strong>Why it matters:</strong> CPE data enables automated vulnerability scanners to
-          accurately match vulnerabilities to specific software in an organization's environment. Without it, security
-          tools can't reliably identify what's at risk.</p>
-        <p class="category-how"><strong>How points are awarded:</strong> Points are earned for including valid CPE
-          identifiers that precisely specify the affected software products, versions, and configurations. Both
-          traditional CPE lists and advanced applicability statements with version ranges are recognized.</p>
-      </div>
-
-      <div class="category-detail">
-        <h3><span class="category-points">10 points</span> Patch Information</h3>
-        <p class="category-what"><strong>What it is:</strong> Direct links to patches, fixes, or official vendor
-          advisories that provide remediation guidance.</p>
-        <p class="category-why"><strong>Why it matters:</strong> Patch information bridges the gap between identifying a
-          vulnerability and actually fixing it. Security teams need clear paths to remediation, not just problem
-          descriptions.</p>
-        <p class="category-how"><strong>How points are awarded:</strong> Points are earned for including direct links to
-          official patches or vendor advisories, rather than generic references or third-party discussions.</p>
-      </div>
-    </section>
-
-    <!-- Technical Documentation Section -->
-    <section class="technical-docs-card card" id="technical-documentation">
-      <h2>Technical Documentation for CNAs</h2>
-      <p class="tech-intro">
-        This section provides the exact technical implementation details for CNAs who want to verify
-        the scoring methodology. All field paths reference the official CVE JSON 5.0 schema.
-      </p>
-
-      <div class="tech-toggle-container">
-        <button class="btn btn-primary" id="toggleTechnicalDetails">Show Technical Details</button>
-      </div>
-
-      <div class="technical-details" id="technicalDetails" style="display: none;">
-
-        <!-- Foundational Completeness Technical Details -->
-        <div class="tech-category" id="foundational-completeness-tech">
-          <h3><span class="category-points">50 points</span> Foundational Completeness - Technical Implementation</h3>
-
-          <div class="tech-subsection">
-            <h4>Schema Field Paths Checked:</h4>
-            <div class="code-block">
-              <code>containers.cna.descriptions</code> (array)<br>
-              <code>containers.cna.affected</code> (array)<br>
-              <code>containers.cna.references</code> (array)
-            </div>
-          </div>
-
-          <div class="tech-subsection">
-            <h4>Validation Logic:</h4>
-            <div class="validation-rule">
-              <strong>Binary Scoring:</strong> All-or-nothing - either 50 points or 0 points
-            </div>
-            <div class="validation-rule">
-              <strong>Requirements:</strong> All three field arrays must exist AND contain at least one valid entry
-            </div>
-            <div class="validation-rule">
-              <strong>Validation Criteria:</strong>
-              <ul>
-                <li><code>descriptions</code>: Must be non-empty array with at least one description object</li>
-                <li><code>affected</code>: Must be non-empty array with at least one affected product object</li>
-                <li><code>references</code>: Must be non-empty array with at least one reference object</li>
-              </ul>
-            </div>
-          </div>
-
-          <div class="tech-subsection">
-            <h4>Code Implementation:</h4>
-            <div class="code-block">
-              <pre>def _calculate_foundational_completeness(cve, cna):
-    descriptions = cna.get('descriptions', [])
-    affected = cna.get('affected', [])
-    references = cna.get('references', [])
-    
-    has_descriptions = isinstance(descriptions, list) and len(descriptions) > 0
-    has_affected = isinstance(affected, list) and len(affected) > 0
-    has_references = isinstance(references, list) and len(references) > 0
-    
-    return 50 if (has_descriptions and has_affected and has_references) else 0</pre>
-            </div>
-          </div>
-        </div>
-
-        <!-- Root Cause Analysis Technical Details -->
-        <div class="tech-category" id="root-cause-analysis-tech">
-          <h3><span class="category-points">15 points</span> Root Cause Analysis - Technical Implementation</h3>
-
-          <div class="tech-subsection">
-            <h4>Schema Field Paths Checked:</h4>
-            <div class="code-block">
-              <code>containers.cna.problemTypes[].descriptions[].cweId</code> (string)
-            </div>
-          </div>
-
-          <div class="tech-subsection">
-            <h4>Validation Logic:</h4>
-            <div class="validation-rule">
-              <strong>Binary Scoring:</strong> Either 15 points or 0 points
-            </div>
-            <div class="validation-rule">
-              <strong>CWE ID Format:</strong> Must match pattern <code>CWE-[0-9]+</code> (case-insensitive)
-            </div>
-            <div class="validation-rule">
-              <strong>Valid CWE List:</strong> Must exist in official MITRE CWE database (loaded from cwe_ids.json)
-            </div>
-            <div class="validation-rule">
-              <strong>Search Process:</strong> Iterates through all problemTypes → descriptions → cweId fields
-            </div>
-          </div>
-
-          <div class="tech-subsection">
-            <h4>Code Implementation:</h4>
-            <div class="code-block">
-              <pre>def _calculate_root_cause_analysis(cve, cna):
-    problem_types = cna.get('problemTypes', [])
-    if not isinstance(problem_types, list):
-        return 0
-    
-    has_valid_cwe = _find_valid_cwe(problem_types)
-    return 15 if has_valid_cwe else 0
-
-def _find_valid_cwe(problem_types):
-    for problem_type in problem_types:
-        descriptions = problem_type.get('descriptions', [])
-        for desc in descriptions:
-            cwe_id = desc.get('cweId', '')
-            if _is_valid_cwe_id(cwe_id):
-                return True
-    return False
-
-def _is_valid_cwe_id(cwe_raw):
-    if not isinstance(cwe_raw, str):
-        return False
-    
-    # Check format: CWE-[digits]
-    import re
-    if not re.match(r'^CWE-\d+$', cwe_raw, re.IGNORECASE):
-        return False
-    
-    # Check against official CWE database
-    return cwe_raw.upper() in scoring_config.valid_cwe_ids</pre>
-            </div>
-          </div>
-        </div>
-
-        <!-- Severity & Impact Context Technical Details -->
-        <div class="tech-category" id="severity-impact-context-tech">
-          <h3><span class="category-points">15 points</span> Severity & Impact Context - Technical Implementation</h3>
-
-          <div class="tech-subsection">
-            <h4>Schema Field Paths Checked:</h4>
-            <div class="code-block">
-              <code>containers.cna.metrics[].cvssV3_0</code> (object)<br>
-              <code>containers.cna.metrics[].cvssV3_1</code> (object)<br>
-              <code>containers.cna.metrics[].cvssV4_0</code> (object)
-            </div>
-          </div>
-
-          <div class="tech-subsection">
-            <h4>Validation Logic:</h4>
-            <div class="validation-rule">
-              <strong>Binary Scoring:</strong> Either 15 points or 0 points
-            </div>
-            <div class="validation-rule">
-              <strong>CVSS Version Support:</strong> Accepts CVSS v3.0, v3.1, or v4.0
-            </div>
-            <div class="validation-rule">
-              <strong>Vector String Required:</strong> Must contain valid <code>vectorString</code> field
-            </div>
-            <div class="validation-rule">
-              <strong>Search Process:</strong> Iterates through metrics array looking for any valid CVSS object
-            </div>
-          </div>
-
-          <div class="tech-subsection">
-            <h4>Code Implementation:</h4>
-            <div class="code-block">
-              <pre>def _calculate_severity_context(cve, cna):
-    metrics = cna.get('metrics', [])
-    if not isinstance(metrics, list):
-        return 0
-    
-    has_cvss = _has_cvss_metrics(metrics)
-    has_vector = _has_valid_cvss_vector(metrics)
-    
-    return 15 if (has_cvss and has_vector) else 0
-
-def _has_cvss_metrics(metrics):
-    for metric in metrics:
-        if any(version in metric for version in ['cvssV3_0', 'cvssV3_1', 'cvssV4_0']):
-            return True
-    return False
-
-def _has_valid_cvss_vector(metrics):
-    for metric in metrics:
-        for version in ['cvssV3_0', 'cvssV3_1', 'cvssV4_0']:
-            if version in metric:
-                cvss_data = metric[version]
-                if isinstance(cvss_data, dict) and cvss_data.get('vectorString'):
-                    return True
-    return False</pre>
-            </div>
-          </div>
-        </div>
-
-        <!-- Software Identification Technical Details -->
-        <div class="tech-category" id="software-identification-tech">
-          <h3><span class="category-points">10 points</span> Software Identification - Technical Implementation</h3>
-
-          <div class="tech-subsection">
-            <h4>Schema Field Paths Checked:</h4>
-            <div class="code-block">
-              <strong>Traditional Field:</strong><br>
-              <code>containers.cna.affected[].cpes</code> (array of CPE 2.3 strings)<br>
-              <br>
-              <strong>CVE 5.1 Advanced Field:</strong><br>
-              <code>containers.cna.cpeApplicability[].nodes[].cpeMatch[].criteria</code> (CPE with operators)
-            </div>
-            <p style="margin-top: 1rem; color: var(--text-secondary); font-style: italic;">
-              <strong>Note:</strong> Both field types are checked. Points are awarded if CPE data is found in either
-              location.
-            </p>
-          </div>
-
-          <div class="tech-subsection">
-            <h4>Validation Logic:</h4>
-            <div class="validation-rule">
-              <strong>Binary Scoring:</strong> Either 10 points or 0 points
-            </div>
-            <div class="validation-rule">
-              <strong>Dual Field Support:</strong> Checks traditional <code>affected[].cpes</code> first, then CVE 5.1
-              <code>cpeApplicability</code>
-            </div>
-            <div class="validation-rule">
-              <strong>Traditional CPE:</strong> At least one affected product must contain non-empty cpes array
-            </div>
-            <div class="validation-rule">
-              <strong>CPE Applicability:</strong> Must contain valid nodes with cpeMatch entries and criteria strings
-            </div>
-          </div>
-
-          <div class="tech-subsection">
-            <h4>Code Implementation:</h4>
-            <div class="code-block">
-              <pre>def _calculate_software_identification(cve, cna):
-    # Check traditional affected[].cpes field
-    affected = cna.get('affected', [])
-    if isinstance(affected, list):
-        has_cpe_in_affected = _has_cpe_identifiers(affected)
-        if has_cpe_in_affected:
-            return 10
-    
-    # Check CVE 5.1 cpeApplicability field
-    has_cpe_applicability = _has_cpe_applicability(cna)
-    if has_cpe_applicability:
-        return 10
-    
-    return 0
-
-def _has_cpe_identifiers(affected):
-    """Check for traditional CPE lists in affected products"""
-    for product in affected:
-        if not isinstance(product, dict):
-            continue
-        
-        cpes = product.get('cpes')
-        if isinstance(cpes, list) and len(cpes) > 0:
-            return True
-    
-    return False
-
-def _has_cpe_applicability(cna):
-    """Check for CVE 5.1 cpeApplicability with advanced matching"""
-    cpe_applicability = cna.get('cpeApplicability', [])
-    
-    for item in cpe_applicability:
-        nodes = item.get('nodes', [])
-        for node in nodes:
-            cpe_match = node.get('cpeMatch', [])
-            for match in cpe_match:
-                if isinstance(match, dict) and match.get('criteria'):
-                    return True
-    
-    return False</pre>
-            </div>
-          </div>
-
-          <div class="tech-subsection">
-            <h4>CVE 5.1 cpeApplicability Structure:</h4>
-            <div class="code-block">
-              <pre>{
-  "cpeApplicability": [
-    {
-      "nodes": [
-        {
-          "operator": "OR",
-          "cpeMatch": [
-            {
-              "vulnerable": true,
-              "criteria": "cpe:2.3:a:vendor:product:*:*:*:*:*:*:*:*",
-              "versionEndExcluding": "1.2.3"
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}</pre>
-            </div>
-            <p style="margin-top: 1rem; color: var(--text-secondary);">
-              The <code>cpeApplicability</code> field provides NVD-style CPE matching with operators and version ranges,
-              enabling more precise vulnerability applicability statements than simple CPE lists.
-            </p>
-          </div>
-        </div>
-
-        <!-- Patch Information Technical Details -->
-        <div class="tech-category" id="patch-information-tech">
-          <h3><span class="category-points">10 points</span> Patch Information - Technical Implementation</h3>
-
-          <div class="tech-subsection">
-            <h4>Schema Field Paths Checked:</h4>
-            <div class="code-block">
-              <code>containers.cna.references[].tags</code> (array of strings)
-            </div>
-          </div>
-
-          <div class="tech-subsection">
-            <h4>Validation Logic:</h4>
-            <div class="validation-rule">
-              <strong>Binary Scoring:</strong> Either 10 points or 0 points
-            </div>
-            <div class="validation-rule">
-              <strong>Tag Matching:</strong> Case-insensitive search for "patch" in any tag string
-            </div>
-            <div class="validation-rule">
-              <strong>Search Process:</strong> Iterates through all references → tags arrays
-            </div>
-          </div>
-
-          <div class="tech-subsection">
-            <h4>Code Implementation:</h4>
-            <div class="code-block">
-              <pre>def _calculate_actionable_intelligence(cve, cna):
-    references = cna.get('references', [])
-    if not isinstance(references, list):
-        return 0
-    
-    has_patch_ref = _has_patch_references(references)
-    return 10 if has_patch_ref else 0
-
-def _has_patch_references(references):
-    for ref in references:
-        if not isinstance(ref, dict):
-            continue
-        
-        tags = ref.get('tags', [])
-        if not isinstance(tags, list):
-            continue
-        
-        # Check for patch-related tags (case-insensitive)
-        for tag in tags:
-            if isinstance(tag, str) and 'patch' in tag.lower():
-                return True
-    
-    return False</pre>
-            </div>
-          </div>
-        </div>
-
-        <!-- Scoring Configuration -->
-        <div class="tech-category" id="scoring-configuration">
-          <h3>Scoring Configuration (rules.json)</h3>
-
-          <div class="tech-subsection">
-            <h4>Complete Scoring Rules:</h4>
-            <div class="code-block">
-              <pre>{
-  "foundationalCompleteness": {
-    "weight": 50,
-    "criteria": ["descriptions", "affected", "references"],
-    "binary": true
-  },
-  "rootCauseAnalysis": {
-    "weight": 15,
-    "criteria": ["validCWE"],
-    "binary": true
-  },
-  "severityAndImpactContext": {
-    "weight": 15,
-    "criteria": ["cvssV3or4", "validVector"],
-    "binary": true
-  },
-  "softwareIdentification": {
-    "weight": 10,
-    "criteria": ["validCPE"],
-    "binary": true
-  },
-  "patchinfo": {
-    "weight": 10,
-    "criteria": ["patchRef"],
-    "binary": true
-  }
-}</pre>
-            </div>
-          </div>
-        </div>
-
-        <!-- Verification Instructions -->
-        <div class="tech-category" id="verification-instructions">
-          <h3>Verification Instructions for CNAs</h3>
-
-          <div class="tech-subsection">
-            <h4>How to Verify Your CVE Scoring:</h4>
-            <ol class="verification-steps">
-              <li><strong>Download your CVE JSON:</strong> Get the official CVE record from the CVE database</li>
-              <li><strong>Check field paths:</strong> Verify the exact schema paths listed above exist in your JSON</li>
-              <li><strong>Validate content:</strong> Ensure arrays are non-empty and contain valid data</li>
-              <li><strong>Test scoring logic:</strong> Apply the binary scoring rules to calculate expected points</li>
-              <li><strong>Compare results:</strong> Match against your CNA scorecard results</li>
-            </ol>
-          </div>
-
-          <div class="tech-subsection">
-            <h4>Common Issues and Solutions:</h4>
-            <div class="issue-solution">
-              <strong>Issue:</strong> Missing foundational completeness points<br>
-              <strong>Check:</strong> Ensure all three arrays (descriptions, affected, references) exist and are
-              non-empty
-            </div>
-            <div class="issue-solution">
-              <strong>Issue:</strong> Missing root cause analysis points<br>
-              <strong>Check:</strong> Verify CWE ID format is "CWE-[number]" and exists in official CWE database
-            </div>
-            <div class="issue-solution">
-              <strong>Issue:</strong> Missing severity context points<br>
-              <strong>Check:</strong> Ensure CVSS object contains valid vectorString field
-            </div>
-            <div class="issue-solution">
-              <strong>Issue:</strong> Missing software identification points<br>
-              <strong>Check:</strong> Verify at least one affected product has non-empty cpes array OR the
-              cpeApplicability field contains valid CPE match data with criteria strings
-            </div>
-            <div class="issue-solution">
-              <strong>Issue:</strong> Missing patch information points<br>
-              <strong>Check:</strong> Ensure at least one reference has "patch" in its tags array
-            </div>
-          </div>
-        </div>
-
-      </div>
-    </section>
-
-    <!-- Grading Tiers Section -->
-    <section class="grading-tiers-card card">
-      <h2>Grading Tiers</h2>
-      <p class="grading-intro">
-        Scores are calculated as a percentage of total possible points (100), then mapped to letter grades for easy
-        interpretation:
-      </p>
-      <div class="grading-table">
-        <div class="grade-row">
-          <span class="badge-grade badge-perfect">Perfect</span>
-          <span class="grade-percentage">100%</span>
-          <span class="grade-description">All essential data fields are complete and accurate</span>
-        </div>
-        <div class="grade-row">
-          <span class="badge-grade badge-great">Great</span>
-          <span class="grade-percentage">&gt;75%</span>
-          <span class="grade-description">Most critical information is provided with minor gaps</span>
-        </div>
-        <div class="grade-row">
-          <span class="badge-grade badge-good">Good</span>
-          <span class="grade-percentage">&gt;50%</span>
-          <span class="grade-description">Basic requirements met with room for improvement</span>
-        </div>
-        <div class="grade-row">
-          <span class="badge-grade badge-needs-work">Needs Work</span>
-          <span class="grade-percentage">&lt;50%</span>
-          <span class="grade-description">Significant gaps in essential vulnerability data</span>
-        </div>
-        <div class="grade-row">
-          <span class="badge-grade badge-missing">Missing Data</span>
-          <span class="grade-percentage">0%</span>
-          <span class="grade-description">No scoring data available for this CNA</span>
-        </div>
-      </div>
-    </section>
-
-    <!-- Performance Trends Section -->
-    <section class="scoring-categories-card card">
-      <h2>Performance Trends Analysis</h2>
-      <p class="categories-intro">
-        Beyond point-in-time scoring, the CNA Scorecard tracks performance trends over time using rolling 7-day averages
-        to identify patterns and improvements in vulnerability data quality.
-      </p>
-
-      <div class="category-detail">
-        <h3>Rolling 7-Day Averages</h3>
-        <p class="category-what"><strong>What it tracks:</strong> Daily average scores for each scoring category
-          calculated over sliding 7-day windows, updated daily for the past 6 months.</p>
-        <p class="category-why"><strong>Why it matters:</strong> Smooths out daily fluctuations to reveal genuine trends
-          in data quality improvement or decline. A single bad day doesn't define overall performance.</p>
-        <p class="category-how"><strong>How it works:</strong> Each day's score represents the average of the previous 7
-          days, creating a smooth trend line that highlights meaningful patterns over noise.</p>
-      </div>
-
-      <div class="category-detail">
-        <h3>Top Improving CNAs</h3>
-        <p class="category-what"><strong>What it identifies:</strong> CNAs showing the most significant improvement by
-          comparing their earliest versus most recent 7-day performance averages over a 6-month analysis period.</p>
-        <p class="category-why"><strong>Why it's valuable:</strong> Recognizes CNAs making genuine efforts to improve
-          their vulnerability reporting practices and helps identify best practices worth emulating.</p>
-        <p class="category-how"><strong>How it's calculated:</strong> Improvement score equals the difference between
-          the most recent 7-day average and the earliest 7-day average for each CNA with sufficient data.</p>
-      </div>
-
-      <div class="category-detail">
-        <h3>Trend Visualization</h3>
-        <p class="category-what"><strong>What it shows:</strong> Interactive line charts displaying rolling averages for
-          Root Cause Analysis (CWE), Severity & Impact (CVSS), Software Identification (CPE), and Patch Information
-          categories.</p>
-        <p class="category-why"><strong>Why separate charts:</strong> Each scoring category has different typical ranges
-          and improvement patterns, requiring dedicated visualization for meaningful analysis.</p>
-        <p class="category-how"><strong>How it adapts:</strong> Charts use auto-scaling Y-axes that adjust to actual
-          data ranges, ensuring trend visibility whether scores are high-performing or need improvement.</p>
-      </div>
-
-      <div class="centered-cta">
-        <a href="trends.html" class="cta-button secondary">View Performance Trends Dashboard</a>
-      </div>
-    </section>
-
-    <!-- CNA Badges Section -->
-    <section class="methodology-notes-card card" style="text-align: left;">
-      <h2 style="text-align: left;">CNA Scorecard Badges</h2>
-      <p>
-        CNAs can display their CNA Scorecard rating on their website, README, or documentation using
-        automatically-generated SVG badges.
-        Badges are updated every time the pipeline runs, so they always reflect the latest score and rank.
-      </p>
-      <div
-        style="margin: 1.5rem 0; padding: 1.5rem; background: #f5f5f5; border-radius: 8px; border-left: 4px solid var(--primary-color);">
-        <h3 style="margin-top: 0; color: var(--primary-color);">Three Badge Styles Available:</h3>
-        <div style="line-height: 1.8;">
-          <div><strong>Rank Badge</strong> - Shows CNA rank (e.g., #1, #5, #42)</div>
-          <div><strong>Score Badge</strong> - Shows percentage score (e.g., 95.0%)</div>
-          <div><strong>Combined Badge</strong> - Shows both rank and score (e.g., #1 - 95.0%)</div>
-        </div>
-        <p style="margin-bottom: 0;">
-          <strong>🎯 Get Your Badge:</strong>
-          <a href="badges.html" style="color: var(--primary-color); font-weight: 600;">Visit the Badge Generator →</a>
-        </p>
-      </div>
-      <p style="color: var(--text-secondary); font-style: italic; text-align: left;">
-        Badges are color-coded based on score (green for 90-100%, blue for 70-79%, yellow for 60-69%, red below 60%)
-        to provide quick visual feedback on performance.
-      </p>
-    </section>
-
-    <!-- Transparency Section -->
-    <section class="methodology-notes-card card">
-      <h2>Transparency & Open Standards</h2>
-      <p class="transparency-statement">
-        The CNA Scorecard is committed to complete transparency in methodology. Every aspect of the scoring system is
-        based on
-        established industry standards and open specifications. The scoring logic is fully documented and publicly
-        available, ensuring that CNAs and security professionals can understand exactly how scores are calculated.
-      </p>
-      <p class="open-source-note">
-        All scoring algorithms, data processing methods, and evaluation criteria are open source and available for
-        review in the <a href="https://github.com/jgamblin/CNAScoreCard" target="_blank">project repository</a>.
-        Feedback and contributions from the security community are welcome to continuously improve the methodology.
-      </p>
-    </section>
-  </main>
-  <footer class="footer">
-    <div class="footer-main">
-      <div class="footer-brand">
-        <img src="assets/logo.svg" alt="CNA Scorecard Logo" class="footer-logo">
-        <span class="footer-title">CNA Scorecard</span>
-      </div>
-      <div class="footer-links">
-        <a href="https://github.com/CVEDB/cvedb.github.io" target="_blank">GitHub</a>
-        <a href="https://cvedb.github.io" target="_blank">CVEDB</a>
-        <a href="https://patchthis.app" target="_blank">PatchThis</a>
-        <a href="https://cveforecast.org" target="_blank">CVEForecast</a>
-        <a href="https://cvedb.github.io" target="_blank">CVEDB</a>
-      </div>
-    </div>
-    <div class="footer-meta">&copy; 2025 CVEDB. All rights reserved.</div>
-  </footer>
-  <script>
-    // Utility function for date formatting (same as homepage)
-    function formatDateRange(dateRangeString) {
-      try {
-        const parts = dateRangeString.split(' to ');
-        if (parts.length !== 2) return dateRangeString;
-
-        // Parse as UTC to avoid timezone conversion issues
-        const startDate = new Date(parts[0] + 'T12:00:00Z');
-        const endDate = new Date(parts[1] + 'T12:00:00Z');
-
-        const formatDate = (date) => {
-          const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
-            'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-
-          const day = date.getDate();
-          const month = months[date.getMonth()];
-          const year = date.getFullYear();
-
-          // Add ordinal suffix (st, nd, rd, th)
-          const getOrdinal = (n) => {
-            const s = ['th', 'st', 'nd', 'rd'];
-            const v = n % 100;
-            return n + (s[(v - 20) % 10] || s[v] || s[0]);
-          };
-
-          return `${month} ${getOrdinal(day)}, ${year}`;
-        };
-
-        return `${formatDate(startDate)} – ${formatDate(endDate)}`;
-      } catch (error) {
-        console.error('Error formatting date range:', error);
-        return dateRangeString;
-      }
-    }
-
-    // Load and display current analysis period
-    async function loadAnalysisPeriod() {
-      try {
-        const response = await fetch('./data/completeness_summary.json');
-        const data = await response.json();
-
-        const rawPeriod = data.analysis_period || 'Not available';
-        const formattedPeriod = rawPeriod !== 'Not available' ? formatDateRange(rawPeriod) : rawPeriod;
-
-        document.getElementById('currentPeriod').textContent = formattedPeriod;
-      } catch (error) {
-        console.error('Error loading analysis period:', error);
-        document.getElementById('currentPeriod').textContent = 'Unable to load current period';
-      }
-    }
-
-    // Load the analysis period when the page loads
-    document.addEventListener('DOMContentLoaded', loadAnalysisPeriod);
-
-    // Technical details toggle functionality
-    document.addEventListener('DOMContentLoaded', function () {
-      const toggleButton = document.getElementById('toggleTechnicalDetails');
-      const technicalDetails = document.getElementById('technicalDetails');
-
-      if (toggleButton && technicalDetails) {
-        toggleButton.addEventListener('click', function () {
-          const isVisible = technicalDetails.style.display !== 'none';
-
-          if (isVisible) {
-            // Hide technical details
-            technicalDetails.style.display = 'none';
-            toggleButton.textContent = 'Show Technical Details';
-            toggleButton.classList.remove('expanded');
-          } else {
-            // Show technical details
-            technicalDetails.style.display = 'block';
-            toggleButton.textContent = 'Hide Technical Details';
-            toggleButton.classList.add('expanded');
-          }
-        });
-      }
-    });
-  </script>
-  <script src="shared/mobile-nav.js"></script>
-</body>
-
-</html>
\ No newline at end of file
diff --git a/templates/cna/trends.html b/templates/cna/trends.html
deleted file mode 100644
index a2fc8846b86..00000000000
--- a/templates/cna/trends.html
+++ /dev/null
@@ -1,759 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-  <!-- Google tag (gtag.js) -->
-  <script async src="https://www.googletagmanager.com/gtag/js?id=G-MQJ07VQQQN"></script>
-  <script>
-    window.dataLayer = window.dataLayer || [];
-    function gtag() { dataLayer.push(arguments); }
-    gtag('js', new Date());
-
-    gtag('config', 'G-MQJ07VQQQN');
-  </script>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>CNA Scorecard: Performance Trends</title>
-  <link rel="icon" type="image/svg+xml" href="assets/logo.svg">
-  <link rel="icon" type="image/png" href="assets/logo.svg">
-  <link rel="stylesheet" href="assets/theme.css">
-  <link rel="stylesheet" href="shared/shared.css">
-  <script src="https://cdn.jsdelivr.net/npm/chart.js" async></script>
-  <style>
-    .container {
-      max-width: 1200px;
-      margin: 0 auto;
-      padding: 2rem 1rem;
-    }
-
-    .page-header {
-      background-color: var(--card-bg);
-      border-radius: 12px;
-      padding: 2rem;
-      margin-bottom: 2rem;
-      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
-      text-align: center;
-    }
-
-    .page-title {
-      font-size: 2.5rem;
-      color: var(--primary-color);
-      margin-bottom: 1rem;
-      font-weight: 600;
-    }
-
-    .page-subtitle {
-      color: var(--text-secondary);
-      font-size: 1.1rem;
-      margin: 0 auto 1rem;
-      line-height: 1.6;
-      max-width: 800px;
-    }
-
-    .section {
-      background-color: var(--card-bg);
-      border-radius: 12px;
-      padding: 2rem;
-      margin-bottom: 2rem;
-      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
-    }
-
-    .section-title {
-      font-size: 1.75rem;
-      font-weight: 600;
-      margin-bottom: 1.5rem;
-      color: var(--primary-color);
-    }
-
-    .charts-grid {
-      display: grid;
-      grid-template-columns: 1fr;
-      gap: 2rem;
-      margin-bottom: 2rem;
-    }
-
-    .chart-card {
-      background: var(--card-bg);
-      border: 1px solid var(--border-color);
-      border-radius: 8px;
-      padding: 1.5rem;
-      position: relative;
-    }
-
-    .chart-title {
-      font-size: 1.25rem;
-      font-weight: 600;
-      color: var(--text-primary);
-      margin-bottom: 1rem;
-      text-align: center;
-    }
-
-    .chart-container {
-      position: relative;
-      height: 300px;
-      width: 100%;
-    }
-
-    .loading-spinner {
-      display: flex;
-      justify-content: center;
-      align-items: center;
-      height: 300px;
-      color: var(--text-secondary);
-    }
-
-    .loading-spinner::after {
-      content: '';
-      width: 40px;
-      height: 40px;
-      border: 4px solid var(--border-color);
-      border-top: 4px solid var(--primary-color);
-      border-radius: 50%;
-      animation: spin 1s linear infinite;
-      margin-left: 1rem;
-    }
-
-    @keyframes spin {
-      0% {
-        transform: rotate(0deg);
-      }
-
-      100% {
-        transform: rotate(360deg);
-      }
-    }
-
-    .improvers-section {
-      background: var(--card-bg);
-      border-radius: 12px;
-      padding: 2rem;
-      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.05);
-      margin-top: 2.5rem;
-    }
-
-    .card-box {
-      max-width: 1100px;
-      margin: 2rem auto 2rem auto;
-      padding: 2rem 2.5rem;
-      background: #fff;
-      border-radius: 18px;
-      box-shadow: 0 2px 16px rgba(0, 0, 0, 0.08);
-    }
-
-    .cna-table,
-    .improvers-table {
-      width: 100%;
-      border-collapse: collapse;
-      background: #fff;
-      border-radius: 12px;
-      overflow: hidden;
-      box-shadow: 0 2px 8px rgba(0, 0, 0, 0.05);
-      border: 1px solid var(--border-color);
-    }
-
-    .cna-table th,
-    .improvers-table th {
-      background-color: #f7fafc;
-      font-weight: 700;
-      color: var(--text-primary);
-      border-bottom: 2px solid var(--border-color);
-      font-size: 1.08em;
-    }
-
-    .cna-table td,
-    .improvers-table td {
-      padding: 0.75rem 1rem;
-      border-bottom: 1px solid var(--border-color);
-      font-size: 1.05em;
-    }
-
-    .cna-table tr:nth-child(even),
-    .improvers-table tr:nth-child(even) {
-      background: #f7fafc;
-    }
-
-    .cna-table tr:hover,
-    .improvers-table tr:hover {
-      background: #e2e8f0;
-    }
-
-    .cna-name {
-      font-weight: 700;
-      color: #0074cc;
-      text-decoration: none;
-      font-size: 1.08em;
-      transition: color 0.2s;
-    }
-
-    .cna-name:hover {
-      color: #1a365d;
-      text-decoration: underline;
-    }
-
-    .cna-sub {
-      display: block;
-      font-size: 0.98em;
-      color: #666;
-      font-weight: 400;
-      margin-top: 2px;
-    }
-
-    .improvement-positive {
-      color: var(--success-color);
-      font-weight: 600;
-    }
-
-    .improvement-negative {
-      color: var(--danger-color);
-      font-weight: 600;
-    }
-
-    .improvement-neutral {
-      color: var(--text-secondary);
-    }
-
-    .category-improvement {
-      font-size: 0.98em;
-      color: var(--text-secondary);
-    }
-
-    @media (max-width: 768px) {
-      .page-title {
-        font-size: 1.5rem;
-      }
-
-      .page-subtitle {
-        font-size: 0.95rem;
-      }
-
-      .section {
-        padding: 1rem;
-      }
-
-      .section-title {
-        font-size: 1.25rem;
-      }
-
-      .charts-grid {
-        grid-template-columns: 1fr;
-        gap: 1rem;
-      }
-
-      .chart-card {
-        padding: 0.75rem;
-      }
-
-      .chart-title {
-        font-size: 1rem;
-      }
-
-      .chart-container {
-        height: 250px;
-      }
-
-      .improvers-table {
-        font-size: 0.85rem;
-      }
-
-      .improvers-table th,
-      .improvers-table td {
-        padding: 0.5rem 0.35rem;
-      }
-    }
-
-    @media (max-width: 480px) {
-      .chart-container {
-        height: 200px;
-      }
-
-      .page-title {
-        font-size: 1.25rem;
-      }
-    }
-  </style>
-</head>
-
-<body>
-  <!-- Skip Link for Accessibility -->
-  <a href="#main-content" class="skip-link">Skip to main content</a>
-
-  <!-- Navigation Bar -->
-  <nav class="navbar" role="navigation" aria-label="Main Navigation">
-    <img src="assets/logo.svg" alt="CNA Scorecard Logo" class="navbar-logo">
-    <div class="navbar-links">
-      <a href="index.html">Home</a>
-      <a href="cna/index.html">CNAs</a>
-      <a href="completeness/index.html">Record Completeness</a>
-      <a href="trends.html" class="active">Performance Trends</a>
-      <a href="scoring.html">Methodology</a>
-    </div>
-  </nav>
-
-  <main class="container" id="main-content">
-    <!-- Page Header -->
-    <section class="page-header">
-      <h1 class="page-title">CNA Scorecard: Performance Trends</h1>
-      <p class="page-subtitle">
-        Track vulnerability data quality trends over time with rolling 7-day averages.
-        Identify patterns in data completeness and discover which CNAs are leading improvements
-        in vulnerability reporting standards.
-      </p>
-    </section>
-
-    <!-- Trends Over Time Section -->
-    <section class="section">
-      <h2 class="section-title">Data Quality Trends Over Time</h2>
-      <div class="charts-grid" id="chartsGrid">
-        <div class="chart-card">
-          <h3 class="chart-title">Root Cause Analysis (CWE)</h3>
-          <div class="chart-container">
-            <div class="loading-spinner">Loading chart data</div>
-            <canvas id="cweChart" style="display: none;"></canvas>
-          </div>
-        </div>
-
-        <div class="chart-card">
-          <h3 class="chart-title">Severity & Impact (CVSS)</h3>
-          <div class="chart-container">
-            <div class="loading-spinner">Loading chart data</div>
-            <canvas id="cvssChart" style="display: none;"></canvas>
-          </div>
-        </div>
-
-        <div class="chart-card">
-          <h3 class="chart-title">Software Identification (CPE)</h3>
-          <div class="chart-container">
-            <div class="loading-spinner">Loading chart data</div>
-            <canvas id="cpeChart" style="display: none;"></canvas>
-          </div>
-        </div>
-
-        <div class="chart-card">
-          <h3 class="chart-title">Patch Information</h3>
-          <div class="chart-container">
-            <div class="loading-spinner">Loading chart data</div>
-            <canvas id="patchChart" style="display: none;"></canvas>
-          </div>
-        </div>
-      </div>
-
-      <div class="data-info" id="dataInfo">
-        Loading analysis period information...
-      </div>
-    </section>
-
-    <!-- Top Improvers Section -->
-    <section class="improvers-section">
-      <div class="card-box">
-        <h2
-          style="font-size:2.1rem;font-weight:800;letter-spacing:-1px;margin-bottom:1.2rem;color:var(--primary-color);text-align:center;">
-          Top Improving CNAs</h2>
-        <p style="text-align:center;color:var(--text-secondary);margin-bottom:1.5rem;">CNAs showing the most significant
-          improvement in data quality over the analysis period, comparing their most recent performance with their
-          earliest data points.</p>
-        <div id="improvorsTableContainer">
-          <div class="loading-spinner">Loading improvement data</div>
-        </div>
-      </div>
-    </section>
-  </main>
-
-  <script type="module">
-    // Performance Trends Dashboard JavaScript
-
-    let trendsData = null;
-    let improvorsData = null;
-    let charts = {};
-
-    // Initialize the dashboard
-    async function initializeDashboard() {
-      try {
-        await Promise.all([
-          loadTrendsData(),
-          loadImprovorsData()
-        ]);
-
-        if (trendsData) {
-          updateDataInfo();
-          createTrendCharts();
-        }
-
-        if (improvorsData) {
-          renderImprovorsTable();
-        }
-
-      } catch (error) {
-        console.error('Error initializing Performance Trends dashboard:', error);
-        showErrorMessage();
-      }
-    }
-
-    // Load trends data from API
-    async function loadTrendsData() {
-      try {
-        const response = await fetch('./data/performance_trends.json');
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        trendsData = await response.json();
-        console.log('Loaded trends data:', trendsData);
-      } catch (error) {
-        console.error('Error loading trends data:', error);
-        trendsData = null;
-      }
-    }
-
-    // Load top improvers data from API  
-    async function loadImprovorsData() {
-      try {
-        const response = await fetch('./data/top_improvers.json');
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        improvorsData = await response.json();
-        console.log('Loaded improvers data:', improvorsData);
-      } catch (error) {
-        console.error('Error loading improvers data:', error);
-        improvorsData = null;
-      }
-    }
-
-    // Update data info section
-    function updateDataInfo() {
-      const dataInfoElement = document.getElementById('dataInfo');
-      if (trendsData && trendsData.analysis_period) {
-        const { start_date, end_date, total_days } = trendsData.analysis_period;
-        dataInfoElement.innerHTML = `
-          Analysis Period: ${formatDate(start_date)} to ${formatDate(end_date)} (${total_days} days)
-          <br>Rolling 7-day averages updated daily
-        `;
-      } else {
-        dataInfoElement.innerHTML = 'Analysis period information unavailable';
-      }
-    }
-
-    // Create all trend charts
-    function createTrendCharts() {
-      if (!trendsData || !trendsData.rolling_trends) {
-        showChartsError();
-        return;
-      }
-
-      const categories = [
-        { key: 'root_cause_analysis', chartId: 'cweChart', title: 'Root Cause Analysis', color: '#FF6384' },
-        { key: 'severity_and_impact', chartId: 'cvssChart', title: 'Severity & Impact', color: '#36A2EB' },
-        { key: 'software_identification', chartId: 'cpeChart', title: 'Software Identification', color: '#FFCE56' },
-        { key: 'patch_information', chartId: 'patchChart', title: 'Patch Information', color: '#4BC0C0' }
-      ];
-
-      categories.forEach(category => {
-        createTrendChart(category);
-      });
-    }
-
-    // Create individual trend chart
-    function createTrendChart(category) {
-      const canvas = document.getElementById(category.chartId);
-      const spinner = canvas.parentElement.querySelector('.loading-spinner');
-
-      try {
-        // Prepare data
-        const chartData = prepareTrendData(category.key);
-
-        if (!chartData || chartData.labels.length === 0) {
-          showChartNoData(canvas, spinner);
-          return;
-        }
-
-        // Calculate auto-scaling for Y-axis
-        const dataValues = chartData.data.filter(val => val !== null && val !== undefined);
-        const minValue = Math.min(...dataValues);
-        const maxValue = Math.max(...dataValues);
-
-        // Add padding around the data range (10% buffer)
-        const range = maxValue - minValue;
-        const buffer = Math.max(range * 0.1, 2); // At least 2% buffer
-        const rawYMin = Math.max(0, minValue - buffer);
-        const rawYMax = maxValue + buffer;
-
-        // Round yMin down and yMax up to nearest 5
-        const yMin = Math.floor(rawYMin / 5) * 5;
-        const yMax = Math.ceil(rawYMax / 5) * 5;
-
-        // Hide spinner and show canvas
-        spinner.style.display = 'none';
-        canvas.style.display = 'block';
-
-        // Create chart
-        const ctx = canvas.getContext('2d');
-        charts[category.chartId] = new Chart(ctx, {
-          type: 'line',
-          data: {
-            labels: chartData.labels,
-            datasets: [{
-              label: `${category.title} (%)`,
-              data: chartData.data,
-              borderColor: category.color,
-              backgroundColor: category.color + '20',
-              borderWidth: 2,
-              fill: true,
-              tension: 0.1,
-              pointRadius: 3,
-              pointHoverRadius: 5
-            }]
-          },
-          options: {
-            responsive: true,
-            maintainAspectRatio: false,
-            plugins: {
-              legend: {
-                display: false
-              },
-              tooltip: {
-                mode: 'index',
-                intersect: false,
-                callbacks: {
-                  title: function (context) {
-                    return formatDate(context[0].label);
-                  },
-                  label: function (context) {
-                    return `${context.parsed.y?.toFixed(1) || 'N/A'}%`;
-                  }
-                }
-              }
-            },
-            scales: {
-              x: {
-                display: true,
-                title: {
-                  display: true,
-                  text: 'Date'
-                },
-                ticks: {
-                  maxTicksLimit: 8,
-                  callback: function (value, index, values) {
-                    const date = this.getLabelForValue(value);
-                    return formatDateShort(date);
-                  }
-                }
-              },
-              y: {
-                display: true,
-                title: {
-                  display: true,
-                  text: 'Percentage (%)'
-                },
-                min: yMin,
-                max: yMax,
-                ticks: {
-                  callback: function (value) {
-                    return Math.round(value) + '%';
-                  },
-                  stepSize: 5
-                }
-              }
-            },
-            interaction: {
-              mode: 'index',
-              intersect: false
-            }
-          }
-        });
-
-      } catch (error) {
-        console.error(`Error creating ${category.title} chart:`, error);
-        showChartError(canvas, spinner);
-      }
-    }
-
-    // Prepare trend data for chart
-    function prepareTrendData(categoryKey) {
-      if (!trendsData || !trendsData.rolling_trends) {
-        return null;
-      }
-
-      const labels = [];
-      const data = [];
-
-      // Sort dates and extract data
-      const sortedDates = Object.keys(trendsData.rolling_trends).sort();
-
-      for (const date of sortedDates) {
-        const dayData = trendsData.rolling_trends[date];
-        if (dayData && dayData[categoryKey] !== null && dayData[categoryKey] !== undefined) {
-          labels.push(date);
-          data.push(dayData[categoryKey]);
-        }
-      }
-
-      return { labels, data };
-    }
-
-    // Render top improvers table
-    function renderImprovorsTable() {
-      const container = document.getElementById('improvorsTableContainer');
-
-      if (!improvorsData || !improvorsData.top_improvers || improvorsData.top_improvers.length === 0) {
-        container.innerHTML = '<div class="no-data-message">No improvement data available</div>';
-        return;
-      }
-
-      const tableHTML = `
-        <table class="improvers-table">
-          <thead>
-            <tr>
-              <th>Rank</th>
-              <th>CNA</th>
-              <th>Total Improvement</th>
-              <th>CVEs Analyzed</th>
-              <th>Best Category</th>
-            </tr>
-          </thead>
-          <tbody>
-            ${improvorsData.top_improvers.map((cna, index) => {
-        const bestCategory = getBestImprovementCategory(cna.category_improvements);
-        return `
-                <tr>
-                  <td><strong>#${index + 1}</strong></td>
-                  <td><a href="https://cvedb.github.io/cna/cna-detail.html?shortName=${encodeURIComponent(cna.cna_name)}" class="cna-name">${cna.cna_name}</a><br><span class="cna-sub">${cna.cna_full_name || ''}</span></td>
-                  <td>${formatImprovement(cna.total_improvement)}</td>
-                  <td>${cna.total_cves_analyzed}</td>
-                  <td class="category-improvement">${bestCategory}</td>
-                </tr>
-              `;
-      }).join('')}
-          </tbody>
-        </table>
-      `;
-
-      container.innerHTML = tableHTML;
-    }
-
-    // Get best improvement category for a CNA
-    function getBestImprovementCategory(categoryImprovements) {
-      let bestCategory = 'None';
-      let bestImprovement = -Infinity;
-
-      const categoryNames = {
-        'root_cause_analysis': 'Root Cause Analysis',
-        'severity_and_impact': 'Severity & Impact',
-        'software_identification': 'Software Identification',
-        'patch_information': 'Patch Information'
-      };
-
-      for (const [key, data] of Object.entries(categoryImprovements)) {
-        if (data.improvement > bestImprovement) {
-          bestImprovement = data.improvement;
-          bestCategory = `${categoryNames[key]} (+${data.improvement.toFixed(1)}%)`;
-        }
-      }
-
-      return bestCategory;
-    }
-
-    // Format improvement value
-    function formatImprovement(improvement) {
-      const formatted = improvement.toFixed(1);
-      if (improvement > 0) {
-        return `<span class="improvement-positive">+${formatted}%</span>`;
-      } else if (improvement < 0) {
-        return `<span class="improvement-negative">${formatted}%</span>`;
-      } else {
-        return `<span class="improvement-neutral">${formatted}%</span>`;
-      }
-    }
-
-    // Utility functions
-    function formatDate(dateString) {
-      try {
-        const date = new Date(dateString);
-        return date.toLocaleDateString('en-US', {
-          year: 'numeric',
-          month: 'short',
-          day: 'numeric'
-        });
-      } catch {
-        return dateString;
-      }
-    }
-
-    function formatDateShort(dateString) {
-      try {
-        const date = new Date(dateString);
-        return date.toLocaleDateString('en-US', {
-          month: 'short',
-          day: 'numeric'
-        });
-      } catch {
-        return dateString;
-      }
-    }
-
-    function showChartsError() {
-      const chartCards = document.querySelectorAll('.chart-card');
-      chartCards.forEach(card => {
-        const spinner = card.querySelector('.loading-spinner');
-        const canvas = card.querySelector('canvas');
-
-        spinner.style.display = 'none';
-        canvas.style.display = 'none';
-
-        const errorDiv = document.createElement('div');
-        errorDiv.className = 'no-data-message';
-        errorDiv.textContent = 'Error loading chart data';
-        card.querySelector('.chart-container').appendChild(errorDiv);
-      });
-    }
-
-    function showChartError(canvas, spinner) {
-      spinner.style.display = 'none';
-      canvas.style.display = 'none';
-
-      const errorDiv = document.createElement('div');
-      errorDiv.className = 'no-data-message';
-      errorDiv.textContent = 'Error loading chart data';
-      canvas.parentElement.appendChild(errorDiv);
-    }
-
-    function showChartNoData(canvas, spinner) {
-      spinner.style.display = 'none';
-      canvas.style.display = 'none';
-
-      const noDataDiv = document.createElement('div');
-      noDataDiv.className = 'no-data-message';
-      noDataDiv.textContent = 'No data available for this period';
-      canvas.parentElement.appendChild(noDataDiv);
-    }
-
-    function showErrorMessage() {
-      document.getElementById('chartsGrid').innerHTML =
-        '<div class="no-data-message">Error loading dashboard data. Please try refreshing the page.</div>';
-      document.getElementById('improvorsTableContainer').innerHTML =
-        '<div class="no-data-message">Error loading improvement data.</div>';
-    }
-
-    // Initialize dashboard when DOM is ready
-    document.addEventListener('DOMContentLoaded', initializeDashboard);
-  </script>
-
-  <!-- Footer -->
-  <footer class="footer">
-    <div class="footer-main">
-      <div class="footer-brand">
-        <img src="assets/logo.svg" alt="CNA Scorecard Logo" class="footer-logo">
-        <span class="footer-title">CNA Scorecard</span>
-      </div>
-      <div class="footer-links">
-        <a href="https://github.com/CVEDB/cvedb.github.io" target="_blank">GitHub</a>
-        <a href="https://cvedb.github.io" target="_blank">CVEDB</a>
-        <a href="https://patchthis.app" target="_blank">PatchThis</a>
-        <a href="https://cveforecast.org" target="_blank">CVEForecast</a>
-        <a href="https://cvedb.github.io" target="_blank">CVEDB</a>
-      </div>
-    </div>
-    <div class="footer-meta">&copy; 2025 CVEDB. All rights reserved.</div>
-  </footer>
-  <script src="shared/mobile-nav.js"></script>
-</body>
-
-</html>
\ No newline at end of file
diff --git a/templates/cpe.html b/templates/cpe.html
index d151c7149f0..35aba599dcf 100644
--- a/templates/cpe.html
+++ b/templates/cpe.html
@@ -1,686 +1,81 @@
 {% extends "base.html" %}
-
-{% block title %}CPE Analysis - CVEDB{% endblock %}
+{% set nav = 'cpe' %}
+{% block title %}CVEs by product &mdash; CVEDB{% endblock %}
+{% block description %}How many CVEs affect each vendor and product, counted from CPE records.{% endblock %}
 
 {% block content %}
-<!-- Hero Section -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">CPE Analysis Dashboard</h1>
-    <small class="text-muted d-block mb-3" id="pageSubtitle">
-        Showing comprehensive analysis across all years (1999-2025)
-    </small>
-
-    <!-- Data Mode Toggle -->
-    <div class="d-flex justify-content-center mb-3">
-        <button type="button" id="dataToggleBtn" onclick="toggleDataMode()" style="
-            color: var(--color-text-secondary);
-            font-weight: var(--font-weight-medium);
-            padding: var(--spacing-sm) var(--spacing-md);
-            border-radius: var(--border-radius);
-            transition: all 0.15s ease-in-out;
-            background: none;
-            border: 2px solid var(--color-border);
-            cursor: pointer;
-            font-size: inherit;
-        " onmouseover="this.style.color='var(--color-accent)'; this.style.backgroundColor='rgba(13, 110, 253, 0.1)'; this.style.borderColor='var(--color-accent)'"
-            onmouseout="this.style.color='var(--color-text-secondary)'; this.style.backgroundColor='transparent'; this.style.borderColor='var(--color-border)'">
-            <span id="toggleText">Switch to 2025 Only</span>
-        </button>
-    </div>
-</div>
-
-<!-- Statistics Cards -->
-<div class="stats-grid mb-4">
-    <div class="stat-card">
-        <div class="stat-number" id="totalCpes">Loading...</div>
-        <div class="stat-label">Total Unique CPEs</div>
-        <small class="text-muted" style="font-size: 0.75rem;">📊 Platform identifiers</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="totalCvesWithCpes">Loading...</div>
-        <div class="stat-label">CVEs with CPEs</div>
-        <small class="text-muted" style="font-size: 0.75rem;">🔗 Linked vulnerabilities</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="avgCpesPerCve">Loading...</div>
-        <div class="stat-label">Avg CPEs per CVE</div>
-        <small class="text-muted" style="font-size: 0.75rem;">📈 Platform coverage</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="totalVendors">Loading...</div>
-        <div class="stat-label">Unique Vendors</div>
-        <small class="text-muted" style="font-size: 0.75rem;">🏢 Organizations</small>
-    </div>
-</div>
-
-<!-- CPE Analysis Overview -->
-<div class="row mb-4">
-    <div class="col-lg-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">CPE Type Distribution</h3>
-                <small class="text-muted">Platform types breakdown</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="typeChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
+<div class="ph"><h1>CVEs by product</h1><span class="note">from CPE records</span></div>
+<p class="lede">A CVE can list many affected products, so these counts sum to more than the
+number of CVEs. A product's count is how many CVEs name it, not how many bugs it has.</p>
 
-    <div class="col-lg-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">Top Vendors by CPE Count</h3>
-                <small class="text-muted">Organizations with most CPE entries</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="vendorChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- Top CPEs Table -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">Top CPEs by Frequency</h3>
-        <small class="text-muted">Most commonly referenced platforms</small>
-    </div>
-    <div class="card-body py-3">
-        <div class="table-responsive">
-            <table class="table table-hover" id="topCpesTable">
-                <thead>
-                    <tr>
-                        <th style="cursor: pointer;" onclick="sortTable('topCpesTable', 0)">Rank</th>
-                        <th style="cursor: pointer;" onclick="sortTable('topCpesTable', 1)">CPE String</th>
-                        <th style="cursor: pointer;" onclick="sortTable('topCpesTable', 2)">Count</th>
-                        <th style="cursor: pointer;" onclick="sortTable('topCpesTable', 3)">Vendor</th>
-                        <th style="cursor: pointer;" onclick="sortTable('topCpesTable', 4)">Product</th>
-                        <th style="cursor: pointer;" onclick="sortTable('topCpesTable', 5)">Type</th>
-                    </tr>
-                </thead>
-                <tbody id="topCpesTableBody">
-                    <tr>
-                        <td colspan="6" class="text-center">Loading...</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-    </div>
-</div>
+<div class="grid" id="tiles"></div>
 
-<!-- CVEs with Most CPEs Table -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">CVEs with Most CPEs</h3>
-        <small class="text-muted">Vulnerabilities affecting multiple platforms</small>
-    </div>
-    <div class="card-body py-3">
-        <div class="table-responsive">
-            <table class="table table-hover" id="topCvesTable">
-                <thead>
-                    <tr>
-                        <th style="cursor: pointer;" onclick="sortTable('topCvesTable', 0)">Rank</th>
-                        <th style="cursor: pointer;" onclick="sortTable('topCvesTable', 1)">CVE ID</th>
-                        <th style="cursor: pointer;" onclick="sortTable('topCvesTable', 2)">CPE Count</th>
-                        <th style="cursor: pointer;" onclick="sortTable('topCvesTable', 3)">Year</th>
-                    </tr>
-                </thead>
-                <tbody id="topCvesTableBody">
-                    <tr>
-                        <td colspan="5" class="text-center">Loading...</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-    </div>
-</div>
-
-<!-- Smart Insights Panel -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">🔍 CPE Intelligence Insights</h3>
-    </div>
-    <div class="card-body py-3">
-        <div class="row" id="cpeInsights">
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">🎯</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Most Targeted Platform</div>
-                        <div class="insight-text" id="topPlatformInsight">Loading...</div>
-                    </div>
-                </div>
-            </div>
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">🏢</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Leading Vendor</div>
-                        <div class="insight-text" id="topVendorInsight">Loading...</div>
-                    </div>
-                </div>
-            </div>
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">📊</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Platform Coverage</div>
-                        <div class="insight-text" id="coverageInsight">Loading...</div>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-
-
-<!-- Export and Share Panel -->
-<div class="card mb-3">
-    <div class="card-header py-2">
-        <h2 class="card-title mb-0" style="font-size: 1.1rem;">📤 Export & Share</h2>
-    </div>
-    <div class="card-body py-3">
-        <div class="export-buttons">
-            <button class="btn btn-primary btn-sm" onclick="exportCpeCSV()">📊 Export CSV</button>
-            <button class="btn btn-primary btn-sm" onclick="exportCpeJSON()">📋 Export JSON</button>
-            <button class="btn btn-secondary btn-sm" onclick="generatePermalink()">🔗 Share Link</button>
-            <button class="btn btn-secondary btn-sm" onclick="window.print()">🖨️ Print Report</button>
-        </div>
-        <div class="permalink-result mt-2" id="permalinkResult" style="display: none;">
-            <input type="text" class="form-control" id="permalinkInput" readonly>
-            <button class="btn btn-outline-primary btn-sm mt-1" onclick="copyPermalink()">Copy Link</button>
-        </div>
-    </div>
+<h2>Vendors</h2>
+<div class="cols c2">
+  <div class="panel"><div class="panel-h">Most-named vendors</div><div class="rows" id="vendors"></div></div>
+  <div class="panel"><div class="panel-h">Most-named products</div><div class="rows" id="products"></div></div>
 </div>
 
+<h2>Platform type</h2>
+<div class="panel"><div class="panel-b"><div id="types"></div></div></div>
 
+<h2>Most-referenced CPE entries <span class="side">one row per CPE string, not per product</span></h2>
+<div class="panel"><div id="cpe-table"></div></div>
 
+<h2>CVEs naming the most products</h2>
+<div class="panel"><div class="rows" id="widest"></div></div>
 {% endblock %}
 
 {% block scripts %}
-<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
 <script>
-    // Global variables
-    let cpeData = null;
-    let currentYearCpeData = null;
-    let isShowingCurrentYear = false;
-
-    // Load data on page load
-    document.addEventListener('DOMContentLoaded', function () {
-        loadCpeData();
-        updatePermalink();
-    });
-
-    // Load CPE data
-    async function loadCpeData() {
-        try {
-            // Load comprehensive data
-            const response = await fetch('data/cpe_analysis.json');
-
-            if (!response.ok) {
-                const errorText = await response.text().catch(() => 'Unable to read error text');
-                throw new Error(`Failed to load comprehensive CPE data: ${response.status} ${response.statusText}. Response: ${errorText}`);
-            }
-
-            const comprehensiveData = await response.json();
-
-            // Validate comprehensive data structure
-            if (!comprehensiveData || typeof comprehensiveData !== 'object') {
-                throw new Error('Invalid comprehensive CPE data structure');
-            }
-
-            cpeData = comprehensiveData;
-
-            // Load current year data
-            try {
-                const currentResponse = await fetch('data/cpe_analysis_current_year.json');
-                if (currentResponse.ok) {
-                    const currentData = await currentResponse.json();
-                    if (currentData && typeof currentData === 'object') {
-                        currentYearCpeData = currentData;
-                    } else {
-                        console.warn('Invalid current year CPE data structure');
-                    }
-                } else {
-                    console.warn('Current year CPE data not available:', currentResponse.status);
-                }
-            } catch (e) {
-                console.warn('Error loading current year CPE data:', e);
-            }
-
-            // Initialize display with validation
-            if (cpeData || currentYearCpeData) {
-                updateDisplay();
-            } else {
-                throw new Error('No valid CPE data loaded');
-            }
-
-        } catch (error) {
-            console.error('Error loading CPE data:');
-            console.error('Error message:', error.message);
-            console.error('Error stack:', error.stack);
-            console.error('Full error object:', error);
-
-            // Try to provide more specific error information
-            if (error.name) console.error('Error name:', error.name);
-            if (error.cause) console.error('Error cause:', error.cause);
-
-            showErrorState();
-        }
-    }
-
-    // Update display based on current mode
-    function updateDisplay() {
-        let data;
-
-        // Improved data selection logic - use any available data on initial load
-        if (isShowingCurrentYear && currentYearCpeData) {
-            data = currentYearCpeData;
-        } else if (cpeData) {
-            data = cpeData;
-        } else if (currentYearCpeData) {
-            // Fallback to current year data if comprehensive data isn't loaded yet
-            data = currentYearCpeData;
-            console.warn('Using current year data as fallback for initial display');
-        } else {
-            console.error('No CPE data available for display');
-            showErrorState();
-            return;
-        }
-
-        updateStatistics(data);
-        updateCharts(data);
-        updateInsights(data);
-        updateLastUpdated(data);
-    }
-
-    // Update statistics cards
-    function updateStatistics(data) {
-        document.getElementById('totalCpes').textContent = data.total_unique_cpes?.toLocaleString() || '0';
-        document.getElementById('totalCvesWithCpes').textContent = data.total_cves_with_cpes?.toLocaleString() || '0';
-        document.getElementById('avgCpesPerCve').textContent = data.average_cpes_per_cve || '0';
-        document.getElementById('totalVendors').textContent = data.total_unique_vendors?.toLocaleString() || '0';
-    }
-
-    // Update all charts and tables
-    function updateCharts(data) {
-        updateTypeChart(data);
-        updateVendorChart(data);
-        updateTopCpesTable(data);
-        updateTopCvesTable(data);
-    }
-
-    // Update CPE bar chart
-    function updateCpeBarChart(data) {
-        const ctx = document.getElementById('cpeBarChart').getContext('2d');
-
-        // Destroy existing chart if it exists
-        if (window.cpeBarChart instanceof Chart) {
-            window.cpeBarChart.destroy();
-        }
-
-        const topCpes = data.top_cpes?.slice(0, 15) || [];
-
-        window.cpeBarChart = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: topCpes.map(cpe => `${cpe.vendor}:${cpe.product}`.substring(0, 25) + '...'),
-                datasets: [{
-                    label: 'CVE Count',
-                    data: topCpes.map(cpe => cpe.count),
-                    backgroundColor: 'rgba(13, 110, 253, 0.8)',
-                    borderColor: 'rgba(13, 110, 253, 1)',
-                    borderWidth: 1
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        display: false
-                    }
-                },
-                scales: {
-                    y: {
-                        beginAtZero: true
-                    }
-                }
-            }
-        });
-    }
-
-    // Update CPE type chart
-    function updateTypeChart(data) {
-        const ctx = document.getElementById('typeChart').getContext('2d');
-
-        // Destroy existing chart if it exists
-        if (window.typeChart instanceof Chart) {
-            window.typeChart.destroy();
-        }
-
-        const typeDistribution = data.cpe_type_distribution || [];
-
-        window.typeChart = new Chart(ctx, {
-            type: 'pie',
-            data: {
-                labels: typeDistribution.map(t => t.type),
-                datasets: [{
-                    data: typeDistribution.map(t => t.count),
-                    backgroundColor: [
-                        '#3b82f6', // Primary blue
-                        '#60a5fa', // Light blue  
-                        '#93c5fd', // Lighter blue
-                        '#bfdbfe', // Very light blue
-                        '#6b7280', // Medium grey
-                        '#9ca3af', // Light grey
-                        '#d1d5db', // Very light grey
-                        '#e5e7eb'  // Lightest grey
-                    ],
-                    borderColor: [
-                        '#1e40af', // Darker blue borders
-                        '#2563eb',
-                        '#3b82f6',
-                        '#60a5fa',
-                        '#4b5563',
-                        '#6b7280',
-                        '#9ca3af',
-                        '#d1d5db'
-                    ],
-                    borderWidth: 2
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        position: 'bottom'
-                    }
-                }
-            }
-        });
-    }
-
-    // Update Top CPEs table
-    function updateTopCpesTable(data) {
-        const tableBody = document.getElementById('topCpesTableBody');
-        const topCpes = data.top_cpes?.slice(0, 20) || [];
-
-        if (topCpes.length === 0) {
-            tableBody.innerHTML = '<tr><td colspan="6" class="text-center text-muted">No CPE data available</td></tr>';
-            return;
-        }
-
-        tableBody.innerHTML = topCpes.map((cpe, index) => `
-        <tr>
-            <td><span class="badge bg-primary">${index + 1}</span></td>
-            <td><code class="text-break" style="font-size: 0.85em;">${cpe.cpe}</code></td>
-            <td><strong>${cpe.count.toLocaleString()}</strong></td>
-            <td><span class="badge bg-info">${cpe.vendor}</span></td>
-            <td>${cpe.product}</td>
-            <td><span class="badge bg-secondary">${cpe.type}</span></td>
-        </tr>
-    `).join('');
-    }
-
-    // Update Top CVEs table
-    function updateTopCvesTable(data) {
-        const tableBody = document.getElementById('topCvesTableBody');
-        const topCves = data.cves_with_most_cpes?.slice(0, 20) || [];
-
-        if (topCves.length === 0) {
-            tableBody.innerHTML = '<tr><td colspan="4" class="text-center text-muted">No CVE data available</td></tr>';
-            return;
-        }
-
-        tableBody.innerHTML = topCves.map((cveData, index) => {
-            const year = cveData.cve ? cveData.cve.split('-')[1] : 'Unknown';
-
-            return `
-            <tr>
-                <td><span class="badge bg-primary">${index + 1}</span></td>
-                <td><a href="https://nvd.nist.gov/vuln/detail/${cveData.cve}" target="_blank" class="text-decoration-none">${cveData.cve}</a></td>
-                <td><strong>${cveData.cpe_count.toLocaleString()}</strong></td>
-                <td><span class="badge bg-warning">${year}</span></td>
-            </tr>
-        `;
-        }).join('');
-    }
-
-    // Update vendor chart
-    function updateVendorChart(data) {
-        const ctx = document.getElementById('vendorChart').getContext('2d');
-
-        // Destroy existing chart if it exists
-        if (window.vendorChart instanceof Chart) {
-            window.vendorChart.destroy();
-        }
-
-        const topVendors = data.top_vendors?.slice(0, 10) || [];
-
-        window.vendorChart = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: topVendors.map(v => v.vendor),
-                datasets: [{
-                    label: 'CPE Count',
-                    data: topVendors.map(v => v.count),
-                    backgroundColor: '#60a5fa', // Light blue from universal palette
-                    borderColor: '#2563eb',     // Darker blue border
-                    borderWidth: 2
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                indexAxis: 'y', // This makes it horizontal
-                plugins: {
-                    legend: {
-                        display: false
-                    }
-                },
-                scales: {
-                    x: {
-                        beginAtZero: true
-                    }
-                }
-            }
-        });
-    }
-
-    // Table sorting function
-    function sortTable(tableId, columnIndex) {
-        const table = document.getElementById(tableId);
-        const tbody = table.querySelector('tbody');
-        const rows = Array.from(tbody.querySelectorAll('tr'));
-
-        // Skip if no data rows
-        if (rows.length === 0 || rows[0].cells.length === 1) return;
-
-        // Determine sort direction
-        const currentSort = table.getAttribute('data-sort-column');
-        const currentDirection = table.getAttribute('data-sort-direction') || 'asc';
-        const newDirection = (currentSort == columnIndex && currentDirection === 'asc') ? 'desc' : 'asc';
-
-        // Sort rows
-        rows.sort((a, b) => {
-            let aVal = a.cells[columnIndex].textContent.trim();
-            let bVal = b.cells[columnIndex].textContent.trim();
-
-            // Handle numeric values
-            const aNum = parseFloat(aVal.replace(/[^0-9.-]/g, ''));
-            const bNum = parseFloat(bVal.replace(/[^0-9.-]/g, ''));
-
-            if (!isNaN(aNum) && !isNaN(bNum)) {
-                return newDirection === 'asc' ? aNum - bNum : bNum - aNum;
-            }
-
-            // Handle text values
-            return newDirection === 'asc' ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
-        });
-
-        // Update table
-        rows.forEach(row => tbody.appendChild(row));
-
-        // Update sort indicators
-        table.setAttribute('data-sort-column', columnIndex);
-        table.setAttribute('data-sort-direction', newDirection);
-
-        // Update header indicators
-        table.querySelectorAll('th').forEach((th, index) => {
-            th.classList.remove('sort-asc', 'sort-desc');
-            if (index === columnIndex) {
-                th.classList.add(newDirection === 'asc' ? 'sort-asc' : 'sort-desc');
-            }
-        });
-    }
-
-    // Update insights
-    function updateInsights(data) {
-        const topCpe = data.top_cpes?.[0];
-        const topVendor = data.top_vendors?.[0];
-
-        if (topCpe) {
-            document.getElementById('topPlatformInsight').innerHTML =
-                `<strong>${topCpe.vendor}:${topCpe.product}</strong> leads with ${topCpe.count.toLocaleString()} CVEs`;
-        }
-
-        if (topVendor) {
-            document.getElementById('topVendorInsight').innerHTML =
-                `<strong>${topVendor.vendor}</strong> has ${topVendor.count.toLocaleString()} CPE entries`;
-        }
-
-        const avgCpes = data.average_cpes_per_cve || 0;
-        document.getElementById('coverageInsight').innerHTML =
-            `Each CVE affects <strong>${avgCpes}</strong> platforms on average`;
-    }
-
-
-
-
-
-    // Toggle data mode
-    function toggleDataMode() {
-        if (!currentYearCpeData) {
-            alert('Current year data not available');
-            return;
-        }
-
-        isShowingCurrentYear = !isShowingCurrentYear;
-
-        // Update toggle button
-        const toggleText = document.getElementById('toggleText');
-        const pageSubtitle = document.getElementById('pageSubtitle');
-
-        if (isShowingCurrentYear) {
-            toggleText.textContent = 'Switch to All Years';
-            pageSubtitle.textContent = `Showing analysis for ${currentYearCpeData.year} only`;
-        } else {
-            toggleText.textContent = 'Switch to 2025 Only';
-            pageSubtitle.textContent = 'Showing comprehensive analysis across all years (1999-2025)';
-        }
-
-        // Reset pagination
-        currentPage = 1;
-
-        // Update display
-        updateDisplay();
-    }
-
-    // Update last updated timestamp
-    function updateLastUpdated(data) {
-        if (data.generated_at) {
-            const date = new Date(data.generated_at);
-            document.getElementById('lastUpdated').textContent = date.toLocaleString();
-        }
-    }
-
-    // Update permalink
-    function updatePermalink() {
-        document.getElementById('permalinkInput').value = window.location.href;
-    }
-
-    // Copy permalink
-    function copyPermalink() {
-        const input = document.getElementById('permalinkInput');
-        input.select();
-        document.execCommand('copy');
-
-        const button = event.target;
-        const originalText = button.textContent;
-        button.textContent = 'Copied!';
-        button.style.backgroundColor = '#28a745';
-
-        setTimeout(() => {
-            button.textContent = originalText;
-            button.style.backgroundColor = '';
-        }, 2000);
-    }
-
-    // Export functions
-    function exportCpeCSV() {
-        if (!cpeData || !cpeData.top_cpes) {
-            alert('No data available for export');
-            return;
-        }
-
-        const data = isShowingCurrentYear && currentYearCpeData ? currentYearCpeData : cpeData;
-
-        let csv = 'CPE Intelligence Dashboard Export\n\n';
-        csv += 'Rank,CPE Identifier,Vendor,Product,Type,CVE Count\n';
-
-        data.top_cpes.forEach((cpe, index) => {
-            csv += `${index + 1},"${cpe.cpe}","${cpe.vendor}","${cpe.product}",${cpe.type},${cpe.count}\n`;
-        });
-
-        csv += '\n\nSummary Statistics\n';
-        csv += `Total CPEs,${data.total_unique_cpes}\n`;
-        csv += `CVEs with CPEs,${data.total_cves_with_cpes}\n`;
-        csv += `Unique Vendors,${data.total_unique_vendors}\n`;
-        csv += `Average CPEs per CVE,${data.average_cpes_per_cve}\n`;
-
-        downloadFile(csv, 'cpe-comprehensive-analysis.csv', 'text/csv');
-    }
-
-    function exportCpeJSON() {
-        if (!cpeData) {
-            alert('No data available for export');
-            return;
-        }
-
-        const data = isShowingCurrentYear && currentYearCpeData ? currentYearCpeData : cpeData;
-        const jsonStr = JSON.stringify(data, null, 2);
-        downloadFile(jsonStr, 'cpe-comprehensive-analysis.json', 'application/json');
-    }
-
-    function downloadFile(content, filename, contentType) {
-        const blob = new Blob([content], { type: contentType });
-        const url = window.URL.createObjectURL(blob);
-        const a = document.createElement('a');
-        a.href = url;
-        a.download = filename;
-        document.body.appendChild(a);
-        a.click();
-        document.body.removeChild(a);
-        window.URL.revokeObjectURL(url);
-    }
-
-    // Error state
-    function showErrorState() {
-        document.getElementById('totalCpes').textContent = 'Error';
-        document.getElementById('totalCvesWithCpes').textContent = 'Error';
-        document.getElementById('averageCpesPerCve').textContent = 'Error';
-        document.getElementById('totalVendors').textContent = 'Error';
-
-        document.getElementById('cpeTableBody').innerHTML =
-            '<tr><td colspan="6" class="text-center text-danger">Error loading CPE data. Please refresh the page.</td></tr>';
-    }
+CVE.page(async () => {
+  const { fmt, chart, el, table } = CVE;
+  const d = await CVE.json('cpe_analysis.json');
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'CVEs with product data', v: fmt.n(d.total_cves_with_cpes),
+      sub: `<b>${fmt.n(d.average_cpes_per_cve)}</b> product entries per CVE on average` },
+    { lbl: 'Distinct vendors', v: fmt.n(d.total_unique_vendors), sub: 'named across all CVEs' },
+    { lbl: 'Distinct products', v: fmt.n(d.total_unique_products), sub: 'named across all CVEs' },
+    { lbl: 'Total CPE entries', v: fmt.compact(d.total_cpe_entries),
+      sub: `<b>${fmt.compact(d.total_unique_cpes)}</b> unique strings` }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  chart.rank('#vendors', (d.top_vendors || []).slice(0, 12)
+    .map(v => ({ label: v.vendor || v.name, value: v.count })), { compact: true , name: 'cve-icu-top-vendors' });
+  chart.rank('#products', (d.top_products || []).slice(0, 12)
+    .map(p => ({ label: p.product || p.name, sub: p.vendor, value: p.count })), { compact: true , name: 'cve-icu-top-products' });
+
+  chart.hbars('#types', (d.cpe_type_distribution || [])
+    .map(t => ({ label: t.type || t.name, value: t.count })), { name: 'cve-icu-platform-types' });
+
+  // A CPE string carries version, update, edition and architecture. Without them
+  // rows like windows_server_2012 r2 and windows_server_2012 - look identical.
+  const cpePart = (cpe, i) => {
+    const parts = String(cpe || '').split(':');
+    const v = parts[i];
+    return !v || v === '*' || v === '-' ? '' : v;
+  };
+  table('#cpe-table', (d.top_cpes || []).map(c => ({
+    vendor: c.vendor,
+    product: c.product,
+    version: cpePart(c.cpe, 5) || '—',
+    edition: [cpePart(c.cpe, 6), cpePart(c.cpe, 8), cpePart(c.cpe, 11)].filter(Boolean).join(' ') || '—',
+    type: c.type || '—',
+    cves: c.count
+  })), [
+    { key: 'vendor', label: 'Vendor' },
+    { key: 'product', label: 'Product' },
+    { key: 'version', label: 'Version' },
+    { key: 'edition', label: 'Edition / arch' },
+    { key: 'type', label: 'Type' },
+    { key: 'cves', label: 'References', num: true, bar: true }
+  ], { name: 'cve-icu-cpe-entries' });
+
+  chart.rank('#widest', (d.cves_with_most_cpes || []).slice(0, 10).map(c => ({
+    label: c.cve || c.cve_id, sub: 'product entries', value: c.cpe_count || c.count
+  })), { name: 'cve-icu-cves-naming-most-products' });
+});
 </script>
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/templates/cvss.html b/templates/cvss.html
index b8a896f3dd3..e950284b53a 100644
--- a/templates/cvss.html
+++ b/templates/cvss.html
@@ -1,739 +1,100 @@
 {% extends "base.html" %}
-
-{% block title %}CVSS Intelligence Dashboard - CVEDB{% endblock %}
+{% set nav = 'scoring' %}
+{% block title %}CVSS scores &mdash; CVEDB{% endblock %}
+{% block description %}How many CVEs carry each CVSS severity and score, by metric version.{% endblock %}
 
 {% block content %}
-<style>
-    .stats-grid {
-        display: grid;
-        grid-template-columns: repeat(4, 1fr);
-        gap: 1.5rem;
-        margin-bottom: 2rem;
-    }
-
-    @media (max-width: 992px) {
-        .stats-grid {
-            grid-template-columns: repeat(2, 1fr);
-        }
-    }
-
-    @media (max-width: 576px) {
-        .stats-grid {
-            grid-template-columns: 1fr;
-        }
-    }
-
-    .chart-container {
-        position: relative;
-        width: 100%;
-    }
-
-    /* Active button styling for better visual indication */
-    .quick-select-btn.active {
-        background-color: #3b82f6 !important;
-        color: white !important;
-        border-color: #2563eb !important;
-    }
-
-    .quick-select-btn:hover {
-        background-color: #60a5fa;
-        color: white;
-        border-color: #3b82f6;
-    }
-</style>
-
-<!-- Hero Section -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">CVSS Intelligence Dashboard</h1>
-    <small class="text-muted d-block mb-3" id="pageSubtitle">
-        Showing comprehensive analysis across all years (1999-2025)
-    </small>
-
-    <!-- Data Mode Toggle -->
-    <div class="d-flex justify-content-center mb-3">
-        <button type="button" id="dataToggleBtn" onclick="toggleDataMode()" style="
-            color: var(--color-text-secondary);
-            font-weight: var(--font-weight-medium);
-            padding: var(--spacing-sm) var(--spacing-md);
-            border-radius: var(--border-radius);
-            transition: all 0.15s ease-in-out;
-            background: none;
-            border: 2px solid var(--color-border);
-            cursor: pointer;
-            font-size: inherit;
-        " onmouseover="this.style.color='var(--color-accent)'; this.style.backgroundColor='rgba(13, 110, 253, 0.1)'; this.style.borderColor='var(--color-accent)'"
-            onmouseout="this.style.color='var(--color-text-secondary)'; this.style.backgroundColor='transparent'; this.style.borderColor='var(--color-border)'">
-            <span id="toggleText">Switch to 2025 Only</span>
-        </button>
-    </div>
+<div class="ph">
+  <h1>CVSS scores</h1>
+  <span class="note">severity, by metric version</span>
+  <span style="margin-left:auto"><span class="seg" id="vsel"></span></span>
 </div>
+<p class="lede">A CVE can hold a score under more than one CVSS version, so these counts add up
+to more than the number of CVEs. Each version is counted separately below.</p>
 
-<!-- Statistics Cards -->
-<div class="stats-grid mb-4">
-    <div class="stat-card">
-        <div class="stat-number" id="cvssV2Avg">-</div>
-        <div class="stat-label">CVSS v2.0 Average</div>
-        <small class="text-muted" style="font-size: 0.75rem;" id="cvssV2Count">- CVEs</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="cvssV3Avg">-</div>
-        <div class="stat-label">CVSS v3.0 Average</div>
-        <small class="text-muted" style="font-size: 0.75rem;" id="cvssV3Count">- CVEs</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="cvssV31Avg">-</div>
-        <div class="stat-label">CVSS v3.1 Average</div>
-        <small class="text-muted" style="font-size: 0.75rem;" id="cvssV31Count">- CVEs</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="cvssV4Avg">-</div>
-        <div class="stat-label">CVSS v4.0 Average</div>
-        <small class="text-muted" style="font-size: 0.75rem;" id="cvssV4Count">- CVEs</small>
-    </div>
-</div>
-
-<!-- CVSS Analysis Charts -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title mb-2" style="font-size: 1.1rem;">CVSS Analysis</h3>
-        <small class="text-muted">Severity and score distribution for <span id="cvssVersionLabel">CVSS
-                v3.1</span></small>
+<div class="grid" id="tiles"></div>
 
-        <!-- Version Selection Buttons -->
-        <div class="quick-select-buttons mt-3" style="text-align: center;" id="cvssVersionButtons">
-            <button class="quick-select-btn" onclick="updateCvssVersion('v2.0')">v2.0</button>
-            <button class="quick-select-btn" onclick="updateCvssVersion('v3.0')">v3.0</button>
-            <button class="quick-select-btn active" onclick="updateCvssVersion('v3.1')">v3.1</button>
-            <button class="quick-select-btn" onclick="updateCvssVersion('v4.0')">v4.0</button>
-        </div>
-    </div>
-    <div class="card-body py-3">
-        <div class="row">
-            <!-- Severity Distribution -->
-            <div class="col-md-6">
-                <h5 class="mb-3" style="font-size: 1rem;">Severity Distribution</h5>
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="severityChart"></canvas>
-                </div>
-            </div>
-
-            <!-- Score Distribution -->
-            <div class="col-md-6">
-                <h5 class="mb-3" style="font-size: 1rem;">Score Distribution</h5>
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="scoreChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- CVSS Temporal Trends Chart -->
-<div class="card mb-4" id="temporalChartContainer">
-    <div class="card-header py-2">
-        <h3 class="card-title mb-2" style="font-size: 1.1rem;">CVSS Version Trends Over Time</h3>
-        <small class="text-muted">CVE count by CVSS version per year - click legend to toggle lines</small>
-
-        <!-- Version Toggle Buttons -->
-        <div class="quick-select-buttons mt-3" style="text-align: center;" id="temporalToggleButtons">
-            <button class="quick-select-btn active" onclick="toggleTemporalLine('v2.0')">v2.0</button>
-            <button class="quick-select-btn active" onclick="toggleTemporalLine('v3.0')">v3.0</button>
-            <button class="quick-select-btn active" onclick="toggleTemporalLine('v3.1')">v3.1</button>
-            <button class="quick-select-btn active" onclick="toggleTemporalLine('v4.0')">v4.0</button>
-        </div>
-    </div>
-    <div class="card-body py-3">
-        <div class="chart-container" style="height: 400px;">
-            <canvas id="temporalChart"></canvas>
-        </div>
-        <p class="mt-3 text-muted" id="kevTimelineInsight" style="font-size: 0.85rem;">
-            Loading KEV timeline insight...
-        </p>
-    </div>
-</div>
+<h2>Scores per version</h2>
+<div class="panel"><div class="panel-b"><div id="versions"></div></div></div>
 
-<!-- Version Adoption Chart -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title mb-0" style="font-size: 1.1rem;">CVSS Version Adoption</h3>
-        <small class="text-muted">Comparison of CVE counts across CVSS versions</small>
-    </div>
-    <div class="card-body py-3">
-        <div class="chart-container" style="height: 400px;">
-            <canvas id="versionChart"></canvas>
-        </div>
-    </div>
-</div>
+<h2>Severity bands <span class="side" id="sev-ver"></span></h2>
+<div class="panel"><div class="panel-b"><div id="sev"></div></div></div>
 
-<!-- Export and Share Panel -->
-<div class="card mb-3">
-    <div class="card-header py-2">
-        <h2 class="card-title mb-0" style="font-size: 1.1rem;">📤 Export & Share</h2>
-    </div>
-    <div class="card-body py-3">
-        <div class="export-buttons">
-            <button class="btn btn-primary btn-sm" onclick="exportCvssCSV()">📊 Export CSV</button>
-            <button class="btn btn-primary btn-sm" onclick="exportCvssJSON()">📋 Export JSON</button>
-            <button class="btn btn-secondary btn-sm" onclick="copyPermalink()">🔗 Copy Permalink</button>
-            <button class="btn btn-secondary btn-sm" onclick="window.print()">🖨️ Print Report</button>
-        </div>
-        <div class="permalink-result mt-2" id="permalinkResult" style="display: none;">
-            <input type="text" class="form-control" id="permalinkInput" readonly>
-            <button class="btn btn-outline-primary btn-sm mt-1" onclick="copyPermalink()">Copy Link</button>
-        </div>
-    </div>
-</div>
+<h2>Score distribution <span class="side" id="dist-ver"></span></h2>
+<div class="panel"><div class="panel-b"><div id="dist"></div></div></div>
 
+<h2>Scored CVEs per year</h2>
+<div class="panel"><div class="panel-b"><div id="by-year"></div></div></div>
 {% endblock %}
 
 {% block scripts %}
-<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
 <script>
-    // Global variables
-    let cvssData = null;
-    let currentYearCvssData = null;
-    let currentDataMode = 'all'; // 'all' or 'current'
-    let charts = {}; // Store chart instances for cleanup
-    let selectedCvssVersion = 'v3.1'; // Default to most common version
-    let temporalLineVisibility = {
-        'v2.0': true,
-        'v3.0': true,
-        'v3.1': true,
-        'v4.0': true
-    }; // Track which temporal lines are visible
-
-    // Load data on page load
-    document.addEventListener('DOMContentLoaded', function () {
-        loadCvssData();
-    });
-
-    // Load CVSS data
-    function loadCvssData() {
-        Promise.all([
-            fetch('/data/cvss_analysis.json').then(response => response.json()),
-            fetch('/data/cvss_analysis_current_year.json').then(response => response.json())
-        ])
-            .then(([allYearData, currentData]) => {
-                cvssData = allYearData;
-                currentYearCvssData = currentData;
-                updateDisplay();
-            })
-            .catch(error => {
-                console.error('Error loading CVSS data:', error);
-                showErrorState();
-            });
-    }
-
-    // Update display based on current mode
-    function updateDisplay() {
-        const data = currentDataMode === 'current' ? currentYearCvssData : cvssData;
-
-        if (!data) {
-            showErrorState();
-            return;
-        }
-
-        updateStatsCards(data);
-        updateCharts(data);
-    }
-
-    // Update statistics cards
-    function updateStatsCards(data) {
-        const versionMapping = {
-            'v2.0': { avgId: 'cvssV2Avg', countId: 'cvssV2Count' },
-            'v3.0': { avgId: 'cvssV3Avg', countId: 'cvssV3Count' },
-            'v3.1': { avgId: 'cvssV31Avg', countId: 'cvssV31Count' },
-            'v4.0': { avgId: 'cvssV4Avg', countId: 'cvssV4Count' }
-        };
-
-        Object.entries(versionMapping).forEach(([version, ids]) => {
-            const avgElement = document.getElementById(ids.avgId);
-            const countElement = document.getElementById(ids.countId);
-
-            const versionData = data.score_distribution?.[version] || {};
-            const count = data.total_by_version?.[version] || 0;
-
-            // Calculate average score
-            let totalScore = 0;
-            let totalCount = 0;
-
-            Object.entries(versionData).forEach(([score, scoreCount]) => {
-                const numScore = parseFloat(score);
-                if (!isNaN(numScore)) {
-                    totalScore += numScore * scoreCount;
-                    totalCount += scoreCount;
-                }
-            });
-
-            const avgScore = totalCount > 0 ? (totalScore / totalCount).toFixed(1) : '0.0';
-
-            if (avgElement) avgElement.textContent = avgScore;
-            if (countElement) countElement.textContent = `${count.toLocaleString()} CVEs`;
-        });
-
-        // KEV stats
-        const kevGlobalEl = document.getElementById('kevGlobal');
-        const kevLabelEl = document.getElementById('kevLabel');
-        if (kevGlobalEl && kevLabelEl) {
-            if (data.kev_global_count !== undefined) {
-                kevGlobalEl.textContent = (data.kev_global_count || 0).toLocaleString();
-                kevLabelEl.textContent = 'CISA KEV catalog (all years)';
-            } else if (data.kev_by_year && data.year) {
-                const yearKev = data.kev_by_year[data.year] || 0;
-                kevGlobalEl.textContent = yearKev.toLocaleString();
-                kevLabelEl.textContent = `Known exploited CVEs in ${data.year}`;
-            }
-        }
-    }
-
-    // Update charts
-    function updateCharts(data) {
-        updateSeverityChart(data);
-        updateScoreChart(data);
-        updateTemporalChart(data);
-        updateVersionChart(data);
-        updateKevTimelineInsight();
-    }
-
-    // KEV timeline insight under temporal chart
-    function updateKevTimelineInsight() {
-        const insightEl = document.getElementById('kevTimelineInsight');
-        if (!insightEl || !cvssData || !cvssData.kev_by_year) {
-            return;
-        }
-
-        const kevEntries = Object.entries(cvssData.kev_by_year)
-            .map(([year, count]) => ({ year: parseInt(year, 10), count: Number(count) || 0 }))
-            .filter(entry => !isNaN(entry.year) && entry.count > 0)
-            .sort((a, b) => a.year - b.year);
-
-        if (!kevEntries.length) {
-            insightEl.textContent = 'No known exploited CVEs are currently recorded in the CISA KEV catalog for the years in view.';
-            return;
-        }
-
-        const totalKev = kevEntries.reduce((sum, e) => sum + e.count, 0);
-        const first = kevEntries[0];
-        const peak = kevEntries.reduce((max, e) => (e.count > max.count ? e : max), kevEntries[0]);
-
-        const spanText = kevEntries.length === 1
-            ? `${first.year}`
-            : `${first.year}-${kevEntries[kevEntries.length - 1].year}`;
-
-        insightEl.textContent = `${totalKev.toLocaleString()} known exploited CVEs appear in the KEV catalog across ${spanText}, ` +
-            `with a hotspot in ${peak.year} (${peak.count.toLocaleString()} KEV CVEs).`;
-    }
-
-    // Update severity distribution chart
-    function updateSeverityChart(data) {
-        const ctx = document.getElementById('severityChart').getContext('2d');
-
-        if (charts.severity) {
-            charts.severity.destroy();
-        }
-
-        // Get severity data for selected version
-        const versionData = data.severity_distribution?.[selectedCvssVersion] || {};
-
-        const labels = Object.keys(versionData).sort();
-        const values = labels.map(s => versionData[s]);
-
-        charts.severity = new Chart(ctx, {
-            type: 'doughnut',
-            data: {
-                labels: labels,
-                datasets: [{
-                    data: values,
-                    backgroundColor: [
-                        '#3b82f6', // Low - Primary blue
-                        '#60a5fa', // Medium - Light blue
-                        '#93c5fd', // High - Lighter blue
-                        '#6b7280'  // Critical - Grey
-                    ],
-                    borderWidth: 2,
-                    borderColor: '#ffffff'
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        position: 'bottom'
-                    }
-                }
-            }
-        });
-    }
-
-    // Update score distribution chart
-    function updateScoreChart(data) {
-        const ctx = document.getElementById('scoreChart').getContext('2d');
-
-        if (charts.score) {
-            charts.score.destroy();
-        }
-
-        // Use binned score distribution for selected version
-        const versionData = data.binned_score_distribution?.[selectedCvssVersion] || {};
-
-        // Sort score ranges properly
-        const sortedRanges = Object.keys(versionData).sort((a, b) => {
-            const aStart = parseFloat(a.split('-')[0]);
-            const bStart = parseFloat(b.split('-')[0]);
-            return aStart - bStart;
-        });
-
-        const labels = sortedRanges;
-        const values = labels.map(range => versionData[range]);
-
-        charts.score = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: labels,
-                datasets: [{
-                    label: 'CVE Count',
-                    data: values,
-                    backgroundColor: '#60a5fa',
-                    borderColor: '#2563eb',
-                    borderWidth: 1
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        display: false
-                    }
-                },
-                scales: {
-                    y: {
-                        beginAtZero: true,
-                        ticks: {
-                            callback: function (value) {
-                                return value.toLocaleString();
-                            }
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // Update temporal trends chart
-    function updateTemporalChart(data) {
-        const ctx = document.getElementById('temporalChart').getContext('2d');
-
-        // Destroy existing chart if it exists
-        if (charts.temporalChart) {
-            charts.temporalChart.destroy();
-        }
-
-        const temporalData = data.temporal_data || {};
-        const years = Object.keys(temporalData).sort();
-        const versions = ['v2.0', 'v3.0', 'v3.1', 'v4.0'];
-        const colors = {
-            'v2.0': '#3b82f6', // Blue
-            'v3.0': '#10b981', // Green
-            'v3.1': '#f59e0b', // Orange
-            'v4.0': '#ef4444'  // Red
-        };
-
-        const datasets = versions.map(version => {
-            const versionData = years.map(year => temporalData[year]?.[version] || 0);
-
-            return {
-                label: `CVSS ${version}`,
-                data: versionData,
-                borderColor: colors[version],
-                backgroundColor: colors[version] + '20', // Add transparency
-                borderWidth: 3,
-                fill: false,
-                tension: 0.1,
-                pointRadius: 4,
-                pointHoverRadius: 6,
-                hidden: !temporalLineVisibility[version]
-            };
-        });
-
-        charts.temporalChart = new Chart(ctx, {
-            type: 'line',
-            data: {
-                labels: years,
-                datasets: datasets
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                interaction: {
-                    intersect: false,
-                    mode: 'index'
-                },
-                plugins: {
-                    legend: {
-                        position: 'bottom',
-                        onClick: function (e, legendItem) {
-                            const version = legendItem.text.replace('CVSS ', '');
-                            toggleTemporalLine(version);
-                        }
-                    },
-                    tooltip: {
-                        callbacks: {
-                            label: function (context) {
-                                return `${context.dataset.label}: ${context.parsed.y.toLocaleString()} CVEs`;
-                            }
-                        }
-                    }
-                },
-                scales: {
-                    x: {
-                        title: {
-                            display: true,
-                            text: 'Year'
-                        }
-                    },
-                    y: {
-                        beginAtZero: true,
-                        title: {
-                            display: true,
-                            text: 'CVE Count'
-                        },
-                        ticks: {
-                            callback: function (value) {
-                                return value.toLocaleString();
-                            }
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // Update version adoption chart
-    function updateVersionChart(data) {
-        const ctx = document.getElementById('versionChart').getContext('2d');
-
-        // Destroy existing chart if it exists
-        if (charts.versionChart) {
-            charts.versionChart.destroy();
-        }
-
-        const versionData = data.total_by_version || {};
-        const versions = ['v2.0', 'v3.0', 'v3.1', 'v4.0'];
-        const counts = versions.map(v => versionData[v] || 0);
-
-        charts.versionChart = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: versions.map(v => `CVSS ${v}`),
-                datasets: [{
-                    label: 'CVE Count',
-                    data: counts,
-                    backgroundColor: [
-                        '#3b82f6', // v2.0 - Primary blue
-                        '#60a5fa', // v3.0 - Light blue
-                        '#93c5fd', // v3.1 - Lighter blue
-                        '#bfdbfe'  // v4.0 - Very light blue
-                    ],
-                    borderColor: [
-                        '#1e40af',
-                        '#2563eb',
-                        '#3b82f6',
-                        '#60a5fa'
-                    ],
-                    borderWidth: 2
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        display: false
-                    }
-                },
-                scales: {
-                    y: {
-                        beginAtZero: true,
-                        ticks: {
-                            callback: function (value) {
-                                return value.toLocaleString();
-                            }
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // Toggle temporal line visibility
-    function toggleTemporalLine(version) {
-        temporalLineVisibility[version] = !temporalLineVisibility[version];
-
-        // Update button states - only affect temporal toggle buttons
-        document.querySelectorAll('#temporalToggleButtons .quick-select-btn').forEach(btn => {
-            if (btn.onclick && btn.onclick.toString().includes(`toggleTemporalLine('${version}')`)) {
-                if (temporalLineVisibility[version]) {
-                    btn.classList.add('active');
-                } else {
-                    btn.classList.remove('active');
-                }
-            }
-        });
-
-        // Update temporal chart
-        const data = currentDataMode === 'current' ? currentYearCvssData : cvssData;
-        updateTemporalChart(data);
-    }
-
-    // Unified CVSS version selection function
-    function updateCvssVersion(version) {
-        selectedCvssVersion = version;
-
-        // Update button states - only affect CVSS version selection buttons
-        document.querySelectorAll('#cvssVersionButtons .quick-select-btn').forEach(btn => {
-            btn.classList.remove('active');
-            if (btn.onclick && btn.onclick.toString().includes(`updateCvssVersion('${version}')`)) {
-                btn.classList.add('active');
-            }
-        });
-
-        // Update label
-        document.getElementById('cvssVersionLabel').textContent = `CVSS ${version}`;
-
-        // Update both charts
-        const data = currentDataMode === 'current' ? currentYearCvssData : cvssData;
-        updateSeverityChart(data);
-        updateScoreChart(data);
-    }
-
-    // Toggle data mode between all years and current year
-    function toggleDataMode() {
-        const newMode = currentDataMode === 'all' ? 'current' : 'all';
-        setDataMode(newMode);
-    }
-
-    // Set data mode
-    function setDataMode(mode) {
-        currentDataMode = mode;
-        updateToggleUI();
-        updateDisplay();
-    }
-
-    // Update toggle UI elements
-    function updateToggleUI() {
-        const toggleText = document.getElementById('toggleText');
-        const pageSubtitle = document.getElementById('pageSubtitle');
-        const temporalChartContainer = document.getElementById('temporalChartContainer');
-
-        if (currentDataMode === 'all') {
-            toggleText.textContent = 'Switch to 2025 Only';
-            pageSubtitle.textContent = 'Showing comprehensive analysis across all years (1999-2025)';
-            // Show temporal chart for all years view
-            if (temporalChartContainer) {
-                temporalChartContainer.style.display = 'block';
-            }
-        } else {
-            toggleText.textContent = 'Switch to All-Time';
-            pageSubtitle.textContent = 'Showing analysis for 2025 data only';
-            // Hide temporal chart for current year view
-            if (temporalChartContainer) {
-                temporalChartContainer.style.display = 'none';
-            }
-        }
-    }
-
-    // Timestamp now handled by universal loader in base.html
-
-    // Show error state
-    function showErrorState() {
-        document.querySelectorAll('.display-4').forEach(el => el.textContent = 'N/A');
-        document.querySelectorAll('.h5').forEach(el => {
-            if (el.id.includes('Count')) el.textContent = 'No data';
-        });
-    }
-
-    // Export functions
-    function exportCvssCSV() {
-        if (!cvssData) {
-            alert('No data available for export');
-            return;
-        }
-
-        const data = currentDataMode === 'current' ? currentYearCvssData : cvssData;
-
-        let csv = 'CVSS Intelligence Dashboard Export\n\n';
-        csv += 'Version,Average Score,CVE Count\n';
-
-        Object.entries(data.total_by_version || {}).forEach(([version, count]) => {
-            const versionData = data.score_distribution?.[version] || {};
-            let totalScore = 0;
-            let totalCount = 0;
-
-            Object.entries(versionData).forEach(([score, scoreCount]) => {
-                const numScore = parseFloat(score);
-                if (!isNaN(numScore)) {
-                    totalScore += numScore * scoreCount;
-                    totalCount += scoreCount;
-                }
-            });
-
-            const avgScore = totalCount > 0 ? (totalScore / totalCount).toFixed(1) : '0.0';
-            csv += `${version},${avgScore},${count}\n`;
-        });
-
-        const blob = new Blob([csv], { type: 'text/csv' });
-        const url = window.URL.createObjectURL(blob);
-        const a = document.createElement('a');
-        a.href = url;
-        a.download = `cvss-analysis-${currentDataMode === 'current' ? '2025' : 'all-years'}.csv`;
-        document.body.appendChild(a);
-        a.click();
-        document.body.removeChild(a);
-        window.URL.revokeObjectURL(url);
-    }
-
-    function exportCvssJSON() {
-        if (!cvssData) {
-            alert('No data available for export');
-            return;
-        }
-
-        const data = currentDataMode === 'current' ? currentYearCvssData : cvssData;
-        const jsonStr = JSON.stringify(data, null, 2);
-        downloadFile(jsonStr, `cvss-analysis-${currentDataMode === 'current' ? '2025' : 'all-years'}.json`, 'application/json');
-    }
-
-    function downloadFile(content, filename, contentType) {
-        const blob = new Blob([content], { type: contentType });
-        const url = URL.createObjectURL(blob);
-        const a = document.createElement('a');
-        a.href = url;
-        a.download = filename;
-        document.body.appendChild(a);
-        a.click();
-        document.body.removeChild(a);
-        URL.revokeObjectURL(url);
-    }
-
-    function copyPermalink() {
-        const url = window.location.href;
-        navigator.clipboard.writeText(url).then(() => {
-            const button = event.target;
-            const originalText = button.textContent;
-            button.textContent = '✅ Copied!';
-            button.style.backgroundColor = '#198754';
-
-            setTimeout(() => {
-                button.textContent = originalText;
-                button.style.backgroundColor = '';
-            }, 2000);
-        });
-    }
-
-    function updatePermalink() {
-        // Update permalink functionality if needed
-    }
+CVE.page(async () => {
+  const { fmt, chart, el } = CVE;
+  const YR = {{ current_year }};
+  const d = await CVE.json('cvss_analysis.json');
+  const versions = Object.keys(d.total_by_version || {});
+  let ver = versions.includes('v3.1') ? 'v3.1' : versions[versions.length - 1];
+
+  el('#vsel').innerHTML = versions.map(v =>
+    `<button data-v="${v}" class="${v === ver ? 'on' : ''}">${v}</button>`).join('');
+
+  chart.hbars('#versions', versions.map(v => ({ label: v, value: d.total_by_version[v] })), { name: 'cve-icu-cvss-by-version' });
+
+  const temporal = d.temporal_data || {};
+  const tYears = Object.keys(temporal).sort();
+  if (tYears.length) {
+    chart.bars('#by-year', tYears.map(y => ({
+      label: y,
+      value: typeof temporal[y] === 'number' ? temporal[y]
+        : (temporal[y].total || temporal[y].count || 0),
+      current: +y === YR
+    })), { ticks: [tYears[0], tYears[tYears.length - 1]] , name: 'cve-icu-cvss-scored-per-year' });
+  } else {
+    el('#by-year').innerHTML = '<div class="empty">No per-year breakdown in this dataset.</div>';
+  }
+
+  function render() {
+    const sev = (d.severity_distribution || {})[ver] || {};
+    const bins = (d.binned_score_distribution || {})[ver] || {};
+    const totalV = d.total_by_version[ver] || 0;
+    const order = ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'NONE', 'UNKNOWN'];
+    const sevRows = order.filter(k => sev[k]).map(k => ({ label: k, value: sev[k] }));
+
+    el('#tiles').innerHTML = [
+      { lead: 1, lbl: `Scores recorded under ${ver}`, v: fmt.n(totalV),
+        sub: `of <b>${fmt.n(d.total_cves_with_cvss)}</b> across all versions` },
+      { lbl: 'Highest band', v: fmt.n(sev.CRITICAL || sev.HIGH || 0),
+        sub: sev.CRITICAL ? `<b>${fmt.share(sev.CRITICAL, totalV)}</b> rated critical`
+          : 'this version has no critical band' },
+      { lbl: 'In the KEV catalog', v: fmt.n(d.kev_global_count),
+        sub: 'across all versions and years' },
+      { lbl: 'Metric versions in use', v: String(versions.length),
+        sub: versions.join(' &middot; ') }
+    ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+        <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+    el('#sev-ver').textContent = ver;
+    el('#dist-ver').textContent = ver;
+    if (sevRows.length) chart.hbars('#sev', sevRows, { name: 'cve-icu-cvss-severity' });
+    else el('#sev').innerHTML = '<div class="empty">No severity bands recorded for ' + ver + '.</div>';
+
+    const keys = Object.keys(bins).sort((a, b) => parseFloat(a) - parseFloat(b));
+    if (keys.length) {
+      chart.bars('#dist', keys.map(k => ({ label: k, value: bins[k] })),
+        { tall: true, ticks: [keys[0], keys[keys.length - 1]] , name: 'cve-icu-cvss-score-distribution' });
+    } else {
+      el('#dist').innerHTML = '<div class="empty">No score distribution for ' + ver + '.</div>';
+    }
+  }
+  render();
+
+  el('#vsel').addEventListener('click', e => {
+    const b = e.target.closest('button[data-v]'); if (!b) return;
+    ver = b.dataset.v;
+    CVE.all('#vsel button').forEach(x => x.classList.toggle('on', x === b));
+    render();
+  });
+});
 </script>
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/templates/cwe.html b/templates/cwe.html
index eb20a16dd00..9f49382fe5e 100644
--- a/templates/cwe.html
+++ b/templates/cwe.html
@@ -1,914 +1,54 @@
 {% extends "base.html" %}
-
-{% block title %}CWE Analysis - CVEDB{% endblock %}
+{% set nav = 'cwe' %}
+{% block title %}CVEs by weakness type &mdash; CVEDB{% endblock %}
+{% block description %}How many CVEs carry each CWE weakness classification.{% endblock %}
 
 {% block content %}
-<!-- Hero Section -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">CWE Intelligence Dashboard</h1>
-    <small class="text-muted d-block mb-3" id="pageSubtitle">
-        Showing comprehensive analysis across all years (1999-2025)
-    </small>
-
-    <!-- Data Mode Toggle -->
-    <div class="d-flex justify-content-center mb-3">
-        <button type="button" id="dataToggleBtn" onclick="toggleDataMode()" style="
-            color: var(--color-text-secondary);
-            font-weight: var(--font-weight-medium);
-            padding: var(--spacing-sm) var(--spacing-md);
-            border-radius: var(--border-radius);
-            transition: all 0.15s ease-in-out;
-            background: none;
-            border: 2px solid var(--color-border);
-            cursor: pointer;
-            font-size: inherit;
-        " onmouseover="this.style.color='var(--color-accent)'; this.style.backgroundColor='rgba(13, 110, 253, 0.1)'; this.style.borderColor='var(--color-accent)'"
-            onmouseout="this.style.color='var(--color-text-secondary)'; this.style.backgroundColor='transparent'; this.style.borderColor='var(--color-border)'">
-            <span id="toggleText">Switch to 2025 Only</span>
-        </button>
-    </div>
-</div>
-
-<!-- Statistics Cards -->
-<div class="stats-grid mb-4">
-    <div class="stat-card">
-        <div class="stat-number" id="totalCwes">Loading...</div>
-        <div class="stat-label">Total CWEs</div>
-        <small class="text-muted" style="font-size: 0.75rem;">🔍 Unique weakness types</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="totalCvesWithCwe">Loading...</div>
-        <div class="stat-label">CVEs with CWE</div>
-        <small class="text-muted" style="font-size: 0.75rem;">📊 Classified vulnerabilities</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="topCwePercentage">Loading...</div>
-        <div class="stat-label" id="topCweLabel">Loading...</div>
-        <small class="text-muted" style="font-size: 0.75rem;">🎯 Most common weakness</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="top5CweShare">Loading...</div>
-        <div class="stat-label">Top 5 CWE Share</div>
-        <small class="text-muted" style="font-size: 0.75rem;">🏆 Combined dominance</small>
-    </div>
-</div>
-
-<!-- Top CWEs and CWE Category Distribution -->
-<div class="row mb-4">
-    <div class="col-lg-8 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">Top Common Weakness Enumerations</h3>
-                <small class="text-muted">Most frequently occurring CWE types in CVE database</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="cweBarChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <div class="col-lg-4 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">CWE Categories</h3>
-                <small class="text-muted">Distribution by weakness category</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="cweCategoryChart"></canvas>
-                </div>
-                <small class="text-muted mt-2 d-block">
-                    <i class="fas fa-info-circle me-1"></i>
-                    Categories based on <a href="https://cwe.mitre.org/data/definitions/1000.html" target="_blank"
-                        class="text-decoration-none">CWE Research Concepts</a> taxonomy.
-                </small>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- Smart Insights Panel -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">🔍 CWE Intelligence Insights</h3>
-    </div>
-    <div class="card-body py-3">
-        <div class="row" id="cweInsights">
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">🎯</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Most Critical</div>
-                        <div class="insight-text" id="criticalInsight">Loading analysis...</div>
-                    </div>
-                </div>
-            </div>
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">📈</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Trend Analysis</div>
-                        <div class="insight-text" id="trendInsight">Loading analysis...</div>
-                    </div>
-                </div>
-            </div>
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">📈</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Temporal Trends</div>
-                        <div class="insight-text" id="temporalInsight">Loading analysis...</div>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
+<div class="ph"><h1>CVEs by weakness type</h1><span class="note">from CWE classifications</span></div>
+<p class="lede">Not every CVE carries a CWE. These counts cover the ones that do.</p>
 
-<!-- CWE Analysis Table -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">📊 Detailed CWE Analysis</h3>
-        <small class="text-muted">Comprehensive breakdown of all Common Weakness Enumerations</small>
-    </div>
-    <div class="card-body py-3">
-        <div class="table-responsive">
-            <table class="table table-hover" id="cweTable">
-                <thead>
-                    <tr>
-                        <th class="sortable" data-sort="rank" style="cursor: pointer;">Rank <span
-                                class="sort-indicator">▲</span></th>
-                        <th class="sortable" data-sort="id" style="cursor: pointer;">CWE ID <span
-                                class="sort-indicator"></span></th>
-                        <th class="sortable" data-sort="name" style="cursor: pointer;">Description <span
-                                class="sort-indicator"></span></th>
-                        <th class="sortable" data-sort="count" style="cursor: pointer;">CVE Count <span
-                                class="sort-indicator"></span></th>
-                        <th class="sortable" data-sort="percentage" style="cursor: pointer;">Percentage <span
-                                class="sort-indicator"></span></th>
-                    </tr>
-                </thead>
-                <tbody id="cweTableBody">
-                    <!-- Table content will be populated by JavaScript -->
-                </tbody>
-            </table>
-        </div>
+<div class="grid" id="tiles"></div>
 
-        <div class="mt-3 text-center">
-            <div class="text-muted mb-2" id="paginationInfo">
-                Showing 1-25 of 68 CWEs
-            </div>
-            <!-- Custom pagination that won't be affected by CSS conflicts -->
-            <div id="customPaginationContainer" style="display:flex; justify-content:center; margin:10px 0;">
-                <!-- Custom pagination will be generated here by renderCustomPagination() -->
-            </div>
-        </div>
-    </div>
-</div>
+<h2>Most common weaknesses</h2>
+<div class="panel"><div class="panel-b"><div id="chart-cwe"></div></div></div>
 
-<!-- Export and Share Panel -->
-<div class="card mb-3">
-    <div class="card-header py-2">
-        <h2 class="card-title mb-0" style="font-size: 1.1rem;">📤 Export & Share</h2>
-    </div>
-    <div class="card-body py-3">
-        <div class="export-buttons">
-            <button class="btn btn-primary btn-sm" onclick="exportData('csv')">📊 Export CSV</button>
-            <button class="btn btn-primary btn-sm" onclick="exportData('json')">📋 Export JSON</button>
-            <button class="btn btn-secondary btn-sm" onclick="generatePermalink()">🔗 Share Link</button>
-            <button class="btn btn-secondary btn-sm" onclick="printReport()">🖨️ Print Report</button>
-        </div>
-        <div class="permalink-result mt-2" id="permalinkResult" style="display: none;">
-            <input type="text" class="form-control" id="permalinkInput" readonly>
-            <button class="btn btn-outline-primary btn-sm mt-1" onclick="copyPermalink()">Copy Link</button>
-        </div>
-    </div>
-</div>
-
-<div class="text-center text-muted mt-4">
-    <small>Last updated: <span id="lastUpdated">Loading...</span></small>
-</div>
+<h2>Every classified weakness</h2>
+<div class="panel"><div id="cwe-table"></div></div>
+{% endblock %}
 
+{% block scripts %}
 <script>
-    // Global variables
-    let cweData = null;
-    let currentYearCweData = null;
-    let isCurrentYearMode = false;
-    let currentPage = 1;
-    let itemsPerPage = 25;
-    let currentSort = { field: null, direction: 'asc' };
-    let sortedData = [];
-    let cweBarChart = null;
-    let cweCategoryChart = null;
-
-    // Load data on page load
-    document.addEventListener('DOMContentLoaded', function () {
-        loadCweData();
-    });
-
-    // Render custom pagination controls (integrated solution)
-    function renderCustomPagination() {
-        const paginationContainer = document.getElementById('customPaginationContainer');
-        if (!paginationContainer) {
-            console.error('Custom pagination container not found');
-            return;
-        }
-
-        // Clear previous pagination
-        paginationContainer.innerHTML = '';
-
-        // Get current pagination data
-        const totalPages = Math.ceil(sortedData.length / itemsPerPage);
-        if (totalPages <= 1) return;
-
-        // Previous button
-        let prevBtn = document.createElement('span');
-        prevBtn.className = currentPage === 1 ? 'disabled' : '';
-        prevBtn.innerHTML = '&laquo;';
-        prevBtn.style.cssText = 'cursor:pointer; padding:5px 12px; margin:0 5px; border:1px solid #dee2e6; border-radius:4px; user-select:none;';
-        if (prevBtn.className === 'disabled') {
-            prevBtn.style.opacity = '0.5';
-            prevBtn.style.cursor = 'not-allowed';
-        } else {
-            prevBtn.onclick = function () { currentPage--; renderTable(); };
-        }
-        paginationContainer.appendChild(prevBtn);
-
-        // Page numbers
-        for (let i = 1; i <= totalPages; i++) {
-            let pageBtn = document.createElement('span');
-            pageBtn.innerText = i;
-            pageBtn.dataset.page = i;
-            pageBtn.style.cssText = 'cursor:pointer; padding:5px 12px; margin:0 5px; border:1px solid #dee2e6; border-radius:4px; user-select:none;';
-            if (i === currentPage) {
-                pageBtn.style.backgroundColor = '#007bff';
-                pageBtn.style.color = 'white';
-                pageBtn.style.fontWeight = 'bold';
-            }
-            pageBtn.onclick = function () {
-                currentPage = parseInt(this.dataset.page);
-                renderTable();
-            };
-            paginationContainer.appendChild(pageBtn);
-        }
-
-        // Next button
-        let nextBtn = document.createElement('span');
-        nextBtn.className = currentPage === totalPages ? 'disabled' : '';
-        nextBtn.innerHTML = '&raquo;';
-        nextBtn.style.cssText = 'cursor:pointer; padding:5px 12px; margin:0 5px; border:1px solid #dee2e6; border-radius:4px; user-select:none;';
-        if (nextBtn.className === 'disabled') {
-            nextBtn.style.opacity = '0.5';
-            nextBtn.style.cursor = 'not-allowed';
-        } else {
-            nextBtn.onclick = function () { currentPage++; renderTable(); };
-        }
-        paginationContainer.appendChild(nextBtn);
-    }
-
-    async function loadCweData() {
-        try {
-            const [allDataResponse, currentYearResponse] = await Promise.all([
-                fetch('/data/cwe_analysis.json'),
-                fetch('/data/cwe_analysis_current_year.json')
-            ]);
-
-            cweData = await allDataResponse.json();
-            currentYearCweData = await currentYearResponse.json();
-
-            displayCweData(cweData);
-        } catch (error) {
-            console.error('Error loading CWE data:', error);
-        }
-    }
-
-    // Display CWE data
-    function displayCweData(data) {
-        updateStatistics(data);
-        updateCharts(data);
-        populateTable(); // Changed from updateTable to populateTable
-        updateInsights(data);
-        updateLastUpdated(data.generated_at);
-    }
-
-    // Update statistics cards
-    function updateStatistics(data) {
-        document.getElementById('totalCwes').textContent = (data.total_unique_cwes || 0).toLocaleString();
-        document.getElementById('totalCvesWithCwe').textContent = (data.total_cves_with_cwe || 0).toLocaleString();
-
-        if (data.top_cwes && data.top_cwes.length > 0) {
-            const topCwe = data.top_cwes[0];
-            const totalCvesWithCwe = data.total_cves_with_cwe || 1;
-            const topCwePercentage = ((topCwe.count / totalCvesWithCwe) * 100).toFixed(1);
-            const topCweId = `CWE-${topCwe.id}`;
-            const topCweName = topCwe.name || topCweId;
-
-            const topCweElement = document.getElementById('topCwePercentage');
-            const topCweLabelElement = document.getElementById('topCweLabel');
-
-            topCweElement.textContent = `${topCwePercentage}%`;
-            topCweLabelElement.textContent = topCweId;
-            topCweElement.title = `${topCweName}: ${topCwe.count.toLocaleString()} CVEs out of ${totalCvesWithCwe.toLocaleString()} total`;
-
-            // Calculate top 5 share
-            const top5Share = data.top_cwes.slice(0, 5).reduce((sum, cwe) => sum + cwe.count, 0);
-            const top5Percentage = ((top5Share / totalCvesWithCwe) * 100).toFixed(1);
-            document.getElementById('top5CweShare').textContent = `${top5Percentage}%`;
-        }
-    }
-
-    // Update charts
-    function updateCharts(data) {
-        if (!data.top_cwes || data.top_cwes.length === 0) return;
-
-        const chartData = data.top_cwes_limited || data.top_cwes.slice(0, 20);
-        const colors = {
-            primary: '#2563eb',
-            secondary: '#64748b',
-            accent: '#0ea5e9',
-            muted: '#94a3b8'
-        };
-
-        // Bar Chart
-        const barCtx = document.getElementById('cweBarChart');
-        if (barCtx) {
-            if (cweBarChart) {
-                cweBarChart.destroy();
-            }
-
-            cweBarChart = new Chart(barCtx, {
-                type: 'bar',
-                data: {
-                    labels: chartData.map(cwe => `CWE-${cwe.id}`),
-                    datasets: [{
-                        label: 'CVE Count',
-                        data: chartData.map(cwe => cwe.count),
-                        backgroundColor: colors.primary,
-                        borderColor: colors.primary,
-                        borderWidth: 1
-                    }]
-                },
-                options: {
-                    responsive: true,
-                    maintainAspectRatio: false,
-                    onClick: (event, elements) => {
-                        if (elements.length > 0) {
-                            const index = elements[0].index;
-                            const cwe = chartData[index];
-                            window.open(`https://cwe.mitre.org/data/definitions/${cwe.id}.html`, '_blank');
-                        }
-                    },
-                    plugins: {
-                        legend: {
-                            display: false
-                        },
-                        tooltip: {
-                            callbacks: {
-                                title: function (context) {
-                                    const cwe = chartData[context[0].dataIndex];
-                                    return cwe.name || `CWE-${cwe.id}`;
-                                },
-                                label: function (context) {
-                                    const count = context.parsed.y;
-                                    const percentage = ((count / data.total_cves_with_cwe) * 100).toFixed(1);
-                                    return `${count.toLocaleString()} CVEs (${percentage}%)`;
-                                }
-                            }
-                        }
-                    },
-                    scales: {
-                        y: {
-                            beginAtZero: true,
-                            ticks: {
-                                callback: function (value) {
-                                    return value.toLocaleString();
-                                }
-                            }
-                        },
-                        x: {
-                            ticks: {
-                                maxRotation: 45
-                            }
-                        }
-                    }
-                }
-            });
-        }
-
-        // Category Chart (simplified)
-        const categoryCtx = document.getElementById('cweCategoryChart');
-        if (categoryCtx) {
-            if (cweCategoryChart) {
-                cweCategoryChart.destroy();
-            }
-
-            const categories = {
-                'Input Validation': 0,
-                'Memory Safety': 0,
-                'Authentication & Access': 0,
-                'Injection Flaws': 0,
-                'Cryptographic Issues': 0,
-                'Other': 0
-            };
-
-            // Comprehensive CWE categorization based on CWE Research Concepts
-            chartData.forEach(cwe => {
-                const id = parseInt(cwe.id);
-
-                // Input Validation Issues (CWE-20 family)
-                if ([20, 79, 352, 601, 1284, 129, 134, 190, 200, 209, 235, 236, 242, 244, 248, 252, 253, 256, 257, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286].includes(id)) {
-                    categories['Input Validation'] += cwe.count;
-                }
-                // Memory Safety Issues (CWE-119 family)
-                else if ([119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 131, 415, 416, 476, 665, 680, 681, 682, 683, 684, 685, 686, 687, 688, 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 733, 787, 788, 789, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832, 833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848, 849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861].includes(id)) {
-                    categories['Memory Safety'] += cwe.count;
-                }
-                // Authentication & Access Control (CWE-287, CWE-862 families)
-                else if ([287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 297, 298, 299, 300, 301, 302, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 862, 863, 864, 865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880, 881, 882, 883, 884, 885, 886, 887, 888, 889, 890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900].includes(id)) {
-                    categories['Authentication & Access'] += cwe.count;
-                }
-                // Injection Flaws (CWE-74 family)
-                else if ([74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118].includes(id)) {
-                    categories['Injection Flaws'] += cwe.count;
-                }
-                // Cryptographic Issues (CWE-310 family)
-                else if ([310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320, 321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336, 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400].includes(id)) {
-                    categories['Cryptographic Issues'] += cwe.count;
-                }
-                // Everything else
-                else {
-                    categories['Other'] += cwe.count;
-                }
-            });
-
-            cweCategoryChart = new Chart(categoryCtx, {
-                type: 'doughnut',
-                data: {
-                    labels: Object.keys(categories),
-                    datasets: [{
-                        data: Object.values(categories),
-                        backgroundColor: [
-                            colors.primary,
-                            colors.accent,
-                            colors.secondary,
-                            colors.muted,
-                            '#94a3b8'
-                        ]
-                    }]
-                },
-                options: {
-                    responsive: true,
-                    maintainAspectRatio: false,
-                    plugins: {
-                        legend: {
-                            position: 'bottom'
-                        },
-                        tooltip: {
-                            callbacks: {
-                                label: function (context) {
-                                    const count = context.parsed;
-                                    const percentage = ((count / data.total_cves_with_cwe) * 100).toFixed(1);
-                                    return `${context.label}: ${count.toLocaleString()} (${percentage}%)`;
-                                }
-                            }
-                        }
-                    }
-                }
-            });
-        }
-    }
-
-    // Update insights
-    function updateInsights(data) {
-        const topCwes = data.top_cwes || [];
-        const totalCvesWithCwe = data.total_cves_with_cwe || 0;
-
-        if (topCwes.length > 0) {
-            // Most Critical insight
-            const topCwe = topCwes[0];
-            const percentage = ((topCwe.count / totalCvesWithCwe) * 100).toFixed(1);
-            document.getElementById('criticalInsight').innerHTML =
-                `<strong>CWE-${topCwe.id}</strong> dominates with <strong>${percentage}%</strong> of all classified vulnerabilities, representing ${topCwe.count.toLocaleString()} CVEs.`;
-
-            // Trend insight
-            const top3Percentage = topCwes.slice(0, 3).reduce((sum, cwe) => sum + cwe.count, 0) / totalCvesWithCwe * 100;
-            document.getElementById('trendInsight').innerHTML =
-                `Top 3 CWEs account for <strong>${top3Percentage.toFixed(1)}%</strong> of all vulnerabilities, showing high concentration in common weakness patterns.`;
-
-            // Temporal Trends insight
-            if (isCurrentYearMode && cweData && currentYearCweData) {
-                // Compare current year vs all-time data for top CWE
-                const allTimeTopCwe = cweData.top_cwes && cweData.top_cwes[0];
-                const currentYearTopCwe = currentYearCweData.top_cwes && currentYearCweData.top_cwes[0];
-
-                if (allTimeTopCwe && currentYearTopCwe && allTimeTopCwe.id === currentYearTopCwe.id) {
-                    // Same top CWE - show if it's increasing or stable
-                    const allTimePercentage = (allTimeTopCwe.count / cweData.total_cves_with_cwe) * 100;
-                    const currentYearPercentage = (currentYearTopCwe.count / currentYearCweData.total_cves_with_cwe) * 100;
-                    const change = currentYearPercentage - allTimePercentage;
-                    const changeText = change > 0 ? `increased <strong>+${change.toFixed(1)}%</strong>` :
-                        change < -0.5 ? `decreased <strong>${change.toFixed(1)}%</strong>` : 'remained stable';
-
-                    document.getElementById('temporalInsight').innerHTML =
-                        `CWE-${currentYearTopCwe.id} ${changeText} in 2025, ${change > 1 ? 'indicating growing threat patterns' : change < -1 ? 'showing improved security focus' : 'maintaining consistent threat levels'}.`;
-                } else if (currentYearTopCwe) {
-                    // Different top CWE in current year
-                    document.getElementById('temporalInsight').innerHTML =
-                        `<strong>CWE-${currentYearTopCwe.id}</strong> emerged as 2025's dominant threat, representing a shift in vulnerability patterns.`;
-                } else {
-                    document.getElementById('temporalInsight').innerHTML = 'Insufficient data for temporal analysis.';
-                }
-            } else {
-                // All-time view - show general trend insight
-                const recentTrend = topCwes.length >= 3 ?
-                    `Top 3 CWEs (${topCwes.slice(0, 3).map(c => `CWE-${c.id}`).join(', ')}) show consistent dominance across multiple years` :
-                    'Historical data shows evolving weakness patterns';
-                document.getElementById('temporalInsight').innerHTML = recentTrend + ', indicating persistent security challenges.';
-            }
-        } else {
-            document.getElementById('criticalInsight').textContent = 'No data available';
-            document.getElementById('trendInsight').textContent = 'No data available';
-            document.getElementById('temporalInsight').textContent = 'No data available';
-        }
-    }
-
-    // Populate CWE table with pagination and sorting
-    function populateTable() {
-        const data = isCurrentYearMode ? currentYearCweData : cweData;
-        if (!data || !data.top_cwes) {
-            console.error('No CWE data available');
-            return;
-        }
-
-        // Create a copy of the data for sorting
-        let dataToSort = data.top_cwes.map((cwe, index) => {
-            return {
-                rank: index + 1,
-                id: cwe.id,
-                name: cwe.name || `CWE-${cwe.id}`,
-                count: cwe.count,
-                percentage: ((cwe.count / data.total_cves_with_cwe) * 100).toFixed(2)
-            };
-        });
-
-        // Sort the data
-        sortedData = [...dataToSort].sort((a, b) => {
-            if (currentSort.field) {
-                const aValue = a[currentSort.field];
-                const bValue = b[currentSort.field];
-
-                // Handle numeric vs string sorting
-                if (typeof aValue === 'number') {
-                    return currentSort.direction === 'asc' ? aValue - bValue : bValue - aValue;
-                } else {
-                    return currentSort.direction === 'asc' ?
-                        String(aValue).localeCompare(String(bValue)) :
-                        String(bValue).localeCompare(String(aValue));
-                }
-            }
-            return 0;
-        });
-
-        // Force sortedData to have content if it's empty (failsafe)
-        if (!sortedData.length && dataToSort.length) {
-            console.warn('sortedData is empty but dataToSort has data! Forcing copy...');
-            sortedData = [...dataToSort];
-        }
-
-        renderTable();
-    }
-
-    // Render table with current sort and pagination
-    function renderTable() {
-        // Calculate indices for current page
-        const startIndex = (currentPage - 1) * itemsPerPage;
-        const endIndex = startIndex + itemsPerPage;
-        const pageData = sortedData.slice(startIndex, endIndex);
-
-        // Clear and populate table body
-        const tbody = document.getElementById('cweTableBody');
-        tbody.innerHTML = '';
-
-        pageData.forEach(cwe => {
-            const mitreUrl = `https://cwe.mitre.org/data/definitions/${cwe.id}.html`;
-
-            const row = document.createElement('tr');
-            row.innerHTML = `
-            <td><span class="badge bg-secondary">#${cwe.rank}</span></td>
-            <td><a href="${mitreUrl}" target="_blank" rel="noopener noreferrer" class="text-decoration-none"><strong>CWE-${cwe.id}</strong></a></td>
-            <td><a href="${mitreUrl}" target="_blank" rel="noopener noreferrer" class="text-decoration-none text-dark">${cwe.name}</a></td>
-            <td>${cwe.count.toLocaleString()}</td>
-            <td>${cwe.percentage}%</td>
-        `;
-            tbody.appendChild(row);
-        });
-
-        // Update pagination
-        updatePaginationInfo();
-        // Use custom pagination instead of the Bootstrap pagination
-        renderCustomPagination();
-    }
-
-    // Update pagination info text
-    function updatePaginationInfo() {
-        const startIndex = (currentPage - 1) * itemsPerPage + 1;
-        const endIndex = Math.min(currentPage * itemsPerPage, sortedData.length);
-        const totalItems = sortedData.length;
-
-        document.getElementById('paginationInfo').textContent =
-            `Showing ${startIndex}-${endIndex} of ${totalItems} CWEs`;
-    }
-
-    // Update pagination controls
-    function updatePaginationControls() {
-        const totalPages = Math.ceil(sortedData.length / itemsPerPage);
-
-        const paginationControls = document.getElementById('paginationControls');
-        if (!paginationControls) {
-            console.error('paginationControls element not found!');
-            return;
-        }
-
-        if (totalPages <= 1) {
-            console.log('Only one page, hiding pagination');
-            paginationControls.innerHTML = '';
-            return;
-        }
-
-        let paginationHTML = '';
-
-        // Previous button
-        const prevDisabled = currentPage === 1 ? 'disabled' : '';
-        paginationHTML += `<li class="page-item ${prevDisabled}"><a class="page-link" href="#" id="prevPage">&laquo;</a></li>`;
-
-        // SIMPLIFIED PAGINATION - ALWAYS SHOW ALL PAGES WITH FORCED INLINE STYLES
-        // This should ensure we see page numbers and not dots
-        console.log('Generating pagination for', totalPages, 'total pages');
-
-        for (let i = 1; i <= totalPages; i++) {
-            const active = i === currentPage ? 'active' : '';
-            // Use inline styles to force display of numbers
-            paginationHTML += `<li class="page-item ${active}" style="display: inline-block !important;"><a class="page-link" href="#" data-page="${i}" style="display: inline-block !important; min-width: 30px !important; text-align: center !important; padding: 5px 10px !important; margin: 0 2px !important; border-radius: 3px !important; text-decoration: none !important; font-weight: normal !important;">${i}</a></li>`;
-            console.log('Added page number with forced style:', i);
-        }
-
-        // Next button
-        const nextDisabled = currentPage === totalPages ? 'disabled' : '';
-        paginationHTML += `<li class="page-item ${nextDisabled}"><a class="page-link" href="#" id="nextPage">&raquo;</a></li>`;
-
-        console.log('Final pagination HTML:', paginationHTML);
-        paginationControls.innerHTML = paginationHTML;
-
-        // Add event listeners for pagination
-        setupPaginationHandlers();
-
-        // Verify HTML was set correctly
-        console.log('Actual pagination HTML after setting:', paginationControls.innerHTML);
-    }
-
-    // Setup pagination event handlers
-    function setupPaginationHandlers() {
-        // Use event delegation for better performance and reliability
-        const paginationControls = document.getElementById('paginationControls');
-
-        // Remove existing event listeners (create new one each time)
-        const newPaginationControls = paginationControls.cloneNode(true);
-        paginationControls.parentNode.replaceChild(newPaginationControls, paginationControls);
-
-        // Add new event listeners
-        newPaginationControls.addEventListener('click', (e) => {
-            e.preventDefault();
-
-            const target = e.target;
-            if (!target.classList.contains('page-link')) return;
-
-            // Handle previous button
-            if (target.id === 'prevPage') {
-                if (currentPage > 1) {
-                    currentPage--;
-                    renderTable();
-                }
-                return;
-            }
-
-            // Handle next button
-            if (target.id === 'nextPage') {
-                const totalPages = Math.ceil(sortedData.length / itemsPerPage);
-                if (currentPage < totalPages) {
-                    currentPage++;
-                    renderTable();
-                }
-                return;
-            }
-
-            // Handle page number clicks
-            const page = parseInt(target.getAttribute('data-page'));
-            if (page && page !== currentPage) {
-                currentPage = page;
-                renderTable();
-            }
-        });
-    }
-
-    // Toggle data mode
-    function toggleDataMode() {
-        isCurrentYearMode = !isCurrentYearMode;
-
-        // Update button text
-        const toggleText = document.getElementById('toggleText');
-        const pageSubtitle = document.getElementById('pageSubtitle');
-
-        if (isCurrentYearMode) {
-            toggleText.textContent = 'Switch to All Data';
-            pageSubtitle.textContent = 'Showing analysis for current year (2025)';
-        } else {
-            toggleText.textContent = 'Switch to 2025 Only';
-            pageSubtitle.textContent = 'Showing comprehensive analysis across all years (1999-2025)';
-        }
-
-        // Get the appropriate data
-        const data = isCurrentYearMode ? currentYearCweData : cweData;
-
-        if (data) {
-            // Reset pagination
-            currentPage = 1;
-            currentSort = { field: null, direction: 'asc' };
-
-            // Update all components with the correct data
-            updateStatistics(data);
-            updateCharts(data);
-            updateInsights(data);
-            populateTable();
-        }
-    }
-
-    // Export functionality
-    function exportData(format) {
-        const data = isCurrentYearMode ? currentYearCweData : cweData;
-        if (!data || !data.top_cwes) return;
-
-        const filename = `cwe_analysis_${isCurrentYearMode ? '2025' : 'all'}.${format}`;
-
-        if (format === 'csv') {
-            const csvContent = [
-                ['Rank', 'CWE ID', 'Name', 'CVE Count', 'Percentage'],
-                ...data.top_cwes.map((cwe, index) => [
-                    index + 1,
-                    `CWE-${cwe.id}`,
-                    cwe.name || `CWE-${cwe.id}`,
-                    cwe.count,
-                    ((cwe.count / data.total_cves_with_cwe) * 100).toFixed(2) + '%'
-                ])
-            ].map(row => row.join(',')).join('\n');
-
-            downloadFile(csvContent, filename, 'text/csv');
-        } else if (format === 'json') {
-            const jsonContent = JSON.stringify(data, null, 2);
-            downloadFile(jsonContent, filename, 'application/json');
-        }
-    }
-
-    // Helper function to download file
-    function downloadFile(content, filename, mimeType) {
-        const blob = new Blob([content], { type: mimeType });
-        const url = URL.createObjectURL(blob);
-        const link = document.createElement('a');
-        link.href = url;
-        link.download = filename;
-        document.body.appendChild(link);
-        link.click();
-        document.body.removeChild(link);
-        URL.revokeObjectURL(url);
-    }
-
-    // Generate permalink
-    function generatePermalink() {
-        const url = window.location.href;
-        const permalinkInput = document.getElementById('permalinkInput');
-        const permalinkResult = document.getElementById('permalinkResult');
-
-        if (permalinkInput && permalinkResult) {
-            permalinkInput.value = url;
-            permalinkResult.style.display = 'block';
-        }
-    }
-
-    // Copy permalink
-    function copyPermalink() {
-        const url = window.location.href;
-        const permalinkInput = document.getElementById('permalinkInput');
-
-        if (permalinkInput) {
-            permalinkInput.value = url;
-        }
-
-        navigator.clipboard.writeText(url).then(() => {
-            // Show temporary feedback
-            const btn = event.target;
-            const originalText = btn.innerHTML;
-            btn.innerHTML = 'Copied!';
-            btn.classList.add('btn-success');
-            btn.classList.remove('btn-outline-primary');
-
-            setTimeout(() => {
-                btn.innerHTML = originalText;
-                btn.classList.remove('btn-success');
-                btn.classList.add('btn-outline-primary');
-            }, 2000);
-        });
-    }
-
-    // Print report
-    function printReport() {
-        // Create a printable version with current data
-        const data = isCurrentYearMode ? currentYearCweData : cweData;
-        if (!data) return;
-
-        // Prepare print window
-        const printWindow = window.open('', '_blank');
-        printWindow.document.write(`
-        <html>
-        <head>
-            <title>CWE Analysis Report - CVEDB</title>
-            <style>
-                body { font-family: Arial, sans-serif; margin: 20px; }
-                h1 { color: #333; }
-                table { border-collapse: collapse; width: 100%; margin: 20px 0; }
-                th, td { padding: 8px; text-align: left; border-bottom: 1px solid #ddd; }
-                th { background-color: #f2f2f2; }
-                .stats { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin: 20px 0; }
-                .stat-card { border: 1px solid #ddd; border-radius: 5px; padding: 15px; background: #f9f9f9; }
-                .stat-number { font-size: 24px; font-weight: bold; margin-bottom: 5px; color: #0d6efd; }
-                .footer { margin-top: 30px; font-size: 12px; color: #666; text-align: center; }
-            </style>
-        </head>
-        <body>
-            <h1>CWE Analysis Report</h1>
-            <p>Generated on ${new Date().toLocaleString()}</p>
-            <p>${isCurrentYearMode ? 'Current Year (2025) Analysis' : 'Comprehensive Analysis (1999-2025)'}</p>
-            
-            <div class="stats">
-                <div class="stat-card">
-                    <div class="stat-number">${data.total_cwes}</div>
-                    <div>Total CWEs</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-number">${data.total_cves_with_cwe}</div>
-                    <div>CVEs with CWE</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-number">${data.top_cwes[0] ? ((data.top_cwes[0].count / data.total_cves_with_cwe) * 100).toFixed(1) + '%' : 'N/A'}</div>
-                    <div>${data.top_cwes[0] ? 'CWE-' + data.top_cwes[0].id : 'N/A'}</div>
-                </div>
-            </div>
-            
-            <h2>Top Common Weakness Enumerations</h2>
-            <table>
-                <thead>
-                    <tr>
-                        <th>Rank</th>
-                        <th>CWE ID</th>
-                        <th>Name</th>
-                        <th>Count</th>
-                        <th>Percentage</th>
-                    </tr>
-                </thead>
-                <tbody>
-                    ${data.top_cwes.slice(0, 20).map((cwe, index) => `
-                        <tr>
-                            <td>${index + 1}</td>
-                            <td>CWE-${cwe.id}</td>
-                            <td>${cwe.name || 'CWE-' + cwe.id}</td>
-                            <td>${cwe.count.toLocaleString()}</td>
-                            <td>${((cwe.count / data.total_cves_with_cwe) * 100).toFixed(1)}%</td>
-                        </tr>
-                    `).join('')}
-                </tbody>
-            </table>
-            
-            <div class="footer">
-                <p>Data provided by CVEDB - Common Weakness Enumeration Intelligence Dashboard</p>
-                <p>Source: National Vulnerability Database (NVD)</p>
-            </div>
-        </body>
-        </html>
-    `);
-
-        printWindow.document.close();
-        printWindow.focus();
-        setTimeout(() => {
-            printWindow.print();
-        }, 500);
-    }
-
-    // Update last updated timestamp
-    function updateLastUpdated(timestamp) {
-        if (timestamp) {
-            const date = new Date(timestamp);
-            document.getElementById('lastUpdated').textContent = date.toLocaleString();
-        }
-    }
+CVE.page(async (S) => {
+  const { fmt, chart, el, table } = CVE;
+  const d = await CVE.json('cwe_analysis.json');
+  const total = Object.values(S.yearly_summary.years).reduce((s, y) => s + y.total_cves, 0);
+  const list = d.top_cwes || [];
+  const top = list[0] || {};
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'CVEs with a weakness type', v: fmt.n(d.total_cves_with_cwe),
+      sub: `<b>${fmt.share(d.total_cves_with_cwe, total)}</b> of all ${fmt.compact(total)} CVEs` },
+    { lbl: 'Distinct weakness types', v: fmt.n(d.total_unique_cwes), sub: 'seen at least once' },
+    { lbl: 'Most common', v: fmt.compact(top.count),
+      sub: `<b>${CVE.esc(top.description || '')}</b>` },
+    { lbl: 'Top 10 share', v: fmt.share(list.slice(0, 10).reduce((s, c) => s + c.count, 0),
+        d.total_cves_with_cwe, 0),
+      sub: 'of all classified CVEs' }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  chart.hbars('#chart-cwe', list.slice(0, 15)
+    .map(c => ({ label: 'CWE-' + c.id, value: c.count })), { compact: false , name: 'cve-icu-weakness-types' });
+
+  table('#cwe-table', list.map(c => ({
+    id: 'CWE-' + c.id, name: c.description || c.name, cves: c.count,
+    share: +(c.count / d.total_cves_with_cwe * 100).toFixed(2)
+  })), [
+    { key: 'id', label: 'CWE' },
+    { key: 'name', label: 'Weakness' },
+    { key: 'cves', label: 'CVEs', num: true, bar: true },
+    { key: 'share', label: 'Share', num: true, fmt: v => v + '%' }
+  ]);
+});
 </script>
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/templates/data-quality.html b/templates/data-quality.html
new file mode 100644
index 00000000000..19042ca8309
--- /dev/null
+++ b/templates/data-quality.html
@@ -0,0 +1,133 @@
+{% extends "base.html" %}
+{% set nav = 'cna' %}
+{% block title %}Publisher name matching &mdash; CVEDB{% endblock %}
+{% block description %}How publisher names in CVE records line up with the official CNA registry.{% endblock %}
+
+{% block content %}
+<div class="ph"><h1>Publisher name matching</h1><span class="note">against the official CNA registry</span></div>
+<p class="lede">Publisher names in CVE records do not always match the official registry exactly.
+This is the count of how many line up, and how.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>How names match</h2>
+<div class="panel"><div class="panel-b"><div id="chart-match"></div></div></div>
+
+<h2>Source agreement <span class="side">two pipelines, two record sets</span></h2>
+<div class="note-box" id="recon-note">
+  Yearly counts come from the NVD mirror. Publisher attribution comes from the CVE Program's
+  own cvelistV5 repository. They are different record sets, so a year can carry two slightly
+  different totals &mdash; measured below rather than hidden.
+</div>
+<div class="panel" style="margin-top:12px"><div id="recon-table"></div></div>
+
+<h2>Names that did not match exactly</h2>
+<div class="cols c2">
+  <div class="panel"><div class="panel-h">Matched another way <span class="side" id="n-soft"></span></div>
+    <div id="soft-table"></div></div>
+  <div class="panel"><div class="panel-h">No match found <span class="side" id="n-un"></span></div>
+    <div class="rows" id="unmatched"></div></div>
+</div>
+{% endblock %}
+
+{% block scripts %}
+<script>
+CVE.page(async () => {
+  const { fmt, chart, el, table } = CVE;
+  const d = await CVE.json('data_quality.json');
+  const s = d.stats || {};
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'Publishers checked', v: fmt.n(s.total_cnas_in_analysis),
+      sub: `against <b>${fmt.n(s.official_cna_registry_count)}</b> in the official registry` },
+    { lbl: 'Exact matches', v: fmt.n(s.exact_matches),
+      sub: `<b>${fmt.share(s.exact_matches, s.total_cnas_in_analysis)}</b> of those checked` },
+    { lbl: 'Matched another way', v: fmt.n((s.case_mismatches || 0) + (s.org_name_matches || 0)
+        + (s.normalized_matches || 0) + (s.partial_matches || 0)),
+      sub: 'case, organisation name, or partial' },
+    { lbl: 'No match', v: fmt.n(s.unmatched), sub: 'not found in the registry' }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  chart.hbars('#chart-match', [
+    { label: 'Exact', value: s.exact_matches || 0 },
+    { label: 'Case differs', value: s.case_mismatches || 0 },
+    { label: 'Organisation name', value: s.org_name_matches || 0 },
+    { label: 'Normalised', value: s.normalized_matches || 0 },
+    { label: 'Partial', value: s.partial_matches || 0 },
+    { label: 'No match', value: s.unmatched || 0 }
+  ].filter(x => x.value), { name: 'cve-icu-name-match-types' });
+
+  const soft = [
+    ...(d.case_mismatches || []).map(x => ({ ...x, how: 'Case differs' })),
+    ...(d.org_name_matches || []).map(x => ({ ...x, how: 'Organisation name' })),
+    ...(d.normalized_matches || []).map(x => ({ ...x, how: 'Normalised' })),
+    ...(d.partial_matches || []).map(x => ({ ...x, how: 'Partial' }))
+  ].map(x => ({
+    name: x.cna_name,
+    match: x.official_short_name || x.official_org_name || '—',
+    org: x.official_org_name || '—',
+    cves: x.cve_count || 0,
+    how: x.how,
+    confidence: x.confidence || '—'
+  }));
+  el('#n-soft').textContent = soft.length + ' publishers';
+  if (soft.length) {
+    table('#soft-table', soft, [
+      { key: 'name', label: 'In CVE records' },
+      { key: 'match', label: 'In the registry' },
+      { key: 'org', label: 'Organisation' },
+      { key: 'cves', label: 'CVEs', num: true },
+      { key: 'how', label: 'Matched by', fmt: v => `<span class="pill">${CVE.esc(v)}</span>` },
+      { key: 'confidence', label: 'Confidence',
+        fmt: v => `<span class="pill ${v === 'high' ? 'live' : v === 'low' ? 'warn' : ''}">${CVE.esc(v)}</span>` }
+    ], { sort: { key: 'cves', dir: -1 } }, { name: 'cve-icu-soft-matched-publishers' });
+  } else {
+    el('#soft-table').innerHTML = '<div class="empty">Every name matched exactly.</div>';
+  }
+
+  // per-year agreement between the NVD and V5 pipelines
+  try {
+    const r = await CVE.json('source_reconciliation.json');
+    const flagged = new Set(r.flagged_years || []);
+    table('#recon-table', (r.years || []).map(y => ({
+      year: y.year, nvd: y.nvd, v5: y.v5, delta: y.delta, pct: y.pct,
+      era: y.modern ? 'modern' : 'historical',
+      state: flagged.has(y.year) ? 'over threshold' : (y.delta === 0 ? 'identical' : 'within threshold')
+    })), [
+      { key: 'year', label: 'Year', num: true, raw: true },
+      { key: 'nvd', label: 'NVD count', num: true },
+      { key: 'v5', label: 'V5 count', num: true },
+      { key: 'delta', label: 'Difference', num: true,
+        fmt: v => v === 0 ? '<span class="faint">0</span>'
+          : `<span style="color:var(--${Math.abs(v) > 200 ? 'warn' : 'dim'})">${v > 0 ? '+' : ''}${fmt.n(v)}</span>` },
+      { key: 'pct', label: '%', num: true,
+        fmt: v => v === 0 ? '<span class="faint">0</span>' : v.toFixed(2) + '%' },
+      { key: 'era', label: 'Era',
+        fmt: v => `<span class="pill${v === 'historical' ? '' : ' live'}">${v}</span>` },
+      { key: 'state', label: 'Status',
+        fmt: v => `<span class="pill${v === 'over threshold' ? ' warn' : ''}">${CVE.esc(v)}</span>` }
+    ], { sort: { key: 'year', dir: -1 } }, { name: 'cve-icu-source-agreement-by-year' });
+
+    const t = r.totals || {};
+    el('#recon-note').insertAdjacentHTML('beforeend',
+      `<p style="margin-top:9px">Across all years: NVD <b>${fmt.n(t.nvd)}</b>,
+       cvelistV5 <b>${fmt.n(t.v5)}</b>, a difference of <b>${t.delta > 0 ? '+' : ''}${fmt.n(t.delta)}</b>.
+       Years before ${r.thresholds.modern_year_floor} predate the current publishing arrangements and
+       are recorded but not held to a threshold; from ${r.thresholds.modern_year_floor} on, a year must
+       agree within ${r.thresholds.max_abs} CVEs or ${r.thresholds.max_pct}% or the build warns.
+       ${flagged.size ? `<b style="color:var(--warn)">${flagged.size} year(s) currently over threshold.</b>`
+         : 'All modern years are currently within threshold.'}</p>`);
+  } catch (err) {
+    el('#recon-table').innerHTML = '<div class="empty">Reconciliation data not available.</div>';
+  }
+
+  const un = (d.unmatched || []).map(x => ({
+    label: x.cna_name, value: x.cve_count || 0
+  }));
+  el('#n-un').textContent = un.length + ' publishers';
+  if (un.length) chart.rank('#unmatched', un.sort((a, b) => b.value - a.value), { name: 'cve-icu-unmatched-publishers' });
+  else el('#unmatched').innerHTML = '<div class="empty">Nothing unmatched.</div>';
+});
+</script>
+{% endblock %}
diff --git a/templates/epss.html b/templates/epss.html
index 2c8a77991cf..9a8b45ec03c 100644
--- a/templates/epss.html
+++ b/templates/epss.html
@@ -1,476 +1,87 @@
 {% extends "base.html" %}
-
-{% block title %}EPSS Analysis - CVEDB{% endblock %}
+{% set nav = 'scoring' %}
+{% block title %}EPSS scores &mdash; CVEDB{% endblock %}
+{% block description %}How many CVEs carry each EPSS exploit-probability score band.{% endblock %}
 
 {% block content %}
-<style>
-    .stats-grid {
-        display: grid;
-        grid-template-columns: repeat(4, 1fr);
-        gap: 1.5rem;
-        margin-bottom: 2rem;
-    }
-
-    @media (max-width: 992px) {
-        .stats-grid {
-            grid-template-columns: repeat(2, 1fr);
-        }
-    }
-
-    @media (max-width: 576px) {
-        .stats-grid {
-            grid-template-columns: 1fr;
-        }
-    }
-
-    .chart-container {
-        position: relative;
-        height: 350px;
-    }
-
-    .high-risk-table {
-        max-height: 400px;
-        overflow-y: auto;
-    }
-
-    .high-risk-table table {
-        width: 100%;
-        border-collapse: separate;
-        border-spacing: 0;
-    }
-
-    .high-risk-table thead {
-        position: sticky;
-        top: 0;
-        z-index: 10;
-    }
-
-    .high-risk-table th {
-        background: var(--color-bg-content, #ffffff);
-        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
-        padding: 0.75rem;
-        font-weight: 600;
-        border-bottom: 2px solid var(--color-border);
-    }
-
-    .epss-bar {
-        height: 8px;
-        background: var(--color-border);
-        border-radius: 4px;
-        overflow: hidden;
-    }
-
-    .epss-bar-fill {
-        height: 100%;
-        border-radius: 4px;
-        transition: width 0.3s;
-    }
-
-    .epss-very-high {
-        background: #ef4444;
-    }
-
-    .epss-high {
-        background: #f97316;
-    }
-
-    .epss-medium {
-        background: #eab308;
-    }
-
-    .epss-low {
-        background: #22c55e;
-    }
-
-    /* Threshold Guide Styles */
-    .threshold-guide {
-        background: var(--color-bg-secondary);
-        border-radius: var(--border-radius-lg);
-        padding: 1.25rem;
-    }
-
-    .threshold-item {
-        display: flex;
-        justify-content: space-between;
-        align-items: center;
-        padding: 0.75rem 0;
-        border-bottom: 1px solid var(--color-border);
-    }
-
-    .threshold-item:last-child {
-        border-bottom: none;
-        padding-bottom: 0;
-    }
-
-    .threshold-item:first-of-type {
-        padding-top: 0;
-    }
-
-    .threshold-header {
-        display: flex;
-        align-items: center;
-        gap: 0.75rem;
-    }
-
-    .threshold-badge {
-        display: inline-block;
-        padding: 0.25rem 0.5rem;
-        border-radius: var(--border-radius);
-        font-size: 0.8rem;
-        font-weight: 600;
-        color: white;
-        min-width: 50px;
-        text-align: center;
-    }
+<div class="ph"><h1>EPSS scores</h1><span class="note">exploit probability, from FIRST</span></div>
+<p class="lede">EPSS gives each CVE a probability of exploitation in the next 30 days. Counts of
+how many sit in each band &mdash; the distribution is heavily weighted to the bottom.</p>
 
-    .threshold-badge.critical {
-        background: rgba(13, 110, 253, 1);
-    }
+<div class="grid" id="tiles"></div>
 
-    .threshold-badge.high {
-        background: rgba(33, 150, 243, 0.9);
-    }
+<h2>Score bands</h2>
+<div class="panel"><div class="panel-b"><div id="buckets"></div></div></div>
 
-    .threshold-badge.elevated {
-        background: rgba(100, 181, 246, 0.9);
-    }
+<h2>CVEs above each threshold</h2>
+<div class="panel"><div class="panel-b"><div id="thresholds"></div></div></div>
 
-    .threshold-badge.monitor {
-        background: rgba(144, 202, 249, 0.9);
-    }
-
-    .threshold-label {
-        font-weight: 500;
-        color: var(--color-text-secondary);
-        font-size: 0.9rem;
-    }
-
-    .threshold-count {
-        font-size: 1.1rem;
-        font-weight: 600;
-        color: var(--color-text-primary);
-    }
-</style>
-
-<!-- Hero Section -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">EPSS Analysis</h1>
-    <p class="text-muted">
-        Exploit Prediction Scoring System - Predicting exploitation likelihood
-    </p>
-</div>
-
-<!-- Stats Cards -->
-<div class="stats-grid mb-4">
-    <div class="stat-card">
-        <div class="stat-number" id="totalEpss">-</div>
-        <div class="stat-label">Total CVEs with EPSS</div>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="epssGt01">-</div>
-        <div class="stat-label">EPSS &gt; 0.1</div>
-        <small class="text-muted">Higher exploitation likelihood</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="epssGt05">-</div>
-        <div class="stat-label">EPSS &gt; 0.5</div>
-        <small class="text-muted">Very high exploitation likelihood</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="avgEpss">-</div>
-        <div class="stat-label">Average Score</div>
-        <small class="text-muted">Across all CVEs</small>
-    </div>
+<h2>Scored CVEs per year</h2>
+<div class="panel">
+  <div class="panel-h">How many CVEs from each year carry an EPSS score</div>
+  <div class="panel-b"><div id="coverage"></div></div>
 </div>
 
-<!-- Distribution Chart -->
-<div class="card mb-4">
-    <div class="card-header">
-        <h3 class="card-title mb-0">Score Distribution</h3>
-        <small class="text-muted">CVEs by EPSS probability bucket</small>
-    </div>
-    <div class="card-body">
-        <div class="chart-container">
-            <canvas id="scoreDistributionChart"></canvas>
-        </div>
-    </div>
-</div>
-
-<!-- Threshold Analysis -->
-<div class="card mb-4">
-    <div class="card-header">
-        <h3 class="card-title mb-0">Threshold Analysis</h3>
-        <small class="text-muted">CVE counts at various EPSS thresholds</small>
-    </div>
-    <div class="card-body">
-        <div class="row align-items-center">
-            <div class="col-lg-8 col-md-7">
-                <div class="chart-container" style="height: 280px;">
-                    <canvas id="thresholdChart"></canvas>
-                </div>
-            </div>
-            <div class="col-lg-4 col-md-5">
-                <div class="threshold-guide">
-                    <h5 class="mb-3">Threshold Guide</h5>
-                    <div class="threshold-item">
-                        <div class="threshold-header">
-                            <span class="threshold-badge critical">> 0.7</span>
-                            <span class="threshold-label">Critical</span>
-                        </div>
-                        <div class="threshold-count" id="gt07Count">-</div>
-                    </div>
-                    <div class="threshold-item">
-                        <div class="threshold-header">
-                            <span class="threshold-badge high">> 0.5</span>
-                            <span class="threshold-label">High</span>
-                        </div>
-                        <div class="threshold-count" id="gt05Count">-</div>
-                    </div>
-                    <div class="threshold-item">
-                        <div class="threshold-header">
-                            <span class="threshold-badge elevated">> 0.3</span>
-                            <span class="threshold-label">Elevated</span>
-                        </div>
-                        <div class="threshold-count" id="gt03Count">-</div>
-                    </div>
-                    <div class="threshold-item">
-                        <div class="threshold-header">
-                            <span class="threshold-badge monitor">> 0.1</span>
-                            <span class="threshold-label">Monitor</span>
-                        </div>
-                        <div class="threshold-count" id="gt01Count">-</div>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- High Risk CVEs Table -->
-<div class="card mb-4">
-    <div class="card-header">
-        <h3 class="card-title mb-0">Highest Risk CVEs</h3>
-        <small class="text-muted">Top 100 CVEs by EPSS score</small>
-    </div>
-    <div class="card-body p-0">
-        <div class="high-risk-table">
-            <table class="table table-striped mb-0">
-                <thead>
-                    <tr>
-                        <th>CVE ID</th>
-                        <th>EPSS Score</th>
-                        <th>Percentile</th>
-                        <th>Risk Level</th>
-                    </tr>
-                </thead>
-                <tbody id="highRiskTable">
-                    <tr>
-                        <td colspan="4" class="text-center">Loading...</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-    </div>
-</div>
+<h2>Highest-scoring CVEs</h2>
+<div class="panel"><div id="high-table"></div></div>
+{% endblock %}
 
-<!-- About EPSS -->
-<div class="card">
-    <div class="card-header">
-        <h3 class="card-title mb-0">About EPSS</h3>
-    </div>
-    <div class="card-body">
-        <p>
-            The <strong>Exploit Prediction Scoring System (EPSS)</strong> is a data-driven effort
-            for estimating the probability that a vulnerability will be exploited in the wild
-            within 30 days of public disclosure.
-        </p>
-        <ul>
-            <li><strong>Score Range:</strong> 0.0 to 1.0 (probability of exploitation)</li>
-            <li><strong>Percentile:</strong> Ranking relative to all other CVEs (shown as %)</li>
-            <li><strong>Updated:</strong> Daily</li>
-            <li><strong>Source:</strong> <a href="https://www.first.org/epss/" target="_blank">FIRST.org EPSS</a></li>
-        </ul>
-        <p class="text-muted mb-0">
-            EPSS complements CVSS by providing a probability of exploitation, helping prioritize
-            which vulnerabilities to patch first based on real-world threat data.
-        </p>
-    </div>
-</div>
-
-<script src="static/js/chart.min.js"></script>
+{% block scripts %}
 <script>
-    fetch('data/epss_analysis.json')
-        .then(r => r.json())
-        .then(data => {
-            // Update stats cards
-            document.getElementById('totalEpss').textContent =
-                data.total_cves_with_epss.toLocaleString();
-            document.getElementById('epssGt01').textContent =
-                data.statistics.gt_0_1.toLocaleString();
-            document.getElementById('epssGt05').textContent =
-                data.statistics.gt_0_5.toLocaleString();
-            document.getElementById('avgEpss').textContent =
-                data.statistics.average_score.toFixed(4);
-
-            // Update threshold counts
-            document.getElementById('gt07Count').textContent =
-                data.statistics.gt_0_7.toLocaleString();
-            document.getElementById('gt05Count').textContent =
-                data.statistics.gt_0_5.toLocaleString();
-            document.getElementById('gt03Count').textContent =
-                data.statistics.gt_0_3.toLocaleString();
-            document.getElementById('gt01Count').textContent =
-                data.statistics.gt_0_1.toLocaleString();
-
-            // Score Distribution Chart
-            const bucketLabels = ['< 0.01', '0.01-0.1', '0.1-0.3', '0.3-0.5', '0.5-0.7', '0.7-1.0'];
-            const bucketData = [
-                data.score_buckets.very_low,
-                data.score_buckets.low,
-                data.score_buckets.medium,
-                data.score_buckets.high,
-                data.score_buckets.very_high,
-                data.score_buckets.critical
-            ];
-
-            new Chart(document.getElementById('scoreDistributionChart'), {
-                type: 'bar',
-                data: {
-                    labels: bucketLabels,
-                    datasets: [{
-                        label: 'CVE Count',
-                        data: bucketData,
-                        backgroundColor: [
-                            'rgba(187, 222, 251, 0.9)',  // Lightest blue
-                            'rgba(144, 202, 249, 0.9)',
-                            'rgba(100, 181, 246, 0.9)',
-                            'rgba(66, 165, 245, 0.9)',
-                            'rgba(33, 150, 243, 0.9)',
-                            'rgba(13, 110, 253, 0.9)'   // Primary blue (darkest)
-                        ],
-                        borderColor: [
-                            'rgba(144, 202, 249, 1)',
-                            'rgba(100, 181, 246, 1)',
-                            'rgba(66, 165, 245, 1)',
-                            'rgba(33, 150, 243, 1)',
-                            'rgba(25, 118, 210, 1)',
-                            'rgba(13, 110, 253, 1)'
-                        ],
-                        borderWidth: 1
-                    }]
-                },
-                options: {
-                    responsive: true,
-                    maintainAspectRatio: false,
-                    plugins: {
-                        legend: { display: false }
-                    },
-                    scales: {
-                        x: {
-                            title: {
-                                display: true,
-                                text: 'EPSS Score Range (0.0 - 1.0)',
-                                font: { size: 12, weight: '600' }
-                            }
-                        },
-                        y: {
-                            beginAtZero: true,
-                            title: {
-                                display: true,
-                                text: 'Number of CVEs',
-                                font: { size: 12, weight: '600' }
-                            },
-                            ticks: {
-                                callback: v => v.toLocaleString()
-                            }
-                        }
-                    }
-                }
-            });
-
-            // Threshold Chart
-            new Chart(document.getElementById('thresholdChart'), {
-                type: 'bar',
-                data: {
-                    labels: ['> 0.1', '> 0.3', '> 0.5', '> 0.7', '> 0.9'],
-                    datasets: [{
-                        label: 'CVEs Above Threshold',
-                        data: [
-                            data.statistics.gt_0_1,
-                            data.statistics.gt_0_3,
-                            data.statistics.gt_0_5,
-                            data.statistics.gt_0_7,
-                            data.statistics.gt_0_9
-                        ],
-                        backgroundColor: [
-                            'rgba(144, 202, 249, 0.9)',
-                            'rgba(100, 181, 246, 0.9)',
-                            'rgba(66, 165, 245, 0.9)',
-                            'rgba(33, 150, 243, 0.9)',
-                            'rgba(13, 110, 253, 0.9)'
-                        ],
-                        borderColor: [
-                            'rgba(100, 181, 246, 1)',
-                            'rgba(66, 165, 245, 1)',
-                            'rgba(33, 150, 243, 1)',
-                            'rgba(25, 118, 210, 1)',
-                            'rgba(13, 110, 253, 1)'
-                        ],
-                        borderWidth: 1
-                    }]
-                },
-                options: {
-                    responsive: true,
-                    maintainAspectRatio: false,
-                    indexAxis: 'y',
-                    plugins: {
-                        legend: { display: false }
-                    },
-                    scales: {
-                        x: {
-                            beginAtZero: true,
-                            ticks: {
-                                callback: v => v.toLocaleString()
-                            }
-                        }
-                    }
-                }
-            });
-
-            // High Risk Table
-            const tbody = document.getElementById('highRiskTable');
-            tbody.innerHTML = data.high_risk_cves.map(cve => {
-                const score = cve.epss_score;
-                let riskClass = 'epss-low';
-                let riskLabel = 'Low';
-                if (score >= 0.7) { riskClass = 'epss-very-high'; riskLabel = 'Critical'; }
-                else if (score >= 0.5) { riskClass = 'epss-high'; riskLabel = 'High'; }
-                else if (score >= 0.3) { riskClass = 'epss-medium'; riskLabel = 'Medium'; }
-
-                return `
-                <tr>
-                    <td>
-                        <a href="https://nvd.nist.gov/vuln/detail/${cve.cve_id}" target="_blank">
-                            ${cve.cve_id}
-                        </a>
-                    </td>
-                    <td>
-                        <div class="d-flex align-items-center gap-2">
-                            <div class="epss-bar flex-grow-1">
-                                <div class="epss-bar-fill ${riskClass}" style="width: ${score * 100}%"></div>
-                            </div>
-                            <span>${score.toFixed(4)}</span>
-                        </div>
-                    </td>
-                    <td>${(cve.epss_percentile * 100).toFixed(1)}%</td>
-                    <td><span class="badge ${riskClass === 'epss-very-high' ? 'bg-danger' : riskClass === 'epss-high' ? 'bg-warning text-dark' : 'bg-info'}">${riskLabel}</span></td>
-                </tr>
-            `;
-            }).join('');
-        })
-        .catch(err => {
-            console.error('Failed to load EPSS data:', err);
-        });
+CVE.page(async (S) => {
+  const { fmt, chart, el, table } = CVE;
+  const YR = {{ current_year }};
+  const d = await CVE.json('epss_analysis.json');
+  const st = d.statistics || {};
+  // Two different populations, kept apart deliberately:
+  //  - matched: EPSS rows tied to a CVE this site counts. Comparable with every
+  //    other total on the site, so it is the headline.
+  //  - rows: every EPSS row, which is what the threshold statistics are computed
+  //    over, so it must be the denominator for their percentages.
+  const rows = d.total_cves_with_epss || 0;
+  const unmatched = d.epss_without_published_record || 0;
+  const total = d.total_cves_with_epss_matched ?? rows;
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'CVEs with an EPSS score', v: fmt.n(total),
+      sub: `average score <b>${(st.average_score ?? 0).toFixed(5)}</b>${unmatched
+        ? ` &middot; <b>${fmt.n(unmatched)}</b> further EPSS rows describe CVEs not counted here` : ''}` },
+    { lbl: 'Above 0.5', v: fmt.n(st.gt_0_5), sub: `<b>${fmt.share(st.gt_0_5, rows, 2)}</b> of scored rows` },
+    { lbl: 'Above 0.9', v: fmt.n(st.gt_0_9), sub: `<b>${fmt.share(st.gt_0_9, rows, 2)}</b> of scored rows` },
+    { lbl: 'Above 0.1', v: fmt.n(st.gt_0_1), sub: `<b>${fmt.share(st.gt_0_1, rows, 2)}</b> of scored rows` }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  const labels = {
+    very_low: 'Very low', low: 'Low', medium: 'Medium',
+    high: 'High', very_high: 'Very high', critical: 'Critical'
+  };
+  chart.hbars('#buckets', Object.entries(d.score_buckets || {})
+    .map(([k, v]) => ({ label: labels[k] || k, value: v })), { name: 'cve-icu-epss-bands' });
+
+  chart.hbars('#thresholds', [
+    { label: '> 0.1', value: st.gt_0_1 || 0 },
+    { label: '> 0.3', value: st.gt_0_3 || 0 },
+    { label: '> 0.5', value: st.gt_0_5 || 0 },
+    { label: '> 0.7', value: st.gt_0_7 || 0 },
+    { label: '> 0.9', value: st.gt_0_9 || 0 }
+  ], { name: 'cve-icu-epss-thresholds' });
+
+  const cov = d.year_coverage || {};
+  const years = Object.keys(cov).sort();
+  chart.bars('#coverage', years.map(y => ({
+    label: y, value: cov[y].with_epss || 0, current: +y === YR
+  })), { ticks: [years[0], years[years.length - 1]] , name: 'cve-icu-epss-coverage-per-year' });
+
+  table('#high-table', (d.high_risk_cves || []).slice(0, 50).map(c => ({
+    cve: c.cve_id,
+    score: c.epss_score,
+    pct: c.epss_percentile
+  })), [
+    { key: 'cve', label: 'CVE' },
+    { key: 'score', label: 'EPSS score', num: true, fmt: v => (+v).toFixed(5) },
+    { key: 'pct', label: 'Percentile', num: true, fmt: v => (v * 100).toFixed(3) + '%' }
+  ], { sort: { key: 'score', dir: -1 } }, { name: 'cve-icu-epss-highest-scoring' });
+});
 </script>
-
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/templates/growth.html b/templates/growth.html
index f16d4312019..609f6c64411 100644
--- a/templates/growth.html
+++ b/templates/growth.html
@@ -1,792 +1,85 @@
 {% extends "base.html" %}
-
-{% block title %}{{ title }}{% endblock %}
+{% set nav = 'years' %}
+{% block title %}Year-over-year change &mdash; CVEDB{% endblock %}
+{% block description %}How CVE publication counts changed from one year to the next, 1999 to {{ current_year }}.{% endblock %}
 
 {% block content %}
-<style>
-.stats-grid {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
-    gap: 1rem;
-    margin-bottom: 2rem;
-}
-
-.chart-container {
-    position: relative;
-    width: 100%;
-}
-
-/* Active button styling for better visual indication */
-.quick-select-btn.active {
-    background-color: #3b82f6 !important;
-    color: white !important;
-    border-color: #2563eb !important;
-}
-
-.quick-select-btn:hover {
-    background-color: #60a5fa;
-    color: white;
-    border-color: #3b82f6;
-}
-</style>
-
-<!-- Hero Section -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">Growth Intelligence Dashboard</h1>
-    <small class="text-muted d-block mb-3" id="pageSubtitle">
-        Showing comprehensive growth analysis across all years (1999-2025)
-    </small>
-    
-    <!-- Note about historical data requirement -->
-    <div class="d-flex justify-content-center mb-3">
-        <div class="text-muted small">
-            <i class="fas fa-info-circle me-1"></i>
-            Growth analysis shows comprehensive trends across all years (1999-2025)
-        </div>
-    </div>
-</div>
-
-<!-- Statistics Cards -->
-<div class="stats-grid mb-4">
-    <div class="stat-card">
-        <div class="stat-number" id="totalCvesCount">-</div>
-        <div class="stat-label">Total CVEs</div>
-        <small class="text-muted" style="font-size: 0.75rem;" id="totalCvesSubtext">📊 Loading...</small>
-    </div>
-    
-    <div class="stat-card">
-        <div class="stat-number" id="avgGrowthRate">-</div>
-        <div class="stat-label">Average Annual Growth</div>
-        <small class="text-muted" style="font-size: 0.75rem;" id="avgGrowthSubtext">📈 Loading...</small>
-    </div>
-    
-    <div class="stat-card">
-        <div class="stat-number" id="peakGrowthYear">-</div>
-        <div class="stat-label">Peak Growth Year</div>
-        <small class="text-muted" style="font-size: 0.75rem;" id="peakGrowthSubtext">🚀 Loading...</small>
-    </div>
-    
-    <div class="stat-card">
-        <div class="stat-number" id="ytdComparison">-</div>
-        <div class="stat-label">Year-to-Date Growth</div>
-        <small class="text-muted" style="font-size: 0.75rem;" id="ytdSubtext">📅 Loading...</small>
-    </div>
-</div>
-
-<!-- Charts Section -->
-<div class="row g-4 mb-4">
-    <!-- CVE Growth Trends Chart -->
-    <div class="col-lg-8">
-        <div class="card mb-4">
-            <div class="card-header py-2 d-flex justify-content-between align-items-center">
-                <h3 class="card-title mb-0" style="font-size: 1.1rem;">
-                    <i class="fas fa-chart-line me-2"></i>CVE Growth Trends Over Time
-                </h3>
-                <div class="chart-controls">
-                    <div class="btn-group btn-group-sm" role="group">
-                        <button type="button" class="btn btn-outline-secondary active quick-select-btn" id="absoluteBtn" onclick="toggleGrowthView('absolute')">
-                            <i class="fas fa-chart-bar me-1"></i>Absolute
-                        </button>
-                        <button type="button" class="btn btn-outline-secondary quick-select-btn" id="rateBtn" onclick="toggleGrowthView('rate')">
-                            <i class="fas fa-percentage me-1"></i>Growth Rate
-                        </button>
-                    </div>
-                </div>
-            </div>
-            <div class="card-body">
-                <div class="chart-container" style="height: 400px;">
-                    <canvas id="growthTrendsChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-    
-    <!-- Growth Rate Distribution Chart -->
-    <div class="col-lg-4">
-        <div class="card mb-4">
-            <div class="card-header py-2">
-                <h3 class="card-title mb-0" style="font-size: 1.1rem;">
-                    <i class="fas fa-chart-bar me-2"></i>Growth Rate Distribution
-                </h3>
-            </div>
-            <div class="card-body">
-                <div class="chart-container" style="height: 400px;">
-                    <canvas id="growthDistributionChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
+<div class="ph">
+  <h1>Year-over-year change</h1>
+  <span class="note">1999&ndash;{{ current_year }}</span>
 </div>
+<p class="lede">The same counts as <a href="years.html" style="color:var(--accent)">Years</a>,
+expressed as change. {{ current_year }} is partial, so it is shown against both the same point
+last year and last year's completed total &mdash; those answer different questions.</p>
 
-<!-- Cumulative Growth Chart -->
-<div class="row mb-4">
-    <div class="col-12">
-        <div class="card mb-4">
-            <div class="card-header py-2">
-                <h3 class="card-title mb-0" style="font-size: 1.1rem;">
-                    <i class="fas fa-chart-area me-2"></i>Cumulative CVE Growth
-                </h3>
-            </div>
-            <div class="card-body">
-                <div class="chart-container" style="height: 350px;">
-                    <canvas id="cumulativeGrowthChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
+<div class="grid" id="tiles"></div>
 
-<!-- Growth Insights Panel -->
-<div class="card mb-4">
-    <div class="card-header py-2">
-        <h3 class="card-title" style="font-size: 1.1rem;">🔍 Growth Intelligence Insights</h3>
-    </div>
-    <div class="card-body py-3">
-        <div class="row" id="growthInsights">
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">📈</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Highest Growth</div>
-                        <div class="insight-text" id="highestGrowthInsight">Loading...</div>
-                    </div>
-                </div>
-            </div>
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">📉</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Lowest Growth</div>
-                        <div class="insight-text" id="lowestGrowthInsight">Loading...</div>
-                    </div>
-                </div>
-            </div>
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">📊</div>
-                    <div class="insight-content">
-                        <div class="insight-title">Trend Analysis</div>
-                        <div class="insight-text" id="trendAnalysisInsight">Loading...</div>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
+<h2>Change per year</h2>
+<div class="panel">
+  <div class="panel-h">Percent change against the prior year
+    <span class="side">bars above the line are increases</span></div>
+  <div class="panel-b"><div id="chart-growth"></div></div>
 </div>
 
-<!-- Growth Data Table -->
-<div class="row mb-4">
-    <div class="col-12">
-        <div class="card mb-4">
-            <div class="card-header py-2">
-                <h3 class="card-title mb-0" style="font-size: 1.1rem;">
-                    <i class="fas fa-table me-2"></i>Year-over-Year Growth Data
-                </h3>
-            </div>
-            <div class="card-body p-0">
-                <div class="table-responsive">
-                    <table class="table table-hover mb-0">
-                        <thead>
-                            <tr>
-                                <th>Year</th>
-                                <th>Total CVEs</th>
-                                <th>Growth Rate</th>
-                                <th>Absolute Change</th>
-                                <th>3-Year Avg</th>
-                            </tr>
-                        </thead>
-                        <tbody id="growthTableBody">
-                            <tr>
-                                <td colspan="5" class="text-center text-muted">Loading growth data...</td>
-                            </tr>
-                        </tbody>
-                    </table>
-                </div>
-            </div>
-        </div>
-    </div>
+<h2>Absolute counts</h2>
+<div class="panel">
+  <div class="panel-h">CVEs added compared with the year before</div>
+  <div class="panel-b"><div id="chart-abs"></div></div>
 </div>
 
-<!-- Export and Share Panel -->
-<div class="card mb-3">
-    <div class="card-header py-2">
-        <h2 class="card-title mb-0" style="font-size: 1.1rem;">📤 Export & Share</h2>
-    </div>
-    <div class="card-body py-3">
-        <div class="export-buttons">
-            <button class="btn btn-primary btn-sm" onclick="exportData('csv')">📊 Export CSV</button>
-            <button class="btn btn-primary btn-sm" onclick="exportData('json')">📋 Export JSON</button>
-            <button class="btn btn-secondary btn-sm" onclick="copyPermalink()">🔗 Copy Permalink</button>
-            <button class="btn btn-secondary btn-sm" onclick="window.print()">🖨️ Print Report</button>
-        </div>
-        <div class="permalink-result mt-2" id="permalinkResult" style="display: none;">
-            <input type="text" class="form-control" id="permalinkInput" readonly>
-            <button class="btn btn-outline-primary btn-sm mt-1" onclick="copyPermalink()">Copy Link</button>
-        </div>
-    </div>
-</div>
+<h2>All years</h2>
+<div class="panel"><div id="growth-table"></div></div>
 {% endblock %}
 
 {% block scripts %}
-<script src="https://cdn.jsdelivr.net/npm/chart.js@4.4.0/dist/chart.min.js"></script>
 <script>
-// Global variables
-let currentGrowthView = 'absolute';
-let growthData = null;
-let charts = {};
-
-// Light blue/gray color palette
-const colorPalette = {
-    primary: '#60a5fa',      // Light blue
-    secondary: '#93c5fd',    // Lighter blue
-    tertiary: '#bfdbfe',     // Very light blue
-    accent: '#3b82f6',       // Standard blue
-    gray: '#9ca3af',         // Light gray
-    lightGray: '#d1d5db',    // Very light gray
-    success: '#10b981',      // Green
-    warning: '#f59e0b',      // Orange
-    danger: '#ef4444',       // Red
-    info: '#06b6d4'          // Cyan
-};
-
-// Initialize page
-document.addEventListener('DOMContentLoaded', function() {
-    loadGrowthData();
+CVE.page(async (S) => {
+  const { fmt, chart, el, table } = CVE;
+  const YR = {{ current_year }};
+  const g = await CVE.json('growth_analysis.json');
+  const data = g.growth_data || [];
+  const cur = data.find(d => d.is_ytd) || data[data.length - 1] || {};
+  const prevFull = (data.find(d => d.year === YR - 1) || {}).cves;
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: `${YR} so far`, v: fmt.n(cur.cves),
+      sub: `projected full year <b>${fmt.compact(cur.projected_full_year)}</b>` },
+    { lbl: `vs same point in ${YR - 1}`, v: fmt.pct(cur.ytd_vs_prev_ytd),
+      sub: `against <b>${fmt.n(cur.prev_year_ytd_actual)}</b> by this date` },
+    { lbl: `vs all of ${YR - 1}`, v: fmt.pct(cur.ytd_vs_prev_full),
+      sub: `against <b>${fmt.n(prevFull)}</b> for the full year` },
+    { lbl: 'Average annual change', v: fmt.pct(g.avg_annual_growth),
+      sub: 'across all years on record' }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}">
+      <div class="lbl">${t.lbl}</div><div class="v">${t.v}</div>
+      <div class="sub">${t.sub}</div></div>`).join('');
+
+  const withPrev = data.filter(d => d.year > 1999);
+  chart.bars('#chart-growth', withPrev.map(d => ({
+    label: String(d.year), value: Math.abs(d.growth_rate || 0),
+    current: d.year === YR, alt: (d.growth_rate || 0) < 0
+  })), { tall: true, ticks: ['2000', String(YR)] , name: 'cve-icu-yearly-change' });
+
+  chart.bars('#chart-abs', withPrev.map(d => ({
+    label: String(d.year), value: Math.abs(d.growth_absolute || 0),
+    current: d.year === YR, alt: (d.growth_absolute || 0) < 0
+  })), { ticks: ['2000', String(YR)] , name: 'cve-icu-yearly-change-absolute' });
+
+  table('#growth-table', data.slice().reverse().map(d => ({
+    year: d.year, cves: d.cves,
+    rate: d.growth_rate == null ? null : d.growth_rate,
+    abs: d.growth_absolute,
+    partial: d.is_ytd ? 'year to date' : ''
+  })), [
+    { key: 'year', label: 'Year', num: true, raw: true },
+    { key: 'cves', label: 'CVEs', num: true, bar: true },
+    { key: 'rate', label: 'Change', num: true,
+      fmt: v => v == null ? '<span class="faint">&mdash;</span>'
+        : `<span style="color:var(--${v > 0 ? 'live' : 'hot'})">${fmt.pct(v)}</span>` },
+    { key: 'abs', label: 'CVEs added', num: true,
+      fmt: v => v == null ? '&mdash;' : (v > 0 ? '+' : '') + fmt.n(v) },
+    { key: 'partial', label: '', fmt: v => v ? `<span class="pill warn">${v}</span>` : '' }
+  ], { sort: { key: 'year', dir: -1 } }, { name: 'cve-icu-growth-by-year' });
 });
-
-// Load growth data
-function loadGrowthData() {
-    fetch('/data/growth_analysis.json')
-        .then(response => {
-            if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-            }
-            return response.json();
-        })
-        .then(data => {
-            growthData = data;
-            updateStatsCards(data);
-            updateGrowthTrendsChart(data);
-            updateGrowthDistributionChart(data);
-            updateCumulativeGrowthChart(data);
-            updateGrowthInsights(data);
-            updateGrowthTable(data);
-        })
-        .catch(error => {
-            console.error('Error loading growth data:', error);
-            showErrorState();
-        });
-}
-
-// Update stats cards
-function updateStatsCards(data) {
-    const growthDataArray = data.growth_data || [];
-    
-    if (growthDataArray.length === 0) {
-        document.getElementById('totalCvesCount').textContent = '0';
-        document.getElementById('avgGrowthRate').textContent = '0%';
-        document.getElementById('peakGrowthYear').textContent = '-';
-        document.getElementById('ytdComparison').textContent = '0%';
-        return;
-    }
-    
-    // Total CVEs (latest year)
-    const latestYear = growthDataArray[growthDataArray.length - 1];
-    document.getElementById('totalCvesCount').textContent = latestYear.cves.toLocaleString();
-    document.getElementById('totalCvesSubtext').textContent = `As of ${latestYear.year}`;
-    
-    // Average annual growth
-    const avgGrowth = data.avg_annual_growth || 0;
-    document.getElementById('avgGrowthRate').textContent = `${avgGrowth}%`;
-    document.getElementById('avgGrowthSubtext').textContent = `Across ${growthDataArray.length} years`;
-    
-    // Peak growth year
-    const peakGrowth = data.highest_growth_year;
-    if (peakGrowth) {
-        document.getElementById('peakGrowthYear').textContent = peakGrowth.year;
-        document.getElementById('peakGrowthSubtext').textContent = `${peakGrowth.growth_rate}% growth`;
-    }
-    
-    // Year-to-date comparison - use same data source as table (growth_data array)
-    const ytdGrowthDataArray = data.growth_data || [];
-    const currentYearData = ytdGrowthDataArray.find(d => d.is_ytd === true);
-    
-    if (currentYearData && typeof currentYearData.ytd_vs_prev_ytd === 'number') {
-        const ytdGrowth = currentYearData.ytd_vs_prev_ytd;
-        const currentYearCVEs = currentYearData.cves;
-        const prevYearYTDActual = currentYearData.prev_year_ytd_actual || 0;
-        
-        document.getElementById('ytdComparison').textContent = `${ytdGrowth > 0 ? '+' : ''}${ytdGrowth}%`;
-        document.getElementById('ytdSubtext').innerHTML = `${currentYearCVEs.toLocaleString()} vs ${prevYearYTDActual.toLocaleString()} CVEs<br>(YTD vs Same Period Last Year)`;
-    } else {
-        console.log('YTD validation failed:', { 
-            hasData: !!currentYearData, 
-            hasYTDField: currentYearData ? 'ytd_vs_prev_ytd' in currentYearData : false,
-            ytdValue: currentYearData ? currentYearData.ytd_vs_prev_ytd : 'N/A'
-        });
-        document.getElementById('ytdComparison').textContent = 'N/A';
-        document.getElementById('ytdSubtext').textContent = 'Insufficient data';
-    }
-}
-
-// Update growth trends chart
-function updateGrowthTrendsChart(data) {
-    const ctx = document.getElementById('growthTrendsChart').getContext('2d');
-    
-    // Destroy existing chart
-    if (charts.growthTrends) {
-        charts.growthTrends.destroy();
-    }
-    
-    const growthDataArray = data.growth_data || [];
-    // Filter out current year YTD data for trend analysis since it's not comparable to completed years
-    const completedYearsData = growthDataArray.filter(d => !d.is_ytd);
-    const labels = completedYearsData.map(d => d.year);
-    
-    let chartData, yAxisLabel, yAxisConfig;
-    
-    if (currentGrowthView === 'absolute') {
-        chartData = completedYearsData.map(d => d.cves);
-        yAxisLabel = 'Total CVEs';
-        yAxisConfig = {
-            beginAtZero: true,
-            ticks: {
-                callback: function(value) {
-                    return value.toLocaleString();
-                }
-            }
-        };
-    } else {
-        chartData = completedYearsData.map(d => d.growth_rate);
-        yAxisLabel = 'Growth Rate (%)';
-        yAxisConfig = {
-            ticks: {
-                callback: function(value) {
-                    return value + '%';
-                }
-            }
-        };
-    }
-    
-    charts.growthTrends = new Chart(ctx, {
-        type: 'line',
-        data: {
-            labels: labels,
-            datasets: [{
-                label: yAxisLabel,
-                data: chartData,
-                borderColor: colorPalette.primary,
-                backgroundColor: `${colorPalette.primary}20`,
-                borderWidth: 3,
-                fill: true,
-                tension: 0.4,
-                pointBackgroundColor: colorPalette.primary,
-                pointBorderColor: '#ffffff',
-                pointBorderWidth: 2,
-                pointRadius: 5
-            }]
-        },
-        options: {
-            responsive: true,
-            maintainAspectRatio: false,
-            plugins: {
-                legend: {
-                    display: false
-                },
-                tooltip: {
-                    callbacks: {
-                        title: function(context) {
-                            return `Year ${context[0].label}`;
-                        },
-                        label: function(context) {
-                            if (currentGrowthView === 'absolute') {
-                                return `Total CVEs: ${context.parsed.y.toLocaleString()}`;
-                            } else {
-                                return `Growth Rate: ${context.parsed.y}%`;
-                            }
-                        }
-                    }
-                }
-            },
-            scales: {
-                x: {
-                    title: {
-                        display: true,
-                        text: 'Year'
-                    }
-                },
-                y: {
-                    title: {
-                        display: true,
-                        text: yAxisLabel
-                    },
-                    ...yAxisConfig
-                }
-            }
-        }
-    });
-}
-
-// Update growth distribution chart
-function updateGrowthDistributionChart(data) {
-    const ctx = document.getElementById('growthDistributionChart').getContext('2d');
-    
-    // Destroy existing chart
-    if (charts.growthDistribution) {
-        charts.growthDistribution.destroy();
-    }
-    
-    const growthDataArray = data.growth_data || [];
-    // Skip first year (0% growth) and exclude current year YTD data
-    const growthRates = growthDataArray.slice(1)
-        .filter(d => !d.is_ytd) // Exclude YTD data from distribution
-        .map(d => d.growth_rate);
-    
-    // Create growth rate bins (ordered from highest to lowest, negative at bottom)
-    const bins = {
-        '50%+': growthRates.filter(r => r >= 50).length,
-        '25-50%': growthRates.filter(r => r >= 25 && r < 50).length,
-        '10-25%': growthRates.filter(r => r >= 10 && r < 25).length,
-        '0-10%': growthRates.filter(r => r >= 0 && r < 10).length,
-        'Negative': growthRates.filter(r => r < 0).length
-    };
-    
-    charts.growthDistribution = new Chart(ctx, {
-        type: 'bar',
-        data: {
-            labels: Object.keys(bins),
-            datasets: [{
-                label: 'Years',
-                data: Object.values(bins),
-                backgroundColor: [
-                    colorPalette.accent,     // Darkest blue for 50%+ (highest growth)
-                    colorPalette.primary,    // Light blue for 25-50%
-                    colorPalette.secondary,  // Lighter blue for 10-25%
-                    colorPalette.tertiary,   // Very light blue for 0-10%
-                    colorPalette.lightGray   // Light gray for negative (lowest)
-                ],
-                borderColor: [
-                    colorPalette.accent,
-                    colorPalette.primary,
-                    colorPalette.secondary,
-                    colorPalette.tertiary,
-                    colorPalette.gray
-                ],
-                borderWidth: 1
-            }]
-        },
-        options: {
-            responsive: true,
-            maintainAspectRatio: false,
-            indexAxis: 'y', // This makes it a horizontal bar chart
-            plugins: {
-                legend: {
-                    display: false // Hide legend for cleaner look
-                },
-                tooltip: {
-                    callbacks: {
-                        label: function(context) {
-                            const total = context.dataset.data.reduce((a, b) => a + b, 0);
-                            const percentage = ((context.parsed.x / total) * 100).toFixed(1);
-                            return `${context.parsed.x} years (${percentage}%)`;
-                        }
-                    }
-                }
-            },
-            scales: {
-                x: {
-                    beginAtZero: true,
-                    title: {
-                        display: true,
-                        text: 'Number of Years'
-                    },
-                    grid: {
-                        color: colorPalette.lightGray
-                    }
-                },
-                y: {
-                    title: {
-                        display: true,
-                        text: 'Growth Rate Range'
-                    },
-                    grid: {
-                        display: false
-                    }
-                }
-            }
-        }
-    });
-}
-
-// Update cumulative growth chart
-function updateCumulativeGrowthChart(data) {
-    const ctx = document.getElementById('cumulativeGrowthChart').getContext('2d');
-    
-    // Destroy existing chart
-    if (charts.cumulativeGrowth) {
-        charts.cumulativeGrowth.destroy();
-    }
-    
-    const growthDataArray = data.growth_data || [];
-    // Filter out current year YTD data for consistency with other charts
-    const completedYearsData = growthDataArray.filter(d => !d.is_ytd);
-    const labels = completedYearsData.map(d => d.year);
-    const cumulativeData = completedYearsData.map(d => d.cves);
-    
-    charts.cumulativeGrowth = new Chart(ctx, {
-        type: 'bar',
-        data: {
-            labels: labels,
-            datasets: [{
-                label: 'Cumulative CVEs',
-                data: cumulativeData,
-                backgroundColor: `${colorPalette.primary}CC`,
-                borderColor: colorPalette.accent,
-                borderWidth: 1
-            }]
-        },
-        options: {
-            responsive: true,
-            maintainAspectRatio: false,
-            plugins: {
-                legend: {
-                    display: false
-                },
-                tooltip: {
-                    callbacks: {
-                        title: function(context) {
-                            return `Year ${context[0].label}`;
-                        },
-                        label: function(context) {
-                            return `Total CVEs: ${context.parsed.y.toLocaleString()}`;
-                        }
-                    }
-                }
-            },
-            scales: {
-                x: {
-                    title: {
-                        display: true,
-                        text: 'Year'
-                    }
-                },
-                y: {
-                    title: {
-                        display: true,
-                        text: 'Cumulative CVEs'
-                    },
-                    beginAtZero: true,
-                    ticks: {
-                        callback: function(value) {
-                            return value.toLocaleString();
-                        }
-                    }
-                }
-            }
-        }
-    });
-}
-
-// Update growth insights
-function updateGrowthInsights(data) {
-    const highestGrowth = data.highest_growth_year;
-    const lowestGrowth = data.lowest_growth_year;
-    const avgGrowth = data.avg_annual_growth || 0;
-    
-    // Highest growth insight
-    if (highestGrowth) {
-        document.getElementById('highestGrowthInsight').innerHTML = 
-            `<strong>${highestGrowth.year}</strong> saw the highest growth at <strong>${highestGrowth.growth_rate}%</strong> with ${highestGrowth.growth_absolute.toLocaleString()} new CVEs.`;
-    }
-    
-    // Lowest growth insight
-    if (lowestGrowth) {
-        document.getElementById('lowestGrowthInsight').innerHTML = 
-            `<strong>${lowestGrowth.year}</strong> had the lowest growth at <strong>${lowestGrowth.growth_rate}%</strong> with ${lowestGrowth.growth_absolute.toLocaleString()} new CVEs.`;
-    }
-    
-    // Trend analysis
-    const growthDataArray = data.growth_data || [];
-    if (growthDataArray.length >= 5) {
-        const recentYears = growthDataArray.slice(-5);
-        const recentAvg = recentYears.reduce((sum, year) => sum + year.growth_rate, 0) / recentYears.length;
-        const trend = recentAvg > avgGrowth ? 'accelerating' : 'decelerating';
-        
-        document.getElementById('trendAnalysisInsight').innerHTML = 
-            `Recent 5-year average growth is <strong>${recentAvg.toFixed(1)}%</strong>, indicating <strong>${trend}</strong> growth trends.`;
-    }
-}
-
-// Update growth table
-function updateGrowthTable(data) {
-    const tableBody = document.getElementById('growthTableBody');
-    const growthDataArray = data.growth_data || [];
-    
-    if (growthDataArray.length === 0) {
-        tableBody.innerHTML = '<tr><td colspan="5" class="text-center text-muted">No growth data available</td></tr>';
-        return;
-    }
-    
-    tableBody.innerHTML = growthDataArray.map(yearData => {
-        const growthRateClass = yearData.growth_rate > 0 ? 'text-success' : yearData.growth_rate < 0 ? 'text-danger' : 'text-muted';
-        const growthIcon = yearData.growth_rate > 0 ? '↗️' : yearData.growth_rate < 0 ? '↘️' : '➡️';
-        
-        let rowClass = '';
-        let yearDisplay = yearData.year;
-        let borderLeftStyle = '';
-        
-        if (yearData.is_ytd) {
-            rowClass = 'table-warning';
-            borderLeftStyle = '4px solid #ffc107';
-            yearDisplay = `${yearData.year} <span class="badge bg-warning text-dark ms-1">YTD</span>`;
-        }
-        
-        const growthIconHtml = yearData.growth_rate > 0 ? 
-            '<i class="fas fa-arrow-up text-success me-1"></i>' : 
-            '<i class="fas fa-arrow-down text-danger me-1"></i>';
-        
-        return `
-            <tr class="${rowClass}" style="border-left: ${borderLeftStyle}">
-                <td>${yearDisplay}</td>
-                <td>${yearData.cves.toLocaleString()}</td>
-                <td class="${growthRateClass}">
-                    ${growthIconHtml}${yearData.growth_rate > 0 ? '+' : ''}${yearData.growth_rate}%
-                </td>
-                <td class="${yearData.growth_absolute >= 0 ? 'text-success' : 'text-danger'}">
-                    ${yearData.growth_absolute >= 0 ? '+' : ''}${yearData.growth_absolute.toLocaleString()}
-                </td>
-                <td>${yearData.growth_rate_3yr_avg}%</td>
-            </tr>
-        `;
-    }).join('');
-}
-
-// Growth view toggle (absolute vs rate)
-function toggleGrowthView(view) {
-    if (currentGrowthView === view) return;
-    
-    currentGrowthView = view;
-    
-    // Update button states
-    document.getElementById('absoluteBtn').classList.toggle('active', view === 'absolute');
-    document.getElementById('rateBtn').classList.toggle('active', view === 'rate');
-    
-    // Update chart
-    if (growthData) {
-        updateGrowthTrendsChart(growthData);
-    }
-}
-
-
-
-// Sort table
-function sortTable(column) {
-    if (!growthData || !growthData.growth_data) return;
-    
-    const sortedData = [...growthData.growth_data];
-    
-    sortedData.sort((a, b) => {
-        if (column === 'year') {
-            return b.year - a.year; // Descending by year
-        } else if (column === 'growth_rate') {
-            return b.growth_rate - a.growth_rate; // Descending by growth rate
-        }
-        return 0;
-    });
-    
-    // Update table with sorted data
-    const tempData = { ...growthData, growth_data: sortedData };
-    updateGrowthTable(tempData);
-}
-
-// Export data
-function exportData(format) {
-    if (!growthData) {
-        alert('No data available to export');
-        return;
-    }
-    
-    const filename = `growth_analysis_${currentDataMode}_${new Date().toISOString().split('T')[0]}`;
-    
-    if (format === 'csv') {
-        const csv = convertToCSV(growthData.growth_data);
-        downloadFile(csv, `${filename}.csv`, 'text/csv');
-    } else if (format === 'json') {
-        const json = JSON.stringify(growthData, null, 2);
-        downloadFile(json, `${filename}.json`, 'application/json');
-    }
-}
-
-// Convert data to CSV
-function convertToCSV(data) {
-    if (!data || data.length === 0) return '';
-    
-    const headers = ['Year', 'Total CVEs', 'Growth Rate (%)', 'Absolute Change', '3-Year Average (%)'];
-    const csvContent = [
-        headers.join(','),
-        ...data.map(row => [
-            row.year,
-            row.cves,
-            row.growth_rate,
-            row.growth_absolute,
-            row.growth_rate_3yr_avg
-        ].join(','))
-    ].join('\n');
-    
-    return csvContent;
-}
-
-// Download file
-function downloadFile(content, filename, contentType) {
-    const blob = new Blob([content], { type: contentType });
-    const url = URL.createObjectURL(blob);
-    const link = document.createElement('a');
-    link.href = url;
-    link.download = filename;
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-    URL.revokeObjectURL(url);
-}
-
-// Timestamp now handled by universal loader in base.html
-
-// Copy permalink
-function copyPermalink() {
-    const url = window.location.href;
-    navigator.clipboard.writeText(url).then(() => {
-        // Show success feedback
-        const btn = event.target.closest('button');
-        const originalText = btn.innerHTML;
-        btn.innerHTML = '<i class="fas fa-check me-1"></i>Copied!';
-        btn.classList.add('btn-success');
-        btn.classList.remove('btn-outline-primary');
-        
-        setTimeout(() => {
-            btn.innerHTML = originalText;
-            btn.classList.remove('btn-success');
-            btn.classList.add('btn-outline-primary');
-        }, 2000);
-    }).catch(err => {
-        console.error('Failed to copy permalink:', err);
-        alert('Failed to copy permalink to clipboard');
-    });
-}
-
-// Show error state
-function showErrorState() {
-    document.getElementById('totalCvesCount').textContent = 'Error';
-    document.getElementById('avgGrowthRate').textContent = 'Error';
-    document.getElementById('peakGrowthYear').textContent = 'Error';
-    document.getElementById('ytdComparison').textContent = 'Error';
-    
-    document.getElementById('totalCvesSubtext').textContent = 'Failed to load data';
-    document.getElementById('avgGrowthSubtext').textContent = 'Failed to load data';
-    document.getElementById('peakGrowthSubtext').textContent = 'Failed to load data';
-    document.getElementById('ytdSubtext').textContent = 'Failed to load data';
-    
-    document.getElementById('growthTableBody').innerHTML = 
-        '<tr><td colspan="5" class="text-center text-danger">Error loading growth data</td></tr>';
-}
 </script>
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/templates/index.html b/templates/index.html
index c2455057a4c..29f5725db0f 100644
--- a/templates/index.html
+++ b/templates/index.html
@@ -1,1038 +1,122 @@
 {% extends "base.html" %}
-
-{% block title %}CVEDB - CVE Analysis Dashboard{% endblock %}
+{% set nav = 'home' %}
+{% block title %}CVEDB &mdash; how many CVEs{% endblock %}
 
 {% block content %}
-<style>
-    /* Quick select button styling matching CVSS dashboard */
-    .quick-select-btn {
-        background-color: #f8f9fa;
-        border: 1px solid #dee2e6;
-        color: #495057;
-        padding: 0.375rem 0.75rem;
-        margin: 0 0.125rem;
-        border-radius: 0.375rem;
-        font-size: 0.875rem;
-        font-weight: 500;
-        cursor: pointer;
-        transition: all 0.15s ease-in-out;
-    }
-
-    .quick-select-btn.active {
-        background-color: #3b82f6 !important;
-        color: white !important;
-        border-color: #2563eb !important;
-    }
-
-    .quick-select-btn:hover {
-        background-color: #60a5fa;
-        color: white;
-        border-color: #3b82f6;
-    }
-</style>
-
-<!-- Page Header -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">CVEDB</h1>
-    <small class="text-muted d-block mb-3">
-        Advanced vulnerability intelligence platform delivering comprehensive CVE analytics from 1999 to {{ current_year
-        if current_year else '2025' }}
-    </small>
-    <div class="mt-2">
-        <a href="about.html" class="btn btn-outline-secondary btn-sm" style="font-size: 0.875rem;">
-            <i class="fas fa-info-circle me-1"></i>Learn More About the Platform
-        </a>
-        <small class="text-muted d-block mt-1" style="font-size: 0.875rem;">
-            Discover data sources, technical architecture, and intelligence capabilities
-        </small>
-    </div>
+<div class="ph">
+  <h1>CVEs published in {{ current_year }}</h1>
+  <span class="note" id="asof"></span>
 </div>
 
-<!-- Statistics Cards -->
-<div class="stats-grid">
-    <div class="stat-card">
-        <div class="stat-number" id="cves-this-year">Loading...</div>
-        <div class="stat-label">CVEs This Year</div>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="avg-cves-per-day">Loading...</div>
-        <div class="stat-label">Avg CVEs/Day</div>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="growth-rate">Loading...</div>
-        <div class="stat-label">YOY Growth</div>
-        <div class="stat-detail" id="growth-detail">Loading...</div>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="total-cves">Loading...</div>
-        <div class="stat-label">Total CVEs</div>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="kev-global-count">Loading...</div>
-        <div class="stat-label">Known Exploited CVEs</div>
-        <div class="stat-detail" id="kev-global-detail">CISA KEV catalog</div>
-    </div>
+<div class="grid g3 kpi" id="tiles">
+  <div class="c"><div class="lbl">Loading</div><div class="v loading">&mdash;</div></div>
 </div>
 
-<!-- Main Chart Section -->
-<section class="homepage-chart-section">
-    <div class="homepage-chart-card">
-        <div class="homepage-chart-header">
-            <h4 class="homepage-chart-title">📊 CVE Publications by Year</h4>
-            <small class="homepage-chart-subtitle">Historical trend of vulnerability disclosures from 1999 to
-                present</small>
-        </div>
-        <div class="homepage-chart-body">
-            <div class="homepage-chart-container">
-                <canvas id="cvesByYearChart"></canvas>
-            </div>
-            <div class="homepage-chart-footer">
-                <a href="years.html" class="btn btn-primary btn-sm">View Full Dashboard →</a>
-            </div>
-        </div>
-    </div>
-</section>
-
-<!-- Preview Charts Section -->
-<section class="homepage-preview-section">
-
-    <!-- CNA Preview -->
-    <div class="homepage-chart-card">
-        <div class="homepage-chart-header">
-            <h4 class="homepage-chart-title">🏢 CNA</h4>
-            <small class="homepage-chart-subtitle">CVE Numbering Authority activity and organizational analysis</small>
-        </div>
-        <div class="homepage-chart-body">
-            <div class="homepage-chart-container homepage-preview-container">
-                <canvas id="cnaPreviewChart"></canvas>
-            </div>
-            <div class="homepage-chart-footer">
-                <a href="cna.html" class="btn btn-primary btn-sm">View Full Dashboard →</a>
-            </div>
-        </div>
-    </div>
-
-    <!-- CPE Preview -->
-    <div class="homepage-chart-card">
-        <div class="homepage-chart-header">
-            <h4 class="homepage-chart-title">💻 CPE</h4>
-            <small class="homepage-chart-subtitle">Common Platform Enumeration and affected technology analysis</small>
-        </div>
-        <div class="homepage-chart-body">
-            <div class="homepage-chart-container homepage-preview-container">
-                <canvas id="cpePreviewChart"></canvas>
-            </div>
-            <div class="homepage-chart-footer">
-                <a href="cpe.html" class="btn btn-primary btn-sm">View Full Dashboard →</a>
-            </div>
-        </div>
-    </div>
-
-    <!-- CWE Preview -->
-    <div class="homepage-chart-card">
-        <div class="homepage-chart-header">
-            <h4 class="homepage-chart-title">🔍 CWE</h4>
-            <small class="homepage-chart-subtitle">Common Weakness Enumeration patterns and vulnerability types</small>
-        </div>
-        <div class="homepage-chart-body">
-            <div class="homepage-chart-container homepage-preview-container">
-                <canvas id="cwePreviewChart"></canvas>
-            </div>
-            <div class="homepage-chart-footer">
-                <a href="cwe.html" class="btn btn-primary btn-sm">View Full Dashboard →</a>
-            </div>
-        </div>
-    </div>
-
-    <!-- Scoring / Threat Intelligence Preview -->
-    <div class="homepage-chart-card">
-        <div class="homepage-chart-header">
-            <h4 class="homepage-chart-title">🎯 Scoring & Risk</h4>
-            <small class="homepage-chart-subtitle">CVE volume compared to Known Exploited Vulnerabilities (KEV) by
-                year</small>
-        </div>
-        <div class="homepage-chart-body">
-            <div class="homepage-chart-container homepage-preview-container">
-                <canvas id="riskVolumeChart"></canvas>
-            </div>
-            <!-- Threat Intelligence Stats -->
-            <div class="stats-grid mt-3">
-                <div class="stat-card">
-                    <div class="stat-number" id="epss-high-risk">Loading...</div>
-                    <div class="stat-label">High Risk CVEs</div>
-                    <div class="stat-detail">EPSS &gt; 0.5</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-number" id="epss-elevated-risk">Loading...</div>
-                    <div class="stat-label">Elevated Risk</div>
-                    <div class="stat-detail">EPSS &gt; 0.1</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-number" id="epss-coverage">Loading...</div>
-                    <div class="stat-label">EPSS Coverage</div>
-                    <div class="stat-detail" id="epss-coverage-detail">CVEs scored</div>
-                </div>
-                <div class="stat-card">
-                    <div class="stat-number" id="kev-recent">Loading...</div>
-                    <div class="stat-label">KEV Recent</div>
-                    <div class="stat-detail">Last 30 days</div>
-                </div>
-            </div>
-            <div class="homepage-chart-footer">
-                <a href="scoring.html" class="btn btn-primary btn-sm">View Scoring Hub →</a>
-            </div>
-        </div>
-    </div>
-
-    <!-- Growth Preview -->
-    <div class="homepage-chart-card">
-        <div class="homepage-chart-header">
-            <h4 class="homepage-chart-title">📈 Growth</h4>
-            <small class="homepage-chart-subtitle">Year-over-year CVE publication trends and growth analysis</small>
-        </div>
-        <div class="homepage-chart-body">
-            <div class="homepage-chart-container homepage-preview-container">
-                <canvas id="growthPreviewChart"></canvas>
-            </div>
-            <div class="homepage-chart-footer">
-                <a href="growth.html" class="btn btn-primary btn-sm">View Full Dashboard →</a>
-            </div>
-        </div>
-    </div>
-
-    <!-- Calendar Preview -->
-    <div class="homepage-chart-card">
-        <div class="homepage-chart-header">
-            <h4 class="homepage-chart-title">📅 Calendar</h4>
-            <small class="homepage-chart-subtitle">Daily and monthly CVE publication patterns</small>
-        </div>
-        <div class="homepage-chart-body">
-            <div class="homepage-chart-container homepage-preview-container">
-                <canvas id="calendarPreviewChart"></canvas>
-            </div>
-            <div class="homepage-chart-footer">
-                <a href="calendar.html" class="btn btn-primary btn-sm">View Full Dashboard →</a>
-            </div>
-        </div>
-    </div>
-
-</section>
-
-<!-- About Section -->
-<div class="card feature-card mt-5">
-    <div class="card-header bg-primary text-white d-flex justify-content-between align-items-center">
-        <h3 class="card-title mb-0">🌐 About CVEDB</h3>
-        <a href="about.html" class="btn btn-outline-light btn-sm">Full About Page →</a>
-    </div>
-    <div class="card-body">
-        <!-- Mission Statement Card -->
-        <div class="card mb-4 border-0 bg-light">
-            <div class="card-body">
-                <h6 class="card-title mb-3" style="color: #0d6efd;">🎯 Where Vulnerability Chaos Meets Clarity</h6>
-                <p class="mb-0">CVEDB embodies <a href="https://cvedb.github.io" target="_blank"
-                        class="fw-bold text-decoration-none" style="color: #0d6efd;">CVEDB'</a> mission of
-                    transforming overwhelming vulnerability data into clear, actionable intelligence that security teams
-                    can actually use.</p>
-            </div>
-        </div>
+<h2>Per year <span class="side">1999&ndash;{{ current_year }}</span></h2>
+<div class="panel">
+  <div class="panel-h">CVEs published each year
+    <span class="side">{{ current_year }} is a partial year</span></div>
+  <div class="panel-b"><div id="chart-years"></div></div>
+</div>
 
-        <!-- Coverage Statistics Card -->
-        <div class="card mb-4 border-0 bg-light">
-            <div class="card-body">
-                <h6 class="card-title mb-3">📈 Coverage Statistics</h6>
-                <div class="row">
-                    <div class="col-md-6">
-                        <ul class="list-unstyled small">
-                            <li class="mb-2">✓ <strong>{{ total_cves|default('287,800+') }} CVE entries</strong> across
-                                {{ available_years|length if available_years else '27' }} years (1999-{{ current_year if
-                                current_year else '2025' }})</li>
-                            <li class="mb-2"> <strong>{{ cvss_coverage|default('284,181') }} CVSS scored</strong>
-                                vulnerabilities</li>
-                            <li class="mb-2"> <strong>{{ kev_coverage|default('1,463') }} known exploited CVEs</strong>
-                                in the CISA KEV catalog</li>
-                        </ul>
-                    </div>
-                    <div class="col-md-6">
-                        <ul class="list-unstyled small">
-                            <li class="mb-2">✓ <strong>{{ cwe_coverage|default('206,053') }} CWE classified</strong>
-                                weaknesses</li>
-                            <li class="mb-2">✓ <strong>{{ cna_count|default('290') }} active CNAs</strong> with
-                                attribution data</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-        </div>
+<h2>Recent days <span class="side">most recent 90 days with data</span></h2>
+<div class="panel">
+  <div class="panel-h">CVEs published per day <span class="side" id="days-side"></span></div>
+  <div class="panel-b"><div id="chart-days"></div></div>
+</div>
 
-        <!-- Platform Features Card -->
-        <div class="card border-0 bg-light">
-            <div class="card-body">
-                <h6 class="card-title mb-3">🚀 Platform Features</h6>
-                <div class="row">
-                    <div class="col-md-6">
-                        <ul class="list-unstyled small">
-                            <li class="mb-1">✓ <strong>Real-Time Analytics:</strong> 6-hour automated updates</li>
-                            <li class="mb-1">✓ <strong>Intelligence Dashboards:</strong> CNA, CVSS, CWE, Growth</li>
-                        </ul>
-                    </div>
-                    <div class="col-md-6">
-                        <ul class="list-unstyled small">
-                            <li class="mb-1">✓ <strong>Open Source:</strong> Free access for everyone</li>
-                            <li class="mb-1">✓ <strong>Modern Tech:</strong> Python, Chart.js, D3.js</li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
+<h2>Breakdowns</h2>
+<div class="cols">
+  <div class="panel">
+    <div class="panel-h">Publishers <span class="side">in {{ current_year }}</span></div>
+    <div class="rows" id="top-cna"></div>
+    <div class="panel-h" style="border-top:1px solid var(--line);border-bottom:0">
+      <a href="cna.html" style="color:var(--accent)">All publishers &rarr;</a></div>
+  </div>
+  <div class="panel">
+    <div class="panel-h">Weakness types <span class="side">all time</span></div>
+    <div class="rows" id="top-cwe"></div>
+    <div class="panel-h" style="border-top:1px solid var(--line);border-bottom:0">
+      <a href="cwe.html" style="color:var(--accent)">All weakness types &rarr;</a></div>
+  </div>
+  <div class="panel">
+    <div class="panel-h">Products <span class="side">CPE references</span></div>
+    <div class="rows" id="top-cpe"></div>
+    <div class="panel-h" style="border-top:1px solid var(--line);border-bottom:0">
+      <a href="cpe.html" style="color:var(--accent)">All products &rarr;</a></div>
+  </div>
 </div>
 {% endblock %}
 
 {% block scripts %}
 <script>
-    // Global CVSS variables removed temporarily
-
-    document.addEventListener('DOMContentLoaded', function () {
-        // Wait for Chart.js and CVE_COLORS to be available
-        if (typeof Chart === 'undefined' || typeof window.CVE_COLORS === 'undefined') {
-            console.error('Chart.js or CVE_COLORS not loaded');
-            return;
-        }
-
-        // Initialize CVEs by Year Chart
-        const ctx = document.getElementById('cvesByYearChart');
-        if (ctx) {
-            // Sample data - this would be populated by the Python backend
-            const yearlyData = {
-                labels: [],
-                datasets: [{
-                    label: 'CVEs Published',
-                    data: [],
-                    borderColor: window.CVE_COLORS.primary,
-                    backgroundColor: window.CVE_COLORS.primaryLight,
-                    fill: false,
-                    tension: 0.1
-                }]
-            };
-
-            // Load actual CVE data from JSON files
-            const currentYear = new Date().getFullYear();
-            const loadPromises = [];
-
-            // Generate years from 1999 to current year and load data
-            for (let year = 1999; year <= currentYear; year++) {
-                yearlyData.labels.push(year.toString());
-
-                // Load actual CVE data for each year
-                const promise = fetch(`data/cve_${year}.json`)
-                    .then(response => {
-                        if (!response.ok) {
-                            console.warn(`No data found for year ${year}`);
-                            return { total_cves: 0 };
-                        }
-                        return response.json();
-                    })
-                    .then(data => {
-                        return { year: year, count: data.total_cves || 0 };
-                    })
-                    .catch(error => {
-                        console.warn(`Error loading data for year ${year}:`, error);
-                        return { year: year, count: 0 };
-                    });
-
-                loadPromises.push(promise);
-            }
-
-            // Wait for all data to load, then create the chart and update stats
-            Promise.all(loadPromises).then(results => {
-                // Sort results by year to ensure correct order
-                results.sort((a, b) => a.year - b.year);
-
-                // Extract the CVE counts in the correct order
-                yearlyData.datasets[0].data = results.map(result => result.count);
-
-                // Calculate and update statistics
-                updateStatistics(results);
-
-                // Create the chart with real data
-                createChart();
-            }).catch(error => {
-                console.error('Error loading CVE data:', error);
-                // Fallback: create chart with empty data and show error in stats
-                updateStatisticsError();
-                createChart();
-            });
-
-            function updateStatistics(results) {
-                try {
-                    // Calculate total CVEs
-                    const totalCves = results.reduce((sum, result) => sum + result.count, 0);
-                    document.getElementById('total-cves').textContent = totalCves.toLocaleString();
-
-                    // Calculate CVEs this year (current year)
-                    const currentYear = new Date().getFullYear();
-                    const currentYearData = results.find(r => r.year === currentYear);
-                    const cvesThisYear = currentYearData ? currentYearData.count : 0;
-                    document.getElementById('cves-this-year').textContent = cvesThisYear.toLocaleString();
-
-                    // Calculate average CVEs per day (based on current year)
-                    const dayOfYear = Math.floor((new Date() - new Date(currentYear, 0, 0)) / (1000 * 60 * 60 * 24));
-                    const avgCvesPerDay = cvesThisYear > 0 && dayOfYear > 0 ? (cvesThisYear / dayOfYear).toFixed(1) : '0';
-                    document.getElementById('avg-cves-per-day').textContent = avgCvesPerDay;
-
-                    // Load YTD growth data from growth_analysis.json (accurate calculation)
-                    fetch('data/growth_analysis.json')
-                        .then(response => response.json())
-                        .then(growthData => {
-                            const currentYearData = growthData.growth_data.find(d => d.is_ytd === true);
-
-                            if (currentYearData && typeof currentYearData.ytd_vs_prev_ytd === 'number') {
-                                const ytdGrowth = currentYearData.ytd_vs_prev_ytd;
-                                const prevYearYTDActual = currentYearData.prev_year_ytd_actual || 0;
-
-                                const growthText = ytdGrowth >= 0 ? `+${ytdGrowth}%` : `${ytdGrowth}%`;
-                                document.getElementById('growth-rate').textContent = growthText;
-                                document.getElementById('growth-detail').textContent = `${cvesThisYear.toLocaleString()} vs ${prevYearYTDActual.toLocaleString()} (YTD vs Same Period ${currentYear - 1})`;
-                            } else {
-                                document.getElementById('growth-rate').textContent = 'N/A';
-                                document.getElementById('growth-detail').textContent = 'No previous year data';
-                            }
-                        })
-                        .catch(error => {
-                            console.warn('Could not load growth analysis data:', error);
-                            document.getElementById('growth-rate').textContent = 'N/A';
-                            document.getElementById('growth-detail').textContent = 'Data unavailable';
-                        });
-                } catch (error) {
-                    console.error('Error updating statistics:', error);
-                    updateStatisticsError();
-                }
-            }
-
-            function updateStatisticsError() {
-                document.getElementById('total-cves').textContent = 'Error';
-                document.getElementById('cves-this-year').textContent = 'Error';
-                document.getElementById('avg-cves-per-day').textContent = 'Error';
-                document.getElementById('growth-rate').textContent = 'Error';
-                document.getElementById('growth-detail').textContent = 'Error loading data';
-            }
-
-            function createChart() {
-                new Chart(ctx, {
-                    type: 'line',
-                    data: yearlyData,
-                    options: {
-                        responsive: true,
-                        maintainAspectRatio: false,
-                        plugins: {
-                            title: {
-                                display: true,
-                                text: 'CVE Publications by Year',
-                                font: {
-                                    size: 16,
-                                    weight: 'bold'
-                                }
-                            },
-                            legend: {
-                                display: false
-                            }
-                        },
-                        scales: {
-                            y: {
-                                beginAtZero: true,
-                                title: {
-                                    display: true,
-                                    text: 'Number of CVEs'
-                                },
-                                grid: {
-                                    color: 'rgba(0, 0, 0, 0.1)'
-                                }
-                            },
-                            x: {
-                                title: {
-                                    display: true,
-                                    text: 'Year'
-                                },
-                                grid: {
-                                    color: 'rgba(0, 0, 0, 0.1)'
-                                }
-                            }
-                        },
-                        elements: {
-                            point: {
-                                radius: 4,
-                                hoverRadius: 6
-                            }
-                        }
-                    }
-                });
-            }
-        }
-
-        // Initialize preview charts with simplified, error-free approach
-        initializeSimplePreviewCharts();
-
-        // Initialize KEV global stats using cvss_analysis.json
-        fetch('data/cvss_analysis.json')
-            .then(response => response.json())
-            .then(data => {
-                const kevGlobal = data.kev_global_count || 0;
-                const el = document.getElementById('kev-global-count');
-                const detail = document.getElementById('kev-global-detail');
-                if (el) el.textContent = kevGlobal.toLocaleString();
-                if (detail) detail.textContent = 'CISA KEV catalog across all years';
-            })
-            .catch(error => {
-                console.error('KEV global stats error:', error);
-            });
-
-        // Initialize Threat Intelligence cards
-        // Load EPSS analysis data
-        fetch('data/epss_analysis.json')
-            .then(response => response.json())
-            .then(data => {
-                const stats = data.statistics || {};
-                const totalWithEpss = data.total_cves_with_epss || 0;
-
-                // High risk (EPSS > 0.5)
-                const highRiskEl = document.getElementById('epss-high-risk');
-                if (highRiskEl) highRiskEl.textContent = (stats.gt_0_5 || 0).toLocaleString();
-
-                // Elevated risk (EPSS > 0.1)
-                const elevatedEl = document.getElementById('epss-elevated-risk');
-                if (elevatedEl) elevatedEl.textContent = (stats.gt_0_1 || 0).toLocaleString();
-
-                // EPSS coverage
-                const coverageEl = document.getElementById('epss-coverage');
-                const coverageDetailEl = document.getElementById('epss-coverage-detail');
-                if (coverageEl) coverageEl.textContent = totalWithEpss.toLocaleString();
-                if (coverageDetailEl) coverageDetailEl.textContent = 'CVEs with EPSS scores';
-            })
-            .catch(error => {
-                console.error('EPSS analysis error:', error);
-            });
-
-        // Load KEV analysis for recent additions
-        fetch('data/kev_analysis.json')
-            .then(response => response.json())
-            .then(data => {
-                const stats = data.statistics || {};
-                const recentEl = document.getElementById('kev-recent');
-                if (recentEl) recentEl.textContent = (stats.added_last_30_days || 0).toLocaleString();
-            })
-            .catch(error => {
-                console.error('KEV analysis error:', error);
-            });
-
-        // Initialize Risk vs Volume chart
-        initializeRiskVolumeChart();
-    });
-
-    // Simplified preview charts initialization to eliminate JavaScript syntax errors
-    function initializeSimplePreviewCharts() {
-        // CNA Preview Chart
-        initializeCnaPreview();
-
-        // CPE Preview Chart
-        initializeCpePreview();
-
-        // CWE Preview Chart
-        initializeCwePreview();
-
-        // Growth Preview Chart
-        initializeGrowthPreview();
-
-        // Calendar Preview Chart
-        initializeCalendarPreview();
-    }
-
-    function initializeGrowthPreview() {
-        const ctx = document.getElementById('growthPreviewChart');
-        if (!ctx) return;
-
-        fetch('data/growth_analysis.json')
-            .then(response => response.json())
-            .then(data => {
-                const growthData = data.growth_data || [];
-                const currentYear = new Date().getFullYear();
-                const filteredData = growthData.filter(item => item.year !== currentYear);
-
-                const labels = filteredData.map(item => item.year.toString());
-                const values = filteredData.map(item => item.growth_rate || 0);
-
-                new Chart(ctx, {
-                    type: 'line',
-                    data: {
-                        labels: labels,
-                        datasets: [{
-                            data: values,
-                            borderColor: '#5a9bd4',
-                            backgroundColor: 'rgba(90, 155, 212, 0.1)',
-                            fill: true,
-                            tension: 0.4
-                        }]
-                    },
-                    options: {
-                        responsive: true,
-                        maintainAspectRatio: false,
-                        plugins: { legend: { display: false } },
-                        scales: {
-                            y: { display: true, grid: { color: 'rgba(0,0,0,0.1)' } },
-                            x: { display: true, grid: { color: 'rgba(0,0,0,0.1)' } }
-                        }
-                    }
-                });
-            })
-            .catch(error => {
-                console.error('Growth preview error:', error);
-                ctx.parentElement.innerHTML = '<div class="text-center text-muted py-4"><small>Preview unavailable</small></div>';
-            });
-    }
-
-    // Global variables for CVSS preview chart
-    let cvssPreviewChart = null;
-    let cvssPreviewData = null;
-    let currentCvssVersion = 'v3.1';
-
-    function initializeCvssPreview() {
-        const ctx = document.getElementById('homepageScoreChart');
-        if (!ctx) return;
-
-        fetch('data/cvss_analysis.json')
-            .then(response => response.json())
-            .then(data => {
-                cvssPreviewData = data;
-
-                // Initialize chart with default version (v3.1)
-                updateCvssPreviewChart('v3.1');
-
-                // Add event listeners for version buttons
-                const versionButtons = document.querySelectorAll('.cvss-version-btn');
-                versionButtons.forEach(button => {
-                    button.addEventListener('click', function () {
-                        const version = this.getAttribute('data-version');
-                        updateCvssPreviewChart(version);
-
-                        // Update button states
-                        versionButtons.forEach(btn => {
-                            btn.classList.remove('active');
-                        });
-                        this.classList.add('active');
-
-                        // Update version label
-                        const versionLabel = document.getElementById('homepageCvssVersionLabel');
-                        if (versionLabel) {
-                            versionLabel.textContent = `CVSS ${version}`;
-                        }
-                    });
-                });
-            })
-            .catch(error => {
-                console.error('CVSS preview error:', error);
-                ctx.parentElement.innerHTML = '<div class="text-center text-muted py-4"><small>Preview unavailable</small></div>';
-            });
-    }
-
-    function updateCvssPreviewChart(version) {
-        const ctx = document.getElementById('homepageScoreChart');
-        if (!ctx || !cvssPreviewData) return;
-
-        currentCvssVersion = version;
-
-        // Get score data for the selected version
-        const versionScores = cvssPreviewData.score_distribution[version] || {};
-        const scoreBins = {};
-
-        // Create 1-point score bins for the selected version
-        Object.entries(versionScores).forEach(([score, count]) => {
-            const scoreFloat = parseFloat(score);
-            let bin;
-
-            // Create 1-point score bins (0-0.99, 1.0-1.99, etc.)
-            if (scoreFloat >= 10.0) bin = '10.0';
-            else if (scoreFloat >= 9.0) bin = '9.0-9.9';
-            else if (scoreFloat >= 8.0) bin = '8.0-8.9';
-            else if (scoreFloat >= 7.0) bin = '7.0-7.9';
-            else if (scoreFloat >= 6.0) bin = '6.0-6.9';
-            else if (scoreFloat >= 5.0) bin = '5.0-5.9';
-            else if (scoreFloat >= 4.0) bin = '4.0-4.9';
-            else if (scoreFloat >= 3.0) bin = '3.0-3.9';
-            else if (scoreFloat >= 2.0) bin = '2.0-2.9';
-            else if (scoreFloat >= 1.0) bin = '1.0-1.9';
-            else bin = '0.0-0.9';
-
-            scoreBins[bin] = (scoreBins[bin] || 0) + count;
-        });
-
-        // Display all bins in sequential order from 0-10
-        const orderedBins = ['0.0-0.9', '1.0-1.9', '2.0-2.9', '3.0-3.9', '4.0-4.9',
-            '5.0-5.9', '6.0-6.9', '7.0-7.9', '8.0-8.9', '9.0-9.9', '10.0'];
-
-        const labels = orderedBins;
-        const values = orderedBins.map(bin => scoreBins[bin] || 0);
-
-        // Light blue/gray color palette matching CVEDB design (11 bins)
-        const colors = [
-            '#d6e7f5', // Lightest blue (0.0-0.9)
-            '#c8dff0', // Very light blue (1.0-1.9)
-            '#b9d7eb', // Light blue (2.0-2.9)
-            '#aacfe6', // Light-medium blue (3.0-3.9)
-            '#9bc7e1', // Medium blue (4.0-4.9)
-            '#8cbfdc', // Medium-dark blue (5.0-5.9)
-            '#7db7d7', // Dark blue (6.0-6.9)
-            '#6eafd2', // Darker blue (7.0-7.9)
-            '#5fa7cd', // Very dark blue (8.0-8.9)
-            '#509fc8', // Darkest blue (9.0-9.9)
-            '#4197c3'  // Deepest blue (10.0)
-        ];
-
-        // Destroy existing chart if it exists
-        if (cvssPreviewChart) {
-            cvssPreviewChart.destroy();
-        }
-
-        // Create new chart
-        cvssPreviewChart = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: labels,
-                datasets: [{
-                    data: values,
-                    backgroundColor: colors,
-                    borderColor: colors,
-                    borderWidth: 1
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: { display: false }
-                },
-                scales: {
-                    y: {
-                        display: true,
-                        grid: { color: 'rgba(0,0,0,0.1)' },
-                        title: {
-                            display: true,
-                            text: 'CVE Count',
-                            font: { size: 10 }
-                        }
-                    },
-                    x: {
-                        display: true,
-                        grid: { color: 'rgba(0,0,0,0.1)' },
-                        title: {
-                            display: true,
-                            text: 'CVSS Score Range',
-                            font: { size: 10 }
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    function initializeCwePreview() {
-        const ctx = document.getElementById('cwePreviewChart');
-        if (!ctx) return;
-
-        fetch('data/cwe_analysis.json')
-            .then(response => response.json())
-            .then(data => {
-                const cweData = data.top_cwes || [];
-                const topCWEs = cweData.slice(0, 5);
-                const labels = topCWEs.map(item => `CWE-${item.id}`);
-                const values = topCWEs.map(item => item.count);
-
-                new Chart(ctx, {
-                    type: 'bar',
-                    data: {
-                        labels: labels,
-                        datasets: [{
-                            data: values,
-                            backgroundColor: ['#a8c8ec', '#9bc7e1', '#8cbfdc', '#7db7d7', '#6eafd2'],
-                            borderColor: ['#9bc7e1', '#8cbfdc', '#7db7d7', '#6eafd2', '#5fa7cd'],
-                            borderWidth: 1
-                        }]
-                    },
-                    options: {
-                        responsive: true,
-                        maintainAspectRatio: false,
-                        plugins: { legend: { display: false } },
-                        scales: {
-                            y: { display: true, grid: { color: 'rgba(0,0,0,0.1)' } },
-                            x: { display: true, grid: { color: 'rgba(0,0,0,0.1)' } }
-                        }
-                    }
-                });
-            })
-            .catch(error => {
-                console.error('CWE preview error:', error);
-                ctx.parentElement.innerHTML = '<div class="text-center text-muted py-4"><small>Preview unavailable</small></div>';
-            });
-    }
-
-    function initializeCnaPreview() {
-        const ctx = document.getElementById('cnaPreviewChart');
-        if (!ctx) return;
-
-        fetch('data/cna_analysis.json')
-            .then(response => response.json())
-            .then(data => {
-                const cnaData = data.cna_list || [];
-                const topCNAs = cnaData.slice(0, 5);
-                const labels = topCNAs.map(item => item.name.length > 15 ? item.name.substring(0, 15) + '...' : item.name);
-                const values = topCNAs.map(item => item.count);
-
-                new Chart(ctx, {
-                    type: 'bar',
-                    data: {
-                        labels: labels,
-                        datasets: [{
-                            data: values,
-                            backgroundColor: ['#a8c8ec', '#9bc7e1', '#8cbfdc', '#7db7d7', '#6eafd2'],
-                            borderColor: ['#9bc7e1', '#8cbfdc', '#7db7d7', '#6eafd2', '#5fa7cd'],
-                            borderWidth: 1
-                        }]
-                    },
-                    options: {
-                        responsive: true,
-                        maintainAspectRatio: false,
-                        indexAxis: 'y',
-                        plugins: { legend: { display: false } },
-                        scales: {
-                            y: { display: true, grid: { color: 'rgba(0,0,0,0.1)' } },
-                            x: { display: true, grid: { color: 'rgba(0,0,0,0.1)' } }
-                        }
-                    }
-                });
-            })
-            .catch(error => {
-                console.error('CNA preview error:', error);
-                ctx.parentElement.innerHTML = '<div class="text-center text-muted py-4"><small>Preview unavailable</small></div>';
-            });
-    }
-
-    function initializeCpePreview() {
-        const ctx = document.getElementById('cpePreviewChart');
-        if (!ctx) return;
-
-        fetch('data/cpe_analysis.json')
-            .then(response => response.json())
-            .then(data => {
-                const cpeData = data.top_cpes || [];
-                const topCPEs = cpeData.slice(0, 5);
-                const labels = topCPEs.map(item => item.vendor.length > 12 ? item.vendor.substring(0, 12) + '...' : item.vendor);
-                const values = topCPEs.map(item => item.count);
-
-                new Chart(ctx, {
-                    type: 'bar',
-                    data: {
-                        labels: labels,
-                        datasets: [{
-                            data: values,
-                            backgroundColor: ['#a8c8ec', '#9bc7e1', '#8cbfdc', '#7db7d7', '#6eafd2'],
-                            borderColor: ['#9bc7e1', '#8cbfdc', '#7db7d7', '#6eafd2', '#5fa7cd'],
-                            borderWidth: 1
-                        }]
-                    },
-                    options: {
-                        responsive: true,
-                        maintainAspectRatio: false,
-                        plugins: { legend: { display: false } },
-                        scales: {
-                            y: { display: true, grid: { color: 'rgba(0,0,0,0.1)' } },
-                            x: { display: true, grid: { color: 'rgba(0,0,0,0.1)' } }
-                        }
-                    }
-                });
-            })
-            .catch(error => {
-                console.error('CPE preview error:', error);
-                ctx.parentElement.innerHTML = '<div class="text-center text-muted py-4"><small>Preview unavailable</small></div>';
-            });
-    }
-
-    // Risk vs Volume dual-axis chart
-    function initializeRiskVolumeChart() {
-        const ctx = document.getElementById('riskVolumeChart');
-        if (!ctx) return;
-
-        // Load both yearly CVE data and KEV analysis
-        Promise.all([
-            fetch('data/yearly_summary.json').then(r => r.json()),
-            fetch('data/kev_analysis.json').then(r => r.json())
-        ])
-            .then(([yearlyData, kevData]) => {
-                const kevByYear = kevData.by_year_cve || {};
-                const yearlySummary = yearlyData.years || {};
-
-                // Get years from 2010 onwards (KEV data starts around 2002 but meaningful from 2010+)
-                const years = Object.keys(yearlySummary)
-                    .map(y => parseInt(y))
-                    .filter(y => y >= 2010)
-                    .sort((a, b) => a - b);
-
-                const labels = years.map(y => y.toString());
-                const cveVolume = years.map(y => yearlySummary[y]?.total_cves || 0);
-                const kevCount = years.map(y => kevByYear[y.toString()] || 0);
-
-                new Chart(ctx, {
-                    type: 'bar',
-                    data: {
-                        labels: labels,
-                        datasets: [
-                            {
-                                label: 'Total CVEs',
-                                data: cveVolume,
-                                backgroundColor: 'rgba(168, 200, 236, 0.7)',
-                                borderColor: '#9bc7e1',
-                                borderWidth: 1,
-                                yAxisID: 'y',
-                                order: 2
-                            },
-                            {
-                                label: 'KEV CVEs',
-                                data: kevCount,
-                                type: 'line',
-                                borderColor: '#dc3545',
-                                backgroundColor: 'rgba(220, 53, 69, 0.1)',
-                                borderWidth: 3,
-                                pointBackgroundColor: '#dc3545',
-                                pointRadius: 4,
-                                pointHoverRadius: 6,
-                                fill: false,
-                                tension: 0.3,
-                                yAxisID: 'y1',
-                                order: 1
-                            }
-                        ]
-                    },
-                    options: {
-                        responsive: true,
-                        maintainAspectRatio: false,
-                        interaction: {
-                            mode: 'index',
-                            intersect: false
-                        },
-                        plugins: {
-                            legend: {
-                                display: true,
-                                position: 'top'
-                            },
-                            tooltip: {
-                                callbacks: {
-                                    afterBody: function (context) {
-                                        const idx = context[0].dataIndex;
-                                        const volume = cveVolume[idx];
-                                        const kev = kevCount[idx];
-                                        if (volume > 0 && kev > 0) {
-                                            const pct = ((kev / volume) * 100).toFixed(2);
-                                            return `KEV Rate: ${pct}%`;
-                                        }
-                                        return '';
-                                    }
-                                }
-                            }
-                        },
-                        scales: {
-                            y: {
-                                type: 'linear',
-                                display: true,
-                                position: 'left',
-                                title: {
-                                    display: true,
-                                    text: 'Total CVEs',
-                                    font: { size: 11 }
-                                },
-                                grid: { color: 'rgba(0,0,0,0.1)' }
-                            },
-                            y1: {
-                                type: 'linear',
-                                display: true,
-                                position: 'right',
-                                title: {
-                                    display: true,
-                                    text: 'KEV CVEs',
-                                    color: '#dc3545',
-                                    font: { size: 11 }
-                                },
-                                grid: { drawOnChartArea: false },
-                                ticks: { color: '#dc3545' }
-                            },
-                            x: {
-                                grid: { color: 'rgba(0,0,0,0.1)' }
-                            }
-                        }
-                    }
-                });
-            })
-            .catch(error => {
-                console.error('Risk vs Volume chart error:', error);
-                ctx.parentElement.innerHTML = '<div class="text-center text-muted py-4"><small>Chart unavailable</small></div>';
-            });
-    }
-
-    // CVSS functionality is handled inline in the initializeCvssPreview function above
-
-    function initializeCalendarPreview() {
-        const ctx = document.getElementById('calendarPreviewChart');
-        if (!ctx) return;
-
-        fetch('data/calendar_analysis_current_year.json')
-            .then(response => response.json())
-            .then(data => {
-                // Aggregate daily_data into monthly totals
-                const dailyData = data.daily_data || [];
-                const monthlyTotals = {};
-
-                dailyData.forEach(day => {
-                    const month = day.date.substring(5, 7); // Extract MM from YYYY-MM-DD
-                    monthlyTotals[month] = (monthlyTotals[month] || 0) + day.value;
-                });
-
-                const allMonths = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-
-                // Filter to only months with data
-                const months = [];
-                const values = [];
-                allMonths.forEach((m, i) => {
-                    const key = String(i + 1).padStart(2, '0');
-                    const value = monthlyTotals[key] || 0;
-                    if (value > 0) {
-                        months.push(m);
-                        values.push(value);
-                    }
-                });
-
-                new Chart(ctx, {
-                    type: 'bar',
-                    data: {
-                        labels: months,
-                        datasets: [{
-                            data: values,
-                            backgroundColor: '#a8c8ec',
-                            borderColor: '#9bc7e1',
-                            borderWidth: 1
-                        }]
-                    },
-                    options: {
-                        responsive: true,
-                        maintainAspectRatio: false,
-                        plugins: { legend: { display: false } },
-                        scales: {
-                            y: { display: true, grid: { color: 'rgba(0,0,0,0.1)' } },
-                            x: { display: true, grid: { color: 'rgba(0,0,0,0.1)' } }
-                        }
-                    }
-                });
-            })
-            .catch(error => {
-                console.error('Calendar preview error:', error);
-                ctx.parentElement.innerHTML = '<div class="text-center text-muted py-4"><small>Preview unavailable</small></div>';
-            });
-    }
-
+CVE.page(async (S) => {
+  const { fmt, chart, el } = CVE;
+  const YR = {{ current_year }};
+
+  const years = Object.values(S.yearly_summary.years)
+    .map(y => ({ year: y.year, count: y.total_cves }))
+    .sort((a, b) => a.year - b.year);
+  const ytd = (years.find(y => y.year === YR) || {}).count || 0;
+
+  const daily = (S.calendar_analysis_current_year.daily_data || [])
+    .slice().sort((a, b) => a.date.localeCompare(b.date));
+  const last = daily[daily.length - 1] || {};
+  const dayNo = Math.max(1, Math.round((Date.now() - new Date(YR, 0, 1)) / 864e5));
+
+  const ytdRow = ((S.growth_analysis || {}).growth_data || []).find(r => r.is_ytd) || {};
+  const pace = ytdRow.projected_full_year;
+
+  // Three numbers, one line of context each: how many, how fast, how that is
+  // changing. Everything else lives in the charts below or on its own page.
+  const TILES = [
+    { lbl: 'Published to date', v: fmt.n(ytd),
+      sub: pace ? `on pace for <b>~${fmt.n(Math.round(pace / 1000) * 1000)}</b> this year`
+                : `day <b>${dayNo}</b> of ${YR}` },
+    { lbl: 'Average per day', v: fmt.n(Math.round(ytd / dayNo)),
+      sub: `across <b>${fmt.n(dayNo)}</b> days of ${YR}` },
+    { lbl: 'Year-over-year growth', v: fmt.pct(ytdRow.ytd_vs_prev_ytd),
+      sub: ytdRow.prev_year_ytd_actual
+        ? `vs <b>${fmt.n(ytdRow.prev_year_ytd_actual)}</b> by this date in ${YR - 1}`
+        : `no ${YR - 1} comparison available` }
+  ];
+
+  el('#tiles').innerHTML = TILES.map(t => `
+    <div class="c">
+      <div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div>
+      <div class="sub">${t.sub}</div>
+    </div>`).join('');
+  el('#asof').textContent = last.date ? `through ${fmt.day(last.date)}` : `${YR} to date`;
+
+  const cnas = (S.cna_analysis.cna_list || []).map(c => ({
+    label: c.name, value: (c.cves_by_year || {})[YR] || 0
+  })).sort((a, b) => b.value - a.value).slice(0, 8);
+  chart.rank('#top-cna', cnas, { compact: true, name: 'cve-icu-top-publishers' });
+
+  chart.rank('#top-cwe', (S.cwe_analysis.top_cwes || []).slice(0, 8)
+    .map(c => ({ label: c.description || c.name, sub: 'CWE-' + c.id, value: c.count })),
+    { compact: true, name: 'cve-icu-top-weaknesses' });
+
+  // top_cpes holds one row per CPE string, so the same product appears several
+  // times (windows_server_2012 r2 vs -, debian_linux 8/9/10/11). Rank the
+  // aggregated product list instead.
+  chart.rank('#top-cpe', (S.cpe_analysis.top_products || []).slice(0, 8)
+    .map(c => ({ label: c.product, value: c.count })), { compact: true, name: 'cve-icu-top-products' });
+
+  chart.bars('#chart-years', years.map(y => ({
+    label: String(y.year), value: y.count, current: y.year === YR
+  })), { tall: true, ticks: [1999, 2005, 2010, 2015, 2020, YR].map(String),
+       name: 'cve-icu-cves-by-year', label: 'CVEs published each year' });
+
+  const recent = daily.slice(-90);
+  chart.bars('#chart-days', recent.map(d => ({
+    label: d.date, value: d.value || 0, current: d === recent[recent.length - 1]
+  })), { ticks: [fmt.day(recent[0] && recent[0].date), fmt.day(last.date)],
+       name: 'cve-icu-recent-days', label: 'CVEs published per day' });
+  el('#days-side').textContent = recent.length
+    ? `${fmt.day(recent[0].date)} – ${fmt.day(last.date)}` : '';
+
+});
 </script>
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/templates/kev.html b/templates/kev.html
index adaa064925c..c8ca2b47443 100644
--- a/templates/kev.html
+++ b/templates/kev.html
@@ -1,431 +1,94 @@
 {% extends "base.html" %}
-
-{% block title %}KEV Analysis - CVEDB{% endblock %}
+{% set nav = 'scoring' %}
+{% block title %}KEV catalog &mdash; CVEDB{% endblock %}
+{% block description %}How many CVEs are in the CISA Known Exploited Vulnerabilities catalog.{% endblock %}
 
 {% block content %}
-<style>
-    .stats-grid {
-        display: grid;
-        grid-template-columns: repeat(4, 1fr);
-        gap: 1.5rem;
-        margin-bottom: 2rem;
-    }
-
-    @media (max-width: 992px) {
-        .stats-grid {
-            grid-template-columns: repeat(2, 1fr);
-        }
-    }
-
-    @media (max-width: 576px) {
-        .stats-grid {
-            grid-template-columns: 1fr;
-        }
-    }
-
-    .chart-container {
-        position: relative;
-        height: 350px;
-    }
-
-    .recent-table {
-        max-height: 500px;
-        overflow-y: auto;
-    }
-
-    .recent-table table {
-        width: 100%;
-        border-collapse: separate;
-        border-spacing: 0;
-    }
-
-    .recent-table thead {
-        position: sticky;
-        top: 0;
-        z-index: 10;
-    }
-
-    .recent-table th {
-        background: var(--color-bg-content, #ffffff);
-        box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
-        padding: 0.75rem;
-        font-weight: 600;
-        border-bottom: 2px solid var(--color-border);
-    }
-
-    .ransomware-badge {
-        background: var(--color-primary);
-        color: white;
-    }
-
-    .top-list {
-        max-height: 300px;
-        overflow-y: auto;
-    }
-
-    .top-list-item {
-        display: flex;
-        justify-content: space-between;
-        align-items: center;
-        padding: 0.5rem 0;
-        border-bottom: 1px solid var(--color-border);
-    }
-
-    .top-list-item:last-child {
-        border-bottom: none;
-    }
-
-    .count-badge {
-        background: var(--color-accent);
-        color: white;
-        padding: 0.25rem 0.5rem;
-        border-radius: var(--border-radius);
-        font-size: 0.85rem;
-        font-weight: 600;
-    }
-</style>
-
-<!-- Hero Section -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">KEV Analysis</h1>
-    <p class="text-muted">
-        CISA Known Exploited Vulnerabilities Catalog - Actively exploited CVEs
-    </p>
-</div>
-
-<!-- Stats Cards -->
-<div class="stats-grid mb-4">
-    <div class="stat-card">
-        <div class="stat-number" id="totalKev">-</div>
-        <div class="stat-label">Total KEV CVEs</div>
-        <small class="text-muted">All time</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="last30Days">-</div>
-        <div class="stat-label">Added Last 30 Days</div>
-        <small class="text-muted">Recent additions</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="last90Days">-</div>
-        <div class="stat-label">Added Last 90 Days</div>
-        <small class="text-muted">Quarter trend</small>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="ransomwareCount">-</div>
-        <div class="stat-label">Ransomware Associated</div>
-        <small class="text-muted">Known campaign use</small>
-    </div>
+<div class="ph">
+  <h1>KEV catalog</h1>
+  <span class="note">CISA Known Exploited Vulnerabilities &middot; catalog <b id="catver"></b></span>
 </div>
+<p class="lede">CVEs that CISA records as having been exploited. Counted two ways below: the year
+the CVE was published, and the year it was added to the catalog &mdash; those differ a lot.</p>
 
-<!-- Timeline and Top Vendors Row -->
-<div class="row mb-4">
-    <div class="col-lg-8 mb-4">
-        <div class="card h-100">
-            <div class="card-header">
-                <h3 class="card-title mb-0">KEV Additions Timeline</h3>
-                <small class="text-muted">Monthly additions to the KEV catalog</small>
-            </div>
-            <div class="card-body">
-                <div class="chart-container">
-                    <canvas id="timelineChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-    <div class="col-lg-4 mb-4">
-        <div class="card h-100">
-            <div class="card-header">
-                <h3 class="card-title mb-0">Top Vendors</h3>
-                <small class="text-muted">By KEV CVE count</small>
-            </div>
-            <div class="card-body">
-                <div class="top-list" id="topVendorsList">
-                    <div class="text-center text-muted">Loading...</div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
+<div class="grid" id="tiles"></div>
 
-<!-- CVE Year and CWE Analysis -->
-<div class="row mb-4">
-    <div class="col-lg-6 mb-4">
-        <div class="card h-100">
-            <div class="card-header">
-                <h3 class="card-title mb-0">KEV by CVE Publication Year</h3>
-                <small class="text-muted">When were exploited CVEs originally published?</small>
-            </div>
-            <div class="card-body">
-                <div class="chart-container">
-                    <canvas id="yearChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-    <div class="col-lg-6 mb-4">
-        <div class="card h-100">
-            <div class="card-header">
-                <h3 class="card-title mb-0">Top CWEs in KEV</h3>
-                <small class="text-muted">Most common weakness types being exploited</small>
-            </div>
-            <div class="card-body">
-                <div class="chart-container">
-                    <canvas id="cweChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
+<h2>Added to the catalog</h2>
+<div class="cols c2">
+  <div class="panel"><div class="panel-h">By year added <span class="side">when CISA listed it</span></div>
+    <div class="panel-b"><div id="by-added"></div></div></div>
+  <div class="panel"><div class="panel-h">By year published <span class="side">when the CVE was issued</span></div>
+    <div class="panel-b"><div id="by-pub"></div></div></div>
 </div>
 
-<!-- Recent Additions Table -->
-<div class="card mb-4">
-    <div class="card-header d-flex justify-content-between align-items-center">
-        <div>
-            <h3 class="card-title mb-0">Recent KEV Additions</h3>
-            <small class="text-muted">Latest vulnerabilities added to the catalog</small>
-        </div>
-        <a href="https://www.cisa.gov/known-exploited-vulnerabilities-catalog" target="_blank"
-            class="btn btn-outline-primary btn-sm">
-            View Full Catalog →
-        </a>
-    </div>
-    <div class="card-body p-0">
-        <div class="recent-table">
-            <table class="table table-striped mb-0">
-                <thead>
-                    <tr>
-                        <th>CVE ID</th>
-                        <th>Vendor / Product</th>
-                        <th>Date Added</th>
-                        <th>Due Date</th>
-                        <th>Ransomware</th>
-                    </tr>
-                </thead>
-                <tbody id="recentTable">
-                    <tr>
-                        <td colspan="5" class="text-center">Loading...</td>
-                    </tr>
-                </tbody>
-            </table>
-        </div>
-    </div>
-</div>
+<h2>Additions per month</h2>
+<div class="panel"><div class="panel-b"><div id="timeline"></div></div></div>
 
-<!-- Top Products -->
-<div class="card mb-4">
-    <div class="card-header">
-        <h3 class="card-title mb-0">Top Vendor/Products</h3>
-        <small class="text-muted">Products with the most exploited vulnerabilities</small>
-    </div>
-    <div class="card-body">
-        <div class="chart-container">
-            <canvas id="productsChart"></canvas>
-        </div>
-    </div>
+<h2>Breakdowns</h2>
+<div class="cols">
+  <div class="panel"><div class="panel-h">Vendors</div><div class="rows" id="vendors"></div></div>
+  <div class="panel"><div class="panel-h">Products</div><div class="rows" id="products"></div></div>
+  <div class="panel"><div class="panel-h">Weakness types</div><div class="rows" id="cwes"></div></div>
 </div>
 
-<!-- About KEV -->
-<div class="card">
-    <div class="card-header">
-        <h3 class="card-title mb-0">About CISA KEV</h3>
-    </div>
-    <div class="card-body">
-        <p>
-            The <strong>Known Exploited Vulnerabilities (KEV) Catalog</strong> is maintained by
-            CISA (Cybersecurity and Infrastructure Security Agency) and contains vulnerabilities
-            that have been <strong>confirmed to be actively exploited in the wild</strong>.
-        </p>
-        <ul>
-            <li><strong>Authority:</strong> U.S. federal agencies are required to remediate KEV vulnerabilities within
-                specified timeframes (BOD 22-01)</li>
-            <li><strong>Criteria:</strong> CVE must have assigned CVE ID, evidence of active exploitation, and clear
-                remediation guidance</li>
-            <li><strong>Source:</strong> <a href="https://www.cisa.gov/known-exploited-vulnerabilities-catalog"
-                    target="_blank">CISA KEV Catalog</a></li>
-        </ul>
-        <p class="text-muted mb-0">
-            If a vulnerability is in KEV, it should be treated as high priority regardless of its CVSS or EPSS scores.
-        </p>
-    </div>
-</div>
+<h2>Most recent additions</h2>
+<div class="panel"><div id="recent-table"></div></div>
+{% endblock %}
 
-<script src="static/js/chart.min.js"></script>
+{% block scripts %}
 <script>
-    fetch('data/kev_analysis.json')
-        .then(r => r.json())
-        .then(data => {
-            // Update stats cards
-            document.getElementById('totalKev').textContent =
-                data.total_kev_cves.toLocaleString();
-            document.getElementById('last30Days').textContent =
-                data.statistics.added_last_30_days.toLocaleString();
-            document.getElementById('last90Days').textContent =
-                data.statistics.added_last_90_days.toLocaleString();
-            document.getElementById('ransomwareCount').textContent =
-                data.statistics.ransomware_associated.toLocaleString();
-
-            // Timeline Chart
-            const timelineLabels = Object.keys(data.timeline).slice(-24); // Last 24 months
-            const timelineData = timelineLabels.map(k => data.timeline[k]);
-
-            new Chart(document.getElementById('timelineChart'), {
-                type: 'bar',
-                data: {
-                    labels: timelineLabels,
-                    datasets: [{
-                        label: 'CVEs Added',
-                        data: timelineData,
-                        backgroundColor: 'rgba(13, 110, 253, 0.8)',
-                        borderColor: 'rgba(13, 110, 253, 1)',
-                        borderWidth: 1
-                    }]
-                },
-                options: {
-                    responsive: true,
-                    maintainAspectRatio: false,
-                    plugins: {
-                        legend: { display: false }
-                    },
-                    scales: {
-                        x: {
-                            ticks: {
-                                maxRotation: 45,
-                                minRotation: 45
-                            }
-                        },
-                        y: {
-                            beginAtZero: true
-                        }
-                    }
-                }
-            });
-
-            // Top Vendors List
-            const vendorsList = document.getElementById('topVendorsList');
-            vendorsList.innerHTML = data.top_vendors.slice(0, 15).map(([vendor, count]) => `
-            <div class="top-list-item">
-                <span>${vendor}</span>
-                <span class="count-badge">${count}</span>
-            </div>
-        `).join('');
-
-            // CVE Year Chart
-            const yearLabels = Object.keys(data.by_year_cve).filter(y => parseInt(y) >= 2010);
-            const yearData = yearLabels.map(y => data.by_year_cve[y] || 0);
-
-            new Chart(document.getElementById('yearChart'), {
-                type: 'bar',
-                data: {
-                    labels: yearLabels,
-                    datasets: [{
-                        label: 'KEV CVEs',
-                        data: yearData,
-                        backgroundColor: 'rgba(33, 150, 243, 0.8)',
-                        borderColor: 'rgba(33, 150, 243, 1)',
-                        borderWidth: 1
-                    }]
-                },
-                options: {
-                    responsive: true,
-                    maintainAspectRatio: false,
-                    plugins: {
-                        legend: { display: false }
-                    },
-                    scales: {
-                        y: {
-                            beginAtZero: true
-                        }
-                    }
-                }
-            });
-
-            // CWE Chart
-            const cweLabels = data.top_cwes.slice(0, 10).map(([cwe]) => cwe);
-            const cweData = data.top_cwes.slice(0, 10).map(([, count]) => count);
-
-            new Chart(document.getElementById('cweChart'), {
-                type: 'bar',
-                data: {
-                    labels: cweLabels,
-                    datasets: [{
-                        label: 'Count',
-                        data: cweData,
-                        backgroundColor: 'rgba(100, 181, 246, 0.8)',
-                        borderColor: 'rgba(100, 181, 246, 1)',
-                        borderWidth: 1
-                    }]
-                },
-                options: {
-                    responsive: true,
-                    maintainAspectRatio: false,
-                    indexAxis: 'y',
-                    plugins: {
-                        legend: { display: false }
-                    },
-                    scales: {
-                        x: {
-                            beginAtZero: true
-                        }
-                    }
-                }
-            });
-
-            // Products Chart
-            const productLabels = data.top_products.slice(0, 10).map(([p]) =>
-                p.length > 30 ? p.substring(0, 30) + '...' : p
-            );
-            const productData = data.top_products.slice(0, 10).map(([, count]) => count);
-
-            new Chart(document.getElementById('productsChart'), {
-                type: 'bar',
-                data: {
-                    labels: productLabels,
-                    datasets: [{
-                        label: 'KEV CVEs',
-                        data: productData,
-                        backgroundColor: 'rgba(66, 165, 245, 0.8)',
-                        borderColor: 'rgba(66, 165, 245, 1)',
-                        borderWidth: 1
-                    }]
-                },
-                options: {
-                    responsive: true,
-                    maintainAspectRatio: false,
-                    indexAxis: 'y',
-                    plugins: {
-                        legend: { display: false }
-                    },
-                    scales: {
-                        x: {
-                            beginAtZero: true
-                        }
-                    }
-                }
-            });
-
-            // Recent Additions Table
-            const tbody = document.getElementById('recentTable');
-            tbody.innerHTML = data.recent_additions.map(item => `
-            <tr>
-                <td>
-                    <a href="https://nvd.nist.gov/vuln/detail/${item.cve_id}" target="_blank">
-                        ${item.cve_id}
-                    </a>
-                </td>
-                <td>${item.vendor} - ${item.product}</td>
-                <td>${item.date_added}</td>
-                <td>${item.due_date || 'N/A'}</td>
-                <td>
-                    ${item.ransomware && item.ransomware.toLowerCase() !== 'unknown' && item.ransomware.toLowerCase() !== 'no'
-                    ? '<span class="badge ransomware-badge">Yes</span>'
-                    : '<span class="text-muted">-</span>'}
-                </td>
-            </tr>
-        `).join('');
-        })
-        .catch(err => {
-            console.error('Failed to load KEV data:', err);
-        });
+CVE.page(async () => {
+  const { fmt, chart, el, table } = CVE;
+  const YR = {{ current_year }};
+  const d = await CVE.json('kev_analysis.json');
+  const st = d.statistics || {};
+  const total = d.total_kev_cves || 0;
+  el('#catver').textContent = d.catalog_version || '—';
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'CVEs in the catalog', v: fmt.n(total),
+      sub: `catalog version <b>${CVE.esc(d.catalog_version || '—')}</b>` },
+    { lbl: 'Added in 30 days', v: fmt.n(st.added_last_30_days), sub: 'most recent month' },
+    { lbl: 'Added in 90 days', v: fmt.n(st.added_last_90_days), sub: 'most recent quarter' },
+    { lbl: 'Linked to ransomware', v: fmt.n(st.ransomware_associated),
+      sub: `<b>${fmt.share(st.ransomware_associated, total, 0)}</b> of the catalog` }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  const added = d.by_year_added || {}, addedY = Object.keys(added).sort();
+  chart.bars('#by-added', addedY.map(y => ({
+    label: y, value: added[y], current: +y === YR
+  })), { ticks: [addedY[0], addedY[addedY.length - 1]] , name: 'cve-icu-kev-by-year-added' });
+
+  const pub = d.by_year_published || {}, pubY = Object.keys(pub).sort();
+  chart.bars('#by-pub', pubY.map(y => ({
+    label: y, value: pub[y], current: +y === YR
+  })), { ticks: [pubY[0], pubY[pubY.length - 1]] , name: 'cve-icu-kev-by-year-published' });
+
+  const tl = d.timeline || {}, months = Object.keys(tl).sort();
+  chart.bars('#timeline', months.map(m => ({ label: m, value: tl[m] })),
+    { tall: true, ticks: [months[0], months[months.length - 1]] , name: 'cve-icu-kev-additions-per-month' });
+
+  // these arrive as [name, count] pairs
+  const pairs = a => (a || []).map(x => Array.isArray(x)
+    ? { label: x[0], value: x[1] } : { label: x.name || x.vendor || x.product, value: x.count });
+  chart.rank('#vendors', pairs(d.top_vendors).slice(0, 10), { name: 'cve-icu-kev-vendors' });
+  chart.rank('#products', pairs(d.top_products).slice(0, 10), { name: 'cve-icu-kev-products' });
+  chart.rank('#cwes', pairs(d.top_cwes).slice(0, 10), { name: 'cve-icu-kev-weaknesses' });
+
+  table('#recent-table', (d.recent_additions || []).map(r => ({
+    cve: r.cve_id, vendor: r.vendor, product: r.product,
+    added: r.date_added, due: r.due_date, ransomware: r.ransomware
+  })), [
+    { key: 'cve', label: 'CVE' },
+    { key: 'vendor', label: 'Vendor' },
+    { key: 'product', label: 'Product' },
+    { key: 'added', label: 'Added' },
+    { key: 'due', label: 'Remediation due' },
+    { key: 'ransomware', label: 'Ransomware',
+      fmt: v => v && v !== 'Unknown' ? `<span class="pill warn">${CVE.esc(v)}</span>`
+        : `<span class="faint">${CVE.esc(v || '—')}</span>` }
+  ], { sort: { key: 'added', dir: -1 } }, { name: 'cve-icu-kev-recent-additions' });
+});
 </script>
-
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/templates/scoring.html b/templates/scoring.html
index 41aabbe2b7f..3bd0f1f2679 100644
--- a/templates/scoring.html
+++ b/templates/scoring.html
@@ -1,479 +1,95 @@
 {% extends "base.html" %}
-
-{% block title %}Scoring Intelligence Hub - CVEDB{% endblock %}
+{% set nav = 'scoring' %}
+{% block title %}Scoring &mdash; CVEDB{% endblock %}
+{% block description %}Counts for the three CVE scoring systems: CVSS, EPSS and CISA KEV.{% endblock %}
 
 {% block content %}
-<style>
-    .stats-grid {
-        display: grid;
-        grid-template-columns: repeat(3, 1fr);
-        gap: 1.5rem;
-        margin-bottom: 2rem;
-    }
-
-    @media (max-width: 992px) {
-        .stats-grid {
-            grid-template-columns: repeat(1, 1fr);
-        }
-    }
-
-    .scoring-card {
-        background: var(--color-bg-content);
-        border: 1px solid var(--color-border);
-        border-radius: var(--border-radius-lg);
-        padding: 1.5rem;
-        transition: transform 0.2s, box-shadow 0.2s;
-        height: 100%;
-    }
-
-    .scoring-card:hover {
-        transform: translateY(-2px);
-        box-shadow: var(--box-shadow-lg);
-    }
-
-    .scoring-card h3 {
-        font-size: 1.25rem;
-        font-weight: var(--font-weight-semibold);
-        margin-bottom: 0;
-        color: var(--color-text-primary);
-    }
-
-    .scoring-card .badge {
-        font-size: 0.75rem;
-        padding: 0.25rem 0.5rem;
-        font-weight: var(--font-weight-medium);
-    }
-
-    .scoring-card .big-number {
-        font-size: 2.5rem;
-        font-weight: var(--font-weight-bold);
-        color: var(--color-primary);
-        line-height: 1.2;
-        margin: 0.5rem 0 0.25rem 0;
-    }
-
-    .scoring-card .stat-label {
-        font-size: 0.9rem;
-        color: var(--color-text-secondary);
-        margin-bottom: 0.75rem;
-    }
-
-    .scoring-card .description {
-        color: var(--color-text-secondary);
-        font-size: 0.9rem;
-        margin: 0.75rem 0;
-        line-height: 1.5;
-    }
-
-    .scoring-card .question {
-        font-style: italic;
-        color: var(--color-text-secondary);
-        font-size: 0.85rem;
-        padding: 0.75rem;
-        background: var(--color-bg-secondary);
-        border-radius: var(--border-radius);
-        margin-top: auto;
-    }
-
-    .nav-card {
-        display: block;
-        text-decoration: none;
-        color: inherit;
-    }
-
-    .nav-card:hover {
-        text-decoration: none;
-        color: inherit;
-    }
-
-    .matrix-cell {
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        aspect-ratio: 1;
-        border-radius: var(--border-radius);
-        font-weight: 600;
-        font-size: 0.8rem;
-        cursor: pointer;
-        transition: transform 0.1s;
-    }
-
-    .matrix-cell:hover {
-        transform: scale(1.05);
-    }
-
-    .comparison-table {
-        width: 100%;
-        border-collapse: collapse;
-    }
-
-    .comparison-table th,
-    .comparison-table td {
-        padding: 0.75rem;
-        text-align: left;
-        border-bottom: 1px solid var(--color-border);
-    }
-
-    .comparison-table th {
-        background: var(--color-bg-secondary);
-        font-weight: var(--font-weight-semibold);
-    }
-</style>
-
-<!-- Hero Section -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">Scoring Intelligence Hub</h1>
-    <p class="text-muted">
-        Compare and understand vulnerability scoring systems: CVSS, EPSS, and KEV
-    </p>
+<div class="ph"><h1>Scoring</h1><span class="note">three systems, three different questions</span></div>
+<p class="lede">Three separate records attach to CVEs. They are not ranks of each other and we do
+not combine them &mdash; below is how many CVEs each one covers.</p>
+
+<div class="grid g3" id="systems"></div>
+
+<h2>Coverage</h2>
+<div class="panel"><div class="panel-b"><div id="coverage"></div></div></div>
+
+<h2>How many carry each record</h2>
+<div class="cols">
+  <a class="panel" href="cvss.html" style="display:block">
+    <div class="panel-h">CVSS <span class="side">&rarr;</span></div>
+    <div class="panel-b"><div class="v" id="v-cvss" style="font:700 30px var(--num);letter-spacing:-.02em"></div>
+      <div class="muted" style="font-size:12.5px;margin-top:5px">scores recorded, across four metric versions</div></div>
+  </a>
+  <a class="panel" href="epss.html" style="display:block">
+    <div class="panel-h">EPSS <span class="side">&rarr;</span></div>
+    <div class="panel-b"><div class="v" id="v-epss" style="font:700 30px var(--num);letter-spacing:-.02em"></div>
+      <div class="muted" style="font-size:12.5px;margin-top:5px">CVEs with an exploit-probability score</div></div>
+  </a>
+  <a class="panel" href="kev.html" style="display:block">
+    <div class="panel-h">KEV <span class="side">&rarr;</span></div>
+    <div class="panel-b"><div class="v" id="v-kev" style="font:700 30px var(--num);letter-spacing:-.02em"></div>
+      <div class="muted" style="font-size:12.5px;margin-top:5px">CVEs in the CISA catalog</div></div>
+  </a>
 </div>
 
-<!-- Main Scoring Systems Cards -->
-<div class="stats-grid mb-5">
-    <!-- CVSS Card -->
-    <a href="cvss.html" class="nav-card">
-        <div class="scoring-card">
-            <div class="d-flex justify-content-between align-items-start mb-2">
-                <h3>CVSS</h3>
-                <span class="badge bg-primary">Severity</span>
-            </div>
-            <div class="big-number" id="cvssCount">-</div>
-            <div class="stat-label">Scored CVEs</div>
-            <p class="description">
-                Common Vulnerability Scoring System measures the <strong>severity and impact</strong> of vulnerabilities
-                on a 0-10 scale.
-            </p>
-            <div class="question">
-                💡 "How bad is this vulnerability?"
-            </div>
-        </div>
-    </a>
-
-    <!-- EPSS Card -->
-    <a href="epss.html" class="nav-card">
-        <div class="scoring-card">
-            <div class="d-flex justify-content-between align-items-start mb-2">
-                <h3>EPSS</h3>
-                <span class="badge bg-warning text-dark">Probability</span>
-            </div>
-            <div class="big-number" id="epssCount">-</div>
-            <div class="stat-label">Scored CVEs</div>
-            <p class="description">
-                Exploit Prediction Scoring System predicts the <strong>likelihood of exploitation</strong> within 30
-                days.
-            </p>
-            <div class="question">
-                💡 "Will this vulnerability be exploited?"
-            </div>
-        </div>
-    </a>
+<h2>Severity bands <span class="side">CVSS v3.1, the most-used version</span></h2>
+<div class="panel"><div class="panel-b"><div id="sev"></div></div></div>
+{% endblock %}
 
-    <!-- KEV Card -->
-    <a href="kev.html" class="nav-card">
-        <div class="scoring-card">
-            <div class="d-flex justify-content-between align-items-start mb-2">
-                <h3>KEV</h3>
-                <span class="badge bg-danger">Exploited</span>
-            </div>
-            <div class="big-number" id="kevCount">-</div>
-            <div class="stat-label">Known Exploited</div>
-            <p class="description">
-                CISA's Known Exploited Vulnerabilities catalog lists CVEs <strong>confirmed to be actively
-                    exploited</strong>.
-            </p>
-            <div class="question">
-                💡 "Is this vulnerability being exploited now?"
-            </div>
-        </div>
-    </a>
-</div>
-
-<!-- Risk Matrix Section -->
-<div class="card mb-4">
-    <div class="card-header">
-        <h3 class="card-title mb-0">Risk Matrix: CVSS × EPSS</h3>
-        <small class="text-muted">Combining severity (CVSS) with exploitation likelihood (EPSS)</small>
-    </div>
-    <div class="card-body">
-        <div id="riskMatrixContainer" style="position: relative; height: 400px;">
-            <canvas id="riskMatrixChart"></canvas>
-        </div>
-    </div>
-</div>
-
-<!-- Comparison Table -->
-<div class="card mb-4">
-    <div class="card-header">
-        <h3 class="card-title mb-0">System Comparison</h3>
-    </div>
-    <div class="card-body">
-        <table class="comparison-table">
-            <thead>
-                <tr>
-                    <th>Aspect</th>
-                    <th>CVSS</th>
-                    <th>EPSS</th>
-                    <th>KEV</th>
-                </tr>
-            </thead>
-            <tbody>
-                <tr>
-                    <td><strong>Purpose</strong></td>
-                    <td>Measure severity/impact</td>
-                    <td>Predict exploitation probability</td>
-                    <td>Confirm active exploitation</td>
-                </tr>
-                <tr>
-                    <td><strong>Scale</strong></td>
-                    <td>0.0 - 10.0</td>
-                    <td>0.0 - 1.0 (probability)</td>
-                    <td>Yes / No (binary)</td>
-                </tr>
-                <tr>
-                    <td><strong>Source</strong></td>
-                    <td>NVD / Vendors</td>
-                    <td>FIRST.org</td>
-                    <td>CISA</td>
-                </tr>
-                <tr>
-                    <td><strong>Update Frequency</strong></td>
-                    <td>Per CVE publication</td>
-                    <td>Daily</td>
-                    <td>As exploits confirmed</td>
-                </tr>
-                <tr>
-                    <td><strong>Coverage</strong></td>
-                    <td id="cvssTableCount">-</td>
-                    <td id="epssTableCount">-</td>
-                    <td id="kevTableCount">-</td>
-                </tr>
-            </tbody>
-        </table>
-    </div>
-</div>
-
-<!-- Overlap Insights -->
-<div class="row mb-4">
-    <div class="col-md-4">
-        <div class="stat-card text-center">
-            <div class="stat-number" id="epssKevOverlap">-</div>
-            <div class="stat-label">EPSS &amp; KEV</div>
-            <small class="text-muted">KEV CVEs with EPSS scores</small>
-        </div>
-    </div>
-    <div class="col-md-4">
-        <div class="stat-card text-center">
-            <div class="stat-number" id="highEpssNotKev">-</div>
-            <div class="stat-label">High EPSS, Not KEV</div>
-            <small class="text-muted">EPSS > 0.5 but not in KEV</small>
-        </div>
-    </div>
-    <div class="col-md-4">
-        <div class="stat-card text-center">
-            <div class="stat-number" id="kevLowEpss">-</div>
-            <div class="stat-label">KEV with Low EPSS</div>
-            <small class="text-muted">In KEV but EPSS < 0.1</small>
-        </div>
-    </div>
-</div>
-
-<script src="static/js/chart.min.js"></script>
+{% block scripts %}
 <script>
-    // Load scoring comparison data
-    Promise.all([
-        fetch('data/scoring_comparison.json').then(r => r.json()),
-        fetch('data/risk_matrix.json').then(r => r.json()),
-        fetch('data/epss_analysis.json').then(r => r.json())
-    ]).then(([comparison, matrix, epss]) => {
-        // Update system cards
-        document.getElementById('cvssCount').textContent =
-            (comparison.systems.cvss.total_scored || 0).toLocaleString();
-        document.getElementById('epssCount').textContent =
-            (comparison.systems.epss.total_scored || 0).toLocaleString();
-        document.getElementById('kevCount').textContent =
-            (comparison.systems.kev.total_scored || 0).toLocaleString();
-
-        // Update comparison table
-        document.getElementById('cvssTableCount').textContent =
-            (comparison.systems.cvss.total_scored || 0).toLocaleString() + ' CVEs';
-        document.getElementById('epssTableCount').textContent =
-            (comparison.systems.epss.total_scored || 0).toLocaleString() + ' CVEs';
-        document.getElementById('kevTableCount').textContent =
-            (comparison.systems.kev.total_scored || 0).toLocaleString() + ' CVEs';
-
-        // Update overlap insights
-        document.getElementById('epssKevOverlap').textContent =
-            (comparison.overlaps.epss_and_kev || 0).toLocaleString();
-        document.getElementById('highEpssNotKev').textContent =
-            (comparison.insights.epss_gt_05_not_kev || 0).toLocaleString();
-        document.getElementById('kevLowEpss').textContent =
-            (comparison.insights.kev_with_low_epss || 0).toLocaleString();
-
-        // Render Risk Matrix as bubble chart
-        renderRiskMatrix(matrix);
-
-    }).catch(err => {
-        console.error('Failed to load scoring data:', err);
-    });
-
-    function renderRiskMatrix(matrix) {
-        const ctx = document.getElementById('riskMatrixChart').getContext('2d');
-
-        // Map severity to x position
-        const severityMap = { 'NONE': 0, 'LOW': 1, 'MEDIUM': 2, 'HIGH': 3, 'CRITICAL': 4 };
-        const epssMap = { '0-0.1': 0, '0.1-0.3': 1, '0.3-0.5': 2, '0.5-0.7': 3, '0.7+': 4 };
-
-        // Prepare data points
-        const dataPoints = [];
-        const kevPoints = [];
-        let maxCount = 0;
-
-        matrix.matrix.forEach(cell => {
-            if (cell.count > 0) {
-                maxCount = Math.max(maxCount, cell.count);
-                dataPoints.push({
-                    x: severityMap[cell.severity],
-                    y: epssMap[cell.epss_bucket],
-                    r: Math.sqrt(cell.count) / 10,  // Scale radius
-                    count: cell.count,
-                    kev_count: cell.kev_count,
-                    label: `${cell.severity} / ${cell.epss_bucket}`
-                });
-            }
-        });
-
-        new Chart(ctx, {
-            type: 'bubble',
-            data: {
-                datasets: [{
-                    label: 'CVE Concentration',
-                    data: dataPoints.map(p => ({
-                        x: p.x,
-                        y: p.y,
-                        r: Math.max(5, Math.min(40, p.r)),
-                        count: p.count,
-                        kev_count: p.kev_count
-                    })),
-                    backgroundColor: dataPoints.map(p => {
-                        // Color based on risk using blues and greys
-                        const risk = (p.x + p.y) / 8;
-                        if (risk > 0.7) return 'rgba(13, 110, 253, 0.85)';   // Primary blue (highest risk)
-                        if (risk > 0.5) return 'rgba(33, 150, 243, 0.75)';   // Medium blue
-                        if (risk > 0.3) return 'rgba(100, 181, 246, 0.65)';  // Light blue
-                        return 'rgba(158, 158, 158, 0.5)';                    // Grey (lowest risk)
-                    }),
-                    borderColor: dataPoints.map(p => {
-                        const risk = (p.x + p.y) / 8;
-                        if (risk > 0.7) return 'rgba(13, 110, 253, 1)';
-                        if (risk > 0.5) return 'rgba(33, 150, 243, 1)';
-                        if (risk > 0.3) return 'rgba(100, 181, 246, 1)';
-                        return 'rgba(117, 117, 117, 1)';
-                    }),
-                    borderWidth: 2
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                layout: {
-                    padding: {
-                        left: 10,
-                        right: 20,
-                        top: 10,
-                        bottom: 10
-                    }
-                },
-                scales: {
-                    x: {
-                        type: 'linear',
-                        position: 'bottom',
-                        min: -0.5,
-                        max: 4.5,
-                        title: {
-                            display: true,
-                            text: 'CVSS Score',
-                            font: {
-                                size: 13,
-                                weight: '600'
-                            },
-                            padding: { top: 8 }
-                        },
-                        afterBuildTicks: function (axis) {
-                            axis.ticks = [
-                                { value: 0, label: 'NONE' },
-                                { value: 1, label: 'LOW' },
-                                { value: 2, label: 'MEDIUM' },
-                                { value: 3, label: 'HIGH' },
-                                { value: 4, label: 'CRITICAL' }
-                            ];
-                        },
-                        ticks: {
-                            callback: function (value, index, ticks) {
-                                const labels = ['NONE', 'LOW', 'MEDIUM', 'HIGH', 'CRITICAL'];
-                                return labels[value] || '';
-                            },
-                            font: { size: 10 },
-                            maxRotation: 0
-                        },
-                        grid: {
-                            color: 'rgba(0, 0, 0, 0.08)',
-                            drawTicks: true
-                        }
-                    },
-                    y: {
-                        type: 'linear',
-                        min: -0.5,
-                        max: 4.5,
-                        title: {
-                            display: true,
-                            text: 'EPSS Score',
-                            font: {
-                                size: 13,
-                                weight: '600'
-                            },
-                            padding: { bottom: 8 }
-                        },
-                        afterBuildTicks: function (axis) {
-                            axis.ticks = [
-                                { value: 0, label: '0-0.1' },
-                                { value: 1, label: '0.1-0.3' },
-                                { value: 2, label: '0.3-0.5' },
-                                { value: 3, label: '0.5-0.7' },
-                                { value: 4, label: '0.7+' }
-                            ];
-                        },
-                        ticks: {
-                            callback: function (value, index, ticks) {
-                                const labels = ['0-0.1', '0.1-0.3', '0.3-0.5', '0.5-0.7', '0.7+'];
-                                return labels[value] || '';
-                            },
-                            font: { size: 10 }
-                        },
-                        grid: {
-                            color: 'rgba(0, 0, 0, 0.08)',
-                            drawTicks: true
-                        }
-                    }
-                },
-                plugins: {
-                    legend: {
-                        display: false
-                    },
-                    tooltip: {
-                        callbacks: {
-                            label: function (context) {
-                                const data = context.raw;
-                                return [
-                                    `CVEs: ${data.count.toLocaleString()}`,
-                                    `KEV: ${data.kev_count.toLocaleString()}`
-                                ];
-                            }
-                        }
-                    }
-                }
-            }
-        });
-    }
+CVE.page(async (S) => {
+  const { fmt, chart, el } = CVE;
+  const [cmp, cvss, epss] = await Promise.all([
+    CVE.json('scoring_comparison.json'),
+    CVE.json('cvss_analysis.json'),
+    CVE.json('epss_analysis.json')
+  ]);
+  const total = Object.values(S.yearly_summary.years).reduce((s, y) => s + y.total_cves, 0);
+  const sys = cmp.systems || {};
+
+  el('#systems').innerHTML = ['cvss', 'epss', 'kev'].map(k => {
+    const s = sys[k] || {};
+    return `<div class="c">
+      <div class="lbl">${CVE.esc(s.name || k.toUpperCase())}</div>
+      <div class="v" style="font-size:19px;letter-spacing:-.01em;font-family:var(--sans);font-weight:650">
+        ${CVE.esc(s.question || '')}</div>
+      <div class="sub">${CVE.esc(s.description || '')}<br>
+        <span class="faint">${CVE.esc(s.source || '')} &middot; updated ${CVE.esc(s.update_frequency || '')}</span></div>
+    </div>`;
+  }).join('');
+
+  const kevN = cvss.kev_global_count || 0;
+  el('#v-cvss').textContent = fmt.n(cvss.total_cves_with_cvss);
+  el('#v-epss').textContent =
+    fmt.n(epss.total_cves_with_epss_matched ?? epss.total_cves_with_epss);
+  el('#v-kev').textContent = fmt.n(kevN);
+
+  // EPSS coverage is bucketed by publication date, so it is directly comparable
+  // with the site's own counts. A few EPSS rows describe CVEs this site does not
+  // count at all (rejected, or not yet published here) - shown separately.
+  const epssMatched = epss.total_cves_with_epss_matched ?? epss.total_cves_with_epss ?? 0;
+  const epssUnmatched = epss.epss_without_published_record ?? 0;
+
+  chart.hbars('#coverage', [
+    { label: 'CVEs counted here', value: total },
+    { label: 'With an EPSS score', value: epssMatched },
+    { label: 'CVSS scores', value: cvss.total_cves_with_cvss || 0 },
+    { label: 'In KEV', value: kevN }
+  ], { name: 'cve-icu-scoring-coverage' });
+  el('#coverage').insertAdjacentHTML('beforeend',
+    `<p class="faint" style="font-size:12px;margin-top:11px;line-height:1.6">
+     <b>With an EPSS score</b> is a genuine subset: EPSS rows are matched to CVEs by
+     publication date, the same basis every other count here uses.${epssUnmatched ? `
+     A further <b>${fmt.n(epssUnmatched)}</b> EPSS rows describe CVEs this site does not
+     count &mdash; rejected records, or ones not published here yet &mdash; and are left out
+     rather than attributed to a year.` : ''}<br>
+     <b>CVSS scores</b> is not a subset: it counts scores, not CVEs, because one CVE can
+     hold a score under several metric versions. It is the only bar that can exceed the total.</p>`);
+
+  const v31 = (cvss.severity_distribution || {})['v3.1'] || {};
+  chart.hbars('#sev', ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'NONE']
+    .filter(k => v31[k]).map(k => ({ label: k, value: v31[k] })), { name: 'cve-icu-cvss-severity-bands' });
+});
 </script>
-
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/templates/years.html b/templates/years.html
index 9636b0c1deb..cee9d90cc97 100644
--- a/templates/years.html
+++ b/templates/years.html
@@ -1,1776 +1,272 @@
 {% extends "base.html" %}
-
-{% block title %}CVE Year Analysis - CVEDB{% endblock %}
+{% set nav = 'years' %}
+{% block title %}CVEs by year &mdash; CVEDB{% endblock %}
+{% block description %}How many CVEs were published each year from 1999 to {{ current_year }}. Compare any set of years.{% endblock %}
 
 {% block content %}
-<!-- Page Header -->
-<div class="page-header mb-4 text-center">
-    <h1 class="display-4 mb-2">CVE Year Analysis</h1>
-    <small class="text-muted d-block mb-3">
-        Comprehensive analysis of CVE data across {{ available_years|length }} years (1999-{{ current_year }})
-    </small>
-</div>
-
-<!-- Statistics Cards -->
-<div class="stats-grid">
-    <div class="stat-card">
-        <div class="stat-number" id="selectedCount">1</div>
-        <div class="stat-label">Years Selected</div>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="selectedCvesTotal">Loading...</div>
-        <div class="stat-label">CVEs in Selection</div>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="dailyAverage">Loading...</div>
-        <div class="stat-label">Daily Average</div>
-    </div>
-    <div class="stat-card">
-        <div class="stat-number" id="totalCvesGlobal">Loading...</div>
-        <div class="stat-label">Total All CVEs</div>
-    </div>
-</div>
-
-<!-- Year Selection Section -->
-<div class="card mb-3">
-    <div class="card-header py-2">
-        <h2 class="card-title mb-0" style="font-size: 1.1rem;">Select Years to Compare</h2>
-    </div>
-    <div class="card-body py-3">
-        <!-- Year Grid -->
-        <div class="year-grid" id="yearSelector">
-            {% for year in available_years %}
-            <label class="year-item">
-                <input type="checkbox" value="{{ year }}">
-                <span class="year-label">{{ year }}</span>
-            </label>
-            {% endfor %}
-        </div>
-
-        <!-- Quick Selection Buttons -->
-        <div class="quick-select-buttons mt-3" style="text-align: center;">
-            <button class="quick-select-btn" onclick="selectRecentYears()">Recent 5 Years</button>
-            <button class="quick-select-btn" onclick="selectDecade('2020s')">2020s</button>
-            <button class="quick-select-btn" onclick="selectDecade('2010s')">2010s</button>
-            <button class="quick-select-btn" onclick="selectAllYears()">All Years</button>
-            <button class="quick-select-btn secondary" onclick="clearSelection()">Clear</button>
-        </div>
-    </div>
+<div class="ph">
+  <h1>CVEs by year</h1>
+  <span class="note">1999&ndash;{{ current_year }}</span>
+  <span style="margin-left:auto" class="ph-actions">
+    <button class="exp-btn" id="share">Share link</button>
+    <button class="exp-btn" id="print">Print</button>
+  </span>
 </div>
-
-<!-- Charts Section -->
-<div class="card mb-3">
-    <div class="card-header py-2">
-        <h2 class="card-title mb-0" style="font-size: 1.1rem;">CVE Trends Over Time</h2>
-    </div>
-    <div class="card-body py-3">
-        <div class="chart-container" style="height: 300px;">
-            <canvas id="yearlyChart"></canvas>
-        </div>
+<p class="lede">Select any set of years to compare. {{ current_year }} is still in progress,
+so its bar keeps growing.</p>
+
+<div class="grid g4" id="tiles"></div>
+
+<h2>Select years <span class="side" id="sel-note"></span></h2>
+<div class="panel">
+  <div class="panel-b">
+    <div class="chips" id="quick" style="margin-bottom:10px">
+      <button class="chip" data-q="recent5">Recent 5 years</button>
+      <button class="chip" data-q="2020s">2020s</button>
+      <button class="chip" data-q="2010s">2010s</button>
+      <button class="chip" data-q="2000s">2000s</button>
+      <button class="chip" data-q="all">All years</button>
+      <button class="chip" data-q="clear">Clear</button>
     </div>
+    <div class="chips" id="chips"></div>
+  </div>
 </div>
 
-<!-- Additional Charts Grid -->
-<div class="row">
-    <div class="col-md-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title mb-0" style="font-size: 1.1rem;">CVSS Score Distribution</h3>
-            </div>
-            <div class="card-body">
-                <div class="chart-container">
-                    <canvas id="severityChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
+<h2>CVEs published each year <span class="side">selected years highlighted</span></h2>
+<div class="panel"><div class="panel-b"><div id="chart-years"></div></div></div>
 
-    <div class="col-md-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">Top CVE Numbering Authorities (CNAs)</h3>
-                <small class="text-muted">Showing top 15 CNAs by CVE count</small>
-            </div>
-            <div class="card-body">
-                <div class="chart-container">
-                    <canvas id="vendorChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- Additional Charts Row 2 -->
-<div class="row">
-    <div class="col-md-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">Top CWE Vulnerability Types</h3>
-                <small class="text-muted">Showing top 15 vulnerability types by count</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="cweChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <div class="col-md-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">Top Affected Vendors</h3>
-                <small class="text-muted">Showing top 15 vendors by vulnerability count</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="affectedVendorChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- Additional Charts Row 3 -->
-<div class="row">
-    <div class="col-md-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">Vulnerability Analysis Status</h3>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="analysisStatusChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <div class="col-md-6 mb-4">
-        <div class="card">
-            <div class="card-header py-2">
-                <h3 class="card-title" style="font-size: 1.1rem;">Reference Types Distribution</h3>
-                <small class="text-muted">Showing top 10 reference types by count</small>
-            </div>
-            <div class="card-body py-3">
-                <div class="chart-container" style="height: 300px;">
-                    <canvas id="referenceTagsChart"></canvas>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- Smart Insights Panel -->
-<div class="card mb-3">
-    <div class="card-header py-2">
-        <h2 class="card-title mb-0" style="font-size: 1.1rem;">📊 Smart Insights</h2>
-    </div>
-    <div class="card-body py-3">
-        <div class="row" id="smartInsights">
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">📈</div>
-                    <div class="insight-content">
-                        <h4 class="insight-title">Publication Peak</h4>
-                        <p class="insight-text" id="peakInsight">Loading...</p>
-                    </div>
-                </div>
-            </div>
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">🎯</div>
-                    <div class="insight-content">
-                        <h4 class="insight-title">Top Vulnerability</h4>
-                        <p class="insight-text" id="topVulnInsight">Loading...</p>
-                    </div>
-                </div>
-            </div>
-            <div class="col-md-4 mb-3">
-                <div class="insight-card">
-                    <div class="insight-icon">⚡</div>
-                    <div class="insight-content">
-                        <h4 class="insight-title">Analysis Status</h4>
-                        <p class="insight-text" id="analysisInsight">Loading...</p>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
+<div id="compare"></div>
+<div id="year-detail"></div>
 
-<!-- Export and Share Panel -->
-<div class="card mb-3">
-    <div class="card-header py-2">
-        <h2 class="card-title mb-0" style="font-size: 1.1rem;">📤 Export & Share</h2>
-    </div>
-    <div class="card-body py-3">
-        <div class="export-buttons">
-            <button class="btn btn-primary btn-sm" onclick="exportData('csv')">📊 Export CSV</button>
-            <button class="btn btn-primary btn-sm" onclick="exportData('json')">📋 Export JSON</button>
-            <button class="btn btn-secondary btn-sm" onclick="generatePermalink()">🔗 Share Link</button>
-            <button class="btn btn-secondary btn-sm" onclick="printReport()">🖨️ Print Report</button>
-        </div>
-        <div class="permalink-result mt-2" id="permalinkResult" style="display: none;">
-            <input type="text" class="form-control" id="permalinkInput" readonly>
-            <button class="btn btn-outline-primary btn-sm mt-1" onclick="copyPermalink()">Copy Link</button>
-        </div>
-    </div>
-</div>
+<h2>All years</h2>
+<div class="panel"><div id="year-table"></div></div>
 {% endblock %}
 
 {% block scripts %}
 <script>
-    // Removed all console.log statements for production
-
-    // Global variables
-    let yearData = {};
-    let cnaAnalysisData = null;  // CNA data from cna_analysis.json
-    let selectedYears = [];
-    let selectedCvesTotal = 0;
-    let totalDays = 0;
-    let yearlyChart = null;
-    let severityChart = null;
-    let vendorChart = null;
-    let cweChart = null;
-    let affectedVendorChart = null;
-    let analysisStatusChart = null;
-    let referenceTagsChart = null;
-
-    // Debug function
-    function debugLog(message, data = null) {
-        console.log(`[CVE Debug] ${message}`, data || '');
-    }
-
-    // Initialize page
-    async function initializePage() {
-        debugLog('Starting page initialization...');
-
-        try {
-            await Promise.all([
-                loadYearData(),
-                loadCnaAnalysisData()
-            ]);
-
-            // Initialize year selector event listeners
-            initializeYearSelector();
-
-            // Load URL parameters first (this may override default selection)
-            loadUrlParameters();
-
-            debugLog(`After URL parameters, selectedYears length: ${selectedYears.length}`);
-
-            // Note: Default year selection will be handled by ensureDefaultYearSelection() with delay
-
-            // Enhance stat cards with additional features
-            enhanceStatCards();
-
-            // Ensure default year selection after DOM is fully ready
-            setTimeout(() => {
-                debugLog('Setting up default year selection with delay...');
-                ensureDefaultYearSelection();
-            }, 500);
-
-            debugLog('Page initialization completed successfully');
-        } catch (error) {
-            debugLog('Error during page initialization:', error);
-            console.error('Failed to initialize page:', error);
-        }
-    }
-
-    // Ensure default year selection works properly
-    function ensureDefaultYearSelection() {
-        debugLog(`Current selectedYears: ${selectedYears}`);
-
-        // ALWAYS reset to just 2025, regardless of what's currently selected
-        const defaultYear = 2025;
-        debugLog(`Forcing selection to only year: ${defaultYear}`);
-
-        const yearCheckbox = document.querySelector(`#yearSelector input[value="${defaultYear}"]`);
-
-        if (yearCheckbox) {
-            debugLog('Found 2025 checkbox, clearing all and selecting only 2025...');
-
-            // Clear ALL selections first
-            const allCheckboxes = document.querySelectorAll('#yearSelector input[type="checkbox"]');
-            allCheckboxes.forEach(checkbox => {
-                checkbox.checked = false;
-            });
-
-            // Clear the selectedYears array
-            selectedYears = [];
-
-            // Select ONLY 2025
-            yearCheckbox.checked = true;
-
-            // Update the UI
-            updateSelectedYears();
-
-            debugLog(`Successfully reset to only year ${defaultYear}. selectedYears: ${selectedYears}`);
-        } else {
-            debugLog(`ERROR: Could not find checkbox for year ${defaultYear}`);
-            // List all available checkboxes for debugging
-            const allCheckboxes = document.querySelectorAll('#yearSelector input[type="checkbox"]');
-            debugLog(`Available year checkboxes: ${Array.from(allCheckboxes).map(cb => cb.value).join(', ')}`);
-        }
-    }
-
-    document.addEventListener('DOMContentLoaded', initializePage);
-
-    // Load year data from consolidated JSON (single request instead of 27)
-    async function loadYearData() {
-        try {
-            debugLog('Loading yearly summary data...');
-            const response = await fetch('data/yearly_summary.json');
-            if (!response.ok) {
-                throw new Error(`Failed to load yearly summary: ${response.status}`);
-            }
-            const summary = await response.json();
-            debugLog('Yearly summary loaded successfully');
-
-            // Extract year data from the consolidated file
-            if (summary.years) {
-                for (const [year, data] of Object.entries(summary.years)) {
-                    yearData[parseInt(year)] = data;
-                }
-            }
-
-            console.log('Year data loaded:', Object.keys(yearData).length, 'years (from single file)');
-        } catch (error) {
-            console.error('Error loading year data:', error);
-            // Fallback to individual files if summary not available
-            await loadYearDataLegacy();
-        }
-    }
-
-    // Legacy loader for backwards compatibility
-    async function loadYearDataLegacy() {
-        console.log('Falling back to individual year files...');
-        const availableYears = [];
-        for (let year = 1999; year <= 2025; year++) {
-            availableYears.push(year);
-        }
-
-        for (const year of availableYears) {
-            try {
-                const response = await fetch(`data/cve_${year}.json`);
-                if (response.ok) {
-                    const data = await response.json();
-                    yearData[year] = data;
-                }
-            } catch (error) {
-                console.warn(`Could not load data for ${year}:`, error);
-            }
-        }
-        console.log('Legacy year data loaded:', Object.keys(yearData).length, 'years');
-    }
-
-    // Load CNA analysis data from CVE V5 processor
-    async function loadCnaAnalysisData() {
-        try {
-            debugLog('Loading CNA analysis data...');
-            const response = await fetch('data/cna_analysis.json');
-            if (!response.ok) {
-                throw new Error(`Failed to load CNA analysis: ${response.status}`);
-            }
-            cnaAnalysisData = await response.json();
-            debugLog('CNA analysis loaded successfully', { totalCnas: cnaAnalysisData.cna_list?.length });
-        } catch (error) {
-            console.error('Error loading CNA analysis data:', error);
-            cnaAnalysisData = null;
-        }
-    }
-
-    // Initialize year selector
-    function initializeYearSelector() {
-        const checkboxes = document.querySelectorAll('#yearSelector input[type="checkbox"]');
-        selectedYears = [];
-
-        checkboxes.forEach(checkbox => {
-            if (checkbox.checked) {
-                selectedYears.push(parseInt(checkbox.value));
-            }
-
-            checkbox.addEventListener('change', function () {
-                if (this.checked) {
-                    selectedYears.push(parseInt(this.value));
-                } else {
-                    selectedYears = selectedYears.filter(year => year !== parseInt(this.value));
-                }
-                selectedYears.sort((a, b) => a - b);
-                updateStatistics();
-                updateCharts();
-            });
-        });
-
-        selectedYears.sort((a, b) => a - b);
-    }
-
-    // Update statistics
-    function updateStatistics() {
-        if (Object.keys(yearData).length === 0) return;
-
-        let totalCvesGlobal = 0;
-        let selectedCvesTotal = 0;
-        let totalDays = 0;
-
-        // Calculate global totals
-        Object.keys(yearData).forEach(year => {
-            totalCvesGlobal += yearData[year].total_cves || 0;
-        });
-
-        // Calculate selected years totals
-        selectedYears.forEach(year => {
-            const yearDataItem = yearData[year];
-            if (yearDataItem) {
-                selectedCvesTotal += yearDataItem.total_cves || 0;
-            }
-        });
-
-        // Calculate daily average based on actual calendar days
-        let dailyAverage = 0;
-        if (selectedYears.length > 0 && selectedCvesTotal > 0) {
-            let totalCalendarDays = 0;
-            const currentDate = new Date();
-            const currentYear = currentDate.getFullYear();
-
-            selectedYears.forEach(year => {
-                if (year === currentYear) {
-                    // For current year, use days elapsed so far
-                    const startOfYear = new Date(year, 0, 1);
-                    const elapsedDays = Math.floor((currentDate - startOfYear) / (1000 * 60 * 60 * 24)) + 1;
-                    totalCalendarDays += elapsedDays;
-                } else {
-                    // For past years, use full year (365 or 366 days)
-                    const isLeapYear = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
-                    totalCalendarDays += isLeapYear ? 366 : 365;
-                }
-            });
-
-            if (totalCalendarDays > 0) {
-                dailyAverage = Math.round(selectedCvesTotal / totalCalendarDays);
-            }
-
-            // Update totalDays for debug output
-            totalDays = totalCalendarDays;
-        }
-
-        // Debug logging (remove after fixing)
-        const debugInfo = {
-            selectedYears: selectedYears,
-            selectedCvesTotal: selectedCvesTotal,
-            totalDays: totalDays,
-            dailyAverage: dailyAverage
-        };
-
-        // Add elapsed days info for single year selections
-        if (selectedYears.length === 1) {
-            const year = selectedYears[0];
-            const currentDate = new Date();
-            const currentYear = currentDate.getFullYear();
-
-            if (year === currentYear) {
-                const startOfYear = new Date(year, 0, 1);
-                const elapsedDays = Math.floor((currentDate - startOfYear) / (1000 * 60 * 60 * 24)) + 1;
-                debugInfo.elapsedDaysInCurrentYear = elapsedDays;
-                debugInfo.calculationMethod = 'elapsed days in current year';
-            } else {
-                const isLeapYear = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
-                debugInfo.daysInYear = isLeapYear ? 366 : 365;
-                debugInfo.calculationMethod = 'full year (past year)';
-            }
-        }
-
-        console.log('Daily Average Debug:', debugInfo);
-
-        // Update DOM elements
-        const selectedCountElement = document.getElementById('selectedCount');
-        const selectedCvesTotalElement = document.getElementById('selectedCvesTotal');
-        const dailyAverageElement = document.getElementById('dailyAverage');
-        const totalCvesGlobalElement = document.getElementById('totalCvesGlobal');
-
-        if (selectedCountElement) selectedCountElement.textContent = selectedYears.length;
-        if (selectedCvesTotalElement) selectedCvesTotalElement.textContent = selectedCvesTotal.toLocaleString();
-        if (dailyAverageElement) dailyAverageElement.textContent = dailyAverage.toLocaleString();
-        if (totalCvesGlobalElement) totalCvesGlobalElement.textContent = totalCvesGlobal.toLocaleString();
-    }
-
-    // Update charts
-    function updateCharts() {
-        if (Object.keys(yearData).length === 0 || selectedYears.length === 0) return;
-
-        updateYearlyChart();
-        updateSeverityChart();
-        updateVendorChart();
-        updateCweChart();
-        updateAffectedVendorChart();
-        updateAnalysisStatusChart();
-        updateReferenceTagsChart();
-        updateSmartInsights();
-    }
-
-    // Update yearly chart
-    function updateYearlyChart() {
-        const ctx = document.getElementById('yearlyChart');
-        if (!ctx) return;
-
-        if (yearlyChart) {
-            yearlyChart.destroy();
-        }
-
-        // Check if 2-5 consecutive years are selected for monthly view
-        if (selectedYears.length >= 2 && selectedYears.length <= 5) {
-            // Check if years are consecutive
-            const sortedYears = [...selectedYears].sort((a, b) => a - b);
-            let isConsecutive = true;
-            for (let i = 1; i < sortedYears.length; i++) {
-                if (sortedYears[i] - sortedYears[i - 1] !== 1) {
-                    isConsecutive = false;
-                    break;
-                }
-            }
-
-            if (isConsecutive) {
-                // Create monthly chart
-                const monthlyData = [];
-                const monthlyLabels = [];
-                const monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-
-                sortedYears.forEach(year => {
-                    const yearDataForChart = yearData[year];
-                    if (yearDataForChart && yearDataForChart.date_data && yearDataForChart.date_data.monthly_distribution) {
-                        const monthlyDist = yearDataForChart.date_data.monthly_distribution;
-                        for (let month = 1; month <= 12; month++) {
-                            const cveCount = monthlyDist[month.toString()] || 0;
-                            // Only add months with CVE data (> 0)
-                            if (cveCount > 0) {
-                                monthlyLabels.push(`${monthNames[month - 1]} ${year}`);
-                                monthlyData.push(cveCount);
-                            }
-                        }
-                    }
-                });
-
-                if (monthlyData.length > 0) {
-                    yearlyChart = new Chart(ctx, {
-                        type: 'line',
-                        data: {
-                            labels: monthlyLabels,
-                            datasets: [{
-                                label: `Monthly CVEs (${sortedYears[0]}-${sortedYears[sortedYears.length - 1]})`,
-                                data: monthlyData,
-                                borderColor: '#0d6efd',
-                                backgroundColor: 'rgba(13, 110, 253, 0.1)',
-                                borderWidth: 2,
-                                fill: true,
-                                tension: 0.3,
-                                pointRadius: 2,
-                                pointHoverRadius: 5
-                            }]
-                        },
-                        options: {
-                            responsive: true,
-                            maintainAspectRatio: false,
-                            plugins: {
-                                legend: {
-                                    display: true
-                                },
-                                title: {
-                                    display: true,
-                                    text: `Monthly CVE Publications (${sortedYears[0]}-${sortedYears[sortedYears.length - 1]})`
-                                }
-                            },
-                            scales: {
-                                y: {
-                                    beginAtZero: true,
-                                    grid: {
-                                        color: 'rgba(0, 0, 0, 0.1)'
-                                    },
-                                    title: {
-                                        display: true,
-                                        text: 'CVEs Published'
-                                    }
-                                },
-                                x: {
-                                    grid: {
-                                        color: 'rgba(0, 0, 0, 0.1)'
-                                    },
-                                    title: {
-                                        display: true,
-                                        text: 'Month'
-                                    },
-                                    ticks: {
-                                        maxTicksLimit: 24 // Show every other month for readability
-                                    }
-                                }
-                            },
-                            interaction: {
-                                intersect: false,
-                                mode: 'index'
-                            }
-                        }
-                    });
-                    return;
-                }
-            }
-        }
-
-        // Check if only one year is selected for monthly view
-        if (selectedYears.length === 1) {
-            const year = selectedYears[0];
-            const yearDataForChart = yearData[year];
-
-            if (yearDataForChart && yearDataForChart.date_data && yearDataForChart.date_data.monthly_distribution) {
-                // Create monthly chart for single year
-                const monthlyDist = yearDataForChart.date_data.monthly_distribution;
-                const monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-                const monthlyData = [];
-                const monthlyLabels = [];
-
-                for (let month = 1; month <= 12; month++) {
-                    const cveCount = monthlyDist[month.toString()] || 0;
-                    // Only add months with CVE data (> 0) or if it's a past month
-                    if (cveCount > 0) {
-                        monthlyLabels.push(monthNames[month - 1]);
-                        monthlyData.push(cveCount);
-                    }
-                }
-
-                if (monthlyData.length > 0) {
-                    yearlyChart = new Chart(ctx, {
-                        type: 'line',
-                        data: {
-                            labels: monthlyLabels,
-                            datasets: [{
-                                label: `Monthly CVEs - ${year}`,
-                                data: monthlyData,
-                                borderColor: '#0d6efd',
-                                backgroundColor: 'rgba(13, 110, 253, 0.1)',
-                                borderWidth: 2,
-                                fill: true,
-                                tension: 0.3,
-                                pointRadius: 4,
-                                pointHoverRadius: 6
-                            }]
-                        },
-                        options: {
-                            responsive: true,
-                            maintainAspectRatio: false,
-                            plugins: {
-                                legend: {
-                                    display: true
-                                },
-                                title: {
-                                    display: true,
-                                    text: `Monthly CVE Publications - ${year}`
-                                }
-                            },
-                            scales: {
-                                y: {
-                                    beginAtZero: true,
-                                    grid: {
-                                        color: 'rgba(0, 0, 0, 0.1)'
-                                    },
-                                    title: {
-                                        display: true,
-                                        text: 'CVEs Published'
-                                    }
-                                },
-                                x: {
-                                    grid: {
-                                        color: 'rgba(0, 0, 0, 0.1)'
-                                    },
-                                    title: {
-                                        display: true,
-                                        text: 'Month'
-                                    }
-                                }
-                            },
-                            interaction: {
-                                intersect: false,
-                                mode: 'index'
-                            }
-                        }
-                    });
-                    return;
-                }
-            }
-        }
-
-        // Default yearly chart for multiple years
-        const labels = selectedYears;
-        const data = selectedYears.map(year => yearData[year]?.total_cves || 0);
-
-        yearlyChart = new Chart(ctx, {
-            type: 'line',
-            data: {
-                labels: labels,
-                datasets: [{
-                    label: 'CVEs Published',
-                    data: data,
-                    borderColor: '#0d6efd',
-                    backgroundColor: 'rgba(13, 110, 253, 0.1)',
-                    borderWidth: 2,
-                    fill: true,
-                    tension: 0.4
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        display: true
-                    },
-                    title: {
-                        display: true,
-                        text: 'CVE Publications by Year'
-                    }
-                },
-                scales: {
-                    y: {
-                        beginAtZero: true,
-                        grid: {
-                            color: 'rgba(0, 0, 0, 0.1)'
-                        },
-                        title: {
-                            display: true,
-                            text: 'CVEs Published'
-                        }
-                    },
-                    x: {
-                        grid: {
-                            color: 'rgba(0, 0, 0, 0.1)'
-                        },
-                        title: {
-                            display: true,
-                            text: 'Year'
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // Update score distribution chart
-    function updateSeverityChart() {
-        const ctx = document.getElementById('severityChart');
-        if (!ctx) return;
-
-        if (severityChart) {
-            severityChart.destroy();
-        }
-
-        // Aggregate score distribution data by CVSS version from selected years
-        const versionBinnedData = {};
-
-        // Define score bins: 0-0.99, 1-1.99, 2-2.99, ..., 9-9.99, 10.0
-        const scoreBins = [
-            { label: '0-0.99', min: 0, max: 0.99 },
-            { label: '1-1.99', min: 1, max: 1.99 },
-            { label: '2-2.99', min: 2, max: 2.99 },
-            { label: '3-3.99', min: 3, max: 3.99 },
-            { label: '4-4.99', min: 4, max: 4.99 },
-            { label: '5-5.99', min: 5, max: 5.99 },
-            { label: '6-6.99', min: 6, max: 6.99 },
-            { label: '7-7.99', min: 7, max: 7.99 },
-            { label: '8-8.99', min: 8, max: 8.99 },
-            { label: '9-9.99', min: 9, max: 9.99 },
-            { label: '10.0', min: 10, max: 10 }
-        ];
-
-        selectedYears.forEach(year => {
-            const yearCvssData = yearData[year]?.cvss || {};
-
-            Object.keys(yearCvssData).forEach(version => {
-                const versionData = yearCvssData[version];
-                if (versionData && versionData.score_distribution && version !== 'unknown') {
-                    if (!versionBinnedData[version]) {
-                        versionBinnedData[version] = {};
-                        // Initialize all bins to 0
-                        scoreBins.forEach(bin => {
-                            versionBinnedData[version][bin.label] = 0;
-                        });
-                    }
-
-                    Object.keys(versionData.score_distribution).forEach(score => {
-                        const scoreValue = parseFloat(score);
-                        if (scoreValue > 0) { // Exclude 0.0 scores (unknown/unscored)
-                            // Find the appropriate bin for this score
-                            const bin = scoreBins.find(b => scoreValue >= b.min && scoreValue <= b.max);
-                            if (bin) {
-                                versionBinnedData[version][bin.label] += versionData.score_distribution[score];
-                            }
-                        }
-                    });
-                }
-            });
-        });
-
-        // Filter out bins with no data across all versions
-        const activeBins = scoreBins.filter(bin => {
-            return Object.keys(versionBinnedData).some(version =>
-                versionBinnedData[version][bin.label] > 0
-            );
-        });
-
-        const activeBinLabels = activeBins.map(bin => bin.label);
-
-        // Define colors using different shades of blue for consistency
-        const versionColors = {
-            'v2.0': '#1e3a8a',   // Dark blue
-            'v3.0': '#3b82f6',   // Medium blue  
-            'v3.1': '#60a5fa',   // Light blue
-            'v4.0': '#93c5fd'    // Very light blue (if it exists)
-        };
-
-        // Create datasets for each version using binned data (only active bins)
-        const datasets = Object.keys(versionBinnedData).map(version => {
-            const data = activeBinLabels.map(binLabel => versionBinnedData[version][binLabel] || 0);
-            return {
-                label: `CVSS ${version}`,
-                data: data,
-                backgroundColor: versionColors[version] || '#6c757d',
-                borderColor: versionColors[version] || '#6c757d',
-                borderWidth: 1
-            };
-        });
-
-        severityChart = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: activeBinLabels,
-                datasets: datasets
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                scales: {
-                    x: {
-                        title: {
-                            display: true,
-                            text: 'CVSS Score'
-                        },
-                        ticks: {
-                            maxTicksLimit: 20 // Limit number of score labels for readability
-                        }
-                    },
-                    y: {
-                        title: {
-                            display: true,
-                            text: 'Number of CVEs'
-                        },
-                        beginAtZero: true
-                    }
-                },
-                plugins: {
-                    legend: {
-                        display: true,
-                        position: 'top'
-                    },
-                    tooltip: {
-                        mode: 'index',
-                        intersect: false
-                    }
-                },
-                interaction: {
-                    mode: 'nearest',
-                    axis: 'x',
-                    intersect: false
-                }
-            }
-        });
-    }
-
-    // Update CNA chart
-    function updateVendorChart() {
-        const ctx = document.getElementById('vendorChart');
-        if (!ctx) return;
-
-        if (vendorChart) {
-            vendorChart.destroy();
-        }
-
-        // Use CNA analysis data (from CVE V5) which has proper per-year breakdown
-        const cnaData = {};
-
-        if (cnaAnalysisData && cnaAnalysisData.cna_list) {
-            // Aggregate CNA counts for selected years from cves_by_year
-            cnaAnalysisData.cna_list.forEach(cna => {
-                if (cna.cves_by_year) {
-                    let totalForSelectedYears = 0;
-                    selectedYears.forEach(year => {
-                        // Keys in JSON are strings, so convert year to string
-                        totalForSelectedYears += cna.cves_by_year[String(year)] || 0;
-                    });
-                    if (totalForSelectedYears > 0) {
-                        cnaData[cna.name] = totalForSelectedYears;
-                    }
-                }
-            });
-        }
-
-        // Sort CNAs by count and take top 15
-        const sortedCnas = Object.entries(cnaData)
-            .sort(([, a], [, b]) => b - a)
-            .slice(0, 15);
-
-        const cnaNames = sortedCnas.map(([name]) => name);
-        const cnaCounts = sortedCnas.map(([, count]) => count);
-
-        vendorChart = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: cnaNames,
-                datasets: [{
-                    label: 'CVEs Assigned',
-                    data: cnaCounts,
-                    backgroundColor: '#60a5fa',
-                    borderColor: '#60a5fa',
-                    borderWidth: 1
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                plugins: {
-                    legend: {
-                        display: false
-                    }
-                },
-                scales: {
-                    y: {
-                        beginAtZero: true
-                    }
-                }
-            }
-        });
-    }
-
-    // Update CWE chart
-    function updateCweChart() {
-        const ctx = document.getElementById('cweChart');
-        if (!ctx) return;
-
-        if (cweChart) {
-            cweChart.destroy();
-        }
-
-        // Aggregate CWE data from selected years
-        const cweData = {};
-
-        selectedYears.forEach(year => {
-            const yearCweData = yearData[year]?.cwe?.top_cwes || [];
-            yearCweData.forEach(cwe => {
-                if (cwe.cwe && cwe.count) {
-                    cweData[cwe.cwe] = (cweData[cwe.cwe] || 0) + cwe.count;
-                }
-            });
-        });
-
-        // Sort CWEs by count and take top 15
-        const sortedCwes = Object.entries(cweData)
-            .sort(([, a], [, b]) => b - a)
-            .slice(0, 15);
-
-        // CWE descriptions for common ones
-        const cweDescriptions = {
-            'CWE-79': 'Cross-site Scripting (XSS)',
-            'CWE-89': 'SQL Injection',
-            'CWE-74': 'Command Injection',
-            'CWE-352': 'Cross-Site Request Forgery',
-            'CWE-862': 'Missing Authorization',
-            'CWE-94': 'Code Injection',
-            'CWE-119': 'Buffer Overflow',
-            'CWE-120': 'Buffer Copy without Checking Size',
-            'CWE-787': 'Out-of-bounds Write',
-            'CWE-284': 'Improper Access Control',
-            'CWE-22': 'Path Traversal',
-            'CWE-476': 'NULL Pointer Dereference',
-            'CWE-20': 'Improper Input Validation',
-            'CWE-125': 'Out-of-bounds Read',
-            'CWE-200': 'Information Exposure'
-        };
-
-        const cweLabels = sortedCwes.map(([cwe]) => {
-            const description = cweDescriptions[cwe];
-            return description ? `${cwe}: ${description}` : cwe;
-        });
-        const cweCounts = sortedCwes.map(([, count]) => count);
-
-        cweChart = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: cweLabels,
-                datasets: [{
-                    label: 'CVE Count',
-                    data: cweCounts,
-                    backgroundColor: '#60a5fa',
-                    borderColor: '#60a5fa',
-                    borderWidth: 1
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                indexAxis: 'y',
-                plugins: {
-                    legend: {
-                        display: false
-                    }
-                },
-                scales: {
-                    x: {
-                        beginAtZero: true
-                    },
-                    y: {
-                        ticks: {
-                            font: {
-                                size: 10
-                            }
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // Update affected vendor chart
-    function updateAffectedVendorChart() {
-        const ctx = document.getElementById('affectedVendorChart');
-        if (!ctx) return;
-
-        if (affectedVendorChart) {
-            affectedVendorChart.destroy();
-        }
-
-        // Aggregate affected vendor data from selected years
-        const vendorData = {};
-
-        selectedYears.forEach(year => {
-            const yearVendorData = yearData[year]?.vendors?.cpe_vendors || [];
-            yearVendorData.forEach(vendor => {
-                if (vendor.name && vendor.count) {
-                    vendorData[vendor.name] = (vendorData[vendor.name] || 0) + vendor.count;
-                }
-            });
-        });
-
-        // Sort vendors by count and take top 15
-        const sortedVendors = Object.entries(vendorData)
-            .sort(([, a], [, b]) => b - a)
-            .slice(0, 15);
-
-        const vendorNames = sortedVendors.map(([name]) => name);
-        const vendorCounts = sortedVendors.map(([, count]) => count);
-
-        affectedVendorChart = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: vendorNames,
-                datasets: [{
-                    label: 'Vulnerabilities Found',
-                    data: vendorCounts,
-                    backgroundColor: '#60a5fa',
-                    borderColor: '#60a5fa',
-                    borderWidth: 1
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                indexAxis: 'y',
-                plugins: {
-                    legend: {
-                        display: false
-                    }
-                },
-                scales: {
-                    x: {
-                        beginAtZero: true
-                    },
-                    y: {
-                        ticks: {
-                            font: {
-                                size: 11
-                            }
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // Update analysis status chart
-    function updateAnalysisStatusChart() {
-        const ctx = document.getElementById('analysisStatusChart');
-        if (!ctx) return;
-
-        if (analysisStatusChart) {
-            analysisStatusChart.destroy();
-        }
-
-        // Aggregate analysis status data from selected years
-        const statusData = {};
-
-        selectedYears.forEach(year => {
-            const yearStatusData = yearData[year]?.metadata?.vulnerability_status || [];
-            yearStatusData.forEach(status => {
-                if (status.status && status.count) {
-                    statusData[status.status] = (statusData[status.status] || 0) + status.count;
-                }
-            });
-        });
-
-        // Sort status data by count (descending) like other charts
-        const sortedStatus = Object.entries(statusData)
-            .sort(([, a], [, b]) => b - a);
-
-        const statusLabels = sortedStatus.map(([status]) => status);
-        const statusCounts = sortedStatus.map(([, count]) => count);
-
-        // Use single consistent blue color like other charts
-        const backgroundColor = '#60a5fa';
-        const backgroundColors = statusLabels.map(() => backgroundColor);
-
-        analysisStatusChart = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: statusLabels,
-                datasets: [{
-                    data: statusCounts,
-                    backgroundColor: backgroundColors,
-                    borderColor: backgroundColors,
-                    borderWidth: 1
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                indexAxis: 'y', // Makes it horizontal
-                scales: {
-                    x: {
-                        beginAtZero: true,
-                        title: {
-                            display: true,
-                            text: 'Number of CVEs'
-                        }
-                    },
-                    y: {
-                        title: {
-                            display: true,
-                            text: 'Analysis Status'
-                        }
-                    }
-                },
-                plugins: {
-                    legend: {
-                        display: false // Hide legend for bar charts to match other charts
-                    },
-                    tooltip: {
-                        callbacks: {
-                            label: function (context) {
-                                const total = context.dataset.data.reduce((a, b) => a + b, 0);
-                                const percentage = ((context.parsed.x / total) * 100).toFixed(1);
-                                return `${context.label}: ${context.parsed.x.toLocaleString()} (${percentage}%)`;
-                            }
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // Update reference tags chart
-    function updateReferenceTagsChart() {
-        const ctx = document.getElementById('referenceTagsChart');
-        if (!ctx) return;
-
-        if (referenceTagsChart) {
-            referenceTagsChart.destroy();
-        }
-
-        // Aggregate reference tags data from selected years
-        const tagsData = {};
-
-        selectedYears.forEach(year => {
-            const yearTagsData = yearData[year]?.metadata?.reference_tags || [];
-            yearTagsData.forEach(tag => {
-                if (tag.tag && tag.count) {
-                    tagsData[tag.tag] = (tagsData[tag.tag] || 0) + tag.count;
-                }
-            });
-        });
-
-        // Sort tags by count and take top 10
-        const sortedTags = Object.entries(tagsData)
-            .sort(([, a], [, b]) => b - a)
-            .slice(0, 10);
-
-        const tagLabels = sortedTags.map(([tag]) => tag);
-        const tagCounts = sortedTags.map(([, count]) => count);
-
-        referenceTagsChart = new Chart(ctx, {
-            type: 'bar',
-            data: {
-                labels: tagLabels,
-                datasets: [{
-                    label: 'Reference Count',
-                    data: tagCounts,
-                    backgroundColor: '#60a5fa',
-                    borderColor: '#60a5fa',
-                    borderWidth: 1
-                }]
-            },
-            options: {
-                responsive: true,
-                maintainAspectRatio: false,
-                indexAxis: 'y',
-                plugins: {
-                    legend: {
-                        display: false
-                    }
-                },
-                scales: {
-                    x: {
-                        beginAtZero: true
-                    },
-                    y: {
-                        ticks: {
-                            font: {
-                                size: 10
-                            }
-                        }
-                    }
-                }
-            }
-        });
-    }
-
-    // Update smart insights
-    function updateSmartInsights() {
-        // Publication Peak Insight
-        let peakDay = null;
-        let peakCount = 0;
-
-        selectedYears.forEach(year => {
-            const dailyAnalysis = yearData[year]?.date_data?.daily_analysis;
-            if (dailyAnalysis?.highest_day && dailyAnalysis.highest_day.count > peakCount) {
-                peakCount = dailyAnalysis.highest_day.count;
-                peakDay = dailyAnalysis.highest_day.date;
-            }
-        });
-
-        const peakInsight = document.getElementById('peakInsight');
-        if (peakInsight && peakDay) {
-            const date = new Date(peakDay).toLocaleDateString('en-US', {
-                month: 'short',
-                day: 'numeric',
-                year: 'numeric'
-            });
-            peakInsight.textContent = `${date} with ${peakCount.toLocaleString()} CVEs published`;
-        }
-
-        // Top Vulnerability Type Insight
-        const cweData = {};
-        selectedYears.forEach(year => {
-            const yearCweData = yearData[year]?.cwe?.top_cwes || [];
-            yearCweData.forEach(cwe => {
-                if (cwe.cwe && cwe.count) {
-                    cweData[cwe.cwe] = (cweData[cwe.cwe] || 0) + cwe.count;
-                }
-            });
-        });
-
-        const topCwe = Object.entries(cweData).sort(([, a], [, b]) => b - a)[0];
-        const topVulnInsight = document.getElementById('topVulnInsight');
-        if (topVulnInsight && topCwe) {
-            const cweDescriptions = {
-                'CWE-79': 'Cross-site Scripting (XSS)',
-                'CWE-89': 'SQL Injection',
-                'CWE-74': 'Command Injection'
-            };
-            const description = cweDescriptions[topCwe[0]] || 'Vulnerability';
-            topVulnInsight.textContent = `${topCwe[0]} (${description}) with ${topCwe[1].toLocaleString()} occurrences`;
-        }
-
-        // Analysis Status Insight
-        const statusData = {};
-        selectedYears.forEach(year => {
-            const yearStatusData = yearData[year]?.metadata?.vulnerability_status || [];
-            yearStatusData.forEach(status => {
-                if (status.status && status.count) {
-                    statusData[status.status] = (statusData[status.status] || 0) + status.count;
-                }
-            });
-        });
-
-        const totalCves = Object.values(statusData).reduce((a, b) => a + b, 0);
-        const analyzedCount = statusData['Analyzed'] || 0;
-        const analysisPercentage = totalCves > 0 ? ((analyzedCount / totalCves) * 100).toFixed(1) : 0;
-
-        const analysisInsight = document.getElementById('analysisInsight');
-        if (analysisInsight) {
-            analysisInsight.textContent = `${analysisPercentage}% analyzed (${analyzedCount.toLocaleString()} of ${totalCves.toLocaleString()} CVEs)`;
-        }
-    }
-
-    // Export functionality
-    function exportData(format) {
-        const data = {
-            selectedYears: selectedYears,
-            totalCves: selectedCvesTotal,
-            dailyAverage: Math.round(selectedCvesTotal / totalDays),
-            exportDate: new Date().toISOString(),
-            yearData: {}
-        };
-
-        // Include data for selected years only
-        selectedYears.forEach(year => {
-            if (yearData[year]) {
-                data.yearData[year] = yearData[year];
-            }
-        });
-
-        if (format === 'csv') {
-            exportCSV(data);
-        } else if (format === 'json') {
-            exportJSON(data);
-        }
-    }
-
-    function exportCSV(data) {
-        // Create comprehensive CSV with data from all charts
-        let csv = '';
-
-        // 1. Basic Year Statistics
-        csv += 'YEAR STATISTICS\n';
-        csv += 'Year,Total CVEs,Daily Average\n';
-        selectedYears.forEach(year => {
-            const yearTotal = yearData[year]?.total_cves || 0;
-            const currentDate = new Date();
-            const currentYear = currentDate.getFullYear();
-            let dailyAvg = 0;
-
-            if (year === currentYear) {
-                const startOfYear = new Date(year, 0, 1);
-                const elapsedDays = Math.floor((currentDate - startOfYear) / (1000 * 60 * 60 * 24)) + 1;
-                dailyAvg = Math.round(yearTotal / elapsedDays);
-            } else {
-                const isLeapYear = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
-                dailyAvg = Math.round(yearTotal / (isLeapYear ? 366 : 365));
-            }
-
-            csv += `${year},${yearTotal},${dailyAvg}\n`;
-        });
-
-        // 2. Top CNAs
-        csv += '\nTOP CVE NUMBERING AUTHORITIES\n';
-        csv += 'CNA,CVE Count\n';
-        const cnaData = {};
-        selectedYears.forEach(year => {
-            const yearCnaData = yearData[year]?.cna_assigners || [];
-            yearCnaData.forEach(cna => {
-                if (cna.assigner && cna.count) {
-                    cnaData[cna.assigner] = (cnaData[cna.assigner] || 0) + cna.count;
-                }
-            });
-        });
-        Object.entries(cnaData)
-            .sort(([, a], [, b]) => b - a)
-            .slice(0, 15)
-            .forEach(([cna, count]) => {
-                csv += `"${cna}",${count}\n`;
-            });
-
-        // 3. Top CWE Types
-        csv += '\nTOP CWE VULNERABILITY TYPES\n';
-        csv += 'CWE,Description,Count\n';
-        const cweData = {};
-        selectedYears.forEach(year => {
-            const yearCweData = yearData[year]?.cwe?.top_cwes || [];
-            yearCweData.forEach(cwe => {
-                if (cwe.cwe_id && cwe.count) {
-                    const key = `${cwe.cwe_id}: ${cwe.name || 'Unknown'}`;
-                    cweData[key] = (cweData[key] || 0) + cwe.count;
-                }
-            });
-        });
-        Object.entries(cweData)
-            .sort(([, a], [, b]) => b - a)
-            .slice(0, 15)
-            .forEach(([cwe, count]) => {
-                const [id, desc] = cwe.split(': ');
-                csv += `"${id}","${desc}",${count}\n`;
-            });
-
-        // 4. Top Affected Vendors
-        csv += '\nTOP AFFECTED VENDORS\n';
-        csv += 'Vendor,Vulnerability Count\n';
-        const vendorData = {};
-        selectedYears.forEach(year => {
-            const yearVendorData = yearData[year]?.vendors?.cpe_vendors || [];
-            yearVendorData.forEach(vendor => {
-                if (vendor.vendor && vendor.count) {
-                    vendorData[vendor.vendor] = (vendorData[vendor.vendor] || 0) + vendor.count;
-                }
-            });
-        });
-        Object.entries(vendorData)
-            .sort(([, a], [, b]) => b - a)
-            .slice(0, 15)
-            .forEach(([vendor, count]) => {
-                csv += `"${vendor}",${count}\n`;
-            });
-
-        // 5. Analysis Status
-        csv += '\nVULNERABILITY ANALYSIS STATUS\n';
-        csv += 'Status,Count\n';
-        const statusData = {};
-        selectedYears.forEach(year => {
-            const yearStatusData = yearData[year]?.metadata?.vulnerability_status || [];
-            yearStatusData.forEach(status => {
-                if (status.status && status.count) {
-                    statusData[status.status] = (statusData[status.status] || 0) + status.count;
-                }
-            });
-        });
-        Object.entries(statusData)
-            .sort(([, a], [, b]) => b - a)
-            .forEach(([status, count]) => {
-                csv += `"${status}",${count}\n`;
-            });
-
-        // 6. Reference Types
-        csv += '\nREFERENCE TYPES DISTRIBUTION\n';
-        csv += 'Reference Type,Count\n';
-        const tagsData = {};
-        selectedYears.forEach(year => {
-            const yearTagsData = yearData[year]?.metadata?.reference_tags || [];
-            yearTagsData.forEach(tag => {
-                if (tag.tag && tag.count) {
-                    tagsData[tag.tag] = (tagsData[tag.tag] || 0) + tag.count;
-                }
-            });
-        });
-        Object.entries(tagsData)
-            .sort(([, a], [, b]) => b - a)
-            .slice(0, 10)
-            .forEach(([tag, count]) => {
-                csv += `"${tag}",${count}\n`;
-            });
-
-        downloadFile(csv, `cve-comprehensive-analysis-${selectedYears.join('-')}.csv`, 'text/csv');
-    }
-
-    function exportJSON(data) {
-        // Create comprehensive JSON with data from all charts
-        const exportData = {
-            metadata: {
-                exportDate: new Date().toISOString(),
-                selectedYears: selectedYears,
-                dataSource: 'CVEDB Analytics Dashboard'
-            },
-
-            // 1. Year Statistics
-            yearStatistics: selectedYears.map(year => {
-                const yearTotal = yearData[year]?.total_cves || 0;
-                const currentDate = new Date();
-                const currentYear = currentDate.getFullYear();
-                let dailyAvg = 0;
-
-                if (year === currentYear) {
-                    const startOfYear = new Date(year, 0, 1);
-                    const elapsedDays = Math.floor((currentDate - startOfYear) / (1000 * 60 * 60 * 24)) + 1;
-                    dailyAvg = Math.round(yearTotal / elapsedDays);
-                } else {
-                    const isLeapYear = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
-                    dailyAvg = Math.round(yearTotal / (isLeapYear ? 366 : 365));
-                }
-
-                return {
-                    year: year,
-                    totalCves: yearTotal,
-                    dailyAverage: dailyAvg
-                };
-            }),
-
-            // 2. CVE Trends (monthly data for charts)
-            cveTrends: {},
-
-            // 3. CVSS Score Distribution
-            cvssScoreDistribution: {},
-
-            // 4. Top CNAs
-            topCnas: (() => {
-                const cnaData = {};
-                selectedYears.forEach(year => {
-                    const yearCnaData = yearData[year]?.cna_assigners || [];
-                    yearCnaData.forEach(cna => {
-                        if (cna.assigner && cna.count) {
-                            cnaData[cna.assigner] = (cnaData[cna.assigner] || 0) + cna.count;
-                        }
-                    });
-                });
-                return Object.entries(cnaData)
-                    .sort(([, a], [, b]) => b - a)
-                    .slice(0, 15)
-                    .map(([cna, count]) => ({ cna, count }));
-            })(),
-
-            // 5. Top CWE Types
-            topCweTypes: (() => {
-                const cweData = {};
-                selectedYears.forEach(year => {
-                    const yearCweData = yearData[year]?.cwe?.top_cwes || [];
-                    yearCweData.forEach(cwe => {
-                        if (cwe.cwe_id && cwe.count) {
-                            const key = cwe.cwe_id;
-                            if (!cweData[key]) {
-                                cweData[key] = {
-                                    cweId: cwe.cwe_id,
-                                    name: cwe.name || 'Unknown',
-                                    count: 0
-                                };
-                            }
-                            cweData[key].count += cwe.count;
-                        }
-                    });
-                });
-                return Object.values(cweData)
-                    .sort((a, b) => b.count - a.count)
-                    .slice(0, 15);
-            })(),
-
-            // 6. Top Affected Vendors
-            topAffectedVendors: (() => {
-                const vendorData = {};
-                selectedYears.forEach(year => {
-                    const yearVendorData = yearData[year]?.vendors?.cpe_vendors || [];
-                    yearVendorData.forEach(vendor => {
-                        if (vendor.vendor && vendor.count) {
-                            vendorData[vendor.vendor] = (vendorData[vendor.vendor] || 0) + vendor.count;
-                        }
-                    });
-                });
-                return Object.entries(vendorData)
-                    .sort(([, a], [, b]) => b - a)
-                    .slice(0, 15)
-                    .map(([vendor, count]) => ({ vendor, count }));
-            })(),
-
-            // 7. Vulnerability Analysis Status
-            vulnerabilityAnalysisStatus: (() => {
-                const statusData = {};
-                selectedYears.forEach(year => {
-                    const yearStatusData = yearData[year]?.metadata?.vulnerability_status || [];
-                    yearStatusData.forEach(status => {
-                        if (status.status && status.count) {
-                            statusData[status.status] = (statusData[status.status] || 0) + status.count;
-                        }
-                    });
-                });
-                return Object.entries(statusData)
-                    .sort(([, a], [, b]) => b - a)
-                    .map(([status, count]) => ({ status, count }));
-            })(),
-
-            // 8. Reference Types Distribution
-            referenceTypesDistribution: (() => {
-                const tagsData = {};
-                selectedYears.forEach(year => {
-                    const yearTagsData = yearData[year]?.metadata?.reference_tags || [];
-                    yearTagsData.forEach(tag => {
-                        if (tag.tag && tag.count) {
-                            tagsData[tag.tag] = (tagsData[tag.tag] || 0) + tag.count;
-                        }
-                    });
-                });
-                return Object.entries(tagsData)
-                    .sort(([, a], [, b]) => b - a)
-                    .slice(0, 10)
-                    .map(([tag, count]) => ({ referenceType: tag, count }));
-            })()
-        };
-
-        // Add CVE trends data if available
-        selectedYears.forEach(year => {
-            if (yearData[year]?.date_data?.monthly_distribution) {
-                exportData.cveTrends[year] = yearData[year].date_data.monthly_distribution;
-            }
-        });
-
-        // Add CVSS score distribution if available
-        selectedYears.forEach(year => {
-            if (yearData[year]?.cvss) {
-                exportData.cvssScoreDistribution[year] = yearData[year].cvss;
-            }
-        });
-
-        const jsonStr = JSON.stringify(exportData, null, 2);
-        downloadFile(jsonStr, `cve-comprehensive-analysis-${selectedYears.join('-')}.json`, 'application/json');
-    }
-
-    function downloadFile(content, filename, contentType) {
-        const blob = new Blob([content], { type: contentType });
-        const url = URL.createObjectURL(blob);
-        const link = document.createElement('a');
-        link.href = url;
-        link.download = filename;
-        document.body.appendChild(link);
-        link.click();
-        document.body.removeChild(link);
-        URL.revokeObjectURL(url);
-    }
-
-    // Permalink functionality
-    function generatePermalink() {
-        const params = new URLSearchParams();
-        params.set('years', selectedYears.join(','));
-
-        const permalink = `${window.location.origin}${window.location.pathname}?${params.toString()}`;
-
-        const resultDiv = document.getElementById('permalinkResult');
-        const input = document.getElementById('permalinkInput');
-
-        input.value = permalink;
-        resultDiv.style.display = 'block';
-    }
-
-    function copyPermalink() {
-        const input = document.getElementById('permalinkInput');
-        input.select();
-        document.execCommand('copy');
-
-        const button = event.target;
-        const originalText = button.textContent;
-        button.textContent = 'Copied!';
-        button.style.backgroundColor = '#198754';
-
-        setTimeout(() => {
-            button.textContent = originalText;
-            button.style.backgroundColor = '';
-        }, 2000);
-    }
-
-    function printReport() {
-        window.print();
-    }
-
-    // Enhance stat cards with additional features
-    function enhanceStatCards() {
-        // Add hover effects and trend indicators to stat cards
-        const statCards = document.querySelectorAll('.stat-card');
-
-        statCards.forEach(card => {
-            // Add enhanced hover effect
-            card.addEventListener('mouseenter', function () {
-                this.style.transform = 'translateY(-2px)';
-                this.style.boxShadow = '0 4px 12px rgba(0, 0, 0, 0.1)';
-            });
-
-            card.addEventListener('mouseleave', function () {
-                this.style.transform = 'translateY(0)';
-                this.style.boxShadow = '';
-            });
-        });
-    }
-
-
-
-    // Load URL parameters on page load
-    function loadUrlParameters() {
-        const params = new URLSearchParams(window.location.search);
-        const yearsParam = params.get('years');
-
-        if (yearsParam) {
-            const years = yearsParam.split(',').map(y => parseInt(y)).filter(y => !isNaN(y));
-            if (years.length > 0) {
-                const checkboxes = document.querySelectorAll('#yearSelector input[type="checkbox"]');
-                checkboxes.forEach(checkbox => {
-                    checkbox.checked = years.includes(parseInt(checkbox.value));
-                });
-                updateSelectedYears();
-            }
-        }
-    }
-
-    // Quick selection functions
-    function selectRecentYears() {
-        const checkboxes = document.querySelectorAll('#yearSelector input[type="checkbox"]');
-        const currentYear = new Date().getFullYear();
-
-        checkboxes.forEach(checkbox => {
-            const year = parseInt(checkbox.value);
-            checkbox.checked = year >= currentYear - 4;
-        });
-
-        updateSelectedYears();
-    }
-
-    function selectDecade(decade) {
-        const checkboxes = document.querySelectorAll('#yearSelector input[type="checkbox"]');
-
-        // Parse decade string to get start year
-        let startYear;
-        if (decade === '2020s') {
-            startYear = 2020;
-        } else if (decade === '2010s') {
-            startYear = 2010;
-        } else if (decade === '2000s') {
-            startYear = 2000;
-        } else if (decade === '1990s') {
-            startYear = 1990;
-        } else {
-            // If it's already a number, use it directly
-            startYear = parseInt(decade);
-        }
-
-        checkboxes.forEach(checkbox => {
-            const year = parseInt(checkbox.value);
-            checkbox.checked = year >= startYear && year < startYear + 10;
-        });
-
-        updateSelectedYears();
-    }
-
-    function selectAllYears() {
-        const checkboxes = document.querySelectorAll('#yearSelector input[type="checkbox"]');
-        checkboxes.forEach(checkbox => {
-            checkbox.checked = true;
-        });
-
-        updateSelectedYears();
-    }
-
-    function clearAllYears() {
-        const checkboxes = document.querySelectorAll('#yearSelector input[type="checkbox"]');
-        checkboxes.forEach(checkbox => {
-            checkbox.checked = false;
-        });
-
-        updateSelectedYears();
-    }
-
-    // Alias for clearAllYears for consistency with button naming
-    function clearSelection() {
-        clearAllYears();
-    }
-
-    // Update selected years array
-    function updateSelectedYears() {
-        const checkboxes = document.querySelectorAll('#yearSelector input[type="checkbox"]');
-        selectedYears = [];
-
-        checkboxes.forEach(checkbox => {
-            if (checkbox.checked) {
-                selectedYears.push(parseInt(checkbox.value));
-            }
-        });
-
-        selectedYears.sort((a, b) => a - b);
-        updateStatistics();
-        updateCharts();
-    }
+CVE.page(async (S) => {
+  const { fmt, chart, el, table, url } = CVE;
+  const YR = {{ current_year }};
+  const full = await CVE.json('yearly_summary.json');
+  const years = Object.values(full.years).sort((a, b) => a.year - b.year);
+  const allYears = years.map(y => y.year);
+  const grandTotal = years.reduce((s, y) => s + y.total_cves, 0);
+
+  const fromUrl = (url.get('years') || '').split(',').map(Number).filter(n => allYears.includes(n));
+  let selected = new Set(fromUrl.length ? fromUrl : [YR]);
+
+  const daysInYear = y => y === YR
+    ? Math.max(1, Math.round((Date.now() - new Date(YR, 0, 1)) / 864e5))
+    : ((y % 4 === 0 && y % 100 !== 0) || y % 400 === 0) ? 366 : 365;
+
+  /* ---------------- selection-aware metrics ---------------- */
+  function tiles() {
+    const sel = [...selected].sort((a, b) => a - b);
+    const picked = years.filter(y => selected.has(y.year));
+    const sum = picked.reduce((s, y) => s + y.total_cves, 0);
+    const days = sel.reduce((s, y) => s + daysInYear(y), 0);
+    const kev = picked.reduce((s, y) => s + ((y.kev || {}).kev_count || 0), 0);
+
+    el('#tiles').innerHTML = [
+      { lbl: 'Years selected', v: fmt.n(sel.length),
+        sub: sel.length ? (sel.length > 6
+          ? `${sel[0]}&ndash;${sel[sel.length - 1]}`
+          : sel.join(', ')) : 'none selected' },
+      { lbl: 'CVEs in selection', v: fmt.n(sum),
+        sub: `<b>${fmt.share(sum, grandTotal)}</b> of all ${fmt.compact(grandTotal)}` },
+      { lbl: 'Average per day', v: fmt.n(days ? Math.round(sum / days) : 0),
+        sub: `across <b>${fmt.n(days)}</b> days` },
+      { lbl: 'In the KEV catalog', v: fmt.n(kev),
+        sub: `<b>${fmt.share(kev, sum, 2)}</b> of the selection` }
+    ].map(t => `<div class="c"><div class="lbl">${t.lbl}</div>
+        <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+    el('#sel-note').textContent = sel.length === 1
+      ? `${sel[0]} selected` : `${sel.length} years selected`;
+  }
+
+  /* ---------------- chips ---------------- */
+  function chips() {
+    el('#chips').innerHTML = allYears.map(y =>
+      `<button class="chip ${selected.has(y) ? 'on' : ''}" data-y="${y}"
+        aria-pressed="${selected.has(y)}">${y}</button>`).join('');
+  }
+
+  /* ---------------- main chart ---------------- */
+  function mainChart() {
+    chart.bars('#chart-years', years.map(y => ({
+      label: String(y.year), value: y.total_cves, current: selected.has(y.year)
+    })), {
+      tall: true, name: 'cve-icu-cves-by-year', label: 'CVEs published each year',
+      ticks: [1999, 2005, 2010, 2015, 2020, YR].map(String),
+      onSelect: key => { toggle(+key); }
+    });
+  }
+
+  /* ---------------- comparison across the selection ---------------- */
+  function compare() {
+    const sel = [...selected].sort((a, b) => a - b);
+    const host = el('#compare');
+    if (sel.length < 2) { host.innerHTML = ''; return; }
+    const picked = years.filter(y => selected.has(y.year));
+    host.innerHTML = `
+      <h2>Comparing ${sel.length} years</h2>
+      <div class="cols c2">
+        <div class="panel"><div class="panel-h">CVEs per selected year</div>
+          <div class="panel-b"><div id="cmp-total"></div></div></div>
+        <div class="panel"><div class="panel-h">Average per day <span class="side">normalises for ${YR} being partial</span></div>
+          <div class="panel-b"><div id="cmp-rate"></div></div></div>
+      </div>
+      <div class="panel" style="margin-top:10px">
+        <div class="panel-h">By month, selected years overlaid</div>
+        <div class="panel-b"><div id="cmp-month"></div></div></div>`;
+
+    chart.hbars('#cmp-total', picked.map(y => ({ label: String(y.year), value: y.total_cves })),
+      { name: 'cve-icu-selected-years-total', label: 'CVEs per selected year' });
+    chart.hbars('#cmp-rate', picked.map(y => ({
+      label: String(y.year), value: Math.round(y.total_cves / daysInYear(y.year))
+    })), { name: 'cve-icu-selected-years-per-day', label: 'Average CVEs per day' });
+
+    const mNames = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+    const monthRows = mNames.map((m, i) => {
+      const row = { month: m };
+      picked.forEach(y => {
+        row[y.year] = ((y.date_data || {}).monthly_distribution || {})[String(i + 1)] || 0;
+      });
+      return row;
+    });
+    table('#cmp-month', monthRows,
+      [{ key: 'month', label: 'Month' },
+       ...picked.map(y => ({ key: String(y.year), label: String(y.year), num: true, bar: true }))],
+      { sort: { key: 'month', dir: 1 }, name: 'cve-icu-selected-years-by-month' });
+  }
+
+  /* ---------------- single-year detail ---------------- */
+  function detail() {
+    const sel = [...selected];
+    const host = el('#year-detail');
+    if (sel.length !== 1) { host.innerHTML = ''; return; }
+    const yr = sel[0];
+    const y = years.find(x => x.year === yr);
+    if (!y) { host.innerHTML = ''; return; }
+
+    const mNames = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+    const months = (y.date_data || {}).monthly_distribution || {};
+    const prev = years.find(x => x.year === yr - 1);
+
+    host.innerHTML = `
+      <h2>${yr} in detail</h2>
+      <div class="cols c2">
+        <div class="panel"><div class="panel-h">By month <span class="side">${yr}</span></div>
+          <div class="panel-b"><div id="d-month"></div></div></div>
+        <div class="panel"><div class="panel-h">CVSS scores by version
+          <span class="side">a CVE may hold more than one</span></div>
+          <div class="panel-b"><div id="d-cvss"></div></div></div>
+      </div>
+      <div class="cols" style="margin-top:10px">
+        <div class="panel"><div class="panel-h">Top vendors</div><div class="rows" id="d-vendor"></div></div>
+        <div class="panel"><div class="panel-h">Top weaknesses</div><div class="rows" id="d-cwe"></div></div>
+        <div class="panel"><div class="panel-h">NVD record status</div><div class="rows" id="d-status"></div></div>
+      </div>
+      <div class="cols c2" style="margin-top:10px">
+        <div class="panel"><div class="panel-h">Reference types
+          <span class="side">how sources are tagged</span></div>
+          <div class="panel-b"><div id="d-refs"></div></div></div>
+        <div class="panel"><div class="panel-h">${yr} against ${yr - 1}</div>
+          <div class="panel-b" id="d-vs" style="font-size:13.5px;line-height:1.7"></div></div>
+      </div>`;
+
+    chart.bars('#d-month', mNames.map((m, i) => ({ label: m, value: months[String(i + 1)] || 0 })),
+      { ticks: ['Jan', 'Dec'], name: `cve-icu-${yr}-by-month`, label: `${yr} CVEs by month` });
+
+    chart.hbars('#d-cvss', Object.entries(y.cvss || {})
+      .map(([v, d]) => ({ label: v, value: d.total || 0 })).filter(x => x.value),
+      { name: `cve-icu-${yr}-cvss-versions`, label: `${yr} CVSS scores by version` });
+
+    chart.rank('#d-vendor', ((y.vendors || {}).cpe_vendors || []).slice(0, 8)
+      .map(v => ({ label: v.name, value: v.count })), { compact: true, name: `cve-icu-${yr}-vendors` });
+    chart.rank('#d-cwe', ((y.cwe || {}).top_cwes || []).slice(0, 8)
+      .map(c => ({ label: c.cwe, value: c.count })), { compact: true, name: `cve-icu-${yr}-weaknesses` });
+    chart.rank('#d-status', ((y.metadata || {}).vulnerability_status || [])
+      .map(s => ({ label: s.status, value: s.count })), { compact: true, name: `cve-icu-${yr}-status` });
+
+    const refs = ((y.metadata || {}).reference_tags || []).slice(0, 8)
+      .map(r => ({ label: r.tag, value: r.count }));
+    if (refs.length) {
+      chart.hbars('#d-refs', refs, { compact: true, name: `cve-icu-${yr}-reference-types`,
+        label: `${yr} reference types` });
+    } else {
+      el('#d-refs').innerHTML = '<div class="empty">No reference tags recorded for ' + yr + '.</div>';
+    }
+
+    const kevN = (y.kev || {}).kev_count || 0;
+    el('#d-vs').innerHTML = prev ? `
+      <div class="kvline"><span>CVEs</span><b>${fmt.n(y.total_cves)}</b>
+        <span class="faint">vs ${fmt.n(prev.total_cves)}</span>
+        <span style="color:var(--${y.total_cves >= prev.total_cves ? 'live' : 'hot'})">
+        ${fmt.pct((y.total_cves / prev.total_cves - 1) * 100)}</span></div>
+      <div class="kvline"><span>Per day</span><b>${fmt.n(Math.round(y.total_cves / daysInYear(yr)))}</b>
+        <span class="faint">vs ${fmt.n(Math.round(prev.total_cves / daysInYear(yr - 1)))}</span></div>
+      <div class="kvline"><span>In KEV</span><b>${fmt.n(kevN)}</b>
+        <span class="faint">vs ${fmt.n((prev.kev || {}).kev_count || 0)}</span></div>
+      ${yr === YR ? '<p class="faint" style="margin-top:9px">' + yr +
+        ' is a partial year, so the per-day figure is the fair comparison.</p>' : ''}`
+      : '<span class="faint">No prior year on record.</span>';
+  }
+
+  /* ---------------- table ---------------- */
+  let run = 0;
+  const rows = years.map(y => {
+    run += y.total_cves;
+    const prev = years.find(x => x.year === y.year - 1);
+    return {
+      year: y.year, cves: y.total_cves,
+      perday: Math.round(y.total_cves / daysInYear(y.year)),
+      change: prev ? +((y.total_cves / prev.total_cves - 1) * 100).toFixed(1) : null,
+      kev: (y.kev || {}).kev_count || 0,
+      running: run
+    };
+  }).reverse();
+
+  table('#year-table', rows, [
+    { key: 'year', label: 'Year', num: true, raw: true },
+    { key: 'cves', label: 'CVEs', num: true, bar: true },
+    { key: 'perday', label: 'Per day', num: true },
+    { key: 'change', label: 'vs prior year', num: true,
+      fmt: v => v == null ? '<span class="faint">&mdash;</span>'
+        : `<span style="color:var(--${v > 0 ? 'live' : 'hot'})">${fmt.pct(v)}</span>` },
+    { key: 'kev', label: 'In KEV', num: true },
+    { key: 'running', label: 'Running total', num: true }
+  ], { sort: { key: 'year', dir: -1 }, name: 'cve-icu-all-years' });
+
+  /* ---------------- wiring ---------------- */
+  function render() {
+    tiles(); chips(); mainChart(); compare(); detail();
+    url.set({ years: [...selected].sort((a, b) => a - b).join(',') || null });
+  }
+  function toggle(y) {
+    if (selected.has(y)) selected.delete(y); else selected.add(y);
+    render();
+  }
+  render();
+
+  el('#chips').addEventListener('click', e => {
+    const c = e.target.closest('.chip'); if (c) toggle(+c.dataset.y);
+  });
+  el('#quick').addEventListener('click', e => {
+    const b = e.target.closest('.chip'); if (!b) return;
+    const q = b.dataset.q;
+    if (q === 'clear') selected = new Set();
+    else if (q === 'all') selected = new Set(allYears);
+    else if (q === 'recent5') selected = new Set(allYears.slice(-5));
+    else {
+      const decade = parseInt(q, 10);
+      selected = new Set(allYears.filter(y => y >= decade && y < decade + 10));
+    }
+    render();
+  });
+  el('#share').addEventListener('click', () => url.share(el('#share')));
+  el('#print').addEventListener('click', () => window.print());
+});
 </script>
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/tests/conftest.py b/tests/conftest.py
index 35088814336..bbe28ff08e0 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -2,30 +2,44 @@
 Pytest configuration and shared fixtures for CVEDB tests.
 """
 
+from __future__ import annotations
+
 import json
 import sys
 import tempfile
-from datetime import datetime, timezone
+from collections.abc import Generator
+from datetime import UTC, datetime
 from pathlib import Path
+from typing import Any
 
 import pytest
 
-# Add the src directory to the path for imports
+
+# Add the data directory to the path for imports
 ROOT_DIR = Path(__file__).parent.parent
-SRC_DIR = ROOT_DIR / "src"
-if str(SRC_DIR) not in sys.path:
-    sys.path.insert(0, str(SRC_DIR))
+DATA_DIR = ROOT_DIR / "data"
+sys.path.insert(0, str(DATA_DIR))
+
+
+@pytest.fixture(autouse=True)
+def quiet_logging():
+    """Automatically silence logging during tests to reduce noise."""
+    from logging_config import restore_logging, silence_for_tests
+
+    silence_for_tests()
+    yield
+    restore_logging()
 
 
 @pytest.fixture
-def temp_dir():
+def temp_dir() -> Generator[Path, None, None]:
     """Create a temporary directory for test outputs."""
     with tempfile.TemporaryDirectory() as tmpdir:
         yield Path(tmpdir)
 
 
 @pytest.fixture
-def sample_cve_record():
+def sample_cve_record() -> dict[str, Any]:
     """Return a sample CVE record in V5 format."""
     return {
         "cveMetadata": {
@@ -34,7 +48,7 @@ def sample_cve_record():
             "assignerShortName": "mitre",
             "state": "PUBLISHED",
             "datePublished": "2024-06-15T10:30:00.000Z",
-            "dateUpdated": "2024-06-20T14:00:00.000Z"
+            "dateUpdated": "2024-06-20T14:00:00.000Z",
         },
         "containers": {
             "cna": {
@@ -42,27 +56,12 @@ def sample_cve_record():
                     {
                         "vendor": "example_vendor",
                         "product": "example_product",
-                        "versions": [
-                            {"version": "1.0.0", "status": "affected"}
-                        ]
-                    }
-                ],
-                "descriptions": [
-                    {
-                        "lang": "en",
-                        "value": "A sample vulnerability description for testing."
+                        "versions": [{"version": "1.0.0", "status": "affected"}],
                     }
                 ],
+                "descriptions": [{"lang": "en", "value": "A sample vulnerability description for testing."}],
                 "problemTypes": [
-                    {
-                        "descriptions": [
-                            {
-                                "type": "CWE",
-                                "cweId": "CWE-79",
-                                "description": "Cross-site Scripting (XSS)"
-                            }
-                        ]
-                    }
+                    {"descriptions": [{"type": "CWE", "cweId": "CWE-79", "description": "Cross-site Scripting (XSS)"}]}
                 ],
                 "metrics": [
                     {
@@ -70,22 +69,18 @@ def sample_cve_record():
                             "version": "3.1",
                             "baseScore": 7.5,
                             "baseSeverity": "HIGH",
-                            "vectorString": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N"
+                            "vectorString": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N",
                         }
                     }
                 ],
-                "references": [
-                    {
-                        "url": "https://example.com/advisory/CVE-2024-12345"
-                    }
-                ]
+                "references": [{"url": "https://example.com/advisory/CVE-2024-12345"}],
             }
-        }
+        },
     }
 
 
 @pytest.fixture
-def sample_epss_data():
+def sample_epss_data() -> dict[str, dict[str, float]]:
     """Return sample EPSS data as a dict keyed by CVE ID."""
     return {
         "CVE-2024-12345": {"epss_score": 0.15, "epss_percentile": 0.85},
@@ -95,7 +90,7 @@ def sample_epss_data():
 
 
 @pytest.fixture
-def sample_kev_data():
+def sample_kev_data() -> set[str]:
     """Return sample KEV data as a list of CVE IDs."""
     return {
         "CVE-2024-12346",  # High EPSS, in KEV
@@ -104,10 +99,10 @@ def sample_kev_data():
 
 
 @pytest.fixture
-def sample_cna_analysis():
+def sample_cna_analysis() -> dict[str, Any]:
     """Return a sample CNA analysis structure."""
     return {
-        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "generated_at": datetime.now(UTC).isoformat(),
         "total_cnas": 5,
         "active_cnas": 4,
         "inactive_cnas": 1,
@@ -119,7 +114,7 @@ def sample_cna_analysis():
                 "epss_high_count": 100,
                 "activity_status": "Active",
                 "cna_types": ["Program"],
-                "is_official": True
+                "is_official": True,
             },
             {
                 "name": "google",
@@ -128,74 +123,64 @@ def sample_cna_analysis():
                 "epss_high_count": 45,
                 "activity_status": "Active",
                 "cna_types": ["Vendor"],
-                "is_official": True
-            }
-        ]
+                "is_official": True,
+            },
+        ],
     }
 
 
 @pytest.fixture
-def sample_cvss_analysis():
+def sample_cvss_analysis() -> dict[str, Any]:
     """Return a sample CVSS analysis structure."""
     return {
-        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "generated_at": datetime.now(UTC).isoformat(),
         "total_cves_with_cvss": 10000,
-        "total_by_version": {
-            "v3.1": 7000,
-            "v3.0": 2000,
-            "v2.0": 1000
-        },
-        "severity_distribution": {
-            "v3.1": {
-                "CRITICAL": 500,
-                "HIGH": 2000,
-                "MEDIUM": 3500,
-                "LOW": 900,
-                "NONE": 100
-            }
-        }
+        "total_by_version": {"v3.1": 7000, "v3.0": 2000, "v2.0": 1000},
+        "severity_distribution": {"v3.1": {"CRITICAL": 500, "HIGH": 2000, "MEDIUM": 3500, "LOW": 900, "NONE": 100}},
     }
 
 
 @pytest.fixture
-def sample_year_data():
+def sample_year_data() -> dict[str, Any]:
     """Return sample year data structure."""
     return {
         "year": 2024,
         "total_cves": 5000,
         "date_data": {
             "monthly_distribution": {
-                "1": 400, "2": 380, "3": 450, "4": 420, "5": 410, "6": 430,
-                "7": 440, "8": 390, "9": 460, "10": 470, "11": 400, "12": 350
+                "1": 400,
+                "2": 380,
+                "3": 450,
+                "4": 420,
+                "5": 410,
+                "6": 430,
+                "7": 440,
+                "8": 390,
+                "9": 460,
+                "10": 470,
+                "11": 400,
+                "12": 350,
             },
             "daily_analysis": {
                 "total_days": 365,
                 "days_with_cves": 350,
                 "avg_cves_per_day": 13.7,
-                "max_cves_in_day": 85
-            }
+                "max_cves_in_day": 85,
+            },
         },
-        "cvss": {
-            "severity_distribution": {
-                "CRITICAL": 250,
-                "HIGH": 1250,
-                "MEDIUM": 2000,
-                "LOW": 1250,
-                "NONE": 250
-            }
-        }
+        "cvss": {"severity_distribution": {"CRITICAL": 250, "HIGH": 1250, "MEDIUM": 2000, "LOW": 1250, "NONE": 250}},
     }
 
 
 @pytest.fixture
-def mock_cve_list_dir(temp_dir):
+def mock_cve_list_dir(temp_dir: Path) -> Generator[Path, None, None]:
     """Create a mock CVE list directory structure with sample data."""
     cves_dir = temp_dir / "cvelistV5" / "cves"
-    
+
     # Create year/number directories
     year_dir = cves_dir / "2024" / "12xxx"
     year_dir.mkdir(parents=True)
-    
+
     # Create a sample CVE file
     cve_file = year_dir / "CVE-2024-12345.json"
     cve_data = {
@@ -204,21 +189,21 @@ def mock_cve_list_dir(temp_dir):
             "assignerOrgId": "test-org-id",
             "assignerShortName": "test_cna",
             "state": "PUBLISHED",
-            "datePublished": "2024-06-15T10:30:00.000Z"
+            "datePublished": "2024-06-15T10:30:00.000Z",
         },
         "containers": {
             "cna": {
                 "affected": [{"vendor": "test_vendor", "product": "test_product"}],
                 "descriptions": [{"lang": "en", "value": "Test vulnerability"}],
                 "problemTypes": [{"descriptions": [{"type": "CWE", "cweId": "CWE-79"}]}],
-                "metrics": [{"cvssV3_1": {"baseScore": 7.5, "baseSeverity": "HIGH"}}]
+                "metrics": [{"cvssV3_1": {"baseScore": 7.5, "baseSeverity": "HIGH"}}],
             }
-        }
+        },
     }
-    
-    with open(cve_file, 'w') as f:
+
+    with open(cve_file, "w") as f:
         json.dump(cve_data, f)
-    
+
     yield temp_dir
 
 
@@ -233,8 +218,8 @@ def mock_cve_list_dir(temp_dir):
         "cvss": {"type": "object"},
         "kev": {"type": "object"},
         "vendors": {"type": "object"},
-        "cwe": {"type": "object"}
-    }
+        "cwe": {"type": "object"},
+    },
 }
 
 CNA_ANALYSIS_SCHEMA = {
@@ -256,11 +241,11 @@ def mock_cve_list_dir(temp_dir):
                     "kev_count": {"type": "integer", "minimum": 0},
                     "epss_high_count": {"type": "integer", "minimum": 0},
                     "activity_status": {"type": "string"},
-                    "is_official": {"type": "boolean"}
-                }
-            }
-        }
-    }
+                    "is_official": {"type": "boolean"},
+                },
+            },
+        },
+    },
 }
 
 CVSS_ANALYSIS_SCHEMA = {
@@ -273,8 +258,8 @@ def mock_cve_list_dir(temp_dir):
         "severity_distribution": {"type": "object"},
         "score_distribution": {"type": "object"},
         "kev_global_count": {"type": "integer"},
-        "kev_by_year": {"type": "object"}
-    }
+        "kev_by_year": {"type": "object"},
+    },
 }
 
 DATA_QUALITY_SCHEMA = {
@@ -291,11 +276,11 @@ def mock_cve_list_dir(temp_dir):
                 "org_name_matches": {"type": "integer"},
                 "normalized_matches": {"type": "integer"},
                 "partial_matches": {"type": "integer"},
-                "unmatched": {"type": "integer"}
-            }
+                "unmatched": {"type": "integer"},
+            },
         },
         "exact_matches": {"type": "array"},
         "case_mismatches": {"type": "array"},
-        "unmatched": {"type": "array"}
-    }
+        "unmatched": {"type": "array"},
+    },
 }
diff --git a/tests/fakes.py b/tests/fakes.py
new file mode 100644
index 00000000000..3f6a90b29fd
--- /dev/null
+++ b/tests/fakes.py
@@ -0,0 +1,493 @@
+#!/usr/bin/env python3
+"""
+Test doubles (fakes) for CVEDB protocols.
+
+Provides in-memory implementations of protocols for unit testing.
+These fakes allow tests to run without actual file system access
+or HTTP requests, making tests faster and more deterministic.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+class FakeHttpResponse:
+    """Fake HTTP response for testing.
+
+    Simulates requests.Response interface with configurable
+    status codes, content, and headers.
+    """
+
+    def __init__(
+        self,
+        status_code: int = 200,
+        content: bytes = b"",
+        headers: dict[str, str] | None = None,
+        json_data: Any | None = None,
+    ) -> None:
+        self._status_code = status_code
+        self._content = content
+        self._headers = headers or {}
+        self._json_data = json_data
+
+        # If json_data provided, serialize it to content
+        if json_data is not None and not content:
+            self._content = json.dumps(json_data).encode("utf-8")
+
+    @property
+    def status_code(self) -> int:
+        return self._status_code
+
+    @property
+    def content(self) -> bytes:
+        return self._content
+
+    @property
+    def text(self) -> str:
+        return self._content.decode("utf-8")
+
+    @property
+    def headers(self) -> dict[str, str]:
+        return self._headers
+
+    def json(self) -> Any:
+        if self._json_data is not None:
+            return self._json_data
+        return json.loads(self._content.decode("utf-8"))
+
+    def raise_for_status(self) -> None:
+        if self._status_code >= 400:
+            raise FakeHttpError(f"HTTP {self._status_code}")
+
+    def iter_content(self, chunk_size: int = 1) -> Any:
+        """Yield content in chunks."""
+        for i in range(0, len(self._content), chunk_size):
+            yield self._content[i : i + chunk_size]
+
+
+class FakeHttpError(Exception):
+    """Fake HTTP error for testing error handling."""
+
+    pass
+
+
+class FakeHttpClient:
+    """Fake HTTP client for testing.
+
+    Provides configurable responses for specific URLs.
+    Tracks request history for assertions.
+
+    Example:
+        client = FakeHttpClient()
+        client.add_response('https://example.com/data.json',
+                           json_data={'key': 'value'})
+        response = client.get('https://example.com/data.json')
+        assert response.json() == {'key': 'value'}
+        assert client.request_count == 1
+    """
+
+    def __init__(self) -> None:
+        self._responses: dict[str, FakeHttpResponse] = {}
+        self._request_history: list[dict[str, Any]] = []
+        self._default_response: FakeHttpResponse | None = None
+
+    def add_response(
+        self,
+        url: str,
+        *,
+        status_code: int = 200,
+        content: bytes = b"",
+        headers: dict[str, str] | None = None,
+        json_data: Any | None = None,
+    ) -> None:
+        """Add a fake response for a specific URL."""
+        self._responses[url] = FakeHttpResponse(
+            status_code=status_code,
+            content=content,
+            headers=headers or {"content-length": str(len(content))},
+            json_data=json_data,
+        )
+
+    def set_default_response(self, status_code: int = 200, content: bytes = b"", json_data: Any | None = None) -> None:
+        """Set default response for unregistered URLs."""
+        self._default_response = FakeHttpResponse(status_code=status_code, content=content, json_data=json_data)
+
+    def get(self, url: str, *, timeout: int | None = None, stream: bool = False) -> FakeHttpResponse:
+        """Perform fake HTTP GET request."""
+        self._request_history.append({"url": url, "timeout": timeout, "stream": stream})
+
+        if url in self._responses:
+            return self._responses[url]
+
+        if self._default_response is not None:
+            return self._default_response
+
+        # Return 404 for unregistered URLs
+        return FakeHttpResponse(status_code=404, content=b"Not Found")
+
+    @property
+    def request_count(self) -> int:
+        """Number of requests made."""
+        return len(self._request_history)
+
+    @property
+    def request_history(self) -> list[dict[str, Any]]:
+        """List of all requests made."""
+        return self._request_history.copy()
+
+    def clear_history(self) -> None:
+        """Clear request history."""
+        self._request_history.clear()
+
+
+class FakeDataReader:
+    """Fake data reader for testing.
+
+    Provides in-memory file system simulation.
+
+    Example:
+        reader = FakeDataReader()
+        reader.add_json(Path('config.json'), {'debug': True})
+        config = reader.read_json(Path('config.json'))
+        assert config == {'debug': True}
+    """
+
+    def __init__(self) -> None:
+        self._files: dict[str, bytes] = {}
+        self._json_files: dict[str, Any] = {}
+
+    def add_file(self, path: Path, content: bytes | str) -> None:
+        """Add a fake file."""
+        key = str(path)
+        if isinstance(content, str):
+            self._files[key] = content.encode("utf-8")
+        else:
+            self._files[key] = content
+
+    def add_json(self, path: Path, data: Any) -> None:
+        """Add a fake JSON file."""
+        key = str(path)
+        self._json_files[key] = data
+        self._files[key] = json.dumps(data).encode("utf-8")
+
+    def add_directory(self, path: Path, files: list[str]) -> None:
+        """Add a fake directory with file names."""
+        key = str(path)
+        # Store directory marker and contents
+        self._files[f"{key}/__dir__"] = b""
+        for file_name in files:
+            file_path = path / file_name
+            if str(file_path) not in self._files:
+                self._files[str(file_path)] = b""
+
+    def read_json(self, path: Path) -> Any:
+        """Read and parse JSON from fake file."""
+        key = str(path)
+        if key in self._json_files:
+            return self._json_files[key]
+        if key in self._files:
+            return json.loads(self._files[key].decode("utf-8"))
+        raise FileNotFoundError(f"Fake file not found: {path}")
+
+    def read_text(self, path: Path) -> str:
+        """Read text content from fake file."""
+        key = str(path)
+        if key in self._files:
+            return self._files[key].decode("utf-8")
+        raise FileNotFoundError(f"Fake file not found: {path}")
+
+    def read_bytes(self, path: Path) -> bytes:
+        """Read binary content from fake file."""
+        key = str(path)
+        if key in self._files:
+            return self._files[key]
+        raise FileNotFoundError(f"Fake file not found: {path}")
+
+    def exists(self, path: Path) -> bool:
+        """Check if fake path exists."""
+        key = str(path)
+        return key in self._files or f"{key}/__dir__" in self._files
+
+    def list_dir(self, path: Path) -> list[Path]:
+        """List fake directory contents."""
+        key = str(path)
+        result = []
+        prefix = f"{key}/"
+        seen = set()
+
+        for file_key in self._files:
+            if file_key.startswith(prefix) and file_key != f"{key}/__dir__":
+                # Get the immediate child
+                remainder = file_key[len(prefix) :]
+                child = remainder.split("/")[0]
+                if child not in seen:
+                    seen.add(child)
+                    result.append(Path(path) / child)
+
+        return result
+
+
+class FakeDataWriter:
+    """Fake data writer for testing.
+
+    Captures all writes in memory for assertions.
+
+    Example:
+        writer = FakeDataWriter()
+        writer.write_json(Path('output.json'), {'result': 42})
+        assert writer.get_json(Path('output.json')) == {'result': 42}
+    """
+
+    def __init__(self) -> None:
+        self._files: dict[str, bytes] = {}
+        self._directories: set[str] = set()
+
+    def write_json(self, path: Path, data: Any, indent: int = 2) -> None:
+        """Write data as JSON to fake file."""
+        key = str(path)
+        self._files[key] = json.dumps(data, indent=indent).encode("utf-8")
+
+    def write_text(self, path: Path, content: str) -> None:
+        """Write text content to fake file."""
+        key = str(path)
+        self._files[key] = content.encode("utf-8")
+
+    def write_bytes(self, path: Path, content: bytes) -> None:
+        """Write binary content to fake file."""
+        key = str(path)
+        self._files[key] = content
+
+    def mkdir(self, path: Path, parents: bool = True, exist_ok: bool = True) -> None:
+        """Create fake directory."""
+        key = str(path)
+        if key in self._directories and not exist_ok:
+            raise FileExistsError(f"Directory exists: {path}")
+        self._directories.add(key)
+
+    # Assertion helpers
+
+    def get_json(self, path: Path) -> Any:
+        """Get written JSON data for assertions."""
+        key = str(path)
+        if key not in self._files:
+            raise KeyError(f"File not written: {path}")
+        return json.loads(self._files[key].decode("utf-8"))
+
+    def get_text(self, path: Path) -> str:
+        """Get written text content for assertions."""
+        key = str(path)
+        if key not in self._files:
+            raise KeyError(f"File not written: {path}")
+        return self._files[key].decode("utf-8")
+
+    def get_bytes(self, path: Path) -> bytes:
+        """Get written binary content for assertions."""
+        key = str(path)
+        if key not in self._files:
+            raise KeyError(f"File not written: {path}")
+        return self._files[key]
+
+    def was_written(self, path: Path) -> bool:
+        """Check if file was written."""
+        return str(path) in self._files
+
+    def was_directory_created(self, path: Path) -> bool:
+        """Check if directory was created."""
+        return str(path) in self._directories
+
+    @property
+    def written_files(self) -> list[str]:
+        """List all written file paths."""
+        return list(self._files.keys())
+
+    @property
+    def created_directories(self) -> list[str]:
+        """List all created directories."""
+        return list(self._directories)
+
+
+class FakeCacheManager:
+    """Fake cache manager for testing.
+
+    In-memory cache with configurable validity.
+
+    Example:
+        cache = FakeCacheManager()
+        cache.set('key', 'value', ttl_seconds=3600)
+        assert cache.get('key') == 'value'
+        assert cache.is_valid('key') == True
+    """
+
+    def __init__(self, default_valid: bool = True) -> None:
+        self._cache: dict[str, Any] = {}
+        self._validity: dict[str, bool] = {}
+        self._default_valid = default_valid
+
+    def is_valid(self, key: str) -> bool:
+        """Check if cache entry is valid."""
+        if key not in self._cache:
+            return False
+        return self._validity.get(key, self._default_valid)
+
+    def get(self, key: str) -> Any | None:
+        """Get cached value."""
+        return self._cache.get(key)
+
+    def set(self, key: str, value: Any, ttl_seconds: int | None = None) -> None:
+        """Set cache value."""
+        self._cache[key] = value
+        self._validity[key] = True
+
+    def invalidate(self, key: str) -> None:
+        """Invalidate cache entry."""
+        self._validity[key] = False
+
+    def set_validity(self, key: str, valid: bool) -> None:
+        """Manually set validity for testing."""
+        self._validity[key] = valid
+
+    def clear(self) -> None:
+        """Clear all cache entries."""
+        self._cache.clear()
+        self._validity.clear()
+
+
+# =============================================================================
+# Async Test Doubles
+# =============================================================================
+
+
+class FakeAsyncHttpResponse:
+    """Fake async HTTP response for testing.
+
+    Simulates httpx.Response interface for async testing.
+    """
+
+    def __init__(
+        self,
+        status_code: int = 200,
+        content: bytes = b"",
+        headers: dict[str, str] | None = None,
+        json_data: Any | None = None,
+    ) -> None:
+        self._status_code = status_code
+        self._content = content
+        self._headers = headers or {}
+        self._json_data = json_data
+
+        if json_data is not None and not content:
+            self._content = json.dumps(json_data).encode("utf-8")
+
+    @property
+    def status_code(self) -> int:
+        return self._status_code
+
+    @property
+    def content(self) -> bytes:
+        return self._content
+
+    @property
+    def text(self) -> str:
+        return self._content.decode("utf-8")
+
+    @property
+    def headers(self) -> dict[str, str]:
+        return self._headers
+
+    def json(self) -> Any:
+        if self._json_data is not None:
+            return self._json_data
+        return json.loads(self._content.decode("utf-8"))
+
+    def raise_for_status(self) -> None:
+        if self._status_code >= 400:
+            raise FakeHttpError(f"HTTP {self._status_code}")
+
+
+class FakeAsyncHttpClient:
+    """Fake async HTTP client for testing.
+
+    Provides configurable responses for async HTTP requests.
+    Supports context manager protocol for async with.
+
+    Example:
+        client = FakeAsyncHttpClient()
+        client.add_response('https://example.com/api', json_data={'key': 'value'})
+
+        async with client:
+            response = await client.get('https://example.com/api')
+            assert response.json() == {'key': 'value'}
+    """
+
+    def __init__(self) -> None:
+        self._responses: dict[str, FakeAsyncHttpResponse] = {}
+        self._request_history: list[dict[str, Any]] = []
+        self._default_response: FakeAsyncHttpResponse | None = None
+
+    def add_response(
+        self,
+        url: str,
+        *,
+        status_code: int = 200,
+        content: bytes = b"",
+        headers: dict[str, str] | None = None,
+        json_data: Any | None = None,
+    ) -> None:
+        """Add a fake response for a specific URL."""
+        self._responses[url] = FakeAsyncHttpResponse(
+            status_code=status_code,
+            content=content,
+            headers=headers or {"content-length": str(len(content))},
+            json_data=json_data,
+        )
+
+    def set_default_response(self, status_code: int = 200, content: bytes = b"", json_data: Any | None = None) -> None:
+        """Set default response for unregistered URLs."""
+        self._default_response = FakeAsyncHttpResponse(status_code=status_code, content=content, json_data=json_data)
+
+    async def __aenter__(self) -> FakeAsyncHttpClient:
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Async context manager exit."""
+        pass
+
+    async def get(
+        self,
+        url: str,
+        *,
+        timeout: int | None = None,
+    ) -> FakeAsyncHttpResponse:
+        """Perform fake async HTTP GET request."""
+        self._request_history.append(
+            {
+                "url": url,
+                "timeout": timeout,
+            }
+        )
+
+        if url in self._responses:
+            return self._responses[url]
+
+        if self._default_response is not None:
+            return self._default_response
+
+        return FakeAsyncHttpResponse(status_code=404, content=b"Not Found")
+
+    @property
+    def request_count(self) -> int:
+        """Number of requests made."""
+        return len(self._request_history)
+
+    @property
+    def request_history(self) -> list[dict[str, Any]]:
+        """List of all requests made."""
+        return self._request_history.copy()
+
+    def clear_history(self) -> None:
+        """Clear request history."""
+        self._request_history.clear()
diff --git a/tests/test_async_downloader.py b/tests/test_async_downloader.py
new file mode 100644
index 00000000000..fc4ef608a6f
--- /dev/null
+++ b/tests/test_async_downloader.py
@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+Tests for async CVE data downloader.
+
+Tests parallel download functionality and async HTTP client behavior.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "data"))
+
+from tests.fakes import FakeAsyncHttpClient
+
+
+class TestFakeAsyncHttpClient:
+    """Tests for FakeAsyncHttpClient test double."""
+
+    @pytest.mark.asyncio
+    async def test_returns_configured_response(self):
+        """Fake async client returns configured response for URL."""
+        client = FakeAsyncHttpClient()
+        client.add_response("https://example.com/api", json_data={"status": "ok"})
+
+        async with client:
+            response = await client.get("https://example.com/api")
+
+        assert response.status_code == 200
+        assert response.json() == {"status": "ok"}
+
+    @pytest.mark.asyncio
+    async def test_returns_404_for_unknown_url(self):
+        """Fake async client returns 404 for unconfigured URLs."""
+        client = FakeAsyncHttpClient()
+
+        async with client:
+            response = await client.get("https://unknown.com")
+
+        assert response.status_code == 404
+
+    @pytest.mark.asyncio
+    async def test_tracks_request_history(self):
+        """Fake async client tracks all requests made."""
+        client = FakeAsyncHttpClient()
+        client.set_default_response(json_data={})
+
+        async with client:
+            await client.get("https://example.com/a")
+            await client.get("https://example.com/b", timeout=30)
+
+        assert client.request_count == 2
+        assert client.request_history[0]["url"] == "https://example.com/a"
+        assert client.request_history[1]["timeout"] == 30
+
+    @pytest.mark.asyncio
+    async def test_parallel_requests(self):
+        """Fake async client handles parallel requests."""
+        client = FakeAsyncHttpClient()
+        client.add_response("https://api1.com", json_data={"source": "api1"})
+        client.add_response("https://api2.com", json_data={"source": "api2"})
+        client.add_response("https://api3.com", json_data={"source": "api3"})
+
+        async with client:
+            responses = await asyncio.gather(
+                client.get("https://api1.com"),
+                client.get("https://api2.com"),
+                client.get("https://api3.com"),
+            )
+
+        assert len(responses) == 3
+        sources = {r.json()["source"] for r in responses}
+        assert sources == {"api1", "api2", "api3"}
+        assert client.request_count == 3
+
+
+class TestAsyncDownloaderIntegration:
+    """Integration tests for AsyncCVEDownloader with fakes."""
+
+    @pytest.mark.asyncio
+    async def test_download_result_dataclass(self):
+        """DownloadResult dataclass works correctly."""
+        # Import here to avoid issues if httpx not installed
+        try:
+            from async_downloader import DownloadResult
+        except ImportError:
+            pytest.skip("async_downloader not available")
+
+        result = DownloadResult(
+            source="test",
+            success=True,
+            path=Path("/tmp/test.json"),
+            size_bytes=1024,
+            duration_seconds=0.5,
+        )
+
+        assert result.source == "test"
+        assert result.success is True
+        assert result.size_bytes == 1024
+        assert result.from_cache is False
+
+    @pytest.mark.asyncio
+    async def test_async_downloader_initialization(self, tmp_path):
+        """AsyncCVEDownloader initializes correctly."""
+        try:
+            from async_downloader import AsyncCVEDownloader
+        except ImportError:
+            pytest.skip("async_downloader not available")
+
+        downloader = AsyncCVEDownloader(cache_dir=tmp_path, quiet=True)
+
+        assert downloader.cache_dir == tmp_path
+        assert downloader.nvd_file == tmp_path / "nvd.json"
+        assert downloader.epss_cache_file == tmp_path / "epss_scores-current.csv.gz"
+        assert downloader.kev_cache_file == tmp_path / "known_exploited_vulnerabilities.json"
+
+
+class TestAsyncDownloaderCacheValidity:
+    """Tests for cache validity checking."""
+
+    def test_cache_validity_for_missing_file(self, tmp_path):
+        """Missing file should report invalid cache."""
+        try:
+            from async_downloader import AsyncCVEDownloader
+        except ImportError:
+            pytest.skip("async_downloader not available")
+
+        downloader = AsyncCVEDownloader(cache_dir=tmp_path, quiet=True)
+
+        assert downloader._is_cache_valid(tmp_path / "missing.json") is False
+
+    def test_cache_validity_for_existing_file(self, tmp_path):
+        """Recent file should report valid cache."""
+        try:
+            from async_downloader import AsyncCVEDownloader
+        except ImportError:
+            pytest.skip("async_downloader not available")
+
+        test_file = tmp_path / "test.json"
+        test_file.write_text('{"test": true}')
+
+        downloader = AsyncCVEDownloader(cache_dir=tmp_path, quiet=True)
+
+        assert downloader._is_cache_valid(test_file) is True
+
+
+class TestEpssKevParsing:
+    """Tests for EPSS and KEV data parsing."""
+
+    def test_parse_kev_json(self, tmp_path):
+        """KEV JSON parsing works correctly."""
+        try:
+            from async_downloader import AsyncCVEDownloader
+        except ImportError:
+            pytest.skip("async_downloader not available")
+
+        # Create fake KEV data
+        kev_data = {
+            "vulnerabilities": [
+                {"cveID": "CVE-2024-0001"},
+                {"cveID": "CVE-2024-0002"},
+                {"cveID": "CVE-2023-9999"},
+            ]
+        }
+
+        downloader = AsyncCVEDownloader(cache_dir=tmp_path, quiet=True)
+        downloader.kev_cache_file.write_text(json.dumps(kev_data))
+
+        result = downloader.parse_kev()
+
+        assert result is not None
+        assert len(result) == 3
+        assert "CVE-2024-0001" in result
+        assert "CVE-2024-0002" in result
+        assert "CVE-2023-9999" in result
+
+    def test_parse_kev_handles_missing_file(self, tmp_path):
+        """KEV parsing handles missing file gracefully."""
+        try:
+            from async_downloader import AsyncCVEDownloader
+        except ImportError:
+            pytest.skip("async_downloader not available")
+
+        downloader = AsyncCVEDownloader(cache_dir=tmp_path, quiet=True)
+
+        result = downloader.parse_kev()
+
+        assert result is None
+
+
+class TestParallelDownloadBehavior:
+    """Tests demonstrating parallel download behavior."""
+
+    @pytest.mark.asyncio
+    async def test_gather_collects_all_results(self):
+        """asyncio.gather collects results from parallel tasks."""
+
+        async def fake_download(name: str, delay: float) -> dict:
+            await asyncio.sleep(delay)
+            return {"source": name, "success": True}
+
+        # All downloads complete in ~0.1s total (parallel)
+        # vs ~0.3s if sequential
+        results = await asyncio.gather(
+            fake_download("nvd", 0.05),
+            fake_download("epss", 0.05),
+            fake_download("kev", 0.05),
+        )
+
+        assert len(results) == 3
+        sources = {r["source"] for r in results}
+        assert sources == {"nvd", "epss", "kev"}
+
+    @pytest.mark.asyncio
+    async def test_gather_handles_exceptions(self):
+        """asyncio.gather with return_exceptions handles failures."""
+
+        async def succeed() -> str:
+            return "ok"
+
+        async def fail() -> str:
+            raise ValueError("download failed")
+
+        results = await asyncio.gather(
+            succeed(),
+            fail(),
+            succeed(),
+            return_exceptions=True,
+        )
+
+        assert results[0] == "ok"
+        assert isinstance(results[1], ValueError)
+        assert results[2] == "ok"
diff --git a/tests/test_build.py b/tests/test_build.py
index 7559ecbc55a..ced8e28c54b 100644
--- a/tests/test_build.py
+++ b/tests/test_build.py
@@ -6,47 +6,36 @@
 """
 
 import json
-import os
 from pathlib import Path
+
 import pytest
 
+
 # Paths
 ROOT_DIR = Path(__file__).parent.parent
-# Updated to point to 'dist' instead of 'web'
-DIST_DIR = ROOT_DIR / "dist"
-DIST_DATA_DIR = DIST_DIR / "data"
+WEB_DIR = ROOT_DIR / "web"
+WEB_DATA_DIR = WEB_DIR / "data"
 TEMPLATES_DIR = ROOT_DIR / "templates"
 
 
 class TestBuildOutputExists:
     """Verify that expected build outputs exist."""
-    
-    @pytest.mark.skipif(
-        not DIST_DIR.exists(),
-        reason="Dist directory not found - run build first"
-    )
-    def test_dist_directory_exists(self):
+
+    @pytest.mark.skipif(not WEB_DIR.exists(), reason="Web directory not found - run build first")
+    def test_web_directory_exists(self):
         """Web output directory should exist."""
-        assert DIST_DIR.exists()
-        assert DIST_DIR.is_dir()
-    
-    @pytest.mark.skipif(
-        not DIST_DATA_DIR.exists(),
-        reason="Dist data directory not found - run build first"
-    )
+        assert WEB_DIR.exists()
+        assert WEB_DIR.is_dir()
+
+    @pytest.mark.skipif(not WEB_DATA_DIR.exists(), reason="Web data directory not found - run build first")
     def test_data_directory_exists(self):
         """Web data directory should exist."""
-        assert DIST_DATA_DIR.exists()
-        assert DIST_DATA_DIR.is_dir()
-    
-    @pytest.mark.skipif(
-        not DIST_DATA_DIR.exists(),
-        reason="Dist data directory not found - run build first"
-    )
+        assert WEB_DATA_DIR.exists()
+        assert WEB_DATA_DIR.is_dir()
+
+    @pytest.mark.skipif(not WEB_DATA_DIR.exists(), reason="Web data directory not found - run build first")
     def test_core_json_files_exist(self):
         """Core JSON data files should exist."""
-        # Note: filenames might have changed slightly depending on 
-        # what build.py generates.
         required_files = [
             "cna_analysis.json",
             "cvss_analysis.json",
@@ -57,17 +46,12 @@ def test_core_json_files_exist(self):
             "yearly_summary.json",
             "cve_all.json",
         ]
-        
+
         for filename in required_files:
-            filepath = DIST_DATA_DIR / filename
-            # Warn but don't fail if we suspect build just didn't finish
-            if not filepath.exists():
-                pytest.warns(UserWarning, match=f"Missing required file: {filename}")
-    
-    @pytest.mark.skipif(
-        not DIST_DIR.exists(),
-        reason="Dist directory not found - run build first"
-    )
+            filepath = WEB_DATA_DIR / filename
+            assert filepath.exists(), f"Missing required file: {filename}"
+
+    @pytest.mark.skipif(not WEB_DIR.exists(), reason="Web directory not found - run build first")
     def test_html_pages_exist(self):
         """HTML pages should be generated."""
         required_pages = [
@@ -86,86 +70,200 @@ def test_html_pages_exist(self):
             "data-quality.html",
             "about.html",
         ]
-        
+
         for page in required_pages:
-            filepath = DIST_DIR / page
+            filepath = WEB_DIR / page
             assert filepath.exists(), f"Missing HTML page: {page}"
-    
-    @pytest.mark.skipif(
-        not (DIST_DIR / "static").exists(),
-        reason="Static directory not found - run build first"
-    )
+
+    @pytest.mark.skipif(not (WEB_DIR / "static").exists(), reason="Static directory not found - run build first")
     def test_static_assets_exist(self):
         """Static assets should be present."""
-        static_dir = DIST_DIR / "static"
-        
+        static_dir = WEB_DIR / "static"
+
         # Check CSS
         css_dir = static_dir / "css"
         assert css_dir.exists(), "CSS directory missing"
-        # We allow style.css or anything else
-        assert any(css_dir.glob("*.css")), "No CSS files found"
-        
-        # Check JS directory exists
+        assert (css_dir / "style.css").exists(), "Main stylesheet missing"
+
+        # No JS directory is expected: the site vendors no JavaScript. Chart.js is
+        # loaded from a pinned CDN URL in base.html. The directory previously held
+        # an ESM build of Chart.js that could not be loaded with a classic script
+        # tag, so it threw on every page that referenced it.
         js_dir = static_dir / "js"
-        assert js_dir.exists(), "JS directory missing"
+        if js_dir.exists():
+            assert not list(js_dir.glob("chart*.js")), (
+                "A vendored Chart.js is back. If that is intended it must be the UMD "
+                "build (dist/chart.umd.js), and base.html should reference it."
+            )
 
 
 class TestBuildOutputValidity:
     """Verify that build outputs are valid and well-formed."""
-    
-    @pytest.mark.skipif(
-        not DIST_DATA_DIR.exists(),
-        reason="Dist data directory not found - run build first"
-    )
+
+    @pytest.mark.skipif(not WEB_DATA_DIR.exists(), reason="Web data directory not found - run build first")
     def test_json_files_are_valid(self):
         """All JSON files should be valid JSON."""
-        json_files = list(DIST_DATA_DIR.glob("*.json"))
-        
-        if len(json_files) == 0:
-            pytest.skip("No JSON files found to test")
-        
+        json_files = list(WEB_DATA_DIR.glob("*.json"))
+
+        assert len(json_files) > 0, "No JSON files found"
+
         for json_file in json_files:
             try:
                 with open(json_file) as f:
                     json.load(f)
             except json.JSONDecodeError as e:
                 pytest.fail(f"Invalid JSON in {json_file.name}: {e}")
-    
-    @pytest.mark.skipif(
-        not DIST_DIR.exists(),
-        reason="Dist directory not found - run build first"
-    )
+
+    @pytest.mark.skipif(not WEB_DIR.exists(), reason="Web directory not found - run build first")
     def test_html_files_have_content(self):
         """HTML files should not be empty."""
-        html_files = list(DIST_DIR.glob("*.html"))
-        
+        html_files = list(WEB_DIR.glob("*.html"))
+
         assert len(html_files) > 0, "No HTML files found"
-        
+
         for html_file in html_files:
             content = html_file.read_text()
             assert len(content) > 100, f"HTML file {html_file.name} appears empty"
-            assert "<!DOCTYPE html>" in content or "<html" in content, \
+            assert "<!DOCTYPE html>" in content or "<html" in content, (
                 f"HTML file {html_file.name} missing HTML structure"
+            )
+
+    @pytest.mark.skipif(
+        not (WEB_DATA_DIR / "cna_analysis.json").exists(), reason="CNA analysis file not found - run build first"
+    )
+    def test_cna_analysis_has_data(self):
+        """CNA analysis should have meaningful data."""
+        with open(WEB_DATA_DIR / "cna_analysis.json") as f:
+            data = json.load(f)
+
+        assert data.get("total_cnas", 0) > 100, "Too few CNAs - data may be incomplete"
+        assert len(data.get("cna_list", [])) > 100, "CNA list too short"
+
+    @pytest.mark.skipif(
+        not (WEB_DATA_DIR / "yearly_summary.json").exists(), reason="Yearly summary file not found - run build first"
+    )
+    def test_yearly_summary_has_all_years(self):
+        """Yearly summary should contain all years from 1999."""
+        with open(WEB_DATA_DIR / "yearly_summary.json") as f:
+            data = json.load(f)
+
+        years = data.get("years", {})
+
+        # Convert keys to integers for comparison
+        year_ints = [int(y) for y in years]
+
+        assert min(year_ints) == 1999, "Missing early years"
+        assert max(year_ints) >= 2024, "Missing recent years"
+
+        # Should have reasonable total CVE counts
+        total_cves = sum(y.get("total_cves", 0) for y in years.values())
+        assert total_cves > 200000, f"Total CVEs ({total_cves}) seems too low"
 
 
 class TestTemplateValidity:
     """Verify that Jinja2 templates are valid."""
-    
+
     def test_templates_exist(self):
         """Template directory should have templates."""
         assert TEMPLATES_DIR.exists(), "Templates directory missing"
-        
-        templates = list(TEMPLATES_DIR.glob("**/*.html"))
-        assert len(templates) > 5, "Too few templates found"
-    
+
+        templates = list(TEMPLATES_DIR.glob("*.html"))
+        assert len(templates) > 10, "Too few templates found"
+
+    def test_templates_extend_base(self):
+        """Most templates should extend base.html."""
+        templates = list(TEMPLATES_DIR.glob("*.html"))
+
+        for template in templates:
+            if template.name == "base.html":
+                continue
+
+            content = template.read_text()
+            # Most templates should extend base
+            if "{% extends" in content:
+                assert "base.html" in content, f"Template {template.name} extends something other than base.html"
+
+    def test_child_blocks_are_defined_in_base(self):
+        """Every block a child template fills must exist in base.html.
+
+        Jinja silently discards a {% block x %} in a child when the parent
+        defines no matching block. calendar.html filled a "head" block that
+        base.html never declared, so ~200 lines of calendar CSS were dropped
+        from every build and the heatmap rendered unstyled.
+        """
+        import re
+
+        base = (TEMPLATES_DIR / "base.html").read_text()
+        defined = set(re.findall(r"{%-?\s*block\s+([a-zA-Z_][a-zA-Z0-9_]*)", base))
+
+        orphans = []
+        for template in sorted(TEMPLATES_DIR.glob("*.html")):
+            if template.name == "base.html":
+                continue
+            content = template.read_text()
+            if "{% extends" not in content:
+                continue
+            for name in re.findall(r"{%-?\s*block\s+([a-zA-Z_][a-zA-Z0-9_]*)", content):
+                if name not in defined:
+                    orphans.append(f"{template.name} fills '{name}'")
+
+        assert not orphans, "These blocks are silently discarded because base.html does not define them: " + "; ".join(
+            orphans
+        )
+
     def test_base_template_has_required_blocks(self):
         """Base template should define required blocks."""
         base_path = TEMPLATES_DIR / "base.html"
         assert base_path.exists(), "base.html template missing"
-        
+
         content = base_path.read_text()
-        
-        # Check for essential blocks - forgivingly
-        if "{% block content %}" not in content:
-             # Might used styled blocks
-             pass
+
+        # Check for essential blocks
+        assert "{% block content %}" in content, "Missing content block"
+        assert "{% block title %}" in content, "Missing title block"
+
+        # Check for navigation
+        assert "nav" in content.lower(), "Missing navigation"
+
+        # Check for footer
+        assert "footer" in content.lower(), "Missing footer"
+
+
+class TestDataConsistency:
+    """Verify data consistency across files."""
+
+    @pytest.mark.skipif(
+        not all((WEB_DATA_DIR / f).exists() for f in ["cna_analysis.json", "cna_analysis_current_year.json"]),
+        reason="Required files not found - run build first",
+    )
+    def test_current_year_subset_of_all(self):
+        """Current year CNAs should be a subset of all CNAs."""
+        with open(WEB_DATA_DIR / "cna_analysis.json") as f:
+            all_data = json.load(f)
+
+        with open(WEB_DATA_DIR / "cna_analysis_current_year.json") as f:
+            current_data = json.load(f)
+
+        all_cna_names = {cna["name"] for cna in all_data.get("cna_list", [])}
+        current_cna_names = {cna["name"] for cna in current_data.get("cna_list", [])}
+
+        # All current year CNAs should exist in the all-time list
+        missing = current_cna_names - all_cna_names
+        assert len(missing) == 0, f"Current year CNAs not in all-time: {missing}"
+
+    @pytest.mark.skipif(
+        not (WEB_DATA_DIR / "data_quality.json").exists(), reason="Data quality file not found - run build first"
+    )
+    def test_data_quality_match_rate(self):
+        """Data quality should show reasonable match rate."""
+        with open(WEB_DATA_DIR / "data_quality.json") as f:
+            data = json.load(f)
+
+        stats = data.get("stats", {})
+        total = stats.get("total_cnas_in_analysis", 0)
+        unmatched = stats.get("unmatched", 0)
+
+        if total > 0:
+            match_rate = (total - unmatched) / total
+            # Should match at least 80% of CNAs
+            assert match_rate >= 0.80, f"Match rate too low: {match_rate:.1%}"
diff --git a/tests/test_data_quality.py b/tests/test_data_quality.py
index c91ed663445..1857efd717d 100644
--- a/tests/test_data_quality.py
+++ b/tests/test_data_quality.py
@@ -1,51 +1,67 @@
 """
-Tests for the data quality analysis module (cvedb.cna.data_quality).
+Tests for the data quality analysis module (rebuild_data_quality.py).
 
 Tests the CNAScorecard-style name matching logic.
 """
 
-import pytest
 import sys
 from pathlib import Path
-from cvedb.cna.data_quality import normalize_name, build_official_cna_lookups, map_cve_name_to_official
 
-# Removed relative path imports as we now use the installed package
+import pytest
+
+
+# Add data/scripts to path
+DATA_SCRIPTS_DIR = Path(__file__).parent.parent / "data" / "scripts"
+sys.path.insert(0, str(DATA_SCRIPTS_DIR))
+
 
 class TestNameNormalization:
     """Test the name normalization function."""
-    
+
     def test_normalize_removes_spaces(self):
         """Normalization should remove spaces."""
+        from rebuild_data_quality import normalize_name
+
         assert normalize_name("Red Hat") == "redhat"
         assert normalize_name("Microsoft Corporation") == "microsoftcorporation"
-    
+
     def test_normalize_removes_hyphens(self):
         """Normalization should remove hyphens."""
+        from rebuild_data_quality import normalize_name
+
         assert normalize_name("F-Secure") == "fsecure"
         assert normalize_name("Hewlett-Packard") == "hewlettpackard"
-    
+
     def test_normalize_removes_underscores(self):
         """Normalization should remove underscores."""
+        from rebuild_data_quality import normalize_name
+
         assert normalize_name("some_vendor") == "somevendor"
-    
+
     def test_normalize_removes_dots(self):
         """Normalization should remove dots."""
+        from rebuild_data_quality import normalize_name
+
         assert normalize_name("example.com") == "examplecom"
-    
+
     def test_normalize_lowercases(self):
         """Normalization should lowercase."""
+        from rebuild_data_quality import normalize_name
+
         assert normalize_name("MICROSOFT") == "microsoft"
         assert normalize_name("Google") == "google"
-    
+
     def test_normalize_empty_string(self):
         """Normalization should handle empty strings."""
+        from rebuild_data_quality import normalize_name
+
         assert normalize_name("") == ""
         assert normalize_name(None) == ""
 
 
 class TestNameMatching:
     """Test the CNA name matching function."""
-    
+
     @pytest.fixture
     def official_cna_list(self):
         """Sample official CNA list."""
@@ -55,130 +71,145 @@ def official_cna_list(self):
             {"shortName": "redhat", "organizationName": "Red Hat, Inc.", "cnaID": "CNA-003"},
             {"shortName": "f-secure", "organizationName": "F-Secure Corporation", "cnaID": "CNA-004"},
         ]
-    
+
     @pytest.fixture
     def lookup_maps(self, official_cna_list):
         """Build lookup maps from official CNA list."""
+        from rebuild_data_quality import build_official_cna_lookups
+
         return build_official_cna_lookups(official_cna_list)
-    
+
     def test_exact_match(self, lookup_maps, official_cna_list):
         """Test exact shortName match."""
+        from rebuild_data_quality import map_cve_name_to_official
+
         short_map, org_map, all_names, norm_map = lookup_maps
-        
+
         result, match_type, confidence = map_cve_name_to_official(
             "microsoft", short_map, org_map, norm_map, official_cna_list
         )
-        
+
         assert result is not None
         assert result["shortName"] == "microsoft"
         assert match_type == "exact_short"
         assert confidence == "high"
-    
+
     def test_case_insensitive_match(self, lookup_maps, official_cna_list):
         """Test case-insensitive match."""
+        from rebuild_data_quality import map_cve_name_to_official
+
         short_map, org_map, all_names, norm_map = lookup_maps
-        
-        # Test case-insensitive match
+
         result, match_type, confidence = map_cve_name_to_official(
             "MICROSOFT", short_map, org_map, norm_map, official_cna_list
         )
-        
+
         assert result is not None
         assert result["shortName"] == "microsoft"
         assert match_type == "case_short"
         assert confidence == "high"
-    
+
     def test_organization_name_match(self, lookup_maps, official_cna_list):
         """Test match via organization name."""
+        from rebuild_data_quality import map_cve_name_to_official
+
         short_map, org_map, all_names, norm_map = lookup_maps
-        
+
         result, match_type, confidence = map_cve_name_to_official(
             "Microsoft Corporation", short_map, org_map, norm_map, official_cna_list
         )
-        
+
         assert result is not None
         assert result["shortName"] == "microsoft"
         assert match_type in ("exact_org", "case_org")
         assert confidence == "high"
-    
+
     def test_normalized_match(self, lookup_maps, official_cna_list):
         """Test match via normalization (removing hyphens, spaces)."""
+        from rebuild_data_quality import map_cve_name_to_official
+
         short_map, org_map, all_names, norm_map = lookup_maps
-        
+
         # "fsecure" should match "f-secure" after normalization
         result, match_type, confidence = map_cve_name_to_official(
             "fsecure", short_map, org_map, norm_map, official_cna_list
         )
-        
+
         assert result is not None
         assert result["shortName"] == "f-secure"
         assert match_type == "normalized"
         assert confidence == "medium"
-    
+
     def test_partial_match(self, lookup_maps, official_cna_list):
         """Test partial/substring match."""
+        from rebuild_data_quality import map_cve_name_to_official
+
         short_map, org_map, all_names, norm_map = lookup_maps
-        
+
         # "microsoftinc" contains "microsoft"
         result, match_type, confidence = map_cve_name_to_official(
             "microsoftinc", short_map, org_map, norm_map, official_cna_list
         )
-        
+
         assert result is not None
         assert result["shortName"] == "microsoft"
         assert match_type == "partial"
         assert confidence == "low"
-    
+
     def test_no_match(self, lookup_maps, official_cna_list):
         """Test when no match is found."""
+        from rebuild_data_quality import map_cve_name_to_official
+
         short_map, org_map, all_names, norm_map = lookup_maps
-        
+
         result, match_type, confidence = map_cve_name_to_official(
             "unknownvendor123", short_map, org_map, norm_map, official_cna_list
         )
-        
+
         assert result is None
         assert match_type is None
         assert confidence is None
-    
+
     def test_empty_name(self, lookup_maps, official_cna_list):
         """Test handling of empty name."""
+        from rebuild_data_quality import map_cve_name_to_official
+
         short_map, org_map, all_names, norm_map = lookup_maps
-        
-        result, match_type, confidence = map_cve_name_to_official(
-            "", short_map, org_map, norm_map, official_cna_list
-        )
-        
+
+        result, match_type, confidence = map_cve_name_to_official("", short_map, org_map, norm_map, official_cna_list)
+
         assert result is None
         assert match_type is None
 
 
 class TestBuildLookups:
     """Test the lookup map building function."""
-    
+
     def test_build_lookups_creates_all_maps(self):
         """Verify all lookup maps are created."""
-        cna_list = [
-            {"shortName": "test", "organizationName": "Test Corp", "cnaID": "CNA-TEST"}
-        ]
-        
+        from rebuild_data_quality import build_official_cna_lookups
+
+        cna_list = [{"shortName": "test", "organizationName": "Test Corp", "cnaID": "CNA-TEST"}]
+
         short_map, org_map, all_names, norm_map = build_official_cna_lookups(cna_list)
-        
+
         assert "test" in short_map
         assert "Test Corp" in org_map
         assert "test" in all_names
         assert "testcorp" in norm_map  # normalized org name
-    
+
     def test_build_lookups_handles_missing_fields(self):
         """Verify handling of CNAs with missing fields."""
+        from rebuild_data_quality import build_official_cna_lookups
+
         cna_list = [
             {"shortName": "test1"},  # Missing organizationName
             {"organizationName": "Test Corp 2"},  # Missing shortName
             {"shortName": "", "organizationName": ""},  # Empty fields
         ]
-        
+
         # Should not raise
         short_map, org_map, all_names, norm_map = build_official_cna_lookups(cna_list)
-        
+
         assert "test1" in short_map
         assert "Test Corp 2" in org_map
diff --git a/tests/test_feed_sanity.py b/tests/test_feed_sanity.py
new file mode 100644
index 00000000000..0615a0e2f69
--- /dev/null
+++ b/tests/test_feed_sanity.py
@@ -0,0 +1,172 @@
+"""The small feeds must not be able to poison the cache with a bad download.
+
+EPSS and KEV both answer 200 with a body, so `raise_for_status()` cannot tell a
+good response from a truncated or empty one. The EPSS endpoint in particular
+redirects to a dated filename, so a client that does not follow redirects gets
+200 and zero bytes.
+
+Both downloads used to be written straight over the cache, which meant a bad
+response destroyed the last good copy and showed up later as a quietly
+shrinking coverage figure rather than an error. These tests hold the line.
+"""
+
+from __future__ import annotations
+
+import gzip
+import json
+from unittest.mock import MagicMock, patch
+
+import pytest
+from download_cve_data import (
+    MIN_EPSS_ROWS,
+    CVEDataDownloader,
+)
+
+
+@pytest.fixture
+def dl(tmp_path):
+    return CVEDataDownloader(cache_dir=tmp_path, quiet=True)
+
+
+def write_epss(path, rows: int) -> None:
+    """A gzipped EPSS CSV with `rows` data rows.
+
+    Scores and percentiles are varied because identical rows compress far better
+    than the real feed does, which would put a legitimately sized file under the
+    byte floor and test the wrong thing.
+    """
+    import random
+
+    rng = random.Random(1234)
+    with gzip.open(path, "wt", encoding="utf-8") as f:
+        f.write("#model_version:v2025.03.14\n")
+        f.write("cve,epss,percentile\n")
+        for i in range(rows):
+            f.write(f"CVE-2026-{i:05d},{rng.random():.5f},{rng.random():.5f}\n")
+
+
+def write_kev(path, entries: int, declared: int | None = None) -> None:
+    catalog = {
+        "catalogVersion": "2026.09.18",
+        "count": entries if declared is None else declared,
+        "vulnerabilities": [{"cveID": f"CVE-2026-{i:05d}"} for i in range(entries)],
+    }
+    # pad so the size floor is not what rejects it
+    catalog["_pad"] = "x" * 300_000
+    path.write_text(json.dumps(catalog))
+
+
+class TestEpssDownloadGuard:
+    def test_empty_response_is_rejected(self, dl):
+        """The real failure: a 200 with no body, from an unfollowed redirect."""
+        tmp = dl.cache_dir / "probe.csv.gz"
+        tmp.write_bytes(b"")
+        problem = dl._epss_download_problem(tmp)
+        assert problem and "bytes" in problem
+
+    def test_truncated_response_is_rejected(self, dl):
+        tmp = dl.cache_dir / "probe.csv.gz"
+        write_epss(tmp, 50)
+        assert dl._epss_download_problem(tmp), "a 50-row EPSS file should not pass"
+
+    def test_non_gzip_body_is_rejected(self, dl):
+        tmp = dl.cache_dir / "probe.csv.gz"
+        tmp.write_bytes(b"<html>404 Not Found</html>" * 40_000)
+        problem = dl._epss_download_problem(tmp)
+        assert problem and "gzip" in problem.lower()
+
+    def test_healthy_feed_is_accepted(self, dl):
+        tmp = dl.cache_dir / "probe.csv.gz"
+        write_epss(tmp, MIN_EPSS_ROWS + 5_000)
+        assert dl._epss_download_problem(tmp) is None
+
+    def test_collapse_against_previous_parse_is_rejected(self, dl):
+        """Passes the absolute floor, but is a fraction of what we had."""
+        dl.epss_parsed_file.write_text(json.dumps({f"CVE-{i}": {} for i in range(400_000)}))
+        tmp = dl.cache_dir / "probe.csv.gz"
+        write_epss(tmp, MIN_EPSS_ROWS + 1_000)
+        problem = dl._epss_download_problem(tmp)
+        assert problem and "previously" in problem
+
+    def test_a_rejected_download_leaves_the_cache_alone(self, dl):
+        """The point of the guard: keep the last good copy."""
+        dl.epss_cache_file.write_bytes(b"known good payload")
+        before = dl.epss_cache_file.read_bytes()
+        tmp = dl.cache_dir / "probe.csv.gz"
+        tmp.write_bytes(b"")
+        assert dl._epss_download_problem(tmp)
+        assert dl.epss_cache_file.read_bytes() == before
+
+
+class TestKevDownloadGuard:
+    def test_empty_response_is_rejected(self, dl):
+        tmp = dl.cache_dir / "probe.json"
+        tmp.write_text("")
+        problem = dl._kev_download_problem(tmp)
+        assert problem and "bytes" in problem
+
+    def test_declared_count_must_match_the_array(self, dl):
+        """A partial body can still be valid JSON; the catalog states its length."""
+        tmp = dl.cache_dir / "probe.json"
+        write_kev(tmp, entries=900, declared=1716)
+        problem = dl._kev_download_problem(tmp)
+        assert problem and "declares" in problem
+
+    def test_healthy_catalog_is_accepted(self, dl):
+        tmp = dl.cache_dir / "probe.json"
+        write_kev(tmp, entries=1716)
+        assert dl._kev_download_problem(tmp) is None
+
+    def test_collapse_against_previous_parse_is_rejected(self, dl):
+        dl.kev_parsed_file.write_text(json.dumps({f"CVE-{i}": True for i in range(1700)}))
+        tmp = dl.cache_dir / "probe.json"
+        write_kev(tmp, entries=600)
+        problem = dl._kev_download_problem(tmp)
+        assert problem and "previously" in problem
+
+
+class TestParsedEntryCount:
+    def test_missing_file_reports_zero_rather_than_raising(self, dl):
+        assert dl._parsed_entry_count(dl.cache_dir / "absent.json") == 0
+
+    def test_corrupt_file_reports_zero_rather_than_raising(self, dl):
+        bad = dl.cache_dir / "bad.json"
+        bad.write_text("{not json")
+        assert dl._parsed_entry_count(bad) == 0
+
+
+class TestDownloadPathEndToEnd:
+    """The guard has to hold through download_epss_data(), not just the checker."""
+
+    def test_empty_body_does_not_destroy_a_good_cache(self, dl):
+        """Reproduces the real incident: 200 OK, zero bytes, from an unfollowed redirect."""
+        write_epss(dl.epss_cache_file, MIN_EPSS_ROWS + 1_000)
+        good = dl.epss_cache_file.read_bytes()
+
+        response = MagicMock()
+        response.raise_for_status.return_value = None
+        response.iter_content.return_value = iter([])  # 200, empty body
+
+        with patch("download_cve_data.requests.get", return_value=response):
+            result = dl.download_epss_data(force=True)
+
+        assert result == dl.epss_cache_file
+        assert dl.epss_cache_file.read_bytes() == good, "a bad download overwrote the cache"
+        assert not list(dl.cache_dir.glob("*.part")), "temp file left behind"
+
+    def test_healthy_body_replaces_the_cache(self, dl):
+        dl.epss_cache_file.write_bytes(b"stale")
+        fresh = dl.cache_dir / "fresh.csv.gz"
+        write_epss(fresh, MIN_EPSS_ROWS + 1_000)
+        payload = fresh.read_bytes()
+
+        response = MagicMock()
+        response.raise_for_status.return_value = None
+        response.iter_content.return_value = iter([payload])
+
+        with patch("download_cve_data.requests.get", return_value=response):
+            result = dl.download_epss_data(force=True)
+
+        assert result == dl.epss_cache_file
+        assert dl.epss_cache_file.read_bytes() == payload
+        assert not list(dl.cache_dir.glob("*.part"))
diff --git a/tests/test_integration.py b/tests/test_integration.py
new file mode 100644
index 00000000000..d62fcd2ba8b
--- /dev/null
+++ b/tests/test_integration.py
@@ -0,0 +1,388 @@
+"""Integration tests for CVEDB build system.
+
+These tests verify the complete build pipeline works correctly,
+including edge cases, error handling, and CLI functionality.
+"""
+
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+
+# Mark all tests in this file as integration tests
+pytestmark = pytest.mark.integration
+
+
+def strip_ansi(text: str) -> str:
+    """Remove ANSI escape codes from text."""
+    ansi_pattern = re.compile(r"\x1b\[[0-9;]*m")
+    return ansi_pattern.sub("", text)
+
+
+class TestCLIIntegration:
+    """Tests for the Typer CLI interface."""
+
+    def test_cli_help(self):
+        """Test that CLI --help works."""
+        result = subprocess.run(
+            [sys.executable, "build.py", "--help"],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent,
+        )
+        assert result.returncode == 0
+        assert "CVEDB Static Site Generator" in result.stdout
+        assert "build" in result.stdout
+        assert "refresh" in result.stdout
+        assert "validate" in result.stdout
+        assert "info" in result.stdout
+
+    def test_cli_build_help(self):
+        """Test that build subcommand --help works."""
+        result = subprocess.run(
+            [sys.executable, "build.py", "build", "--help"],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent,
+        )
+        assert result.returncode == 0
+        # Strip ANSI codes from Rich/Typer output before checking
+        output = strip_ansi(result.stdout)
+        assert "--quiet" in output
+        assert "--refresh-data" in output
+        assert "--validate" in output
+
+    def test_cli_info(self):
+        """Test the info command shows expected output."""
+        result = subprocess.run(
+            [sys.executable, "build.py", "info"],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent,
+        )
+        assert result.returncode == 0
+        assert "Current Year:" in result.stdout
+        assert "Year Coverage:" in result.stdout
+        assert "Web Output:" in result.stdout
+
+    def test_cli_validate_quiet(self):
+        """Test validate command with quiet flag."""
+        result = subprocess.run(
+            [sys.executable, "build.py", "validate", "--quiet"],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent,
+        )
+        # Should complete (may pass or fail depending on data state)
+        assert result.returncode in [0, 1]
+
+    def test_cli_backward_compatibility(self):
+        """Test that running without subcommand still works (backward compat)."""
+        result = subprocess.run(
+            [sys.executable, "build.py", "--help"],
+            capture_output=True,
+            text=True,
+            cwd=Path(__file__).parent.parent,
+        )
+        assert result.returncode == 0
+        # Strip ANSI codes from Rich/Typer output before checking
+        output = strip_ansi(result.stdout)
+        # Should show options that work without subcommand
+        assert "--quiet" in output
+
+
+class TestBuildPipelineIntegration:
+    """Tests for the complete build pipeline."""
+
+    @pytest.fixture
+    def project_root(self):
+        """Get the project root directory."""
+        return Path(__file__).parent.parent
+
+    def test_web_data_directory_structure(self, project_root):
+        """Test that web/data directory has expected structure."""
+        data_dir = project_root / "web" / "data"
+        if not data_dir.exists():
+            pytest.skip("No built data available")
+
+        # Check for core files
+        expected_files = [
+            "cve_all.json",
+            "cna_analysis.json",
+            "calendar_analysis.json",
+        ]
+
+        for filename in expected_files:
+            filepath = data_dir / filename
+            if filepath.exists():
+                # Verify it's valid JSON
+                with open(filepath) as f:
+                    data = json.load(f)
+                assert isinstance(data, dict)
+
+    def test_year_files_consistency(self, project_root):
+        """Test that year files have consistent structure."""
+        data_dir = project_root / "web" / "data"
+        if not data_dir.exists():
+            pytest.skip("No built data available")
+
+        year_files = list(data_dir.glob("cve_*.json"))
+        year_files = [f for f in year_files if f.stem.startswith("cve_") and f.stem[4:].isdigit()]
+
+        if not year_files:
+            pytest.skip("No year files available")
+
+        for year_file in year_files[:5]:  # Check first 5
+            with open(year_file) as f:
+                data = json.load(f)
+
+            # All year files should have these keys
+            assert "total_cves" in data
+            assert "year" in data
+            assert isinstance(data["total_cves"], int)
+            assert data["total_cves"] >= 0
+
+    def test_cve_all_has_required_fields(self, project_root):
+        """Test that cve_all.json has all required fields."""
+        cve_all_path = project_root / "web" / "data" / "cve_all.json"
+        if not cve_all_path.exists():
+            pytest.skip("cve_all.json not available")
+
+        with open(cve_all_path) as f:
+            data = json.load(f)
+
+        required_fields = ["total_cves", "yearly_trend"]
+        for field in required_fields:
+            assert field in data, f"Missing required field: {field}"
+
+        # Yearly trend should be a list
+        assert isinstance(data["yearly_trend"], list)
+
+        # Each trend entry should have year and count
+        if data["yearly_trend"]:
+            entry = data["yearly_trend"][0]
+            assert "year" in entry
+            assert "count" in entry
+
+    def test_cna_analysis_structure(self, project_root):
+        """Test that CNA analysis has expected structure."""
+        cna_path = project_root / "web" / "data" / "cna_analysis.json"
+        if not cna_path.exists():
+            pytest.skip("cna_analysis.json not available")
+
+        with open(cna_path) as f:
+            data = json.load(f)
+
+        # Should have repository stats
+        assert "repository_stats" in data
+        assert "total_cves" in data["repository_stats"]
+
+        # Should have CNA list
+        assert "cna_list" in data
+        assert isinstance(data["cna_list"], list)
+
+
+class TestEdgeCases:
+    """Tests for edge cases and error handling."""
+
+    def test_builder_quiet_mode(self):
+        """Test that quiet mode is properly set."""
+        from build import CVESiteBuilder
+
+        builder = CVESiteBuilder(quiet=True)
+        assert builder.quiet is True
+
+        builder = CVESiteBuilder(quiet=False)
+        assert builder.quiet is False
+
+    def test_builder_year_range_valid(self):
+        """Test that builder has valid year range."""
+        from build import CVESiteBuilder
+
+        builder = CVESiteBuilder(quiet=True)
+
+        # Should have years from 1999 to current year
+        assert 1999 in builder.available_years
+        assert builder.current_year >= 2024
+        assert builder.current_year in builder.available_years
+
+    def test_builder_paths_are_valid(self):
+        """Test that builder paths are properly configured."""
+        from build import CVESiteBuilder
+
+        builder = CVESiteBuilder(quiet=True)
+
+        # All paths should be Path objects
+        assert isinstance(builder.web_dir, Path)
+        assert isinstance(builder.data_dir, Path)
+        assert isinstance(builder.templates_dir, Path)
+        assert isinstance(builder.cache_dir, Path)
+
+        # Templates directory should exist
+        assert builder.templates_dir.exists()
+
+
+class TestDataValidation:
+    """Tests for data validation functionality."""
+
+    def test_validate_data_counts_function_exists(self):
+        """Test that validate_data_counts function is available."""
+        from build import validate_data_counts
+
+        assert callable(validate_data_counts)
+
+    def test_validation_with_mock_builder(self):
+        """Test validation with a mock builder."""
+
+        from build import CVESiteBuilder, validate_data_counts
+
+        # Create a mock builder with temp directory
+        builder = CVESiteBuilder(quiet=True)
+
+        # If data directory exists and has files, validation should run
+        if builder.data_dir.exists() and (builder.data_dir / "cve_all.json").exists():
+            result = validate_data_counts(builder)
+            # Result should be boolean
+            assert isinstance(result, bool)
+
+
+class TestCnaVsCveAllReconciliation:
+    """Tests for reconcile_cna_vs_year_totals().
+
+    Regression cover for the 2026-08-25 deploy failure: the old check compared
+    abs(CNA - cve_all) against a flat 1,000, so the permanent 679-record pre-1999
+    offset consumed most of the budget and a normal busy publication day
+    (diff 1,196) failed the build.
+    """
+
+    def test_real_2026_08_25_numbers_now_pass(self):
+        """The exact totals that broke the deploy should reconcile cleanly."""
+        from build import reconcile_cna_vs_year_totals
+
+        # diff was 1,196 = 679 pre-1999 + 517 NVD ingestion lag
+        result = reconcile_cna_vs_year_totals(repo_total=364_000, cve_all_total=362_804, excluded_pre_1999=679)
+
+        assert result.ok
+        assert result.lag == 517
+
+    def test_pre_1999_offset_does_not_consume_lag_budget(self):
+        """Growing the pre-1999 offset must not shrink the room for lag."""
+        from build import MAX_INGESTION_LAG, reconcile_cna_vs_year_totals
+
+        small = reconcile_cna_vs_year_totals(300_000 + MAX_INGESTION_LAG, 300_000, 0)
+        large = reconcile_cna_vs_year_totals(300_000 + MAX_INGESTION_LAG + 5_000, 300_000, 5_000)
+
+        assert small.ok and large.ok
+        assert small.lag == large.lag == MAX_INGESTION_LAG
+
+    def test_heavy_publication_day_passes(self):
+        """An Oracle-CPU-sized day of un-ingested CVEs is normal, not a failure."""
+        from build import reconcile_cna_vs_year_totals
+
+        # 2026-07-21 published 1,474 CVEs; NVD trailing a full such day is fine.
+        result = reconcile_cna_vs_year_totals(364_000 + 1_474, 364_000, excluded_pre_1999=0)
+        assert result.ok
+
+    def test_stalled_nvd_feed_fails(self):
+        """Lag beyond two heavy publication days means NVD has stopped ingesting."""
+        from build import MAX_INGESTION_LAG, reconcile_cna_vs_year_totals
+
+        result = reconcile_cna_vs_year_totals(364_000 + MAX_INGESTION_LAG + 1, 364_000, excluded_pre_1999=0)
+
+        assert not result.ok
+        assert "ingestion lag" in result.message
+
+    def test_nvd_leading_v5_fails(self):
+        """NVD ahead of cvelistV5 is impossible; the old abs() check was blind to it."""
+        from build import reconcile_cna_vs_year_totals
+
+        result = reconcile_cna_vs_year_totals(repo_total=360_000, cve_all_total=365_000, excluded_pre_1999=679)
+
+        assert not result.ok
+        assert "should never be ahead" in result.message
+
+    def test_missing_offset_uses_documented_fallback(self):
+        """A cve_all.json predating the field still reconciles via the constant."""
+        from build import PRE_1999_FALLBACK, reconcile_cna_vs_year_totals
+
+        result = reconcile_cna_vs_year_totals(364_000, 364_000 - PRE_1999_FALLBACK)
+
+        assert result.ok
+        assert result.pre_1999 == PRE_1999_FALLBACK
+        assert result.lag == 0
+
+
+class TestHistoricalYearCoverageGuard:
+    """Tests for the truncated-feed guardrail (verify_historical_year_coverage)."""
+
+    def _year_data(self, years):
+        """Build a minimal all_year_data list from a {year: total_cves} mapping."""
+        return [{"year": y, "total_cves": c} for y, c in years.items()]
+
+    def test_passes_when_all_historical_years_present(self):
+        """A complete set of non-empty historical years should not raise."""
+        from build import CVESiteBuilder
+
+        builder = CVESiteBuilder(quiet=True)
+        data = self._year_data(dict.fromkeys(range(1999, builder.current_year + 1), 1000))
+
+        # Should not raise
+        builder.verify_historical_year_coverage(data)
+
+    def test_raises_when_historical_year_missing(self):
+        """A missing historical year (the 1999 outage) must abort the build."""
+        from build import CVESiteBuilder
+
+        builder = CVESiteBuilder(quiet=True)
+        # Drop 1999 entirely, mimicking the truncated feed on 2026-07-08.
+        data = self._year_data(dict.fromkeys(range(2000, builder.current_year + 1), 1000))
+
+        with pytest.raises(RuntimeError, match="1999"):
+            builder.verify_historical_year_coverage(data)
+
+    def test_raises_when_historical_year_zero(self):
+        """A historical year present but with zero CVEs must abort the build."""
+        from build import CVESiteBuilder
+
+        builder = CVESiteBuilder(quiet=True)
+        years = dict.fromkeys(range(1999, builder.current_year + 1), 1000)
+        years[1999] = 0
+        data = self._year_data(years)
+
+        with pytest.raises(RuntimeError, match="1999"):
+            builder.verify_historical_year_coverage(data)
+
+    def test_allows_empty_current_year(self):
+        """The still-accumulating current year is exempt from the guard."""
+        from build import CVESiteBuilder
+
+        builder = CVESiteBuilder(quiet=True)
+        years = dict.fromkeys(range(1999, builder.current_year), 1000)
+        years[builder.current_year] = 0
+        data = self._year_data(years)
+
+        # Should not raise — current year is allowed to be empty.
+        builder.verify_historical_year_coverage(data)
+
+
+class TestAsyncFunctionality:
+    """Tests for async functionality (requires pytest-asyncio)."""
+
+    @pytest.mark.asyncio
+    async def test_async_http_session_concept(self):
+        """Test that httpx is available and can create async clients."""
+        # httpx is an optional dependency: the downloader falls back to a
+        # sequential requests-based path without it. Skip rather than fail so a
+        # clean checkout is green.
+        httpx = pytest.importorskip("httpx")
+
+        # Basic smoke test - module should be importable
+        assert httpx is not None
+
+        # Test that we can reference async client types
+        assert hasattr(httpx, "AsyncClient")
+        assert hasattr(httpx, "Response")
diff --git a/tests/test_number_invariants.py b/tests/test_number_invariants.py
new file mode 100644
index 00000000000..ef4a3295f15
--- /dev/null
+++ b/tests/test_number_invariants.py
@@ -0,0 +1,198 @@
+"""Invariants for every number the site displays.
+
+These encode an audit of the figures shown across the 14 pages. Each check is a
+relationship that must hold for the site to be internally honest: a subset must
+not exceed its superset, a breakdown must sum to its total, and the same
+quantity must not differ between two pages.
+
+Where two figures legitimately disagree - because they come from different
+sources or count different things - the tolerance is stated and explained
+rather than left implicit. A failure here means either a real regression or a
+change in what a number means; both need a human decision.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+
+DATA = Path(__file__).parent.parent / "web" / "data"
+
+
+def load(name: str):
+    path = DATA / name
+    if not path.exists():
+        pytest.skip(f"{name} not built")
+    return json.loads(path.read_text())
+
+
+@pytest.fixture(scope="module")
+def d() -> dict:
+    names = [
+        "yearly_summary",
+        "homepage_summary",
+        "cvss_analysis",
+        "epss_analysis",
+        "kev_analysis",
+        "cwe_analysis",
+        "cpe_analysis",
+        "cna_analysis",
+        "growth_analysis",
+        "data_quality",
+        "scoring_comparison",
+    ]
+    return {n: load(f"{n}.json") for n in names}
+
+
+@pytest.fixture(scope="module")
+def site_total(d) -> int:
+    """The site's own CVE count: what every other figure is judged against."""
+    return sum(y["total_cves"] for y in d["yearly_summary"]["years"].values())
+
+
+class TestSubsets:
+    """A count of CVEs with some property cannot exceed the number of CVEs."""
+
+    @pytest.mark.parametrize(
+        "label,path",
+        [
+            ("CWE classified", ("cwe_analysis", "total_cves_with_cwe")),
+            ("CPE with product data", ("cpe_analysis", "total_cves_with_cpes")),
+            ("KEV", ("kev_analysis", "total_kev_cves")),
+            ("EPSS matched", ("epss_analysis", "total_cves_with_epss_matched")),
+        ],
+    )
+    def test_subset_never_exceeds_site_total(self, d, site_total, label, path):
+        value = d[path[0]].get(path[1])
+        if value is None:
+            pytest.skip(f"{label} not present")
+        assert value <= site_total, (
+            f"{label} ({value:,}) exceeds the site's own CVE total ({site_total:,}). "
+            "Either it counts a different population, or a denominator is wrong."
+        )
+
+    def test_cvss_scores_are_not_a_subset(self, d, site_total):
+        """CVSS is the documented exception: it counts scores, not CVEs.
+
+        A CVE can hold a score under several metric versions, so this figure
+        exceeding the total is expected - the pages label it accordingly.
+        """
+        assert d["cvss_analysis"]["total_cves_with_cvss"] > site_total
+
+
+class TestBreakdownsSumToTotals:
+    def test_cvss_versions_sum_to_total(self, d):
+        c = d["cvss_analysis"]
+        assert sum(c["total_by_version"].values()) == c["total_cves_with_cvss"]
+
+    @pytest.mark.parametrize("version", ["v2.0", "v3.0", "v3.1", "v4.0"])
+    def test_cvss_severity_bands_sum_to_version_total(self, d, version):
+        c = d["cvss_analysis"]
+        if version not in c["total_by_version"]:
+            pytest.skip(f"{version} absent")
+        assert sum(c["severity_distribution"][version].values()) == c["total_by_version"][version]
+
+    @pytest.mark.parametrize("grouping", ["by_year_added", "by_year_published", "timeline"])
+    def test_kev_groupings_sum_to_catalog_total(self, d, grouping):
+        k = d["kev_analysis"]
+        assert sum(k[grouping].values()) == k["total_kev_cves"], (
+            f"KEV {grouping} does not account for every catalog entry"
+        )
+
+    def test_epss_score_buckets_sum_to_row_count(self, d):
+        e = d["epss_analysis"]
+        assert sum(e["score_buckets"].values()) == e["total_cves_with_epss"]
+
+    def test_data_quality_buckets_account_for_every_publisher(self, d):
+        s = d["data_quality"]["stats"]
+        soft = s["case_mismatches"] + s["org_name_matches"] + s["normalized_matches"] + s["partial_matches"]
+        assert s["exact_matches"] + soft + s["unmatched"] == s["total_cnas_in_analysis"]
+
+    def test_cna_active_plus_inactive_equals_total(self, d):
+        c = d["cna_analysis"]
+        assert c["active_cnas"] + c["inactive_cnas"] == c["total_cnas"]
+
+
+class TestCrossPageAgreement:
+    """The same quantity must not differ depending on which page you open."""
+
+    def test_kev_total_agrees_across_sources(self, d):
+        assert d["kev_analysis"]["total_kev_cves"] == d["cvss_analysis"]["kev_global_count"]
+
+    def test_scoring_comparison_matches_its_sources(self, d):
+        sysd = d["scoring_comparison"]["systems"]
+        assert sysd["cvss"]["total_scored"] == d["cvss_analysis"]["total_cves_with_cvss"]
+        assert sysd["kev"]["total_scored"] == d["kev_analysis"]["total_kev_cves"]
+
+    def test_per_year_kev_agrees_between_sources(self, d):
+        years = d["yearly_summary"]["years"]
+        published = d["kev_analysis"]["by_year_published"]
+        for year, data in years.items():
+            recorded = (data.get("kev") or {}).get("kev_count")
+            if recorded is None:
+                continue
+            assert recorded == published.get(year, 0), f"{year} KEV count differs between sources"
+
+    def test_growth_counts_match_yearly_summary(self, d):
+        years = d["yearly_summary"]["years"]
+        for row in d["growth_analysis"]["growth_data"]:
+            assert row["cves"] == years[str(row["year"])]["total_cves"], (
+                f"{row['year']} differs between growth_analysis and yearly_summary"
+            )
+
+
+class TestEpssPublicationBucketing:
+    """EPSS is bucketed by publication date so it is comparable with the totals.
+
+    These apply only to data produced by the current pipeline. The repository
+    also carries committed output from earlier builds, which bucketed EPSS by
+    CVE ID year and would legitimately fail here - that is the defect this
+    change fixed, not a regression to catch. `total_cves_with_epss_matched` is
+    only emitted by the fixed analyzer, so its presence marks data the
+    invariants apply to. After the first build on the new pipeline the skip
+    stops firing.
+    """
+
+    @pytest.fixture(autouse=True)
+    def _requires_current_pipeline(self, d):
+        if "total_cves_with_epss_matched" not in d["epss_analysis"]:
+            pytest.skip("epss_analysis.json predates publication-date bucketing")
+
+    def test_coverage_never_exceeds_its_own_denominator(self, d):
+        over = [y for y, v in d["epss_analysis"]["year_coverage"].items() if v["with_epss"] > v["total"]]
+        assert not over, f"more CVEs have EPSS scores than exist, in: {over}"
+
+    def test_coverage_denominators_sum_to_site_total(self, d, site_total):
+        cov = d["epss_analysis"]["year_coverage"]
+        assert sum(v["total"] for v in cov.values()) == site_total
+
+    def test_matched_plus_unmatched_equals_raw(self, d):
+        e = d["epss_analysis"]
+        assert e["total_cves_with_epss_matched"] + e["epss_without_published_record"] == (e["total_cves_with_epss"])
+
+    def test_thresholds_are_monotonic(self, d):
+        s = d["epss_analysis"]["statistics"]
+        assert s["gt_0_1"] >= s["gt_0_3"] >= s["gt_0_5"] >= s["gt_0_7"] >= s["gt_0_9"]
+
+
+class TestKnownSourceDisagreement:
+    """The CNA pipeline reads cvelistV5 while the yearly totals read NVD.
+
+    They will not agree exactly. The site says so on the Publishers page, and
+    source_reconciliation.json measures it. This bounds the gap so a real
+    regression is not mistaken for the usual drift.
+    """
+
+    MAX_ALLTIME_GAP = 5000
+
+    def test_cna_attribution_gap_stays_bounded(self, d, site_total):
+        attributed = sum(c["count"] for c in d["cna_analysis"]["cna_list"])
+        gap = attributed - site_total
+        assert abs(gap) <= self.MAX_ALLTIME_GAP, (
+            f"CNA attribution ({attributed:,}) differs from the site total "
+            f"({site_total:,}) by {gap:+,}, beyond the tolerated drift. "
+            "See docs/COUNTING.md and source_reconciliation.json."
+        )
diff --git a/tests/test_protocols.py b/tests/test_protocols.py
new file mode 100644
index 00000000000..8c0d08ca426
--- /dev/null
+++ b/tests/test_protocols.py
@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+"""
+Tests for protocol implementations and test fakes.
+
+Validates that:
+1. Default implementations conform to protocols
+2. Test fakes provide expected behavior
+3. Protocol-based code can use either implementation
+"""
+
+from __future__ import annotations
+
+# Import protocols
+import sys
+from pathlib import Path
+
+import pytest
+
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "data"))
+
+from protocols import (
+    CacheManager,
+    DataReader,
+    DataWriter,
+    FileSystemDataReader,
+    FileSystemDataWriter,
+    HttpClient,
+)
+
+# Import fakes from tests directory
+from tests.fakes import (
+    FakeCacheManager,
+    FakeDataReader,
+    FakeDataWriter,
+    FakeHttpClient,
+    FakeHttpError,
+)
+
+
+class TestFakeHttpClient:
+    """Tests for FakeHttpClient test double."""
+
+    def test_returns_configured_response(self):
+        """Fake client returns configured response for URL."""
+        client = FakeHttpClient()
+        client.add_response("https://example.com/api", json_data={"status": "ok"})
+
+        response = client.get("https://example.com/api")
+
+        assert response.status_code == 200
+        assert response.json() == {"status": "ok"}
+
+    def test_returns_404_for_unknown_url(self):
+        """Fake client returns 404 for unconfigured URLs."""
+        client = FakeHttpClient()
+
+        response = client.get("https://unknown.com")
+
+        assert response.status_code == 404
+
+    def test_tracks_request_history(self):
+        """Fake client tracks all requests made."""
+        client = FakeHttpClient()
+        client.set_default_response(json_data={})
+
+        client.get("https://example.com/a")
+        client.get("https://example.com/b", timeout=30)
+
+        assert client.request_count == 2
+        assert client.request_history[0]["url"] == "https://example.com/a"
+        assert client.request_history[1]["timeout"] == 30
+
+    def test_raise_for_status_on_error(self):
+        """Fake response raises on error status codes."""
+        client = FakeHttpClient()
+        client.add_response("https://example.com/error", status_code=500)
+
+        response = client.get("https://example.com/error")
+
+        with pytest.raises(FakeHttpError):
+            response.raise_for_status()
+
+    def test_iter_content_yields_chunks(self):
+        """Fake response yields content in chunks."""
+        client = FakeHttpClient()
+        client.add_response("https://example.com/data", content=b"Hello World")
+
+        response = client.get("https://example.com/data")
+        chunks = list(response.iter_content(chunk_size=5))
+
+        assert chunks == [b"Hello", b" Worl", b"d"]
+
+
+class TestFakeDataReader:
+    """Tests for FakeDataReader test double."""
+
+    def test_reads_json_file(self):
+        """Fake reader returns configured JSON data."""
+        reader = FakeDataReader()
+        reader.add_json(Path("/data/config.json"), {"debug": True})
+
+        data = reader.read_json(Path("/data/config.json"))
+
+        assert data == {"debug": True}
+
+    def test_reads_text_file(self):
+        """Fake reader returns configured text content."""
+        reader = FakeDataReader()
+        reader.add_file(Path("/data/readme.txt"), "Hello World")
+
+        content = reader.read_text(Path("/data/readme.txt"))
+
+        assert content == "Hello World"
+
+    def test_reads_binary_file(self):
+        """Fake reader returns configured binary content."""
+        reader = FakeDataReader()
+        reader.add_file(Path("/data/image.png"), b"\x89PNG")
+
+        content = reader.read_bytes(Path("/data/image.png"))
+
+        assert content == b"\x89PNG"
+
+    def test_exists_returns_true_for_added_files(self):
+        """Fake reader reports existence correctly."""
+        reader = FakeDataReader()
+        reader.add_file(Path("/exists.txt"), "content")
+
+        assert reader.exists(Path("/exists.txt")) is True
+        assert reader.exists(Path("/missing.txt")) is False
+
+    def test_raises_on_missing_file(self):
+        """Fake reader raises FileNotFoundError for missing files."""
+        reader = FakeDataReader()
+
+        with pytest.raises(FileNotFoundError):
+            reader.read_json(Path("/missing.json"))
+
+    def test_list_dir_returns_children(self):
+        """Fake reader lists directory contents."""
+        reader = FakeDataReader()
+        reader.add_directory(Path("/data"), ["a.json", "b.json", "c.txt"])
+
+        contents = reader.list_dir(Path("/data"))
+        names = [p.name for p in contents]
+
+        assert sorted(names) == ["a.json", "b.json", "c.txt"]
+
+
+class TestFakeDataWriter:
+    """Tests for FakeDataWriter test double."""
+
+    def test_captures_json_writes(self):
+        """Fake writer captures JSON writes for assertions."""
+        writer = FakeDataWriter()
+
+        writer.write_json(Path("/output.json"), {"result": 42})
+
+        assert writer.get_json(Path("/output.json")) == {"result": 42}
+        assert writer.was_written(Path("/output.json")) is True
+
+    def test_captures_text_writes(self):
+        """Fake writer captures text writes for assertions."""
+        writer = FakeDataWriter()
+
+        writer.write_text(Path("/output.txt"), "Hello World")
+
+        assert writer.get_text(Path("/output.txt")) == "Hello World"
+
+    def test_captures_binary_writes(self):
+        """Fake writer captures binary writes for assertions."""
+        writer = FakeDataWriter()
+
+        writer.write_bytes(Path("/output.bin"), b"\x00\x01\x02")
+
+        assert writer.get_bytes(Path("/output.bin")) == b"\x00\x01\x02"
+
+    def test_tracks_directory_creation(self):
+        """Fake writer tracks directory creation."""
+        writer = FakeDataWriter()
+
+        writer.mkdir(Path("/new/dir"))
+
+        assert writer.was_directory_created(Path("/new/dir")) is True
+        assert writer.was_directory_created(Path("/other")) is False
+
+    def test_lists_written_files(self):
+        """Fake writer lists all written files."""
+        writer = FakeDataWriter()
+        writer.write_text(Path("/a.txt"), "a")
+        writer.write_text(Path("/b.txt"), "b")
+
+        assert len(writer.written_files) == 2
+
+
+class TestFakeCacheManager:
+    """Tests for FakeCacheManager test double."""
+
+    def test_stores_and_retrieves_values(self):
+        """Fake cache stores and retrieves values."""
+        cache = FakeCacheManager()
+
+        cache.set("key", {"data": "value"})
+
+        assert cache.get("key") == {"data": "value"}
+        assert cache.is_valid("key") is True
+
+    def test_returns_none_for_missing_keys(self):
+        """Fake cache returns None for missing keys."""
+        cache = FakeCacheManager()
+
+        assert cache.get("missing") is None
+        assert cache.is_valid("missing") is False
+
+    def test_invalidation_works(self):
+        """Fake cache invalidation works."""
+        cache = FakeCacheManager()
+        cache.set("key", "value")
+
+        cache.invalidate("key")
+
+        assert cache.is_valid("key") is False
+        assert cache.get("key") == "value"  # Data still there, just invalid
+
+    def test_manual_validity_control(self):
+        """Fake cache allows manual validity control for testing."""
+        cache = FakeCacheManager()
+        cache.set("key", "value")
+
+        cache.set_validity("key", False)
+
+        assert cache.is_valid("key") is False
+
+
+class TestProtocolConformance:
+    """Tests that implementations conform to protocols."""
+
+    def test_fake_http_client_is_http_client(self):
+        """FakeHttpClient conforms to HttpClient protocol."""
+        client = FakeHttpClient()
+        assert isinstance(client, HttpClient)
+
+    def test_fake_data_reader_is_data_reader(self):
+        """FakeDataReader conforms to DataReader protocol."""
+        reader = FakeDataReader()
+        assert isinstance(reader, DataReader)
+
+    def test_fake_data_writer_is_data_writer(self):
+        """FakeDataWriter conforms to DataWriter protocol."""
+        writer = FakeDataWriter()
+        assert isinstance(writer, DataWriter)
+
+    def test_fake_cache_manager_is_cache_manager(self):
+        """FakeCacheManager conforms to CacheManager protocol."""
+        cache = FakeCacheManager()
+        assert isinstance(cache, CacheManager)
+
+    def test_filesystem_reader_is_data_reader(self):
+        """FileSystemDataReader conforms to DataReader protocol."""
+        reader = FileSystemDataReader()
+        assert isinstance(reader, DataReader)
+
+    def test_filesystem_writer_is_data_writer(self):
+        """FileSystemDataWriter conforms to DataWriter protocol."""
+        writer = FileSystemDataWriter()
+        assert isinstance(writer, DataWriter)
+
+
+class TestFileSystemIntegration:
+    """Integration tests for FileSystem implementations with real files."""
+
+    def test_reader_reads_real_json(self, tmp_path):
+        """FileSystemDataReader reads actual JSON files."""
+        test_file = tmp_path / "test.json"
+        test_file.write_text('{"key": "value"}')
+
+        reader = FileSystemDataReader()
+        data = reader.read_json(test_file)
+
+        assert data == {"key": "value"}
+
+    def test_writer_writes_real_json(self, tmp_path):
+        """FileSystemDataWriter writes actual JSON files."""
+        test_file = tmp_path / "output.json"
+
+        writer = FileSystemDataWriter()
+        writer.write_json(test_file, {"result": 42})
+
+        # Verify with reader
+        reader = FileSystemDataReader()
+        assert reader.read_json(test_file) == {"result": 42}
+
+    def test_reader_exists_check(self, tmp_path):
+        """FileSystemDataReader checks file existence correctly."""
+        existing = tmp_path / "exists.txt"
+        existing.write_text("content")
+
+        reader = FileSystemDataReader()
+
+        assert reader.exists(existing) is True
+        assert reader.exists(tmp_path / "missing.txt") is False
+
+    def test_writer_creates_directories(self, tmp_path):
+        """FileSystemDataWriter creates directories."""
+        new_dir = tmp_path / "new" / "nested" / "dir"
+
+        writer = FileSystemDataWriter()
+        writer.mkdir(new_dir)
+
+        assert new_dir.exists()
+        assert new_dir.is_dir()
diff --git a/tests/test_refresh_fallback.py b/tests/test_refresh_fallback.py
new file mode 100644
index 00000000000..ec7ab20d883
--- /dev/null
+++ b/tests/test_refresh_fallback.py
@@ -0,0 +1,111 @@
+"""Tests for the data refresh path.
+
+A refresh that downloads nothing must never report success. Before the
+sequential fallback existed, a missing httpx made `build.py refresh --force`
+print a success message and exit 0 in about a second, having fetched nothing.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from build import CVESiteBuilder
+
+
+@pytest.fixture
+def builder(tmp_path):
+    b = CVESiteBuilder(quiet=True)
+    b.cache_dir = tmp_path
+    return b
+
+
+class TestAsyncUnavailableFallback:
+    def test_missing_httpx_falls_back_instead_of_claiming_success(self, builder):
+        """The regression this file exists for."""
+        with (
+            patch.object(CVESiteBuilder, "verify_source_manifest", return_value=None),
+            patch("build.AsyncCVEDownloader", side_effect=ImportError("httpx is required")),
+            patch.object(CVESiteBuilder, "refresh_data_sync", return_value=True) as fallback,
+        ):
+            assert builder.refresh_data(force=True) is True
+            fallback.assert_called_once()
+            assert fallback.call_args.kwargs["force"] is True
+
+    def test_fallback_failure_is_reported(self, builder):
+        with (
+            patch.object(CVESiteBuilder, "verify_source_manifest", return_value=None),
+            patch("build.AsyncCVEDownloader", side_effect=ImportError("httpx is required")),
+            patch.object(CVESiteBuilder, "refresh_data_sync", return_value=False),
+        ):
+            assert builder.refresh_data(force=True) is False
+
+
+class TestRefreshDataSync:
+    def _downloader(self, resolves_to=...):
+        d = MagicMock()
+        d.download_epss_data.return_value = "epss.gz"
+        d.download_kev_data.return_value = "kev.json"
+
+        # The real download_data records which snapshot the bytes turned out to
+        # be, which is a newer one when it raced a publish. refresh_data_sync
+        # persists that, not the manifest it asked for.
+        def record(force=False, manifest=None):
+            d.accepted_manifest = manifest if resolves_to is ... else resolves_to
+
+        d.download_data.side_effect = record
+        d.accepted_manifest = None
+        return d
+
+    def test_downloads_every_source(self, builder):
+        d = self._downloader()
+        with patch("download_cve_data.CVEDataDownloader", return_value=d):
+            assert builder.refresh_data_sync(force=True) is True
+
+        d.download_data.assert_called_once()
+        d.download_cna_mapping_files.assert_called_once()
+        d.download_epss_data.assert_called_once_with(force=True)
+        d.parse_epss_csv.assert_called_once()
+        d.download_kev_data.assert_called_once_with(force=True)
+        d.parse_kev_json.assert_called_once()
+
+    def test_passes_manifest_through_for_verification(self, builder):
+        d = self._downloader()
+        manifest = {"cve_count": 1, "last_run_iso": "x"}
+        with patch("download_cve_data.CVEDataDownloader", return_value=d):
+            builder.refresh_data_sync(force=False, manifest=manifest)
+
+        assert d.download_data.call_args.kwargs["manifest"] == manifest
+        d.persist_accepted_manifest.assert_called_once_with(manifest)
+
+    def test_persists_the_snapshot_actually_downloaded(self, builder):
+        """A publish landing mid-download must not be recorded as the old one."""
+        raced = {"cve_count": 2, "last_run_iso": "y"}
+        d = self._downloader(resolves_to=raced)
+        with patch("download_cve_data.CVEDataDownloader", return_value=d):
+            builder.refresh_data_sync(force=False, manifest={"cve_count": 1, "last_run_iso": "x"})
+
+        d.persist_accepted_manifest.assert_called_once_with(raced)
+
+    def test_manifest_not_persisted_when_absent(self, builder):
+        d = self._downloader()
+        with patch("download_cve_data.CVEDataDownloader", return_value=d):
+            builder.refresh_data_sync(force=False, manifest=None)
+        d.persist_accepted_manifest.assert_not_called()
+
+    def test_download_failure_returns_false(self, builder):
+        """A failed download must not be reported as a successful refresh."""
+        d = self._downloader()
+        d.download_data.side_effect = OSError("Truncated download")
+        with patch("download_cve_data.CVEDataDownloader", return_value=d):
+            assert builder.refresh_data_sync(force=True) is False
+
+    def test_skips_parsing_when_supplemental_download_fails(self, builder):
+        """EPSS and KEV are non-critical, but a failed fetch must not be parsed."""
+        d = self._downloader()
+        d.download_epss_data.return_value = None
+        with patch("download_cve_data.CVEDataDownloader", return_value=d):
+            assert builder.refresh_data_sync(force=True) is True
+        d.parse_epss_csv.assert_not_called()
+        d.parse_kev_json.assert_called_once()
diff --git a/tests/test_regression_guards.py b/tests/test_regression_guards.py
new file mode 100644
index 00000000000..1332d053196
--- /dev/null
+++ b/tests/test_regression_guards.py
@@ -0,0 +1,369 @@
+"""Tests for the build-side regression, freshness, and provenance guards.
+
+These are independent of the source-manifest checks in the downloader. The
+manifest catches a bad snapshot from the producer; these catch a regression in
+our own analysis code, which the producer cannot see.
+
+Keying note: everything here is publication-date bucketed, matching our own
+outputs. Manifest year_counts are CVE-ID keyed and are never compared to these.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime, timedelta
+from unittest.mock import patch
+
+import pytest
+
+from build import CVESiteBuilder
+
+
+def year_data(**counts: int) -> list[dict[str, int]]:
+    """Build all_year_data-shaped input from year=count pairs."""
+    return [{"year": int(y), "total_cves": c} for y, c in counts.items()]
+
+
+def published(total: int, **counts: int) -> dict:
+    return {
+        "total_cves": total,
+        "yearly_trend": [{"year": int(y), "count": c} for y, c in counts.items()],
+    }
+
+
+@pytest.fixture
+def builder(tmp_path):
+    """A builder in strict mode, i.e. how it behaves in CI.
+
+    Strict is set explicitly rather than inherited from the environment so the
+    suite behaves identically whether or not CI is set in the shell running it.
+    """
+    b = CVESiteBuilder(quiet=True)
+    b.cache_dir = tmp_path
+    b.current_year = 2026
+    b.accept_baseline = False
+    b.strict_data_guards = True
+    return b
+
+
+@pytest.fixture
+def lenient_builder(builder):
+    """A builder outside CI, where guards warn instead of aborting."""
+    builder.strict_data_guards = False
+    return builder
+
+
+class TestVerifyNoRegression:
+    def test_accepts_growth(self, builder):
+        with patch.object(
+            CVESiteBuilder, "fetch_published_totals", return_value=published(1000, **{"2025": 600, "2026": 400})
+        ):
+            builder.verify_no_regression(year_data(**{"2025": 600, "2026": 450}))
+
+    def test_accepts_small_decrease_within_allowance(self, builder):
+        """Genuine CVE withdrawals are a handful of records and must not fail."""
+        with patch.object(
+            CVESiteBuilder, "fetch_published_totals", return_value=published(1000, **{"2025": 600, "2026": 400})
+        ):
+            builder.verify_no_regression(year_data(**{"2025": 595, "2026": 400}))
+
+    def test_rejects_total_regression_beyond_allowance(self, builder):
+        with patch.object(
+            CVESiteBuilder, "fetch_published_totals", return_value=published(359880, **{"2025": 48154, "2026": 51675})
+        ):
+            with pytest.raises(RuntimeError, match="total"):
+                builder.verify_no_regression(year_data(**{"2025": 48154, "2026": 51375}))
+
+    def test_rejects_closed_year_regression(self, builder):
+        """The 2026-06-29 shape: year 2024 lost 5,254 CVEs and got them back."""
+        with patch.object(
+            CVESiteBuilder, "fetch_published_totals", return_value=published(100000, **{"2024": 39959, "2026": 60041})
+        ):
+            with pytest.raises(RuntimeError, match="year 2024"):
+                builder.verify_no_regression(year_data(**{"2024": 34705, "2026": 70000}))
+
+    def test_rejects_vanished_closed_year(self, builder):
+        """The 2026-07-08 shape: year 1999 disappeared entirely."""
+        with patch.object(
+            CVESiteBuilder, "fetch_published_totals", return_value=published(10000, **{"1999": 894, "2026": 9106})
+        ):
+            with pytest.raises(RuntimeError, match="year 1999"):
+                builder.verify_no_regression(year_data(**{"2026": 9106}))
+
+    def test_current_year_decrease_is_not_a_closed_year_error(self, builder):
+        """The current year is still accumulating; only the total covers it."""
+        with patch.object(
+            CVESiteBuilder, "fetch_published_totals", return_value=published(1000, **{"2025": 600, "2026": 400})
+        ):
+            # total stays healthy, current year dips slightly
+            builder.verify_no_regression(year_data(**{"2025": 700, "2026": 395}))
+
+    def test_no_baseline_is_accepted(self, builder):
+        """First run has nothing published to compare against."""
+        with patch.object(CVESiteBuilder, "fetch_published_totals", return_value=None):
+            builder.verify_no_regression(year_data(**{"2026": 1}))
+
+    def test_accept_baseline_skips_check(self, builder):
+        builder.accept_baseline = True
+        with patch.object(
+            CVESiteBuilder, "fetch_published_totals", side_effect=AssertionError("should not be fetched")
+        ):
+            builder.verify_no_regression(year_data(**{"2026": 1}))
+
+    def test_allowance_boundary(self, builder):
+        """Exactly at the allowance passes; one beyond fails."""
+        base = published(1000, **{"2026": 1000})
+        with patch.object(CVESiteBuilder, "fetch_published_totals", return_value=base):
+            builder.verify_no_regression(year_data(**{"2026": 990}))
+            with pytest.raises(RuntimeError):
+                builder.verify_no_regression(year_data(**{"2026": 989}))
+
+
+class TestVerifyDataFreshness:
+    """Age is the producer's last run, not our download time.
+
+    Downloading a stale snapshot makes it freshly downloaded, not fresh.
+    """
+
+    def _write_cache_info(self, builder, *, downloaded=None, source_run=None, **extra):
+        payload: dict[str, object] = dict(extra)
+        if downloaded is not None:
+            payload["download_time"] = downloaded.isoformat()
+        if source_run is not None:
+            payload["source_last_run"] = source_run.isoformat()
+        (builder.cache_dir / "cache_info.json").write_text(json.dumps(payload))
+        builder.source_provenance.cache_clear()
+
+    def test_accepts_fresh_data(self, builder):
+        """A normal CI run: producer ran hours ago, we downloaded minutes ago."""
+        now = datetime.now(UTC)
+        self._write_cache_info(builder, downloaded=now - timedelta(minutes=7), source_run=now - timedelta(hours=6))
+        builder.verify_data_freshness()
+
+    def test_rejects_stale_data(self, builder):
+        now = datetime.now(UTC)
+        self._write_cache_info(builder, downloaded=now - timedelta(days=50), source_run=now - timedelta(days=50))
+        with pytest.raises(RuntimeError, match="over the 24.0h limit"):
+            builder.verify_data_freshness()
+
+    def test_rejects_stale_snapshot_downloaded_moments_ago(self, builder):
+        """The case this guard exists for, and the one it used to miss.
+
+        CI downloads a few minutes before building, so download time is always
+        ~now no matter how old the data behind it is. Gating on that interval
+        meant the guard could never fire.
+        """
+        now = datetime.now(UTC)
+        self._write_cache_info(builder, downloaded=now - timedelta(minutes=7), source_run=now - timedelta(days=3))
+        with pytest.raises(RuntimeError, match=r"72\.\dh old, over the 24\.0h limit"):
+            builder.verify_data_freshness()
+
+    def test_accepts_observed_producer_gap(self, builder):
+        """GitHub drops most scheduled triggers, so 5-7h gaps are routine."""
+        now = datetime.now(UTC)
+        self._write_cache_info(builder, downloaded=now, source_run=now - timedelta(hours=7))
+        builder.verify_data_freshness()
+
+    def test_limit_boundary(self, builder):
+        """Just inside the limit passes; just past it fails."""
+        now = datetime.now(UTC)
+        self._write_cache_info(builder, downloaded=now, source_run=now - timedelta(hours=23, minutes=55))
+        builder.verify_data_freshness()
+
+        self._write_cache_info(builder, downloaded=now, source_run=now - timedelta(hours=24, minutes=10))
+        with pytest.raises(RuntimeError, match="over the 24.0h limit"):
+            builder.verify_data_freshness()
+
+    def test_missing_source_last_run_warns_but_passes(self, builder):
+        """cache_info files from the async path carry no producer timestamp.
+
+        Nothing to measure against, so the build should not be blocked on it.
+        """
+        self._write_cache_info(builder, downloaded=datetime.now(UTC) - timedelta(days=50))
+        builder.verify_data_freshness()
+
+    def test_missing_cache_info_warns_but_passes(self, builder):
+        """An unreadable cache info should not block a build on its own."""
+        builder.source_provenance.cache_clear()
+        builder.verify_data_freshness()
+
+
+class TestSourceProvenance:
+    def test_reports_age_and_source_fields(self, builder, tmp_path):
+        when = datetime.now(UTC) - timedelta(hours=3)
+        (tmp_path / "cache_info.json").write_text(
+            json.dumps(
+                {
+                    "download_time": when.isoformat(),
+                    "source_last_run": "2026-08-18T01:07:27.380633+00:00",
+                    "source_cve_count": 378426,
+                }
+            )
+        )
+        builder.source_provenance.cache_clear()
+        p = builder.source_provenance()
+        assert p["source_cve_count"] == 378426
+        assert p["source_last_run"] == "2026-08-18T01:07:27.380633+00:00"
+        assert 2.9 < p["data_age_hours"] < 3.1
+        assert p["data_as_of"].endswith("Z")
+
+    def test_build_latency_and_data_age_are_separate_signals(self, builder, tmp_path):
+        """A recent download of an old snapshot: ~0h latency, 30h of data age."""
+        now = datetime.now(UTC)
+        (tmp_path / "cache_info.json").write_text(
+            json.dumps(
+                {
+                    "download_time": (now - timedelta(minutes=6)).isoformat(),
+                    "source_last_run": (now - timedelta(hours=30)).isoformat(),
+                }
+            )
+        )
+        builder.source_provenance.cache_clear()
+        p = builder.source_provenance()
+        assert 0.0 <= p["data_age_hours"] < 0.2
+        assert 29.9 < p["source_age_hours"] < 30.1
+
+    def test_naive_source_last_run_is_read_as_utc(self, builder, tmp_path):
+        naive = (datetime.now(UTC) - timedelta(hours=5)).replace(tzinfo=None)
+        (tmp_path / "cache_info.json").write_text(json.dumps({"source_last_run": naive.isoformat()}))
+        builder.source_provenance.cache_clear()
+        p = builder.source_provenance()
+        assert 4.9 < p["source_age_hours"] < 5.1
+
+    def test_unparseable_source_last_run_leaves_age_unset(self, builder, tmp_path):
+        (tmp_path / "cache_info.json").write_text(json.dumps({"source_last_run": "not-a-timestamp"}))
+        builder.source_provenance.cache_clear()
+        p = builder.source_provenance()
+        assert p["source_last_run"] == "not-a-timestamp"
+        assert p["source_age_hours"] is None
+
+    def test_naive_timestamp_is_read_as_utc(self, builder, tmp_path):
+        """Older cache_info files predate the UTC fix."""
+        naive = (datetime.now(UTC) - timedelta(hours=1)).replace(tzinfo=None)
+        (tmp_path / "cache_info.json").write_text(json.dumps({"download_time": naive.isoformat()}))
+        builder.source_provenance.cache_clear()
+        p = builder.source_provenance()
+        assert 0.9 < p["data_age_hours"] < 1.1
+
+    def test_missing_file_returns_empty_provenance(self, builder):
+        builder.source_provenance.cache_clear()
+        p = builder.source_provenance()
+        assert p["data_as_of"] is None
+        assert p["data_age_hours"] is None
+        assert p["source_age_hours"] is None
+
+
+class TestGuardEnforcementMode:
+    """The guards exist to stop bad data being published.
+
+    A local build publishes nothing, so it warns rather than blocking a
+    developer working from a deliberately old cache. CI is the deploy path.
+    """
+
+    def test_regression_warns_instead_of_raising_outside_ci(self, lenient_builder):
+        with patch.object(
+            CVESiteBuilder, "fetch_published_totals", return_value=published(10000, **{"1999": 894, "2026": 9106})
+        ):
+            lenient_builder.verify_no_regression(year_data(**{"2026": 9106}))
+
+    def test_stale_data_warns_instead_of_raising_outside_ci(self, lenient_builder):
+        stale = datetime.now(UTC) - timedelta(days=53)
+        (lenient_builder.cache_dir / "cache_info.json").write_text(
+            json.dumps({"download_time": stale.isoformat(), "source_last_run": stale.isoformat()})
+        )
+        lenient_builder.source_provenance.cache_clear()
+        lenient_builder.verify_data_freshness()
+
+    def test_strict_mode_is_inferred_from_ci_env(self, monkeypatch):
+        monkeypatch.setenv("CI", "true")
+        assert CVESiteBuilder(quiet=True).strict_data_guards is True
+
+    def test_not_strict_without_ci_env(self, monkeypatch):
+        monkeypatch.delenv("CI", raising=False)
+        assert CVESiteBuilder(quiet=True).strict_data_guards is False
+
+
+class TestYearlySourceReconciliation:
+    """Per-year agreement between the NVD-sourced and V5-sourced counts.
+
+    yearly_summary.json counts from the NVD mirror; cna_analysis.json counts
+    from cvelistV5. Both bucket by publication year, so modern years should
+    agree closely. Historical years differ because NVD normalised early
+    publication dates differently, and are deliberately exempt.
+    """
+
+    def test_identical_sources_produce_no_drift(self):
+        from build import reconcile_yearly_sources
+
+        years = {2024: 39953, 2025: 48153}
+        drifts = reconcile_yearly_sources(years, dict(years))
+        assert all(d.delta == 0 for d in drifts)
+        assert all(d.ok for d in drifts)
+
+    def test_small_modern_drift_is_allowed(self):
+        from build import reconcile_yearly_sources
+
+        # the real 2026 gap: 76 CVEs on ~68k is 0.11%
+        drifts = reconcile_yearly_sources({2026: 68224}, {2026: 68300})
+        (d,) = drifts
+        assert d.delta == 76
+        assert round(d.pct, 2) == 0.11
+        assert d.ok
+
+    def test_large_modern_drift_is_flagged(self):
+        from build import reconcile_yearly_sources
+
+        # 8% on a modern year clears both the absolute and percentage allowance
+        drifts = reconcile_yearly_sources({2026: 68224}, {2026: 73682})
+        (d,) = drifts
+        assert not d.ok
+        assert d.delta == 5458
+
+    def test_absolute_allowance_covers_small_years(self):
+        from build import MAX_YEAR_DRIFT_ABS, reconcile_yearly_sources
+
+        # 200 on a 3k year is 6.7% - over the percentage bar, under the absolute one
+        drifts = reconcile_yearly_sources({2016: 3000}, {2016: 3000 + MAX_YEAR_DRIFT_ABS - 50})
+        (d,) = drifts
+        assert abs(d.pct) > 0.5
+        assert d.ok, "the absolute allowance should cover small modern years"
+
+    def test_historical_years_are_exempt(self):
+        from build import reconcile_yearly_sources
+
+        # 2005 really does differ by ~36% between the two sources
+        drifts = reconcile_yearly_sources({2005: 4932}, {2005: 6708})
+        (d,) = drifts
+        assert not d.modern
+        assert d.ok, "pre-2016 years are recorded but not held to a threshold"
+
+    def test_years_missing_from_one_source_still_appear(self):
+        from build import reconcile_yearly_sources
+
+        drifts = reconcile_yearly_sources({2024: 100}, {2025: 200})
+        assert [d.year for d in drifts] == [2024, 2025]
+        assert drifts[0].v5 == 0 and drifts[1].nvd == 0
+
+    def test_zero_nvd_count_does_not_divide_by_zero(self):
+        from build import MAX_YEAR_DRIFT_ABS, reconcile_yearly_sources
+
+        # Small gap: passes on the absolute allowance, as any small gap would.
+        (small,) = reconcile_yearly_sources({2026: 0}, {2026: 40})
+        assert small.pct == 0.0, "pct must stay JSON-safe with no baseline"
+        assert small.ok
+
+        # Large gap with no baseline: the percentage is undefined, so it must not
+        # approve the year - the absolute allowance is the only thing that can.
+        (big,) = reconcile_yearly_sources({2026: 0}, {2026: MAX_YEAR_DRIFT_ABS + 1})
+        assert big.pct == 0.0
+        assert not big.ok, "an undefined percentage must never approve a year"
+
+    def test_real_build_output_has_no_flagged_years(self):
+        """The committed data should reconcile; if it stops, the build warns."""
+        from pathlib import Path
+
+        recon = Path(__file__).parent.parent / "web" / "data" / "source_reconciliation.json"
+        if not recon.exists():
+            pytest.skip("source_reconciliation.json not built")
+        data = json.loads(recon.read_text())
+        assert data["flagged_years"] == [], f"years drifting beyond threshold: {data['flagged_years']}"
diff --git a/tests/test_schemas.py b/tests/test_schemas.py
index decc85f55d2..b1490a8c06c 100644
--- a/tests/test_schemas.py
+++ b/tests/test_schemas.py
@@ -8,132 +8,174 @@
 import json
 import sys
 from pathlib import Path
+
 import pytest
-from jsonschema import validate, ValidationError
+from jsonschema import validate
+
 
 # Add tests directory to path for importing conftest schemas
 sys.path.insert(0, str(Path(__file__).parent))
 
 from conftest import (
-    CVE_YEAR_SCHEMA,
     CNA_ANALYSIS_SCHEMA,
+    CVE_YEAR_SCHEMA,
     CVSS_ANALYSIS_SCHEMA,
     DATA_QUALITY_SCHEMA,
 )
 
-# Path to dist data directory
-DIST_DATA_DIR = Path(__file__).parent.parent / "dist" / "data"
+
+# Path to web data directory
+WEB_DATA_DIR = Path(__file__).parent.parent / "web" / "data"
+
 
 class TestSchemaValidation:
     """Test that generated JSON files conform to expected schemas."""
-    
+
     @pytest.mark.skipif(
-        not (DIST_DATA_DIR / "cna_analysis.json").exists(),
-        reason="CNA analysis file not found - run build first"
+        not (WEB_DATA_DIR / "cna_analysis.json").exists(), reason="CNA analysis file not found - run build first"
     )
     def test_cna_analysis_schema(self):
         """Validate cna_analysis.json against schema."""
-        with open(DIST_DATA_DIR / "cna_analysis.json") as f:
+        with open(WEB_DATA_DIR / "cna_analysis.json") as f:
             data = json.load(f)
+
+        # Validate against schema
         validate(instance=data, schema=CNA_ANALYSIS_SCHEMA)
+
+        # Additional assertions
         assert data["total_cnas"] > 0, "Should have at least one CNA"
         assert len(data["cna_list"]) > 0, "CNA list should not be empty"
+        assert data["active_cnas"] + data["inactive_cnas"] == data["total_cnas"]
 
     @pytest.mark.skipif(
-        not (DIST_DATA_DIR / "cvss_analysis.json").exists(),
-        reason="CVSS analysis file not found - run build first"
+        not (WEB_DATA_DIR / "cvss_analysis.json").exists(), reason="CVSS analysis file not found - run build first"
     )
     def test_cvss_analysis_schema(self):
         """Validate cvss_analysis.json against schema."""
-        with open(DIST_DATA_DIR / "cvss_analysis.json") as f:
+        with open(WEB_DATA_DIR / "cvss_analysis.json") as f:
             data = json.load(f)
+
+        # Validate against schema
         validate(instance=data, schema=CVSS_ANALYSIS_SCHEMA)
+
+        # Additional assertions
         assert data["total_cves_with_cvss"] > 0, "Should have scored CVEs"
+        assert len(data["severity_distribution"]) > 0, "Severity distribution should have entries"
 
     @pytest.mark.skipif(
-        not (DIST_DATA_DIR / "data_quality.json").exists(),
-        reason="Data quality file not found - run build first"
+        not (WEB_DATA_DIR / "data_quality.json").exists(), reason="Data quality file not found - run build first"
     )
     def test_data_quality_schema(self):
         """Validate data_quality.json against schema."""
-        with open(DIST_DATA_DIR / "data_quality.json") as f:
+        with open(WEB_DATA_DIR / "data_quality.json") as f:
             data = json.load(f)
+
+        # Validate against schema
         validate(instance=data, schema=DATA_QUALITY_SCHEMA)
+
+        # Additional assertions
         stats = data["stats"]
-        total = stats["total_cnas_in_analysis"]
-        matched = (stats["exact_matches"] + stats["case_mismatches"] + 
-                   stats["org_name_matches"] + stats["normalized_matches"] + 
-                   stats["partial_matches"])
+        total_analyzed = stats["total_cnas_in_analysis"]
+        matched = (
+            stats["exact_matches"]
+            + stats["case_mismatches"]
+            + stats["org_name_matches"]
+            + stats["normalized_matches"]
+            + stats["partial_matches"]
+        )
         unmatched = stats["unmatched"]
-        assert total == matched + unmatched
+
+        assert total_analyzed == matched + unmatched, "Total should equal matched + unmatched"
 
     @pytest.mark.skipif(
-        not (DIST_DATA_DIR / "cve_2024.json").exists(),
-        reason="Year data file not found - run build first"
+        not (WEB_DATA_DIR / "cve_2024.json").exists(), reason="Year data file not found - run build first"
     )
     def test_year_data_schema(self):
         """Validate a sample year data file against schema."""
-        with open(DIST_DATA_DIR / "cve_2024.json") as f:
+        with open(WEB_DATA_DIR / "cve_2024.json") as f:
             data = json.load(f)
+
+        # Validate against schema
         validate(instance=data, schema=CVE_YEAR_SCHEMA)
+
+        # Additional assertions
         assert data["year"] == 2024
         assert data["total_cves"] > 0
 
+
 class TestDataIntegrity:
     """Test data integrity and consistency across files."""
-    
+
     @pytest.mark.skipif(
-        not (DIST_DATA_DIR / "cna_analysis.json").exists(),
-        reason="CNA analysis file not found - run build first"
+        not (WEB_DATA_DIR / "cna_analysis.json").exists(), reason="CNA analysis file not found - run build first"
     )
     def test_cna_list_has_required_fields(self):
         """Verify all CNAs have required fields populated."""
-        with open(DIST_DATA_DIR / "cna_analysis.json") as f:
+        with open(WEB_DATA_DIR / "cna_analysis.json") as f:
             data = json.load(f)
+
         for cna in data["cna_list"]:
-            assert "name" in cna
-            assert "count" in cna
-            assert cna["count"] >= 0
+            assert "name" in cna, "CNA missing 'name' field"
+            assert "count" in cna, f"CNA {cna.get('name', 'unknown')} missing 'count'"
+            assert cna["count"] >= 0, f"CNA {cna['name']} has negative count"
 
     @pytest.mark.skipif(
-        not (DIST_DATA_DIR / "yearly_summary.json").exists(),
-        reason="Yearly summary file not found - run build first"
+        not (WEB_DATA_DIR / "yearly_summary.json").exists(), reason="Yearly summary file not found - run build first"
     )
     def test_yearly_summary_completeness(self):
         """Verify yearly summary contains all expected years."""
-        with open(DIST_DATA_DIR / "yearly_summary.json") as f:
+        with open(WEB_DATA_DIR / "yearly_summary.json") as f:
             data = json.load(f)
+
         years = data.get("years", {})
-        # Check for start and end years roughly
-        assert any(y in years or str(y) in years for y in range(1999, 2005))
-        assert any(y in years or str(y) in years for y in range(2023, 2027))
+
+        # Should have data from 1999 to current year
+        assert "1999" in years or 1999 in years, "Missing 1999 data"
+        assert "2024" in years or 2024 in years, "Missing 2024 data"
+
+        # Each year should have required fields
+        for year, year_data in years.items():
+            assert "total_cves" in year_data, f"Year {year} missing total_cves"
+            assert year_data["total_cves"] >= 0, f"Year {year} has negative CVE count"
 
     @pytest.mark.skipif(
-        not all((DIST_DATA_DIR / f).exists() for f in ["cna_analysis.json", "cve_all.json"]),
-        reason="Required files not found - run build first"
+        not all((WEB_DATA_DIR / f).exists() for f in ["cna_analysis.json", "cve_all.json"]),
+        reason="Required files not found - run build first",
     )
     def test_cve_totals_reasonable(self):
         """Verify CVE totals are in reasonable ranges."""
-        with open(DIST_DATA_DIR / "cna_analysis.json") as f:
+        with open(WEB_DATA_DIR / "cna_analysis.json") as f:
             cna_data = json.load(f)
-        with open(DIST_DATA_DIR / "cve_all.json") as f:
+
+        with open(WEB_DATA_DIR / "cve_all.json") as f:
             all_data = json.load(f)
-        
+
+        # Total CVEs from CNA analysis
         cna_total = sum(cna["count"] for cna in cna_data["cna_list"])
+
+        # cve_all.json contains metadata with total
         all_total = all_data.get("total_cves", 0)
-        
-        # Basic sanity checks
-        assert cna_total > 1000
-        assert all_total > 1000
-        
+
+        # Both should be in reasonable range (200K+ CVEs exist)
+        assert cna_total > 200000, f"CNA total ({cna_total}) seems too low"
+        assert all_total > 200000, f"All total ({all_total}) seems too low"
+
+        # They may differ due to data sources/timing, but should be same order of magnitude
+        ratio = cna_total / all_total if all_total > 0 else 0
+        assert 0.8 <= ratio <= 1.2, f"CNA total ({cna_total}) differs significantly from cve_all ({all_total})"
+
+
 class TestFixtureSchemas:
     """Test that fixtures conform to schemas (validates our test data)."""
-    
+
     def test_sample_cna_analysis_valid(self, sample_cna_analysis):
+        """Verify sample CNA analysis fixture is valid."""
         validate(instance=sample_cna_analysis, schema=CNA_ANALYSIS_SCHEMA)
-    
+
     def test_sample_cvss_analysis_valid(self, sample_cvss_analysis):
+        """Verify sample CVSS analysis fixture is valid."""
         validate(instance=sample_cvss_analysis, schema=CVSS_ANALYSIS_SCHEMA)
-    
+
     def test_sample_year_data_valid(self, sample_year_data):
+        """Verify sample year data fixture is valid."""
         validate(instance=sample_year_data, schema=CVE_YEAR_SCHEMA)
diff --git a/tests/test_source_manifest.py b/tests/test_source_manifest.py
new file mode 100644
index 00000000000..4673bdb6e46
--- /dev/null
+++ b/tests/test_source_manifest.py
@@ -0,0 +1,269 @@
+"""Tests for source manifest ingest and verification.
+
+The producer publishes metadata.json describing the snapshot behind nvd.json.
+These tests cover the gates that stand between that manifest and a build:
+health (degraded / API fallback / completeness), regression against the last
+accepted snapshot, and integrity of the downloaded object.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from data.download_cve_data import CVEDataDownloader
+from tests.fakes import FakeDataReader, FakeDataWriter, FakeHttpClient
+
+
+MANIFEST_URL = "https://nvd.handsonhacking.org/metadata.json"
+BASELINE_URL = "https://cvedb.github.io/data/source_manifest.json"
+
+
+def make_manifest(**overrides):
+    """A healthy manifest, shaped like the real one."""
+    manifest = {
+        "last_run_iso": "2026-08-18T01:07:27.380633+00:00",
+        "cve_count": 378426,
+        "degraded": False,
+        "years_via_api": [],
+        "expected_total": 378739,
+        "completeness_ratio": 0.9992,
+        "year_counts": {"1999": 1579, "2025": 45146, "2026": 45127},
+    }
+    manifest.update(overrides)
+    return manifest
+
+
+def make_downloader(tmp_path: Path, http_client: FakeHttpClient) -> CVEDataDownloader:
+    return CVEDataDownloader(
+        cache_dir=tmp_path,
+        quiet=True,
+        http_client=http_client,
+        data_reader=FakeDataReader(),
+        data_writer=FakeDataWriter(),
+    )
+
+
+class TestFetchSourceManifest:
+    def test_returns_parsed_manifest(self, tmp_path):
+        manifest = make_manifest()
+        client = FakeHttpClient()
+        client.add_response(MANIFEST_URL, json_data=manifest)
+
+        assert make_downloader(tmp_path, client).fetch_source_manifest() == manifest
+
+    def test_returns_none_when_unavailable(self, tmp_path):
+        """An unreachable manifest must not break the build."""
+        client = FakeHttpClient()  # unregistered URLs 404
+        assert make_downloader(tmp_path, client).fetch_source_manifest() is None
+
+    def test_returns_none_on_malformed_payload(self, tmp_path):
+        client = FakeHttpClient()
+        client.add_response(MANIFEST_URL, json_data={"unexpected": True})
+        assert make_downloader(tmp_path, client).fetch_source_manifest() is None
+
+
+class TestVerifyManifestHealthy:
+    def test_accepts_healthy_manifest(self, tmp_path):
+        d = make_downloader(tmp_path, FakeHttpClient())
+        d.verify_manifest_healthy(make_manifest())  # must not raise
+
+    def test_rejects_degraded_run(self, tmp_path):
+        d = make_downloader(tmp_path, FakeHttpClient())
+        with pytest.raises(ValueError, match="degraded"):
+            d.verify_manifest_healthy(make_manifest(degraded=True))
+
+    def test_rejects_api_fallback(self, tmp_path):
+        """The REST API fallback drops records whose ID year != publication year."""
+        d = make_downloader(tmp_path, FakeHttpClient())
+        with pytest.raises(ValueError, match="REST API"):
+            d.verify_manifest_healthy(make_manifest(years_via_api=["2023"]))
+
+    def test_rejects_low_completeness(self, tmp_path):
+        """The leading-edge failure mode shows up as a completeness dip."""
+        d = make_downloader(tmp_path, FakeHttpClient())
+        with pytest.raises(ValueError, match="completeness_ratio"):
+            d.verify_manifest_healthy(make_manifest(completeness_ratio=0.97))
+
+    def test_tolerates_absent_completeness_field(self, tmp_path):
+        m = make_manifest()
+        del m["completeness_ratio"]
+        make_downloader(tmp_path, FakeHttpClient()).verify_manifest_healthy(m)
+
+
+class TestVerifyManifestNotRegressed:
+    def test_accepts_growth(self, tmp_path):
+        d = make_downloader(tmp_path, FakeHttpClient())
+        baseline = make_manifest(cve_count=378000, year_counts={"1999": 1579, "2026": 45000})
+        d.verify_manifest_not_regressed(make_manifest(), baseline)
+
+    def test_accepts_identical(self, tmp_path):
+        """A producer run with no new CVEs is normal, not a regression."""
+        d = make_downloader(tmp_path, FakeHttpClient())
+        d.verify_manifest_not_regressed(make_manifest(), make_manifest())
+
+    def test_rejects_total_regression(self, tmp_path):
+        d = make_downloader(tmp_path, FakeHttpClient())
+        baseline = make_manifest(cve_count=378426)
+        with pytest.raises(ValueError, match="total"):
+            d.verify_manifest_not_regressed(make_manifest(cve_count=377000), baseline)
+
+    def test_rejects_single_year_regression(self, tmp_path):
+        """The 2023-feed fallback showed up as one year moving, not the total."""
+        d = make_downloader(tmp_path, FakeHttpClient())
+        baseline = make_manifest()
+        regressed = make_manifest(
+            cve_count=999999,  # total grew, masking the per-year loss
+            year_counts={"1999": 1579, "2025": 40000, "2026": 45127},
+        )
+        with pytest.raises(ValueError, match="year 2025"):
+            d.verify_manifest_not_regressed(regressed, baseline)
+
+    def test_rejects_disappeared_year(self, tmp_path):
+        """Year 1999 vanishing entirely is the 2026-07-08 shape."""
+        d = make_downloader(tmp_path, FakeHttpClient())
+        with pytest.raises(ValueError, match="year 1999"):
+            d.verify_manifest_not_regressed(
+                make_manifest(year_counts={"2025": 45146, "2026": 45127}),
+                make_manifest(),
+            )
+
+    def test_no_baseline_is_accepted(self, tmp_path):
+        """First run has nothing to compare against."""
+        d = make_downloader(tmp_path, FakeHttpClient())
+        d.verify_manifest_not_regressed(make_manifest(), None)
+
+
+class TestVerifyDownloadAgainstManifest:
+    def test_accepts_matching_size(self, tmp_path):
+        d = make_downloader(tmp_path, FakeHttpClient())
+        d.verify_download_against_manifest(make_manifest(bytes=1000), 1000)
+
+    def test_rejects_size_mismatch(self, tmp_path):
+        d = make_downloader(tmp_path, FakeHttpClient())
+        with pytest.raises(OSError, match="Size mismatch"):
+            d.verify_download_against_manifest(make_manifest(bytes=1787783421), 1787000000)
+
+    def test_tolerates_absent_integrity_fields(self, tmp_path):
+        """bytes and sha256 only appear from the first post-merge producer run."""
+        d = make_downloader(tmp_path, FakeHttpClient())
+        d.verify_download_against_manifest(make_manifest(), 12345)
+
+    def test_no_manifest_skips_verification(self, tmp_path):
+        d = make_downloader(tmp_path, FakeHttpClient())
+        d.verify_download_against_manifest(None, 12345)
+
+    def test_rejects_sha256_mismatch(self, tmp_path):
+        real_cache = tmp_path / "cache"
+        real_cache.mkdir()
+        d = CVEDataDownloader(cache_dir=real_cache, quiet=True, http_client=FakeHttpClient())
+        d.cache_file.write_bytes(b"payload")
+        with pytest.raises(OSError, match="SHA-256 mismatch"):
+            d.verify_download_against_manifest(make_manifest(sha256="0" * 64), 7)
+
+    def test_accepts_correct_sha256(self, tmp_path):
+        import hashlib
+
+        real_cache = tmp_path / "cache"
+        real_cache.mkdir()
+        d = CVEDataDownloader(cache_dir=real_cache, quiet=True, http_client=FakeHttpClient())
+        payload = b"payload"
+        d.cache_file.write_bytes(payload)
+        d.verify_download_against_manifest(make_manifest(sha256=hashlib.sha256(payload).hexdigest()), len(payload))
+
+
+class TestPublishRace:
+    """The producer writes nvd.json before metadata.json, so a reader can end up
+    holding the next snapshot while the manifest still names the previous one.
+    That used to fail the build as "Snapshot is incomplete", which was both a
+    false failure and a misleading message. It matters more since the producer
+    moved from a 3-hourly to an hourly cadence on 2026-09-22.
+    """
+
+    def make(self, tmp_path, fresh=None):
+        http = FakeHttpClient()
+        if fresh is not None:
+            http.add_response(MANIFEST_URL, json_data=fresh)
+        return make_downloader(tmp_path, http)
+
+    def test_accepts_bytes_matching_the_newer_snapshot(self, tmp_path):
+        """Raced a publish: the bytes are good, they are just the next snapshot."""
+        stale = make_manifest(bytes=100, sha256="a" * 64)
+        fresh = make_manifest(bytes=200, sha256="b" * 64, cve_count=378500)
+        d = self.make(tmp_path, fresh)
+
+        accepted = d.verify_download_against_manifest(stale, 200, "b" * 64)
+
+        assert accepted == fresh, "must report the snapshot the bytes really are"
+
+    def test_unchanged_manifest_is_still_a_bad_download(self, tmp_path):
+        """No concurrent publish to blame means the bytes really are wrong."""
+        manifest = make_manifest(bytes=100, sha256="a" * 64)
+        d = self.make(tmp_path, manifest)
+        with pytest.raises(OSError, match="has not moved"):
+            d.verify_download_against_manifest(manifest, 999, "a" * 64)
+
+    def test_matching_neither_snapshot_fails(self, tmp_path):
+        stale = make_manifest(bytes=100, sha256="a" * 64)
+        fresh = make_manifest(bytes=200, sha256="b" * 64)
+        d = self.make(tmp_path, fresh)
+        with pytest.raises(OSError, match="neither snapshot"):
+            d.verify_download_against_manifest(stale, 300, "c" * 64)
+
+    def test_unreadable_manifest_fails_closed(self, tmp_path):
+        """Cannot rule out corruption without a second read, so do not guess."""
+        stale = make_manifest(bytes=100, sha256="a" * 64)
+        d = self.make(tmp_path)
+        with pytest.raises(OSError, match="Could not re-read"):
+            d.verify_download_against_manifest(stale, 200, "b" * 64)
+
+    def test_raced_snapshot_must_still_be_healthy(self, tmp_path):
+        """Racing a publish is not a way around the producer-health gate."""
+        stale = make_manifest(bytes=100, sha256="a" * 64)
+        fresh = make_manifest(bytes=200, sha256="b" * 64, degraded=True)
+        d = self.make(tmp_path, fresh)
+        with pytest.raises(ValueError):
+            d.verify_download_against_manifest(stale, 200, "b" * 64)
+
+    def test_clean_match_returns_the_original_manifest(self, tmp_path):
+        """No mismatch means no second manifest read."""
+        manifest = make_manifest(bytes=100, sha256="a" * 64)
+        d = self.make(tmp_path)
+
+        assert d.verify_download_against_manifest(manifest, 100, "a" * 64) == manifest
+        assert d._http_client.request_count == 0
+
+
+class TestStreamingHash:
+    def test_matches_hashlib(self, tmp_path):
+        import hashlib
+
+        target = tmp_path / "blob.bin"
+        payload = b"x" * (3 * 1024 * 1024)
+        target.write_bytes(payload)
+        d = CVEDataDownloader(cache_dir=tmp_path, quiet=True, http_client=FakeHttpClient())
+        assert d.calculate_file_hash_streaming(target, chunk_size=64 * 1024) == (hashlib.sha256(payload).hexdigest())
+
+
+class TestBaselineManifest:
+    def test_missing_baseline_returns_none(self, tmp_path):
+        """404 on first run is expected, not an error."""
+        client = FakeHttpClient()
+        client.add_response(BASELINE_URL, status_code=404, content=b"Not Found")
+        assert make_downloader(tmp_path, client).fetch_baseline_manifest() is None
+
+    def test_returns_baseline(self, tmp_path):
+        baseline = make_manifest(cve_count=1)
+        client = FakeHttpClient()
+        client.add_response(BASELINE_URL, json_data=baseline)
+        assert make_downloader(tmp_path, client).fetch_baseline_manifest() == baseline
+
+
+class TestPersistAcceptedManifest:
+    def test_writes_manifest(self, tmp_path):
+        writer = FakeDataWriter()
+        d = CVEDataDownloader(cache_dir=tmp_path, quiet=True, http_client=FakeHttpClient(), data_writer=writer)
+        manifest = make_manifest()
+        d.persist_accepted_manifest(manifest)
+        assert writer.get_json(d.manifest_file) == manifest
diff --git a/static/CNAME b/web/CNAME
similarity index 100%
rename from static/CNAME
rename to web/CNAME
diff --git a/web/about.html b/web/about.html
new file mode 100644
index 00000000000..ce3f21119d3
--- /dev/null
+++ b/web/about.html
@@ -0,0 +1,227 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>About &mdash; CVEDB</title>
+
+<meta name="description" content="What CVEDB counts, where the data comes from, and how often it updates.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    >Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      >Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  >Scoring</a></li>
+    <li><a href="about.html"    class="on" aria-current="page">About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph"><h1>About</h1><span class="note">what this counts, and what it does not</span></div>
+<p class="lede">CVEDB counts CVEs. That is the whole product: how many were published this year,
+how many all time, and how those break down by publisher, product and weakness type. Nothing
+here is weighted, scored or prioritised by us.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Where the numbers come from</h2>
+<div class="panel"><div id="src-table"></div></div>
+
+<h2>How counting works</h2>
+<div class="cols c2">
+  <div class="panel">
+    <div class="panel-h">Counts that add up</div>
+    <div class="panel-b muted" style="font-size:13.5px;line-height:1.65">
+      <p>Each CVE is published by exactly one authority and belongs to exactly one year, so
+      <a href="years.html" style="color:var(--accent)">yearly</a> and
+      <a href="cna.html" style="color:var(--accent)">publisher</a> counts sum to the total.</p>
+      <p style="margin-top:9px">A day's count is the CVEs published that day. Publication is
+      bursty: a single publisher can file thousands at once, so daily figures swing hard.</p>
+    </div>
+  </div>
+  <div class="panel">
+    <div class="panel-h">Counts that do not</div>
+    <div class="panel-b muted" style="font-size:13.5px;line-height:1.65">
+      <p>A CVE can name many affected <a href="cpe.html" style="color:var(--accent)">products</a>,
+      so product counts sum to far more than the number of CVEs.</p>
+      <p style="margin-top:9px">A CVE can also hold a <a href="cvss.html" style="color:var(--accent)">CVSS</a>
+      score under several metric versions at once. The total scored figure counts scores, not
+      CVEs, which is why it can exceed the number of CVEs that exist.</p>
+      <p style="margin-top:9px">Not every CVE carries a
+      <a href="cwe.html" style="color:var(--accent)">weakness type</a>, so those counts cover a
+      subset.</p>
+    </div>
+  </div>
+</div>
+
+<h2>Freshness</h2>
+<div class="note-box" id="fresh-box">
+  The site rebuilds <b>hourly</b>. Its data comes from an upstream mirror of the NVD and CVE
+  Program records, so the site can never be fresher than that feed &mdash; both timestamps are
+  shown below and in the header.
+</div>
+<div class="grid g3" style="margin-top:12px" id="fresh-tiles"></div>
+
+<h2>Using the data</h2>
+<div class="note-box">
+  Every number on this site is read from a JSON file you can fetch directly at
+  <code>cvedb.github.io/data/</code>. No key, no rate limit, no registration. If you want the counts
+  rather than the pages, start there.
+</div>
+
+<h2>Built with</h2>
+<div class="panel"><div class="panel-b muted" style="font-size:13.5px;line-height:1.7">
+  Python builds the data and renders static pages with Jinja. The pages ship no charting
+  library &mdash; the charts here are counts, and counts draw fine with SVG and CSS.
+  Hosted on GitHub Pages. Source is on
+  <a href="https://github.com/cvedb/cvedb.github.io" style="color:var(--accent)" rel="noopener">GitHub</a>.
+</div></div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async (S) => {
+  const { fmt, el, table } = CVE;
+  const years = Object.values(S.yearly_summary.years);
+  const total = years.reduce((s, y) => s + y.total_cves, 0);
+  const YR = 2026;
+  const ytd = (years.find(y => y.year === YR) || {}).total_cves || 0;
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'CVEs counted', v: fmt.n(total),
+      sub: `across <b>${years.length}</b> years, 1999&ndash;${YR}` },
+    { lbl: `Published in ${YR}`, v: fmt.n(ytd), sub: 'so far this year' },
+    { lbl: 'Publishers', v: fmt.n(S.cna_analysis.total_cnas),
+      sub: `<b>${fmt.n(S.cna_analysis.active_cnas)}</b> active` },
+    { lbl: 'In the KEV catalog', v: fmt.n(S.cvss_analysis.kev_global_count),
+      sub: `<b>${fmt.share(S.cvss_analysis.kev_global_count, total, 2)}</b> of all CVEs` }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  table('#src-table', [
+    { what: 'CVE records', who: 'CVE Program / NVD', how: 'every count on the site',
+      freq: 'continuous' },
+    { what: 'EPSS scores', who: 'FIRST.org', how: 'exploit probability bands',
+      freq: 'daily' },
+    { what: 'KEV catalog', who: 'CISA', how: 'known-exploited counts',
+      freq: 'a few times a week' },
+    { what: 'CNA registry', who: 'CVE Program', how: 'publisher name matching',
+      freq: 'occasional' }
+  ], [
+    { key: 'what', label: 'Data' },
+    { key: 'who', label: 'Source' },
+    { key: 'how', label: 'Used for' },
+    { key: 'freq', label: 'Updated' }
+  ], { sort: { key: 'what', dir: 1 }, name: 'cve-icu-data-sources' });
+
+  el('#fresh-tiles').innerHTML = [
+    { lbl: 'Data as of', v: `<span data-asof>&mdash;</span>`, sub: 'newest record in this build' },
+    { lbl: 'Rebuilt', v: '<span data-built>&mdash;</span>', sub: 'when this build last ran' },
+    { lbl: 'Upstream feed ran', v: '<span data-srcrun>&mdash;</span>',
+      sub: 'the ceiling on freshness' }
+  ].map(t => `<div class="c"><div class="lbl">${t.lbl}</div>
+      <div class="v" style="font-size:20px;font-family:var(--sans);font-weight:650">${t.v}</div>
+      <div class="sub">${t.sub}</div></div>`).join('');
+  CVE.freshness(S);
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/calendar.html b/web/calendar.html
new file mode 100644
index 00000000000..eeb606e46ce
--- /dev/null
+++ b/web/calendar.html
@@ -0,0 +1,197 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>CVEs by day &mdash; CVEDB</title>
+
+<meta name="description" content="Daily CVE publication counts, every day on record.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    >Years</a></li>
+    <li><a href="calendar.html" class="on" aria-current="page">Calendar</a></li>
+    <li><a href="cna.html"      >Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  >Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph">
+  <h1>CVEs by day</h1>
+  <span class="note" id="span-note"></span>
+  <span style="margin-left:auto"><span class="seg" id="yearsel"></span></span>
+</div>
+<p class="lede">One square per day. Publication is bursty &mdash; large batches from a single
+publisher can land on one day, so daily counts swing far more than yearly ones.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Heatmap <span class="side" id="heat-year"></span></h2>
+<div class="panel"><div class="panel-b"><div id="heat"></div></div></div>
+
+<h2>Daily counts</h2>
+<div class="panel">
+  <div class="panel-h">Every day in the selected year</div>
+  <div class="panel-b"><div id="chart-days"></div></div>
+</div>
+
+<h2>Busiest days</h2>
+<div class="panel"><div class="rows" id="busiest"></div></div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async (S) => {
+  const { fmt, chart, el } = CVE;
+  const YR = 2026;
+  const cal = await CVE.json('calendar_analysis.json');
+  const all = (cal.daily_data || []).slice().sort((a, b) => a.date.localeCompare(b.date));
+  const yearsAvail = [...new Set(all.map(d => d.date.slice(0, 4)))].sort().reverse().slice(0, 6);
+  let year = String(YR);
+
+  el('#yearsel').innerHTML = yearsAvail.map(y =>
+    `<button data-y="${y}" class="${y === year ? 'on' : ''}">${y}</button>`).join('');
+  el('#span-note').textContent = all.length
+    ? `${all[0].date} to ${all[all.length - 1].date}` : '';
+
+  function render() {
+    const days = all.filter(d => d.date.startsWith(year));
+    const total = days.reduce((s, d) => s + (d.value || 0), 0);
+    const active = days.filter(d => d.value > 0).length;
+    const peak = days.reduce((m, d) => (d.value || 0) > (m.value || 0) ? d : m, { value: 0 });
+    const quiet = days.filter(d => d.value > 0)
+      .reduce((m, d) => (d.value || 0) < (m.value || 0) ? d : m, { value: Infinity });
+
+    el('#tiles').innerHTML = [
+      { lead: 1, lbl: `Published in ${year}`, v: fmt.n(total),
+        sub: `across <b>${fmt.n(active)}</b> days with at least one CVE` },
+      { lbl: 'Average per active day', v: fmt.n(active ? Math.round(total / active) : 0),
+        sub: `${fmt.n(days.length)} days in range` },
+      { lbl: 'Busiest day', v: fmt.n(peak.value), sub: peak.date || '&mdash;' },
+      { lbl: 'Quietest active day', v: fmt.n(quiet.value === Infinity ? 0 : quiet.value),
+        sub: quiet.date || '&mdash;' }
+    ].map(t => `<div class="c ${t.lead ? 'lead' : ''}">
+        <div class="lbl">${t.lbl}</div><div class="v">${t.v}</div>
+        <div class="sub">${t.sub}</div></div>`).join('');
+
+    el('#heat-year').textContent = year;
+    chart.heat('#heat', days, { name: 'cve-icu-daily-heatmap' });
+
+    chart.bars('#chart-days', days.map(d => ({
+      label: d.date, value: d.value || 0
+    })), { tall: true, ticks: days.length ? [fmt.day(days[0].date), fmt.day(days[days.length - 1].date)] : [] , name: 'cve-icu-daily-counts' });
+
+    chart.rank('#busiest', days.slice().sort((a, b) => b.value - a.value).slice(0, 10)
+      .map(d => ({ label: fmt.day(d.date), sub: d.date, value: d.value })), { name: 'cve-icu-busiest-days' });
+  }
+  render();
+
+  el('#yearsel').addEventListener('click', e => {
+    const b = e.target.closest('button[data-y]'); if (!b) return;
+    year = b.dataset.y;
+    CVE.all('#yearsel button').forEach(x => x.classList.toggle('on', x === b));
+    render();
+  });
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/cna-hub.html b/web/cna-hub.html
new file mode 100644
index 00000000000..623854afa6c
--- /dev/null
+++ b/web/cna-hub.html
@@ -0,0 +1,170 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>Publishers &mdash; CVEDB</title>
+
+<meta name="description" content="Overview of CVE Numbering Authority counts and name matching.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    >Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      class="on" aria-current="page">Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  >Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph"><h1>Publishers</h1><span class="note">CVE Numbering Authorities</span></div>
+<p class="lede">Two views of the same set of organisations: how many CVEs each has published,
+and how well their names line up with the official registry.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Where to go</h2>
+<div class="cols c2">
+  <a class="panel" href="cna.html" style="display:block">
+    <div class="panel-h">Counts by publisher <span class="side">&rarr;</span></div>
+    <div class="panel-b muted" style="font-size:13.5px">
+      Every authority with its count for this year and all time, how long it has been
+      publishing, and how many of its CVEs are in the KEV catalog. Sortable.
+    </div>
+  </a>
+  <a class="panel" href="data-quality.html" style="display:block">
+    <div class="panel-h">Name matching <span class="side">&rarr;</span></div>
+    <div class="panel-b muted" style="font-size:13.5px">
+      How the publisher names in the CVE record line up with the official CNA registry:
+      exact matches, case differences, and the ones that do not match at all.
+    </div>
+  </a>
+</div>
+
+<h2>Largest publishers</h2>
+<div class="panel"><div class="rows" id="top"></div></div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async () => {
+  const { fmt, chart, el } = CVE;
+  const YR = 2026;
+  const d = await CVE.json('cna_analysis.json');
+  const list = d.cna_list || [];
+  const total = list.reduce((s, c) => s + c.count, 0);
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'Publishers on record', v: fmt.n(d.total_cnas),
+      sub: `<b>${fmt.n(d.active_cnas)}</b> active &middot; <b>${fmt.n(d.inactive_cnas)}</b> inactive` },
+    { lbl: 'CVEs attributed', v: fmt.compact(total), sub: 'across all publishers' },
+    { lbl: 'High-volume publishers', v: fmt.n(d.high_volume_cnas), sub: 'more than 1,000 CVEs' },
+    { lbl: 'Median years active', v: String(d.median_years_active ?? '—'), sub: 'across all publishers' }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  chart.rank('#top', list.slice().sort((a, b) => b.count - a.count).slice(0, 12)
+    .map(c => ({ label: c.name, sub: `since ${c.first_cve_year || '?'}`, value: c.count })),
+    { compact: true, name: 'cve-icu-largest-publishers' });
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/cna.html b/web/cna.html
new file mode 100644
index 00000000000..452772163ea
--- /dev/null
+++ b/web/cna.html
@@ -0,0 +1,270 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>CVEs by publisher &mdash; CVEDB</title>
+
+<meta name="description" content="How many CVEs each CVE Numbering Authority has published, this year and all time.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    >Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      class="on" aria-current="page">Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  >Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph">
+  <h1>CVEs by publisher</h1>
+  <span class="note">CVE Numbering Authorities</span>
+  <span style="margin-left:auto"><span class="seg" id="scope">
+    <button data-scope="year" class="on">2026</button>
+    <button data-scope="all">All time</button>
+  </span></span>
+</div>
+<p class="lede">Each CVE is assigned by exactly one authority. These are counts of what each
+publisher is credited with in the CVE record, which can differ by a few dozen from the
+<a href="years.html" style="color:var(--accent)">yearly totals</a> as records are reassigned.
+<a href="data-quality.html" style="color:var(--accent)">Name matching</a> covers how these
+names line up with the official registry.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Largest publishers <span class="side" id="scope-side"></span></h2>
+<div class="panel"><div class="panel-b"><div id="chart-cna"></div></div></div>
+
+<h2>Activity</h2>
+<div class="cols c2">
+  <div class="panel"><div class="panel-h">Publishers by first year <span class="side">when they started</span></div>
+    <div class="panel-b"><div id="chart-first"></div></div></div>
+  <div class="panel"><div class="panel-h">Status</div><div class="rows" id="status"></div></div>
+</div>
+
+<h2>Every publisher <span class="side" id="filter-count"></span></h2>
+<div class="panel">
+  <div class="panel-h" style="gap:12px;flex-wrap:wrap">
+    <label class="fl">Status
+      <select id="f-status"><option value="">Any</option></select></label>
+    <label class="fl">Type
+      <select id="f-type"><option value="">Any</option></select></label>
+    <label class="fl">Name
+      <input id="f-name" type="search" placeholder="filter&hellip;" autocomplete="off"></label>
+    <button class="exp-btn" id="f-reset">Reset</button>
+    <span class="side" id="f-note"></span>
+  </div>
+  <div id="cna-table"></div>
+</div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async () => {
+  const { fmt, chart, el, table } = CVE;
+  const YR = 2026;
+  const d = await CVE.json('cna_analysis.json');
+  const list = d.cna_list || [];
+  let scope = 'year';
+  const yearCount = c => (c.cves_by_year || {})[YR] || 0;
+
+  function render() {
+    const val = c => scope === 'year' ? yearCount(c) : c.count;
+    const activeNow = list.filter(c => yearCount(c) > 0);
+    const totalScope = list.reduce((s, c) => s + val(c), 0);
+    const ranked = list.slice().sort((a, b) => val(b) - val(a));
+    const top5 = ranked.slice(0, 5).reduce((s, c) => s + val(c), 0);
+
+    el('#tiles').innerHTML = [
+      { lead: 1, lbl: scope === 'year' ? `Attributed in ${YR}` : 'Attributed since 1999',
+        v: fmt.n(totalScope),
+        sub: `by <b>${fmt.n(scope === 'year' ? activeNow.length : list.length)}</b> publishers` },
+      { lbl: 'Publishers on record', v: fmt.n(d.total_cnas),
+        sub: `<b>${fmt.n(d.active_cnas)}</b> currently active` },
+      { lbl: 'Largest publisher', v: fmt.compact(val(ranked[0] || {})),
+        sub: `<b>${CVE.esc((ranked[0] || {}).name || '')}</b>` },
+      { lbl: 'Top 5 share', v: fmt.share(top5, totalScope, 0),
+        sub: 'of the CVEs in this view' }
+    ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+        <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+    chart.hbars('#chart-cna', ranked.slice(0, 15).filter(c => val(c) > 0)
+      .map(c => ({ label: c.name, value: val(c) })), { name: 'cve-icu-publishers' });
+    el('#scope-side').textContent = scope === 'year' ? `in ${YR}` : 'all time';
+
+    const byFirst = {};
+    list.forEach(c => { const y = c.first_cve_year; if (y) byFirst[y] = (byFirst[y] || 0) + 1; });
+    const firstYears = Object.keys(byFirst).sort();
+    chart.bars('#chart-first', firstYears.map(y => ({
+      label: y, value: byFirst[y], current: +y === YR
+    })), { ticks: [firstYears[0], firstYears[firstYears.length - 1]] , name: 'cve-icu-publishers-by-first-year' });
+
+    const byStatus = {};
+    list.forEach(c => { const s = c.activity_status || 'Unknown';
+      byStatus[s] = (byStatus[s] || 0) + 1; });
+    chart.rank('#status', Object.entries(byStatus)
+      .map(([k, v]) => ({ label: k, value: v })).sort((a, b) => b.value - a.value), { name: 'cve-icu-publisher-status' });
+
+    const statuses = [...new Set(list.map(c => c.activity_status).filter(Boolean))].sort();
+    const types = [...new Set(list.flatMap(c => c.cna_types || []).filter(Boolean))].sort();
+    const fill = (sel, vals) => {
+      const e = el(sel), keep = e.value;
+      e.innerHTML = '<option value="">Any</option>' +
+        vals.map(v => `<option value="${CVE.esc(v)}">${CVE.esc(v)}</option>`).join('');
+      e.value = keep;
+    };
+    fill('#f-status', statuses);
+    fill('#f-type', types);
+
+    const fStatus = el('#f-status').value;
+    const fType = el('#f-type').value;
+    const fName = (el('#f-name').value || '').trim().toLowerCase();
+    const filtered = list.filter(c =>
+      (!fStatus || c.activity_status === fStatus) &&
+      (!fType || (c.cna_types || []).includes(fType)) &&
+      (!fName || c.name.toLowerCase().includes(fName)));
+
+    el('#filter-count').textContent = filtered.length === list.length
+      ? `all ${fmt.n(list.length)}` : `${fmt.n(filtered.length)} of ${fmt.n(list.length)}`;
+    el('#f-note').textContent = filtered.length === list.length ? '' : 'filtered';
+
+    table('#cna-table', filtered.map(c => ({
+      name: c.name,
+      year: yearCount(c),
+      all: c.count,
+      kev: c.kev_count || 0,
+      since: c.first_cve_year || null,
+      active: c.years_active || 0,
+      status: c.activity_status || '—'
+    })), [
+      { key: 'name', label: 'Publisher' },
+      { key: 'year', label: String(YR), num: true, bar: true },
+      { key: 'all', label: 'All time', num: true, bar: true },
+      { key: 'kev', label: 'In KEV', num: true },
+      { key: 'since', label: 'Since', num: true, raw: true,
+        fmt: v => v == null ? '<span class="faint">&mdash;</span>' : String(v) },
+      { key: 'active', label: 'Years active', num: true, raw: true },
+      { key: 'status', label: 'Status',
+        fmt: v => `<span class="pill ${v === 'Active' ? 'live' : ''}">${CVE.esc(v)}</span>` }
+    ], { sort: { key: scope === 'year' ? 'year' : 'all', dir: -1 } });
+  }
+  render();
+
+  ['#f-status', '#f-type'].forEach(sel =>
+    el(sel).addEventListener('change', render));
+  let t;
+  el('#f-name').addEventListener('input', () => { clearTimeout(t); t = setTimeout(render, 160); });
+  el('#f-reset').addEventListener('click', () => {
+    el('#f-status').value = ''; el('#f-type').value = ''; el('#f-name').value = '';
+    render();
+  });
+
+  el('#scope').addEventListener('click', e => {
+    const b = e.target.closest('button[data-scope]'); if (!b) return;
+    scope = b.dataset.scope;
+    CVE.all('#scope button').forEach(x => x.classList.toggle('on', x === b));
+    render();
+  });
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/cpe.html b/web/cpe.html
new file mode 100644
index 00000000000..e3b1a0bb0d7
--- /dev/null
+++ b/web/cpe.html
@@ -0,0 +1,193 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>CVEs by product &mdash; CVEDB</title>
+
+<meta name="description" content="How many CVEs affect each vendor and product, counted from CPE records.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    >Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      >Publishers</a></li>
+    <li><a href="cpe.html"      class="on" aria-current="page">Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  >Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph"><h1>CVEs by product</h1><span class="note">from CPE records</span></div>
+<p class="lede">A CVE can list many affected products, so these counts sum to more than the
+number of CVEs. A product's count is how many CVEs name it, not how many bugs it has.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Vendors</h2>
+<div class="cols c2">
+  <div class="panel"><div class="panel-h">Most-named vendors</div><div class="rows" id="vendors"></div></div>
+  <div class="panel"><div class="panel-h">Most-named products</div><div class="rows" id="products"></div></div>
+</div>
+
+<h2>Platform type</h2>
+<div class="panel"><div class="panel-b"><div id="types"></div></div></div>
+
+<h2>Most-referenced CPE entries <span class="side">one row per CPE string, not per product</span></h2>
+<div class="panel"><div id="cpe-table"></div></div>
+
+<h2>CVEs naming the most products</h2>
+<div class="panel"><div class="rows" id="widest"></div></div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async () => {
+  const { fmt, chart, el, table } = CVE;
+  const d = await CVE.json('cpe_analysis.json');
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'CVEs with product data', v: fmt.n(d.total_cves_with_cpes),
+      sub: `<b>${fmt.n(d.average_cpes_per_cve)}</b> product entries per CVE on average` },
+    { lbl: 'Distinct vendors', v: fmt.n(d.total_unique_vendors), sub: 'named across all CVEs' },
+    { lbl: 'Distinct products', v: fmt.n(d.total_unique_products), sub: 'named across all CVEs' },
+    { lbl: 'Total CPE entries', v: fmt.compact(d.total_cpe_entries),
+      sub: `<b>${fmt.compact(d.total_unique_cpes)}</b> unique strings` }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  chart.rank('#vendors', (d.top_vendors || []).slice(0, 12)
+    .map(v => ({ label: v.vendor || v.name, value: v.count })), { compact: true , name: 'cve-icu-top-vendors' });
+  chart.rank('#products', (d.top_products || []).slice(0, 12)
+    .map(p => ({ label: p.product || p.name, sub: p.vendor, value: p.count })), { compact: true , name: 'cve-icu-top-products' });
+
+  chart.hbars('#types', (d.cpe_type_distribution || [])
+    .map(t => ({ label: t.type || t.name, value: t.count })), { name: 'cve-icu-platform-types' });
+
+  // A CPE string carries version, update, edition and architecture. Without them
+  // rows like windows_server_2012 r2 and windows_server_2012 - look identical.
+  const cpePart = (cpe, i) => {
+    const parts = String(cpe || '').split(':');
+    const v = parts[i];
+    return !v || v === '*' || v === '-' ? '' : v;
+  };
+  table('#cpe-table', (d.top_cpes || []).map(c => ({
+    vendor: c.vendor,
+    product: c.product,
+    version: cpePart(c.cpe, 5) || '—',
+    edition: [cpePart(c.cpe, 6), cpePart(c.cpe, 8), cpePart(c.cpe, 11)].filter(Boolean).join(' ') || '—',
+    type: c.type || '—',
+    cves: c.count
+  })), [
+    { key: 'vendor', label: 'Vendor' },
+    { key: 'product', label: 'Product' },
+    { key: 'version', label: 'Version' },
+    { key: 'edition', label: 'Edition / arch' },
+    { key: 'type', label: 'Type' },
+    { key: 'cves', label: 'References', num: true, bar: true }
+  ], { name: 'cve-icu-cpe-entries' });
+
+  chart.rank('#widest', (d.cves_with_most_cpes || []).slice(0, 10).map(c => ({
+    label: c.cve || c.cve_id, sub: 'product entries', value: c.cpe_count || c.count
+  })), { name: 'cve-icu-cves-naming-most-products' });
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/cvss.html b/web/cvss.html
new file mode 100644
index 00000000000..e1895922e40
--- /dev/null
+++ b/web/cvss.html
@@ -0,0 +1,212 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>CVSS scores &mdash; CVEDB</title>
+
+<meta name="description" content="How many CVEs carry each CVSS severity and score, by metric version.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    >Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      >Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  class="on" aria-current="page">Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph">
+  <h1>CVSS scores</h1>
+  <span class="note">severity, by metric version</span>
+  <span style="margin-left:auto"><span class="seg" id="vsel"></span></span>
+</div>
+<p class="lede">A CVE can hold a score under more than one CVSS version, so these counts add up
+to more than the number of CVEs. Each version is counted separately below.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Scores per version</h2>
+<div class="panel"><div class="panel-b"><div id="versions"></div></div></div>
+
+<h2>Severity bands <span class="side" id="sev-ver"></span></h2>
+<div class="panel"><div class="panel-b"><div id="sev"></div></div></div>
+
+<h2>Score distribution <span class="side" id="dist-ver"></span></h2>
+<div class="panel"><div class="panel-b"><div id="dist"></div></div></div>
+
+<h2>Scored CVEs per year</h2>
+<div class="panel"><div class="panel-b"><div id="by-year"></div></div></div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async () => {
+  const { fmt, chart, el } = CVE;
+  const YR = 2026;
+  const d = await CVE.json('cvss_analysis.json');
+  const versions = Object.keys(d.total_by_version || {});
+  let ver = versions.includes('v3.1') ? 'v3.1' : versions[versions.length - 1];
+
+  el('#vsel').innerHTML = versions.map(v =>
+    `<button data-v="${v}" class="${v === ver ? 'on' : ''}">${v}</button>`).join('');
+
+  chart.hbars('#versions', versions.map(v => ({ label: v, value: d.total_by_version[v] })), { name: 'cve-icu-cvss-by-version' });
+
+  const temporal = d.temporal_data || {};
+  const tYears = Object.keys(temporal).sort();
+  if (tYears.length) {
+    chart.bars('#by-year', tYears.map(y => ({
+      label: y,
+      value: typeof temporal[y] === 'number' ? temporal[y]
+        : (temporal[y].total || temporal[y].count || 0),
+      current: +y === YR
+    })), { ticks: [tYears[0], tYears[tYears.length - 1]] , name: 'cve-icu-cvss-scored-per-year' });
+  } else {
+    el('#by-year').innerHTML = '<div class="empty">No per-year breakdown in this dataset.</div>';
+  }
+
+  function render() {
+    const sev = (d.severity_distribution || {})[ver] || {};
+    const bins = (d.binned_score_distribution || {})[ver] || {};
+    const totalV = d.total_by_version[ver] || 0;
+    const order = ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'NONE', 'UNKNOWN'];
+    const sevRows = order.filter(k => sev[k]).map(k => ({ label: k, value: sev[k] }));
+
+    el('#tiles').innerHTML = [
+      { lead: 1, lbl: `Scores recorded under ${ver}`, v: fmt.n(totalV),
+        sub: `of <b>${fmt.n(d.total_cves_with_cvss)}</b> across all versions` },
+      { lbl: 'Highest band', v: fmt.n(sev.CRITICAL || sev.HIGH || 0),
+        sub: sev.CRITICAL ? `<b>${fmt.share(sev.CRITICAL, totalV)}</b> rated critical`
+          : 'this version has no critical band' },
+      { lbl: 'In the KEV catalog', v: fmt.n(d.kev_global_count),
+        sub: 'across all versions and years' },
+      { lbl: 'Metric versions in use', v: String(versions.length),
+        sub: versions.join(' &middot; ') }
+    ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+        <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+    el('#sev-ver').textContent = ver;
+    el('#dist-ver').textContent = ver;
+    if (sevRows.length) chart.hbars('#sev', sevRows, { name: 'cve-icu-cvss-severity' });
+    else el('#sev').innerHTML = '<div class="empty">No severity bands recorded for ' + ver + '.</div>';
+
+    const keys = Object.keys(bins).sort((a, b) => parseFloat(a) - parseFloat(b));
+    if (keys.length) {
+      chart.bars('#dist', keys.map(k => ({ label: k, value: bins[k] })),
+        { tall: true, ticks: [keys[0], keys[keys.length - 1]] , name: 'cve-icu-cvss-score-distribution' });
+    } else {
+      el('#dist').innerHTML = '<div class="empty">No score distribution for ' + ver + '.</div>';
+    }
+  }
+  render();
+
+  el('#vsel').addEventListener('click', e => {
+    const b = e.target.closest('button[data-v]'); if (!b) return;
+    ver = b.dataset.v;
+    CVE.all('#vsel button').forEach(x => x.classList.toggle('on', x === b));
+    render();
+  });
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/cwe.html b/web/cwe.html
new file mode 100644
index 00000000000..c39c33c4084
--- /dev/null
+++ b/web/cwe.html
@@ -0,0 +1,166 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>CVEs by weakness type &mdash; CVEDB</title>
+
+<meta name="description" content="How many CVEs carry each CWE weakness classification.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    >Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      >Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      class="on" aria-current="page">Weaknesses</a></li>
+    <li><a href="scoring.html"  >Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph"><h1>CVEs by weakness type</h1><span class="note">from CWE classifications</span></div>
+<p class="lede">Not every CVE carries a CWE. These counts cover the ones that do.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Most common weaknesses</h2>
+<div class="panel"><div class="panel-b"><div id="chart-cwe"></div></div></div>
+
+<h2>Every classified weakness</h2>
+<div class="panel"><div id="cwe-table"></div></div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async (S) => {
+  const { fmt, chart, el, table } = CVE;
+  const d = await CVE.json('cwe_analysis.json');
+  const total = Object.values(S.yearly_summary.years).reduce((s, y) => s + y.total_cves, 0);
+  const list = d.top_cwes || [];
+  const top = list[0] || {};
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'CVEs with a weakness type', v: fmt.n(d.total_cves_with_cwe),
+      sub: `<b>${fmt.share(d.total_cves_with_cwe, total)}</b> of all ${fmt.compact(total)} CVEs` },
+    { lbl: 'Distinct weakness types', v: fmt.n(d.total_unique_cwes), sub: 'seen at least once' },
+    { lbl: 'Most common', v: fmt.compact(top.count),
+      sub: `<b>${CVE.esc(top.description || '')}</b>` },
+    { lbl: 'Top 10 share', v: fmt.share(list.slice(0, 10).reduce((s, c) => s + c.count, 0),
+        d.total_cves_with_cwe, 0),
+      sub: 'of all classified CVEs' }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  chart.hbars('#chart-cwe', list.slice(0, 15)
+    .map(c => ({ label: 'CWE-' + c.id, value: c.count })), { compact: false , name: 'cve-icu-weakness-types' });
+
+  table('#cwe-table', list.map(c => ({
+    id: 'CWE-' + c.id, name: c.description || c.name, cves: c.count,
+    share: +(c.count / d.total_cves_with_cwe * 100).toFixed(2)
+  })), [
+    { key: 'id', label: 'CWE' },
+    { key: 'name', label: 'Weakness' },
+    { key: 'cves', label: 'CVEs', num: true, bar: true },
+    { key: 'share', label: 'Share', num: true, fmt: v => v + '%' }
+  ]);
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/data-quality.html b/web/data-quality.html
new file mode 100644
index 00000000000..8f8712053f0
--- /dev/null
+++ b/web/data-quality.html
@@ -0,0 +1,245 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>Publisher name matching &mdash; CVEDB</title>
+
+<meta name="description" content="How publisher names in CVE records line up with the official CNA registry.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    >Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      class="on" aria-current="page">Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  >Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph"><h1>Publisher name matching</h1><span class="note">against the official CNA registry</span></div>
+<p class="lede">Publisher names in CVE records do not always match the official registry exactly.
+This is the count of how many line up, and how.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>How names match</h2>
+<div class="panel"><div class="panel-b"><div id="chart-match"></div></div></div>
+
+<h2>Source agreement <span class="side">two pipelines, two record sets</span></h2>
+<div class="note-box" id="recon-note">
+  Yearly counts come from the NVD mirror. Publisher attribution comes from the CVE Program's
+  own cvelistV5 repository. They are different record sets, so a year can carry two slightly
+  different totals &mdash; measured below rather than hidden.
+</div>
+<div class="panel" style="margin-top:12px"><div id="recon-table"></div></div>
+
+<h2>Names that did not match exactly</h2>
+<div class="cols c2">
+  <div class="panel"><div class="panel-h">Matched another way <span class="side" id="n-soft"></span></div>
+    <div id="soft-table"></div></div>
+  <div class="panel"><div class="panel-h">No match found <span class="side" id="n-un"></span></div>
+    <div class="rows" id="unmatched"></div></div>
+</div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async () => {
+  const { fmt, chart, el, table } = CVE;
+  const d = await CVE.json('data_quality.json');
+  const s = d.stats || {};
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'Publishers checked', v: fmt.n(s.total_cnas_in_analysis),
+      sub: `against <b>${fmt.n(s.official_cna_registry_count)}</b> in the official registry` },
+    { lbl: 'Exact matches', v: fmt.n(s.exact_matches),
+      sub: `<b>${fmt.share(s.exact_matches, s.total_cnas_in_analysis)}</b> of those checked` },
+    { lbl: 'Matched another way', v: fmt.n((s.case_mismatches || 0) + (s.org_name_matches || 0)
+        + (s.normalized_matches || 0) + (s.partial_matches || 0)),
+      sub: 'case, organisation name, or partial' },
+    { lbl: 'No match', v: fmt.n(s.unmatched), sub: 'not found in the registry' }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  chart.hbars('#chart-match', [
+    { label: 'Exact', value: s.exact_matches || 0 },
+    { label: 'Case differs', value: s.case_mismatches || 0 },
+    { label: 'Organisation name', value: s.org_name_matches || 0 },
+    { label: 'Normalised', value: s.normalized_matches || 0 },
+    { label: 'Partial', value: s.partial_matches || 0 },
+    { label: 'No match', value: s.unmatched || 0 }
+  ].filter(x => x.value), { name: 'cve-icu-name-match-types' });
+
+  const soft = [
+    ...(d.case_mismatches || []).map(x => ({ ...x, how: 'Case differs' })),
+    ...(d.org_name_matches || []).map(x => ({ ...x, how: 'Organisation name' })),
+    ...(d.normalized_matches || []).map(x => ({ ...x, how: 'Normalised' })),
+    ...(d.partial_matches || []).map(x => ({ ...x, how: 'Partial' }))
+  ].map(x => ({
+    name: x.cna_name,
+    match: x.official_short_name || x.official_org_name || '—',
+    org: x.official_org_name || '—',
+    cves: x.cve_count || 0,
+    how: x.how,
+    confidence: x.confidence || '—'
+  }));
+  el('#n-soft').textContent = soft.length + ' publishers';
+  if (soft.length) {
+    table('#soft-table', soft, [
+      { key: 'name', label: 'In CVE records' },
+      { key: 'match', label: 'In the registry' },
+      { key: 'org', label: 'Organisation' },
+      { key: 'cves', label: 'CVEs', num: true },
+      { key: 'how', label: 'Matched by', fmt: v => `<span class="pill">${CVE.esc(v)}</span>` },
+      { key: 'confidence', label: 'Confidence',
+        fmt: v => `<span class="pill ${v === 'high' ? 'live' : v === 'low' ? 'warn' : ''}">${CVE.esc(v)}</span>` }
+    ], { sort: { key: 'cves', dir: -1 } }, { name: 'cve-icu-soft-matched-publishers' });
+  } else {
+    el('#soft-table').innerHTML = '<div class="empty">Every name matched exactly.</div>';
+  }
+
+  // per-year agreement between the NVD and V5 pipelines
+  try {
+    const r = await CVE.json('source_reconciliation.json');
+    const flagged = new Set(r.flagged_years || []);
+    table('#recon-table', (r.years || []).map(y => ({
+      year: y.year, nvd: y.nvd, v5: y.v5, delta: y.delta, pct: y.pct,
+      era: y.modern ? 'modern' : 'historical',
+      state: flagged.has(y.year) ? 'over threshold' : (y.delta === 0 ? 'identical' : 'within threshold')
+    })), [
+      { key: 'year', label: 'Year', num: true, raw: true },
+      { key: 'nvd', label: 'NVD count', num: true },
+      { key: 'v5', label: 'V5 count', num: true },
+      { key: 'delta', label: 'Difference', num: true,
+        fmt: v => v === 0 ? '<span class="faint">0</span>'
+          : `<span style="color:var(--${Math.abs(v) > 200 ? 'warn' : 'dim'})">${v > 0 ? '+' : ''}${fmt.n(v)}</span>` },
+      { key: 'pct', label: '%', num: true,
+        fmt: v => v === 0 ? '<span class="faint">0</span>' : v.toFixed(2) + '%' },
+      { key: 'era', label: 'Era',
+        fmt: v => `<span class="pill${v === 'historical' ? '' : ' live'}">${v}</span>` },
+      { key: 'state', label: 'Status',
+        fmt: v => `<span class="pill${v === 'over threshold' ? ' warn' : ''}">${CVE.esc(v)}</span>` }
+    ], { sort: { key: 'year', dir: -1 } }, { name: 'cve-icu-source-agreement-by-year' });
+
+    const t = r.totals || {};
+    el('#recon-note').insertAdjacentHTML('beforeend',
+      `<p style="margin-top:9px">Across all years: NVD <b>${fmt.n(t.nvd)}</b>,
+       cvelistV5 <b>${fmt.n(t.v5)}</b>, a difference of <b>${t.delta > 0 ? '+' : ''}${fmt.n(t.delta)}</b>.
+       Years before ${r.thresholds.modern_year_floor} predate the current publishing arrangements and
+       are recorded but not held to a threshold; from ${r.thresholds.modern_year_floor} on, a year must
+       agree within ${r.thresholds.max_abs} CVEs or ${r.thresholds.max_pct}% or the build warns.
+       ${flagged.size ? `<b style="color:var(--warn)">${flagged.size} year(s) currently over threshold.</b>`
+         : 'All modern years are currently within threshold.'}</p>`);
+  } catch (err) {
+    el('#recon-table').innerHTML = '<div class="empty">Reconciliation data not available.</div>';
+  }
+
+  const un = (d.unmatched || []).map(x => ({
+    label: x.cna_name, value: x.cve_count || 0
+  }));
+  el('#n-un').textContent = un.length + ' publishers';
+  if (un.length) chart.rank('#unmatched', un.sort((a, b) => b.value - a.value), { name: 'cve-icu-unmatched-publishers' });
+  else el('#unmatched').innerHTML = '<div class="empty">Nothing unmatched.</div>';
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/data/calendar_analysis.json b/web/data/calendar_analysis.json
new file mode 100644
index 00000000000..63e35d0d2c6
--- /dev/null
+++ b/web/data/calendar_analysis.json
@@ -0,0 +1,48505 @@
+{
+  "generated_at": "2026-09-23T22:55:40.227997",
+  "statistics": {
+    "total_cves": 378478,
+    "total_days_with_data": 8078,
+    "date_range": {
+      "start": "1988-10-01",
+      "end": "2026-09-23"
+    },
+    "daily_stats": {
+      "average_per_day": 46.85,
+      "max_per_day": 1559,
+      "min_per_day": 1,
+      "peak_day": {
+        "date": "2026-09-08",
+        "count": 1559
+      }
+    },
+    "cvss_stats": {
+      "average_score": 6.8,
+      "total_with_scores": 369500
+    },
+    "current_year": {
+      "year": 2026,
+      "total_cves": 69597,
+      "days_with_data": 264
+    }
+  },
+  "daily_data": [
+    {
+      "date": "1988-10-01",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1988-11-11",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1989-01-01",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1989-07-26",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1989-10-26",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1990-01-29",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1990-05-01",
+      "value": 1,
+      "avg_cvss": 8.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "1990-05-09",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1990-08-14",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1990-10-03",
+      "value": 3,
+      "avg_cvss": 7.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "1990-10-25",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1990-10-31",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1990-12-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1990-12-31",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-01-15",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-02-22",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-03-27",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1991-05-01",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-05-14",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-05-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-05-23",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-08-23",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-09-10",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-09-27",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-10-22",
+      "value": 1,
+      "avg_cvss": 6.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-12-06",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-12-18",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1991-12-31",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1992-02-25",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1992-03-01",
+      "value": 1,
+      "avg_cvss": 0.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1992-03-19",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1992-03-31",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1992-04-27",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1992-05-27",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1992-06-04",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1992-07-21",
+      "value": 2,
+      "avg_cvss": 8.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "1992-11-17",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1992-12-10",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1992-12-30",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1993-01-13",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1993-02-03",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1993-02-18",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1993-02-24",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1993-04-22",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1993-05-24",
+      "value": 1,
+      "avg_cvss": 6.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "1993-08-09",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1993-09-16",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1993-09-17",
+      "value": 2,
+      "avg_cvss": 8.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "1993-09-30",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1993-10-01",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1993-12-16",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-01-01",
+      "value": 1,
+      "avg_cvss": 6.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-02-07",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-02-14",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-02-24",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-03-21",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-04-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-05-04",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-05-13",
+      "value": 1,
+      "avg_cvss": 6.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-05-18",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-05-23",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-06-01",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-06-03",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-06-09",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-07-13",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-07-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-08-09",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-08-11",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-09-21",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-10-02",
+      "value": 1,
+      "avg_cvss": 6.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1994-11-30",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "1994-12-19",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-01-01",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-02-01",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-02-17",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-03-01",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-03-03",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1995-04-03",
+      "value": 1,
+      "avg_cvss": 7.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-05-10",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-07-31",
+      "value": 2,
+      "avg_cvss": 8.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "1995-08-02",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-08-17",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-08-23",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-08-29",
+      "value": 1,
+      "avg_cvss": 6.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-08-31",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-09-07",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-10-01",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-10-13",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-10-19",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-11-01",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-11-30",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1995-12-01",
+      "value": 3,
+      "avg_cvss": 6.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "1995-12-12",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-01-02",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-01-03",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-02-02",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-02-08",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-02-21",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-02-25",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-03-01",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-03-20",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-03-29",
+      "value": 1,
+      "avg_cvss": 3.7,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-04-01",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-04-03",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-04-18",
+      "value": 1,
+      "avg_cvss": 1.9,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-04-24",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-05-17",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-05-23",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-05-28",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-05-29",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-06-07",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "1996-06-26",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-07-01",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-07-03",
+      "value": 1,
+      "avg_cvss": 7.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-07-09",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-07-16",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1996-07-24",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-07-25",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-07-31",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-08-03",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-08-06",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-08-14",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-08-15",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-08-21",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-08-26",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-08-30",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-09-01",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-09-04",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-09-11",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-09-13",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-09-17",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-09-19",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-09-21",
+      "value": 1,
+      "avg_cvss": 6.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-10-01",
+      "value": 4,
+      "avg_cvss": 8.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "1996-10-08",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-10-16",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-10-25",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-10-28",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-10-30",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-11-01",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1996-11-03",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-11-16",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-11-17",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-11-22",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-11-26",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-12-01",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-12-03",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "1996-12-04",
+      "value": 1,
+      "avg_cvss": 9.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-12-05",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-12-10",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "1996-12-12",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-12-13",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-12-18",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-12-19",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1996-12-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1996-12-24",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-01-01",
+      "value": 41,
+      "avg_cvss": 6.5,
+      "cvss_count": 41
+    },
+    {
+      "date": "1997-01-04",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-01-06",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-01-07",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-01-08",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-01-09",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-01-11",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-01-27",
+      "value": 2,
+      "avg_cvss": 8.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-01-28",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-01-30",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-02-01",
+      "value": 4,
+      "avg_cvss": 7.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "1997-02-02",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-02-03",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-02-05",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-02-06",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-02-07",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-02-10",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-02-13",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-02-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-03-01",
+      "value": 6,
+      "avg_cvss": 4.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "1997-03-04",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-03-05",
+      "value": 2,
+      "avg_cvss": 5.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-03-14",
+      "value": 1,
+      "avg_cvss": 5.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-04-01",
+      "value": 3,
+      "avg_cvss": 6.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "1997-04-02",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-04-07",
+      "value": 2,
+      "avg_cvss": 8.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-04-17",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-04-19",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-04-26",
+      "value": 1,
+      "avg_cvss": 8.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-04-29",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-05-01",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-05-03",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-05-04",
+      "value": 1,
+      "avg_cvss": 5.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-05-05",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-05-06",
+      "value": 1,
+      "avg_cvss": 7.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-05-07",
+      "value": 3,
+      "avg_cvss": 6.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "1997-05-09",
+      "value": 2,
+      "avg_cvss": 6.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-05-13",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-05-14",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-05-15",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-05-16",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-05-17",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-05-19",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-05-21",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-05-23",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-05-26",
+      "value": 2,
+      "avg_cvss": 7.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-05-28",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-05-29",
+      "value": 2,
+      "avg_cvss": 6.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-06-01",
+      "value": 4,
+      "avg_cvss": 5.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "1997-06-04",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-06-10",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-06-11",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-06-12",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-06-13",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-06-18",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-06-19",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-06-24",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-06-26",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-07-01",
+      "value": 17,
+      "avg_cvss": 6.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "1997-07-04",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-07-08",
+      "value": 2,
+      "avg_cvss": 3.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-07-10",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-07-14",
+      "value": 1,
+      "avg_cvss": 7.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-07-15",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-07-16",
+      "value": 6,
+      "avg_cvss": 7.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "1997-07-17",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-07-21",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "1997-07-22",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-07-23",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-07-25",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-07-30",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-07-31",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-08-01",
+      "value": 5,
+      "avg_cvss": 6.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "1997-08-05",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-08-11",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-08-13",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-08-19",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-08-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-08-24",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-09-01",
+      "value": 9,
+      "avg_cvss": 6.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "1997-09-08",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-09-12",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-09-15",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-09-19",
+      "value": 4,
+      "avg_cvss": 8.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "1997-09-23",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-09-30",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-10-01",
+      "value": 9,
+      "avg_cvss": 6.3,
+      "cvss_count": 9
+    },
+    {
+      "date": "1997-10-02",
+      "value": 1,
+      "avg_cvss": 5.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-10-04",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-10-06",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-10-08",
+      "value": 1,
+      "avg_cvss": 3.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-10-16",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-10-18",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-10-19",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-10-22",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-10-24",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-10-28",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-10-29",
+      "value": 5,
+      "avg_cvss": 6.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "1997-11-01",
+      "value": 4,
+      "avg_cvss": 6.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "1997-11-04",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-11-05",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-11-08",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-11-10",
+      "value": 5,
+      "avg_cvss": 6.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "1997-11-12",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-11-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-11-26",
+      "value": 2,
+      "avg_cvss": 8.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1997-12-01",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "1997-12-05",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-12-10",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-12-14",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-12-15",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-12-16",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "1997-12-23",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-12-24",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-12-29",
+      "value": 1,
+      "avg_cvss": 6.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "1997-12-30",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-01-01",
+      "value": 8,
+      "avg_cvss": 6.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "1998-01-02",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-01-05",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-01-08",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-01-10",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-01-12",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-01-15",
+      "value": 2,
+      "avg_cvss": 6.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-01-21",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-01-22",
+      "value": 1,
+      "avg_cvss": 8.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-01-25",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-01-27",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-02-01",
+      "value": 6,
+      "avg_cvss": 6.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "1998-02-02",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-02-06",
+      "value": 2,
+      "avg_cvss": 4.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-02-13",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-02-14",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-02-18",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-02-20",
+      "value": 2,
+      "avg_cvss": 8.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-02-21",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-02-25",
+      "value": 2,
+      "avg_cvss": 1.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-03-01",
+      "value": 7,
+      "avg_cvss": 7.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "1998-03-09",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-03-11",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-03-16",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-03-18",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-03-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-04-01",
+      "value": 6,
+      "avg_cvss": 7.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "1998-04-02",
+      "value": 1,
+      "avg_cvss": 7.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-04-03",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-04-06",
+      "value": 1,
+      "avg_cvss": 3.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-04-07",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-04-08",
+      "value": 11,
+      "avg_cvss": 6.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "1998-04-10",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-04-14",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-04-28",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-04-29",
+      "value": 3,
+      "avg_cvss": 7.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "1998-05-01",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-05-03",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-05-07",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-05-09",
+      "value": 1,
+      "avg_cvss": 6.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-05-10",
+      "value": 2,
+      "avg_cvss": 10.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-05-11",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-05-14",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-05-15",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-05-16",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-05-21",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-05-27",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-05-28",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-06-01",
+      "value": 4,
+      "avg_cvss": 5.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "1998-06-02",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-06-03",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-06-08",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-06-10",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-06-11",
+      "value": 3,
+      "avg_cvss": 3.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "1998-06-12",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-06-16",
+      "value": 1,
+      "avg_cvss": 5.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-06-22",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-06-24",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-06-26",
+      "value": 4,
+      "avg_cvss": 6.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "1998-06-29",
+      "value": 2,
+      "avg_cvss": 4.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-06-30",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-07-01",
+      "value": 3,
+      "avg_cvss": 6.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "1998-07-03",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-07-06",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-07-07",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-07-08",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-07-09",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-07-10",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-07-11",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-07-13",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-07-14",
+      "value": 1,
+      "avg_cvss": 9.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-07-15",
+      "value": 4,
+      "avg_cvss": 6.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "1998-07-16",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "1998-07-20",
+      "value": 4,
+      "avg_cvss": 7.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "1998-07-25",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-07-28",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-07-29",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-07-30",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-08-01",
+      "value": 6,
+      "avg_cvss": 6.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "1998-08-03",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-08-04",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-08-07",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-08-12",
+      "value": 1,
+      "avg_cvss": 3.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-08-14",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-08-18",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-08-23",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-08-27",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-08-31",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-09-01",
+      "value": 5,
+      "avg_cvss": 6.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "1998-09-03",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-09-04",
+      "value": 1,
+      "avg_cvss": 2.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-09-05",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-09-09",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-09-18",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-09-22",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-09-25",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-09-27",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-09-29",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-10-01",
+      "value": 5,
+      "avg_cvss": 6.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "1998-10-02",
+      "value": 3,
+      "avg_cvss": 5.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "1998-10-05",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-10-06",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-10-08",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-10-12",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-10-13",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-10-26",
+      "value": 2,
+      "avg_cvss": 8.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-11-01",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-11-02",
+      "value": 2,
+      "avg_cvss": 8.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-11-04",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-11-05",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-11-09",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "1998-11-11",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-11-12",
+      "value": 2,
+      "avg_cvss": 4.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-11-16",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-11-18",
+      "value": 4,
+      "avg_cvss": 5.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "1998-11-19",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-11-26",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-11-30",
+      "value": 3,
+      "avg_cvss": 7.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "1998-12-01",
+      "value": 7,
+      "avg_cvss": 6.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "1998-12-02",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-12-03",
+      "value": 3,
+      "avg_cvss": 9.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "1998-12-04",
+      "value": 2,
+      "avg_cvss": 8.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-12-07",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-12-10",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-12-12",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-12-17",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-12-18",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-12-24",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-12-25",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1998-12-26",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-12-27",
+      "value": 2,
+      "avg_cvss": 3.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1998-12-29",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-01-01",
+      "value": 112,
+      "avg_cvss": 7.8,
+      "cvss_count": 112
+    },
+    {
+      "date": "1999-01-02",
+      "value": 4,
+      "avg_cvss": 6.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-01-03",
+      "value": 3,
+      "avg_cvss": 6.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-01-04",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-01-05",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-01-06",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-01-07",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-01-10",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-01-11",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-01-14",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-01-17",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-01-19",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-01-21",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-01-24",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-01-25",
+      "value": 4,
+      "avg_cvss": 7.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-01-26",
+      "value": 4,
+      "avg_cvss": 7.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-01-27",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-01-28",
+      "value": 2,
+      "avg_cvss": 8.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-01-29",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-01-30",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-02-01",
+      "value": 6,
+      "avg_cvss": 6.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "1999-02-02",
+      "value": 5,
+      "avg_cvss": 5.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-02-04",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-02-06",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-02-08",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-02-09",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-02-10",
+      "value": 2,
+      "avg_cvss": 7.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-02-11",
+      "value": 2,
+      "avg_cvss": 3.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-02-12",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-02-14",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-02-15",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-02-16",
+      "value": 3,
+      "avg_cvss": 4.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-02-17",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-02-18",
+      "value": 3,
+      "avg_cvss": 5.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-02-19",
+      "value": 8,
+      "avg_cvss": 5.1,
+      "cvss_count": 8
+    },
+    {
+      "date": "1999-02-20",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-02-21",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-02-22",
+      "value": 4,
+      "avg_cvss": 5.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-02-23",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-02-24",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-02-25",
+      "value": 3,
+      "avg_cvss": 5.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-02-26",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-03-01",
+      "value": 22,
+      "avg_cvss": 5.6,
+      "cvss_count": 22
+    },
+    {
+      "date": "1999-03-02",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-03-04",
+      "value": 3,
+      "avg_cvss": 3.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-03-05",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-03-07",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-03-08",
+      "value": 4,
+      "avg_cvss": 5.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-03-09",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-03-11",
+      "value": 3,
+      "avg_cvss": 5.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-03-12",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-03-17",
+      "value": 4,
+      "avg_cvss": 6.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-03-18",
+      "value": 2,
+      "avg_cvss": 4.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-03-21",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-03-22",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-03-23",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-03-26",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-03-30",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-03-31",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-04-01",
+      "value": 12,
+      "avg_cvss": 5.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "1999-04-05",
+      "value": 3,
+      "avg_cvss": 4.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-04-06",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-04-07",
+      "value": 3,
+      "avg_cvss": 4.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-04-09",
+      "value": 6,
+      "avg_cvss": 6.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "1999-04-12",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-04-14",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-04-15",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-04-19",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-04-20",
+      "value": 3,
+      "avg_cvss": 4.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-04-21",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-04-23",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-04-27",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-04-29",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-05-01",
+      "value": 8,
+      "avg_cvss": 6.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "1999-05-04",
+      "value": 2,
+      "avg_cvss": 5.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-05-05",
+      "value": 1,
+      "avg_cvss": 5.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-05-06",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-05-07",
+      "value": 6,
+      "avg_cvss": 4.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "1999-05-08",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-05-10",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-05-11",
+      "value": 5,
+      "avg_cvss": 6.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-05-12",
+      "value": 3,
+      "avg_cvss": 5.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-05-13",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-05-15",
+      "value": 1,
+      "avg_cvss": 3.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-05-17",
+      "value": 4,
+      "avg_cvss": 6.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-05-19",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-05-20",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-05-21",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-05-23",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-05-24",
+      "value": 1,
+      "avg_cvss": 2.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-05-25",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-05-26",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-05-27",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-05-28",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-05-31",
+      "value": 2,
+      "avg_cvss": 5.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-06-01",
+      "value": 7,
+      "avg_cvss": 6.1,
+      "cvss_count": 7
+    },
+    {
+      "date": "1999-06-03",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-06-05",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-06-06",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-06-07",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-06-08",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-06-09",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-06-10",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-06-11",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-06-12",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-06-16",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-06-22",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-06-23",
+      "value": 3,
+      "avg_cvss": 6.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-06-24",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-06-25",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-06-26",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-06-28",
+      "value": 3,
+      "avg_cvss": 8.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-06-29",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-06-30",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-07-01",
+      "value": 5,
+      "avg_cvss": 7.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-07-02",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-07-03",
+      "value": 1,
+      "avg_cvss": 7.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-07-06",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-07-07",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-07-09",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-07-10",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-07-11",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-07-13",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-07-14",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-07-15",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-07-19",
+      "value": 3,
+      "avg_cvss": 8.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-07-20",
+      "value": 3,
+      "avg_cvss": 8.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-07-21",
+      "value": 4,
+      "avg_cvss": 6.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-07-23",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-07-25",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-07-27",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-07-28",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-07-29",
+      "value": 3,
+      "avg_cvss": 5.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-07-30",
+      "value": 4,
+      "avg_cvss": 6.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-08-01",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-08-03",
+      "value": 3,
+      "avg_cvss": 5.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-08-05",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-08-06",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-08-07",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-08-08",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-08-09",
+      "value": 4,
+      "avg_cvss": 5.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-08-10",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-08-11",
+      "value": 5,
+      "avg_cvss": 5.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-08-12",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-08-13",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-08-16",
+      "value": 3,
+      "avg_cvss": 4.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-08-17",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-08-18",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-08-19",
+      "value": 5,
+      "avg_cvss": 6.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-08-20",
+      "value": 5,
+      "avg_cvss": 5.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-08-21",
+      "value": 2,
+      "avg_cvss": 6.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-08-22",
+      "value": 3,
+      "avg_cvss": 10.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-08-23",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-08-24",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-08-25",
+      "value": 4,
+      "avg_cvss": 6.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-08-26",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-08-27",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-08-30",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-08-31",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-09-01",
+      "value": 5,
+      "avg_cvss": 5.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-09-02",
+      "value": 4,
+      "avg_cvss": 4.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-09-03",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-09-05",
+      "value": 2,
+      "avg_cvss": 3.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-09-07",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-09-08",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-09-09",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-09-10",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-09-12",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-09-13",
+      "value": 8,
+      "avg_cvss": 6.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "1999-09-15",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-09-16",
+      "value": 5,
+      "avg_cvss": 7.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-09-17",
+      "value": 2,
+      "avg_cvss": 5.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-09-20",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-09-21",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-09-22",
+      "value": 2,
+      "avg_cvss": 3.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-09-23",
+      "value": 6,
+      "avg_cvss": 6.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "1999-09-24",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-09-26",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-09-27",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-09-28",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-09-29",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-09-30",
+      "value": 4,
+      "avg_cvss": 6.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-10-01",
+      "value": 9,
+      "avg_cvss": 5.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "1999-10-04",
+      "value": 6,
+      "avg_cvss": 6.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "1999-10-05",
+      "value": 3,
+      "avg_cvss": 6.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-10-06",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-10-07",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-10-08",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-10-11",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-10-13",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-10-15",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-10-17",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-10-18",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-10-20",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-10-21",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-10-22",
+      "value": 4,
+      "avg_cvss": 7.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-10-23",
+      "value": 3,
+      "avg_cvss": 7.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-10-24",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-10-25",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-10-26",
+      "value": 4,
+      "avg_cvss": 5.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-10-28",
+      "value": 4,
+      "avg_cvss": 5.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-10-29",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-10-30",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-10-31",
+      "value": 1,
+      "avg_cvss": 5.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-11-01",
+      "value": 7,
+      "avg_cvss": 5.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "1999-11-02",
+      "value": 5,
+      "avg_cvss": 6.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-11-03",
+      "value": 2,
+      "avg_cvss": 4.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-11-04",
+      "value": 9,
+      "avg_cvss": 6.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "1999-11-07",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-11-08",
+      "value": 5,
+      "avg_cvss": 5.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-11-09",
+      "value": 6,
+      "avg_cvss": 7.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "1999-11-10",
+      "value": 8,
+      "avg_cvss": 6.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "1999-11-11",
+      "value": 1,
+      "avg_cvss": 5.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-11-12",
+      "value": 2,
+      "avg_cvss": 6.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-11-13",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-11-14",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-11-15",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-11-16",
+      "value": 4,
+      "avg_cvss": 7.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-11-17",
+      "value": 4,
+      "avg_cvss": 4.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-11-18",
+      "value": 2,
+      "avg_cvss": 10.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-11-19",
+      "value": 3,
+      "avg_cvss": 4.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-11-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-11-22",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-11-23",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-11-24",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-11-25",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-11-29",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-11-30",
+      "value": 4,
+      "avg_cvss": 7.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-12-01",
+      "value": 16,
+      "avg_cvss": 5.3,
+      "cvss_count": 16
+    },
+    {
+      "date": "1999-12-02",
+      "value": 6,
+      "avg_cvss": 3.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "1999-12-03",
+      "value": 7,
+      "avg_cvss": 5.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "1999-12-04",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-12-05",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-12-06",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-12-07",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-12-08",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-12-09",
+      "value": 3,
+      "avg_cvss": 8.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-12-10",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-12-12",
+      "value": 2,
+      "avg_cvss": 3.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-12-13",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-12-14",
+      "value": 3,
+      "avg_cvss": 3.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-12-15",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-12-16",
+      "value": 6,
+      "avg_cvss": 5.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "1999-12-19",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-12-20",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-12-21",
+      "value": 7,
+      "avg_cvss": 6.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "1999-12-22",
+      "value": 9,
+      "avg_cvss": 6.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "1999-12-23",
+      "value": 4,
+      "avg_cvss": 6.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-12-24",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "1999-12-25",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "1999-12-26",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "1999-12-27",
+      "value": 5,
+      "avg_cvss": 6.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-12-28",
+      "value": 5,
+      "avg_cvss": 5.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-12-29",
+      "value": 5,
+      "avg_cvss": 6.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "1999-12-30",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "1999-12-31",
+      "value": 92,
+      "avg_cvss": 5.6,
+      "cvss_count": 92
+    },
+    {
+      "date": "2000-01-01",
+      "value": 3,
+      "avg_cvss": 5.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-01-02",
+      "value": 3,
+      "avg_cvss": 6.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-01-04",
+      "value": 13,
+      "avg_cvss": 7.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2000-01-05",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-01-06",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-01-07",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-01-08",
+      "value": 2,
+      "avg_cvss": 10.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-01-10",
+      "value": 3,
+      "avg_cvss": 6.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-01-11",
+      "value": 4,
+      "avg_cvss": 5.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-01-12",
+      "value": 4,
+      "avg_cvss": 6.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-01-13",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-01-17",
+      "value": 5,
+      "avg_cvss": 5.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-01-18",
+      "value": 4,
+      "avg_cvss": 7.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-01-19",
+      "value": 1,
+      "avg_cvss": 6.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-01-20",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-01-21",
+      "value": 3,
+      "avg_cvss": 8.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-01-24",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-01-26",
+      "value": 4,
+      "avg_cvss": 5.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-01-27",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-01-29",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-01-30",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-01-31",
+      "value": 2,
+      "avg_cvss": 6.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-02-01",
+      "value": 20,
+      "avg_cvss": 6.9,
+      "cvss_count": 20
+    },
+    {
+      "date": "2000-02-02",
+      "value": 3,
+      "avg_cvss": 5.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-02-03",
+      "value": 5,
+      "avg_cvss": 5.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-02-04",
+      "value": 3,
+      "avg_cvss": 4.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-02-05",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-02-06",
+      "value": 1,
+      "avg_cvss": 3.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-02-07",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-02-08",
+      "value": 4,
+      "avg_cvss": 5.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-02-10",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-02-11",
+      "value": 3,
+      "avg_cvss": 6.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-02-12",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-02-14",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-02-15",
+      "value": 3,
+      "avg_cvss": 4.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-02-16",
+      "value": 4,
+      "avg_cvss": 5.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-02-17",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-02-18",
+      "value": 3,
+      "avg_cvss": 6.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-02-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-02-21",
+      "value": 4,
+      "avg_cvss": 5.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-02-23",
+      "value": 4,
+      "avg_cvss": 5.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-02-24",
+      "value": 6,
+      "avg_cvss": 5.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2000-02-25",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-02-26",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-02-27",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-02-28",
+      "value": 6,
+      "avg_cvss": 6.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2000-02-29",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-03-01",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-03-02",
+      "value": 4,
+      "avg_cvss": 7.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-03-03",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-03-04",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-03-05",
+      "value": 2,
+      "avg_cvss": 5.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-03-06",
+      "value": 1,
+      "avg_cvss": 5.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-03-07",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-03-08",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-03-09",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-03-10",
+      "value": 3,
+      "avg_cvss": 5.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-03-11",
+      "value": 3,
+      "avg_cvss": 6.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-03-13",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-03-14",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-03-15",
+      "value": 4,
+      "avg_cvss": 6.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-03-16",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-03-17",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-03-20",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-03-21",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-03-22",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-03-23",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-03-25",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-03-26",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-03-27",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-03-29",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-03-30",
+      "value": 3,
+      "avg_cvss": 4.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-03-31",
+      "value": 4,
+      "avg_cvss": 5.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-04-01",
+      "value": 1,
+      "avg_cvss": 2.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-04-03",
+      "value": 4,
+      "avg_cvss": 5.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-04-04",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-04-05",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-04-06",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-04-07",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-04-09",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-04-10",
+      "value": 4,
+      "avg_cvss": 3.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-04-11",
+      "value": 6,
+      "avg_cvss": 7.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2000-04-12",
+      "value": 8,
+      "avg_cvss": 6.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2000-04-14",
+      "value": 4,
+      "avg_cvss": 7.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-04-16",
+      "value": 5,
+      "avg_cvss": 4.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-04-17",
+      "value": 2,
+      "avg_cvss": 3.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-04-18",
+      "value": 5,
+      "avg_cvss": 3.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-04-19",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-04-20",
+      "value": 5,
+      "avg_cvss": 4.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-04-21",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-04-22",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-04-23",
+      "value": 2,
+      "avg_cvss": 5.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-04-24",
+      "value": 8,
+      "avg_cvss": 7.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2000-04-25",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-04-26",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-04-27",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-04-28",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-04-29",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-05-01",
+      "value": 8,
+      "avg_cvss": 6.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2000-05-02",
+      "value": 8,
+      "avg_cvss": 5.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2000-05-03",
+      "value": 7,
+      "avg_cvss": 6.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2000-05-04",
+      "value": 4,
+      "avg_cvss": 6.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-05-05",
+      "value": 3,
+      "avg_cvss": 5.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-05-06",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-05-08",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-05-09",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-05-10",
+      "value": 5,
+      "avg_cvss": 4.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-05-11",
+      "value": 7,
+      "avg_cvss": 6.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2000-05-12",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-05-13",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-05-15",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-05-16",
+      "value": 10,
+      "avg_cvss": 7.5,
+      "cvss_count": 10
+    },
+    {
+      "date": "2000-05-17",
+      "value": 5,
+      "avg_cvss": 6.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-05-18",
+      "value": 6,
+      "avg_cvss": 6.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2000-05-19",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-05-22",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-05-23",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-05-24",
+      "value": 10,
+      "avg_cvss": 6.5,
+      "cvss_count": 10
+    },
+    {
+      "date": "2000-05-25",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-05-26",
+      "value": 2,
+      "avg_cvss": 3.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-05-27",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-05-28",
+      "value": 2,
+      "avg_cvss": 2.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-05-29",
+      "value": 4,
+      "avg_cvss": 4.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-05-30",
+      "value": 5,
+      "avg_cvss": 4.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-05-31",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-06-01",
+      "value": 10,
+      "avg_cvss": 7.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2000-06-02",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-06-04",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-06-05",
+      "value": 8,
+      "avg_cvss": 5.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2000-06-06",
+      "value": 6,
+      "avg_cvss": 6.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2000-06-07",
+      "value": 7,
+      "avg_cvss": 6.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2000-06-08",
+      "value": 8,
+      "avg_cvss": 6.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2000-06-09",
+      "value": 9,
+      "avg_cvss": 6.1,
+      "cvss_count": 9
+    },
+    {
+      "date": "2000-06-11",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-06-12",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-06-13",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-06-14",
+      "value": 5,
+      "avg_cvss": 6.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-06-15",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-06-16",
+      "value": 5,
+      "avg_cvss": 5.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-06-17",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-06-19",
+      "value": 5,
+      "avg_cvss": 5.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-06-20",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-06-21",
+      "value": 13,
+      "avg_cvss": 5.5,
+      "cvss_count": 13
+    },
+    {
+      "date": "2000-06-22",
+      "value": 5,
+      "avg_cvss": 5.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-06-23",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-06-24",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-06-25",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-06-26",
+      "value": 6,
+      "avg_cvss": 6.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2000-06-27",
+      "value": 5,
+      "avg_cvss": 6.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-06-29",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-06-30",
+      "value": 6,
+      "avg_cvss": 5.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2000-07-01",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-07-02",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-07-03",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-07-04",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-07-05",
+      "value": 6,
+      "avg_cvss": 5.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2000-07-07",
+      "value": 4,
+      "avg_cvss": 6.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-07-08",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-07-10",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-07-11",
+      "value": 6,
+      "avg_cvss": 5.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2000-07-12",
+      "value": 8,
+      "avg_cvss": 6.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2000-07-13",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-07-14",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-07-16",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-07-17",
+      "value": 4,
+      "avg_cvss": 6.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-07-18",
+      "value": 5,
+      "avg_cvss": 4.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-07-19",
+      "value": 4,
+      "avg_cvss": 5.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-07-20",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2000-07-21",
+      "value": 5,
+      "avg_cvss": 5.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2000-07-24",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-07-25",
+      "value": 6,
+      "avg_cvss": 4.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2000-07-26",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-07-27",
+      "value": 3,
+      "avg_cvss": 4.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2000-08-03",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-08-08",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-08-29",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-09-16",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-09-28",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-09-30",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-10-06",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-10-13",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-10-14",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-10-18",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-10-20",
+      "value": 130,
+      "avg_cvss": 6.3,
+      "cvss_count": 130
+    },
+    {
+      "date": "2000-11-01",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2000-11-14",
+      "value": 68,
+      "avg_cvss": 6.3,
+      "cvss_count": 68
+    },
+    {
+      "date": "2000-11-20",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-11-21",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-11-23",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-12-10",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-12-11",
+      "value": 79,
+      "avg_cvss": 6.8,
+      "cvss_count": 79
+    },
+    {
+      "date": "2000-12-14",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-12-16",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-12-18",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-12-19",
+      "value": 108,
+      "avg_cvss": 6.5,
+      "cvss_count": 108
+    },
+    {
+      "date": "2000-12-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2000-12-31",
+      "value": 20,
+      "avg_cvss": 6.2,
+      "cvss_count": 20
+    },
+    {
+      "date": "2001-01-01",
+      "value": 4,
+      "avg_cvss": 5.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-01-08",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-01-09",
+      "value": 111,
+      "avg_cvss": 5.7,
+      "cvss_count": 111
+    },
+    {
+      "date": "2001-01-10",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-01-11",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-01-12",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-01-18",
+      "value": 8,
+      "avg_cvss": 5.9,
+      "cvss_count": 8
+    },
+    {
+      "date": "2001-01-19",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-01-23",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-02-07",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-02-09",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-02-12",
+      "value": 72,
+      "avg_cvss": 6.4,
+      "cvss_count": 72
+    },
+    {
+      "date": "2001-02-16",
+      "value": 37,
+      "avg_cvss": 5.7,
+      "cvss_count": 37
+    },
+    {
+      "date": "2001-02-23",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-02-28",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-03-01",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-03-03",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-03-12",
+      "value": 71,
+      "avg_cvss": 5.2,
+      "cvss_count": 71
+    },
+    {
+      "date": "2001-03-13",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-03-26",
+      "value": 30,
+      "avg_cvss": 6.2,
+      "cvss_count": 30
+    },
+    {
+      "date": "2001-04-10",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-04-11",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-04-17",
+      "value": 11,
+      "avg_cvss": 3.5,
+      "cvss_count": 11
+    },
+    {
+      "date": "2001-04-20",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-04-21",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-05-03",
+      "value": 82,
+      "avg_cvss": 6.8,
+      "cvss_count": 82
+    },
+    {
+      "date": "2001-05-10",
+      "value": 2,
+      "avg_cvss": 4.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-05-11",
+      "value": 1,
+      "avg_cvss": 2.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-05-12",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-05-16",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-05-18",
+      "value": 1,
+      "avg_cvss": 1.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-05-21",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-05-22",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-05-24",
+      "value": 7,
+      "avg_cvss": 6.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2001-05-27",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-05-28",
+      "value": 5,
+      "avg_cvss": 6.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2001-05-29",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-05-30",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-06-02",
+      "value": 51,
+      "avg_cvss": 5.6,
+      "cvss_count": 51
+    },
+    {
+      "date": "2001-06-05",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-06-06",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-06-08",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-06-11",
+      "value": 6,
+      "avg_cvss": 5.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2001-06-12",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-06-13",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-06-15",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-06-16",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-06-18",
+      "value": 44,
+      "avg_cvss": 6.3,
+      "cvss_count": 44
+    },
+    {
+      "date": "2001-06-19",
+      "value": 2,
+      "avg_cvss": 8.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-06-21",
+      "value": 2,
+      "avg_cvss": 5.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-06-22",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-06-23",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-06-26",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-06-27",
+      "value": 85,
+      "avg_cvss": 6.0,
+      "cvss_count": 85
+    },
+    {
+      "date": "2001-06-28",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-06-29",
+      "value": 5,
+      "avg_cvss": 5.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2001-06-30",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-07-01",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-07-02",
+      "value": 45,
+      "avg_cvss": 6.3,
+      "cvss_count": 45
+    },
+    {
+      "date": "2001-07-03",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-07-04",
+      "value": 3,
+      "avg_cvss": 5.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-07-05",
+      "value": 4,
+      "avg_cvss": 5.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-07-06",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-07-07",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-07-09",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-07-10",
+      "value": 3,
+      "avg_cvss": 5.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-07-11",
+      "value": 8,
+      "avg_cvss": 5.9,
+      "cvss_count": 8
+    },
+    {
+      "date": "2001-07-12",
+      "value": 9,
+      "avg_cvss": 4.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2001-07-13",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-07-16",
+      "value": 20,
+      "avg_cvss": 7.2,
+      "cvss_count": 20
+    },
+    {
+      "date": "2001-07-17",
+      "value": 9,
+      "avg_cvss": 7.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2001-07-18",
+      "value": 4,
+      "avg_cvss": 4.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-07-19",
+      "value": 12,
+      "avg_cvss": 7.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2001-07-20",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-07-21",
+      "value": 34,
+      "avg_cvss": 6.4,
+      "cvss_count": 34
+    },
+    {
+      "date": "2001-07-22",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-07-23",
+      "value": 3,
+      "avg_cvss": 6.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-07-24",
+      "value": 3,
+      "avg_cvss": 4.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-07-25",
+      "value": 3,
+      "avg_cvss": 8.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-07-26",
+      "value": 5,
+      "avg_cvss": 6.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2001-07-27",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-07-29",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-07-30",
+      "value": 4,
+      "avg_cvss": 5.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-07-31",
+      "value": 2,
+      "avg_cvss": 8.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-08-02",
+      "value": 24,
+      "avg_cvss": 5.5,
+      "cvss_count": 24
+    },
+    {
+      "date": "2001-08-03",
+      "value": 4,
+      "avg_cvss": 4.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-08-04",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-08-06",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-08-07",
+      "value": 5,
+      "avg_cvss": 5.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2001-08-09",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-08-10",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-08-12",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-08-13",
+      "value": 4,
+      "avg_cvss": 7.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-08-14",
+      "value": 43,
+      "avg_cvss": 6.7,
+      "cvss_count": 43
+    },
+    {
+      "date": "2001-08-17",
+      "value": 2,
+      "avg_cvss": 5.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-08-20",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-08-21",
+      "value": 5,
+      "avg_cvss": 4.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2001-08-22",
+      "value": 46,
+      "avg_cvss": 5.4,
+      "cvss_count": 46
+    },
+    {
+      "date": "2001-08-23",
+      "value": 2,
+      "avg_cvss": 8.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-08-24",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-08-27",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-08-28",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-08-29",
+      "value": 4,
+      "avg_cvss": 6.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-08-30",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-08-31",
+      "value": 55,
+      "avg_cvss": 6.5,
+      "cvss_count": 55
+    },
+    {
+      "date": "2001-09-02",
+      "value": 2,
+      "avg_cvss": 7.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-09-03",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-09-04",
+      "value": 5,
+      "avg_cvss": 6.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2001-09-05",
+      "value": 5,
+      "avg_cvss": 7.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2001-09-06",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-09-07",
+      "value": 3,
+      "avg_cvss": 4.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-09-08",
+      "value": 4,
+      "avg_cvss": 6.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-09-10",
+      "value": 12,
+      "avg_cvss": 6.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2001-09-11",
+      "value": 4,
+      "avg_cvss": 6.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-09-12",
+      "value": 8,
+      "avg_cvss": 6.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2001-09-13",
+      "value": 2,
+      "avg_cvss": 3.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-09-14",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-09-15",
+      "value": 3,
+      "avg_cvss": 8.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-09-18",
+      "value": 2,
+      "avg_cvss": 6.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-09-19",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-09-20",
+      "value": 62,
+      "avg_cvss": 5.6,
+      "cvss_count": 62
+    },
+    {
+      "date": "2001-09-21",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-09-22",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-09-23",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-09-24",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-09-25",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-09-26",
+      "value": 2,
+      "avg_cvss": 5.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-09-27",
+      "value": 4,
+      "avg_cvss": 5.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-09-28",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-09-29",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-10-01",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-10-02",
+      "value": 16,
+      "avg_cvss": 6.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2001-10-03",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-10-05",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-10-06",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-10-07",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-10-08",
+      "value": 4,
+      "avg_cvss": 6.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-10-09",
+      "value": 4,
+      "avg_cvss": 5.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-10-10",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-10-12",
+      "value": 8,
+      "avg_cvss": 6.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2001-10-13",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-10-15",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-10-16",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-10-17",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-10-18",
+      "value": 64,
+      "avg_cvss": 6.1,
+      "cvss_count": 64
+    },
+    {
+      "date": "2001-10-22",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-10-24",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-10-25",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-10-30",
+      "value": 22,
+      "avg_cvss": 5.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2001-11-02",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-11-05",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-11-11",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-11-12",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-11-13",
+      "value": 3,
+      "avg_cvss": 4.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-11-14",
+      "value": 2,
+      "avg_cvss": 7.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-11-15",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-11-16",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-11-18",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-11-19",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-11-20",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-11-21",
+      "value": 8,
+      "avg_cvss": 6.1,
+      "cvss_count": 8
+    },
+    {
+      "date": "2001-11-22",
+      "value": 4,
+      "avg_cvss": 5.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-11-25",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-11-26",
+      "value": 4,
+      "avg_cvss": 6.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-11-27",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-11-28",
+      "value": 13,
+      "avg_cvss": 7.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2001-11-29",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-11-30",
+      "value": 8,
+      "avg_cvss": 6.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2001-12-01",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-12-02",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-12-03",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-12-04",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2001-12-06",
+      "value": 74,
+      "avg_cvss": 6.6,
+      "cvss_count": 74
+    },
+    {
+      "date": "2001-12-07",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-12-08",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-12-10",
+      "value": 1,
+      "avg_cvss": 6.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-12-11",
+      "value": 5,
+      "avg_cvss": 5.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2001-12-12",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-12-13",
+      "value": 4,
+      "avg_cvss": 5.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2001-12-14",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-12-15",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2001-12-17",
+      "value": 5,
+      "avg_cvss": 7.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2001-12-18",
+      "value": 2,
+      "avg_cvss": 5.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-12-19",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-12-20",
+      "value": 7,
+      "avg_cvss": 5.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2001-12-21",
+      "value": 14,
+      "avg_cvss": 6.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2001-12-23",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2001-12-25",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-12-26",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-12-27",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-12-28",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-12-29",
+      "value": 2,
+      "avg_cvss": 7.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2001-12-30",
+      "value": 5,
+      "avg_cvss": 6.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2001-12-31",
+      "value": 108,
+      "avg_cvss": 5.6,
+      "cvss_count": 108
+    },
+    {
+      "date": "2002-01-02",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-01-09",
+      "value": 4,
+      "avg_cvss": 5.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2002-01-11",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-01-13",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-01-15",
+      "value": 3,
+      "avg_cvss": 3.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2002-01-30",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-01-31",
+      "value": 14,
+      "avg_cvss": 6.6,
+      "cvss_count": 14
+    },
+    {
+      "date": "2002-02-06",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-02-09",
+      "value": 1,
+      "avg_cvss": 5.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-02-13",
+      "value": 5,
+      "avg_cvss": 7.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2002-02-26",
+      "value": 2,
+      "avg_cvss": 4.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-02-27",
+      "value": 5,
+      "avg_cvss": 7.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2002-03-04",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-03-08",
+      "value": 25,
+      "avg_cvss": 6.6,
+      "cvss_count": 25
+    },
+    {
+      "date": "2002-03-15",
+      "value": 16,
+      "avg_cvss": 6.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2002-03-19",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-03-21",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-03-22",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-03-25",
+      "value": 53,
+      "avg_cvss": 5.8,
+      "cvss_count": 53
+    },
+    {
+      "date": "2002-03-26",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-03-27",
+      "value": 1,
+      "avg_cvss": 6.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-03-28",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-03-29",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-04-01",
+      "value": 7,
+      "avg_cvss": 6.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2002-04-02",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-04-03",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-04-04",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-04-05",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-04-08",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-04-22",
+      "value": 30,
+      "avg_cvss": 7.0,
+      "cvss_count": 30
+    },
+    {
+      "date": "2002-04-23",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-05-01",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-05-06",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-05-16",
+      "value": 44,
+      "avg_cvss": 6.2,
+      "cvss_count": 44
+    },
+    {
+      "date": "2002-05-17",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-05-19",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-05-21",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-05-27",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-05-28",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-05-29",
+      "value": 57,
+      "avg_cvss": 6.5,
+      "cvss_count": 57
+    },
+    {
+      "date": "2002-05-31",
+      "value": 40,
+      "avg_cvss": 5.9,
+      "cvss_count": 40
+    },
+    {
+      "date": "2002-06-18",
+      "value": 51,
+      "avg_cvss": 6.2,
+      "cvss_count": 51
+    },
+    {
+      "date": "2002-06-25",
+      "value": 51,
+      "avg_cvss": 6.3,
+      "cvss_count": 51
+    },
+    {
+      "date": "2002-07-03",
+      "value": 60,
+      "avg_cvss": 7.0,
+      "cvss_count": 60
+    },
+    {
+      "date": "2002-07-08",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-07-11",
+      "value": 4,
+      "avg_cvss": 8.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2002-07-23",
+      "value": 24,
+      "avg_cvss": 6.7,
+      "cvss_count": 24
+    },
+    {
+      "date": "2002-07-26",
+      "value": 46,
+      "avg_cvss": 7.1,
+      "cvss_count": 46
+    },
+    {
+      "date": "2002-07-31",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-08-01",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-08-12",
+      "value": 242,
+      "avg_cvss": 6.7,
+      "cvss_count": 242
+    },
+    {
+      "date": "2002-08-14",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-08-15",
+      "value": 1,
+      "avg_cvss": 2.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-08-24",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-08-29",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-08-30",
+      "value": 4,
+      "avg_cvss": 4.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2002-08-31",
+      "value": 2,
+      "avg_cvss": 4.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-09-02",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-09-05",
+      "value": 22,
+      "avg_cvss": 6.3,
+      "cvss_count": 22
+    },
+    {
+      "date": "2002-09-09",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-09-10",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-09-13",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-09-24",
+      "value": 39,
+      "avg_cvss": 6.6,
+      "cvss_count": 39
+    },
+    {
+      "date": "2002-09-25",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-10-03",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-10-04",
+      "value": 234,
+      "avg_cvss": 6.2,
+      "cvss_count": 234
+    },
+    {
+      "date": "2002-10-10",
+      "value": 11,
+      "avg_cvss": 6.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2002-10-11",
+      "value": 31,
+      "avg_cvss": 6.0,
+      "cvss_count": 31
+    },
+    {
+      "date": "2002-10-16",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-10-22",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-10-24",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-10-28",
+      "value": 33,
+      "avg_cvss": 6.6,
+      "cvss_count": 33
+    },
+    {
+      "date": "2002-10-29",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-11-04",
+      "value": 12,
+      "avg_cvss": 5.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2002-11-08",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-11-12",
+      "value": 23,
+      "avg_cvss": 6.9,
+      "cvss_count": 23
+    },
+    {
+      "date": "2002-11-20",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-11-25",
+      "value": 2,
+      "avg_cvss": 8.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2002-11-29",
+      "value": 35,
+      "avg_cvss": 6.3,
+      "cvss_count": 35
+    },
+    {
+      "date": "2002-12-03",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-12-04",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-12-11",
+      "value": 22,
+      "avg_cvss": 5.9,
+      "cvss_count": 22
+    },
+    {
+      "date": "2002-12-18",
+      "value": 13,
+      "avg_cvss": 6.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2002-12-19",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-12-23",
+      "value": 26,
+      "avg_cvss": 7.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2002-12-24",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-12-26",
+      "value": 12,
+      "avg_cvss": 8.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2002-12-27",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2002-12-31",
+      "value": 791,
+      "avg_cvss": 5.8,
+      "cvss_count": 791
+    },
+    {
+      "date": "2003-01-02",
+      "value": 7,
+      "avg_cvss": 5.8,
+      "cvss_count": 7
+    },
+    {
+      "date": "2003-01-03",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-01-07",
+      "value": 5,
+      "avg_cvss": 7.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2003-01-11",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-01-17",
+      "value": 21,
+      "avg_cvss": 6.2,
+      "cvss_count": 21
+    },
+    {
+      "date": "2003-01-27",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-02-06",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-02-07",
+      "value": 18,
+      "avg_cvss": 6.0,
+      "cvss_count": 18
+    },
+    {
+      "date": "2003-02-11",
+      "value": 1,
+      "avg_cvss": 1.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-02-18",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-02-19",
+      "value": 26,
+      "avg_cvss": 6.2,
+      "cvss_count": 26
+    },
+    {
+      "date": "2003-02-28",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-03-03",
+      "value": 30,
+      "avg_cvss": 6.7,
+      "cvss_count": 30
+    },
+    {
+      "date": "2003-03-05",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-03-07",
+      "value": 13,
+      "avg_cvss": 6.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2003-03-18",
+      "value": 19,
+      "avg_cvss": 6.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2003-03-20",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-03-24",
+      "value": 12,
+      "avg_cvss": 6.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2003-03-25",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-03-28",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-03-31",
+      "value": 41,
+      "avg_cvss": 6.2,
+      "cvss_count": 41
+    },
+    {
+      "date": "2003-04-02",
+      "value": 66,
+      "avg_cvss": 5.9,
+      "cvss_count": 66
+    },
+    {
+      "date": "2003-04-11",
+      "value": 46,
+      "avg_cvss": 6.3,
+      "cvss_count": 46
+    },
+    {
+      "date": "2003-04-16",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-04-22",
+      "value": 20,
+      "avg_cvss": 6.7,
+      "cvss_count": 20
+    },
+    {
+      "date": "2003-04-28",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2003-05-05",
+      "value": 15,
+      "avg_cvss": 6.3,
+      "cvss_count": 15
+    },
+    {
+      "date": "2003-05-10",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-05-11",
+      "value": 1,
+      "avg_cvss": 6.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-05-12",
+      "value": 26,
+      "avg_cvss": 6.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2003-05-15",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-05-19",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-05-20",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-05-21",
+      "value": 4,
+      "avg_cvss": 6.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2003-05-22",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2003-05-27",
+      "value": 26,
+      "avg_cvss": 6.9,
+      "cvss_count": 26
+    },
+    {
+      "date": "2003-06-03",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2003-06-06",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-06-09",
+      "value": 50,
+      "avg_cvss": 6.5,
+      "cvss_count": 50
+    },
+    {
+      "date": "2003-06-13",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-06-16",
+      "value": 55,
+      "avg_cvss": 6.3,
+      "cvss_count": 55
+    },
+    {
+      "date": "2003-06-17",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-06-19",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-06-30",
+      "value": 18,
+      "avg_cvss": 6.6,
+      "cvss_count": 18
+    },
+    {
+      "date": "2003-07-02",
+      "value": 15,
+      "avg_cvss": 6.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2003-07-03",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-07-23",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2003-07-24",
+      "value": 29,
+      "avg_cvss": 5.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2003-07-25",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-08-06",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-08-07",
+      "value": 47,
+      "avg_cvss": 6.4,
+      "cvss_count": 47
+    },
+    {
+      "date": "2003-08-11",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-08-15",
+      "value": 1,
+      "avg_cvss": 2.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-08-18",
+      "value": 58,
+      "avg_cvss": 6.5,
+      "cvss_count": 58
+    },
+    {
+      "date": "2003-08-19",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-08-20",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-08-27",
+      "value": 95,
+      "avg_cvss": 5.9,
+      "cvss_count": 95
+    },
+    {
+      "date": "2003-09-07",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-09-09",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-09-17",
+      "value": 18,
+      "avg_cvss": 6.9,
+      "cvss_count": 18
+    },
+    {
+      "date": "2003-09-22",
+      "value": 15,
+      "avg_cvss": 7.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2003-10-03",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-10-06",
+      "value": 21,
+      "avg_cvss": 7.4,
+      "cvss_count": 21
+    },
+    {
+      "date": "2003-10-07",
+      "value": 1,
+      "avg_cvss": 9.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-10-14",
+      "value": 1,
+      "avg_cvss": 1.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-10-15",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-10-20",
+      "value": 47,
+      "avg_cvss": 6.8,
+      "cvss_count": 47
+    },
+    {
+      "date": "2003-10-23",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-10-25",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2003-10-27",
+      "value": 7,
+      "avg_cvss": 6.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2003-10-28",
+      "value": 2,
+      "avg_cvss": 4.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "2003-10-29",
+      "value": 3,
+      "avg_cvss": 5.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2003-10-30",
+      "value": 4,
+      "avg_cvss": 7.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2003-10-31",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-11-02",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2003-11-03",
+      "value": 25,
+      "avg_cvss": 6.6,
+      "cvss_count": 25
+    },
+    {
+      "date": "2003-11-04",
+      "value": 2,
+      "avg_cvss": 8.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2003-11-13",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-11-17",
+      "value": 59,
+      "avg_cvss": 6.2,
+      "cvss_count": 59
+    },
+    {
+      "date": "2003-11-20",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-11-23",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-11-24",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-11-27",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-12-01",
+      "value": 17,
+      "avg_cvss": 5.6,
+      "cvss_count": 17
+    },
+    {
+      "date": "2003-12-03",
+      "value": 1,
+      "avg_cvss": 3.7,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-12-08",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-12-11",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-12-15",
+      "value": 43,
+      "avg_cvss": 6.4,
+      "cvss_count": 43
+    },
+    {
+      "date": "2003-12-26",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2003-12-29",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2003-12-31",
+      "value": 441,
+      "avg_cvss": 5.9,
+      "cvss_count": 441
+    },
+    {
+      "date": "2004-01-03",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-01-04",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-01-05",
+      "value": 23,
+      "avg_cvss": 6.1,
+      "cvss_count": 23
+    },
+    {
+      "date": "2004-01-10",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-01-14",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-01-15",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-01-20",
+      "value": 25,
+      "avg_cvss": 6.7,
+      "cvss_count": 25
+    },
+    {
+      "date": "2004-01-21",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-01-23",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-01-24",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-01-27",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-01-28",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-01-29",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-02-01",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-02-03",
+      "value": 25,
+      "avg_cvss": 6.4,
+      "cvss_count": 25
+    },
+    {
+      "date": "2004-02-04",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-02-06",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-02-07",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-02-08",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-02-09",
+      "value": 5,
+      "avg_cvss": 5.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2004-02-10",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-02-11",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-02-12",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-02-13",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-02-16",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-02-17",
+      "value": 39,
+      "avg_cvss": 6.2,
+      "cvss_count": 39
+    },
+    {
+      "date": "2004-02-19",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-02-21",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-02-23",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-02-27",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-02-28",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-03-03",
+      "value": 48,
+      "avg_cvss": 6.6,
+      "cvss_count": 48
+    },
+    {
+      "date": "2004-03-04",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-03-11",
+      "value": 3,
+      "avg_cvss": 8.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-03-12",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-03-15",
+      "value": 29,
+      "avg_cvss": 6.4,
+      "cvss_count": 29
+    },
+    {
+      "date": "2004-03-16",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-03-18",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-03-19",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-03-20",
+      "value": 5,
+      "avg_cvss": 6.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2004-03-22",
+      "value": 3,
+      "avg_cvss": 4.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-03-23",
+      "value": 4,
+      "avg_cvss": 5.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "2004-03-24",
+      "value": 7,
+      "avg_cvss": 5.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2004-03-25",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-03-26",
+      "value": 4,
+      "avg_cvss": 5.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2004-03-29",
+      "value": 25,
+      "avg_cvss": 6.2,
+      "cvss_count": 25
+    },
+    {
+      "date": "2004-03-30",
+      "value": 4,
+      "avg_cvss": 5.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2004-04-02",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-04-04",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-04-07",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-04-08",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-04-09",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-04-10",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-04-11",
+      "value": 5,
+      "avg_cvss": 4.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2004-04-12",
+      "value": 6,
+      "avg_cvss": 5.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2004-04-13",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-04-14",
+      "value": 3,
+      "avg_cvss": 5.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-04-15",
+      "value": 39,
+      "avg_cvss": 6.4,
+      "cvss_count": 39
+    },
+    {
+      "date": "2004-04-19",
+      "value": 7,
+      "avg_cvss": 6.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2004-04-20",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-04-21",
+      "value": 3,
+      "avg_cvss": 4.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-04-23",
+      "value": 6,
+      "avg_cvss": 5.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2004-04-25",
+      "value": 3,
+      "avg_cvss": 6.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-04-26",
+      "value": 7,
+      "avg_cvss": 5.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2004-04-27",
+      "value": 3,
+      "avg_cvss": 4.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-04-28",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-04-29",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-04-30",
+      "value": 7,
+      "avg_cvss": 5.8,
+      "cvss_count": 7
+    },
+    {
+      "date": "2004-05-01",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-05-02",
+      "value": 3,
+      "avg_cvss": 4.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-05-03",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-05-04",
+      "value": 30,
+      "avg_cvss": 6.7,
+      "cvss_count": 30
+    },
+    {
+      "date": "2004-05-05",
+      "value": 8,
+      "avg_cvss": 5.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2004-05-06",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-05-07",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-05-08",
+      "value": 3,
+      "avg_cvss": 4.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-05-10",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-05-14",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-05-21",
+      "value": 2,
+      "avg_cvss": 4.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-05-22",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-05-24",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-05-26",
+      "value": 3,
+      "avg_cvss": 4.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-05-28",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-05-29",
+      "value": 5,
+      "avg_cvss": 5.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2004-06-01",
+      "value": 40,
+      "avg_cvss": 5.8,
+      "cvss_count": 40
+    },
+    {
+      "date": "2004-06-14",
+      "value": 9,
+      "avg_cvss": 6.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2004-06-15",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-06-19",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-06-21",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-07-07",
+      "value": 36,
+      "avg_cvss": 5.7,
+      "cvss_count": 36
+    },
+    {
+      "date": "2004-07-19",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-07-22",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-07-23",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-07-24",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-07-27",
+      "value": 53,
+      "avg_cvss": 6.5,
+      "cvss_count": 53
+    },
+    {
+      "date": "2004-07-29",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-07-30",
+      "value": 4,
+      "avg_cvss": 7.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2004-08-02",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-08-04",
+      "value": 12,
+      "avg_cvss": 6.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2004-08-05",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-08-06",
+      "value": 108,
+      "avg_cvss": 6.8,
+      "cvss_count": 108
+    },
+    {
+      "date": "2004-08-09",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-08-10",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-08-11",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-08-15",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-08-16",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-08-17",
+      "value": 5,
+      "avg_cvss": 4.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2004-08-18",
+      "value": 64,
+      "avg_cvss": 6.7,
+      "cvss_count": 64
+    },
+    {
+      "date": "2004-08-20",
+      "value": 7,
+      "avg_cvss": 6.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2004-08-21",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-08-23",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-08-24",
+      "value": 6,
+      "avg_cvss": 5.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "2004-08-25",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-08-26",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-08-28",
+      "value": 2,
+      "avg_cvss": 4.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-08-29",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-08-30",
+      "value": 5,
+      "avg_cvss": 5.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2004-08-31",
+      "value": 7,
+      "avg_cvss": 6.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2004-09-01",
+      "value": 5,
+      "avg_cvss": 5.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2004-09-02",
+      "value": 4,
+      "avg_cvss": 5.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2004-09-04",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-09-05",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-09-06",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-09-07",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-09-08",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-09-09",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-09-10",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-09-11",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-09-12",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-09-13",
+      "value": 6,
+      "avg_cvss": 4.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2004-09-14",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-09-15",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-09-16",
+      "value": 12,
+      "avg_cvss": 5.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2004-09-17",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-09-18",
+      "value": 4,
+      "avg_cvss": 5.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2004-09-20",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-09-21",
+      "value": 5,
+      "avg_cvss": 6.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2004-09-24",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-09-28",
+      "value": 30,
+      "avg_cvss": 6.6,
+      "cvss_count": 30
+    },
+    {
+      "date": "2004-09-29",
+      "value": 1,
+      "avg_cvss": 2.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-09-30",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-10-04",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-10-05",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-10-06",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-10-07",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-10-12",
+      "value": 5,
+      "avg_cvss": 6.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2004-10-13",
+      "value": 4,
+      "avg_cvss": 6.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2004-10-14",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-10-15",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-10-16",
+      "value": 4,
+      "avg_cvss": 6.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2004-10-18",
+      "value": 14,
+      "avg_cvss": 5.3,
+      "cvss_count": 14
+    },
+    {
+      "date": "2004-10-19",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-10-20",
+      "value": 44,
+      "avg_cvss": 6.3,
+      "cvss_count": 44
+    },
+    {
+      "date": "2004-10-21",
+      "value": 3,
+      "avg_cvss": 6.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-10-22",
+      "value": 4,
+      "avg_cvss": 5.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "2004-10-23",
+      "value": 2,
+      "avg_cvss": 8.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-10-24",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-10-25",
+      "value": 5,
+      "avg_cvss": 4.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2004-10-26",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-10-30",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-11-01",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-11-03",
+      "value": 33,
+      "avg_cvss": 6.6,
+      "cvss_count": 33
+    },
+    {
+      "date": "2004-11-12",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-11-16",
+      "value": 1,
+      "avg_cvss": 2.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-11-23",
+      "value": 134,
+      "avg_cvss": 6.7,
+      "cvss_count": 134
+    },
+    {
+      "date": "2004-11-24",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-11-30",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-12-01",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-12-02",
+      "value": 7,
+      "avg_cvss": 4.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2004-12-03",
+      "value": 2,
+      "avg_cvss": 8.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-12-06",
+      "value": 49,
+      "avg_cvss": 6.7,
+      "cvss_count": 49
+    },
+    {
+      "date": "2004-12-07",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-12-10",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-12-15",
+      "value": 10,
+      "avg_cvss": 4.9,
+      "cvss_count": 10
+    },
+    {
+      "date": "2004-12-16",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-12-17",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-12-18",
+      "value": 3,
+      "avg_cvss": 4.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-12-20",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2004-12-21",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-12-22",
+      "value": 5,
+      "avg_cvss": 5.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2004-12-23",
+      "value": 34,
+      "avg_cvss": 5.8,
+      "cvss_count": 34
+    },
+    {
+      "date": "2004-12-27",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2004-12-28",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-12-29",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-12-30",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2004-12-31",
+      "value": 1098,
+      "avg_cvss": 5.7,
+      "cvss_count": 1098
+    },
+    {
+      "date": "2005-01-01",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-01-03",
+      "value": 4,
+      "avg_cvss": 7.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2005-01-04",
+      "value": 3,
+      "avg_cvss": 5.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-01-05",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-01-06",
+      "value": 3,
+      "avg_cvss": 4.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-01-07",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-01-10",
+      "value": 217,
+      "avg_cvss": 7.5,
+      "cvss_count": 217
+    },
+    {
+      "date": "2005-01-11",
+      "value": 7,
+      "avg_cvss": 5.8,
+      "cvss_count": 7
+    },
+    {
+      "date": "2005-01-12",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-01-13",
+      "value": 4,
+      "avg_cvss": 5.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2005-01-14",
+      "value": 2,
+      "avg_cvss": 4.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-01-15",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-01-16",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-01-17",
+      "value": 6,
+      "avg_cvss": 5.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2005-01-18",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-01-19",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-01-20",
+      "value": 3,
+      "avg_cvss": 5.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-01-21",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-01-22",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-01-24",
+      "value": 6,
+      "avg_cvss": 6.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2005-01-25",
+      "value": 4,
+      "avg_cvss": 4.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2005-01-26",
+      "value": 3,
+      "avg_cvss": 5.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-01-27",
+      "value": 33,
+      "avg_cvss": 6.5,
+      "cvss_count": 33
+    },
+    {
+      "date": "2005-01-28",
+      "value": 5,
+      "avg_cvss": 4.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2005-01-29",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-01-31",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-02-01",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-02-02",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-02-03",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-02-07",
+      "value": 6,
+      "avg_cvss": 4.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2005-02-08",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-02-09",
+      "value": 31,
+      "avg_cvss": 5.9,
+      "cvss_count": 31
+    },
+    {
+      "date": "2005-02-10",
+      "value": 2,
+      "avg_cvss": 3.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-02-11",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-02-12",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-02-14",
+      "value": 6,
+      "avg_cvss": 6.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2005-02-15",
+      "value": 5,
+      "avg_cvss": 4.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2005-02-16",
+      "value": 3,
+      "avg_cvss": 4.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-02-17",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-02-18",
+      "value": 3,
+      "avg_cvss": 6.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-02-19",
+      "value": 3,
+      "avg_cvss": 4.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-02-20",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-02-21",
+      "value": 7,
+      "avg_cvss": 7.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2005-02-22",
+      "value": 5,
+      "avg_cvss": 4.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2005-02-23",
+      "value": 6,
+      "avg_cvss": 4.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2005-02-24",
+      "value": 4,
+      "avg_cvss": 4.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2005-02-25",
+      "value": 3,
+      "avg_cvss": 4.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-02-28",
+      "value": 8,
+      "avg_cvss": 4.1,
+      "cvss_count": 8
+    },
+    {
+      "date": "2005-03-01",
+      "value": 35,
+      "avg_cvss": 6.6,
+      "cvss_count": 35
+    },
+    {
+      "date": "2005-03-02",
+      "value": 8,
+      "avg_cvss": 6.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2005-03-03",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-03-04",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-03-05",
+      "value": 2,
+      "avg_cvss": 5.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-03-06",
+      "value": 4,
+      "avg_cvss": 6.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2005-03-07",
+      "value": 20,
+      "avg_cvss": 5.4,
+      "cvss_count": 20
+    },
+    {
+      "date": "2005-03-08",
+      "value": 11,
+      "avg_cvss": 5.5,
+      "cvss_count": 11
+    },
+    {
+      "date": "2005-03-09",
+      "value": 3,
+      "avg_cvss": 2.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-03-10",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-03-12",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-03-14",
+      "value": 20,
+      "avg_cvss": 5.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2005-03-15",
+      "value": 8,
+      "avg_cvss": 6.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2005-03-16",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-03-21",
+      "value": 3,
+      "avg_cvss": 4.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-03-23",
+      "value": 6,
+      "avg_cvss": 4.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2005-03-24",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-03-25",
+      "value": 3,
+      "avg_cvss": 5.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-03-26",
+      "value": 3,
+      "avg_cvss": 4.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-03-27",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-03-28",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-03-29",
+      "value": 5,
+      "avg_cvss": 5.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2005-03-30",
+      "value": 15,
+      "avg_cvss": 5.5,
+      "cvss_count": 15
+    },
+    {
+      "date": "2005-03-31",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-04-01",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-04-05",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-04-06",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-04-07",
+      "value": 3,
+      "avg_cvss": 6.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-04-08",
+      "value": 3,
+      "avg_cvss": 5.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-04-09",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-04-10",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-04-11",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-04-12",
+      "value": 16,
+      "avg_cvss": 5.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2005-04-13",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-04-14",
+      "value": 31,
+      "avg_cvss": 5.4,
+      "cvss_count": 31
+    },
+    {
+      "date": "2005-04-15",
+      "value": 5,
+      "avg_cvss": 6.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2005-04-18",
+      "value": 4,
+      "avg_cvss": 6.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2005-04-19",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-04-20",
+      "value": 5,
+      "avg_cvss": 6.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2005-04-22",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-04-23",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-04-24",
+      "value": 4,
+      "avg_cvss": 8.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2005-04-25",
+      "value": 9,
+      "avg_cvss": 7.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2005-04-26",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-04-27",
+      "value": 21,
+      "avg_cvss": 5.8,
+      "cvss_count": 21
+    },
+    {
+      "date": "2005-04-29",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-05-02",
+      "value": 816,
+      "avg_cvss": 5.6,
+      "cvss_count": 816
+    },
+    {
+      "date": "2005-05-03",
+      "value": 81,
+      "avg_cvss": 6.3,
+      "cvss_count": 81
+    },
+    {
+      "date": "2005-05-04",
+      "value": 15,
+      "avg_cvss": 6.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2005-05-05",
+      "value": 17,
+      "avg_cvss": 5.4,
+      "cvss_count": 17
+    },
+    {
+      "date": "2005-05-06",
+      "value": 4,
+      "avg_cvss": 5.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2005-05-09",
+      "value": 2,
+      "avg_cvss": 5.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-05-10",
+      "value": 2,
+      "avg_cvss": 5.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-05-11",
+      "value": 56,
+      "avg_cvss": 6.3,
+      "cvss_count": 56
+    },
+    {
+      "date": "2005-05-12",
+      "value": 13,
+      "avg_cvss": 5.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2005-05-13",
+      "value": 2,
+      "avg_cvss": 3.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-05-14",
+      "value": 26,
+      "avg_cvss": 5.7,
+      "cvss_count": 26
+    },
+    {
+      "date": "2005-05-16",
+      "value": 38,
+      "avg_cvss": 6.3,
+      "cvss_count": 38
+    },
+    {
+      "date": "2005-05-17",
+      "value": 21,
+      "avg_cvss": 6.1,
+      "cvss_count": 21
+    },
+    {
+      "date": "2005-05-18",
+      "value": 28,
+      "avg_cvss": 5.8,
+      "cvss_count": 28
+    },
+    {
+      "date": "2005-05-19",
+      "value": 12,
+      "avg_cvss": 5.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2005-05-20",
+      "value": 14,
+      "avg_cvss": 5.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2005-05-24",
+      "value": 46,
+      "avg_cvss": 6.0,
+      "cvss_count": 46
+    },
+    {
+      "date": "2005-05-25",
+      "value": 11,
+      "avg_cvss": 6.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2005-05-26",
+      "value": 11,
+      "avg_cvss": 5.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2005-05-27",
+      "value": 4,
+      "avg_cvss": 6.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2005-05-28",
+      "value": 6,
+      "avg_cvss": 5.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2005-05-29",
+      "value": 5,
+      "avg_cvss": 5.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2005-05-30",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-05-31",
+      "value": 23,
+      "avg_cvss": 5.8,
+      "cvss_count": 23
+    },
+    {
+      "date": "2005-06-01",
+      "value": 24,
+      "avg_cvss": 6.1,
+      "cvss_count": 24
+    },
+    {
+      "date": "2005-06-02",
+      "value": 7,
+      "avg_cvss": 6.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2005-06-03",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-06-05",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-06-06",
+      "value": 5,
+      "avg_cvss": 5.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2005-06-07",
+      "value": 5,
+      "avg_cvss": 5.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2005-06-08",
+      "value": 13,
+      "avg_cvss": 5.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2005-06-09",
+      "value": 41,
+      "avg_cvss": 5.9,
+      "cvss_count": 41
+    },
+    {
+      "date": "2005-06-10",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-06-11",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-06-12",
+      "value": 5,
+      "avg_cvss": 5.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2005-06-13",
+      "value": 8,
+      "avg_cvss": 7.1,
+      "cvss_count": 8
+    },
+    {
+      "date": "2005-06-14",
+      "value": 14,
+      "avg_cvss": 6.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2005-06-15",
+      "value": 11,
+      "avg_cvss": 5.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2005-06-16",
+      "value": 32,
+      "avg_cvss": 5.7,
+      "cvss_count": 32
+    },
+    {
+      "date": "2005-06-17",
+      "value": 8,
+      "avg_cvss": 5.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "2005-06-18",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-06-19",
+      "value": 2,
+      "avg_cvss": 5.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-06-20",
+      "value": 14,
+      "avg_cvss": 5.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2005-06-21",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-06-22",
+      "value": 9,
+      "avg_cvss": 7.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2005-06-23",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-06-28",
+      "value": 7,
+      "avg_cvss": 5.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2005-06-29",
+      "value": 25,
+      "avg_cvss": 5.1,
+      "cvss_count": 25
+    },
+    {
+      "date": "2005-06-30",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-07-05",
+      "value": 49,
+      "avg_cvss": 4.9,
+      "cvss_count": 49
+    },
+    {
+      "date": "2005-07-06",
+      "value": 24,
+      "avg_cvss": 6.3,
+      "cvss_count": 24
+    },
+    {
+      "date": "2005-07-07",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-07-08",
+      "value": 2,
+      "avg_cvss": 3.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-07-09",
+      "value": 2,
+      "avg_cvss": 5.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-07-11",
+      "value": 39,
+      "avg_cvss": 5.9,
+      "cvss_count": 39
+    },
+    {
+      "date": "2005-07-12",
+      "value": 35,
+      "avg_cvss": 5.9,
+      "cvss_count": 35
+    },
+    {
+      "date": "2005-07-13",
+      "value": 28,
+      "avg_cvss": 6.1,
+      "cvss_count": 28
+    },
+    {
+      "date": "2005-07-15",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-07-18",
+      "value": 24,
+      "avg_cvss": 5.5,
+      "cvss_count": 24
+    },
+    {
+      "date": "2005-07-19",
+      "value": 31,
+      "avg_cvss": 5.6,
+      "cvss_count": 31
+    },
+    {
+      "date": "2005-07-20",
+      "value": 8,
+      "avg_cvss": 5.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2005-07-26",
+      "value": 22,
+      "avg_cvss": 6.1,
+      "cvss_count": 22
+    },
+    {
+      "date": "2005-07-27",
+      "value": 22,
+      "avg_cvss": 5.7,
+      "cvss_count": 22
+    },
+    {
+      "date": "2005-08-01",
+      "value": 6,
+      "avg_cvss": 5.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2005-08-02",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-08-03",
+      "value": 41,
+      "avg_cvss": 5.4,
+      "cvss_count": 41
+    },
+    {
+      "date": "2005-08-04",
+      "value": 3,
+      "avg_cvss": 4.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-08-05",
+      "value": 18,
+      "avg_cvss": 4.9,
+      "cvss_count": 18
+    },
+    {
+      "date": "2005-08-07",
+      "value": 8,
+      "avg_cvss": 5.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2005-08-08",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-08-10",
+      "value": 29,
+      "avg_cvss": 5.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2005-08-12",
+      "value": 8,
+      "avg_cvss": 5.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "2005-08-15",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-08-16",
+      "value": 36,
+      "avg_cvss": 5.9,
+      "cvss_count": 36
+    },
+    {
+      "date": "2005-08-17",
+      "value": 32,
+      "avg_cvss": 5.9,
+      "cvss_count": 32
+    },
+    {
+      "date": "2005-08-19",
+      "value": 33,
+      "avg_cvss": 5.7,
+      "cvss_count": 33
+    },
+    {
+      "date": "2005-08-23",
+      "value": 53,
+      "avg_cvss": 6.0,
+      "cvss_count": 53
+    },
+    {
+      "date": "2005-08-24",
+      "value": 15,
+      "avg_cvss": 5.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2005-08-26",
+      "value": 7,
+      "avg_cvss": 5.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2005-08-29",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-08-30",
+      "value": 24,
+      "avg_cvss": 5.3,
+      "cvss_count": 24
+    },
+    {
+      "date": "2005-08-31",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-09-01",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-09-02",
+      "value": 31,
+      "avg_cvss": 6.1,
+      "cvss_count": 31
+    },
+    {
+      "date": "2005-09-06",
+      "value": 12,
+      "avg_cvss": 5.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2005-09-07",
+      "value": 21,
+      "avg_cvss": 5.8,
+      "cvss_count": 21
+    },
+    {
+      "date": "2005-09-08",
+      "value": 31,
+      "avg_cvss": 5.6,
+      "cvss_count": 31
+    },
+    {
+      "date": "2005-09-09",
+      "value": 3,
+      "avg_cvss": 4.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-09-13",
+      "value": 4,
+      "avg_cvss": 6.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2005-09-14",
+      "value": 32,
+      "avg_cvss": 5.4,
+      "cvss_count": 32
+    },
+    {
+      "date": "2005-09-15",
+      "value": 5,
+      "avg_cvss": 5.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2005-09-16",
+      "value": 16,
+      "avg_cvss": 5.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2005-09-20",
+      "value": 26,
+      "avg_cvss": 5.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2005-09-21",
+      "value": 32,
+      "avg_cvss": 5.5,
+      "cvss_count": 32
+    },
+    {
+      "date": "2005-09-22",
+      "value": 14,
+      "avg_cvss": 6.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2005-09-23",
+      "value": 7,
+      "avg_cvss": 6.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2005-09-24",
+      "value": 8,
+      "avg_cvss": 6.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2005-09-26",
+      "value": 4,
+      "avg_cvss": 4.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2005-09-27",
+      "value": 28,
+      "avg_cvss": 5.5,
+      "cvss_count": 28
+    },
+    {
+      "date": "2005-09-28",
+      "value": 18,
+      "avg_cvss": 5.2,
+      "cvss_count": 18
+    },
+    {
+      "date": "2005-09-30",
+      "value": 15,
+      "avg_cvss": 3.6,
+      "cvss_count": 15
+    },
+    {
+      "date": "2005-10-04",
+      "value": 11,
+      "avg_cvss": 5.5,
+      "cvss_count": 11
+    },
+    {
+      "date": "2005-10-05",
+      "value": 25,
+      "avg_cvss": 5.4,
+      "cvss_count": 25
+    },
+    {
+      "date": "2005-10-06",
+      "value": 21,
+      "avg_cvss": 5.8,
+      "cvss_count": 21
+    },
+    {
+      "date": "2005-10-07",
+      "value": 4,
+      "avg_cvss": 4.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2005-10-12",
+      "value": 12,
+      "avg_cvss": 5.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2005-10-13",
+      "value": 9,
+      "avg_cvss": 6.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2005-10-14",
+      "value": 47,
+      "avg_cvss": 5.3,
+      "cvss_count": 47
+    },
+    {
+      "date": "2005-10-17",
+      "value": 3,
+      "avg_cvss": 6.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-10-18",
+      "value": 7,
+      "avg_cvss": 6.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2005-10-20",
+      "value": 15,
+      "avg_cvss": 6.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2005-10-21",
+      "value": 12,
+      "avg_cvss": 5.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2005-10-23",
+      "value": 24,
+      "avg_cvss": 5.6,
+      "cvss_count": 24
+    },
+    {
+      "date": "2005-10-24",
+      "value": 2,
+      "avg_cvss": 5.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-10-25",
+      "value": 10,
+      "avg_cvss": 4.8,
+      "cvss_count": 10
+    },
+    {
+      "date": "2005-10-26",
+      "value": 15,
+      "avg_cvss": 5.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2005-10-27",
+      "value": 38,
+      "avg_cvss": 5.8,
+      "cvss_count": 38
+    },
+    {
+      "date": "2005-10-28",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-10-30",
+      "value": 26,
+      "avg_cvss": 5.9,
+      "cvss_count": 26
+    },
+    {
+      "date": "2005-11-01",
+      "value": 44,
+      "avg_cvss": 5.4,
+      "cvss_count": 44
+    },
+    {
+      "date": "2005-11-02",
+      "value": 47,
+      "avg_cvss": 8.4,
+      "cvss_count": 47
+    },
+    {
+      "date": "2005-11-03",
+      "value": 17,
+      "avg_cvss": 5.8,
+      "cvss_count": 17
+    },
+    {
+      "date": "2005-11-04",
+      "value": 13,
+      "avg_cvss": 5.8,
+      "cvss_count": 13
+    },
+    {
+      "date": "2005-11-05",
+      "value": 13,
+      "avg_cvss": 5.2,
+      "cvss_count": 13
+    },
+    {
+      "date": "2005-11-06",
+      "value": 17,
+      "avg_cvss": 5.3,
+      "cvss_count": 17
+    },
+    {
+      "date": "2005-11-07",
+      "value": 2,
+      "avg_cvss": 8.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-11-09",
+      "value": 1,
+      "avg_cvss": 4.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2005-11-16",
+      "value": 63,
+      "avg_cvss": 6.2,
+      "cvss_count": 63
+    },
+    {
+      "date": "2005-11-17",
+      "value": 7,
+      "avg_cvss": 6.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2005-11-18",
+      "value": 39,
+      "avg_cvss": 6.7,
+      "cvss_count": 39
+    },
+    {
+      "date": "2005-11-19",
+      "value": 11,
+      "avg_cvss": 6.1,
+      "cvss_count": 11
+    },
+    {
+      "date": "2005-11-20",
+      "value": 10,
+      "avg_cvss": 5.5,
+      "cvss_count": 10
+    },
+    {
+      "date": "2005-11-21",
+      "value": 24,
+      "avg_cvss": 6.5,
+      "cvss_count": 24
+    },
+    {
+      "date": "2005-11-22",
+      "value": 34,
+      "avg_cvss": 6.1,
+      "cvss_count": 34
+    },
+    {
+      "date": "2005-11-23",
+      "value": 19,
+      "avg_cvss": 5.7,
+      "cvss_count": 19
+    },
+    {
+      "date": "2005-11-24",
+      "value": 18,
+      "avg_cvss": 5.8,
+      "cvss_count": 18
+    },
+    {
+      "date": "2005-11-25",
+      "value": 7,
+      "avg_cvss": 6.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2005-11-26",
+      "value": 35,
+      "avg_cvss": 6.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2005-11-27",
+      "value": 12,
+      "avg_cvss": 5.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2005-11-29",
+      "value": 45,
+      "avg_cvss": 6.8,
+      "cvss_count": 45
+    },
+    {
+      "date": "2005-11-30",
+      "value": 26,
+      "avg_cvss": 6.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2005-12-01",
+      "value": 39,
+      "avg_cvss": 6.8,
+      "cvss_count": 39
+    },
+    {
+      "date": "2005-12-02",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-12-03",
+      "value": 14,
+      "avg_cvss": 5.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2005-12-04",
+      "value": 12,
+      "avg_cvss": 6.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2005-12-05",
+      "value": 36,
+      "avg_cvss": 6.0,
+      "cvss_count": 36
+    },
+    {
+      "date": "2005-12-06",
+      "value": 15,
+      "avg_cvss": 6.1,
+      "cvss_count": 15
+    },
+    {
+      "date": "2005-12-07",
+      "value": 26,
+      "avg_cvss": 5.9,
+      "cvss_count": 26
+    },
+    {
+      "date": "2005-12-08",
+      "value": 29,
+      "avg_cvss": 5.9,
+      "cvss_count": 29
+    },
+    {
+      "date": "2005-12-09",
+      "value": 13,
+      "avg_cvss": 6.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2005-12-10",
+      "value": 11,
+      "avg_cvss": 5.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2005-12-11",
+      "value": 27,
+      "avg_cvss": 6.1,
+      "cvss_count": 27
+    },
+    {
+      "date": "2005-12-12",
+      "value": 2,
+      "avg_cvss": 5.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "2005-12-13",
+      "value": 23,
+      "avg_cvss": 5.5,
+      "cvss_count": 23
+    },
+    {
+      "date": "2005-12-14",
+      "value": 49,
+      "avg_cvss": 6.2,
+      "cvss_count": 49
+    },
+    {
+      "date": "2005-12-15",
+      "value": 23,
+      "avg_cvss": 6.2,
+      "cvss_count": 23
+    },
+    {
+      "date": "2005-12-16",
+      "value": 29,
+      "avg_cvss": 5.5,
+      "cvss_count": 29
+    },
+    {
+      "date": "2005-12-17",
+      "value": 35,
+      "avg_cvss": 6.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2005-12-19",
+      "value": 10,
+      "avg_cvss": 6.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2005-12-20",
+      "value": 76,
+      "avg_cvss": 5.6,
+      "cvss_count": 76
+    },
+    {
+      "date": "2005-12-21",
+      "value": 38,
+      "avg_cvss": 6.5,
+      "cvss_count": 38
+    },
+    {
+      "date": "2005-12-22",
+      "value": 46,
+      "avg_cvss": 5.9,
+      "cvss_count": 46
+    },
+    {
+      "date": "2005-12-23",
+      "value": 11,
+      "avg_cvss": 5.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2005-12-27",
+      "value": 3,
+      "avg_cvss": 4.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2005-12-28",
+      "value": 35,
+      "avg_cvss": 6.1,
+      "cvss_count": 35
+    },
+    {
+      "date": "2005-12-29",
+      "value": 23,
+      "avg_cvss": 6.3,
+      "cvss_count": 23
+    },
+    {
+      "date": "2005-12-30",
+      "value": 5,
+      "avg_cvss": 5.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2005-12-31",
+      "value": 384,
+      "avg_cvss": 5.8,
+      "cvss_count": 384
+    },
+    {
+      "date": "2006-01-03",
+      "value": 6,
+      "avg_cvss": 7.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2006-01-04",
+      "value": 13,
+      "avg_cvss": 5.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2006-01-05",
+      "value": 11,
+      "avg_cvss": 5.7,
+      "cvss_count": 11
+    },
+    {
+      "date": "2006-01-06",
+      "value": 12,
+      "avg_cvss": 5.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2006-01-07",
+      "value": 7,
+      "avg_cvss": 5.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2006-01-09",
+      "value": 39,
+      "avg_cvss": 5.9,
+      "cvss_count": 39
+    },
+    {
+      "date": "2006-01-10",
+      "value": 15,
+      "avg_cvss": 6.6,
+      "cvss_count": 15
+    },
+    {
+      "date": "2006-01-11",
+      "value": 19,
+      "avg_cvss": 5.7,
+      "cvss_count": 19
+    },
+    {
+      "date": "2006-01-12",
+      "value": 7,
+      "avg_cvss": 6.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2006-01-13",
+      "value": 19,
+      "avg_cvss": 5.5,
+      "cvss_count": 19
+    },
+    {
+      "date": "2006-01-14",
+      "value": 5,
+      "avg_cvss": 5.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2006-01-15",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-01-16",
+      "value": 9,
+      "avg_cvss": 5.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2006-01-17",
+      "value": 3,
+      "avg_cvss": 4.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2006-01-18",
+      "value": 59,
+      "avg_cvss": 8.0,
+      "cvss_count": 59
+    },
+    {
+      "date": "2006-01-19",
+      "value": 22,
+      "avg_cvss": 6.6,
+      "cvss_count": 22
+    },
+    {
+      "date": "2006-01-20",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2006-01-21",
+      "value": 25,
+      "avg_cvss": 5.7,
+      "cvss_count": 25
+    },
+    {
+      "date": "2006-01-22",
+      "value": 24,
+      "avg_cvss": 5.3,
+      "cvss_count": 24
+    },
+    {
+      "date": "2006-01-23",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2006-01-24",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-01-25",
+      "value": 36,
+      "avg_cvss": 5.3,
+      "cvss_count": 36
+    },
+    {
+      "date": "2006-01-26",
+      "value": 10,
+      "avg_cvss": 5.7,
+      "cvss_count": 10
+    },
+    {
+      "date": "2006-01-27",
+      "value": 12,
+      "avg_cvss": 5.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2006-01-30",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2006-01-31",
+      "value": 17,
+      "avg_cvss": 5.3,
+      "cvss_count": 17
+    },
+    {
+      "date": "2006-02-01",
+      "value": 27,
+      "avg_cvss": 5.2,
+      "cvss_count": 27
+    },
+    {
+      "date": "2006-02-02",
+      "value": 25,
+      "avg_cvss": 5.7,
+      "cvss_count": 25
+    },
+    {
+      "date": "2006-02-04",
+      "value": 22,
+      "avg_cvss": 6.1,
+      "cvss_count": 22
+    },
+    {
+      "date": "2006-02-06",
+      "value": 8,
+      "avg_cvss": 5.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "2006-02-07",
+      "value": 10,
+      "avg_cvss": 5.2,
+      "cvss_count": 10
+    },
+    {
+      "date": "2006-02-08",
+      "value": 27,
+      "avg_cvss": 5.9,
+      "cvss_count": 27
+    },
+    {
+      "date": "2006-02-09",
+      "value": 18,
+      "avg_cvss": 5.7,
+      "cvss_count": 18
+    },
+    {
+      "date": "2006-02-10",
+      "value": 18,
+      "avg_cvss": 5.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2006-02-11",
+      "value": 1,
+      "avg_cvss": 4.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-02-13",
+      "value": 34,
+      "avg_cvss": 6.0,
+      "cvss_count": 34
+    },
+    {
+      "date": "2006-02-14",
+      "value": 13,
+      "avg_cvss": 6.2,
+      "cvss_count": 13
+    },
+    {
+      "date": "2006-02-15",
+      "value": 42,
+      "avg_cvss": 6.1,
+      "cvss_count": 42
+    },
+    {
+      "date": "2006-02-16",
+      "value": 16,
+      "avg_cvss": 5.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2006-02-17",
+      "value": 4,
+      "avg_cvss": 5.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "2006-02-18",
+      "value": 23,
+      "avg_cvss": 5.4,
+      "cvss_count": 23
+    },
+    {
+      "date": "2006-02-19",
+      "value": 28,
+      "avg_cvss": 5.7,
+      "cvss_count": 28
+    },
+    {
+      "date": "2006-02-20",
+      "value": 3,
+      "avg_cvss": 3.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2006-02-21",
+      "value": 19,
+      "avg_cvss": 6.1,
+      "cvss_count": 19
+    },
+    {
+      "date": "2006-02-22",
+      "value": 17,
+      "avg_cvss": 5.0,
+      "cvss_count": 17
+    },
+    {
+      "date": "2006-02-23",
+      "value": 24,
+      "avg_cvss": 6.3,
+      "cvss_count": 24
+    },
+    {
+      "date": "2006-02-24",
+      "value": 18,
+      "avg_cvss": 5.8,
+      "cvss_count": 18
+    },
+    {
+      "date": "2006-02-25",
+      "value": 14,
+      "avg_cvss": 4.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2006-02-27",
+      "value": 5,
+      "avg_cvss": 7.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2006-02-28",
+      "value": 32,
+      "avg_cvss": 5.1,
+      "cvss_count": 32
+    },
+    {
+      "date": "2006-03-01",
+      "value": 10,
+      "avg_cvss": 6.4,
+      "cvss_count": 10
+    },
+    {
+      "date": "2006-03-02",
+      "value": 15,
+      "avg_cvss": 5.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2006-03-03",
+      "value": 24,
+      "avg_cvss": 4.9,
+      "cvss_count": 24
+    },
+    {
+      "date": "2006-03-06",
+      "value": 18,
+      "avg_cvss": 6.0,
+      "cvss_count": 18
+    },
+    {
+      "date": "2006-03-07",
+      "value": 51,
+      "avg_cvss": 5.8,
+      "cvss_count": 51
+    },
+    {
+      "date": "2006-03-08",
+      "value": 4,
+      "avg_cvss": 4.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2006-03-09",
+      "value": 57,
+      "avg_cvss": 5.9,
+      "cvss_count": 57
+    },
+    {
+      "date": "2006-03-10",
+      "value": 28,
+      "avg_cvss": 5.6,
+      "cvss_count": 28
+    },
+    {
+      "date": "2006-03-12",
+      "value": 13,
+      "avg_cvss": 5.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2006-03-13",
+      "value": 9,
+      "avg_cvss": 5.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2006-03-14",
+      "value": 49,
+      "avg_cvss": 5.5,
+      "cvss_count": 49
+    },
+    {
+      "date": "2006-03-15",
+      "value": 10,
+      "avg_cvss": 5.9,
+      "cvss_count": 10
+    },
+    {
+      "date": "2006-03-16",
+      "value": 1,
+      "avg_cvss": 2.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-03-17",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2006-03-19",
+      "value": 49,
+      "avg_cvss": 6.0,
+      "cvss_count": 49
+    },
+    {
+      "date": "2006-03-20",
+      "value": 5,
+      "avg_cvss": 5.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2006-03-21",
+      "value": 22,
+      "avg_cvss": 5.7,
+      "cvss_count": 22
+    },
+    {
+      "date": "2006-03-22",
+      "value": 17,
+      "avg_cvss": 5.9,
+      "cvss_count": 17
+    },
+    {
+      "date": "2006-03-23",
+      "value": 20,
+      "avg_cvss": 6.9,
+      "cvss_count": 20
+    },
+    {
+      "date": "2006-03-24",
+      "value": 16,
+      "avg_cvss": 5.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2006-03-25",
+      "value": 3,
+      "avg_cvss": 5.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2006-03-26",
+      "value": 7,
+      "avg_cvss": 5.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2006-03-27",
+      "value": 1,
+      "avg_cvss": 1.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-03-28",
+      "value": 38,
+      "avg_cvss": 5.1,
+      "cvss_count": 38
+    },
+    {
+      "date": "2006-03-29",
+      "value": 21,
+      "avg_cvss": 5.4,
+      "cvss_count": 21
+    },
+    {
+      "date": "2006-03-30",
+      "value": 36,
+      "avg_cvss": 6.0,
+      "cvss_count": 36
+    },
+    {
+      "date": "2006-03-31",
+      "value": 16,
+      "avg_cvss": 5.9,
+      "cvss_count": 16
+    },
+    {
+      "date": "2006-04-01",
+      "value": 8,
+      "avg_cvss": 5.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2006-04-02",
+      "value": 12,
+      "avg_cvss": 6.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2006-04-03",
+      "value": 17,
+      "avg_cvss": 5.8,
+      "cvss_count": 17
+    },
+    {
+      "date": "2006-04-04",
+      "value": 14,
+      "avg_cvss": 6.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2006-04-05",
+      "value": 15,
+      "avg_cvss": 5.5,
+      "cvss_count": 15
+    },
+    {
+      "date": "2006-04-06",
+      "value": 27,
+      "avg_cvss": 6.0,
+      "cvss_count": 27
+    },
+    {
+      "date": "2006-04-07",
+      "value": 16,
+      "avg_cvss": 6.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2006-04-08",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-04-10",
+      "value": 8,
+      "avg_cvss": 3.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2006-04-11",
+      "value": 56,
+      "avg_cvss": 5.7,
+      "cvss_count": 56
+    },
+    {
+      "date": "2006-04-12",
+      "value": 14,
+      "avg_cvss": 5.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2006-04-13",
+      "value": 39,
+      "avg_cvss": 5.7,
+      "cvss_count": 39
+    },
+    {
+      "date": "2006-04-14",
+      "value": 29,
+      "avg_cvss": 6.9,
+      "cvss_count": 29
+    },
+    {
+      "date": "2006-04-15",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2006-04-17",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2006-04-18",
+      "value": 33,
+      "avg_cvss": 5.1,
+      "cvss_count": 33
+    },
+    {
+      "date": "2006-04-19",
+      "value": 29,
+      "avg_cvss": 4.8,
+      "cvss_count": 29
+    },
+    {
+      "date": "2006-04-20",
+      "value": 77,
+      "avg_cvss": 6.2,
+      "cvss_count": 77
+    },
+    {
+      "date": "2006-04-21",
+      "value": 36,
+      "avg_cvss": 5.4,
+      "cvss_count": 36
+    },
+    {
+      "date": "2006-04-24",
+      "value": 4,
+      "avg_cvss": 5.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2006-04-25",
+      "value": 50,
+      "avg_cvss": 5.4,
+      "cvss_count": 50
+    },
+    {
+      "date": "2006-04-26",
+      "value": 38,
+      "avg_cvss": 5.4,
+      "cvss_count": 38
+    },
+    {
+      "date": "2006-04-27",
+      "value": 19,
+      "avg_cvss": 5.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2006-04-28",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-04-29",
+      "value": 25,
+      "avg_cvss": 5.6,
+      "cvss_count": 25
+    },
+    {
+      "date": "2006-05-01",
+      "value": 22,
+      "avg_cvss": 5.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2006-05-02",
+      "value": 17,
+      "avg_cvss": 5.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2006-05-03",
+      "value": 14,
+      "avg_cvss": 6.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2006-05-04",
+      "value": 29,
+      "avg_cvss": 5.8,
+      "cvss_count": 29
+    },
+    {
+      "date": "2006-05-05",
+      "value": 33,
+      "avg_cvss": 5.5,
+      "cvss_count": 33
+    },
+    {
+      "date": "2006-05-08",
+      "value": 2,
+      "avg_cvss": 6.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2006-05-09",
+      "value": 40,
+      "avg_cvss": 6.0,
+      "cvss_count": 40
+    },
+    {
+      "date": "2006-05-10",
+      "value": 30,
+      "avg_cvss": 6.0,
+      "cvss_count": 30
+    },
+    {
+      "date": "2006-05-11",
+      "value": 8,
+      "avg_cvss": 7.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2006-05-12",
+      "value": 66,
+      "avg_cvss": 5.6,
+      "cvss_count": 66
+    },
+    {
+      "date": "2006-05-15",
+      "value": 19,
+      "avg_cvss": 5.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2006-05-16",
+      "value": 31,
+      "avg_cvss": 5.8,
+      "cvss_count": 31
+    },
+    {
+      "date": "2006-05-17",
+      "value": 19,
+      "avg_cvss": 6.6,
+      "cvss_count": 19
+    },
+    {
+      "date": "2006-05-18",
+      "value": 7,
+      "avg_cvss": 4.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2006-05-19",
+      "value": 35,
+      "avg_cvss": 5.6,
+      "cvss_count": 35
+    },
+    {
+      "date": "2006-05-20",
+      "value": 9,
+      "avg_cvss": 7.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2006-05-22",
+      "value": 42,
+      "avg_cvss": 6.2,
+      "cvss_count": 42
+    },
+    {
+      "date": "2006-05-23",
+      "value": 13,
+      "avg_cvss": 5.4,
+      "cvss_count": 13
+    },
+    {
+      "date": "2006-05-24",
+      "value": 33,
+      "avg_cvss": 5.9,
+      "cvss_count": 33
+    },
+    {
+      "date": "2006-05-25",
+      "value": 16,
+      "avg_cvss": 5.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2006-05-26",
+      "value": 11,
+      "avg_cvss": 4.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2006-05-27",
+      "value": 3,
+      "avg_cvss": 6.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2006-05-28",
+      "value": 2,
+      "avg_cvss": 5.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2006-05-29",
+      "value": 1,
+      "avg_cvss": 2.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-05-30",
+      "value": 38,
+      "avg_cvss": 5.7,
+      "cvss_count": 38
+    },
+    {
+      "date": "2006-05-31",
+      "value": 43,
+      "avg_cvss": 5.8,
+      "cvss_count": 43
+    },
+    {
+      "date": "2006-06-01",
+      "value": 39,
+      "avg_cvss": 6.0,
+      "cvss_count": 39
+    },
+    {
+      "date": "2006-06-02",
+      "value": 41,
+      "avg_cvss": 5.7,
+      "cvss_count": 41
+    },
+    {
+      "date": "2006-06-03",
+      "value": 15,
+      "avg_cvss": 6.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2006-06-05",
+      "value": 25,
+      "avg_cvss": 7.0,
+      "cvss_count": 25
+    },
+    {
+      "date": "2006-06-06",
+      "value": 45,
+      "avg_cvss": 6.4,
+      "cvss_count": 45
+    },
+    {
+      "date": "2006-06-07",
+      "value": 28,
+      "avg_cvss": 5.5,
+      "cvss_count": 28
+    },
+    {
+      "date": "2006-06-08",
+      "value": 6,
+      "avg_cvss": 5.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2006-06-09",
+      "value": 15,
+      "avg_cvss": 5.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2006-06-12",
+      "value": 39,
+      "avg_cvss": 5.4,
+      "cvss_count": 39
+    },
+    {
+      "date": "2006-06-13",
+      "value": 47,
+      "avg_cvss": 6.1,
+      "cvss_count": 47
+    },
+    {
+      "date": "2006-06-14",
+      "value": 4,
+      "avg_cvss": 8.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2006-06-15",
+      "value": 28,
+      "avg_cvss": 5.6,
+      "cvss_count": 28
+    },
+    {
+      "date": "2006-06-16",
+      "value": 16,
+      "avg_cvss": 5.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2006-06-17",
+      "value": 1,
+      "avg_cvss": 9.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-06-19",
+      "value": 36,
+      "avg_cvss": 5.2,
+      "cvss_count": 36
+    },
+    {
+      "date": "2006-06-20",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2006-06-21",
+      "value": 16,
+      "avg_cvss": 5.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2006-06-22",
+      "value": 37,
+      "avg_cvss": 5.9,
+      "cvss_count": 37
+    },
+    {
+      "date": "2006-06-23",
+      "value": 41,
+      "avg_cvss": 5.8,
+      "cvss_count": 41
+    },
+    {
+      "date": "2006-06-24",
+      "value": 20,
+      "avg_cvss": 6.0,
+      "cvss_count": 20
+    },
+    {
+      "date": "2006-06-26",
+      "value": 9,
+      "avg_cvss": 4.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2006-06-27",
+      "value": 40,
+      "avg_cvss": 5.3,
+      "cvss_count": 40
+    },
+    {
+      "date": "2006-06-28",
+      "value": 30,
+      "avg_cvss": 5.8,
+      "cvss_count": 30
+    },
+    {
+      "date": "2006-06-29",
+      "value": 28,
+      "avg_cvss": 5.3,
+      "cvss_count": 28
+    },
+    {
+      "date": "2006-06-30",
+      "value": 21,
+      "avg_cvss": 5.4,
+      "cvss_count": 21
+    },
+    {
+      "date": "2006-07-03",
+      "value": 14,
+      "avg_cvss": 5.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2006-07-05",
+      "value": 4,
+      "avg_cvss": 5.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2006-07-06",
+      "value": 53,
+      "avg_cvss": 5.5,
+      "cvss_count": 53
+    },
+    {
+      "date": "2006-07-07",
+      "value": 29,
+      "avg_cvss": 5.9,
+      "cvss_count": 29
+    },
+    {
+      "date": "2006-07-08",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-07-10",
+      "value": 27,
+      "avg_cvss": 5.7,
+      "cvss_count": 27
+    },
+    {
+      "date": "2006-07-11",
+      "value": 19,
+      "avg_cvss": 6.8,
+      "cvss_count": 19
+    },
+    {
+      "date": "2006-07-12",
+      "value": 20,
+      "avg_cvss": 6.3,
+      "cvss_count": 20
+    },
+    {
+      "date": "2006-07-13",
+      "value": 56,
+      "avg_cvss": 6.0,
+      "cvss_count": 56
+    },
+    {
+      "date": "2006-07-14",
+      "value": 1,
+      "avg_cvss": 5.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-07-18",
+      "value": 59,
+      "avg_cvss": 5.6,
+      "cvss_count": 59
+    },
+    {
+      "date": "2006-07-21",
+      "value": 91,
+      "avg_cvss": 6.7,
+      "cvss_count": 91
+    },
+    {
+      "date": "2006-07-24",
+      "value": 33,
+      "avg_cvss": 5.8,
+      "cvss_count": 33
+    },
+    {
+      "date": "2006-07-25",
+      "value": 35,
+      "avg_cvss": 5.2,
+      "cvss_count": 35
+    },
+    {
+      "date": "2006-07-26",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-07-27",
+      "value": 40,
+      "avg_cvss": 6.2,
+      "cvss_count": 40
+    },
+    {
+      "date": "2006-07-28",
+      "value": 21,
+      "avg_cvss": 5.4,
+      "cvss_count": 21
+    },
+    {
+      "date": "2006-07-29",
+      "value": 2,
+      "avg_cvss": 3.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2006-07-31",
+      "value": 23,
+      "avg_cvss": 5.7,
+      "cvss_count": 23
+    },
+    {
+      "date": "2006-08-01",
+      "value": 24,
+      "avg_cvss": 6.6,
+      "cvss_count": 24
+    },
+    {
+      "date": "2006-08-02",
+      "value": 8,
+      "avg_cvss": 5.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2006-08-03",
+      "value": 16,
+      "avg_cvss": 6.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2006-08-04",
+      "value": 4,
+      "avg_cvss": 7.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2006-08-05",
+      "value": 24,
+      "avg_cvss": 6.4,
+      "cvss_count": 24
+    },
+    {
+      "date": "2006-08-07",
+      "value": 17,
+      "avg_cvss": 5.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2006-08-08",
+      "value": 18,
+      "avg_cvss": 5.8,
+      "cvss_count": 18
+    },
+    {
+      "date": "2006-08-09",
+      "value": 42,
+      "avg_cvss": 7.0,
+      "cvss_count": 42
+    },
+    {
+      "date": "2006-08-10",
+      "value": 22,
+      "avg_cvss": 6.2,
+      "cvss_count": 22
+    },
+    {
+      "date": "2006-08-11",
+      "value": 25,
+      "avg_cvss": 5.7,
+      "cvss_count": 25
+    },
+    {
+      "date": "2006-08-14",
+      "value": 42,
+      "avg_cvss": 6.1,
+      "cvss_count": 42
+    },
+    {
+      "date": "2006-08-15",
+      "value": 3,
+      "avg_cvss": 5.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2006-08-16",
+      "value": 13,
+      "avg_cvss": 6.8,
+      "cvss_count": 13
+    },
+    {
+      "date": "2006-08-17",
+      "value": 39,
+      "avg_cvss": 5.8,
+      "cvss_count": 39
+    },
+    {
+      "date": "2006-08-18",
+      "value": 14,
+      "avg_cvss": 5.7,
+      "cvss_count": 14
+    },
+    {
+      "date": "2006-08-21",
+      "value": 38,
+      "avg_cvss": 6.5,
+      "cvss_count": 38
+    },
+    {
+      "date": "2006-08-22",
+      "value": 12,
+      "avg_cvss": 6.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2006-08-23",
+      "value": 24,
+      "avg_cvss": 6.0,
+      "cvss_count": 24
+    },
+    {
+      "date": "2006-08-24",
+      "value": 26,
+      "avg_cvss": 6.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2006-08-25",
+      "value": 6,
+      "avg_cvss": 5.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2006-08-26",
+      "value": 15,
+      "avg_cvss": 6.5,
+      "cvss_count": 15
+    },
+    {
+      "date": "2006-08-27",
+      "value": 11,
+      "avg_cvss": 5.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2006-08-28",
+      "value": 6,
+      "avg_cvss": 5.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2006-08-29",
+      "value": 23,
+      "avg_cvss": 6.5,
+      "cvss_count": 23
+    },
+    {
+      "date": "2006-08-30",
+      "value": 11,
+      "avg_cvss": 6.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2006-08-31",
+      "value": 55,
+      "avg_cvss": 6.3,
+      "cvss_count": 55
+    },
+    {
+      "date": "2006-09-01",
+      "value": 12,
+      "avg_cvss": 6.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2006-09-05",
+      "value": 9,
+      "avg_cvss": 6.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2006-09-06",
+      "value": 41,
+      "avg_cvss": 7.0,
+      "cvss_count": 41
+    },
+    {
+      "date": "2006-09-07",
+      "value": 31,
+      "avg_cvss": 6.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2006-09-08",
+      "value": 23,
+      "avg_cvss": 6.4,
+      "cvss_count": 23
+    },
+    {
+      "date": "2006-09-09",
+      "value": 22,
+      "avg_cvss": 5.7,
+      "cvss_count": 22
+    },
+    {
+      "date": "2006-09-11",
+      "value": 14,
+      "avg_cvss": 5.7,
+      "cvss_count": 14
+    },
+    {
+      "date": "2006-09-12",
+      "value": 34,
+      "avg_cvss": 6.0,
+      "cvss_count": 34
+    },
+    {
+      "date": "2006-09-13",
+      "value": 42,
+      "avg_cvss": 5.9,
+      "cvss_count": 42
+    },
+    {
+      "date": "2006-09-14",
+      "value": 36,
+      "avg_cvss": 5.8,
+      "cvss_count": 36
+    },
+    {
+      "date": "2006-09-15",
+      "value": 27,
+      "avg_cvss": 6.0,
+      "cvss_count": 27
+    },
+    {
+      "date": "2006-09-19",
+      "value": 62,
+      "avg_cvss": 6.3,
+      "cvss_count": 62
+    },
+    {
+      "date": "2006-09-20",
+      "value": 1,
+      "avg_cvss": 6.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-09-21",
+      "value": 23,
+      "avg_cvss": 6.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2006-09-22",
+      "value": 3,
+      "avg_cvss": 5.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2006-09-23",
+      "value": 30,
+      "avg_cvss": 6.4,
+      "cvss_count": 30
+    },
+    {
+      "date": "2006-09-25",
+      "value": 15,
+      "avg_cvss": 5.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2006-09-26",
+      "value": 20,
+      "avg_cvss": 6.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2006-09-27",
+      "value": 53,
+      "avg_cvss": 6.9,
+      "cvss_count": 53
+    },
+    {
+      "date": "2006-09-28",
+      "value": 23,
+      "avg_cvss": 6.2,
+      "cvss_count": 23
+    },
+    {
+      "date": "2006-09-29",
+      "value": 29,
+      "avg_cvss": 6.9,
+      "cvss_count": 29
+    },
+    {
+      "date": "2006-10-03",
+      "value": 51,
+      "avg_cvss": 6.2,
+      "cvss_count": 51
+    },
+    {
+      "date": "2006-10-05",
+      "value": 25,
+      "avg_cvss": 6.8,
+      "cvss_count": 25
+    },
+    {
+      "date": "2006-10-10",
+      "value": 86,
+      "avg_cvss": 6.4,
+      "cvss_count": 86
+    },
+    {
+      "date": "2006-10-11",
+      "value": 7,
+      "avg_cvss": 7.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2006-10-12",
+      "value": 31,
+      "avg_cvss": 6.5,
+      "cvss_count": 31
+    },
+    {
+      "date": "2006-10-13",
+      "value": 11,
+      "avg_cvss": 7.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2006-10-16",
+      "value": 11,
+      "avg_cvss": 5.2,
+      "cvss_count": 11
+    },
+    {
+      "date": "2006-10-17",
+      "value": 34,
+      "avg_cvss": 6.5,
+      "cvss_count": 34
+    },
+    {
+      "date": "2006-10-18",
+      "value": 70,
+      "avg_cvss": 8.2,
+      "cvss_count": 70
+    },
+    {
+      "date": "2006-10-19",
+      "value": 5,
+      "avg_cvss": 5.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2006-10-20",
+      "value": 35,
+      "avg_cvss": 6.5,
+      "cvss_count": 35
+    },
+    {
+      "date": "2006-10-21",
+      "value": 1,
+      "avg_cvss": 6.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2006-10-23",
+      "value": 19,
+      "avg_cvss": 5.6,
+      "cvss_count": 19
+    },
+    {
+      "date": "2006-10-24",
+      "value": 20,
+      "avg_cvss": 6.2,
+      "cvss_count": 20
+    },
+    {
+      "date": "2006-10-25",
+      "value": 26,
+      "avg_cvss": 6.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2006-10-26",
+      "value": 43,
+      "avg_cvss": 6.2,
+      "cvss_count": 43
+    },
+    {
+      "date": "2006-10-27",
+      "value": 28,
+      "avg_cvss": 6.3,
+      "cvss_count": 28
+    },
+    {
+      "date": "2006-10-28",
+      "value": 11,
+      "avg_cvss": 5.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2006-10-30",
+      "value": 6,
+      "avg_cvss": 6.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2006-10-31",
+      "value": 26,
+      "avg_cvss": 6.9,
+      "cvss_count": 26
+    },
+    {
+      "date": "2006-11-01",
+      "value": 16,
+      "avg_cvss": 6.9,
+      "cvss_count": 16
+    },
+    {
+      "date": "2006-11-03",
+      "value": 30,
+      "avg_cvss": 6.5,
+      "cvss_count": 30
+    },
+    {
+      "date": "2006-11-04",
+      "value": 26,
+      "avg_cvss": 5.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2006-11-06",
+      "value": 40,
+      "avg_cvss": 6.0,
+      "cvss_count": 40
+    },
+    {
+      "date": "2006-11-07",
+      "value": 23,
+      "avg_cvss": 6.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2006-11-08",
+      "value": 31,
+      "avg_cvss": 6.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2006-11-09",
+      "value": 4,
+      "avg_cvss": 5.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2006-11-10",
+      "value": 31,
+      "avg_cvss": 6.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2006-11-11",
+      "value": 5,
+      "avg_cvss": 6.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2006-11-14",
+      "value": 27,
+      "avg_cvss": 6.8,
+      "cvss_count": 27
+    },
+    {
+      "date": "2006-11-15",
+      "value": 29,
+      "avg_cvss": 6.8,
+      "cvss_count": 29
+    },
+    {
+      "date": "2006-11-16",
+      "value": 15,
+      "avg_cvss": 7.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2006-11-17",
+      "value": 26,
+      "avg_cvss": 6.3,
+      "cvss_count": 26
+    },
+    {
+      "date": "2006-11-18",
+      "value": 5,
+      "avg_cvss": 7.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2006-11-20",
+      "value": 16,
+      "avg_cvss": 7.0,
+      "cvss_count": 16
+    },
+    {
+      "date": "2006-11-21",
+      "value": 31,
+      "avg_cvss": 6.7,
+      "cvss_count": 31
+    },
+    {
+      "date": "2006-11-22",
+      "value": 38,
+      "avg_cvss": 6.7,
+      "cvss_count": 38
+    },
+    {
+      "date": "2006-11-24",
+      "value": 26,
+      "avg_cvss": 6.3,
+      "cvss_count": 26
+    },
+    {
+      "date": "2006-11-26",
+      "value": 15,
+      "avg_cvss": 6.5,
+      "cvss_count": 15
+    },
+    {
+      "date": "2006-11-27",
+      "value": 7,
+      "avg_cvss": 4.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2006-11-28",
+      "value": 32,
+      "avg_cvss": 6.6,
+      "cvss_count": 32
+    },
+    {
+      "date": "2006-11-29",
+      "value": 9,
+      "avg_cvss": 6.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2006-11-30",
+      "value": 25,
+      "avg_cvss": 6.5,
+      "cvss_count": 25
+    },
+    {
+      "date": "2006-12-01",
+      "value": 41,
+      "avg_cvss": 7.1,
+      "cvss_count": 41
+    },
+    {
+      "date": "2006-12-02",
+      "value": 14,
+      "avg_cvss": 6.6,
+      "cvss_count": 14
+    },
+    {
+      "date": "2006-12-03",
+      "value": 9,
+      "avg_cvss": 6.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2006-12-04",
+      "value": 47,
+      "avg_cvss": 7.1,
+      "cvss_count": 47
+    },
+    {
+      "date": "2006-12-05",
+      "value": 15,
+      "avg_cvss": 6.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2006-12-06",
+      "value": 17,
+      "avg_cvss": 6.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2006-12-07",
+      "value": 47,
+      "avg_cvss": 7.3,
+      "cvss_count": 47
+    },
+    {
+      "date": "2006-12-08",
+      "value": 16,
+      "avg_cvss": 6.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2006-12-10",
+      "value": 56,
+      "avg_cvss": 6.8,
+      "cvss_count": 56
+    },
+    {
+      "date": "2006-12-11",
+      "value": 19,
+      "avg_cvss": 7.4,
+      "cvss_count": 19
+    },
+    {
+      "date": "2006-12-12",
+      "value": 17,
+      "avg_cvss": 6.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2006-12-13",
+      "value": 8,
+      "avg_cvss": 6.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2006-12-14",
+      "value": 62,
+      "avg_cvss": 6.8,
+      "cvss_count": 62
+    },
+    {
+      "date": "2006-12-15",
+      "value": 43,
+      "avg_cvss": 6.8,
+      "cvss_count": 43
+    },
+    {
+      "date": "2006-12-18",
+      "value": 31,
+      "avg_cvss": 6.7,
+      "cvss_count": 31
+    },
+    {
+      "date": "2006-12-19",
+      "value": 8,
+      "avg_cvss": 6.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2006-12-20",
+      "value": 46,
+      "avg_cvss": 5.8,
+      "cvss_count": 46
+    },
+    {
+      "date": "2006-12-21",
+      "value": 26,
+      "avg_cvss": 6.6,
+      "cvss_count": 26
+    },
+    {
+      "date": "2006-12-22",
+      "value": 3,
+      "avg_cvss": 5.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2006-12-23",
+      "value": 24,
+      "avg_cvss": 7.0,
+      "cvss_count": 24
+    },
+    {
+      "date": "2006-12-26",
+      "value": 23,
+      "avg_cvss": 6.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2006-12-27",
+      "value": 31,
+      "avg_cvss": 6.6,
+      "cvss_count": 31
+    },
+    {
+      "date": "2006-12-28",
+      "value": 33,
+      "avg_cvss": 7.1,
+      "cvss_count": 33
+    },
+    {
+      "date": "2006-12-29",
+      "value": 18,
+      "avg_cvss": 6.1,
+      "cvss_count": 18
+    },
+    {
+      "date": "2006-12-31",
+      "value": 125,
+      "avg_cvss": 7.2,
+      "cvss_count": 125
+    },
+    {
+      "date": "2007-01-01",
+      "value": 1,
+      "avg_cvss": 6.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-01-03",
+      "value": 7,
+      "avg_cvss": 6.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2007-01-04",
+      "value": 10,
+      "avg_cvss": 7.3,
+      "cvss_count": 10
+    },
+    {
+      "date": "2007-01-05",
+      "value": 25,
+      "avg_cvss": 6.9,
+      "cvss_count": 25
+    },
+    {
+      "date": "2007-01-08",
+      "value": 3,
+      "avg_cvss": 8.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2007-01-09",
+      "value": 64,
+      "avg_cvss": 7.1,
+      "cvss_count": 64
+    },
+    {
+      "date": "2007-01-10",
+      "value": 8,
+      "avg_cvss": 7.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2007-01-11",
+      "value": 28,
+      "avg_cvss": 7.2,
+      "cvss_count": 28
+    },
+    {
+      "date": "2007-01-12",
+      "value": 16,
+      "avg_cvss": 6.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2007-01-13",
+      "value": 20,
+      "avg_cvss": 7.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2007-01-16",
+      "value": 32,
+      "avg_cvss": 7.4,
+      "cvss_count": 32
+    },
+    {
+      "date": "2007-01-17",
+      "value": 41,
+      "avg_cvss": 5.6,
+      "cvss_count": 41
+    },
+    {
+      "date": "2007-01-18",
+      "value": 38,
+      "avg_cvss": 7.1,
+      "cvss_count": 38
+    },
+    {
+      "date": "2007-01-19",
+      "value": 56,
+      "avg_cvss": 6.6,
+      "cvss_count": 56
+    },
+    {
+      "date": "2007-01-20",
+      "value": 1,
+      "avg_cvss": 6.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-01-22",
+      "value": 6,
+      "avg_cvss": 6.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2007-01-23",
+      "value": 44,
+      "avg_cvss": 6.3,
+      "cvss_count": 44
+    },
+    {
+      "date": "2007-01-24",
+      "value": 12,
+      "avg_cvss": 7.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2007-01-25",
+      "value": 28,
+      "avg_cvss": 7.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2007-01-26",
+      "value": 33,
+      "avg_cvss": 6.4,
+      "cvss_count": 33
+    },
+    {
+      "date": "2007-01-27",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-01-29",
+      "value": 34,
+      "avg_cvss": 5.9,
+      "cvss_count": 34
+    },
+    {
+      "date": "2007-01-30",
+      "value": 50,
+      "avg_cvss": 6.7,
+      "cvss_count": 50
+    },
+    {
+      "date": "2007-01-31",
+      "value": 36,
+      "avg_cvss": 6.8,
+      "cvss_count": 36
+    },
+    {
+      "date": "2007-02-01",
+      "value": 15,
+      "avg_cvss": 6.8,
+      "cvss_count": 15
+    },
+    {
+      "date": "2007-02-02",
+      "value": 9,
+      "avg_cvss": 5.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2007-02-03",
+      "value": 27,
+      "avg_cvss": 6.6,
+      "cvss_count": 27
+    },
+    {
+      "date": "2007-02-04",
+      "value": 13,
+      "avg_cvss": 7.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2007-02-06",
+      "value": 38,
+      "avg_cvss": 6.7,
+      "cvss_count": 38
+    },
+    {
+      "date": "2007-02-07",
+      "value": 39,
+      "avg_cvss": 5.6,
+      "cvss_count": 39
+    },
+    {
+      "date": "2007-02-08",
+      "value": 34,
+      "avg_cvss": 6.6,
+      "cvss_count": 34
+    },
+    {
+      "date": "2007-02-09",
+      "value": 20,
+      "avg_cvss": 7.0,
+      "cvss_count": 20
+    },
+    {
+      "date": "2007-02-11",
+      "value": 1,
+      "avg_cvss": 7.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-02-12",
+      "value": 43,
+      "avg_cvss": 6.8,
+      "cvss_count": 43
+    },
+    {
+      "date": "2007-02-13",
+      "value": 29,
+      "avg_cvss": 7.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2007-02-14",
+      "value": 22,
+      "avg_cvss": 6.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2007-02-15",
+      "value": 25,
+      "avg_cvss": 7.4,
+      "cvss_count": 25
+    },
+    {
+      "date": "2007-02-16",
+      "value": 34,
+      "avg_cvss": 6.9,
+      "cvss_count": 34
+    },
+    {
+      "date": "2007-02-20",
+      "value": 9,
+      "avg_cvss": 6.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2007-02-21",
+      "value": 50,
+      "avg_cvss": 7.5,
+      "cvss_count": 50
+    },
+    {
+      "date": "2007-02-22",
+      "value": 23,
+      "avg_cvss": 7.8,
+      "cvss_count": 23
+    },
+    {
+      "date": "2007-02-23",
+      "value": 28,
+      "avg_cvss": 7.4,
+      "cvss_count": 28
+    },
+    {
+      "date": "2007-02-24",
+      "value": 23,
+      "avg_cvss": 7.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2007-02-26",
+      "value": 34,
+      "avg_cvss": 6.5,
+      "cvss_count": 34
+    },
+    {
+      "date": "2007-02-27",
+      "value": 18,
+      "avg_cvss": 6.6,
+      "cvss_count": 18
+    },
+    {
+      "date": "2007-03-02",
+      "value": 114,
+      "avg_cvss": 6.4,
+      "cvss_count": 114
+    },
+    {
+      "date": "2007-03-03",
+      "value": 41,
+      "avg_cvss": 6.7,
+      "cvss_count": 41
+    },
+    {
+      "date": "2007-03-04",
+      "value": 2,
+      "avg_cvss": 5.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2007-03-05",
+      "value": 13,
+      "avg_cvss": 6.8,
+      "cvss_count": 13
+    },
+    {
+      "date": "2007-03-06",
+      "value": 36,
+      "avg_cvss": 6.9,
+      "cvss_count": 36
+    },
+    {
+      "date": "2007-03-07",
+      "value": 59,
+      "avg_cvss": 6.9,
+      "cvss_count": 59
+    },
+    {
+      "date": "2007-03-08",
+      "value": 13,
+      "avg_cvss": 6.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2007-03-09",
+      "value": 4,
+      "avg_cvss": 4.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "2007-03-10",
+      "value": 45,
+      "avg_cvss": 7.2,
+      "cvss_count": 45
+    },
+    {
+      "date": "2007-03-12",
+      "value": 10,
+      "avg_cvss": 6.8,
+      "cvss_count": 10
+    },
+    {
+      "date": "2007-03-13",
+      "value": 32,
+      "avg_cvss": 7.4,
+      "cvss_count": 32
+    },
+    {
+      "date": "2007-03-14",
+      "value": 19,
+      "avg_cvss": 6.5,
+      "cvss_count": 19
+    },
+    {
+      "date": "2007-03-15",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-03-16",
+      "value": 38,
+      "avg_cvss": 6.2,
+      "cvss_count": 38
+    },
+    {
+      "date": "2007-03-17",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-03-19",
+      "value": 9,
+      "avg_cvss": 5.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2007-03-20",
+      "value": 61,
+      "avg_cvss": 6.3,
+      "cvss_count": 61
+    },
+    {
+      "date": "2007-03-21",
+      "value": 43,
+      "avg_cvss": 7.4,
+      "cvss_count": 43
+    },
+    {
+      "date": "2007-03-22",
+      "value": 21,
+      "avg_cvss": 6.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2007-03-23",
+      "value": 29,
+      "avg_cvss": 7.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2007-03-24",
+      "value": 20,
+      "avg_cvss": 8.2,
+      "cvss_count": 20
+    },
+    {
+      "date": "2007-03-26",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2007-03-27",
+      "value": 24,
+      "avg_cvss": 7.0,
+      "cvss_count": 24
+    },
+    {
+      "date": "2007-03-28",
+      "value": 24,
+      "avg_cvss": 7.8,
+      "cvss_count": 24
+    },
+    {
+      "date": "2007-03-29",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-03-30",
+      "value": 32,
+      "avg_cvss": 7.3,
+      "cvss_count": 32
+    },
+    {
+      "date": "2007-03-31",
+      "value": 8,
+      "avg_cvss": 7.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2007-04-02",
+      "value": 35,
+      "avg_cvss": 7.8,
+      "cvss_count": 35
+    },
+    {
+      "date": "2007-04-03",
+      "value": 35,
+      "avg_cvss": 6.1,
+      "cvss_count": 35
+    },
+    {
+      "date": "2007-04-04",
+      "value": 8,
+      "avg_cvss": 8.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2007-04-06",
+      "value": 26,
+      "avg_cvss": 7.7,
+      "cvss_count": 26
+    },
+    {
+      "date": "2007-04-09",
+      "value": 5,
+      "avg_cvss": 5.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2007-04-10",
+      "value": 48,
+      "avg_cvss": 6.8,
+      "cvss_count": 48
+    },
+    {
+      "date": "2007-04-11",
+      "value": 39,
+      "avg_cvss": 7.1,
+      "cvss_count": 39
+    },
+    {
+      "date": "2007-04-12",
+      "value": 48,
+      "avg_cvss": 6.9,
+      "cvss_count": 48
+    },
+    {
+      "date": "2007-04-13",
+      "value": 14,
+      "avg_cvss": 5.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2007-04-16",
+      "value": 26,
+      "avg_cvss": 6.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2007-04-18",
+      "value": 85,
+      "avg_cvss": 7.6,
+      "cvss_count": 85
+    },
+    {
+      "date": "2007-04-19",
+      "value": 23,
+      "avg_cvss": 7.4,
+      "cvss_count": 23
+    },
+    {
+      "date": "2007-04-22",
+      "value": 15,
+      "avg_cvss": 6.5,
+      "cvss_count": 15
+    },
+    {
+      "date": "2007-04-24",
+      "value": 62,
+      "avg_cvss": 7.3,
+      "cvss_count": 62
+    },
+    {
+      "date": "2007-04-25",
+      "value": 44,
+      "avg_cvss": 6.9,
+      "cvss_count": 44
+    },
+    {
+      "date": "2007-04-26",
+      "value": 40,
+      "avg_cvss": 7.3,
+      "cvss_count": 40
+    },
+    {
+      "date": "2007-04-27",
+      "value": 28,
+      "avg_cvss": 7.7,
+      "cvss_count": 28
+    },
+    {
+      "date": "2007-04-30",
+      "value": 46,
+      "avg_cvss": 7.4,
+      "cvss_count": 46
+    },
+    {
+      "date": "2007-05-01",
+      "value": 5,
+      "avg_cvss": 7.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2007-05-02",
+      "value": 55,
+      "avg_cvss": 7.1,
+      "cvss_count": 55
+    },
+    {
+      "date": "2007-05-03",
+      "value": 13,
+      "avg_cvss": 7.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2007-05-04",
+      "value": 17,
+      "avg_cvss": 8.3,
+      "cvss_count": 17
+    },
+    {
+      "date": "2007-05-07",
+      "value": 3,
+      "avg_cvss": 8.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2007-05-08",
+      "value": 25,
+      "avg_cvss": 8.3,
+      "cvss_count": 25
+    },
+    {
+      "date": "2007-05-09",
+      "value": 65,
+      "avg_cvss": 6.8,
+      "cvss_count": 65
+    },
+    {
+      "date": "2007-05-10",
+      "value": 12,
+      "avg_cvss": 6.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2007-05-11",
+      "value": 47,
+      "avg_cvss": 7.1,
+      "cvss_count": 47
+    },
+    {
+      "date": "2007-05-13",
+      "value": 16,
+      "avg_cvss": 8.0,
+      "cvss_count": 16
+    },
+    {
+      "date": "2007-05-14",
+      "value": 41,
+      "avg_cvss": 6.9,
+      "cvss_count": 41
+    },
+    {
+      "date": "2007-05-15",
+      "value": 5,
+      "avg_cvss": 5.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2007-05-16",
+      "value": 55,
+      "avg_cvss": 6.6,
+      "cvss_count": 55
+    },
+    {
+      "date": "2007-05-17",
+      "value": 22,
+      "avg_cvss": 6.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2007-05-18",
+      "value": 12,
+      "avg_cvss": 7.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2007-05-21",
+      "value": 24,
+      "avg_cvss": 7.4,
+      "cvss_count": 24
+    },
+    {
+      "date": "2007-05-22",
+      "value": 37,
+      "avg_cvss": 6.6,
+      "cvss_count": 37
+    },
+    {
+      "date": "2007-05-23",
+      "value": 1,
+      "avg_cvss": 5.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-05-24",
+      "value": 34,
+      "avg_cvss": 8.1,
+      "cvss_count": 34
+    },
+    {
+      "date": "2007-05-25",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2007-05-29",
+      "value": 9,
+      "avg_cvss": 6.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2007-05-30",
+      "value": 39,
+      "avg_cvss": 5.6,
+      "cvss_count": 39
+    },
+    {
+      "date": "2007-05-31",
+      "value": 25,
+      "avg_cvss": 7.0,
+      "cvss_count": 25
+    },
+    {
+      "date": "2007-06-01",
+      "value": 31,
+      "avg_cvss": 7.2,
+      "cvss_count": 31
+    },
+    {
+      "date": "2007-06-04",
+      "value": 24,
+      "avg_cvss": 5.8,
+      "cvss_count": 24
+    },
+    {
+      "date": "2007-06-05",
+      "value": 10,
+      "avg_cvss": 6.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2007-06-06",
+      "value": 57,
+      "avg_cvss": 7.0,
+      "cvss_count": 57
+    },
+    {
+      "date": "2007-06-07",
+      "value": 21,
+      "avg_cvss": 6.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2007-06-08",
+      "value": 13,
+      "avg_cvss": 6.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2007-06-11",
+      "value": 45,
+      "avg_cvss": 6.1,
+      "cvss_count": 45
+    },
+    {
+      "date": "2007-06-12",
+      "value": 37,
+      "avg_cvss": 7.8,
+      "cvss_count": 37
+    },
+    {
+      "date": "2007-06-13",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-06-14",
+      "value": 32,
+      "avg_cvss": 6.1,
+      "cvss_count": 32
+    },
+    {
+      "date": "2007-06-15",
+      "value": 15,
+      "avg_cvss": 6.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2007-06-18",
+      "value": 10,
+      "avg_cvss": 7.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2007-06-19",
+      "value": 29,
+      "avg_cvss": 7.0,
+      "cvss_count": 29
+    },
+    {
+      "date": "2007-06-20",
+      "value": 17,
+      "avg_cvss": 6.8,
+      "cvss_count": 17
+    },
+    {
+      "date": "2007-06-21",
+      "value": 36,
+      "avg_cvss": 6.7,
+      "cvss_count": 36
+    },
+    {
+      "date": "2007-06-22",
+      "value": 35,
+      "avg_cvss": 7.1,
+      "cvss_count": 35
+    },
+    {
+      "date": "2007-06-25",
+      "value": 8,
+      "avg_cvss": 6.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2007-06-26",
+      "value": 46,
+      "avg_cvss": 6.4,
+      "cvss_count": 46
+    },
+    {
+      "date": "2007-06-27",
+      "value": 53,
+      "avg_cvss": 6.2,
+      "cvss_count": 53
+    },
+    {
+      "date": "2007-06-28",
+      "value": 19,
+      "avg_cvss": 5.5,
+      "cvss_count": 19
+    },
+    {
+      "date": "2007-06-29",
+      "value": 19,
+      "avg_cvss": 6.7,
+      "cvss_count": 19
+    },
+    {
+      "date": "2007-06-30",
+      "value": 5,
+      "avg_cvss": 5.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2007-07-02",
+      "value": 4,
+      "avg_cvss": 7.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2007-07-03",
+      "value": 46,
+      "avg_cvss": 6.5,
+      "cvss_count": 46
+    },
+    {
+      "date": "2007-07-04",
+      "value": 11,
+      "avg_cvss": 6.2,
+      "cvss_count": 11
+    },
+    {
+      "date": "2007-07-05",
+      "value": 29,
+      "avg_cvss": 6.0,
+      "cvss_count": 29
+    },
+    {
+      "date": "2007-07-06",
+      "value": 28,
+      "avg_cvss": 5.8,
+      "cvss_count": 28
+    },
+    {
+      "date": "2007-07-09",
+      "value": 11,
+      "avg_cvss": 6.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2007-07-10",
+      "value": 48,
+      "avg_cvss": 6.7,
+      "cvss_count": 48
+    },
+    {
+      "date": "2007-07-11",
+      "value": 39,
+      "avg_cvss": 6.5,
+      "cvss_count": 39
+    },
+    {
+      "date": "2007-07-12",
+      "value": 19,
+      "avg_cvss": 5.0,
+      "cvss_count": 19
+    },
+    {
+      "date": "2007-07-14",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2007-07-15",
+      "value": 43,
+      "avg_cvss": 6.9,
+      "cvss_count": 43
+    },
+    {
+      "date": "2007-07-16",
+      "value": 6,
+      "avg_cvss": 6.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2007-07-17",
+      "value": 39,
+      "avg_cvss": 6.2,
+      "cvss_count": 39
+    },
+    {
+      "date": "2007-07-18",
+      "value": 40,
+      "avg_cvss": 6.9,
+      "cvss_count": 40
+    },
+    {
+      "date": "2007-07-19",
+      "value": 6,
+      "avg_cvss": 6.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2007-07-20",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-07-21",
+      "value": 22,
+      "avg_cvss": 7.1,
+      "cvss_count": 22
+    },
+    {
+      "date": "2007-07-23",
+      "value": 3,
+      "avg_cvss": 7.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2007-07-24",
+      "value": 17,
+      "avg_cvss": 6.1,
+      "cvss_count": 17
+    },
+    {
+      "date": "2007-07-25",
+      "value": 38,
+      "avg_cvss": 6.4,
+      "cvss_count": 38
+    },
+    {
+      "date": "2007-07-26",
+      "value": 31,
+      "avg_cvss": 6.6,
+      "cvss_count": 31
+    },
+    {
+      "date": "2007-07-27",
+      "value": 20,
+      "avg_cvss": 6.7,
+      "cvss_count": 20
+    },
+    {
+      "date": "2007-07-30",
+      "value": 50,
+      "avg_cvss": 6.1,
+      "cvss_count": 50
+    },
+    {
+      "date": "2007-07-31",
+      "value": 18,
+      "avg_cvss": 6.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2007-08-01",
+      "value": 12,
+      "avg_cvss": 6.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2007-08-03",
+      "value": 41,
+      "avg_cvss": 6.0,
+      "cvss_count": 41
+    },
+    {
+      "date": "2007-08-07",
+      "value": 11,
+      "avg_cvss": 6.2,
+      "cvss_count": 11
+    },
+    {
+      "date": "2007-08-08",
+      "value": 83,
+      "avg_cvss": 5.8,
+      "cvss_count": 83
+    },
+    {
+      "date": "2007-08-09",
+      "value": 22,
+      "avg_cvss": 6.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2007-08-10",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2007-08-13",
+      "value": 21,
+      "avg_cvss": 5.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2007-08-14",
+      "value": 42,
+      "avg_cvss": 6.6,
+      "cvss_count": 42
+    },
+    {
+      "date": "2007-08-15",
+      "value": 24,
+      "avg_cvss": 6.6,
+      "cvss_count": 24
+    },
+    {
+      "date": "2007-08-16",
+      "value": 10,
+      "avg_cvss": 6.5,
+      "cvss_count": 10
+    },
+    {
+      "date": "2007-08-17",
+      "value": 15,
+      "avg_cvss": 6.5,
+      "cvss_count": 15
+    },
+    {
+      "date": "2007-08-18",
+      "value": 35,
+      "avg_cvss": 6.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2007-08-20",
+      "value": 15,
+      "avg_cvss": 5.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2007-08-21",
+      "value": 28,
+      "avg_cvss": 6.1,
+      "cvss_count": 28
+    },
+    {
+      "date": "2007-08-22",
+      "value": 18,
+      "avg_cvss": 6.1,
+      "cvss_count": 18
+    },
+    {
+      "date": "2007-08-23",
+      "value": 20,
+      "avg_cvss": 6.6,
+      "cvss_count": 20
+    },
+    {
+      "date": "2007-08-25",
+      "value": 16,
+      "avg_cvss": 5.9,
+      "cvss_count": 16
+    },
+    {
+      "date": "2007-08-27",
+      "value": 15,
+      "avg_cvss": 5.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2007-08-28",
+      "value": 23,
+      "avg_cvss": 6.4,
+      "cvss_count": 23
+    },
+    {
+      "date": "2007-08-29",
+      "value": 16,
+      "avg_cvss": 6.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2007-08-30",
+      "value": 6,
+      "avg_cvss": 6.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2007-08-31",
+      "value": 47,
+      "avg_cvss": 6.9,
+      "cvss_count": 47
+    },
+    {
+      "date": "2007-09-04",
+      "value": 22,
+      "avg_cvss": 6.1,
+      "cvss_count": 22
+    },
+    {
+      "date": "2007-09-05",
+      "value": 23,
+      "avg_cvss": 6.5,
+      "cvss_count": 23
+    },
+    {
+      "date": "2007-09-06",
+      "value": 20,
+      "avg_cvss": 7.3,
+      "cvss_count": 20
+    },
+    {
+      "date": "2007-09-08",
+      "value": 12,
+      "avg_cvss": 6.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2007-09-10",
+      "value": 27,
+      "avg_cvss": 6.7,
+      "cvss_count": 27
+    },
+    {
+      "date": "2007-09-11",
+      "value": 24,
+      "avg_cvss": 6.7,
+      "cvss_count": 24
+    },
+    {
+      "date": "2007-09-12",
+      "value": 31,
+      "avg_cvss": 6.2,
+      "cvss_count": 31
+    },
+    {
+      "date": "2007-09-13",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-09-14",
+      "value": 28,
+      "avg_cvss": 5.5,
+      "cvss_count": 28
+    },
+    {
+      "date": "2007-09-17",
+      "value": 25,
+      "avg_cvss": 6.7,
+      "cvss_count": 25
+    },
+    {
+      "date": "2007-09-18",
+      "value": 51,
+      "avg_cvss": 6.5,
+      "cvss_count": 51
+    },
+    {
+      "date": "2007-09-19",
+      "value": 19,
+      "avg_cvss": 5.8,
+      "cvss_count": 19
+    },
+    {
+      "date": "2007-09-20",
+      "value": 12,
+      "avg_cvss": 6.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2007-09-21",
+      "value": 23,
+      "avg_cvss": 6.1,
+      "cvss_count": 23
+    },
+    {
+      "date": "2007-09-24",
+      "value": 43,
+      "avg_cvss": 6.4,
+      "cvss_count": 43
+    },
+    {
+      "date": "2007-09-25",
+      "value": 1,
+      "avg_cvss": 6.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-09-26",
+      "value": 33,
+      "avg_cvss": 6.1,
+      "cvss_count": 33
+    },
+    {
+      "date": "2007-09-27",
+      "value": 31,
+      "avg_cvss": 5.7,
+      "cvss_count": 31
+    },
+    {
+      "date": "2007-09-28",
+      "value": 8,
+      "avg_cvss": 6.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2007-10-01",
+      "value": 37,
+      "avg_cvss": 6.7,
+      "cvss_count": 37
+    },
+    {
+      "date": "2007-10-03",
+      "value": 17,
+      "avg_cvss": 6.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "2007-10-04",
+      "value": 16,
+      "avg_cvss": 6.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2007-10-05",
+      "value": 24,
+      "avg_cvss": 6.2,
+      "cvss_count": 24
+    },
+    {
+      "date": "2007-10-06",
+      "value": 27,
+      "avg_cvss": 6.5,
+      "cvss_count": 27
+    },
+    {
+      "date": "2007-10-08",
+      "value": 18,
+      "avg_cvss": 5.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2007-10-09",
+      "value": 44,
+      "avg_cvss": 5.9,
+      "cvss_count": 44
+    },
+    {
+      "date": "2007-10-11",
+      "value": 19,
+      "avg_cvss": 6.8,
+      "cvss_count": 19
+    },
+    {
+      "date": "2007-10-12",
+      "value": 42,
+      "avg_cvss": 6.4,
+      "cvss_count": 42
+    },
+    {
+      "date": "2007-10-13",
+      "value": 15,
+      "avg_cvss": 8.1,
+      "cvss_count": 15
+    },
+    {
+      "date": "2007-10-14",
+      "value": 23,
+      "avg_cvss": 6.3,
+      "cvss_count": 23
+    },
+    {
+      "date": "2007-10-15",
+      "value": 8,
+      "avg_cvss": 6.9,
+      "cvss_count": 8
+    },
+    {
+      "date": "2007-10-16",
+      "value": 16,
+      "avg_cvss": 5.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2007-10-17",
+      "value": 36,
+      "avg_cvss": 7.5,
+      "cvss_count": 36
+    },
+    {
+      "date": "2007-10-18",
+      "value": 46,
+      "avg_cvss": 7.0,
+      "cvss_count": 46
+    },
+    {
+      "date": "2007-10-19",
+      "value": 17,
+      "avg_cvss": 5.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2007-10-20",
+      "value": 1,
+      "avg_cvss": 9.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2007-10-21",
+      "value": 8,
+      "avg_cvss": 6.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2007-10-22",
+      "value": 4,
+      "avg_cvss": 4.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2007-10-23",
+      "value": 33,
+      "avg_cvss": 6.1,
+      "cvss_count": 33
+    },
+    {
+      "date": "2007-10-24",
+      "value": 7,
+      "avg_cvss": 5.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2007-10-25",
+      "value": 2,
+      "avg_cvss": 8.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "2007-10-26",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2007-10-28",
+      "value": 4,
+      "avg_cvss": 6.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2007-10-29",
+      "value": 26,
+      "avg_cvss": 6.3,
+      "cvss_count": 26
+    },
+    {
+      "date": "2007-10-30",
+      "value": 39,
+      "avg_cvss": 6.0,
+      "cvss_count": 39
+    },
+    {
+      "date": "2007-10-31",
+      "value": 14,
+      "avg_cvss": 7.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2007-11-01",
+      "value": 23,
+      "avg_cvss": 6.6,
+      "cvss_count": 23
+    },
+    {
+      "date": "2007-11-02",
+      "value": 5,
+      "avg_cvss": 8.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2007-11-03",
+      "value": 7,
+      "avg_cvss": 6.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2007-11-05",
+      "value": 41,
+      "avg_cvss": 6.4,
+      "cvss_count": 41
+    },
+    {
+      "date": "2007-11-06",
+      "value": 12,
+      "avg_cvss": 7.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2007-11-07",
+      "value": 18,
+      "avg_cvss": 7.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2007-11-08",
+      "value": 17,
+      "avg_cvss": 7.4,
+      "cvss_count": 17
+    },
+    {
+      "date": "2007-11-09",
+      "value": 3,
+      "avg_cvss": 5.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2007-11-10",
+      "value": 26,
+      "avg_cvss": 6.3,
+      "cvss_count": 26
+    },
+    {
+      "date": "2007-11-13",
+      "value": 7,
+      "avg_cvss": 5.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2007-11-14",
+      "value": 27,
+      "avg_cvss": 5.8,
+      "cvss_count": 27
+    },
+    {
+      "date": "2007-11-15",
+      "value": 73,
+      "avg_cvss": 6.6,
+      "cvss_count": 73
+    },
+    {
+      "date": "2007-11-16",
+      "value": 4,
+      "avg_cvss": 9.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2007-11-19",
+      "value": 2,
+      "avg_cvss": 8.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "2007-11-20",
+      "value": 41,
+      "avg_cvss": 7.1,
+      "cvss_count": 41
+    },
+    {
+      "date": "2007-11-21",
+      "value": 7,
+      "avg_cvss": 7.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2007-11-22",
+      "value": 18,
+      "avg_cvss": 7.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2007-11-23",
+      "value": 19,
+      "avg_cvss": 6.1,
+      "cvss_count": 19
+    },
+    {
+      "date": "2007-11-26",
+      "value": 12,
+      "avg_cvss": 6.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2007-11-27",
+      "value": 16,
+      "avg_cvss": 6.1,
+      "cvss_count": 16
+    },
+    {
+      "date": "2007-11-29",
+      "value": 16,
+      "avg_cvss": 6.6,
+      "cvss_count": 16
+    },
+    {
+      "date": "2007-11-30",
+      "value": 27,
+      "avg_cvss": 6.9,
+      "cvss_count": 27
+    },
+    {
+      "date": "2007-12-01",
+      "value": 9,
+      "avg_cvss": 7.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2007-12-03",
+      "value": 3,
+      "avg_cvss": 4.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2007-12-04",
+      "value": 34,
+      "avg_cvss": 5.8,
+      "cvss_count": 34
+    },
+    {
+      "date": "2007-12-05",
+      "value": 7,
+      "avg_cvss": 6.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2007-12-06",
+      "value": 14,
+      "avg_cvss": 8.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2007-12-07",
+      "value": 17,
+      "avg_cvss": 7.0,
+      "cvss_count": 17
+    },
+    {
+      "date": "2007-12-10",
+      "value": 21,
+      "avg_cvss": 5.8,
+      "cvss_count": 21
+    },
+    {
+      "date": "2007-12-11",
+      "value": 8,
+      "avg_cvss": 4.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2007-12-12",
+      "value": 18,
+      "avg_cvss": 6.9,
+      "cvss_count": 18
+    },
+    {
+      "date": "2007-12-13",
+      "value": 23,
+      "avg_cvss": 6.9,
+      "cvss_count": 23
+    },
+    {
+      "date": "2007-12-14",
+      "value": 2,
+      "avg_cvss": 7.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2007-12-15",
+      "value": 38,
+      "avg_cvss": 6.3,
+      "cvss_count": 38
+    },
+    {
+      "date": "2007-12-17",
+      "value": 28,
+      "avg_cvss": 6.1,
+      "cvss_count": 28
+    },
+    {
+      "date": "2007-12-18",
+      "value": 13,
+      "avg_cvss": 6.8,
+      "cvss_count": 13
+    },
+    {
+      "date": "2007-12-19",
+      "value": 26,
+      "avg_cvss": 6.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2007-12-20",
+      "value": 74,
+      "avg_cvss": 6.6,
+      "cvss_count": 74
+    },
+    {
+      "date": "2007-12-21",
+      "value": 10,
+      "avg_cvss": 6.3,
+      "cvss_count": 10
+    },
+    {
+      "date": "2007-12-24",
+      "value": 9,
+      "avg_cvss": 6.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2007-12-27",
+      "value": 18,
+      "avg_cvss": 7.1,
+      "cvss_count": 18
+    },
+    {
+      "date": "2007-12-28",
+      "value": 51,
+      "avg_cvss": 6.5,
+      "cvss_count": 51
+    },
+    {
+      "date": "2007-12-31",
+      "value": 12,
+      "avg_cvss": 5.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2008-01-03",
+      "value": 11,
+      "avg_cvss": 5.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-01-04",
+      "value": 54,
+      "avg_cvss": 6.4,
+      "cvss_count": 54
+    },
+    {
+      "date": "2008-01-08",
+      "value": 45,
+      "avg_cvss": 6.3,
+      "cvss_count": 45
+    },
+    {
+      "date": "2008-01-09",
+      "value": 34,
+      "avg_cvss": 6.5,
+      "cvss_count": 34
+    },
+    {
+      "date": "2008-01-10",
+      "value": 37,
+      "avg_cvss": 5.9,
+      "cvss_count": 37
+    },
+    {
+      "date": "2008-01-11",
+      "value": 13,
+      "avg_cvss": 6.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2008-01-12",
+      "value": 16,
+      "avg_cvss": 7.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2008-01-15",
+      "value": 34,
+      "avg_cvss": 5.7,
+      "cvss_count": 34
+    },
+    {
+      "date": "2008-01-16",
+      "value": 29,
+      "avg_cvss": 7.1,
+      "cvss_count": 29
+    },
+    {
+      "date": "2008-01-17",
+      "value": 43,
+      "avg_cvss": 7.7,
+      "cvss_count": 43
+    },
+    {
+      "date": "2008-01-18",
+      "value": 23,
+      "avg_cvss": 6.7,
+      "cvss_count": 23
+    },
+    {
+      "date": "2008-01-19",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2008-01-22",
+      "value": 16,
+      "avg_cvss": 7.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2008-01-23",
+      "value": 41,
+      "avg_cvss": 6.7,
+      "cvss_count": 41
+    },
+    {
+      "date": "2008-01-25",
+      "value": 27,
+      "avg_cvss": 6.1,
+      "cvss_count": 27
+    },
+    {
+      "date": "2008-01-29",
+      "value": 30,
+      "avg_cvss": 6.8,
+      "cvss_count": 30
+    },
+    {
+      "date": "2008-01-30",
+      "value": 15,
+      "avg_cvss": 6.8,
+      "cvss_count": 15
+    },
+    {
+      "date": "2008-01-31",
+      "value": 26,
+      "avg_cvss": 6.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2008-02-01",
+      "value": 19,
+      "avg_cvss": 5.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2008-02-04",
+      "value": 8,
+      "avg_cvss": 6.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2008-02-05",
+      "value": 39,
+      "avg_cvss": 5.8,
+      "cvss_count": 39
+    },
+    {
+      "date": "2008-02-06",
+      "value": 34,
+      "avg_cvss": 6.5,
+      "cvss_count": 34
+    },
+    {
+      "date": "2008-02-07",
+      "value": 17,
+      "avg_cvss": 8.1,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-02-08",
+      "value": 18,
+      "avg_cvss": 7.1,
+      "cvss_count": 18
+    },
+    {
+      "date": "2008-02-09",
+      "value": 4,
+      "avg_cvss": 4.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2008-02-11",
+      "value": 4,
+      "avg_cvss": 5.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2008-02-12",
+      "value": 88,
+      "avg_cvss": 6.9,
+      "cvss_count": 88
+    },
+    {
+      "date": "2008-02-13",
+      "value": 45,
+      "avg_cvss": 7.5,
+      "cvss_count": 45
+    },
+    {
+      "date": "2008-02-14",
+      "value": 18,
+      "avg_cvss": 5.9,
+      "cvss_count": 18
+    },
+    {
+      "date": "2008-02-15",
+      "value": 25,
+      "avg_cvss": 7.0,
+      "cvss_count": 25
+    },
+    {
+      "date": "2008-02-18",
+      "value": 2,
+      "avg_cvss": 7.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2008-02-19",
+      "value": 30,
+      "avg_cvss": 6.6,
+      "cvss_count": 30
+    },
+    {
+      "date": "2008-02-20",
+      "value": 16,
+      "avg_cvss": 6.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2008-02-21",
+      "value": 40,
+      "avg_cvss": 6.3,
+      "cvss_count": 40
+    },
+    {
+      "date": "2008-02-22",
+      "value": 29,
+      "avg_cvss": 6.3,
+      "cvss_count": 29
+    },
+    {
+      "date": "2008-02-25",
+      "value": 25,
+      "avg_cvss": 5.9,
+      "cvss_count": 25
+    },
+    {
+      "date": "2008-02-26",
+      "value": 5,
+      "avg_cvss": 6.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2008-02-27",
+      "value": 19,
+      "avg_cvss": 6.7,
+      "cvss_count": 19
+    },
+    {
+      "date": "2008-02-28",
+      "value": 22,
+      "avg_cvss": 6.2,
+      "cvss_count": 22
+    },
+    {
+      "date": "2008-02-29",
+      "value": 17,
+      "avg_cvss": 6.3,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-03-03",
+      "value": 16,
+      "avg_cvss": 6.6,
+      "cvss_count": 16
+    },
+    {
+      "date": "2008-03-04",
+      "value": 24,
+      "avg_cvss": 6.1,
+      "cvss_count": 24
+    },
+    {
+      "date": "2008-03-05",
+      "value": 15,
+      "avg_cvss": 6.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2008-03-06",
+      "value": 32,
+      "avg_cvss": 6.2,
+      "cvss_count": 32
+    },
+    {
+      "date": "2008-03-08",
+      "value": 11,
+      "avg_cvss": 5.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-03-09",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2008-03-10",
+      "value": 55,
+      "avg_cvss": 7.0,
+      "cvss_count": 55
+    },
+    {
+      "date": "2008-03-11",
+      "value": 20,
+      "avg_cvss": 7.8,
+      "cvss_count": 20
+    },
+    {
+      "date": "2008-03-12",
+      "value": 26,
+      "avg_cvss": 6.3,
+      "cvss_count": 26
+    },
+    {
+      "date": "2008-03-13",
+      "value": 19,
+      "avg_cvss": 6.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2008-03-14",
+      "value": 7,
+      "avg_cvss": 7.8,
+      "cvss_count": 7
+    },
+    {
+      "date": "2008-03-17",
+      "value": 24,
+      "avg_cvss": 6.0,
+      "cvss_count": 24
+    },
+    {
+      "date": "2008-03-18",
+      "value": 39,
+      "avg_cvss": 5.9,
+      "cvss_count": 39
+    },
+    {
+      "date": "2008-03-19",
+      "value": 15,
+      "avg_cvss": 5.6,
+      "cvss_count": 15
+    },
+    {
+      "date": "2008-03-20",
+      "value": 47,
+      "avg_cvss": 6.3,
+      "cvss_count": 47
+    },
+    {
+      "date": "2008-03-24",
+      "value": 41,
+      "avg_cvss": 6.1,
+      "cvss_count": 41
+    },
+    {
+      "date": "2008-03-25",
+      "value": 27,
+      "avg_cvss": 7.0,
+      "cvss_count": 27
+    },
+    {
+      "date": "2008-03-26",
+      "value": 10,
+      "avg_cvss": 6.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2008-03-27",
+      "value": 17,
+      "avg_cvss": 6.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-03-28",
+      "value": 19,
+      "avg_cvss": 6.6,
+      "cvss_count": 19
+    },
+    {
+      "date": "2008-03-31",
+      "value": 37,
+      "avg_cvss": 5.9,
+      "cvss_count": 37
+    },
+    {
+      "date": "2008-04-01",
+      "value": 11,
+      "avg_cvss": 6.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-04-02",
+      "value": 40,
+      "avg_cvss": 6.4,
+      "cvss_count": 40
+    },
+    {
+      "date": "2008-04-04",
+      "value": 20,
+      "avg_cvss": 7.0,
+      "cvss_count": 20
+    },
+    {
+      "date": "2008-04-06",
+      "value": 6,
+      "avg_cvss": 6.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2008-04-07",
+      "value": 11,
+      "avg_cvss": 6.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-04-08",
+      "value": 22,
+      "avg_cvss": 7.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2008-04-09",
+      "value": 19,
+      "avg_cvss": 6.4,
+      "cvss_count": 19
+    },
+    {
+      "date": "2008-04-10",
+      "value": 11,
+      "avg_cvss": 8.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-04-11",
+      "value": 20,
+      "avg_cvss": 6.6,
+      "cvss_count": 20
+    },
+    {
+      "date": "2008-04-12",
+      "value": 10,
+      "avg_cvss": 7.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2008-04-14",
+      "value": 15,
+      "avg_cvss": 6.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2008-04-15",
+      "value": 18,
+      "avg_cvss": 5.7,
+      "cvss_count": 18
+    },
+    {
+      "date": "2008-04-16",
+      "value": 60,
+      "avg_cvss": 7.1,
+      "cvss_count": 60
+    },
+    {
+      "date": "2008-04-17",
+      "value": 30,
+      "avg_cvss": 6.7,
+      "cvss_count": 30
+    },
+    {
+      "date": "2008-04-18",
+      "value": 16,
+      "avg_cvss": 6.1,
+      "cvss_count": 16
+    },
+    {
+      "date": "2008-04-21",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2008-04-22",
+      "value": 19,
+      "avg_cvss": 7.1,
+      "cvss_count": 19
+    },
+    {
+      "date": "2008-04-23",
+      "value": 14,
+      "avg_cvss": 6.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2008-04-24",
+      "value": 4,
+      "avg_cvss": 5.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "2008-04-25",
+      "value": 28,
+      "avg_cvss": 6.5,
+      "cvss_count": 28
+    },
+    {
+      "date": "2008-04-27",
+      "value": 29,
+      "avg_cvss": 5.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2008-04-28",
+      "value": 13,
+      "avg_cvss": 6.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2008-04-29",
+      "value": 2,
+      "avg_cvss": 7.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2008-04-30",
+      "value": 33,
+      "avg_cvss": 6.2,
+      "cvss_count": 33
+    },
+    {
+      "date": "2008-05-01",
+      "value": 9,
+      "avg_cvss": 5.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2008-05-02",
+      "value": 11,
+      "avg_cvss": 6.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-05-05",
+      "value": 15,
+      "avg_cvss": 7.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2008-05-06",
+      "value": 11,
+      "avg_cvss": 7.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-05-07",
+      "value": 10,
+      "avg_cvss": 6.5,
+      "cvss_count": 10
+    },
+    {
+      "date": "2008-05-08",
+      "value": 14,
+      "avg_cvss": 6.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2008-05-09",
+      "value": 16,
+      "avg_cvss": 6.3,
+      "cvss_count": 16
+    },
+    {
+      "date": "2008-05-12",
+      "value": 24,
+      "avg_cvss": 6.3,
+      "cvss_count": 24
+    },
+    {
+      "date": "2008-05-13",
+      "value": 34,
+      "avg_cvss": 6.2,
+      "cvss_count": 34
+    },
+    {
+      "date": "2008-05-14",
+      "value": 43,
+      "avg_cvss": 6.3,
+      "cvss_count": 43
+    },
+    {
+      "date": "2008-05-16",
+      "value": 34,
+      "avg_cvss": 6.7,
+      "cvss_count": 34
+    },
+    {
+      "date": "2008-05-18",
+      "value": 22,
+      "avg_cvss": 6.9,
+      "cvss_count": 22
+    },
+    {
+      "date": "2008-05-19",
+      "value": 12,
+      "avg_cvss": 7.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2008-05-20",
+      "value": 12,
+      "avg_cvss": 6.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2008-05-21",
+      "value": 17,
+      "avg_cvss": 7.4,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-05-22",
+      "value": 19,
+      "avg_cvss": 7.0,
+      "cvss_count": 19
+    },
+    {
+      "date": "2008-05-23",
+      "value": 17,
+      "avg_cvss": 6.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-05-27",
+      "value": 19,
+      "avg_cvss": 6.6,
+      "cvss_count": 19
+    },
+    {
+      "date": "2008-05-28",
+      "value": 22,
+      "avg_cvss": 6.9,
+      "cvss_count": 22
+    },
+    {
+      "date": "2008-05-29",
+      "value": 22,
+      "avg_cvss": 7.0,
+      "cvss_count": 22
+    },
+    {
+      "date": "2008-06-02",
+      "value": 28,
+      "avg_cvss": 6.8,
+      "cvss_count": 28
+    },
+    {
+      "date": "2008-06-03",
+      "value": 27,
+      "avg_cvss": 6.3,
+      "cvss_count": 27
+    },
+    {
+      "date": "2008-06-04",
+      "value": 31,
+      "avg_cvss": 8.0,
+      "cvss_count": 31
+    },
+    {
+      "date": "2008-06-05",
+      "value": 16,
+      "avg_cvss": 6.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2008-06-06",
+      "value": 20,
+      "avg_cvss": 6.9,
+      "cvss_count": 20
+    },
+    {
+      "date": "2008-06-09",
+      "value": 1,
+      "avg_cvss": 7.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2008-06-10",
+      "value": 33,
+      "avg_cvss": 7.3,
+      "cvss_count": 33
+    },
+    {
+      "date": "2008-06-11",
+      "value": 1,
+      "avg_cvss": 4.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2008-06-12",
+      "value": 27,
+      "avg_cvss": 7.2,
+      "cvss_count": 27
+    },
+    {
+      "date": "2008-06-13",
+      "value": 21,
+      "avg_cvss": 7.4,
+      "cvss_count": 21
+    },
+    {
+      "date": "2008-06-16",
+      "value": 31,
+      "avg_cvss": 6.4,
+      "cvss_count": 31
+    },
+    {
+      "date": "2008-06-17",
+      "value": 5,
+      "avg_cvss": 6.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2008-06-18",
+      "value": 31,
+      "avg_cvss": 5.7,
+      "cvss_count": 31
+    },
+    {
+      "date": "2008-06-19",
+      "value": 13,
+      "avg_cvss": 7.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2008-06-20",
+      "value": 13,
+      "avg_cvss": 6.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2008-06-23",
+      "value": 20,
+      "avg_cvss": 7.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2008-06-24",
+      "value": 16,
+      "avg_cvss": 7.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2008-06-25",
+      "value": 27,
+      "avg_cvss": 6.5,
+      "cvss_count": 27
+    },
+    {
+      "date": "2008-06-26",
+      "value": 20,
+      "avg_cvss": 6.8,
+      "cvss_count": 20
+    },
+    {
+      "date": "2008-06-27",
+      "value": 17,
+      "avg_cvss": 8.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-06-30",
+      "value": 37,
+      "avg_cvss": 6.7,
+      "cvss_count": 37
+    },
+    {
+      "date": "2008-07-01",
+      "value": 13,
+      "avg_cvss": 5.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2008-07-02",
+      "value": 34,
+      "avg_cvss": 6.1,
+      "cvss_count": 34
+    },
+    {
+      "date": "2008-07-03",
+      "value": 9,
+      "avg_cvss": 6.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2008-07-07",
+      "value": 57,
+      "avg_cvss": 7.0,
+      "cvss_count": 57
+    },
+    {
+      "date": "2008-07-08",
+      "value": 15,
+      "avg_cvss": 7.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2008-07-09",
+      "value": 43,
+      "avg_cvss": 6.7,
+      "cvss_count": 43
+    },
+    {
+      "date": "2008-07-10",
+      "value": 26,
+      "avg_cvss": 6.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2008-07-11",
+      "value": 12,
+      "avg_cvss": 7.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2008-07-14",
+      "value": 23,
+      "avg_cvss": 7.4,
+      "cvss_count": 23
+    },
+    {
+      "date": "2008-07-15",
+      "value": 54,
+      "avg_cvss": 5.6,
+      "cvss_count": 54
+    },
+    {
+      "date": "2008-07-16",
+      "value": 9,
+      "avg_cvss": 6.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2008-07-17",
+      "value": 12,
+      "avg_cvss": 6.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2008-07-18",
+      "value": 30,
+      "avg_cvss": 6.5,
+      "cvss_count": 30
+    },
+    {
+      "date": "2008-07-21",
+      "value": 17,
+      "avg_cvss": 7.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-07-22",
+      "value": 12,
+      "avg_cvss": 5.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2008-07-24",
+      "value": 17,
+      "avg_cvss": 6.4,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-07-25",
+      "value": 31,
+      "avg_cvss": 6.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2008-07-27",
+      "value": 10,
+      "avg_cvss": 6.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2008-07-28",
+      "value": 22,
+      "avg_cvss": 6.9,
+      "cvss_count": 22
+    },
+    {
+      "date": "2008-07-29",
+      "value": 5,
+      "avg_cvss": 7.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2008-07-30",
+      "value": 27,
+      "avg_cvss": 7.1,
+      "cvss_count": 27
+    },
+    {
+      "date": "2008-07-31",
+      "value": 39,
+      "avg_cvss": 6.4,
+      "cvss_count": 39
+    },
+    {
+      "date": "2008-08-01",
+      "value": 22,
+      "avg_cvss": 7.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2008-08-04",
+      "value": 25,
+      "avg_cvss": 6.6,
+      "cvss_count": 25
+    },
+    {
+      "date": "2008-08-05",
+      "value": 8,
+      "avg_cvss": 6.1,
+      "cvss_count": 8
+    },
+    {
+      "date": "2008-08-06",
+      "value": 23,
+      "avg_cvss": 6.6,
+      "cvss_count": 23
+    },
+    {
+      "date": "2008-08-07",
+      "value": 10,
+      "avg_cvss": 6.1,
+      "cvss_count": 10
+    },
+    {
+      "date": "2008-08-08",
+      "value": 21,
+      "avg_cvss": 6.8,
+      "cvss_count": 21
+    },
+    {
+      "date": "2008-08-10",
+      "value": 24,
+      "avg_cvss": 6.0,
+      "cvss_count": 24
+    },
+    {
+      "date": "2008-08-11",
+      "value": 10,
+      "avg_cvss": 7.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2008-08-12",
+      "value": 26,
+      "avg_cvss": 7.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2008-08-13",
+      "value": 39,
+      "avg_cvss": 7.6,
+      "cvss_count": 39
+    },
+    {
+      "date": "2008-08-14",
+      "value": 17,
+      "avg_cvss": 5.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-08-15",
+      "value": 6,
+      "avg_cvss": 6.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2008-08-18",
+      "value": 10,
+      "avg_cvss": 7.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2008-08-19",
+      "value": 13,
+      "avg_cvss": 5.5,
+      "cvss_count": 13
+    },
+    {
+      "date": "2008-08-20",
+      "value": 18,
+      "avg_cvss": 6.7,
+      "cvss_count": 18
+    },
+    {
+      "date": "2008-08-21",
+      "value": 18,
+      "avg_cvss": 7.0,
+      "cvss_count": 18
+    },
+    {
+      "date": "2008-08-22",
+      "value": 10,
+      "avg_cvss": 6.2,
+      "cvss_count": 10
+    },
+    {
+      "date": "2008-08-25",
+      "value": 3,
+      "avg_cvss": 4.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2008-08-26",
+      "value": 11,
+      "avg_cvss": 6.1,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-08-27",
+      "value": 35,
+      "avg_cvss": 6.0,
+      "cvss_count": 35
+    },
+    {
+      "date": "2008-08-28",
+      "value": 7,
+      "avg_cvss": 6.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2008-08-29",
+      "value": 11,
+      "avg_cvss": 6.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-09-02",
+      "value": 16,
+      "avg_cvss": 7.1,
+      "cvss_count": 16
+    },
+    {
+      "date": "2008-09-03",
+      "value": 28,
+      "avg_cvss": 5.8,
+      "cvss_count": 28
+    },
+    {
+      "date": "2008-09-04",
+      "value": 36,
+      "avg_cvss": 6.4,
+      "cvss_count": 36
+    },
+    {
+      "date": "2008-09-05",
+      "value": 22,
+      "avg_cvss": 6.7,
+      "cvss_count": 22
+    },
+    {
+      "date": "2008-09-11",
+      "value": 72,
+      "avg_cvss": 7.1,
+      "cvss_count": 72
+    },
+    {
+      "date": "2008-09-12",
+      "value": 6,
+      "avg_cvss": 5.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2008-09-15",
+      "value": 23,
+      "avg_cvss": 6.3,
+      "cvss_count": 23
+    },
+    {
+      "date": "2008-09-16",
+      "value": 25,
+      "avg_cvss": 6.8,
+      "cvss_count": 25
+    },
+    {
+      "date": "2008-09-18",
+      "value": 29,
+      "avg_cvss": 6.6,
+      "cvss_count": 29
+    },
+    {
+      "date": "2008-09-19",
+      "value": 8,
+      "avg_cvss": 7.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2008-09-22",
+      "value": 18,
+      "avg_cvss": 6.1,
+      "cvss_count": 18
+    },
+    {
+      "date": "2008-09-23",
+      "value": 17,
+      "avg_cvss": 6.0,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-09-24",
+      "value": 49,
+      "avg_cvss": 6.8,
+      "cvss_count": 49
+    },
+    {
+      "date": "2008-09-25",
+      "value": 7,
+      "avg_cvss": 6.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2008-09-26",
+      "value": 19,
+      "avg_cvss": 7.7,
+      "cvss_count": 19
+    },
+    {
+      "date": "2008-09-27",
+      "value": 16,
+      "avg_cvss": 6.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2008-09-29",
+      "value": 17,
+      "avg_cvss": 6.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-09-30",
+      "value": 41,
+      "avg_cvss": 6.9,
+      "cvss_count": 41
+    },
+    {
+      "date": "2008-10-01",
+      "value": 13,
+      "avg_cvss": 6.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2008-10-02",
+      "value": 8,
+      "avg_cvss": 7.1,
+      "cvss_count": 8
+    },
+    {
+      "date": "2008-10-03",
+      "value": 35,
+      "avg_cvss": 6.7,
+      "cvss_count": 35
+    },
+    {
+      "date": "2008-10-06",
+      "value": 15,
+      "avg_cvss": 6.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2008-10-07",
+      "value": 24,
+      "avg_cvss": 7.4,
+      "cvss_count": 24
+    },
+    {
+      "date": "2008-10-08",
+      "value": 22,
+      "avg_cvss": 6.2,
+      "cvss_count": 22
+    },
+    {
+      "date": "2008-10-09",
+      "value": 39,
+      "avg_cvss": 7.1,
+      "cvss_count": 39
+    },
+    {
+      "date": "2008-10-10",
+      "value": 17,
+      "avg_cvss": 7.1,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-10-13",
+      "value": 10,
+      "avg_cvss": 5.7,
+      "cvss_count": 10
+    },
+    {
+      "date": "2008-10-14",
+      "value": 56,
+      "avg_cvss": 5.8,
+      "cvss_count": 56
+    },
+    {
+      "date": "2008-10-15",
+      "value": 43,
+      "avg_cvss": 7.6,
+      "cvss_count": 43
+    },
+    {
+      "date": "2008-10-16",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2008-10-17",
+      "value": 9,
+      "avg_cvss": 7.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2008-10-18",
+      "value": 8,
+      "avg_cvss": 7.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2008-10-20",
+      "value": 11,
+      "avg_cvss": 6.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-10-21",
+      "value": 28,
+      "avg_cvss": 6.6,
+      "cvss_count": 28
+    },
+    {
+      "date": "2008-10-22",
+      "value": 55,
+      "avg_cvss": 6.8,
+      "cvss_count": 55
+    },
+    {
+      "date": "2008-10-23",
+      "value": 36,
+      "avg_cvss": 7.2,
+      "cvss_count": 36
+    },
+    {
+      "date": "2008-10-24",
+      "value": 14,
+      "avg_cvss": 7.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2008-10-27",
+      "value": 16,
+      "avg_cvss": 6.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2008-10-28",
+      "value": 21,
+      "avg_cvss": 6.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2008-10-29",
+      "value": 17,
+      "avg_cvss": 7.0,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-10-30",
+      "value": 9,
+      "avg_cvss": 8.3,
+      "cvss_count": 9
+    },
+    {
+      "date": "2008-10-31",
+      "value": 15,
+      "avg_cvss": 6.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2008-11-01",
+      "value": 16,
+      "avg_cvss": 7.1,
+      "cvss_count": 16
+    },
+    {
+      "date": "2008-11-03",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2008-11-04",
+      "value": 50,
+      "avg_cvss": 6.7,
+      "cvss_count": 50
+    },
+    {
+      "date": "2008-11-05",
+      "value": 37,
+      "avg_cvss": 6.9,
+      "cvss_count": 37
+    },
+    {
+      "date": "2008-11-06",
+      "value": 28,
+      "avg_cvss": 7.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2008-11-07",
+      "value": 9,
+      "avg_cvss": 6.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2008-11-10",
+      "value": 33,
+      "avg_cvss": 7.2,
+      "cvss_count": 33
+    },
+    {
+      "date": "2008-11-12",
+      "value": 11,
+      "avg_cvss": 6.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-11-13",
+      "value": 38,
+      "avg_cvss": 7.5,
+      "cvss_count": 38
+    },
+    {
+      "date": "2008-11-14",
+      "value": 19,
+      "avg_cvss": 7.5,
+      "cvss_count": 19
+    },
+    {
+      "date": "2008-11-17",
+      "value": 30,
+      "avg_cvss": 7.4,
+      "cvss_count": 30
+    },
+    {
+      "date": "2008-11-18",
+      "value": 47,
+      "avg_cvss": 6.8,
+      "cvss_count": 47
+    },
+    {
+      "date": "2008-11-19",
+      "value": 14,
+      "avg_cvss": 7.3,
+      "cvss_count": 14
+    },
+    {
+      "date": "2008-11-20",
+      "value": 6,
+      "avg_cvss": 7.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2008-11-21",
+      "value": 26,
+      "avg_cvss": 6.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2008-11-24",
+      "value": 10,
+      "avg_cvss": 6.4,
+      "cvss_count": 10
+    },
+    {
+      "date": "2008-11-25",
+      "value": 25,
+      "avg_cvss": 6.4,
+      "cvss_count": 25
+    },
+    {
+      "date": "2008-11-26",
+      "value": 23,
+      "avg_cvss": 7.2,
+      "cvss_count": 23
+    },
+    {
+      "date": "2008-11-27",
+      "value": 5,
+      "avg_cvss": 5.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2008-11-28",
+      "value": 13,
+      "avg_cvss": 5.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2008-11-29",
+      "value": 6,
+      "avg_cvss": 8.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2008-12-01",
+      "value": 20,
+      "avg_cvss": 6.7,
+      "cvss_count": 20
+    },
+    {
+      "date": "2008-12-02",
+      "value": 6,
+      "avg_cvss": 7.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2008-12-03",
+      "value": 17,
+      "avg_cvss": 6.6,
+      "cvss_count": 17
+    },
+    {
+      "date": "2008-12-05",
+      "value": 41,
+      "avg_cvss": 7.2,
+      "cvss_count": 41
+    },
+    {
+      "date": "2008-12-08",
+      "value": 20,
+      "avg_cvss": 6.7,
+      "cvss_count": 20
+    },
+    {
+      "date": "2008-12-09",
+      "value": 19,
+      "avg_cvss": 7.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2008-12-10",
+      "value": 52,
+      "avg_cvss": 8.5,
+      "cvss_count": 52
+    },
+    {
+      "date": "2008-12-11",
+      "value": 18,
+      "avg_cvss": 5.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2008-12-12",
+      "value": 49,
+      "avg_cvss": 8.1,
+      "cvss_count": 49
+    },
+    {
+      "date": "2008-12-13",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2008-12-15",
+      "value": 26,
+      "avg_cvss": 6.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2008-12-16",
+      "value": 24,
+      "avg_cvss": 6.1,
+      "cvss_count": 24
+    },
+    {
+      "date": "2008-12-17",
+      "value": 72,
+      "avg_cvss": 7.0,
+      "cvss_count": 72
+    },
+    {
+      "date": "2008-12-18",
+      "value": 1,
+      "avg_cvss": 9.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2008-12-19",
+      "value": 42,
+      "avg_cvss": 6.6,
+      "cvss_count": 42
+    },
+    {
+      "date": "2008-12-22",
+      "value": 11,
+      "avg_cvss": 5.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-12-23",
+      "value": 7,
+      "avg_cvss": 8.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2008-12-24",
+      "value": 11,
+      "avg_cvss": 6.7,
+      "cvss_count": 11
+    },
+    {
+      "date": "2008-12-26",
+      "value": 27,
+      "avg_cvss": 6.4,
+      "cvss_count": 27
+    },
+    {
+      "date": "2008-12-29",
+      "value": 7,
+      "avg_cvss": 6.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2008-12-30",
+      "value": 31,
+      "avg_cvss": 6.7,
+      "cvss_count": 31
+    },
+    {
+      "date": "2008-12-31",
+      "value": 26,
+      "avg_cvss": 7.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2009-01-02",
+      "value": 24,
+      "avg_cvss": 6.7,
+      "cvss_count": 24
+    },
+    {
+      "date": "2009-01-05",
+      "value": 12,
+      "avg_cvss": 6.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2009-01-06",
+      "value": 17,
+      "avg_cvss": 5.9,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-01-07",
+      "value": 15,
+      "avg_cvss": 6.1,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-01-08",
+      "value": 20,
+      "avg_cvss": 6.9,
+      "cvss_count": 20
+    },
+    {
+      "date": "2009-01-09",
+      "value": 13,
+      "avg_cvss": 6.8,
+      "cvss_count": 13
+    },
+    {
+      "date": "2009-01-12",
+      "value": 19,
+      "avg_cvss": 6.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2009-01-13",
+      "value": 4,
+      "avg_cvss": 6.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2009-01-14",
+      "value": 45,
+      "avg_cvss": 5.7,
+      "cvss_count": 45
+    },
+    {
+      "date": "2009-01-15",
+      "value": 24,
+      "avg_cvss": 6.4,
+      "cvss_count": 24
+    },
+    {
+      "date": "2009-01-16",
+      "value": 21,
+      "avg_cvss": 6.9,
+      "cvss_count": 21
+    },
+    {
+      "date": "2009-01-20",
+      "value": 19,
+      "avg_cvss": 6.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2009-01-21",
+      "value": 38,
+      "avg_cvss": 6.9,
+      "cvss_count": 38
+    },
+    {
+      "date": "2009-01-22",
+      "value": 31,
+      "avg_cvss": 6.5,
+      "cvss_count": 31
+    },
+    {
+      "date": "2009-01-23",
+      "value": 21,
+      "avg_cvss": 7.2,
+      "cvss_count": 21
+    },
+    {
+      "date": "2009-01-26",
+      "value": 14,
+      "avg_cvss": 7.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2009-01-27",
+      "value": 44,
+      "avg_cvss": 6.7,
+      "cvss_count": 44
+    },
+    {
+      "date": "2009-01-28",
+      "value": 37,
+      "avg_cvss": 6.5,
+      "cvss_count": 37
+    },
+    {
+      "date": "2009-01-29",
+      "value": 28,
+      "avg_cvss": 7.1,
+      "cvss_count": 28
+    },
+    {
+      "date": "2009-01-30",
+      "value": 20,
+      "avg_cvss": 6.5,
+      "cvss_count": 20
+    },
+    {
+      "date": "2009-02-02",
+      "value": 25,
+      "avg_cvss": 7.3,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-02-03",
+      "value": 51,
+      "avg_cvss": 6.8,
+      "cvss_count": 51
+    },
+    {
+      "date": "2009-02-04",
+      "value": 21,
+      "avg_cvss": 6.0,
+      "cvss_count": 21
+    },
+    {
+      "date": "2009-02-05",
+      "value": 26,
+      "avg_cvss": 6.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2009-02-06",
+      "value": 29,
+      "avg_cvss": 6.1,
+      "cvss_count": 29
+    },
+    {
+      "date": "2009-02-08",
+      "value": 14,
+      "avg_cvss": 8.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2009-02-09",
+      "value": 19,
+      "avg_cvss": 5.2,
+      "cvss_count": 19
+    },
+    {
+      "date": "2009-02-10",
+      "value": 75,
+      "avg_cvss": 6.8,
+      "cvss_count": 75
+    },
+    {
+      "date": "2009-02-11",
+      "value": 34,
+      "avg_cvss": 6.5,
+      "cvss_count": 34
+    },
+    {
+      "date": "2009-02-12",
+      "value": 9,
+      "avg_cvss": 6.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2009-02-13",
+      "value": 38,
+      "avg_cvss": 6.4,
+      "cvss_count": 38
+    },
+    {
+      "date": "2009-02-14",
+      "value": 8,
+      "avg_cvss": 6.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2009-02-16",
+      "value": 28,
+      "avg_cvss": 6.4,
+      "cvss_count": 28
+    },
+    {
+      "date": "2009-02-17",
+      "value": 15,
+      "avg_cvss": 6.1,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-02-18",
+      "value": 9,
+      "avg_cvss": 5.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2009-02-19",
+      "value": 32,
+      "avg_cvss": 6.4,
+      "cvss_count": 32
+    },
+    {
+      "date": "2009-02-20",
+      "value": 58,
+      "avg_cvss": 6.7,
+      "cvss_count": 58
+    },
+    {
+      "date": "2009-02-21",
+      "value": 6,
+      "avg_cvss": 8.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2009-02-22",
+      "value": 11,
+      "avg_cvss": 5.5,
+      "cvss_count": 11
+    },
+    {
+      "date": "2009-02-23",
+      "value": 28,
+      "avg_cvss": 6.5,
+      "cvss_count": 28
+    },
+    {
+      "date": "2009-02-24",
+      "value": 25,
+      "avg_cvss": 7.1,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-02-25",
+      "value": 36,
+      "avg_cvss": 6.6,
+      "cvss_count": 36
+    },
+    {
+      "date": "2009-02-26",
+      "value": 43,
+      "avg_cvss": 7.1,
+      "cvss_count": 43
+    },
+    {
+      "date": "2009-02-27",
+      "value": 45,
+      "avg_cvss": 6.3,
+      "cvss_count": 45
+    },
+    {
+      "date": "2009-03-02",
+      "value": 50,
+      "avg_cvss": 6.4,
+      "cvss_count": 50
+    },
+    {
+      "date": "2009-03-03",
+      "value": 9,
+      "avg_cvss": 6.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2009-03-04",
+      "value": 19,
+      "avg_cvss": 6.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2009-03-05",
+      "value": 32,
+      "avg_cvss": 6.6,
+      "cvss_count": 32
+    },
+    {
+      "date": "2009-03-06",
+      "value": 52,
+      "avg_cvss": 6.0,
+      "cvss_count": 52
+    },
+    {
+      "date": "2009-03-09",
+      "value": 24,
+      "avg_cvss": 6.0,
+      "cvss_count": 24
+    },
+    {
+      "date": "2009-03-10",
+      "value": 19,
+      "avg_cvss": 7.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2009-03-11",
+      "value": 13,
+      "avg_cvss": 5.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2009-03-12",
+      "value": 17,
+      "avg_cvss": 6.3,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-03-13",
+      "value": 21,
+      "avg_cvss": 7.0,
+      "cvss_count": 21
+    },
+    {
+      "date": "2009-03-14",
+      "value": 9,
+      "avg_cvss": 5.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2009-03-16",
+      "value": 17,
+      "avg_cvss": 7.1,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-03-17",
+      "value": 11,
+      "avg_cvss": 5.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2009-03-18",
+      "value": 19,
+      "avg_cvss": 6.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2009-03-19",
+      "value": 15,
+      "avg_cvss": 6.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-03-20",
+      "value": 31,
+      "avg_cvss": 6.8,
+      "cvss_count": 31
+    },
+    {
+      "date": "2009-03-23",
+      "value": 19,
+      "avg_cvss": 6.8,
+      "cvss_count": 19
+    },
+    {
+      "date": "2009-03-24",
+      "value": 16,
+      "avg_cvss": 6.9,
+      "cvss_count": 16
+    },
+    {
+      "date": "2009-03-25",
+      "value": 58,
+      "avg_cvss": 7.1,
+      "cvss_count": 58
+    },
+    {
+      "date": "2009-03-26",
+      "value": 24,
+      "avg_cvss": 6.5,
+      "cvss_count": 24
+    },
+    {
+      "date": "2009-03-27",
+      "value": 15,
+      "avg_cvss": 6.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-03-30",
+      "value": 28,
+      "avg_cvss": 7.2,
+      "cvss_count": 28
+    },
+    {
+      "date": "2009-03-31",
+      "value": 35,
+      "avg_cvss": 6.5,
+      "cvss_count": 35
+    },
+    {
+      "date": "2009-04-01",
+      "value": 28,
+      "avg_cvss": 6.9,
+      "cvss_count": 28
+    },
+    {
+      "date": "2009-04-02",
+      "value": 21,
+      "avg_cvss": 6.4,
+      "cvss_count": 21
+    },
+    {
+      "date": "2009-04-03",
+      "value": 25,
+      "avg_cvss": 7.0,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-04-04",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2009-04-06",
+      "value": 38,
+      "avg_cvss": 6.5,
+      "cvss_count": 38
+    },
+    {
+      "date": "2009-04-07",
+      "value": 43,
+      "avg_cvss": 6.4,
+      "cvss_count": 43
+    },
+    {
+      "date": "2009-04-08",
+      "value": 25,
+      "avg_cvss": 5.9,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-04-09",
+      "value": 31,
+      "avg_cvss": 6.0,
+      "cvss_count": 31
+    },
+    {
+      "date": "2009-04-10",
+      "value": 32,
+      "avg_cvss": 6.7,
+      "cvss_count": 32
+    },
+    {
+      "date": "2009-04-13",
+      "value": 18,
+      "avg_cvss": 6.2,
+      "cvss_count": 18
+    },
+    {
+      "date": "2009-04-14",
+      "value": 6,
+      "avg_cvss": 5.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2009-04-15",
+      "value": 63,
+      "avg_cvss": 6.3,
+      "cvss_count": 63
+    },
+    {
+      "date": "2009-04-16",
+      "value": 10,
+      "avg_cvss": 7.9,
+      "cvss_count": 10
+    },
+    {
+      "date": "2009-04-17",
+      "value": 32,
+      "avg_cvss": 6.8,
+      "cvss_count": 32
+    },
+    {
+      "date": "2009-04-20",
+      "value": 11,
+      "avg_cvss": 6.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2009-04-21",
+      "value": 26,
+      "avg_cvss": 7.0,
+      "cvss_count": 26
+    },
+    {
+      "date": "2009-04-22",
+      "value": 25,
+      "avg_cvss": 5.5,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-04-23",
+      "value": 25,
+      "avg_cvss": 6.0,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-04-24",
+      "value": 23,
+      "avg_cvss": 6.5,
+      "cvss_count": 23
+    },
+    {
+      "date": "2009-04-27",
+      "value": 19,
+      "avg_cvss": 6.2,
+      "cvss_count": 19
+    },
+    {
+      "date": "2009-04-28",
+      "value": 26,
+      "avg_cvss": 6.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2009-04-29",
+      "value": 23,
+      "avg_cvss": 6.5,
+      "cvss_count": 23
+    },
+    {
+      "date": "2009-04-30",
+      "value": 16,
+      "avg_cvss": 6.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2009-05-01",
+      "value": 33,
+      "avg_cvss": 7.0,
+      "cvss_count": 33
+    },
+    {
+      "date": "2009-05-04",
+      "value": 11,
+      "avg_cvss": 5.7,
+      "cvss_count": 11
+    },
+    {
+      "date": "2009-05-05",
+      "value": 17,
+      "avg_cvss": 7.0,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-05-06",
+      "value": 19,
+      "avg_cvss": 5.8,
+      "cvss_count": 19
+    },
+    {
+      "date": "2009-05-07",
+      "value": 19,
+      "avg_cvss": 7.0,
+      "cvss_count": 19
+    },
+    {
+      "date": "2009-05-08",
+      "value": 5,
+      "avg_cvss": 5.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2009-05-11",
+      "value": 27,
+      "avg_cvss": 7.2,
+      "cvss_count": 27
+    },
+    {
+      "date": "2009-05-12",
+      "value": 27,
+      "avg_cvss": 8.0,
+      "cvss_count": 27
+    },
+    {
+      "date": "2009-05-13",
+      "value": 20,
+      "avg_cvss": 6.3,
+      "cvss_count": 20
+    },
+    {
+      "date": "2009-05-14",
+      "value": 12,
+      "avg_cvss": 5.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2009-05-15",
+      "value": 12,
+      "avg_cvss": 8.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2009-05-16",
+      "value": 8,
+      "avg_cvss": 7.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2009-05-18",
+      "value": 25,
+      "avg_cvss": 7.8,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-05-19",
+      "value": 5,
+      "avg_cvss": 5.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2009-05-20",
+      "value": 13,
+      "avg_cvss": 6.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2009-05-21",
+      "value": 9,
+      "avg_cvss": 6.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2009-05-22",
+      "value": 40,
+      "avg_cvss": 6.3,
+      "cvss_count": 40
+    },
+    {
+      "date": "2009-05-26",
+      "value": 17,
+      "avg_cvss": 7.1,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-05-27",
+      "value": 5,
+      "avg_cvss": 8.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2009-05-28",
+      "value": 15,
+      "avg_cvss": 6.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-05-29",
+      "value": 25,
+      "avg_cvss": 6.6,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-06-01",
+      "value": 20,
+      "avg_cvss": 6.5,
+      "cvss_count": 20
+    },
+    {
+      "date": "2009-06-02",
+      "value": 16,
+      "avg_cvss": 8.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2009-06-03",
+      "value": 13,
+      "avg_cvss": 6.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2009-06-04",
+      "value": 17,
+      "avg_cvss": 6.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-06-05",
+      "value": 25,
+      "avg_cvss": 5.9,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-06-08",
+      "value": 27,
+      "avg_cvss": 6.0,
+      "cvss_count": 27
+    },
+    {
+      "date": "2009-06-09",
+      "value": 19,
+      "avg_cvss": 6.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2009-06-10",
+      "value": 66,
+      "avg_cvss": 7.2,
+      "cvss_count": 66
+    },
+    {
+      "date": "2009-06-11",
+      "value": 21,
+      "avg_cvss": 8.5,
+      "cvss_count": 21
+    },
+    {
+      "date": "2009-06-12",
+      "value": 24,
+      "avg_cvss": 6.8,
+      "cvss_count": 24
+    },
+    {
+      "date": "2009-06-15",
+      "value": 17,
+      "avg_cvss": 6.6,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-06-16",
+      "value": 18,
+      "avg_cvss": 5.8,
+      "cvss_count": 18
+    },
+    {
+      "date": "2009-06-17",
+      "value": 13,
+      "avg_cvss": 6.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2009-06-18",
+      "value": 14,
+      "avg_cvss": 6.3,
+      "cvss_count": 14
+    },
+    {
+      "date": "2009-06-19",
+      "value": 25,
+      "avg_cvss": 5.5,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-06-22",
+      "value": 31,
+      "avg_cvss": 6.4,
+      "cvss_count": 31
+    },
+    {
+      "date": "2009-06-23",
+      "value": 18,
+      "avg_cvss": 6.0,
+      "cvss_count": 18
+    },
+    {
+      "date": "2009-06-25",
+      "value": 25,
+      "avg_cvss": 6.2,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-06-26",
+      "value": 17,
+      "avg_cvss": 6.8,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-06-27",
+      "value": 15,
+      "avg_cvss": 6.3,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-06-30",
+      "value": 9,
+      "avg_cvss": 7.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2009-07-01",
+      "value": 25,
+      "avg_cvss": 6.0,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-07-02",
+      "value": 25,
+      "avg_cvss": 6.7,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-07-05",
+      "value": 28,
+      "avg_cvss": 6.2,
+      "cvss_count": 28
+    },
+    {
+      "date": "2009-07-07",
+      "value": 27,
+      "avg_cvss": 6.6,
+      "cvss_count": 27
+    },
+    {
+      "date": "2009-07-08",
+      "value": 26,
+      "avg_cvss": 7.0,
+      "cvss_count": 26
+    },
+    {
+      "date": "2009-07-09",
+      "value": 23,
+      "avg_cvss": 6.5,
+      "cvss_count": 23
+    },
+    {
+      "date": "2009-07-10",
+      "value": 17,
+      "avg_cvss": 6.0,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-07-13",
+      "value": 17,
+      "avg_cvss": 5.8,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-07-14",
+      "value": 61,
+      "avg_cvss": 6.6,
+      "cvss_count": 61
+    },
+    {
+      "date": "2009-07-15",
+      "value": 9,
+      "avg_cvss": 9.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2009-07-16",
+      "value": 17,
+      "avg_cvss": 6.0,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-07-17",
+      "value": 5,
+      "avg_cvss": 5.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2009-07-20",
+      "value": 23,
+      "avg_cvss": 6.2,
+      "cvss_count": 23
+    },
+    {
+      "date": "2009-07-21",
+      "value": 12,
+      "avg_cvss": 6.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2009-07-22",
+      "value": 22,
+      "avg_cvss": 7.7,
+      "cvss_count": 22
+    },
+    {
+      "date": "2009-07-23",
+      "value": 11,
+      "avg_cvss": 6.1,
+      "cvss_count": 11
+    },
+    {
+      "date": "2009-07-24",
+      "value": 14,
+      "avg_cvss": 5.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2009-07-27",
+      "value": 26,
+      "avg_cvss": 6.6,
+      "cvss_count": 26
+    },
+    {
+      "date": "2009-07-28",
+      "value": 13,
+      "avg_cvss": 7.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2009-07-29",
+      "value": 14,
+      "avg_cvss": 7.7,
+      "cvss_count": 14
+    },
+    {
+      "date": "2009-07-30",
+      "value": 16,
+      "avg_cvss": 6.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2009-07-31",
+      "value": 15,
+      "avg_cvss": 7.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-08-03",
+      "value": 18,
+      "avg_cvss": 6.2,
+      "cvss_count": 18
+    },
+    {
+      "date": "2009-08-04",
+      "value": 11,
+      "avg_cvss": 6.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2009-08-05",
+      "value": 16,
+      "avg_cvss": 7.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2009-08-06",
+      "value": 25,
+      "avg_cvss": 7.0,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-08-07",
+      "value": 15,
+      "avg_cvss": 6.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-08-10",
+      "value": 27,
+      "avg_cvss": 7.7,
+      "cvss_count": 27
+    },
+    {
+      "date": "2009-08-11",
+      "value": 22,
+      "avg_cvss": 6.3,
+      "cvss_count": 22
+    },
+    {
+      "date": "2009-08-12",
+      "value": 43,
+      "avg_cvss": 7.5,
+      "cvss_count": 43
+    },
+    {
+      "date": "2009-08-13",
+      "value": 25,
+      "avg_cvss": 6.1,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-08-14",
+      "value": 22,
+      "avg_cvss": 6.7,
+      "cvss_count": 22
+    },
+    {
+      "date": "2009-08-17",
+      "value": 14,
+      "avg_cvss": 6.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2009-08-18",
+      "value": 19,
+      "avg_cvss": 5.7,
+      "cvss_count": 19
+    },
+    {
+      "date": "2009-08-19",
+      "value": 49,
+      "avg_cvss": 6.3,
+      "cvss_count": 49
+    },
+    {
+      "date": "2009-08-20",
+      "value": 16,
+      "avg_cvss": 6.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2009-08-21",
+      "value": 44,
+      "avg_cvss": 6.0,
+      "cvss_count": 44
+    },
+    {
+      "date": "2009-08-24",
+      "value": 40,
+      "avg_cvss": 6.3,
+      "cvss_count": 40
+    },
+    {
+      "date": "2009-08-25",
+      "value": 29,
+      "avg_cvss": 7.2,
+      "cvss_count": 29
+    },
+    {
+      "date": "2009-08-26",
+      "value": 12,
+      "avg_cvss": 6.2,
+      "cvss_count": 12
+    },
+    {
+      "date": "2009-08-27",
+      "value": 27,
+      "avg_cvss": 6.8,
+      "cvss_count": 27
+    },
+    {
+      "date": "2009-08-28",
+      "value": 25,
+      "avg_cvss": 6.1,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-08-31",
+      "value": 28,
+      "avg_cvss": 5.8,
+      "cvss_count": 28
+    },
+    {
+      "date": "2009-09-01",
+      "value": 26,
+      "avg_cvss": 6.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2009-09-02",
+      "value": 20,
+      "avg_cvss": 6.4,
+      "cvss_count": 20
+    },
+    {
+      "date": "2009-09-03",
+      "value": 16,
+      "avg_cvss": 6.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2009-09-04",
+      "value": 12,
+      "avg_cvss": 7.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2009-09-08",
+      "value": 64,
+      "avg_cvss": 7.2,
+      "cvss_count": 64
+    },
+    {
+      "date": "2009-09-09",
+      "value": 24,
+      "avg_cvss": 6.5,
+      "cvss_count": 24
+    },
+    {
+      "date": "2009-09-10",
+      "value": 55,
+      "avg_cvss": 7.0,
+      "cvss_count": 55
+    },
+    {
+      "date": "2009-09-11",
+      "value": 31,
+      "avg_cvss": 6.6,
+      "cvss_count": 31
+    },
+    {
+      "date": "2009-09-13",
+      "value": 6,
+      "avg_cvss": 8.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2009-09-14",
+      "value": 30,
+      "avg_cvss": 6.5,
+      "cvss_count": 30
+    },
+    {
+      "date": "2009-09-15",
+      "value": 24,
+      "avg_cvss": 5.5,
+      "cvss_count": 24
+    },
+    {
+      "date": "2009-09-16",
+      "value": 26,
+      "avg_cvss": 6.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2009-09-17",
+      "value": 13,
+      "avg_cvss": 6.2,
+      "cvss_count": 13
+    },
+    {
+      "date": "2009-09-18",
+      "value": 39,
+      "avg_cvss": 5.9,
+      "cvss_count": 39
+    },
+    {
+      "date": "2009-09-21",
+      "value": 16,
+      "avg_cvss": 5.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2009-09-22",
+      "value": 11,
+      "avg_cvss": 6.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2009-09-23",
+      "value": 29,
+      "avg_cvss": 7.1,
+      "cvss_count": 29
+    },
+    {
+      "date": "2009-09-24",
+      "value": 39,
+      "avg_cvss": 7.5,
+      "cvss_count": 39
+    },
+    {
+      "date": "2009-09-25",
+      "value": 15,
+      "avg_cvss": 6.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-09-28",
+      "value": 27,
+      "avg_cvss": 6.4,
+      "cvss_count": 27
+    },
+    {
+      "date": "2009-09-29",
+      "value": 24,
+      "avg_cvss": 6.3,
+      "cvss_count": 24
+    },
+    {
+      "date": "2009-09-30",
+      "value": 27,
+      "avg_cvss": 6.6,
+      "cvss_count": 27
+    },
+    {
+      "date": "2009-10-01",
+      "value": 21,
+      "avg_cvss": 6.6,
+      "cvss_count": 21
+    },
+    {
+      "date": "2009-10-02",
+      "value": 16,
+      "avg_cvss": 6.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2009-10-05",
+      "value": 6,
+      "avg_cvss": 5.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2009-10-06",
+      "value": 10,
+      "avg_cvss": 7.3,
+      "cvss_count": 10
+    },
+    {
+      "date": "2009-10-07",
+      "value": 4,
+      "avg_cvss": 5.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2009-10-08",
+      "value": 13,
+      "avg_cvss": 5.2,
+      "cvss_count": 13
+    },
+    {
+      "date": "2009-10-09",
+      "value": 17,
+      "avg_cvss": 5.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-10-11",
+      "value": 12,
+      "avg_cvss": 7.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2009-10-13",
+      "value": 14,
+      "avg_cvss": 6.6,
+      "cvss_count": 14
+    },
+    {
+      "date": "2009-10-14",
+      "value": 29,
+      "avg_cvss": 8.3,
+      "cvss_count": 29
+    },
+    {
+      "date": "2009-10-15",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2009-10-16",
+      "value": 23,
+      "avg_cvss": 7.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2009-10-19",
+      "value": 31,
+      "avg_cvss": 7.6,
+      "cvss_count": 31
+    },
+    {
+      "date": "2009-10-20",
+      "value": 6,
+      "avg_cvss": 5.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2009-10-21",
+      "value": 6,
+      "avg_cvss": 8.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2009-10-22",
+      "value": 62,
+      "avg_cvss": 5.5,
+      "cvss_count": 62
+    },
+    {
+      "date": "2009-10-23",
+      "value": 7,
+      "avg_cvss": 6.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2009-10-26",
+      "value": 15,
+      "avg_cvss": 6.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-10-27",
+      "value": 15,
+      "avg_cvss": 6.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-10-28",
+      "value": 14,
+      "avg_cvss": 6.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2009-10-29",
+      "value": 18,
+      "avg_cvss": 8.1,
+      "cvss_count": 18
+    },
+    {
+      "date": "2009-10-30",
+      "value": 10,
+      "avg_cvss": 6.4,
+      "cvss_count": 10
+    },
+    {
+      "date": "2009-11-02",
+      "value": 20,
+      "avg_cvss": 6.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2009-11-03",
+      "value": 6,
+      "avg_cvss": 6.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2009-11-04",
+      "value": 17,
+      "avg_cvss": 7.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "2009-11-05",
+      "value": 14,
+      "avg_cvss": 8.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2009-11-06",
+      "value": 11,
+      "avg_cvss": 6.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2009-11-09",
+      "value": 24,
+      "avg_cvss": 5.8,
+      "cvss_count": 24
+    },
+    {
+      "date": "2009-11-10",
+      "value": 29,
+      "avg_cvss": 6.2,
+      "cvss_count": 29
+    },
+    {
+      "date": "2009-11-11",
+      "value": 15,
+      "avg_cvss": 8.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-11-12",
+      "value": 8,
+      "avg_cvss": 7.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2009-11-13",
+      "value": 12,
+      "avg_cvss": 6.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2009-11-16",
+      "value": 15,
+      "avg_cvss": 5.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2009-11-17",
+      "value": 7,
+      "avg_cvss": 6.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2009-11-18",
+      "value": 13,
+      "avg_cvss": 7.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2009-11-19",
+      "value": 4,
+      "avg_cvss": 5.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2009-11-20",
+      "value": 20,
+      "avg_cvss": 6.4,
+      "cvss_count": 20
+    },
+    {
+      "date": "2009-11-23",
+      "value": 10,
+      "avg_cvss": 5.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2009-11-24",
+      "value": 25,
+      "avg_cvss": 6.4,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-11-25",
+      "value": 9,
+      "avg_cvss": 5.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2009-11-29",
+      "value": 40,
+      "avg_cvss": 6.7,
+      "cvss_count": 40
+    },
+    {
+      "date": "2009-11-30",
+      "value": 9,
+      "avg_cvss": 5.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2009-12-01",
+      "value": 7,
+      "avg_cvss": 6.1,
+      "cvss_count": 7
+    },
+    {
+      "date": "2009-12-02",
+      "value": 35,
+      "avg_cvss": 6.0,
+      "cvss_count": 35
+    },
+    {
+      "date": "2009-12-03",
+      "value": 12,
+      "avg_cvss": 7.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2009-12-04",
+      "value": 21,
+      "avg_cvss": 6.8,
+      "cvss_count": 21
+    },
+    {
+      "date": "2009-12-07",
+      "value": 11,
+      "avg_cvss": 7.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2009-12-08",
+      "value": 21,
+      "avg_cvss": 7.0,
+      "cvss_count": 21
+    },
+    {
+      "date": "2009-12-09",
+      "value": 14,
+      "avg_cvss": 8.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2009-12-10",
+      "value": 36,
+      "avg_cvss": 8.0,
+      "cvss_count": 36
+    },
+    {
+      "date": "2009-12-11",
+      "value": 6,
+      "avg_cvss": 8.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2009-12-13",
+      "value": 10,
+      "avg_cvss": 8.2,
+      "cvss_count": 10
+    },
+    {
+      "date": "2009-12-14",
+      "value": 12,
+      "avg_cvss": 5.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2009-12-15",
+      "value": 6,
+      "avg_cvss": 5.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2009-12-16",
+      "value": 23,
+      "avg_cvss": 5.8,
+      "cvss_count": 23
+    },
+    {
+      "date": "2009-12-17",
+      "value": 30,
+      "avg_cvss": 6.7,
+      "cvss_count": 30
+    },
+    {
+      "date": "2009-12-18",
+      "value": 14,
+      "avg_cvss": 9.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2009-12-20",
+      "value": 4,
+      "avg_cvss": 5.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2009-12-21",
+      "value": 26,
+      "avg_cvss": 6.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2009-12-22",
+      "value": 25,
+      "avg_cvss": 5.9,
+      "cvss_count": 25
+    },
+    {
+      "date": "2009-12-23",
+      "value": 16,
+      "avg_cvss": 5.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2009-12-24",
+      "value": 16,
+      "avg_cvss": 5.9,
+      "cvss_count": 16
+    },
+    {
+      "date": "2009-12-28",
+      "value": 23,
+      "avg_cvss": 6.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2009-12-29",
+      "value": 13,
+      "avg_cvss": 5.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2009-12-30",
+      "value": 30,
+      "avg_cvss": 6.6,
+      "cvss_count": 30
+    },
+    {
+      "date": "2009-12-31",
+      "value": 29,
+      "avg_cvss": 5.2,
+      "cvss_count": 29
+    },
+    {
+      "date": "2010-01-04",
+      "value": 28,
+      "avg_cvss": 5.8,
+      "cvss_count": 28
+    },
+    {
+      "date": "2010-01-05",
+      "value": 7,
+      "avg_cvss": 5.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2010-01-06",
+      "value": 15,
+      "avg_cvss": 6.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2010-01-07",
+      "value": 20,
+      "avg_cvss": 4.9,
+      "cvss_count": 20
+    },
+    {
+      "date": "2010-01-08",
+      "value": 8,
+      "avg_cvss": 7.9,
+      "cvss_count": 8
+    },
+    {
+      "date": "2010-01-09",
+      "value": 6,
+      "avg_cvss": 8.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2010-01-12",
+      "value": 14,
+      "avg_cvss": 6.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2010-01-13",
+      "value": 50,
+      "avg_cvss": 6.5,
+      "cvss_count": 50
+    },
+    {
+      "date": "2010-01-14",
+      "value": 13,
+      "avg_cvss": 5.8,
+      "cvss_count": 13
+    },
+    {
+      "date": "2010-01-15",
+      "value": 37,
+      "avg_cvss": 6.4,
+      "cvss_count": 37
+    },
+    {
+      "date": "2010-01-18",
+      "value": 16,
+      "avg_cvss": 7.3,
+      "cvss_count": 16
+    },
+    {
+      "date": "2010-01-19",
+      "value": 7,
+      "avg_cvss": 7.8,
+      "cvss_count": 7
+    },
+    {
+      "date": "2010-01-20",
+      "value": 11,
+      "avg_cvss": 8.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2010-01-21",
+      "value": 19,
+      "avg_cvss": 7.2,
+      "cvss_count": 19
+    },
+    {
+      "date": "2010-01-22",
+      "value": 12,
+      "avg_cvss": 7.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2010-01-25",
+      "value": 18,
+      "avg_cvss": 7.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-01-26",
+      "value": 6,
+      "avg_cvss": 7.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2010-01-27",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2010-01-28",
+      "value": 22,
+      "avg_cvss": 6.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2010-01-29",
+      "value": 8,
+      "avg_cvss": 5.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "2010-02-02",
+      "value": 12,
+      "avg_cvss": 6.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2010-02-03",
+      "value": 12,
+      "avg_cvss": 5.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2010-02-04",
+      "value": 17,
+      "avg_cvss": 5.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2010-02-05",
+      "value": 17,
+      "avg_cvss": 4.4,
+      "cvss_count": 17
+    },
+    {
+      "date": "2010-02-08",
+      "value": 10,
+      "avg_cvss": 5.1,
+      "cvss_count": 10
+    },
+    {
+      "date": "2010-02-09",
+      "value": 2,
+      "avg_cvss": 8.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2010-02-10",
+      "value": 36,
+      "avg_cvss": 8.1,
+      "cvss_count": 36
+    },
+    {
+      "date": "2010-02-11",
+      "value": 21,
+      "avg_cvss": 7.0,
+      "cvss_count": 21
+    },
+    {
+      "date": "2010-02-12",
+      "value": 15,
+      "avg_cvss": 6.6,
+      "cvss_count": 15
+    },
+    {
+      "date": "2010-02-15",
+      "value": 12,
+      "avg_cvss": 5.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2010-02-16",
+      "value": 5,
+      "avg_cvss": 9.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2010-02-17",
+      "value": 4,
+      "avg_cvss": 4.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2010-02-18",
+      "value": 25,
+      "avg_cvss": 6.2,
+      "cvss_count": 25
+    },
+    {
+      "date": "2010-02-19",
+      "value": 17,
+      "avg_cvss": 6.9,
+      "cvss_count": 17
+    },
+    {
+      "date": "2010-02-22",
+      "value": 25,
+      "avg_cvss": 6.5,
+      "cvss_count": 25
+    },
+    {
+      "date": "2010-02-23",
+      "value": 22,
+      "avg_cvss": 6.3,
+      "cvss_count": 22
+    },
+    {
+      "date": "2010-02-24",
+      "value": 6,
+      "avg_cvss": 4.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2010-02-25",
+      "value": 18,
+      "avg_cvss": 5.7,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-02-26",
+      "value": 23,
+      "avg_cvss": 6.6,
+      "cvss_count": 23
+    },
+    {
+      "date": "2010-02-27",
+      "value": 9,
+      "avg_cvss": 6.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2010-03-02",
+      "value": 19,
+      "avg_cvss": 6.0,
+      "cvss_count": 19
+    },
+    {
+      "date": "2010-03-03",
+      "value": 22,
+      "avg_cvss": 6.4,
+      "cvss_count": 22
+    },
+    {
+      "date": "2010-03-05",
+      "value": 42,
+      "avg_cvss": 7.0,
+      "cvss_count": 42
+    },
+    {
+      "date": "2010-03-08",
+      "value": 14,
+      "avg_cvss": 5.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2010-03-10",
+      "value": 50,
+      "avg_cvss": 6.7,
+      "cvss_count": 50
+    },
+    {
+      "date": "2010-03-15",
+      "value": 42,
+      "avg_cvss": 6.6,
+      "cvss_count": 42
+    },
+    {
+      "date": "2010-03-16",
+      "value": 28,
+      "avg_cvss": 6.1,
+      "cvss_count": 28
+    },
+    {
+      "date": "2010-03-18",
+      "value": 20,
+      "avg_cvss": 6.9,
+      "cvss_count": 20
+    },
+    {
+      "date": "2010-03-19",
+      "value": 35,
+      "avg_cvss": 6.3,
+      "cvss_count": 35
+    },
+    {
+      "date": "2010-03-23",
+      "value": 47,
+      "avg_cvss": 6.2,
+      "cvss_count": 47
+    },
+    {
+      "date": "2010-03-24",
+      "value": 19,
+      "avg_cvss": 6.1,
+      "cvss_count": 19
+    },
+    {
+      "date": "2010-03-25",
+      "value": 40,
+      "avg_cvss": 6.9,
+      "cvss_count": 40
+    },
+    {
+      "date": "2010-03-26",
+      "value": 28,
+      "avg_cvss": 6.3,
+      "cvss_count": 28
+    },
+    {
+      "date": "2010-03-27",
+      "value": 6,
+      "avg_cvss": 7.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2010-03-29",
+      "value": 24,
+      "avg_cvss": 7.6,
+      "cvss_count": 24
+    },
+    {
+      "date": "2010-03-30",
+      "value": 49,
+      "avg_cvss": 6.6,
+      "cvss_count": 49
+    },
+    {
+      "date": "2010-03-31",
+      "value": 28,
+      "avg_cvss": 6.9,
+      "cvss_count": 28
+    },
+    {
+      "date": "2010-04-01",
+      "value": 48,
+      "avg_cvss": 6.5,
+      "cvss_count": 48
+    },
+    {
+      "date": "2010-04-05",
+      "value": 43,
+      "avg_cvss": 6.4,
+      "cvss_count": 43
+    },
+    {
+      "date": "2010-04-06",
+      "value": 24,
+      "avg_cvss": 6.4,
+      "cvss_count": 24
+    },
+    {
+      "date": "2010-04-07",
+      "value": 11,
+      "avg_cvss": 6.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2010-04-08",
+      "value": 15,
+      "avg_cvss": 5.3,
+      "cvss_count": 15
+    },
+    {
+      "date": "2010-04-09",
+      "value": 18,
+      "avg_cvss": 6.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-04-12",
+      "value": 21,
+      "avg_cvss": 6.9,
+      "cvss_count": 21
+    },
+    {
+      "date": "2010-04-13",
+      "value": 66,
+      "avg_cvss": 5.3,
+      "cvss_count": 66
+    },
+    {
+      "date": "2010-04-14",
+      "value": 40,
+      "avg_cvss": 7.9,
+      "cvss_count": 40
+    },
+    {
+      "date": "2010-04-15",
+      "value": 10,
+      "avg_cvss": 7.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2010-04-16",
+      "value": 14,
+      "avg_cvss": 6.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2010-04-19",
+      "value": 13,
+      "avg_cvss": 7.2,
+      "cvss_count": 13
+    },
+    {
+      "date": "2010-04-20",
+      "value": 27,
+      "avg_cvss": 6.5,
+      "cvss_count": 27
+    },
+    {
+      "date": "2010-04-21",
+      "value": 19,
+      "avg_cvss": 6.5,
+      "cvss_count": 19
+    },
+    {
+      "date": "2010-04-22",
+      "value": 16,
+      "avg_cvss": 6.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2010-04-23",
+      "value": 28,
+      "avg_cvss": 6.6,
+      "cvss_count": 28
+    },
+    {
+      "date": "2010-04-26",
+      "value": 17,
+      "avg_cvss": 5.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "2010-04-27",
+      "value": 24,
+      "avg_cvss": 5.4,
+      "cvss_count": 24
+    },
+    {
+      "date": "2010-04-28",
+      "value": 18,
+      "avg_cvss": 6.0,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-04-29",
+      "value": 28,
+      "avg_cvss": 6.2,
+      "cvss_count": 28
+    },
+    {
+      "date": "2010-05-03",
+      "value": 16,
+      "avg_cvss": 5.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2010-05-04",
+      "value": 29,
+      "avg_cvss": 6.6,
+      "cvss_count": 29
+    },
+    {
+      "date": "2010-05-05",
+      "value": 5,
+      "avg_cvss": 7.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2010-05-06",
+      "value": 32,
+      "avg_cvss": 6.4,
+      "cvss_count": 32
+    },
+    {
+      "date": "2010-05-07",
+      "value": 43,
+      "avg_cvss": 5.9,
+      "cvss_count": 43
+    },
+    {
+      "date": "2010-05-11",
+      "value": 18,
+      "avg_cvss": 5.8,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-05-12",
+      "value": 42,
+      "avg_cvss": 6.8,
+      "cvss_count": 42
+    },
+    {
+      "date": "2010-05-13",
+      "value": 28,
+      "avg_cvss": 8.5,
+      "cvss_count": 28
+    },
+    {
+      "date": "2010-05-14",
+      "value": 20,
+      "avg_cvss": 6.4,
+      "cvss_count": 20
+    },
+    {
+      "date": "2010-05-17",
+      "value": 9,
+      "avg_cvss": 5.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2010-05-19",
+      "value": 40,
+      "avg_cvss": 6.6,
+      "cvss_count": 40
+    },
+    {
+      "date": "2010-05-20",
+      "value": 24,
+      "avg_cvss": 5.2,
+      "cvss_count": 24
+    },
+    {
+      "date": "2010-05-21",
+      "value": 11,
+      "avg_cvss": 5.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2010-05-24",
+      "value": 16,
+      "avg_cvss": 5.9,
+      "cvss_count": 16
+    },
+    {
+      "date": "2010-05-25",
+      "value": 21,
+      "avg_cvss": 6.0,
+      "cvss_count": 21
+    },
+    {
+      "date": "2010-05-26",
+      "value": 14,
+      "avg_cvss": 5.7,
+      "cvss_count": 14
+    },
+    {
+      "date": "2010-05-27",
+      "value": 34,
+      "avg_cvss": 6.4,
+      "cvss_count": 34
+    },
+    {
+      "date": "2010-05-28",
+      "value": 16,
+      "avg_cvss": 6.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2010-06-01",
+      "value": 18,
+      "avg_cvss": 5.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-06-02",
+      "value": 14,
+      "avg_cvss": 6.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2010-06-03",
+      "value": 17,
+      "avg_cvss": 5.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2010-06-07",
+      "value": 12,
+      "avg_cvss": 4.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2010-06-08",
+      "value": 47,
+      "avg_cvss": 7.6,
+      "cvss_count": 47
+    },
+    {
+      "date": "2010-06-09",
+      "value": 7,
+      "avg_cvss": 6.1,
+      "cvss_count": 7
+    },
+    {
+      "date": "2010-06-10",
+      "value": 11,
+      "avg_cvss": 8.7,
+      "cvss_count": 11
+    },
+    {
+      "date": "2010-06-11",
+      "value": 56,
+      "avg_cvss": 7.0,
+      "cvss_count": 56
+    },
+    {
+      "date": "2010-06-15",
+      "value": 78,
+      "avg_cvss": 7.3,
+      "cvss_count": 78
+    },
+    {
+      "date": "2010-06-16",
+      "value": 14,
+      "avg_cvss": 6.6,
+      "cvss_count": 14
+    },
+    {
+      "date": "2010-06-17",
+      "value": 28,
+      "avg_cvss": 5.9,
+      "cvss_count": 28
+    },
+    {
+      "date": "2010-06-18",
+      "value": 30,
+      "avg_cvss": 6.5,
+      "cvss_count": 30
+    },
+    {
+      "date": "2010-06-21",
+      "value": 21,
+      "avg_cvss": 6.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2010-06-22",
+      "value": 16,
+      "avg_cvss": 5.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2010-06-24",
+      "value": 33,
+      "avg_cvss": 6.2,
+      "cvss_count": 33
+    },
+    {
+      "date": "2010-06-25",
+      "value": 26,
+      "avg_cvss": 5.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2010-06-28",
+      "value": 23,
+      "avg_cvss": 5.5,
+      "cvss_count": 23
+    },
+    {
+      "date": "2010-06-29",
+      "value": 18,
+      "avg_cvss": 7.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-06-30",
+      "value": 21,
+      "avg_cvss": 8.6,
+      "cvss_count": 21
+    },
+    {
+      "date": "2010-07-02",
+      "value": 31,
+      "avg_cvss": 6.0,
+      "cvss_count": 31
+    },
+    {
+      "date": "2010-07-06",
+      "value": 26,
+      "avg_cvss": 6.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2010-07-08",
+      "value": 30,
+      "avg_cvss": 5.8,
+      "cvss_count": 30
+    },
+    {
+      "date": "2010-07-12",
+      "value": 36,
+      "avg_cvss": 6.7,
+      "cvss_count": 36
+    },
+    {
+      "date": "2010-07-13",
+      "value": 71,
+      "avg_cvss": 5.1,
+      "cvss_count": 71
+    },
+    {
+      "date": "2010-07-15",
+      "value": 9,
+      "avg_cvss": 6.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2010-07-22",
+      "value": 34,
+      "avg_cvss": 6.5,
+      "cvss_count": 34
+    },
+    {
+      "date": "2010-07-25",
+      "value": 16,
+      "avg_cvss": 5.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2010-07-28",
+      "value": 45,
+      "avg_cvss": 7.2,
+      "cvss_count": 45
+    },
+    {
+      "date": "2010-07-30",
+      "value": 45,
+      "avg_cvss": 7.4,
+      "cvss_count": 45
+    },
+    {
+      "date": "2010-08-02",
+      "value": 18,
+      "avg_cvss": 6.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-08-05",
+      "value": 27,
+      "avg_cvss": 7.1,
+      "cvss_count": 27
+    },
+    {
+      "date": "2010-08-09",
+      "value": 18,
+      "avg_cvss": 7.2,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-08-10",
+      "value": 20,
+      "avg_cvss": 6.3,
+      "cvss_count": 20
+    },
+    {
+      "date": "2010-08-11",
+      "value": 46,
+      "avg_cvss": 8.1,
+      "cvss_count": 46
+    },
+    {
+      "date": "2010-08-13",
+      "value": 4,
+      "avg_cvss": 7.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2010-08-16",
+      "value": 24,
+      "avg_cvss": 6.0,
+      "cvss_count": 24
+    },
+    {
+      "date": "2010-08-17",
+      "value": 22,
+      "avg_cvss": 7.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2010-08-19",
+      "value": 24,
+      "avg_cvss": 6.4,
+      "cvss_count": 24
+    },
+    {
+      "date": "2010-08-20",
+      "value": 26,
+      "avg_cvss": 6.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2010-08-21",
+      "value": 4,
+      "avg_cvss": 9.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2010-08-23",
+      "value": 11,
+      "avg_cvss": 7.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2010-08-24",
+      "value": 20,
+      "avg_cvss": 7.8,
+      "cvss_count": 20
+    },
+    {
+      "date": "2010-08-25",
+      "value": 31,
+      "avg_cvss": 6.6,
+      "cvss_count": 31
+    },
+    {
+      "date": "2010-08-26",
+      "value": 38,
+      "avg_cvss": 9.0,
+      "cvss_count": 38
+    },
+    {
+      "date": "2010-08-27",
+      "value": 18,
+      "avg_cvss": 9.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-08-30",
+      "value": 17,
+      "avg_cvss": 7.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2010-08-31",
+      "value": 12,
+      "avg_cvss": 6.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2010-09-03",
+      "value": 16,
+      "avg_cvss": 6.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2010-09-07",
+      "value": 26,
+      "avg_cvss": 6.9,
+      "cvss_count": 26
+    },
+    {
+      "date": "2010-09-08",
+      "value": 15,
+      "avg_cvss": 5.8,
+      "cvss_count": 15
+    },
+    {
+      "date": "2010-09-09",
+      "value": 27,
+      "avg_cvss": 7.2,
+      "cvss_count": 27
+    },
+    {
+      "date": "2010-09-10",
+      "value": 18,
+      "avg_cvss": 6.8,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-09-13",
+      "value": 8,
+      "avg_cvss": 5.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2010-09-14",
+      "value": 10,
+      "avg_cvss": 5.7,
+      "cvss_count": 10
+    },
+    {
+      "date": "2010-09-15",
+      "value": 25,
+      "avg_cvss": 7.7,
+      "cvss_count": 25
+    },
+    {
+      "date": "2010-09-16",
+      "value": 24,
+      "avg_cvss": 6.7,
+      "cvss_count": 24
+    },
+    {
+      "date": "2010-09-17",
+      "value": 19,
+      "avg_cvss": 4.8,
+      "cvss_count": 19
+    },
+    {
+      "date": "2010-09-20",
+      "value": 19,
+      "avg_cvss": 4.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2010-09-21",
+      "value": 10,
+      "avg_cvss": 4.7,
+      "cvss_count": 10
+    },
+    {
+      "date": "2010-09-22",
+      "value": 16,
+      "avg_cvss": 6.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2010-09-23",
+      "value": 12,
+      "avg_cvss": 7.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2010-09-24",
+      "value": 23,
+      "avg_cvss": 6.4,
+      "cvss_count": 23
+    },
+    {
+      "date": "2010-09-28",
+      "value": 6,
+      "avg_cvss": 5.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2010-09-29",
+      "value": 14,
+      "avg_cvss": 4.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2010-09-30",
+      "value": 9,
+      "avg_cvss": 5.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2010-10-04",
+      "value": 6,
+      "avg_cvss": 6.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2010-10-05",
+      "value": 33,
+      "avg_cvss": 6.4,
+      "cvss_count": 33
+    },
+    {
+      "date": "2010-10-06",
+      "value": 28,
+      "avg_cvss": 7.9,
+      "cvss_count": 28
+    },
+    {
+      "date": "2010-10-07",
+      "value": 7,
+      "avg_cvss": 4.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2010-10-08",
+      "value": 11,
+      "avg_cvss": 5.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2010-10-12",
+      "value": 5,
+      "avg_cvss": 6.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2010-10-13",
+      "value": 44,
+      "avg_cvss": 8.3,
+      "cvss_count": 44
+    },
+    {
+      "date": "2010-10-14",
+      "value": 91,
+      "avg_cvss": 5.1,
+      "cvss_count": 91
+    },
+    {
+      "date": "2010-10-18",
+      "value": 13,
+      "avg_cvss": 6.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2010-10-19",
+      "value": 55,
+      "avg_cvss": 7.6,
+      "cvss_count": 55
+    },
+    {
+      "date": "2010-10-20",
+      "value": 32,
+      "avg_cvss": 6.7,
+      "cvss_count": 32
+    },
+    {
+      "date": "2010-10-21",
+      "value": 31,
+      "avg_cvss": 6.9,
+      "cvss_count": 31
+    },
+    {
+      "date": "2010-10-23",
+      "value": 8,
+      "avg_cvss": 5.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2010-10-25",
+      "value": 16,
+      "avg_cvss": 6.6,
+      "cvss_count": 16
+    },
+    {
+      "date": "2010-10-26",
+      "value": 12,
+      "avg_cvss": 6.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2010-10-27",
+      "value": 4,
+      "avg_cvss": 5.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2010-10-28",
+      "value": 25,
+      "avg_cvss": 6.1,
+      "cvss_count": 25
+    },
+    {
+      "date": "2010-10-29",
+      "value": 13,
+      "avg_cvss": 9.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2010-11-02",
+      "value": 18,
+      "avg_cvss": 6.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-11-03",
+      "value": 9,
+      "avg_cvss": 7.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2010-11-04",
+      "value": 4,
+      "avg_cvss": 5.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2010-11-05",
+      "value": 17,
+      "avg_cvss": 6.3,
+      "cvss_count": 17
+    },
+    {
+      "date": "2010-11-06",
+      "value": 20,
+      "avg_cvss": 8.2,
+      "cvss_count": 20
+    },
+    {
+      "date": "2010-11-07",
+      "value": 20,
+      "avg_cvss": 8.3,
+      "cvss_count": 20
+    },
+    {
+      "date": "2010-11-09",
+      "value": 25,
+      "avg_cvss": 5.4,
+      "cvss_count": 25
+    },
+    {
+      "date": "2010-11-10",
+      "value": 15,
+      "avg_cvss": 7.1,
+      "cvss_count": 15
+    },
+    {
+      "date": "2010-11-12",
+      "value": 15,
+      "avg_cvss": 6.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2010-11-15",
+      "value": 18,
+      "avg_cvss": 6.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-11-16",
+      "value": 22,
+      "avg_cvss": 6.4,
+      "cvss_count": 22
+    },
+    {
+      "date": "2010-11-17",
+      "value": 22,
+      "avg_cvss": 6.9,
+      "cvss_count": 22
+    },
+    {
+      "date": "2010-11-22",
+      "value": 34,
+      "avg_cvss": 7.7,
+      "cvss_count": 34
+    },
+    {
+      "date": "2010-11-26",
+      "value": 23,
+      "avg_cvss": 5.9,
+      "cvss_count": 23
+    },
+    {
+      "date": "2010-11-29",
+      "value": 9,
+      "avg_cvss": 2.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2010-11-30",
+      "value": 7,
+      "avg_cvss": 3.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2010-12-01",
+      "value": 16,
+      "avg_cvss": 6.0,
+      "cvss_count": 16
+    },
+    {
+      "date": "2010-12-02",
+      "value": 24,
+      "avg_cvss": 6.6,
+      "cvss_count": 24
+    },
+    {
+      "date": "2010-12-06",
+      "value": 31,
+      "avg_cvss": 6.0,
+      "cvss_count": 31
+    },
+    {
+      "date": "2010-12-07",
+      "value": 26,
+      "avg_cvss": 5.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2010-12-08",
+      "value": 14,
+      "avg_cvss": 5.7,
+      "cvss_count": 14
+    },
+    {
+      "date": "2010-12-09",
+      "value": 20,
+      "avg_cvss": 7.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2010-12-10",
+      "value": 18,
+      "avg_cvss": 7.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2010-12-14",
+      "value": 29,
+      "avg_cvss": 8.8,
+      "cvss_count": 29
+    },
+    {
+      "date": "2010-12-16",
+      "value": 52,
+      "avg_cvss": 6.9,
+      "cvss_count": 52
+    },
+    {
+      "date": "2010-12-17",
+      "value": 12,
+      "avg_cvss": 6.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2010-12-22",
+      "value": 45,
+      "avg_cvss": 6.1,
+      "cvss_count": 45
+    },
+    {
+      "date": "2010-12-23",
+      "value": 10,
+      "avg_cvss": 6.8,
+      "cvss_count": 10
+    },
+    {
+      "date": "2010-12-29",
+      "value": 24,
+      "avg_cvss": 5.9,
+      "cvss_count": 24
+    },
+    {
+      "date": "2010-12-30",
+      "value": 38,
+      "avg_cvss": 5.4,
+      "cvss_count": 38
+    },
+    {
+      "date": "2011-01-03",
+      "value": 16,
+      "avg_cvss": 4.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2011-01-07",
+      "value": 56,
+      "avg_cvss": 6.9,
+      "cvss_count": 56
+    },
+    {
+      "date": "2011-01-10",
+      "value": 8,
+      "avg_cvss": 5.1,
+      "cvss_count": 8
+    },
+    {
+      "date": "2011-01-11",
+      "value": 28,
+      "avg_cvss": 5.4,
+      "cvss_count": 28
+    },
+    {
+      "date": "2011-01-12",
+      "value": 8,
+      "avg_cvss": 6.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2011-01-13",
+      "value": 27,
+      "avg_cvss": 7.8,
+      "cvss_count": 27
+    },
+    {
+      "date": "2011-01-14",
+      "value": 34,
+      "avg_cvss": 6.7,
+      "cvss_count": 34
+    },
+    {
+      "date": "2011-01-18",
+      "value": 19,
+      "avg_cvss": 6.4,
+      "cvss_count": 19
+    },
+    {
+      "date": "2011-01-19",
+      "value": 69,
+      "avg_cvss": 5.4,
+      "cvss_count": 69
+    },
+    {
+      "date": "2011-01-20",
+      "value": 37,
+      "avg_cvss": 6.7,
+      "cvss_count": 37
+    },
+    {
+      "date": "2011-01-22",
+      "value": 8,
+      "avg_cvss": 5.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2011-01-24",
+      "value": 13,
+      "avg_cvss": 5.4,
+      "cvss_count": 13
+    },
+    {
+      "date": "2011-01-25",
+      "value": 17,
+      "avg_cvss": 6.0,
+      "cvss_count": 17
+    },
+    {
+      "date": "2011-01-28",
+      "value": 34,
+      "avg_cvss": 7.0,
+      "cvss_count": 34
+    },
+    {
+      "date": "2011-01-31",
+      "value": 22,
+      "avg_cvss": 6.9,
+      "cvss_count": 22
+    },
+    {
+      "date": "2011-02-01",
+      "value": 12,
+      "avg_cvss": 6.2,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-02-02",
+      "value": 25,
+      "avg_cvss": 6.8,
+      "cvss_count": 25
+    },
+    {
+      "date": "2011-02-03",
+      "value": 12,
+      "avg_cvss": 8.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-02-04",
+      "value": 20,
+      "avg_cvss": 5.9,
+      "cvss_count": 20
+    },
+    {
+      "date": "2011-02-07",
+      "value": 10,
+      "avg_cvss": 7.3,
+      "cvss_count": 10
+    },
+    {
+      "date": "2011-02-08",
+      "value": 21,
+      "avg_cvss": 7.6,
+      "cvss_count": 21
+    },
+    {
+      "date": "2011-02-09",
+      "value": 15,
+      "avg_cvss": 7.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2011-02-10",
+      "value": 95,
+      "avg_cvss": 8.3,
+      "cvss_count": 95
+    },
+    {
+      "date": "2011-02-14",
+      "value": 11,
+      "avg_cvss": 5.1,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-02-15",
+      "value": 7,
+      "avg_cvss": 7.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-02-16",
+      "value": 10,
+      "avg_cvss": 6.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2011-02-17",
+      "value": 26,
+      "avg_cvss": 6.3,
+      "cvss_count": 26
+    },
+    {
+      "date": "2011-02-18",
+      "value": 12,
+      "avg_cvss": 6.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-02-19",
+      "value": 14,
+      "avg_cvss": 6.7,
+      "cvss_count": 14
+    },
+    {
+      "date": "2011-02-21",
+      "value": 18,
+      "avg_cvss": 7.2,
+      "cvss_count": 18
+    },
+    {
+      "date": "2011-02-22",
+      "value": 6,
+      "avg_cvss": 4.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2011-02-23",
+      "value": 17,
+      "avg_cvss": 5.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2011-02-24",
+      "value": 2,
+      "avg_cvss": 6.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2011-02-25",
+      "value": 37,
+      "avg_cvss": 8.2,
+      "cvss_count": 37
+    },
+    {
+      "date": "2011-02-28",
+      "value": 7,
+      "avg_cvss": 4.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-03-01",
+      "value": 34,
+      "avg_cvss": 6.1,
+      "cvss_count": 34
+    },
+    {
+      "date": "2011-03-02",
+      "value": 16,
+      "avg_cvss": 7.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2011-03-03",
+      "value": 62,
+      "avg_cvss": 7.2,
+      "cvss_count": 62
+    },
+    {
+      "date": "2011-03-04",
+      "value": 2,
+      "avg_cvss": 1.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2011-03-07",
+      "value": 7,
+      "avg_cvss": 5.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-03-08",
+      "value": 19,
+      "avg_cvss": 5.1,
+      "cvss_count": 19
+    },
+    {
+      "date": "2011-03-09",
+      "value": 6,
+      "avg_cvss": 8.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2011-03-10",
+      "value": 4,
+      "avg_cvss": 8.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "2011-03-11",
+      "value": 42,
+      "avg_cvss": 6.1,
+      "cvss_count": 42
+    },
+    {
+      "date": "2011-03-14",
+      "value": 7,
+      "avg_cvss": 5.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-03-15",
+      "value": 11,
+      "avg_cvss": 5.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-03-16",
+      "value": 14,
+      "avg_cvss": 6.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2011-03-18",
+      "value": 25,
+      "avg_cvss": 4.7,
+      "cvss_count": 25
+    },
+    {
+      "date": "2011-03-20",
+      "value": 15,
+      "avg_cvss": 4.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2011-03-22",
+      "value": 16,
+      "avg_cvss": 5.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2011-03-23",
+      "value": 28,
+      "avg_cvss": 6.1,
+      "cvss_count": 28
+    },
+    {
+      "date": "2011-03-25",
+      "value": 10,
+      "avg_cvss": 7.4,
+      "cvss_count": 10
+    },
+    {
+      "date": "2011-03-28",
+      "value": 11,
+      "avg_cvss": 6.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-03-29",
+      "value": 8,
+      "avg_cvss": 5.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2011-03-30",
+      "value": 9,
+      "avg_cvss": 5.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2011-03-31",
+      "value": 9,
+      "avg_cvss": 5.1,
+      "cvss_count": 9
+    },
+    {
+      "date": "2011-04-04",
+      "value": 19,
+      "avg_cvss": 6.1,
+      "cvss_count": 19
+    },
+    {
+      "date": "2011-04-05",
+      "value": 12,
+      "avg_cvss": 8.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-04-06",
+      "value": 3,
+      "avg_cvss": 6.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2011-04-07",
+      "value": 6,
+      "avg_cvss": 5.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2011-04-08",
+      "value": 10,
+      "avg_cvss": 5.7,
+      "cvss_count": 10
+    },
+    {
+      "date": "2011-04-10",
+      "value": 30,
+      "avg_cvss": 4.9,
+      "cvss_count": 30
+    },
+    {
+      "date": "2011-04-11",
+      "value": 6,
+      "avg_cvss": 4.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "2011-04-13",
+      "value": 63,
+      "avg_cvss": 7.6,
+      "cvss_count": 63
+    },
+    {
+      "date": "2011-04-14",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2011-04-15",
+      "value": 14,
+      "avg_cvss": 6.3,
+      "cvss_count": 14
+    },
+    {
+      "date": "2011-04-18",
+      "value": 18,
+      "avg_cvss": 5.7,
+      "cvss_count": 18
+    },
+    {
+      "date": "2011-04-19",
+      "value": 5,
+      "avg_cvss": 5.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2011-04-20",
+      "value": 59,
+      "avg_cvss": 4.7,
+      "cvss_count": 59
+    },
+    {
+      "date": "2011-04-21",
+      "value": 18,
+      "avg_cvss": 4.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2011-04-22",
+      "value": 9,
+      "avg_cvss": 5.1,
+      "cvss_count": 9
+    },
+    {
+      "date": "2011-04-27",
+      "value": 26,
+      "avg_cvss": 6.0,
+      "cvss_count": 26
+    },
+    {
+      "date": "2011-04-28",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2011-04-29",
+      "value": 12,
+      "avg_cvss": 5.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-05-03",
+      "value": 65,
+      "avg_cvss": 6.6,
+      "cvss_count": 65
+    },
+    {
+      "date": "2011-05-04",
+      "value": 4,
+      "avg_cvss": 7.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2011-05-05",
+      "value": 12,
+      "avg_cvss": 6.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-05-07",
+      "value": 30,
+      "avg_cvss": 8.6,
+      "cvss_count": 30
+    },
+    {
+      "date": "2011-05-09",
+      "value": 18,
+      "avg_cvss": 5.7,
+      "cvss_count": 18
+    },
+    {
+      "date": "2011-05-10",
+      "value": 13,
+      "avg_cvss": 6.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2011-05-13",
+      "value": 41,
+      "avg_cvss": 7.3,
+      "cvss_count": 41
+    },
+    {
+      "date": "2011-05-16",
+      "value": 15,
+      "avg_cvss": 5.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2011-05-20",
+      "value": 35,
+      "avg_cvss": 6.0,
+      "cvss_count": 35
+    },
+    {
+      "date": "2011-05-23",
+      "value": 7,
+      "avg_cvss": 5.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-05-24",
+      "value": 13,
+      "avg_cvss": 5.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2011-05-26",
+      "value": 14,
+      "avg_cvss": 6.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2011-05-31",
+      "value": 28,
+      "avg_cvss": 7.4,
+      "cvss_count": 28
+    },
+    {
+      "date": "2011-06-02",
+      "value": 18,
+      "avg_cvss": 7.1,
+      "cvss_count": 18
+    },
+    {
+      "date": "2011-06-03",
+      "value": 2,
+      "avg_cvss": 4.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2011-06-06",
+      "value": 23,
+      "avg_cvss": 4.9,
+      "cvss_count": 23
+    },
+    {
+      "date": "2011-06-08",
+      "value": 5,
+      "avg_cvss": 8.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2011-06-09",
+      "value": 36,
+      "avg_cvss": 6.9,
+      "cvss_count": 36
+    },
+    {
+      "date": "2011-06-14",
+      "value": 32,
+      "avg_cvss": 6.8,
+      "cvss_count": 32
+    },
+    {
+      "date": "2011-06-16",
+      "value": 77,
+      "avg_cvss": 8.6,
+      "cvss_count": 77
+    },
+    {
+      "date": "2011-06-21",
+      "value": 14,
+      "avg_cvss": 6.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2011-06-22",
+      "value": 13,
+      "avg_cvss": 4.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2011-06-24",
+      "value": 26,
+      "avg_cvss": 6.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2011-06-29",
+      "value": 15,
+      "avg_cvss": 5.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2011-06-30",
+      "value": 33,
+      "avg_cvss": 6.6,
+      "cvss_count": 33
+    },
+    {
+      "date": "2011-07-01",
+      "value": 39,
+      "avg_cvss": 5.5,
+      "cvss_count": 39
+    },
+    {
+      "date": "2011-07-06",
+      "value": 5,
+      "avg_cvss": 5.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2011-07-07",
+      "value": 12,
+      "avg_cvss": 6.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-07-08",
+      "value": 12,
+      "avg_cvss": 5.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-07-11",
+      "value": 8,
+      "avg_cvss": 6.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "2011-07-13",
+      "value": 21,
+      "avg_cvss": 7.2,
+      "cvss_count": 21
+    },
+    {
+      "date": "2011-07-14",
+      "value": 11,
+      "avg_cvss": 5.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-07-17",
+      "value": 17,
+      "avg_cvss": 6.1,
+      "cvss_count": 17
+    },
+    {
+      "date": "2011-07-18",
+      "value": 8,
+      "avg_cvss": 6.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2011-07-19",
+      "value": 12,
+      "avg_cvss": 6.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-07-20",
+      "value": 46,
+      "avg_cvss": 5.4,
+      "cvss_count": 46
+    },
+    {
+      "date": "2011-07-21",
+      "value": 65,
+      "avg_cvss": 6.9,
+      "cvss_count": 65
+    },
+    {
+      "date": "2011-07-27",
+      "value": 27,
+      "avg_cvss": 5.8,
+      "cvss_count": 27
+    },
+    {
+      "date": "2011-07-28",
+      "value": 13,
+      "avg_cvss": 6.4,
+      "cvss_count": 13
+    },
+    {
+      "date": "2011-07-29",
+      "value": 11,
+      "avg_cvss": 7.7,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-08-01",
+      "value": 13,
+      "avg_cvss": 5.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2011-08-03",
+      "value": 31,
+      "avg_cvss": 5.8,
+      "cvss_count": 31
+    },
+    {
+      "date": "2011-08-04",
+      "value": 11,
+      "avg_cvss": 8.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-08-05",
+      "value": 9,
+      "avg_cvss": 5.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2011-08-09",
+      "value": 23,
+      "avg_cvss": 5.4,
+      "cvss_count": 23
+    },
+    {
+      "date": "2011-08-10",
+      "value": 47,
+      "avg_cvss": 7.7,
+      "cvss_count": 47
+    },
+    {
+      "date": "2011-08-11",
+      "value": 17,
+      "avg_cvss": 7.4,
+      "cvss_count": 17
+    },
+    {
+      "date": "2011-08-12",
+      "value": 11,
+      "avg_cvss": 6.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-08-15",
+      "value": 13,
+      "avg_cvss": 6.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2011-08-16",
+      "value": 4,
+      "avg_cvss": 8.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2011-08-18",
+      "value": 30,
+      "avg_cvss": 8.7,
+      "cvss_count": 30
+    },
+    {
+      "date": "2011-08-19",
+      "value": 12,
+      "avg_cvss": 5.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-08-23",
+      "value": 13,
+      "avg_cvss": 6.4,
+      "cvss_count": 13
+    },
+    {
+      "date": "2011-08-24",
+      "value": 7,
+      "avg_cvss": 5.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-08-25",
+      "value": 9,
+      "avg_cvss": 6.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2011-08-29",
+      "value": 37,
+      "avg_cvss": 6.5,
+      "cvss_count": 37
+    },
+    {
+      "date": "2011-08-31",
+      "value": 7,
+      "avg_cvss": 5.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-09-02",
+      "value": 19,
+      "avg_cvss": 5.4,
+      "cvss_count": 19
+    },
+    {
+      "date": "2011-09-06",
+      "value": 18,
+      "avg_cvss": 5.9,
+      "cvss_count": 18
+    },
+    {
+      "date": "2011-09-08",
+      "value": 8,
+      "avg_cvss": 5.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2011-09-12",
+      "value": 13,
+      "avg_cvss": 6.4,
+      "cvss_count": 13
+    },
+    {
+      "date": "2011-09-13",
+      "value": 6,
+      "avg_cvss": 4.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2011-09-14",
+      "value": 11,
+      "avg_cvss": 5.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-09-15",
+      "value": 31,
+      "avg_cvss": 8.1,
+      "cvss_count": 31
+    },
+    {
+      "date": "2011-09-16",
+      "value": 20,
+      "avg_cvss": 8.4,
+      "cvss_count": 20
+    },
+    {
+      "date": "2011-09-19",
+      "value": 38,
+      "avg_cvss": 6.3,
+      "cvss_count": 38
+    },
+    {
+      "date": "2011-09-20",
+      "value": 11,
+      "avg_cvss": 5.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-09-21",
+      "value": 8,
+      "avg_cvss": 6.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2011-09-22",
+      "value": 9,
+      "avg_cvss": 7.1,
+      "cvss_count": 9
+    },
+    {
+      "date": "2011-09-23",
+      "value": 68,
+      "avg_cvss": 5.1,
+      "cvss_count": 68
+    },
+    {
+      "date": "2011-09-24",
+      "value": 67,
+      "avg_cvss": 5.0,
+      "cvss_count": 67
+    },
+    {
+      "date": "2011-09-27",
+      "value": 25,
+      "avg_cvss": 5.8,
+      "cvss_count": 25
+    },
+    {
+      "date": "2011-09-28",
+      "value": 16,
+      "avg_cvss": 4.3,
+      "cvss_count": 16
+    },
+    {
+      "date": "2011-09-29",
+      "value": 14,
+      "avg_cvss": 7.3,
+      "cvss_count": 14
+    },
+    {
+      "date": "2011-09-30",
+      "value": 5,
+      "avg_cvss": 6.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2011-10-02",
+      "value": 10,
+      "avg_cvss": 5.9,
+      "cvss_count": 10
+    },
+    {
+      "date": "2011-10-03",
+      "value": 19,
+      "avg_cvss": 7.5,
+      "cvss_count": 19
+    },
+    {
+      "date": "2011-10-04",
+      "value": 18,
+      "avg_cvss": 6.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2011-10-05",
+      "value": 28,
+      "avg_cvss": 6.4,
+      "cvss_count": 28
+    },
+    {
+      "date": "2011-10-06",
+      "value": 13,
+      "avg_cvss": 8.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2011-10-07",
+      "value": 26,
+      "avg_cvss": 6.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2011-10-08",
+      "value": 39,
+      "avg_cvss": 6.7,
+      "cvss_count": 39
+    },
+    {
+      "date": "2011-10-09",
+      "value": 42,
+      "avg_cvss": 7.0,
+      "cvss_count": 42
+    },
+    {
+      "date": "2011-10-10",
+      "value": 10,
+      "avg_cvss": 6.4,
+      "cvss_count": 10
+    },
+    {
+      "date": "2011-10-12",
+      "value": 50,
+      "avg_cvss": 7.7,
+      "cvss_count": 50
+    },
+    {
+      "date": "2011-10-14",
+      "value": 47,
+      "avg_cvss": 5.0,
+      "cvss_count": 47
+    },
+    {
+      "date": "2011-10-16",
+      "value": 2,
+      "avg_cvss": 9.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2011-10-18",
+      "value": 59,
+      "avg_cvss": 4.7,
+      "cvss_count": 59
+    },
+    {
+      "date": "2011-10-19",
+      "value": 32,
+      "avg_cvss": 7.4,
+      "cvss_count": 32
+    },
+    {
+      "date": "2011-10-20",
+      "value": 7,
+      "avg_cvss": 7.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-10-21",
+      "value": 12,
+      "avg_cvss": 6.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-10-22",
+      "value": 6,
+      "avg_cvss": 6.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2011-10-23",
+      "value": 4,
+      "avg_cvss": 3.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2011-10-24",
+      "value": 9,
+      "avg_cvss": 6.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2011-10-25",
+      "value": 18,
+      "avg_cvss": 6.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2011-10-27",
+      "value": 11,
+      "avg_cvss": 6.5,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-10-28",
+      "value": 9,
+      "avg_cvss": 7.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2011-10-29",
+      "value": 3,
+      "avg_cvss": 4.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2011-10-30",
+      "value": 10,
+      "avg_cvss": 6.2,
+      "cvss_count": 10
+    },
+    {
+      "date": "2011-11-01",
+      "value": 45,
+      "avg_cvss": 7.5,
+      "cvss_count": 45
+    },
+    {
+      "date": "2011-11-02",
+      "value": 54,
+      "avg_cvss": 6.8,
+      "cvss_count": 54
+    },
+    {
+      "date": "2011-11-03",
+      "value": 17,
+      "avg_cvss": 5.6,
+      "cvss_count": 17
+    },
+    {
+      "date": "2011-11-04",
+      "value": 12,
+      "avg_cvss": 6.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-11-07",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2011-11-08",
+      "value": 11,
+      "avg_cvss": 8.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-11-09",
+      "value": 16,
+      "avg_cvss": 6.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2011-11-10",
+      "value": 2,
+      "avg_cvss": 5.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2011-11-11",
+      "value": 27,
+      "avg_cvss": 7.7,
+      "cvss_count": 27
+    },
+    {
+      "date": "2011-11-12",
+      "value": 4,
+      "avg_cvss": 5.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2011-11-15",
+      "value": 7,
+      "avg_cvss": 5.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-11-16",
+      "value": 4,
+      "avg_cvss": 5.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2011-11-17",
+      "value": 10,
+      "avg_cvss": 5.1,
+      "cvss_count": 10
+    },
+    {
+      "date": "2011-11-19",
+      "value": 5,
+      "avg_cvss": 5.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2011-11-21",
+      "value": 4,
+      "avg_cvss": 7.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2011-11-22",
+      "value": 9,
+      "avg_cvss": 8.1,
+      "cvss_count": 9
+    },
+    {
+      "date": "2011-11-23",
+      "value": 19,
+      "avg_cvss": 6.2,
+      "cvss_count": 19
+    },
+    {
+      "date": "2011-11-24",
+      "value": 22,
+      "avg_cvss": 9.1,
+      "cvss_count": 22
+    },
+    {
+      "date": "2011-11-26",
+      "value": 3,
+      "avg_cvss": 5.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2011-11-28",
+      "value": 11,
+      "avg_cvss": 4.7,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-11-29",
+      "value": 15,
+      "avg_cvss": 5.6,
+      "cvss_count": 15
+    },
+    {
+      "date": "2011-11-30",
+      "value": 10,
+      "avg_cvss": 5.9,
+      "cvss_count": 10
+    },
+    {
+      "date": "2011-12-01",
+      "value": 6,
+      "avg_cvss": 5.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2011-12-02",
+      "value": 12,
+      "avg_cvss": 6.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2011-12-05",
+      "value": 8,
+      "avg_cvss": 8.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2011-12-06",
+      "value": 7,
+      "avg_cvss": 5.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-12-07",
+      "value": 29,
+      "avg_cvss": 5.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2011-12-08",
+      "value": 22,
+      "avg_cvss": 5.6,
+      "cvss_count": 22
+    },
+    {
+      "date": "2011-12-09",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2011-12-10",
+      "value": 3,
+      "avg_cvss": 5.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2011-12-13",
+      "value": 18,
+      "avg_cvss": 6.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2011-12-14",
+      "value": 37,
+      "avg_cvss": 7.0,
+      "cvss_count": 37
+    },
+    {
+      "date": "2011-12-15",
+      "value": 22,
+      "avg_cvss": 5.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2011-12-16",
+      "value": 59,
+      "avg_cvss": 6.8,
+      "cvss_count": 59
+    },
+    {
+      "date": "2011-12-17",
+      "value": 7,
+      "avg_cvss": 7.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-12-20",
+      "value": 4,
+      "avg_cvss": 6.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2011-12-21",
+      "value": 7,
+      "avg_cvss": 7.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-12-22",
+      "value": 7,
+      "avg_cvss": 5.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2011-12-23",
+      "value": 11,
+      "avg_cvss": 6.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2011-12-24",
+      "value": 8,
+      "avg_cvss": 6.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "2011-12-25",
+      "value": 16,
+      "avg_cvss": 8.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2011-12-27",
+      "value": 14,
+      "avg_cvss": 6.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2011-12-29",
+      "value": 17,
+      "avg_cvss": 5.8,
+      "cvss_count": 17
+    },
+    {
+      "date": "2011-12-30",
+      "value": 22,
+      "avg_cvss": 6.2,
+      "cvss_count": 22
+    },
+    {
+      "date": "2011-12-31",
+      "value": 3,
+      "avg_cvss": 6.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-01-02",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-01-03",
+      "value": 7,
+      "avg_cvss": 5.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2012-01-04",
+      "value": 10,
+      "avg_cvss": 5.3,
+      "cvss_count": 10
+    },
+    {
+      "date": "2012-01-05",
+      "value": 3,
+      "avg_cvss": 4.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-01-06",
+      "value": 11,
+      "avg_cvss": 5.2,
+      "cvss_count": 11
+    },
+    {
+      "date": "2012-01-07",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-01-08",
+      "value": 18,
+      "avg_cvss": 6.0,
+      "cvss_count": 18
+    },
+    {
+      "date": "2012-01-10",
+      "value": 14,
+      "avg_cvss": 8.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2012-01-12",
+      "value": 3,
+      "avg_cvss": 9.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-01-13",
+      "value": 14,
+      "avg_cvss": 5.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2012-01-14",
+      "value": 7,
+      "avg_cvss": 5.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2012-01-15",
+      "value": 7,
+      "avg_cvss": 6.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2012-01-17",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2012-01-18",
+      "value": 80,
+      "avg_cvss": 4.3,
+      "cvss_count": 80
+    },
+    {
+      "date": "2012-01-19",
+      "value": 16,
+      "avg_cvss": 6.9,
+      "cvss_count": 16
+    },
+    {
+      "date": "2012-01-20",
+      "value": 14,
+      "avg_cvss": 5.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2012-01-23",
+      "value": 1,
+      "avg_cvss": 9.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2012-01-24",
+      "value": 23,
+      "avg_cvss": 6.2,
+      "cvss_count": 23
+    },
+    {
+      "date": "2012-01-25",
+      "value": 23,
+      "avg_cvss": 6.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2012-01-26",
+      "value": 4,
+      "avg_cvss": 4.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-01-27",
+      "value": 20,
+      "avg_cvss": 5.7,
+      "cvss_count": 20
+    },
+    {
+      "date": "2012-01-28",
+      "value": 5,
+      "avg_cvss": 6.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-01-29",
+      "value": 20,
+      "avg_cvss": 5.7,
+      "cvss_count": 20
+    },
+    {
+      "date": "2012-01-30",
+      "value": 5,
+      "avg_cvss": 5.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-02-01",
+      "value": 11,
+      "avg_cvss": 7.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2012-02-02",
+      "value": 34,
+      "avg_cvss": 6.3,
+      "cvss_count": 34
+    },
+    {
+      "date": "2012-02-03",
+      "value": 14,
+      "avg_cvss": 8.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2012-02-05",
+      "value": 1,
+      "avg_cvss": 2.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2012-02-06",
+      "value": 5,
+      "avg_cvss": 7.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-02-07",
+      "value": 9,
+      "avg_cvss": 5.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2012-02-08",
+      "value": 31,
+      "avg_cvss": 6.5,
+      "cvss_count": 31
+    },
+    {
+      "date": "2012-02-09",
+      "value": 20,
+      "avg_cvss": 6.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2012-02-10",
+      "value": 7,
+      "avg_cvss": 6.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2012-02-11",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2012-02-12",
+      "value": 4,
+      "avg_cvss": 4.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-02-13",
+      "value": 5,
+      "avg_cvss": 5.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-02-14",
+      "value": 59,
+      "avg_cvss": 6.1,
+      "cvss_count": 59
+    },
+    {
+      "date": "2012-02-15",
+      "value": 22,
+      "avg_cvss": 8.7,
+      "cvss_count": 22
+    },
+    {
+      "date": "2012-02-16",
+      "value": 21,
+      "avg_cvss": 7.1,
+      "cvss_count": 21
+    },
+    {
+      "date": "2012-02-17",
+      "value": 7,
+      "avg_cvss": 5.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2012-02-18",
+      "value": 11,
+      "avg_cvss": 6.2,
+      "cvss_count": 11
+    },
+    {
+      "date": "2012-02-21",
+      "value": 45,
+      "avg_cvss": 6.8,
+      "cvss_count": 45
+    },
+    {
+      "date": "2012-02-22",
+      "value": 4,
+      "avg_cvss": 7.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-02-23",
+      "value": 10,
+      "avg_cvss": 5.7,
+      "cvss_count": 10
+    },
+    {
+      "date": "2012-02-24",
+      "value": 14,
+      "avg_cvss": 5.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2012-02-25",
+      "value": 4,
+      "avg_cvss": 7.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-02-29",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-03-01",
+      "value": 11,
+      "avg_cvss": 7.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2012-03-02",
+      "value": 8,
+      "avg_cvss": 6.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2012-03-03",
+      "value": 6,
+      "avg_cvss": 5.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-03-05",
+      "value": 17,
+      "avg_cvss": 6.6,
+      "cvss_count": 17
+    },
+    {
+      "date": "2012-03-06",
+      "value": 3,
+      "avg_cvss": 8.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-03-07",
+      "value": 28,
+      "avg_cvss": 10.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2012-03-08",
+      "value": 74,
+      "avg_cvss": 8.4,
+      "cvss_count": 74
+    },
+    {
+      "date": "2012-03-09",
+      "value": 6,
+      "avg_cvss": 6.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-03-10",
+      "value": 1,
+      "avg_cvss": 9.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2012-03-12",
+      "value": 5,
+      "avg_cvss": 5.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-03-13",
+      "value": 26,
+      "avg_cvss": 5.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2012-03-14",
+      "value": 25,
+      "avg_cvss": 8.4,
+      "cvss_count": 25
+    },
+    {
+      "date": "2012-03-15",
+      "value": 19,
+      "avg_cvss": 8.1,
+      "cvss_count": 19
+    },
+    {
+      "date": "2012-03-16",
+      "value": 7,
+      "avg_cvss": 5.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2012-03-17",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2012-03-18",
+      "value": 2,
+      "avg_cvss": 9.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2012-03-19",
+      "value": 33,
+      "avg_cvss": 5.6,
+      "cvss_count": 33
+    },
+    {
+      "date": "2012-03-20",
+      "value": 12,
+      "avg_cvss": 6.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2012-03-21",
+      "value": 45,
+      "avg_cvss": 4.3,
+      "cvss_count": 45
+    },
+    {
+      "date": "2012-03-22",
+      "value": 22,
+      "avg_cvss": 6.3,
+      "cvss_count": 22
+    },
+    {
+      "date": "2012-03-23",
+      "value": 3,
+      "avg_cvss": 4.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-03-26",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-03-27",
+      "value": 5,
+      "avg_cvss": 5.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-03-28",
+      "value": 17,
+      "avg_cvss": 6.0,
+      "cvss_count": 17
+    },
+    {
+      "date": "2012-03-29",
+      "value": 13,
+      "avg_cvss": 7.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2012-03-30",
+      "value": 8,
+      "avg_cvss": 6.1,
+      "cvss_count": 8
+    },
+    {
+      "date": "2012-03-31",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2012-04-02",
+      "value": 11,
+      "avg_cvss": 6.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2012-04-03",
+      "value": 5,
+      "avg_cvss": 7.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-04-05",
+      "value": 33,
+      "avg_cvss": 6.3,
+      "cvss_count": 33
+    },
+    {
+      "date": "2012-04-06",
+      "value": 6,
+      "avg_cvss": 7.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-04-09",
+      "value": 5,
+      "avg_cvss": 6.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-04-10",
+      "value": 16,
+      "avg_cvss": 8.6,
+      "cvss_count": 16
+    },
+    {
+      "date": "2012-04-11",
+      "value": 21,
+      "avg_cvss": 5.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2012-04-12",
+      "value": 4,
+      "avg_cvss": 5.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-04-13",
+      "value": 15,
+      "avg_cvss": 6.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2012-04-16",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2012-04-17",
+      "value": 11,
+      "avg_cvss": 5.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2012-04-18",
+      "value": 14,
+      "avg_cvss": 6.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2012-04-19",
+      "value": 3,
+      "avg_cvss": 5.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-04-20",
+      "value": 8,
+      "avg_cvss": 5.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2012-04-21",
+      "value": 6,
+      "avg_cvss": 6.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-04-22",
+      "value": 11,
+      "avg_cvss": 5.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2012-04-24",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2012-04-25",
+      "value": 39,
+      "avg_cvss": 7.1,
+      "cvss_count": 39
+    },
+    {
+      "date": "2012-04-27",
+      "value": 6,
+      "avg_cvss": 5.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-04-28",
+      "value": 6,
+      "avg_cvss": 7.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-04-30",
+      "value": 5,
+      "avg_cvss": 5.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-05-01",
+      "value": 9,
+      "avg_cvss": 7.3,
+      "cvss_count": 9
+    },
+    {
+      "date": "2012-05-02",
+      "value": 31,
+      "avg_cvss": 5.9,
+      "cvss_count": 31
+    },
+    {
+      "date": "2012-05-03",
+      "value": 111,
+      "avg_cvss": 5.2,
+      "cvss_count": 111
+    },
+    {
+      "date": "2012-05-04",
+      "value": 8,
+      "avg_cvss": 8.9,
+      "cvss_count": 8
+    },
+    {
+      "date": "2012-05-08",
+      "value": 3,
+      "avg_cvss": 6.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-05-09",
+      "value": 42,
+      "avg_cvss": 8.7,
+      "cvss_count": 42
+    },
+    {
+      "date": "2012-05-11",
+      "value": 19,
+      "avg_cvss": 6.2,
+      "cvss_count": 19
+    },
+    {
+      "date": "2012-05-14",
+      "value": 5,
+      "avg_cvss": 7.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-05-15",
+      "value": 9,
+      "avg_cvss": 5.1,
+      "cvss_count": 9
+    },
+    {
+      "date": "2012-05-16",
+      "value": 30,
+      "avg_cvss": 8.3,
+      "cvss_count": 30
+    },
+    {
+      "date": "2012-05-17",
+      "value": 21,
+      "avg_cvss": 5.9,
+      "cvss_count": 21
+    },
+    {
+      "date": "2012-05-18",
+      "value": 12,
+      "avg_cvss": 7.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2012-05-21",
+      "value": 43,
+      "avg_cvss": 5.5,
+      "cvss_count": 43
+    },
+    {
+      "date": "2012-05-22",
+      "value": 7,
+      "avg_cvss": 5.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2012-05-23",
+      "value": 5,
+      "avg_cvss": 7.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-05-24",
+      "value": 33,
+      "avg_cvss": 6.8,
+      "cvss_count": 33
+    },
+    {
+      "date": "2012-05-25",
+      "value": 8,
+      "avg_cvss": 8.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2012-05-27",
+      "value": 14,
+      "avg_cvss": 4.7,
+      "cvss_count": 14
+    },
+    {
+      "date": "2012-05-29",
+      "value": 11,
+      "avg_cvss": 5.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2012-05-30",
+      "value": 1,
+      "avg_cvss": 6.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2012-05-31",
+      "value": 3,
+      "avg_cvss": 6.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-06-01",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-06-02",
+      "value": 2,
+      "avg_cvss": 3.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2012-06-04",
+      "value": 22,
+      "avg_cvss": 5.7,
+      "cvss_count": 22
+    },
+    {
+      "date": "2012-06-05",
+      "value": 26,
+      "avg_cvss": 7.3,
+      "cvss_count": 26
+    },
+    {
+      "date": "2012-06-07",
+      "value": 17,
+      "avg_cvss": 6.6,
+      "cvss_count": 17
+    },
+    {
+      "date": "2012-06-08",
+      "value": 12,
+      "avg_cvss": 5.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2012-06-09",
+      "value": 12,
+      "avg_cvss": 7.2,
+      "cvss_count": 12
+    },
+    {
+      "date": "2012-06-11",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2012-06-12",
+      "value": 24,
+      "avg_cvss": 7.8,
+      "cvss_count": 24
+    },
+    {
+      "date": "2012-06-13",
+      "value": 32,
+      "avg_cvss": 4.6,
+      "cvss_count": 32
+    },
+    {
+      "date": "2012-06-14",
+      "value": 16,
+      "avg_cvss": 6.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2012-06-15",
+      "value": 6,
+      "avg_cvss": 3.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-06-16",
+      "value": 30,
+      "avg_cvss": 7.4,
+      "cvss_count": 30
+    },
+    {
+      "date": "2012-06-17",
+      "value": 13,
+      "avg_cvss": 6.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2012-06-18",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2012-06-19",
+      "value": 14,
+      "avg_cvss": 5.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2012-06-20",
+      "value": 20,
+      "avg_cvss": 5.5,
+      "cvss_count": 20
+    },
+    {
+      "date": "2012-06-21",
+      "value": 37,
+      "avg_cvss": 5.4,
+      "cvss_count": 37
+    },
+    {
+      "date": "2012-06-22",
+      "value": 11,
+      "avg_cvss": 6.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2012-06-25",
+      "value": 7,
+      "avg_cvss": 5.8,
+      "cvss_count": 7
+    },
+    {
+      "date": "2012-06-26",
+      "value": 3,
+      "avg_cvss": 5.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-06-27",
+      "value": 63,
+      "avg_cvss": 5.5,
+      "cvss_count": 63
+    },
+    {
+      "date": "2012-06-29",
+      "value": 26,
+      "avg_cvss": 5.9,
+      "cvss_count": 26
+    },
+    {
+      "date": "2012-06-30",
+      "value": 6,
+      "avg_cvss": 4.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-07-03",
+      "value": 45,
+      "avg_cvss": 4.8,
+      "cvss_count": 45
+    },
+    {
+      "date": "2012-07-05",
+      "value": 20,
+      "avg_cvss": 6.6,
+      "cvss_count": 20
+    },
+    {
+      "date": "2012-07-07",
+      "value": 5,
+      "avg_cvss": 5.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-07-09",
+      "value": 10,
+      "avg_cvss": 6.1,
+      "cvss_count": 10
+    },
+    {
+      "date": "2012-07-10",
+      "value": 14,
+      "avg_cvss": 6.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2012-07-11",
+      "value": 16,
+      "avg_cvss": 5.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2012-07-12",
+      "value": 34,
+      "avg_cvss": 6.8,
+      "cvss_count": 34
+    },
+    {
+      "date": "2012-07-13",
+      "value": 12,
+      "avg_cvss": 6.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2012-07-16",
+      "value": 28,
+      "avg_cvss": 5.3,
+      "cvss_count": 28
+    },
+    {
+      "date": "2012-07-17",
+      "value": 99,
+      "avg_cvss": 4.5,
+      "cvss_count": 99
+    },
+    {
+      "date": "2012-07-18",
+      "value": 29,
+      "avg_cvss": 7.0,
+      "cvss_count": 29
+    },
+    {
+      "date": "2012-07-19",
+      "value": 4,
+      "avg_cvss": 8.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-07-20",
+      "value": 17,
+      "avg_cvss": 5.4,
+      "cvss_count": 17
+    },
+    {
+      "date": "2012-07-21",
+      "value": 15,
+      "avg_cvss": 4.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2012-07-22",
+      "value": 18,
+      "avg_cvss": 5.2,
+      "cvss_count": 18
+    },
+    {
+      "date": "2012-07-23",
+      "value": 19,
+      "avg_cvss": 5.4,
+      "cvss_count": 19
+    },
+    {
+      "date": "2012-07-24",
+      "value": 3,
+      "avg_cvss": 5.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-07-25",
+      "value": 113,
+      "avg_cvss": 7.6,
+      "cvss_count": 113
+    },
+    {
+      "date": "2012-07-26",
+      "value": 16,
+      "avg_cvss": 5.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2012-07-27",
+      "value": 2,
+      "avg_cvss": 4.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2012-07-30",
+      "value": 5,
+      "avg_cvss": 5.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-07-31",
+      "value": 12,
+      "avg_cvss": 5.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2012-08-06",
+      "value": 63,
+      "avg_cvss": 5.6,
+      "cvss_count": 63
+    },
+    {
+      "date": "2012-08-07",
+      "value": 20,
+      "avg_cvss": 5.0,
+      "cvss_count": 20
+    },
+    {
+      "date": "2012-08-08",
+      "value": 12,
+      "avg_cvss": 5.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2012-08-09",
+      "value": 6,
+      "avg_cvss": 6.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-08-10",
+      "value": 7,
+      "avg_cvss": 5.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2012-08-12",
+      "value": 35,
+      "avg_cvss": 5.9,
+      "cvss_count": 35
+    },
+    {
+      "date": "2012-08-13",
+      "value": 56,
+      "avg_cvss": 5.3,
+      "cvss_count": 56
+    },
+    {
+      "date": "2012-08-14",
+      "value": 38,
+      "avg_cvss": 5.5,
+      "cvss_count": 38
+    },
+    {
+      "date": "2012-08-15",
+      "value": 52,
+      "avg_cvss": 8.4,
+      "cvss_count": 52
+    },
+    {
+      "date": "2012-08-16",
+      "value": 23,
+      "avg_cvss": 4.6,
+      "cvss_count": 23
+    },
+    {
+      "date": "2012-08-17",
+      "value": 20,
+      "avg_cvss": 4.6,
+      "cvss_count": 20
+    },
+    {
+      "date": "2012-08-19",
+      "value": 7,
+      "avg_cvss": 8.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2012-08-20",
+      "value": 37,
+      "avg_cvss": 5.7,
+      "cvss_count": 37
+    },
+    {
+      "date": "2012-08-21",
+      "value": 17,
+      "avg_cvss": 6.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2012-08-22",
+      "value": 35,
+      "avg_cvss": 5.3,
+      "cvss_count": 35
+    },
+    {
+      "date": "2012-08-23",
+      "value": 30,
+      "avg_cvss": 5.4,
+      "cvss_count": 30
+    },
+    {
+      "date": "2012-08-24",
+      "value": 4,
+      "avg_cvss": 6.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-08-25",
+      "value": 55,
+      "avg_cvss": 6.1,
+      "cvss_count": 55
+    },
+    {
+      "date": "2012-08-26",
+      "value": 65,
+      "avg_cvss": 5.4,
+      "cvss_count": 65
+    },
+    {
+      "date": "2012-08-27",
+      "value": 19,
+      "avg_cvss": 4.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2012-08-28",
+      "value": 12,
+      "avg_cvss": 5.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2012-08-29",
+      "value": 47,
+      "avg_cvss": 7.7,
+      "cvss_count": 47
+    },
+    {
+      "date": "2012-08-30",
+      "value": 17,
+      "avg_cvss": 6.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "2012-08-31",
+      "value": 58,
+      "avg_cvss": 5.6,
+      "cvss_count": 58
+    },
+    {
+      "date": "2012-09-04",
+      "value": 13,
+      "avg_cvss": 5.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2012-09-05",
+      "value": 40,
+      "avg_cvss": 5.3,
+      "cvss_count": 40
+    },
+    {
+      "date": "2012-09-06",
+      "value": 80,
+      "avg_cvss": 6.4,
+      "cvss_count": 80
+    },
+    {
+      "date": "2012-09-07",
+      "value": 57,
+      "avg_cvss": 7.0,
+      "cvss_count": 57
+    },
+    {
+      "date": "2012-09-08",
+      "value": 8,
+      "avg_cvss": 6.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2012-09-09",
+      "value": 19,
+      "avg_cvss": 5.2,
+      "cvss_count": 19
+    },
+    {
+      "date": "2012-09-10",
+      "value": 44,
+      "avg_cvss": 8.3,
+      "cvss_count": 44
+    },
+    {
+      "date": "2012-09-11",
+      "value": 8,
+      "avg_cvss": 5.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2012-09-12",
+      "value": 8,
+      "avg_cvss": 7.1,
+      "cvss_count": 8
+    },
+    {
+      "date": "2012-09-13",
+      "value": 58,
+      "avg_cvss": 6.9,
+      "cvss_count": 58
+    },
+    {
+      "date": "2012-09-14",
+      "value": 11,
+      "avg_cvss": 5.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2012-09-15",
+      "value": 29,
+      "avg_cvss": 6.6,
+      "cvss_count": 29
+    },
+    {
+      "date": "2012-09-16",
+      "value": 16,
+      "avg_cvss": 5.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2012-09-17",
+      "value": 21,
+      "avg_cvss": 5.6,
+      "cvss_count": 21
+    },
+    {
+      "date": "2012-09-18",
+      "value": 24,
+      "avg_cvss": 5.3,
+      "cvss_count": 24
+    },
+    {
+      "date": "2012-09-19",
+      "value": 35,
+      "avg_cvss": 5.8,
+      "cvss_count": 35
+    },
+    {
+      "date": "2012-09-20",
+      "value": 60,
+      "avg_cvss": 4.4,
+      "cvss_count": 60
+    },
+    {
+      "date": "2012-09-21",
+      "value": 5,
+      "avg_cvss": 8.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-09-23",
+      "value": 19,
+      "avg_cvss": 5.5,
+      "cvss_count": 19
+    },
+    {
+      "date": "2012-09-24",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-09-25",
+      "value": 30,
+      "avg_cvss": 6.7,
+      "cvss_count": 30
+    },
+    {
+      "date": "2012-09-26",
+      "value": 31,
+      "avg_cvss": 6.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2012-09-27",
+      "value": 9,
+      "avg_cvss": 7.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2012-09-28",
+      "value": 27,
+      "avg_cvss": 6.3,
+      "cvss_count": 27
+    },
+    {
+      "date": "2012-10-01",
+      "value": 49,
+      "avg_cvss": 5.2,
+      "cvss_count": 49
+    },
+    {
+      "date": "2012-10-02",
+      "value": 4,
+      "avg_cvss": 6.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-10-03",
+      "value": 11,
+      "avg_cvss": 5.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2012-10-04",
+      "value": 26,
+      "avg_cvss": 5.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2012-10-05",
+      "value": 12,
+      "avg_cvss": 6.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2012-10-06",
+      "value": 14,
+      "avg_cvss": 5.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2012-10-07",
+      "value": 10,
+      "avg_cvss": 4.9,
+      "cvss_count": 10
+    },
+    {
+      "date": "2012-10-08",
+      "value": 50,
+      "avg_cvss": 5.9,
+      "cvss_count": 50
+    },
+    {
+      "date": "2012-10-09",
+      "value": 63,
+      "avg_cvss": 7.5,
+      "cvss_count": 63
+    },
+    {
+      "date": "2012-10-10",
+      "value": 40,
+      "avg_cvss": 6.7,
+      "cvss_count": 40
+    },
+    {
+      "date": "2012-10-11",
+      "value": 12,
+      "avg_cvss": 6.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2012-10-12",
+      "value": 5,
+      "avg_cvss": 7.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-10-16",
+      "value": 67,
+      "avg_cvss": 5.4,
+      "cvss_count": 67
+    },
+    {
+      "date": "2012-10-17",
+      "value": 67,
+      "avg_cvss": 4.4,
+      "cvss_count": 67
+    },
+    {
+      "date": "2012-10-18",
+      "value": 3,
+      "avg_cvss": 6.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-10-20",
+      "value": 6,
+      "avg_cvss": 7.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-10-22",
+      "value": 33,
+      "avg_cvss": 5.6,
+      "cvss_count": 33
+    },
+    {
+      "date": "2012-10-23",
+      "value": 6,
+      "avg_cvss": 10.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-10-24",
+      "value": 4,
+      "avg_cvss": 5.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-10-25",
+      "value": 31,
+      "avg_cvss": 6.8,
+      "cvss_count": 31
+    },
+    {
+      "date": "2012-10-26",
+      "value": 4,
+      "avg_cvss": 6.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-10-28",
+      "value": 1,
+      "avg_cvss": 6.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2012-10-29",
+      "value": 9,
+      "avg_cvss": 6.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2012-10-30",
+      "value": 1,
+      "avg_cvss": 9.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2012-10-31",
+      "value": 25,
+      "avg_cvss": 4.5,
+      "cvss_count": 25
+    },
+    {
+      "date": "2012-11-01",
+      "value": 7,
+      "avg_cvss": 7.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2012-11-02",
+      "value": 8,
+      "avg_cvss": 5.9,
+      "cvss_count": 8
+    },
+    {
+      "date": "2012-11-03",
+      "value": 3,
+      "avg_cvss": 4.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-11-04",
+      "value": 49,
+      "avg_cvss": 6.0,
+      "cvss_count": 49
+    },
+    {
+      "date": "2012-11-06",
+      "value": 8,
+      "avg_cvss": 5.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "2012-11-07",
+      "value": 24,
+      "avg_cvss": 8.1,
+      "cvss_count": 24
+    },
+    {
+      "date": "2012-11-08",
+      "value": 6,
+      "avg_cvss": 5.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-11-09",
+      "value": 9,
+      "avg_cvss": 9.3,
+      "cvss_count": 9
+    },
+    {
+      "date": "2012-11-10",
+      "value": 1,
+      "avg_cvss": 6.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2012-11-11",
+      "value": 19,
+      "avg_cvss": 6.1,
+      "cvss_count": 19
+    },
+    {
+      "date": "2012-11-13",
+      "value": 8,
+      "avg_cvss": 8.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2012-11-14",
+      "value": 31,
+      "avg_cvss": 7.4,
+      "cvss_count": 31
+    },
+    {
+      "date": "2012-11-15",
+      "value": 4,
+      "avg_cvss": 4.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-11-16",
+      "value": 15,
+      "avg_cvss": 5.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2012-11-17",
+      "value": 34,
+      "avg_cvss": 5.6,
+      "cvss_count": 34
+    },
+    {
+      "date": "2012-11-18",
+      "value": 21,
+      "avg_cvss": 6.6,
+      "cvss_count": 21
+    },
+    {
+      "date": "2012-11-19",
+      "value": 11,
+      "avg_cvss": 5.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2012-11-20",
+      "value": 12,
+      "avg_cvss": 5.2,
+      "cvss_count": 12
+    },
+    {
+      "date": "2012-11-21",
+      "value": 45,
+      "avg_cvss": 7.0,
+      "cvss_count": 45
+    },
+    {
+      "date": "2012-11-22",
+      "value": 2,
+      "avg_cvss": 4.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2012-11-23",
+      "value": 36,
+      "avg_cvss": 6.0,
+      "cvss_count": 36
+    },
+    {
+      "date": "2012-11-24",
+      "value": 13,
+      "avg_cvss": 5.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2012-11-26",
+      "value": 18,
+      "avg_cvss": 5.9,
+      "cvss_count": 18
+    },
+    {
+      "date": "2012-11-27",
+      "value": 9,
+      "avg_cvss": 5.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2012-11-28",
+      "value": 14,
+      "avg_cvss": 6.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2012-11-29",
+      "value": 3,
+      "avg_cvss": 5.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-11-30",
+      "value": 26,
+      "avg_cvss": 5.6,
+      "cvss_count": 26
+    },
+    {
+      "date": "2012-12-03",
+      "value": 38,
+      "avg_cvss": 4.7,
+      "cvss_count": 38
+    },
+    {
+      "date": "2012-12-04",
+      "value": 6,
+      "avg_cvss": 9.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2012-12-05",
+      "value": 24,
+      "avg_cvss": 4.9,
+      "cvss_count": 24
+    },
+    {
+      "date": "2012-12-06",
+      "value": 7,
+      "avg_cvss": 6.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2012-12-08",
+      "value": 5,
+      "avg_cvss": 6.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-12-10",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2012-12-11",
+      "value": 4,
+      "avg_cvss": 5.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-12-12",
+      "value": 26,
+      "avg_cvss": 8.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2012-12-13",
+      "value": 15,
+      "avg_cvss": 5.3,
+      "cvss_count": 15
+    },
+    {
+      "date": "2012-12-18",
+      "value": 18,
+      "avg_cvss": 5.9,
+      "cvss_count": 18
+    },
+    {
+      "date": "2012-12-19",
+      "value": 18,
+      "avg_cvss": 5.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2012-12-20",
+      "value": 10,
+      "avg_cvss": 6.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2012-12-21",
+      "value": 20,
+      "avg_cvss": 5.6,
+      "cvss_count": 20
+    },
+    {
+      "date": "2012-12-23",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2012-12-24",
+      "value": 5,
+      "avg_cvss": 7.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-12-25",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2012-12-26",
+      "value": 24,
+      "avg_cvss": 4.8,
+      "cvss_count": 24
+    },
+    {
+      "date": "2012-12-27",
+      "value": 5,
+      "avg_cvss": 4.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2012-12-28",
+      "value": 10,
+      "avg_cvss": 5.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2012-12-30",
+      "value": 1,
+      "avg_cvss": 8.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2012-12-31",
+      "value": 10,
+      "avg_cvss": 4.5,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-01-01",
+      "value": 6,
+      "avg_cvss": 5.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2013-01-02",
+      "value": 14,
+      "avg_cvss": 5.7,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-01-03",
+      "value": 16,
+      "avg_cvss": 5.6,
+      "cvss_count": 16
+    },
+    {
+      "date": "2013-01-04",
+      "value": 22,
+      "avg_cvss": 4.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2013-01-05",
+      "value": 4,
+      "avg_cvss": 6.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-01-08",
+      "value": 1,
+      "avg_cvss": 6.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-01-09",
+      "value": 15,
+      "avg_cvss": 7.6,
+      "cvss_count": 15
+    },
+    {
+      "date": "2013-01-10",
+      "value": 28,
+      "avg_cvss": 9.9,
+      "cvss_count": 28
+    },
+    {
+      "date": "2013-01-11",
+      "value": 8,
+      "avg_cvss": 7.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2013-01-12",
+      "value": 8,
+      "avg_cvss": 5.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2013-01-13",
+      "value": 29,
+      "avg_cvss": 8.6,
+      "cvss_count": 29
+    },
+    {
+      "date": "2013-01-14",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-01-15",
+      "value": 24,
+      "avg_cvss": 6.6,
+      "cvss_count": 24
+    },
+    {
+      "date": "2013-01-17",
+      "value": 93,
+      "avg_cvss": 5.1,
+      "cvss_count": 93
+    },
+    {
+      "date": "2013-01-18",
+      "value": 11,
+      "avg_cvss": 5.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2013-01-19",
+      "value": 4,
+      "avg_cvss": 5.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-01-21",
+      "value": 10,
+      "avg_cvss": 7.8,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-01-22",
+      "value": 10,
+      "avg_cvss": 4.7,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-01-23",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-01-24",
+      "value": 44,
+      "avg_cvss": 6.4,
+      "cvss_count": 44
+    },
+    {
+      "date": "2013-01-25",
+      "value": 3,
+      "avg_cvss": 7.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2013-01-26",
+      "value": 5,
+      "avg_cvss": 6.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-01-27",
+      "value": 20,
+      "avg_cvss": 5.6,
+      "cvss_count": 20
+    },
+    {
+      "date": "2013-01-28",
+      "value": 1,
+      "avg_cvss": 6.9,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-01-29",
+      "value": 18,
+      "avg_cvss": 5.7,
+      "cvss_count": 18
+    },
+    {
+      "date": "2013-01-30",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-01-31",
+      "value": 42,
+      "avg_cvss": 6.8,
+      "cvss_count": 42
+    },
+    {
+      "date": "2013-02-01",
+      "value": 1,
+      "avg_cvss": 3.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-02-02",
+      "value": 51,
+      "avg_cvss": 8.1,
+      "cvss_count": 51
+    },
+    {
+      "date": "2013-02-03",
+      "value": 19,
+      "avg_cvss": 2.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2013-02-04",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-02-05",
+      "value": 10,
+      "avg_cvss": 4.8,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-02-06",
+      "value": 15,
+      "avg_cvss": 6.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2013-02-07",
+      "value": 2,
+      "avg_cvss": 4.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2013-02-08",
+      "value": 21,
+      "avg_cvss": 6.0,
+      "cvss_count": 21
+    },
+    {
+      "date": "2013-02-11",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-02-12",
+      "value": 27,
+      "avg_cvss": 7.9,
+      "cvss_count": 27
+    },
+    {
+      "date": "2013-02-13",
+      "value": 79,
+      "avg_cvss": 6.5,
+      "cvss_count": 79
+    },
+    {
+      "date": "2013-02-14",
+      "value": 9,
+      "avg_cvss": 6.1,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-02-15",
+      "value": 11,
+      "avg_cvss": 7.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2013-02-16",
+      "value": 7,
+      "avg_cvss": 5.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2013-02-18",
+      "value": 12,
+      "avg_cvss": 4.7,
+      "cvss_count": 12
+    },
+    {
+      "date": "2013-02-19",
+      "value": 18,
+      "avg_cvss": 7.8,
+      "cvss_count": 18
+    },
+    {
+      "date": "2013-02-20",
+      "value": 22,
+      "avg_cvss": 5.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2013-02-21",
+      "value": 5,
+      "avg_cvss": 4.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-02-22",
+      "value": 10,
+      "avg_cvss": 6.4,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-02-23",
+      "value": 23,
+      "avg_cvss": 6.8,
+      "cvss_count": 23
+    },
+    {
+      "date": "2013-02-24",
+      "value": 34,
+      "avg_cvss": 6.1,
+      "cvss_count": 34
+    },
+    {
+      "date": "2013-02-25",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-02-26",
+      "value": 2,
+      "avg_cvss": 4.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2013-02-27",
+      "value": 14,
+      "avg_cvss": 7.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-02-28",
+      "value": 10,
+      "avg_cvss": 4.9,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-03-01",
+      "value": 19,
+      "avg_cvss": 4.2,
+      "cvss_count": 19
+    },
+    {
+      "date": "2013-03-05",
+      "value": 31,
+      "avg_cvss": 6.5,
+      "cvss_count": 31
+    },
+    {
+      "date": "2013-03-06",
+      "value": 9,
+      "avg_cvss": 4.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-03-07",
+      "value": 22,
+      "avg_cvss": 4.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2013-03-08",
+      "value": 16,
+      "avg_cvss": 6.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2013-03-09",
+      "value": 18,
+      "avg_cvss": 7.7,
+      "cvss_count": 18
+    },
+    {
+      "date": "2013-03-11",
+      "value": 21,
+      "avg_cvss": 7.4,
+      "cvss_count": 21
+    },
+    {
+      "date": "2013-03-12",
+      "value": 20,
+      "avg_cvss": 5.0,
+      "cvss_count": 20
+    },
+    {
+      "date": "2013-03-13",
+      "value": 27,
+      "avg_cvss": 8.1,
+      "cvss_count": 27
+    },
+    {
+      "date": "2013-03-14",
+      "value": 13,
+      "avg_cvss": 6.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2013-03-15",
+      "value": 33,
+      "avg_cvss": 3.8,
+      "cvss_count": 33
+    },
+    {
+      "date": "2013-03-18",
+      "value": 3,
+      "avg_cvss": 8.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2013-03-19",
+      "value": 22,
+      "avg_cvss": 5.4,
+      "cvss_count": 22
+    },
+    {
+      "date": "2013-03-20",
+      "value": 29,
+      "avg_cvss": 6.2,
+      "cvss_count": 29
+    },
+    {
+      "date": "2013-03-21",
+      "value": 27,
+      "avg_cvss": 5.0,
+      "cvss_count": 27
+    },
+    {
+      "date": "2013-03-22",
+      "value": 20,
+      "avg_cvss": 5.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2013-03-25",
+      "value": 8,
+      "avg_cvss": 4.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2013-03-26",
+      "value": 7,
+      "avg_cvss": 5.1,
+      "cvss_count": 7
+    },
+    {
+      "date": "2013-03-27",
+      "value": 37,
+      "avg_cvss": 4.0,
+      "cvss_count": 37
+    },
+    {
+      "date": "2013-03-28",
+      "value": 31,
+      "avg_cvss": 7.0,
+      "cvss_count": 31
+    },
+    {
+      "date": "2013-03-29",
+      "value": 17,
+      "avg_cvss": 6.3,
+      "cvss_count": 17
+    },
+    {
+      "date": "2013-04-01",
+      "value": 8,
+      "avg_cvss": 6.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2013-04-02",
+      "value": 10,
+      "avg_cvss": 5.1,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-04-03",
+      "value": 19,
+      "avg_cvss": 6.7,
+      "cvss_count": 19
+    },
+    {
+      "date": "2013-04-04",
+      "value": 14,
+      "avg_cvss": 6.7,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-04-05",
+      "value": 8,
+      "avg_cvss": 6.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2013-04-07",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2013-04-08",
+      "value": 7,
+      "avg_cvss": 5.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2013-04-09",
+      "value": 31,
+      "avg_cvss": 6.4,
+      "cvss_count": 31
+    },
+    {
+      "date": "2013-04-10",
+      "value": 15,
+      "avg_cvss": 7.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2013-04-11",
+      "value": 16,
+      "avg_cvss": 7.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2013-04-12",
+      "value": 10,
+      "avg_cvss": 6.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-04-13",
+      "value": 2,
+      "avg_cvss": 7.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2013-04-16",
+      "value": 14,
+      "avg_cvss": 6.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-04-17",
+      "value": 152,
+      "avg_cvss": 5.2,
+      "cvss_count": 152
+    },
+    {
+      "date": "2013-04-18",
+      "value": 14,
+      "avg_cvss": 7.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-04-19",
+      "value": 7,
+      "avg_cvss": 6.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2013-04-21",
+      "value": 3,
+      "avg_cvss": 5.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2013-04-22",
+      "value": 22,
+      "avg_cvss": 5.3,
+      "cvss_count": 22
+    },
+    {
+      "date": "2013-04-23",
+      "value": 5,
+      "avg_cvss": 4.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-04-24",
+      "value": 16,
+      "avg_cvss": 4.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2013-04-25",
+      "value": 28,
+      "avg_cvss": 7.7,
+      "cvss_count": 28
+    },
+    {
+      "date": "2013-04-26",
+      "value": 10,
+      "avg_cvss": 6.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-04-27",
+      "value": 4,
+      "avg_cvss": 4.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-04-28",
+      "value": 3,
+      "avg_cvss": 3.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2013-04-29",
+      "value": 15,
+      "avg_cvss": 5.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2013-04-30",
+      "value": 3,
+      "avg_cvss": 9.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2013-05-01",
+      "value": 21,
+      "avg_cvss": 5.8,
+      "cvss_count": 21
+    },
+    {
+      "date": "2013-05-02",
+      "value": 21,
+      "avg_cvss": 5.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2013-05-03",
+      "value": 14,
+      "avg_cvss": 5.3,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-05-04",
+      "value": 3,
+      "avg_cvss": 4.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2013-05-05",
+      "value": 5,
+      "avg_cvss": 7.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-05-07",
+      "value": 3,
+      "avg_cvss": 4.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2013-05-08",
+      "value": 18,
+      "avg_cvss": 5.8,
+      "cvss_count": 18
+    },
+    {
+      "date": "2013-05-09",
+      "value": 14,
+      "avg_cvss": 7.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-05-10",
+      "value": 25,
+      "avg_cvss": 6.3,
+      "cvss_count": 25
+    },
+    {
+      "date": "2013-05-13",
+      "value": 15,
+      "avg_cvss": 4.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2013-05-14",
+      "value": 1,
+      "avg_cvss": 8.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-05-15",
+      "value": 31,
+      "avg_cvss": 8.5,
+      "cvss_count": 31
+    },
+    {
+      "date": "2013-05-16",
+      "value": 58,
+      "avg_cvss": 9.1,
+      "cvss_count": 58
+    },
+    {
+      "date": "2013-05-20",
+      "value": 23,
+      "avg_cvss": 7.8,
+      "cvss_count": 23
+    },
+    {
+      "date": "2013-05-21",
+      "value": 7,
+      "avg_cvss": 4.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2013-05-22",
+      "value": 18,
+      "avg_cvss": 6.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2013-05-23",
+      "value": 17,
+      "avg_cvss": 6.1,
+      "cvss_count": 17
+    },
+    {
+      "date": "2013-05-24",
+      "value": 16,
+      "avg_cvss": 8.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2013-05-25",
+      "value": 13,
+      "avg_cvss": 5.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2013-05-27",
+      "value": 7,
+      "avg_cvss": 4.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2013-05-28",
+      "value": 4,
+      "avg_cvss": 5.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-05-29",
+      "value": 15,
+      "avg_cvss": 5.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2013-05-31",
+      "value": 7,
+      "avg_cvss": 5.8,
+      "cvss_count": 7
+    },
+    {
+      "date": "2013-06-01",
+      "value": 5,
+      "avg_cvss": 5.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-06-03",
+      "value": 6,
+      "avg_cvss": 5.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2013-06-05",
+      "value": 34,
+      "avg_cvss": 6.1,
+      "cvss_count": 34
+    },
+    {
+      "date": "2013-06-06",
+      "value": 15,
+      "avg_cvss": 9.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2013-06-07",
+      "value": 14,
+      "avg_cvss": 4.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-06-08",
+      "value": 12,
+      "avg_cvss": 5.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2013-06-09",
+      "value": 10,
+      "avg_cvss": 5.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-06-10",
+      "value": 10,
+      "avg_cvss": 4.7,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-06-12",
+      "value": 26,
+      "avg_cvss": 8.6,
+      "cvss_count": 26
+    },
+    {
+      "date": "2013-06-13",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-06-14",
+      "value": 14,
+      "avg_cvss": 6.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-06-15",
+      "value": 29,
+      "avg_cvss": 6.8,
+      "cvss_count": 29
+    },
+    {
+      "date": "2013-06-16",
+      "value": 1,
+      "avg_cvss": 7.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-06-17",
+      "value": 21,
+      "avg_cvss": 5.6,
+      "cvss_count": 21
+    },
+    {
+      "date": "2013-06-18",
+      "value": 46,
+      "avg_cvss": 6.9,
+      "cvss_count": 46
+    },
+    {
+      "date": "2013-06-19",
+      "value": 5,
+      "avg_cvss": 5.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-06-20",
+      "value": 15,
+      "avg_cvss": 7.1,
+      "cvss_count": 15
+    },
+    {
+      "date": "2013-06-21",
+      "value": 23,
+      "avg_cvss": 5.2,
+      "cvss_count": 23
+    },
+    {
+      "date": "2013-06-24",
+      "value": 4,
+      "avg_cvss": 4.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-06-25",
+      "value": 9,
+      "avg_cvss": 5.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-06-26",
+      "value": 22,
+      "avg_cvss": 7.1,
+      "cvss_count": 22
+    },
+    {
+      "date": "2013-06-27",
+      "value": 11,
+      "avg_cvss": 6.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2013-06-28",
+      "value": 14,
+      "avg_cvss": 5.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-06-30",
+      "value": 13,
+      "avg_cvss": 7.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2013-07-01",
+      "value": 13,
+      "avg_cvss": 5.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2013-07-02",
+      "value": 10,
+      "avg_cvss": 6.3,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-07-03",
+      "value": 24,
+      "avg_cvss": 5.1,
+      "cvss_count": 24
+    },
+    {
+      "date": "2013-07-04",
+      "value": 11,
+      "avg_cvss": 4.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2013-07-06",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-07-08",
+      "value": 22,
+      "avg_cvss": 5.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2013-07-09",
+      "value": 10,
+      "avg_cvss": 5.7,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-07-10",
+      "value": 71,
+      "avg_cvss": 7.6,
+      "cvss_count": 71
+    },
+    {
+      "date": "2013-07-11",
+      "value": 10,
+      "avg_cvss": 7.4,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-07-12",
+      "value": 8,
+      "avg_cvss": 5.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2013-07-13",
+      "value": 3,
+      "avg_cvss": 6.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2013-07-15",
+      "value": 6,
+      "avg_cvss": 5.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2013-07-16",
+      "value": 13,
+      "avg_cvss": 5.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2013-07-17",
+      "value": 75,
+      "avg_cvss": 5.0,
+      "cvss_count": 75
+    },
+    {
+      "date": "2013-07-18",
+      "value": 29,
+      "avg_cvss": 6.6,
+      "cvss_count": 29
+    },
+    {
+      "date": "2013-07-19",
+      "value": 5,
+      "avg_cvss": 5.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-07-20",
+      "value": 9,
+      "avg_cvss": 6.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-07-22",
+      "value": 14,
+      "avg_cvss": 4.6,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-07-23",
+      "value": 16,
+      "avg_cvss": 7.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2013-07-24",
+      "value": 5,
+      "avg_cvss": 4.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-07-25",
+      "value": 6,
+      "avg_cvss": 6.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2013-07-26",
+      "value": 2,
+      "avg_cvss": 8.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "2013-07-29",
+      "value": 45,
+      "avg_cvss": 5.5,
+      "cvss_count": 45
+    },
+    {
+      "date": "2013-07-30",
+      "value": 17,
+      "avg_cvss": 5.4,
+      "cvss_count": 17
+    },
+    {
+      "date": "2013-07-31",
+      "value": 41,
+      "avg_cvss": 6.1,
+      "cvss_count": 41
+    },
+    {
+      "date": "2013-08-01",
+      "value": 17,
+      "avg_cvss": 6.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2013-08-02",
+      "value": 6,
+      "avg_cvss": 5.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2013-08-05",
+      "value": 12,
+      "avg_cvss": 6.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2013-08-06",
+      "value": 13,
+      "avg_cvss": 6.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2013-08-07",
+      "value": 15,
+      "avg_cvss": 7.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2013-08-08",
+      "value": 2,
+      "avg_cvss": 8.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "2013-08-09",
+      "value": 34,
+      "avg_cvss": 5.9,
+      "cvss_count": 34
+    },
+    {
+      "date": "2013-08-12",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2013-08-13",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2013-08-14",
+      "value": 26,
+      "avg_cvss": 7.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2013-08-15",
+      "value": 6,
+      "avg_cvss": 5.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2013-08-16",
+      "value": 23,
+      "avg_cvss": 5.3,
+      "cvss_count": 23
+    },
+    {
+      "date": "2013-08-17",
+      "value": 2,
+      "avg_cvss": 3.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2013-08-18",
+      "value": 4,
+      "avg_cvss": 6.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-08-19",
+      "value": 23,
+      "avg_cvss": 4.8,
+      "cvss_count": 23
+    },
+    {
+      "date": "2013-08-20",
+      "value": 30,
+      "avg_cvss": 5.3,
+      "cvss_count": 30
+    },
+    {
+      "date": "2013-08-21",
+      "value": 21,
+      "avg_cvss": 5.9,
+      "cvss_count": 21
+    },
+    {
+      "date": "2013-08-22",
+      "value": 6,
+      "avg_cvss": 5.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2013-08-23",
+      "value": 20,
+      "avg_cvss": 5.4,
+      "cvss_count": 20
+    },
+    {
+      "date": "2013-08-24",
+      "value": 1,
+      "avg_cvss": 6.9,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-08-25",
+      "value": 24,
+      "avg_cvss": 6.4,
+      "cvss_count": 24
+    },
+    {
+      "date": "2013-08-27",
+      "value": 9,
+      "avg_cvss": 4.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-08-28",
+      "value": 34,
+      "avg_cvss": 5.7,
+      "cvss_count": 34
+    },
+    {
+      "date": "2013-08-29",
+      "value": 12,
+      "avg_cvss": 6.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2013-08-30",
+      "value": 9,
+      "avg_cvss": 5.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-08-31",
+      "value": 19,
+      "avg_cvss": 7.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2013-09-04",
+      "value": 3,
+      "avg_cvss": 4.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2013-09-05",
+      "value": 17,
+      "avg_cvss": 4.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2013-09-06",
+      "value": 17,
+      "avg_cvss": 6.9,
+      "cvss_count": 17
+    },
+    {
+      "date": "2013-09-08",
+      "value": 9,
+      "avg_cvss": 6.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-09-09",
+      "value": 15,
+      "avg_cvss": 5.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2013-09-10",
+      "value": 14,
+      "avg_cvss": 6.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-09-11",
+      "value": 47,
+      "avg_cvss": 8.2,
+      "cvss_count": 47
+    },
+    {
+      "date": "2013-09-12",
+      "value": 41,
+      "avg_cvss": 7.8,
+      "cvss_count": 41
+    },
+    {
+      "date": "2013-09-13",
+      "value": 6,
+      "avg_cvss": 5.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2013-09-16",
+      "value": 65,
+      "avg_cvss": 5.4,
+      "cvss_count": 65
+    },
+    {
+      "date": "2013-09-17",
+      "value": 12,
+      "avg_cvss": 6.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2013-09-18",
+      "value": 20,
+      "avg_cvss": 7.4,
+      "cvss_count": 20
+    },
+    {
+      "date": "2013-09-19",
+      "value": 43,
+      "avg_cvss": 5.7,
+      "cvss_count": 43
+    },
+    {
+      "date": "2013-09-20",
+      "value": 20,
+      "avg_cvss": 5.8,
+      "cvss_count": 20
+    },
+    {
+      "date": "2013-09-23",
+      "value": 27,
+      "avg_cvss": 5.6,
+      "cvss_count": 27
+    },
+    {
+      "date": "2013-09-24",
+      "value": 9,
+      "avg_cvss": 5.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-09-25",
+      "value": 22,
+      "avg_cvss": 5.2,
+      "cvss_count": 22
+    },
+    {
+      "date": "2013-09-26",
+      "value": 4,
+      "avg_cvss": 4.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-09-27",
+      "value": 16,
+      "avg_cvss": 7.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2013-09-28",
+      "value": 9,
+      "avg_cvss": 5.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-09-30",
+      "value": 38,
+      "avg_cvss": 5.1,
+      "cvss_count": 38
+    },
+    {
+      "date": "2013-10-01",
+      "value": 52,
+      "avg_cvss": 5.3,
+      "cvss_count": 52
+    },
+    {
+      "date": "2013-10-02",
+      "value": 32,
+      "avg_cvss": 6.3,
+      "cvss_count": 32
+    },
+    {
+      "date": "2013-10-03",
+      "value": 27,
+      "avg_cvss": 6.6,
+      "cvss_count": 27
+    },
+    {
+      "date": "2013-10-04",
+      "value": 24,
+      "avg_cvss": 6.1,
+      "cvss_count": 24
+    },
+    {
+      "date": "2013-10-05",
+      "value": 10,
+      "avg_cvss": 6.1,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-10-09",
+      "value": 43,
+      "avg_cvss": 7.5,
+      "cvss_count": 43
+    },
+    {
+      "date": "2013-10-10",
+      "value": 23,
+      "avg_cvss": 6.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2013-10-11",
+      "value": 24,
+      "avg_cvss": 6.5,
+      "cvss_count": 24
+    },
+    {
+      "date": "2013-10-13",
+      "value": 25,
+      "avg_cvss": 7.3,
+      "cvss_count": 25
+    },
+    {
+      "date": "2013-10-14",
+      "value": 5,
+      "avg_cvss": 5.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-10-15",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-10-16",
+      "value": 136,
+      "avg_cvss": 5.6,
+      "cvss_count": 136
+    },
+    {
+      "date": "2013-10-17",
+      "value": 19,
+      "avg_cvss": 4.5,
+      "cvss_count": 19
+    },
+    {
+      "date": "2013-10-19",
+      "value": 14,
+      "avg_cvss": 6.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-10-21",
+      "value": 5,
+      "avg_cvss": 6.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-10-22",
+      "value": 8,
+      "avg_cvss": 5.9,
+      "cvss_count": 8
+    },
+    {
+      "date": "2013-10-23",
+      "value": 3,
+      "avg_cvss": 6.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2013-10-24",
+      "value": 52,
+      "avg_cvss": 4.9,
+      "cvss_count": 52
+    },
+    {
+      "date": "2013-10-25",
+      "value": 19,
+      "avg_cvss": 5.8,
+      "cvss_count": 19
+    },
+    {
+      "date": "2013-10-26",
+      "value": 6,
+      "avg_cvss": 6.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2013-10-27",
+      "value": 5,
+      "avg_cvss": 5.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-10-28",
+      "value": 28,
+      "avg_cvss": 5.7,
+      "cvss_count": 28
+    },
+    {
+      "date": "2013-10-29",
+      "value": 4,
+      "avg_cvss": 4.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-10-30",
+      "value": 14,
+      "avg_cvss": 8.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-10-31",
+      "value": 4,
+      "avg_cvss": 7.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-11-01",
+      "value": 10,
+      "avg_cvss": 5.2,
+      "cvss_count": 10
+    },
+    {
+      "date": "2013-11-02",
+      "value": 24,
+      "avg_cvss": 5.4,
+      "cvss_count": 24
+    },
+    {
+      "date": "2013-11-04",
+      "value": 20,
+      "avg_cvss": 6.2,
+      "cvss_count": 20
+    },
+    {
+      "date": "2013-11-05",
+      "value": 23,
+      "avg_cvss": 6.2,
+      "cvss_count": 23
+    },
+    {
+      "date": "2013-11-06",
+      "value": 9,
+      "avg_cvss": 5.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-11-08",
+      "value": 14,
+      "avg_cvss": 6.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-11-09",
+      "value": 4,
+      "avg_cvss": 3.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-11-12",
+      "value": 12,
+      "avg_cvss": 6.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2013-11-13",
+      "value": 49,
+      "avg_cvss": 6.6,
+      "cvss_count": 49
+    },
+    {
+      "date": "2013-11-14",
+      "value": 7,
+      "avg_cvss": 5.8,
+      "cvss_count": 7
+    },
+    {
+      "date": "2013-11-18",
+      "value": 43,
+      "avg_cvss": 5.5,
+      "cvss_count": 43
+    },
+    {
+      "date": "2013-11-19",
+      "value": 9,
+      "avg_cvss": 5.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-11-20",
+      "value": 36,
+      "avg_cvss": 6.2,
+      "cvss_count": 36
+    },
+    {
+      "date": "2013-11-21",
+      "value": 14,
+      "avg_cvss": 5.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-11-22",
+      "value": 14,
+      "avg_cvss": 5.6,
+      "cvss_count": 14
+    },
+    {
+      "date": "2013-11-23",
+      "value": 60,
+      "avg_cvss": 6.5,
+      "cvss_count": 60
+    },
+    {
+      "date": "2013-11-24",
+      "value": 5,
+      "avg_cvss": 8.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-11-25",
+      "value": 6,
+      "avg_cvss": 5.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2013-11-26",
+      "value": 8,
+      "avg_cvss": 6.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2013-11-27",
+      "value": 11,
+      "avg_cvss": 5.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2013-11-28",
+      "value": 4,
+      "avg_cvss": 6.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-11-29",
+      "value": 8,
+      "avg_cvss": 4.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "2013-11-30",
+      "value": 4,
+      "avg_cvss": 4.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-12-01",
+      "value": 4,
+      "avg_cvss": 5.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2013-12-02",
+      "value": 9,
+      "avg_cvss": 6.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-12-03",
+      "value": 5,
+      "avg_cvss": 5.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-12-04",
+      "value": 9,
+      "avg_cvss": 6.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2013-12-05",
+      "value": 29,
+      "avg_cvss": 4.5,
+      "cvss_count": 29
+    },
+    {
+      "date": "2013-12-06",
+      "value": 2,
+      "avg_cvss": 6.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2013-12-07",
+      "value": 53,
+      "avg_cvss": 6.8,
+      "cvss_count": 53
+    },
+    {
+      "date": "2013-12-09",
+      "value": 46,
+      "avg_cvss": 6.2,
+      "cvss_count": 46
+    },
+    {
+      "date": "2013-12-10",
+      "value": 13,
+      "avg_cvss": 6.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2013-12-11",
+      "value": 37,
+      "avg_cvss": 7.5,
+      "cvss_count": 37
+    },
+    {
+      "date": "2013-12-12",
+      "value": 17,
+      "avg_cvss": 6.0,
+      "cvss_count": 17
+    },
+    {
+      "date": "2013-12-13",
+      "value": 27,
+      "avg_cvss": 5.5,
+      "cvss_count": 27
+    },
+    {
+      "date": "2013-12-14",
+      "value": 41,
+      "avg_cvss": 5.3,
+      "cvss_count": 41
+    },
+    {
+      "date": "2013-12-16",
+      "value": 1,
+      "avg_cvss": 9.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-12-17",
+      "value": 20,
+      "avg_cvss": 5.5,
+      "cvss_count": 20
+    },
+    {
+      "date": "2013-12-18",
+      "value": 16,
+      "avg_cvss": 5.6,
+      "cvss_count": 16
+    },
+    {
+      "date": "2013-12-19",
+      "value": 23,
+      "avg_cvss": 6.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2013-12-20",
+      "value": 7,
+      "avg_cvss": 6.1,
+      "cvss_count": 7
+    },
+    {
+      "date": "2013-12-21",
+      "value": 32,
+      "avg_cvss": 4.7,
+      "cvss_count": 32
+    },
+    {
+      "date": "2013-12-22",
+      "value": 8,
+      "avg_cvss": 4.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2013-12-23",
+      "value": 22,
+      "avg_cvss": 5.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2013-12-24",
+      "value": 15,
+      "avg_cvss": 4.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2013-12-26",
+      "value": 1,
+      "avg_cvss": 10.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2013-12-27",
+      "value": 5,
+      "avg_cvss": 5.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2013-12-28",
+      "value": 11,
+      "avg_cvss": 5.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2013-12-29",
+      "value": 6,
+      "avg_cvss": 6.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2013-12-30",
+      "value": 13,
+      "avg_cvss": 4.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2013-12-31",
+      "value": 12,
+      "avg_cvss": 6.7,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-01-01",
+      "value": 1,
+      "avg_cvss": 5.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2014-01-02",
+      "value": 10,
+      "avg_cvss": 5.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2014-01-03",
+      "value": 14,
+      "avg_cvss": 5.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2014-01-04",
+      "value": 9,
+      "avg_cvss": 10.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-01-05",
+      "value": 4,
+      "avg_cvss": 4.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2014-01-06",
+      "value": 9,
+      "avg_cvss": 4.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-01-07",
+      "value": 12,
+      "avg_cvss": 5.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-01-08",
+      "value": 20,
+      "avg_cvss": 4.6,
+      "cvss_count": 20
+    },
+    {
+      "date": "2014-01-09",
+      "value": 14,
+      "avg_cvss": 7.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2014-01-10",
+      "value": 24,
+      "avg_cvss": 5.6,
+      "cvss_count": 24
+    },
+    {
+      "date": "2014-01-11",
+      "value": 4,
+      "avg_cvss": 6.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2014-01-12",
+      "value": 12,
+      "avg_cvss": 7.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-01-13",
+      "value": 6,
+      "avg_cvss": 3.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2014-01-14",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2014-01-15",
+      "value": 152,
+      "avg_cvss": 5.4,
+      "cvss_count": 152
+    },
+    {
+      "date": "2014-01-16",
+      "value": 33,
+      "avg_cvss": 5.7,
+      "cvss_count": 33
+    },
+    {
+      "date": "2014-01-17",
+      "value": 7,
+      "avg_cvss": 5.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2014-01-18",
+      "value": 8,
+      "avg_cvss": 3.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2014-01-19",
+      "value": 9,
+      "avg_cvss": 5.1,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-01-20",
+      "value": 7,
+      "avg_cvss": 6.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2014-01-21",
+      "value": 38,
+      "avg_cvss": 5.8,
+      "cvss_count": 38
+    },
+    {
+      "date": "2014-01-22",
+      "value": 19,
+      "avg_cvss": 5.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2014-01-23",
+      "value": 25,
+      "avg_cvss": 5.5,
+      "cvss_count": 25
+    },
+    {
+      "date": "2014-01-24",
+      "value": 23,
+      "avg_cvss": 5.6,
+      "cvss_count": 23
+    },
+    {
+      "date": "2014-01-25",
+      "value": 6,
+      "avg_cvss": 6.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2014-01-26",
+      "value": 28,
+      "avg_cvss": 5.2,
+      "cvss_count": 28
+    },
+    {
+      "date": "2014-01-27",
+      "value": 1,
+      "avg_cvss": 7.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2014-01-28",
+      "value": 13,
+      "avg_cvss": 5.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2014-01-29",
+      "value": 23,
+      "avg_cvss": 5.9,
+      "cvss_count": 23
+    },
+    {
+      "date": "2014-01-30",
+      "value": 17,
+      "avg_cvss": 5.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "2014-01-31",
+      "value": 8,
+      "avg_cvss": 6.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2014-02-01",
+      "value": 9,
+      "avg_cvss": 5.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-02-02",
+      "value": 7,
+      "avg_cvss": 3.8,
+      "cvss_count": 7
+    },
+    {
+      "date": "2014-02-03",
+      "value": 5,
+      "avg_cvss": 5.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2014-02-04",
+      "value": 24,
+      "avg_cvss": 6.9,
+      "cvss_count": 24
+    },
+    {
+      "date": "2014-02-05",
+      "value": 23,
+      "avg_cvss": 5.6,
+      "cvss_count": 23
+    },
+    {
+      "date": "2014-02-06",
+      "value": 48,
+      "avg_cvss": 6.2,
+      "cvss_count": 48
+    },
+    {
+      "date": "2014-02-07",
+      "value": 7,
+      "avg_cvss": 5.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2014-02-08",
+      "value": 10,
+      "avg_cvss": 4.9,
+      "cvss_count": 10
+    },
+    {
+      "date": "2014-02-10",
+      "value": 19,
+      "avg_cvss": 5.1,
+      "cvss_count": 19
+    },
+    {
+      "date": "2014-02-11",
+      "value": 11,
+      "avg_cvss": 5.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2014-02-12",
+      "value": 35,
+      "avg_cvss": 8.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2014-02-13",
+      "value": 8,
+      "avg_cvss": 6.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2014-02-14",
+      "value": 44,
+      "avg_cvss": 5.5,
+      "cvss_count": 44
+    },
+    {
+      "date": "2014-02-15",
+      "value": 20,
+      "avg_cvss": 5.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2014-02-17",
+      "value": 10,
+      "avg_cvss": 5.2,
+      "cvss_count": 10
+    },
+    {
+      "date": "2014-02-18",
+      "value": 12,
+      "avg_cvss": 6.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-02-20",
+      "value": 10,
+      "avg_cvss": 5.4,
+      "cvss_count": 10
+    },
+    {
+      "date": "2014-02-21",
+      "value": 4,
+      "avg_cvss": 8.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2014-02-22",
+      "value": 24,
+      "avg_cvss": 6.5,
+      "cvss_count": 24
+    },
+    {
+      "date": "2014-02-24",
+      "value": 14,
+      "avg_cvss": 7.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2014-02-25",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2014-02-26",
+      "value": 28,
+      "avg_cvss": 5.3,
+      "cvss_count": 28
+    },
+    {
+      "date": "2014-02-27",
+      "value": 49,
+      "avg_cvss": 6.5,
+      "cvss_count": 49
+    },
+    {
+      "date": "2014-02-28",
+      "value": 9,
+      "avg_cvss": 4.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-03-01",
+      "value": 11,
+      "avg_cvss": 5.5,
+      "cvss_count": 11
+    },
+    {
+      "date": "2014-03-02",
+      "value": 17,
+      "avg_cvss": 5.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2014-03-03",
+      "value": 25,
+      "avg_cvss": 6.4,
+      "cvss_count": 25
+    },
+    {
+      "date": "2014-03-04",
+      "value": 4,
+      "avg_cvss": 4.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2014-03-05",
+      "value": 24,
+      "avg_cvss": 5.7,
+      "cvss_count": 24
+    },
+    {
+      "date": "2014-03-06",
+      "value": 26,
+      "avg_cvss": 5.9,
+      "cvss_count": 26
+    },
+    {
+      "date": "2014-03-07",
+      "value": 3,
+      "avg_cvss": 5.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2014-03-09",
+      "value": 18,
+      "avg_cvss": 5.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2014-03-11",
+      "value": 51,
+      "avg_cvss": 5.9,
+      "cvss_count": 51
+    },
+    {
+      "date": "2014-03-12",
+      "value": 30,
+      "avg_cvss": 7.9,
+      "cvss_count": 30
+    },
+    {
+      "date": "2014-03-13",
+      "value": 5,
+      "avg_cvss": 5.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2014-03-14",
+      "value": 87,
+      "avg_cvss": 5.5,
+      "cvss_count": 87
+    },
+    {
+      "date": "2014-03-16",
+      "value": 33,
+      "avg_cvss": 6.8,
+      "cvss_count": 33
+    },
+    {
+      "date": "2014-03-18",
+      "value": 23,
+      "avg_cvss": 6.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2014-03-19",
+      "value": 30,
+      "avg_cvss": 6.8,
+      "cvss_count": 30
+    },
+    {
+      "date": "2014-03-20",
+      "value": 9,
+      "avg_cvss": 5.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-03-21",
+      "value": 24,
+      "avg_cvss": 5.8,
+      "cvss_count": 24
+    },
+    {
+      "date": "2014-03-24",
+      "value": 35,
+      "avg_cvss": 5.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2014-03-25",
+      "value": 21,
+      "avg_cvss": 5.0,
+      "cvss_count": 21
+    },
+    {
+      "date": "2014-03-26",
+      "value": 11,
+      "avg_cvss": 5.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2014-03-27",
+      "value": 20,
+      "avg_cvss": 7.4,
+      "cvss_count": 20
+    },
+    {
+      "date": "2014-03-28",
+      "value": 8,
+      "avg_cvss": 5.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2014-03-29",
+      "value": 8,
+      "avg_cvss": 6.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2014-03-31",
+      "value": 21,
+      "avg_cvss": 6.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2014-04-01",
+      "value": 30,
+      "avg_cvss": 6.1,
+      "cvss_count": 30
+    },
+    {
+      "date": "2014-04-02",
+      "value": 33,
+      "avg_cvss": 6.1,
+      "cvss_count": 33
+    },
+    {
+      "date": "2014-04-03",
+      "value": 3,
+      "avg_cvss": 6.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2014-04-04",
+      "value": 15,
+      "avg_cvss": 6.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2014-04-05",
+      "value": 11,
+      "avg_cvss": 4.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2014-04-06",
+      "value": 2,
+      "avg_cvss": 5.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2014-04-07",
+      "value": 4,
+      "avg_cvss": 5.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2014-04-08",
+      "value": 24,
+      "avg_cvss": 6.9,
+      "cvss_count": 24
+    },
+    {
+      "date": "2014-04-09",
+      "value": 14,
+      "avg_cvss": 7.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2014-04-10",
+      "value": 40,
+      "avg_cvss": 6.1,
+      "cvss_count": 40
+    },
+    {
+      "date": "2014-04-11",
+      "value": 26,
+      "avg_cvss": 6.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2014-04-12",
+      "value": 20,
+      "avg_cvss": 6.7,
+      "cvss_count": 20
+    },
+    {
+      "date": "2014-04-14",
+      "value": 15,
+      "avg_cvss": 5.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2014-04-15",
+      "value": 55,
+      "avg_cvss": 6.1,
+      "cvss_count": 55
+    },
+    {
+      "date": "2014-04-16",
+      "value": 111,
+      "avg_cvss": 5.4,
+      "cvss_count": 111
+    },
+    {
+      "date": "2014-04-17",
+      "value": 17,
+      "avg_cvss": 5.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2014-04-18",
+      "value": 18,
+      "avg_cvss": 5.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2014-04-19",
+      "value": 15,
+      "avg_cvss": 6.6,
+      "cvss_count": 15
+    },
+    {
+      "date": "2014-04-20",
+      "value": 2,
+      "avg_cvss": 4.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2014-04-21",
+      "value": 5,
+      "avg_cvss": 5.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2014-04-22",
+      "value": 25,
+      "avg_cvss": 5.7,
+      "cvss_count": 25
+    },
+    {
+      "date": "2014-04-23",
+      "value": 46,
+      "avg_cvss": 5.6,
+      "cvss_count": 46
+    },
+    {
+      "date": "2014-04-24",
+      "value": 12,
+      "avg_cvss": 5.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-04-25",
+      "value": 18,
+      "avg_cvss": 6.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2014-04-26",
+      "value": 9,
+      "avg_cvss": 7.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-04-27",
+      "value": 19,
+      "avg_cvss": 6.7,
+      "cvss_count": 19
+    },
+    {
+      "date": "2014-04-28",
+      "value": 14,
+      "avg_cvss": 6.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2014-04-29",
+      "value": 32,
+      "avg_cvss": 5.6,
+      "cvss_count": 32
+    },
+    {
+      "date": "2014-04-30",
+      "value": 37,
+      "avg_cvss": 6.5,
+      "cvss_count": 37
+    },
+    {
+      "date": "2014-05-01",
+      "value": 12,
+      "avg_cvss": 5.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-05-02",
+      "value": 38,
+      "avg_cvss": 6.6,
+      "cvss_count": 38
+    },
+    {
+      "date": "2014-05-05",
+      "value": 15,
+      "avg_cvss": 5.8,
+      "cvss_count": 15
+    },
+    {
+      "date": "2014-05-06",
+      "value": 11,
+      "avg_cvss": 5.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2014-05-07",
+      "value": 13,
+      "avg_cvss": 5.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2014-05-08",
+      "value": 52,
+      "avg_cvss": 5.1,
+      "cvss_count": 52
+    },
+    {
+      "date": "2014-05-09",
+      "value": 6,
+      "avg_cvss": 4.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2014-05-10",
+      "value": 2,
+      "avg_cvss": 3.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2014-05-11",
+      "value": 5,
+      "avg_cvss": 4.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2014-05-12",
+      "value": 21,
+      "avg_cvss": 5.9,
+      "cvss_count": 21
+    },
+    {
+      "date": "2014-05-13",
+      "value": 17,
+      "avg_cvss": 5.6,
+      "cvss_count": 17
+    },
+    {
+      "date": "2014-05-14",
+      "value": 65,
+      "avg_cvss": 7.0,
+      "cvss_count": 65
+    },
+    {
+      "date": "2014-05-15",
+      "value": 8,
+      "avg_cvss": 6.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2014-05-16",
+      "value": 21,
+      "avg_cvss": 6.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2014-05-17",
+      "value": 5,
+      "avg_cvss": 5.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2014-05-18",
+      "value": 1,
+      "avg_cvss": 4.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2014-05-19",
+      "value": 27,
+      "avg_cvss": 5.0,
+      "cvss_count": 27
+    },
+    {
+      "date": "2014-05-20",
+      "value": 33,
+      "avg_cvss": 6.0,
+      "cvss_count": 33
+    },
+    {
+      "date": "2014-05-21",
+      "value": 14,
+      "avg_cvss": 5.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2014-05-22",
+      "value": 47,
+      "avg_cvss": 5.9,
+      "cvss_count": 47
+    },
+    {
+      "date": "2014-05-23",
+      "value": 17,
+      "avg_cvss": 5.6,
+      "cvss_count": 17
+    },
+    {
+      "date": "2014-05-25",
+      "value": 3,
+      "avg_cvss": 5.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2014-05-26",
+      "value": 40,
+      "avg_cvss": 5.4,
+      "cvss_count": 40
+    },
+    {
+      "date": "2014-05-27",
+      "value": 26,
+      "avg_cvss": 5.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2014-05-28",
+      "value": 2,
+      "avg_cvss": 4.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2014-05-29",
+      "value": 18,
+      "avg_cvss": 4.7,
+      "cvss_count": 18
+    },
+    {
+      "date": "2014-05-30",
+      "value": 25,
+      "avg_cvss": 5.1,
+      "cvss_count": 25
+    },
+    {
+      "date": "2014-05-31",
+      "value": 6,
+      "avg_cvss": 4.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2014-06-01",
+      "value": 4,
+      "avg_cvss": 6.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2014-06-02",
+      "value": 31,
+      "avg_cvss": 6.6,
+      "cvss_count": 31
+    },
+    {
+      "date": "2014-06-03",
+      "value": 10,
+      "avg_cvss": 4.8,
+      "cvss_count": 10
+    },
+    {
+      "date": "2014-06-04",
+      "value": 30,
+      "avg_cvss": 5.6,
+      "cvss_count": 30
+    },
+    {
+      "date": "2014-06-05",
+      "value": 32,
+      "avg_cvss": 5.6,
+      "cvss_count": 32
+    },
+    {
+      "date": "2014-06-06",
+      "value": 12,
+      "avg_cvss": 6.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-06-07",
+      "value": 1,
+      "avg_cvss": 7.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2014-06-08",
+      "value": 17,
+      "avg_cvss": 5.4,
+      "cvss_count": 17
+    },
+    {
+      "date": "2014-06-09",
+      "value": 23,
+      "avg_cvss": 4.9,
+      "cvss_count": 23
+    },
+    {
+      "date": "2014-06-10",
+      "value": 13,
+      "avg_cvss": 4.5,
+      "cvss_count": 13
+    },
+    {
+      "date": "2014-06-11",
+      "value": 102,
+      "avg_cvss": 8.1,
+      "cvss_count": 102
+    },
+    {
+      "date": "2014-06-13",
+      "value": 23,
+      "avg_cvss": 6.7,
+      "cvss_count": 23
+    },
+    {
+      "date": "2014-06-14",
+      "value": 6,
+      "avg_cvss": 5.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "2014-06-16",
+      "value": 11,
+      "avg_cvss": 5.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2014-06-17",
+      "value": 19,
+      "avg_cvss": 5.0,
+      "cvss_count": 19
+    },
+    {
+      "date": "2014-06-18",
+      "value": 34,
+      "avg_cvss": 5.6,
+      "cvss_count": 34
+    },
+    {
+      "date": "2014-06-19",
+      "value": 19,
+      "avg_cvss": 6.5,
+      "cvss_count": 19
+    },
+    {
+      "date": "2014-06-20",
+      "value": 11,
+      "avg_cvss": 6.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2014-06-21",
+      "value": 8,
+      "avg_cvss": 5.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2014-06-22",
+      "value": 3,
+      "avg_cvss": 4.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2014-06-23",
+      "value": 9,
+      "avg_cvss": 4.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-06-25",
+      "value": 11,
+      "avg_cvss": 5.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2014-06-27",
+      "value": 4,
+      "avg_cvss": 5.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2014-06-28",
+      "value": 12,
+      "avg_cvss": 5.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-07-01",
+      "value": 68,
+      "avg_cvss": 5.6,
+      "cvss_count": 68
+    },
+    {
+      "date": "2014-07-02",
+      "value": 76,
+      "avg_cvss": 4.6,
+      "cvss_count": 76
+    },
+    {
+      "date": "2014-07-03",
+      "value": 26,
+      "avg_cvss": 5.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2014-07-06",
+      "value": 2,
+      "avg_cvss": 3.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2014-07-07",
+      "value": 41,
+      "avg_cvss": 6.1,
+      "cvss_count": 41
+    },
+    {
+      "date": "2014-07-08",
+      "value": 31,
+      "avg_cvss": 8.7,
+      "cvss_count": 31
+    },
+    {
+      "date": "2014-07-09",
+      "value": 21,
+      "avg_cvss": 5.9,
+      "cvss_count": 21
+    },
+    {
+      "date": "2014-07-10",
+      "value": 21,
+      "avg_cvss": 4.9,
+      "cvss_count": 21
+    },
+    {
+      "date": "2014-07-11",
+      "value": 24,
+      "avg_cvss": 5.7,
+      "cvss_count": 24
+    },
+    {
+      "date": "2014-07-14",
+      "value": 12,
+      "avg_cvss": 6.2,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-07-15",
+      "value": 11,
+      "avg_cvss": 6.1,
+      "cvss_count": 11
+    },
+    {
+      "date": "2014-07-16",
+      "value": 16,
+      "avg_cvss": 6.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2014-07-17",
+      "value": 92,
+      "avg_cvss": 5.0,
+      "cvss_count": 92
+    },
+    {
+      "date": "2014-07-18",
+      "value": 6,
+      "avg_cvss": 6.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2014-07-19",
+      "value": 20,
+      "avg_cvss": 5.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2014-07-20",
+      "value": 29,
+      "avg_cvss": 5.0,
+      "cvss_count": 29
+    },
+    {
+      "date": "2014-07-21",
+      "value": 5,
+      "avg_cvss": 5.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2014-07-22",
+      "value": 14,
+      "avg_cvss": 6.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2014-07-23",
+      "value": 22,
+      "avg_cvss": 7.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2014-07-24",
+      "value": 22,
+      "avg_cvss": 5.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2014-07-25",
+      "value": 6,
+      "avg_cvss": 5.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2014-07-26",
+      "value": 16,
+      "avg_cvss": 6.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2014-07-27",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2014-07-28",
+      "value": 18,
+      "avg_cvss": 5.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2014-07-29",
+      "value": 36,
+      "avg_cvss": 4.8,
+      "cvss_count": 36
+    },
+    {
+      "date": "2014-07-30",
+      "value": 7,
+      "avg_cvss": 4.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2014-07-31",
+      "value": 9,
+      "avg_cvss": 5.1,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-08-01",
+      "value": 13,
+      "avg_cvss": 5.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2014-08-03",
+      "value": 5,
+      "avg_cvss": 4.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2014-08-06",
+      "value": 20,
+      "avg_cvss": 6.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2014-08-07",
+      "value": 25,
+      "avg_cvss": 6.1,
+      "cvss_count": 25
+    },
+    {
+      "date": "2014-08-11",
+      "value": 7,
+      "avg_cvss": 6.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2014-08-12",
+      "value": 79,
+      "avg_cvss": 7.2,
+      "cvss_count": 79
+    },
+    {
+      "date": "2014-08-13",
+      "value": 12,
+      "avg_cvss": 5.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-08-14",
+      "value": 24,
+      "avg_cvss": 6.4,
+      "cvss_count": 24
+    },
+    {
+      "date": "2014-08-15",
+      "value": 6,
+      "avg_cvss": 7.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2014-08-16",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2014-08-17",
+      "value": 17,
+      "avg_cvss": 6.1,
+      "cvss_count": 17
+    },
+    {
+      "date": "2014-08-18",
+      "value": 10,
+      "avg_cvss": 5.8,
+      "cvss_count": 10
+    },
+    {
+      "date": "2014-08-19",
+      "value": 20,
+      "avg_cvss": 5.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2014-08-20",
+      "value": 18,
+      "avg_cvss": 5.6,
+      "cvss_count": 18
+    },
+    {
+      "date": "2014-08-21",
+      "value": 12,
+      "avg_cvss": 6.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-08-22",
+      "value": 30,
+      "avg_cvss": 5.7,
+      "cvss_count": 30
+    },
+    {
+      "date": "2014-08-23",
+      "value": 7,
+      "avg_cvss": 6.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2014-08-25",
+      "value": 16,
+      "avg_cvss": 5.3,
+      "cvss_count": 16
+    },
+    {
+      "date": "2014-08-26",
+      "value": 21,
+      "avg_cvss": 5.6,
+      "cvss_count": 21
+    },
+    {
+      "date": "2014-08-27",
+      "value": 12,
+      "avg_cvss": 7.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-08-28",
+      "value": 13,
+      "avg_cvss": 5.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2014-08-29",
+      "value": 24,
+      "avg_cvss": 5.3,
+      "cvss_count": 24
+    },
+    {
+      "date": "2014-08-30",
+      "value": 2,
+      "avg_cvss": 5.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2014-08-31",
+      "value": 5,
+      "avg_cvss": 6.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2014-09-01",
+      "value": 3,
+      "avg_cvss": 4.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2014-09-02",
+      "value": 12,
+      "avg_cvss": 5.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-09-03",
+      "value": 10,
+      "avg_cvss": 7.2,
+      "cvss_count": 10
+    },
+    {
+      "date": "2014-09-04",
+      "value": 23,
+      "avg_cvss": 5.2,
+      "cvss_count": 23
+    },
+    {
+      "date": "2014-09-05",
+      "value": 15,
+      "avg_cvss": 5.1,
+      "cvss_count": 15
+    },
+    {
+      "date": "2014-09-08",
+      "value": 5,
+      "avg_cvss": 5.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2014-09-09",
+      "value": 326,
+      "avg_cvss": 5.4,
+      "cvss_count": 326
+    },
+    {
+      "date": "2014-09-10",
+      "value": 79,
+      "avg_cvss": 7.8,
+      "cvss_count": 79
+    },
+    {
+      "date": "2014-09-11",
+      "value": 45,
+      "avg_cvss": 5.6,
+      "cvss_count": 45
+    },
+    {
+      "date": "2014-09-12",
+      "value": 22,
+      "avg_cvss": 5.4,
+      "cvss_count": 22
+    },
+    {
+      "date": "2014-09-15",
+      "value": 27,
+      "avg_cvss": 5.3,
+      "cvss_count": 27
+    },
+    {
+      "date": "2014-09-17",
+      "value": 32,
+      "avg_cvss": 6.3,
+      "cvss_count": 32
+    },
+    {
+      "date": "2014-09-18",
+      "value": 93,
+      "avg_cvss": 5.4,
+      "cvss_count": 93
+    },
+    {
+      "date": "2014-09-19",
+      "value": 35,
+      "avg_cvss": 6.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2014-09-20",
+      "value": 41,
+      "avg_cvss": 5.5,
+      "cvss_count": 41
+    },
+    {
+      "date": "2014-09-22",
+      "value": 62,
+      "avg_cvss": 5.2,
+      "cvss_count": 62
+    },
+    {
+      "date": "2014-09-23",
+      "value": 59,
+      "avg_cvss": 5.4,
+      "cvss_count": 59
+    },
+    {
+      "date": "2014-09-24",
+      "value": 12,
+      "avg_cvss": 5.7,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-09-25",
+      "value": 27,
+      "avg_cvss": 6.3,
+      "cvss_count": 27
+    },
+    {
+      "date": "2014-09-26",
+      "value": 23,
+      "avg_cvss": 5.4,
+      "cvss_count": 23
+    },
+    {
+      "date": "2014-09-27",
+      "value": 17,
+      "avg_cvss": 5.8,
+      "cvss_count": 17
+    },
+    {
+      "date": "2014-09-28",
+      "value": 42,
+      "avg_cvss": 6.1,
+      "cvss_count": 42
+    },
+    {
+      "date": "2014-09-29",
+      "value": 53,
+      "avg_cvss": 5.5,
+      "cvss_count": 53
+    },
+    {
+      "date": "2014-09-30",
+      "value": 83,
+      "avg_cvss": 5.4,
+      "cvss_count": 83
+    },
+    {
+      "date": "2014-10-01",
+      "value": 8,
+      "avg_cvss": 5.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2014-10-02",
+      "value": 54,
+      "avg_cvss": 5.5,
+      "cvss_count": 54
+    },
+    {
+      "date": "2014-10-03",
+      "value": 30,
+      "avg_cvss": 6.1,
+      "cvss_count": 30
+    },
+    {
+      "date": "2014-10-04",
+      "value": 29,
+      "avg_cvss": 5.3,
+      "cvss_count": 29
+    },
+    {
+      "date": "2014-10-05",
+      "value": 6,
+      "avg_cvss": 6.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2014-10-06",
+      "value": 28,
+      "avg_cvss": 5.9,
+      "cvss_count": 28
+    },
+    {
+      "date": "2014-10-07",
+      "value": 20,
+      "avg_cvss": 6.9,
+      "cvss_count": 20
+    },
+    {
+      "date": "2014-10-08",
+      "value": 42,
+      "avg_cvss": 6.0,
+      "cvss_count": 42
+    },
+    {
+      "date": "2014-10-09",
+      "value": 6,
+      "avg_cvss": 3.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2014-10-10",
+      "value": 51,
+      "avg_cvss": 6.0,
+      "cvss_count": 51
+    },
+    {
+      "date": "2014-10-11",
+      "value": 11,
+      "avg_cvss": 5.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2014-10-12",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2014-10-13",
+      "value": 16,
+      "avg_cvss": 4.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2014-10-14",
+      "value": 11,
+      "avg_cvss": 6.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2014-10-15",
+      "value": 196,
+      "avg_cvss": 5.7,
+      "cvss_count": 196
+    },
+    {
+      "date": "2014-10-16",
+      "value": 126,
+      "avg_cvss": 5.4,
+      "cvss_count": 126
+    },
+    {
+      "date": "2014-10-17",
+      "value": 23,
+      "avg_cvss": 5.3,
+      "cvss_count": 23
+    },
+    {
+      "date": "2014-10-18",
+      "value": 25,
+      "avg_cvss": 5.1,
+      "cvss_count": 25
+    },
+    {
+      "date": "2014-10-19",
+      "value": 244,
+      "avg_cvss": 5.4,
+      "cvss_count": 244
+    },
+    {
+      "date": "2014-10-20",
+      "value": 146,
+      "avg_cvss": 5.4,
+      "cvss_count": 146
+    },
+    {
+      "date": "2014-10-21",
+      "value": 181,
+      "avg_cvss": 5.4,
+      "cvss_count": 181
+    },
+    {
+      "date": "2014-10-22",
+      "value": 19,
+      "avg_cvss": 5.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2014-10-23",
+      "value": 10,
+      "avg_cvss": 6.5,
+      "cvss_count": 10
+    },
+    {
+      "date": "2014-10-24",
+      "value": 2,
+      "avg_cvss": 6.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2014-10-25",
+      "value": 21,
+      "avg_cvss": 4.7,
+      "cvss_count": 21
+    },
+    {
+      "date": "2014-10-26",
+      "value": 12,
+      "avg_cvss": 5.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2014-10-27",
+      "value": 16,
+      "avg_cvss": 6.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2014-10-28",
+      "value": 9,
+      "avg_cvss": 5.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-10-29",
+      "value": 33,
+      "avg_cvss": 4.8,
+      "cvss_count": 33
+    },
+    {
+      "date": "2014-10-30",
+      "value": 7,
+      "avg_cvss": 6.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2014-10-31",
+      "value": 29,
+      "avg_cvss": 4.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2014-11-01",
+      "value": 5,
+      "avg_cvss": 5.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2014-11-02",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2014-11-03",
+      "value": 18,
+      "avg_cvss": 6.1,
+      "cvss_count": 18
+    },
+    {
+      "date": "2014-11-04",
+      "value": 46,
+      "avg_cvss": 6.6,
+      "cvss_count": 46
+    },
+    {
+      "date": "2014-11-05",
+      "value": 19,
+      "avg_cvss": 6.4,
+      "cvss_count": 19
+    },
+    {
+      "date": "2014-11-06",
+      "value": 30,
+      "avg_cvss": 5.9,
+      "cvss_count": 30
+    },
+    {
+      "date": "2014-11-07",
+      "value": 21,
+      "avg_cvss": 5.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2014-11-08",
+      "value": 7,
+      "avg_cvss": 3.8,
+      "cvss_count": 7
+    },
+    {
+      "date": "2014-11-10",
+      "value": 17,
+      "avg_cvss": 5.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2014-11-11",
+      "value": 50,
+      "avg_cvss": 8.1,
+      "cvss_count": 50
+    },
+    {
+      "date": "2014-11-12",
+      "value": 5,
+      "avg_cvss": 5.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2014-11-13",
+      "value": 9,
+      "avg_cvss": 5.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-11-14",
+      "value": 7,
+      "avg_cvss": 6.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2014-11-15",
+      "value": 11,
+      "avg_cvss": 5.5,
+      "cvss_count": 11
+    },
+    {
+      "date": "2014-11-16",
+      "value": 22,
+      "avg_cvss": 5.7,
+      "cvss_count": 22
+    },
+    {
+      "date": "2014-11-17",
+      "value": 14,
+      "avg_cvss": 5.3,
+      "cvss_count": 14
+    },
+    {
+      "date": "2014-11-18",
+      "value": 28,
+      "avg_cvss": 5.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2014-11-19",
+      "value": 25,
+      "avg_cvss": 6.6,
+      "cvss_count": 25
+    },
+    {
+      "date": "2014-11-20",
+      "value": 28,
+      "avg_cvss": 6.1,
+      "cvss_count": 28
+    },
+    {
+      "date": "2014-11-21",
+      "value": 13,
+      "avg_cvss": 5.8,
+      "cvss_count": 13
+    },
+    {
+      "date": "2014-11-23",
+      "value": 9,
+      "avg_cvss": 5.3,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-11-24",
+      "value": 38,
+      "avg_cvss": 5.1,
+      "cvss_count": 38
+    },
+    {
+      "date": "2014-11-25",
+      "value": 20,
+      "avg_cvss": 6.4,
+      "cvss_count": 20
+    },
+    {
+      "date": "2014-11-26",
+      "value": 26,
+      "avg_cvss": 6.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2014-11-27",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2014-11-28",
+      "value": 16,
+      "avg_cvss": 6.1,
+      "cvss_count": 16
+    },
+    {
+      "date": "2014-11-30",
+      "value": 13,
+      "avg_cvss": 5.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2014-12-01",
+      "value": 18,
+      "avg_cvss": 5.0,
+      "cvss_count": 18
+    },
+    {
+      "date": "2014-12-02",
+      "value": 26,
+      "avg_cvss": 5.7,
+      "cvss_count": 26
+    },
+    {
+      "date": "2014-12-03",
+      "value": 23,
+      "avg_cvss": 6.2,
+      "cvss_count": 23
+    },
+    {
+      "date": "2014-12-04",
+      "value": 7,
+      "avg_cvss": 6.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2014-12-05",
+      "value": 30,
+      "avg_cvss": 5.5,
+      "cvss_count": 30
+    },
+    {
+      "date": "2014-12-06",
+      "value": 8,
+      "avg_cvss": 5.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2014-12-07",
+      "value": 6,
+      "avg_cvss": 6.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2014-12-08",
+      "value": 34,
+      "avg_cvss": 5.9,
+      "cvss_count": 34
+    },
+    {
+      "date": "2014-12-09",
+      "value": 18,
+      "avg_cvss": 6.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2014-12-10",
+      "value": 69,
+      "avg_cvss": 7.2,
+      "cvss_count": 69
+    },
+    {
+      "date": "2014-12-11",
+      "value": 50,
+      "avg_cvss": 6.6,
+      "cvss_count": 50
+    },
+    {
+      "date": "2014-12-12",
+      "value": 31,
+      "avg_cvss": 5.2,
+      "cvss_count": 31
+    },
+    {
+      "date": "2014-12-13",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2014-12-15",
+      "value": 27,
+      "avg_cvss": 5.9,
+      "cvss_count": 27
+    },
+    {
+      "date": "2014-12-16",
+      "value": 22,
+      "avg_cvss": 6.7,
+      "cvss_count": 22
+    },
+    {
+      "date": "2014-12-17",
+      "value": 18,
+      "avg_cvss": 5.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2014-12-18",
+      "value": 23,
+      "avg_cvss": 5.1,
+      "cvss_count": 23
+    },
+    {
+      "date": "2014-12-19",
+      "value": 48,
+      "avg_cvss": 5.5,
+      "cvss_count": 48
+    },
+    {
+      "date": "2014-12-20",
+      "value": 9,
+      "avg_cvss": 6.3,
+      "cvss_count": 9
+    },
+    {
+      "date": "2014-12-22",
+      "value": 10,
+      "avg_cvss": 4.7,
+      "cvss_count": 10
+    },
+    {
+      "date": "2014-12-23",
+      "value": 13,
+      "avg_cvss": 5.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2014-12-24",
+      "value": 31,
+      "avg_cvss": 5.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2014-12-25",
+      "value": 5,
+      "avg_cvss": 6.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2014-12-26",
+      "value": 19,
+      "avg_cvss": 5.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2014-12-27",
+      "value": 13,
+      "avg_cvss": 7.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2014-12-28",
+      "value": 13,
+      "avg_cvss": 5.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2014-12-29",
+      "value": 10,
+      "avg_cvss": 5.4,
+      "cvss_count": 10
+    },
+    {
+      "date": "2014-12-30",
+      "value": 4,
+      "avg_cvss": 5.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2014-12-31",
+      "value": 27,
+      "avg_cvss": 6.0,
+      "cvss_count": 27
+    },
+    {
+      "date": "2015-01-01",
+      "value": 34,
+      "avg_cvss": 6.0,
+      "cvss_count": 34
+    },
+    {
+      "date": "2015-01-02",
+      "value": 33,
+      "avg_cvss": 6.2,
+      "cvss_count": 33
+    },
+    {
+      "date": "2015-01-03",
+      "value": 9,
+      "avg_cvss": 6.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-01-04",
+      "value": 7,
+      "avg_cvss": 5.1,
+      "cvss_count": 7
+    },
+    {
+      "date": "2015-01-05",
+      "value": 17,
+      "avg_cvss": 6.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2015-01-06",
+      "value": 6,
+      "avg_cvss": 5.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "2015-01-07",
+      "value": 13,
+      "avg_cvss": 5.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2015-01-08",
+      "value": 16,
+      "avg_cvss": 5.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2015-01-09",
+      "value": 29,
+      "avg_cvss": 4.6,
+      "cvss_count": 29
+    },
+    {
+      "date": "2015-01-10",
+      "value": 17,
+      "avg_cvss": 5.4,
+      "cvss_count": 17
+    },
+    {
+      "date": "2015-01-12",
+      "value": 6,
+      "avg_cvss": 7.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2015-01-13",
+      "value": 94,
+      "avg_cvss": 6.1,
+      "cvss_count": 94
+    },
+    {
+      "date": "2015-01-14",
+      "value": 18,
+      "avg_cvss": 5.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2015-01-15",
+      "value": 38,
+      "avg_cvss": 5.1,
+      "cvss_count": 38
+    },
+    {
+      "date": "2015-01-16",
+      "value": 35,
+      "avg_cvss": 5.6,
+      "cvss_count": 35
+    },
+    {
+      "date": "2015-01-17",
+      "value": 14,
+      "avg_cvss": 6.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2015-01-18",
+      "value": 3,
+      "avg_cvss": 5.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-01-20",
+      "value": 9,
+      "avg_cvss": 5.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-01-21",
+      "value": 164,
+      "avg_cvss": 5.0,
+      "cvss_count": 164
+    },
+    {
+      "date": "2015-01-22",
+      "value": 36,
+      "avg_cvss": 6.7,
+      "cvss_count": 36
+    },
+    {
+      "date": "2015-01-23",
+      "value": 11,
+      "avg_cvss": 5.1,
+      "cvss_count": 11
+    },
+    {
+      "date": "2015-01-26",
+      "value": 10,
+      "avg_cvss": 5.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-01-27",
+      "value": 28,
+      "avg_cvss": 6.4,
+      "cvss_count": 28
+    },
+    {
+      "date": "2015-01-28",
+      "value": 9,
+      "avg_cvss": 7.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-01-29",
+      "value": 10,
+      "avg_cvss": 4.7,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-01-30",
+      "value": 47,
+      "avg_cvss": 7.0,
+      "cvss_count": 47
+    },
+    {
+      "date": "2015-02-01",
+      "value": 15,
+      "avg_cvss": 6.3,
+      "cvss_count": 15
+    },
+    {
+      "date": "2015-02-02",
+      "value": 27,
+      "avg_cvss": 6.3,
+      "cvss_count": 27
+    },
+    {
+      "date": "2015-02-03",
+      "value": 36,
+      "avg_cvss": 6.2,
+      "cvss_count": 36
+    },
+    {
+      "date": "2015-02-04",
+      "value": 22,
+      "avg_cvss": 5.3,
+      "cvss_count": 22
+    },
+    {
+      "date": "2015-02-06",
+      "value": 39,
+      "avg_cvss": 8.4,
+      "cvss_count": 39
+    },
+    {
+      "date": "2015-02-07",
+      "value": 11,
+      "avg_cvss": 5.2,
+      "cvss_count": 11
+    },
+    {
+      "date": "2015-02-08",
+      "value": 20,
+      "avg_cvss": 6.8,
+      "cvss_count": 20
+    },
+    {
+      "date": "2015-02-09",
+      "value": 8,
+      "avg_cvss": 4.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-02-10",
+      "value": 12,
+      "avg_cvss": 5.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2015-02-11",
+      "value": 65,
+      "avg_cvss": 7.7,
+      "cvss_count": 65
+    },
+    {
+      "date": "2015-02-12",
+      "value": 18,
+      "avg_cvss": 5.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2015-02-13",
+      "value": 20,
+      "avg_cvss": 5.2,
+      "cvss_count": 20
+    },
+    {
+      "date": "2015-02-14",
+      "value": 8,
+      "avg_cvss": 4.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-02-15",
+      "value": 3,
+      "avg_cvss": 3.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-02-16",
+      "value": 20,
+      "avg_cvss": 6.5,
+      "cvss_count": 20
+    },
+    {
+      "date": "2015-02-17",
+      "value": 13,
+      "avg_cvss": 4.8,
+      "cvss_count": 13
+    },
+    {
+      "date": "2015-02-18",
+      "value": 8,
+      "avg_cvss": 4.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-02-19",
+      "value": 32,
+      "avg_cvss": 5.5,
+      "cvss_count": 32
+    },
+    {
+      "date": "2015-02-20",
+      "value": 18,
+      "avg_cvss": 5.8,
+      "cvss_count": 18
+    },
+    {
+      "date": "2015-02-21",
+      "value": 4,
+      "avg_cvss": 7.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2015-02-22",
+      "value": 1,
+      "avg_cvss": 7.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2015-02-23",
+      "value": 13,
+      "avg_cvss": 6.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2015-02-24",
+      "value": 22,
+      "avg_cvss": 5.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2015-02-25",
+      "value": 23,
+      "avg_cvss": 5.6,
+      "cvss_count": 23
+    },
+    {
+      "date": "2015-02-26",
+      "value": 6,
+      "avg_cvss": 5.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2015-02-27",
+      "value": 13,
+      "avg_cvss": 5.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2015-02-28",
+      "value": 9,
+      "avg_cvss": 6.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-03-02",
+      "value": 5,
+      "avg_cvss": 3.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2015-03-03",
+      "value": 10,
+      "avg_cvss": 5.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-03-04",
+      "value": 5,
+      "avg_cvss": 4.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2015-03-05",
+      "value": 9,
+      "avg_cvss": 5.3,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-03-06",
+      "value": 11,
+      "avg_cvss": 6.2,
+      "cvss_count": 11
+    },
+    {
+      "date": "2015-03-07",
+      "value": 10,
+      "avg_cvss": 5.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-03-08",
+      "value": 7,
+      "avg_cvss": 5.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2015-03-09",
+      "value": 52,
+      "avg_cvss": 7.3,
+      "cvss_count": 52
+    },
+    {
+      "date": "2015-03-10",
+      "value": 8,
+      "avg_cvss": 5.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-03-11",
+      "value": 48,
+      "avg_cvss": 6.6,
+      "cvss_count": 48
+    },
+    {
+      "date": "2015-03-12",
+      "value": 20,
+      "avg_cvss": 5.9,
+      "cvss_count": 20
+    },
+    {
+      "date": "2015-03-13",
+      "value": 25,
+      "avg_cvss": 7.0,
+      "cvss_count": 25
+    },
+    {
+      "date": "2015-03-14",
+      "value": 12,
+      "avg_cvss": 7.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2015-03-15",
+      "value": 1,
+      "avg_cvss": 6.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2015-03-16",
+      "value": 10,
+      "avg_cvss": 6.3,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-03-17",
+      "value": 7,
+      "avg_cvss": 6.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2015-03-18",
+      "value": 37,
+      "avg_cvss": 5.5,
+      "cvss_count": 37
+    },
+    {
+      "date": "2015-03-19",
+      "value": 18,
+      "avg_cvss": 5.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2015-03-20",
+      "value": 8,
+      "avg_cvss": 7.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-03-21",
+      "value": 3,
+      "avg_cvss": 6.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-03-22",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2015-03-23",
+      "value": 8,
+      "avg_cvss": 5.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-03-24",
+      "value": 22,
+      "avg_cvss": 5.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2015-03-25",
+      "value": 12,
+      "avg_cvss": 4.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2015-03-26",
+      "value": 24,
+      "avg_cvss": 7.1,
+      "cvss_count": 24
+    },
+    {
+      "date": "2015-03-27",
+      "value": 22,
+      "avg_cvss": 5.6,
+      "cvss_count": 22
+    },
+    {
+      "date": "2015-03-28",
+      "value": 3,
+      "avg_cvss": 6.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-03-29",
+      "value": 12,
+      "avg_cvss": 6.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2015-03-30",
+      "value": 23,
+      "avg_cvss": 6.4,
+      "cvss_count": 23
+    },
+    {
+      "date": "2015-03-31",
+      "value": 20,
+      "avg_cvss": 6.7,
+      "cvss_count": 20
+    },
+    {
+      "date": "2015-04-01",
+      "value": 40,
+      "avg_cvss": 5.8,
+      "cvss_count": 40
+    },
+    {
+      "date": "2015-04-03",
+      "value": 30,
+      "avg_cvss": 6.0,
+      "cvss_count": 30
+    },
+    {
+      "date": "2015-04-04",
+      "value": 2,
+      "avg_cvss": 4.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2015-04-05",
+      "value": 6,
+      "avg_cvss": 6.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2015-04-06",
+      "value": 15,
+      "avg_cvss": 6.5,
+      "cvss_count": 15
+    },
+    {
+      "date": "2015-04-07",
+      "value": 2,
+      "avg_cvss": 4.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2015-04-08",
+      "value": 22,
+      "avg_cvss": 5.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2015-04-10",
+      "value": 79,
+      "avg_cvss": 5.3,
+      "cvss_count": 79
+    },
+    {
+      "date": "2015-04-11",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-04-13",
+      "value": 19,
+      "avg_cvss": 5.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2015-04-14",
+      "value": 64,
+      "avg_cvss": 7.8,
+      "cvss_count": 64
+    },
+    {
+      "date": "2015-04-15",
+      "value": 10,
+      "avg_cvss": 5.8,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-04-16",
+      "value": 92,
+      "avg_cvss": 4.7,
+      "cvss_count": 92
+    },
+    {
+      "date": "2015-04-17",
+      "value": 10,
+      "avg_cvss": 6.5,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-04-18",
+      "value": 4,
+      "avg_cvss": 6.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2015-04-19",
+      "value": 17,
+      "avg_cvss": 5.8,
+      "cvss_count": 17
+    },
+    {
+      "date": "2015-04-21",
+      "value": 64,
+      "avg_cvss": 5.2,
+      "cvss_count": 64
+    },
+    {
+      "date": "2015-04-22",
+      "value": 6,
+      "avg_cvss": 6.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "2015-04-23",
+      "value": 2,
+      "avg_cvss": 4.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2015-04-24",
+      "value": 17,
+      "avg_cvss": 6.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2015-04-27",
+      "value": 14,
+      "avg_cvss": 6.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2015-04-28",
+      "value": 5,
+      "avg_cvss": 5.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2015-04-29",
+      "value": 15,
+      "avg_cvss": 5.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2015-05-01",
+      "value": 18,
+      "avg_cvss": 6.2,
+      "cvss_count": 18
+    },
+    {
+      "date": "2015-05-02",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2015-05-07",
+      "value": 6,
+      "avg_cvss": 7.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2015-05-08",
+      "value": 13,
+      "avg_cvss": 5.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2015-05-12",
+      "value": 28,
+      "avg_cvss": 6.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2015-05-13",
+      "value": 95,
+      "avg_cvss": 8.1,
+      "cvss_count": 95
+    },
+    {
+      "date": "2015-05-14",
+      "value": 29,
+      "avg_cvss": 5.8,
+      "cvss_count": 29
+    },
+    {
+      "date": "2015-05-15",
+      "value": 9,
+      "avg_cvss": 5.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-05-16",
+      "value": 7,
+      "avg_cvss": 6.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2015-05-17",
+      "value": 3,
+      "avg_cvss": 6.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-05-18",
+      "value": 13,
+      "avg_cvss": 7.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2015-05-19",
+      "value": 9,
+      "avg_cvss": 6.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-05-20",
+      "value": 35,
+      "avg_cvss": 6.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2015-05-21",
+      "value": 9,
+      "avg_cvss": 6.3,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-05-22",
+      "value": 3,
+      "avg_cvss": 5.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-05-23",
+      "value": 1,
+      "avg_cvss": 6.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2015-05-25",
+      "value": 43,
+      "avg_cvss": 6.2,
+      "cvss_count": 43
+    },
+    {
+      "date": "2015-05-26",
+      "value": 16,
+      "avg_cvss": 6.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2015-05-27",
+      "value": 15,
+      "avg_cvss": 5.3,
+      "cvss_count": 15
+    },
+    {
+      "date": "2015-05-28",
+      "value": 13,
+      "avg_cvss": 5.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2015-05-29",
+      "value": 24,
+      "avg_cvss": 7.2,
+      "cvss_count": 24
+    },
+    {
+      "date": "2015-05-30",
+      "value": 15,
+      "avg_cvss": 5.1,
+      "cvss_count": 15
+    },
+    {
+      "date": "2015-05-31",
+      "value": 5,
+      "avg_cvss": 6.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2015-06-01",
+      "value": 25,
+      "avg_cvss": 4.5,
+      "cvss_count": 25
+    },
+    {
+      "date": "2015-06-02",
+      "value": 19,
+      "avg_cvss": 5.7,
+      "cvss_count": 19
+    },
+    {
+      "date": "2015-06-03",
+      "value": 8,
+      "avg_cvss": 5.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-06-04",
+      "value": 7,
+      "avg_cvss": 5.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2015-06-05",
+      "value": 7,
+      "avg_cvss": 6.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2015-06-07",
+      "value": 16,
+      "avg_cvss": 6.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2015-06-08",
+      "value": 14,
+      "avg_cvss": 6.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2015-06-09",
+      "value": 26,
+      "avg_cvss": 6.7,
+      "cvss_count": 26
+    },
+    {
+      "date": "2015-06-10",
+      "value": 70,
+      "avg_cvss": 7.3,
+      "cvss_count": 70
+    },
+    {
+      "date": "2015-06-11",
+      "value": 7,
+      "avg_cvss": 4.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2015-06-12",
+      "value": 16,
+      "avg_cvss": 5.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2015-06-13",
+      "value": 22,
+      "avg_cvss": 6.0,
+      "cvss_count": 22
+    },
+    {
+      "date": "2015-06-15",
+      "value": 67,
+      "avg_cvss": 4.8,
+      "cvss_count": 67
+    },
+    {
+      "date": "2015-06-16",
+      "value": 15,
+      "avg_cvss": 5.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2015-06-17",
+      "value": 19,
+      "avg_cvss": 5.6,
+      "cvss_count": 19
+    },
+    {
+      "date": "2015-06-18",
+      "value": 16,
+      "avg_cvss": 5.3,
+      "cvss_count": 16
+    },
+    {
+      "date": "2015-06-19",
+      "value": 11,
+      "avg_cvss": 6.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2015-06-20",
+      "value": 4,
+      "avg_cvss": 5.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2015-06-22",
+      "value": 10,
+      "avg_cvss": 5.1,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-06-23",
+      "value": 16,
+      "avg_cvss": 6.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2015-06-24",
+      "value": 27,
+      "avg_cvss": 5.9,
+      "cvss_count": 27
+    },
+    {
+      "date": "2015-06-25",
+      "value": 3,
+      "avg_cvss": 5.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-06-26",
+      "value": 11,
+      "avg_cvss": 5.5,
+      "cvss_count": 11
+    },
+    {
+      "date": "2015-06-27",
+      "value": 2,
+      "avg_cvss": 5.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2015-06-28",
+      "value": 25,
+      "avg_cvss": 4.5,
+      "cvss_count": 25
+    },
+    {
+      "date": "2015-06-29",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-06-30",
+      "value": 29,
+      "avg_cvss": 7.2,
+      "cvss_count": 29
+    },
+    {
+      "date": "2015-07-01",
+      "value": 17,
+      "avg_cvss": 5.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2015-07-02",
+      "value": 9,
+      "avg_cvss": 5.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-07-03",
+      "value": 75,
+      "avg_cvss": 6.6,
+      "cvss_count": 75
+    },
+    {
+      "date": "2015-07-04",
+      "value": 7,
+      "avg_cvss": 5.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2015-07-05",
+      "value": 5,
+      "avg_cvss": 6.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2015-07-06",
+      "value": 39,
+      "avg_cvss": 7.3,
+      "cvss_count": 39
+    },
+    {
+      "date": "2015-07-07",
+      "value": 3,
+      "avg_cvss": 5.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-07-08",
+      "value": 22,
+      "avg_cvss": 6.1,
+      "cvss_count": 22
+    },
+    {
+      "date": "2015-07-09",
+      "value": 36,
+      "avg_cvss": 8.9,
+      "cvss_count": 36
+    },
+    {
+      "date": "2015-07-10",
+      "value": 18,
+      "avg_cvss": 5.9,
+      "cvss_count": 18
+    },
+    {
+      "date": "2015-07-13",
+      "value": 1,
+      "avg_cvss": 9.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2015-07-14",
+      "value": 88,
+      "avg_cvss": 7.0,
+      "cvss_count": 88
+    },
+    {
+      "date": "2015-07-15",
+      "value": 48,
+      "avg_cvss": 8.1,
+      "cvss_count": 48
+    },
+    {
+      "date": "2015-07-16",
+      "value": 172,
+      "avg_cvss": 5.5,
+      "cvss_count": 172
+    },
+    {
+      "date": "2015-07-18",
+      "value": 5,
+      "avg_cvss": 6.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2015-07-19",
+      "value": 2,
+      "avg_cvss": 6.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2015-07-20",
+      "value": 22,
+      "avg_cvss": 5.4,
+      "cvss_count": 22
+    },
+    {
+      "date": "2015-07-21",
+      "value": 8,
+      "avg_cvss": 5.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-07-22",
+      "value": 6,
+      "avg_cvss": 4.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2015-07-23",
+      "value": 23,
+      "avg_cvss": 6.4,
+      "cvss_count": 23
+    },
+    {
+      "date": "2015-07-24",
+      "value": 4,
+      "avg_cvss": 7.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "2015-07-25",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2015-07-26",
+      "value": 10,
+      "avg_cvss": 5.2,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-07-27",
+      "value": 1,
+      "avg_cvss": 4.9,
+      "cvss_count": 1
+    },
+    {
+      "date": "2015-07-29",
+      "value": 10,
+      "avg_cvss": 5.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-07-30",
+      "value": 3,
+      "avg_cvss": 6.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-08-01",
+      "value": 18,
+      "avg_cvss": 5.7,
+      "cvss_count": 18
+    },
+    {
+      "date": "2015-08-03",
+      "value": 18,
+      "avg_cvss": 6.6,
+      "cvss_count": 18
+    },
+    {
+      "date": "2015-08-04",
+      "value": 32,
+      "avg_cvss": 9.1,
+      "cvss_count": 32
+    },
+    {
+      "date": "2015-08-05",
+      "value": 3,
+      "avg_cvss": 4.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-08-06",
+      "value": 1,
+      "avg_cvss": 4.9,
+      "cvss_count": 1
+    },
+    {
+      "date": "2015-08-07",
+      "value": 1,
+      "avg_cvss": 9.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2015-08-08",
+      "value": 10,
+      "avg_cvss": 5.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-08-11",
+      "value": 13,
+      "avg_cvss": 5.4,
+      "cvss_count": 13
+    },
+    {
+      "date": "2015-08-12",
+      "value": 20,
+      "avg_cvss": 5.5,
+      "cvss_count": 20
+    },
+    {
+      "date": "2015-08-13",
+      "value": 8,
+      "avg_cvss": 6.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-08-14",
+      "value": 55,
+      "avg_cvss": 8.8,
+      "cvss_count": 55
+    },
+    {
+      "date": "2015-08-15",
+      "value": 40,
+      "avg_cvss": 7.3,
+      "cvss_count": 40
+    },
+    {
+      "date": "2015-08-16",
+      "value": 81,
+      "avg_cvss": 6.4,
+      "cvss_count": 81
+    },
+    {
+      "date": "2015-08-17",
+      "value": 55,
+      "avg_cvss": 6.6,
+      "cvss_count": 55
+    },
+    {
+      "date": "2015-08-18",
+      "value": 50,
+      "avg_cvss": 5.0,
+      "cvss_count": 50
+    },
+    {
+      "date": "2015-08-19",
+      "value": 19,
+      "avg_cvss": 6.0,
+      "cvss_count": 19
+    },
+    {
+      "date": "2015-08-20",
+      "value": 29,
+      "avg_cvss": 6.3,
+      "cvss_count": 29
+    },
+    {
+      "date": "2015-08-22",
+      "value": 15,
+      "avg_cvss": 5.8,
+      "cvss_count": 15
+    },
+    {
+      "date": "2015-08-23",
+      "value": 14,
+      "avg_cvss": 5.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2015-08-24",
+      "value": 45,
+      "avg_cvss": 6.1,
+      "cvss_count": 45
+    },
+    {
+      "date": "2015-08-25",
+      "value": 8,
+      "avg_cvss": 6.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-08-26",
+      "value": 12,
+      "avg_cvss": 5.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2015-08-27",
+      "value": 16,
+      "avg_cvss": 6.3,
+      "cvss_count": 16
+    },
+    {
+      "date": "2015-08-28",
+      "value": 4,
+      "avg_cvss": 6.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2015-08-29",
+      "value": 5,
+      "avg_cvss": 8.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2015-08-30",
+      "value": 3,
+      "avg_cvss": 6.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-08-31",
+      "value": 44,
+      "avg_cvss": 5.3,
+      "cvss_count": 44
+    },
+    {
+      "date": "2015-09-01",
+      "value": 14,
+      "avg_cvss": 5.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2015-09-02",
+      "value": 6,
+      "avg_cvss": 5.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2015-09-03",
+      "value": 26,
+      "avg_cvss": 6.0,
+      "cvss_count": 26
+    },
+    {
+      "date": "2015-09-04",
+      "value": 12,
+      "avg_cvss": 6.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2015-09-05",
+      "value": 7,
+      "avg_cvss": 5.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2015-09-06",
+      "value": 9,
+      "avg_cvss": 7.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-09-07",
+      "value": 3,
+      "avg_cvss": 5.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-09-08",
+      "value": 7,
+      "avg_cvss": 6.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2015-09-09",
+      "value": 54,
+      "avg_cvss": 7.5,
+      "cvss_count": 54
+    },
+    {
+      "date": "2015-09-11",
+      "value": 23,
+      "avg_cvss": 6.4,
+      "cvss_count": 23
+    },
+    {
+      "date": "2015-09-14",
+      "value": 13,
+      "avg_cvss": 6.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2015-09-15",
+      "value": 8,
+      "avg_cvss": 7.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-09-16",
+      "value": 18,
+      "avg_cvss": 6.0,
+      "cvss_count": 18
+    },
+    {
+      "date": "2015-09-17",
+      "value": 15,
+      "avg_cvss": 4.8,
+      "cvss_count": 15
+    },
+    {
+      "date": "2015-09-18",
+      "value": 113,
+      "avg_cvss": 5.8,
+      "cvss_count": 113
+    },
+    {
+      "date": "2015-09-20",
+      "value": 26,
+      "avg_cvss": 6.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2015-09-21",
+      "value": 19,
+      "avg_cvss": 5.5,
+      "cvss_count": 19
+    },
+    {
+      "date": "2015-09-22",
+      "value": 26,
+      "avg_cvss": 8.7,
+      "cvss_count": 26
+    },
+    {
+      "date": "2015-09-24",
+      "value": 30,
+      "avg_cvss": 6.5,
+      "cvss_count": 30
+    },
+    {
+      "date": "2015-09-25",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2015-09-26",
+      "value": 15,
+      "avg_cvss": 5.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2015-09-28",
+      "value": 31,
+      "avg_cvss": 6.6,
+      "cvss_count": 31
+    },
+    {
+      "date": "2015-09-29",
+      "value": 14,
+      "avg_cvss": 5.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2015-09-30",
+      "value": 2,
+      "avg_cvss": 5.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2015-10-01",
+      "value": 36,
+      "avg_cvss": 8.4,
+      "cvss_count": 36
+    },
+    {
+      "date": "2015-10-02",
+      "value": 7,
+      "avg_cvss": 7.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2015-10-03",
+      "value": 10,
+      "avg_cvss": 4.1,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-10-04",
+      "value": 15,
+      "avg_cvss": 4.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2015-10-05",
+      "value": 9,
+      "avg_cvss": 6.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-10-06",
+      "value": 57,
+      "avg_cvss": 7.2,
+      "cvss_count": 57
+    },
+    {
+      "date": "2015-10-08",
+      "value": 3,
+      "avg_cvss": 6.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-10-09",
+      "value": 49,
+      "avg_cvss": 5.7,
+      "cvss_count": 49
+    },
+    {
+      "date": "2015-10-11",
+      "value": 4,
+      "avg_cvss": 5.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2015-10-12",
+      "value": 16,
+      "avg_cvss": 6.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2015-10-13",
+      "value": 3,
+      "avg_cvss": 6.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-10-14",
+      "value": 98,
+      "avg_cvss": 6.8,
+      "cvss_count": 98
+    },
+    {
+      "date": "2015-10-15",
+      "value": 33,
+      "avg_cvss": 7.6,
+      "cvss_count": 33
+    },
+    {
+      "date": "2015-10-16",
+      "value": 21,
+      "avg_cvss": 5.8,
+      "cvss_count": 21
+    },
+    {
+      "date": "2015-10-18",
+      "value": 23,
+      "avg_cvss": 7.6,
+      "cvss_count": 23
+    },
+    {
+      "date": "2015-10-19",
+      "value": 18,
+      "avg_cvss": 5.9,
+      "cvss_count": 18
+    },
+    {
+      "date": "2015-10-21",
+      "value": 119,
+      "avg_cvss": 5.2,
+      "cvss_count": 119
+    },
+    {
+      "date": "2015-10-22",
+      "value": 17,
+      "avg_cvss": 4.9,
+      "cvss_count": 17
+    },
+    {
+      "date": "2015-10-23",
+      "value": 71,
+      "avg_cvss": 6.8,
+      "cvss_count": 71
+    },
+    {
+      "date": "2015-10-25",
+      "value": 11,
+      "avg_cvss": 6.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2015-10-26",
+      "value": 24,
+      "avg_cvss": 5.3,
+      "cvss_count": 24
+    },
+    {
+      "date": "2015-10-27",
+      "value": 9,
+      "avg_cvss": 5.1,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-10-28",
+      "value": 26,
+      "avg_cvss": 6.0,
+      "cvss_count": 26
+    },
+    {
+      "date": "2015-10-29",
+      "value": 22,
+      "avg_cvss": 6.4,
+      "cvss_count": 22
+    },
+    {
+      "date": "2015-10-30",
+      "value": 19,
+      "avg_cvss": 4.8,
+      "cvss_count": 19
+    },
+    {
+      "date": "2015-10-31",
+      "value": 6,
+      "avg_cvss": 5.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2015-11-02",
+      "value": 14,
+      "avg_cvss": 6.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2015-11-03",
+      "value": 10,
+      "avg_cvss": 8.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-11-04",
+      "value": 13,
+      "avg_cvss": 6.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2015-11-05",
+      "value": 23,
+      "avg_cvss": 6.4,
+      "cvss_count": 23
+    },
+    {
+      "date": "2015-11-06",
+      "value": 22,
+      "avg_cvss": 6.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2015-11-07",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2015-11-08",
+      "value": 19,
+      "avg_cvss": 5.0,
+      "cvss_count": 19
+    },
+    {
+      "date": "2015-11-09",
+      "value": 24,
+      "avg_cvss": 5.4,
+      "cvss_count": 24
+    },
+    {
+      "date": "2015-11-10",
+      "value": 14,
+      "avg_cvss": 5.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2015-11-11",
+      "value": 67,
+      "avg_cvss": 8.2,
+      "cvss_count": 67
+    },
+    {
+      "date": "2015-11-12",
+      "value": 9,
+      "avg_cvss": 6.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-11-13",
+      "value": 6,
+      "avg_cvss": 7.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "2015-11-14",
+      "value": 8,
+      "avg_cvss": 5.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-11-15",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2015-11-16",
+      "value": 13,
+      "avg_cvss": 5.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2015-11-17",
+      "value": 21,
+      "avg_cvss": 5.9,
+      "cvss_count": 21
+    },
+    {
+      "date": "2015-11-18",
+      "value": 17,
+      "avg_cvss": 5.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "2015-11-19",
+      "value": 15,
+      "avg_cvss": 5.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2015-11-20",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-11-21",
+      "value": 9,
+      "avg_cvss": 6.1,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-11-22",
+      "value": 3,
+      "avg_cvss": 5.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-11-23",
+      "value": 3,
+      "avg_cvss": 5.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-11-24",
+      "value": 18,
+      "avg_cvss": 6.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2015-11-25",
+      "value": 19,
+      "avg_cvss": 6.2,
+      "cvss_count": 19
+    },
+    {
+      "date": "2015-11-26",
+      "value": 5,
+      "avg_cvss": 6.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2015-11-27",
+      "value": 2,
+      "avg_cvss": 9.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2015-12-01",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2015-12-02",
+      "value": 19,
+      "avg_cvss": 8.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2015-12-03",
+      "value": 8,
+      "avg_cvss": 6.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2015-12-05",
+      "value": 6,
+      "avg_cvss": 5.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2015-12-06",
+      "value": 32,
+      "avg_cvss": 6.9,
+      "cvss_count": 32
+    },
+    {
+      "date": "2015-12-07",
+      "value": 17,
+      "avg_cvss": 5.6,
+      "cvss_count": 17
+    },
+    {
+      "date": "2015-12-08",
+      "value": 22,
+      "avg_cvss": 6.9,
+      "cvss_count": 22
+    },
+    {
+      "date": "2015-12-09",
+      "value": 58,
+      "avg_cvss": 8.1,
+      "cvss_count": 58
+    },
+    {
+      "date": "2015-12-10",
+      "value": 79,
+      "avg_cvss": 9.8,
+      "cvss_count": 79
+    },
+    {
+      "date": "2015-12-11",
+      "value": 72,
+      "avg_cvss": 6.6,
+      "cvss_count": 72
+    },
+    {
+      "date": "2015-12-12",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2015-12-13",
+      "value": 9,
+      "avg_cvss": 5.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-12-14",
+      "value": 11,
+      "avg_cvss": 6.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2015-12-15",
+      "value": 23,
+      "avg_cvss": 6.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2015-12-16",
+      "value": 38,
+      "avg_cvss": 6.7,
+      "cvss_count": 38
+    },
+    {
+      "date": "2015-12-17",
+      "value": 15,
+      "avg_cvss": 6.1,
+      "cvss_count": 15
+    },
+    {
+      "date": "2015-12-18",
+      "value": 5,
+      "avg_cvss": 5.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2015-12-19",
+      "value": 3,
+      "avg_cvss": 6.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2015-12-21",
+      "value": 16,
+      "avg_cvss": 7.6,
+      "cvss_count": 16
+    },
+    {
+      "date": "2015-12-22",
+      "value": 1,
+      "avg_cvss": 6.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2015-12-23",
+      "value": 13,
+      "avg_cvss": 7.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2015-12-24",
+      "value": 10,
+      "avg_cvss": 8.8,
+      "cvss_count": 10
+    },
+    {
+      "date": "2015-12-26",
+      "value": 2,
+      "avg_cvss": 5.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2015-12-27",
+      "value": 11,
+      "avg_cvss": 6.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2015-12-28",
+      "value": 30,
+      "avg_cvss": 7.4,
+      "cvss_count": 30
+    },
+    {
+      "date": "2015-12-29",
+      "value": 9,
+      "avg_cvss": 6.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2015-12-30",
+      "value": 16,
+      "avg_cvss": 6.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2015-12-31",
+      "value": 33,
+      "avg_cvss": 7.8,
+      "cvss_count": 33
+    },
+    {
+      "date": "2016-01-01",
+      "value": 12,
+      "avg_cvss": 5.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2016-01-02",
+      "value": 27,
+      "avg_cvss": 6.1,
+      "cvss_count": 27
+    },
+    {
+      "date": "2016-01-03",
+      "value": 16,
+      "avg_cvss": 5.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2016-01-04",
+      "value": 33,
+      "avg_cvss": 5.5,
+      "cvss_count": 33
+    },
+    {
+      "date": "2016-01-05",
+      "value": 10,
+      "avg_cvss": 7.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2016-01-06",
+      "value": 13,
+      "avg_cvss": 6.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-01-08",
+      "value": 47,
+      "avg_cvss": 6.9,
+      "cvss_count": 47
+    },
+    {
+      "date": "2016-01-09",
+      "value": 16,
+      "avg_cvss": 6.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2016-01-10",
+      "value": 5,
+      "avg_cvss": 5.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-01-11",
+      "value": 10,
+      "avg_cvss": 7.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2016-01-12",
+      "value": 24,
+      "avg_cvss": 7.0,
+      "cvss_count": 24
+    },
+    {
+      "date": "2016-01-13",
+      "value": 28,
+      "avg_cvss": 7.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2016-01-14",
+      "value": 20,
+      "avg_cvss": 8.8,
+      "cvss_count": 20
+    },
+    {
+      "date": "2016-01-15",
+      "value": 40,
+      "avg_cvss": 7.1,
+      "cvss_count": 40
+    },
+    {
+      "date": "2016-01-16",
+      "value": 7,
+      "avg_cvss": 6.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2016-01-17",
+      "value": 7,
+      "avg_cvss": 4.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2016-01-18",
+      "value": 8,
+      "avg_cvss": 5.9,
+      "cvss_count": 8
+    },
+    {
+      "date": "2016-01-19",
+      "value": 11,
+      "avg_cvss": 7.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2016-01-20",
+      "value": 13,
+      "avg_cvss": 6.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-01-21",
+      "value": 216,
+      "avg_cvss": 5.0,
+      "cvss_count": 216
+    },
+    {
+      "date": "2016-01-22",
+      "value": 15,
+      "avg_cvss": 8.5,
+      "cvss_count": 15
+    },
+    {
+      "date": "2016-01-23",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-01-25",
+      "value": 11,
+      "avg_cvss": 6.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2016-01-26",
+      "value": 12,
+      "avg_cvss": 6.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2016-01-27",
+      "value": 15,
+      "avg_cvss": 6.8,
+      "cvss_count": 15
+    },
+    {
+      "date": "2016-01-28",
+      "value": 1,
+      "avg_cvss": 9.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2016-01-29",
+      "value": 19,
+      "avg_cvss": 6.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2016-01-30",
+      "value": 15,
+      "avg_cvss": 6.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2016-01-31",
+      "value": 16,
+      "avg_cvss": 7.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2016-02-01",
+      "value": 21,
+      "avg_cvss": 7.6,
+      "cvss_count": 21
+    },
+    {
+      "date": "2016-02-03",
+      "value": 12,
+      "avg_cvss": 8.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2016-02-04",
+      "value": 2,
+      "avg_cvss": 6.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-02-05",
+      "value": 2,
+      "avg_cvss": 7.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-02-06",
+      "value": 6,
+      "avg_cvss": 7.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-02-07",
+      "value": 20,
+      "avg_cvss": 7.8,
+      "cvss_count": 20
+    },
+    {
+      "date": "2016-02-08",
+      "value": 27,
+      "avg_cvss": 6.8,
+      "cvss_count": 27
+    },
+    {
+      "date": "2016-02-09",
+      "value": 4,
+      "avg_cvss": 5.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-02-10",
+      "value": 71,
+      "avg_cvss": 7.9,
+      "cvss_count": 71
+    },
+    {
+      "date": "2016-02-11",
+      "value": 1,
+      "avg_cvss": 9.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2016-02-12",
+      "value": 14,
+      "avg_cvss": 7.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2016-02-13",
+      "value": 14,
+      "avg_cvss": 7.7,
+      "cvss_count": 14
+    },
+    {
+      "date": "2016-02-14",
+      "value": 6,
+      "avg_cvss": 7.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-02-15",
+      "value": 30,
+      "avg_cvss": 6.1,
+      "cvss_count": 30
+    },
+    {
+      "date": "2016-02-16",
+      "value": 13,
+      "avg_cvss": 6.4,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-02-17",
+      "value": 27,
+      "avg_cvss": 6.6,
+      "cvss_count": 27
+    },
+    {
+      "date": "2016-02-18",
+      "value": 14,
+      "avg_cvss": 7.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2016-02-19",
+      "value": 6,
+      "avg_cvss": 6.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-02-20",
+      "value": 9,
+      "avg_cvss": 5.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2016-02-21",
+      "value": 4,
+      "avg_cvss": 9.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-02-22",
+      "value": 27,
+      "avg_cvss": 5.7,
+      "cvss_count": 27
+    },
+    {
+      "date": "2016-02-23",
+      "value": 6,
+      "avg_cvss": 8.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-02-24",
+      "value": 3,
+      "avg_cvss": 9.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2016-02-25",
+      "value": 7,
+      "avg_cvss": 6.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2016-02-26",
+      "value": 2,
+      "avg_cvss": 7.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-02-27",
+      "value": 8,
+      "avg_cvss": 8.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2016-02-28",
+      "value": 12,
+      "avg_cvss": 6.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2016-02-29",
+      "value": 12,
+      "avg_cvss": 6.7,
+      "cvss_count": 12
+    },
+    {
+      "date": "2016-03-01",
+      "value": 6,
+      "avg_cvss": 5.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-03-02",
+      "value": 4,
+      "avg_cvss": 6.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-03-03",
+      "value": 19,
+      "avg_cvss": 7.0,
+      "cvss_count": 19
+    },
+    {
+      "date": "2016-03-04",
+      "value": 14,
+      "avg_cvss": 8.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2016-03-06",
+      "value": 16,
+      "avg_cvss": 8.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2016-03-09",
+      "value": 53,
+      "avg_cvss": 7.7,
+      "cvss_count": 53
+    },
+    {
+      "date": "2016-03-12",
+      "value": 49,
+      "avg_cvss": 7.8,
+      "cvss_count": 49
+    },
+    {
+      "date": "2016-03-13",
+      "value": 47,
+      "avg_cvss": 8.0,
+      "cvss_count": 47
+    },
+    {
+      "date": "2016-03-14",
+      "value": 5,
+      "avg_cvss": 5.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-03-15",
+      "value": 2,
+      "avg_cvss": 9.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-03-16",
+      "value": 5,
+      "avg_cvss": 6.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-03-17",
+      "value": 4,
+      "avg_cvss": 8.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-03-18",
+      "value": 11,
+      "avg_cvss": 7.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2016-03-19",
+      "value": 4,
+      "avg_cvss": 7.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-03-21",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2016-03-22",
+      "value": 4,
+      "avg_cvss": 8.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-03-24",
+      "value": 62,
+      "avg_cvss": 6.8,
+      "cvss_count": 62
+    },
+    {
+      "date": "2016-03-25",
+      "value": 1,
+      "avg_cvss": 5.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2016-03-26",
+      "value": 7,
+      "avg_cvss": 6.8,
+      "cvss_count": 7
+    },
+    {
+      "date": "2016-03-28",
+      "value": 4,
+      "avg_cvss": 7.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-03-29",
+      "value": 8,
+      "avg_cvss": 8.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2016-03-30",
+      "value": 2,
+      "avg_cvss": 7.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-03-31",
+      "value": 2,
+      "avg_cvss": 9.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-04-01",
+      "value": 6,
+      "avg_cvss": 8.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-04-05",
+      "value": 12,
+      "avg_cvss": 7.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2016-04-06",
+      "value": 22,
+      "avg_cvss": 7.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2016-04-07",
+      "value": 36,
+      "avg_cvss": 7.5,
+      "cvss_count": 36
+    },
+    {
+      "date": "2016-04-08",
+      "value": 21,
+      "avg_cvss": 7.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2016-04-09",
+      "value": 23,
+      "avg_cvss": 8.7,
+      "cvss_count": 23
+    },
+    {
+      "date": "2016-04-11",
+      "value": 40,
+      "avg_cvss": 7.2,
+      "cvss_count": 40
+    },
+    {
+      "date": "2016-04-12",
+      "value": 85,
+      "avg_cvss": 7.4,
+      "cvss_count": 85
+    },
+    {
+      "date": "2016-04-13",
+      "value": 54,
+      "avg_cvss": 6.9,
+      "cvss_count": 54
+    },
+    {
+      "date": "2016-04-14",
+      "value": 21,
+      "avg_cvss": 7.0,
+      "cvss_count": 21
+    },
+    {
+      "date": "2016-04-15",
+      "value": 19,
+      "avg_cvss": 7.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2016-04-16",
+      "value": 2,
+      "avg_cvss": 8.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-04-18",
+      "value": 55,
+      "avg_cvss": 7.6,
+      "cvss_count": 55
+    },
+    {
+      "date": "2016-04-19",
+      "value": 14,
+      "avg_cvss": 7.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2016-04-20",
+      "value": 10,
+      "avg_cvss": 7.1,
+      "cvss_count": 10
+    },
+    {
+      "date": "2016-04-21",
+      "value": 118,
+      "avg_cvss": 6.4,
+      "cvss_count": 118
+    },
+    {
+      "date": "2016-04-22",
+      "value": 29,
+      "avg_cvss": 6.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2016-04-25",
+      "value": 29,
+      "avg_cvss": 6.5,
+      "cvss_count": 29
+    },
+    {
+      "date": "2016-04-26",
+      "value": 5,
+      "avg_cvss": 9.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-04-27",
+      "value": 28,
+      "avg_cvss": 6.1,
+      "cvss_count": 28
+    },
+    {
+      "date": "2016-04-28",
+      "value": 5,
+      "avg_cvss": 6.6,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-04-30",
+      "value": 19,
+      "avg_cvss": 7.4,
+      "cvss_count": 19
+    },
+    {
+      "date": "2016-05-01",
+      "value": 8,
+      "avg_cvss": 6.1,
+      "cvss_count": 8
+    },
+    {
+      "date": "2016-05-02",
+      "value": 36,
+      "avg_cvss": 6.0,
+      "cvss_count": 36
+    },
+    {
+      "date": "2016-05-03",
+      "value": 4,
+      "avg_cvss": 5.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-05-05",
+      "value": 25,
+      "avg_cvss": 7.1,
+      "cvss_count": 25
+    },
+    {
+      "date": "2016-05-06",
+      "value": 7,
+      "avg_cvss": 7.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2016-05-07",
+      "value": 18,
+      "avg_cvss": 7.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2016-05-09",
+      "value": 41,
+      "avg_cvss": 7.4,
+      "cvss_count": 41
+    },
+    {
+      "date": "2016-05-10",
+      "value": 5,
+      "avg_cvss": 7.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-05-11",
+      "value": 156,
+      "avg_cvss": 8.8,
+      "cvss_count": 156
+    },
+    {
+      "date": "2016-05-12",
+      "value": 5,
+      "avg_cvss": 5.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-05-13",
+      "value": 25,
+      "avg_cvss": 8.0,
+      "cvss_count": 25
+    },
+    {
+      "date": "2016-05-14",
+      "value": 25,
+      "avg_cvss": 7.8,
+      "cvss_count": 25
+    },
+    {
+      "date": "2016-05-15",
+      "value": 3,
+      "avg_cvss": 5.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2016-05-16",
+      "value": 27,
+      "avg_cvss": 8.3,
+      "cvss_count": 27
+    },
+    {
+      "date": "2016-05-17",
+      "value": 13,
+      "avg_cvss": 5.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-05-18",
+      "value": 4,
+      "avg_cvss": 6.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-05-19",
+      "value": 1,
+      "avg_cvss": 9.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2016-05-20",
+      "value": 84,
+      "avg_cvss": 7.2,
+      "cvss_count": 84
+    },
+    {
+      "date": "2016-05-21",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-05-22",
+      "value": 40,
+      "avg_cvss": 7.4,
+      "cvss_count": 40
+    },
+    {
+      "date": "2016-05-23",
+      "value": 28,
+      "avg_cvss": 7.2,
+      "cvss_count": 28
+    },
+    {
+      "date": "2016-05-24",
+      "value": 1,
+      "avg_cvss": 5.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2016-05-25",
+      "value": 13,
+      "avg_cvss": 7.4,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-05-26",
+      "value": 14,
+      "avg_cvss": 7.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2016-05-28",
+      "value": 3,
+      "avg_cvss": 6.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2016-05-29",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-05-30",
+      "value": 7,
+      "avg_cvss": 7.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2016-05-31",
+      "value": 15,
+      "avg_cvss": 7.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2016-06-01",
+      "value": 17,
+      "avg_cvss": 7.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2016-06-03",
+      "value": 8,
+      "avg_cvss": 7.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2016-06-04",
+      "value": 9,
+      "avg_cvss": 7.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2016-06-05",
+      "value": 36,
+      "avg_cvss": 7.3,
+      "cvss_count": 36
+    },
+    {
+      "date": "2016-06-06",
+      "value": 1,
+      "avg_cvss": 9.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2016-06-07",
+      "value": 21,
+      "avg_cvss": 7.5,
+      "cvss_count": 21
+    },
+    {
+      "date": "2016-06-08",
+      "value": 40,
+      "avg_cvss": 7.9,
+      "cvss_count": 40
+    },
+    {
+      "date": "2016-06-09",
+      "value": 12,
+      "avg_cvss": 8.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2016-06-10",
+      "value": 22,
+      "avg_cvss": 7.4,
+      "cvss_count": 22
+    },
+    {
+      "date": "2016-06-13",
+      "value": 74,
+      "avg_cvss": 7.6,
+      "cvss_count": 74
+    },
+    {
+      "date": "2016-06-14",
+      "value": 6,
+      "avg_cvss": 7.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-06-16",
+      "value": 94,
+      "avg_cvss": 8.1,
+      "cvss_count": 94
+    },
+    {
+      "date": "2016-06-17",
+      "value": 6,
+      "avg_cvss": 8.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-06-18",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2016-06-19",
+      "value": 37,
+      "avg_cvss": 6.5,
+      "cvss_count": 37
+    },
+    {
+      "date": "2016-06-20",
+      "value": 7,
+      "avg_cvss": 7.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2016-06-23",
+      "value": 9,
+      "avg_cvss": 6.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2016-06-24",
+      "value": 6,
+      "avg_cvss": 6.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-06-25",
+      "value": 14,
+      "avg_cvss": 6.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2016-06-26",
+      "value": 11,
+      "avg_cvss": 6.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2016-06-27",
+      "value": 14,
+      "avg_cvss": 7.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2016-06-28",
+      "value": 3,
+      "avg_cvss": 8.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2016-06-29",
+      "value": 18,
+      "avg_cvss": 7.2,
+      "cvss_count": 18
+    },
+    {
+      "date": "2016-06-30",
+      "value": 42,
+      "avg_cvss": 7.2,
+      "cvss_count": 42
+    },
+    {
+      "date": "2016-07-01",
+      "value": 5,
+      "avg_cvss": 7.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-07-02",
+      "value": 21,
+      "avg_cvss": 6.2,
+      "cvss_count": 21
+    },
+    {
+      "date": "2016-07-03",
+      "value": 46,
+      "avg_cvss": 7.2,
+      "cvss_count": 46
+    },
+    {
+      "date": "2016-07-04",
+      "value": 12,
+      "avg_cvss": 7.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2016-07-05",
+      "value": 8,
+      "avg_cvss": 6.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2016-07-06",
+      "value": 6,
+      "avg_cvss": 6.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-07-07",
+      "value": 7,
+      "avg_cvss": 7.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2016-07-08",
+      "value": 12,
+      "avg_cvss": 7.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2016-07-11",
+      "value": 100,
+      "avg_cvss": 7.5,
+      "cvss_count": 100
+    },
+    {
+      "date": "2016-07-12",
+      "value": 17,
+      "avg_cvss": 6.8,
+      "cvss_count": 17
+    },
+    {
+      "date": "2016-07-13",
+      "value": 131,
+      "avg_cvss": 8.2,
+      "cvss_count": 131
+    },
+    {
+      "date": "2016-07-15",
+      "value": 27,
+      "avg_cvss": 7.2,
+      "cvss_count": 27
+    },
+    {
+      "date": "2016-07-17",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-07-19",
+      "value": 10,
+      "avg_cvss": 7.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2016-07-21",
+      "value": 192,
+      "avg_cvss": 6.6,
+      "cvss_count": 192
+    },
+    {
+      "date": "2016-07-22",
+      "value": 68,
+      "avg_cvss": 7.4,
+      "cvss_count": 68
+    },
+    {
+      "date": "2016-07-23",
+      "value": 18,
+      "avg_cvss": 7.9,
+      "cvss_count": 18
+    },
+    {
+      "date": "2016-07-25",
+      "value": 10,
+      "avg_cvss": 9.2,
+      "cvss_count": 10
+    },
+    {
+      "date": "2016-07-26",
+      "value": 4,
+      "avg_cvss": 7.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-07-28",
+      "value": 10,
+      "avg_cvss": 7.3,
+      "cvss_count": 10
+    },
+    {
+      "date": "2016-08-01",
+      "value": 14,
+      "avg_cvss": 7.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2016-08-02",
+      "value": 14,
+      "avg_cvss": 7.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2016-08-03",
+      "value": 9,
+      "avg_cvss": 9.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2016-08-05",
+      "value": 84,
+      "avg_cvss": 7.2,
+      "cvss_count": 84
+    },
+    {
+      "date": "2016-08-06",
+      "value": 73,
+      "avg_cvss": 6.9,
+      "cvss_count": 73
+    },
+    {
+      "date": "2016-08-07",
+      "value": 50,
+      "avg_cvss": 8.2,
+      "cvss_count": 50
+    },
+    {
+      "date": "2016-08-08",
+      "value": 27,
+      "avg_cvss": 6.5,
+      "cvss_count": 27
+    },
+    {
+      "date": "2016-08-09",
+      "value": 32,
+      "avg_cvss": 6.8,
+      "cvss_count": 32
+    },
+    {
+      "date": "2016-08-10",
+      "value": 6,
+      "avg_cvss": 7.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-08-12",
+      "value": 4,
+      "avg_cvss": 6.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-08-13",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2016-08-18",
+      "value": 6,
+      "avg_cvss": 8.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-08-19",
+      "value": 17,
+      "avg_cvss": 7.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2016-08-22",
+      "value": 11,
+      "avg_cvss": 7.1,
+      "cvss_count": 11
+    },
+    {
+      "date": "2016-08-23",
+      "value": 5,
+      "avg_cvss": 7.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-08-24",
+      "value": 7,
+      "avg_cvss": 7.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2016-08-25",
+      "value": 8,
+      "avg_cvss": 7.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2016-08-26",
+      "value": 19,
+      "avg_cvss": 8.2,
+      "cvss_count": 19
+    },
+    {
+      "date": "2016-08-29",
+      "value": 1,
+      "avg_cvss": 6.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2016-08-30",
+      "value": 6,
+      "avg_cvss": 8.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-08-31",
+      "value": 13,
+      "avg_cvss": 8.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-09-01",
+      "value": 16,
+      "avg_cvss": 5.5,
+      "cvss_count": 16
+    },
+    {
+      "date": "2016-09-02",
+      "value": 19,
+      "avg_cvss": 7.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2016-09-03",
+      "value": 8,
+      "avg_cvss": 7.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2016-09-06",
+      "value": 5,
+      "avg_cvss": 7.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-09-07",
+      "value": 37,
+      "avg_cvss": 7.2,
+      "cvss_count": 37
+    },
+    {
+      "date": "2016-09-08",
+      "value": 4,
+      "avg_cvss": 5.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-09-09",
+      "value": 14,
+      "avg_cvss": 6.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2016-09-11",
+      "value": 61,
+      "avg_cvss": 7.0,
+      "cvss_count": 61
+    },
+    {
+      "date": "2016-09-12",
+      "value": 24,
+      "avg_cvss": 7.2,
+      "cvss_count": 24
+    },
+    {
+      "date": "2016-09-14",
+      "value": 76,
+      "avg_cvss": 7.5,
+      "cvss_count": 76
+    },
+    {
+      "date": "2016-09-16",
+      "value": 15,
+      "avg_cvss": 8.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2016-09-17",
+      "value": 16,
+      "avg_cvss": 8.3,
+      "cvss_count": 16
+    },
+    {
+      "date": "2016-09-18",
+      "value": 28,
+      "avg_cvss": 6.6,
+      "cvss_count": 28
+    },
+    {
+      "date": "2016-09-19",
+      "value": 9,
+      "avg_cvss": 7.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2016-09-20",
+      "value": 22,
+      "avg_cvss": 6.4,
+      "cvss_count": 22
+    },
+    {
+      "date": "2016-09-21",
+      "value": 43,
+      "avg_cvss": 7.7,
+      "cvss_count": 43
+    },
+    {
+      "date": "2016-09-22",
+      "value": 30,
+      "avg_cvss": 8.3,
+      "cvss_count": 30
+    },
+    {
+      "date": "2016-09-24",
+      "value": 11,
+      "avg_cvss": 7.7,
+      "cvss_count": 11
+    },
+    {
+      "date": "2016-09-25",
+      "value": 77,
+      "avg_cvss": 7.4,
+      "cvss_count": 77
+    },
+    {
+      "date": "2016-09-26",
+      "value": 57,
+      "avg_cvss": 6.5,
+      "cvss_count": 57
+    },
+    {
+      "date": "2016-09-27",
+      "value": 9,
+      "avg_cvss": 7.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2016-09-28",
+      "value": 3,
+      "avg_cvss": 8.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2016-09-29",
+      "value": 6,
+      "avg_cvss": 6.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-09-30",
+      "value": 5,
+      "avg_cvss": 6.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-10-01",
+      "value": 3,
+      "avg_cvss": 6.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2016-10-03",
+      "value": 45,
+      "avg_cvss": 7.1,
+      "cvss_count": 45
+    },
+    {
+      "date": "2016-10-05",
+      "value": 52,
+      "avg_cvss": 7.6,
+      "cvss_count": 52
+    },
+    {
+      "date": "2016-10-06",
+      "value": 42,
+      "avg_cvss": 7.9,
+      "cvss_count": 42
+    },
+    {
+      "date": "2016-10-07",
+      "value": 13,
+      "avg_cvss": 7.4,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-10-10",
+      "value": 108,
+      "avg_cvss": 6.9,
+      "cvss_count": 108
+    },
+    {
+      "date": "2016-10-13",
+      "value": 99,
+      "avg_cvss": 9.1,
+      "cvss_count": 99
+    },
+    {
+      "date": "2016-10-14",
+      "value": 38,
+      "avg_cvss": 6.9,
+      "cvss_count": 38
+    },
+    {
+      "date": "2016-10-16",
+      "value": 14,
+      "avg_cvss": 6.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2016-10-21",
+      "value": 10,
+      "avg_cvss": 8.2,
+      "cvss_count": 10
+    },
+    {
+      "date": "2016-10-22",
+      "value": 9,
+      "avg_cvss": 6.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2016-10-25",
+      "value": 162,
+      "avg_cvss": 6.2,
+      "cvss_count": 162
+    },
+    {
+      "date": "2016-10-26",
+      "value": 6,
+      "avg_cvss": 6.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-10-27",
+      "value": 18,
+      "avg_cvss": 7.2,
+      "cvss_count": 18
+    },
+    {
+      "date": "2016-10-28",
+      "value": 35,
+      "avg_cvss": 7.6,
+      "cvss_count": 35
+    },
+    {
+      "date": "2016-10-29",
+      "value": 6,
+      "avg_cvss": 7.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-10-30",
+      "value": 6,
+      "avg_cvss": 6.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-10-31",
+      "value": 13,
+      "avg_cvss": 7.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-11-01",
+      "value": 1,
+      "avg_cvss": 8.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2016-11-02",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2016-11-03",
+      "value": 22,
+      "avg_cvss": 8.1,
+      "cvss_count": 22
+    },
+    {
+      "date": "2016-11-04",
+      "value": 21,
+      "avg_cvss": 7.0,
+      "cvss_count": 21
+    },
+    {
+      "date": "2016-11-07",
+      "value": 2,
+      "avg_cvss": 7.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-11-08",
+      "value": 35,
+      "avg_cvss": 7.8,
+      "cvss_count": 35
+    },
+    {
+      "date": "2016-11-10",
+      "value": 75,
+      "avg_cvss": 7.2,
+      "cvss_count": 75
+    },
+    {
+      "date": "2016-11-11",
+      "value": 9,
+      "avg_cvss": 7.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2016-11-12",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-11-14",
+      "value": 7,
+      "avg_cvss": 8.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2016-11-15",
+      "value": 5,
+      "avg_cvss": 8.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-11-16",
+      "value": 13,
+      "avg_cvss": 6.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-11-17",
+      "value": 5,
+      "avg_cvss": 5.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2016-11-18",
+      "value": 6,
+      "avg_cvss": 8.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-11-19",
+      "value": 13,
+      "avg_cvss": 6.4,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-11-22",
+      "value": 10,
+      "avg_cvss": 9.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2016-11-23",
+      "value": 6,
+      "avg_cvss": 6.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-11-24",
+      "value": 11,
+      "avg_cvss": 4.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2016-11-25",
+      "value": 78,
+      "avg_cvss": 6.6,
+      "cvss_count": 78
+    },
+    {
+      "date": "2016-11-28",
+      "value": 15,
+      "avg_cvss": 6.8,
+      "cvss_count": 15
+    },
+    {
+      "date": "2016-11-29",
+      "value": 9,
+      "avg_cvss": 7.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2016-11-30",
+      "value": 40,
+      "avg_cvss": 5.8,
+      "cvss_count": 40
+    },
+    {
+      "date": "2016-12-01",
+      "value": 11,
+      "avg_cvss": 6.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2016-12-02",
+      "value": 2,
+      "avg_cvss": 7.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-12-03",
+      "value": 9,
+      "avg_cvss": 5.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2016-12-05",
+      "value": 7,
+      "avg_cvss": 8.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2016-12-06",
+      "value": 2,
+      "avg_cvss": 6.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-12-08",
+      "value": 13,
+      "avg_cvss": 7.2,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-12-09",
+      "value": 18,
+      "avg_cvss": 7.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2016-12-10",
+      "value": 18,
+      "avg_cvss": 5.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2016-12-11",
+      "value": 48,
+      "avg_cvss": 6.6,
+      "cvss_count": 48
+    },
+    {
+      "date": "2016-12-12",
+      "value": 34,
+      "avg_cvss": 7.1,
+      "cvss_count": 34
+    },
+    {
+      "date": "2016-12-13",
+      "value": 42,
+      "avg_cvss": 8.1,
+      "cvss_count": 42
+    },
+    {
+      "date": "2016-12-14",
+      "value": 42,
+      "avg_cvss": 7.0,
+      "cvss_count": 42
+    },
+    {
+      "date": "2016-12-15",
+      "value": 58,
+      "avg_cvss": 7.2,
+      "cvss_count": 58
+    },
+    {
+      "date": "2016-12-16",
+      "value": 25,
+      "avg_cvss": 7.7,
+      "cvss_count": 25
+    },
+    {
+      "date": "2016-12-17",
+      "value": 9,
+      "avg_cvss": 7.1,
+      "cvss_count": 9
+    },
+    {
+      "date": "2016-12-18",
+      "value": 13,
+      "avg_cvss": 6.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-12-19",
+      "value": 2,
+      "avg_cvss": 8.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-12-20",
+      "value": 44,
+      "avg_cvss": 7.1,
+      "cvss_count": 44
+    },
+    {
+      "date": "2016-12-21",
+      "value": 3,
+      "avg_cvss": 7.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2016-12-22",
+      "value": 6,
+      "avg_cvss": 7.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2016-12-23",
+      "value": 29,
+      "avg_cvss": 6.4,
+      "cvss_count": 29
+    },
+    {
+      "date": "2016-12-24",
+      "value": 4,
+      "avg_cvss": 7.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2016-12-25",
+      "value": 2,
+      "avg_cvss": 6.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-12-26",
+      "value": 3,
+      "avg_cvss": 8.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2016-12-27",
+      "value": 2,
+      "avg_cvss": 6.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "2016-12-28",
+      "value": 13,
+      "avg_cvss": 6.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2016-12-29",
+      "value": 43,
+      "avg_cvss": 6.9,
+      "cvss_count": 43
+    },
+    {
+      "date": "2016-12-30",
+      "value": 9,
+      "avg_cvss": 8.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2016-12-31",
+      "value": 6,
+      "avg_cvss": 6.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2017-01-01",
+      "value": 1,
+      "avg_cvss": 7.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2017-01-02",
+      "value": 4,
+      "avg_cvss": 7.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2017-01-03",
+      "value": 5,
+      "avg_cvss": 8.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2017-01-04",
+      "value": 19,
+      "avg_cvss": 8.4,
+      "cvss_count": 19
+    },
+    {
+      "date": "2017-01-05",
+      "value": 14,
+      "avg_cvss": 7.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2017-01-06",
+      "value": 53,
+      "avg_cvss": 7.3,
+      "cvss_count": 53
+    },
+    {
+      "date": "2017-01-09",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2017-01-10",
+      "value": 16,
+      "avg_cvss": 7.9,
+      "cvss_count": 16
+    },
+    {
+      "date": "2017-01-11",
+      "value": 52,
+      "avg_cvss": 7.8,
+      "cvss_count": 52
+    },
+    {
+      "date": "2017-01-12",
+      "value": 159,
+      "avg_cvss": 6.8,
+      "cvss_count": 159
+    },
+    {
+      "date": "2017-01-13",
+      "value": 41,
+      "avg_cvss": 6.8,
+      "cvss_count": 41
+    },
+    {
+      "date": "2017-01-14",
+      "value": 10,
+      "avg_cvss": 8.4,
+      "cvss_count": 10
+    },
+    {
+      "date": "2017-01-15",
+      "value": 10,
+      "avg_cvss": 6.8,
+      "cvss_count": 10
+    },
+    {
+      "date": "2017-01-16",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2017-01-17",
+      "value": 7,
+      "avg_cvss": 7.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2017-01-18",
+      "value": 61,
+      "avg_cvss": 7.0,
+      "cvss_count": 61
+    },
+    {
+      "date": "2017-01-19",
+      "value": 39,
+      "avg_cvss": 7.3,
+      "cvss_count": 39
+    },
+    {
+      "date": "2017-01-20",
+      "value": 25,
+      "avg_cvss": 6.3,
+      "cvss_count": 25
+    },
+    {
+      "date": "2017-01-21",
+      "value": 1,
+      "avg_cvss": 9.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2017-01-23",
+      "value": 97,
+      "avg_cvss": 7.9,
+      "cvss_count": 97
+    },
+    {
+      "date": "2017-01-24",
+      "value": 10,
+      "avg_cvss": 7.7,
+      "cvss_count": 10
+    },
+    {
+      "date": "2017-01-25",
+      "value": 10,
+      "avg_cvss": 8.3,
+      "cvss_count": 10
+    },
+    {
+      "date": "2017-01-26",
+      "value": 31,
+      "avg_cvss": 6.5,
+      "cvss_count": 31
+    },
+    {
+      "date": "2017-01-27",
+      "value": 261,
+      "avg_cvss": 7.0,
+      "cvss_count": 261
+    },
+    {
+      "date": "2017-01-28",
+      "value": 45,
+      "avg_cvss": 9.6,
+      "cvss_count": 45
+    },
+    {
+      "date": "2017-01-30",
+      "value": 57,
+      "avg_cvss": 7.2,
+      "cvss_count": 57
+    },
+    {
+      "date": "2017-01-31",
+      "value": 48,
+      "avg_cvss": 7.1,
+      "cvss_count": 48
+    },
+    {
+      "date": "2017-02-01",
+      "value": 143,
+      "avg_cvss": 6.3,
+      "cvss_count": 143
+    },
+    {
+      "date": "2017-02-02",
+      "value": 15,
+      "avg_cvss": 7.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2017-02-03",
+      "value": 44,
+      "avg_cvss": 6.2,
+      "cvss_count": 44
+    },
+    {
+      "date": "2017-02-04",
+      "value": 3,
+      "avg_cvss": 6.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2017-02-05",
+      "value": 3,
+      "avg_cvss": 7.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2017-02-06",
+      "value": 32,
+      "avg_cvss": 7.1,
+      "cvss_count": 32
+    },
+    {
+      "date": "2017-02-07",
+      "value": 34,
+      "avg_cvss": 7.5,
+      "cvss_count": 34
+    },
+    {
+      "date": "2017-02-08",
+      "value": 86,
+      "avg_cvss": 6.5,
+      "cvss_count": 86
+    },
+    {
+      "date": "2017-02-09",
+      "value": 52,
+      "avg_cvss": 7.3,
+      "cvss_count": 52
+    },
+    {
+      "date": "2017-02-10",
+      "value": 9,
+      "avg_cvss": 7.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2017-02-12",
+      "value": 6,
+      "avg_cvss": 6.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2017-02-13",
+      "value": 124,
+      "avg_cvss": 7.7,
+      "cvss_count": 124
+    },
+    {
+      "date": "2017-02-14",
+      "value": 4,
+      "avg_cvss": 6.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2017-02-15",
+      "value": 92,
+      "avg_cvss": 7.4,
+      "cvss_count": 92
+    },
+    {
+      "date": "2017-02-16",
+      "value": 6,
+      "avg_cvss": 6.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2017-02-17",
+      "value": 81,
+      "avg_cvss": 6.8,
+      "cvss_count": 81
+    },
+    {
+      "date": "2017-02-18",
+      "value": 3,
+      "avg_cvss": 6.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2017-02-20",
+      "value": 154,
+      "avg_cvss": 6.9,
+      "cvss_count": 154
+    },
+    {
+      "date": "2017-02-21",
+      "value": 21,
+      "avg_cvss": 7.8,
+      "cvss_count": 21
+    },
+    {
+      "date": "2017-02-22",
+      "value": 41,
+      "avg_cvss": 7.0,
+      "cvss_count": 41
+    },
+    {
+      "date": "2017-02-23",
+      "value": 8,
+      "avg_cvss": 7.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2017-02-24",
+      "value": 37,
+      "avg_cvss": 6.8,
+      "cvss_count": 37
+    },
+    {
+      "date": "2017-02-26",
+      "value": 1,
+      "avg_cvss": 8.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2017-02-27",
+      "value": 30,
+      "avg_cvss": 7.0,
+      "cvss_count": 30
+    },
+    {
+      "date": "2017-02-28",
+      "value": 12,
+      "avg_cvss": 7.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2017-03-01",
+      "value": 58,
+      "avg_cvss": 6.3,
+      "cvss_count": 58
+    },
+    {
+      "date": "2017-03-02",
+      "value": 48,
+      "avg_cvss": 7.0,
+      "cvss_count": 48
+    },
+    {
+      "date": "2017-03-03",
+      "value": 50,
+      "avg_cvss": 7.1,
+      "cvss_count": 50
+    },
+    {
+      "date": "2017-03-04",
+      "value": 8,
+      "avg_cvss": 7.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2017-03-05",
+      "value": 16,
+      "avg_cvss": 6.3,
+      "cvss_count": 16
+    },
+    {
+      "date": "2017-03-06",
+      "value": 16,
+      "avg_cvss": 7.0,
+      "cvss_count": 16
+    },
+    {
+      "date": "2017-03-07",
+      "value": 64,
+      "avg_cvss": 7.0,
+      "cvss_count": 64
+    },
+    {
+      "date": "2017-03-08",
+      "value": 109,
+      "avg_cvss": 6.5,
+      "cvss_count": 109
+    },
+    {
+      "date": "2017-03-09",
+      "value": 28,
+      "avg_cvss": 7.2,
+      "cvss_count": 28
+    },
+    {
+      "date": "2017-03-10",
+      "value": 24,
+      "avg_cvss": 7.7,
+      "cvss_count": 24
+    },
+    {
+      "date": "2017-03-11",
+      "value": 9,
+      "avg_cvss": 7.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2017-03-12",
+      "value": 12,
+      "avg_cvss": 6.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2017-03-13",
+      "value": 15,
+      "avg_cvss": 7.7,
+      "cvss_count": 15
+    },
+    {
+      "date": "2017-03-14",
+      "value": 64,
+      "avg_cvss": 7.1,
+      "cvss_count": 64
+    },
+    {
+      "date": "2017-03-15",
+      "value": 88,
+      "avg_cvss": 6.7,
+      "cvss_count": 88
+    },
+    {
+      "date": "2017-03-16",
+      "value": 20,
+      "avg_cvss": 7.0,
+      "cvss_count": 20
+    },
+    {
+      "date": "2017-03-17",
+      "value": 180,
+      "avg_cvss": 6.5,
+      "cvss_count": 180
+    },
+    {
+      "date": "2017-03-18",
+      "value": 3,
+      "avg_cvss": 8.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2017-03-19",
+      "value": 3,
+      "avg_cvss": 6.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2017-03-20",
+      "value": 63,
+      "avg_cvss": 6.8,
+      "cvss_count": 63
+    },
+    {
+      "date": "2017-03-21",
+      "value": 22,
+      "avg_cvss": 6.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2017-03-22",
+      "value": 29,
+      "avg_cvss": 7.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2017-03-23",
+      "value": 105,
+      "avg_cvss": 7.1,
+      "cvss_count": 105
+    },
+    {
+      "date": "2017-03-24",
+      "value": 47,
+      "avg_cvss": 7.6,
+      "cvss_count": 47
+    },
+    {
+      "date": "2017-03-25",
+      "value": 1,
+      "avg_cvss": 5.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2017-03-26",
+      "value": 9,
+      "avg_cvss": 6.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2017-03-27",
+      "value": 59,
+      "avg_cvss": 7.2,
+      "cvss_count": 59
+    },
+    {
+      "date": "2017-03-28",
+      "value": 39,
+      "avg_cvss": 6.8,
+      "cvss_count": 39
+    },
+    {
+      "date": "2017-03-29",
+      "value": 32,
+      "avg_cvss": 7.3,
+      "cvss_count": 32
+    },
+    {
+      "date": "2017-03-30",
+      "value": 45,
+      "avg_cvss": 7.3,
+      "cvss_count": 45
+    },
+    {
+      "date": "2017-03-31",
+      "value": 34,
+      "avg_cvss": 7.1,
+      "cvss_count": 34
+    },
+    {
+      "date": "2017-04-01",
+      "value": 11,
+      "avg_cvss": 6.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2017-04-02",
+      "value": 177,
+      "avg_cvss": 7.3,
+      "cvss_count": 177
+    },
+    {
+      "date": "2017-04-03",
+      "value": 48,
+      "avg_cvss": 6.9,
+      "cvss_count": 48
+    },
+    {
+      "date": "2017-04-04",
+      "value": 23,
+      "avg_cvss": 7.2,
+      "cvss_count": 23
+    },
+    {
+      "date": "2017-04-05",
+      "value": 34,
+      "avg_cvss": 6.5,
+      "cvss_count": 34
+    },
+    {
+      "date": "2017-04-06",
+      "value": 32,
+      "avg_cvss": 8.0,
+      "cvss_count": 32
+    },
+    {
+      "date": "2017-04-07",
+      "value": 87,
+      "avg_cvss": 6.8,
+      "cvss_count": 87
+    },
+    {
+      "date": "2017-04-09",
+      "value": 26,
+      "avg_cvss": 6.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2017-04-10",
+      "value": 98,
+      "avg_cvss": 7.7,
+      "cvss_count": 98
+    },
+    {
+      "date": "2017-04-11",
+      "value": 36,
+      "avg_cvss": 7.2,
+      "cvss_count": 36
+    },
+    {
+      "date": "2017-04-12",
+      "value": 154,
+      "avg_cvss": 7.2,
+      "cvss_count": 154
+    },
+    {
+      "date": "2017-04-13",
+      "value": 77,
+      "avg_cvss": 7.3,
+      "cvss_count": 77
+    },
+    {
+      "date": "2017-04-14",
+      "value": 60,
+      "avg_cvss": 7.7,
+      "cvss_count": 60
+    },
+    {
+      "date": "2017-04-15",
+      "value": 2,
+      "avg_cvss": 9.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2017-04-16",
+      "value": 1,
+      "avg_cvss": 8.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2017-04-17",
+      "value": 31,
+      "avg_cvss": 6.6,
+      "cvss_count": 31
+    },
+    {
+      "date": "2017-04-18",
+      "value": 14,
+      "avg_cvss": 6.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2017-04-19",
+      "value": 23,
+      "avg_cvss": 6.9,
+      "cvss_count": 23
+    },
+    {
+      "date": "2017-04-20",
+      "value": 101,
+      "avg_cvss": 6.8,
+      "cvss_count": 101
+    },
+    {
+      "date": "2017-04-21",
+      "value": 47,
+      "avg_cvss": 7.5,
+      "cvss_count": 47
+    },
+    {
+      "date": "2017-04-22",
+      "value": 6,
+      "avg_cvss": 6.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2017-04-23",
+      "value": 19,
+      "avg_cvss": 7.7,
+      "cvss_count": 19
+    },
+    {
+      "date": "2017-04-24",
+      "value": 281,
+      "avg_cvss": 6.6,
+      "cvss_count": 281
+    },
+    {
+      "date": "2017-04-25",
+      "value": 37,
+      "avg_cvss": 7.3,
+      "cvss_count": 37
+    },
+    {
+      "date": "2017-04-26",
+      "value": 11,
+      "avg_cvss": 6.7,
+      "cvss_count": 11
+    },
+    {
+      "date": "2017-04-27",
+      "value": 20,
+      "avg_cvss": 8.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2017-04-28",
+      "value": 76,
+      "avg_cvss": 6.8,
+      "cvss_count": 76
+    },
+    {
+      "date": "2017-04-29",
+      "value": 9,
+      "avg_cvss": 8.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2017-04-30",
+      "value": 29,
+      "avg_cvss": 7.2,
+      "cvss_count": 29
+    },
+    {
+      "date": "2017-05-01",
+      "value": 31,
+      "avg_cvss": 7.2,
+      "cvss_count": 31
+    },
+    {
+      "date": "2017-05-02",
+      "value": 21,
+      "avg_cvss": 7.2,
+      "cvss_count": 21
+    },
+    {
+      "date": "2017-05-03",
+      "value": 28,
+      "avg_cvss": 6.8,
+      "cvss_count": 28
+    },
+    {
+      "date": "2017-05-04",
+      "value": 19,
+      "avg_cvss": 7.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2017-05-05",
+      "value": 43,
+      "avg_cvss": 7.1,
+      "cvss_count": 43
+    },
+    {
+      "date": "2017-05-06",
+      "value": 11,
+      "avg_cvss": 7.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2017-05-07",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2017-05-08",
+      "value": 26,
+      "avg_cvss": 6.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2017-05-09",
+      "value": 40,
+      "avg_cvss": 7.6,
+      "cvss_count": 40
+    },
+    {
+      "date": "2017-05-10",
+      "value": 31,
+      "avg_cvss": 7.2,
+      "cvss_count": 31
+    },
+    {
+      "date": "2017-05-11",
+      "value": 25,
+      "avg_cvss": 7.3,
+      "cvss_count": 25
+    },
+    {
+      "date": "2017-05-12",
+      "value": 174,
+      "avg_cvss": 6.8,
+      "cvss_count": 174
+    },
+    {
+      "date": "2017-05-14",
+      "value": 4,
+      "avg_cvss": 8.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2017-05-15",
+      "value": 29,
+      "avg_cvss": 6.5,
+      "cvss_count": 29
+    },
+    {
+      "date": "2017-05-16",
+      "value": 38,
+      "avg_cvss": 7.7,
+      "cvss_count": 38
+    },
+    {
+      "date": "2017-05-17",
+      "value": 21,
+      "avg_cvss": 7.2,
+      "cvss_count": 21
+    },
+    {
+      "date": "2017-05-18",
+      "value": 41,
+      "avg_cvss": 7.4,
+      "cvss_count": 41
+    },
+    {
+      "date": "2017-05-19",
+      "value": 30,
+      "avg_cvss": 7.5,
+      "cvss_count": 30
+    },
+    {
+      "date": "2017-05-21",
+      "value": 24,
+      "avg_cvss": 7.5,
+      "cvss_count": 24
+    },
+    {
+      "date": "2017-05-22",
+      "value": 127,
+      "avg_cvss": 7.3,
+      "cvss_count": 127
+    },
+    {
+      "date": "2017-05-23",
+      "value": 117,
+      "avg_cvss": 8.1,
+      "cvss_count": 117
+    },
+    {
+      "date": "2017-05-24",
+      "value": 17,
+      "avg_cvss": 8.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "2017-05-25",
+      "value": 16,
+      "avg_cvss": 7.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2017-05-26",
+      "value": 27,
+      "avg_cvss": 7.1,
+      "cvss_count": 27
+    },
+    {
+      "date": "2017-05-27",
+      "value": 9,
+      "avg_cvss": 6.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2017-05-28",
+      "value": 10,
+      "avg_cvss": 6.9,
+      "cvss_count": 10
+    },
+    {
+      "date": "2017-05-29",
+      "value": 26,
+      "avg_cvss": 7.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2017-05-30",
+      "value": 16,
+      "avg_cvss": 7.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2017-05-31",
+      "value": 8,
+      "avg_cvss": 6.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2017-06-01",
+      "value": 13,
+      "avg_cvss": 7.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2017-06-02",
+      "value": 33,
+      "avg_cvss": 7.4,
+      "cvss_count": 33
+    },
+    {
+      "date": "2017-06-04",
+      "value": 12,
+      "avg_cvss": 7.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2017-06-05",
+      "value": 30,
+      "avg_cvss": 7.7,
+      "cvss_count": 30
+    },
+    {
+      "date": "2017-06-06",
+      "value": 49,
+      "avg_cvss": 7.2,
+      "cvss_count": 49
+    },
+    {
+      "date": "2017-06-07",
+      "value": 59,
+      "avg_cvss": 7.0,
+      "cvss_count": 59
+    },
+    {
+      "date": "2017-06-08",
+      "value": 68,
+      "avg_cvss": 7.6,
+      "cvss_count": 68
+    },
+    {
+      "date": "2017-06-09",
+      "value": 68,
+      "avg_cvss": 7.2,
+      "cvss_count": 68
+    },
+    {
+      "date": "2017-06-11",
+      "value": 3,
+      "avg_cvss": 7.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2017-06-12",
+      "value": 27,
+      "avg_cvss": 6.8,
+      "cvss_count": 27
+    },
+    {
+      "date": "2017-06-13",
+      "value": 121,
+      "avg_cvss": 7.2,
+      "cvss_count": 121
+    },
+    {
+      "date": "2017-06-14",
+      "value": 37,
+      "avg_cvss": 6.4,
+      "cvss_count": 37
+    },
+    {
+      "date": "2017-06-15",
+      "value": 112,
+      "avg_cvss": 6.4,
+      "cvss_count": 112
+    },
+    {
+      "date": "2017-06-16",
+      "value": 74,
+      "avg_cvss": 6.4,
+      "cvss_count": 74
+    },
+    {
+      "date": "2017-06-17",
+      "value": 2,
+      "avg_cvss": 7.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2017-06-18",
+      "value": 2,
+      "avg_cvss": 8.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2017-06-19",
+      "value": 38,
+      "avg_cvss": 7.8,
+      "cvss_count": 38
+    },
+    {
+      "date": "2017-06-20",
+      "value": 31,
+      "avg_cvss": 9.2,
+      "cvss_count": 31
+    },
+    {
+      "date": "2017-06-21",
+      "value": 32,
+      "avg_cvss": 7.6,
+      "cvss_count": 32
+    },
+    {
+      "date": "2017-06-22",
+      "value": 19,
+      "avg_cvss": 7.5,
+      "cvss_count": 19
+    },
+    {
+      "date": "2017-06-23",
+      "value": 13,
+      "avg_cvss": 6.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2017-06-24",
+      "value": 7,
+      "avg_cvss": 7.1,
+      "cvss_count": 7
+    },
+    {
+      "date": "2017-06-25",
+      "value": 10,
+      "avg_cvss": 6.3,
+      "cvss_count": 10
+    },
+    {
+      "date": "2017-06-26",
+      "value": 29,
+      "avg_cvss": 7.2,
+      "cvss_count": 29
+    },
+    {
+      "date": "2017-06-27",
+      "value": 53,
+      "avg_cvss": 7.1,
+      "cvss_count": 53
+    },
+    {
+      "date": "2017-06-28",
+      "value": 18,
+      "avg_cvss": 7.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2017-06-29",
+      "value": 38,
+      "avg_cvss": 7.8,
+      "cvss_count": 38
+    },
+    {
+      "date": "2017-06-30",
+      "value": 35,
+      "avg_cvss": 7.8,
+      "cvss_count": 35
+    },
+    {
+      "date": "2017-07-01",
+      "value": 2,
+      "avg_cvss": 7.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2017-07-02",
+      "value": 11,
+      "avg_cvss": 6.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2017-07-03",
+      "value": 15,
+      "avg_cvss": 7.6,
+      "cvss_count": 15
+    },
+    {
+      "date": "2017-07-04",
+      "value": 30,
+      "avg_cvss": 6.6,
+      "cvss_count": 30
+    },
+    {
+      "date": "2017-07-05",
+      "value": 180,
+      "avg_cvss": 7.6,
+      "cvss_count": 180
+    },
+    {
+      "date": "2017-07-06",
+      "value": 69,
+      "avg_cvss": 7.1,
+      "cvss_count": 69
+    },
+    {
+      "date": "2017-07-07",
+      "value": 74,
+      "avg_cvss": 7.7,
+      "cvss_count": 74
+    },
+    {
+      "date": "2017-07-08",
+      "value": 8,
+      "avg_cvss": 7.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2017-07-09",
+      "value": 3,
+      "avg_cvss": 7.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2017-07-10",
+      "value": 33,
+      "avg_cvss": 7.2,
+      "cvss_count": 33
+    },
+    {
+      "date": "2017-07-11",
+      "value": 63,
+      "avg_cvss": 7.2,
+      "cvss_count": 63
+    },
+    {
+      "date": "2017-07-12",
+      "value": 39,
+      "avg_cvss": 7.3,
+      "cvss_count": 39
+    },
+    {
+      "date": "2017-07-13",
+      "value": 18,
+      "avg_cvss": 7.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2017-07-17",
+      "value": 217,
+      "avg_cvss": 7.6,
+      "cvss_count": 217
+    },
+    {
+      "date": "2017-07-18",
+      "value": 28,
+      "avg_cvss": 8.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2017-07-19",
+      "value": 30,
+      "avg_cvss": 7.4,
+      "cvss_count": 30
+    },
+    {
+      "date": "2017-07-20",
+      "value": 87,
+      "avg_cvss": 7.9,
+      "cvss_count": 87
+    },
+    {
+      "date": "2017-07-21",
+      "value": 35,
+      "avg_cvss": 7.7,
+      "cvss_count": 35
+    },
+    {
+      "date": "2017-07-22",
+      "value": 13,
+      "avg_cvss": 8.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2017-07-23",
+      "value": 35,
+      "avg_cvss": 7.2,
+      "cvss_count": 35
+    },
+    {
+      "date": "2017-07-24",
+      "value": 34,
+      "avg_cvss": 7.2,
+      "cvss_count": 34
+    },
+    {
+      "date": "2017-07-25",
+      "value": 57,
+      "avg_cvss": 7.2,
+      "cvss_count": 57
+    },
+    {
+      "date": "2017-07-26",
+      "value": 36,
+      "avg_cvss": 7.7,
+      "cvss_count": 36
+    },
+    {
+      "date": "2017-07-27",
+      "value": 29,
+      "avg_cvss": 7.1,
+      "cvss_count": 29
+    },
+    {
+      "date": "2017-07-28",
+      "value": 30,
+      "avg_cvss": 7.6,
+      "cvss_count": 30
+    },
+    {
+      "date": "2017-07-29",
+      "value": 12,
+      "avg_cvss": 6.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2017-07-30",
+      "value": 14,
+      "avg_cvss": 6.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2017-07-31",
+      "value": 66,
+      "avg_cvss": 6.8,
+      "cvss_count": 66
+    },
+    {
+      "date": "2017-08-01",
+      "value": 29,
+      "avg_cvss": 7.3,
+      "cvss_count": 29
+    },
+    {
+      "date": "2017-08-02",
+      "value": 68,
+      "avg_cvss": 7.3,
+      "cvss_count": 68
+    },
+    {
+      "date": "2017-08-03",
+      "value": 13,
+      "avg_cvss": 8.2,
+      "cvss_count": 13
+    },
+    {
+      "date": "2017-08-04",
+      "value": 38,
+      "avg_cvss": 7.7,
+      "cvss_count": 38
+    },
+    {
+      "date": "2017-08-05",
+      "value": 23,
+      "avg_cvss": 7.8,
+      "cvss_count": 23
+    },
+    {
+      "date": "2017-08-06",
+      "value": 10,
+      "avg_cvss": 8.1,
+      "cvss_count": 10
+    },
+    {
+      "date": "2017-08-07",
+      "value": 118,
+      "avg_cvss": 7.6,
+      "cvss_count": 118
+    },
+    {
+      "date": "2017-08-08",
+      "value": 316,
+      "avg_cvss": 6.5,
+      "cvss_count": 316
+    },
+    {
+      "date": "2017-08-09",
+      "value": 84,
+      "avg_cvss": 7.5,
+      "cvss_count": 84
+    },
+    {
+      "date": "2017-08-10",
+      "value": 25,
+      "avg_cvss": 6.8,
+      "cvss_count": 25
+    },
+    {
+      "date": "2017-08-11",
+      "value": 100,
+      "avg_cvss": 7.9,
+      "cvss_count": 100
+    },
+    {
+      "date": "2017-08-14",
+      "value": 20,
+      "avg_cvss": 7.5,
+      "cvss_count": 20
+    },
+    {
+      "date": "2017-08-15",
+      "value": 6,
+      "avg_cvss": 8.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2017-08-16",
+      "value": 20,
+      "avg_cvss": 7.4,
+      "cvss_count": 20
+    },
+    {
+      "date": "2017-08-17",
+      "value": 35,
+      "avg_cvss": 6.8,
+      "cvss_count": 35
+    },
+    {
+      "date": "2017-08-18",
+      "value": 176,
+      "avg_cvss": 8.6,
+      "cvss_count": 176
+    },
+    {
+      "date": "2017-08-19",
+      "value": 5,
+      "avg_cvss": 7.4,
+      "cvss_count": 5
+    },
+    {
+      "date": "2017-08-20",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2017-08-21",
+      "value": 18,
+      "avg_cvss": 7.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2017-08-22",
+      "value": 26,
+      "avg_cvss": 7.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2017-08-23",
+      "value": 33,
+      "avg_cvss": 7.6,
+      "cvss_count": 33
+    },
+    {
+      "date": "2017-08-24",
+      "value": 36,
+      "avg_cvss": 7.3,
+      "cvss_count": 36
+    },
+    {
+      "date": "2017-08-25",
+      "value": 36,
+      "avg_cvss": 7.3,
+      "cvss_count": 36
+    },
+    {
+      "date": "2017-08-26",
+      "value": 1,
+      "avg_cvss": 6.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2017-08-27",
+      "value": 4,
+      "avg_cvss": 8.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2017-08-28",
+      "value": 68,
+      "avg_cvss": 7.2,
+      "cvss_count": 68
+    },
+    {
+      "date": "2017-08-29",
+      "value": 134,
+      "avg_cvss": 6.8,
+      "cvss_count": 134
+    },
+    {
+      "date": "2017-08-30",
+      "value": 51,
+      "avg_cvss": 7.4,
+      "cvss_count": 51
+    },
+    {
+      "date": "2017-08-31",
+      "value": 42,
+      "avg_cvss": 7.2,
+      "cvss_count": 42
+    },
+    {
+      "date": "2017-09-01",
+      "value": 30,
+      "avg_cvss": 7.5,
+      "cvss_count": 30
+    },
+    {
+      "date": "2017-09-02",
+      "value": 4,
+      "avg_cvss": 7.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2017-09-03",
+      "value": 9,
+      "avg_cvss": 7.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2017-09-04",
+      "value": 12,
+      "avg_cvss": 7.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2017-09-05",
+      "value": 26,
+      "avg_cvss": 7.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2017-09-06",
+      "value": 26,
+      "avg_cvss": 6.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2017-09-07",
+      "value": 77,
+      "avg_cvss": 7.1,
+      "cvss_count": 77
+    },
+    {
+      "date": "2017-09-08",
+      "value": 58,
+      "avg_cvss": 7.4,
+      "cvss_count": 58
+    },
+    {
+      "date": "2017-09-09",
+      "value": 14,
+      "avg_cvss": 7.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2017-09-10",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2017-09-11",
+      "value": 82,
+      "avg_cvss": 7.7,
+      "cvss_count": 82
+    },
+    {
+      "date": "2017-09-12",
+      "value": 50,
+      "avg_cvss": 7.0,
+      "cvss_count": 50
+    },
+    {
+      "date": "2017-09-13",
+      "value": 136,
+      "avg_cvss": 6.8,
+      "cvss_count": 136
+    },
+    {
+      "date": "2017-09-14",
+      "value": 130,
+      "avg_cvss": 9.3,
+      "cvss_count": 130
+    },
+    {
+      "date": "2017-09-15",
+      "value": 26,
+      "avg_cvss": 7.2,
+      "cvss_count": 26
+    },
+    {
+      "date": "2017-09-17",
+      "value": 20,
+      "avg_cvss": 7.6,
+      "cvss_count": 20
+    },
+    {
+      "date": "2017-09-18",
+      "value": 59,
+      "avg_cvss": 7.5,
+      "cvss_count": 59
+    },
+    {
+      "date": "2017-09-19",
+      "value": 45,
+      "avg_cvss": 7.5,
+      "cvss_count": 45
+    },
+    {
+      "date": "2017-09-20",
+      "value": 51,
+      "avg_cvss": 7.1,
+      "cvss_count": 51
+    },
+    {
+      "date": "2017-09-21",
+      "value": 82,
+      "avg_cvss": 7.7,
+      "cvss_count": 82
+    },
+    {
+      "date": "2017-09-22",
+      "value": 41,
+      "avg_cvss": 7.5,
+      "cvss_count": 41
+    },
+    {
+      "date": "2017-09-23",
+      "value": 11,
+      "avg_cvss": 6.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2017-09-25",
+      "value": 49,
+      "avg_cvss": 7.0,
+      "cvss_count": 49
+    },
+    {
+      "date": "2017-09-26",
+      "value": 49,
+      "avg_cvss": 7.2,
+      "cvss_count": 49
+    },
+    {
+      "date": "2017-09-27",
+      "value": 9,
+      "avg_cvss": 7.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2017-09-28",
+      "value": 42,
+      "avg_cvss": 7.9,
+      "cvss_count": 42
+    },
+    {
+      "date": "2017-09-29",
+      "value": 39,
+      "avg_cvss": 7.0,
+      "cvss_count": 39
+    },
+    {
+      "date": "2017-09-30",
+      "value": 48,
+      "avg_cvss": 7.0,
+      "cvss_count": 48
+    },
+    {
+      "date": "2017-10-01",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2017-10-02",
+      "value": 10,
+      "avg_cvss": 6.5,
+      "cvss_count": 10
+    },
+    {
+      "date": "2017-10-03",
+      "value": 63,
+      "avg_cvss": 7.2,
+      "cvss_count": 63
+    },
+    {
+      "date": "2017-10-04",
+      "value": 46,
+      "avg_cvss": 7.7,
+      "cvss_count": 46
+    },
+    {
+      "date": "2017-10-05",
+      "value": 90,
+      "avg_cvss": 7.1,
+      "cvss_count": 90
+    },
+    {
+      "date": "2017-10-06",
+      "value": 42,
+      "avg_cvss": 7.2,
+      "cvss_count": 42
+    },
+    {
+      "date": "2017-10-09",
+      "value": 4,
+      "avg_cvss": 5.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2017-10-10",
+      "value": 70,
+      "avg_cvss": 7.4,
+      "cvss_count": 70
+    },
+    {
+      "date": "2017-10-11",
+      "value": 80,
+      "avg_cvss": 6.7,
+      "cvss_count": 80
+    },
+    {
+      "date": "2017-10-12",
+      "value": 23,
+      "avg_cvss": 6.6,
+      "cvss_count": 23
+    },
+    {
+      "date": "2017-10-13",
+      "value": 96,
+      "avg_cvss": 7.1,
+      "cvss_count": 96
+    },
+    {
+      "date": "2017-10-14",
+      "value": 3,
+      "avg_cvss": 6.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2017-10-15",
+      "value": 6,
+      "avg_cvss": 6.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2017-10-16",
+      "value": 43,
+      "avg_cvss": 7.7,
+      "cvss_count": 43
+    },
+    {
+      "date": "2017-10-17",
+      "value": 41,
+      "avg_cvss": 7.6,
+      "cvss_count": 41
+    },
+    {
+      "date": "2017-10-18",
+      "value": 54,
+      "avg_cvss": 7.2,
+      "cvss_count": 54
+    },
+    {
+      "date": "2017-10-19",
+      "value": 229,
+      "avg_cvss": 6.5,
+      "cvss_count": 229
+    },
+    {
+      "date": "2017-10-20",
+      "value": 17,
+      "avg_cvss": 7.3,
+      "cvss_count": 17
+    },
+    {
+      "date": "2017-10-22",
+      "value": 74,
+      "avg_cvss": 7.8,
+      "cvss_count": 74
+    },
+    {
+      "date": "2017-10-23",
+      "value": 118,
+      "avg_cvss": 7.3,
+      "cvss_count": 118
+    },
+    {
+      "date": "2017-10-24",
+      "value": 34,
+      "avg_cvss": 7.1,
+      "cvss_count": 34
+    },
+    {
+      "date": "2017-10-25",
+      "value": 7,
+      "avg_cvss": 5.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2017-10-26",
+      "value": 31,
+      "avg_cvss": 6.7,
+      "cvss_count": 31
+    },
+    {
+      "date": "2017-10-27",
+      "value": 102,
+      "avg_cvss": 7.2,
+      "cvss_count": 102
+    },
+    {
+      "date": "2017-10-28",
+      "value": 8,
+      "avg_cvss": 6.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2017-10-29",
+      "value": 30,
+      "avg_cvss": 9.2,
+      "cvss_count": 30
+    },
+    {
+      "date": "2017-10-30",
+      "value": 31,
+      "avg_cvss": 7.9,
+      "cvss_count": 31
+    },
+    {
+      "date": "2017-10-31",
+      "value": 46,
+      "avg_cvss": 8.3,
+      "cvss_count": 46
+    },
+    {
+      "date": "2017-11-01",
+      "value": 33,
+      "avg_cvss": 6.9,
+      "cvss_count": 33
+    },
+    {
+      "date": "2017-11-02",
+      "value": 23,
+      "avg_cvss": 7.3,
+      "cvss_count": 23
+    },
+    {
+      "date": "2017-11-03",
+      "value": 33,
+      "avg_cvss": 6.9,
+      "cvss_count": 33
+    },
+    {
+      "date": "2017-11-04",
+      "value": 17,
+      "avg_cvss": 6.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2017-11-05",
+      "value": 4,
+      "avg_cvss": 9.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2017-11-06",
+      "value": 29,
+      "avg_cvss": 7.0,
+      "cvss_count": 29
+    },
+    {
+      "date": "2017-11-07",
+      "value": 44,
+      "avg_cvss": 7.9,
+      "cvss_count": 44
+    },
+    {
+      "date": "2017-11-08",
+      "value": 19,
+      "avg_cvss": 7.6,
+      "cvss_count": 19
+    },
+    {
+      "date": "2017-11-09",
+      "value": 11,
+      "avg_cvss": 7.1,
+      "cvss_count": 11
+    },
+    {
+      "date": "2017-11-10",
+      "value": 35,
+      "avg_cvss": 7.1,
+      "cvss_count": 35
+    },
+    {
+      "date": "2017-11-11",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2017-11-12",
+      "value": 6,
+      "avg_cvss": 6.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2017-11-13",
+      "value": 97,
+      "avg_cvss": 7.3,
+      "cvss_count": 97
+    },
+    {
+      "date": "2017-11-14",
+      "value": 22,
+      "avg_cvss": 6.7,
+      "cvss_count": 22
+    },
+    {
+      "date": "2017-11-15",
+      "value": 91,
+      "avg_cvss": 6.7,
+      "cvss_count": 91
+    },
+    {
+      "date": "2017-11-16",
+      "value": 124,
+      "avg_cvss": 7.4,
+      "cvss_count": 124
+    },
+    {
+      "date": "2017-11-17",
+      "value": 100,
+      "avg_cvss": 7.4,
+      "cvss_count": 100
+    },
+    {
+      "date": "2017-11-18",
+      "value": 4,
+      "avg_cvss": 6.6,
+      "cvss_count": 4
+    },
+    {
+      "date": "2017-11-19",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2017-11-20",
+      "value": 26,
+      "avg_cvss": 7.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2017-11-21",
+      "value": 19,
+      "avg_cvss": 8.4,
+      "cvss_count": 19
+    },
+    {
+      "date": "2017-11-22",
+      "value": 162,
+      "avg_cvss": 6.9,
+      "cvss_count": 162
+    },
+    {
+      "date": "2017-11-23",
+      "value": 7,
+      "avg_cvss": 8.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2017-11-24",
+      "value": 7,
+      "avg_cvss": 8.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2017-11-25",
+      "value": 5,
+      "avg_cvss": 7.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2017-11-26",
+      "value": 1,
+      "avg_cvss": 7.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2017-11-27",
+      "value": 55,
+      "avg_cvss": 6.8,
+      "cvss_count": 55
+    },
+    {
+      "date": "2017-11-28",
+      "value": 16,
+      "avg_cvss": 7.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2017-11-29",
+      "value": 16,
+      "avg_cvss": 8.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2017-11-30",
+      "value": 58,
+      "avg_cvss": 6.5,
+      "cvss_count": 58
+    },
+    {
+      "date": "2017-12-01",
+      "value": 41,
+      "avg_cvss": 8.0,
+      "cvss_count": 41
+    },
+    {
+      "date": "2017-12-02",
+      "value": 6,
+      "avg_cvss": 6.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2017-12-03",
+      "value": 8,
+      "avg_cvss": 6.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "2017-12-04",
+      "value": 22,
+      "avg_cvss": 7.4,
+      "cvss_count": 22
+    },
+    {
+      "date": "2017-12-05",
+      "value": 60,
+      "avg_cvss": 7.9,
+      "cvss_count": 60
+    },
+    {
+      "date": "2017-12-06",
+      "value": 52,
+      "avg_cvss": 7.7,
+      "cvss_count": 52
+    },
+    {
+      "date": "2017-12-07",
+      "value": 34,
+      "avg_cvss": 6.5,
+      "cvss_count": 34
+    },
+    {
+      "date": "2017-12-08",
+      "value": 30,
+      "avg_cvss": 7.7,
+      "cvss_count": 30
+    },
+    {
+      "date": "2017-12-09",
+      "value": 86,
+      "avg_cvss": 8.4,
+      "cvss_count": 86
+    },
+    {
+      "date": "2017-12-10",
+      "value": 3,
+      "avg_cvss": 8.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2017-12-11",
+      "value": 52,
+      "avg_cvss": 7.3,
+      "cvss_count": 52
+    },
+    {
+      "date": "2017-12-12",
+      "value": 58,
+      "avg_cvss": 7.1,
+      "cvss_count": 58
+    },
+    {
+      "date": "2017-12-13",
+      "value": 104,
+      "avg_cvss": 8.9,
+      "cvss_count": 104
+    },
+    {
+      "date": "2017-12-14",
+      "value": 35,
+      "avg_cvss": 8.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2017-12-15",
+      "value": 19,
+      "avg_cvss": 7.4,
+      "cvss_count": 19
+    },
+    {
+      "date": "2017-12-16",
+      "value": 22,
+      "avg_cvss": 8.3,
+      "cvss_count": 22
+    },
+    {
+      "date": "2017-12-17",
+      "value": 4,
+      "avg_cvss": 6.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2017-12-18",
+      "value": 22,
+      "avg_cvss": 8.4,
+      "cvss_count": 22
+    },
+    {
+      "date": "2017-12-19",
+      "value": 22,
+      "avg_cvss": 8.4,
+      "cvss_count": 22
+    },
+    {
+      "date": "2017-12-20",
+      "value": 133,
+      "avg_cvss": 7.5,
+      "cvss_count": 133
+    },
+    {
+      "date": "2017-12-21",
+      "value": 51,
+      "avg_cvss": 7.2,
+      "cvss_count": 51
+    },
+    {
+      "date": "2017-12-22",
+      "value": 24,
+      "avg_cvss": 7.0,
+      "cvss_count": 24
+    },
+    {
+      "date": "2017-12-23",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2017-12-25",
+      "value": 23,
+      "avg_cvss": 7.3,
+      "cvss_count": 23
+    },
+    {
+      "date": "2017-12-26",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2017-12-27",
+      "value": 106,
+      "avg_cvss": 7.5,
+      "cvss_count": 106
+    },
+    {
+      "date": "2017-12-28",
+      "value": 30,
+      "avg_cvss": 7.4,
+      "cvss_count": 30
+    },
+    {
+      "date": "2017-12-29",
+      "value": 26,
+      "avg_cvss": 7.7,
+      "cvss_count": 26
+    },
+    {
+      "date": "2017-12-30",
+      "value": 24,
+      "avg_cvss": 6.2,
+      "cvss_count": 24
+    },
+    {
+      "date": "2017-12-31",
+      "value": 4,
+      "avg_cvss": 7.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2018-01-01",
+      "value": 11,
+      "avg_cvss": 7.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2018-01-02",
+      "value": 40,
+      "avg_cvss": 7.5,
+      "cvss_count": 40
+    },
+    {
+      "date": "2018-01-03",
+      "value": 57,
+      "avg_cvss": 7.2,
+      "cvss_count": 57
+    },
+    {
+      "date": "2018-01-04",
+      "value": 66,
+      "avg_cvss": 6.7,
+      "cvss_count": 66
+    },
+    {
+      "date": "2018-01-05",
+      "value": 27,
+      "avg_cvss": 7.8,
+      "cvss_count": 27
+    },
+    {
+      "date": "2018-01-06",
+      "value": 4,
+      "avg_cvss": 8.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2018-01-07",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2018-01-08",
+      "value": 58,
+      "avg_cvss": 7.1,
+      "cvss_count": 58
+    },
+    {
+      "date": "2018-01-09",
+      "value": 34,
+      "avg_cvss": 7.2,
+      "cvss_count": 34
+    },
+    {
+      "date": "2018-01-10",
+      "value": 103,
+      "avg_cvss": 7.3,
+      "cvss_count": 103
+    },
+    {
+      "date": "2018-01-11",
+      "value": 49,
+      "avg_cvss": 6.8,
+      "cvss_count": 49
+    },
+    {
+      "date": "2018-01-12",
+      "value": 118,
+      "avg_cvss": 7.6,
+      "cvss_count": 118
+    },
+    {
+      "date": "2018-01-13",
+      "value": 26,
+      "avg_cvss": 5.7,
+      "cvss_count": 26
+    },
+    {
+      "date": "2018-01-14",
+      "value": 20,
+      "avg_cvss": 6.7,
+      "cvss_count": 20
+    },
+    {
+      "date": "2018-01-15",
+      "value": 4,
+      "avg_cvss": 8.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2018-01-16",
+      "value": 45,
+      "avg_cvss": 6.9,
+      "cvss_count": 45
+    },
+    {
+      "date": "2018-01-17",
+      "value": 6,
+      "avg_cvss": 7.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2018-01-18",
+      "value": 217,
+      "avg_cvss": 6.7,
+      "cvss_count": 217
+    },
+    {
+      "date": "2018-01-19",
+      "value": 32,
+      "avg_cvss": 7.3,
+      "cvss_count": 32
+    },
+    {
+      "date": "2018-01-20",
+      "value": 5,
+      "avg_cvss": 7.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2018-01-21",
+      "value": 7,
+      "avg_cvss": 8.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2018-01-22",
+      "value": 27,
+      "avg_cvss": 7.2,
+      "cvss_count": 27
+    },
+    {
+      "date": "2018-01-23",
+      "value": 64,
+      "avg_cvss": 7.5,
+      "cvss_count": 64
+    },
+    {
+      "date": "2018-01-24",
+      "value": 52,
+      "avg_cvss": 8.7,
+      "cvss_count": 52
+    },
+    {
+      "date": "2018-01-25",
+      "value": 39,
+      "avg_cvss": 7.1,
+      "cvss_count": 39
+    },
+    {
+      "date": "2018-01-26",
+      "value": 55,
+      "avg_cvss": 6.7,
+      "cvss_count": 55
+    },
+    {
+      "date": "2018-01-27",
+      "value": 7,
+      "avg_cvss": 7.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2018-01-28",
+      "value": 1,
+      "avg_cvss": 8.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2018-01-29",
+      "value": 36,
+      "avg_cvss": 8.1,
+      "cvss_count": 36
+    },
+    {
+      "date": "2018-01-30",
+      "value": 23,
+      "avg_cvss": 7.5,
+      "cvss_count": 23
+    },
+    {
+      "date": "2018-01-31",
+      "value": 39,
+      "avg_cvss": 7.4,
+      "cvss_count": 39
+    },
+    {
+      "date": "2018-02-01",
+      "value": 28,
+      "avg_cvss": 7.7,
+      "cvss_count": 28
+    },
+    {
+      "date": "2018-02-02",
+      "value": 66,
+      "avg_cvss": 7.1,
+      "cvss_count": 66
+    },
+    {
+      "date": "2018-02-03",
+      "value": 9,
+      "avg_cvss": 7.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2018-02-04",
+      "value": 6,
+      "avg_cvss": 6.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2018-02-05",
+      "value": 40,
+      "avg_cvss": 7.7,
+      "cvss_count": 40
+    },
+    {
+      "date": "2018-02-06",
+      "value": 64,
+      "avg_cvss": 7.8,
+      "cvss_count": 64
+    },
+    {
+      "date": "2018-02-07",
+      "value": 60,
+      "avg_cvss": 7.6,
+      "cvss_count": 60
+    },
+    {
+      "date": "2018-02-08",
+      "value": 74,
+      "avg_cvss": 8.1,
+      "cvss_count": 74
+    },
+    {
+      "date": "2018-02-09",
+      "value": 77,
+      "avg_cvss": 7.4,
+      "cvss_count": 77
+    },
+    {
+      "date": "2018-02-11",
+      "value": 3,
+      "avg_cvss": 8.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2018-02-12",
+      "value": 54,
+      "avg_cvss": 7.1,
+      "cvss_count": 54
+    },
+    {
+      "date": "2018-02-13",
+      "value": 28,
+      "avg_cvss": 7.6,
+      "cvss_count": 28
+    },
+    {
+      "date": "2018-02-14",
+      "value": 38,
+      "avg_cvss": 7.1,
+      "cvss_count": 38
+    },
+    {
+      "date": "2018-02-15",
+      "value": 340,
+      "avg_cvss": 7.2,
+      "cvss_count": 340
+    },
+    {
+      "date": "2018-02-16",
+      "value": 22,
+      "avg_cvss": 6.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2018-02-17",
+      "value": 31,
+      "avg_cvss": 9.8,
+      "cvss_count": 31
+    },
+    {
+      "date": "2018-02-18",
+      "value": 11,
+      "avg_cvss": 7.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2018-02-19",
+      "value": 43,
+      "avg_cvss": 7.6,
+      "cvss_count": 43
+    },
+    {
+      "date": "2018-02-20",
+      "value": 28,
+      "avg_cvss": 7.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2018-02-21",
+      "value": 44,
+      "avg_cvss": 6.4,
+      "cvss_count": 44
+    },
+    {
+      "date": "2018-02-22",
+      "value": 48,
+      "avg_cvss": 7.9,
+      "cvss_count": 48
+    },
+    {
+      "date": "2018-02-23",
+      "value": 59,
+      "avg_cvss": 7.6,
+      "cvss_count": 59
+    },
+    {
+      "date": "2018-02-24",
+      "value": 11,
+      "avg_cvss": 6.2,
+      "cvss_count": 11
+    },
+    {
+      "date": "2018-02-25",
+      "value": 6,
+      "avg_cvss": 6.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2018-02-26",
+      "value": 30,
+      "avg_cvss": 7.3,
+      "cvss_count": 30
+    },
+    {
+      "date": "2018-02-27",
+      "value": 77,
+      "avg_cvss": 7.3,
+      "cvss_count": 77
+    },
+    {
+      "date": "2018-02-28",
+      "value": 28,
+      "avg_cvss": 8.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2018-03-01",
+      "value": 53,
+      "avg_cvss": 7.4,
+      "cvss_count": 53
+    },
+    {
+      "date": "2018-03-02",
+      "value": 46,
+      "avg_cvss": 6.4,
+      "cvss_count": 46
+    },
+    {
+      "date": "2018-03-04",
+      "value": 12,
+      "avg_cvss": 6.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2018-03-05",
+      "value": 51,
+      "avg_cvss": 6.9,
+      "cvss_count": 51
+    },
+    {
+      "date": "2018-03-06",
+      "value": 52,
+      "avg_cvss": 6.9,
+      "cvss_count": 52
+    },
+    {
+      "date": "2018-03-07",
+      "value": 30,
+      "avg_cvss": 7.6,
+      "cvss_count": 30
+    },
+    {
+      "date": "2018-03-08",
+      "value": 59,
+      "avg_cvss": 6.8,
+      "cvss_count": 59
+    },
+    {
+      "date": "2018-03-09",
+      "value": 104,
+      "avg_cvss": 6.6,
+      "cvss_count": 104
+    },
+    {
+      "date": "2018-03-10",
+      "value": 4,
+      "avg_cvss": 6.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2018-03-11",
+      "value": 5,
+      "avg_cvss": 8.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2018-03-12",
+      "value": 47,
+      "avg_cvss": 7.0,
+      "cvss_count": 47
+    },
+    {
+      "date": "2018-03-13",
+      "value": 72,
+      "avg_cvss": 7.2,
+      "cvss_count": 72
+    },
+    {
+      "date": "2018-03-14",
+      "value": 133,
+      "avg_cvss": 7.0,
+      "cvss_count": 133
+    },
+    {
+      "date": "2018-03-15",
+      "value": 64,
+      "avg_cvss": 7.3,
+      "cvss_count": 64
+    },
+    {
+      "date": "2018-03-16",
+      "value": 42,
+      "avg_cvss": 7.4,
+      "cvss_count": 42
+    },
+    {
+      "date": "2018-03-17",
+      "value": 3,
+      "avg_cvss": 7.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2018-03-18",
+      "value": 9,
+      "avg_cvss": 7.3,
+      "cvss_count": 9
+    },
+    {
+      "date": "2018-03-19",
+      "value": 30,
+      "avg_cvss": 7.1,
+      "cvss_count": 30
+    },
+    {
+      "date": "2018-03-20",
+      "value": 61,
+      "avg_cvss": 7.1,
+      "cvss_count": 61
+    },
+    {
+      "date": "2018-03-21",
+      "value": 30,
+      "avg_cvss": 6.7,
+      "cvss_count": 30
+    },
+    {
+      "date": "2018-03-22",
+      "value": 67,
+      "avg_cvss": 7.5,
+      "cvss_count": 67
+    },
+    {
+      "date": "2018-03-23",
+      "value": 29,
+      "avg_cvss": 6.8,
+      "cvss_count": 29
+    },
+    {
+      "date": "2018-03-24",
+      "value": 13,
+      "avg_cvss": 7.5,
+      "cvss_count": 13
+    },
+    {
+      "date": "2018-03-25",
+      "value": 35,
+      "avg_cvss": 7.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2018-03-26",
+      "value": 51,
+      "avg_cvss": 6.7,
+      "cvss_count": 51
+    },
+    {
+      "date": "2018-03-27",
+      "value": 66,
+      "avg_cvss": 7.1,
+      "cvss_count": 66
+    },
+    {
+      "date": "2018-03-28",
+      "value": 56,
+      "avg_cvss": 7.6,
+      "cvss_count": 56
+    },
+    {
+      "date": "2018-03-29",
+      "value": 33,
+      "avg_cvss": 7.9,
+      "cvss_count": 33
+    },
+    {
+      "date": "2018-03-30",
+      "value": 71,
+      "avg_cvss": 7.3,
+      "cvss_count": 71
+    },
+    {
+      "date": "2018-03-31",
+      "value": 9,
+      "avg_cvss": 8.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2018-04-01",
+      "value": 8,
+      "avg_cvss": 6.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2018-04-02",
+      "value": 25,
+      "avg_cvss": 7.4,
+      "cvss_count": 25
+    },
+    {
+      "date": "2018-04-03",
+      "value": 170,
+      "avg_cvss": 7.4,
+      "cvss_count": 170
+    },
+    {
+      "date": "2018-04-04",
+      "value": 163,
+      "avg_cvss": 7.6,
+      "cvss_count": 163
+    },
+    {
+      "date": "2018-04-05",
+      "value": 57,
+      "avg_cvss": 7.6,
+      "cvss_count": 57
+    },
+    {
+      "date": "2018-04-06",
+      "value": 14,
+      "avg_cvss": 7.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2018-04-07",
+      "value": 10,
+      "avg_cvss": 8.2,
+      "cvss_count": 10
+    },
+    {
+      "date": "2018-04-08",
+      "value": 5,
+      "avg_cvss": 7.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2018-04-09",
+      "value": 14,
+      "avg_cvss": 7.6,
+      "cvss_count": 14
+    },
+    {
+      "date": "2018-04-10",
+      "value": 50,
+      "avg_cvss": 7.0,
+      "cvss_count": 50
+    },
+    {
+      "date": "2018-04-11",
+      "value": 88,
+      "avg_cvss": 7.7,
+      "cvss_count": 88
+    },
+    {
+      "date": "2018-04-12",
+      "value": 112,
+      "avg_cvss": 6.8,
+      "cvss_count": 112
+    },
+    {
+      "date": "2018-04-13",
+      "value": 41,
+      "avg_cvss": 7.4,
+      "cvss_count": 41
+    },
+    {
+      "date": "2018-04-16",
+      "value": 61,
+      "avg_cvss": 6.8,
+      "cvss_count": 61
+    },
+    {
+      "date": "2018-04-17",
+      "value": 31,
+      "avg_cvss": 7.9,
+      "cvss_count": 31
+    },
+    {
+      "date": "2018-04-18",
+      "value": 281,
+      "avg_cvss": 9.0,
+      "cvss_count": 281
+    },
+    {
+      "date": "2018-04-19",
+      "value": 200,
+      "avg_cvss": 6.6,
+      "cvss_count": 200
+    },
+    {
+      "date": "2018-04-20",
+      "value": 36,
+      "avg_cvss": 7.3,
+      "cvss_count": 36
+    },
+    {
+      "date": "2018-04-21",
+      "value": 6,
+      "avg_cvss": 7.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2018-04-22",
+      "value": 14,
+      "avg_cvss": 7.6,
+      "cvss_count": 14
+    },
+    {
+      "date": "2018-04-23",
+      "value": 24,
+      "avg_cvss": 7.1,
+      "cvss_count": 24
+    },
+    {
+      "date": "2018-04-24",
+      "value": 100,
+      "avg_cvss": 7.4,
+      "cvss_count": 100
+    },
+    {
+      "date": "2018-04-25",
+      "value": 45,
+      "avg_cvss": 6.6,
+      "cvss_count": 45
+    },
+    {
+      "date": "2018-04-26",
+      "value": 36,
+      "avg_cvss": 6.7,
+      "cvss_count": 36
+    },
+    {
+      "date": "2018-04-27",
+      "value": 29,
+      "avg_cvss": 7.0,
+      "cvss_count": 29
+    },
+    {
+      "date": "2018-04-28",
+      "value": 3,
+      "avg_cvss": 6.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2018-04-29",
+      "value": 15,
+      "avg_cvss": 7.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2018-04-30",
+      "value": 29,
+      "avg_cvss": 6.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2018-05-01",
+      "value": 31,
+      "avg_cvss": 7.2,
+      "cvss_count": 31
+    },
+    {
+      "date": "2018-05-02",
+      "value": 63,
+      "avg_cvss": 7.3,
+      "cvss_count": 63
+    },
+    {
+      "date": "2018-05-03",
+      "value": 13,
+      "avg_cvss": 7.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2018-05-04",
+      "value": 35,
+      "avg_cvss": 7.7,
+      "cvss_count": 35
+    },
+    {
+      "date": "2018-05-05",
+      "value": 5,
+      "avg_cvss": 8.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2018-05-06",
+      "value": 4,
+      "avg_cvss": 6.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2018-05-07",
+      "value": 14,
+      "avg_cvss": 7.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2018-05-08",
+      "value": 34,
+      "avg_cvss": 6.7,
+      "cvss_count": 34
+    },
+    {
+      "date": "2018-05-09",
+      "value": 103,
+      "avg_cvss": 7.1,
+      "cvss_count": 103
+    },
+    {
+      "date": "2018-05-10",
+      "value": 49,
+      "avg_cvss": 7.0,
+      "cvss_count": 49
+    },
+    {
+      "date": "2018-05-11",
+      "value": 25,
+      "avg_cvss": 6.8,
+      "cvss_count": 25
+    },
+    {
+      "date": "2018-05-12",
+      "value": 7,
+      "avg_cvss": 7.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2018-05-13",
+      "value": 4,
+      "avg_cvss": 8.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2018-05-14",
+      "value": 50,
+      "avg_cvss": 7.1,
+      "cvss_count": 50
+    },
+    {
+      "date": "2018-05-15",
+      "value": 37,
+      "avg_cvss": 7.1,
+      "cvss_count": 37
+    },
+    {
+      "date": "2018-05-16",
+      "value": 28,
+      "avg_cvss": 7.2,
+      "cvss_count": 28
+    },
+    {
+      "date": "2018-05-17",
+      "value": 139,
+      "avg_cvss": 7.7,
+      "cvss_count": 139
+    },
+    {
+      "date": "2018-05-18",
+      "value": 31,
+      "avg_cvss": 6.9,
+      "cvss_count": 31
+    },
+    {
+      "date": "2018-05-19",
+      "value": 38,
+      "avg_cvss": 8.2,
+      "cvss_count": 38
+    },
+    {
+      "date": "2018-05-20",
+      "value": 4,
+      "avg_cvss": 7.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2018-05-21",
+      "value": 13,
+      "avg_cvss": 6.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2018-05-22",
+      "value": 63,
+      "avg_cvss": 6.8,
+      "cvss_count": 63
+    },
+    {
+      "date": "2018-05-23",
+      "value": 32,
+      "avg_cvss": 7.5,
+      "cvss_count": 32
+    },
+    {
+      "date": "2018-05-24",
+      "value": 55,
+      "avg_cvss": 7.5,
+      "cvss_count": 55
+    },
+    {
+      "date": "2018-05-25",
+      "value": 46,
+      "avg_cvss": 6.9,
+      "cvss_count": 46
+    },
+    {
+      "date": "2018-05-26",
+      "value": 17,
+      "avg_cvss": 7.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2018-05-28",
+      "value": 11,
+      "avg_cvss": 7.1,
+      "cvss_count": 11
+    },
+    {
+      "date": "2018-05-29",
+      "value": 80,
+      "avg_cvss": 7.9,
+      "cvss_count": 80
+    },
+    {
+      "date": "2018-05-30",
+      "value": 30,
+      "avg_cvss": 6.8,
+      "cvss_count": 30
+    },
+    {
+      "date": "2018-05-31",
+      "value": 101,
+      "avg_cvss": 7.3,
+      "cvss_count": 101
+    },
+    {
+      "date": "2018-06-01",
+      "value": 96,
+      "avg_cvss": 7.4,
+      "cvss_count": 96
+    },
+    {
+      "date": "2018-06-02",
+      "value": 60,
+      "avg_cvss": 8.6,
+      "cvss_count": 60
+    },
+    {
+      "date": "2018-06-04",
+      "value": 136,
+      "avg_cvss": 7.6,
+      "cvss_count": 136
+    },
+    {
+      "date": "2018-06-05",
+      "value": 60,
+      "avg_cvss": 7.1,
+      "cvss_count": 60
+    },
+    {
+      "date": "2018-06-06",
+      "value": 27,
+      "avg_cvss": 7.3,
+      "cvss_count": 27
+    },
+    {
+      "date": "2018-06-07",
+      "value": 237,
+      "avg_cvss": 7.5,
+      "cvss_count": 237
+    },
+    {
+      "date": "2018-06-08",
+      "value": 96,
+      "avg_cvss": 7.3,
+      "cvss_count": 96
+    },
+    {
+      "date": "2018-06-09",
+      "value": 1,
+      "avg_cvss": 8.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2018-06-10",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2018-06-11",
+      "value": 349,
+      "avg_cvss": 7.7,
+      "cvss_count": 349
+    },
+    {
+      "date": "2018-06-12",
+      "value": 56,
+      "avg_cvss": 7.3,
+      "cvss_count": 56
+    },
+    {
+      "date": "2018-06-13",
+      "value": 59,
+      "avg_cvss": 7.0,
+      "cvss_count": 59
+    },
+    {
+      "date": "2018-06-14",
+      "value": 71,
+      "avg_cvss": 6.7,
+      "cvss_count": 71
+    },
+    {
+      "date": "2018-06-15",
+      "value": 35,
+      "avg_cvss": 6.8,
+      "cvss_count": 35
+    },
+    {
+      "date": "2018-06-16",
+      "value": 17,
+      "avg_cvss": 7.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2018-06-17",
+      "value": 26,
+      "avg_cvss": 7.9,
+      "cvss_count": 26
+    },
+    {
+      "date": "2018-06-18",
+      "value": 27,
+      "avg_cvss": 7.9,
+      "cvss_count": 27
+    },
+    {
+      "date": "2018-06-19",
+      "value": 39,
+      "avg_cvss": 7.4,
+      "cvss_count": 39
+    },
+    {
+      "date": "2018-06-20",
+      "value": 44,
+      "avg_cvss": 7.7,
+      "cvss_count": 44
+    },
+    {
+      "date": "2018-06-21",
+      "value": 41,
+      "avg_cvss": 7.2,
+      "cvss_count": 41
+    },
+    {
+      "date": "2018-06-22",
+      "value": 26,
+      "avg_cvss": 7.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2018-06-23",
+      "value": 10,
+      "avg_cvss": 7.9,
+      "cvss_count": 10
+    },
+    {
+      "date": "2018-06-24",
+      "value": 4,
+      "avg_cvss": 8.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2018-06-25",
+      "value": 29,
+      "avg_cvss": 7.5,
+      "cvss_count": 29
+    },
+    {
+      "date": "2018-06-26",
+      "value": 144,
+      "avg_cvss": 7.1,
+      "cvss_count": 144
+    },
+    {
+      "date": "2018-06-27",
+      "value": 31,
+      "avg_cvss": 7.6,
+      "cvss_count": 31
+    },
+    {
+      "date": "2018-06-28",
+      "value": 20,
+      "avg_cvss": 7.9,
+      "cvss_count": 20
+    },
+    {
+      "date": "2018-06-29",
+      "value": 37,
+      "avg_cvss": 7.7,
+      "cvss_count": 37
+    },
+    {
+      "date": "2018-06-30",
+      "value": 4,
+      "avg_cvss": 7.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2018-07-01",
+      "value": 8,
+      "avg_cvss": 8.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2018-07-02",
+      "value": 33,
+      "avg_cvss": 7.4,
+      "cvss_count": 33
+    },
+    {
+      "date": "2018-07-03",
+      "value": 146,
+      "avg_cvss": 7.0,
+      "cvss_count": 146
+    },
+    {
+      "date": "2018-07-04",
+      "value": 16,
+      "avg_cvss": 7.4,
+      "cvss_count": 16
+    },
+    {
+      "date": "2018-07-05",
+      "value": 133,
+      "avg_cvss": 7.4,
+      "cvss_count": 133
+    },
+    {
+      "date": "2018-07-06",
+      "value": 96,
+      "avg_cvss": 7.1,
+      "cvss_count": 96
+    },
+    {
+      "date": "2018-07-07",
+      "value": 8,
+      "avg_cvss": 7.1,
+      "cvss_count": 8
+    },
+    {
+      "date": "2018-07-08",
+      "value": 9,
+      "avg_cvss": 8.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2018-07-09",
+      "value": 431,
+      "avg_cvss": 7.7,
+      "cvss_count": 431
+    },
+    {
+      "date": "2018-07-10",
+      "value": 87,
+      "avg_cvss": 7.3,
+      "cvss_count": 87
+    },
+    {
+      "date": "2018-07-11",
+      "value": 98,
+      "avg_cvss": 7.2,
+      "cvss_count": 98
+    },
+    {
+      "date": "2018-07-12",
+      "value": 34,
+      "avg_cvss": 7.1,
+      "cvss_count": 34
+    },
+    {
+      "date": "2018-07-13",
+      "value": 86,
+      "avg_cvss": 7.8,
+      "cvss_count": 86
+    },
+    {
+      "date": "2018-07-15",
+      "value": 12,
+      "avg_cvss": 8.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2018-07-16",
+      "value": 39,
+      "avg_cvss": 7.4,
+      "cvss_count": 39
+    },
+    {
+      "date": "2018-07-17",
+      "value": 37,
+      "avg_cvss": 8.6,
+      "cvss_count": 37
+    },
+    {
+      "date": "2018-07-18",
+      "value": 253,
+      "avg_cvss": 6.5,
+      "cvss_count": 253
+    },
+    {
+      "date": "2018-07-19",
+      "value": 49,
+      "avg_cvss": 7.3,
+      "cvss_count": 49
+    },
+    {
+      "date": "2018-07-20",
+      "value": 164,
+      "avg_cvss": 7.8,
+      "cvss_count": 164
+    },
+    {
+      "date": "2018-07-21",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2018-07-22",
+      "value": 3,
+      "avg_cvss": 8.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2018-07-23",
+      "value": 61,
+      "avg_cvss": 7.3,
+      "cvss_count": 61
+    },
+    {
+      "date": "2018-07-24",
+      "value": 49,
+      "avg_cvss": 8.2,
+      "cvss_count": 49
+    },
+    {
+      "date": "2018-07-25",
+      "value": 33,
+      "avg_cvss": 6.7,
+      "cvss_count": 33
+    },
+    {
+      "date": "2018-07-26",
+      "value": 44,
+      "avg_cvss": 6.4,
+      "cvss_count": 44
+    },
+    {
+      "date": "2018-07-27",
+      "value": 76,
+      "avg_cvss": 6.1,
+      "cvss_count": 76
+    },
+    {
+      "date": "2018-07-28",
+      "value": 9,
+      "avg_cvss": 7.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2018-07-29",
+      "value": 1,
+      "avg_cvss": 7.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2018-07-30",
+      "value": 23,
+      "avg_cvss": 7.3,
+      "cvss_count": 23
+    },
+    {
+      "date": "2018-07-31",
+      "value": 128,
+      "avg_cvss": 8.0,
+      "cvss_count": 128
+    },
+    {
+      "date": "2018-08-01",
+      "value": 79,
+      "avg_cvss": 6.5,
+      "cvss_count": 79
+    },
+    {
+      "date": "2018-08-02",
+      "value": 40,
+      "avg_cvss": 7.6,
+      "cvss_count": 40
+    },
+    {
+      "date": "2018-08-03",
+      "value": 43,
+      "avg_cvss": 7.2,
+      "cvss_count": 43
+    },
+    {
+      "date": "2018-08-04",
+      "value": 8,
+      "avg_cvss": 8.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2018-08-05",
+      "value": 21,
+      "avg_cvss": 7.4,
+      "cvss_count": 21
+    },
+    {
+      "date": "2018-08-06",
+      "value": 81,
+      "avg_cvss": 7.1,
+      "cvss_count": 81
+    },
+    {
+      "date": "2018-08-07",
+      "value": 12,
+      "avg_cvss": 6.5,
+      "cvss_count": 12
+    },
+    {
+      "date": "2018-08-08",
+      "value": 23,
+      "avg_cvss": 7.7,
+      "cvss_count": 23
+    },
+    {
+      "date": "2018-08-09",
+      "value": 14,
+      "avg_cvss": 7.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2018-08-10",
+      "value": 28,
+      "avg_cvss": 7.1,
+      "cvss_count": 28
+    },
+    {
+      "date": "2018-08-12",
+      "value": 3,
+      "avg_cvss": 8.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2018-08-13",
+      "value": 36,
+      "avg_cvss": 7.3,
+      "cvss_count": 36
+    },
+    {
+      "date": "2018-08-14",
+      "value": 34,
+      "avg_cvss": 7.2,
+      "cvss_count": 34
+    },
+    {
+      "date": "2018-08-15",
+      "value": 109,
+      "avg_cvss": 7.4,
+      "cvss_count": 109
+    },
+    {
+      "date": "2018-08-16",
+      "value": 15,
+      "avg_cvss": 7.1,
+      "cvss_count": 15
+    },
+    {
+      "date": "2018-08-17",
+      "value": 29,
+      "avg_cvss": 7.9,
+      "cvss_count": 29
+    },
+    {
+      "date": "2018-08-18",
+      "value": 8,
+      "avg_cvss": 7.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "2018-08-20",
+      "value": 67,
+      "avg_cvss": 7.5,
+      "cvss_count": 67
+    },
+    {
+      "date": "2018-08-21",
+      "value": 28,
+      "avg_cvss": 7.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2018-08-22",
+      "value": 25,
+      "avg_cvss": 6.3,
+      "cvss_count": 25
+    },
+    {
+      "date": "2018-08-23",
+      "value": 46,
+      "avg_cvss": 8.2,
+      "cvss_count": 46
+    },
+    {
+      "date": "2018-08-24",
+      "value": 34,
+      "avg_cvss": 8.1,
+      "cvss_count": 34
+    },
+    {
+      "date": "2018-08-25",
+      "value": 27,
+      "avg_cvss": 6.4,
+      "cvss_count": 27
+    },
+    {
+      "date": "2018-08-26",
+      "value": 8,
+      "avg_cvss": 7.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2018-08-27",
+      "value": 27,
+      "avg_cvss": 7.6,
+      "cvss_count": 27
+    },
+    {
+      "date": "2018-08-28",
+      "value": 54,
+      "avg_cvss": 7.0,
+      "cvss_count": 54
+    },
+    {
+      "date": "2018-08-29",
+      "value": 45,
+      "avg_cvss": 7.6,
+      "cvss_count": 45
+    },
+    {
+      "date": "2018-08-30",
+      "value": 56,
+      "avg_cvss": 7.3,
+      "cvss_count": 56
+    },
+    {
+      "date": "2018-08-31",
+      "value": 13,
+      "avg_cvss": 6.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2018-09-01",
+      "value": 20,
+      "avg_cvss": 7.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2018-09-02",
+      "value": 28,
+      "avg_cvss": 7.6,
+      "cvss_count": 28
+    },
+    {
+      "date": "2018-09-03",
+      "value": 31,
+      "avg_cvss": 7.1,
+      "cvss_count": 31
+    },
+    {
+      "date": "2018-09-04",
+      "value": 52,
+      "avg_cvss": 7.3,
+      "cvss_count": 52
+    },
+    {
+      "date": "2018-09-05",
+      "value": 53,
+      "avg_cvss": 7.2,
+      "cvss_count": 53
+    },
+    {
+      "date": "2018-09-06",
+      "value": 51,
+      "avg_cvss": 7.0,
+      "cvss_count": 51
+    },
+    {
+      "date": "2018-09-07",
+      "value": 65,
+      "avg_cvss": 7.2,
+      "cvss_count": 65
+    },
+    {
+      "date": "2018-09-08",
+      "value": 7,
+      "avg_cvss": 8.1,
+      "cvss_count": 7
+    },
+    {
+      "date": "2018-09-09",
+      "value": 7,
+      "avg_cvss": 7.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2018-09-10",
+      "value": 47,
+      "avg_cvss": 7.1,
+      "cvss_count": 47
+    },
+    {
+      "date": "2018-09-11",
+      "value": 39,
+      "avg_cvss": 6.5,
+      "cvss_count": 39
+    },
+    {
+      "date": "2018-09-12",
+      "value": 69,
+      "avg_cvss": 7.1,
+      "cvss_count": 69
+    },
+    {
+      "date": "2018-09-13",
+      "value": 104,
+      "avg_cvss": 6.7,
+      "cvss_count": 104
+    },
+    {
+      "date": "2018-09-14",
+      "value": 31,
+      "avg_cvss": 7.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2018-09-15",
+      "value": 9,
+      "avg_cvss": 8.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2018-09-16",
+      "value": 26,
+      "avg_cvss": 7.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2018-09-17",
+      "value": 38,
+      "avg_cvss": 7.6,
+      "cvss_count": 38
+    },
+    {
+      "date": "2018-09-18",
+      "value": 78,
+      "avg_cvss": 7.1,
+      "cvss_count": 78
+    },
+    {
+      "date": "2018-09-19",
+      "value": 57,
+      "avg_cvss": 7.4,
+      "cvss_count": 57
+    },
+    {
+      "date": "2018-09-20",
+      "value": 43,
+      "avg_cvss": 7.7,
+      "cvss_count": 43
+    },
+    {
+      "date": "2018-09-21",
+      "value": 63,
+      "avg_cvss": 7.5,
+      "cvss_count": 63
+    },
+    {
+      "date": "2018-09-22",
+      "value": 6,
+      "avg_cvss": 7.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2018-09-23",
+      "value": 16,
+      "avg_cvss": 6.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2018-09-24",
+      "value": 28,
+      "avg_cvss": 7.4,
+      "cvss_count": 28
+    },
+    {
+      "date": "2018-09-25",
+      "value": 53,
+      "avg_cvss": 7.0,
+      "cvss_count": 53
+    },
+    {
+      "date": "2018-09-26",
+      "value": 63,
+      "avg_cvss": 7.6,
+      "cvss_count": 63
+    },
+    {
+      "date": "2018-09-27",
+      "value": 15,
+      "avg_cvss": 7.1,
+      "cvss_count": 15
+    },
+    {
+      "date": "2018-09-28",
+      "value": 62,
+      "avg_cvss": 8.0,
+      "cvss_count": 62
+    },
+    {
+      "date": "2018-09-29",
+      "value": 2,
+      "avg_cvss": 7.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2018-09-30",
+      "value": 6,
+      "avg_cvss": 7.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2018-10-01",
+      "value": 51,
+      "avg_cvss": 7.3,
+      "cvss_count": 51
+    },
+    {
+      "date": "2018-10-02",
+      "value": 78,
+      "avg_cvss": 6.6,
+      "cvss_count": 78
+    },
+    {
+      "date": "2018-10-03",
+      "value": 40,
+      "avg_cvss": 7.4,
+      "cvss_count": 40
+    },
+    {
+      "date": "2018-10-04",
+      "value": 29,
+      "avg_cvss": 6.3,
+      "cvss_count": 29
+    },
+    {
+      "date": "2018-10-05",
+      "value": 134,
+      "avg_cvss": 7.3,
+      "cvss_count": 134
+    },
+    {
+      "date": "2018-10-06",
+      "value": 2,
+      "avg_cvss": 6.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2018-10-07",
+      "value": 6,
+      "avg_cvss": 7.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2018-10-08",
+      "value": 48,
+      "avg_cvss": 7.4,
+      "cvss_count": 48
+    },
+    {
+      "date": "2018-10-09",
+      "value": 58,
+      "avg_cvss": 7.3,
+      "cvss_count": 58
+    },
+    {
+      "date": "2018-10-10",
+      "value": 110,
+      "avg_cvss": 7.0,
+      "cvss_count": 110
+    },
+    {
+      "date": "2018-10-11",
+      "value": 16,
+      "avg_cvss": 7.9,
+      "cvss_count": 16
+    },
+    {
+      "date": "2018-10-12",
+      "value": 114,
+      "avg_cvss": 6.8,
+      "cvss_count": 114
+    },
+    {
+      "date": "2018-10-14",
+      "value": 4,
+      "avg_cvss": 5.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2018-10-15",
+      "value": 33,
+      "avg_cvss": 7.3,
+      "cvss_count": 33
+    },
+    {
+      "date": "2018-10-16",
+      "value": 23,
+      "avg_cvss": 7.2,
+      "cvss_count": 23
+    },
+    {
+      "date": "2018-10-17",
+      "value": 261,
+      "avg_cvss": 6.7,
+      "cvss_count": 261
+    },
+    {
+      "date": "2018-10-18",
+      "value": 62,
+      "avg_cvss": 7.5,
+      "cvss_count": 62
+    },
+    {
+      "date": "2018-10-19",
+      "value": 42,
+      "avg_cvss": 7.7,
+      "cvss_count": 42
+    },
+    {
+      "date": "2018-10-20",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2018-10-21",
+      "value": 4,
+      "avg_cvss": 7.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2018-10-22",
+      "value": 14,
+      "avg_cvss": 7.7,
+      "cvss_count": 14
+    },
+    {
+      "date": "2018-10-23",
+      "value": 69,
+      "avg_cvss": 7.3,
+      "cvss_count": 69
+    },
+    {
+      "date": "2018-10-24",
+      "value": 35,
+      "avg_cvss": 7.1,
+      "cvss_count": 35
+    },
+    {
+      "date": "2018-10-25",
+      "value": 7,
+      "avg_cvss": 6.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2018-10-26",
+      "value": 36,
+      "avg_cvss": 7.2,
+      "cvss_count": 36
+    },
+    {
+      "date": "2018-10-29",
+      "value": 110,
+      "avg_cvss": 7.5,
+      "cvss_count": 110
+    },
+    {
+      "date": "2018-10-30",
+      "value": 40,
+      "avg_cvss": 7.5,
+      "cvss_count": 40
+    },
+    {
+      "date": "2018-10-31",
+      "value": 40,
+      "avg_cvss": 6.9,
+      "cvss_count": 40
+    },
+    {
+      "date": "2018-11-01",
+      "value": 29,
+      "avg_cvss": 7.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2018-11-02",
+      "value": 28,
+      "avg_cvss": 7.3,
+      "cvss_count": 28
+    },
+    {
+      "date": "2018-11-03",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2018-11-04",
+      "value": 6,
+      "avg_cvss": 8.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2018-11-05",
+      "value": 22,
+      "avg_cvss": 7.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2018-11-06",
+      "value": 52,
+      "avg_cvss": 7.3,
+      "cvss_count": 52
+    },
+    {
+      "date": "2018-11-07",
+      "value": 45,
+      "avg_cvss": 7.4,
+      "cvss_count": 45
+    },
+    {
+      "date": "2018-11-08",
+      "value": 38,
+      "avg_cvss": 7.0,
+      "cvss_count": 38
+    },
+    {
+      "date": "2018-11-09",
+      "value": 32,
+      "avg_cvss": 6.5,
+      "cvss_count": 32
+    },
+    {
+      "date": "2018-11-10",
+      "value": 8,
+      "avg_cvss": 7.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2018-11-11",
+      "value": 9,
+      "avg_cvss": 6.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2018-11-12",
+      "value": 43,
+      "avg_cvss": 7.2,
+      "cvss_count": 43
+    },
+    {
+      "date": "2018-11-13",
+      "value": 38,
+      "avg_cvss": 7.1,
+      "cvss_count": 38
+    },
+    {
+      "date": "2018-11-14",
+      "value": 157,
+      "avg_cvss": 7.1,
+      "cvss_count": 157
+    },
+    {
+      "date": "2018-11-15",
+      "value": 42,
+      "avg_cvss": 7.3,
+      "cvss_count": 42
+    },
+    {
+      "date": "2018-11-16",
+      "value": 39,
+      "avg_cvss": 7.9,
+      "cvss_count": 39
+    },
+    {
+      "date": "2018-11-17",
+      "value": 20,
+      "avg_cvss": 7.3,
+      "cvss_count": 20
+    },
+    {
+      "date": "2018-11-18",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2018-11-19",
+      "value": 9,
+      "avg_cvss": 9.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2018-11-20",
+      "value": 36,
+      "avg_cvss": 7.2,
+      "cvss_count": 36
+    },
+    {
+      "date": "2018-11-21",
+      "value": 15,
+      "avg_cvss": 7.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2018-11-22",
+      "value": 12,
+      "avg_cvss": 7.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2018-11-23",
+      "value": 13,
+      "avg_cvss": 7.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2018-11-24",
+      "value": 1,
+      "avg_cvss": 5.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2018-11-25",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2018-11-26",
+      "value": 60,
+      "avg_cvss": 7.6,
+      "cvss_count": 60
+    },
+    {
+      "date": "2018-11-27",
+      "value": 96,
+      "avg_cvss": 7.6,
+      "cvss_count": 96
+    },
+    {
+      "date": "2018-11-28",
+      "value": 41,
+      "avg_cvss": 7.3,
+      "cvss_count": 41
+    },
+    {
+      "date": "2018-11-29",
+      "value": 44,
+      "avg_cvss": 7.3,
+      "cvss_count": 44
+    },
+    {
+      "date": "2018-11-30",
+      "value": 37,
+      "avg_cvss": 7.4,
+      "cvss_count": 37
+    },
+    {
+      "date": "2018-12-01",
+      "value": 8,
+      "avg_cvss": 7.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2018-12-02",
+      "value": 1,
+      "avg_cvss": 6.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2018-12-03",
+      "value": 54,
+      "avg_cvss": 6.9,
+      "cvss_count": 54
+    },
+    {
+      "date": "2018-12-04",
+      "value": 80,
+      "avg_cvss": 7.1,
+      "cvss_count": 80
+    },
+    {
+      "date": "2018-12-05",
+      "value": 29,
+      "avg_cvss": 7.1,
+      "cvss_count": 29
+    },
+    {
+      "date": "2018-12-06",
+      "value": 75,
+      "avg_cvss": 6.8,
+      "cvss_count": 75
+    },
+    {
+      "date": "2018-12-07",
+      "value": 57,
+      "avg_cvss": 7.6,
+      "cvss_count": 57
+    },
+    {
+      "date": "2018-12-08",
+      "value": 8,
+      "avg_cvss": 7.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2018-12-09",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2018-12-10",
+      "value": 32,
+      "avg_cvss": 6.8,
+      "cvss_count": 32
+    },
+    {
+      "date": "2018-12-11",
+      "value": 53,
+      "avg_cvss": 7.4,
+      "cvss_count": 53
+    },
+    {
+      "date": "2018-12-12",
+      "value": 81,
+      "avg_cvss": 6.8,
+      "cvss_count": 81
+    },
+    {
+      "date": "2018-12-13",
+      "value": 48,
+      "avg_cvss": 6.3,
+      "cvss_count": 48
+    },
+    {
+      "date": "2018-12-14",
+      "value": 28,
+      "avg_cvss": 6.4,
+      "cvss_count": 28
+    },
+    {
+      "date": "2018-12-15",
+      "value": 3,
+      "avg_cvss": 7.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2018-12-17",
+      "value": 78,
+      "avg_cvss": 6.5,
+      "cvss_count": 78
+    },
+    {
+      "date": "2018-12-18",
+      "value": 19,
+      "avg_cvss": 6.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2018-12-19",
+      "value": 30,
+      "avg_cvss": 7.1,
+      "cvss_count": 30
+    },
+    {
+      "date": "2018-12-20",
+      "value": 136,
+      "avg_cvss": 7.8,
+      "cvss_count": 136
+    },
+    {
+      "date": "2018-12-21",
+      "value": 30,
+      "avg_cvss": 7.8,
+      "cvss_count": 30
+    },
+    {
+      "date": "2018-12-22",
+      "value": 14,
+      "avg_cvss": 5.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2018-12-23",
+      "value": 40,
+      "avg_cvss": 8.3,
+      "cvss_count": 40
+    },
+    {
+      "date": "2018-12-24",
+      "value": 41,
+      "avg_cvss": 7.9,
+      "cvss_count": 41
+    },
+    {
+      "date": "2018-12-25",
+      "value": 26,
+      "avg_cvss": 7.3,
+      "cvss_count": 26
+    },
+    {
+      "date": "2018-12-26",
+      "value": 33,
+      "avg_cvss": 7.3,
+      "cvss_count": 33
+    },
+    {
+      "date": "2018-12-27",
+      "value": 5,
+      "avg_cvss": 7.1,
+      "cvss_count": 5
+    },
+    {
+      "date": "2018-12-28",
+      "value": 88,
+      "avg_cvss": 6.9,
+      "cvss_count": 88
+    },
+    {
+      "date": "2018-12-30",
+      "value": 29,
+      "avg_cvss": 6.8,
+      "cvss_count": 29
+    },
+    {
+      "date": "2018-12-31",
+      "value": 34,
+      "avg_cvss": 7.3,
+      "cvss_count": 34
+    },
+    {
+      "date": "2019-01-01",
+      "value": 4,
+      "avg_cvss": 6.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2019-01-02",
+      "value": 29,
+      "avg_cvss": 8.1,
+      "cvss_count": 29
+    },
+    {
+      "date": "2019-01-03",
+      "value": 58,
+      "avg_cvss": 7.0,
+      "cvss_count": 58
+    },
+    {
+      "date": "2019-01-04",
+      "value": 10,
+      "avg_cvss": 6.1,
+      "cvss_count": 10
+    },
+    {
+      "date": "2019-01-07",
+      "value": 8,
+      "avg_cvss": 7.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2019-01-08",
+      "value": 71,
+      "avg_cvss": 7.1,
+      "cvss_count": 71
+    },
+    {
+      "date": "2019-01-09",
+      "value": 196,
+      "avg_cvss": 7.3,
+      "cvss_count": 196
+    },
+    {
+      "date": "2019-01-10",
+      "value": 48,
+      "avg_cvss": 6.6,
+      "cvss_count": 48
+    },
+    {
+      "date": "2019-01-11",
+      "value": 58,
+      "avg_cvss": 7.5,
+      "cvss_count": 58
+    },
+    {
+      "date": "2019-01-12",
+      "value": 4,
+      "avg_cvss": 6.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2019-01-13",
+      "value": 9,
+      "avg_cvss": 7.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2019-01-14",
+      "value": 14,
+      "avg_cvss": 7.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2019-01-15",
+      "value": 60,
+      "avg_cvss": 7.3,
+      "cvss_count": 60
+    },
+    {
+      "date": "2019-01-16",
+      "value": 212,
+      "avg_cvss": 6.4,
+      "cvss_count": 212
+    },
+    {
+      "date": "2019-01-17",
+      "value": 12,
+      "avg_cvss": 7.2,
+      "cvss_count": 12
+    },
+    {
+      "date": "2019-01-18",
+      "value": 123,
+      "avg_cvss": 7.6,
+      "cvss_count": 123
+    },
+    {
+      "date": "2019-01-20",
+      "value": 3,
+      "avg_cvss": 8.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2019-01-21",
+      "value": 4,
+      "avg_cvss": 7.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2019-01-22",
+      "value": 27,
+      "avg_cvss": 8.1,
+      "cvss_count": 27
+    },
+    {
+      "date": "2019-01-23",
+      "value": 28,
+      "avg_cvss": 7.3,
+      "cvss_count": 28
+    },
+    {
+      "date": "2019-01-24",
+      "value": 107,
+      "avg_cvss": 8.3,
+      "cvss_count": 107
+    },
+    {
+      "date": "2019-01-25",
+      "value": 13,
+      "avg_cvss": 7.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2019-01-26",
+      "value": 3,
+      "avg_cvss": 7.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2019-01-27",
+      "value": 2,
+      "avg_cvss": 9.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2019-01-28",
+      "value": 28,
+      "avg_cvss": 6.6,
+      "cvss_count": 28
+    },
+    {
+      "date": "2019-01-29",
+      "value": 26,
+      "avg_cvss": 6.0,
+      "cvss_count": 26
+    },
+    {
+      "date": "2019-01-30",
+      "value": 26,
+      "avg_cvss": 7.2,
+      "cvss_count": 26
+    },
+    {
+      "date": "2019-01-31",
+      "value": 29,
+      "avg_cvss": 7.1,
+      "cvss_count": 29
+    },
+    {
+      "date": "2019-02-01",
+      "value": 26,
+      "avg_cvss": 7.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2019-02-03",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2019-02-04",
+      "value": 71,
+      "avg_cvss": 6.9,
+      "cvss_count": 71
+    },
+    {
+      "date": "2019-02-05",
+      "value": 66,
+      "avg_cvss": 7.8,
+      "cvss_count": 66
+    },
+    {
+      "date": "2019-02-06",
+      "value": 51,
+      "avg_cvss": 6.8,
+      "cvss_count": 51
+    },
+    {
+      "date": "2019-02-07",
+      "value": 35,
+      "avg_cvss": 7.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2019-02-08",
+      "value": 18,
+      "avg_cvss": 7.7,
+      "cvss_count": 18
+    },
+    {
+      "date": "2019-02-09",
+      "value": 14,
+      "avg_cvss": 7.8,
+      "cvss_count": 14
+    },
+    {
+      "date": "2019-02-10",
+      "value": 16,
+      "avg_cvss": 7.7,
+      "cvss_count": 16
+    },
+    {
+      "date": "2019-02-11",
+      "value": 60,
+      "avg_cvss": 7.5,
+      "cvss_count": 60
+    },
+    {
+      "date": "2019-02-12",
+      "value": 22,
+      "avg_cvss": 7.2,
+      "cvss_count": 22
+    },
+    {
+      "date": "2019-02-13",
+      "value": 42,
+      "avg_cvss": 7.5,
+      "cvss_count": 42
+    },
+    {
+      "date": "2019-02-14",
+      "value": 1,
+      "avg_cvss": 6.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-02-15",
+      "value": 31,
+      "avg_cvss": 7.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2019-02-16",
+      "value": 5,
+      "avg_cvss": 7.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2019-02-17",
+      "value": 30,
+      "avg_cvss": 7.5,
+      "cvss_count": 30
+    },
+    {
+      "date": "2019-02-18",
+      "value": 43,
+      "avg_cvss": 7.2,
+      "cvss_count": 43
+    },
+    {
+      "date": "2019-02-19",
+      "value": 38,
+      "avg_cvss": 7.4,
+      "cvss_count": 38
+    },
+    {
+      "date": "2019-02-20",
+      "value": 25,
+      "avg_cvss": 7.2,
+      "cvss_count": 25
+    },
+    {
+      "date": "2019-02-21",
+      "value": 35,
+      "avg_cvss": 6.6,
+      "cvss_count": 35
+    },
+    {
+      "date": "2019-02-22",
+      "value": 16,
+      "avg_cvss": 8.0,
+      "cvss_count": 16
+    },
+    {
+      "date": "2019-02-23",
+      "value": 31,
+      "avg_cvss": 7.4,
+      "cvss_count": 31
+    },
+    {
+      "date": "2019-02-24",
+      "value": 12,
+      "avg_cvss": 6.9,
+      "cvss_count": 12
+    },
+    {
+      "date": "2019-02-25",
+      "value": 55,
+      "avg_cvss": 7.5,
+      "cvss_count": 55
+    },
+    {
+      "date": "2019-02-26",
+      "value": 19,
+      "avg_cvss": 8.1,
+      "cvss_count": 19
+    },
+    {
+      "date": "2019-02-27",
+      "value": 18,
+      "avg_cvss": 7.0,
+      "cvss_count": 18
+    },
+    {
+      "date": "2019-02-28",
+      "value": 54,
+      "avg_cvss": 7.6,
+      "cvss_count": 54
+    },
+    {
+      "date": "2019-03-01",
+      "value": 11,
+      "avg_cvss": 7.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2019-03-02",
+      "value": 2,
+      "avg_cvss": 5.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2019-03-03",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2019-03-04",
+      "value": 11,
+      "avg_cvss": 7.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2019-03-05",
+      "value": 153,
+      "avg_cvss": 7.3,
+      "cvss_count": 153
+    },
+    {
+      "date": "2019-03-06",
+      "value": 39,
+      "avg_cvss": 7.2,
+      "cvss_count": 39
+    },
+    {
+      "date": "2019-03-07",
+      "value": 65,
+      "avg_cvss": 7.8,
+      "cvss_count": 65
+    },
+    {
+      "date": "2019-03-08",
+      "value": 51,
+      "avg_cvss": 8.2,
+      "cvss_count": 51
+    },
+    {
+      "date": "2019-03-09",
+      "value": 6,
+      "avg_cvss": 7.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2019-03-10",
+      "value": 1,
+      "avg_cvss": 6.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-03-11",
+      "value": 38,
+      "avg_cvss": 7.3,
+      "cvss_count": 38
+    },
+    {
+      "date": "2019-03-12",
+      "value": 34,
+      "avg_cvss": 6.9,
+      "cvss_count": 34
+    },
+    {
+      "date": "2019-03-13",
+      "value": 31,
+      "avg_cvss": 7.0,
+      "cvss_count": 31
+    },
+    {
+      "date": "2019-03-14",
+      "value": 84,
+      "avg_cvss": 6.6,
+      "cvss_count": 84
+    },
+    {
+      "date": "2019-03-15",
+      "value": 30,
+      "avg_cvss": 7.6,
+      "cvss_count": 30
+    },
+    {
+      "date": "2019-03-17",
+      "value": 1,
+      "avg_cvss": 6.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-03-18",
+      "value": 2,
+      "avg_cvss": 8.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2019-03-21",
+      "value": 262,
+      "avg_cvss": 7.2,
+      "cvss_count": 262
+    },
+    {
+      "date": "2019-03-22",
+      "value": 26,
+      "avg_cvss": 6.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2019-03-23",
+      "value": 6,
+      "avg_cvss": 7.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2019-03-24",
+      "value": 17,
+      "avg_cvss": 7.5,
+      "cvss_count": 17
+    },
+    {
+      "date": "2019-03-25",
+      "value": 72,
+      "avg_cvss": 7.5,
+      "cvss_count": 72
+    },
+    {
+      "date": "2019-03-26",
+      "value": 61,
+      "avg_cvss": 7.2,
+      "cvss_count": 61
+    },
+    {
+      "date": "2019-03-27",
+      "value": 63,
+      "avg_cvss": 7.3,
+      "cvss_count": 63
+    },
+    {
+      "date": "2019-03-28",
+      "value": 72,
+      "avg_cvss": 7.4,
+      "cvss_count": 72
+    },
+    {
+      "date": "2019-03-29",
+      "value": 22,
+      "avg_cvss": 7.6,
+      "cvss_count": 22
+    },
+    {
+      "date": "2019-03-30",
+      "value": 17,
+      "avg_cvss": 8.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2019-03-31",
+      "value": 3,
+      "avg_cvss": 9.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2019-04-01",
+      "value": 51,
+      "avg_cvss": 7.1,
+      "cvss_count": 51
+    },
+    {
+      "date": "2019-04-02",
+      "value": 39,
+      "avg_cvss": 7.1,
+      "cvss_count": 39
+    },
+    {
+      "date": "2019-04-03",
+      "value": 202,
+      "avg_cvss": 7.3,
+      "cvss_count": 202
+    },
+    {
+      "date": "2019-04-04",
+      "value": 99,
+      "avg_cvss": 7.8,
+      "cvss_count": 99
+    },
+    {
+      "date": "2019-04-05",
+      "value": 22,
+      "avg_cvss": 8.1,
+      "cvss_count": 22
+    },
+    {
+      "date": "2019-04-06",
+      "value": 2,
+      "avg_cvss": 7.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2019-04-07",
+      "value": 8,
+      "avg_cvss": 6.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2019-04-08",
+      "value": 59,
+      "avg_cvss": 7.0,
+      "cvss_count": 59
+    },
+    {
+      "date": "2019-04-09",
+      "value": 191,
+      "avg_cvss": 7.1,
+      "cvss_count": 191
+    },
+    {
+      "date": "2019-04-10",
+      "value": 55,
+      "avg_cvss": 7.4,
+      "cvss_count": 55
+    },
+    {
+      "date": "2019-04-11",
+      "value": 31,
+      "avg_cvss": 8.0,
+      "cvss_count": 31
+    },
+    {
+      "date": "2019-04-12",
+      "value": 17,
+      "avg_cvss": 6.7,
+      "cvss_count": 17
+    },
+    {
+      "date": "2019-04-15",
+      "value": 35,
+      "avg_cvss": 7.8,
+      "cvss_count": 35
+    },
+    {
+      "date": "2019-04-16",
+      "value": 4,
+      "avg_cvss": 7.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2019-04-17",
+      "value": 71,
+      "avg_cvss": 7.2,
+      "cvss_count": 71
+    },
+    {
+      "date": "2019-04-18",
+      "value": 60,
+      "avg_cvss": 7.0,
+      "cvss_count": 60
+    },
+    {
+      "date": "2019-04-19",
+      "value": 29,
+      "avg_cvss": 7.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2019-04-20",
+      "value": 13,
+      "avg_cvss": 7.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2019-04-21",
+      "value": 5,
+      "avg_cvss": 5.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2019-04-22",
+      "value": 73,
+      "avg_cvss": 7.2,
+      "cvss_count": 73
+    },
+    {
+      "date": "2019-04-23",
+      "value": 188,
+      "avg_cvss": 6.7,
+      "cvss_count": 188
+    },
+    {
+      "date": "2019-04-24",
+      "value": 42,
+      "avg_cvss": 7.8,
+      "cvss_count": 42
+    },
+    {
+      "date": "2019-04-25",
+      "value": 69,
+      "avg_cvss": 7.1,
+      "cvss_count": 69
+    },
+    {
+      "date": "2019-04-26",
+      "value": 58,
+      "avg_cvss": 7.7,
+      "cvss_count": 58
+    },
+    {
+      "date": "2019-04-27",
+      "value": 3,
+      "avg_cvss": 8.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2019-04-28",
+      "value": 4,
+      "avg_cvss": 7.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2019-04-29",
+      "value": 26,
+      "avg_cvss": 7.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2019-04-30",
+      "value": 77,
+      "avg_cvss": 7.4,
+      "cvss_count": 77
+    },
+    {
+      "date": "2019-05-01",
+      "value": 17,
+      "avg_cvss": 7.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2019-05-02",
+      "value": 26,
+      "avg_cvss": 8.2,
+      "cvss_count": 26
+    },
+    {
+      "date": "2019-05-03",
+      "value": 59,
+      "avg_cvss": 6.9,
+      "cvss_count": 59
+    },
+    {
+      "date": "2019-05-05",
+      "value": 2,
+      "avg_cvss": 7.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2019-05-06",
+      "value": 47,
+      "avg_cvss": 7.5,
+      "cvss_count": 47
+    },
+    {
+      "date": "2019-05-07",
+      "value": 33,
+      "avg_cvss": 7.1,
+      "cvss_count": 33
+    },
+    {
+      "date": "2019-05-08",
+      "value": 40,
+      "avg_cvss": 7.6,
+      "cvss_count": 40
+    },
+    {
+      "date": "2019-05-09",
+      "value": 42,
+      "avg_cvss": 7.6,
+      "cvss_count": 42
+    },
+    {
+      "date": "2019-05-10",
+      "value": 33,
+      "avg_cvss": 7.1,
+      "cvss_count": 33
+    },
+    {
+      "date": "2019-05-12",
+      "value": 1,
+      "avg_cvss": 6.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-05-13",
+      "value": 80,
+      "avg_cvss": 7.5,
+      "cvss_count": 80
+    },
+    {
+      "date": "2019-05-14",
+      "value": 49,
+      "avg_cvss": 7.5,
+      "cvss_count": 49
+    },
+    {
+      "date": "2019-05-15",
+      "value": 68,
+      "avg_cvss": 6.8,
+      "cvss_count": 68
+    },
+    {
+      "date": "2019-05-16",
+      "value": 120,
+      "avg_cvss": 7.2,
+      "cvss_count": 120
+    },
+    {
+      "date": "2019-05-17",
+      "value": 92,
+      "avg_cvss": 6.7,
+      "cvss_count": 92
+    },
+    {
+      "date": "2019-05-18",
+      "value": 1,
+      "avg_cvss": 8.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-05-19",
+      "value": 1,
+      "avg_cvss": 5.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-05-20",
+      "value": 31,
+      "avg_cvss": 7.1,
+      "cvss_count": 31
+    },
+    {
+      "date": "2019-05-21",
+      "value": 11,
+      "avg_cvss": 6.2,
+      "cvss_count": 11
+    },
+    {
+      "date": "2019-05-22",
+      "value": 168,
+      "avg_cvss": 7.9,
+      "cvss_count": 168
+    },
+    {
+      "date": "2019-05-23",
+      "value": 111,
+      "avg_cvss": 8.0,
+      "cvss_count": 111
+    },
+    {
+      "date": "2019-05-24",
+      "value": 146,
+      "avg_cvss": 8.2,
+      "cvss_count": 146
+    },
+    {
+      "date": "2019-05-27",
+      "value": 4,
+      "avg_cvss": 6.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2019-05-28",
+      "value": 21,
+      "avg_cvss": 6.6,
+      "cvss_count": 21
+    },
+    {
+      "date": "2019-05-29",
+      "value": 48,
+      "avg_cvss": 7.5,
+      "cvss_count": 48
+    },
+    {
+      "date": "2019-05-30",
+      "value": 29,
+      "avg_cvss": 6.7,
+      "cvss_count": 29
+    },
+    {
+      "date": "2019-05-31",
+      "value": 36,
+      "avg_cvss": 7.6,
+      "cvss_count": 36
+    },
+    {
+      "date": "2019-06-02",
+      "value": 3,
+      "avg_cvss": 8.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2019-06-03",
+      "value": 93,
+      "avg_cvss": 7.6,
+      "cvss_count": 93
+    },
+    {
+      "date": "2019-06-04",
+      "value": 27,
+      "avg_cvss": 6.3,
+      "cvss_count": 27
+    },
+    {
+      "date": "2019-06-05",
+      "value": 156,
+      "avg_cvss": 8.3,
+      "cvss_count": 156
+    },
+    {
+      "date": "2019-06-06",
+      "value": 51,
+      "avg_cvss": 6.6,
+      "cvss_count": 51
+    },
+    {
+      "date": "2019-06-07",
+      "value": 76,
+      "avg_cvss": 7.9,
+      "cvss_count": 76
+    },
+    {
+      "date": "2019-06-10",
+      "value": 23,
+      "avg_cvss": 7.9,
+      "cvss_count": 23
+    },
+    {
+      "date": "2019-06-11",
+      "value": 41,
+      "avg_cvss": 7.6,
+      "cvss_count": 41
+    },
+    {
+      "date": "2019-06-12",
+      "value": 123,
+      "avg_cvss": 6.5,
+      "cvss_count": 123
+    },
+    {
+      "date": "2019-06-13",
+      "value": 38,
+      "avg_cvss": 6.4,
+      "cvss_count": 38
+    },
+    {
+      "date": "2019-06-14",
+      "value": 45,
+      "avg_cvss": 7.7,
+      "cvss_count": 45
+    },
+    {
+      "date": "2019-06-15",
+      "value": 8,
+      "avg_cvss": 8.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2019-06-16",
+      "value": 1,
+      "avg_cvss": 7.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-06-17",
+      "value": 69,
+      "avg_cvss": 7.3,
+      "cvss_count": 69
+    },
+    {
+      "date": "2019-06-18",
+      "value": 40,
+      "avg_cvss": 7.5,
+      "cvss_count": 40
+    },
+    {
+      "date": "2019-06-19",
+      "value": 101,
+      "avg_cvss": 7.9,
+      "cvss_count": 101
+    },
+    {
+      "date": "2019-06-20",
+      "value": 56,
+      "avg_cvss": 6.7,
+      "cvss_count": 56
+    },
+    {
+      "date": "2019-06-21",
+      "value": 25,
+      "avg_cvss": 7.3,
+      "cvss_count": 25
+    },
+    {
+      "date": "2019-06-23",
+      "value": 3,
+      "avg_cvss": 7.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2019-06-24",
+      "value": 28,
+      "avg_cvss": 7.5,
+      "cvss_count": 28
+    },
+    {
+      "date": "2019-06-25",
+      "value": 28,
+      "avg_cvss": 6.5,
+      "cvss_count": 28
+    },
+    {
+      "date": "2019-06-26",
+      "value": 35,
+      "avg_cvss": 7.0,
+      "cvss_count": 35
+    },
+    {
+      "date": "2019-06-27",
+      "value": 106,
+      "avg_cvss": 7.1,
+      "cvss_count": 106
+    },
+    {
+      "date": "2019-06-28",
+      "value": 39,
+      "avg_cvss": 7.7,
+      "cvss_count": 39
+    },
+    {
+      "date": "2019-06-29",
+      "value": 13,
+      "avg_cvss": 7.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2019-06-30",
+      "value": 26,
+      "avg_cvss": 7.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2019-07-01",
+      "value": 59,
+      "avg_cvss": 7.1,
+      "cvss_count": 59
+    },
+    {
+      "date": "2019-07-02",
+      "value": 69,
+      "avg_cvss": 8.3,
+      "cvss_count": 69
+    },
+    {
+      "date": "2019-07-03",
+      "value": 97,
+      "avg_cvss": 7.7,
+      "cvss_count": 97
+    },
+    {
+      "date": "2019-07-04",
+      "value": 48,
+      "avg_cvss": 7.4,
+      "cvss_count": 48
+    },
+    {
+      "date": "2019-07-05",
+      "value": 59,
+      "avg_cvss": 7.6,
+      "cvss_count": 59
+    },
+    {
+      "date": "2019-07-06",
+      "value": 19,
+      "avg_cvss": 7.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2019-07-07",
+      "value": 4,
+      "avg_cvss": 8.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2019-07-08",
+      "value": 33,
+      "avg_cvss": 7.6,
+      "cvss_count": 33
+    },
+    {
+      "date": "2019-07-09",
+      "value": 37,
+      "avg_cvss": 7.3,
+      "cvss_count": 37
+    },
+    {
+      "date": "2019-07-10",
+      "value": 89,
+      "avg_cvss": 7.1,
+      "cvss_count": 89
+    },
+    {
+      "date": "2019-07-11",
+      "value": 84,
+      "avg_cvss": 7.1,
+      "cvss_count": 84
+    },
+    {
+      "date": "2019-07-12",
+      "value": 11,
+      "avg_cvss": 7.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2019-07-13",
+      "value": 2,
+      "avg_cvss": 6.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2019-07-14",
+      "value": 6,
+      "avg_cvss": 8.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2019-07-15",
+      "value": 117,
+      "avg_cvss": 7.4,
+      "cvss_count": 117
+    },
+    {
+      "date": "2019-07-16",
+      "value": 37,
+      "avg_cvss": 8.1,
+      "cvss_count": 37
+    },
+    {
+      "date": "2019-07-17",
+      "value": 68,
+      "avg_cvss": 7.1,
+      "cvss_count": 68
+    },
+    {
+      "date": "2019-07-18",
+      "value": 60,
+      "avg_cvss": 7.3,
+      "cvss_count": 60
+    },
+    {
+      "date": "2019-07-19",
+      "value": 47,
+      "avg_cvss": 7.6,
+      "cvss_count": 47
+    },
+    {
+      "date": "2019-07-20",
+      "value": 3,
+      "avg_cvss": 8.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2019-07-21",
+      "value": 13,
+      "avg_cvss": 8.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2019-07-22",
+      "value": 36,
+      "avg_cvss": 7.3,
+      "cvss_count": 36
+    },
+    {
+      "date": "2019-07-23",
+      "value": 244,
+      "avg_cvss": 6.5,
+      "cvss_count": 244
+    },
+    {
+      "date": "2019-07-24",
+      "value": 20,
+      "avg_cvss": 6.8,
+      "cvss_count": 20
+    },
+    {
+      "date": "2019-07-25",
+      "value": 62,
+      "avg_cvss": 7.8,
+      "cvss_count": 62
+    },
+    {
+      "date": "2019-07-26",
+      "value": 43,
+      "avg_cvss": 7.1,
+      "cvss_count": 43
+    },
+    {
+      "date": "2019-07-27",
+      "value": 20,
+      "avg_cvss": 6.9,
+      "cvss_count": 20
+    },
+    {
+      "date": "2019-07-28",
+      "value": 20,
+      "avg_cvss": 7.0,
+      "cvss_count": 20
+    },
+    {
+      "date": "2019-07-29",
+      "value": 54,
+      "avg_cvss": 7.1,
+      "cvss_count": 54
+    },
+    {
+      "date": "2019-07-30",
+      "value": 95,
+      "avg_cvss": 6.3,
+      "cvss_count": 95
+    },
+    {
+      "date": "2019-07-31",
+      "value": 62,
+      "avg_cvss": 7.4,
+      "cvss_count": 62
+    },
+    {
+      "date": "2019-08-01",
+      "value": 162,
+      "avg_cvss": 6.3,
+      "cvss_count": 162
+    },
+    {
+      "date": "2019-08-02",
+      "value": 182,
+      "avg_cvss": 6.0,
+      "cvss_count": 182
+    },
+    {
+      "date": "2019-08-03",
+      "value": 2,
+      "avg_cvss": 8.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2019-08-05",
+      "value": 60,
+      "avg_cvss": 6.2,
+      "cvss_count": 60
+    },
+    {
+      "date": "2019-08-06",
+      "value": 62,
+      "avg_cvss": 7.6,
+      "cvss_count": 62
+    },
+    {
+      "date": "2019-08-07",
+      "value": 77,
+      "avg_cvss": 7.4,
+      "cvss_count": 77
+    },
+    {
+      "date": "2019-08-08",
+      "value": 59,
+      "avg_cvss": 6.8,
+      "cvss_count": 59
+    },
+    {
+      "date": "2019-08-09",
+      "value": 54,
+      "avg_cvss": 7.1,
+      "cvss_count": 54
+    },
+    {
+      "date": "2019-08-10",
+      "value": 4,
+      "avg_cvss": 3.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2019-08-11",
+      "value": 2,
+      "avg_cvss": 8.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2019-08-12",
+      "value": 48,
+      "avg_cvss": 6.6,
+      "cvss_count": 48
+    },
+    {
+      "date": "2019-08-13",
+      "value": 69,
+      "avg_cvss": 7.0,
+      "cvss_count": 69
+    },
+    {
+      "date": "2019-08-14",
+      "value": 173,
+      "avg_cvss": 7.5,
+      "cvss_count": 173
+    },
+    {
+      "date": "2019-08-15",
+      "value": 54,
+      "avg_cvss": 7.2,
+      "cvss_count": 54
+    },
+    {
+      "date": "2019-08-16",
+      "value": 47,
+      "avg_cvss": 8.2,
+      "cvss_count": 47
+    },
+    {
+      "date": "2019-08-17",
+      "value": 5,
+      "avg_cvss": 6.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2019-08-18",
+      "value": 17,
+      "avg_cvss": 7.1,
+      "cvss_count": 17
+    },
+    {
+      "date": "2019-08-19",
+      "value": 39,
+      "avg_cvss": 6.4,
+      "cvss_count": 39
+    },
+    {
+      "date": "2019-08-20",
+      "value": 200,
+      "avg_cvss": 7.4,
+      "cvss_count": 200
+    },
+    {
+      "date": "2019-08-21",
+      "value": 114,
+      "avg_cvss": 7.0,
+      "cvss_count": 114
+    },
+    {
+      "date": "2019-08-22",
+      "value": 111,
+      "avg_cvss": 7.6,
+      "cvss_count": 111
+    },
+    {
+      "date": "2019-08-23",
+      "value": 75,
+      "avg_cvss": 7.2,
+      "cvss_count": 75
+    },
+    {
+      "date": "2019-08-25",
+      "value": 2,
+      "avg_cvss": 7.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2019-08-26",
+      "value": 121,
+      "avg_cvss": 8.6,
+      "cvss_count": 121
+    },
+    {
+      "date": "2019-08-27",
+      "value": 62,
+      "avg_cvss": 7.9,
+      "cvss_count": 62
+    },
+    {
+      "date": "2019-08-28",
+      "value": 68,
+      "avg_cvss": 6.9,
+      "cvss_count": 68
+    },
+    {
+      "date": "2019-08-29",
+      "value": 76,
+      "avg_cvss": 7.6,
+      "cvss_count": 76
+    },
+    {
+      "date": "2019-08-30",
+      "value": 56,
+      "avg_cvss": 7.3,
+      "cvss_count": 56
+    },
+    {
+      "date": "2019-09-02",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-09-03",
+      "value": 36,
+      "avg_cvss": 6.9,
+      "cvss_count": 36
+    },
+    {
+      "date": "2019-09-04",
+      "value": 37,
+      "avg_cvss": 6.7,
+      "cvss_count": 37
+    },
+    {
+      "date": "2019-09-05",
+      "value": 59,
+      "avg_cvss": 7.4,
+      "cvss_count": 59
+    },
+    {
+      "date": "2019-09-06",
+      "value": 55,
+      "avg_cvss": 7.2,
+      "cvss_count": 55
+    },
+    {
+      "date": "2019-09-08",
+      "value": 22,
+      "avg_cvss": 7.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2019-09-09",
+      "value": 97,
+      "avg_cvss": 6.8,
+      "cvss_count": 97
+    },
+    {
+      "date": "2019-09-10",
+      "value": 57,
+      "avg_cvss": 6.6,
+      "cvss_count": 57
+    },
+    {
+      "date": "2019-09-11",
+      "value": 137,
+      "avg_cvss": 7.0,
+      "cvss_count": 137
+    },
+    {
+      "date": "2019-09-12",
+      "value": 42,
+      "avg_cvss": 7.2,
+      "cvss_count": 42
+    },
+    {
+      "date": "2019-09-13",
+      "value": 49,
+      "avg_cvss": 7.5,
+      "cvss_count": 49
+    },
+    {
+      "date": "2019-09-14",
+      "value": 12,
+      "avg_cvss": 8.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2019-09-15",
+      "value": 8,
+      "avg_cvss": 6.9,
+      "cvss_count": 8
+    },
+    {
+      "date": "2019-09-16",
+      "value": 71,
+      "avg_cvss": 7.0,
+      "cvss_count": 71
+    },
+    {
+      "date": "2019-09-17",
+      "value": 72,
+      "avg_cvss": 7.1,
+      "cvss_count": 72
+    },
+    {
+      "date": "2019-09-18",
+      "value": 41,
+      "avg_cvss": 7.7,
+      "cvss_count": 41
+    },
+    {
+      "date": "2019-09-19",
+      "value": 19,
+      "avg_cvss": 7.2,
+      "cvss_count": 19
+    },
+    {
+      "date": "2019-09-20",
+      "value": 77,
+      "avg_cvss": 6.9,
+      "cvss_count": 77
+    },
+    {
+      "date": "2019-09-21",
+      "value": 17,
+      "avg_cvss": 7.0,
+      "cvss_count": 17
+    },
+    {
+      "date": "2019-09-22",
+      "value": 6,
+      "avg_cvss": 9.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2019-09-23",
+      "value": 39,
+      "avg_cvss": 7.0,
+      "cvss_count": 39
+    },
+    {
+      "date": "2019-09-24",
+      "value": 30,
+      "avg_cvss": 7.6,
+      "cvss_count": 30
+    },
+    {
+      "date": "2019-09-25",
+      "value": 93,
+      "avg_cvss": 6.9,
+      "cvss_count": 93
+    },
+    {
+      "date": "2019-09-26",
+      "value": 77,
+      "avg_cvss": 6.6,
+      "cvss_count": 77
+    },
+    {
+      "date": "2019-09-27",
+      "value": 309,
+      "avg_cvss": 7.0,
+      "cvss_count": 309
+    },
+    {
+      "date": "2019-09-28",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2019-09-30",
+      "value": 63,
+      "avg_cvss": 7.3,
+      "cvss_count": 63
+    },
+    {
+      "date": "2019-10-01",
+      "value": 47,
+      "avg_cvss": 6.4,
+      "cvss_count": 47
+    },
+    {
+      "date": "2019-10-02",
+      "value": 74,
+      "avg_cvss": 7.4,
+      "cvss_count": 74
+    },
+    {
+      "date": "2019-10-03",
+      "value": 52,
+      "avg_cvss": 7.2,
+      "cvss_count": 52
+    },
+    {
+      "date": "2019-10-04",
+      "value": 32,
+      "avg_cvss": 7.5,
+      "cvss_count": 32
+    },
+    {
+      "date": "2019-10-05",
+      "value": 8,
+      "avg_cvss": 7.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2019-10-06",
+      "value": 13,
+      "avg_cvss": 7.4,
+      "cvss_count": 13
+    },
+    {
+      "date": "2019-10-07",
+      "value": 57,
+      "avg_cvss": 8.2,
+      "cvss_count": 57
+    },
+    {
+      "date": "2019-10-08",
+      "value": 77,
+      "avg_cvss": 7.2,
+      "cvss_count": 77
+    },
+    {
+      "date": "2019-10-09",
+      "value": 103,
+      "avg_cvss": 7.3,
+      "cvss_count": 103
+    },
+    {
+      "date": "2019-10-10",
+      "value": 133,
+      "avg_cvss": 7.2,
+      "cvss_count": 133
+    },
+    {
+      "date": "2019-10-11",
+      "value": 52,
+      "avg_cvss": 7.5,
+      "cvss_count": 52
+    },
+    {
+      "date": "2019-10-12",
+      "value": 9,
+      "avg_cvss": 7.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2019-10-13",
+      "value": 6,
+      "avg_cvss": 7.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2019-10-14",
+      "value": 42,
+      "avg_cvss": 7.9,
+      "cvss_count": 42
+    },
+    {
+      "date": "2019-10-15",
+      "value": 19,
+      "avg_cvss": 8.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2019-10-16",
+      "value": 243,
+      "avg_cvss": 6.1,
+      "cvss_count": 243
+    },
+    {
+      "date": "2019-10-17",
+      "value": 112,
+      "avg_cvss": 8.1,
+      "cvss_count": 112
+    },
+    {
+      "date": "2019-10-18",
+      "value": 13,
+      "avg_cvss": 8.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2019-10-19",
+      "value": 3,
+      "avg_cvss": 6.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2019-10-20",
+      "value": 1,
+      "avg_cvss": 6.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-10-21",
+      "value": 37,
+      "avg_cvss": 6.9,
+      "cvss_count": 37
+    },
+    {
+      "date": "2019-10-22",
+      "value": 24,
+      "avg_cvss": 7.0,
+      "cvss_count": 24
+    },
+    {
+      "date": "2019-10-23",
+      "value": 95,
+      "avg_cvss": 6.8,
+      "cvss_count": 95
+    },
+    {
+      "date": "2019-10-24",
+      "value": 39,
+      "avg_cvss": 7.4,
+      "cvss_count": 39
+    },
+    {
+      "date": "2019-10-25",
+      "value": 56,
+      "avg_cvss": 8.0,
+      "cvss_count": 56
+    },
+    {
+      "date": "2019-10-28",
+      "value": 35,
+      "avg_cvss": 7.9,
+      "cvss_count": 35
+    },
+    {
+      "date": "2019-10-29",
+      "value": 76,
+      "avg_cvss": 7.3,
+      "cvss_count": 76
+    },
+    {
+      "date": "2019-10-30",
+      "value": 33,
+      "avg_cvss": 7.2,
+      "cvss_count": 33
+    },
+    {
+      "date": "2019-10-31",
+      "value": 75,
+      "avg_cvss": 7.2,
+      "cvss_count": 75
+    },
+    {
+      "date": "2019-11-01",
+      "value": 32,
+      "avg_cvss": 6.8,
+      "cvss_count": 32
+    },
+    {
+      "date": "2019-11-02",
+      "value": 10,
+      "avg_cvss": 6.2,
+      "cvss_count": 10
+    },
+    {
+      "date": "2019-11-04",
+      "value": 43,
+      "avg_cvss": 7.4,
+      "cvss_count": 43
+    },
+    {
+      "date": "2019-11-05",
+      "value": 87,
+      "avg_cvss": 6.9,
+      "cvss_count": 87
+    },
+    {
+      "date": "2019-11-06",
+      "value": 144,
+      "avg_cvss": 7.4,
+      "cvss_count": 144
+    },
+    {
+      "date": "2019-11-07",
+      "value": 61,
+      "avg_cvss": 7.0,
+      "cvss_count": 61
+    },
+    {
+      "date": "2019-11-08",
+      "value": 30,
+      "avg_cvss": 7.0,
+      "cvss_count": 30
+    },
+    {
+      "date": "2019-11-09",
+      "value": 29,
+      "avg_cvss": 6.1,
+      "cvss_count": 29
+    },
+    {
+      "date": "2019-11-11",
+      "value": 10,
+      "avg_cvss": 7.4,
+      "cvss_count": 10
+    },
+    {
+      "date": "2019-11-12",
+      "value": 134,
+      "avg_cvss": 7.2,
+      "cvss_count": 134
+    },
+    {
+      "date": "2019-11-13",
+      "value": 105,
+      "avg_cvss": 7.1,
+      "cvss_count": 105
+    },
+    {
+      "date": "2019-11-14",
+      "value": 267,
+      "avg_cvss": 6.6,
+      "cvss_count": 267
+    },
+    {
+      "date": "2019-11-15",
+      "value": 36,
+      "avg_cvss": 7.5,
+      "cvss_count": 36
+    },
+    {
+      "date": "2019-11-16",
+      "value": 1,
+      "avg_cvss": 9.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-11-17",
+      "value": 6,
+      "avg_cvss": 7.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2019-11-18",
+      "value": 77,
+      "avg_cvss": 6.5,
+      "cvss_count": 77
+    },
+    {
+      "date": "2019-11-19",
+      "value": 31,
+      "avg_cvss": 7.2,
+      "cvss_count": 31
+    },
+    {
+      "date": "2019-11-20",
+      "value": 42,
+      "avg_cvss": 7.5,
+      "cvss_count": 42
+    },
+    {
+      "date": "2019-11-21",
+      "value": 104,
+      "avg_cvss": 7.5,
+      "cvss_count": 104
+    },
+    {
+      "date": "2019-11-22",
+      "value": 56,
+      "avg_cvss": 6.7,
+      "cvss_count": 56
+    },
+    {
+      "date": "2019-11-23",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-11-25",
+      "value": 144,
+      "avg_cvss": 6.7,
+      "cvss_count": 144
+    },
+    {
+      "date": "2019-11-26",
+      "value": 128,
+      "avg_cvss": 6.9,
+      "cvss_count": 128
+    },
+    {
+      "date": "2019-11-27",
+      "value": 49,
+      "avg_cvss": 7.0,
+      "cvss_count": 49
+    },
+    {
+      "date": "2019-11-28",
+      "value": 6,
+      "avg_cvss": 6.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2019-11-29",
+      "value": 38,
+      "avg_cvss": 6.7,
+      "cvss_count": 38
+    },
+    {
+      "date": "2019-11-30",
+      "value": 6,
+      "avg_cvss": 6.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2019-12-01",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2019-12-02",
+      "value": 41,
+      "avg_cvss": 7.6,
+      "cvss_count": 41
+    },
+    {
+      "date": "2019-12-03",
+      "value": 64,
+      "avg_cvss": 6.7,
+      "cvss_count": 64
+    },
+    {
+      "date": "2019-12-04",
+      "value": 31,
+      "avg_cvss": 7.9,
+      "cvss_count": 31
+    },
+    {
+      "date": "2019-12-05",
+      "value": 52,
+      "avg_cvss": 7.2,
+      "cvss_count": 52
+    },
+    {
+      "date": "2019-12-06",
+      "value": 48,
+      "avg_cvss": 7.0,
+      "cvss_count": 48
+    },
+    {
+      "date": "2019-12-07",
+      "value": 1,
+      "avg_cvss": 3.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-12-08",
+      "value": 9,
+      "avg_cvss": 8.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2019-12-09",
+      "value": 27,
+      "avg_cvss": 7.4,
+      "cvss_count": 27
+    },
+    {
+      "date": "2019-12-10",
+      "value": 99,
+      "avg_cvss": 6.9,
+      "cvss_count": 99
+    },
+    {
+      "date": "2019-12-11",
+      "value": 65,
+      "avg_cvss": 7.4,
+      "cvss_count": 65
+    },
+    {
+      "date": "2019-12-12",
+      "value": 132,
+      "avg_cvss": 7.8,
+      "cvss_count": 132
+    },
+    {
+      "date": "2019-12-13",
+      "value": 57,
+      "avg_cvss": 7.6,
+      "cvss_count": 57
+    },
+    {
+      "date": "2019-12-14",
+      "value": 2,
+      "avg_cvss": 4.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "2019-12-15",
+      "value": 10,
+      "avg_cvss": 7.3,
+      "cvss_count": 10
+    },
+    {
+      "date": "2019-12-16",
+      "value": 45,
+      "avg_cvss": 7.0,
+      "cvss_count": 45
+    },
+    {
+      "date": "2019-12-17",
+      "value": 75,
+      "avg_cvss": 7.0,
+      "cvss_count": 75
+    },
+    {
+      "date": "2019-12-18",
+      "value": 364,
+      "avg_cvss": 7.4,
+      "cvss_count": 364
+    },
+    {
+      "date": "2019-12-19",
+      "value": 57,
+      "avg_cvss": 8.2,
+      "cvss_count": 57
+    },
+    {
+      "date": "2019-12-20",
+      "value": 36,
+      "avg_cvss": 7.2,
+      "cvss_count": 36
+    },
+    {
+      "date": "2019-12-22",
+      "value": 2,
+      "avg_cvss": 7.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2019-12-23",
+      "value": 56,
+      "avg_cvss": 7.1,
+      "cvss_count": 56
+    },
+    {
+      "date": "2019-12-24",
+      "value": 19,
+      "avg_cvss": 7.7,
+      "cvss_count": 19
+    },
+    {
+      "date": "2019-12-25",
+      "value": 6,
+      "avg_cvss": 5.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2019-12-26",
+      "value": 72,
+      "avg_cvss": 6.9,
+      "cvss_count": 72
+    },
+    {
+      "date": "2019-12-27",
+      "value": 66,
+      "avg_cvss": 7.0,
+      "cvss_count": 66
+    },
+    {
+      "date": "2019-12-28",
+      "value": 1,
+      "avg_cvss": 5.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2019-12-29",
+      "value": 5,
+      "avg_cvss": 6.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2019-12-30",
+      "value": 72,
+      "avg_cvss": 6.8,
+      "cvss_count": 72
+    },
+    {
+      "date": "2019-12-31",
+      "value": 58,
+      "avg_cvss": 6.8,
+      "cvss_count": 58
+    },
+    {
+      "date": "2020-01-02",
+      "value": 57,
+      "avg_cvss": 7.1,
+      "cvss_count": 57
+    },
+    {
+      "date": "2020-01-03",
+      "value": 54,
+      "avg_cvss": 6.9,
+      "cvss_count": 54
+    },
+    {
+      "date": "2020-01-04",
+      "value": 4,
+      "avg_cvss": 6.9,
+      "cvss_count": 4
+    },
+    {
+      "date": "2020-01-05",
+      "value": 15,
+      "avg_cvss": 6.8,
+      "cvss_count": 15
+    },
+    {
+      "date": "2020-01-06",
+      "value": 63,
+      "avg_cvss": 7.3,
+      "cvss_count": 63
+    },
+    {
+      "date": "2020-01-07",
+      "value": 33,
+      "avg_cvss": 7.3,
+      "cvss_count": 33
+    },
+    {
+      "date": "2020-01-08",
+      "value": 100,
+      "avg_cvss": 7.6,
+      "cvss_count": 100
+    },
+    {
+      "date": "2020-01-09",
+      "value": 75,
+      "avg_cvss": 7.2,
+      "cvss_count": 75
+    },
+    {
+      "date": "2020-01-10",
+      "value": 43,
+      "avg_cvss": 7.3,
+      "cvss_count": 43
+    },
+    {
+      "date": "2020-01-11",
+      "value": 8,
+      "avg_cvss": 7.9,
+      "cvss_count": 8
+    },
+    {
+      "date": "2020-01-13",
+      "value": 42,
+      "avg_cvss": 6.7,
+      "cvss_count": 42
+    },
+    {
+      "date": "2020-01-14",
+      "value": 106,
+      "avg_cvss": 7.3,
+      "cvss_count": 106
+    },
+    {
+      "date": "2020-01-15",
+      "value": 280,
+      "avg_cvss": 6.3,
+      "cvss_count": 280
+    },
+    {
+      "date": "2020-01-16",
+      "value": 29,
+      "avg_cvss": 7.3,
+      "cvss_count": 29
+    },
+    {
+      "date": "2020-01-17",
+      "value": 31,
+      "avg_cvss": 7.0,
+      "cvss_count": 31
+    },
+    {
+      "date": "2020-01-18",
+      "value": 6,
+      "avg_cvss": 6.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2020-01-19",
+      "value": 6,
+      "avg_cvss": 6.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2020-01-20",
+      "value": 8,
+      "avg_cvss": 7.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2020-01-21",
+      "value": 77,
+      "avg_cvss": 7.7,
+      "cvss_count": 77
+    },
+    {
+      "date": "2020-01-22",
+      "value": 52,
+      "avg_cvss": 7.8,
+      "cvss_count": 52
+    },
+    {
+      "date": "2020-01-23",
+      "value": 78,
+      "avg_cvss": 7.3,
+      "cvss_count": 78
+    },
+    {
+      "date": "2020-01-24",
+      "value": 65,
+      "avg_cvss": 7.6,
+      "cvss_count": 65
+    },
+    {
+      "date": "2020-01-25",
+      "value": 12,
+      "avg_cvss": 8.3,
+      "cvss_count": 12
+    },
+    {
+      "date": "2020-01-26",
+      "value": 31,
+      "avg_cvss": 6.8,
+      "cvss_count": 31
+    },
+    {
+      "date": "2020-01-27",
+      "value": 100,
+      "avg_cvss": 7.3,
+      "cvss_count": 100
+    },
+    {
+      "date": "2020-01-28",
+      "value": 120,
+      "avg_cvss": 6.8,
+      "cvss_count": 120
+    },
+    {
+      "date": "2020-01-29",
+      "value": 52,
+      "avg_cvss": 7.7,
+      "cvss_count": 52
+    },
+    {
+      "date": "2020-01-30",
+      "value": 58,
+      "avg_cvss": 6.9,
+      "cvss_count": 58
+    },
+    {
+      "date": "2020-01-31",
+      "value": 51,
+      "avg_cvss": 7.2,
+      "cvss_count": 51
+    },
+    {
+      "date": "2020-02-01",
+      "value": 2,
+      "avg_cvss": 8.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2020-02-02",
+      "value": 3,
+      "avg_cvss": 6.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2020-02-03",
+      "value": 36,
+      "avg_cvss": 7.2,
+      "cvss_count": 36
+    },
+    {
+      "date": "2020-02-04",
+      "value": 74,
+      "avg_cvss": 6.8,
+      "cvss_count": 74
+    },
+    {
+      "date": "2020-02-05",
+      "value": 64,
+      "avg_cvss": 7.3,
+      "cvss_count": 64
+    },
+    {
+      "date": "2020-02-06",
+      "value": 68,
+      "avg_cvss": 7.1,
+      "cvss_count": 68
+    },
+    {
+      "date": "2020-02-07",
+      "value": 67,
+      "avg_cvss": 7.8,
+      "cvss_count": 67
+    },
+    {
+      "date": "2020-02-08",
+      "value": 25,
+      "avg_cvss": 7.0,
+      "cvss_count": 25
+    },
+    {
+      "date": "2020-02-10",
+      "value": 52,
+      "avg_cvss": 6.9,
+      "cvss_count": 52
+    },
+    {
+      "date": "2020-02-11",
+      "value": 205,
+      "avg_cvss": 7.3,
+      "cvss_count": 205
+    },
+    {
+      "date": "2020-02-12",
+      "value": 115,
+      "avg_cvss": 7.0,
+      "cvss_count": 115
+    },
+    {
+      "date": "2020-02-13",
+      "value": 111,
+      "avg_cvss": 8.0,
+      "cvss_count": 111
+    },
+    {
+      "date": "2020-02-14",
+      "value": 52,
+      "avg_cvss": 7.0,
+      "cvss_count": 52
+    },
+    {
+      "date": "2020-02-15",
+      "value": 1,
+      "avg_cvss": 5.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2020-02-16",
+      "value": 7,
+      "avg_cvss": 6.0,
+      "cvss_count": 7
+    },
+    {
+      "date": "2020-02-17",
+      "value": 58,
+      "avg_cvss": 7.6,
+      "cvss_count": 58
+    },
+    {
+      "date": "2020-02-18",
+      "value": 59,
+      "avg_cvss": 7.5,
+      "cvss_count": 59
+    },
+    {
+      "date": "2020-02-19",
+      "value": 60,
+      "avg_cvss": 7.3,
+      "cvss_count": 60
+    },
+    {
+      "date": "2020-02-20",
+      "value": 53,
+      "avg_cvss": 7.4,
+      "cvss_count": 53
+    },
+    {
+      "date": "2020-02-21",
+      "value": 27,
+      "avg_cvss": 7.4,
+      "cvss_count": 27
+    },
+    {
+      "date": "2020-02-22",
+      "value": 11,
+      "avg_cvss": 7.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2020-02-23",
+      "value": 6,
+      "avg_cvss": 7.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2020-02-24",
+      "value": 47,
+      "avg_cvss": 7.8,
+      "cvss_count": 47
+    },
+    {
+      "date": "2020-02-25",
+      "value": 39,
+      "avg_cvss": 7.5,
+      "cvss_count": 39
+    },
+    {
+      "date": "2020-02-26",
+      "value": 36,
+      "avg_cvss": 6.9,
+      "cvss_count": 36
+    },
+    {
+      "date": "2020-02-27",
+      "value": 78,
+      "avg_cvss": 7.0,
+      "cvss_count": 78
+    },
+    {
+      "date": "2020-02-28",
+      "value": 38,
+      "avg_cvss": 7.3,
+      "cvss_count": 38
+    },
+    {
+      "date": "2020-03-02",
+      "value": 61,
+      "avg_cvss": 7.5,
+      "cvss_count": 61
+    },
+    {
+      "date": "2020-03-03",
+      "value": 14,
+      "avg_cvss": 6.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2020-03-04",
+      "value": 41,
+      "avg_cvss": 7.2,
+      "cvss_count": 41
+    },
+    {
+      "date": "2020-03-05",
+      "value": 89,
+      "avg_cvss": 7.9,
+      "cvss_count": 89
+    },
+    {
+      "date": "2020-03-06",
+      "value": 21,
+      "avg_cvss": 7.6,
+      "cvss_count": 21
+    },
+    {
+      "date": "2020-03-07",
+      "value": 11,
+      "avg_cvss": 8.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2020-03-08",
+      "value": 5,
+      "avg_cvss": 8.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2020-03-09",
+      "value": 69,
+      "avg_cvss": 6.7,
+      "cvss_count": 69
+    },
+    {
+      "date": "2020-03-10",
+      "value": 128,
+      "avg_cvss": 6.5,
+      "cvss_count": 128
+    },
+    {
+      "date": "2020-03-11",
+      "value": 50,
+      "avg_cvss": 7.6,
+      "cvss_count": 50
+    },
+    {
+      "date": "2020-03-12",
+      "value": 307,
+      "avg_cvss": 6.3,
+      "cvss_count": 307
+    },
+    {
+      "date": "2020-03-13",
+      "value": 76,
+      "avg_cvss": 7.7,
+      "cvss_count": 76
+    },
+    {
+      "date": "2020-03-14",
+      "value": 12,
+      "avg_cvss": 7.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2020-03-15",
+      "value": 26,
+      "avg_cvss": 8.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2020-03-16",
+      "value": 89,
+      "avg_cvss": 7.2,
+      "cvss_count": 89
+    },
+    {
+      "date": "2020-03-17",
+      "value": 31,
+      "avg_cvss": 6.9,
+      "cvss_count": 31
+    },
+    {
+      "date": "2020-03-18",
+      "value": 71,
+      "avg_cvss": 7.4,
+      "cvss_count": 71
+    },
+    {
+      "date": "2020-03-19",
+      "value": 75,
+      "avg_cvss": 7.2,
+      "cvss_count": 75
+    },
+    {
+      "date": "2020-03-20",
+      "value": 73,
+      "avg_cvss": 6.9,
+      "cvss_count": 73
+    },
+    {
+      "date": "2020-03-21",
+      "value": 5,
+      "avg_cvss": 8.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2020-03-22",
+      "value": 14,
+      "avg_cvss": 6.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2020-03-23",
+      "value": 70,
+      "avg_cvss": 7.5,
+      "cvss_count": 70
+    },
+    {
+      "date": "2020-03-24",
+      "value": 175,
+      "avg_cvss": 7.5,
+      "cvss_count": 175
+    },
+    {
+      "date": "2020-03-25",
+      "value": 107,
+      "avg_cvss": 7.9,
+      "cvss_count": 107
+    },
+    {
+      "date": "2020-03-26",
+      "value": 28,
+      "avg_cvss": 7.5,
+      "cvss_count": 28
+    },
+    {
+      "date": "2020-03-27",
+      "value": 43,
+      "avg_cvss": 7.5,
+      "cvss_count": 43
+    },
+    {
+      "date": "2020-03-30",
+      "value": 34,
+      "avg_cvss": 7.2,
+      "cvss_count": 34
+    },
+    {
+      "date": "2020-03-31",
+      "value": 29,
+      "avg_cvss": 7.6,
+      "cvss_count": 29
+    },
+    {
+      "date": "2020-04-01",
+      "value": 106,
+      "avg_cvss": 7.1,
+      "cvss_count": 106
+    },
+    {
+      "date": "2020-04-02",
+      "value": 57,
+      "avg_cvss": 7.2,
+      "cvss_count": 57
+    },
+    {
+      "date": "2020-04-03",
+      "value": 23,
+      "avg_cvss": 7.5,
+      "cvss_count": 23
+    },
+    {
+      "date": "2020-04-04",
+      "value": 8,
+      "avg_cvss": 7.3,
+      "cvss_count": 8
+    },
+    {
+      "date": "2020-04-05",
+      "value": 3,
+      "avg_cvss": 8.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2020-04-06",
+      "value": 43,
+      "avg_cvss": 7.6,
+      "cvss_count": 43
+    },
+    {
+      "date": "2020-04-07",
+      "value": 118,
+      "avg_cvss": 7.2,
+      "cvss_count": 118
+    },
+    {
+      "date": "2020-04-08",
+      "value": 147,
+      "avg_cvss": 7.0,
+      "cvss_count": 147
+    },
+    {
+      "date": "2020-04-09",
+      "value": 26,
+      "avg_cvss": 7.7,
+      "cvss_count": 26
+    },
+    {
+      "date": "2020-04-10",
+      "value": 21,
+      "avg_cvss": 6.7,
+      "cvss_count": 21
+    },
+    {
+      "date": "2020-04-12",
+      "value": 17,
+      "avg_cvss": 7.9,
+      "cvss_count": 17
+    },
+    {
+      "date": "2020-04-13",
+      "value": 42,
+      "avg_cvss": 6.7,
+      "cvss_count": 42
+    },
+    {
+      "date": "2020-04-14",
+      "value": 74,
+      "avg_cvss": 6.8,
+      "cvss_count": 74
+    },
+    {
+      "date": "2020-04-15",
+      "value": 508,
+      "avg_cvss": 6.8,
+      "cvss_count": 508
+    },
+    {
+      "date": "2020-04-16",
+      "value": 170,
+      "avg_cvss": 7.4,
+      "cvss_count": 170
+    },
+    {
+      "date": "2020-04-17",
+      "value": 74,
+      "avg_cvss": 7.4,
+      "cvss_count": 74
+    },
+    {
+      "date": "2020-04-19",
+      "value": 3,
+      "avg_cvss": 9.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2020-04-20",
+      "value": 65,
+      "avg_cvss": 6.4,
+      "cvss_count": 65
+    },
+    {
+      "date": "2020-04-21",
+      "value": 65,
+      "avg_cvss": 6.7,
+      "cvss_count": 65
+    },
+    {
+      "date": "2020-04-22",
+      "value": 127,
+      "avg_cvss": 7.4,
+      "cvss_count": 127
+    },
+    {
+      "date": "2020-04-23",
+      "value": 84,
+      "avg_cvss": 7.6,
+      "cvss_count": 84
+    },
+    {
+      "date": "2020-04-24",
+      "value": 79,
+      "avg_cvss": 7.4,
+      "cvss_count": 79
+    },
+    {
+      "date": "2020-04-26",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2020-04-27",
+      "value": 85,
+      "avg_cvss": 7.3,
+      "cvss_count": 85
+    },
+    {
+      "date": "2020-04-28",
+      "value": 94,
+      "avg_cvss": 7.2,
+      "cvss_count": 94
+    },
+    {
+      "date": "2020-04-29",
+      "value": 89,
+      "avg_cvss": 7.4,
+      "cvss_count": 89
+    },
+    {
+      "date": "2020-04-30",
+      "value": 56,
+      "avg_cvss": 7.2,
+      "cvss_count": 56
+    },
+    {
+      "date": "2020-05-01",
+      "value": 5,
+      "avg_cvss": 7.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2020-05-02",
+      "value": 3,
+      "avg_cvss": 7.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2020-05-03",
+      "value": 1,
+      "avg_cvss": 6.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2020-05-04",
+      "value": 48,
+      "avg_cvss": 6.9,
+      "cvss_count": 48
+    },
+    {
+      "date": "2020-05-05",
+      "value": 39,
+      "avg_cvss": 6.8,
+      "cvss_count": 39
+    },
+    {
+      "date": "2020-05-06",
+      "value": 68,
+      "avg_cvss": 6.7,
+      "cvss_count": 68
+    },
+    {
+      "date": "2020-05-07",
+      "value": 78,
+      "avg_cvss": 7.0,
+      "cvss_count": 78
+    },
+    {
+      "date": "2020-05-08",
+      "value": 40,
+      "avg_cvss": 7.9,
+      "cvss_count": 40
+    },
+    {
+      "date": "2020-05-09",
+      "value": 14,
+      "avg_cvss": 6.3,
+      "cvss_count": 14
+    },
+    {
+      "date": "2020-05-10",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2020-05-11",
+      "value": 47,
+      "avg_cvss": 7.3,
+      "cvss_count": 47
+    },
+    {
+      "date": "2020-05-12",
+      "value": 47,
+      "avg_cvss": 7.2,
+      "cvss_count": 47
+    },
+    {
+      "date": "2020-05-13",
+      "value": 57,
+      "avg_cvss": 6.9,
+      "cvss_count": 57
+    },
+    {
+      "date": "2020-05-14",
+      "value": 74,
+      "avg_cvss": 7.2,
+      "cvss_count": 74
+    },
+    {
+      "date": "2020-05-15",
+      "value": 31,
+      "avg_cvss": 6.7,
+      "cvss_count": 31
+    },
+    {
+      "date": "2020-05-16",
+      "value": 5,
+      "avg_cvss": 8.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2020-05-17",
+      "value": 3,
+      "avg_cvss": 6.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2020-05-18",
+      "value": 47,
+      "avg_cvss": 7.2,
+      "cvss_count": 47
+    },
+    {
+      "date": "2020-05-19",
+      "value": 36,
+      "avg_cvss": 7.2,
+      "cvss_count": 36
+    },
+    {
+      "date": "2020-05-20",
+      "value": 29,
+      "avg_cvss": 7.3,
+      "cvss_count": 29
+    },
+    {
+      "date": "2020-05-21",
+      "value": 168,
+      "avg_cvss": 7.3,
+      "cvss_count": 168
+    },
+    {
+      "date": "2020-05-22",
+      "value": 32,
+      "avg_cvss": 7.7,
+      "cvss_count": 32
+    },
+    {
+      "date": "2020-05-23",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2020-05-24",
+      "value": 8,
+      "avg_cvss": 6.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2020-05-25",
+      "value": 7,
+      "avg_cvss": 8.1,
+      "cvss_count": 7
+    },
+    {
+      "date": "2020-05-26",
+      "value": 24,
+      "avg_cvss": 7.5,
+      "cvss_count": 24
+    },
+    {
+      "date": "2020-05-27",
+      "value": 30,
+      "avg_cvss": 6.8,
+      "cvss_count": 30
+    },
+    {
+      "date": "2020-05-28",
+      "value": 30,
+      "avg_cvss": 6.5,
+      "cvss_count": 30
+    },
+    {
+      "date": "2020-05-29",
+      "value": 42,
+      "avg_cvss": 5.7,
+      "cvss_count": 42
+    },
+    {
+      "date": "2020-06-01",
+      "value": 38,
+      "avg_cvss": 7.1,
+      "cvss_count": 38
+    },
+    {
+      "date": "2020-06-02",
+      "value": 54,
+      "avg_cvss": 7.1,
+      "cvss_count": 54
+    },
+    {
+      "date": "2020-06-03",
+      "value": 127,
+      "avg_cvss": 6.9,
+      "cvss_count": 127
+    },
+    {
+      "date": "2020-06-04",
+      "value": 96,
+      "avg_cvss": 7.5,
+      "cvss_count": 96
+    },
+    {
+      "date": "2020-06-05",
+      "value": 37,
+      "avg_cvss": 7.3,
+      "cvss_count": 37
+    },
+    {
+      "date": "2020-06-06",
+      "value": 5,
+      "avg_cvss": 6.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2020-06-07",
+      "value": 8,
+      "avg_cvss": 7.7,
+      "cvss_count": 8
+    },
+    {
+      "date": "2020-06-08",
+      "value": 33,
+      "avg_cvss": 7.2,
+      "cvss_count": 33
+    },
+    {
+      "date": "2020-06-09",
+      "value": 223,
+      "avg_cvss": 7.3,
+      "cvss_count": 223
+    },
+    {
+      "date": "2020-06-10",
+      "value": 73,
+      "avg_cvss": 7.3,
+      "cvss_count": 73
+    },
+    {
+      "date": "2020-06-11",
+      "value": 123,
+      "avg_cvss": 6.7,
+      "cvss_count": 123
+    },
+    {
+      "date": "2020-06-12",
+      "value": 28,
+      "avg_cvss": 6.5,
+      "cvss_count": 28
+    },
+    {
+      "date": "2020-06-14",
+      "value": 3,
+      "avg_cvss": 8.1,
+      "cvss_count": 3
+    },
+    {
+      "date": "2020-06-15",
+      "value": 90,
+      "avg_cvss": 7.4,
+      "cvss_count": 90
+    },
+    {
+      "date": "2020-06-16",
+      "value": 53,
+      "avg_cvss": 7.3,
+      "cvss_count": 53
+    },
+    {
+      "date": "2020-06-17",
+      "value": 49,
+      "avg_cvss": 6.7,
+      "cvss_count": 49
+    },
+    {
+      "date": "2020-06-18",
+      "value": 84,
+      "avg_cvss": 7.2,
+      "cvss_count": 84
+    },
+    {
+      "date": "2020-06-19",
+      "value": 193,
+      "avg_cvss": 6.5,
+      "cvss_count": 193
+    },
+    {
+      "date": "2020-06-20",
+      "value": 2,
+      "avg_cvss": 9.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2020-06-21",
+      "value": 4,
+      "avg_cvss": 7.8,
+      "cvss_count": 4
+    },
+    {
+      "date": "2020-06-22",
+      "value": 84,
+      "avg_cvss": 7.2,
+      "cvss_count": 84
+    },
+    {
+      "date": "2020-06-23",
+      "value": 29,
+      "avg_cvss": 7.5,
+      "cvss_count": 29
+    },
+    {
+      "date": "2020-06-24",
+      "value": 65,
+      "avg_cvss": 7.1,
+      "cvss_count": 65
+    },
+    {
+      "date": "2020-06-25",
+      "value": 74,
+      "avg_cvss": 7.0,
+      "cvss_count": 74
+    },
+    {
+      "date": "2020-06-26",
+      "value": 83,
+      "avg_cvss": 7.1,
+      "cvss_count": 83
+    },
+    {
+      "date": "2020-06-27",
+      "value": 2,
+      "avg_cvss": 6.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2020-06-28",
+      "value": 3,
+      "avg_cvss": 7.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2020-06-29",
+      "value": 72,
+      "avg_cvss": 7.0,
+      "cvss_count": 72
+    },
+    {
+      "date": "2020-06-30",
+      "value": 51,
+      "avg_cvss": 7.1,
+      "cvss_count": 51
+    },
+    {
+      "date": "2020-07-01",
+      "value": 71,
+      "avg_cvss": 7.2,
+      "cvss_count": 71
+    },
+    {
+      "date": "2020-07-02",
+      "value": 54,
+      "avg_cvss": 6.0,
+      "cvss_count": 54
+    },
+    {
+      "date": "2020-07-03",
+      "value": 11,
+      "avg_cvss": 7.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2020-07-04",
+      "value": 1,
+      "avg_cvss": 7.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2020-07-05",
+      "value": 13,
+      "avg_cvss": 8.0,
+      "cvss_count": 13
+    },
+    {
+      "date": "2020-07-06",
+      "value": 28,
+      "avg_cvss": 7.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2020-07-07",
+      "value": 67,
+      "avg_cvss": 6.8,
+      "cvss_count": 67
+    },
+    {
+      "date": "2020-07-08",
+      "value": 18,
+      "avg_cvss": 7.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2020-07-09",
+      "value": 51,
+      "avg_cvss": 7.0,
+      "cvss_count": 51
+    },
+    {
+      "date": "2020-07-10",
+      "value": 24,
+      "avg_cvss": 6.8,
+      "cvss_count": 24
+    },
+    {
+      "date": "2020-07-13",
+      "value": 19,
+      "avg_cvss": 7.2,
+      "cvss_count": 19
+    },
+    {
+      "date": "2020-07-14",
+      "value": 193,
+      "avg_cvss": 7.3,
+      "cvss_count": 193
+    },
+    {
+      "date": "2020-07-15",
+      "value": 278,
+      "avg_cvss": 6.4,
+      "cvss_count": 278
+    },
+    {
+      "date": "2020-07-16",
+      "value": 53,
+      "avg_cvss": 7.6,
+      "cvss_count": 53
+    },
+    {
+      "date": "2020-07-17",
+      "value": 81,
+      "avg_cvss": 7.4,
+      "cvss_count": 81
+    },
+    {
+      "date": "2020-07-18",
+      "value": 2,
+      "avg_cvss": 6.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2020-07-20",
+      "value": 36,
+      "avg_cvss": 7.5,
+      "cvss_count": 36
+    },
+    {
+      "date": "2020-07-21",
+      "value": 18,
+      "avg_cvss": 7.6,
+      "cvss_count": 18
+    },
+    {
+      "date": "2020-07-22",
+      "value": 71,
+      "avg_cvss": 7.5,
+      "cvss_count": 71
+    },
+    {
+      "date": "2020-07-23",
+      "value": 40,
+      "avg_cvss": 7.6,
+      "cvss_count": 40
+    },
+    {
+      "date": "2020-07-24",
+      "value": 26,
+      "avg_cvss": 7.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2020-07-25",
+      "value": 7,
+      "avg_cvss": 7.1,
+      "cvss_count": 7
+    },
+    {
+      "date": "2020-07-27",
+      "value": 25,
+      "avg_cvss": 6.0,
+      "cvss_count": 25
+    },
+    {
+      "date": "2020-07-28",
+      "value": 86,
+      "avg_cvss": 8.2,
+      "cvss_count": 86
+    },
+    {
+      "date": "2020-07-29",
+      "value": 60,
+      "avg_cvss": 7.5,
+      "cvss_count": 60
+    },
+    {
+      "date": "2020-07-30",
+      "value": 51,
+      "avg_cvss": 7.3,
+      "cvss_count": 51
+    },
+    {
+      "date": "2020-07-31",
+      "value": 33,
+      "avg_cvss": 7.6,
+      "cvss_count": 33
+    },
+    {
+      "date": "2020-08-03",
+      "value": 32,
+      "avg_cvss": 6.9,
+      "cvss_count": 32
+    },
+    {
+      "date": "2020-08-04",
+      "value": 27,
+      "avg_cvss": 6.8,
+      "cvss_count": 27
+    },
+    {
+      "date": "2020-08-05",
+      "value": 26,
+      "avg_cvss": 7.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2020-08-06",
+      "value": 24,
+      "avg_cvss": 7.7,
+      "cvss_count": 24
+    },
+    {
+      "date": "2020-08-07",
+      "value": 36,
+      "avg_cvss": 7.6,
+      "cvss_count": 36
+    },
+    {
+      "date": "2020-08-08",
+      "value": 15,
+      "avg_cvss": 6.6,
+      "cvss_count": 15
+    },
+    {
+      "date": "2020-08-09",
+      "value": 3,
+      "avg_cvss": 5.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2020-08-10",
+      "value": 48,
+      "avg_cvss": 7.0,
+      "cvss_count": 48
+    },
+    {
+      "date": "2020-08-11",
+      "value": 61,
+      "avg_cvss": 7.0,
+      "cvss_count": 61
+    },
+    {
+      "date": "2020-08-12",
+      "value": 62,
+      "avg_cvss": 6.7,
+      "cvss_count": 62
+    },
+    {
+      "date": "2020-08-13",
+      "value": 112,
+      "avg_cvss": 6.7,
+      "cvss_count": 112
+    },
+    {
+      "date": "2020-08-14",
+      "value": 30,
+      "avg_cvss": 7.3,
+      "cvss_count": 30
+    },
+    {
+      "date": "2020-08-16",
+      "value": 2,
+      "avg_cvss": 8.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2020-08-17",
+      "value": 169,
+      "avg_cvss": 7.3,
+      "cvss_count": 169
+    },
+    {
+      "date": "2020-08-18",
+      "value": 17,
+      "avg_cvss": 8.6,
+      "cvss_count": 17
+    },
+    {
+      "date": "2020-08-19",
+      "value": 36,
+      "avg_cvss": 6.8,
+      "cvss_count": 36
+    },
+    {
+      "date": "2020-08-20",
+      "value": 37,
+      "avg_cvss": 7.5,
+      "cvss_count": 37
+    },
+    {
+      "date": "2020-08-21",
+      "value": 70,
+      "avg_cvss": 6.8,
+      "cvss_count": 70
+    },
+    {
+      "date": "2020-08-23",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2020-08-24",
+      "value": 41,
+      "avg_cvss": 6.7,
+      "cvss_count": 41
+    },
+    {
+      "date": "2020-08-25",
+      "value": 51,
+      "avg_cvss": 7.5,
+      "cvss_count": 51
+    },
+    {
+      "date": "2020-08-26",
+      "value": 102,
+      "avg_cvss": 6.6,
+      "cvss_count": 102
+    },
+    {
+      "date": "2020-08-27",
+      "value": 54,
+      "avg_cvss": 7.1,
+      "cvss_count": 54
+    },
+    {
+      "date": "2020-08-28",
+      "value": 16,
+      "avg_cvss": 6.6,
+      "cvss_count": 16
+    },
+    {
+      "date": "2020-08-29",
+      "value": 8,
+      "avg_cvss": 8.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2020-08-30",
+      "value": 7,
+      "avg_cvss": 6.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2020-08-31",
+      "value": 68,
+      "avg_cvss": 7.1,
+      "cvss_count": 68
+    },
+    {
+      "date": "2020-09-01",
+      "value": 106,
+      "avg_cvss": 8.0,
+      "cvss_count": 106
+    },
+    {
+      "date": "2020-09-02",
+      "value": 42,
+      "avg_cvss": 7.1,
+      "cvss_count": 42
+    },
+    {
+      "date": "2020-09-03",
+      "value": 64,
+      "avg_cvss": 6.8,
+      "cvss_count": 64
+    },
+    {
+      "date": "2020-09-04",
+      "value": 41,
+      "avg_cvss": 7.2,
+      "cvss_count": 41
+    },
+    {
+      "date": "2020-09-05",
+      "value": 1,
+      "avg_cvss": 5.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2020-09-08",
+      "value": 52,
+      "avg_cvss": 7.6,
+      "cvss_count": 52
+    },
+    {
+      "date": "2020-09-09",
+      "value": 121,
+      "avg_cvss": 6.2,
+      "cvss_count": 121
+    },
+    {
+      "date": "2020-09-10",
+      "value": 42,
+      "avg_cvss": 7.1,
+      "cvss_count": 42
+    },
+    {
+      "date": "2020-09-11",
+      "value": 180,
+      "avg_cvss": 6.9,
+      "cvss_count": 180
+    },
+    {
+      "date": "2020-09-13",
+      "value": 6,
+      "avg_cvss": 6.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2020-09-14",
+      "value": 60,
+      "avg_cvss": 6.5,
+      "cvss_count": 60
+    },
+    {
+      "date": "2020-09-15",
+      "value": 51,
+      "avg_cvss": 6.8,
+      "cvss_count": 51
+    },
+    {
+      "date": "2020-09-16",
+      "value": 84,
+      "avg_cvss": 6.7,
+      "cvss_count": 84
+    },
+    {
+      "date": "2020-09-17",
+      "value": 138,
+      "avg_cvss": 6.8,
+      "cvss_count": 138
+    },
+    {
+      "date": "2020-09-18",
+      "value": 104,
+      "avg_cvss": 6.5,
+      "cvss_count": 104
+    },
+    {
+      "date": "2020-09-19",
+      "value": 12,
+      "avg_cvss": 7.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2020-09-21",
+      "value": 58,
+      "avg_cvss": 7.5,
+      "cvss_count": 58
+    },
+    {
+      "date": "2020-09-22",
+      "value": 34,
+      "avg_cvss": 7.3,
+      "cvss_count": 34
+    },
+    {
+      "date": "2020-09-23",
+      "value": 72,
+      "avg_cvss": 6.7,
+      "cvss_count": 72
+    },
+    {
+      "date": "2020-09-24",
+      "value": 99,
+      "avg_cvss": 7.5,
+      "cvss_count": 99
+    },
+    {
+      "date": "2020-09-25",
+      "value": 112,
+      "avg_cvss": 7.3,
+      "cvss_count": 112
+    },
+    {
+      "date": "2020-09-27",
+      "value": 11,
+      "avg_cvss": 6.7,
+      "cvss_count": 11
+    },
+    {
+      "date": "2020-09-29",
+      "value": 12,
+      "avg_cvss": 6.2,
+      "cvss_count": 12
+    },
+    {
+      "date": "2020-09-30",
+      "value": 91,
+      "avg_cvss": 6.9,
+      "cvss_count": 91
+    },
+    {
+      "date": "2020-10-01",
+      "value": 44,
+      "avg_cvss": 6.9,
+      "cvss_count": 44
+    },
+    {
+      "date": "2020-10-02",
+      "value": 72,
+      "avg_cvss": 7.4,
+      "cvss_count": 72
+    },
+    {
+      "date": "2020-10-04",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2020-10-05",
+      "value": 23,
+      "avg_cvss": 7.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2020-10-06",
+      "value": 72,
+      "avg_cvss": 7.1,
+      "cvss_count": 72
+    },
+    {
+      "date": "2020-10-07",
+      "value": 28,
+      "avg_cvss": 6.6,
+      "cvss_count": 28
+    },
+    {
+      "date": "2020-10-08",
+      "value": 54,
+      "avg_cvss": 6.3,
+      "cvss_count": 54
+    },
+    {
+      "date": "2020-10-09",
+      "value": 41,
+      "avg_cvss": 7.6,
+      "cvss_count": 41
+    },
+    {
+      "date": "2020-10-10",
+      "value": 6,
+      "avg_cvss": 7.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2020-10-12",
+      "value": 60,
+      "avg_cvss": 6.4,
+      "cvss_count": 60
+    },
+    {
+      "date": "2020-10-13",
+      "value": 23,
+      "avg_cvss": 7.2,
+      "cvss_count": 23
+    },
+    {
+      "date": "2020-10-14",
+      "value": 51,
+      "avg_cvss": 6.8,
+      "cvss_count": 51
+    },
+    {
+      "date": "2020-10-15",
+      "value": 50,
+      "avg_cvss": 6.9,
+      "cvss_count": 50
+    },
+    {
+      "date": "2020-10-16",
+      "value": 200,
+      "avg_cvss": 7.2,
+      "cvss_count": 200
+    },
+    {
+      "date": "2020-10-17",
+      "value": 1,
+      "avg_cvss": 9.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2020-10-18",
+      "value": 1,
+      "avg_cvss": 5.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2020-10-19",
+      "value": 96,
+      "avg_cvss": 8.6,
+      "cvss_count": 96
+    },
+    {
+      "date": "2020-10-20",
+      "value": 49,
+      "avg_cvss": 6.6,
+      "cvss_count": 49
+    },
+    {
+      "date": "2020-10-21",
+      "value": 243,
+      "avg_cvss": 6.3,
+      "cvss_count": 243
+    },
+    {
+      "date": "2020-10-22",
+      "value": 99,
+      "avg_cvss": 7.2,
+      "cvss_count": 99
+    },
+    {
+      "date": "2020-10-23",
+      "value": 27,
+      "avg_cvss": 6.8,
+      "cvss_count": 27
+    },
+    {
+      "date": "2020-10-26",
+      "value": 28,
+      "avg_cvss": 7.8,
+      "cvss_count": 28
+    },
+    {
+      "date": "2020-10-27",
+      "value": 171,
+      "avg_cvss": 7.2,
+      "cvss_count": 171
+    },
+    {
+      "date": "2020-10-28",
+      "value": 58,
+      "avg_cvss": 7.2,
+      "cvss_count": 58
+    },
+    {
+      "date": "2020-10-29",
+      "value": 52,
+      "avg_cvss": 7.3,
+      "cvss_count": 52
+    },
+    {
+      "date": "2020-10-30",
+      "value": 11,
+      "avg_cvss": 7.1,
+      "cvss_count": 11
+    },
+    {
+      "date": "2020-10-31",
+      "value": 2,
+      "avg_cvss": 6.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2020-11-01",
+      "value": 1,
+      "avg_cvss": 8.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2020-11-02",
+      "value": 84,
+      "avg_cvss": 7.6,
+      "cvss_count": 84
+    },
+    {
+      "date": "2020-11-03",
+      "value": 53,
+      "avg_cvss": 8.0,
+      "cvss_count": 53
+    },
+    {
+      "date": "2020-11-04",
+      "value": 40,
+      "avg_cvss": 6.9,
+      "cvss_count": 40
+    },
+    {
+      "date": "2020-11-05",
+      "value": 60,
+      "avg_cvss": 6.8,
+      "cvss_count": 60
+    },
+    {
+      "date": "2020-11-06",
+      "value": 74,
+      "avg_cvss": 7.2,
+      "cvss_count": 74
+    },
+    {
+      "date": "2020-11-07",
+      "value": 3,
+      "avg_cvss": 6.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2020-11-08",
+      "value": 8,
+      "avg_cvss": 8.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2020-11-09",
+      "value": 41,
+      "avg_cvss": 6.5,
+      "cvss_count": 41
+    },
+    {
+      "date": "2020-11-10",
+      "value": 58,
+      "avg_cvss": 7.3,
+      "cvss_count": 58
+    },
+    {
+      "date": "2020-11-11",
+      "value": 131,
+      "avg_cvss": 6.8,
+      "cvss_count": 131
+    },
+    {
+      "date": "2020-11-12",
+      "value": 157,
+      "avg_cvss": 7.2,
+      "cvss_count": 157
+    },
+    {
+      "date": "2020-11-13",
+      "value": 35,
+      "avg_cvss": 7.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2020-11-15",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2020-11-16",
+      "value": 83,
+      "avg_cvss": 7.0,
+      "cvss_count": 83
+    },
+    {
+      "date": "2020-11-17",
+      "value": 59,
+      "avg_cvss": 7.0,
+      "cvss_count": 59
+    },
+    {
+      "date": "2020-11-18",
+      "value": 58,
+      "avg_cvss": 7.1,
+      "cvss_count": 58
+    },
+    {
+      "date": "2020-11-19",
+      "value": 66,
+      "avg_cvss": 7.2,
+      "cvss_count": 66
+    },
+    {
+      "date": "2020-11-20",
+      "value": 17,
+      "avg_cvss": 7.4,
+      "cvss_count": 17
+    },
+    {
+      "date": "2020-11-21",
+      "value": 8,
+      "avg_cvss": 7.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2020-11-23",
+      "value": 57,
+      "avg_cvss": 6.9,
+      "cvss_count": 57
+    },
+    {
+      "date": "2020-11-24",
+      "value": 56,
+      "avg_cvss": 7.8,
+      "cvss_count": 56
+    },
+    {
+      "date": "2020-11-25",
+      "value": 14,
+      "avg_cvss": 6.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2020-11-26",
+      "value": 18,
+      "avg_cvss": 6.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2020-11-27",
+      "value": 34,
+      "avg_cvss": 7.3,
+      "cvss_count": 34
+    },
+    {
+      "date": "2020-11-28",
+      "value": 9,
+      "avg_cvss": 5.5,
+      "cvss_count": 9
+    },
+    {
+      "date": "2020-11-29",
+      "value": 9,
+      "avg_cvss": 8.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2020-11-30",
+      "value": 36,
+      "avg_cvss": 6.3,
+      "cvss_count": 36
+    },
+    {
+      "date": "2020-12-01",
+      "value": 33,
+      "avg_cvss": 7.1,
+      "cvss_count": 33
+    },
+    {
+      "date": "2020-12-02",
+      "value": 44,
+      "avg_cvss": 7.5,
+      "cvss_count": 44
+    },
+    {
+      "date": "2020-12-03",
+      "value": 54,
+      "avg_cvss": 6.8,
+      "cvss_count": 54
+    },
+    {
+      "date": "2020-12-04",
+      "value": 26,
+      "avg_cvss": 5.6,
+      "cvss_count": 26
+    },
+    {
+      "date": "2020-12-06",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2020-12-07",
+      "value": 19,
+      "avg_cvss": 7.2,
+      "cvss_count": 19
+    },
+    {
+      "date": "2020-12-08",
+      "value": 115,
+      "avg_cvss": 6.7,
+      "cvss_count": 115
+    },
+    {
+      "date": "2020-12-09",
+      "value": 73,
+      "avg_cvss": 6.9,
+      "cvss_count": 73
+    },
+    {
+      "date": "2020-12-10",
+      "value": 95,
+      "avg_cvss": 7.0,
+      "cvss_count": 95
+    },
+    {
+      "date": "2020-12-11",
+      "value": 117,
+      "avg_cvss": 7.4,
+      "cvss_count": 117
+    },
+    {
+      "date": "2020-12-12",
+      "value": 9,
+      "avg_cvss": 6.3,
+      "cvss_count": 9
+    },
+    {
+      "date": "2020-12-14",
+      "value": 90,
+      "avg_cvss": 7.6,
+      "cvss_count": 90
+    },
+    {
+      "date": "2020-12-15",
+      "value": 126,
+      "avg_cvss": 6.4,
+      "cvss_count": 126
+    },
+    {
+      "date": "2020-12-16",
+      "value": 48,
+      "avg_cvss": 7.2,
+      "cvss_count": 48
+    },
+    {
+      "date": "2020-12-17",
+      "value": 51,
+      "avg_cvss": 7.9,
+      "cvss_count": 51
+    },
+    {
+      "date": "2020-12-18",
+      "value": 77,
+      "avg_cvss": 7.1,
+      "cvss_count": 77
+    },
+    {
+      "date": "2020-12-20",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2020-12-21",
+      "value": 49,
+      "avg_cvss": 7.2,
+      "cvss_count": 49
+    },
+    {
+      "date": "2020-12-22",
+      "value": 44,
+      "avg_cvss": 7.3,
+      "cvss_count": 44
+    },
+    {
+      "date": "2020-12-23",
+      "value": 41,
+      "avg_cvss": 7.8,
+      "cvss_count": 41
+    },
+    {
+      "date": "2020-12-24",
+      "value": 50,
+      "avg_cvss": 6.9,
+      "cvss_count": 50
+    },
+    {
+      "date": "2020-12-25",
+      "value": 9,
+      "avg_cvss": 6.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2020-12-26",
+      "value": 29,
+      "avg_cvss": 7.9,
+      "cvss_count": 29
+    },
+    {
+      "date": "2020-12-27",
+      "value": 13,
+      "avg_cvss": 6.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2020-12-28",
+      "value": 43,
+      "avg_cvss": 6.8,
+      "cvss_count": 43
+    },
+    {
+      "date": "2020-12-29",
+      "value": 38,
+      "avg_cvss": 7.9,
+      "cvss_count": 38
+    },
+    {
+      "date": "2020-12-30",
+      "value": 109,
+      "avg_cvss": 6.9,
+      "cvss_count": 109
+    },
+    {
+      "date": "2020-12-31",
+      "value": 123,
+      "avg_cvss": 7.6,
+      "cvss_count": 123
+    },
+    {
+      "date": "2021-01-01",
+      "value": 30,
+      "avg_cvss": 8.2,
+      "cvss_count": 30
+    },
+    {
+      "date": "2021-01-02",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-01-03",
+      "value": 8,
+      "avg_cvss": 6.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2021-01-04",
+      "value": 44,
+      "avg_cvss": 6.9,
+      "cvss_count": 44
+    },
+    {
+      "date": "2021-01-05",
+      "value": 48,
+      "avg_cvss": 7.1,
+      "cvss_count": 48
+    },
+    {
+      "date": "2021-01-06",
+      "value": 54,
+      "avg_cvss": 7.5,
+      "cvss_count": 54
+    },
+    {
+      "date": "2021-01-07",
+      "value": 60,
+      "avg_cvss": 7.3,
+      "cvss_count": 60
+    },
+    {
+      "date": "2021-01-08",
+      "value": 97,
+      "avg_cvss": 7.3,
+      "cvss_count": 97
+    },
+    {
+      "date": "2021-01-09",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-01-11",
+      "value": 84,
+      "avg_cvss": 7.0,
+      "cvss_count": 84
+    },
+    {
+      "date": "2021-01-12",
+      "value": 178,
+      "avg_cvss": 7.4,
+      "cvss_count": 178
+    },
+    {
+      "date": "2021-01-13",
+      "value": 169,
+      "avg_cvss": 6.7,
+      "cvss_count": 169
+    },
+    {
+      "date": "2021-01-14",
+      "value": 32,
+      "avg_cvss": 7.8,
+      "cvss_count": 32
+    },
+    {
+      "date": "2021-01-15",
+      "value": 52,
+      "avg_cvss": 7.3,
+      "cvss_count": 52
+    },
+    {
+      "date": "2021-01-17",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-01-18",
+      "value": 14,
+      "avg_cvss": 7.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2021-01-19",
+      "value": 48,
+      "avg_cvss": 7.0,
+      "cvss_count": 48
+    },
+    {
+      "date": "2021-01-20",
+      "value": 236,
+      "avg_cvss": 6.7,
+      "cvss_count": 236
+    },
+    {
+      "date": "2021-01-21",
+      "value": 49,
+      "avg_cvss": 7.8,
+      "cvss_count": 49
+    },
+    {
+      "date": "2021-01-22",
+      "value": 12,
+      "avg_cvss": 7.2,
+      "cvss_count": 12
+    },
+    {
+      "date": "2021-01-25",
+      "value": 4,
+      "avg_cvss": 7.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2021-01-26",
+      "value": 160,
+      "avg_cvss": 7.3,
+      "cvss_count": 160
+    },
+    {
+      "date": "2021-01-27",
+      "value": 43,
+      "avg_cvss": 6.8,
+      "cvss_count": 43
+    },
+    {
+      "date": "2021-01-28",
+      "value": 31,
+      "avg_cvss": 7.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2021-01-29",
+      "value": 60,
+      "avg_cvss": 7.1,
+      "cvss_count": 60
+    },
+    {
+      "date": "2021-01-30",
+      "value": 4,
+      "avg_cvss": 8.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2021-01-31",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-02-01",
+      "value": 47,
+      "avg_cvss": 8.1,
+      "cvss_count": 47
+    },
+    {
+      "date": "2021-02-02",
+      "value": 40,
+      "avg_cvss": 7.1,
+      "cvss_count": 40
+    },
+    {
+      "date": "2021-02-03",
+      "value": 77,
+      "avg_cvss": 6.5,
+      "cvss_count": 77
+    },
+    {
+      "date": "2021-02-04",
+      "value": 113,
+      "avg_cvss": 6.9,
+      "cvss_count": 113
+    },
+    {
+      "date": "2021-02-05",
+      "value": 37,
+      "avg_cvss": 7.2,
+      "cvss_count": 37
+    },
+    {
+      "date": "2021-02-06",
+      "value": 21,
+      "avg_cvss": 5.7,
+      "cvss_count": 21
+    },
+    {
+      "date": "2021-02-07",
+      "value": 5,
+      "avg_cvss": 8.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2021-02-08",
+      "value": 76,
+      "avg_cvss": 7.3,
+      "cvss_count": 76
+    },
+    {
+      "date": "2021-02-09",
+      "value": 146,
+      "avg_cvss": 7.4,
+      "cvss_count": 146
+    },
+    {
+      "date": "2021-02-10",
+      "value": 113,
+      "avg_cvss": 8.1,
+      "cvss_count": 113
+    },
+    {
+      "date": "2021-02-11",
+      "value": 86,
+      "avg_cvss": 6.9,
+      "cvss_count": 86
+    },
+    {
+      "date": "2021-02-12",
+      "value": 59,
+      "avg_cvss": 7.1,
+      "cvss_count": 59
+    },
+    {
+      "date": "2021-02-13",
+      "value": 2,
+      "avg_cvss": 6.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-02-14",
+      "value": 4,
+      "avg_cvss": 8.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2021-02-15",
+      "value": 41,
+      "avg_cvss": 7.4,
+      "cvss_count": 41
+    },
+    {
+      "date": "2021-02-16",
+      "value": 55,
+      "avg_cvss": 6.6,
+      "cvss_count": 55
+    },
+    {
+      "date": "2021-02-17",
+      "value": 110,
+      "avg_cvss": 6.8,
+      "cvss_count": 110
+    },
+    {
+      "date": "2021-02-18",
+      "value": 37,
+      "avg_cvss": 7.3,
+      "cvss_count": 37
+    },
+    {
+      "date": "2021-02-19",
+      "value": 44,
+      "avg_cvss": 7.0,
+      "cvss_count": 44
+    },
+    {
+      "date": "2021-02-20",
+      "value": 2,
+      "avg_cvss": 7.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-02-21",
+      "value": 1,
+      "avg_cvss": 6.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-02-22",
+      "value": 71,
+      "avg_cvss": 7.7,
+      "cvss_count": 71
+    },
+    {
+      "date": "2021-02-23",
+      "value": 64,
+      "avg_cvss": 6.7,
+      "cvss_count": 64
+    },
+    {
+      "date": "2021-02-24",
+      "value": 41,
+      "avg_cvss": 7.1,
+      "cvss_count": 41
+    },
+    {
+      "date": "2021-02-25",
+      "value": 74,
+      "avg_cvss": 7.3,
+      "cvss_count": 74
+    },
+    {
+      "date": "2021-02-26",
+      "value": 74,
+      "avg_cvss": 6.7,
+      "cvss_count": 74
+    },
+    {
+      "date": "2021-02-27",
+      "value": 16,
+      "avg_cvss": 8.1,
+      "cvss_count": 16
+    },
+    {
+      "date": "2021-03-01",
+      "value": 29,
+      "avg_cvss": 7.5,
+      "cvss_count": 29
+    },
+    {
+      "date": "2021-03-02",
+      "value": 33,
+      "avg_cvss": 6.6,
+      "cvss_count": 33
+    },
+    {
+      "date": "2021-03-03",
+      "value": 63,
+      "avg_cvss": 7.2,
+      "cvss_count": 63
+    },
+    {
+      "date": "2021-03-04",
+      "value": 66,
+      "avg_cvss": 6.0,
+      "cvss_count": 66
+    },
+    {
+      "date": "2021-03-05",
+      "value": 62,
+      "avg_cvss": 7.8,
+      "cvss_count": 62
+    },
+    {
+      "date": "2021-03-06",
+      "value": 1,
+      "avg_cvss": 8.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-03-07",
+      "value": 6,
+      "avg_cvss": 7.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2021-03-08",
+      "value": 25,
+      "avg_cvss": 6.8,
+      "cvss_count": 25
+    },
+    {
+      "date": "2021-03-09",
+      "value": 90,
+      "avg_cvss": 6.8,
+      "cvss_count": 90
+    },
+    {
+      "date": "2021-03-10",
+      "value": 100,
+      "avg_cvss": 6.8,
+      "cvss_count": 100
+    },
+    {
+      "date": "2021-03-11",
+      "value": 121,
+      "avg_cvss": 7.6,
+      "cvss_count": 121
+    },
+    {
+      "date": "2021-03-12",
+      "value": 44,
+      "avg_cvss": 7.5,
+      "cvss_count": 44
+    },
+    {
+      "date": "2021-03-13",
+      "value": 5,
+      "avg_cvss": 7.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2021-03-15",
+      "value": 65,
+      "avg_cvss": 6.9,
+      "cvss_count": 65
+    },
+    {
+      "date": "2021-03-16",
+      "value": 22,
+      "avg_cvss": 7.2,
+      "cvss_count": 22
+    },
+    {
+      "date": "2021-03-17",
+      "value": 38,
+      "avg_cvss": 7.7,
+      "cvss_count": 38
+    },
+    {
+      "date": "2021-03-18",
+      "value": 93,
+      "avg_cvss": 6.6,
+      "cvss_count": 93
+    },
+    {
+      "date": "2021-03-19",
+      "value": 45,
+      "avg_cvss": 7.0,
+      "cvss_count": 45
+    },
+    {
+      "date": "2021-03-20",
+      "value": 6,
+      "avg_cvss": 6.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2021-03-21",
+      "value": 6,
+      "avg_cvss": 8.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2021-03-22",
+      "value": 40,
+      "avg_cvss": 6.0,
+      "cvss_count": 40
+    },
+    {
+      "date": "2021-03-23",
+      "value": 77,
+      "avg_cvss": 7.1,
+      "cvss_count": 77
+    },
+    {
+      "date": "2021-03-24",
+      "value": 86,
+      "avg_cvss": 6.7,
+      "cvss_count": 86
+    },
+    {
+      "date": "2021-03-25",
+      "value": 71,
+      "avg_cvss": 7.0,
+      "cvss_count": 71
+    },
+    {
+      "date": "2021-03-26",
+      "value": 72,
+      "avg_cvss": 6.5,
+      "cvss_count": 72
+    },
+    {
+      "date": "2021-03-27",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-03-29",
+      "value": 41,
+      "avg_cvss": 8.0,
+      "cvss_count": 41
+    },
+    {
+      "date": "2021-03-30",
+      "value": 81,
+      "avg_cvss": 6.4,
+      "cvss_count": 81
+    },
+    {
+      "date": "2021-03-31",
+      "value": 56,
+      "avg_cvss": 7.2,
+      "cvss_count": 56
+    },
+    {
+      "date": "2021-04-01",
+      "value": 64,
+      "avg_cvss": 6.7,
+      "cvss_count": 64
+    },
+    {
+      "date": "2021-04-02",
+      "value": 178,
+      "avg_cvss": 7.0,
+      "cvss_count": 178
+    },
+    {
+      "date": "2021-04-03",
+      "value": 1,
+      "avg_cvss": 7.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-04-05",
+      "value": 65,
+      "avg_cvss": 6.7,
+      "cvss_count": 65
+    },
+    {
+      "date": "2021-04-06",
+      "value": 89,
+      "avg_cvss": 6.3,
+      "cvss_count": 89
+    },
+    {
+      "date": "2021-04-07",
+      "value": 62,
+      "avg_cvss": 7.3,
+      "cvss_count": 62
+    },
+    {
+      "date": "2021-04-08",
+      "value": 64,
+      "avg_cvss": 6.8,
+      "cvss_count": 64
+    },
+    {
+      "date": "2021-04-09",
+      "value": 55,
+      "avg_cvss": 6.7,
+      "cvss_count": 55
+    },
+    {
+      "date": "2021-04-10",
+      "value": 2,
+      "avg_cvss": 8.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-04-11",
+      "value": 9,
+      "avg_cvss": 7.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2021-04-12",
+      "value": 56,
+      "avg_cvss": 7.1,
+      "cvss_count": 56
+    },
+    {
+      "date": "2021-04-13",
+      "value": 206,
+      "avg_cvss": 7.4,
+      "cvss_count": 206
+    },
+    {
+      "date": "2021-04-14",
+      "value": 74,
+      "avg_cvss": 7.4,
+      "cvss_count": 74
+    },
+    {
+      "date": "2021-04-15",
+      "value": 54,
+      "avg_cvss": 6.5,
+      "cvss_count": 54
+    },
+    {
+      "date": "2021-04-16",
+      "value": 21,
+      "avg_cvss": 7.4,
+      "cvss_count": 21
+    },
+    {
+      "date": "2021-04-17",
+      "value": 4,
+      "avg_cvss": 9.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2021-04-18",
+      "value": 8,
+      "avg_cvss": 8.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2021-04-19",
+      "value": 44,
+      "avg_cvss": 6.8,
+      "cvss_count": 44
+    },
+    {
+      "date": "2021-04-20",
+      "value": 30,
+      "avg_cvss": 6.9,
+      "cvss_count": 30
+    },
+    {
+      "date": "2021-04-21",
+      "value": 40,
+      "avg_cvss": 6.9,
+      "cvss_count": 40
+    },
+    {
+      "date": "2021-04-22",
+      "value": 295,
+      "avg_cvss": 6.9,
+      "cvss_count": 295
+    },
+    {
+      "date": "2021-04-23",
+      "value": 48,
+      "avg_cvss": 6.9,
+      "cvss_count": 48
+    },
+    {
+      "date": "2021-04-24",
+      "value": 4,
+      "avg_cvss": 6.5,
+      "cvss_count": 4
+    },
+    {
+      "date": "2021-04-25",
+      "value": 6,
+      "avg_cvss": 9.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2021-04-26",
+      "value": 68,
+      "avg_cvss": 7.4,
+      "cvss_count": 68
+    },
+    {
+      "date": "2021-04-27",
+      "value": 50,
+      "avg_cvss": 7.6,
+      "cvss_count": 50
+    },
+    {
+      "date": "2021-04-28",
+      "value": 58,
+      "avg_cvss": 7.2,
+      "cvss_count": 58
+    },
+    {
+      "date": "2021-04-29",
+      "value": 112,
+      "avg_cvss": 7.5,
+      "cvss_count": 112
+    },
+    {
+      "date": "2021-04-30",
+      "value": 51,
+      "avg_cvss": 6.9,
+      "cvss_count": 51
+    },
+    {
+      "date": "2021-05-02",
+      "value": 1,
+      "avg_cvss": 6.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-05-03",
+      "value": 19,
+      "avg_cvss": 8.0,
+      "cvss_count": 19
+    },
+    {
+      "date": "2021-05-04",
+      "value": 13,
+      "avg_cvss": 7.1,
+      "cvss_count": 13
+    },
+    {
+      "date": "2021-05-05",
+      "value": 57,
+      "avg_cvss": 6.5,
+      "cvss_count": 57
+    },
+    {
+      "date": "2021-05-06",
+      "value": 134,
+      "avg_cvss": 7.4,
+      "cvss_count": 134
+    },
+    {
+      "date": "2021-05-07",
+      "value": 105,
+      "avg_cvss": 7.0,
+      "cvss_count": 105
+    },
+    {
+      "date": "2021-05-10",
+      "value": 56,
+      "avg_cvss": 7.3,
+      "cvss_count": 56
+    },
+    {
+      "date": "2021-05-11",
+      "value": 141,
+      "avg_cvss": 6.9,
+      "cvss_count": 141
+    },
+    {
+      "date": "2021-05-12",
+      "value": 43,
+      "avg_cvss": 7.1,
+      "cvss_count": 43
+    },
+    {
+      "date": "2021-05-13",
+      "value": 64,
+      "avg_cvss": 6.6,
+      "cvss_count": 64
+    },
+    {
+      "date": "2021-05-14",
+      "value": 168,
+      "avg_cvss": 4.4,
+      "cvss_count": 168
+    },
+    {
+      "date": "2021-05-15",
+      "value": 2,
+      "avg_cvss": 7.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-05-16",
+      "value": 5,
+      "avg_cvss": 7.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2021-05-17",
+      "value": 76,
+      "avg_cvss": 7.1,
+      "cvss_count": 76
+    },
+    {
+      "date": "2021-05-18",
+      "value": 41,
+      "avg_cvss": 6.7,
+      "cvss_count": 41
+    },
+    {
+      "date": "2021-05-19",
+      "value": 29,
+      "avg_cvss": 6.6,
+      "cvss_count": 29
+    },
+    {
+      "date": "2021-05-20",
+      "value": 59,
+      "avg_cvss": 6.9,
+      "cvss_count": 59
+    },
+    {
+      "date": "2021-05-21",
+      "value": 43,
+      "avg_cvss": 7.6,
+      "cvss_count": 43
+    },
+    {
+      "date": "2021-05-22",
+      "value": 18,
+      "avg_cvss": 5.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2021-05-24",
+      "value": 78,
+      "avg_cvss": 7.3,
+      "cvss_count": 78
+    },
+    {
+      "date": "2021-05-25",
+      "value": 66,
+      "avg_cvss": 6.7,
+      "cvss_count": 66
+    },
+    {
+      "date": "2021-05-26",
+      "value": 100,
+      "avg_cvss": 6.9,
+      "cvss_count": 100
+    },
+    {
+      "date": "2021-05-27",
+      "value": 88,
+      "avg_cvss": 7.0,
+      "cvss_count": 88
+    },
+    {
+      "date": "2021-05-28",
+      "value": 61,
+      "avg_cvss": 6.9,
+      "cvss_count": 61
+    },
+    {
+      "date": "2021-05-29",
+      "value": 4,
+      "avg_cvss": 9.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2021-05-31",
+      "value": 2,
+      "avg_cvss": 9.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-06-01",
+      "value": 96,
+      "avg_cvss": 6.8,
+      "cvss_count": 96
+    },
+    {
+      "date": "2021-06-02",
+      "value": 76,
+      "avg_cvss": 6.9,
+      "cvss_count": 76
+    },
+    {
+      "date": "2021-06-03",
+      "value": 50,
+      "avg_cvss": 6.9,
+      "cvss_count": 50
+    },
+    {
+      "date": "2021-06-04",
+      "value": 63,
+      "avg_cvss": 7.5,
+      "cvss_count": 63
+    },
+    {
+      "date": "2021-06-06",
+      "value": 7,
+      "avg_cvss": 7.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2021-06-07",
+      "value": 63,
+      "avg_cvss": 7.2,
+      "cvss_count": 63
+    },
+    {
+      "date": "2021-06-08",
+      "value": 108,
+      "avg_cvss": 7.0,
+      "cvss_count": 108
+    },
+    {
+      "date": "2021-06-09",
+      "value": 184,
+      "avg_cvss": 6.9,
+      "cvss_count": 184
+    },
+    {
+      "date": "2021-06-10",
+      "value": 74,
+      "avg_cvss": 6.9,
+      "cvss_count": 74
+    },
+    {
+      "date": "2021-06-11",
+      "value": 159,
+      "avg_cvss": 7.2,
+      "cvss_count": 159
+    },
+    {
+      "date": "2021-06-12",
+      "value": 14,
+      "avg_cvss": 6.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2021-06-13",
+      "value": 1,
+      "avg_cvss": 8.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-06-14",
+      "value": 32,
+      "avg_cvss": 7.0,
+      "cvss_count": 32
+    },
+    {
+      "date": "2021-06-15",
+      "value": 56,
+      "avg_cvss": 7.6,
+      "cvss_count": 56
+    },
+    {
+      "date": "2021-06-16",
+      "value": 86,
+      "avg_cvss": 7.3,
+      "cvss_count": 86
+    },
+    {
+      "date": "2021-06-17",
+      "value": 32,
+      "avg_cvss": 7.0,
+      "cvss_count": 32
+    },
+    {
+      "date": "2021-06-18",
+      "value": 41,
+      "avg_cvss": 7.1,
+      "cvss_count": 41
+    },
+    {
+      "date": "2021-06-20",
+      "value": 1,
+      "avg_cvss": 6.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-06-21",
+      "value": 82,
+      "avg_cvss": 7.2,
+      "cvss_count": 82
+    },
+    {
+      "date": "2021-06-22",
+      "value": 104,
+      "avg_cvss": 6.5,
+      "cvss_count": 104
+    },
+    {
+      "date": "2021-06-23",
+      "value": 31,
+      "avg_cvss": 6.8,
+      "cvss_count": 31
+    },
+    {
+      "date": "2021-06-24",
+      "value": 105,
+      "avg_cvss": 6.7,
+      "cvss_count": 105
+    },
+    {
+      "date": "2021-06-25",
+      "value": 47,
+      "avg_cvss": 7.6,
+      "cvss_count": 47
+    },
+    {
+      "date": "2021-06-27",
+      "value": 1,
+      "avg_cvss": 6.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-06-28",
+      "value": 72,
+      "avg_cvss": 6.5,
+      "cvss_count": 72
+    },
+    {
+      "date": "2021-06-29",
+      "value": 61,
+      "avg_cvss": 7.3,
+      "cvss_count": 61
+    },
+    {
+      "date": "2021-06-30",
+      "value": 66,
+      "avg_cvss": 7.4,
+      "cvss_count": 66
+    },
+    {
+      "date": "2021-07-01",
+      "value": 57,
+      "avg_cvss": 7.0,
+      "cvss_count": 57
+    },
+    {
+      "date": "2021-07-02",
+      "value": 63,
+      "avg_cvss": 6.7,
+      "cvss_count": 63
+    },
+    {
+      "date": "2021-07-05",
+      "value": 5,
+      "avg_cvss": 6.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2021-07-06",
+      "value": 27,
+      "avg_cvss": 6.2,
+      "cvss_count": 27
+    },
+    {
+      "date": "2021-07-07",
+      "value": 108,
+      "avg_cvss": 7.4,
+      "cvss_count": 108
+    },
+    {
+      "date": "2021-07-08",
+      "value": 66,
+      "avg_cvss": 6.9,
+      "cvss_count": 66
+    },
+    {
+      "date": "2021-07-09",
+      "value": 61,
+      "avg_cvss": 7.0,
+      "cvss_count": 61
+    },
+    {
+      "date": "2021-07-10",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-07-11",
+      "value": 4,
+      "avg_cvss": 6.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2021-07-12",
+      "value": 88,
+      "avg_cvss": 6.3,
+      "cvss_count": 88
+    },
+    {
+      "date": "2021-07-13",
+      "value": 139,
+      "avg_cvss": 7.0,
+      "cvss_count": 139
+    },
+    {
+      "date": "2021-07-14",
+      "value": 171,
+      "avg_cvss": 7.1,
+      "cvss_count": 171
+    },
+    {
+      "date": "2021-07-15",
+      "value": 82,
+      "avg_cvss": 6.9,
+      "cvss_count": 82
+    },
+    {
+      "date": "2021-07-16",
+      "value": 58,
+      "avg_cvss": 7.2,
+      "cvss_count": 58
+    },
+    {
+      "date": "2021-07-17",
+      "value": 6,
+      "avg_cvss": 7.1,
+      "cvss_count": 6
+    },
+    {
+      "date": "2021-07-18",
+      "value": 1,
+      "avg_cvss": 7.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-07-19",
+      "value": 60,
+      "avg_cvss": 6.9,
+      "cvss_count": 60
+    },
+    {
+      "date": "2021-07-20",
+      "value": 44,
+      "avg_cvss": 6.7,
+      "cvss_count": 44
+    },
+    {
+      "date": "2021-07-21",
+      "value": 215,
+      "avg_cvss": 6.5,
+      "cvss_count": 215
+    },
+    {
+      "date": "2021-07-22",
+      "value": 91,
+      "avg_cvss": 7.4,
+      "cvss_count": 91
+    },
+    {
+      "date": "2021-07-23",
+      "value": 20,
+      "avg_cvss": 7.7,
+      "cvss_count": 20
+    },
+    {
+      "date": "2021-07-24",
+      "value": 1,
+      "avg_cvss": 4.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-07-25",
+      "value": 34,
+      "avg_cvss": 5.9,
+      "cvss_count": 34
+    },
+    {
+      "date": "2021-07-26",
+      "value": 62,
+      "avg_cvss": 6.7,
+      "cvss_count": 62
+    },
+    {
+      "date": "2021-07-27",
+      "value": 6,
+      "avg_cvss": 6.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2021-07-28",
+      "value": 11,
+      "avg_cvss": 6.4,
+      "cvss_count": 11
+    },
+    {
+      "date": "2021-07-29",
+      "value": 11,
+      "avg_cvss": 7.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2021-07-30",
+      "value": 83,
+      "avg_cvss": 7.0,
+      "cvss_count": 83
+    },
+    {
+      "date": "2021-07-31",
+      "value": 6,
+      "avg_cvss": 8.0,
+      "cvss_count": 6
+    },
+    {
+      "date": "2021-08-01",
+      "value": 1,
+      "avg_cvss": 7.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-08-02",
+      "value": 116,
+      "avg_cvss": 7.1,
+      "cvss_count": 116
+    },
+    {
+      "date": "2021-08-03",
+      "value": 117,
+      "avg_cvss": 7.4,
+      "cvss_count": 117
+    },
+    {
+      "date": "2021-08-04",
+      "value": 84,
+      "avg_cvss": 7.0,
+      "cvss_count": 84
+    },
+    {
+      "date": "2021-08-05",
+      "value": 91,
+      "avg_cvss": 7.0,
+      "cvss_count": 91
+    },
+    {
+      "date": "2021-08-06",
+      "value": 52,
+      "avg_cvss": 7.1,
+      "cvss_count": 52
+    },
+    {
+      "date": "2021-08-07",
+      "value": 11,
+      "avg_cvss": 8.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2021-08-08",
+      "value": 68,
+      "avg_cvss": 7.6,
+      "cvss_count": 68
+    },
+    {
+      "date": "2021-08-09",
+      "value": 68,
+      "avg_cvss": 6.9,
+      "cvss_count": 68
+    },
+    {
+      "date": "2021-08-10",
+      "value": 86,
+      "avg_cvss": 6.7,
+      "cvss_count": 86
+    },
+    {
+      "date": "2021-08-11",
+      "value": 125,
+      "avg_cvss": 7.0,
+      "cvss_count": 125
+    },
+    {
+      "date": "2021-08-12",
+      "value": 167,
+      "avg_cvss": 7.0,
+      "cvss_count": 167
+    },
+    {
+      "date": "2021-08-13",
+      "value": 65,
+      "avg_cvss": 7.3,
+      "cvss_count": 65
+    },
+    {
+      "date": "2021-08-14",
+      "value": 1,
+      "avg_cvss": 3.7,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-08-15",
+      "value": 3,
+      "avg_cvss": 6.6,
+      "cvss_count": 3
+    },
+    {
+      "date": "2021-08-16",
+      "value": 106,
+      "avg_cvss": 6.6,
+      "cvss_count": 106
+    },
+    {
+      "date": "2021-08-17",
+      "value": 72,
+      "avg_cvss": 7.3,
+      "cvss_count": 72
+    },
+    {
+      "date": "2021-08-18",
+      "value": 95,
+      "avg_cvss": 6.8,
+      "cvss_count": 95
+    },
+    {
+      "date": "2021-08-19",
+      "value": 36,
+      "avg_cvss": 7.1,
+      "cvss_count": 36
+    },
+    {
+      "date": "2021-08-20",
+      "value": 73,
+      "avg_cvss": 6.6,
+      "cvss_count": 73
+    },
+    {
+      "date": "2021-08-21",
+      "value": 1,
+      "avg_cvss": 9.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-08-22",
+      "value": 6,
+      "avg_cvss": 5.9,
+      "cvss_count": 6
+    },
+    {
+      "date": "2021-08-23",
+      "value": 94,
+      "avg_cvss": 7.0,
+      "cvss_count": 94
+    },
+    {
+      "date": "2021-08-24",
+      "value": 222,
+      "avg_cvss": 6.9,
+      "cvss_count": 222
+    },
+    {
+      "date": "2021-08-25",
+      "value": 68,
+      "avg_cvss": 6.8,
+      "cvss_count": 68
+    },
+    {
+      "date": "2021-08-26",
+      "value": 59,
+      "avg_cvss": 7.1,
+      "cvss_count": 59
+    },
+    {
+      "date": "2021-08-27",
+      "value": 33,
+      "avg_cvss": 7.4,
+      "cvss_count": 33
+    },
+    {
+      "date": "2021-08-28",
+      "value": 1,
+      "avg_cvss": 8.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-08-29",
+      "value": 8,
+      "avg_cvss": 8.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2021-08-30",
+      "value": 87,
+      "avg_cvss": 7.4,
+      "cvss_count": 87
+    },
+    {
+      "date": "2021-08-31",
+      "value": 69,
+      "avg_cvss": 7.2,
+      "cvss_count": 69
+    },
+    {
+      "date": "2021-09-01",
+      "value": 115,
+      "avg_cvss": 7.3,
+      "cvss_count": 115
+    },
+    {
+      "date": "2021-09-02",
+      "value": 54,
+      "avg_cvss": 6.8,
+      "cvss_count": 54
+    },
+    {
+      "date": "2021-09-03",
+      "value": 27,
+      "avg_cvss": 7.8,
+      "cvss_count": 27
+    },
+    {
+      "date": "2021-09-04",
+      "value": 1,
+      "avg_cvss": 5.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-09-05",
+      "value": 4,
+      "avg_cvss": 6.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2021-09-06",
+      "value": 37,
+      "avg_cvss": 6.4,
+      "cvss_count": 37
+    },
+    {
+      "date": "2021-09-07",
+      "value": 122,
+      "avg_cvss": 7.2,
+      "cvss_count": 122
+    },
+    {
+      "date": "2021-09-08",
+      "value": 278,
+      "avg_cvss": 7.0,
+      "cvss_count": 278
+    },
+    {
+      "date": "2021-09-09",
+      "value": 140,
+      "avg_cvss": 6.8,
+      "cvss_count": 140
+    },
+    {
+      "date": "2021-09-10",
+      "value": 50,
+      "avg_cvss": 7.0,
+      "cvss_count": 50
+    },
+    {
+      "date": "2021-09-11",
+      "value": 2,
+      "avg_cvss": 9.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-09-12",
+      "value": 2,
+      "avg_cvss": 7.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-09-13",
+      "value": 66,
+      "avg_cvss": 6.7,
+      "cvss_count": 66
+    },
+    {
+      "date": "2021-09-14",
+      "value": 100,
+      "avg_cvss": 7.0,
+      "cvss_count": 100
+    },
+    {
+      "date": "2021-09-15",
+      "value": 153,
+      "avg_cvss": 7.4,
+      "cvss_count": 153
+    },
+    {
+      "date": "2021-09-16",
+      "value": 48,
+      "avg_cvss": 6.8,
+      "cvss_count": 48
+    },
+    {
+      "date": "2021-09-17",
+      "value": 50,
+      "avg_cvss": 7.8,
+      "cvss_count": 50
+    },
+    {
+      "date": "2021-09-18",
+      "value": 4,
+      "avg_cvss": 6.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2021-09-19",
+      "value": 2,
+      "avg_cvss": 7.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-09-20",
+      "value": 169,
+      "avg_cvss": 6.7,
+      "cvss_count": 169
+    },
+    {
+      "date": "2021-09-21",
+      "value": 25,
+      "avg_cvss": 7.4,
+      "cvss_count": 25
+    },
+    {
+      "date": "2021-09-22",
+      "value": 29,
+      "avg_cvss": 7.2,
+      "cvss_count": 29
+    },
+    {
+      "date": "2021-09-23",
+      "value": 104,
+      "avg_cvss": 6.7,
+      "cvss_count": 104
+    },
+    {
+      "date": "2021-09-24",
+      "value": 26,
+      "avg_cvss": 7.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2021-09-25",
+      "value": 1,
+      "avg_cvss": 5.5,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-09-26",
+      "value": 2,
+      "avg_cvss": 6.2,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-09-27",
+      "value": 115,
+      "avg_cvss": 7.1,
+      "cvss_count": 115
+    },
+    {
+      "date": "2021-09-28",
+      "value": 51,
+      "avg_cvss": 7.2,
+      "cvss_count": 51
+    },
+    {
+      "date": "2021-09-29",
+      "value": 72,
+      "avg_cvss": 6.7,
+      "cvss_count": 72
+    },
+    {
+      "date": "2021-09-30",
+      "value": 53,
+      "avg_cvss": 7.5,
+      "cvss_count": 53
+    },
+    {
+      "date": "2021-10-01",
+      "value": 65,
+      "avg_cvss": 7.1,
+      "cvss_count": 65
+    },
+    {
+      "date": "2021-10-02",
+      "value": 5,
+      "avg_cvss": 6.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2021-10-04",
+      "value": 95,
+      "avg_cvss": 6.6,
+      "cvss_count": 95
+    },
+    {
+      "date": "2021-10-05",
+      "value": 58,
+      "avg_cvss": 6.5,
+      "cvss_count": 58
+    },
+    {
+      "date": "2021-10-06",
+      "value": 123,
+      "avg_cvss": 6.1,
+      "cvss_count": 123
+    },
+    {
+      "date": "2021-10-07",
+      "value": 68,
+      "avg_cvss": 7.7,
+      "cvss_count": 68
+    },
+    {
+      "date": "2021-10-08",
+      "value": 61,
+      "avg_cvss": 7.1,
+      "cvss_count": 61
+    },
+    {
+      "date": "2021-10-10",
+      "value": 1,
+      "avg_cvss": 8.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-10-11",
+      "value": 66,
+      "avg_cvss": 7.1,
+      "cvss_count": 66
+    },
+    {
+      "date": "2021-10-12",
+      "value": 72,
+      "avg_cvss": 7.1,
+      "cvss_count": 72
+    },
+    {
+      "date": "2021-10-13",
+      "value": 116,
+      "avg_cvss": 7.0,
+      "cvss_count": 116
+    },
+    {
+      "date": "2021-10-14",
+      "value": 34,
+      "avg_cvss": 7.4,
+      "cvss_count": 34
+    },
+    {
+      "date": "2021-10-15",
+      "value": 59,
+      "avg_cvss": 7.0,
+      "cvss_count": 59
+    },
+    {
+      "date": "2021-10-18",
+      "value": 64,
+      "avg_cvss": 6.8,
+      "cvss_count": 64
+    },
+    {
+      "date": "2021-10-19",
+      "value": 120,
+      "avg_cvss": 7.0,
+      "cvss_count": 120
+    },
+    {
+      "date": "2021-10-20",
+      "value": 191,
+      "avg_cvss": 6.3,
+      "cvss_count": 191
+    },
+    {
+      "date": "2021-10-21",
+      "value": 59,
+      "avg_cvss": 6.5,
+      "cvss_count": 59
+    },
+    {
+      "date": "2021-10-22",
+      "value": 99,
+      "avg_cvss": 7.0,
+      "cvss_count": 99
+    },
+    {
+      "date": "2021-10-25",
+      "value": 84,
+      "avg_cvss": 6.6,
+      "cvss_count": 84
+    },
+    {
+      "date": "2021-10-26",
+      "value": 43,
+      "avg_cvss": 7.5,
+      "cvss_count": 43
+    },
+    {
+      "date": "2021-10-27",
+      "value": 70,
+      "avg_cvss": 6.9,
+      "cvss_count": 70
+    },
+    {
+      "date": "2021-10-28",
+      "value": 105,
+      "avg_cvss": 6.8,
+      "cvss_count": 105
+    },
+    {
+      "date": "2021-10-29",
+      "value": 31,
+      "avg_cvss": 7.5,
+      "cvss_count": 31
+    },
+    {
+      "date": "2021-10-30",
+      "value": 1,
+      "avg_cvss": 5.9,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-10-31",
+      "value": 11,
+      "avg_cvss": 9.2,
+      "cvss_count": 11
+    },
+    {
+      "date": "2021-11-01",
+      "value": 69,
+      "avg_cvss": 6.6,
+      "cvss_count": 69
+    },
+    {
+      "date": "2021-11-02",
+      "value": 86,
+      "avg_cvss": 7.3,
+      "cvss_count": 86
+    },
+    {
+      "date": "2021-11-03",
+      "value": 88,
+      "avg_cvss": 7.5,
+      "cvss_count": 88
+    },
+    {
+      "date": "2021-11-04",
+      "value": 52,
+      "avg_cvss": 7.4,
+      "cvss_count": 52
+    },
+    {
+      "date": "2021-11-05",
+      "value": 100,
+      "avg_cvss": 6.5,
+      "cvss_count": 100
+    },
+    {
+      "date": "2021-11-07",
+      "value": 6,
+      "avg_cvss": 7.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2021-11-08",
+      "value": 89,
+      "avg_cvss": 6.8,
+      "cvss_count": 89
+    },
+    {
+      "date": "2021-11-09",
+      "value": 69,
+      "avg_cvss": 7.2,
+      "cvss_count": 69
+    },
+    {
+      "date": "2021-11-10",
+      "value": 132,
+      "avg_cvss": 6.9,
+      "cvss_count": 132
+    },
+    {
+      "date": "2021-11-11",
+      "value": 23,
+      "avg_cvss": 7.1,
+      "cvss_count": 23
+    },
+    {
+      "date": "2021-11-12",
+      "value": 72,
+      "avg_cvss": 7.0,
+      "cvss_count": 72
+    },
+    {
+      "date": "2021-11-13",
+      "value": 14,
+      "avg_cvss": 6.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2021-11-14",
+      "value": 17,
+      "avg_cvss": 7.8,
+      "cvss_count": 17
+    },
+    {
+      "date": "2021-11-15",
+      "value": 65,
+      "avg_cvss": 7.1,
+      "cvss_count": 65
+    },
+    {
+      "date": "2021-11-16",
+      "value": 51,
+      "avg_cvss": 7.3,
+      "cvss_count": 51
+    },
+    {
+      "date": "2021-11-17",
+      "value": 104,
+      "avg_cvss": 6.7,
+      "cvss_count": 104
+    },
+    {
+      "date": "2021-11-18",
+      "value": 66,
+      "avg_cvss": 6.8,
+      "cvss_count": 66
+    },
+    {
+      "date": "2021-11-19",
+      "value": 76,
+      "avg_cvss": 7.3,
+      "cvss_count": 76
+    },
+    {
+      "date": "2021-11-20",
+      "value": 19,
+      "avg_cvss": 5.9,
+      "cvss_count": 19
+    },
+    {
+      "date": "2021-11-21",
+      "value": 1,
+      "avg_cvss": 8.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-11-22",
+      "value": 50,
+      "avg_cvss": 6.9,
+      "cvss_count": 50
+    },
+    {
+      "date": "2021-11-23",
+      "value": 90,
+      "avg_cvss": 7.0,
+      "cvss_count": 90
+    },
+    {
+      "date": "2021-11-24",
+      "value": 46,
+      "avg_cvss": 7.2,
+      "cvss_count": 46
+    },
+    {
+      "date": "2021-11-25",
+      "value": 1,
+      "avg_cvss": 8.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-11-26",
+      "value": 17,
+      "avg_cvss": 7.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2021-11-27",
+      "value": 1,
+      "avg_cvss": 5.4,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-11-28",
+      "value": 2,
+      "avg_cvss": 8.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2021-11-29",
+      "value": 52,
+      "avg_cvss": 6.7,
+      "cvss_count": 52
+    },
+    {
+      "date": "2021-11-30",
+      "value": 50,
+      "avg_cvss": 7.1,
+      "cvss_count": 50
+    },
+    {
+      "date": "2021-12-01",
+      "value": 73,
+      "avg_cvss": 7.4,
+      "cvss_count": 73
+    },
+    {
+      "date": "2021-12-02",
+      "value": 38,
+      "avg_cvss": 7.0,
+      "cvss_count": 38
+    },
+    {
+      "date": "2021-12-03",
+      "value": 31,
+      "avg_cvss": 7.7,
+      "cvss_count": 31
+    },
+    {
+      "date": "2021-12-04",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-12-05",
+      "value": 6,
+      "avg_cvss": 7.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2021-12-06",
+      "value": 52,
+      "avg_cvss": 8.1,
+      "cvss_count": 52
+    },
+    {
+      "date": "2021-12-07",
+      "value": 136,
+      "avg_cvss": 7.8,
+      "cvss_count": 136
+    },
+    {
+      "date": "2021-12-08",
+      "value": 139,
+      "avg_cvss": 7.0,
+      "cvss_count": 139
+    },
+    {
+      "date": "2021-12-09",
+      "value": 52,
+      "avg_cvss": 7.7,
+      "cvss_count": 52
+    },
+    {
+      "date": "2021-12-10",
+      "value": 33,
+      "avg_cvss": 7.1,
+      "cvss_count": 33
+    },
+    {
+      "date": "2021-12-11",
+      "value": 1,
+      "avg_cvss": 4.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2021-12-12",
+      "value": 4,
+      "avg_cvss": 8.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2021-12-13",
+      "value": 108,
+      "avg_cvss": 6.4,
+      "cvss_count": 108
+    },
+    {
+      "date": "2021-12-14",
+      "value": 114,
+      "avg_cvss": 6.9,
+      "cvss_count": 114
+    },
+    {
+      "date": "2021-12-15",
+      "value": 252,
+      "avg_cvss": 6.9,
+      "cvss_count": 252
+    },
+    {
+      "date": "2021-12-16",
+      "value": 44,
+      "avg_cvss": 7.0,
+      "cvss_count": 44
+    },
+    {
+      "date": "2021-12-17",
+      "value": 65,
+      "avg_cvss": 6.6,
+      "cvss_count": 65
+    },
+    {
+      "date": "2021-12-18",
+      "value": 3,
+      "avg_cvss": 7.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2021-12-19",
+      "value": 3,
+      "avg_cvss": 8.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2021-12-20",
+      "value": 70,
+      "avg_cvss": 7.0,
+      "cvss_count": 70
+    },
+    {
+      "date": "2021-12-21",
+      "value": 65,
+      "avg_cvss": 6.9,
+      "cvss_count": 65
+    },
+    {
+      "date": "2021-12-22",
+      "value": 117,
+      "avg_cvss": 7.6,
+      "cvss_count": 117
+    },
+    {
+      "date": "2021-12-23",
+      "value": 94,
+      "avg_cvss": 7.8,
+      "cvss_count": 94
+    },
+    {
+      "date": "2021-12-24",
+      "value": 15,
+      "avg_cvss": 6.5,
+      "cvss_count": 15
+    },
+    {
+      "date": "2021-12-25",
+      "value": 11,
+      "avg_cvss": 6.5,
+      "cvss_count": 11
+    },
+    {
+      "date": "2021-12-26",
+      "value": 220,
+      "avg_cvss": 7.9,
+      "cvss_count": 220
+    },
+    {
+      "date": "2021-12-27",
+      "value": 94,
+      "avg_cvss": 8.1,
+      "cvss_count": 94
+    },
+    {
+      "date": "2021-12-28",
+      "value": 28,
+      "avg_cvss": 7.7,
+      "cvss_count": 28
+    },
+    {
+      "date": "2021-12-29",
+      "value": 21,
+      "avg_cvss": 6.6,
+      "cvss_count": 21
+    },
+    {
+      "date": "2021-12-30",
+      "value": 50,
+      "avg_cvss": 7.4,
+      "cvss_count": 50
+    },
+    {
+      "date": "2021-12-31",
+      "value": 2,
+      "avg_cvss": 6.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2022-01-01",
+      "value": 41,
+      "avg_cvss": 6.8,
+      "cvss_count": 41
+    },
+    {
+      "date": "2022-01-02",
+      "value": 3,
+      "avg_cvss": 6.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2022-01-03",
+      "value": 104,
+      "avg_cvss": 7.2,
+      "cvss_count": 104
+    },
+    {
+      "date": "2022-01-04",
+      "value": 53,
+      "avg_cvss": 7.1,
+      "cvss_count": 53
+    },
+    {
+      "date": "2022-01-05",
+      "value": 31,
+      "avg_cvss": 6.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2022-01-06",
+      "value": 60,
+      "avg_cvss": 6.6,
+      "cvss_count": 60
+    },
+    {
+      "date": "2022-01-07",
+      "value": 2,
+      "avg_cvss": 3.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2022-01-10",
+      "value": 171,
+      "avg_cvss": 6.8,
+      "cvss_count": 171
+    },
+    {
+      "date": "2022-01-11",
+      "value": 134,
+      "avg_cvss": 7.1,
+      "cvss_count": 134
+    },
+    {
+      "date": "2022-01-12",
+      "value": 65,
+      "avg_cvss": 6.4,
+      "cvss_count": 65
+    },
+    {
+      "date": "2022-01-13",
+      "value": 156,
+      "avg_cvss": 7.0,
+      "cvss_count": 156
+    },
+    {
+      "date": "2022-01-14",
+      "value": 148,
+      "avg_cvss": 6.8,
+      "cvss_count": 148
+    },
+    {
+      "date": "2022-01-15",
+      "value": 15,
+      "avg_cvss": 7.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2022-01-16",
+      "value": 3,
+      "avg_cvss": 5.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2022-01-17",
+      "value": 35,
+      "avg_cvss": 6.5,
+      "cvss_count": 35
+    },
+    {
+      "date": "2022-01-18",
+      "value": 85,
+      "avg_cvss": 6.4,
+      "cvss_count": 85
+    },
+    {
+      "date": "2022-01-19",
+      "value": 229,
+      "avg_cvss": 6.1,
+      "cvss_count": 229
+    },
+    {
+      "date": "2022-01-20",
+      "value": 64,
+      "avg_cvss": 6.7,
+      "cvss_count": 64
+    },
+    {
+      "date": "2022-01-21",
+      "value": 84,
+      "avg_cvss": 7.5,
+      "cvss_count": 84
+    },
+    {
+      "date": "2022-01-22",
+      "value": 3,
+      "avg_cvss": 5.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2022-01-23",
+      "value": 4,
+      "avg_cvss": 7.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2022-01-24",
+      "value": 78,
+      "avg_cvss": 7.2,
+      "cvss_count": 78
+    },
+    {
+      "date": "2022-01-25",
+      "value": 102,
+      "avg_cvss": 7.0,
+      "cvss_count": 102
+    },
+    {
+      "date": "2022-01-26",
+      "value": 51,
+      "avg_cvss": 6.8,
+      "cvss_count": 51
+    },
+    {
+      "date": "2022-01-27",
+      "value": 87,
+      "avg_cvss": 6.2,
+      "cvss_count": 87
+    },
+    {
+      "date": "2022-01-28",
+      "value": 166,
+      "avg_cvss": 7.4,
+      "cvss_count": 166
+    },
+    {
+      "date": "2022-01-29",
+      "value": 6,
+      "avg_cvss": 6.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2022-01-30",
+      "value": 8,
+      "avg_cvss": 7.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2022-01-31",
+      "value": 28,
+      "avg_cvss": 6.9,
+      "cvss_count": 28
+    },
+    {
+      "date": "2022-02-01",
+      "value": 72,
+      "avg_cvss": 6.9,
+      "cvss_count": 72
+    },
+    {
+      "date": "2022-02-02",
+      "value": 28,
+      "avg_cvss": 7.7,
+      "cvss_count": 28
+    },
+    {
+      "date": "2022-02-03",
+      "value": 47,
+      "avg_cvss": 7.4,
+      "cvss_count": 47
+    },
+    {
+      "date": "2022-02-04",
+      "value": 218,
+      "avg_cvss": 7.7,
+      "cvss_count": 218
+    },
+    {
+      "date": "2022-02-05",
+      "value": 3,
+      "avg_cvss": 7.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2022-02-06",
+      "value": 11,
+      "avg_cvss": 8.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2022-02-07",
+      "value": 50,
+      "avg_cvss": 6.4,
+      "cvss_count": 50
+    },
+    {
+      "date": "2022-02-08",
+      "value": 39,
+      "avg_cvss": 7.0,
+      "cvss_count": 39
+    },
+    {
+      "date": "2022-02-09",
+      "value": 271,
+      "avg_cvss": 6.9,
+      "cvss_count": 271
+    },
+    {
+      "date": "2022-02-10",
+      "value": 47,
+      "avg_cvss": 7.6,
+      "cvss_count": 47
+    },
+    {
+      "date": "2022-02-11",
+      "value": 139,
+      "avg_cvss": 7.2,
+      "cvss_count": 139
+    },
+    {
+      "date": "2022-02-12",
+      "value": 46,
+      "avg_cvss": 7.8,
+      "cvss_count": 46
+    },
+    {
+      "date": "2022-02-14",
+      "value": 79,
+      "avg_cvss": 7.2,
+      "cvss_count": 79
+    },
+    {
+      "date": "2022-02-15",
+      "value": 91,
+      "avg_cvss": 7.1,
+      "cvss_count": 91
+    },
+    {
+      "date": "2022-02-16",
+      "value": 93,
+      "avg_cvss": 7.5,
+      "cvss_count": 93
+    },
+    {
+      "date": "2022-02-17",
+      "value": 34,
+      "avg_cvss": 7.2,
+      "cvss_count": 34
+    },
+    {
+      "date": "2022-02-18",
+      "value": 214,
+      "avg_cvss": 7.4,
+      "cvss_count": 214
+    },
+    {
+      "date": "2022-02-19",
+      "value": 26,
+      "avg_cvss": 7.9,
+      "cvss_count": 26
+    },
+    {
+      "date": "2022-02-20",
+      "value": 13,
+      "avg_cvss": 6.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2022-02-21",
+      "value": 49,
+      "avg_cvss": 6.3,
+      "cvss_count": 49
+    },
+    {
+      "date": "2022-02-22",
+      "value": 20,
+      "avg_cvss": 7.1,
+      "cvss_count": 20
+    },
+    {
+      "date": "2022-02-23",
+      "value": 22,
+      "avg_cvss": 6.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2022-02-24",
+      "value": 146,
+      "avg_cvss": 7.5,
+      "cvss_count": 146
+    },
+    {
+      "date": "2022-02-25",
+      "value": 83,
+      "avg_cvss": 7.4,
+      "cvss_count": 83
+    },
+    {
+      "date": "2022-02-26",
+      "value": 18,
+      "avg_cvss": 6.9,
+      "cvss_count": 18
+    },
+    {
+      "date": "2022-02-27",
+      "value": 2,
+      "avg_cvss": 6.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2022-02-28",
+      "value": 81,
+      "avg_cvss": 6.5,
+      "cvss_count": 81
+    },
+    {
+      "date": "2022-03-01",
+      "value": 47,
+      "avg_cvss": 7.2,
+      "cvss_count": 47
+    },
+    {
+      "date": "2022-03-02",
+      "value": 72,
+      "avg_cvss": 7.0,
+      "cvss_count": 72
+    },
+    {
+      "date": "2022-03-03",
+      "value": 61,
+      "avg_cvss": 7.1,
+      "cvss_count": 61
+    },
+    {
+      "date": "2022-03-04",
+      "value": 55,
+      "avg_cvss": 7.0,
+      "cvss_count": 55
+    },
+    {
+      "date": "2022-03-05",
+      "value": 7,
+      "avg_cvss": 8.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2022-03-06",
+      "value": 11,
+      "avg_cvss": 7.6,
+      "cvss_count": 11
+    },
+    {
+      "date": "2022-03-07",
+      "value": 50,
+      "avg_cvss": 6.6,
+      "cvss_count": 50
+    },
+    {
+      "date": "2022-03-08",
+      "value": 34,
+      "avg_cvss": 6.8,
+      "cvss_count": 34
+    },
+    {
+      "date": "2022-03-09",
+      "value": 96,
+      "avg_cvss": 6.8,
+      "cvss_count": 96
+    },
+    {
+      "date": "2022-03-10",
+      "value": 239,
+      "avg_cvss": 7.0,
+      "cvss_count": 239
+    },
+    {
+      "date": "2022-03-11",
+      "value": 95,
+      "avg_cvss": 7.2,
+      "cvss_count": 95
+    },
+    {
+      "date": "2022-03-12",
+      "value": 9,
+      "avg_cvss": 6.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2022-03-13",
+      "value": 10,
+      "avg_cvss": 6.8,
+      "cvss_count": 10
+    },
+    {
+      "date": "2022-03-14",
+      "value": 91,
+      "avg_cvss": 6.6,
+      "cvss_count": 91
+    },
+    {
+      "date": "2022-03-15",
+      "value": 94,
+      "avg_cvss": 7.4,
+      "cvss_count": 94
+    },
+    {
+      "date": "2022-03-16",
+      "value": 148,
+      "avg_cvss": 6.9,
+      "cvss_count": 148
+    },
+    {
+      "date": "2022-03-17",
+      "value": 56,
+      "avg_cvss": 7.6,
+      "cvss_count": 56
+    },
+    {
+      "date": "2022-03-18",
+      "value": 159,
+      "avg_cvss": 7.7,
+      "cvss_count": 159
+    },
+    {
+      "date": "2022-03-19",
+      "value": 2,
+      "avg_cvss": 8.0,
+      "cvss_count": 2
+    },
+    {
+      "date": "2022-03-20",
+      "value": 13,
+      "avg_cvss": 7.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2022-03-21",
+      "value": 62,
+      "avg_cvss": 7.6,
+      "cvss_count": 62
+    },
+    {
+      "date": "2022-03-22",
+      "value": 23,
+      "avg_cvss": 8.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2022-03-23",
+      "value": 98,
+      "avg_cvss": 7.4,
+      "cvss_count": 98
+    },
+    {
+      "date": "2022-03-24",
+      "value": 43,
+      "avg_cvss": 7.9,
+      "cvss_count": 43
+    },
+    {
+      "date": "2022-03-25",
+      "value": 77,
+      "avg_cvss": 7.1,
+      "cvss_count": 77
+    },
+    {
+      "date": "2022-03-26",
+      "value": 10,
+      "avg_cvss": 7.5,
+      "cvss_count": 10
+    },
+    {
+      "date": "2022-03-27",
+      "value": 8,
+      "avg_cvss": 8.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2022-03-28",
+      "value": 110,
+      "avg_cvss": 6.6,
+      "cvss_count": 110
+    },
+    {
+      "date": "2022-03-29",
+      "value": 95,
+      "avg_cvss": 7.1,
+      "cvss_count": 95
+    },
+    {
+      "date": "2022-03-30",
+      "value": 137,
+      "avg_cvss": 7.0,
+      "cvss_count": 137
+    },
+    {
+      "date": "2022-03-31",
+      "value": 46,
+      "avg_cvss": 7.2,
+      "cvss_count": 46
+    },
+    {
+      "date": "2022-04-01",
+      "value": 102,
+      "avg_cvss": 7.4,
+      "cvss_count": 102
+    },
+    {
+      "date": "2022-04-02",
+      "value": 4,
+      "avg_cvss": 6.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2022-04-03",
+      "value": 25,
+      "avg_cvss": 7.2,
+      "cvss_count": 25
+    },
+    {
+      "date": "2022-04-04",
+      "value": 100,
+      "avg_cvss": 6.6,
+      "cvss_count": 100
+    },
+    {
+      "date": "2022-04-05",
+      "value": 128,
+      "avg_cvss": 8.0,
+      "cvss_count": 128
+    },
+    {
+      "date": "2022-04-06",
+      "value": 59,
+      "avg_cvss": 7.1,
+      "cvss_count": 59
+    },
+    {
+      "date": "2022-04-07",
+      "value": 46,
+      "avg_cvss": 8.0,
+      "cvss_count": 46
+    },
+    {
+      "date": "2022-04-08",
+      "value": 58,
+      "avg_cvss": 7.3,
+      "cvss_count": 58
+    },
+    {
+      "date": "2022-04-09",
+      "value": 7,
+      "avg_cvss": 5.9,
+      "cvss_count": 7
+    },
+    {
+      "date": "2022-04-10",
+      "value": 39,
+      "avg_cvss": 8.0,
+      "cvss_count": 39
+    },
+    {
+      "date": "2022-04-11",
+      "value": 186,
+      "avg_cvss": 6.5,
+      "cvss_count": 186
+    },
+    {
+      "date": "2022-04-12",
+      "value": 163,
+      "avg_cvss": 7.2,
+      "cvss_count": 163
+    },
+    {
+      "date": "2022-04-13",
+      "value": 59,
+      "avg_cvss": 7.0,
+      "cvss_count": 59
+    },
+    {
+      "date": "2022-04-14",
+      "value": 110,
+      "avg_cvss": 7.3,
+      "cvss_count": 110
+    },
+    {
+      "date": "2022-04-15",
+      "value": 232,
+      "avg_cvss": 7.3,
+      "cvss_count": 232
+    },
+    {
+      "date": "2022-04-16",
+      "value": 6,
+      "avg_cvss": 5.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "2022-04-18",
+      "value": 101,
+      "avg_cvss": 7.4,
+      "cvss_count": 101
+    },
+    {
+      "date": "2022-04-19",
+      "value": 129,
+      "avg_cvss": 6.4,
+      "cvss_count": 129
+    },
+    {
+      "date": "2022-04-20",
+      "value": 43,
+      "avg_cvss": 7.3,
+      "cvss_count": 43
+    },
+    {
+      "date": "2022-04-21",
+      "value": 109,
+      "avg_cvss": 8.0,
+      "cvss_count": 109
+    },
+    {
+      "date": "2022-04-22",
+      "value": 44,
+      "avg_cvss": 7.0,
+      "cvss_count": 44
+    },
+    {
+      "date": "2022-04-23",
+      "value": 2,
+      "avg_cvss": 6.7,
+      "cvss_count": 2
+    },
+    {
+      "date": "2022-04-24",
+      "value": 3,
+      "avg_cvss": 6.5,
+      "cvss_count": 3
+    },
+    {
+      "date": "2022-04-25",
+      "value": 79,
+      "avg_cvss": 7.0,
+      "cvss_count": 79
+    },
+    {
+      "date": "2022-04-26",
+      "value": 36,
+      "avg_cvss": 7.7,
+      "cvss_count": 36
+    },
+    {
+      "date": "2022-04-27",
+      "value": 63,
+      "avg_cvss": 6.5,
+      "cvss_count": 63
+    },
+    {
+      "date": "2022-04-28",
+      "value": 57,
+      "avg_cvss": 6.8,
+      "cvss_count": 57
+    },
+    {
+      "date": "2022-04-29",
+      "value": 50,
+      "avg_cvss": 7.2,
+      "cvss_count": 50
+    },
+    {
+      "date": "2022-04-30",
+      "value": 6,
+      "avg_cvss": 7.3,
+      "cvss_count": 6
+    },
+    {
+      "date": "2022-05-01",
+      "value": 22,
+      "avg_cvss": 7.2,
+      "cvss_count": 22
+    },
+    {
+      "date": "2022-05-02",
+      "value": 81,
+      "avg_cvss": 7.5,
+      "cvss_count": 81
+    },
+    {
+      "date": "2022-05-03",
+      "value": 109,
+      "avg_cvss": 6.7,
+      "cvss_count": 109
+    },
+    {
+      "date": "2022-05-04",
+      "value": 77,
+      "avg_cvss": 7.4,
+      "cvss_count": 77
+    },
+    {
+      "date": "2022-05-05",
+      "value": 121,
+      "avg_cvss": 7.3,
+      "cvss_count": 121
+    },
+    {
+      "date": "2022-05-06",
+      "value": 79,
+      "avg_cvss": 7.0,
+      "cvss_count": 79
+    },
+    {
+      "date": "2022-05-07",
+      "value": 4,
+      "avg_cvss": 6.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2022-05-08",
+      "value": 5,
+      "avg_cvss": 8.2,
+      "cvss_count": 5
+    },
+    {
+      "date": "2022-05-09",
+      "value": 44,
+      "avg_cvss": 7.3,
+      "cvss_count": 44
+    },
+    {
+      "date": "2022-05-10",
+      "value": 171,
+      "avg_cvss": 7.7,
+      "cvss_count": 171
+    },
+    {
+      "date": "2022-05-11",
+      "value": 174,
+      "avg_cvss": 6.8,
+      "cvss_count": 174
+    },
+    {
+      "date": "2022-05-12",
+      "value": 157,
+      "avg_cvss": 7.4,
+      "cvss_count": 157
+    },
+    {
+      "date": "2022-05-13",
+      "value": 89,
+      "avg_cvss": 7.7,
+      "cvss_count": 89
+    },
+    {
+      "date": "2022-05-14",
+      "value": 3,
+      "avg_cvss": 8.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2022-05-15",
+      "value": 7,
+      "avg_cvss": 8.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2022-05-16",
+      "value": 97,
+      "avg_cvss": 7.1,
+      "cvss_count": 97
+    },
+    {
+      "date": "2022-05-17",
+      "value": 111,
+      "avg_cvss": 6.9,
+      "cvss_count": 111
+    },
+    {
+      "date": "2022-05-18",
+      "value": 77,
+      "avg_cvss": 7.0,
+      "cvss_count": 77
+    },
+    {
+      "date": "2022-05-19",
+      "value": 39,
+      "avg_cvss": 7.6,
+      "cvss_count": 39
+    },
+    {
+      "date": "2022-05-20",
+      "value": 124,
+      "avg_cvss": 6.9,
+      "cvss_count": 124
+    },
+    {
+      "date": "2022-05-21",
+      "value": 18,
+      "avg_cvss": 6.8,
+      "cvss_count": 18
+    },
+    {
+      "date": "2022-05-22",
+      "value": 1,
+      "avg_cvss": 9.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2022-05-23",
+      "value": 47,
+      "avg_cvss": 6.9,
+      "cvss_count": 47
+    },
+    {
+      "date": "2022-05-24",
+      "value": 75,
+      "avg_cvss": 7.0,
+      "cvss_count": 75
+    },
+    {
+      "date": "2022-05-25",
+      "value": 59,
+      "avg_cvss": 7.2,
+      "cvss_count": 59
+    },
+    {
+      "date": "2022-05-26",
+      "value": 153,
+      "avg_cvss": 7.4,
+      "cvss_count": 153
+    },
+    {
+      "date": "2022-05-27",
+      "value": 26,
+      "avg_cvss": 6.4,
+      "cvss_count": 26
+    },
+    {
+      "date": "2022-05-29",
+      "value": 2,
+      "avg_cvss": 6.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2022-05-30",
+      "value": 26,
+      "avg_cvss": 5.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2022-05-31",
+      "value": 23,
+      "avg_cvss": 7.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2022-06-01",
+      "value": 16,
+      "avg_cvss": 7.0,
+      "cvss_count": 16
+    },
+    {
+      "date": "2022-06-02",
+      "value": 320,
+      "avg_cvss": 7.8,
+      "cvss_count": 320
+    },
+    {
+      "date": "2022-06-03",
+      "value": 25,
+      "avg_cvss": 8.0,
+      "cvss_count": 25
+    },
+    {
+      "date": "2022-06-05",
+      "value": 2,
+      "avg_cvss": 6.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2022-06-06",
+      "value": 61,
+      "avg_cvss": 6.6,
+      "cvss_count": 61
+    },
+    {
+      "date": "2022-06-07",
+      "value": 78,
+      "avg_cvss": 5.3,
+      "cvss_count": 78
+    },
+    {
+      "date": "2022-06-08",
+      "value": 79,
+      "avg_cvss": 6.8,
+      "cvss_count": 79
+    },
+    {
+      "date": "2022-06-09",
+      "value": 101,
+      "avg_cvss": 6.8,
+      "cvss_count": 101
+    },
+    {
+      "date": "2022-06-10",
+      "value": 44,
+      "avg_cvss": 6.7,
+      "cvss_count": 44
+    },
+    {
+      "date": "2022-06-11",
+      "value": 8,
+      "avg_cvss": 7.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2022-06-12",
+      "value": 10,
+      "avg_cvss": 5.4,
+      "cvss_count": 10
+    },
+    {
+      "date": "2022-06-13",
+      "value": 147,
+      "avg_cvss": 6.8,
+      "cvss_count": 147
+    },
+    {
+      "date": "2022-06-14",
+      "value": 197,
+      "avg_cvss": 7.2,
+      "cvss_count": 197
+    },
+    {
+      "date": "2022-06-15",
+      "value": 255,
+      "avg_cvss": 7.1,
+      "cvss_count": 255
+    },
+    {
+      "date": "2022-06-16",
+      "value": 100,
+      "avg_cvss": 7.3,
+      "cvss_count": 100
+    },
+    {
+      "date": "2022-06-17",
+      "value": 56,
+      "avg_cvss": 7.6,
+      "cvss_count": 56
+    },
+    {
+      "date": "2022-06-18",
+      "value": 20,
+      "avg_cvss": 5.5,
+      "cvss_count": 20
+    },
+    {
+      "date": "2022-06-19",
+      "value": 16,
+      "avg_cvss": 6.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2022-06-20",
+      "value": 60,
+      "avg_cvss": 6.5,
+      "cvss_count": 60
+    },
+    {
+      "date": "2022-06-21",
+      "value": 63,
+      "avg_cvss": 6.8,
+      "cvss_count": 63
+    },
+    {
+      "date": "2022-06-22",
+      "value": 18,
+      "avg_cvss": 5.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2022-06-23",
+      "value": 123,
+      "avg_cvss": 6.6,
+      "cvss_count": 123
+    },
+    {
+      "date": "2022-06-24",
+      "value": 135,
+      "avg_cvss": 7.5,
+      "cvss_count": 135
+    },
+    {
+      "date": "2022-06-25",
+      "value": 7,
+      "avg_cvss": 6.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2022-06-26",
+      "value": 4,
+      "avg_cvss": 6.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2022-06-27",
+      "value": 125,
+      "avg_cvss": 6.3,
+      "cvss_count": 125
+    },
+    {
+      "date": "2022-06-28",
+      "value": 63,
+      "avg_cvss": 6.7,
+      "cvss_count": 63
+    },
+    {
+      "date": "2022-06-29",
+      "value": 49,
+      "avg_cvss": 6.2,
+      "cvss_count": 49
+    },
+    {
+      "date": "2022-06-30",
+      "value": 98,
+      "avg_cvss": 6.7,
+      "cvss_count": 98
+    },
+    {
+      "date": "2022-07-01",
+      "value": 87,
+      "avg_cvss": 7.0,
+      "cvss_count": 87
+    },
+    {
+      "date": "2022-07-02",
+      "value": 9,
+      "avg_cvss": 7.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2022-07-03",
+      "value": 3,
+      "avg_cvss": 7.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2022-07-04",
+      "value": 38,
+      "avg_cvss": 6.2,
+      "cvss_count": 38
+    },
+    {
+      "date": "2022-07-05",
+      "value": 31,
+      "avg_cvss": 7.4,
+      "cvss_count": 31
+    },
+    {
+      "date": "2022-07-06",
+      "value": 93,
+      "avg_cvss": 6.9,
+      "cvss_count": 93
+    },
+    {
+      "date": "2022-07-07",
+      "value": 47,
+      "avg_cvss": 7.0,
+      "cvss_count": 47
+    },
+    {
+      "date": "2022-07-08",
+      "value": 26,
+      "avg_cvss": 7.2,
+      "cvss_count": 26
+    },
+    {
+      "date": "2022-07-09",
+      "value": 1,
+      "avg_cvss": 6.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2022-07-10",
+      "value": 2,
+      "avg_cvss": 5.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2022-07-11",
+      "value": 144,
+      "avg_cvss": 8.1,
+      "cvss_count": 144
+    },
+    {
+      "date": "2022-07-12",
+      "value": 247,
+      "avg_cvss": 6.5,
+      "cvss_count": 247
+    },
+    {
+      "date": "2022-07-13",
+      "value": 53,
+      "avg_cvss": 7.1,
+      "cvss_count": 53
+    },
+    {
+      "date": "2022-07-14",
+      "value": 68,
+      "avg_cvss": 6.8,
+      "cvss_count": 68
+    },
+    {
+      "date": "2022-07-15",
+      "value": 75,
+      "avg_cvss": 6.8,
+      "cvss_count": 75
+    },
+    {
+      "date": "2022-07-16",
+      "value": 12,
+      "avg_cvss": 6.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2022-07-17",
+      "value": 67,
+      "avg_cvss": 6.9,
+      "cvss_count": 67
+    },
+    {
+      "date": "2022-07-18",
+      "value": 106,
+      "avg_cvss": 7.1,
+      "cvss_count": 106
+    },
+    {
+      "date": "2022-07-19",
+      "value": 142,
+      "avg_cvss": 6.4,
+      "cvss_count": 142
+    },
+    {
+      "date": "2022-07-20",
+      "value": 89,
+      "avg_cvss": 7.5,
+      "cvss_count": 89
+    },
+    {
+      "date": "2022-07-21",
+      "value": 57,
+      "avg_cvss": 6.3,
+      "cvss_count": 57
+    },
+    {
+      "date": "2022-07-22",
+      "value": 82,
+      "avg_cvss": 6.5,
+      "cvss_count": 82
+    },
+    {
+      "date": "2022-07-23",
+      "value": 25,
+      "avg_cvss": 7.8,
+      "cvss_count": 25
+    },
+    {
+      "date": "2022-07-24",
+      "value": 3,
+      "avg_cvss": 7.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2022-07-25",
+      "value": 102,
+      "avg_cvss": 7.3,
+      "cvss_count": 102
+    },
+    {
+      "date": "2022-07-26",
+      "value": 115,
+      "avg_cvss": 7.1,
+      "cvss_count": 115
+    },
+    {
+      "date": "2022-07-27",
+      "value": 110,
+      "avg_cvss": 6.7,
+      "cvss_count": 110
+    },
+    {
+      "date": "2022-07-28",
+      "value": 96,
+      "avg_cvss": 7.5,
+      "cvss_count": 96
+    },
+    {
+      "date": "2022-07-29",
+      "value": 33,
+      "avg_cvss": 7.1,
+      "cvss_count": 33
+    },
+    {
+      "date": "2022-07-30",
+      "value": 6,
+      "avg_cvss": 6.6,
+      "cvss_count": 6
+    },
+    {
+      "date": "2022-08-01",
+      "value": 123,
+      "avg_cvss": 6.5,
+      "cvss_count": 123
+    },
+    {
+      "date": "2022-08-02",
+      "value": 53,
+      "avg_cvss": 8.0,
+      "cvss_count": 53
+    },
+    {
+      "date": "2022-08-03",
+      "value": 44,
+      "avg_cvss": 7.4,
+      "cvss_count": 44
+    },
+    {
+      "date": "2022-08-04",
+      "value": 58,
+      "avg_cvss": 6.9,
+      "cvss_count": 58
+    },
+    {
+      "date": "2022-08-05",
+      "value": 169,
+      "avg_cvss": 6.9,
+      "cvss_count": 169
+    },
+    {
+      "date": "2022-08-06",
+      "value": 12,
+      "avg_cvss": 5.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2022-08-07",
+      "value": 1,
+      "avg_cvss": 9.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2022-08-08",
+      "value": 46,
+      "avg_cvss": 6.5,
+      "cvss_count": 46
+    },
+    {
+      "date": "2022-08-09",
+      "value": 124,
+      "avg_cvss": 7.0,
+      "cvss_count": 124
+    },
+    {
+      "date": "2022-08-10",
+      "value": 134,
+      "avg_cvss": 7.6,
+      "cvss_count": 134
+    },
+    {
+      "date": "2022-08-11",
+      "value": 94,
+      "avg_cvss": 6.7,
+      "cvss_count": 94
+    },
+    {
+      "date": "2022-08-12",
+      "value": 164,
+      "avg_cvss": 6.2,
+      "cvss_count": 164
+    },
+    {
+      "date": "2022-08-15",
+      "value": 64,
+      "avg_cvss": 7.4,
+      "cvss_count": 64
+    },
+    {
+      "date": "2022-08-16",
+      "value": 162,
+      "avg_cvss": 6.7,
+      "cvss_count": 162
+    },
+    {
+      "date": "2022-08-17",
+      "value": 48,
+      "avg_cvss": 7.4,
+      "cvss_count": 48
+    },
+    {
+      "date": "2022-08-18",
+      "value": 127,
+      "avg_cvss": 7.1,
+      "cvss_count": 127
+    },
+    {
+      "date": "2022-08-19",
+      "value": 49,
+      "avg_cvss": 7.4,
+      "cvss_count": 49
+    },
+    {
+      "date": "2022-08-20",
+      "value": 3,
+      "avg_cvss": 7.9,
+      "cvss_count": 3
+    },
+    {
+      "date": "2022-08-21",
+      "value": 4,
+      "avg_cvss": 8.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2022-08-22",
+      "value": 114,
+      "avg_cvss": 6.5,
+      "cvss_count": 114
+    },
+    {
+      "date": "2022-08-23",
+      "value": 90,
+      "avg_cvss": 6.7,
+      "cvss_count": 90
+    },
+    {
+      "date": "2022-08-24",
+      "value": 65,
+      "avg_cvss": 6.9,
+      "cvss_count": 65
+    },
+    {
+      "date": "2022-08-25",
+      "value": 222,
+      "avg_cvss": 8.1,
+      "cvss_count": 222
+    },
+    {
+      "date": "2022-08-26",
+      "value": 66,
+      "avg_cvss": 7.0,
+      "cvss_count": 66
+    },
+    {
+      "date": "2022-08-27",
+      "value": 9,
+      "avg_cvss": 6.2,
+      "cvss_count": 9
+    },
+    {
+      "date": "2022-08-28",
+      "value": 25,
+      "avg_cvss": 8.6,
+      "cvss_count": 25
+    },
+    {
+      "date": "2022-08-29",
+      "value": 108,
+      "avg_cvss": 7.1,
+      "cvss_count": 108
+    },
+    {
+      "date": "2022-08-30",
+      "value": 52,
+      "avg_cvss": 7.9,
+      "cvss_count": 52
+    },
+    {
+      "date": "2022-08-31",
+      "value": 87,
+      "avg_cvss": 7.4,
+      "cvss_count": 87
+    },
+    {
+      "date": "2022-09-01",
+      "value": 69,
+      "avg_cvss": 6.8,
+      "cvss_count": 69
+    },
+    {
+      "date": "2022-09-02",
+      "value": 76,
+      "avg_cvss": 7.6,
+      "cvss_count": 76
+    },
+    {
+      "date": "2022-09-03",
+      "value": 1,
+      "avg_cvss": 7.8,
+      "cvss_count": 1
+    },
+    {
+      "date": "2022-09-04",
+      "value": 1,
+      "avg_cvss": 7.3,
+      "cvss_count": 1
+    },
+    {
+      "date": "2022-09-05",
+      "value": 40,
+      "avg_cvss": 6.7,
+      "cvss_count": 40
+    },
+    {
+      "date": "2022-09-06",
+      "value": 157,
+      "avg_cvss": 7.0,
+      "cvss_count": 157
+    },
+    {
+      "date": "2022-09-07",
+      "value": 54,
+      "avg_cvss": 7.7,
+      "cvss_count": 54
+    },
+    {
+      "date": "2022-09-08",
+      "value": 62,
+      "avg_cvss": 7.5,
+      "cvss_count": 62
+    },
+    {
+      "date": "2022-09-09",
+      "value": 131,
+      "avg_cvss": 5.8,
+      "cvss_count": 131
+    },
+    {
+      "date": "2022-09-11",
+      "value": 7,
+      "avg_cvss": 6.4,
+      "cvss_count": 7
+    },
+    {
+      "date": "2022-09-12",
+      "value": 51,
+      "avg_cvss": 6.9,
+      "cvss_count": 51
+    },
+    {
+      "date": "2022-09-13",
+      "value": 201,
+      "avg_cvss": 7.5,
+      "cvss_count": 201
+    },
+    {
+      "date": "2022-09-14",
+      "value": 48,
+      "avg_cvss": 7.0,
+      "cvss_count": 48
+    },
+    {
+      "date": "2022-09-15",
+      "value": 86,
+      "avg_cvss": 7.2,
+      "cvss_count": 86
+    },
+    {
+      "date": "2022-09-16",
+      "value": 255,
+      "avg_cvss": 7.0,
+      "cvss_count": 255
+    },
+    {
+      "date": "2022-09-17",
+      "value": 8,
+      "avg_cvss": 5.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2022-09-18",
+      "value": 7,
+      "avg_cvss": 6.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2022-09-19",
+      "value": 122,
+      "avg_cvss": 7.8,
+      "cvss_count": 122
+    },
+    {
+      "date": "2022-09-20",
+      "value": 88,
+      "avg_cvss": 7.5,
+      "cvss_count": 88
+    },
+    {
+      "date": "2022-09-21",
+      "value": 95,
+      "avg_cvss": 6.7,
+      "cvss_count": 95
+    },
+    {
+      "date": "2022-09-22",
+      "value": 60,
+      "avg_cvss": 6.7,
+      "cvss_count": 60
+    },
+    {
+      "date": "2022-09-23",
+      "value": 204,
+      "avg_cvss": 6.9,
+      "cvss_count": 204
+    },
+    {
+      "date": "2022-09-24",
+      "value": 7,
+      "avg_cvss": 6.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2022-09-25",
+      "value": 3,
+      "avg_cvss": 7.7,
+      "cvss_count": 3
+    },
+    {
+      "date": "2022-09-26",
+      "value": 105,
+      "avg_cvss": 7.6,
+      "cvss_count": 105
+    },
+    {
+      "date": "2022-09-27",
+      "value": 32,
+      "avg_cvss": 6.9,
+      "cvss_count": 32
+    },
+    {
+      "date": "2022-09-28",
+      "value": 73,
+      "avg_cvss": 6.7,
+      "cvss_count": 73
+    },
+    {
+      "date": "2022-09-29",
+      "value": 87,
+      "avg_cvss": 6.8,
+      "cvss_count": 87
+    },
+    {
+      "date": "2022-09-30",
+      "value": 67,
+      "avg_cvss": 6.7,
+      "cvss_count": 67
+    },
+    {
+      "date": "2022-10-01",
+      "value": 1,
+      "avg_cvss": 9.1,
+      "cvss_count": 1
+    },
+    {
+      "date": "2022-10-02",
+      "value": 2,
+      "avg_cvss": 7.5,
+      "cvss_count": 2
+    },
+    {
+      "date": "2022-10-03",
+      "value": 49,
+      "avg_cvss": 7.0,
+      "cvss_count": 49
+    },
+    {
+      "date": "2022-10-06",
+      "value": 66,
+      "avg_cvss": 7.2,
+      "cvss_count": 64
+    },
+    {
+      "date": "2022-10-07",
+      "value": 115,
+      "avg_cvss": 6.9,
+      "cvss_count": 115
+    },
+    {
+      "date": "2022-10-08",
+      "value": 3,
+      "avg_cvss": 4.8,
+      "cvss_count": 3
+    },
+    {
+      "date": "2022-10-09",
+      "value": 2,
+      "avg_cvss": 5.9,
+      "cvss_count": 2
+    },
+    {
+      "date": "2022-10-10",
+      "value": 47,
+      "avg_cvss": 6.3,
+      "cvss_count": 47
+    },
+    {
+      "date": "2022-10-11",
+      "value": 260,
+      "avg_cvss": 7.4,
+      "cvss_count": 260
+    },
+    {
+      "date": "2022-10-12",
+      "value": 65,
+      "avg_cvss": 7.2,
+      "cvss_count": 65
+    },
+    {
+      "date": "2022-10-13",
+      "value": 63,
+      "avg_cvss": 7.4,
+      "cvss_count": 63
+    },
+    {
+      "date": "2022-10-14",
+      "value": 191,
+      "avg_cvss": 6.9,
+      "cvss_count": 191
+    },
+    {
+      "date": "2022-10-15",
+      "value": 4,
+      "avg_cvss": 5.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2022-10-16",
+      "value": 7,
+      "avg_cvss": 5.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2022-10-17",
+      "value": 118,
+      "avg_cvss": 6.5,
+      "cvss_count": 118
+    },
+    {
+      "date": "2022-10-18",
+      "value": 165,
+      "avg_cvss": 6.3,
+      "cvss_count": 165
+    },
+    {
+      "date": "2022-10-19",
+      "value": 139,
+      "avg_cvss": 6.9,
+      "cvss_count": 139
+    },
+    {
+      "date": "2022-10-20",
+      "value": 35,
+      "avg_cvss": 7.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2022-10-21",
+      "value": 58,
+      "avg_cvss": 6.4,
+      "cvss_count": 58
+    },
+    {
+      "date": "2022-10-22",
+      "value": 1,
+      "avg_cvss": 5.0,
+      "cvss_count": 1
+    },
+    {
+      "date": "2022-10-24",
+      "value": 30,
+      "avg_cvss": 7.2,
+      "cvss_count": 30
+    },
+    {
+      "date": "2022-10-25",
+      "value": 125,
+      "avg_cvss": 7.8,
+      "cvss_count": 125
+    },
+    {
+      "date": "2022-10-26",
+      "value": 59,
+      "avg_cvss": 7.3,
+      "cvss_count": 59
+    },
+    {
+      "date": "2022-10-27",
+      "value": 57,
+      "avg_cvss": 7.2,
+      "cvss_count": 57
+    },
+    {
+      "date": "2022-10-28",
+      "value": 84,
+      "avg_cvss": 7.6,
+      "cvss_count": 84
+    },
+    {
+      "date": "2022-10-29",
+      "value": 6,
+      "avg_cvss": 8.5,
+      "cvss_count": 6
+    },
+    {
+      "date": "2022-10-30",
+      "value": 7,
+      "avg_cvss": 6.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2022-10-31",
+      "value": 90,
+      "avg_cvss": 7.3,
+      "cvss_count": 90
+    },
+    {
+      "date": "2022-11-01",
+      "value": 208,
+      "avg_cvss": 6.8,
+      "cvss_count": 208
+    },
+    {
+      "date": "2022-11-02",
+      "value": 69,
+      "avg_cvss": 6.3,
+      "cvss_count": 69
+    },
+    {
+      "date": "2022-11-03",
+      "value": 86,
+      "avg_cvss": 6.6,
+      "cvss_count": 86
+    },
+    {
+      "date": "2022-11-04",
+      "value": 48,
+      "avg_cvss": 6.9,
+      "cvss_count": 48
+    },
+    {
+      "date": "2022-11-05",
+      "value": 2,
+      "avg_cvss": 5.4,
+      "cvss_count": 2
+    },
+    {
+      "date": "2022-11-06",
+      "value": 3,
+      "avg_cvss": 8.4,
+      "cvss_count": 3
+    },
+    {
+      "date": "2022-11-07",
+      "value": 64,
+      "avg_cvss": 7.7,
+      "cvss_count": 64
+    },
+    {
+      "date": "2022-11-08",
+      "value": 119,
+      "avg_cvss": 6.7,
+      "cvss_count": 119
+    },
+    {
+      "date": "2022-11-09",
+      "value": 172,
+      "avg_cvss": 7.2,
+      "cvss_count": 172
+    },
+    {
+      "date": "2022-11-10",
+      "value": 54,
+      "avg_cvss": 6.7,
+      "cvss_count": 54
+    },
+    {
+      "date": "2022-11-11",
+      "value": 86,
+      "avg_cvss": 6.3,
+      "cvss_count": 86
+    },
+    {
+      "date": "2022-11-12",
+      "value": 13,
+      "avg_cvss": 7.7,
+      "cvss_count": 13
+    },
+    {
+      "date": "2022-11-13",
+      "value": 15,
+      "avg_cvss": 5.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2022-11-14",
+      "value": 81,
+      "avg_cvss": 6.4,
+      "cvss_count": 81
+    },
+    {
+      "date": "2022-11-15",
+      "value": 160,
+      "avg_cvss": 6.5,
+      "cvss_count": 160
+    },
+    {
+      "date": "2022-11-16",
+      "value": 44,
+      "avg_cvss": 6.8,
+      "cvss_count": 44
+    },
+    {
+      "date": "2022-11-17",
+      "value": 88,
+      "avg_cvss": 7.0,
+      "cvss_count": 88
+    },
+    {
+      "date": "2022-11-18",
+      "value": 88,
+      "avg_cvss": 6.0,
+      "cvss_count": 88
+    },
+    {
+      "date": "2022-11-19",
+      "value": 20,
+      "avg_cvss": 6.5,
+      "cvss_count": 20
+    },
+    {
+      "date": "2022-11-20",
+      "value": 8,
+      "avg_cvss": 6.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2022-11-21",
+      "value": 71,
+      "avg_cvss": 7.3,
+      "cvss_count": 71
+    },
+    {
+      "date": "2022-11-22",
+      "value": 78,
+      "avg_cvss": 7.9,
+      "cvss_count": 78
+    },
+    {
+      "date": "2022-11-23",
+      "value": 100,
+      "avg_cvss": 7.4,
+      "cvss_count": 100
+    },
+    {
+      "date": "2022-11-24",
+      "value": 11,
+      "avg_cvss": 6.7,
+      "cvss_count": 11
+    },
+    {
+      "date": "2022-11-25",
+      "value": 69,
+      "avg_cvss": 6.8,
+      "cvss_count": 69
+    },
+    {
+      "date": "2022-11-26",
+      "value": 4,
+      "avg_cvss": 9.1,
+      "cvss_count": 4
+    },
+    {
+      "date": "2022-11-27",
+      "value": 8,
+      "avg_cvss": 7.8,
+      "cvss_count": 8
+    },
+    {
+      "date": "2022-11-28",
+      "value": 65,
+      "avg_cvss": 6.6,
+      "cvss_count": 65
+    },
+    {
+      "date": "2022-11-29",
+      "value": 63,
+      "avg_cvss": 6.6,
+      "cvss_count": 63
+    },
+    {
+      "date": "2022-11-30",
+      "value": 61,
+      "avg_cvss": 6.6,
+      "cvss_count": 61
+    },
+    {
+      "date": "2022-12-01",
+      "value": 45,
+      "avg_cvss": 6.3,
+      "cvss_count": 45
+    },
+    {
+      "date": "2022-12-02",
+      "value": 98,
+      "avg_cvss": 7.2,
+      "cvss_count": 98
+    },
+    {
+      "date": "2022-12-03",
+      "value": 11,
+      "avg_cvss": 6.0,
+      "cvss_count": 11
+    },
+    {
+      "date": "2022-12-04",
+      "value": 11,
+      "avg_cvss": 7.7,
+      "cvss_count": 11
+    },
+    {
+      "date": "2022-12-05",
+      "value": 100,
+      "avg_cvss": 7.0,
+      "cvss_count": 100
+    },
+    {
+      "date": "2022-12-06",
+      "value": 104,
+      "avg_cvss": 6.7,
+      "cvss_count": 104
+    },
+    {
+      "date": "2022-12-07",
+      "value": 61,
+      "avg_cvss": 7.2,
+      "cvss_count": 61
+    },
+    {
+      "date": "2022-12-08",
+      "value": 102,
+      "avg_cvss": 6.2,
+      "cvss_count": 102
+    },
+    {
+      "date": "2022-12-09",
+      "value": 37,
+      "avg_cvss": 6.6,
+      "cvss_count": 37
+    },
+    {
+      "date": "2022-12-10",
+      "value": 6,
+      "avg_cvss": 6.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2022-12-11",
+      "value": 7,
+      "avg_cvss": 5.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2022-12-12",
+      "value": 156,
+      "avg_cvss": 6.7,
+      "cvss_count": 156
+    },
+    {
+      "date": "2022-12-13",
+      "value": 221,
+      "avg_cvss": 7.0,
+      "cvss_count": 221
+    },
+    {
+      "date": "2022-12-14",
+      "value": 93,
+      "avg_cvss": 7.3,
+      "cvss_count": 93
+    },
+    {
+      "date": "2022-12-15",
+      "value": 110,
+      "avg_cvss": 6.8,
+      "cvss_count": 110
+    },
+    {
+      "date": "2022-12-16",
+      "value": 206,
+      "avg_cvss": 6.1,
+      "cvss_count": 206
+    },
+    {
+      "date": "2022-12-17",
+      "value": 16,
+      "avg_cvss": 4.9,
+      "cvss_count": 16
+    },
+    {
+      "date": "2022-12-18",
+      "value": 36,
+      "avg_cvss": 5.1,
+      "cvss_count": 36
+    },
+    {
+      "date": "2022-12-19",
+      "value": 113,
+      "avg_cvss": 6.3,
+      "cvss_count": 113
+    },
+    {
+      "date": "2022-12-20",
+      "value": 88,
+      "avg_cvss": 7.5,
+      "cvss_count": 88
+    },
+    {
+      "date": "2022-12-21",
+      "value": 63,
+      "avg_cvss": 5.7,
+      "cvss_count": 63
+    },
+    {
+      "date": "2022-12-22",
+      "value": 238,
+      "avg_cvss": 7.2,
+      "cvss_count": 238
+    },
+    {
+      "date": "2022-12-23",
+      "value": 73,
+      "avg_cvss": 7.9,
+      "cvss_count": 73
+    },
+    {
+      "date": "2022-12-24",
+      "value": 9,
+      "avg_cvss": 6.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2022-12-25",
+      "value": 44,
+      "avg_cvss": 6.3,
+      "cvss_count": 44
+    },
+    {
+      "date": "2022-12-26",
+      "value": 88,
+      "avg_cvss": 6.7,
+      "cvss_count": 88
+    },
+    {
+      "date": "2022-12-27",
+      "value": 91,
+      "avg_cvss": 6.0,
+      "cvss_count": 91
+    },
+    {
+      "date": "2022-12-28",
+      "value": 60,
+      "avg_cvss": 5.5,
+      "cvss_count": 60
+    },
+    {
+      "date": "2022-12-29",
+      "value": 32,
+      "avg_cvss": 6.3,
+      "cvss_count": 32
+    },
+    {
+      "date": "2022-12-30",
+      "value": 89,
+      "avg_cvss": 7.4,
+      "cvss_count": 89
+    },
+    {
+      "date": "2022-12-31",
+      "value": 13,
+      "avg_cvss": 5.6,
+      "cvss_count": 13
+    },
+    {
+      "date": "2023-01-01",
+      "value": 23,
+      "avg_cvss": 5.8,
+      "cvss_count": 23
+    },
+    {
+      "date": "2023-01-02",
+      "value": 75,
+      "avg_cvss": 6.2,
+      "cvss_count": 75
+    },
+    {
+      "date": "2023-01-03",
+      "value": 68,
+      "avg_cvss": 7.1,
+      "cvss_count": 68
+    },
+    {
+      "date": "2023-01-04",
+      "value": 79,
+      "avg_cvss": 6.0,
+      "cvss_count": 79
+    },
+    {
+      "date": "2023-01-05",
+      "value": 112,
+      "avg_cvss": 6.5,
+      "cvss_count": 112
+    },
+    {
+      "date": "2023-01-06",
+      "value": 46,
+      "avg_cvss": 6.6,
+      "cvss_count": 46
+    },
+    {
+      "date": "2023-01-07",
+      "value": 48,
+      "avg_cvss": 5.0,
+      "cvss_count": 48
+    },
+    {
+      "date": "2023-01-08",
+      "value": 18,
+      "avg_cvss": 5.0,
+      "cvss_count": 18
+    },
+    {
+      "date": "2023-01-09",
+      "value": 96,
+      "avg_cvss": 6.3,
+      "cvss_count": 96
+    },
+    {
+      "date": "2023-01-10",
+      "value": 186,
+      "avg_cvss": 7.2,
+      "cvss_count": 186
+    },
+    {
+      "date": "2023-01-11",
+      "value": 164,
+      "avg_cvss": 8.3,
+      "cvss_count": 164
+    },
+    {
+      "date": "2023-01-12",
+      "value": 73,
+      "avg_cvss": 6.5,
+      "cvss_count": 73
+    },
+    {
+      "date": "2023-01-13",
+      "value": 116,
+      "avg_cvss": 6.9,
+      "cvss_count": 116
+    },
+    {
+      "date": "2023-01-14",
+      "value": 28,
+      "avg_cvss": 6.9,
+      "cvss_count": 28
+    },
+    {
+      "date": "2023-01-15",
+      "value": 31,
+      "avg_cvss": 5.9,
+      "cvss_count": 31
+    },
+    {
+      "date": "2023-01-16",
+      "value": 66,
+      "avg_cvss": 5.7,
+      "cvss_count": 66
+    },
+    {
+      "date": "2023-01-17",
+      "value": 84,
+      "avg_cvss": 6.8,
+      "cvss_count": 84
+    },
+    {
+      "date": "2023-01-18",
+      "value": 164,
+      "avg_cvss": 6.4,
+      "cvss_count": 164
+    },
+    {
+      "date": "2023-01-19",
+      "value": 36,
+      "avg_cvss": 6.5,
+      "cvss_count": 36
+    },
+    {
+      "date": "2023-01-20",
+      "value": 118,
+      "avg_cvss": 7.1,
+      "cvss_count": 118
+    },
+    {
+      "date": "2023-01-21",
+      "value": 8,
+      "avg_cvss": 8.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2023-01-22",
+      "value": 7,
+      "avg_cvss": 6.6,
+      "cvss_count": 7
+    },
+    {
+      "date": "2023-01-23",
+      "value": 86,
+      "avg_cvss": 6.5,
+      "cvss_count": 86
+    },
+    {
+      "date": "2023-01-24",
+      "value": 8,
+      "avg_cvss": 7.5,
+      "cvss_count": 8
+    },
+    {
+      "date": "2023-01-25",
+      "value": 2,
+      "avg_cvss": 8.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2023-01-26",
+      "value": 348,
+      "avg_cvss": 7.4,
+      "cvss_count": 348
+    },
+    {
+      "date": "2023-01-27",
+      "value": 74,
+      "avg_cvss": 6.5,
+      "cvss_count": 74
+    },
+    {
+      "date": "2023-01-28",
+      "value": 14,
+      "avg_cvss": 5.6,
+      "cvss_count": 14
+    },
+    {
+      "date": "2023-01-29",
+      "value": 12,
+      "avg_cvss": 5.2,
+      "cvss_count": 12
+    },
+    {
+      "date": "2023-01-30",
+      "value": 100,
+      "avg_cvss": 6.9,
+      "cvss_count": 100
+    },
+    {
+      "date": "2023-01-31",
+      "value": 47,
+      "avg_cvss": 7.7,
+      "cvss_count": 47
+    },
+    {
+      "date": "2023-02-01",
+      "value": 131,
+      "avg_cvss": 7.3,
+      "cvss_count": 131
+    },
+    {
+      "date": "2023-02-02",
+      "value": 45,
+      "avg_cvss": 6.6,
+      "cvss_count": 45
+    },
+    {
+      "date": "2023-02-03",
+      "value": 118,
+      "avg_cvss": 7.6,
+      "cvss_count": 118
+    },
+    {
+      "date": "2023-02-04",
+      "value": 16,
+      "avg_cvss": 5.8,
+      "cvss_count": 16
+    },
+    {
+      "date": "2023-02-05",
+      "value": 1,
+      "avg_cvss": 2.6,
+      "cvss_count": 1
+    },
+    {
+      "date": "2023-02-06",
+      "value": 137,
+      "avg_cvss": 6.4,
+      "cvss_count": 137
+    },
+    {
+      "date": "2023-02-07",
+      "value": 75,
+      "avg_cvss": 6.6,
+      "cvss_count": 75
+    },
+    {
+      "date": "2023-02-08",
+      "value": 68,
+      "avg_cvss": 6.8,
+      "cvss_count": 68
+    },
+    {
+      "date": "2023-02-09",
+      "value": 91,
+      "avg_cvss": 6.4,
+      "cvss_count": 91
+    },
+    {
+      "date": "2023-02-10",
+      "value": 45,
+      "avg_cvss": 7.1,
+      "cvss_count": 45
+    },
+    {
+      "date": "2023-02-11",
+      "value": 35,
+      "avg_cvss": 6.6,
+      "cvss_count": 35
+    },
+    {
+      "date": "2023-02-12",
+      "value": 110,
+      "avg_cvss": 6.5,
+      "cvss_count": 110
+    },
+    {
+      "date": "2023-02-13",
+      "value": 119,
+      "avg_cvss": 6.6,
+      "cvss_count": 119
+    },
+    {
+      "date": "2023-02-14",
+      "value": 197,
+      "avg_cvss": 7.2,
+      "cvss_count": 197
+    },
+    {
+      "date": "2023-02-15",
+      "value": 94,
+      "avg_cvss": 7.2,
+      "cvss_count": 94
+    },
+    {
+      "date": "2023-02-16",
+      "value": 162,
+      "avg_cvss": 6.5,
+      "cvss_count": 162
+    },
+    {
+      "date": "2023-02-17",
+      "value": 100,
+      "avg_cvss": 7.3,
+      "cvss_count": 100
+    },
+    {
+      "date": "2023-02-18",
+      "value": 13,
+      "avg_cvss": 5.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2023-02-19",
+      "value": 9,
+      "avg_cvss": 5.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2023-02-20",
+      "value": 41,
+      "avg_cvss": 7.0,
+      "cvss_count": 41
+    },
+    {
+      "date": "2023-02-21",
+      "value": 91,
+      "avg_cvss": 6.2,
+      "cvss_count": 91
+    },
+    {
+      "date": "2023-02-22",
+      "value": 56,
+      "avg_cvss": 7.6,
+      "cvss_count": 56
+    },
+    {
+      "date": "2023-02-23",
+      "value": 57,
+      "avg_cvss": 6.8,
+      "cvss_count": 57
+    },
+    {
+      "date": "2023-02-24",
+      "value": 46,
+      "avg_cvss": 6.6,
+      "cvss_count": 46
+    },
+    {
+      "date": "2023-02-25",
+      "value": 21,
+      "avg_cvss": 7.5,
+      "cvss_count": 21
+    },
+    {
+      "date": "2023-02-26",
+      "value": 21,
+      "avg_cvss": 6.0,
+      "cvss_count": 21
+    },
+    {
+      "date": "2023-02-27",
+      "value": 145,
+      "avg_cvss": 6.8,
+      "cvss_count": 145
+    },
+    {
+      "date": "2023-02-28",
+      "value": 78,
+      "avg_cvss": 6.5,
+      "cvss_count": 78
+    },
+    {
+      "date": "2023-03-01",
+      "value": 135,
+      "avg_cvss": 6.5,
+      "cvss_count": 135
+    },
+    {
+      "date": "2023-03-02",
+      "value": 55,
+      "avg_cvss": 6.9,
+      "cvss_count": 55
+    },
+    {
+      "date": "2023-03-03",
+      "value": 50,
+      "avg_cvss": 7.3,
+      "cvss_count": 50
+    },
+    {
+      "date": "2023-03-04",
+      "value": 13,
+      "avg_cvss": 6.2,
+      "cvss_count": 13
+    },
+    {
+      "date": "2023-03-05",
+      "value": 15,
+      "avg_cvss": 4.9,
+      "cvss_count": 15
+    },
+    {
+      "date": "2023-03-06",
+      "value": 107,
+      "avg_cvss": 6.3,
+      "cvss_count": 107
+    },
+    {
+      "date": "2023-03-07",
+      "value": 116,
+      "avg_cvss": 6.2,
+      "cvss_count": 116
+    },
+    {
+      "date": "2023-03-08",
+      "value": 45,
+      "avg_cvss": 7.6,
+      "cvss_count": 45
+    },
+    {
+      "date": "2023-03-09",
+      "value": 60,
+      "avg_cvss": 6.8,
+      "cvss_count": 60
+    },
+    {
+      "date": "2023-03-10",
+      "value": 139,
+      "avg_cvss": 6.5,
+      "cvss_count": 139
+    },
+    {
+      "date": "2023-03-11",
+      "value": 9,
+      "avg_cvss": 4.7,
+      "cvss_count": 9
+    },
+    {
+      "date": "2023-03-12",
+      "value": 10,
+      "avg_cvss": 5.8,
+      "cvss_count": 10
+    },
+    {
+      "date": "2023-03-13",
+      "value": 81,
+      "avg_cvss": 6.8,
+      "cvss_count": 81
+    },
+    {
+      "date": "2023-03-14",
+      "value": 152,
+      "avg_cvss": 7.0,
+      "cvss_count": 152
+    },
+    {
+      "date": "2023-03-15",
+      "value": 71,
+      "avg_cvss": 6.9,
+      "cvss_count": 71
+    },
+    {
+      "date": "2023-03-16",
+      "value": 106,
+      "avg_cvss": 6.9,
+      "cvss_count": 106
+    },
+    {
+      "date": "2023-03-17",
+      "value": 56,
+      "avg_cvss": 6.0,
+      "cvss_count": 56
+    },
+    {
+      "date": "2023-03-18",
+      "value": 22,
+      "avg_cvss": 5.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2023-03-19",
+      "value": 15,
+      "avg_cvss": 7.3,
+      "cvss_count": 15
+    },
+    {
+      "date": "2023-03-20",
+      "value": 59,
+      "avg_cvss": 6.2,
+      "cvss_count": 59
+    },
+    {
+      "date": "2023-03-21",
+      "value": 74,
+      "avg_cvss": 7.1,
+      "cvss_count": 74
+    },
+    {
+      "date": "2023-03-22",
+      "value": 102,
+      "avg_cvss": 6.5,
+      "cvss_count": 102
+    },
+    {
+      "date": "2023-03-23",
+      "value": 116,
+      "avg_cvss": 7.0,
+      "cvss_count": 116
+    },
+    {
+      "date": "2023-03-24",
+      "value": 180,
+      "avg_cvss": 6.6,
+      "cvss_count": 180
+    },
+    {
+      "date": "2023-03-25",
+      "value": 34,
+      "avg_cvss": 6.9,
+      "cvss_count": 34
+    },
+    {
+      "date": "2023-03-26",
+      "value": 15,
+      "avg_cvss": 6.5,
+      "cvss_count": 15
+    },
+    {
+      "date": "2023-03-27",
+      "value": 179,
+      "avg_cvss": 6.7,
+      "cvss_count": 179
+    },
+    {
+      "date": "2023-03-28",
+      "value": 145,
+      "avg_cvss": 7.4,
+      "cvss_count": 145
+    },
+    {
+      "date": "2023-03-29",
+      "value": 233,
+      "avg_cvss": 7.3,
+      "cvss_count": 233
+    },
+    {
+      "date": "2023-03-30",
+      "value": 63,
+      "avg_cvss": 6.5,
+      "cvss_count": 63
+    },
+    {
+      "date": "2023-03-31",
+      "value": 59,
+      "avg_cvss": 6.7,
+      "cvss_count": 59
+    },
+    {
+      "date": "2023-04-01",
+      "value": 19,
+      "avg_cvss": 6.4,
+      "cvss_count": 19
+    },
+    {
+      "date": "2023-04-02",
+      "value": 39,
+      "avg_cvss": 6.5,
+      "cvss_count": 39
+    },
+    {
+      "date": "2023-04-03",
+      "value": 45,
+      "avg_cvss": 6.8,
+      "cvss_count": 45
+    },
+    {
+      "date": "2023-04-04",
+      "value": 132,
+      "avg_cvss": 7.3,
+      "cvss_count": 132
+    },
+    {
+      "date": "2023-04-05",
+      "value": 137,
+      "avg_cvss": 6.2,
+      "cvss_count": 137
+    },
+    {
+      "date": "2023-04-06",
+      "value": 111,
+      "avg_cvss": 6.2,
+      "cvss_count": 111
+    },
+    {
+      "date": "2023-04-07",
+      "value": 98,
+      "avg_cvss": 7.2,
+      "cvss_count": 98
+    },
+    {
+      "date": "2023-04-08",
+      "value": 20,
+      "avg_cvss": 5.5,
+      "cvss_count": 20
+    },
+    {
+      "date": "2023-04-09",
+      "value": 13,
+      "avg_cvss": 7.3,
+      "cvss_count": 13
+    },
+    {
+      "date": "2023-04-10",
+      "value": 80,
+      "avg_cvss": 6.9,
+      "cvss_count": 80
+    },
+    {
+      "date": "2023-04-11",
+      "value": 236,
+      "avg_cvss": 6.9,
+      "cvss_count": 236
+    },
+    {
+      "date": "2023-04-12",
+      "value": 104,
+      "avg_cvss": 6.6,
+      "cvss_count": 104
+    },
+    {
+      "date": "2023-04-13",
+      "value": 74,
+      "avg_cvss": 7.7,
+      "cvss_count": 74
+    },
+    {
+      "date": "2023-04-14",
+      "value": 109,
+      "avg_cvss": 7.1,
+      "cvss_count": 109
+    },
+    {
+      "date": "2023-04-15",
+      "value": 63,
+      "avg_cvss": 6.9,
+      "cvss_count": 63
+    },
+    {
+      "date": "2023-04-16",
+      "value": 44,
+      "avg_cvss": 7.1,
+      "cvss_count": 44
+    },
+    {
+      "date": "2023-04-17",
+      "value": 85,
+      "avg_cvss": 6.9,
+      "cvss_count": 85
+    },
+    {
+      "date": "2023-04-18",
+      "value": 163,
+      "avg_cvss": 6.0,
+      "cvss_count": 163
+    },
+    {
+      "date": "2023-04-19",
+      "value": 121,
+      "avg_cvss": 7.2,
+      "cvss_count": 121
+    },
+    {
+      "date": "2023-04-20",
+      "value": 54,
+      "avg_cvss": 6.7,
+      "cvss_count": 54
+    },
+    {
+      "date": "2023-04-21",
+      "value": 60,
+      "avg_cvss": 6.3,
+      "cvss_count": 60
+    },
+    {
+      "date": "2023-04-22",
+      "value": 31,
+      "avg_cvss": 6.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2023-04-23",
+      "value": 26,
+      "avg_cvss": 6.1,
+      "cvss_count": 26
+    },
+    {
+      "date": "2023-04-24",
+      "value": 113,
+      "avg_cvss": 7.2,
+      "cvss_count": 113
+    },
+    {
+      "date": "2023-04-25",
+      "value": 91,
+      "avg_cvss": 6.5,
+      "cvss_count": 91
+    },
+    {
+      "date": "2023-04-26",
+      "value": 63,
+      "avg_cvss": 7.2,
+      "cvss_count": 63
+    },
+    {
+      "date": "2023-04-27",
+      "value": 72,
+      "avg_cvss": 7.1,
+      "cvss_count": 72
+    },
+    {
+      "date": "2023-04-28",
+      "value": 107,
+      "avg_cvss": 6.0,
+      "cvss_count": 107
+    },
+    {
+      "date": "2023-04-29",
+      "value": 17,
+      "avg_cvss": 5.8,
+      "cvss_count": 17
+    },
+    {
+      "date": "2023-04-30",
+      "value": 3,
+      "avg_cvss": 6.2,
+      "cvss_count": 3
+    },
+    {
+      "date": "2023-05-01",
+      "value": 38,
+      "avg_cvss": 6.7,
+      "cvss_count": 38
+    },
+    {
+      "date": "2023-05-02",
+      "value": 70,
+      "avg_cvss": 6.7,
+      "cvss_count": 70
+    },
+    {
+      "date": "2023-05-03",
+      "value": 87,
+      "avg_cvss": 6.1,
+      "cvss_count": 87
+    },
+    {
+      "date": "2023-05-04",
+      "value": 87,
+      "avg_cvss": 6.7,
+      "cvss_count": 87
+    },
+    {
+      "date": "2023-05-05",
+      "value": 41,
+      "avg_cvss": 6.9,
+      "cvss_count": 41
+    },
+    {
+      "date": "2023-05-06",
+      "value": 8,
+      "avg_cvss": 5.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2023-05-07",
+      "value": 5,
+      "avg_cvss": 7.5,
+      "cvss_count": 5
+    },
+    {
+      "date": "2023-05-08",
+      "value": 185,
+      "avg_cvss": 7.0,
+      "cvss_count": 185
+    },
+    {
+      "date": "2023-05-09",
+      "value": 251,
+      "avg_cvss": 6.4,
+      "cvss_count": 251
+    },
+    {
+      "date": "2023-05-10",
+      "value": 210,
+      "avg_cvss": 6.4,
+      "cvss_count": 210
+    },
+    {
+      "date": "2023-05-11",
+      "value": 98,
+      "avg_cvss": 6.7,
+      "cvss_count": 98
+    },
+    {
+      "date": "2023-05-12",
+      "value": 90,
+      "avg_cvss": 7.0,
+      "cvss_count": 90
+    },
+    {
+      "date": "2023-05-14",
+      "value": 11,
+      "avg_cvss": 5.8,
+      "cvss_count": 11
+    },
+    {
+      "date": "2023-05-15",
+      "value": 147,
+      "avg_cvss": 6.9,
+      "cvss_count": 147
+    },
+    {
+      "date": "2023-05-16",
+      "value": 90,
+      "avg_cvss": 6.6,
+      "cvss_count": 90
+    },
+    {
+      "date": "2023-05-17",
+      "value": 61,
+      "avg_cvss": 6.7,
+      "cvss_count": 61
+    },
+    {
+      "date": "2023-05-18",
+      "value": 90,
+      "avg_cvss": 6.6,
+      "cvss_count": 90
+    },
+    {
+      "date": "2023-05-19",
+      "value": 27,
+      "avg_cvss": 6.3,
+      "cvss_count": 27
+    },
+    {
+      "date": "2023-05-20",
+      "value": 23,
+      "avg_cvss": 6.3,
+      "cvss_count": 23
+    },
+    {
+      "date": "2023-05-21",
+      "value": 7,
+      "avg_cvss": 5.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2023-05-22",
+      "value": 84,
+      "avg_cvss": 6.9,
+      "cvss_count": 84
+    },
+    {
+      "date": "2023-05-23",
+      "value": 92,
+      "avg_cvss": 7.1,
+      "cvss_count": 92
+    },
+    {
+      "date": "2023-05-24",
+      "value": 91,
+      "avg_cvss": 6.4,
+      "cvss_count": 91
+    },
+    {
+      "date": "2023-05-25",
+      "value": 79,
+      "avg_cvss": 6.1,
+      "cvss_count": 79
+    },
+    {
+      "date": "2023-05-26",
+      "value": 87,
+      "avg_cvss": 6.4,
+      "cvss_count": 87
+    },
+    {
+      "date": "2023-05-27",
+      "value": 25,
+      "avg_cvss": 6.3,
+      "cvss_count": 25
+    },
+    {
+      "date": "2023-05-28",
+      "value": 30,
+      "avg_cvss": 6.2,
+      "cvss_count": 30
+    },
+    {
+      "date": "2023-05-29",
+      "value": 38,
+      "avg_cvss": 6.2,
+      "cvss_count": 38
+    },
+    {
+      "date": "2023-05-30",
+      "value": 135,
+      "avg_cvss": 6.8,
+      "cvss_count": 135
+    },
+    {
+      "date": "2023-05-31",
+      "value": 131,
+      "avg_cvss": 6.8,
+      "cvss_count": 131
+    },
+    {
+      "date": "2023-06-01",
+      "value": 73,
+      "avg_cvss": 6.8,
+      "cvss_count": 73
+    },
+    {
+      "date": "2023-06-02",
+      "value": 139,
+      "avg_cvss": 7.1,
+      "cvss_count": 139
+    },
+    {
+      "date": "2023-06-03",
+      "value": 25,
+      "avg_cvss": 6.3,
+      "cvss_count": 25
+    },
+    {
+      "date": "2023-06-04",
+      "value": 6,
+      "avg_cvss": 5.7,
+      "cvss_count": 6
+    },
+    {
+      "date": "2023-06-05",
+      "value": 72,
+      "avg_cvss": 6.4,
+      "cvss_count": 72
+    },
+    {
+      "date": "2023-06-06",
+      "value": 151,
+      "avg_cvss": 6.6,
+      "cvss_count": 151
+    },
+    {
+      "date": "2023-06-07",
+      "value": 183,
+      "avg_cvss": 7.3,
+      "cvss_count": 183
+    },
+    {
+      "date": "2023-06-08",
+      "value": 41,
+      "avg_cvss": 6.9,
+      "cvss_count": 41
+    },
+    {
+      "date": "2023-06-09",
+      "value": 119,
+      "avg_cvss": 5.8,
+      "cvss_count": 119
+    },
+    {
+      "date": "2023-06-10",
+      "value": 4,
+      "avg_cvss": 6.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2023-06-11",
+      "value": 8,
+      "avg_cvss": 8.0,
+      "cvss_count": 8
+    },
+    {
+      "date": "2023-06-12",
+      "value": 81,
+      "avg_cvss": 7.4,
+      "cvss_count": 81
+    },
+    {
+      "date": "2023-06-13",
+      "value": 130,
+      "avg_cvss": 6.7,
+      "cvss_count": 130
+    },
+    {
+      "date": "2023-06-14",
+      "value": 175,
+      "avg_cvss": 7.1,
+      "cvss_count": 175
+    },
+    {
+      "date": "2023-06-15",
+      "value": 94,
+      "avg_cvss": 6.6,
+      "cvss_count": 94
+    },
+    {
+      "date": "2023-06-16",
+      "value": 78,
+      "avg_cvss": 6.7,
+      "cvss_count": 78
+    },
+    {
+      "date": "2023-06-17",
+      "value": 9,
+      "avg_cvss": 8.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2023-06-18",
+      "value": 13,
+      "avg_cvss": 6.2,
+      "cvss_count": 13
+    },
+    {
+      "date": "2023-06-19",
+      "value": 116,
+      "avg_cvss": 7.1,
+      "cvss_count": 116
+    },
+    {
+      "date": "2023-06-20",
+      "value": 64,
+      "avg_cvss": 7.1,
+      "cvss_count": 64
+    },
+    {
+      "date": "2023-06-21",
+      "value": 29,
+      "avg_cvss": 7.3,
+      "cvss_count": 29
+    },
+    {
+      "date": "2023-06-22",
+      "value": 111,
+      "avg_cvss": 6.9,
+      "cvss_count": 111
+    },
+    {
+      "date": "2023-06-23",
+      "value": 190,
+      "avg_cvss": 6.5,
+      "cvss_count": 190
+    },
+    {
+      "date": "2023-06-24",
+      "value": 6,
+      "avg_cvss": 8.2,
+      "cvss_count": 6
+    },
+    {
+      "date": "2023-06-25",
+      "value": 10,
+      "avg_cvss": 7.6,
+      "cvss_count": 10
+    },
+    {
+      "date": "2023-06-26",
+      "value": 94,
+      "avg_cvss": 7.1,
+      "cvss_count": 94
+    },
+    {
+      "date": "2023-06-27",
+      "value": 78,
+      "avg_cvss": 6.2,
+      "cvss_count": 78
+    },
+    {
+      "date": "2023-06-28",
+      "value": 150,
+      "avg_cvss": 6.5,
+      "cvss_count": 150
+    },
+    {
+      "date": "2023-06-29",
+      "value": 67,
+      "avg_cvss": 7.2,
+      "cvss_count": 67
+    },
+    {
+      "date": "2023-06-30",
+      "value": 68,
+      "avg_cvss": 6.8,
+      "cvss_count": 68
+    },
+    {
+      "date": "2023-07-01",
+      "value": 50,
+      "avg_cvss": 5.3,
+      "cvss_count": 50
+    },
+    {
+      "date": "2023-07-03",
+      "value": 34,
+      "avg_cvss": 7.1,
+      "cvss_count": 34
+    },
+    {
+      "date": "2023-07-04",
+      "value": 66,
+      "avg_cvss": 6.8,
+      "cvss_count": 66
+    },
+    {
+      "date": "2023-07-05",
+      "value": 79,
+      "avg_cvss": 7.1,
+      "cvss_count": 79
+    },
+    {
+      "date": "2023-07-06",
+      "value": 197,
+      "avg_cvss": 7.1,
+      "cvss_count": 197
+    },
+    {
+      "date": "2023-07-07",
+      "value": 62,
+      "avg_cvss": 6.7,
+      "cvss_count": 62
+    },
+    {
+      "date": "2023-07-08",
+      "value": 4,
+      "avg_cvss": 6.2,
+      "cvss_count": 4
+    },
+    {
+      "date": "2023-07-10",
+      "value": 154,
+      "avg_cvss": 6.2,
+      "cvss_count": 154
+    },
+    {
+      "date": "2023-07-11",
+      "value": 275,
+      "avg_cvss": 6.9,
+      "cvss_count": 275
+    },
+    {
+      "date": "2023-07-12",
+      "value": 210,
+      "avg_cvss": 6.0,
+      "cvss_count": 210
+    },
+    {
+      "date": "2023-07-13",
+      "value": 139,
+      "avg_cvss": 7.1,
+      "cvss_count": 139
+    },
+    {
+      "date": "2023-07-14",
+      "value": 61,
+      "avg_cvss": 7.3,
+      "cvss_count": 61
+    },
+    {
+      "date": "2023-07-15",
+      "value": 12,
+      "avg_cvss": 6.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2023-07-16",
+      "value": 15,
+      "avg_cvss": 6.3,
+      "cvss_count": 15
+    },
+    {
+      "date": "2023-07-17",
+      "value": 97,
+      "avg_cvss": 6.3,
+      "cvss_count": 97
+    },
+    {
+      "date": "2023-07-18",
+      "value": 155,
+      "avg_cvss": 6.3,
+      "cvss_count": 155
+    },
+    {
+      "date": "2023-07-19",
+      "value": 62,
+      "avg_cvss": 6.3,
+      "cvss_count": 62
+    },
+    {
+      "date": "2023-07-20",
+      "value": 67,
+      "avg_cvss": 6.1,
+      "cvss_count": 67
+    },
+    {
+      "date": "2023-07-21",
+      "value": 70,
+      "avg_cvss": 7.4,
+      "cvss_count": 70
+    },
+    {
+      "date": "2023-07-22",
+      "value": 17,
+      "avg_cvss": 4.1,
+      "cvss_count": 17
+    },
+    {
+      "date": "2023-07-23",
+      "value": 18,
+      "avg_cvss": 4.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2023-07-24",
+      "value": 55,
+      "avg_cvss": 6.2,
+      "cvss_count": 55
+    },
+    {
+      "date": "2023-07-25",
+      "value": 99,
+      "avg_cvss": 6.6,
+      "cvss_count": 99
+    },
+    {
+      "date": "2023-07-26",
+      "value": 57,
+      "avg_cvss": 6.7,
+      "cvss_count": 57
+    },
+    {
+      "date": "2023-07-27",
+      "value": 86,
+      "avg_cvss": 7.0,
+      "cvss_count": 86
+    },
+    {
+      "date": "2023-07-28",
+      "value": 57,
+      "avg_cvss": 7.1,
+      "cvss_count": 57
+    },
+    {
+      "date": "2023-07-29",
+      "value": 34,
+      "avg_cvss": 7.3,
+      "cvss_count": 34
+    },
+    {
+      "date": "2023-07-30",
+      "value": 10,
+      "avg_cvss": 8.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2023-07-31",
+      "value": 63,
+      "avg_cvss": 7.2,
+      "cvss_count": 63
+    },
+    {
+      "date": "2023-08-01",
+      "value": 70,
+      "avg_cvss": 7.4,
+      "cvss_count": 70
+    },
+    {
+      "date": "2023-08-02",
+      "value": 67,
+      "avg_cvss": 5.8,
+      "cvss_count": 67
+    },
+    {
+      "date": "2023-08-03",
+      "value": 132,
+      "avg_cvss": 7.1,
+      "cvss_count": 132
+    },
+    {
+      "date": "2023-08-04",
+      "value": 74,
+      "avg_cvss": 7.6,
+      "cvss_count": 74
+    },
+    {
+      "date": "2023-08-05",
+      "value": 25,
+      "avg_cvss": 6.4,
+      "cvss_count": 25
+    },
+    {
+      "date": "2023-08-06",
+      "value": 19,
+      "avg_cvss": 5.7,
+      "cvss_count": 19
+    },
+    {
+      "date": "2023-08-07",
+      "value": 115,
+      "avg_cvss": 7.0,
+      "cvss_count": 115
+    },
+    {
+      "date": "2023-08-08",
+      "value": 253,
+      "avg_cvss": 7.2,
+      "cvss_count": 253
+    },
+    {
+      "date": "2023-08-09",
+      "value": 99,
+      "avg_cvss": 7.5,
+      "cvss_count": 99
+    },
+    {
+      "date": "2023-08-10",
+      "value": 131,
+      "avg_cvss": 6.7,
+      "cvss_count": 131
+    },
+    {
+      "date": "2023-08-11",
+      "value": 156,
+      "avg_cvss": 6.6,
+      "cvss_count": 156
+    },
+    {
+      "date": "2023-08-12",
+      "value": 3,
+      "avg_cvss": 8.3,
+      "cvss_count": 3
+    },
+    {
+      "date": "2023-08-13",
+      "value": 29,
+      "avg_cvss": 7.9,
+      "cvss_count": 29
+    },
+    {
+      "date": "2023-08-14",
+      "value": 134,
+      "avg_cvss": 7.0,
+      "cvss_count": 134
+    },
+    {
+      "date": "2023-08-15",
+      "value": 95,
+      "avg_cvss": 7.6,
+      "cvss_count": 95
+    },
+    {
+      "date": "2023-08-16",
+      "value": 97,
+      "avg_cvss": 6.4,
+      "cvss_count": 97
+    },
+    {
+      "date": "2023-08-17",
+      "value": 78,
+      "avg_cvss": 6.9,
+      "cvss_count": 78
+    },
+    {
+      "date": "2023-08-18",
+      "value": 59,
+      "avg_cvss": 7.6,
+      "cvss_count": 59
+    },
+    {
+      "date": "2023-08-19",
+      "value": 7,
+      "avg_cvss": 7.2,
+      "cvss_count": 7
+    },
+    {
+      "date": "2023-08-20",
+      "value": 13,
+      "avg_cvss": 6.5,
+      "cvss_count": 13
+    },
+    {
+      "date": "2023-08-21",
+      "value": 63,
+      "avg_cvss": 7.3,
+      "cvss_count": 63
+    },
+    {
+      "date": "2023-08-22",
+      "value": 186,
+      "avg_cvss": 6.8,
+      "cvss_count": 186
+    },
+    {
+      "date": "2023-08-23",
+      "value": 59,
+      "avg_cvss": 7.0,
+      "cvss_count": 59
+    },
+    {
+      "date": "2023-08-24",
+      "value": 60,
+      "avg_cvss": 7.3,
+      "cvss_count": 60
+    },
+    {
+      "date": "2023-08-25",
+      "value": 87,
+      "avg_cvss": 6.6,
+      "cvss_count": 87
+    },
+    {
+      "date": "2023-08-26",
+      "value": 6,
+      "avg_cvss": 5.4,
+      "cvss_count": 6
+    },
+    {
+      "date": "2023-08-27",
+      "value": 12,
+      "avg_cvss": 6.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2023-08-28",
+      "value": 78,
+      "avg_cvss": 7.6,
+      "cvss_count": 78
+    },
+    {
+      "date": "2023-08-29",
+      "value": 52,
+      "avg_cvss": 7.1,
+      "cvss_count": 52
+    },
+    {
+      "date": "2023-08-30",
+      "value": 114,
+      "avg_cvss": 7.0,
+      "cvss_count": 114
+    },
+    {
+      "date": "2023-08-31",
+      "value": 104,
+      "avg_cvss": 6.2,
+      "cvss_count": 104
+    },
+    {
+      "date": "2023-09-01",
+      "value": 80,
+      "avg_cvss": 6.6,
+      "cvss_count": 80
+    },
+    {
+      "date": "2023-09-02",
+      "value": 10,
+      "avg_cvss": 7.5,
+      "cvss_count": 10
+    },
+    {
+      "date": "2023-09-03",
+      "value": 24,
+      "avg_cvss": 6.9,
+      "cvss_count": 24
+    },
+    {
+      "date": "2023-09-04",
+      "value": 151,
+      "avg_cvss": 6.1,
+      "cvss_count": 151
+    },
+    {
+      "date": "2023-09-05",
+      "value": 125,
+      "avg_cvss": 7.3,
+      "cvss_count": 125
+    },
+    {
+      "date": "2023-09-06",
+      "value": 160,
+      "avg_cvss": 6.7,
+      "cvss_count": 160
+    },
+    {
+      "date": "2023-09-07",
+      "value": 66,
+      "avg_cvss": 6.9,
+      "cvss_count": 66
+    },
+    {
+      "date": "2023-09-08",
+      "value": 54,
+      "avg_cvss": 6.6,
+      "cvss_count": 54
+    },
+    {
+      "date": "2023-09-09",
+      "value": 14,
+      "avg_cvss": 5.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2023-09-10",
+      "value": 12,
+      "avg_cvss": 5.7,
+      "cvss_count": 12
+    },
+    {
+      "date": "2023-09-11",
+      "value": 110,
+      "avg_cvss": 7.3,
+      "cvss_count": 110
+    },
+    {
+      "date": "2023-09-12",
+      "value": 161,
+      "avg_cvss": 7.0,
+      "cvss_count": 161
+    },
+    {
+      "date": "2023-09-13",
+      "value": 59,
+      "avg_cvss": 6.3,
+      "cvss_count": 59
+    },
+    {
+      "date": "2023-09-14",
+      "value": 59,
+      "avg_cvss": 6.9,
+      "cvss_count": 59
+    },
+    {
+      "date": "2023-09-15",
+      "value": 83,
+      "avg_cvss": 7.0,
+      "cvss_count": 83
+    },
+    {
+      "date": "2023-09-16",
+      "value": 11,
+      "avg_cvss": 6.5,
+      "cvss_count": 11
+    },
+    {
+      "date": "2023-09-17",
+      "value": 18,
+      "avg_cvss": 5.1,
+      "cvss_count": 18
+    },
+    {
+      "date": "2023-09-18",
+      "value": 53,
+      "avg_cvss": 7.3,
+      "cvss_count": 53
+    },
+    {
+      "date": "2023-09-19",
+      "value": 55,
+      "avg_cvss": 7.3,
+      "cvss_count": 55
+    },
+    {
+      "date": "2023-09-20",
+      "value": 127,
+      "avg_cvss": 7.5,
+      "cvss_count": 127
+    },
+    {
+      "date": "2023-09-21",
+      "value": 51,
+      "avg_cvss": 7.6,
+      "cvss_count": 51
+    },
+    {
+      "date": "2023-09-22",
+      "value": 41,
+      "avg_cvss": 7.6,
+      "cvss_count": 41
+    },
+    {
+      "date": "2023-09-23",
+      "value": 7,
+      "avg_cvss": 7.7,
+      "cvss_count": 7
+    },
+    {
+      "date": "2023-09-24",
+      "value": 7,
+      "avg_cvss": 6.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2023-09-25",
+      "value": 92,
+      "avg_cvss": 7.3,
+      "cvss_count": 92
+    },
+    {
+      "date": "2023-09-26",
+      "value": 2,
+      "avg_cvss": 6.6,
+      "cvss_count": 2
+    },
+    {
+      "date": "2023-09-27",
+      "value": 309,
+      "avg_cvss": 6.8,
+      "cvss_count": 309
+    },
+    {
+      "date": "2023-09-28",
+      "value": 71,
+      "avg_cvss": 7.3,
+      "cvss_count": 71
+    },
+    {
+      "date": "2023-09-29",
+      "value": 80,
+      "avg_cvss": 5.8,
+      "cvss_count": 80
+    },
+    {
+      "date": "2023-09-30",
+      "value": 56,
+      "avg_cvss": 5.6,
+      "cvss_count": 56
+    },
+    {
+      "date": "2023-10-01",
+      "value": 7,
+      "avg_cvss": 5.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2023-10-02",
+      "value": 77,
+      "avg_cvss": 6.9,
+      "cvss_count": 77
+    },
+    {
+      "date": "2023-10-03",
+      "value": 138,
+      "avg_cvss": 7.0,
+      "cvss_count": 138
+    },
+    {
+      "date": "2023-10-04",
+      "value": 106,
+      "avg_cvss": 6.8,
+      "cvss_count": 106
+    },
+    {
+      "date": "2023-10-05",
+      "value": 59,
+      "avg_cvss": 6.9,
+      "cvss_count": 59
+    },
+    {
+      "date": "2023-10-06",
+      "value": 68,
+      "avg_cvss": 6.1,
+      "cvss_count": 68
+    },
+    {
+      "date": "2023-10-07",
+      "value": 4,
+      "avg_cvss": 7.7,
+      "cvss_count": 4
+    },
+    {
+      "date": "2023-10-08",
+      "value": 24,
+      "avg_cvss": 5.6,
+      "cvss_count": 24
+    },
+    {
+      "date": "2023-10-09",
+      "value": 85,
+      "avg_cvss": 6.4,
+      "cvss_count": 85
+    },
+    {
+      "date": "2023-10-10",
+      "value": 254,
+      "avg_cvss": 7.0,
+      "cvss_count": 254
+    },
+    {
+      "date": "2023-10-11",
+      "value": 110,
+      "avg_cvss": 7.3,
+      "cvss_count": 110
+    },
+    {
+      "date": "2023-10-12",
+      "value": 67,
+      "avg_cvss": 6.8,
+      "cvss_count": 67
+    },
+    {
+      "date": "2023-10-13",
+      "value": 84,
+      "avg_cvss": 6.6,
+      "cvss_count": 84
+    },
+    {
+      "date": "2023-10-14",
+      "value": 30,
+      "avg_cvss": 6.3,
+      "cvss_count": 30
+    },
+    {
+      "date": "2023-10-15",
+      "value": 10,
+      "avg_cvss": 6.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2023-10-16",
+      "value": 162,
+      "avg_cvss": 6.6,
+      "cvss_count": 162
+    },
+    {
+      "date": "2023-10-17",
+      "value": 165,
+      "avg_cvss": 6.4,
+      "cvss_count": 165
+    },
+    {
+      "date": "2023-10-18",
+      "value": 73,
+      "avg_cvss": 6.9,
+      "cvss_count": 73
+    },
+    {
+      "date": "2023-10-19",
+      "value": 104,
+      "avg_cvss": 7.5,
+      "cvss_count": 104
+    },
+    {
+      "date": "2023-10-20",
+      "value": 115,
+      "avg_cvss": 6.3,
+      "cvss_count": 115
+    },
+    {
+      "date": "2023-10-21",
+      "value": 29,
+      "avg_cvss": 6.4,
+      "cvss_count": 29
+    },
+    {
+      "date": "2023-10-22",
+      "value": 19,
+      "avg_cvss": 6.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2023-10-23",
+      "value": 58,
+      "avg_cvss": 6.3,
+      "cvss_count": 58
+    },
+    {
+      "date": "2023-10-24",
+      "value": 2,
+      "avg_cvss": 4.8,
+      "cvss_count": 2
+    },
+    {
+      "date": "2023-10-25",
+      "value": 327,
+      "avg_cvss": 7.4,
+      "cvss_count": 327
+    },
+    {
+      "date": "2023-10-26",
+      "value": 92,
+      "avg_cvss": 7.2,
+      "cvss_count": 92
+    },
+    {
+      "date": "2023-10-27",
+      "value": 99,
+      "avg_cvss": 6.7,
+      "cvss_count": 99
+    },
+    {
+      "date": "2023-10-28",
+      "value": 13,
+      "avg_cvss": 6.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2023-10-29",
+      "value": 15,
+      "avg_cvss": 7.2,
+      "cvss_count": 15
+    },
+    {
+      "date": "2023-10-30",
+      "value": 168,
+      "avg_cvss": 6.4,
+      "cvss_count": 168
+    },
+    {
+      "date": "2023-10-31",
+      "value": 116,
+      "avg_cvss": 7.2,
+      "cvss_count": 116
+    },
+    {
+      "date": "2023-11-01",
+      "value": 144,
+      "avg_cvss": 6.4,
+      "cvss_count": 144
+    },
+    {
+      "date": "2023-11-02",
+      "value": 94,
+      "avg_cvss": 6.9,
+      "cvss_count": 94
+    },
+    {
+      "date": "2023-11-03",
+      "value": 102,
+      "avg_cvss": 7.4,
+      "cvss_count": 102
+    },
+    {
+      "date": "2023-11-04",
+      "value": 9,
+      "avg_cvss": 7.6,
+      "cvss_count": 9
+    },
+    {
+      "date": "2023-11-05",
+      "value": 8,
+      "avg_cvss": 6.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2023-11-06",
+      "value": 117,
+      "avg_cvss": 6.7,
+      "cvss_count": 117
+    },
+    {
+      "date": "2023-11-07",
+      "value": 172,
+      "avg_cvss": 6.6,
+      "cvss_count": 172
+    },
+    {
+      "date": "2023-11-08",
+      "value": 106,
+      "avg_cvss": 6.9,
+      "cvss_count": 106
+    },
+    {
+      "date": "2023-11-09",
+      "value": 100,
+      "avg_cvss": 5.7,
+      "cvss_count": 100
+    },
+    {
+      "date": "2023-11-10",
+      "value": 41,
+      "avg_cvss": 6.5,
+      "cvss_count": 41
+    },
+    {
+      "date": "2023-11-11",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2023-11-12",
+      "value": 25,
+      "avg_cvss": 5.1,
+      "cvss_count": 25
+    },
+    {
+      "date": "2023-11-13",
+      "value": 85,
+      "avg_cvss": 5.7,
+      "cvss_count": 85
+    },
+    {
+      "date": "2023-11-14",
+      "value": 330,
+      "avg_cvss": 6.6,
+      "cvss_count": 330
+    },
+    {
+      "date": "2023-11-15",
+      "value": 73,
+      "avg_cvss": 7.0,
+      "cvss_count": 73
+    },
+    {
+      "date": "2023-11-16",
+      "value": 123,
+      "avg_cvss": 6.6,
+      "cvss_count": 123
+    },
+    {
+      "date": "2023-11-17",
+      "value": 68,
+      "avg_cvss": 7.5,
+      "cvss_count": 68
+    },
+    {
+      "date": "2023-11-18",
+      "value": 45,
+      "avg_cvss": 5.8,
+      "cvss_count": 45
+    },
+    {
+      "date": "2023-11-19",
+      "value": 1,
+      "avg_cvss": 6.2,
+      "cvss_count": 1
+    },
+    {
+      "date": "2023-11-20",
+      "value": 71,
+      "avg_cvss": 7.2,
+      "cvss_count": 71
+    },
+    {
+      "date": "2023-11-21",
+      "value": 61,
+      "avg_cvss": 6.9,
+      "cvss_count": 61
+    },
+    {
+      "date": "2023-11-22",
+      "value": 160,
+      "avg_cvss": 6.3,
+      "cvss_count": 160
+    },
+    {
+      "date": "2023-11-23",
+      "value": 57,
+      "avg_cvss": 7.2,
+      "cvss_count": 57
+    },
+    {
+      "date": "2023-11-24",
+      "value": 17,
+      "avg_cvss": 6.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2023-11-26",
+      "value": 5,
+      "avg_cvss": 5.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2023-11-27",
+      "value": 94,
+      "avg_cvss": 6.5,
+      "cvss_count": 94
+    },
+    {
+      "date": "2023-11-28",
+      "value": 73,
+      "avg_cvss": 6.7,
+      "cvss_count": 73
+    },
+    {
+      "date": "2023-11-29",
+      "value": 56,
+      "avg_cvss": 8.0,
+      "cvss_count": 56
+    },
+    {
+      "date": "2023-11-30",
+      "value": 207,
+      "avg_cvss": 6.8,
+      "cvss_count": 207
+    },
+    {
+      "date": "2023-12-01",
+      "value": 55,
+      "avg_cvss": 6.6,
+      "cvss_count": 55
+    },
+    {
+      "date": "2023-12-02",
+      "value": 9,
+      "avg_cvss": 4.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2023-12-03",
+      "value": 9,
+      "avg_cvss": 5.9,
+      "cvss_count": 9
+    },
+    {
+      "date": "2023-12-04",
+      "value": 233,
+      "avg_cvss": 6.9,
+      "cvss_count": 233
+    },
+    {
+      "date": "2023-12-05",
+      "value": 138,
+      "avg_cvss": 7.3,
+      "cvss_count": 138
+    },
+    {
+      "date": "2023-12-06",
+      "value": 55,
+      "avg_cvss": 7.2,
+      "cvss_count": 55
+    },
+    {
+      "date": "2023-12-07",
+      "value": 139,
+      "avg_cvss": 7.4,
+      "cvss_count": 139
+    },
+    {
+      "date": "2023-12-08",
+      "value": 77,
+      "avg_cvss": 6.5,
+      "cvss_count": 77
+    },
+    {
+      "date": "2023-12-09",
+      "value": 28,
+      "avg_cvss": 6.6,
+      "cvss_count": 28
+    },
+    {
+      "date": "2023-12-10",
+      "value": 24,
+      "avg_cvss": 6.0,
+      "cvss_count": 24
+    },
+    {
+      "date": "2023-12-11",
+      "value": 38,
+      "avg_cvss": 7.2,
+      "cvss_count": 38
+    },
+    {
+      "date": "2023-12-12",
+      "value": 191,
+      "avg_cvss": 6.7,
+      "cvss_count": 191
+    },
+    {
+      "date": "2023-12-13",
+      "value": 151,
+      "avg_cvss": 6.5,
+      "cvss_count": 151
+    },
+    {
+      "date": "2023-12-14",
+      "value": 159,
+      "avg_cvss": 7.2,
+      "cvss_count": 159
+    },
+    {
+      "date": "2023-12-15",
+      "value": 289,
+      "avg_cvss": 5.9,
+      "cvss_count": 289
+    },
+    {
+      "date": "2023-12-16",
+      "value": 19,
+      "avg_cvss": 6.8,
+      "cvss_count": 19
+    },
+    {
+      "date": "2023-12-17",
+      "value": 25,
+      "avg_cvss": 5.4,
+      "cvss_count": 25
+    },
+    {
+      "date": "2023-12-18",
+      "value": 99,
+      "avg_cvss": 6.0,
+      "cvss_count": 99
+    },
+    {
+      "date": "2023-12-19",
+      "value": 114,
+      "avg_cvss": 7.1,
+      "cvss_count": 114
+    },
+    {
+      "date": "2023-12-20",
+      "value": 119,
+      "avg_cvss": 7.7,
+      "cvss_count": 119
+    },
+    {
+      "date": "2023-12-21",
+      "value": 127,
+      "avg_cvss": 6.9,
+      "cvss_count": 127
+    },
+    {
+      "date": "2023-12-22",
+      "value": 83,
+      "avg_cvss": 7.3,
+      "cvss_count": 83
+    },
+    {
+      "date": "2023-12-23",
+      "value": 12,
+      "avg_cvss": 6.6,
+      "cvss_count": 12
+    },
+    {
+      "date": "2023-12-24",
+      "value": 10,
+      "avg_cvss": 7.1,
+      "cvss_count": 10
+    },
+    {
+      "date": "2023-12-25",
+      "value": 46,
+      "avg_cvss": 7.1,
+      "cvss_count": 46
+    },
+    {
+      "date": "2023-12-26",
+      "value": 66,
+      "avg_cvss": 7.1,
+      "cvss_count": 66
+    },
+    {
+      "date": "2023-12-27",
+      "value": 29,
+      "avg_cvss": 7.5,
+      "cvss_count": 29
+    },
+    {
+      "date": "2023-12-28",
+      "value": 73,
+      "avg_cvss": 6.5,
+      "cvss_count": 73
+    },
+    {
+      "date": "2023-12-29",
+      "value": 162,
+      "avg_cvss": 6.3,
+      "cvss_count": 161
+    },
+    {
+      "date": "2023-12-30",
+      "value": 35,
+      "avg_cvss": 7.0,
+      "cvss_count": 35
+    },
+    {
+      "date": "2023-12-31",
+      "value": 36,
+      "avg_cvss": 6.7,
+      "cvss_count": 36
+    },
+    {
+      "date": "2024-01-01",
+      "value": 14,
+      "avg_cvss": 6.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2024-01-02",
+      "value": 103,
+      "avg_cvss": 6.6,
+      "cvss_count": 103
+    },
+    {
+      "date": "2024-01-03",
+      "value": 97,
+      "avg_cvss": 6.7,
+      "cvss_count": 97
+    },
+    {
+      "date": "2024-01-04",
+      "value": 59,
+      "avg_cvss": 7.5,
+      "cvss_count": 59
+    },
+    {
+      "date": "2024-01-05",
+      "value": 72,
+      "avg_cvss": 6.0,
+      "cvss_count": 72
+    },
+    {
+      "date": "2024-01-06",
+      "value": 8,
+      "avg_cvss": 6.9,
+      "cvss_count": 8
+    },
+    {
+      "date": "2024-01-07",
+      "value": 34,
+      "avg_cvss": 5.9,
+      "cvss_count": 34
+    },
+    {
+      "date": "2024-01-08",
+      "value": 193,
+      "avg_cvss": 7.3,
+      "cvss_count": 193
+    },
+    {
+      "date": "2024-01-09",
+      "value": 160,
+      "avg_cvss": 7.0,
+      "cvss_count": 160
+    },
+    {
+      "date": "2024-01-10",
+      "value": 178,
+      "avg_cvss": 6.9,
+      "cvss_count": 178
+    },
+    {
+      "date": "2024-01-11",
+      "value": 143,
+      "avg_cvss": 6.6,
+      "cvss_count": 143
+    },
+    {
+      "date": "2024-01-12",
+      "value": 128,
+      "avg_cvss": 6.8,
+      "cvss_count": 128
+    },
+    {
+      "date": "2024-01-13",
+      "value": 54,
+      "avg_cvss": 6.2,
+      "cvss_count": 54
+    },
+    {
+      "date": "2024-01-14",
+      "value": 2,
+      "avg_cvss": 5.3,
+      "cvss_count": 2
+    },
+    {
+      "date": "2024-01-15",
+      "value": 68,
+      "avg_cvss": 6.7,
+      "cvss_count": 68
+    },
+    {
+      "date": "2024-01-16",
+      "value": 229,
+      "avg_cvss": 6.5,
+      "cvss_count": 229
+    },
+    {
+      "date": "2024-01-17",
+      "value": 78,
+      "avg_cvss": 6.5,
+      "cvss_count": 78
+    },
+    {
+      "date": "2024-01-18",
+      "value": 94,
+      "avg_cvss": 6.4,
+      "cvss_count": 94
+    },
+    {
+      "date": "2024-01-19",
+      "value": 104,
+      "avg_cvss": 6.7,
+      "cvss_count": 104
+    },
+    {
+      "date": "2024-01-20",
+      "value": 14,
+      "avg_cvss": 8.2,
+      "cvss_count": 14
+    },
+    {
+      "date": "2024-01-21",
+      "value": 12,
+      "avg_cvss": 6.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2024-01-22",
+      "value": 58,
+      "avg_cvss": 6.5,
+      "cvss_count": 58
+    },
+    {
+      "date": "2024-01-23",
+      "value": 133,
+      "avg_cvss": 7.0,
+      "cvss_count": 133
+    },
+    {
+      "date": "2024-01-24",
+      "value": 90,
+      "avg_cvss": 6.9,
+      "cvss_count": 90
+    },
+    {
+      "date": "2024-01-25",
+      "value": 56,
+      "avg_cvss": 6.6,
+      "cvss_count": 56
+    },
+    {
+      "date": "2024-01-26",
+      "value": 122,
+      "avg_cvss": 7.2,
+      "cvss_count": 122
+    },
+    {
+      "date": "2024-01-27",
+      "value": 21,
+      "avg_cvss": 6.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2024-01-28",
+      "value": 9,
+      "avg_cvss": 8.0,
+      "cvss_count": 9
+    },
+    {
+      "date": "2024-01-29",
+      "value": 95,
+      "avg_cvss": 6.4,
+      "cvss_count": 95
+    },
+    {
+      "date": "2024-01-30",
+      "value": 75,
+      "avg_cvss": 6.9,
+      "cvss_count": 75
+    },
+    {
+      "date": "2024-01-31",
+      "value": 91,
+      "avg_cvss": 6.7,
+      "cvss_count": 91
+    },
+    {
+      "date": "2024-02-01",
+      "value": 82,
+      "avg_cvss": 6.6,
+      "cvss_count": 82
+    },
+    {
+      "date": "2024-02-02",
+      "value": 146,
+      "avg_cvss": 6.5,
+      "cvss_count": 146
+    },
+    {
+      "date": "2024-02-03",
+      "value": 20,
+      "avg_cvss": 6.4,
+      "cvss_count": 20
+    },
+    {
+      "date": "2024-02-04",
+      "value": 14,
+      "avg_cvss": 6.6,
+      "cvss_count": 14
+    },
+    {
+      "date": "2024-02-05",
+      "value": 157,
+      "avg_cvss": 6.5,
+      "cvss_count": 157
+    },
+    {
+      "date": "2024-02-06",
+      "value": 149,
+      "avg_cvss": 6.9,
+      "cvss_count": 149
+    },
+    {
+      "date": "2024-02-07",
+      "value": 81,
+      "avg_cvss": 6.9,
+      "cvss_count": 81
+    },
+    {
+      "date": "2024-02-08",
+      "value": 82,
+      "avg_cvss": 7.8,
+      "cvss_count": 82
+    },
+    {
+      "date": "2024-02-09",
+      "value": 88,
+      "avg_cvss": 7.1,
+      "cvss_count": 88
+    },
+    {
+      "date": "2024-02-10",
+      "value": 30,
+      "avg_cvss": 6.1,
+      "cvss_count": 30
+    },
+    {
+      "date": "2024-02-11",
+      "value": 17,
+      "avg_cvss": 7.2,
+      "cvss_count": 17
+    },
+    {
+      "date": "2024-02-12",
+      "value": 89,
+      "avg_cvss": 6.5,
+      "cvss_count": 89
+    },
+    {
+      "date": "2024-02-13",
+      "value": 176,
+      "avg_cvss": 7.2,
+      "cvss_count": 176
+    },
+    {
+      "date": "2024-02-14",
+      "value": 175,
+      "avg_cvss": 6.6,
+      "cvss_count": 175
+    },
+    {
+      "date": "2024-02-15",
+      "value": 104,
+      "avg_cvss": 7.3,
+      "cvss_count": 104
+    },
+    {
+      "date": "2024-02-16",
+      "value": 50,
+      "avg_cvss": 6.8,
+      "cvss_count": 50
+    },
+    {
+      "date": "2024-02-17",
+      "value": 66,
+      "avg_cvss": 5.7,
+      "cvss_count": 66
+    },
+    {
+      "date": "2024-02-18",
+      "value": 29,
+      "avg_cvss": 7.2,
+      "cvss_count": 29
+    },
+    {
+      "date": "2024-02-19",
+      "value": 35,
+      "avg_cvss": 6.7,
+      "cvss_count": 35
+    },
+    {
+      "date": "2024-02-20",
+      "value": 117,
+      "avg_cvss": 7.3,
+      "cvss_count": 117
+    },
+    {
+      "date": "2024-02-21",
+      "value": 138,
+      "avg_cvss": 6.9,
+      "cvss_count": 138
+    },
+    {
+      "date": "2024-02-22",
+      "value": 108,
+      "avg_cvss": 7.0,
+      "cvss_count": 108
+    },
+    {
+      "date": "2024-02-23",
+      "value": 86,
+      "avg_cvss": 6.5,
+      "cvss_count": 86
+    },
+    {
+      "date": "2024-02-24",
+      "value": 4,
+      "avg_cvss": 6.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2024-02-26",
+      "value": 105,
+      "avg_cvss": 6.7,
+      "cvss_count": 105
+    },
+    {
+      "date": "2024-02-27",
+      "value": 158,
+      "avg_cvss": 6.5,
+      "cvss_count": 158
+    },
+    {
+      "date": "2024-02-28",
+      "value": 184,
+      "avg_cvss": 6.4,
+      "cvss_count": 184
+    },
+    {
+      "date": "2024-02-29",
+      "value": 288,
+      "avg_cvss": 6.2,
+      "cvss_count": 288
+    },
+    {
+      "date": "2024-03-01",
+      "value": 126,
+      "avg_cvss": 6.5,
+      "cvss_count": 126
+    },
+    {
+      "date": "2024-03-02",
+      "value": 68,
+      "avg_cvss": 6.3,
+      "cvss_count": 68
+    },
+    {
+      "date": "2024-03-03",
+      "value": 29,
+      "avg_cvss": 6.1,
+      "cvss_count": 29
+    },
+    {
+      "date": "2024-03-04",
+      "value": 109,
+      "avg_cvss": 6.6,
+      "cvss_count": 109
+    },
+    {
+      "date": "2024-03-05",
+      "value": 112,
+      "avg_cvss": 6.5,
+      "cvss_count": 112
+    },
+    {
+      "date": "2024-03-06",
+      "value": 101,
+      "avg_cvss": 6.8,
+      "cvss_count": 101
+    },
+    {
+      "date": "2024-03-07",
+      "value": 91,
+      "avg_cvss": 6.9,
+      "cvss_count": 91
+    },
+    {
+      "date": "2024-03-08",
+      "value": 104,
+      "avg_cvss": 5.8,
+      "cvss_count": 104
+    },
+    {
+      "date": "2024-03-09",
+      "value": 26,
+      "avg_cvss": 6.7,
+      "cvss_count": 26
+    },
+    {
+      "date": "2024-03-10",
+      "value": 9,
+      "avg_cvss": 4.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2024-03-11",
+      "value": 113,
+      "avg_cvss": 6.8,
+      "cvss_count": 113
+    },
+    {
+      "date": "2024-03-12",
+      "value": 178,
+      "avg_cvss": 7.1,
+      "cvss_count": 178
+    },
+    {
+      "date": "2024-03-13",
+      "value": 220,
+      "avg_cvss": 6.4,
+      "cvss_count": 220
+    },
+    {
+      "date": "2024-03-14",
+      "value": 68,
+      "avg_cvss": 6.8,
+      "cvss_count": 68
+    },
+    {
+      "date": "2024-03-15",
+      "value": 127,
+      "avg_cvss": 6.7,
+      "cvss_count": 127
+    },
+    {
+      "date": "2024-03-16",
+      "value": 50,
+      "avg_cvss": 5.8,
+      "cvss_count": 50
+    },
+    {
+      "date": "2024-03-17",
+      "value": 29,
+      "avg_cvss": 6.1,
+      "cvss_count": 29
+    },
+    {
+      "date": "2024-03-18",
+      "value": 197,
+      "avg_cvss": 6.6,
+      "cvss_count": 197
+    },
+    {
+      "date": "2024-03-19",
+      "value": 130,
+      "avg_cvss": 6.8,
+      "cvss_count": 130
+    },
+    {
+      "date": "2024-03-20",
+      "value": 157,
+      "avg_cvss": 6.4,
+      "cvss_count": 157
+    },
+    {
+      "date": "2024-03-21",
+      "value": 162,
+      "avg_cvss": 7.2,
+      "cvss_count": 162
+    },
+    {
+      "date": "2024-03-22",
+      "value": 81,
+      "avg_cvss": 6.7,
+      "cvss_count": 81
+    },
+    {
+      "date": "2024-03-23",
+      "value": 18,
+      "avg_cvss": 6.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2024-03-24",
+      "value": 16,
+      "avg_cvss": 7.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2024-03-25",
+      "value": 117,
+      "avg_cvss": 6.7,
+      "cvss_count": 117
+    },
+    {
+      "date": "2024-03-26",
+      "value": 158,
+      "avg_cvss": 6.9,
+      "cvss_count": 158
+    },
+    {
+      "date": "2024-03-27",
+      "value": 285,
+      "avg_cvss": 6.8,
+      "cvss_count": 282
+    },
+    {
+      "date": "2024-03-28",
+      "value": 183,
+      "avg_cvss": 7.1,
+      "cvss_count": 183
+    },
+    {
+      "date": "2024-03-29",
+      "value": 156,
+      "avg_cvss": 6.8,
+      "cvss_count": 156
+    },
+    {
+      "date": "2024-03-30",
+      "value": 26,
+      "avg_cvss": 6.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2024-03-31",
+      "value": 63,
+      "avg_cvss": 6.5,
+      "cvss_count": 63
+    },
+    {
+      "date": "2024-04-01",
+      "value": 105,
+      "avg_cvss": 6.5,
+      "cvss_count": 105
+    },
+    {
+      "date": "2024-04-02",
+      "value": 172,
+      "avg_cvss": 6.2,
+      "cvss_count": 172
+    },
+    {
+      "date": "2024-04-03",
+      "value": 232,
+      "avg_cvss": 6.6,
+      "cvss_count": 232
+    },
+    {
+      "date": "2024-04-04",
+      "value": 139,
+      "avg_cvss": 6.7,
+      "cvss_count": 139
+    },
+    {
+      "date": "2024-04-05",
+      "value": 94,
+      "avg_cvss": 6.7,
+      "cvss_count": 94
+    },
+    {
+      "date": "2024-04-06",
+      "value": 39,
+      "avg_cvss": 6.2,
+      "cvss_count": 39
+    },
+    {
+      "date": "2024-04-07",
+      "value": 58,
+      "avg_cvss": 6.5,
+      "cvss_count": 58
+    },
+    {
+      "date": "2024-04-08",
+      "value": 123,
+      "avg_cvss": 6.7,
+      "cvss_count": 122
+    },
+    {
+      "date": "2024-04-09",
+      "value": 384,
+      "avg_cvss": 7.0,
+      "cvss_count": 384
+    },
+    {
+      "date": "2024-04-10",
+      "value": 219,
+      "avg_cvss": 6.6,
+      "cvss_count": 219
+    },
+    {
+      "date": "2024-04-11",
+      "value": 111,
+      "avg_cvss": 6.1,
+      "cvss_count": 111
+    },
+    {
+      "date": "2024-04-12",
+      "value": 128,
+      "avg_cvss": 6.2,
+      "cvss_count": 128
+    },
+    {
+      "date": "2024-04-13",
+      "value": 16,
+      "avg_cvss": 5.9,
+      "cvss_count": 16
+    },
+    {
+      "date": "2024-04-14",
+      "value": 4,
+      "avg_cvss": 4.3,
+      "cvss_count": 4
+    },
+    {
+      "date": "2024-04-15",
+      "value": 218,
+      "avg_cvss": 6.1,
+      "cvss_count": 218
+    },
+    {
+      "date": "2024-04-16",
+      "value": 242,
+      "avg_cvss": 6.5,
+      "cvss_count": 241
+    },
+    {
+      "date": "2024-04-17",
+      "value": 295,
+      "avg_cvss": 6.6,
+      "cvss_count": 295
+    },
+    {
+      "date": "2024-04-18",
+      "value": 124,
+      "avg_cvss": 6.5,
+      "cvss_count": 124
+    },
+    {
+      "date": "2024-04-19",
+      "value": 116,
+      "avg_cvss": 7.1,
+      "cvss_count": 116
+    },
+    {
+      "date": "2024-04-20",
+      "value": 5,
+      "avg_cvss": 6.7,
+      "cvss_count": 5
+    },
+    {
+      "date": "2024-04-21",
+      "value": 5,
+      "avg_cvss": 4.3,
+      "cvss_count": 5
+    },
+    {
+      "date": "2024-04-22",
+      "value": 78,
+      "avg_cvss": 6.9,
+      "cvss_count": 78
+    },
+    {
+      "date": "2024-04-23",
+      "value": 63,
+      "avg_cvss": 6.4,
+      "cvss_count": 63
+    },
+    {
+      "date": "2024-04-24",
+      "value": 124,
+      "avg_cvss": 6.6,
+      "cvss_count": 124
+    },
+    {
+      "date": "2024-04-25",
+      "value": 95,
+      "avg_cvss": 6.9,
+      "cvss_count": 95
+    },
+    {
+      "date": "2024-04-26",
+      "value": 138,
+      "avg_cvss": 6.6,
+      "cvss_count": 138
+    },
+    {
+      "date": "2024-04-27",
+      "value": 26,
+      "avg_cvss": 6.9,
+      "cvss_count": 26
+    },
+    {
+      "date": "2024-04-28",
+      "value": 44,
+      "avg_cvss": 6.3,
+      "cvss_count": 44
+    },
+    {
+      "date": "2024-04-29",
+      "value": 138,
+      "avg_cvss": 7.1,
+      "cvss_count": 138
+    },
+    {
+      "date": "2024-04-30",
+      "value": 86,
+      "avg_cvss": 7.2,
+      "cvss_count": 86
+    },
+    {
+      "date": "2024-05-01",
+      "value": 253,
+      "avg_cvss": 6.7,
+      "cvss_count": 253
+    },
+    {
+      "date": "2024-05-02",
+      "value": 235,
+      "avg_cvss": 6.3,
+      "cvss_count": 235
+    },
+    {
+      "date": "2024-05-03",
+      "value": 845,
+      "avg_cvss": 7.5,
+      "cvss_count": 845
+    },
+    {
+      "date": "2024-05-04",
+      "value": 14,
+      "avg_cvss": 6.4,
+      "cvss_count": 14
+    },
+    {
+      "date": "2024-05-05",
+      "value": 34,
+      "avg_cvss": 6.9,
+      "cvss_count": 34
+    },
+    {
+      "date": "2024-05-06",
+      "value": 156,
+      "avg_cvss": 6.5,
+      "cvss_count": 156
+    },
+    {
+      "date": "2024-05-07",
+      "value": 187,
+      "avg_cvss": 6.7,
+      "cvss_count": 187
+    },
+    {
+      "date": "2024-05-08",
+      "value": 106,
+      "avg_cvss": 6.7,
+      "cvss_count": 106
+    },
+    {
+      "date": "2024-05-14",
+      "value": 824,
+      "avg_cvss": 6.7,
+      "cvss_count": 824
+    },
+    {
+      "date": "2024-05-15",
+      "value": 135,
+      "avg_cvss": 6.6,
+      "cvss_count": 134
+    },
+    {
+      "date": "2024-05-16",
+      "value": 220,
+      "avg_cvss": 6.6,
+      "cvss_count": 217
+    },
+    {
+      "date": "2024-05-17",
+      "value": 319,
+      "avg_cvss": 6.9,
+      "cvss_count": 319
+    },
+    {
+      "date": "2024-05-18",
+      "value": 28,
+      "avg_cvss": 7.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2024-05-19",
+      "value": 100,
+      "avg_cvss": 6.9,
+      "cvss_count": 100
+    },
+    {
+      "date": "2024-05-20",
+      "value": 124,
+      "avg_cvss": 6.8,
+      "cvss_count": 124
+    },
+    {
+      "date": "2024-05-21",
+      "value": 436,
+      "avg_cvss": 6.6,
+      "cvss_count": 435
+    },
+    {
+      "date": "2024-05-22",
+      "value": 176,
+      "avg_cvss": 6.7,
+      "cvss_count": 176
+    },
+    {
+      "date": "2024-05-23",
+      "value": 118,
+      "avg_cvss": 7.1,
+      "cvss_count": 118
+    },
+    {
+      "date": "2024-05-24",
+      "value": 129,
+      "avg_cvss": 6.5,
+      "cvss_count": 129
+    },
+    {
+      "date": "2024-05-25",
+      "value": 12,
+      "avg_cvss": 5.7,
+      "cvss_count": 12
+    },
+    {
+      "date": "2024-05-26",
+      "value": 46,
+      "avg_cvss": 5.2,
+      "cvss_count": 46
+    },
+    {
+      "date": "2024-05-27",
+      "value": 55,
+      "avg_cvss": 6.4,
+      "cvss_count": 53
+    },
+    {
+      "date": "2024-05-28",
+      "value": 133,
+      "avg_cvss": 7.4,
+      "cvss_count": 130
+    },
+    {
+      "date": "2024-05-29",
+      "value": 61,
+      "avg_cvss": 6.4,
+      "cvss_count": 61
+    },
+    {
+      "date": "2024-05-30",
+      "value": 176,
+      "avg_cvss": 6.7,
+      "cvss_count": 176
+    },
+    {
+      "date": "2024-05-31",
+      "value": 77,
+      "avg_cvss": 7.3,
+      "cvss_count": 74
+    },
+    {
+      "date": "2024-06-01",
+      "value": 18,
+      "avg_cvss": 7.0,
+      "cvss_count": 18
+    },
+    {
+      "date": "2024-06-02",
+      "value": 13,
+      "avg_cvss": 7.2,
+      "cvss_count": 13
+    },
+    {
+      "date": "2024-06-03",
+      "value": 109,
+      "avg_cvss": 6.7,
+      "cvss_count": 107
+    },
+    {
+      "date": "2024-06-04",
+      "value": 182,
+      "avg_cvss": 6.6,
+      "cvss_count": 179
+    },
+    {
+      "date": "2024-06-05",
+      "value": 71,
+      "avg_cvss": 6.7,
+      "cvss_count": 71
+    },
+    {
+      "date": "2024-06-06",
+      "value": 179,
+      "avg_cvss": 7.2,
+      "cvss_count": 179
+    },
+    {
+      "date": "2024-06-07",
+      "value": 70,
+      "avg_cvss": 6.9,
+      "cvss_count": 70
+    },
+    {
+      "date": "2024-06-08",
+      "value": 78,
+      "avg_cvss": 6.4,
+      "cvss_count": 78
+    },
+    {
+      "date": "2024-06-09",
+      "value": 107,
+      "avg_cvss": 6.0,
+      "cvss_count": 107
+    },
+    {
+      "date": "2024-06-10",
+      "value": 145,
+      "avg_cvss": 6.8,
+      "cvss_count": 145
+    },
+    {
+      "date": "2024-06-11",
+      "value": 226,
+      "avg_cvss": 6.6,
+      "cvss_count": 224
+    },
+    {
+      "date": "2024-06-12",
+      "value": 112,
+      "avg_cvss": 6.3,
+      "cvss_count": 111
+    },
+    {
+      "date": "2024-06-13",
+      "value": 313,
+      "avg_cvss": 6.2,
+      "cvss_count": 309
+    },
+    {
+      "date": "2024-06-14",
+      "value": 163,
+      "avg_cvss": 6.7,
+      "cvss_count": 161
+    },
+    {
+      "date": "2024-06-15",
+      "value": 29,
+      "avg_cvss": 6.5,
+      "cvss_count": 29
+    },
+    {
+      "date": "2024-06-16",
+      "value": 26,
+      "avg_cvss": 7.8,
+      "cvss_count": 26
+    },
+    {
+      "date": "2024-06-17",
+      "value": 75,
+      "avg_cvss": 6.8,
+      "cvss_count": 75
+    },
+    {
+      "date": "2024-06-18",
+      "value": 61,
+      "avg_cvss": 6.4,
+      "cvss_count": 61
+    },
+    {
+      "date": "2024-06-19",
+      "value": 223,
+      "avg_cvss": 6.8,
+      "cvss_count": 223
+    },
+    {
+      "date": "2024-06-20",
+      "value": 163,
+      "avg_cvss": 6.6,
+      "cvss_count": 162
+    },
+    {
+      "date": "2024-06-21",
+      "value": 136,
+      "avg_cvss": 6.4,
+      "cvss_count": 136
+    },
+    {
+      "date": "2024-06-22",
+      "value": 23,
+      "avg_cvss": 6.0,
+      "cvss_count": 23
+    },
+    {
+      "date": "2024-06-23",
+      "value": 8,
+      "avg_cvss": 5.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2024-06-24",
+      "value": 97,
+      "avg_cvss": 7.2,
+      "cvss_count": 95
+    },
+    {
+      "date": "2024-06-25",
+      "value": 138,
+      "avg_cvss": 7.2,
+      "cvss_count": 137
+    },
+    {
+      "date": "2024-06-26",
+      "value": 76,
+      "avg_cvss": 6.0,
+      "cvss_count": 76
+    },
+    {
+      "date": "2024-06-27",
+      "value": 121,
+      "avg_cvss": 7.0,
+      "cvss_count": 120
+    },
+    {
+      "date": "2024-06-28",
+      "value": 79,
+      "avg_cvss": 6.4,
+      "cvss_count": 78
+    },
+    {
+      "date": "2024-06-29",
+      "value": 17,
+      "avg_cvss": 7.0,
+      "cvss_count": 17
+    },
+    {
+      "date": "2024-06-30",
+      "value": 20,
+      "avg_cvss": 5.7,
+      "cvss_count": 20
+    },
+    {
+      "date": "2024-07-01",
+      "value": 122,
+      "avg_cvss": 7.3,
+      "cvss_count": 122
+    },
+    {
+      "date": "2024-07-02",
+      "value": 135,
+      "avg_cvss": 6.4,
+      "cvss_count": 134
+    },
+    {
+      "date": "2024-07-03",
+      "value": 58,
+      "avg_cvss": 6.0,
+      "cvss_count": 58
+    },
+    {
+      "date": "2024-07-04",
+      "value": 38,
+      "avg_cvss": 7.3,
+      "cvss_count": 38
+    },
+    {
+      "date": "2024-07-05",
+      "value": 64,
+      "avg_cvss": 7.3,
+      "cvss_count": 64
+    },
+    {
+      "date": "2024-07-06",
+      "value": 14,
+      "avg_cvss": 5.7,
+      "cvss_count": 14
+    },
+    {
+      "date": "2024-07-07",
+      "value": 14,
+      "avg_cvss": 5.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2024-07-08",
+      "value": 62,
+      "avg_cvss": 6.6,
+      "cvss_count": 61
+    },
+    {
+      "date": "2024-07-09",
+      "value": 471,
+      "avg_cvss": 7.2,
+      "cvss_count": 464
+    },
+    {
+      "date": "2024-07-10",
+      "value": 123,
+      "avg_cvss": 6.8,
+      "cvss_count": 118
+    },
+    {
+      "date": "2024-07-11",
+      "value": 81,
+      "avg_cvss": 6.8,
+      "cvss_count": 80
+    },
+    {
+      "date": "2024-07-12",
+      "value": 200,
+      "avg_cvss": 7.0,
+      "cvss_count": 200
+    },
+    {
+      "date": "2024-07-13",
+      "value": 49,
+      "avg_cvss": 6.1,
+      "cvss_count": 49
+    },
+    {
+      "date": "2024-07-14",
+      "value": 10,
+      "avg_cvss": 6.0,
+      "cvss_count": 10
+    },
+    {
+      "date": "2024-07-15",
+      "value": 87,
+      "avg_cvss": 6.5,
+      "cvss_count": 78
+    },
+    {
+      "date": "2024-07-16",
+      "value": 253,
+      "avg_cvss": 6.6,
+      "cvss_count": 253
+    },
+    {
+      "date": "2024-07-17",
+      "value": 81,
+      "avg_cvss": 6.8,
+      "cvss_count": 80
+    },
+    {
+      "date": "2024-07-18",
+      "value": 51,
+      "avg_cvss": 7.0,
+      "cvss_count": 51
+    },
+    {
+      "date": "2024-07-19",
+      "value": 53,
+      "avg_cvss": 7.0,
+      "cvss_count": 50
+    },
+    {
+      "date": "2024-07-20",
+      "value": 83,
+      "avg_cvss": 6.4,
+      "cvss_count": 83
+    },
+    {
+      "date": "2024-07-21",
+      "value": 77,
+      "avg_cvss": 5.9,
+      "cvss_count": 77
+    },
+    {
+      "date": "2024-07-22",
+      "value": 134,
+      "avg_cvss": 7.0,
+      "cvss_count": 134
+    },
+    {
+      "date": "2024-07-23",
+      "value": 38,
+      "avg_cvss": 7.2,
+      "cvss_count": 38
+    },
+    {
+      "date": "2024-07-24",
+      "value": 85,
+      "avg_cvss": 6.9,
+      "cvss_count": 85
+    },
+    {
+      "date": "2024-07-25",
+      "value": 46,
+      "avg_cvss": 7.0,
+      "cvss_count": 46
+    },
+    {
+      "date": "2024-07-26",
+      "value": 71,
+      "avg_cvss": 7.1,
+      "cvss_count": 68
+    },
+    {
+      "date": "2024-07-27",
+      "value": 29,
+      "avg_cvss": 5.8,
+      "cvss_count": 29
+    },
+    {
+      "date": "2024-07-28",
+      "value": 26,
+      "avg_cvss": 6.0,
+      "cvss_count": 26
+    },
+    {
+      "date": "2024-07-29",
+      "value": 281,
+      "avg_cvss": 6.6,
+      "cvss_count": 280
+    },
+    {
+      "date": "2024-07-30",
+      "value": 169,
+      "avg_cvss": 6.4,
+      "cvss_count": 168
+    },
+    {
+      "date": "2024-07-31",
+      "value": 108,
+      "avg_cvss": 6.4,
+      "cvss_count": 107
+    },
+    {
+      "date": "2024-08-01",
+      "value": 129,
+      "avg_cvss": 6.4,
+      "cvss_count": 127
+    },
+    {
+      "date": "2024-08-02",
+      "value": 67,
+      "avg_cvss": 7.2,
+      "cvss_count": 66
+    },
+    {
+      "date": "2024-08-03",
+      "value": 21,
+      "avg_cvss": 6.3,
+      "cvss_count": 21
+    },
+    {
+      "date": "2024-08-04",
+      "value": 12,
+      "avg_cvss": 5.8,
+      "cvss_count": 12
+    },
+    {
+      "date": "2024-08-05",
+      "value": 93,
+      "avg_cvss": 7.3,
+      "cvss_count": 90
+    },
+    {
+      "date": "2024-08-06",
+      "value": 171,
+      "avg_cvss": 7.4,
+      "cvss_count": 170
+    },
+    {
+      "date": "2024-08-07",
+      "value": 115,
+      "avg_cvss": 6.6,
+      "cvss_count": 115
+    },
+    {
+      "date": "2024-08-08",
+      "value": 80,
+      "avg_cvss": 6.5,
+      "cvss_count": 80
+    },
+    {
+      "date": "2024-08-12",
+      "value": 255,
+      "avg_cvss": 6.9,
+      "cvss_count": 251
+    },
+    {
+      "date": "2024-08-13",
+      "value": 224,
+      "avg_cvss": 6.8,
+      "cvss_count": 217
+    },
+    {
+      "date": "2024-08-14",
+      "value": 201,
+      "avg_cvss": 6.6,
+      "cvss_count": 200
+    },
+    {
+      "date": "2024-08-15",
+      "value": 120,
+      "avg_cvss": 7.1,
+      "cvss_count": 119
+    },
+    {
+      "date": "2024-08-16",
+      "value": 62,
+      "avg_cvss": 6.8,
+      "cvss_count": 62
+    },
+    {
+      "date": "2024-08-17",
+      "value": 135,
+      "avg_cvss": 6.4,
+      "cvss_count": 135
+    },
+    {
+      "date": "2024-08-18",
+      "value": 66,
+      "avg_cvss": 6.5,
+      "cvss_count": 66
+    },
+    {
+      "date": "2024-08-19",
+      "value": 68,
+      "avg_cvss": 7.3,
+      "cvss_count": 68
+    },
+    {
+      "date": "2024-08-20",
+      "value": 140,
+      "avg_cvss": 7.7,
+      "cvss_count": 139
+    },
+    {
+      "date": "2024-08-21",
+      "value": 184,
+      "avg_cvss": 6.9,
+      "cvss_count": 182
+    },
+    {
+      "date": "2024-08-22",
+      "value": 128,
+      "avg_cvss": 6.4,
+      "cvss_count": 127
+    },
+    {
+      "date": "2024-08-23",
+      "value": 78,
+      "avg_cvss": 7.1,
+      "cvss_count": 76
+    },
+    {
+      "date": "2024-08-24",
+      "value": 28,
+      "avg_cvss": 6.5,
+      "cvss_count": 28
+    },
+    {
+      "date": "2024-08-25",
+      "value": 24,
+      "avg_cvss": 4.9,
+      "cvss_count": 24
+    },
+    {
+      "date": "2024-08-26",
+      "value": 140,
+      "avg_cvss": 6.5,
+      "cvss_count": 140
+    },
+    {
+      "date": "2024-08-27",
+      "value": 64,
+      "avg_cvss": 7.1,
+      "cvss_count": 64
+    },
+    {
+      "date": "2024-08-28",
+      "value": 73,
+      "avg_cvss": 7.0,
+      "cvss_count": 73
+    },
+    {
+      "date": "2024-08-29",
+      "value": 137,
+      "avg_cvss": 7.2,
+      "cvss_count": 137
+    },
+    {
+      "date": "2024-08-30",
+      "value": 60,
+      "avg_cvss": 6.6,
+      "cvss_count": 60
+    },
+    {
+      "date": "2024-08-31",
+      "value": 21,
+      "avg_cvss": 6.0,
+      "cvss_count": 21
+    },
+    {
+      "date": "2024-09-01",
+      "value": 6,
+      "avg_cvss": 5.8,
+      "cvss_count": 6
+    },
+    {
+      "date": "2024-09-02",
+      "value": 79,
+      "avg_cvss": 7.0,
+      "cvss_count": 79
+    },
+    {
+      "date": "2024-09-03",
+      "value": 69,
+      "avg_cvss": 7.1,
+      "cvss_count": 69
+    },
+    {
+      "date": "2024-09-04",
+      "value": 173,
+      "avg_cvss": 6.4,
+      "cvss_count": 173
+    },
+    {
+      "date": "2024-09-05",
+      "value": 66,
+      "avg_cvss": 7.3,
+      "cvss_count": 66
+    },
+    {
+      "date": "2024-09-06",
+      "value": 74,
+      "avg_cvss": 7.1,
+      "cvss_count": 74
+    },
+    {
+      "date": "2024-09-07",
+      "value": 50,
+      "avg_cvss": 6.8,
+      "cvss_count": 50
+    },
+    {
+      "date": "2024-09-08",
+      "value": 28,
+      "avg_cvss": 6.2,
+      "cvss_count": 28
+    },
+    {
+      "date": "2024-09-09",
+      "value": 56,
+      "avg_cvss": 6.7,
+      "cvss_count": 56
+    },
+    {
+      "date": "2024-09-10",
+      "value": 237,
+      "avg_cvss": 6.9,
+      "cvss_count": 237
+    },
+    {
+      "date": "2024-09-11",
+      "value": 110,
+      "avg_cvss": 7.0,
+      "cvss_count": 108
+    },
+    {
+      "date": "2024-09-12",
+      "value": 120,
+      "avg_cvss": 6.8,
+      "cvss_count": 120
+    },
+    {
+      "date": "2024-09-13",
+      "value": 152,
+      "avg_cvss": 6.7,
+      "cvss_count": 152
+    },
+    {
+      "date": "2024-09-14",
+      "value": 13,
+      "avg_cvss": 6.9,
+      "cvss_count": 13
+    },
+    {
+      "date": "2024-09-15",
+      "value": 27,
+      "avg_cvss": 6.1,
+      "cvss_count": 27
+    },
+    {
+      "date": "2024-09-16",
+      "value": 71,
+      "avg_cvss": 6.8,
+      "cvss_count": 71
+    },
+    {
+      "date": "2024-09-17",
+      "value": 180,
+      "avg_cvss": 6.4,
+      "cvss_count": 179
+    },
+    {
+      "date": "2024-09-18",
+      "value": 256,
+      "avg_cvss": 6.9,
+      "cvss_count": 254
+    },
+    {
+      "date": "2024-09-19",
+      "value": 51,
+      "avg_cvss": 7.0,
+      "cvss_count": 49
+    },
+    {
+      "date": "2024-09-20",
+      "value": 47,
+      "avg_cvss": 6.8,
+      "cvss_count": 47
+    },
+    {
+      "date": "2024-09-21",
+      "value": 8,
+      "avg_cvss": 5.6,
+      "cvss_count": 8
+    },
+    {
+      "date": "2024-09-22",
+      "value": 18,
+      "avg_cvss": 6.3,
+      "cvss_count": 18
+    },
+    {
+      "date": "2024-09-23",
+      "value": 63,
+      "avg_cvss": 6.9,
+      "cvss_count": 61
+    },
+    {
+      "date": "2024-09-24",
+      "value": 18,
+      "avg_cvss": 6.5,
+      "cvss_count": 18
+    },
+    {
+      "date": "2024-09-25",
+      "value": 157,
+      "avg_cvss": 7.1,
+      "cvss_count": 155
+    },
+    {
+      "date": "2024-09-26",
+      "value": 119,
+      "avg_cvss": 6.2,
+      "cvss_count": 117
+    },
+    {
+      "date": "2024-09-27",
+      "value": 162,
+      "avg_cvss": 6.7,
+      "cvss_count": 157
+    },
+    {
+      "date": "2024-09-28",
+      "value": 28,
+      "avg_cvss": 6.6,
+      "cvss_count": 28
+    },
+    {
+      "date": "2024-09-29",
+      "value": 10,
+      "avg_cvss": 5.9,
+      "cvss_count": 10
+    },
+    {
+      "date": "2024-09-30",
+      "value": 66,
+      "avg_cvss": 6.7,
+      "cvss_count": 65
+    },
+    {
+      "date": "2024-10-01",
+      "value": 110,
+      "avg_cvss": 7.0,
+      "cvss_count": 107
+    },
+    {
+      "date": "2024-10-02",
+      "value": 91,
+      "avg_cvss": 6.8,
+      "cvss_count": 89
+    },
+    {
+      "date": "2024-10-03",
+      "value": 56,
+      "avg_cvss": 7.1,
+      "cvss_count": 54
+    },
+    {
+      "date": "2024-10-04",
+      "value": 90,
+      "avg_cvss": 6.4,
+      "cvss_count": 87
+    },
+    {
+      "date": "2024-10-05",
+      "value": 83,
+      "avg_cvss": 6.8,
+      "cvss_count": 82
+    },
+    {
+      "date": "2024-10-06",
+      "value": 84,
+      "avg_cvss": 7.0,
+      "cvss_count": 84
+    },
+    {
+      "date": "2024-10-07",
+      "value": 109,
+      "avg_cvss": 7.0,
+      "cvss_count": 109
+    },
+    {
+      "date": "2024-10-08",
+      "value": 234,
+      "avg_cvss": 7.0,
+      "cvss_count": 230
+    },
+    {
+      "date": "2024-10-09",
+      "value": 122,
+      "avg_cvss": 6.9,
+      "cvss_count": 119
+    },
+    {
+      "date": "2024-10-10",
+      "value": 120,
+      "avg_cvss": 6.2,
+      "cvss_count": 118
+    },
+    {
+      "date": "2024-10-11",
+      "value": 132,
+      "avg_cvss": 7.1,
+      "cvss_count": 131
+    },
+    {
+      "date": "2024-10-12",
+      "value": 22,
+      "avg_cvss": 5.9,
+      "cvss_count": 22
+    },
+    {
+      "date": "2024-10-13",
+      "value": 18,
+      "avg_cvss": 7.2,
+      "cvss_count": 18
+    },
+    {
+      "date": "2024-10-14",
+      "value": 74,
+      "avg_cvss": 6.7,
+      "cvss_count": 73
+    },
+    {
+      "date": "2024-10-15",
+      "value": 189,
+      "avg_cvss": 6.7,
+      "cvss_count": 183
+    },
+    {
+      "date": "2024-10-16",
+      "value": 186,
+      "avg_cvss": 7.2,
+      "cvss_count": 178
+    },
+    {
+      "date": "2024-10-17",
+      "value": 156,
+      "avg_cvss": 6.9,
+      "cvss_count": 150
+    },
+    {
+      "date": "2024-10-18",
+      "value": 78,
+      "avg_cvss": 6.6,
+      "cvss_count": 77
+    },
+    {
+      "date": "2024-10-19",
+      "value": 23,
+      "avg_cvss": 5.9,
+      "cvss_count": 23
+    },
+    {
+      "date": "2024-10-20",
+      "value": 69,
+      "avg_cvss": 7.5,
+      "cvss_count": 69
+    },
+    {
+      "date": "2024-10-21",
+      "value": 431,
+      "avg_cvss": 6.6,
+      "cvss_count": 430
+    },
+    {
+      "date": "2024-10-22",
+      "value": 83,
+      "avg_cvss": 6.9,
+      "cvss_count": 80
+    },
+    {
+      "date": "2024-10-23",
+      "value": 120,
+      "avg_cvss": 6.5,
+      "cvss_count": 119
+    },
+    {
+      "date": "2024-10-24",
+      "value": 104,
+      "avg_cvss": 7.1,
+      "cvss_count": 103
+    },
+    {
+      "date": "2024-10-25",
+      "value": 136,
+      "avg_cvss": 6.8,
+      "cvss_count": 135
+    },
+    {
+      "date": "2024-10-26",
+      "value": 43,
+      "avg_cvss": 7.2,
+      "cvss_count": 39
+    },
+    {
+      "date": "2024-10-27",
+      "value": 33,
+      "avg_cvss": 6.1,
+      "cvss_count": 33
+    },
+    {
+      "date": "2024-10-28",
+      "value": 196,
+      "avg_cvss": 6.4,
+      "cvss_count": 196
+    },
+    {
+      "date": "2024-10-29",
+      "value": 207,
+      "avg_cvss": 7.1,
+      "cvss_count": 207
+    },
+    {
+      "date": "2024-10-30",
+      "value": 96,
+      "avg_cvss": 7.3,
+      "cvss_count": 96
+    },
+    {
+      "date": "2024-10-31",
+      "value": 69,
+      "avg_cvss": 7.3,
+      "cvss_count": 67
+    },
+    {
+      "date": "2024-11-01",
+      "value": 237,
+      "avg_cvss": 5.8,
+      "cvss_count": 235
+    },
+    {
+      "date": "2024-11-02",
+      "value": 12,
+      "avg_cvss": 6.4,
+      "cvss_count": 12
+    },
+    {
+      "date": "2024-11-03",
+      "value": 16,
+      "avg_cvss": 6.1,
+      "cvss_count": 16
+    },
+    {
+      "date": "2024-11-04",
+      "value": 141,
+      "avg_cvss": 6.9,
+      "cvss_count": 138
+    },
+    {
+      "date": "2024-11-05",
+      "value": 218,
+      "avg_cvss": 6.6,
+      "cvss_count": 212
+    },
+    {
+      "date": "2024-11-06",
+      "value": 94,
+      "avg_cvss": 5.7,
+      "cvss_count": 93
+    },
+    {
+      "date": "2024-11-07",
+      "value": 110,
+      "avg_cvss": 6.8,
+      "cvss_count": 107
+    },
+    {
+      "date": "2024-11-08",
+      "value": 125,
+      "avg_cvss": 6.9,
+      "cvss_count": 123
+    },
+    {
+      "date": "2024-11-09",
+      "value": 195,
+      "avg_cvss": 6.8,
+      "cvss_count": 195
+    },
+    {
+      "date": "2024-11-10",
+      "value": 32,
+      "avg_cvss": 6.8,
+      "cvss_count": 32
+    },
+    {
+      "date": "2024-11-11",
+      "value": 116,
+      "avg_cvss": 7.1,
+      "cvss_count": 108
+    },
+    {
+      "date": "2024-11-12",
+      "value": 333,
+      "avg_cvss": 7.0,
+      "cvss_count": 327
+    },
+    {
+      "date": "2024-11-13",
+      "value": 230,
+      "avg_cvss": 6.7,
+      "cvss_count": 225
+    },
+    {
+      "date": "2024-11-14",
+      "value": 147,
+      "avg_cvss": 7.1,
+      "cvss_count": 139
+    },
+    {
+      "date": "2024-11-15",
+      "value": 222,
+      "avg_cvss": 6.2,
+      "cvss_count": 220
+    },
+    {
+      "date": "2024-11-16",
+      "value": 50,
+      "avg_cvss": 7.5,
+      "cvss_count": 50
+    },
+    {
+      "date": "2024-11-17",
+      "value": 11,
+      "avg_cvss": 7.1,
+      "cvss_count": 11
+    },
+    {
+      "date": "2024-11-18",
+      "value": 184,
+      "avg_cvss": 6.9,
+      "cvss_count": 181
+    },
+    {
+      "date": "2024-11-19",
+      "value": 383,
+      "avg_cvss": 6.7,
+      "cvss_count": 383
+    },
+    {
+      "date": "2024-11-20",
+      "value": 124,
+      "avg_cvss": 7.0,
+      "cvss_count": 120
+    },
+    {
+      "date": "2024-11-21",
+      "value": 133,
+      "avg_cvss": 6.4,
+      "cvss_count": 130
+    },
+    {
+      "date": "2024-11-22",
+      "value": 385,
+      "avg_cvss": 7.3,
+      "cvss_count": 383
+    },
+    {
+      "date": "2024-11-23",
+      "value": 47,
+      "avg_cvss": 6.6,
+      "cvss_count": 47
+    },
+    {
+      "date": "2024-11-24",
+      "value": 14,
+      "avg_cvss": 8.5,
+      "cvss_count": 14
+    },
+    {
+      "date": "2024-11-25",
+      "value": 71,
+      "avg_cvss": 6.0,
+      "cvss_count": 69
+    },
+    {
+      "date": "2024-11-26",
+      "value": 161,
+      "avg_cvss": 7.0,
+      "cvss_count": 160
+    },
+    {
+      "date": "2024-11-27",
+      "value": 67,
+      "avg_cvss": 6.5,
+      "cvss_count": 64
+    },
+    {
+      "date": "2024-11-28",
+      "value": 93,
+      "avg_cvss": 7.1,
+      "cvss_count": 92
+    },
+    {
+      "date": "2024-11-29",
+      "value": 76,
+      "avg_cvss": 7.4,
+      "cvss_count": 70
+    },
+    {
+      "date": "2024-11-30",
+      "value": 29,
+      "avg_cvss": 6.1,
+      "cvss_count": 29
+    },
+    {
+      "date": "2024-12-01",
+      "value": 12,
+      "avg_cvss": 6.7,
+      "cvss_count": 12
+    },
+    {
+      "date": "2024-12-02",
+      "value": 194,
+      "avg_cvss": 7.0,
+      "cvss_count": 187
+    },
+    {
+      "date": "2024-12-03",
+      "value": 83,
+      "avg_cvss": 6.3,
+      "cvss_count": 82
+    },
+    {
+      "date": "2024-12-04",
+      "value": 117,
+      "avg_cvss": 6.6,
+      "cvss_count": 108
+    },
+    {
+      "date": "2024-12-05",
+      "value": 124,
+      "avg_cvss": 7.3,
+      "cvss_count": 115
+    },
+    {
+      "date": "2024-12-06",
+      "value": 171,
+      "avg_cvss": 7.3,
+      "cvss_count": 168
+    },
+    {
+      "date": "2024-12-07",
+      "value": 32,
+      "avg_cvss": 6.2,
+      "cvss_count": 32
+    },
+    {
+      "date": "2024-12-08",
+      "value": 5,
+      "avg_cvss": 7.8,
+      "cvss_count": 5
+    },
+    {
+      "date": "2024-12-09",
+      "value": 281,
+      "avg_cvss": 5.8,
+      "cvss_count": 278
+    },
+    {
+      "date": "2024-12-10",
+      "value": 271,
+      "avg_cvss": 6.5,
+      "cvss_count": 267
+    },
+    {
+      "date": "2024-12-11",
+      "value": 35,
+      "avg_cvss": 6.6,
+      "cvss_count": 34
+    },
+    {
+      "date": "2024-12-12",
+      "value": 340,
+      "avg_cvss": 6.9,
+      "cvss_count": 338
+    },
+    {
+      "date": "2024-12-13",
+      "value": 296,
+      "avg_cvss": 6.3,
+      "cvss_count": 294
+    },
+    {
+      "date": "2024-12-14",
+      "value": 49,
+      "avg_cvss": 6.3,
+      "cvss_count": 49
+    },
+    {
+      "date": "2024-12-15",
+      "value": 8,
+      "avg_cvss": 7.1,
+      "cvss_count": 8
+    },
+    {
+      "date": "2024-12-16",
+      "value": 204,
+      "avg_cvss": 7.0,
+      "cvss_count": 202
+    },
+    {
+      "date": "2024-12-17",
+      "value": 88,
+      "avg_cvss": 6.8,
+      "cvss_count": 87
+    },
+    {
+      "date": "2024-12-18",
+      "value": 138,
+      "avg_cvss": 7.2,
+      "cvss_count": 135
+    },
+    {
+      "date": "2024-12-19",
+      "value": 106,
+      "avg_cvss": 6.9,
+      "cvss_count": 98
+    },
+    {
+      "date": "2024-12-20",
+      "value": 85,
+      "avg_cvss": 6.3,
+      "cvss_count": 78
+    },
+    {
+      "date": "2024-12-21",
+      "value": 32,
+      "avg_cvss": 6.3,
+      "cvss_count": 32
+    },
+    {
+      "date": "2024-12-22",
+      "value": 14,
+      "avg_cvss": 5.9,
+      "cvss_count": 14
+    },
+    {
+      "date": "2024-12-23",
+      "value": 30,
+      "avg_cvss": 7.0,
+      "cvss_count": 28
+    },
+    {
+      "date": "2024-12-24",
+      "value": 60,
+      "avg_cvss": 6.5,
+      "cvss_count": 54
+    },
+    {
+      "date": "2024-12-25",
+      "value": 27,
+      "avg_cvss": 6.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2024-12-26",
+      "value": 67,
+      "avg_cvss": 6.2,
+      "cvss_count": 65
+    },
+    {
+      "date": "2024-12-27",
+      "value": 283,
+      "avg_cvss": 6.6,
+      "cvss_count": 283
+    },
+    {
+      "date": "2024-12-28",
+      "value": 50,
+      "avg_cvss": 6.2,
+      "cvss_count": 50
+    },
+    {
+      "date": "2024-12-29",
+      "value": 68,
+      "avg_cvss": 5.8,
+      "cvss_count": 68
+    },
+    {
+      "date": "2024-12-30",
+      "value": 58,
+      "avg_cvss": 6.9,
+      "cvss_count": 54
+    },
+    {
+      "date": "2024-12-31",
+      "value": 103,
+      "avg_cvss": 6.9,
+      "cvss_count": 100
+    },
+    {
+      "date": "2025-01-01",
+      "value": 4,
+      "avg_cvss": 6.4,
+      "cvss_count": 4
+    },
+    {
+      "date": "2025-01-02",
+      "value": 232,
+      "avg_cvss": 5.5,
+      "cvss_count": 229
+    },
+    {
+      "date": "2025-01-03",
+      "value": 60,
+      "avg_cvss": 6.8,
+      "cvss_count": 58
+    },
+    {
+      "date": "2025-01-04",
+      "value": 39,
+      "avg_cvss": 6.6,
+      "cvss_count": 39
+    },
+    {
+      "date": "2025-01-05",
+      "value": 27,
+      "avg_cvss": 4.7,
+      "cvss_count": 27
+    },
+    {
+      "date": "2025-01-06",
+      "value": 107,
+      "avg_cvss": 6.8,
+      "cvss_count": 105
+    },
+    {
+      "date": "2025-01-07",
+      "value": 347,
+      "avg_cvss": 6.5,
+      "cvss_count": 347
+    },
+    {
+      "date": "2025-01-08",
+      "value": 127,
+      "avg_cvss": 6.5,
+      "cvss_count": 124
+    },
+    {
+      "date": "2025-01-09",
+      "value": 269,
+      "avg_cvss": 6.6,
+      "cvss_count": 263
+    },
+    {
+      "date": "2025-01-10",
+      "value": 72,
+      "avg_cvss": 7.1,
+      "cvss_count": 70
+    },
+    {
+      "date": "2025-01-11",
+      "value": 105,
+      "avg_cvss": 6.4,
+      "cvss_count": 105
+    },
+    {
+      "date": "2025-01-12",
+      "value": 11,
+      "avg_cvss": 3.9,
+      "cvss_count": 11
+    },
+    {
+      "date": "2025-01-13",
+      "value": 105,
+      "avg_cvss": 6.4,
+      "cvss_count": 103
+    },
+    {
+      "date": "2025-01-14",
+      "value": 478,
+      "avg_cvss": 7.3,
+      "cvss_count": 477
+    },
+    {
+      "date": "2025-01-15",
+      "value": 213,
+      "avg_cvss": 6.9,
+      "cvss_count": 209
+    },
+    {
+      "date": "2025-01-16",
+      "value": 300,
+      "avg_cvss": 6.8,
+      "cvss_count": 300
+    },
+    {
+      "date": "2025-01-17",
+      "value": 86,
+      "avg_cvss": 6.4,
+      "cvss_count": 79
+    },
+    {
+      "date": "2025-01-18",
+      "value": 43,
+      "avg_cvss": 6.1,
+      "cvss_count": 43
+    },
+    {
+      "date": "2025-01-19",
+      "value": 63,
+      "avg_cvss": 6.4,
+      "cvss_count": 63
+    },
+    {
+      "date": "2025-01-20",
+      "value": 34,
+      "avg_cvss": 6.3,
+      "cvss_count": 32
+    },
+    {
+      "date": "2025-01-21",
+      "value": 281,
+      "avg_cvss": 6.7,
+      "cvss_count": 280
+    },
+    {
+      "date": "2025-01-22",
+      "value": 173,
+      "avg_cvss": 7.0,
+      "cvss_count": 171
+    },
+    {
+      "date": "2025-01-23",
+      "value": 111,
+      "avg_cvss": 6.8,
+      "cvss_count": 110
+    },
+    {
+      "date": "2025-01-24",
+      "value": 198,
+      "avg_cvss": 6.3,
+      "cvss_count": 197
+    },
+    {
+      "date": "2025-01-25",
+      "value": 50,
+      "avg_cvss": 6.0,
+      "cvss_count": 50
+    },
+    {
+      "date": "2025-01-26",
+      "value": 19,
+      "avg_cvss": 6.4,
+      "cvss_count": 18
+    },
+    {
+      "date": "2025-01-27",
+      "value": 242,
+      "avg_cvss": 6.4,
+      "cvss_count": 240
+    },
+    {
+      "date": "2025-01-28",
+      "value": 101,
+      "avg_cvss": 6.7,
+      "cvss_count": 93
+    },
+    {
+      "date": "2025-01-29",
+      "value": 72,
+      "avg_cvss": 6.6,
+      "cvss_count": 71
+    },
+    {
+      "date": "2025-01-30",
+      "value": 143,
+      "avg_cvss": 6.5,
+      "cvss_count": 132
+    },
+    {
+      "date": "2025-01-31",
+      "value": 163,
+      "avg_cvss": 6.7,
+      "cvss_count": 161
+    },
+    {
+      "date": "2025-02-01",
+      "value": 39,
+      "avg_cvss": 5.9,
+      "cvss_count": 39
+    },
+    {
+      "date": "2025-02-02",
+      "value": 3,
+      "avg_cvss": 5.0,
+      "cvss_count": 3
+    },
+    {
+      "date": "2025-02-03",
+      "value": 185,
+      "avg_cvss": 6.9,
+      "cvss_count": 179
+    },
+    {
+      "date": "2025-02-04",
+      "value": 143,
+      "avg_cvss": 6.5,
+      "cvss_count": 140
+    },
+    {
+      "date": "2025-02-05",
+      "value": 114,
+      "avg_cvss": 6.8,
+      "cvss_count": 113
+    },
+    {
+      "date": "2025-02-06",
+      "value": 105,
+      "avg_cvss": 6.7,
+      "cvss_count": 103
+    },
+    {
+      "date": "2025-02-07",
+      "value": 120,
+      "avg_cvss": 6.7,
+      "cvss_count": 117
+    },
+    {
+      "date": "2025-02-08",
+      "value": 7,
+      "avg_cvss": 6.3,
+      "cvss_count": 7
+    },
+    {
+      "date": "2025-02-09",
+      "value": 4,
+      "avg_cvss": 6.0,
+      "cvss_count": 4
+    },
+    {
+      "date": "2025-02-10",
+      "value": 72,
+      "avg_cvss": 6.3,
+      "cvss_count": 66
+    },
+    {
+      "date": "2025-02-11",
+      "value": 280,
+      "avg_cvss": 6.8,
+      "cvss_count": 279
+    },
+    {
+      "date": "2025-02-12",
+      "value": 266,
+      "avg_cvss": 6.7,
+      "cvss_count": 262
+    },
+    {
+      "date": "2025-02-13",
+      "value": 132,
+      "avg_cvss": 6.8,
+      "cvss_count": 132
+    },
+    {
+      "date": "2025-02-14",
+      "value": 127,
+      "avg_cvss": 6.9,
+      "cvss_count": 119
+    },
+    {
+      "date": "2025-02-15",
+      "value": 28,
+      "avg_cvss": 6.6,
+      "cvss_count": 27
+    },
+    {
+      "date": "2025-02-16",
+      "value": 38,
+      "avg_cvss": 6.0,
+      "cvss_count": 37
+    },
+    {
+      "date": "2025-02-17",
+      "value": 47,
+      "avg_cvss": 5.8,
+      "cvss_count": 47
+    },
+    {
+      "date": "2025-02-18",
+      "value": 164,
+      "avg_cvss": 6.9,
+      "cvss_count": 155
+    },
+    {
+      "date": "2025-02-19",
+      "value": 119,
+      "avg_cvss": 6.7,
+      "cvss_count": 116
+    },
+    {
+      "date": "2025-02-20",
+      "value": 123,
+      "avg_cvss": 6.9,
+      "cvss_count": 118
+    },
+    {
+      "date": "2025-02-21",
+      "value": 80,
+      "avg_cvss": 6.4,
+      "cvss_count": 79
+    },
+    {
+      "date": "2025-02-22",
+      "value": 35,
+      "avg_cvss": 6.7,
+      "cvss_count": 35
+    },
+    {
+      "date": "2025-02-23",
+      "value": 29,
+      "avg_cvss": 5.2,
+      "cvss_count": 29
+    },
+    {
+      "date": "2025-02-24",
+      "value": 119,
+      "avg_cvss": 6.2,
+      "cvss_count": 117
+    },
+    {
+      "date": "2025-02-25",
+      "value": 142,
+      "avg_cvss": 6.4,
+      "cvss_count": 141
+    },
+    {
+      "date": "2025-02-26",
+      "value": 792,
+      "avg_cvss": 6.2,
+      "cvss_count": 792
+    },
+    {
+      "date": "2025-02-27",
+      "value": 267,
+      "avg_cvss": 6.7,
+      "cvss_count": 266
+    },
+    {
+      "date": "2025-02-28",
+      "value": 93,
+      "avg_cvss": 6.6,
+      "cvss_count": 84
+    },
+    {
+      "date": "2025-03-01",
+      "value": 45,
+      "avg_cvss": 6.8,
+      "cvss_count": 44
+    },
+    {
+      "date": "2025-03-02",
+      "value": 29,
+      "avg_cvss": 5.5,
+      "cvss_count": 29
+    },
+    {
+      "date": "2025-03-03",
+      "value": 346,
+      "avg_cvss": 7.0,
+      "cvss_count": 342
+    },
+    {
+      "date": "2025-03-04",
+      "value": 147,
+      "avg_cvss": 6.0,
+      "cvss_count": 143
+    },
+    {
+      "date": "2025-03-05",
+      "value": 143,
+      "avg_cvss": 7.6,
+      "cvss_count": 139
+    },
+    {
+      "date": "2025-03-06",
+      "value": 140,
+      "avg_cvss": 6.1,
+      "cvss_count": 133
+    },
+    {
+      "date": "2025-03-07",
+      "value": 113,
+      "avg_cvss": 6.6,
+      "cvss_count": 106
+    },
+    {
+      "date": "2025-03-08",
+      "value": 40,
+      "avg_cvss": 6.1,
+      "cvss_count": 40
+    },
+    {
+      "date": "2025-03-09",
+      "value": 23,
+      "avg_cvss": 4.6,
+      "cvss_count": 23
+    },
+    {
+      "date": "2025-03-10",
+      "value": 83,
+      "avg_cvss": 6.6,
+      "cvss_count": 82
+    },
+    {
+      "date": "2025-03-11",
+      "value": 331,
+      "avg_cvss": 6.5,
+      "cvss_count": 321
+    },
+    {
+      "date": "2025-03-12",
+      "value": 103,
+      "avg_cvss": 6.6,
+      "cvss_count": 97
+    },
+    {
+      "date": "2025-03-13",
+      "value": 90,
+      "avg_cvss": 6.7,
+      "cvss_count": 81
+    },
+    {
+      "date": "2025-03-14",
+      "value": 86,
+      "avg_cvss": 7.2,
+      "cvss_count": 73
+    },
+    {
+      "date": "2025-03-15",
+      "value": 44,
+      "avg_cvss": 6.9,
+      "cvss_count": 44
+    },
+    {
+      "date": "2025-03-16",
+      "value": 31,
+      "avg_cvss": 5.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2025-03-17",
+      "value": 131,
+      "avg_cvss": 6.6,
+      "cvss_count": 121
+    },
+    {
+      "date": "2025-03-18",
+      "value": 72,
+      "avg_cvss": 7.5,
+      "cvss_count": 70
+    },
+    {
+      "date": "2025-03-19",
+      "value": 83,
+      "avg_cvss": 7.1,
+      "cvss_count": 81
+    },
+    {
+      "date": "2025-03-20",
+      "value": 365,
+      "avg_cvss": 7.3,
+      "cvss_count": 363
+    },
+    {
+      "date": "2025-03-21",
+      "value": 70,
+      "avg_cvss": 6.1,
+      "cvss_count": 70
+    },
+    {
+      "date": "2025-03-22",
+      "value": 38,
+      "avg_cvss": 6.2,
+      "cvss_count": 38
+    },
+    {
+      "date": "2025-03-23",
+      "value": 39,
+      "avg_cvss": 6.5,
+      "cvss_count": 39
+    },
+    {
+      "date": "2025-03-24",
+      "value": 151,
+      "avg_cvss": 6.2,
+      "cvss_count": 149
+    },
+    {
+      "date": "2025-03-25",
+      "value": 140,
+      "avg_cvss": 6.7,
+      "cvss_count": 125
+    },
+    {
+      "date": "2025-03-26",
+      "value": 171,
+      "avg_cvss": 6.9,
+      "cvss_count": 169
+    },
+    {
+      "date": "2025-03-27",
+      "value": 375,
+      "avg_cvss": 6.3,
+      "cvss_count": 372
+    },
+    {
+      "date": "2025-03-28",
+      "value": 171,
+      "avg_cvss": 6.7,
+      "cvss_count": 161
+    },
+    {
+      "date": "2025-03-29",
+      "value": 12,
+      "avg_cvss": 6.1,
+      "cvss_count": 12
+    },
+    {
+      "date": "2025-03-30",
+      "value": 16,
+      "avg_cvss": 6.2,
+      "cvss_count": 16
+    },
+    {
+      "date": "2025-03-31",
+      "value": 370,
+      "avg_cvss": 6.7,
+      "cvss_count": 359
+    },
+    {
+      "date": "2025-04-01",
+      "value": 430,
+      "avg_cvss": 6.5,
+      "cvss_count": 425
+    },
+    {
+      "date": "2025-04-02",
+      "value": 109,
+      "avg_cvss": 6.4,
+      "cvss_count": 104
+    },
+    {
+      "date": "2025-04-03",
+      "value": 175,
+      "avg_cvss": 6.7,
+      "cvss_count": 172
+    },
+    {
+      "date": "2025-04-04",
+      "value": 232,
+      "avg_cvss": 6.3,
+      "cvss_count": 230
+    },
+    {
+      "date": "2025-04-05",
+      "value": 33,
+      "avg_cvss": 5.9,
+      "cvss_count": 33
+    },
+    {
+      "date": "2025-04-06",
+      "value": 28,
+      "avg_cvss": 6.5,
+      "cvss_count": 26
+    },
+    {
+      "date": "2025-04-07",
+      "value": 169,
+      "avg_cvss": 6.8,
+      "cvss_count": 163
+    },
+    {
+      "date": "2025-04-08",
+      "value": 348,
+      "avg_cvss": 6.8,
+      "cvss_count": 344
+    },
+    {
+      "date": "2025-04-09",
+      "value": 194,
+      "avg_cvss": 6.7,
+      "cvss_count": 192
+    },
+    {
+      "date": "2025-04-10",
+      "value": 107,
+      "avg_cvss": 6.5,
+      "cvss_count": 97
+    },
+    {
+      "date": "2025-04-11",
+      "value": 127,
+      "avg_cvss": 7.2,
+      "cvss_count": 111
+    },
+    {
+      "date": "2025-04-12",
+      "value": 15,
+      "avg_cvss": 6.0,
+      "cvss_count": 15
+    },
+    {
+      "date": "2025-04-13",
+      "value": 15,
+      "avg_cvss": 6.3,
+      "cvss_count": 15
+    },
+    {
+      "date": "2025-04-14",
+      "value": 83,
+      "avg_cvss": 5.9,
+      "cvss_count": 79
+    },
+    {
+      "date": "2025-04-15",
+      "value": 264,
+      "avg_cvss": 6.3,
+      "cvss_count": 253
+    },
+    {
+      "date": "2025-04-16",
+      "value": 375,
+      "avg_cvss": 6.9,
+      "cvss_count": 371
+    },
+    {
+      "date": "2025-04-17",
+      "value": 314,
+      "avg_cvss": 7.1,
+      "cvss_count": 306
+    },
+    {
+      "date": "2025-04-18",
+      "value": 99,
+      "avg_cvss": 6.9,
+      "cvss_count": 97
+    },
+    {
+      "date": "2025-04-19",
+      "value": 36,
+      "avg_cvss": 6.3,
+      "cvss_count": 36
+    },
+    {
+      "date": "2025-04-20",
+      "value": 19,
+      "avg_cvss": 4.6,
+      "cvss_count": 19
+    },
+    {
+      "date": "2025-04-21",
+      "value": 49,
+      "avg_cvss": 6.2,
+      "cvss_count": 40
+    },
+    {
+      "date": "2025-04-22",
+      "value": 115,
+      "avg_cvss": 6.9,
+      "cvss_count": 112
+    },
+    {
+      "date": "2025-04-23",
+      "value": 75,
+      "avg_cvss": 6.9,
+      "cvss_count": 69
+    },
+    {
+      "date": "2025-04-24",
+      "value": 171,
+      "avg_cvss": 6.6,
+      "cvss_count": 169
+    },
+    {
+      "date": "2025-04-25",
+      "value": 80,
+      "avg_cvss": 6.4,
+      "cvss_count": 77
+    },
+    {
+      "date": "2025-04-26",
+      "value": 22,
+      "avg_cvss": 6.3,
+      "cvss_count": 22
+    },
+    {
+      "date": "2025-04-27",
+      "value": 56,
+      "avg_cvss": 5.5,
+      "cvss_count": 56
+    },
+    {
+      "date": "2025-04-28",
+      "value": 92,
+      "avg_cvss": 6.1,
+      "cvss_count": 91
+    },
+    {
+      "date": "2025-04-29",
+      "value": 92,
+      "avg_cvss": 6.6,
+      "cvss_count": 86
+    },
+    {
+      "date": "2025-04-30",
+      "value": 110,
+      "avg_cvss": 6.8,
+      "cvss_count": 108
+    },
+    {
+      "date": "2025-05-01",
+      "value": 370,
+      "avg_cvss": 6.4,
+      "cvss_count": 368
+    },
+    {
+      "date": "2025-05-02",
+      "value": 178,
+      "avg_cvss": 6.6,
+      "cvss_count": 177
+    },
+    {
+      "date": "2025-05-03",
+      "value": 30,
+      "avg_cvss": 6.6,
+      "cvss_count": 30
+    },
+    {
+      "date": "2025-05-04",
+      "value": 8,
+      "avg_cvss": 7.2,
+      "cvss_count": 8
+    },
+    {
+      "date": "2025-05-05",
+      "value": 127,
+      "avg_cvss": 7.2,
+      "cvss_count": 125
+    },
+    {
+      "date": "2025-05-06",
+      "value": 167,
+      "avg_cvss": 7.0,
+      "cvss_count": 158
+    },
+    {
+      "date": "2025-05-07",
+      "value": 304,
+      "avg_cvss": 6.2,
+      "cvss_count": 300
+    },
+    {
+      "date": "2025-05-08",
+      "value": 111,
+      "avg_cvss": 7.1,
+      "cvss_count": 105
+    },
+    {
+      "date": "2025-05-09",
+      "value": 154,
+      "avg_cvss": 7.0,
+      "cvss_count": 148
+    },
+    {
+      "date": "2025-05-10",
+      "value": 33,
+      "avg_cvss": 6.4,
+      "cvss_count": 33
+    },
+    {
+      "date": "2025-05-11",
+      "value": 27,
+      "avg_cvss": 5.3,
+      "cvss_count": 27
+    },
+    {
+      "date": "2025-05-12",
+      "value": 125,
+      "avg_cvss": 6.8,
+      "cvss_count": 120
+    },
+    {
+      "date": "2025-05-13",
+      "value": 313,
+      "avg_cvss": 7.0,
+      "cvss_count": 310
+    },
+    {
+      "date": "2025-05-14",
+      "value": 105,
+      "avg_cvss": 6.8,
+      "cvss_count": 88
+    },
+    {
+      "date": "2025-05-15",
+      "value": 304,
+      "avg_cvss": 5.8,
+      "cvss_count": 297
+    },
+    {
+      "date": "2025-05-16",
+      "value": 174,
+      "avg_cvss": 6.4,
+      "cvss_count": 170
+    },
+    {
+      "date": "2025-05-17",
+      "value": 46,
+      "avg_cvss": 7.6,
+      "cvss_count": 46
+    },
+    {
+      "date": "2025-05-18",
+      "value": 51,
+      "avg_cvss": 6.3,
+      "cvss_count": 51
+    },
+    {
+      "date": "2025-05-19",
+      "value": 242,
+      "avg_cvss": 6.9,
+      "cvss_count": 240
+    },
+    {
+      "date": "2025-05-20",
+      "value": 174,
+      "avg_cvss": 7.0,
+      "cvss_count": 169
+    },
+    {
+      "date": "2025-05-21",
+      "value": 115,
+      "avg_cvss": 6.6,
+      "cvss_count": 103
+    },
+    {
+      "date": "2025-05-22",
+      "value": 135,
+      "avg_cvss": 7.0,
+      "cvss_count": 132
+    },
+    {
+      "date": "2025-05-23",
+      "value": 184,
+      "avg_cvss": 7.8,
+      "cvss_count": 170
+    },
+    {
+      "date": "2025-05-24",
+      "value": 25,
+      "avg_cvss": 5.2,
+      "cvss_count": 25
+    },
+    {
+      "date": "2025-05-25",
+      "value": 19,
+      "avg_cvss": 5.3,
+      "cvss_count": 19
+    },
+    {
+      "date": "2025-05-26",
+      "value": 68,
+      "avg_cvss": 5.6,
+      "cvss_count": 61
+    },
+    {
+      "date": "2025-05-27",
+      "value": 98,
+      "avg_cvss": 6.8,
+      "cvss_count": 92
+    },
+    {
+      "date": "2025-05-28",
+      "value": 67,
+      "avg_cvss": 6.1,
+      "cvss_count": 63
+    },
+    {
+      "date": "2025-05-29",
+      "value": 75,
+      "avg_cvss": 6.5,
+      "cvss_count": 69
+    },
+    {
+      "date": "2025-05-30",
+      "value": 114,
+      "avg_cvss": 6.9,
+      "cvss_count": 106
+    },
+    {
+      "date": "2025-05-31",
+      "value": 37,
+      "avg_cvss": 6.4,
+      "cvss_count": 37
+    },
+    {
+      "date": "2025-06-01",
+      "value": 18,
+      "avg_cvss": 6.0,
+      "cvss_count": 18
+    },
+    {
+      "date": "2025-06-02",
+      "value": 116,
+      "avg_cvss": 6.7,
+      "cvss_count": 107
+    },
+    {
+      "date": "2025-06-03",
+      "value": 119,
+      "avg_cvss": 6.7,
+      "cvss_count": 117
+    },
+    {
+      "date": "2025-06-04",
+      "value": 134,
+      "avg_cvss": 6.6,
+      "cvss_count": 129
+    },
+    {
+      "date": "2025-06-05",
+      "value": 95,
+      "avg_cvss": 6.3,
+      "cvss_count": 93
+    },
+    {
+      "date": "2025-06-06",
+      "value": 343,
+      "avg_cvss": 6.3,
+      "cvss_count": 329
+    },
+    {
+      "date": "2025-06-07",
+      "value": 15,
+      "avg_cvss": 7.0,
+      "cvss_count": 14
+    },
+    {
+      "date": "2025-06-08",
+      "value": 32,
+      "avg_cvss": 6.5,
+      "cvss_count": 32
+    },
+    {
+      "date": "2025-06-09",
+      "value": 178,
+      "avg_cvss": 7.3,
+      "cvss_count": 176
+    },
+    {
+      "date": "2025-06-10",
+      "value": 485,
+      "avg_cvss": 6.2,
+      "cvss_count": 478
+    },
+    {
+      "date": "2025-06-11",
+      "value": 63,
+      "avg_cvss": 7.0,
+      "cvss_count": 56
+    },
+    {
+      "date": "2025-06-12",
+      "value": 76,
+      "avg_cvss": 6.5,
+      "cvss_count": 72
+    },
+    {
+      "date": "2025-06-13",
+      "value": 87,
+      "avg_cvss": 7.1,
+      "cvss_count": 79
+    },
+    {
+      "date": "2025-06-14",
+      "value": 21,
+      "avg_cvss": 6.4,
+      "cvss_count": 21
+    },
+    {
+      "date": "2025-06-15",
+      "value": 14,
+      "avg_cvss": 6.5,
+      "cvss_count": 11
+    },
+    {
+      "date": "2025-06-16",
+      "value": 95,
+      "avg_cvss": 7.1,
+      "cvss_count": 90
+    },
+    {
+      "date": "2025-06-17",
+      "value": 174,
+      "avg_cvss": 7.3,
+      "cvss_count": 166
+    },
+    {
+      "date": "2025-06-18",
+      "value": 401,
+      "avg_cvss": 6.4,
+      "cvss_count": 400
+    },
+    {
+      "date": "2025-06-19",
+      "value": 64,
+      "avg_cvss": 6.3,
+      "cvss_count": 62
+    },
+    {
+      "date": "2025-06-20",
+      "value": 222,
+      "avg_cvss": 6.5,
+      "cvss_count": 209
+    },
+    {
+      "date": "2025-06-21",
+      "value": 57,
+      "avg_cvss": 6.8,
+      "cvss_count": 55
+    },
+    {
+      "date": "2025-06-22",
+      "value": 39,
+      "avg_cvss": 6.2,
+      "cvss_count": 39
+    },
+    {
+      "date": "2025-06-23",
+      "value": 73,
+      "avg_cvss": 6.7,
+      "cvss_count": 61
+    },
+    {
+      "date": "2025-06-24",
+      "value": 120,
+      "avg_cvss": 7.1,
+      "cvss_count": 110
+    },
+    {
+      "date": "2025-06-25",
+      "value": 121,
+      "avg_cvss": 6.5,
+      "cvss_count": 114
+    },
+    {
+      "date": "2025-06-26",
+      "value": 114,
+      "avg_cvss": 6.5,
+      "cvss_count": 103
+    },
+    {
+      "date": "2025-06-27",
+      "value": 225,
+      "avg_cvss": 6.7,
+      "cvss_count": 224
+    },
+    {
+      "date": "2025-06-28",
+      "value": 45,
+      "avg_cvss": 6.7,
+      "cvss_count": 45
+    },
+    {
+      "date": "2025-06-29",
+      "value": 47,
+      "avg_cvss": 5.9,
+      "cvss_count": 47
+    },
+    {
+      "date": "2025-06-30",
+      "value": 88,
+      "avg_cvss": 7.0,
+      "cvss_count": 87
+    },
+    {
+      "date": "2025-07-01",
+      "value": 89,
+      "avg_cvss": 7.1,
+      "cvss_count": 69
+    },
+    {
+      "date": "2025-07-02",
+      "value": 85,
+      "avg_cvss": 6.9,
+      "cvss_count": 75
+    },
+    {
+      "date": "2025-07-03",
+      "value": 147,
+      "avg_cvss": 6.7,
+      "cvss_count": 137
+    },
+    {
+      "date": "2025-07-04",
+      "value": 184,
+      "avg_cvss": 6.9,
+      "cvss_count": 181
+    },
+    {
+      "date": "2025-07-05",
+      "value": 9,
+      "avg_cvss": 6.4,
+      "cvss_count": 9
+    },
+    {
+      "date": "2025-07-06",
+      "value": 28,
+      "avg_cvss": 7.2,
+      "cvss_count": 27
+    },
+    {
+      "date": "2025-07-07",
+      "value": 175,
+      "avg_cvss": 6.5,
+      "cvss_count": 171
+    },
+    {
+      "date": "2025-07-08",
+      "value": 435,
+      "avg_cvss": 7.1,
+      "cvss_count": 431
+    },
+    {
+      "date": "2025-07-09",
+      "value": 114,
+      "avg_cvss": 6.6,
+      "cvss_count": 107
+    },
+    {
+      "date": "2025-07-10",
+      "value": 198,
+      "avg_cvss": 6.6,
+      "cvss_count": 185
+    },
+    {
+      "date": "2025-07-11",
+      "value": 109,
+      "avg_cvss": 6.7,
+      "cvss_count": 98
+    },
+    {
+      "date": "2025-07-12",
+      "value": 49,
+      "avg_cvss": 7.1,
+      "cvss_count": 49
+    },
+    {
+      "date": "2025-07-13",
+      "value": 46,
+      "avg_cvss": 7.2,
+      "cvss_count": 45
+    },
+    {
+      "date": "2025-07-14",
+      "value": 124,
+      "avg_cvss": 6.6,
+      "cvss_count": 117
+    },
+    {
+      "date": "2025-07-15",
+      "value": 162,
+      "avg_cvss": 6.6,
+      "cvss_count": 148
+    },
+    {
+      "date": "2025-07-16",
+      "value": 188,
+      "avg_cvss": 6.8,
+      "cvss_count": 157
+    },
+    {
+      "date": "2025-07-17",
+      "value": 87,
+      "avg_cvss": 7.3,
+      "cvss_count": 81
+    },
+    {
+      "date": "2025-07-18",
+      "value": 110,
+      "avg_cvss": 6.7,
+      "cvss_count": 100
+    },
+    {
+      "date": "2025-07-19",
+      "value": 45,
+      "avg_cvss": 6.7,
+      "cvss_count": 44
+    },
+    {
+      "date": "2025-07-20",
+      "value": 66,
+      "avg_cvss": 5.8,
+      "cvss_count": 66
+    },
+    {
+      "date": "2025-07-21",
+      "value": 232,
+      "avg_cvss": 7.3,
+      "cvss_count": 225
+    },
+    {
+      "date": "2025-07-22",
+      "value": 112,
+      "avg_cvss": 7.1,
+      "cvss_count": 105
+    },
+    {
+      "date": "2025-07-23",
+      "value": 102,
+      "avg_cvss": 7.2,
+      "cvss_count": 85
+    },
+    {
+      "date": "2025-07-24",
+      "value": 75,
+      "avg_cvss": 7.1,
+      "cvss_count": 71
+    },
+    {
+      "date": "2025-07-25",
+      "value": 223,
+      "avg_cvss": 6.8,
+      "cvss_count": 205
+    },
+    {
+      "date": "2025-07-26",
+      "value": 45,
+      "avg_cvss": 6.5,
+      "cvss_count": 39
+    },
+    {
+      "date": "2025-07-27",
+      "value": 39,
+      "avg_cvss": 6.0,
+      "cvss_count": 39
+    },
+    {
+      "date": "2025-07-28",
+      "value": 121,
+      "avg_cvss": 6.8,
+      "cvss_count": 112
+    },
+    {
+      "date": "2025-07-29",
+      "value": 97,
+      "avg_cvss": 7.0,
+      "cvss_count": 95
+    },
+    {
+      "date": "2025-07-30",
+      "value": 162,
+      "avg_cvss": 7.0,
+      "cvss_count": 158
+    },
+    {
+      "date": "2025-07-31",
+      "value": 118,
+      "avg_cvss": 6.4,
+      "cvss_count": 99
+    },
+    {
+      "date": "2025-08-01",
+      "value": 102,
+      "avg_cvss": 7.3,
+      "cvss_count": 89
+    },
+    {
+      "date": "2025-08-02",
+      "value": 48,
+      "avg_cvss": 6.6,
+      "cvss_count": 48
+    },
+    {
+      "date": "2025-08-03",
+      "value": 31,
+      "avg_cvss": 5.7,
+      "cvss_count": 31
+    },
+    {
+      "date": "2025-08-04",
+      "value": 84,
+      "avg_cvss": 6.9,
+      "cvss_count": 80
+    },
+    {
+      "date": "2025-08-05",
+      "value": 108,
+      "avg_cvss": 6.3,
+      "cvss_count": 87
+    },
+    {
+      "date": "2025-08-06",
+      "value": 227,
+      "avg_cvss": 6.5,
+      "cvss_count": 215
+    },
+    {
+      "date": "2025-08-07",
+      "value": 92,
+      "avg_cvss": 7.0,
+      "cvss_count": 82
+    },
+    {
+      "date": "2025-08-08",
+      "value": 75,
+      "avg_cvss": 6.6,
+      "cvss_count": 59
+    },
+    {
+      "date": "2025-08-09",
+      "value": 43,
+      "avg_cvss": 5.8,
+      "cvss_count": 40
+    },
+    {
+      "date": "2025-08-10",
+      "value": 36,
+      "avg_cvss": 5.5,
+      "cvss_count": 36
+    },
+    {
+      "date": "2025-08-11",
+      "value": 93,
+      "avg_cvss": 6.6,
+      "cvss_count": 80
+    },
+    {
+      "date": "2025-08-12",
+      "value": 353,
+      "avg_cvss": 6.7,
+      "cvss_count": 349
+    },
+    {
+      "date": "2025-08-13",
+      "value": 143,
+      "avg_cvss": 7.3,
+      "cvss_count": 114
+    },
+    {
+      "date": "2025-08-14",
+      "value": 312,
+      "avg_cvss": 6.7,
+      "cvss_count": 296
+    },
+    {
+      "date": "2025-08-15",
+      "value": 92,
+      "avg_cvss": 6.6,
+      "cvss_count": 85
+    },
+    {
+      "date": "2025-08-16",
+      "value": 95,
+      "avg_cvss": 6.9,
+      "cvss_count": 93
+    },
+    {
+      "date": "2025-08-17",
+      "value": 7,
+      "avg_cvss": 5.5,
+      "cvss_count": 7
+    },
+    {
+      "date": "2025-08-18",
+      "value": 75,
+      "avg_cvss": 6.4,
+      "cvss_count": 70
+    },
+    {
+      "date": "2025-08-19",
+      "value": 172,
+      "avg_cvss": 6.6,
+      "cvss_count": 171
+    },
+    {
+      "date": "2025-08-20",
+      "value": 273,
+      "avg_cvss": 7.3,
+      "cvss_count": 243
+    },
+    {
+      "date": "2025-08-21",
+      "value": 128,
+      "avg_cvss": 6.8,
+      "cvss_count": 107
+    },
+    {
+      "date": "2025-08-22",
+      "value": 168,
+      "avg_cvss": 6.9,
+      "cvss_count": 162
+    },
+    {
+      "date": "2025-08-23",
+      "value": 29,
+      "avg_cvss": 7.1,
+      "cvss_count": 29
+    },
+    {
+      "date": "2025-08-24",
+      "value": 22,
+      "avg_cvss": 5.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2025-08-25",
+      "value": 123,
+      "avg_cvss": 7.6,
+      "cvss_count": 111
+    },
+    {
+      "date": "2025-08-26",
+      "value": 126,
+      "avg_cvss": 6.9,
+      "cvss_count": 119
+    },
+    {
+      "date": "2025-08-27",
+      "value": 131,
+      "avg_cvss": 6.9,
+      "cvss_count": 104
+    },
+    {
+      "date": "2025-08-28",
+      "value": 189,
+      "avg_cvss": 6.6,
+      "cvss_count": 187
+    },
+    {
+      "date": "2025-08-29",
+      "value": 164,
+      "avg_cvss": 6.3,
+      "cvss_count": 156
+    },
+    {
+      "date": "2025-08-30",
+      "value": 46,
+      "avg_cvss": 6.8,
+      "cvss_count": 35
+    },
+    {
+      "date": "2025-08-31",
+      "value": 41,
+      "avg_cvss": 5.4,
+      "cvss_count": 41
+    },
+    {
+      "date": "2025-09-01",
+      "value": 84,
+      "avg_cvss": 6.8,
+      "cvss_count": 81
+    },
+    {
+      "date": "2025-09-02",
+      "value": 136,
+      "avg_cvss": 6.9,
+      "cvss_count": 130
+    },
+    {
+      "date": "2025-09-03",
+      "value": 183,
+      "avg_cvss": 6.2,
+      "cvss_count": 178
+    },
+    {
+      "date": "2025-09-04",
+      "value": 276,
+      "avg_cvss": 6.6,
+      "cvss_count": 269
+    },
+    {
+      "date": "2025-09-05",
+      "value": 235,
+      "avg_cvss": 6.5,
+      "cvss_count": 228
+    },
+    {
+      "date": "2025-09-06",
+      "value": 62,
+      "avg_cvss": 6.2,
+      "cvss_count": 60
+    },
+    {
+      "date": "2025-09-07",
+      "value": 17,
+      "avg_cvss": 5.9,
+      "cvss_count": 16
+    },
+    {
+      "date": "2025-09-08",
+      "value": 92,
+      "avg_cvss": 6.9,
+      "cvss_count": 82
+    },
+    {
+      "date": "2025-09-09",
+      "value": 351,
+      "avg_cvss": 7.0,
+      "cvss_count": 332
+    },
+    {
+      "date": "2025-09-10",
+      "value": 96,
+      "avg_cvss": 6.7,
+      "cvss_count": 88
+    },
+    {
+      "date": "2025-09-11",
+      "value": 155,
+      "avg_cvss": 6.4,
+      "cvss_count": 146
+    },
+    {
+      "date": "2025-09-12",
+      "value": 93,
+      "avg_cvss": 6.7,
+      "cvss_count": 85
+    },
+    {
+      "date": "2025-09-13",
+      "value": 15,
+      "avg_cvss": 4.6,
+      "cvss_count": 15
+    },
+    {
+      "date": "2025-09-14",
+      "value": 35,
+      "avg_cvss": 6.2,
+      "cvss_count": 34
+    },
+    {
+      "date": "2025-09-15",
+      "value": 408,
+      "avg_cvss": 6.3,
+      "cvss_count": 393
+    },
+    {
+      "date": "2025-09-16",
+      "value": 231,
+      "avg_cvss": 6.6,
+      "cvss_count": 221
+    },
+    {
+      "date": "2025-09-17",
+      "value": 216,
+      "avg_cvss": 6.6,
+      "cvss_count": 212
+    },
+    {
+      "date": "2025-09-18",
+      "value": 200,
+      "avg_cvss": 6.5,
+      "cvss_count": 195
+    },
+    {
+      "date": "2025-09-19",
+      "value": 121,
+      "avg_cvss": 7.0,
+      "cvss_count": 118
+    },
+    {
+      "date": "2025-09-20",
+      "value": 14,
+      "avg_cvss": 6.1,
+      "cvss_count": 14
+    },
+    {
+      "date": "2025-09-21",
+      "value": 17,
+      "avg_cvss": 5.9,
+      "cvss_count": 17
+    },
+    {
+      "date": "2025-09-22",
+      "value": 413,
+      "avg_cvss": 6.1,
+      "cvss_count": 406
+    },
+    {
+      "date": "2025-09-23",
+      "value": 128,
+      "avg_cvss": 6.7,
+      "cvss_count": 118
+    },
+    {
+      "date": "2025-09-24",
+      "value": 125,
+      "avg_cvss": 7.0,
+      "cvss_count": 121
+    },
+    {
+      "date": "2025-09-25",
+      "value": 107,
+      "avg_cvss": 6.7,
+      "cvss_count": 104
+    },
+    {
+      "date": "2025-09-26",
+      "value": 200,
+      "avg_cvss": 5.9,
+      "cvss_count": 196
+    },
+    {
+      "date": "2025-09-27",
+      "value": 52,
+      "avg_cvss": 6.0,
+      "cvss_count": 52
+    },
+    {
+      "date": "2025-09-28",
+      "value": 36,
+      "avg_cvss": 6.8,
+      "cvss_count": 36
+    },
+    {
+      "date": "2025-09-29",
+      "value": 114,
+      "avg_cvss": 6.8,
+      "cvss_count": 110
+    },
+    {
+      "date": "2025-09-30",
+      "value": 109,
+      "avg_cvss": 6.7,
+      "cvss_count": 104
+    },
+    {
+      "date": "2025-10-01",
+      "value": 242,
+      "avg_cvss": 6.4,
+      "cvss_count": 235
+    },
+    {
+      "date": "2025-10-02",
+      "value": 121,
+      "avg_cvss": 6.9,
+      "cvss_count": 111
+    },
+    {
+      "date": "2025-10-03",
+      "value": 157,
+      "avg_cvss": 6.4,
+      "cvss_count": 150
+    },
+    {
+      "date": "2025-10-04",
+      "value": 159,
+      "avg_cvss": 6.6,
+      "cvss_count": 159
+    },
+    {
+      "date": "2025-10-05",
+      "value": 38,
+      "avg_cvss": 6.2,
+      "cvss_count": 38
+    },
+    {
+      "date": "2025-10-06",
+      "value": 114,
+      "avg_cvss": 6.5,
+      "cvss_count": 101
+    },
+    {
+      "date": "2025-10-07",
+      "value": 236,
+      "avg_cvss": 6.5,
+      "cvss_count": 232
+    },
+    {
+      "date": "2025-10-08",
+      "value": 105,
+      "avg_cvss": 6.1,
+      "cvss_count": 96
+    },
+    {
+      "date": "2025-10-09",
+      "value": 171,
+      "avg_cvss": 7.1,
+      "cvss_count": 164
+    },
+    {
+      "date": "2025-10-10",
+      "value": 124,
+      "avg_cvss": 6.3,
+      "cvss_count": 115
+    },
+    {
+      "date": "2025-10-11",
+      "value": 76,
+      "avg_cvss": 6.0,
+      "cvss_count": 76
+    },
+    {
+      "date": "2025-10-12",
+      "value": 35,
+      "avg_cvss": 4.4,
+      "cvss_count": 35
+    },
+    {
+      "date": "2025-10-13",
+      "value": 91,
+      "avg_cvss": 6.7,
+      "cvss_count": 82
+    },
+    {
+      "date": "2025-10-14",
+      "value": 369,
+      "avg_cvss": 7.0,
+      "cvss_count": 356
+    },
+    {
+      "date": "2025-10-15",
+      "value": 187,
+      "avg_cvss": 6.8,
+      "cvss_count": 163
+    },
+    {
+      "date": "2025-10-16",
+      "value": 132,
+      "avg_cvss": 6.7,
+      "cvss_count": 126
+    },
+    {
+      "date": "2025-10-17",
+      "value": 83,
+      "avg_cvss": 6.9,
+      "cvss_count": 71
+    },
+    {
+      "date": "2025-10-18",
+      "value": 42,
+      "avg_cvss": 6.6,
+      "cvss_count": 28
+    },
+    {
+      "date": "2025-10-19",
+      "value": 11,
+      "avg_cvss": 5.3,
+      "cvss_count": 11
+    },
+    {
+      "date": "2025-10-20",
+      "value": 79,
+      "avg_cvss": 7.3,
+      "cvss_count": 52
+    },
+    {
+      "date": "2025-10-21",
+      "value": 147,
+      "avg_cvss": 6.4,
+      "cvss_count": 136
+    },
+    {
+      "date": "2025-10-22",
+      "value": 389,
+      "avg_cvss": 7.0,
+      "cvss_count": 330
+    },
+    {
+      "date": "2025-10-23",
+      "value": 97,
+      "avg_cvss": 6.5,
+      "cvss_count": 91
+    },
+    {
+      "date": "2025-10-24",
+      "value": 99,
+      "avg_cvss": 6.9,
+      "cvss_count": 85
+    },
+    {
+      "date": "2025-10-25",
+      "value": 39,
+      "avg_cvss": 6.3,
+      "cvss_count": 39
+    },
+    {
+      "date": "2025-10-26",
+      "value": 5,
+      "avg_cvss": 7.9,
+      "cvss_count": 5
+    },
+    {
+      "date": "2025-10-27",
+      "value": 309,
+      "avg_cvss": 6.1,
+      "cvss_count": 299
+    },
+    {
+      "date": "2025-10-28",
+      "value": 153,
+      "avg_cvss": 7.1,
+      "cvss_count": 116
+    },
+    {
+      "date": "2025-10-29",
+      "value": 148,
+      "avg_cvss": 6.5,
+      "cvss_count": 139
+    },
+    {
+      "date": "2025-10-30",
+      "value": 204,
+      "avg_cvss": 6.8,
+      "cvss_count": 186
+    },
+    {
+      "date": "2025-10-31",
+      "value": 111,
+      "avg_cvss": 6.9,
+      "cvss_count": 100
+    },
+    {
+      "date": "2025-11-01",
+      "value": 34,
+      "avg_cvss": 7.0,
+      "cvss_count": 34
+    },
+    {
+      "date": "2025-11-02",
+      "value": 8,
+      "avg_cvss": 6.4,
+      "cvss_count": 8
+    },
+    {
+      "date": "2025-11-03",
+      "value": 61,
+      "avg_cvss": 6.8,
+      "cvss_count": 59
+    },
+    {
+      "date": "2025-11-04",
+      "value": 255,
+      "avg_cvss": 6.3,
+      "cvss_count": 253
+    },
+    {
+      "date": "2025-11-05",
+      "value": 100,
+      "avg_cvss": 6.8,
+      "cvss_count": 100
+    },
+    {
+      "date": "2025-11-06",
+      "value": 246,
+      "avg_cvss": 7.4,
+      "cvss_count": 243
+    },
+    {
+      "date": "2025-11-07",
+      "value": 111,
+      "avg_cvss": 6.3,
+      "cvss_count": 100
+    },
+    {
+      "date": "2025-11-08",
+      "value": 48,
+      "avg_cvss": 6.2,
+      "cvss_count": 46
+    },
+    {
+      "date": "2025-11-09",
+      "value": 7,
+      "avg_cvss": 4.0,
+      "cvss_count": 5
+    },
+    {
+      "date": "2025-11-10",
+      "value": 119,
+      "avg_cvss": 6.8,
+      "cvss_count": 112
+    },
+    {
+      "date": "2025-11-11",
+      "value": 323,
+      "avg_cvss": 6.7,
+      "cvss_count": 315
+    },
+    {
+      "date": "2025-11-12",
+      "value": 212,
+      "avg_cvss": 6.9,
+      "cvss_count": 140
+    },
+    {
+      "date": "2025-11-13",
+      "value": 150,
+      "avg_cvss": 6.3,
+      "cvss_count": 142
+    },
+    {
+      "date": "2025-11-14",
+      "value": 92,
+      "avg_cvss": 5.9,
+      "cvss_count": 78
+    },
+    {
+      "date": "2025-11-15",
+      "value": 35,
+      "avg_cvss": 5.9,
+      "cvss_count": 35
+    },
+    {
+      "date": "2025-11-16",
+      "value": 22,
+      "avg_cvss": 6.3,
+      "cvss_count": 22
+    },
+    {
+      "date": "2025-11-17",
+      "value": 117,
+      "avg_cvss": 6.7,
+      "cvss_count": 114
+    },
+    {
+      "date": "2025-11-18",
+      "value": 188,
+      "avg_cvss": 6.5,
+      "cvss_count": 187
+    },
+    {
+      "date": "2025-11-19",
+      "value": 123,
+      "avg_cvss": 6.9,
+      "cvss_count": 107
+    },
+    {
+      "date": "2025-11-20",
+      "value": 101,
+      "avg_cvss": 6.5,
+      "cvss_count": 95
+    },
+    {
+      "date": "2025-11-21",
+      "value": 162,
+      "avg_cvss": 6.1,
+      "cvss_count": 153
+    },
+    {
+      "date": "2025-11-22",
+      "value": 9,
+      "avg_cvss": 5.8,
+      "cvss_count": 9
+    },
+    {
+      "date": "2025-11-23",
+      "value": 31,
+      "avg_cvss": 7.0,
+      "cvss_count": 29
+    },
+    {
+      "date": "2025-11-24",
+      "value": 96,
+      "avg_cvss": 6.5,
+      "cvss_count": 83
+    },
+    {
+      "date": "2025-11-25",
+      "value": 120,
+      "avg_cvss": 6.6,
+      "cvss_count": 102
+    },
+    {
+      "date": "2025-11-26",
+      "value": 104,
+      "avg_cvss": 7.6,
+      "cvss_count": 91
+    },
+    {
+      "date": "2025-11-27",
+      "value": 53,
+      "avg_cvss": 6.4,
+      "cvss_count": 46
+    },
+    {
+      "date": "2025-11-28",
+      "value": 45,
+      "avg_cvss": 6.2,
+      "cvss_count": 42
+    },
+    {
+      "date": "2025-11-29",
+      "value": 27,
+      "avg_cvss": 6.7,
+      "cvss_count": 26
+    },
+    {
+      "date": "2025-11-30",
+      "value": 22,
+      "avg_cvss": 5.8,
+      "cvss_count": 22
+    },
+    {
+      "date": "2025-12-01",
+      "value": 144,
+      "avg_cvss": 7.0,
+      "cvss_count": 140
+    },
+    {
+      "date": "2025-12-02",
+      "value": 177,
+      "avg_cvss": 6.7,
+      "cvss_count": 170
+    },
+    {
+      "date": "2025-12-03",
+      "value": 93,
+      "avg_cvss": 6.7,
+      "cvss_count": 89
+    },
+    {
+      "date": "2025-12-04",
+      "value": 170,
+      "avg_cvss": 6.9,
+      "cvss_count": 120
+    },
+    {
+      "date": "2025-12-05",
+      "value": 145,
+      "avg_cvss": 5.9,
+      "cvss_count": 138
+    },
+    {
+      "date": "2025-12-06",
+      "value": 66,
+      "avg_cvss": 6.9,
+      "cvss_count": 55
+    },
+    {
+      "date": "2025-12-07",
+      "value": 22,
+      "avg_cvss": 6.0,
+      "cvss_count": 22
+    },
+    {
+      "date": "2025-12-08",
+      "value": 239,
+      "avg_cvss": 6.8,
+      "cvss_count": 188
+    },
+    {
+      "date": "2025-12-09",
+      "value": 659,
+      "avg_cvss": 6.6,
+      "cvss_count": 532
+    },
+    {
+      "date": "2025-12-10",
+      "value": 272,
+      "avg_cvss": 6.6,
+      "cvss_count": 263
+    },
+    {
+      "date": "2025-12-11",
+      "value": 211,
+      "avg_cvss": 7.4,
+      "cvss_count": 192
+    },
+    {
+      "date": "2025-12-12",
+      "value": 226,
+      "avg_cvss": 6.2,
+      "cvss_count": 223
+    },
+    {
+      "date": "2025-12-13",
+      "value": 82,
+      "avg_cvss": 6.2,
+      "cvss_count": 80
+    },
+    {
+      "date": "2025-12-14",
+      "value": 42,
+      "avg_cvss": 6.6,
+      "cvss_count": 42
+    },
+    {
+      "date": "2025-12-15",
+      "value": 125,
+      "avg_cvss": 6.8,
+      "cvss_count": 113
+    },
+    {
+      "date": "2025-12-16",
+      "value": 389,
+      "avg_cvss": 6.7,
+      "cvss_count": 289
+    },
+    {
+      "date": "2025-12-17",
+      "value": 186,
+      "avg_cvss": 6.8,
+      "cvss_count": 180
+    },
+    {
+      "date": "2025-12-18",
+      "value": 398,
+      "avg_cvss": 7.4,
+      "cvss_count": 385
+    },
+    {
+      "date": "2025-12-19",
+      "value": 113,
+      "avg_cvss": 6.8,
+      "cvss_count": 108
+    },
+    {
+      "date": "2025-12-20",
+      "value": 22,
+      "avg_cvss": 6.2,
+      "cvss_count": 22
+    },
+    {
+      "date": "2025-12-21",
+      "value": 31,
+      "avg_cvss": 6.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2025-12-22",
+      "value": 110,
+      "avg_cvss": 7.3,
+      "cvss_count": 91
+    },
+    {
+      "date": "2025-12-23",
+      "value": 156,
+      "avg_cvss": 7.6,
+      "cvss_count": 151
+    },
+    {
+      "date": "2025-12-24",
+      "value": 493,
+      "avg_cvss": 7.0,
+      "cvss_count": 271
+    },
+    {
+      "date": "2025-12-25",
+      "value": 30,
+      "avg_cvss": 6.6,
+      "cvss_count": 30
+    },
+    {
+      "date": "2025-12-26",
+      "value": 55,
+      "avg_cvss": 6.4,
+      "cvss_count": 53
+    },
+    {
+      "date": "2025-12-27",
+      "value": 20,
+      "avg_cvss": 6.9,
+      "cvss_count": 20
+    },
+    {
+      "date": "2025-12-28",
+      "value": 43,
+      "avg_cvss": 4.9,
+      "cvss_count": 43
+    },
+    {
+      "date": "2025-12-29",
+      "value": 119,
+      "avg_cvss": 6.8,
+      "cvss_count": 119
+    },
+    {
+      "date": "2025-12-30",
+      "value": 438,
+      "avg_cvss": 7.0,
+      "cvss_count": 252
+    },
+    {
+      "date": "2025-12-31",
+      "value": 217,
+      "avg_cvss": 6.1,
+      "cvss_count": 213
+    },
+    {
+      "date": "2026-01-01",
+      "value": 35,
+      "avg_cvss": 6.2,
+      "cvss_count": 35
+    },
+    {
+      "date": "2026-01-02",
+      "value": 105,
+      "avg_cvss": 6.7,
+      "cvss_count": 101
+    },
+    {
+      "date": "2026-01-03",
+      "value": 3,
+      "avg_cvss": 7.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2026-01-04",
+      "value": 15,
+      "avg_cvss": 6.3,
+      "cvss_count": 15
+    },
+    {
+      "date": "2026-01-05",
+      "value": 144,
+      "avg_cvss": 7.1,
+      "cvss_count": 128
+    },
+    {
+      "date": "2026-01-06",
+      "value": 156,
+      "avg_cvss": 6.8,
+      "cvss_count": 156
+    },
+    {
+      "date": "2026-01-07",
+      "value": 235,
+      "avg_cvss": 6.5,
+      "cvss_count": 221
+    },
+    {
+      "date": "2026-01-08",
+      "value": 212,
+      "avg_cvss": 7.1,
+      "cvss_count": 204
+    },
+    {
+      "date": "2026-01-09",
+      "value": 129,
+      "avg_cvss": 6.6,
+      "cvss_count": 120
+    },
+    {
+      "date": "2026-01-10",
+      "value": 74,
+      "avg_cvss": 6.5,
+      "cvss_count": 74
+    },
+    {
+      "date": "2026-01-11",
+      "value": 12,
+      "avg_cvss": 7.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2026-01-12",
+      "value": 87,
+      "avg_cvss": 7.6,
+      "cvss_count": 78
+    },
+    {
+      "date": "2026-01-13",
+      "value": 443,
+      "avg_cvss": 7.4,
+      "cvss_count": 405
+    },
+    {
+      "date": "2026-01-14",
+      "value": 181,
+      "avg_cvss": 6.5,
+      "cvss_count": 172
+    },
+    {
+      "date": "2026-01-15",
+      "value": 151,
+      "avg_cvss": 6.9,
+      "cvss_count": 149
+    },
+    {
+      "date": "2026-01-16",
+      "value": 187,
+      "avg_cvss": 7.1,
+      "cvss_count": 182
+    },
+    {
+      "date": "2026-01-17",
+      "value": 38,
+      "avg_cvss": 5.6,
+      "cvss_count": 38
+    },
+    {
+      "date": "2026-01-18",
+      "value": 28,
+      "avg_cvss": 6.2,
+      "cvss_count": 28
+    },
+    {
+      "date": "2026-01-19",
+      "value": 111,
+      "avg_cvss": 6.7,
+      "cvss_count": 110
+    },
+    {
+      "date": "2026-01-20",
+      "value": 237,
+      "avg_cvss": 6.5,
+      "cvss_count": 221
+    },
+    {
+      "date": "2026-01-21",
+      "value": 118,
+      "avg_cvss": 7.1,
+      "cvss_count": 115
+    },
+    {
+      "date": "2026-01-22",
+      "value": 443,
+      "avg_cvss": 7.0,
+      "cvss_count": 431
+    },
+    {
+      "date": "2026-01-23",
+      "value": 253,
+      "avg_cvss": 6.8,
+      "cvss_count": 252
+    },
+    {
+      "date": "2026-01-24",
+      "value": 70,
+      "avg_cvss": 6.1,
+      "cvss_count": 69
+    },
+    {
+      "date": "2026-01-25",
+      "value": 31,
+      "avg_cvss": 6.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2026-01-26",
+      "value": 115,
+      "avg_cvss": 6.3,
+      "cvss_count": 91
+    },
+    {
+      "date": "2026-01-27",
+      "value": 189,
+      "avg_cvss": 7.3,
+      "cvss_count": 149
+    },
+    {
+      "date": "2026-01-28",
+      "value": 211,
+      "avg_cvss": 6.8,
+      "cvss_count": 205
+    },
+    {
+      "date": "2026-01-29",
+      "value": 123,
+      "avg_cvss": 7.0,
+      "cvss_count": 119
+    },
+    {
+      "date": "2026-01-30",
+      "value": 122,
+      "avg_cvss": 7.1,
+      "cvss_count": 110
+    },
+    {
+      "date": "2026-01-31",
+      "value": 44,
+      "avg_cvss": 5.7,
+      "cvss_count": 31
+    },
+    {
+      "date": "2026-02-01",
+      "value": 34,
+      "avg_cvss": 6.9,
+      "cvss_count": 33
+    },
+    {
+      "date": "2026-02-02",
+      "value": 146,
+      "avg_cvss": 6.9,
+      "cvss_count": 132
+    },
+    {
+      "date": "2026-02-03",
+      "value": 346,
+      "avg_cvss": 6.7,
+      "cvss_count": 319
+    },
+    {
+      "date": "2026-02-04",
+      "value": 237,
+      "avg_cvss": 6.6,
+      "cvss_count": 203
+    },
+    {
+      "date": "2026-02-05",
+      "value": 132,
+      "avg_cvss": 6.7,
+      "cvss_count": 127
+    },
+    {
+      "date": "2026-02-06",
+      "value": 172,
+      "avg_cvss": 6.7,
+      "cvss_count": 171
+    },
+    {
+      "date": "2026-02-07",
+      "value": 83,
+      "avg_cvss": 6.7,
+      "cvss_count": 83
+    },
+    {
+      "date": "2026-02-08",
+      "value": 75,
+      "avg_cvss": 6.7,
+      "cvss_count": 75
+    },
+    {
+      "date": "2026-02-09",
+      "value": 163,
+      "avg_cvss": 7.0,
+      "cvss_count": 156
+    },
+    {
+      "date": "2026-02-10",
+      "value": 285,
+      "avg_cvss": 6.7,
+      "cvss_count": 261
+    },
+    {
+      "date": "2026-02-11",
+      "value": 325,
+      "avg_cvss": 6.7,
+      "cvss_count": 314
+    },
+    {
+      "date": "2026-02-12",
+      "value": 123,
+      "avg_cvss": 7.6,
+      "cvss_count": 114
+    },
+    {
+      "date": "2026-02-13",
+      "value": 63,
+      "avg_cvss": 7.5,
+      "cvss_count": 57
+    },
+    {
+      "date": "2026-02-14",
+      "value": 163,
+      "avg_cvss": 6.1,
+      "cvss_count": 155
+    },
+    {
+      "date": "2026-02-15",
+      "value": 30,
+      "avg_cvss": 7.1,
+      "cvss_count": 27
+    },
+    {
+      "date": "2026-02-16",
+      "value": 88,
+      "avg_cvss": 6.3,
+      "cvss_count": 88
+    },
+    {
+      "date": "2026-02-17",
+      "value": 96,
+      "avg_cvss": 6.7,
+      "cvss_count": 93
+    },
+    {
+      "date": "2026-02-18",
+      "value": 237,
+      "avg_cvss": 6.4,
+      "cvss_count": 230
+    },
+    {
+      "date": "2026-02-19",
+      "value": 374,
+      "avg_cvss": 6.2,
+      "cvss_count": 363
+    },
+    {
+      "date": "2026-02-20",
+      "value": 385,
+      "avg_cvss": 7.4,
+      "cvss_count": 376
+    },
+    {
+      "date": "2026-02-21",
+      "value": 73,
+      "avg_cvss": 6.9,
+      "cvss_count": 73
+    },
+    {
+      "date": "2026-02-22",
+      "value": 57,
+      "avg_cvss": 6.9,
+      "cvss_count": 57
+    },
+    {
+      "date": "2026-02-23",
+      "value": 93,
+      "avg_cvss": 6.6,
+      "cvss_count": 88
+    },
+    {
+      "date": "2026-02-24",
+      "value": 228,
+      "avg_cvss": 7.5,
+      "cvss_count": 227
+    },
+    {
+      "date": "2026-02-25",
+      "value": 222,
+      "avg_cvss": 7.0,
+      "cvss_count": 216
+    },
+    {
+      "date": "2026-02-26",
+      "value": 168,
+      "avg_cvss": 6.5,
+      "cvss_count": 163
+    },
+    {
+      "date": "2026-02-27",
+      "value": 203,
+      "avg_cvss": 7.2,
+      "cvss_count": 199
+    },
+    {
+      "date": "2026-02-28",
+      "value": 15,
+      "avg_cvss": 6.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2026-03-01",
+      "value": 20,
+      "avg_cvss": 5.2,
+      "cvss_count": 20
+    },
+    {
+      "date": "2026-03-02",
+      "value": 219,
+      "avg_cvss": 7.4,
+      "cvss_count": 213
+    },
+    {
+      "date": "2026-03-03",
+      "value": 137,
+      "avg_cvss": 7.0,
+      "cvss_count": 135
+    },
+    {
+      "date": "2026-03-04",
+      "value": 200,
+      "avg_cvss": 7.0,
+      "cvss_count": 198
+    },
+    {
+      "date": "2026-03-05",
+      "value": 463,
+      "avg_cvss": 7.8,
+      "cvss_count": 461
+    },
+    {
+      "date": "2026-03-06",
+      "value": 209,
+      "avg_cvss": 7.1,
+      "cvss_count": 207
+    },
+    {
+      "date": "2026-03-07",
+      "value": 110,
+      "avg_cvss": 6.2,
+      "cvss_count": 110
+    },
+    {
+      "date": "2026-03-08",
+      "value": 81,
+      "avg_cvss": 6.5,
+      "cvss_count": 81
+    },
+    {
+      "date": "2026-03-09",
+      "value": 114,
+      "avg_cvss": 7.3,
+      "cvss_count": 113
+    },
+    {
+      "date": "2026-03-10",
+      "value": 387,
+      "avg_cvss": 7.0,
+      "cvss_count": 372
+    },
+    {
+      "date": "2026-03-11",
+      "value": 336,
+      "avg_cvss": 6.7,
+      "cvss_count": 333
+    },
+    {
+      "date": "2026-03-12",
+      "value": 178,
+      "avg_cvss": 7.3,
+      "cvss_count": 173
+    },
+    {
+      "date": "2026-03-13",
+      "value": 247,
+      "avg_cvss": 6.2,
+      "cvss_count": 247
+    },
+    {
+      "date": "2026-03-16",
+      "value": 325,
+      "avg_cvss": 6.4,
+      "cvss_count": 314
+    },
+    {
+      "date": "2026-03-17",
+      "value": 103,
+      "avg_cvss": 6.5,
+      "cvss_count": 100
+    },
+    {
+      "date": "2026-03-18",
+      "value": 201,
+      "avg_cvss": 7.0,
+      "cvss_count": 193
+    },
+    {
+      "date": "2026-03-19",
+      "value": 230,
+      "avg_cvss": 6.9,
+      "cvss_count": 229
+    },
+    {
+      "date": "2026-03-20",
+      "value": 299,
+      "avg_cvss": 7.2,
+      "cvss_count": 299
+    },
+    {
+      "date": "2026-03-21",
+      "value": 182,
+      "avg_cvss": 6.1,
+      "cvss_count": 182
+    },
+    {
+      "date": "2026-03-22",
+      "value": 77,
+      "avg_cvss": 6.4,
+      "cvss_count": 77
+    },
+    {
+      "date": "2026-03-23",
+      "value": 181,
+      "avg_cvss": 6.8,
+      "cvss_count": 173
+    },
+    {
+      "date": "2026-03-24",
+      "value": 274,
+      "avg_cvss": 7.5,
+      "cvss_count": 256
+    },
+    {
+      "date": "2026-03-25",
+      "value": 606,
+      "avg_cvss": 6.9,
+      "cvss_count": 604
+    },
+    {
+      "date": "2026-03-26",
+      "value": 297,
+      "avg_cvss": 6.5,
+      "cvss_count": 295
+    },
+    {
+      "date": "2026-03-27",
+      "value": 246,
+      "avg_cvss": 7.1,
+      "cvss_count": 240
+    },
+    {
+      "date": "2026-03-28",
+      "value": 56,
+      "avg_cvss": 7.5,
+      "cvss_count": 56
+    },
+    {
+      "date": "2026-03-29",
+      "value": 47,
+      "avg_cvss": 7.8,
+      "cvss_count": 47
+    },
+    {
+      "date": "2026-03-30",
+      "value": 139,
+      "avg_cvss": 6.8,
+      "cvss_count": 134
+    },
+    {
+      "date": "2026-03-31",
+      "value": 270,
+      "avg_cvss": 6.8,
+      "cvss_count": 267
+    },
+    {
+      "date": "2026-04-01",
+      "value": 235,
+      "avg_cvss": 7.0,
+      "cvss_count": 234
+    },
+    {
+      "date": "2026-04-02",
+      "value": 254,
+      "avg_cvss": 6.8,
+      "cvss_count": 251
+    },
+    {
+      "date": "2026-04-03",
+      "value": 215,
+      "avg_cvss": 6.9,
+      "cvss_count": 215
+    },
+    {
+      "date": "2026-04-04",
+      "value": 69,
+      "avg_cvss": 6.8,
+      "cvss_count": 69
+    },
+    {
+      "date": "2026-04-05",
+      "value": 111,
+      "avg_cvss": 6.8,
+      "cvss_count": 110
+    },
+    {
+      "date": "2026-04-06",
+      "value": 253,
+      "avg_cvss": 6.9,
+      "cvss_count": 253
+    },
+    {
+      "date": "2026-04-07",
+      "value": 271,
+      "avg_cvss": 7.2,
+      "cvss_count": 256
+    },
+    {
+      "date": "2026-04-08",
+      "value": 487,
+      "avg_cvss": 6.4,
+      "cvss_count": 484
+    },
+    {
+      "date": "2026-04-09",
+      "value": 271,
+      "avg_cvss": 7.1,
+      "cvss_count": 270
+    },
+    {
+      "date": "2026-04-10",
+      "value": 220,
+      "avg_cvss": 6.9,
+      "cvss_count": 215
+    },
+    {
+      "date": "2026-04-11",
+      "value": 39,
+      "avg_cvss": 7.2,
+      "cvss_count": 39
+    },
+    {
+      "date": "2026-04-12",
+      "value": 54,
+      "avg_cvss": 7.3,
+      "cvss_count": 54
+    },
+    {
+      "date": "2026-04-13",
+      "value": 220,
+      "avg_cvss": 6.5,
+      "cvss_count": 215
+    },
+    {
+      "date": "2026-04-14",
+      "value": 395,
+      "avg_cvss": 6.8,
+      "cvss_count": 387
+    },
+    {
+      "date": "2026-04-15",
+      "value": 200,
+      "avg_cvss": 6.9,
+      "cvss_count": 195
+    },
+    {
+      "date": "2026-04-16",
+      "value": 130,
+      "avg_cvss": 7.1,
+      "cvss_count": 123
+    },
+    {
+      "date": "2026-04-17",
+      "value": 151,
+      "avg_cvss": 6.9,
+      "cvss_count": 146
+    },
+    {
+      "date": "2026-04-18",
+      "value": 53,
+      "avg_cvss": 6.8,
+      "cvss_count": 49
+    },
+    {
+      "date": "2026-04-19",
+      "value": 22,
+      "avg_cvss": 6.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2026-04-20",
+      "value": 164,
+      "avg_cvss": 6.6,
+      "cvss_count": 162
+    },
+    {
+      "date": "2026-04-21",
+      "value": 354,
+      "avg_cvss": 6.7,
+      "cvss_count": 332
+    },
+    {
+      "date": "2026-04-22",
+      "value": 338,
+      "avg_cvss": 6.3,
+      "cvss_count": 326
+    },
+    {
+      "date": "2026-04-23",
+      "value": 187,
+      "avg_cvss": 7.2,
+      "cvss_count": 181
+    },
+    {
+      "date": "2026-04-24",
+      "value": 285,
+      "avg_cvss": 6.9,
+      "cvss_count": 281
+    },
+    {
+      "date": "2026-04-25",
+      "value": 40,
+      "avg_cvss": 5.9,
+      "cvss_count": 40
+    },
+    {
+      "date": "2026-04-26",
+      "value": 76,
+      "avg_cvss": 6.3,
+      "cvss_count": 76
+    },
+    {
+      "date": "2026-04-27",
+      "value": 177,
+      "avg_cvss": 7.2,
+      "cvss_count": 169
+    },
+    {
+      "date": "2026-04-28",
+      "value": 245,
+      "avg_cvss": 6.9,
+      "cvss_count": 241
+    },
+    {
+      "date": "2026-04-29",
+      "value": 133,
+      "avg_cvss": 6.9,
+      "cvss_count": 125
+    },
+    {
+      "date": "2026-04-30",
+      "value": 161,
+      "avg_cvss": 6.6,
+      "cvss_count": 161
+    },
+    {
+      "date": "2026-05-01",
+      "value": 263,
+      "avg_cvss": 6.9,
+      "cvss_count": 257
+    },
+    {
+      "date": "2026-05-02",
+      "value": 73,
+      "avg_cvss": 6.5,
+      "cvss_count": 73
+    },
+    {
+      "date": "2026-05-03",
+      "value": 41,
+      "avg_cvss": 6.0,
+      "cvss_count": 41
+    },
+    {
+      "date": "2026-05-04",
+      "value": 189,
+      "avg_cvss": 7.2,
+      "cvss_count": 177
+    },
+    {
+      "date": "2026-05-05",
+      "value": 193,
+      "avg_cvss": 7.2,
+      "cvss_count": 185
+    },
+    {
+      "date": "2026-05-06",
+      "value": 482,
+      "avg_cvss": 6.5,
+      "cvss_count": 474
+    },
+    {
+      "date": "2026-05-07",
+      "value": 201,
+      "avg_cvss": 7.1,
+      "cvss_count": 192
+    },
+    {
+      "date": "2026-05-08",
+      "value": 424,
+      "avg_cvss": 6.8,
+      "cvss_count": 394
+    },
+    {
+      "date": "2026-05-09",
+      "value": 70,
+      "avg_cvss": 6.5,
+      "cvss_count": 64
+    },
+    {
+      "date": "2026-05-10",
+      "value": 101,
+      "avg_cvss": 6.4,
+      "cvss_count": 101
+    },
+    {
+      "date": "2026-05-11",
+      "value": 354,
+      "avg_cvss": 6.5,
+      "cvss_count": 336
+    },
+    {
+      "date": "2026-05-12",
+      "value": 554,
+      "avg_cvss": 7.2,
+      "cvss_count": 518
+    },
+    {
+      "date": "2026-05-13",
+      "value": 346,
+      "avg_cvss": 6.9,
+      "cvss_count": 325
+    },
+    {
+      "date": "2026-05-14",
+      "value": 305,
+      "avg_cvss": 6.7,
+      "cvss_count": 273
+    },
+    {
+      "date": "2026-05-15",
+      "value": 211,
+      "avg_cvss": 6.7,
+      "cvss_count": 160
+    },
+    {
+      "date": "2026-05-16",
+      "value": 47,
+      "avg_cvss": 7.3,
+      "cvss_count": 47
+    },
+    {
+      "date": "2026-05-17",
+      "value": 62,
+      "avg_cvss": 6.5,
+      "cvss_count": 62
+    },
+    {
+      "date": "2026-05-18",
+      "value": 103,
+      "avg_cvss": 6.4,
+      "cvss_count": 99
+    },
+    {
+      "date": "2026-05-19",
+      "value": 201,
+      "avg_cvss": 7.1,
+      "cvss_count": 182
+    },
+    {
+      "date": "2026-05-20",
+      "value": 206,
+      "avg_cvss": 6.6,
+      "cvss_count": 192
+    },
+    {
+      "date": "2026-05-21",
+      "value": 189,
+      "avg_cvss": 6.7,
+      "cvss_count": 188
+    },
+    {
+      "date": "2026-05-22",
+      "value": 152,
+      "avg_cvss": 6.8,
+      "cvss_count": 137
+    },
+    {
+      "date": "2026-05-23",
+      "value": 41,
+      "avg_cvss": 7.3,
+      "cvss_count": 41
+    },
+    {
+      "date": "2026-05-24",
+      "value": 62,
+      "avg_cvss": 6.9,
+      "cvss_count": 61
+    },
+    {
+      "date": "2026-05-25",
+      "value": 188,
+      "avg_cvss": 6.8,
+      "cvss_count": 181
+    },
+    {
+      "date": "2026-05-26",
+      "value": 274,
+      "avg_cvss": 6.7,
+      "cvss_count": 256
+    },
+    {
+      "date": "2026-05-27",
+      "value": 716,
+      "avg_cvss": 6.6,
+      "cvss_count": 701
+    },
+    {
+      "date": "2026-05-28",
+      "value": 543,
+      "avg_cvss": 7.1,
+      "cvss_count": 504
+    },
+    {
+      "date": "2026-05-29",
+      "value": 249,
+      "avg_cvss": 7.1,
+      "cvss_count": 232
+    },
+    {
+      "date": "2026-05-30",
+      "value": 48,
+      "avg_cvss": 7.3,
+      "cvss_count": 48
+    },
+    {
+      "date": "2026-05-31",
+      "value": 50,
+      "avg_cvss": 6.9,
+      "cvss_count": 50
+    },
+    {
+      "date": "2026-06-01",
+      "value": 376,
+      "avg_cvss": 6.6,
+      "cvss_count": 361
+    },
+    {
+      "date": "2026-06-02",
+      "value": 224,
+      "avg_cvss": 6.7,
+      "cvss_count": 200
+    },
+    {
+      "date": "2026-06-03",
+      "value": 154,
+      "avg_cvss": 6.7,
+      "cvss_count": 137
+    },
+    {
+      "date": "2026-06-04",
+      "value": 553,
+      "avg_cvss": 7.4,
+      "cvss_count": 541
+    },
+    {
+      "date": "2026-06-05",
+      "value": 229,
+      "avg_cvss": 6.7,
+      "cvss_count": 207
+    },
+    {
+      "date": "2026-06-06",
+      "value": 54,
+      "avg_cvss": 5.7,
+      "cvss_count": 49
+    },
+    {
+      "date": "2026-06-07",
+      "value": 20,
+      "avg_cvss": 6.0,
+      "cvss_count": 20
+    },
+    {
+      "date": "2026-06-08",
+      "value": 215,
+      "avg_cvss": 6.8,
+      "cvss_count": 206
+    },
+    {
+      "date": "2026-06-09",
+      "value": 747,
+      "avg_cvss": 6.9,
+      "cvss_count": 722
+    },
+    {
+      "date": "2026-06-10",
+      "value": 296,
+      "avg_cvss": 6.7,
+      "cvss_count": 273
+    },
+    {
+      "date": "2026-06-11",
+      "value": 193,
+      "avg_cvss": 7.1,
+      "cvss_count": 171
+    },
+    {
+      "date": "2026-06-12",
+      "value": 279,
+      "avg_cvss": 7.1,
+      "cvss_count": 227
+    },
+    {
+      "date": "2026-06-13",
+      "value": 23,
+      "avg_cvss": 6.3,
+      "cvss_count": 22
+    },
+    {
+      "date": "2026-06-14",
+      "value": 16,
+      "avg_cvss": 7.3,
+      "cvss_count": 16
+    },
+    {
+      "date": "2026-06-15",
+      "value": 395,
+      "avg_cvss": 7.5,
+      "cvss_count": 371
+    },
+    {
+      "date": "2026-06-16",
+      "value": 214,
+      "avg_cvss": 7.0,
+      "cvss_count": 198
+    },
+    {
+      "date": "2026-06-17",
+      "value": 732,
+      "avg_cvss": 8.0,
+      "cvss_count": 709
+    },
+    {
+      "date": "2026-06-18",
+      "value": 143,
+      "avg_cvss": 7.1,
+      "cvss_count": 117
+    },
+    {
+      "date": "2026-06-19",
+      "value": 203,
+      "avg_cvss": 7.5,
+      "cvss_count": 184
+    },
+    {
+      "date": "2026-06-20",
+      "value": 45,
+      "avg_cvss": 6.7,
+      "cvss_count": 41
+    },
+    {
+      "date": "2026-06-21",
+      "value": 68,
+      "avg_cvss": 6.5,
+      "cvss_count": 67
+    },
+    {
+      "date": "2026-06-22",
+      "value": 221,
+      "avg_cvss": 6.7,
+      "cvss_count": 194
+    },
+    {
+      "date": "2026-06-23",
+      "value": 255,
+      "avg_cvss": 6.8,
+      "cvss_count": 220
+    },
+    {
+      "date": "2026-06-24",
+      "value": 509,
+      "avg_cvss": 6.9,
+      "cvss_count": 464
+    },
+    {
+      "date": "2026-06-25",
+      "value": 472,
+      "avg_cvss": 7.0,
+      "cvss_count": 444
+    },
+    {
+      "date": "2026-06-26",
+      "value": 362,
+      "avg_cvss": 6.9,
+      "cvss_count": 351
+    },
+    {
+      "date": "2026-06-27",
+      "value": 31,
+      "avg_cvss": 6.1,
+      "cvss_count": 31
+    },
+    {
+      "date": "2026-06-28",
+      "value": 42,
+      "avg_cvss": 5.8,
+      "cvss_count": 42
+    },
+    {
+      "date": "2026-06-29",
+      "value": 239,
+      "avg_cvss": 6.7,
+      "cvss_count": 229
+    },
+    {
+      "date": "2026-06-30",
+      "value": 632,
+      "avg_cvss": 6.8,
+      "cvss_count": 609
+    },
+    {
+      "date": "2026-07-01",
+      "value": 370,
+      "avg_cvss": 7.0,
+      "cvss_count": 345
+    },
+    {
+      "date": "2026-07-02",
+      "value": 250,
+      "avg_cvss": 7.3,
+      "cvss_count": 238
+    },
+    {
+      "date": "2026-07-03",
+      "value": 200,
+      "avg_cvss": 7.0,
+      "cvss_count": 194
+    },
+    {
+      "date": "2026-07-04",
+      "value": 70,
+      "avg_cvss": 6.6,
+      "cvss_count": 67
+    },
+    {
+      "date": "2026-07-05",
+      "value": 86,
+      "avg_cvss": 6.2,
+      "cvss_count": 84
+    },
+    {
+      "date": "2026-07-06",
+      "value": 195,
+      "avg_cvss": 7.0,
+      "cvss_count": 173
+    },
+    {
+      "date": "2026-07-07",
+      "value": 167,
+      "avg_cvss": 6.9,
+      "cvss_count": 142
+    },
+    {
+      "date": "2026-07-08",
+      "value": 362,
+      "avg_cvss": 6.8,
+      "cvss_count": 350
+    },
+    {
+      "date": "2026-07-09",
+      "value": 270,
+      "avg_cvss": 6.6,
+      "cvss_count": 245
+    },
+    {
+      "date": "2026-07-10",
+      "value": 358,
+      "avg_cvss": 6.7,
+      "cvss_count": 297
+    },
+    {
+      "date": "2026-07-11",
+      "value": 78,
+      "avg_cvss": 6.2,
+      "cvss_count": 77
+    },
+    {
+      "date": "2026-07-12",
+      "value": 61,
+      "avg_cvss": 6.6,
+      "cvss_count": 61
+    },
+    {
+      "date": "2026-07-13",
+      "value": 338,
+      "avg_cvss": 7.1,
+      "cvss_count": 315
+    },
+    {
+      "date": "2026-07-14",
+      "value": 1008,
+      "avg_cvss": 7.2,
+      "cvss_count": 973
+    },
+    {
+      "date": "2026-07-15",
+      "value": 266,
+      "avg_cvss": 6.8,
+      "cvss_count": 218
+    },
+    {
+      "date": "2026-07-16",
+      "value": 242,
+      "avg_cvss": 6.7,
+      "cvss_count": 202
+    },
+    {
+      "date": "2026-07-17",
+      "value": 296,
+      "avg_cvss": 6.8,
+      "cvss_count": 269
+    },
+    {
+      "date": "2026-07-18",
+      "value": 80,
+      "avg_cvss": 6.7,
+      "cvss_count": 80
+    },
+    {
+      "date": "2026-07-19",
+      "value": 462,
+      "avg_cvss": 7.5,
+      "cvss_count": 374
+    },
+    {
+      "date": "2026-07-20",
+      "value": 265,
+      "avg_cvss": 7.0,
+      "cvss_count": 230
+    },
+    {
+      "date": "2026-07-21",
+      "value": 1474,
+      "avg_cvss": 7.4,
+      "cvss_count": 1456
+    },
+    {
+      "date": "2026-07-22",
+      "value": 201,
+      "avg_cvss": 7.1,
+      "cvss_count": 193
+    },
+    {
+      "date": "2026-07-23",
+      "value": 374,
+      "avg_cvss": 7.0,
+      "cvss_count": 356
+    },
+    {
+      "date": "2026-07-24",
+      "value": 196,
+      "avg_cvss": 7.1,
+      "cvss_count": 173
+    },
+    {
+      "date": "2026-07-25",
+      "value": 284,
+      "avg_cvss": 7.3,
+      "cvss_count": 229
+    },
+    {
+      "date": "2026-07-26",
+      "value": 15,
+      "avg_cvss": 6.8,
+      "cvss_count": 15
+    },
+    {
+      "date": "2026-07-27",
+      "value": 440,
+      "avg_cvss": 7.3,
+      "cvss_count": 398
+    },
+    {
+      "date": "2026-07-28",
+      "value": 241,
+      "avg_cvss": 7.0,
+      "cvss_count": 212
+    },
+    {
+      "date": "2026-07-29",
+      "value": 274,
+      "avg_cvss": 7.2,
+      "cvss_count": 242
+    },
+    {
+      "date": "2026-07-30",
+      "value": 664,
+      "avg_cvss": 6.8,
+      "cvss_count": 646
+    },
+    {
+      "date": "2026-07-31",
+      "value": 183,
+      "avg_cvss": 6.7,
+      "cvss_count": 164
+    },
+    {
+      "date": "2026-08-01",
+      "value": 145,
+      "avg_cvss": 6.6,
+      "cvss_count": 142
+    },
+    {
+      "date": "2026-08-02",
+      "value": 52,
+      "avg_cvss": 6.7,
+      "cvss_count": 52
+    },
+    {
+      "date": "2026-08-03",
+      "value": 293,
+      "avg_cvss": 7.0,
+      "cvss_count": 267
+    },
+    {
+      "date": "2026-08-04",
+      "value": 283,
+      "avg_cvss": 7.1,
+      "cvss_count": 254
+    },
+    {
+      "date": "2026-08-05",
+      "value": 423,
+      "avg_cvss": 7.2,
+      "cvss_count": 402
+    },
+    {
+      "date": "2026-08-06",
+      "value": 477,
+      "avg_cvss": 7.1,
+      "cvss_count": 441
+    },
+    {
+      "date": "2026-08-07",
+      "value": 231,
+      "avg_cvss": 6.9,
+      "cvss_count": 176
+    },
+    {
+      "date": "2026-08-08",
+      "value": 54,
+      "avg_cvss": 7.4,
+      "cvss_count": 50
+    },
+    {
+      "date": "2026-08-09",
+      "value": 84,
+      "avg_cvss": 6.4,
+      "cvss_count": 83
+    },
+    {
+      "date": "2026-08-10",
+      "value": 674,
+      "avg_cvss": 7.5,
+      "cvss_count": 429
+    },
+    {
+      "date": "2026-08-11",
+      "value": 931,
+      "avg_cvss": 7.2,
+      "cvss_count": 837
+    },
+    {
+      "date": "2026-08-12",
+      "value": 426,
+      "avg_cvss": 7.0,
+      "cvss_count": 374
+    },
+    {
+      "date": "2026-08-13",
+      "value": 611,
+      "avg_cvss": 7.1,
+      "cvss_count": 574
+    },
+    {
+      "date": "2026-08-14",
+      "value": 204,
+      "avg_cvss": 7.1,
+      "cvss_count": 170
+    },
+    {
+      "date": "2026-08-15",
+      "value": 921,
+      "avg_cvss": 8.2,
+      "cvss_count": 582
+    },
+    {
+      "date": "2026-08-16",
+      "value": 109,
+      "avg_cvss": 6.8,
+      "cvss_count": 107
+    },
+    {
+      "date": "2026-08-17",
+      "value": 337,
+      "avg_cvss": 6.9,
+      "cvss_count": 303
+    },
+    {
+      "date": "2026-08-18",
+      "value": 1406,
+      "avg_cvss": 7.4,
+      "cvss_count": 1355
+    },
+    {
+      "date": "2026-08-19",
+      "value": 672,
+      "avg_cvss": 7.1,
+      "cvss_count": 587
+    },
+    {
+      "date": "2026-08-20",
+      "value": 469,
+      "avg_cvss": 7.3,
+      "cvss_count": 403
+    },
+    {
+      "date": "2026-08-21",
+      "value": 258,
+      "avg_cvss": 7.0,
+      "cvss_count": 196
+    },
+    {
+      "date": "2026-08-22",
+      "value": 236,
+      "avg_cvss": 7.7,
+      "cvss_count": 164
+    },
+    {
+      "date": "2026-08-23",
+      "value": 45,
+      "avg_cvss": 6.7,
+      "cvss_count": 45
+    },
+    {
+      "date": "2026-08-24",
+      "value": 310,
+      "avg_cvss": 7.3,
+      "cvss_count": 267
+    },
+    {
+      "date": "2026-08-25",
+      "value": 750,
+      "avg_cvss": 6.7,
+      "cvss_count": 694
+    },
+    {
+      "date": "2026-08-26",
+      "value": 396,
+      "avg_cvss": 7.4,
+      "cvss_count": 340
+    },
+    {
+      "date": "2026-08-27",
+      "value": 365,
+      "avg_cvss": 6.9,
+      "cvss_count": 319
+    },
+    {
+      "date": "2026-08-28",
+      "value": 582,
+      "avg_cvss": 7.0,
+      "cvss_count": 458
+    },
+    {
+      "date": "2026-08-29",
+      "value": 64,
+      "avg_cvss": 6.9,
+      "cvss_count": 63
+    },
+    {
+      "date": "2026-08-30",
+      "value": 91,
+      "avg_cvss": 6.3,
+      "cvss_count": 69
+    },
+    {
+      "date": "2026-08-31",
+      "value": 360,
+      "avg_cvss": 7.1,
+      "cvss_count": 315
+    },
+    {
+      "date": "2026-09-01",
+      "value": 450,
+      "avg_cvss": 7.2,
+      "cvss_count": 358
+    },
+    {
+      "date": "2026-09-02",
+      "value": 342,
+      "avg_cvss": 6.5,
+      "cvss_count": 324
+    },
+    {
+      "date": "2026-09-03",
+      "value": 349,
+      "avg_cvss": 7.2,
+      "cvss_count": 304
+    },
+    {
+      "date": "2026-09-04",
+      "value": 554,
+      "avg_cvss": 6.9,
+      "cvss_count": 367
+    },
+    {
+      "date": "2026-09-05",
+      "value": 143,
+      "avg_cvss": 6.5,
+      "cvss_count": 129
+    },
+    {
+      "date": "2026-09-06",
+      "value": 90,
+      "avg_cvss": 6.8,
+      "cvss_count": 87
+    },
+    {
+      "date": "2026-09-07",
+      "value": 255,
+      "avg_cvss": 6.4,
+      "cvss_count": 229
+    },
+    {
+      "date": "2026-09-08",
+      "value": 1559,
+      "avg_cvss": 7.2,
+      "cvss_count": 1523
+    },
+    {
+      "date": "2026-09-09",
+      "value": 655,
+      "avg_cvss": 6.4,
+      "cvss_count": 624
+    },
+    {
+      "date": "2026-09-10",
+      "value": 381,
+      "avg_cvss": 7.4,
+      "cvss_count": 343
+    },
+    {
+      "date": "2026-09-11",
+      "value": 708,
+      "avg_cvss": 7.6,
+      "cvss_count": 496
+    },
+    {
+      "date": "2026-09-12",
+      "value": 91,
+      "avg_cvss": 6.6,
+      "cvss_count": 90
+    },
+    {
+      "date": "2026-09-13",
+      "value": 130,
+      "avg_cvss": 5.9,
+      "cvss_count": 129
+    },
+    {
+      "date": "2026-09-14",
+      "value": 782,
+      "avg_cvss": 6.3,
+      "cvss_count": 733
+    },
+    {
+      "date": "2026-09-15",
+      "value": 1422,
+      "avg_cvss": 7.5,
+      "cvss_count": 1319
+    },
+    {
+      "date": "2026-09-16",
+      "value": 878,
+      "avg_cvss": 7.2,
+      "cvss_count": 688
+    },
+    {
+      "date": "2026-09-17",
+      "value": 1019,
+      "avg_cvss": 7.4,
+      "cvss_count": 514
+    },
+    {
+      "date": "2026-09-18",
+      "value": 522,
+      "avg_cvss": 6.8,
+      "cvss_count": 501
+    },
+    {
+      "date": "2026-09-19",
+      "value": 107,
+      "avg_cvss": 6.1,
+      "cvss_count": 105
+    },
+    {
+      "date": "2026-09-20",
+      "value": 102,
+      "avg_cvss": 6.1,
+      "cvss_count": 95
+    },
+    {
+      "date": "2026-09-21",
+      "value": 288,
+      "avg_cvss": 6.6,
+      "cvss_count": 229
+    },
+    {
+      "date": "2026-09-22",
+      "value": 449,
+      "avg_cvss": 7.3,
+      "cvss_count": 365
+    },
+    {
+      "date": "2026-09-23",
+      "value": 450,
+      "avg_cvss": 6.7,
+      "cvss_count": 370
+    }
+  ],
+  "metadata": {
+    "total_records": 378478,
+    "total_days": 8078,
+    "data_source": "NVD JSONL",
+    "analysis_type": "calendar_heatmap"
+  }
+}
\ No newline at end of file
diff --git a/web/data/calendar_analysis_current_year.json b/web/data/calendar_analysis_current_year.json
new file mode 100644
index 00000000000..687af98010c
--- /dev/null
+++ b/web/data/calendar_analysis_current_year.json
@@ -0,0 +1,1606 @@
+{
+  "generated_at": "2026-09-23T22:55:40.839852",
+  "statistics": {
+    "year": 2026,
+    "total_cves": 69597,
+    "total_days_with_data": 264,
+    "average_per_day": 263.62,
+    "peak_day": {
+      "date": "2026-09-08",
+      "count": 1559
+    },
+    "average_cvss": 6.84
+  },
+  "daily_data": [
+    {
+      "date": "2026-01-01",
+      "value": 35,
+      "avg_cvss": 6.2,
+      "cvss_count": 35
+    },
+    {
+      "date": "2026-01-02",
+      "value": 105,
+      "avg_cvss": 6.7,
+      "cvss_count": 101
+    },
+    {
+      "date": "2026-01-03",
+      "value": 3,
+      "avg_cvss": 7.1,
+      "cvss_count": 2
+    },
+    {
+      "date": "2026-01-04",
+      "value": 15,
+      "avg_cvss": 6.3,
+      "cvss_count": 15
+    },
+    {
+      "date": "2026-01-05",
+      "value": 144,
+      "avg_cvss": 7.1,
+      "cvss_count": 128
+    },
+    {
+      "date": "2026-01-06",
+      "value": 156,
+      "avg_cvss": 6.8,
+      "cvss_count": 156
+    },
+    {
+      "date": "2026-01-07",
+      "value": 235,
+      "avg_cvss": 6.5,
+      "cvss_count": 221
+    },
+    {
+      "date": "2026-01-08",
+      "value": 212,
+      "avg_cvss": 7.1,
+      "cvss_count": 204
+    },
+    {
+      "date": "2026-01-09",
+      "value": 129,
+      "avg_cvss": 6.6,
+      "cvss_count": 120
+    },
+    {
+      "date": "2026-01-10",
+      "value": 74,
+      "avg_cvss": 6.5,
+      "cvss_count": 74
+    },
+    {
+      "date": "2026-01-11",
+      "value": 12,
+      "avg_cvss": 7.0,
+      "cvss_count": 12
+    },
+    {
+      "date": "2026-01-12",
+      "value": 87,
+      "avg_cvss": 7.6,
+      "cvss_count": 78
+    },
+    {
+      "date": "2026-01-13",
+      "value": 443,
+      "avg_cvss": 7.4,
+      "cvss_count": 405
+    },
+    {
+      "date": "2026-01-14",
+      "value": 181,
+      "avg_cvss": 6.5,
+      "cvss_count": 172
+    },
+    {
+      "date": "2026-01-15",
+      "value": 151,
+      "avg_cvss": 6.9,
+      "cvss_count": 149
+    },
+    {
+      "date": "2026-01-16",
+      "value": 187,
+      "avg_cvss": 7.1,
+      "cvss_count": 182
+    },
+    {
+      "date": "2026-01-17",
+      "value": 38,
+      "avg_cvss": 5.6,
+      "cvss_count": 38
+    },
+    {
+      "date": "2026-01-18",
+      "value": 28,
+      "avg_cvss": 6.2,
+      "cvss_count": 28
+    },
+    {
+      "date": "2026-01-19",
+      "value": 111,
+      "avg_cvss": 6.7,
+      "cvss_count": 110
+    },
+    {
+      "date": "2026-01-20",
+      "value": 237,
+      "avg_cvss": 6.5,
+      "cvss_count": 221
+    },
+    {
+      "date": "2026-01-21",
+      "value": 118,
+      "avg_cvss": 7.1,
+      "cvss_count": 115
+    },
+    {
+      "date": "2026-01-22",
+      "value": 443,
+      "avg_cvss": 7.0,
+      "cvss_count": 431
+    },
+    {
+      "date": "2026-01-23",
+      "value": 253,
+      "avg_cvss": 6.8,
+      "cvss_count": 252
+    },
+    {
+      "date": "2026-01-24",
+      "value": 70,
+      "avg_cvss": 6.1,
+      "cvss_count": 69
+    },
+    {
+      "date": "2026-01-25",
+      "value": 31,
+      "avg_cvss": 6.3,
+      "cvss_count": 31
+    },
+    {
+      "date": "2026-01-26",
+      "value": 115,
+      "avg_cvss": 6.3,
+      "cvss_count": 91
+    },
+    {
+      "date": "2026-01-27",
+      "value": 189,
+      "avg_cvss": 7.3,
+      "cvss_count": 149
+    },
+    {
+      "date": "2026-01-28",
+      "value": 211,
+      "avg_cvss": 6.8,
+      "cvss_count": 205
+    },
+    {
+      "date": "2026-01-29",
+      "value": 123,
+      "avg_cvss": 7.0,
+      "cvss_count": 119
+    },
+    {
+      "date": "2026-01-30",
+      "value": 122,
+      "avg_cvss": 7.1,
+      "cvss_count": 110
+    },
+    {
+      "date": "2026-01-31",
+      "value": 44,
+      "avg_cvss": 5.7,
+      "cvss_count": 31
+    },
+    {
+      "date": "2026-02-01",
+      "value": 34,
+      "avg_cvss": 6.9,
+      "cvss_count": 33
+    },
+    {
+      "date": "2026-02-02",
+      "value": 146,
+      "avg_cvss": 6.9,
+      "cvss_count": 132
+    },
+    {
+      "date": "2026-02-03",
+      "value": 346,
+      "avg_cvss": 6.7,
+      "cvss_count": 319
+    },
+    {
+      "date": "2026-02-04",
+      "value": 237,
+      "avg_cvss": 6.6,
+      "cvss_count": 203
+    },
+    {
+      "date": "2026-02-05",
+      "value": 132,
+      "avg_cvss": 6.7,
+      "cvss_count": 127
+    },
+    {
+      "date": "2026-02-06",
+      "value": 172,
+      "avg_cvss": 6.7,
+      "cvss_count": 171
+    },
+    {
+      "date": "2026-02-07",
+      "value": 83,
+      "avg_cvss": 6.7,
+      "cvss_count": 83
+    },
+    {
+      "date": "2026-02-08",
+      "value": 75,
+      "avg_cvss": 6.7,
+      "cvss_count": 75
+    },
+    {
+      "date": "2026-02-09",
+      "value": 163,
+      "avg_cvss": 7.0,
+      "cvss_count": 156
+    },
+    {
+      "date": "2026-02-10",
+      "value": 285,
+      "avg_cvss": 6.7,
+      "cvss_count": 261
+    },
+    {
+      "date": "2026-02-11",
+      "value": 325,
+      "avg_cvss": 6.7,
+      "cvss_count": 314
+    },
+    {
+      "date": "2026-02-12",
+      "value": 123,
+      "avg_cvss": 7.6,
+      "cvss_count": 114
+    },
+    {
+      "date": "2026-02-13",
+      "value": 63,
+      "avg_cvss": 7.5,
+      "cvss_count": 57
+    },
+    {
+      "date": "2026-02-14",
+      "value": 163,
+      "avg_cvss": 6.1,
+      "cvss_count": 155
+    },
+    {
+      "date": "2026-02-15",
+      "value": 30,
+      "avg_cvss": 7.1,
+      "cvss_count": 27
+    },
+    {
+      "date": "2026-02-16",
+      "value": 88,
+      "avg_cvss": 6.3,
+      "cvss_count": 88
+    },
+    {
+      "date": "2026-02-17",
+      "value": 96,
+      "avg_cvss": 6.7,
+      "cvss_count": 93
+    },
+    {
+      "date": "2026-02-18",
+      "value": 237,
+      "avg_cvss": 6.4,
+      "cvss_count": 230
+    },
+    {
+      "date": "2026-02-19",
+      "value": 374,
+      "avg_cvss": 6.2,
+      "cvss_count": 363
+    },
+    {
+      "date": "2026-02-20",
+      "value": 385,
+      "avg_cvss": 7.4,
+      "cvss_count": 376
+    },
+    {
+      "date": "2026-02-21",
+      "value": 73,
+      "avg_cvss": 6.9,
+      "cvss_count": 73
+    },
+    {
+      "date": "2026-02-22",
+      "value": 57,
+      "avg_cvss": 6.9,
+      "cvss_count": 57
+    },
+    {
+      "date": "2026-02-23",
+      "value": 93,
+      "avg_cvss": 6.6,
+      "cvss_count": 88
+    },
+    {
+      "date": "2026-02-24",
+      "value": 228,
+      "avg_cvss": 7.5,
+      "cvss_count": 227
+    },
+    {
+      "date": "2026-02-25",
+      "value": 222,
+      "avg_cvss": 7.0,
+      "cvss_count": 216
+    },
+    {
+      "date": "2026-02-26",
+      "value": 168,
+      "avg_cvss": 6.5,
+      "cvss_count": 163
+    },
+    {
+      "date": "2026-02-27",
+      "value": 203,
+      "avg_cvss": 7.2,
+      "cvss_count": 199
+    },
+    {
+      "date": "2026-02-28",
+      "value": 15,
+      "avg_cvss": 6.4,
+      "cvss_count": 15
+    },
+    {
+      "date": "2026-03-01",
+      "value": 20,
+      "avg_cvss": 5.2,
+      "cvss_count": 20
+    },
+    {
+      "date": "2026-03-02",
+      "value": 219,
+      "avg_cvss": 7.4,
+      "cvss_count": 213
+    },
+    {
+      "date": "2026-03-03",
+      "value": 137,
+      "avg_cvss": 7.0,
+      "cvss_count": 135
+    },
+    {
+      "date": "2026-03-04",
+      "value": 200,
+      "avg_cvss": 7.0,
+      "cvss_count": 198
+    },
+    {
+      "date": "2026-03-05",
+      "value": 463,
+      "avg_cvss": 7.8,
+      "cvss_count": 461
+    },
+    {
+      "date": "2026-03-06",
+      "value": 209,
+      "avg_cvss": 7.1,
+      "cvss_count": 207
+    },
+    {
+      "date": "2026-03-07",
+      "value": 110,
+      "avg_cvss": 6.2,
+      "cvss_count": 110
+    },
+    {
+      "date": "2026-03-08",
+      "value": 81,
+      "avg_cvss": 6.5,
+      "cvss_count": 81
+    },
+    {
+      "date": "2026-03-09",
+      "value": 114,
+      "avg_cvss": 7.3,
+      "cvss_count": 113
+    },
+    {
+      "date": "2026-03-10",
+      "value": 387,
+      "avg_cvss": 7.0,
+      "cvss_count": 372
+    },
+    {
+      "date": "2026-03-11",
+      "value": 336,
+      "avg_cvss": 6.7,
+      "cvss_count": 333
+    },
+    {
+      "date": "2026-03-12",
+      "value": 178,
+      "avg_cvss": 7.3,
+      "cvss_count": 173
+    },
+    {
+      "date": "2026-03-13",
+      "value": 247,
+      "avg_cvss": 6.2,
+      "cvss_count": 247
+    },
+    {
+      "date": "2026-03-16",
+      "value": 325,
+      "avg_cvss": 6.4,
+      "cvss_count": 314
+    },
+    {
+      "date": "2026-03-17",
+      "value": 103,
+      "avg_cvss": 6.5,
+      "cvss_count": 100
+    },
+    {
+      "date": "2026-03-18",
+      "value": 201,
+      "avg_cvss": 7.0,
+      "cvss_count": 193
+    },
+    {
+      "date": "2026-03-19",
+      "value": 230,
+      "avg_cvss": 6.9,
+      "cvss_count": 229
+    },
+    {
+      "date": "2026-03-20",
+      "value": 299,
+      "avg_cvss": 7.2,
+      "cvss_count": 299
+    },
+    {
+      "date": "2026-03-21",
+      "value": 182,
+      "avg_cvss": 6.1,
+      "cvss_count": 182
+    },
+    {
+      "date": "2026-03-22",
+      "value": 77,
+      "avg_cvss": 6.4,
+      "cvss_count": 77
+    },
+    {
+      "date": "2026-03-23",
+      "value": 181,
+      "avg_cvss": 6.8,
+      "cvss_count": 173
+    },
+    {
+      "date": "2026-03-24",
+      "value": 274,
+      "avg_cvss": 7.5,
+      "cvss_count": 256
+    },
+    {
+      "date": "2026-03-25",
+      "value": 606,
+      "avg_cvss": 6.9,
+      "cvss_count": 604
+    },
+    {
+      "date": "2026-03-26",
+      "value": 297,
+      "avg_cvss": 6.5,
+      "cvss_count": 295
+    },
+    {
+      "date": "2026-03-27",
+      "value": 246,
+      "avg_cvss": 7.1,
+      "cvss_count": 240
+    },
+    {
+      "date": "2026-03-28",
+      "value": 56,
+      "avg_cvss": 7.5,
+      "cvss_count": 56
+    },
+    {
+      "date": "2026-03-29",
+      "value": 47,
+      "avg_cvss": 7.8,
+      "cvss_count": 47
+    },
+    {
+      "date": "2026-03-30",
+      "value": 139,
+      "avg_cvss": 6.8,
+      "cvss_count": 134
+    },
+    {
+      "date": "2026-03-31",
+      "value": 270,
+      "avg_cvss": 6.8,
+      "cvss_count": 267
+    },
+    {
+      "date": "2026-04-01",
+      "value": 235,
+      "avg_cvss": 7.0,
+      "cvss_count": 234
+    },
+    {
+      "date": "2026-04-02",
+      "value": 254,
+      "avg_cvss": 6.8,
+      "cvss_count": 251
+    },
+    {
+      "date": "2026-04-03",
+      "value": 215,
+      "avg_cvss": 6.9,
+      "cvss_count": 215
+    },
+    {
+      "date": "2026-04-04",
+      "value": 69,
+      "avg_cvss": 6.8,
+      "cvss_count": 69
+    },
+    {
+      "date": "2026-04-05",
+      "value": 111,
+      "avg_cvss": 6.8,
+      "cvss_count": 110
+    },
+    {
+      "date": "2026-04-06",
+      "value": 253,
+      "avg_cvss": 6.9,
+      "cvss_count": 253
+    },
+    {
+      "date": "2026-04-07",
+      "value": 271,
+      "avg_cvss": 7.2,
+      "cvss_count": 256
+    },
+    {
+      "date": "2026-04-08",
+      "value": 487,
+      "avg_cvss": 6.4,
+      "cvss_count": 484
+    },
+    {
+      "date": "2026-04-09",
+      "value": 271,
+      "avg_cvss": 7.1,
+      "cvss_count": 270
+    },
+    {
+      "date": "2026-04-10",
+      "value": 220,
+      "avg_cvss": 6.9,
+      "cvss_count": 215
+    },
+    {
+      "date": "2026-04-11",
+      "value": 39,
+      "avg_cvss": 7.2,
+      "cvss_count": 39
+    },
+    {
+      "date": "2026-04-12",
+      "value": 54,
+      "avg_cvss": 7.3,
+      "cvss_count": 54
+    },
+    {
+      "date": "2026-04-13",
+      "value": 220,
+      "avg_cvss": 6.5,
+      "cvss_count": 215
+    },
+    {
+      "date": "2026-04-14",
+      "value": 395,
+      "avg_cvss": 6.8,
+      "cvss_count": 387
+    },
+    {
+      "date": "2026-04-15",
+      "value": 200,
+      "avg_cvss": 6.9,
+      "cvss_count": 195
+    },
+    {
+      "date": "2026-04-16",
+      "value": 130,
+      "avg_cvss": 7.1,
+      "cvss_count": 123
+    },
+    {
+      "date": "2026-04-17",
+      "value": 151,
+      "avg_cvss": 6.9,
+      "cvss_count": 146
+    },
+    {
+      "date": "2026-04-18",
+      "value": 53,
+      "avg_cvss": 6.8,
+      "cvss_count": 49
+    },
+    {
+      "date": "2026-04-19",
+      "value": 22,
+      "avg_cvss": 6.5,
+      "cvss_count": 22
+    },
+    {
+      "date": "2026-04-20",
+      "value": 164,
+      "avg_cvss": 6.6,
+      "cvss_count": 162
+    },
+    {
+      "date": "2026-04-21",
+      "value": 354,
+      "avg_cvss": 6.7,
+      "cvss_count": 332
+    },
+    {
+      "date": "2026-04-22",
+      "value": 338,
+      "avg_cvss": 6.3,
+      "cvss_count": 326
+    },
+    {
+      "date": "2026-04-23",
+      "value": 187,
+      "avg_cvss": 7.2,
+      "cvss_count": 181
+    },
+    {
+      "date": "2026-04-24",
+      "value": 285,
+      "avg_cvss": 6.9,
+      "cvss_count": 281
+    },
+    {
+      "date": "2026-04-25",
+      "value": 40,
+      "avg_cvss": 5.9,
+      "cvss_count": 40
+    },
+    {
+      "date": "2026-04-26",
+      "value": 76,
+      "avg_cvss": 6.3,
+      "cvss_count": 76
+    },
+    {
+      "date": "2026-04-27",
+      "value": 177,
+      "avg_cvss": 7.2,
+      "cvss_count": 169
+    },
+    {
+      "date": "2026-04-28",
+      "value": 245,
+      "avg_cvss": 6.9,
+      "cvss_count": 241
+    },
+    {
+      "date": "2026-04-29",
+      "value": 133,
+      "avg_cvss": 6.9,
+      "cvss_count": 125
+    },
+    {
+      "date": "2026-04-30",
+      "value": 161,
+      "avg_cvss": 6.6,
+      "cvss_count": 161
+    },
+    {
+      "date": "2026-05-01",
+      "value": 263,
+      "avg_cvss": 6.9,
+      "cvss_count": 257
+    },
+    {
+      "date": "2026-05-02",
+      "value": 73,
+      "avg_cvss": 6.5,
+      "cvss_count": 73
+    },
+    {
+      "date": "2026-05-03",
+      "value": 41,
+      "avg_cvss": 6.0,
+      "cvss_count": 41
+    },
+    {
+      "date": "2026-05-04",
+      "value": 189,
+      "avg_cvss": 7.2,
+      "cvss_count": 177
+    },
+    {
+      "date": "2026-05-05",
+      "value": 193,
+      "avg_cvss": 7.2,
+      "cvss_count": 185
+    },
+    {
+      "date": "2026-05-06",
+      "value": 482,
+      "avg_cvss": 6.5,
+      "cvss_count": 474
+    },
+    {
+      "date": "2026-05-07",
+      "value": 201,
+      "avg_cvss": 7.1,
+      "cvss_count": 192
+    },
+    {
+      "date": "2026-05-08",
+      "value": 424,
+      "avg_cvss": 6.8,
+      "cvss_count": 394
+    },
+    {
+      "date": "2026-05-09",
+      "value": 70,
+      "avg_cvss": 6.5,
+      "cvss_count": 64
+    },
+    {
+      "date": "2026-05-10",
+      "value": 101,
+      "avg_cvss": 6.4,
+      "cvss_count": 101
+    },
+    {
+      "date": "2026-05-11",
+      "value": 354,
+      "avg_cvss": 6.5,
+      "cvss_count": 336
+    },
+    {
+      "date": "2026-05-12",
+      "value": 554,
+      "avg_cvss": 7.2,
+      "cvss_count": 518
+    },
+    {
+      "date": "2026-05-13",
+      "value": 346,
+      "avg_cvss": 6.9,
+      "cvss_count": 325
+    },
+    {
+      "date": "2026-05-14",
+      "value": 305,
+      "avg_cvss": 6.7,
+      "cvss_count": 273
+    },
+    {
+      "date": "2026-05-15",
+      "value": 211,
+      "avg_cvss": 6.7,
+      "cvss_count": 160
+    },
+    {
+      "date": "2026-05-16",
+      "value": 47,
+      "avg_cvss": 7.3,
+      "cvss_count": 47
+    },
+    {
+      "date": "2026-05-17",
+      "value": 62,
+      "avg_cvss": 6.5,
+      "cvss_count": 62
+    },
+    {
+      "date": "2026-05-18",
+      "value": 103,
+      "avg_cvss": 6.4,
+      "cvss_count": 99
+    },
+    {
+      "date": "2026-05-19",
+      "value": 201,
+      "avg_cvss": 7.1,
+      "cvss_count": 182
+    },
+    {
+      "date": "2026-05-20",
+      "value": 206,
+      "avg_cvss": 6.6,
+      "cvss_count": 192
+    },
+    {
+      "date": "2026-05-21",
+      "value": 189,
+      "avg_cvss": 6.7,
+      "cvss_count": 188
+    },
+    {
+      "date": "2026-05-22",
+      "value": 152,
+      "avg_cvss": 6.8,
+      "cvss_count": 137
+    },
+    {
+      "date": "2026-05-23",
+      "value": 41,
+      "avg_cvss": 7.3,
+      "cvss_count": 41
+    },
+    {
+      "date": "2026-05-24",
+      "value": 62,
+      "avg_cvss": 6.9,
+      "cvss_count": 61
+    },
+    {
+      "date": "2026-05-25",
+      "value": 188,
+      "avg_cvss": 6.8,
+      "cvss_count": 181
+    },
+    {
+      "date": "2026-05-26",
+      "value": 274,
+      "avg_cvss": 6.7,
+      "cvss_count": 256
+    },
+    {
+      "date": "2026-05-27",
+      "value": 716,
+      "avg_cvss": 6.6,
+      "cvss_count": 701
+    },
+    {
+      "date": "2026-05-28",
+      "value": 543,
+      "avg_cvss": 7.1,
+      "cvss_count": 504
+    },
+    {
+      "date": "2026-05-29",
+      "value": 249,
+      "avg_cvss": 7.1,
+      "cvss_count": 232
+    },
+    {
+      "date": "2026-05-30",
+      "value": 48,
+      "avg_cvss": 7.3,
+      "cvss_count": 48
+    },
+    {
+      "date": "2026-05-31",
+      "value": 50,
+      "avg_cvss": 6.9,
+      "cvss_count": 50
+    },
+    {
+      "date": "2026-06-01",
+      "value": 376,
+      "avg_cvss": 6.6,
+      "cvss_count": 361
+    },
+    {
+      "date": "2026-06-02",
+      "value": 224,
+      "avg_cvss": 6.7,
+      "cvss_count": 200
+    },
+    {
+      "date": "2026-06-03",
+      "value": 154,
+      "avg_cvss": 6.7,
+      "cvss_count": 137
+    },
+    {
+      "date": "2026-06-04",
+      "value": 553,
+      "avg_cvss": 7.4,
+      "cvss_count": 541
+    },
+    {
+      "date": "2026-06-05",
+      "value": 229,
+      "avg_cvss": 6.7,
+      "cvss_count": 207
+    },
+    {
+      "date": "2026-06-06",
+      "value": 54,
+      "avg_cvss": 5.7,
+      "cvss_count": 49
+    },
+    {
+      "date": "2026-06-07",
+      "value": 20,
+      "avg_cvss": 6.0,
+      "cvss_count": 20
+    },
+    {
+      "date": "2026-06-08",
+      "value": 215,
+      "avg_cvss": 6.8,
+      "cvss_count": 206
+    },
+    {
+      "date": "2026-06-09",
+      "value": 747,
+      "avg_cvss": 6.9,
+      "cvss_count": 722
+    },
+    {
+      "date": "2026-06-10",
+      "value": 296,
+      "avg_cvss": 6.7,
+      "cvss_count": 273
+    },
+    {
+      "date": "2026-06-11",
+      "value": 193,
+      "avg_cvss": 7.1,
+      "cvss_count": 171
+    },
+    {
+      "date": "2026-06-12",
+      "value": 279,
+      "avg_cvss": 7.1,
+      "cvss_count": 227
+    },
+    {
+      "date": "2026-06-13",
+      "value": 23,
+      "avg_cvss": 6.3,
+      "cvss_count": 22
+    },
+    {
+      "date": "2026-06-14",
+      "value": 16,
+      "avg_cvss": 7.3,
+      "cvss_count": 16
+    },
+    {
+      "date": "2026-06-15",
+      "value": 395,
+      "avg_cvss": 7.5,
+      "cvss_count": 371
+    },
+    {
+      "date": "2026-06-16",
+      "value": 214,
+      "avg_cvss": 7.0,
+      "cvss_count": 198
+    },
+    {
+      "date": "2026-06-17",
+      "value": 732,
+      "avg_cvss": 8.0,
+      "cvss_count": 709
+    },
+    {
+      "date": "2026-06-18",
+      "value": 143,
+      "avg_cvss": 7.1,
+      "cvss_count": 117
+    },
+    {
+      "date": "2026-06-19",
+      "value": 203,
+      "avg_cvss": 7.5,
+      "cvss_count": 184
+    },
+    {
+      "date": "2026-06-20",
+      "value": 45,
+      "avg_cvss": 6.7,
+      "cvss_count": 41
+    },
+    {
+      "date": "2026-06-21",
+      "value": 68,
+      "avg_cvss": 6.5,
+      "cvss_count": 67
+    },
+    {
+      "date": "2026-06-22",
+      "value": 221,
+      "avg_cvss": 6.7,
+      "cvss_count": 194
+    },
+    {
+      "date": "2026-06-23",
+      "value": 255,
+      "avg_cvss": 6.8,
+      "cvss_count": 220
+    },
+    {
+      "date": "2026-06-24",
+      "value": 509,
+      "avg_cvss": 6.9,
+      "cvss_count": 464
+    },
+    {
+      "date": "2026-06-25",
+      "value": 472,
+      "avg_cvss": 7.0,
+      "cvss_count": 444
+    },
+    {
+      "date": "2026-06-26",
+      "value": 362,
+      "avg_cvss": 6.9,
+      "cvss_count": 351
+    },
+    {
+      "date": "2026-06-27",
+      "value": 31,
+      "avg_cvss": 6.1,
+      "cvss_count": 31
+    },
+    {
+      "date": "2026-06-28",
+      "value": 42,
+      "avg_cvss": 5.8,
+      "cvss_count": 42
+    },
+    {
+      "date": "2026-06-29",
+      "value": 239,
+      "avg_cvss": 6.7,
+      "cvss_count": 229
+    },
+    {
+      "date": "2026-06-30",
+      "value": 632,
+      "avg_cvss": 6.8,
+      "cvss_count": 609
+    },
+    {
+      "date": "2026-07-01",
+      "value": 370,
+      "avg_cvss": 7.0,
+      "cvss_count": 345
+    },
+    {
+      "date": "2026-07-02",
+      "value": 250,
+      "avg_cvss": 7.3,
+      "cvss_count": 238
+    },
+    {
+      "date": "2026-07-03",
+      "value": 200,
+      "avg_cvss": 7.0,
+      "cvss_count": 194
+    },
+    {
+      "date": "2026-07-04",
+      "value": 70,
+      "avg_cvss": 6.6,
+      "cvss_count": 67
+    },
+    {
+      "date": "2026-07-05",
+      "value": 86,
+      "avg_cvss": 6.2,
+      "cvss_count": 84
+    },
+    {
+      "date": "2026-07-06",
+      "value": 195,
+      "avg_cvss": 7.0,
+      "cvss_count": 173
+    },
+    {
+      "date": "2026-07-07",
+      "value": 167,
+      "avg_cvss": 6.9,
+      "cvss_count": 142
+    },
+    {
+      "date": "2026-07-08",
+      "value": 362,
+      "avg_cvss": 6.8,
+      "cvss_count": 350
+    },
+    {
+      "date": "2026-07-09",
+      "value": 270,
+      "avg_cvss": 6.6,
+      "cvss_count": 245
+    },
+    {
+      "date": "2026-07-10",
+      "value": 358,
+      "avg_cvss": 6.7,
+      "cvss_count": 297
+    },
+    {
+      "date": "2026-07-11",
+      "value": 78,
+      "avg_cvss": 6.2,
+      "cvss_count": 77
+    },
+    {
+      "date": "2026-07-12",
+      "value": 61,
+      "avg_cvss": 6.6,
+      "cvss_count": 61
+    },
+    {
+      "date": "2026-07-13",
+      "value": 338,
+      "avg_cvss": 7.1,
+      "cvss_count": 315
+    },
+    {
+      "date": "2026-07-14",
+      "value": 1008,
+      "avg_cvss": 7.2,
+      "cvss_count": 973
+    },
+    {
+      "date": "2026-07-15",
+      "value": 266,
+      "avg_cvss": 6.8,
+      "cvss_count": 218
+    },
+    {
+      "date": "2026-07-16",
+      "value": 242,
+      "avg_cvss": 6.7,
+      "cvss_count": 202
+    },
+    {
+      "date": "2026-07-17",
+      "value": 296,
+      "avg_cvss": 6.8,
+      "cvss_count": 269
+    },
+    {
+      "date": "2026-07-18",
+      "value": 80,
+      "avg_cvss": 6.7,
+      "cvss_count": 80
+    },
+    {
+      "date": "2026-07-19",
+      "value": 462,
+      "avg_cvss": 7.5,
+      "cvss_count": 374
+    },
+    {
+      "date": "2026-07-20",
+      "value": 265,
+      "avg_cvss": 7.0,
+      "cvss_count": 230
+    },
+    {
+      "date": "2026-07-21",
+      "value": 1474,
+      "avg_cvss": 7.4,
+      "cvss_count": 1456
+    },
+    {
+      "date": "2026-07-22",
+      "value": 201,
+      "avg_cvss": 7.1,
+      "cvss_count": 193
+    },
+    {
+      "date": "2026-07-23",
+      "value": 374,
+      "avg_cvss": 7.0,
+      "cvss_count": 356
+    },
+    {
+      "date": "2026-07-24",
+      "value": 196,
+      "avg_cvss": 7.1,
+      "cvss_count": 173
+    },
+    {
+      "date": "2026-07-25",
+      "value": 284,
+      "avg_cvss": 7.3,
+      "cvss_count": 229
+    },
+    {
+      "date": "2026-07-26",
+      "value": 15,
+      "avg_cvss": 6.8,
+      "cvss_count": 15
+    },
+    {
+      "date": "2026-07-27",
+      "value": 440,
+      "avg_cvss": 7.3,
+      "cvss_count": 398
+    },
+    {
+      "date": "2026-07-28",
+      "value": 241,
+      "avg_cvss": 7.0,
+      "cvss_count": 212
+    },
+    {
+      "date": "2026-07-29",
+      "value": 274,
+      "avg_cvss": 7.2,
+      "cvss_count": 242
+    },
+    {
+      "date": "2026-07-30",
+      "value": 664,
+      "avg_cvss": 6.8,
+      "cvss_count": 646
+    },
+    {
+      "date": "2026-07-31",
+      "value": 183,
+      "avg_cvss": 6.7,
+      "cvss_count": 164
+    },
+    {
+      "date": "2026-08-01",
+      "value": 145,
+      "avg_cvss": 6.6,
+      "cvss_count": 142
+    },
+    {
+      "date": "2026-08-02",
+      "value": 52,
+      "avg_cvss": 6.7,
+      "cvss_count": 52
+    },
+    {
+      "date": "2026-08-03",
+      "value": 293,
+      "avg_cvss": 7.0,
+      "cvss_count": 267
+    },
+    {
+      "date": "2026-08-04",
+      "value": 283,
+      "avg_cvss": 7.1,
+      "cvss_count": 254
+    },
+    {
+      "date": "2026-08-05",
+      "value": 423,
+      "avg_cvss": 7.2,
+      "cvss_count": 402
+    },
+    {
+      "date": "2026-08-06",
+      "value": 477,
+      "avg_cvss": 7.1,
+      "cvss_count": 441
+    },
+    {
+      "date": "2026-08-07",
+      "value": 231,
+      "avg_cvss": 6.9,
+      "cvss_count": 176
+    },
+    {
+      "date": "2026-08-08",
+      "value": 54,
+      "avg_cvss": 7.4,
+      "cvss_count": 50
+    },
+    {
+      "date": "2026-08-09",
+      "value": 84,
+      "avg_cvss": 6.4,
+      "cvss_count": 83
+    },
+    {
+      "date": "2026-08-10",
+      "value": 674,
+      "avg_cvss": 7.5,
+      "cvss_count": 429
+    },
+    {
+      "date": "2026-08-11",
+      "value": 931,
+      "avg_cvss": 7.2,
+      "cvss_count": 837
+    },
+    {
+      "date": "2026-08-12",
+      "value": 426,
+      "avg_cvss": 7.0,
+      "cvss_count": 374
+    },
+    {
+      "date": "2026-08-13",
+      "value": 611,
+      "avg_cvss": 7.1,
+      "cvss_count": 574
+    },
+    {
+      "date": "2026-08-14",
+      "value": 204,
+      "avg_cvss": 7.1,
+      "cvss_count": 170
+    },
+    {
+      "date": "2026-08-15",
+      "value": 921,
+      "avg_cvss": 8.2,
+      "cvss_count": 582
+    },
+    {
+      "date": "2026-08-16",
+      "value": 109,
+      "avg_cvss": 6.8,
+      "cvss_count": 107
+    },
+    {
+      "date": "2026-08-17",
+      "value": 337,
+      "avg_cvss": 6.9,
+      "cvss_count": 303
+    },
+    {
+      "date": "2026-08-18",
+      "value": 1406,
+      "avg_cvss": 7.4,
+      "cvss_count": 1355
+    },
+    {
+      "date": "2026-08-19",
+      "value": 672,
+      "avg_cvss": 7.1,
+      "cvss_count": 587
+    },
+    {
+      "date": "2026-08-20",
+      "value": 469,
+      "avg_cvss": 7.3,
+      "cvss_count": 403
+    },
+    {
+      "date": "2026-08-21",
+      "value": 258,
+      "avg_cvss": 7.0,
+      "cvss_count": 196
+    },
+    {
+      "date": "2026-08-22",
+      "value": 236,
+      "avg_cvss": 7.7,
+      "cvss_count": 164
+    },
+    {
+      "date": "2026-08-23",
+      "value": 45,
+      "avg_cvss": 6.7,
+      "cvss_count": 45
+    },
+    {
+      "date": "2026-08-24",
+      "value": 310,
+      "avg_cvss": 7.3,
+      "cvss_count": 267
+    },
+    {
+      "date": "2026-08-25",
+      "value": 750,
+      "avg_cvss": 6.7,
+      "cvss_count": 694
+    },
+    {
+      "date": "2026-08-26",
+      "value": 396,
+      "avg_cvss": 7.4,
+      "cvss_count": 340
+    },
+    {
+      "date": "2026-08-27",
+      "value": 365,
+      "avg_cvss": 6.9,
+      "cvss_count": 319
+    },
+    {
+      "date": "2026-08-28",
+      "value": 582,
+      "avg_cvss": 7.0,
+      "cvss_count": 458
+    },
+    {
+      "date": "2026-08-29",
+      "value": 64,
+      "avg_cvss": 6.9,
+      "cvss_count": 63
+    },
+    {
+      "date": "2026-08-30",
+      "value": 91,
+      "avg_cvss": 6.3,
+      "cvss_count": 69
+    },
+    {
+      "date": "2026-08-31",
+      "value": 360,
+      "avg_cvss": 7.1,
+      "cvss_count": 315
+    },
+    {
+      "date": "2026-09-01",
+      "value": 450,
+      "avg_cvss": 7.2,
+      "cvss_count": 358
+    },
+    {
+      "date": "2026-09-02",
+      "value": 342,
+      "avg_cvss": 6.5,
+      "cvss_count": 324
+    },
+    {
+      "date": "2026-09-03",
+      "value": 349,
+      "avg_cvss": 7.2,
+      "cvss_count": 304
+    },
+    {
+      "date": "2026-09-04",
+      "value": 554,
+      "avg_cvss": 6.9,
+      "cvss_count": 367
+    },
+    {
+      "date": "2026-09-05",
+      "value": 143,
+      "avg_cvss": 6.5,
+      "cvss_count": 129
+    },
+    {
+      "date": "2026-09-06",
+      "value": 90,
+      "avg_cvss": 6.8,
+      "cvss_count": 87
+    },
+    {
+      "date": "2026-09-07",
+      "value": 255,
+      "avg_cvss": 6.4,
+      "cvss_count": 229
+    },
+    {
+      "date": "2026-09-08",
+      "value": 1559,
+      "avg_cvss": 7.2,
+      "cvss_count": 1523
+    },
+    {
+      "date": "2026-09-09",
+      "value": 655,
+      "avg_cvss": 6.4,
+      "cvss_count": 624
+    },
+    {
+      "date": "2026-09-10",
+      "value": 381,
+      "avg_cvss": 7.4,
+      "cvss_count": 343
+    },
+    {
+      "date": "2026-09-11",
+      "value": 708,
+      "avg_cvss": 7.6,
+      "cvss_count": 496
+    },
+    {
+      "date": "2026-09-12",
+      "value": 91,
+      "avg_cvss": 6.6,
+      "cvss_count": 90
+    },
+    {
+      "date": "2026-09-13",
+      "value": 130,
+      "avg_cvss": 5.9,
+      "cvss_count": 129
+    },
+    {
+      "date": "2026-09-14",
+      "value": 782,
+      "avg_cvss": 6.3,
+      "cvss_count": 733
+    },
+    {
+      "date": "2026-09-15",
+      "value": 1422,
+      "avg_cvss": 7.5,
+      "cvss_count": 1319
+    },
+    {
+      "date": "2026-09-16",
+      "value": 878,
+      "avg_cvss": 7.2,
+      "cvss_count": 688
+    },
+    {
+      "date": "2026-09-17",
+      "value": 1019,
+      "avg_cvss": 7.4,
+      "cvss_count": 514
+    },
+    {
+      "date": "2026-09-18",
+      "value": 522,
+      "avg_cvss": 6.8,
+      "cvss_count": 501
+    },
+    {
+      "date": "2026-09-19",
+      "value": 107,
+      "avg_cvss": 6.1,
+      "cvss_count": 105
+    },
+    {
+      "date": "2026-09-20",
+      "value": 102,
+      "avg_cvss": 6.1,
+      "cvss_count": 95
+    },
+    {
+      "date": "2026-09-21",
+      "value": 288,
+      "avg_cvss": 6.6,
+      "cvss_count": 229
+    },
+    {
+      "date": "2026-09-22",
+      "value": 449,
+      "avg_cvss": 7.3,
+      "cvss_count": 365
+    },
+    {
+      "date": "2026-09-23",
+      "value": 450,
+      "avg_cvss": 6.7,
+      "cvss_count": 370
+    }
+  ],
+  "metadata": {
+    "year": 2026,
+    "total_days": 264,
+    "data_source": "NVD JSONL",
+    "analysis_type": "current_year_calendar"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cna_analysis.json b/web/data/cna_analysis.json
new file mode 100644
index 00000000000..4856ee48ca9
--- /dev/null
+++ b/web/data/cna_analysis.json
@@ -0,0 +1,15980 @@
+{
+  "generated_at": "2026-09-23T22:53:09.880895",
+  "source": "CVE V5 List (Authoritative)",
+  "repository_stats": {
+    "total_years": 28,
+    "total_cves": 378495,
+    "years_available": [
+      1999,
+      2000,
+      2001,
+      2002,
+      2003,
+      2004,
+      2005,
+      2006,
+      2007,
+      2008,
+      2009,
+      2010,
+      2011,
+      2012,
+      2013,
+      2014,
+      2015,
+      2016,
+      2017,
+      2018,
+      2019,
+      2020,
+      2021,
+      2022,
+      2023,
+      2024,
+      2025,
+      2026
+    ]
+  },
+  "total_cnas": 471,
+  "active_cnas": 393,
+  "inactive_cnas": 78,
+  "official_cnas": 471,
+  "unofficial_cnas": 0,
+  "high_volume_cnas": 40,
+  "market_concentration": 49.3,
+  "median_years_active": 4,
+  "type_distribution": {
+    "sorted_types": [
+      [
+        "Vendor",
+        426
+      ],
+      [
+        "CERT",
+        22
+      ],
+      [
+        "Security Researcher",
+        9
+      ],
+      [
+        "Open Source",
+        7
+      ],
+      [
+        "Government",
+        4
+      ],
+      [
+        "Academic",
+        2
+      ],
+      [
+        "Program",
+        1
+      ],
+      [
+        "Other",
+        1
+      ]
+    ],
+    "type_percentages": {
+      "Vendor": 90.4,
+      "CERT": 4.7,
+      "Security Researcher": 1.9,
+      "Open Source": 1.5,
+      "Government": 0.8,
+      "Academic": 0.4,
+      "Program": 0.2,
+      "Other": 0.2
+    }
+  },
+  "cna_list": [
+    {
+      "name": "mitre",
+      "assigner_org_id": "8254265b-2729-46b6-b9e3-3dfca2d5bfca",
+      "count": 115033,
+      "years_active": 28,
+      "first_cve_year": 1999,
+      "last_cve_year": 2026,
+      "first_cve_date": "1999-09-29T00:00:00.000Z",
+      "last_cve_date": "2026-09-23T16:58:37.139Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Program"
+      ],
+      "cves_by_year": {
+        "1999": 320,
+        "2000": 1437,
+        "2001": 1323,
+        "2002": 1690,
+        "2020": 7221,
+        "2004": 1612,
+        "2007": 6730,
+        "2005": 6302,
+        "2006": 6355,
+        "2003": 1223,
+        "2009": 4899,
+        "2010": 2831,
+        "2011": 2086,
+        "2016": 1647,
+        "2014": 2655,
+        "2015": 2031,
+        "2025": 5203,
+        "2021": 6473,
+        "2013": 1234,
+        "2019": 7730,
+        "2008": 5038,
+        "2018": 7290,
+        "2017": 6611,
+        "2012": 2107,
+        "2022": 7610,
+        "2023": 6237,
+        "2024": 5910,
+        "2026": 3228
+      },
+      "years_active_list": [
+        1999,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 322,
+      "epss_high_count": 1732,
+      "epss_elevated_count": 7270,
+      "top_cwes": [],
+      "rank": 1
+    },
+    {
+      "name": "GitHub_M",
+      "assigner_org_id": "a0819718-46f1-4df5-94e2-005712e83aaa",
+      "count": 20253,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-09-30T21:39:38.000Z",
+      "last_cve_date": "2026-09-23T22:07:35.095Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Open Source"
+      ],
+      "cves_by_year": {
+        "2019": 26,
+        "2020": 498,
+        "2022": 1293,
+        "2021": 1065,
+        "2024": 2120,
+        "2023": 1771,
+        "2026": 10614,
+        "2025": 2866
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 41,
+      "epss_high_count": 178,
+      "epss_elevated_count": 423,
+      "top_cwes": [],
+      "rank": 2
+    },
+    {
+      "name": "Patchstack",
+      "assigner_org_id": "21595511-bba5-4825-b968-b78d1f9984a3",
+      "count": 18050,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-09-09T11:18:20.862Z",
+      "last_cve_date": "2026-09-23T19:28:55.531Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "cves_by_year": {
+        "2022": 381,
+        "2021": 30,
+        "2023": 2146,
+        "2024": 4564,
+        "2025": 7006,
+        "2026": 3923
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 12,
+      "epss_elevated_count": 34,
+      "top_cwes": [],
+      "rank": 3
+    },
+    {
+      "name": "VulDB",
+      "assigner_org_id": "1af790b2-7ee1-4545-860a-a788eba489b5",
+      "count": 16730,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-03-28T18:00:15.000Z",
+      "last_cve_date": "2026-09-23T22:45:09.921Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "cves_by_year": {
+        "2023": 1931,
+        "2024": 2930,
+        "2022": 854,
+        "2025": 5901,
+        "2026": 5114
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 4,
+      "epss_high_count": 32,
+      "epss_elevated_count": 266,
+      "top_cwes": [],
+      "rank": 4
+    },
+    {
+      "name": "Linux",
+      "assigner_org_id": "416baaa9-dc9f-4396-8d5f-8c081fb06d67",
+      "count": 16509,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-02-20T12:52:56.753Z",
+      "last_cve_date": "2026-09-17T16:12:24.403Z",
+      "days_since_last_cve": 6,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Open Source"
+      ],
+      "cves_by_year": {
+        "2024": 4287,
+        "2025": 5675,
+        "2026": 6547
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 11,
+      "epss_high_count": 5,
+      "epss_elevated_count": 12,
+      "top_cwes": [],
+      "rank": 5
+    },
+    {
+      "name": "microsoft",
+      "assigner_org_id": "f38d906d-7342-40ea-92c1-6c4a2c6478c8",
+      "count": 14479,
+      "years_active": 22,
+      "first_cve_year": 2005,
+      "last_cve_year": 2026,
+      "first_cve_date": "2005-04-13T04:00:00.000Z",
+      "last_cve_date": "2026-09-23T22:40:40.537Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2005": 49,
+        "2006": 121,
+        "2007": 109,
+        "2014": 342,
+        "2008": 146,
+        "2009": 170,
+        "2010": 264,
+        "2012": 148,
+        "2011": 221,
+        "2013": 321,
+        "2018": 703,
+        "2015": 526,
+        "2017": 695,
+        "2016": 461,
+        "2020": 1262,
+        "2019": 845,
+        "2023": 994,
+        "2021": 871,
+        "2022": 931,
+        "2024": 1095,
+        "2025": 1244,
+        "2026": 2961
+      },
+      "years_active_list": [
+        2005,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 379,
+      "epss_high_count": 556,
+      "epss_elevated_count": 3668,
+      "top_cwes": [],
+      "rank": 6
+    },
+    {
+      "name": "redhat",
+      "assigner_org_id": "53f830b8-0a3f-465b-8143-3b8a9948e749",
+      "count": 11691,
+      "years_active": 22,
+      "first_cve_year": 2005,
+      "last_cve_year": 2026,
+      "first_cve_date": "2005-02-07T05:00:00.000Z",
+      "last_cve_date": "2026-09-23T21:24:01.514Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2006": 270,
+        "2019": 630,
+        "2021": 452,
+        "2014": 950,
+        "2005": 239,
+        "2010": 464,
+        "2007": 244,
+        "2020": 567,
+        "2017": 477,
+        "2012": 1156,
+        "2008": 272,
+        "2013": 970,
+        "2009": 311,
+        "2011": 515,
+        "2018": 562,
+        "2016": 537,
+        "2022": 627,
+        "2015": 400,
+        "2023": 446,
+        "2024": 306,
+        "2025": 300,
+        "2026": 996
+      },
+      "years_active_list": [
+        2005,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 33,
+      "epss_high_count": 187,
+      "epss_elevated_count": 783,
+      "top_cwes": [],
+      "rank": 7
+    },
+    {
+      "name": "oracle",
+      "assigner_org_id": "43595867-4340-4103-b7a2-9a5208d29a85",
+      "count": 11319,
+      "years_active": 19,
+      "first_cve_year": 2008,
+      "last_cve_year": 2026,
+      "first_cve_date": "2008-10-14T21:00:00.000Z",
+      "last_cve_date": "2026-09-15T21:53:18.809Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2013": 525,
+        "2009": 145,
+        "2008": 32,
+        "2010": 250,
+        "2011": 307,
+        "2012": 406,
+        "2014": 447,
+        "2015": 483,
+        "2016": 667,
+        "2017": 869,
+        "2019": 613,
+        "2018": 707,
+        "2020": 811,
+        "2024": 370,
+        "2021": 586,
+        "2022": 416,
+        "2025": 314,
+        "2023": 295,
+        "2026": 3076
+      },
+      "years_active_list": [
+        2008,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 44,
+      "epss_high_count": 116,
+      "epss_elevated_count": 219,
+      "top_cwes": [],
+      "rank": 8
+    },
+    {
+      "name": "Wordfence",
+      "assigner_org_id": "b15e7b5b-3da4-40ae-a43c-f7aa60e62599",
+      "count": 11222,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-07-07T12:20:58.388Z",
+      "last_cve_date": "2026-09-23T21:27:34.729Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "cves_by_year": {
+        "2024": 3524,
+        "2025": 3450,
+        "2023": 879,
+        "2026": 3046,
+        "2022": 169,
+        "2021": 154
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 54,
+      "epss_elevated_count": 140,
+      "top_cwes": [],
+      "rank": 9
+    },
+    {
+      "name": "ibm",
+      "assigner_org_id": "9a959283-ebb5-44b6-b705-dcc2bbced522",
+      "count": 7779,
+      "years_active": 15,
+      "first_cve_year": 2012,
+      "last_cve_year": 2026,
+      "first_cve_date": "2012-01-18T20:00:00.000Z",
+      "last_cve_date": "2026-09-23T21:39:25.036Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 406,
+        "2013": 388,
+        "2020": 565,
+        "2012": 151,
+        "2018": 644,
+        "2014": 448,
+        "2015": 309,
+        "2017": 677,
+        "2016": 368,
+        "2019": 489,
+        "2021": 605,
+        "2023": 414,
+        "2024": 504,
+        "2025": 606,
+        "2026": 1205
+      },
+      "years_active_list": [
+        2012,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 8,
+      "epss_high_count": 19,
+      "epss_elevated_count": 53,
+      "top_cwes": [],
+      "rank": 10
+    },
+    {
+      "name": "adobe",
+      "assigner_org_id": "078d4453-3bcd-4900-85e6-15281da43538",
+      "count": 7594,
+      "years_active": 18,
+      "first_cve_year": 2009,
+      "last_cve_year": 2026,
+      "first_cve_date": "2009-10-13T10:00:00.000Z",
+      "last_cve_date": "2026-09-22T18:58:12.860Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2009": 20,
+        "2010": 180,
+        "2011": 181,
+        "2012": 136,
+        "2018": 387,
+        "2014": 130,
+        "2013": 142,
+        "2015": 481,
+        "2016": 547,
+        "2017": 353,
+        "2019": 704,
+        "2023": 681,
+        "2020": 349,
+        "2021": 431,
+        "2026": 830,
+        "2022": 460,
+        "2024": 753,
+        "2025": 829
+      },
+      "years_active_list": [
+        2009,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 75,
+      "epss_high_count": 118,
+      "epss_elevated_count": 717,
+      "top_cwes": [],
+      "rank": 11
+    },
+    {
+      "name": "VulnCheck",
+      "assigner_org_id": "83251b91-4cc7-4094-a5c7-464a1b83ea10",
+      "count": 7501,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-04-19T19:10:12.523Z",
+      "last_cve_date": "2026-09-23T21:36:23.658Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1073,
+        "2026": 6380,
+        "2023": 10,
+        "2024": 38
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 19,
+      "epss_high_count": 33,
+      "epss_elevated_count": 79,
+      "top_cwes": [],
+      "rank": 12
+    },
+    {
+      "name": "apple",
+      "assigner_org_id": "286789f9-fbc2-4510-9f9a-43facdede74c",
+      "count": 7347,
+      "years_active": 17,
+      "first_cve_year": 2010,
+      "last_cve_year": 2026,
+      "first_cve_date": "2010-01-20T16:00:00.000Z",
+      "last_cve_date": "2026-09-23T17:20:20.178Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2010": 265,
+        "2011": 211,
+        "2017": 581,
+        "2013": 173,
+        "2012": 281,
+        "2020": 463,
+        "2015": 612,
+        "2014": 253,
+        "2016": 303,
+        "2019": 500,
+        "2018": 177,
+        "2021": 561,
+        "2025": 730,
+        "2022": 370,
+        "2023": 460,
+        "2024": 596,
+        "2026": 811
+      },
+      "years_active_list": [
+        2010,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 94,
+      "epss_high_count": 10,
+      "epss_elevated_count": 128,
+      "top_cwes": [],
+      "rank": 13
+    },
+    {
+      "name": "cisco",
+      "assigner_org_id": "d1c1063e-7a18-46af-9102-31f8928bc633",
+      "count": 6523,
+      "years_active": 20,
+      "first_cve_year": 2007,
+      "last_cve_year": 2026,
+      "first_cve_date": "2007-11-08T02:00:00.000Z",
+      "last_cve_date": "2026-09-16T20:26:30.469Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2007": 5,
+        "2008": 73,
+        "2009": 85,
+        "2011": 133,
+        "2010": 111,
+        "2020": 558,
+        "2017": 466,
+        "2012": 159,
+        "2019": 566,
+        "2014": 365,
+        "2013": 432,
+        "2015": 489,
+        "2016": 354,
+        "2018": 464,
+        "2025": 274,
+        "2024": 361,
+        "2021": 586,
+        "2023": 263,
+        "2022": 316,
+        "2026": 463
+      },
+      "years_active_list": [
+        2007,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 98,
+      "epss_high_count": 74,
+      "epss_elevated_count": 223,
+      "top_cwes": [],
+      "rank": 14
+    },
+    {
+      "name": "Chrome",
+      "assigner_org_id": "ebfee0ef-53dd-4cf3-9e2a-08a5bd7a7e28",
+      "count": 6269,
+      "years_active": 16,
+      "first_cve_year": 2011,
+      "last_cve_year": 2026,
+      "first_cve_date": "2011-05-16T17:00:00.000Z",
+      "last_cve_date": "2026-09-17T21:08:43.666Z",
+      "days_since_last_cve": 6,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2012": 194,
+        "2020": 262,
+        "2011": 165,
+        "2013": 219,
+        "2019": 358,
+        "2014": 116,
+        "2017": 164,
+        "2015": 178,
+        "2018": 163,
+        "2016": 171,
+        "2021": 375,
+        "2024": 261,
+        "2023": 297,
+        "2022": 357,
+        "2025": 195,
+        "2026": 2794
+      },
+      "years_active_list": [
+        2011,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 76,
+      "epss_high_count": 17,
+      "epss_elevated_count": 123,
+      "top_cwes": [],
+      "rank": 15
+    },
+    {
+      "name": "WPScan",
+      "assigner_org_id": "1bfdd5d7-9bf6-4a53-96ea-42e2716d7a81",
+      "count": 5550,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-03-18T14:57:47.000Z",
+      "last_cve_date": "2026-09-23T12:08:59.817Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 747,
+        "2025": 595,
+        "2024": 773,
+        "2022": 1144,
+        "2023": 935,
+        "2026": 1356
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 36,
+      "epss_elevated_count": 150,
+      "top_cwes": [],
+      "rank": 16
+    },
+    {
+      "name": "google_android",
+      "assigner_org_id": "baff130e-b8d5-4e15-b3d3-c3cf5d5545c6",
+      "count": 5230,
+      "years_active": 12,
+      "first_cve_year": 2015,
+      "last_cve_year": 2026,
+      "first_cve_date": "2015-10-01T00:00:00.000Z",
+      "last_cve_date": "2026-09-08T19:20:33.261Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2016": 518,
+        "2017": 702,
+        "2020": 535,
+        "2018": 286,
+        "2015": 82,
+        "2024": 258,
+        "2025": 286,
+        "2019": 477,
+        "2021": 530,
+        "2022": 698,
+        "2023": 626,
+        "2026": 232
+      },
+      "years_active_list": [
+        2015,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 14,
+      "epss_high_count": 7,
+      "epss_elevated_count": 14,
+      "top_cwes": [],
+      "rank": 17
+    },
+    {
+      "name": "icscert",
+      "assigner_org_id": "7d14cffa-0d7d-4270-9dc0-52cabd5a23a6",
+      "count": 3796,
+      "years_active": 15,
+      "first_cve_year": 2012,
+      "last_cve_year": 2026,
+      "first_cve_date": "2012-05-09T10:00:00.000Z",
+      "last_cve_date": "2026-09-22T20:40:26.449Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2019": 228,
+        "2012": 49,
+        "2013": 112,
+        "2015": 145,
+        "2014": 104,
+        "2016": 130,
+        "2018": 338,
+        "2017": 276,
+        "2020": 280,
+        "2023": 335,
+        "2021": 306,
+        "2022": 493,
+        "2024": 255,
+        "2025": 333,
+        "2026": 412
+      },
+      "years_active_list": [
+        2012,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 8,
+      "epss_high_count": 27,
+      "epss_elevated_count": 155,
+      "top_cwes": [],
+      "rank": 18
+    },
+    {
+      "name": "zdi",
+      "assigner_org_id": "99f1926a-a320-47d8-bbb5-42feb611262e",
+      "count": 3426,
+      "years_active": 12,
+      "first_cve_year": 2015,
+      "last_cve_year": 2026,
+      "first_cve_date": "2015-05-20T18:00:00.000Z",
+      "last_cve_date": "2026-09-15T18:05:59.201Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2015": 1,
+        "2016": 1,
+        "2018": 246,
+        "2017": 63,
+        "2019": 154,
+        "2020": 193,
+        "2021": 218,
+        "2022": 298,
+        "2024": 1286,
+        "2023": 259,
+        "2025": 487,
+        "2026": 220
+      },
+      "years_active_list": [
+        2015,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 6,
+      "epss_high_count": 85,
+      "epss_elevated_count": 152,
+      "top_cwes": [],
+      "rank": 19
+    },
+    {
+      "name": "jpcert",
+      "assigner_org_id": "ede6fdc4-6654-4307-a26d-3331c018e2ce",
+      "count": 3224,
+      "years_active": 17,
+      "first_cve_year": 2010,
+      "last_cve_year": 2026,
+      "first_cve_date": "2010-06-25T18:00:00.000Z",
+      "last_cve_date": "2026-09-16T07:30:01.520Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2011": 76,
+        "2010": 21,
+        "2020": 168,
+        "2014": 132,
+        "2012": 93,
+        "2013": 120,
+        "2015": 154,
+        "2023": 324,
+        "2017": 408,
+        "2019": 195,
+        "2016": 112,
+        "2018": 172,
+        "2021": 242,
+        "2022": 217,
+        "2025": 270,
+        "2024": 281,
+        "2026": 239
+      },
+      "years_active_list": [
+        2010,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 6,
+      "epss_high_count": 8,
+      "epss_elevated_count": 21,
+      "top_cwes": [],
+      "rank": 20
+    },
+    {
+      "name": "certcc",
+      "assigner_org_id": "37e5125f-f79b-445b-8fad-9564f167944b",
+      "count": 3135,
+      "years_active": 22,
+      "first_cve_year": 2005,
+      "last_cve_year": 2026,
+      "first_cve_date": "2005-03-08T05:00:00.000Z",
+      "last_cve_date": "2026-09-23T18:25:22.672Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2005": 12,
+        "2006": 21,
+        "2007": 55,
+        "2008": 47,
+        "2009": 32,
+        "2010": 27,
+        "2015": 154,
+        "2012": 231,
+        "2011": 58,
+        "2019": 43,
+        "2020": 53,
+        "2013": 111,
+        "2014": 1536,
+        "2017": 200,
+        "2016": 124,
+        "2022": 26,
+        "2018": 110,
+        "2024": 24,
+        "2023": 37,
+        "2021": 9,
+        "2026": 178,
+        "2025": 47
+      },
+      "years_active_list": [
+        2005,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 7,
+      "epss_high_count": 66,
+      "epss_elevated_count": 229,
+      "top_cwes": [],
+      "rank": 21
+    },
+    {
+      "name": "qualcomm",
+      "assigner_org_id": "2cfc7d3e-20d3-47ac-8db7-1b7285aff15f",
+      "count": 3064,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-04-06T19:00:00.000Z",
+      "last_cve_date": "2026-09-22T09:45:23.173Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 297,
+        "2018": 670,
+        "2024": 257,
+        "2019": 305,
+        "2020": 304,
+        "2021": 261,
+        "2022": 246,
+        "2023": 314,
+        "2025": 273,
+        "2026": 137
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 12,
+      "epss_high_count": 0,
+      "epss_elevated_count": 4,
+      "top_cwes": [],
+      "rank": 22
+    },
+    {
+      "name": "mozilla",
+      "assigner_org_id": "f16b083a-5664-49f3-a51e-8d479e5ed7fe",
+      "count": 2704,
+      "years_active": 14,
+      "first_cve_year": 2013,
+      "last_cve_year": 2026,
+      "first_cve_date": "2013-01-13T20:00:00.000Z",
+      "last_cve_date": "2026-09-15T19:42:53.494Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2013": 158,
+        "2020": 173,
+        "2014": 117,
+        "2019": 144,
+        "2015": 185,
+        "2016": 134,
+        "2018": 350,
+        "2017": 2,
+        "2023": 194,
+        "2021": 148,
+        "2022": 176,
+        "2024": 202,
+        "2025": 208,
+        "2026": 513
+      },
+      "years_active_list": [
+        2013,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 12,
+      "epss_high_count": 13,
+      "epss_elevated_count": 57,
+      "top_cwes": [],
+      "rank": 23
+    },
+    {
+      "name": "apache",
+      "assigner_org_id": "f0158376-9dc2-43b6-827c-5f631a4d8d09",
+      "count": 2594,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-12-05T19:00:00.000Z",
+      "last_cve_date": "2026-09-23T12:31:53.210Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Open Source"
+      ],
+      "cves_by_year": {
+        "2023": 259,
+        "2017": 160,
+        "2018": 166,
+        "2016": 1,
+        "2026": 837,
+        "2019": 137,
+        "2020": 148,
+        "2021": 185,
+        "2022": 222,
+        "2024": 261,
+        "2025": 218
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 35,
+      "epss_high_count": 182,
+      "epss_elevated_count": 337,
+      "top_cwes": [],
+      "rank": 24
+    },
+    {
+      "name": "talos",
+      "assigner_org_id": "b86d76f8-0f8a-4a96-a78d-d8abfc7fc29b",
+      "count": 2418,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-10-28T14:00:00.000Z",
+      "last_cve_date": "2026-06-25T21:46:00.057Z",
+      "days_since_last_cve": 90,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 335,
+        "2016": 14,
+        "2017": 133,
+        "2023": 347,
+        "2019": 187,
+        "2020": 198,
+        "2021": 272,
+        "2022": 408,
+        "2024": 259,
+        "2025": 200,
+        "2026": 65
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 28,
+      "epss_elevated_count": 140,
+      "top_cwes": [],
+      "rank": 25
+    },
+    {
+      "name": "dell",
+      "assigner_org_id": "c550e75a-17ff-4988-97f0-544cde3820fe",
+      "count": 2396,
+      "years_active": 18,
+      "first_cve_year": 2009,
+      "last_cve_year": 2026,
+      "first_cve_date": "2009-04-15T19:00:00.000Z",
+      "last_cve_date": "2026-09-23T14:34:43.284Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2009": 1,
+        "2020": 68,
+        "2010": 9,
+        "2011": 24,
+        "2012": 37,
+        "2013": 50,
+        "2018": 177,
+        "2017": 143,
+        "2014": 59,
+        "2015": 79,
+        "2016": 63,
+        "2019": 99,
+        "2021": 177,
+        "2022": 187,
+        "2024": 258,
+        "2023": 266,
+        "2026": 476,
+        "2025": 223
+      },
+      "years_active_list": [
+        2009,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 3,
+      "epss_high_count": 13,
+      "epss_elevated_count": 36,
+      "top_cwes": [],
+      "rank": 26
+    },
+    {
+      "name": "@huntr_ai",
+      "assigner_org_id": "c09c270a-b464-47c1-9133-acb35b22c19a",
+      "count": 2385,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-06-17T12:09:42.000Z",
+      "last_cve_date": "2026-08-10T06:29:56.111Z",
+      "days_since_last_cve": 44,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Other"
+      ],
+      "cves_by_year": {
+        "2021": 169,
+        "2024": 325,
+        "2022": 850,
+        "2023": 612,
+        "2025": 356,
+        "2026": 73
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 31,
+      "epss_elevated_count": 94,
+      "top_cwes": [],
+      "rank": 27
+    },
+    {
+      "name": "intel",
+      "assigner_org_id": "6dda929c-bb53-4a77-a76d-48e79601a1ce",
+      "count": 2223,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-10-10T16:00:00.000Z",
+      "last_cve_date": "2026-08-11T17:39:06.609Z",
+      "days_since_last_cve": 43,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 89,
+        "2016": 5,
+        "2018": 95,
+        "2019": 245,
+        "2020": 240,
+        "2021": 198,
+        "2024": 348,
+        "2022": 239,
+        "2023": 349,
+        "2025": 273,
+        "2026": 142
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 5,
+      "epss_elevated_count": 10,
+      "top_cwes": [],
+      "rank": 28
+    },
+    {
+      "name": "huawei",
+      "assigner_org_id": "25ac1063-e409-4190-8079-24548c77ea2e",
+      "count": 2208,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-09-26T14:00:00.000Z",
+      "last_cve_date": "2026-09-09T04:00:25.389Z",
+      "days_since_last_cve": 14,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 223,
+        "2018": 226,
+        "2016": 5,
+        "2019": 95,
+        "2023": 254,
+        "2020": 187,
+        "2022": 315,
+        "2021": 327,
+        "2024": 221,
+        "2025": 224,
+        "2026": 131
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 29
+    },
+    {
+      "name": "siemens",
+      "assigner_org_id": "cec7a2ec-15b4-4faf-bd53-b40f371f3a77",
+      "count": 1841,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-11-22T11:00:00.000Z",
+      "last_cve_date": "2026-09-16T07:59:08.075Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 276,
+        "2016": 7,
+        "2017": 36,
+        "2018": 66,
+        "2019": 126,
+        "2020": 94,
+        "2021": 300,
+        "2024": 296,
+        "2022": 296,
+        "2023": 248,
+        "2026": 96
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 14,
+      "top_cwes": [],
+      "rank": 30
+    },
+    {
+      "name": "hackerone",
+      "assigner_org_id": "36234546-b8fa-4601-9d6f-f4e334aa8ea1",
+      "count": 1761,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-11-03T10:00:00.000Z",
+      "last_cve_date": "2026-09-23T19:52:47.216Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 529,
+        "2019": 97,
+        "2016": 2,
+        "2017": 59,
+        "2021": 137,
+        "2020": 206,
+        "2022": 85,
+        "2023": 144,
+        "2024": 187,
+        "2025": 84,
+        "2026": 231
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 27,
+      "epss_high_count": 71,
+      "epss_elevated_count": 157,
+      "top_cwes": [],
+      "rank": 31
+    },
+    {
+      "name": "jenkins",
+      "assigner_org_id": "39769cd5-e6e2-4dc8-927e-97b3aa056f5b",
+      "count": 1592,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-01-22T14:00:00.000Z",
+      "last_cve_date": "2026-09-16T13:53:14.924Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 339,
+        "2020": 235,
+        "2021": 103,
+        "2022": 391,
+        "2023": 240,
+        "2024": 49,
+        "2025": 97,
+        "2026": 138
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 3,
+      "epss_high_count": 33,
+      "epss_elevated_count": 44,
+      "top_cwes": [],
+      "rank": 32
+    },
+    {
+      "name": "sap",
+      "assigner_org_id": "e4686d1a-f260-4930-ac4c-2f5c992778dd",
+      "count": 1564,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-12-12T14:00:00.000Z",
+      "last_cve_date": "2026-09-22T00:28:40.930Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 12,
+        "2018": 129,
+        "2019": 123,
+        "2020": 218,
+        "2022": 190,
+        "2021": 198,
+        "2023": 167,
+        "2024": 141,
+        "2025": 212,
+        "2026": 174
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 8,
+      "epss_high_count": 8,
+      "epss_elevated_count": 22,
+      "top_cwes": [],
+      "rank": 33
+    },
+    {
+      "name": "hpe",
+      "assigner_org_id": "eb103674-0d28-4225-80f8-39fb86215de0",
+      "count": 1473,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-10-28T21:00:00.000Z",
+      "last_cve_date": "2026-09-22T19:12:34.074Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 257,
+        "2017": 7,
+        "2016": 6,
+        "2019": 141,
+        "2020": 127,
+        "2021": 183,
+        "2022": 149,
+        "2023": 178,
+        "2024": 106,
+        "2025": 97,
+        "2026": 222
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 18,
+      "epss_elevated_count": 88,
+      "top_cwes": [],
+      "rank": 34
+    },
+    {
+      "name": "SamsungMobile",
+      "assigner_org_id": "3af57064-a867-422c-b2ad-40307b65c458",
+      "count": 1392,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-03-02T17:21:16.000Z",
+      "last_cve_date": "2026-09-09T04:48:03.726Z",
+      "days_since_last_cve": 14,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 198,
+        "2022": 356,
+        "2025": 234,
+        "2023": 237,
+        "2024": 221,
+        "2026": 146
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 13,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 35
+    },
+    {
+      "name": "GitLab",
+      "assigner_org_id": "ceab7361-8a18-47b1-92ba-4d7d25f6715a",
+      "count": 1357,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-06-09T15:34:39.000Z",
+      "last_cve_date": "2026-09-18T14:34:32.131Z",
+      "days_since_last_cve": 5,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Open Source"
+      ],
+      "cves_by_year": {
+        "2020": 114,
+        "2021": 181,
+        "2022": 183,
+        "2023": 210,
+        "2024": 170,
+        "2025": 181,
+        "2026": 318
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 6,
+      "epss_high_count": 23,
+      "epss_elevated_count": 40,
+      "top_cwes": [],
+      "rank": 36
+    },
+    {
+      "name": "INCIBE",
+      "assigner_org_id": "0cbda920-cd7f-484a-8e76-bf7f4b7f4516",
+      "count": 1127,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-04-01T20:18:19.303Z",
+      "last_cve_date": "2026-09-23T10:22:43.693Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 20,
+        "2022": 24,
+        "2020": 2,
+        "2023": 170,
+        "2025": 404,
+        "2024": 325,
+        "2026": 182
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 37
+    },
+    {
+      "name": "nvidia",
+      "assigner_org_id": "9576f279-3576-44b5-a4af-b9a8644b2de6",
+      "count": 1057,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-11-08T20:37:00.000Z",
+      "last_cve_date": "2026-09-22T14:10:35.206Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2016": 40,
+        "2017": 78,
+        "2018": 38,
+        "2019": 47,
+        "2020": 45,
+        "2022": 91,
+        "2021": 107,
+        "2023": 102,
+        "2024": 75,
+        "2025": 186,
+        "2026": 248
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 5,
+      "top_cwes": [],
+      "rank": 38
+    },
+    {
+      "name": "fortinet",
+      "assigner_org_id": "6abe59d8-c742-4dff-8ce8-9b0ca1073da8",
+      "count": 1038,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-02-01T17:00:00.000Z",
+      "last_cve_date": "2026-09-22T14:12:50.908Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 38,
+        "2018": 17,
+        "2019": 40,
+        "2020": 45,
+        "2025": 237,
+        "2021": 126,
+        "2022": 106,
+        "2024": 121,
+        "2023": 198,
+        "2026": 110
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 30,
+      "epss_high_count": 26,
+      "epss_elevated_count": 57,
+      "top_cwes": [],
+      "rank": 39
+    },
+    {
+      "name": "MediaTek",
+      "assigner_org_id": "ee979b05-11f8-4f25-a7e0-a1fa9c190374",
+      "count": 1019,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-01-04T15:56:21.000Z",
+      "last_cve_date": "2026-09-07T01:57:36.053Z",
+      "days_since_last_cve": 16,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 324,
+        "2022": 237,
+        "2024": 153,
+        "2025": 162,
+        "2026": 143
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 40
+    },
+    {
+      "name": "hp",
+      "assigner_org_id": "74586083-13ce-40fd-b46a-8e5d23cfbcb2",
+      "count": 935,
+      "years_active": 18,
+      "first_cve_year": 2009,
+      "last_cve_year": 2026,
+      "first_cve_date": "2009-11-17T18:00:00.000Z",
+      "last_cve_date": "2026-09-22T14:57:28.834Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2009": 16,
+        "2010": 115,
+        "2020": 10,
+        "2011": 125,
+        "2012": 75,
+        "2013": 134,
+        "2014": 91,
+        "2015": 81,
+        "2016": 8,
+        "2017": 1,
+        "2018": 13,
+        "2019": 25,
+        "2023": 61,
+        "2021": 14,
+        "2022": 46,
+        "2024": 38,
+        "2025": 41,
+        "2026": 41
+      },
+      "years_active_list": [
+        2009,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 54,
+      "epss_elevated_count": 179,
+      "top_cwes": [],
+      "rank": 41
+    },
+    {
+      "name": "juniper",
+      "assigner_org_id": "8cbe9d5a-a066-4c94-8978-4b15efeae968",
+      "count": 929,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-03-20T20:00:00.000Z",
+      "last_cve_date": "2026-07-09T21:14:33.905Z",
+      "days_since_last_cve": 76,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 86,
+        "2018": 60,
+        "2019": 73,
+        "2020": 81,
+        "2021": 134,
+        "2022": 95,
+        "2023": 100,
+        "2024": 132,
+        "2025": 94,
+        "2026": 74
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 7,
+      "epss_high_count": 4,
+      "epss_elevated_count": 7,
+      "top_cwes": [],
+      "rank": 42
+    },
+    {
+      "name": "twcert",
+      "assigner_org_id": "cded6c7f-6ce5-4948-8f87-aa7a3bbb6b0e",
+      "count": 917,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-02-11T20:00:00.000Z",
+      "last_cve_date": "2026-09-23T08:18:49.332Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2019": 28,
+        "2020": 58,
+        "2022": 89,
+        "2021": 165,
+        "2023": 122,
+        "2024": 169,
+        "2025": 147,
+        "2026": 139
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 3,
+      "epss_high_count": 1,
+      "epss_elevated_count": 6,
+      "top_cwes": [],
+      "rank": 43
+    },
+    {
+      "name": "vmware",
+      "assigner_org_id": "dcf2e128-44bd-42ed-91e8-88f912c1401d",
+      "count": 886,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-12-29T09:02:00.000Z",
+      "last_cve_date": "2026-09-15T09:16:59.460Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 49,
+        "2016": 8,
+        "2018": 35,
+        "2019": 32,
+        "2020": 64,
+        "2021": 87,
+        "2022": 98,
+        "2023": 80,
+        "2024": 90,
+        "2025": 66,
+        "2026": 277
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 32,
+      "epss_high_count": 28,
+      "epss_elevated_count": 68,
+      "top_cwes": [],
+      "rank": 44
+    },
+    {
+      "name": "snyk",
+      "assigner_org_id": "bae035ff-b466-4ff4-94d0-fc9efd9e1730",
+      "count": 869,
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "first_cve_date": "2018-07-25T17:00:00.000Z",
+      "last_cve_date": "2026-09-10T09:54:01.912Z",
+      "days_since_last_cve": 13,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 10,
+        "2019": 31,
+        "2020": 223,
+        "2022": 194,
+        "2021": 178,
+        "2023": 90,
+        "2024": 74,
+        "2025": 36,
+        "2026": 33
+      },
+      "years_active_list": [
+        2018,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 4,
+      "epss_elevated_count": 24,
+      "top_cwes": [],
+      "rank": 45
+    },
+    {
+      "name": "f5",
+      "assigner_org_id": "9dacffd4-cb11-413f-8451-fbbfd4ddc0ab",
+      "count": 825,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-01-03T21:00:00.000Z",
+      "last_cve_date": "2026-09-22T14:17:42.730Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 51,
+        "2018": 89,
+        "2019": 102,
+        "2020": 118,
+        "2021": 82,
+        "2022": 110,
+        "2023": 54,
+        "2024": 50,
+        "2025": 81,
+        "2026": 88
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 8,
+      "epss_high_count": 12,
+      "epss_elevated_count": 20,
+      "top_cwes": [],
+      "rank": 46
+    },
+    {
+      "name": "TR-CERT",
+      "assigner_org_id": "ca940d4e-fea4-4aa2-9a58-591a58b1ce21",
+      "count": 810,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-09-18T13:20:11.941Z",
+      "last_cve_date": "2026-09-23T12:07:17.175Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2022": 21,
+        "2021": 3,
+        "2023": 171,
+        "2024": 123,
+        "2025": 208,
+        "2026": 284
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 47
+    },
+    {
+      "name": "schneider",
+      "assigner_org_id": "076d1eb6-cfab-4401-b34d-6dfc2a413bdb",
+      "count": 738,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-05-09T17:00:00.000Z",
+      "last_cve_date": "2026-09-11T15:13:18.079Z",
+      "days_since_last_cve": 12,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 84,
+        "2017": 17,
+        "2019": 83,
+        "2020": 118,
+        "2022": 105,
+        "2021": 87,
+        "2023": 94,
+        "2024": 48,
+        "2025": 61,
+        "2026": 41
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 3,
+      "epss_elevated_count": 28,
+      "top_cwes": [],
+      "rank": 48
+    },
+    {
+      "name": "CERTVDE",
+      "assigner_org_id": "270ccfa6-a436-4e77-922e-914ec3a9685c",
+      "count": 727,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-05-29T17:27:54.803Z",
+      "last_cve_date": "2026-09-16T07:52:23.443Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2024": 86,
+        "2023": 104,
+        "2025": 136,
+        "2022": 92,
+        "2020": 23,
+        "2021": 89,
+        "2026": 197
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 8,
+      "epss_elevated_count": 16,
+      "top_cwes": [],
+      "rank": 49
+    },
+    {
+      "name": "Unisoc",
+      "assigner_org_id": "63f92e9c-2193-4c24-98a9-93640392c3d3",
+      "count": 656,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-09-09T14:39:12.000Z",
+      "last_cve_date": "2026-08-03T07:18:31.000Z",
+      "days_since_last_cve": 51,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 464,
+        "2022": 88,
+        "2025": 29,
+        "2024": 52,
+        "2026": 23
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 50
+    },
+    {
+      "name": "debian",
+      "assigner_org_id": "79363d38-fa19-49d1-9214-5f28da3f3ac5",
+      "count": 645,
+      "years_active": 22,
+      "first_cve_year": 2005,
+      "last_cve_year": 2026,
+      "first_cve_date": "2005-02-06T05:00:00.000Z",
+      "last_cve_date": "2026-06-10T09:10:30.301Z",
+      "days_since_last_cve": 105,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2016": 87,
+        "2005": 99,
+        "2006": 59,
+        "2019": 33,
+        "2007": 1,
+        "2018": 44,
+        "2012": 23,
+        "2014": 71,
+        "2013": 19,
+        "2020": 14,
+        "2025": 9,
+        "2015": 42,
+        "2017": 135,
+        "2021": 1,
+        "2022": 5,
+        "2026": 3
+      },
+      "years_active_list": [
+        2005,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 3,
+      "epss_high_count": 8,
+      "epss_elevated_count": 34,
+      "top_cwes": [],
+      "rank": 51
+    },
+    {
+      "name": "HCL",
+      "assigner_org_id": "1e47fe04-f25f-42fa-b674-36de2c5e3cfc",
+      "count": 620,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-10-18T19:28:38.000Z",
+      "last_cve_date": "2026-09-18T11:12:24.764Z",
+      "days_since_last_cve": 5,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 47,
+        "2019": 2,
+        "2021": 12,
+        "2022": 63,
+        "2023": 53,
+        "2025": 126,
+        "2024": 86,
+        "2026": 231
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 52
+    },
+    {
+      "name": "qnap",
+      "assigner_org_id": "2fd009eb-170a-4625-932b-17a53af1051f",
+      "count": 614,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-09-14T15:00:00.000Z",
+      "last_cve_date": "2026-09-18T06:51:06.187Z",
+      "days_since_last_cve": 5,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 12,
+        "2018": 29,
+        "2025": 145,
+        "2020": 30,
+        "2021": 54,
+        "2019": 14,
+        "2022": 22,
+        "2024": 146,
+        "2023": 37,
+        "2026": 125
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 12,
+      "epss_high_count": 8,
+      "epss_elevated_count": 29,
+      "top_cwes": [],
+      "rank": 53
+    },
+    {
+      "name": "OpenText",
+      "assigner_org_id": "f81092c5-7f14-476d-80dc-24857f90be84",
+      "count": 608,
+      "years_active": 13,
+      "first_cve_year": 2014,
+      "last_cve_year": 2026,
+      "first_cve_date": "2014-11-10T11:00:00.000Z",
+      "last_cve_date": "2026-09-09T09:14:31.300Z",
+      "days_since_last_cve": 14,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 88,
+        "2018": 122,
+        "2016": 65,
+        "2014": 3,
+        "2015": 8,
+        "2019": 56,
+        "2020": 39,
+        "2024": 104,
+        "2021": 37,
+        "2023": 18,
+        "2022": 15,
+        "2025": 31,
+        "2026": 22
+      },
+      "years_active_list": [
+        2014,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 7,
+      "epss_elevated_count": 20,
+      "top_cwes": [],
+      "rank": 54
+    },
+    {
+      "name": "tenable",
+      "assigner_org_id": "5ac1ecc2-367a-4d16-a0b2-35d495ddd0be",
+      "count": 585,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-08-09T12:00:00.000Z",
+      "last_cve_date": "2026-09-16T15:23:21.834Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "cves_by_year": {
+        "2017": 5,
+        "2018": 52,
+        "2019": 85,
+        "2020": 99,
+        "2021": 111,
+        "2022": 33,
+        "2023": 69,
+        "2024": 45,
+        "2025": 24,
+        "2026": 62
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 8,
+      "epss_high_count": 27,
+      "epss_elevated_count": 86,
+      "top_cwes": [],
+      "rank": 55
+    },
+    {
+      "name": "CERT-PL",
+      "assigner_org_id": "4bb8329e-dd38-46c1-aafb-9bf32bcb93c6",
+      "count": 524,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-09-05T07:46:45.194Z",
+      "last_cve_date": "2026-09-23T14:41:08.125Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2024": 86,
+        "2023": 6,
+        "2025": 167,
+        "2026": 265
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 0,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 56
+    },
+    {
+      "name": "canonical",
+      "assigner_org_id": "cc1ad9ee-3454-478d-9317-d3e869d708bc",
+      "count": 522,
+      "years_active": 20,
+      "first_cve_year": 2007,
+      "last_cve_year": 2026,
+      "first_cve_date": "2007-01-05T00:00:00.000Z",
+      "last_cve_date": "2026-08-26T12:50:10.502Z",
+      "days_since_last_cve": 28,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2007": 14,
+        "2008": 6,
+        "2009": 5,
+        "2010": 22,
+        "2011": 15,
+        "2019": 25,
+        "2014": 23,
+        "2012": 17,
+        "2020": 58,
+        "2015": 21,
+        "2013": 17,
+        "2021": 31,
+        "2016": 14,
+        "2017": 7,
+        "2018": 15,
+        "2024": 51,
+        "2023": 32,
+        "2025": 37,
+        "2022": 4,
+        "2026": 108
+      },
+      "years_active_list": [
+        2007,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 3,
+      "epss_high_count": 5,
+      "epss_elevated_count": 14,
+      "top_cwes": [],
+      "rank": 57
+    },
+    {
+      "name": "lenovo",
+      "assigner_org_id": "da227ddf-6e25-4b41-b023-0f976dcaca4b",
+      "count": 515,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-11-29T20:00:00.000Z",
+      "last_cve_date": "2026-09-10T21:00:31.582Z",
+      "days_since_last_cve": 13,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 39,
+        "2016": 3,
+        "2018": 40,
+        "2024": 91,
+        "2019": 35,
+        "2020": 43,
+        "2021": 37,
+        "2022": 27,
+        "2023": 99,
+        "2025": 45,
+        "2026": 56
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 58
+    },
+    {
+      "name": "trendmicro",
+      "assigner_org_id": "7f7bd7df-cffe-4fdb-ab6d-859363b89272",
+      "count": 506,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-08-01T15:00:00.000Z",
+      "last_cve_date": "2026-05-21T13:04:35.027Z",
+      "days_since_last_cve": 125,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "cves_by_year": {
+        "2017": 34,
+        "2018": 67,
+        "2019": 27,
+        "2020": 77,
+        "2021": 73,
+        "2022": 60,
+        "2023": 44,
+        "2025": 42,
+        "2024": 63,
+        "2026": 19
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 12,
+      "epss_high_count": 13,
+      "epss_elevated_count": 54,
+      "top_cwes": [],
+      "rank": 59
+    },
+    {
+      "name": "flexera",
+      "assigner_org_id": "44d08088-2bea-4760-83a6-1e9be26b15ab",
+      "count": 501,
+      "years_active": 21,
+      "first_cve_year": 2006,
+      "last_cve_year": 2026,
+      "first_cve_date": "2006-05-09T10:00:00.000Z",
+      "last_cve_date": "2026-06-19T13:15:39.453Z",
+      "days_since_last_cve": 96,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2006": 39,
+        "2007": 47,
+        "2008": 55,
+        "2009": 45,
+        "2010": 77,
+        "2011": 30,
+        "2012": 25,
+        "2014": 57,
+        "2013": 40,
+        "2020": 27,
+        "2018": 25,
+        "2017": 8,
+        "2023": 3,
+        "2019": 9,
+        "2021": 4,
+        "2025": 7,
+        "2024": 1,
+        "2026": 2
+      },
+      "years_active_list": [
+        2006,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 13,
+      "epss_elevated_count": 56,
+      "top_cwes": [],
+      "rank": 60
+    },
+    {
+      "name": "Mattermost",
+      "assigner_org_id": "9302f53e-dde5-4bf3-b2f2-a83f91ac0eee",
+      "count": 493,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-12-14T19:57:44.107Z",
+      "last_cve_date": "2026-09-22T20:34:49.141Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 3,
+        "2022": 25,
+        "2021": 5,
+        "2023": 84,
+        "2024": 95,
+        "2025": 120,
+        "2026": 161
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 61
+    },
+    {
+      "name": "AMD",
+      "assigner_org_id": "b58fc414-a1e4-4f92-9d70-1add41838648",
+      "count": 464,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-10-13T21:11:26.000Z",
+      "last_cve_date": "2026-09-02T19:57:10.678Z",
+      "days_since_last_cve": 21,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 57,
+        "2020": 6,
+        "2022": 55,
+        "2023": 95,
+        "2025": 83,
+        "2024": 51,
+        "2026": 117
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 62
+    },
+    {
+      "name": "Joomla",
+      "assigner_org_id": "6ff30186-7fb7-4ad9-be33-533e7b05e586",
+      "count": 453,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-12-28T19:39:18.000Z",
+      "last_cve_date": "2026-09-23T18:43:32.107Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 7,
+        "2021": 24,
+        "2022": 16,
+        "2023": 31,
+        "2024": 21,
+        "2025": 52,
+        "2026": 302
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 6,
+      "epss_high_count": 4,
+      "epss_elevated_count": 11,
+      "top_cwes": [],
+      "rank": 63
+    },
+    {
+      "name": "palo_alto",
+      "assigner_org_id": "d6c1279f-00f6-4ef7-9217-f89ffe703ec0",
+      "count": 424,
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "first_cve_date": "2018-08-16T18:00:00.000Z",
+      "last_cve_date": "2026-09-10T06:05:20.011Z",
+      "days_since_last_cve": 13,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 5,
+        "2020": 73,
+        "2019": 34,
+        "2021": 37,
+        "2022": 28,
+        "2024": 71,
+        "2023": 20,
+        "2025": 64,
+        "2026": 92
+      },
+      "years_active_list": [
+        2018,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 14,
+      "epss_high_count": 12,
+      "epss_elevated_count": 24,
+      "top_cwes": [],
+      "rank": 64
+    },
+    {
+      "name": "Google_Devices",
+      "assigner_org_id": "83238938-5644-45f0-9007-c0392bcf6222",
+      "count": 416,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-10-11T20:37:08.490Z",
+      "last_cve_date": "2026-09-15T18:34:55.580Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 28,
+        "2024": 162,
+        "2025": 67,
+        "2026": 159
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 4,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 65
+    },
+    {
+      "name": "atlassian",
+      "assigner_org_id": "f08a6ab8-ed46-4c22-8884-d911ccfe3c66",
+      "count": 411,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-06-14T20:00:00.000Z",
+      "last_cve_date": "2026-09-15T17:00:00.390Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 19,
+        "2018": 74,
+        "2019": 69,
+        "2020": 80,
+        "2021": 71,
+        "2025": 18,
+        "2022": 37,
+        "2023": 14,
+        "2024": 17,
+        "2026": 12
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 13,
+      "epss_high_count": 28,
+      "epss_elevated_count": 44,
+      "top_cwes": [],
+      "rank": 66
+    },
+    {
+      "name": "drupal",
+      "assigner_org_id": "2c85b837-eb8b-40ed-9d74-228c62987387",
+      "count": 407,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-03-16T14:00:00.000Z",
+      "last_cve_date": "2026-09-02T12:55:30.885Z",
+      "days_since_last_cve": 21,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 10,
+        "2017": 4,
+        "2019": 10,
+        "2020": 2,
+        "2021": 7,
+        "2022": 12,
+        "2023": 8,
+        "2024": 9,
+        "2025": 196,
+        "2026": 149
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 5,
+      "epss_high_count": 4,
+      "epss_elevated_count": 8,
+      "top_cwes": [],
+      "rank": 67
+    },
+    {
+      "name": "JetBrains",
+      "assigner_org_id": "547ada31-17d8-4964-bc5f-1b8238ba8014",
+      "count": 404,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-04-05T17:55:17.000Z",
+      "last_cve_date": "2026-09-07T16:26:51.153Z",
+      "days_since_last_cve": 16,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 46,
+        "2023": 53,
+        "2024": 103,
+        "2025": 83,
+        "2026": 119
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 4,
+      "epss_high_count": 12,
+      "epss_elevated_count": 19,
+      "top_cwes": [],
+      "rank": 68
+    },
+    {
+      "name": "autodesk",
+      "assigner_org_id": "7e40ea87-bc65-4944-9723-dd79dd760601",
+      "count": 359,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-04-09T19:21:46.000Z",
+      "last_cve_date": "2026-09-10T13:29:58.109Z",
+      "days_since_last_cve": 13,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 9,
+        "2020": 7,
+        "2021": 25,
+        "2022": 73,
+        "2023": 31,
+        "2024": 102,
+        "2025": 71,
+        "2026": 41
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 69
+    },
+    {
+      "name": "elastic",
+      "assigner_org_id": "271b6943-45a9-4f3a-ab4e-976f3fa05b5a",
+      "count": 355,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-06-05T14:00:00.000Z",
+      "last_cve_date": "2026-09-03T18:35:44.977Z",
+      "days_since_last_cve": 20,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 25,
+        "2018": 19,
+        "2019": 14,
+        "2020": 12,
+        "2021": 20,
+        "2023": 31,
+        "2022": 12,
+        "2024": 21,
+        "2025": 49,
+        "2026": 152
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 4,
+      "epss_elevated_count": 7,
+      "top_cwes": [],
+      "rank": 70
+    },
+    {
+      "name": "Fluid Attacks",
+      "assigner_org_id": "84fe0718-d6bb-4716-a7e8-81a6d1daa869",
+      "count": 349,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-01-07T21:59:38.000Z",
+      "last_cve_date": "2026-09-23T18:02:02.601Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 54,
+        "2023": 149,
+        "2024": 47,
+        "2025": 33,
+        "2026": 66
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 4,
+      "top_cwes": [],
+      "rank": 71
+    },
+    {
+      "name": "trellix",
+      "assigner_org_id": "01626437-bf8f-4d1c-912a-893b5eb04808",
+      "count": 336,
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "first_cve_date": "2018-04-02T13:00:00.000Z",
+      "last_cve_date": "2026-07-14T12:45:10.526Z",
+      "days_since_last_cve": 71,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 47,
+        "2019": 54,
+        "2020": 86,
+        "2021": 53,
+        "2022": 28,
+        "2023": 37,
+        "2024": 21,
+        "2025": 7,
+        "2026": 3
+      },
+      "years_active_list": [
+        2018,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 72
+    },
+    {
+      "name": "CPANSec",
+      "assigner_org_id": "9b29abf9-4ab0-4765-b253-1875cd9b441e",
+      "count": 333,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-03-10T23:51:33.279Z",
+      "last_cve_date": "2026-09-22T18:21:23.728Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 286,
+        "2025": 47
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 73
+    },
+    {
+      "name": "symantec",
+      "assigner_org_id": "80d3bcb6-88de-48c2-a47e-aebf795f19b5",
+      "count": 332,
+      "years_active": 14,
+      "first_cve_year": 2013,
+      "last_cve_year": 2026,
+      "first_cve_date": "2013-02-18T11:00:00.000Z",
+      "last_cve_date": "2026-07-17T06:57:17.699Z",
+      "days_since_last_cve": 68,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2013": 22,
+        "2014": 29,
+        "2015": 33,
+        "2016": 41,
+        "2017": 34,
+        "2018": 31,
+        "2020": 37,
+        "2019": 41,
+        "2022": 13,
+        "2021": 2,
+        "2023": 11,
+        "2024": 12,
+        "2025": 17,
+        "2026": 9
+      },
+      "years_active_list": [
+        2013,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 7,
+      "epss_elevated_count": 21,
+      "top_cwes": [],
+      "rank": 74
+    },
+    {
+      "name": "synology",
+      "assigner_org_id": "db201096-a0cc-46c7-9a55-61d9e221bf01",
+      "count": 324,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-05-12T20:00:00.000Z",
+      "last_cve_date": "2026-09-18T08:29:33.365Z",
+      "days_since_last_cve": 5,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 46,
+        "2018": 30,
+        "2019": 28,
+        "2020": 14,
+        "2021": 33,
+        "2026": 49,
+        "2022": 35,
+        "2023": 13,
+        "2024": 47,
+        "2025": 29
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 2,
+      "epss_elevated_count": 12,
+      "top_cwes": [],
+      "rank": 75
+    },
+    {
+      "name": "EEF",
+      "assigner_org_id": "6b3ad84c-e1a6-4bf7-a703-f496b71e49db",
+      "count": 311,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-06-16T11:00:54.643Z",
+      "last_cve_date": "2026-09-22T15:51:57.998Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 9,
+        "2026": 302
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 76
+    },
+    {
+      "name": "fedora",
+      "assigner_org_id": "92fb86c3-55a5-4fb5-9c3f-4757b9e96dc5",
+      "count": 307,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-09-14T13:00:00.000Z",
+      "last_cve_date": "2026-09-14T20:05:00.169Z",
+      "days_since_last_cve": 9,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 3,
+        "2019": 2,
+        "2018": 1,
+        "2022": 57,
+        "2023": 65,
+        "2021": 25,
+        "2024": 71,
+        "2025": 43,
+        "2026": 40
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 2,
+      "epss_elevated_count": 6,
+      "top_cwes": [],
+      "rank": 77
+    },
+    {
+      "name": "Nozomi",
+      "assigner_org_id": "bec8025f-a851-46e5-b3a3-058e6b0aa23c",
+      "count": 303,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-02-22T20:31:06.852Z",
+      "last_cve_date": "2026-09-16T13:03:44.204Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 16,
+        "2021": 2,
+        "2023": 15,
+        "2024": 109,
+        "2025": 87,
+        "2026": 74
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 78
+    },
+    {
+      "name": "mongodb",
+      "assigner_org_id": "a39b4221-9bd0-4244-95fc-f3e2e07f1deb",
+      "count": 292,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-08-06T18:32:07.000Z",
+      "last_cve_date": "2026-09-18T17:27:51.644Z",
+      "days_since_last_cve": 5,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 18,
+        "2021": 14,
+        "2019": 3,
+        "2022": 4,
+        "2023": 6,
+        "2024": 18,
+        "2025": 36,
+        "2026": 193
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 79
+    },
+    {
+      "name": "rapid7",
+      "assigner_org_id": "9974b330-7714-4307-a722-5648477acda7",
+      "count": 289,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-12-20T22:00:00.000Z",
+      "last_cve_date": "2026-09-10T03:00:00.939Z",
+      "days_since_last_cve": 13,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "cves_by_year": {
+        "2016": 1,
+        "2022": 26,
+        "2017": 29,
+        "2023": 44,
+        "2018": 8,
+        "2019": 21,
+        "2020": 33,
+        "2021": 26,
+        "2025": 29,
+        "2024": 23,
+        "2026": 49
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 11,
+      "epss_elevated_count": 30,
+      "top_cwes": [],
+      "rank": 80
+    },
+    {
+      "name": "suse",
+      "assigner_org_id": "404e59f5-483d-4b8a-8e7a-e67604dd8afb",
+      "count": 280,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-05-13T14:17:09.831Z",
+      "last_cve_date": "2026-09-21T13:49:21.327Z",
+      "days_since_last_cve": 2,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 39,
+        "2021": 23,
+        "2019": 5,
+        "2022": 28,
+        "2023": 26,
+        "2024": 24,
+        "2025": 43,
+        "2026": 92
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 81
+    },
+    {
+      "name": "ABB",
+      "assigner_org_id": "2b718523-d88f-4f37-9bbd-300c20644bf9",
+      "count": 279,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-12-18T20:19:34.000Z",
+      "last_cve_date": "2026-09-23T05:05:16.249Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 55,
+        "2019": 4,
+        "2021": 7,
+        "2024": 53,
+        "2022": 20,
+        "2023": 29,
+        "2025": 87,
+        "2026": 24
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 4,
+      "top_cwes": [],
+      "rank": 82
+    },
+    {
+      "name": "eclipse",
+      "assigner_org_id": "e51fbebd-6053-4e49-959f-1b94eeb69a2c",
+      "count": 278,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-09-11T16:00:00.000Z",
+      "last_cve_date": "2026-09-22T09:27:34.713Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Open Source"
+      ],
+      "cves_by_year": {
+        "2018": 16,
+        "2019": 31,
+        "2017": 2,
+        "2020": 10,
+        "2021": 33,
+        "2022": 10,
+        "2023": 13,
+        "2024": 22,
+        "2025": 49,
+        "2026": 92
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 7,
+      "epss_elevated_count": 11,
+      "top_cwes": [],
+      "rank": 83
+    },
+    {
+      "name": "Google",
+      "assigner_org_id": "14ed7db2-1595-443d-9d34-6215bf890778",
+      "count": 278,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-03-26T11:31:55.000Z",
+      "last_cve_date": "2026-09-22T21:48:26.539Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 31,
+        "2021": 18,
+        "2023": 62,
+        "2022": 53,
+        "2024": 34,
+        "2025": 47,
+        "2026": 33
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 5,
+      "epss_high_count": 4,
+      "epss_elevated_count": 6,
+      "top_cwes": [],
+      "rank": 84
+    },
+    {
+      "name": "INCD",
+      "assigner_org_id": "a57ee1ae-c9c1-4f40-aa7b-cf10760fde3f",
+      "count": 268,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-09-01T12:35:08.000Z",
+      "last_cve_date": "2026-08-13T09:44:23.924Z",
+      "days_since_last_cve": 41,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 9,
+        "2022": 53,
+        "2023": 84,
+        "2024": 72,
+        "2025": 38,
+        "2026": 12
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 85
+    },
+    {
+      "name": "zephyr",
+      "assigner_org_id": "e2e69745-5e70-4e92-8431-deb5529a81ad",
+      "count": 258,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-04-12T16:20:02.000Z",
+      "last_cve_date": "2026-09-21T21:16:05.314Z",
+      "days_since_last_cve": 2,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 3,
+        "2021": 23,
+        "2020": 17,
+        "2022": 13,
+        "2023": 25,
+        "2024": 20,
+        "2025": 14,
+        "2026": 143
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 86
+    },
+    {
+      "name": "Rockwell",
+      "assigner_org_id": "b73dd486-f505-4403-b634-40b078b177f0",
+      "count": 251,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-09-23T15:24:18.224Z",
+      "last_cve_date": "2026-09-03T13:10:28.638Z",
+      "days_since_last_cve": 20,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 9,
+        "2023": 42,
+        "2024": 72,
+        "2026": 58,
+        "2025": 70
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 3,
+      "epss_elevated_count": 10,
+      "top_cwes": [],
+      "rank": 87
+    },
+    {
+      "name": "Go",
+      "assigner_org_id": "1bb62c36-49e3-4200-9d77-64a1400537cc",
+      "count": 243,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-11-18T00:00:00.000Z",
+      "last_cve_date": "2026-09-02T19:37:05.807Z",
+      "days_since_last_cve": 21,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 52,
+        "2020": 2,
+        "2023": 40,
+        "2024": 20,
+        "2025": 38,
+        "2026": 91
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 88
+    },
+    {
+      "name": "freebsd",
+      "assigner_org_id": "63664ac6-956c-4cba-a5d0-f46076e16109",
+      "count": 238,
+      "years_active": 22,
+      "first_cve_year": 2005,
+      "last_cve_year": 2026,
+      "first_cve_date": "2005-04-13T04:00:00.000Z",
+      "last_cve_date": "2026-08-26T05:39:42.893Z",
+      "days_since_last_cve": 28,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2005": 6,
+        "2006": 13,
+        "2007": 5,
+        "2008": 4,
+        "2009": 2,
+        "2010": 2,
+        "2011": 3,
+        "2017": 3,
+        "2018": 22,
+        "2019": 19,
+        "2020": 22,
+        "2021": 21,
+        "2022": 1,
+        "2024": 33,
+        "2023": 12,
+        "2025": 4,
+        "2026": 66
+      },
+      "years_active_list": [
+        2005,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 5,
+      "top_cwes": [],
+      "rank": 89
+    },
+    {
+      "name": "ProgressSoftware",
+      "assigner_org_id": "f9fea0b6-671e-4eea-8fde-31911902ae05",
+      "count": 233,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-09-20T16:04:54.432Z",
+      "last_cve_date": "2026-09-11T12:28:49.216Z",
+      "days_since_last_cve": 12,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 22,
+        "2024": 89,
+        "2025": 34,
+        "2026": 88
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 6,
+      "epss_high_count": 13,
+      "epss_elevated_count": 32,
+      "top_cwes": [],
+      "rank": 90
+    },
+    {
+      "name": "Zoom",
+      "assigner_org_id": "99b9af0d-a833-4a5d-9e2f-8b1324f35351",
+      "count": 230,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-09-27T13:55:30.000Z",
+      "last_cve_date": "2026-08-11T16:02:28.384Z",
+      "days_since_last_cve": 43,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 20,
+        "2022": 29,
+        "2023": 62,
+        "2024": 39,
+        "2025": 61,
+        "2026": 19
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 91
+    },
+    {
+      "name": "Liferay",
+      "assigner_org_id": "8b54e794-c6f0-462e-9faa-c1001a673ac3",
+      "count": 210,
+      "years_active": 3,
+      "first_cve_year": 2023,
+      "last_cve_year": 2025,
+      "first_cve_date": "2023-05-24T12:16:36.342Z",
+      "last_cve_date": "2025-11-01T02:42:50.698Z",
+      "days_since_last_cve": 326,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 40,
+        "2023": 26,
+        "2025": 144
+      },
+      "years_active_list": [
+        2023,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 92
+    },
+    {
+      "name": "sonicwall",
+      "assigner_org_id": "44b2ff79-1416-4492-88bb-ed0da00c7315",
+      "count": 206,
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "first_cve_date": "2018-08-03T20:00:00.000Z",
+      "last_cve_date": "2026-09-04T18:22:16.711Z",
+      "days_since_last_cve": 19,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 16,
+        "2018": 1,
+        "2020": 17,
+        "2021": 32,
+        "2022": 20,
+        "2023": 34,
+        "2024": 21,
+        "2025": 31,
+        "2026": 34
+      },
+      "years_active_list": [
+        2018,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 19,
+      "epss_high_count": 16,
+      "epss_elevated_count": 37,
+      "top_cwes": [],
+      "rank": 93
+    },
+    {
+      "name": "ivanti",
+      "assigner_org_id": "3c1d8aa1-5a33-4ea4-8992-aadd6440af75",
+      "count": 206,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-08-13T18:10:55.710Z",
+      "last_cve_date": "2026-09-08T14:43:54.531Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 68,
+        "2025": 99,
+        "2026": 39
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 17,
+      "epss_high_count": 19,
+      "epss_elevated_count": 46,
+      "top_cwes": [],
+      "rank": 94
+    },
+    {
+      "name": "NCSC.ch",
+      "assigner_org_id": "455daabc-a392-441d-aa46-37d35189897c",
+      "count": 204,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-11-16T11:45:20.110Z",
+      "last_cve_date": "2026-09-03T08:45:42.216Z",
+      "days_since_last_cve": 20,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2021": 17,
+        "2022": 13,
+        "2023": 18,
+        "2024": 24,
+        "2025": 35,
+        "2026": 97
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 95
+    },
+    {
+      "name": "SolarWinds",
+      "assigner_org_id": "49f11609-934d-4621-84e6-e02e032104d6",
+      "count": 203,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-07-14T20:55:25.167Z",
+      "last_cve_date": "2026-09-22T19:12:44.576Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 33,
+        "2022": 24,
+        "2023": 46,
+        "2024": 44,
+        "2025": 21,
+        "2026": 35
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 9,
+      "epss_high_count": 21,
+      "epss_elevated_count": 34,
+      "top_cwes": [],
+      "rank": 96
+    },
+    {
+      "name": "wikimedia-foundation",
+      "assigner_org_id": "c4f26cc8-17ff-4c99-b5e2-38fc1793eacc",
+      "count": 201,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-10-04T23:53:50.766Z",
+      "last_cve_date": "2026-09-23T18:50:13.056Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 7,
+        "2026": 106,
+        "2025": 88
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 97
+    },
+    {
+      "name": "CIRCL",
+      "assigner_org_id": "5a6e4751-2f3f-4070-9419-94fb35b644e8",
+      "count": 200,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-05-07T12:07:59.273Z",
+      "last_cve_date": "2026-09-22T15:09:09.738Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 200
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 98
+    },
+    {
+      "name": "TuranSec",
+      "assigner_org_id": "309f9ea4-e3e9-4c6c-b79d-e8eb01244f2c",
+      "count": 199,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-03-10T11:07:07.393Z",
+      "last_cve_date": "2026-08-11T11:22:47.134Z",
+      "days_since_last_cve": 43,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 199
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 99
+    },
+    {
+      "name": "cisa-cg",
+      "assigner_org_id": "9119a7d8-5eab-497f-8521-727c672e3725",
+      "count": 195,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-09-05T20:15:57.824Z",
+      "last_cve_date": "2026-09-23T16:07:10.048Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT",
+        "Government"
+      ],
+      "cves_by_year": {
+        "2026": 81,
+        "2024": 21,
+        "2023": 13,
+        "2025": 80
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 8,
+      "epss_high_count": 3,
+      "epss_elevated_count": 4,
+      "top_cwes": [],
+      "rank": 100
+    },
+    {
+      "name": "krcert",
+      "assigner_org_id": "cdd7a122-0fae-4202-8d86-14efbacc2863",
+      "count": 191,
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "first_cve_date": "2018-01-17T17:00:00.000Z",
+      "last_cve_date": "2026-02-27T02:01:12.377Z",
+      "days_since_last_cve": 208,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2018": 9,
+        "2019": 29,
+        "2020": 43,
+        "2021": 49,
+        "2022": 36,
+        "2023": 11,
+        "2024": 8,
+        "2025": 3,
+        "2026": 3
+      },
+      "years_active_list": [
+        2018,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 101
+    },
+    {
+      "name": "Acronis",
+      "assigner_org_id": "73dc0fef-1c66-4a72-9d2d-0a0f4012c175",
+      "count": 189,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-11-29T18:18:51.474Z",
+      "last_cve_date": "2026-09-17T22:57:18.089Z",
+      "days_since_last_cve": 5,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 21,
+        "2021": 7,
+        "2023": 61,
+        "2024": 33,
+        "2025": 27,
+        "2026": 40
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 102
+    },
+    {
+      "name": "zte",
+      "assigner_org_id": "6786b568-6808-4982-b61f-398b0d9679eb",
+      "count": 188,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-09-19T14:00:00.000Z",
+      "last_cve_date": "2026-09-20T09:15:43.868Z",
+      "days_since_last_cve": 3,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 4,
+        "2018": 16,
+        "2019": 23,
+        "2020": 20,
+        "2021": 30,
+        "2023": 14,
+        "2022": 13,
+        "2024": 17,
+        "2025": 21,
+        "2026": 30
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 3,
+      "epss_elevated_count": 5,
+      "top_cwes": [],
+      "rank": 103
+    },
+    {
+      "name": "TPLink",
+      "assigner_org_id": "f23511db-6c3e-4e32-a477-6aa17d310630",
+      "count": 187,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-04-18T00:03:00.275Z",
+      "last_cve_date": "2026-09-10T23:35:53.023Z",
+      "days_since_last_cve": 12,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 159,
+        "2025": 28
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 104
+    },
+    {
+      "name": "AMZN",
+      "assigner_org_id": "ff89ba41-3aa1-4d27-914a-91399e9639e5",
+      "count": 186,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-10-21T23:19:31.138Z",
+      "last_cve_date": "2026-09-22T20:04:44.360Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 10,
+        "2025": 38,
+        "2026": 138
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 105
+    },
+    {
+      "name": "Meta",
+      "assigner_org_id": "4fc57720-52fe-4431-a0fb-3d2c8747b827",
+      "count": 184,
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "first_cve_date": "2018-12-03T14:00:00.000Z",
+      "last_cve_date": "2026-07-23T16:27:01.658Z",
+      "days_since_last_cve": 62,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 39,
+        "2018": 14,
+        "2020": 31,
+        "2021": 28,
+        "2022": 23,
+        "2023": 16,
+        "2024": 5,
+        "2025": 19,
+        "2026": 9
+      },
+      "years_active_list": [
+        2018,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 5,
+      "epss_high_count": 4,
+      "epss_elevated_count": 11,
+      "top_cwes": [],
+      "rank": 106
+    },
+    {
+      "name": "JFROG",
+      "assigner_org_id": "48a46f29-ae42-4e1d-90dd-c1676c1e5e6d",
+      "count": 178,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-10-19T00:00:00.000Z",
+      "last_cve_date": "2026-09-23T10:03:06.643Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 32,
+        "2021": 17,
+        "2023": 10,
+        "2024": 28,
+        "2025": 26,
+        "2026": 65
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 5,
+      "epss_high_count": 4,
+      "epss_elevated_count": 8,
+      "top_cwes": [],
+      "rank": 107
+    },
+    {
+      "name": "OpenHarmony",
+      "assigner_org_id": "0cf5dd6e-1214-4398-a481-30441e48fafd",
+      "count": 177,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-09-09T14:39:56.347Z",
+      "last_cve_date": "2026-05-19T03:08:47.111Z",
+      "days_since_last_cve": 127,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 16,
+        "2023": 17,
+        "2024": 61,
+        "2025": 66,
+        "2026": 17
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 108
+    },
+    {
+      "name": "brocade",
+      "assigner_org_id": "87b297d7-335e-4844-9551-11b97995a791",
+      "count": 176,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-10-31T21:00:00.000Z",
+      "last_cve_date": "2026-09-23T20:45:24.825Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 9,
+        "2016": 1,
+        "2018": 14,
+        "2020": 16,
+        "2019": 9,
+        "2021": 16,
+        "2022": 25,
+        "2023": 18,
+        "2024": 36,
+        "2025": 17,
+        "2026": 15
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 109
+    },
+    {
+      "name": "DEVOLUTIONS",
+      "assigner_org_id": "bfee16bd-18e6-446c-9a65-f5b2e3d89c23",
+      "count": 176,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-10-18T13:22:57.000Z",
+      "last_cve_date": "2026-09-15T20:14:31.376Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 1,
+        "2022": 8,
+        "2023": 30,
+        "2024": 28,
+        "2025": 34,
+        "2026": 75
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 110
+    },
+    {
+      "name": "tibco",
+      "assigner_org_id": "4f830c72-39e4-45f6-a99f-78cc01ae04db",
+      "count": 175,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-05-09T20:00:00.000Z",
+      "last_cve_date": "2026-03-24T20:44:06.781Z",
+      "days_since_last_cve": 183,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 8,
+        "2018": 22,
+        "2019": 35,
+        "2020": 15,
+        "2021": 31,
+        "2022": 33,
+        "2023": 14,
+        "2024": 10,
+        "2025": 5,
+        "2026": 2
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 111
+    },
+    {
+      "name": "OX",
+      "assigner_org_id": "8ce71d90-2354-404b-a86e-bec2cc4e6981",
+      "count": 171,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-04-04T14:37:29.388Z",
+      "last_cve_date": "2026-08-28T10:12:33.625Z",
+      "days_since_last_cve": 26,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 34,
+        "2024": 27,
+        "2025": 14,
+        "2026": 96
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 112
+    },
+    {
+      "name": "Esri",
+      "assigner_org_id": "cedc17bb-4939-4f40-a1f4-30ae8af1094e",
+      "count": 167,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-03-25T18:37:37.051Z",
+      "last_cve_date": "2026-08-21T20:54:13.967Z",
+      "days_since_last_cve": 33,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 22,
+        "2022": 31,
+        "2023": 14,
+        "2025": 53,
+        "2024": 25,
+        "2026": 22
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 113
+    },
+    {
+      "name": "XEN",
+      "assigner_org_id": "23aa2041-22e1-471f-9209-9b7396fa234f",
+      "count": 166,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-04-06T18:07:41.000Z",
+      "last_cve_date": "2026-09-08T12:11:21.789Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 57,
+        "2021": 24,
+        "2023": 9,
+        "2024": 23,
+        "2025": 11,
+        "2026": 42
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 114
+    },
+    {
+      "name": "Zyxel",
+      "assigner_org_id": "96e50032-ad0d-4058-a115-4d2c13821f9f",
+      "count": 166,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-07-02T10:29:07.000Z",
+      "last_cve_date": "2026-08-04T02:28:53.719Z",
+      "days_since_last_cve": 50,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 21,
+        "2021": 9,
+        "2023": 60,
+        "2024": 37,
+        "2025": 16,
+        "2026": 23
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 9,
+      "epss_high_count": 9,
+      "epss_elevated_count": 21,
+      "top_cwes": [],
+      "rank": 115
+    },
+    {
+      "name": "Kaspersky",
+      "assigner_org_id": "e45d732a-8f6b-4b6b-be76-7420f6a2b988",
+      "count": 163,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-08-25T20:00:00.000Z",
+      "last_cve_date": "2026-08-20T18:03:38.982Z",
+      "days_since_last_cve": 34,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 9,
+        "2018": 50,
+        "2019": 48,
+        "2025": 5,
+        "2021": 12,
+        "2020": 7,
+        "2022": 3,
+        "2023": 7,
+        "2024": 13,
+        "2026": 9
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 3,
+      "epss_high_count": 0,
+      "epss_elevated_count": 7,
+      "top_cwes": [],
+      "rank": 116
+    },
+    {
+      "name": "SICK AG",
+      "assigner_org_id": "a6863dd2-93fc-443d-bef1-79f0b5020988",
+      "count": 162,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-07-29T13:18:55.000Z",
+      "last_cve_date": "2026-09-11T08:27:39.772Z",
+      "days_since_last_cve": 12,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 4,
+        "2021": 4,
+        "2022": 18,
+        "2023": 37,
+        "2024": 9,
+        "2025": 68,
+        "2026": 22
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 117
+    },
+    {
+      "name": "dwf",
+      "assigner_org_id": "7556d962-6fb7-411e-85fa-6cd62f095ba8",
+      "count": 157,
+      "years_active": 1,
+      "first_cve_year": 2019,
+      "last_cve_year": 2019,
+      "first_cve_date": "2019-03-27T17:55:00.000Z",
+      "last_cve_date": "2019-10-15T17:35:57.000Z",
+      "days_since_last_cve": 2535,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 157
+      },
+      "years_active_list": [
+        2019,
+        2019
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 118
+    },
+    {
+      "name": "Mend",
+      "assigner_org_id": "478c68dd-22c1-4a41-97cd-654224dfacff",
+      "count": 150,
+      "years_active": 3,
+      "first_cve_year": 2020,
+      "last_cve_year": 2022,
+      "first_cve_date": "2020-11-10T15:58:51.000Z",
+      "last_cve_date": "2022-10-17T18:25:09.233Z",
+      "days_since_last_cve": 1437,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 16,
+        "2021": 75,
+        "2022": 59
+      },
+      "years_active_list": [
+        2020,
+        2022
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 3,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 119
+    },
+    {
+      "name": "CERT-In",
+      "assigner_org_id": "66834db9-ab24-42b4-be80-296b2e40335c",
+      "count": 147,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-02-09T22:05:30.830Z",
+      "last_cve_date": "2026-09-01T12:44:17.855Z",
+      "days_since_last_cve": 22,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2023": 10,
+        "2022": 5,
+        "2024": 77,
+        "2025": 29,
+        "2026": 26
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 120
+    },
+    {
+      "name": "Zohocorp",
+      "assigner_org_id": "0fc0942c-577d-436f-ae8e-945763c79b02",
+      "count": 145,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-01-11T07:57:12.987Z",
+      "last_cve_date": "2026-09-23T13:41:27.385Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 54,
+        "2025": 40,
+        "2026": 51
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 4,
+      "top_cwes": [],
+      "rank": 121
+    },
+    {
+      "name": "ConcreteCMS",
+      "assigner_org_id": "ff5b8ace-8b95-4078-9743-eac1ca5451de",
+      "count": 138,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-02-09T18:58:24.672Z",
+      "last_cve_date": "2026-09-16T17:16:09.563Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 17,
+        "2025": 4,
+        "2026": 117
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 122
+    },
+    {
+      "name": "Mitsubishi",
+      "assigner_org_id": "e0f77b61-78fd-4786-b3fb-1ee347a748ad",
+      "count": 137,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-01-29T14:54:32.000Z",
+      "last_cve_date": "2026-09-17T08:15:27.769Z",
+      "days_since_last_cve": 6,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 22,
+        "2022": 40,
+        "2023": 23,
+        "2024": 22,
+        "2025": 17,
+        "2026": 13
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 123
+    },
+    {
+      "name": "Arista",
+      "assigner_org_id": "c8b34d1a-69ae-45c3-88fe-f3b3d44f39b7",
+      "count": 136,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-09-09T12:38:21.000Z",
+      "last_cve_date": "2026-09-22T07:37:24.300Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 11,
+        "2021": 7,
+        "2023": 11,
+        "2026": 66,
+        "2024": 3,
+        "2025": 38
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 3,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 124
+    },
+    {
+      "name": "isc",
+      "assigner_org_id": "404fd4d2-a609-4245-b543-2c944a302a22",
+      "count": 135,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-01-16T20:00:00.000Z",
+      "last_cve_date": "2026-09-16T14:17:11.956Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 38,
+        "2020": 9,
+        "2021": 7,
+        "2022": 13,
+        "2023": 9,
+        "2024": 10,
+        "2025": 14,
+        "2026": 35
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 5,
+      "epss_elevated_count": 25,
+      "top_cwes": [],
+      "rank": 125
+    },
+    {
+      "name": "netapp",
+      "assigner_org_id": "11fdca00-0482-4c88-a206-37f9c182c87d",
+      "count": 134,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-11-09T19:00:00.000Z",
+      "last_cve_date": "2026-08-28T21:45:53.370Z",
+      "days_since_last_cve": 26,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 4,
+        "2018": 12,
+        "2019": 25,
+        "2020": 17,
+        "2021": 28,
+        "2022": 10,
+        "2023": 12,
+        "2024": 11,
+        "2025": 7,
+        "2026": 8
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 126
+    },
+    {
+      "name": "bosch",
+      "assigner_org_id": "c95f66b2-7e7c-41c5-8f09-6f86ec68659c",
+      "count": 134,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-05-29T19:40:01.253Z",
+      "last_cve_date": "2026-09-10T09:05:36.803Z",
+      "days_since_last_cve": 13,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 9,
+        "2021": 27,
+        "2020": 6,
+        "2022": 13,
+        "2023": 18,
+        "2024": 29,
+        "2026": 13,
+        "2025": 19
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 127
+    },
+    {
+      "name": "GitHub_P",
+      "assigner_org_id": "82327ea3-741d-41e4-88f8-2cf9e791e760",
+      "count": 134,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-06-03T13:31:24.000Z",
+      "last_cve_date": "2026-09-22T20:43:59.193Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Open Source"
+      ],
+      "cves_by_year": {
+        "2021": 11,
+        "2020": 3,
+        "2022": 11,
+        "2023": 25,
+        "2024": 39,
+        "2025": 11,
+        "2026": 34
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 2,
+      "epss_elevated_count": 4,
+      "top_cwes": [],
+      "rank": 128
+    },
+    {
+      "name": "Silabs",
+      "assigner_org_id": "030b2754-1501-44a4-bef8-48be86a33bf4",
+      "count": 132,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-11-02T17:25:38.758Z",
+      "last_cve_date": "2026-09-10T17:15:49.895Z",
+      "days_since_last_cve": 13,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 5,
+        "2024": 25,
+        "2023": 31,
+        "2025": 29,
+        "2026": 42
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 129
+    },
+    {
+      "name": "openssl",
+      "assigner_org_id": "3a12439a-ef3a-4c79-92e6-6081a721f1e5",
+      "count": 130,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-05-04T19:00:00.000Z",
+      "last_cve_date": "2026-08-25T13:00:25.067Z",
+      "days_since_last_cve": 29,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 10,
+        "2018": 6,
+        "2019": 7,
+        "2020": 3,
+        "2021": 8,
+        "2022": 13,
+        "2023": 19,
+        "2024": 9,
+        "2025": 6,
+        "2026": 49
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 18,
+      "epss_elevated_count": 36,
+      "top_cwes": [],
+      "rank": 130
+    },
+    {
+      "name": "SEC-VLab",
+      "assigner_org_id": "551230f0-3615-47bd-b7cc-93e92e730bbf",
+      "count": 126,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-11-22T11:22:58.159Z",
+      "last_cve_date": "2026-06-18T08:32:14.717Z",
+      "days_since_last_cve": 97,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 40,
+        "2023": 2,
+        "2025": 29,
+        "2026": 55
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 131
+    },
+    {
+      "name": "openjs",
+      "assigner_org_id": "ce714d77-add3-4f53-aff5-83d477b104bb",
+      "count": 126,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-07-17T15:26:45.427Z",
+      "last_cve_date": "2026-09-17T06:55:42.300Z",
+      "days_since_last_cve": 6,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 3,
+        "2026": 123
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 132
+    },
+    {
+      "name": "GovTech CSG",
+      "assigner_org_id": "1a37b84a-8e51-4525-b3d6-87e2fae01dbd",
+      "count": 124,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-11-23T21:37:07.000Z",
+      "last_cve_date": "2026-03-24T06:05:21.161Z",
+      "days_since_last_cve": 183,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Government"
+      ],
+      "cves_by_year": {
+        "2021": 3,
+        "2022": 11,
+        "2023": 2,
+        "2024": 2,
+        "2025": 25,
+        "2026": 81
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 133
+    },
+    {
+      "name": "HashiCorp",
+      "assigner_org_id": "67fedba0-ff2e-4543-ba5b-aa93e87718cc",
+      "count": 124,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-11-10T05:34:52.468Z",
+      "last_cve_date": "2026-09-15T19:45:07.836Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 3,
+        "2023": 29,
+        "2024": 24,
+        "2025": 25,
+        "2026": 43
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 134
+    },
+    {
+      "name": "Checkmk",
+      "assigner_org_id": "f7d6281c-4801-44ce-ace2-493291dedb0f",
+      "count": 123,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-01-09T16:11:16.227Z",
+      "last_cve_date": "2026-09-22T10:43:28.959Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 31,
+        "2024": 35,
+        "2026": 30,
+        "2025": 27
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 135
+    },
+    {
+      "name": "PostgreSQL",
+      "assigner_org_id": "f86ef6dc-4d3a-42ad-8f28-e6d5547a5007",
+      "count": 123,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-02-08T13:00:02.411Z",
+      "last_cve_date": "2026-09-23T16:04:48.392Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 16,
+        "2025": 19,
+        "2026": 88
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 4,
+      "epss_elevated_count": 5,
+      "top_cwes": [],
+      "rank": 136
+    },
+    {
+      "name": "checkpoint",
+      "assigner_org_id": "897c38be-0345-43cd-b6cf-fe179e0c4f45",
+      "count": 116,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-01-11T06:02:00.000Z",
+      "last_cve_date": "2026-09-22T12:59:01.057Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 8,
+        "2018": 12,
+        "2019": 27,
+        "2020": 16,
+        "2021": 7,
+        "2022": 9,
+        "2023": 4,
+        "2024": 4,
+        "2025": 10,
+        "2026": 19
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 8,
+      "epss_high_count": 5,
+      "epss_elevated_count": 19,
+      "top_cwes": [],
+      "rank": 137
+    },
+    {
+      "name": "Hitachi Energy",
+      "assigner_org_id": "e383dce4-0c27-4495-91c4-0db157728d17",
+      "count": 115,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-07-14T13:15:37.070Z",
+      "last_cve_date": "2026-09-03T07:59:47.162Z",
+      "days_since_last_cve": 20,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Government"
+      ],
+      "cves_by_year": {
+        "2021": 9,
+        "2022": 17,
+        "2023": 28,
+        "2024": 29,
+        "2025": 20,
+        "2026": 12
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 138
+    },
+    {
+      "name": "Splunk",
+      "assigner_org_id": "42b59230-ec95-491e-8425-5a5befa1a469",
+      "count": 110,
+      "years_active": 4,
+      "first_cve_year": 2022,
+      "last_cve_year": 2025,
+      "first_cve_date": "2022-03-25T18:02:43.000Z",
+      "last_cve_date": "2025-01-30T17:04:49.734Z",
+      "days_since_last_cve": 601,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 31,
+        "2023": 36,
+        "2024": 41,
+        "2025": 2
+      },
+      "years_active_list": [
+        2022,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 2,
+      "epss_elevated_count": 7,
+      "top_cwes": [],
+      "rank": 139
+    },
+    {
+      "name": "DIVD",
+      "assigner_org_id": "b87402ff-ae37-4194-9dae-31abdbd6f217",
+      "count": 107,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-02-21T00:00:00.000Z",
+      "last_cve_date": "2026-07-17T09:30:36.710Z",
+      "days_since_last_cve": 68,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 27,
+        "2022": 13,
+        "2024": 13,
+        "2025": 44,
+        "2026": 10
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 140
+    },
+    {
+      "name": "Bitdefender",
+      "assigner_org_id": "b3d5ebe7-963e-41fb-98e1-2edaeabb8f82",
+      "count": 106,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-01-27T13:55:17.731Z",
+      "last_cve_date": "2026-07-14T07:11:50.520Z",
+      "days_since_last_cve": 71,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 15,
+        "2020": 27,
+        "2025": 11,
+        "2021": 17,
+        "2023": 10,
+        "2024": 23,
+        "2026": 3
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 141
+    },
+    {
+      "name": "3DS",
+      "assigner_org_id": "f5a594e6-46a7-4e60-8a08-0a786e70e433",
+      "count": 106,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-03-09T16:30:42.445Z",
+      "last_cve_date": "2026-09-21T12:07:15.359Z",
+      "days_since_last_cve": 2,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 26,
+        "2023": 13,
+        "2025": 46,
+        "2026": 21
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 3,
+      "epss_high_count": 3,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 142
+    },
+    {
+      "name": "wolfSSL",
+      "assigner_org_id": "50d2cd11-d01a-48ed-9441-5bfce9d63b27",
+      "count": 104,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-07-17T21:13:10.623Z",
+      "last_cve_date": "2026-08-28T14:43:43.099Z",
+      "days_since_last_cve": 26,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2024": 12,
+        "2025": 15,
+        "2026": 76
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 143
+    },
+    {
+      "name": "samsung.tv_appliance",
+      "assigner_org_id": "ca193ba2-0cff-4e34-b04e-1ea07103c6fe",
+      "count": 102,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-11-08T06:32:40.430Z",
+      "last_cve_date": "2026-09-15T21:34:04.487Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 2,
+        "2024": 7,
+        "2025": 30,
+        "2026": 63
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 1,
+      "epss_elevated_count": 5,
+      "top_cwes": [],
+      "rank": 144
+    },
+    {
+      "name": "kubernetes",
+      "assigner_org_id": "a6081bf6-c852-4425-ad4f-a67919267565",
+      "count": 101,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-09-14T13:00:00.000Z",
+      "last_cve_date": "2026-07-23T18:43:25.357Z",
+      "days_since_last_cve": 62,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 6,
+        "2017": 1,
+        "2020": 15,
+        "2019": 11,
+        "2021": 12,
+        "2022": 5,
+        "2023": 20,
+        "2024": 7,
+        "2025": 15,
+        "2026": 9
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 5,
+      "epss_elevated_count": 11,
+      "top_cwes": [],
+      "rank": 145
+    },
+    {
+      "name": "NI",
+      "assigner_org_id": "bca5b2e8-03a4-4781-b4ca-c6a078c0bfd4",
+      "count": 101,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-10-05T15:26:45.467Z",
+      "last_cve_date": "2026-09-17T18:42:17.190Z",
+      "days_since_last_cve": 6,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 3,
+        "2024": 25,
+        "2025": 36,
+        "2026": 37
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 146
+    },
+    {
+      "name": "jci",
+      "assigner_org_id": "7281d04a-a537-43df-bfb4-fa4110af9d01",
+      "count": 99,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-06-18T13:23:05.440Z",
+      "last_cve_date": "2026-08-27T14:42:33.253Z",
+      "days_since_last_cve": 27,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 4,
+        "2020": 7,
+        "2021": 12,
+        "2023": 12,
+        "2022": 14,
+        "2024": 17,
+        "2025": 11,
+        "2026": 22
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 147
+    },
+    {
+      "name": "Gitea",
+      "assigner_org_id": "88ee5874-cf24-4952-aea0-31affedb7ff2",
+      "count": 97,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-08-06T03:23:21.692Z",
+      "last_cve_date": "2026-08-13T16:48:52.623Z",
+      "days_since_last_cve": 41,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2026": 96
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 148
+    },
+    {
+      "name": "GRAFANA",
+      "assigner_org_id": "57da9224-a3e2-4646-9d0e-c4dc2e05e7da",
+      "count": 96,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-03-01T15:35:55.259Z",
+      "last_cve_date": "2026-09-17T20:47:01.006Z",
+      "days_since_last_cve": 6,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 14,
+        "2023": 11,
+        "2025": 16,
+        "2026": 55
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 3,
+      "epss_elevated_count": 7,
+      "top_cwes": [],
+      "rank": 149
+    },
+    {
+      "name": "Foxit",
+      "assigner_org_id": "14984358-7092-470d-8f34-ade47a7658a2",
+      "count": 96,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-12-19T01:51:22.461Z",
+      "last_cve_date": "2026-09-23T07:51:31.844Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 15,
+        "2026": 81
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 150
+    },
+    {
+      "name": "Perforce",
+      "assigner_org_id": "ca2a266c-be2f-4d4b-92d0-47b76b1a9c4e",
+      "count": 94,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-02-08T22:00:00.000Z",
+      "last_cve_date": "2026-09-11T14:40:53.491Z",
+      "days_since_last_cve": 12,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 9,
+        "2018": 18,
+        "2019": 5,
+        "2020": 4,
+        "2021": 9,
+        "2025": 11,
+        "2022": 4,
+        "2023": 9,
+        "2024": 17,
+        "2026": 8
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 151
+    },
+    {
+      "name": "WatchGuard",
+      "assigner_org_id": "5d1c2695-1a31-4499-88ae-e847036fd7e3",
+      "count": 94,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-05-16T17:56:43.521Z",
+      "last_cve_date": "2026-09-23T12:52:04.902Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 7,
+        "2025": 26,
+        "2026": 61
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 152
+    },
+    {
+      "name": "php",
+      "assigner_org_id": "dd77f84a-d19a-4638-8c3d-a322d820ed2b",
+      "count": 93,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-04-18T16:57:00.954Z",
+      "last_cve_date": "2026-07-30T11:22:53.918Z",
+      "days_since_last_cve": 55,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 16,
+        "2020": 13,
+        "2021": 7,
+        "2022": 7,
+        "2025": 13,
+        "2023": 6,
+        "2024": 17,
+        "2026": 14
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 3,
+      "epss_elevated_count": 10,
+      "top_cwes": [],
+      "rank": 153
+    },
+    {
+      "name": "WSO2",
+      "assigner_org_id": "ed10eef1-636d-4fbe-9993-6890dfa878f8",
+      "count": 93,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-12-15T09:16:27.473Z",
+      "last_cve_date": "2026-09-15T09:53:54.532Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 6,
+        "2025": 39,
+        "2026": 48
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 154
+    },
+    {
+      "name": "Axis",
+      "assigner_org_id": "f2daf9a0-02c2-4b83-a01d-63b3b304b807",
+      "count": 92,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-08-25T18:29:41.000Z",
+      "last_cve_date": "2026-08-11T05:52:33.481Z",
+      "days_since_last_cve": 43,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 2,
+        "2021": 4,
+        "2023": 16,
+        "2024": 19,
+        "2025": 36,
+        "2026": 15
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 155
+    },
+    {
+      "name": "Zabbix",
+      "assigner_org_id": "72de3e22-0555-4a0d-ae81-9249e0f0a1e8",
+      "count": 92,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-01-13T15:50:39.137Z",
+      "last_cve_date": "2026-08-18T12:21:29.618Z",
+      "days_since_last_cve": 36,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 14,
+        "2023": 18,
+        "2024": 24,
+        "2025": 16,
+        "2026": 20
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 5,
+      "epss_elevated_count": 7,
+      "top_cwes": [],
+      "rank": 156
+    },
+    {
+      "name": "ASRG",
+      "assigner_org_id": "c15abc07-96a9-4d11-a503-5d621bfe42ba",
+      "count": 88,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-06-01T05:34:48.206Z",
+      "last_cve_date": "2026-06-25T14:11:18.921Z",
+      "days_since_last_cve": 90,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 40,
+        "2025": 16,
+        "2023": 13,
+        "2026": 19
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 157
+    },
+    {
+      "name": "imaginationtech",
+      "assigner_org_id": "367425dc-4d06-4041-9650-c2dc6aaa27ce",
+      "count": 87,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-10-14T08:17:01.686Z",
+      "last_cve_date": "2026-09-04T01:53:55.981Z",
+      "days_since_last_cve": 19,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 38,
+        "2024": 9,
+        "2026": 40
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 158
+    },
+    {
+      "name": "Tanium",
+      "assigner_org_id": "3938794e-25f5-4123-a1ba-5cbd7f104512",
+      "count": 86,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-11-19T02:44:55.622Z",
+      "last_cve_date": "2026-09-16T19:43:03.949Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1,
+        "2026": 85
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 159
+    },
+    {
+      "name": "OTRS",
+      "assigner_org_id": "2e1bf29f-dc29-4ed8-830c-7b9348b6f0e8",
+      "count": 82,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-01-10T15:08:55.756Z",
+      "last_cve_date": "2026-06-01T03:33:23.990Z",
+      "days_since_last_cve": 114,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 14,
+        "2021": 18,
+        "2022": 14,
+        "2023": 11,
+        "2025": 7,
+        "2024": 9,
+        "2026": 9
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 160
+    },
+    {
+      "name": "ca",
+      "assigner_org_id": "e291eae9-7c0a-46ac-ba7d-5251811f8b7f",
+      "count": 80,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-09-22T14:00:00.000Z",
+      "last_cve_date": "2026-05-19T18:42:00.155Z",
+      "days_since_last_cve": 127,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 27,
+        "2017": 2,
+        "2019": 11,
+        "2020": 15,
+        "2021": 2,
+        "2022": 11,
+        "2026": 11,
+        "2025": 1
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 2,
+      "epss_elevated_count": 5,
+      "top_cwes": [],
+      "rank": 161
+    },
+    {
+      "name": "PSF",
+      "assigner_org_id": "28c92f92-d60d-412d-b760-e73465c3df22",
+      "count": 80,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-10-24T20:56:05.469Z",
+      "last_cve_date": "2026-09-14T19:14:03.873Z",
+      "days_since_last_cve": 9,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 2,
+        "2024": 14,
+        "2025": 17,
+        "2026": 47
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 162
+    },
+    {
+      "name": "Hitachi",
+      "assigner_org_id": "50d0f415-c707-4733-9afc-8f6c0e9b3f82",
+      "count": 78,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-08-29T13:46:00.000Z",
+      "last_cve_date": "2026-09-08T08:15:00.929Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 19,
+        "2022": 11,
+        "2024": 17,
+        "2025": 13,
+        "2026": 18
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 163
+    },
+    {
+      "name": "GV",
+      "assigner_org_id": "0df08a0e-a200-4957-9bb0-084f562506f9",
+      "count": 78,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-03-23T01:05:31.952Z",
+      "last_cve_date": "2026-09-17T01:50:05.966Z",
+      "days_since_last_cve": 6,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 78
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 164
+    },
+    {
+      "name": "NLnet Labs",
+      "assigner_org_id": "206fc3a0-e175-490b-9eaa-a5738056c9f6",
+      "count": 76,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-12-07T21:46:47.878Z",
+      "last_cve_date": "2026-09-16T08:32:25.398Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 1,
+        "2021": 4,
+        "2022": 4,
+        "2023": 4,
+        "2024": 3,
+        "2025": 3,
+        "2026": 57
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 165
+    },
+    {
+      "name": "Moxa",
+      "assigner_org_id": "2e0a0ee2-d866-482a-9f5e-ac03d156dbaa",
+      "count": 75,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-05-22T05:38:29.841Z",
+      "last_cve_date": "2026-09-18T09:32:59.993Z",
+      "days_since_last_cve": 5,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 30,
+        "2025": 19,
+        "2024": 15,
+        "2026": 11
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 166
+    },
+    {
+      "name": "Octopus",
+      "assigner_org_id": "6f4f8c89-ef06-4bae-a2a5-6734ddf76272",
+      "count": 72,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-06-17T13:22:17.000Z",
+      "last_cve_date": "2026-09-16T07:29:27.076Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 8,
+        "2022": 24,
+        "2023": 14,
+        "2024": 9,
+        "2025": 7,
+        "2026": 10
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 167
+    },
+    {
+      "name": "TYPO3",
+      "assigner_org_id": "f4fb688c-4412-4426-b4b8-421ecf27b14a",
+      "count": 72,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-07-22T10:18:38.449Z",
+      "last_cve_date": "2026-09-08T09:18:41.605Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 12,
+        "2026": 60
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 168
+    },
+    {
+      "name": "ENISA",
+      "assigner_org_id": "a6d3dc9e-0591-4a13-bce7-0f5b31ff6158",
+      "count": 71,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-05-27T07:01:52.386Z",
+      "last_cve_date": "2026-09-18T11:19:34.183Z",
+      "days_since_last_cve": 5,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 26,
+        "2024": 2,
+        "2026": 43
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 169
+    },
+    {
+      "name": "ASUS",
+      "assigner_org_id": "54bf65a7-a193-42d2-b1ba-8e150d3c35e1",
+      "count": 70,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-12-04T01:20:10.965Z",
+      "last_cve_date": "2026-09-08T02:04:26.991Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 40,
+        "2025": 29,
+        "2024": 1
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 170
+    },
+    {
+      "name": "Gallagher",
+      "assigner_org_id": "0c426f27-3ee1-4eff-be88-288d5a1822bc",
+      "count": 70,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-09-15T13:17:49.000Z",
+      "last_cve_date": "2026-07-07T03:49:34.370Z",
+      "days_since_last_cve": 78,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 9,
+        "2021": 13,
+        "2022": 2,
+        "2023": 13,
+        "2024": 13,
+        "2025": 13,
+        "2026": 7
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 171
+    },
+    {
+      "name": "cloudflare",
+      "assigner_org_id": "a22f1246-ba21-4bb4-a601-ad51614c1513",
+      "count": 70,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-10-02T14:16:23.809Z",
+      "last_cve_date": "2026-08-12T11:31:15.102Z",
+      "days_since_last_cve": 42,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 1,
+        "2021": 8,
+        "2025": 12,
+        "2022": 10,
+        "2023": 22,
+        "2024": 4,
+        "2026": 13
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 172
+    },
+    {
+      "name": "larry_cashdollar",
+      "assigner_org_id": "461b2335-328f-427d-ae3d-eff7d6814455",
+      "count": 69,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-11-10T16:00:00.000Z",
+      "last_cve_date": "2026-01-13T15:12:53.126Z",
+      "days_since_last_cve": 253,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 11,
+        "2016": 3,
+        "2017": 34,
+        "2018": 15,
+        "2020": 3,
+        "2022": 1,
+        "2025": 1,
+        "2026": 1
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 2,
+      "epss_elevated_count": 8,
+      "top_cwes": [],
+      "rank": 173
+    },
+    {
+      "name": "Citrix",
+      "assigner_org_id": "e437aed5-38e0-4fa3-a98b-cb73e7acaec6",
+      "count": 69,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-03-09T14:58:02.000Z",
+      "last_cve_date": "2026-09-11T19:14:58.264Z",
+      "days_since_last_cve": 12,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 11,
+        "2023": 17,
+        "2024": 22,
+        "2025": 14,
+        "2026": 5
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 11,
+      "epss_high_count": 7,
+      "epss_elevated_count": 16,
+      "top_cwes": [],
+      "rank": 174
+    },
+    {
+      "name": "NEC",
+      "assigner_org_id": "f2760a35-e0d8-4637-ac4c-cc1a2de3e282",
+      "count": 67,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-06-07T13:25:26.000Z",
+      "last_cve_date": "2026-09-07T00:48:01.015Z",
+      "days_since_last_cve": 16,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 6,
+        "2021": 10,
+        "2023": 11,
+        "2024": 17,
+        "2025": 14,
+        "2026": 9
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 175
+    },
+    {
+      "name": "blackberry",
+      "assigner_org_id": "dbe78b00-5e7b-4fda-8748-329789ecfc5c",
+      "count": 66,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-04-22T18:00:00.000Z",
+      "last_cve_date": "2026-08-11T16:17:02.891Z",
+      "days_since_last_cve": 43,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 13,
+        "2016": 2,
+        "2018": 6,
+        "2019": 3,
+        "2020": 2,
+        "2021": 9,
+        "2022": 4,
+        "2023": 5,
+        "2025": 7,
+        "2024": 7,
+        "2026": 8
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 176
+    },
+    {
+      "name": "curl",
+      "assigner_org_id": "2499f714-1537-4658-8207-48ae4bb9eae9",
+      "count": 66,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-02-03T13:35:25.863Z",
+      "last_cve_date": "2026-09-06T17:49:35.050Z",
+      "days_since_last_cve": 17,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 11,
+        "2025": 9,
+        "2026": 46
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 177
+    },
+    {
+      "name": "OpenVPN",
+      "assigner_org_id": "36a55730-e66d-4d39-8ca6-3c3b3017965e",
+      "count": 64,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-07-14T17:27:31.000Z",
+      "last_cve_date": "2026-09-07T11:03:14.851Z",
+      "days_since_last_cve": 16,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 9,
+        "2020": 1,
+        "2022": 4,
+        "2023": 3,
+        "2024": 9,
+        "2025": 13,
+        "2026": 25
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 178
+    },
+    {
+      "name": "TML",
+      "assigner_org_id": "07aac9b9-e3e9-4d03-a447-764bd31371d7",
+      "count": 64,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-10-31T20:05:35.055Z",
+      "last_cve_date": "2026-07-27T02:23:23.674Z",
+      "days_since_last_cve": 58,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 16,
+        "2023": 34,
+        "2024": 5,
+        "2025": 2,
+        "2026": 7
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 179
+    },
+    {
+      "name": "Deltaww",
+      "assigner_org_id": "759f5e80-c8e1-4224-bead-956d7b33c98b",
+      "count": 64,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-02-07T07:26:04.691Z",
+      "last_cve_date": "2026-08-24T09:34:58.858Z",
+      "days_since_last_cve": 30,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 40,
+        "2026": 24
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 180
+    },
+    {
+      "name": "HiddenLayer",
+      "assigner_org_id": "6f8de1f0-f67e-45a6-b68f-98777fdb759c",
+      "count": 63,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-02-05T21:15:19.026Z",
+      "last_cve_date": "2026-09-11T14:35:34.416Z",
+      "days_since_last_cve": 12,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 39,
+        "2025": 7,
+        "2026": 17
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 181
+    },
+    {
+      "name": "Arm",
+      "assigner_org_id": "56a131ea-b967-4a0d-a41e-5f3549952846",
+      "count": 62,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-07-27T21:28:08.461Z",
+      "last_cve_date": "2026-09-08T14:22:15.418Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 12,
+        "2024": 19,
+        "2025": 18,
+        "2026": 13
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 182
+    },
+    {
+      "name": "Absolute",
+      "assigner_org_id": "b6533044-ea05-4482-8458-7bddeca0d079",
+      "count": 61,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-09-16T11:18:27.000Z",
+      "last_cve_date": "2026-08-13T16:16:22.160Z",
+      "days_since_last_cve": 41,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 2,
+        "2024": 13,
+        "2025": 18,
+        "2026": 28
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 183
+    },
+    {
+      "name": "Honeywell",
+      "assigner_org_id": "0dc86260-d7e3-4e81-ba06-3508e030ce8d",
+      "count": 61,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-05-30T16:15:50.508Z",
+      "last_cve_date": "2026-07-27T18:45:35.455Z",
+      "days_since_last_cve": 58,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 17,
+        "2024": 19,
+        "2025": 19,
+        "2026": 6
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 184
+    },
+    {
+      "name": "CyberDanube",
+      "assigner_org_id": "7d092a75-6bbd-48c6-a15a-0297458009bc",
+      "count": 61,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-05-08T12:11:34.963Z",
+      "last_cve_date": "2026-08-10T19:38:57.641Z",
+      "days_since_last_cve": 44,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2024": 28,
+        "2023": 8,
+        "2025": 5,
+        "2026": 20
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 6,
+      "top_cwes": [],
+      "rank": 185
+    },
+    {
+      "name": "M-Files Corporation",
+      "assigner_org_id": "bcf7a16e-bfdc-46e4-9e42-4187da3f4410",
+      "count": 60,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-01-18T16:51:49.630Z",
+      "last_cve_date": "2026-08-19T11:47:07.591Z",
+      "days_since_last_cve": 35,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 10,
+        "2023": 19,
+        "2024": 12,
+        "2025": 13,
+        "2026": 6
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 186
+    },
+    {
+      "name": "SEL",
+      "assigner_org_id": "5804bb70-792c-43e0-8596-486cc0efe699",
+      "count": 60,
+      "years_active": 3,
+      "first_cve_year": 2023,
+      "last_cve_year": 2025,
+      "first_cve_date": "2023-05-10T19:18:43.806Z",
+      "last_cve_date": "2025-05-20T15:14:36.200Z",
+      "days_since_last_cve": 491,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 40,
+        "2024": 1,
+        "2025": 19
+      },
+      "years_active_list": [
+        2023,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 187
+    },
+    {
+      "name": "BlackDuck",
+      "assigner_org_id": "8cad7728-009c-4a3d-a95e-ca62e6ff8a0b",
+      "count": 59,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-06-08T14:31:16.000Z",
+      "last_cve_date": "2026-08-24T14:17:23.940Z",
+      "days_since_last_cve": 30,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 15,
+        "2021": 7,
+        "2023": 17,
+        "2025": 10,
+        "2024": 5,
+        "2026": 5
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 4,
+      "top_cwes": [],
+      "rank": 188
+    },
+    {
+      "name": "pivotal",
+      "assigner_org_id": "862b2186-222f-48b9-af87-f1fb7bb26d03",
+      "count": 58,
+      "years_active": 3,
+      "first_cve_year": 2019,
+      "last_cve_year": 2021,
+      "first_cve_date": "2019-06-12T14:46:18.601Z",
+      "last_cve_date": "2021-01-27T17:30:17.264Z",
+      "days_since_last_cve": 2065,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 23,
+        "2020": 33,
+        "2021": 2
+      },
+      "years_active_list": [
+        2019,
+        2021
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 3,
+      "epss_elevated_count": 5,
+      "top_cwes": [],
+      "rank": 189
+    },
+    {
+      "name": "PandoraFMS",
+      "assigner_org_id": "63375d6c-d89a-45ed-8ecc-c8c361b0e04c",
+      "count": 58,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-03-09T15:09:18.756Z",
+      "last_cve_date": "2026-05-12T15:13:28.487Z",
+      "days_since_last_cve": 134,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 10,
+        "2023": 19,
+        "2024": 11,
+        "2025": 5,
+        "2026": 13
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 2,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 190
+    },
+    {
+      "name": "Zscaler",
+      "assigner_org_id": "73c6f63b-efac-410d-a0a9-569700f85a04",
+      "count": 56,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-02-16T19:37:39.000Z",
+      "last_cve_date": "2026-09-18T14:01:10.683Z",
+      "days_since_last_cve": 5,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 4,
+        "2023": 17,
+        "2024": 20,
+        "2025": 3,
+        "2026": 12
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 191
+    },
+    {
+      "name": "Xiaomi",
+      "assigner_org_id": "b57733aa-7326-4f07-8e09-0be8e0df1909",
+      "count": 56,
+      "years_active": 6,
+      "first_cve_year": 2020,
+      "last_cve_year": 2025,
+      "first_cve_date": "2020-06-24T15:17:35.000Z",
+      "last_cve_date": "2025-06-23T09:34:38.676Z",
+      "days_since_last_cve": 457,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 4,
+        "2022": 18,
+        "2021": 13,
+        "2023": 6,
+        "2024": 7,
+        "2025": 8
+      },
+      "years_active_list": [
+        2020,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 192
+    },
+    {
+      "name": "Eaton",
+      "assigner_org_id": "63703b7d-23e2-41ef-94b3-a3c6333f7759",
+      "count": 54,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-03-23T13:25:43.903Z",
+      "last_cve_date": "2026-07-30T10:21:17.647Z",
+      "days_since_last_cve": 55,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 5,
+        "2021": 8,
+        "2022": 7,
+        "2024": 6,
+        "2023": 3,
+        "2025": 15,
+        "2026": 10
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 193
+    },
+    {
+      "name": "securin",
+      "assigner_org_id": "33c584b5-0579-4c06-b2a0-8d8329fcab9c",
+      "count": 54,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-10-08T07:49:56.847Z",
+      "last_cve_date": "2026-07-01T03:33:28.957Z",
+      "days_since_last_cve": 84,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 53,
+        "2024": 1
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 194
+    },
+    {
+      "name": "Ping Identity",
+      "assigner_org_id": "5998a2e9-ae88-42cd-b6e0-7564fd979f9e",
+      "count": 52,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-08-18T18:49:35.000Z",
+      "last_cve_date": "2026-09-14T11:18:33.045Z",
+      "days_since_last_cve": 9,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 4,
+        "2022": 15,
+        "2023": 10,
+        "2024": 12,
+        "2025": 6,
+        "2026": 5
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 195
+    },
+    {
+      "name": "HITVAN",
+      "assigner_org_id": "dce6e192-ff49-4263-9134-f0beccb9bc13",
+      "count": 52,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-11-02T14:26:02.105Z",
+      "last_cve_date": "2026-05-27T02:54:25.857Z",
+      "days_since_last_cve": 119,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 3,
+        "2023": 20,
+        "2024": 5,
+        "2025": 19,
+        "2026": 5
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 2,
+      "epss_elevated_count": 5,
+      "top_cwes": [],
+      "rank": 196
+    },
+    {
+      "name": "Honor",
+      "assigner_org_id": "3836d913-7555-4dd0-a509-f5667fdf5fe4",
+      "count": 52,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-12-29T01:20:05.826Z",
+      "last_cve_date": "2026-04-21T06:40:08.446Z",
+      "days_since_last_cve": 155,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 30,
+        "2024": 12,
+        "2025": 7,
+        "2026": 3
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 197
+    },
+    {
+      "name": "Gridware",
+      "assigner_org_id": "b7efe717-a805-47cf-8e9a-921fca0ce0ce",
+      "count": 52,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-12-04T00:23:39.944Z",
+      "last_cve_date": "2026-03-05T05:12:35.774Z",
+      "days_since_last_cve": 202,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 2,
+        "2025": 29,
+        "2026": 21
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 198
+    },
+    {
+      "name": "Document Fdn.",
+      "assigner_org_id": "4fe7d05b-1353-44cc-8b7a-1e416936dff2",
+      "count": 51,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-05-09T13:51:04.424Z",
+      "last_cve_date": "2026-09-22T11:10:41.707Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 9,
+        "2020": 3,
+        "2021": 4,
+        "2022": 5,
+        "2025": 7,
+        "2023": 4,
+        "2024": 4,
+        "2026": 15
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 199
+    },
+    {
+      "name": "GEN",
+      "assigner_org_id": "dbd8429d-f261-4b1e-94cc-ae3132817e2e",
+      "count": 51,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-04-12T16:11:34.000Z",
+      "last_cve_date": "2026-09-16T14:01:47.369Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 4,
+        "2023": 7,
+        "2025": 15,
+        "2024": 6,
+        "2026": 19
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 200
+    },
+    {
+      "name": "AMI",
+      "assigner_org_id": "7e9044f1-7f56-4c38-8864-c0c7302263d6",
+      "count": 51,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-06-12T16:54:19.265Z",
+      "last_cve_date": "2026-09-08T14:02:30.089Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 14,
+        "2023": 22,
+        "2025": 14,
+        "2026": 1
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 201
+    },
+    {
+      "name": "GoogleCloud",
+      "assigner_org_id": "f45cbf4e-4146-4068-b7e1-655ffc2c548c",
+      "count": 50,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-08-25T07:05:31.047Z",
+      "last_cve_date": "2026-09-15T15:22:29.905Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 20,
+        "2026": 30
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 202
+    },
+    {
+      "name": "dahua",
+      "assigner_org_id": "79ee569e-7d1e-4364-98f0-3a18e2a739ad",
+      "count": 49,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-11-13T16:00:00.000Z",
+      "last_cve_date": "2026-06-10T06:16:34.173Z",
+      "days_since_last_cve": 105,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 3,
+        "2018": 1,
+        "2019": 6,
+        "2020": 5,
+        "2021": 2,
+        "2022": 17,
+        "2023": 1,
+        "2024": 7,
+        "2025": 3,
+        "2026": 4
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 2,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 203
+    },
+    {
+      "name": "NETGEAR",
+      "assigner_org_id": "a2826606-91e7-4eb6-899e-8484bd4575d5",
+      "count": 49,
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "first_cve_date": "2017-05-26T20:00:00.000Z",
+      "last_cve_date": "2026-09-08T17:09:12.157Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 1,
+        "2020": 1,
+        "2025": 7,
+        "2026": 40
+      },
+      "years_active_list": [
+        2017,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 204
+    },
+    {
+      "name": "Sophos",
+      "assigner_org_id": "526a354d-e866-4174-ae7d-bac848e5c4c5",
+      "count": 49,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-03-22T17:24:28.000Z",
+      "last_cve_date": "2026-08-06T20:30:39.943Z",
+      "days_since_last_cve": 48,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 8,
+        "2021": 8,
+        "2022": 18,
+        "2025": 10,
+        "2024": 4,
+        "2026": 1
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 3,
+      "epss_high_count": 3,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 205
+    },
+    {
+      "name": "WDC PSIRT",
+      "assigner_org_id": "cb3b742e-5145-4748-b44b-5ffd45bf3b6a",
+      "count": 49,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-01-13T20:27:24.000Z",
+      "last_cve_date": "2026-01-26T22:47:58.624Z",
+      "days_since_last_cve": 240,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 23,
+        "2023": 18,
+        "2024": 6,
+        "2026": 1,
+        "2025": 1
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 206
+    },
+    {
+      "name": "Canon",
+      "assigner_org_id": "f98c90f0-e9bd-4fa7-911b-51993f3571fd",
+      "count": 49,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-05-11T00:00:00.000Z",
+      "last_cve_date": "2026-08-02T23:32:44.893Z",
+      "days_since_last_cve": 51,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 11,
+        "2024": 8,
+        "2025": 13,
+        "2026": 17
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 207
+    },
+    {
+      "name": "Acer",
+      "assigner_org_id": "8fc372e3-d9c5-46e4-9410-38469745c639",
+      "count": 49,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-05-08T05:57:22.797Z",
+      "last_cve_date": "2026-09-23T07:20:41.257Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 49
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 208
+    },
+    {
+      "name": "hikvision",
+      "assigner_org_id": "da451dce-859b-4e51-8b87-9c8b60d19b32",
+      "count": 48,
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "first_cve_date": "2018-04-18T15:00:00.000Z",
+      "last_cve_date": "2026-09-10T12:47:29.537Z",
+      "days_since_last_cve": 13,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 2,
+        "2021": 1,
+        "2022": 3,
+        "2023": 6,
+        "2025": 8,
+        "2024": 8,
+        "2026": 20
+      },
+      "years_active_list": [
+        2018,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 2,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 209
+    },
+    {
+      "name": "bcorg",
+      "assigner_org_id": "91579145-5d7b-4cc5-b925-a0262ff19630",
+      "count": 48,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-08-12T09:13:42.770Z",
+      "last_cve_date": "2026-08-08T00:59:40.512Z",
+      "days_since_last_cve": 46,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 42,
+        "2025": 6
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 210
+    },
+    {
+      "name": "CSA",
+      "assigner_org_id": "5f57b9bf-260d-4433-bf07-b6a79e9bb7d4",
+      "count": 48,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-06-24T02:02:08.633Z",
+      "last_cve_date": "2026-08-26T07:24:32.411Z",
+      "days_since_last_cve": 28,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 15,
+        "2026": 33
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 1,
+      "epss_elevated_count": 5,
+      "top_cwes": [],
+      "rank": 211
+    },
+    {
+      "name": "Pega",
+      "assigner_org_id": "c91e5604-2bd1-401f-a0ec-b25342b57ef9",
+      "count": 47,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-04-01T18:38:57.721Z",
+      "last_cve_date": "2026-08-28T13:11:34.206Z",
+      "days_since_last_cve": 26,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 2,
+        "2022": 6,
+        "2023": 10,
+        "2024": 9,
+        "2025": 6,
+        "2026": 14
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 212
+    },
+    {
+      "name": "Palantir",
+      "assigner_org_id": "bbcbe11d-db20-4bc2-8a6e-c79f87041fd4",
+      "count": 47,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-04-26T22:35:08.294Z",
+      "last_cve_date": "2026-01-22T19:06:05.914Z",
+      "days_since_last_cve": 244,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 28,
+        "2022": 6,
+        "2024": 5,
+        "2025": 6,
+        "2026": 2
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 213
+    },
+    {
+      "name": "F-SecureUS",
+      "assigner_org_id": "126858f1-1b65-4b74-81ca-7034f7f7723f",
+      "count": 46,
+      "years_active": 2,
+      "first_cve_year": 2021,
+      "last_cve_year": 2022,
+      "first_cve_date": "2021-06-21T11:10:32.776Z",
+      "last_cve_date": "2022-10-12T00:00:00.000Z",
+      "days_since_last_cve": 1442,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 20,
+        "2022": 26
+      },
+      "years_active_list": [
+        2021,
+        2022
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 214
+    },
+    {
+      "name": "avaya",
+      "assigner_org_id": "9d670455-bdb5-4cca-a883-5914865f5d96",
+      "count": 45,
+      "years_active": 8,
+      "first_cve_year": 2018,
+      "last_cve_year": 2025,
+      "first_cve_date": "2018-09-12T21:00:00.000Z",
+      "last_cve_date": "2025-06-10T06:05:25.883Z",
+      "days_since_last_cve": 470,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 6,
+        "2019": 7,
+        "2020": 6,
+        "2021": 13,
+        "2022": 3,
+        "2023": 2,
+        "2024": 5,
+        "2025": 3
+      },
+      "years_active_list": [
+        2018,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 215
+    },
+    {
+      "name": "Salesforce",
+      "assigner_org_id": "c9b25dee-ae6d-4083-ba23-638c500cc364",
+      "count": 45,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-08-30T16:56:14.000Z",
+      "last_cve_date": "2026-03-23T19:54:32.967Z",
+      "days_since_last_cve": 184,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 2,
+        "2020": 3,
+        "2021": 5,
+        "2022": 2,
+        "2025": 27,
+        "2026": 6
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 216
+    },
+    {
+      "name": "Secomea",
+      "assigner_org_id": "f2815942-3388-4c08-ba09-6c15850fda90",
+      "count": 45,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-02-08T22:08:50.970Z",
+      "last_cve_date": "2026-09-15T10:54:38.505Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 16,
+        "2022": 18,
+        "2024": 4,
+        "2023": 4,
+        "2026": 3
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 217
+    },
+    {
+      "name": "Sonatype",
+      "assigner_org_id": "103e4ec9-0a87-450b-af77-479448ddef11",
+      "count": 45,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-03-06T20:08:21.962Z",
+      "last_cve_date": "2026-09-02T17:03:26.186Z",
+      "days_since_last_cve": 21,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 6,
+        "2025": 8,
+        "2026": 31
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 218
+    },
+    {
+      "name": "Mautic",
+      "assigner_org_id": "4e531c38-7a33-45d3-98dd-d909c0d8852e",
+      "count": 44,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-03-23T19:11:56.967Z",
+      "last_cve_date": "2026-05-29T10:41:29.041Z",
+      "days_since_last_cve": 117,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 13,
+        "2021": 6,
+        "2022": 2,
+        "2025": 15,
+        "2026": 8
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 219
+    },
+    {
+      "name": "ZUSO ART",
+      "assigner_org_id": "256c161b-b921-402b-8c3b-c6c9c14d5d88",
+      "count": 44,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-12-16T00:00:00.000Z",
+      "last_cve_date": "2026-09-15T08:49:12.313Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 1,
+        "2023": 7,
+        "2024": 13,
+        "2025": 15,
+        "2026": 8
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 220
+    },
+    {
+      "name": "Docker",
+      "assigner_org_id": "686469e6-3ff6-451b-ab8b-cf5b9e89401e",
+      "count": 43,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-03-13T11:16:30.426Z",
+      "last_cve_date": "2026-09-15T20:33:21.074Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 9,
+        "2024": 5,
+        "2025": 11,
+        "2026": 18
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 221
+    },
+    {
+      "name": "Toshiba",
+      "assigner_org_id": "ecc0f906-8666-484c-bcf8-c3b7520a72f0",
+      "count": 43,
+      "years_active": 1,
+      "first_cve_year": 2024,
+      "last_cve_year": 2024,
+      "first_cve_date": "2024-06-14T02:21:24.696Z",
+      "last_cve_date": "2024-06-14T04:20:01.103Z",
+      "days_since_last_cve": 831,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 43
+      },
+      "years_active_list": [
+        2024,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 222
+    },
+    {
+      "name": "TV",
+      "assigner_org_id": "13430f76-86eb-43b2-a71c-82c956ef31b6",
+      "count": 41,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-03-23T15:18:25.048Z",
+      "last_cve_date": "2026-08-26T09:16:13.127Z",
+      "days_since_last_cve": 28,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 1,
+        "2023": 1,
+        "2024": 7,
+        "2025": 17,
+        "2026": 15
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 223
+    },
+    {
+      "name": "naver",
+      "assigner_org_id": "f9629fae-ca2e-4fbf-9785-3ed86476aef6",
+      "count": 40,
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "first_cve_date": "2018-08-02T13:00:00.000Z",
+      "last_cve_date": "2026-05-08T04:36:12.538Z",
+      "days_since_last_cve": 138,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2018": 2,
+        "2019": 2,
+        "2022": 7,
+        "2020": 3,
+        "2021": 3,
+        "2023": 1,
+        "2024": 8,
+        "2025": 10,
+        "2026": 4
+      },
+      "years_active_list": [
+        2018,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 224
+    },
+    {
+      "name": "RTI",
+      "assigner_org_id": "3f572a00-62e2-4423-959a-7ea25eff1638",
+      "count": 40,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-12-13T10:12:32.502Z",
+      "last_cve_date": "2026-09-22T17:50:23.288Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 10,
+        "2025": 8,
+        "2026": 22
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 225
+    },
+    {
+      "name": "openEuler",
+      "assigner_org_id": "7e1ac599-2767-43fa-b3ea-f10178cc98f2",
+      "count": 39,
+      "years_active": 6,
+      "first_cve_year": 2020,
+      "last_cve_year": 2025,
+      "first_cve_date": "2020-11-23T20:08:17.000Z",
+      "last_cve_date": "2025-04-14T07:49:36.597Z",
+      "days_since_last_cve": 527,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 2,
+        "2023": 8,
+        "2024": 10,
+        "2022": 17,
+        "2021": 1,
+        "2025": 1
+      },
+      "years_active_list": [
+        2020,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 226
+    },
+    {
+      "name": "NCSC-NL",
+      "assigner_org_id": "cf4a7ff5-dd38-4ede-a530-ffaa7ea59c39",
+      "count": 39,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-08-29T08:47:13.848Z",
+      "last_cve_date": "2026-02-20T07:58:57.686Z",
+      "days_since_last_cve": 215,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2023": 18,
+        "2024": 10,
+        "2026": 6,
+        "2025": 5
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 227
+    },
+    {
+      "name": "azure-access",
+      "assigner_org_id": "a0340c66-c385-4f8b-991b-3d05f6fd5220",
+      "count": 39,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-10-15T19:10:33.929Z",
+      "last_cve_date": "2025-11-01T18:56:52.453Z",
+      "days_since_last_cve": 326,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 39
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 228
+    },
+    {
+      "name": "ESET",
+      "assigner_org_id": "4a9b9929-2450-4021-b7b9-469a0255b215",
+      "count": 38,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-11-08T13:35:49.000Z",
+      "last_cve_date": "2026-09-09T08:29:18.906Z",
+      "days_since_last_cve": 14,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 1,
+        "2022": 6,
+        "2023": 4,
+        "2024": 10,
+        "2025": 9,
+        "2026": 8
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 4,
+      "epss_high_count": 2,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 229
+    },
+    {
+      "name": "AHA",
+      "assigner_org_id": "26969f82-7e87-44d8-9cb5-f6fb926ddd43",
+      "count": 38,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-06-07T02:25:27.974Z",
+      "last_cve_date": "2026-06-23T23:54:21.635Z",
+      "days_since_last_cve": 91,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 6,
+        "2023": 6,
+        "2025": 20,
+        "2026": 6
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 230
+    },
+    {
+      "name": "runZero",
+      "assigner_org_id": "44488dab-36db-4358-99f9-bc116477f914",
+      "count": 38,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-04-07T14:10:08.773Z",
+      "last_cve_date": "2026-09-15T13:57:28.846Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 38
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 231
+    },
+    {
+      "name": "yandex",
+      "assigner_org_id": "a51c9250-e584-488d-808b-03e6f1386796",
+      "count": 37,
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "first_cve_date": "2016-10-26T18:00:00.000Z",
+      "last_cve_date": "2026-06-02T08:27:06.020Z",
+      "days_since_last_cve": 113,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2016": 6,
+        "2017": 2,
+        "2018": 3,
+        "2019": 7,
+        "2025": 9,
+        "2021": 3,
+        "2022": 5,
+        "2024": 1,
+        "2026": 1
+      },
+      "years_active_list": [
+        2016,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 232
+    },
+    {
+      "name": "ASUSTOR1",
+      "assigner_org_id": "f35eaae9-79f2-4d0d-a5c7-7bea6ed6be77",
+      "count": 37,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-08-05T16:46:19.585Z",
+      "last_cve_date": "2026-08-04T07:25:09.087Z",
+      "days_since_last_cve": 50,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 1,
+        "2023": 9,
+        "2025": 9,
+        "2026": 18
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 233
+    },
+    {
+      "name": "XI",
+      "assigner_org_id": "902ff664-2e36-43e3-a1aa-3210c82d1b67",
+      "count": 37,
+      "years_active": 2,
+      "first_cve_year": 2023,
+      "last_cve_year": 2024,
+      "first_cve_date": "2023-08-23T21:47:26.833Z",
+      "last_cve_date": "2024-07-25T21:44:53.974Z",
+      "days_since_last_cve": 790,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 32,
+        "2023": 5
+      },
+      "years_active_list": [
+        2023,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 234
+    },
+    {
+      "name": "Fortra",
+      "assigner_org_id": "df4dee71-de3a-4139-9588-11b62fe6c0ff",
+      "count": 37,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-01-22T18:05:13.194Z",
+      "last_cve_date": "2026-09-09T21:18:54.261Z",
+      "days_since_last_cve": 14,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 17,
+        "2025": 9,
+        "2026": 11
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 3,
+      "epss_elevated_count": 4,
+      "top_cwes": [],
+      "rank": 235
+    },
+    {
+      "name": "ERIC",
+      "assigner_org_id": "85b1779b-6ecd-4f52-bcc5-73eac4659dcf",
+      "count": 36,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-04-04T18:25:21.681Z",
+      "last_cve_date": "2026-08-28T12:57:50.134Z",
+      "days_since_last_cve": 26,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 14,
+        "2026": 17,
+        "2024": 5
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 236
+    },
+    {
+      "name": "Okta",
+      "assigner_org_id": "59b22baa-87b2-4371-8e4a-e080df12f74a",
+      "count": 35,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-02-21T17:49:32.000Z",
+      "last_cve_date": "2026-09-08T20:18:48.504Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 3,
+        "2023": 3,
+        "2024": 6,
+        "2025": 1,
+        "2026": 22
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 237
+    },
+    {
+      "name": "STAR_Labs",
+      "assigner_org_id": "b1571b85-cbc9-431f-830b-0c8155323a69",
+      "count": 35,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-04-17T10:18:27.543Z",
+      "last_cve_date": "2026-06-24T04:37:01.955Z",
+      "days_since_last_cve": 91,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 30,
+        "2024": 4,
+        "2026": 1
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 5,
+      "epss_elevated_count": 9,
+      "top_cwes": [],
+      "rank": 238
+    },
+    {
+      "name": "odoo",
+      "assigner_org_id": "22c90092-d340-4fb8-a06e-f1193e012523",
+      "count": 34,
+      "years_active": 7,
+      "first_cve_year": 2019,
+      "last_cve_year": 2025,
+      "first_cve_date": "2019-04-09T15:41:20.000Z",
+      "last_cve_date": "2025-02-25T19:10:40.570Z",
+      "days_since_last_cve": 575,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 4,
+        "2020": 13,
+        "2023": 15,
+        "2025": 2
+      },
+      "years_active_list": [
+        2019,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 239
+    },
+    {
+      "name": "DSF",
+      "assigner_org_id": "6a34fbeb-21d4-45e7-8e0a-62b95bc12c92",
+      "count": 34,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-11-05T15:07:17.031Z",
+      "last_cve_date": "2026-08-04T15:48:40.537Z",
+      "days_since_last_cve": 50,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 4,
+        "2026": 30
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 240
+    },
+    {
+      "name": "Centreon",
+      "assigner_org_id": "bd4443e6-1eef-43f3-9886-25fc9ceeaae7",
+      "count": 33,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-04-22T15:16:24.312Z",
+      "last_cve_date": "2026-07-13T08:19:13.094Z",
+      "days_since_last_cve": 72,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 11,
+        "2025": 22
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 241
+    },
+    {
+      "name": "Securifera",
+      "assigner_org_id": "c35fbbdf-8d87-49b6-8120-920a36e62b7f",
+      "count": 32,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-08-09T17:02:24.923Z",
+      "last_cve_date": "2026-09-22T23:10:19.304Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 25,
+        "2026": 7
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 242
+    },
+    {
+      "name": "HeroDevs",
+      "assigner_org_id": "36c7be3b-2937-45df-85ea-ca7133ea542c",
+      "count": 32,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-07-11T17:08:08.224Z",
+      "last_cve_date": "2026-09-23T02:21:48.323Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 7,
+        "2025": 12,
+        "2026": 13
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 243
+    },
+    {
+      "name": "glibc",
+      "assigner_org_id": "3ff69d7a-14f2-4f67-a097-88dee7810d18",
+      "count": 32,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-04-17T17:27:40.541Z",
+      "last_cve_date": "2026-09-22T16:50:07.239Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 5,
+        "2025": 5,
+        "2026": 22
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 244
+    },
+    {
+      "name": "LGE",
+      "assigner_org_id": "42f21055-226c-4bce-a3c8-ecf55a3551fb",
+      "count": 31,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-01-21T18:17:30.000Z",
+      "last_cve_date": "2026-07-30T01:50:16.571Z",
+      "days_since_last_cve": 55,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 6,
+        "2023": 13,
+        "2024": 8,
+        "2025": 3,
+        "2026": 1
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 2,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 245
+    },
+    {
+      "name": "forcepoint",
+      "assigner_org_id": "e23ea22c-8c39-4eff-8980-2881e5ae54e2",
+      "count": 30,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-02-07T23:00:00.000Z",
+      "last_cve_date": "2026-09-23T13:27:22.017Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 9,
+        "2020": 1,
+        "2021": 2,
+        "2022": 3,
+        "2024": 4,
+        "2023": 4,
+        "2025": 2,
+        "2026": 5
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 246
+    },
+    {
+      "name": "rami.io",
+      "assigner_org_id": "655498c3-6ec5-4f0b-aea6-853b334d05a6",
+      "count": 30,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-08-23T14:18:05.416Z",
+      "last_cve_date": "2026-08-31T07:44:09.516Z",
+      "days_since_last_cve": 23,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 2,
+        "2025": 3,
+        "2026": 25
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 247
+    },
+    {
+      "name": "Secur0",
+      "assigner_org_id": "4daa8cea-433a-44bd-9456-53b127fc289a",
+      "count": 30,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-06-24T10:45:17.553Z",
+      "last_cve_date": "2026-09-14T20:58:39.818Z",
+      "days_since_last_cve": 9,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 30
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 248
+    },
+    {
+      "name": "Alias",
+      "assigner_org_id": "dc524f69-879d-41dc-ab8f-724e78658a1a",
+      "count": 29,
+      "years_active": 1,
+      "first_cve_year": 2020,
+      "last_cve_year": 2020,
+      "first_cve_date": "2020-04-06T12:08:40.625Z",
+      "last_cve_date": "2020-11-06T11:20:19.128Z",
+      "days_since_last_cve": 2147,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 29
+      },
+      "years_active_list": [
+        2020,
+        2020
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 249
+    },
+    {
+      "name": "Nokia",
+      "assigner_org_id": "b48c3b8f-639e-4c16-8725-497bc411dad0",
+      "count": 29,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-10-17T12:16:02.750Z",
+      "last_cve_date": "2026-08-31T06:37:19.360Z",
+      "days_since_last_cve": 23,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 13,
+        "2024": 2,
+        "2026": 14
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 250
+    },
+    {
+      "name": "YokogawaGroup",
+      "assigner_org_id": "7168b535-132a-4efe-a076-338f829b2eb9",
+      "count": 29,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-12-01T06:12:03.581Z",
+      "last_cve_date": "2026-06-23T00:53:43.698Z",
+      "days_since_last_cve": 92,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2024": 4,
+        "2026": 23,
+        "2025": 1
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 251
+    },
+    {
+      "name": "Ubiquiti",
+      "assigner_org_id": "fe490ce8-0395-4072-90d8-2707e1bdf984",
+      "count": 29,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-08-26T08:57:33.271Z",
+      "last_cve_date": "2026-09-22T18:49:39.376Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 29
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 252
+    },
+    {
+      "name": "Vaadin",
+      "assigner_org_id": "9e0f3122-90e9-42d5-93de-8c6b98deef7e",
+      "count": 28,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-04-23T16:05:40.338Z",
+      "last_cve_date": "2026-05-19T11:01:47.212Z",
+      "days_since_last_cve": 127,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 20,
+        "2022": 1,
+        "2023": 2,
+        "2025": 1,
+        "2026": 4
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 253
+    },
+    {
+      "name": "TianoCore",
+      "assigner_org_id": "65518388-201a-4f93-8712-366d21fe8d2c",
+      "count": 27,
+      "years_active": 5,
+      "first_cve_year": 2021,
+      "last_cve_year": 2025,
+      "first_cve_date": "2021-06-11T15:11:23.000Z",
+      "last_cve_date": "2025-12-09T15:00:48.437Z",
+      "days_since_last_cve": 288,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 5,
+        "2022": 2,
+        "2024": 14,
+        "2025": 6
+      },
+      "years_active_list": [
+        2021,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 254
+    },
+    {
+      "name": "airbus",
+      "assigner_org_id": "24a3c815-5f22-4d74-967a-30958d6466f4",
+      "count": 26,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-04-12T17:37:54.000Z",
+      "last_cve_date": "2026-09-16T12:10:36.202Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 4,
+        "2020": 1,
+        "2021": 1,
+        "2025": 11,
+        "2026": 9
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 255
+    },
+    {
+      "name": "OPPO",
+      "assigner_org_id": "7f2b1ad8-5432-4d64-91a1-9099af1cc695",
+      "count": 26,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-04-21T13:42:04.000Z",
+      "last_cve_date": "2026-08-17T06:13:58.205Z",
+      "days_since_last_cve": 37,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 3,
+        "2020": 8,
+        "2022": 2,
+        "2023": 3,
+        "2024": 3,
+        "2025": 3,
+        "2026": 4
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 256
+    },
+    {
+      "name": "LY-Corporation",
+      "assigner_org_id": "657f3255-0560-4aed-82e4-7f579ec6acfb",
+      "count": 26,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-07-13T17:47:37.000Z",
+      "last_cve_date": "2026-08-19T01:19:34.960Z",
+      "days_since_last_cve": 35,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 5,
+        "2022": 3,
+        "2023": 1,
+        "2024": 3,
+        "2025": 6,
+        "2026": 8
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 257
+    },
+    {
+      "name": "SN",
+      "assigner_org_id": "303448ea-6ef3-4077-ad29-5c9bf253c375",
+      "count": 26,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-04-10T00:00:00.000Z",
+      "last_cve_date": "2026-08-27T19:05:04.612Z",
+      "days_since_last_cve": 27,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 8,
+        "2024": 6,
+        "2025": 5,
+        "2026": 7
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 4,
+      "epss_elevated_count": 5,
+      "top_cwes": [],
+      "rank": 258
+    },
+    {
+      "name": "Vivo",
+      "assigner_org_id": "c6f5cd8e-fe3d-4460-82c2-f8a4e7b272c8",
+      "count": 25,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-11-10T15:31:38.958Z",
+      "last_cve_date": "2026-08-26T06:46:54.944Z",
+      "days_since_last_cve": 28,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 9,
+        "2021": 2,
+        "2020": 1,
+        "2023": 1,
+        "2025": 5,
+        "2026": 7
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 259
+    },
+    {
+      "name": "Baidu",
+      "assigner_org_id": "7b443bca-21a2-4df8-b477-ec36491d9932",
+      "count": 25,
+      "years_active": 3,
+      "first_cve_year": 2022,
+      "last_cve_year": 2024,
+      "first_cve_date": "2022-12-07T07:41:04.470Z",
+      "last_cve_date": "2024-01-03T08:15:52.057Z",
+      "days_since_last_cve": 994,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 2,
+        "2024": 18,
+        "2023": 5
+      },
+      "years_active_list": [
+        2022,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 260
+    },
+    {
+      "name": "Microchip",
+      "assigner_org_id": "dc3f6da9-85b5-4a73-84a2-2ec90b40fca5",
+      "count": 25,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-05-16T13:07:57.462Z",
+      "last_cve_date": "2026-09-12T09:26:05.932Z",
+      "days_since_last_cve": 11,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 11,
+        "2025": 3,
+        "2026": 11
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 261
+    },
+    {
+      "name": "NCSC-FI",
+      "assigner_org_id": "db4dfee8-a97e-4877-bfae-eba6d14a2166",
+      "count": 25,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-12-20T19:19:43.985Z",
+      "last_cve_date": "2026-09-16T13:38:30.097Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2026": 17,
+        "2025": 7
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 262
+    },
+    {
+      "name": "Carrier",
+      "assigner_org_id": "e24e6442-3ae1-4538-a7b8-7ac95586db8f",
+      "count": 24,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-06-06T16:36:46.116Z",
+      "last_cve_date": "2026-01-22T12:52:14.611Z",
+      "days_since_last_cve": 244,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 8,
+        "2024": 6,
+        "2025": 9,
+        "2026": 1
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 263
+    },
+    {
+      "name": "Dragos",
+      "assigner_org_id": "12bdf821-1545-4a87-aac5-61670cc6fcef",
+      "count": 24,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-08-24T16:03:36.347Z",
+      "last_cve_date": "2026-01-03T00:28:24.506Z",
+      "days_since_last_cve": 263,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 9,
+        "2023": 5,
+        "2026": 7,
+        "2025": 3
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 264
+    },
+    {
+      "name": "PaperCut",
+      "assigner_org_id": "eb41dac7-0af8-4f84-9f6d-0272772514f4",
+      "count": 24,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-11-14T04:04:03.280Z",
+      "last_cve_date": "2026-08-28T11:45:25.388Z",
+      "days_since_last_cve": 26,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2024": 12,
+        "2025": 1,
+        "2026": 10
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 2,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 265
+    },
+    {
+      "name": "Insyde",
+      "assigner_org_id": "8338d8cb-57f7-4252-abc0-96fd13e98d21",
+      "count": 23,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-06-11T00:25:17.737Z",
+      "last_cve_date": "2026-09-09T03:59:11.348Z",
+      "days_since_last_cve": 14,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 12,
+        "2025": 11
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 266
+    },
+    {
+      "name": "Everpure",
+      "assigner_org_id": "3895c224-4e1d-482a-adb3-fa64795683ac",
+      "count": 23,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-10-02T22:20:21.550Z",
+      "last_cve_date": "2026-09-09T12:45:30.861Z",
+      "days_since_last_cve": 14,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 6,
+        "2024": 7,
+        "2025": 5,
+        "2026": 5
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 267
+    },
+    {
+      "name": "Mandiant",
+      "assigner_org_id": "027e81ed-0dd4-4685-ab4d-884aec5bb484",
+      "count": 23,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-12-24T21:34:46.527Z",
+      "last_cve_date": "2026-08-18T18:25:51.499Z",
+      "days_since_last_cve": 36,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 2,
+        "2024": 4,
+        "2025": 6,
+        "2026": 11
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 1,
+      "epss_elevated_count": 4,
+      "top_cwes": [],
+      "rank": 268
+    },
+    {
+      "name": "BT",
+      "assigner_org_id": "13061848-ea10-403d-bd75-c83a022c2891",
+      "count": 23,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-02-16T18:54:33.382Z",
+      "last_cve_date": "2026-08-17T16:29:12.385Z",
+      "days_since_last_cve": 37,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 10,
+        "2025": 5,
+        "2026": 8
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 3,
+      "epss_high_count": 2,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 269
+    },
+    {
+      "name": "TQtC",
+      "assigner_org_id": "a59d8014-47c4-4630-ab43-e1b13cbe58e3",
+      "count": 23,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-04-11T07:39:48.298Z",
+      "last_cve_date": "2026-09-23T11:39:03.788Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 10,
+        "2026": 13
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 270
+    },
+    {
+      "name": "BD",
+      "assigner_org_id": "2325d071-eabf-4b7b-a4ea-0819b6629a18",
+      "count": 22,
+      "years_active": 3,
+      "first_cve_year": 2022,
+      "last_cve_year": 2024,
+      "first_cve_date": "2022-02-11T18:12:07.247Z",
+      "last_cve_date": "2024-12-17T15:16:44.982Z",
+      "days_since_last_cve": 645,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 15,
+        "2022": 6,
+        "2024": 1
+      },
+      "years_active_list": [
+        2022,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 271
+    },
+    {
+      "name": "Proofpoint",
+      "assigner_org_id": "d83a79dd-e128-4b83-8b64-84faf54eed46",
+      "count": 22,
+      "years_active": 4,
+      "first_cve_year": 2022,
+      "last_cve_year": 2025,
+      "first_cve_date": "2022-12-06T19:52:02.111Z",
+      "last_cve_date": "2025-11-03T18:40:03.946Z",
+      "days_since_last_cve": 324,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 3,
+        "2023": 13,
+        "2024": 3,
+        "2025": 3
+      },
+      "years_active_list": [
+        2022,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 272
+    },
+    {
+      "name": "ASR",
+      "assigner_org_id": "68630edc-a58c-4cbd-9b01-0e130455c8ae",
+      "count": 22,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-11-30T07:04:48.134Z",
+      "last_cve_date": "2026-09-23T09:03:56.690Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 3,
+        "2024": 5,
+        "2025": 11,
+        "2026": 3
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 273
+    },
+    {
+      "name": "VULSec",
+      "assigner_org_id": "2fdefc65-d750-4b8d-96ee-6e2c0c42dbfe",
+      "count": 22,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-08-21T11:35:44.087Z",
+      "last_cve_date": "2026-03-05T16:04:36.443Z",
+      "days_since_last_cve": 202,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2024": 10,
+        "2026": 11
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 274
+    },
+    {
+      "name": "TECNOMobile",
+      "assigner_org_id": "907edf6c-bf03-423e-ab1a-8da27e1aa1ea",
+      "count": 22,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-04-15T07:56:07.521Z",
+      "last_cve_date": "2026-08-05T01:47:16.191Z",
+      "days_since_last_cve": 49,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 9,
+        "2025": 9,
+        "2026": 4
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 275
+    },
+    {
+      "name": "Lexmark",
+      "assigner_org_id": "7bc73191-a2b6-4c63-9918-753964601853",
+      "count": 21,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-02-28T01:47:47.211Z",
+      "last_cve_date": "2026-02-03T20:51:20.556Z",
+      "days_since_last_cve": 232,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 4,
+        "2025": 12,
+        "2026": 5
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 276
+    },
+    {
+      "name": "OpenNMS",
+      "assigner_org_id": "70b007e9-5235-4ee5-90b5-a71a81beeda0",
+      "count": 21,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-02-22T18:35:19.051Z",
+      "last_cve_date": "2026-09-10T20:30:58.379Z",
+      "days_since_last_cve": 13,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 14,
+        "2025": 2,
+        "2026": 5
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 277
+    },
+    {
+      "name": "Xerox",
+      "assigner_org_id": "10b61619-3869-496c-8a1e-f291b0e71e3f",
+      "count": 21,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-10-07T17:43:38.811Z",
+      "last_cve_date": "2026-02-27T08:18:17.816Z",
+      "days_since_last_cve": 208,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 6,
+        "2025": 12,
+        "2026": 3
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 278
+    },
+    {
+      "name": "Altium",
+      "assigner_org_id": "4760f414-e1ae-4ff1-bdad-c7a9c3538b79",
+      "count": 21,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-01-15T22:24:16.136Z",
+      "last_cve_date": "2026-09-16T20:06:28.498Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 21
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 279
+    },
+    {
+      "name": "Teradici",
+      "assigner_org_id": "ba3c294d-a544-4fff-ad44-2de7c7bbb6be",
+      "count": 20,
+      "years_active": 2,
+      "first_cve_year": 2020,
+      "last_cve_year": 2021,
+      "first_cve_date": "2020-05-28T21:05:33.000Z",
+      "last_cve_date": "2021-07-21T12:37:39.000Z",
+      "days_since_last_cve": 1890,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 8,
+        "2021": 12
+      },
+      "years_active_list": [
+        2020,
+        2021
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 280
+    },
+    {
+      "name": "Netskope",
+      "assigner_org_id": "bf992f6a-e49d-4e94-9479-c4cff32c62bc",
+      "count": 20,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-11-03T19:20:41.897Z",
+      "last_cve_date": "2026-09-11T13:57:02.512Z",
+      "days_since_last_cve": 12,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 1,
+        "2023": 3,
+        "2025": 6,
+        "2024": 2,
+        "2026": 8
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 281
+    },
+    {
+      "name": "Anolis",
+      "assigner_org_id": "cb8f1db9-b4b1-487b-a760-f65c4f368d8e",
+      "count": 20,
+      "years_active": 4,
+      "first_cve_year": 2022,
+      "last_cve_year": 2025,
+      "first_cve_date": "2022-05-25T14:49:30.000Z",
+      "last_cve_date": "2025-02-18T02:34:44.846Z",
+      "days_since_last_cve": 582,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 6,
+        "2024": 13,
+        "2025": 1
+      },
+      "years_active_list": [
+        2022,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 282
+    },
+    {
+      "name": "ONEKEY",
+      "assigner_org_id": "2d533b80-6e4a-4e20-93e2-171235122846",
+      "count": 20,
+      "years_active": 4,
+      "first_cve_year": 2022,
+      "last_cve_year": 2025,
+      "first_cve_date": "2022-12-01T09:26:48.459Z",
+      "last_cve_date": "2025-09-12T13:48:18.818Z",
+      "days_since_last_cve": 376,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 6,
+        "2022": 1,
+        "2024": 5,
+        "2025": 8
+      },
+      "years_active_list": [
+        2022,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 2,
+      "epss_elevated_count": 5,
+      "top_cwes": [],
+      "rank": 283
+    },
+    {
+      "name": "Hanwha_Vision",
+      "assigner_org_id": "fc9afe74-3f80-4fb7-a313-e6f036a89882",
+      "count": 20,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-11-13T07:42:00.337Z",
+      "last_cve_date": "2026-04-28T07:06:17.252Z",
+      "days_since_last_cve": 148,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 10,
+        "2023": 2,
+        "2026": 3,
+        "2025": 5
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 284
+    },
+    {
+      "name": "GandC",
+      "assigner_org_id": "ace9cabe-4f4f-416b-8c39-b0e002761924",
+      "count": 20,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-05-11T20:08:25.610Z",
+      "last_cve_date": "2026-09-03T20:25:18.792Z",
+      "days_since_last_cve": 20,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 5,
+        "2024": 10,
+        "2025": 3,
+        "2026": 2
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 285
+    },
+    {
+      "name": "SNOWFLAKE",
+      "assigner_org_id": "412d305a-227d-44f9-a262-a31ba44f2aea",
+      "count": 20,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-04-16T18:43:21.181Z",
+      "last_cve_date": "2026-09-17T10:49:59.907Z",
+      "days_since_last_cve": 6,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 20
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 286
+    },
+    {
+      "name": "crafter",
+      "assigner_org_id": "4ff2b028-869f-4b00-a7b2-05997f6f14fd",
+      "count": 19,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-10-06T14:09:25.176Z",
+      "last_cve_date": "2026-02-02T16:16:01.466Z",
+      "days_since_last_cve": 233,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 2,
+        "2021": 7,
+        "2022": 5,
+        "2023": 2,
+        "2025": 2,
+        "2026": 1
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 287
+    },
+    {
+      "name": "HYPR",
+      "assigner_org_id": "0dc7baee-4a9f-419f-bd0a-e21ec5dac512",
+      "count": 19,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-07-19T14:07:38.000Z",
+      "last_cve_date": "2026-06-25T15:39:28.322Z",
+      "days_since_last_cve": 90,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 4,
+        "2024": 6,
+        "2023": 3,
+        "2025": 3,
+        "2026": 3
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 288
+    },
+    {
+      "name": "BLSOPS",
+      "assigner_org_id": "27b6da8a-f51d-48d9-9eef-9b7f3405d20d",
+      "count": 19,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-07-14T12:28:53.363Z",
+      "last_cve_date": "2026-07-08T15:03:50.730Z",
+      "days_since_last_cve": 77,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 2,
+        "2025": 9,
+        "2026": 8
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 289
+    },
+    {
+      "name": "Temporal",
+      "assigner_org_id": "61241ed8-fa44-4f23-92db-b8c443751968",
+      "count": 19,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-06-30T17:37:57.772Z",
+      "last_cve_date": "2026-09-23T18:58:46.233Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2024": 2,
+        "2025": 4,
+        "2026": 12
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 290
+    },
+    {
+      "name": "KoreLogic",
+      "assigner_org_id": "bbf0bd87-ece2-41be-b873-96928ee8fab9",
+      "count": 19,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-08-07T23:01:15.473Z",
+      "last_cve_date": "2026-01-08T21:01:31.240Z",
+      "days_since_last_cve": 258,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 10,
+        "2024": 8,
+        "2026": 1
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 2,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 291
+    },
+    {
+      "name": "nodejs",
+      "assigner_org_id": "386269d4-a6c6-4eaa-bf8e-bc0b0d010558",
+      "count": 18,
+      "years_active": 3,
+      "first_cve_year": 2017,
+      "last_cve_year": 2019,
+      "first_cve_date": "2017-12-11T21:00:00.000Z",
+      "last_cve_date": "2019-03-28T16:27:34.000Z",
+      "days_since_last_cve": 2736,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 2,
+        "2018": 14,
+        "2019": 2
+      },
+      "years_active_list": [
+        2017,
+        2019
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 292
+    },
+    {
+      "name": "THA-PSIRT",
+      "assigner_org_id": "9d5917ae-205d-4ae5-8749-1f49479b1395",
+      "count": 18,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-12-20T20:19:09.000Z",
+      "last_cve_date": "2026-07-13T09:42:45.431Z",
+      "days_since_last_cve": 72,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 3,
+        "2022": 3,
+        "2024": 4,
+        "2023": 1,
+        "2025": 1,
+        "2026": 6
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 293
+    },
+    {
+      "name": "Yugabyte",
+      "assigner_org_id": "d4ae51d3-4db5-465e-bc8a-eb6768324078",
+      "count": 18,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-08-12T18:01:37.000Z",
+      "last_cve_date": "2026-02-05T11:38:28.291Z",
+      "days_since_last_cve": 230,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 1,
+        "2023": 6,
+        "2024": 5,
+        "2025": 5,
+        "2026": 1
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 294
+    },
+    {
+      "name": "Baxter",
+      "assigner_org_id": "dba971b9-eb30-4121-91e1-3b45611354aa",
+      "count": 18,
+      "years_active": 4,
+      "first_cve_year": 2022,
+      "last_cve_year": 2025,
+      "first_cve_date": "2022-09-09T14:40:05.978Z",
+      "last_cve_date": "2025-02-07T17:07:27.929Z",
+      "days_since_last_cve": 593,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 4,
+        "2025": 2,
+        "2024": 12
+      },
+      "years_active_list": [
+        2022,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 295
+    },
+    {
+      "name": "N-able",
+      "assigner_org_id": "a5532a13-c4dd-4202-bef1-e0b8f2f8d12b",
+      "count": 18,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-07-01T20:46:40.163Z",
+      "last_cve_date": "2026-09-06T02:15:28.824Z",
+      "days_since_last_cve": 17,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 3,
+        "2025": 9,
+        "2026": 6
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 5,
+      "epss_high_count": 1,
+      "epss_elevated_count": 4,
+      "top_cwes": [],
+      "rank": 296
+    },
+    {
+      "name": "Tcpdump",
+      "assigner_org_id": "cfdbb673-b408-4d03-89c1-c3d73ed80896",
+      "count": 17,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-10-03T15:55:20.000Z",
+      "last_cve_date": "2026-09-05T18:51:57.956Z",
+      "days_since_last_cve": 18,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 1,
+        "2020": 2,
+        "2022": 1,
+        "2024": 3,
+        "2023": 1,
+        "2025": 2,
+        "2026": 7
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 297
+    },
+    {
+      "name": "sba-research",
+      "assigner_org_id": "1e3a9e0f-5156-4bf8-b8a3-cc311bfc0f4a",
+      "count": 17,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-06-06T10:29:40.393Z",
+      "last_cve_date": "2026-07-30T09:45:24.228Z",
+      "days_since_last_cve": 55,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Academic"
+      ],
+      "cves_by_year": {
+        "2025": 4,
+        "2024": 3,
+        "2026": 10
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 298
+    },
+    {
+      "name": "FSI",
+      "assigner_org_id": "09832df1-09c1-45b4-8a85-16c601d30feb",
+      "count": 17,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-04-07T06:02:06.218Z",
+      "last_cve_date": "2026-09-15T02:16:27.614Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 12,
+        "2026": 5
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 299
+    },
+    {
+      "name": "redhat-cnalr",
+      "assigner_org_id": "74b3a70d-cca6-4d34-9789-e83b222ae3be",
+      "count": 17,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-03-25T18:08:02.848Z",
+      "last_cve_date": "2026-09-18T19:01:34.027Z",
+      "days_since_last_cve": 5,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 4,
+        "2026": 13
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 300
+    },
+    {
+      "name": "Kong",
+      "assigner_org_id": "02762ae7-200e-4b20-9b2b-a77d5b8fc4cb",
+      "count": 17,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-05-09T11:37:49.660Z",
+      "last_cve_date": "2026-09-16T10:14:34.372Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1,
+        "2026": 16
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 301
+    },
+    {
+      "name": "floragunn",
+      "assigner_org_id": "9f311a02-c44f-4938-8530-9219246b8255",
+      "count": 16,
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "first_cve_date": "2019-08-12T20:51:23.000Z",
+      "last_cve_date": "2026-03-31T14:57:56.792Z",
+      "days_since_last_cve": 176,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 9,
+        "2025": 4,
+        "2026": 3
+      },
+      "years_active_list": [
+        2019,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 302
+    },
+    {
+      "name": "SWI",
+      "assigner_org_id": "747bec18-acd0-4d99-a5c8-5e366c66ab7e",
+      "count": 16,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-02-10T00:00:00.000Z",
+      "last_cve_date": "2026-04-07T19:58:41.379Z",
+      "days_since_last_cve": 169,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 3,
+        "2023": 10,
+        "2026": 3
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 303
+    },
+    {
+      "name": "HW",
+      "assigner_org_id": "ff95705b-1a40-4639-8017-a58fa868baee",
+      "count": 16,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-07-22T15:56:23.016Z",
+      "last_cve_date": "2026-03-04T12:13:09.918Z",
+      "days_since_last_cve": 203,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 10,
+        "2023": 1,
+        "2025": 4,
+        "2026": 1
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 304
+    },
+    {
+      "name": "Panasonic_Holdings_Corporation",
+      "assigner_org_id": "2163caeb-3942-4e93-a74b-8c75338146ce",
+      "count": 15,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-03-31T06:29:32.493Z",
+      "last_cve_date": "2026-09-14T05:53:54.638Z",
+      "days_since_last_cve": 9,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 10,
+        "2024": 2,
+        "2025": 2,
+        "2026": 1
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 305
+    },
+    {
+      "name": "SRA",
+      "assigner_org_id": "57dba5dd-1a03-47f6-8b36-e84e47d335d8",
+      "count": 15,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-02-19T21:28:01.273Z",
+      "last_cve_date": "2026-07-28T20:03:11.667Z",
+      "days_since_last_cve": 57,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 2,
+        "2026": 12,
+        "2025": 1
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 306
+    },
+    {
+      "name": "harborist",
+      "assigner_org_id": "7ffcee3d-2c14-4c3e-b844-86c6a321a158",
+      "count": 15,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-06-23T18:41:18.771Z",
+      "last_cve_date": "2026-09-21T02:27:00.752Z",
+      "days_since_last_cve": 2,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 6,
+        "2026": 9
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 307
+    },
+    {
+      "name": "S21sec",
+      "assigner_org_id": "50b5080a-775f-442e-83b5-926b5ca517b6",
+      "count": 15,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-09-29T15:14:39.779Z",
+      "last_cve_date": "2026-01-07T17:12:01.065Z",
+      "days_since_last_cve": 259,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 6,
+        "2026": 9
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 308
+    },
+    {
+      "name": "Commvault",
+      "assigner_org_id": "050066fd-a2f9-4f32-ab5d-4c53f48bc333",
+      "count": 15,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-01-07T22:03:05.033Z",
+      "last_cve_date": "2026-09-08T12:12:55.097Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 15
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 309
+    },
+    {
+      "name": "netflix",
+      "assigner_org_id": "ea63fd80-a441-4c7b-ba78-e48a8071cae2",
+      "count": 14,
+      "years_active": 6,
+      "first_cve_year": 2019,
+      "last_cve_year": 2024,
+      "first_cve_date": "2019-06-21T20:10:03.000Z",
+      "last_cve_date": "2024-09-27T17:41:49.445Z",
+      "days_since_last_cve": 726,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 1,
+        "2020": 6,
+        "2021": 2,
+        "2022": 1,
+        "2024": 4
+      },
+      "years_active_list": [
+        2019,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 310
+    },
+    {
+      "name": "SailPoint",
+      "assigner_org_id": "2cfc7547-56a0-4049-8b52-c3078e8a8719",
+      "count": 14,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-01-31T00:00:00.000Z",
+      "last_cve_date": "2026-07-20T18:22:36.997Z",
+      "days_since_last_cve": 65,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 3,
+        "2024": 7,
+        "2025": 1,
+        "2026": 3
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 311
+    },
+    {
+      "name": "upKeeper",
+      "assigner_org_id": "80f39f49-2521-4ee7-9e17-af5d55e8032f",
+      "count": 14,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-08-16T13:22:59.157Z",
+      "last_cve_date": "2026-06-24T08:04:58.703Z",
+      "days_since_last_cve": 91,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 7,
+        "2025": 4,
+        "2026": 3
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 312
+    },
+    {
+      "name": "arcinfo",
+      "assigner_org_id": "87c8e6ad-f0f5-4ca8-89e2-89f26d6ed932",
+      "count": 14,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-12-04T14:30:35.838Z",
+      "last_cve_date": "2026-07-07T09:26:55.347Z",
+      "days_since_last_cve": 78,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 2,
+        "2025": 3,
+        "2026": 9
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 313
+    },
+    {
+      "name": "Supermicro",
+      "assigner_org_id": "def9a96e-e099-41a9-bfac-30fd4f82c411",
+      "count": 14,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-02-04T07:59:26.354Z",
+      "last_cve_date": "2026-07-22T06:15:31.648Z",
+      "days_since_last_cve": 63,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 10,
+        "2026": 4
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 314
+    },
+    {
+      "name": "ConnectWise",
+      "assigner_org_id": "7d616e1a-3288-43b1-a0dd-0a65d3e70a49",
+      "count": 14,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-04-25T18:27:44.244Z",
+      "last_cve_date": "2026-09-08T19:29:33.630Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 7,
+        "2026": 7
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 315
+    },
+    {
+      "name": "PRJBLK",
+      "assigner_org_id": "ab69c47f-b95e-4bf2-b2d9-4b1fd1b24b4a",
+      "count": 14,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-02-18T22:59:55.491Z",
+      "last_cve_date": "2026-08-26T02:11:01.673Z",
+      "days_since_last_cve": 28,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 14
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 316
+    },
+    {
+      "name": "AppCheck",
+      "assigner_org_id": "2c188fdb-58e1-4908-8fce-3e437b94f1ae",
+      "count": 13,
+      "years_active": 4,
+      "first_cve_year": 2021,
+      "last_cve_year": 2024,
+      "first_cve_date": "2021-11-19T15:39:00.854Z",
+      "last_cve_date": "2024-03-26T15:30:28.269Z",
+      "days_since_last_cve": 911,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 3,
+        "2022": 3,
+        "2023": 2,
+        "2024": 5
+      },
+      "years_active_list": [
+        2021,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 317
+    },
+    {
+      "name": "Fidelis",
+      "assigner_org_id": "11ea3a0d-87b4-4e67-a1fa-f5a6be5d6676",
+      "count": 13,
+      "years_active": 2,
+      "first_cve_year": 2021,
+      "last_cve_year": 2022,
+      "first_cve_date": "2021-06-25T11:44:25.422Z",
+      "last_cve_date": "2022-05-17T19:32:58.251Z",
+      "days_since_last_cve": 1590,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 4,
+        "2022": 9
+      },
+      "years_active_list": [
+        2021,
+        2022
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 318
+    },
+    {
+      "name": "KNIME",
+      "assigner_org_id": "296541fb-a0e3-4ca7-ab3d-683e666d143e",
+      "count": 13,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-11-24T06:36:23.587Z",
+      "last_cve_date": "2026-03-24T08:15:16.512Z",
+      "days_since_last_cve": 183,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 2,
+        "2023": 3,
+        "2024": 1,
+        "2025": 6,
+        "2026": 1
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 319
+    },
+    {
+      "name": "Pentraze",
+      "assigner_org_id": "41c37e40-543d-43a2-b660-2fee83ea851a",
+      "count": 13,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-04-09T23:55:43.501Z",
+      "last_cve_date": "2026-02-19T01:37:22.018Z",
+      "days_since_last_cve": 216,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 6,
+        "2024": 6,
+        "2026": 1
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 320
+    },
+    {
+      "name": "Checkmarx",
+      "assigner_org_id": "596c5446-0ce5-4ba2-aa66-48b3b757a647",
+      "count": 12,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-05-13T10:04:42.886Z",
+      "last_cve_date": "2026-06-17T13:41:49.439Z",
+      "days_since_last_cve": 98,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "cves_by_year": {
+        "2025": 6,
+        "2024": 4,
+        "2026": 2
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 321
+    },
+    {
+      "name": "Medtronic",
+      "assigner_org_id": "3c337f33-b2bd-4529-9792-f48cdb2838b4",
+      "count": 12,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-11-17T20:47:05.258Z",
+      "last_cve_date": "2026-05-07T15:03:35.674Z",
+      "days_since_last_cve": 139,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 1,
+        "2023": 2,
+        "2025": 7,
+        "2026": 2
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 322
+    },
+    {
+      "name": "cirosec",
+      "assigner_org_id": "a341c0d1-ebf7-493f-a84e-38cf86618674",
+      "count": 12,
+      "years_active": 2,
+      "first_cve_year": 2024,
+      "last_cve_year": 2025,
+      "first_cve_date": "2024-07-15T13:18:09.079Z",
+      "last_cve_date": "2025-07-21T11:01:29.417Z",
+      "days_since_last_cve": 429,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 4,
+        "2025": 8
+      },
+      "years_active_list": [
+        2024,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 323
+    },
+    {
+      "name": "Genetec",
+      "assigner_org_id": "f2b06212-cb4b-41a4-9501-fa2e367495b8",
+      "count": 12,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-04-05T18:51:02.590Z",
+      "last_cve_date": "2026-08-27T22:08:52.736Z",
+      "days_since_last_cve": 27,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2024": 1,
+        "2025": 2,
+        "2026": 8
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 324
+    },
+    {
+      "name": "Solidigm",
+      "assigner_org_id": "f946a70c-00eb-42ce-8e9b-634d1f7b5a6f",
+      "count": 12,
+      "years_active": 2,
+      "first_cve_year": 2024,
+      "last_cve_year": 2025,
+      "first_cve_date": "2024-10-07T18:57:27.239Z",
+      "last_cve_date": "2025-11-07T20:24:11.186Z",
+      "days_since_last_cve": 320,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 9,
+        "2025": 3
+      },
+      "years_active_list": [
+        2024,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 325
+    },
+    {
+      "name": "TCS-CERT",
+      "assigner_org_id": "64c5ae8f-7972-4697-86a0-7ada793ac795",
+      "count": 12,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-12-01T15:47:10.317Z",
+      "last_cve_date": "2026-09-08T10:28:10.125Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2025": 4,
+        "2026": 8
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 326
+    },
+    {
+      "name": "Altera",
+      "assigner_org_id": "04c0172e-9735-4a9d-a92a-fe01fa863447",
+      "count": 12,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-12-11T20:35:24.735Z",
+      "last_cve_date": "2026-01-06T21:42:28.480Z",
+      "days_since_last_cve": 260,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 6,
+        "2026": 6
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 327
+    },
+    {
+      "name": "ChromeOS",
+      "assigner_org_id": "7f6e188d-c52a-4a19-8674-3c3fa7d1fc7f",
+      "count": 12,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-03-06T23:49:03.219Z",
+      "last_cve_date": "2025-07-07T18:58:45.456Z",
+      "days_since_last_cve": 443,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 12
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 328
+    },
+    {
+      "name": "sgi",
+      "assigner_org_id": "bc94ec7e-8909-4cbb-83df-d2fc9330fa88",
+      "count": 11,
+      "years_active": 6,
+      "first_cve_year": 2005,
+      "last_cve_year": 2010,
+      "first_cve_date": "2005-07-12T04:00:00.000Z",
+      "last_cve_date": "2010-10-26T18:00:00.000Z",
+      "days_since_last_cve": 5811,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2005": 1,
+        "2006": 7,
+        "2007": 1,
+        "2009": 1,
+        "2010": 1
+      },
+      "years_active_list": [
+        2005,
+        2010
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 329
+    },
+    {
+      "name": "CSW",
+      "assigner_org_id": "ee1bbb37-1770-46bd-bba8-910037954ee0",
+      "count": 11,
+      "years_active": 2,
+      "first_cve_year": 2021,
+      "last_cve_year": 2022,
+      "first_cve_date": "2021-06-04T19:39:00.000Z",
+      "last_cve_date": "2022-10-17T00:00:00.000Z",
+      "days_since_last_cve": 1437,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 6,
+        "2022": 5
+      },
+      "years_active_list": [
+        2021,
+        2022
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 330
+    },
+    {
+      "name": "VDOO",
+      "assigner_org_id": "6b4ace4a-d6e0-415b-9ce8-aa20e97e4b24",
+      "count": 11,
+      "years_active": 2,
+      "first_cve_year": 2020,
+      "last_cve_year": 2021,
+      "first_cve_date": "2020-10-15T15:11:50.000Z",
+      "last_cve_date": "2021-10-21T15:42:23.000Z",
+      "days_since_last_cve": 1798,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 8,
+        "2020": 3
+      },
+      "years_active_list": [
+        2020,
+        2021
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 331
+    },
+    {
+      "name": "directcyber",
+      "assigner_org_id": "430a6cef-dc26-47e3-9fa8-52fb7f19644e",
+      "count": 11,
+      "years_active": 1,
+      "first_cve_year": 2024,
+      "last_cve_year": 2024,
+      "first_cve_date": "2024-04-14T23:47:13.849Z",
+      "last_cve_date": "2024-04-22T19:21:46.408Z",
+      "days_since_last_cve": 884,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2024": 11
+      },
+      "years_active_list": [
+        2024,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 332
+    },
+    {
+      "name": "Delinea",
+      "assigner_org_id": "1443cd92-d354-46d2-9290-d812316ca43a",
+      "count": 11,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-12-26T15:45:39.592Z",
+      "last_cve_date": "2026-09-15T23:22:15.196Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2026": 8,
+        "2025": 2
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 333
+    },
+    {
+      "name": "Neo4j",
+      "assigner_org_id": "3b236295-4ccd-4a1f-a1c1-a72eecc8d7b6",
+      "count": 11,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-09-11T14:05:30.592Z",
+      "last_cve_date": "2026-08-18T16:35:19.878Z",
+      "days_since_last_cve": 36,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 2,
+        "2026": 9
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 334
+    },
+    {
+      "name": "MHV",
+      "assigner_org_id": "56a186b1-7f5e-4314-ba38-38d5499fccfd",
+      "count": 11,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-01-14T14:34:14.034Z",
+      "last_cve_date": "2026-03-06T15:05:20.800Z",
+      "days_since_last_cve": 201,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 11
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 335
+    },
+    {
+      "name": "Tigera",
+      "assigner_org_id": "e6d453f4-3dae-4941-bcea-9af25f4e824d",
+      "count": 10,
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "first_cve_date": "2020-06-03T16:44:38.089Z",
+      "last_cve_date": "2026-07-30T14:45:04.418Z",
+      "days_since_last_cve": 55,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 1,
+        "2022": 1,
+        "2023": 1,
+        "2024": 1,
+        "2026": 6
+      },
+      "years_active_list": [
+        2020,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 336
+    },
+    {
+      "name": "Snow",
+      "assigner_org_id": "ea911274-ddd9-4e68-b39a-d7d6ae8b8a65",
+      "count": 10,
+      "years_active": 4,
+      "first_cve_year": 2021,
+      "last_cve_year": 2024,
+      "first_cve_date": "2021-11-03T20:27:10.199Z",
+      "last_cve_date": "2024-05-10T06:55:53.209Z",
+      "days_since_last_cve": 866,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 1,
+        "2022": 2,
+        "2023": 3,
+        "2024": 4
+      },
+      "years_active_list": [
+        2021,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 337
+    },
+    {
+      "name": "Swift",
+      "assigner_org_id": "e4a1ddda-f4f5-496e-96c8-82c37d06abd0",
+      "count": 10,
+      "years_active": 4,
+      "first_cve_year": 2022,
+      "last_cve_year": 2025,
+      "first_cve_date": "2022-02-09T22:05:16.000Z",
+      "last_cve_date": "2025-01-15T00:48:07.959Z",
+      "days_since_last_cve": 616,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 7,
+        "2023": 2,
+        "2025": 1
+      },
+      "years_active_list": [
+        2022,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 338
+    },
+    {
+      "name": "Qualys",
+      "assigner_org_id": "8a309ac4-d8c7-4735-9c1d-ca39c5dfbcda",
+      "count": 10,
+      "years_active": 3,
+      "first_cve_year": 2023,
+      "last_cve_year": 2025,
+      "first_cve_date": "2023-04-18T15:47:37.719Z",
+      "last_cve_date": "2025-11-10T17:10:31.066Z",
+      "days_since_last_cve": 317,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "cves_by_year": {
+        "2023": 6,
+        "2024": 3,
+        "2025": 1
+      },
+      "years_active_list": [
+        2023,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 339
+    },
+    {
+      "name": "Omnissa",
+      "assigner_org_id": "de5a6978-88fe-4c27-a7df-d0d5b52d5b52",
+      "count": 10,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-02-04T22:12:39.209Z",
+      "last_cve_date": "2026-07-08T13:37:24.925Z",
+      "days_since_last_cve": 77,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 8,
+        "2026": 2
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 340
+    },
+    {
+      "name": "Bugcrowd",
+      "assigner_org_id": "4ac701fe-44e9-4bcd-9585-dd6449257611",
+      "count": 10,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-07-29T23:31:31.305Z",
+      "last_cve_date": "2026-09-01T00:13:03.935Z",
+      "days_since_last_cve": 22,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "cves_by_year": {
+        "2025": 2,
+        "2026": 8
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 341
+    },
+    {
+      "name": "Armis",
+      "assigner_org_id": "dd59f033-460c-4b88-a075-d4d3fedb6191",
+      "count": 10,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-09-02T11:23:59.838Z",
+      "last_cve_date": "2025-09-02T11:30:14.832Z",
+      "days_since_last_cve": 386,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 10
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 342
+    },
+    {
+      "name": "HDFG",
+      "assigner_org_id": "0253b833-3e77-4dfe-9d57-17db1a2f0a74",
+      "count": 10,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-07-27T15:11:36.949Z",
+      "last_cve_date": "2026-09-16T15:16:54.160Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 10
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 343
+    },
+    {
+      "name": "NetScaler",
+      "assigner_org_id": "50a63c94-1ea7-4568-8c11-eb79e7c5a2b5",
+      "count": 10,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-03-23T20:09:44.971Z",
+      "last_cve_date": "2026-08-19T12:54:39.730Z",
+      "days_since_last_cve": 35,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 10
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 3,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 344
+    },
+    {
+      "name": "ForgeRock",
+      "assigner_org_id": "6b18ae97-0aab-4af2-9ba4-74b2b139ddfa",
+      "count": 9,
+      "years_active": 3,
+      "first_cve_year": 2022,
+      "last_cve_year": 2024,
+      "first_cve_date": "2022-02-14T21:04:29.132Z",
+      "last_cve_date": "2024-03-27T17:09:43.769Z",
+      "days_since_last_cve": 910,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 4,
+        "2023": 4,
+        "2024": 1
+      },
+      "years_active_list": [
+        2022,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 345
+    },
+    {
+      "name": "GE_Vernova",
+      "assigner_org_id": "2cf0fb33-79e2-44e0-beb8-826cc5ce3250",
+      "count": 9,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-08-25T17:26:02.044Z",
+      "last_cve_date": "2026-02-10T20:06:12.992Z",
+      "days_since_last_cve": 225,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 2,
+        "2023": 1,
+        "2025": 4,
+        "2026": 2
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 346
+    },
+    {
+      "name": "dotCMS",
+      "assigner_org_id": "5b9d93f2-25c7-46b4-ab60-d201718c9dd8",
+      "count": 9,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-10-17T22:52:05.453Z",
+      "last_cve_date": "2026-07-20T19:15:11.190Z",
+      "days_since_last_cve": 65,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2024": 4,
+        "2025": 1,
+        "2026": 3
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 347
+    },
+    {
+      "name": "Softing",
+      "assigner_org_id": "10de8ef9-5c89-4b17-8228-e97b74acf4bd",
+      "count": 9,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-08-21T06:08:00.210Z",
+      "last_cve_date": "2026-09-04T09:44:58.319Z",
+      "days_since_last_cve": 19,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 6,
+        "2025": 3
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 348
+    },
+    {
+      "name": "Payara",
+      "assigner_org_id": "769c9ae7-73c3-4e47-ae19-903170fc3eb8",
+      "count": 9,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-11-15T19:54:23.590Z",
+      "last_cve_date": "2026-09-15T14:04:25.241Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2024": 3,
+        "2025": 2,
+        "2026": 3
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 349
+    },
+    {
+      "name": "GEHC",
+      "assigner_org_id": "171caf72-b841-4e04-a68e-93493aff2b94",
+      "count": 9,
+      "years_active": 1,
+      "first_cve_year": 2024,
+      "last_cve_year": 2024,
+      "first_cve_date": "2024-05-14T15:10:22.262Z",
+      "last_cve_date": "2024-05-14T17:16:39.659Z",
+      "days_since_last_cve": 862,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 9
+      },
+      "years_active_list": [
+        2024,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 350
+    },
+    {
+      "name": "Cato",
+      "assigner_org_id": "2505284f-8ffb-486c-bf60-e19c1097a90b",
+      "count": 9,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-07-31T16:55:20.505Z",
+      "last_cve_date": "2026-07-01T14:07:28.896Z",
+      "days_since_last_cve": 84,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 5,
+        "2025": 2,
+        "2026": 2
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 351
+    },
+    {
+      "name": "Toreon",
+      "assigner_org_id": "1c6b5737-9389-4011-8117-89fa251edfb2",
+      "count": 9,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-07-03T11:18:26.211Z",
+      "last_cve_date": "2026-07-29T13:46:06.383Z",
+      "days_since_last_cve": 56,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 6,
+        "2026": 3
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 352
+    },
+    {
+      "name": "BCNY",
+      "assigner_org_id": "59469e6c-7ea7-446f-8e43-06aa32c115e8",
+      "count": 9,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-11-21T17:55:52.758Z",
+      "last_cve_date": "2026-09-23T19:02:02.034Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 3,
+        "2026": 6
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 353
+    },
+    {
+      "name": "bizerba",
+      "assigner_org_id": "0beee27a-7d8c-424f-8e46-ac453fa147e6",
+      "count": 9,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-03-26T14:49:38.291Z",
+      "last_cve_date": "2026-07-20T11:54:37.566Z",
+      "days_since_last_cve": 65,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 7,
+        "2026": 2
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 354
+    },
+    {
+      "name": "Silver Peak",
+      "assigner_org_id": "83cc1b1a-46b0-4ac1-94f2-bbef3319bc4c",
+      "count": 8,
+      "years_active": 1,
+      "first_cve_year": 2020,
+      "last_cve_year": 2020,
+      "first_cve_date": "2020-05-05T19:53:56.000Z",
+      "last_cve_date": "2020-12-11T15:24:23.056Z",
+      "days_since_last_cve": 2112,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 8
+      },
+      "years_active_list": [
+        2020,
+        2020
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 355
+    },
+    {
+      "name": "Phoenix",
+      "assigner_org_id": "22d9ba52-f336-4b0d-bf1f-0efbdcc3c1de",
+      "count": 8,
+      "years_active": 3,
+      "first_cve_year": 2023,
+      "last_cve_year": 2025,
+      "first_cve_date": "2023-11-14T23:17:07.869Z",
+      "last_cve_date": "2025-05-13T14:56:41.235Z",
+      "days_since_last_cve": 498,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 2,
+        "2024": 3,
+        "2025": 3
+      },
+      "years_active_list": [
+        2023,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 356
+    },
+    {
+      "name": "1E",
+      "assigner_org_id": "4a68d2b9-b68a-4765-95bd-17f35092666b",
+      "count": 8,
+      "years_active": 3,
+      "first_cve_year": 2023,
+      "last_cve_year": 2025,
+      "first_cve_date": "2023-10-05T10:11:20.065Z",
+      "last_cve_date": "2025-03-12T15:25:27.765Z",
+      "days_since_last_cve": 560,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 6,
+        "2024": 1,
+        "2025": 1
+      },
+      "years_active_list": [
+        2023,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 357
+    },
+    {
+      "name": "PlexTrac",
+      "assigner_org_id": "5fea7123-217b-4b2d-ada8-8892719b43cd",
+      "count": 8,
+      "years_active": 1,
+      "first_cve_year": 2024,
+      "last_cve_year": 2024,
+      "first_cve_date": "2024-12-13T05:49:23.911Z",
+      "last_cve_date": "2024-12-16T19:09:08.481Z",
+      "days_since_last_cve": 646,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 8
+      },
+      "years_active_list": [
+        2024,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 358
+    },
+    {
+      "name": "seal",
+      "assigner_org_id": "22e2d327-25fe-45d7-9f0c-dcd23b7108df",
+      "count": 8,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-03-27T16:25:34.410Z",
+      "last_cve_date": "2026-08-20T12:42:42.952Z",
+      "days_since_last_cve": 34,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1,
+        "2026": 7
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 359
+    },
+    {
+      "name": "EDB",
+      "assigner_org_id": "20be33e2-bf35-4d13-8fad-18bd2f3e3659",
+      "count": 8,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-05-09T18:12:18.399Z",
+      "last_cve_date": "2026-07-28T17:55:58.209Z",
+      "days_since_last_cve": 57,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2025": 2,
+        "2026": 5
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 360
+    },
+    {
+      "name": "Crestron",
+      "assigner_org_id": "25b0b659-c4b4-483f-aecb-067757d23ef3",
+      "count": 8,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-05-06T19:49:09.288Z",
+      "last_cve_date": "2026-05-05T15:05:12.734Z",
+      "days_since_last_cve": 141,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 7,
+        "2026": 1
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 361
+    },
+    {
+      "name": "ExtremeNetworks",
+      "assigner_org_id": "1c053176-eef3-4d6a-ae0b-24728c86587b",
+      "count": 8,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-06-13T21:06:34.653Z",
+      "last_cve_date": "2026-07-20T17:34:10.950Z",
+      "days_since_last_cve": 65,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 4,
+        "2026": 4
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 362
+    },
+    {
+      "name": "AxxonSoft",
+      "assigner_org_id": "15ede60e-6fda-426e-be9c-e788f151a377",
+      "count": 8,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-09-10T12:28:39.023Z",
+      "last_cve_date": "2025-09-10T12:39:12.391Z",
+      "days_since_last_cve": 378,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 8
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 363
+    },
+    {
+      "name": "Zowe",
+      "assigner_org_id": "b1336bef-059d-4e13-b11b-9a6ef21b3c78",
+      "count": 7,
+      "years_active": 2,
+      "first_cve_year": 2023,
+      "last_cve_year": 2024,
+      "first_cve_date": "2023-01-18T15:23:42.797Z",
+      "last_cve_date": "2024-10-10T07:41:03.374Z",
+      "days_since_last_cve": 713,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 2,
+        "2024": 5
+      },
+      "years_active_list": [
+        2023,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 364
+    },
+    {
+      "name": "Logitech",
+      "assigner_org_id": "b573e801-1dd3-4adf-bd73-c9b814fbe067",
+      "count": 7,
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "first_cve_date": "2022-04-12T18:35:09.413Z",
+      "last_cve_date": "2026-09-14T07:27:36.817Z",
+      "days_since_last_cve": 9,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 2,
+        "2024": 4,
+        "2026": 1
+      },
+      "years_active_list": [
+        2022,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 365
+    },
+    {
+      "name": "IDEMIA",
+      "assigner_org_id": "a87f365f-9d39-4848-9b3a-58c7cae69cab",
+      "count": 7,
+      "years_active": 1,
+      "first_cve_year": 2023,
+      "last_cve_year": 2023,
+      "first_cve_date": "2023-11-28T08:09:10.450Z",
+      "last_cve_date": "2023-12-15T11:33:17.760Z",
+      "days_since_last_cve": 1013,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 7
+      },
+      "years_active_list": [
+        2023,
+        2023
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 366
+    },
+    {
+      "name": "Wiz",
+      "assigner_org_id": "9947ef80-c5d5-474a-bbab-97341a59000e",
+      "count": 7,
+      "years_active": 2,
+      "first_cve_year": 2024,
+      "last_cve_year": 2025,
+      "first_cve_date": "2024-10-01T07:23:03.891Z",
+      "last_cve_date": "2025-12-10T13:23:46.777Z",
+      "days_since_last_cve": 287,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2025": 6
+      },
+      "years_active_list": [
+        2024,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 2,
+      "epss_elevated_count": 3,
+      "top_cwes": [],
+      "rank": 367
+    },
+    {
+      "name": "TRO",
+      "assigner_org_id": "1b7e193f-2525-49a1-b171-84af8827c9eb",
+      "count": 7,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-08-08T11:09:17.348Z",
+      "last_cve_date": "2026-05-08T11:45:18.462Z",
+      "days_since_last_cve": 138,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 6,
+        "2026": 1
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 368
+    },
+    {
+      "name": "HackRTU",
+      "assigner_org_id": "ffb98d57-deaa-4918-a669-5225ccc13e39",
+      "count": 7,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-02-11T09:05:07.289Z",
+      "last_cve_date": "2026-06-17T08:13:37.802Z",
+      "days_since_last_cve": 98,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 7
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 369
+    },
+    {
+      "name": "ThinkstAppliedResearch",
+      "assigner_org_id": "0f2be0ad-3469-4e56-b38f-4eb96719b425",
+      "count": 7,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-06-03T13:02:15.195Z",
+      "last_cve_date": "2026-09-21T19:39:43.314Z",
+      "days_since_last_cve": 2,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Academic"
+      ],
+      "cves_by_year": {
+        "2026": 7
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 370
+    },
+    {
+      "name": "Hackrate",
+      "assigner_org_id": "7004884b-51e2-48e8-b4a2-5ca29e80453e",
+      "count": 7,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-02-11T14:49:44.991Z",
+      "last_cve_date": "2026-09-10T16:05:55.403Z",
+      "days_since_last_cve": 13,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 7
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 371
+    },
+    {
+      "name": "wibu",
+      "assigner_org_id": "2fc02b1f-71e7-4514-a878-169626f68903",
+      "count": 7,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-08-27T07:06:17.884Z",
+      "last_cve_date": "2026-08-27T07:46:30.828Z",
+      "days_since_last_cve": 27,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 7
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 372
+    },
+    {
+      "name": "obdev",
+      "assigner_org_id": "e0cebea7-a708-4bfe-81c1-855d35eb4544",
+      "count": 6,
+      "years_active": 5,
+      "first_cve_year": 2016,
+      "last_cve_year": 2020,
+      "first_cve_date": "2016-11-15T15:00:00.000Z",
+      "last_cve_date": "2020-06-30T16:33:54.000Z",
+      "days_since_last_cve": 2276,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2016": 1,
+        "2017": 1,
+        "2018": 1,
+        "2019": 2,
+        "2020": 1
+      },
+      "years_active_list": [
+        2016,
+        2020
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 373
+    },
+    {
+      "name": "duo",
+      "assigner_org_id": "7cd4c57f-0a88-4dda-be53-70336b413766",
+      "count": 6,
+      "years_active": 3,
+      "first_cve_year": 2017,
+      "last_cve_year": 2019,
+      "first_cve_date": "2017-08-24T16:00:00.000Z",
+      "last_cve_date": "2019-04-17T14:01:03.000Z",
+      "days_since_last_cve": 2716,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 5,
+        "2017": 1
+      },
+      "years_active_list": [
+        2017,
+        2019
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 374
+    },
+    {
+      "name": "360ST",
+      "assigner_org_id": "40f8fa2f-7875-43d0-a30e-e901a5537754",
+      "count": 6,
+      "years_active": 3,
+      "first_cve_year": 2019,
+      "last_cve_year": 2021,
+      "first_cve_date": "2019-11-04T14:42:42.000Z",
+      "last_cve_date": "2021-01-11T15:48:42.000Z",
+      "days_since_last_cve": 2081,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 1,
+        "2020": 4,
+        "2021": 1
+      },
+      "years_active_list": [
+        2019,
+        2021
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 375
+    },
+    {
+      "name": "Opera",
+      "assigner_org_id": "9aee7086-24f5-48b4-9428-908ac90b8b54",
+      "count": 6,
+      "years_active": 7,
+      "first_cve_year": 2019,
+      "last_cve_year": 2025,
+      "first_cve_date": "2019-12-18T21:31:10.000Z",
+      "last_cve_date": "2025-10-31T14:10:19.919Z",
+      "days_since_last_cve": 327,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2019": 1,
+        "2025": 2,
+        "2020": 2,
+        "2021": 1
+      },
+      "years_active_list": [
+        2019,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 376
+    },
+    {
+      "name": "Synaptics",
+      "assigner_org_id": "54bb2a58-4278-44a9-851f-17e74ee51f48",
+      "count": 6,
+      "years_active": 4,
+      "first_cve_year": 2022,
+      "last_cve_year": 2025,
+      "first_cve_date": "2022-06-16T16:15:00.966Z",
+      "last_cve_date": "2025-12-01T18:55:10.227Z",
+      "days_since_last_cve": 296,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 1,
+        "2024": 2,
+        "2023": 1,
+        "2025": 2
+      },
+      "years_active_list": [
+        2022,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 377
+    },
+    {
+      "name": "ShopBeat",
+      "assigner_org_id": "d3f162d7-5820-4c58-beef-03f43baaf8ad",
+      "count": 6,
+      "years_active": 1,
+      "first_cve_year": 2023,
+      "last_cve_year": 2023,
+      "first_cve_date": "2023-05-30T00:00:00.000Z",
+      "last_cve_date": "2023-05-30T00:00:00.000Z",
+      "days_since_last_cve": 1212,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 6
+      },
+      "years_active_list": [
+        2023,
+        2023
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 378
+    },
+    {
+      "name": "SK-CERT",
+      "assigner_org_id": "bc375322-d3d7-4481-b261-e29662236cfd",
+      "count": 6,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-09-11T09:04:09.924Z",
+      "last_cve_date": "2026-06-02T11:13:40.342Z",
+      "days_since_last_cve": 113,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2024": 1,
+        "2025": 1,
+        "2026": 3
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 379
+    },
+    {
+      "name": "SoftIron",
+      "assigner_org_id": "0a72a055-908d-47f5-a16a-1f09049c16c6",
+      "count": 6,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-12-05T16:15:07.027Z",
+      "last_cve_date": "2026-02-20T16:23:16.498Z",
+      "days_since_last_cve": 215,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 3,
+        "2024": 1,
+        "2025": 1,
+        "2026": 1
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 380
+    },
+    {
+      "name": "libreswan",
+      "assigner_org_id": "d42dc95b-23f1-4e06-9076-20753a0fb0df",
+      "count": 6,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-03-11T19:39:03.280Z",
+      "last_cve_date": "2026-09-02T02:19:00.114Z",
+      "days_since_last_cve": 21,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 2,
+        "2026": 4
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 381
+    },
+    {
+      "name": "OMRON",
+      "assigner_org_id": "bba440f9-ef23-4224-aa62-7ac0935d18d1",
+      "count": 6,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-01-14T00:45:38.605Z",
+      "last_cve_date": "2026-04-15T04:11:29.716Z",
+      "days_since_last_cve": 161,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 5,
+        "2026": 1
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 382
+    },
+    {
+      "name": "Canon_EMEA",
+      "assigner_org_id": "4586e0a2-224d-4f8a-9cb4-8882b208c0b3",
+      "count": 6,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-09-02T19:53:10.487Z",
+      "last_cve_date": "2026-09-23T07:22:01.346Z",
+      "days_since_last_cve": 0,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 2,
+        "2025": 2,
+        "2026": 2
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 383
+    },
+    {
+      "name": "OAI",
+      "assigner_org_id": "8f4f43ab-ba69-4d92-aa1d-d772184d6fb7",
+      "count": 6,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-06-05T00:12:32.077Z",
+      "last_cve_date": "2026-09-01T17:14:49.978Z",
+      "days_since_last_cve": 22,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 6
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 384
+    },
+    {
+      "name": "joshbressers",
+      "assigner_org_id": "46fe6300-5254-4a98-9594-a9567bec8179",
+      "count": 5,
+      "years_active": 1,
+      "first_cve_year": 2017,
+      "last_cve_year": 2017,
+      "first_cve_date": "2017-04-03T01:00:00.000Z",
+      "last_cve_date": "2017-11-27T14:00:00.000Z",
+      "days_since_last_cve": 3222,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2017": 5
+      },
+      "years_active_list": [
+        2017,
+        2017
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 385
+    },
+    {
+      "name": "alibaba",
+      "assigner_org_id": "0cc2b86d-1d45-434d-ae74-11d09ec61ae8",
+      "count": 5,
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "first_cve_date": "2021-11-03T19:09:33.000Z",
+      "last_cve_date": "2026-07-28T09:05:30.652Z",
+      "days_since_last_cve": 57,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 1,
+        "2026": 4
+      },
+      "years_active_list": [
+        2021,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 386
+    },
+    {
+      "name": "Mirantis",
+      "assigner_org_id": "ac17a704-eccd-4263-a802-5cee95c1d547",
+      "count": 5,
+      "years_active": 1,
+      "first_cve_year": 2022,
+      "last_cve_year": 2022,
+      "first_cve_date": "2022-01-10T15:05:44.000Z",
+      "last_cve_date": "2022-02-04T22:29:20.398Z",
+      "days_since_last_cve": 1692,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 5
+      },
+      "years_active_list": [
+        2022,
+        2022
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 387
+    },
+    {
+      "name": "Baicells",
+      "assigner_org_id": "084566ad-deee-4e89-acff-6b7b1bf9d4b7",
+      "count": 5,
+      "years_active": 2,
+      "first_cve_year": 2023,
+      "last_cve_year": 2024,
+      "first_cve_date": "2023-01-24T15:51:17.731Z",
+      "last_cve_date": "2024-06-25T01:34:56.567Z",
+      "days_since_last_cve": 820,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 4,
+        "2024": 1
+      },
+      "years_active_list": [
+        2023,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 388
+    },
+    {
+      "name": "ODA",
+      "assigner_org_id": "8a9629cb-c5e7-4d2a-a894-111e8039b7ea",
+      "count": 5,
+      "years_active": 3,
+      "first_cve_year": 2023,
+      "last_cve_year": 2025,
+      "first_cve_date": "2023-11-07T15:16:22.607Z",
+      "last_cve_date": "2025-12-22T15:48:07.288Z",
+      "days_since_last_cve": 275,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 2,
+        "2024": 2,
+        "2025": 1
+      },
+      "years_active_list": [
+        2023,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 389
+    },
+    {
+      "name": "AlgoSec",
+      "assigner_org_id": "ca5f073f-8266-4d43-b3e3-6eb0bb18a738",
+      "count": 5,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-11-02T07:47:50.794Z",
+      "last_cve_date": "2026-09-08T10:44:32.657Z",
+      "days_since_last_cve": 15,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2023": 1,
+        "2025": 2,
+        "2026": 1
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 390
+    },
+    {
+      "name": "Dfinity",
+      "assigner_org_id": "6b35d637-e00f-4228-858c-b20ad6e1d07b",
+      "count": 5,
+      "years_active": 2,
+      "first_cve_year": 2023,
+      "last_cve_year": 2024,
+      "first_cve_date": "2023-12-08T14:26:09.331Z",
+      "last_cve_date": "2024-12-09T14:38:07.288Z",
+      "days_since_last_cve": 653,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2024": 4
+      },
+      "years_active_list": [
+        2023,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 391
+    },
+    {
+      "name": "Milestone",
+      "assigner_org_id": "cf45122d-9d50-442a-9b23-e05cde9943d8",
+      "count": 5,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-10-08T10:00:38.099Z",
+      "last_cve_date": "2026-07-14T09:45:22.651Z",
+      "days_since_last_cve": 71,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Government"
+      ],
+      "cves_by_year": {
+        "2024": 2,
+        "2025": 2,
+        "2026": 1
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 392
+    },
+    {
+      "name": "tlt_net",
+      "assigner_org_id": "001d69cf-3fc9-4203-93fb-9865b54e05b2",
+      "count": 5,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-12-10T08:56:55.195Z",
+      "last_cve_date": "2026-08-13T10:52:35.564Z",
+      "days_since_last_cve": 41,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2025": 1,
+        "2026": 3
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 393
+    },
+    {
+      "name": "CyberArk",
+      "assigner_org_id": "96148269-fe82-4198-b1bf-3a73ce8bc92e",
+      "count": 5,
+      "years_active": 2,
+      "first_cve_year": 2024,
+      "last_cve_year": 2025,
+      "first_cve_date": "2024-12-15T10:56:26.124Z",
+      "last_cve_date": "2025-09-01T19:03:19.540Z",
+      "days_since_last_cve": 387,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2025": 4
+      },
+      "years_active_list": [
+        2024,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 394
+    },
+    {
+      "name": "Seagate",
+      "assigner_org_id": "c6156efd-4bd0-48d7-8520-680200527478",
+      "count": 5,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-08-14T16:27:05.364Z",
+      "last_cve_date": "2026-06-02T22:31:45.704Z",
+      "days_since_last_cve": 113,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 2,
+        "2026": 3
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 395
+    },
+    {
+      "name": "CrowdStrike",
+      "assigner_org_id": "13ddcd98-6f4a-40a8-8e24-29ca0aee4661",
+      "count": 5,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-02-12T18:27:35.458Z",
+      "last_cve_date": "2026-09-15T17:47:53.251Z",
+      "days_since_last_cve": 8,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 3,
+        "2026": 2
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 396
+    },
+    {
+      "name": "2N",
+      "assigner_org_id": "be69f613-e5f6-419b-800c-30351aa8933c",
+      "count": 5,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-03-04T15:19:13.116Z",
+      "last_cve_date": "2026-03-04T15:31:59.211Z",
+      "days_since_last_cve": 203,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 5
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 397
+    },
+    {
+      "name": "FERMAX",
+      "assigner_org_id": "539080bd-5750-4cce-b30b-eed9a4ef6dcc",
+      "count": 5,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-12-02T07:55:06.867Z",
+      "last_cve_date": "2026-09-16T10:13:22.416Z",
+      "days_since_last_cve": 7,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1,
+        "2026": 4
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 398
+    },
+    {
+      "name": "StrongDM",
+      "assigner_org_id": "ebf2cdfb-f390-4894-8ec9-f81bf1c57e6b",
+      "count": 5,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-08-20T16:41:25.007Z",
+      "last_cve_date": "2026-05-29T18:28:00.572Z",
+      "days_since_last_cve": 117,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 4,
+        "2026": 1
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 399
+    },
+    {
+      "name": "Canva",
+      "assigner_org_id": "61adb53e-e4b3-47f7-8a93-4717c9e77dc6",
+      "count": 5,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-09-04T06:00:46.389Z",
+      "last_cve_date": "2026-09-21T06:43:02.132Z",
+      "days_since_last_cve": 2,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 5
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 400
+    },
+    {
+      "name": "PTC",
+      "assigner_org_id": "0b655efc-079c-4cb9-9e8d-164871239f4e",
+      "count": 5,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-03-23T21:48:05.652Z",
+      "last_cve_date": "2026-08-20T22:11:25.150Z",
+      "days_since_last_cve": 34,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 5
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [],
+      "rank": 401
+    },
+    {
+      "name": "Caliptra",
+      "assigner_org_id": "b01ddd03-5ef6-483b-b2c5-acba77f1a554",
+      "count": 5,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-06-23T23:49:44.591Z",
+      "last_cve_date": "2026-08-04T00:03:23.278Z",
+      "days_since_last_cve": 50,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 5
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 402
+    },
+    {
+      "name": "Cribl",
+      "assigner_org_id": "af879a92-7297-456a-bb0e-905ac6c64bdc",
+      "count": 5,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-05-12T01:06:25.477Z",
+      "last_cve_date": "2026-07-27T19:27:31.700Z",
+      "days_since_last_cve": 58,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 5
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 403
+    },
+    {
+      "name": "B.Braun",
+      "assigner_org_id": "653264ec-f98b-4e8f-b8b4-540a01b7657d",
+      "count": 4,
+      "years_active": 3,
+      "first_cve_year": 2023,
+      "last_cve_year": 2025,
+      "first_cve_date": "2023-03-13T08:14:32.358Z",
+      "last_cve_date": "2025-06-06T08:14:00.444Z",
+      "days_since_last_cve": 474,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2025": 3
+      },
+      "years_active_list": [
+        2023,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 404
+    },
+    {
+      "name": "Hillstone",
+      "assigner_org_id": "2b565742-f273-46f9-b583-07c1fcdea31a",
+      "count": 4,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-11-04T00:00:00.000Z",
+      "last_cve_date": "2026-02-04T03:11:30.275Z",
+      "days_since_last_cve": 231,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2024": 1,
+        "2025": 1,
+        "2026": 1
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 405
+    },
+    {
+      "name": "TXOne",
+      "assigner_org_id": "3ad20294-822c-4ebc-9301-f9a7cf62d46e",
+      "count": 4,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-01-08T03:00:31.170Z",
+      "last_cve_date": "2026-07-17T03:50:13.217Z",
+      "days_since_last_cve": 68,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 3,
+        "2026": 1
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 406
+    },
+    {
+      "name": "SCHUTZWERK",
+      "assigner_org_id": "23637b5d-af4c-4cf9-b8f6-deb7fd0f8423",
+      "count": 4,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-04-30T07:10:17.999Z",
+      "last_cve_date": "2026-09-09T06:14:22.143Z",
+      "days_since_last_cve": 14,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 4
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 407
+    },
+    {
+      "name": "Ciena",
+      "assigner_org_id": "7bd90cf1-1651-495e-9ae8-9415fb3c9feb",
+      "count": 4,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-03-05T18:54:00.839Z",
+      "last_cve_date": "2026-07-14T22:25:55.317Z",
+      "days_since_last_cve": 71,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2026": 3
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 408
+    },
+    {
+      "name": "Digi",
+      "assigner_org_id": "e8a6bb0b-e373-42b1-a5de-93e314325576",
+      "count": 4,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-05-12T20:40:03.567Z",
+      "last_cve_date": "2026-07-07T14:32:43.977Z",
+      "days_since_last_cve": 78,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 2,
+        "2026": 2
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 409
+    },
+    {
+      "name": "FSOFT",
+      "assigner_org_id": "5ac195ad-69e7-48e7-9c1e-bfc958c39761",
+      "count": 4,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-03-27T04:00:55.276Z",
+      "last_cve_date": "2026-04-13T02:27:53.206Z",
+      "days_since_last_cve": 163,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 3,
+        "2026": 1
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 410
+    },
+    {
+      "name": "Danfoss",
+      "assigner_org_id": "d7ff35af-cf88-454c-bab9-af60602f10f8",
+      "count": 4,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-05-08T09:41:20.881Z",
+      "last_cve_date": "2026-08-26T05:36:02.006Z",
+      "days_since_last_cve": 28,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Open Source"
+      ],
+      "cves_by_year": {
+        "2025": 3,
+        "2026": 1
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 411
+    },
+    {
+      "name": "postiz",
+      "assigner_org_id": "4cdc9741-f887-419a-a2fd-acbbd2729276",
+      "count": 4,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-08-06T17:02:44.054Z",
+      "last_cve_date": "2026-09-22T16:17:00.413Z",
+      "days_since_last_cve": 1,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 4
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 412
+    },
+    {
+      "name": "linqi",
+      "assigner_org_id": "86c47df7-7d28-48da-920a-6423c52fd3da",
+      "count": 4,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-06-05T10:18:35.703Z",
+      "last_cve_date": "2026-06-05T12:37:46.830Z",
+      "days_since_last_cve": 110,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 4
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 413
+    },
+    {
+      "name": "Halborn",
+      "assigner_org_id": "79d7e77b-4bd9-4e64-ae2c-02965b1d2b73",
+      "count": 3,
+      "years_active": 1,
+      "first_cve_year": 2023,
+      "last_cve_year": 2023,
+      "first_cve_date": "2023-04-17T00:00:00.000Z",
+      "last_cve_date": "2023-08-09T21:01:37.417Z",
+      "days_since_last_cve": 1141,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 3
+      },
+      "years_active_list": [
+        2023,
+        2023
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 414
+    },
+    {
+      "name": "42Gears",
+      "assigner_org_id": "e5d7a401-f4d6-4559-911a-da9b371cd8ce",
+      "count": 3,
+      "years_active": 1,
+      "first_cve_year": 2023,
+      "last_cve_year": 2023,
+      "first_cve_date": "2023-04-27T11:51:45.946Z",
+      "last_cve_date": "2023-07-25T08:59:31.668Z",
+      "days_since_last_cve": 1156,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 3
+      },
+      "years_active_list": [
+        2023,
+        2023
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 415
+    },
+    {
+      "name": "NX",
+      "assigner_org_id": "96d4e157-0bf0-48b3-8efd-382c68caf4e0",
+      "count": 3,
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "first_cve_date": "2023-11-22T17:56:56.711Z",
+      "last_cve_date": "2026-08-24T14:51:08.681Z",
+      "days_since_last_cve": 30,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2026": 2
+      },
+      "years_active_list": [
+        2023,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 416
+    },
+    {
+      "name": "Forescout",
+      "assigner_org_id": "a14582b7-06f4-4d66-8e82-3d7ba3739e88",
+      "count": 3,
+      "years_active": 2,
+      "first_cve_year": 2024,
+      "last_cve_year": 2025,
+      "first_cve_date": "2024-10-23T17:37:42.978Z",
+      "last_cve_date": "2025-05-13T17:34:53.955Z",
+      "days_since_last_cve": 498,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2025": 2
+      },
+      "years_active_list": [
+        2024,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 417
+    },
+    {
+      "name": "Roche",
+      "assigner_org_id": "5cdcf916-2b10-4ec8-bfc1-d054821e439e",
+      "count": 3,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-01-17T20:02:32.351Z",
+      "last_cve_date": "2026-06-02T13:23:45.761Z",
+      "days_since_last_cve": 113,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 2,
+        "2026": 1
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 418
+    },
+    {
+      "name": "CoolKit",
+      "assigner_org_id": "68870bb1-d075-4169-957d-e580b18692b9",
+      "count": 3,
+      "years_active": 1,
+      "first_cve_year": 2024,
+      "last_cve_year": 2024,
+      "first_cve_date": "2024-04-01T09:13:53.082Z",
+      "last_cve_date": "2024-10-08T06:14:12.144Z",
+      "days_since_last_cve": 715,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 3
+      },
+      "years_active_list": [
+        2024,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 419
+    },
+    {
+      "name": "9front",
+      "assigner_org_id": "1d66c9f9-fff2-411a-aa19-ca6312fa25e9",
+      "count": 3,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-08-25T21:31:08.246Z",
+      "last_cve_date": "2026-05-22T03:21:49.646Z",
+      "days_since_last_cve": 124,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2026": 2
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 420
+    },
+    {
+      "name": "JAMF",
+      "assigner_org_id": "67325c3f-c596-46c5-a235-e1a1e73abe4e",
+      "count": 3,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-06-27T21:28:35.198Z",
+      "last_cve_date": "2026-01-21T15:25:19.543Z",
+      "days_since_last_cve": 245,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 2,
+        "2026": 1
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 421
+    },
+    {
+      "name": "ClickHouse",
+      "assigner_org_id": "cb7ba516-3b07-4c98-b0c2-715220f1a8f6",
+      "count": 3,
+      "years_active": 2,
+      "first_cve_year": 2024,
+      "last_cve_year": 2025,
+      "first_cve_date": "2024-08-01T15:57:25.304Z",
+      "last_cve_date": "2025-04-11T04:27:35.846Z",
+      "days_since_last_cve": 530,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2025": 2
+      },
+      "years_active_list": [
+        2024,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 422
+    },
+    {
+      "name": "Philips",
+      "assigner_org_id": "20705f08-db8b-4497-8f94-7eea62317651",
+      "count": 3,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-04-07T15:36:46.060Z",
+      "last_cve_date": "2025-04-07T16:23:00.325Z",
+      "days_since_last_cve": 534,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 3
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 423
+    },
+    {
+      "name": "Saviynt",
+      "assigner_org_id": "bd8dbf88-98d9-42c6-be08-cf8e48a32093",
+      "count": 3,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-04-21T09:20:14.110Z",
+      "last_cve_date": "2025-04-21T09:39:16.343Z",
+      "days_since_last_cve": 520,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 3
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 424
+    },
+    {
+      "name": "rust",
+      "assigner_org_id": "986d4109-89ea-491f-99fd-a8e4803919bd",
+      "count": 3,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-10-01T16:49:50.139Z",
+      "last_cve_date": "2026-05-25T08:57:08.488Z",
+      "days_since_last_cve": 121,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1,
+        "2026": 2
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 425
+    },
+    {
+      "name": "Jaspersoft",
+      "assigner_org_id": "db6d2600-d19b-4111-a010-f3c4ed70cd50",
+      "count": 3,
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "first_cve_date": "2025-09-16T16:41:44.931Z",
+      "last_cve_date": "2026-08-10T18:00:20.122Z",
+      "days_since_last_cve": 44,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1,
+        "2026": 2
+      },
+      "years_active_list": [
+        2025,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 426
+    },
+    {
+      "name": "Radiometer",
+      "assigner_org_id": "46b595e9-1acc-41cb-9398-adaf98d37a9b",
+      "count": 3,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-12-17T11:45:43.341Z",
+      "last_cve_date": "2025-12-17T12:36:03.779Z",
+      "days_since_last_cve": 280,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 3
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 427
+    },
+    {
+      "name": "WindRiver",
+      "assigner_org_id": "0bf9931a-6ebf-4f48-bd14-39ee5e1d61f8",
+      "count": 3,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-03-21T22:20:36.101Z",
+      "last_cve_date": "2025-09-18T18:46:44.962Z",
+      "days_since_last_cve": 370,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 3
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 428
+    },
+    {
+      "name": "OMICRON",
+      "assigner_org_id": "57995746-fc30-4a4d-94f6-a13d079c41f4",
+      "count": 3,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-08-06T13:14:24.169Z",
+      "last_cve_date": "2026-08-06T13:14:25.937Z",
+      "days_since_last_cve": 48,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 3
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 429
+    },
+    {
+      "name": "systemd",
+      "assigner_org_id": "98a521c5-3a3e-4e2b-bc27-002067e0463c",
+      "count": 3,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-08-10T13:02:31.716Z",
+      "last_cve_date": "2026-08-10T13:03:06.869Z",
+      "days_since_last_cve": 44,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 3
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 430
+    },
+    {
+      "name": "watchdog",
+      "assigner_org_id": "34edf4f2-2577-40ab-82ce-39f45972c129",
+      "count": 3,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-09-20T12:02:34.251Z",
+      "last_cve_date": "2026-09-20T12:24:47.393Z",
+      "days_since_last_cve": 3,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 3
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 431
+    },
+    {
+      "name": "YesWeHack",
+      "assigner_org_id": "30a5e7fb-040d-440a-8cdf-a4a2068ce72e",
+      "count": 3,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-09-07T07:58:09.190Z",
+      "last_cve_date": "2026-09-07T08:07:31.633Z",
+      "days_since_last_cve": 16,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 3
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 432
+    },
+    {
+      "name": "Replicated",
+      "assigner_org_id": "7d06583b-61c8-4499-8067-80a92a3b48e1",
+      "count": 2,
+      "years_active": 5,
+      "first_cve_year": 2021,
+      "last_cve_year": 2025,
+      "first_cve_date": "2021-11-01T21:03:18.000Z",
+      "last_cve_date": "2025-01-23T22:45:37.185Z",
+      "days_since_last_cve": 608,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 1,
+        "2025": 1
+      },
+      "years_active_list": [
+        2021,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 433
+    },
+    {
+      "name": "OpenBMC",
+      "assigner_org_id": "7eaec9cd-e18a-43f9-bb90-5f82d308c514",
+      "count": 2,
+      "years_active": 1,
+      "first_cve_year": 2022,
+      "last_cve_year": 2022,
+      "first_cve_date": "2022-10-27T13:09:19.424Z",
+      "last_cve_date": "2022-10-27T13:09:19.716Z",
+      "days_since_last_cve": 1427,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 2
+      },
+      "years_active_list": [
+        2022,
+        2022
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 434
+    },
+    {
+      "name": "Profelis",
+      "assigner_org_id": "3039e14d-1e9f-46c2-98a6-44436e4ca5d5",
+      "count": 2,
+      "years_active": 1,
+      "first_cve_year": 2022,
+      "last_cve_year": 2022,
+      "first_cve_date": "2022-03-30T14:55:11.000Z",
+      "last_cve_date": "2022-03-30T14:55:17.000Z",
+      "days_since_last_cve": 1638,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 2
+      },
+      "years_active_list": [
+        2022,
+        2022
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 435
+    },
+    {
+      "name": "Cybellum",
+      "assigner_org_id": "24e70c8d-eeca-431d-8285-199a41b4014e",
+      "count": 2,
+      "years_active": 3,
+      "first_cve_year": 2022,
+      "last_cve_year": 2024,
+      "first_cve_date": "2022-08-23T23:16:32.342Z",
+      "last_cve_date": "2024-03-05T05:23:16.947Z",
+      "days_since_last_cve": 932,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2022": 1,
+        "2024": 1
+      },
+      "years_active_list": [
+        2022,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 436
+    },
+    {
+      "name": "MIM",
+      "assigner_org_id": "f77a3b2e-a86f-4a4e-80d3-3d1378fbb974",
+      "count": 2,
+      "years_active": 3,
+      "first_cve_year": 2023,
+      "last_cve_year": 2025,
+      "first_cve_date": "2023-09-19T14:54:12.524Z",
+      "last_cve_date": "2025-06-04T13:01:17.637Z",
+      "days_since_last_cve": 476,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1,
+        "2025": 1
+      },
+      "years_active_list": [
+        2023,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 437
+    },
+    {
+      "name": "ELAN",
+      "assigner_org_id": "36106deb-8e95-420b-a0a0-e70af5d245df",
+      "count": 2,
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "first_cve_date": "2024-01-12T01:48:47.887Z",
+      "last_cve_date": "2026-08-06T03:46:00.081Z",
+      "days_since_last_cve": 48,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 1,
+        "2026": 1
+      },
+      "years_active_list": [
+        2024,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 438
+    },
+    {
+      "name": "ATIS",
+      "assigner_org_id": "68e1e1d3-5247-4d65-9f39-ef1a02cf571e",
+      "count": 2,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-02-27T12:03:10.610Z",
+      "last_cve_date": "2025-11-24T07:30:49.545Z",
+      "days_since_last_cve": 303,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 2
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 439
+    },
+    {
+      "name": "Huntress",
+      "assigner_org_id": "5dacb0b8-2277-4717-899c-254586fe4912",
+      "count": 2,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-10-09T16:50:49.117Z",
+      "last_cve_date": "2025-12-12T21:01:13.116Z",
+      "days_since_last_cve": 285,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 2
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 2,
+      "epss_high_count": 2,
+      "epss_elevated_count": 2,
+      "top_cwes": [],
+      "rank": 440
+    },
+    {
+      "name": "MON-CSIRT",
+      "assigner_org_id": "9c1820ae-fb77-4810-a8aa-ca46e7474d2f",
+      "count": 2,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-04-21T05:27:06.090Z",
+      "last_cve_date": "2025-11-17T02:48:25.684Z",
+      "days_since_last_cve": 310,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2025": 2
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 441
+    },
+    {
+      "name": "FTI",
+      "assigner_org_id": "763b0cbd-1a52-41de-b280-f255286be201",
+      "count": 2,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-07-22T15:07:35.516Z",
+      "last_cve_date": "2026-07-22T15:14:12.557Z",
+      "days_since_last_cve": 63,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 2
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 442
+    },
+    {
+      "name": "BombadilSystems",
+      "assigner_org_id": "aa17e1a1-c329-4d6e-a1ed-8d0188aea082",
+      "count": 2,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-07-04T13:25:55.283Z",
+      "last_cve_date": "2026-07-04T13:31:14.937Z",
+      "days_since_last_cve": 81,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 2
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 443
+    },
+    {
+      "name": "CODRA",
+      "assigner_org_id": "30aa36b7-a224-4bc9-b7d3-abea20aa4887",
+      "count": 2,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-03-25T12:29:13.631Z",
+      "last_cve_date": "2026-03-25T12:45:27.361Z",
+      "days_since_last_cve": 182,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 2
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 444
+    },
+    {
+      "name": "illumos",
+      "assigner_org_id": "0ca53633-f0b5-4853-ba72-e0a2e62000d0",
+      "count": 2,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-07-16T19:27:16.036Z",
+      "last_cve_date": "2026-07-16T19:29:13.931Z",
+      "days_since_last_cve": 69,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 2
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 445
+    },
+    {
+      "name": "cspcert",
+      "assigner_org_id": "8207d157-a9c5-4c55-ab16-b67a7ac0b646",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2018,
+      "last_cve_year": 2018,
+      "first_cve_date": "2018-11-27T21:00:00.000Z",
+      "last_cve_date": "2018-11-27T21:00:00.000Z",
+      "days_since_last_cve": 2857,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2018": 1
+      },
+      "years_active_list": [
+        2018,
+        2018
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 446
+    },
+    {
+      "name": "EA",
+      "assigner_org_id": "442d7a9f-d735-4edc-91a9-bdd618cbff51",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2020,
+      "last_cve_year": 2020,
+      "first_cve_date": "2020-10-30T16:23:56.000Z",
+      "last_cve_date": "2020-10-30T16:23:56.000Z",
+      "days_since_last_cve": 2154,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2020": 1
+      },
+      "years_active_list": [
+        2020,
+        2020
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 447
+    },
+    {
+      "name": "DeepSurface",
+      "assigner_org_id": "17539d52-06bd-4776-9c7a-95dc115e9083",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2021,
+      "last_cve_year": 2021,
+      "first_cve_date": "2021-04-09T13:34:59.000Z",
+      "last_cve_date": "2021-04-09T13:34:59.000Z",
+      "days_since_last_cve": 1993,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2021": 1
+      },
+      "years_active_list": [
+        2021,
+        2021
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 448
+    },
+    {
+      "name": "Illumio",
+      "assigner_org_id": "ea070963-4842-4451-bceb-906a17f8dc69",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2023,
+      "last_cve_year": 2023,
+      "first_cve_date": "2023-09-26T21:29:36.575Z",
+      "last_cve_date": "2023-09-26T21:29:36.575Z",
+      "days_since_last_cve": 1093,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1
+      },
+      "years_active_list": [
+        2023,
+        2023
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 449
+    },
+    {
+      "name": "OpenCloudOS",
+      "assigner_org_id": "03686db1-8513-43c4-b487-c6ad847afd3a",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2023,
+      "last_cve_year": 2023,
+      "first_cve_date": "2023-08-07T12:13:37.229Z",
+      "last_cve_date": "2023-08-07T12:13:37.229Z",
+      "days_since_last_cve": 1143,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2023": 1
+      },
+      "years_active_list": [
+        2023,
+        2023
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 450
+    },
+    {
+      "name": "GreenRocketSecurity",
+      "assigner_org_id": "6a7d5611-ec52-41f4-b33a-a457deec1320",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2023,
+      "last_cve_year": 2023,
+      "first_cve_date": "2023-09-14T16:43:40.721Z",
+      "last_cve_date": "2023-09-14T16:43:40.721Z",
+      "days_since_last_cve": 1105,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2023": 1
+      },
+      "years_active_list": [
+        2023,
+        2023
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 451
+    },
+    {
+      "name": "ICT",
+      "assigner_org_id": "56c94bcb-ac34-4d7f-b660-d297a6b7ff82",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2024,
+      "last_cve_year": 2024,
+      "first_cve_date": "2024-05-06T22:33:03.969Z",
+      "last_cve_date": "2024-05-06T22:33:03.969Z",
+      "days_since_last_cve": 870,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2024": 1
+      },
+      "years_active_list": [
+        2024,
+        2024
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 452
+    },
+    {
+      "name": "Ribose",
+      "assigner_org_id": "6504adb2-f5e9-4c9b-9eda-5e19c93bd9b3",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-11-21T17:05:15.683Z",
+      "last_cve_date": "2025-11-21T17:05:15.683Z",
+      "days_since_last_cve": 306,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 453
+    },
+    {
+      "name": "iManage",
+      "assigner_org_id": "5d978718-751a-428d-ac8e-4f9445ebfd11",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-04-17T14:58:00.520Z",
+      "last_cve_date": "2025-04-17T14:58:00.520Z",
+      "days_since_last_cve": 524,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 454
+    },
+    {
+      "name": "OB",
+      "assigner_org_id": "7f247420-63a8-4d59-ac93-d85dd04cd014",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-07-24T07:12:13.878Z",
+      "last_cve_date": "2025-07-24T07:12:13.878Z",
+      "days_since_last_cve": 426,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 455
+    },
+    {
+      "name": "openam-jp",
+      "assigner_org_id": "37c6977f-aa3f-41e8-829b-3e8ff4df3c14",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-09-02T02:06:20.806Z",
+      "last_cve_date": "2025-09-02T02:06:20.806Z",
+      "days_since_last_cve": 386,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 456
+    },
+    {
+      "name": "BECLS",
+      "assigner_org_id": "4ad3d9a7-bd20-4af3-8862-46d6b5a570db",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-02-26T16:28:36.746Z",
+      "last_cve_date": "2025-02-26T16:28:36.746Z",
+      "days_since_last_cve": 574,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 457
+    },
+    {
+      "name": "Profisee",
+      "assigner_org_id": "c0ec9282-ea44-45d7-9b32-48d87cb37538",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-06-18T14:46:57.742Z",
+      "last_cve_date": "2025-06-18T14:46:57.742Z",
+      "days_since_last_cve": 462,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 458
+    },
+    {
+      "name": "Dremio",
+      "assigner_org_id": "05b98450-cf83-4905-9546-e47a66a8fec2",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-04-21T15:12:24.391Z",
+      "last_cve_date": "2025-04-21T15:12:24.391Z",
+      "days_since_last_cve": 520,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 459
+    },
+    {
+      "name": "Edgewatch",
+      "assigner_org_id": "8ca67973-55d1-4246-bb7c-ce7e65ad8782",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2025,
+      "last_cve_year": 2025,
+      "first_cve_date": "2025-05-15T11:49:59.054Z",
+      "last_cve_date": "2025-05-15T11:49:59.054Z",
+      "days_since_last_cve": 496,
+      "activity_status": "Inactive",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2025": 1
+      },
+      "years_active_list": [
+        2025,
+        2025
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 460
+    },
+    {
+      "name": "Bull",
+      "assigner_org_id": "5bcc34ac-0282-4e8a-96fc-046c583d3048",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-09-11T08:02:03.465Z",
+      "last_cve_date": "2026-09-11T08:02:03.465Z",
+      "days_since_last_cve": 12,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 1
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 461
+    },
+    {
+      "name": "spartans-security",
+      "assigner_org_id": "66fe30d5-b042-4547-a192-c18da4c41a81",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-02-23T01:24:47.676Z",
+      "last_cve_date": "2026-02-23T01:24:47.676Z",
+      "days_since_last_cve": 212,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "CERT"
+      ],
+      "cves_by_year": {
+        "2026": 1
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 462
+    },
+    {
+      "name": "Nintendo",
+      "assigner_org_id": "60e0823a-f1a8-4923-bd51-812de398c42c",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-09-10T05:13:33.030Z",
+      "last_cve_date": "2026-09-10T05:13:33.030Z",
+      "days_since_last_cve": 13,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 1
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 463
+    },
+    {
+      "name": "Proton",
+      "assigner_org_id": "b2fa7fcc-7d08-41f0-853b-11242c5539db",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-09-07T11:47:32.716Z",
+      "last_cve_date": "2026-09-07T11:47:32.716Z",
+      "days_since_last_cve": 16,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 1
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 464
+    },
+    {
+      "name": "Nutanix",
+      "assigner_org_id": "2ffdacf6-8681-47df-b023-4f11abd61c1d",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-04-28T13:06:35.686Z",
+      "last_cve_date": "2026-04-28T13:06:35.686Z",
+      "days_since_last_cve": 148,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 1
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 465
+    },
+    {
+      "name": "KrakenD",
+      "assigner_org_id": "e5bd9809-e237-4575-952b-81f8a96826ee",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-02-25T15:12:23.336Z",
+      "last_cve_date": "2026-02-25T15:12:23.336Z",
+      "days_since_last_cve": 210,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 1
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 466
+    },
+    {
+      "name": "Intigriti",
+      "assigner_org_id": "3ba556a3-57d7-4c5d-b460-9d6daa180ee1",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-02-27T14:09:38.150Z",
+      "last_cve_date": "2026-02-27T14:09:38.150Z",
+      "days_since_last_cve": 208,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 1
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 467
+    },
+    {
+      "name": "Spotfire",
+      "assigner_org_id": "8b479ca1-d558-42a2-87eb-a4751ba58a09",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-07-14T13:49:04.755Z",
+      "last_cve_date": "2026-07-14T13:49:04.755Z",
+      "days_since_last_cve": 71,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 1
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 468
+    },
+    {
+      "name": "Echo",
+      "assigner_org_id": "abd028dc-c042-4c4d-9749-38d0f850af89",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-05-04T12:38:28.464Z",
+      "last_cve_date": "2026-05-04T12:38:28.464Z",
+      "days_since_last_cve": 142,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 1
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 469
+    },
+    {
+      "name": "openGauss",
+      "assigner_org_id": "a1a479f7-907b-4ae8-a999-9148cadc9224",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-06-30T13:56:16.846Z",
+      "last_cve_date": "2026-06-30T13:56:16.846Z",
+      "days_since_last_cve": 85,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 1
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 470
+    },
+    {
+      "name": "Vestel",
+      "assigner_org_id": "5431be70-064b-4f6a-be51-69eacabef109",
+      "count": 1,
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "first_cve_date": "2026-08-07T13:32:45.790Z",
+      "last_cve_date": "2026-08-07T13:32:45.790Z",
+      "days_since_last_cve": 47,
+      "activity_status": "Active",
+      "is_official": true,
+      "cna_types": [
+        "Vendor"
+      ],
+      "cves_by_year": {
+        "2026": 1
+      },
+      "years_active_list": [
+        2026,
+        2026
+      ],
+      "severity_distribution": {},
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [],
+      "rank": 471
+    }
+  ]
+}
\ No newline at end of file
diff --git a/web/data/cna_analysis_current_year.json b/web/data/cna_analysis_current_year.json
new file mode 100644
index 00000000000..c470f12371d
--- /dev/null
+++ b/web/data/cna_analysis_current_year.json
@@ -0,0 +1,18428 @@
+{
+  "generated_at": "2026-09-23T22:53:40.349308",
+  "source": "CVE V5 List (Authoritative)",
+  "year": 2026,
+  "total_cnas": 378,
+  "active_cnas": 378,
+  "inactive_cnas": 0,
+  "official_cnas": 378,
+  "unofficial_cnas": 0,
+  "cna_list": [
+    {
+      "name": "GitHub_M",
+      "assigner_org_id": "a0819718-46f1-4df5-94e2-005712e83aaa",
+      "count": 10614,
+      "rank": 1,
+      "first_cve_date": "2026-01-01T15:11:46.028Z",
+      "last_cve_date": "2026-09-23T22:07:35.095Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Open Source"
+      ],
+      "severity_distribution": {
+        "Medium": 4273,
+        "High": 4448,
+        "Low": 568,
+        "Critical": 1325
+      },
+      "top_cwe_types": {
+        "CWE-79": 961,
+        "CWE-22": 755,
+        "CWE-918": 640,
+        "CWE-862": 629,
+        "CWE-863": 518
+      },
+      "kev_count": 12,
+      "epss_high_count": 8,
+      "epss_elevated_count": 55,
+      "top_cwes": [
+        [
+          "CWE-79",
+          961
+        ],
+        [
+          "CWE-22",
+          755
+        ],
+        [
+          "CWE-918",
+          640
+        ],
+        [
+          "CWE-862",
+          629
+        ],
+        [
+          "CWE-863",
+          518
+        ]
+      ]
+    },
+    {
+      "name": "Linux",
+      "assigner_org_id": "416baaa9-dc9f-4396-8d5f-8c081fb06d67",
+      "count": 6547,
+      "rank": 2,
+      "first_cve_date": "2026-01-05T09:32:25.534Z",
+      "last_cve_date": "2026-09-17T16:12:24.403Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Open Source"
+      ],
+      "severity_distribution": {
+        "High": 2388,
+        "Critical": 533,
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-825": 18,
+        "CWE-787": 11,
+        "CWE-416": 8,
+        "CWE-1341": 5,
+        "CWE-190": 5
+      },
+      "kev_count": 3,
+      "epss_high_count": 3,
+      "epss_elevated_count": 3,
+      "top_cwes": [
+        [
+          "CWE-825",
+          18
+        ],
+        [
+          "CWE-787",
+          11
+        ],
+        [
+          "CWE-416",
+          8
+        ],
+        [
+          "CWE-1341",
+          5
+        ],
+        [
+          "CWE-190",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "VulnCheck",
+      "assigner_org_id": "83251b91-4cc7-4094-a5c7-464a1b83ea10",
+      "count": 6380,
+      "rank": 3,
+      "first_cve_date": "2026-01-03T21:18:51.053Z",
+      "last_cve_date": "2026-09-23T21:36:23.658Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 938,
+        "Medium": 2008,
+        "High": 3367,
+        "Low": 67
+      },
+      "top_cwe_types": {
+        "CWE-79": 675,
+        "CWE-89": 463,
+        "CWE-862": 348,
+        "CWE-22": 334,
+        "CWE-863": 257
+      },
+      "kev_count": 6,
+      "epss_high_count": 6,
+      "epss_elevated_count": 23,
+      "top_cwes": [
+        [
+          "CWE-79",
+          675
+        ],
+        [
+          "CWE-89",
+          463
+        ],
+        [
+          "CWE-862",
+          348
+        ],
+        [
+          "CWE-22",
+          334
+        ],
+        [
+          "CWE-863",
+          257
+        ]
+      ]
+    },
+    {
+      "name": "VulDB",
+      "assigner_org_id": "1af790b2-7ee1-4545-860a-a788eba489b5",
+      "count": 5114,
+      "rank": 4,
+      "first_cve_date": "2026-01-01T09:02:10.684Z",
+      "last_cve_date": "2026-09-23T22:45:09.921Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "severity_distribution": {
+        "Medium": 3028,
+        "Critical": 718,
+        "High": 1275,
+        "Low": 93
+      },
+      "top_cwe_types": {
+        "CWE-74": 1413,
+        "CWE-89": 1032,
+        "CWE-119": 822,
+        "CWE-77": 618,
+        "CWE-94": 527
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 42,
+      "top_cwes": [
+        [
+          "CWE-74",
+          1413
+        ],
+        [
+          "CWE-89",
+          1032
+        ],
+        [
+          "CWE-119",
+          822
+        ],
+        [
+          "CWE-77",
+          618
+        ],
+        [
+          "CWE-94",
+          527
+        ]
+      ]
+    },
+    {
+      "name": "Patchstack",
+      "assigner_org_id": "21595511-bba5-4825-b968-b78d1f9984a3",
+      "count": 3923,
+      "rank": 5,
+      "first_cve_date": "2026-01-05T10:18:16.966Z",
+      "last_cve_date": "2026-09-23T19:28:55.531Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "severity_distribution": {
+        "Medium": 1504,
+        "Critical": 496,
+        "High": 1918,
+        "Low": 5
+      },
+      "top_cwe_types": {
+        "CWE-862": 985,
+        "CWE-79": 924,
+        "CWE-98": 509,
+        "CWE-89": 337,
+        "CWE-502": 264
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-862",
+          985
+        ],
+        [
+          "CWE-79",
+          924
+        ],
+        [
+          "CWE-98",
+          509
+        ],
+        [
+          "CWE-89",
+          337
+        ],
+        [
+          "CWE-502",
+          264
+        ]
+      ]
+    },
+    {
+      "name": "mitre",
+      "assigner_org_id": "8254265b-2729-46b6-b9e3-3dfca2d5bfca",
+      "count": 3228,
+      "rank": 6,
+      "first_cve_date": "2026-01-01T04:39:48.140Z",
+      "last_cve_date": "2026-09-23T16:58:37.139Z",
+      "years_active": 28,
+      "first_cve_year": 1999,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Program"
+      ],
+      "severity_distribution": {
+        "Medium": 1029,
+        "High": 1261,
+        "Critical": 748,
+        "Low": 173
+      },
+      "top_cwe_types": {
+        "CWE-79": 317,
+        "CWE-89": 263,
+        "CWE-284": 261,
+        "CWE-121": 183,
+        "CWE-94": 139
+      },
+      "kev_count": 8,
+      "epss_high_count": 2,
+      "epss_elevated_count": 14,
+      "top_cwes": [
+        [
+          "CWE-79",
+          317
+        ],
+        [
+          "CWE-89",
+          263
+        ],
+        [
+          "CWE-284",
+          261
+        ],
+        [
+          "CWE-121",
+          183
+        ],
+        [
+          "CWE-94",
+          139
+        ]
+      ]
+    },
+    {
+      "name": "oracle",
+      "assigner_org_id": "43595867-4340-4103-b7a2-9a5208d29a85",
+      "count": 3076,
+      "rank": 7,
+      "first_cve_date": "2026-01-20T21:56:19.994Z",
+      "last_cve_date": "2026-09-15T21:53:18.809Z",
+      "years_active": 19,
+      "first_cve_year": 2008,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 671,
+        "Low": 115,
+        "High": 1698,
+        "Critical": 592
+      },
+      "top_cwe_types": {
+        "CWE-284": 2071,
+        "CWE-306": 454,
+        "CWE-269": 325,
+        "CWE-200": 176,
+        "CWE-400": 152
+      },
+      "kev_count": 3,
+      "epss_high_count": 1,
+      "epss_elevated_count": 3,
+      "top_cwes": [
+        [
+          "CWE-284",
+          2071
+        ],
+        [
+          "CWE-306",
+          454
+        ],
+        [
+          "CWE-269",
+          325
+        ],
+        [
+          "CWE-200",
+          176
+        ],
+        [
+          "CWE-400",
+          152
+        ]
+      ]
+    },
+    {
+      "name": "Wordfence",
+      "assigner_org_id": "b15e7b5b-3da4-40ae-a43c-f7aa60e62599",
+      "count": 3046,
+      "rank": 8,
+      "first_cve_date": "2026-01-01T16:19:30.690Z",
+      "last_cve_date": "2026-09-23T21:27:34.729Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "severity_distribution": {
+        "Critical": 180,
+        "Medium": 2146,
+        "High": 707,
+        "Low": 13
+      },
+      "top_cwe_types": {
+        "CWE-79": 1138,
+        "CWE-862": 581,
+        "CWE-89": 262,
+        "CWE-352": 187,
+        "CWE-639": 127
+      },
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 12,
+      "top_cwes": [
+        [
+          "CWE-79",
+          1138
+        ],
+        [
+          "CWE-862",
+          581
+        ],
+        [
+          "CWE-89",
+          262
+        ],
+        [
+          "CWE-352",
+          187
+        ],
+        [
+          "CWE-639",
+          127
+        ]
+      ]
+    },
+    {
+      "name": "microsoft",
+      "assigner_org_id": "f38d906d-7342-40ea-92c1-6c4a2c6478c8",
+      "count": 2961,
+      "rank": 9,
+      "first_cve_date": "2026-01-07T22:54:54.800Z",
+      "last_cve_date": "2026-09-23T22:40:40.537Z",
+      "years_active": 22,
+      "first_cve_year": 2005,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 730,
+        "High": 2023,
+        "Critical": 197,
+        "Low": 11
+      },
+      "top_cwe_types": {
+        "CWE-122": 608,
+        "CWE-416": 555,
+        "CWE-125": 315,
+        "CWE-362": 188,
+        "CWE-190": 97
+      },
+      "kev_count": 25,
+      "epss_high_count": 11,
+      "epss_elevated_count": 29,
+      "top_cwes": [
+        [
+          "CWE-122",
+          608
+        ],
+        [
+          "CWE-416",
+          555
+        ],
+        [
+          "CWE-125",
+          315
+        ],
+        [
+          "CWE-362",
+          188
+        ],
+        [
+          "CWE-190",
+          97
+        ]
+      ]
+    },
+    {
+      "name": "Chrome",
+      "assigner_org_id": "ebfee0ef-53dd-4cf3-9e2a-08a5bd7a7e28",
+      "count": 2794,
+      "rank": 10,
+      "first_cve_date": "2026-01-06T23:57:00.488Z",
+      "last_cve_date": "2026-09-17T21:08:43.666Z",
+      "years_active": 16,
+      "first_cve_year": 2011,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 316,
+        "High": 1129,
+        "Medium": 1222,
+        "Low": 127
+      },
+      "top_cwe_types": {
+        "CWE-416": 704,
+        "CWE-20": 419,
+        "CWE-451": 190,
+        "CWE-125": 142,
+        "CWE-346": 121
+      },
+      "kev_count": 7,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-416",
+          704
+        ],
+        [
+          "CWE-20",
+          419
+        ],
+        [
+          "CWE-451",
+          190
+        ],
+        [
+          "CWE-125",
+          142
+        ],
+        [
+          "CWE-346",
+          121
+        ]
+      ]
+    },
+    {
+      "name": "WPScan",
+      "assigner_org_id": "1bfdd5d7-9bf6-4a53-96ea-42e2716d7a81",
+      "count": 1356,
+      "rank": 11,
+      "first_cve_date": "2026-01-01T06:00:03.091Z",
+      "last_cve_date": "2026-09-23T12:08:59.817Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 369,
+        "Low": 133,
+        "Medium": 743,
+        "Critical": 111
+      },
+      "top_cwe_types": {
+        "CWE-79": 234,
+        "CWE-862": 167,
+        "CWE-200": 151,
+        "CWE-639": 147,
+        "CWE-287": 88
+      },
+      "kev_count": 2,
+      "epss_high_count": 2,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-79",
+          234
+        ],
+        [
+          "CWE-862",
+          167
+        ],
+        [
+          "CWE-200",
+          151
+        ],
+        [
+          "CWE-639",
+          147
+        ],
+        [
+          "CWE-287",
+          88
+        ]
+      ]
+    },
+    {
+      "name": "ibm",
+      "assigner_org_id": "9a959283-ebb5-44b6-b705-dcc2bbced522",
+      "count": 1205,
+      "rank": 12,
+      "first_cve_date": "2026-01-20T14:50:51.912Z",
+      "last_cve_date": "2026-09-23T21:39:25.036Z",
+      "years_active": 15,
+      "first_cve_year": 2012,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 522,
+        "Critical": 142,
+        "High": 503,
+        "Low": 38
+      },
+      "top_cwe_types": {
+        "CWE-787": 75,
+        "CWE-78": 74,
+        "CWE-79": 67,
+        "CWE-22": 66,
+        "CWE-918": 42
+      },
+      "kev_count": 1,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-787",
+          75
+        ],
+        [
+          "CWE-78",
+          74
+        ],
+        [
+          "CWE-79",
+          67
+        ],
+        [
+          "CWE-22",
+          66
+        ],
+        [
+          "CWE-918",
+          42
+        ]
+      ]
+    },
+    {
+      "name": "redhat",
+      "assigner_org_id": "53f830b8-0a3f-465b-8143-3b8a9948e749",
+      "count": 996,
+      "rank": 13,
+      "first_cve_date": "2026-01-07T16:04:22.155Z",
+      "last_cve_date": "2026-09-23T21:24:01.514Z",
+      "years_active": 22,
+      "first_cve_year": 2005,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 370,
+        "Medium": 501,
+        "Low": 71,
+        "Critical": 54
+      },
+      "top_cwe_types": {
+        "CWE-125": 67,
+        "CWE-862": 36,
+        "CWE-787": 36,
+        "CWE-190": 33,
+        "CWE-639": 31
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-125",
+          67
+        ],
+        [
+          "CWE-862",
+          36
+        ],
+        [
+          "CWE-787",
+          36
+        ],
+        [
+          "CWE-190",
+          33
+        ],
+        [
+          "CWE-639",
+          31
+        ]
+      ]
+    },
+    {
+      "name": "apache",
+      "assigner_org_id": "f0158376-9dc2-43b6-827c-5f631a4d8d09",
+      "count": 837,
+      "rank": 14,
+      "first_cve_date": "2026-01-01T16:14:00.837Z",
+      "last_cve_date": "2026-09-23T12:31:53.210Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Open Source"
+      ],
+      "severity_distribution": {
+        "Critical": 179,
+        "High": 358,
+        "Medium": 276,
+        "Low": 24
+      },
+      "top_cwe_types": {
+        "CWE-20": 67,
+        "CWE-502": 49,
+        "CWE-200": 37,
+        "CWE-863": 36,
+        "CWE-400": 33
+      },
+      "kev_count": 2,
+      "epss_high_count": 2,
+      "epss_elevated_count": 10,
+      "top_cwes": [
+        [
+          "CWE-20",
+          67
+        ],
+        [
+          "CWE-502",
+          49
+        ],
+        [
+          "CWE-200",
+          37
+        ],
+        [
+          "CWE-863",
+          36
+        ],
+        [
+          "CWE-400",
+          33
+        ]
+      ]
+    },
+    {
+      "name": "adobe",
+      "assigner_org_id": "078d4453-3bcd-4900-85e6-15281da43538",
+      "count": 830,
+      "rank": 15,
+      "first_cve_date": "2026-01-13T18:25:34.136Z",
+      "last_cve_date": "2026-09-22T18:58:12.860Z",
+      "years_active": 18,
+      "first_cve_year": 2009,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 375,
+        "High": 363,
+        "Low": 10,
+        "Critical": 82
+      },
+      "top_cwe_types": {
+        "CWE-79": 245,
+        "CWE-787": 101,
+        "CWE-20": 56,
+        "CWE-122": 55,
+        "CWE-863": 54
+      },
+      "kev_count": 3,
+      "epss_high_count": 0,
+      "epss_elevated_count": 8,
+      "top_cwes": [
+        [
+          "CWE-79",
+          245
+        ],
+        [
+          "CWE-787",
+          101
+        ],
+        [
+          "CWE-20",
+          56
+        ],
+        [
+          "CWE-122",
+          55
+        ],
+        [
+          "CWE-863",
+          54
+        ]
+      ]
+    },
+    {
+      "name": "apple",
+      "assigner_org_id": "286789f9-fbc2-4510-9f9a-43facdede74c",
+      "count": 811,
+      "rank": 16,
+      "first_cve_date": "2026-01-09T21:14:39.092Z",
+      "last_cve_date": "2026-09-23T17:20:20.178Z",
+      "years_active": 17,
+      "first_cve_year": 2010,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 31,
+        "High": 265,
+        "Medium": 440,
+        "Critical": 69
+      },
+      "top_cwe_types": {
+        "CWE-284": 81,
+        "CWE-119": 78,
+        "CWE-787": 67,
+        "CWE-416": 63,
+        "CWE-125": 61
+      },
+      "kev_count": 2,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-284",
+          81
+        ],
+        [
+          "CWE-119",
+          78
+        ],
+        [
+          "CWE-787",
+          67
+        ],
+        [
+          "CWE-416",
+          63
+        ],
+        [
+          "CWE-125",
+          61
+        ]
+      ]
+    },
+    {
+      "name": "mozilla",
+      "assigner_org_id": "f16b083a-5664-49f3-a51e-8d479e5ed7fe",
+      "count": 513,
+      "rank": 17,
+      "first_cve_date": "2026-01-13T13:30:52.979Z",
+      "last_cve_date": "2026-09-15T19:42:53.494Z",
+      "years_active": 14,
+      "first_cve_year": 2013,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 245,
+        "Critical": 169,
+        "Medium": 99
+      },
+      "top_cwe_types": {
+        "CWE-416": 92,
+        "CWE-119": 89,
+        "CWE-693": 47,
+        "CWE-200": 41,
+        "CWE-269": 38
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-416",
+          92
+        ],
+        [
+          "CWE-119",
+          89
+        ],
+        [
+          "CWE-693",
+          47
+        ],
+        [
+          "CWE-200",
+          41
+        ],
+        [
+          "CWE-269",
+          38
+        ]
+      ]
+    },
+    {
+      "name": "dell",
+      "assigner_org_id": "c550e75a-17ff-4988-97f0-544cde3820fe",
+      "count": 476,
+      "rank": 18,
+      "first_cve_date": "2026-01-06T15:01:17.368Z",
+      "last_cve_date": "2026-09-23T14:34:43.284Z",
+      "years_active": 18,
+      "first_cve_year": 2009,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 220,
+        "High": 195,
+        "Low": 37,
+        "Critical": 24
+      },
+      "top_cwe_types": {
+        "CWE-78": 48,
+        "CWE-295": 30,
+        "CWE-284": 19,
+        "CWE-269": 16,
+        "CWE-89": 16
+      },
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-78",
+          48
+        ],
+        [
+          "CWE-295",
+          30
+        ],
+        [
+          "CWE-284",
+          19
+        ],
+        [
+          "CWE-269",
+          16
+        ],
+        [
+          "CWE-89",
+          16
+        ]
+      ]
+    },
+    {
+      "name": "cisco",
+      "assigner_org_id": "d1c1063e-7a18-46af-9102-31f8928bc633",
+      "count": 463,
+      "rank": 19,
+      "first_cve_date": "2026-01-07T16:23:43.283Z",
+      "last_cve_date": "2026-09-16T20:26:30.469Z",
+      "years_active": 20,
+      "first_cve_year": 2007,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 235,
+        "High": 156,
+        "Critical": 64,
+        "Low": 8
+      },
+      "top_cwe_types": {
+        "CWE-79": 31,
+        "CWE-284": 21,
+        "CWE-89": 20,
+        "CWE-22": 18,
+        "CWE-20": 17
+      },
+      "kev_count": 16,
+      "epss_high_count": 5,
+      "epss_elevated_count": 13,
+      "top_cwes": [
+        [
+          "CWE-79",
+          31
+        ],
+        [
+          "CWE-284",
+          21
+        ],
+        [
+          "CWE-89",
+          20
+        ],
+        [
+          "CWE-22",
+          18
+        ],
+        [
+          "CWE-20",
+          17
+        ]
+      ]
+    },
+    {
+      "name": "icscert",
+      "assigner_org_id": "7d14cffa-0d7d-4270-9dc0-52cabd5a23a6",
+      "count": 412,
+      "rank": 20,
+      "first_cve_date": "2026-01-05T15:39:19.710Z",
+      "last_cve_date": "2026-09-22T20:40:26.449Z",
+      "years_active": 15,
+      "first_cve_year": 2012,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "Critical": 107,
+        "High": 216,
+        "Medium": 84,
+        "Low": 5
+      },
+      "top_cwe_types": {
+        "CWE-306": 60,
+        "CWE-78": 29,
+        "CWE-862": 23,
+        "CWE-798": 23,
+        "CWE-125": 18
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-306",
+          60
+        ],
+        [
+          "CWE-78",
+          29
+        ],
+        [
+          "CWE-862",
+          23
+        ],
+        [
+          "CWE-798",
+          23
+        ],
+        [
+          "CWE-125",
+          18
+        ]
+      ]
+    },
+    {
+      "name": "GitLab",
+      "assigner_org_id": "ceab7361-8a18-47b1-92ba-4d7d25f6715a",
+      "count": 318,
+      "rank": 21,
+      "first_cve_date": "2026-01-09T10:03:51.554Z",
+      "last_cve_date": "2026-09-18T14:34:32.131Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Open Source"
+      ],
+      "severity_distribution": {
+        "Medium": 194,
+        "High": 82,
+        "Low": 34,
+        "Critical": 8
+      },
+      "top_cwe_types": {
+        "CWE-862": 30,
+        "CWE-770": 30,
+        "CWE-79": 28,
+        "CWE-863": 25,
+        "CWE-122": 21
+      },
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-862",
+          30
+        ],
+        [
+          "CWE-770",
+          30
+        ],
+        [
+          "CWE-79",
+          28
+        ],
+        [
+          "CWE-863",
+          25
+        ],
+        [
+          "CWE-122",
+          21
+        ]
+      ]
+    },
+    {
+      "name": "Joomla",
+      "assigner_org_id": "6ff30186-7fb7-4ad9-be33-533e7b05e586",
+      "count": 302,
+      "rank": 22,
+      "first_cve_date": "2026-01-06T16:01:15.123Z",
+      "last_cve_date": "2026-09-23T18:43:32.107Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 126,
+        "Critical": 77,
+        "High": 98,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-284": 71,
+        "CWE-79": 65,
+        "CWE-89": 31,
+        "CWE-22": 27,
+        "CWE-352": 23
+      },
+      "kev_count": 5,
+      "epss_high_count": 1,
+      "epss_elevated_count": 5,
+      "top_cwes": [
+        [
+          "CWE-284",
+          71
+        ],
+        [
+          "CWE-79",
+          65
+        ],
+        [
+          "CWE-89",
+          31
+        ],
+        [
+          "CWE-22",
+          27
+        ],
+        [
+          "CWE-352",
+          23
+        ]
+      ]
+    },
+    {
+      "name": "EEF",
+      "assigner_org_id": "6b3ad84c-e1a6-4bf7-a703-f496b71e49db",
+      "count": 302,
+      "rank": 23,
+      "first_cve_date": "2026-01-19T14:22:46.770Z",
+      "last_cve_date": "2026-09-22T15:51:57.998Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 121,
+        "Low": 58,
+        "Critical": 18,
+        "Medium": 105
+      },
+      "top_cwe_types": {
+        "CWE-770": 45,
+        "CWE-863": 15,
+        "CWE-1284": 14,
+        "CWE-400": 13,
+        "CWE-407": 9
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-770",
+          45
+        ],
+        [
+          "CWE-863",
+          15
+        ],
+        [
+          "CWE-1284",
+          14
+        ],
+        [
+          "CWE-400",
+          13
+        ],
+        [
+          "CWE-407",
+          9
+        ]
+      ]
+    },
+    {
+      "name": "CPANSec",
+      "assigner_org_id": "9b29abf9-4ab0-4765-b253-1875cd9b441e",
+      "count": 286,
+      "rank": 24,
+      "first_cve_date": "2026-01-06T00:22:50.114Z",
+      "last_cve_date": "2026-09-22T18:21:23.728Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 101,
+        "Medium": 65,
+        "High": 106,
+        "Low": 14
+      },
+      "top_cwe_types": {
+        "CWE-338": 34,
+        "CWE-125": 28,
+        "CWE-340": 18,
+        "CWE-59": 18,
+        "CWE-732": 16
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-338",
+          34
+        ],
+        [
+          "CWE-125",
+          28
+        ],
+        [
+          "CWE-340",
+          18
+        ],
+        [
+          "CWE-59",
+          18
+        ],
+        [
+          "CWE-732",
+          16
+        ]
+      ]
+    },
+    {
+      "name": "TR-CERT",
+      "assigner_org_id": "ca940d4e-fea4-4aa2-9a58-591a58b1ce21",
+      "count": 284,
+      "rank": 25,
+      "first_cve_date": "2026-01-22T09:10:16.989Z",
+      "last_cve_date": "2026-09-23T12:07:17.175Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "High": 119,
+        "Critical": 70,
+        "Medium": 92,
+        "Low": 3
+      },
+      "top_cwe_types": {
+        "CWE-79": 57,
+        "CWE-89": 38,
+        "CWE-639": 27,
+        "CWE-306": 16,
+        "CWE-862": 16
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          57
+        ],
+        [
+          "CWE-89",
+          38
+        ],
+        [
+          "CWE-639",
+          27
+        ],
+        [
+          "CWE-306",
+          16
+        ],
+        [
+          "CWE-862",
+          16
+        ]
+      ]
+    },
+    {
+      "name": "vmware",
+      "assigner_org_id": "dcf2e128-44bd-42ed-91e8-88f912c1401d",
+      "count": 277,
+      "rank": 26,
+      "first_cve_date": "2026-01-14T05:10:58.485Z",
+      "last_cve_date": "2026-09-15T09:16:59.460Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 118,
+        "High": 111,
+        "Critical": 21,
+        "Low": 27
+      },
+      "top_cwe_types": {
+        "CWE-770": 17,
+        "CWE-22": 16,
+        "CWE-400": 15,
+        "CWE-502": 14,
+        "CWE-79": 12
+      },
+      "kev_count": 2,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-770",
+          17
+        ],
+        [
+          "CWE-22",
+          16
+        ],
+        [
+          "CWE-400",
+          15
+        ],
+        [
+          "CWE-502",
+          14
+        ],
+        [
+          "CWE-79",
+          12
+        ]
+      ]
+    },
+    {
+      "name": "CERT-PL",
+      "assigner_org_id": "4bb8329e-dd38-46c1-aafb-9bf32bcb93c6",
+      "count": 265,
+      "rank": 27,
+      "first_cve_date": "2026-01-07T13:00:46.715Z",
+      "last_cve_date": "2026-09-23T14:41:08.125Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "High": 73,
+        "Medium": 145,
+        "Critical": 32,
+        "Low": 15
+      },
+      "top_cwe_types": {
+        "CWE-79": 39,
+        "CWE-89": 20,
+        "CWE-22": 17,
+        "CWE-78": 15,
+        "CWE-639": 10
+      },
+      "kev_count": 2,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          39
+        ],
+        [
+          "CWE-89",
+          20
+        ],
+        [
+          "CWE-22",
+          17
+        ],
+        [
+          "CWE-78",
+          15
+        ],
+        [
+          "CWE-639",
+          10
+        ]
+      ]
+    },
+    {
+      "name": "nvidia",
+      "assigner_org_id": "9576f279-3576-44b5-a4af-b9a8644b2de6",
+      "count": 248,
+      "rank": 28,
+      "first_cve_date": "2026-01-14T18:30:41.061Z",
+      "last_cve_date": "2026-09-22T14:10:35.206Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 181,
+        "Medium": 56,
+        "Critical": 11
+      },
+      "top_cwe_types": {
+        "CWE-502": 72,
+        "CWE-78": 13,
+        "CWE-94": 11,
+        "CWE-918": 9,
+        "CWE-77": 8
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-502",
+          72
+        ],
+        [
+          "CWE-78",
+          13
+        ],
+        [
+          "CWE-94",
+          11
+        ],
+        [
+          "CWE-918",
+          9
+        ],
+        [
+          "CWE-77",
+          8
+        ]
+      ]
+    },
+    {
+      "name": "jpcert",
+      "assigner_org_id": "ede6fdc4-6654-4307-a26d-3331c018e2ce",
+      "count": 239,
+      "rank": 29,
+      "first_cve_date": "2026-01-06T06:34:11.329Z",
+      "last_cve_date": "2026-09-16T07:30:01.520Z",
+      "years_active": 17,
+      "first_cve_year": 2010,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "Medium": 106,
+        "High": 114,
+        "Low": 2,
+        "Critical": 17
+      },
+      "top_cwe_types": {
+        "CWE-79": 35,
+        "CWE-78": 27,
+        "CWE-427": 19,
+        "CWE-276": 10,
+        "CWE-306": 10
+      },
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          35
+        ],
+        [
+          "CWE-78",
+          27
+        ],
+        [
+          "CWE-427",
+          19
+        ],
+        [
+          "CWE-276",
+          10
+        ],
+        [
+          "CWE-306",
+          10
+        ]
+      ]
+    },
+    {
+      "name": "google_android",
+      "assigner_org_id": "baff130e-b8d5-4e15-b3d3-c3cf5d5545c6",
+      "count": 232,
+      "rank": 30,
+      "first_cve_date": "2026-01-16T18:19:02.047Z",
+      "last_cve_date": "2026-09-08T19:20:33.261Z",
+      "years_active": 12,
+      "first_cve_year": 2015,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 46,
+        "High": 143,
+        "Critical": 23,
+        "Low": 20
+      },
+      "top_cwe_types": {
+        "CWE-693": 34,
+        "CWE-20": 22,
+        "CWE-862": 21,
+        "CWE-269": 21,
+        "CWE-441": 18
+      },
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-693",
+          34
+        ],
+        [
+          "CWE-20",
+          22
+        ],
+        [
+          "CWE-862",
+          21
+        ],
+        [
+          "CWE-269",
+          21
+        ],
+        [
+          "CWE-441",
+          18
+        ]
+      ]
+    },
+    {
+      "name": "HCL",
+      "assigner_org_id": "1e47fe04-f25f-42fa-b674-36de2c5e3cfc",
+      "count": 231,
+      "rank": 31,
+      "first_cve_date": "2026-01-07T06:48:19.946Z",
+      "last_cve_date": "2026-09-18T11:12:24.764Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 105,
+        "Low": 100,
+        "High": 22,
+        "Critical": 4
+      },
+      "top_cwe_types": {
+        "CWE-200": 26,
+        "CWE-209": 14,
+        "CWE-79": 9,
+        "CWE-532": 8,
+        "CWE-20": 7
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-200",
+          26
+        ],
+        [
+          "CWE-209",
+          14
+        ],
+        [
+          "CWE-79",
+          9
+        ],
+        [
+          "CWE-532",
+          8
+        ],
+        [
+          "CWE-20",
+          7
+        ]
+      ]
+    },
+    {
+      "name": "hackerone",
+      "assigner_org_id": "36234546-b8fa-4601-9d6f-f4e334aa8ea1",
+      "count": 231,
+      "rank": 32,
+      "first_cve_date": "2026-01-05T16:47:38.510Z",
+      "last_cve_date": "2026-09-23T19:52:47.216Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 63,
+        "High": 87,
+        "Low": 17,
+        "Medium": 64
+      },
+      "top_cwe_types": {
+        "CWE-284": 39,
+        "CWE-89": 14,
+        "CWE-22": 14,
+        "CWE-20": 13,
+        "CWE-79": 12
+      },
+      "kev_count": 3,
+      "epss_high_count": 3,
+      "epss_elevated_count": 6,
+      "top_cwes": [
+        [
+          "CWE-284",
+          39
+        ],
+        [
+          "CWE-89",
+          14
+        ],
+        [
+          "CWE-22",
+          14
+        ],
+        [
+          "CWE-20",
+          13
+        ],
+        [
+          "CWE-79",
+          12
+        ]
+      ]
+    },
+    {
+      "name": "hpe",
+      "assigner_org_id": "eb103674-0d28-4225-80f8-39fb86215de0",
+      "count": 222,
+      "rank": 33,
+      "first_cve_date": "2026-01-13T17:40:56.557Z",
+      "last_cve_date": "2026-09-22T19:12:34.074Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 131,
+        "Medium": 66,
+        "Critical": 19,
+        "Low": 6
+      },
+      "top_cwe_types": {
+        "CWE-77": 25,
+        "CWE-269": 23,
+        "CWE-400": 18,
+        "CWE-200": 16,
+        "CWE-287": 15
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-77",
+          25
+        ],
+        [
+          "CWE-269",
+          23
+        ],
+        [
+          "CWE-400",
+          18
+        ],
+        [
+          "CWE-200",
+          16
+        ],
+        [
+          "CWE-287",
+          15
+        ]
+      ]
+    },
+    {
+      "name": "zdi",
+      "assigner_org_id": "99f1926a-a320-47d8-bbb5-42feb611262e",
+      "count": 220,
+      "rank": 34,
+      "first_cve_date": "2026-01-23T02:47:05.205Z",
+      "last_cve_date": "2026-09-15T18:05:59.201Z",
+      "years_active": 12,
+      "first_cve_year": 2015,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 169,
+        "Critical": 20,
+        "Medium": 28,
+        "Low": 3
+      },
+      "top_cwe_types": {
+        "CWE-78": 33,
+        "CWE-122": 26,
+        "CWE-787": 19,
+        "CWE-22": 17,
+        "CWE-502": 14
+      },
+      "kev_count": 1,
+      "epss_high_count": 3,
+      "epss_elevated_count": 4,
+      "top_cwes": [
+        [
+          "CWE-78",
+          33
+        ],
+        [
+          "CWE-122",
+          26
+        ],
+        [
+          "CWE-787",
+          19
+        ],
+        [
+          "CWE-22",
+          17
+        ],
+        [
+          "CWE-502",
+          14
+        ]
+      ]
+    },
+    {
+      "name": "CIRCL",
+      "assigner_org_id": "5a6e4751-2f3f-4070-9419-94fb35b644e8",
+      "count": 200,
+      "rank": 35,
+      "first_cve_date": "2026-05-07T12:07:59.273Z",
+      "last_cve_date": "2026-09-22T15:09:09.738Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 107,
+        "Low": 3,
+        "High": 70,
+        "Critical": 20
+      },
+      "top_cwe_types": {
+        "CWE-79": 42,
+        "CWE-862": 32,
+        "CWE-20": 20,
+        "CWE-200": 15,
+        "CWE-918": 15
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          42
+        ],
+        [
+          "CWE-862",
+          32
+        ],
+        [
+          "CWE-20",
+          20
+        ],
+        [
+          "CWE-200",
+          15
+        ],
+        [
+          "CWE-918",
+          15
+        ]
+      ]
+    },
+    {
+      "name": "TuranSec",
+      "assigner_org_id": "309f9ea4-e3e9-4c6c-b79d-e8eb01244f2c",
+      "count": 199,
+      "rank": 36,
+      "first_cve_date": "2026-03-10T11:07:07.393Z",
+      "last_cve_date": "2026-08-11T11:22:47.134Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 111,
+        "Critical": 44,
+        "Medium": 44
+      },
+      "top_cwe_types": {
+        "CWE-89": 28,
+        "CWE-918": 16,
+        "CWE-306": 16,
+        "CWE-79": 14,
+        "CWE-22": 13
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-89",
+          28
+        ],
+        [
+          "CWE-918",
+          16
+        ],
+        [
+          "CWE-306",
+          16
+        ],
+        [
+          "CWE-79",
+          14
+        ],
+        [
+          "CWE-22",
+          13
+        ]
+      ]
+    },
+    {
+      "name": "CERTVDE",
+      "assigner_org_id": "270ccfa6-a436-4e77-922e-914ec3a9685c",
+      "count": 197,
+      "rank": 37,
+      "first_cve_date": "2026-01-13T07:48:19.811Z",
+      "last_cve_date": "2026-09-16T07:52:23.443Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "Medium": 32,
+        "Critical": 31,
+        "High": 134
+      },
+      "top_cwe_types": {
+        "CWE-89": 46,
+        "CWE-78": 28,
+        "CWE-306": 10,
+        "CWE-121": 10,
+        "CWE-79": 5
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-89",
+          46
+        ],
+        [
+          "CWE-78",
+          28
+        ],
+        [
+          "CWE-306",
+          10
+        ],
+        [
+          "CWE-121",
+          10
+        ],
+        [
+          "CWE-79",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "mongodb",
+      "assigner_org_id": "a39b4221-9bd0-4244-95fc-f3e2e07f1deb",
+      "count": 193,
+      "rank": 38,
+      "first_cve_date": "2026-01-27T17:29:21.423Z",
+      "last_cve_date": "2026-09-18T17:27:51.644Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 122,
+        "Medium": 62,
+        "Critical": 8,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-617": 21,
+        "CWE-943": 18,
+        "CWE-863": 13,
+        "CWE-416": 12,
+        "CWE-770": 10
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-617",
+          21
+        ],
+        [
+          "CWE-943",
+          18
+        ],
+        [
+          "CWE-863",
+          13
+        ],
+        [
+          "CWE-416",
+          12
+        ],
+        [
+          "CWE-770",
+          10
+        ]
+      ]
+    },
+    {
+      "name": "INCIBE",
+      "assigner_org_id": "0cbda920-cd7f-484a-8e76-bf7f4b7f4516",
+      "count": 182,
+      "rank": 39,
+      "first_cve_date": "2026-01-12T11:26:30.574Z",
+      "last_cve_date": "2026-09-23T10:22:43.693Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 55,
+        "Medium": 82,
+        "Critical": 44,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-79": 66,
+        "CWE-89": 37,
+        "CWE-639": 10,
+        "CWE-284": 7,
+        "CWE-352": 5
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          66
+        ],
+        [
+          "CWE-89",
+          37
+        ],
+        [
+          "CWE-639",
+          10
+        ],
+        [
+          "CWE-284",
+          7
+        ],
+        [
+          "CWE-352",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "certcc",
+      "assigner_org_id": "37e5125f-f79b-445b-8fad-9564f167944b",
+      "count": 178,
+      "rank": 40,
+      "first_cve_date": "2026-01-06T14:45:29.207Z",
+      "last_cve_date": "2026-09-23T18:25:22.672Z",
+      "years_active": 22,
+      "first_cve_year": 2005,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "High": 76,
+        "Critical": 61,
+        "Medium": 39
+      },
+      "top_cwe_types": {
+        "CWE-502": 12,
+        "CWE-284": 10,
+        "CWE-639": 10,
+        "CWE-94": 10,
+        "CWE-269": 8
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-502",
+          12
+        ],
+        [
+          "CWE-284",
+          10
+        ],
+        [
+          "CWE-639",
+          10
+        ],
+        [
+          "CWE-94",
+          10
+        ],
+        [
+          "CWE-269",
+          8
+        ]
+      ]
+    },
+    {
+      "name": "sap",
+      "assigner_org_id": "e4686d1a-f260-4930-ac4c-2f5c992778dd",
+      "count": 174,
+      "rank": 41,
+      "first_cve_date": "2026-01-13T01:12:53.331Z",
+      "last_cve_date": "2026-09-22T00:28:40.930Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 17,
+        "Medium": 106,
+        "High": 28,
+        "Critical": 23
+      },
+      "top_cwe_types": {
+        "CWE-862": 46,
+        "CWE-79": 17,
+        "CWE-601": 9,
+        "CWE-89": 9,
+        "CWE-94": 8
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-862",
+          46
+        ],
+        [
+          "CWE-79",
+          17
+        ],
+        [
+          "CWE-601",
+          9
+        ],
+        [
+          "CWE-89",
+          9
+        ],
+        [
+          "CWE-94",
+          8
+        ]
+      ]
+    },
+    {
+      "name": "Mattermost",
+      "assigner_org_id": "9302f53e-dde5-4bf3-b2f2-a83f91ac0eee",
+      "count": 161,
+      "rank": 42,
+      "first_cve_date": "2026-01-16T08:52:43.848Z",
+      "last_cve_date": "2026-09-22T20:34:49.141Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 16,
+        "Medium": 117,
+        "Low": 28
+      },
+      "top_cwe_types": {
+        "CWE-863": 34,
+        "CWE-862": 21,
+        "CWE-770": 9,
+        "CWE-639": 9,
+        "CWE-200": 8
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-863",
+          34
+        ],
+        [
+          "CWE-862",
+          21
+        ],
+        [
+          "CWE-770",
+          9
+        ],
+        [
+          "CWE-639",
+          9
+        ],
+        [
+          "CWE-200",
+          8
+        ]
+      ]
+    },
+    {
+      "name": "Google_Devices",
+      "assigner_org_id": "83238938-5644-45f0-9007-c0392bcf6222",
+      "count": 159,
+      "rank": 43,
+      "first_cve_date": "2026-01-15T17:41:57.504Z",
+      "last_cve_date": "2026-09-15T18:34:55.580Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 12,
+        "High": 83,
+        "Medium": 62,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-787": 47,
+        "CWE-693": 24,
+        "CWE-120": 23,
+        "CWE-125": 18,
+        "CWE-20": 16
+      },
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          47
+        ],
+        [
+          "CWE-693",
+          24
+        ],
+        [
+          "CWE-120",
+          23
+        ],
+        [
+          "CWE-125",
+          18
+        ],
+        [
+          "CWE-20",
+          16
+        ]
+      ]
+    },
+    {
+      "name": "TPLink",
+      "assigner_org_id": "f23511db-6c3e-4e32-a477-6aa17d310630",
+      "count": 159,
+      "rank": 44,
+      "first_cve_date": "2026-01-07T01:04:26.594Z",
+      "last_cve_date": "2026-09-10T23:35:53.023Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 102,
+        "Medium": 54,
+        "Low": 2,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-78": 34,
+        "CWE-20": 14,
+        "CWE-122": 13,
+        "CWE-121": 13,
+        "CWE-476": 7
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-78",
+          34
+        ],
+        [
+          "CWE-20",
+          14
+        ],
+        [
+          "CWE-122",
+          13
+        ],
+        [
+          "CWE-121",
+          13
+        ],
+        [
+          "CWE-476",
+          7
+        ]
+      ]
+    },
+    {
+      "name": "elastic",
+      "assigner_org_id": "271b6943-45a9-4f3a-ab4e-976f3fa05b5a",
+      "count": 152,
+      "rank": 45,
+      "first_cve_date": "2026-01-13T21:02:18.501Z",
+      "last_cve_date": "2026-09-03T18:35:44.977Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 29,
+        "Medium": 121,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-863": 24,
+        "CWE-770": 19,
+        "CWE-862": 18,
+        "CWE-400": 13,
+        "CWE-639": 8
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-863",
+          24
+        ],
+        [
+          "CWE-770",
+          19
+        ],
+        [
+          "CWE-862",
+          18
+        ],
+        [
+          "CWE-400",
+          13
+        ],
+        [
+          "CWE-639",
+          8
+        ]
+      ]
+    },
+    {
+      "name": "drupal",
+      "assigner_org_id": "2c85b837-eb8b-40ed-9d74-228c62987387",
+      "count": 149,
+      "rank": 46,
+      "first_cve_date": "2026-01-14T18:38:21.047Z",
+      "last_cve_date": "2026-09-02T12:55:30.885Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 112,
+        "High": 15,
+        "Critical": 12,
+        "Low": 10
+      },
+      "top_cwe_types": {
+        "CWE-79": 46,
+        "CWE-863": 17,
+        "CWE-862": 15,
+        "CWE-288": 9,
+        "CWE-915": 9
+      },
+      "kev_count": 1,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-79",
+          46
+        ],
+        [
+          "CWE-863",
+          17
+        ],
+        [
+          "CWE-862",
+          15
+        ],
+        [
+          "CWE-288",
+          9
+        ],
+        [
+          "CWE-915",
+          9
+        ]
+      ]
+    },
+    {
+      "name": "SamsungMobile",
+      "assigner_org_id": "3af57064-a867-422c-b2ad-40307b65c458",
+      "count": 146,
+      "rank": 47,
+      "first_cve_date": "2026-01-09T06:15:41.575Z",
+      "last_cve_date": "2026-09-09T04:48:03.726Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 111,
+        "High": 29,
+        "Low": 3,
+        "Critical": 3
+      },
+      "top_cwe_types": {
+        "CWE-20": 32,
+        "CWE-284": 18,
+        "CWE-926": 18,
+        "CWE-787": 13,
+        "CWE-269": 6
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          32
+        ],
+        [
+          "CWE-284",
+          18
+        ],
+        [
+          "CWE-926",
+          18
+        ],
+        [
+          "CWE-787",
+          13
+        ],
+        [
+          "CWE-269",
+          6
+        ]
+      ]
+    },
+    {
+      "name": "MediaTek",
+      "assigner_org_id": "ee979b05-11f8-4f25-a7e0-a1fa9c190374",
+      "count": 143,
+      "rank": 48,
+      "first_cve_date": "2026-01-06T01:46:29.572Z",
+      "last_cve_date": "2026-09-07T01:57:36.053Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 111,
+        "High": 30,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-787": 46,
+        "CWE-416": 21,
+        "CWE-125": 12,
+        "CWE-617": 8,
+        "CWE-122": 7
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          46
+        ],
+        [
+          "CWE-416",
+          21
+        ],
+        [
+          "CWE-125",
+          12
+        ],
+        [
+          "CWE-617",
+          8
+        ],
+        [
+          "CWE-122",
+          7
+        ]
+      ]
+    },
+    {
+      "name": "zephyr",
+      "assigner_org_id": "e2e69745-5e70-4e92-8431-deb5529a81ad",
+      "count": 143,
+      "rank": 49,
+      "first_cve_date": "2026-01-30T05:34:19.703Z",
+      "last_cve_date": "2026-09-21T21:16:05.314Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 87,
+        "Low": 19,
+        "High": 34,
+        "Critical": 3
+      },
+      "top_cwe_types": {
+        "CWE-787": 34,
+        "CWE-125": 24,
+        "CWE-416": 19,
+        "CWE-476": 12,
+        "CWE-835": 7
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          34
+        ],
+        [
+          "CWE-125",
+          24
+        ],
+        [
+          "CWE-416",
+          19
+        ],
+        [
+          "CWE-476",
+          12
+        ],
+        [
+          "CWE-835",
+          7
+        ]
+      ]
+    },
+    {
+      "name": "intel",
+      "assigner_org_id": "6dda929c-bb53-4a77-a76d-48e79601a1ce",
+      "count": 142,
+      "rank": 50,
+      "first_cve_date": "2026-02-10T16:25:04.959Z",
+      "last_cve_date": "2026-08-11T17:39:06.609Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 94,
+        "High": 40,
+        "Low": 7,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-20": 15,
+        "CWE-693": 12,
+        "CWE-754": 11,
+        "CWE-427": 8,
+        "CWE-125": 8
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          15
+        ],
+        [
+          "CWE-693",
+          12
+        ],
+        [
+          "CWE-754",
+          11
+        ],
+        [
+          "CWE-427",
+          8
+        ],
+        [
+          "CWE-125",
+          8
+        ]
+      ]
+    },
+    {
+      "name": "twcert",
+      "assigner_org_id": "cded6c7f-6ce5-4948-8f87-aa7a3bbb6b0e",
+      "count": 139,
+      "rank": 51,
+      "first_cve_date": "2026-01-05T07:25:33.577Z",
+      "last_cve_date": "2026-09-23T08:18:49.332Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "High": 67,
+        "Medium": 35,
+        "Critical": 37
+      },
+      "top_cwe_types": {
+        "CWE-89": 18,
+        "CWE-434": 15,
+        "CWE-306": 13,
+        "CWE-78": 11,
+        "CWE-79": 10
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-89",
+          18
+        ],
+        [
+          "CWE-434",
+          15
+        ],
+        [
+          "CWE-306",
+          13
+        ],
+        [
+          "CWE-78",
+          11
+        ],
+        [
+          "CWE-79",
+          10
+        ]
+      ]
+    },
+    {
+      "name": "AMZN",
+      "assigner_org_id": "ff89ba41-3aa1-4d27-914a-91399e9639e5",
+      "count": 138,
+      "rank": 52,
+      "first_cve_date": "2026-01-09T21:10:09.310Z",
+      "last_cve_date": "2026-09-22T20:04:44.360Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 24,
+        "High": 96,
+        "Critical": 18
+      },
+      "top_cwe_types": {
+        "CWE-78": 12,
+        "CWE-787": 6,
+        "CWE-770": 4,
+        "CWE-88": 4,
+        "CWE-283": 4
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          12
+        ],
+        [
+          "CWE-787",
+          6
+        ],
+        [
+          "CWE-770",
+          4
+        ],
+        [
+          "CWE-88",
+          4
+        ],
+        [
+          "CWE-283",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "jenkins",
+      "assigner_org_id": "39769cd5-e6e2-4dc8-927e-97b3aa056f5b",
+      "count": 138,
+      "rank": 53,
+      "first_cve_date": "2026-02-18T14:17:43.911Z",
+      "last_cve_date": "2026-09-16T13:53:14.924Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 45,
+        "Medium": 85,
+        "Low": 5,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-862": 29,
+        "CWE-79": 15,
+        "CWE-352": 13,
+        "CWE-502": 9,
+        "CWE-22": 9
+      },
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-862",
+          29
+        ],
+        [
+          "CWE-79",
+          15
+        ],
+        [
+          "CWE-352",
+          13
+        ],
+        [
+          "CWE-502",
+          9
+        ],
+        [
+          "CWE-22",
+          9
+        ]
+      ]
+    },
+    {
+      "name": "qualcomm",
+      "assigner_org_id": "2cfc7d3e-20d3-47ac-8db7-1b7285aff15f",
+      "count": 137,
+      "rank": 54,
+      "first_cve_date": "2026-01-06T22:48:28.547Z",
+      "last_cve_date": "2026-09-22T09:45:23.173Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 93,
+        "Medium": 41,
+        "Critical": 3
+      },
+      "top_cwe_types": {
+        "CWE-126": 26,
+        "CWE-416": 19,
+        "CWE-787": 14,
+        "CWE-120": 11,
+        "CWE-822": 7
+      },
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-126",
+          26
+        ],
+        [
+          "CWE-416",
+          19
+        ],
+        [
+          "CWE-787",
+          14
+        ],
+        [
+          "CWE-120",
+          11
+        ],
+        [
+          "CWE-822",
+          7
+        ]
+      ]
+    },
+    {
+      "name": "huawei",
+      "assigner_org_id": "25ac1063-e409-4190-8079-24548c77ea2e",
+      "count": 131,
+      "rank": 55,
+      "first_cve_date": "2026-01-14T01:51:42.163Z",
+      "last_cve_date": "2026-09-09T04:00:25.389Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 18,
+        "Medium": 102,
+        "Low": 9,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-362": 23,
+        "CWE-264": 21,
+        "CWE-200": 10,
+        "CWE-840": 9,
+        "CWE-416": 7
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-362",
+          23
+        ],
+        [
+          "CWE-264",
+          21
+        ],
+        [
+          "CWE-200",
+          10
+        ],
+        [
+          "CWE-840",
+          9
+        ],
+        [
+          "CWE-416",
+          7
+        ]
+      ]
+    },
+    {
+      "name": "qnap",
+      "assigner_org_id": "2fd009eb-170a-4625-932b-17a53af1051f",
+      "count": 125,
+      "rank": 56,
+      "first_cve_date": "2026-01-02T14:51:49.742Z",
+      "last_cve_date": "2026-09-18T06:51:06.187Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 39,
+        "Low": 71,
+        "Critical": 3,
+        "High": 12
+      },
+      "top_cwe_types": {
+        "CWE-476": 26,
+        "CWE-22": 14,
+        "CWE-770": 12,
+        "CWE-121": 11,
+        "CWE-120": 10
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-476",
+          26
+        ],
+        [
+          "CWE-22",
+          14
+        ],
+        [
+          "CWE-770",
+          12
+        ],
+        [
+          "CWE-121",
+          11
+        ],
+        [
+          "CWE-120",
+          10
+        ]
+      ]
+    },
+    {
+      "name": "openjs",
+      "assigner_org_id": "ce714d77-add3-4f53-aff5-83d477b104bb",
+      "count": 123,
+      "rank": 57,
+      "first_cve_date": "2026-01-21T19:05:28.846Z",
+      "last_cve_date": "2026-09-17T06:55:42.300Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 62,
+        "Medium": 43,
+        "Critical": 11,
+        "Low": 7
+      },
+      "top_cwe_types": {
+        "CWE-436": 15,
+        "CWE-248": 13,
+        "CWE-770": 11,
+        "CWE-20": 9,
+        "CWE-400": 9
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-436",
+          15
+        ],
+        [
+          "CWE-248",
+          13
+        ],
+        [
+          "CWE-770",
+          11
+        ],
+        [
+          "CWE-20",
+          9
+        ],
+        [
+          "CWE-400",
+          9
+        ]
+      ]
+    },
+    {
+      "name": "JetBrains",
+      "assigner_org_id": "547ada31-17d8-4964-bc5f-1b8238ba8014",
+      "count": 119,
+      "rank": 58,
+      "first_cve_date": "2026-02-09T10:38:59.786Z",
+      "last_cve_date": "2026-09-07T16:26:51.153Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 45,
+        "High": 43,
+        "Low": 18,
+        "Critical": 13
+      },
+      "top_cwe_types": {
+        "CWE-862": 21,
+        "CWE-79": 15,
+        "CWE-306": 10,
+        "CWE-829": 9,
+        "CWE-863": 6
+      },
+      "kev_count": 1,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-862",
+          21
+        ],
+        [
+          "CWE-79",
+          15
+        ],
+        [
+          "CWE-306",
+          10
+        ],
+        [
+          "CWE-829",
+          9
+        ],
+        [
+          "CWE-863",
+          6
+        ]
+      ]
+    },
+    {
+      "name": "AMD",
+      "assigner_org_id": "b58fc414-a1e4-4f92-9d70-1add41838648",
+      "count": 117,
+      "rank": 59,
+      "first_cve_date": "2026-01-16T15:46:08.641Z",
+      "last_cve_date": "2026-09-02T19:57:10.678Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 51,
+        "Low": 12,
+        "Medium": 53,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-427": 9,
+        "CWE-787": 8,
+        "CWE-1220": 5,
+        "CWE-367": 5,
+        "CWE-125": 5
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-427",
+          9
+        ],
+        [
+          "CWE-787",
+          8
+        ],
+        [
+          "CWE-1220",
+          5
+        ],
+        [
+          "CWE-367",
+          5
+        ],
+        [
+          "CWE-125",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "ConcreteCMS",
+      "assigner_org_id": "ff5b8ace-8b95-4078-9743-eac1ca5451de",
+      "count": 117,
+      "rank": 60,
+      "first_cve_date": "2026-03-04T01:49:27.027Z",
+      "last_cve_date": "2026-09-16T17:16:09.563Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 40,
+        "Low": 45,
+        "High": 31,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-352": 32,
+        "CWE-862": 29,
+        "CWE-79": 28,
+        "CWE-1275": 13,
+        "CWE-639": 10
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-352",
+          32
+        ],
+        [
+          "CWE-862",
+          29
+        ],
+        [
+          "CWE-79",
+          28
+        ],
+        [
+          "CWE-1275",
+          13
+        ],
+        [
+          "CWE-639",
+          10
+        ]
+      ]
+    },
+    {
+      "name": "fortinet",
+      "assigner_org_id": "6abe59d8-c742-4dff-8ce8-9b0ca1073da8",
+      "count": 110,
+      "rank": 61,
+      "first_cve_date": "2026-01-13T16:32:28.665Z",
+      "last_cve_date": "2026-09-22T14:12:50.908Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 68,
+        "Critical": 12,
+        "Low": 13,
+        "High": 17
+      },
+      "top_cwe_types": {
+        "CWE-89": 8,
+        "CWE-22": 7,
+        "CWE-79": 7,
+        "CWE-78": 7,
+        "CWE-284": 7
+      },
+      "kev_count": 7,
+      "epss_high_count": 5,
+      "epss_elevated_count": 8,
+      "top_cwes": [
+        [
+          "CWE-89",
+          8
+        ],
+        [
+          "CWE-22",
+          7
+        ],
+        [
+          "CWE-79",
+          7
+        ],
+        [
+          "CWE-78",
+          7
+        ],
+        [
+          "CWE-284",
+          7
+        ]
+      ]
+    },
+    {
+      "name": "canonical",
+      "assigner_org_id": "cc1ad9ee-3454-478d-9317-d3e869d708bc",
+      "count": 108,
+      "rank": 62,
+      "first_cve_date": "2026-01-28T15:01:46.364Z",
+      "last_cve_date": "2026-08-26T12:50:10.502Z",
+      "years_active": 20,
+      "first_cve_year": 2007,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 42,
+        "High": 26,
+        "Low": 24,
+        "Critical": 16
+      },
+      "top_cwe_types": {
+        "CWE-367": 14,
+        "CWE-863": 8,
+        "CWE-59": 7,
+        "CWE-20": 7,
+        "CWE-22": 6
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-367",
+          14
+        ],
+        [
+          "CWE-863",
+          8
+        ],
+        [
+          "CWE-59",
+          7
+        ],
+        [
+          "CWE-20",
+          7
+        ],
+        [
+          "CWE-22",
+          6
+        ]
+      ]
+    },
+    {
+      "name": "wikimedia-foundation",
+      "assigner_org_id": "c4f26cc8-17ff-4c99-b5e2-38fc1793eacc",
+      "count": 106,
+      "rank": 63,
+      "first_cve_date": "2026-01-07T17:36:19.258Z",
+      "last_cve_date": "2026-09-23T18:50:13.056Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 68,
+        "High": 3,
+        "Medium": 35
+      },
+      "top_cwe_types": {
+        "CWE-79": 43,
+        "CWE-200": 15,
+        "CWE-22": 11,
+        "CWE-20": 5,
+        "CWE-80": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          43
+        ],
+        [
+          "CWE-200",
+          15
+        ],
+        [
+          "CWE-22",
+          11
+        ],
+        [
+          "CWE-20",
+          5
+        ],
+        [
+          "CWE-80",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "NCSC.ch",
+      "assigner_org_id": "455daabc-a392-441d-aa46-37d35189897c",
+      "count": 97,
+      "rank": 64,
+      "first_cve_date": "2026-01-22T09:24:14.634Z",
+      "last_cve_date": "2026-09-03T08:45:42.216Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "Medium": 33,
+        "High": 44,
+        "Low": 4,
+        "Critical": 16
+      },
+      "top_cwe_types": {
+        "CWE-20": 19,
+        "CWE-79": 8,
+        "CWE-78": 5,
+        "CWE-502": 5,
+        "CWE-22": 5
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-20",
+          19
+        ],
+        [
+          "CWE-79",
+          8
+        ],
+        [
+          "CWE-78",
+          5
+        ],
+        [
+          "CWE-502",
+          5
+        ],
+        [
+          "CWE-22",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "siemens",
+      "assigner_org_id": "cec7a2ec-15b4-4faf-bd53-b40f371f3a77",
+      "count": 96,
+      "rank": 65,
+      "first_cve_date": "2026-01-13T09:44:03.338Z",
+      "last_cve_date": "2026-09-16T07:59:08.075Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 17,
+        "Low": 1,
+        "High": 64,
+        "Critical": 14
+      },
+      "top_cwe_types": {
+        "CWE-125": 10,
+        "CWE-79": 7,
+        "CWE-787": 7,
+        "CWE-121": 4,
+        "CWE-770": 4
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-125",
+          10
+        ],
+        [
+          "CWE-79",
+          7
+        ],
+        [
+          "CWE-787",
+          7
+        ],
+        [
+          "CWE-121",
+          4
+        ],
+        [
+          "CWE-770",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "OX",
+      "assigner_org_id": "8ce71d90-2354-404b-a86e-bec2cc4e6981",
+      "count": 96,
+      "rank": 66,
+      "first_cve_date": "2026-02-09T14:20:46.592Z",
+      "last_cve_date": "2026-08-28T10:12:33.625Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 18,
+        "Medium": 61,
+        "Low": 16,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-400": 17,
+        "CWE-770": 12,
+        "CWE-20": 6,
+        "CWE-200": 4,
+        "CWE-287": 4
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-400",
+          17
+        ],
+        [
+          "CWE-770",
+          12
+        ],
+        [
+          "CWE-20",
+          6
+        ],
+        [
+          "CWE-200",
+          4
+        ],
+        [
+          "CWE-287",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "Gitea",
+      "assigner_org_id": "88ee5874-cf24-4952-aea0-31affedb7ff2",
+      "count": 96,
+      "rank": 67,
+      "first_cve_date": "2026-01-22T22:01:49.410Z",
+      "last_cve_date": "2026-08-13T16:48:52.623Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 21,
+        "High": 36,
+        "Medium": 34,
+        "Low": 5
+      },
+      "top_cwe_types": {
+        "CWE-284": 37,
+        "CWE-863": 18,
+        "CWE-200": 14,
+        "CWE-862": 11,
+        "CWE-639": 10
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-284",
+          37
+        ],
+        [
+          "CWE-863",
+          18
+        ],
+        [
+          "CWE-200",
+          14
+        ],
+        [
+          "CWE-862",
+          11
+        ],
+        [
+          "CWE-639",
+          10
+        ]
+      ]
+    },
+    {
+      "name": "eclipse",
+      "assigner_org_id": "e51fbebd-6053-4e49-959f-1b94eeb69a2c",
+      "count": 92,
+      "rank": 68,
+      "first_cve_date": "2026-01-15T20:50:25.642Z",
+      "last_cve_date": "2026-09-22T09:27:34.713Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Open Source"
+      ],
+      "severity_distribution": {
+        "High": 42,
+        "Medium": 31,
+        "Low": 2,
+        "Critical": 17
+      },
+      "top_cwe_types": {
+        "CWE-22": 11,
+        "CWE-918": 7,
+        "CWE-400": 6,
+        "CWE-829": 6,
+        "CWE-863": 6
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-22",
+          11
+        ],
+        [
+          "CWE-918",
+          7
+        ],
+        [
+          "CWE-400",
+          6
+        ],
+        [
+          "CWE-829",
+          6
+        ],
+        [
+          "CWE-863",
+          6
+        ]
+      ]
+    },
+    {
+      "name": "suse",
+      "assigner_org_id": "404e59f5-483d-4b8a-8e7a-e67604dd8afb",
+      "count": 92,
+      "rank": 69,
+      "first_cve_date": "2026-01-08T10:23:18.934Z",
+      "last_cve_date": "2026-09-21T13:49:21.327Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 50,
+        "Medium": 25,
+        "Low": 3,
+        "Critical": 14
+      },
+      "top_cwe_types": {
+        "CWE-863": 7,
+        "CWE-122": 7,
+        "CWE-23": 5,
+        "CWE-367": 5,
+        "CWE-78": 5
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-863",
+          7
+        ],
+        [
+          "CWE-122",
+          7
+        ],
+        [
+          "CWE-23",
+          5
+        ],
+        [
+          "CWE-367",
+          5
+        ],
+        [
+          "CWE-78",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "palo_alto",
+      "assigner_org_id": "d6c1279f-00f6-4ef7-9217-f89ffe703ec0",
+      "count": 92,
+      "rank": 70,
+      "first_cve_date": "2026-01-15T18:45:08.579Z",
+      "last_cve_date": "2026-09-10T06:05:20.011Z",
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 51,
+        "Low": 18,
+        "High": 20,
+        "Critical": 3
+      },
+      "top_cwe_types": {
+        "CWE-295": 9,
+        "CWE-754": 8,
+        "CWE-78": 7,
+        "CWE-787": 6,
+        "CWE-79": 5
+      },
+      "kev_count": 2,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-295",
+          9
+        ],
+        [
+          "CWE-754",
+          8
+        ],
+        [
+          "CWE-78",
+          7
+        ],
+        [
+          "CWE-787",
+          6
+        ],
+        [
+          "CWE-79",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "Go",
+      "assigner_org_id": "1bb62c36-49e3-4200-9d77-64a1400537cc",
+      "count": 91,
+      "rank": 71,
+      "first_cve_date": "2026-01-28T19:30:30.704Z",
+      "last_cve_date": "2026-09-02T19:37:05.807Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 47,
+        "Critical": 13,
+        "Medium": 28,
+        "Low": 3
+      },
+      "top_cwe_types": {
+        "CWE-79": 9,
+        "CWE-407": 8,
+        "CWE-770": 8,
+        "CWE-125": 6,
+        "CWE-400": 5
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          9
+        ],
+        [
+          "CWE-407",
+          8
+        ],
+        [
+          "CWE-770",
+          8
+        ],
+        [
+          "CWE-125",
+          6
+        ],
+        [
+          "CWE-400",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "ProgressSoftware",
+      "assigner_org_id": "f9fea0b6-671e-4eea-8fde-31911902ae05",
+      "count": 88,
+      "rank": 72,
+      "first_cve_date": "2026-01-06T22:16:48.036Z",
+      "last_cve_date": "2026-09-11T12:28:49.216Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 53,
+        "Critical": 15,
+        "Low": 5,
+        "Medium": 15
+      },
+      "top_cwe_types": {
+        "CWE-22": 7,
+        "CWE-79": 7,
+        "CWE-269": 5,
+        "CWE-73": 5,
+        "CWE-77": 5
+      },
+      "kev_count": 1,
+      "epss_high_count": 3,
+      "epss_elevated_count": 7,
+      "top_cwes": [
+        [
+          "CWE-22",
+          7
+        ],
+        [
+          "CWE-79",
+          7
+        ],
+        [
+          "CWE-269",
+          5
+        ],
+        [
+          "CWE-73",
+          5
+        ],
+        [
+          "CWE-77",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "PostgreSQL",
+      "assigner_org_id": "f86ef6dc-4d3a-42ad-8f28-e6d5547a5007",
+      "count": 88,
+      "rank": 73,
+      "first_cve_date": "2026-02-05T17:30:05.089Z",
+      "last_cve_date": "2026-09-23T16:04:48.392Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 4,
+        "High": 49,
+        "Critical": 8,
+        "Medium": 27
+      },
+      "top_cwe_types": {
+        "CWE-89": 14,
+        "CWE-190": 7,
+        "CWE-122": 7,
+        "CWE-843": 5,
+        "CWE-862": 5
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-89",
+          14
+        ],
+        [
+          "CWE-190",
+          7
+        ],
+        [
+          "CWE-122",
+          7
+        ],
+        [
+          "CWE-843",
+          5
+        ],
+        [
+          "CWE-862",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "f5",
+      "assigner_org_id": "9dacffd4-cb11-413f-8451-fbbfd4ddc0ab",
+      "count": 88,
+      "rank": 74,
+      "first_cve_date": "2026-02-04T15:02:04.810Z",
+      "last_cve_date": "2026-09-22T14:17:42.730Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 21,
+        "High": 55,
+        "Critical": 9,
+        "Low": 3
+      },
+      "top_cwe_types": {
+        "CWE-122": 9,
+        "CWE-476": 5,
+        "CWE-732": 5,
+        "CWE-125": 4,
+        "CWE-76": 4
+      },
+      "kev_count": 1,
+      "epss_high_count": 1,
+      "epss_elevated_count": 3,
+      "top_cwes": [
+        [
+          "CWE-122",
+          9
+        ],
+        [
+          "CWE-476",
+          5
+        ],
+        [
+          "CWE-732",
+          5
+        ],
+        [
+          "CWE-125",
+          4
+        ],
+        [
+          "CWE-76",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "Tanium",
+      "assigner_org_id": "3938794e-25f5-4123-a1ba-5cbd7f104512",
+      "count": 85,
+      "rank": 75,
+      "first_cve_date": "2026-01-26T17:36:33.504Z",
+      "last_cve_date": "2026-09-16T19:43:03.949Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 53,
+        "Low": 13,
+        "High": 19
+      },
+      "top_cwe_types": {
+        "CWE-276": 10,
+        "CWE-862": 10,
+        "CWE-89": 8,
+        "CWE-59": 7,
+        "CWE-863": 6
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-276",
+          10
+        ],
+        [
+          "CWE-862",
+          10
+        ],
+        [
+          "CWE-89",
+          8
+        ],
+        [
+          "CWE-59",
+          7
+        ],
+        [
+          "CWE-863",
+          6
+        ]
+      ]
+    },
+    {
+      "name": "cisa-cg",
+      "assigner_org_id": "9119a7d8-5eab-497f-8521-727c672e3725",
+      "count": 81,
+      "rank": 76,
+      "first_cve_date": "2026-01-08T17:09:03.313Z",
+      "last_cve_date": "2026-09-23T16:07:10.048Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT",
+        "Government"
+      ],
+      "severity_distribution": {
+        "Critical": 20,
+        "Medium": 31,
+        "High": 30
+      },
+      "top_cwe_types": {
+        "CWE-79": 10,
+        "CWE-306": 8,
+        "CWE-22": 5,
+        "CWE-89": 5,
+        "CWE-862": 4
+      },
+      "kev_count": 1,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-79",
+          10
+        ],
+        [
+          "CWE-306",
+          8
+        ],
+        [
+          "CWE-22",
+          5
+        ],
+        [
+          "CWE-89",
+          5
+        ],
+        [
+          "CWE-862",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "Foxit",
+      "assigner_org_id": "14984358-7092-470d-8f34-ade47a7658a2",
+      "count": 81,
+      "rank": 77,
+      "first_cve_date": "2026-01-20T06:51:34.771Z",
+      "last_cve_date": "2026-09-23T07:51:31.844Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 26,
+        "High": 55
+      },
+      "top_cwe_types": {
+        "CWE-416": 31,
+        "CWE-125": 10,
+        "CWE-787": 7,
+        "CWE-79": 3,
+        "CWE-918": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-416",
+          31
+        ],
+        [
+          "CWE-125",
+          10
+        ],
+        [
+          "CWE-787",
+          7
+        ],
+        [
+          "CWE-79",
+          3
+        ],
+        [
+          "CWE-918",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "GovTech CSG",
+      "assigner_org_id": "1a37b84a-8e51-4525-b3d6-87e2fae01dbd",
+      "count": 81,
+      "rank": 78,
+      "first_cve_date": "2026-01-27T08:15:57.520Z",
+      "last_cve_date": "2026-03-24T06:05:21.161Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Government"
+      ],
+      "severity_distribution": {
+        "Medium": 25,
+        "Critical": 30,
+        "High": 24,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-787": 18,
+        "CWE-125": 12,
+        "CWE-119": 10,
+        "CWE-190": 8,
+        "CWE-476": 6
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          18
+        ],
+        [
+          "CWE-125",
+          12
+        ],
+        [
+          "CWE-119",
+          10
+        ],
+        [
+          "CWE-190",
+          8
+        ],
+        [
+          "CWE-476",
+          6
+        ]
+      ]
+    },
+    {
+      "name": "GV",
+      "assigner_org_id": "0df08a0e-a200-4957-9bb0-084f562506f9",
+      "count": 78,
+      "rank": 79,
+      "first_cve_date": "2026-03-23T01:05:31.952Z",
+      "last_cve_date": "2026-09-17T01:50:05.966Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 43,
+        "Critical": 24,
+        "Medium": 11
+      },
+      "top_cwe_types": {
+        "CWE-121": 17,
+        "CWE-78": 12,
+        "CWE-129": 11,
+        "CWE-120": 7,
+        "CWE-787": 4
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-121",
+          17
+        ],
+        [
+          "CWE-78",
+          12
+        ],
+        [
+          "CWE-129",
+          11
+        ],
+        [
+          "CWE-120",
+          7
+        ],
+        [
+          "CWE-787",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "wolfSSL",
+      "assigner_org_id": "50d2cd11-d01a-48ed-9441-5bfce9d63b27",
+      "count": 76,
+      "rank": 80,
+      "first_cve_date": "2026-01-06T17:26:30.360Z",
+      "last_cve_date": "2026-08-28T14:43:43.099Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 3,
+        "Medium": 29,
+        "High": 19,
+        "Low": 25
+      },
+      "top_cwe_types": {
+        "CWE-295": 13,
+        "CWE-787": 9,
+        "CWE-122": 9,
+        "CWE-125": 7,
+        "CWE-347": 5
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-295",
+          13
+        ],
+        [
+          "CWE-787",
+          9
+        ],
+        [
+          "CWE-122",
+          9
+        ],
+        [
+          "CWE-125",
+          7
+        ],
+        [
+          "CWE-347",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "DEVOLUTIONS",
+      "assigner_org_id": "bfee16bd-18e6-446c-9a65-f5b2e3d89c23",
+      "count": 75,
+      "rank": 81,
+      "first_cve_date": "2026-01-07T17:00:21.027Z",
+      "last_cve_date": "2026-09-15T20:14:31.376Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 20,
+        "Medium": 42,
+        "Low": 8,
+        "Critical": 5
+      },
+      "top_cwe_types": {
+        "CWE-862": 13,
+        "CWE-284": 6,
+        "CWE-295": 6,
+        "CWE-863": 5,
+        "CWE-312": 4
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-862",
+          13
+        ],
+        [
+          "CWE-284",
+          6
+        ],
+        [
+          "CWE-295",
+          6
+        ],
+        [
+          "CWE-863",
+          5
+        ],
+        [
+          "CWE-312",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "juniper",
+      "assigner_org_id": "8cbe9d5a-a066-4c94-8978-4b15efeae968",
+      "count": 74,
+      "rank": 82,
+      "first_cve_date": "2026-01-15T20:10:44.846Z",
+      "last_cve_date": "2026-07-09T21:14:33.905Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 4,
+        "High": 48,
+        "Medium": 22
+      },
+      "top_cwe_types": {
+        "CWE-754": 13,
+        "CWE-401": 5,
+        "CWE-1286": 3,
+        "CWE-862": 3,
+        "CWE-732": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-754",
+          13
+        ],
+        [
+          "CWE-401",
+          5
+        ],
+        [
+          "CWE-1286",
+          3
+        ],
+        [
+          "CWE-862",
+          3
+        ],
+        [
+          "CWE-732",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Nozomi",
+      "assigner_org_id": "bec8025f-a851-46e5-b3a3-058e6b0aa23c",
+      "count": 74,
+      "rank": 83,
+      "first_cve_date": "2026-02-20T16:48:34.348Z",
+      "last_cve_date": "2026-09-16T13:03:44.204Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 23,
+        "High": 41,
+        "Critical": 10
+      },
+      "top_cwe_types": {
+        "CWE-78": 18,
+        "CWE-79": 9,
+        "CWE-732": 5,
+        "CWE-863": 3,
+        "CWE-23": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          18
+        ],
+        [
+          "CWE-79",
+          9
+        ],
+        [
+          "CWE-732",
+          5
+        ],
+        [
+          "CWE-863",
+          3
+        ],
+        [
+          "CWE-23",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "@huntr_ai",
+      "assigner_org_id": "c09c270a-b464-47c1-9133-acb35b22c19a",
+      "count": 73,
+      "rank": 84,
+      "first_cve_date": "2026-01-01T07:03:57.277Z",
+      "last_cve_date": "2026-08-10T06:29:56.111Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Other"
+      ],
+      "severity_distribution": {
+        "Critical": 16,
+        "High": 36,
+        "Medium": 18,
+        "Low": 3
+      },
+      "top_cwe_types": {
+        "CWE-22": 12,
+        "CWE-284": 6,
+        "CWE-502": 5,
+        "CWE-94": 5,
+        "CWE-400": 4
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-22",
+          12
+        ],
+        [
+          "CWE-284",
+          6
+        ],
+        [
+          "CWE-502",
+          5
+        ],
+        [
+          "CWE-94",
+          5
+        ],
+        [
+          "CWE-400",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "Arista",
+      "assigner_org_id": "c8b34d1a-69ae-45c3-88fe-f3b3d44f39b7",
+      "count": 66,
+      "rank": 85,
+      "first_cve_date": "2026-01-06T19:15:44.409Z",
+      "last_cve_date": "2026-09-22T07:37:24.300Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 28,
+        "Medium": 22,
+        "Critical": 12,
+        "Low": 4
+      },
+      "top_cwe_types": {
+        "CWE-78": 7,
+        "CWE-20": 6,
+        "CWE-532": 5,
+        "CWE-306": 3,
+        "CWE-345": 3
+      },
+      "kev_count": 3,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          7
+        ],
+        [
+          "CWE-20",
+          6
+        ],
+        [
+          "CWE-532",
+          5
+        ],
+        [
+          "CWE-306",
+          3
+        ],
+        [
+          "CWE-345",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "freebsd",
+      "assigner_org_id": "63664ac6-956c-4cba-a5d0-f46076e16109",
+      "count": 66,
+      "rank": 86,
+      "first_cve_date": "2026-03-09T11:27:27.275Z",
+      "last_cve_date": "2026-08-26T05:39:42.893Z",
+      "years_active": 22,
+      "first_cve_year": 2005,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 53,
+        "Low": 3,
+        "Medium": 8,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-416": 10,
+        "CWE-122": 8,
+        "CWE-121": 6,
+        "CWE-787": 6,
+        "CWE-269": 5
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-416",
+          10
+        ],
+        [
+          "CWE-122",
+          8
+        ],
+        [
+          "CWE-121",
+          6
+        ],
+        [
+          "CWE-787",
+          6
+        ],
+        [
+          "CWE-269",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "Fluid Attacks",
+      "assigner_org_id": "84fe0718-d6bb-4716-a7e8-81a6d1daa869",
+      "count": 66,
+      "rank": 87,
+      "first_cve_date": "2026-01-06T15:15:30.305Z",
+      "last_cve_date": "2026-09-23T18:02:02.601Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 28,
+        "Medium": 38
+      },
+      "top_cwe_types": {
+        "CWE-79": 39,
+        "CWE-862": 5,
+        "CWE-89": 5,
+        "CWE-863": 3,
+        "CWE-732": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          39
+        ],
+        [
+          "CWE-862",
+          5
+        ],
+        [
+          "CWE-89",
+          5
+        ],
+        [
+          "CWE-863",
+          3
+        ],
+        [
+          "CWE-732",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "talos",
+      "assigner_org_id": "b86d76f8-0f8a-4a96-a78d-d8abfc7fc29b",
+      "count": 65,
+      "rank": 88,
+      "first_cve_date": "2026-01-15T15:19:48.838Z",
+      "last_cve_date": "2026-06-25T21:46:00.057Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 46,
+        "High": 14,
+        "Critical": 5
+      },
+      "top_cwe_types": {
+        "CWE-79": 28,
+        "CWE-125": 18,
+        "CWE-122": 4,
+        "CWE-190": 4,
+        "CWE-120": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          28
+        ],
+        [
+          "CWE-125",
+          18
+        ],
+        [
+          "CWE-122",
+          4
+        ],
+        [
+          "CWE-190",
+          4
+        ],
+        [
+          "CWE-120",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "JFROG",
+      "assigner_org_id": "48a46f29-ae42-4e1d-90dd-c1676c1e5e6d",
+      "count": 65,
+      "rank": 89,
+      "first_cve_date": "2026-01-04T09:17:34.468Z",
+      "last_cve_date": "2026-09-23T10:03:06.643Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 31,
+        "High": 29,
+        "Critical": 3,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-862": 15,
+        "CWE-918": 9,
+        "CWE-287": 5,
+        "CWE-22": 5,
+        "CWE-79": 4
+      },
+      "kev_count": 4,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-862",
+          15
+        ],
+        [
+          "CWE-918",
+          9
+        ],
+        [
+          "CWE-287",
+          5
+        ],
+        [
+          "CWE-22",
+          5
+        ],
+        [
+          "CWE-79",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "samsung.tv_appliance",
+      "assigner_org_id": "ca193ba2-0cff-4e34-b04e-1ea07103c6fe",
+      "count": 63,
+      "rank": 90,
+      "first_cve_date": "2026-02-02T04:49:13.086Z",
+      "last_cve_date": "2026-09-15T21:34:04.487Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 51,
+        "High": 10,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-190": 13,
+        "CWE-787": 7,
+        "CWE-125": 6,
+        "CWE-674": 5,
+        "CWE-476": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-190",
+          13
+        ],
+        [
+          "CWE-787",
+          7
+        ],
+        [
+          "CWE-125",
+          6
+        ],
+        [
+          "CWE-674",
+          5
+        ],
+        [
+          "CWE-476",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "tenable",
+      "assigner_org_id": "5ac1ecc2-367a-4d16-a0b2-35d495ddd0be",
+      "count": 62,
+      "rank": 91,
+      "first_cve_date": "2026-01-13T15:05:19.918Z",
+      "last_cve_date": "2026-09-16T15:23:21.834Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "severity_distribution": {
+        "High": 22,
+        "Critical": 20,
+        "Medium": 18,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-78": 10,
+        "CWE-89": 8,
+        "CWE-862": 5,
+        "CWE-306": 4,
+        "CWE-79": 4
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-78",
+          10
+        ],
+        [
+          "CWE-89",
+          8
+        ],
+        [
+          "CWE-862",
+          5
+        ],
+        [
+          "CWE-306",
+          4
+        ],
+        [
+          "CWE-79",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "WatchGuard",
+      "assigner_org_id": "5d1c2695-1a31-4499-88ae-e847036fd7e3",
+      "count": 61,
+      "rank": 92,
+      "first_cve_date": "2026-01-30T13:02:59.561Z",
+      "last_cve_date": "2026-09-23T12:52:04.902Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 33,
+        "Medium": 20,
+        "Critical": 8
+      },
+      "top_cwe_types": {
+        "CWE-787": 10,
+        "CWE-79": 9,
+        "CWE-121": 5,
+        "CWE-502": 4,
+        "CWE-918": 4
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          10
+        ],
+        [
+          "CWE-79",
+          9
+        ],
+        [
+          "CWE-121",
+          5
+        ],
+        [
+          "CWE-502",
+          4
+        ],
+        [
+          "CWE-918",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "TYPO3",
+      "assigner_org_id": "f4fb688c-4412-4426-b4b8-421ecf27b14a",
+      "count": 60,
+      "rank": 93,
+      "first_cve_date": "2026-01-13T11:53:02.274Z",
+      "last_cve_date": "2026-09-08T09:18:41.605Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 26,
+        "Medium": 28,
+        "Low": 3,
+        "Critical": 3
+      },
+      "top_cwe_types": {
+        "CWE-862": 21,
+        "CWE-639": 10,
+        "CWE-502": 8,
+        "CWE-200": 4,
+        "CWE-22": 4
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-862",
+          21
+        ],
+        [
+          "CWE-639",
+          10
+        ],
+        [
+          "CWE-502",
+          8
+        ],
+        [
+          "CWE-200",
+          4
+        ],
+        [
+          "CWE-22",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "Rockwell",
+      "assigner_org_id": "b73dd486-f505-4403-b634-40b078b177f0",
+      "count": 58,
+      "rank": 94,
+      "first_cve_date": "2026-01-20T13:18:32.484Z",
+      "last_cve_date": "2026-09-03T13:10:28.638Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 46,
+        "Critical": 6,
+        "Medium": 6
+      },
+      "top_cwe_types": {
+        "CWE-400": 10,
+        "CWE-787": 6,
+        "CWE-120": 4,
+        "CWE-770": 3,
+        "CWE-306": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-400",
+          10
+        ],
+        [
+          "CWE-787",
+          6
+        ],
+        [
+          "CWE-120",
+          4
+        ],
+        [
+          "CWE-770",
+          3
+        ],
+        [
+          "CWE-306",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "NLnet Labs",
+      "assigner_org_id": "206fc3a0-e175-490b-9eaa-a5738056c9f6",
+      "count": 57,
+      "rank": 95,
+      "first_cve_date": "2026-05-20T09:17:47.920Z",
+      "last_cve_date": "2026-09-16T08:32:25.398Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 23,
+        "Medium": 25,
+        "Low": 7,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-416": 6,
+        "CWE-122": 5,
+        "CWE-20": 3,
+        "CWE-770": 3,
+        "CWE-345": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-416",
+          6
+        ],
+        [
+          "CWE-122",
+          5
+        ],
+        [
+          "CWE-20",
+          3
+        ],
+        [
+          "CWE-770",
+          3
+        ],
+        [
+          "CWE-345",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "lenovo",
+      "assigner_org_id": "da227ddf-6e25-4b41-b023-0f976dcaca4b",
+      "count": 56,
+      "rank": 96,
+      "first_cve_date": "2026-01-14T22:16:13.569Z",
+      "last_cve_date": "2026-09-10T21:00:31.582Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 35,
+        "Medium": 17,
+        "Low": 3,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-59": 6,
+        "CWE-290": 4,
+        "CWE-78": 4,
+        "CWE-88": 4,
+        "CWE-787": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-59",
+          6
+        ],
+        [
+          "CWE-290",
+          4
+        ],
+        [
+          "CWE-78",
+          4
+        ],
+        [
+          "CWE-88",
+          4
+        ],
+        [
+          "CWE-787",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "SEC-VLab",
+      "assigner_org_id": "551230f0-3615-47bd-b7cc-93e92e730bbf",
+      "count": 55,
+      "rank": 97,
+      "first_cve_date": "2026-01-26T10:03:21.868Z",
+      "last_cve_date": "2026-06-18T08:32:14.717Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 29,
+        "Critical": 8,
+        "Medium": 18
+      },
+      "top_cwe_types": {
+        "CWE-798": 6,
+        "CWE-306": 4,
+        "CWE-862": 3,
+        "CWE-367": 3,
+        "CWE-1188": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-798",
+          6
+        ],
+        [
+          "CWE-306",
+          4
+        ],
+        [
+          "CWE-862",
+          3
+        ],
+        [
+          "CWE-367",
+          3
+        ],
+        [
+          "CWE-1188",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "GRAFANA",
+      "assigner_org_id": "57da9224-a3e2-4646-9d0e-c4dc2e05e7da",
+      "count": 55,
+      "rank": 98,
+      "first_cve_date": "2026-01-27T09:07:04.758Z",
+      "last_cve_date": "2026-09-17T20:47:01.006Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 4,
+        "Medium": 27,
+        "Critical": 4,
+        "High": 20
+      },
+      "top_cwe_types": {
+        "CWE-400": 12,
+        "CWE-770": 6,
+        "CWE-284": 6,
+        "CWE-79": 5,
+        "CWE-863": 5
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-400",
+          12
+        ],
+        [
+          "CWE-770",
+          6
+        ],
+        [
+          "CWE-284",
+          6
+        ],
+        [
+          "CWE-79",
+          5
+        ],
+        [
+          "CWE-863",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "securin",
+      "assigner_org_id": "33c584b5-0579-4c06-b2a0-8d8329fcab9c",
+      "count": 53,
+      "rank": 99,
+      "first_cve_date": "2026-04-10T07:40:59.902Z",
+      "last_cve_date": "2026-07-01T03:33:28.957Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 13,
+        "Critical": 8,
+        "High": 18,
+        "Low": 14
+      },
+      "top_cwe_types": {
+        "CWE-787": 7,
+        "CWE-798": 6,
+        "CWE-125": 4,
+        "CWE-121": 3,
+        "CWE-78": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          7
+        ],
+        [
+          "CWE-798",
+          6
+        ],
+        [
+          "CWE-125",
+          4
+        ],
+        [
+          "CWE-121",
+          3
+        ],
+        [
+          "CWE-78",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "Zohocorp",
+      "assigner_org_id": "0fc0942c-577d-436f-ae8e-945763c79b02",
+      "count": 51,
+      "rank": 100,
+      "first_cve_date": "2026-01-13T13:14:03.879Z",
+      "last_cve_date": "2026-09-23T13:41:27.385Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 8,
+        "Critical": 7,
+        "High": 36
+      },
+      "top_cwe_types": {
+        "CWE-79": 9,
+        "CWE-89": 7,
+        "CWE-20": 4,
+        "CWE-269": 4,
+        "CWE-78": 4
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          9
+        ],
+        [
+          "CWE-89",
+          7
+        ],
+        [
+          "CWE-20",
+          4
+        ],
+        [
+          "CWE-269",
+          4
+        ],
+        [
+          "CWE-78",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "synology",
+      "assigner_org_id": "db201096-a0cc-46c7-9a55-61d9e221bf01",
+      "count": 49,
+      "rank": 101,
+      "first_cve_date": "2026-02-24T02:31:20.298Z",
+      "last_cve_date": "2026-09-18T08:29:33.365Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 27,
+        "High": 12,
+        "Low": 6,
+        "Critical": 4
+      },
+      "top_cwe_types": {
+        "CWE-79": 6,
+        "CWE-22": 5,
+        "CWE-346": 3,
+        "CWE-89": 3,
+        "CWE-552": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          6
+        ],
+        [
+          "CWE-22",
+          5
+        ],
+        [
+          "CWE-346",
+          3
+        ],
+        [
+          "CWE-89",
+          3
+        ],
+        [
+          "CWE-552",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "openssl",
+      "assigner_org_id": "3a12439a-ef3a-4c79-92e6-6081a721f1e5",
+      "count": 49,
+      "rank": 102,
+      "first_cve_date": "2026-01-27T15:59:41.681Z",
+      "last_cve_date": "2026-08-25T13:00:25.067Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 17,
+        "High": 25,
+        "Critical": 5,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-476": 12,
+        "CWE-787": 7,
+        "CWE-754": 4,
+        "CWE-325": 4,
+        "CWE-125": 4
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-476",
+          12
+        ],
+        [
+          "CWE-787",
+          7
+        ],
+        [
+          "CWE-754",
+          4
+        ],
+        [
+          "CWE-325",
+          4
+        ],
+        [
+          "CWE-125",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "rapid7",
+      "assigner_org_id": "9974b330-7714-4307-a722-5648477acda7",
+      "count": 49,
+      "rank": 103,
+      "first_cve_date": "2026-02-03T14:54:12.073Z",
+      "last_cve_date": "2026-09-10T03:00:00.939Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "severity_distribution": {
+        "Medium": 23,
+        "High": 20,
+        "Low": 2,
+        "Critical": 4
+      },
+      "top_cwe_types": {
+        "CWE-78": 9,
+        "CWE-863": 5,
+        "CWE-22": 4,
+        "CWE-862": 3,
+        "CWE-94": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-78",
+          9
+        ],
+        [
+          "CWE-863",
+          5
+        ],
+        [
+          "CWE-22",
+          4
+        ],
+        [
+          "CWE-862",
+          3
+        ],
+        [
+          "CWE-94",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "Acer",
+      "assigner_org_id": "8fc372e3-d9c5-46e4-9410-38469745c639",
+      "count": 49,
+      "rank": 104,
+      "first_cve_date": "2026-05-08T05:57:22.797Z",
+      "last_cve_date": "2026-09-23T07:20:41.257Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 24,
+        "Medium": 11,
+        "Low": 3,
+        "Critical": 11
+      },
+      "top_cwe_types": {
+        "CWE-284": 7,
+        "CWE-287": 6,
+        "CWE-269": 5,
+        "CWE-732": 5,
+        "CWE-306": 5
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-284",
+          7
+        ],
+        [
+          "CWE-287",
+          6
+        ],
+        [
+          "CWE-269",
+          5
+        ],
+        [
+          "CWE-732",
+          5
+        ],
+        [
+          "CWE-306",
+          5
+        ]
+      ]
+    },
+    {
+      "name": "WSO2",
+      "assigner_org_id": "ed10eef1-636d-4fbe-9993-6890dfa878f8",
+      "count": 48,
+      "rank": 105,
+      "first_cve_date": "2026-02-19T10:04:47.542Z",
+      "last_cve_date": "2026-09-15T09:53:54.532Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 6,
+        "Medium": 26,
+        "High": 10,
+        "Critical": 6
+      },
+      "top_cwe_types": {
+        "CWE-79": 8,
+        "CWE-613": 4,
+        "CWE-20": 4,
+        "CWE-203": 3,
+        "CWE-611": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          8
+        ],
+        [
+          "CWE-613",
+          4
+        ],
+        [
+          "CWE-20",
+          4
+        ],
+        [
+          "CWE-203",
+          3
+        ],
+        [
+          "CWE-611",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "PSF",
+      "assigner_org_id": "28c92f92-d60d-412d-b760-e73465c3df22",
+      "count": 47,
+      "rank": 106,
+      "first_cve_date": "2026-01-20T21:09:11.229Z",
+      "last_cve_date": "2026-09-14T19:14:03.873Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 8,
+        "Medium": 29,
+        "High": 9,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-22": 8,
+        "CWE-93": 5,
+        "CWE-20": 3,
+        "CWE-74": 3,
+        "CWE-77": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-22",
+          8
+        ],
+        [
+          "CWE-93",
+          5
+        ],
+        [
+          "CWE-20",
+          3
+        ],
+        [
+          "CWE-74",
+          3
+        ],
+        [
+          "CWE-77",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "curl",
+      "assigner_org_id": "2499f714-1537-4658-8207-48ae4bb9eae9",
+      "count": 46,
+      "rank": 107,
+      "first_cve_date": "2026-01-08T10:00:25.773Z",
+      "last_cve_date": "2026-09-06T17:49:35.050Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 16,
+        "Low": 1,
+        "High": 19,
+        "Critical": 10
+      },
+      "top_cwe_types": {
+        "CWE-295": 7,
+        "CWE-522": 5,
+        "CWE-416": 5,
+        "CWE-488": 4,
+        "CWE-305": 4
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-295",
+          7
+        ],
+        [
+          "CWE-522",
+          5
+        ],
+        [
+          "CWE-416",
+          5
+        ],
+        [
+          "CWE-488",
+          4
+        ],
+        [
+          "CWE-305",
+          4
+        ]
+      ]
+    },
+    {
+      "name": "ENISA",
+      "assigner_org_id": "a6d3dc9e-0591-4a13-bce7-0f5b31ff6158",
+      "count": 43,
+      "rank": 108,
+      "first_cve_date": "2026-02-24T17:14:36.141Z",
+      "last_cve_date": "2026-09-18T11:19:34.183Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 13,
+        "High": 17,
+        "Critical": 12,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-78": 5,
+        "CWE-20": 5,
+        "CWE-347": 4,
+        "CWE-798": 3,
+        "CWE-22": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          5
+        ],
+        [
+          "CWE-20",
+          5
+        ],
+        [
+          "CWE-347",
+          4
+        ],
+        [
+          "CWE-798",
+          3
+        ],
+        [
+          "CWE-22",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "HashiCorp",
+      "assigner_org_id": "67fedba0-ff2e-4543-ba5b-aa93e87718cc",
+      "count": 43,
+      "rank": 109,
+      "first_cve_date": "2026-02-12T01:35:06.231Z",
+      "last_cve_date": "2026-09-15T19:45:07.836Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 19,
+        "Critical": 3,
+        "Medium": 21
+      },
+      "top_cwe_types": {
+        "CWE-22": 6,
+        "CWE-770": 6,
+        "CWE-59": 6,
+        "CWE-863": 4,
+        "CWE-918": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-22",
+          6
+        ],
+        [
+          "CWE-770",
+          6
+        ],
+        [
+          "CWE-59",
+          6
+        ],
+        [
+          "CWE-863",
+          4
+        ],
+        [
+          "CWE-918",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "bcorg",
+      "assigner_org_id": "91579145-5d7b-4cc5-b925-a0262ff19630",
+      "count": 42,
+      "rank": 110,
+      "first_cve_date": "2026-04-15T08:56:34.057Z",
+      "last_cve_date": "2026-08-08T00:59:40.512Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 28,
+        "Critical": 5,
+        "Medium": 8,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-770": 6,
+        "CWE-354": 6,
+        "CWE-789": 6,
+        "CWE-347": 4,
+        "CWE-327": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-770",
+          6
+        ],
+        [
+          "CWE-354",
+          6
+        ],
+        [
+          "CWE-789",
+          6
+        ],
+        [
+          "CWE-347",
+          4
+        ],
+        [
+          "CWE-327",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "XEN",
+      "assigner_org_id": "23aa2041-22e1-471f-9209-9b7396fa234f",
+      "count": 42,
+      "rank": 111,
+      "first_cve_date": "2026-01-28T15:33:17.316Z",
+      "last_cve_date": "2026-09-08T12:11:21.789Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 11,
+        "High": 16,
+        "Medium": 14,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-362": 8,
+        "CWE-250": 5,
+        "CWE-367": 3,
+        "CWE-276": 3,
+        "CWE-667": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-362",
+          8
+        ],
+        [
+          "CWE-250",
+          5
+        ],
+        [
+          "CWE-367",
+          3
+        ],
+        [
+          "CWE-276",
+          3
+        ],
+        [
+          "CWE-667",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "Silabs",
+      "assigner_org_id": "030b2754-1501-44a4-bef8-48be86a33bf4",
+      "count": 42,
+      "rank": 112,
+      "first_cve_date": "2026-01-05T17:07:32.807Z",
+      "last_cve_date": "2026-09-10T17:15:49.895Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 5,
+        "High": 26,
+        "Critical": 1,
+        "Medium": 10
+      },
+      "top_cwe_types": {
+        "CWE-125": 7,
+        "CWE-331": 3,
+        "CWE-617": 3,
+        "CWE-191": 3,
+        "CWE-440": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-125",
+          7
+        ],
+        [
+          "CWE-331",
+          3
+        ],
+        [
+          "CWE-617",
+          3
+        ],
+        [
+          "CWE-191",
+          3
+        ],
+        [
+          "CWE-440",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "schneider",
+      "assigner_org_id": "076d1eb6-cfab-4401-b34d-6dfc2a413bdb",
+      "count": 41,
+      "rank": 113,
+      "first_cve_date": "2026-01-15T18:28:37.316Z",
+      "last_cve_date": "2026-09-11T15:13:18.079Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 23,
+        "Medium": 15,
+        "Critical": 2,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-522": 3,
+        "CWE-78": 3,
+        "CWE-798": 2,
+        "CWE-502": 2,
+        "CWE-307": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-522",
+          3
+        ],
+        [
+          "CWE-78",
+          3
+        ],
+        [
+          "CWE-798",
+          2
+        ],
+        [
+          "CWE-502",
+          2
+        ],
+        [
+          "CWE-307",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "autodesk",
+      "assigner_org_id": "7e40ea87-bc65-4944-9723-dd79dd760601",
+      "count": 41,
+      "rank": 114,
+      "first_cve_date": "2026-01-22T16:58:43.084Z",
+      "last_cve_date": "2026-09-10T13:29:58.109Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 10,
+        "High": 30,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-787": 11,
+        "CWE-79": 6,
+        "CWE-125": 5,
+        "CWE-674": 3,
+        "CWE-120": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          11
+        ],
+        [
+          "CWE-79",
+          6
+        ],
+        [
+          "CWE-125",
+          5
+        ],
+        [
+          "CWE-674",
+          3
+        ],
+        [
+          "CWE-120",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "hp",
+      "assigner_org_id": "74586083-13ce-40fd-b46a-8e5d23cfbcb2",
+      "count": 41,
+      "rank": 115,
+      "first_cve_date": "2026-02-10T17:34:18.409Z",
+      "last_cve_date": "2026-09-22T14:57:28.834Z",
+      "years_active": 18,
+      "first_cve_year": 2009,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 21,
+        "Medium": 14,
+        "Critical": 6
+      },
+      "top_cwe_types": {
+        "CWE-122": 5,
+        "CWE-379": 3,
+        "CWE-79": 3,
+        "CWE-78": 3,
+        "CWE-400": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-122",
+          5
+        ],
+        [
+          "CWE-379",
+          3
+        ],
+        [
+          "CWE-79",
+          3
+        ],
+        [
+          "CWE-78",
+          3
+        ],
+        [
+          "CWE-400",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "ASUS",
+      "assigner_org_id": "54bf65a7-a193-42d2-b1ba-8e150d3c35e1",
+      "count": 40,
+      "rank": 116,
+      "first_cve_date": "2026-01-06T02:14:37.216Z",
+      "last_cve_date": "2026-09-08T02:04:26.991Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 17,
+        "Medium": 19,
+        "Low": 2,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-782": 5,
+        "CWE-732": 3,
+        "CWE-125": 3,
+        "CWE-1284": 2,
+        "CWE-226": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-782",
+          5
+        ],
+        [
+          "CWE-732",
+          3
+        ],
+        [
+          "CWE-125",
+          3
+        ],
+        [
+          "CWE-1284",
+          2
+        ],
+        [
+          "CWE-226",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "fedora",
+      "assigner_org_id": "92fb86c3-55a5-4fb5-9c3f-4757b9e96dc5",
+      "count": 40,
+      "rank": 117,
+      "first_cve_date": "2026-01-09T07:53:48.144Z",
+      "last_cve_date": "2026-09-14T20:05:00.169Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 19,
+        "Low": 3,
+        "Medium": 18
+      },
+      "top_cwe_types": {
+        "CWE-79": 3,
+        "CWE-787": 3,
+        "CWE-125": 3,
+        "CWE-121": 2,
+        "CWE-476": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-79",
+          3
+        ],
+        [
+          "CWE-787",
+          3
+        ],
+        [
+          "CWE-125",
+          3
+        ],
+        [
+          "CWE-121",
+          2
+        ],
+        [
+          "CWE-476",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "imaginationtech",
+      "assigner_org_id": "367425dc-4d06-4041-9650-c2dc6aaa27ce",
+      "count": 40,
+      "rank": 118,
+      "first_cve_date": "2026-01-13T16:27:40.857Z",
+      "last_cve_date": "2026-09-04T01:53:55.981Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 5,
+        "Low": 2,
+        "High": 28,
+        "Medium": 5
+      },
+      "top_cwe_types": {
+        "CWE-416": 11,
+        "CWE-823": 7,
+        "CWE-280": 4,
+        "CWE-787": 3,
+        "CWE-119": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-416",
+          11
+        ],
+        [
+          "CWE-823",
+          7
+        ],
+        [
+          "CWE-280",
+          4
+        ],
+        [
+          "CWE-787",
+          3
+        ],
+        [
+          "CWE-119",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Acronis",
+      "assigner_org_id": "73dc0fef-1c66-4a72-9d2d-0a0f4012c175",
+      "count": 40,
+      "rank": 119,
+      "first_cve_date": "2026-01-27T16:43:42.575Z",
+      "last_cve_date": "2026-09-17T22:57:18.089Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 22,
+        "High": 14,
+        "Critical": 4
+      },
+      "top_cwe_types": {
+        "CWE-427": 9,
+        "CWE-863": 8,
+        "CWE-732": 4,
+        "CWE-276": 4,
+        "CWE-1390": 3
+      },
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-427",
+          9
+        ],
+        [
+          "CWE-863",
+          8
+        ],
+        [
+          "CWE-732",
+          4
+        ],
+        [
+          "CWE-276",
+          4
+        ],
+        [
+          "CWE-1390",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "NETGEAR",
+      "assigner_org_id": "a2826606-91e7-4eb6-899e-8484bd4575d5",
+      "count": 40,
+      "rank": 120,
+      "first_cve_date": "2026-01-13T16:00:25.831Z",
+      "last_cve_date": "2026-09-08T17:09:12.157Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 7,
+        "Medium": 33
+      },
+      "top_cwe_types": {
+        "CWE-20": 21,
+        "CWE-121": 6,
+        "CWE-287": 3,
+        "CWE-306": 1,
+        "CWE-352": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          21
+        ],
+        [
+          "CWE-121",
+          6
+        ],
+        [
+          "CWE-287",
+          3
+        ],
+        [
+          "CWE-306",
+          1
+        ],
+        [
+          "CWE-352",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "ivanti",
+      "assigner_org_id": "3c1d8aa1-5a33-4ea4-8992-aadd6440af75",
+      "count": 39,
+      "rank": 121,
+      "first_cve_date": "2026-01-29T21:31:17.041Z",
+      "last_cve_date": "2026-09-08T14:43:54.531Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 22,
+        "Medium": 6,
+        "Critical": 11
+      },
+      "top_cwe_types": {
+        "CWE-502": 5,
+        "CWE-862": 4,
+        "CWE-295": 4,
+        "CWE-284": 3,
+        "CWE-288": 3
+      },
+      "kev_count": 5,
+      "epss_high_count": 5,
+      "epss_elevated_count": 8,
+      "top_cwes": [
+        [
+          "CWE-502",
+          5
+        ],
+        [
+          "CWE-862",
+          4
+        ],
+        [
+          "CWE-295",
+          4
+        ],
+        [
+          "CWE-284",
+          3
+        ],
+        [
+          "CWE-288",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "runZero",
+      "assigner_org_id": "44488dab-36db-4358-99f9-bc116477f914",
+      "count": 38,
+      "rank": 122,
+      "first_cve_date": "2026-04-07T14:10:08.773Z",
+      "last_cve_date": "2026-09-15T13:57:28.846Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 15,
+        "Critical": 5,
+        "Medium": 13,
+        "Low": 5
+      },
+      "top_cwe_types": {
+        "CWE-863": 9,
+        "CWE-862": 3,
+        "CWE-798": 2,
+        "CWE-306": 2,
+        "CWE-321": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-863",
+          9
+        ],
+        [
+          "CWE-862",
+          3
+        ],
+        [
+          "CWE-798",
+          2
+        ],
+        [
+          "CWE-306",
+          2
+        ],
+        [
+          "CWE-321",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "NI",
+      "assigner_org_id": "bca5b2e8-03a4-4781-b4ca-c6a078c0bfd4",
+      "count": 37,
+      "rank": 123,
+      "first_cve_date": "2026-03-13T14:31:25.652Z",
+      "last_cve_date": "2026-09-17T18:42:17.190Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 30,
+        "Critical": 3,
+        "Medium": 4
+      },
+      "top_cwe_types": {
+        "CWE-125": 12,
+        "CWE-787": 10,
+        "CWE-476": 2,
+        "CWE-306": 2,
+        "CWE-1285": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-125",
+          12
+        ],
+        [
+          "CWE-787",
+          10
+        ],
+        [
+          "CWE-476",
+          2
+        ],
+        [
+          "CWE-306",
+          2
+        ],
+        [
+          "CWE-1285",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "isc",
+      "assigner_org_id": "404fd4d2-a609-4245-b543-2c944a302a22",
+      "count": 35,
+      "rank": 124,
+      "first_cve_date": "2026-01-21T14:43:27.260Z",
+      "last_cve_date": "2026-09-16T14:17:11.956Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 22,
+        "Medium": 13
+      },
+      "top_cwe_types": {
+        "CWE-617": 9,
+        "CWE-416": 4,
+        "CWE-770": 3,
+        "CWE-346": 2,
+        "CWE-349": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-617",
+          9
+        ],
+        [
+          "CWE-416",
+          4
+        ],
+        [
+          "CWE-770",
+          3
+        ],
+        [
+          "CWE-346",
+          2
+        ],
+        [
+          "CWE-349",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "SolarWinds",
+      "assigner_org_id": "49f11609-934d-4621-84e6-e02e032104d6",
+      "count": 35,
+      "rank": 125,
+      "first_cve_date": "2026-01-28T07:30:09.503Z",
+      "last_cve_date": "2026-09-22T19:12:44.576Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 24,
+        "High": 6,
+        "Medium": 5
+      },
+      "top_cwe_types": {
+        "CWE-639": 7,
+        "CWE-284": 4,
+        "CWE-704": 3,
+        "CWE-502": 3,
+        "CWE-79": 3
+      },
+      "kev_count": 3,
+      "epss_high_count": 4,
+      "epss_elevated_count": 6,
+      "top_cwes": [
+        [
+          "CWE-639",
+          7
+        ],
+        [
+          "CWE-284",
+          4
+        ],
+        [
+          "CWE-704",
+          3
+        ],
+        [
+          "CWE-502",
+          3
+        ],
+        [
+          "CWE-79",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "GitHub_P",
+      "assigner_org_id": "82327ea3-741d-41e4-88f8-2cf9e791e760",
+      "count": 34,
+      "rank": 126,
+      "first_cve_date": "2026-01-06T20:44:02.712Z",
+      "last_cve_date": "2026-09-22T20:43:59.193Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Open Source"
+      ],
+      "severity_distribution": {
+        "High": 16,
+        "Medium": 16,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-918": 7,
+        "CWE-79": 5,
+        "CWE-862": 4,
+        "CWE-639": 4,
+        "CWE-22": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-918",
+          7
+        ],
+        [
+          "CWE-79",
+          5
+        ],
+        [
+          "CWE-862",
+          4
+        ],
+        [
+          "CWE-639",
+          4
+        ],
+        [
+          "CWE-22",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "sonicwall",
+      "assigner_org_id": "44b2ff79-1416-4492-88bb-ed0da00c7315",
+      "count": 34,
+      "rank": 127,
+      "first_cve_date": "2026-02-24T14:52:10.841Z",
+      "last_cve_date": "2026-09-04T18:22:16.711Z",
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 7,
+        "High": 12,
+        "Medium": 13,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-94": 6,
+        "CWE-121": 3,
+        "CWE-78": 2,
+        "CWE-918": 2,
+        "CWE-79": 2
+      },
+      "kev_count": 4,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-94",
+          6
+        ],
+        [
+          "CWE-121",
+          3
+        ],
+        [
+          "CWE-78",
+          2
+        ],
+        [
+          "CWE-918",
+          2
+        ],
+        [
+          "CWE-79",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "snyk",
+      "assigner_org_id": "bae035ff-b466-4ff4-94d0-fc9efd9e1730",
+      "count": 33,
+      "rank": 128,
+      "first_cve_date": "2026-01-16T05:00:06.808Z",
+      "last_cve_date": "2026-09-10T09:54:01.912Z",
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 14,
+        "Medium": 13,
+        "Critical": 6
+      },
+      "top_cwe_types": {
+        "CWE-79": 6,
+        "CWE-94": 3,
+        "CWE-1321": 2,
+        "CWE-1333": 2,
+        "CWE-22": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          6
+        ],
+        [
+          "CWE-94",
+          3
+        ],
+        [
+          "CWE-1321",
+          2
+        ],
+        [
+          "CWE-1333",
+          2
+        ],
+        [
+          "CWE-22",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Google",
+      "assigner_org_id": "14ed7db2-1595-443d-9d34-6215bf890778",
+      "count": 33,
+      "rank": 129,
+      "first_cve_date": "2026-01-15T14:09:53.603Z",
+      "last_cve_date": "2026-09-22T21:48:26.539Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 1,
+        "Medium": 8,
+        "Critical": 8,
+        "High": 16
+      },
+      "top_cwe_types": {
+        "CWE-863": 5,
+        "CWE-674": 3,
+        "CWE-22": 3,
+        "CWE-287": 3,
+        "CWE-918": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-863",
+          5
+        ],
+        [
+          "CWE-674",
+          3
+        ],
+        [
+          "CWE-22",
+          3
+        ],
+        [
+          "CWE-287",
+          3
+        ],
+        [
+          "CWE-918",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "CSA",
+      "assigner_org_id": "5f57b9bf-260d-4433-bf07-b6a79e9bb7d4",
+      "count": 33,
+      "rank": 130,
+      "first_cve_date": "2026-01-12T02:27:16.744Z",
+      "last_cve_date": "2026-08-26T07:24:32.411Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 8,
+        "High": 10,
+        "Medium": 10,
+        "Low": 5
+      },
+      "top_cwe_types": {
+        "CWE-89": 8,
+        "CWE-284": 5,
+        "CWE-121": 4,
+        "CWE-434": 2,
+        "CWE-639": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-89",
+          8
+        ],
+        [
+          "CWE-284",
+          5
+        ],
+        [
+          "CWE-121",
+          4
+        ],
+        [
+          "CWE-434",
+          2
+        ],
+        [
+          "CWE-639",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Sonatype",
+      "assigner_org_id": "103e4ec9-0a87-450b-af77-479448ddef11",
+      "count": 31,
+      "rank": 131,
+      "first_cve_date": "2026-01-14T22:05:17.135Z",
+      "last_cve_date": "2026-09-02T17:03:26.186Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 12,
+        "Medium": 17,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-918": 6,
+        "CWE-79": 4,
+        "CWE-863": 4,
+        "CWE-502": 3,
+        "CWE-862": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-918",
+          6
+        ],
+        [
+          "CWE-79",
+          4
+        ],
+        [
+          "CWE-863",
+          4
+        ],
+        [
+          "CWE-502",
+          3
+        ],
+        [
+          "CWE-862",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Checkmk",
+      "assigner_org_id": "f7d6281c-4801-44ce-ace2-493291dedb0f",
+      "count": 30,
+      "rank": 132,
+      "first_cve_date": "2026-02-09T15:29:16.780Z",
+      "last_cve_date": "2026-09-22T10:43:28.959Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 20,
+        "High": 7,
+        "Critical": 1,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-79": 8,
+        "CWE-862": 4,
+        "CWE-140": 3,
+        "CWE-863": 3,
+        "CWE-522": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          8
+        ],
+        [
+          "CWE-862",
+          4
+        ],
+        [
+          "CWE-140",
+          3
+        ],
+        [
+          "CWE-863",
+          3
+        ],
+        [
+          "CWE-522",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "DSF",
+      "assigner_org_id": "6a34fbeb-21d4-45e7-8e0a-62b95bc12c92",
+      "count": 30,
+      "rank": 133,
+      "first_cve_date": "2026-02-03T14:32:26.240Z",
+      "last_cve_date": "2026-08-04T15:48:40.537Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 11,
+        "High": 9,
+        "Low": 9,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-407": 3,
+        "CWE-524": 3,
+        "CWE-770": 3,
+        "CWE-89": 3,
+        "CWE-862": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-407",
+          3
+        ],
+        [
+          "CWE-524",
+          3
+        ],
+        [
+          "CWE-770",
+          3
+        ],
+        [
+          "CWE-89",
+          3
+        ],
+        [
+          "CWE-862",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "zte",
+      "assigner_org_id": "6786b568-6808-4982-b61f-398b0d9679eb",
+      "count": 30,
+      "rank": 134,
+      "first_cve_date": "2026-01-09T02:24:58.971Z",
+      "last_cve_date": "2026-09-20T09:15:43.868Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 19,
+        "Low": 5,
+        "High": 4,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-269": 6,
+        "CWE-89": 3,
+        "CWE-79": 2,
+        "CWE-798": 2,
+        "CWE-321": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-269",
+          6
+        ],
+        [
+          "CWE-89",
+          3
+        ],
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-798",
+          2
+        ],
+        [
+          "CWE-321",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "GoogleCloud",
+      "assigner_org_id": "f45cbf4e-4146-4068-b7e1-655ffc2c548c",
+      "count": 30,
+      "rank": 135,
+      "first_cve_date": "2026-02-06T21:44:42.763Z",
+      "last_cve_date": "2026-09-15T15:22:29.905Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 15,
+        "High": 13,
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-862": 6,
+        "CWE-918": 3,
+        "CWE-330": 2,
+        "CWE-863": 2,
+        "CWE-79": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-862",
+          6
+        ],
+        [
+          "CWE-918",
+          3
+        ],
+        [
+          "CWE-330",
+          2
+        ],
+        [
+          "CWE-863",
+          2
+        ],
+        [
+          "CWE-79",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Secur0",
+      "assigner_org_id": "4daa8cea-433a-44bd-9456-53b127fc289a",
+      "count": 30,
+      "rank": 136,
+      "first_cve_date": "2026-06-24T10:45:17.553Z",
+      "last_cve_date": "2026-09-14T20:58:39.818Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 18,
+        "High": 10,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-639": 12,
+        "CWE-79": 6,
+        "CWE-306": 2,
+        "CWE-918": 2,
+        "CWE-862": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-639",
+          12
+        ],
+        [
+          "CWE-79",
+          6
+        ],
+        [
+          "CWE-306",
+          2
+        ],
+        [
+          "CWE-918",
+          2
+        ],
+        [
+          "CWE-862",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Ubiquiti",
+      "assigner_org_id": "fe490ce8-0395-4072-90d8-2707e1bdf984",
+      "count": 29,
+      "rank": 137,
+      "first_cve_date": "2026-08-26T08:57:33.271Z",
+      "last_cve_date": "2026-09-22T18:49:39.376Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 22,
+        "High": 7
+      },
+      "top_cwe_types": {
+        "CWE-20": 12,
+        "CWE-284": 7,
+        "CWE-787": 3,
+        "CWE-125": 2,
+        "CWE-93": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          12
+        ],
+        [
+          "CWE-284",
+          7
+        ],
+        [
+          "CWE-787",
+          3
+        ],
+        [
+          "CWE-125",
+          2
+        ],
+        [
+          "CWE-93",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Absolute",
+      "assigner_org_id": "b6533044-ea05-4482-8458-7bddeca0d079",
+      "count": 28,
+      "rank": 138,
+      "first_cve_date": "2026-01-17T01:04:55.634Z",
+      "last_cve_date": "2026-08-13T16:16:22.160Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 14,
+        "High": 6,
+        "Low": 8
+      },
+      "top_cwe_types": {
+        "CWE-400": 7,
+        "CWE-121": 5,
+        "CWE-125": 3,
+        "CWE-119": 2,
+        "CWE-200": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-400",
+          7
+        ],
+        [
+          "CWE-121",
+          5
+        ],
+        [
+          "CWE-125",
+          3
+        ],
+        [
+          "CWE-119",
+          2
+        ],
+        [
+          "CWE-200",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "CERT-In",
+      "assigner_org_id": "66834db9-ab24-42b4-be80-296b2e40335c",
+      "count": 26,
+      "rank": 139,
+      "first_cve_date": "2026-01-09T11:02:50.926Z",
+      "last_cve_date": "2026-09-01T12:44:17.855Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "High": 22,
+        "Medium": 1,
+        "Critical": 3
+      },
+      "top_cwe_types": {
+        "CWE-319": 4,
+        "CWE-639": 4,
+        "CWE-321": 2,
+        "CWE-306": 2,
+        "CWE-307": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-319",
+          4
+        ],
+        [
+          "CWE-639",
+          4
+        ],
+        [
+          "CWE-321",
+          2
+        ],
+        [
+          "CWE-306",
+          2
+        ],
+        [
+          "CWE-307",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "OpenVPN",
+      "assigner_org_id": "36a55730-e66d-4d39-8ca6-3c3b3017965e",
+      "count": 25,
+      "rank": 140,
+      "first_cve_date": "2026-01-30T18:06:07.499Z",
+      "last_cve_date": "2026-09-07T11:03:14.851Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 15,
+        "Low": 4,
+        "Critical": 1,
+        "High": 5
+      },
+      "top_cwe_types": {
+        "CWE-416": 4,
+        "CWE-617": 3,
+        "CWE-125": 3,
+        "CWE-131": 3,
+        "CWE-787": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-416",
+          4
+        ],
+        [
+          "CWE-617",
+          3
+        ],
+        [
+          "CWE-125",
+          3
+        ],
+        [
+          "CWE-131",
+          3
+        ],
+        [
+          "CWE-787",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "rami.io",
+      "assigner_org_id": "655498c3-6ec5-4f0b-aea6-853b334d05a6",
+      "count": 25,
+      "rank": 141,
+      "first_cve_date": "2026-02-16T10:15:09.149Z",
+      "last_cve_date": "2026-08-31T07:44:09.516Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 9,
+        "Low": 8,
+        "High": 7,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-80": 7,
+        "CWE-841": 4,
+        "CWE-639": 3,
+        "CWE-20": 3,
+        "CWE-627": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-80",
+          7
+        ],
+        [
+          "CWE-841",
+          4
+        ],
+        [
+          "CWE-639",
+          3
+        ],
+        [
+          "CWE-20",
+          3
+        ],
+        [
+          "CWE-627",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "ABB",
+      "assigner_org_id": "2b718523-d88f-4f37-9bbd-300c20644bf9",
+      "count": 24,
+      "rank": 142,
+      "first_cve_date": "2026-01-07T16:55:43.036Z",
+      "last_cve_date": "2026-09-23T05:05:16.249Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 5,
+        "High": 15,
+        "Medium": 4
+      },
+      "top_cwe_types": {
+        "CWE-306": 2,
+        "CWE-295": 2,
+        "CWE-770": 2,
+        "CWE-303": 2,
+        "CWE-130": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-306",
+          2
+        ],
+        [
+          "CWE-295",
+          2
+        ],
+        [
+          "CWE-770",
+          2
+        ],
+        [
+          "CWE-303",
+          2
+        ],
+        [
+          "CWE-130",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Deltaww",
+      "assigner_org_id": "759f5e80-c8e1-4224-bead-956d7b33c98b",
+      "count": 24,
+      "rank": 143,
+      "first_cve_date": "2026-01-16T02:03:22.030Z",
+      "last_cve_date": "2026-08-24T09:34:58.858Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 9,
+        "High": 15
+      },
+      "top_cwe_types": {
+        "CWE-89": 4,
+        "CWE-121": 4,
+        "CWE-306": 2,
+        "CWE-321": 1,
+        "CWE-125": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-89",
+          4
+        ],
+        [
+          "CWE-121",
+          4
+        ],
+        [
+          "CWE-306",
+          2
+        ],
+        [
+          "CWE-321",
+          1
+        ],
+        [
+          "CWE-125",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "YokogawaGroup",
+      "assigner_org_id": "7168b535-132a-4efe-a076-338f829b2eb9",
+      "count": 23,
+      "rank": 144,
+      "first_cve_date": "2026-02-09T03:06:00.996Z",
+      "last_cve_date": "2026-06-23T00:53:43.698Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 13,
+        "Low": 5,
+        "High": 5
+      },
+      "top_cwe_types": {
+        "CWE-358": 4,
+        "CWE-617": 3,
+        "CWE-191": 2,
+        "CWE-327": 2,
+        "CWE-319": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-358",
+          4
+        ],
+        [
+          "CWE-617",
+          3
+        ],
+        [
+          "CWE-191",
+          2
+        ],
+        [
+          "CWE-327",
+          2
+        ],
+        [
+          "CWE-319",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Unisoc",
+      "assigner_org_id": "63f92e9c-2193-4c24-98a9-93640392c3d3",
+      "count": 23,
+      "rank": 145,
+      "first_cve_date": "2026-03-09T09:02:21.471Z",
+      "last_cve_date": "2026-08-03T07:18:31.000Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 23
+      },
+      "top_cwe_types": {
+        "CWE-20": 21,
+        "CWE-121": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          21
+        ],
+        [
+          "CWE-121",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Zyxel",
+      "assigner_org_id": "96e50032-ad0d-4058-a115-4d2c13821f9f",
+      "count": 23,
+      "rank": 146,
+      "first_cve_date": "2026-02-05T01:55:12.291Z",
+      "last_cve_date": "2026-08-04T02:28:53.719Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 10,
+        "Critical": 1,
+        "Medium": 12
+      },
+      "top_cwe_types": {
+        "CWE-78": 9,
+        "CWE-476": 4,
+        "CWE-120": 3,
+        "CWE-287": 1,
+        "CWE-922": 1
+      },
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          9
+        ],
+        [
+          "CWE-476",
+          4
+        ],
+        [
+          "CWE-120",
+          3
+        ],
+        [
+          "CWE-287",
+          1
+        ],
+        [
+          "CWE-922",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "OpenText",
+      "assigner_org_id": "f81092c5-7f14-476d-80dc-24857f90be84",
+      "count": 22,
+      "rank": 147,
+      "first_cve_date": "2026-01-30T18:31:31.448Z",
+      "last_cve_date": "2026-09-09T09:14:31.300Z",
+      "years_active": 13,
+      "first_cve_year": 2014,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 9,
+        "High": 11,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-79": 8,
+        "CWE-502": 2,
+        "CWE-312": 1,
+        "CWE-532": 1,
+        "CWE-94": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          8
+        ],
+        [
+          "CWE-502",
+          2
+        ],
+        [
+          "CWE-312",
+          1
+        ],
+        [
+          "CWE-532",
+          1
+        ],
+        [
+          "CWE-94",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "RTI",
+      "assigner_org_id": "3f572a00-62e2-4423-959a-7ea25eff1638",
+      "count": 22,
+      "rank": 148,
+      "first_cve_date": "2026-04-01T00:52:39.353Z",
+      "last_cve_date": "2026-09-22T17:50:23.288Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 9,
+        "Critical": 4,
+        "Medium": 9
+      },
+      "top_cwe_types": {
+        "CWE-125": 5,
+        "CWE-611": 2,
+        "CWE-122": 2,
+        "CWE-685": 2,
+        "CWE-843": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-125",
+          5
+        ],
+        [
+          "CWE-611",
+          2
+        ],
+        [
+          "CWE-122",
+          2
+        ],
+        [
+          "CWE-685",
+          2
+        ],
+        [
+          "CWE-843",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "jci",
+      "assigner_org_id": "7281d04a-a537-43df-bfb4-fa4110af9d01",
+      "count": 22,
+      "rank": 149,
+      "first_cve_date": "2026-01-28T11:24:46.317Z",
+      "last_cve_date": "2026-08-27T14:42:33.253Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1,
+        "High": 12,
+        "Medium": 8,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-94": 3,
+        "CWE-79": 2,
+        "CWE-77": 1,
+        "CWE-121": 1,
+        "CWE-427": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-94",
+          3
+        ],
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-77",
+          1
+        ],
+        [
+          "CWE-121",
+          1
+        ],
+        [
+          "CWE-427",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "glibc",
+      "assigner_org_id": "3ff69d7a-14f2-4f67-a097-88dee7810d18",
+      "count": 22,
+      "rank": 150,
+      "first_cve_date": "2026-01-14T21:01:11.037Z",
+      "last_cve_date": "2026-09-22T16:50:07.239Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 8,
+        "Medium": 11,
+        "Critical": 1,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-908": 3,
+        "CWE-121": 3,
+        "CWE-835": 2,
+        "CWE-787": 2,
+        "CWE-122": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-908",
+          3
+        ],
+        [
+          "CWE-121",
+          3
+        ],
+        [
+          "CWE-835",
+          2
+        ],
+        [
+          "CWE-787",
+          2
+        ],
+        [
+          "CWE-122",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "SICK AG",
+      "assigner_org_id": "a6863dd2-93fc-443d-bef1-79f0b5020988",
+      "count": 22,
+      "rank": 151,
+      "first_cve_date": "2026-01-15T12:59:51.574Z",
+      "last_cve_date": "2026-09-11T08:27:39.772Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 13,
+        "High": 3,
+        "Low": 1,
+        "Critical": 5
+      },
+      "top_cwe_types": {
+        "CWE-266": 4,
+        "CWE-552": 3,
+        "CWE-79": 2,
+        "CWE-327": 2,
+        "CWE-1391": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-266",
+          4
+        ],
+        [
+          "CWE-552",
+          3
+        ],
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-327",
+          2
+        ],
+        [
+          "CWE-1391",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Esri",
+      "assigner_org_id": "cedc17bb-4939-4f40-a1f4-30ae8af1094e",
+      "count": 22,
+      "rank": 152,
+      "first_cve_date": "2026-01-26T17:24:12.411Z",
+      "last_cve_date": "2026-08-21T20:54:13.967Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 14,
+        "Low": 2,
+        "Critical": 5,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-79": 11,
+        "CWE-200": 2,
+        "CWE-640": 2,
+        "CWE-266": 2,
+        "CWE-306": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          11
+        ],
+        [
+          "CWE-200",
+          2
+        ],
+        [
+          "CWE-640",
+          2
+        ],
+        [
+          "CWE-266",
+          2
+        ],
+        [
+          "CWE-306",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Okta",
+      "assigner_org_id": "59b22baa-87b2-4371-8e4a-e080df12f74a",
+      "count": 22,
+      "rank": 153,
+      "first_cve_date": "2026-08-25T20:07:20.216Z",
+      "last_cve_date": "2026-09-08T20:18:48.504Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 5,
+        "Medium": 16,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-94": 3,
+        "CWE-78": 2,
+        "CWE-532": 2,
+        "CWE-306": 1,
+        "CWE-79": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-94",
+          3
+        ],
+        [
+          "CWE-78",
+          2
+        ],
+        [
+          "CWE-532",
+          2
+        ],
+        [
+          "CWE-306",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Altium",
+      "assigner_org_id": "4760f414-e1ae-4ff1-bdad-c7a9c3538b79",
+      "count": 21,
+      "rank": 154,
+      "first_cve_date": "2026-01-15T22:24:16.136Z",
+      "last_cve_date": "2026-09-16T20:06:28.498Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 6,
+        "Medium": 3,
+        "Critical": 12
+      },
+      "top_cwe_types": {
+        "CWE-22": 9,
+        "CWE-79": 6,
+        "CWE-306": 4,
+        "CWE-200": 3,
+        "CWE-918": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-22",
+          9
+        ],
+        [
+          "CWE-79",
+          6
+        ],
+        [
+          "CWE-306",
+          4
+        ],
+        [
+          "CWE-200",
+          3
+        ],
+        [
+          "CWE-918",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "3DS",
+      "assigner_org_id": "f5a594e6-46a7-4e60-8a08-0a786e70e433",
+      "count": 21,
+      "rank": 155,
+      "first_cve_date": "2026-01-26T13:25:04.586Z",
+      "last_cve_date": "2026-09-21T12:07:15.359Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 15,
+        "Critical": 6
+      },
+      "top_cwe_types": {
+        "CWE-79": 4,
+        "CWE-502": 3,
+        "CWE-22": 2,
+        "CWE-787": 2,
+        "CWE-285": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          4
+        ],
+        [
+          "CWE-502",
+          3
+        ],
+        [
+          "CWE-22",
+          2
+        ],
+        [
+          "CWE-787",
+          2
+        ],
+        [
+          "CWE-285",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Gridware",
+      "assigner_org_id": "b7efe717-a805-47cf-8e9a-921fca0ce0ce",
+      "count": 21,
+      "rank": 156,
+      "first_cve_date": "2026-02-05T06:33:02.766Z",
+      "last_cve_date": "2026-03-05T05:12:35.774Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 6,
+        "High": 11,
+        "Medium": 4
+      },
+      "top_cwe_types": {
+        "CWE-798": 6,
+        "CWE-269": 5,
+        "CWE-79": 3,
+        "CWE-732": 2,
+        "CWE-78": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-798",
+          6
+        ],
+        [
+          "CWE-269",
+          5
+        ],
+        [
+          "CWE-79",
+          3
+        ],
+        [
+          "CWE-732",
+          2
+        ],
+        [
+          "CWE-78",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "CyberDanube",
+      "assigner_org_id": "7d092a75-6bbd-48c6-a15a-0297458009bc",
+      "count": 20,
+      "rank": 157,
+      "first_cve_date": "2026-05-28T13:05:40.423Z",
+      "last_cve_date": "2026-08-10T19:38:57.641Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "Critical": 11,
+        "High": 7,
+        "Low": 1,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-798": 4,
+        "CWE-306": 4,
+        "CWE-1191": 2,
+        "CWE-78": 2,
+        "CWE-89": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-798",
+          4
+        ],
+        [
+          "CWE-306",
+          4
+        ],
+        [
+          "CWE-1191",
+          2
+        ],
+        [
+          "CWE-78",
+          2
+        ],
+        [
+          "CWE-89",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "hikvision",
+      "assigner_org_id": "da451dce-859b-4e51-8b87-9c8b60d19b32",
+      "count": 20,
+      "rank": 158,
+      "first_cve_date": "2026-01-13T01:47:27.191Z",
+      "last_cve_date": "2026-09-10T12:47:29.537Z",
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 10,
+        "Medium": 9,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-121": 3,
+        "CWE-78": 3,
+        "CWE-284": 2,
+        "CWE-22": 1,
+        "CWE-233": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-121",
+          3
+        ],
+        [
+          "CWE-78",
+          3
+        ],
+        [
+          "CWE-284",
+          2
+        ],
+        [
+          "CWE-22",
+          1
+        ],
+        [
+          "CWE-233",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "SNOWFLAKE",
+      "assigner_org_id": "412d305a-227d-44f9-a262-a31ba44f2aea",
+      "count": 20,
+      "rank": 159,
+      "first_cve_date": "2026-04-16T18:43:21.181Z",
+      "last_cve_date": "2026-09-17T10:49:59.907Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 10,
+        "Medium": 6,
+        "Low": 1,
+        "Critical": 3
+      },
+      "top_cwe_types": {
+        "CWE-89": 8,
+        "CWE-918": 4,
+        "CWE-441": 2,
+        "CWE-532": 2,
+        "CWE-22": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-89",
+          8
+        ],
+        [
+          "CWE-918",
+          4
+        ],
+        [
+          "CWE-441",
+          2
+        ],
+        [
+          "CWE-532",
+          2
+        ],
+        [
+          "CWE-22",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Zabbix",
+      "assigner_org_id": "72de3e22-0555-4a0d-ae81-9249e0f0a1e8",
+      "count": 20,
+      "rank": 160,
+      "first_cve_date": "2026-03-06T08:24:15.428Z",
+      "last_cve_date": "2026-08-18T12:21:29.618Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 11,
+        "Low": 2,
+        "High": 7
+      },
+      "top_cwe_types": {
+        "CWE-405": 2,
+        "CWE-522": 2,
+        "CWE-79": 2,
+        "CWE-203": 2,
+        "CWE-427": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-405",
+          2
+        ],
+        [
+          "CWE-522",
+          2
+        ],
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-203",
+          2
+        ],
+        [
+          "CWE-427",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "trendmicro",
+      "assigner_org_id": "7f7bd7df-cffe-4fdb-ab6d-859363b89272",
+      "count": 19,
+      "rank": 161,
+      "first_cve_date": "2026-01-08T12:50:25.113Z",
+      "last_cve_date": "2026-05-21T13:04:35.027Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "severity_distribution": {
+        "Critical": 3,
+        "High": 15,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-346": 12,
+        "CWE-120": 3,
+        "CWE-367": 3,
+        "CWE-22": 2,
+        "CWE-290": 1
+      },
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-346",
+          12
+        ],
+        [
+          "CWE-120",
+          3
+        ],
+        [
+          "CWE-367",
+          3
+        ],
+        [
+          "CWE-22",
+          2
+        ],
+        [
+          "CWE-290",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "GEN",
+      "assigner_org_id": "dbd8429d-f261-4b1e-94cc-ae3132817e2e",
+      "count": 19,
+      "rank": 162,
+      "first_cve_date": "2026-06-12T21:59:52.538Z",
+      "last_cve_date": "2026-09-16T14:01:47.369Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 14,
+        "Medium": 5
+      },
+      "top_cwe_types": {
+        "CWE-125": 8,
+        "CWE-787": 3,
+        "CWE-674": 2,
+        "CWE-590": 1,
+        "CWE-121": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-125",
+          8
+        ],
+        [
+          "CWE-787",
+          3
+        ],
+        [
+          "CWE-674",
+          2
+        ],
+        [
+          "CWE-590",
+          1
+        ],
+        [
+          "CWE-121",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "checkpoint",
+      "assigner_org_id": "897c38be-0345-43cd-b6cf-fe179e0c4f45",
+      "count": 19,
+      "rank": 163,
+      "first_cve_date": "2026-01-14T14:30:48.630Z",
+      "last_cve_date": "2026-09-22T12:59:01.057Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 8,
+        "Critical": 8,
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-287": 3,
+        "CWE-122": 3,
+        "CWE-22": 2,
+        "CWE-89": 2,
+        "CWE-295": 2
+      },
+      "kev_count": 5,
+      "epss_high_count": 2,
+      "epss_elevated_count": 3,
+      "top_cwes": [
+        [
+          "CWE-287",
+          3
+        ],
+        [
+          "CWE-122",
+          3
+        ],
+        [
+          "CWE-22",
+          2
+        ],
+        [
+          "CWE-89",
+          2
+        ],
+        [
+          "CWE-295",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "ASRG",
+      "assigner_org_id": "c15abc07-96a9-4d11-a503-5d621bfe42ba",
+      "count": 19,
+      "rank": 164,
+      "first_cve_date": "2026-01-22T15:21:21.945Z",
+      "last_cve_date": "2026-06-25T14:11:18.921Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 12,
+        "High": 4,
+        "Critical": 1,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-121": 4,
+        "CWE-754": 4,
+        "CWE-294": 3,
+        "CWE-1390": 2,
+        "CWE-327": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-121",
+          4
+        ],
+        [
+          "CWE-754",
+          4
+        ],
+        [
+          "CWE-294",
+          3
+        ],
+        [
+          "CWE-1390",
+          2
+        ],
+        [
+          "CWE-327",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Zoom",
+      "assigner_org_id": "99b9af0d-a833-4a5d-9e2f-8b1324f35351",
+      "count": 19,
+      "rank": 165,
+      "first_cve_date": "2026-01-20T13:57:44.803Z",
+      "last_cve_date": "2026-08-11T16:02:28.384Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 3,
+        "High": 14,
+        "Medium": 1,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-20": 4,
+        "CWE-939": 2,
+        "CWE-73": 2,
+        "CWE-78": 1,
+        "CWE-787": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-20",
+          4
+        ],
+        [
+          "CWE-939",
+          2
+        ],
+        [
+          "CWE-73",
+          2
+        ],
+        [
+          "CWE-78",
+          1
+        ],
+        [
+          "CWE-787",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Hitachi",
+      "assigner_org_id": "50d0f415-c707-4733-9afc-8f6c0e9b3f82",
+      "count": 18,
+      "rank": 166,
+      "first_cve_date": "2026-02-25T03:01:21.623Z",
+      "last_cve_date": "2026-09-08T08:15:00.929Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 7,
+        "Medium": 7,
+        "Low": 1,
+        "Critical": 3
+      },
+      "top_cwe_types": {
+        "CWE-78": 2,
+        "CWE-532": 2,
+        "CWE-347": 1,
+        "CWE-770": 1,
+        "CWE-522": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          2
+        ],
+        [
+          "CWE-532",
+          2
+        ],
+        [
+          "CWE-347",
+          1
+        ],
+        [
+          "CWE-770",
+          1
+        ],
+        [
+          "CWE-522",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Docker",
+      "assigner_org_id": "686469e6-3ff6-451b-ab8b-cf5b9e89401e",
+      "count": 18,
+      "rank": 167,
+      "first_cve_date": "2026-02-04T13:57:23.002Z",
+      "last_cve_date": "2026-09-15T20:33:21.074Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 9,
+        "High": 7,
+        "Critical": 1,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-59": 3,
+        "CWE-863": 2,
+        "CWE-829": 2,
+        "CWE-923": 2,
+        "CWE-22": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-59",
+          3
+        ],
+        [
+          "CWE-863",
+          2
+        ],
+        [
+          "CWE-829",
+          2
+        ],
+        [
+          "CWE-923",
+          2
+        ],
+        [
+          "CWE-22",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "ASUSTOR1",
+      "assigner_org_id": "f35eaae9-79f2-4d0d-a5c7-7bea6ed6be77",
+      "count": 18,
+      "rank": 168,
+      "first_cve_date": "2026-02-03T02:19:41.915Z",
+      "last_cve_date": "2026-08-04T07:25:09.087Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 12,
+        "Critical": 3,
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-295": 5,
+        "CWE-134": 4,
+        "CWE-22": 4,
+        "CWE-121": 2,
+        "CWE-20": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-295",
+          5
+        ],
+        [
+          "CWE-134",
+          4
+        ],
+        [
+          "CWE-22",
+          4
+        ],
+        [
+          "CWE-121",
+          2
+        ],
+        [
+          "CWE-20",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "ERIC",
+      "assigner_org_id": "85b1779b-6ecd-4f52-bcc5-73eac4659dcf",
+      "count": 17,
+      "rank": 169,
+      "first_cve_date": "2026-03-25T12:54:46.406Z",
+      "last_cve_date": "2026-08-28T12:57:50.134Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 7,
+        "High": 7,
+        "Low": 2,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-228": 3,
+        "CWE-230": 2,
+        "CWE-790": 1,
+        "CWE-79": 1,
+        "CWE-352": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-228",
+          3
+        ],
+        [
+          "CWE-230",
+          2
+        ],
+        [
+          "CWE-790",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-352",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "NCSC-FI",
+      "assigner_org_id": "db4dfee8-a97e-4877-bfae-eba6d14a2166",
+      "count": 17,
+      "rank": 170,
+      "first_cve_date": "2026-01-13T13:39:02.370Z",
+      "last_cve_date": "2026-09-16T13:38:30.097Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "High": 4,
+        "Medium": 9,
+        "Critical": 4
+      },
+      "top_cwe_types": {
+        "CWE-522": 2,
+        "CWE-613": 2,
+        "CWE-22": 2,
+        "CWE-250": 2,
+        "CWE-79": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-522",
+          2
+        ],
+        [
+          "CWE-613",
+          2
+        ],
+        [
+          "CWE-22",
+          2
+        ],
+        [
+          "CWE-250",
+          2
+        ],
+        [
+          "CWE-79",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "OpenHarmony",
+      "assigner_org_id": "0cf5dd6e-1214-4398-a481-30441e48fafd",
+      "count": 17,
+      "rank": 171,
+      "first_cve_date": "2026-03-16T07:08:53.480Z",
+      "last_cve_date": "2026-05-19T03:08:47.111Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 8,
+        "Low": 6,
+        "High": 3
+      },
+      "top_cwe_types": {
+        "CWE-787": 4,
+        "CWE-20": 3,
+        "CWE-364": 3,
+        "CWE-908": 1,
+        "CWE-843": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          4
+        ],
+        [
+          "CWE-20",
+          3
+        ],
+        [
+          "CWE-364",
+          3
+        ],
+        [
+          "CWE-908",
+          1
+        ],
+        [
+          "CWE-843",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Canon",
+      "assigner_org_id": "f98c90f0-e9bd-4fa7-911b-51993f3571fd",
+      "count": 17,
+      "rank": 172,
+      "first_cve_date": "2026-01-15T23:35:27.096Z",
+      "last_cve_date": "2026-08-02T23:32:44.893Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 7,
+        "High": 6,
+        "Medium": 4
+      },
+      "top_cwe_types": {
+        "CWE-787": 6,
+        "CWE-295": 2,
+        "CWE-59": 2,
+        "CWE-763": 1,
+        "CWE-1188": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          6
+        ],
+        [
+          "CWE-295",
+          2
+        ],
+        [
+          "CWE-59",
+          2
+        ],
+        [
+          "CWE-763",
+          1
+        ],
+        [
+          "CWE-1188",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "HiddenLayer",
+      "assigner_org_id": "6f8de1f0-f67e-45a6-b68f-98777fdb759c",
+      "count": 17,
+      "rank": 173,
+      "first_cve_date": "2026-02-26T14:56:39.524Z",
+      "last_cve_date": "2026-09-11T14:35:34.416Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 3,
+        "High": 6,
+        "Critical": 8
+      },
+      "top_cwe_types": {
+        "CWE-79": 3,
+        "CWE-639": 3,
+        "CWE-22": 2,
+        "CWE-502": 2,
+        "CWE-94": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-79",
+          3
+        ],
+        [
+          "CWE-639",
+          3
+        ],
+        [
+          "CWE-22",
+          2
+        ],
+        [
+          "CWE-502",
+          2
+        ],
+        [
+          "CWE-94",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Kong",
+      "assigner_org_id": "02762ae7-200e-4b20-9b2b-a77d5b8fc4cb",
+      "count": 16,
+      "rank": 174,
+      "first_cve_date": "2026-06-11T13:47:01.309Z",
+      "last_cve_date": "2026-09-16T10:14:34.372Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 7,
+        "Low": 1,
+        "Medium": 7,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-400": 2,
+        "CWE-862": 2,
+        "CWE-20": 2,
+        "CWE-295": 2,
+        "CWE-323": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-400",
+          2
+        ],
+        [
+          "CWE-862",
+          2
+        ],
+        [
+          "CWE-20",
+          2
+        ],
+        [
+          "CWE-295",
+          2
+        ],
+        [
+          "CWE-323",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "brocade",
+      "assigner_org_id": "87b297d7-335e-4844-9551-11b97995a791",
+      "count": 15,
+      "rank": 175,
+      "first_cve_date": "2026-02-02T20:50:29.756Z",
+      "last_cve_date": "2026-09-23T20:45:24.825Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 10,
+        "Medium": 5
+      },
+      "top_cwe_types": {
+        "CWE-312": 4,
+        "CWE-305": 2,
+        "CWE-250": 2,
+        "CWE-35": 2,
+        "CWE-78": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-312",
+          4
+        ],
+        [
+          "CWE-305",
+          2
+        ],
+        [
+          "CWE-250",
+          2
+        ],
+        [
+          "CWE-35",
+          2
+        ],
+        [
+          "CWE-78",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Axis",
+      "assigner_org_id": "f2daf9a0-02c2-4b83-a01d-63b3b304b807",
+      "count": 15,
+      "rank": 176,
+      "first_cve_date": "2026-02-10T05:32:19.555Z",
+      "last_cve_date": "2026-08-11T05:52:33.481Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 12,
+        "High": 3
+      },
+      "top_cwe_types": {
+        "CWE-732": 3,
+        "CWE-367": 2,
+        "CWE-1287": 2,
+        "CWE-248": 1,
+        "CWE-532": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-732",
+          3
+        ],
+        [
+          "CWE-367",
+          2
+        ],
+        [
+          "CWE-1287",
+          2
+        ],
+        [
+          "CWE-248",
+          1
+        ],
+        [
+          "CWE-532",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Commvault",
+      "assigner_org_id": "050066fd-a2f9-4f32-ab5d-4c53f48bc333",
+      "count": 15,
+      "rank": 177,
+      "first_cve_date": "2026-01-07T22:03:05.033Z",
+      "last_cve_date": "2026-09-08T12:12:55.097Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 1,
+        "Critical": 3,
+        "High": 11
+      },
+      "top_cwe_types": {
+        "CWE-863": 2,
+        "CWE-22": 2,
+        "CWE-79": 1,
+        "CWE-918": 1,
+        "CWE-89": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-863",
+          2
+        ],
+        [
+          "CWE-22",
+          2
+        ],
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-918",
+          1
+        ],
+        [
+          "CWE-89",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "TV",
+      "assigner_org_id": "13430f76-86eb-43b2-a71c-82c956ef31b6",
+      "count": 15,
+      "rank": 178,
+      "first_cve_date": "2026-01-29T08:39:56.105Z",
+      "last_cve_date": "2026-08-26T09:16:13.127Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 4,
+        "Medium": 11
+      },
+      "top_cwe_types": {
+        "CWE-20": 4,
+        "CWE-125": 2,
+        "CWE-73": 1,
+        "CWE-78": 1,
+        "CWE-862": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          4
+        ],
+        [
+          "CWE-125",
+          2
+        ],
+        [
+          "CWE-73",
+          1
+        ],
+        [
+          "CWE-78",
+          1
+        ],
+        [
+          "CWE-862",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Document Fdn.",
+      "assigner_org_id": "4fe7d05b-1353-44cc-8b7a-1e416936dff2",
+      "count": 15,
+      "rank": 179,
+      "first_cve_date": "2026-05-07T07:16:18.851Z",
+      "last_cve_date": "2026-09-22T11:10:41.707Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 13,
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-787": 13,
+        "CWE-125": 3,
+        "CWE-843": 2,
+        "CWE-200": 1,
+        "CWE-121": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          13
+        ],
+        [
+          "CWE-125",
+          3
+        ],
+        [
+          "CWE-843",
+          2
+        ],
+        [
+          "CWE-200",
+          1
+        ],
+        [
+          "CWE-121",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Nokia",
+      "assigner_org_id": "b48c3b8f-639e-4c16-8725-497bc411dad0",
+      "count": 14,
+      "rank": 180,
+      "first_cve_date": "2026-01-07T07:24:46.149Z",
+      "last_cve_date": "2026-08-31T06:37:19.360Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 6,
+        "Medium": 8
+      },
+      "top_cwe_types": {
+        "CWE-284": 3,
+        "CWE-78": 2,
+        "CWE-269": 2,
+        "CWE-434": 1,
+        "CWE-23": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-284",
+          3
+        ],
+        [
+          "CWE-78",
+          2
+        ],
+        [
+          "CWE-269",
+          2
+        ],
+        [
+          "CWE-434",
+          1
+        ],
+        [
+          "CWE-23",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "php",
+      "assigner_org_id": "dd77f84a-d19a-4638-8c3d-a322d820ed2b",
+      "count": 14,
+      "rank": 181,
+      "first_cve_date": "2026-05-10T03:27:00.607Z",
+      "last_cve_date": "2026-07-30T11:22:53.918Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 8,
+        "Low": 1,
+        "Medium": 4,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-125": 3,
+        "CWE-89": 2,
+        "CWE-476": 2,
+        "CWE-416": 2,
+        "CWE-787": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-125",
+          3
+        ],
+        [
+          "CWE-89",
+          2
+        ],
+        [
+          "CWE-476",
+          2
+        ],
+        [
+          "CWE-416",
+          2
+        ],
+        [
+          "CWE-787",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Pega",
+      "assigner_org_id": "c91e5604-2bd1-401f-a0ec-b25342b57ef9",
+      "count": 14,
+      "rank": 182,
+      "first_cve_date": "2026-01-13T16:37:06.709Z",
+      "last_cve_date": "2026-08-28T13:11:34.206Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 9,
+        "High": 4,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-79": 6,
+        "CWE-284": 3,
+        "CWE-639": 1,
+        "CWE-434": 1,
+        "CWE-606": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          6
+        ],
+        [
+          "CWE-284",
+          3
+        ],
+        [
+          "CWE-639",
+          1
+        ],
+        [
+          "CWE-434",
+          1
+        ],
+        [
+          "CWE-606",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "PRJBLK",
+      "assigner_org_id": "ab69c47f-b95e-4bf2-b2d9-4b1fd1b24b4a",
+      "count": 14,
+      "rank": 183,
+      "first_cve_date": "2026-02-18T22:59:55.491Z",
+      "last_cve_date": "2026-08-26T02:11:01.673Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 5,
+        "Critical": 1,
+        "High": 7,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-89": 3,
+        "CWE-287": 3,
+        "CWE-78": 3,
+        "CWE-98": 2,
+        "CWE-23": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-89",
+          3
+        ],
+        [
+          "CWE-287",
+          3
+        ],
+        [
+          "CWE-78",
+          3
+        ],
+        [
+          "CWE-98",
+          2
+        ],
+        [
+          "CWE-23",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "bosch",
+      "assigner_org_id": "c95f66b2-7e7c-41c5-8f09-6f86ec68659c",
+      "count": 13,
+      "rank": 184,
+      "first_cve_date": "2026-02-18T14:01:59.030Z",
+      "last_cve_date": "2026-09-10T09:05:36.803Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 11,
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-502": 4,
+        "CWE-121": 2,
+        "CWE-400": 1,
+        "CWE-284": 1,
+        "CWE-312": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-502",
+          4
+        ],
+        [
+          "CWE-121",
+          2
+        ],
+        [
+          "CWE-400",
+          1
+        ],
+        [
+          "CWE-284",
+          1
+        ],
+        [
+          "CWE-312",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Arm",
+      "assigner_org_id": "56a131ea-b967-4a0d-a41e-5f3549952846",
+      "count": 13,
+      "rank": 185,
+      "first_cve_date": "2026-01-14T10:58:44.342Z",
+      "last_cve_date": "2026-09-08T14:22:15.418Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 7,
+        "Critical": 1,
+        "Medium": 4,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-416": 8,
+        "CWE-362": 3,
+        "CWE-226": 1,
+        "CWE-266": 1,
+        "CWE-200": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-416",
+          8
+        ],
+        [
+          "CWE-362",
+          3
+        ],
+        [
+          "CWE-226",
+          1
+        ],
+        [
+          "CWE-266",
+          1
+        ],
+        [
+          "CWE-200",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Mitsubishi",
+      "assigner_org_id": "e0f77b61-78fd-4786-b3fb-1ee347a748ad",
+      "count": 13,
+      "rank": 186,
+      "first_cve_date": "2026-02-05T03:07:55.753Z",
+      "last_cve_date": "2026-09-17T08:15:27.769Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 9,
+        "Critical": 3,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-404": 2,
+        "CWE-276": 1,
+        "CWE-312": 1,
+        "CWE-317": 1,
+        "CWE-1285": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-404",
+          2
+        ],
+        [
+          "CWE-276",
+          1
+        ],
+        [
+          "CWE-312",
+          1
+        ],
+        [
+          "CWE-317",
+          1
+        ],
+        [
+          "CWE-1285",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "HeroDevs",
+      "assigner_org_id": "36c7be3b-2937-45df-85ea-ca7133ea542c",
+      "count": 13,
+      "rank": 187,
+      "first_cve_date": "2026-01-08T21:05:14.800Z",
+      "last_cve_date": "2026-09-23T02:21:48.323Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 5,
+        "High": 8
+      },
+      "top_cwe_types": {
+        "CWE-400": 5,
+        "CWE-770": 3,
+        "CWE-1333": 2,
+        "CWE-1240": 1,
+        "CWE-502": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-400",
+          5
+        ],
+        [
+          "CWE-770",
+          3
+        ],
+        [
+          "CWE-1333",
+          2
+        ],
+        [
+          "CWE-1240",
+          1
+        ],
+        [
+          "CWE-502",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "TQtC",
+      "assigner_org_id": "a59d8014-47c4-4630-ab43-e1b13cbe58e3",
+      "count": 13,
+      "rank": 188,
+      "first_cve_date": "2026-04-30T12:39:40.067Z",
+      "last_cve_date": "2026-09-23T11:39:03.788Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 4,
+        "High": 5,
+        "Medium": 4
+      },
+      "top_cwe_types": {
+        "CWE-125": 4,
+        "CWE-674": 3,
+        "CWE-427": 1,
+        "CWE-20": 1,
+        "CWE-94": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-125",
+          4
+        ],
+        [
+          "CWE-674",
+          3
+        ],
+        [
+          "CWE-427",
+          1
+        ],
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-94",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "cloudflare",
+      "assigner_org_id": "a22f1246-ba21-4bb4-a601-ad51614c1513",
+      "count": 13,
+      "rank": 189,
+      "first_cve_date": "2026-01-20T22:58:05.212Z",
+      "last_cve_date": "2026-08-12T11:31:15.102Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 7,
+        "Medium": 3,
+        "Critical": 2,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-444": 2,
+        "CWE-706": 1,
+        "CWE-918": 1,
+        "CWE-1104": 1,
+        "CWE-78": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-444",
+          2
+        ],
+        [
+          "CWE-706",
+          1
+        ],
+        [
+          "CWE-918",
+          1
+        ],
+        [
+          "CWE-1104",
+          1
+        ],
+        [
+          "CWE-78",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "redhat-cnalr",
+      "assigner_org_id": "74b3a70d-cca6-4d34-9789-e83b222ae3be",
+      "count": 13,
+      "rank": 190,
+      "first_cve_date": "2026-01-29T13:38:35.932Z",
+      "last_cve_date": "2026-09-18T19:01:34.027Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 5,
+        "Medium": 2,
+        "High": 6
+      },
+      "top_cwe_types": {
+        "CWE-79": 2,
+        "CWE-125": 2,
+        "CWE-306": 2,
+        "CWE-352": 1,
+        "CWE-787": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-125",
+          2
+        ],
+        [
+          "CWE-306",
+          2
+        ],
+        [
+          "CWE-352",
+          1
+        ],
+        [
+          "CWE-787",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "PandoraFMS",
+      "assigner_org_id": "63375d6c-d89a-45ed-8ecc-c8c361b0e04c",
+      "count": 13,
+      "rank": 191,
+      "first_cve_date": "2026-04-13T15:44:46.120Z",
+      "last_cve_date": "2026-05-12T15:13:28.487Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 11,
+        "Critical": 1,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-89": 3,
+        "CWE-78": 3,
+        "CWE-352": 1,
+        "CWE-384": 1,
+        "CWE-276": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-89",
+          3
+        ],
+        [
+          "CWE-78",
+          3
+        ],
+        [
+          "CWE-352",
+          1
+        ],
+        [
+          "CWE-384",
+          1
+        ],
+        [
+          "CWE-276",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Insyde",
+      "assigner_org_id": "8338d8cb-57f7-4252-abc0-96fd13e98d21",
+      "count": 12,
+      "rank": 192,
+      "first_cve_date": "2026-01-14T01:13:33.407Z",
+      "last_cve_date": "2026-09-09T03:59:11.348Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 3,
+        "High": 8,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-787": 5,
+        "CWE-732": 1,
+        "CWE-120": 1,
+        "CWE-256": 1,
+        "CWE-522": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          5
+        ],
+        [
+          "CWE-732",
+          1
+        ],
+        [
+          "CWE-120",
+          1
+        ],
+        [
+          "CWE-256",
+          1
+        ],
+        [
+          "CWE-522",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "INCD",
+      "assigner_org_id": "a57ee1ae-c9c1-4f40-aa7b-cf10760fde3f",
+      "count": 12,
+      "rank": 193,
+      "first_cve_date": "2026-01-01T18:30:45.844Z",
+      "last_cve_date": "2026-08-13T09:44:23.924Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 4,
+        "Critical": 5,
+        "Medium": 2,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-200": 2,
+        "CWE-284": 2,
+        "CWE-89": 1,
+        "CWE-203": 1,
+        "CWE-602": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-200",
+          2
+        ],
+        [
+          "CWE-284",
+          2
+        ],
+        [
+          "CWE-89",
+          1
+        ],
+        [
+          "CWE-203",
+          1
+        ],
+        [
+          "CWE-602",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "SRA",
+      "assigner_org_id": "57dba5dd-1a03-47f6-8b36-e84e47d335d8",
+      "count": 12,
+      "rank": 194,
+      "first_cve_date": "2026-01-20T21:36:00.681Z",
+      "last_cve_date": "2026-07-28T20:03:11.667Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 8,
+        "Medium": 1,
+        "Critical": 3
+      },
+      "top_cwe_types": {
+        "CWE-522": 2,
+        "CWE-89": 2,
+        "CWE-79": 2,
+        "CWE-923": 1,
+        "CWE-1392": 1
+      },
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-522",
+          2
+        ],
+        [
+          "CWE-89",
+          2
+        ],
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-923",
+          1
+        ],
+        [
+          "CWE-1392",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Hitachi Energy",
+      "assigner_org_id": "e383dce4-0c27-4495-91c4-0db157728d17",
+      "count": 12,
+      "rank": 195,
+      "first_cve_date": "2026-01-28T09:02:21.430Z",
+      "last_cve_date": "2026-09-03T07:59:47.162Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Government"
+      ],
+      "severity_distribution": {
+        "High": 7,
+        "Medium": 5
+      },
+      "top_cwe_types": {
+        "CWE-303": 2,
+        "CWE-476": 2,
+        "CWE-267": 2,
+        "CWE-1392": 1,
+        "CWE-1236": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-303",
+          2
+        ],
+        [
+          "CWE-476",
+          2
+        ],
+        [
+          "CWE-267",
+          2
+        ],
+        [
+          "CWE-1392",
+          1
+        ],
+        [
+          "CWE-1236",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Temporal",
+      "assigner_org_id": "61241ed8-fa44-4f23-92db-b8c443751968",
+      "count": 12,
+      "rank": 196,
+      "first_cve_date": "2026-04-01T17:49:15.464Z",
+      "last_cve_date": "2026-09-23T18:58:46.233Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 8,
+        "Critical": 1,
+        "Low": 2,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-129": 3,
+        "CWE-606": 1,
+        "CWE-296": 1,
+        "CWE-807": 1,
+        "CWE-639": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-129",
+          3
+        ],
+        [
+          "CWE-606",
+          1
+        ],
+        [
+          "CWE-296",
+          1
+        ],
+        [
+          "CWE-807",
+          1
+        ],
+        [
+          "CWE-639",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "atlassian",
+      "assigner_org_id": "f08a6ab8-ed46-4c22-8884-d911ccfe3c66",
+      "count": 12,
+      "rank": 197,
+      "first_cve_date": "2026-01-28T00:30:00.557Z",
+      "last_cve_date": "2026-09-15T17:00:00.390Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 11,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-285": 3,
+        "CWE-400": 2,
+        "CWE-94": 2,
+        "CWE-611": 1,
+        "CWE-79": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-285",
+          3
+        ],
+        [
+          "CWE-400",
+          2
+        ],
+        [
+          "CWE-94",
+          2
+        ],
+        [
+          "CWE-611",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Zscaler",
+      "assigner_org_id": "73c6f63b-efac-410d-a0a9-569700f85a04",
+      "count": 12,
+      "rank": 198,
+      "first_cve_date": "2026-02-23T16:12:52.917Z",
+      "last_cve_date": "2026-09-18T14:01:10.683Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 7,
+        "Medium": 3,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-20": 6,
+        "CWE-229": 2,
+        "CWE-1289": 1,
+        "CWE-280": 1,
+        "CWE-304": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          6
+        ],
+        [
+          "CWE-229",
+          2
+        ],
+        [
+          "CWE-1289",
+          1
+        ],
+        [
+          "CWE-280",
+          1
+        ],
+        [
+          "CWE-304",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Microchip",
+      "assigner_org_id": "dc3f6da9-85b5-4a73-84a2-2ec90b40fca5",
+      "count": 11,
+      "rank": 199,
+      "first_cve_date": "2026-02-24T15:34:20.905Z",
+      "last_cve_date": "2026-09-12T09:26:05.932Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 6,
+        "Critical": 3,
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-79": 3,
+        "CWE-494": 1,
+        "CWE-798": 1,
+        "CWE-1247": 1,
+        "CWE-200": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          3
+        ],
+        [
+          "CWE-494",
+          1
+        ],
+        [
+          "CWE-798",
+          1
+        ],
+        [
+          "CWE-1247",
+          1
+        ],
+        [
+          "CWE-200",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "ca",
+      "assigner_org_id": "e291eae9-7c0a-46ac-ba7d-5251811f8b7f",
+      "count": 11,
+      "rank": 200,
+      "first_cve_date": "2026-01-12T03:53:00.624Z",
+      "last_cve_date": "2026-05-19T18:42:00.155Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 4,
+        "High": 5,
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-502": 1,
+        "CWE-522": 1,
+        "CWE-22": 1,
+        "CWE-78": 1,
+        "CWE-598": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-502",
+          1
+        ],
+        [
+          "CWE-522",
+          1
+        ],
+        [
+          "CWE-22",
+          1
+        ],
+        [
+          "CWE-78",
+          1
+        ],
+        [
+          "CWE-598",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Mandiant",
+      "assigner_org_id": "027e81ed-0dd4-4685-ab4d-884aec5bb484",
+      "count": 11,
+      "rank": 201,
+      "first_cve_date": "2026-01-28T17:09:49.715Z",
+      "last_cve_date": "2026-08-18T18:25:51.499Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3,
+        "Medium": 2,
+        "Critical": 6
+      },
+      "top_cwe_types": {
+        "CWE-434": 2,
+        "CWE-89": 2,
+        "CWE-347": 1,
+        "CWE-79": 1,
+        "CWE-257": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-434",
+          2
+        ],
+        [
+          "CWE-89",
+          2
+        ],
+        [
+          "CWE-347",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-257",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Centreon",
+      "assigner_org_id": "bd4443e6-1eef-43f3-9886-25fc9ceeaae7",
+      "count": 11,
+      "rank": 202,
+      "first_cve_date": "2026-01-05T10:06:05.494Z",
+      "last_cve_date": "2026-07-13T08:19:13.094Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 4,
+        "High": 2,
+        "Critical": 5
+      },
+      "top_cwe_types": {
+        "CWE-79": 3,
+        "CWE-89": 2,
+        "CWE-78": 1,
+        "CWE-862": 1,
+        "CWE-306": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-79",
+          3
+        ],
+        [
+          "CWE-89",
+          2
+        ],
+        [
+          "CWE-78",
+          1
+        ],
+        [
+          "CWE-862",
+          1
+        ],
+        [
+          "CWE-306",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Fortra",
+      "assigner_org_id": "df4dee71-de3a-4139-9588-11b62fe6c0ff",
+      "count": 11,
+      "rank": 203,
+      "first_cve_date": "2026-02-25T18:57:02.962Z",
+      "last_cve_date": "2026-09-09T21:18:54.261Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3,
+        "Medium": 7,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-78": 2,
+        "CWE-74": 2,
+        "CWE-307": 1,
+        "CWE-326": 1,
+        "CWE-613": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          2
+        ],
+        [
+          "CWE-74",
+          2
+        ],
+        [
+          "CWE-307",
+          1
+        ],
+        [
+          "CWE-326",
+          1
+        ],
+        [
+          "CWE-613",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "MHV",
+      "assigner_org_id": "56a186b1-7f5e-4314-ba38-38d5499fccfd",
+      "count": 11,
+      "rank": 204,
+      "first_cve_date": "2026-01-14T14:34:14.034Z",
+      "last_cve_date": "2026-03-06T15:05:20.800Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 7,
+        "High": 3,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-306": 4,
+        "CWE-287": 3,
+        "CWE-200": 2,
+        "CWE-312": 1,
+        "CWE-522": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-306",
+          4
+        ],
+        [
+          "CWE-287",
+          3
+        ],
+        [
+          "CWE-200",
+          2
+        ],
+        [
+          "CWE-312",
+          1
+        ],
+        [
+          "CWE-522",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Moxa",
+      "assigner_org_id": "2e0a0ee2-d866-482a-9f5e-ac03d156dbaa",
+      "count": 11,
+      "rank": 205,
+      "first_cve_date": "2026-02-05T16:58:50.181Z",
+      "last_cve_date": "2026-09-18T09:32:59.993Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 8,
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-325": 1,
+        "CWE-130": 1,
+        "CWE-282": 1,
+        "CWE-522": 1,
+        "CWE-319": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-325",
+          1
+        ],
+        [
+          "CWE-130",
+          1
+        ],
+        [
+          "CWE-282",
+          1
+        ],
+        [
+          "CWE-522",
+          1
+        ],
+        [
+          "CWE-319",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "VULSec",
+      "assigner_org_id": "2fdefc65-d750-4b8d-96ee-6e2c0c42dbfe",
+      "count": 11,
+      "rank": 206,
+      "first_cve_date": "2026-03-05T14:14:11.125Z",
+      "last_cve_date": "2026-03-05T16:04:36.443Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 6,
+        "Critical": 2,
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-327": 2,
+        "CWE-684": 2,
+        "CWE-345": 2,
+        "CWE-916": 2,
+        "CWE-749": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-327",
+          2
+        ],
+        [
+          "CWE-684",
+          2
+        ],
+        [
+          "CWE-345",
+          2
+        ],
+        [
+          "CWE-916",
+          2
+        ],
+        [
+          "CWE-749",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "sba-research",
+      "assigner_org_id": "1e3a9e0f-5156-4bf8-b8a3-cc311bfc0f4a",
+      "count": 10,
+      "rank": 207,
+      "first_cve_date": "2026-03-04T22:43:53.077Z",
+      "last_cve_date": "2026-07-30T09:45:24.228Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Academic"
+      ],
+      "severity_distribution": {
+        "Medium": 5,
+        "High": 5
+      },
+      "top_cwe_types": {
+        "CWE-79": 3,
+        "CWE-770": 2,
+        "CWE-20": 1,
+        "CWE-284": 1,
+        "CWE-367": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          3
+        ],
+        [
+          "CWE-770",
+          2
+        ],
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-284",
+          1
+        ],
+        [
+          "CWE-367",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Eaton",
+      "assigner_org_id": "63703b7d-23e2-41ef-94b3-a3c6333f7759",
+      "count": 10,
+      "rank": 208,
+      "first_cve_date": "2026-02-09T05:39:22.834Z",
+      "last_cve_date": "2026-07-30T10:21:17.647Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 4,
+        "Medium": 6
+      },
+      "top_cwe_types": {
+        "CWE-78": 2,
+        "CWE-427": 1,
+        "CWE-358": 1,
+        "CWE-295": 1,
+        "CWE-307": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          2
+        ],
+        [
+          "CWE-427",
+          1
+        ],
+        [
+          "CWE-358",
+          1
+        ],
+        [
+          "CWE-295",
+          1
+        ],
+        [
+          "CWE-307",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "DIVD",
+      "assigner_org_id": "b87402ff-ae37-4194-9dae-31abdbd6f217",
+      "count": 10,
+      "rank": 209,
+      "first_cve_date": "2026-07-13T09:10:56.109Z",
+      "last_cve_date": "2026-07-17T09:30:36.710Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3,
+        "Critical": 7
+      },
+      "top_cwe_types": {
+        "CWE-77": 2,
+        "CWE-639": 1,
+        "CWE-306": 1,
+        "CWE-20": 1,
+        "CWE-295": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-77",
+          2
+        ],
+        [
+          "CWE-639",
+          1
+        ],
+        [
+          "CWE-306",
+          1
+        ],
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-295",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "HDFG",
+      "assigner_org_id": "0253b833-3e77-4dfe-9d57-17db1a2f0a74",
+      "count": 10,
+      "rank": 210,
+      "first_cve_date": "2026-07-27T15:11:36.949Z",
+      "last_cve_date": "2026-09-16T15:16:54.160Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 9,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-476": 3,
+        "CWE-125": 3,
+        "CWE-1284": 2,
+        "CWE-416": 1,
+        "CWE-617": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-476",
+          3
+        ],
+        [
+          "CWE-125",
+          3
+        ],
+        [
+          "CWE-1284",
+          2
+        ],
+        [
+          "CWE-416",
+          1
+        ],
+        [
+          "CWE-617",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Octopus",
+      "assigner_org_id": "6f4f8c89-ef06-4bae-a2a5-6734ddf76272",
+      "count": 10,
+      "rank": 211,
+      "first_cve_date": "2026-02-25T12:22:18.328Z",
+      "last_cve_date": "2026-09-16T07:29:27.076Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 4,
+        "Low": 2,
+        "Medium": 4
+      },
+      "top_cwe_types": {
+        "CWE-22": 2,
+        "CWE-863": 2,
+        "CWE-285": 1,
+        "CWE-79": 1,
+        "CWE-284": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-22",
+          2
+        ],
+        [
+          "CWE-863",
+          2
+        ],
+        [
+          "CWE-285",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-284",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "PaperCut",
+      "assigner_org_id": "eb41dac7-0af8-4f84-9f6d-0272772514f4",
+      "count": 10,
+      "rank": 212,
+      "first_cve_date": "2026-03-31T00:39:56.135Z",
+      "last_cve_date": "2026-08-28T11:45:25.388Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1,
+        "Low": 2,
+        "Medium": 5,
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-470": 1,
+        "CWE-319": 1,
+        "CWE-307": 1,
+        "CWE-208": 1,
+        "CWE-532": 1
+      },
+      "kev_count": 2,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-470",
+          1
+        ],
+        [
+          "CWE-319",
+          1
+        ],
+        [
+          "CWE-307",
+          1
+        ],
+        [
+          "CWE-208",
+          1
+        ],
+        [
+          "CWE-532",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "NetScaler",
+      "assigner_org_id": "50a63c94-1ea7-4568-8c11-eb79e7c5a2b5",
+      "count": 10,
+      "rank": 213,
+      "first_cve_date": "2026-03-23T20:09:44.971Z",
+      "last_cve_date": "2026-08-19T12:54:39.730Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 7,
+        "Critical": 2,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-125": 3,
+        "CWE-119": 2,
+        "CWE-401": 1,
+        "CWE-120": 1,
+        "CWE-288": 1
+      },
+      "kev_count": 3,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-125",
+          3
+        ],
+        [
+          "CWE-119",
+          2
+        ],
+        [
+          "CWE-401",
+          1
+        ],
+        [
+          "CWE-120",
+          1
+        ],
+        [
+          "CWE-288",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Kaspersky",
+      "assigner_org_id": "e45d732a-8f6b-4b6b-be76-7420f6a2b988",
+      "count": 9,
+      "rank": 214,
+      "first_cve_date": "2026-05-15T07:30:29.287Z",
+      "last_cve_date": "2026-08-20T18:03:38.982Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3,
+        "Medium": 1,
+        "Critical": 5
+      },
+      "top_cwe_types": {
+        "CWE-367": 1,
+        "CWE-676": 1,
+        "CWE-340": 1,
+        "CWE-377": 1,
+        "CWE-305": 1
+      },
+      "kev_count": 3,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-367",
+          1
+        ],
+        [
+          "CWE-676",
+          1
+        ],
+        [
+          "CWE-340",
+          1
+        ],
+        [
+          "CWE-377",
+          1
+        ],
+        [
+          "CWE-305",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "symantec",
+      "assigner_org_id": "80d3bcb6-88de-48c2-a47e-aebf795f19b5",
+      "count": 9,
+      "rank": 215,
+      "first_cve_date": "2026-01-28T16:29:59.092Z",
+      "last_cve_date": "2026-07-17T06:57:17.699Z",
+      "years_active": 14,
+      "first_cve_year": 2013,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 7,
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-269": 4,
+        "CWE-427": 1,
+        "CWE-829": 1,
+        "CWE-79": 1,
+        "CWE-502": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-269",
+          4
+        ],
+        [
+          "CWE-427",
+          1
+        ],
+        [
+          "CWE-829",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-502",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "airbus",
+      "assigner_org_id": "24a3c815-5f22-4d74-967a-30958d6466f4",
+      "count": 9,
+      "rank": 216,
+      "first_cve_date": "2026-04-03T07:30:10.711Z",
+      "last_cve_date": "2026-09-16T12:10:36.202Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3,
+        "Medium": 5,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-79": 2,
+        "CWE-276": 1,
+        "CWE-532": 1,
+        "CWE-295": 1,
+        "CWE-502": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-276",
+          1
+        ],
+        [
+          "CWE-532",
+          1
+        ],
+        [
+          "CWE-295",
+          1
+        ],
+        [
+          "CWE-502",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Neo4j",
+      "assigner_org_id": "3b236295-4ccd-4a1f-a1c1-a72eecc8d7b6",
+      "count": 9,
+      "rank": 217,
+      "first_cve_date": "2026-01-22T13:29:11.655Z",
+      "last_cve_date": "2026-08-18T16:35:19.878Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 5,
+        "High": 2,
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-863": 3,
+        "CWE-200": 1,
+        "CWE-639": 1,
+        "CWE-302": 1,
+        "CWE-130": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-863",
+          3
+        ],
+        [
+          "CWE-200",
+          1
+        ],
+        [
+          "CWE-639",
+          1
+        ],
+        [
+          "CWE-302",
+          1
+        ],
+        [
+          "CWE-130",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "kubernetes",
+      "assigner_org_id": "a6081bf6-c852-4425-ad4f-a67919267565",
+      "count": 9,
+      "rank": 218,
+      "first_cve_date": "2026-02-03T22:16:47.223Z",
+      "last_cve_date": "2026-07-23T18:43:25.357Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 5,
+        "Medium": 2,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-20": 5,
+        "CWE-22": 2,
+        "CWE-770": 1,
+        "CWE-754": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          5
+        ],
+        [
+          "CWE-22",
+          2
+        ],
+        [
+          "CWE-770",
+          1
+        ],
+        [
+          "CWE-754",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "NEC",
+      "assigner_org_id": "f2760a35-e0d8-4637-ac4c-cc1a2de3e282",
+      "count": 9,
+      "rank": 219,
+      "first_cve_date": "2026-03-27T11:46:26.310Z",
+      "last_cve_date": "2026-09-07T00:48:01.015Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1,
+        "High": 4,
+        "Medium": 4
+      },
+      "top_cwe_types": {
+        "CWE-78": 3,
+        "CWE-306": 1,
+        "CWE-782": 1,
+        "CWE-79": 1,
+        "CWE-912": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          3
+        ],
+        [
+          "CWE-306",
+          1
+        ],
+        [
+          "CWE-782",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-912",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "OTRS",
+      "assigner_org_id": "2e1bf29f-dc29-4ed8-830c-7b9348b6f0e8",
+      "count": 9,
+      "rank": 220,
+      "first_cve_date": "2026-04-20T18:20:01.664Z",
+      "last_cve_date": "2026-06-01T03:33:23.990Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 5,
+        "Low": 2,
+        "Critical": 1,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-400": 3,
+        "CWE-770": 2,
+        "CWE-276": 2,
+        "CWE-200": 2,
+        "CWE-20": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-400",
+          3
+        ],
+        [
+          "CWE-770",
+          2
+        ],
+        [
+          "CWE-276",
+          2
+        ],
+        [
+          "CWE-200",
+          2
+        ],
+        [
+          "CWE-20",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "S21sec",
+      "assigner_org_id": "50b5080a-775f-442e-83b5-926b5ca517b6",
+      "count": 9,
+      "rank": 221,
+      "first_cve_date": "2026-01-07T14:16:32.682Z",
+      "last_cve_date": "2026-01-07T17:12:01.065Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 2,
+        "High": 4,
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-400": 3,
+        "CWE-319": 1,
+        "CWE-497": 1,
+        "CWE-261": 1,
+        "CWE-201": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-400",
+          3
+        ],
+        [
+          "CWE-319",
+          1
+        ],
+        [
+          "CWE-497",
+          1
+        ],
+        [
+          "CWE-261",
+          1
+        ],
+        [
+          "CWE-201",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "harborist",
+      "assigner_org_id": "7ffcee3d-2c14-4c3e-b844-86c6a321a158",
+      "count": 9,
+      "rank": 222,
+      "first_cve_date": "2026-02-12T04:39:42.914Z",
+      "last_cve_date": "2026-09-21T02:27:00.752Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 5,
+        "Critical": 1,
+        "High": 2,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-22": 2,
+        "CWE-770": 1,
+        "CWE-248": 1,
+        "CWE-703": 1,
+        "CWE-77": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-22",
+          2
+        ],
+        [
+          "CWE-770",
+          1
+        ],
+        [
+          "CWE-248",
+          1
+        ],
+        [
+          "CWE-703",
+          1
+        ],
+        [
+          "CWE-77",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Meta",
+      "assigner_org_id": "4fc57720-52fe-4431-a0fb-3d2c8747b827",
+      "count": 9,
+      "rank": 223,
+      "first_cve_date": "2026-01-26T19:16:38.250Z",
+      "last_cve_date": "2026-07-23T16:27:01.658Z",
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 6,
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-502": 4,
+        "CWE-770": 2,
+        "CWE-400": 2,
+        "CWE-1284": 1,
+        "CWE-158": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-502",
+          4
+        ],
+        [
+          "CWE-770",
+          2
+        ],
+        [
+          "CWE-400",
+          2
+        ],
+        [
+          "CWE-1284",
+          1
+        ],
+        [
+          "CWE-158",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "arcinfo",
+      "assigner_org_id": "87c8e6ad-f0f5-4ca8-89e2-89f26d6ed932",
+      "count": 9,
+      "rank": 224,
+      "first_cve_date": "2026-02-26T07:55:18.433Z",
+      "last_cve_date": "2026-07-07T09:26:55.347Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1,
+        "Medium": 6,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-79": 2,
+        "CWE-326": 1,
+        "CWE-256": 1,
+        "CWE-1385": 1,
+        "CWE-1390": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-326",
+          1
+        ],
+        [
+          "CWE-256",
+          1
+        ],
+        [
+          "CWE-1385",
+          1
+        ],
+        [
+          "CWE-1390",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "ESET",
+      "assigner_org_id": "4a9b9929-2450-4021-b7b9-469a0255b215",
+      "count": 8,
+      "rank": 225,
+      "first_cve_date": "2026-01-30T12:18:58.271Z",
+      "last_cve_date": "2026-09-09T08:29:18.906Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 6,
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-269": 5,
+        "CWE-367": 1,
+        "CWE-204": 1,
+        "CWE-416": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-269",
+          5
+        ],
+        [
+          "CWE-367",
+          1
+        ],
+        [
+          "CWE-204",
+          1
+        ],
+        [
+          "CWE-416",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "blackberry",
+      "assigner_org_id": "dbe78b00-5e7b-4fda-8748-329789ecfc5c",
+      "count": 8,
+      "rank": 226,
+      "first_cve_date": "2026-01-13T16:36:21.061Z",
+      "last_cve_date": "2026-08-11T16:17:02.891Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 5,
+        "High": 3
+      },
+      "top_cwe_types": {
+        "CWE-79": 2,
+        "CWE-476": 1,
+        "CWE-74": 1,
+        "CWE-1284": 1,
+        "CWE-233": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-476",
+          1
+        ],
+        [
+          "CWE-74",
+          1
+        ],
+        [
+          "CWE-1284",
+          1
+        ],
+        [
+          "CWE-233",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Delinea",
+      "assigner_org_id": "1443cd92-d354-46d2-9290-d812316ca43a",
+      "count": 8,
+      "rank": 227,
+      "first_cve_date": "2026-01-27T19:46:04.677Z",
+      "last_cve_date": "2026-09-15T23:22:15.196Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 3,
+        "Critical": 5
+      },
+      "top_cwe_types": {
+        "CWE-89": 2,
+        "CWE-290": 2,
+        "CWE-287": 1,
+        "CWE-444": 1,
+        "CWE-327": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-89",
+          2
+        ],
+        [
+          "CWE-290",
+          2
+        ],
+        [
+          "CWE-287",
+          1
+        ],
+        [
+          "CWE-444",
+          1
+        ],
+        [
+          "CWE-327",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Genetec",
+      "assigner_org_id": "f2b06212-cb4b-41a4-9501-fa2e367495b8",
+      "count": 8,
+      "rank": 228,
+      "first_cve_date": "2026-02-13T16:45:06.539Z",
+      "last_cve_date": "2026-08-27T22:08:52.736Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 4,
+        "High": 4
+      },
+      "top_cwe_types": {
+        "CWE-346": 1,
+        "CWE-250": 1,
+        "CWE-276": 1,
+        "CWE-287": 1,
+        "CWE-89": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-346",
+          1
+        ],
+        [
+          "CWE-250",
+          1
+        ],
+        [
+          "CWE-276",
+          1
+        ],
+        [
+          "CWE-287",
+          1
+        ],
+        [
+          "CWE-89",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Netskope",
+      "assigner_org_id": "bf992f6a-e49d-4e94-9479-c4cff32c62bc",
+      "count": 8,
+      "rank": 229,
+      "first_cve_date": "2026-03-17T18:55:59.156Z",
+      "last_cve_date": "2026-09-11T13:57:02.512Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 7,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-190": 3,
+        "CWE-125": 2,
+        "CWE-782": 1,
+        "CWE-276": 1,
+        "CWE-908": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-190",
+          3
+        ],
+        [
+          "CWE-125",
+          2
+        ],
+        [
+          "CWE-782",
+          1
+        ],
+        [
+          "CWE-276",
+          1
+        ],
+        [
+          "CWE-908",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "TCS-CERT",
+      "assigner_org_id": "64c5ae8f-7972-4697-86a0-7ada793ac795",
+      "count": 8,
+      "rank": 230,
+      "first_cve_date": "2026-01-07T13:23:09.002Z",
+      "last_cve_date": "2026-09-08T10:28:10.125Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "Medium": 5,
+        "Low": 1,
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-79": 4,
+        "CWE-611": 2,
+        "CWE-256": 1,
+        "CWE-732": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          4
+        ],
+        [
+          "CWE-611",
+          2
+        ],
+        [
+          "CWE-256",
+          1
+        ],
+        [
+          "CWE-732",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "LY-Corporation",
+      "assigner_org_id": "657f3255-0560-4aed-82e4-7f579ec6acfb",
+      "count": 8,
+      "rank": 231,
+      "first_cve_date": "2026-04-16T05:54:05.194Z",
+      "last_cve_date": "2026-08-19T01:19:34.960Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 4,
+        "Medium": 2,
+        "Critical": 2
+      },
+      "top_cwe_types": {
+        "CWE-94": 1,
+        "CWE-427": 1,
+        "CWE-400": 1,
+        "CWE-451": 1,
+        "CWE-90": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-94",
+          1
+        ],
+        [
+          "CWE-427",
+          1
+        ],
+        [
+          "CWE-400",
+          1
+        ],
+        [
+          "CWE-451",
+          1
+        ],
+        [
+          "CWE-90",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "netapp",
+      "assigner_org_id": "11fdca00-0482-4c88-a206-37f9c182c87d",
+      "count": 8,
+      "rank": 232,
+      "first_cve_date": "2026-01-12T17:15:07.484Z",
+      "last_cve_date": "2026-08-28T21:45:53.370Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 4,
+        "High": 2,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-259": 2,
+        "CWE-209": 1,
+        "CWE-918": 1,
+        "CWE-774": 1,
+        "CWE-200": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-259",
+          2
+        ],
+        [
+          "CWE-209",
+          1
+        ],
+        [
+          "CWE-918",
+          1
+        ],
+        [
+          "CWE-774",
+          1
+        ],
+        [
+          "CWE-200",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "ZUSO ART",
+      "assigner_org_id": "256c161b-b921-402b-8c3b-c6c9c14d5d88",
+      "count": 8,
+      "rank": 233,
+      "first_cve_date": "2026-01-30T03:48:28.100Z",
+      "last_cve_date": "2026-09-15T08:49:12.313Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 6,
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-306": 2,
+        "CWE-434": 2,
+        "CWE-73": 1,
+        "CWE-78": 1,
+        "CWE-732": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-306",
+          2
+        ],
+        [
+          "CWE-434",
+          2
+        ],
+        [
+          "CWE-73",
+          1
+        ],
+        [
+          "CWE-78",
+          1
+        ],
+        [
+          "CWE-732",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Mautic",
+      "assigner_org_id": "4e531c38-7a33-45d3-98dd-d909c0d8852e",
+      "count": 8,
+      "rank": 234,
+      "first_cve_date": "2026-02-24T18:39:03.352Z",
+      "last_cve_date": "2026-05-29T10:41:29.041Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 4,
+        "Critical": 2,
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-79": 2,
+        "CWE-89": 2,
+        "CWE-863": 1,
+        "CWE-22": 1,
+        "CWE-73": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-89",
+          2
+        ],
+        [
+          "CWE-863",
+          1
+        ],
+        [
+          "CWE-22",
+          1
+        ],
+        [
+          "CWE-73",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Bugcrowd",
+      "assigner_org_id": "4ac701fe-44e9-4bcd-9585-dd6449257611",
+      "count": 8,
+      "rank": 235,
+      "first_cve_date": "2026-04-14T01:49:08.920Z",
+      "last_cve_date": "2026-09-01T00:13:03.935Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "severity_distribution": {
+        "High": 1,
+        "Critical": 4,
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-94": 2,
+        "CWE-122": 2,
+        "CWE-284": 1,
+        "CWE-59": 1,
+        "CWE-125": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-94",
+          2
+        ],
+        [
+          "CWE-122",
+          2
+        ],
+        [
+          "CWE-284",
+          1
+        ],
+        [
+          "CWE-59",
+          1
+        ],
+        [
+          "CWE-125",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Perforce",
+      "assigner_org_id": "ca2a266c-be2f-4d4b-92d0-47b76b1a9c4e",
+      "count": 8,
+      "rank": 236,
+      "first_cve_date": "2026-04-24T11:02:50.723Z",
+      "last_cve_date": "2026-09-11T14:40:53.491Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 5,
+        "Critical": 2,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-78": 2,
+        "CWE-94": 2,
+        "CWE-20": 1,
+        "CWE-269": 1,
+        "CWE-41": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          2
+        ],
+        [
+          "CWE-94",
+          2
+        ],
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-269",
+          1
+        ],
+        [
+          "CWE-41",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "BT",
+      "assigner_org_id": "13061848-ea10-403d-bd75-c83a022c2891",
+      "count": 8,
+      "rank": 237,
+      "first_cve_date": "2026-02-02T16:18:47.242Z",
+      "last_cve_date": "2026-08-17T16:29:12.385Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 4,
+        "Critical": 3,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-287": 2,
+        "CWE-400": 1,
+        "CWE-125": 1,
+        "CWE-1220": 1,
+        "CWE-943": 1
+      },
+      "kev_count": 1,
+      "epss_high_count": 1,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-287",
+          2
+        ],
+        [
+          "CWE-400",
+          1
+        ],
+        [
+          "CWE-125",
+          1
+        ],
+        [
+          "CWE-1220",
+          1
+        ],
+        [
+          "CWE-943",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "BLSOPS",
+      "assigner_org_id": "27b6da8a-f51d-48d9-9eef-9b7f3405d20d",
+      "count": 8,
+      "rank": 238,
+      "first_cve_date": "2026-02-06T16:22:28.282Z",
+      "last_cve_date": "2026-07-08T15:03:50.730Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 4,
+        "Medium": 2,
+        "Critical": 1,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-22": 3,
+        "CWE-59": 2,
+        "CWE-918": 1,
+        "CWE-89": 1,
+        "CWE-321": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-22",
+          3
+        ],
+        [
+          "CWE-59",
+          2
+        ],
+        [
+          "CWE-918",
+          1
+        ],
+        [
+          "CWE-89",
+          1
+        ],
+        [
+          "CWE-321",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Gallagher",
+      "assigner_org_id": "0c426f27-3ee1-4eff-be88-288d5a1822bc",
+      "count": 7,
+      "rank": 239,
+      "first_cve_date": "2026-03-03T02:39:30.623Z",
+      "last_cve_date": "2026-07-07T03:49:34.370Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 3,
+        "Low": 3,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-248": 2,
+        "CWE-312": 1,
+        "CWE-319": 1,
+        "CWE-667": 1,
+        "CWE-532": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-248",
+          2
+        ],
+        [
+          "CWE-312",
+          1
+        ],
+        [
+          "CWE-319",
+          1
+        ],
+        [
+          "CWE-667",
+          1
+        ],
+        [
+          "CWE-532",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "HackRTU",
+      "assigner_org_id": "ffb98d57-deaa-4918-a669-5225ccc13e39",
+      "count": 7,
+      "rank": 240,
+      "first_cve_date": "2026-02-11T09:05:07.289Z",
+      "last_cve_date": "2026-06-17T08:13:37.802Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 7
+      },
+      "top_cwe_types": {
+        "CWE-79": 4,
+        "CWE-497": 1,
+        "CWE-770": 1,
+        "CWE-201": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          4
+        ],
+        [
+          "CWE-497",
+          1
+        ],
+        [
+          "CWE-770",
+          1
+        ],
+        [
+          "CWE-201",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Dragos",
+      "assigner_org_id": "12bdf821-1545-4a87-aac5-61670cc6fcef",
+      "count": 7,
+      "rank": 241,
+      "first_cve_date": "2026-01-02T21:26:57.225Z",
+      "last_cve_date": "2026-01-03T00:28:24.506Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3,
+        "Critical": 4
+      },
+      "top_cwe_types": {
+        "CWE-441": 2,
+        "CWE-78": 2,
+        "CWE-522": 1,
+        "CWE-288": 1,
+        "CWE-603": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-441",
+          2
+        ],
+        [
+          "CWE-78",
+          2
+        ],
+        [
+          "CWE-522",
+          1
+        ],
+        [
+          "CWE-288",
+          1
+        ],
+        [
+          "CWE-603",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "TML",
+      "assigner_org_id": "07aac9b9-e3e9-4d03-a447-764bd31371d7",
+      "count": 7,
+      "rank": 242,
+      "first_cve_date": "2026-01-05T00:02:51.266Z",
+      "last_cve_date": "2026-07-27T02:23:23.674Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 6,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-639": 3,
+        "CWE-79": 2,
+        "CWE-1188": 1,
+        "CWE-288": 1,
+        "CWE-1241": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-639",
+          3
+        ],
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-1188",
+          1
+        ],
+        [
+          "CWE-288",
+          1
+        ],
+        [
+          "CWE-1241",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "SN",
+      "assigner_org_id": "303448ea-6ef3-4077-ad29-5c9bf253c375",
+      "count": 7,
+      "rank": 243,
+      "first_cve_date": "2026-01-12T21:29:37.421Z",
+      "last_cve_date": "2026-08-27T19:05:04.612Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 7
+      },
+      "top_cwe_types": {
+        "CWE-94": 3,
+        "CWE-250": 1,
+        "CWE-284": 1,
+        "CWE-89": 1,
+        "CWE-653": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 2,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-94",
+          3
+        ],
+        [
+          "CWE-250",
+          1
+        ],
+        [
+          "CWE-284",
+          1
+        ],
+        [
+          "CWE-89",
+          1
+        ],
+        [
+          "CWE-653",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Vivo",
+      "assigner_org_id": "c6f5cd8e-fe3d-4460-82c2-f8a4e7b272c8",
+      "count": 7,
+      "rank": 244,
+      "first_cve_date": "2026-02-27T06:52:34.399Z",
+      "last_cve_date": "2026-08-26T06:46:54.944Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 3,
+        "High": 1,
+        "Critical": 1,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-306": 4,
+        "CWE-807": 1,
+        "CWE-841": 1,
+        "CWE-653": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-306",
+          4
+        ],
+        [
+          "CWE-807",
+          1
+        ],
+        [
+          "CWE-841",
+          1
+        ],
+        [
+          "CWE-653",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "ThinkstAppliedResearch",
+      "assigner_org_id": "0f2be0ad-3469-4e56-b38f-4eb96719b425",
+      "count": 7,
+      "rank": 245,
+      "first_cve_date": "2026-06-03T13:02:15.195Z",
+      "last_cve_date": "2026-09-21T19:39:43.314Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Academic"
+      ],
+      "severity_distribution": {
+        "Medium": 1,
+        "Low": 6
+      },
+      "top_cwe_types": {
+        "CWE-74": 3,
+        "CWE-770": 2,
+        "CWE-20": 1,
+        "CWE-835": 1,
+        "CWE-79": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-74",
+          3
+        ],
+        [
+          "CWE-770",
+          2
+        ],
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-835",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Securifera",
+      "assigner_org_id": "c35fbbdf-8d87-49b6-8120-920a36e62b7f",
+      "count": 7,
+      "rank": 246,
+      "first_cve_date": "2026-09-17T11:57:44.343Z",
+      "last_cve_date": "2026-09-22T23:10:19.304Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 3,
+        "Critical": 3,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-78": 2,
+        "CWE-798": 1,
+        "CWE-290": 1,
+        "CWE-330": 1,
+        "CWE-121": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          2
+        ],
+        [
+          "CWE-798",
+          1
+        ],
+        [
+          "CWE-290",
+          1
+        ],
+        [
+          "CWE-330",
+          1
+        ],
+        [
+          "CWE-121",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Hackrate",
+      "assigner_org_id": "7004884b-51e2-48e8-b4a2-5ca29e80453e",
+      "count": 7,
+      "rank": 247,
+      "first_cve_date": "2026-02-11T14:49:44.991Z",
+      "last_cve_date": "2026-09-10T16:05:55.403Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 6,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-470": 1,
+        "CWE-639": 1,
+        "CWE-693": 1,
+        "CWE-285": 1,
+        "CWE-89": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-470",
+          1
+        ],
+        [
+          "CWE-639",
+          1
+        ],
+        [
+          "CWE-693",
+          1
+        ],
+        [
+          "CWE-285",
+          1
+        ],
+        [
+          "CWE-89",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "ConnectWise",
+      "assigner_org_id": "7d616e1a-3288-43b1-a0dd-0a65d3e70a49",
+      "count": 7,
+      "rank": 248,
+      "first_cve_date": "2026-01-16T13:34:42.833Z",
+      "last_cve_date": "2026-09-08T19:29:33.630Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3,
+        "Critical": 2,
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-494": 1,
+        "CWE-269": 1,
+        "CWE-862": 1,
+        "CWE-347": 1,
+        "CWE-1284": 1
+      },
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-494",
+          1
+        ],
+        [
+          "CWE-269",
+          1
+        ],
+        [
+          "CWE-862",
+          1
+        ],
+        [
+          "CWE-347",
+          1
+        ],
+        [
+          "CWE-1284",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "seal",
+      "assigner_org_id": "22e2d327-25fe-45d7-9f0c-dcd23b7108df",
+      "count": 7,
+      "rank": 249,
+      "first_cve_date": "2026-06-30T08:05:36.399Z",
+      "last_cve_date": "2026-08-20T12:42:42.952Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 4,
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-400": 4,
+        "CWE-407": 2,
+        "CWE-22": 1,
+        "CWE-59": 1,
+        "CWE-787": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-400",
+          4
+        ],
+        [
+          "CWE-407",
+          2
+        ],
+        [
+          "CWE-22",
+          1
+        ],
+        [
+          "CWE-59",
+          1
+        ],
+        [
+          "CWE-787",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Tcpdump",
+      "assigner_org_id": "cfdbb673-b408-4d03-89c1-c3d73ed80896",
+      "count": 7,
+      "rank": 250,
+      "first_cve_date": "2026-09-05T18:48:39.126Z",
+      "last_cve_date": "2026-09-05T18:51:57.956Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 6,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-125": 2,
+        "CWE-401": 1,
+        "CWE-126": 1,
+        "CWE-1288": 1,
+        "CWE-617": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-125",
+          2
+        ],
+        [
+          "CWE-401",
+          1
+        ],
+        [
+          "CWE-126",
+          1
+        ],
+        [
+          "CWE-1288",
+          1
+        ],
+        [
+          "CWE-617",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "wibu",
+      "assigner_org_id": "2fc02b1f-71e7-4514-a878-169626f68903",
+      "count": 7,
+      "rank": 251,
+      "first_cve_date": "2026-08-27T07:06:17.884Z",
+      "last_cve_date": "2026-08-27T07:46:30.828Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 7
+      },
+      "top_cwe_types": {
+        "CWE-119": 1,
+        "CWE-284": 1,
+        "CWE-130": 1,
+        "CWE-59": 1,
+        "CWE-134": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-119",
+          1
+        ],
+        [
+          "CWE-284",
+          1
+        ],
+        [
+          "CWE-130",
+          1
+        ],
+        [
+          "CWE-59",
+          1
+        ],
+        [
+          "CWE-134",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Softing",
+      "assigner_org_id": "10de8ef9-5c89-4b17-8228-e97b74acf4bd",
+      "count": 6,
+      "rank": 252,
+      "first_cve_date": "2026-03-16T13:14:49.030Z",
+      "last_cve_date": "2026-09-04T09:44:58.319Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 5,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-121": 1,
+        "CWE-416": 1,
+        "CWE-476": 1,
+        "CWE-122": 1,
+        "CWE-20": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-121",
+          1
+        ],
+        [
+          "CWE-416",
+          1
+        ],
+        [
+          "CWE-476",
+          1
+        ],
+        [
+          "CWE-122",
+          1
+        ],
+        [
+          "CWE-20",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "NCSC-NL",
+      "assigner_org_id": "cf4a7ff5-dd38-4ede-a530-ffaa7ea59c39",
+      "count": 6,
+      "rank": 253,
+      "first_cve_date": "2026-01-09T09:59:58.839Z",
+      "last_cve_date": "2026-02-20T07:58:57.686Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "High": 2,
+        "Critical": 3,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-77": 3,
+        "CWE-89": 1,
+        "CWE-78": 1,
+        "CWE-22": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-77",
+          3
+        ],
+        [
+          "CWE-89",
+          1
+        ],
+        [
+          "CWE-78",
+          1
+        ],
+        [
+          "CWE-22",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Altera",
+      "assigner_org_id": "04c0172e-9735-4a9d-a92a-fe01fa863447",
+      "count": 6,
+      "rank": 254,
+      "first_cve_date": "2026-01-06T21:06:19.457Z",
+      "last_cve_date": "2026-01-06T21:42:28.480Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 6
+      },
+      "top_cwe_types": {
+        "CWE-427": 4,
+        "CWE-377": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-427",
+          4
+        ],
+        [
+          "CWE-377",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "BCNY",
+      "assigner_org_id": "59469e6c-7ea7-446f-8e43-06aa32c115e8",
+      "count": 6,
+      "rank": 255,
+      "first_cve_date": "2026-01-16T18:11:32.153Z",
+      "last_cve_date": "2026-09-23T19:02:02.034Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 6
+      },
+      "top_cwe_types": {
+        "CWE-1021": 4,
+        "CWE-451": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-1021",
+          4
+        ],
+        [
+          "CWE-451",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Salesforce",
+      "assigner_org_id": "c9b25dee-ae6d-4083-ba23-638c500cc364",
+      "count": 6,
+      "rank": 256,
+      "first_cve_date": "2026-01-09T22:10:02.933Z",
+      "last_cve_date": "2026-03-23T19:54:32.967Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 6
+      },
+      "top_cwe_types": {
+        "CWE-88": 3,
+        "CWE-321": 1,
+        "CWE-94": 1,
+        "CWE-327": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-88",
+          3
+        ],
+        [
+          "CWE-321",
+          1
+        ],
+        [
+          "CWE-94",
+          1
+        ],
+        [
+          "CWE-327",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "N-able",
+      "assigner_org_id": "a5532a13-c4dd-4202-bef1-e0b8f2f8d12b",
+      "count": 6,
+      "rank": 257,
+      "first_cve_date": "2026-08-01T19:59:30.913Z",
+      "last_cve_date": "2026-09-06T02:15:28.824Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1,
+        "Medium": 2,
+        "High": 3
+      },
+      "top_cwe_types": {
+        "CWE-288": 2,
+        "CWE-96": 1,
+        "CWE-791": 1,
+        "CWE-305": 1,
+        "CWE-1385": 1
+      },
+      "kev_count": 3,
+      "epss_high_count": 1,
+      "epss_elevated_count": 2,
+      "top_cwes": [
+        [
+          "CWE-288",
+          2
+        ],
+        [
+          "CWE-96",
+          1
+        ],
+        [
+          "CWE-791",
+          1
+        ],
+        [
+          "CWE-305",
+          1
+        ],
+        [
+          "CWE-1385",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "THA-PSIRT",
+      "assigner_org_id": "9d5917ae-205d-4ae5-8749-1f49479b1395",
+      "count": 6,
+      "rank": 258,
+      "first_cve_date": "2026-02-04T10:42:14.626Z",
+      "last_cve_date": "2026-07-13T09:42:45.431Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1,
+        "Medium": 3,
+        "High": 1,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-79": 2,
+        "CWE-22": 1,
+        "CWE-73": 1,
+        "CWE-94": 1,
+        "CWE-694": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-22",
+          1
+        ],
+        [
+          "CWE-73",
+          1
+        ],
+        [
+          "CWE-94",
+          1
+        ],
+        [
+          "CWE-694",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Honeywell",
+      "assigner_org_id": "0dc86260-d7e3-4e81-ba06-3508e030ce8d",
+      "count": 6,
+      "rank": 259,
+      "first_cve_date": "2026-04-05T22:00:27.141Z",
+      "last_cve_date": "2026-07-27T18:45:35.455Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 4,
+        "Critical": 1,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-367": 1,
+        "CWE-200": 1,
+        "CWE-77": 1,
+        "CWE-538": 1,
+        "CWE-280": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-367",
+          1
+        ],
+        [
+          "CWE-200",
+          1
+        ],
+        [
+          "CWE-77",
+          1
+        ],
+        [
+          "CWE-538",
+          1
+        ],
+        [
+          "CWE-280",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "M-Files Corporation",
+      "assigner_org_id": "bcf7a16e-bfdc-46e4-9e42-4187da3f4410",
+      "count": 6,
+      "rank": 260,
+      "first_cve_date": "2026-01-21T10:29:57.786Z",
+      "last_cve_date": "2026-08-19T11:47:07.591Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 5,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-1286": 3,
+        "CWE-79": 2,
+        "CWE-918": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-1286",
+          3
+        ],
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-918",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "OAI",
+      "assigner_org_id": "8f4f43ab-ba69-4d92-aa1d-d772184d6fb7",
+      "count": 6,
+      "rank": 261,
+      "first_cve_date": "2026-06-05T00:12:32.077Z",
+      "last_cve_date": "2026-09-01T17:14:49.978Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3,
+        "Critical": 1,
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-15": 2,
+        "CWE-150": 1,
+        "CWE-427": 1,
+        "CWE-284": 1,
+        "CWE-200": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-15",
+          2
+        ],
+        [
+          "CWE-150",
+          1
+        ],
+        [
+          "CWE-427",
+          1
+        ],
+        [
+          "CWE-284",
+          1
+        ],
+        [
+          "CWE-200",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "AHA",
+      "assigner_org_id": "26969f82-7e87-44d8-9cb5-f6fb926ddd43",
+      "count": 6,
+      "rank": 262,
+      "first_cve_date": "2026-02-27T04:28:46.955Z",
+      "last_cve_date": "2026-06-23T23:54:21.635Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 2,
+        "High": 4
+      },
+      "top_cwe_types": {
+        "CWE-306": 1,
+        "CWE-798": 1,
+        "CWE-353": 1,
+        "CWE-912": 1,
+        "CWE-321": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-306",
+          1
+        ],
+        [
+          "CWE-798",
+          1
+        ],
+        [
+          "CWE-353",
+          1
+        ],
+        [
+          "CWE-912",
+          1
+        ],
+        [
+          "CWE-321",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Tigera",
+      "assigner_org_id": "e6d453f4-3dae-4941-bcea-9af25f4e824d",
+      "count": 6,
+      "rank": 263,
+      "first_cve_date": "2026-05-28T15:47:42.173Z",
+      "last_cve_date": "2026-07-30T14:45:04.418Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 4,
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-532": 3,
+        "CWE-200": 1,
+        "CWE-489": 1,
+        "CWE-285": 1,
+        "CWE-863": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-532",
+          3
+        ],
+        [
+          "CWE-200",
+          1
+        ],
+        [
+          "CWE-489",
+          1
+        ],
+        [
+          "CWE-285",
+          1
+        ],
+        [
+          "CWE-863",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "HITVAN",
+      "assigner_org_id": "dce6e192-ff49-4263-9134-f0beccb9bc13",
+      "count": 5,
+      "rank": 264,
+      "first_cve_date": "2026-03-09T22:12:51.587Z",
+      "last_cve_date": "2026-05-27T02:54:25.857Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 2,
+        "Medium": 2,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-862": 1,
+        "CWE-1395": 1,
+        "CWE-522": 1,
+        "CWE-732": 1,
+        "CWE-611": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-862",
+          1
+        ],
+        [
+          "CWE-1395",
+          1
+        ],
+        [
+          "CWE-522",
+          1
+        ],
+        [
+          "CWE-732",
+          1
+        ],
+        [
+          "CWE-611",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Ping Identity",
+      "assigner_org_id": "5998a2e9-ae88-42cd-b6e0-7564fd979f9e",
+      "count": 5,
+      "rank": 265,
+      "first_cve_date": "2026-04-07T22:33:05.356Z",
+      "last_cve_date": "2026-09-14T11:18:33.045Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 3,
+        "Critical": 1,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-352": 1,
+        "CWE-1220": 1,
+        "CWE-290": 1,
+        "CWE-401": 1,
+        "CWE-863": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-352",
+          1
+        ],
+        [
+          "CWE-1220",
+          1
+        ],
+        [
+          "CWE-290",
+          1
+        ],
+        [
+          "CWE-401",
+          1
+        ],
+        [
+          "CWE-863",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Lexmark",
+      "assigner_org_id": "7bc73191-a2b6-4c63-9918-753964601853",
+      "count": 5,
+      "rank": 266,
+      "first_cve_date": "2026-02-03T20:23:24.405Z",
+      "last_cve_date": "2026-02-03T20:51:20.556Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 3,
+        "Critical": 1,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-122": 1,
+        "CWE-125": 1,
+        "CWE-843": 1,
+        "CWE-426": 1,
+        "CWE-22": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-122",
+          1
+        ],
+        [
+          "CWE-125",
+          1
+        ],
+        [
+          "CWE-843",
+          1
+        ],
+        [
+          "CWE-426",
+          1
+        ],
+        [
+          "CWE-22",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "2N",
+      "assigner_org_id": "be69f613-e5f6-419b-800c-30351aa8933c",
+      "count": 5,
+      "rank": 267,
+      "first_cve_date": "2026-03-04T15:19:13.116Z",
+      "last_cve_date": "2026-03-04T15:31:59.211Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 4,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-613": 1,
+        "CWE-703": 1,
+        "CWE-117": 1,
+        "CWE-78": 1,
+        "CWE-1286": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-613",
+          1
+        ],
+        [
+          "CWE-703",
+          1
+        ],
+        [
+          "CWE-117",
+          1
+        ],
+        [
+          "CWE-78",
+          1
+        ],
+        [
+          "CWE-1286",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "forcepoint",
+      "assigner_org_id": "e23ea22c-8c39-4eff-8980-2881e5ae54e2",
+      "count": 5,
+      "rank": 268,
+      "first_cve_date": "2026-03-11T15:36:32.755Z",
+      "last_cve_date": "2026-09-23T13:27:22.017Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3,
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-250": 2,
+        "CWE-79": 1,
+        "CWE-754": 1,
+        "CWE-1284": 1,
+        "CWE-183": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-250",
+          2
+        ],
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-754",
+          1
+        ],
+        [
+          "CWE-1284",
+          1
+        ],
+        [
+          "CWE-183",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "FSI",
+      "assigner_org_id": "09832df1-09c1-45b4-8a85-16c601d30feb",
+      "count": 5,
+      "rank": 269,
+      "first_cve_date": "2026-05-21T08:07:48.088Z",
+      "last_cve_date": "2026-09-15T02:16:27.614Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 4,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-20": 3,
+        "CWE-202": 1,
+        "CWE-434": 1,
+        "CWE-613": 1,
+        "CWE-1286": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          3
+        ],
+        [
+          "CWE-202",
+          1
+        ],
+        [
+          "CWE-434",
+          1
+        ],
+        [
+          "CWE-613",
+          1
+        ],
+        [
+          "CWE-1286",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Canva",
+      "assigner_org_id": "61adb53e-e4b3-47f7-8a93-4717c9e77dc6",
+      "count": 5,
+      "rank": 270,
+      "first_cve_date": "2026-09-04T06:00:46.389Z",
+      "last_cve_date": "2026-09-21T06:43:02.132Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1,
+        "Critical": 1,
+        "High": 3
+      },
+      "top_cwe_types": {
+        "CWE-212": 2,
+        "CWE-174": 1,
+        "CWE-940": 1,
+        "CWE-121": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-212",
+          2
+        ],
+        [
+          "CWE-174",
+          1
+        ],
+        [
+          "CWE-940",
+          1
+        ],
+        [
+          "CWE-121",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "EDB",
+      "assigner_org_id": "20be33e2-bf35-4d13-8fad-18bd2f3e3659",
+      "count": 5,
+      "rank": 271,
+      "first_cve_date": "2026-01-16T16:29:42.134Z",
+      "last_cve_date": "2026-07-28T17:55:58.209Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 2,
+        "High": 1,
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-250": 1,
+        "CWE-416": 1,
+        "CWE-89": 1,
+        "CWE-125": 1,
+        "CWE-79": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-250",
+          1
+        ],
+        [
+          "CWE-416",
+          1
+        ],
+        [
+          "CWE-89",
+          1
+        ],
+        [
+          "CWE-125",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Citrix",
+      "assigner_org_id": "e437aed5-38e0-4fa3-a98b-cb73e7acaec6",
+      "count": 5,
+      "rank": 272,
+      "first_cve_date": "2026-07-14T12:49:17.998Z",
+      "last_cve_date": "2026-09-11T19:14:58.264Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 4,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-125": 2,
+        "CWE-787": 1,
+        "CWE-73": 1,
+        "CWE-269": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-125",
+          2
+        ],
+        [
+          "CWE-787",
+          1
+        ],
+        [
+          "CWE-73",
+          1
+        ],
+        [
+          "CWE-269",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "OpenNMS",
+      "assigner_org_id": "70b007e9-5235-4ee5-90b5-a71a81beeda0",
+      "count": 5,
+      "rank": 273,
+      "first_cve_date": "2026-08-13T04:47:25.584Z",
+      "last_cve_date": "2026-09-10T20:30:58.379Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 4,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-611": 1,
+        "CWE-863": 1,
+        "CWE-470": 1,
+        "CWE-89": 1,
+        "CWE-862": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-611",
+          1
+        ],
+        [
+          "CWE-863",
+          1
+        ],
+        [
+          "CWE-470",
+          1
+        ],
+        [
+          "CWE-89",
+          1
+        ],
+        [
+          "CWE-862",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "PTC",
+      "assigner_org_id": "0b655efc-079c-4cb9-9e8d-164871239f4e",
+      "count": 5,
+      "rank": 274,
+      "first_cve_date": "2026-03-23T21:48:05.652Z",
+      "last_cve_date": "2026-08-20T22:11:25.150Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 4,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-502": 3,
+        "CWE-20": 2,
+        "CWE-918": 1,
+        "CWE-306": 1,
+        "CWE-620": 1
+      },
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-502",
+          3
+        ],
+        [
+          "CWE-20",
+          2
+        ],
+        [
+          "CWE-918",
+          1
+        ],
+        [
+          "CWE-306",
+          1
+        ],
+        [
+          "CWE-620",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Caliptra",
+      "assigner_org_id": "b01ddd03-5ef6-483b-b2c5-acba77f1a554",
+      "count": 5,
+      "rank": 275,
+      "first_cve_date": "2026-06-23T23:49:44.591Z",
+      "last_cve_date": "2026-08-04T00:03:23.278Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1,
+        "Low": 1,
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-253": 1,
+        "CWE-345": 1,
+        "CWE-20": 1,
+        "CWE-367": 1,
+        "CWE-862": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-253",
+          1
+        ],
+        [
+          "CWE-345",
+          1
+        ],
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-367",
+          1
+        ],
+        [
+          "CWE-862",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "BlackDuck",
+      "assigner_org_id": "8cad7728-009c-4a3d-a95e-ca62e6ff8a0b",
+      "count": 5,
+      "rank": 276,
+      "first_cve_date": "2026-03-27T14:14:01.871Z",
+      "last_cve_date": "2026-08-24T14:17:23.940Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 2,
+        "High": 3
+      },
+      "top_cwe_types": {
+        "CWE-288": 1,
+        "CWE-89": 1,
+        "CWE-639": 1,
+        "CWE-214": 1,
+        "CWE-78": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-288",
+          1
+        ],
+        [
+          "CWE-89",
+          1
+        ],
+        [
+          "CWE-639",
+          1
+        ],
+        [
+          "CWE-214",
+          1
+        ],
+        [
+          "CWE-78",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Everpure",
+      "assigner_org_id": "3895c224-4e1d-482a-adb3-fa64795683ac",
+      "count": 5,
+      "rank": 277,
+      "first_cve_date": "2026-04-14T17:52:54.759Z",
+      "last_cve_date": "2026-09-09T12:45:30.861Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 4,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-532": 1,
+        "CWE-783": 1,
+        "CWE-939": 1,
+        "CWE-639": 1,
+        "CWE-266": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-532",
+          1
+        ],
+        [
+          "CWE-783",
+          1
+        ],
+        [
+          "CWE-939",
+          1
+        ],
+        [
+          "CWE-639",
+          1
+        ],
+        [
+          "CWE-266",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Cribl",
+      "assigner_org_id": "af879a92-7297-456a-bb0e-905ac6c64bdc",
+      "count": 5,
+      "rank": 278,
+      "first_cve_date": "2026-05-12T01:06:25.477Z",
+      "last_cve_date": "2026-07-27T19:27:31.700Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 3,
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-20": 3,
+        "CWE-78": 2,
+        "CWE-79": 1,
+        "CWE-276": 1,
+        "CWE-61": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          3
+        ],
+        [
+          "CWE-78",
+          2
+        ],
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-276",
+          1
+        ],
+        [
+          "CWE-61",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "SCHUTZWERK",
+      "assigner_org_id": "23637b5d-af4c-4cf9-b8f6-deb7fd0f8423",
+      "count": 4,
+      "rank": 279,
+      "first_cve_date": "2026-04-30T07:10:17.999Z",
+      "last_cve_date": "2026-09-09T06:14:22.143Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-611": 2,
+        "CWE-20": 1,
+        "CWE-79": 1,
+        "CWE-305": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-611",
+          2
+        ],
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-305",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "dahua",
+      "assigner_org_id": "79ee569e-7d1e-4364-98f0-3a18e2a739ad",
+      "count": 4,
+      "rank": 280,
+      "first_cve_date": "2026-03-18T07:13:21.911Z",
+      "last_cve_date": "2026-06-10T06:16:34.173Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 2,
+        "Medium": 1,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-617": 2,
+        "CWE-305": 1,
+        "CWE-538": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-617",
+          2
+        ],
+        [
+          "CWE-305",
+          1
+        ],
+        [
+          "CWE-538",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Supermicro",
+      "assigner_org_id": "def9a96e-e099-41a9-bfac-30fd4f82c411",
+      "count": 4,
+      "rank": 281,
+      "first_cve_date": "2026-01-16T08:36:33.739Z",
+      "last_cve_date": "2026-07-22T06:15:31.648Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 4
+      },
+      "top_cwe_types": {
+        "CWE-347": 2,
+        "CWE-78": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-347",
+          2
+        ],
+        [
+          "CWE-78",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Vaadin",
+      "assigner_org_id": "9e0f3122-90e9-42d5-93de-8c6b98deef7e",
+      "count": 4,
+      "rank": 282,
+      "first_cve_date": "2026-01-05T07:52:56.478Z",
+      "last_cve_date": "2026-05-19T11:01:47.212Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 2,
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-79": 1,
+        "CWE-209": 1,
+        "CWE-284": 1,
+        "CWE-22": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-209",
+          1
+        ],
+        [
+          "CWE-284",
+          1
+        ],
+        [
+          "CWE-22",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "TECNOMobile",
+      "assigner_org_id": "907edf6c-bf03-423e-ab1a-8da27e1aa1ea",
+      "count": 4,
+      "rank": 283,
+      "first_cve_date": "2026-01-06T01:39:20.526Z",
+      "last_cve_date": "2026-08-05T01:47:16.191Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1,
+        "High": 2,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-345": 1,
+        "CWE-23": 1,
+        "CWE-88": 1,
+        "CWE-79": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-345",
+          1
+        ],
+        [
+          "CWE-23",
+          1
+        ],
+        [
+          "CWE-88",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "alibaba",
+      "assigner_org_id": "0cc2b86d-1d45-434d-ae74-11d09ec61ae8",
+      "count": 4,
+      "rank": 284,
+      "first_cve_date": "2026-02-03T03:22:48.256Z",
+      "last_cve_date": "2026-07-28T09:05:30.652Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1,
+        "Medium": 2,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-20": 2,
+        "CWE-502": 1,
+        "CWE-1188": 1,
+        "CWE-347": 1,
+        "CWE-787": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-20",
+          2
+        ],
+        [
+          "CWE-502",
+          1
+        ],
+        [
+          "CWE-1188",
+          1
+        ],
+        [
+          "CWE-347",
+          1
+        ],
+        [
+          "CWE-787",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "OPPO",
+      "assigner_org_id": "7f2b1ad8-5432-4d64-91a1-9099af1cc695",
+      "count": 4,
+      "rank": 285,
+      "first_cve_date": "2026-04-27T06:37:05.647Z",
+      "last_cve_date": "2026-08-17T06:13:58.205Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1,
+        "High": 3
+      },
+      "top_cwe_types": {
+        "CWE-346": 1,
+        "CWE-23": 1,
+        "CWE-20": 1,
+        "CWE-266": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-346",
+          1
+        ],
+        [
+          "CWE-23",
+          1
+        ],
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-266",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "FERMAX",
+      "assigner_org_id": "539080bd-5750-4cce-b30b-eed9a4ef6dcc",
+      "count": 4,
+      "rank": 286,
+      "first_cve_date": "2026-09-16T09:12:29.119Z",
+      "last_cve_date": "2026-09-16T10:13:22.416Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-295": 1,
+        "CWE-312": 1,
+        "CWE-347": 1,
+        "CWE-319": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-295",
+          1
+        ],
+        [
+          "CWE-312",
+          1
+        ],
+        [
+          "CWE-347",
+          1
+        ],
+        [
+          "CWE-319",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "ExtremeNetworks",
+      "assigner_org_id": "1c053176-eef3-4d6a-ae0b-24728c86587b",
+      "count": 4,
+      "rank": 287,
+      "first_cve_date": "2026-03-02T15:16:44.054Z",
+      "last_cve_date": "2026-07-20T17:34:10.950Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 2,
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-362": 1,
+        "CWE-488": 1,
+        "CWE-59": 1,
+        "CWE-338": 1,
+        "CWE-522": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-362",
+          1
+        ],
+        [
+          "CWE-488",
+          1
+        ],
+        [
+          "CWE-59",
+          1
+        ],
+        [
+          "CWE-338",
+          1
+        ],
+        [
+          "CWE-522",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "libreswan",
+      "assigner_org_id": "d42dc95b-23f1-4e06-9076-20753a0fb0df",
+      "count": 4,
+      "rank": 288,
+      "first_cve_date": "2026-07-02T21:19:22.177Z",
+      "last_cve_date": "2026-09-02T02:19:00.114Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 4
+      },
+      "top_cwe_types": {
+        "CWE-617": 4,
+        "CWE-347": 2,
+        "CWE-193": 1,
+        "CWE-252": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-617",
+          4
+        ],
+        [
+          "CWE-347",
+          2
+        ],
+        [
+          "CWE-193",
+          1
+        ],
+        [
+          "CWE-252",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "postiz",
+      "assigner_org_id": "4cdc9741-f887-419a-a2fd-acbbd2729276",
+      "count": 4,
+      "rank": 289,
+      "first_cve_date": "2026-08-06T17:02:44.054Z",
+      "last_cve_date": "2026-09-22T16:17:00.413Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1,
+        "Critical": 2,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-345": 2,
+        "CWE-22": 1,
+        "CWE-330": 1,
+        "CWE-338": 1,
+        "CWE-341": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-345",
+          2
+        ],
+        [
+          "CWE-22",
+          1
+        ],
+        [
+          "CWE-330",
+          1
+        ],
+        [
+          "CWE-338",
+          1
+        ],
+        [
+          "CWE-341",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "naver",
+      "assigner_org_id": "f9629fae-ca2e-4fbf-9785-3ed86476aef6",
+      "count": 4,
+      "rank": 290,
+      "first_cve_date": "2026-01-16T05:20:58.677Z",
+      "last_cve_date": "2026-05-08T04:36:12.538Z",
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1,
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-79": 2,
+        "CWE-266": 1,
+        "CWE-918": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          2
+        ],
+        [
+          "CWE-266",
+          1
+        ],
+        [
+          "CWE-918",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "linqi",
+      "assigner_org_id": "86c47df7-7d28-48da-920a-6423c52fd3da",
+      "count": 4,
+      "rank": 291,
+      "first_cve_date": "2026-06-05T10:18:35.703Z",
+      "last_cve_date": "2026-06-05T12:37:46.830Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 2,
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-918": 1,
+        "CWE-287": 1,
+        "CWE-321": 1,
+        "CWE-338": 1,
+        "CWE-639": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-918",
+          1
+        ],
+        [
+          "CWE-287",
+          1
+        ],
+        [
+          "CWE-321",
+          1
+        ],
+        [
+          "CWE-338",
+          1
+        ],
+        [
+          "CWE-639",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Hanwha_Vision",
+      "assigner_org_id": "fc9afe74-3f80-4fb7-a313-e6f036a89882",
+      "count": 3,
+      "rank": 292,
+      "first_cve_date": "2026-04-28T06:51:33.550Z",
+      "last_cve_date": "2026-04-28T07:06:17.252Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 2,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-306": 1,
+        "CWE-20": 1,
+        "CWE-78": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-306",
+          1
+        ],
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-78",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "krcert",
+      "assigner_org_id": "cdd7a122-0fae-4202-8d86-14efbacc2863",
+      "count": 3,
+      "rank": 293,
+      "first_cve_date": "2026-02-04T04:46:55.545Z",
+      "last_cve_date": "2026-02-27T02:01:12.377Z",
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "High": 2,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-843": 1,
+        "CWE-121": 1,
+        "CWE-200": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-843",
+          1
+        ],
+        [
+          "CWE-121",
+          1
+        ],
+        [
+          "CWE-200",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "dotCMS",
+      "assigner_org_id": "5b9d93f2-25c7-46b4-ab60-d201718c9dd8",
+      "count": 3,
+      "rank": 294,
+      "first_cve_date": "2026-02-24T08:27:07.579Z",
+      "last_cve_date": "2026-07-20T19:15:11.190Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 3
+      },
+      "top_cwe_types": {
+        "CWE-89": 2,
+        "CWE-269": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-89",
+          2
+        ],
+        [
+          "CWE-269",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "trellix",
+      "assigner_org_id": "01626437-bf8f-4d1c-912a-893b5eb04808",
+      "count": 3,
+      "rank": 295,
+      "first_cve_date": "2026-02-24T17:11:06.812Z",
+      "last_cve_date": "2026-07-14T12:45:10.526Z",
+      "years_active": 9,
+      "first_cve_year": 2018,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1,
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-94": 1,
+        "CWE-20": 1,
+        "CWE-409": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-94",
+          1
+        ],
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-409",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Secomea",
+      "assigner_org_id": "f2815942-3388-4c08-ba09-6c15850fda90",
+      "count": 3,
+      "rank": 296,
+      "first_cve_date": "2026-03-19T10:52:30.851Z",
+      "last_cve_date": "2026-09-15T10:54:38.505Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 2,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-287": 1,
+        "CWE-384": 1,
+        "CWE-280": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-287",
+          1
+        ],
+        [
+          "CWE-384",
+          1
+        ],
+        [
+          "CWE-280",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Payara",
+      "assigner_org_id": "769c9ae7-73c3-4e47-ae19-903170fc3eb8",
+      "count": 3,
+      "rank": 297,
+      "first_cve_date": "2026-02-18T13:39:11.316Z",
+      "last_cve_date": "2026-09-15T14:04:25.241Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 2,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-79": 1,
+        "CWE-307": 1,
+        "CWE-352": 1,
+        "CWE-918": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-307",
+          1
+        ],
+        [
+          "CWE-352",
+          1
+        ],
+        [
+          "CWE-918",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "SWI",
+      "assigner_org_id": "747bec18-acd0-4d99-a5c8-5e366c66ab7e",
+      "count": 3,
+      "rank": 298,
+      "first_cve_date": "2026-04-07T19:56:59.042Z",
+      "last_cve_date": "2026-04-07T19:58:41.379Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 2,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-226": 1,
+        "CWE-327": 1,
+        "CWE-123": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-226",
+          1
+        ],
+        [
+          "CWE-327",
+          1
+        ],
+        [
+          "CWE-123",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "OMICRON",
+      "assigner_org_id": "57995746-fc30-4a4d-94f6-a13d079c41f4",
+      "count": 3,
+      "rank": 299,
+      "first_cve_date": "2026-08-06T13:14:24.169Z",
+      "last_cve_date": "2026-08-06T13:14:25.937Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1,
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-208": 2,
+        "CWE-20": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-208",
+          2
+        ],
+        [
+          "CWE-20",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "tlt_net",
+      "assigner_org_id": "001d69cf-3fc9-4203-93fb-9865b54e05b2",
+      "count": 3,
+      "rank": 300,
+      "first_cve_date": "2026-06-05T09:36:29.744Z",
+      "last_cve_date": "2026-08-13T10:52:35.564Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 2,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-93": 1,
+        "CWE-122": 1,
+        "CWE-95": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-93",
+          1
+        ],
+        [
+          "CWE-122",
+          1
+        ],
+        [
+          "CWE-95",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "systemd",
+      "assigner_org_id": "98a521c5-3a3e-4e2b-bc27-002067e0463c",
+      "count": 3,
+      "rank": 301,
+      "first_cve_date": "2026-08-10T13:02:31.716Z",
+      "last_cve_date": "2026-08-10T13:03:06.869Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-269": 1,
+        "CWE-347": 1,
+        "CWE-284": 1,
+        "CWE-862": 1,
+        "CWE-22": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-269",
+          1
+        ],
+        [
+          "CWE-347",
+          1
+        ],
+        [
+          "CWE-284",
+          1
+        ],
+        [
+          "CWE-862",
+          1
+        ],
+        [
+          "CWE-22",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "watchdog",
+      "assigner_org_id": "34edf4f2-2577-40ab-82ce-39f45972c129",
+      "count": 3,
+      "rank": 302,
+      "first_cve_date": "2026-09-20T12:02:34.251Z",
+      "last_cve_date": "2026-09-20T12:24:47.393Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-20": 1,
+        "CWE-306": 1,
+        "CWE-59": 1,
+        "CWE-276": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-306",
+          1
+        ],
+        [
+          "CWE-59",
+          1
+        ],
+        [
+          "CWE-276",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Toreon",
+      "assigner_org_id": "1c6b5737-9389-4011-8117-89fa251edfb2",
+      "count": 3,
+      "rank": 303,
+      "first_cve_date": "2026-03-16T07:14:07.366Z",
+      "last_cve_date": "2026-07-29T13:46:06.383Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1,
+        "Medium": 1,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-1336": 1,
+        "CWE-306": 1,
+        "CWE-829": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-1336",
+          1
+        ],
+        [
+          "CWE-306",
+          1
+        ],
+        [
+          "CWE-829",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "YesWeHack",
+      "assigner_org_id": "30a5e7fb-040d-440a-8cdf-a4a2068ce72e",
+      "count": 3,
+      "rank": 304,
+      "first_cve_date": "2026-09-07T07:58:09.190Z",
+      "last_cve_date": "2026-09-07T08:07:31.633Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1,
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-1342": 1,
+        "CWE-347": 1,
+        "CWE-787": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-1342",
+          1
+        ],
+        [
+          "CWE-347",
+          1
+        ],
+        [
+          "CWE-787",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Honor",
+      "assigner_org_id": "3836d913-7555-4dd0-a509-f5667fdf5fe4",
+      "count": 3,
+      "rank": 305,
+      "first_cve_date": "2026-04-21T06:26:52.403Z",
+      "last_cve_date": "2026-04-21T06:40:08.446Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1,
+        "High": 1,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-269": 2,
+        "CWE-200": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-269",
+          2
+        ],
+        [
+          "CWE-200",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "ASR",
+      "assigner_org_id": "68630edc-a58c-4cbd-9b01-0e130455c8ae",
+      "count": 3,
+      "rank": 306,
+      "first_cve_date": "2026-04-30T08:36:22.958Z",
+      "last_cve_date": "2026-09-23T09:03:56.690Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3
+      },
+      "top_cwe_types": {
+        "CWE-476": 2,
+        "CWE-125": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-476",
+          2
+        ],
+        [
+          "CWE-125",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Ciena",
+      "assigner_org_id": "7bd90cf1-1651-495e-9ae8-9415fb3c9feb",
+      "count": 3,
+      "rank": 307,
+      "first_cve_date": "2026-07-06T15:25:56.938Z",
+      "last_cve_date": "2026-07-14T22:25:55.317Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 3
+      },
+      "top_cwe_types": {
+        "CWE-1393": 1,
+        "CWE-287": 1,
+        "CWE-288": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-1393",
+          1
+        ],
+        [
+          "CWE-287",
+          1
+        ],
+        [
+          "CWE-288",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "SailPoint",
+      "assigner_org_id": "2cfc7547-56a0-4049-8b52-c3078e8a8719",
+      "count": 3,
+      "rank": 308,
+      "first_cve_date": "2026-04-15T18:08:45.737Z",
+      "last_cve_date": "2026-07-20T18:22:36.997Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3
+      },
+      "top_cwe_types": {
+        "CWE-863": 2,
+        "CWE-287": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-863",
+          2
+        ],
+        [
+          "CWE-287",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "SK-CERT",
+      "assigner_org_id": "bc375322-d3d7-4481-b261-e29662236cfd",
+      "count": 3,
+      "rank": 309,
+      "first_cve_date": "2026-03-19T11:25:44.800Z",
+      "last_cve_date": "2026-06-02T11:13:40.342Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "High": 1,
+        "Medium": 1,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-611": 1,
+        "CWE-1395": 1,
+        "CWE-200": 1,
+        "CWE-74": 1,
+        "CWE-94": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-611",
+          1
+        ],
+        [
+          "CWE-1395",
+          1
+        ],
+        [
+          "CWE-200",
+          1
+        ],
+        [
+          "CWE-74",
+          1
+        ],
+        [
+          "CWE-94",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "debian",
+      "assigner_org_id": "79363d38-fa19-49d1-9214-5f28da3f3ac5",
+      "count": 3,
+      "rank": 310,
+      "first_cve_date": "2026-03-07T08:10:53.207Z",
+      "last_cve_date": "2026-06-10T09:10:30.301Z",
+      "years_active": 22,
+      "first_cve_year": 2005,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 2,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-862": 1,
+        "CWE-59": 1,
+        "CWE-835": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-862",
+          1
+        ],
+        [
+          "CWE-59",
+          1
+        ],
+        [
+          "CWE-835",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "upKeeper",
+      "assigner_org_id": "80f39f49-2521-4ee7-9e17-af5d55e8032f",
+      "count": 3,
+      "rank": 311,
+      "first_cve_date": "2026-04-14T11:56:04.741Z",
+      "last_cve_date": "2026-06-24T08:04:58.703Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 2,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-117": 1,
+        "CWE-520": 1,
+        "CWE-88": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-117",
+          1
+        ],
+        [
+          "CWE-520",
+          1
+        ],
+        [
+          "CWE-88",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Bitdefender",
+      "assigner_org_id": "b3d5ebe7-963e-41fb-98e1-2edaeabb8f82",
+      "count": 3,
+      "rank": 312,
+      "first_cve_date": "2026-06-02T14:16:21.927Z",
+      "last_cve_date": "2026-07-14T07:11:50.520Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 3
+      },
+      "top_cwe_types": {
+        "CWE-787": 2,
+        "CWE-59": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          2
+        ],
+        [
+          "CWE-59",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Seagate",
+      "assigner_org_id": "c6156efd-4bd0-48d7-8520-680200527478",
+      "count": 3,
+      "rank": 313,
+      "first_cve_date": "2026-06-02T22:06:34.629Z",
+      "last_cve_date": "2026-06-02T22:31:45.704Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 2,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-787": 3
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-787",
+          3
+        ]
+      ]
+    },
+    {
+      "name": "Xerox",
+      "assigner_org_id": "10b61619-3869-496c-8a1e-f291b0e71e3f",
+      "count": 3,
+      "rank": 314,
+      "first_cve_date": "2026-02-06T17:19:45.450Z",
+      "last_cve_date": "2026-02-27T08:18:17.816Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1,
+        "Critical": 1,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-611": 1,
+        "CWE-918": 1,
+        "CWE-22": 1,
+        "CWE-79": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-611",
+          1
+        ],
+        [
+          "CWE-918",
+          1
+        ],
+        [
+          "CWE-22",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "HYPR",
+      "assigner_org_id": "0dc7baee-4a9f-419f-bd0a-e21ec5dac512",
+      "count": 3,
+      "rank": 315,
+      "first_cve_date": "2026-03-25T16:56:05.927Z",
+      "last_cve_date": "2026-06-25T15:39:28.322Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-639": 1,
+        "CWE-266": 1,
+        "CWE-306": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-639",
+          1
+        ],
+        [
+          "CWE-266",
+          1
+        ],
+        [
+          "CWE-306",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "floragunn",
+      "assigner_org_id": "9f311a02-c44f-4938-8530-9219246b8255",
+      "count": 3,
+      "rank": 316,
+      "first_cve_date": "2026-03-31T14:41:05.646Z",
+      "last_cve_date": "2026-03-31T14:57:56.792Z",
+      "years_active": 8,
+      "first_cve_year": 2019,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 3
+      },
+      "top_cwe_types": {
+        "CWE-522": 1,
+        "CWE-532": 1,
+        "CWE-601": 1,
+        "CWE-285": 1,
+        "CWE-862": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-522",
+          1
+        ],
+        [
+          "CWE-532",
+          1
+        ],
+        [
+          "CWE-601",
+          1
+        ],
+        [
+          "CWE-285",
+          1
+        ],
+        [
+          "CWE-862",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Palantir",
+      "assigner_org_id": "bbcbe11d-db20-4bc2-8a6e-c79f87041fd4",
+      "count": 2,
+      "rank": 317,
+      "first_cve_date": "2026-01-09T21:17:37.023Z",
+      "last_cve_date": "2026-01-22T19:06:05.914Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1,
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-305": 1,
+        "CWE-863": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-305",
+          1
+        ],
+        [
+          "CWE-863",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Cato",
+      "assigner_org_id": "2505284f-8ffb-486c-bf60-e19c1097a90b",
+      "count": 2,
+      "rank": 318,
+      "first_cve_date": "2026-03-31T11:35:48.868Z",
+      "last_cve_date": "2026-07-01T14:07:28.896Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-20": 1,
+        "CWE-78": 1,
+        "CWE-295": 1,
+        "CWE-367": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-78",
+          1
+        ],
+        [
+          "CWE-295",
+          1
+        ],
+        [
+          "CWE-367",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Medtronic",
+      "assigner_org_id": "3c337f33-b2bd-4529-9792-f48cdb2838b4",
+      "count": 2,
+      "rank": 319,
+      "first_cve_date": "2026-05-07T15:00:21.310Z",
+      "last_cve_date": "2026-05-07T15:03:35.674Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-1263": 1,
+        "CWE-313": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-1263",
+          1
+        ],
+        [
+          "CWE-313",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Jaspersoft",
+      "assigner_org_id": "db6d2600-d19b-4111-a010-f3c4ed70cd50",
+      "count": 2,
+      "rank": 320,
+      "first_cve_date": "2026-05-19T17:23:40.646Z",
+      "last_cve_date": "2026-08-10T18:00:20.122Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-611": 1,
+        "CWE-502": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-611",
+          1
+        ],
+        [
+          "CWE-502",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "bizerba",
+      "assigner_org_id": "0beee27a-7d8c-424f-8e46-ac453fa147e6",
+      "count": 2,
+      "rank": 321,
+      "first_cve_date": "2026-07-20T11:51:40.416Z",
+      "last_cve_date": "2026-07-20T11:54:37.566Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-276": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-276",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "FTI",
+      "assigner_org_id": "763b0cbd-1a52-41de-b280-f255286be201",
+      "count": 2,
+      "rank": 322,
+      "first_cve_date": "2026-07-22T15:07:35.516Z",
+      "last_cve_date": "2026-07-22T15:14:12.557Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-94": 1,
+        "CWE-269": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-94",
+          1
+        ],
+        [
+          "CWE-269",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Omnissa",
+      "assigner_org_id": "de5a6978-88fe-4c27-a7df-d0d5b52d5b52",
+      "count": 2,
+      "rank": 323,
+      "first_cve_date": "2026-06-09T16:34:24.180Z",
+      "last_cve_date": "2026-07-08T13:37:24.925Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-22": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-22",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "Canon_EMEA",
+      "assigner_org_id": "4586e0a2-224d-4f8a-9cb4-8882b208c0b3",
+      "count": 2,
+      "rank": 324,
+      "first_cve_date": "2026-07-06T08:12:49.571Z",
+      "last_cve_date": "2026-09-23T07:22:01.346Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-613": 1,
+        "CWE-522": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-613",
+          1
+        ],
+        [
+          "CWE-522",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "9front",
+      "assigner_org_id": "1d66c9f9-fff2-411a-aa19-ca6312fa25e9",
+      "count": 2,
+      "rank": 325,
+      "first_cve_date": "2026-05-22T02:57:35.162Z",
+      "last_cve_date": "2026-05-22T03:21:49.646Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-130": 1,
+        "CWE-434": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-130",
+          1
+        ],
+        [
+          "CWE-434",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Checkmarx",
+      "assigner_org_id": "596c5446-0ce5-4ba2-aa66-48b3b757a647",
+      "count": 2,
+      "rank": 326,
+      "first_cve_date": "2026-06-17T12:18:28.771Z",
+      "last_cve_date": "2026-06-17T13:41:49.439Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Security Researcher"
+      ],
+      "severity_distribution": {
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-352": 1,
+        "CWE-79": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-352",
+          1
+        ],
+        [
+          "CWE-79",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "GandC",
+      "assigner_org_id": "ace9cabe-4f4f-416b-8c39-b0e002761924",
+      "count": 2,
+      "rank": 327,
+      "first_cve_date": "2026-03-18T21:44:36.651Z",
+      "last_cve_date": "2026-09-03T20:25:18.792Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 2
+      },
+      "top_cwe_types": {
+        "CWE-369": 1,
+        "CWE-20": 1,
+        "CWE-787": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-369",
+          1
+        ],
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-787",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "NX",
+      "assigner_org_id": "96d4e157-0bf0-48b3-8efd-382c68caf4e0",
+      "count": 2,
+      "rank": 328,
+      "first_cve_date": "2026-05-29T08:04:59.926Z",
+      "last_cve_date": "2026-08-24T14:51:08.681Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-79": 1,
+        "CWE-942": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-942",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "rust",
+      "assigner_org_id": "986d4109-89ea-491f-99fd-a8e4803919bd",
+      "count": 2,
+      "rank": 329,
+      "first_cve_date": "2026-05-25T08:54:56.348Z",
+      "last_cve_date": "2026-05-25T08:57:08.488Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 1,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-647": 1,
+        "CWE-61": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-647",
+          1
+        ],
+        [
+          "CWE-61",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "tibco",
+      "assigner_org_id": "4f830c72-39e4-45f6-a99f-78cc01ae04db",
+      "count": 2,
+      "rank": 330,
+      "first_cve_date": "2026-03-17T18:20:16.934Z",
+      "last_cve_date": "2026-03-24T20:44:06.781Z",
+      "years_active": 10,
+      "first_cve_year": 2017,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-20": 1,
+        "CWE-306": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-20",
+          1
+        ],
+        [
+          "CWE-306",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "CrowdStrike",
+      "assigner_org_id": "13ddcd98-6f4a-40a8-8e24-29ca0aee4661",
+      "count": 2,
+      "rank": 331,
+      "first_cve_date": "2026-04-21T16:48:24.722Z",
+      "last_cve_date": "2026-09-15T17:47:53.251Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1,
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-367": 1,
+        "CWE-22": 1,
+        "CWE-306": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-367",
+          1
+        ],
+        [
+          "CWE-22",
+          1
+        ],
+        [
+          "CWE-306",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Digi",
+      "assigner_org_id": "e8a6bb0b-e373-42b1-a5de-93e314325576",
+      "count": 2,
+      "rank": 332,
+      "first_cve_date": "2026-07-07T14:31:08.550Z",
+      "last_cve_date": "2026-07-07T14:32:43.977Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 2
+      },
+      "top_cwe_types": {
+        "CWE-79": 1,
+        "CWE-863": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          1
+        ],
+        [
+          "CWE-863",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "BombadilSystems",
+      "assigner_org_id": "aa17e1a1-c329-4d6e-a1ed-8d0188aea082",
+      "count": 2,
+      "rank": 333,
+      "first_cve_date": "2026-07-04T13:25:55.283Z",
+      "last_cve_date": "2026-07-04T13:31:14.937Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-693": 1,
+        "CWE-184": 1,
+        "CWE-502": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-693",
+          1
+        ],
+        [
+          "CWE-184",
+          1
+        ],
+        [
+          "CWE-502",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "GE_Vernova",
+      "assigner_org_id": "2cf0fb33-79e2-44e0-beb8-826cc5ce3250",
+      "count": 2,
+      "rank": 334,
+      "first_cve_date": "2026-02-10T20:06:00.213Z",
+      "last_cve_date": "2026-02-10T20:06:12.992Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 1,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-23": 1,
+        "CWE-35": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-23",
+          1
+        ],
+        [
+          "CWE-35",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "CODRA",
+      "assigner_org_id": "30aa36b7-a224-4bc9-b7d3-abea20aa4887",
+      "count": 2,
+      "rank": 335,
+      "first_cve_date": "2026-03-25T12:29:13.631Z",
+      "last_cve_date": "2026-03-25T12:45:27.361Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 1,
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-732": 1,
+        "CWE-552": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-732",
+          1
+        ],
+        [
+          "CWE-552",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "flexera",
+      "assigner_org_id": "44d08088-2bea-4760-83a6-1e9be26b15ab",
+      "count": 2,
+      "rank": 336,
+      "first_cve_date": "2026-06-19T12:59:51.822Z",
+      "last_cve_date": "2026-06-19T13:15:39.453Z",
+      "years_active": 21,
+      "first_cve_year": 2006,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 2
+      },
+      "top_cwe_types": {
+        "CWE-284": 2
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-284",
+          2
+        ]
+      ]
+    },
+    {
+      "name": "illumos",
+      "assigner_org_id": "0ca53633-f0b5-4853-ba72-e0a2e62000d0",
+      "count": 2,
+      "rank": 337,
+      "first_cve_date": "2026-07-16T19:27:16.036Z",
+      "last_cve_date": "2026-07-16T19:29:13.931Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1,
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-122": 2,
+        "CWE-787": 1,
+        "CWE-367": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-122",
+          2
+        ],
+        [
+          "CWE-787",
+          1
+        ],
+        [
+          "CWE-367",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "WDC PSIRT",
+      "assigner_org_id": "cb3b742e-5145-4748-b44b-5ffd45bf3b6a",
+      "count": 1,
+      "rank": 338,
+      "first_cve_date": "2026-01-26T22:47:58.624Z",
+      "last_cve_date": "2026-01-26T22:47:58.624Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-427": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-427",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Carrier",
+      "assigner_org_id": "e24e6442-3ae1-4538-a7b8-7ac95586db8f",
+      "count": 1,
+      "rank": 339,
+      "first_cve_date": "2026-01-22T12:52:14.611Z",
+      "last_cve_date": "2026-01-22T12:52:14.611Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-257": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-257",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Pentraze",
+      "assigner_org_id": "41c37e40-543d-43a2-b660-2fee83ea851a",
+      "count": 1,
+      "rank": 340,
+      "first_cve_date": "2026-02-19T01:37:22.018Z",
+      "last_cve_date": "2026-02-19T01:37:22.018Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-863": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-863",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Bull",
+      "assigner_org_id": "5bcc34ac-0282-4e8a-96fc-046c583d3048",
+      "count": 1,
+      "rank": 341,
+      "first_cve_date": "2026-09-11T08:02:03.465Z",
+      "last_cve_date": "2026-09-11T08:02:03.465Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-258": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-258",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "KoreLogic",
+      "assigner_org_id": "bbf0bd87-ece2-41be-b873-96928ee8fab9",
+      "count": 1,
+      "rank": 342,
+      "first_cve_date": "2026-01-08T21:01:31.240Z",
+      "last_cve_date": "2026-01-08T21:01:31.240Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-926": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-926",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Panasonic_Holdings_Corporation",
+      "assigner_org_id": "2163caeb-3942-4e93-a74b-8c75338146ce",
+      "count": 1,
+      "rank": 343,
+      "first_cve_date": "2026-09-14T05:53:54.638Z",
+      "last_cve_date": "2026-09-14T05:53:54.638Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-120": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-120",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "larry_cashdollar",
+      "assigner_org_id": "461b2335-328f-427d-ae3d-eff7d6814455",
+      "count": 1,
+      "rank": 344,
+      "first_cve_date": "2026-01-13T15:12:53.126Z",
+      "last_cve_date": "2026-01-13T15:12:53.126Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-77": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 1,
+      "top_cwes": [
+        [
+          "CWE-77",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "spartans-security",
+      "assigner_org_id": "66fe30d5-b042-4547-a192-c18da4c41a81",
+      "count": 1,
+      "rank": 345,
+      "first_cve_date": "2026-02-23T01:24:47.676Z",
+      "last_cve_date": "2026-02-23T01:24:47.676Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "CERT"
+      ],
+      "severity_distribution": {
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-89": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-89",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "HW",
+      "assigner_org_id": "ff95705b-1a40-4639-8017-a58fa868baee",
+      "count": 1,
+      "rank": 346,
+      "first_cve_date": "2026-03-04T12:13:09.918Z",
+      "last_cve_date": "2026-03-04T12:13:09.918Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-552": 1,
+        "CWE-732": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-552",
+          1
+        ],
+        [
+          "CWE-732",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Nintendo",
+      "assigner_org_id": "60e0823a-f1a8-4923-bd51-812de398c42c",
+      "count": 1,
+      "rank": 347,
+      "first_cve_date": "2026-09-10T05:13:33.030Z",
+      "last_cve_date": "2026-09-10T05:13:33.030Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-121": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-121",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Roche",
+      "assigner_org_id": "5cdcf916-2b10-4ec8-bfc1-d054821e439e",
+      "count": 1,
+      "rank": 348,
+      "first_cve_date": "2026-06-02T13:23:45.761Z",
+      "last_cve_date": "2026-06-02T13:23:45.761Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-1392": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-1392",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "STAR_Labs",
+      "assigner_org_id": "b1571b85-cbc9-431f-830b-0c8155323a69",
+      "count": 1,
+      "rank": 349,
+      "first_cve_date": "2026-06-24T04:37:01.955Z",
+      "last_cve_date": "2026-06-24T04:37:01.955Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-125": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-125",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Proton",
+      "assigner_org_id": "b2fa7fcc-7d08-41f0-853b-11242c5539db",
+      "count": 1,
+      "rank": 350,
+      "first_cve_date": "2026-09-07T11:47:32.716Z",
+      "last_cve_date": "2026-09-07T11:47:32.716Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-79": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "ELAN",
+      "assigner_org_id": "36106deb-8e95-420b-a0a0-e70af5d245df",
+      "count": 1,
+      "rank": 351,
+      "first_cve_date": "2026-08-06T03:46:00.081Z",
+      "last_cve_date": "2026-08-06T03:46:00.081Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-121": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-121",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Sophos",
+      "assigner_org_id": "526a354d-e866-4174-ae7d-bac848e5c4c5",
+      "count": 1,
+      "rank": 352,
+      "first_cve_date": "2026-08-06T20:30:39.943Z",
+      "last_cve_date": "2026-08-06T20:30:39.943Z",
+      "years_active": 6,
+      "first_cve_year": 2021,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-285": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-285",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "AMI",
+      "assigner_org_id": "7e9044f1-7f56-4c38-8864-c0c7302263d6",
+      "count": 1,
+      "rank": 353,
+      "first_cve_date": "2026-09-08T14:02:30.089Z",
+      "last_cve_date": "2026-09-08T14:02:30.089Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-184": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-184",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "AlgoSec",
+      "assigner_org_id": "ca5f073f-8266-4d43-b3e3-6eb0bb18a738",
+      "count": 1,
+      "rank": 354,
+      "first_cve_date": "2026-09-08T10:44:32.657Z",
+      "last_cve_date": "2026-09-08T10:44:32.657Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-266": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-266",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "OMRON",
+      "assigner_org_id": "bba440f9-ef23-4224-aa62-7ac0935d18d1",
+      "count": 1,
+      "rank": 355,
+      "first_cve_date": "2026-04-15T04:11:29.716Z",
+      "last_cve_date": "2026-04-15T04:11:29.716Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-427": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-427",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Nutanix",
+      "assigner_org_id": "2ffdacf6-8681-47df-b023-4f11abd61c1d",
+      "count": 1,
+      "rank": 356,
+      "first_cve_date": "2026-04-28T13:06:35.686Z",
+      "last_cve_date": "2026-04-28T13:06:35.686Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-306": 1,
+        "CWE-862": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-306",
+          1
+        ],
+        [
+          "CWE-862",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Milestone",
+      "assigner_org_id": "cf45122d-9d50-442a-9b23-e05cde9943d8",
+      "count": 1,
+      "rank": 357,
+      "first_cve_date": "2026-07-14T09:45:22.651Z",
+      "last_cve_date": "2026-07-14T09:45:22.651Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Government"
+      ],
+      "severity_distribution": {
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-78": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "KrakenD",
+      "assigner_org_id": "e5bd9809-e237-4575-952b-81f8a96826ee",
+      "count": 1,
+      "rank": 358,
+      "first_cve_date": "2026-02-25T15:12:23.336Z",
+      "last_cve_date": "2026-02-25T15:12:23.336Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-404": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-404",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Intigriti",
+      "assigner_org_id": "3ba556a3-57d7-4c5d-b460-9d6daa180ee1",
+      "count": 1,
+      "rank": 359,
+      "first_cve_date": "2026-02-27T14:09:38.150Z",
+      "last_cve_date": "2026-02-27T14:09:38.150Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-79": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Spotfire",
+      "assigner_org_id": "8b479ca1-d558-42a2-87eb-a4751ba58a09",
+      "count": 1,
+      "rank": 360,
+      "first_cve_date": "2026-07-14T13:49:04.755Z",
+      "last_cve_date": "2026-07-14T13:49:04.755Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {},
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": []
+    },
+    {
+      "name": "TRO",
+      "assigner_org_id": "1b7e193f-2525-49a1-b171-84af8827c9eb",
+      "count": 1,
+      "rank": 361,
+      "first_cve_date": "2026-05-08T11:45:18.462Z",
+      "last_cve_date": "2026-05-08T11:45:18.462Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-78": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-78",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Crestron",
+      "assigner_org_id": "25b0b659-c4b4-483f-aecb-067757d23ef3",
+      "count": 1,
+      "rank": 362,
+      "first_cve_date": "2026-05-05T15:05:12.734Z",
+      "last_cve_date": "2026-05-05T15:05:12.734Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-88": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-88",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Echo",
+      "assigner_org_id": "abd028dc-c042-4c4d-9749-38d0f850af89",
+      "count": 1,
+      "rank": 363,
+      "first_cve_date": "2026-05-04T12:38:28.464Z",
+      "last_cve_date": "2026-05-04T12:38:28.464Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-125": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-125",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Logitech",
+      "assigner_org_id": "b573e801-1dd3-4adf-bd73-c9b814fbe067",
+      "count": 1,
+      "rank": 364,
+      "first_cve_date": "2026-09-14T07:27:36.817Z",
+      "last_cve_date": "2026-09-14T07:27:36.817Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-269": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-269",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "yandex",
+      "assigner_org_id": "a51c9250-e584-488d-808b-03e6f1386796",
+      "count": 1,
+      "rank": 365,
+      "first_cve_date": "2026-06-02T08:27:06.020Z",
+      "last_cve_date": "2026-06-02T08:27:06.020Z",
+      "years_active": 11,
+      "first_cve_year": 2016,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-280": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-280",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "TXOne",
+      "assigner_org_id": "3ad20294-822c-4ebc-9301-f9a7cf62d46e",
+      "count": 1,
+      "rank": 366,
+      "first_cve_date": "2026-07-17T03:50:13.217Z",
+      "last_cve_date": "2026-07-17T03:50:13.217Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-284": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-284",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "FSOFT",
+      "assigner_org_id": "5ac195ad-69e7-48e7-9c1e-bfc958c39761",
+      "count": 1,
+      "rank": 367,
+      "first_cve_date": "2026-04-13T02:27:53.206Z",
+      "last_cve_date": "2026-04-13T02:27:53.206Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-79": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-79",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "openGauss",
+      "assigner_org_id": "a1a479f7-907b-4ae8-a999-9148cadc9224",
+      "count": 1,
+      "rank": 368,
+      "first_cve_date": "2026-06-30T13:56:16.846Z",
+      "last_cve_date": "2026-06-30T13:56:16.846Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-416": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-416",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "crafter",
+      "assigner_org_id": "4ff2b028-869f-4b00-a7b2-05997f6f14fd",
+      "count": 1,
+      "rank": 369,
+      "first_cve_date": "2026-02-02T16:16:01.466Z",
+      "last_cve_date": "2026-02-02T16:16:01.466Z",
+      "years_active": 7,
+      "first_cve_year": 2020,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-913": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-913",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "JAMF",
+      "assigner_org_id": "67325c3f-c596-46c5-a235-e1a1e73abe4e",
+      "count": 1,
+      "rank": 370,
+      "first_cve_date": "2026-01-21T15:25:19.543Z",
+      "last_cve_date": "2026-01-21T15:25:19.543Z",
+      "years_active": 3,
+      "first_cve_year": 2024,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-305": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-305",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Hillstone",
+      "assigner_org_id": "2b565742-f273-46f9-b583-07c1fcdea31a",
+      "count": 1,
+      "rank": 371,
+      "first_cve_date": "2026-02-04T03:11:30.275Z",
+      "last_cve_date": "2026-02-04T03:11:30.275Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-434": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-434",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Yugabyte",
+      "assigner_org_id": "d4ae51d3-4db5-465e-bc8a-eb6768324078",
+      "count": 1,
+      "rank": 372,
+      "first_cve_date": "2026-02-05T11:38:28.291Z",
+      "last_cve_date": "2026-02-05T11:38:28.291Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-522": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-522",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "SoftIron",
+      "assigner_org_id": "0a72a055-908d-47f5-a16a-1f09049c16c6",
+      "count": 1,
+      "rank": 373,
+      "first_cve_date": "2026-02-20T16:23:16.498Z",
+      "last_cve_date": "2026-02-20T16:23:16.498Z",
+      "years_active": 4,
+      "first_cve_year": 2023,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-613": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-613",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "KNIME",
+      "assigner_org_id": "296541fb-a0e3-4ca7-ab3d-683e666d143e",
+      "count": 1,
+      "rank": 374,
+      "first_cve_date": "2026-03-24T08:15:16.512Z",
+      "last_cve_date": "2026-03-24T08:15:16.512Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Medium": 1
+      },
+      "top_cwe_types": {
+        "CWE-306": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-306",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "StrongDM",
+      "assigner_org_id": "ebf2cdfb-f390-4894-8ec9-f81bf1c57e6b",
+      "count": 1,
+      "rank": 375,
+      "first_cve_date": "2026-05-29T18:28:00.572Z",
+      "last_cve_date": "2026-05-29T18:28:00.572Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "Low": 1
+      },
+      "top_cwe_types": {
+        "CWE-312": 1,
+        "CWE-522": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-312",
+          1
+        ],
+        [
+          "CWE-522",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Vestel",
+      "assigner_org_id": "5431be70-064b-4f6a-be51-69eacabef109",
+      "count": 1,
+      "rank": 376,
+      "first_cve_date": "2026-08-07T13:32:45.790Z",
+      "last_cve_date": "2026-08-07T13:32:45.790Z",
+      "years_active": 1,
+      "first_cve_year": 2026,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-918": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-918",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "Danfoss",
+      "assigner_org_id": "d7ff35af-cf88-454c-bab9-af60602f10f8",
+      "count": 1,
+      "rank": 377,
+      "first_cve_date": "2026-08-26T05:36:02.006Z",
+      "last_cve_date": "2026-08-26T05:36:02.006Z",
+      "years_active": 2,
+      "first_cve_year": 2025,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Open Source"
+      ],
+      "severity_distribution": {
+        "Critical": 1
+      },
+      "top_cwe_types": {
+        "CWE-1191": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-1191",
+          1
+        ]
+      ]
+    },
+    {
+      "name": "LGE",
+      "assigner_org_id": "42f21055-226c-4bce-a3c8-ecf55a3551fb",
+      "count": 1,
+      "rank": 378,
+      "first_cve_date": "2026-07-30T01:50:16.571Z",
+      "last_cve_date": "2026-07-30T01:50:16.571Z",
+      "years_active": 5,
+      "first_cve_year": 2022,
+      "last_cve_year": 2026,
+      "is_official": true,
+      "activity_status": "Active",
+      "cna_types": [
+        "Vendor"
+      ],
+      "severity_distribution": {
+        "High": 1
+      },
+      "top_cwe_types": {
+        "CWE-89": 1
+      },
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "epss_elevated_count": 0,
+      "top_cwes": [
+        [
+          "CWE-89",
+          1
+        ]
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/web/data/cpe_analysis.json b/web/data/cpe_analysis.json
new file mode 100644
index 00000000000..1cd33d51957
--- /dev/null
+++ b/web/data/cpe_analysis.json
@@ -0,0 +1,624 @@
+{
+  "generated_at": "2026-09-23T22:54:06.010466",
+  "total_unique_cpes": 373603,
+  "total_cpe_entries": 2608086,
+  "total_cves_with_cpes": 317118,
+  "total_unique_vendors": 36588,
+  "total_unique_products": 114736,
+  "top_cpes": [
+    {
+      "cpe": "cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*",
+      "count": 51997,
+      "vendor": "linux",
+      "product": "linux_kernel",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:a:google:chrome:*:*:*:*:*:*:*:*",
+      "count": 6706,
+      "vendor": "google",
+      "product": "chrome",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:o:apple:macos:*:*:*:*:*:*:*:*",
+      "count": 5178,
+      "vendor": "apple",
+      "product": "macos",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:apple:iphone_os:*:*:*:*:*:*:*:*",
+      "count": 4593,
+      "vendor": "apple",
+      "product": "iphone_os",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2012:r2:*:*:*:*:*:*:*",
+      "count": 4320,
+      "vendor": "microsoft",
+      "product": "windows_server_2012",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2012:-:*:*:*:*:*:*:*",
+      "count": 4109,
+      "vendor": "microsoft",
+      "product": "windows_server_2012",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:debian:debian_linux:9.0:*:*:*:*:*:*:*",
+      "count": 3999,
+      "vendor": "debian",
+      "product": "debian_linux",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:debian:debian_linux:8.0:*:*:*:*:*:*:*",
+      "count": 3481,
+      "vendor": "debian",
+      "product": "debian_linux",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:debian:debian_linux:10.0:*:*:*:*:*:*:*",
+      "count": 3437,
+      "vendor": "debian",
+      "product": "debian_linux",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:a:gitlab:gitlab:*:*:*:*:enterprise:*:*:*",
+      "count": 3308,
+      "vendor": "gitlab",
+      "product": "gitlab",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:a:mozilla:firefox:*:*:*:*:*:*:*:*",
+      "count": 2868,
+      "vendor": "mozilla",
+      "product": "firefox",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:a:gitlab:gitlab:*:*:*:*:community:*:*:*",
+      "count": 2809,
+      "vendor": "gitlab",
+      "product": "gitlab",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:o:apple:mac_os_x:*:*:*:*:*:*:*:*",
+      "count": 2726,
+      "vendor": "apple",
+      "product": "mac_os_x",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2019:-:*:*:*:*:*:*:*",
+      "count": 2701,
+      "vendor": "microsoft",
+      "product": "windows_server_2019",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2016:-:*:*:*:*:*:*:*",
+      "count": 2641,
+      "vendor": "microsoft",
+      "product": "windows_server_2016",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2022:*:*:*:*:*:*:*:*",
+      "count": 2609,
+      "vendor": "microsoft",
+      "product": "windows_server_2022",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:apple:ipados:*:*:*:*:*:*:*:*",
+      "count": 2599,
+      "vendor": "apple",
+      "product": "ipados",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2019:*:*:*:*:*:*:*:*",
+      "count": 2497,
+      "vendor": "microsoft",
+      "product": "windows_server_2019",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2008:r2:sp1:*:*:*:*:x64:*",
+      "count": 2405,
+      "vendor": "microsoft",
+      "product": "windows_server_2008",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:a:adobe:acrobat_dc:*:*:*:*:classic:*:*:*",
+      "count": 2383,
+      "vendor": "adobe",
+      "product": "acrobat_dc",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:a:adobe:acrobat_reader_dc:*:*:*:*:classic:*:*:*",
+      "count": 2380,
+      "vendor": "adobe",
+      "product": "acrobat_reader_dc",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2016:*:*:*:*:*:*:*:*",
+      "count": 2335,
+      "vendor": "microsoft",
+      "product": "windows_server_2016",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:apple:tvos:*:*:*:*:*:*:*:*",
+      "count": 2150,
+      "vendor": "apple",
+      "product": "tvos",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_1809:*:*:*:*:*:*:x64:*",
+      "count": 2124,
+      "vendor": "microsoft",
+      "product": "windows_10_1809",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_1809:*:*:*:*:*:*:x86:*",
+      "count": 2069,
+      "vendor": "microsoft",
+      "product": "windows_10_1809",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:debian:debian_linux:11.0:*:*:*:*:*:*:*",
+      "count": 2060,
+      "vendor": "debian",
+      "product": "debian_linux",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:a:oracle:mysql:*:*:*:*:*:*:*:*",
+      "count": 2055,
+      "vendor": "oracle",
+      "product": "mysql",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:a:adobe:acrobat_dc:*:*:*:*:continuous:*:*:*",
+      "count": 2027,
+      "vendor": "adobe",
+      "product": "acrobat_dc",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:a:adobe:acrobat_reader_dc:*:*:*:*:continuous:*:*:*",
+      "count": 2015,
+      "vendor": "adobe",
+      "product": "acrobat_reader_dc",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:a:adobe:flash_player:*:*:*:*:*:*:*:*",
+      "count": 1993,
+      "vendor": "adobe",
+      "product": "flash_player",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:o:google:android:11.0:*:*:*:*:*:*:*",
+      "count": 1958,
+      "vendor": "google",
+      "product": "android",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_1607:*:*:*:*:*:*:x64:*",
+      "count": 1933,
+      "vendor": "microsoft",
+      "product": "windows_10_1607",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10:1607:*:*:*:*:*:*:*",
+      "count": 1914,
+      "vendor": "microsoft",
+      "product": "windows_10",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:apple:watchos:*:*:*:*:*:*:*:*",
+      "count": 1900,
+      "vendor": "apple",
+      "product": "watchos",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_1607:*:*:*:*:*:*:x86:*",
+      "count": 1888,
+      "vendor": "microsoft",
+      "product": "windows_10_1607",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10:-:*:*:*:*:*:*:*",
+      "count": 1886,
+      "vendor": "microsoft",
+      "product": "windows_10",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2025:*:*:*:*:*:*:*:*",
+      "count": 1847,
+      "vendor": "microsoft",
+      "product": "windows_server_2025",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:google:android:10.0:*:*:*:*:*:*:*",
+      "count": 1814,
+      "vendor": "google",
+      "product": "android",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2008:-:sp2:*:*:*:*:*:*",
+      "count": 1809,
+      "vendor": "microsoft",
+      "product": "windows_server_2008",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:a:f5:big-ip_access_policy_manager:*:*:*:*:*:*:*:*",
+      "count": 1794,
+      "vendor": "f5",
+      "product": "big-ip_access_policy_manager",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:o:google:android:12.0:*:*:*:*:*:*:*",
+      "count": 1781,
+      "vendor": "google",
+      "product": "android",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:canonical:ubuntu_linux:18.04:*:*:*:lts:*:*:*",
+      "count": 1775,
+      "vendor": "canonical",
+      "product": "ubuntu_linux",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_rt_8.1:-:*:*:*:*:*:*:*",
+      "count": 1775,
+      "vendor": "microsoft",
+      "product": "windows_rt_8.1",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10:1809:*:*:*:*:*:*:*",
+      "count": 1772,
+      "vendor": "microsoft",
+      "product": "windows_10",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:a:mozilla:thunderbird:*:*:*:*:*:*:*:*",
+      "count": 1692,
+      "vendor": "mozilla",
+      "product": "thunderbird",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:a:apple:safari:*:*:*:*:*:*:*:*",
+      "count": 1670,
+      "vendor": "apple",
+      "product": "safari",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:o:google:android:-:*:*:*:*:*:*:*",
+      "count": 1658,
+      "vendor": "google",
+      "product": "android",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:a:f5:big-ip_application_security_manager:*:*:*:*:*:*:*:*",
+      "count": 1626,
+      "vendor": "f5",
+      "product": "big-ip_application_security_manager",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2022_23h2:*:*:*:*:*:*:*:*",
+      "count": 1610,
+      "vendor": "microsoft",
+      "product": "windows_server_2022_23h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:a:f5:big-ip_advanced_firewall_manager:*:*:*:*:*:*:*:*",
+      "count": 1551,
+      "vendor": "f5",
+      "product": "big-ip_advanced_firewall_manager",
+      "type": "Application"
+    }
+  ],
+  "top_vendors": [
+    {
+      "vendor": "qualcomm",
+      "count": 208634
+    },
+    {
+      "vendor": "cisco",
+      "count": 191242
+    },
+    {
+      "vendor": "linux",
+      "count": 163315
+    },
+    {
+      "vendor": "microsoft",
+      "count": 155980
+    },
+    {
+      "vendor": "adobe",
+      "count": 96816
+    },
+    {
+      "vendor": "apple",
+      "count": 94702
+    },
+    {
+      "vendor": "mozilla",
+      "count": 85896
+    },
+    {
+      "vendor": "juniper",
+      "count": 75739
+    },
+    {
+      "vendor": "ibm",
+      "count": 73998
+    },
+    {
+      "vendor": "oracle",
+      "count": 71310
+    },
+    {
+      "vendor": "google",
+      "count": 64919
+    },
+    {
+      "vendor": "intel",
+      "count": 58771
+    },
+    {
+      "vendor": "sun",
+      "count": 56588
+    },
+    {
+      "vendor": "samsung",
+      "count": 39347
+    },
+    {
+      "vendor": "f5",
+      "count": 38132
+    },
+    {
+      "vendor": "redhat",
+      "count": 34321
+    },
+    {
+      "vendor": "hp",
+      "count": 32916
+    },
+    {
+      "vendor": "dell",
+      "count": 30795
+    },
+    {
+      "vendor": "apache",
+      "count": 21854
+    },
+    {
+      "vendor": "opera",
+      "count": 21541
+    }
+  ],
+  "top_products": [
+    {
+      "product": "linux_kernel",
+      "count": 163077
+    },
+    {
+      "product": "ios",
+      "count": 69388
+    },
+    {
+      "product": "junos",
+      "count": 65330
+    },
+    {
+      "product": "android",
+      "count": 59389
+    },
+    {
+      "product": "firefox",
+      "count": 37894
+    },
+    {
+      "product": "chrome",
+      "count": 36944
+    },
+    {
+      "product": "ios_xe",
+      "count": 33003
+    },
+    {
+      "product": "jre",
+      "count": 28704
+    },
+    {
+      "product": "jdk",
+      "count": 24356
+    },
+    {
+      "product": "seamonkey",
+      "count": 22185
+    },
+    {
+      "product": "opera_browser",
+      "count": 20879
+    },
+    {
+      "product": "safari",
+      "count": 19364
+    },
+    {
+      "product": "windows_10",
+      "count": 19340
+    },
+    {
+      "product": "flash_player",
+      "count": 19014
+    },
+    {
+      "product": "mac_os_x",
+      "count": 18211
+    },
+    {
+      "product": "php",
+      "count": 16569
+    },
+    {
+      "product": "debian_linux",
+      "count": 16358
+    },
+    {
+      "product": "itunes",
+      "count": 15472
+    },
+    {
+      "product": "adaptive_security_appliance_software",
+      "count": 14577
+    },
+    {
+      "product": "thunderbird",
+      "count": 14499
+    }
+  ],
+  "cpe_type_distribution": [
+    {
+      "type": "Application",
+      "count": 1355741,
+      "percentage": 52.0
+    },
+    {
+      "type": "Operating System",
+      "count": 1197244,
+      "percentage": 45.9
+    },
+    {
+      "type": "Hardware",
+      "count": 55101,
+      "percentage": 2.1
+    }
+  ],
+  "cves_with_most_cpes": [
+    {
+      "cve": "CVE-2016-1409",
+      "cpe_count": 4891
+    },
+    {
+      "cve": "CVE-2017-6770",
+      "cpe_count": 3788
+    },
+    {
+      "cve": "CVE-2025-20169",
+      "cpe_count": 3396
+    },
+    {
+      "cve": "CVE-2025-20170",
+      "cpe_count": 3395
+    },
+    {
+      "cve": "CVE-2016-6380",
+      "cpe_count": 3334
+    },
+    {
+      "cve": "CVE-2021-3942",
+      "cpe_count": 2942
+    },
+    {
+      "cve": "CVE-2024-20433",
+      "cpe_count": 2434
+    },
+    {
+      "cve": "CVE-2008-4609",
+      "cpe_count": 2046
+    },
+    {
+      "cve": "CVE-2020-3201",
+      "cpe_count": 1917
+    },
+    {
+      "cve": "CVE-2019-1761",
+      "cpe_count": 1761
+    },
+    {
+      "cve": "CVE-2021-34705",
+      "cpe_count": 1721
+    },
+    {
+      "cve": "CVE-2022-20920",
+      "cpe_count": 1596
+    },
+    {
+      "cve": "CVE-2025-20171",
+      "cpe_count": 1579
+    },
+    {
+      "cve": "CVE-2009-5040",
+      "cpe_count": 1550
+    },
+    {
+      "cve": "CVE-2007-5381",
+      "cpe_count": 1429
+    },
+    {
+      "cve": "CVE-2025-20173",
+      "cpe_count": 1411
+    },
+    {
+      "cve": "CVE-2011-2395",
+      "cpe_count": 1409
+    },
+    {
+      "cve": "CVE-2017-5753",
+      "cpe_count": 1388
+    },
+    {
+      "cve": "CVE-2025-20175",
+      "cpe_count": 1348
+    },
+    {
+      "cve": "CVE-2020-0551",
+      "cpe_count": 1321
+    }
+  ],
+  "average_cpes_per_cve": 8.2
+}
\ No newline at end of file
diff --git a/web/data/cpe_analysis_current_year.json b/web/data/cpe_analysis_current_year.json
new file mode 100644
index 00000000000..1e286954047
--- /dev/null
+++ b/web/data/cpe_analysis_current_year.json
@@ -0,0 +1,445 @@
+{
+  "generated_at": "2026-09-23T22:54:28.170606",
+  "year": 2026,
+  "total_unique_cpes": 17934,
+  "total_cpe_entries": 187778,
+  "total_cves_with_cpes": 34490,
+  "total_unique_vendors": 2840,
+  "total_unique_products": 8111,
+  "top_cpes": [
+    {
+      "cpe": "cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*",
+      "count": 12770,
+      "vendor": "linux",
+      "product": "linux_kernel",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:a:google:chrome:*:*:*:*:*:*:*:*",
+      "count": 2878,
+      "vendor": "google",
+      "product": "chrome",
+      "type": "Application"
+    },
+    {
+      "cpe": "cpe:2.3:o:apple:macos:*:*:*:*:*:*:*:*",
+      "count": 1361,
+      "vendor": "apple",
+      "product": "macos",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_11_24h2:*:*:*:*:*:*:x64:*",
+      "count": 1325,
+      "vendor": "microsoft",
+      "product": "windows_11_24h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_11_25h2:*:*:*:*:*:*:x64:*",
+      "count": 1323,
+      "vendor": "microsoft",
+      "product": "windows_11_25h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_11_26h1:*:*:*:*:*:*:x64:*",
+      "count": 1323,
+      "vendor": "microsoft",
+      "product": "windows_11_26h1",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_11_24h2:*:*:*:*:*:*:arm64:*",
+      "count": 1321,
+      "vendor": "microsoft",
+      "product": "windows_11_24h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_11_25h2:*:*:*:*:*:*:arm64:*",
+      "count": 1321,
+      "vendor": "microsoft",
+      "product": "windows_11_25h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_11_26h1:*:*:*:*:*:*:arm64:*",
+      "count": 1321,
+      "vendor": "microsoft",
+      "product": "windows_11_26h1",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_1809:*:*:*:*:*:*:x64:*",
+      "count": 1294,
+      "vendor": "microsoft",
+      "product": "windows_10_1809",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_1809:*:*:*:*:*:*:x86:*",
+      "count": 1280,
+      "vendor": "microsoft",
+      "product": "windows_10_1809",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2022:*:*:*:*:*:*:*:*",
+      "count": 1213,
+      "vendor": "microsoft",
+      "product": "windows_server_2022",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_22h2:*:*:*:*:*:*:x64:*",
+      "count": 1154,
+      "vendor": "microsoft",
+      "product": "windows_10_22h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_21h2:*:*:*:*:*:*:x64:*",
+      "count": 1153,
+      "vendor": "microsoft",
+      "product": "windows_10_21h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_22h2:*:*:*:*:*:*:arm64:*",
+      "count": 1140,
+      "vendor": "microsoft",
+      "product": "windows_10_22h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_21h2:*:*:*:*:*:*:arm64:*",
+      "count": 1139,
+      "vendor": "microsoft",
+      "product": "windows_10_21h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_21h2:*:*:*:*:*:*:x86:*",
+      "count": 1138,
+      "vendor": "microsoft",
+      "product": "windows_10_21h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2019:*:*:*:*:*:*:*:*",
+      "count": 1137,
+      "vendor": "microsoft",
+      "product": "windows_server_2019",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_22h2:*:*:*:*:*:*:x86:*",
+      "count": 1137,
+      "vendor": "microsoft",
+      "product": "windows_10_22h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2025:*:*:*:*:*:*:*:*",
+      "count": 1120,
+      "vendor": "microsoft",
+      "product": "windows_server_2025",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_1607:*:*:*:*:*:*:x64:*",
+      "count": 1106,
+      "vendor": "microsoft",
+      "product": "windows_10_1607",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_10_1607:*:*:*:*:*:*:x86:*",
+      "count": 1096,
+      "vendor": "microsoft",
+      "product": "windows_10_1607",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2016:*:*:*:*:*:*:*:*",
+      "count": 978,
+      "vendor": "microsoft",
+      "product": "windows_server_2016",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_11_23h2:*:*:*:*:*:*:x64:*",
+      "count": 957,
+      "vendor": "microsoft",
+      "product": "windows_11_23h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_11_23h2:*:*:*:*:*:*:arm64:*",
+      "count": 956,
+      "vendor": "microsoft",
+      "product": "windows_11_23h2",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2012:r2:*:*:*:*:*:*:*",
+      "count": 880,
+      "vendor": "microsoft",
+      "product": "windows_server_2012",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:microsoft:windows_server_2012:-:*:*:*:*:*:*:*",
+      "count": 840,
+      "vendor": "microsoft",
+      "product": "windows_server_2012",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:linux:linux_kernel:7.0:rc1:*:*:*:*:*:*",
+      "count": 812,
+      "vendor": "linux",
+      "product": "linux_kernel",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:linux:linux_kernel:7.0:rc2:*:*:*:*:*:*",
+      "count": 749,
+      "vendor": "linux",
+      "product": "linux_kernel",
+      "type": "Operating System"
+    },
+    {
+      "cpe": "cpe:2.3:o:linux:linux_kernel:7.0:rc3:*:*:*:*:*:*",
+      "count": 697,
+      "vendor": "linux",
+      "product": "linux_kernel",
+      "type": "Operating System"
+    }
+  ],
+  "top_vendors": [
+    {
+      "vendor": "microsoft",
+      "count": 36386
+    },
+    {
+      "vendor": "linux",
+      "count": 23704
+    },
+    {
+      "vendor": "adobe",
+      "count": 13898
+    },
+    {
+      "vendor": "qualcomm",
+      "count": 12794
+    },
+    {
+      "vendor": "cisco",
+      "count": 10996
+    },
+    {
+      "vendor": "samsung",
+      "count": 6350
+    },
+    {
+      "vendor": "oracle",
+      "count": 4552
+    },
+    {
+      "vendor": "ibm",
+      "count": 4371
+    },
+    {
+      "vendor": "coollabs",
+      "count": 4211
+    },
+    {
+      "vendor": "paloaltonetworks",
+      "count": 4095
+    },
+    {
+      "vendor": "google",
+      "count": 4024
+    },
+    {
+      "vendor": "f5",
+      "count": 3513
+    },
+    {
+      "vendor": "juniper",
+      "count": 3349
+    },
+    {
+      "vendor": "apple",
+      "count": 3347
+    },
+    {
+      "vendor": "checkmk",
+      "count": 1788
+    }
+  ],
+  "top_products": [
+    {
+      "product": "linux_kernel",
+      "count": 23704
+    },
+    {
+      "product": "android",
+      "count": 7006
+    },
+    {
+      "product": "commerce",
+      "count": 4224
+    },
+    {
+      "product": "coolify",
+      "count": 4211
+    },
+    {
+      "product": "pan-os",
+      "count": 3686
+    },
+    {
+      "product": "windows_10_22h2",
+      "count": 3542
+    },
+    {
+      "product": "windows_10_21h2",
+      "count": 3541
+    },
+    {
+      "product": "commerce_b2b",
+      "count": 3329
+    },
+    {
+      "product": "chrome",
+      "count": 2884
+    },
+    {
+      "product": "ios_xe",
+      "count": 2811
+    },
+    {
+      "product": "windows_11_24h2",
+      "count": 2782
+    },
+    {
+      "product": "windows_11_25h2",
+      "count": 2780
+    },
+    {
+      "product": "windows_11_26h1",
+      "count": 2680
+    },
+    {
+      "product": "windows_10_1809",
+      "count": 2584
+    },
+    {
+      "product": "magento",
+      "count": 2315
+    }
+  ],
+  "cpe_type_distribution": [
+    {
+      "type": "Operating System",
+      "count": 105080,
+      "percentage": 56.0
+    },
+    {
+      "type": "Application",
+      "count": 82650,
+      "percentage": 44.0
+    },
+    {
+      "type": "Hardware",
+      "count": 48,
+      "percentage": 0.0
+    }
+  ],
+  "cves_with_most_cpes": [
+    {
+      "cve": "CVE-2026-20012",
+      "cpe_count": 1271
+    },
+    {
+      "cve": "CVE-2025-64419",
+      "cpe_count": 435
+    },
+    {
+      "cve": "CVE-2026-20301",
+      "cpe_count": 427
+    },
+    {
+      "cve": "CVE-2025-64422",
+      "cpe_count": 426
+    },
+    {
+      "cve": "CVE-2025-64420",
+      "cpe_count": 425
+    },
+    {
+      "cve": "CVE-2025-64421",
+      "cpe_count": 425
+    },
+    {
+      "cve": "CVE-2025-64423",
+      "cpe_count": 425
+    },
+    {
+      "cve": "CVE-2025-64424",
+      "cpe_count": 425
+    },
+    {
+      "cve": "CVE-2025-64425",
+      "cpe_count": 425
+    },
+    {
+      "cve": "CVE-2025-59156",
+      "cpe_count": 408
+    },
+    {
+      "cve": "CVE-2025-59157",
+      "cpe_count": 408
+    },
+    {
+      "cve": "CVE-2025-59158",
+      "cpe_count": 408
+    },
+    {
+      "cve": "CVE-2026-25275",
+      "cpe_count": 376
+    },
+    {
+      "cve": "CVE-2026-45321",
+      "cpe_count": 343
+    },
+    {
+      "cve": "CVE-2025-47331",
+      "cpe_count": 299
+    },
+    {
+      "cve": "CVE-2026-20124",
+      "cpe_count": 277
+    },
+    {
+      "cve": "CVE-2026-24085",
+      "cpe_count": 273
+    },
+    {
+      "cve": "CVE-2026-24091",
+      "cpe_count": 273
+    },
+    {
+      "cve": "CVE-2026-20267",
+      "cpe_count": 267
+    },
+    {
+      "cve": "CVE-2026-20268",
+      "cpe_count": 267
+    }
+  ],
+  "average_cpes_per_cve": 5.4
+}
\ No newline at end of file
diff --git a/web/data/cve_1999.json b/web/data/cve_1999.json
new file mode 100644
index 00000000000..8a1baba6a38
--- /dev/null
+++ b/web/data/cve_1999.json
@@ -0,0 +1,672 @@
+{
+  "year": 1999,
+  "total_cves": 894,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 153,
+      "2": 58,
+      "3": 52,
+      "4": 39,
+      "5": 54,
+      "6": 37,
+      "7": 40,
+      "8": 60,
+      "9": 60,
+      "10": 57,
+      "11": 83,
+      "12": 201
+    },
+    "daily_analysis": {
+      "total_days": 256,
+      "avg_per_day": 3.49,
+      "highest_day": {
+        "date": "1999-01-01",
+        "count": 112
+      },
+      "lowest_day": {
+        "date": "1999-01-05",
+        "count": 1
+      },
+      "daily_counts": {
+        "1999-01-01": 112,
+        "1999-01-02": 4,
+        "1999-01-03": 3,
+        "1999-01-04": 2,
+        "1999-01-05": 1,
+        "1999-01-06": 2,
+        "1999-01-07": 1,
+        "1999-01-08": 0,
+        "1999-01-09": 0,
+        "1999-01-10": 1,
+        "1999-01-11": 1,
+        "1999-01-12": 0,
+        "1999-01-13": 0,
+        "1999-01-14": 3,
+        "1999-01-15": 0,
+        "1999-01-16": 0,
+        "1999-01-17": 2,
+        "1999-01-18": 0,
+        "1999-01-19": 2,
+        "1999-01-20": 0,
+        "1999-01-21": 2,
+        "1999-01-22": 0,
+        "1999-01-23": 0,
+        "1999-01-24": 1,
+        "1999-01-25": 4,
+        "1999-01-26": 4,
+        "1999-01-27": 3,
+        "1999-01-28": 2,
+        "1999-01-29": 2,
+        "1999-01-30": 1,
+        "1999-01-31": 0,
+        "1999-02-01": 6,
+        "1999-02-02": 5,
+        "1999-02-03": 0,
+        "1999-02-04": 2,
+        "1999-02-05": 0,
+        "1999-02-06": 1,
+        "1999-02-07": 0,
+        "1999-02-08": 2,
+        "1999-02-09": 3,
+        "1999-02-10": 2,
+        "1999-02-11": 2,
+        "1999-02-12": 2,
+        "1999-02-13": 0,
+        "1999-02-14": 1,
+        "1999-02-15": 2,
+        "1999-02-16": 3,
+        "1999-02-17": 3,
+        "1999-02-18": 3,
+        "1999-02-19": 8,
+        "1999-02-20": 2,
+        "1999-02-21": 1,
+        "1999-02-22": 4,
+        "1999-02-23": 1,
+        "1999-02-24": 1,
+        "1999-02-25": 3,
+        "1999-02-26": 1,
+        "1999-02-27": 0,
+        "1999-02-28": 0,
+        "1999-03-01": 22,
+        "1999-03-02": 1,
+        "1999-03-03": 0,
+        "1999-03-04": 3,
+        "1999-03-05": 1,
+        "1999-03-06": 0,
+        "1999-03-07": 1,
+        "1999-03-08": 4,
+        "1999-03-09": 1,
+        "1999-03-10": 0,
+        "1999-03-11": 3,
+        "1999-03-12": 1,
+        "1999-03-13": 0,
+        "1999-03-14": 0,
+        "1999-03-15": 0,
+        "1999-03-16": 0,
+        "1999-03-17": 4,
+        "1999-03-18": 2,
+        "1999-03-19": 0,
+        "1999-03-20": 0,
+        "1999-03-21": 2,
+        "1999-03-22": 2,
+        "1999-03-23": 2,
+        "1999-03-24": 0,
+        "1999-03-25": 0,
+        "1999-03-26": 1,
+        "1999-03-27": 0,
+        "1999-03-28": 0,
+        "1999-03-29": 0,
+        "1999-03-30": 1,
+        "1999-03-31": 1,
+        "1999-04-01": 12,
+        "1999-04-02": 0,
+        "1999-04-03": 0,
+        "1999-04-04": 0,
+        "1999-04-05": 3,
+        "1999-04-06": 1,
+        "1999-04-07": 3,
+        "1999-04-08": 0,
+        "1999-04-09": 6,
+        "1999-04-10": 0,
+        "1999-04-11": 0,
+        "1999-04-12": 2,
+        "1999-04-13": 0,
+        "1999-04-14": 1,
+        "1999-04-15": 1,
+        "1999-04-16": 0,
+        "1999-04-17": 0,
+        "1999-04-18": 0,
+        "1999-04-19": 1,
+        "1999-04-20": 3,
+        "1999-04-21": 3,
+        "1999-04-22": 0,
+        "1999-04-23": 1,
+        "1999-04-24": 0,
+        "1999-04-25": 0,
+        "1999-04-26": 0,
+        "1999-04-27": 1,
+        "1999-04-28": 0,
+        "1999-04-29": 1,
+        "1999-04-30": 0,
+        "1999-05-01": 8,
+        "1999-05-02": 0,
+        "1999-05-03": 0,
+        "1999-05-04": 2,
+        "1999-05-05": 1,
+        "1999-05-06": 3,
+        "1999-05-07": 6,
+        "1999-05-08": 1,
+        "1999-05-09": 0,
+        "1999-05-10": 1,
+        "1999-05-11": 5,
+        "1999-05-12": 3,
+        "1999-05-13": 1,
+        "1999-05-14": 0,
+        "1999-05-15": 1,
+        "1999-05-16": 0,
+        "1999-05-17": 4,
+        "1999-05-18": 0,
+        "1999-05-19": 3,
+        "1999-05-20": 1,
+        "1999-05-21": 1,
+        "1999-05-22": 0,
+        "1999-05-23": 1,
+        "1999-05-24": 1,
+        "1999-05-25": 2,
+        "1999-05-26": 3,
+        "1999-05-27": 3,
+        "1999-05-28": 1,
+        "1999-05-29": 0,
+        "1999-05-30": 0,
+        "1999-05-31": 2,
+        "1999-06-01": 7,
+        "1999-06-02": 0,
+        "1999-06-03": 2,
+        "1999-06-04": 0,
+        "1999-06-05": 1,
+        "1999-06-06": 1,
+        "1999-06-07": 1,
+        "1999-06-08": 1,
+        "1999-06-09": 2,
+        "1999-06-10": 2,
+        "1999-06-11": 1,
+        "1999-06-12": 1,
+        "1999-06-13": 0,
+        "1999-06-14": 0,
+        "1999-06-15": 0,
+        "1999-06-16": 2,
+        "1999-06-17": 0,
+        "1999-06-18": 0,
+        "1999-06-19": 0,
+        "1999-06-20": 0,
+        "1999-06-21": 0,
+        "1999-06-22": 1,
+        "1999-06-23": 3,
+        "1999-06-24": 2,
+        "1999-06-25": 2,
+        "1999-06-26": 1,
+        "1999-06-27": 0,
+        "1999-06-28": 3,
+        "1999-06-29": 1,
+        "1999-06-30": 3,
+        "1999-07-01": 5,
+        "1999-07-02": 1,
+        "1999-07-03": 1,
+        "1999-07-04": 0,
+        "1999-07-05": 0,
+        "1999-07-06": 3,
+        "1999-07-07": 1,
+        "1999-07-08": 0,
+        "1999-07-09": 1,
+        "1999-07-10": 1,
+        "1999-07-11": 1,
+        "1999-07-12": 0,
+        "1999-07-13": 1,
+        "1999-07-14": 1,
+        "1999-07-15": 2,
+        "1999-07-16": 0,
+        "1999-07-17": 0,
+        "1999-07-18": 0,
+        "1999-07-19": 3,
+        "1999-07-20": 3,
+        "1999-07-21": 4,
+        "1999-07-22": 0,
+        "1999-07-23": 1,
+        "1999-07-24": 0,
+        "1999-07-25": 1,
+        "1999-07-26": 0,
+        "1999-07-27": 1,
+        "1999-07-28": 2,
+        "1999-07-29": 3,
+        "1999-07-30": 4,
+        "1999-07-31": 0,
+        "1999-08-01": 2,
+        "1999-08-02": 0,
+        "1999-08-03": 3,
+        "1999-08-04": 0,
+        "1999-08-05": 2,
+        "1999-08-06": 2,
+        "1999-08-07": 1,
+        "1999-08-08": 2,
+        "1999-08-09": 4,
+        "1999-08-10": 1,
+        "1999-08-11": 5,
+        "1999-08-12": 2,
+        "1999-08-13": 1,
+        "1999-08-14": 0,
+        "1999-08-15": 0,
+        "1999-08-16": 3,
+        "1999-08-17": 1,
+        "1999-08-18": 2,
+        "1999-08-19": 5,
+        "1999-08-20": 5,
+        "1999-08-21": 2,
+        "1999-08-22": 3,
+        "1999-08-23": 1,
+        "1999-08-24": 2,
+        "1999-08-25": 4,
+        "1999-08-26": 1,
+        "1999-08-27": 2,
+        "1999-08-28": 0,
+        "1999-08-29": 0,
+        "1999-08-30": 2,
+        "1999-08-31": 2,
+        "1999-09-01": 5,
+        "1999-09-02": 4,
+        "1999-09-03": 2,
+        "1999-09-04": 0,
+        "1999-09-05": 2,
+        "1999-09-06": 0,
+        "1999-09-07": 1,
+        "1999-09-08": 1,
+        "1999-09-09": 2,
+        "1999-09-10": 3,
+        "1999-09-11": 0,
+        "1999-09-12": 1,
+        "1999-09-13": 8,
+        "1999-09-14": 0,
+        "1999-09-15": 1,
+        "1999-09-16": 5,
+        "1999-09-17": 2,
+        "1999-09-18": 0,
+        "1999-09-19": 0,
+        "1999-09-20": 1,
+        "1999-09-21": 1,
+        "1999-09-22": 2,
+        "1999-09-23": 6,
+        "1999-09-24": 3,
+        "1999-09-25": 0,
+        "1999-09-26": 1,
+        "1999-09-27": 2,
+        "1999-09-28": 2,
+        "1999-09-29": 1,
+        "1999-09-30": 4,
+        "1999-10-01": 9,
+        "1999-10-02": 0,
+        "1999-10-03": 0,
+        "1999-10-04": 6,
+        "1999-10-05": 3,
+        "1999-10-06": 2,
+        "1999-10-07": 3,
+        "1999-10-08": 3,
+        "1999-10-09": 0,
+        "1999-10-10": 0,
+        "1999-10-11": 1,
+        "1999-10-12": 0,
+        "1999-10-13": 2,
+        "1999-10-14": 0,
+        "1999-10-15": 1,
+        "1999-10-16": 0,
+        "1999-10-17": 1,
+        "1999-10-18": 1,
+        "1999-10-19": 0,
+        "1999-10-20": 1,
+        "1999-10-21": 3,
+        "1999-10-22": 4,
+        "1999-10-23": 3,
+        "1999-10-24": 1,
+        "1999-10-25": 2,
+        "1999-10-26": 4,
+        "1999-10-27": 0,
+        "1999-10-28": 4,
+        "1999-10-29": 1,
+        "1999-10-30": 1,
+        "1999-10-31": 1,
+        "1999-11-01": 7,
+        "1999-11-02": 5,
+        "1999-11-03": 2,
+        "1999-11-04": 9,
+        "1999-11-05": 0,
+        "1999-11-06": 0,
+        "1999-11-07": 2,
+        "1999-11-08": 5,
+        "1999-11-09": 6,
+        "1999-11-10": 8,
+        "1999-11-11": 1,
+        "1999-11-12": 2,
+        "1999-11-13": 1,
+        "1999-11-14": 2,
+        "1999-11-15": 1,
+        "1999-11-16": 4,
+        "1999-11-17": 4,
+        "1999-11-18": 2,
+        "1999-11-19": 3,
+        "1999-11-20": 1,
+        "1999-11-21": 0,
+        "1999-11-22": 1,
+        "1999-11-23": 2,
+        "1999-11-24": 4,
+        "1999-11-25": 3,
+        "1999-11-26": 0,
+        "1999-11-27": 0,
+        "1999-11-28": 0,
+        "1999-11-29": 4,
+        "1999-11-30": 4,
+        "1999-12-01": 16,
+        "1999-12-02": 6,
+        "1999-12-03": 7,
+        "1999-12-04": 1,
+        "1999-12-05": 2,
+        "1999-12-06": 2,
+        "1999-12-07": 2,
+        "1999-12-08": 2,
+        "1999-12-09": 3,
+        "1999-12-10": 2,
+        "1999-12-11": 0,
+        "1999-12-12": 2,
+        "1999-12-13": 3,
+        "1999-12-14": 3,
+        "1999-12-15": 3,
+        "1999-12-16": 6,
+        "1999-12-17": 0,
+        "1999-12-18": 0,
+        "1999-12-19": 2,
+        "1999-12-20": 2,
+        "1999-12-21": 7,
+        "1999-12-22": 9,
+        "1999-12-23": 4,
+        "1999-12-24": 1,
+        "1999-12-25": 3,
+        "1999-12-26": 2,
+        "1999-12-27": 5,
+        "1999-12-28": 5,
+        "1999-12-29": 5,
+        "1999-12-30": 4,
+        "1999-12-31": 92
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 894,
+      "severity_distribution": {
+        "UNKNOWN": 894
+      },
+      "score_distribution": {
+        "10.0": 159,
+        "5.0": 235,
+        "7.5": 130,
+        "4.6": 83,
+        "5.1": 18,
+        "3.7": 1,
+        "0.0": 14,
+        "6.4": 13,
+        "7.2": 115,
+        "4.9": 1,
+        "2.1": 70,
+        "7.8": 7,
+        "2.6": 16,
+        "6.2": 4,
+        "9.3": 3,
+        "1.2": 4,
+        "3.6": 8,
+        "7.6": 5,
+        "7.1": 2,
+        "4.0": 2,
+        "9.0": 1,
+        "4.3": 2,
+        "3.5": 1
+      }
+    },
+    "v3.1": {
+      "total": 9,
+      "severity_distribution": {
+        "HIGH": 5,
+        "CRITICAL": 3,
+        "MEDIUM": 1
+      },
+      "score_distribution": {
+        "7.3": 1,
+        "7.5": 2,
+        "9.8": 3,
+        "8.2": 1,
+        "7.8": 1,
+        "5.5": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 110,
+      "epss_gt_0_5": 6,
+      "epss_gt_0_9": 0
+    }
+  },
+  "kev": {
+    "kev_count": 0
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 173
+      },
+      {
+        "name": "Sun",
+        "count": 55
+      },
+      {
+        "name": "Redhat",
+        "count": 40
+      },
+      {
+        "name": "Debian",
+        "count": 27
+      },
+      {
+        "name": "Ibm",
+        "count": 22
+      },
+      {
+        "name": "Cisco",
+        "count": 21
+      },
+      {
+        "name": "Netscape",
+        "count": 21
+      },
+      {
+        "name": "Sco",
+        "count": 20
+      },
+      {
+        "name": "Linux",
+        "count": 19
+      },
+      {
+        "name": "Hp",
+        "count": 18
+      },
+      {
+        "name": "Suse",
+        "count": 18
+      },
+      {
+        "name": "Freebsd",
+        "count": 18
+      },
+      {
+        "name": "Caldera",
+        "count": 13
+      },
+      {
+        "name": "Netbsd",
+        "count": 13
+      },
+      {
+        "name": "Openbsd",
+        "count": 13
+      },
+      {
+        "name": "Sgi",
+        "count": 10
+      },
+      {
+        "name": "Ipswitch",
+        "count": 8
+      },
+      {
+        "name": "Apache",
+        "count": 8
+      },
+      {
+        "name": "Novell",
+        "count": 8
+      },
+      {
+        "name": "Isc",
+        "count": 8
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-200",
+        "count": 9
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 8
+      },
+      {
+        "cwe": "CWE-16",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-193",
+        "count": 2
+      },
+      {
+        "cwe": "CWE-19",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-276",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-384",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-120",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-362",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-346",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-665",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-772",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-307",
+        "count": 1
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 894
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 458
+      },
+      {
+        "tag": "Patch",
+        "count": 336
+      },
+      {
+        "tag": "Exploit",
+        "count": 236
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 48
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 44
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 34
+      },
+      {
+        "tag": "Broken Link",
+        "count": 20
+      },
+      {
+        "tag": "Mailing List",
+        "count": 8
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 6
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:42.514064",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2000.json b/web/data/cve_2000.json
new file mode 100644
index 00000000000..48b17a2d518
--- /dev/null
+++ b/web/data/cve_2000.json
@@ -0,0 +1,674 @@
+{
+  "year": 2000,
+  "total_cves": 1019,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 68,
+      "2": 86,
+      "3": 57,
+      "4": 79,
+      "5": 110,
+      "6": 119,
+      "7": 74,
+      "8": 3,
+      "9": 3,
+      "10": 135,
+      "11": 73,
+      "12": 212
+    },
+    "daily_analysis": {
+      "total_days": 197,
+      "avg_per_day": 5.17,
+      "highest_day": {
+        "date": "2000-10-20",
+        "count": 130
+      },
+      "lowest_day": {
+        "date": "2000-01-07",
+        "count": 1
+      },
+      "daily_counts": {
+        "2000-01-01": 3,
+        "2000-01-02": 3,
+        "2000-01-03": 0,
+        "2000-01-04": 13,
+        "2000-01-05": 2,
+        "2000-01-06": 3,
+        "2000-01-07": 1,
+        "2000-01-08": 2,
+        "2000-01-09": 0,
+        "2000-01-10": 3,
+        "2000-01-11": 4,
+        "2000-01-12": 4,
+        "2000-01-13": 2,
+        "2000-01-14": 0,
+        "2000-01-15": 0,
+        "2000-01-16": 0,
+        "2000-01-17": 5,
+        "2000-01-18": 4,
+        "2000-01-19": 1,
+        "2000-01-20": 2,
+        "2000-01-21": 3,
+        "2000-01-22": 0,
+        "2000-01-23": 0,
+        "2000-01-24": 1,
+        "2000-01-25": 0,
+        "2000-01-26": 4,
+        "2000-01-27": 3,
+        "2000-01-28": 0,
+        "2000-01-29": 2,
+        "2000-01-30": 1,
+        "2000-01-31": 2,
+        "2000-02-01": 20,
+        "2000-02-02": 3,
+        "2000-02-03": 5,
+        "2000-02-04": 3,
+        "2000-02-05": 1,
+        "2000-02-06": 1,
+        "2000-02-07": 2,
+        "2000-02-08": 4,
+        "2000-02-09": 0,
+        "2000-02-10": 1,
+        "2000-02-11": 3,
+        "2000-02-12": 1,
+        "2000-02-13": 0,
+        "2000-02-14": 1,
+        "2000-02-15": 3,
+        "2000-02-16": 4,
+        "2000-02-17": 1,
+        "2000-02-18": 3,
+        "2000-02-19": 0,
+        "2000-02-20": 1,
+        "2000-02-21": 4,
+        "2000-02-22": 0,
+        "2000-02-23": 4,
+        "2000-02-24": 6,
+        "2000-02-25": 1,
+        "2000-02-26": 1,
+        "2000-02-27": 3,
+        "2000-02-28": 6,
+        "2000-02-29": 4,
+        "2000-03-01": 3,
+        "2000-03-02": 4,
+        "2000-03-03": 2,
+        "2000-03-04": 1,
+        "2000-03-05": 2,
+        "2000-03-06": 1,
+        "2000-03-07": 1,
+        "2000-03-08": 2,
+        "2000-03-09": 3,
+        "2000-03-10": 3,
+        "2000-03-11": 3,
+        "2000-03-12": 0,
+        "2000-03-13": 1,
+        "2000-03-14": 2,
+        "2000-03-15": 4,
+        "2000-03-16": 1,
+        "2000-03-17": 3,
+        "2000-03-18": 0,
+        "2000-03-19": 0,
+        "2000-03-20": 2,
+        "2000-03-21": 2,
+        "2000-03-22": 2,
+        "2000-03-23": 1,
+        "2000-03-24": 0,
+        "2000-03-25": 2,
+        "2000-03-26": 1,
+        "2000-03-27": 3,
+        "2000-03-28": 0,
+        "2000-03-29": 1,
+        "2000-03-30": 3,
+        "2000-03-31": 4,
+        "2000-04-01": 1,
+        "2000-04-02": 0,
+        "2000-04-03": 4,
+        "2000-04-04": 1,
+        "2000-04-05": 1,
+        "2000-04-06": 3,
+        "2000-04-07": 2,
+        "2000-04-08": 0,
+        "2000-04-09": 1,
+        "2000-04-10": 4,
+        "2000-04-11": 6,
+        "2000-04-12": 8,
+        "2000-04-13": 0,
+        "2000-04-14": 4,
+        "2000-04-15": 0,
+        "2000-04-16": 5,
+        "2000-04-17": 2,
+        "2000-04-18": 5,
+        "2000-04-19": 3,
+        "2000-04-20": 5,
+        "2000-04-21": 4,
+        "2000-04-22": 2,
+        "2000-04-23": 2,
+        "2000-04-24": 8,
+        "2000-04-25": 2,
+        "2000-04-26": 2,
+        "2000-04-27": 2,
+        "2000-04-28": 1,
+        "2000-04-29": 1,
+        "2000-04-30": 0,
+        "2000-05-01": 8,
+        "2000-05-02": 8,
+        "2000-05-03": 7,
+        "2000-05-04": 4,
+        "2000-05-05": 3,
+        "2000-05-06": 1,
+        "2000-05-07": 0,
+        "2000-05-08": 3,
+        "2000-05-09": 1,
+        "2000-05-10": 5,
+        "2000-05-11": 7,
+        "2000-05-12": 2,
+        "2000-05-13": 3,
+        "2000-05-14": 0,
+        "2000-05-15": 2,
+        "2000-05-16": 10,
+        "2000-05-17": 5,
+        "2000-05-18": 6,
+        "2000-05-19": 3,
+        "2000-05-20": 0,
+        "2000-05-21": 0,
+        "2000-05-22": 2,
+        "2000-05-23": 2,
+        "2000-05-24": 10,
+        "2000-05-25": 2,
+        "2000-05-26": 2,
+        "2000-05-27": 1,
+        "2000-05-28": 2,
+        "2000-05-29": 4,
+        "2000-05-30": 5,
+        "2000-05-31": 2,
+        "2000-06-01": 10,
+        "2000-06-02": 1,
+        "2000-06-03": 0,
+        "2000-06-04": 2,
+        "2000-06-05": 8,
+        "2000-06-06": 6,
+        "2000-06-07": 7,
+        "2000-06-08": 8,
+        "2000-06-09": 9,
+        "2000-06-10": 0,
+        "2000-06-11": 1,
+        "2000-06-12": 1,
+        "2000-06-13": 2,
+        "2000-06-14": 5,
+        "2000-06-15": 4,
+        "2000-06-16": 5,
+        "2000-06-17": 1,
+        "2000-06-18": 0,
+        "2000-06-19": 5,
+        "2000-06-20": 2,
+        "2000-06-21": 13,
+        "2000-06-22": 5,
+        "2000-06-23": 2,
+        "2000-06-24": 1,
+        "2000-06-25": 1,
+        "2000-06-26": 6,
+        "2000-06-27": 5,
+        "2000-06-28": 0,
+        "2000-06-29": 3,
+        "2000-06-30": 6,
+        "2000-07-01": 1,
+        "2000-07-02": 1,
+        "2000-07-03": 1,
+        "2000-07-04": 2,
+        "2000-07-05": 6,
+        "2000-07-06": 0,
+        "2000-07-07": 4,
+        "2000-07-08": 2,
+        "2000-07-09": 0,
+        "2000-07-10": 4,
+        "2000-07-11": 6,
+        "2000-07-12": 8,
+        "2000-07-13": 2,
+        "2000-07-14": 2,
+        "2000-07-15": 0,
+        "2000-07-16": 1,
+        "2000-07-17": 4,
+        "2000-07-18": 5,
+        "2000-07-19": 4,
+        "2000-07-20": 4,
+        "2000-07-21": 5,
+        "2000-07-22": 0,
+        "2000-07-23": 0,
+        "2000-07-24": 1,
+        "2000-07-25": 6,
+        "2000-07-26": 2,
+        "2000-07-27": 3,
+        "2000-07-28": 0,
+        "2000-07-29": 0,
+        "2000-07-30": 0,
+        "2000-07-31": 0,
+        "2000-08-01": 0,
+        "2000-08-02": 0,
+        "2000-08-03": 1,
+        "2000-08-04": 0,
+        "2000-08-05": 0,
+        "2000-08-06": 0,
+        "2000-08-07": 0,
+        "2000-08-08": 1,
+        "2000-08-09": 0,
+        "2000-08-10": 0,
+        "2000-08-11": 0,
+        "2000-08-12": 0,
+        "2000-08-13": 0,
+        "2000-08-14": 0,
+        "2000-08-15": 0,
+        "2000-08-16": 0,
+        "2000-08-17": 0,
+        "2000-08-18": 0,
+        "2000-08-19": 0,
+        "2000-08-20": 0,
+        "2000-08-21": 0,
+        "2000-08-22": 0,
+        "2000-08-23": 0,
+        "2000-08-24": 0,
+        "2000-08-25": 0,
+        "2000-08-26": 0,
+        "2000-08-27": 0,
+        "2000-08-28": 0,
+        "2000-08-29": 1,
+        "2000-08-30": 0,
+        "2000-08-31": 0,
+        "2000-09-01": 0,
+        "2000-09-02": 0,
+        "2000-09-03": 0,
+        "2000-09-04": 0,
+        "2000-09-05": 0,
+        "2000-09-06": 0,
+        "2000-09-07": 0,
+        "2000-09-08": 0,
+        "2000-09-09": 0,
+        "2000-09-10": 0,
+        "2000-09-11": 0,
+        "2000-09-12": 0,
+        "2000-09-13": 0,
+        "2000-09-14": 0,
+        "2000-09-15": 0,
+        "2000-09-16": 1,
+        "2000-09-17": 0,
+        "2000-09-18": 0,
+        "2000-09-19": 0,
+        "2000-09-20": 0,
+        "2000-09-21": 0,
+        "2000-09-22": 0,
+        "2000-09-23": 0,
+        "2000-09-24": 0,
+        "2000-09-25": 0,
+        "2000-09-26": 0,
+        "2000-09-27": 0,
+        "2000-09-28": 1,
+        "2000-09-29": 0,
+        "2000-09-30": 1,
+        "2000-10-01": 0,
+        "2000-10-02": 0,
+        "2000-10-03": 0,
+        "2000-10-04": 0,
+        "2000-10-05": 0,
+        "2000-10-06": 1,
+        "2000-10-07": 0,
+        "2000-10-08": 0,
+        "2000-10-09": 0,
+        "2000-10-10": 0,
+        "2000-10-11": 0,
+        "2000-10-12": 0,
+        "2000-10-13": 1,
+        "2000-10-14": 1,
+        "2000-10-15": 0,
+        "2000-10-16": 0,
+        "2000-10-17": 0,
+        "2000-10-18": 2,
+        "2000-10-19": 0,
+        "2000-10-20": 130,
+        "2000-10-21": 0,
+        "2000-10-22": 0,
+        "2000-10-23": 0,
+        "2000-10-24": 0,
+        "2000-10-25": 0,
+        "2000-10-26": 0,
+        "2000-10-27": 0,
+        "2000-10-28": 0,
+        "2000-10-29": 0,
+        "2000-10-30": 0,
+        "2000-10-31": 0,
+        "2000-11-01": 2,
+        "2000-11-02": 0,
+        "2000-11-03": 0,
+        "2000-11-04": 0,
+        "2000-11-05": 0,
+        "2000-11-06": 0,
+        "2000-11-07": 0,
+        "2000-11-08": 0,
+        "2000-11-09": 0,
+        "2000-11-10": 0,
+        "2000-11-11": 0,
+        "2000-11-12": 0,
+        "2000-11-13": 0,
+        "2000-11-14": 68,
+        "2000-11-15": 0,
+        "2000-11-16": 0,
+        "2000-11-17": 0,
+        "2000-11-18": 0,
+        "2000-11-19": 0,
+        "2000-11-20": 1,
+        "2000-11-21": 1,
+        "2000-11-22": 0,
+        "2000-11-23": 1,
+        "2000-11-24": 0,
+        "2000-11-25": 0,
+        "2000-11-26": 0,
+        "2000-11-27": 0,
+        "2000-11-28": 0,
+        "2000-11-29": 0,
+        "2000-11-30": 0,
+        "2000-12-01": 0,
+        "2000-12-02": 0,
+        "2000-12-03": 0,
+        "2000-12-04": 0,
+        "2000-12-05": 0,
+        "2000-12-06": 0,
+        "2000-12-07": 0,
+        "2000-12-08": 0,
+        "2000-12-09": 0,
+        "2000-12-10": 1,
+        "2000-12-11": 79,
+        "2000-12-12": 0,
+        "2000-12-13": 0,
+        "2000-12-14": 1,
+        "2000-12-15": 0,
+        "2000-12-16": 1,
+        "2000-12-17": 0,
+        "2000-12-18": 1,
+        "2000-12-19": 108,
+        "2000-12-20": 1,
+        "2000-12-21": 0,
+        "2000-12-22": 0,
+        "2000-12-23": 0,
+        "2000-12-24": 0,
+        "2000-12-25": 0,
+        "2000-12-26": 0,
+        "2000-12-27": 0,
+        "2000-12-28": 0,
+        "2000-12-29": 0,
+        "2000-12-30": 0,
+        "2000-12-31": 20
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 1019,
+      "severity_distribution": {
+        "UNKNOWN": 1019
+      },
+      "score_distribution": {
+        "7.2": 130,
+        "2.1": 59,
+        "7.5": 168,
+        "5.0": 371,
+        "4.6": 59,
+        "10.0": 141,
+        "6.4": 19,
+        "3.6": 9,
+        "6.2": 9,
+        "2.6": 19,
+        "4.3": 1,
+        "5.1": 11,
+        "1.2": 7,
+        "7.6": 6,
+        "7.8": 3,
+        "7.1": 1,
+        "3.7": 4,
+        "9.0": 2
+      }
+    },
+    "v3.0": {
+      "total": 1,
+      "severity_distribution": {
+        "HIGH": 1
+      },
+      "score_distribution": {
+        "7.5": 1
+      }
+    },
+    "v3.1": {
+      "total": 9,
+      "severity_distribution": {
+        "CRITICAL": 2,
+        "MEDIUM": 3,
+        "HIGH": 4
+      },
+      "score_distribution": {
+        "9.8": 2,
+        "5.5": 3,
+        "7.5": 4
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 148,
+      "epss_gt_0_5": 20,
+      "epss_gt_0_9": 2
+    }
+  },
+  "kev": {
+    "kev_count": 0
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 143
+      },
+      {
+        "name": "Redhat",
+        "count": 48
+      },
+      {
+        "name": "Hp",
+        "count": 36
+      },
+      {
+        "name": "Freebsd",
+        "count": 27
+      },
+      {
+        "name": "Sun",
+        "count": 26
+      },
+      {
+        "name": "Netscape",
+        "count": 22
+      },
+      {
+        "name": "Mandrakesoft",
+        "count": 18
+      },
+      {
+        "name": "Openbsd",
+        "count": 18
+      },
+      {
+        "name": "Suse",
+        "count": 18
+      },
+      {
+        "name": "Sgi",
+        "count": 17
+      },
+      {
+        "name": "Debian",
+        "count": 17
+      },
+      {
+        "name": "Ibm",
+        "count": 17
+      },
+      {
+        "name": "Cisco",
+        "count": 16
+      },
+      {
+        "name": "Checkpoint",
+        "count": 15
+      },
+      {
+        "name": "Gnu",
+        "count": 14
+      },
+      {
+        "name": "Sco",
+        "count": 12
+      },
+      {
+        "name": "Allaire",
+        "count": 11
+      },
+      {
+        "name": "Oracle",
+        "count": 11
+      },
+      {
+        "name": "Netbsd",
+        "count": 11
+      },
+      {
+        "name": "Caldera",
+        "count": 10
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-120",
+        "count": 4
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 4
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-178",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 2
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-254",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-16",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-346",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-667",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-459",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-362",
+        "count": 1
+      },
+      {
+        "cwe": "CWE-522",
+        "count": 1
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 1019
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 1896
+      },
+      {
+        "tag": "Patch",
+        "count": 1284
+      },
+      {
+        "tag": "Exploit",
+        "count": 832
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 112
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 76
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 64
+      },
+      {
+        "tag": "Broken Link",
+        "count": 64
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 14
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 2
+      },
+      {
+        "tag": "Product",
+        "count": 2
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:42.535683",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2001.json b/web/data/cve_2001.json
new file mode 100644
index 00000000000..3a0ffea1721
--- /dev/null
+++ b/web/data/cve_2001.json
@@ -0,0 +1,689 @@
+{
+  "year": 2001,
+  "total_cves": 1676,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 130,
+      "2": 117,
+      "3": 105,
+      "4": 17,
+      "5": 105,
+      "6": 211,
+      "7": 190,
+      "8": 205,
+      "9": 135,
+      "10": 142,
+      "11": 61,
+      "12": 258
+    },
+    "daily_analysis": {
+      "total_days": 194,
+      "avg_per_day": 8.64,
+      "highest_day": {
+        "date": "2001-01-09",
+        "count": 111
+      },
+      "lowest_day": {
+        "date": "2001-01-08",
+        "count": 1
+      },
+      "daily_counts": {
+        "2001-01-01": 4,
+        "2001-01-02": 0,
+        "2001-01-03": 0,
+        "2001-01-04": 0,
+        "2001-01-05": 0,
+        "2001-01-06": 0,
+        "2001-01-07": 0,
+        "2001-01-08": 1,
+        "2001-01-09": 111,
+        "2001-01-10": 1,
+        "2001-01-11": 1,
+        "2001-01-12": 1,
+        "2001-01-13": 0,
+        "2001-01-14": 0,
+        "2001-01-15": 0,
+        "2001-01-16": 0,
+        "2001-01-17": 0,
+        "2001-01-18": 8,
+        "2001-01-19": 1,
+        "2001-01-20": 0,
+        "2001-01-21": 0,
+        "2001-01-22": 0,
+        "2001-01-23": 2,
+        "2001-01-24": 0,
+        "2001-01-25": 0,
+        "2001-01-26": 0,
+        "2001-01-27": 0,
+        "2001-01-28": 0,
+        "2001-01-29": 0,
+        "2001-01-30": 0,
+        "2001-01-31": 0,
+        "2001-02-01": 0,
+        "2001-02-02": 0,
+        "2001-02-03": 0,
+        "2001-02-04": 0,
+        "2001-02-05": 0,
+        "2001-02-06": 0,
+        "2001-02-07": 3,
+        "2001-02-08": 0,
+        "2001-02-09": 2,
+        "2001-02-10": 0,
+        "2001-02-11": 0,
+        "2001-02-12": 72,
+        "2001-02-13": 0,
+        "2001-02-14": 0,
+        "2001-02-15": 0,
+        "2001-02-16": 37,
+        "2001-02-17": 0,
+        "2001-02-18": 0,
+        "2001-02-19": 0,
+        "2001-02-20": 0,
+        "2001-02-21": 0,
+        "2001-02-22": 0,
+        "2001-02-23": 1,
+        "2001-02-24": 0,
+        "2001-02-25": 0,
+        "2001-02-26": 0,
+        "2001-02-27": 0,
+        "2001-02-28": 2,
+        "2001-03-01": 1,
+        "2001-03-02": 0,
+        "2001-03-03": 1,
+        "2001-03-04": 0,
+        "2001-03-05": 0,
+        "2001-03-06": 0,
+        "2001-03-07": 0,
+        "2001-03-08": 0,
+        "2001-03-09": 0,
+        "2001-03-10": 0,
+        "2001-03-11": 0,
+        "2001-03-12": 71,
+        "2001-03-13": 2,
+        "2001-03-14": 0,
+        "2001-03-15": 0,
+        "2001-03-16": 0,
+        "2001-03-17": 0,
+        "2001-03-18": 0,
+        "2001-03-19": 0,
+        "2001-03-20": 0,
+        "2001-03-21": 0,
+        "2001-03-22": 0,
+        "2001-03-23": 0,
+        "2001-03-24": 0,
+        "2001-03-25": 0,
+        "2001-03-26": 30,
+        "2001-03-27": 0,
+        "2001-03-28": 0,
+        "2001-03-29": 0,
+        "2001-03-30": 0,
+        "2001-03-31": 0,
+        "2001-04-01": 0,
+        "2001-04-02": 0,
+        "2001-04-03": 0,
+        "2001-04-04": 0,
+        "2001-04-05": 0,
+        "2001-04-06": 0,
+        "2001-04-07": 0,
+        "2001-04-08": 0,
+        "2001-04-09": 0,
+        "2001-04-10": 3,
+        "2001-04-11": 1,
+        "2001-04-12": 0,
+        "2001-04-13": 0,
+        "2001-04-14": 0,
+        "2001-04-15": 0,
+        "2001-04-16": 0,
+        "2001-04-17": 11,
+        "2001-04-18": 0,
+        "2001-04-19": 0,
+        "2001-04-20": 1,
+        "2001-04-21": 1,
+        "2001-04-22": 0,
+        "2001-04-23": 0,
+        "2001-04-24": 0,
+        "2001-04-25": 0,
+        "2001-04-26": 0,
+        "2001-04-27": 0,
+        "2001-04-28": 0,
+        "2001-04-29": 0,
+        "2001-04-30": 0,
+        "2001-05-01": 0,
+        "2001-05-02": 0,
+        "2001-05-03": 82,
+        "2001-05-04": 0,
+        "2001-05-05": 0,
+        "2001-05-06": 0,
+        "2001-05-07": 0,
+        "2001-05-08": 0,
+        "2001-05-09": 0,
+        "2001-05-10": 2,
+        "2001-05-11": 1,
+        "2001-05-12": 1,
+        "2001-05-13": 0,
+        "2001-05-14": 0,
+        "2001-05-15": 0,
+        "2001-05-16": 1,
+        "2001-05-17": 0,
+        "2001-05-18": 1,
+        "2001-05-19": 0,
+        "2001-05-20": 0,
+        "2001-05-21": 1,
+        "2001-05-22": 1,
+        "2001-05-23": 0,
+        "2001-05-24": 7,
+        "2001-05-25": 0,
+        "2001-05-26": 0,
+        "2001-05-27": 1,
+        "2001-05-28": 5,
+        "2001-05-29": 1,
+        "2001-05-30": 1,
+        "2001-05-31": 0,
+        "2001-06-01": 0,
+        "2001-06-02": 51,
+        "2001-06-03": 0,
+        "2001-06-04": 0,
+        "2001-06-05": 2,
+        "2001-06-06": 1,
+        "2001-06-07": 0,
+        "2001-06-08": 1,
+        "2001-06-09": 0,
+        "2001-06-10": 0,
+        "2001-06-11": 6,
+        "2001-06-12": 2,
+        "2001-06-13": 1,
+        "2001-06-14": 0,
+        "2001-06-15": 1,
+        "2001-06-16": 1,
+        "2001-06-17": 0,
+        "2001-06-18": 44,
+        "2001-06-19": 2,
+        "2001-06-20": 0,
+        "2001-06-21": 2,
+        "2001-06-22": 2,
+        "2001-06-23": 1,
+        "2001-06-24": 0,
+        "2001-06-25": 0,
+        "2001-06-26": 2,
+        "2001-06-27": 85,
+        "2001-06-28": 1,
+        "2001-06-29": 5,
+        "2001-06-30": 1,
+        "2001-07-01": 2,
+        "2001-07-02": 45,
+        "2001-07-03": 1,
+        "2001-07-04": 3,
+        "2001-07-05": 4,
+        "2001-07-06": 2,
+        "2001-07-07": 1,
+        "2001-07-08": 0,
+        "2001-07-09": 3,
+        "2001-07-10": 3,
+        "2001-07-11": 8,
+        "2001-07-12": 9,
+        "2001-07-13": 2,
+        "2001-07-14": 0,
+        "2001-07-15": 0,
+        "2001-07-16": 20,
+        "2001-07-17": 9,
+        "2001-07-18": 4,
+        "2001-07-19": 12,
+        "2001-07-20": 3,
+        "2001-07-21": 34,
+        "2001-07-22": 2,
+        "2001-07-23": 3,
+        "2001-07-24": 3,
+        "2001-07-25": 3,
+        "2001-07-26": 5,
+        "2001-07-27": 2,
+        "2001-07-28": 0,
+        "2001-07-29": 1,
+        "2001-07-30": 4,
+        "2001-07-31": 2,
+        "2001-08-01": 0,
+        "2001-08-02": 24,
+        "2001-08-03": 4,
+        "2001-08-04": 1,
+        "2001-08-05": 0,
+        "2001-08-06": 1,
+        "2001-08-07": 5,
+        "2001-08-08": 0,
+        "2001-08-09": 1,
+        "2001-08-10": 1,
+        "2001-08-11": 0,
+        "2001-08-12": 1,
+        "2001-08-13": 4,
+        "2001-08-14": 43,
+        "2001-08-15": 0,
+        "2001-08-16": 0,
+        "2001-08-17": 2,
+        "2001-08-18": 0,
+        "2001-08-19": 0,
+        "2001-08-20": 1,
+        "2001-08-21": 5,
+        "2001-08-22": 46,
+        "2001-08-23": 2,
+        "2001-08-24": 1,
+        "2001-08-25": 0,
+        "2001-08-26": 0,
+        "2001-08-27": 2,
+        "2001-08-28": 1,
+        "2001-08-29": 4,
+        "2001-08-30": 1,
+        "2001-08-31": 55,
+        "2001-09-01": 0,
+        "2001-09-02": 2,
+        "2001-09-03": 2,
+        "2001-09-04": 5,
+        "2001-09-05": 5,
+        "2001-09-06": 2,
+        "2001-09-07": 3,
+        "2001-09-08": 4,
+        "2001-09-09": 0,
+        "2001-09-10": 12,
+        "2001-09-11": 4,
+        "2001-09-12": 8,
+        "2001-09-13": 2,
+        "2001-09-14": 1,
+        "2001-09-15": 3,
+        "2001-09-16": 0,
+        "2001-09-17": 0,
+        "2001-09-18": 2,
+        "2001-09-19": 2,
+        "2001-09-20": 62,
+        "2001-09-21": 2,
+        "2001-09-22": 1,
+        "2001-09-23": 1,
+        "2001-09-24": 3,
+        "2001-09-25": 1,
+        "2001-09-26": 2,
+        "2001-09-27": 4,
+        "2001-09-28": 1,
+        "2001-09-29": 1,
+        "2001-09-30": 0,
+        "2001-10-01": 3,
+        "2001-10-02": 16,
+        "2001-10-03": 1,
+        "2001-10-04": 0,
+        "2001-10-05": 3,
+        "2001-10-06": 3,
+        "2001-10-07": 1,
+        "2001-10-08": 4,
+        "2001-10-09": 4,
+        "2001-10-10": 4,
+        "2001-10-11": 0,
+        "2001-10-12": 8,
+        "2001-10-13": 1,
+        "2001-10-14": 0,
+        "2001-10-15": 2,
+        "2001-10-16": 1,
+        "2001-10-17": 1,
+        "2001-10-18": 64,
+        "2001-10-19": 0,
+        "2001-10-20": 0,
+        "2001-10-21": 0,
+        "2001-10-22": 2,
+        "2001-10-23": 0,
+        "2001-10-24": 1,
+        "2001-10-25": 1,
+        "2001-10-26": 0,
+        "2001-10-27": 0,
+        "2001-10-28": 0,
+        "2001-10-29": 0,
+        "2001-10-30": 22,
+        "2001-10-31": 0,
+        "2001-11-01": 0,
+        "2001-11-02": 1,
+        "2001-11-03": 0,
+        "2001-11-04": 0,
+        "2001-11-05": 2,
+        "2001-11-06": 0,
+        "2001-11-07": 0,
+        "2001-11-08": 0,
+        "2001-11-09": 0,
+        "2001-11-10": 0,
+        "2001-11-11": 1,
+        "2001-11-12": 1,
+        "2001-11-13": 3,
+        "2001-11-14": 2,
+        "2001-11-15": 3,
+        "2001-11-16": 1,
+        "2001-11-17": 0,
+        "2001-11-18": 2,
+        "2001-11-19": 2,
+        "2001-11-20": 3,
+        "2001-11-21": 8,
+        "2001-11-22": 4,
+        "2001-11-23": 0,
+        "2001-11-24": 0,
+        "2001-11-25": 1,
+        "2001-11-26": 4,
+        "2001-11-27": 1,
+        "2001-11-28": 13,
+        "2001-11-29": 1,
+        "2001-11-30": 8,
+        "2001-12-01": 1,
+        "2001-12-02": 1,
+        "2001-12-03": 1,
+        "2001-12-04": 5,
+        "2001-12-05": 0,
+        "2001-12-06": 74,
+        "2001-12-07": 3,
+        "2001-12-08": 2,
+        "2001-12-09": 0,
+        "2001-12-10": 1,
+        "2001-12-11": 5,
+        "2001-12-12": 2,
+        "2001-12-13": 4,
+        "2001-12-14": 3,
+        "2001-12-15": 3,
+        "2001-12-16": 0,
+        "2001-12-17": 5,
+        "2001-12-18": 2,
+        "2001-12-19": 1,
+        "2001-12-20": 7,
+        "2001-12-21": 14,
+        "2001-12-22": 0,
+        "2001-12-23": 1,
+        "2001-12-24": 0,
+        "2001-12-25": 2,
+        "2001-12-26": 2,
+        "2001-12-27": 2,
+        "2001-12-28": 2,
+        "2001-12-29": 2,
+        "2001-12-30": 5,
+        "2001-12-31": 108
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 1676,
+      "severity_distribution": {
+        "UNKNOWN": 1676
+      },
+      "score_distribution": {
+        "5.0": 520,
+        "7.5": 456,
+        "4.6": 134,
+        "2.1": 132,
+        "10.0": 148,
+        "7.2": 157,
+        "3.7": 6,
+        "5.1": 13,
+        "4.3": 6,
+        "3.6": 12,
+        "6.4": 25,
+        "9.0": 1,
+        "6.2": 14,
+        "2.6": 13,
+        "1.2": 26,
+        "7.8": 2,
+        "7.6": 5,
+        "3.3": 1,
+        "7.1": 1,
+        "4.0": 1,
+        "6.8": 2,
+        "9.3": 1
+      }
+    },
+    "v3.1": {
+      "total": 38,
+      "severity_distribution": {
+        "MEDIUM": 7,
+        "HIGH": 19,
+        "CRITICAL": 12
+      },
+      "score_distribution": {
+        "5.5": 6,
+        "7.1": 1,
+        "7.8": 4,
+        "9.8": 12,
+        "7.5": 12,
+        "8.8": 1,
+        "7.3": 1,
+        "5.3": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 191,
+      "epss_gt_0_5": 27,
+      "epss_gt_0_9": 4
+    }
+  },
+  "kev": {
+    "kev_count": 0
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 173
+      },
+      {
+        "name": "Ibm",
+        "count": 59
+      },
+      {
+        "name": "Sun",
+        "count": 56
+      },
+      {
+        "name": "Cisco",
+        "count": 55
+      },
+      {
+        "name": "Redhat",
+        "count": 48
+      },
+      {
+        "name": "Hp",
+        "count": 48
+      },
+      {
+        "name": "Debian",
+        "count": 36
+      },
+      {
+        "name": "Freebsd",
+        "count": 36
+      },
+      {
+        "name": "Mandrakesoft",
+        "count": 35
+      },
+      {
+        "name": "Oracle",
+        "count": 35
+      },
+      {
+        "name": "Openbsd",
+        "count": 30
+      },
+      {
+        "name": "Linux",
+        "count": 23
+      },
+      {
+        "name": "Suse",
+        "count": 21
+      },
+      {
+        "name": "Caldera",
+        "count": 20
+      },
+      {
+        "name": "Sco",
+        "count": 20
+      },
+      {
+        "name": "Immunix",
+        "count": 19
+      },
+      {
+        "name": "Trend Micro",
+        "count": 17
+      },
+      {
+        "name": "Lotus",
+        "count": 16
+      },
+      {
+        "name": "Apache",
+        "count": 16
+      },
+      {
+        "name": "Sgi",
+        "count": 15
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-119",
+        "count": 9
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 7
+      },
+      {
+        "cwe": "CWE-120",
+        "count": 5
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 5
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 5
+      },
+      {
+        "cwe": "CWE-203",
+        "count": 4
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 4
+      },
+      {
+        "cwe": "CWE-88",
+        "count": 4
+      },
+      {
+        "cwe": "CWE-193",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-307",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-131",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-178",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-434",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-312",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-401",
+        "count": 2
+      },
+      {
+        "cwe": "CWE-281",
+        "count": 2
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 2
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 2
+      },
+      {
+        "cwe": "CWE-667",
+        "count": 2
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 1675
+      },
+      {
+        "status": "Analyzed",
+        "count": 1
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 4276
+      },
+      {
+        "tag": "Patch",
+        "count": 2868
+      },
+      {
+        "tag": "Exploit",
+        "count": 1696
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 546
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 534
+      },
+      {
+        "tag": "Broken Link",
+        "count": 306
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 268
+      },
+      {
+        "tag": "Mailing List",
+        "count": 44
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 22
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 6
+      },
+      {
+        "tag": "Release Notes",
+        "count": 4
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:42.569786",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2002.json b/web/data/cve_2002.json
new file mode 100644
index 00000000000..0ac4df8fa76
--- /dev/null
+++ b/web/data/cve_2002.json
@@ -0,0 +1,709 @@
+{
+  "year": 2002,
+  "total_cves": 2156,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 25,
+      "2": 15,
+      "3": 104,
+      "4": 45,
+      "5": 148,
+      "6": 102,
+      "7": 137,
+      "8": 255,
+      "9": 68,
+      "10": 314,
+      "11": 74,
+      "12": 869
+    },
+    "daily_analysis": {
+      "total_days": 89,
+      "avg_per_day": 24.22,
+      "highest_day": {
+        "date": "2002-12-31",
+        "count": 791
+      },
+      "lowest_day": {
+        "date": "2002-01-02",
+        "count": 1
+      },
+      "daily_counts": {
+        "2002-01-01": 0,
+        "2002-01-02": 1,
+        "2002-01-03": 0,
+        "2002-01-04": 0,
+        "2002-01-05": 0,
+        "2002-01-06": 0,
+        "2002-01-07": 0,
+        "2002-01-08": 0,
+        "2002-01-09": 4,
+        "2002-01-10": 0,
+        "2002-01-11": 1,
+        "2002-01-12": 0,
+        "2002-01-13": 1,
+        "2002-01-14": 0,
+        "2002-01-15": 3,
+        "2002-01-16": 0,
+        "2002-01-17": 0,
+        "2002-01-18": 0,
+        "2002-01-19": 0,
+        "2002-01-20": 0,
+        "2002-01-21": 0,
+        "2002-01-22": 0,
+        "2002-01-23": 0,
+        "2002-01-24": 0,
+        "2002-01-25": 0,
+        "2002-01-26": 0,
+        "2002-01-27": 0,
+        "2002-01-28": 0,
+        "2002-01-29": 0,
+        "2002-01-30": 1,
+        "2002-01-31": 14,
+        "2002-02-01": 0,
+        "2002-02-02": 0,
+        "2002-02-03": 0,
+        "2002-02-04": 0,
+        "2002-02-05": 0,
+        "2002-02-06": 2,
+        "2002-02-07": 0,
+        "2002-02-08": 0,
+        "2002-02-09": 1,
+        "2002-02-10": 0,
+        "2002-02-11": 0,
+        "2002-02-12": 0,
+        "2002-02-13": 5,
+        "2002-02-14": 0,
+        "2002-02-15": 0,
+        "2002-02-16": 0,
+        "2002-02-17": 0,
+        "2002-02-18": 0,
+        "2002-02-19": 0,
+        "2002-02-20": 0,
+        "2002-02-21": 0,
+        "2002-02-22": 0,
+        "2002-02-23": 0,
+        "2002-02-24": 0,
+        "2002-02-25": 0,
+        "2002-02-26": 2,
+        "2002-02-27": 5,
+        "2002-02-28": 0,
+        "2002-03-01": 0,
+        "2002-03-02": 0,
+        "2002-03-03": 0,
+        "2002-03-04": 2,
+        "2002-03-05": 0,
+        "2002-03-06": 0,
+        "2002-03-07": 0,
+        "2002-03-08": 25,
+        "2002-03-09": 0,
+        "2002-03-10": 0,
+        "2002-03-11": 0,
+        "2002-03-12": 0,
+        "2002-03-13": 0,
+        "2002-03-14": 0,
+        "2002-03-15": 16,
+        "2002-03-16": 0,
+        "2002-03-17": 0,
+        "2002-03-18": 0,
+        "2002-03-19": 1,
+        "2002-03-20": 0,
+        "2002-03-21": 1,
+        "2002-03-22": 1,
+        "2002-03-23": 0,
+        "2002-03-24": 0,
+        "2002-03-25": 53,
+        "2002-03-26": 1,
+        "2002-03-27": 1,
+        "2002-03-28": 2,
+        "2002-03-29": 1,
+        "2002-03-30": 0,
+        "2002-03-31": 0,
+        "2002-04-01": 7,
+        "2002-04-02": 1,
+        "2002-04-03": 2,
+        "2002-04-04": 2,
+        "2002-04-05": 1,
+        "2002-04-06": 0,
+        "2002-04-07": 0,
+        "2002-04-08": 1,
+        "2002-04-09": 0,
+        "2002-04-10": 0,
+        "2002-04-11": 0,
+        "2002-04-12": 0,
+        "2002-04-13": 0,
+        "2002-04-14": 0,
+        "2002-04-15": 0,
+        "2002-04-16": 0,
+        "2002-04-17": 0,
+        "2002-04-18": 0,
+        "2002-04-19": 0,
+        "2002-04-20": 0,
+        "2002-04-21": 0,
+        "2002-04-22": 30,
+        "2002-04-23": 1,
+        "2002-04-24": 0,
+        "2002-04-25": 0,
+        "2002-04-26": 0,
+        "2002-04-27": 0,
+        "2002-04-28": 0,
+        "2002-04-29": 0,
+        "2002-04-30": 0,
+        "2002-05-01": 1,
+        "2002-05-02": 0,
+        "2002-05-03": 0,
+        "2002-05-04": 0,
+        "2002-05-05": 0,
+        "2002-05-06": 1,
+        "2002-05-07": 0,
+        "2002-05-08": 0,
+        "2002-05-09": 0,
+        "2002-05-10": 0,
+        "2002-05-11": 0,
+        "2002-05-12": 0,
+        "2002-05-13": 0,
+        "2002-05-14": 0,
+        "2002-05-15": 0,
+        "2002-05-16": 44,
+        "2002-05-17": 1,
+        "2002-05-18": 0,
+        "2002-05-19": 1,
+        "2002-05-20": 0,
+        "2002-05-21": 1,
+        "2002-05-22": 0,
+        "2002-05-23": 0,
+        "2002-05-24": 0,
+        "2002-05-25": 0,
+        "2002-05-26": 0,
+        "2002-05-27": 1,
+        "2002-05-28": 1,
+        "2002-05-29": 57,
+        "2002-05-30": 0,
+        "2002-05-31": 40,
+        "2002-06-01": 0,
+        "2002-06-02": 0,
+        "2002-06-03": 0,
+        "2002-06-04": 0,
+        "2002-06-05": 0,
+        "2002-06-06": 0,
+        "2002-06-07": 0,
+        "2002-06-08": 0,
+        "2002-06-09": 0,
+        "2002-06-10": 0,
+        "2002-06-11": 0,
+        "2002-06-12": 0,
+        "2002-06-13": 0,
+        "2002-06-14": 0,
+        "2002-06-15": 0,
+        "2002-06-16": 0,
+        "2002-06-17": 0,
+        "2002-06-18": 51,
+        "2002-06-19": 0,
+        "2002-06-20": 0,
+        "2002-06-21": 0,
+        "2002-06-22": 0,
+        "2002-06-23": 0,
+        "2002-06-24": 0,
+        "2002-06-25": 51,
+        "2002-06-26": 0,
+        "2002-06-27": 0,
+        "2002-06-28": 0,
+        "2002-06-29": 0,
+        "2002-06-30": 0,
+        "2002-07-01": 0,
+        "2002-07-02": 0,
+        "2002-07-03": 60,
+        "2002-07-04": 0,
+        "2002-07-05": 0,
+        "2002-07-06": 0,
+        "2002-07-07": 0,
+        "2002-07-08": 1,
+        "2002-07-09": 0,
+        "2002-07-10": 0,
+        "2002-07-11": 4,
+        "2002-07-12": 0,
+        "2002-07-13": 0,
+        "2002-07-14": 0,
+        "2002-07-15": 0,
+        "2002-07-16": 0,
+        "2002-07-17": 0,
+        "2002-07-18": 0,
+        "2002-07-19": 0,
+        "2002-07-20": 0,
+        "2002-07-21": 0,
+        "2002-07-22": 0,
+        "2002-07-23": 24,
+        "2002-07-24": 0,
+        "2002-07-25": 0,
+        "2002-07-26": 46,
+        "2002-07-27": 0,
+        "2002-07-28": 0,
+        "2002-07-29": 0,
+        "2002-07-30": 0,
+        "2002-07-31": 2,
+        "2002-08-01": 2,
+        "2002-08-02": 0,
+        "2002-08-03": 0,
+        "2002-08-04": 0,
+        "2002-08-05": 0,
+        "2002-08-06": 0,
+        "2002-08-07": 0,
+        "2002-08-08": 0,
+        "2002-08-09": 0,
+        "2002-08-10": 0,
+        "2002-08-11": 0,
+        "2002-08-12": 242,
+        "2002-08-13": 0,
+        "2002-08-14": 2,
+        "2002-08-15": 1,
+        "2002-08-16": 0,
+        "2002-08-17": 0,
+        "2002-08-18": 0,
+        "2002-08-19": 0,
+        "2002-08-20": 0,
+        "2002-08-21": 0,
+        "2002-08-22": 0,
+        "2002-08-23": 0,
+        "2002-08-24": 1,
+        "2002-08-25": 0,
+        "2002-08-26": 0,
+        "2002-08-27": 0,
+        "2002-08-28": 0,
+        "2002-08-29": 1,
+        "2002-08-30": 4,
+        "2002-08-31": 2,
+        "2002-09-01": 0,
+        "2002-09-02": 2,
+        "2002-09-03": 0,
+        "2002-09-04": 0,
+        "2002-09-05": 22,
+        "2002-09-06": 0,
+        "2002-09-07": 0,
+        "2002-09-08": 0,
+        "2002-09-09": 1,
+        "2002-09-10": 1,
+        "2002-09-11": 0,
+        "2002-09-12": 0,
+        "2002-09-13": 2,
+        "2002-09-14": 0,
+        "2002-09-15": 0,
+        "2002-09-16": 0,
+        "2002-09-17": 0,
+        "2002-09-18": 0,
+        "2002-09-19": 0,
+        "2002-09-20": 0,
+        "2002-09-21": 0,
+        "2002-09-22": 0,
+        "2002-09-23": 0,
+        "2002-09-24": 39,
+        "2002-09-25": 1,
+        "2002-09-26": 0,
+        "2002-09-27": 0,
+        "2002-09-28": 0,
+        "2002-09-29": 0,
+        "2002-09-30": 0,
+        "2002-10-01": 0,
+        "2002-10-02": 0,
+        "2002-10-03": 1,
+        "2002-10-04": 234,
+        "2002-10-05": 0,
+        "2002-10-06": 0,
+        "2002-10-07": 0,
+        "2002-10-08": 0,
+        "2002-10-09": 0,
+        "2002-10-10": 11,
+        "2002-10-11": 31,
+        "2002-10-12": 0,
+        "2002-10-13": 0,
+        "2002-10-14": 0,
+        "2002-10-15": 0,
+        "2002-10-16": 1,
+        "2002-10-17": 0,
+        "2002-10-18": 0,
+        "2002-10-19": 0,
+        "2002-10-20": 0,
+        "2002-10-21": 0,
+        "2002-10-22": 1,
+        "2002-10-23": 0,
+        "2002-10-24": 1,
+        "2002-10-25": 0,
+        "2002-10-26": 0,
+        "2002-10-27": 0,
+        "2002-10-28": 33,
+        "2002-10-29": 1,
+        "2002-10-30": 0,
+        "2002-10-31": 0,
+        "2002-11-01": 0,
+        "2002-11-02": 0,
+        "2002-11-03": 0,
+        "2002-11-04": 12,
+        "2002-11-05": 0,
+        "2002-11-06": 0,
+        "2002-11-07": 0,
+        "2002-11-08": 1,
+        "2002-11-09": 0,
+        "2002-11-10": 0,
+        "2002-11-11": 0,
+        "2002-11-12": 23,
+        "2002-11-13": 0,
+        "2002-11-14": 0,
+        "2002-11-15": 0,
+        "2002-11-16": 0,
+        "2002-11-17": 0,
+        "2002-11-18": 0,
+        "2002-11-19": 0,
+        "2002-11-20": 1,
+        "2002-11-21": 0,
+        "2002-11-22": 0,
+        "2002-11-23": 0,
+        "2002-11-24": 0,
+        "2002-11-25": 2,
+        "2002-11-26": 0,
+        "2002-11-27": 0,
+        "2002-11-28": 0,
+        "2002-11-29": 35,
+        "2002-11-30": 0,
+        "2002-12-01": 0,
+        "2002-12-02": 0,
+        "2002-12-03": 1,
+        "2002-12-04": 1,
+        "2002-12-05": 0,
+        "2002-12-06": 0,
+        "2002-12-07": 0,
+        "2002-12-08": 0,
+        "2002-12-09": 0,
+        "2002-12-10": 0,
+        "2002-12-11": 22,
+        "2002-12-12": 0,
+        "2002-12-13": 0,
+        "2002-12-14": 0,
+        "2002-12-15": 0,
+        "2002-12-16": 0,
+        "2002-12-17": 0,
+        "2002-12-18": 13,
+        "2002-12-19": 1,
+        "2002-12-20": 0,
+        "2002-12-21": 0,
+        "2002-12-22": 0,
+        "2002-12-23": 26,
+        "2002-12-24": 1,
+        "2002-12-25": 0,
+        "2002-12-26": 12,
+        "2002-12-27": 1,
+        "2002-12-28": 0,
+        "2002-12-29": 0,
+        "2002-12-30": 0,
+        "2002-12-31": 791
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 2156,
+      "severity_distribution": {
+        "UNKNOWN": 2156
+      },
+      "score_distribution": {
+        "7.2": 141,
+        "5.0": 685,
+        "7.5": 671,
+        "1.2": 8,
+        "10.0": 156,
+        "3.6": 12,
+        "5.1": 15,
+        "4.6": 101,
+        "6.4": 48,
+        "2.6": 11,
+        "7.6": 5,
+        "2.1": 113,
+        "6.2": 10,
+        "6.8": 27,
+        "4.3": 96,
+        "5.4": 1,
+        "7.8": 21,
+        "1.7": 1,
+        "3.7": 2,
+        "7.1": 6,
+        "6.9": 3,
+        "1.9": 2,
+        "4.0": 2,
+        "4.9": 5,
+        "3.8": 1,
+        "8.5": 1,
+        "8.3": 1,
+        "6.6": 1,
+        "9.4": 2,
+        "3.3": 1,
+        "5.8": 4,
+        "8.8": 1,
+        "9.3": 1,
+        "3.5": 1
+      }
+    },
+    "v3.1": {
+      "total": 54,
+      "severity_distribution": {
+        "CRITICAL": 10,
+        "HIGH": 31,
+        "MEDIUM": 12,
+        "LOW": 1
+      },
+      "score_distribution": {
+        "9.8": 9,
+        "7.8": 8,
+        "7.5": 23,
+        "5.5": 11,
+        "9.1": 1,
+        "3.3": 1,
+        "5.3": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 289,
+      "epss_gt_0_5": 33,
+      "epss_gt_0_9": 2
+    }
+  },
+  "kev": {
+    "kev_count": 1
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 246
+      },
+      {
+        "name": "Cisco",
+        "count": 65
+      },
+      {
+        "name": "Hp",
+        "count": 58
+      },
+      {
+        "name": "Sun",
+        "count": 57
+      },
+      {
+        "name": "Oracle",
+        "count": 56
+      },
+      {
+        "name": "Ibm",
+        "count": 43
+      },
+      {
+        "name": "Sgi",
+        "count": 33
+      },
+      {
+        "name": "Apache",
+        "count": 32
+      },
+      {
+        "name": "Freebsd",
+        "count": 31
+      },
+      {
+        "name": "Mozilla",
+        "count": 30
+      },
+      {
+        "name": "Openbsd",
+        "count": 25
+      },
+      {
+        "name": "Apple",
+        "count": 25
+      },
+      {
+        "name": "Redhat",
+        "count": 23
+      },
+      {
+        "name": "Caldera",
+        "count": 23
+      },
+      {
+        "name": "Novell",
+        "count": 22
+      },
+      {
+        "name": "Symantec",
+        "count": 22
+      },
+      {
+        "name": "Macromedia",
+        "count": 20
+      },
+      {
+        "name": "Gnu",
+        "count": 18
+      },
+      {
+        "name": "Netscape",
+        "count": 17
+      },
+      {
+        "name": "Linux",
+        "count": 15
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-119",
+        "count": 41
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 34
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 31
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 27
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 17
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 14
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 12
+      },
+      {
+        "cwe": "CWE-16",
+        "count": 9
+      },
+      {
+        "cwe": "CWE-326",
+        "count": 8
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 8
+      },
+      {
+        "cwe": "CWE-193",
+        "count": 7
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 7
+      },
+      {
+        "cwe": "CWE-667",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-459",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 5
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 5
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 5
+      },
+      {
+        "cwe": "CWE-269",
+        "count": 4
+      },
+      {
+        "cwe": "CWE-203",
+        "count": 4
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 2155
+      },
+      {
+        "status": "Analyzed",
+        "count": 1
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 4590
+      },
+      {
+        "tag": "Patch",
+        "count": 3794
+      },
+      {
+        "tag": "Exploit",
+        "count": 1706
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 756
+      },
+      {
+        "tag": "Broken Link",
+        "count": 750
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 717
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 364
+      },
+      {
+        "tag": "Mailing List",
+        "count": 124
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 48
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 18
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 8
+      },
+      {
+        "tag": "Release Notes",
+        "count": 6
+      },
+      {
+        "tag": "Product",
+        "count": 6
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:42.615677",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2003.json b/web/data/cve_2003.json
new file mode 100644
index 00000000000..77a2fb762d1
--- /dev/null
+++ b/web/data/cve_2003.json
@@ -0,0 +1,711 @@
+{
+  "year": 2003,
+  "total_cves": 1527,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 36,
+      "2": 48,
+      "3": 119,
+      "4": 135,
+      "5": 80,
+      "6": 129,
+      "7": 48,
+      "8": 205,
+      "9": 35,
+      "10": 92,
+      "11": 93,
+      "12": 507
+    },
+    "daily_analysis": {
+      "total_days": 91,
+      "avg_per_day": 16.78,
+      "highest_day": {
+        "date": "2003-12-31",
+        "count": 441
+      },
+      "lowest_day": {
+        "date": "2003-01-03",
+        "count": 1
+      },
+      "daily_counts": {
+        "2003-01-01": 0,
+        "2003-01-02": 7,
+        "2003-01-03": 1,
+        "2003-01-04": 0,
+        "2003-01-05": 0,
+        "2003-01-06": 0,
+        "2003-01-07": 5,
+        "2003-01-08": 0,
+        "2003-01-09": 0,
+        "2003-01-10": 0,
+        "2003-01-11": 1,
+        "2003-01-12": 0,
+        "2003-01-13": 0,
+        "2003-01-14": 0,
+        "2003-01-15": 0,
+        "2003-01-16": 0,
+        "2003-01-17": 21,
+        "2003-01-18": 0,
+        "2003-01-19": 0,
+        "2003-01-20": 0,
+        "2003-01-21": 0,
+        "2003-01-22": 0,
+        "2003-01-23": 0,
+        "2003-01-24": 0,
+        "2003-01-25": 0,
+        "2003-01-26": 0,
+        "2003-01-27": 1,
+        "2003-01-28": 0,
+        "2003-01-29": 0,
+        "2003-01-30": 0,
+        "2003-01-31": 0,
+        "2003-02-01": 0,
+        "2003-02-02": 0,
+        "2003-02-03": 0,
+        "2003-02-04": 0,
+        "2003-02-05": 0,
+        "2003-02-06": 1,
+        "2003-02-07": 18,
+        "2003-02-08": 0,
+        "2003-02-09": 0,
+        "2003-02-10": 0,
+        "2003-02-11": 1,
+        "2003-02-12": 0,
+        "2003-02-13": 0,
+        "2003-02-14": 0,
+        "2003-02-15": 0,
+        "2003-02-16": 0,
+        "2003-02-17": 0,
+        "2003-02-18": 1,
+        "2003-02-19": 26,
+        "2003-02-20": 0,
+        "2003-02-21": 0,
+        "2003-02-22": 0,
+        "2003-02-23": 0,
+        "2003-02-24": 0,
+        "2003-02-25": 0,
+        "2003-02-26": 0,
+        "2003-02-27": 0,
+        "2003-02-28": 1,
+        "2003-03-01": 0,
+        "2003-03-02": 0,
+        "2003-03-03": 30,
+        "2003-03-04": 0,
+        "2003-03-05": 1,
+        "2003-03-06": 0,
+        "2003-03-07": 13,
+        "2003-03-08": 0,
+        "2003-03-09": 0,
+        "2003-03-10": 0,
+        "2003-03-11": 0,
+        "2003-03-12": 0,
+        "2003-03-13": 0,
+        "2003-03-14": 0,
+        "2003-03-15": 0,
+        "2003-03-16": 0,
+        "2003-03-17": 0,
+        "2003-03-18": 19,
+        "2003-03-19": 0,
+        "2003-03-20": 1,
+        "2003-03-21": 0,
+        "2003-03-22": 0,
+        "2003-03-23": 0,
+        "2003-03-24": 12,
+        "2003-03-25": 1,
+        "2003-03-26": 0,
+        "2003-03-27": 0,
+        "2003-03-28": 1,
+        "2003-03-29": 0,
+        "2003-03-30": 0,
+        "2003-03-31": 41,
+        "2003-04-01": 0,
+        "2003-04-02": 66,
+        "2003-04-03": 0,
+        "2003-04-04": 0,
+        "2003-04-05": 0,
+        "2003-04-06": 0,
+        "2003-04-07": 0,
+        "2003-04-08": 0,
+        "2003-04-09": 0,
+        "2003-04-10": 0,
+        "2003-04-11": 46,
+        "2003-04-12": 0,
+        "2003-04-13": 0,
+        "2003-04-14": 0,
+        "2003-04-15": 0,
+        "2003-04-16": 1,
+        "2003-04-17": 0,
+        "2003-04-18": 0,
+        "2003-04-19": 0,
+        "2003-04-20": 0,
+        "2003-04-21": 0,
+        "2003-04-22": 20,
+        "2003-04-23": 0,
+        "2003-04-24": 0,
+        "2003-04-25": 0,
+        "2003-04-26": 0,
+        "2003-04-27": 0,
+        "2003-04-28": 2,
+        "2003-04-29": 0,
+        "2003-04-30": 0,
+        "2003-05-01": 0,
+        "2003-05-02": 0,
+        "2003-05-03": 0,
+        "2003-05-04": 0,
+        "2003-05-05": 15,
+        "2003-05-06": 0,
+        "2003-05-07": 0,
+        "2003-05-08": 0,
+        "2003-05-09": 0,
+        "2003-05-10": 1,
+        "2003-05-11": 1,
+        "2003-05-12": 26,
+        "2003-05-13": 0,
+        "2003-05-14": 0,
+        "2003-05-15": 1,
+        "2003-05-16": 0,
+        "2003-05-17": 0,
+        "2003-05-18": 0,
+        "2003-05-19": 1,
+        "2003-05-20": 1,
+        "2003-05-21": 4,
+        "2003-05-22": 4,
+        "2003-05-23": 0,
+        "2003-05-24": 0,
+        "2003-05-25": 0,
+        "2003-05-26": 0,
+        "2003-05-27": 26,
+        "2003-05-28": 0,
+        "2003-05-29": 0,
+        "2003-05-30": 0,
+        "2003-05-31": 0,
+        "2003-06-01": 0,
+        "2003-06-02": 0,
+        "2003-06-03": 2,
+        "2003-06-04": 0,
+        "2003-06-05": 0,
+        "2003-06-06": 1,
+        "2003-06-07": 0,
+        "2003-06-08": 0,
+        "2003-06-09": 50,
+        "2003-06-10": 0,
+        "2003-06-11": 0,
+        "2003-06-12": 0,
+        "2003-06-13": 1,
+        "2003-06-14": 0,
+        "2003-06-15": 0,
+        "2003-06-16": 55,
+        "2003-06-17": 1,
+        "2003-06-18": 0,
+        "2003-06-19": 1,
+        "2003-06-20": 0,
+        "2003-06-21": 0,
+        "2003-06-22": 0,
+        "2003-06-23": 0,
+        "2003-06-24": 0,
+        "2003-06-25": 0,
+        "2003-06-26": 0,
+        "2003-06-27": 0,
+        "2003-06-28": 0,
+        "2003-06-29": 0,
+        "2003-06-30": 18,
+        "2003-07-01": 0,
+        "2003-07-02": 15,
+        "2003-07-03": 1,
+        "2003-07-04": 0,
+        "2003-07-05": 0,
+        "2003-07-06": 0,
+        "2003-07-07": 0,
+        "2003-07-08": 0,
+        "2003-07-09": 0,
+        "2003-07-10": 0,
+        "2003-07-11": 0,
+        "2003-07-12": 0,
+        "2003-07-13": 0,
+        "2003-07-14": 0,
+        "2003-07-15": 0,
+        "2003-07-16": 0,
+        "2003-07-17": 0,
+        "2003-07-18": 0,
+        "2003-07-19": 0,
+        "2003-07-20": 0,
+        "2003-07-21": 0,
+        "2003-07-22": 0,
+        "2003-07-23": 2,
+        "2003-07-24": 29,
+        "2003-07-25": 1,
+        "2003-07-26": 0,
+        "2003-07-27": 0,
+        "2003-07-28": 0,
+        "2003-07-29": 0,
+        "2003-07-30": 0,
+        "2003-07-31": 0,
+        "2003-08-01": 0,
+        "2003-08-02": 0,
+        "2003-08-03": 0,
+        "2003-08-04": 0,
+        "2003-08-05": 0,
+        "2003-08-06": 1,
+        "2003-08-07": 47,
+        "2003-08-08": 0,
+        "2003-08-09": 0,
+        "2003-08-10": 0,
+        "2003-08-11": 1,
+        "2003-08-12": 0,
+        "2003-08-13": 0,
+        "2003-08-14": 0,
+        "2003-08-15": 1,
+        "2003-08-16": 0,
+        "2003-08-17": 0,
+        "2003-08-18": 58,
+        "2003-08-19": 1,
+        "2003-08-20": 1,
+        "2003-08-21": 0,
+        "2003-08-22": 0,
+        "2003-08-23": 0,
+        "2003-08-24": 0,
+        "2003-08-25": 0,
+        "2003-08-26": 0,
+        "2003-08-27": 95,
+        "2003-08-28": 0,
+        "2003-08-29": 0,
+        "2003-08-30": 0,
+        "2003-08-31": 0,
+        "2003-09-01": 0,
+        "2003-09-02": 0,
+        "2003-09-03": 0,
+        "2003-09-04": 0,
+        "2003-09-05": 0,
+        "2003-09-06": 0,
+        "2003-09-07": 1,
+        "2003-09-08": 0,
+        "2003-09-09": 1,
+        "2003-09-10": 0,
+        "2003-09-11": 0,
+        "2003-09-12": 0,
+        "2003-09-13": 0,
+        "2003-09-14": 0,
+        "2003-09-15": 0,
+        "2003-09-16": 0,
+        "2003-09-17": 18,
+        "2003-09-18": 0,
+        "2003-09-19": 0,
+        "2003-09-20": 0,
+        "2003-09-21": 0,
+        "2003-09-22": 15,
+        "2003-09-23": 0,
+        "2003-09-24": 0,
+        "2003-09-25": 0,
+        "2003-09-26": 0,
+        "2003-09-27": 0,
+        "2003-09-28": 0,
+        "2003-09-29": 0,
+        "2003-09-30": 0,
+        "2003-10-01": 0,
+        "2003-10-02": 0,
+        "2003-10-03": 1,
+        "2003-10-04": 0,
+        "2003-10-05": 0,
+        "2003-10-06": 21,
+        "2003-10-07": 1,
+        "2003-10-08": 0,
+        "2003-10-09": 0,
+        "2003-10-10": 0,
+        "2003-10-11": 0,
+        "2003-10-12": 0,
+        "2003-10-13": 0,
+        "2003-10-14": 1,
+        "2003-10-15": 1,
+        "2003-10-16": 0,
+        "2003-10-17": 0,
+        "2003-10-18": 0,
+        "2003-10-19": 0,
+        "2003-10-20": 47,
+        "2003-10-21": 0,
+        "2003-10-22": 0,
+        "2003-10-23": 1,
+        "2003-10-24": 0,
+        "2003-10-25": 2,
+        "2003-10-26": 0,
+        "2003-10-27": 7,
+        "2003-10-28": 2,
+        "2003-10-29": 3,
+        "2003-10-30": 4,
+        "2003-10-31": 1,
+        "2003-11-01": 0,
+        "2003-11-02": 2,
+        "2003-11-03": 25,
+        "2003-11-04": 2,
+        "2003-11-05": 0,
+        "2003-11-06": 0,
+        "2003-11-07": 0,
+        "2003-11-08": 0,
+        "2003-11-09": 0,
+        "2003-11-10": 0,
+        "2003-11-11": 0,
+        "2003-11-12": 0,
+        "2003-11-13": 1,
+        "2003-11-14": 0,
+        "2003-11-15": 0,
+        "2003-11-16": 0,
+        "2003-11-17": 59,
+        "2003-11-18": 0,
+        "2003-11-19": 0,
+        "2003-11-20": 1,
+        "2003-11-21": 0,
+        "2003-11-22": 0,
+        "2003-11-23": 1,
+        "2003-11-24": 1,
+        "2003-11-25": 0,
+        "2003-11-26": 0,
+        "2003-11-27": 1,
+        "2003-11-28": 0,
+        "2003-11-29": 0,
+        "2003-11-30": 0,
+        "2003-12-01": 17,
+        "2003-12-02": 0,
+        "2003-12-03": 1,
+        "2003-12-04": 0,
+        "2003-12-05": 0,
+        "2003-12-06": 0,
+        "2003-12-07": 0,
+        "2003-12-08": 1,
+        "2003-12-09": 0,
+        "2003-12-10": 0,
+        "2003-12-11": 1,
+        "2003-12-12": 0,
+        "2003-12-13": 0,
+        "2003-12-14": 0,
+        "2003-12-15": 43,
+        "2003-12-16": 0,
+        "2003-12-17": 0,
+        "2003-12-18": 0,
+        "2003-12-19": 0,
+        "2003-12-20": 0,
+        "2003-12-21": 0,
+        "2003-12-22": 0,
+        "2003-12-23": 0,
+        "2003-12-24": 0,
+        "2003-12-25": 0,
+        "2003-12-26": 1,
+        "2003-12-27": 0,
+        "2003-12-28": 0,
+        "2003-12-29": 2,
+        "2003-12-30": 0,
+        "2003-12-31": 441
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 1527,
+      "severity_distribution": {
+        "UNKNOWN": 1527
+      },
+      "score_distribution": {
+        "7.5": 407,
+        "7.2": 109,
+        "4.6": 114,
+        "4.3": 105,
+        "10.0": 119,
+        "5.0": 400,
+        "2.1": 61,
+        "6.5": 2,
+        "1.2": 10,
+        "3.6": 12,
+        "5.8": 5,
+        "6.4": 29,
+        "6.2": 4,
+        "7.8": 16,
+        "6.8": 64,
+        "2.6": 8,
+        "9.0": 7,
+        "5.1": 9,
+        "9.3": 8,
+        "7.6": 6,
+        "4.4": 4,
+        "3.7": 3,
+        "6.9": 1,
+        "7.1": 2,
+        "4.9": 3,
+        "1.7": 1,
+        "4.0": 3,
+        "5.2": 1,
+        "8.5": 2,
+        "3.3": 2,
+        "8.3": 1,
+        "8.8": 1,
+        "6.6": 1,
+        "1.9": 2,
+        "4.8": 1,
+        "3.5": 1,
+        "6.3": 3
+      }
+    },
+    "v3.1": {
+      "total": 17,
+      "severity_distribution": {
+        "HIGH": 6,
+        "CRITICAL": 9,
+        "MEDIUM": 2
+      },
+      "score_distribution": {
+        "7.5": 3,
+        "9.8": 9,
+        "7.3": 1,
+        "5.5": 1,
+        "7.8": 1,
+        "7.1": 1,
+        "6.5": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 204,
+      "epss_gt_0_5": 36,
+      "epss_gt_0_9": 1
+    }
+  },
+  "kev": {
+    "kev_count": 0
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 118
+      },
+      {
+        "name": "Sun",
+        "count": 64
+      },
+      {
+        "name": "Apple",
+        "count": 48
+      },
+      {
+        "name": "Hp",
+        "count": 43
+      },
+      {
+        "name": "Redhat",
+        "count": 38
+      },
+      {
+        "name": "Ibm",
+        "count": 34
+      },
+      {
+        "name": "Linux",
+        "count": 28
+      },
+      {
+        "name": "Cisco",
+        "count": 27
+      },
+      {
+        "name": "Apache",
+        "count": 25
+      },
+      {
+        "name": "Sgi",
+        "count": 24
+      },
+      {
+        "name": "Oracle",
+        "count": 21
+      },
+      {
+        "name": "Bea",
+        "count": 20
+      },
+      {
+        "name": "Openbsd",
+        "count": 18
+      },
+      {
+        "name": "Novell",
+        "count": 16
+      },
+      {
+        "name": "Netbsd",
+        "count": 14
+      },
+      {
+        "name": "Freebsd",
+        "count": 14
+      },
+      {
+        "name": "Gnu",
+        "count": 14
+      },
+      {
+        "name": "Debian",
+        "count": 13
+      },
+      {
+        "name": "Mozilla",
+        "count": 13
+      },
+      {
+        "name": "Sap",
+        "count": 12
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-119",
+        "count": 52
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 34
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 26
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 25
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 18
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 17
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 15
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 13
+      },
+      {
+        "cwe": "CWE-16",
+        "count": 11
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 9
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 8
+      },
+      {
+        "cwe": "CWE-120",
+        "count": 7
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 7
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 7
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-193",
+        "count": 4
+      },
+      {
+        "cwe": "CWE-203",
+        "count": 3
+      },
+      {
+        "cwe": "CWE-415",
+        "count": 2
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 2
+      },
+      {
+        "cwe": "CWE-134",
+        "count": 2
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 1527
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 3349
+      },
+      {
+        "tag": "Patch",
+        "count": 2836
+      },
+      {
+        "tag": "Exploit",
+        "count": 1702
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 648
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 556
+      },
+      {
+        "tag": "Broken Link",
+        "count": 408
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 160
+      },
+      {
+        "tag": "Mailing List",
+        "count": 56
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 52
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 34
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 6
+      },
+      {
+        "tag": "Product",
+        "count": 2
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 2
+      },
+      {
+        "tag": "Release Notes",
+        "count": 2
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:42.651116",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2004.json b/web/data/cve_2004.json
new file mode 100644
index 00000000000..30645e38d7a
--- /dev/null
+++ b/web/data/cve_2004.json
@@ -0,0 +1,738 @@
+{
+  "year": 2004,
+  "total_cves": 2451,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 65,
+      "2": 91,
+      "3": 141,
+      "4": 107,
+      "5": 68,
+      "6": 52,
+      "7": 101,
+      "8": 240,
+      "9": 90,
+      "10": 101,
+      "11": 172,
+      "12": 1223
+    },
+    "daily_analysis": {
+      "total_days": 186,
+      "avg_per_day": 13.18,
+      "highest_day": {
+        "date": "2004-12-31",
+        "count": 1098
+      },
+      "lowest_day": {
+        "date": "2004-01-04",
+        "count": 1
+      },
+      "daily_counts": {
+        "2004-01-01": 0,
+        "2004-01-02": 0,
+        "2004-01-03": 2,
+        "2004-01-04": 1,
+        "2004-01-05": 23,
+        "2004-01-06": 0,
+        "2004-01-07": 0,
+        "2004-01-08": 0,
+        "2004-01-09": 0,
+        "2004-01-10": 1,
+        "2004-01-11": 0,
+        "2004-01-12": 0,
+        "2004-01-13": 0,
+        "2004-01-14": 2,
+        "2004-01-15": 1,
+        "2004-01-16": 0,
+        "2004-01-17": 0,
+        "2004-01-18": 0,
+        "2004-01-19": 0,
+        "2004-01-20": 25,
+        "2004-01-21": 2,
+        "2004-01-22": 0,
+        "2004-01-23": 1,
+        "2004-01-24": 2,
+        "2004-01-25": 0,
+        "2004-01-26": 0,
+        "2004-01-27": 1,
+        "2004-01-28": 1,
+        "2004-01-29": 3,
+        "2004-01-30": 0,
+        "2004-01-31": 0,
+        "2004-02-01": 1,
+        "2004-02-02": 0,
+        "2004-02-03": 25,
+        "2004-02-04": 1,
+        "2004-02-05": 0,
+        "2004-02-06": 3,
+        "2004-02-07": 2,
+        "2004-02-08": 3,
+        "2004-02-09": 5,
+        "2004-02-10": 1,
+        "2004-02-11": 2,
+        "2004-02-12": 1,
+        "2004-02-13": 1,
+        "2004-02-14": 0,
+        "2004-02-15": 0,
+        "2004-02-16": 1,
+        "2004-02-17": 39,
+        "2004-02-18": 0,
+        "2004-02-19": 1,
+        "2004-02-20": 0,
+        "2004-02-21": 1,
+        "2004-02-22": 0,
+        "2004-02-23": 2,
+        "2004-02-24": 0,
+        "2004-02-25": 0,
+        "2004-02-26": 0,
+        "2004-02-27": 1,
+        "2004-02-28": 1,
+        "2004-02-29": 0,
+        "2004-03-01": 0,
+        "2004-03-02": 0,
+        "2004-03-03": 48,
+        "2004-03-04": 1,
+        "2004-03-05": 0,
+        "2004-03-06": 0,
+        "2004-03-07": 0,
+        "2004-03-08": 0,
+        "2004-03-09": 0,
+        "2004-03-10": 0,
+        "2004-03-11": 3,
+        "2004-03-12": 1,
+        "2004-03-13": 0,
+        "2004-03-14": 0,
+        "2004-03-15": 29,
+        "2004-03-16": 2,
+        "2004-03-17": 0,
+        "2004-03-18": 2,
+        "2004-03-19": 1,
+        "2004-03-20": 5,
+        "2004-03-21": 0,
+        "2004-03-22": 3,
+        "2004-03-23": 4,
+        "2004-03-24": 7,
+        "2004-03-25": 2,
+        "2004-03-26": 4,
+        "2004-03-27": 0,
+        "2004-03-28": 0,
+        "2004-03-29": 25,
+        "2004-03-30": 4,
+        "2004-03-31": 0,
+        "2004-04-01": 0,
+        "2004-04-02": 1,
+        "2004-04-03": 0,
+        "2004-04-04": 1,
+        "2004-04-05": 0,
+        "2004-04-06": 0,
+        "2004-04-07": 1,
+        "2004-04-08": 3,
+        "2004-04-09": 2,
+        "2004-04-10": 2,
+        "2004-04-11": 5,
+        "2004-04-12": 6,
+        "2004-04-13": 3,
+        "2004-04-14": 3,
+        "2004-04-15": 39,
+        "2004-04-16": 0,
+        "2004-04-17": 0,
+        "2004-04-18": 0,
+        "2004-04-19": 7,
+        "2004-04-20": 3,
+        "2004-04-21": 3,
+        "2004-04-22": 0,
+        "2004-04-23": 6,
+        "2004-04-24": 0,
+        "2004-04-25": 3,
+        "2004-04-26": 7,
+        "2004-04-27": 3,
+        "2004-04-28": 1,
+        "2004-04-29": 1,
+        "2004-04-30": 7,
+        "2004-05-01": 1,
+        "2004-05-02": 3,
+        "2004-05-03": 3,
+        "2004-05-04": 30,
+        "2004-05-05": 8,
+        "2004-05-06": 3,
+        "2004-05-07": 1,
+        "2004-05-08": 3,
+        "2004-05-09": 0,
+        "2004-05-10": 1,
+        "2004-05-11": 0,
+        "2004-05-12": 0,
+        "2004-05-13": 0,
+        "2004-05-14": 1,
+        "2004-05-15": 0,
+        "2004-05-16": 0,
+        "2004-05-17": 0,
+        "2004-05-18": 0,
+        "2004-05-19": 0,
+        "2004-05-20": 0,
+        "2004-05-21": 2,
+        "2004-05-22": 2,
+        "2004-05-23": 0,
+        "2004-05-24": 1,
+        "2004-05-25": 0,
+        "2004-05-26": 3,
+        "2004-05-27": 0,
+        "2004-05-28": 1,
+        "2004-05-29": 5,
+        "2004-05-30": 0,
+        "2004-05-31": 0,
+        "2004-06-01": 40,
+        "2004-06-02": 0,
+        "2004-06-03": 0,
+        "2004-06-04": 0,
+        "2004-06-05": 0,
+        "2004-06-06": 0,
+        "2004-06-07": 0,
+        "2004-06-08": 0,
+        "2004-06-09": 0,
+        "2004-06-10": 0,
+        "2004-06-11": 0,
+        "2004-06-12": 0,
+        "2004-06-13": 0,
+        "2004-06-14": 9,
+        "2004-06-15": 1,
+        "2004-06-16": 0,
+        "2004-06-17": 0,
+        "2004-06-18": 0,
+        "2004-06-19": 1,
+        "2004-06-20": 0,
+        "2004-06-21": 1,
+        "2004-06-22": 0,
+        "2004-06-23": 0,
+        "2004-06-24": 0,
+        "2004-06-25": 0,
+        "2004-06-26": 0,
+        "2004-06-27": 0,
+        "2004-06-28": 0,
+        "2004-06-29": 0,
+        "2004-06-30": 0,
+        "2004-07-01": 0,
+        "2004-07-02": 0,
+        "2004-07-03": 0,
+        "2004-07-04": 0,
+        "2004-07-05": 0,
+        "2004-07-06": 0,
+        "2004-07-07": 36,
+        "2004-07-08": 0,
+        "2004-07-09": 0,
+        "2004-07-10": 0,
+        "2004-07-11": 0,
+        "2004-07-12": 0,
+        "2004-07-13": 0,
+        "2004-07-14": 0,
+        "2004-07-15": 0,
+        "2004-07-16": 0,
+        "2004-07-17": 0,
+        "2004-07-18": 0,
+        "2004-07-19": 1,
+        "2004-07-20": 0,
+        "2004-07-21": 0,
+        "2004-07-22": 1,
+        "2004-07-23": 1,
+        "2004-07-24": 2,
+        "2004-07-25": 0,
+        "2004-07-26": 0,
+        "2004-07-27": 53,
+        "2004-07-28": 0,
+        "2004-07-29": 3,
+        "2004-07-30": 4,
+        "2004-07-31": 0,
+        "2004-08-01": 0,
+        "2004-08-02": 2,
+        "2004-08-03": 0,
+        "2004-08-04": 12,
+        "2004-08-05": 1,
+        "2004-08-06": 108,
+        "2004-08-07": 0,
+        "2004-08-08": 0,
+        "2004-08-09": 2,
+        "2004-08-10": 2,
+        "2004-08-11": 2,
+        "2004-08-12": 0,
+        "2004-08-13": 0,
+        "2004-08-14": 0,
+        "2004-08-15": 1,
+        "2004-08-16": 3,
+        "2004-08-17": 5,
+        "2004-08-18": 64,
+        "2004-08-19": 0,
+        "2004-08-20": 7,
+        "2004-08-21": 1,
+        "2004-08-22": 0,
+        "2004-08-23": 3,
+        "2004-08-24": 6,
+        "2004-08-25": 2,
+        "2004-08-26": 2,
+        "2004-08-27": 0,
+        "2004-08-28": 2,
+        "2004-08-29": 3,
+        "2004-08-30": 5,
+        "2004-08-31": 7,
+        "2004-09-01": 5,
+        "2004-09-02": 4,
+        "2004-09-03": 0,
+        "2004-09-04": 1,
+        "2004-09-05": 2,
+        "2004-09-06": 1,
+        "2004-09-07": 2,
+        "2004-09-08": 1,
+        "2004-09-09": 2,
+        "2004-09-10": 3,
+        "2004-09-11": 1,
+        "2004-09-12": 2,
+        "2004-09-13": 6,
+        "2004-09-14": 2,
+        "2004-09-15": 2,
+        "2004-09-16": 12,
+        "2004-09-17": 1,
+        "2004-09-18": 4,
+        "2004-09-19": 0,
+        "2004-09-20": 1,
+        "2004-09-21": 5,
+        "2004-09-22": 0,
+        "2004-09-23": 0,
+        "2004-09-24": 1,
+        "2004-09-25": 0,
+        "2004-09-26": 0,
+        "2004-09-27": 0,
+        "2004-09-28": 30,
+        "2004-09-29": 1,
+        "2004-09-30": 1,
+        "2004-10-01": 0,
+        "2004-10-02": 0,
+        "2004-10-03": 0,
+        "2004-10-04": 1,
+        "2004-10-05": 1,
+        "2004-10-06": 3,
+        "2004-10-07": 1,
+        "2004-10-08": 0,
+        "2004-10-09": 0,
+        "2004-10-10": 0,
+        "2004-10-11": 0,
+        "2004-10-12": 5,
+        "2004-10-13": 4,
+        "2004-10-14": 2,
+        "2004-10-15": 1,
+        "2004-10-16": 4,
+        "2004-10-17": 0,
+        "2004-10-18": 14,
+        "2004-10-19": 2,
+        "2004-10-20": 44,
+        "2004-10-21": 3,
+        "2004-10-22": 4,
+        "2004-10-23": 2,
+        "2004-10-24": 1,
+        "2004-10-25": 5,
+        "2004-10-26": 3,
+        "2004-10-27": 0,
+        "2004-10-28": 0,
+        "2004-10-29": 0,
+        "2004-10-30": 1,
+        "2004-10-31": 0,
+        "2004-11-01": 1,
+        "2004-11-02": 0,
+        "2004-11-03": 33,
+        "2004-11-04": 0,
+        "2004-11-05": 0,
+        "2004-11-06": 0,
+        "2004-11-07": 0,
+        "2004-11-08": 0,
+        "2004-11-09": 0,
+        "2004-11-10": 0,
+        "2004-11-11": 0,
+        "2004-11-12": 1,
+        "2004-11-13": 0,
+        "2004-11-14": 0,
+        "2004-11-15": 0,
+        "2004-11-16": 1,
+        "2004-11-17": 0,
+        "2004-11-18": 0,
+        "2004-11-19": 0,
+        "2004-11-20": 0,
+        "2004-11-21": 0,
+        "2004-11-22": 0,
+        "2004-11-23": 134,
+        "2004-11-24": 1,
+        "2004-11-25": 0,
+        "2004-11-26": 0,
+        "2004-11-27": 0,
+        "2004-11-28": 0,
+        "2004-11-29": 0,
+        "2004-11-30": 1,
+        "2004-12-01": 1,
+        "2004-12-02": 7,
+        "2004-12-03": 2,
+        "2004-12-04": 0,
+        "2004-12-05": 0,
+        "2004-12-06": 49,
+        "2004-12-07": 1,
+        "2004-12-08": 0,
+        "2004-12-09": 0,
+        "2004-12-10": 1,
+        "2004-12-11": 0,
+        "2004-12-12": 0,
+        "2004-12-13": 0,
+        "2004-12-14": 0,
+        "2004-12-15": 10,
+        "2004-12-16": 1,
+        "2004-12-17": 1,
+        "2004-12-18": 3,
+        "2004-12-19": 0,
+        "2004-12-20": 3,
+        "2004-12-21": 2,
+        "2004-12-22": 5,
+        "2004-12-23": 34,
+        "2004-12-24": 0,
+        "2004-12-25": 0,
+        "2004-12-26": 0,
+        "2004-12-27": 2,
+        "2004-12-28": 1,
+        "2004-12-29": 1,
+        "2004-12-30": 1,
+        "2004-12-31": 1098
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 2451,
+      "severity_distribution": {
+        "UNKNOWN": 2451
+      },
+      "score_distribution": {
+        "4.6": 105,
+        "2.1": 148,
+        "5.0": 761,
+        "7.2": 134,
+        "7.5": 586,
+        "10.0": 208,
+        "4.3": 239,
+        "7.8": 15,
+        "6.0": 5,
+        "9.3": 9,
+        "3.7": 7,
+        "6.8": 60,
+        "7.6": 6,
+        "5.1": 30,
+        "2.6": 38,
+        "3.5": 2,
+        "6.4": 34,
+        "1.2": 4,
+        "3.6": 6,
+        "8.5": 4,
+        "4.4": 3,
+        "9.0": 4,
+        "6.5": 6,
+        "4.7": 1,
+        "4.9": 4,
+        "4.0": 11,
+        "7.1": 3,
+        "5.8": 7,
+        "5.4": 2,
+        "6.9": 3,
+        "6.2": 1,
+        "1.0": 1,
+        "1.7": 1,
+        "5.5": 1,
+        "1.9": 1,
+        "5.6": 1
+      }
+    },
+    "v3.0": {
+      "total": 1,
+      "severity_distribution": {
+        "CRITICAL": 1
+      },
+      "score_distribution": {
+        "9.8": 1
+      }
+    },
+    "v3.1": {
+      "total": 44,
+      "severity_distribution": {
+        "MEDIUM": 10,
+        "HIGH": 25,
+        "CRITICAL": 9
+      },
+      "score_distribution": {
+        "6.1": 1,
+        "7.5": 12,
+        "7.8": 6,
+        "9.8": 9,
+        "4.8": 1,
+        "7.0": 1,
+        "8.8": 3,
+        "7.1": 2,
+        "5.5": 4,
+        "5.9": 1,
+        "6.5": 1,
+        "5.3": 2,
+        "8.4": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 273,
+      "epss_gt_0_5": 61,
+      "epss_gt_0_9": 0
+    }
+  },
+  "kev": {
+    "kev_count": 2
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 150
+      },
+      {
+        "name": "Apple",
+        "count": 67
+      },
+      {
+        "name": "Mozilla",
+        "count": 59
+      },
+      {
+        "name": "Ibm",
+        "count": 54
+      },
+      {
+        "name": "Sun",
+        "count": 54
+      },
+      {
+        "name": "Linux",
+        "count": 52
+      },
+      {
+        "name": "Sgi",
+        "count": 52
+      },
+      {
+        "name": "Redhat",
+        "count": 51
+      },
+      {
+        "name": "Gentoo",
+        "count": 45
+      },
+      {
+        "name": "Gnu",
+        "count": 40
+      },
+      {
+        "name": "Francisco Burzi",
+        "count": 38
+      },
+      {
+        "name": "Debian",
+        "count": 36
+      },
+      {
+        "name": "Cisco",
+        "count": 36
+      },
+      {
+        "name": "Oracle",
+        "count": 34
+      },
+      {
+        "name": "Openbsd",
+        "count": 33
+      },
+      {
+        "name": "Suse",
+        "count": 32
+      },
+      {
+        "name": "Mandrakesoft",
+        "count": 31
+      },
+      {
+        "name": "Hp",
+        "count": 31
+      },
+      {
+        "name": "Symantec",
+        "count": 28
+      },
+      {
+        "name": "Apache",
+        "count": 25
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-79",
+        "count": 24
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 23
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 20
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 17
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 15
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 10
+      },
+      {
+        "cwe": "CWE-476",
+        "count": 9
+      },
+      {
+        "cwe": "CWE-203",
+        "count": 7
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-88",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-134",
+        "count": 5
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 5
+      },
+      {
+        "cwe": "CWE-415",
+        "count": 4
+      },
+      {
+        "cwe": "CWE-120",
+        "count": 4
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 4
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 2448
+      },
+      {
+        "status": "Analyzed",
+        "count": 3
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 6514
+      },
+      {
+        "tag": "Patch",
+        "count": 6018
+      },
+      {
+        "tag": "Exploit",
+        "count": 3522
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 1610
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1052
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 910
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 532
+      },
+      {
+        "tag": "Mailing List",
+        "count": 242
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 94
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 52
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 22
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 12
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 10
+      },
+      {
+        "tag": "Product",
+        "count": 8
+      },
+      {
+        "tag": "Release Notes",
+        "count": 6
+      },
+      {
+        "tag": "Mitigation",
+        "count": 2
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:42.712787",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2005.json b/web/data/cve_2005.json
new file mode 100644
index 00000000000..b9158602754
--- /dev/null
+++ b/web/data/cve_2005.json
@@ -0,0 +1,748 @@
+{
+  "year": 2005,
+  "total_cves": 4932,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 320,
+      "2": 105,
+      "3": 164,
+      "4": 125,
+      "5": 1254,
+      "6": 242,
+      "7": 288,
+      "8": 322,
+      "9": 309,
+      "10": 283,
+      "11": 504,
+      "12": 1016
+    },
+    "daily_analysis": {
+      "total_days": 262,
+      "avg_per_day": 18.82,
+      "highest_day": {
+        "date": "2005-05-02",
+        "count": 816
+      },
+      "lowest_day": {
+        "date": "2005-01-01",
+        "count": 1
+      },
+      "daily_counts": {
+        "2005-01-01": 1,
+        "2005-01-02": 0,
+        "2005-01-03": 4,
+        "2005-01-04": 3,
+        "2005-01-05": 1,
+        "2005-01-06": 3,
+        "2005-01-07": 1,
+        "2005-01-08": 0,
+        "2005-01-09": 0,
+        "2005-01-10": 217,
+        "2005-01-11": 7,
+        "2005-01-12": 2,
+        "2005-01-13": 4,
+        "2005-01-14": 2,
+        "2005-01-15": 2,
+        "2005-01-16": 1,
+        "2005-01-17": 6,
+        "2005-01-18": 2,
+        "2005-01-19": 2,
+        "2005-01-20": 3,
+        "2005-01-21": 3,
+        "2005-01-22": 2,
+        "2005-01-23": 0,
+        "2005-01-24": 6,
+        "2005-01-25": 4,
+        "2005-01-26": 3,
+        "2005-01-27": 33,
+        "2005-01-28": 5,
+        "2005-01-29": 2,
+        "2005-01-30": 0,
+        "2005-01-31": 1,
+        "2005-02-01": 2,
+        "2005-02-02": 1,
+        "2005-02-03": 1,
+        "2005-02-04": 0,
+        "2005-02-05": 0,
+        "2005-02-06": 0,
+        "2005-02-07": 6,
+        "2005-02-08": 3,
+        "2005-02-09": 31,
+        "2005-02-10": 2,
+        "2005-02-11": 2,
+        "2005-02-12": 1,
+        "2005-02-13": 0,
+        "2005-02-14": 6,
+        "2005-02-15": 5,
+        "2005-02-16": 3,
+        "2005-02-17": 2,
+        "2005-02-18": 3,
+        "2005-02-19": 3,
+        "2005-02-20": 1,
+        "2005-02-21": 7,
+        "2005-02-22": 5,
+        "2005-02-23": 6,
+        "2005-02-24": 4,
+        "2005-02-25": 3,
+        "2005-02-26": 0,
+        "2005-02-27": 0,
+        "2005-02-28": 8,
+        "2005-03-01": 35,
+        "2005-03-02": 8,
+        "2005-03-03": 2,
+        "2005-03-04": 2,
+        "2005-03-05": 2,
+        "2005-03-06": 4,
+        "2005-03-07": 20,
+        "2005-03-08": 11,
+        "2005-03-09": 3,
+        "2005-03-10": 3,
+        "2005-03-11": 0,
+        "2005-03-12": 2,
+        "2005-03-13": 0,
+        "2005-03-14": 20,
+        "2005-03-15": 8,
+        "2005-03-16": 1,
+        "2005-03-17": 0,
+        "2005-03-18": 0,
+        "2005-03-19": 0,
+        "2005-03-20": 0,
+        "2005-03-21": 3,
+        "2005-03-22": 0,
+        "2005-03-23": 6,
+        "2005-03-24": 3,
+        "2005-03-25": 3,
+        "2005-03-26": 3,
+        "2005-03-27": 1,
+        "2005-03-28": 3,
+        "2005-03-29": 5,
+        "2005-03-30": 15,
+        "2005-03-31": 1,
+        "2005-04-01": 1,
+        "2005-04-02": 0,
+        "2005-04-03": 0,
+        "2005-04-04": 0,
+        "2005-04-05": 1,
+        "2005-04-06": 2,
+        "2005-04-07": 3,
+        "2005-04-08": 3,
+        "2005-04-09": 1,
+        "2005-04-10": 2,
+        "2005-04-11": 2,
+        "2005-04-12": 16,
+        "2005-04-13": 3,
+        "2005-04-14": 31,
+        "2005-04-15": 5,
+        "2005-04-16": 0,
+        "2005-04-17": 0,
+        "2005-04-18": 4,
+        "2005-04-19": 2,
+        "2005-04-20": 5,
+        "2005-04-21": 0,
+        "2005-04-22": 3,
+        "2005-04-23": 3,
+        "2005-04-24": 4,
+        "2005-04-25": 9,
+        "2005-04-26": 3,
+        "2005-04-27": 21,
+        "2005-04-28": 0,
+        "2005-04-29": 1,
+        "2005-04-30": 0,
+        "2005-05-01": 0,
+        "2005-05-02": 816,
+        "2005-05-03": 81,
+        "2005-05-04": 15,
+        "2005-05-05": 17,
+        "2005-05-06": 4,
+        "2005-05-07": 0,
+        "2005-05-08": 0,
+        "2005-05-09": 2,
+        "2005-05-10": 2,
+        "2005-05-11": 56,
+        "2005-05-12": 13,
+        "2005-05-13": 2,
+        "2005-05-14": 26,
+        "2005-05-15": 0,
+        "2005-05-16": 38,
+        "2005-05-17": 21,
+        "2005-05-18": 28,
+        "2005-05-19": 12,
+        "2005-05-20": 14,
+        "2005-05-21": 0,
+        "2005-05-22": 0,
+        "2005-05-23": 0,
+        "2005-05-24": 46,
+        "2005-05-25": 11,
+        "2005-05-26": 11,
+        "2005-05-27": 4,
+        "2005-05-28": 6,
+        "2005-05-29": 5,
+        "2005-05-30": 1,
+        "2005-05-31": 23,
+        "2005-06-01": 24,
+        "2005-06-02": 7,
+        "2005-06-03": 2,
+        "2005-06-04": 0,
+        "2005-06-05": 1,
+        "2005-06-06": 5,
+        "2005-06-07": 5,
+        "2005-06-08": 13,
+        "2005-06-09": 41,
+        "2005-06-10": 3,
+        "2005-06-11": 1,
+        "2005-06-12": 5,
+        "2005-06-13": 8,
+        "2005-06-14": 14,
+        "2005-06-15": 11,
+        "2005-06-16": 32,
+        "2005-06-17": 8,
+        "2005-06-18": 1,
+        "2005-06-19": 2,
+        "2005-06-20": 14,
+        "2005-06-21": 2,
+        "2005-06-22": 9,
+        "2005-06-23": 1,
+        "2005-06-24": 0,
+        "2005-06-25": 0,
+        "2005-06-26": 0,
+        "2005-06-27": 0,
+        "2005-06-28": 7,
+        "2005-06-29": 25,
+        "2005-06-30": 1,
+        "2005-07-01": 0,
+        "2005-07-02": 0,
+        "2005-07-03": 0,
+        "2005-07-04": 0,
+        "2005-07-05": 49,
+        "2005-07-06": 24,
+        "2005-07-07": 1,
+        "2005-07-08": 2,
+        "2005-07-09": 2,
+        "2005-07-10": 0,
+        "2005-07-11": 39,
+        "2005-07-12": 35,
+        "2005-07-13": 28,
+        "2005-07-14": 0,
+        "2005-07-15": 1,
+        "2005-07-16": 0,
+        "2005-07-17": 0,
+        "2005-07-18": 24,
+        "2005-07-19": 31,
+        "2005-07-20": 8,
+        "2005-07-21": 0,
+        "2005-07-22": 0,
+        "2005-07-23": 0,
+        "2005-07-24": 0,
+        "2005-07-25": 0,
+        "2005-07-26": 22,
+        "2005-07-27": 22,
+        "2005-07-28": 0,
+        "2005-07-29": 0,
+        "2005-07-30": 0,
+        "2005-07-31": 0,
+        "2005-08-01": 6,
+        "2005-08-02": 2,
+        "2005-08-03": 41,
+        "2005-08-04": 3,
+        "2005-08-05": 18,
+        "2005-08-06": 0,
+        "2005-08-07": 8,
+        "2005-08-08": 1,
+        "2005-08-09": 0,
+        "2005-08-10": 29,
+        "2005-08-11": 0,
+        "2005-08-12": 8,
+        "2005-08-13": 0,
+        "2005-08-14": 0,
+        "2005-08-15": 2,
+        "2005-08-16": 36,
+        "2005-08-17": 32,
+        "2005-08-18": 0,
+        "2005-08-19": 33,
+        "2005-08-20": 0,
+        "2005-08-21": 0,
+        "2005-08-22": 0,
+        "2005-08-23": 53,
+        "2005-08-24": 15,
+        "2005-08-25": 0,
+        "2005-08-26": 7,
+        "2005-08-27": 0,
+        "2005-08-28": 0,
+        "2005-08-29": 3,
+        "2005-08-30": 24,
+        "2005-08-31": 1,
+        "2005-09-01": 2,
+        "2005-09-02": 31,
+        "2005-09-03": 0,
+        "2005-09-04": 0,
+        "2005-09-05": 0,
+        "2005-09-06": 12,
+        "2005-09-07": 21,
+        "2005-09-08": 31,
+        "2005-09-09": 3,
+        "2005-09-10": 0,
+        "2005-09-11": 0,
+        "2005-09-12": 0,
+        "2005-09-13": 4,
+        "2005-09-14": 32,
+        "2005-09-15": 5,
+        "2005-09-16": 16,
+        "2005-09-17": 0,
+        "2005-09-18": 0,
+        "2005-09-19": 0,
+        "2005-09-20": 26,
+        "2005-09-21": 32,
+        "2005-09-22": 14,
+        "2005-09-23": 7,
+        "2005-09-24": 8,
+        "2005-09-25": 0,
+        "2005-09-26": 4,
+        "2005-09-27": 28,
+        "2005-09-28": 18,
+        "2005-09-29": 0,
+        "2005-09-30": 15,
+        "2005-10-01": 0,
+        "2005-10-02": 0,
+        "2005-10-03": 0,
+        "2005-10-04": 11,
+        "2005-10-05": 25,
+        "2005-10-06": 21,
+        "2005-10-07": 4,
+        "2005-10-08": 0,
+        "2005-10-09": 0,
+        "2005-10-10": 0,
+        "2005-10-11": 0,
+        "2005-10-12": 12,
+        "2005-10-13": 9,
+        "2005-10-14": 47,
+        "2005-10-15": 0,
+        "2005-10-16": 0,
+        "2005-10-17": 3,
+        "2005-10-18": 7,
+        "2005-10-19": 0,
+        "2005-10-20": 15,
+        "2005-10-21": 12,
+        "2005-10-22": 0,
+        "2005-10-23": 24,
+        "2005-10-24": 2,
+        "2005-10-25": 10,
+        "2005-10-26": 15,
+        "2005-10-27": 38,
+        "2005-10-28": 2,
+        "2005-10-29": 0,
+        "2005-10-30": 26,
+        "2005-10-31": 0,
+        "2005-11-01": 44,
+        "2005-11-02": 47,
+        "2005-11-03": 17,
+        "2005-11-04": 13,
+        "2005-11-05": 13,
+        "2005-11-06": 17,
+        "2005-11-07": 2,
+        "2005-11-08": 0,
+        "2005-11-09": 1,
+        "2005-11-10": 0,
+        "2005-11-11": 0,
+        "2005-11-12": 0,
+        "2005-11-13": 0,
+        "2005-11-14": 0,
+        "2005-11-15": 0,
+        "2005-11-16": 63,
+        "2005-11-17": 7,
+        "2005-11-18": 39,
+        "2005-11-19": 11,
+        "2005-11-20": 10,
+        "2005-11-21": 24,
+        "2005-11-22": 34,
+        "2005-11-23": 19,
+        "2005-11-24": 18,
+        "2005-11-25": 7,
+        "2005-11-26": 35,
+        "2005-11-27": 12,
+        "2005-11-28": 0,
+        "2005-11-29": 45,
+        "2005-11-30": 26,
+        "2005-12-01": 39,
+        "2005-12-02": 2,
+        "2005-12-03": 14,
+        "2005-12-04": 12,
+        "2005-12-05": 36,
+        "2005-12-06": 15,
+        "2005-12-07": 26,
+        "2005-12-08": 29,
+        "2005-12-09": 13,
+        "2005-12-10": 11,
+        "2005-12-11": 27,
+        "2005-12-12": 2,
+        "2005-12-13": 23,
+        "2005-12-14": 49,
+        "2005-12-15": 23,
+        "2005-12-16": 29,
+        "2005-12-17": 35,
+        "2005-12-18": 0,
+        "2005-12-19": 10,
+        "2005-12-20": 76,
+        "2005-12-21": 38,
+        "2005-12-22": 46,
+        "2005-12-23": 11,
+        "2005-12-24": 0,
+        "2005-12-25": 0,
+        "2005-12-26": 0,
+        "2005-12-27": 3,
+        "2005-12-28": 35,
+        "2005-12-29": 23,
+        "2005-12-30": 5,
+        "2005-12-31": 384
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 4932,
+      "severity_distribution": {
+        "UNKNOWN": 4932
+      },
+      "score_distribution": {
+        "5.0": 1172,
+        "4.6": 196,
+        "7.2": 176,
+        "10.0": 286,
+        "4.3": 687,
+        "5.1": 131,
+        "2.1": 315,
+        "6.4": 81,
+        "1.2": 23,
+        "3.6": 18,
+        "6.2": 4,
+        "6.8": 79,
+        "7.5": 1456,
+        "5.8": 13,
+        "9.3": 17,
+        "6.6": 2,
+        "6.5": 20,
+        "6.9": 5,
+        "2.6": 71,
+        "4.7": 1,
+        "7.8": 79,
+        "6.1": 2,
+        "4.9": 20,
+        "4.0": 19,
+        "7.1": 9,
+        "7.6": 9,
+        "3.7": 12,
+        "1.9": 5,
+        "4.4": 1,
+        "8.5": 1,
+        "1.7": 2,
+        "3.5": 7,
+        "5.4": 5,
+        "9.4": 3,
+        "9.0": 3,
+        "5.6": 1,
+        "5.7": 1
+      }
+    },
+    "v3.0": {
+      "total": 1,
+      "severity_distribution": {
+        "MEDIUM": 1
+      },
+      "score_distribution": {
+        "5.6": 1
+      }
+    },
+    "v3.1": {
+      "total": 64,
+      "severity_distribution": {
+        "HIGH": 26,
+        "CRITICAL": 13,
+        "MEDIUM": 23,
+        "LOW": 2
+      },
+      "score_distribution": {
+        "7.8": 4,
+        "7.5": 17,
+        "9.8": 13,
+        "5.5": 9,
+        "6.5": 3,
+        "3.7": 2,
+        "5.3": 3,
+        "8.8": 1,
+        "4.7": 3,
+        "8.4": 1,
+        "7.4": 1,
+        "4.5": 1,
+        "4.3": 1,
+        "5.0": 1,
+        "7.3": 1,
+        "6.1": 1,
+        "6.3": 1,
+        "7.1": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 383,
+      "epss_gt_0_5": 93,
+      "epss_gt_0_9": 1
+    }
+  },
+  "kev": {
+    "kev_count": 1
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 172
+      },
+      {
+        "name": "Apple",
+        "count": 150
+      },
+      {
+        "name": "Linux",
+        "count": 134
+      },
+      {
+        "name": "Redhat",
+        "count": 101
+      },
+      {
+        "name": "Mozilla",
+        "count": 93
+      },
+      {
+        "name": "Debian",
+        "count": 82
+      },
+      {
+        "name": "Suse",
+        "count": 82
+      },
+      {
+        "name": "Ibm",
+        "count": 81
+      },
+      {
+        "name": "Oracle",
+        "count": 80
+      },
+      {
+        "name": "Gentoo",
+        "count": 79
+      },
+      {
+        "name": "Sun",
+        "count": 75
+      },
+      {
+        "name": "Cisco",
+        "count": 54
+      },
+      {
+        "name": "Ethereal Group",
+        "count": 49
+      },
+      {
+        "name": "Gnu",
+        "count": 46
+      },
+      {
+        "name": "Ubuntu",
+        "count": 43
+      },
+      {
+        "name": "Hp",
+        "count": 36
+      },
+      {
+        "name": "Mandrakesoft",
+        "count": 34
+      },
+      {
+        "name": "Novell",
+        "count": 34
+      },
+      {
+        "name": "Trustix",
+        "count": 33
+      },
+      {
+        "name": "Phpbb Group",
+        "count": 32
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-119",
+        "count": 71
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 52
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 42
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 38
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 32
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 30
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 30
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 19
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 14
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 14
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 13
+      },
+      {
+        "cwe": "CWE-425",
+        "count": 9
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-131",
+        "count": 5
+      },
+      {
+        "cwe": "CWE-434",
+        "count": 5
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 5
+      },
+      {
+        "cwe": "CWE-400",
+        "count": 4
+      },
+      {
+        "cwe": "CWE-190",
+        "count": 4
+      },
+      {
+        "cwe": "CWE-134",
+        "count": 4
+      },
+      {
+        "cwe": "CWE-601",
+        "count": 4
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 4925
+      },
+      {
+        "status": "Analyzed",
+        "count": 7
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 12694
+      },
+      {
+        "tag": "Patch",
+        "count": 9316
+      },
+      {
+        "tag": "Exploit",
+        "count": 5362
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 2080
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1404
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 943
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 602
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 296
+      },
+      {
+        "tag": "Mailing List",
+        "count": 276
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 170
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 162
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 50
+      },
+      {
+        "tag": "Product",
+        "count": 24
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 10
+      },
+      {
+        "tag": "Release Notes",
+        "count": 8
+      },
+      {
+        "tag": "Technical Description",
+        "count": 4
+      },
+      {
+        "tag": "Mitigation",
+        "count": 2
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:42.829266",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2006.json b/web/data/cve_2006.json
new file mode 100644
index 00000000000..f726801030a
--- /dev/null
+++ b/web/data/cve_2006.json
@@ -0,0 +1,748 @@
+{
+  "year": 2006,
+  "total_cves": 6608,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 381,
+      "2": 448,
+      "3": 543,
+      "4": 575,
+      "5": 583,
+      "6": 629,
+      "7": 529,
+      "8": 538,
+      "9": 550,
+      "10": 546,
+      "11": 507,
+      "12": 779
+    },
+    "daily_analysis": {
+      "total_days": 287,
+      "avg_per_day": 23.02,
+      "highest_day": {
+        "date": "2006-12-31",
+        "count": 125
+      },
+      "lowest_day": {
+        "date": "2006-01-15",
+        "count": 1
+      },
+      "daily_counts": {
+        "2006-01-01": 0,
+        "2006-01-02": 0,
+        "2006-01-03": 6,
+        "2006-01-04": 13,
+        "2006-01-05": 11,
+        "2006-01-06": 12,
+        "2006-01-07": 7,
+        "2006-01-08": 0,
+        "2006-01-09": 39,
+        "2006-01-10": 15,
+        "2006-01-11": 19,
+        "2006-01-12": 7,
+        "2006-01-13": 19,
+        "2006-01-14": 5,
+        "2006-01-15": 1,
+        "2006-01-16": 9,
+        "2006-01-17": 3,
+        "2006-01-18": 59,
+        "2006-01-19": 22,
+        "2006-01-20": 3,
+        "2006-01-21": 25,
+        "2006-01-22": 24,
+        "2006-01-23": 3,
+        "2006-01-24": 1,
+        "2006-01-25": 36,
+        "2006-01-26": 10,
+        "2006-01-27": 12,
+        "2006-01-28": 0,
+        "2006-01-29": 0,
+        "2006-01-30": 3,
+        "2006-01-31": 17,
+        "2006-02-01": 27,
+        "2006-02-02": 25,
+        "2006-02-03": 0,
+        "2006-02-04": 22,
+        "2006-02-05": 0,
+        "2006-02-06": 8,
+        "2006-02-07": 10,
+        "2006-02-08": 27,
+        "2006-02-09": 18,
+        "2006-02-10": 18,
+        "2006-02-11": 1,
+        "2006-02-12": 0,
+        "2006-02-13": 34,
+        "2006-02-14": 13,
+        "2006-02-15": 42,
+        "2006-02-16": 16,
+        "2006-02-17": 4,
+        "2006-02-18": 23,
+        "2006-02-19": 28,
+        "2006-02-20": 3,
+        "2006-02-21": 19,
+        "2006-02-22": 17,
+        "2006-02-23": 24,
+        "2006-02-24": 18,
+        "2006-02-25": 14,
+        "2006-02-26": 0,
+        "2006-02-27": 5,
+        "2006-02-28": 32,
+        "2006-03-01": 10,
+        "2006-03-02": 15,
+        "2006-03-03": 24,
+        "2006-03-04": 0,
+        "2006-03-05": 0,
+        "2006-03-06": 18,
+        "2006-03-07": 51,
+        "2006-03-08": 4,
+        "2006-03-09": 57,
+        "2006-03-10": 28,
+        "2006-03-11": 0,
+        "2006-03-12": 13,
+        "2006-03-13": 9,
+        "2006-03-14": 49,
+        "2006-03-15": 10,
+        "2006-03-16": 1,
+        "2006-03-17": 3,
+        "2006-03-18": 0,
+        "2006-03-19": 49,
+        "2006-03-20": 5,
+        "2006-03-21": 22,
+        "2006-03-22": 17,
+        "2006-03-23": 20,
+        "2006-03-24": 16,
+        "2006-03-25": 3,
+        "2006-03-26": 7,
+        "2006-03-27": 1,
+        "2006-03-28": 38,
+        "2006-03-29": 21,
+        "2006-03-30": 36,
+        "2006-03-31": 16,
+        "2006-04-01": 8,
+        "2006-04-02": 12,
+        "2006-04-03": 17,
+        "2006-04-04": 14,
+        "2006-04-05": 15,
+        "2006-04-06": 27,
+        "2006-04-07": 16,
+        "2006-04-08": 1,
+        "2006-04-09": 0,
+        "2006-04-10": 8,
+        "2006-04-11": 56,
+        "2006-04-12": 14,
+        "2006-04-13": 39,
+        "2006-04-14": 29,
+        "2006-04-15": 3,
+        "2006-04-16": 0,
+        "2006-04-17": 4,
+        "2006-04-18": 33,
+        "2006-04-19": 29,
+        "2006-04-20": 77,
+        "2006-04-21": 36,
+        "2006-04-22": 0,
+        "2006-04-23": 0,
+        "2006-04-24": 4,
+        "2006-04-25": 50,
+        "2006-04-26": 38,
+        "2006-04-27": 19,
+        "2006-04-28": 1,
+        "2006-04-29": 25,
+        "2006-04-30": 0,
+        "2006-05-01": 22,
+        "2006-05-02": 17,
+        "2006-05-03": 14,
+        "2006-05-04": 29,
+        "2006-05-05": 33,
+        "2006-05-06": 0,
+        "2006-05-07": 0,
+        "2006-05-08": 2,
+        "2006-05-09": 40,
+        "2006-05-10": 30,
+        "2006-05-11": 8,
+        "2006-05-12": 66,
+        "2006-05-13": 0,
+        "2006-05-14": 0,
+        "2006-05-15": 19,
+        "2006-05-16": 31,
+        "2006-05-17": 19,
+        "2006-05-18": 7,
+        "2006-05-19": 35,
+        "2006-05-20": 9,
+        "2006-05-21": 0,
+        "2006-05-22": 42,
+        "2006-05-23": 13,
+        "2006-05-24": 33,
+        "2006-05-25": 16,
+        "2006-05-26": 11,
+        "2006-05-27": 3,
+        "2006-05-28": 2,
+        "2006-05-29": 1,
+        "2006-05-30": 38,
+        "2006-05-31": 43,
+        "2006-06-01": 39,
+        "2006-06-02": 41,
+        "2006-06-03": 15,
+        "2006-06-04": 0,
+        "2006-06-05": 25,
+        "2006-06-06": 45,
+        "2006-06-07": 28,
+        "2006-06-08": 6,
+        "2006-06-09": 15,
+        "2006-06-10": 0,
+        "2006-06-11": 0,
+        "2006-06-12": 39,
+        "2006-06-13": 47,
+        "2006-06-14": 4,
+        "2006-06-15": 28,
+        "2006-06-16": 16,
+        "2006-06-17": 1,
+        "2006-06-18": 0,
+        "2006-06-19": 36,
+        "2006-06-20": 2,
+        "2006-06-21": 16,
+        "2006-06-22": 37,
+        "2006-06-23": 41,
+        "2006-06-24": 20,
+        "2006-06-25": 0,
+        "2006-06-26": 9,
+        "2006-06-27": 40,
+        "2006-06-28": 30,
+        "2006-06-29": 28,
+        "2006-06-30": 21,
+        "2006-07-01": 0,
+        "2006-07-02": 0,
+        "2006-07-03": 14,
+        "2006-07-04": 0,
+        "2006-07-05": 4,
+        "2006-07-06": 53,
+        "2006-07-07": 29,
+        "2006-07-08": 1,
+        "2006-07-09": 0,
+        "2006-07-10": 27,
+        "2006-07-11": 19,
+        "2006-07-12": 20,
+        "2006-07-13": 56,
+        "2006-07-14": 1,
+        "2006-07-15": 0,
+        "2006-07-16": 0,
+        "2006-07-17": 0,
+        "2006-07-18": 59,
+        "2006-07-19": 0,
+        "2006-07-20": 0,
+        "2006-07-21": 91,
+        "2006-07-22": 0,
+        "2006-07-23": 0,
+        "2006-07-24": 33,
+        "2006-07-25": 35,
+        "2006-07-26": 1,
+        "2006-07-27": 40,
+        "2006-07-28": 21,
+        "2006-07-29": 2,
+        "2006-07-30": 0,
+        "2006-07-31": 23,
+        "2006-08-01": 24,
+        "2006-08-02": 8,
+        "2006-08-03": 16,
+        "2006-08-04": 4,
+        "2006-08-05": 24,
+        "2006-08-06": 0,
+        "2006-08-07": 17,
+        "2006-08-08": 18,
+        "2006-08-09": 42,
+        "2006-08-10": 22,
+        "2006-08-11": 25,
+        "2006-08-12": 0,
+        "2006-08-13": 0,
+        "2006-08-14": 42,
+        "2006-08-15": 3,
+        "2006-08-16": 13,
+        "2006-08-17": 39,
+        "2006-08-18": 14,
+        "2006-08-19": 0,
+        "2006-08-20": 0,
+        "2006-08-21": 38,
+        "2006-08-22": 12,
+        "2006-08-23": 24,
+        "2006-08-24": 26,
+        "2006-08-25": 6,
+        "2006-08-26": 15,
+        "2006-08-27": 11,
+        "2006-08-28": 6,
+        "2006-08-29": 23,
+        "2006-08-30": 11,
+        "2006-08-31": 55,
+        "2006-09-01": 12,
+        "2006-09-02": 0,
+        "2006-09-03": 0,
+        "2006-09-04": 0,
+        "2006-09-05": 9,
+        "2006-09-06": 41,
+        "2006-09-07": 31,
+        "2006-09-08": 23,
+        "2006-09-09": 22,
+        "2006-09-10": 0,
+        "2006-09-11": 14,
+        "2006-09-12": 34,
+        "2006-09-13": 42,
+        "2006-09-14": 36,
+        "2006-09-15": 27,
+        "2006-09-16": 0,
+        "2006-09-17": 0,
+        "2006-09-18": 0,
+        "2006-09-19": 62,
+        "2006-09-20": 1,
+        "2006-09-21": 23,
+        "2006-09-22": 3,
+        "2006-09-23": 30,
+        "2006-09-24": 0,
+        "2006-09-25": 15,
+        "2006-09-26": 20,
+        "2006-09-27": 53,
+        "2006-09-28": 23,
+        "2006-09-29": 29,
+        "2006-09-30": 0,
+        "2006-10-01": 0,
+        "2006-10-02": 0,
+        "2006-10-03": 51,
+        "2006-10-04": 0,
+        "2006-10-05": 25,
+        "2006-10-06": 0,
+        "2006-10-07": 0,
+        "2006-10-08": 0,
+        "2006-10-09": 0,
+        "2006-10-10": 86,
+        "2006-10-11": 7,
+        "2006-10-12": 31,
+        "2006-10-13": 11,
+        "2006-10-14": 0,
+        "2006-10-15": 0,
+        "2006-10-16": 11,
+        "2006-10-17": 34,
+        "2006-10-18": 70,
+        "2006-10-19": 5,
+        "2006-10-20": 35,
+        "2006-10-21": 1,
+        "2006-10-22": 0,
+        "2006-10-23": 19,
+        "2006-10-24": 20,
+        "2006-10-25": 26,
+        "2006-10-26": 43,
+        "2006-10-27": 28,
+        "2006-10-28": 11,
+        "2006-10-29": 0,
+        "2006-10-30": 6,
+        "2006-10-31": 26,
+        "2006-11-01": 16,
+        "2006-11-02": 0,
+        "2006-11-03": 30,
+        "2006-11-04": 26,
+        "2006-11-05": 0,
+        "2006-11-06": 40,
+        "2006-11-07": 23,
+        "2006-11-08": 31,
+        "2006-11-09": 4,
+        "2006-11-10": 31,
+        "2006-11-11": 5,
+        "2006-11-12": 0,
+        "2006-11-13": 0,
+        "2006-11-14": 27,
+        "2006-11-15": 29,
+        "2006-11-16": 15,
+        "2006-11-17": 26,
+        "2006-11-18": 5,
+        "2006-11-19": 0,
+        "2006-11-20": 16,
+        "2006-11-21": 31,
+        "2006-11-22": 38,
+        "2006-11-23": 0,
+        "2006-11-24": 26,
+        "2006-11-25": 0,
+        "2006-11-26": 15,
+        "2006-11-27": 7,
+        "2006-11-28": 32,
+        "2006-11-29": 9,
+        "2006-11-30": 25,
+        "2006-12-01": 41,
+        "2006-12-02": 14,
+        "2006-12-03": 9,
+        "2006-12-04": 47,
+        "2006-12-05": 15,
+        "2006-12-06": 17,
+        "2006-12-07": 47,
+        "2006-12-08": 16,
+        "2006-12-09": 0,
+        "2006-12-10": 56,
+        "2006-12-11": 19,
+        "2006-12-12": 17,
+        "2006-12-13": 8,
+        "2006-12-14": 62,
+        "2006-12-15": 43,
+        "2006-12-16": 0,
+        "2006-12-17": 0,
+        "2006-12-18": 31,
+        "2006-12-19": 8,
+        "2006-12-20": 46,
+        "2006-12-21": 26,
+        "2006-12-22": 3,
+        "2006-12-23": 24,
+        "2006-12-24": 0,
+        "2006-12-25": 0,
+        "2006-12-26": 23,
+        "2006-12-27": 31,
+        "2006-12-28": 33,
+        "2006-12-29": 18,
+        "2006-12-30": 0,
+        "2006-12-31": 125
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 6608,
+      "severity_distribution": {
+        "UNKNOWN": 6608
+      },
+      "score_distribution": {
+        "7.5": 2041,
+        "4.3": 707,
+        "6.6": 10,
+        "2.1": 144,
+        "7.8": 117,
+        "5.1": 374,
+        "5.0": 1038,
+        "7.2": 128,
+        "4.6": 136,
+        "10.0": 273,
+        "4.0": 108,
+        "3.6": 27,
+        "9.3": 107,
+        "4.9": 65,
+        "3.5": 20,
+        "6.5": 87,
+        "2.6": 270,
+        "5.8": 98,
+        "6.4": 202,
+        "9.0": 46,
+        "5.5": 15,
+        "7.1": 12,
+        "6.8": 432,
+        "7.6": 35,
+        "1.2": 17,
+        "6.2": 11,
+        "4.4": 3,
+        "1.5": 1,
+        "1.7": 13,
+        "3.2": 2,
+        "3.7": 11,
+        "6.9": 2,
+        "1.9": 3,
+        "3.3": 2,
+        "9.7": 1,
+        "6.0": 19,
+        "4.7": 2,
+        "5.4": 14,
+        "5.6": 1,
+        "2.3": 1,
+        "8.3": 1,
+        "5.7": 1,
+        "6.1": 1,
+        "4.1": 4,
+        "2.7": 1,
+        "2.4": 2,
+        "6.3": 1,
+        "2.9": 1,
+        "7.9": 1
+      }
+    },
+    "v3.0": {
+      "total": 2,
+      "severity_distribution": {
+        "HIGH": 1,
+        "MEDIUM": 1
+      },
+      "score_distribution": {
+        "7.5": 1,
+        "6.1": 1
+      }
+    },
+    "v3.1": {
+      "total": 47,
+      "severity_distribution": {
+        "MEDIUM": 14,
+        "HIGH": 22,
+        "CRITICAL": 11
+      },
+      "score_distribution": {
+        "6.1": 2,
+        "5.3": 1,
+        "5.6": 1,
+        "8.4": 1,
+        "7.5": 11,
+        "5.5": 7,
+        "7.3": 1,
+        "8.8": 3,
+        "9.8": 11,
+        "7.8": 3,
+        "8.1": 2,
+        "7.2": 1,
+        "6.5": 3
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 524,
+      "epss_gt_0_5": 106,
+      "epss_gt_0_9": 4
+    }
+  },
+  "kev": {
+    "kev_count": 2
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 272
+      },
+      {
+        "name": "Oracle",
+        "count": 164
+      },
+      {
+        "name": "Apple",
+        "count": 140
+      },
+      {
+        "name": "Mozilla",
+        "count": 122
+      },
+      {
+        "name": "Linux",
+        "count": 91
+      },
+      {
+        "name": "Ibm",
+        "count": 90
+      },
+      {
+        "name": "Sun",
+        "count": 86
+      },
+      {
+        "name": "Cisco",
+        "count": 69
+      },
+      {
+        "name": "Joomla",
+        "count": 53
+      },
+      {
+        "name": "Novell",
+        "count": 46
+      },
+      {
+        "name": "Php",
+        "count": 42
+      },
+      {
+        "name": "Mybulletinboard",
+        "count": 42
+      },
+      {
+        "name": "Symantec",
+        "count": 41
+      },
+      {
+        "name": "Hp",
+        "count": 39
+      },
+      {
+        "name": "Drupal",
+        "count": 37
+      },
+      {
+        "name": "Adobe",
+        "count": 32
+      },
+      {
+        "name": "Debian",
+        "count": 31
+      },
+      {
+        "name": "Xerox",
+        "count": 31
+      },
+      {
+        "name": "Mambo",
+        "count": 29
+      },
+      {
+        "name": "Phpbb Group",
+        "count": 28
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-94",
+        "count": 184
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 144
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 122
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 100
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 75
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 53
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 51
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 35
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 31
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 24
+      },
+      {
+        "cwe": "CWE-134",
+        "count": 17
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 13
+      },
+      {
+        "cwe": "CWE-88",
+        "count": 9
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-120",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-400",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-362",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 6
+      },
+      {
+        "cwe": "CWE-16",
+        "count": 5
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 5
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 6598
+      },
+      {
+        "status": "Analyzed",
+        "count": 10
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 15948
+      },
+      {
+        "tag": "Patch",
+        "count": 9344
+      },
+      {
+        "tag": "Exploit",
+        "count": 8026
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 3066
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 1764
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1490
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 836
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 354
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 234
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 132
+      },
+      {
+        "tag": "Mailing List",
+        "count": 128
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 46
+      },
+      {
+        "tag": "Release Notes",
+        "count": 22
+      },
+      {
+        "tag": "Product",
+        "count": 14
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 4
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:42.972857",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2007.json b/web/data/cve_2007.json
new file mode 100644
index 00000000000..b5e9e8f2c00
--- /dev/null
+++ b/web/data/cve_2007.json
@@ -0,0 +1,754 @@
+{
+  "year": 2007,
+  "total_cves": 6516,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 594,
+      "2": 534,
+      "3": 704,
+      "4": 627,
+      "5": 565,
+      "6": 563,
+      "7": 571,
+      "8": 522,
+      "9": 434,
+      "10": 546,
+      "11": 421,
+      "12": 435
+    },
+    "daily_analysis": {
+      "total_days": 270,
+      "avg_per_day": 24.13,
+      "highest_day": {
+        "date": "2007-03-02",
+        "count": 114
+      },
+      "lowest_day": {
+        "date": "2007-01-01",
+        "count": 1
+      },
+      "daily_counts": {
+        "2007-01-01": 1,
+        "2007-01-02": 0,
+        "2007-01-03": 7,
+        "2007-01-04": 10,
+        "2007-01-05": 25,
+        "2007-01-06": 0,
+        "2007-01-07": 0,
+        "2007-01-08": 3,
+        "2007-01-09": 64,
+        "2007-01-10": 8,
+        "2007-01-11": 28,
+        "2007-01-12": 16,
+        "2007-01-13": 20,
+        "2007-01-14": 0,
+        "2007-01-15": 0,
+        "2007-01-16": 32,
+        "2007-01-17": 41,
+        "2007-01-18": 38,
+        "2007-01-19": 56,
+        "2007-01-20": 1,
+        "2007-01-21": 0,
+        "2007-01-22": 6,
+        "2007-01-23": 44,
+        "2007-01-24": 12,
+        "2007-01-25": 28,
+        "2007-01-26": 33,
+        "2007-01-27": 1,
+        "2007-01-28": 0,
+        "2007-01-29": 34,
+        "2007-01-30": 50,
+        "2007-01-31": 36,
+        "2007-02-01": 15,
+        "2007-02-02": 9,
+        "2007-02-03": 27,
+        "2007-02-04": 13,
+        "2007-02-05": 0,
+        "2007-02-06": 38,
+        "2007-02-07": 39,
+        "2007-02-08": 34,
+        "2007-02-09": 20,
+        "2007-02-10": 0,
+        "2007-02-11": 1,
+        "2007-02-12": 43,
+        "2007-02-13": 29,
+        "2007-02-14": 22,
+        "2007-02-15": 25,
+        "2007-02-16": 34,
+        "2007-02-17": 0,
+        "2007-02-18": 0,
+        "2007-02-19": 0,
+        "2007-02-20": 9,
+        "2007-02-21": 50,
+        "2007-02-22": 23,
+        "2007-02-23": 28,
+        "2007-02-24": 23,
+        "2007-02-25": 0,
+        "2007-02-26": 34,
+        "2007-02-27": 18,
+        "2007-02-28": 0,
+        "2007-03-01": 0,
+        "2007-03-02": 114,
+        "2007-03-03": 41,
+        "2007-03-04": 2,
+        "2007-03-05": 13,
+        "2007-03-06": 36,
+        "2007-03-07": 59,
+        "2007-03-08": 13,
+        "2007-03-09": 4,
+        "2007-03-10": 45,
+        "2007-03-11": 0,
+        "2007-03-12": 10,
+        "2007-03-13": 32,
+        "2007-03-14": 19,
+        "2007-03-15": 1,
+        "2007-03-16": 38,
+        "2007-03-17": 1,
+        "2007-03-18": 0,
+        "2007-03-19": 9,
+        "2007-03-20": 61,
+        "2007-03-21": 43,
+        "2007-03-22": 21,
+        "2007-03-23": 29,
+        "2007-03-24": 20,
+        "2007-03-25": 0,
+        "2007-03-26": 4,
+        "2007-03-27": 24,
+        "2007-03-28": 24,
+        "2007-03-29": 1,
+        "2007-03-30": 32,
+        "2007-03-31": 8,
+        "2007-04-01": 0,
+        "2007-04-02": 35,
+        "2007-04-03": 35,
+        "2007-04-04": 8,
+        "2007-04-05": 0,
+        "2007-04-06": 26,
+        "2007-04-07": 0,
+        "2007-04-08": 0,
+        "2007-04-09": 5,
+        "2007-04-10": 48,
+        "2007-04-11": 39,
+        "2007-04-12": 48,
+        "2007-04-13": 14,
+        "2007-04-14": 0,
+        "2007-04-15": 0,
+        "2007-04-16": 26,
+        "2007-04-17": 0,
+        "2007-04-18": 85,
+        "2007-04-19": 23,
+        "2007-04-20": 0,
+        "2007-04-21": 0,
+        "2007-04-22": 15,
+        "2007-04-23": 0,
+        "2007-04-24": 62,
+        "2007-04-25": 44,
+        "2007-04-26": 40,
+        "2007-04-27": 28,
+        "2007-04-28": 0,
+        "2007-04-29": 0,
+        "2007-04-30": 46,
+        "2007-05-01": 5,
+        "2007-05-02": 55,
+        "2007-05-03": 13,
+        "2007-05-04": 17,
+        "2007-05-05": 0,
+        "2007-05-06": 0,
+        "2007-05-07": 3,
+        "2007-05-08": 25,
+        "2007-05-09": 65,
+        "2007-05-10": 12,
+        "2007-05-11": 47,
+        "2007-05-12": 0,
+        "2007-05-13": 16,
+        "2007-05-14": 41,
+        "2007-05-15": 5,
+        "2007-05-16": 55,
+        "2007-05-17": 22,
+        "2007-05-18": 12,
+        "2007-05-19": 0,
+        "2007-05-20": 0,
+        "2007-05-21": 24,
+        "2007-05-22": 37,
+        "2007-05-23": 1,
+        "2007-05-24": 34,
+        "2007-05-25": 3,
+        "2007-05-26": 0,
+        "2007-05-27": 0,
+        "2007-05-28": 0,
+        "2007-05-29": 9,
+        "2007-05-30": 39,
+        "2007-05-31": 25,
+        "2007-06-01": 31,
+        "2007-06-02": 0,
+        "2007-06-03": 0,
+        "2007-06-04": 24,
+        "2007-06-05": 10,
+        "2007-06-06": 57,
+        "2007-06-07": 21,
+        "2007-06-08": 13,
+        "2007-06-09": 0,
+        "2007-06-10": 0,
+        "2007-06-11": 45,
+        "2007-06-12": 37,
+        "2007-06-13": 1,
+        "2007-06-14": 32,
+        "2007-06-15": 15,
+        "2007-06-16": 0,
+        "2007-06-17": 0,
+        "2007-06-18": 10,
+        "2007-06-19": 29,
+        "2007-06-20": 17,
+        "2007-06-21": 36,
+        "2007-06-22": 35,
+        "2007-06-23": 0,
+        "2007-06-24": 0,
+        "2007-06-25": 8,
+        "2007-06-26": 46,
+        "2007-06-27": 53,
+        "2007-06-28": 19,
+        "2007-06-29": 19,
+        "2007-06-30": 5,
+        "2007-07-01": 0,
+        "2007-07-02": 4,
+        "2007-07-03": 46,
+        "2007-07-04": 11,
+        "2007-07-05": 29,
+        "2007-07-06": 28,
+        "2007-07-07": 0,
+        "2007-07-08": 0,
+        "2007-07-09": 11,
+        "2007-07-10": 48,
+        "2007-07-11": 39,
+        "2007-07-12": 19,
+        "2007-07-13": 0,
+        "2007-07-14": 2,
+        "2007-07-15": 43,
+        "2007-07-16": 6,
+        "2007-07-17": 39,
+        "2007-07-18": 40,
+        "2007-07-19": 6,
+        "2007-07-20": 1,
+        "2007-07-21": 22,
+        "2007-07-22": 0,
+        "2007-07-23": 3,
+        "2007-07-24": 17,
+        "2007-07-25": 38,
+        "2007-07-26": 31,
+        "2007-07-27": 20,
+        "2007-07-28": 0,
+        "2007-07-29": 0,
+        "2007-07-30": 50,
+        "2007-07-31": 18,
+        "2007-08-01": 12,
+        "2007-08-02": 0,
+        "2007-08-03": 41,
+        "2007-08-04": 0,
+        "2007-08-05": 0,
+        "2007-08-06": 0,
+        "2007-08-07": 11,
+        "2007-08-08": 83,
+        "2007-08-09": 22,
+        "2007-08-10": 2,
+        "2007-08-11": 0,
+        "2007-08-12": 0,
+        "2007-08-13": 21,
+        "2007-08-14": 42,
+        "2007-08-15": 24,
+        "2007-08-16": 10,
+        "2007-08-17": 15,
+        "2007-08-18": 35,
+        "2007-08-19": 0,
+        "2007-08-20": 15,
+        "2007-08-21": 28,
+        "2007-08-22": 18,
+        "2007-08-23": 20,
+        "2007-08-24": 0,
+        "2007-08-25": 16,
+        "2007-08-26": 0,
+        "2007-08-27": 15,
+        "2007-08-28": 23,
+        "2007-08-29": 16,
+        "2007-08-30": 6,
+        "2007-08-31": 47,
+        "2007-09-01": 0,
+        "2007-09-02": 0,
+        "2007-09-03": 0,
+        "2007-09-04": 22,
+        "2007-09-05": 23,
+        "2007-09-06": 20,
+        "2007-09-07": 0,
+        "2007-09-08": 12,
+        "2007-09-09": 0,
+        "2007-09-10": 27,
+        "2007-09-11": 24,
+        "2007-09-12": 31,
+        "2007-09-13": 1,
+        "2007-09-14": 28,
+        "2007-09-15": 0,
+        "2007-09-16": 0,
+        "2007-09-17": 25,
+        "2007-09-18": 51,
+        "2007-09-19": 19,
+        "2007-09-20": 12,
+        "2007-09-21": 23,
+        "2007-09-22": 0,
+        "2007-09-23": 0,
+        "2007-09-24": 43,
+        "2007-09-25": 1,
+        "2007-09-26": 33,
+        "2007-09-27": 31,
+        "2007-09-28": 8,
+        "2007-09-29": 0,
+        "2007-09-30": 0,
+        "2007-10-01": 37,
+        "2007-10-02": 0,
+        "2007-10-03": 17,
+        "2007-10-04": 16,
+        "2007-10-05": 24,
+        "2007-10-06": 27,
+        "2007-10-07": 0,
+        "2007-10-08": 18,
+        "2007-10-09": 44,
+        "2007-10-10": 0,
+        "2007-10-11": 19,
+        "2007-10-12": 42,
+        "2007-10-13": 15,
+        "2007-10-14": 23,
+        "2007-10-15": 8,
+        "2007-10-16": 16,
+        "2007-10-17": 36,
+        "2007-10-18": 46,
+        "2007-10-19": 17,
+        "2007-10-20": 1,
+        "2007-10-21": 8,
+        "2007-10-22": 4,
+        "2007-10-23": 33,
+        "2007-10-24": 7,
+        "2007-10-25": 2,
+        "2007-10-26": 3,
+        "2007-10-27": 0,
+        "2007-10-28": 4,
+        "2007-10-29": 26,
+        "2007-10-30": 39,
+        "2007-10-31": 14,
+        "2007-11-01": 23,
+        "2007-11-02": 5,
+        "2007-11-03": 7,
+        "2007-11-04": 0,
+        "2007-11-05": 41,
+        "2007-11-06": 12,
+        "2007-11-07": 18,
+        "2007-11-08": 17,
+        "2007-11-09": 3,
+        "2007-11-10": 26,
+        "2007-11-11": 0,
+        "2007-11-12": 0,
+        "2007-11-13": 7,
+        "2007-11-14": 27,
+        "2007-11-15": 73,
+        "2007-11-16": 4,
+        "2007-11-17": 0,
+        "2007-11-18": 0,
+        "2007-11-19": 2,
+        "2007-11-20": 41,
+        "2007-11-21": 7,
+        "2007-11-22": 18,
+        "2007-11-23": 19,
+        "2007-11-24": 0,
+        "2007-11-25": 0,
+        "2007-11-26": 12,
+        "2007-11-27": 16,
+        "2007-11-28": 0,
+        "2007-11-29": 16,
+        "2007-11-30": 27,
+        "2007-12-01": 9,
+        "2007-12-02": 0,
+        "2007-12-03": 3,
+        "2007-12-04": 34,
+        "2007-12-05": 7,
+        "2007-12-06": 14,
+        "2007-12-07": 17,
+        "2007-12-08": 0,
+        "2007-12-09": 0,
+        "2007-12-10": 21,
+        "2007-12-11": 8,
+        "2007-12-12": 18,
+        "2007-12-13": 23,
+        "2007-12-14": 2,
+        "2007-12-15": 38,
+        "2007-12-16": 0,
+        "2007-12-17": 28,
+        "2007-12-18": 13,
+        "2007-12-19": 26,
+        "2007-12-20": 74,
+        "2007-12-21": 10,
+        "2007-12-22": 0,
+        "2007-12-23": 0,
+        "2007-12-24": 9,
+        "2007-12-25": 0,
+        "2007-12-26": 0,
+        "2007-12-27": 18,
+        "2007-12-28": 51,
+        "2007-12-29": 0,
+        "2007-12-30": 0,
+        "2007-12-31": 12
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 6516,
+      "severity_distribution": {
+        "UNKNOWN": 6516
+      },
+      "score_distribution": {
+        "10.0": 475,
+        "6.8": 795,
+        "2.1": 80,
+        "7.5": 1509,
+        "5.0": 665,
+        "7.8": 356,
+        "5.1": 27,
+        "9.4": 16,
+        "4.6": 71,
+        "4.3": 941,
+        "7.1": 93,
+        "7.2": 147,
+        "4.0": 43,
+        "4.9": 70,
+        "5.8": 66,
+        "1.2": 5,
+        "2.6": 38,
+        "6.4": 97,
+        "6.0": 59,
+        "9.3": 442,
+        "4.4": 34,
+        "3.5": 49,
+        "8.5": 28,
+        "6.6": 25,
+        "4.1": 5,
+        "6.5": 87,
+        "5.5": 20,
+        "1.9": 21,
+        "6.9": 59,
+        "9.0": 49,
+        "7.6": 41,
+        "3.7": 4,
+        "3.2": 1,
+        "1.7": 4,
+        "6.2": 16,
+        "1.5": 4,
+        "3.3": 12,
+        "2.9": 2,
+        "5.4": 9,
+        "3.6": 8,
+        "4.7": 14,
+        "6.1": 7,
+        "7.3": 1,
+        "5.2": 1,
+        "6.3": 6,
+        "3.4": 1,
+        "3.8": 1,
+        "7.9": 1,
+        "7.4": 1,
+        "8.3": 3,
+        "1.8": 1,
+        "2.3": 2,
+        "8.8": 3,
+        "5.7": 1
+      }
+    },
+    "v3.0": {
+      "total": 1,
+      "severity_distribution": {
+        "MEDIUM": 1
+      },
+      "score_distribution": {
+        "5.9": 1
+      }
+    },
+    "v3.1": {
+      "total": 59,
+      "severity_distribution": {
+        "HIGH": 26,
+        "CRITICAL": 21,
+        "MEDIUM": 12
+      },
+      "score_distribution": {
+        "7.5": 15,
+        "9.8": 20,
+        "6.5": 1,
+        "7.8": 6,
+        "8.8": 3,
+        "5.4": 1,
+        "9.1": 1,
+        "5.5": 3,
+        "6.1": 4,
+        "5.3": 2,
+        "4.6": 1,
+        "8.1": 2
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 665,
+      "epss_gt_0_5": 121,
+      "epss_gt_0_9": 3
+    }
+  },
+  "kev": {
+    "kev_count": 2
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 343
+      },
+      {
+        "name": "Apple",
+        "count": 238
+      },
+      {
+        "name": "Ibm",
+        "count": 148
+      },
+      {
+        "name": "Oracle",
+        "count": 141
+      },
+      {
+        "name": "Sun",
+        "count": 136
+      },
+      {
+        "name": "Php",
+        "count": 116
+      },
+      {
+        "name": "Cisco",
+        "count": 113
+      },
+      {
+        "name": "Linux",
+        "count": 105
+      },
+      {
+        "name": "Mozilla",
+        "count": 89
+      },
+      {
+        "name": "Hp",
+        "count": 85
+      },
+      {
+        "name": "Debian",
+        "count": 68
+      },
+      {
+        "name": "Joomla",
+        "count": 59
+      },
+      {
+        "name": "Redhat",
+        "count": 58
+      },
+      {
+        "name": "Canonical",
+        "count": 49
+      },
+      {
+        "name": "Wordpress",
+        "count": 48
+      },
+      {
+        "name": "Broadcom",
+        "count": 47
+      },
+      {
+        "name": "Symantec",
+        "count": 46
+      },
+      {
+        "name": "Apache",
+        "count": 45
+      },
+      {
+        "name": "Bea",
+        "count": 40
+      },
+      {
+        "name": "Hitachi",
+        "count": 37
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-119",
+        "count": 431
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 361
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 308
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 256
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 237
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 217
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 165
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 101
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 98
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 88
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 68
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 37
+      },
+      {
+        "cwe": "CWE-16",
+        "count": 32
+      },
+      {
+        "cwe": "CWE-134",
+        "count": 30
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 24
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 23
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 23
+      },
+      {
+        "cwe": "CWE-362",
+        "count": 17
+      },
+      {
+        "cwe": "CWE-190",
+        "count": 9
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 7
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 6506
+      },
+      {
+        "status": "Analyzed",
+        "count": 10
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 11817
+      },
+      {
+        "tag": "Patch",
+        "count": 6274
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 5058
+      },
+      {
+        "tag": "Exploit",
+        "count": 4150
+      },
+      {
+        "tag": "Broken Link",
+        "count": 2154
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 1538
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 1358
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 242
+      },
+      {
+        "tag": "Mailing List",
+        "count": 240
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 200
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 134
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 102
+      },
+      {
+        "tag": "Release Notes",
+        "count": 28
+      },
+      {
+        "tag": "Technical Description",
+        "count": 16
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 14
+      },
+      {
+        "tag": "Product",
+        "count": 4
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:43.112329",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2008.json b/web/data/cve_2008.json
new file mode 100644
index 00000000000..5297856e7a8
--- /dev/null
+++ b/web/data/cve_2008.json
@@ -0,0 +1,761 @@
+{
+  "year": 2008,
+  "total_cves": 5632,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 497,
+      "2": 524,
+      "3": 506,
+      "4": 454,
+      "5": 383,
+      "6": 435,
+      "7": 517,
+      "8": 367,
+      "9": 449,
+      "10": 524,
+      "11": 448,
+      "12": 528
+    },
+    "daily_analysis": {
+      "total_days": 255,
+      "avg_per_day": 22.09,
+      "highest_day": {
+        "date": "2008-02-12",
+        "count": 88
+      },
+      "lowest_day": {
+        "date": "2008-06-09",
+        "count": 1
+      },
+      "daily_counts": {
+        "2008-01-01": 0,
+        "2008-01-02": 0,
+        "2008-01-03": 11,
+        "2008-01-04": 54,
+        "2008-01-05": 0,
+        "2008-01-06": 0,
+        "2008-01-07": 0,
+        "2008-01-08": 45,
+        "2008-01-09": 34,
+        "2008-01-10": 37,
+        "2008-01-11": 13,
+        "2008-01-12": 16,
+        "2008-01-13": 0,
+        "2008-01-14": 0,
+        "2008-01-15": 34,
+        "2008-01-16": 29,
+        "2008-01-17": 43,
+        "2008-01-18": 23,
+        "2008-01-19": 3,
+        "2008-01-20": 0,
+        "2008-01-21": 0,
+        "2008-01-22": 16,
+        "2008-01-23": 41,
+        "2008-01-24": 0,
+        "2008-01-25": 27,
+        "2008-01-26": 0,
+        "2008-01-27": 0,
+        "2008-01-28": 0,
+        "2008-01-29": 30,
+        "2008-01-30": 15,
+        "2008-01-31": 26,
+        "2008-02-01": 19,
+        "2008-02-02": 0,
+        "2008-02-03": 0,
+        "2008-02-04": 8,
+        "2008-02-05": 39,
+        "2008-02-06": 34,
+        "2008-02-07": 17,
+        "2008-02-08": 18,
+        "2008-02-09": 4,
+        "2008-02-10": 0,
+        "2008-02-11": 4,
+        "2008-02-12": 88,
+        "2008-02-13": 45,
+        "2008-02-14": 18,
+        "2008-02-15": 25,
+        "2008-02-16": 0,
+        "2008-02-17": 0,
+        "2008-02-18": 2,
+        "2008-02-19": 30,
+        "2008-02-20": 16,
+        "2008-02-21": 40,
+        "2008-02-22": 29,
+        "2008-02-23": 0,
+        "2008-02-24": 0,
+        "2008-02-25": 25,
+        "2008-02-26": 5,
+        "2008-02-27": 19,
+        "2008-02-28": 22,
+        "2008-02-29": 17,
+        "2008-03-01": 0,
+        "2008-03-02": 0,
+        "2008-03-03": 16,
+        "2008-03-04": 24,
+        "2008-03-05": 15,
+        "2008-03-06": 32,
+        "2008-03-07": 0,
+        "2008-03-08": 11,
+        "2008-03-09": 5,
+        "2008-03-10": 55,
+        "2008-03-11": 20,
+        "2008-03-12": 26,
+        "2008-03-13": 19,
+        "2008-03-14": 7,
+        "2008-03-15": 0,
+        "2008-03-16": 0,
+        "2008-03-17": 24,
+        "2008-03-18": 39,
+        "2008-03-19": 15,
+        "2008-03-20": 47,
+        "2008-03-21": 0,
+        "2008-03-22": 0,
+        "2008-03-23": 0,
+        "2008-03-24": 41,
+        "2008-03-25": 27,
+        "2008-03-26": 10,
+        "2008-03-27": 17,
+        "2008-03-28": 19,
+        "2008-03-29": 0,
+        "2008-03-30": 0,
+        "2008-03-31": 37,
+        "2008-04-01": 11,
+        "2008-04-02": 40,
+        "2008-04-03": 0,
+        "2008-04-04": 20,
+        "2008-04-05": 0,
+        "2008-04-06": 6,
+        "2008-04-07": 11,
+        "2008-04-08": 22,
+        "2008-04-09": 19,
+        "2008-04-10": 11,
+        "2008-04-11": 20,
+        "2008-04-12": 10,
+        "2008-04-13": 0,
+        "2008-04-14": 15,
+        "2008-04-15": 18,
+        "2008-04-16": 60,
+        "2008-04-17": 30,
+        "2008-04-18": 16,
+        "2008-04-19": 0,
+        "2008-04-20": 0,
+        "2008-04-21": 3,
+        "2008-04-22": 19,
+        "2008-04-23": 14,
+        "2008-04-24": 4,
+        "2008-04-25": 28,
+        "2008-04-26": 0,
+        "2008-04-27": 29,
+        "2008-04-28": 13,
+        "2008-04-29": 2,
+        "2008-04-30": 33,
+        "2008-05-01": 9,
+        "2008-05-02": 11,
+        "2008-05-03": 0,
+        "2008-05-04": 0,
+        "2008-05-05": 15,
+        "2008-05-06": 11,
+        "2008-05-07": 10,
+        "2008-05-08": 14,
+        "2008-05-09": 16,
+        "2008-05-10": 0,
+        "2008-05-11": 0,
+        "2008-05-12": 24,
+        "2008-05-13": 34,
+        "2008-05-14": 43,
+        "2008-05-15": 0,
+        "2008-05-16": 34,
+        "2008-05-17": 0,
+        "2008-05-18": 22,
+        "2008-05-19": 12,
+        "2008-05-20": 12,
+        "2008-05-21": 17,
+        "2008-05-22": 19,
+        "2008-05-23": 17,
+        "2008-05-24": 0,
+        "2008-05-25": 0,
+        "2008-05-26": 0,
+        "2008-05-27": 19,
+        "2008-05-28": 22,
+        "2008-05-29": 22,
+        "2008-05-30": 0,
+        "2008-05-31": 0,
+        "2008-06-01": 0,
+        "2008-06-02": 28,
+        "2008-06-03": 27,
+        "2008-06-04": 31,
+        "2008-06-05": 16,
+        "2008-06-06": 20,
+        "2008-06-07": 0,
+        "2008-06-08": 0,
+        "2008-06-09": 1,
+        "2008-06-10": 33,
+        "2008-06-11": 1,
+        "2008-06-12": 27,
+        "2008-06-13": 21,
+        "2008-06-14": 0,
+        "2008-06-15": 0,
+        "2008-06-16": 31,
+        "2008-06-17": 5,
+        "2008-06-18": 31,
+        "2008-06-19": 13,
+        "2008-06-20": 13,
+        "2008-06-21": 0,
+        "2008-06-22": 0,
+        "2008-06-23": 20,
+        "2008-06-24": 16,
+        "2008-06-25": 27,
+        "2008-06-26": 20,
+        "2008-06-27": 17,
+        "2008-06-28": 0,
+        "2008-06-29": 0,
+        "2008-06-30": 37,
+        "2008-07-01": 13,
+        "2008-07-02": 34,
+        "2008-07-03": 9,
+        "2008-07-04": 0,
+        "2008-07-05": 0,
+        "2008-07-06": 0,
+        "2008-07-07": 57,
+        "2008-07-08": 15,
+        "2008-07-09": 43,
+        "2008-07-10": 26,
+        "2008-07-11": 12,
+        "2008-07-12": 0,
+        "2008-07-13": 0,
+        "2008-07-14": 23,
+        "2008-07-15": 54,
+        "2008-07-16": 9,
+        "2008-07-17": 12,
+        "2008-07-18": 30,
+        "2008-07-19": 0,
+        "2008-07-20": 0,
+        "2008-07-21": 17,
+        "2008-07-22": 12,
+        "2008-07-23": 0,
+        "2008-07-24": 17,
+        "2008-07-25": 31,
+        "2008-07-26": 0,
+        "2008-07-27": 10,
+        "2008-07-28": 22,
+        "2008-07-29": 5,
+        "2008-07-30": 27,
+        "2008-07-31": 39,
+        "2008-08-01": 22,
+        "2008-08-02": 0,
+        "2008-08-03": 0,
+        "2008-08-04": 25,
+        "2008-08-05": 8,
+        "2008-08-06": 23,
+        "2008-08-07": 10,
+        "2008-08-08": 21,
+        "2008-08-09": 0,
+        "2008-08-10": 24,
+        "2008-08-11": 10,
+        "2008-08-12": 26,
+        "2008-08-13": 39,
+        "2008-08-14": 17,
+        "2008-08-15": 6,
+        "2008-08-16": 0,
+        "2008-08-17": 0,
+        "2008-08-18": 10,
+        "2008-08-19": 13,
+        "2008-08-20": 18,
+        "2008-08-21": 18,
+        "2008-08-22": 10,
+        "2008-08-23": 0,
+        "2008-08-24": 0,
+        "2008-08-25": 3,
+        "2008-08-26": 11,
+        "2008-08-27": 35,
+        "2008-08-28": 7,
+        "2008-08-29": 11,
+        "2008-08-30": 0,
+        "2008-08-31": 0,
+        "2008-09-01": 0,
+        "2008-09-02": 16,
+        "2008-09-03": 28,
+        "2008-09-04": 36,
+        "2008-09-05": 22,
+        "2008-09-06": 0,
+        "2008-09-07": 0,
+        "2008-09-08": 0,
+        "2008-09-09": 0,
+        "2008-09-10": 0,
+        "2008-09-11": 72,
+        "2008-09-12": 6,
+        "2008-09-13": 0,
+        "2008-09-14": 0,
+        "2008-09-15": 23,
+        "2008-09-16": 25,
+        "2008-09-17": 0,
+        "2008-09-18": 29,
+        "2008-09-19": 8,
+        "2008-09-20": 0,
+        "2008-09-21": 0,
+        "2008-09-22": 18,
+        "2008-09-23": 17,
+        "2008-09-24": 49,
+        "2008-09-25": 7,
+        "2008-09-26": 19,
+        "2008-09-27": 16,
+        "2008-09-28": 0,
+        "2008-09-29": 17,
+        "2008-09-30": 41,
+        "2008-10-01": 13,
+        "2008-10-02": 8,
+        "2008-10-03": 35,
+        "2008-10-04": 0,
+        "2008-10-05": 0,
+        "2008-10-06": 15,
+        "2008-10-07": 24,
+        "2008-10-08": 22,
+        "2008-10-09": 39,
+        "2008-10-10": 17,
+        "2008-10-11": 0,
+        "2008-10-12": 0,
+        "2008-10-13": 10,
+        "2008-10-14": 56,
+        "2008-10-15": 43,
+        "2008-10-16": 3,
+        "2008-10-17": 9,
+        "2008-10-18": 8,
+        "2008-10-19": 0,
+        "2008-10-20": 11,
+        "2008-10-21": 28,
+        "2008-10-22": 55,
+        "2008-10-23": 36,
+        "2008-10-24": 14,
+        "2008-10-25": 0,
+        "2008-10-26": 0,
+        "2008-10-27": 16,
+        "2008-10-28": 21,
+        "2008-10-29": 17,
+        "2008-10-30": 9,
+        "2008-10-31": 15,
+        "2008-11-01": 16,
+        "2008-11-02": 0,
+        "2008-11-03": 2,
+        "2008-11-04": 50,
+        "2008-11-05": 37,
+        "2008-11-06": 28,
+        "2008-11-07": 9,
+        "2008-11-08": 0,
+        "2008-11-09": 0,
+        "2008-11-10": 33,
+        "2008-11-11": 0,
+        "2008-11-12": 11,
+        "2008-11-13": 38,
+        "2008-11-14": 19,
+        "2008-11-15": 0,
+        "2008-11-16": 0,
+        "2008-11-17": 30,
+        "2008-11-18": 47,
+        "2008-11-19": 14,
+        "2008-11-20": 6,
+        "2008-11-21": 26,
+        "2008-11-22": 0,
+        "2008-11-23": 0,
+        "2008-11-24": 10,
+        "2008-11-25": 25,
+        "2008-11-26": 23,
+        "2008-11-27": 5,
+        "2008-11-28": 13,
+        "2008-11-29": 6,
+        "2008-11-30": 0,
+        "2008-12-01": 20,
+        "2008-12-02": 6,
+        "2008-12-03": 17,
+        "2008-12-04": 0,
+        "2008-12-05": 41,
+        "2008-12-06": 0,
+        "2008-12-07": 0,
+        "2008-12-08": 20,
+        "2008-12-09": 19,
+        "2008-12-10": 52,
+        "2008-12-11": 18,
+        "2008-12-12": 49,
+        "2008-12-13": 1,
+        "2008-12-14": 0,
+        "2008-12-15": 26,
+        "2008-12-16": 24,
+        "2008-12-17": 72,
+        "2008-12-18": 1,
+        "2008-12-19": 42,
+        "2008-12-20": 0,
+        "2008-12-21": 0,
+        "2008-12-22": 11,
+        "2008-12-23": 7,
+        "2008-12-24": 11,
+        "2008-12-25": 0,
+        "2008-12-26": 27,
+        "2008-12-27": 0,
+        "2008-12-28": 0,
+        "2008-12-29": 7,
+        "2008-12-30": 31,
+        "2008-12-31": 26
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 5632,
+      "severity_distribution": {
+        "UNKNOWN": 5632
+      },
+      "score_distribution": {
+        "4.6": 56,
+        "10.0": 425,
+        "5.0": 521,
+        "4.3": 964,
+        "6.4": 66,
+        "6.8": 468,
+        "7.5": 1425,
+        "5.8": 41,
+        "6.5": 87,
+        "9.3": 513,
+        "4.0": 42,
+        "3.5": 45,
+        "7.1": 69,
+        "7.2": 141,
+        "2.1": 61,
+        "7.8": 149,
+        "8.5": 28,
+        "6.9": 147,
+        "6.2": 7,
+        "5.1": 25,
+        "2.6": 33,
+        "3.3": 7,
+        "9.0": 63,
+        "4.9": 67,
+        "4.4": 22,
+        "1.9": 16,
+        "6.3": 8,
+        "8.8": 5,
+        "3.6": 12,
+        "6.0": 28,
+        "5.5": 17,
+        "6.6": 6,
+        "4.7": 22,
+        "7.9": 1,
+        "3.7": 5,
+        "9.4": 4,
+        "5.4": 6,
+        "1.7": 3,
+        "7.6": 15,
+        "4.1": 1,
+        "4.8": 1,
+        "8.3": 3,
+        "1.5": 1,
+        "1.2": 2,
+        "6.1": 1,
+        "1.0": 2,
+        "3.2": 1
+      }
+    },
+    "v3.0": {
+      "total": 1,
+      "severity_distribution": {
+        "CRITICAL": 1
+      },
+      "score_distribution": {
+        "9.8": 1
+      }
+    },
+    "v3.1": {
+      "total": 87,
+      "severity_distribution": {
+        "HIGH": 46,
+        "MEDIUM": 22,
+        "CRITICAL": 18,
+        "LOW": 1
+      },
+      "score_distribution": {
+        "7.8": 8,
+        "5.3": 3,
+        "9.8": 16,
+        "5.5": 6,
+        "7.5": 23,
+        "8.8": 8,
+        "6.1": 8,
+        "8.1": 5,
+        "6.8": 1,
+        "9.1": 2,
+        "4.4": 1,
+        "6.5": 2,
+        "8.4": 1,
+        "5.9": 1,
+        "3.7": 1,
+        "7.0": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 562,
+      "epss_gt_0_5": 92,
+      "epss_gt_0_9": 7
+    }
+  },
+  "kev": {
+    "kev_count": 6
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 337
+      },
+      {
+        "name": "Apple",
+        "count": 228
+      },
+      {
+        "name": "Sun",
+        "count": 160
+      },
+      {
+        "name": "Ibm",
+        "count": 148
+      },
+      {
+        "name": "Oracle",
+        "count": 130
+      },
+      {
+        "name": "Joomla",
+        "count": 119
+      },
+      {
+        "name": "Debian",
+        "count": 114
+      },
+      {
+        "name": "Mozilla",
+        "count": 102
+      },
+      {
+        "name": "Linux",
+        "count": 98
+      },
+      {
+        "name": "Cisco",
+        "count": 94
+      },
+      {
+        "name": "Redhat",
+        "count": 81
+      },
+      {
+        "name": "Canonical",
+        "count": 77
+      },
+      {
+        "name": "Drupal",
+        "count": 73
+      },
+      {
+        "name": "Hp",
+        "count": 72
+      },
+      {
+        "name": "Adobe",
+        "count": 65
+      },
+      {
+        "name": "Typo3",
+        "count": 53
+      },
+      {
+        "name": "Wordpress",
+        "count": 52
+      },
+      {
+        "name": "Novell",
+        "count": 50
+      },
+      {
+        "name": "Mambo",
+        "count": 48
+      },
+      {
+        "name": "Opera",
+        "count": 35
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-89",
+        "count": 1093
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 797
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 554
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 433
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 381
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 352
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 312
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 285
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 193
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 174
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 142
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 140
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 80
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 49
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 34
+      },
+      {
+        "cwe": "CWE-16",
+        "count": 34
+      },
+      {
+        "cwe": "CWE-134",
+        "count": 24
+      },
+      {
+        "cwe": "CWE-362",
+        "count": 24
+      },
+      {
+        "cwe": "CWE-190",
+        "count": 13
+      },
+      {
+        "cwe": "CWE-120",
+        "count": 8
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 5621
+      },
+      {
+        "status": "Analyzed",
+        "count": 11
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 9746
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 8735
+      },
+      {
+        "tag": "Exploit",
+        "count": 4872
+      },
+      {
+        "tag": "Patch",
+        "count": 4100
+      },
+      {
+        "tag": "Broken Link",
+        "count": 2270
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 2130
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 1285
+      },
+      {
+        "tag": "Mailing List",
+        "count": 696
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 396
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 346
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 232
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 160
+      },
+      {
+        "tag": "Release Notes",
+        "count": 26
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 24
+      },
+      {
+        "tag": "Product",
+        "count": 17
+      },
+      {
+        "tag": "Technical Description",
+        "count": 6
+      },
+      {
+        "tag": "Mitigation",
+        "count": 4
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 2
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:43.253704",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2009.json b/web/data/cve_2009.json
new file mode 100644
index 00000000000..04014a73188
--- /dev/null
+++ b/web/data/cve_2009.json
@@ -0,0 +1,756 @@
+{
+  "year": 2009,
+  "total_cves": 5732,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 466,
+      "2": 685,
+      "3": 553,
+      "4": 567,
+      "5": 364,
+      "6": 450,
+      "7": 446,
+      "8": 527,
+      "9": 574,
+      "10": 352,
+      "11": 308,
+      "12": 440
+    },
+    "daily_analysis": {
+      "total_days": 263,
+      "avg_per_day": 21.79,
+      "highest_day": {
+        "date": "2009-02-10",
+        "count": 75
+      },
+      "lowest_day": {
+        "date": "2009-04-04",
+        "count": 1
+      },
+      "daily_counts": {
+        "2009-01-01": 0,
+        "2009-01-02": 24,
+        "2009-01-03": 0,
+        "2009-01-04": 0,
+        "2009-01-05": 12,
+        "2009-01-06": 17,
+        "2009-01-07": 15,
+        "2009-01-08": 20,
+        "2009-01-09": 13,
+        "2009-01-10": 0,
+        "2009-01-11": 0,
+        "2009-01-12": 19,
+        "2009-01-13": 4,
+        "2009-01-14": 45,
+        "2009-01-15": 24,
+        "2009-01-16": 21,
+        "2009-01-17": 0,
+        "2009-01-18": 0,
+        "2009-01-19": 0,
+        "2009-01-20": 19,
+        "2009-01-21": 38,
+        "2009-01-22": 31,
+        "2009-01-23": 21,
+        "2009-01-24": 0,
+        "2009-01-25": 0,
+        "2009-01-26": 14,
+        "2009-01-27": 44,
+        "2009-01-28": 37,
+        "2009-01-29": 28,
+        "2009-01-30": 20,
+        "2009-01-31": 0,
+        "2009-02-01": 0,
+        "2009-02-02": 25,
+        "2009-02-03": 51,
+        "2009-02-04": 21,
+        "2009-02-05": 26,
+        "2009-02-06": 29,
+        "2009-02-07": 0,
+        "2009-02-08": 14,
+        "2009-02-09": 19,
+        "2009-02-10": 75,
+        "2009-02-11": 34,
+        "2009-02-12": 9,
+        "2009-02-13": 38,
+        "2009-02-14": 8,
+        "2009-02-15": 0,
+        "2009-02-16": 28,
+        "2009-02-17": 15,
+        "2009-02-18": 9,
+        "2009-02-19": 32,
+        "2009-02-20": 58,
+        "2009-02-21": 6,
+        "2009-02-22": 11,
+        "2009-02-23": 28,
+        "2009-02-24": 25,
+        "2009-02-25": 36,
+        "2009-02-26": 43,
+        "2009-02-27": 45,
+        "2009-02-28": 0,
+        "2009-03-01": 0,
+        "2009-03-02": 50,
+        "2009-03-03": 9,
+        "2009-03-04": 19,
+        "2009-03-05": 32,
+        "2009-03-06": 52,
+        "2009-03-07": 0,
+        "2009-03-08": 0,
+        "2009-03-09": 24,
+        "2009-03-10": 19,
+        "2009-03-11": 13,
+        "2009-03-12": 17,
+        "2009-03-13": 21,
+        "2009-03-14": 9,
+        "2009-03-15": 0,
+        "2009-03-16": 17,
+        "2009-03-17": 11,
+        "2009-03-18": 19,
+        "2009-03-19": 15,
+        "2009-03-20": 31,
+        "2009-03-21": 0,
+        "2009-03-22": 0,
+        "2009-03-23": 19,
+        "2009-03-24": 16,
+        "2009-03-25": 58,
+        "2009-03-26": 24,
+        "2009-03-27": 15,
+        "2009-03-28": 0,
+        "2009-03-29": 0,
+        "2009-03-30": 28,
+        "2009-03-31": 35,
+        "2009-04-01": 28,
+        "2009-04-02": 21,
+        "2009-04-03": 25,
+        "2009-04-04": 1,
+        "2009-04-05": 0,
+        "2009-04-06": 38,
+        "2009-04-07": 43,
+        "2009-04-08": 25,
+        "2009-04-09": 31,
+        "2009-04-10": 32,
+        "2009-04-11": 0,
+        "2009-04-12": 0,
+        "2009-04-13": 18,
+        "2009-04-14": 6,
+        "2009-04-15": 63,
+        "2009-04-16": 10,
+        "2009-04-17": 32,
+        "2009-04-18": 0,
+        "2009-04-19": 0,
+        "2009-04-20": 11,
+        "2009-04-21": 26,
+        "2009-04-22": 25,
+        "2009-04-23": 25,
+        "2009-04-24": 23,
+        "2009-04-25": 0,
+        "2009-04-26": 0,
+        "2009-04-27": 19,
+        "2009-04-28": 26,
+        "2009-04-29": 23,
+        "2009-04-30": 16,
+        "2009-05-01": 33,
+        "2009-05-02": 0,
+        "2009-05-03": 0,
+        "2009-05-04": 11,
+        "2009-05-05": 17,
+        "2009-05-06": 19,
+        "2009-05-07": 19,
+        "2009-05-08": 5,
+        "2009-05-09": 0,
+        "2009-05-10": 0,
+        "2009-05-11": 27,
+        "2009-05-12": 27,
+        "2009-05-13": 20,
+        "2009-05-14": 12,
+        "2009-05-15": 12,
+        "2009-05-16": 8,
+        "2009-05-17": 0,
+        "2009-05-18": 25,
+        "2009-05-19": 5,
+        "2009-05-20": 13,
+        "2009-05-21": 9,
+        "2009-05-22": 40,
+        "2009-05-23": 0,
+        "2009-05-24": 0,
+        "2009-05-25": 0,
+        "2009-05-26": 17,
+        "2009-05-27": 5,
+        "2009-05-28": 15,
+        "2009-05-29": 25,
+        "2009-05-30": 0,
+        "2009-05-31": 0,
+        "2009-06-01": 20,
+        "2009-06-02": 16,
+        "2009-06-03": 13,
+        "2009-06-04": 17,
+        "2009-06-05": 25,
+        "2009-06-06": 0,
+        "2009-06-07": 0,
+        "2009-06-08": 27,
+        "2009-06-09": 19,
+        "2009-06-10": 66,
+        "2009-06-11": 21,
+        "2009-06-12": 24,
+        "2009-06-13": 0,
+        "2009-06-14": 0,
+        "2009-06-15": 17,
+        "2009-06-16": 18,
+        "2009-06-17": 13,
+        "2009-06-18": 14,
+        "2009-06-19": 25,
+        "2009-06-20": 0,
+        "2009-06-21": 0,
+        "2009-06-22": 31,
+        "2009-06-23": 18,
+        "2009-06-24": 0,
+        "2009-06-25": 25,
+        "2009-06-26": 17,
+        "2009-06-27": 15,
+        "2009-06-28": 0,
+        "2009-06-29": 0,
+        "2009-06-30": 9,
+        "2009-07-01": 25,
+        "2009-07-02": 25,
+        "2009-07-03": 0,
+        "2009-07-04": 0,
+        "2009-07-05": 28,
+        "2009-07-06": 0,
+        "2009-07-07": 27,
+        "2009-07-08": 26,
+        "2009-07-09": 23,
+        "2009-07-10": 17,
+        "2009-07-11": 0,
+        "2009-07-12": 0,
+        "2009-07-13": 17,
+        "2009-07-14": 61,
+        "2009-07-15": 9,
+        "2009-07-16": 17,
+        "2009-07-17": 5,
+        "2009-07-18": 0,
+        "2009-07-19": 0,
+        "2009-07-20": 23,
+        "2009-07-21": 12,
+        "2009-07-22": 22,
+        "2009-07-23": 11,
+        "2009-07-24": 14,
+        "2009-07-25": 0,
+        "2009-07-26": 0,
+        "2009-07-27": 26,
+        "2009-07-28": 13,
+        "2009-07-29": 14,
+        "2009-07-30": 16,
+        "2009-07-31": 15,
+        "2009-08-01": 0,
+        "2009-08-02": 0,
+        "2009-08-03": 18,
+        "2009-08-04": 11,
+        "2009-08-05": 16,
+        "2009-08-06": 25,
+        "2009-08-07": 15,
+        "2009-08-08": 0,
+        "2009-08-09": 0,
+        "2009-08-10": 27,
+        "2009-08-11": 22,
+        "2009-08-12": 43,
+        "2009-08-13": 25,
+        "2009-08-14": 22,
+        "2009-08-15": 0,
+        "2009-08-16": 0,
+        "2009-08-17": 14,
+        "2009-08-18": 19,
+        "2009-08-19": 49,
+        "2009-08-20": 16,
+        "2009-08-21": 44,
+        "2009-08-22": 0,
+        "2009-08-23": 0,
+        "2009-08-24": 40,
+        "2009-08-25": 29,
+        "2009-08-26": 12,
+        "2009-08-27": 27,
+        "2009-08-28": 25,
+        "2009-08-29": 0,
+        "2009-08-30": 0,
+        "2009-08-31": 28,
+        "2009-09-01": 26,
+        "2009-09-02": 20,
+        "2009-09-03": 16,
+        "2009-09-04": 12,
+        "2009-09-05": 0,
+        "2009-09-06": 0,
+        "2009-09-07": 0,
+        "2009-09-08": 64,
+        "2009-09-09": 24,
+        "2009-09-10": 55,
+        "2009-09-11": 31,
+        "2009-09-12": 0,
+        "2009-09-13": 6,
+        "2009-09-14": 30,
+        "2009-09-15": 24,
+        "2009-09-16": 26,
+        "2009-09-17": 13,
+        "2009-09-18": 39,
+        "2009-09-19": 0,
+        "2009-09-20": 0,
+        "2009-09-21": 16,
+        "2009-09-22": 11,
+        "2009-09-23": 29,
+        "2009-09-24": 39,
+        "2009-09-25": 15,
+        "2009-09-26": 0,
+        "2009-09-27": 0,
+        "2009-09-28": 27,
+        "2009-09-29": 24,
+        "2009-09-30": 27,
+        "2009-10-01": 21,
+        "2009-10-02": 16,
+        "2009-10-03": 0,
+        "2009-10-04": 0,
+        "2009-10-05": 6,
+        "2009-10-06": 10,
+        "2009-10-07": 4,
+        "2009-10-08": 13,
+        "2009-10-09": 17,
+        "2009-10-10": 0,
+        "2009-10-11": 12,
+        "2009-10-12": 0,
+        "2009-10-13": 14,
+        "2009-10-14": 29,
+        "2009-10-15": 3,
+        "2009-10-16": 23,
+        "2009-10-17": 0,
+        "2009-10-18": 0,
+        "2009-10-19": 31,
+        "2009-10-20": 6,
+        "2009-10-21": 6,
+        "2009-10-22": 62,
+        "2009-10-23": 7,
+        "2009-10-24": 0,
+        "2009-10-25": 0,
+        "2009-10-26": 15,
+        "2009-10-27": 15,
+        "2009-10-28": 14,
+        "2009-10-29": 18,
+        "2009-10-30": 10,
+        "2009-10-31": 0,
+        "2009-11-01": 0,
+        "2009-11-02": 20,
+        "2009-11-03": 6,
+        "2009-11-04": 17,
+        "2009-11-05": 14,
+        "2009-11-06": 11,
+        "2009-11-07": 0,
+        "2009-11-08": 0,
+        "2009-11-09": 24,
+        "2009-11-10": 29,
+        "2009-11-11": 15,
+        "2009-11-12": 8,
+        "2009-11-13": 12,
+        "2009-11-14": 0,
+        "2009-11-15": 0,
+        "2009-11-16": 15,
+        "2009-11-17": 7,
+        "2009-11-18": 13,
+        "2009-11-19": 4,
+        "2009-11-20": 20,
+        "2009-11-21": 0,
+        "2009-11-22": 0,
+        "2009-11-23": 10,
+        "2009-11-24": 25,
+        "2009-11-25": 9,
+        "2009-11-26": 0,
+        "2009-11-27": 0,
+        "2009-11-28": 0,
+        "2009-11-29": 40,
+        "2009-11-30": 9,
+        "2009-12-01": 7,
+        "2009-12-02": 35,
+        "2009-12-03": 12,
+        "2009-12-04": 21,
+        "2009-12-05": 0,
+        "2009-12-06": 0,
+        "2009-12-07": 11,
+        "2009-12-08": 21,
+        "2009-12-09": 14,
+        "2009-12-10": 36,
+        "2009-12-11": 6,
+        "2009-12-12": 0,
+        "2009-12-13": 10,
+        "2009-12-14": 12,
+        "2009-12-15": 6,
+        "2009-12-16": 23,
+        "2009-12-17": 30,
+        "2009-12-18": 14,
+        "2009-12-19": 0,
+        "2009-12-20": 4,
+        "2009-12-21": 26,
+        "2009-12-22": 25,
+        "2009-12-23": 16,
+        "2009-12-24": 16,
+        "2009-12-25": 0,
+        "2009-12-26": 0,
+        "2009-12-27": 0,
+        "2009-12-28": 23,
+        "2009-12-29": 13,
+        "2009-12-30": 30,
+        "2009-12-31": 29
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 5732,
+      "severity_distribution": {
+        "UNKNOWN": 5732
+      },
+      "score_distribution": {
+        "7.6": 13,
+        "5.0": 672,
+        "7.5": 1320,
+        "5.8": 62,
+        "3.5": 65,
+        "9.3": 618,
+        "10.0": 371,
+        "4.3": 961,
+        "4.9": 97,
+        "9.0": 42,
+        "6.8": 493,
+        "2.6": 34,
+        "7.8": 172,
+        "4.6": 40,
+        "4.0": 68,
+        "6.5": 109,
+        "5.1": 37,
+        "6.4": 44,
+        "1.7": 3,
+        "5.5": 39,
+        "2.1": 62,
+        "1.2": 2,
+        "7.1": 49,
+        "7.2": 109,
+        "6.0": 50,
+        "6.9": 56,
+        "5.4": 15,
+        "4.7": 18,
+        "8.5": 14,
+        "4.4": 31,
+        "8.8": 6,
+        "6.2": 5,
+        "1.9": 15,
+        "9.4": 1,
+        "6.3": 4,
+        "3.7": 2,
+        "3.3": 8,
+        "6.1": 2,
+        "3.6": 8,
+        "6.6": 3,
+        "7.3": 2,
+        "5.7": 1,
+        "4.1": 2,
+        "3.0": 1,
+        "1.5": 1,
+        "8.3": 1,
+        "5.9": 2,
+        "4.8": 1,
+        "2.7": 1
+      }
+    },
+    "v3.0": {
+      "total": 1,
+      "severity_distribution": {
+        "MEDIUM": 1
+      },
+      "score_distribution": {
+        "4.2": 1
+      }
+    },
+    "v3.1": {
+      "total": 107,
+      "severity_distribution": {
+        "HIGH": 69,
+        "CRITICAL": 15,
+        "MEDIUM": 23
+      },
+      "score_distribution": {
+        "7.5": 19,
+        "9.8": 14,
+        "7.8": 21,
+        "8.8": 18,
+        "5.5": 11,
+        "8.1": 6,
+        "6.5": 7,
+        "5.4": 1,
+        "4.7": 1,
+        "6.1": 1,
+        "5.9": 2,
+        "7.2": 1,
+        "7.1": 3,
+        "9.9": 1,
+        "7.0": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 524,
+      "epss_gt_0_5": 85,
+      "epss_gt_0_9": 8
+    }
+  },
+  "kev": {
+    "kev_count": 14
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 330
+      },
+      {
+        "name": "Apple",
+        "count": 238
+      },
+      {
+        "name": "Sun",
+        "count": 221
+      },
+      {
+        "name": "Ibm",
+        "count": 172
+      },
+      {
+        "name": "Oracle",
+        "count": 171
+      },
+      {
+        "name": "Mozilla",
+        "count": 149
+      },
+      {
+        "name": "Joomla",
+        "count": 145
+      },
+      {
+        "name": "Drupal",
+        "count": 144
+      },
+      {
+        "name": "Linux",
+        "count": 128
+      },
+      {
+        "name": "Cisco",
+        "count": 110
+      },
+      {
+        "name": "Adobe",
+        "count": 98
+      },
+      {
+        "name": "Typo3",
+        "count": 93
+      },
+      {
+        "name": "Hp",
+        "count": 78
+      },
+      {
+        "name": "Debian",
+        "count": 59
+      },
+      {
+        "name": "Canonical",
+        "count": 57
+      },
+      {
+        "name": "Google",
+        "count": 47
+      },
+      {
+        "name": "Redhat",
+        "count": 44
+      },
+      {
+        "name": "Fedoraproject",
+        "count": 43
+      },
+      {
+        "name": "Apache",
+        "count": 41
+      },
+      {
+        "name": "Opensuse",
+        "count": 39
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-89",
+        "count": 948
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 822
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 549
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 412
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 326
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 322
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 302
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 215
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 209
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 161
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 149
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 114
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 79
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 64
+      },
+      {
+        "cwe": "CWE-16",
+        "count": 49
+      },
+      {
+        "cwe": "CWE-362",
+        "count": 33
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 32
+      },
+      {
+        "cwe": "CWE-134",
+        "count": 28
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 18
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 18
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 5710
+      },
+      {
+        "status": "Analyzed",
+        "count": 22
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 14892
+      },
+      {
+        "tag": "Patch",
+        "count": 7642
+      },
+      {
+        "tag": "Exploit",
+        "count": 6294
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 4931
+      },
+      {
+        "tag": "Broken Link",
+        "count": 2600
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 1341
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 987
+      },
+      {
+        "tag": "Mailing List",
+        "count": 960
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 248
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 224
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 156
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 138
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 46
+      },
+      {
+        "tag": "Release Notes",
+        "count": 44
+      },
+      {
+        "tag": "Product",
+        "count": 14
+      },
+      {
+        "tag": "Mitigation",
+        "count": 4
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 4
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:43.429358",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2010.json b/web/data/cve_2010.json
new file mode 100644
index 00000000000..36944f7296a
--- /dev/null
+++ b/web/data/cve_2010.json
@@ -0,0 +1,763 @@
+{
+  "year": 2010,
+  "total_cves": 4639,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 319,
+      "2": 308,
+      "3": 513,
+      "4": 500,
+      "5": 418,
+      "6": 490,
+      "7": 343,
+      "8": 380,
+      "9": 297,
+      "10": 434,
+      "11": 278,
+      "12": 359
+    },
+    "daily_analysis": {
+      "total_days": 208,
+      "avg_per_day": 22.3,
+      "highest_day": {
+        "date": "2010-10-14",
+        "count": 91
+      },
+      "lowest_day": {
+        "date": "2010-01-27",
+        "count": 2
+      },
+      "daily_counts": {
+        "2010-01-01": 0,
+        "2010-01-02": 0,
+        "2010-01-03": 0,
+        "2010-01-04": 28,
+        "2010-01-05": 7,
+        "2010-01-06": 15,
+        "2010-01-07": 20,
+        "2010-01-08": 8,
+        "2010-01-09": 6,
+        "2010-01-10": 0,
+        "2010-01-11": 0,
+        "2010-01-12": 14,
+        "2010-01-13": 50,
+        "2010-01-14": 13,
+        "2010-01-15": 37,
+        "2010-01-16": 0,
+        "2010-01-17": 0,
+        "2010-01-18": 16,
+        "2010-01-19": 7,
+        "2010-01-20": 11,
+        "2010-01-21": 19,
+        "2010-01-22": 12,
+        "2010-01-23": 0,
+        "2010-01-24": 0,
+        "2010-01-25": 18,
+        "2010-01-26": 6,
+        "2010-01-27": 2,
+        "2010-01-28": 22,
+        "2010-01-29": 8,
+        "2010-01-30": 0,
+        "2010-01-31": 0,
+        "2010-02-01": 0,
+        "2010-02-02": 12,
+        "2010-02-03": 12,
+        "2010-02-04": 17,
+        "2010-02-05": 17,
+        "2010-02-06": 0,
+        "2010-02-07": 0,
+        "2010-02-08": 10,
+        "2010-02-09": 2,
+        "2010-02-10": 36,
+        "2010-02-11": 21,
+        "2010-02-12": 15,
+        "2010-02-13": 0,
+        "2010-02-14": 0,
+        "2010-02-15": 12,
+        "2010-02-16": 5,
+        "2010-02-17": 4,
+        "2010-02-18": 25,
+        "2010-02-19": 17,
+        "2010-02-20": 0,
+        "2010-02-21": 0,
+        "2010-02-22": 25,
+        "2010-02-23": 22,
+        "2010-02-24": 6,
+        "2010-02-25": 18,
+        "2010-02-26": 23,
+        "2010-02-27": 9,
+        "2010-02-28": 0,
+        "2010-03-01": 0,
+        "2010-03-02": 19,
+        "2010-03-03": 22,
+        "2010-03-04": 0,
+        "2010-03-05": 42,
+        "2010-03-06": 0,
+        "2010-03-07": 0,
+        "2010-03-08": 14,
+        "2010-03-09": 0,
+        "2010-03-10": 50,
+        "2010-03-11": 0,
+        "2010-03-12": 0,
+        "2010-03-13": 0,
+        "2010-03-14": 0,
+        "2010-03-15": 42,
+        "2010-03-16": 28,
+        "2010-03-17": 0,
+        "2010-03-18": 20,
+        "2010-03-19": 35,
+        "2010-03-20": 0,
+        "2010-03-21": 0,
+        "2010-03-22": 0,
+        "2010-03-23": 47,
+        "2010-03-24": 19,
+        "2010-03-25": 40,
+        "2010-03-26": 28,
+        "2010-03-27": 6,
+        "2010-03-28": 0,
+        "2010-03-29": 24,
+        "2010-03-30": 49,
+        "2010-03-31": 28,
+        "2010-04-01": 48,
+        "2010-04-02": 0,
+        "2010-04-03": 0,
+        "2010-04-04": 0,
+        "2010-04-05": 43,
+        "2010-04-06": 24,
+        "2010-04-07": 11,
+        "2010-04-08": 15,
+        "2010-04-09": 18,
+        "2010-04-10": 0,
+        "2010-04-11": 0,
+        "2010-04-12": 21,
+        "2010-04-13": 66,
+        "2010-04-14": 40,
+        "2010-04-15": 10,
+        "2010-04-16": 14,
+        "2010-04-17": 0,
+        "2010-04-18": 0,
+        "2010-04-19": 13,
+        "2010-04-20": 27,
+        "2010-04-21": 19,
+        "2010-04-22": 16,
+        "2010-04-23": 28,
+        "2010-04-24": 0,
+        "2010-04-25": 0,
+        "2010-04-26": 17,
+        "2010-04-27": 24,
+        "2010-04-28": 18,
+        "2010-04-29": 28,
+        "2010-04-30": 0,
+        "2010-05-01": 0,
+        "2010-05-02": 0,
+        "2010-05-03": 16,
+        "2010-05-04": 29,
+        "2010-05-05": 5,
+        "2010-05-06": 32,
+        "2010-05-07": 43,
+        "2010-05-08": 0,
+        "2010-05-09": 0,
+        "2010-05-10": 0,
+        "2010-05-11": 18,
+        "2010-05-12": 42,
+        "2010-05-13": 28,
+        "2010-05-14": 20,
+        "2010-05-15": 0,
+        "2010-05-16": 0,
+        "2010-05-17": 9,
+        "2010-05-18": 0,
+        "2010-05-19": 40,
+        "2010-05-20": 24,
+        "2010-05-21": 11,
+        "2010-05-22": 0,
+        "2010-05-23": 0,
+        "2010-05-24": 16,
+        "2010-05-25": 21,
+        "2010-05-26": 14,
+        "2010-05-27": 34,
+        "2010-05-28": 16,
+        "2010-05-29": 0,
+        "2010-05-30": 0,
+        "2010-05-31": 0,
+        "2010-06-01": 18,
+        "2010-06-02": 14,
+        "2010-06-03": 17,
+        "2010-06-04": 0,
+        "2010-06-05": 0,
+        "2010-06-06": 0,
+        "2010-06-07": 12,
+        "2010-06-08": 47,
+        "2010-06-09": 7,
+        "2010-06-10": 11,
+        "2010-06-11": 56,
+        "2010-06-12": 0,
+        "2010-06-13": 0,
+        "2010-06-14": 0,
+        "2010-06-15": 78,
+        "2010-06-16": 14,
+        "2010-06-17": 28,
+        "2010-06-18": 30,
+        "2010-06-19": 0,
+        "2010-06-20": 0,
+        "2010-06-21": 21,
+        "2010-06-22": 16,
+        "2010-06-23": 0,
+        "2010-06-24": 33,
+        "2010-06-25": 26,
+        "2010-06-26": 0,
+        "2010-06-27": 0,
+        "2010-06-28": 23,
+        "2010-06-29": 18,
+        "2010-06-30": 21,
+        "2010-07-01": 0,
+        "2010-07-02": 31,
+        "2010-07-03": 0,
+        "2010-07-04": 0,
+        "2010-07-05": 0,
+        "2010-07-06": 26,
+        "2010-07-07": 0,
+        "2010-07-08": 30,
+        "2010-07-09": 0,
+        "2010-07-10": 0,
+        "2010-07-11": 0,
+        "2010-07-12": 36,
+        "2010-07-13": 71,
+        "2010-07-14": 0,
+        "2010-07-15": 9,
+        "2010-07-16": 0,
+        "2010-07-17": 0,
+        "2010-07-18": 0,
+        "2010-07-19": 0,
+        "2010-07-20": 0,
+        "2010-07-21": 0,
+        "2010-07-22": 34,
+        "2010-07-23": 0,
+        "2010-07-24": 0,
+        "2010-07-25": 16,
+        "2010-07-26": 0,
+        "2010-07-27": 0,
+        "2010-07-28": 45,
+        "2010-07-29": 0,
+        "2010-07-30": 45,
+        "2010-07-31": 0,
+        "2010-08-01": 0,
+        "2010-08-02": 18,
+        "2010-08-03": 0,
+        "2010-08-04": 0,
+        "2010-08-05": 27,
+        "2010-08-06": 0,
+        "2010-08-07": 0,
+        "2010-08-08": 0,
+        "2010-08-09": 18,
+        "2010-08-10": 20,
+        "2010-08-11": 46,
+        "2010-08-12": 0,
+        "2010-08-13": 4,
+        "2010-08-14": 0,
+        "2010-08-15": 0,
+        "2010-08-16": 24,
+        "2010-08-17": 22,
+        "2010-08-18": 0,
+        "2010-08-19": 24,
+        "2010-08-20": 26,
+        "2010-08-21": 4,
+        "2010-08-22": 0,
+        "2010-08-23": 11,
+        "2010-08-24": 20,
+        "2010-08-25": 31,
+        "2010-08-26": 38,
+        "2010-08-27": 18,
+        "2010-08-28": 0,
+        "2010-08-29": 0,
+        "2010-08-30": 17,
+        "2010-08-31": 12,
+        "2010-09-01": 0,
+        "2010-09-02": 0,
+        "2010-09-03": 16,
+        "2010-09-04": 0,
+        "2010-09-05": 0,
+        "2010-09-06": 0,
+        "2010-09-07": 26,
+        "2010-09-08": 15,
+        "2010-09-09": 27,
+        "2010-09-10": 18,
+        "2010-09-11": 0,
+        "2010-09-12": 0,
+        "2010-09-13": 8,
+        "2010-09-14": 10,
+        "2010-09-15": 25,
+        "2010-09-16": 24,
+        "2010-09-17": 19,
+        "2010-09-18": 0,
+        "2010-09-19": 0,
+        "2010-09-20": 19,
+        "2010-09-21": 10,
+        "2010-09-22": 16,
+        "2010-09-23": 12,
+        "2010-09-24": 23,
+        "2010-09-25": 0,
+        "2010-09-26": 0,
+        "2010-09-27": 0,
+        "2010-09-28": 6,
+        "2010-09-29": 14,
+        "2010-09-30": 9,
+        "2010-10-01": 0,
+        "2010-10-02": 0,
+        "2010-10-03": 0,
+        "2010-10-04": 6,
+        "2010-10-05": 33,
+        "2010-10-06": 28,
+        "2010-10-07": 7,
+        "2010-10-08": 11,
+        "2010-10-09": 0,
+        "2010-10-10": 0,
+        "2010-10-11": 0,
+        "2010-10-12": 5,
+        "2010-10-13": 44,
+        "2010-10-14": 91,
+        "2010-10-15": 0,
+        "2010-10-16": 0,
+        "2010-10-17": 0,
+        "2010-10-18": 13,
+        "2010-10-19": 55,
+        "2010-10-20": 32,
+        "2010-10-21": 31,
+        "2010-10-22": 0,
+        "2010-10-23": 8,
+        "2010-10-24": 0,
+        "2010-10-25": 16,
+        "2010-10-26": 12,
+        "2010-10-27": 4,
+        "2010-10-28": 25,
+        "2010-10-29": 13,
+        "2010-10-30": 0,
+        "2010-10-31": 0,
+        "2010-11-01": 0,
+        "2010-11-02": 18,
+        "2010-11-03": 9,
+        "2010-11-04": 4,
+        "2010-11-05": 17,
+        "2010-11-06": 20,
+        "2010-11-07": 20,
+        "2010-11-08": 0,
+        "2010-11-09": 25,
+        "2010-11-10": 15,
+        "2010-11-11": 0,
+        "2010-11-12": 15,
+        "2010-11-13": 0,
+        "2010-11-14": 0,
+        "2010-11-15": 18,
+        "2010-11-16": 22,
+        "2010-11-17": 22,
+        "2010-11-18": 0,
+        "2010-11-19": 0,
+        "2010-11-20": 0,
+        "2010-11-21": 0,
+        "2010-11-22": 34,
+        "2010-11-23": 0,
+        "2010-11-24": 0,
+        "2010-11-25": 0,
+        "2010-11-26": 23,
+        "2010-11-27": 0,
+        "2010-11-28": 0,
+        "2010-11-29": 9,
+        "2010-11-30": 7,
+        "2010-12-01": 16,
+        "2010-12-02": 24,
+        "2010-12-03": 0,
+        "2010-12-04": 0,
+        "2010-12-05": 0,
+        "2010-12-06": 31,
+        "2010-12-07": 26,
+        "2010-12-08": 14,
+        "2010-12-09": 20,
+        "2010-12-10": 18,
+        "2010-12-11": 0,
+        "2010-12-12": 0,
+        "2010-12-13": 0,
+        "2010-12-14": 29,
+        "2010-12-15": 0,
+        "2010-12-16": 52,
+        "2010-12-17": 12,
+        "2010-12-18": 0,
+        "2010-12-19": 0,
+        "2010-12-20": 0,
+        "2010-12-21": 0,
+        "2010-12-22": 45,
+        "2010-12-23": 10,
+        "2010-12-24": 0,
+        "2010-12-25": 0,
+        "2010-12-26": 0,
+        "2010-12-27": 0,
+        "2010-12-28": 0,
+        "2010-12-29": 24,
+        "2010-12-30": 38,
+        "2010-12-31": 0
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 4639,
+      "severity_distribution": {
+        "UNKNOWN": 4639
+      },
+      "score_distribution": {
+        "10.0": 252,
+        "7.5": 771,
+        "3.5": 55,
+        "5.0": 504,
+        "4.0": 95,
+        "4.6": 37,
+        "2.6": 42,
+        "4.3": 808,
+        "1.9": 32,
+        "7.2": 97,
+        "6.8": 392,
+        "7.8": 115,
+        "4.7": 20,
+        "6.5": 45,
+        "6.9": 97,
+        "1.2": 2,
+        "9.3": 742,
+        "2.1": 97,
+        "5.8": 44,
+        "6.0": 32,
+        "3.6": 11,
+        "4.9": 44,
+        "1.0": 2,
+        "3.2": 6,
+        "9.0": 37,
+        "6.2": 10,
+        "5.5": 28,
+        "1.5": 2,
+        "3.3": 19,
+        "5.1": 26,
+        "7.1": 30,
+        "6.4": 43,
+        "8.5": 15,
+        "6.1": 4,
+        "3.7": 2,
+        "7.6": 21,
+        "5.4": 4,
+        "6.3": 3,
+        "4.1": 1,
+        "5.6": 3,
+        "4.4": 20,
+        "7.3": 1,
+        "8.8": 1,
+        "8.3": 5,
+        "2.9": 2,
+        "3.0": 3,
+        "3.8": 1,
+        "2.4": 2,
+        "6.6": 8,
+        "5.7": 3,
+        "1.7": 1,
+        "8.0": 1,
+        "2.7": 1
+      }
+    },
+    "v3.0": {
+      "total": 3,
+      "severity_distribution": {
+        "LOW": 2,
+        "MEDIUM": 1
+      },
+      "score_distribution": {
+        "3.7": 2,
+        "6.3": 1
+      }
+    },
+    "v3.1": {
+      "total": 124,
+      "severity_distribution": {
+        "CRITICAL": 28,
+        "HIGH": 77,
+        "MEDIUM": 19
+      },
+      "score_distribution": {
+        "9.8": 28,
+        "8.8": 30,
+        "7.5": 11,
+        "6.5": 7,
+        "4.7": 1,
+        "7.8": 24,
+        "8.1": 6,
+        "5.8": 1,
+        "5.9": 1,
+        "5.5": 7,
+        "5.3": 1,
+        "7.0": 1,
+        "8.4": 2,
+        "7.3": 2,
+        "7.1": 1,
+        "4.3": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 563,
+      "epss_gt_0_5": 98,
+      "epss_gt_0_9": 12
+    }
+  },
+  "kev": {
+    "kev_count": 23
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 597
+      },
+      {
+        "name": "Apple",
+        "count": 442
+      },
+      {
+        "name": "Oracle",
+        "count": 216
+      },
+      {
+        "name": "Joomla",
+        "count": 211
+      },
+      {
+        "name": "Ibm",
+        "count": 208
+      },
+      {
+        "name": "Adobe",
+        "count": 207
+      },
+      {
+        "name": "Linux",
+        "count": 193
+      },
+      {
+        "name": "Google",
+        "count": 178
+      },
+      {
+        "name": "Cisco",
+        "count": 155
+      },
+      {
+        "name": "Mozilla",
+        "count": 129
+      },
+      {
+        "name": "Hp",
+        "count": 122
+      },
+      {
+        "name": "Canonical",
+        "count": 103
+      },
+      {
+        "name": "Sun",
+        "count": 102
+      },
+      {
+        "name": "Typo3",
+        "count": 98
+      },
+      {
+        "name": "Debian",
+        "count": 90
+      },
+      {
+        "name": "Suse",
+        "count": 72
+      },
+      {
+        "name": "Opensuse",
+        "count": 72
+      },
+      {
+        "name": "Redhat",
+        "count": 57
+      },
+      {
+        "name": "Realnetworks",
+        "count": 55
+      },
+      {
+        "name": "Apache",
+        "count": 51
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-79",
+        "count": 595
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 515
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 506
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 333
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 284
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 276
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 253
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 194
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 158
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 132
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 76
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 75
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 67
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 50
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 33
+      },
+      {
+        "cwe": "CWE-362",
+        "count": 33
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 31
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 25
+      },
+      {
+        "cwe": "CWE-16",
+        "count": 24
+      },
+      {
+        "cwe": "CWE-190",
+        "count": 19
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 4614
+      },
+      {
+        "status": "Analyzed",
+        "count": 25
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 11703
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 6930
+      },
+      {
+        "tag": "Exploit",
+        "count": 5586
+      },
+      {
+        "tag": "Patch",
+        "count": 4834
+      },
+      {
+        "tag": "Mailing List",
+        "count": 1936
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1917
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 1184
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 1040
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 548
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 222
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 152
+      },
+      {
+        "tag": "Release Notes",
+        "count": 126
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 56
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 44
+      },
+      {
+        "tag": "Product",
+        "count": 16
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 16
+      },
+      {
+        "tag": "Mitigation",
+        "count": 2
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:43.590360",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2011.json b/web/data/cve_2011.json
new file mode 100644
index 00000000000..3d33cb74759
--- /dev/null
+++ b/web/data/cve_2011.json
@@ -0,0 +1,770 @@
+{
+  "year": 2011,
+  "total_cves": 4150,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 396,
+      "2": 377,
+      "3": 355,
+      "4": 312,
+      "5": 295,
+      "6": 294,
+      "7": 307,
+      "8": 294,
+      "9": 387,
+      "10": 484,
+      "11": 309,
+      "12": 340
+    },
+    "daily_analysis": {
+      "total_days": 218,
+      "avg_per_day": 19.04,
+      "highest_day": {
+        "date": "2011-02-10",
+        "count": 95
+      },
+      "lowest_day": {
+        "date": "2011-04-14",
+        "count": 1
+      },
+      "daily_counts": {
+        "2011-01-01": 0,
+        "2011-01-02": 0,
+        "2011-01-03": 16,
+        "2011-01-04": 0,
+        "2011-01-05": 0,
+        "2011-01-06": 0,
+        "2011-01-07": 56,
+        "2011-01-08": 0,
+        "2011-01-09": 0,
+        "2011-01-10": 8,
+        "2011-01-11": 28,
+        "2011-01-12": 8,
+        "2011-01-13": 27,
+        "2011-01-14": 34,
+        "2011-01-15": 0,
+        "2011-01-16": 0,
+        "2011-01-17": 0,
+        "2011-01-18": 19,
+        "2011-01-19": 69,
+        "2011-01-20": 37,
+        "2011-01-21": 0,
+        "2011-01-22": 8,
+        "2011-01-23": 0,
+        "2011-01-24": 13,
+        "2011-01-25": 17,
+        "2011-01-26": 0,
+        "2011-01-27": 0,
+        "2011-01-28": 34,
+        "2011-01-29": 0,
+        "2011-01-30": 0,
+        "2011-01-31": 22,
+        "2011-02-01": 12,
+        "2011-02-02": 25,
+        "2011-02-03": 12,
+        "2011-02-04": 20,
+        "2011-02-05": 0,
+        "2011-02-06": 0,
+        "2011-02-07": 10,
+        "2011-02-08": 21,
+        "2011-02-09": 15,
+        "2011-02-10": 95,
+        "2011-02-11": 0,
+        "2011-02-12": 0,
+        "2011-02-13": 0,
+        "2011-02-14": 11,
+        "2011-02-15": 7,
+        "2011-02-16": 10,
+        "2011-02-17": 26,
+        "2011-02-18": 12,
+        "2011-02-19": 14,
+        "2011-02-20": 0,
+        "2011-02-21": 18,
+        "2011-02-22": 6,
+        "2011-02-23": 17,
+        "2011-02-24": 2,
+        "2011-02-25": 37,
+        "2011-02-26": 0,
+        "2011-02-27": 0,
+        "2011-02-28": 7,
+        "2011-03-01": 34,
+        "2011-03-02": 16,
+        "2011-03-03": 62,
+        "2011-03-04": 2,
+        "2011-03-05": 0,
+        "2011-03-06": 0,
+        "2011-03-07": 7,
+        "2011-03-08": 19,
+        "2011-03-09": 6,
+        "2011-03-10": 4,
+        "2011-03-11": 42,
+        "2011-03-12": 0,
+        "2011-03-13": 0,
+        "2011-03-14": 7,
+        "2011-03-15": 11,
+        "2011-03-16": 14,
+        "2011-03-17": 0,
+        "2011-03-18": 25,
+        "2011-03-19": 0,
+        "2011-03-20": 15,
+        "2011-03-21": 0,
+        "2011-03-22": 16,
+        "2011-03-23": 28,
+        "2011-03-24": 0,
+        "2011-03-25": 10,
+        "2011-03-26": 0,
+        "2011-03-27": 0,
+        "2011-03-28": 11,
+        "2011-03-29": 8,
+        "2011-03-30": 9,
+        "2011-03-31": 9,
+        "2011-04-01": 0,
+        "2011-04-02": 0,
+        "2011-04-03": 0,
+        "2011-04-04": 19,
+        "2011-04-05": 12,
+        "2011-04-06": 3,
+        "2011-04-07": 6,
+        "2011-04-08": 10,
+        "2011-04-09": 0,
+        "2011-04-10": 30,
+        "2011-04-11": 6,
+        "2011-04-12": 0,
+        "2011-04-13": 63,
+        "2011-04-14": 1,
+        "2011-04-15": 14,
+        "2011-04-16": 0,
+        "2011-04-17": 0,
+        "2011-04-18": 18,
+        "2011-04-19": 5,
+        "2011-04-20": 59,
+        "2011-04-21": 18,
+        "2011-04-22": 9,
+        "2011-04-23": 0,
+        "2011-04-24": 0,
+        "2011-04-25": 0,
+        "2011-04-26": 0,
+        "2011-04-27": 26,
+        "2011-04-28": 1,
+        "2011-04-29": 12,
+        "2011-04-30": 0,
+        "2011-05-01": 0,
+        "2011-05-02": 0,
+        "2011-05-03": 65,
+        "2011-05-04": 4,
+        "2011-05-05": 12,
+        "2011-05-06": 0,
+        "2011-05-07": 30,
+        "2011-05-08": 0,
+        "2011-05-09": 18,
+        "2011-05-10": 13,
+        "2011-05-11": 0,
+        "2011-05-12": 0,
+        "2011-05-13": 41,
+        "2011-05-14": 0,
+        "2011-05-15": 0,
+        "2011-05-16": 15,
+        "2011-05-17": 0,
+        "2011-05-18": 0,
+        "2011-05-19": 0,
+        "2011-05-20": 35,
+        "2011-05-21": 0,
+        "2011-05-22": 0,
+        "2011-05-23": 7,
+        "2011-05-24": 13,
+        "2011-05-25": 0,
+        "2011-05-26": 14,
+        "2011-05-27": 0,
+        "2011-05-28": 0,
+        "2011-05-29": 0,
+        "2011-05-30": 0,
+        "2011-05-31": 28,
+        "2011-06-01": 0,
+        "2011-06-02": 18,
+        "2011-06-03": 2,
+        "2011-06-04": 0,
+        "2011-06-05": 0,
+        "2011-06-06": 23,
+        "2011-06-07": 0,
+        "2011-06-08": 5,
+        "2011-06-09": 36,
+        "2011-06-10": 0,
+        "2011-06-11": 0,
+        "2011-06-12": 0,
+        "2011-06-13": 0,
+        "2011-06-14": 32,
+        "2011-06-15": 0,
+        "2011-06-16": 77,
+        "2011-06-17": 0,
+        "2011-06-18": 0,
+        "2011-06-19": 0,
+        "2011-06-20": 0,
+        "2011-06-21": 14,
+        "2011-06-22": 13,
+        "2011-06-23": 0,
+        "2011-06-24": 26,
+        "2011-06-25": 0,
+        "2011-06-26": 0,
+        "2011-06-27": 0,
+        "2011-06-28": 0,
+        "2011-06-29": 15,
+        "2011-06-30": 33,
+        "2011-07-01": 39,
+        "2011-07-02": 0,
+        "2011-07-03": 0,
+        "2011-07-04": 0,
+        "2011-07-05": 0,
+        "2011-07-06": 5,
+        "2011-07-07": 12,
+        "2011-07-08": 12,
+        "2011-07-09": 0,
+        "2011-07-10": 0,
+        "2011-07-11": 8,
+        "2011-07-12": 0,
+        "2011-07-13": 21,
+        "2011-07-14": 11,
+        "2011-07-15": 0,
+        "2011-07-16": 0,
+        "2011-07-17": 17,
+        "2011-07-18": 8,
+        "2011-07-19": 12,
+        "2011-07-20": 46,
+        "2011-07-21": 65,
+        "2011-07-22": 0,
+        "2011-07-23": 0,
+        "2011-07-24": 0,
+        "2011-07-25": 0,
+        "2011-07-26": 0,
+        "2011-07-27": 27,
+        "2011-07-28": 13,
+        "2011-07-29": 11,
+        "2011-07-30": 0,
+        "2011-07-31": 0,
+        "2011-08-01": 13,
+        "2011-08-02": 0,
+        "2011-08-03": 31,
+        "2011-08-04": 11,
+        "2011-08-05": 9,
+        "2011-08-06": 0,
+        "2011-08-07": 0,
+        "2011-08-08": 0,
+        "2011-08-09": 23,
+        "2011-08-10": 47,
+        "2011-08-11": 17,
+        "2011-08-12": 11,
+        "2011-08-13": 0,
+        "2011-08-14": 0,
+        "2011-08-15": 13,
+        "2011-08-16": 4,
+        "2011-08-17": 0,
+        "2011-08-18": 30,
+        "2011-08-19": 12,
+        "2011-08-20": 0,
+        "2011-08-21": 0,
+        "2011-08-22": 0,
+        "2011-08-23": 13,
+        "2011-08-24": 7,
+        "2011-08-25": 9,
+        "2011-08-26": 0,
+        "2011-08-27": 0,
+        "2011-08-28": 0,
+        "2011-08-29": 37,
+        "2011-08-30": 0,
+        "2011-08-31": 7,
+        "2011-09-01": 0,
+        "2011-09-02": 19,
+        "2011-09-03": 0,
+        "2011-09-04": 0,
+        "2011-09-05": 0,
+        "2011-09-06": 18,
+        "2011-09-07": 0,
+        "2011-09-08": 8,
+        "2011-09-09": 0,
+        "2011-09-10": 0,
+        "2011-09-11": 0,
+        "2011-09-12": 13,
+        "2011-09-13": 6,
+        "2011-09-14": 11,
+        "2011-09-15": 31,
+        "2011-09-16": 20,
+        "2011-09-17": 0,
+        "2011-09-18": 0,
+        "2011-09-19": 38,
+        "2011-09-20": 11,
+        "2011-09-21": 8,
+        "2011-09-22": 9,
+        "2011-09-23": 68,
+        "2011-09-24": 67,
+        "2011-09-25": 0,
+        "2011-09-26": 0,
+        "2011-09-27": 25,
+        "2011-09-28": 16,
+        "2011-09-29": 14,
+        "2011-09-30": 5,
+        "2011-10-01": 0,
+        "2011-10-02": 10,
+        "2011-10-03": 19,
+        "2011-10-04": 18,
+        "2011-10-05": 28,
+        "2011-10-06": 13,
+        "2011-10-07": 26,
+        "2011-10-08": 39,
+        "2011-10-09": 42,
+        "2011-10-10": 10,
+        "2011-10-11": 0,
+        "2011-10-12": 50,
+        "2011-10-13": 0,
+        "2011-10-14": 47,
+        "2011-10-15": 0,
+        "2011-10-16": 2,
+        "2011-10-17": 0,
+        "2011-10-18": 59,
+        "2011-10-19": 32,
+        "2011-10-20": 7,
+        "2011-10-21": 12,
+        "2011-10-22": 6,
+        "2011-10-23": 4,
+        "2011-10-24": 9,
+        "2011-10-25": 18,
+        "2011-10-26": 0,
+        "2011-10-27": 11,
+        "2011-10-28": 9,
+        "2011-10-29": 3,
+        "2011-10-30": 10,
+        "2011-10-31": 0,
+        "2011-11-01": 45,
+        "2011-11-02": 54,
+        "2011-11-03": 17,
+        "2011-11-04": 12,
+        "2011-11-05": 0,
+        "2011-11-06": 0,
+        "2011-11-07": 2,
+        "2011-11-08": 11,
+        "2011-11-09": 16,
+        "2011-11-10": 2,
+        "2011-11-11": 27,
+        "2011-11-12": 4,
+        "2011-11-13": 0,
+        "2011-11-14": 0,
+        "2011-11-15": 7,
+        "2011-11-16": 4,
+        "2011-11-17": 10,
+        "2011-11-18": 0,
+        "2011-11-19": 5,
+        "2011-11-20": 0,
+        "2011-11-21": 4,
+        "2011-11-22": 9,
+        "2011-11-23": 19,
+        "2011-11-24": 22,
+        "2011-11-25": 0,
+        "2011-11-26": 3,
+        "2011-11-27": 0,
+        "2011-11-28": 11,
+        "2011-11-29": 15,
+        "2011-11-30": 10,
+        "2011-12-01": 6,
+        "2011-12-02": 12,
+        "2011-12-03": 0,
+        "2011-12-04": 0,
+        "2011-12-05": 8,
+        "2011-12-06": 7,
+        "2011-12-07": 29,
+        "2011-12-08": 22,
+        "2011-12-09": 1,
+        "2011-12-10": 3,
+        "2011-12-11": 0,
+        "2011-12-12": 0,
+        "2011-12-13": 18,
+        "2011-12-14": 37,
+        "2011-12-15": 22,
+        "2011-12-16": 59,
+        "2011-12-17": 7,
+        "2011-12-18": 0,
+        "2011-12-19": 0,
+        "2011-12-20": 4,
+        "2011-12-21": 7,
+        "2011-12-22": 7,
+        "2011-12-23": 11,
+        "2011-12-24": 8,
+        "2011-12-25": 16,
+        "2011-12-26": 0,
+        "2011-12-27": 14,
+        "2011-12-28": 0,
+        "2011-12-29": 17,
+        "2011-12-30": 22,
+        "2011-12-31": 3
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 4150,
+      "severity_distribution": {
+        "UNKNOWN": 4150
+      },
+      "score_distribution": {
+        "2.1": 70,
+        "4.3": 685,
+        "5.0": 613,
+        "6.8": 318,
+        "4.0": 88,
+        "4.6": 19,
+        "6.5": 41,
+        "6.0": 25,
+        "3.5": 58,
+        "5.8": 57,
+        "8.5": 11,
+        "7.5": 507,
+        "7.6": 97,
+        "7.8": 119,
+        "10.0": 380,
+        "6.9": 48,
+        "6.4": 37,
+        "3.3": 29,
+        "1.9": 21,
+        "2.6": 34,
+        "7.1": 19,
+        "5.4": 3,
+        "4.1": 3,
+        "1.7": 9,
+        "9.3": 480,
+        "4.9": 44,
+        "4.7": 12,
+        "5.1": 14,
+        "9.0": 26,
+        "7.2": 121,
+        "5.5": 43,
+        "7.9": 5,
+        "4.4": 22,
+        "3.6": 17,
+        "9.4": 1,
+        "1.0": 1,
+        "5.7": 6,
+        "6.2": 8,
+        "6.1": 5,
+        "1.2": 8,
+        "3.7": 6,
+        "8.3": 6,
+        "8.0": 1,
+        "8.8": 4,
+        "6.3": 12,
+        "3.0": 1,
+        "6.6": 2,
+        "1.5": 3,
+        "8.2": 1,
+        "1.3": 1,
+        "5.2": 1,
+        "7.4": 1,
+        "5.6": 2,
+        "7.7": 1,
+        "2.4": 1,
+        "2.8": 1,
+        "1.8": 1,
+        "3.2": 1
+      }
+    },
+    "v3.0": {
+      "total": 3,
+      "severity_distribution": {
+        "MEDIUM": 2,
+        "HIGH": 1
+      },
+      "score_distribution": {
+        "6.5": 1,
+        "7.5": 1,
+        "5.3": 1
+      }
+    },
+    "v3.1": {
+      "total": 58,
+      "severity_distribution": {
+        "MEDIUM": 12,
+        "HIGH": 41,
+        "CRITICAL": 5
+      },
+      "score_distribution": {
+        "6.8": 1,
+        "7.5": 12,
+        "5.5": 1,
+        "7.8": 12,
+        "8.1": 1,
+        "6.1": 3,
+        "5.3": 2,
+        "7.4": 1,
+        "8.8": 8,
+        "9.8": 5,
+        "8.4": 4,
+        "7.7": 1,
+        "5.9": 1,
+        "6.5": 3,
+        "7.1": 1,
+        "7.3": 1,
+        "5.7": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 480,
+      "epss_gt_0_5": 84,
+      "epss_gt_0_9": 6
+    }
+  },
+  "kev": {
+    "kev_count": 9
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 520
+      },
+      {
+        "name": "Apple",
+        "count": 408
+      },
+      {
+        "name": "Google",
+        "count": 344
+      },
+      {
+        "name": "Oracle",
+        "count": 258
+      },
+      {
+        "name": "Adobe",
+        "count": 202
+      },
+      {
+        "name": "Ibm",
+        "count": 176
+      },
+      {
+        "name": "Cisco",
+        "count": 167
+      },
+      {
+        "name": "Linux",
+        "count": 156
+      },
+      {
+        "name": "Hp",
+        "count": 145
+      },
+      {
+        "name": "Sun",
+        "count": 144
+      },
+      {
+        "name": "Mozilla",
+        "count": 123
+      },
+      {
+        "name": "Redhat",
+        "count": 91
+      },
+      {
+        "name": "Novell",
+        "count": 82
+      },
+      {
+        "name": "Joomla",
+        "count": 73
+      },
+      {
+        "name": "Debian",
+        "count": 72
+      },
+      {
+        "name": "Opera",
+        "count": 56
+      },
+      {
+        "name": "Apache",
+        "count": 54
+      },
+      {
+        "name": "Parallels",
+        "count": 53
+      },
+      {
+        "name": "Wordpress",
+        "count": 46
+      },
+      {
+        "name": "Canonical",
+        "count": 43
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-119",
+        "count": 580
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 461
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 356
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 293
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 289
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 282
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 250
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 106
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 105
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 102
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 58
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 56
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 55
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 55
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 39
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 34
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 31
+      },
+      {
+        "cwe": "CWE-16",
+        "count": 29
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 26
+      },
+      {
+        "cwe": "CWE-476",
+        "count": 22
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 4141
+      },
+      {
+        "status": "Analyzed",
+        "count": 9
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 8161
+      },
+      {
+        "tag": "Patch",
+        "count": 5450
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 4486
+      },
+      {
+        "tag": "Exploit",
+        "count": 3818
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 1163
+      },
+      {
+        "tag": "Mailing List",
+        "count": 1152
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1122
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 1018
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 521
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 166
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 100
+      },
+      {
+        "tag": "Release Notes",
+        "count": 86
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 66
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 54
+      },
+      {
+        "tag": "Product",
+        "count": 8
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 2
+      },
+      {
+        "tag": "Mitigation",
+        "count": 2
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:43.755861",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2012.json b/web/data/cve_2012.json
new file mode 100644
index 00000000000..1d5ae1cd6c2
--- /dev/null
+++ b/web/data/cve_2012.json
@@ -0,0 +1,782 @@
+{
+  "year": 2012,
+  "total_cves": 5288,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 314,
+      "2": 343,
+      "3": 403,
+      "4": 228,
+      "5": 425,
+      "6": 405,
+      "7": 536,
+      "8": 735,
+      "9": 655,
+      "10": 553,
+      "11": 436,
+      "12": 255
+    },
+    "daily_analysis": {
+      "total_days": 283,
+      "avg_per_day": 18.69,
+      "highest_day": {
+        "date": "2012-07-25",
+        "count": 113
+      },
+      "lowest_day": {
+        "date": "2012-01-23",
+        "count": 1
+      },
+      "daily_counts": {
+        "2012-01-01": 0,
+        "2012-01-02": 4,
+        "2012-01-03": 7,
+        "2012-01-04": 10,
+        "2012-01-05": 3,
+        "2012-01-06": 11,
+        "2012-01-07": 3,
+        "2012-01-08": 18,
+        "2012-01-09": 0,
+        "2012-01-10": 14,
+        "2012-01-11": 0,
+        "2012-01-12": 3,
+        "2012-01-13": 14,
+        "2012-01-14": 7,
+        "2012-01-15": 7,
+        "2012-01-16": 0,
+        "2012-01-17": 2,
+        "2012-01-18": 80,
+        "2012-01-19": 16,
+        "2012-01-20": 14,
+        "2012-01-21": 0,
+        "2012-01-22": 0,
+        "2012-01-23": 1,
+        "2012-01-24": 23,
+        "2012-01-25": 23,
+        "2012-01-26": 4,
+        "2012-01-27": 20,
+        "2012-01-28": 5,
+        "2012-01-29": 20,
+        "2012-01-30": 5,
+        "2012-01-31": 0,
+        "2012-02-01": 11,
+        "2012-02-02": 34,
+        "2012-02-03": 14,
+        "2012-02-04": 0,
+        "2012-02-05": 1,
+        "2012-02-06": 5,
+        "2012-02-07": 9,
+        "2012-02-08": 31,
+        "2012-02-09": 20,
+        "2012-02-10": 7,
+        "2012-02-11": 2,
+        "2012-02-12": 4,
+        "2012-02-13": 5,
+        "2012-02-14": 59,
+        "2012-02-15": 22,
+        "2012-02-16": 21,
+        "2012-02-17": 7,
+        "2012-02-18": 11,
+        "2012-02-19": 0,
+        "2012-02-20": 0,
+        "2012-02-21": 45,
+        "2012-02-22": 4,
+        "2012-02-23": 10,
+        "2012-02-24": 14,
+        "2012-02-25": 4,
+        "2012-02-26": 0,
+        "2012-02-27": 0,
+        "2012-02-28": 0,
+        "2012-02-29": 3,
+        "2012-03-01": 11,
+        "2012-03-02": 8,
+        "2012-03-03": 6,
+        "2012-03-04": 0,
+        "2012-03-05": 17,
+        "2012-03-06": 3,
+        "2012-03-07": 28,
+        "2012-03-08": 74,
+        "2012-03-09": 6,
+        "2012-03-10": 1,
+        "2012-03-11": 0,
+        "2012-03-12": 5,
+        "2012-03-13": 26,
+        "2012-03-14": 25,
+        "2012-03-15": 19,
+        "2012-03-16": 7,
+        "2012-03-17": 2,
+        "2012-03-18": 2,
+        "2012-03-19": 33,
+        "2012-03-20": 12,
+        "2012-03-21": 45,
+        "2012-03-22": 22,
+        "2012-03-23": 3,
+        "2012-03-24": 0,
+        "2012-03-25": 0,
+        "2012-03-26": 3,
+        "2012-03-27": 5,
+        "2012-03-28": 17,
+        "2012-03-29": 13,
+        "2012-03-30": 8,
+        "2012-03-31": 2,
+        "2012-04-01": 0,
+        "2012-04-02": 11,
+        "2012-04-03": 5,
+        "2012-04-04": 0,
+        "2012-04-05": 33,
+        "2012-04-06": 6,
+        "2012-04-07": 0,
+        "2012-04-08": 0,
+        "2012-04-09": 5,
+        "2012-04-10": 16,
+        "2012-04-11": 21,
+        "2012-04-12": 4,
+        "2012-04-13": 15,
+        "2012-04-14": 0,
+        "2012-04-15": 0,
+        "2012-04-16": 2,
+        "2012-04-17": 11,
+        "2012-04-18": 14,
+        "2012-04-19": 3,
+        "2012-04-20": 8,
+        "2012-04-21": 6,
+        "2012-04-22": 11,
+        "2012-04-23": 0,
+        "2012-04-24": 1,
+        "2012-04-25": 39,
+        "2012-04-26": 0,
+        "2012-04-27": 6,
+        "2012-04-28": 6,
+        "2012-04-29": 0,
+        "2012-04-30": 5,
+        "2012-05-01": 9,
+        "2012-05-02": 31,
+        "2012-05-03": 111,
+        "2012-05-04": 8,
+        "2012-05-05": 0,
+        "2012-05-06": 0,
+        "2012-05-07": 0,
+        "2012-05-08": 3,
+        "2012-05-09": 42,
+        "2012-05-10": 0,
+        "2012-05-11": 19,
+        "2012-05-12": 0,
+        "2012-05-13": 0,
+        "2012-05-14": 5,
+        "2012-05-15": 9,
+        "2012-05-16": 30,
+        "2012-05-17": 21,
+        "2012-05-18": 12,
+        "2012-05-19": 0,
+        "2012-05-20": 0,
+        "2012-05-21": 43,
+        "2012-05-22": 7,
+        "2012-05-23": 5,
+        "2012-05-24": 33,
+        "2012-05-25": 8,
+        "2012-05-26": 0,
+        "2012-05-27": 14,
+        "2012-05-28": 0,
+        "2012-05-29": 11,
+        "2012-05-30": 1,
+        "2012-05-31": 3,
+        "2012-06-01": 3,
+        "2012-06-02": 2,
+        "2012-06-03": 0,
+        "2012-06-04": 22,
+        "2012-06-05": 26,
+        "2012-06-06": 0,
+        "2012-06-07": 17,
+        "2012-06-08": 12,
+        "2012-06-09": 12,
+        "2012-06-10": 0,
+        "2012-06-11": 2,
+        "2012-06-12": 24,
+        "2012-06-13": 32,
+        "2012-06-14": 16,
+        "2012-06-15": 6,
+        "2012-06-16": 30,
+        "2012-06-17": 13,
+        "2012-06-18": 1,
+        "2012-06-19": 14,
+        "2012-06-20": 20,
+        "2012-06-21": 37,
+        "2012-06-22": 11,
+        "2012-06-23": 0,
+        "2012-06-24": 0,
+        "2012-06-25": 7,
+        "2012-06-26": 3,
+        "2012-06-27": 63,
+        "2012-06-28": 0,
+        "2012-06-29": 26,
+        "2012-06-30": 6,
+        "2012-07-01": 0,
+        "2012-07-02": 0,
+        "2012-07-03": 45,
+        "2012-07-04": 0,
+        "2012-07-05": 20,
+        "2012-07-06": 0,
+        "2012-07-07": 5,
+        "2012-07-08": 0,
+        "2012-07-09": 10,
+        "2012-07-10": 14,
+        "2012-07-11": 16,
+        "2012-07-12": 34,
+        "2012-07-13": 12,
+        "2012-07-14": 0,
+        "2012-07-15": 0,
+        "2012-07-16": 28,
+        "2012-07-17": 99,
+        "2012-07-18": 29,
+        "2012-07-19": 4,
+        "2012-07-20": 17,
+        "2012-07-21": 15,
+        "2012-07-22": 18,
+        "2012-07-23": 19,
+        "2012-07-24": 3,
+        "2012-07-25": 113,
+        "2012-07-26": 16,
+        "2012-07-27": 2,
+        "2012-07-28": 0,
+        "2012-07-29": 0,
+        "2012-07-30": 5,
+        "2012-07-31": 12,
+        "2012-08-01": 0,
+        "2012-08-02": 0,
+        "2012-08-03": 0,
+        "2012-08-04": 0,
+        "2012-08-05": 0,
+        "2012-08-06": 63,
+        "2012-08-07": 20,
+        "2012-08-08": 12,
+        "2012-08-09": 6,
+        "2012-08-10": 7,
+        "2012-08-11": 0,
+        "2012-08-12": 35,
+        "2012-08-13": 56,
+        "2012-08-14": 38,
+        "2012-08-15": 52,
+        "2012-08-16": 23,
+        "2012-08-17": 20,
+        "2012-08-18": 0,
+        "2012-08-19": 7,
+        "2012-08-20": 37,
+        "2012-08-21": 17,
+        "2012-08-22": 35,
+        "2012-08-23": 30,
+        "2012-08-24": 4,
+        "2012-08-25": 55,
+        "2012-08-26": 65,
+        "2012-08-27": 19,
+        "2012-08-28": 12,
+        "2012-08-29": 47,
+        "2012-08-30": 17,
+        "2012-08-31": 58,
+        "2012-09-01": 0,
+        "2012-09-02": 0,
+        "2012-09-03": 0,
+        "2012-09-04": 13,
+        "2012-09-05": 40,
+        "2012-09-06": 80,
+        "2012-09-07": 57,
+        "2012-09-08": 8,
+        "2012-09-09": 19,
+        "2012-09-10": 44,
+        "2012-09-11": 8,
+        "2012-09-12": 8,
+        "2012-09-13": 58,
+        "2012-09-14": 11,
+        "2012-09-15": 29,
+        "2012-09-16": 16,
+        "2012-09-17": 21,
+        "2012-09-18": 24,
+        "2012-09-19": 35,
+        "2012-09-20": 60,
+        "2012-09-21": 5,
+        "2012-09-22": 0,
+        "2012-09-23": 19,
+        "2012-09-24": 3,
+        "2012-09-25": 30,
+        "2012-09-26": 31,
+        "2012-09-27": 9,
+        "2012-09-28": 27,
+        "2012-09-29": 0,
+        "2012-09-30": 0,
+        "2012-10-01": 49,
+        "2012-10-02": 4,
+        "2012-10-03": 11,
+        "2012-10-04": 26,
+        "2012-10-05": 12,
+        "2012-10-06": 14,
+        "2012-10-07": 10,
+        "2012-10-08": 50,
+        "2012-10-09": 63,
+        "2012-10-10": 40,
+        "2012-10-11": 12,
+        "2012-10-12": 5,
+        "2012-10-13": 0,
+        "2012-10-14": 0,
+        "2012-10-15": 0,
+        "2012-10-16": 67,
+        "2012-10-17": 67,
+        "2012-10-18": 3,
+        "2012-10-19": 0,
+        "2012-10-20": 6,
+        "2012-10-21": 0,
+        "2012-10-22": 33,
+        "2012-10-23": 6,
+        "2012-10-24": 4,
+        "2012-10-25": 31,
+        "2012-10-26": 4,
+        "2012-10-27": 0,
+        "2012-10-28": 1,
+        "2012-10-29": 9,
+        "2012-10-30": 1,
+        "2012-10-31": 25,
+        "2012-11-01": 7,
+        "2012-11-02": 8,
+        "2012-11-03": 3,
+        "2012-11-04": 49,
+        "2012-11-05": 0,
+        "2012-11-06": 8,
+        "2012-11-07": 24,
+        "2012-11-08": 6,
+        "2012-11-09": 9,
+        "2012-11-10": 1,
+        "2012-11-11": 19,
+        "2012-11-12": 0,
+        "2012-11-13": 8,
+        "2012-11-14": 31,
+        "2012-11-15": 4,
+        "2012-11-16": 15,
+        "2012-11-17": 34,
+        "2012-11-18": 21,
+        "2012-11-19": 11,
+        "2012-11-20": 12,
+        "2012-11-21": 45,
+        "2012-11-22": 2,
+        "2012-11-23": 36,
+        "2012-11-24": 13,
+        "2012-11-25": 0,
+        "2012-11-26": 18,
+        "2012-11-27": 9,
+        "2012-11-28": 14,
+        "2012-11-29": 3,
+        "2012-11-30": 26,
+        "2012-12-01": 0,
+        "2012-12-02": 0,
+        "2012-12-03": 38,
+        "2012-12-04": 6,
+        "2012-12-05": 24,
+        "2012-12-06": 7,
+        "2012-12-07": 0,
+        "2012-12-08": 5,
+        "2012-12-09": 0,
+        "2012-12-10": 2,
+        "2012-12-11": 4,
+        "2012-12-12": 26,
+        "2012-12-13": 15,
+        "2012-12-14": 0,
+        "2012-12-15": 0,
+        "2012-12-16": 0,
+        "2012-12-17": 0,
+        "2012-12-18": 18,
+        "2012-12-19": 18,
+        "2012-12-20": 10,
+        "2012-12-21": 20,
+        "2012-12-22": 0,
+        "2012-12-23": 3,
+        "2012-12-24": 5,
+        "2012-12-25": 4,
+        "2012-12-26": 24,
+        "2012-12-27": 5,
+        "2012-12-28": 10,
+        "2012-12-29": 0,
+        "2012-12-30": 1,
+        "2012-12-31": 10
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 5288,
+      "severity_distribution": {
+        "UNKNOWN": 5288
+      },
+      "score_distribution": {
+        "5.0": 632,
+        "7.5": 496,
+        "4.3": 959,
+        "2.1": 161,
+        "6.8": 472,
+        "6.2": 45,
+        "6.5": 71,
+        "1.9": 29,
+        "9.3": 503,
+        "6.0": 55,
+        "2.6": 64,
+        "3.5": 130,
+        "4.0": 197,
+        "4.9": 71,
+        "3.3": 52,
+        "4.6": 29,
+        "5.8": 144,
+        "6.4": 93,
+        "10.0": 426,
+        "8.5": 14,
+        "3.6": 30,
+        "6.9": 140,
+        "5.1": 21,
+        "7.8": 109,
+        "4.4": 20,
+        "6.1": 10,
+        "5.5": 41,
+        "7.2": 68,
+        "7.1": 28,
+        "7.6": 24,
+        "7.9": 7,
+        "5.4": 11,
+        "6.3": 9,
+        "4.7": 18,
+        "8.3": 10,
+        "1.2": 9,
+        "7.4": 4,
+        "3.7": 7,
+        "1.7": 5,
+        "2.7": 2,
+        "3.0": 1,
+        "9.0": 26,
+        "2.9": 9,
+        "7.7": 5,
+        "3.2": 3,
+        "1.8": 6,
+        "5.9": 1,
+        "6.6": 2,
+        "5.2": 1,
+        "5.6": 6,
+        "2.3": 1,
+        "2.8": 1,
+        "5.7": 1,
+        "8.8": 1,
+        "9.4": 2,
+        "0.0": 2,
+        "1.5": 1,
+        "5.3": 1,
+        "4.8": 2
+      }
+    },
+    "v3.0": {
+      "total": 1,
+      "severity_distribution": {
+        "MEDIUM": 1
+      },
+      "score_distribution": {
+        "6.8": 1
+      }
+    },
+    "v3.1": {
+      "total": 115,
+      "severity_distribution": {
+        "MEDIUM": 43,
+        "HIGH": 51,
+        "CRITICAL": 21
+      },
+      "score_distribution": {
+        "5.3": 2,
+        "7.0": 3,
+        "4.5": 1,
+        "4.8": 1,
+        "9.8": 14,
+        "5.9": 6,
+        "7.8": 11,
+        "8.8": 12,
+        "5.5": 17,
+        "7.5": 11,
+        "6.0": 1,
+        "9.1": 4,
+        "6.5": 8,
+        "8.1": 5,
+        "6.1": 3,
+        "8.4": 2,
+        "7.2": 1,
+        "9.9": 1,
+        "7.4": 5,
+        "5.8": 1,
+        "9.6": 1,
+        "7.3": 1,
+        "6.7": 1,
+        "4.7": 1,
+        "9.0": 1,
+        "5.4": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 482,
+      "epss_gt_0_5": 132,
+      "epss_gt_0_9": 32
+    }
+  },
+  "kev": {
+    "kev_count": 22
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Apple",
+        "count": 478
+      },
+      {
+        "name": "Google",
+        "count": 403
+      },
+      {
+        "name": "Oracle",
+        "count": 393
+      },
+      {
+        "name": "Microsoft",
+        "count": 376
+      },
+      {
+        "name": "Linux",
+        "count": 227
+      },
+      {
+        "name": "Mozilla",
+        "count": 205
+      },
+      {
+        "name": "Drupal",
+        "count": 203
+      },
+      {
+        "name": "Ibm",
+        "count": 175
+      },
+      {
+        "name": "Redhat",
+        "count": 167
+      },
+      {
+        "name": "Cisco",
+        "count": 160
+      },
+      {
+        "name": "Opensuse",
+        "count": 150
+      },
+      {
+        "name": "Adobe",
+        "count": 148
+      },
+      {
+        "name": "Canonical",
+        "count": 119
+      },
+      {
+        "name": "Sun",
+        "count": 115
+      },
+      {
+        "name": "Wordpress",
+        "count": 104
+      },
+      {
+        "name": "Suse",
+        "count": 99
+      },
+      {
+        "name": "Moodle",
+        "count": 95
+      },
+      {
+        "name": "Debian",
+        "count": 91
+      },
+      {
+        "name": "Hp",
+        "count": 87
+      },
+      {
+        "name": "Apache",
+        "count": 67
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-79",
+        "count": 731
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 683
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 573
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 353
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 238
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 232
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 222
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 154
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 143
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 132
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 120
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 100
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 92
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 83
+      },
+      {
+        "cwe": "CWE-362",
+        "count": 74
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 50
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 35
+      },
+      {
+        "cwe": "CWE-16",
+        "count": 19
+      },
+      {
+        "cwe": "CWE-190",
+        "count": 19
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 17
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 5256
+      },
+      {
+        "status": "Analyzed",
+        "count": 32
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 9377
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 7308
+      },
+      {
+        "tag": "Exploit",
+        "count": 3974
+      },
+      {
+        "tag": "Patch",
+        "count": 3674
+      },
+      {
+        "tag": "Mailing List",
+        "count": 1765
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 1552
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1372
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 1144
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 525
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 436
+      },
+      {
+        "tag": "Release Notes",
+        "count": 155
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 58
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 36
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 22
+      },
+      {
+        "tag": "Mitigation",
+        "count": 17
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 16
+      },
+      {
+        "tag": "Technical Description",
+        "count": 6
+      },
+      {
+        "tag": "Product",
+        "count": 2
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:43.946850",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2013.json b/web/data/cve_2013.json
new file mode 100644
index 00000000000..5ba3c0fdd14
--- /dev/null
+++ b/web/data/cve_2013.json
@@ -0,0 +1,786 @@
+{
+  "year": 2013,
+  "total_cves": 5187,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 439,
+      "2": 405,
+      "3": 430,
+      "4": 438,
+      "5": 356,
+      "6": 360,
+      "7": 470,
+      "8": 374,
+      "9": 454,
+      "10": 583,
+      "11": 394,
+      "12": 484
+    },
+    "daily_analysis": {
+      "total_days": 294,
+      "avg_per_day": 17.64,
+      "highest_day": {
+        "date": "2013-04-17",
+        "count": 152
+      },
+      "lowest_day": {
+        "date": "2013-01-08",
+        "count": 1
+      },
+      "daily_counts": {
+        "2013-01-01": 6,
+        "2013-01-02": 14,
+        "2013-01-03": 16,
+        "2013-01-04": 22,
+        "2013-01-05": 4,
+        "2013-01-06": 0,
+        "2013-01-07": 0,
+        "2013-01-08": 1,
+        "2013-01-09": 15,
+        "2013-01-10": 28,
+        "2013-01-11": 8,
+        "2013-01-12": 8,
+        "2013-01-13": 29,
+        "2013-01-14": 1,
+        "2013-01-15": 24,
+        "2013-01-16": 0,
+        "2013-01-17": 93,
+        "2013-01-18": 11,
+        "2013-01-19": 4,
+        "2013-01-20": 0,
+        "2013-01-21": 10,
+        "2013-01-22": 10,
+        "2013-01-23": 1,
+        "2013-01-24": 44,
+        "2013-01-25": 3,
+        "2013-01-26": 5,
+        "2013-01-27": 20,
+        "2013-01-28": 1,
+        "2013-01-29": 18,
+        "2013-01-30": 1,
+        "2013-01-31": 42,
+        "2013-02-01": 1,
+        "2013-02-02": 51,
+        "2013-02-03": 19,
+        "2013-02-04": 1,
+        "2013-02-05": 10,
+        "2013-02-06": 15,
+        "2013-02-07": 2,
+        "2013-02-08": 21,
+        "2013-02-09": 0,
+        "2013-02-10": 0,
+        "2013-02-11": 1,
+        "2013-02-12": 27,
+        "2013-02-13": 79,
+        "2013-02-14": 9,
+        "2013-02-15": 11,
+        "2013-02-16": 7,
+        "2013-02-17": 0,
+        "2013-02-18": 12,
+        "2013-02-19": 18,
+        "2013-02-20": 22,
+        "2013-02-21": 5,
+        "2013-02-22": 10,
+        "2013-02-23": 23,
+        "2013-02-24": 34,
+        "2013-02-25": 1,
+        "2013-02-26": 2,
+        "2013-02-27": 14,
+        "2013-02-28": 10,
+        "2013-03-01": 19,
+        "2013-03-02": 0,
+        "2013-03-03": 0,
+        "2013-03-04": 0,
+        "2013-03-05": 31,
+        "2013-03-06": 9,
+        "2013-03-07": 22,
+        "2013-03-08": 16,
+        "2013-03-09": 18,
+        "2013-03-10": 0,
+        "2013-03-11": 21,
+        "2013-03-12": 20,
+        "2013-03-13": 27,
+        "2013-03-14": 13,
+        "2013-03-15": 33,
+        "2013-03-16": 0,
+        "2013-03-17": 0,
+        "2013-03-18": 3,
+        "2013-03-19": 22,
+        "2013-03-20": 29,
+        "2013-03-21": 27,
+        "2013-03-22": 20,
+        "2013-03-23": 0,
+        "2013-03-24": 0,
+        "2013-03-25": 8,
+        "2013-03-26": 7,
+        "2013-03-27": 37,
+        "2013-03-28": 31,
+        "2013-03-29": 17,
+        "2013-03-30": 0,
+        "2013-03-31": 0,
+        "2013-04-01": 8,
+        "2013-04-02": 10,
+        "2013-04-03": 19,
+        "2013-04-04": 14,
+        "2013-04-05": 8,
+        "2013-04-06": 0,
+        "2013-04-07": 2,
+        "2013-04-08": 7,
+        "2013-04-09": 31,
+        "2013-04-10": 15,
+        "2013-04-11": 16,
+        "2013-04-12": 10,
+        "2013-04-13": 2,
+        "2013-04-14": 0,
+        "2013-04-15": 0,
+        "2013-04-16": 14,
+        "2013-04-17": 152,
+        "2013-04-18": 14,
+        "2013-04-19": 7,
+        "2013-04-20": 0,
+        "2013-04-21": 3,
+        "2013-04-22": 22,
+        "2013-04-23": 5,
+        "2013-04-24": 16,
+        "2013-04-25": 28,
+        "2013-04-26": 10,
+        "2013-04-27": 4,
+        "2013-04-28": 3,
+        "2013-04-29": 15,
+        "2013-04-30": 3,
+        "2013-05-01": 21,
+        "2013-05-02": 21,
+        "2013-05-03": 14,
+        "2013-05-04": 3,
+        "2013-05-05": 5,
+        "2013-05-06": 0,
+        "2013-05-07": 3,
+        "2013-05-08": 18,
+        "2013-05-09": 14,
+        "2013-05-10": 25,
+        "2013-05-11": 0,
+        "2013-05-12": 0,
+        "2013-05-13": 15,
+        "2013-05-14": 1,
+        "2013-05-15": 31,
+        "2013-05-16": 58,
+        "2013-05-17": 0,
+        "2013-05-18": 0,
+        "2013-05-19": 0,
+        "2013-05-20": 23,
+        "2013-05-21": 7,
+        "2013-05-22": 18,
+        "2013-05-23": 17,
+        "2013-05-24": 16,
+        "2013-05-25": 13,
+        "2013-05-26": 0,
+        "2013-05-27": 7,
+        "2013-05-28": 4,
+        "2013-05-29": 15,
+        "2013-05-30": 0,
+        "2013-05-31": 7,
+        "2013-06-01": 5,
+        "2013-06-02": 0,
+        "2013-06-03": 6,
+        "2013-06-04": 0,
+        "2013-06-05": 34,
+        "2013-06-06": 15,
+        "2013-06-07": 14,
+        "2013-06-08": 12,
+        "2013-06-09": 10,
+        "2013-06-10": 10,
+        "2013-06-11": 0,
+        "2013-06-12": 26,
+        "2013-06-13": 1,
+        "2013-06-14": 14,
+        "2013-06-15": 29,
+        "2013-06-16": 1,
+        "2013-06-17": 21,
+        "2013-06-18": 46,
+        "2013-06-19": 5,
+        "2013-06-20": 15,
+        "2013-06-21": 23,
+        "2013-06-22": 0,
+        "2013-06-23": 0,
+        "2013-06-24": 4,
+        "2013-06-25": 9,
+        "2013-06-26": 22,
+        "2013-06-27": 11,
+        "2013-06-28": 14,
+        "2013-06-29": 0,
+        "2013-06-30": 13,
+        "2013-07-01": 13,
+        "2013-07-02": 10,
+        "2013-07-03": 24,
+        "2013-07-04": 11,
+        "2013-07-05": 0,
+        "2013-07-06": 5,
+        "2013-07-07": 0,
+        "2013-07-08": 22,
+        "2013-07-09": 10,
+        "2013-07-10": 71,
+        "2013-07-11": 10,
+        "2013-07-12": 8,
+        "2013-07-13": 3,
+        "2013-07-14": 0,
+        "2013-07-15": 6,
+        "2013-07-16": 13,
+        "2013-07-17": 75,
+        "2013-07-18": 29,
+        "2013-07-19": 5,
+        "2013-07-20": 9,
+        "2013-07-21": 0,
+        "2013-07-22": 14,
+        "2013-07-23": 16,
+        "2013-07-24": 5,
+        "2013-07-25": 6,
+        "2013-07-26": 2,
+        "2013-07-27": 0,
+        "2013-07-28": 0,
+        "2013-07-29": 45,
+        "2013-07-30": 17,
+        "2013-07-31": 41,
+        "2013-08-01": 17,
+        "2013-08-02": 6,
+        "2013-08-03": 0,
+        "2013-08-04": 0,
+        "2013-08-05": 12,
+        "2013-08-06": 13,
+        "2013-08-07": 15,
+        "2013-08-08": 2,
+        "2013-08-09": 34,
+        "2013-08-10": 0,
+        "2013-08-11": 0,
+        "2013-08-12": 3,
+        "2013-08-13": 3,
+        "2013-08-14": 26,
+        "2013-08-15": 6,
+        "2013-08-16": 23,
+        "2013-08-17": 2,
+        "2013-08-18": 4,
+        "2013-08-19": 23,
+        "2013-08-20": 30,
+        "2013-08-21": 21,
+        "2013-08-22": 6,
+        "2013-08-23": 20,
+        "2013-08-24": 1,
+        "2013-08-25": 24,
+        "2013-08-26": 0,
+        "2013-08-27": 9,
+        "2013-08-28": 34,
+        "2013-08-29": 12,
+        "2013-08-30": 9,
+        "2013-08-31": 19,
+        "2013-09-01": 0,
+        "2013-09-02": 0,
+        "2013-09-03": 0,
+        "2013-09-04": 3,
+        "2013-09-05": 17,
+        "2013-09-06": 17,
+        "2013-09-07": 0,
+        "2013-09-08": 9,
+        "2013-09-09": 15,
+        "2013-09-10": 14,
+        "2013-09-11": 47,
+        "2013-09-12": 41,
+        "2013-09-13": 6,
+        "2013-09-14": 0,
+        "2013-09-15": 0,
+        "2013-09-16": 65,
+        "2013-09-17": 12,
+        "2013-09-18": 20,
+        "2013-09-19": 43,
+        "2013-09-20": 20,
+        "2013-09-21": 0,
+        "2013-09-22": 0,
+        "2013-09-23": 27,
+        "2013-09-24": 9,
+        "2013-09-25": 22,
+        "2013-09-26": 4,
+        "2013-09-27": 16,
+        "2013-09-28": 9,
+        "2013-09-29": 0,
+        "2013-09-30": 38,
+        "2013-10-01": 52,
+        "2013-10-02": 32,
+        "2013-10-03": 27,
+        "2013-10-04": 24,
+        "2013-10-05": 10,
+        "2013-10-06": 0,
+        "2013-10-07": 0,
+        "2013-10-08": 0,
+        "2013-10-09": 43,
+        "2013-10-10": 23,
+        "2013-10-11": 24,
+        "2013-10-12": 0,
+        "2013-10-13": 25,
+        "2013-10-14": 5,
+        "2013-10-15": 1,
+        "2013-10-16": 136,
+        "2013-10-17": 19,
+        "2013-10-18": 0,
+        "2013-10-19": 14,
+        "2013-10-20": 0,
+        "2013-10-21": 5,
+        "2013-10-22": 8,
+        "2013-10-23": 3,
+        "2013-10-24": 52,
+        "2013-10-25": 19,
+        "2013-10-26": 6,
+        "2013-10-27": 5,
+        "2013-10-28": 28,
+        "2013-10-29": 4,
+        "2013-10-30": 14,
+        "2013-10-31": 4,
+        "2013-11-01": 10,
+        "2013-11-02": 24,
+        "2013-11-03": 0,
+        "2013-11-04": 20,
+        "2013-11-05": 23,
+        "2013-11-06": 9,
+        "2013-11-07": 0,
+        "2013-11-08": 14,
+        "2013-11-09": 4,
+        "2013-11-10": 0,
+        "2013-11-11": 0,
+        "2013-11-12": 12,
+        "2013-11-13": 49,
+        "2013-11-14": 7,
+        "2013-11-15": 0,
+        "2013-11-16": 0,
+        "2013-11-17": 0,
+        "2013-11-18": 43,
+        "2013-11-19": 9,
+        "2013-11-20": 36,
+        "2013-11-21": 14,
+        "2013-11-22": 14,
+        "2013-11-23": 60,
+        "2013-11-24": 5,
+        "2013-11-25": 6,
+        "2013-11-26": 8,
+        "2013-11-27": 11,
+        "2013-11-28": 4,
+        "2013-11-29": 8,
+        "2013-11-30": 4,
+        "2013-12-01": 4,
+        "2013-12-02": 9,
+        "2013-12-03": 5,
+        "2013-12-04": 9,
+        "2013-12-05": 29,
+        "2013-12-06": 2,
+        "2013-12-07": 53,
+        "2013-12-08": 0,
+        "2013-12-09": 46,
+        "2013-12-10": 13,
+        "2013-12-11": 37,
+        "2013-12-12": 17,
+        "2013-12-13": 27,
+        "2013-12-14": 41,
+        "2013-12-15": 0,
+        "2013-12-16": 1,
+        "2013-12-17": 20,
+        "2013-12-18": 16,
+        "2013-12-19": 23,
+        "2013-12-20": 7,
+        "2013-12-21": 32,
+        "2013-12-22": 8,
+        "2013-12-23": 22,
+        "2013-12-24": 15,
+        "2013-12-25": 0,
+        "2013-12-26": 1,
+        "2013-12-27": 5,
+        "2013-12-28": 11,
+        "2013-12-29": 6,
+        "2013-12-30": 13,
+        "2013-12-31": 12
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 5187,
+      "severity_distribution": {
+        "UNKNOWN": 5187
+      },
+      "score_distribution": {
+        "5.0": 558,
+        "5.8": 123,
+        "7.2": 107,
+        "6.8": 446,
+        "4.0": 217,
+        "7.5": 404,
+        "10.0": 438,
+        "7.4": 5,
+        "9.3": 425,
+        "3.7": 10,
+        "4.3": 881,
+        "7.1": 66,
+        "6.9": 76,
+        "2.6": 36,
+        "1.9": 59,
+        "3.6": 16,
+        "4.9": 115,
+        "6.2": 30,
+        "4.6": 49,
+        "5.1": 24,
+        "6.0": 42,
+        "3.3": 39,
+        "7.8": 162,
+        "5.7": 9,
+        "2.1": 131,
+        "6.1": 19,
+        "5.5": 35,
+        "6.4": 61,
+        "4.4": 30,
+        "2.7": 4,
+        "3.5": 170,
+        "9.0": 44,
+        "6.3": 19,
+        "5.2": 12,
+        "6.5": 82,
+        "1.5": 9,
+        "1.2": 4,
+        "8.5": 24,
+        "7.9": 10,
+        "7.6": 31,
+        "8.8": 3,
+        "3.2": 3,
+        "8.2": 1,
+        "5.4": 30,
+        "6.6": 18,
+        "2.4": 2,
+        "2.9": 25,
+        "4.7": 50,
+        "6.7": 1,
+        "5.9": 2,
+        "1.7": 5,
+        "2.8": 1,
+        "3.8": 3,
+        "3.0": 1,
+        "8.3": 8,
+        "2.3": 2,
+        "9.4": 4,
+        "8.0": 2,
+        "7.7": 1,
+        "0.0": 1,
+        "7.0": 1,
+        "4.1": 1
+      }
+    },
+    "v3.0": {
+      "total": 3,
+      "severity_distribution": {
+        "MEDIUM": 2,
+        "HIGH": 1
+      },
+      "score_distribution": {
+        "5.9": 1,
+        "6.1": 1,
+        "7.5": 1
+      }
+    },
+    "v3.1": {
+      "total": 98,
+      "severity_distribution": {
+        "HIGH": 54,
+        "MEDIUM": 20,
+        "CRITICAL": 23,
+        "LOW": 1
+      },
+      "score_distribution": {
+        "7.5": 13,
+        "5.5": 6,
+        "9.8": 19,
+        "6.5": 3,
+        "5.3": 2,
+        "10.0": 1,
+        "4.8": 1,
+        "9.1": 1,
+        "8.8": 13,
+        "5.4": 2,
+        "9.0": 1,
+        "7.0": 5,
+        "7.4": 2,
+        "7.8": 12,
+        "5.9": 2,
+        "7.6": 1,
+        "6.1": 2,
+        "3.7": 1,
+        "8.4": 3,
+        "7.3": 2,
+        "8.1": 3,
+        "6.3": 1,
+        "5.0": 1,
+        "9.3": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 557,
+      "epss_gt_0_5": 123,
+      "epss_gt_0_9": 12
+    }
+  },
+  "kev": {
+    "kev_count": 35
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 516
+      },
+      {
+        "name": "Oracle",
+        "count": 515
+      },
+      {
+        "name": "Cisco",
+        "count": 436
+      },
+      {
+        "name": "Ibm",
+        "count": 390
+      },
+      {
+        "name": "Apple",
+        "count": 298
+      },
+      {
+        "name": "Redhat",
+        "count": 288
+      },
+      {
+        "name": "Linux",
+        "count": 280
+      },
+      {
+        "name": "Google",
+        "count": 252
+      },
+      {
+        "name": "Opensuse",
+        "count": 236
+      },
+      {
+        "name": "Canonical",
+        "count": 202
+      },
+      {
+        "name": "Sun",
+        "count": 169
+      },
+      {
+        "name": "Mozilla",
+        "count": 167
+      },
+      {
+        "name": "Adobe",
+        "count": 148
+      },
+      {
+        "name": "Hp",
+        "count": 146
+      },
+      {
+        "name": "Debian",
+        "count": 124
+      },
+      {
+        "name": "Drupal",
+        "count": 90
+      },
+      {
+        "name": "Suse",
+        "count": 88
+      },
+      {
+        "name": "Wireshark",
+        "count": 82
+      },
+      {
+        "name": "Apache",
+        "count": 79
+      },
+      {
+        "name": "Ffmpeg",
+        "count": 78
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-119",
+        "count": 734
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 617
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 556
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 494
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 261
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 247
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 146
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 143
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 130
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 124
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 120
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 111
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 103
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 86
+      },
+      {
+        "cwe": "CWE-362",
+        "count": 70
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 46
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 33
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 24
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 21
+      },
+      {
+        "cwe": "CWE-16",
+        "count": 20
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 5152
+      },
+      {
+        "status": "Analyzed",
+        "count": 35
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 9216
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 5248
+      },
+      {
+        "tag": "Patch",
+        "count": 2918
+      },
+      {
+        "tag": "Exploit",
+        "count": 2290
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 1659
+      },
+      {
+        "tag": "Mailing List",
+        "count": 1498
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 788
+      },
+      {
+        "tag": "Broken Link",
+        "count": 714
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 456
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 162
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 40
+      },
+      {
+        "tag": "Release Notes",
+        "count": 34
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 20
+      },
+      {
+        "tag": "Technical Description",
+        "count": 14
+      },
+      {
+        "tag": "Mitigation",
+        "count": 10
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 8
+      },
+      {
+        "tag": "Product",
+        "count": 4
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 2
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:44.150685",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2014.json b/web/data/cve_2014.json
new file mode 100644
index 00000000000..109fd36c1e1
--- /dev/null
+++ b/web/data/cve_2014.json
@@ -0,0 +1,798 @@
+{
+  "year": 2014,
+  "total_cves": 7928,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 558,
+      "2": 431,
+      "3": 544,
+      "4": 672,
+      "5": 550,
+      "6": 445,
+      "7": 653,
+      "8": 401,
+      "9": 1146,
+      "10": 1413,
+      "11": 501,
+      "12": 614
+    },
+    "daily_analysis": {
+      "total_days": 322,
+      "avg_per_day": 24.62,
+      "highest_day": {
+        "date": "2014-09-09",
+        "count": 326
+      },
+      "lowest_day": {
+        "date": "2014-01-01",
+        "count": 1
+      },
+      "daily_counts": {
+        "2014-01-01": 1,
+        "2014-01-02": 10,
+        "2014-01-03": 14,
+        "2014-01-04": 9,
+        "2014-01-05": 4,
+        "2014-01-06": 9,
+        "2014-01-07": 12,
+        "2014-01-08": 20,
+        "2014-01-09": 14,
+        "2014-01-10": 24,
+        "2014-01-11": 4,
+        "2014-01-12": 12,
+        "2014-01-13": 6,
+        "2014-01-14": 2,
+        "2014-01-15": 152,
+        "2014-01-16": 33,
+        "2014-01-17": 7,
+        "2014-01-18": 8,
+        "2014-01-19": 9,
+        "2014-01-20": 7,
+        "2014-01-21": 38,
+        "2014-01-22": 19,
+        "2014-01-23": 25,
+        "2014-01-24": 23,
+        "2014-01-25": 6,
+        "2014-01-26": 28,
+        "2014-01-27": 1,
+        "2014-01-28": 13,
+        "2014-01-29": 23,
+        "2014-01-30": 17,
+        "2014-01-31": 8,
+        "2014-02-01": 9,
+        "2014-02-02": 7,
+        "2014-02-03": 5,
+        "2014-02-04": 24,
+        "2014-02-05": 23,
+        "2014-02-06": 48,
+        "2014-02-07": 7,
+        "2014-02-08": 10,
+        "2014-02-09": 0,
+        "2014-02-10": 19,
+        "2014-02-11": 11,
+        "2014-02-12": 35,
+        "2014-02-13": 8,
+        "2014-02-14": 44,
+        "2014-02-15": 20,
+        "2014-02-16": 0,
+        "2014-02-17": 10,
+        "2014-02-18": 12,
+        "2014-02-19": 0,
+        "2014-02-20": 10,
+        "2014-02-21": 4,
+        "2014-02-22": 24,
+        "2014-02-23": 0,
+        "2014-02-24": 14,
+        "2014-02-25": 1,
+        "2014-02-26": 28,
+        "2014-02-27": 49,
+        "2014-02-28": 9,
+        "2014-03-01": 11,
+        "2014-03-02": 17,
+        "2014-03-03": 25,
+        "2014-03-04": 4,
+        "2014-03-05": 24,
+        "2014-03-06": 26,
+        "2014-03-07": 3,
+        "2014-03-08": 0,
+        "2014-03-09": 18,
+        "2014-03-10": 0,
+        "2014-03-11": 51,
+        "2014-03-12": 30,
+        "2014-03-13": 5,
+        "2014-03-14": 87,
+        "2014-03-15": 0,
+        "2014-03-16": 33,
+        "2014-03-17": 0,
+        "2014-03-18": 23,
+        "2014-03-19": 30,
+        "2014-03-20": 9,
+        "2014-03-21": 24,
+        "2014-03-22": 0,
+        "2014-03-23": 0,
+        "2014-03-24": 35,
+        "2014-03-25": 21,
+        "2014-03-26": 11,
+        "2014-03-27": 20,
+        "2014-03-28": 8,
+        "2014-03-29": 8,
+        "2014-03-30": 0,
+        "2014-03-31": 21,
+        "2014-04-01": 30,
+        "2014-04-02": 33,
+        "2014-04-03": 3,
+        "2014-04-04": 15,
+        "2014-04-05": 11,
+        "2014-04-06": 2,
+        "2014-04-07": 4,
+        "2014-04-08": 24,
+        "2014-04-09": 14,
+        "2014-04-10": 40,
+        "2014-04-11": 26,
+        "2014-04-12": 20,
+        "2014-04-13": 0,
+        "2014-04-14": 15,
+        "2014-04-15": 55,
+        "2014-04-16": 111,
+        "2014-04-17": 17,
+        "2014-04-18": 18,
+        "2014-04-19": 15,
+        "2014-04-20": 2,
+        "2014-04-21": 5,
+        "2014-04-22": 25,
+        "2014-04-23": 46,
+        "2014-04-24": 12,
+        "2014-04-25": 18,
+        "2014-04-26": 9,
+        "2014-04-27": 19,
+        "2014-04-28": 14,
+        "2014-04-29": 32,
+        "2014-04-30": 37,
+        "2014-05-01": 12,
+        "2014-05-02": 38,
+        "2014-05-03": 0,
+        "2014-05-04": 0,
+        "2014-05-05": 15,
+        "2014-05-06": 11,
+        "2014-05-07": 13,
+        "2014-05-08": 52,
+        "2014-05-09": 6,
+        "2014-05-10": 2,
+        "2014-05-11": 5,
+        "2014-05-12": 21,
+        "2014-05-13": 17,
+        "2014-05-14": 65,
+        "2014-05-15": 8,
+        "2014-05-16": 21,
+        "2014-05-17": 5,
+        "2014-05-18": 1,
+        "2014-05-19": 27,
+        "2014-05-20": 33,
+        "2014-05-21": 14,
+        "2014-05-22": 47,
+        "2014-05-23": 17,
+        "2014-05-24": 0,
+        "2014-05-25": 3,
+        "2014-05-26": 40,
+        "2014-05-27": 26,
+        "2014-05-28": 2,
+        "2014-05-29": 18,
+        "2014-05-30": 25,
+        "2014-05-31": 6,
+        "2014-06-01": 4,
+        "2014-06-02": 31,
+        "2014-06-03": 10,
+        "2014-06-04": 30,
+        "2014-06-05": 32,
+        "2014-06-06": 12,
+        "2014-06-07": 1,
+        "2014-06-08": 17,
+        "2014-06-09": 23,
+        "2014-06-10": 13,
+        "2014-06-11": 102,
+        "2014-06-12": 0,
+        "2014-06-13": 23,
+        "2014-06-14": 6,
+        "2014-06-15": 0,
+        "2014-06-16": 11,
+        "2014-06-17": 19,
+        "2014-06-18": 34,
+        "2014-06-19": 19,
+        "2014-06-20": 11,
+        "2014-06-21": 8,
+        "2014-06-22": 3,
+        "2014-06-23": 9,
+        "2014-06-24": 0,
+        "2014-06-25": 11,
+        "2014-06-26": 0,
+        "2014-06-27": 4,
+        "2014-06-28": 12,
+        "2014-06-29": 0,
+        "2014-06-30": 0,
+        "2014-07-01": 68,
+        "2014-07-02": 76,
+        "2014-07-03": 26,
+        "2014-07-04": 0,
+        "2014-07-05": 0,
+        "2014-07-06": 2,
+        "2014-07-07": 41,
+        "2014-07-08": 31,
+        "2014-07-09": 21,
+        "2014-07-10": 21,
+        "2014-07-11": 24,
+        "2014-07-12": 0,
+        "2014-07-13": 0,
+        "2014-07-14": 12,
+        "2014-07-15": 11,
+        "2014-07-16": 16,
+        "2014-07-17": 92,
+        "2014-07-18": 6,
+        "2014-07-19": 20,
+        "2014-07-20": 29,
+        "2014-07-21": 5,
+        "2014-07-22": 14,
+        "2014-07-23": 22,
+        "2014-07-24": 22,
+        "2014-07-25": 6,
+        "2014-07-26": 16,
+        "2014-07-27": 2,
+        "2014-07-28": 18,
+        "2014-07-29": 36,
+        "2014-07-30": 7,
+        "2014-07-31": 9,
+        "2014-08-01": 13,
+        "2014-08-02": 0,
+        "2014-08-03": 5,
+        "2014-08-04": 0,
+        "2014-08-05": 0,
+        "2014-08-06": 20,
+        "2014-08-07": 25,
+        "2014-08-08": 0,
+        "2014-08-09": 0,
+        "2014-08-10": 0,
+        "2014-08-11": 7,
+        "2014-08-12": 79,
+        "2014-08-13": 12,
+        "2014-08-14": 24,
+        "2014-08-15": 6,
+        "2014-08-16": 3,
+        "2014-08-17": 17,
+        "2014-08-18": 10,
+        "2014-08-19": 20,
+        "2014-08-20": 18,
+        "2014-08-21": 12,
+        "2014-08-22": 30,
+        "2014-08-23": 7,
+        "2014-08-24": 0,
+        "2014-08-25": 16,
+        "2014-08-26": 21,
+        "2014-08-27": 12,
+        "2014-08-28": 13,
+        "2014-08-29": 24,
+        "2014-08-30": 2,
+        "2014-08-31": 5,
+        "2014-09-01": 3,
+        "2014-09-02": 12,
+        "2014-09-03": 10,
+        "2014-09-04": 23,
+        "2014-09-05": 15,
+        "2014-09-06": 0,
+        "2014-09-07": 0,
+        "2014-09-08": 5,
+        "2014-09-09": 326,
+        "2014-09-10": 79,
+        "2014-09-11": 45,
+        "2014-09-12": 22,
+        "2014-09-13": 0,
+        "2014-09-14": 0,
+        "2014-09-15": 27,
+        "2014-09-16": 0,
+        "2014-09-17": 32,
+        "2014-09-18": 93,
+        "2014-09-19": 35,
+        "2014-09-20": 41,
+        "2014-09-21": 0,
+        "2014-09-22": 62,
+        "2014-09-23": 59,
+        "2014-09-24": 12,
+        "2014-09-25": 27,
+        "2014-09-26": 23,
+        "2014-09-27": 17,
+        "2014-09-28": 42,
+        "2014-09-29": 53,
+        "2014-09-30": 83,
+        "2014-10-01": 8,
+        "2014-10-02": 54,
+        "2014-10-03": 30,
+        "2014-10-04": 29,
+        "2014-10-05": 6,
+        "2014-10-06": 28,
+        "2014-10-07": 20,
+        "2014-10-08": 42,
+        "2014-10-09": 6,
+        "2014-10-10": 51,
+        "2014-10-11": 11,
+        "2014-10-12": 2,
+        "2014-10-13": 16,
+        "2014-10-14": 11,
+        "2014-10-15": 196,
+        "2014-10-16": 126,
+        "2014-10-17": 23,
+        "2014-10-18": 25,
+        "2014-10-19": 244,
+        "2014-10-20": 146,
+        "2014-10-21": 181,
+        "2014-10-22": 19,
+        "2014-10-23": 10,
+        "2014-10-24": 2,
+        "2014-10-25": 21,
+        "2014-10-26": 12,
+        "2014-10-27": 16,
+        "2014-10-28": 9,
+        "2014-10-29": 33,
+        "2014-10-30": 7,
+        "2014-10-31": 29,
+        "2014-11-01": 5,
+        "2014-11-02": 3,
+        "2014-11-03": 18,
+        "2014-11-04": 46,
+        "2014-11-05": 19,
+        "2014-11-06": 30,
+        "2014-11-07": 21,
+        "2014-11-08": 7,
+        "2014-11-09": 0,
+        "2014-11-10": 17,
+        "2014-11-11": 50,
+        "2014-11-12": 5,
+        "2014-11-13": 9,
+        "2014-11-14": 7,
+        "2014-11-15": 11,
+        "2014-11-16": 22,
+        "2014-11-17": 14,
+        "2014-11-18": 28,
+        "2014-11-19": 25,
+        "2014-11-20": 28,
+        "2014-11-21": 13,
+        "2014-11-22": 0,
+        "2014-11-23": 9,
+        "2014-11-24": 38,
+        "2014-11-25": 20,
+        "2014-11-26": 26,
+        "2014-11-27": 1,
+        "2014-11-28": 16,
+        "2014-11-29": 0,
+        "2014-11-30": 13,
+        "2014-12-01": 18,
+        "2014-12-02": 26,
+        "2014-12-03": 23,
+        "2014-12-04": 7,
+        "2014-12-05": 30,
+        "2014-12-06": 8,
+        "2014-12-07": 6,
+        "2014-12-08": 34,
+        "2014-12-09": 18,
+        "2014-12-10": 69,
+        "2014-12-11": 50,
+        "2014-12-12": 31,
+        "2014-12-13": 2,
+        "2014-12-14": 0,
+        "2014-12-15": 27,
+        "2014-12-16": 22,
+        "2014-12-17": 18,
+        "2014-12-18": 23,
+        "2014-12-19": 48,
+        "2014-12-20": 9,
+        "2014-12-21": 0,
+        "2014-12-22": 10,
+        "2014-12-23": 13,
+        "2014-12-24": 31,
+        "2014-12-25": 5,
+        "2014-12-26": 19,
+        "2014-12-27": 13,
+        "2014-12-28": 13,
+        "2014-12-29": 10,
+        "2014-12-30": 4,
+        "2014-12-31": 27
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 7928,
+      "severity_distribution": {
+        "UNKNOWN": 7928
+      },
+      "score_distribution": {
+        "2.1": 182,
+        "7.5": 727,
+        "9.3": 406,
+        "4.9": 113,
+        "4.4": 41,
+        "5.8": 144,
+        "4.0": 294,
+        "4.7": 25,
+        "4.3": 1224,
+        "6.4": 93,
+        "1.9": 43,
+        "6.2": 13,
+        "5.0": 881,
+        "6.0": 55,
+        "3.3": 46,
+        "6.8": 557,
+        "7.8": 141,
+        "3.5": 272,
+        "5.5": 51,
+        "7.7": 3,
+        "6.1": 20,
+        "4.6": 74,
+        "3.6": 23,
+        "5.7": 6,
+        "2.6": 37,
+        "6.5": 202,
+        "6.9": 58,
+        "6.3": 20,
+        "5.4": 1416,
+        "10.0": 338,
+        "3.7": 5,
+        "8.5": 33,
+        "7.4": 3,
+        "7.2": 94,
+        "1.8": 4,
+        "4.8": 4,
+        "2.8": 6,
+        "5.1": 16,
+        "7.1": 75,
+        "1.7": 5,
+        "2.7": 7,
+        "3.2": 4,
+        "5.2": 8,
+        "1.2": 4,
+        "8.3": 18,
+        "9.0": 56,
+        "9.4": 4,
+        "8.8": 1,
+        "4.1": 8,
+        "7.6": 22,
+        "3.8": 1,
+        "2.9": 9,
+        "7.9": 6,
+        "2.4": 5,
+        "6.6": 7,
+        "5.6": 1,
+        "2.3": 4,
+        "3.0": 2,
+        "7.0": 1,
+        "6.7": 1,
+        "9.7": 2,
+        "8.0": 1,
+        "8.2": 2,
+        "1.4": 1,
+        "1.0": 2,
+        "1.5": 1
+      }
+    },
+    "v3.0": {
+      "total": 10,
+      "severity_distribution": {
+        "CRITICAL": 1,
+        "MEDIUM": 4,
+        "HIGH": 4,
+        "LOW": 1
+      },
+      "score_distribution": {
+        "9.8": 1,
+        "4.9": 1,
+        "5.6": 1,
+        "5.5": 1,
+        "7.8": 3,
+        "3.3": 1,
+        "8.1": 1,
+        "6.1": 1
+      }
+    },
+    "v3.1": {
+      "total": 113,
+      "severity_distribution": {
+        "HIGH": 52,
+        "MEDIUM": 40,
+        "CRITICAL": 19,
+        "LOW": 2
+      },
+      "score_distribution": {
+        "7.2": 1,
+        "6.1": 5,
+        "5.5": 13,
+        "6.5": 11,
+        "5.4": 2,
+        "4.9": 1,
+        "8.1": 2,
+        "9.8": 17,
+        "8.4": 1,
+        "8.8": 21,
+        "9.1": 2,
+        "7.3": 3,
+        "7.5": 9,
+        "4.6": 1,
+        "7.4": 2,
+        "5.9": 1,
+        "4.2": 1,
+        "7.8": 12,
+        "7.1": 1,
+        "6.8": 1,
+        "4.0": 1,
+        "5.3": 1,
+        "4.7": 2,
+        "3.4": 1,
+        "3.3": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 717,
+      "epss_gt_0_5": 135,
+      "epss_gt_0_9": 21
+    }
+  },
+  "kev": {
+    "kev_count": 34
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 524
+      },
+      {
+        "name": "Oracle",
+        "count": 508
+      },
+      {
+        "name": "Ibm",
+        "count": 465
+      },
+      {
+        "name": "Apple",
+        "count": 434
+      },
+      {
+        "name": "Cisco",
+        "count": 368
+      },
+      {
+        "name": "Redhat",
+        "count": 300
+      },
+      {
+        "name": "Canonical",
+        "count": 256
+      },
+      {
+        "name": "Debian",
+        "count": 248
+      },
+      {
+        "name": "Linux",
+        "count": 234
+      },
+      {
+        "name": "Opensuse",
+        "count": 225
+      },
+      {
+        "name": "Google",
+        "count": 199
+      },
+      {
+        "name": "Adobe",
+        "count": 141
+      },
+      {
+        "name": "Suse",
+        "count": 135
+      },
+      {
+        "name": "Mozilla",
+        "count": 122
+      },
+      {
+        "name": "Hp",
+        "count": 104
+      },
+      {
+        "name": "Fedoraproject",
+        "count": 97
+      },
+      {
+        "name": "Apache",
+        "count": 92
+      },
+      {
+        "name": "Sap",
+        "count": 83
+      },
+      {
+        "name": "Owncloud",
+        "count": 58
+      },
+      {
+        "name": "Wordpress",
+        "count": 56
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-310",
+        "count": 1580
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 1035
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 746
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 679
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 546
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 358
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 299
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 248
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 227
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 205
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 190
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 148
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 113
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 101
+      },
+      {
+        "cwe": "CWE-59",
+        "count": 60
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 51
+      },
+      {
+        "cwe": "CWE-362",
+        "count": 43
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 33
+      },
+      {
+        "cwe": "CWE-284",
+        "count": 22
+      },
+      {
+        "cwe": "CWE-17",
+        "count": 21
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 7894
+      },
+      {
+        "status": "Analyzed",
+        "count": 34
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Third Party Advisory",
+        "count": 13166
+      },
+      {
+        "tag": "Vendor Advisory",
+        "count": 10147
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 6334
+      },
+      {
+        "tag": "Exploit",
+        "count": 5479
+      },
+      {
+        "tag": "Patch",
+        "count": 4053
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 2620
+      },
+      {
+        "tag": "Mailing List",
+        "count": 2300
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1589
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 963
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 690
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 246
+      },
+      {
+        "tag": "Release Notes",
+        "count": 108
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 34
+      },
+      {
+        "tag": "Mitigation",
+        "count": 18
+      },
+      {
+        "tag": "Technical Description",
+        "count": 18
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 8
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 4
+      },
+      {
+        "tag": "Product",
+        "count": 2
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:44.360246",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2015.json b/web/data/cve_2015.json
new file mode 100644
index 00000000000..f48a69224f6
--- /dev/null
+++ b/web/data/cve_2015.json
@@ -0,0 +1,814 @@
+{
+  "year": 2015,
+  "total_cves": 6494,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 713,
+      "2": 486,
+      "3": 453,
+      "4": 538,
+      "5": 410,
+      "6": 495,
+      "7": 635,
+      "8": 619,
+      "9": 493,
+      "10": 726,
+      "11": 361,
+      "12": 565
+    },
+    "daily_analysis": {
+      "total_days": 313,
+      "avg_per_day": 20.75,
+      "highest_day": {
+        "date": "2015-07-16",
+        "count": 172
+      },
+      "lowest_day": {
+        "date": "2015-02-22",
+        "count": 1
+      },
+      "daily_counts": {
+        "2015-01-01": 34,
+        "2015-01-02": 33,
+        "2015-01-03": 9,
+        "2015-01-04": 7,
+        "2015-01-05": 17,
+        "2015-01-06": 6,
+        "2015-01-07": 13,
+        "2015-01-08": 16,
+        "2015-01-09": 29,
+        "2015-01-10": 17,
+        "2015-01-11": 0,
+        "2015-01-12": 6,
+        "2015-01-13": 94,
+        "2015-01-14": 18,
+        "2015-01-15": 38,
+        "2015-01-16": 35,
+        "2015-01-17": 14,
+        "2015-01-18": 3,
+        "2015-01-19": 0,
+        "2015-01-20": 9,
+        "2015-01-21": 164,
+        "2015-01-22": 36,
+        "2015-01-23": 11,
+        "2015-01-24": 0,
+        "2015-01-25": 0,
+        "2015-01-26": 10,
+        "2015-01-27": 28,
+        "2015-01-28": 9,
+        "2015-01-29": 10,
+        "2015-01-30": 47,
+        "2015-01-31": 0,
+        "2015-02-01": 15,
+        "2015-02-02": 27,
+        "2015-02-03": 36,
+        "2015-02-04": 22,
+        "2015-02-05": 0,
+        "2015-02-06": 39,
+        "2015-02-07": 11,
+        "2015-02-08": 20,
+        "2015-02-09": 8,
+        "2015-02-10": 12,
+        "2015-02-11": 65,
+        "2015-02-12": 18,
+        "2015-02-13": 20,
+        "2015-02-14": 8,
+        "2015-02-15": 3,
+        "2015-02-16": 20,
+        "2015-02-17": 13,
+        "2015-02-18": 8,
+        "2015-02-19": 32,
+        "2015-02-20": 18,
+        "2015-02-21": 4,
+        "2015-02-22": 1,
+        "2015-02-23": 13,
+        "2015-02-24": 22,
+        "2015-02-25": 23,
+        "2015-02-26": 6,
+        "2015-02-27": 13,
+        "2015-02-28": 9,
+        "2015-03-01": 0,
+        "2015-03-02": 5,
+        "2015-03-03": 10,
+        "2015-03-04": 5,
+        "2015-03-05": 9,
+        "2015-03-06": 11,
+        "2015-03-07": 10,
+        "2015-03-08": 7,
+        "2015-03-09": 52,
+        "2015-03-10": 8,
+        "2015-03-11": 48,
+        "2015-03-12": 20,
+        "2015-03-13": 25,
+        "2015-03-14": 12,
+        "2015-03-15": 1,
+        "2015-03-16": 10,
+        "2015-03-17": 7,
+        "2015-03-18": 37,
+        "2015-03-19": 18,
+        "2015-03-20": 8,
+        "2015-03-21": 3,
+        "2015-03-22": 1,
+        "2015-03-23": 8,
+        "2015-03-24": 22,
+        "2015-03-25": 12,
+        "2015-03-26": 24,
+        "2015-03-27": 22,
+        "2015-03-28": 3,
+        "2015-03-29": 12,
+        "2015-03-30": 23,
+        "2015-03-31": 20,
+        "2015-04-01": 40,
+        "2015-04-02": 0,
+        "2015-04-03": 30,
+        "2015-04-04": 2,
+        "2015-04-05": 6,
+        "2015-04-06": 15,
+        "2015-04-07": 2,
+        "2015-04-08": 22,
+        "2015-04-09": 0,
+        "2015-04-10": 79,
+        "2015-04-11": 3,
+        "2015-04-12": 0,
+        "2015-04-13": 19,
+        "2015-04-14": 64,
+        "2015-04-15": 10,
+        "2015-04-16": 92,
+        "2015-04-17": 10,
+        "2015-04-18": 4,
+        "2015-04-19": 17,
+        "2015-04-20": 0,
+        "2015-04-21": 64,
+        "2015-04-22": 6,
+        "2015-04-23": 2,
+        "2015-04-24": 17,
+        "2015-04-25": 0,
+        "2015-04-26": 0,
+        "2015-04-27": 14,
+        "2015-04-28": 5,
+        "2015-04-29": 15,
+        "2015-04-30": 0,
+        "2015-05-01": 18,
+        "2015-05-02": 1,
+        "2015-05-03": 0,
+        "2015-05-04": 0,
+        "2015-05-05": 0,
+        "2015-05-06": 0,
+        "2015-05-07": 6,
+        "2015-05-08": 13,
+        "2015-05-09": 0,
+        "2015-05-10": 0,
+        "2015-05-11": 0,
+        "2015-05-12": 28,
+        "2015-05-13": 95,
+        "2015-05-14": 29,
+        "2015-05-15": 9,
+        "2015-05-16": 7,
+        "2015-05-17": 3,
+        "2015-05-18": 13,
+        "2015-05-19": 9,
+        "2015-05-20": 35,
+        "2015-05-21": 9,
+        "2015-05-22": 3,
+        "2015-05-23": 1,
+        "2015-05-24": 0,
+        "2015-05-25": 43,
+        "2015-05-26": 16,
+        "2015-05-27": 15,
+        "2015-05-28": 13,
+        "2015-05-29": 24,
+        "2015-05-30": 15,
+        "2015-05-31": 5,
+        "2015-06-01": 25,
+        "2015-06-02": 19,
+        "2015-06-03": 8,
+        "2015-06-04": 7,
+        "2015-06-05": 7,
+        "2015-06-06": 0,
+        "2015-06-07": 16,
+        "2015-06-08": 14,
+        "2015-06-09": 26,
+        "2015-06-10": 70,
+        "2015-06-11": 7,
+        "2015-06-12": 16,
+        "2015-06-13": 22,
+        "2015-06-14": 0,
+        "2015-06-15": 67,
+        "2015-06-16": 15,
+        "2015-06-17": 19,
+        "2015-06-18": 16,
+        "2015-06-19": 11,
+        "2015-06-20": 4,
+        "2015-06-21": 0,
+        "2015-06-22": 10,
+        "2015-06-23": 16,
+        "2015-06-24": 27,
+        "2015-06-25": 3,
+        "2015-06-26": 11,
+        "2015-06-27": 2,
+        "2015-06-28": 25,
+        "2015-06-29": 3,
+        "2015-06-30": 29,
+        "2015-07-01": 17,
+        "2015-07-02": 9,
+        "2015-07-03": 75,
+        "2015-07-04": 7,
+        "2015-07-05": 5,
+        "2015-07-06": 39,
+        "2015-07-07": 3,
+        "2015-07-08": 22,
+        "2015-07-09": 36,
+        "2015-07-10": 18,
+        "2015-07-11": 0,
+        "2015-07-12": 0,
+        "2015-07-13": 1,
+        "2015-07-14": 88,
+        "2015-07-15": 48,
+        "2015-07-16": 172,
+        "2015-07-17": 0,
+        "2015-07-18": 5,
+        "2015-07-19": 2,
+        "2015-07-20": 22,
+        "2015-07-21": 8,
+        "2015-07-22": 6,
+        "2015-07-23": 23,
+        "2015-07-24": 4,
+        "2015-07-25": 1,
+        "2015-07-26": 10,
+        "2015-07-27": 1,
+        "2015-07-28": 0,
+        "2015-07-29": 10,
+        "2015-07-30": 3,
+        "2015-07-31": 0,
+        "2015-08-01": 18,
+        "2015-08-02": 0,
+        "2015-08-03": 18,
+        "2015-08-04": 32,
+        "2015-08-05": 3,
+        "2015-08-06": 1,
+        "2015-08-07": 1,
+        "2015-08-08": 10,
+        "2015-08-09": 0,
+        "2015-08-10": 0,
+        "2015-08-11": 13,
+        "2015-08-12": 20,
+        "2015-08-13": 8,
+        "2015-08-14": 55,
+        "2015-08-15": 40,
+        "2015-08-16": 81,
+        "2015-08-17": 55,
+        "2015-08-18": 50,
+        "2015-08-19": 19,
+        "2015-08-20": 29,
+        "2015-08-21": 0,
+        "2015-08-22": 15,
+        "2015-08-23": 14,
+        "2015-08-24": 45,
+        "2015-08-25": 8,
+        "2015-08-26": 12,
+        "2015-08-27": 16,
+        "2015-08-28": 4,
+        "2015-08-29": 5,
+        "2015-08-30": 3,
+        "2015-08-31": 44,
+        "2015-09-01": 14,
+        "2015-09-02": 6,
+        "2015-09-03": 26,
+        "2015-09-04": 12,
+        "2015-09-05": 7,
+        "2015-09-06": 9,
+        "2015-09-07": 3,
+        "2015-09-08": 7,
+        "2015-09-09": 54,
+        "2015-09-10": 0,
+        "2015-09-11": 23,
+        "2015-09-12": 0,
+        "2015-09-13": 0,
+        "2015-09-14": 13,
+        "2015-09-15": 8,
+        "2015-09-16": 18,
+        "2015-09-17": 15,
+        "2015-09-18": 113,
+        "2015-09-19": 0,
+        "2015-09-20": 26,
+        "2015-09-21": 19,
+        "2015-09-22": 26,
+        "2015-09-23": 0,
+        "2015-09-24": 30,
+        "2015-09-25": 2,
+        "2015-09-26": 15,
+        "2015-09-27": 0,
+        "2015-09-28": 31,
+        "2015-09-29": 14,
+        "2015-09-30": 2,
+        "2015-10-01": 36,
+        "2015-10-02": 7,
+        "2015-10-03": 10,
+        "2015-10-04": 15,
+        "2015-10-05": 9,
+        "2015-10-06": 57,
+        "2015-10-07": 0,
+        "2015-10-08": 3,
+        "2015-10-09": 49,
+        "2015-10-10": 0,
+        "2015-10-11": 4,
+        "2015-10-12": 16,
+        "2015-10-13": 3,
+        "2015-10-14": 98,
+        "2015-10-15": 33,
+        "2015-10-16": 21,
+        "2015-10-17": 0,
+        "2015-10-18": 23,
+        "2015-10-19": 18,
+        "2015-10-20": 0,
+        "2015-10-21": 119,
+        "2015-10-22": 17,
+        "2015-10-23": 71,
+        "2015-10-24": 0,
+        "2015-10-25": 11,
+        "2015-10-26": 24,
+        "2015-10-27": 9,
+        "2015-10-28": 26,
+        "2015-10-29": 22,
+        "2015-10-30": 19,
+        "2015-10-31": 6,
+        "2015-11-01": 0,
+        "2015-11-02": 14,
+        "2015-11-03": 10,
+        "2015-11-04": 13,
+        "2015-11-05": 23,
+        "2015-11-06": 22,
+        "2015-11-07": 2,
+        "2015-11-08": 19,
+        "2015-11-09": 24,
+        "2015-11-10": 14,
+        "2015-11-11": 67,
+        "2015-11-12": 9,
+        "2015-11-13": 6,
+        "2015-11-14": 8,
+        "2015-11-15": 2,
+        "2015-11-16": 13,
+        "2015-11-17": 21,
+        "2015-11-18": 17,
+        "2015-11-19": 15,
+        "2015-11-20": 3,
+        "2015-11-21": 9,
+        "2015-11-22": 3,
+        "2015-11-23": 3,
+        "2015-11-24": 18,
+        "2015-11-25": 19,
+        "2015-11-26": 5,
+        "2015-11-27": 2,
+        "2015-11-28": 0,
+        "2015-11-29": 0,
+        "2015-11-30": 0,
+        "2015-12-01": 2,
+        "2015-12-02": 19,
+        "2015-12-03": 8,
+        "2015-12-04": 0,
+        "2015-12-05": 6,
+        "2015-12-06": 32,
+        "2015-12-07": 17,
+        "2015-12-08": 22,
+        "2015-12-09": 58,
+        "2015-12-10": 79,
+        "2015-12-11": 72,
+        "2015-12-12": 5,
+        "2015-12-13": 9,
+        "2015-12-14": 11,
+        "2015-12-15": 23,
+        "2015-12-16": 38,
+        "2015-12-17": 15,
+        "2015-12-18": 5,
+        "2015-12-19": 3,
+        "2015-12-20": 0,
+        "2015-12-21": 16,
+        "2015-12-22": 1,
+        "2015-12-23": 13,
+        "2015-12-24": 10,
+        "2015-12-25": 0,
+        "2015-12-26": 2,
+        "2015-12-27": 11,
+        "2015-12-28": 30,
+        "2015-12-29": 9,
+        "2015-12-30": 16,
+        "2015-12-31": 33
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 6494,
+      "severity_distribution": {
+        "UNKNOWN": 6494
+      },
+      "score_distribution": {
+        "10.0": 611,
+        "4.3": 982,
+        "6.8": 741,
+        "7.5": 651,
+        "9.3": 468,
+        "6.4": 82,
+        "5.0": 827,
+        "5.8": 92,
+        "8.8": 4,
+        "6.5": 166,
+        "7.2": 259,
+        "3.5": 255,
+        "6.3": 7,
+        "4.6": 55,
+        "2.1": 182,
+        "3.3": 27,
+        "7.8": 163,
+        "5.1": 12,
+        "3.7": 5,
+        "5.4": 9,
+        "2.6": 37,
+        "4.0": 257,
+        "5.5": 37,
+        "6.9": 94,
+        "9.0": 76,
+        "4.9": 76,
+        "1.9": 37,
+        "7.1": 50,
+        "6.1": 27,
+        "6.6": 11,
+        "8.5": 29,
+        "3.2": 6,
+        "7.6": 9,
+        "6.0": 31,
+        "4.7": 12,
+        "8.3": 11,
+        "3.6": 17,
+        "4.4": 16,
+        "1.2": 4,
+        "9.4": 6,
+        "7.7": 4,
+        "5.7": 5,
+        "1.8": 2,
+        "5.6": 3,
+        "7.9": 5,
+        "7.0": 2,
+        "1.5": 6,
+        "1.7": 4,
+        "2.8": 3,
+        "2.7": 1,
+        "2.9": 2,
+        "8.7": 1,
+        "6.2": 3,
+        "4.8": 3,
+        "3.8": 1,
+        "8.0": 1,
+        "1.3": 1,
+        "7.3": 1,
+        "4.1": 1,
+        "9.7": 1,
+        "7.4": 1,
+        "2.3": 1,
+        "5.9": 1
+      }
+    },
+    "v3.0": {
+      "total": 139,
+      "severity_distribution": {
+        "MEDIUM": 47,
+        "HIGH": 64,
+        "LOW": 6,
+        "CRITICAL": 22
+      },
+      "score_distribution": {
+        "5.3": 9,
+        "7.5": 11,
+        "3.7": 3,
+        "6.5": 5,
+        "9.8": 16,
+        "7.8": 1,
+        "7.3": 6,
+        "6.1": 10,
+        "4.3": 6,
+        "8.3": 4,
+        "8.6": 5,
+        "10.0": 4,
+        "8.0": 4,
+        "6.8": 3,
+        "6.7": 1,
+        "9.1": 1,
+        "7.2": 1,
+        "8.8": 25,
+        "9.9": 1,
+        "8.5": 2,
+        "8.7": 1,
+        "5.9": 4,
+        "6.9": 1,
+        "4.4": 1,
+        "2.3": 3,
+        "5.8": 4,
+        "4.0": 1,
+        "8.4": 1,
+        "6.3": 1,
+        "7.4": 2,
+        "4.9": 1,
+        "8.1": 1
+      }
+    },
+    "v3.1": {
+      "total": 96,
+      "severity_distribution": {
+        "MEDIUM": 13,
+        "HIGH": 53,
+        "CRITICAL": 28,
+        "LOW": 2
+      },
+      "score_distribution": {
+        "5.4": 2,
+        "8.8": 13,
+        "8.0": 1,
+        "9.8": 25,
+        "7.8": 13,
+        "6.5": 1,
+        "7.5": 18,
+        "3.7": 2,
+        "7.3": 2,
+        "9.1": 1,
+        "4.8": 1,
+        "6.0": 1,
+        "8.1": 1,
+        "5.1": 1,
+        "6.6": 1,
+        "6.4": 1,
+        "7.0": 2,
+        "8.2": 1,
+        "10.0": 2,
+        "6.1": 1,
+        "5.3": 3,
+        "7.4": 1,
+        "6.7": 1,
+        "7.2": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 839,
+      "epss_gt_0_5": 135,
+      "epss_gt_0_9": 25
+    }
+  },
+  "kev": {
+    "kev_count": 45
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Apple",
+        "count": 1159
+      },
+      {
+        "name": "Microsoft",
+        "count": 1035
+      },
+      {
+        "name": "Oracle",
+        "count": 622
+      },
+      {
+        "name": "Cisco",
+        "count": 490
+      },
+      {
+        "name": "Adobe",
+        "count": 483
+      },
+      {
+        "name": "Google",
+        "count": 471
+      },
+      {
+        "name": "Linux",
+        "count": 431
+      },
+      {
+        "name": "Canonical",
+        "count": 349
+      },
+      {
+        "name": "Opensuse",
+        "count": 333
+      },
+      {
+        "name": "Debian",
+        "count": 322
+      },
+      {
+        "name": "Ibm",
+        "count": 320
+      },
+      {
+        "name": "Redhat",
+        "count": 283
+      },
+      {
+        "name": "Mozilla",
+        "count": 189
+      },
+      {
+        "name": "Fedoraproject",
+        "count": 172
+      },
+      {
+        "name": "Hp",
+        "count": 111
+      },
+      {
+        "name": "Suse",
+        "count": 86
+      },
+      {
+        "name": "Emc",
+        "count": 69
+      },
+      {
+        "name": "Sap",
+        "count": 62
+      },
+      {
+        "name": "Apache",
+        "count": 57
+      },
+      {
+        "name": "Novell",
+        "count": 46
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-119",
+        "count": 966
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 727
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 596
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 535
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 382
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 352
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 242
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 213
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 145
+      },
+      {
+        "cwe": "CWE-284",
+        "count": 144
+      },
+      {
+        "cwe": "CWE-17",
+        "count": 120
+      },
+      {
+        "cwe": "CWE-189",
+        "count": 115
+      },
+      {
+        "cwe": "CWE-254",
+        "count": 95
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 84
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 76
+      },
+      {
+        "cwe": "CWE-19",
+        "count": 60
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 51
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 49
+      },
+      {
+        "cwe": "CWE-362",
+        "count": 48
+      },
+      {
+        "cwe": "CWE-77",
+        "count": 40
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 6447
+      },
+      {
+        "status": "Analyzed",
+        "count": 47
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 14201
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 11817
+      },
+      {
+        "tag": "Patch",
+        "count": 4648
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 4114
+      },
+      {
+        "tag": "Exploit",
+        "count": 3637
+      },
+      {
+        "tag": "Mailing List",
+        "count": 1814
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 803
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 578
+      },
+      {
+        "tag": "Broken Link",
+        "count": 528
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 94
+      },
+      {
+        "tag": "Release Notes",
+        "count": 86
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 66
+      },
+      {
+        "tag": "Product",
+        "count": 24
+      },
+      {
+        "tag": "Mitigation",
+        "count": 18
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 14
+      },
+      {
+        "tag": "Technical Description",
+        "count": 14
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 12
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:44.520079",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2016.json b/web/data/cve_2016.json
new file mode 100644
index 00000000000..045074cae26
--- /dev/null
+++ b/web/data/cve_2016.json
@@ -0,0 +1,871 @@
+{
+  "year": 2016,
+  "total_cves": 6449,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 669,
+      "2": 380,
+      "3": 330,
+      "4": 653,
+      "5": 612,
+      "6": 510,
+      "7": 709,
+      "8": 409,
+      "9": 595,
+      "10": 679,
+      "11": 386,
+      "12": 517
+    },
+    "daily_analysis": {
+      "total_days": 288,
+      "avg_per_day": 22.39,
+      "highest_day": {
+        "date": "2016-01-21",
+        "count": 216
+      },
+      "lowest_day": {
+        "date": "2016-01-28",
+        "count": 1
+      },
+      "daily_counts": {
+        "2016-01-01": 12,
+        "2016-01-02": 27,
+        "2016-01-03": 16,
+        "2016-01-04": 33,
+        "2016-01-05": 10,
+        "2016-01-06": 13,
+        "2016-01-07": 0,
+        "2016-01-08": 47,
+        "2016-01-09": 16,
+        "2016-01-10": 5,
+        "2016-01-11": 10,
+        "2016-01-12": 24,
+        "2016-01-13": 28,
+        "2016-01-14": 20,
+        "2016-01-15": 40,
+        "2016-01-16": 7,
+        "2016-01-17": 7,
+        "2016-01-18": 8,
+        "2016-01-19": 11,
+        "2016-01-20": 13,
+        "2016-01-21": 216,
+        "2016-01-22": 15,
+        "2016-01-23": 2,
+        "2016-01-24": 0,
+        "2016-01-25": 11,
+        "2016-01-26": 12,
+        "2016-01-27": 15,
+        "2016-01-28": 1,
+        "2016-01-29": 19,
+        "2016-01-30": 15,
+        "2016-01-31": 16,
+        "2016-02-01": 21,
+        "2016-02-02": 0,
+        "2016-02-03": 12,
+        "2016-02-04": 2,
+        "2016-02-05": 2,
+        "2016-02-06": 6,
+        "2016-02-07": 20,
+        "2016-02-08": 27,
+        "2016-02-09": 4,
+        "2016-02-10": 71,
+        "2016-02-11": 1,
+        "2016-02-12": 14,
+        "2016-02-13": 14,
+        "2016-02-14": 6,
+        "2016-02-15": 30,
+        "2016-02-16": 13,
+        "2016-02-17": 27,
+        "2016-02-18": 14,
+        "2016-02-19": 6,
+        "2016-02-20": 9,
+        "2016-02-21": 4,
+        "2016-02-22": 27,
+        "2016-02-23": 6,
+        "2016-02-24": 3,
+        "2016-02-25": 7,
+        "2016-02-26": 2,
+        "2016-02-27": 8,
+        "2016-02-28": 12,
+        "2016-02-29": 12,
+        "2016-03-01": 6,
+        "2016-03-02": 4,
+        "2016-03-03": 19,
+        "2016-03-04": 14,
+        "2016-03-05": 0,
+        "2016-03-06": 16,
+        "2016-03-07": 0,
+        "2016-03-08": 0,
+        "2016-03-09": 53,
+        "2016-03-10": 0,
+        "2016-03-11": 0,
+        "2016-03-12": 49,
+        "2016-03-13": 47,
+        "2016-03-14": 5,
+        "2016-03-15": 2,
+        "2016-03-16": 5,
+        "2016-03-17": 4,
+        "2016-03-18": 11,
+        "2016-03-19": 4,
+        "2016-03-20": 0,
+        "2016-03-21": 1,
+        "2016-03-22": 4,
+        "2016-03-23": 0,
+        "2016-03-24": 62,
+        "2016-03-25": 1,
+        "2016-03-26": 7,
+        "2016-03-27": 0,
+        "2016-03-28": 4,
+        "2016-03-29": 8,
+        "2016-03-30": 2,
+        "2016-03-31": 2,
+        "2016-04-01": 6,
+        "2016-04-02": 0,
+        "2016-04-03": 0,
+        "2016-04-04": 0,
+        "2016-04-05": 12,
+        "2016-04-06": 22,
+        "2016-04-07": 36,
+        "2016-04-08": 21,
+        "2016-04-09": 23,
+        "2016-04-10": 0,
+        "2016-04-11": 40,
+        "2016-04-12": 85,
+        "2016-04-13": 54,
+        "2016-04-14": 21,
+        "2016-04-15": 19,
+        "2016-04-16": 2,
+        "2016-04-17": 0,
+        "2016-04-18": 55,
+        "2016-04-19": 14,
+        "2016-04-20": 10,
+        "2016-04-21": 118,
+        "2016-04-22": 29,
+        "2016-04-23": 0,
+        "2016-04-24": 0,
+        "2016-04-25": 29,
+        "2016-04-26": 5,
+        "2016-04-27": 28,
+        "2016-04-28": 5,
+        "2016-04-29": 0,
+        "2016-04-30": 19,
+        "2016-05-01": 8,
+        "2016-05-02": 36,
+        "2016-05-03": 4,
+        "2016-05-04": 0,
+        "2016-05-05": 25,
+        "2016-05-06": 7,
+        "2016-05-07": 18,
+        "2016-05-08": 0,
+        "2016-05-09": 41,
+        "2016-05-10": 5,
+        "2016-05-11": 156,
+        "2016-05-12": 5,
+        "2016-05-13": 25,
+        "2016-05-14": 25,
+        "2016-05-15": 3,
+        "2016-05-16": 27,
+        "2016-05-17": 13,
+        "2016-05-18": 4,
+        "2016-05-19": 1,
+        "2016-05-20": 84,
+        "2016-05-21": 2,
+        "2016-05-22": 40,
+        "2016-05-23": 28,
+        "2016-05-24": 1,
+        "2016-05-25": 13,
+        "2016-05-26": 14,
+        "2016-05-27": 0,
+        "2016-05-28": 3,
+        "2016-05-29": 2,
+        "2016-05-30": 7,
+        "2016-05-31": 15,
+        "2016-06-01": 17,
+        "2016-06-02": 0,
+        "2016-06-03": 8,
+        "2016-06-04": 9,
+        "2016-06-05": 36,
+        "2016-06-06": 1,
+        "2016-06-07": 21,
+        "2016-06-08": 40,
+        "2016-06-09": 12,
+        "2016-06-10": 22,
+        "2016-06-11": 0,
+        "2016-06-12": 0,
+        "2016-06-13": 74,
+        "2016-06-14": 6,
+        "2016-06-15": 0,
+        "2016-06-16": 94,
+        "2016-06-17": 6,
+        "2016-06-18": 3,
+        "2016-06-19": 37,
+        "2016-06-20": 7,
+        "2016-06-21": 0,
+        "2016-06-22": 0,
+        "2016-06-23": 9,
+        "2016-06-24": 6,
+        "2016-06-25": 14,
+        "2016-06-26": 11,
+        "2016-06-27": 14,
+        "2016-06-28": 3,
+        "2016-06-29": 18,
+        "2016-06-30": 42,
+        "2016-07-01": 5,
+        "2016-07-02": 21,
+        "2016-07-03": 46,
+        "2016-07-04": 12,
+        "2016-07-05": 8,
+        "2016-07-06": 6,
+        "2016-07-07": 7,
+        "2016-07-08": 12,
+        "2016-07-09": 0,
+        "2016-07-10": 0,
+        "2016-07-11": 100,
+        "2016-07-12": 17,
+        "2016-07-13": 131,
+        "2016-07-14": 0,
+        "2016-07-15": 27,
+        "2016-07-16": 0,
+        "2016-07-17": 5,
+        "2016-07-18": 0,
+        "2016-07-19": 10,
+        "2016-07-20": 0,
+        "2016-07-21": 192,
+        "2016-07-22": 68,
+        "2016-07-23": 18,
+        "2016-07-24": 0,
+        "2016-07-25": 10,
+        "2016-07-26": 4,
+        "2016-07-27": 0,
+        "2016-07-28": 10,
+        "2016-07-29": 0,
+        "2016-07-30": 0,
+        "2016-07-31": 0,
+        "2016-08-01": 14,
+        "2016-08-02": 14,
+        "2016-08-03": 9,
+        "2016-08-04": 0,
+        "2016-08-05": 84,
+        "2016-08-06": 73,
+        "2016-08-07": 50,
+        "2016-08-08": 27,
+        "2016-08-09": 32,
+        "2016-08-10": 6,
+        "2016-08-11": 0,
+        "2016-08-12": 4,
+        "2016-08-13": 3,
+        "2016-08-14": 0,
+        "2016-08-15": 0,
+        "2016-08-16": 0,
+        "2016-08-17": 0,
+        "2016-08-18": 6,
+        "2016-08-19": 17,
+        "2016-08-20": 0,
+        "2016-08-21": 0,
+        "2016-08-22": 11,
+        "2016-08-23": 5,
+        "2016-08-24": 7,
+        "2016-08-25": 8,
+        "2016-08-26": 19,
+        "2016-08-27": 0,
+        "2016-08-28": 0,
+        "2016-08-29": 1,
+        "2016-08-30": 6,
+        "2016-08-31": 13,
+        "2016-09-01": 16,
+        "2016-09-02": 19,
+        "2016-09-03": 8,
+        "2016-09-04": 0,
+        "2016-09-05": 0,
+        "2016-09-06": 5,
+        "2016-09-07": 37,
+        "2016-09-08": 4,
+        "2016-09-09": 14,
+        "2016-09-10": 0,
+        "2016-09-11": 61,
+        "2016-09-12": 24,
+        "2016-09-13": 0,
+        "2016-09-14": 76,
+        "2016-09-15": 0,
+        "2016-09-16": 15,
+        "2016-09-17": 16,
+        "2016-09-18": 28,
+        "2016-09-19": 9,
+        "2016-09-20": 22,
+        "2016-09-21": 43,
+        "2016-09-22": 30,
+        "2016-09-23": 0,
+        "2016-09-24": 11,
+        "2016-09-25": 77,
+        "2016-09-26": 57,
+        "2016-09-27": 9,
+        "2016-09-28": 3,
+        "2016-09-29": 6,
+        "2016-09-30": 5,
+        "2016-10-01": 3,
+        "2016-10-02": 0,
+        "2016-10-03": 45,
+        "2016-10-04": 0,
+        "2016-10-05": 52,
+        "2016-10-06": 42,
+        "2016-10-07": 13,
+        "2016-10-08": 0,
+        "2016-10-09": 0,
+        "2016-10-10": 108,
+        "2016-10-11": 0,
+        "2016-10-12": 0,
+        "2016-10-13": 99,
+        "2016-10-14": 38,
+        "2016-10-15": 0,
+        "2016-10-16": 14,
+        "2016-10-17": 0,
+        "2016-10-18": 0,
+        "2016-10-19": 0,
+        "2016-10-20": 0,
+        "2016-10-21": 10,
+        "2016-10-22": 9,
+        "2016-10-23": 0,
+        "2016-10-24": 0,
+        "2016-10-25": 162,
+        "2016-10-26": 6,
+        "2016-10-27": 18,
+        "2016-10-28": 35,
+        "2016-10-29": 6,
+        "2016-10-30": 6,
+        "2016-10-31": 13,
+        "2016-11-01": 1,
+        "2016-11-02": 1,
+        "2016-11-03": 22,
+        "2016-11-04": 21,
+        "2016-11-05": 0,
+        "2016-11-06": 0,
+        "2016-11-07": 2,
+        "2016-11-08": 35,
+        "2016-11-09": 0,
+        "2016-11-10": 75,
+        "2016-11-11": 9,
+        "2016-11-12": 2,
+        "2016-11-13": 0,
+        "2016-11-14": 7,
+        "2016-11-15": 5,
+        "2016-11-16": 13,
+        "2016-11-17": 5,
+        "2016-11-18": 6,
+        "2016-11-19": 13,
+        "2016-11-20": 0,
+        "2016-11-21": 0,
+        "2016-11-22": 10,
+        "2016-11-23": 6,
+        "2016-11-24": 11,
+        "2016-11-25": 78,
+        "2016-11-26": 0,
+        "2016-11-27": 0,
+        "2016-11-28": 15,
+        "2016-11-29": 9,
+        "2016-11-30": 40,
+        "2016-12-01": 11,
+        "2016-12-02": 2,
+        "2016-12-03": 9,
+        "2016-12-04": 0,
+        "2016-12-05": 7,
+        "2016-12-06": 2,
+        "2016-12-07": 0,
+        "2016-12-08": 13,
+        "2016-12-09": 18,
+        "2016-12-10": 18,
+        "2016-12-11": 48,
+        "2016-12-12": 34,
+        "2016-12-13": 42,
+        "2016-12-14": 42,
+        "2016-12-15": 58,
+        "2016-12-16": 25,
+        "2016-12-17": 9,
+        "2016-12-18": 13,
+        "2016-12-19": 2,
+        "2016-12-20": 44,
+        "2016-12-21": 3,
+        "2016-12-22": 6,
+        "2016-12-23": 29,
+        "2016-12-24": 4,
+        "2016-12-25": 2,
+        "2016-12-26": 3,
+        "2016-12-27": 2,
+        "2016-12-28": 13,
+        "2016-12-29": 43,
+        "2016-12-30": 9,
+        "2016-12-31": 6
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 6449,
+      "severity_distribution": {
+        "UNKNOWN": 6449
+      },
+      "score_distribution": {
+        "5.0": 719,
+        "7.8": 148,
+        "4.3": 1043,
+        "2.1": 232,
+        "7.5": 396,
+        "10.0": 484,
+        "4.9": 127,
+        "7.2": 301,
+        "5.8": 100,
+        "6.8": 522,
+        "4.6": 73,
+        "9.3": 765,
+        "9.0": 89,
+        "4.0": 262,
+        "3.6": 26,
+        "7.1": 73,
+        "6.9": 77,
+        "9.4": 11,
+        "6.5": 120,
+        "3.5": 209,
+        "1.9": 47,
+        "8.5": 25,
+        "6.2": 7,
+        "5.5": 67,
+        "3.3": 21,
+        "2.7": 2,
+        "2.6": 51,
+        "6.4": 118,
+        "2.9": 6,
+        "6.0": 33,
+        "5.7": 4,
+        "6.6": 9,
+        "7.6": 125,
+        "6.3": 4,
+        "8.3": 9,
+        "4.7": 19,
+        "1.7": 7,
+        "8.0": 6,
+        "7.7": 3,
+        "4.4": 24,
+        "6.1": 19,
+        "7.3": 1,
+        "1.2": 5,
+        "1.8": 2,
+        "5.2": 3,
+        "1.5": 2,
+        "2.8": 2,
+        "1.4": 1,
+        "5.4": 10,
+        "5.6": 7,
+        "5.1": 19,
+        "3.0": 2,
+        "3.2": 2,
+        "4.1": 2,
+        "9.7": 1,
+        "4.8": 1,
+        "5.9": 3,
+        "7.0": 2,
+        "7.9": 1
+      }
+    },
+    "v3.0": {
+      "total": 5474,
+      "severity_distribution": {
+        "HIGH": 2415,
+        "MEDIUM": 2086,
+        "CRITICAL": 794,
+        "LOW": 179
+      },
+      "score_distribution": {
+        "7.5": 678,
+        "5.9": 147,
+        "5.5": 354,
+        "4.3": 163,
+        "9.8": 694,
+        "6.2": 29,
+        "6.5": 316,
+        "7.8": 712,
+        "7.6": 19,
+        "3.3": 55,
+        "6.8": 36,
+        "8.1": 111,
+        "6.1": 360,
+        "8.8": 495,
+        "7.3": 71,
+        "5.3": 223,
+        "9.1": 52,
+        "5.4": 183,
+        "7.4": 43,
+        "3.7": 44,
+        "4.0": 13,
+        "5.1": 14,
+        "8.0": 15,
+        "8.5": 6,
+        "7.0": 40,
+        "7.7": 15,
+        "10.0": 16,
+        "8.4": 38,
+        "2.5": 11,
+        "4.7": 40,
+        "5.6": 7,
+        "5.0": 17,
+        "3.5": 9,
+        "3.1": 30,
+        "6.6": 19,
+        "8.6": 59,
+        "9.0": 5,
+        "8.3": 9,
+        "6.3": 28,
+        "9.6": 19,
+        "6.4": 14,
+        "4.6": 21,
+        "6.7": 12,
+        "7.1": 34,
+        "4.1": 7,
+        "4.9": 22,
+        "4.4": 19,
+        "7.2": 26,
+        "9.9": 3,
+        "4.2": 6,
+        "8.2": 41,
+        "2.0": 1,
+        "2.9": 3,
+        "2.6": 1,
+        "9.3": 2,
+        "5.8": 10,
+        "5.7": 10,
+        "7.9": 2,
+        "3.4": 2,
+        "3.8": 2,
+        "4.8": 6,
+        "2.7": 7,
+        "6.0": 5,
+        "8.7": 1,
+        "4.5": 4,
+        "6.9": 1,
+        "3.0": 2,
+        "9.4": 3,
+        "2.4": 4,
+        "2.8": 4,
+        "2.1": 2,
+        "1.8": 1,
+        "1.9": 1
+      }
+    },
+    "v3.1": {
+      "total": 791,
+      "severity_distribution": {
+        "MEDIUM": 207,
+        "CRITICAL": 97,
+        "HIGH": 480,
+        "LOW": 7
+      },
+      "score_distribution": {
+        "5.9": 12,
+        "10.0": 1,
+        "7.8": 107,
+        "9.8": 87,
+        "9.1": 7,
+        "9.0": 1,
+        "8.6": 5,
+        "8.2": 2,
+        "7.3": 12,
+        "7.7": 2,
+        "6.5": 51,
+        "7.5": 71,
+        "6.2": 1,
+        "5.3": 13,
+        "8.8": 241,
+        "5.5": 25,
+        "6.0": 28,
+        "4.3": 6,
+        "4.6": 2,
+        "6.8": 4,
+        "5.1": 2,
+        "9.6": 1,
+        "8.0": 2,
+        "7.6": 2,
+        "8.1": 14,
+        "7.0": 14,
+        "7.1": 1,
+        "6.1": 20,
+        "8.4": 5,
+        "5.4": 3,
+        "3.3": 4,
+        "6.4": 2,
+        "4.7": 1,
+        "4.1": 2,
+        "6.7": 3,
+        "5.6": 2,
+        "4.4": 18,
+        "5.0": 1,
+        "7.2": 2,
+        "2.5": 1,
+        "6.3": 1,
+        "3.7": 2,
+        "4.9": 10
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 734,
+      "epss_gt_0_5": 133,
+      "epss_gt_0_9": 20
+    }
+  },
+  "kev": {
+    "kev_count": 53
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 1064
+      },
+      {
+        "name": "Google",
+        "count": 947
+      },
+      {
+        "name": "Apple",
+        "count": 824
+      },
+      {
+        "name": "Oracle",
+        "count": 821
+      },
+      {
+        "name": "Adobe",
+        "count": 548
+      },
+      {
+        "name": "Linux",
+        "count": 474
+      },
+      {
+        "name": "Debian",
+        "count": 454
+      },
+      {
+        "name": "Opensuse",
+        "count": 404
+      },
+      {
+        "name": "Ibm",
+        "count": 387
+      },
+      {
+        "name": "Cisco",
+        "count": 344
+      },
+      {
+        "name": "Canonical",
+        "count": 340
+      },
+      {
+        "name": "Redhat",
+        "count": 326
+      },
+      {
+        "name": "Suse",
+        "count": 151
+      },
+      {
+        "name": "Fedoraproject",
+        "count": 144
+      },
+      {
+        "name": "Mozilla",
+        "count": 143
+      },
+      {
+        "name": "Php",
+        "count": 120
+      },
+      {
+        "name": "Hp",
+        "count": 114
+      },
+      {
+        "name": "Apache",
+        "count": 104
+      },
+      {
+        "name": "Huawei",
+        "count": 100
+      },
+      {
+        "name": "Wireshark",
+        "count": 95
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-119",
+        "count": 1039
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 690
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 619
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 528
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 473
+      },
+      {
+        "cwe": "CWE-284",
+        "count": 399
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 179
+      },
+      {
+        "cwe": "CWE-399",
+        "count": 173
+      },
+      {
+        "cwe": "CWE-254",
+        "count": 170
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 162
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 96
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 94
+      },
+      {
+        "cwe": "CWE-476",
+        "count": 84
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 82
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 81
+      },
+      {
+        "cwe": "CWE-190",
+        "count": 71
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 61
+      },
+      {
+        "cwe": "CWE-19",
+        "count": 58
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 51
+      },
+      {
+        "cwe": "CWE-255",
+        "count": 48
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 6395
+      },
+      {
+        "status": "Analyzed",
+        "count": 54
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Third Party Advisory",
+        "count": 20026
+      },
+      {
+        "tag": "Vendor Advisory",
+        "count": 13312
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 6581
+      },
+      {
+        "tag": "Patch",
+        "count": 6250
+      },
+      {
+        "tag": "Mailing List",
+        "count": 4649
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 2235
+      },
+      {
+        "tag": "Broken Link",
+        "count": 2150
+      },
+      {
+        "tag": "Exploit",
+        "count": 1662
+      },
+      {
+        "tag": "Release Notes",
+        "count": 662
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 643
+      },
+      {
+        "tag": "Mitigation",
+        "count": 248
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 178
+      },
+      {
+        "tag": "Technical Description",
+        "count": 158
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 98
+      },
+      {
+        "tag": "Product",
+        "count": 56
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 20
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 16
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:44.716032",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2017.json b/web/data/cve_2017.json
new file mode 100644
index 00000000000..ca1590114c0
--- /dev/null
+++ b/web/data/cve_2017.json
@@ -0,0 +1,904 @@
+{
+  "year": 2017,
+  "total_cves": 14642,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 1083,
+      "2": 1041,
+      "3": 1300,
+      "4": 1570,
+      "5": 1010,
+      "6": 1033,
+      "7": 1268,
+      "8": 1540,
+      "9": 1227,
+      "10": 1399,
+      "11": 1066,
+      "12": 1105
+    },
+    "daily_analysis": {
+      "total_days": 342,
+      "avg_per_day": 42.81,
+      "highest_day": {
+        "date": "2017-08-08",
+        "count": 316
+      },
+      "lowest_day": {
+        "date": "2017-01-01",
+        "count": 1
+      },
+      "daily_counts": {
+        "2017-01-01": 1,
+        "2017-01-02": 4,
+        "2017-01-03": 5,
+        "2017-01-04": 19,
+        "2017-01-05": 14,
+        "2017-01-06": 53,
+        "2017-01-07": 0,
+        "2017-01-08": 0,
+        "2017-01-09": 5,
+        "2017-01-10": 16,
+        "2017-01-11": 52,
+        "2017-01-12": 159,
+        "2017-01-13": 41,
+        "2017-01-14": 10,
+        "2017-01-15": 10,
+        "2017-01-16": 2,
+        "2017-01-17": 7,
+        "2017-01-18": 61,
+        "2017-01-19": 39,
+        "2017-01-20": 25,
+        "2017-01-21": 1,
+        "2017-01-22": 0,
+        "2017-01-23": 97,
+        "2017-01-24": 10,
+        "2017-01-25": 10,
+        "2017-01-26": 31,
+        "2017-01-27": 261,
+        "2017-01-28": 45,
+        "2017-01-29": 0,
+        "2017-01-30": 57,
+        "2017-01-31": 48,
+        "2017-02-01": 143,
+        "2017-02-02": 15,
+        "2017-02-03": 44,
+        "2017-02-04": 3,
+        "2017-02-05": 3,
+        "2017-02-06": 32,
+        "2017-02-07": 34,
+        "2017-02-08": 86,
+        "2017-02-09": 52,
+        "2017-02-10": 9,
+        "2017-02-11": 0,
+        "2017-02-12": 6,
+        "2017-02-13": 124,
+        "2017-02-14": 4,
+        "2017-02-15": 92,
+        "2017-02-16": 6,
+        "2017-02-17": 81,
+        "2017-02-18": 3,
+        "2017-02-19": 0,
+        "2017-02-20": 154,
+        "2017-02-21": 21,
+        "2017-02-22": 41,
+        "2017-02-23": 8,
+        "2017-02-24": 37,
+        "2017-02-25": 0,
+        "2017-02-26": 1,
+        "2017-02-27": 30,
+        "2017-02-28": 12,
+        "2017-03-01": 58,
+        "2017-03-02": 48,
+        "2017-03-03": 50,
+        "2017-03-04": 8,
+        "2017-03-05": 16,
+        "2017-03-06": 16,
+        "2017-03-07": 64,
+        "2017-03-08": 109,
+        "2017-03-09": 28,
+        "2017-03-10": 24,
+        "2017-03-11": 9,
+        "2017-03-12": 12,
+        "2017-03-13": 15,
+        "2017-03-14": 64,
+        "2017-03-15": 88,
+        "2017-03-16": 20,
+        "2017-03-17": 180,
+        "2017-03-18": 3,
+        "2017-03-19": 3,
+        "2017-03-20": 63,
+        "2017-03-21": 22,
+        "2017-03-22": 29,
+        "2017-03-23": 105,
+        "2017-03-24": 47,
+        "2017-03-25": 1,
+        "2017-03-26": 9,
+        "2017-03-27": 59,
+        "2017-03-28": 39,
+        "2017-03-29": 32,
+        "2017-03-30": 45,
+        "2017-03-31": 34,
+        "2017-04-01": 11,
+        "2017-04-02": 177,
+        "2017-04-03": 48,
+        "2017-04-04": 23,
+        "2017-04-05": 34,
+        "2017-04-06": 32,
+        "2017-04-07": 87,
+        "2017-04-08": 0,
+        "2017-04-09": 26,
+        "2017-04-10": 98,
+        "2017-04-11": 36,
+        "2017-04-12": 154,
+        "2017-04-13": 77,
+        "2017-04-14": 60,
+        "2017-04-15": 2,
+        "2017-04-16": 1,
+        "2017-04-17": 31,
+        "2017-04-18": 14,
+        "2017-04-19": 23,
+        "2017-04-20": 101,
+        "2017-04-21": 47,
+        "2017-04-22": 6,
+        "2017-04-23": 19,
+        "2017-04-24": 281,
+        "2017-04-25": 37,
+        "2017-04-26": 11,
+        "2017-04-27": 20,
+        "2017-04-28": 76,
+        "2017-04-29": 9,
+        "2017-04-30": 29,
+        "2017-05-01": 31,
+        "2017-05-02": 21,
+        "2017-05-03": 28,
+        "2017-05-04": 19,
+        "2017-05-05": 43,
+        "2017-05-06": 11,
+        "2017-05-07": 1,
+        "2017-05-08": 26,
+        "2017-05-09": 40,
+        "2017-05-10": 31,
+        "2017-05-11": 25,
+        "2017-05-12": 174,
+        "2017-05-13": 0,
+        "2017-05-14": 4,
+        "2017-05-15": 29,
+        "2017-05-16": 38,
+        "2017-05-17": 21,
+        "2017-05-18": 41,
+        "2017-05-19": 30,
+        "2017-05-20": 0,
+        "2017-05-21": 24,
+        "2017-05-22": 127,
+        "2017-05-23": 117,
+        "2017-05-24": 17,
+        "2017-05-25": 16,
+        "2017-05-26": 27,
+        "2017-05-27": 9,
+        "2017-05-28": 10,
+        "2017-05-29": 26,
+        "2017-05-30": 16,
+        "2017-05-31": 8,
+        "2017-06-01": 13,
+        "2017-06-02": 33,
+        "2017-06-03": 0,
+        "2017-06-04": 12,
+        "2017-06-05": 30,
+        "2017-06-06": 49,
+        "2017-06-07": 59,
+        "2017-06-08": 68,
+        "2017-06-09": 68,
+        "2017-06-10": 0,
+        "2017-06-11": 3,
+        "2017-06-12": 27,
+        "2017-06-13": 121,
+        "2017-06-14": 37,
+        "2017-06-15": 112,
+        "2017-06-16": 74,
+        "2017-06-17": 2,
+        "2017-06-18": 2,
+        "2017-06-19": 38,
+        "2017-06-20": 31,
+        "2017-06-21": 32,
+        "2017-06-22": 19,
+        "2017-06-23": 13,
+        "2017-06-24": 7,
+        "2017-06-25": 10,
+        "2017-06-26": 29,
+        "2017-06-27": 53,
+        "2017-06-28": 18,
+        "2017-06-29": 38,
+        "2017-06-30": 35,
+        "2017-07-01": 2,
+        "2017-07-02": 11,
+        "2017-07-03": 15,
+        "2017-07-04": 30,
+        "2017-07-05": 180,
+        "2017-07-06": 69,
+        "2017-07-07": 74,
+        "2017-07-08": 8,
+        "2017-07-09": 3,
+        "2017-07-10": 33,
+        "2017-07-11": 63,
+        "2017-07-12": 39,
+        "2017-07-13": 18,
+        "2017-07-14": 0,
+        "2017-07-15": 0,
+        "2017-07-16": 0,
+        "2017-07-17": 217,
+        "2017-07-18": 28,
+        "2017-07-19": 30,
+        "2017-07-20": 87,
+        "2017-07-21": 35,
+        "2017-07-22": 13,
+        "2017-07-23": 35,
+        "2017-07-24": 34,
+        "2017-07-25": 57,
+        "2017-07-26": 36,
+        "2017-07-27": 29,
+        "2017-07-28": 30,
+        "2017-07-29": 12,
+        "2017-07-30": 14,
+        "2017-07-31": 66,
+        "2017-08-01": 29,
+        "2017-08-02": 68,
+        "2017-08-03": 13,
+        "2017-08-04": 38,
+        "2017-08-05": 23,
+        "2017-08-06": 10,
+        "2017-08-07": 118,
+        "2017-08-08": 316,
+        "2017-08-09": 84,
+        "2017-08-10": 25,
+        "2017-08-11": 100,
+        "2017-08-12": 0,
+        "2017-08-13": 0,
+        "2017-08-14": 20,
+        "2017-08-15": 6,
+        "2017-08-16": 20,
+        "2017-08-17": 35,
+        "2017-08-18": 176,
+        "2017-08-19": 5,
+        "2017-08-20": 5,
+        "2017-08-21": 18,
+        "2017-08-22": 26,
+        "2017-08-23": 33,
+        "2017-08-24": 36,
+        "2017-08-25": 36,
+        "2017-08-26": 1,
+        "2017-08-27": 4,
+        "2017-08-28": 68,
+        "2017-08-29": 134,
+        "2017-08-30": 51,
+        "2017-08-31": 42,
+        "2017-09-01": 30,
+        "2017-09-02": 4,
+        "2017-09-03": 9,
+        "2017-09-04": 12,
+        "2017-09-05": 26,
+        "2017-09-06": 26,
+        "2017-09-07": 77,
+        "2017-09-08": 58,
+        "2017-09-09": 14,
+        "2017-09-10": 2,
+        "2017-09-11": 82,
+        "2017-09-12": 50,
+        "2017-09-13": 136,
+        "2017-09-14": 130,
+        "2017-09-15": 26,
+        "2017-09-16": 0,
+        "2017-09-17": 20,
+        "2017-09-18": 59,
+        "2017-09-19": 45,
+        "2017-09-20": 51,
+        "2017-09-21": 82,
+        "2017-09-22": 41,
+        "2017-09-23": 11,
+        "2017-09-24": 0,
+        "2017-09-25": 49,
+        "2017-09-26": 49,
+        "2017-09-27": 9,
+        "2017-09-28": 42,
+        "2017-09-29": 39,
+        "2017-09-30": 48,
+        "2017-10-01": 1,
+        "2017-10-02": 10,
+        "2017-10-03": 63,
+        "2017-10-04": 46,
+        "2017-10-05": 90,
+        "2017-10-06": 42,
+        "2017-10-07": 0,
+        "2017-10-08": 0,
+        "2017-10-09": 4,
+        "2017-10-10": 70,
+        "2017-10-11": 80,
+        "2017-10-12": 23,
+        "2017-10-13": 96,
+        "2017-10-14": 3,
+        "2017-10-15": 6,
+        "2017-10-16": 43,
+        "2017-10-17": 41,
+        "2017-10-18": 54,
+        "2017-10-19": 229,
+        "2017-10-20": 17,
+        "2017-10-21": 0,
+        "2017-10-22": 74,
+        "2017-10-23": 118,
+        "2017-10-24": 34,
+        "2017-10-25": 7,
+        "2017-10-26": 31,
+        "2017-10-27": 102,
+        "2017-10-28": 8,
+        "2017-10-29": 30,
+        "2017-10-30": 31,
+        "2017-10-31": 46,
+        "2017-11-01": 33,
+        "2017-11-02": 23,
+        "2017-11-03": 33,
+        "2017-11-04": 17,
+        "2017-11-05": 4,
+        "2017-11-06": 29,
+        "2017-11-07": 44,
+        "2017-11-08": 19,
+        "2017-11-09": 11,
+        "2017-11-10": 35,
+        "2017-11-11": 1,
+        "2017-11-12": 6,
+        "2017-11-13": 97,
+        "2017-11-14": 22,
+        "2017-11-15": 91,
+        "2017-11-16": 124,
+        "2017-11-17": 100,
+        "2017-11-18": 4,
+        "2017-11-19": 1,
+        "2017-11-20": 26,
+        "2017-11-21": 19,
+        "2017-11-22": 162,
+        "2017-11-23": 7,
+        "2017-11-24": 7,
+        "2017-11-25": 5,
+        "2017-11-26": 1,
+        "2017-11-27": 55,
+        "2017-11-28": 16,
+        "2017-11-29": 16,
+        "2017-11-30": 58,
+        "2017-12-01": 41,
+        "2017-12-02": 6,
+        "2017-12-03": 8,
+        "2017-12-04": 22,
+        "2017-12-05": 60,
+        "2017-12-06": 52,
+        "2017-12-07": 34,
+        "2017-12-08": 30,
+        "2017-12-09": 86,
+        "2017-12-10": 3,
+        "2017-12-11": 52,
+        "2017-12-12": 58,
+        "2017-12-13": 104,
+        "2017-12-14": 35,
+        "2017-12-15": 19,
+        "2017-12-16": 22,
+        "2017-12-17": 4,
+        "2017-12-18": 22,
+        "2017-12-19": 22,
+        "2017-12-20": 133,
+        "2017-12-21": 51,
+        "2017-12-22": 24,
+        "2017-12-23": 1,
+        "2017-12-24": 0,
+        "2017-12-25": 23,
+        "2017-12-26": 3,
+        "2017-12-27": 106,
+        "2017-12-28": 30,
+        "2017-12-29": 26,
+        "2017-12-30": 24,
+        "2017-12-31": 4
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 14642,
+      "severity_distribution": {
+        "UNKNOWN": 14642
+      },
+      "score_distribution": {
+        "3.6": 47,
+        "4.9": 191,
+        "7.5": 1452,
+        "4.6": 425,
+        "10.0": 452,
+        "4.3": 2809,
+        "5.0": 1831,
+        "6.5": 427,
+        "9.3": 893,
+        "7.2": 484,
+        "5.8": 410,
+        "6.8": 1639,
+        "3.5": 618,
+        "9.0": 177,
+        "2.1": 414,
+        "4.8": 2,
+        "7.8": 223,
+        "4.0": 582,
+        "6.0": 78,
+        "7.6": 360,
+        "9.7": 1,
+        "6.6": 3,
+        "6.9": 108,
+        "5.5": 102,
+        "4.4": 64,
+        "1.9": 118,
+        "7.1": 154,
+        "2.6": 98,
+        "6.4": 126,
+        "5.6": 5,
+        "1.7": 6,
+        "7.9": 14,
+        "4.7": 11,
+        "3.3": 47,
+        "3.7": 20,
+        "8.5": 28,
+        "1.2": 3,
+        "5.1": 38,
+        "8.3": 28,
+        "9.4": 2,
+        "5.4": 17,
+        "6.1": 28,
+        "3.0": 2,
+        "4.1": 5,
+        "6.2": 8,
+        "8.0": 2,
+        "2.3": 9,
+        "5.7": 2,
+        "3.2": 4,
+        "1.5": 3,
+        "1.0": 1,
+        "2.9": 19,
+        "7.7": 11,
+        "7.4": 6,
+        "6.3": 14,
+        "5.2": 12,
+        "8.2": 1,
+        "7.0": 1,
+        "8.8": 1,
+        "2.7": 5,
+        "1.4": 1
+      }
+    },
+    "v3.0": {
+      "total": 13062,
+      "severity_distribution": {
+        "HIGH": 5882,
+        "MEDIUM": 5119,
+        "CRITICAL": 1850,
+        "LOW": 211
+      },
+      "score_distribution": {
+        "7.1": 84,
+        "5.5": 975,
+        "9.8": 1667,
+        "7.8": 1825,
+        "7.3": 78,
+        "6.1": 1006,
+        "5.3": 379,
+        "8.8": 1292,
+        "4.8": 72,
+        "7.4": 42,
+        "6.5": 866,
+        "5.4": 526,
+        "7.5": 1605,
+        "5.9": 313,
+        "6.2": 19,
+        "8.1": 201,
+        "4.9": 72,
+        "3.1": 35,
+        "6.6": 27,
+        "7.0": 270,
+        "4.0": 14,
+        "3.3": 79,
+        "4.6": 38,
+        "8.2": 193,
+        "7.2": 104,
+        "9.1": 77,
+        "3.7": 41,
+        "4.3": 292,
+        "8.3": 18,
+        "10.0": 38,
+        "6.8": 65,
+        "4.4": 33,
+        "4.7": 143,
+        "2.8": 2,
+        "8.0": 40,
+        "6.4": 22,
+        "6.7": 62,
+        "5.0": 46,
+        "4.2": 18,
+        "9.3": 2,
+        "9.0": 23,
+        "6.3": 44,
+        "6.0": 12,
+        "8.4": 26,
+        "8.6": 54,
+        "7.9": 5,
+        "2.1": 1,
+        "4.1": 3,
+        "5.6": 7,
+        "2.7": 7,
+        "5.7": 23,
+        "7.6": 23,
+        "2.4": 14,
+        "9.9": 25,
+        "8.5": 9,
+        "5.1": 7,
+        "3.4": 2,
+        "3.5": 11,
+        "9.6": 16,
+        "4.5": 6,
+        "5.8": 26,
+        "2.9": 1,
+        "2.6": 1,
+        "3.9": 3,
+        "7.7": 9,
+        "8.7": 4,
+        "2.5": 7,
+        "3.8": 2,
+        "9.4": 2,
+        "6.9": 2,
+        "1.9": 1,
+        "1.8": 1,
+        "5.2": 1,
+        "2.3": 3
+      }
+    },
+    "v3.1": {
+      "total": 1802,
+      "severity_distribution": {
+        "CRITICAL": 343,
+        "MEDIUM": 601,
+        "HIGH": 833,
+        "LOW": 25
+      },
+      "score_distribution": {
+        "9.8": 308,
+        "4.3": 27,
+        "7.5": 250,
+        "6.1": 89,
+        "6.5": 182,
+        "7.8": 210,
+        "5.5": 113,
+        "8.8": 246,
+        "7.0": 36,
+        "5.9": 48,
+        "7.1": 7,
+        "5.3": 38,
+        "6.7": 6,
+        "3.3": 5,
+        "7.9": 1,
+        "7.7": 3,
+        "3.7": 5,
+        "9.6": 14,
+        "8.1": 33,
+        "9.1": 14,
+        "4.8": 6,
+        "5.1": 1,
+        "7.2": 11,
+        "7.3": 9,
+        "6.2": 4,
+        "4.7": 6,
+        "8.2": 2,
+        "4.6": 4,
+        "5.4": 17,
+        "8.6": 7,
+        "6.3": 5,
+        "8.0": 5,
+        "10.0": 6,
+        "6.0": 4,
+        "4.4": 4,
+        "5.6": 3,
+        "4.0": 5,
+        "8.9": 1,
+        "7.4": 7,
+        "2.7": 3,
+        "2.4": 1,
+        "6.4": 3,
+        "6.6": 10,
+        "4.9": 5,
+        "5.7": 1,
+        "3.5": 1,
+        "4.5": 1,
+        "6.8": 6,
+        "5.0": 10,
+        "3.4": 1,
+        "4.2": 1,
+        "8.3": 3,
+        "9.0": 1,
+        "3.1": 4,
+        "8.4": 2,
+        "4.1": 1,
+        "3.8": 3,
+        "1.9": 1,
+        "2.6": 1,
+        "5.8": 1
+      }
+    },
+    "v4.0": {
+      "total": 3,
+      "severity_distribution": {
+        "HIGH": 3
+      },
+      "score_distribution": {
+        "7.1": 2,
+        "8.7": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 978,
+      "epss_gt_0_5": 245,
+      "epss_gt_0_9": 46
+    }
+  },
+  "kev": {
+    "kev_count": 89
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 1290
+      },
+      {
+        "name": "Google",
+        "count": 1086
+      },
+      {
+        "name": "Oracle",
+        "count": 934
+      },
+      {
+        "name": "Apple",
+        "count": 911
+      },
+      {
+        "name": "Debian",
+        "count": 861
+      },
+      {
+        "name": "Ibm",
+        "count": 687
+      },
+      {
+        "name": "Linux",
+        "count": 628
+      },
+      {
+        "name": "Cisco",
+        "count": 492
+      },
+      {
+        "name": "Redhat",
+        "count": 395
+      },
+      {
+        "name": "Imagemagick",
+        "count": 357
+      },
+      {
+        "name": "Adobe",
+        "count": 353
+      },
+      {
+        "name": "Canonical",
+        "count": 259
+      },
+      {
+        "name": "Huawei",
+        "count": 253
+      },
+      {
+        "name": "Apache",
+        "count": 223
+      },
+      {
+        "name": "Gnu",
+        "count": 186
+      },
+      {
+        "name": "Netapp",
+        "count": 141
+      },
+      {
+        "name": "Tcpdump",
+        "count": 134
+      },
+      {
+        "name": "Fedoraproject",
+        "count": 121
+      },
+      {
+        "name": "Opensuse",
+        "count": 116
+      },
+      {
+        "name": "Irfanview",
+        "count": 115
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-119",
+        "count": 2169
+      },
+      {
+        "cwe": "CWE-79",
+        "count": 1559
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 1348
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 1012
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 779
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 516
+      },
+      {
+        "cwe": "CWE-476",
+        "count": 352
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 336
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 319
+      },
+      {
+        "cwe": "CWE-264",
+        "count": 316
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 296
+      },
+      {
+        "cwe": "CWE-284",
+        "count": 279
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 268
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 263
+      },
+      {
+        "cwe": "CWE-190",
+        "count": 231
+      },
+      {
+        "cwe": "CWE-295",
+        "count": 182
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 172
+      },
+      {
+        "cwe": "CWE-772",
+        "count": 170
+      },
+      {
+        "cwe": "CWE-400",
+        "count": 148
+      },
+      {
+        "cwe": "CWE-426",
+        "count": 141
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 14532
+      },
+      {
+        "status": "Analyzed",
+        "count": 110
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Third Party Advisory",
+        "count": 53173
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 25837
+      },
+      {
+        "tag": "Vendor Advisory",
+        "count": 20361
+      },
+      {
+        "tag": "Patch",
+        "count": 16697
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 8837
+      },
+      {
+        "tag": "Exploit",
+        "count": 7208
+      },
+      {
+        "tag": "Mailing List",
+        "count": 6092
+      },
+      {
+        "tag": "Release Notes",
+        "count": 1672
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1336
+      },
+      {
+        "tag": "Mitigation",
+        "count": 1272
+      },
+      {
+        "tag": "Technical Description",
+        "count": 996
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 873
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 223
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 74
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 74
+      },
+      {
+        "tag": "Product",
+        "count": 71
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 62
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 16
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:45.087032",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2018.json b/web/data/cve_2018.json
new file mode 100644
index 00000000000..74ee1b03335
--- /dev/null
+++ b/web/data/cve_2018.json
@@ -0,0 +1,896 @@
+{
+  "year": 2018,
+  "total_cves": 16510,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 1273,
+      "2": 1325,
+      "3": 1337,
+      "4": 1667,
+      "5": 1162,
+      "6": 1783,
+      "7": 2167,
+      "8": 1013,
+      "9": 1169,
+      "10": 1468,
+      "11": 983,
+      "12": 1163
+    },
+    "daily_analysis": {
+      "total_days": 351,
+      "avg_per_day": 47.04,
+      "highest_day": {
+        "date": "2018-07-09",
+        "count": 431
+      },
+      "lowest_day": {
+        "date": "2018-01-07",
+        "count": 1
+      },
+      "daily_counts": {
+        "2018-01-01": 11,
+        "2018-01-02": 40,
+        "2018-01-03": 57,
+        "2018-01-04": 66,
+        "2018-01-05": 27,
+        "2018-01-06": 4,
+        "2018-01-07": 1,
+        "2018-01-08": 58,
+        "2018-01-09": 34,
+        "2018-01-10": 103,
+        "2018-01-11": 49,
+        "2018-01-12": 118,
+        "2018-01-13": 26,
+        "2018-01-14": 20,
+        "2018-01-15": 4,
+        "2018-01-16": 45,
+        "2018-01-17": 6,
+        "2018-01-18": 217,
+        "2018-01-19": 32,
+        "2018-01-20": 5,
+        "2018-01-21": 7,
+        "2018-01-22": 27,
+        "2018-01-23": 64,
+        "2018-01-24": 52,
+        "2018-01-25": 39,
+        "2018-01-26": 55,
+        "2018-01-27": 7,
+        "2018-01-28": 1,
+        "2018-01-29": 36,
+        "2018-01-30": 23,
+        "2018-01-31": 39,
+        "2018-02-01": 28,
+        "2018-02-02": 66,
+        "2018-02-03": 9,
+        "2018-02-04": 6,
+        "2018-02-05": 40,
+        "2018-02-06": 64,
+        "2018-02-07": 60,
+        "2018-02-08": 74,
+        "2018-02-09": 77,
+        "2018-02-10": 0,
+        "2018-02-11": 3,
+        "2018-02-12": 54,
+        "2018-02-13": 28,
+        "2018-02-14": 38,
+        "2018-02-15": 340,
+        "2018-02-16": 22,
+        "2018-02-17": 31,
+        "2018-02-18": 11,
+        "2018-02-19": 43,
+        "2018-02-20": 28,
+        "2018-02-21": 44,
+        "2018-02-22": 48,
+        "2018-02-23": 59,
+        "2018-02-24": 11,
+        "2018-02-25": 6,
+        "2018-02-26": 30,
+        "2018-02-27": 77,
+        "2018-02-28": 28,
+        "2018-03-01": 53,
+        "2018-03-02": 46,
+        "2018-03-03": 0,
+        "2018-03-04": 12,
+        "2018-03-05": 51,
+        "2018-03-06": 52,
+        "2018-03-07": 30,
+        "2018-03-08": 59,
+        "2018-03-09": 104,
+        "2018-03-10": 4,
+        "2018-03-11": 5,
+        "2018-03-12": 47,
+        "2018-03-13": 72,
+        "2018-03-14": 133,
+        "2018-03-15": 64,
+        "2018-03-16": 42,
+        "2018-03-17": 3,
+        "2018-03-18": 9,
+        "2018-03-19": 30,
+        "2018-03-20": 61,
+        "2018-03-21": 30,
+        "2018-03-22": 67,
+        "2018-03-23": 29,
+        "2018-03-24": 13,
+        "2018-03-25": 35,
+        "2018-03-26": 51,
+        "2018-03-27": 66,
+        "2018-03-28": 56,
+        "2018-03-29": 33,
+        "2018-03-30": 71,
+        "2018-03-31": 9,
+        "2018-04-01": 8,
+        "2018-04-02": 25,
+        "2018-04-03": 170,
+        "2018-04-04": 163,
+        "2018-04-05": 57,
+        "2018-04-06": 14,
+        "2018-04-07": 10,
+        "2018-04-08": 5,
+        "2018-04-09": 14,
+        "2018-04-10": 50,
+        "2018-04-11": 88,
+        "2018-04-12": 112,
+        "2018-04-13": 41,
+        "2018-04-14": 0,
+        "2018-04-15": 0,
+        "2018-04-16": 61,
+        "2018-04-17": 31,
+        "2018-04-18": 281,
+        "2018-04-19": 200,
+        "2018-04-20": 36,
+        "2018-04-21": 6,
+        "2018-04-22": 14,
+        "2018-04-23": 24,
+        "2018-04-24": 100,
+        "2018-04-25": 45,
+        "2018-04-26": 36,
+        "2018-04-27": 29,
+        "2018-04-28": 3,
+        "2018-04-29": 15,
+        "2018-04-30": 29,
+        "2018-05-01": 31,
+        "2018-05-02": 63,
+        "2018-05-03": 13,
+        "2018-05-04": 35,
+        "2018-05-05": 5,
+        "2018-05-06": 4,
+        "2018-05-07": 14,
+        "2018-05-08": 34,
+        "2018-05-09": 103,
+        "2018-05-10": 49,
+        "2018-05-11": 25,
+        "2018-05-12": 7,
+        "2018-05-13": 4,
+        "2018-05-14": 50,
+        "2018-05-15": 37,
+        "2018-05-16": 28,
+        "2018-05-17": 139,
+        "2018-05-18": 31,
+        "2018-05-19": 38,
+        "2018-05-20": 4,
+        "2018-05-21": 13,
+        "2018-05-22": 63,
+        "2018-05-23": 32,
+        "2018-05-24": 55,
+        "2018-05-25": 46,
+        "2018-05-26": 17,
+        "2018-05-27": 0,
+        "2018-05-28": 11,
+        "2018-05-29": 80,
+        "2018-05-30": 30,
+        "2018-05-31": 101,
+        "2018-06-01": 96,
+        "2018-06-02": 60,
+        "2018-06-03": 0,
+        "2018-06-04": 136,
+        "2018-06-05": 60,
+        "2018-06-06": 27,
+        "2018-06-07": 237,
+        "2018-06-08": 96,
+        "2018-06-09": 1,
+        "2018-06-10": 1,
+        "2018-06-11": 349,
+        "2018-06-12": 56,
+        "2018-06-13": 59,
+        "2018-06-14": 71,
+        "2018-06-15": 35,
+        "2018-06-16": 17,
+        "2018-06-17": 26,
+        "2018-06-18": 27,
+        "2018-06-19": 39,
+        "2018-06-20": 44,
+        "2018-06-21": 41,
+        "2018-06-22": 26,
+        "2018-06-23": 10,
+        "2018-06-24": 4,
+        "2018-06-25": 29,
+        "2018-06-26": 144,
+        "2018-06-27": 31,
+        "2018-06-28": 20,
+        "2018-06-29": 37,
+        "2018-06-30": 4,
+        "2018-07-01": 8,
+        "2018-07-02": 33,
+        "2018-07-03": 146,
+        "2018-07-04": 16,
+        "2018-07-05": 133,
+        "2018-07-06": 96,
+        "2018-07-07": 8,
+        "2018-07-08": 9,
+        "2018-07-09": 431,
+        "2018-07-10": 87,
+        "2018-07-11": 98,
+        "2018-07-12": 34,
+        "2018-07-13": 86,
+        "2018-07-14": 0,
+        "2018-07-15": 12,
+        "2018-07-16": 39,
+        "2018-07-17": 37,
+        "2018-07-18": 253,
+        "2018-07-19": 49,
+        "2018-07-20": 164,
+        "2018-07-21": 1,
+        "2018-07-22": 3,
+        "2018-07-23": 61,
+        "2018-07-24": 49,
+        "2018-07-25": 33,
+        "2018-07-26": 44,
+        "2018-07-27": 76,
+        "2018-07-28": 9,
+        "2018-07-29": 1,
+        "2018-07-30": 23,
+        "2018-07-31": 128,
+        "2018-08-01": 79,
+        "2018-08-02": 40,
+        "2018-08-03": 43,
+        "2018-08-04": 8,
+        "2018-08-05": 21,
+        "2018-08-06": 81,
+        "2018-08-07": 12,
+        "2018-08-08": 23,
+        "2018-08-09": 14,
+        "2018-08-10": 28,
+        "2018-08-11": 0,
+        "2018-08-12": 3,
+        "2018-08-13": 36,
+        "2018-08-14": 34,
+        "2018-08-15": 109,
+        "2018-08-16": 15,
+        "2018-08-17": 29,
+        "2018-08-18": 8,
+        "2018-08-19": 0,
+        "2018-08-20": 67,
+        "2018-08-21": 28,
+        "2018-08-22": 25,
+        "2018-08-23": 46,
+        "2018-08-24": 34,
+        "2018-08-25": 27,
+        "2018-08-26": 8,
+        "2018-08-27": 27,
+        "2018-08-28": 54,
+        "2018-08-29": 45,
+        "2018-08-30": 56,
+        "2018-08-31": 13,
+        "2018-09-01": 20,
+        "2018-09-02": 28,
+        "2018-09-03": 31,
+        "2018-09-04": 52,
+        "2018-09-05": 53,
+        "2018-09-06": 51,
+        "2018-09-07": 65,
+        "2018-09-08": 7,
+        "2018-09-09": 7,
+        "2018-09-10": 47,
+        "2018-09-11": 39,
+        "2018-09-12": 69,
+        "2018-09-13": 104,
+        "2018-09-14": 31,
+        "2018-09-15": 9,
+        "2018-09-16": 26,
+        "2018-09-17": 38,
+        "2018-09-18": 78,
+        "2018-09-19": 57,
+        "2018-09-20": 43,
+        "2018-09-21": 63,
+        "2018-09-22": 6,
+        "2018-09-23": 16,
+        "2018-09-24": 28,
+        "2018-09-25": 53,
+        "2018-09-26": 63,
+        "2018-09-27": 15,
+        "2018-09-28": 62,
+        "2018-09-29": 2,
+        "2018-09-30": 6,
+        "2018-10-01": 51,
+        "2018-10-02": 78,
+        "2018-10-03": 40,
+        "2018-10-04": 29,
+        "2018-10-05": 134,
+        "2018-10-06": 2,
+        "2018-10-07": 6,
+        "2018-10-08": 48,
+        "2018-10-09": 58,
+        "2018-10-10": 110,
+        "2018-10-11": 16,
+        "2018-10-12": 114,
+        "2018-10-13": 0,
+        "2018-10-14": 4,
+        "2018-10-15": 33,
+        "2018-10-16": 23,
+        "2018-10-17": 261,
+        "2018-10-18": 62,
+        "2018-10-19": 42,
+        "2018-10-20": 2,
+        "2018-10-21": 4,
+        "2018-10-22": 14,
+        "2018-10-23": 69,
+        "2018-10-24": 35,
+        "2018-10-25": 7,
+        "2018-10-26": 36,
+        "2018-10-27": 0,
+        "2018-10-28": 0,
+        "2018-10-29": 110,
+        "2018-10-30": 40,
+        "2018-10-31": 40,
+        "2018-11-01": 29,
+        "2018-11-02": 28,
+        "2018-11-03": 3,
+        "2018-11-04": 6,
+        "2018-11-05": 22,
+        "2018-11-06": 52,
+        "2018-11-07": 45,
+        "2018-11-08": 38,
+        "2018-11-09": 32,
+        "2018-11-10": 8,
+        "2018-11-11": 9,
+        "2018-11-12": 43,
+        "2018-11-13": 38,
+        "2018-11-14": 157,
+        "2018-11-15": 42,
+        "2018-11-16": 39,
+        "2018-11-17": 20,
+        "2018-11-18": 5,
+        "2018-11-19": 9,
+        "2018-11-20": 36,
+        "2018-11-21": 15,
+        "2018-11-22": 12,
+        "2018-11-23": 13,
+        "2018-11-24": 1,
+        "2018-11-25": 3,
+        "2018-11-26": 60,
+        "2018-11-27": 96,
+        "2018-11-28": 41,
+        "2018-11-29": 44,
+        "2018-11-30": 37,
+        "2018-12-01": 8,
+        "2018-12-02": 1,
+        "2018-12-03": 54,
+        "2018-12-04": 80,
+        "2018-12-05": 29,
+        "2018-12-06": 75,
+        "2018-12-07": 57,
+        "2018-12-08": 8,
+        "2018-12-09": 3,
+        "2018-12-10": 32,
+        "2018-12-11": 53,
+        "2018-12-12": 81,
+        "2018-12-13": 48,
+        "2018-12-14": 28,
+        "2018-12-15": 3,
+        "2018-12-16": 0,
+        "2018-12-17": 78,
+        "2018-12-18": 19,
+        "2018-12-19": 30,
+        "2018-12-20": 136,
+        "2018-12-21": 30,
+        "2018-12-22": 14,
+        "2018-12-23": 40,
+        "2018-12-24": 41,
+        "2018-12-25": 26,
+        "2018-12-26": 33,
+        "2018-12-27": 5,
+        "2018-12-28": 88,
+        "2018-12-29": 0,
+        "2018-12-30": 29,
+        "2018-12-31": 34
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 16510,
+      "severity_distribution": {
+        "UNKNOWN": 16510
+      },
+      "score_distribution": {
+        "5.0": 2790,
+        "2.1": 463,
+        "4.0": 751,
+        "7.2": 546,
+        "1.9": 113,
+        "7.5": 1546,
+        "3.3": 90,
+        "6.4": 184,
+        "4.9": 173,
+        "6.5": 606,
+        "4.3": 2648,
+        "10.0": 697,
+        "3.5": 946,
+        "6.8": 1662,
+        "9.3": 524,
+        "3.6": 59,
+        "5.5": 221,
+        "5.8": 410,
+        "4.1": 6,
+        "7.8": 246,
+        "2.9": 30,
+        "4.6": 468,
+        "5.1": 35,
+        "9.0": 345,
+        "7.6": 184,
+        "6.6": 7,
+        "8.5": 37,
+        "1.5": 1,
+        "6.9": 70,
+        "6.0": 77,
+        "7.3": 2,
+        "2.6": 40,
+        "7.1": 83,
+        "4.4": 103,
+        "6.1": 175,
+        "8.3": 33,
+        "2.7": 10,
+        "5.2": 8,
+        "4.7": 23,
+        "6.2": 3,
+        "3.7": 7,
+        "5.7": 5,
+        "1.2": 4,
+        "6.3": 12,
+        "8.0": 16,
+        "7.7": 8,
+        "4.8": 5,
+        "5.4": 14,
+        "3.8": 3,
+        "7.9": 2,
+        "9.4": 2,
+        "2.3": 2,
+        "7.4": 3,
+        "5.6": 7,
+        "8.8": 3,
+        "7.0": 1,
+        "6.7": 1
+      }
+    },
+    "v3.0": {
+      "total": 15199,
+      "severity_distribution": {
+        "HIGH": 6844,
+        "MEDIUM": 5828,
+        "CRITICAL": 2295,
+        "LOW": 232
+      },
+      "score_distribution": {
+        "7.5": 2310,
+        "6.8": 83,
+        "6.5": 1127,
+        "6.7": 43,
+        "4.1": 12,
+        "9.8": 2051,
+        "5.3": 554,
+        "5.5": 718,
+        "8.1": 396,
+        "5.9": 264,
+        "8.8": 1772,
+        "5.4": 657,
+        "4.3": 323,
+        "7.3": 59,
+        "6.1": 1192,
+        "4.4": 44,
+        "3.3": 62,
+        "7.8": 1394,
+        "7.4": 70,
+        "7.1": 129,
+        "7.0": 132,
+        "9.1": 98,
+        "7.2": 208,
+        "2.7": 16,
+        "8.6": 88,
+        "4.6": 42,
+        "6.3": 53,
+        "4.8": 276,
+        "8.0": 71,
+        "4.2": 28,
+        "7.6": 25,
+        "3.5": 16,
+        "3.7": 57,
+        "8.2": 65,
+        "9.6": 23,
+        "10.0": 55,
+        "4.7": 101,
+        "6.6": 27,
+        "8.3": 27,
+        "6.4": 26,
+        "4.9": 72,
+        "2.2": 2,
+        "5.0": 21,
+        "3.1": 28,
+        "4.0": 27,
+        "6.2": 32,
+        "6.9": 4,
+        "5.8": 24,
+        "8.4": 31,
+        "5.6": 31,
+        "5.7": 23,
+        "9.9": 33,
+        "7.7": 27,
+        "8.7": 8,
+        "2.0": 2,
+        "3.9": 8,
+        "5.1": 9,
+        "6.0": 8,
+        "9.0": 27,
+        "2.8": 3,
+        "2.6": 4,
+        "2.4": 5,
+        "2.3": 7,
+        "4.5": 3,
+        "5.2": 4,
+        "8.5": 30,
+        "9.3": 4,
+        "3.6": 3,
+        "2.9": 1,
+        "2.1": 1,
+        "3.8": 8,
+        "3.4": 4,
+        "9.4": 4,
+        "2.5": 4,
+        "7.9": 1,
+        "1.8": 1,
+        "8.9": 1
+      }
+    },
+    "v3.1": {
+      "total": 1853,
+      "severity_distribution": {
+        "HIGH": 872,
+        "MEDIUM": 629,
+        "CRITICAL": 331,
+        "LOW": 21
+      },
+      "score_distribution": {
+        "7.5": 294,
+        "7.8": 195,
+        "6.1": 85,
+        "9.8": 267,
+        "8.8": 193,
+        "6.5": 157,
+        "5.4": 38,
+        "5.9": 38,
+        "5.5": 79,
+        "8.1": 77,
+        "4.9": 32,
+        "5.3": 74,
+        "10.0": 9,
+        "8.2": 9,
+        "7.4": 12,
+        "7.1": 8,
+        "5.6": 10,
+        "4.7": 13,
+        "7.0": 12,
+        "6.8": 15,
+        "4.4": 8,
+        "3.3": 6,
+        "7.2": 23,
+        "4.3": 25,
+        "8.0": 5,
+        "9.0": 5,
+        "9.9": 32,
+        "4.6": 5,
+        "9.1": 16,
+        "3.7": 4,
+        "4.8": 14,
+        "4.5": 1,
+        "8.3": 13,
+        "6.0": 1,
+        "8.6": 15,
+        "6.7": 14,
+        "3.6": 1,
+        "5.0": 2,
+        "7.7": 7,
+        "6.6": 6,
+        "3.8": 1,
+        "3.1": 4,
+        "6.3": 4,
+        "5.8": 1,
+        "7.6": 2,
+        "6.2": 1,
+        "6.4": 1,
+        "7.3": 5,
+        "2.7": 2,
+        "2.8": 1,
+        "9.4": 1,
+        "5.2": 1,
+        "4.2": 1,
+        "9.6": 1,
+        "2.4": 1,
+        "8.7": 1,
+        "3.4": 1,
+        "8.4": 1,
+        "5.7": 3
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 1270,
+      "epss_gt_0_5": 263,
+      "epss_gt_0_9": 43
+    }
+  },
+  "kev": {
+    "kev_count": 76
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Debian",
+        "count": 1416
+      },
+      {
+        "name": "Microsoft",
+        "count": 1358
+      },
+      {
+        "name": "Redhat",
+        "count": 929
+      },
+      {
+        "name": "Canonical",
+        "count": 885
+      },
+      {
+        "name": "Google",
+        "count": 842
+      },
+      {
+        "name": "Oracle",
+        "count": 819
+      },
+      {
+        "name": "Ibm",
+        "count": 643
+      },
+      {
+        "name": "Apple",
+        "count": 520
+      },
+      {
+        "name": "Cisco",
+        "count": 457
+      },
+      {
+        "name": "Adobe",
+        "count": 387
+      },
+      {
+        "name": "Qualcomm",
+        "count": 376
+      },
+      {
+        "name": "Mozilla",
+        "count": 358
+      },
+      {
+        "name": "Hp",
+        "count": 311
+      },
+      {
+        "name": "Linux",
+        "count": 282
+      },
+      {
+        "name": "Foxitsoftware",
+        "count": 249
+      },
+      {
+        "name": "Huawei",
+        "count": 226
+      },
+      {
+        "name": "Netapp",
+        "count": 190
+      },
+      {
+        "name": "Apache",
+        "count": 176
+      },
+      {
+        "name": "Jenkins",
+        "count": 161
+      },
+      {
+        "name": "Opensuse",
+        "count": 132
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-79",
+        "count": 2189
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 1402
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 1132
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 1029
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 908
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 821
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 746
+      },
+      {
+        "cwe": "CWE-190",
+        "count": 738
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 555
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 510
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 495
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 364
+      },
+      {
+        "cwe": "CWE-476",
+        "count": 360
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 338
+      },
+      {
+        "cwe": "CWE-400",
+        "count": 260
+      },
+      {
+        "cwe": "CWE-732",
+        "count": 229
+      },
+      {
+        "cwe": "CWE-611",
+        "count": 208
+      },
+      {
+        "cwe": "CWE-310",
+        "count": 185
+      },
+      {
+        "cwe": "CWE-434",
+        "count": 184
+      },
+      {
+        "cwe": "CWE-311",
+        "count": 179
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 16406
+      },
+      {
+        "status": "Analyzed",
+        "count": 102
+      },
+      {
+        "status": "Undergoing Analysis",
+        "count": 2
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Third Party Advisory",
+        "count": 62915
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 23519
+      },
+      {
+        "tag": "Vendor Advisory",
+        "count": 21992
+      },
+      {
+        "tag": "Exploit",
+        "count": 13681
+      },
+      {
+        "tag": "Patch",
+        "count": 11714
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 5112
+      },
+      {
+        "tag": "Mailing List",
+        "count": 4387
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1318
+      },
+      {
+        "tag": "Release Notes",
+        "count": 1222
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 1140
+      },
+      {
+        "tag": "Mitigation",
+        "count": 1137
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 724
+      },
+      {
+        "tag": "Technical Description",
+        "count": 692
+      },
+      {
+        "tag": "Product",
+        "count": 153
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 74
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 74
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 36
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 6
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:45.509550",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2019.json b/web/data/cve_2019.json
new file mode 100644
index 00000000000..76d82a0cc33
--- /dev/null
+++ b/web/data/cve_2019.json
@@ -0,0 +1,907 @@
+{
+  "year": 2019,
+  "total_cves": 17305,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 1212,
+      "2": 838,
+      "3": 1182,
+      "4": 1533,
+      "5": 1316,
+      "6": 1254,
+      "7": 1618,
+      "8": 2001,
+      "9": 1531,
+      "10": 1566,
+      "11": 1677,
+      "12": 1577
+    },
+    "daily_analysis": {
+      "total_days": 336,
+      "avg_per_day": 51.5,
+      "highest_day": {
+        "date": "2019-12-18",
+        "count": 364
+      },
+      "lowest_day": {
+        "date": "2019-02-14",
+        "count": 1
+      },
+      "daily_counts": {
+        "2019-01-01": 4,
+        "2019-01-02": 29,
+        "2019-01-03": 58,
+        "2019-01-04": 10,
+        "2019-01-05": 0,
+        "2019-01-06": 0,
+        "2019-01-07": 8,
+        "2019-01-08": 71,
+        "2019-01-09": 196,
+        "2019-01-10": 48,
+        "2019-01-11": 58,
+        "2019-01-12": 4,
+        "2019-01-13": 9,
+        "2019-01-14": 14,
+        "2019-01-15": 60,
+        "2019-01-16": 212,
+        "2019-01-17": 12,
+        "2019-01-18": 123,
+        "2019-01-19": 0,
+        "2019-01-20": 3,
+        "2019-01-21": 4,
+        "2019-01-22": 27,
+        "2019-01-23": 28,
+        "2019-01-24": 107,
+        "2019-01-25": 13,
+        "2019-01-26": 3,
+        "2019-01-27": 2,
+        "2019-01-28": 28,
+        "2019-01-29": 26,
+        "2019-01-30": 26,
+        "2019-01-31": 29,
+        "2019-02-01": 26,
+        "2019-02-02": 0,
+        "2019-02-03": 4,
+        "2019-02-04": 71,
+        "2019-02-05": 66,
+        "2019-02-06": 51,
+        "2019-02-07": 35,
+        "2019-02-08": 18,
+        "2019-02-09": 14,
+        "2019-02-10": 16,
+        "2019-02-11": 60,
+        "2019-02-12": 22,
+        "2019-02-13": 42,
+        "2019-02-14": 1,
+        "2019-02-15": 31,
+        "2019-02-16": 5,
+        "2019-02-17": 30,
+        "2019-02-18": 43,
+        "2019-02-19": 38,
+        "2019-02-20": 25,
+        "2019-02-21": 35,
+        "2019-02-22": 16,
+        "2019-02-23": 31,
+        "2019-02-24": 12,
+        "2019-02-25": 55,
+        "2019-02-26": 19,
+        "2019-02-27": 18,
+        "2019-02-28": 54,
+        "2019-03-01": 11,
+        "2019-03-02": 2,
+        "2019-03-03": 2,
+        "2019-03-04": 11,
+        "2019-03-05": 153,
+        "2019-03-06": 39,
+        "2019-03-07": 65,
+        "2019-03-08": 51,
+        "2019-03-09": 6,
+        "2019-03-10": 1,
+        "2019-03-11": 38,
+        "2019-03-12": 34,
+        "2019-03-13": 31,
+        "2019-03-14": 84,
+        "2019-03-15": 30,
+        "2019-03-16": 0,
+        "2019-03-17": 1,
+        "2019-03-18": 2,
+        "2019-03-19": 0,
+        "2019-03-20": 0,
+        "2019-03-21": 262,
+        "2019-03-22": 26,
+        "2019-03-23": 6,
+        "2019-03-24": 17,
+        "2019-03-25": 72,
+        "2019-03-26": 61,
+        "2019-03-27": 63,
+        "2019-03-28": 72,
+        "2019-03-29": 22,
+        "2019-03-30": 17,
+        "2019-03-31": 3,
+        "2019-04-01": 51,
+        "2019-04-02": 39,
+        "2019-04-03": 202,
+        "2019-04-04": 99,
+        "2019-04-05": 22,
+        "2019-04-06": 2,
+        "2019-04-07": 8,
+        "2019-04-08": 59,
+        "2019-04-09": 191,
+        "2019-04-10": 55,
+        "2019-04-11": 31,
+        "2019-04-12": 17,
+        "2019-04-13": 0,
+        "2019-04-14": 0,
+        "2019-04-15": 35,
+        "2019-04-16": 4,
+        "2019-04-17": 71,
+        "2019-04-18": 60,
+        "2019-04-19": 29,
+        "2019-04-20": 13,
+        "2019-04-21": 5,
+        "2019-04-22": 73,
+        "2019-04-23": 188,
+        "2019-04-24": 42,
+        "2019-04-25": 69,
+        "2019-04-26": 58,
+        "2019-04-27": 3,
+        "2019-04-28": 4,
+        "2019-04-29": 26,
+        "2019-04-30": 77,
+        "2019-05-01": 17,
+        "2019-05-02": 26,
+        "2019-05-03": 59,
+        "2019-05-04": 0,
+        "2019-05-05": 2,
+        "2019-05-06": 47,
+        "2019-05-07": 33,
+        "2019-05-08": 40,
+        "2019-05-09": 42,
+        "2019-05-10": 33,
+        "2019-05-11": 0,
+        "2019-05-12": 1,
+        "2019-05-13": 80,
+        "2019-05-14": 49,
+        "2019-05-15": 68,
+        "2019-05-16": 120,
+        "2019-05-17": 92,
+        "2019-05-18": 1,
+        "2019-05-19": 1,
+        "2019-05-20": 31,
+        "2019-05-21": 11,
+        "2019-05-22": 168,
+        "2019-05-23": 111,
+        "2019-05-24": 146,
+        "2019-05-25": 0,
+        "2019-05-26": 0,
+        "2019-05-27": 4,
+        "2019-05-28": 21,
+        "2019-05-29": 48,
+        "2019-05-30": 29,
+        "2019-05-31": 36,
+        "2019-06-01": 0,
+        "2019-06-02": 3,
+        "2019-06-03": 93,
+        "2019-06-04": 27,
+        "2019-06-05": 156,
+        "2019-06-06": 51,
+        "2019-06-07": 76,
+        "2019-06-08": 0,
+        "2019-06-09": 0,
+        "2019-06-10": 23,
+        "2019-06-11": 41,
+        "2019-06-12": 123,
+        "2019-06-13": 38,
+        "2019-06-14": 45,
+        "2019-06-15": 8,
+        "2019-06-16": 1,
+        "2019-06-17": 69,
+        "2019-06-18": 40,
+        "2019-06-19": 101,
+        "2019-06-20": 56,
+        "2019-06-21": 25,
+        "2019-06-22": 0,
+        "2019-06-23": 3,
+        "2019-06-24": 28,
+        "2019-06-25": 28,
+        "2019-06-26": 35,
+        "2019-06-27": 106,
+        "2019-06-28": 39,
+        "2019-06-29": 13,
+        "2019-06-30": 26,
+        "2019-07-01": 59,
+        "2019-07-02": 69,
+        "2019-07-03": 97,
+        "2019-07-04": 48,
+        "2019-07-05": 59,
+        "2019-07-06": 19,
+        "2019-07-07": 4,
+        "2019-07-08": 33,
+        "2019-07-09": 37,
+        "2019-07-10": 89,
+        "2019-07-11": 84,
+        "2019-07-12": 11,
+        "2019-07-13": 2,
+        "2019-07-14": 6,
+        "2019-07-15": 117,
+        "2019-07-16": 37,
+        "2019-07-17": 68,
+        "2019-07-18": 60,
+        "2019-07-19": 47,
+        "2019-07-20": 3,
+        "2019-07-21": 13,
+        "2019-07-22": 36,
+        "2019-07-23": 244,
+        "2019-07-24": 20,
+        "2019-07-25": 62,
+        "2019-07-26": 43,
+        "2019-07-27": 20,
+        "2019-07-28": 20,
+        "2019-07-29": 54,
+        "2019-07-30": 95,
+        "2019-07-31": 62,
+        "2019-08-01": 162,
+        "2019-08-02": 182,
+        "2019-08-03": 2,
+        "2019-08-04": 0,
+        "2019-08-05": 60,
+        "2019-08-06": 62,
+        "2019-08-07": 77,
+        "2019-08-08": 59,
+        "2019-08-09": 54,
+        "2019-08-10": 4,
+        "2019-08-11": 2,
+        "2019-08-12": 48,
+        "2019-08-13": 69,
+        "2019-08-14": 173,
+        "2019-08-15": 54,
+        "2019-08-16": 47,
+        "2019-08-17": 5,
+        "2019-08-18": 17,
+        "2019-08-19": 39,
+        "2019-08-20": 200,
+        "2019-08-21": 114,
+        "2019-08-22": 111,
+        "2019-08-23": 75,
+        "2019-08-24": 0,
+        "2019-08-25": 2,
+        "2019-08-26": 121,
+        "2019-08-27": 62,
+        "2019-08-28": 68,
+        "2019-08-29": 76,
+        "2019-08-30": 56,
+        "2019-08-31": 0,
+        "2019-09-01": 0,
+        "2019-09-02": 1,
+        "2019-09-03": 36,
+        "2019-09-04": 37,
+        "2019-09-05": 59,
+        "2019-09-06": 55,
+        "2019-09-07": 0,
+        "2019-09-08": 22,
+        "2019-09-09": 97,
+        "2019-09-10": 57,
+        "2019-09-11": 137,
+        "2019-09-12": 42,
+        "2019-09-13": 49,
+        "2019-09-14": 12,
+        "2019-09-15": 8,
+        "2019-09-16": 71,
+        "2019-09-17": 72,
+        "2019-09-18": 41,
+        "2019-09-19": 19,
+        "2019-09-20": 77,
+        "2019-09-21": 17,
+        "2019-09-22": 6,
+        "2019-09-23": 39,
+        "2019-09-24": 30,
+        "2019-09-25": 93,
+        "2019-09-26": 77,
+        "2019-09-27": 309,
+        "2019-09-28": 5,
+        "2019-09-29": 0,
+        "2019-09-30": 63,
+        "2019-10-01": 47,
+        "2019-10-02": 74,
+        "2019-10-03": 52,
+        "2019-10-04": 32,
+        "2019-10-05": 8,
+        "2019-10-06": 13,
+        "2019-10-07": 57,
+        "2019-10-08": 77,
+        "2019-10-09": 103,
+        "2019-10-10": 133,
+        "2019-10-11": 52,
+        "2019-10-12": 9,
+        "2019-10-13": 6,
+        "2019-10-14": 42,
+        "2019-10-15": 19,
+        "2019-10-16": 243,
+        "2019-10-17": 112,
+        "2019-10-18": 13,
+        "2019-10-19": 3,
+        "2019-10-20": 1,
+        "2019-10-21": 37,
+        "2019-10-22": 24,
+        "2019-10-23": 95,
+        "2019-10-24": 39,
+        "2019-10-25": 56,
+        "2019-10-26": 0,
+        "2019-10-27": 0,
+        "2019-10-28": 35,
+        "2019-10-29": 76,
+        "2019-10-30": 33,
+        "2019-10-31": 75,
+        "2019-11-01": 32,
+        "2019-11-02": 10,
+        "2019-11-03": 0,
+        "2019-11-04": 43,
+        "2019-11-05": 87,
+        "2019-11-06": 144,
+        "2019-11-07": 61,
+        "2019-11-08": 30,
+        "2019-11-09": 29,
+        "2019-11-10": 0,
+        "2019-11-11": 10,
+        "2019-11-12": 134,
+        "2019-11-13": 105,
+        "2019-11-14": 267,
+        "2019-11-15": 36,
+        "2019-11-16": 1,
+        "2019-11-17": 6,
+        "2019-11-18": 77,
+        "2019-11-19": 31,
+        "2019-11-20": 42,
+        "2019-11-21": 104,
+        "2019-11-22": 56,
+        "2019-11-23": 1,
+        "2019-11-24": 0,
+        "2019-11-25": 144,
+        "2019-11-26": 128,
+        "2019-11-27": 49,
+        "2019-11-28": 6,
+        "2019-11-29": 38,
+        "2019-11-30": 6,
+        "2019-12-01": 5,
+        "2019-12-02": 41,
+        "2019-12-03": 64,
+        "2019-12-04": 31,
+        "2019-12-05": 52,
+        "2019-12-06": 48,
+        "2019-12-07": 1,
+        "2019-12-08": 9,
+        "2019-12-09": 27,
+        "2019-12-10": 99,
+        "2019-12-11": 65,
+        "2019-12-12": 132,
+        "2019-12-13": 57,
+        "2019-12-14": 2,
+        "2019-12-15": 10,
+        "2019-12-16": 45,
+        "2019-12-17": 75,
+        "2019-12-18": 364,
+        "2019-12-19": 57,
+        "2019-12-20": 36,
+        "2019-12-21": 0,
+        "2019-12-22": 2,
+        "2019-12-23": 56,
+        "2019-12-24": 19,
+        "2019-12-25": 6,
+        "2019-12-26": 72,
+        "2019-12-27": 66,
+        "2019-12-28": 1,
+        "2019-12-29": 5,
+        "2019-12-30": 72,
+        "2019-12-31": 58
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 17305,
+      "severity_distribution": {
+        "UNKNOWN": 17305
+      },
+      "score_distribution": {
+        "4.6": 546,
+        "7.5": 1705,
+        "5.0": 2411,
+        "4.3": 3066,
+        "2.1": 818,
+        "6.8": 1672,
+        "7.2": 672,
+        "10.0": 570,
+        "6.5": 708,
+        "1.9": 76,
+        "6.4": 271,
+        "4.0": 1028,
+        "9.0": 380,
+        "3.6": 92,
+        "2.9": 12,
+        "7.8": 224,
+        "5.5": 207,
+        "5.2": 21,
+        "3.5": 861,
+        "5.8": 414,
+        "4.9": 205,
+        "9.4": 12,
+        "4.4": 104,
+        "3.3": 103,
+        "9.3": 450,
+        "6.3": 3,
+        "6.6": 29,
+        "7.1": 61,
+        "7.9": 7,
+        "2.6": 37,
+        "4.7": 37,
+        "6.0": 61,
+        "6.2": 4,
+        "6.9": 72,
+        "6.1": 31,
+        "8.5": 32,
+        "5.1": 25,
+        "8.7": 2,
+        "4.8": 20,
+        "8.3": 43,
+        "2.7": 15,
+        "7.7": 21,
+        "4.1": 4,
+        "5.4": 11,
+        "7.6": 131,
+        "3.8": 1,
+        "1.2": 6,
+        "5.6": 4,
+        "5.7": 2,
+        "1.7": 2,
+        "8.8": 2,
+        "9.7": 4,
+        "2.3": 3,
+        "3.7": 7
+      }
+    },
+    "v3.0": {
+      "total": 9655,
+      "severity_distribution": {
+        "CRITICAL": 1399,
+        "MEDIUM": 4089,
+        "HIGH": 3960,
+        "LOW": 207
+      },
+      "score_distribution": {
+        "9.8": 1201,
+        "5.5": 398,
+        "8.8": 1196,
+        "6.1": 993,
+        "7.5": 1003,
+        "5.7": 21,
+        "3.8": 14,
+        "2.8": 6,
+        "5.2": 4,
+        "7.0": 44,
+        "5.3": 328,
+        "9.1": 86,
+        "8.1": 176,
+        "5.9": 143,
+        "6.8": 89,
+        "8.6": 77,
+        "9.6": 12,
+        "2.0": 4,
+        "6.5": 751,
+        "7.4": 86,
+        "7.8": 781,
+        "4.3": 221,
+        "5.4": 423,
+        "7.3": 68,
+        "6.4": 29,
+        "3.9": 8,
+        "6.7": 104,
+        "2.7": 16,
+        "4.9": 64,
+        "4.7": 46,
+        "4.8": 132,
+        "1.6": 1,
+        "1.8": 1,
+        "7.1": 83,
+        "7.2": 171,
+        "3.3": 64,
+        "10.0": 35,
+        "6.2": 18,
+        "3.7": 21,
+        "8.5": 9,
+        "2.1": 2,
+        "8.7": 12,
+        "7.7": 35,
+        "8.3": 18,
+        "9.9": 19,
+        "8.2": 94,
+        "8.0": 46,
+        "8.4": 39,
+        "6.3": 45,
+        "2.5": 7,
+        "3.1": 20,
+        "3.5": 15,
+        "4.4": 44,
+        "5.0": 25,
+        "5.8": 43,
+        "4.5": 9,
+        "4.2": 30,
+        "9.0": 24,
+        "4.0": 30,
+        "5.1": 22,
+        "4.6": 28,
+        "9.3": 16,
+        "7.9": 2,
+        "4.1": 11,
+        "2.2": 3,
+        "5.6": 18,
+        "6.0": 10,
+        "7.6": 19,
+        "2.3": 4,
+        "2.9": 5,
+        "2.4": 13,
+        "6.9": 1,
+        "9.4": 6,
+        "6.6": 9,
+        "8.9": 1,
+        "3.4": 1,
+        "3.2": 1,
+        "3.6": 1
+      }
+    },
+    "v3.1": {
+      "total": 9227,
+      "severity_distribution": {
+        "HIGH": 3838,
+        "CRITICAL": 1295,
+        "MEDIUM": 3896,
+        "LOW": 198
+      },
+      "score_distribution": {
+        "7.8": 932,
+        "9.8": 1127,
+        "7.5": 1229,
+        "6.1": 703,
+        "5.5": 527,
+        "8.1": 122,
+        "9.1": 84,
+        "6.5": 846,
+        "3.1": 12,
+        "3.3": 96,
+        "5.6": 12,
+        "8.8": 1039,
+        "5.9": 102,
+        "7.1": 69,
+        "8.0": 33,
+        "5.3": 344,
+        "5.4": 326,
+        "4.8": 88,
+        "4.7": 54,
+        "8.6": 42,
+        "7.2": 141,
+        "8.2": 38,
+        "6.7": 110,
+        "7.3": 48,
+        "3.7": 30,
+        "4.3": 294,
+        "7.4": 40,
+        "2.7": 12,
+        "6.2": 9,
+        "6.3": 23,
+        "4.4": 76,
+        "10.0": 28,
+        "4.6": 56,
+        "7.0": 49,
+        "4.2": 32,
+        "2.4": 15,
+        "2.5": 4,
+        "6.8": 54,
+        "5.7": 17,
+        "7.6": 6,
+        "7.7": 25,
+        "4.9": 117,
+        "5.0": 25,
+        "8.3": 10,
+        "2.6": 2,
+        "5.2": 4,
+        "6.4": 19,
+        "4.1": 7,
+        "5.8": 17,
+        "9.9": 25,
+        "9.3": 6,
+        "9.0": 9,
+        "5.1": 7,
+        "9.4": 5,
+        "6.0": 8,
+        "2.1": 1,
+        "8.5": 1,
+        "3.6": 2,
+        "6.6": 12,
+        "3.4": 2,
+        "2.2": 2,
+        "2.8": 1,
+        "9.6": 11,
+        "2.3": 6,
+        "7.9": 1,
+        "8.7": 3,
+        "3.5": 7,
+        "6.9": 1,
+        "3.8": 1,
+        "1.6": 1,
+        "8.4": 9,
+        "4.0": 4,
+        "3.9": 3,
+        "1.8": 1,
+        "4.5": 2,
+        "8.9": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 1042,
+      "epss_gt_0_5": 263,
+      "epss_gt_0_9": 57
+    }
+  },
+  "kev": {
+    "kev_count": 129
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 1853
+      },
+      {
+        "name": "Debian",
+        "count": 1197
+      },
+      {
+        "name": "Apple",
+        "count": 1108
+      },
+      {
+        "name": "Google",
+        "count": 898
+      },
+      {
+        "name": "Redhat",
+        "count": 809
+      },
+      {
+        "name": "Oracle",
+        "count": 789
+      },
+      {
+        "name": "Canonical",
+        "count": 710
+      },
+      {
+        "name": "Fedoraproject",
+        "count": 703
+      },
+      {
+        "name": "Opensuse",
+        "count": 701
+      },
+      {
+        "name": "Adobe",
+        "count": 569
+      },
+      {
+        "name": "Cisco",
+        "count": 560
+      },
+      {
+        "name": "Ibm",
+        "count": 477
+      },
+      {
+        "name": "Linux",
+        "count": 394
+      },
+      {
+        "name": "Jenkins",
+        "count": 345
+      },
+      {
+        "name": "Netapp",
+        "count": 324
+      },
+      {
+        "name": "Cpanel",
+        "count": 321
+      },
+      {
+        "name": "Qualcomm",
+        "count": 298
+      },
+      {
+        "name": "Intel",
+        "count": 236
+      },
+      {
+        "name": "Hp",
+        "count": 191
+      },
+      {
+        "name": "Siemens",
+        "count": 182
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-79",
+        "count": 2491
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 1347
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 1027
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 997
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 713
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 598
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 597
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 572
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 540
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 527
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 452
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 315
+      },
+      {
+        "cwe": "CWE-476",
+        "count": 263
+      },
+      {
+        "cwe": "CWE-190",
+        "count": 251
+      },
+      {
+        "cwe": "CWE-732",
+        "count": 227
+      },
+      {
+        "cwe": "CWE-434",
+        "count": 223
+      },
+      {
+        "cwe": "CWE-862",
+        "count": 215
+      },
+      {
+        "cwe": "CWE-306",
+        "count": 204
+      },
+      {
+        "cwe": "CWE-522",
+        "count": 194
+      },
+      {
+        "cwe": "CWE-400",
+        "count": 193
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 17139
+      },
+      {
+        "status": "Analyzed",
+        "count": 166
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Third Party Advisory",
+        "count": 51062
+      },
+      {
+        "tag": "Vendor Advisory",
+        "count": 25546
+      },
+      {
+        "tag": "Patch",
+        "count": 12299
+      },
+      {
+        "tag": "Exploit",
+        "count": 11996
+      },
+      {
+        "tag": "Mailing List",
+        "count": 9283
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 9156
+      },
+      {
+        "tag": "Release Notes",
+        "count": 4363
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 3797
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1565
+      },
+      {
+        "tag": "Product",
+        "count": 1235
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 892
+      },
+      {
+        "tag": "Mitigation",
+        "count": 762
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 748
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 328
+      },
+      {
+        "tag": "Technical Description",
+        "count": 136
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 39
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 38
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 8
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:45.963304",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2020.json b/web/data/cve_2020.json
new file mode 100644
index 00000000000..4a0891a7b23
--- /dev/null
+++ b/web/data/cve_2020.json
@@ -0,0 +1,930 @@
+{
+  "year": 2020,
+  "total_cves": 18322,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 1656,
+      "2": 1394,
+      "3": 1754,
+      "4": 2187,
+      "5": 1017,
+      "6": 1786,
+      "7": 1417,
+      "8": 1155,
+      "9": 1593,
+      "10": 1563,
+      "11": 1271,
+      "12": 1529
+    },
+    "daily_analysis": {
+      "total_days": 330,
+      "avg_per_day": 55.52,
+      "highest_day": {
+        "date": "2020-04-15",
+        "count": 508
+      },
+      "lowest_day": {
+        "date": "2020-02-15",
+        "count": 1
+      },
+      "daily_counts": {
+        "2020-01-01": 0,
+        "2020-01-02": 57,
+        "2020-01-03": 54,
+        "2020-01-04": 4,
+        "2020-01-05": 15,
+        "2020-01-06": 63,
+        "2020-01-07": 33,
+        "2020-01-08": 100,
+        "2020-01-09": 75,
+        "2020-01-10": 43,
+        "2020-01-11": 8,
+        "2020-01-12": 0,
+        "2020-01-13": 42,
+        "2020-01-14": 106,
+        "2020-01-15": 280,
+        "2020-01-16": 29,
+        "2020-01-17": 31,
+        "2020-01-18": 6,
+        "2020-01-19": 6,
+        "2020-01-20": 8,
+        "2020-01-21": 77,
+        "2020-01-22": 52,
+        "2020-01-23": 78,
+        "2020-01-24": 65,
+        "2020-01-25": 12,
+        "2020-01-26": 31,
+        "2020-01-27": 100,
+        "2020-01-28": 120,
+        "2020-01-29": 52,
+        "2020-01-30": 58,
+        "2020-01-31": 51,
+        "2020-02-01": 2,
+        "2020-02-02": 3,
+        "2020-02-03": 36,
+        "2020-02-04": 74,
+        "2020-02-05": 64,
+        "2020-02-06": 68,
+        "2020-02-07": 67,
+        "2020-02-08": 25,
+        "2020-02-09": 0,
+        "2020-02-10": 52,
+        "2020-02-11": 205,
+        "2020-02-12": 115,
+        "2020-02-13": 111,
+        "2020-02-14": 52,
+        "2020-02-15": 1,
+        "2020-02-16": 7,
+        "2020-02-17": 58,
+        "2020-02-18": 59,
+        "2020-02-19": 60,
+        "2020-02-20": 53,
+        "2020-02-21": 27,
+        "2020-02-22": 11,
+        "2020-02-23": 6,
+        "2020-02-24": 47,
+        "2020-02-25": 39,
+        "2020-02-26": 36,
+        "2020-02-27": 78,
+        "2020-02-28": 38,
+        "2020-02-29": 0,
+        "2020-03-01": 0,
+        "2020-03-02": 61,
+        "2020-03-03": 14,
+        "2020-03-04": 41,
+        "2020-03-05": 89,
+        "2020-03-06": 21,
+        "2020-03-07": 11,
+        "2020-03-08": 5,
+        "2020-03-09": 69,
+        "2020-03-10": 128,
+        "2020-03-11": 50,
+        "2020-03-12": 307,
+        "2020-03-13": 76,
+        "2020-03-14": 12,
+        "2020-03-15": 26,
+        "2020-03-16": 89,
+        "2020-03-17": 31,
+        "2020-03-18": 71,
+        "2020-03-19": 75,
+        "2020-03-20": 73,
+        "2020-03-21": 5,
+        "2020-03-22": 14,
+        "2020-03-23": 70,
+        "2020-03-24": 175,
+        "2020-03-25": 107,
+        "2020-03-26": 28,
+        "2020-03-27": 43,
+        "2020-03-28": 0,
+        "2020-03-29": 0,
+        "2020-03-30": 34,
+        "2020-03-31": 29,
+        "2020-04-01": 106,
+        "2020-04-02": 57,
+        "2020-04-03": 23,
+        "2020-04-04": 8,
+        "2020-04-05": 3,
+        "2020-04-06": 43,
+        "2020-04-07": 118,
+        "2020-04-08": 147,
+        "2020-04-09": 26,
+        "2020-04-10": 21,
+        "2020-04-11": 0,
+        "2020-04-12": 17,
+        "2020-04-13": 42,
+        "2020-04-14": 74,
+        "2020-04-15": 508,
+        "2020-04-16": 170,
+        "2020-04-17": 74,
+        "2020-04-18": 0,
+        "2020-04-19": 3,
+        "2020-04-20": 65,
+        "2020-04-21": 65,
+        "2020-04-22": 127,
+        "2020-04-23": 84,
+        "2020-04-24": 79,
+        "2020-04-25": 0,
+        "2020-04-26": 3,
+        "2020-04-27": 85,
+        "2020-04-28": 94,
+        "2020-04-29": 89,
+        "2020-04-30": 56,
+        "2020-05-01": 5,
+        "2020-05-02": 3,
+        "2020-05-03": 1,
+        "2020-05-04": 48,
+        "2020-05-05": 39,
+        "2020-05-06": 68,
+        "2020-05-07": 78,
+        "2020-05-08": 40,
+        "2020-05-09": 14,
+        "2020-05-10": 2,
+        "2020-05-11": 47,
+        "2020-05-12": 47,
+        "2020-05-13": 57,
+        "2020-05-14": 74,
+        "2020-05-15": 31,
+        "2020-05-16": 5,
+        "2020-05-17": 3,
+        "2020-05-18": 47,
+        "2020-05-19": 36,
+        "2020-05-20": 29,
+        "2020-05-21": 168,
+        "2020-05-22": 32,
+        "2020-05-23": 2,
+        "2020-05-24": 8,
+        "2020-05-25": 7,
+        "2020-05-26": 24,
+        "2020-05-27": 30,
+        "2020-05-28": 30,
+        "2020-05-29": 42,
+        "2020-05-30": 0,
+        "2020-05-31": 0,
+        "2020-06-01": 38,
+        "2020-06-02": 54,
+        "2020-06-03": 127,
+        "2020-06-04": 96,
+        "2020-06-05": 37,
+        "2020-06-06": 5,
+        "2020-06-07": 8,
+        "2020-06-08": 33,
+        "2020-06-09": 223,
+        "2020-06-10": 73,
+        "2020-06-11": 123,
+        "2020-06-12": 28,
+        "2020-06-13": 0,
+        "2020-06-14": 3,
+        "2020-06-15": 90,
+        "2020-06-16": 53,
+        "2020-06-17": 49,
+        "2020-06-18": 84,
+        "2020-06-19": 193,
+        "2020-06-20": 2,
+        "2020-06-21": 4,
+        "2020-06-22": 84,
+        "2020-06-23": 29,
+        "2020-06-24": 65,
+        "2020-06-25": 74,
+        "2020-06-26": 83,
+        "2020-06-27": 2,
+        "2020-06-28": 3,
+        "2020-06-29": 72,
+        "2020-06-30": 51,
+        "2020-07-01": 71,
+        "2020-07-02": 54,
+        "2020-07-03": 11,
+        "2020-07-04": 1,
+        "2020-07-05": 13,
+        "2020-07-06": 28,
+        "2020-07-07": 67,
+        "2020-07-08": 18,
+        "2020-07-09": 51,
+        "2020-07-10": 24,
+        "2020-07-11": 0,
+        "2020-07-12": 0,
+        "2020-07-13": 19,
+        "2020-07-14": 193,
+        "2020-07-15": 278,
+        "2020-07-16": 53,
+        "2020-07-17": 81,
+        "2020-07-18": 2,
+        "2020-07-19": 0,
+        "2020-07-20": 36,
+        "2020-07-21": 18,
+        "2020-07-22": 71,
+        "2020-07-23": 40,
+        "2020-07-24": 26,
+        "2020-07-25": 7,
+        "2020-07-26": 0,
+        "2020-07-27": 25,
+        "2020-07-28": 86,
+        "2020-07-29": 60,
+        "2020-07-30": 51,
+        "2020-07-31": 33,
+        "2020-08-01": 0,
+        "2020-08-02": 0,
+        "2020-08-03": 32,
+        "2020-08-04": 27,
+        "2020-08-05": 26,
+        "2020-08-06": 24,
+        "2020-08-07": 36,
+        "2020-08-08": 15,
+        "2020-08-09": 3,
+        "2020-08-10": 48,
+        "2020-08-11": 61,
+        "2020-08-12": 62,
+        "2020-08-13": 112,
+        "2020-08-14": 30,
+        "2020-08-15": 0,
+        "2020-08-16": 2,
+        "2020-08-17": 169,
+        "2020-08-18": 17,
+        "2020-08-19": 36,
+        "2020-08-20": 37,
+        "2020-08-21": 70,
+        "2020-08-22": 0,
+        "2020-08-23": 1,
+        "2020-08-24": 41,
+        "2020-08-25": 51,
+        "2020-08-26": 102,
+        "2020-08-27": 54,
+        "2020-08-28": 16,
+        "2020-08-29": 8,
+        "2020-08-30": 7,
+        "2020-08-31": 68,
+        "2020-09-01": 106,
+        "2020-09-02": 42,
+        "2020-09-03": 64,
+        "2020-09-04": 41,
+        "2020-09-05": 1,
+        "2020-09-06": 0,
+        "2020-09-07": 0,
+        "2020-09-08": 52,
+        "2020-09-09": 121,
+        "2020-09-10": 42,
+        "2020-09-11": 180,
+        "2020-09-12": 0,
+        "2020-09-13": 6,
+        "2020-09-14": 60,
+        "2020-09-15": 51,
+        "2020-09-16": 84,
+        "2020-09-17": 138,
+        "2020-09-18": 104,
+        "2020-09-19": 12,
+        "2020-09-20": 0,
+        "2020-09-21": 58,
+        "2020-09-22": 34,
+        "2020-09-23": 72,
+        "2020-09-24": 99,
+        "2020-09-25": 112,
+        "2020-09-26": 0,
+        "2020-09-27": 11,
+        "2020-09-28": 0,
+        "2020-09-29": 12,
+        "2020-09-30": 91,
+        "2020-10-01": 44,
+        "2020-10-02": 72,
+        "2020-10-03": 0,
+        "2020-10-04": 1,
+        "2020-10-05": 23,
+        "2020-10-06": 72,
+        "2020-10-07": 28,
+        "2020-10-08": 54,
+        "2020-10-09": 41,
+        "2020-10-10": 6,
+        "2020-10-11": 0,
+        "2020-10-12": 60,
+        "2020-10-13": 23,
+        "2020-10-14": 51,
+        "2020-10-15": 50,
+        "2020-10-16": 200,
+        "2020-10-17": 1,
+        "2020-10-18": 1,
+        "2020-10-19": 96,
+        "2020-10-20": 49,
+        "2020-10-21": 243,
+        "2020-10-22": 99,
+        "2020-10-23": 27,
+        "2020-10-24": 0,
+        "2020-10-25": 0,
+        "2020-10-26": 28,
+        "2020-10-27": 171,
+        "2020-10-28": 58,
+        "2020-10-29": 52,
+        "2020-10-30": 11,
+        "2020-10-31": 2,
+        "2020-11-01": 1,
+        "2020-11-02": 84,
+        "2020-11-03": 53,
+        "2020-11-04": 40,
+        "2020-11-05": 60,
+        "2020-11-06": 74,
+        "2020-11-07": 3,
+        "2020-11-08": 8,
+        "2020-11-09": 41,
+        "2020-11-10": 58,
+        "2020-11-11": 131,
+        "2020-11-12": 157,
+        "2020-11-13": 35,
+        "2020-11-14": 0,
+        "2020-11-15": 2,
+        "2020-11-16": 83,
+        "2020-11-17": 59,
+        "2020-11-18": 58,
+        "2020-11-19": 66,
+        "2020-11-20": 17,
+        "2020-11-21": 8,
+        "2020-11-22": 0,
+        "2020-11-23": 57,
+        "2020-11-24": 56,
+        "2020-11-25": 14,
+        "2020-11-26": 18,
+        "2020-11-27": 34,
+        "2020-11-28": 9,
+        "2020-11-29": 9,
+        "2020-11-30": 36,
+        "2020-12-01": 33,
+        "2020-12-02": 44,
+        "2020-12-03": 54,
+        "2020-12-04": 26,
+        "2020-12-05": 0,
+        "2020-12-06": 2,
+        "2020-12-07": 19,
+        "2020-12-08": 115,
+        "2020-12-09": 73,
+        "2020-12-10": 95,
+        "2020-12-11": 117,
+        "2020-12-12": 9,
+        "2020-12-13": 0,
+        "2020-12-14": 90,
+        "2020-12-15": 126,
+        "2020-12-16": 48,
+        "2020-12-17": 51,
+        "2020-12-18": 77,
+        "2020-12-19": 0,
+        "2020-12-20": 2,
+        "2020-12-21": 49,
+        "2020-12-22": 44,
+        "2020-12-23": 41,
+        "2020-12-24": 50,
+        "2020-12-25": 9,
+        "2020-12-26": 29,
+        "2020-12-27": 13,
+        "2020-12-28": 43,
+        "2020-12-29": 38,
+        "2020-12-30": 109,
+        "2020-12-31": 123
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 18322,
+      "severity_distribution": {
+        "UNKNOWN": 18322
+      },
+      "score_distribution": {
+        "7.5": 1637,
+        "3.2": 3,
+        "4.3": 2307,
+        "5.0": 2567,
+        "10.0": 611,
+        "3.5": 1145,
+        "7.2": 753,
+        "6.5": 781,
+        "1.9": 103,
+        "6.8": 1334,
+        "9.0": 399,
+        "6.0": 95,
+        "6.4": 307,
+        "1.5": 1,
+        "4.9": 208,
+        "2.1": 1058,
+        "7.8": 229,
+        "6.9": 131,
+        "8.3": 53,
+        "4.0": 1057,
+        "9.3": 464,
+        "3.6": 153,
+        "5.5": 239,
+        "5.8": 620,
+        "4.6": 1004,
+        "2.7": 25,
+        "4.4": 194,
+        "2.6": 39,
+        "8.7": 1,
+        "6.3": 9,
+        "6.6": 20,
+        "7.1": 47,
+        "5.2": 135,
+        "3.3": 185,
+        "4.8": 28,
+        "7.9": 6,
+        "5.1": 39,
+        "2.9": 28,
+        "2.3": 11,
+        "8.5": 51,
+        "9.4": 28,
+        "5.6": 6,
+        "4.1": 3,
+        "6.1": 43,
+        "5.4": 16,
+        "8.8": 2,
+        "4.7": 21,
+        "7.6": 66,
+        "3.7": 17,
+        "7.7": 19,
+        "8.0": 2,
+        "1.2": 7,
+        "7.4": 3,
+        "5.9": 2,
+        "6.7": 1,
+        "1.7": 1,
+        "6.2": 2,
+        "3.0": 1,
+        "5.7": 4,
+        "9.7": 1
+      }
+    },
+    "v3.0": {
+      "total": 2658,
+      "severity_distribution": {
+        "MEDIUM": 1393,
+        "LOW": 112,
+        "CRITICAL": 223,
+        "HIGH": 930
+      },
+      "score_distribution": {
+        "6.3": 49,
+        "5.3": 128,
+        "3.7": 30,
+        "4.3": 158,
+        "6.4": 47,
+        "10.0": 18,
+        "6.7": 39,
+        "8.4": 29,
+        "7.8": 110,
+        "5.2": 32,
+        "6.2": 21,
+        "8.8": 225,
+        "7.7": 13,
+        "4.0": 14,
+        "6.1": 94,
+        "4.2": 14,
+        "7.5": 140,
+        "4.6": 13,
+        "6.8": 132,
+        "5.0": 13,
+        "6.5": 132,
+        "4.7": 38,
+        "7.4": 46,
+        "9.6": 19,
+        "8.6": 56,
+        "4.5": 7,
+        "8.0": 17,
+        "8.1": 36,
+        "7.1": 46,
+        "7.3": 18,
+        "7.6": 15,
+        "4.8": 46,
+        "4.4": 20,
+        "3.2": 2,
+        "8.2": 100,
+        "5.4": 129,
+        "5.7": 5,
+        "6.0": 87,
+        "9.8": 126,
+        "7.2": 49,
+        "4.9": 44,
+        "3.5": 8,
+        "9.1": 22,
+        "8.3": 10,
+        "5.1": 13,
+        "9.0": 11,
+        "5.5": 19,
+        "9.9": 14,
+        "5.9": 61,
+        "3.1": 13,
+        "2.7": 14,
+        "9.4": 7,
+        "2.3": 2,
+        "8.7": 4,
+        "7.0": 10,
+        "6.9": 4,
+        "7.9": 1,
+        "5.6": 6,
+        "2.4": 6,
+        "2.9": 5,
+        "6.6": 3,
+        "3.3": 18,
+        "4.1": 7,
+        "5.8": 18,
+        "3.9": 3,
+        "9.3": 6,
+        "3.8": 4,
+        "3.0": 1,
+        "2.5": 2,
+        "8.5": 5,
+        "2.8": 1,
+        "2.2": 1,
+        "2.6": 1,
+        "3.4": 1
+      }
+    },
+    "v3.1": {
+      "total": 18322,
+      "severity_distribution": {
+        "CRITICAL": 2622,
+        "MEDIUM": 7551,
+        "HIGH": 7663,
+        "LOW": 486
+      },
+      "score_distribution": {
+        "9.8": 2172,
+        "6.8": 262,
+        "5.9": 177,
+        "7.5": 2153,
+        "6.1": 1185,
+        "7.2": 314,
+        "8.8": 1662,
+        "3.3": 149,
+        "6.5": 1136,
+        "5.3": 741,
+        "5.4": 748,
+        "5.5": 977,
+        "9.1": 214,
+        "9.6": 65,
+        "7.8": 2082,
+        "2.4": 47,
+        "4.3": 589,
+        "7.0": 127,
+        "4.8": 345,
+        "8.1": 272,
+        "6.4": 71,
+        "4.9": 180,
+        "7.4": 89,
+        "4.6": 95,
+        "5.7": 46,
+        "6.3": 100,
+        "5.0": 59,
+        "9.9": 43,
+        "7.1": 211,
+        "8.4": 42,
+        "6.6": 44,
+        "9.3": 19,
+        "3.8": 17,
+        "3.5": 42,
+        "10.0": 51,
+        "7.3": 107,
+        "3.7": 62,
+        "2.7": 36,
+        "6.7": 194,
+        "6.2": 40,
+        "4.2": 45,
+        "8.0": 93,
+        "7.7": 80,
+        "2.5": 7,
+        "8.6": 111,
+        "4.0": 15,
+        "4.7": 97,
+        "4.5": 10,
+        "4.4": 149,
+        "2.0": 6,
+        "2.3": 13,
+        "5.8": 49,
+        "8.7": 28,
+        "7.9": 15,
+        "9.0": 45,
+        "8.2": 186,
+        "6.9": 15,
+        "2.9": 1,
+        "5.2": 13,
+        "8.3": 37,
+        "3.1": 32,
+        "9.4": 13,
+        "5.1": 10,
+        "5.6": 24,
+        "7.6": 33,
+        "6.0": 96,
+        "2.8": 10,
+        "4.1": 39,
+        "3.9": 17,
+        "1.6": 1,
+        "2.2": 18,
+        "2.6": 5,
+        "3.0": 6,
+        "3.2": 9,
+        "8.5": 14,
+        "8.9": 7,
+        "3.4": 4,
+        "3.6": 3,
+        "2.1": 1
+      }
+    },
+    "v4.0": {
+      "total": 5,
+      "severity_distribution": {
+        "HIGH": 2,
+        "CRITICAL": 3
+      },
+      "score_distribution": {
+        "7.1": 1,
+        "10.0": 1,
+        "7.3": 1,
+        "9.3": 2
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 900,
+      "epss_gt_0_5": 318,
+      "epss_gt_0_9": 82
+    }
+  },
+  "kev": {
+    "kev_count": 146
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 1882
+      },
+      {
+        "name": "Google",
+        "count": 1257
+      },
+      {
+        "name": "Debian",
+        "count": 1061
+      },
+      {
+        "name": "Oracle",
+        "count": 1039
+      },
+      {
+        "name": "Fedoraproject",
+        "count": 856
+      },
+      {
+        "name": "Opensuse",
+        "count": 785
+      },
+      {
+        "name": "Apple",
+        "count": 697
+      },
+      {
+        "name": "Netgear",
+        "count": 631
+      },
+      {
+        "name": "Canonical",
+        "count": 580
+      },
+      {
+        "name": "Cisco",
+        "count": 568
+      },
+      {
+        "name": "Ibm",
+        "count": 568
+      },
+      {
+        "name": "Netapp",
+        "count": 388
+      },
+      {
+        "name": "Redhat",
+        "count": 351
+      },
+      {
+        "name": "Qualcomm",
+        "count": 319
+      },
+      {
+        "name": "Adobe",
+        "count": 313
+      },
+      {
+        "name": "Linux",
+        "count": 244
+      },
+      {
+        "name": "Intel",
+        "count": 242
+      },
+      {
+        "name": "Gitlab",
+        "count": 241
+      },
+      {
+        "name": "Jenkins",
+        "count": 230
+      },
+      {
+        "name": "Sap",
+        "count": 222
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-79",
+        "count": 2456
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 1471
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 991
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 758
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 641
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 549
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 504
+      },
+      {
+        "cwe": "CWE-120",
+        "count": 434
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 433
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 431
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 397
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 383
+      },
+      {
+        "cwe": "CWE-269",
+        "count": 310
+      },
+      {
+        "cwe": "CWE-306",
+        "count": 296
+      },
+      {
+        "cwe": "CWE-400",
+        "count": 287
+      },
+      {
+        "cwe": "CWE-862",
+        "count": 281
+      },
+      {
+        "cwe": "CWE-434",
+        "count": 248
+      },
+      {
+        "cwe": "CWE-190",
+        "count": 240
+      },
+      {
+        "cwe": "CWE-276",
+        "count": 224
+      },
+      {
+        "cwe": "CWE-798",
+        "count": 221
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 18115
+      },
+      {
+        "status": "Analyzed",
+        "count": 204
+      },
+      {
+        "status": "Undergoing Analysis",
+        "count": 3
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Third Party Advisory",
+        "count": 43130
+      },
+      {
+        "tag": "Vendor Advisory",
+        "count": 30837
+      },
+      {
+        "tag": "Patch",
+        "count": 12641
+      },
+      {
+        "tag": "Exploit",
+        "count": 11396
+      },
+      {
+        "tag": "Mailing List",
+        "count": 8060
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 5597
+      },
+      {
+        "tag": "Release Notes",
+        "count": 4605
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 3124
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 1398
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1369
+      },
+      {
+        "tag": "Product",
+        "count": 1248
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 1211
+      },
+      {
+        "tag": "Mitigation",
+        "count": 485
+      },
+      {
+        "tag": "Technical Description",
+        "count": 358
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 226
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 40
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 24
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 16
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:46.457753",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2021.json b/web/data/cve_2021.json
new file mode 100644
index 00000000000..b9b1ac26a04
--- /dev/null
+++ b/web/data/cve_2021.json
@@ -0,0 +1,924 @@
+{
+  "year": 2021,
+  "total_cves": 20149,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 1524,
+      "2": 1456,
+      "3": 1446,
+      "4": 1818,
+      "5": 1473,
+      "6": 1712,
+      "7": 1582,
+      "8": 2085,
+      "9": 1902,
+      "10": 1701,
+      "11": 1508,
+      "12": 1942
+    },
+    "daily_analysis": {
+      "total_days": 340,
+      "avg_per_day": 59.26,
+      "highest_day": {
+        "date": "2021-04-22",
+        "count": 295
+      },
+      "lowest_day": {
+        "date": "2021-01-31",
+        "count": 1
+      },
+      "daily_counts": {
+        "2021-01-01": 30,
+        "2021-01-02": 2,
+        "2021-01-03": 8,
+        "2021-01-04": 44,
+        "2021-01-05": 48,
+        "2021-01-06": 54,
+        "2021-01-07": 60,
+        "2021-01-08": 97,
+        "2021-01-09": 2,
+        "2021-01-10": 0,
+        "2021-01-11": 84,
+        "2021-01-12": 178,
+        "2021-01-13": 169,
+        "2021-01-14": 32,
+        "2021-01-15": 52,
+        "2021-01-16": 0,
+        "2021-01-17": 2,
+        "2021-01-18": 14,
+        "2021-01-19": 48,
+        "2021-01-20": 236,
+        "2021-01-21": 49,
+        "2021-01-22": 12,
+        "2021-01-23": 0,
+        "2021-01-24": 0,
+        "2021-01-25": 4,
+        "2021-01-26": 160,
+        "2021-01-27": 43,
+        "2021-01-28": 31,
+        "2021-01-29": 60,
+        "2021-01-30": 4,
+        "2021-01-31": 1,
+        "2021-02-01": 47,
+        "2021-02-02": 40,
+        "2021-02-03": 77,
+        "2021-02-04": 113,
+        "2021-02-05": 37,
+        "2021-02-06": 21,
+        "2021-02-07": 5,
+        "2021-02-08": 76,
+        "2021-02-09": 146,
+        "2021-02-10": 113,
+        "2021-02-11": 86,
+        "2021-02-12": 59,
+        "2021-02-13": 2,
+        "2021-02-14": 4,
+        "2021-02-15": 41,
+        "2021-02-16": 55,
+        "2021-02-17": 110,
+        "2021-02-18": 37,
+        "2021-02-19": 44,
+        "2021-02-20": 2,
+        "2021-02-21": 1,
+        "2021-02-22": 71,
+        "2021-02-23": 64,
+        "2021-02-24": 41,
+        "2021-02-25": 74,
+        "2021-02-26": 74,
+        "2021-02-27": 16,
+        "2021-02-28": 0,
+        "2021-03-01": 29,
+        "2021-03-02": 33,
+        "2021-03-03": 63,
+        "2021-03-04": 66,
+        "2021-03-05": 62,
+        "2021-03-06": 1,
+        "2021-03-07": 6,
+        "2021-03-08": 25,
+        "2021-03-09": 90,
+        "2021-03-10": 100,
+        "2021-03-11": 121,
+        "2021-03-12": 44,
+        "2021-03-13": 5,
+        "2021-03-14": 0,
+        "2021-03-15": 65,
+        "2021-03-16": 22,
+        "2021-03-17": 38,
+        "2021-03-18": 93,
+        "2021-03-19": 45,
+        "2021-03-20": 6,
+        "2021-03-21": 6,
+        "2021-03-22": 40,
+        "2021-03-23": 77,
+        "2021-03-24": 86,
+        "2021-03-25": 71,
+        "2021-03-26": 72,
+        "2021-03-27": 2,
+        "2021-03-28": 0,
+        "2021-03-29": 41,
+        "2021-03-30": 81,
+        "2021-03-31": 56,
+        "2021-04-01": 64,
+        "2021-04-02": 178,
+        "2021-04-03": 1,
+        "2021-04-04": 0,
+        "2021-04-05": 65,
+        "2021-04-06": 89,
+        "2021-04-07": 62,
+        "2021-04-08": 64,
+        "2021-04-09": 55,
+        "2021-04-10": 2,
+        "2021-04-11": 9,
+        "2021-04-12": 56,
+        "2021-04-13": 206,
+        "2021-04-14": 74,
+        "2021-04-15": 54,
+        "2021-04-16": 21,
+        "2021-04-17": 4,
+        "2021-04-18": 8,
+        "2021-04-19": 44,
+        "2021-04-20": 30,
+        "2021-04-21": 40,
+        "2021-04-22": 295,
+        "2021-04-23": 48,
+        "2021-04-24": 4,
+        "2021-04-25": 6,
+        "2021-04-26": 68,
+        "2021-04-27": 50,
+        "2021-04-28": 58,
+        "2021-04-29": 112,
+        "2021-04-30": 51,
+        "2021-05-01": 0,
+        "2021-05-02": 1,
+        "2021-05-03": 19,
+        "2021-05-04": 13,
+        "2021-05-05": 57,
+        "2021-05-06": 134,
+        "2021-05-07": 105,
+        "2021-05-08": 0,
+        "2021-05-09": 0,
+        "2021-05-10": 56,
+        "2021-05-11": 141,
+        "2021-05-12": 43,
+        "2021-05-13": 64,
+        "2021-05-14": 168,
+        "2021-05-15": 2,
+        "2021-05-16": 5,
+        "2021-05-17": 76,
+        "2021-05-18": 41,
+        "2021-05-19": 29,
+        "2021-05-20": 59,
+        "2021-05-21": 43,
+        "2021-05-22": 18,
+        "2021-05-23": 0,
+        "2021-05-24": 78,
+        "2021-05-25": 66,
+        "2021-05-26": 100,
+        "2021-05-27": 88,
+        "2021-05-28": 61,
+        "2021-05-29": 4,
+        "2021-05-30": 0,
+        "2021-05-31": 2,
+        "2021-06-01": 96,
+        "2021-06-02": 76,
+        "2021-06-03": 50,
+        "2021-06-04": 63,
+        "2021-06-05": 0,
+        "2021-06-06": 7,
+        "2021-06-07": 63,
+        "2021-06-08": 108,
+        "2021-06-09": 184,
+        "2021-06-10": 74,
+        "2021-06-11": 159,
+        "2021-06-12": 14,
+        "2021-06-13": 1,
+        "2021-06-14": 32,
+        "2021-06-15": 56,
+        "2021-06-16": 86,
+        "2021-06-17": 32,
+        "2021-06-18": 41,
+        "2021-06-19": 0,
+        "2021-06-20": 1,
+        "2021-06-21": 82,
+        "2021-06-22": 104,
+        "2021-06-23": 31,
+        "2021-06-24": 105,
+        "2021-06-25": 47,
+        "2021-06-26": 0,
+        "2021-06-27": 1,
+        "2021-06-28": 72,
+        "2021-06-29": 61,
+        "2021-06-30": 66,
+        "2021-07-01": 57,
+        "2021-07-02": 63,
+        "2021-07-03": 0,
+        "2021-07-04": 0,
+        "2021-07-05": 5,
+        "2021-07-06": 27,
+        "2021-07-07": 108,
+        "2021-07-08": 66,
+        "2021-07-09": 61,
+        "2021-07-10": 2,
+        "2021-07-11": 4,
+        "2021-07-12": 88,
+        "2021-07-13": 139,
+        "2021-07-14": 171,
+        "2021-07-15": 82,
+        "2021-07-16": 58,
+        "2021-07-17": 6,
+        "2021-07-18": 1,
+        "2021-07-19": 60,
+        "2021-07-20": 44,
+        "2021-07-21": 215,
+        "2021-07-22": 91,
+        "2021-07-23": 20,
+        "2021-07-24": 1,
+        "2021-07-25": 34,
+        "2021-07-26": 62,
+        "2021-07-27": 6,
+        "2021-07-28": 11,
+        "2021-07-29": 11,
+        "2021-07-30": 83,
+        "2021-07-31": 6,
+        "2021-08-01": 1,
+        "2021-08-02": 116,
+        "2021-08-03": 117,
+        "2021-08-04": 84,
+        "2021-08-05": 91,
+        "2021-08-06": 52,
+        "2021-08-07": 11,
+        "2021-08-08": 68,
+        "2021-08-09": 68,
+        "2021-08-10": 86,
+        "2021-08-11": 125,
+        "2021-08-12": 167,
+        "2021-08-13": 65,
+        "2021-08-14": 1,
+        "2021-08-15": 3,
+        "2021-08-16": 106,
+        "2021-08-17": 72,
+        "2021-08-18": 95,
+        "2021-08-19": 36,
+        "2021-08-20": 73,
+        "2021-08-21": 1,
+        "2021-08-22": 6,
+        "2021-08-23": 94,
+        "2021-08-24": 222,
+        "2021-08-25": 68,
+        "2021-08-26": 59,
+        "2021-08-27": 33,
+        "2021-08-28": 1,
+        "2021-08-29": 8,
+        "2021-08-30": 87,
+        "2021-08-31": 69,
+        "2021-09-01": 115,
+        "2021-09-02": 54,
+        "2021-09-03": 27,
+        "2021-09-04": 1,
+        "2021-09-05": 4,
+        "2021-09-06": 37,
+        "2021-09-07": 122,
+        "2021-09-08": 278,
+        "2021-09-09": 140,
+        "2021-09-10": 50,
+        "2021-09-11": 2,
+        "2021-09-12": 2,
+        "2021-09-13": 66,
+        "2021-09-14": 100,
+        "2021-09-15": 153,
+        "2021-09-16": 48,
+        "2021-09-17": 50,
+        "2021-09-18": 4,
+        "2021-09-19": 2,
+        "2021-09-20": 169,
+        "2021-09-21": 25,
+        "2021-09-22": 29,
+        "2021-09-23": 104,
+        "2021-09-24": 26,
+        "2021-09-25": 1,
+        "2021-09-26": 2,
+        "2021-09-27": 115,
+        "2021-09-28": 51,
+        "2021-09-29": 72,
+        "2021-09-30": 53,
+        "2021-10-01": 65,
+        "2021-10-02": 5,
+        "2021-10-03": 0,
+        "2021-10-04": 95,
+        "2021-10-05": 58,
+        "2021-10-06": 123,
+        "2021-10-07": 68,
+        "2021-10-08": 61,
+        "2021-10-09": 0,
+        "2021-10-10": 1,
+        "2021-10-11": 66,
+        "2021-10-12": 72,
+        "2021-10-13": 116,
+        "2021-10-14": 34,
+        "2021-10-15": 59,
+        "2021-10-16": 0,
+        "2021-10-17": 0,
+        "2021-10-18": 64,
+        "2021-10-19": 120,
+        "2021-10-20": 191,
+        "2021-10-21": 59,
+        "2021-10-22": 99,
+        "2021-10-23": 0,
+        "2021-10-24": 0,
+        "2021-10-25": 84,
+        "2021-10-26": 43,
+        "2021-10-27": 70,
+        "2021-10-28": 105,
+        "2021-10-29": 31,
+        "2021-10-30": 1,
+        "2021-10-31": 11,
+        "2021-11-01": 69,
+        "2021-11-02": 86,
+        "2021-11-03": 88,
+        "2021-11-04": 52,
+        "2021-11-05": 100,
+        "2021-11-06": 0,
+        "2021-11-07": 6,
+        "2021-11-08": 89,
+        "2021-11-09": 69,
+        "2021-11-10": 132,
+        "2021-11-11": 23,
+        "2021-11-12": 72,
+        "2021-11-13": 14,
+        "2021-11-14": 17,
+        "2021-11-15": 65,
+        "2021-11-16": 51,
+        "2021-11-17": 104,
+        "2021-11-18": 66,
+        "2021-11-19": 76,
+        "2021-11-20": 19,
+        "2021-11-21": 1,
+        "2021-11-22": 50,
+        "2021-11-23": 90,
+        "2021-11-24": 46,
+        "2021-11-25": 1,
+        "2021-11-26": 17,
+        "2021-11-27": 1,
+        "2021-11-28": 2,
+        "2021-11-29": 52,
+        "2021-11-30": 50,
+        "2021-12-01": 73,
+        "2021-12-02": 38,
+        "2021-12-03": 31,
+        "2021-12-04": 1,
+        "2021-12-05": 6,
+        "2021-12-06": 52,
+        "2021-12-07": 136,
+        "2021-12-08": 139,
+        "2021-12-09": 52,
+        "2021-12-10": 33,
+        "2021-12-11": 1,
+        "2021-12-12": 4,
+        "2021-12-13": 108,
+        "2021-12-14": 114,
+        "2021-12-15": 252,
+        "2021-12-16": 44,
+        "2021-12-17": 65,
+        "2021-12-18": 3,
+        "2021-12-19": 3,
+        "2021-12-20": 70,
+        "2021-12-21": 65,
+        "2021-12-22": 117,
+        "2021-12-23": 94,
+        "2021-12-24": 15,
+        "2021-12-25": 11,
+        "2021-12-26": 220,
+        "2021-12-27": 94,
+        "2021-12-28": 28,
+        "2021-12-29": 21,
+        "2021-12-30": 50,
+        "2021-12-31": 2
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 20149,
+      "severity_distribution": {
+        "UNKNOWN": 20149
+      },
+      "score_distribution": {
+        "5.0": 2632,
+        "4.3": 2826,
+        "2.1": 1123,
+        "5.5": 312,
+        "6.8": 2089,
+        "7.5": 1785,
+        "4.6": 1030,
+        "7.2": 674,
+        "5.8": 483,
+        "9.3": 347,
+        "10.0": 371,
+        "6.5": 1060,
+        "3.5": 1530,
+        "4.0": 1240,
+        "8.8": 6,
+        "6.4": 326,
+        "3.6": 162,
+        "7.1": 57,
+        "9.0": 445,
+        "4.9": 191,
+        "2.3": 11,
+        "5.2": 76,
+        "3.8": 2,
+        "2.7": 28,
+        "2.6": 40,
+        "4.4": 172,
+        "4.1": 6,
+        "6.9": 139,
+        "7.8": 186,
+        "3.3": 158,
+        "6.0": 136,
+        "8.3": 61,
+        "8.5": 63,
+        "5.1": 47,
+        "2.9": 39,
+        "6.1": 38,
+        "7.9": 11,
+        "1.9": 82,
+        "1.8": 2,
+        "7.7": 20,
+        "4.8": 15,
+        "9.4": 18,
+        "6.2": 5,
+        "6.7": 1,
+        "6.6": 19,
+        "4.7": 17,
+        "5.6": 7,
+        "3.2": 1,
+        "6.3": 12,
+        "7.6": 21,
+        "5.7": 3,
+        "1.2": 4,
+        "7.0": 1,
+        "8.7": 2,
+        "5.9": 1,
+        "5.4": 10,
+        "8.0": 3,
+        "1.4": 1,
+        "1.7": 1,
+        "7.4": 1
+      }
+    },
+    "v3.0": {
+      "total": 1644,
+      "severity_distribution": {
+        "HIGH": 596,
+        "MEDIUM": 828,
+        "LOW": 101,
+        "CRITICAL": 119
+      },
+      "score_distribution": {
+        "8.8": 142,
+        "5.9": 72,
+        "3.7": 14,
+        "4.2": 5,
+        "9.4": 2,
+        "7.4": 15,
+        "5.3": 69,
+        "5.4": 139,
+        "4.3": 133,
+        "4.6": 9,
+        "7.1": 23,
+        "8.2": 18,
+        "4.8": 14,
+        "4.7": 12,
+        "4.4": 20,
+        "5.5": 16,
+        "2.3": 1,
+        "6.7": 10,
+        "6.5": 81,
+        "6.1": 34,
+        "9.3": 6,
+        "7.5": 59,
+        "6.4": 56,
+        "5.7": 3,
+        "2.9": 1,
+        "4.0": 24,
+        "4.1": 3,
+        "6.2": 22,
+        "7.6": 8,
+        "2.6": 2,
+        "8.6": 9,
+        "3.1": 11,
+        "5.1": 9,
+        "8.1": 32,
+        "6.3": 25,
+        "9.6": 14,
+        "3.4": 2,
+        "6.9": 2,
+        "7.8": 206,
+        "3.3": 49,
+        "8.0": 12,
+        "9.8": 33,
+        "7.2": 4,
+        "6.8": 21,
+        "7.7": 31,
+        "4.9": 19,
+        "10.0": 19,
+        "8.4": 8,
+        "5.8": 3,
+        "2.4": 2,
+        "9.9": 17,
+        "3.6": 1,
+        "2.7": 11,
+        "9.1": 24,
+        "5.6": 5,
+        "6.6": 7,
+        "7.0": 4,
+        "8.3": 5,
+        "3.2": 2,
+        "6.0": 8,
+        "7.3": 18,
+        "9.0": 4,
+        "4.5": 2,
+        "3.5": 2,
+        "5.2": 2,
+        "7.9": 1,
+        "5.0": 3,
+        "2.5": 1,
+        "3.8": 1,
+        "3.9": 1,
+        "8.7": 1
+      }
+    },
+    "v3.1": {
+      "total": 20045,
+      "severity_distribution": {
+        "HIGH": 8405,
+        "MEDIUM": 8457,
+        "CRITICAL": 2552,
+        "LOW": 631
+      },
+      "score_distribution": {
+        "7.5": 2143,
+        "6.5": 1311,
+        "5.9": 228,
+        "5.5": 1228,
+        "8.1": 468,
+        "7.8": 2195,
+        "9.8": 1905,
+        "6.1": 1260,
+        "3.7": 52,
+        "4.3": 558,
+        "8.8": 1698,
+        "5.4": 1071,
+        "9.6": 139,
+        "4.8": 349,
+        "10.0": 83,
+        "5.3": 716,
+        "7.1": 229,
+        "6.8": 199,
+        "3.3": 208,
+        "4.9": 255,
+        "2.6": 10,
+        "9.1": 286,
+        "3.1": 43,
+        "7.3": 179,
+        "3.5": 55,
+        "9.9": 59,
+        "4.1": 26,
+        "7.2": 482,
+        "6.3": 113,
+        "7.0": 119,
+        "8.2": 170,
+        "7.4": 97,
+        "9.0": 49,
+        "4.4": 195,
+        "3.8": 16,
+        "6.7": 239,
+        "5.1": 15,
+        "4.7": 87,
+        "2.3": 12,
+        "6.4": 71,
+        "6.6": 33,
+        "9.3": 22,
+        "5.8": 47,
+        "2.7": 40,
+        "7.7": 74,
+        "4.5": 19,
+        "8.7": 28,
+        "5.7": 66,
+        "3.9": 21,
+        "6.0": 66,
+        "8.0": 105,
+        "4.6": 66,
+        "8.6": 124,
+        "6.9": 15,
+        "2.9": 7,
+        "3.6": 5,
+        "5.2": 19,
+        "8.3": 47,
+        "5.0": 46,
+        "7.6": 60,
+        "4.0": 47,
+        "8.4": 138,
+        "6.2": 42,
+        "4.2": 38,
+        "2.4": 21,
+        "2.5": 105,
+        "7.9": 11,
+        "5.6": 32,
+        "3.2": 14,
+        "8.5": 30,
+        "2.2": 3,
+        "3.0": 3,
+        "2.8": 2,
+        "2.1": 1,
+        "2.0": 5,
+        "1.8": 3,
+        "1.9": 2,
+        "9.4": 9,
+        "8.9": 8,
+        "3.4": 2,
+        "1.7": 1
+      }
+    },
+    "v4.0": {
+      "total": 10,
+      "severity_distribution": {
+        "HIGH": 6,
+        "MEDIUM": 4
+      },
+      "score_distribution": {
+        "8.7": 4,
+        "8.6": 2,
+        "6.9": 1,
+        "5.9": 3
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 1018,
+      "epss_gt_0_5": 426,
+      "epss_gt_0_9": 89
+    }
+  },
+  "kev": {
+    "kev_count": 214
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 1713
+      },
+      {
+        "name": "Google",
+        "count": 1252
+      },
+      {
+        "name": "Fedoraproject",
+        "count": 1137
+      },
+      {
+        "name": "Debian",
+        "count": 1076
+      },
+      {
+        "name": "Oracle",
+        "count": 909
+      },
+      {
+        "name": "Apple",
+        "count": 778
+      },
+      {
+        "name": "Ibm",
+        "count": 608
+      },
+      {
+        "name": "Cisco",
+        "count": 591
+      },
+      {
+        "name": "Netapp",
+        "count": 548
+      },
+      {
+        "name": "Siemens",
+        "count": 450
+      },
+      {
+        "name": "Linux",
+        "count": 430
+      },
+      {
+        "name": "Adobe",
+        "count": 408
+      },
+      {
+        "name": "Huawei",
+        "count": 327
+      },
+      {
+        "name": "Netgear",
+        "count": 285
+      },
+      {
+        "name": "Redhat",
+        "count": 282
+      },
+      {
+        "name": "Qualcomm",
+        "count": 262
+      },
+      {
+        "name": "Apache",
+        "count": 211
+      },
+      {
+        "name": "Intel",
+        "count": 208
+      },
+      {
+        "name": "Sap",
+        "count": 204
+      },
+      {
+        "name": "Dell",
+        "count": 177
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-79",
+        "count": 3191
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 1730
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 892
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 856
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 780
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 665
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 636
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 594
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 574
+      },
+      {
+        "cwe": "CWE-120",
+        "count": 480
+      },
+      {
+        "cwe": "CWE-476",
+        "count": 426
+      },
+      {
+        "cwe": "CWE-269",
+        "count": 374
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 357
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 353
+      },
+      {
+        "cwe": "CWE-434",
+        "count": 347
+      },
+      {
+        "cwe": "CWE-77",
+        "count": 323
+      },
+      {
+        "cwe": "CWE-863",
+        "count": 322
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 316
+      },
+      {
+        "cwe": "CWE-862",
+        "count": 299
+      },
+      {
+        "cwe": "CWE-502",
+        "count": 299
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 19810
+      },
+      {
+        "status": "Analyzed",
+        "count": 339
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Third Party Advisory",
+        "count": 44359
+      },
+      {
+        "tag": "Vendor Advisory",
+        "count": 30173
+      },
+      {
+        "tag": "Patch",
+        "count": 15925
+      },
+      {
+        "tag": "Exploit",
+        "count": 14835
+      },
+      {
+        "tag": "Mailing List",
+        "count": 5412
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 4855
+      },
+      {
+        "tag": "Release Notes",
+        "count": 4720
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 4385
+      },
+      {
+        "tag": "Product",
+        "count": 2055
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 1600
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1160
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 1073
+      },
+      {
+        "tag": "Mitigation",
+        "count": 635
+      },
+      {
+        "tag": "Technical Description",
+        "count": 518
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 394
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 34
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 22
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 10
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:47.068773",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2022.json b/web/data/cve_2022.json
new file mode 100644
index 00000000000..120bda51056
--- /dev/null
+++ b/web/data/cve_2022.json
@@ -0,0 +1,946 @@
+{
+  "year": 2022,
+  "total_cves": 25074,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 2016,
+      "2": 1942,
+      "3": 2058,
+      "4": 2046,
+      "5": 2021,
+      "6": 2280,
+      "7": 1969,
+      "8": 2317,
+      "9": 2197,
+      "10": 1849,
+      "11": 1958,
+      "12": 2421
+    },
+    "daily_analysis": {
+      "total_days": 352,
+      "avg_per_day": 71.23,
+      "highest_day": {
+        "date": "2022-06-02",
+        "count": 320
+      },
+      "lowest_day": {
+        "date": "2022-05-22",
+        "count": 1
+      },
+      "daily_counts": {
+        "2022-01-01": 41,
+        "2022-01-02": 3,
+        "2022-01-03": 104,
+        "2022-01-04": 53,
+        "2022-01-05": 31,
+        "2022-01-06": 60,
+        "2022-01-07": 2,
+        "2022-01-08": 0,
+        "2022-01-09": 0,
+        "2022-01-10": 171,
+        "2022-01-11": 134,
+        "2022-01-12": 65,
+        "2022-01-13": 156,
+        "2022-01-14": 148,
+        "2022-01-15": 15,
+        "2022-01-16": 3,
+        "2022-01-17": 35,
+        "2022-01-18": 85,
+        "2022-01-19": 229,
+        "2022-01-20": 64,
+        "2022-01-21": 84,
+        "2022-01-22": 3,
+        "2022-01-23": 4,
+        "2022-01-24": 78,
+        "2022-01-25": 102,
+        "2022-01-26": 51,
+        "2022-01-27": 87,
+        "2022-01-28": 166,
+        "2022-01-29": 6,
+        "2022-01-30": 8,
+        "2022-01-31": 28,
+        "2022-02-01": 72,
+        "2022-02-02": 28,
+        "2022-02-03": 47,
+        "2022-02-04": 218,
+        "2022-02-05": 3,
+        "2022-02-06": 11,
+        "2022-02-07": 50,
+        "2022-02-08": 39,
+        "2022-02-09": 271,
+        "2022-02-10": 47,
+        "2022-02-11": 139,
+        "2022-02-12": 46,
+        "2022-02-13": 0,
+        "2022-02-14": 79,
+        "2022-02-15": 91,
+        "2022-02-16": 93,
+        "2022-02-17": 34,
+        "2022-02-18": 214,
+        "2022-02-19": 26,
+        "2022-02-20": 13,
+        "2022-02-21": 49,
+        "2022-02-22": 20,
+        "2022-02-23": 22,
+        "2022-02-24": 146,
+        "2022-02-25": 83,
+        "2022-02-26": 18,
+        "2022-02-27": 2,
+        "2022-02-28": 81,
+        "2022-03-01": 47,
+        "2022-03-02": 72,
+        "2022-03-03": 61,
+        "2022-03-04": 55,
+        "2022-03-05": 7,
+        "2022-03-06": 11,
+        "2022-03-07": 50,
+        "2022-03-08": 34,
+        "2022-03-09": 96,
+        "2022-03-10": 239,
+        "2022-03-11": 95,
+        "2022-03-12": 9,
+        "2022-03-13": 10,
+        "2022-03-14": 91,
+        "2022-03-15": 94,
+        "2022-03-16": 148,
+        "2022-03-17": 56,
+        "2022-03-18": 159,
+        "2022-03-19": 2,
+        "2022-03-20": 13,
+        "2022-03-21": 62,
+        "2022-03-22": 23,
+        "2022-03-23": 98,
+        "2022-03-24": 43,
+        "2022-03-25": 77,
+        "2022-03-26": 10,
+        "2022-03-27": 8,
+        "2022-03-28": 110,
+        "2022-03-29": 95,
+        "2022-03-30": 137,
+        "2022-03-31": 46,
+        "2022-04-01": 102,
+        "2022-04-02": 4,
+        "2022-04-03": 25,
+        "2022-04-04": 100,
+        "2022-04-05": 128,
+        "2022-04-06": 59,
+        "2022-04-07": 46,
+        "2022-04-08": 58,
+        "2022-04-09": 7,
+        "2022-04-10": 39,
+        "2022-04-11": 186,
+        "2022-04-12": 163,
+        "2022-04-13": 59,
+        "2022-04-14": 110,
+        "2022-04-15": 232,
+        "2022-04-16": 6,
+        "2022-04-17": 0,
+        "2022-04-18": 101,
+        "2022-04-19": 129,
+        "2022-04-20": 43,
+        "2022-04-21": 109,
+        "2022-04-22": 44,
+        "2022-04-23": 2,
+        "2022-04-24": 3,
+        "2022-04-25": 79,
+        "2022-04-26": 36,
+        "2022-04-27": 63,
+        "2022-04-28": 57,
+        "2022-04-29": 50,
+        "2022-04-30": 6,
+        "2022-05-01": 22,
+        "2022-05-02": 81,
+        "2022-05-03": 109,
+        "2022-05-04": 77,
+        "2022-05-05": 121,
+        "2022-05-06": 79,
+        "2022-05-07": 4,
+        "2022-05-08": 5,
+        "2022-05-09": 44,
+        "2022-05-10": 171,
+        "2022-05-11": 174,
+        "2022-05-12": 157,
+        "2022-05-13": 89,
+        "2022-05-14": 3,
+        "2022-05-15": 7,
+        "2022-05-16": 97,
+        "2022-05-17": 111,
+        "2022-05-18": 77,
+        "2022-05-19": 39,
+        "2022-05-20": 124,
+        "2022-05-21": 18,
+        "2022-05-22": 1,
+        "2022-05-23": 47,
+        "2022-05-24": 75,
+        "2022-05-25": 59,
+        "2022-05-26": 153,
+        "2022-05-27": 26,
+        "2022-05-28": 0,
+        "2022-05-29": 2,
+        "2022-05-30": 26,
+        "2022-05-31": 23,
+        "2022-06-01": 16,
+        "2022-06-02": 320,
+        "2022-06-03": 25,
+        "2022-06-04": 0,
+        "2022-06-05": 2,
+        "2022-06-06": 61,
+        "2022-06-07": 78,
+        "2022-06-08": 79,
+        "2022-06-09": 101,
+        "2022-06-10": 44,
+        "2022-06-11": 8,
+        "2022-06-12": 10,
+        "2022-06-13": 147,
+        "2022-06-14": 197,
+        "2022-06-15": 255,
+        "2022-06-16": 100,
+        "2022-06-17": 56,
+        "2022-06-18": 20,
+        "2022-06-19": 16,
+        "2022-06-20": 60,
+        "2022-06-21": 63,
+        "2022-06-22": 18,
+        "2022-06-23": 123,
+        "2022-06-24": 135,
+        "2022-06-25": 7,
+        "2022-06-26": 4,
+        "2022-06-27": 125,
+        "2022-06-28": 63,
+        "2022-06-29": 49,
+        "2022-06-30": 98,
+        "2022-07-01": 87,
+        "2022-07-02": 9,
+        "2022-07-03": 3,
+        "2022-07-04": 38,
+        "2022-07-05": 31,
+        "2022-07-06": 93,
+        "2022-07-07": 47,
+        "2022-07-08": 26,
+        "2022-07-09": 1,
+        "2022-07-10": 2,
+        "2022-07-11": 144,
+        "2022-07-12": 247,
+        "2022-07-13": 53,
+        "2022-07-14": 68,
+        "2022-07-15": 75,
+        "2022-07-16": 12,
+        "2022-07-17": 67,
+        "2022-07-18": 106,
+        "2022-07-19": 142,
+        "2022-07-20": 89,
+        "2022-07-21": 57,
+        "2022-07-22": 82,
+        "2022-07-23": 25,
+        "2022-07-24": 3,
+        "2022-07-25": 102,
+        "2022-07-26": 115,
+        "2022-07-27": 110,
+        "2022-07-28": 96,
+        "2022-07-29": 33,
+        "2022-07-30": 6,
+        "2022-07-31": 0,
+        "2022-08-01": 123,
+        "2022-08-02": 53,
+        "2022-08-03": 44,
+        "2022-08-04": 58,
+        "2022-08-05": 169,
+        "2022-08-06": 12,
+        "2022-08-07": 1,
+        "2022-08-08": 46,
+        "2022-08-09": 124,
+        "2022-08-10": 134,
+        "2022-08-11": 94,
+        "2022-08-12": 164,
+        "2022-08-13": 0,
+        "2022-08-14": 0,
+        "2022-08-15": 64,
+        "2022-08-16": 162,
+        "2022-08-17": 48,
+        "2022-08-18": 127,
+        "2022-08-19": 49,
+        "2022-08-20": 3,
+        "2022-08-21": 4,
+        "2022-08-22": 114,
+        "2022-08-23": 90,
+        "2022-08-24": 65,
+        "2022-08-25": 222,
+        "2022-08-26": 66,
+        "2022-08-27": 9,
+        "2022-08-28": 25,
+        "2022-08-29": 108,
+        "2022-08-30": 52,
+        "2022-08-31": 87,
+        "2022-09-01": 69,
+        "2022-09-02": 76,
+        "2022-09-03": 1,
+        "2022-09-04": 1,
+        "2022-09-05": 40,
+        "2022-09-06": 157,
+        "2022-09-07": 54,
+        "2022-09-08": 62,
+        "2022-09-09": 131,
+        "2022-09-10": 0,
+        "2022-09-11": 7,
+        "2022-09-12": 51,
+        "2022-09-13": 201,
+        "2022-09-14": 48,
+        "2022-09-15": 86,
+        "2022-09-16": 255,
+        "2022-09-17": 8,
+        "2022-09-18": 7,
+        "2022-09-19": 122,
+        "2022-09-20": 88,
+        "2022-09-21": 95,
+        "2022-09-22": 60,
+        "2022-09-23": 204,
+        "2022-09-24": 7,
+        "2022-09-25": 3,
+        "2022-09-26": 105,
+        "2022-09-27": 32,
+        "2022-09-28": 73,
+        "2022-09-29": 87,
+        "2022-09-30": 67,
+        "2022-10-01": 1,
+        "2022-10-02": 2,
+        "2022-10-03": 49,
+        "2022-10-04": 0,
+        "2022-10-05": 0,
+        "2022-10-06": 66,
+        "2022-10-07": 115,
+        "2022-10-08": 3,
+        "2022-10-09": 2,
+        "2022-10-10": 47,
+        "2022-10-11": 260,
+        "2022-10-12": 65,
+        "2022-10-13": 63,
+        "2022-10-14": 191,
+        "2022-10-15": 4,
+        "2022-10-16": 7,
+        "2022-10-17": 118,
+        "2022-10-18": 165,
+        "2022-10-19": 139,
+        "2022-10-20": 35,
+        "2022-10-21": 58,
+        "2022-10-22": 1,
+        "2022-10-23": 0,
+        "2022-10-24": 30,
+        "2022-10-25": 125,
+        "2022-10-26": 59,
+        "2022-10-27": 57,
+        "2022-10-28": 84,
+        "2022-10-29": 6,
+        "2022-10-30": 7,
+        "2022-10-31": 90,
+        "2022-11-01": 208,
+        "2022-11-02": 69,
+        "2022-11-03": 86,
+        "2022-11-04": 48,
+        "2022-11-05": 2,
+        "2022-11-06": 3,
+        "2022-11-07": 64,
+        "2022-11-08": 119,
+        "2022-11-09": 172,
+        "2022-11-10": 54,
+        "2022-11-11": 86,
+        "2022-11-12": 13,
+        "2022-11-13": 15,
+        "2022-11-14": 81,
+        "2022-11-15": 160,
+        "2022-11-16": 44,
+        "2022-11-17": 88,
+        "2022-11-18": 88,
+        "2022-11-19": 20,
+        "2022-11-20": 8,
+        "2022-11-21": 71,
+        "2022-11-22": 78,
+        "2022-11-23": 100,
+        "2022-11-24": 11,
+        "2022-11-25": 69,
+        "2022-11-26": 4,
+        "2022-11-27": 8,
+        "2022-11-28": 65,
+        "2022-11-29": 63,
+        "2022-11-30": 61,
+        "2022-12-01": 45,
+        "2022-12-02": 98,
+        "2022-12-03": 11,
+        "2022-12-04": 11,
+        "2022-12-05": 100,
+        "2022-12-06": 104,
+        "2022-12-07": 61,
+        "2022-12-08": 102,
+        "2022-12-09": 37,
+        "2022-12-10": 6,
+        "2022-12-11": 7,
+        "2022-12-12": 156,
+        "2022-12-13": 221,
+        "2022-12-14": 93,
+        "2022-12-15": 110,
+        "2022-12-16": 206,
+        "2022-12-17": 16,
+        "2022-12-18": 36,
+        "2022-12-19": 113,
+        "2022-12-20": 88,
+        "2022-12-21": 63,
+        "2022-12-22": 238,
+        "2022-12-23": 73,
+        "2022-12-24": 9,
+        "2022-12-25": 44,
+        "2022-12-26": 88,
+        "2022-12-27": 91,
+        "2022-12-28": 60,
+        "2022-12-29": 32,
+        "2022-12-30": 89,
+        "2022-12-31": 13
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 13226,
+      "severity_distribution": {
+        "UNKNOWN": 13226
+      },
+      "score_distribution": {
+        "7.5": 1501,
+        "5.0": 1615,
+        "4.3": 1854,
+        "5.8": 238,
+        "4.0": 831,
+        "2.1": 589,
+        "7.9": 8,
+        "6.4": 281,
+        "5.5": 171,
+        "8.5": 45,
+        "2.6": 38,
+        "8.3": 31,
+        "6.8": 1134,
+        "3.5": 1065,
+        "8.0": 1,
+        "6.5": 820,
+        "4.4": 124,
+        "10.0": 404,
+        "4.6": 457,
+        "4.9": 157,
+        "7.2": 525,
+        "6.0": 96,
+        "3.6": 79,
+        "6.9": 115,
+        "5.2": 7,
+        "2.3": 4,
+        "4.8": 7,
+        "1.9": 57,
+        "2.7": 10,
+        "9.3": 254,
+        "9.0": 192,
+        "3.3": 69,
+        "6.1": 16,
+        "7.8": 210,
+        "5.6": 1,
+        "7.7": 7,
+        "2.9": 28,
+        "8.8": 2,
+        "6.6": 15,
+        "5.1": 56,
+        "1.2": 3,
+        "7.1": 48,
+        "9.4": 8,
+        "4.7": 16,
+        "7.6": 10,
+        "7.4": 1,
+        "6.2": 5,
+        "5.4": 10,
+        "3.8": 1,
+        "6.3": 1,
+        "3.7": 3,
+        "5.7": 2,
+        "7.0": 1,
+        "5.9": 1,
+        "1.4": 1,
+        "1.8": 1
+      }
+    },
+    "v3.0": {
+      "total": 2000,
+      "severity_distribution": {
+        "MEDIUM": 666,
+        "LOW": 133,
+        "HIGH": 917,
+        "CRITICAL": 284
+      },
+      "score_distribution": {
+        "6.5": 81,
+        "2.1": 1,
+        "2.4": 3,
+        "5.3": 79,
+        "7.1": 56,
+        "7.3": 41,
+        "6.2": 23,
+        "4.3": 69,
+        "8.8": 71,
+        "5.4": 71,
+        "10.0": 66,
+        "5.7": 16,
+        "4.4": 10,
+        "4.0": 13,
+        "6.8": 35,
+        "8.6": 87,
+        "7.5": 43,
+        "2.7": 6,
+        "3.0": 3,
+        "5.9": 36,
+        "3.1": 8,
+        "8.4": 29,
+        "6.3": 36,
+        "7.8": 395,
+        "3.3": 63,
+        "9.8": 46,
+        "7.0": 12,
+        "7.7": 10,
+        "7.6": 29,
+        "8.1": 28,
+        "9.1": 51,
+        "2.2": 4,
+        "3.7": 18,
+        "9.0": 31,
+        "7.4": 15,
+        "5.8": 4,
+        "4.8": 16,
+        "4.1": 3,
+        "5.6": 7,
+        "4.9": 22,
+        "5.5": 19,
+        "8.2": 37,
+        "9.3": 10,
+        "4.6": 14,
+        "3.5": 7,
+        "2.0": 1,
+        "6.4": 8,
+        "6.1": 29,
+        "4.5": 4,
+        "5.2": 2,
+        "8.0": 18,
+        "9.6": 45,
+        "8.3": 20,
+        "4.7": 6,
+        "7.2": 21,
+        "6.6": 29,
+        "6.7": 7,
+        "8.5": 2,
+        "9.4": 12,
+        "5.1": 8,
+        "3.8": 4,
+        "3.4": 3,
+        "5.0": 6,
+        "6.9": 2,
+        "9.9": 23,
+        "4.2": 7,
+        "2.9": 2,
+        "8.7": 2,
+        "3.9": 1,
+        "7.9": 1,
+        "3.6": 3,
+        "2.5": 2,
+        "2.8": 2,
+        "6.0": 4,
+        "2.3": 2
+      }
+    },
+    "v3.1": {
+      "total": 24978,
+      "severity_distribution": {
+        "MEDIUM": 10670,
+        "LOW": 942,
+        "HIGH": 9606,
+        "CRITICAL": 3758,
+        "NONE": 2
+      },
+      "score_distribution": {
+        "5.3": 779,
+        "3.7": 68,
+        "5.0": 72,
+        "5.4": 1226,
+        "7.5": 2599,
+        "5.5": 1687,
+        "6.7": 347,
+        "7.0": 177,
+        "6.5": 1665,
+        "4.3": 829,
+        "6.1": 1275,
+        "8.3": 65,
+        "9.8": 3004,
+        "4.8": 562,
+        "8.8": 1819,
+        "9.1": 299,
+        "8.1": 408,
+        "7.3": 224,
+        "8.6": 115,
+        "6.2": 86,
+        "3.5": 303,
+        "7.6": 58,
+        "7.2": 789,
+        "5.9": 313,
+        "6.3": 346,
+        "6.4": 128,
+        "2.8": 12,
+        "5.6": 35,
+        "4.7": 163,
+        "2.7": 47,
+        "4.4": 175,
+        "7.8": 2389,
+        "3.1": 35,
+        "2.6": 35,
+        "3.3": 211,
+        "3.0": 10,
+        "2.4": 47,
+        "4.2": 42,
+        "4.6": 102,
+        "5.8": 39,
+        "8.2": 177,
+        "2.2": 8,
+        "10.0": 117,
+        "7.1": 233,
+        "4.9": 210,
+        "3.4": 31,
+        "6.8": 177,
+        "7.7": 139,
+        "3.8": 25,
+        "5.1": 22,
+        "4.0": 117,
+        "9.4": 25,
+        "3.2": 4,
+        "9.0": 62,
+        "9.3": 110,
+        "9.6": 61,
+        "6.6": 77,
+        "8.4": 111,
+        "8.0": 110,
+        "4.5": 15,
+        "6.9": 17,
+        "9.9": 79,
+        "7.4": 96,
+        "2.5": 13,
+        "8.5": 40,
+        "8.7": 33,
+        "2.0": 14,
+        "5.7": 58,
+        "4.1": 47,
+        "6.0": 46,
+        "5.2": 13,
+        "3.9": 21,
+        "2.3": 17,
+        "7.9": 16,
+        "2.9": 21,
+        "1.9": 12,
+        "3.6": 4,
+        "2.1": 2,
+        "8.9": 8,
+        "1.8": 2,
+        "0.0": 2,
+        "9.2": 1
+      }
+    },
+    "v4.0": {
+      "total": 31,
+      "severity_distribution": {
+        "MEDIUM": 16,
+        "HIGH": 11,
+        "CRITICAL": 3,
+        "LOW": 1
+      },
+      "score_distribution": {
+        "5.1": 6,
+        "8.8": 2,
+        "8.6": 5,
+        "8.7": 2,
+        "9.3": 2,
+        "5.3": 2,
+        "6.9": 5,
+        "2.1": 1,
+        "9.2": 1,
+        "6.3": 1,
+        "5.5": 1,
+        "7.1": 2,
+        "5.2": 1
+      }
+    },
+    "unknown": {
+      "total": 2,
+      "severity_distribution": {
+        "UNKNOWN": 2
+      },
+      "score_distribution": {
+        "0.0": 2
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 951,
+      "epss_gt_0_5": 308,
+      "epss_gt_0_9": 69
+    }
+  },
+  "kev": {
+    "kev_count": 131
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Google",
+        "count": 1808
+      },
+      {
+        "name": "Microsoft",
+        "count": 1757
+      },
+      {
+        "name": "Debian",
+        "count": 968
+      },
+      {
+        "name": "Fedoraproject",
+        "count": 954
+      },
+      {
+        "name": "Apple",
+        "count": 875
+      },
+      {
+        "name": "Linux",
+        "count": 592
+      },
+      {
+        "name": "Oracle",
+        "count": 551
+      },
+      {
+        "name": "Netapp",
+        "count": 502
+      },
+      {
+        "name": "Adobe",
+        "count": 461
+      },
+      {
+        "name": "Ibm",
+        "count": 421
+      },
+      {
+        "name": "Jenkins",
+        "count": 393
+      },
+      {
+        "name": "Tenda",
+        "count": 390
+      },
+      {
+        "name": "Siemens",
+        "count": 341
+      },
+      {
+        "name": "Redhat",
+        "count": 333
+      },
+      {
+        "name": "Cisco",
+        "count": 317
+      },
+      {
+        "name": "Huawei",
+        "count": 316
+      },
+      {
+        "name": "Intel",
+        "count": 249
+      },
+      {
+        "name": "Qualcomm",
+        "count": 247
+      },
+      {
+        "name": "Mediatek",
+        "count": 240
+      },
+      {
+        "name": "Apache",
+        "count": 223
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-79",
+        "count": 4379
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 3013
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 2232
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 1182
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 1067
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 1001
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 955
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 943
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 770
+      },
+      {
+        "cwe": "CWE-862",
+        "count": 688
+      },
+      {
+        "cwe": "CWE-434",
+        "count": 642
+      },
+      {
+        "cwe": "CWE-120",
+        "count": 639
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 558
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 542
+      },
+      {
+        "cwe": "CWE-476",
+        "count": 524
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 416
+      },
+      {
+        "cwe": "CWE-269",
+        "count": 377
+      },
+      {
+        "cwe": "CWE-863",
+        "count": 373
+      },
+      {
+        "cwe": "CWE-284",
+        "count": 362
+      },
+      {
+        "cwe": "CWE-400",
+        "count": 344
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 24770
+      },
+      {
+        "status": "Analyzed",
+        "count": 304
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Third Party Advisory",
+        "count": 56153
+      },
+      {
+        "tag": "Vendor Advisory",
+        "count": 30186
+      },
+      {
+        "tag": "Exploit",
+        "count": 22182
+      },
+      {
+        "tag": "Patch",
+        "count": 18182
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 7734
+      },
+      {
+        "tag": "Mailing List",
+        "count": 5637
+      },
+      {
+        "tag": "Release Notes",
+        "count": 5352
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 3694
+      },
+      {
+        "tag": "Product",
+        "count": 2564
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 2245
+      },
+      {
+        "tag": "Mitigation",
+        "count": 1776
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1342
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 1336
+      },
+      {
+        "tag": "Technical Description",
+        "count": 606
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 400
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 38
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 16
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 16
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:47.733011",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2023.json b/web/data/cve_2023.json
new file mode 100644
index 00000000000..2cd7423d030
--- /dev/null
+++ b/web/data/cve_2023.json
@@ -0,0 +1,925 @@
+{
+  "year": 2023,
+  "total_cves": 28816,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 2337,
+      "2": 2122,
+      "3": 2516,
+      "4": 2330,
+      "5": 2418,
+      "6": 2384,
+      "7": 2305,
+      "8": 2477,
+      "9": 2148,
+      "10": 2680,
+      "11": 2449,
+      "12": 2650
+    },
+    "daily_analysis": {
+      "total_days": 361,
+      "avg_per_day": 79.82,
+      "highest_day": {
+        "date": "2023-01-26",
+        "count": 348
+      },
+      "lowest_day": {
+        "date": "2023-02-05",
+        "count": 1
+      },
+      "daily_counts": {
+        "2023-01-01": 23,
+        "2023-01-02": 75,
+        "2023-01-03": 68,
+        "2023-01-04": 79,
+        "2023-01-05": 112,
+        "2023-01-06": 46,
+        "2023-01-07": 48,
+        "2023-01-08": 18,
+        "2023-01-09": 96,
+        "2023-01-10": 186,
+        "2023-01-11": 164,
+        "2023-01-12": 73,
+        "2023-01-13": 116,
+        "2023-01-14": 28,
+        "2023-01-15": 31,
+        "2023-01-16": 66,
+        "2023-01-17": 84,
+        "2023-01-18": 164,
+        "2023-01-19": 36,
+        "2023-01-20": 118,
+        "2023-01-21": 8,
+        "2023-01-22": 7,
+        "2023-01-23": 86,
+        "2023-01-24": 8,
+        "2023-01-25": 2,
+        "2023-01-26": 348,
+        "2023-01-27": 74,
+        "2023-01-28": 14,
+        "2023-01-29": 12,
+        "2023-01-30": 100,
+        "2023-01-31": 47,
+        "2023-02-01": 131,
+        "2023-02-02": 45,
+        "2023-02-03": 118,
+        "2023-02-04": 16,
+        "2023-02-05": 1,
+        "2023-02-06": 137,
+        "2023-02-07": 75,
+        "2023-02-08": 68,
+        "2023-02-09": 91,
+        "2023-02-10": 45,
+        "2023-02-11": 35,
+        "2023-02-12": 110,
+        "2023-02-13": 119,
+        "2023-02-14": 197,
+        "2023-02-15": 94,
+        "2023-02-16": 162,
+        "2023-02-17": 100,
+        "2023-02-18": 13,
+        "2023-02-19": 9,
+        "2023-02-20": 41,
+        "2023-02-21": 91,
+        "2023-02-22": 56,
+        "2023-02-23": 57,
+        "2023-02-24": 46,
+        "2023-02-25": 21,
+        "2023-02-26": 21,
+        "2023-02-27": 145,
+        "2023-02-28": 78,
+        "2023-03-01": 135,
+        "2023-03-02": 55,
+        "2023-03-03": 50,
+        "2023-03-04": 13,
+        "2023-03-05": 15,
+        "2023-03-06": 107,
+        "2023-03-07": 116,
+        "2023-03-08": 45,
+        "2023-03-09": 60,
+        "2023-03-10": 139,
+        "2023-03-11": 9,
+        "2023-03-12": 10,
+        "2023-03-13": 81,
+        "2023-03-14": 152,
+        "2023-03-15": 71,
+        "2023-03-16": 106,
+        "2023-03-17": 56,
+        "2023-03-18": 22,
+        "2023-03-19": 15,
+        "2023-03-20": 59,
+        "2023-03-21": 74,
+        "2023-03-22": 102,
+        "2023-03-23": 116,
+        "2023-03-24": 180,
+        "2023-03-25": 34,
+        "2023-03-26": 15,
+        "2023-03-27": 179,
+        "2023-03-28": 145,
+        "2023-03-29": 233,
+        "2023-03-30": 63,
+        "2023-03-31": 59,
+        "2023-04-01": 19,
+        "2023-04-02": 39,
+        "2023-04-03": 45,
+        "2023-04-04": 132,
+        "2023-04-05": 137,
+        "2023-04-06": 111,
+        "2023-04-07": 98,
+        "2023-04-08": 20,
+        "2023-04-09": 13,
+        "2023-04-10": 80,
+        "2023-04-11": 236,
+        "2023-04-12": 104,
+        "2023-04-13": 74,
+        "2023-04-14": 109,
+        "2023-04-15": 63,
+        "2023-04-16": 44,
+        "2023-04-17": 85,
+        "2023-04-18": 163,
+        "2023-04-19": 121,
+        "2023-04-20": 54,
+        "2023-04-21": 60,
+        "2023-04-22": 31,
+        "2023-04-23": 26,
+        "2023-04-24": 113,
+        "2023-04-25": 91,
+        "2023-04-26": 63,
+        "2023-04-27": 72,
+        "2023-04-28": 107,
+        "2023-04-29": 17,
+        "2023-04-30": 3,
+        "2023-05-01": 38,
+        "2023-05-02": 70,
+        "2023-05-03": 87,
+        "2023-05-04": 87,
+        "2023-05-05": 41,
+        "2023-05-06": 8,
+        "2023-05-07": 5,
+        "2023-05-08": 185,
+        "2023-05-09": 251,
+        "2023-05-10": 210,
+        "2023-05-11": 98,
+        "2023-05-12": 90,
+        "2023-05-13": 0,
+        "2023-05-14": 11,
+        "2023-05-15": 147,
+        "2023-05-16": 90,
+        "2023-05-17": 61,
+        "2023-05-18": 90,
+        "2023-05-19": 27,
+        "2023-05-20": 23,
+        "2023-05-21": 7,
+        "2023-05-22": 84,
+        "2023-05-23": 92,
+        "2023-05-24": 91,
+        "2023-05-25": 79,
+        "2023-05-26": 87,
+        "2023-05-27": 25,
+        "2023-05-28": 30,
+        "2023-05-29": 38,
+        "2023-05-30": 135,
+        "2023-05-31": 131,
+        "2023-06-01": 73,
+        "2023-06-02": 139,
+        "2023-06-03": 25,
+        "2023-06-04": 6,
+        "2023-06-05": 72,
+        "2023-06-06": 151,
+        "2023-06-07": 183,
+        "2023-06-08": 41,
+        "2023-06-09": 119,
+        "2023-06-10": 4,
+        "2023-06-11": 8,
+        "2023-06-12": 81,
+        "2023-06-13": 130,
+        "2023-06-14": 175,
+        "2023-06-15": 94,
+        "2023-06-16": 78,
+        "2023-06-17": 9,
+        "2023-06-18": 13,
+        "2023-06-19": 116,
+        "2023-06-20": 64,
+        "2023-06-21": 29,
+        "2023-06-22": 111,
+        "2023-06-23": 190,
+        "2023-06-24": 6,
+        "2023-06-25": 10,
+        "2023-06-26": 94,
+        "2023-06-27": 78,
+        "2023-06-28": 150,
+        "2023-06-29": 67,
+        "2023-06-30": 68,
+        "2023-07-01": 50,
+        "2023-07-02": 0,
+        "2023-07-03": 34,
+        "2023-07-04": 66,
+        "2023-07-05": 79,
+        "2023-07-06": 197,
+        "2023-07-07": 62,
+        "2023-07-08": 4,
+        "2023-07-09": 0,
+        "2023-07-10": 154,
+        "2023-07-11": 275,
+        "2023-07-12": 210,
+        "2023-07-13": 139,
+        "2023-07-14": 61,
+        "2023-07-15": 12,
+        "2023-07-16": 15,
+        "2023-07-17": 97,
+        "2023-07-18": 155,
+        "2023-07-19": 62,
+        "2023-07-20": 67,
+        "2023-07-21": 70,
+        "2023-07-22": 17,
+        "2023-07-23": 18,
+        "2023-07-24": 55,
+        "2023-07-25": 99,
+        "2023-07-26": 57,
+        "2023-07-27": 86,
+        "2023-07-28": 57,
+        "2023-07-29": 34,
+        "2023-07-30": 10,
+        "2023-07-31": 63,
+        "2023-08-01": 70,
+        "2023-08-02": 67,
+        "2023-08-03": 132,
+        "2023-08-04": 74,
+        "2023-08-05": 25,
+        "2023-08-06": 19,
+        "2023-08-07": 115,
+        "2023-08-08": 253,
+        "2023-08-09": 99,
+        "2023-08-10": 131,
+        "2023-08-11": 156,
+        "2023-08-12": 3,
+        "2023-08-13": 29,
+        "2023-08-14": 134,
+        "2023-08-15": 95,
+        "2023-08-16": 97,
+        "2023-08-17": 78,
+        "2023-08-18": 59,
+        "2023-08-19": 7,
+        "2023-08-20": 13,
+        "2023-08-21": 63,
+        "2023-08-22": 186,
+        "2023-08-23": 59,
+        "2023-08-24": 60,
+        "2023-08-25": 87,
+        "2023-08-26": 6,
+        "2023-08-27": 12,
+        "2023-08-28": 78,
+        "2023-08-29": 52,
+        "2023-08-30": 114,
+        "2023-08-31": 104,
+        "2023-09-01": 80,
+        "2023-09-02": 10,
+        "2023-09-03": 24,
+        "2023-09-04": 151,
+        "2023-09-05": 125,
+        "2023-09-06": 160,
+        "2023-09-07": 66,
+        "2023-09-08": 54,
+        "2023-09-09": 14,
+        "2023-09-10": 12,
+        "2023-09-11": 110,
+        "2023-09-12": 161,
+        "2023-09-13": 59,
+        "2023-09-14": 59,
+        "2023-09-15": 83,
+        "2023-09-16": 11,
+        "2023-09-17": 18,
+        "2023-09-18": 53,
+        "2023-09-19": 55,
+        "2023-09-20": 127,
+        "2023-09-21": 51,
+        "2023-09-22": 41,
+        "2023-09-23": 7,
+        "2023-09-24": 7,
+        "2023-09-25": 92,
+        "2023-09-26": 2,
+        "2023-09-27": 309,
+        "2023-09-28": 71,
+        "2023-09-29": 80,
+        "2023-09-30": 56,
+        "2023-10-01": 7,
+        "2023-10-02": 77,
+        "2023-10-03": 138,
+        "2023-10-04": 106,
+        "2023-10-05": 59,
+        "2023-10-06": 68,
+        "2023-10-07": 4,
+        "2023-10-08": 24,
+        "2023-10-09": 85,
+        "2023-10-10": 254,
+        "2023-10-11": 110,
+        "2023-10-12": 67,
+        "2023-10-13": 84,
+        "2023-10-14": 30,
+        "2023-10-15": 10,
+        "2023-10-16": 162,
+        "2023-10-17": 165,
+        "2023-10-18": 73,
+        "2023-10-19": 104,
+        "2023-10-20": 115,
+        "2023-10-21": 29,
+        "2023-10-22": 19,
+        "2023-10-23": 58,
+        "2023-10-24": 2,
+        "2023-10-25": 327,
+        "2023-10-26": 92,
+        "2023-10-27": 99,
+        "2023-10-28": 13,
+        "2023-10-29": 15,
+        "2023-10-30": 168,
+        "2023-10-31": 116,
+        "2023-11-01": 144,
+        "2023-11-02": 94,
+        "2023-11-03": 102,
+        "2023-11-04": 9,
+        "2023-11-05": 8,
+        "2023-11-06": 117,
+        "2023-11-07": 172,
+        "2023-11-08": 106,
+        "2023-11-09": 100,
+        "2023-11-10": 41,
+        "2023-11-11": 5,
+        "2023-11-12": 25,
+        "2023-11-13": 85,
+        "2023-11-14": 330,
+        "2023-11-15": 73,
+        "2023-11-16": 123,
+        "2023-11-17": 68,
+        "2023-11-18": 45,
+        "2023-11-19": 1,
+        "2023-11-20": 71,
+        "2023-11-21": 61,
+        "2023-11-22": 160,
+        "2023-11-23": 57,
+        "2023-11-24": 17,
+        "2023-11-25": 0,
+        "2023-11-26": 5,
+        "2023-11-27": 94,
+        "2023-11-28": 73,
+        "2023-11-29": 56,
+        "2023-11-30": 207,
+        "2023-12-01": 55,
+        "2023-12-02": 9,
+        "2023-12-03": 9,
+        "2023-12-04": 233,
+        "2023-12-05": 138,
+        "2023-12-06": 55,
+        "2023-12-07": 139,
+        "2023-12-08": 77,
+        "2023-12-09": 28,
+        "2023-12-10": 24,
+        "2023-12-11": 38,
+        "2023-12-12": 191,
+        "2023-12-13": 151,
+        "2023-12-14": 159,
+        "2023-12-15": 289,
+        "2023-12-16": 19,
+        "2023-12-17": 25,
+        "2023-12-18": 99,
+        "2023-12-19": 114,
+        "2023-12-20": 119,
+        "2023-12-21": 127,
+        "2023-12-22": 83,
+        "2023-12-23": 12,
+        "2023-12-24": 10,
+        "2023-12-25": 46,
+        "2023-12-26": 66,
+        "2023-12-27": 29,
+        "2023-12-28": 73,
+        "2023-12-29": 162,
+        "2023-12-30": 35,
+        "2023-12-31": 36
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 1926,
+      "severity_distribution": {
+        "UNKNOWN": 1926
+      },
+      "score_distribution": {
+        "5.2": 230,
+        "4.0": 458,
+        "2.7": 30,
+        "7.5": 86,
+        "6.5": 589,
+        "2.6": 21,
+        "1.4": 13,
+        "5.0": 95,
+        "5.8": 109,
+        "2.1": 12,
+        "4.6": 37,
+        "3.3": 78,
+        "4.1": 5,
+        "2.3": 8,
+        "4.9": 7,
+        "3.7": 3,
+        "5.5": 7,
+        "1.7": 19,
+        "4.3": 34,
+        "1.0": 2,
+        "3.5": 1,
+        "5.1": 11,
+        "4.7": 7,
+        "6.8": 12,
+        "9.0": 4,
+        "7.8": 7,
+        "8.3": 13,
+        "6.0": 2,
+        "6.1": 3,
+        "6.4": 5,
+        "7.2": 1,
+        "3.2": 6,
+        "10.0": 5,
+        "1.8": 1,
+        "1.2": 1,
+        "7.7": 3,
+        "4.8": 1
+      }
+    },
+    "v3.0": {
+      "total": 1160,
+      "severity_distribution": {
+        "HIGH": 574,
+        "MEDIUM": 370,
+        "CRITICAL": 117,
+        "LOW": 99
+      },
+      "score_distribution": {
+        "8.5": 86,
+        "6.5": 41,
+        "8.7": 5,
+        "7.5": 32,
+        "7.4": 5,
+        "5.3": 35,
+        "7.1": 22,
+        "7.3": 31,
+        "9.0": 14,
+        "8.8": 62,
+        "7.6": 18,
+        "4.6": 11,
+        "7.8": 140,
+        "7.2": 87,
+        "3.3": 61,
+        "4.9": 1,
+        "9.8": 47,
+        "8.2": 8,
+        "6.8": 34,
+        "9.1": 18,
+        "5.0": 5,
+        "5.9": 12,
+        "4.3": 26,
+        "2.2": 2,
+        "6.6": 5,
+        "3.9": 1,
+        "6.3": 20,
+        "8.0": 13,
+        "5.5": 14,
+        "9.4": 2,
+        "5.1": 11,
+        "6.4": 7,
+        "2.5": 1,
+        "9.3": 7,
+        "5.4": 41,
+        "4.2": 4,
+        "3.8": 3,
+        "6.7": 7,
+        "3.1": 6,
+        "8.3": 18,
+        "8.4": 5,
+        "3.5": 16,
+        "8.6": 8,
+        "5.7": 7,
+        "4.7": 9,
+        "6.1": 19,
+        "5.8": 5,
+        "4.0": 14,
+        "9.6": 9,
+        "8.1": 24,
+        "9.9": 4,
+        "2.4": 2,
+        "4.4": 7,
+        "4.8": 10,
+        "5.2": 10,
+        "3.4": 1,
+        "6.0": 7,
+        "4.5": 2,
+        "8.9": 2,
+        "7.7": 6,
+        "10.0": 16,
+        "4.1": 3,
+        "6.2": 2,
+        "3.0": 1,
+        "2.6": 1,
+        "7.9": 1,
+        "5.6": 1,
+        "3.2": 1,
+        "2.7": 3,
+        "7.0": 1
+      }
+    },
+    "v3.1": {
+      "total": 28815,
+      "severity_distribution": {
+        "MEDIUM": 14071,
+        "HIGH": 9773,
+        "LOW": 1315,
+        "CRITICAL": 3652,
+        "NONE": 4
+      },
+      "score_distribution": {
+        "5.5": 1906,
+        "7.5": 2539,
+        "3.5": 520,
+        "7.3": 279,
+        "6.3": 838,
+        "3.1": 100,
+        "2.6": 31,
+        "4.3": 1453,
+        "9.8": 2812,
+        "5.3": 924,
+        "5.0": 109,
+        "4.7": 250,
+        "2.4": 89,
+        "4.6": 129,
+        "5.4": 1937,
+        "2.8": 16,
+        "6.5": 1713,
+        "6.1": 1185,
+        "8.8": 1842,
+        "7.2": 660,
+        "5.9": 735,
+        "3.7": 108,
+        "3.3": 204,
+        "2.0": 19,
+        "2.5": 11,
+        "4.8": 371,
+        "8.1": 373,
+        "9.9": 209,
+        "8.5": 73,
+        "7.7": 74,
+        "5.6": 44,
+        "7.8": 2075,
+        "9.0": 102,
+        "7.4": 114,
+        "7.6": 142,
+        "10.0": 103,
+        "9.6": 92,
+        "6.6": 83,
+        "6.8": 239,
+        "9.1": 266,
+        "7.0": 155,
+        "4.0": 76,
+        "5.7": 97,
+        "4.4": 379,
+        "8.6": 146,
+        "4.2": 55,
+        "7.1": 636,
+        "6.7": 597,
+        "6.4": 241,
+        "8.3": 80,
+        "8.0": 142,
+        "5.8": 80,
+        "6.2": 110,
+        "3.2": 10,
+        "2.3": 11,
+        "8.7": 39,
+        "8.2": 227,
+        "3.9": 32,
+        "2.7": 64,
+        "4.9": 241,
+        "8.4": 141,
+        "1.9": 8,
+        "2.1": 5,
+        "4.1": 57,
+        "6.0": 94,
+        "9.3": 47,
+        "8.9": 14,
+        "5.2": 22,
+        "5.1": 58,
+        "1.8": 4,
+        "7.9": 22,
+        "9.4": 21,
+        "6.9": 15,
+        "4.5": 33,
+        "2.2": 13,
+        "3.8": 30,
+        "2.9": 9,
+        "3.4": 13,
+        "0.0": 4,
+        "3.6": 11,
+        "3.0": 7
+      }
+    },
+    "v4.0": {
+      "total": 53,
+      "severity_distribution": {
+        "HIGH": 25,
+        "MEDIUM": 17,
+        "CRITICAL": 4,
+        "LOW": 7
+      },
+      "score_distribution": {
+        "8.7": 6,
+        "5.3": 8,
+        "5.1": 3,
+        "7.3": 14,
+        "9.1": 1,
+        "2.0": 4,
+        "4.8": 1,
+        "5.4": 1,
+        "7.1": 3,
+        "6.9": 4,
+        "2.3": 1,
+        "9.2": 1,
+        "8.2": 1,
+        "9.4": 2,
+        "8.6": 1,
+        "1.9": 1,
+        "2.1": 1
+      }
+    },
+    "unknown": {
+      "total": 1,
+      "severity_distribution": {
+        "UNKNOWN": 1
+      },
+      "score_distribution": {
+        "0.0": 1
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 958,
+      "epss_gt_0_5": 390,
+      "epss_gt_0_9": 88
+    }
+  },
+  "kev": {
+    "kev_count": 165
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 1943
+      },
+      {
+        "name": "Google",
+        "count": 1791
+      },
+      {
+        "name": "Apple",
+        "count": 967
+      },
+      {
+        "name": "Adobe",
+        "count": 676
+      },
+      {
+        "name": "Linux",
+        "count": 611
+      },
+      {
+        "name": "Fedoraproject",
+        "count": 555
+      },
+      {
+        "name": "Debian",
+        "count": 516
+      },
+      {
+        "name": "Unisoc",
+        "count": 464
+      },
+      {
+        "name": "Ibm",
+        "count": 416
+      },
+      {
+        "name": "Intel",
+        "count": 351
+      },
+      {
+        "name": "Redhat",
+        "count": 329
+      },
+      {
+        "name": "Oracle",
+        "count": 326
+      },
+      {
+        "name": "Mediatek",
+        "count": 324
+      },
+      {
+        "name": "Qualcomm",
+        "count": 315
+      },
+      {
+        "name": "Samsung",
+        "count": 282
+      },
+      {
+        "name": "Apache",
+        "count": 266
+      },
+      {
+        "name": "Cisco",
+        "count": 266
+      },
+      {
+        "name": "Dell",
+        "count": 264
+      },
+      {
+        "name": "Jenkins",
+        "count": 255
+      },
+      {
+        "name": "Huawei",
+        "count": 254
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-79",
+        "count": 6203
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 2683
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 2647
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 1637
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 1317
+      },
+      {
+        "cwe": "CWE-862",
+        "count": 1159
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 1113
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 986
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 946
+      },
+      {
+        "cwe": "CWE-120",
+        "count": 903
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 863
+      },
+      {
+        "cwe": "CWE-77",
+        "count": 738
+      },
+      {
+        "cwe": "CWE-434",
+        "count": 731
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 639
+      },
+      {
+        "cwe": "CWE-863",
+        "count": 538
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 523
+      },
+      {
+        "cwe": "CWE-400",
+        "count": 523
+      },
+      {
+        "cwe": "CWE-287",
+        "count": 504
+      },
+      {
+        "cwe": "CWE-284",
+        "count": 495
+      },
+      {
+        "cwe": "CWE-269",
+        "count": 431
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Modified",
+        "count": 28240
+      },
+      {
+        "status": "Analyzed",
+        "count": 576
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Third Party Advisory",
+        "count": 44760
+      },
+      {
+        "tag": "Vendor Advisory",
+        "count": 34212
+      },
+      {
+        "tag": "Patch",
+        "count": 19568
+      },
+      {
+        "tag": "Exploit",
+        "count": 19147
+      },
+      {
+        "tag": "Release Notes",
+        "count": 7028
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 6420
+      },
+      {
+        "tag": "Mailing List",
+        "count": 6119
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 5911
+      },
+      {
+        "tag": "Product",
+        "count": 4849
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 4234
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1657
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 1219
+      },
+      {
+        "tag": "Mitigation",
+        "count": 1121
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 1037
+      },
+      {
+        "tag": "Technical Description",
+        "count": 756
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 102
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 8
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 2
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:48.501477",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2024.json b/web/data/cve_2024.json
new file mode 100644
index 00000000000..48405c082a1
--- /dev/null
+++ b/web/data/cve_2024.json
@@ -0,0 +1,993 @@
+{
+  "year": 2024,
+  "total_cves": 39953,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 2594,
+      "2": 2778,
+      "3": 3309,
+      "4": 3621,
+      "5": 4999,
+      "6": 3078,
+      "7": 3113,
+      "8": 2896,
+      "9": 2514,
+      "10": 3564,
+      "11": 4056,
+      "12": 3431
+    },
+    "daily_analysis": {
+      "total_days": 357,
+      "avg_per_day": 111.91,
+      "highest_day": {
+        "date": "2024-05-03",
+        "count": 845
+      },
+      "lowest_day": {
+        "date": "2024-01-14",
+        "count": 2
+      },
+      "daily_counts": {
+        "2024-01-01": 14,
+        "2024-01-02": 103,
+        "2024-01-03": 97,
+        "2024-01-04": 59,
+        "2024-01-05": 72,
+        "2024-01-06": 8,
+        "2024-01-07": 34,
+        "2024-01-08": 193,
+        "2024-01-09": 160,
+        "2024-01-10": 178,
+        "2024-01-11": 143,
+        "2024-01-12": 128,
+        "2024-01-13": 54,
+        "2024-01-14": 2,
+        "2024-01-15": 68,
+        "2024-01-16": 229,
+        "2024-01-17": 78,
+        "2024-01-18": 94,
+        "2024-01-19": 104,
+        "2024-01-20": 14,
+        "2024-01-21": 12,
+        "2024-01-22": 58,
+        "2024-01-23": 133,
+        "2024-01-24": 90,
+        "2024-01-25": 56,
+        "2024-01-26": 122,
+        "2024-01-27": 21,
+        "2024-01-28": 9,
+        "2024-01-29": 95,
+        "2024-01-30": 75,
+        "2024-01-31": 91,
+        "2024-02-01": 82,
+        "2024-02-02": 146,
+        "2024-02-03": 20,
+        "2024-02-04": 14,
+        "2024-02-05": 157,
+        "2024-02-06": 149,
+        "2024-02-07": 81,
+        "2024-02-08": 82,
+        "2024-02-09": 88,
+        "2024-02-10": 30,
+        "2024-02-11": 17,
+        "2024-02-12": 89,
+        "2024-02-13": 176,
+        "2024-02-14": 175,
+        "2024-02-15": 104,
+        "2024-02-16": 50,
+        "2024-02-17": 66,
+        "2024-02-18": 29,
+        "2024-02-19": 35,
+        "2024-02-20": 117,
+        "2024-02-21": 138,
+        "2024-02-22": 108,
+        "2024-02-23": 86,
+        "2024-02-24": 4,
+        "2024-02-25": 0,
+        "2024-02-26": 105,
+        "2024-02-27": 158,
+        "2024-02-28": 184,
+        "2024-02-29": 288,
+        "2024-03-01": 126,
+        "2024-03-02": 68,
+        "2024-03-03": 29,
+        "2024-03-04": 109,
+        "2024-03-05": 112,
+        "2024-03-06": 101,
+        "2024-03-07": 91,
+        "2024-03-08": 104,
+        "2024-03-09": 26,
+        "2024-03-10": 9,
+        "2024-03-11": 113,
+        "2024-03-12": 178,
+        "2024-03-13": 220,
+        "2024-03-14": 68,
+        "2024-03-15": 127,
+        "2024-03-16": 50,
+        "2024-03-17": 29,
+        "2024-03-18": 197,
+        "2024-03-19": 130,
+        "2024-03-20": 157,
+        "2024-03-21": 162,
+        "2024-03-22": 81,
+        "2024-03-23": 18,
+        "2024-03-24": 16,
+        "2024-03-25": 117,
+        "2024-03-26": 158,
+        "2024-03-27": 285,
+        "2024-03-28": 183,
+        "2024-03-29": 156,
+        "2024-03-30": 26,
+        "2024-03-31": 63,
+        "2024-04-01": 105,
+        "2024-04-02": 172,
+        "2024-04-03": 232,
+        "2024-04-04": 139,
+        "2024-04-05": 94,
+        "2024-04-06": 39,
+        "2024-04-07": 58,
+        "2024-04-08": 123,
+        "2024-04-09": 384,
+        "2024-04-10": 219,
+        "2024-04-11": 111,
+        "2024-04-12": 128,
+        "2024-04-13": 16,
+        "2024-04-14": 4,
+        "2024-04-15": 218,
+        "2024-04-16": 242,
+        "2024-04-17": 295,
+        "2024-04-18": 124,
+        "2024-04-19": 116,
+        "2024-04-20": 5,
+        "2024-04-21": 5,
+        "2024-04-22": 78,
+        "2024-04-23": 63,
+        "2024-04-24": 124,
+        "2024-04-25": 95,
+        "2024-04-26": 138,
+        "2024-04-27": 26,
+        "2024-04-28": 44,
+        "2024-04-29": 138,
+        "2024-04-30": 86,
+        "2024-05-01": 253,
+        "2024-05-02": 235,
+        "2024-05-03": 845,
+        "2024-05-04": 14,
+        "2024-05-05": 34,
+        "2024-05-06": 156,
+        "2024-05-07": 187,
+        "2024-05-08": 106,
+        "2024-05-09": 0,
+        "2024-05-10": 0,
+        "2024-05-11": 0,
+        "2024-05-12": 0,
+        "2024-05-13": 0,
+        "2024-05-14": 824,
+        "2024-05-15": 135,
+        "2024-05-16": 220,
+        "2024-05-17": 319,
+        "2024-05-18": 28,
+        "2024-05-19": 100,
+        "2024-05-20": 124,
+        "2024-05-21": 436,
+        "2024-05-22": 176,
+        "2024-05-23": 118,
+        "2024-05-24": 129,
+        "2024-05-25": 12,
+        "2024-05-26": 46,
+        "2024-05-27": 55,
+        "2024-05-28": 133,
+        "2024-05-29": 61,
+        "2024-05-30": 176,
+        "2024-05-31": 77,
+        "2024-06-01": 18,
+        "2024-06-02": 13,
+        "2024-06-03": 109,
+        "2024-06-04": 182,
+        "2024-06-05": 71,
+        "2024-06-06": 179,
+        "2024-06-07": 70,
+        "2024-06-08": 78,
+        "2024-06-09": 107,
+        "2024-06-10": 145,
+        "2024-06-11": 226,
+        "2024-06-12": 112,
+        "2024-06-13": 313,
+        "2024-06-14": 163,
+        "2024-06-15": 29,
+        "2024-06-16": 26,
+        "2024-06-17": 75,
+        "2024-06-18": 61,
+        "2024-06-19": 223,
+        "2024-06-20": 163,
+        "2024-06-21": 136,
+        "2024-06-22": 23,
+        "2024-06-23": 8,
+        "2024-06-24": 97,
+        "2024-06-25": 138,
+        "2024-06-26": 76,
+        "2024-06-27": 121,
+        "2024-06-28": 79,
+        "2024-06-29": 17,
+        "2024-06-30": 20,
+        "2024-07-01": 122,
+        "2024-07-02": 135,
+        "2024-07-03": 58,
+        "2024-07-04": 38,
+        "2024-07-05": 64,
+        "2024-07-06": 14,
+        "2024-07-07": 14,
+        "2024-07-08": 62,
+        "2024-07-09": 471,
+        "2024-07-10": 123,
+        "2024-07-11": 81,
+        "2024-07-12": 200,
+        "2024-07-13": 49,
+        "2024-07-14": 10,
+        "2024-07-15": 87,
+        "2024-07-16": 253,
+        "2024-07-17": 81,
+        "2024-07-18": 51,
+        "2024-07-19": 53,
+        "2024-07-20": 83,
+        "2024-07-21": 77,
+        "2024-07-22": 134,
+        "2024-07-23": 38,
+        "2024-07-24": 85,
+        "2024-07-25": 46,
+        "2024-07-26": 71,
+        "2024-07-27": 29,
+        "2024-07-28": 26,
+        "2024-07-29": 281,
+        "2024-07-30": 169,
+        "2024-07-31": 108,
+        "2024-08-01": 129,
+        "2024-08-02": 67,
+        "2024-08-03": 21,
+        "2024-08-04": 12,
+        "2024-08-05": 93,
+        "2024-08-06": 171,
+        "2024-08-07": 115,
+        "2024-08-08": 80,
+        "2024-08-09": 0,
+        "2024-08-10": 0,
+        "2024-08-11": 0,
+        "2024-08-12": 255,
+        "2024-08-13": 224,
+        "2024-08-14": 201,
+        "2024-08-15": 120,
+        "2024-08-16": 62,
+        "2024-08-17": 135,
+        "2024-08-18": 66,
+        "2024-08-19": 68,
+        "2024-08-20": 140,
+        "2024-08-21": 184,
+        "2024-08-22": 128,
+        "2024-08-23": 78,
+        "2024-08-24": 28,
+        "2024-08-25": 24,
+        "2024-08-26": 140,
+        "2024-08-27": 64,
+        "2024-08-28": 73,
+        "2024-08-29": 137,
+        "2024-08-30": 60,
+        "2024-08-31": 21,
+        "2024-09-01": 6,
+        "2024-09-02": 79,
+        "2024-09-03": 69,
+        "2024-09-04": 173,
+        "2024-09-05": 66,
+        "2024-09-06": 74,
+        "2024-09-07": 50,
+        "2024-09-08": 28,
+        "2024-09-09": 56,
+        "2024-09-10": 237,
+        "2024-09-11": 110,
+        "2024-09-12": 120,
+        "2024-09-13": 152,
+        "2024-09-14": 13,
+        "2024-09-15": 27,
+        "2024-09-16": 71,
+        "2024-09-17": 180,
+        "2024-09-18": 256,
+        "2024-09-19": 51,
+        "2024-09-20": 47,
+        "2024-09-21": 8,
+        "2024-09-22": 18,
+        "2024-09-23": 63,
+        "2024-09-24": 18,
+        "2024-09-25": 157,
+        "2024-09-26": 119,
+        "2024-09-27": 162,
+        "2024-09-28": 28,
+        "2024-09-29": 10,
+        "2024-09-30": 66,
+        "2024-10-01": 110,
+        "2024-10-02": 91,
+        "2024-10-03": 56,
+        "2024-10-04": 90,
+        "2024-10-05": 83,
+        "2024-10-06": 84,
+        "2024-10-07": 109,
+        "2024-10-08": 234,
+        "2024-10-09": 122,
+        "2024-10-10": 120,
+        "2024-10-11": 132,
+        "2024-10-12": 22,
+        "2024-10-13": 18,
+        "2024-10-14": 74,
+        "2024-10-15": 189,
+        "2024-10-16": 186,
+        "2024-10-17": 156,
+        "2024-10-18": 78,
+        "2024-10-19": 23,
+        "2024-10-20": 69,
+        "2024-10-21": 431,
+        "2024-10-22": 83,
+        "2024-10-23": 120,
+        "2024-10-24": 104,
+        "2024-10-25": 136,
+        "2024-10-26": 43,
+        "2024-10-27": 33,
+        "2024-10-28": 196,
+        "2024-10-29": 207,
+        "2024-10-30": 96,
+        "2024-10-31": 69,
+        "2024-11-01": 237,
+        "2024-11-02": 12,
+        "2024-11-03": 16,
+        "2024-11-04": 141,
+        "2024-11-05": 218,
+        "2024-11-06": 94,
+        "2024-11-07": 110,
+        "2024-11-08": 125,
+        "2024-11-09": 195,
+        "2024-11-10": 32,
+        "2024-11-11": 116,
+        "2024-11-12": 333,
+        "2024-11-13": 230,
+        "2024-11-14": 147,
+        "2024-11-15": 222,
+        "2024-11-16": 50,
+        "2024-11-17": 11,
+        "2024-11-18": 184,
+        "2024-11-19": 383,
+        "2024-11-20": 124,
+        "2024-11-21": 133,
+        "2024-11-22": 385,
+        "2024-11-23": 47,
+        "2024-11-24": 14,
+        "2024-11-25": 71,
+        "2024-11-26": 161,
+        "2024-11-27": 67,
+        "2024-11-28": 93,
+        "2024-11-29": 76,
+        "2024-11-30": 29,
+        "2024-12-01": 12,
+        "2024-12-02": 194,
+        "2024-12-03": 83,
+        "2024-12-04": 117,
+        "2024-12-05": 124,
+        "2024-12-06": 171,
+        "2024-12-07": 32,
+        "2024-12-08": 5,
+        "2024-12-09": 281,
+        "2024-12-10": 271,
+        "2024-12-11": 35,
+        "2024-12-12": 340,
+        "2024-12-13": 296,
+        "2024-12-14": 49,
+        "2024-12-15": 8,
+        "2024-12-16": 204,
+        "2024-12-17": 88,
+        "2024-12-18": 138,
+        "2024-12-19": 106,
+        "2024-12-20": 85,
+        "2024-12-21": 32,
+        "2024-12-22": 14,
+        "2024-12-23": 30,
+        "2024-12-24": 60,
+        "2024-12-25": 27,
+        "2024-12-26": 67,
+        "2024-12-27": 283,
+        "2024-12-28": 50,
+        "2024-12-29": 68,
+        "2024-12-30": 58,
+        "2024-12-31": 103
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 2971,
+      "severity_distribution": {
+        "UNKNOWN": 2971
+      },
+      "score_distribution": {
+        "5.1": 12,
+        "5.0": 227,
+        "6.5": 1001,
+        "4.0": 494,
+        "2.6": 36,
+        "3.3": 115,
+        "6.4": 5,
+        "2.1": 10,
+        "5.2": 38,
+        "2.7": 11,
+        "4.3": 17,
+        "7.7": 6,
+        "7.8": 5,
+        "7.5": 383,
+        "5.8": 164,
+        "8.3": 30,
+        "10.0": 15,
+        "6.8": 29,
+        "7.3": 2,
+        "1.4": 5,
+        "5.5": 16,
+        "9.0": 283,
+        "3.2": 2,
+        "1.7": 19,
+        "9.3": 2,
+        "9.4": 1,
+        "4.8": 1,
+        "4.6": 15,
+        "1.8": 2,
+        "1.0": 4,
+        "3.7": 1,
+        "4.7": 3,
+        "0.8": 1,
+        "6.1": 3,
+        "6.3": 2,
+        "4.9": 2,
+        "6.0": 1,
+        "7.6": 3,
+        "2.3": 2,
+        "6.2": 2,
+        "3.5": 1
+      }
+    },
+    "v3.0": {
+      "total": 1908,
+      "severity_distribution": {
+        "HIGH": 1239,
+        "MEDIUM": 300,
+        "LOW": 198,
+        "CRITICAL": 170,
+        "NONE": 1
+      },
+      "score_distribution": {
+        "8.2": 25,
+        "5.4": 17,
+        "4.3": 25,
+        "6.1": 9,
+        "6.5": 60,
+        "8.8": 254,
+        "7.8": 612,
+        "3.3": 164,
+        "7.5": 122,
+        "3.8": 2,
+        "3.1": 8,
+        "6.8": 62,
+        "7.9": 3,
+        "9.8": 87,
+        "4.1": 1,
+        "5.7": 6,
+        "7.4": 13,
+        "4.4": 12,
+        "7.2": 50,
+        "7.7": 11,
+        "3.5": 4,
+        "10.0": 5,
+        "9.6": 16,
+        "5.5": 13,
+        "1.9": 1,
+        "9.9": 10,
+        "7.1": 30,
+        "7.0": 14,
+        "8.0": 18,
+        "9.0": 5,
+        "4.6": 3,
+        "8.1": 29,
+        "5.8": 3,
+        "9.1": 38,
+        "6.3": 4,
+        "7.6": 7,
+        "8.3": 11,
+        "5.3": 29,
+        "6.6": 6,
+        "4.9": 6,
+        "8.6": 11,
+        "3.7": 2,
+        "5.9": 7,
+        "2.6": 2,
+        "6.7": 11,
+        "7.3": 15,
+        "4.0": 6,
+        "9.3": 6,
+        "5.0": 3,
+        "8.5": 3,
+        "4.8": 5,
+        "9.4": 3,
+        "3.4": 5,
+        "0.0": 1,
+        "4.2": 2,
+        "2.2": 2,
+        "6.0": 1,
+        "2.8": 1,
+        "8.4": 10,
+        "2.7": 2,
+        "8.7": 1,
+        "6.4": 2,
+        "4.7": 2,
+        "3.9": 1,
+        "6.2": 3,
+        "2.9": 1,
+        "5.1": 1,
+        "5.2": 1,
+        "2.4": 1,
+        "3.6": 1,
+        "2.5": 1
+      }
+    },
+    "v3.1": {
+      "total": 39097,
+      "severity_distribution": {
+        "MEDIUM": 19788,
+        "LOW": 1582,
+        "CRITICAL": 3751,
+        "HIGH": 13969,
+        "NONE": 7
+      },
+      "score_distribution": {
+        "5.6": 44,
+        "4.3": 1937,
+        "6.3": 1371,
+        "3.5": 552,
+        "9.1": 453,
+        "8.3": 162,
+        "9.8": 2466,
+        "3.7": 155,
+        "5.3": 1731,
+        "8.8": 2639,
+        "2.4": 135,
+        "6.5": 2700,
+        "8.4": 281,
+        "7.2": 685,
+        "2.6": 25,
+        "5.5": 3281,
+        "4.7": 478,
+        "7.8": 3273,
+        "6.7": 388,
+        "7.5": 2499,
+        "5.4": 1606,
+        "7.3": 771,
+        "6.4": 1326,
+        "7.1": 1262,
+        "4.4": 328,
+        "5.7": 174,
+        "9.6": 150,
+        "4.9": 281,
+        "4.6": 163,
+        "6.2": 208,
+        "3.8": 71,
+        "6.1": 1437,
+        "8.2": 328,
+        "7.4": 190,
+        "8.6": 197,
+        "5.9": 685,
+        "8.0": 307,
+        "8.1": 542,
+        "5.1": 86,
+        "9.3": 117,
+        "7.6": 226,
+        "8.7": 61,
+        "5.0": 117,
+        "9.9": 169,
+        "7.0": 177,
+        "3.3": 241,
+        "6.8": 347,
+        "4.8": 425,
+        "10.0": 234,
+        "7.7": 142,
+        "6.0": 84,
+        "4.0": 113,
+        "9.4": 45,
+        "6.6": 122,
+        "2.3": 18,
+        "4.1": 69,
+        "3.9": 32,
+        "5.2": 29,
+        "5.8": 94,
+        "7.9": 30,
+        "4.5": 40,
+        "2.2": 26,
+        "2.7": 82,
+        "2.9": 24,
+        "3.1": 100,
+        "6.9": 35,
+        "9.0": 115,
+        "8.5": 187,
+        "4.2": 89,
+        "3.2": 2,
+        "3.4": 15,
+        "1.7": 1,
+        "2.0": 15,
+        "2.5": 21,
+        "1.8": 7,
+        "3.0": 21,
+        "2.8": 19,
+        "3.6": 12,
+        "8.9": 10,
+        "1.9": 6,
+        "0.0": 7,
+        "1.6": 1,
+        "2.1": 1,
+        "9.2": 2
+      }
+    },
+    "v4.0": {
+      "total": 3576,
+      "severity_distribution": {
+        "MEDIUM": 2246,
+        "CRITICAL": 275,
+        "HIGH": 934,
+        "LOW": 121
+      },
+      "score_distribution": {
+        "6.3": 52,
+        "5.3": 1089,
+        "5.1": 252,
+        "10.0": 39,
+        "9.0": 5,
+        "8.7": 344,
+        "4.8": 53,
+        "1.0": 8,
+        "8.6": 70,
+        "8.5": 79,
+        "7.3": 88,
+        "2.0": 23,
+        "7.1": 94,
+        "2.3": 32,
+        "6.9": 518,
+        "7.5": 11,
+        "8.2": 38,
+        "5.2": 12,
+        "8.9": 18,
+        "5.7": 15,
+        "9.2": 43,
+        "7.0": 42,
+        "7.7": 24,
+        "9.3": 138,
+        "6.7": 7,
+        "5.9": 24,
+        "6.8": 56,
+        "5.4": 67,
+        "4.6": 18,
+        "8.1": 4,
+        "2.1": 34,
+        "1.8": 8,
+        "8.4": 35,
+        "9.4": 32,
+        "6.4": 3,
+        "1.3": 1,
+        "8.8": 37,
+        "6.0": 27,
+        "8.3": 25,
+        "5.6": 6,
+        "5.5": 6,
+        "9.1": 7,
+        "7.4": 1,
+        "1.2": 5,
+        "1.9": 2,
+        "7.2": 11,
+        "6.2": 4,
+        "7.8": 3,
+        "6.1": 2,
+        "9.5": 9,
+        "6.5": 1,
+        "9.9": 2,
+        "7.6": 7,
+        "5.8": 11,
+        "4.3": 4,
+        "4.1": 2,
+        "4.9": 2,
+        "2.4": 6,
+        "6.6": 9,
+        "4.4": 2,
+        "5.0": 4,
+        "2.7": 2,
+        "7.9": 3
+      }
+    },
+    "unknown": {
+      "total": 8,
+      "severity_distribution": {
+        "UNKNOWN": 8
+      },
+      "score_distribution": {
+        "0.0": 8
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 949,
+      "epss_gt_0_5": 334,
+      "epss_gt_0_9": 86
+    }
+  },
+  "kev": {
+    "kev_count": 160
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Linux",
+        "count": 4528
+      },
+      {
+        "name": "Microsoft",
+        "count": 1803
+      },
+      {
+        "name": "Apple",
+        "count": 959
+      },
+      {
+        "name": "Google",
+        "count": 898
+      },
+      {
+        "name": "Adobe",
+        "count": 760
+      },
+      {
+        "name": "Ibm",
+        "count": 509
+      },
+      {
+        "name": "Debian",
+        "count": 509
+      },
+      {
+        "name": "Tenda",
+        "count": 432
+      },
+      {
+        "name": "Dlink",
+        "count": 399
+      },
+      {
+        "name": "Oracle",
+        "count": 384
+      },
+      {
+        "name": "Fedoraproject",
+        "count": 361
+      },
+      {
+        "name": "Oretnom23",
+        "count": 346
+      },
+      {
+        "name": "Cisco",
+        "count": 324
+      },
+      {
+        "name": "Samsung",
+        "count": 272
+      },
+      {
+        "name": "Apache",
+        "count": 267
+      },
+      {
+        "name": "Totolink",
+        "count": 262
+      },
+      {
+        "name": "Dell",
+        "count": 259
+      },
+      {
+        "name": "Qualcomm",
+        "count": 257
+      },
+      {
+        "name": "Campcodes",
+        "count": 223
+      },
+      {
+        "name": "Huawei",
+        "count": 220
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-79",
+        "count": 9391
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 3364
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 2467
+      },
+      {
+        "cwe": "CWE-862",
+        "count": 2234
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 1729
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 1699
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 1559
+      },
+      {
+        "cwe": "CWE-476",
+        "count": 1359
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 1311
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 1034
+      },
+      {
+        "cwe": "CWE-434",
+        "count": 935
+      },
+      {
+        "cwe": "CWE-121",
+        "count": 903
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 870
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 837
+      },
+      {
+        "cwe": "CWE-120",
+        "count": 822
+      },
+      {
+        "cwe": "CWE-284",
+        "count": 784
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 721
+      },
+      {
+        "cwe": "CWE-77",
+        "count": 617
+      },
+      {
+        "cwe": "CWE-502",
+        "count": 543
+      },
+      {
+        "cwe": "CWE-122",
+        "count": 532
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Analyzed",
+        "count": 17747
+      },
+      {
+        "status": "Modified",
+        "count": 14432
+      },
+      {
+        "status": "Deferred",
+        "count": 7769
+      },
+      {
+        "status": "Undergoing Analysis",
+        "count": 5
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Patch",
+        "count": 44102
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 34380
+      },
+      {
+        "tag": "Vendor Advisory",
+        "count": 23331
+      },
+      {
+        "tag": "Exploit",
+        "count": 14039
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 8190
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 6451
+      },
+      {
+        "tag": "Product",
+        "count": 6366
+      },
+      {
+        "tag": "Mailing List",
+        "count": 5454
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 4132
+      },
+      {
+        "tag": "Release Notes",
+        "count": 3871
+      },
+      {
+        "tag": "Broken Link",
+        "count": 2042
+      },
+      {
+        "tag": "Mitigation",
+        "count": 537
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 528
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 454
+      },
+      {
+        "tag": "Technical Description",
+        "count": 353
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 92
+      },
+      {
+        "tag": "Related",
+        "count": 15
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 8
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 8
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:49.371989",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2025.json b/web/data/cve_2025.json
new file mode 100644
index 00000000000..eb4ba02421d
--- /dev/null
+++ b/web/data/cve_2025.json
@@ -0,0 +1,1008 @@
+{
+  "year": 2025,
+  "total_cves": 48153,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 4275,
+      "2": 3673,
+      "3": 3998,
+      "4": 4034,
+      "5": 3980,
+      "6": 3681,
+      "7": 3776,
+      "8": 3628,
+      "9": 4321,
+      "10": 4273,
+      "11": 3021,
+      "12": 5493
+    },
+    "daily_analysis": {
+      "total_days": 365,
+      "avg_per_day": 131.93,
+      "highest_day": {
+        "date": "2025-02-26",
+        "count": 792
+      },
+      "lowest_day": {
+        "date": "2025-02-02",
+        "count": 3
+      },
+      "daily_counts": {
+        "2025-01-01": 4,
+        "2025-01-02": 232,
+        "2025-01-03": 60,
+        "2025-01-04": 39,
+        "2025-01-05": 27,
+        "2025-01-06": 107,
+        "2025-01-07": 347,
+        "2025-01-08": 127,
+        "2025-01-09": 269,
+        "2025-01-10": 72,
+        "2025-01-11": 105,
+        "2025-01-12": 11,
+        "2025-01-13": 105,
+        "2025-01-14": 478,
+        "2025-01-15": 213,
+        "2025-01-16": 300,
+        "2025-01-17": 86,
+        "2025-01-18": 43,
+        "2025-01-19": 63,
+        "2025-01-20": 34,
+        "2025-01-21": 281,
+        "2025-01-22": 173,
+        "2025-01-23": 111,
+        "2025-01-24": 198,
+        "2025-01-25": 50,
+        "2025-01-26": 19,
+        "2025-01-27": 242,
+        "2025-01-28": 101,
+        "2025-01-29": 72,
+        "2025-01-30": 143,
+        "2025-01-31": 163,
+        "2025-02-01": 39,
+        "2025-02-02": 3,
+        "2025-02-03": 185,
+        "2025-02-04": 143,
+        "2025-02-05": 114,
+        "2025-02-06": 105,
+        "2025-02-07": 120,
+        "2025-02-08": 7,
+        "2025-02-09": 4,
+        "2025-02-10": 72,
+        "2025-02-11": 280,
+        "2025-02-12": 266,
+        "2025-02-13": 132,
+        "2025-02-14": 127,
+        "2025-02-15": 28,
+        "2025-02-16": 38,
+        "2025-02-17": 47,
+        "2025-02-18": 164,
+        "2025-02-19": 119,
+        "2025-02-20": 123,
+        "2025-02-21": 80,
+        "2025-02-22": 35,
+        "2025-02-23": 29,
+        "2025-02-24": 119,
+        "2025-02-25": 142,
+        "2025-02-26": 792,
+        "2025-02-27": 267,
+        "2025-02-28": 93,
+        "2025-03-01": 45,
+        "2025-03-02": 29,
+        "2025-03-03": 346,
+        "2025-03-04": 147,
+        "2025-03-05": 143,
+        "2025-03-06": 140,
+        "2025-03-07": 113,
+        "2025-03-08": 40,
+        "2025-03-09": 23,
+        "2025-03-10": 83,
+        "2025-03-11": 331,
+        "2025-03-12": 103,
+        "2025-03-13": 90,
+        "2025-03-14": 86,
+        "2025-03-15": 44,
+        "2025-03-16": 31,
+        "2025-03-17": 131,
+        "2025-03-18": 72,
+        "2025-03-19": 83,
+        "2025-03-20": 365,
+        "2025-03-21": 70,
+        "2025-03-22": 38,
+        "2025-03-23": 39,
+        "2025-03-24": 151,
+        "2025-03-25": 140,
+        "2025-03-26": 171,
+        "2025-03-27": 375,
+        "2025-03-28": 171,
+        "2025-03-29": 12,
+        "2025-03-30": 16,
+        "2025-03-31": 370,
+        "2025-04-01": 430,
+        "2025-04-02": 109,
+        "2025-04-03": 175,
+        "2025-04-04": 232,
+        "2025-04-05": 33,
+        "2025-04-06": 28,
+        "2025-04-07": 169,
+        "2025-04-08": 348,
+        "2025-04-09": 194,
+        "2025-04-10": 107,
+        "2025-04-11": 127,
+        "2025-04-12": 15,
+        "2025-04-13": 15,
+        "2025-04-14": 83,
+        "2025-04-15": 264,
+        "2025-04-16": 375,
+        "2025-04-17": 314,
+        "2025-04-18": 99,
+        "2025-04-19": 36,
+        "2025-04-20": 19,
+        "2025-04-21": 49,
+        "2025-04-22": 115,
+        "2025-04-23": 75,
+        "2025-04-24": 171,
+        "2025-04-25": 80,
+        "2025-04-26": 22,
+        "2025-04-27": 56,
+        "2025-04-28": 92,
+        "2025-04-29": 92,
+        "2025-04-30": 110,
+        "2025-05-01": 370,
+        "2025-05-02": 178,
+        "2025-05-03": 30,
+        "2025-05-04": 8,
+        "2025-05-05": 127,
+        "2025-05-06": 167,
+        "2025-05-07": 304,
+        "2025-05-08": 111,
+        "2025-05-09": 154,
+        "2025-05-10": 33,
+        "2025-05-11": 27,
+        "2025-05-12": 125,
+        "2025-05-13": 313,
+        "2025-05-14": 105,
+        "2025-05-15": 304,
+        "2025-05-16": 174,
+        "2025-05-17": 46,
+        "2025-05-18": 51,
+        "2025-05-19": 242,
+        "2025-05-20": 174,
+        "2025-05-21": 115,
+        "2025-05-22": 135,
+        "2025-05-23": 184,
+        "2025-05-24": 25,
+        "2025-05-25": 19,
+        "2025-05-26": 68,
+        "2025-05-27": 98,
+        "2025-05-28": 67,
+        "2025-05-29": 75,
+        "2025-05-30": 114,
+        "2025-05-31": 37,
+        "2025-06-01": 18,
+        "2025-06-02": 116,
+        "2025-06-03": 119,
+        "2025-06-04": 134,
+        "2025-06-05": 95,
+        "2025-06-06": 343,
+        "2025-06-07": 15,
+        "2025-06-08": 32,
+        "2025-06-09": 178,
+        "2025-06-10": 485,
+        "2025-06-11": 63,
+        "2025-06-12": 76,
+        "2025-06-13": 87,
+        "2025-06-14": 21,
+        "2025-06-15": 14,
+        "2025-06-16": 95,
+        "2025-06-17": 174,
+        "2025-06-18": 401,
+        "2025-06-19": 64,
+        "2025-06-20": 222,
+        "2025-06-21": 57,
+        "2025-06-22": 39,
+        "2025-06-23": 73,
+        "2025-06-24": 120,
+        "2025-06-25": 121,
+        "2025-06-26": 114,
+        "2025-06-27": 225,
+        "2025-06-28": 45,
+        "2025-06-29": 47,
+        "2025-06-30": 88,
+        "2025-07-01": 89,
+        "2025-07-02": 85,
+        "2025-07-03": 147,
+        "2025-07-04": 184,
+        "2025-07-05": 9,
+        "2025-07-06": 28,
+        "2025-07-07": 175,
+        "2025-07-08": 435,
+        "2025-07-09": 114,
+        "2025-07-10": 198,
+        "2025-07-11": 109,
+        "2025-07-12": 49,
+        "2025-07-13": 46,
+        "2025-07-14": 124,
+        "2025-07-15": 162,
+        "2025-07-16": 188,
+        "2025-07-17": 87,
+        "2025-07-18": 110,
+        "2025-07-19": 45,
+        "2025-07-20": 66,
+        "2025-07-21": 232,
+        "2025-07-22": 112,
+        "2025-07-23": 102,
+        "2025-07-24": 75,
+        "2025-07-25": 223,
+        "2025-07-26": 45,
+        "2025-07-27": 39,
+        "2025-07-28": 121,
+        "2025-07-29": 97,
+        "2025-07-30": 162,
+        "2025-07-31": 118,
+        "2025-08-01": 102,
+        "2025-08-02": 48,
+        "2025-08-03": 31,
+        "2025-08-04": 84,
+        "2025-08-05": 108,
+        "2025-08-06": 227,
+        "2025-08-07": 92,
+        "2025-08-08": 75,
+        "2025-08-09": 43,
+        "2025-08-10": 36,
+        "2025-08-11": 93,
+        "2025-08-12": 353,
+        "2025-08-13": 143,
+        "2025-08-14": 312,
+        "2025-08-15": 92,
+        "2025-08-16": 95,
+        "2025-08-17": 7,
+        "2025-08-18": 75,
+        "2025-08-19": 172,
+        "2025-08-20": 273,
+        "2025-08-21": 128,
+        "2025-08-22": 168,
+        "2025-08-23": 29,
+        "2025-08-24": 22,
+        "2025-08-25": 123,
+        "2025-08-26": 126,
+        "2025-08-27": 131,
+        "2025-08-28": 189,
+        "2025-08-29": 164,
+        "2025-08-30": 46,
+        "2025-08-31": 41,
+        "2025-09-01": 84,
+        "2025-09-02": 136,
+        "2025-09-03": 183,
+        "2025-09-04": 276,
+        "2025-09-05": 235,
+        "2025-09-06": 62,
+        "2025-09-07": 17,
+        "2025-09-08": 92,
+        "2025-09-09": 351,
+        "2025-09-10": 96,
+        "2025-09-11": 155,
+        "2025-09-12": 93,
+        "2025-09-13": 15,
+        "2025-09-14": 35,
+        "2025-09-15": 408,
+        "2025-09-16": 231,
+        "2025-09-17": 216,
+        "2025-09-18": 200,
+        "2025-09-19": 121,
+        "2025-09-20": 14,
+        "2025-09-21": 17,
+        "2025-09-22": 413,
+        "2025-09-23": 128,
+        "2025-09-24": 125,
+        "2025-09-25": 107,
+        "2025-09-26": 200,
+        "2025-09-27": 52,
+        "2025-09-28": 36,
+        "2025-09-29": 114,
+        "2025-09-30": 109,
+        "2025-10-01": 242,
+        "2025-10-02": 121,
+        "2025-10-03": 157,
+        "2025-10-04": 159,
+        "2025-10-05": 38,
+        "2025-10-06": 114,
+        "2025-10-07": 236,
+        "2025-10-08": 105,
+        "2025-10-09": 171,
+        "2025-10-10": 124,
+        "2025-10-11": 76,
+        "2025-10-12": 35,
+        "2025-10-13": 91,
+        "2025-10-14": 369,
+        "2025-10-15": 187,
+        "2025-10-16": 132,
+        "2025-10-17": 83,
+        "2025-10-18": 42,
+        "2025-10-19": 11,
+        "2025-10-20": 79,
+        "2025-10-21": 147,
+        "2025-10-22": 389,
+        "2025-10-23": 97,
+        "2025-10-24": 99,
+        "2025-10-25": 39,
+        "2025-10-26": 5,
+        "2025-10-27": 309,
+        "2025-10-28": 153,
+        "2025-10-29": 148,
+        "2025-10-30": 204,
+        "2025-10-31": 111,
+        "2025-11-01": 34,
+        "2025-11-02": 8,
+        "2025-11-03": 61,
+        "2025-11-04": 255,
+        "2025-11-05": 100,
+        "2025-11-06": 246,
+        "2025-11-07": 111,
+        "2025-11-08": 48,
+        "2025-11-09": 7,
+        "2025-11-10": 119,
+        "2025-11-11": 323,
+        "2025-11-12": 212,
+        "2025-11-13": 150,
+        "2025-11-14": 92,
+        "2025-11-15": 35,
+        "2025-11-16": 22,
+        "2025-11-17": 117,
+        "2025-11-18": 188,
+        "2025-11-19": 123,
+        "2025-11-20": 101,
+        "2025-11-21": 162,
+        "2025-11-22": 9,
+        "2025-11-23": 31,
+        "2025-11-24": 96,
+        "2025-11-25": 120,
+        "2025-11-26": 104,
+        "2025-11-27": 53,
+        "2025-11-28": 45,
+        "2025-11-29": 27,
+        "2025-11-30": 22,
+        "2025-12-01": 144,
+        "2025-12-02": 177,
+        "2025-12-03": 93,
+        "2025-12-04": 170,
+        "2025-12-05": 145,
+        "2025-12-06": 66,
+        "2025-12-07": 22,
+        "2025-12-08": 239,
+        "2025-12-09": 659,
+        "2025-12-10": 272,
+        "2025-12-11": 211,
+        "2025-12-12": 226,
+        "2025-12-13": 82,
+        "2025-12-14": 42,
+        "2025-12-15": 125,
+        "2025-12-16": 389,
+        "2025-12-17": 186,
+        "2025-12-18": 398,
+        "2025-12-19": 113,
+        "2025-12-20": 22,
+        "2025-12-21": 31,
+        "2025-12-22": 110,
+        "2025-12-23": 156,
+        "2025-12-24": 493,
+        "2025-12-25": 30,
+        "2025-12-26": 55,
+        "2025-12-27": 20,
+        "2025-12-28": 43,
+        "2025-12-29": 119,
+        "2025-12-30": 438,
+        "2025-12-31": 217
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 5899,
+      "severity_distribution": {
+        "UNKNOWN": 5899
+      },
+      "score_distribution": {
+        "6.0": 22,
+        "7.5": 1707,
+        "2.6": 102,
+        "6.2": 4,
+        "4.0": 578,
+        "4.3": 194,
+        "1.7": 124,
+        "5.8": 216,
+        "6.5": 1339,
+        "5.0": 406,
+        "5.1": 37,
+        "9.0": 530,
+        "3.3": 264,
+        "6.8": 39,
+        "3.5": 11,
+        "1.0": 23,
+        "5.2": 23,
+        "4.6": 19,
+        "7.8": 3,
+        "8.3": 25,
+        "3.4": 1,
+        "2.1": 31,
+        "7.6": 5,
+        "5.5": 55,
+        "1.8": 14,
+        "1.4": 3,
+        "6.4": 5,
+        "2.7": 7,
+        "1.2": 8,
+        "10.0": 47,
+        "2.2": 2,
+        "7.7": 24,
+        "7.2": 5,
+        "6.1": 5,
+        "3.2": 3,
+        "2.9": 1,
+        "7.4": 2,
+        "3.7": 2,
+        "2.3": 1,
+        "3.6": 1,
+        "4.8": 2,
+        "0.8": 5,
+        "4.7": 2,
+        "3.8": 1,
+        "5.9": 1
+      }
+    },
+    "v3.0": {
+      "total": 1136,
+      "severity_distribution": {
+        "MEDIUM": 339,
+        "CRITICAL": 97,
+        "LOW": 71,
+        "HIGH": 629
+      },
+      "score_distribution": {
+        "5.3": 43,
+        "5.6": 3,
+        "9.8": 55,
+        "5.5": 9,
+        "6.1": 25,
+        "6.8": 43,
+        "4.9": 5,
+        "4.0": 2,
+        "6.6": 5,
+        "3.1": 5,
+        "4.4": 4,
+        "7.3": 19,
+        "8.1": 22,
+        "3.6": 2,
+        "7.0": 13,
+        "7.8": 287,
+        "7.2": 22,
+        "7.5": 130,
+        "3.3": 38,
+        "8.0": 13,
+        "6.5": 59,
+        "9.1": 18,
+        "6.3": 17,
+        "8.3": 2,
+        "8.8": 67,
+        "4.6": 3,
+        "5.4": 29,
+        "7.6": 6,
+        "8.2": 13,
+        "2.4": 2,
+        "3.5": 10,
+        "7.1": 18,
+        "7.7": 4,
+        "9.6": 2,
+        "9.4": 6,
+        "7.4": 8,
+        "4.3": 39,
+        "5.8": 5,
+        "5.9": 8,
+        "10.0": 3,
+        "4.2": 2,
+        "8.4": 3,
+        "6.9": 1,
+        "9.0": 4,
+        "4.7": 2,
+        "6.7": 14,
+        "6.2": 3,
+        "9.3": 2,
+        "5.0": 3,
+        "4.8": 8,
+        "5.2": 2,
+        "2.7": 2,
+        "6.4": 2,
+        "3.7": 6,
+        "3.8": 3,
+        "9.9": 7,
+        "2.1": 1,
+        "2.5": 1,
+        "4.5": 2,
+        "5.1": 1,
+        "3.4": 1,
+        "8.6": 1,
+        "8.7": 1
+      }
+    },
+    "v3.1": {
+      "total": 44523,
+      "severity_distribution": {
+        "MEDIUM": 22169,
+        "CRITICAL": 3820,
+        "HIGH": 16457,
+        "LOW": 2073,
+        "NONE": 4
+      },
+      "score_distribution": {
+        "5.4": 1907,
+        "5.6": 112,
+        "9.8": 2533,
+        "8.8": 2481,
+        "7.5": 2848,
+        "7.4": 139,
+        "7.0": 248,
+        "8.3": 95,
+        "7.2": 592,
+        "6.1": 1383,
+        "6.5": 3560,
+        "9.9": 147,
+        "3.9": 23,
+        "3.4": 24,
+        "4.9": 381,
+        "5.0": 151,
+        "5.5": 3421,
+        "6.3": 1606,
+        "5.7": 117,
+        "7.3": 2119,
+        "3.1": 168,
+        "3.7": 189,
+        "7.8": 3111,
+        "4.4": 229,
+        "6.7": 304,
+        "6.2": 163,
+        "6.4": 1169,
+        "5.1": 120,
+        "5.3": 2033,
+        "8.2": 269,
+        "4.3": 2700,
+        "8.4": 220,
+        "8.1": 833,
+        "6.8": 311,
+        "4.1": 87,
+        "4.7": 485,
+        "5.8": 102,
+        "3.5": 590,
+        "9.1": 510,
+        "6.6": 162,
+        "7.1": 2255,
+        "10.0": 206,
+        "3.3": 322,
+        "5.9": 628,
+        "7.9": 32,
+        "3.0": 13,
+        "8.0": 193,
+        "8.9": 17,
+        "8.5": 210,
+        "4.8": 405,
+        "7.7": 158,
+        "2.7": 124,
+        "2.5": 46,
+        "4.6": 171,
+        "6.0": 90,
+        "4.2": 92,
+        "4.0": 163,
+        "3.8": 84,
+        "8.6": 252,
+        "2.6": 29,
+        "2.3": 20,
+        "2.9": 48,
+        "3.2": 35,
+        "7.6": 265,
+        "5.2": 32,
+        "4.5": 63,
+        "8.7": 120,
+        "2.8": 25,
+        "1.9": 9,
+        "9.3": 177,
+        "2.4": 262,
+        "9.6": 112,
+        "2.0": 21,
+        "1.6": 5,
+        "9.0": 95,
+        "9.4": 39,
+        "0.0": 4,
+        "2.2": 20,
+        "6.9": 22,
+        "1.8": 4,
+        "3.6": 9,
+        "2.1": 3,
+        "9.2": 1
+      }
+    },
+    "v4.0": {
+      "total": 12421,
+      "severity_distribution": {
+        "HIGH": 3209,
+        "CRITICAL": 1022,
+        "MEDIUM": 5808,
+        "LOW": 2373,
+        "NONE": 9
+      },
+      "score_distribution": {
+        "7.5": 59,
+        "8.7": 861,
+        "8.4": 169,
+        "9.3": 563,
+        "8.6": 276,
+        "10.0": 153,
+        "8.5": 259,
+        "9.4": 155,
+        "8.3": 67,
+        "7.3": 148,
+        "5.1": 814,
+        "6.9": 1327,
+        "7.1": 293,
+        "9.5": 31,
+        "7.2": 63,
+        "5.3": 1153,
+        "8.8": 104,
+        "9.2": 72,
+        "1.3": 67,
+        "2.9": 79,
+        "5.4": 103,
+        "6.8": 100,
+        "8.2": 78,
+        "1.9": 301,
+        "2.3": 121,
+        "5.2": 30,
+        "4.8": 410,
+        "5.9": 77,
+        "5.8": 31,
+        "4.3": 4,
+        "5.6": 20,
+        "7.4": 441,
+        "6.1": 35,
+        "6.0": 82,
+        "6.2": 17,
+        "9.9": 18,
+        "6.7": 24,
+        "7.0": 121,
+        "6.3": 164,
+        "2.1": 1151,
+        "2.4": 30,
+        "9.1": 14,
+        "4.6": 59,
+        "2.0": 478,
+        "7.7": 97,
+        "1.8": 21,
+        "5.7": 62,
+        "4.1": 16,
+        "7.6": 18,
+        "1.0": 25,
+        "6.4": 50,
+        "5.5": 1162,
+        "1.1": 23,
+        "9.0": 16,
+        "4.4": 5,
+        "8.1": 16,
+        "2.7": 28,
+        "4.5": 7,
+        "8.9": 111,
+        "4.7": 4,
+        "7.8": 18,
+        "6.6": 33,
+        "7.9": 6,
+        "4.0": 3,
+        "8.0": 4,
+        "1.7": 11,
+        "5.0": 4,
+        "0.0": 9,
+        "4.9": 7,
+        "6.5": 5,
+        "1.2": 11,
+        "2.6": 1,
+        "0.3": 8,
+        "0.9": 6,
+        "2.5": 1,
+        "0.5": 2,
+        "0.6": 3,
+        "2.2": 3,
+        "3.7": 1,
+        "3.8": 2
+      }
+    },
+    "unknown": {
+      "total": 897,
+      "severity_distribution": {
+        "UNKNOWN": 897
+      },
+      "score_distribution": {
+        "0.0": 897
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 697,
+      "epss_gt_0_5": 186,
+      "epss_gt_0_9": 58
+    }
+  },
+  "kev": {
+    "kev_count": 197
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Linux",
+        "count": 4720
+      },
+      {
+        "name": "Microsoft",
+        "count": 1938
+      },
+      {
+        "name": "Apple",
+        "count": 1110
+      },
+      {
+        "name": "Adobe",
+        "count": 829
+      },
+      {
+        "name": "Google",
+        "count": 690
+      },
+      {
+        "name": "Debian",
+        "count": 680
+      },
+      {
+        "name": "Phpgurukul",
+        "count": 615
+      },
+      {
+        "name": "Ibm",
+        "count": 609
+      },
+      {
+        "name": "Tenda",
+        "count": 469
+      },
+      {
+        "name": "Fabian",
+        "count": 353
+      },
+      {
+        "name": "Totolink",
+        "count": 339
+      },
+      {
+        "name": "Dlink",
+        "count": 329
+      },
+      {
+        "name": "Oracle",
+        "count": 322
+      },
+      {
+        "name": "Campcodes",
+        "count": 310
+      },
+      {
+        "name": "Samsung",
+        "count": 298
+      },
+      {
+        "name": "Qualcomm",
+        "count": 274
+      },
+      {
+        "name": "Fortinet",
+        "count": 237
+      },
+      {
+        "name": "Code-Projects",
+        "count": 231
+      },
+      {
+        "name": "Huawei",
+        "count": 224
+      },
+      {
+        "name": "Dell",
+        "count": 223
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-79",
+        "count": 8837
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 5313
+      },
+      {
+        "cwe": "CWE-74",
+        "count": 2573
+      },
+      {
+        "cwe": "CWE-862",
+        "count": 2413
+      },
+      {
+        "cwe": "CWE-352",
+        "count": 1996
+      },
+      {
+        "cwe": "CWE-476",
+        "count": 1580
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 1456
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 1293
+      },
+      {
+        "cwe": "CWE-284",
+        "count": 1253
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 1214
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 1172
+      },
+      {
+        "cwe": "CWE-119",
+        "count": 1160
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 1103
+      },
+      {
+        "cwe": "CWE-434",
+        "count": 1064
+      },
+      {
+        "cwe": "CWE-120",
+        "count": 1027
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 1003
+      },
+      {
+        "cwe": "CWE-121",
+        "count": 884
+      },
+      {
+        "cwe": "CWE-77",
+        "count": 860
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 834
+      },
+      {
+        "cwe": "CWE-401",
+        "count": 772
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Analyzed",
+        "count": 23649
+      },
+      {
+        "status": "Deferred",
+        "count": 17963
+      },
+      {
+        "status": "Modified",
+        "count": 6529
+      },
+      {
+        "status": "Undergoing Analysis",
+        "count": 11
+      },
+      {
+        "status": "Awaiting Analysis",
+        "count": 1
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Third Party Advisory",
+        "count": 28381
+      },
+      {
+        "tag": "Patch",
+        "count": 25931
+      },
+      {
+        "tag": "Exploit",
+        "count": 15853
+      },
+      {
+        "tag": "Vendor Advisory",
+        "count": 15307
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 15189
+      },
+      {
+        "tag": "Product",
+        "count": 6856
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 5921
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 5710
+      },
+      {
+        "tag": "Release Notes",
+        "count": 3416
+      },
+      {
+        "tag": "Mailing List",
+        "count": 1229
+      },
+      {
+        "tag": "Broken Link",
+        "count": 1222
+      },
+      {
+        "tag": "Mitigation",
+        "count": 535
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 424
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 370
+      },
+      {
+        "tag": "Technical Description",
+        "count": 184
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 103
+      },
+      {
+        "tag": "Related",
+        "count": 8
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 5
+      },
+      {
+        "tag": "Tool Signature",
+        "count": 1
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:50.312530",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_2026.json b/web/data/cve_2026.json
new file mode 100644
index 00000000000..17ebc967754
--- /dev/null
+++ b/web/data/cve_2026.json
@@ -0,0 +1,907 @@
+{
+  "year": 2026,
+  "total_cves": 69597,
+  "date_data": {
+    "monthly_distribution": {
+      "1": 4302,
+      "2": 4616,
+      "3": 6234,
+      "4": 5810,
+      "5": 6938,
+      "6": 7942,
+      "7": 9770,
+      "8": 12259,
+      "9": 11726,
+      "10": 0,
+      "11": 0,
+      "12": 0
+    },
+    "daily_analysis": {
+      "total_days": 264,
+      "avg_per_day": 263.62,
+      "highest_day": {
+        "date": "2026-09-08",
+        "count": 1559
+      },
+      "lowest_day": {
+        "date": "2026-01-03",
+        "count": 3
+      },
+      "daily_counts": {
+        "2026-01-01": 35,
+        "2026-01-02": 105,
+        "2026-01-03": 3,
+        "2026-01-04": 15,
+        "2026-01-05": 144,
+        "2026-01-06": 156,
+        "2026-01-07": 235,
+        "2026-01-08": 212,
+        "2026-01-09": 129,
+        "2026-01-10": 74,
+        "2026-01-11": 12,
+        "2026-01-12": 87,
+        "2026-01-13": 443,
+        "2026-01-14": 181,
+        "2026-01-15": 151,
+        "2026-01-16": 187,
+        "2026-01-17": 38,
+        "2026-01-18": 28,
+        "2026-01-19": 111,
+        "2026-01-20": 237,
+        "2026-01-21": 118,
+        "2026-01-22": 443,
+        "2026-01-23": 253,
+        "2026-01-24": 70,
+        "2026-01-25": 31,
+        "2026-01-26": 115,
+        "2026-01-27": 189,
+        "2026-01-28": 211,
+        "2026-01-29": 123,
+        "2026-01-30": 122,
+        "2026-01-31": 44,
+        "2026-02-01": 34,
+        "2026-02-02": 146,
+        "2026-02-03": 346,
+        "2026-02-04": 237,
+        "2026-02-05": 132,
+        "2026-02-06": 172,
+        "2026-02-07": 83,
+        "2026-02-08": 75,
+        "2026-02-09": 163,
+        "2026-02-10": 285,
+        "2026-02-11": 325,
+        "2026-02-12": 123,
+        "2026-02-13": 63,
+        "2026-02-14": 163,
+        "2026-02-15": 30,
+        "2026-02-16": 88,
+        "2026-02-17": 96,
+        "2026-02-18": 237,
+        "2026-02-19": 374,
+        "2026-02-20": 385,
+        "2026-02-21": 73,
+        "2026-02-22": 57,
+        "2026-02-23": 93,
+        "2026-02-24": 228,
+        "2026-02-25": 222,
+        "2026-02-26": 168,
+        "2026-02-27": 203,
+        "2026-02-28": 15,
+        "2026-03-01": 20,
+        "2026-03-02": 219,
+        "2026-03-03": 137,
+        "2026-03-04": 200,
+        "2026-03-05": 463,
+        "2026-03-06": 209,
+        "2026-03-07": 110,
+        "2026-03-08": 81,
+        "2026-03-09": 114,
+        "2026-03-10": 387,
+        "2026-03-11": 336,
+        "2026-03-12": 178,
+        "2026-03-13": 247,
+        "2026-03-14": 0,
+        "2026-03-15": 0,
+        "2026-03-16": 325,
+        "2026-03-17": 103,
+        "2026-03-18": 201,
+        "2026-03-19": 230,
+        "2026-03-20": 299,
+        "2026-03-21": 182,
+        "2026-03-22": 77,
+        "2026-03-23": 181,
+        "2026-03-24": 274,
+        "2026-03-25": 606,
+        "2026-03-26": 297,
+        "2026-03-27": 246,
+        "2026-03-28": 56,
+        "2026-03-29": 47,
+        "2026-03-30": 139,
+        "2026-03-31": 270,
+        "2026-04-01": 235,
+        "2026-04-02": 254,
+        "2026-04-03": 215,
+        "2026-04-04": 69,
+        "2026-04-05": 111,
+        "2026-04-06": 253,
+        "2026-04-07": 271,
+        "2026-04-08": 487,
+        "2026-04-09": 271,
+        "2026-04-10": 220,
+        "2026-04-11": 39,
+        "2026-04-12": 54,
+        "2026-04-13": 220,
+        "2026-04-14": 395,
+        "2026-04-15": 200,
+        "2026-04-16": 130,
+        "2026-04-17": 151,
+        "2026-04-18": 53,
+        "2026-04-19": 22,
+        "2026-04-20": 164,
+        "2026-04-21": 354,
+        "2026-04-22": 338,
+        "2026-04-23": 187,
+        "2026-04-24": 285,
+        "2026-04-25": 40,
+        "2026-04-26": 76,
+        "2026-04-27": 177,
+        "2026-04-28": 245,
+        "2026-04-29": 133,
+        "2026-04-30": 161,
+        "2026-05-01": 263,
+        "2026-05-02": 73,
+        "2026-05-03": 41,
+        "2026-05-04": 189,
+        "2026-05-05": 193,
+        "2026-05-06": 482,
+        "2026-05-07": 201,
+        "2026-05-08": 424,
+        "2026-05-09": 70,
+        "2026-05-10": 101,
+        "2026-05-11": 354,
+        "2026-05-12": 554,
+        "2026-05-13": 346,
+        "2026-05-14": 305,
+        "2026-05-15": 211,
+        "2026-05-16": 47,
+        "2026-05-17": 62,
+        "2026-05-18": 103,
+        "2026-05-19": 201,
+        "2026-05-20": 206,
+        "2026-05-21": 189,
+        "2026-05-22": 152,
+        "2026-05-23": 41,
+        "2026-05-24": 62,
+        "2026-05-25": 188,
+        "2026-05-26": 274,
+        "2026-05-27": 716,
+        "2026-05-28": 543,
+        "2026-05-29": 249,
+        "2026-05-30": 48,
+        "2026-05-31": 50,
+        "2026-06-01": 376,
+        "2026-06-02": 224,
+        "2026-06-03": 154,
+        "2026-06-04": 553,
+        "2026-06-05": 229,
+        "2026-06-06": 54,
+        "2026-06-07": 20,
+        "2026-06-08": 215,
+        "2026-06-09": 747,
+        "2026-06-10": 296,
+        "2026-06-11": 193,
+        "2026-06-12": 279,
+        "2026-06-13": 23,
+        "2026-06-14": 16,
+        "2026-06-15": 395,
+        "2026-06-16": 214,
+        "2026-06-17": 732,
+        "2026-06-18": 143,
+        "2026-06-19": 203,
+        "2026-06-20": 45,
+        "2026-06-21": 68,
+        "2026-06-22": 221,
+        "2026-06-23": 255,
+        "2026-06-24": 509,
+        "2026-06-25": 472,
+        "2026-06-26": 362,
+        "2026-06-27": 31,
+        "2026-06-28": 42,
+        "2026-06-29": 239,
+        "2026-06-30": 632,
+        "2026-07-01": 370,
+        "2026-07-02": 250,
+        "2026-07-03": 200,
+        "2026-07-04": 70,
+        "2026-07-05": 86,
+        "2026-07-06": 195,
+        "2026-07-07": 167,
+        "2026-07-08": 362,
+        "2026-07-09": 270,
+        "2026-07-10": 358,
+        "2026-07-11": 78,
+        "2026-07-12": 61,
+        "2026-07-13": 338,
+        "2026-07-14": 1008,
+        "2026-07-15": 266,
+        "2026-07-16": 242,
+        "2026-07-17": 296,
+        "2026-07-18": 80,
+        "2026-07-19": 462,
+        "2026-07-20": 265,
+        "2026-07-21": 1474,
+        "2026-07-22": 201,
+        "2026-07-23": 374,
+        "2026-07-24": 196,
+        "2026-07-25": 284,
+        "2026-07-26": 15,
+        "2026-07-27": 440,
+        "2026-07-28": 241,
+        "2026-07-29": 274,
+        "2026-07-30": 664,
+        "2026-07-31": 183,
+        "2026-08-01": 145,
+        "2026-08-02": 52,
+        "2026-08-03": 293,
+        "2026-08-04": 283,
+        "2026-08-05": 423,
+        "2026-08-06": 477,
+        "2026-08-07": 231,
+        "2026-08-08": 54,
+        "2026-08-09": 84,
+        "2026-08-10": 674,
+        "2026-08-11": 931,
+        "2026-08-12": 426,
+        "2026-08-13": 611,
+        "2026-08-14": 204,
+        "2026-08-15": 921,
+        "2026-08-16": 109,
+        "2026-08-17": 337,
+        "2026-08-18": 1406,
+        "2026-08-19": 672,
+        "2026-08-20": 469,
+        "2026-08-21": 258,
+        "2026-08-22": 236,
+        "2026-08-23": 45,
+        "2026-08-24": 310,
+        "2026-08-25": 750,
+        "2026-08-26": 396,
+        "2026-08-27": 365,
+        "2026-08-28": 582,
+        "2026-08-29": 64,
+        "2026-08-30": 91,
+        "2026-08-31": 360,
+        "2026-09-01": 450,
+        "2026-09-02": 342,
+        "2026-09-03": 349,
+        "2026-09-04": 554,
+        "2026-09-05": 143,
+        "2026-09-06": 90,
+        "2026-09-07": 255,
+        "2026-09-08": 1559,
+        "2026-09-09": 655,
+        "2026-09-10": 381,
+        "2026-09-11": 708,
+        "2026-09-12": 91,
+        "2026-09-13": 130,
+        "2026-09-14": 782,
+        "2026-09-15": 1422,
+        "2026-09-16": 878,
+        "2026-09-17": 1019,
+        "2026-09-18": 522,
+        "2026-09-19": 107,
+        "2026-09-20": 102,
+        "2026-09-21": 288,
+        "2026-09-22": 449,
+        "2026-09-23": 450
+      }
+    }
+  },
+  "cvss": {
+    "v2.0": {
+      "total": 5118,
+      "severity_distribution": {
+        "UNKNOWN": 5118
+      },
+      "score_distribution": {
+        "5.0": 496,
+        "4.3": 186,
+        "4.6": 34,
+        "6.5": 1122,
+        "7.5": 1119,
+        "5.8": 205,
+        "3.3": 133,
+        "1.7": 196,
+        "9.0": 520,
+        "4.0": 401,
+        "5.5": 52,
+        "2.6": 105,
+        "6.4": 40,
+        "10.0": 158,
+        "8.3": 92,
+        "6.0": 14,
+        "4.7": 11,
+        "2.1": 28,
+        "5.1": 47,
+        "1.2": 3,
+        "6.2": 1,
+        "5.9": 1,
+        "2.2": 1,
+        "7.6": 10,
+        "6.8": 44,
+        "1.8": 8,
+        "3.6": 5,
+        "5.2": 10,
+        "1.0": 18,
+        "3.5": 6,
+        "6.1": 2,
+        "2.7": 4,
+        "7.8": 3,
+        "7.7": 7,
+        "8.5": 2,
+        "3.2": 11,
+        "1.4": 8,
+        "2.4": 10,
+        "7.1": 2,
+        "4.8": 1,
+        "2.9": 2
+      }
+    },
+    "v3.0": {
+      "total": 628,
+      "severity_distribution": {
+        "MEDIUM": 195,
+        "CRITICAL": 65,
+        "HIGH": 336,
+        "LOW": 29,
+        "NONE": 3
+      },
+      "score_distribution": {
+        "6.4": 2,
+        "9.6": 6,
+        "7.5": 45,
+        "9.1": 4,
+        "7.8": 117,
+        "6.3": 12,
+        "8.1": 18,
+        "4.2": 2,
+        "7.1": 14,
+        "2.8": 1,
+        "6.5": 23,
+        "5.9": 10,
+        "7.0": 7,
+        "9.8": 40,
+        "3.3": 10,
+        "6.0": 1,
+        "5.3": 18,
+        "5.7": 4,
+        "10.0": 7,
+        "4.4": 5,
+        "5.5": 9,
+        "7.3": 17,
+        "4.7": 9,
+        "8.8": 51,
+        "4.8": 4,
+        "5.8": 2,
+        "2.7": 2,
+        "6.1": 13,
+        "7.2": 34,
+        "6.7": 12,
+        "7.9": 1,
+        "4.9": 2,
+        "8.2": 4,
+        "4.3": 26,
+        "4.6": 2,
+        "5.4": 16,
+        "7.6": 1,
+        "6.8": 12,
+        "8.6": 4,
+        "8.7": 2,
+        "5.0": 3,
+        "7.7": 3,
+        "8.3": 5,
+        "8.0": 7,
+        "2.2": 1,
+        "4.1": 2,
+        "7.4": 2,
+        "8.5": 4,
+        "9.0": 1,
+        "9.3": 1,
+        "1.8": 1,
+        "9.9": 6,
+        "3.7": 4,
+        "0.0": 3,
+        "5.6": 1,
+        "2.4": 4,
+        "3.8": 1,
+        "3.1": 2,
+        "5.2": 1,
+        "6.2": 2,
+        "6.6": 1,
+        "3.5": 1,
+        "3.9": 1,
+        "2.5": 1,
+        "4.0": 1
+      }
+    },
+    "v3.1": {
+      "total": 63243,
+      "severity_distribution": {
+        "HIGH": 27333,
+        "CRITICAL": 7634,
+        "MEDIUM": 25693,
+        "LOW": 2556,
+        "NONE": 27
+      },
+      "score_distribution": {
+        "7.5": 5834,
+        "9.8": 3914,
+        "9.1": 1279,
+        "5.3": 3190,
+        "6.1": 1539,
+        "7.2": 1129,
+        "6.4": 1049,
+        "8.2": 975,
+        "9.9": 677,
+        "8.8": 4619,
+        "4.3": 3097,
+        "6.2": 442,
+        "5.5": 2909,
+        "7.8": 4148,
+        "8.4": 547,
+        "8.1": 2348,
+        "7.1": 1995,
+        "5.4": 1937,
+        "10.0": 452,
+        "5.9": 732,
+        "6.5": 4741,
+        "6.8": 524,
+        "4.0": 126,
+        "8.3": 550,
+        "8.6": 509,
+        "7.6": 363,
+        "3.5": 329,
+        "6.3": 1545,
+        "4.8": 387,
+        "4.1": 76,
+        "8.0": 373,
+        "4.9": 455,
+        "6.7": 307,
+        "5.0": 282,
+        "7.7": 535,
+        "7.3": 1646,
+        "7.4": 501,
+        "4.6": 197,
+        "2.0": 22,
+        "9.0": 187,
+        "3.3": 437,
+        "3.7": 477,
+        "2.4": 152,
+        "5.8": 205,
+        "5.6": 112,
+        "9.4": 116,
+        "2.7": 233,
+        "3.1": 396,
+        "9.6": 605,
+        "2.9": 58,
+        "7.0": 517,
+        "5.7": 179,
+        "4.2": 238,
+        "8.5": 383,
+        "8.9": 37,
+        "3.4": 37,
+        "4.7": 497,
+        "9.3": 399,
+        "5.1": 74,
+        "7.9": 52,
+        "4.4": 397,
+        "2.2": 34,
+        "6.6": 195,
+        "8.7": 272,
+        "2.3": 18,
+        "6.0": 121,
+        "3.8": 104,
+        "3.2": 23,
+        "2.6": 41,
+        "2.8": 26,
+        "1.8": 9,
+        "6.9": 47,
+        "4.5": 53,
+        "3.9": 24,
+        "5.2": 40,
+        "1.9": 14,
+        "0.0": 27,
+        "3.0": 25,
+        "3.6": 40,
+        "2.5": 54,
+        "9.2": 5,
+        "2.1": 3
+      }
+    },
+    "v4.0": {
+      "total": 21762,
+      "severity_distribution": {
+        "CRITICAL": 2156,
+        "MEDIUM": 7730,
+        "HIGH": 8258,
+        "LOW": 3566,
+        "NONE": 52
+      },
+      "score_distribution": {
+        "9.3": 1150,
+        "6.9": 1503,
+        "8.7": 2022,
+        "5.1": 1115,
+        "8.8": 595,
+        "5.3": 1201,
+        "6.8": 258,
+        "8.5": 659,
+        "8.6": 752,
+        "7.1": 1183,
+        "7.0": 252,
+        "9.1": 98,
+        "8.4": 334,
+        "4.8": 314,
+        "6.7": 95,
+        "4.6": 160,
+        "9.0": 58,
+        "7.7": 284,
+        "7.2": 208,
+        "6.3": 545,
+        "7.3": 247,
+        "1.8": 36,
+        "8.3": 247,
+        "9.2": 331,
+        "5.5": 1327,
+        "5.6": 51,
+        "4.1": 24,
+        "8.2": 358,
+        "2.3": 307,
+        "5.9": 172,
+        "1.7": 32,
+        "2.0": 470,
+        "6.0": 274,
+        "2.7": 43,
+        "0.1": 2,
+        "5.7": 101,
+        "5.2": 38,
+        "7.5": 108,
+        "2.1": 1740,
+        "7.6": 163,
+        "1.9": 481,
+        "7.4": 526,
+        "1.3": 127,
+        "4.9": 58,
+        "1.2": 42,
+        "2.2": 3,
+        "8.1": 24,
+        "4.4": 13,
+        "9.4": 274,
+        "10.0": 177,
+        "7.9": 15,
+        "5.0": 7,
+        "6.6": 60,
+        "5.4": 93,
+        "8.9": 229,
+        "2.4": 38,
+        "9.5": 57,
+        "5.8": 86,
+        "3.8": 3,
+        "0.0": 52,
+        "0.4": 1,
+        "1.1": 46,
+        "1.0": 19,
+        "6.2": 28,
+        "4.5": 12,
+        "4.0": 13,
+        "0.6": 12,
+        "3.6": 6,
+        "4.7": 10,
+        "2.9": 133,
+        "6.4": 55,
+        "0.9": 13,
+        "6.1": 81,
+        "4.3": 23,
+        "7.8": 42,
+        "8.0": 10,
+        "6.5": 12,
+        "0.3": 4,
+        "9.9": 11,
+        "2.5": 1,
+        "3.3": 2,
+        "0.5": 4,
+        "1.6": 1,
+        "4.2": 1
+      }
+    },
+    "unknown": {
+      "total": 1849,
+      "severity_distribution": {
+        "UNKNOWN": 1849
+      },
+      "score_distribution": {
+        "0.0": 1849
+      }
+    },
+    "epss_summary": {
+      "epss_gt_0_1": 315,
+      "epss_gt_0_5": 81,
+      "epss_gt_0_9": 23
+    }
+  },
+  "kev": {
+    "kev_count": 165
+  },
+  "vendors": {
+    "cna_assigners": [],
+    "cpe_vendors": [
+      {
+        "name": "Microsoft",
+        "count": 4359
+      },
+      {
+        "name": "Linux",
+        "count": 4213
+      },
+      {
+        "name": "Google",
+        "count": 3286
+      },
+      {
+        "name": "Oracle",
+        "count": 2692
+      },
+      {
+        "name": "Apple",
+        "count": 2289
+      },
+      {
+        "name": "Ibm",
+        "count": 814
+      },
+      {
+        "name": "Adobe",
+        "count": 783
+      },
+      {
+        "name": "Apache",
+        "count": 727
+      },
+      {
+        "name": "Openclaw",
+        "count": 577
+      },
+      {
+        "name": "Mozilla",
+        "count": 435
+      },
+      {
+        "name": "Redhat",
+        "count": 399
+      },
+      {
+        "name": "Dell",
+        "count": 376
+      },
+      {
+        "name": "Tenda",
+        "count": 272
+      },
+      {
+        "name": "Dlink",
+        "count": 211
+      },
+      {
+        "name": "Gitlab",
+        "count": 186
+      },
+      {
+        "name": "Samsung",
+        "count": 183
+      },
+      {
+        "name": "Nvidia",
+        "count": 177
+      },
+      {
+        "name": "Vmware",
+        "count": 177
+      },
+      {
+        "name": "N8N",
+        "count": 162
+      },
+      {
+        "name": "Cisco",
+        "count": 156
+      }
+    ]
+  },
+  "cwe": {
+    "top_cwes": [
+      {
+        "cwe": "CWE-79",
+        "count": 6342
+      },
+      {
+        "cwe": "CWE-284",
+        "count": 3721
+      },
+      {
+        "cwe": "CWE-862",
+        "count": 3591
+      },
+      {
+        "cwe": "CWE-89",
+        "count": 3571
+      },
+      {
+        "cwe": "CWE-22",
+        "count": 2437
+      },
+      {
+        "cwe": "CWE-416",
+        "count": 2388
+      },
+      {
+        "cwe": "CWE-78",
+        "count": 1852
+      },
+      {
+        "cwe": "CWE-125",
+        "count": 1799
+      },
+      {
+        "cwe": "CWE-787",
+        "count": 1779
+      },
+      {
+        "cwe": "CWE-918",
+        "count": 1737
+      },
+      {
+        "cwe": "CWE-20",
+        "count": 1687
+      },
+      {
+        "cwe": "CWE-200",
+        "count": 1658
+      },
+      {
+        "cwe": "CWE-94",
+        "count": 1637
+      },
+      {
+        "cwe": "CWE-863",
+        "count": 1627
+      },
+      {
+        "cwe": "CWE-74",
+        "count": 1588
+      },
+      {
+        "cwe": "CWE-639",
+        "count": 1558
+      },
+      {
+        "cwe": "CWE-306",
+        "count": 1494
+      },
+      {
+        "cwe": "CWE-122",
+        "count": 1386
+      },
+      {
+        "cwe": "CWE-121",
+        "count": 1141
+      },
+      {
+        "cwe": "CWE-269",
+        "count": 1126
+      }
+    ]
+  },
+  "metadata": {
+    "vulnerability_status": [
+      {
+        "status": "Analyzed",
+        "count": 30074
+      },
+      {
+        "status": "Deferred",
+        "count": 25208
+      },
+      {
+        "status": "Awaiting Analysis",
+        "count": 4954
+      },
+      {
+        "status": "Received",
+        "count": 4268
+      },
+      {
+        "status": "Modified",
+        "count": 4230
+      },
+      {
+        "status": "Undergoing Analysis",
+        "count": 863
+      }
+    ],
+    "cve_tags": [],
+    "reference_tags": [
+      {
+        "tag": "Vendor Advisory",
+        "count": 32012
+      },
+      {
+        "tag": "Patch",
+        "count": 26171
+      },
+      {
+        "tag": "Third Party Advisory",
+        "count": 12540
+      },
+      {
+        "tag": "Exploit",
+        "count": 9808
+      },
+      {
+        "tag": "Release Notes",
+        "count": 9275
+      },
+      {
+        "tag": "Product",
+        "count": 5327
+      },
+      {
+        "tag": "Permissions Required",
+        "count": 4932
+      },
+      {
+        "tag": "VDB Entry",
+        "count": 4808
+      },
+      {
+        "tag": "Issue Tracking",
+        "count": 4477
+      },
+      {
+        "tag": "Mitigation",
+        "count": 3443
+      },
+      {
+        "tag": "Mailing List",
+        "count": 1621
+      },
+      {
+        "tag": "Broken Link",
+        "count": 719
+      },
+      {
+        "tag": "US Government Resource",
+        "count": 509
+      },
+      {
+        "tag": "Not Applicable",
+        "count": 305
+      },
+      {
+        "tag": "Technical Description",
+        "count": 61
+      },
+      {
+        "tag": "Press/Media Coverage",
+        "count": 24
+      },
+      {
+        "tag": "URL Repurposed",
+        "count": 3
+      }
+    ]
+  },
+  "processing_stats": {
+    "processed_at": "2026-09-23T22:50:51.525051",
+    "data_source": "data/cache/nvd.json"
+  }
+}
\ No newline at end of file
diff --git a/web/data/cve_all.json b/web/data/cve_all.json
new file mode 100644
index 00000000000..b6b16711ec2
--- /dev/null
+++ b/web/data/cve_all.json
@@ -0,0 +1,130 @@
+{
+  "generated_at": "2026-09-23T22:56:24.608997Z",
+  "data_as_of": "2026-09-23T22:49:26.546081Z",
+  "data_age_hours": 0.0,
+  "source_last_run": "2026-09-23T22:43:35.530306+00:00",
+  "source_age_hours": 0.1,
+  "source_cve_count": 396856,
+  "total_cves": 377799,
+  "years_covered": 28,
+  "current_year": 2026,
+  "current_year_cves": 69597,
+  "peak_year": 2026,
+  "peak_count": 69597,
+  "yoy_growth_rate": 44.5,
+  "excluded_pre_1999": 679,
+  "yearly_trend": [
+    {
+      "year": 1999,
+      "count": 894
+    },
+    {
+      "year": 2000,
+      "count": 1019
+    },
+    {
+      "year": 2001,
+      "count": 1676
+    },
+    {
+      "year": 2002,
+      "count": 2156
+    },
+    {
+      "year": 2003,
+      "count": 1527
+    },
+    {
+      "year": 2004,
+      "count": 2451
+    },
+    {
+      "year": 2005,
+      "count": 4932
+    },
+    {
+      "year": 2006,
+      "count": 6608
+    },
+    {
+      "year": 2007,
+      "count": 6516
+    },
+    {
+      "year": 2008,
+      "count": 5632
+    },
+    {
+      "year": 2009,
+      "count": 5732
+    },
+    {
+      "year": 2010,
+      "count": 4639
+    },
+    {
+      "year": 2011,
+      "count": 4150
+    },
+    {
+      "year": 2012,
+      "count": 5288
+    },
+    {
+      "year": 2013,
+      "count": 5187
+    },
+    {
+      "year": 2014,
+      "count": 7928
+    },
+    {
+      "year": 2015,
+      "count": 6494
+    },
+    {
+      "year": 2016,
+      "count": 6449
+    },
+    {
+      "year": 2017,
+      "count": 14642
+    },
+    {
+      "year": 2018,
+      "count": 16510
+    },
+    {
+      "year": 2019,
+      "count": 17305
+    },
+    {
+      "year": 2020,
+      "count": 18322
+    },
+    {
+      "year": 2021,
+      "count": 20149
+    },
+    {
+      "year": 2022,
+      "count": 25074
+    },
+    {
+      "year": 2023,
+      "count": 28816
+    },
+    {
+      "year": 2024,
+      "count": 39953
+    },
+    {
+      "year": 2025,
+      "count": 48153
+    },
+    {
+      "year": 2026,
+      "count": 69597
+    }
+  ]
+}
\ No newline at end of file
diff --git a/web/data/cvss_analysis.json b/web/data/cvss_analysis.json
new file mode 100644
index 00000000000..ee3f15eb4df
--- /dev/null
+++ b/web/data/cvss_analysis.json
@@ -0,0 +1,775 @@
+{
+  "generated_at": "2026-09-23T22:54:28.274238",
+  "total_cves_with_cvss": 541733,
+  "total_by_version": {
+    "v2.0": 195346,
+    "v3.0": 54691,
+    "v3.1": 253835,
+    "v4.0": 37861
+  },
+  "severity_distribution": {
+    "v2.0": {
+      "UNKNOWN": 195346
+    },
+    "v3.0": {
+      "HIGH": 24394,
+      "CRITICAL": 7438,
+      "MEDIUM": 21274,
+      "LOW": 1581,
+      "NONE": 4
+    },
+    "v3.1": {
+      "HIGH": 99836,
+      "CRITICAL": 30102,
+      "MEDIUM": 114008,
+      "LOW": 9845,
+      "NONE": 44
+    },
+    "v4.0": {
+      "HIGH": 12448,
+      "CRITICAL": 3463,
+      "MEDIUM": 15821,
+      "LOW": 6068,
+      "NONE": 61
+    }
+  },
+  "score_distribution": {
+    "v2.0": {
+      "10.0": 9020,
+      "5.0": 26844,
+      "7.5": 27042,
+      "4.6": 5466,
+      "5.1": 1169,
+      "3.7": 152,
+      "0.0": 17,
+      "6.4": 2735,
+      "7.2": 6194,
+      "4.9": 2056,
+      "2.1": 6846,
+      "7.8": 3230,
+      "2.6": 1408,
+      "6.2": 235,
+      "9.3": 8442,
+      "1.2": 183,
+      "3.6": 870,
+      "7.6": 1265,
+      "7.1": 1040,
+      "4.0": 9129,
+      "9.0": 3847,
+      "4.3": 27232,
+      "3.5": 7524,
+      "3.3": 1508,
+      "6.8": 15522,
+      "5.4": 1613,
+      "1.7": 432,
+      "6.9": 1501,
+      "1.9": 882,
+      "3.8": 16,
+      "8.5": 487,
+      "8.3": 486,
+      "6.6": 198,
+      "9.4": 125,
+      "5.8": 4269,
+      "8.8": 46,
+      "6.5": 9578,
+      "4.4": 1032,
+      "5.2": 587,
+      "4.8": 95,
+      "6.3": 149,
+      "6.0": 1016,
+      "4.7": 362,
+      "1.0": 56,
+      "5.5": 1776,
+      "5.6": 55,
+      "6.1": 461,
+      "5.7": 56,
+      "1.5": 36,
+      "3.2": 59,
+      "9.7": 11,
+      "2.3": 62,
+      "4.1": 57,
+      "2.7": 164,
+      "2.4": 22,
+      "2.9": 215,
+      "7.9": 85,
+      "7.3": 10,
+      "3.4": 2,
+      "7.4": 31,
+      "1.8": 44,
+      "3.0": 14,
+      "5.9": 15,
+      "8.0": 36,
+      "8.2": 5,
+      "1.3": 2,
+      "7.7": 143,
+      "2.8": 14,
+      "5.3": 1,
+      "6.7": 5,
+      "7.0": 10,
+      "1.4": 34,
+      "8.7": 6,
+      "0.8": 6,
+      "2.2": 3
+    },
+    "v3.0": {
+      "7.5": 6182,
+      "9.8": 6066,
+      "5.6": 88,
+      "6.1": 3787,
+      "5.9": 1079,
+      "4.2": 119,
+      "3.7": 242,
+      "6.3": 335,
+      "6.5": 3543,
+      "5.3": 1895,
+      "6.8": 616,
+      "4.9": 331,
+      "5.5": 2545,
+      "7.8": 6583,
+      "3.3": 664,
+      "8.1": 1075,
+      "7.3": 441,
+      "4.3": 1481,
+      "8.3": 147,
+      "8.6": 459,
+      "10.0": 282,
+      "8.0": 274,
+      "6.7": 322,
+      "9.1": 489,
+      "7.2": 777,
+      "8.8": 5652,
+      "9.9": 162,
+      "8.5": 156,
+      "8.7": 42,
+      "6.9": 18,
+      "4.4": 219,
+      "2.3": 22,
+      "5.8": 147,
+      "4.0": 159,
+      "8.4": 219,
+      "7.4": 347,
+      "6.2": 174,
+      "7.6": 170,
+      "5.4": 2231,
+      "5.1": 95,
+      "7.0": 547,
+      "7.7": 164,
+      "2.5": 38,
+      "4.7": 408,
+      "5.0": 145,
+      "3.5": 99,
+      "3.1": 166,
+      "6.6": 138,
+      "9.0": 149,
+      "9.6": 181,
+      "6.4": 215,
+      "4.6": 184,
+      "7.1": 539,
+      "4.1": 52,
+      "8.2": 598,
+      "2.0": 8,
+      "2.9": 19,
+      "2.6": 12,
+      "9.3": 62,
+      "5.7": 118,
+      "7.9": 18,
+      "3.4": 22,
+      "3.8": 44,
+      "4.8": 589,
+      "2.7": 86,
+      "6.0": 143,
+      "4.5": 39,
+      "3.0": 7,
+      "9.4": 47,
+      "2.4": 56,
+      "2.8": 20,
+      "2.1": 8,
+      "1.8": 5,
+      "1.9": 3,
+      "3.9": 27,
+      "5.2": 59,
+      "2.2": 15,
+      "3.6": 11,
+      "8.9": 4,
+      "1.6": 1,
+      "3.2": 6,
+      "0.0": 4
+    },
+    "v3.1": {
+      "7.3": 5415,
+      "7.5": 22674,
+      "9.8": 20821,
+      "8.2": 2385,
+      "7.8": 20863,
+      "5.5": 16259,
+      "7.1": 6917,
+      "8.8": 18613,
+      "5.3": 10607,
+      "9.1": 3440,
+      "3.3": 1885,
+      "6.5": 18113,
+      "6.1": 10192,
+      "4.8": 2956,
+      "7.0": 1645,
+      "5.9": 3713,
+      "8.4": 1513,
+      "3.7": 1158,
+      "4.7": 2139,
+      "7.4": 1297,
+      "4.5": 239,
+      "4.3": 11517,
+      "5.0": 876,
+      "6.3": 5954,
+      "5.6": 431,
+      "8.1": 5523,
+      "7.2": 4833,
+      "5.4": 10825,
+      "4.6": 992,
+      "6.8": 2141,
+      "4.4": 1959,
+      "9.9": 1442,
+      "5.8": 637,
+      "7.7": 1240,
+      "5.7": 759,
+      "6.0": 640,
+      "9.6": 1252,
+      "6.7": 2511,
+      "9.0": 673,
+      "10.0": 1293,
+      "7.6": 1158,
+      "9.3": 898,
+      "4.9": 2168,
+      "4.2": 634,
+      "4.0": 667,
+      "3.4": 131,
+      "8.0": 1369,
+      "5.1": 396,
+      "6.6": 745,
+      "6.4": 4081,
+      "8.6": 1523,
+      "6.2": 1106,
+      "4.1": 411,
+      "2.5": 262,
+      "7.9": 180,
+      "8.9": 103,
+      "2.7": 643,
+      "2.4": 770,
+      "3.5": 2399,
+      "8.3": 1062,
+      "3.1": 894,
+      "3.8": 352,
+      "1.9": 52,
+      "2.6": 179,
+      "3.6": 87,
+      "2.8": 112,
+      "9.4": 274,
+      "5.2": 173,
+      "8.7": 585,
+      "2.1": 17,
+      "8.5": 938,
+      "2.2": 124,
+      "2.3": 115,
+      "6.9": 167,
+      "1.6": 8,
+      "3.9": 173,
+      "1.8": 30,
+      "2.0": 102,
+      "2.9": 168,
+      "3.0": 85,
+      "3.2": 97,
+      "1.7": 2,
+      "0.0": 44,
+      "9.2": 9
+    },
+    "v4.0": {
+      "7.1": 1578,
+      "8.7": 3240,
+      "10.0": 370,
+      "7.3": 498,
+      "9.3": 1855,
+      "8.6": 1106,
+      "6.9": 3358,
+      "5.9": 276,
+      "5.1": 2190,
+      "8.8": 738,
+      "5.3": 3453,
+      "2.1": 2927,
+      "9.2": 448,
+      "6.3": 762,
+      "5.5": 2496,
+      "5.2": 81,
+      "9.1": 120,
+      "2.0": 975,
+      "4.8": 778,
+      "5.4": 264,
+      "2.3": 461,
+      "8.2": 475,
+      "9.4": 463,
+      "1.9": 785,
+      "9.0": 79,
+      "1.0": 52,
+      "8.5": 997,
+      "7.5": 178,
+      "8.9": 358,
+      "5.7": 178,
+      "7.0": 415,
+      "7.7": 405,
+      "6.7": 126,
+      "6.8": 414,
+      "4.6": 237,
+      "8.1": 44,
+      "1.8": 65,
+      "8.4": 538,
+      "6.4": 108,
+      "1.3": 195,
+      "6.0": 383,
+      "8.3": 339,
+      "5.6": 77,
+      "7.4": 968,
+      "1.2": 58,
+      "7.2": 282,
+      "6.2": 49,
+      "7.8": 63,
+      "6.1": 118,
+      "9.5": 97,
+      "6.5": 18,
+      "9.9": 31,
+      "7.6": 188,
+      "5.8": 128,
+      "4.3": 31,
+      "4.1": 42,
+      "4.9": 67,
+      "2.4": 74,
+      "6.6": 102,
+      "4.4": 20,
+      "5.0": 15,
+      "2.7": 73,
+      "7.9": 24,
+      "2.9": 212,
+      "1.1": 69,
+      "4.5": 19,
+      "4.7": 14,
+      "4.0": 16,
+      "8.0": 14,
+      "1.7": 43,
+      "0.0": 61,
+      "2.6": 1,
+      "0.3": 12,
+      "0.9": 19,
+      "2.5": 2,
+      "0.5": 6,
+      "0.6": 15,
+      "2.2": 6,
+      "3.7": 1,
+      "3.8": 5,
+      "0.1": 2,
+      "0.4": 1,
+      "3.6": 6,
+      "3.3": 2,
+      "1.6": 1,
+      "4.2": 1
+    }
+  },
+  "binned_score_distribution": {
+    "v2.0": {
+      "0-0.99": 23,
+      "1-1.99": 1669,
+      "2-2.99": 8734,
+      "3-3.99": 10145,
+      "4-4.99": 45429,
+      "5-5.99": 36385,
+      "6-6.99": 31400,
+      "7-7.99": 39050,
+      "8-8.99": 1066,
+      "9-9.99": 12425,
+      "10.0": 9020
+    },
+    "v3.0": {
+      "0-0.99": 4,
+      "1-1.99": 9,
+      "2-2.99": 284,
+      "3-3.99": 1288,
+      "4-4.99": 3581,
+      "5-5.99": 8402,
+      "6-6.99": 9291,
+      "7-7.99": 15768,
+      "8-8.99": 8626,
+      "9-9.99": 7156,
+      "10.0": 282
+    },
+    "v3.1": {
+      "0-0.99": 44,
+      "1-1.99": 92,
+      "2-2.99": 2492,
+      "3-3.99": 7261,
+      "4-4.99": 23682,
+      "5-5.99": 44676,
+      "6-6.99": 45650,
+      "7-7.99": 66222,
+      "8-8.99": 33614,
+      "9-9.99": 28809,
+      "10.0": 1293
+    },
+    "v4.0": {
+      "0-0.99": 116,
+      "1-1.99": 1268,
+      "2-2.99": 4731,
+      "3-3.99": 14,
+      "4-4.99": 1225,
+      "5-5.99": 9158,
+      "6-6.99": 5438,
+      "7-7.99": 4599,
+      "8-8.99": 7849,
+      "9-9.99": 3093,
+      "10.0": 370
+    }
+  },
+  "temporal_data": {
+    "1999": {
+      "v2.0": 894,
+      "v3.0": 0,
+      "v3.1": 9,
+      "v4.0": 0
+    },
+    "2000": {
+      "v2.0": 1019,
+      "v3.0": 1,
+      "v3.1": 9,
+      "v4.0": 0
+    },
+    "2001": {
+      "v2.0": 1676,
+      "v3.0": 0,
+      "v3.1": 38,
+      "v4.0": 0
+    },
+    "2002": {
+      "v2.0": 2156,
+      "v3.0": 0,
+      "v3.1": 54,
+      "v4.0": 0
+    },
+    "2003": {
+      "v2.0": 1527,
+      "v3.0": 0,
+      "v3.1": 17,
+      "v4.0": 0
+    },
+    "2004": {
+      "v2.0": 2451,
+      "v3.0": 1,
+      "v3.1": 44,
+      "v4.0": 0
+    },
+    "2005": {
+      "v2.0": 4932,
+      "v3.0": 1,
+      "v3.1": 64,
+      "v4.0": 0
+    },
+    "2006": {
+      "v2.0": 6608,
+      "v3.0": 2,
+      "v3.1": 47,
+      "v4.0": 0
+    },
+    "2007": {
+      "v2.0": 6516,
+      "v3.0": 1,
+      "v3.1": 59,
+      "v4.0": 0
+    },
+    "2008": {
+      "v2.0": 5632,
+      "v3.0": 1,
+      "v3.1": 87,
+      "v4.0": 0
+    },
+    "2009": {
+      "v2.0": 5732,
+      "v3.0": 1,
+      "v3.1": 107,
+      "v4.0": 0
+    },
+    "2010": {
+      "v2.0": 4639,
+      "v3.0": 3,
+      "v3.1": 124,
+      "v4.0": 0
+    },
+    "2011": {
+      "v2.0": 4150,
+      "v3.0": 3,
+      "v3.1": 58,
+      "v4.0": 0
+    },
+    "2012": {
+      "v2.0": 5288,
+      "v3.0": 1,
+      "v3.1": 115,
+      "v4.0": 0
+    },
+    "2013": {
+      "v2.0": 5187,
+      "v3.0": 3,
+      "v3.1": 98,
+      "v4.0": 0
+    },
+    "2014": {
+      "v2.0": 7928,
+      "v3.0": 10,
+      "v3.1": 113,
+      "v4.0": 0
+    },
+    "2015": {
+      "v2.0": 6494,
+      "v3.0": 139,
+      "v3.1": 96,
+      "v4.0": 0
+    },
+    "2016": {
+      "v2.0": 6449,
+      "v3.0": 5474,
+      "v3.1": 791,
+      "v4.0": 0
+    },
+    "2017": {
+      "v2.0": 14642,
+      "v3.0": 13062,
+      "v3.1": 1802,
+      "v4.0": 3
+    },
+    "2018": {
+      "v2.0": 16510,
+      "v3.0": 15199,
+      "v3.1": 1853,
+      "v4.0": 0
+    },
+    "2019": {
+      "v2.0": 17305,
+      "v3.0": 9655,
+      "v3.1": 9227,
+      "v4.0": 0
+    },
+    "2020": {
+      "v2.0": 18322,
+      "v3.0": 2658,
+      "v3.1": 18322,
+      "v4.0": 5
+    },
+    "2021": {
+      "v2.0": 20149,
+      "v3.0": 1644,
+      "v3.1": 20045,
+      "v4.0": 10
+    },
+    "2022": {
+      "v2.0": 13226,
+      "v3.0": 2000,
+      "v3.1": 24978,
+      "v4.0": 31
+    },
+    "2023": {
+      "v2.0": 1926,
+      "v3.0": 1160,
+      "v3.1": 28815,
+      "v4.0": 53
+    },
+    "2024": {
+      "v2.0": 2971,
+      "v3.0": 1908,
+      "v3.1": 39097,
+      "v4.0": 3576
+    },
+    "2025": {
+      "v2.0": 5899,
+      "v3.0": 1136,
+      "v3.1": 44523,
+      "v4.0": 12421
+    },
+    "2026": {
+      "v2.0": 5118,
+      "v3.0": 628,
+      "v3.1": 63243,
+      "v4.0": 21762
+    }
+  },
+  "epss_global_buckets": {
+    "epss_gt_0_1": 17323,
+    "epss_gt_0_5": 4334,
+    "epss_gt_0_9": 801
+  },
+  "epss_by_year": {
+    "1999": {
+      "epss_gt_0_1": 110,
+      "epss_gt_0_5": 6,
+      "epss_gt_0_9": 0
+    },
+    "2000": {
+      "epss_gt_0_1": 148,
+      "epss_gt_0_5": 20,
+      "epss_gt_0_9": 2
+    },
+    "2001": {
+      "epss_gt_0_1": 191,
+      "epss_gt_0_5": 27,
+      "epss_gt_0_9": 4
+    },
+    "2002": {
+      "epss_gt_0_1": 289,
+      "epss_gt_0_5": 33,
+      "epss_gt_0_9": 2
+    },
+    "2003": {
+      "epss_gt_0_1": 204,
+      "epss_gt_0_5": 36,
+      "epss_gt_0_9": 1
+    },
+    "2004": {
+      "epss_gt_0_1": 273,
+      "epss_gt_0_5": 61,
+      "epss_gt_0_9": 0
+    },
+    "2005": {
+      "epss_gt_0_1": 383,
+      "epss_gt_0_5": 93,
+      "epss_gt_0_9": 1
+    },
+    "2006": {
+      "epss_gt_0_1": 524,
+      "epss_gt_0_5": 106,
+      "epss_gt_0_9": 4
+    },
+    "2007": {
+      "epss_gt_0_1": 665,
+      "epss_gt_0_5": 121,
+      "epss_gt_0_9": 3
+    },
+    "2008": {
+      "epss_gt_0_1": 562,
+      "epss_gt_0_5": 92,
+      "epss_gt_0_9": 7
+    },
+    "2009": {
+      "epss_gt_0_1": 524,
+      "epss_gt_0_5": 85,
+      "epss_gt_0_9": 8
+    },
+    "2010": {
+      "epss_gt_0_1": 563,
+      "epss_gt_0_5": 98,
+      "epss_gt_0_9": 12
+    },
+    "2011": {
+      "epss_gt_0_1": 480,
+      "epss_gt_0_5": 84,
+      "epss_gt_0_9": 6
+    },
+    "2012": {
+      "epss_gt_0_1": 482,
+      "epss_gt_0_5": 132,
+      "epss_gt_0_9": 32
+    },
+    "2013": {
+      "epss_gt_0_1": 557,
+      "epss_gt_0_5": 123,
+      "epss_gt_0_9": 12
+    },
+    "2014": {
+      "epss_gt_0_1": 717,
+      "epss_gt_0_5": 135,
+      "epss_gt_0_9": 21
+    },
+    "2015": {
+      "epss_gt_0_1": 839,
+      "epss_gt_0_5": 135,
+      "epss_gt_0_9": 25
+    },
+    "2016": {
+      "epss_gt_0_1": 734,
+      "epss_gt_0_5": 133,
+      "epss_gt_0_9": 20
+    },
+    "2017": {
+      "epss_gt_0_1": 978,
+      "epss_gt_0_5": 245,
+      "epss_gt_0_9": 46
+    },
+    "2018": {
+      "epss_gt_0_1": 1270,
+      "epss_gt_0_5": 263,
+      "epss_gt_0_9": 43
+    },
+    "2019": {
+      "epss_gt_0_1": 1042,
+      "epss_gt_0_5": 263,
+      "epss_gt_0_9": 57
+    },
+    "2020": {
+      "epss_gt_0_1": 900,
+      "epss_gt_0_5": 318,
+      "epss_gt_0_9": 82
+    },
+    "2021": {
+      "epss_gt_0_1": 1018,
+      "epss_gt_0_5": 426,
+      "epss_gt_0_9": 89
+    },
+    "2022": {
+      "epss_gt_0_1": 951,
+      "epss_gt_0_5": 308,
+      "epss_gt_0_9": 69
+    },
+    "2023": {
+      "epss_gt_0_1": 958,
+      "epss_gt_0_5": 390,
+      "epss_gt_0_9": 88
+    },
+    "2024": {
+      "epss_gt_0_1": 949,
+      "epss_gt_0_5": 334,
+      "epss_gt_0_9": 86
+    },
+    "2025": {
+      "epss_gt_0_1": 697,
+      "epss_gt_0_5": 186,
+      "epss_gt_0_9": 58
+    },
+    "2026": {
+      "epss_gt_0_1": 315,
+      "epss_gt_0_5": 81,
+      "epss_gt_0_9": 23
+    }
+  },
+  "kev_global_count": 1721,
+  "kev_by_year": {
+    "1999": 0,
+    "2000": 0,
+    "2001": 0,
+    "2002": 1,
+    "2003": 0,
+    "2004": 2,
+    "2005": 1,
+    "2006": 2,
+    "2007": 2,
+    "2008": 6,
+    "2009": 14,
+    "2010": 23,
+    "2011": 9,
+    "2012": 22,
+    "2013": 35,
+    "2014": 34,
+    "2015": 45,
+    "2016": 53,
+    "2017": 89,
+    "2018": 76,
+    "2019": 129,
+    "2020": 146,
+    "2021": 214,
+    "2022": 131,
+    "2023": 165,
+    "2024": 160,
+    "2025": 197,
+    "2026": 165
+  }
+}
\ No newline at end of file
diff --git a/web/data/cvss_analysis_current_year.json b/web/data/cvss_analysis_current_year.json
new file mode 100644
index 00000000000..6597c4756f1
--- /dev/null
+++ b/web/data/cvss_analysis_current_year.json
@@ -0,0 +1,372 @@
+{
+  "generated_at": "2026-09-23T22:54:28.275814",
+  "year": 2026,
+  "total_cves_with_cvss": 90751,
+  "total_by_version": {
+    "v2.0": 5118,
+    "v3.0": 628,
+    "v3.1": 63243,
+    "v4.0": 21762
+  },
+  "severity_distribution": {
+    "v2.0": {
+      "UNKNOWN": 5118
+    },
+    "v3.0": {
+      "MEDIUM": 195,
+      "CRITICAL": 65,
+      "HIGH": 336,
+      "LOW": 29,
+      "NONE": 3
+    },
+    "v3.1": {
+      "HIGH": 27333,
+      "CRITICAL": 7634,
+      "MEDIUM": 25693,
+      "LOW": 2556,
+      "NONE": 27
+    },
+    "v4.0": {
+      "CRITICAL": 2156,
+      "MEDIUM": 7730,
+      "HIGH": 8258,
+      "LOW": 3566,
+      "NONE": 52
+    }
+  },
+  "score_distribution": {
+    "v2.0": {
+      "5.0": 496,
+      "4.3": 186,
+      "4.6": 34,
+      "6.5": 1122,
+      "7.5": 1119,
+      "5.8": 205,
+      "3.3": 133,
+      "1.7": 196,
+      "9.0": 520,
+      "4.0": 401,
+      "5.5": 52,
+      "2.6": 105,
+      "6.4": 40,
+      "10.0": 158,
+      "8.3": 92,
+      "6.0": 14,
+      "4.7": 11,
+      "2.1": 28,
+      "5.1": 47,
+      "1.2": 3,
+      "6.2": 1,
+      "5.9": 1,
+      "2.2": 1,
+      "7.6": 10,
+      "6.8": 44,
+      "1.8": 8,
+      "3.6": 5,
+      "5.2": 10,
+      "1.0": 18,
+      "3.5": 6,
+      "6.1": 2,
+      "2.7": 4,
+      "7.8": 3,
+      "7.7": 7,
+      "8.5": 2,
+      "3.2": 11,
+      "1.4": 8,
+      "2.4": 10,
+      "7.1": 2,
+      "4.8": 1,
+      "2.9": 2
+    },
+    "v3.0": {
+      "6.4": 2,
+      "9.6": 6,
+      "7.5": 45,
+      "9.1": 4,
+      "7.8": 117,
+      "6.3": 12,
+      "8.1": 18,
+      "4.2": 2,
+      "7.1": 14,
+      "2.8": 1,
+      "6.5": 23,
+      "5.9": 10,
+      "7.0": 7,
+      "9.8": 40,
+      "3.3": 10,
+      "6.0": 1,
+      "5.3": 18,
+      "5.7": 4,
+      "10.0": 7,
+      "4.4": 5,
+      "5.5": 9,
+      "7.3": 17,
+      "4.7": 9,
+      "8.8": 51,
+      "4.8": 4,
+      "5.8": 2,
+      "2.7": 2,
+      "6.1": 13,
+      "7.2": 34,
+      "6.7": 12,
+      "7.9": 1,
+      "4.9": 2,
+      "8.2": 4,
+      "4.3": 26,
+      "4.6": 2,
+      "5.4": 16,
+      "7.6": 1,
+      "6.8": 12,
+      "8.6": 4,
+      "8.7": 2,
+      "5.0": 3,
+      "7.7": 3,
+      "8.3": 5,
+      "8.0": 7,
+      "2.2": 1,
+      "4.1": 2,
+      "7.4": 2,
+      "8.5": 4,
+      "9.0": 1,
+      "9.3": 1,
+      "1.8": 1,
+      "9.9": 6,
+      "3.7": 4,
+      "0.0": 3,
+      "5.6": 1,
+      "2.4": 4,
+      "3.8": 1,
+      "3.1": 2,
+      "5.2": 1,
+      "6.2": 2,
+      "6.6": 1,
+      "3.5": 1,
+      "3.9": 1,
+      "2.5": 1,
+      "4.0": 1
+    },
+    "v3.1": {
+      "7.5": 5834,
+      "9.8": 3914,
+      "9.1": 1279,
+      "5.3": 3190,
+      "6.1": 1539,
+      "7.2": 1129,
+      "6.4": 1049,
+      "8.2": 975,
+      "9.9": 677,
+      "8.8": 4619,
+      "4.3": 3097,
+      "6.2": 442,
+      "5.5": 2909,
+      "7.8": 4148,
+      "8.4": 547,
+      "8.1": 2348,
+      "7.1": 1995,
+      "5.4": 1937,
+      "10.0": 452,
+      "5.9": 732,
+      "6.5": 4741,
+      "6.8": 524,
+      "4.0": 126,
+      "8.3": 550,
+      "8.6": 509,
+      "7.6": 363,
+      "3.5": 329,
+      "6.3": 1545,
+      "4.8": 387,
+      "4.1": 76,
+      "8.0": 373,
+      "4.9": 455,
+      "6.7": 307,
+      "5.0": 282,
+      "7.7": 535,
+      "7.3": 1646,
+      "7.4": 501,
+      "4.6": 197,
+      "2.0": 22,
+      "9.0": 187,
+      "3.3": 437,
+      "3.7": 477,
+      "2.4": 152,
+      "5.8": 205,
+      "5.6": 112,
+      "9.4": 116,
+      "2.7": 233,
+      "3.1": 396,
+      "9.6": 605,
+      "2.9": 58,
+      "7.0": 517,
+      "5.7": 179,
+      "4.2": 238,
+      "8.5": 383,
+      "8.9": 37,
+      "3.4": 37,
+      "4.7": 497,
+      "9.3": 399,
+      "5.1": 74,
+      "7.9": 52,
+      "4.4": 397,
+      "2.2": 34,
+      "6.6": 195,
+      "8.7": 272,
+      "2.3": 18,
+      "6.0": 121,
+      "3.8": 104,
+      "3.2": 23,
+      "2.6": 41,
+      "2.8": 26,
+      "1.8": 9,
+      "6.9": 47,
+      "4.5": 53,
+      "3.9": 24,
+      "5.2": 40,
+      "1.9": 14,
+      "0.0": 27,
+      "3.0": 25,
+      "3.6": 40,
+      "2.5": 54,
+      "9.2": 5,
+      "2.1": 3
+    },
+    "v4.0": {
+      "9.3": 1150,
+      "6.9": 1503,
+      "8.7": 2022,
+      "5.1": 1115,
+      "8.8": 595,
+      "5.3": 1201,
+      "6.8": 258,
+      "8.5": 659,
+      "8.6": 752,
+      "7.1": 1183,
+      "7.0": 252,
+      "9.1": 98,
+      "8.4": 334,
+      "4.8": 314,
+      "6.7": 95,
+      "4.6": 160,
+      "9.0": 58,
+      "7.7": 284,
+      "7.2": 208,
+      "6.3": 545,
+      "7.3": 247,
+      "1.8": 36,
+      "8.3": 247,
+      "9.2": 331,
+      "5.5": 1327,
+      "5.6": 51,
+      "4.1": 24,
+      "8.2": 358,
+      "2.3": 307,
+      "5.9": 172,
+      "1.7": 32,
+      "2.0": 470,
+      "6.0": 274,
+      "2.7": 43,
+      "0.1": 2,
+      "5.7": 101,
+      "5.2": 38,
+      "7.5": 108,
+      "2.1": 1740,
+      "7.6": 163,
+      "1.9": 481,
+      "7.4": 526,
+      "1.3": 127,
+      "4.9": 58,
+      "1.2": 42,
+      "2.2": 3,
+      "8.1": 24,
+      "4.4": 13,
+      "9.4": 274,
+      "10.0": 177,
+      "7.9": 15,
+      "5.0": 7,
+      "6.6": 60,
+      "5.4": 93,
+      "8.9": 229,
+      "2.4": 38,
+      "9.5": 57,
+      "5.8": 86,
+      "3.8": 3,
+      "0.0": 52,
+      "0.4": 1,
+      "1.1": 46,
+      "1.0": 19,
+      "6.2": 28,
+      "4.5": 12,
+      "4.0": 13,
+      "0.6": 12,
+      "3.6": 6,
+      "4.7": 10,
+      "2.9": 133,
+      "6.4": 55,
+      "0.9": 13,
+      "6.1": 81,
+      "4.3": 23,
+      "7.8": 42,
+      "8.0": 10,
+      "6.5": 12,
+      "0.3": 4,
+      "9.9": 11,
+      "2.5": 1,
+      "3.3": 2,
+      "0.5": 4,
+      "1.6": 1,
+      "4.2": 1
+    }
+  },
+  "binned_score_distribution": {
+    "v2.0": {
+      "1-1.99": 233,
+      "2-2.99": 150,
+      "3-3.99": 155,
+      "4-4.99": 633,
+      "5-5.99": 811,
+      "6-6.99": 1223,
+      "7-7.99": 1141,
+      "8-8.99": 94,
+      "9-9.99": 520,
+      "10.0": 158
+    },
+    "v3.0": {
+      "0-0.99": 3,
+      "1-1.99": 1,
+      "2-2.99": 9,
+      "3-3.99": 19,
+      "4-4.99": 53,
+      "5-5.99": 64,
+      "6-6.99": 78,
+      "7-7.99": 241,
+      "8-8.99": 95,
+      "9-9.99": 58,
+      "10.0": 7
+    },
+    "v3.1": {
+      "0-0.99": 27,
+      "1-1.99": 23,
+      "2-2.99": 641,
+      "3-3.99": 1892,
+      "4-4.99": 5523,
+      "5-5.99": 9660,
+      "6-6.99": 10510,
+      "7-7.99": 16720,
+      "8-8.99": 10613,
+      "9-9.99": 7182,
+      "10.0": 452
+    },
+    "v4.0": {
+      "0-0.99": 88,
+      "1-1.99": 784,
+      "2-2.99": 2735,
+      "3-3.99": 11,
+      "4-4.99": 628,
+      "5-5.99": 4191,
+      "6-6.99": 2911,
+      "7-7.99": 3028,
+      "8-8.99": 5230,
+      "9-9.99": 1979,
+      "10.0": 177
+    }
+  }
+}
\ No newline at end of file
diff --git a/web/data/cwe_analysis.json b/web/data/cwe_analysis.json
new file mode 100644
index 00000000000..b6d455fc6c7
--- /dev/null
+++ b/web/data/cwe_analysis.json
@@ -0,0 +1,543 @@
+{
+  "generated_at": "2026-09-23T22:54:28.279152",
+  "total_cves_with_cwe": 269872,
+  "total_unique_cwes": 69,
+  "top_cwes": [
+    {
+      "id": "79",
+      "name": "CWE-79: Cross-site Scripting (XSS)",
+      "count": 53914,
+      "description": "Cross-site Scripting (XSS)"
+    },
+    {
+      "id": "89",
+      "name": "CWE-89: SQL Injection",
+      "count": 24511,
+      "description": "SQL Injection"
+    },
+    {
+      "id": "787",
+      "name": "CWE-787: Out-of-bounds Write",
+      "count": 17297,
+      "description": "Out-of-bounds Write"
+    },
+    {
+      "id": "20",
+      "name": "CWE-20: Improper Input Validation",
+      "count": 13705,
+      "description": "Improper Input Validation"
+    },
+    {
+      "id": "119",
+      "name": "CWE-119: Buffer Overflow",
+      "count": 12752,
+      "description": "Buffer Overflow"
+    },
+    {
+      "id": "22",
+      "name": "CWE-22: Path Traversal",
+      "count": 11674,
+      "description": "Path Traversal"
+    },
+    {
+      "id": "200",
+      "name": "CWE-200: Information Exposure",
+      "count": 11454,
+      "description": "Information Exposure"
+    },
+    {
+      "id": "125",
+      "name": "CWE-125: Out-of-bounds Read",
+      "count": 11297,
+      "description": "Out-of-bounds Read"
+    },
+    {
+      "id": "862",
+      "name": "CWE-862: Missing Authorization",
+      "count": 10880,
+      "description": "Missing Authorization"
+    },
+    {
+      "id": "416",
+      "name": "CWE-416: Use After Free",
+      "count": 10346,
+      "description": "Use After Free"
+    },
+    {
+      "id": "352",
+      "name": "CWE-352: Cross-Site Request Forgery (CSRF)",
+      "count": 9931,
+      "description": "Cross-Site Request Forgery (CSRF)"
+    },
+    {
+      "id": "78",
+      "name": "CWE-78: OS Command Injection",
+      "count": 7847,
+      "description": "OS Command Injection"
+    },
+    {
+      "id": "284",
+      "name": "CWE-284",
+      "count": 7459,
+      "description": "CWE-284"
+    },
+    {
+      "id": "94",
+      "name": "CWE-94: Code Injection",
+      "count": 6567,
+      "description": "Code Injection"
+    },
+    {
+      "id": "264",
+      "name": "CWE-264",
+      "count": 5092,
+      "description": "CWE-264"
+    },
+    {
+      "id": "476",
+      "name": "CWE-476: NULL Pointer Dereference",
+      "count": 4979,
+      "description": "NULL Pointer Dereference"
+    },
+    {
+      "id": "434",
+      "name": "CWE-434: Unrestricted Upload of File",
+      "count": 4382,
+      "description": "Unrestricted Upload of File"
+    },
+    {
+      "id": "120",
+      "name": "CWE-120",
+      "count": 4340,
+      "description": "CWE-120"
+    },
+    {
+      "id": "74",
+      "name": "CWE-74",
+      "count": 4161,
+      "description": "CWE-74"
+    },
+    {
+      "id": "287",
+      "name": "CWE-287: Improper Authentication",
+      "count": 3732,
+      "description": "Improper Authentication"
+    },
+    {
+      "id": "121",
+      "name": "CWE-121",
+      "count": 2928,
+      "description": "CWE-121"
+    },
+    {
+      "id": "863",
+      "name": "CWE-863: Incorrect Authorization",
+      "count": 2860,
+      "description": "Incorrect Authorization"
+    },
+    {
+      "id": "269",
+      "name": "CWE-269: Improper Privilege Management",
+      "count": 2622,
+      "description": "Improper Privilege Management"
+    },
+    {
+      "id": "77",
+      "name": "CWE-77",
+      "count": 2578,
+      "description": "CWE-77"
+    },
+    {
+      "id": "399",
+      "name": "CWE-399",
+      "count": 2439,
+      "description": "CWE-399"
+    },
+    {
+      "id": "310",
+      "name": "CWE-310",
+      "count": 2408,
+      "description": "CWE-310"
+    },
+    {
+      "id": "306",
+      "name": "CWE-306",
+      "count": 1994,
+      "description": "CWE-306"
+    },
+    {
+      "id": "122",
+      "name": "CWE-122",
+      "count": 1918,
+      "description": "CWE-122"
+    },
+    {
+      "id": "400",
+      "name": "CWE-400",
+      "count": 1765,
+      "description": "CWE-400"
+    },
+    {
+      "id": "918",
+      "name": "CWE-918",
+      "count": 1737,
+      "description": "CWE-918"
+    },
+    {
+      "id": "190",
+      "name": "CWE-190: Integer Overflow",
+      "count": 1595,
+      "description": "Integer Overflow"
+    },
+    {
+      "id": "639",
+      "name": "CWE-639",
+      "count": 1558,
+      "description": "CWE-639"
+    },
+    {
+      "id": "189",
+      "name": "CWE-189",
+      "count": 1150,
+      "description": "CWE-189"
+    },
+    {
+      "id": "502",
+      "name": "CWE-502",
+      "count": 842,
+      "description": "CWE-502"
+    },
+    {
+      "id": "401",
+      "name": "CWE-401",
+      "count": 774,
+      "description": "CWE-401"
+    },
+    {
+      "id": "255",
+      "name": "CWE-255",
+      "count": 628,
+      "description": "CWE-255"
+    },
+    {
+      "id": "732",
+      "name": "CWE-732",
+      "count": 456,
+      "description": "CWE-732"
+    },
+    {
+      "id": "59",
+      "name": "CWE-59",
+      "count": 430,
+      "description": "CWE-59"
+    },
+    {
+      "id": "362",
+      "name": "CWE-362",
+      "count": 350,
+      "description": "CWE-362"
+    },
+    {
+      "id": "254",
+      "name": "CWE-254",
+      "count": 266,
+      "description": "CWE-254"
+    },
+    {
+      "id": "16",
+      "name": "CWE-16",
+      "count": 239,
+      "description": "CWE-16"
+    },
+    {
+      "id": "276",
+      "name": "CWE-276",
+      "count": 225,
+      "description": "CWE-276"
+    },
+    {
+      "id": "798",
+      "name": "CWE-798",
+      "count": 221,
+      "description": "CWE-798"
+    },
+    {
+      "id": "611",
+      "name": "CWE-611",
+      "count": 208,
+      "description": "CWE-611"
+    },
+    {
+      "id": "522",
+      "name": "CWE-522",
+      "count": 195,
+      "description": "CWE-522"
+    },
+    {
+      "id": "295",
+      "name": "CWE-295: Improper Certificate Validation",
+      "count": 182,
+      "description": "Improper Certificate Validation"
+    },
+    {
+      "id": "311",
+      "name": "CWE-311",
+      "count": 179,
+      "description": "CWE-311"
+    },
+    {
+      "id": "772",
+      "name": "CWE-772",
+      "count": 171,
+      "description": "CWE-772"
+    },
+    {
+      "id": "17",
+      "name": "CWE-17",
+      "count": 141,
+      "description": "CWE-17"
+    },
+    {
+      "id": "426",
+      "name": "CWE-426",
+      "count": 141,
+      "description": "CWE-426"
+    },
+    {
+      "id": "19",
+      "name": "CWE-19",
+      "count": 119,
+      "description": "CWE-19"
+    },
+    {
+      "id": "134",
+      "name": "CWE-134",
+      "count": 110,
+      "description": "CWE-134"
+    },
+    {
+      "id": "88",
+      "name": "CWE-88",
+      "count": 19,
+      "description": "CWE-88"
+    },
+    {
+      "id": "203",
+      "name": "CWE-203",
+      "count": 18,
+      "description": "CWE-203"
+    },
+    {
+      "id": "193",
+      "name": "CWE-193",
+      "count": 16,
+      "description": "CWE-193"
+    },
+    {
+      "id": "667",
+      "name": "CWE-667",
+      "count": 9,
+      "description": "CWE-667"
+    },
+    {
+      "id": "425",
+      "name": "CWE-425",
+      "count": 9,
+      "description": "CWE-425"
+    },
+    {
+      "id": "131",
+      "name": "CWE-131",
+      "count": 8,
+      "description": "CWE-131"
+    },
+    {
+      "id": "326",
+      "name": "CWE-326",
+      "count": 8,
+      "description": "CWE-326"
+    },
+    {
+      "id": "459",
+      "name": "CWE-459",
+      "count": 7,
+      "description": "CWE-459"
+    },
+    {
+      "id": "178",
+      "name": "CWE-178",
+      "count": 6,
+      "description": "CWE-178"
+    },
+    {
+      "id": "415",
+      "name": "CWE-415",
+      "count": 6,
+      "description": "CWE-415"
+    },
+    {
+      "id": "307",
+      "name": "CWE-307",
+      "count": 4,
+      "description": "CWE-307"
+    },
+    {
+      "id": "601",
+      "name": "CWE-601",
+      "count": 4,
+      "description": "CWE-601"
+    },
+    {
+      "id": "312",
+      "name": "CWE-312",
+      "count": 3,
+      "description": "CWE-312"
+    },
+    {
+      "id": "346",
+      "name": "CWE-346",
+      "count": 2,
+      "description": "CWE-346"
+    },
+    {
+      "id": "281",
+      "name": "CWE-281",
+      "count": 2,
+      "description": "CWE-281"
+    },
+    {
+      "id": "384",
+      "name": "CWE-384",
+      "count": 1,
+      "description": "CWE-384"
+    },
+    {
+      "id": "665",
+      "name": "CWE-665",
+      "count": 1,
+      "description": "CWE-665"
+    }
+  ],
+  "top_cwes_limited": [
+    {
+      "id": "79",
+      "name": "CWE-79: Cross-site Scripting (XSS)",
+      "count": 53914,
+      "description": "Cross-site Scripting (XSS)"
+    },
+    {
+      "id": "89",
+      "name": "CWE-89: SQL Injection",
+      "count": 24511,
+      "description": "SQL Injection"
+    },
+    {
+      "id": "787",
+      "name": "CWE-787: Out-of-bounds Write",
+      "count": 17297,
+      "description": "Out-of-bounds Write"
+    },
+    {
+      "id": "20",
+      "name": "CWE-20: Improper Input Validation",
+      "count": 13705,
+      "description": "Improper Input Validation"
+    },
+    {
+      "id": "119",
+      "name": "CWE-119: Buffer Overflow",
+      "count": 12752,
+      "description": "Buffer Overflow"
+    },
+    {
+      "id": "22",
+      "name": "CWE-22: Path Traversal",
+      "count": 11674,
+      "description": "Path Traversal"
+    },
+    {
+      "id": "200",
+      "name": "CWE-200: Information Exposure",
+      "count": 11454,
+      "description": "Information Exposure"
+    },
+    {
+      "id": "125",
+      "name": "CWE-125: Out-of-bounds Read",
+      "count": 11297,
+      "description": "Out-of-bounds Read"
+    },
+    {
+      "id": "862",
+      "name": "CWE-862: Missing Authorization",
+      "count": 10880,
+      "description": "Missing Authorization"
+    },
+    {
+      "id": "416",
+      "name": "CWE-416: Use After Free",
+      "count": 10346,
+      "description": "Use After Free"
+    },
+    {
+      "id": "352",
+      "name": "CWE-352: Cross-Site Request Forgery (CSRF)",
+      "count": 9931,
+      "description": "Cross-Site Request Forgery (CSRF)"
+    },
+    {
+      "id": "78",
+      "name": "CWE-78: OS Command Injection",
+      "count": 7847,
+      "description": "OS Command Injection"
+    },
+    {
+      "id": "284",
+      "name": "CWE-284",
+      "count": 7459,
+      "description": "CWE-284"
+    },
+    {
+      "id": "94",
+      "name": "CWE-94: Code Injection",
+      "count": 6567,
+      "description": "Code Injection"
+    },
+    {
+      "id": "264",
+      "name": "CWE-264",
+      "count": 5092,
+      "description": "CWE-264"
+    },
+    {
+      "id": "476",
+      "name": "CWE-476: NULL Pointer Dereference",
+      "count": 4979,
+      "description": "NULL Pointer Dereference"
+    },
+    {
+      "id": "434",
+      "name": "CWE-434: Unrestricted Upload of File",
+      "count": 4382,
+      "description": "Unrestricted Upload of File"
+    },
+    {
+      "id": "120",
+      "name": "CWE-120",
+      "count": 4340,
+      "description": "CWE-120"
+    },
+    {
+      "id": "74",
+      "name": "CWE-74",
+      "count": 4161,
+      "description": "CWE-74"
+    },
+    {
+      "id": "287",
+      "name": "CWE-287: Improper Authentication",
+      "count": 3732,
+      "description": "Improper Authentication"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/web/data/cwe_analysis_current_year.json b/web/data/cwe_analysis_current_year.json
new file mode 100644
index 00000000000..5d3ef6fb69b
--- /dev/null
+++ b/web/data/cwe_analysis_current_year.json
@@ -0,0 +1,290 @@
+{
+  "generated_at": "2026-09-23T22:54:28.279701",
+  "year": 2026,
+  "total_cves_with_cwe": 44119,
+  "total_unique_cwes": 20,
+  "top_cwes": [
+    {
+      "cwe": "CWE-79",
+      "count": 6342,
+      "id": "79",
+      "description": "Cross-site Scripting (XSS)",
+      "name": "CWE-79: Cross-site Scripting (XSS)"
+    },
+    {
+      "cwe": "CWE-284",
+      "count": 3721,
+      "id": "284",
+      "description": "CWE-284",
+      "name": "CWE-284"
+    },
+    {
+      "cwe": "CWE-862",
+      "count": 3591,
+      "id": "862",
+      "description": "Missing Authorization",
+      "name": "CWE-862: Missing Authorization"
+    },
+    {
+      "cwe": "CWE-89",
+      "count": 3571,
+      "id": "89",
+      "description": "SQL Injection",
+      "name": "CWE-89: SQL Injection"
+    },
+    {
+      "cwe": "CWE-22",
+      "count": 2437,
+      "id": "22",
+      "description": "Path Traversal",
+      "name": "CWE-22: Path Traversal"
+    },
+    {
+      "cwe": "CWE-416",
+      "count": 2388,
+      "id": "416",
+      "description": "Use After Free",
+      "name": "CWE-416: Use After Free"
+    },
+    {
+      "cwe": "CWE-78",
+      "count": 1852,
+      "id": "78",
+      "description": "OS Command Injection",
+      "name": "CWE-78: OS Command Injection"
+    },
+    {
+      "cwe": "CWE-125",
+      "count": 1799,
+      "id": "125",
+      "description": "Out-of-bounds Read",
+      "name": "CWE-125: Out-of-bounds Read"
+    },
+    {
+      "cwe": "CWE-787",
+      "count": 1779,
+      "id": "787",
+      "description": "Out-of-bounds Write",
+      "name": "CWE-787: Out-of-bounds Write"
+    },
+    {
+      "cwe": "CWE-918",
+      "count": 1737,
+      "id": "918",
+      "description": "CWE-918",
+      "name": "CWE-918"
+    },
+    {
+      "cwe": "CWE-20",
+      "count": 1687,
+      "id": "20",
+      "description": "Improper Input Validation",
+      "name": "CWE-20: Improper Input Validation"
+    },
+    {
+      "cwe": "CWE-200",
+      "count": 1658,
+      "id": "200",
+      "description": "Information Exposure",
+      "name": "CWE-200: Information Exposure"
+    },
+    {
+      "cwe": "CWE-94",
+      "count": 1637,
+      "id": "94",
+      "description": "Code Injection",
+      "name": "CWE-94: Code Injection"
+    },
+    {
+      "cwe": "CWE-863",
+      "count": 1627,
+      "id": "863",
+      "description": "Incorrect Authorization",
+      "name": "CWE-863: Incorrect Authorization"
+    },
+    {
+      "cwe": "CWE-74",
+      "count": 1588,
+      "id": "74",
+      "description": "CWE-74",
+      "name": "CWE-74"
+    },
+    {
+      "cwe": "CWE-639",
+      "count": 1558,
+      "id": "639",
+      "description": "CWE-639",
+      "name": "CWE-639"
+    },
+    {
+      "cwe": "CWE-306",
+      "count": 1494,
+      "id": "306",
+      "description": "CWE-306",
+      "name": "CWE-306"
+    },
+    {
+      "cwe": "CWE-122",
+      "count": 1386,
+      "id": "122",
+      "description": "CWE-122",
+      "name": "CWE-122"
+    },
+    {
+      "cwe": "CWE-121",
+      "count": 1141,
+      "id": "121",
+      "description": "CWE-121",
+      "name": "CWE-121"
+    },
+    {
+      "cwe": "CWE-269",
+      "count": 1126,
+      "id": "269",
+      "description": "Improper Privilege Management",
+      "name": "CWE-269: Improper Privilege Management"
+    }
+  ],
+  "top_cwes_limited": [
+    {
+      "cwe": "CWE-79",
+      "count": 6342,
+      "id": "79",
+      "description": "Cross-site Scripting (XSS)",
+      "name": "CWE-79: Cross-site Scripting (XSS)"
+    },
+    {
+      "cwe": "CWE-284",
+      "count": 3721,
+      "id": "284",
+      "description": "CWE-284",
+      "name": "CWE-284"
+    },
+    {
+      "cwe": "CWE-862",
+      "count": 3591,
+      "id": "862",
+      "description": "Missing Authorization",
+      "name": "CWE-862: Missing Authorization"
+    },
+    {
+      "cwe": "CWE-89",
+      "count": 3571,
+      "id": "89",
+      "description": "SQL Injection",
+      "name": "CWE-89: SQL Injection"
+    },
+    {
+      "cwe": "CWE-22",
+      "count": 2437,
+      "id": "22",
+      "description": "Path Traversal",
+      "name": "CWE-22: Path Traversal"
+    },
+    {
+      "cwe": "CWE-416",
+      "count": 2388,
+      "id": "416",
+      "description": "Use After Free",
+      "name": "CWE-416: Use After Free"
+    },
+    {
+      "cwe": "CWE-78",
+      "count": 1852,
+      "id": "78",
+      "description": "OS Command Injection",
+      "name": "CWE-78: OS Command Injection"
+    },
+    {
+      "cwe": "CWE-125",
+      "count": 1799,
+      "id": "125",
+      "description": "Out-of-bounds Read",
+      "name": "CWE-125: Out-of-bounds Read"
+    },
+    {
+      "cwe": "CWE-787",
+      "count": 1779,
+      "id": "787",
+      "description": "Out-of-bounds Write",
+      "name": "CWE-787: Out-of-bounds Write"
+    },
+    {
+      "cwe": "CWE-918",
+      "count": 1737,
+      "id": "918",
+      "description": "CWE-918",
+      "name": "CWE-918"
+    },
+    {
+      "cwe": "CWE-20",
+      "count": 1687,
+      "id": "20",
+      "description": "Improper Input Validation",
+      "name": "CWE-20: Improper Input Validation"
+    },
+    {
+      "cwe": "CWE-200",
+      "count": 1658,
+      "id": "200",
+      "description": "Information Exposure",
+      "name": "CWE-200: Information Exposure"
+    },
+    {
+      "cwe": "CWE-94",
+      "count": 1637,
+      "id": "94",
+      "description": "Code Injection",
+      "name": "CWE-94: Code Injection"
+    },
+    {
+      "cwe": "CWE-863",
+      "count": 1627,
+      "id": "863",
+      "description": "Incorrect Authorization",
+      "name": "CWE-863: Incorrect Authorization"
+    },
+    {
+      "cwe": "CWE-74",
+      "count": 1588,
+      "id": "74",
+      "description": "CWE-74",
+      "name": "CWE-74"
+    },
+    {
+      "cwe": "CWE-639",
+      "count": 1558,
+      "id": "639",
+      "description": "CWE-639",
+      "name": "CWE-639"
+    },
+    {
+      "cwe": "CWE-306",
+      "count": 1494,
+      "id": "306",
+      "description": "CWE-306",
+      "name": "CWE-306"
+    },
+    {
+      "cwe": "CWE-122",
+      "count": 1386,
+      "id": "122",
+      "description": "CWE-122",
+      "name": "CWE-122"
+    },
+    {
+      "cwe": "CWE-121",
+      "count": 1141,
+      "id": "121",
+      "description": "CWE-121",
+      "name": "CWE-121"
+    },
+    {
+      "cwe": "CWE-269",
+      "count": 1126,
+      "id": "269",
+      "description": "Improper Privilege Management",
+      "name": "CWE-269: Improper Privilege Management"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/web/data/data_quality.json b/web/data/data_quality.json
new file mode 100644
index 00000000000..e33330fc910
--- /dev/null
+++ b/web/data/data_quality.json
@@ -0,0 +1,985 @@
+{
+  "stats": {
+    "total_cnas_in_analysis": 471,
+    "official_cna_registry_count": 550,
+    "exact_matches": 427,
+    "case_mismatches": 1,
+    "org_name_matches": 6,
+    "normalized_matches": 6,
+    "partial_matches": 4,
+    "unmatched": 27,
+    "exact_match_cves": 374803,
+    "case_mismatch_cves": 178,
+    "org_name_match_cves": 782,
+    "normalized_match_cves": 1596,
+    "partial_match_cves": 78,
+    "unmatched_cves": 1058,
+    "exact_match_pct": 99.02,
+    "issues_pct": 0.98
+  },
+  "exact_matches": [
+    {
+      "cna_name": "mitre",
+      "cve_count": 115033,
+      "kev_count": 322,
+      "epss_high_count": 1732,
+      "official_short_name": "mitre",
+      "official_org_name": "MITRE Corporation",
+      "official_id": "CNA-1999-0001",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "GitHub_M",
+      "cve_count": 20253,
+      "kev_count": 41,
+      "epss_high_count": 178,
+      "official_short_name": "GitHub_M",
+      "official_org_name": "GitHub, Inc.",
+      "official_id": "CNA-2019-0009",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "Patchstack",
+      "cve_count": 18050,
+      "kev_count": 0,
+      "epss_high_count": 12,
+      "official_short_name": "Patchstack",
+      "official_org_name": "Patchstack",
+      "official_id": "CNA-2021-0025",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "VulDB",
+      "cve_count": 16730,
+      "kev_count": 4,
+      "epss_high_count": 32,
+      "official_short_name": "VulDB",
+      "official_org_name": "VulDB",
+      "official_id": "CNA-2001-0063",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "Linux",
+      "cve_count": 16509,
+      "kev_count": 11,
+      "epss_high_count": 5,
+      "official_short_name": "Linux",
+      "official_org_name": "kernel.org",
+      "official_id": "CNA-2024-0016",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "microsoft",
+      "cve_count": 14479,
+      "kev_count": 379,
+      "epss_high_count": 556,
+      "official_short_name": "microsoft",
+      "official_org_name": "Microsoft Corporation",
+      "official_id": "CNA-2005-0005",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "redhat",
+      "cve_count": 11691,
+      "kev_count": 33,
+      "epss_high_count": 187,
+      "official_short_name": "redhat",
+      "official_org_name": "Red Hat, Inc.",
+      "official_id": "CNA-2005-0006",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "oracle",
+      "cve_count": 11319,
+      "kev_count": 44,
+      "epss_high_count": 116,
+      "official_short_name": "oracle",
+      "official_org_name": "Oracle",
+      "official_id": "CNA-2008-0001",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "Wordfence",
+      "cve_count": 11222,
+      "kev_count": 0,
+      "epss_high_count": 54,
+      "official_short_name": "Wordfence",
+      "official_org_name": "Wordfence",
+      "official_id": "CNA-2021-0022",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "ibm",
+      "cve_count": 7779,
+      "kev_count": 8,
+      "epss_high_count": 19,
+      "official_short_name": "ibm",
+      "official_org_name": "IBM Corporation",
+      "official_id": "CNA-2011-0007",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "adobe",
+      "cve_count": 7594,
+      "kev_count": 75,
+      "epss_high_count": 118,
+      "official_short_name": "adobe",
+      "official_org_name": "Adobe Systems Incorporated",
+      "official_id": "CNA-2009-0001",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "VulnCheck",
+      "cve_count": 7501,
+      "kev_count": 19,
+      "epss_high_count": 33,
+      "official_short_name": "VulnCheck",
+      "official_org_name": "VulnCheck",
+      "official_id": "CNA-2023-0021",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "apple",
+      "cve_count": 7347,
+      "kev_count": 94,
+      "epss_high_count": 10,
+      "official_short_name": "apple",
+      "official_org_name": "Apple Inc.",
+      "official_id": "CNA-2009-0002",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "cisco",
+      "cve_count": 6523,
+      "kev_count": 98,
+      "epss_high_count": 74,
+      "official_short_name": "cisco",
+      "official_org_name": "Cisco Systems, Inc.",
+      "official_id": "CNA-2007-0001",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "Chrome",
+      "cve_count": 6269,
+      "kev_count": 76,
+      "epss_high_count": 17,
+      "official_short_name": "Chrome",
+      "official_org_name": "Chrome",
+      "official_id": "CNA-2011-0003",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "WPScan",
+      "cve_count": 5550,
+      "kev_count": 2,
+      "epss_high_count": 36,
+      "official_short_name": "WPScan",
+      "official_org_name": "WPScan",
+      "official_id": "CNA-2021-0002",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "google_android",
+      "cve_count": 5230,
+      "kev_count": 14,
+      "epss_high_count": 7,
+      "official_short_name": "google_android",
+      "official_org_name": "Android (associated with Google Inc. or Open Handset Alliance)",
+      "official_id": "CNA-2011-0002",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "icscert",
+      "cve_count": 3796,
+      "kev_count": 8,
+      "epss_high_count": 27,
+      "official_short_name": "icscert",
+      "official_org_name": "Cybersecurity and Infrastructure Security Agency (CISA) Industrial Control Systems (ICS)",
+      "official_id": "CNA-2012-0001",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "zdi",
+      "cve_count": 3426,
+      "kev_count": 6,
+      "epss_high_count": 85,
+      "official_short_name": "zdi",
+      "official_org_name": "Zero Day Initiative",
+      "official_id": "CNA-2017-0018",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "jpcert",
+      "cve_count": 3224,
+      "kev_count": 6,
+      "epss_high_count": 8,
+      "official_short_name": "jpcert",
+      "official_org_name": "JPCERT/CC",
+      "official_id": "CNA-2010-0001",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "certcc",
+      "cve_count": 3135,
+      "kev_count": 7,
+      "epss_high_count": 66,
+      "official_short_name": "certcc",
+      "official_org_name": "CERT/CC",
+      "official_id": "CNA-2005-0002",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "qualcomm",
+      "cve_count": 3064,
+      "kev_count": 12,
+      "epss_high_count": 0,
+      "official_short_name": "qualcomm",
+      "official_org_name": "Qualcomm, Inc.",
+      "official_id": "CNA-2017-0007",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "mozilla",
+      "cve_count": 2704,
+      "kev_count": 12,
+      "epss_high_count": 13,
+      "official_short_name": "mozilla",
+      "official_org_name": "Mozilla Corporation",
+      "official_id": "CNA-2012-0002",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "apache",
+      "cve_count": 2594,
+      "kev_count": 35,
+      "epss_high_count": 182,
+      "official_short_name": "apache",
+      "official_org_name": "Apache Software Foundation",
+      "official_id": "CNA-2016-0004",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "talos",
+      "cve_count": 2418,
+      "kev_count": 2,
+      "epss_high_count": 28,
+      "official_short_name": "talos",
+      "official_org_name": "Talos",
+      "official_id": "CNA-2016-0017",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "dell",
+      "cve_count": 2396,
+      "kev_count": 3,
+      "epss_high_count": 13,
+      "official_short_name": "dell",
+      "official_org_name": "Dell",
+      "official_id": "CNA-2011-0004",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "@huntr_ai",
+      "cve_count": 2385,
+      "kev_count": 0,
+      "epss_high_count": 31,
+      "official_short_name": "@huntr_ai",
+      "official_org_name": "Protect AI (formerly huntr.dev)",
+      "official_id": "CNA-2021-0018",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "intel",
+      "cve_count": 2223,
+      "kev_count": 1,
+      "epss_high_count": 5,
+      "official_short_name": "intel",
+      "official_org_name": "Intel Corporation",
+      "official_id": "CNA-2016-0005",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "huawei",
+      "cve_count": 2208,
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "official_short_name": "huawei",
+      "official_org_name": "Huawei Technologies",
+      "official_id": "CNA-2016-0012",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "siemens",
+      "cve_count": 1841,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "siemens",
+      "official_org_name": "Siemens",
+      "official_id": "CNA-2017-0006",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "hackerone",
+      "cve_count": 1761,
+      "kev_count": 27,
+      "epss_high_count": 71,
+      "official_short_name": "hackerone",
+      "official_org_name": "HackerOne",
+      "official_id": "CNA-2016-0011",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "jenkins",
+      "cve_count": 1592,
+      "kev_count": 3,
+      "epss_high_count": 33,
+      "official_short_name": "jenkins",
+      "official_org_name": "Jenkins Project",
+      "official_id": "CNA-2018-0015",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "sap",
+      "cve_count": 1564,
+      "kev_count": 8,
+      "epss_high_count": 8,
+      "official_short_name": "sap",
+      "official_org_name": "SAP SE",
+      "official_id": "CNA-2017-0038",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "hpe",
+      "cve_count": 1473,
+      "kev_count": 2,
+      "epss_high_count": 18,
+      "official_short_name": "hpe",
+      "official_org_name": "Hewlett Packard Enterprise (HPE)",
+      "official_id": "CNA-2016-0003",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "GitLab",
+      "cve_count": 1357,
+      "kev_count": 6,
+      "epss_high_count": 23,
+      "official_short_name": "GitLab",
+      "official_org_name": "GitLab Inc.",
+      "official_id": "CNA-2020-0018",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "INCIBE",
+      "cve_count": 1127,
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "official_short_name": "INCIBE",
+      "official_org_name": "Spanish National Cybersecurity Institute, S.A. (INCIBE)",
+      "official_id": "CNA-2020-0002",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "nvidia",
+      "cve_count": 1057,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "nvidia",
+      "official_org_name": "NVIDIA Corporation",
+      "official_id": "CNA-2016-0015",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "fortinet",
+      "cve_count": 1038,
+      "kev_count": 30,
+      "epss_high_count": 26,
+      "official_short_name": "fortinet",
+      "official_org_name": "Fortinet, Inc.",
+      "official_id": "CNA-2016-0010",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "MediaTek",
+      "cve_count": 1019,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "MediaTek",
+      "official_org_name": "MediaTek, Inc.",
+      "official_id": "CNA-2021-0043",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "hp",
+      "cve_count": 935,
+      "kev_count": 1,
+      "epss_high_count": 54,
+      "official_short_name": "hp",
+      "official_org_name": "HP Inc.",
+      "official_id": "CNA-2009-0003",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "juniper",
+      "cve_count": 929,
+      "kev_count": 7,
+      "epss_high_count": 4,
+      "official_short_name": "juniper",
+      "official_org_name": "Juniper Networks, Inc.",
+      "official_id": "CNA-2016-0001",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "twcert",
+      "cve_count": 917,
+      "kev_count": 3,
+      "epss_high_count": 1,
+      "official_short_name": "twcert",
+      "official_org_name": "TWCERT/CC",
+      "official_id": "CNA-2018-0012",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "vmware",
+      "cve_count": 886,
+      "kev_count": 32,
+      "epss_high_count": 28,
+      "official_short_name": "vmware",
+      "official_org_name": "VMware by Broadcom",
+      "official_id": "CNA-2016-0025",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "snyk",
+      "cve_count": 869,
+      "kev_count": 2,
+      "epss_high_count": 4,
+      "official_short_name": "snyk",
+      "official_org_name": "Snyk",
+      "official_id": "CNA-2017-0029",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "f5",
+      "cve_count": 825,
+      "kev_count": 8,
+      "epss_high_count": 12,
+      "official_short_name": "F5",
+      "official_org_name": "F5, Inc.",
+      "official_id": "CNA-2016-0009",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "TR-CERT",
+      "cve_count": 810,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "TR-CERT",
+      "official_org_name": "TR-CERT (Computer Emergency Response Team of the Republic of T\u00fcrkiye)",
+      "official_id": "CNA-2021-0034",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "schneider",
+      "cve_count": 738,
+      "kev_count": 1,
+      "epss_high_count": 3,
+      "official_short_name": "schneider",
+      "official_org_name": "Schneider Electric",
+      "official_id": "CNA-2017-0009",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "CERTVDE",
+      "cve_count": 727,
+      "kev_count": 0,
+      "epss_high_count": 8,
+      "official_short_name": "CERTVDE",
+      "official_org_name": "CERT@VDE",
+      "official_id": "CNA-2020-0010",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "Unisoc",
+      "cve_count": 656,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "Unisoc",
+      "official_org_name": "Unisoc (Shanghai) Technologies Co., Ltd.",
+      "official_id": "CNA-2022-0025",
+      "match_type": "exact_short",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "debian",
+      "cve_count": 645,
+      "kev_count": 3,
+      "epss_high_count": 8,
+      "official_short_name": "debian",
+      "official_org_name": "Debian GNU/Linux",
+      "official_id": "CNA-2005-0003",
+      "match_type": "exact_short",
+      "confidence": "high"
+    }
+  ],
+  "case_mismatches": [
+    {
+      "cna_name": "JFROG",
+      "cve_count": 178,
+      "kev_count": 5,
+      "epss_high_count": 4,
+      "official_short_name": "JFrog",
+      "official_org_name": "JFrog",
+      "official_id": "CNA-2021-0039",
+      "match_type": "case_short",
+      "confidence": "high"
+    }
+  ],
+  "org_name_matches": [
+    {
+      "cna_name": "Fluid Attacks",
+      "cve_count": 349,
+      "kev_count": 1,
+      "epss_high_count": 0,
+      "official_short_name": "Fluid_Attacks",
+      "official_org_name": "Fluid Attacks",
+      "official_id": "CNA-2021-0020",
+      "match_type": "exact_org",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "SICK AG",
+      "cve_count": 162,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "SICK_AG",
+      "official_org_name": "SICK AG",
+      "official_id": "CNA-2019-0016",
+      "match_type": "exact_org",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "Hitachi Energy",
+      "cve_count": 115,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "Hitachi_Energy",
+      "official_org_name": "Hitachi Energy",
+      "official_id": "CNA-2021-0028",
+      "match_type": "exact_org",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "NLnet Labs",
+      "cve_count": 76,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "NLnet_Labs",
+      "official_org_name": "NLnet Labs",
+      "official_id": "CNA-2020-0033",
+      "match_type": "exact_org",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "M-Files Corporation",
+      "cve_count": 60,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "M-Files",
+      "official_org_name": "M-Files Corporation",
+      "official_id": "CNA-2021-0038",
+      "match_type": "exact_org",
+      "confidence": "high"
+    },
+    {
+      "cna_name": "SNOWFLAKE",
+      "cve_count": 20,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "SNOW",
+      "official_org_name": "Snowflake",
+      "official_id": "CNA-2026-0021",
+      "match_type": "case_org",
+      "confidence": "high"
+    }
+  ],
+  "normalized_matches": [
+    {
+      "cna_name": "SamsungMobile",
+      "cve_count": 1392,
+      "kev_count": 13,
+      "epss_high_count": 0,
+      "official_short_name": "Samsung_Mobile",
+      "official_org_name": "Samsung Mobile",
+      "official_id": "CNA-2021-0001",
+      "match_type": "normalized",
+      "confidence": "medium"
+    },
+    {
+      "cna_name": "Ping Identity",
+      "cve_count": 52,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "PingIdentity",
+      "official_org_name": "Ping Identity Corporation",
+      "official_id": "CNA-2021-0042",
+      "match_type": "normalized",
+      "confidence": "medium"
+    },
+    {
+      "cna_name": "Document Fdn.",
+      "cve_count": 51,
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "official_short_name": "Document_Fdn.",
+      "official_org_name": "Document Foundation, The",
+      "official_id": "CNA-2019-0002",
+      "match_type": "normalized",
+      "confidence": "medium"
+    },
+    {
+      "cna_name": "WDC PSIRT",
+      "cve_count": 49,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "WDC_PSIRT",
+      "official_org_name": "Western Digital",
+      "official_id": "CNA-2021-0051",
+      "match_type": "normalized",
+      "confidence": "medium"
+    },
+    {
+      "cna_name": "ZUSO ART",
+      "cve_count": 44,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "ZUSO_ART",
+      "official_org_name": "ZUSO Advanced Research Team (ZUSO ART)",
+      "official_id": "CNA-2022-0010",
+      "match_type": "normalized",
+      "confidence": "medium"
+    },
+    {
+      "cna_name": "Silver Peak",
+      "cve_count": 8,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "Silver_Peak",
+      "official_org_name": "Silver Peak Systems, Inc.",
+      "official_id": "CNA-2020-0011",
+      "match_type": "normalized",
+      "confidence": "medium"
+    }
+  ],
+  "partial_matches": [
+    {
+      "cna_name": "ASUSTOR1",
+      "cve_count": 37,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "ASUSTOR",
+      "official_org_name": "ASUSTOR, Inc.",
+      "official_id": "CNA-2021-0048",
+      "match_type": "partial",
+      "confidence": "low"
+    },
+    {
+      "cna_name": "crafter",
+      "cve_count": 19,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "Crafter_CMS",
+      "official_org_name": "Crafter CMS",
+      "official_id": "CNA-2020-0030",
+      "match_type": "partial",
+      "confidence": "low"
+    },
+    {
+      "cna_name": "redhat-cnalr",
+      "cve_count": 17,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "redhat",
+      "official_org_name": "Red Hat, Inc.",
+      "official_id": "CNA-2005-0006",
+      "match_type": "partial",
+      "confidence": "low"
+    },
+    {
+      "cna_name": "Milestone",
+      "cve_count": 5,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "official_short_name": "milestonesys",
+      "official_org_name": "Milestone Systems A/S",
+      "official_id": "CNA-2024-0007",
+      "match_type": "partial",
+      "confidence": "low"
+    }
+  ],
+  "unmatched": [
+    {
+      "cna_name": "dwf",
+      "cve_count": 157,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "Mend",
+      "cve_count": 150,
+      "kev_count": 0,
+      "epss_high_count": 3,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "GovTech CSG",
+      "cve_count": 124,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "Splunk",
+      "cve_count": 110,
+      "kev_count": 0,
+      "epss_high_count": 2,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "3DS",
+      "cve_count": 106,
+      "kev_count": 3,
+      "epss_high_count": 3,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "TML",
+      "cve_count": 64,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "pivotal",
+      "cve_count": 58,
+      "kev_count": 1,
+      "epss_high_count": 3,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "HITVAN",
+      "cve_count": 52,
+      "kev_count": 2,
+      "epss_high_count": 2,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "F-SecureUS",
+      "cve_count": 46,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "TV",
+      "cve_count": 41,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "TQtC",
+      "cve_count": 23,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "Teradici",
+      "cve_count": 20,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "SWI",
+      "cve_count": 16,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "HW",
+      "cve_count": 16,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "sgi",
+      "cve_count": 11,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "VDOO",
+      "cve_count": 11,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "ForgeRock",
+      "cve_count": 9,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "GEHC",
+      "cve_count": 9,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "1E",
+      "cve_count": 8,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "duo",
+      "cve_count": 6,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "360ST",
+      "cve_count": 6,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "joshbressers",
+      "cve_count": 5,
+      "kev_count": 0,
+      "epss_high_count": 1,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "Baicells",
+      "cve_count": 5,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "Cybellum",
+      "cve_count": 2,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "cspcert",
+      "cve_count": 1,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "DeepSurface",
+      "cve_count": 1,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    },
+    {
+      "cna_name": "OpenCloudOS",
+      "cve_count": 1,
+      "kev_count": 0,
+      "epss_high_count": 0,
+      "match_type": null,
+      "confidence": null
+    }
+  ]
+}
\ No newline at end of file
diff --git a/web/data/epss_analysis.json b/web/data/epss_analysis.json
new file mode 100644
index 00000000000..916b2ba4306
--- /dev/null
+++ b/web/data/epss_analysis.json
@@ -0,0 +1,650 @@
+{
+  "generated_at": "2026-09-23T22:56:03.445867Z",
+  "total_cves_with_epss": 378156,
+  "statistics": {
+    "average_score": 0.027281,
+    "gt_0_1": 17397,
+    "gt_0_3": 7073,
+    "gt_0_5": 4346,
+    "gt_0_7": 2479,
+    "gt_0_9": 802
+  },
+  "score_buckets": {
+    "very_low": 231979,
+    "low": 128780,
+    "medium": 10323,
+    "high": 2727,
+    "very_high": 1868,
+    "critical": 2479
+  },
+  "percentile_distribution": {
+    "0": 37812,
+    "1": 37816,
+    "2": 37815,
+    "3": 37816,
+    "4": 37815,
+    "5": 37816,
+    "6": 37815,
+    "7": 37816,
+    "8": 37815,
+    "9": 37820
+  },
+  "year_coverage": {
+    "1999": {
+      "total": 894,
+      "with_epss": 894
+    },
+    "2000": {
+      "total": 1019,
+      "with_epss": 1019
+    },
+    "2001": {
+      "total": 1676,
+      "with_epss": 1676
+    },
+    "2002": {
+      "total": 2156,
+      "with_epss": 2156
+    },
+    "2003": {
+      "total": 1527,
+      "with_epss": 1527
+    },
+    "2004": {
+      "total": 2451,
+      "with_epss": 2451
+    },
+    "2005": {
+      "total": 4932,
+      "with_epss": 4932
+    },
+    "2006": {
+      "total": 6608,
+      "with_epss": 6608
+    },
+    "2007": {
+      "total": 6516,
+      "with_epss": 6516
+    },
+    "2008": {
+      "total": 5632,
+      "with_epss": 5632
+    },
+    "2009": {
+      "total": 5732,
+      "with_epss": 5732
+    },
+    "2010": {
+      "total": 4639,
+      "with_epss": 4639
+    },
+    "2011": {
+      "total": 4150,
+      "with_epss": 4150
+    },
+    "2012": {
+      "total": 5288,
+      "with_epss": 5288
+    },
+    "2013": {
+      "total": 5187,
+      "with_epss": 5187
+    },
+    "2014": {
+      "total": 7928,
+      "with_epss": 7928
+    },
+    "2015": {
+      "total": 6494,
+      "with_epss": 6494
+    },
+    "2016": {
+      "total": 6449,
+      "with_epss": 6449
+    },
+    "2017": {
+      "total": 14642,
+      "with_epss": 14642
+    },
+    "2018": {
+      "total": 16510,
+      "with_epss": 16510
+    },
+    "2019": {
+      "total": 17305,
+      "with_epss": 17305
+    },
+    "2020": {
+      "total": 18322,
+      "with_epss": 18322
+    },
+    "2021": {
+      "total": 20149,
+      "with_epss": 20149
+    },
+    "2022": {
+      "total": 25074,
+      "with_epss": 25074
+    },
+    "2023": {
+      "total": 28816,
+      "with_epss": 28816
+    },
+    "2024": {
+      "total": 39953,
+      "with_epss": 39953
+    },
+    "2025": {
+      "total": 48153,
+      "with_epss": 48153
+    },
+    "2026": {
+      "total": 69597,
+      "with_epss": 69275
+    }
+  },
+  "epss_without_published_record": 679,
+  "total_cves_with_epss_matched": 377477,
+  "high_risk_cves": [
+    {
+      "cve_id": "CVE-2014-0160",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99997
+    },
+    {
+      "cve_id": "CVE-2014-3566",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99999
+    },
+    {
+      "cve_id": "CVE-2014-6271",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99993
+    },
+    {
+      "cve_id": "CVE-2015-1635",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99998
+    },
+    {
+      "cve_id": "CVE-2017-5638",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99994
+    },
+    {
+      "cve_id": "CVE-2017-9841",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99994
+    },
+    {
+      "cve_id": "CVE-2018-13379",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99994
+    },
+    {
+      "cve_id": "CVE-2019-0708",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99999
+    },
+    {
+      "cve_id": "CVE-2019-11510",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99996
+    },
+    {
+      "cve_id": "CVE-2019-19781",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99998
+    },
+    {
+      "cve_id": "CVE-2020-5902",
+      "epss_score": 0.99999,
+      "epss_percentile": 1.0
+    },
+    {
+      "cve_id": "CVE-2021-1498",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99991
+    },
+    {
+      "cve_id": "CVE-2021-21985",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99993
+    },
+    {
+      "cve_id": "CVE-2021-22005",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99998
+    },
+    {
+      "cve_id": "CVE-2021-26084",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99993
+    },
+    {
+      "cve_id": "CVE-2021-26086",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99992
+    },
+    {
+      "cve_id": "CVE-2021-34473",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99997
+    },
+    {
+      "cve_id": "CVE-2021-35464",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99994
+    },
+    {
+      "cve_id": "CVE-2021-40438",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99997
+    },
+    {
+      "cve_id": "CVE-2021-44228",
+      "epss_score": 0.99999,
+      "epss_percentile": 1.0
+    },
+    {
+      "cve_id": "CVE-2021-45105",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99991
+    },
+    {
+      "cve_id": "CVE-2022-26134",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99993
+    },
+    {
+      "cve_id": "CVE-2022-29464",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99995
+    },
+    {
+      "cve_id": "CVE-2023-0669",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99997
+    },
+    {
+      "cve_id": "CVE-2023-1389",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99992
+    },
+    {
+      "cve_id": "CVE-2023-1671",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99992
+    },
+    {
+      "cve_id": "CVE-2023-22518",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99996
+    },
+    {
+      "cve_id": "CVE-2023-27350",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99995
+    },
+    {
+      "cve_id": "CVE-2023-32315",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99992
+    },
+    {
+      "cve_id": "CVE-2023-35078",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99995
+    },
+    {
+      "cve_id": "CVE-2023-35082",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99996
+    },
+    {
+      "cve_id": "CVE-2023-44487",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99999
+    },
+    {
+      "cve_id": "CVE-2023-4966",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99998
+    },
+    {
+      "cve_id": "CVE-2024-21887",
+      "epss_score": 0.99999,
+      "epss_percentile": 1.0
+    },
+    {
+      "cve_id": "CVE-2024-21893",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99999
+    },
+    {
+      "cve_id": "CVE-2024-23897",
+      "epss_score": 0.99999,
+      "epss_percentile": 0.99995
+    },
+    {
+      "cve_id": "CVE-2024-3400",
+      "epss_score": 0.99999,
+      "epss_percentile": 1.0
+    },
+    {
+      "cve_id": "CVE-2012-1823",
+      "epss_score": 0.99998,
+      "epss_percentile": 0.9999
+    },
+    {
+      "cve_id": "CVE-2013-2251",
+      "epss_score": 0.99998,
+      "epss_percentile": 0.9999
+    },
+    {
+      "cve_id": "CVE-2017-7921",
+      "epss_score": 0.99998,
+      "epss_percentile": 0.9999
+    },
+    {
+      "cve_id": "CVE-2025-53770",
+      "epss_score": 0.99998,
+      "epss_percentile": 0.99991
+    },
+    {
+      "cve_id": "CVE-2020-14882",
+      "epss_score": 0.99997,
+      "epss_percentile": 0.9999
+    },
+    {
+      "cve_id": "CVE-2022-22954",
+      "epss_score": 0.99997,
+      "epss_percentile": 0.99989
+    },
+    {
+      "cve_id": "CVE-2024-3273",
+      "epss_score": 0.99997,
+      "epss_percentile": 0.99989
+    },
+    {
+      "cve_id": "CVE-2019-16920",
+      "epss_score": 0.99996,
+      "epss_percentile": 0.99989
+    },
+    {
+      "cve_id": "CVE-2021-26855",
+      "epss_score": 0.99996,
+      "epss_percentile": 0.99989
+    },
+    {
+      "cve_id": "CVE-2022-44877",
+      "epss_score": 0.99995,
+      "epss_percentile": 0.99988
+    },
+    {
+      "cve_id": "CVE-2025-49704",
+      "epss_score": 0.99995,
+      "epss_percentile": 0.99988
+    },
+    {
+      "cve_id": "CVE-2024-34102",
+      "epss_score": 0.99994,
+      "epss_percentile": 0.99988
+    },
+    {
+      "cve_id": "CVE-2020-8515",
+      "epss_score": 0.99993,
+      "epss_percentile": 0.99988
+    },
+    {
+      "cve_id": "CVE-2020-3452",
+      "epss_score": 0.99992,
+      "epss_percentile": 0.99987
+    },
+    {
+      "cve_id": "CVE-2021-41773",
+      "epss_score": 0.99992,
+      "epss_percentile": 0.99987
+    },
+    {
+      "cve_id": "CVE-2024-13159",
+      "epss_score": 0.99992,
+      "epss_percentile": 0.99987
+    },
+    {
+      "cve_id": "CVE-2018-11776",
+      "epss_score": 0.99991,
+      "epss_percentile": 0.99986
+    },
+    {
+      "cve_id": "CVE-2018-7600",
+      "epss_score": 0.99991,
+      "epss_percentile": 0.99986
+    },
+    {
+      "cve_id": "CVE-2023-29300",
+      "epss_score": 0.99991,
+      "epss_percentile": 0.99986
+    },
+    {
+      "cve_id": "CVE-2024-27199",
+      "epss_score": 0.99991,
+      "epss_percentile": 0.99986
+    },
+    {
+      "cve_id": "CVE-2017-10271",
+      "epss_score": 0.9999,
+      "epss_percentile": 0.99985
+    },
+    {
+      "cve_id": "CVE-2021-34523",
+      "epss_score": 0.9999,
+      "epss_percentile": 0.99985
+    },
+    {
+      "cve_id": "CVE-2024-7593",
+      "epss_score": 0.9999,
+      "epss_percentile": 0.99985
+    },
+    {
+      "cve_id": "CVE-2025-3248",
+      "epss_score": 0.9999,
+      "epss_percentile": 0.99985
+    },
+    {
+      "cve_id": "CVE-2017-12617",
+      "epss_score": 0.99988,
+      "epss_percentile": 0.99984
+    },
+    {
+      "cve_id": "CVE-2020-9054",
+      "epss_score": 0.99988,
+      "epss_percentile": 0.99984
+    },
+    {
+      "cve_id": "CVE-2023-42793",
+      "epss_score": 0.99988,
+      "epss_percentile": 0.99984
+    },
+    {
+      "cve_id": "CVE-2023-50387",
+      "epss_score": 0.99988,
+      "epss_percentile": 0.99984
+    },
+    {
+      "cve_id": "CVE-2024-4577",
+      "epss_score": 0.99987,
+      "epss_percentile": 0.99983
+    },
+    {
+      "cve_id": "CVE-2019-9670",
+      "epss_score": 0.99986,
+      "epss_percentile": 0.99983
+    },
+    {
+      "cve_id": "CVE-2023-46805",
+      "epss_score": 0.99986,
+      "epss_percentile": 0.99983
+    },
+    {
+      "cve_id": "CVE-2022-40684",
+      "epss_score": 0.99984,
+      "epss_percentile": 0.99983
+    },
+    {
+      "cve_id": "CVE-2023-22527",
+      "epss_score": 0.99984,
+      "epss_percentile": 0.99982
+    },
+    {
+      "cve_id": "CVE-2023-29357",
+      "epss_score": 0.99984,
+      "epss_percentile": 0.99982
+    },
+    {
+      "cve_id": "CVE-2021-20090",
+      "epss_score": 0.99983,
+      "epss_percentile": 0.99981
+    },
+    {
+      "cve_id": "CVE-2024-45195",
+      "epss_score": 0.99983,
+      "epss_percentile": 0.99982
+    },
+    {
+      "cve_id": "CVE-2021-22204",
+      "epss_score": 0.99981,
+      "epss_percentile": 0.99981
+    },
+    {
+      "cve_id": "CVE-2025-22457",
+      "epss_score": 0.99981,
+      "epss_percentile": 0.99981
+    },
+    {
+      "cve_id": "CVE-2024-1709",
+      "epss_score": 0.9998,
+      "epss_percentile": 0.9998
+    },
+    {
+      "cve_id": "CVE-2025-59287",
+      "epss_score": 0.9998,
+      "epss_percentile": 0.99981
+    },
+    {
+      "cve_id": "CVE-2023-4863",
+      "epss_score": 0.99979,
+      "epss_percentile": 0.9998
+    },
+    {
+      "cve_id": "CVE-2025-0282",
+      "epss_score": 0.99979,
+      "epss_percentile": 0.9998
+    },
+    {
+      "cve_id": "CVE-2024-24919",
+      "epss_score": 0.99978,
+      "epss_percentile": 0.9998
+    },
+    {
+      "cve_id": "CVE-2014-0195",
+      "epss_score": 0.99977,
+      "epss_percentile": 0.99979
+    },
+    {
+      "cve_id": "CVE-2021-45046",
+      "epss_score": 0.99977,
+      "epss_percentile": 0.99979
+    },
+    {
+      "cve_id": "CVE-2012-0158",
+      "epss_score": 0.99976,
+      "epss_percentile": 0.99979
+    },
+    {
+      "cve_id": "CVE-2024-4879",
+      "epss_score": 0.99976,
+      "epss_percentile": 0.99979
+    },
+    {
+      "cve_id": "CVE-2025-31161",
+      "epss_score": 0.99976,
+      "epss_percentile": 0.99978
+    },
+    {
+      "cve_id": "CVE-2014-8361",
+      "epss_score": 0.99975,
+      "epss_percentile": 0.99978
+    },
+    {
+      "cve_id": "CVE-2014-3704",
+      "epss_score": 0.99974,
+      "epss_percentile": 0.99978
+    },
+    {
+      "cve_id": "CVE-2025-5777",
+      "epss_score": 0.99972,
+      "epss_percentile": 0.99977
+    },
+    {
+      "cve_id": "CVE-2022-41082",
+      "epss_score": 0.9997,
+      "epss_percentile": 0.99977
+    },
+    {
+      "cve_id": "CVE-2021-3156",
+      "epss_score": 0.99969,
+      "epss_percentile": 0.99977
+    },
+    {
+      "cve_id": "CVE-2020-25506",
+      "epss_score": 0.99968,
+      "epss_percentile": 0.99977
+    },
+    {
+      "cve_id": "CVE-2022-47986",
+      "epss_score": 0.99968,
+      "epss_percentile": 0.99976
+    },
+    {
+      "cve_id": "CVE-2015-7297",
+      "epss_score": 0.99967,
+      "epss_percentile": 0.99976
+    },
+    {
+      "cve_id": "CVE-2019-2725",
+      "epss_score": 0.99964,
+      "epss_percentile": 0.99976
+    },
+    {
+      "cve_id": "CVE-2021-42013",
+      "epss_score": 0.99964,
+      "epss_percentile": 0.99976
+    },
+    {
+      "cve_id": "CVE-2020-0688",
+      "epss_score": 0.99962,
+      "epss_percentile": 0.99975
+    },
+    {
+      "cve_id": "CVE-2019-10149",
+      "epss_score": 0.99961,
+      "epss_percentile": 0.99975
+    },
+    {
+      "cve_id": "CVE-2022-1388",
+      "epss_score": 0.99958,
+      "epss_percentile": 0.99975
+    },
+    {
+      "cve_id": "CVE-2024-38475",
+      "epss_score": 0.99957,
+      "epss_percentile": 0.99975
+    },
+    {
+      "cve_id": "CVE-2022-41040",
+      "epss_score": 0.99956,
+      "epss_percentile": 0.99974
+    }
+  ]
+}
\ No newline at end of file
diff --git a/web/data/growth_analysis.json b/web/data/growth_analysis.json
new file mode 100644
index 00000000000..11c41f0b439
--- /dev/null
+++ b/web/data/growth_analysis.json
@@ -0,0 +1,262 @@
+{
+  "generated_at": "2026-09-23T22:55:40.848651",
+  "growth_data": [
+    {
+      "year": 1999,
+      "cves": 894,
+      "growth_rate": 0,
+      "growth_absolute": 0,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 0
+    },
+    {
+      "year": 2000,
+      "cves": 1019,
+      "growth_rate": 14.0,
+      "growth_absolute": 125,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 14.0
+    },
+    {
+      "year": 2001,
+      "cves": 1676,
+      "growth_rate": 64.5,
+      "growth_absolute": 657,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 26.2
+    },
+    {
+      "year": 2002,
+      "cves": 2156,
+      "growth_rate": 28.6,
+      "growth_absolute": 480,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 35.7
+    },
+    {
+      "year": 2003,
+      "cves": 1527,
+      "growth_rate": -29.2,
+      "growth_absolute": -629,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 21.3
+    },
+    {
+      "year": 2004,
+      "cves": 2451,
+      "growth_rate": 60.5,
+      "growth_absolute": 924,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 20.0
+    },
+    {
+      "year": 2005,
+      "cves": 4932,
+      "growth_rate": 101.2,
+      "growth_absolute": 2481,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 44.2
+    },
+    {
+      "year": 2006,
+      "cves": 6608,
+      "growth_rate": 34.0,
+      "growth_absolute": 1676,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 65.2
+    },
+    {
+      "year": 2007,
+      "cves": 6516,
+      "growth_rate": -1.4,
+      "growth_absolute": -92,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 44.6
+    },
+    {
+      "year": 2008,
+      "cves": 5632,
+      "growth_rate": -13.6,
+      "growth_absolute": -884,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 6.3
+    },
+    {
+      "year": 2009,
+      "cves": 5732,
+      "growth_rate": 1.8,
+      "growth_absolute": 100,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": -4.4
+    },
+    {
+      "year": 2010,
+      "cves": 4639,
+      "growth_rate": -19.1,
+      "growth_absolute": -1093,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": -10.3
+    },
+    {
+      "year": 2011,
+      "cves": 4150,
+      "growth_rate": -10.5,
+      "growth_absolute": -489,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": -9.3
+    },
+    {
+      "year": 2012,
+      "cves": 5288,
+      "growth_rate": 27.4,
+      "growth_absolute": 1138,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": -0.7
+    },
+    {
+      "year": 2013,
+      "cves": 5187,
+      "growth_rate": -1.9,
+      "growth_absolute": -101,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 5.0
+    },
+    {
+      "year": 2014,
+      "cves": 7928,
+      "growth_rate": 52.8,
+      "growth_absolute": 2741,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 26.1
+    },
+    {
+      "year": 2015,
+      "cves": 6494,
+      "growth_rate": -18.1,
+      "growth_absolute": -1434,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 10.9
+    },
+    {
+      "year": 2016,
+      "cves": 6449,
+      "growth_rate": -0.7,
+      "growth_absolute": -45,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 11.3
+    },
+    {
+      "year": 2017,
+      "cves": 14642,
+      "growth_rate": 127.0,
+      "growth_absolute": 8193,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 36.1
+    },
+    {
+      "year": 2018,
+      "cves": 16510,
+      "growth_rate": 12.8,
+      "growth_absolute": 1868,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 46.4
+    },
+    {
+      "year": 2019,
+      "cves": 17305,
+      "growth_rate": 4.8,
+      "growth_absolute": 795,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 48.2
+    },
+    {
+      "year": 2020,
+      "cves": 18322,
+      "growth_rate": 5.9,
+      "growth_absolute": 1017,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 7.8
+    },
+    {
+      "year": 2021,
+      "cves": 20149,
+      "growth_rate": 10.0,
+      "growth_absolute": 1827,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 6.9
+    },
+    {
+      "year": 2022,
+      "cves": 25074,
+      "growth_rate": 24.4,
+      "growth_absolute": 4925,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 13.4
+    },
+    {
+      "year": 2023,
+      "cves": 28816,
+      "growth_rate": 14.9,
+      "growth_absolute": 3742,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 16.4
+    },
+    {
+      "year": 2024,
+      "cves": 39953,
+      "growth_rate": 38.6,
+      "growth_absolute": 11137,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 26.0
+    },
+    {
+      "year": 2025,
+      "cves": 48153,
+      "growth_rate": 20.5,
+      "growth_absolute": 8200,
+      "is_ytd": false,
+      "growth_rate_3yr_avg": 24.7
+    },
+    {
+      "year": 2026,
+      "cves": 69597,
+      "growth_rate": 101.0,
+      "growth_absolute": 34974,
+      "is_ytd": true,
+      "projected_full_year": 95499,
+      "ytd_vs_prev_full": 44.5,
+      "ytd_vs_prev_ytd": 101.0,
+      "prev_year_ytd_actual": 34623,
+      "growth_rate_3yr_avg": 101.0
+    }
+  ],
+  "avg_annual_growth": 21.1,
+  "highest_growth_year": {
+    "year": 2017,
+    "cves": 14642,
+    "growth_rate": 127.0,
+    "growth_absolute": 8193,
+    "is_ytd": false,
+    "growth_rate_3yr_avg": 36.1
+  },
+  "lowest_growth_year": {
+    "year": 2003,
+    "cves": 1527,
+    "growth_rate": -29.2,
+    "growth_absolute": -629,
+    "is_ytd": false,
+    "growth_rate_3yr_avg": 21.3
+  },
+  "current_year_ytd": {
+    "year": 2026,
+    "cves": 69597,
+    "growth_rate": 101.0,
+    "growth_absolute": 34974,
+    "is_ytd": true,
+    "projected_full_year": 95499,
+    "ytd_vs_prev_full": 44.5,
+    "ytd_vs_prev_ytd": 101.0,
+    "prev_year_ytd_actual": 34623,
+    "growth_rate_3yr_avg": 101.0
+  }
+}
\ No newline at end of file
diff --git a/web/data/homepage_summary.json b/web/data/homepage_summary.json
new file mode 100644
index 00000000000..91d6fe9b74f
--- /dev/null
+++ b/web/data/homepage_summary.json
@@ -0,0 +1,3821 @@
+{
+  "generated_at": "2026-09-23T22:56:24.627160Z",
+  "data_as_of": "2026-09-23T22:49:26.546081Z",
+  "data_age_hours": 0.0,
+  "source_last_run": "2026-09-23T22:43:35.530306+00:00",
+  "source_age_hours": 0.1,
+  "source_cve_count": 396856,
+  "current_year": 2026,
+  "yearly_summary": {
+    "years": {
+      "1999": {
+        "year": 1999,
+        "total_cves": 894
+      },
+      "2000": {
+        "year": 2000,
+        "total_cves": 1019
+      },
+      "2001": {
+        "year": 2001,
+        "total_cves": 1676
+      },
+      "2002": {
+        "year": 2002,
+        "total_cves": 2156
+      },
+      "2003": {
+        "year": 2003,
+        "total_cves": 1527
+      },
+      "2004": {
+        "year": 2004,
+        "total_cves": 2451
+      },
+      "2005": {
+        "year": 2005,
+        "total_cves": 4932
+      },
+      "2006": {
+        "year": 2006,
+        "total_cves": 6608
+      },
+      "2007": {
+        "year": 2007,
+        "total_cves": 6516
+      },
+      "2008": {
+        "year": 2008,
+        "total_cves": 5632
+      },
+      "2009": {
+        "year": 2009,
+        "total_cves": 5732
+      },
+      "2010": {
+        "year": 2010,
+        "total_cves": 4639
+      },
+      "2011": {
+        "year": 2011,
+        "total_cves": 4150
+      },
+      "2012": {
+        "year": 2012,
+        "total_cves": 5288
+      },
+      "2013": {
+        "year": 2013,
+        "total_cves": 5187
+      },
+      "2014": {
+        "year": 2014,
+        "total_cves": 7928
+      },
+      "2015": {
+        "year": 2015,
+        "total_cves": 6494
+      },
+      "2016": {
+        "year": 2016,
+        "total_cves": 6449
+      },
+      "2017": {
+        "year": 2017,
+        "total_cves": 14642
+      },
+      "2018": {
+        "year": 2018,
+        "total_cves": 16510
+      },
+      "2019": {
+        "year": 2019,
+        "total_cves": 17305
+      },
+      "2020": {
+        "year": 2020,
+        "total_cves": 18322
+      },
+      "2021": {
+        "year": 2021,
+        "total_cves": 20149
+      },
+      "2022": {
+        "year": 2022,
+        "total_cves": 25074
+      },
+      "2023": {
+        "year": 2023,
+        "total_cves": 28816
+      },
+      "2024": {
+        "year": 2024,
+        "total_cves": 39953
+      },
+      "2025": {
+        "year": 2025,
+        "total_cves": 48153
+      },
+      "2026": {
+        "year": 2026,
+        "total_cves": 69597
+      }
+    }
+  },
+  "growth_analysis": {
+    "growth_data": [
+      {
+        "year": 1999,
+        "cves": 894,
+        "growth_rate": 0,
+        "growth_absolute": 0,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 0
+      },
+      {
+        "year": 2000,
+        "cves": 1019,
+        "growth_rate": 14.0,
+        "growth_absolute": 125,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 14.0
+      },
+      {
+        "year": 2001,
+        "cves": 1676,
+        "growth_rate": 64.5,
+        "growth_absolute": 657,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 26.2
+      },
+      {
+        "year": 2002,
+        "cves": 2156,
+        "growth_rate": 28.6,
+        "growth_absolute": 480,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 35.7
+      },
+      {
+        "year": 2003,
+        "cves": 1527,
+        "growth_rate": -29.2,
+        "growth_absolute": -629,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 21.3
+      },
+      {
+        "year": 2004,
+        "cves": 2451,
+        "growth_rate": 60.5,
+        "growth_absolute": 924,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 20.0
+      },
+      {
+        "year": 2005,
+        "cves": 4932,
+        "growth_rate": 101.2,
+        "growth_absolute": 2481,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 44.2
+      },
+      {
+        "year": 2006,
+        "cves": 6608,
+        "growth_rate": 34.0,
+        "growth_absolute": 1676,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 65.2
+      },
+      {
+        "year": 2007,
+        "cves": 6516,
+        "growth_rate": -1.4,
+        "growth_absolute": -92,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 44.6
+      },
+      {
+        "year": 2008,
+        "cves": 5632,
+        "growth_rate": -13.6,
+        "growth_absolute": -884,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 6.3
+      },
+      {
+        "year": 2009,
+        "cves": 5732,
+        "growth_rate": 1.8,
+        "growth_absolute": 100,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": -4.4
+      },
+      {
+        "year": 2010,
+        "cves": 4639,
+        "growth_rate": -19.1,
+        "growth_absolute": -1093,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": -10.3
+      },
+      {
+        "year": 2011,
+        "cves": 4150,
+        "growth_rate": -10.5,
+        "growth_absolute": -489,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": -9.3
+      },
+      {
+        "year": 2012,
+        "cves": 5288,
+        "growth_rate": 27.4,
+        "growth_absolute": 1138,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": -0.7
+      },
+      {
+        "year": 2013,
+        "cves": 5187,
+        "growth_rate": -1.9,
+        "growth_absolute": -101,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 5.0
+      },
+      {
+        "year": 2014,
+        "cves": 7928,
+        "growth_rate": 52.8,
+        "growth_absolute": 2741,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 26.1
+      },
+      {
+        "year": 2015,
+        "cves": 6494,
+        "growth_rate": -18.1,
+        "growth_absolute": -1434,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 10.9
+      },
+      {
+        "year": 2016,
+        "cves": 6449,
+        "growth_rate": -0.7,
+        "growth_absolute": -45,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 11.3
+      },
+      {
+        "year": 2017,
+        "cves": 14642,
+        "growth_rate": 127.0,
+        "growth_absolute": 8193,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 36.1
+      },
+      {
+        "year": 2018,
+        "cves": 16510,
+        "growth_rate": 12.8,
+        "growth_absolute": 1868,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 46.4
+      },
+      {
+        "year": 2019,
+        "cves": 17305,
+        "growth_rate": 4.8,
+        "growth_absolute": 795,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 48.2
+      },
+      {
+        "year": 2020,
+        "cves": 18322,
+        "growth_rate": 5.9,
+        "growth_absolute": 1017,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 7.8
+      },
+      {
+        "year": 2021,
+        "cves": 20149,
+        "growth_rate": 10.0,
+        "growth_absolute": 1827,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 6.9
+      },
+      {
+        "year": 2022,
+        "cves": 25074,
+        "growth_rate": 24.4,
+        "growth_absolute": 4925,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 13.4
+      },
+      {
+        "year": 2023,
+        "cves": 28816,
+        "growth_rate": 14.9,
+        "growth_absolute": 3742,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 16.4
+      },
+      {
+        "year": 2024,
+        "cves": 39953,
+        "growth_rate": 38.6,
+        "growth_absolute": 11137,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 26.0
+      },
+      {
+        "year": 2025,
+        "cves": 48153,
+        "growth_rate": 20.5,
+        "growth_absolute": 8200,
+        "is_ytd": false,
+        "growth_rate_3yr_avg": 24.7
+      },
+      {
+        "year": 2026,
+        "cves": 69597,
+        "growth_rate": 101.0,
+        "growth_absolute": 34974,
+        "is_ytd": true,
+        "projected_full_year": 95499,
+        "ytd_vs_prev_full": 44.5,
+        "ytd_vs_prev_ytd": 101.0,
+        "prev_year_ytd_actual": 34623,
+        "growth_rate_3yr_avg": 101.0
+      }
+    ]
+  },
+  "cvss_analysis": {
+    "score_distribution": {
+      "v2.0": {
+        "10.0": 9020,
+        "5.0": 26844,
+        "7.5": 27042,
+        "4.6": 5466,
+        "5.1": 1169,
+        "3.7": 152,
+        "0.0": 17,
+        "6.4": 2735,
+        "7.2": 6194,
+        "4.9": 2056,
+        "2.1": 6846,
+        "7.8": 3230,
+        "2.6": 1408,
+        "6.2": 235,
+        "9.3": 8442,
+        "1.2": 183,
+        "3.6": 870,
+        "7.6": 1265,
+        "7.1": 1040,
+        "4.0": 9129,
+        "9.0": 3847,
+        "4.3": 27232,
+        "3.5": 7524,
+        "3.3": 1508,
+        "6.8": 15522,
+        "5.4": 1613,
+        "1.7": 432,
+        "6.9": 1501,
+        "1.9": 882,
+        "3.8": 16,
+        "8.5": 487,
+        "8.3": 486,
+        "6.6": 198,
+        "9.4": 125,
+        "5.8": 4269,
+        "8.8": 46,
+        "6.5": 9578,
+        "4.4": 1032,
+        "5.2": 587,
+        "4.8": 95,
+        "6.3": 149,
+        "6.0": 1016,
+        "4.7": 362,
+        "1.0": 56,
+        "5.5": 1776,
+        "5.6": 55,
+        "6.1": 461,
+        "5.7": 56,
+        "1.5": 36,
+        "3.2": 59,
+        "9.7": 11,
+        "2.3": 62,
+        "4.1": 57,
+        "2.7": 164,
+        "2.4": 22,
+        "2.9": 215,
+        "7.9": 85,
+        "7.3": 10,
+        "3.4": 2,
+        "7.4": 31,
+        "1.8": 44,
+        "3.0": 14,
+        "5.9": 15,
+        "8.0": 36,
+        "8.2": 5,
+        "1.3": 2,
+        "7.7": 143,
+        "2.8": 14,
+        "5.3": 1,
+        "6.7": 5,
+        "7.0": 10,
+        "1.4": 34,
+        "8.7": 6,
+        "0.8": 6,
+        "2.2": 3
+      },
+      "v3.0": {
+        "7.5": 6182,
+        "9.8": 6066,
+        "5.6": 88,
+        "6.1": 3787,
+        "5.9": 1079,
+        "4.2": 119,
+        "3.7": 242,
+        "6.3": 335,
+        "6.5": 3543,
+        "5.3": 1895,
+        "6.8": 616,
+        "4.9": 331,
+        "5.5": 2545,
+        "7.8": 6583,
+        "3.3": 664,
+        "8.1": 1075,
+        "7.3": 441,
+        "4.3": 1481,
+        "8.3": 147,
+        "8.6": 459,
+        "10.0": 282,
+        "8.0": 274,
+        "6.7": 322,
+        "9.1": 489,
+        "7.2": 777,
+        "8.8": 5652,
+        "9.9": 162,
+        "8.5": 156,
+        "8.7": 42,
+        "6.9": 18,
+        "4.4": 219,
+        "2.3": 22,
+        "5.8": 147,
+        "4.0": 159,
+        "8.4": 219,
+        "7.4": 347,
+        "6.2": 174,
+        "7.6": 170,
+        "5.4": 2231,
+        "5.1": 95,
+        "7.0": 547,
+        "7.7": 164,
+        "2.5": 38,
+        "4.7": 408,
+        "5.0": 145,
+        "3.5": 99,
+        "3.1": 166,
+        "6.6": 138,
+        "9.0": 149,
+        "9.6": 181,
+        "6.4": 215,
+        "4.6": 184,
+        "7.1": 539,
+        "4.1": 52,
+        "8.2": 598,
+        "2.0": 8,
+        "2.9": 19,
+        "2.6": 12,
+        "9.3": 62,
+        "5.7": 118,
+        "7.9": 18,
+        "3.4": 22,
+        "3.8": 44,
+        "4.8": 589,
+        "2.7": 86,
+        "6.0": 143,
+        "4.5": 39,
+        "3.0": 7,
+        "9.4": 47,
+        "2.4": 56,
+        "2.8": 20,
+        "2.1": 8,
+        "1.8": 5,
+        "1.9": 3,
+        "3.9": 27,
+        "5.2": 59,
+        "2.2": 15,
+        "3.6": 11,
+        "8.9": 4,
+        "1.6": 1,
+        "3.2": 6,
+        "0.0": 4
+      },
+      "v3.1": {
+        "7.3": 5415,
+        "7.5": 22674,
+        "9.8": 20821,
+        "8.2": 2385,
+        "7.8": 20863,
+        "5.5": 16259,
+        "7.1": 6917,
+        "8.8": 18613,
+        "5.3": 10607,
+        "9.1": 3440,
+        "3.3": 1885,
+        "6.5": 18113,
+        "6.1": 10192,
+        "4.8": 2956,
+        "7.0": 1645,
+        "5.9": 3713,
+        "8.4": 1513,
+        "3.7": 1158,
+        "4.7": 2139,
+        "7.4": 1297,
+        "4.5": 239,
+        "4.3": 11517,
+        "5.0": 876,
+        "6.3": 5954,
+        "5.6": 431,
+        "8.1": 5523,
+        "7.2": 4833,
+        "5.4": 10825,
+        "4.6": 992,
+        "6.8": 2141,
+        "4.4": 1959,
+        "9.9": 1442,
+        "5.8": 637,
+        "7.7": 1240,
+        "5.7": 759,
+        "6.0": 640,
+        "9.6": 1252,
+        "6.7": 2511,
+        "9.0": 673,
+        "10.0": 1293,
+        "7.6": 1158,
+        "9.3": 898,
+        "4.9": 2168,
+        "4.2": 634,
+        "4.0": 667,
+        "3.4": 131,
+        "8.0": 1369,
+        "5.1": 396,
+        "6.6": 745,
+        "6.4": 4081,
+        "8.6": 1523,
+        "6.2": 1106,
+        "4.1": 411,
+        "2.5": 262,
+        "7.9": 180,
+        "8.9": 103,
+        "2.7": 643,
+        "2.4": 770,
+        "3.5": 2399,
+        "8.3": 1062,
+        "3.1": 894,
+        "3.8": 352,
+        "1.9": 52,
+        "2.6": 179,
+        "3.6": 87,
+        "2.8": 112,
+        "9.4": 274,
+        "5.2": 173,
+        "8.7": 585,
+        "2.1": 17,
+        "8.5": 938,
+        "2.2": 124,
+        "2.3": 115,
+        "6.9": 167,
+        "1.6": 8,
+        "3.9": 173,
+        "1.8": 30,
+        "2.0": 102,
+        "2.9": 168,
+        "3.0": 85,
+        "3.2": 97,
+        "1.7": 2,
+        "0.0": 44,
+        "9.2": 9
+      },
+      "v4.0": {
+        "7.1": 1578,
+        "8.7": 3240,
+        "10.0": 370,
+        "7.3": 498,
+        "9.3": 1855,
+        "8.6": 1106,
+        "6.9": 3358,
+        "5.9": 276,
+        "5.1": 2190,
+        "8.8": 738,
+        "5.3": 3453,
+        "2.1": 2927,
+        "9.2": 448,
+        "6.3": 762,
+        "5.5": 2496,
+        "5.2": 81,
+        "9.1": 120,
+        "2.0": 975,
+        "4.8": 778,
+        "5.4": 264,
+        "2.3": 461,
+        "8.2": 475,
+        "9.4": 463,
+        "1.9": 785,
+        "9.0": 79,
+        "1.0": 52,
+        "8.5": 997,
+        "7.5": 178,
+        "8.9": 358,
+        "5.7": 178,
+        "7.0": 415,
+        "7.7": 405,
+        "6.7": 126,
+        "6.8": 414,
+        "4.6": 237,
+        "8.1": 44,
+        "1.8": 65,
+        "8.4": 538,
+        "6.4": 108,
+        "1.3": 195,
+        "6.0": 383,
+        "8.3": 339,
+        "5.6": 77,
+        "7.4": 968,
+        "1.2": 58,
+        "7.2": 282,
+        "6.2": 49,
+        "7.8": 63,
+        "6.1": 118,
+        "9.5": 97,
+        "6.5": 18,
+        "9.9": 31,
+        "7.6": 188,
+        "5.8": 128,
+        "4.3": 31,
+        "4.1": 42,
+        "4.9": 67,
+        "2.4": 74,
+        "6.6": 102,
+        "4.4": 20,
+        "5.0": 15,
+        "2.7": 73,
+        "7.9": 24,
+        "2.9": 212,
+        "1.1": 69,
+        "4.5": 19,
+        "4.7": 14,
+        "4.0": 16,
+        "8.0": 14,
+        "1.7": 43,
+        "0.0": 61,
+        "2.6": 1,
+        "0.3": 12,
+        "0.9": 19,
+        "2.5": 2,
+        "0.5": 6,
+        "0.6": 15,
+        "2.2": 6,
+        "3.7": 1,
+        "3.8": 5,
+        "0.1": 2,
+        "0.4": 1,
+        "3.6": 6,
+        "3.3": 2,
+        "1.6": 1,
+        "4.2": 1
+      }
+    },
+    "kev_global_count": 1721,
+    "total_scores_all_versions": 541733
+  },
+  "epss_analysis": {
+    "statistics": {
+      "average_score": 0.027281,
+      "gt_0_1": 17397,
+      "gt_0_3": 7073,
+      "gt_0_5": 4346,
+      "gt_0_7": 2479,
+      "gt_0_9": 802
+    },
+    "total_cves_with_epss": 378156,
+    "total_cves_with_epss_matched": 377477,
+    "epss_without_published_record": 679
+  },
+  "kev_analysis": {
+    "statistics": {
+      "added_last_30_days": 47,
+      "added_last_90_days": 94,
+      "ransomware_associated": 361
+    },
+    "by_year_added": {
+      "2021": 311,
+      "2022": 555,
+      "2023": 187,
+      "2024": 186,
+      "2025": 245,
+      "2026": 237
+    },
+    "by_year_published": {
+      "2002": 1,
+      "2004": 2,
+      "2005": 1,
+      "2006": 2,
+      "2007": 2,
+      "2008": 6,
+      "2009": 14,
+      "2010": 23,
+      "2011": 9,
+      "2012": 22,
+      "2013": 35,
+      "2014": 34,
+      "2015": 45,
+      "2016": 53,
+      "2017": 89,
+      "2018": 76,
+      "2019": 129,
+      "2020": 146,
+      "2021": 214,
+      "2022": 131,
+      "2023": 165,
+      "2024": 160,
+      "2025": 197,
+      "2026": 165
+    }
+  },
+  "cwe_analysis": {
+    "top_cwes": [
+      {
+        "id": "79",
+        "name": "CWE-79: Cross-site Scripting (XSS)",
+        "count": 53914,
+        "description": "Cross-site Scripting (XSS)"
+      },
+      {
+        "id": "89",
+        "name": "CWE-89: SQL Injection",
+        "count": 24511,
+        "description": "SQL Injection"
+      },
+      {
+        "id": "787",
+        "name": "CWE-787: Out-of-bounds Write",
+        "count": 17297,
+        "description": "Out-of-bounds Write"
+      },
+      {
+        "id": "20",
+        "name": "CWE-20: Improper Input Validation",
+        "count": 13705,
+        "description": "Improper Input Validation"
+      },
+      {
+        "id": "119",
+        "name": "CWE-119: Buffer Overflow",
+        "count": 12752,
+        "description": "Buffer Overflow"
+      },
+      {
+        "id": "22",
+        "name": "CWE-22: Path Traversal",
+        "count": 11674,
+        "description": "Path Traversal"
+      },
+      {
+        "id": "200",
+        "name": "CWE-200: Information Exposure",
+        "count": 11454,
+        "description": "Information Exposure"
+      },
+      {
+        "id": "125",
+        "name": "CWE-125: Out-of-bounds Read",
+        "count": 11297,
+        "description": "Out-of-bounds Read"
+      },
+      {
+        "id": "862",
+        "name": "CWE-862: Missing Authorization",
+        "count": 10880,
+        "description": "Missing Authorization"
+      },
+      {
+        "id": "416",
+        "name": "CWE-416: Use After Free",
+        "count": 10346,
+        "description": "Use After Free"
+      }
+    ],
+    "total_cves_with_cwe": 269872,
+    "total_unique_cwes": 69
+  },
+  "cna_analysis": {
+    "cna_list": [
+      {
+        "name": "mitre",
+        "assigner_org_id": "8254265b-2729-46b6-b9e3-3dfca2d5bfca",
+        "count": 115033,
+        "years_active": 28,
+        "first_cve_year": 1999,
+        "last_cve_year": 2026,
+        "first_cve_date": "1999-09-29T00:00:00.000Z",
+        "last_cve_date": "2026-09-23T16:58:37.139Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Program"
+        ],
+        "cves_by_year": {
+          "1999": 320,
+          "2000": 1437,
+          "2001": 1323,
+          "2002": 1690,
+          "2020": 7221,
+          "2004": 1612,
+          "2007": 6730,
+          "2005": 6302,
+          "2006": 6355,
+          "2003": 1223,
+          "2009": 4899,
+          "2010": 2831,
+          "2011": 2086,
+          "2016": 1647,
+          "2014": 2655,
+          "2015": 2031,
+          "2025": 5203,
+          "2021": 6473,
+          "2013": 1234,
+          "2019": 7730,
+          "2008": 5038,
+          "2018": 7290,
+          "2017": 6611,
+          "2012": 2107,
+          "2022": 7610,
+          "2023": 6237,
+          "2024": 5910,
+          "2026": 3228
+        },
+        "years_active_list": [
+          1999,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 322,
+        "epss_high_count": 1732,
+        "epss_elevated_count": 7270,
+        "top_cwes": [],
+        "rank": 1
+      },
+      {
+        "name": "GitHub_M",
+        "assigner_org_id": "a0819718-46f1-4df5-94e2-005712e83aaa",
+        "count": 20253,
+        "years_active": 8,
+        "first_cve_year": 2019,
+        "last_cve_year": 2026,
+        "first_cve_date": "2019-09-30T21:39:38.000Z",
+        "last_cve_date": "2026-09-23T22:07:35.095Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Open Source"
+        ],
+        "cves_by_year": {
+          "2019": 26,
+          "2020": 498,
+          "2022": 1293,
+          "2021": 1065,
+          "2024": 2120,
+          "2023": 1771,
+          "2026": 10614,
+          "2025": 2866
+        },
+        "years_active_list": [
+          2019,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 41,
+        "epss_high_count": 178,
+        "epss_elevated_count": 423,
+        "top_cwes": [],
+        "rank": 2
+      },
+      {
+        "name": "Patchstack",
+        "assigner_org_id": "21595511-bba5-4825-b968-b78d1f9984a3",
+        "count": 18050,
+        "years_active": 6,
+        "first_cve_year": 2021,
+        "last_cve_year": 2026,
+        "first_cve_date": "2021-09-09T11:18:20.862Z",
+        "last_cve_date": "2026-09-23T19:28:55.531Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Security Researcher"
+        ],
+        "cves_by_year": {
+          "2022": 381,
+          "2021": 30,
+          "2023": 2146,
+          "2024": 4564,
+          "2025": 7006,
+          "2026": 3923
+        },
+        "years_active_list": [
+          2021,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 0,
+        "epss_high_count": 12,
+        "epss_elevated_count": 34,
+        "top_cwes": [],
+        "rank": 3
+      },
+      {
+        "name": "VulDB",
+        "assigner_org_id": "1af790b2-7ee1-4545-860a-a788eba489b5",
+        "count": 16730,
+        "years_active": 5,
+        "first_cve_year": 2022,
+        "last_cve_year": 2026,
+        "first_cve_date": "2022-03-28T18:00:15.000Z",
+        "last_cve_date": "2026-09-23T22:45:09.921Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Security Researcher"
+        ],
+        "cves_by_year": {
+          "2023": 1931,
+          "2024": 2930,
+          "2022": 854,
+          "2025": 5901,
+          "2026": 5114
+        },
+        "years_active_list": [
+          2022,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 4,
+        "epss_high_count": 32,
+        "epss_elevated_count": 266,
+        "top_cwes": [],
+        "rank": 4
+      },
+      {
+        "name": "Linux",
+        "assigner_org_id": "416baaa9-dc9f-4396-8d5f-8c081fb06d67",
+        "count": 16509,
+        "years_active": 3,
+        "first_cve_year": 2024,
+        "last_cve_year": 2026,
+        "first_cve_date": "2024-02-20T12:52:56.753Z",
+        "last_cve_date": "2026-09-17T16:12:24.403Z",
+        "days_since_last_cve": 6,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Open Source"
+        ],
+        "cves_by_year": {
+          "2024": 4287,
+          "2025": 5675,
+          "2026": 6547
+        },
+        "years_active_list": [
+          2024,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 11,
+        "epss_high_count": 5,
+        "epss_elevated_count": 12,
+        "top_cwes": [],
+        "rank": 5
+      },
+      {
+        "name": "microsoft",
+        "assigner_org_id": "f38d906d-7342-40ea-92c1-6c4a2c6478c8",
+        "count": 14479,
+        "years_active": 22,
+        "first_cve_year": 2005,
+        "last_cve_year": 2026,
+        "first_cve_date": "2005-04-13T04:00:00.000Z",
+        "last_cve_date": "2026-09-23T22:40:40.537Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2005": 49,
+          "2006": 121,
+          "2007": 109,
+          "2014": 342,
+          "2008": 146,
+          "2009": 170,
+          "2010": 264,
+          "2012": 148,
+          "2011": 221,
+          "2013": 321,
+          "2018": 703,
+          "2015": 526,
+          "2017": 695,
+          "2016": 461,
+          "2020": 1262,
+          "2019": 845,
+          "2023": 994,
+          "2021": 871,
+          "2022": 931,
+          "2024": 1095,
+          "2025": 1244,
+          "2026": 2961
+        },
+        "years_active_list": [
+          2005,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 379,
+        "epss_high_count": 556,
+        "epss_elevated_count": 3668,
+        "top_cwes": [],
+        "rank": 6
+      },
+      {
+        "name": "redhat",
+        "assigner_org_id": "53f830b8-0a3f-465b-8143-3b8a9948e749",
+        "count": 11691,
+        "years_active": 22,
+        "first_cve_year": 2005,
+        "last_cve_year": 2026,
+        "first_cve_date": "2005-02-07T05:00:00.000Z",
+        "last_cve_date": "2026-09-23T21:24:01.514Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2006": 270,
+          "2019": 630,
+          "2021": 452,
+          "2014": 950,
+          "2005": 239,
+          "2010": 464,
+          "2007": 244,
+          "2020": 567,
+          "2017": 477,
+          "2012": 1156,
+          "2008": 272,
+          "2013": 970,
+          "2009": 311,
+          "2011": 515,
+          "2018": 562,
+          "2016": 537,
+          "2022": 627,
+          "2015": 400,
+          "2023": 446,
+          "2024": 306,
+          "2025": 300,
+          "2026": 996
+        },
+        "years_active_list": [
+          2005,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 33,
+        "epss_high_count": 187,
+        "epss_elevated_count": 783,
+        "top_cwes": [],
+        "rank": 7
+      },
+      {
+        "name": "oracle",
+        "assigner_org_id": "43595867-4340-4103-b7a2-9a5208d29a85",
+        "count": 11319,
+        "years_active": 19,
+        "first_cve_year": 2008,
+        "last_cve_year": 2026,
+        "first_cve_date": "2008-10-14T21:00:00.000Z",
+        "last_cve_date": "2026-09-15T21:53:18.809Z",
+        "days_since_last_cve": 8,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2013": 525,
+          "2009": 145,
+          "2008": 32,
+          "2010": 250,
+          "2011": 307,
+          "2012": 406,
+          "2014": 447,
+          "2015": 483,
+          "2016": 667,
+          "2017": 869,
+          "2019": 613,
+          "2018": 707,
+          "2020": 811,
+          "2024": 370,
+          "2021": 586,
+          "2022": 416,
+          "2025": 314,
+          "2023": 295,
+          "2026": 3076
+        },
+        "years_active_list": [
+          2008,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 44,
+        "epss_high_count": 116,
+        "epss_elevated_count": 219,
+        "top_cwes": [],
+        "rank": 8
+      },
+      {
+        "name": "Wordfence",
+        "assigner_org_id": "b15e7b5b-3da4-40ae-a43c-f7aa60e62599",
+        "count": 11222,
+        "years_active": 6,
+        "first_cve_year": 2021,
+        "last_cve_year": 2026,
+        "first_cve_date": "2021-07-07T12:20:58.388Z",
+        "last_cve_date": "2026-09-23T21:27:34.729Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Security Researcher"
+        ],
+        "cves_by_year": {
+          "2024": 3524,
+          "2025": 3450,
+          "2023": 879,
+          "2026": 3046,
+          "2022": 169,
+          "2021": 154
+        },
+        "years_active_list": [
+          2021,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 0,
+        "epss_high_count": 54,
+        "epss_elevated_count": 140,
+        "top_cwes": [],
+        "rank": 9
+      },
+      {
+        "name": "ibm",
+        "assigner_org_id": "9a959283-ebb5-44b6-b705-dcc2bbced522",
+        "count": 7779,
+        "years_active": 15,
+        "first_cve_year": 2012,
+        "last_cve_year": 2026,
+        "first_cve_date": "2012-01-18T20:00:00.000Z",
+        "last_cve_date": "2026-09-23T21:39:25.036Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2022": 406,
+          "2013": 388,
+          "2020": 565,
+          "2012": 151,
+          "2018": 644,
+          "2014": 448,
+          "2015": 309,
+          "2017": 677,
+          "2016": 368,
+          "2019": 489,
+          "2021": 605,
+          "2023": 414,
+          "2024": 504,
+          "2025": 606,
+          "2026": 1205
+        },
+        "years_active_list": [
+          2012,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 8,
+        "epss_high_count": 19,
+        "epss_elevated_count": 53,
+        "top_cwes": [],
+        "rank": 10
+      },
+      {
+        "name": "adobe",
+        "assigner_org_id": "078d4453-3bcd-4900-85e6-15281da43538",
+        "count": 7594,
+        "years_active": 18,
+        "first_cve_year": 2009,
+        "last_cve_year": 2026,
+        "first_cve_date": "2009-10-13T10:00:00.000Z",
+        "last_cve_date": "2026-09-22T18:58:12.860Z",
+        "days_since_last_cve": 1,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2009": 20,
+          "2010": 180,
+          "2011": 181,
+          "2012": 136,
+          "2018": 387,
+          "2014": 130,
+          "2013": 142,
+          "2015": 481,
+          "2016": 547,
+          "2017": 353,
+          "2019": 704,
+          "2023": 681,
+          "2020": 349,
+          "2021": 431,
+          "2026": 830,
+          "2022": 460,
+          "2024": 753,
+          "2025": 829
+        },
+        "years_active_list": [
+          2009,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 75,
+        "epss_high_count": 118,
+        "epss_elevated_count": 717,
+        "top_cwes": [],
+        "rank": 11
+      },
+      {
+        "name": "VulnCheck",
+        "assigner_org_id": "83251b91-4cc7-4094-a5c7-464a1b83ea10",
+        "count": 7501,
+        "years_active": 4,
+        "first_cve_year": 2023,
+        "last_cve_year": 2026,
+        "first_cve_date": "2023-04-19T19:10:12.523Z",
+        "last_cve_date": "2026-09-23T21:36:23.658Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2025": 1073,
+          "2026": 6380,
+          "2023": 10,
+          "2024": 38
+        },
+        "years_active_list": [
+          2023,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 19,
+        "epss_high_count": 33,
+        "epss_elevated_count": 79,
+        "top_cwes": [],
+        "rank": 12
+      },
+      {
+        "name": "apple",
+        "assigner_org_id": "286789f9-fbc2-4510-9f9a-43facdede74c",
+        "count": 7347,
+        "years_active": 17,
+        "first_cve_year": 2010,
+        "last_cve_year": 2026,
+        "first_cve_date": "2010-01-20T16:00:00.000Z",
+        "last_cve_date": "2026-09-23T17:20:20.178Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2010": 265,
+          "2011": 211,
+          "2017": 581,
+          "2013": 173,
+          "2012": 281,
+          "2020": 463,
+          "2015": 612,
+          "2014": 253,
+          "2016": 303,
+          "2019": 500,
+          "2018": 177,
+          "2021": 561,
+          "2025": 730,
+          "2022": 370,
+          "2023": 460,
+          "2024": 596,
+          "2026": 811
+        },
+        "years_active_list": [
+          2010,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 94,
+        "epss_high_count": 10,
+        "epss_elevated_count": 128,
+        "top_cwes": [],
+        "rank": 13
+      },
+      {
+        "name": "cisco",
+        "assigner_org_id": "d1c1063e-7a18-46af-9102-31f8928bc633",
+        "count": 6523,
+        "years_active": 20,
+        "first_cve_year": 2007,
+        "last_cve_year": 2026,
+        "first_cve_date": "2007-11-08T02:00:00.000Z",
+        "last_cve_date": "2026-09-16T20:26:30.469Z",
+        "days_since_last_cve": 7,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2007": 5,
+          "2008": 73,
+          "2009": 85,
+          "2011": 133,
+          "2010": 111,
+          "2020": 558,
+          "2017": 466,
+          "2012": 159,
+          "2019": 566,
+          "2014": 365,
+          "2013": 432,
+          "2015": 489,
+          "2016": 354,
+          "2018": 464,
+          "2025": 274,
+          "2024": 361,
+          "2021": 586,
+          "2023": 263,
+          "2022": 316,
+          "2026": 463
+        },
+        "years_active_list": [
+          2007,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 98,
+        "epss_high_count": 74,
+        "epss_elevated_count": 223,
+        "top_cwes": [],
+        "rank": 14
+      },
+      {
+        "name": "Chrome",
+        "assigner_org_id": "ebfee0ef-53dd-4cf3-9e2a-08a5bd7a7e28",
+        "count": 6269,
+        "years_active": 16,
+        "first_cve_year": 2011,
+        "last_cve_year": 2026,
+        "first_cve_date": "2011-05-16T17:00:00.000Z",
+        "last_cve_date": "2026-09-17T21:08:43.666Z",
+        "days_since_last_cve": 6,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2012": 194,
+          "2020": 262,
+          "2011": 165,
+          "2013": 219,
+          "2019": 358,
+          "2014": 116,
+          "2017": 164,
+          "2015": 178,
+          "2018": 163,
+          "2016": 171,
+          "2021": 375,
+          "2024": 261,
+          "2023": 297,
+          "2022": 357,
+          "2025": 195,
+          "2026": 2794
+        },
+        "years_active_list": [
+          2011,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 76,
+        "epss_high_count": 17,
+        "epss_elevated_count": 123,
+        "top_cwes": [],
+        "rank": 15
+      },
+      {
+        "name": "WPScan",
+        "assigner_org_id": "1bfdd5d7-9bf6-4a53-96ea-42e2716d7a81",
+        "count": 5550,
+        "years_active": 6,
+        "first_cve_year": 2021,
+        "last_cve_year": 2026,
+        "first_cve_date": "2021-03-18T14:57:47.000Z",
+        "last_cve_date": "2026-09-23T12:08:59.817Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2021": 747,
+          "2025": 595,
+          "2024": 773,
+          "2022": 1144,
+          "2023": 935,
+          "2026": 1356
+        },
+        "years_active_list": [
+          2021,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 2,
+        "epss_high_count": 36,
+        "epss_elevated_count": 150,
+        "top_cwes": [],
+        "rank": 16
+      },
+      {
+        "name": "google_android",
+        "assigner_org_id": "baff130e-b8d5-4e15-b3d3-c3cf5d5545c6",
+        "count": 5230,
+        "years_active": 12,
+        "first_cve_year": 2015,
+        "last_cve_year": 2026,
+        "first_cve_date": "2015-10-01T00:00:00.000Z",
+        "last_cve_date": "2026-09-08T19:20:33.261Z",
+        "days_since_last_cve": 15,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2016": 518,
+          "2017": 702,
+          "2020": 535,
+          "2018": 286,
+          "2015": 82,
+          "2024": 258,
+          "2025": 286,
+          "2019": 477,
+          "2021": 530,
+          "2022": 698,
+          "2023": 626,
+          "2026": 232
+        },
+        "years_active_list": [
+          2015,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 14,
+        "epss_high_count": 7,
+        "epss_elevated_count": 14,
+        "top_cwes": [],
+        "rank": 17
+      },
+      {
+        "name": "icscert",
+        "assigner_org_id": "7d14cffa-0d7d-4270-9dc0-52cabd5a23a6",
+        "count": 3796,
+        "years_active": 15,
+        "first_cve_year": 2012,
+        "last_cve_year": 2026,
+        "first_cve_date": "2012-05-09T10:00:00.000Z",
+        "last_cve_date": "2026-09-22T20:40:26.449Z",
+        "days_since_last_cve": 1,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "CERT"
+        ],
+        "cves_by_year": {
+          "2019": 228,
+          "2012": 49,
+          "2013": 112,
+          "2015": 145,
+          "2014": 104,
+          "2016": 130,
+          "2018": 338,
+          "2017": 276,
+          "2020": 280,
+          "2023": 335,
+          "2021": 306,
+          "2022": 493,
+          "2024": 255,
+          "2025": 333,
+          "2026": 412
+        },
+        "years_active_list": [
+          2012,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 8,
+        "epss_high_count": 27,
+        "epss_elevated_count": 155,
+        "top_cwes": [],
+        "rank": 18
+      },
+      {
+        "name": "zdi",
+        "assigner_org_id": "99f1926a-a320-47d8-bbb5-42feb611262e",
+        "count": 3426,
+        "years_active": 12,
+        "first_cve_year": 2015,
+        "last_cve_year": 2026,
+        "first_cve_date": "2015-05-20T18:00:00.000Z",
+        "last_cve_date": "2026-09-15T18:05:59.201Z",
+        "days_since_last_cve": 8,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2015": 1,
+          "2016": 1,
+          "2018": 246,
+          "2017": 63,
+          "2019": 154,
+          "2020": 193,
+          "2021": 218,
+          "2022": 298,
+          "2024": 1286,
+          "2023": 259,
+          "2025": 487,
+          "2026": 220
+        },
+        "years_active_list": [
+          2015,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 6,
+        "epss_high_count": 85,
+        "epss_elevated_count": 152,
+        "top_cwes": [],
+        "rank": 19
+      },
+      {
+        "name": "jpcert",
+        "assigner_org_id": "ede6fdc4-6654-4307-a26d-3331c018e2ce",
+        "count": 3224,
+        "years_active": 17,
+        "first_cve_year": 2010,
+        "last_cve_year": 2026,
+        "first_cve_date": "2010-06-25T18:00:00.000Z",
+        "last_cve_date": "2026-09-16T07:30:01.520Z",
+        "days_since_last_cve": 7,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "CERT"
+        ],
+        "cves_by_year": {
+          "2011": 76,
+          "2010": 21,
+          "2020": 168,
+          "2014": 132,
+          "2012": 93,
+          "2013": 120,
+          "2015": 154,
+          "2023": 324,
+          "2017": 408,
+          "2019": 195,
+          "2016": 112,
+          "2018": 172,
+          "2021": 242,
+          "2022": 217,
+          "2025": 270,
+          "2024": 281,
+          "2026": 239
+        },
+        "years_active_list": [
+          2010,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 6,
+        "epss_high_count": 8,
+        "epss_elevated_count": 21,
+        "top_cwes": [],
+        "rank": 20
+      },
+      {
+        "name": "certcc",
+        "assigner_org_id": "37e5125f-f79b-445b-8fad-9564f167944b",
+        "count": 3135,
+        "years_active": 22,
+        "first_cve_year": 2005,
+        "last_cve_year": 2026,
+        "first_cve_date": "2005-03-08T05:00:00.000Z",
+        "last_cve_date": "2026-09-23T18:25:22.672Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "CERT"
+        ],
+        "cves_by_year": {
+          "2005": 12,
+          "2006": 21,
+          "2007": 55,
+          "2008": 47,
+          "2009": 32,
+          "2010": 27,
+          "2015": 154,
+          "2012": 231,
+          "2011": 58,
+          "2019": 43,
+          "2020": 53,
+          "2013": 111,
+          "2014": 1536,
+          "2017": 200,
+          "2016": 124,
+          "2022": 26,
+          "2018": 110,
+          "2024": 24,
+          "2023": 37,
+          "2021": 9,
+          "2026": 178,
+          "2025": 47
+        },
+        "years_active_list": [
+          2005,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 7,
+        "epss_high_count": 66,
+        "epss_elevated_count": 229,
+        "top_cwes": [],
+        "rank": 21
+      },
+      {
+        "name": "qualcomm",
+        "assigner_org_id": "2cfc7d3e-20d3-47ac-8db7-1b7285aff15f",
+        "count": 3064,
+        "years_active": 10,
+        "first_cve_year": 2017,
+        "last_cve_year": 2026,
+        "first_cve_date": "2017-04-06T19:00:00.000Z",
+        "last_cve_date": "2026-09-22T09:45:23.173Z",
+        "days_since_last_cve": 1,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2017": 297,
+          "2018": 670,
+          "2024": 257,
+          "2019": 305,
+          "2020": 304,
+          "2021": 261,
+          "2022": 246,
+          "2023": 314,
+          "2025": 273,
+          "2026": 137
+        },
+        "years_active_list": [
+          2017,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 12,
+        "epss_high_count": 0,
+        "epss_elevated_count": 4,
+        "top_cwes": [],
+        "rank": 22
+      },
+      {
+        "name": "mozilla",
+        "assigner_org_id": "f16b083a-5664-49f3-a51e-8d479e5ed7fe",
+        "count": 2704,
+        "years_active": 14,
+        "first_cve_year": 2013,
+        "last_cve_year": 2026,
+        "first_cve_date": "2013-01-13T20:00:00.000Z",
+        "last_cve_date": "2026-09-15T19:42:53.494Z",
+        "days_since_last_cve": 8,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2013": 158,
+          "2020": 173,
+          "2014": 117,
+          "2019": 144,
+          "2015": 185,
+          "2016": 134,
+          "2018": 350,
+          "2017": 2,
+          "2023": 194,
+          "2021": 148,
+          "2022": 176,
+          "2024": 202,
+          "2025": 208,
+          "2026": 513
+        },
+        "years_active_list": [
+          2013,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 12,
+        "epss_high_count": 13,
+        "epss_elevated_count": 57,
+        "top_cwes": [],
+        "rank": 23
+      },
+      {
+        "name": "apache",
+        "assigner_org_id": "f0158376-9dc2-43b6-827c-5f631a4d8d09",
+        "count": 2594,
+        "years_active": 11,
+        "first_cve_year": 2016,
+        "last_cve_year": 2026,
+        "first_cve_date": "2016-12-05T19:00:00.000Z",
+        "last_cve_date": "2026-09-23T12:31:53.210Z",
+        "days_since_last_cve": 0,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Open Source"
+        ],
+        "cves_by_year": {
+          "2023": 259,
+          "2017": 160,
+          "2018": 166,
+          "2016": 1,
+          "2026": 837,
+          "2019": 137,
+          "2020": 148,
+          "2021": 185,
+          "2022": 222,
+          "2024": 261,
+          "2025": 218
+        },
+        "years_active_list": [
+          2016,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 35,
+        "epss_high_count": 182,
+        "epss_elevated_count": 337,
+        "top_cwes": [],
+        "rank": 24
+      },
+      {
+        "name": "talos",
+        "assigner_org_id": "b86d76f8-0f8a-4a96-a78d-d8abfc7fc29b",
+        "count": 2418,
+        "years_active": 11,
+        "first_cve_year": 2016,
+        "last_cve_year": 2026,
+        "first_cve_date": "2016-10-28T14:00:00.000Z",
+        "last_cve_date": "2026-06-25T21:46:00.057Z",
+        "days_since_last_cve": 90,
+        "activity_status": "Active",
+        "is_official": true,
+        "cna_types": [
+          "Vendor"
+        ],
+        "cves_by_year": {
+          "2018": 335,
+          "2016": 14,
+          "2017": 133,
+          "2023": 347,
+          "2019": 187,
+          "2020": 198,
+          "2021": 272,
+          "2022": 408,
+          "2024": 259,
+          "2025": 200,
+          "2026": 65
+        },
+        "years_active_list": [
+          2016,
+          2026
+        ],
+        "severity_distribution": {},
+        "top_cwe_types": {},
+        "kev_count": 2,
+        "epss_high_count": 28,
+        "epss_elevated_count": 140,
+        "top_cwes": [],
+        "rank": 25
+      }
+    ],
+    "total_cnas": 471,
+    "active_cnas": 393
+  },
+  "cpe_analysis": {
+    "top_cpes": [
+      {
+        "cpe": "cpe:2.3:o:linux:linux_kernel:*:*:*:*:*:*:*:*",
+        "count": 51997,
+        "vendor": "linux",
+        "product": "linux_kernel",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:a:google:chrome:*:*:*:*:*:*:*:*",
+        "count": 6706,
+        "vendor": "google",
+        "product": "chrome",
+        "type": "Application"
+      },
+      {
+        "cpe": "cpe:2.3:o:apple:macos:*:*:*:*:*:*:*:*",
+        "count": 5178,
+        "vendor": "apple",
+        "product": "macos",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:apple:iphone_os:*:*:*:*:*:*:*:*",
+        "count": 4593,
+        "vendor": "apple",
+        "product": "iphone_os",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:microsoft:windows_server_2012:r2:*:*:*:*:*:*:*",
+        "count": 4320,
+        "vendor": "microsoft",
+        "product": "windows_server_2012",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:microsoft:windows_server_2012:-:*:*:*:*:*:*:*",
+        "count": 4109,
+        "vendor": "microsoft",
+        "product": "windows_server_2012",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:debian:debian_linux:9.0:*:*:*:*:*:*:*",
+        "count": 3999,
+        "vendor": "debian",
+        "product": "debian_linux",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:debian:debian_linux:8.0:*:*:*:*:*:*:*",
+        "count": 3481,
+        "vendor": "debian",
+        "product": "debian_linux",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:debian:debian_linux:10.0:*:*:*:*:*:*:*",
+        "count": 3437,
+        "vendor": "debian",
+        "product": "debian_linux",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:a:gitlab:gitlab:*:*:*:*:enterprise:*:*:*",
+        "count": 3308,
+        "vendor": "gitlab",
+        "product": "gitlab",
+        "type": "Application"
+      },
+      {
+        "cpe": "cpe:2.3:a:mozilla:firefox:*:*:*:*:*:*:*:*",
+        "count": 2868,
+        "vendor": "mozilla",
+        "product": "firefox",
+        "type": "Application"
+      },
+      {
+        "cpe": "cpe:2.3:a:gitlab:gitlab:*:*:*:*:community:*:*:*",
+        "count": 2809,
+        "vendor": "gitlab",
+        "product": "gitlab",
+        "type": "Application"
+      },
+      {
+        "cpe": "cpe:2.3:o:apple:mac_os_x:*:*:*:*:*:*:*:*",
+        "count": 2726,
+        "vendor": "apple",
+        "product": "mac_os_x",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:microsoft:windows_server_2019:-:*:*:*:*:*:*:*",
+        "count": 2701,
+        "vendor": "microsoft",
+        "product": "windows_server_2019",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:microsoft:windows_server_2016:-:*:*:*:*:*:*:*",
+        "count": 2641,
+        "vendor": "microsoft",
+        "product": "windows_server_2016",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:microsoft:windows_server_2022:*:*:*:*:*:*:*:*",
+        "count": 2609,
+        "vendor": "microsoft",
+        "product": "windows_server_2022",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:apple:ipados:*:*:*:*:*:*:*:*",
+        "count": 2599,
+        "vendor": "apple",
+        "product": "ipados",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:microsoft:windows_server_2019:*:*:*:*:*:*:*:*",
+        "count": 2497,
+        "vendor": "microsoft",
+        "product": "windows_server_2019",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:microsoft:windows_server_2008:r2:sp1:*:*:*:*:x64:*",
+        "count": 2405,
+        "vendor": "microsoft",
+        "product": "windows_server_2008",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:a:adobe:acrobat_dc:*:*:*:*:classic:*:*:*",
+        "count": 2383,
+        "vendor": "adobe",
+        "product": "acrobat_dc",
+        "type": "Application"
+      },
+      {
+        "cpe": "cpe:2.3:a:adobe:acrobat_reader_dc:*:*:*:*:classic:*:*:*",
+        "count": 2380,
+        "vendor": "adobe",
+        "product": "acrobat_reader_dc",
+        "type": "Application"
+      },
+      {
+        "cpe": "cpe:2.3:o:microsoft:windows_server_2016:*:*:*:*:*:*:*:*",
+        "count": 2335,
+        "vendor": "microsoft",
+        "product": "windows_server_2016",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:apple:tvos:*:*:*:*:*:*:*:*",
+        "count": 2150,
+        "vendor": "apple",
+        "product": "tvos",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:microsoft:windows_10_1809:*:*:*:*:*:*:x64:*",
+        "count": 2124,
+        "vendor": "microsoft",
+        "product": "windows_10_1809",
+        "type": "Operating System"
+      },
+      {
+        "cpe": "cpe:2.3:o:microsoft:windows_10_1809:*:*:*:*:*:*:x86:*",
+        "count": 2069,
+        "vendor": "microsoft",
+        "product": "windows_10_1809",
+        "type": "Operating System"
+      }
+    ],
+    "top_products": [
+      {
+        "product": "linux_kernel",
+        "count": 163077
+      },
+      {
+        "product": "ios",
+        "count": 69388
+      },
+      {
+        "product": "junos",
+        "count": 65330
+      },
+      {
+        "product": "android",
+        "count": 59389
+      },
+      {
+        "product": "firefox",
+        "count": 37894
+      },
+      {
+        "product": "chrome",
+        "count": 36944
+      },
+      {
+        "product": "ios_xe",
+        "count": 33003
+      },
+      {
+        "product": "jre",
+        "count": 28704
+      },
+      {
+        "product": "jdk",
+        "count": 24356
+      },
+      {
+        "product": "seamonkey",
+        "count": 22185
+      },
+      {
+        "product": "opera_browser",
+        "count": 20879
+      },
+      {
+        "product": "safari",
+        "count": 19364
+      },
+      {
+        "product": "windows_10",
+        "count": 19340
+      },
+      {
+        "product": "flash_player",
+        "count": 19014
+      },
+      {
+        "product": "mac_os_x",
+        "count": 18211
+      },
+      {
+        "product": "php",
+        "count": 16569
+      },
+      {
+        "product": "debian_linux",
+        "count": 16358
+      },
+      {
+        "product": "itunes",
+        "count": 15472
+      },
+      {
+        "product": "adaptive_security_appliance_software",
+        "count": 14577
+      },
+      {
+        "product": "thunderbird",
+        "count": 14499
+      }
+    ],
+    "top_vendors": [
+      {
+        "vendor": "qualcomm",
+        "count": 208634
+      },
+      {
+        "vendor": "cisco",
+        "count": 191242
+      },
+      {
+        "vendor": "linux",
+        "count": 163315
+      },
+      {
+        "vendor": "microsoft",
+        "count": 155980
+      },
+      {
+        "vendor": "adobe",
+        "count": 96816
+      },
+      {
+        "vendor": "apple",
+        "count": 94702
+      },
+      {
+        "vendor": "mozilla",
+        "count": 85896
+      },
+      {
+        "vendor": "juniper",
+        "count": 75739
+      },
+      {
+        "vendor": "ibm",
+        "count": 73998
+      },
+      {
+        "vendor": "oracle",
+        "count": 71310
+      },
+      {
+        "vendor": "google",
+        "count": 64919
+      },
+      {
+        "vendor": "intel",
+        "count": 58771
+      },
+      {
+        "vendor": "sun",
+        "count": 56588
+      },
+      {
+        "vendor": "samsung",
+        "count": 39347
+      },
+      {
+        "vendor": "f5",
+        "count": 38132
+      },
+      {
+        "vendor": "redhat",
+        "count": 34321
+      },
+      {
+        "vendor": "hp",
+        "count": 32916
+      },
+      {
+        "vendor": "dell",
+        "count": 30795
+      },
+      {
+        "vendor": "apache",
+        "count": 21854
+      },
+      {
+        "vendor": "opera",
+        "count": 21541
+      }
+    ],
+    "total_cpe_entries": 2608086,
+    "total_cves_with_cpes": 317118
+  },
+  "calendar_analysis_current_year": {
+    "daily_data": [
+      {
+        "date": "2026-01-01",
+        "value": 35,
+        "avg_cvss": 6.2,
+        "cvss_count": 35
+      },
+      {
+        "date": "2026-01-02",
+        "value": 105,
+        "avg_cvss": 6.7,
+        "cvss_count": 101
+      },
+      {
+        "date": "2026-01-03",
+        "value": 3,
+        "avg_cvss": 7.1,
+        "cvss_count": 2
+      },
+      {
+        "date": "2026-01-04",
+        "value": 15,
+        "avg_cvss": 6.3,
+        "cvss_count": 15
+      },
+      {
+        "date": "2026-01-05",
+        "value": 144,
+        "avg_cvss": 7.1,
+        "cvss_count": 128
+      },
+      {
+        "date": "2026-01-06",
+        "value": 156,
+        "avg_cvss": 6.8,
+        "cvss_count": 156
+      },
+      {
+        "date": "2026-01-07",
+        "value": 235,
+        "avg_cvss": 6.5,
+        "cvss_count": 221
+      },
+      {
+        "date": "2026-01-08",
+        "value": 212,
+        "avg_cvss": 7.1,
+        "cvss_count": 204
+      },
+      {
+        "date": "2026-01-09",
+        "value": 129,
+        "avg_cvss": 6.6,
+        "cvss_count": 120
+      },
+      {
+        "date": "2026-01-10",
+        "value": 74,
+        "avg_cvss": 6.5,
+        "cvss_count": 74
+      },
+      {
+        "date": "2026-01-11",
+        "value": 12,
+        "avg_cvss": 7.0,
+        "cvss_count": 12
+      },
+      {
+        "date": "2026-01-12",
+        "value": 87,
+        "avg_cvss": 7.6,
+        "cvss_count": 78
+      },
+      {
+        "date": "2026-01-13",
+        "value": 443,
+        "avg_cvss": 7.4,
+        "cvss_count": 405
+      },
+      {
+        "date": "2026-01-14",
+        "value": 181,
+        "avg_cvss": 6.5,
+        "cvss_count": 172
+      },
+      {
+        "date": "2026-01-15",
+        "value": 151,
+        "avg_cvss": 6.9,
+        "cvss_count": 149
+      },
+      {
+        "date": "2026-01-16",
+        "value": 187,
+        "avg_cvss": 7.1,
+        "cvss_count": 182
+      },
+      {
+        "date": "2026-01-17",
+        "value": 38,
+        "avg_cvss": 5.6,
+        "cvss_count": 38
+      },
+      {
+        "date": "2026-01-18",
+        "value": 28,
+        "avg_cvss": 6.2,
+        "cvss_count": 28
+      },
+      {
+        "date": "2026-01-19",
+        "value": 111,
+        "avg_cvss": 6.7,
+        "cvss_count": 110
+      },
+      {
+        "date": "2026-01-20",
+        "value": 237,
+        "avg_cvss": 6.5,
+        "cvss_count": 221
+      },
+      {
+        "date": "2026-01-21",
+        "value": 118,
+        "avg_cvss": 7.1,
+        "cvss_count": 115
+      },
+      {
+        "date": "2026-01-22",
+        "value": 443,
+        "avg_cvss": 7.0,
+        "cvss_count": 431
+      },
+      {
+        "date": "2026-01-23",
+        "value": 253,
+        "avg_cvss": 6.8,
+        "cvss_count": 252
+      },
+      {
+        "date": "2026-01-24",
+        "value": 70,
+        "avg_cvss": 6.1,
+        "cvss_count": 69
+      },
+      {
+        "date": "2026-01-25",
+        "value": 31,
+        "avg_cvss": 6.3,
+        "cvss_count": 31
+      },
+      {
+        "date": "2026-01-26",
+        "value": 115,
+        "avg_cvss": 6.3,
+        "cvss_count": 91
+      },
+      {
+        "date": "2026-01-27",
+        "value": 189,
+        "avg_cvss": 7.3,
+        "cvss_count": 149
+      },
+      {
+        "date": "2026-01-28",
+        "value": 211,
+        "avg_cvss": 6.8,
+        "cvss_count": 205
+      },
+      {
+        "date": "2026-01-29",
+        "value": 123,
+        "avg_cvss": 7.0,
+        "cvss_count": 119
+      },
+      {
+        "date": "2026-01-30",
+        "value": 122,
+        "avg_cvss": 7.1,
+        "cvss_count": 110
+      },
+      {
+        "date": "2026-01-31",
+        "value": 44,
+        "avg_cvss": 5.7,
+        "cvss_count": 31
+      },
+      {
+        "date": "2026-02-01",
+        "value": 34,
+        "avg_cvss": 6.9,
+        "cvss_count": 33
+      },
+      {
+        "date": "2026-02-02",
+        "value": 146,
+        "avg_cvss": 6.9,
+        "cvss_count": 132
+      },
+      {
+        "date": "2026-02-03",
+        "value": 346,
+        "avg_cvss": 6.7,
+        "cvss_count": 319
+      },
+      {
+        "date": "2026-02-04",
+        "value": 237,
+        "avg_cvss": 6.6,
+        "cvss_count": 203
+      },
+      {
+        "date": "2026-02-05",
+        "value": 132,
+        "avg_cvss": 6.7,
+        "cvss_count": 127
+      },
+      {
+        "date": "2026-02-06",
+        "value": 172,
+        "avg_cvss": 6.7,
+        "cvss_count": 171
+      },
+      {
+        "date": "2026-02-07",
+        "value": 83,
+        "avg_cvss": 6.7,
+        "cvss_count": 83
+      },
+      {
+        "date": "2026-02-08",
+        "value": 75,
+        "avg_cvss": 6.7,
+        "cvss_count": 75
+      },
+      {
+        "date": "2026-02-09",
+        "value": 163,
+        "avg_cvss": 7.0,
+        "cvss_count": 156
+      },
+      {
+        "date": "2026-02-10",
+        "value": 285,
+        "avg_cvss": 6.7,
+        "cvss_count": 261
+      },
+      {
+        "date": "2026-02-11",
+        "value": 325,
+        "avg_cvss": 6.7,
+        "cvss_count": 314
+      },
+      {
+        "date": "2026-02-12",
+        "value": 123,
+        "avg_cvss": 7.6,
+        "cvss_count": 114
+      },
+      {
+        "date": "2026-02-13",
+        "value": 63,
+        "avg_cvss": 7.5,
+        "cvss_count": 57
+      },
+      {
+        "date": "2026-02-14",
+        "value": 163,
+        "avg_cvss": 6.1,
+        "cvss_count": 155
+      },
+      {
+        "date": "2026-02-15",
+        "value": 30,
+        "avg_cvss": 7.1,
+        "cvss_count": 27
+      },
+      {
+        "date": "2026-02-16",
+        "value": 88,
+        "avg_cvss": 6.3,
+        "cvss_count": 88
+      },
+      {
+        "date": "2026-02-17",
+        "value": 96,
+        "avg_cvss": 6.7,
+        "cvss_count": 93
+      },
+      {
+        "date": "2026-02-18",
+        "value": 237,
+        "avg_cvss": 6.4,
+        "cvss_count": 230
+      },
+      {
+        "date": "2026-02-19",
+        "value": 374,
+        "avg_cvss": 6.2,
+        "cvss_count": 363
+      },
+      {
+        "date": "2026-02-20",
+        "value": 385,
+        "avg_cvss": 7.4,
+        "cvss_count": 376
+      },
+      {
+        "date": "2026-02-21",
+        "value": 73,
+        "avg_cvss": 6.9,
+        "cvss_count": 73
+      },
+      {
+        "date": "2026-02-22",
+        "value": 57,
+        "avg_cvss": 6.9,
+        "cvss_count": 57
+      },
+      {
+        "date": "2026-02-23",
+        "value": 93,
+        "avg_cvss": 6.6,
+        "cvss_count": 88
+      },
+      {
+        "date": "2026-02-24",
+        "value": 228,
+        "avg_cvss": 7.5,
+        "cvss_count": 227
+      },
+      {
+        "date": "2026-02-25",
+        "value": 222,
+        "avg_cvss": 7.0,
+        "cvss_count": 216
+      },
+      {
+        "date": "2026-02-26",
+        "value": 168,
+        "avg_cvss": 6.5,
+        "cvss_count": 163
+      },
+      {
+        "date": "2026-02-27",
+        "value": 203,
+        "avg_cvss": 7.2,
+        "cvss_count": 199
+      },
+      {
+        "date": "2026-02-28",
+        "value": 15,
+        "avg_cvss": 6.4,
+        "cvss_count": 15
+      },
+      {
+        "date": "2026-03-01",
+        "value": 20,
+        "avg_cvss": 5.2,
+        "cvss_count": 20
+      },
+      {
+        "date": "2026-03-02",
+        "value": 219,
+        "avg_cvss": 7.4,
+        "cvss_count": 213
+      },
+      {
+        "date": "2026-03-03",
+        "value": 137,
+        "avg_cvss": 7.0,
+        "cvss_count": 135
+      },
+      {
+        "date": "2026-03-04",
+        "value": 200,
+        "avg_cvss": 7.0,
+        "cvss_count": 198
+      },
+      {
+        "date": "2026-03-05",
+        "value": 463,
+        "avg_cvss": 7.8,
+        "cvss_count": 461
+      },
+      {
+        "date": "2026-03-06",
+        "value": 209,
+        "avg_cvss": 7.1,
+        "cvss_count": 207
+      },
+      {
+        "date": "2026-03-07",
+        "value": 110,
+        "avg_cvss": 6.2,
+        "cvss_count": 110
+      },
+      {
+        "date": "2026-03-08",
+        "value": 81,
+        "avg_cvss": 6.5,
+        "cvss_count": 81
+      },
+      {
+        "date": "2026-03-09",
+        "value": 114,
+        "avg_cvss": 7.3,
+        "cvss_count": 113
+      },
+      {
+        "date": "2026-03-10",
+        "value": 387,
+        "avg_cvss": 7.0,
+        "cvss_count": 372
+      },
+      {
+        "date": "2026-03-11",
+        "value": 336,
+        "avg_cvss": 6.7,
+        "cvss_count": 333
+      },
+      {
+        "date": "2026-03-12",
+        "value": 178,
+        "avg_cvss": 7.3,
+        "cvss_count": 173
+      },
+      {
+        "date": "2026-03-13",
+        "value": 247,
+        "avg_cvss": 6.2,
+        "cvss_count": 247
+      },
+      {
+        "date": "2026-03-16",
+        "value": 325,
+        "avg_cvss": 6.4,
+        "cvss_count": 314
+      },
+      {
+        "date": "2026-03-17",
+        "value": 103,
+        "avg_cvss": 6.5,
+        "cvss_count": 100
+      },
+      {
+        "date": "2026-03-18",
+        "value": 201,
+        "avg_cvss": 7.0,
+        "cvss_count": 193
+      },
+      {
+        "date": "2026-03-19",
+        "value": 230,
+        "avg_cvss": 6.9,
+        "cvss_count": 229
+      },
+      {
+        "date": "2026-03-20",
+        "value": 299,
+        "avg_cvss": 7.2,
+        "cvss_count": 299
+      },
+      {
+        "date": "2026-03-21",
+        "value": 182,
+        "avg_cvss": 6.1,
+        "cvss_count": 182
+      },
+      {
+        "date": "2026-03-22",
+        "value": 77,
+        "avg_cvss": 6.4,
+        "cvss_count": 77
+      },
+      {
+        "date": "2026-03-23",
+        "value": 181,
+        "avg_cvss": 6.8,
+        "cvss_count": 173
+      },
+      {
+        "date": "2026-03-24",
+        "value": 274,
+        "avg_cvss": 7.5,
+        "cvss_count": 256
+      },
+      {
+        "date": "2026-03-25",
+        "value": 606,
+        "avg_cvss": 6.9,
+        "cvss_count": 604
+      },
+      {
+        "date": "2026-03-26",
+        "value": 297,
+        "avg_cvss": 6.5,
+        "cvss_count": 295
+      },
+      {
+        "date": "2026-03-27",
+        "value": 246,
+        "avg_cvss": 7.1,
+        "cvss_count": 240
+      },
+      {
+        "date": "2026-03-28",
+        "value": 56,
+        "avg_cvss": 7.5,
+        "cvss_count": 56
+      },
+      {
+        "date": "2026-03-29",
+        "value": 47,
+        "avg_cvss": 7.8,
+        "cvss_count": 47
+      },
+      {
+        "date": "2026-03-30",
+        "value": 139,
+        "avg_cvss": 6.8,
+        "cvss_count": 134
+      },
+      {
+        "date": "2026-03-31",
+        "value": 270,
+        "avg_cvss": 6.8,
+        "cvss_count": 267
+      },
+      {
+        "date": "2026-04-01",
+        "value": 235,
+        "avg_cvss": 7.0,
+        "cvss_count": 234
+      },
+      {
+        "date": "2026-04-02",
+        "value": 254,
+        "avg_cvss": 6.8,
+        "cvss_count": 251
+      },
+      {
+        "date": "2026-04-03",
+        "value": 215,
+        "avg_cvss": 6.9,
+        "cvss_count": 215
+      },
+      {
+        "date": "2026-04-04",
+        "value": 69,
+        "avg_cvss": 6.8,
+        "cvss_count": 69
+      },
+      {
+        "date": "2026-04-05",
+        "value": 111,
+        "avg_cvss": 6.8,
+        "cvss_count": 110
+      },
+      {
+        "date": "2026-04-06",
+        "value": 253,
+        "avg_cvss": 6.9,
+        "cvss_count": 253
+      },
+      {
+        "date": "2026-04-07",
+        "value": 271,
+        "avg_cvss": 7.2,
+        "cvss_count": 256
+      },
+      {
+        "date": "2026-04-08",
+        "value": 487,
+        "avg_cvss": 6.4,
+        "cvss_count": 484
+      },
+      {
+        "date": "2026-04-09",
+        "value": 271,
+        "avg_cvss": 7.1,
+        "cvss_count": 270
+      },
+      {
+        "date": "2026-04-10",
+        "value": 220,
+        "avg_cvss": 6.9,
+        "cvss_count": 215
+      },
+      {
+        "date": "2026-04-11",
+        "value": 39,
+        "avg_cvss": 7.2,
+        "cvss_count": 39
+      },
+      {
+        "date": "2026-04-12",
+        "value": 54,
+        "avg_cvss": 7.3,
+        "cvss_count": 54
+      },
+      {
+        "date": "2026-04-13",
+        "value": 220,
+        "avg_cvss": 6.5,
+        "cvss_count": 215
+      },
+      {
+        "date": "2026-04-14",
+        "value": 395,
+        "avg_cvss": 6.8,
+        "cvss_count": 387
+      },
+      {
+        "date": "2026-04-15",
+        "value": 200,
+        "avg_cvss": 6.9,
+        "cvss_count": 195
+      },
+      {
+        "date": "2026-04-16",
+        "value": 130,
+        "avg_cvss": 7.1,
+        "cvss_count": 123
+      },
+      {
+        "date": "2026-04-17",
+        "value": 151,
+        "avg_cvss": 6.9,
+        "cvss_count": 146
+      },
+      {
+        "date": "2026-04-18",
+        "value": 53,
+        "avg_cvss": 6.8,
+        "cvss_count": 49
+      },
+      {
+        "date": "2026-04-19",
+        "value": 22,
+        "avg_cvss": 6.5,
+        "cvss_count": 22
+      },
+      {
+        "date": "2026-04-20",
+        "value": 164,
+        "avg_cvss": 6.6,
+        "cvss_count": 162
+      },
+      {
+        "date": "2026-04-21",
+        "value": 354,
+        "avg_cvss": 6.7,
+        "cvss_count": 332
+      },
+      {
+        "date": "2026-04-22",
+        "value": 338,
+        "avg_cvss": 6.3,
+        "cvss_count": 326
+      },
+      {
+        "date": "2026-04-23",
+        "value": 187,
+        "avg_cvss": 7.2,
+        "cvss_count": 181
+      },
+      {
+        "date": "2026-04-24",
+        "value": 285,
+        "avg_cvss": 6.9,
+        "cvss_count": 281
+      },
+      {
+        "date": "2026-04-25",
+        "value": 40,
+        "avg_cvss": 5.9,
+        "cvss_count": 40
+      },
+      {
+        "date": "2026-04-26",
+        "value": 76,
+        "avg_cvss": 6.3,
+        "cvss_count": 76
+      },
+      {
+        "date": "2026-04-27",
+        "value": 177,
+        "avg_cvss": 7.2,
+        "cvss_count": 169
+      },
+      {
+        "date": "2026-04-28",
+        "value": 245,
+        "avg_cvss": 6.9,
+        "cvss_count": 241
+      },
+      {
+        "date": "2026-04-29",
+        "value": 133,
+        "avg_cvss": 6.9,
+        "cvss_count": 125
+      },
+      {
+        "date": "2026-04-30",
+        "value": 161,
+        "avg_cvss": 6.6,
+        "cvss_count": 161
+      },
+      {
+        "date": "2026-05-01",
+        "value": 263,
+        "avg_cvss": 6.9,
+        "cvss_count": 257
+      },
+      {
+        "date": "2026-05-02",
+        "value": 73,
+        "avg_cvss": 6.5,
+        "cvss_count": 73
+      },
+      {
+        "date": "2026-05-03",
+        "value": 41,
+        "avg_cvss": 6.0,
+        "cvss_count": 41
+      },
+      {
+        "date": "2026-05-04",
+        "value": 189,
+        "avg_cvss": 7.2,
+        "cvss_count": 177
+      },
+      {
+        "date": "2026-05-05",
+        "value": 193,
+        "avg_cvss": 7.2,
+        "cvss_count": 185
+      },
+      {
+        "date": "2026-05-06",
+        "value": 482,
+        "avg_cvss": 6.5,
+        "cvss_count": 474
+      },
+      {
+        "date": "2026-05-07",
+        "value": 201,
+        "avg_cvss": 7.1,
+        "cvss_count": 192
+      },
+      {
+        "date": "2026-05-08",
+        "value": 424,
+        "avg_cvss": 6.8,
+        "cvss_count": 394
+      },
+      {
+        "date": "2026-05-09",
+        "value": 70,
+        "avg_cvss": 6.5,
+        "cvss_count": 64
+      },
+      {
+        "date": "2026-05-10",
+        "value": 101,
+        "avg_cvss": 6.4,
+        "cvss_count": 101
+      },
+      {
+        "date": "2026-05-11",
+        "value": 354,
+        "avg_cvss": 6.5,
+        "cvss_count": 336
+      },
+      {
+        "date": "2026-05-12",
+        "value": 554,
+        "avg_cvss": 7.2,
+        "cvss_count": 518
+      },
+      {
+        "date": "2026-05-13",
+        "value": 346,
+        "avg_cvss": 6.9,
+        "cvss_count": 325
+      },
+      {
+        "date": "2026-05-14",
+        "value": 305,
+        "avg_cvss": 6.7,
+        "cvss_count": 273
+      },
+      {
+        "date": "2026-05-15",
+        "value": 211,
+        "avg_cvss": 6.7,
+        "cvss_count": 160
+      },
+      {
+        "date": "2026-05-16",
+        "value": 47,
+        "avg_cvss": 7.3,
+        "cvss_count": 47
+      },
+      {
+        "date": "2026-05-17",
+        "value": 62,
+        "avg_cvss": 6.5,
+        "cvss_count": 62
+      },
+      {
+        "date": "2026-05-18",
+        "value": 103,
+        "avg_cvss": 6.4,
+        "cvss_count": 99
+      },
+      {
+        "date": "2026-05-19",
+        "value": 201,
+        "avg_cvss": 7.1,
+        "cvss_count": 182
+      },
+      {
+        "date": "2026-05-20",
+        "value": 206,
+        "avg_cvss": 6.6,
+        "cvss_count": 192
+      },
+      {
+        "date": "2026-05-21",
+        "value": 189,
+        "avg_cvss": 6.7,
+        "cvss_count": 188
+      },
+      {
+        "date": "2026-05-22",
+        "value": 152,
+        "avg_cvss": 6.8,
+        "cvss_count": 137
+      },
+      {
+        "date": "2026-05-23",
+        "value": 41,
+        "avg_cvss": 7.3,
+        "cvss_count": 41
+      },
+      {
+        "date": "2026-05-24",
+        "value": 62,
+        "avg_cvss": 6.9,
+        "cvss_count": 61
+      },
+      {
+        "date": "2026-05-25",
+        "value": 188,
+        "avg_cvss": 6.8,
+        "cvss_count": 181
+      },
+      {
+        "date": "2026-05-26",
+        "value": 274,
+        "avg_cvss": 6.7,
+        "cvss_count": 256
+      },
+      {
+        "date": "2026-05-27",
+        "value": 716,
+        "avg_cvss": 6.6,
+        "cvss_count": 701
+      },
+      {
+        "date": "2026-05-28",
+        "value": 543,
+        "avg_cvss": 7.1,
+        "cvss_count": 504
+      },
+      {
+        "date": "2026-05-29",
+        "value": 249,
+        "avg_cvss": 7.1,
+        "cvss_count": 232
+      },
+      {
+        "date": "2026-05-30",
+        "value": 48,
+        "avg_cvss": 7.3,
+        "cvss_count": 48
+      },
+      {
+        "date": "2026-05-31",
+        "value": 50,
+        "avg_cvss": 6.9,
+        "cvss_count": 50
+      },
+      {
+        "date": "2026-06-01",
+        "value": 376,
+        "avg_cvss": 6.6,
+        "cvss_count": 361
+      },
+      {
+        "date": "2026-06-02",
+        "value": 224,
+        "avg_cvss": 6.7,
+        "cvss_count": 200
+      },
+      {
+        "date": "2026-06-03",
+        "value": 154,
+        "avg_cvss": 6.7,
+        "cvss_count": 137
+      },
+      {
+        "date": "2026-06-04",
+        "value": 553,
+        "avg_cvss": 7.4,
+        "cvss_count": 541
+      },
+      {
+        "date": "2026-06-05",
+        "value": 229,
+        "avg_cvss": 6.7,
+        "cvss_count": 207
+      },
+      {
+        "date": "2026-06-06",
+        "value": 54,
+        "avg_cvss": 5.7,
+        "cvss_count": 49
+      },
+      {
+        "date": "2026-06-07",
+        "value": 20,
+        "avg_cvss": 6.0,
+        "cvss_count": 20
+      },
+      {
+        "date": "2026-06-08",
+        "value": 215,
+        "avg_cvss": 6.8,
+        "cvss_count": 206
+      },
+      {
+        "date": "2026-06-09",
+        "value": 747,
+        "avg_cvss": 6.9,
+        "cvss_count": 722
+      },
+      {
+        "date": "2026-06-10",
+        "value": 296,
+        "avg_cvss": 6.7,
+        "cvss_count": 273
+      },
+      {
+        "date": "2026-06-11",
+        "value": 193,
+        "avg_cvss": 7.1,
+        "cvss_count": 171
+      },
+      {
+        "date": "2026-06-12",
+        "value": 279,
+        "avg_cvss": 7.1,
+        "cvss_count": 227
+      },
+      {
+        "date": "2026-06-13",
+        "value": 23,
+        "avg_cvss": 6.3,
+        "cvss_count": 22
+      },
+      {
+        "date": "2026-06-14",
+        "value": 16,
+        "avg_cvss": 7.3,
+        "cvss_count": 16
+      },
+      {
+        "date": "2026-06-15",
+        "value": 395,
+        "avg_cvss": 7.5,
+        "cvss_count": 371
+      },
+      {
+        "date": "2026-06-16",
+        "value": 214,
+        "avg_cvss": 7.0,
+        "cvss_count": 198
+      },
+      {
+        "date": "2026-06-17",
+        "value": 732,
+        "avg_cvss": 8.0,
+        "cvss_count": 709
+      },
+      {
+        "date": "2026-06-18",
+        "value": 143,
+        "avg_cvss": 7.1,
+        "cvss_count": 117
+      },
+      {
+        "date": "2026-06-19",
+        "value": 203,
+        "avg_cvss": 7.5,
+        "cvss_count": 184
+      },
+      {
+        "date": "2026-06-20",
+        "value": 45,
+        "avg_cvss": 6.7,
+        "cvss_count": 41
+      },
+      {
+        "date": "2026-06-21",
+        "value": 68,
+        "avg_cvss": 6.5,
+        "cvss_count": 67
+      },
+      {
+        "date": "2026-06-22",
+        "value": 221,
+        "avg_cvss": 6.7,
+        "cvss_count": 194
+      },
+      {
+        "date": "2026-06-23",
+        "value": 255,
+        "avg_cvss": 6.8,
+        "cvss_count": 220
+      },
+      {
+        "date": "2026-06-24",
+        "value": 509,
+        "avg_cvss": 6.9,
+        "cvss_count": 464
+      },
+      {
+        "date": "2026-06-25",
+        "value": 472,
+        "avg_cvss": 7.0,
+        "cvss_count": 444
+      },
+      {
+        "date": "2026-06-26",
+        "value": 362,
+        "avg_cvss": 6.9,
+        "cvss_count": 351
+      },
+      {
+        "date": "2026-06-27",
+        "value": 31,
+        "avg_cvss": 6.1,
+        "cvss_count": 31
+      },
+      {
+        "date": "2026-06-28",
+        "value": 42,
+        "avg_cvss": 5.8,
+        "cvss_count": 42
+      },
+      {
+        "date": "2026-06-29",
+        "value": 239,
+        "avg_cvss": 6.7,
+        "cvss_count": 229
+      },
+      {
+        "date": "2026-06-30",
+        "value": 632,
+        "avg_cvss": 6.8,
+        "cvss_count": 609
+      },
+      {
+        "date": "2026-07-01",
+        "value": 370,
+        "avg_cvss": 7.0,
+        "cvss_count": 345
+      },
+      {
+        "date": "2026-07-02",
+        "value": 250,
+        "avg_cvss": 7.3,
+        "cvss_count": 238
+      },
+      {
+        "date": "2026-07-03",
+        "value": 200,
+        "avg_cvss": 7.0,
+        "cvss_count": 194
+      },
+      {
+        "date": "2026-07-04",
+        "value": 70,
+        "avg_cvss": 6.6,
+        "cvss_count": 67
+      },
+      {
+        "date": "2026-07-05",
+        "value": 86,
+        "avg_cvss": 6.2,
+        "cvss_count": 84
+      },
+      {
+        "date": "2026-07-06",
+        "value": 195,
+        "avg_cvss": 7.0,
+        "cvss_count": 173
+      },
+      {
+        "date": "2026-07-07",
+        "value": 167,
+        "avg_cvss": 6.9,
+        "cvss_count": 142
+      },
+      {
+        "date": "2026-07-08",
+        "value": 362,
+        "avg_cvss": 6.8,
+        "cvss_count": 350
+      },
+      {
+        "date": "2026-07-09",
+        "value": 270,
+        "avg_cvss": 6.6,
+        "cvss_count": 245
+      },
+      {
+        "date": "2026-07-10",
+        "value": 358,
+        "avg_cvss": 6.7,
+        "cvss_count": 297
+      },
+      {
+        "date": "2026-07-11",
+        "value": 78,
+        "avg_cvss": 6.2,
+        "cvss_count": 77
+      },
+      {
+        "date": "2026-07-12",
+        "value": 61,
+        "avg_cvss": 6.6,
+        "cvss_count": 61
+      },
+      {
+        "date": "2026-07-13",
+        "value": 338,
+        "avg_cvss": 7.1,
+        "cvss_count": 315
+      },
+      {
+        "date": "2026-07-14",
+        "value": 1008,
+        "avg_cvss": 7.2,
+        "cvss_count": 973
+      },
+      {
+        "date": "2026-07-15",
+        "value": 266,
+        "avg_cvss": 6.8,
+        "cvss_count": 218
+      },
+      {
+        "date": "2026-07-16",
+        "value": 242,
+        "avg_cvss": 6.7,
+        "cvss_count": 202
+      },
+      {
+        "date": "2026-07-17",
+        "value": 296,
+        "avg_cvss": 6.8,
+        "cvss_count": 269
+      },
+      {
+        "date": "2026-07-18",
+        "value": 80,
+        "avg_cvss": 6.7,
+        "cvss_count": 80
+      },
+      {
+        "date": "2026-07-19",
+        "value": 462,
+        "avg_cvss": 7.5,
+        "cvss_count": 374
+      },
+      {
+        "date": "2026-07-20",
+        "value": 265,
+        "avg_cvss": 7.0,
+        "cvss_count": 230
+      },
+      {
+        "date": "2026-07-21",
+        "value": 1474,
+        "avg_cvss": 7.4,
+        "cvss_count": 1456
+      },
+      {
+        "date": "2026-07-22",
+        "value": 201,
+        "avg_cvss": 7.1,
+        "cvss_count": 193
+      },
+      {
+        "date": "2026-07-23",
+        "value": 374,
+        "avg_cvss": 7.0,
+        "cvss_count": 356
+      },
+      {
+        "date": "2026-07-24",
+        "value": 196,
+        "avg_cvss": 7.1,
+        "cvss_count": 173
+      },
+      {
+        "date": "2026-07-25",
+        "value": 284,
+        "avg_cvss": 7.3,
+        "cvss_count": 229
+      },
+      {
+        "date": "2026-07-26",
+        "value": 15,
+        "avg_cvss": 6.8,
+        "cvss_count": 15
+      },
+      {
+        "date": "2026-07-27",
+        "value": 440,
+        "avg_cvss": 7.3,
+        "cvss_count": 398
+      },
+      {
+        "date": "2026-07-28",
+        "value": 241,
+        "avg_cvss": 7.0,
+        "cvss_count": 212
+      },
+      {
+        "date": "2026-07-29",
+        "value": 274,
+        "avg_cvss": 7.2,
+        "cvss_count": 242
+      },
+      {
+        "date": "2026-07-30",
+        "value": 664,
+        "avg_cvss": 6.8,
+        "cvss_count": 646
+      },
+      {
+        "date": "2026-07-31",
+        "value": 183,
+        "avg_cvss": 6.7,
+        "cvss_count": 164
+      },
+      {
+        "date": "2026-08-01",
+        "value": 145,
+        "avg_cvss": 6.6,
+        "cvss_count": 142
+      },
+      {
+        "date": "2026-08-02",
+        "value": 52,
+        "avg_cvss": 6.7,
+        "cvss_count": 52
+      },
+      {
+        "date": "2026-08-03",
+        "value": 293,
+        "avg_cvss": 7.0,
+        "cvss_count": 267
+      },
+      {
+        "date": "2026-08-04",
+        "value": 283,
+        "avg_cvss": 7.1,
+        "cvss_count": 254
+      },
+      {
+        "date": "2026-08-05",
+        "value": 423,
+        "avg_cvss": 7.2,
+        "cvss_count": 402
+      },
+      {
+        "date": "2026-08-06",
+        "value": 477,
+        "avg_cvss": 7.1,
+        "cvss_count": 441
+      },
+      {
+        "date": "2026-08-07",
+        "value": 231,
+        "avg_cvss": 6.9,
+        "cvss_count": 176
+      },
+      {
+        "date": "2026-08-08",
+        "value": 54,
+        "avg_cvss": 7.4,
+        "cvss_count": 50
+      },
+      {
+        "date": "2026-08-09",
+        "value": 84,
+        "avg_cvss": 6.4,
+        "cvss_count": 83
+      },
+      {
+        "date": "2026-08-10",
+        "value": 674,
+        "avg_cvss": 7.5,
+        "cvss_count": 429
+      },
+      {
+        "date": "2026-08-11",
+        "value": 931,
+        "avg_cvss": 7.2,
+        "cvss_count": 837
+      },
+      {
+        "date": "2026-08-12",
+        "value": 426,
+        "avg_cvss": 7.0,
+        "cvss_count": 374
+      },
+      {
+        "date": "2026-08-13",
+        "value": 611,
+        "avg_cvss": 7.1,
+        "cvss_count": 574
+      },
+      {
+        "date": "2026-08-14",
+        "value": 204,
+        "avg_cvss": 7.1,
+        "cvss_count": 170
+      },
+      {
+        "date": "2026-08-15",
+        "value": 921,
+        "avg_cvss": 8.2,
+        "cvss_count": 582
+      },
+      {
+        "date": "2026-08-16",
+        "value": 109,
+        "avg_cvss": 6.8,
+        "cvss_count": 107
+      },
+      {
+        "date": "2026-08-17",
+        "value": 337,
+        "avg_cvss": 6.9,
+        "cvss_count": 303
+      },
+      {
+        "date": "2026-08-18",
+        "value": 1406,
+        "avg_cvss": 7.4,
+        "cvss_count": 1355
+      },
+      {
+        "date": "2026-08-19",
+        "value": 672,
+        "avg_cvss": 7.1,
+        "cvss_count": 587
+      },
+      {
+        "date": "2026-08-20",
+        "value": 469,
+        "avg_cvss": 7.3,
+        "cvss_count": 403
+      },
+      {
+        "date": "2026-08-21",
+        "value": 258,
+        "avg_cvss": 7.0,
+        "cvss_count": 196
+      },
+      {
+        "date": "2026-08-22",
+        "value": 236,
+        "avg_cvss": 7.7,
+        "cvss_count": 164
+      },
+      {
+        "date": "2026-08-23",
+        "value": 45,
+        "avg_cvss": 6.7,
+        "cvss_count": 45
+      },
+      {
+        "date": "2026-08-24",
+        "value": 310,
+        "avg_cvss": 7.3,
+        "cvss_count": 267
+      },
+      {
+        "date": "2026-08-25",
+        "value": 750,
+        "avg_cvss": 6.7,
+        "cvss_count": 694
+      },
+      {
+        "date": "2026-08-26",
+        "value": 396,
+        "avg_cvss": 7.4,
+        "cvss_count": 340
+      },
+      {
+        "date": "2026-08-27",
+        "value": 365,
+        "avg_cvss": 6.9,
+        "cvss_count": 319
+      },
+      {
+        "date": "2026-08-28",
+        "value": 582,
+        "avg_cvss": 7.0,
+        "cvss_count": 458
+      },
+      {
+        "date": "2026-08-29",
+        "value": 64,
+        "avg_cvss": 6.9,
+        "cvss_count": 63
+      },
+      {
+        "date": "2026-08-30",
+        "value": 91,
+        "avg_cvss": 6.3,
+        "cvss_count": 69
+      },
+      {
+        "date": "2026-08-31",
+        "value": 360,
+        "avg_cvss": 7.1,
+        "cvss_count": 315
+      },
+      {
+        "date": "2026-09-01",
+        "value": 450,
+        "avg_cvss": 7.2,
+        "cvss_count": 358
+      },
+      {
+        "date": "2026-09-02",
+        "value": 342,
+        "avg_cvss": 6.5,
+        "cvss_count": 324
+      },
+      {
+        "date": "2026-09-03",
+        "value": 349,
+        "avg_cvss": 7.2,
+        "cvss_count": 304
+      },
+      {
+        "date": "2026-09-04",
+        "value": 554,
+        "avg_cvss": 6.9,
+        "cvss_count": 367
+      },
+      {
+        "date": "2026-09-05",
+        "value": 143,
+        "avg_cvss": 6.5,
+        "cvss_count": 129
+      },
+      {
+        "date": "2026-09-06",
+        "value": 90,
+        "avg_cvss": 6.8,
+        "cvss_count": 87
+      },
+      {
+        "date": "2026-09-07",
+        "value": 255,
+        "avg_cvss": 6.4,
+        "cvss_count": 229
+      },
+      {
+        "date": "2026-09-08",
+        "value": 1559,
+        "avg_cvss": 7.2,
+        "cvss_count": 1523
+      },
+      {
+        "date": "2026-09-09",
+        "value": 655,
+        "avg_cvss": 6.4,
+        "cvss_count": 624
+      },
+      {
+        "date": "2026-09-10",
+        "value": 381,
+        "avg_cvss": 7.4,
+        "cvss_count": 343
+      },
+      {
+        "date": "2026-09-11",
+        "value": 708,
+        "avg_cvss": 7.6,
+        "cvss_count": 496
+      },
+      {
+        "date": "2026-09-12",
+        "value": 91,
+        "avg_cvss": 6.6,
+        "cvss_count": 90
+      },
+      {
+        "date": "2026-09-13",
+        "value": 130,
+        "avg_cvss": 5.9,
+        "cvss_count": 129
+      },
+      {
+        "date": "2026-09-14",
+        "value": 782,
+        "avg_cvss": 6.3,
+        "cvss_count": 733
+      },
+      {
+        "date": "2026-09-15",
+        "value": 1422,
+        "avg_cvss": 7.5,
+        "cvss_count": 1319
+      },
+      {
+        "date": "2026-09-16",
+        "value": 878,
+        "avg_cvss": 7.2,
+        "cvss_count": 688
+      },
+      {
+        "date": "2026-09-17",
+        "value": 1019,
+        "avg_cvss": 7.4,
+        "cvss_count": 514
+      },
+      {
+        "date": "2026-09-18",
+        "value": 522,
+        "avg_cvss": 6.8,
+        "cvss_count": 501
+      },
+      {
+        "date": "2026-09-19",
+        "value": 107,
+        "avg_cvss": 6.1,
+        "cvss_count": 105
+      },
+      {
+        "date": "2026-09-20",
+        "value": 102,
+        "avg_cvss": 6.1,
+        "cvss_count": 95
+      },
+      {
+        "date": "2026-09-21",
+        "value": 288,
+        "avg_cvss": 6.6,
+        "cvss_count": 229
+      },
+      {
+        "date": "2026-09-22",
+        "value": 449,
+        "avg_cvss": 7.3,
+        "cvss_count": 365
+      },
+      {
+        "date": "2026-09-23",
+        "value": 450,
+        "avg_cvss": 6.7,
+        "cvss_count": 370
+      }
+    ]
+  }
+}
\ No newline at end of file
diff --git a/web/data/kev_analysis.json b/web/data/kev_analysis.json
new file mode 100644
index 00000000000..bc2fcfeee13
--- /dev/null
+++ b/web/data/kev_analysis.json
@@ -0,0 +1,539 @@
+{
+  "generated_at": "2026-09-23T22:56:24.095937Z",
+  "catalog_version": "2026.09.23",
+  "total_kev_cves": 1721,
+  "statistics": {
+    "added_last_30_days": 47,
+    "added_last_90_days": 94,
+    "ransomware_associated": 361
+  },
+  "by_year_added": {
+    "2021": 311,
+    "2022": 555,
+    "2023": 187,
+    "2024": 186,
+    "2025": 245,
+    "2026": 237
+  },
+  "by_year_cve": {
+    "2002": 1,
+    "2004": 2,
+    "2005": 1,
+    "2006": 2,
+    "2007": 3,
+    "2008": 6,
+    "2009": 15,
+    "2010": 23,
+    "2011": 9,
+    "2012": 22,
+    "2013": 38,
+    "2014": 34,
+    "2015": 46,
+    "2016": 59,
+    "2017": 86,
+    "2018": 89,
+    "2019": 119,
+    "2020": 146,
+    "2021": 215,
+    "2022": 132,
+    "2023": 165,
+    "2024": 164,
+    "2025": 188,
+    "2026": 156
+  },
+  "by_year_published": {
+    "2002": 1,
+    "2004": 2,
+    "2005": 1,
+    "2006": 2,
+    "2007": 2,
+    "2008": 6,
+    "2009": 14,
+    "2010": 23,
+    "2011": 9,
+    "2012": 22,
+    "2013": 35,
+    "2014": 34,
+    "2015": 45,
+    "2016": 53,
+    "2017": 89,
+    "2018": 76,
+    "2019": 129,
+    "2020": 146,
+    "2021": 214,
+    "2022": 131,
+    "2023": 165,
+    "2024": 160,
+    "2025": 197,
+    "2026": 165
+  },
+  "timeline": {
+    "2021-11": 291,
+    "2021-12": 20,
+    "2022-01": 40,
+    "2022-02": 32,
+    "2022-03": 226,
+    "2022-04": 45,
+    "2022-05": 83,
+    "2022-06": 48,
+    "2022-07": 3,
+    "2022-08": 23,
+    "2022-09": 24,
+    "2022-10": 12,
+    "2022-11": 10,
+    "2022-12": 9,
+    "2023-01": 5,
+    "2023-02": 14,
+    "2023-03": 18,
+    "2023-04": 17,
+    "2023-05": 19,
+    "2023-06": 24,
+    "2023-07": 16,
+    "2023-08": 8,
+    "2023-09": 19,
+    "2023-10": 18,
+    "2023-11": 18,
+    "2023-12": 11,
+    "2024-01": 21,
+    "2024-02": 9,
+    "2024-03": 10,
+    "2024-04": 10,
+    "2024-05": 14,
+    "2024-06": 9,
+    "2024-07": 14,
+    "2024-08": 19,
+    "2024-09": 25,
+    "2024-10": 17,
+    "2024-11": 22,
+    "2024-12": 16,
+    "2025-01": 14,
+    "2025-02": 27,
+    "2025-03": 32,
+    "2025-04": 15,
+    "2025-05": 24,
+    "2025-06": 20,
+    "2025-07": 20,
+    "2025-08": 15,
+    "2025-09": 16,
+    "2025-10": 31,
+    "2025-11": 11,
+    "2025-12": 20,
+    "2026-01": 17,
+    "2026-02": 28,
+    "2026-03": 26,
+    "2026-04": 31,
+    "2026-05": 21,
+    "2026-06": 23,
+    "2026-07": 26,
+    "2026-08": 31,
+    "2026-09": 34
+  },
+  "top_vendors": [
+    [
+      "Microsoft",
+      388
+    ],
+    [
+      "Cisco",
+      99
+    ],
+    [
+      "Apple",
+      94
+    ],
+    [
+      "Adobe",
+      81
+    ],
+    [
+      "Google",
+      75
+    ],
+    [
+      "Oracle",
+      46
+    ],
+    [
+      "Apache",
+      40
+    ],
+    [
+      "Ivanti",
+      35
+    ],
+    [
+      "Linux",
+      31
+    ],
+    [
+      "Fortinet",
+      30
+    ],
+    [
+      "D-Link",
+      26
+    ],
+    [
+      "VMware",
+      26
+    ],
+    [
+      "Citrix",
+      24
+    ],
+    [
+      "SonicWall",
+      19
+    ],
+    [
+      "Synacor",
+      19
+    ],
+    [
+      "Android",
+      17
+    ],
+    [
+      "Palo Alto Networks",
+      15
+    ],
+    [
+      "Samsung",
+      15
+    ],
+    [
+      "SAP",
+      14
+    ],
+    [
+      "Zyxel",
+      13
+    ]
+  ],
+  "top_products": [
+    [
+      "Microsoft - Windows",
+      172
+    ],
+    [
+      "Apple - Multiple Products",
+      53
+    ],
+    [
+      "Google - Chromium V8",
+      41
+    ],
+    [
+      "Microsoft - Internet Explorer",
+      36
+    ],
+    [
+      "Adobe - Flash Player",
+      33
+    ],
+    [
+      "Linux - Kernel",
+      31
+    ],
+    [
+      "Microsoft - Office",
+      29
+    ],
+    [
+      "Microsoft - Win32k",
+      25
+    ],
+    [
+      "Microsoft - Exchange Server",
+      17
+    ],
+    [
+      "Synacor - Zimbra Collaboration Suite (ZCS)",
+      16
+    ],
+    [
+      "Adobe - ColdFusion",
+      16
+    ],
+    [
+      "Cisco - IOS and IOS XE Software",
+      14
+    ],
+    [
+      "Adobe - Acrobat and Reader",
+      13
+    ],
+    [
+      "Samsung - Mobile Devices",
+      13
+    ],
+    [
+      "Oracle - WebLogic Server",
+      12
+    ],
+    [
+      "Palo Alto Networks - PAN-OS",
+      12
+    ],
+    [
+      "Apple - iOS, iPadOS, and macOS",
+      11
+    ],
+    [
+      "Qualcomm - Multiple Chipsets",
+      10
+    ],
+    [
+      "SAP - NetWeaver",
+      10
+    ],
+    [
+      "Microsoft - SharePoint",
+      9
+    ]
+  ],
+  "top_cwes": [
+    [
+      "CWE-20",
+      119
+    ],
+    [
+      "CWE-78",
+      110
+    ],
+    [
+      "CWE-787",
+      104
+    ],
+    [
+      "CWE-416",
+      93
+    ],
+    [
+      "CWE-119",
+      85
+    ],
+    [
+      "CWE-22",
+      79
+    ],
+    [
+      "CWE-502",
+      71
+    ],
+    [
+      "CWE-94",
+      70
+    ],
+    [
+      "CWE-287",
+      47
+    ],
+    [
+      "CWE-306",
+      42
+    ],
+    [
+      "CWE-843",
+      38
+    ],
+    [
+      "CWE-284",
+      36
+    ],
+    [
+      "CWE-122",
+      33
+    ],
+    [
+      "CWE-79",
+      33
+    ],
+    [
+      "CWE-89",
+      32
+    ],
+    [
+      "CWE-264",
+      31
+    ],
+    [
+      "CWE-77",
+      30
+    ],
+    [
+      "CWE-200",
+      25
+    ],
+    [
+      "CWE-434",
+      23
+    ],
+    [
+      "CWE-918",
+      22
+    ]
+  ],
+  "recent_additions": [
+    {
+      "cve_id": "CVE-2026-93952",
+      "vendor": "Arista",
+      "product": "VeloCloud Orchestrator",
+      "date_added": "2026-09-22",
+      "due_date": "2026-09-25",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-94127",
+      "vendor": "F5",
+      "product": "BIG-IP APM",
+      "date_added": "2026-09-22",
+      "due_date": "2026-09-25",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-93616",
+      "vendor": "Check Point",
+      "product": "Multiple Products",
+      "date_added": "2026-09-22",
+      "due_date": "2026-09-25",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-85102",
+      "vendor": "Check Point",
+      "product": "Multiple Products",
+      "date_added": "2026-09-22",
+      "due_date": "2026-09-25",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-7273",
+      "vendor": "Zyxel",
+      "product": "GS1900 Series Switches",
+      "date_added": "2026-09-21",
+      "due_date": "2026-09-24",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2025-39964",
+      "vendor": "Linux",
+      "product": "Kernel",
+      "date_added": "2026-09-18",
+      "due_date": "2026-09-21",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-53266",
+      "vendor": "Linux",
+      "product": "Kernel",
+      "date_added": "2026-09-18",
+      "due_date": "2026-09-21",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2025-39682",
+      "vendor": "Linux",
+      "product": "Kernel",
+      "date_added": "2026-09-18",
+      "due_date": "2026-09-21",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-58704",
+      "vendor": "Google",
+      "product": "Pixel",
+      "date_added": "2026-09-16",
+      "due_date": "2026-09-19",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-76460",
+      "vendor": "Cisco",
+      "product": "Identity Services Engine",
+      "date_added": "2026-09-16",
+      "due_date": "2026-09-19",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-87886",
+      "vendor": "Acronis",
+      "product": "Backup",
+      "date_added": "2026-09-16",
+      "due_date": "2026-09-19",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-76461",
+      "vendor": "Cisco",
+      "product": "Secure Email Gateway",
+      "date_added": "2026-09-14",
+      "due_date": "2026-09-17",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-84869",
+      "vendor": "ConnectWise",
+      "product": "ScreenConnect",
+      "date_added": "2026-09-11",
+      "due_date": "2026-09-14",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-42016",
+      "vendor": "JFrog",
+      "product": "Artifactory",
+      "date_added": "2026-09-11",
+      "due_date": "2026-09-25",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-42018",
+      "vendor": "JFrog",
+      "product": "Artifactory",
+      "date_added": "2026-09-11",
+      "due_date": "2026-09-25",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-85706",
+      "vendor": "GitLab",
+      "product": "Community Edition and Enterprise Edition",
+      "date_added": "2026-09-11",
+      "due_date": "2026-09-14",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-86060",
+      "vendor": "MikroTik",
+      "product": "RouterOS",
+      "date_added": "2026-09-10",
+      "due_date": "2026-09-13",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-67277",
+      "vendor": "MikroTik",
+      "product": "RouterOS",
+      "date_added": "2026-09-10",
+      "due_date": "2026-09-13",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2026-19490",
+      "vendor": "Citrix",
+      "product": "NetScaler",
+      "date_added": "2026-09-09",
+      "due_date": "2026-09-12",
+      "ransomware": "Unknown"
+    },
+    {
+      "cve_id": "CVE-2025-25249",
+      "vendor": "Fortinet",
+      "product": "Multiple Products",
+      "date_added": "2026-09-09",
+      "due_date": "2026-09-12",
+      "ransomware": "Unknown"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/web/data/risk_matrix.json b/web/data/risk_matrix.json
new file mode 100644
index 00000000000..cb8c5abb891
--- /dev/null
+++ b/web/data/risk_matrix.json
@@ -0,0 +1,173 @@
+{
+  "generated_at": "2026-09-23T22:55:59.750421Z",
+  "severity_bands": [
+    "NONE",
+    "LOW",
+    "MEDIUM",
+    "HIGH",
+    "CRITICAL"
+  ],
+  "epss_buckets": [
+    "0-0.1",
+    "0.1-0.3",
+    "0.3-0.5",
+    "0.5-0.7",
+    "0.7+"
+  ],
+  "matrix": [
+    {
+      "severity": "NONE",
+      "epss_bucket": "0-0.1",
+      "count": 88,
+      "kev_count": 0
+    },
+    {
+      "severity": "NONE",
+      "epss_bucket": "0.1-0.3",
+      "count": 1,
+      "kev_count": 0
+    },
+    {
+      "severity": "NONE",
+      "epss_bucket": "0.3-0.5",
+      "count": 0,
+      "kev_count": 0
+    },
+    {
+      "severity": "NONE",
+      "epss_bucket": "0.5-0.7",
+      "count": 2,
+      "kev_count": 0
+    },
+    {
+      "severity": "NONE",
+      "epss_bucket": "0.7+",
+      "count": 0,
+      "kev_count": 0
+    },
+    {
+      "severity": "LOW",
+      "epss_bucket": "0-0.1",
+      "count": 16244,
+      "kev_count": 4
+    },
+    {
+      "severity": "LOW",
+      "epss_bucket": "0.1-0.3",
+      "count": 91,
+      "kev_count": 1
+    },
+    {
+      "severity": "LOW",
+      "epss_bucket": "0.3-0.5",
+      "count": 21,
+      "kev_count": 1
+    },
+    {
+      "severity": "LOW",
+      "epss_bucket": "0.5-0.7",
+      "count": 8,
+      "kev_count": 0
+    },
+    {
+      "severity": "LOW",
+      "epss_bucket": "0.7+",
+      "count": 14,
+      "kev_count": 2
+    },
+    {
+      "severity": "MEDIUM",
+      "epss_bucket": "0-0.1",
+      "count": 166827,
+      "kev_count": 77
+    },
+    {
+      "severity": "MEDIUM",
+      "epss_bucket": "0.1-0.3",
+      "count": 2634,
+      "kev_count": 48
+    },
+    {
+      "severity": "MEDIUM",
+      "epss_bucket": "0.3-0.5",
+      "count": 592,
+      "kev_count": 20
+    },
+    {
+      "severity": "MEDIUM",
+      "epss_bucket": "0.5-0.7",
+      "count": 371,
+      "kev_count": 20
+    },
+    {
+      "severity": "MEDIUM",
+      "epss_bucket": "0.7+",
+      "count": 373,
+      "kev_count": 35
+    },
+    {
+      "severity": "HIGH",
+      "epss_bucket": "0-0.1",
+      "count": 133905,
+      "kev_count": 284
+    },
+    {
+      "severity": "HIGH",
+      "epss_bucket": "0.1-0.3",
+      "count": 3889,
+      "kev_count": 160
+    },
+    {
+      "severity": "HIGH",
+      "epss_bucket": "0.3-0.5",
+      "count": 955,
+      "kev_count": 90
+    },
+    {
+      "severity": "HIGH",
+      "epss_bucket": "0.5-0.7",
+      "count": 812,
+      "kev_count": 80
+    },
+    {
+      "severity": "HIGH",
+      "epss_bucket": "0.7+",
+      "count": 920,
+      "kev_count": 286
+    },
+    {
+      "severity": "CRITICAL",
+      "epss_bucket": "0-0.1",
+      "count": 40944,
+      "kev_count": 60
+    },
+    {
+      "severity": "CRITICAL",
+      "epss_bucket": "0.1-0.3",
+      "count": 3708,
+      "kev_count": 62
+    },
+    {
+      "severity": "CRITICAL",
+      "epss_bucket": "0.3-0.5",
+      "count": 1159,
+      "kev_count": 31
+    },
+    {
+      "severity": "CRITICAL",
+      "epss_bucket": "0.5-0.7",
+      "count": 675,
+      "kev_count": 40
+    },
+    {
+      "severity": "CRITICAL",
+      "epss_bucket": "0.7+",
+      "count": 1172,
+      "kev_count": 420
+    }
+  ],
+  "totals": {
+    "cves_in_matrix": 375405,
+    "kev_in_matrix": 1721
+  }
+}
\ No newline at end of file
diff --git a/web/data/scoring_comparison.json b/web/data/scoring_comparison.json
new file mode 100644
index 00000000000..fa63ea0bcac
--- /dev/null
+++ b/web/data/scoring_comparison.json
@@ -0,0 +1,41 @@
+{
+  "generated_at": "2026-09-23T22:56:24.525497Z",
+  "systems": {
+    "cvss": {
+      "name": "CVSS",
+      "full_name": "Common Vulnerability Scoring System",
+      "description": "Measures severity/impact of vulnerabilities",
+      "question": "How bad is it?",
+      "total_scored": 541733,
+      "source": "NVD / Vendors",
+      "update_frequency": "Per CVE publication"
+    },
+    "epss": {
+      "name": "EPSS",
+      "full_name": "Exploit Prediction Scoring System",
+      "description": "Predicts likelihood of exploitation in 30 days",
+      "question": "Will it be exploited?",
+      "total_scored": 378156,
+      "source": "FIRST.org",
+      "update_frequency": "Daily"
+    },
+    "kev": {
+      "name": "KEV",
+      "full_name": "Known Exploited Vulnerabilities",
+      "description": "Confirmed actively exploited vulnerabilities",
+      "question": "Is it being exploited?",
+      "total_scored": 1721,
+      "source": "CISA",
+      "update_frequency": "As exploits are confirmed"
+    }
+  },
+  "overlaps": {
+    "epss_and_kev": 1721,
+    "high_epss_in_kev": 883,
+    "kev_coverage_by_epss": 100.0
+  },
+  "insights": {
+    "epss_gt_05_not_kev": 3463,
+    "kev_with_low_epss": 425
+  }
+}
\ No newline at end of file
diff --git a/web/data/source_manifest.json b/web/data/source_manifest.json
new file mode 100644
index 00000000000..2808fb0eba1
--- /dev/null
+++ b/web/data/source_manifest.json
@@ -0,0 +1,72 @@
+{
+  "last_run_iso": "2026-09-23T22:43:35.530306+00:00",
+  "cve_count": 396856,
+  "duration_seconds": 275.089565,
+  "commit_sha": "38ff9ea004ec0186966cda3966bb221588e2d4af",
+  "degraded": false,
+  "years_via_api": [],
+  "expected_total": 396869,
+  "completeness_ratio": 1.0,
+  "year_counts": {
+    "1999": 1579,
+    "2000": 1243,
+    "2001": 1556,
+    "2002": 2393,
+    "2003": 1555,
+    "2004": 2707,
+    "2005": 4770,
+    "2006": 7145,
+    "2007": 6580,
+    "2008": 7179,
+    "2009": 5054,
+    "2010": 5249,
+    "2011": 4899,
+    "2012": 5939,
+    "2013": 6831,
+    "2014": 9002,
+    "2015": 8779,
+    "2016": 10648,
+    "2017": 17106,
+    "2018": 17817,
+    "2019": 17624,
+    "2020": 21076,
+    "2021": 23470,
+    "2022": 27555,
+    "2023": 31444,
+    "2024": 39250,
+    "2025": 45309,
+    "2026": 63097
+  },
+  "feed_timestamps": {
+    "2002": "2026-08-28T03:04:40.240591+00:00",
+    "2003": "2026-08-28T03:04:38.841612+00:00",
+    "2004": "2026-08-28T03:04:37.194431+00:00",
+    "2005": "2026-08-28T03:04:34.380129+00:00",
+    "2006": "2026-08-28T03:04:29.783454+00:00",
+    "2007": "2026-08-28T03:04:25.261935+00:00",
+    "2008": "2026-08-28T03:04:20.277819+00:00",
+    "2009": "2026-08-28T03:04:15.689861+00:00",
+    "2010": "2026-08-28T03:04:10.899279+00:00",
+    "2011": "2026-09-15T03:03:36.390024+00:00",
+    "2012": "2026-09-18T03:02:45.991690+00:00",
+    "2013": "2026-09-15T03:03:29.371446+00:00",
+    "2014": "2026-08-28T03:03:47.765220+00:00",
+    "2015": "2026-08-28T03:03:41.728532+00:00",
+    "2016": "2026-09-23T03:03:44.442607+00:00",
+    "2017": "2026-09-23T03:03:33.327808+00:00",
+    "2018": "2026-09-19T03:03:14.220040+00:00",
+    "2019": "2026-09-23T03:03:19.980474+00:00",
+    "2020": "2026-09-23T03:03:02.715013+00:00",
+    "2021": "2026-09-23T03:02:42.612820+00:00",
+    "2022": "2026-09-23T03:02:19.780706+00:00",
+    "2023": "2026-09-23T03:01:54.627023+00:00",
+    "2024": "2026-09-23T03:01:23.730396+00:00",
+    "2025": "2026-09-23T03:00:48.574714+00:00",
+    "2026": "2026-09-23T03:00:02.494303+00:00",
+    "modified": "2026-09-23T18:00:05.766322+00:00"
+  },
+  "schema_version": 2,
+  "data_object_key": "nvd.json",
+  "bytes": 1856883164,
+  "sha256": "71b3a2aa907c684d680964813c5260ae76684ee23803a2674314af72cce4fe13"
+}
\ No newline at end of file
diff --git a/web/data/source_reconciliation.json b/web/data/source_reconciliation.json
new file mode 100644
index 00000000000..a4fe864fb6f
--- /dev/null
+++ b/web/data/source_reconciliation.json
@@ -0,0 +1,280 @@
+{
+  "generated_at": "2026-09-23T22:56:24.634125Z",
+  "sources": {
+    "nvd": {
+      "label": "NVD mirror",
+      "used_for": "yearly and daily counts, CVSS, CWE, CPE",
+      "file": "yearly_summary.json"
+    },
+    "v5": {
+      "label": "CVE Program cvelistV5",
+      "used_for": "publisher attribution",
+      "file": "cna_analysis.json"
+    }
+  },
+  "thresholds": {
+    "modern_year_floor": 2016,
+    "max_abs": 250,
+    "max_pct": 0.5
+  },
+  "totals": {
+    "nvd": 377799,
+    "v5": 378495,
+    "delta": 696
+  },
+  "years": [
+    {
+      "year": 1999,
+      "nvd": 894,
+      "v5": 320,
+      "delta": -574,
+      "pct": -64.206,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2000,
+      "nvd": 1019,
+      "v5": 1437,
+      "delta": 418,
+      "pct": 41.021,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2001,
+      "nvd": 1676,
+      "v5": 1323,
+      "delta": -353,
+      "pct": -21.062,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2002,
+      "nvd": 2156,
+      "v5": 1690,
+      "delta": -466,
+      "pct": -21.614,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2003,
+      "nvd": 1527,
+      "v5": 1223,
+      "delta": -304,
+      "pct": -19.908,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2004,
+      "nvd": 2451,
+      "v5": 1612,
+      "delta": -839,
+      "pct": -34.231,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2005,
+      "nvd": 4932,
+      "v5": 6708,
+      "delta": 1776,
+      "pct": 36.01,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2006,
+      "nvd": 6608,
+      "v5": 6885,
+      "delta": 277,
+      "pct": 4.192,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2007,
+      "nvd": 6516,
+      "v5": 7211,
+      "delta": 695,
+      "pct": 10.666,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2008,
+      "nvd": 5632,
+      "v5": 5673,
+      "delta": 41,
+      "pct": 0.728,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2009,
+      "nvd": 5732,
+      "v5": 5732,
+      "delta": 0,
+      "pct": 0.0,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2010,
+      "nvd": 4639,
+      "v5": 4639,
+      "delta": 0,
+      "pct": 0.0,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2011,
+      "nvd": 4150,
+      "v5": 4150,
+      "delta": 0,
+      "pct": 0.0,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2012,
+      "nvd": 5288,
+      "v5": 5288,
+      "delta": 0,
+      "pct": 0.0,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2013,
+      "nvd": 5187,
+      "v5": 5187,
+      "delta": 0,
+      "pct": 0.0,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2014,
+      "nvd": 7928,
+      "v5": 7928,
+      "delta": 0,
+      "pct": 0.0,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2015,
+      "nvd": 6494,
+      "v5": 6494,
+      "delta": 0,
+      "pct": 0.0,
+      "modern": false,
+      "within_threshold": true
+    },
+    {
+      "year": 2016,
+      "nvd": 6449,
+      "v5": 6457,
+      "delta": 8,
+      "pct": 0.124,
+      "modern": true,
+      "within_threshold": true
+    },
+    {
+      "year": 2017,
+      "nvd": 14642,
+      "v5": 14642,
+      "delta": 0,
+      "pct": 0.0,
+      "modern": true,
+      "within_threshold": true
+    },
+    {
+      "year": 2018,
+      "nvd": 16510,
+      "v5": 16510,
+      "delta": 0,
+      "pct": 0.0,
+      "modern": true,
+      "within_threshold": true
+    },
+    {
+      "year": 2019,
+      "nvd": 17305,
+      "v5": 17308,
+      "delta": 3,
+      "pct": 0.017,
+      "modern": true,
+      "within_threshold": true
+    },
+    {
+      "year": 2020,
+      "nvd": 18322,
+      "v5": 18363,
+      "delta": 41,
+      "pct": 0.224,
+      "modern": true,
+      "within_threshold": true
+    },
+    {
+      "year": 2021,
+      "nvd": 20149,
+      "v5": 20177,
+      "delta": 28,
+      "pct": 0.139,
+      "modern": true,
+      "within_threshold": true
+    },
+    {
+      "year": 2022,
+      "nvd": 25074,
+      "v5": 25000,
+      "delta": -74,
+      "pct": -0.295,
+      "modern": true,
+      "within_threshold": true
+    },
+    {
+      "year": 2023,
+      "nvd": 28816,
+      "v5": 28847,
+      "delta": 31,
+      "pct": 0.108,
+      "modern": true,
+      "within_threshold": true
+    },
+    {
+      "year": 2024,
+      "nvd": 39953,
+      "v5": 39924,
+      "delta": -29,
+      "pct": -0.073,
+      "modern": true,
+      "within_threshold": true
+    },
+    {
+      "year": 2025,
+      "nvd": 48153,
+      "v5": 48153,
+      "delta": 0,
+      "pct": 0.0,
+      "modern": true,
+      "within_threshold": true
+    },
+    {
+      "year": 2026,
+      "nvd": 69597,
+      "v5": 69614,
+      "delta": 17,
+      "pct": 0.024,
+      "modern": true,
+      "within_threshold": true
+    }
+  ],
+  "flagged_years": []
+}
\ No newline at end of file
diff --git a/web/data/yearly_summary.json b/web/data/yearly_summary.json
new file mode 100644
index 00000000000..6743dd1436d
--- /dev/null
+++ b/web/data/yearly_summary.json
@@ -0,0 +1 @@
+{"generated_at": "2026-09-23T22:56:24.609338Z", "data_as_of": "2026-09-23T22:49:26.546081Z", "data_age_hours": 0.0, "source_last_run": "2026-09-23T22:43:35.530306+00:00", "source_age_hours": 0.1, "source_cve_count": 396856, "years": {"1999": {"year": 1999, "total_cves": 894, "date_data": {"monthly_distribution": {"1": 153, "2": 58, "3": 52, "4": 39, "5": 54, "6": 37, "7": 40, "8": 60, "9": 60, "10": 57, "11": 83, "12": 201}, "daily_analysis": {"total_days": 256, "avg_per_day": 3.49, "highest_day": {"date": "1999-01-01", "count": 112}, "lowest_day": {"date": "1999-01-05", "count": 1}}}, "cvss": {"v2.0": {"total": 894, "severity_distribution": {"UNKNOWN": 894}, "score_distribution": {"10.0": 159, "5.0": 235, "7.5": 130, "4.6": 83, "5.1": 18, "3.7": 1, "0.0": 14, "6.4": 13, "7.2": 115, "4.9": 1, "2.1": 70, "7.8": 7, "2.6": 16, "6.2": 4, "9.3": 3, "1.2": 4, "3.6": 8, "7.6": 5, "7.1": 2, "4.0": 2, "9.0": 1, "4.3": 2, "3.5": 1}}, "v3.1": {"total": 9, "severity_distribution": {"HIGH": 5, "CRITICAL": 3, "MEDIUM": 1}, "score_distribution": {"7.3": 1, "7.5": 2, "9.8": 3, "8.2": 1, "7.8": 1, "5.5": 1}}, "epss_summary": {"epss_gt_0_1": 110, "epss_gt_0_5": 6, "epss_gt_0_9": 0}}, "kev": {"kev_count": 0}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 173}, {"name": "Sun", "count": 55}, {"name": "Redhat", "count": 40}, {"name": "Debian", "count": 27}, {"name": "Ibm", "count": 22}, {"name": "Cisco", "count": 21}, {"name": "Netscape", "count": 21}, {"name": "Sco", "count": 20}, {"name": "Linux", "count": 19}, {"name": "Hp", "count": 18}, {"name": "Suse", "count": 18}, {"name": "Freebsd", "count": 18}, {"name": "Caldera", "count": 13}, {"name": "Netbsd", "count": 13}, {"name": "Openbsd", "count": 13}, {"name": "Sgi", "count": 10}, {"name": "Ipswitch", "count": 8}, {"name": "Apache", "count": 8}, {"name": "Novell", "count": 8}, {"name": "Isc", "count": 8}]}, "cwe": {"top_cwes": [{"cwe": "CWE-200", "count": 9}, {"cwe": "CWE-20", "count": 8}, {"cwe": "CWE-16", "count": 6}, {"cwe": "CWE-119", "count": 6}, {"cwe": "CWE-264", "count": 6}, {"cwe": "CWE-287", "count": 3}, {"cwe": "CWE-94", "count": 3}, {"cwe": "CWE-255", "count": 3}, {"cwe": "CWE-59", "count": 3}, {"cwe": "CWE-193", "count": 2}, {"cwe": "CWE-19", "count": 1}, {"cwe": "CWE-276", "count": 1}, {"cwe": "CWE-384", "count": 1}, {"cwe": "CWE-120", "count": 1}, {"cwe": "CWE-362", "count": 1}, {"cwe": "CWE-346", "count": 1}, {"cwe": "CWE-665", "count": 1}, {"cwe": "CWE-772", "count": 1}, {"cwe": "CWE-307", "count": 1}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 894}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 458}, {"tag": "Patch", "count": 336}, {"tag": "Exploit", "count": 236}, {"tag": "Third Party Advisory", "count": 48}, {"tag": "US Government Resource", "count": 44}, {"tag": "VDB Entry", "count": 34}, {"tag": "Broken Link", "count": 20}, {"tag": "Mailing List", "count": 8}, {"tag": "URL Repurposed", "count": 6}]}}, "2000": {"year": 2000, "total_cves": 1019, "date_data": {"monthly_distribution": {"1": 68, "2": 86, "3": 57, "4": 79, "5": 110, "6": 119, "7": 74, "8": 3, "9": 3, "10": 135, "11": 73, "12": 212}, "daily_analysis": {"total_days": 197, "avg_per_day": 5.17, "highest_day": {"date": "2000-10-20", "count": 130}, "lowest_day": {"date": "2000-01-07", "count": 1}}}, "cvss": {"v2.0": {"total": 1019, "severity_distribution": {"UNKNOWN": 1019}, "score_distribution": {"7.2": 130, "2.1": 59, "7.5": 168, "5.0": 371, "4.6": 59, "10.0": 141, "6.4": 19, "3.6": 9, "6.2": 9, "2.6": 19, "4.3": 1, "5.1": 11, "1.2": 7, "7.6": 6, "7.8": 3, "7.1": 1, "3.7": 4, "9.0": 2}}, "v3.0": {"total": 1, "severity_distribution": {"HIGH": 1}, "score_distribution": {"7.5": 1}}, "v3.1": {"total": 9, "severity_distribution": {"CRITICAL": 2, "MEDIUM": 3, "HIGH": 4}, "score_distribution": {"9.8": 2, "5.5": 3, "7.5": 4}}, "epss_summary": {"epss_gt_0_1": 148, "epss_gt_0_5": 20, "epss_gt_0_9": 2}}, "kev": {"kev_count": 0}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 143}, {"name": "Redhat", "count": 48}, {"name": "Hp", "count": 36}, {"name": "Freebsd", "count": 27}, {"name": "Sun", "count": 26}, {"name": "Netscape", "count": 22}, {"name": "Mandrakesoft", "count": 18}, {"name": "Openbsd", "count": 18}, {"name": "Suse", "count": 18}, {"name": "Sgi", "count": 17}, {"name": "Debian", "count": 17}, {"name": "Ibm", "count": 17}, {"name": "Cisco", "count": 16}, {"name": "Checkpoint", "count": 15}, {"name": "Gnu", "count": 14}, {"name": "Sco", "count": 12}, {"name": "Allaire", "count": 11}, {"name": "Oracle", "count": 11}, {"name": "Netbsd", "count": 11}, {"name": "Caldera", "count": 10}]}, "cwe": {"top_cwes": [{"cwe": "CWE-120", "count": 4}, {"cwe": "CWE-200", "count": 4}, {"cwe": "CWE-20", "count": 3}, {"cwe": "CWE-59", "count": 3}, {"cwe": "CWE-178", "count": 3}, {"cwe": "CWE-264", "count": 2}, {"cwe": "CWE-119", "count": 1}, {"cwe": "CWE-79", "count": 1}, {"cwe": "CWE-94", "count": 1}, {"cwe": "CWE-254", "count": 1}, {"cwe": "CWE-16", "count": 1}, {"cwe": "CWE-346", "count": 1}, {"cwe": "CWE-667", "count": 1}, {"cwe": "CWE-399", "count": 1}, {"cwe": "CWE-459", "count": 1}, {"cwe": "CWE-310", "count": 1}, {"cwe": "CWE-362", "count": 1}, {"cwe": "CWE-522", "count": 1}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 1019}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 1896}, {"tag": "Patch", "count": 1284}, {"tag": "Exploit", "count": 832}, {"tag": "Third Party Advisory", "count": 112}, {"tag": "US Government Resource", "count": 76}, {"tag": "VDB Entry", "count": 64}, {"tag": "Broken Link", "count": 64}, {"tag": "URL Repurposed", "count": 14}, {"tag": "Not Applicable", "count": 2}, {"tag": "Product", "count": 2}]}}, "2001": {"year": 2001, "total_cves": 1676, "date_data": {"monthly_distribution": {"1": 130, "2": 117, "3": 105, "4": 17, "5": 105, "6": 211, "7": 190, "8": 205, "9": 135, "10": 142, "11": 61, "12": 258}, "daily_analysis": {"total_days": 194, "avg_per_day": 8.64, "highest_day": {"date": "2001-01-09", "count": 111}, "lowest_day": {"date": "2001-01-08", "count": 1}}}, "cvss": {"v2.0": {"total": 1676, "severity_distribution": {"UNKNOWN": 1676}, "score_distribution": {"5.0": 520, "7.5": 456, "4.6": 134, "2.1": 132, "10.0": 148, "7.2": 157, "3.7": 6, "5.1": 13, "4.3": 6, "3.6": 12, "6.4": 25, "9.0": 1, "6.2": 14, "2.6": 13, "1.2": 26, "7.8": 2, "7.6": 5, "3.3": 1, "7.1": 1, "4.0": 1, "6.8": 2, "9.3": 1}}, "v3.1": {"total": 38, "severity_distribution": {"MEDIUM": 7, "HIGH": 19, "CRITICAL": 12}, "score_distribution": {"5.5": 6, "7.1": 1, "7.8": 4, "9.8": 12, "7.5": 12, "8.8": 1, "7.3": 1, "5.3": 1}}, "epss_summary": {"epss_gt_0_1": 191, "epss_gt_0_5": 27, "epss_gt_0_9": 4}}, "kev": {"kev_count": 0}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 173}, {"name": "Ibm", "count": 59}, {"name": "Sun", "count": 56}, {"name": "Cisco", "count": 55}, {"name": "Redhat", "count": 48}, {"name": "Hp", "count": 48}, {"name": "Debian", "count": 36}, {"name": "Freebsd", "count": 36}, {"name": "Mandrakesoft", "count": 35}, {"name": "Oracle", "count": 35}, {"name": "Openbsd", "count": 30}, {"name": "Linux", "count": 23}, {"name": "Suse", "count": 21}, {"name": "Caldera", "count": 20}, {"name": "Sco", "count": 20}, {"name": "Immunix", "count": 19}, {"name": "Trend Micro", "count": 17}, {"name": "Lotus", "count": 16}, {"name": "Apache", "count": 16}, {"name": "Sgi", "count": 15}]}, "cwe": {"top_cwes": [{"cwe": "CWE-119", "count": 9}, {"cwe": "CWE-59", "count": 7}, {"cwe": "CWE-120", "count": 5}, {"cwe": "CWE-22", "count": 5}, {"cwe": "CWE-20", "count": 5}, {"cwe": "CWE-203", "count": 4}, {"cwe": "CWE-310", "count": 4}, {"cwe": "CWE-88", "count": 4}, {"cwe": "CWE-193", "count": 3}, {"cwe": "CWE-307", "count": 3}, {"cwe": "CWE-131", "count": 3}, {"cwe": "CWE-178", "count": 3}, {"cwe": "CWE-434", "count": 3}, {"cwe": "CWE-264", "count": 3}, {"cwe": "CWE-312", "count": 3}, {"cwe": "CWE-401", "count": 2}, {"cwe": "CWE-281", "count": 2}, {"cwe": "CWE-94", "count": 2}, {"cwe": "CWE-287", "count": 2}, {"cwe": "CWE-667", "count": 2}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 1675}, {"status": "Analyzed", "count": 1}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 4276}, {"tag": "Patch", "count": 2868}, {"tag": "Exploit", "count": 1696}, {"tag": "US Government Resource", "count": 546}, {"tag": "Third Party Advisory", "count": 534}, {"tag": "Broken Link", "count": 306}, {"tag": "VDB Entry", "count": 268}, {"tag": "Mailing List", "count": 44}, {"tag": "URL Repurposed", "count": 22}, {"tag": "Issue Tracking", "count": 6}, {"tag": "Release Notes", "count": 4}]}}, "2002": {"year": 2002, "total_cves": 2156, "date_data": {"monthly_distribution": {"1": 25, "2": 15, "3": 104, "4": 45, "5": 148, "6": 102, "7": 137, "8": 255, "9": 68, "10": 314, "11": 74, "12": 869}, "daily_analysis": {"total_days": 89, "avg_per_day": 24.22, "highest_day": {"date": "2002-12-31", "count": 791}, "lowest_day": {"date": "2002-01-02", "count": 1}}}, "cvss": {"v2.0": {"total": 2156, "severity_distribution": {"UNKNOWN": 2156}, "score_distribution": {"7.2": 141, "5.0": 685, "7.5": 671, "1.2": 8, "10.0": 156, "3.6": 12, "5.1": 15, "4.6": 101, "6.4": 48, "2.6": 11, "7.6": 5, "2.1": 113, "6.2": 10, "6.8": 27, "4.3": 96, "5.4": 1, "7.8": 21, "1.7": 1, "3.7": 2, "7.1": 6, "6.9": 3, "1.9": 2, "4.0": 2, "4.9": 5, "3.8": 1, "8.5": 1, "8.3": 1, "6.6": 1, "9.4": 2, "3.3": 1, "5.8": 4, "8.8": 1, "9.3": 1, "3.5": 1}}, "v3.1": {"total": 54, "severity_distribution": {"CRITICAL": 10, "HIGH": 31, "MEDIUM": 12, "LOW": 1}, "score_distribution": {"9.8": 9, "7.8": 8, "7.5": 23, "5.5": 11, "9.1": 1, "3.3": 1, "5.3": 1}}, "epss_summary": {"epss_gt_0_1": 289, "epss_gt_0_5": 33, "epss_gt_0_9": 2}}, "kev": {"kev_count": 1}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 246}, {"name": "Cisco", "count": 65}, {"name": "Hp", "count": 58}, {"name": "Sun", "count": 57}, {"name": "Oracle", "count": 56}, {"name": "Ibm", "count": 43}, {"name": "Sgi", "count": 33}, {"name": "Apache", "count": 32}, {"name": "Freebsd", "count": 31}, {"name": "Mozilla", "count": 30}, {"name": "Openbsd", "count": 25}, {"name": "Apple", "count": 25}, {"name": "Redhat", "count": 23}, {"name": "Caldera", "count": 23}, {"name": "Novell", "count": 22}, {"name": "Symantec", "count": 22}, {"name": "Macromedia", "count": 20}, {"name": "Gnu", "count": 18}, {"name": "Netscape", "count": 17}, {"name": "Linux", "count": 15}]}, "cwe": {"top_cwes": [{"cwe": "CWE-119", "count": 41}, {"cwe": "CWE-79", "count": 34}, {"cwe": "CWE-264", "count": 31}, {"cwe": "CWE-20", "count": 27}, {"cwe": "CWE-200", "count": 17}, {"cwe": "CWE-22", "count": 14}, {"cwe": "CWE-94", "count": 12}, {"cwe": "CWE-16", "count": 9}, {"cwe": "CWE-326", "count": 8}, {"cwe": "CWE-255", "count": 8}, {"cwe": "CWE-193", "count": 7}, {"cwe": "CWE-89", "count": 7}, {"cwe": "CWE-667", "count": 6}, {"cwe": "CWE-459", "count": 6}, {"cwe": "CWE-59", "count": 6}, {"cwe": "CWE-287", "count": 5}, {"cwe": "CWE-399", "count": 5}, {"cwe": "CWE-189", "count": 5}, {"cwe": "CWE-269", "count": 4}, {"cwe": "CWE-203", "count": 4}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 2155}, {"status": "Analyzed", "count": 1}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 4590}, {"tag": "Patch", "count": 3794}, {"tag": "Exploit", "count": 1706}, {"tag": "Third Party Advisory", "count": 756}, {"tag": "Broken Link", "count": 750}, {"tag": "US Government Resource", "count": 717}, {"tag": "VDB Entry", "count": 364}, {"tag": "Mailing List", "count": 124}, {"tag": "URL Repurposed", "count": 48}, {"tag": "Issue Tracking", "count": 18}, {"tag": "Not Applicable", "count": 8}, {"tag": "Release Notes", "count": 6}, {"tag": "Product", "count": 6}]}}, "2003": {"year": 2003, "total_cves": 1527, "date_data": {"monthly_distribution": {"1": 36, "2": 48, "3": 119, "4": 135, "5": 80, "6": 129, "7": 48, "8": 205, "9": 35, "10": 92, "11": 93, "12": 507}, "daily_analysis": {"total_days": 91, "avg_per_day": 16.78, "highest_day": {"date": "2003-12-31", "count": 441}, "lowest_day": {"date": "2003-01-03", "count": 1}}}, "cvss": {"v2.0": {"total": 1527, "severity_distribution": {"UNKNOWN": 1527}, "score_distribution": {"7.5": 407, "7.2": 109, "4.6": 114, "4.3": 105, "10.0": 119, "5.0": 400, "2.1": 61, "6.5": 2, "1.2": 10, "3.6": 12, "5.8": 5, "6.4": 29, "6.2": 4, "7.8": 16, "6.8": 64, "2.6": 8, "9.0": 7, "5.1": 9, "9.3": 8, "7.6": 6, "4.4": 4, "3.7": 3, "6.9": 1, "7.1": 2, "4.9": 3, "1.7": 1, "4.0": 3, "5.2": 1, "8.5": 2, "3.3": 2, "8.3": 1, "8.8": 1, "6.6": 1, "1.9": 2, "4.8": 1, "3.5": 1, "6.3": 3}}, "v3.1": {"total": 17, "severity_distribution": {"HIGH": 6, "CRITICAL": 9, "MEDIUM": 2}, "score_distribution": {"7.5": 3, "9.8": 9, "7.3": 1, "5.5": 1, "7.8": 1, "7.1": 1, "6.5": 1}}, "epss_summary": {"epss_gt_0_1": 204, "epss_gt_0_5": 36, "epss_gt_0_9": 1}}, "kev": {"kev_count": 0}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 118}, {"name": "Sun", "count": 64}, {"name": "Apple", "count": 48}, {"name": "Hp", "count": 43}, {"name": "Redhat", "count": 38}, {"name": "Ibm", "count": 34}, {"name": "Linux", "count": 28}, {"name": "Cisco", "count": 27}, {"name": "Apache", "count": 25}, {"name": "Sgi", "count": 24}, {"name": "Oracle", "count": 21}, {"name": "Bea", "count": 20}, {"name": "Openbsd", "count": 18}, {"name": "Novell", "count": 16}, {"name": "Netbsd", "count": 14}, {"name": "Freebsd", "count": 14}, {"name": "Gnu", "count": 14}, {"name": "Debian", "count": 13}, {"name": "Mozilla", "count": 13}, {"name": "Sap", "count": 12}]}, "cwe": {"top_cwes": [{"cwe": "CWE-119", "count": 52}, {"cwe": "CWE-79", "count": 34}, {"cwe": "CWE-20", "count": 26}, {"cwe": "CWE-200", "count": 25}, {"cwe": "CWE-264", "count": 18}, {"cwe": "CWE-22", "count": 17}, {"cwe": "CWE-94", "count": 15}, {"cwe": "CWE-89", "count": 13}, {"cwe": "CWE-16", "count": 11}, {"cwe": "CWE-310", "count": 9}, {"cwe": "CWE-255", "count": 8}, {"cwe": "CWE-120", "count": 7}, {"cwe": "CWE-287", "count": 7}, {"cwe": "CWE-399", "count": 7}, {"cwe": "CWE-59", "count": 6}, {"cwe": "CWE-193", "count": 4}, {"cwe": "CWE-203", "count": 3}, {"cwe": "CWE-415", "count": 2}, {"cwe": "CWE-189", "count": 2}, {"cwe": "CWE-134", "count": 2}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 1527}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 3349}, {"tag": "Patch", "count": 2836}, {"tag": "Exploit", "count": 1702}, {"tag": "Third Party Advisory", "count": 648}, {"tag": "US Government Resource", "count": 556}, {"tag": "Broken Link", "count": 408}, {"tag": "VDB Entry", "count": 160}, {"tag": "Mailing List", "count": 56}, {"tag": "URL Repurposed", "count": 52}, {"tag": "Issue Tracking", "count": 34}, {"tag": "Not Applicable", "count": 6}, {"tag": "Product", "count": 2}, {"tag": "Tool Signature", "count": 2}, {"tag": "Release Notes", "count": 2}]}}, "2004": {"year": 2004, "total_cves": 2451, "date_data": {"monthly_distribution": {"1": 65, "2": 91, "3": 141, "4": 107, "5": 68, "6": 52, "7": 101, "8": 240, "9": 90, "10": 101, "11": 172, "12": 1223}, "daily_analysis": {"total_days": 186, "avg_per_day": 13.18, "highest_day": {"date": "2004-12-31", "count": 1098}, "lowest_day": {"date": "2004-01-04", "count": 1}}}, "cvss": {"v2.0": {"total": 2451, "severity_distribution": {"UNKNOWN": 2451}, "score_distribution": {"4.6": 105, "2.1": 148, "5.0": 761, "7.2": 134, "7.5": 586, "10.0": 208, "4.3": 239, "7.8": 15, "6.0": 5, "9.3": 9, "3.7": 7, "6.8": 60, "7.6": 6, "5.1": 30, "2.6": 38, "3.5": 2, "6.4": 34, "1.2": 4, "3.6": 6, "8.5": 4, "4.4": 3, "9.0": 4, "6.5": 6, "4.7": 1, "4.9": 4, "4.0": 11, "7.1": 3, "5.8": 7, "5.4": 2, "6.9": 3, "6.2": 1, "1.0": 1, "1.7": 1, "5.5": 1, "1.9": 1, "5.6": 1}}, "v3.0": {"total": 1, "severity_distribution": {"CRITICAL": 1}, "score_distribution": {"9.8": 1}}, "v3.1": {"total": 44, "severity_distribution": {"MEDIUM": 10, "HIGH": 25, "CRITICAL": 9}, "score_distribution": {"6.1": 1, "7.5": 12, "7.8": 6, "9.8": 9, "4.8": 1, "7.0": 1, "8.8": 3, "7.1": 2, "5.5": 4, "5.9": 1, "6.5": 1, "5.3": 2, "8.4": 1}}, "epss_summary": {"epss_gt_0_1": 273, "epss_gt_0_5": 61, "epss_gt_0_9": 0}}, "kev": {"kev_count": 2}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 150}, {"name": "Apple", "count": 67}, {"name": "Mozilla", "count": 59}, {"name": "Ibm", "count": 54}, {"name": "Sun", "count": 54}, {"name": "Linux", "count": 52}, {"name": "Sgi", "count": 52}, {"name": "Redhat", "count": 51}, {"name": "Gentoo", "count": 45}, {"name": "Gnu", "count": 40}, {"name": "Francisco Burzi", "count": 38}, {"name": "Debian", "count": 36}, {"name": "Cisco", "count": 36}, {"name": "Oracle", "count": 34}, {"name": "Openbsd", "count": 33}, {"name": "Suse", "count": 32}, {"name": "Mandrakesoft", "count": 31}, {"name": "Hp", "count": 31}, {"name": "Symantec", "count": 28}, {"name": "Apache", "count": 25}]}, "cwe": {"top_cwes": [{"cwe": "CWE-79", "count": 24}, {"cwe": "CWE-119", "count": 23}, {"cwe": "CWE-264", "count": 20}, {"cwe": "CWE-20", "count": 17}, {"cwe": "CWE-22", "count": 15}, {"cwe": "CWE-89", "count": 10}, {"cwe": "CWE-476", "count": 9}, {"cwe": "CWE-203", "count": 7}, {"cwe": "CWE-200", "count": 6}, {"cwe": "CWE-88", "count": 6}, {"cwe": "CWE-287", "count": 6}, {"cwe": "CWE-94", "count": 6}, {"cwe": "CWE-59", "count": 6}, {"cwe": "CWE-125", "count": 6}, {"cwe": "CWE-255", "count": 6}, {"cwe": "CWE-134", "count": 5}, {"cwe": "CWE-787", "count": 5}, {"cwe": "CWE-415", "count": 4}, {"cwe": "CWE-120", "count": 4}, {"cwe": "CWE-352", "count": 4}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 2448}, {"status": "Analyzed", "count": 3}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 6514}, {"tag": "Patch", "count": 6018}, {"tag": "Exploit", "count": 3522}, {"tag": "Third Party Advisory", "count": 1610}, {"tag": "Broken Link", "count": 1052}, {"tag": "US Government Resource", "count": 910}, {"tag": "VDB Entry", "count": 532}, {"tag": "Mailing List", "count": 242}, {"tag": "URL Repurposed", "count": 94}, {"tag": "Issue Tracking", "count": 52}, {"tag": "Not Applicable", "count": 22}, {"tag": "Permissions Required", "count": 12}, {"tag": "Tool Signature", "count": 10}, {"tag": "Product", "count": 8}, {"tag": "Release Notes", "count": 6}, {"tag": "Mitigation", "count": 2}]}}, "2005": {"year": 2005, "total_cves": 4932, "date_data": {"monthly_distribution": {"1": 320, "2": 105, "3": 164, "4": 125, "5": 1254, "6": 242, "7": 288, "8": 322, "9": 309, "10": 283, "11": 504, "12": 1016}, "daily_analysis": {"total_days": 262, "avg_per_day": 18.82, "highest_day": {"date": "2005-05-02", "count": 816}, "lowest_day": {"date": "2005-01-01", "count": 1}}}, "cvss": {"v2.0": {"total": 4932, "severity_distribution": {"UNKNOWN": 4932}, "score_distribution": {"5.0": 1172, "4.6": 196, "7.2": 176, "10.0": 286, "4.3": 687, "5.1": 131, "2.1": 315, "6.4": 81, "1.2": 23, "3.6": 18, "6.2": 4, "6.8": 79, "7.5": 1456, "5.8": 13, "9.3": 17, "6.6": 2, "6.5": 20, "6.9": 5, "2.6": 71, "4.7": 1, "7.8": 79, "6.1": 2, "4.9": 20, "4.0": 19, "7.1": 9, "7.6": 9, "3.7": 12, "1.9": 5, "4.4": 1, "8.5": 1, "1.7": 2, "3.5": 7, "5.4": 5, "9.4": 3, "9.0": 3, "5.6": 1, "5.7": 1}}, "v3.0": {"total": 1, "severity_distribution": {"MEDIUM": 1}, "score_distribution": {"5.6": 1}}, "v3.1": {"total": 64, "severity_distribution": {"HIGH": 26, "CRITICAL": 13, "MEDIUM": 23, "LOW": 2}, "score_distribution": {"7.8": 4, "7.5": 17, "9.8": 13, "5.5": 9, "6.5": 3, "3.7": 2, "5.3": 3, "8.8": 1, "4.7": 3, "8.4": 1, "7.4": 1, "4.5": 1, "4.3": 1, "5.0": 1, "7.3": 1, "6.1": 1, "6.3": 1, "7.1": 1}}, "epss_summary": {"epss_gt_0_1": 383, "epss_gt_0_5": 93, "epss_gt_0_9": 1}}, "kev": {"kev_count": 1}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 172}, {"name": "Apple", "count": 150}, {"name": "Linux", "count": 134}, {"name": "Redhat", "count": 101}, {"name": "Mozilla", "count": 93}, {"name": "Debian", "count": 82}, {"name": "Suse", "count": 82}, {"name": "Ibm", "count": 81}, {"name": "Oracle", "count": 80}, {"name": "Gentoo", "count": 79}, {"name": "Sun", "count": 75}, {"name": "Cisco", "count": 54}, {"name": "Ethereal Group", "count": 49}, {"name": "Gnu", "count": 46}, {"name": "Ubuntu", "count": 43}, {"name": "Hp", "count": 36}, {"name": "Mandrakesoft", "count": 34}, {"name": "Novell", "count": 34}, {"name": "Trustix", "count": 33}, {"name": "Phpbb Group", "count": 32}]}, "cwe": {"top_cwes": [{"cwe": "CWE-119", "count": 71}, {"cwe": "CWE-89", "count": 52}, {"cwe": "CWE-79", "count": 42}, {"cwe": "CWE-264", "count": 38}, {"cwe": "CWE-399", "count": 32}, {"cwe": "CWE-20", "count": 30}, {"cwe": "CWE-94", "count": 30}, {"cwe": "CWE-200", "count": 19}, {"cwe": "CWE-22", "count": 14}, {"cwe": "CWE-189", "count": 14}, {"cwe": "CWE-59", "count": 13}, {"cwe": "CWE-425", "count": 9}, {"cwe": "CWE-287", "count": 6}, {"cwe": "CWE-131", "count": 5}, {"cwe": "CWE-434", "count": 5}, {"cwe": "CWE-352", "count": 5}, {"cwe": "CWE-400", "count": 4}, {"cwe": "CWE-190", "count": 4}, {"cwe": "CWE-134", "count": 4}, {"cwe": "CWE-601", "count": 4}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 4925}, {"status": "Analyzed", "count": 7}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 12694}, {"tag": "Patch", "count": 9316}, {"tag": "Exploit", "count": 5362}, {"tag": "Third Party Advisory", "count": 2080}, {"tag": "Broken Link", "count": 1404}, {"tag": "US Government Resource", "count": 943}, {"tag": "VDB Entry", "count": 602}, {"tag": "URL Repurposed", "count": 296}, {"tag": "Mailing List", "count": 276}, {"tag": "Permissions Required", "count": 170}, {"tag": "Not Applicable", "count": 162}, {"tag": "Issue Tracking", "count": 50}, {"tag": "Product", "count": 24}, {"tag": "Tool Signature", "count": 10}, {"tag": "Release Notes", "count": 8}, {"tag": "Technical Description", "count": 4}, {"tag": "Mitigation", "count": 2}]}}, "2006": {"year": 2006, "total_cves": 6608, "date_data": {"monthly_distribution": {"1": 381, "2": 448, "3": 543, "4": 575, "5": 583, "6": 629, "7": 529, "8": 538, "9": 550, "10": 546, "11": 507, "12": 779}, "daily_analysis": {"total_days": 287, "avg_per_day": 23.02, "highest_day": {"date": "2006-12-31", "count": 125}, "lowest_day": {"date": "2006-01-15", "count": 1}}}, "cvss": {"v2.0": {"total": 6608, "severity_distribution": {"UNKNOWN": 6608}, "score_distribution": {"7.5": 2041, "4.3": 707, "6.6": 10, "2.1": 144, "7.8": 117, "5.1": 374, "5.0": 1038, "7.2": 128, "4.6": 136, "10.0": 273, "4.0": 108, "3.6": 27, "9.3": 107, "4.9": 65, "3.5": 20, "6.5": 87, "2.6": 270, "5.8": 98, "6.4": 202, "9.0": 46, "5.5": 15, "7.1": 12, "6.8": 432, "7.6": 35, "1.2": 17, "6.2": 11, "4.4": 3, "1.5": 1, "1.7": 13, "3.2": 2, "3.7": 11, "6.9": 2, "1.9": 3, "3.3": 2, "9.7": 1, "6.0": 19, "4.7": 2, "5.4": 14, "5.6": 1, "2.3": 1, "8.3": 1, "5.7": 1, "6.1": 1, "4.1": 4, "2.7": 1, "2.4": 2, "6.3": 1, "2.9": 1, "7.9": 1}}, "v3.0": {"total": 2, "severity_distribution": {"HIGH": 1, "MEDIUM": 1}, "score_distribution": {"7.5": 1, "6.1": 1}}, "v3.1": {"total": 47, "severity_distribution": {"MEDIUM": 14, "HIGH": 22, "CRITICAL": 11}, "score_distribution": {"6.1": 2, "5.3": 1, "5.6": 1, "8.4": 1, "7.5": 11, "5.5": 7, "7.3": 1, "8.8": 3, "9.8": 11, "7.8": 3, "8.1": 2, "7.2": 1, "6.5": 3}}, "epss_summary": {"epss_gt_0_1": 524, "epss_gt_0_5": 106, "epss_gt_0_9": 4}}, "kev": {"kev_count": 2}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 272}, {"name": "Oracle", "count": 164}, {"name": "Apple", "count": 140}, {"name": "Mozilla", "count": 122}, {"name": "Linux", "count": 91}, {"name": "Ibm", "count": 90}, {"name": "Sun", "count": 86}, {"name": "Cisco", "count": 69}, {"name": "Joomla", "count": 53}, {"name": "Novell", "count": 46}, {"name": "Php", "count": 42}, {"name": "Mybulletinboard", "count": 42}, {"name": "Symantec", "count": 41}, {"name": "Hp", "count": 39}, {"name": "Drupal", "count": 37}, {"name": "Adobe", "count": 32}, {"name": "Debian", "count": 31}, {"name": "Xerox", "count": 31}, {"name": "Mambo", "count": 29}, {"name": "Phpbb Group", "count": 28}]}, "cwe": {"top_cwes": [{"cwe": "CWE-94", "count": 184}, {"cwe": "CWE-119", "count": 144}, {"cwe": "CWE-79", "count": 122}, {"cwe": "CWE-89", "count": 100}, {"cwe": "CWE-399", "count": 75}, {"cwe": "CWE-20", "count": 53}, {"cwe": "CWE-264", "count": 51}, {"cwe": "CWE-189", "count": 35}, {"cwe": "CWE-200", "count": 31}, {"cwe": "CWE-22", "count": 24}, {"cwe": "CWE-134", "count": 17}, {"cwe": "CWE-287", "count": 13}, {"cwe": "CWE-88", "count": 9}, {"cwe": "CWE-310", "count": 6}, {"cwe": "CWE-120", "count": 6}, {"cwe": "CWE-400", "count": 6}, {"cwe": "CWE-362", "count": 6}, {"cwe": "CWE-787", "count": 6}, {"cwe": "CWE-16", "count": 5}, {"cwe": "CWE-255", "count": 5}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 6598}, {"status": "Analyzed", "count": 10}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 15948}, {"tag": "Patch", "count": 9344}, {"tag": "Exploit", "count": 8026}, {"tag": "Third Party Advisory", "count": 3066}, {"tag": "US Government Resource", "count": 1764}, {"tag": "Broken Link", "count": 1490}, {"tag": "VDB Entry", "count": 836}, {"tag": "URL Repurposed", "count": 354}, {"tag": "Permissions Required", "count": 234}, {"tag": "Not Applicable", "count": 132}, {"tag": "Mailing List", "count": 128}, {"tag": "Issue Tracking", "count": 46}, {"tag": "Release Notes", "count": 22}, {"tag": "Product", "count": 14}, {"tag": "Tool Signature", "count": 4}]}}, "2007": {"year": 2007, "total_cves": 6516, "date_data": {"monthly_distribution": {"1": 594, "2": 534, "3": 704, "4": 627, "5": 565, "6": 563, "7": 571, "8": 522, "9": 434, "10": 546, "11": 421, "12": 435}, "daily_analysis": {"total_days": 270, "avg_per_day": 24.13, "highest_day": {"date": "2007-03-02", "count": 114}, "lowest_day": {"date": "2007-01-01", "count": 1}}}, "cvss": {"v2.0": {"total": 6516, "severity_distribution": {"UNKNOWN": 6516}, "score_distribution": {"10.0": 475, "6.8": 795, "2.1": 80, "7.5": 1509, "5.0": 665, "7.8": 356, "5.1": 27, "9.4": 16, "4.6": 71, "4.3": 941, "7.1": 93, "7.2": 147, "4.0": 43, "4.9": 70, "5.8": 66, "1.2": 5, "2.6": 38, "6.4": 97, "6.0": 59, "9.3": 442, "4.4": 34, "3.5": 49, "8.5": 28, "6.6": 25, "4.1": 5, "6.5": 87, "5.5": 20, "1.9": 21, "6.9": 59, "9.0": 49, "7.6": 41, "3.7": 4, "3.2": 1, "1.7": 4, "6.2": 16, "1.5": 4, "3.3": 12, "2.9": 2, "5.4": 9, "3.6": 8, "4.7": 14, "6.1": 7, "7.3": 1, "5.2": 1, "6.3": 6, "3.4": 1, "3.8": 1, "7.9": 1, "7.4": 1, "8.3": 3, "1.8": 1, "2.3": 2, "8.8": 3, "5.7": 1}}, "v3.0": {"total": 1, "severity_distribution": {"MEDIUM": 1}, "score_distribution": {"5.9": 1}}, "v3.1": {"total": 59, "severity_distribution": {"HIGH": 26, "CRITICAL": 21, "MEDIUM": 12}, "score_distribution": {"7.5": 15, "9.8": 20, "6.5": 1, "7.8": 6, "8.8": 3, "5.4": 1, "9.1": 1, "5.5": 3, "6.1": 4, "5.3": 2, "4.6": 1, "8.1": 2}}, "epss_summary": {"epss_gt_0_1": 665, "epss_gt_0_5": 121, "epss_gt_0_9": 3}}, "kev": {"kev_count": 2}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 343}, {"name": "Apple", "count": 238}, {"name": "Ibm", "count": 148}, {"name": "Oracle", "count": 141}, {"name": "Sun", "count": 136}, {"name": "Php", "count": 116}, {"name": "Cisco", "count": 113}, {"name": "Linux", "count": 105}, {"name": "Mozilla", "count": 89}, {"name": "Hp", "count": 85}, {"name": "Debian", "count": 68}, {"name": "Joomla", "count": 59}, {"name": "Redhat", "count": 58}, {"name": "Canonical", "count": 49}, {"name": "Wordpress", "count": 48}, {"name": "Broadcom", "count": 47}, {"name": "Symantec", "count": 46}, {"name": "Apache", "count": 45}, {"name": "Bea", "count": 40}, {"name": "Hitachi", "count": 37}]}, "cwe": {"top_cwes": [{"cwe": "CWE-119", "count": 431}, {"cwe": "CWE-79", "count": 361}, {"cwe": "CWE-94", "count": 308}, {"cwe": "CWE-89", "count": 256}, {"cwe": "CWE-20", "count": 237}, {"cwe": "CWE-264", "count": 217}, {"cwe": "CWE-22", "count": 165}, {"cwe": "CWE-200", "count": 101}, {"cwe": "CWE-399", "count": 98}, {"cwe": "CWE-189", "count": 88}, {"cwe": "CWE-287", "count": 68}, {"cwe": "CWE-352", "count": 37}, {"cwe": "CWE-16", "count": 32}, {"cwe": "CWE-134", "count": 30}, {"cwe": "CWE-310", "count": 24}, {"cwe": "CWE-255", "count": 23}, {"cwe": "CWE-59", "count": 23}, {"cwe": "CWE-362", "count": 17}, {"cwe": "CWE-190", "count": 9}, {"cwe": "CWE-787", "count": 7}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 6506}, {"status": "Analyzed", "count": 10}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 11817}, {"tag": "Patch", "count": 6274}, {"tag": "Third Party Advisory", "count": 5058}, {"tag": "Exploit", "count": 4150}, {"tag": "Broken Link", "count": 2154}, {"tag": "US Government Resource", "count": 1538}, {"tag": "VDB Entry", "count": 1358}, {"tag": "Permissions Required", "count": 242}, {"tag": "Mailing List", "count": 240}, {"tag": "Not Applicable", "count": 200}, {"tag": "URL Repurposed", "count": 134}, {"tag": "Issue Tracking", "count": 102}, {"tag": "Release Notes", "count": 28}, {"tag": "Technical Description", "count": 16}, {"tag": "Tool Signature", "count": 14}, {"tag": "Product", "count": 4}]}}, "2008": {"year": 2008, "total_cves": 5632, "date_data": {"monthly_distribution": {"1": 497, "2": 524, "3": 506, "4": 454, "5": 383, "6": 435, "7": 517, "8": 367, "9": 449, "10": 524, "11": 448, "12": 528}, "daily_analysis": {"total_days": 255, "avg_per_day": 22.09, "highest_day": {"date": "2008-02-12", "count": 88}, "lowest_day": {"date": "2008-06-09", "count": 1}}}, "cvss": {"v2.0": {"total": 5632, "severity_distribution": {"UNKNOWN": 5632}, "score_distribution": {"4.6": 56, "10.0": 425, "5.0": 521, "4.3": 964, "6.4": 66, "6.8": 468, "7.5": 1425, "5.8": 41, "6.5": 87, "9.3": 513, "4.0": 42, "3.5": 45, "7.1": 69, "7.2": 141, "2.1": 61, "7.8": 149, "8.5": 28, "6.9": 147, "6.2": 7, "5.1": 25, "2.6": 33, "3.3": 7, "9.0": 63, "4.9": 67, "4.4": 22, "1.9": 16, "6.3": 8, "8.8": 5, "3.6": 12, "6.0": 28, "5.5": 17, "6.6": 6, "4.7": 22, "7.9": 1, "3.7": 5, "9.4": 4, "5.4": 6, "1.7": 3, "7.6": 15, "4.1": 1, "4.8": 1, "8.3": 3, "1.5": 1, "1.2": 2, "6.1": 1, "1.0": 2, "3.2": 1}}, "v3.0": {"total": 1, "severity_distribution": {"CRITICAL": 1}, "score_distribution": {"9.8": 1}}, "v3.1": {"total": 87, "severity_distribution": {"HIGH": 46, "MEDIUM": 22, "CRITICAL": 18, "LOW": 1}, "score_distribution": {"7.8": 8, "5.3": 3, "9.8": 16, "5.5": 6, "7.5": 23, "8.8": 8, "6.1": 8, "8.1": 5, "6.8": 1, "9.1": 2, "4.4": 1, "6.5": 2, "8.4": 1, "5.9": 1, "3.7": 1, "7.0": 1}}, "epss_summary": {"epss_gt_0_1": 562, "epss_gt_0_5": 92, "epss_gt_0_9": 7}}, "kev": {"kev_count": 6}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 337}, {"name": "Apple", "count": 228}, {"name": "Sun", "count": 160}, {"name": "Ibm", "count": 148}, {"name": "Oracle", "count": 130}, {"name": "Joomla", "count": 119}, {"name": "Debian", "count": 114}, {"name": "Mozilla", "count": 102}, {"name": "Linux", "count": 98}, {"name": "Cisco", "count": 94}, {"name": "Redhat", "count": 81}, {"name": "Canonical", "count": 77}, {"name": "Drupal", "count": 73}, {"name": "Hp", "count": 72}, {"name": "Adobe", "count": 65}, {"name": "Typo3", "count": 53}, {"name": "Wordpress", "count": 52}, {"name": "Novell", "count": 50}, {"name": "Mambo", "count": 48}, {"name": "Opera", "count": 35}]}, "cwe": {"top_cwes": [{"cwe": "CWE-89", "count": 1093}, {"cwe": "CWE-79", "count": 797}, {"cwe": "CWE-119", "count": 554}, {"cwe": "CWE-264", "count": 433}, {"cwe": "CWE-20", "count": 381}, {"cwe": "CWE-22", "count": 352}, {"cwe": "CWE-94", "count": 312}, {"cwe": "CWE-399", "count": 285}, {"cwe": "CWE-200", "count": 193}, {"cwe": "CWE-59", "count": 174}, {"cwe": "CWE-189", "count": 142}, {"cwe": "CWE-287", "count": 140}, {"cwe": "CWE-352", "count": 80}, {"cwe": "CWE-255", "count": 49}, {"cwe": "CWE-310", "count": 34}, {"cwe": "CWE-16", "count": 34}, {"cwe": "CWE-134", "count": 24}, {"cwe": "CWE-362", "count": 24}, {"cwe": "CWE-190", "count": 13}, {"cwe": "CWE-120", "count": 8}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 5621}, {"status": "Analyzed", "count": 11}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 9746}, {"tag": "Third Party Advisory", "count": 8735}, {"tag": "Exploit", "count": 4872}, {"tag": "Patch", "count": 4100}, {"tag": "Broken Link", "count": 2270}, {"tag": "VDB Entry", "count": 2130}, {"tag": "US Government Resource", "count": 1285}, {"tag": "Mailing List", "count": 696}, {"tag": "Permissions Required", "count": 396}, {"tag": "Not Applicable", "count": 346}, {"tag": "Issue Tracking", "count": 232}, {"tag": "URL Repurposed", "count": 160}, {"tag": "Release Notes", "count": 26}, {"tag": "Tool Signature", "count": 24}, {"tag": "Product", "count": 17}, {"tag": "Technical Description", "count": 6}, {"tag": "Mitigation", "count": 4}, {"tag": "Press/Media Coverage", "count": 2}]}}, "2009": {"year": 2009, "total_cves": 5732, "date_data": {"monthly_distribution": {"1": 466, "2": 685, "3": 553, "4": 567, "5": 364, "6": 450, "7": 446, "8": 527, "9": 574, "10": 352, "11": 308, "12": 440}, "daily_analysis": {"total_days": 263, "avg_per_day": 21.79, "highest_day": {"date": "2009-02-10", "count": 75}, "lowest_day": {"date": "2009-04-04", "count": 1}}}, "cvss": {"v2.0": {"total": 5732, "severity_distribution": {"UNKNOWN": 5732}, "score_distribution": {"7.6": 13, "5.0": 672, "7.5": 1320, "5.8": 62, "3.5": 65, "9.3": 618, "10.0": 371, "4.3": 961, "4.9": 97, "9.0": 42, "6.8": 493, "2.6": 34, "7.8": 172, "4.6": 40, "4.0": 68, "6.5": 109, "5.1": 37, "6.4": 44, "1.7": 3, "5.5": 39, "2.1": 62, "1.2": 2, "7.1": 49, "7.2": 109, "6.0": 50, "6.9": 56, "5.4": 15, "4.7": 18, "8.5": 14, "4.4": 31, "8.8": 6, "6.2": 5, "1.9": 15, "9.4": 1, "6.3": 4, "3.7": 2, "3.3": 8, "6.1": 2, "3.6": 8, "6.6": 3, "7.3": 2, "5.7": 1, "4.1": 2, "3.0": 1, "1.5": 1, "8.3": 1, "5.9": 2, "4.8": 1, "2.7": 1}}, "v3.0": {"total": 1, "severity_distribution": {"MEDIUM": 1}, "score_distribution": {"4.2": 1}}, "v3.1": {"total": 107, "severity_distribution": {"HIGH": 69, "CRITICAL": 15, "MEDIUM": 23}, "score_distribution": {"7.5": 19, "9.8": 14, "7.8": 21, "8.8": 18, "5.5": 11, "8.1": 6, "6.5": 7, "5.4": 1, "4.7": 1, "6.1": 1, "5.9": 2, "7.2": 1, "7.1": 3, "9.9": 1, "7.0": 1}}, "epss_summary": {"epss_gt_0_1": 524, "epss_gt_0_5": 85, "epss_gt_0_9": 8}}, "kev": {"kev_count": 14}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 330}, {"name": "Apple", "count": 238}, {"name": "Sun", "count": 221}, {"name": "Ibm", "count": 172}, {"name": "Oracle", "count": 171}, {"name": "Mozilla", "count": 149}, {"name": "Joomla", "count": 145}, {"name": "Drupal", "count": 144}, {"name": "Linux", "count": 128}, {"name": "Cisco", "count": 110}, {"name": "Adobe", "count": 98}, {"name": "Typo3", "count": 93}, {"name": "Hp", "count": 78}, {"name": "Debian", "count": 59}, {"name": "Canonical", "count": 57}, {"name": "Google", "count": 47}, {"name": "Redhat", "count": 44}, {"name": "Fedoraproject", "count": 43}, {"name": "Apache", "count": 41}, {"name": "Opensuse", "count": 39}]}, "cwe": {"top_cwes": [{"cwe": "CWE-89", "count": 948}, {"cwe": "CWE-79", "count": 822}, {"cwe": "CWE-119", "count": 549}, {"cwe": "CWE-264", "count": 412}, {"cwe": "CWE-94", "count": 326}, {"cwe": "CWE-22", "count": 322}, {"cwe": "CWE-20", "count": 302}, {"cwe": "CWE-399", "count": 215}, {"cwe": "CWE-287", "count": 209}, {"cwe": "CWE-200", "count": 161}, {"cwe": "CWE-189", "count": 149}, {"cwe": "CWE-352", "count": 114}, {"cwe": "CWE-310", "count": 79}, {"cwe": "CWE-255", "count": 64}, {"cwe": "CWE-16", "count": 49}, {"cwe": "CWE-362", "count": 33}, {"cwe": "CWE-59", "count": 32}, {"cwe": "CWE-134", "count": 28}, {"cwe": "CWE-78", "count": 18}, {"cwe": "CWE-787", "count": 18}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 5710}, {"status": "Analyzed", "count": 22}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 14892}, {"tag": "Patch", "count": 7642}, {"tag": "Exploit", "count": 6294}, {"tag": "Third Party Advisory", "count": 4931}, {"tag": "Broken Link", "count": 2600}, {"tag": "VDB Entry", "count": 1341}, {"tag": "US Government Resource", "count": 987}, {"tag": "Mailing List", "count": 960}, {"tag": "Issue Tracking", "count": 248}, {"tag": "Not Applicable", "count": 224}, {"tag": "Permissions Required", "count": 156}, {"tag": "URL Repurposed", "count": 138}, {"tag": "Tool Signature", "count": 46}, {"tag": "Release Notes", "count": 44}, {"tag": "Product", "count": 14}, {"tag": "Mitigation", "count": 4}, {"tag": "Press/Media Coverage", "count": 4}]}}, "2010": {"year": 2010, "total_cves": 4639, "date_data": {"monthly_distribution": {"1": 319, "2": 308, "3": 513, "4": 500, "5": 418, "6": 490, "7": 343, "8": 380, "9": 297, "10": 434, "11": 278, "12": 359}, "daily_analysis": {"total_days": 208, "avg_per_day": 22.3, "highest_day": {"date": "2010-10-14", "count": 91}, "lowest_day": {"date": "2010-01-27", "count": 2}}}, "cvss": {"v2.0": {"total": 4639, "severity_distribution": {"UNKNOWN": 4639}, "score_distribution": {"10.0": 252, "7.5": 771, "3.5": 55, "5.0": 504, "4.0": 95, "4.6": 37, "2.6": 42, "4.3": 808, "1.9": 32, "7.2": 97, "6.8": 392, "7.8": 115, "4.7": 20, "6.5": 45, "6.9": 97, "1.2": 2, "9.3": 742, "2.1": 97, "5.8": 44, "6.0": 32, "3.6": 11, "4.9": 44, "1.0": 2, "3.2": 6, "9.0": 37, "6.2": 10, "5.5": 28, "1.5": 2, "3.3": 19, "5.1": 26, "7.1": 30, "6.4": 43, "8.5": 15, "6.1": 4, "3.7": 2, "7.6": 21, "5.4": 4, "6.3": 3, "4.1": 1, "5.6": 3, "4.4": 20, "7.3": 1, "8.8": 1, "8.3": 5, "2.9": 2, "3.0": 3, "3.8": 1, "2.4": 2, "6.6": 8, "5.7": 3, "1.7": 1, "8.0": 1, "2.7": 1}}, "v3.0": {"total": 3, "severity_distribution": {"LOW": 2, "MEDIUM": 1}, "score_distribution": {"3.7": 2, "6.3": 1}}, "v3.1": {"total": 124, "severity_distribution": {"CRITICAL": 28, "HIGH": 77, "MEDIUM": 19}, "score_distribution": {"9.8": 28, "8.8": 30, "7.5": 11, "6.5": 7, "4.7": 1, "7.8": 24, "8.1": 6, "5.8": 1, "5.9": 1, "5.5": 7, "5.3": 1, "7.0": 1, "8.4": 2, "7.3": 2, "7.1": 1, "4.3": 1}}, "epss_summary": {"epss_gt_0_1": 563, "epss_gt_0_5": 98, "epss_gt_0_9": 12}}, "kev": {"kev_count": 23}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 597}, {"name": "Apple", "count": 442}, {"name": "Oracle", "count": 216}, {"name": "Joomla", "count": 211}, {"name": "Ibm", "count": 208}, {"name": "Adobe", "count": 207}, {"name": "Linux", "count": 193}, {"name": "Google", "count": 178}, {"name": "Cisco", "count": 155}, {"name": "Mozilla", "count": 129}, {"name": "Hp", "count": 122}, {"name": "Canonical", "count": 103}, {"name": "Sun", "count": 102}, {"name": "Typo3", "count": 98}, {"name": "Debian", "count": 90}, {"name": "Suse", "count": 72}, {"name": "Opensuse", "count": 72}, {"name": "Redhat", "count": 57}, {"name": "Realnetworks", "count": 55}, {"name": "Apache", "count": 51}]}, "cwe": {"top_cwes": [{"cwe": "CWE-79", "count": 595}, {"cwe": "CWE-89", "count": 515}, {"cwe": "CWE-119", "count": 506}, {"cwe": "CWE-264", "count": 333}, {"cwe": "CWE-20", "count": 284}, {"cwe": "CWE-22", "count": 276}, {"cwe": "CWE-94", "count": 253}, {"cwe": "CWE-399", "count": 194}, {"cwe": "CWE-200", "count": 158}, {"cwe": "CWE-189", "count": 132}, {"cwe": "CWE-287", "count": 76}, {"cwe": "CWE-352", "count": 75}, {"cwe": "CWE-310", "count": 67}, {"cwe": "CWE-255", "count": 50}, {"cwe": "CWE-787", "count": 33}, {"cwe": "CWE-362", "count": 33}, {"cwe": "CWE-416", "count": 31}, {"cwe": "CWE-59", "count": 25}, {"cwe": "CWE-16", "count": 24}, {"cwe": "CWE-190", "count": 19}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 4614}, {"status": "Analyzed", "count": 25}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 11703}, {"tag": "Third Party Advisory", "count": 6930}, {"tag": "Exploit", "count": 5586}, {"tag": "Patch", "count": 4834}, {"tag": "Mailing List", "count": 1936}, {"tag": "Broken Link", "count": 1917}, {"tag": "US Government Resource", "count": 1184}, {"tag": "VDB Entry", "count": 1040}, {"tag": "Issue Tracking", "count": 548}, {"tag": "Permissions Required", "count": 222}, {"tag": "Not Applicable", "count": 152}, {"tag": "Release Notes", "count": 126}, {"tag": "URL Repurposed", "count": 56}, {"tag": "Tool Signature", "count": 44}, {"tag": "Product", "count": 16}, {"tag": "Press/Media Coverage", "count": 16}, {"tag": "Mitigation", "count": 2}]}}, "2011": {"year": 2011, "total_cves": 4150, "date_data": {"monthly_distribution": {"1": 396, "2": 377, "3": 355, "4": 312, "5": 295, "6": 294, "7": 307, "8": 294, "9": 387, "10": 484, "11": 309, "12": 340}, "daily_analysis": {"total_days": 218, "avg_per_day": 19.04, "highest_day": {"date": "2011-02-10", "count": 95}, "lowest_day": {"date": "2011-04-14", "count": 1}}}, "cvss": {"v2.0": {"total": 4150, "severity_distribution": {"UNKNOWN": 4150}, "score_distribution": {"2.1": 70, "4.3": 685, "5.0": 613, "6.8": 318, "4.0": 88, "4.6": 19, "6.5": 41, "6.0": 25, "3.5": 58, "5.8": 57, "8.5": 11, "7.5": 507, "7.6": 97, "7.8": 119, "10.0": 380, "6.9": 48, "6.4": 37, "3.3": 29, "1.9": 21, "2.6": 34, "7.1": 19, "5.4": 3, "4.1": 3, "1.7": 9, "9.3": 480, "4.9": 44, "4.7": 12, "5.1": 14, "9.0": 26, "7.2": 121, "5.5": 43, "7.9": 5, "4.4": 22, "3.6": 17, "9.4": 1, "1.0": 1, "5.7": 6, "6.2": 8, "6.1": 5, "1.2": 8, "3.7": 6, "8.3": 6, "8.0": 1, "8.8": 4, "6.3": 12, "3.0": 1, "6.6": 2, "1.5": 3, "8.2": 1, "1.3": 1, "5.2": 1, "7.4": 1, "5.6": 2, "7.7": 1, "2.4": 1, "2.8": 1, "1.8": 1, "3.2": 1}}, "v3.0": {"total": 3, "severity_distribution": {"MEDIUM": 2, "HIGH": 1}, "score_distribution": {"6.5": 1, "7.5": 1, "5.3": 1}}, "v3.1": {"total": 58, "severity_distribution": {"MEDIUM": 12, "HIGH": 41, "CRITICAL": 5}, "score_distribution": {"6.8": 1, "7.5": 12, "5.5": 1, "7.8": 12, "8.1": 1, "6.1": 3, "5.3": 2, "7.4": 1, "8.8": 8, "9.8": 5, "8.4": 4, "7.7": 1, "5.9": 1, "6.5": 3, "7.1": 1, "7.3": 1, "5.7": 1}}, "epss_summary": {"epss_gt_0_1": 480, "epss_gt_0_5": 84, "epss_gt_0_9": 6}}, "kev": {"kev_count": 9}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 520}, {"name": "Apple", "count": 408}, {"name": "Google", "count": 344}, {"name": "Oracle", "count": 258}, {"name": "Adobe", "count": 202}, {"name": "Ibm", "count": 176}, {"name": "Cisco", "count": 167}, {"name": "Linux", "count": 156}, {"name": "Hp", "count": 145}, {"name": "Sun", "count": 144}, {"name": "Mozilla", "count": 123}, {"name": "Redhat", "count": 91}, {"name": "Novell", "count": 82}, {"name": "Joomla", "count": 73}, {"name": "Debian", "count": 72}, {"name": "Opera", "count": 56}, {"name": "Apache", "count": 54}, {"name": "Parallels", "count": 53}, {"name": "Wordpress", "count": 46}, {"name": "Canonical", "count": 43}]}, "cwe": {"top_cwes": [{"cwe": "CWE-119", "count": 580}, {"cwe": "CWE-79", "count": 461}, {"cwe": "CWE-20", "count": 356}, {"cwe": "CWE-200", "count": 293}, {"cwe": "CWE-89", "count": 289}, {"cwe": "CWE-399", "count": 282}, {"cwe": "CWE-264", "count": 250}, {"cwe": "CWE-22", "count": 106}, {"cwe": "CWE-189", "count": 105}, {"cwe": "CWE-94", "count": 102}, {"cwe": "CWE-310", "count": 58}, {"cwe": "CWE-416", "count": 56}, {"cwe": "CWE-287", "count": 55}, {"cwe": "CWE-352", "count": 55}, {"cwe": "CWE-255", "count": 39}, {"cwe": "CWE-59", "count": 34}, {"cwe": "CWE-787", "count": 31}, {"cwe": "CWE-16", "count": 29}, {"cwe": "CWE-125", "count": 26}, {"cwe": "CWE-476", "count": 22}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 4141}, {"status": "Analyzed", "count": 9}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 8161}, {"tag": "Patch", "count": 5450}, {"tag": "Third Party Advisory", "count": 4486}, {"tag": "Exploit", "count": 3818}, {"tag": "US Government Resource", "count": 1163}, {"tag": "Mailing List", "count": 1152}, {"tag": "Broken Link", "count": 1122}, {"tag": "VDB Entry", "count": 1018}, {"tag": "Issue Tracking", "count": 521}, {"tag": "Permissions Required", "count": 166}, {"tag": "Not Applicable", "count": 100}, {"tag": "Release Notes", "count": 86}, {"tag": "URL Repurposed", "count": 66}, {"tag": "Tool Signature", "count": 54}, {"tag": "Product", "count": 8}, {"tag": "Press/Media Coverage", "count": 2}, {"tag": "Mitigation", "count": 2}]}}, "2012": {"year": 2012, "total_cves": 5288, "date_data": {"monthly_distribution": {"1": 314, "2": 343, "3": 403, "4": 228, "5": 425, "6": 405, "7": 536, "8": 735, "9": 655, "10": 553, "11": 436, "12": 255}, "daily_analysis": {"total_days": 283, "avg_per_day": 18.69, "highest_day": {"date": "2012-07-25", "count": 113}, "lowest_day": {"date": "2012-01-23", "count": 1}}}, "cvss": {"v2.0": {"total": 5288, "severity_distribution": {"UNKNOWN": 5288}, "score_distribution": {"5.0": 632, "7.5": 496, "4.3": 959, "2.1": 161, "6.8": 472, "6.2": 45, "6.5": 71, "1.9": 29, "9.3": 503, "6.0": 55, "2.6": 64, "3.5": 130, "4.0": 197, "4.9": 71, "3.3": 52, "4.6": 29, "5.8": 144, "6.4": 93, "10.0": 426, "8.5": 14, "3.6": 30, "6.9": 140, "5.1": 21, "7.8": 109, "4.4": 20, "6.1": 10, "5.5": 41, "7.2": 68, "7.1": 28, "7.6": 24, "7.9": 7, "5.4": 11, "6.3": 9, "4.7": 18, "8.3": 10, "1.2": 9, "7.4": 4, "3.7": 7, "1.7": 5, "2.7": 2, "3.0": 1, "9.0": 26, "2.9": 9, "7.7": 5, "3.2": 3, "1.8": 6, "5.9": 1, "6.6": 2, "5.2": 1, "5.6": 6, "2.3": 1, "2.8": 1, "5.7": 1, "8.8": 1, "9.4": 2, "0.0": 2, "1.5": 1, "5.3": 1, "4.8": 2}}, "v3.0": {"total": 1, "severity_distribution": {"MEDIUM": 1}, "score_distribution": {"6.8": 1}}, "v3.1": {"total": 115, "severity_distribution": {"MEDIUM": 43, "HIGH": 51, "CRITICAL": 21}, "score_distribution": {"5.3": 2, "7.0": 3, "4.5": 1, "4.8": 1, "9.8": 14, "5.9": 6, "7.8": 11, "8.8": 12, "5.5": 17, "7.5": 11, "6.0": 1, "9.1": 4, "6.5": 8, "8.1": 5, "6.1": 3, "8.4": 2, "7.2": 1, "9.9": 1, "7.4": 5, "5.8": 1, "9.6": 1, "7.3": 1, "6.7": 1, "4.7": 1, "9.0": 1, "5.4": 1}}, "epss_summary": {"epss_gt_0_1": 482, "epss_gt_0_5": 132, "epss_gt_0_9": 32}}, "kev": {"kev_count": 22}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Apple", "count": 478}, {"name": "Google", "count": 403}, {"name": "Oracle", "count": 393}, {"name": "Microsoft", "count": 376}, {"name": "Linux", "count": 227}, {"name": "Mozilla", "count": 205}, {"name": "Drupal", "count": 203}, {"name": "Ibm", "count": 175}, {"name": "Redhat", "count": 167}, {"name": "Cisco", "count": 160}, {"name": "Opensuse", "count": 150}, {"name": "Adobe", "count": 148}, {"name": "Canonical", "count": 119}, {"name": "Sun", "count": 115}, {"name": "Wordpress", "count": 104}, {"name": "Suse", "count": 99}, {"name": "Moodle", "count": 95}, {"name": "Debian", "count": 91}, {"name": "Hp", "count": 87}, {"name": "Apache", "count": 67}]}, "cwe": {"top_cwes": [{"cwe": "CWE-79", "count": 731}, {"cwe": "CWE-119", "count": 683}, {"cwe": "CWE-264", "count": 573}, {"cwe": "CWE-20", "count": 353}, {"cwe": "CWE-89", "count": 238}, {"cwe": "CWE-399", "count": 232}, {"cwe": "CWE-200", "count": 222}, {"cwe": "CWE-352", "count": 154}, {"cwe": "CWE-94", "count": 143}, {"cwe": "CWE-189", "count": 132}, {"cwe": "CWE-22", "count": 120}, {"cwe": "CWE-287", "count": 100}, {"cwe": "CWE-310", "count": 92}, {"cwe": "CWE-416", "count": 83}, {"cwe": "CWE-362", "count": 74}, {"cwe": "CWE-255", "count": 50}, {"cwe": "CWE-787", "count": 35}, {"cwe": "CWE-16", "count": 19}, {"cwe": "CWE-190", "count": 19}, {"cwe": "CWE-59", "count": 17}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 5256}, {"status": "Analyzed", "count": 32}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 9377}, {"tag": "Third Party Advisory", "count": 7308}, {"tag": "Exploit", "count": 3974}, {"tag": "Patch", "count": 3674}, {"tag": "Mailing List", "count": 1765}, {"tag": "VDB Entry", "count": 1552}, {"tag": "Broken Link", "count": 1372}, {"tag": "US Government Resource", "count": 1144}, {"tag": "Issue Tracking", "count": 525}, {"tag": "Not Applicable", "count": 436}, {"tag": "Release Notes", "count": 155}, {"tag": "Permissions Required", "count": 58}, {"tag": "URL Repurposed", "count": 36}, {"tag": "Tool Signature", "count": 22}, {"tag": "Mitigation", "count": 17}, {"tag": "Press/Media Coverage", "count": 16}, {"tag": "Technical Description", "count": 6}, {"tag": "Product", "count": 2}]}}, "2013": {"year": 2013, "total_cves": 5187, "date_data": {"monthly_distribution": {"1": 439, "2": 405, "3": 430, "4": 438, "5": 356, "6": 360, "7": 470, "8": 374, "9": 454, "10": 583, "11": 394, "12": 484}, "daily_analysis": {"total_days": 294, "avg_per_day": 17.64, "highest_day": {"date": "2013-04-17", "count": 152}, "lowest_day": {"date": "2013-01-08", "count": 1}}}, "cvss": {"v2.0": {"total": 5187, "severity_distribution": {"UNKNOWN": 5187}, "score_distribution": {"5.0": 558, "5.8": 123, "7.2": 107, "6.8": 446, "4.0": 217, "7.5": 404, "10.0": 438, "7.4": 5, "9.3": 425, "3.7": 10, "4.3": 881, "7.1": 66, "6.9": 76, "2.6": 36, "1.9": 59, "3.6": 16, "4.9": 115, "6.2": 30, "4.6": 49, "5.1": 24, "6.0": 42, "3.3": 39, "7.8": 162, "5.7": 9, "2.1": 131, "6.1": 19, "5.5": 35, "6.4": 61, "4.4": 30, "2.7": 4, "3.5": 170, "9.0": 44, "6.3": 19, "5.2": 12, "6.5": 82, "1.5": 9, "1.2": 4, "8.5": 24, "7.9": 10, "7.6": 31, "8.8": 3, "3.2": 3, "8.2": 1, "5.4": 30, "6.6": 18, "2.4": 2, "2.9": 25, "4.7": 50, "6.7": 1, "5.9": 2, "1.7": 5, "2.8": 1, "3.8": 3, "3.0": 1, "8.3": 8, "2.3": 2, "9.4": 4, "8.0": 2, "7.7": 1, "0.0": 1, "7.0": 1, "4.1": 1}}, "v3.0": {"total": 3, "severity_distribution": {"MEDIUM": 2, "HIGH": 1}, "score_distribution": {"5.9": 1, "6.1": 1, "7.5": 1}}, "v3.1": {"total": 98, "severity_distribution": {"HIGH": 54, "MEDIUM": 20, "CRITICAL": 23, "LOW": 1}, "score_distribution": {"7.5": 13, "5.5": 6, "9.8": 19, "6.5": 3, "5.3": 2, "10.0": 1, "4.8": 1, "9.1": 1, "8.8": 13, "5.4": 2, "9.0": 1, "7.0": 5, "7.4": 2, "7.8": 12, "5.9": 2, "7.6": 1, "6.1": 2, "3.7": 1, "8.4": 3, "7.3": 2, "8.1": 3, "6.3": 1, "5.0": 1, "9.3": 1}}, "epss_summary": {"epss_gt_0_1": 557, "epss_gt_0_5": 123, "epss_gt_0_9": 12}}, "kev": {"kev_count": 35}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 516}, {"name": "Oracle", "count": 515}, {"name": "Cisco", "count": 436}, {"name": "Ibm", "count": 390}, {"name": "Apple", "count": 298}, {"name": "Redhat", "count": 288}, {"name": "Linux", "count": 280}, {"name": "Google", "count": 252}, {"name": "Opensuse", "count": 236}, {"name": "Canonical", "count": 202}, {"name": "Sun", "count": 169}, {"name": "Mozilla", "count": 167}, {"name": "Adobe", "count": 148}, {"name": "Hp", "count": 146}, {"name": "Debian", "count": 124}, {"name": "Drupal", "count": 90}, {"name": "Suse", "count": 88}, {"name": "Wireshark", "count": 82}, {"name": "Apache", "count": 79}, {"name": "Ffmpeg", "count": 78}]}, "cwe": {"top_cwes": [{"cwe": "CWE-119", "count": 734}, {"cwe": "CWE-79", "count": 617}, {"cwe": "CWE-264", "count": 556}, {"cwe": "CWE-20", "count": 494}, {"cwe": "CWE-399", "count": 261}, {"cwe": "CWE-200", "count": 247}, {"cwe": "CWE-89", "count": 146}, {"cwe": "CWE-94", "count": 143}, {"cwe": "CWE-189", "count": 130}, {"cwe": "CWE-310", "count": 124}, {"cwe": "CWE-352", "count": 120}, {"cwe": "CWE-287", "count": 111}, {"cwe": "CWE-22", "count": 103}, {"cwe": "CWE-255", "count": 86}, {"cwe": "CWE-362", "count": 70}, {"cwe": "CWE-416", "count": 46}, {"cwe": "CWE-78", "count": 33}, {"cwe": "CWE-787", "count": 24}, {"cwe": "CWE-59", "count": 21}, {"cwe": "CWE-16", "count": 20}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 5152}, {"status": "Analyzed", "count": 35}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 9216}, {"tag": "Third Party Advisory", "count": 5248}, {"tag": "Patch", "count": 2918}, {"tag": "Exploit", "count": 2290}, {"tag": "US Government Resource", "count": 1659}, {"tag": "Mailing List", "count": 1498}, {"tag": "VDB Entry", "count": 788}, {"tag": "Broken Link", "count": 714}, {"tag": "Issue Tracking", "count": 456}, {"tag": "Not Applicable", "count": 162}, {"tag": "Permissions Required", "count": 40}, {"tag": "Release Notes", "count": 34}, {"tag": "URL Repurposed", "count": 20}, {"tag": "Technical Description", "count": 14}, {"tag": "Mitigation", "count": 10}, {"tag": "Tool Signature", "count": 8}, {"tag": "Product", "count": 4}, {"tag": "Press/Media Coverage", "count": 2}]}}, "2014": {"year": 2014, "total_cves": 7928, "date_data": {"monthly_distribution": {"1": 558, "2": 431, "3": 544, "4": 672, "5": 550, "6": 445, "7": 653, "8": 401, "9": 1146, "10": 1413, "11": 501, "12": 614}, "daily_analysis": {"total_days": 322, "avg_per_day": 24.62, "highest_day": {"date": "2014-09-09", "count": 326}, "lowest_day": {"date": "2014-01-01", "count": 1}}}, "cvss": {"v2.0": {"total": 7928, "severity_distribution": {"UNKNOWN": 7928}, "score_distribution": {"2.1": 182, "7.5": 727, "9.3": 406, "4.9": 113, "4.4": 41, "5.8": 144, "4.0": 294, "4.7": 25, "4.3": 1224, "6.4": 93, "1.9": 43, "6.2": 13, "5.0": 881, "6.0": 55, "3.3": 46, "6.8": 557, "7.8": 141, "3.5": 272, "5.5": 51, "7.7": 3, "6.1": 20, "4.6": 74, "3.6": 23, "5.7": 6, "2.6": 37, "6.5": 202, "6.9": 58, "6.3": 20, "5.4": 1416, "10.0": 338, "3.7": 5, "8.5": 33, "7.4": 3, "7.2": 94, "1.8": 4, "4.8": 4, "2.8": 6, "5.1": 16, "7.1": 75, "1.7": 5, "2.7": 7, "3.2": 4, "5.2": 8, "1.2": 4, "8.3": 18, "9.0": 56, "9.4": 4, "8.8": 1, "4.1": 8, "7.6": 22, "3.8": 1, "2.9": 9, "7.9": 6, "2.4": 5, "6.6": 7, "5.6": 1, "2.3": 4, "3.0": 2, "7.0": 1, "6.7": 1, "9.7": 2, "8.0": 1, "8.2": 2, "1.4": 1, "1.0": 2, "1.5": 1}}, "v3.0": {"total": 10, "severity_distribution": {"CRITICAL": 1, "MEDIUM": 4, "HIGH": 4, "LOW": 1}, "score_distribution": {"9.8": 1, "4.9": 1, "5.6": 1, "5.5": 1, "7.8": 3, "3.3": 1, "8.1": 1, "6.1": 1}}, "v3.1": {"total": 113, "severity_distribution": {"HIGH": 52, "MEDIUM": 40, "CRITICAL": 19, "LOW": 2}, "score_distribution": {"7.2": 1, "6.1": 5, "5.5": 13, "6.5": 11, "5.4": 2, "4.9": 1, "8.1": 2, "9.8": 17, "8.4": 1, "8.8": 21, "9.1": 2, "7.3": 3, "7.5": 9, "4.6": 1, "7.4": 2, "5.9": 1, "4.2": 1, "7.8": 12, "7.1": 1, "6.8": 1, "4.0": 1, "5.3": 1, "4.7": 2, "3.4": 1, "3.3": 1}}, "epss_summary": {"epss_gt_0_1": 717, "epss_gt_0_5": 135, "epss_gt_0_9": 21}}, "kev": {"kev_count": 34}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 524}, {"name": "Oracle", "count": 508}, {"name": "Ibm", "count": 465}, {"name": "Apple", "count": 434}, {"name": "Cisco", "count": 368}, {"name": "Redhat", "count": 300}, {"name": "Canonical", "count": 256}, {"name": "Debian", "count": 248}, {"name": "Linux", "count": 234}, {"name": "Opensuse", "count": 225}, {"name": "Google", "count": 199}, {"name": "Adobe", "count": 141}, {"name": "Suse", "count": 135}, {"name": "Mozilla", "count": 122}, {"name": "Hp", "count": 104}, {"name": "Fedoraproject", "count": 97}, {"name": "Apache", "count": 92}, {"name": "Sap", "count": 83}, {"name": "Owncloud", "count": 58}, {"name": "Wordpress", "count": 56}]}, "cwe": {"top_cwes": [{"cwe": "CWE-310", "count": 1580}, {"cwe": "CWE-79", "count": 1035}, {"cwe": "CWE-119", "count": 746}, {"cwe": "CWE-264", "count": 679}, {"cwe": "CWE-20", "count": 546}, {"cwe": "CWE-200", "count": 358}, {"cwe": "CWE-89", "count": 299}, {"cwe": "CWE-352", "count": 248}, {"cwe": "CWE-399", "count": 227}, {"cwe": "CWE-22", "count": 205}, {"cwe": "CWE-94", "count": 190}, {"cwe": "CWE-287", "count": 148}, {"cwe": "CWE-255", "count": 113}, {"cwe": "CWE-189", "count": 101}, {"cwe": "CWE-59", "count": 60}, {"cwe": "CWE-78", "count": 51}, {"cwe": "CWE-362", "count": 43}, {"cwe": "CWE-416", "count": 33}, {"cwe": "CWE-284", "count": 22}, {"cwe": "CWE-17", "count": 21}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 7894}, {"status": "Analyzed", "count": 34}], "cve_tags": [], "reference_tags": [{"tag": "Third Party Advisory", "count": 13166}, {"tag": "Vendor Advisory", "count": 10147}, {"tag": "US Government Resource", "count": 6334}, {"tag": "Exploit", "count": 5479}, {"tag": "Patch", "count": 4053}, {"tag": "VDB Entry", "count": 2620}, {"tag": "Mailing List", "count": 2300}, {"tag": "Broken Link", "count": 1589}, {"tag": "Issue Tracking", "count": 963}, {"tag": "Not Applicable", "count": 690}, {"tag": "Permissions Required", "count": 246}, {"tag": "Release Notes", "count": 108}, {"tag": "URL Repurposed", "count": 34}, {"tag": "Mitigation", "count": 18}, {"tag": "Technical Description", "count": 18}, {"tag": "Press/Media Coverage", "count": 8}, {"tag": "Tool Signature", "count": 4}, {"tag": "Product", "count": 2}]}}, "2015": {"year": 2015, "total_cves": 6494, "date_data": {"monthly_distribution": {"1": 713, "2": 486, "3": 453, "4": 538, "5": 410, "6": 495, "7": 635, "8": 619, "9": 493, "10": 726, "11": 361, "12": 565}, "daily_analysis": {"total_days": 313, "avg_per_day": 20.75, "highest_day": {"date": "2015-07-16", "count": 172}, "lowest_day": {"date": "2015-02-22", "count": 1}}}, "cvss": {"v2.0": {"total": 6494, "severity_distribution": {"UNKNOWN": 6494}, "score_distribution": {"10.0": 611, "4.3": 982, "6.8": 741, "7.5": 651, "9.3": 468, "6.4": 82, "5.0": 827, "5.8": 92, "8.8": 4, "6.5": 166, "7.2": 259, "3.5": 255, "6.3": 7, "4.6": 55, "2.1": 182, "3.3": 27, "7.8": 163, "5.1": 12, "3.7": 5, "5.4": 9, "2.6": 37, "4.0": 257, "5.5": 37, "6.9": 94, "9.0": 76, "4.9": 76, "1.9": 37, "7.1": 50, "6.1": 27, "6.6": 11, "8.5": 29, "3.2": 6, "7.6": 9, "6.0": 31, "4.7": 12, "8.3": 11, "3.6": 17, "4.4": 16, "1.2": 4, "9.4": 6, "7.7": 4, "5.7": 5, "1.8": 2, "5.6": 3, "7.9": 5, "7.0": 2, "1.5": 6, "1.7": 4, "2.8": 3, "2.7": 1, "2.9": 2, "8.7": 1, "6.2": 3, "4.8": 3, "3.8": 1, "8.0": 1, "1.3": 1, "7.3": 1, "4.1": 1, "9.7": 1, "7.4": 1, "2.3": 1, "5.9": 1}}, "v3.0": {"total": 139, "severity_distribution": {"MEDIUM": 47, "HIGH": 64, "LOW": 6, "CRITICAL": 22}, "score_distribution": {"5.3": 9, "7.5": 11, "3.7": 3, "6.5": 5, "9.8": 16, "7.8": 1, "7.3": 6, "6.1": 10, "4.3": 6, "8.3": 4, "8.6": 5, "10.0": 4, "8.0": 4, "6.8": 3, "6.7": 1, "9.1": 1, "7.2": 1, "8.8": 25, "9.9": 1, "8.5": 2, "8.7": 1, "5.9": 4, "6.9": 1, "4.4": 1, "2.3": 3, "5.8": 4, "4.0": 1, "8.4": 1, "6.3": 1, "7.4": 2, "4.9": 1, "8.1": 1}}, "v3.1": {"total": 96, "severity_distribution": {"MEDIUM": 13, "HIGH": 53, "CRITICAL": 28, "LOW": 2}, "score_distribution": {"5.4": 2, "8.8": 13, "8.0": 1, "9.8": 25, "7.8": 13, "6.5": 1, "7.5": 18, "3.7": 2, "7.3": 2, "9.1": 1, "4.8": 1, "6.0": 1, "8.1": 1, "5.1": 1, "6.6": 1, "6.4": 1, "7.0": 2, "8.2": 1, "10.0": 2, "6.1": 1, "5.3": 3, "7.4": 1, "6.7": 1, "7.2": 1}}, "epss_summary": {"epss_gt_0_1": 839, "epss_gt_0_5": 135, "epss_gt_0_9": 25}}, "kev": {"kev_count": 45}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Apple", "count": 1159}, {"name": "Microsoft", "count": 1035}, {"name": "Oracle", "count": 622}, {"name": "Cisco", "count": 490}, {"name": "Adobe", "count": 483}, {"name": "Google", "count": 471}, {"name": "Linux", "count": 431}, {"name": "Canonical", "count": 349}, {"name": "Opensuse", "count": 333}, {"name": "Debian", "count": 322}, {"name": "Ibm", "count": 320}, {"name": "Redhat", "count": 283}, {"name": "Mozilla", "count": 189}, {"name": "Fedoraproject", "count": 172}, {"name": "Hp", "count": 111}, {"name": "Suse", "count": 86}, {"name": "Emc", "count": 69}, {"name": "Sap", "count": 62}, {"name": "Apache", "count": 57}, {"name": "Novell", "count": 46}]}, "cwe": {"top_cwes": [{"cwe": "CWE-119", "count": 966}, {"cwe": "CWE-79", "count": 727}, {"cwe": "CWE-200", "count": 596}, {"cwe": "CWE-264", "count": 535}, {"cwe": "CWE-20", "count": 382}, {"cwe": "CWE-399", "count": 352}, {"cwe": "CWE-352", "count": 242}, {"cwe": "CWE-89", "count": 213}, {"cwe": "CWE-22", "count": 145}, {"cwe": "CWE-284", "count": 144}, {"cwe": "CWE-17", "count": 120}, {"cwe": "CWE-189", "count": 115}, {"cwe": "CWE-254", "count": 95}, {"cwe": "CWE-310", "count": 84}, {"cwe": "CWE-255", "count": 76}, {"cwe": "CWE-19", "count": 60}, {"cwe": "CWE-94", "count": 51}, {"cwe": "CWE-416", "count": 49}, {"cwe": "CWE-362", "count": 48}, {"cwe": "CWE-77", "count": 40}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 6447}, {"status": "Analyzed", "count": 47}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 14201}, {"tag": "Third Party Advisory", "count": 11817}, {"tag": "Patch", "count": 4648}, {"tag": "VDB Entry", "count": 4114}, {"tag": "Exploit", "count": 3637}, {"tag": "Mailing List", "count": 1814}, {"tag": "US Government Resource", "count": 803}, {"tag": "Issue Tracking", "count": 578}, {"tag": "Broken Link", "count": 528}, {"tag": "Not Applicable", "count": 94}, {"tag": "Release Notes", "count": 86}, {"tag": "Permissions Required", "count": 66}, {"tag": "Product", "count": 24}, {"tag": "Mitigation", "count": 18}, {"tag": "URL Repurposed", "count": 14}, {"tag": "Technical Description", "count": 14}, {"tag": "Press/Media Coverage", "count": 12}]}}, "2016": {"year": 2016, "total_cves": 6449, "date_data": {"monthly_distribution": {"1": 669, "2": 380, "3": 330, "4": 653, "5": 612, "6": 510, "7": 709, "8": 409, "9": 595, "10": 679, "11": 386, "12": 517}, "daily_analysis": {"total_days": 288, "avg_per_day": 22.39, "highest_day": {"date": "2016-01-21", "count": 216}, "lowest_day": {"date": "2016-01-28", "count": 1}}}, "cvss": {"v2.0": {"total": 6449, "severity_distribution": {"UNKNOWN": 6449}, "score_distribution": {"5.0": 719, "7.8": 148, "4.3": 1043, "2.1": 232, "7.5": 396, "10.0": 484, "4.9": 127, "7.2": 301, "5.8": 100, "6.8": 522, "4.6": 73, "9.3": 765, "9.0": 89, "4.0": 262, "3.6": 26, "7.1": 73, "6.9": 77, "9.4": 11, "6.5": 120, "3.5": 209, "1.9": 47, "8.5": 25, "6.2": 7, "5.5": 67, "3.3": 21, "2.7": 2, "2.6": 51, "6.4": 118, "2.9": 6, "6.0": 33, "5.7": 4, "6.6": 9, "7.6": 125, "6.3": 4, "8.3": 9, "4.7": 19, "1.7": 7, "8.0": 6, "7.7": 3, "4.4": 24, "6.1": 19, "7.3": 1, "1.2": 5, "1.8": 2, "5.2": 3, "1.5": 2, "2.8": 2, "1.4": 1, "5.4": 10, "5.6": 7, "5.1": 19, "3.0": 2, "3.2": 2, "4.1": 2, "9.7": 1, "4.8": 1, "5.9": 3, "7.0": 2, "7.9": 1}}, "v3.0": {"total": 5474, "severity_distribution": {"HIGH": 2415, "MEDIUM": 2086, "CRITICAL": 794, "LOW": 179}, "score_distribution": {"7.5": 678, "5.9": 147, "5.5": 354, "4.3": 163, "9.8": 694, "6.2": 29, "6.5": 316, "7.8": 712, "7.6": 19, "3.3": 55, "6.8": 36, "8.1": 111, "6.1": 360, "8.8": 495, "7.3": 71, "5.3": 223, "9.1": 52, "5.4": 183, "7.4": 43, "3.7": 44, "4.0": 13, "5.1": 14, "8.0": 15, "8.5": 6, "7.0": 40, "7.7": 15, "10.0": 16, "8.4": 38, "2.5": 11, "4.7": 40, "5.6": 7, "5.0": 17, "3.5": 9, "3.1": 30, "6.6": 19, "8.6": 59, "9.0": 5, "8.3": 9, "6.3": 28, "9.6": 19, "6.4": 14, "4.6": 21, "6.7": 12, "7.1": 34, "4.1": 7, "4.9": 22, "4.4": 19, "7.2": 26, "9.9": 3, "4.2": 6, "8.2": 41, "2.0": 1, "2.9": 3, "2.6": 1, "9.3": 2, "5.8": 10, "5.7": 10, "7.9": 2, "3.4": 2, "3.8": 2, "4.8": 6, "2.7": 7, "6.0": 5, "8.7": 1, "4.5": 4, "6.9": 1, "3.0": 2, "9.4": 3, "2.4": 4, "2.8": 4, "2.1": 2, "1.8": 1, "1.9": 1}}, "v3.1": {"total": 791, "severity_distribution": {"MEDIUM": 207, "CRITICAL": 97, "HIGH": 480, "LOW": 7}, "score_distribution": {"5.9": 12, "10.0": 1, "7.8": 107, "9.8": 87, "9.1": 7, "9.0": 1, "8.6": 5, "8.2": 2, "7.3": 12, "7.7": 2, "6.5": 51, "7.5": 71, "6.2": 1, "5.3": 13, "8.8": 241, "5.5": 25, "6.0": 28, "4.3": 6, "4.6": 2, "6.8": 4, "5.1": 2, "9.6": 1, "8.0": 2, "7.6": 2, "8.1": 14, "7.0": 14, "7.1": 1, "6.1": 20, "8.4": 5, "5.4": 3, "3.3": 4, "6.4": 2, "4.7": 1, "4.1": 2, "6.7": 3, "5.6": 2, "4.4": 18, "5.0": 1, "7.2": 2, "2.5": 1, "6.3": 1, "3.7": 2, "4.9": 10}}, "epss_summary": {"epss_gt_0_1": 734, "epss_gt_0_5": 133, "epss_gt_0_9": 20}}, "kev": {"kev_count": 53}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 1064}, {"name": "Google", "count": 947}, {"name": "Apple", "count": 824}, {"name": "Oracle", "count": 821}, {"name": "Adobe", "count": 548}, {"name": "Linux", "count": 474}, {"name": "Debian", "count": 454}, {"name": "Opensuse", "count": 404}, {"name": "Ibm", "count": 387}, {"name": "Cisco", "count": 344}, {"name": "Canonical", "count": 340}, {"name": "Redhat", "count": 326}, {"name": "Suse", "count": 151}, {"name": "Fedoraproject", "count": 144}, {"name": "Mozilla", "count": 143}, {"name": "Php", "count": 120}, {"name": "Hp", "count": 114}, {"name": "Apache", "count": 104}, {"name": "Huawei", "count": 100}, {"name": "Wireshark", "count": 95}]}, "cwe": {"top_cwes": [{"cwe": "CWE-119", "count": 1039}, {"cwe": "CWE-200", "count": 690}, {"cwe": "CWE-264", "count": 619}, {"cwe": "CWE-20", "count": 528}, {"cwe": "CWE-79", "count": 473}, {"cwe": "CWE-284", "count": 399}, {"cwe": "CWE-787", "count": 179}, {"cwe": "CWE-399", "count": 173}, {"cwe": "CWE-254", "count": 170}, {"cwe": "CWE-416", "count": 162}, {"cwe": "CWE-89", "count": 96}, {"cwe": "CWE-125", "count": 94}, {"cwe": "CWE-476", "count": 84}, {"cwe": "CWE-352", "count": 82}, {"cwe": "CWE-22", "count": 81}, {"cwe": "CWE-190", "count": 71}, {"cwe": "CWE-310", "count": 61}, {"cwe": "CWE-19", "count": 58}, {"cwe": "CWE-287", "count": 51}, {"cwe": "CWE-255", "count": 48}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 6395}, {"status": "Analyzed", "count": 54}], "cve_tags": [], "reference_tags": [{"tag": "Third Party Advisory", "count": 20026}, {"tag": "Vendor Advisory", "count": 13312}, {"tag": "VDB Entry", "count": 6581}, {"tag": "Patch", "count": 6250}, {"tag": "Mailing List", "count": 4649}, {"tag": "Issue Tracking", "count": 2235}, {"tag": "Broken Link", "count": 2150}, {"tag": "Exploit", "count": 1662}, {"tag": "Release Notes", "count": 662}, {"tag": "US Government Resource", "count": 643}, {"tag": "Mitigation", "count": 248}, {"tag": "Permissions Required", "count": 178}, {"tag": "Technical Description", "count": 158}, {"tag": "Not Applicable", "count": 98}, {"tag": "Product", "count": 56}, {"tag": "URL Repurposed", "count": 20}, {"tag": "Press/Media Coverage", "count": 16}]}}, "2017": {"year": 2017, "total_cves": 14642, "date_data": {"monthly_distribution": {"1": 1083, "2": 1041, "3": 1300, "4": 1570, "5": 1010, "6": 1033, "7": 1268, "8": 1540, "9": 1227, "10": 1399, "11": 1066, "12": 1105}, "daily_analysis": {"total_days": 342, "avg_per_day": 42.81, "highest_day": {"date": "2017-08-08", "count": 316}, "lowest_day": {"date": "2017-01-01", "count": 1}}}, "cvss": {"v2.0": {"total": 14642, "severity_distribution": {"UNKNOWN": 14642}, "score_distribution": {"3.6": 47, "4.9": 191, "7.5": 1452, "4.6": 425, "10.0": 452, "4.3": 2809, "5.0": 1831, "6.5": 427, "9.3": 893, "7.2": 484, "5.8": 410, "6.8": 1639, "3.5": 618, "9.0": 177, "2.1": 414, "4.8": 2, "7.8": 223, "4.0": 582, "6.0": 78, "7.6": 360, "9.7": 1, "6.6": 3, "6.9": 108, "5.5": 102, "4.4": 64, "1.9": 118, "7.1": 154, "2.6": 98, "6.4": 126, "5.6": 5, "1.7": 6, "7.9": 14, "4.7": 11, "3.3": 47, "3.7": 20, "8.5": 28, "1.2": 3, "5.1": 38, "8.3": 28, "9.4": 2, "5.4": 17, "6.1": 28, "3.0": 2, "4.1": 5, "6.2": 8, "8.0": 2, "2.3": 9, "5.7": 2, "3.2": 4, "1.5": 3, "1.0": 1, "2.9": 19, "7.7": 11, "7.4": 6, "6.3": 14, "5.2": 12, "8.2": 1, "7.0": 1, "8.8": 1, "2.7": 5, "1.4": 1}}, "v3.0": {"total": 13062, "severity_distribution": {"HIGH": 5882, "MEDIUM": 5119, "CRITICAL": 1850, "LOW": 211}, "score_distribution": {"7.1": 84, "5.5": 975, "9.8": 1667, "7.8": 1825, "7.3": 78, "6.1": 1006, "5.3": 379, "8.8": 1292, "4.8": 72, "7.4": 42, "6.5": 866, "5.4": 526, "7.5": 1605, "5.9": 313, "6.2": 19, "8.1": 201, "4.9": 72, "3.1": 35, "6.6": 27, "7.0": 270, "4.0": 14, "3.3": 79, "4.6": 38, "8.2": 193, "7.2": 104, "9.1": 77, "3.7": 41, "4.3": 292, "8.3": 18, "10.0": 38, "6.8": 65, "4.4": 33, "4.7": 143, "2.8": 2, "8.0": 40, "6.4": 22, "6.7": 62, "5.0": 46, "4.2": 18, "9.3": 2, "9.0": 23, "6.3": 44, "6.0": 12, "8.4": 26, "8.6": 54, "7.9": 5, "2.1": 1, "4.1": 3, "5.6": 7, "2.7": 7, "5.7": 23, "7.6": 23, "2.4": 14, "9.9": 25, "8.5": 9, "5.1": 7, "3.4": 2, "3.5": 11, "9.6": 16, "4.5": 6, "5.8": 26, "2.9": 1, "2.6": 1, "3.9": 3, "7.7": 9, "8.7": 4, "2.5": 7, "3.8": 2, "9.4": 2, "6.9": 2, "1.9": 1, "1.8": 1, "5.2": 1, "2.3": 3}}, "v3.1": {"total": 1802, "severity_distribution": {"CRITICAL": 343, "MEDIUM": 601, "HIGH": 833, "LOW": 25}, "score_distribution": {"9.8": 308, "4.3": 27, "7.5": 250, "6.1": 89, "6.5": 182, "7.8": 210, "5.5": 113, "8.8": 246, "7.0": 36, "5.9": 48, "7.1": 7, "5.3": 38, "6.7": 6, "3.3": 5, "7.9": 1, "7.7": 3, "3.7": 5, "9.6": 14, "8.1": 33, "9.1": 14, "4.8": 6, "5.1": 1, "7.2": 11, "7.3": 9, "6.2": 4, "4.7": 6, "8.2": 2, "4.6": 4, "5.4": 17, "8.6": 7, "6.3": 5, "8.0": 5, "10.0": 6, "6.0": 4, "4.4": 4, "5.6": 3, "4.0": 5, "8.9": 1, "7.4": 7, "2.7": 3, "2.4": 1, "6.4": 3, "6.6": 10, "4.9": 5, "5.7": 1, "3.5": 1, "4.5": 1, "6.8": 6, "5.0": 10, "3.4": 1, "4.2": 1, "8.3": 3, "9.0": 1, "3.1": 4, "8.4": 2, "4.1": 1, "3.8": 3, "1.9": 1, "2.6": 1, "5.8": 1}}, "v4.0": {"total": 3, "severity_distribution": {"HIGH": 3}, "score_distribution": {"7.1": 2, "8.7": 1}}, "epss_summary": {"epss_gt_0_1": 978, "epss_gt_0_5": 245, "epss_gt_0_9": 46}}, "kev": {"kev_count": 89}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 1290}, {"name": "Google", "count": 1086}, {"name": "Oracle", "count": 934}, {"name": "Apple", "count": 911}, {"name": "Debian", "count": 861}, {"name": "Ibm", "count": 687}, {"name": "Linux", "count": 628}, {"name": "Cisco", "count": 492}, {"name": "Redhat", "count": 395}, {"name": "Imagemagick", "count": 357}, {"name": "Adobe", "count": 353}, {"name": "Canonical", "count": 259}, {"name": "Huawei", "count": 253}, {"name": "Apache", "count": 223}, {"name": "Gnu", "count": 186}, {"name": "Netapp", "count": 141}, {"name": "Tcpdump", "count": 134}, {"name": "Fedoraproject", "count": 121}, {"name": "Opensuse", "count": 116}, {"name": "Irfanview", "count": 115}]}, "cwe": {"top_cwes": [{"cwe": "CWE-119", "count": 2169}, {"cwe": "CWE-79", "count": 1559}, {"cwe": "CWE-200", "count": 1348}, {"cwe": "CWE-20", "count": 1012}, {"cwe": "CWE-125", "count": 779}, {"cwe": "CWE-89", "count": 516}, {"cwe": "CWE-476", "count": 352}, {"cwe": "CWE-352", "count": 336}, {"cwe": "CWE-416", "count": 319}, {"cwe": "CWE-264", "count": 316}, {"cwe": "CWE-22", "count": 296}, {"cwe": "CWE-284", "count": 279}, {"cwe": "CWE-787", "count": 268}, {"cwe": "CWE-287", "count": 263}, {"cwe": "CWE-190", "count": 231}, {"cwe": "CWE-295", "count": 182}, {"cwe": "CWE-78", "count": 172}, {"cwe": "CWE-772", "count": 170}, {"cwe": "CWE-400", "count": 148}, {"cwe": "CWE-426", "count": 141}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 14532}, {"status": "Analyzed", "count": 110}], "cve_tags": [], "reference_tags": [{"tag": "Third Party Advisory", "count": 53173}, {"tag": "VDB Entry", "count": 25837}, {"tag": "Vendor Advisory", "count": 20361}, {"tag": "Patch", "count": 16697}, {"tag": "Issue Tracking", "count": 8837}, {"tag": "Exploit", "count": 7208}, {"tag": "Mailing List", "count": 6092}, {"tag": "Release Notes", "count": 1672}, {"tag": "Broken Link", "count": 1336}, {"tag": "Mitigation", "count": 1272}, {"tag": "Technical Description", "count": 996}, {"tag": "US Government Resource", "count": 873}, {"tag": "Permissions Required", "count": 223}, {"tag": "Not Applicable", "count": 74}, {"tag": "URL Repurposed", "count": 74}, {"tag": "Product", "count": 71}, {"tag": "Press/Media Coverage", "count": 62}, {"tag": "Tool Signature", "count": 16}]}}, "2018": {"year": 2018, "total_cves": 16510, "date_data": {"monthly_distribution": {"1": 1273, "2": 1325, "3": 1337, "4": 1667, "5": 1162, "6": 1783, "7": 2167, "8": 1013, "9": 1169, "10": 1468, "11": 983, "12": 1163}, "daily_analysis": {"total_days": 351, "avg_per_day": 47.04, "highest_day": {"date": "2018-07-09", "count": 431}, "lowest_day": {"date": "2018-01-07", "count": 1}}}, "cvss": {"v2.0": {"total": 16510, "severity_distribution": {"UNKNOWN": 16510}, "score_distribution": {"5.0": 2790, "2.1": 463, "4.0": 751, "7.2": 546, "1.9": 113, "7.5": 1546, "3.3": 90, "6.4": 184, "4.9": 173, "6.5": 606, "4.3": 2648, "10.0": 697, "3.5": 946, "6.8": 1662, "9.3": 524, "3.6": 59, "5.5": 221, "5.8": 410, "4.1": 6, "7.8": 246, "2.9": 30, "4.6": 468, "5.1": 35, "9.0": 345, "7.6": 184, "6.6": 7, "8.5": 37, "1.5": 1, "6.9": 70, "6.0": 77, "7.3": 2, "2.6": 40, "7.1": 83, "4.4": 103, "6.1": 175, "8.3": 33, "2.7": 10, "5.2": 8, "4.7": 23, "6.2": 3, "3.7": 7, "5.7": 5, "1.2": 4, "6.3": 12, "8.0": 16, "7.7": 8, "4.8": 5, "5.4": 14, "3.8": 3, "7.9": 2, "9.4": 2, "2.3": 2, "7.4": 3, "5.6": 7, "8.8": 3, "7.0": 1, "6.7": 1}}, "v3.0": {"total": 15199, "severity_distribution": {"HIGH": 6844, "MEDIUM": 5828, "CRITICAL": 2295, "LOW": 232}, "score_distribution": {"7.5": 2310, "6.8": 83, "6.5": 1127, "6.7": 43, "4.1": 12, "9.8": 2051, "5.3": 554, "5.5": 718, "8.1": 396, "5.9": 264, "8.8": 1772, "5.4": 657, "4.3": 323, "7.3": 59, "6.1": 1192, "4.4": 44, "3.3": 62, "7.8": 1394, "7.4": 70, "7.1": 129, "7.0": 132, "9.1": 98, "7.2": 208, "2.7": 16, "8.6": 88, "4.6": 42, "6.3": 53, "4.8": 276, "8.0": 71, "4.2": 28, "7.6": 25, "3.5": 16, "3.7": 57, "8.2": 65, "9.6": 23, "10.0": 55, "4.7": 101, "6.6": 27, "8.3": 27, "6.4": 26, "4.9": 72, "2.2": 2, "5.0": 21, "3.1": 28, "4.0": 27, "6.2": 32, "6.9": 4, "5.8": 24, "8.4": 31, "5.6": 31, "5.7": 23, "9.9": 33, "7.7": 27, "8.7": 8, "2.0": 2, "3.9": 8, "5.1": 9, "6.0": 8, "9.0": 27, "2.8": 3, "2.6": 4, "2.4": 5, "2.3": 7, "4.5": 3, "5.2": 4, "8.5": 30, "9.3": 4, "3.6": 3, "2.9": 1, "2.1": 1, "3.8": 8, "3.4": 4, "9.4": 4, "2.5": 4, "7.9": 1, "1.8": 1, "8.9": 1}}, "v3.1": {"total": 1853, "severity_distribution": {"HIGH": 872, "MEDIUM": 629, "CRITICAL": 331, "LOW": 21}, "score_distribution": {"7.5": 294, "7.8": 195, "6.1": 85, "9.8": 267, "8.8": 193, "6.5": 157, "5.4": 38, "5.9": 38, "5.5": 79, "8.1": 77, "4.9": 32, "5.3": 74, "10.0": 9, "8.2": 9, "7.4": 12, "7.1": 8, "5.6": 10, "4.7": 13, "7.0": 12, "6.8": 15, "4.4": 8, "3.3": 6, "7.2": 23, "4.3": 25, "8.0": 5, "9.0": 5, "9.9": 32, "4.6": 5, "9.1": 16, "3.7": 4, "4.8": 14, "4.5": 1, "8.3": 13, "6.0": 1, "8.6": 15, "6.7": 14, "3.6": 1, "5.0": 2, "7.7": 7, "6.6": 6, "3.8": 1, "3.1": 4, "6.3": 4, "5.8": 1, "7.6": 2, "6.2": 1, "6.4": 1, "7.3": 5, "2.7": 2, "2.8": 1, "9.4": 1, "5.2": 1, "4.2": 1, "9.6": 1, "2.4": 1, "8.7": 1, "3.4": 1, "8.4": 1, "5.7": 3}}, "epss_summary": {"epss_gt_0_1": 1270, "epss_gt_0_5": 263, "epss_gt_0_9": 43}}, "kev": {"kev_count": 76}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Debian", "count": 1416}, {"name": "Microsoft", "count": 1358}, {"name": "Redhat", "count": 929}, {"name": "Canonical", "count": 885}, {"name": "Google", "count": 842}, {"name": "Oracle", "count": 819}, {"name": "Ibm", "count": 643}, {"name": "Apple", "count": 520}, {"name": "Cisco", "count": 457}, {"name": "Adobe", "count": 387}, {"name": "Qualcomm", "count": 376}, {"name": "Mozilla", "count": 358}, {"name": "Hp", "count": 311}, {"name": "Linux", "count": 282}, {"name": "Foxitsoftware", "count": 249}, {"name": "Huawei", "count": 226}, {"name": "Netapp", "count": 190}, {"name": "Apache", "count": 176}, {"name": "Jenkins", "count": 161}, {"name": "Opensuse", "count": 132}]}, "cwe": {"top_cwes": [{"cwe": "CWE-79", "count": 2189}, {"cwe": "CWE-20", "count": 1402}, {"cwe": "CWE-200", "count": 1132}, {"cwe": "CWE-119", "count": 1029}, {"cwe": "CWE-787", "count": 908}, {"cwe": "CWE-125", "count": 821}, {"cwe": "CWE-22", "count": 746}, {"cwe": "CWE-190", "count": 738}, {"cwe": "CWE-89", "count": 555}, {"cwe": "CWE-416", "count": 510}, {"cwe": "CWE-352", "count": 495}, {"cwe": "CWE-78", "count": 364}, {"cwe": "CWE-476", "count": 360}, {"cwe": "CWE-287", "count": 338}, {"cwe": "CWE-400", "count": 260}, {"cwe": "CWE-732", "count": 229}, {"cwe": "CWE-611", "count": 208}, {"cwe": "CWE-310", "count": 185}, {"cwe": "CWE-434", "count": 184}, {"cwe": "CWE-311", "count": 179}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 16406}, {"status": "Analyzed", "count": 102}, {"status": "Undergoing Analysis", "count": 2}], "cve_tags": [], "reference_tags": [{"tag": "Third Party Advisory", "count": 62915}, {"tag": "VDB Entry", "count": 23519}, {"tag": "Vendor Advisory", "count": 21992}, {"tag": "Exploit", "count": 13681}, {"tag": "Patch", "count": 11714}, {"tag": "Issue Tracking", "count": 5112}, {"tag": "Mailing List", "count": 4387}, {"tag": "Broken Link", "count": 1318}, {"tag": "Release Notes", "count": 1222}, {"tag": "US Government Resource", "count": 1140}, {"tag": "Mitigation", "count": 1137}, {"tag": "Permissions Required", "count": 724}, {"tag": "Technical Description", "count": 692}, {"tag": "Product", "count": 153}, {"tag": "Not Applicable", "count": 74}, {"tag": "URL Repurposed", "count": 74}, {"tag": "Press/Media Coverage", "count": 36}, {"tag": "Tool Signature", "count": 6}]}}, "2019": {"year": 2019, "total_cves": 17305, "date_data": {"monthly_distribution": {"1": 1212, "2": 838, "3": 1182, "4": 1533, "5": 1316, "6": 1254, "7": 1618, "8": 2001, "9": 1531, "10": 1566, "11": 1677, "12": 1577}, "daily_analysis": {"total_days": 336, "avg_per_day": 51.5, "highest_day": {"date": "2019-12-18", "count": 364}, "lowest_day": {"date": "2019-02-14", "count": 1}}}, "cvss": {"v2.0": {"total": 17305, "severity_distribution": {"UNKNOWN": 17305}, "score_distribution": {"4.6": 546, "7.5": 1705, "5.0": 2411, "4.3": 3066, "2.1": 818, "6.8": 1672, "7.2": 672, "10.0": 570, "6.5": 708, "1.9": 76, "6.4": 271, "4.0": 1028, "9.0": 380, "3.6": 92, "2.9": 12, "7.8": 224, "5.5": 207, "5.2": 21, "3.5": 861, "5.8": 414, "4.9": 205, "9.4": 12, "4.4": 104, "3.3": 103, "9.3": 450, "6.3": 3, "6.6": 29, "7.1": 61, "7.9": 7, "2.6": 37, "4.7": 37, "6.0": 61, "6.2": 4, "6.9": 72, "6.1": 31, "8.5": 32, "5.1": 25, "8.7": 2, "4.8": 20, "8.3": 43, "2.7": 15, "7.7": 21, "4.1": 4, "5.4": 11, "7.6": 131, "3.8": 1, "1.2": 6, "5.6": 4, "5.7": 2, "1.7": 2, "8.8": 2, "9.7": 4, "2.3": 3, "3.7": 7}}, "v3.0": {"total": 9655, "severity_distribution": {"CRITICAL": 1399, "MEDIUM": 4089, "HIGH": 3960, "LOW": 207}, "score_distribution": {"9.8": 1201, "5.5": 398, "8.8": 1196, "6.1": 993, "7.5": 1003, "5.7": 21, "3.8": 14, "2.8": 6, "5.2": 4, "7.0": 44, "5.3": 328, "9.1": 86, "8.1": 176, "5.9": 143, "6.8": 89, "8.6": 77, "9.6": 12, "2.0": 4, "6.5": 751, "7.4": 86, "7.8": 781, "4.3": 221, "5.4": 423, "7.3": 68, "6.4": 29, "3.9": 8, "6.7": 104, "2.7": 16, "4.9": 64, "4.7": 46, "4.8": 132, "1.6": 1, "1.8": 1, "7.1": 83, "7.2": 171, "3.3": 64, "10.0": 35, "6.2": 18, "3.7": 21, "8.5": 9, "2.1": 2, "8.7": 12, "7.7": 35, "8.3": 18, "9.9": 19, "8.2": 94, "8.0": 46, "8.4": 39, "6.3": 45, "2.5": 7, "3.1": 20, "3.5": 15, "4.4": 44, "5.0": 25, "5.8": 43, "4.5": 9, "4.2": 30, "9.0": 24, "4.0": 30, "5.1": 22, "4.6": 28, "9.3": 16, "7.9": 2, "4.1": 11, "2.2": 3, "5.6": 18, "6.0": 10, "7.6": 19, "2.3": 4, "2.9": 5, "2.4": 13, "6.9": 1, "9.4": 6, "6.6": 9, "8.9": 1, "3.4": 1, "3.2": 1, "3.6": 1}}, "v3.1": {"total": 9227, "severity_distribution": {"HIGH": 3838, "CRITICAL": 1295, "MEDIUM": 3896, "LOW": 198}, "score_distribution": {"7.8": 932, "9.8": 1127, "7.5": 1229, "6.1": 703, "5.5": 527, "8.1": 122, "9.1": 84, "6.5": 846, "3.1": 12, "3.3": 96, "5.6": 12, "8.8": 1039, "5.9": 102, "7.1": 69, "8.0": 33, "5.3": 344, "5.4": 326, "4.8": 88, "4.7": 54, "8.6": 42, "7.2": 141, "8.2": 38, "6.7": 110, "7.3": 48, "3.7": 30, "4.3": 294, "7.4": 40, "2.7": 12, "6.2": 9, "6.3": 23, "4.4": 76, "10.0": 28, "4.6": 56, "7.0": 49, "4.2": 32, "2.4": 15, "2.5": 4, "6.8": 54, "5.7": 17, "7.6": 6, "7.7": 25, "4.9": 117, "5.0": 25, "8.3": 10, "2.6": 2, "5.2": 4, "6.4": 19, "4.1": 7, "5.8": 17, "9.9": 25, "9.3": 6, "9.0": 9, "5.1": 7, "9.4": 5, "6.0": 8, "2.1": 1, "8.5": 1, "3.6": 2, "6.6": 12, "3.4": 2, "2.2": 2, "2.8": 1, "9.6": 11, "2.3": 6, "7.9": 1, "8.7": 3, "3.5": 7, "6.9": 1, "3.8": 1, "1.6": 1, "8.4": 9, "4.0": 4, "3.9": 3, "1.8": 1, "4.5": 2, "8.9": 1}}, "epss_summary": {"epss_gt_0_1": 1042, "epss_gt_0_5": 263, "epss_gt_0_9": 57}}, "kev": {"kev_count": 129}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 1853}, {"name": "Debian", "count": 1197}, {"name": "Apple", "count": 1108}, {"name": "Google", "count": 898}, {"name": "Redhat", "count": 809}, {"name": "Oracle", "count": 789}, {"name": "Canonical", "count": 710}, {"name": "Fedoraproject", "count": 703}, {"name": "Opensuse", "count": 701}, {"name": "Adobe", "count": 569}, {"name": "Cisco", "count": 560}, {"name": "Ibm", "count": 477}, {"name": "Linux", "count": 394}, {"name": "Jenkins", "count": 345}, {"name": "Netapp", "count": 324}, {"name": "Cpanel", "count": 321}, {"name": "Qualcomm", "count": 298}, {"name": "Intel", "count": 236}, {"name": "Hp", "count": 191}, {"name": "Siemens", "count": 182}]}, "cwe": {"top_cwes": [{"cwe": "CWE-79", "count": 2491}, {"cwe": "CWE-787", "count": 1347}, {"cwe": "CWE-20", "count": 1027}, {"cwe": "CWE-125", "count": 997}, {"cwe": "CWE-416", "count": 713}, {"cwe": "CWE-200", "count": 598}, {"cwe": "CWE-89", "count": 597}, {"cwe": "CWE-352", "count": 572}, {"cwe": "CWE-22", "count": 540}, {"cwe": "CWE-119", "count": 527}, {"cwe": "CWE-78", "count": 452}, {"cwe": "CWE-287", "count": 315}, {"cwe": "CWE-476", "count": 263}, {"cwe": "CWE-190", "count": 251}, {"cwe": "CWE-732", "count": 227}, {"cwe": "CWE-434", "count": 223}, {"cwe": "CWE-862", "count": 215}, {"cwe": "CWE-306", "count": 204}, {"cwe": "CWE-522", "count": 194}, {"cwe": "CWE-400", "count": 193}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 17139}, {"status": "Analyzed", "count": 166}], "cve_tags": [], "reference_tags": [{"tag": "Third Party Advisory", "count": 51062}, {"tag": "Vendor Advisory", "count": 25546}, {"tag": "Patch", "count": 12299}, {"tag": "Exploit", "count": 11996}, {"tag": "Mailing List", "count": 9283}, {"tag": "VDB Entry", "count": 9156}, {"tag": "Release Notes", "count": 4363}, {"tag": "Issue Tracking", "count": 3797}, {"tag": "Broken Link", "count": 1565}, {"tag": "Product", "count": 1235}, {"tag": "US Government Resource", "count": 892}, {"tag": "Mitigation", "count": 762}, {"tag": "Permissions Required", "count": 748}, {"tag": "Not Applicable", "count": 328}, {"tag": "Technical Description", "count": 136}, {"tag": "Press/Media Coverage", "count": 39}, {"tag": "URL Repurposed", "count": 38}, {"tag": "Tool Signature", "count": 8}]}}, "2020": {"year": 2020, "total_cves": 18322, "date_data": {"monthly_distribution": {"1": 1656, "2": 1394, "3": 1754, "4": 2187, "5": 1017, "6": 1786, "7": 1417, "8": 1155, "9": 1593, "10": 1563, "11": 1271, "12": 1529}, "daily_analysis": {"total_days": 330, "avg_per_day": 55.52, "highest_day": {"date": "2020-04-15", "count": 508}, "lowest_day": {"date": "2020-02-15", "count": 1}}}, "cvss": {"v2.0": {"total": 18322, "severity_distribution": {"UNKNOWN": 18322}, "score_distribution": {"7.5": 1637, "3.2": 3, "4.3": 2307, "5.0": 2567, "10.0": 611, "3.5": 1145, "7.2": 753, "6.5": 781, "1.9": 103, "6.8": 1334, "9.0": 399, "6.0": 95, "6.4": 307, "1.5": 1, "4.9": 208, "2.1": 1058, "7.8": 229, "6.9": 131, "8.3": 53, "4.0": 1057, "9.3": 464, "3.6": 153, "5.5": 239, "5.8": 620, "4.6": 1004, "2.7": 25, "4.4": 194, "2.6": 39, "8.7": 1, "6.3": 9, "6.6": 20, "7.1": 47, "5.2": 135, "3.3": 185, "4.8": 28, "7.9": 6, "5.1": 39, "2.9": 28, "2.3": 11, "8.5": 51, "9.4": 28, "5.6": 6, "4.1": 3, "6.1": 43, "5.4": 16, "8.8": 2, "4.7": 21, "7.6": 66, "3.7": 17, "7.7": 19, "8.0": 2, "1.2": 7, "7.4": 3, "5.9": 2, "6.7": 1, "1.7": 1, "6.2": 2, "3.0": 1, "5.7": 4, "9.7": 1}}, "v3.0": {"total": 2658, "severity_distribution": {"MEDIUM": 1393, "LOW": 112, "CRITICAL": 223, "HIGH": 930}, "score_distribution": {"6.3": 49, "5.3": 128, "3.7": 30, "4.3": 158, "6.4": 47, "10.0": 18, "6.7": 39, "8.4": 29, "7.8": 110, "5.2": 32, "6.2": 21, "8.8": 225, "7.7": 13, "4.0": 14, "6.1": 94, "4.2": 14, "7.5": 140, "4.6": 13, "6.8": 132, "5.0": 13, "6.5": 132, "4.7": 38, "7.4": 46, "9.6": 19, "8.6": 56, "4.5": 7, "8.0": 17, "8.1": 36, "7.1": 46, "7.3": 18, "7.6": 15, "4.8": 46, "4.4": 20, "3.2": 2, "8.2": 100, "5.4": 129, "5.7": 5, "6.0": 87, "9.8": 126, "7.2": 49, "4.9": 44, "3.5": 8, "9.1": 22, "8.3": 10, "5.1": 13, "9.0": 11, "5.5": 19, "9.9": 14, "5.9": 61, "3.1": 13, "2.7": 14, "9.4": 7, "2.3": 2, "8.7": 4, "7.0": 10, "6.9": 4, "7.9": 1, "5.6": 6, "2.4": 6, "2.9": 5, "6.6": 3, "3.3": 18, "4.1": 7, "5.8": 18, "3.9": 3, "9.3": 6, "3.8": 4, "3.0": 1, "2.5": 2, "8.5": 5, "2.8": 1, "2.2": 1, "2.6": 1, "3.4": 1}}, "v3.1": {"total": 18322, "severity_distribution": {"CRITICAL": 2622, "MEDIUM": 7551, "HIGH": 7663, "LOW": 486}, "score_distribution": {"9.8": 2172, "6.8": 262, "5.9": 177, "7.5": 2153, "6.1": 1185, "7.2": 314, "8.8": 1662, "3.3": 149, "6.5": 1136, "5.3": 741, "5.4": 748, "5.5": 977, "9.1": 214, "9.6": 65, "7.8": 2082, "2.4": 47, "4.3": 589, "7.0": 127, "4.8": 345, "8.1": 272, "6.4": 71, "4.9": 180, "7.4": 89, "4.6": 95, "5.7": 46, "6.3": 100, "5.0": 59, "9.9": 43, "7.1": 211, "8.4": 42, "6.6": 44, "9.3": 19, "3.8": 17, "3.5": 42, "10.0": 51, "7.3": 107, "3.7": 62, "2.7": 36, "6.7": 194, "6.2": 40, "4.2": 45, "8.0": 93, "7.7": 80, "2.5": 7, "8.6": 111, "4.0": 15, "4.7": 97, "4.5": 10, "4.4": 149, "2.0": 6, "2.3": 13, "5.8": 49, "8.7": 28, "7.9": 15, "9.0": 45, "8.2": 186, "6.9": 15, "2.9": 1, "5.2": 13, "8.3": 37, "3.1": 32, "9.4": 13, "5.1": 10, "5.6": 24, "7.6": 33, "6.0": 96, "2.8": 10, "4.1": 39, "3.9": 17, "1.6": 1, "2.2": 18, "2.6": 5, "3.0": 6, "3.2": 9, "8.5": 14, "8.9": 7, "3.4": 4, "3.6": 3, "2.1": 1}}, "v4.0": {"total": 5, "severity_distribution": {"HIGH": 2, "CRITICAL": 3}, "score_distribution": {"7.1": 1, "10.0": 1, "7.3": 1, "9.3": 2}}, "epss_summary": {"epss_gt_0_1": 900, "epss_gt_0_5": 318, "epss_gt_0_9": 82}}, "kev": {"kev_count": 146}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 1882}, {"name": "Google", "count": 1257}, {"name": "Debian", "count": 1061}, {"name": "Oracle", "count": 1039}, {"name": "Fedoraproject", "count": 856}, {"name": "Opensuse", "count": 785}, {"name": "Apple", "count": 697}, {"name": "Netgear", "count": 631}, {"name": "Canonical", "count": 580}, {"name": "Cisco", "count": 568}, {"name": "Ibm", "count": 568}, {"name": "Netapp", "count": 388}, {"name": "Redhat", "count": 351}, {"name": "Qualcomm", "count": 319}, {"name": "Adobe", "count": 313}, {"name": "Linux", "count": 244}, {"name": "Intel", "count": 242}, {"name": "Gitlab", "count": 241}, {"name": "Jenkins", "count": 230}, {"name": "Sap", "count": 222}]}, "cwe": {"top_cwes": [{"cwe": "CWE-79", "count": 2456}, {"cwe": "CWE-787", "count": 1471}, {"cwe": "CWE-20", "count": 991}, {"cwe": "CWE-125", "count": 758}, {"cwe": "CWE-78", "count": 641}, {"cwe": "CWE-89", "count": 549}, {"cwe": "CWE-22", "count": 504}, {"cwe": "CWE-120", "count": 434}, {"cwe": "CWE-352", "count": 433}, {"cwe": "CWE-416", "count": 431}, {"cwe": "CWE-287", "count": 397}, {"cwe": "CWE-200", "count": 383}, {"cwe": "CWE-269", "count": 310}, {"cwe": "CWE-306", "count": 296}, {"cwe": "CWE-400", "count": 287}, {"cwe": "CWE-862", "count": 281}, {"cwe": "CWE-434", "count": 248}, {"cwe": "CWE-190", "count": 240}, {"cwe": "CWE-276", "count": 224}, {"cwe": "CWE-798", "count": 221}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 18115}, {"status": "Analyzed", "count": 204}, {"status": "Undergoing Analysis", "count": 3}], "cve_tags": [], "reference_tags": [{"tag": "Third Party Advisory", "count": 43130}, {"tag": "Vendor Advisory", "count": 30837}, {"tag": "Patch", "count": 12641}, {"tag": "Exploit", "count": 11396}, {"tag": "Mailing List", "count": 8060}, {"tag": "VDB Entry", "count": 5597}, {"tag": "Release Notes", "count": 4605}, {"tag": "Issue Tracking", "count": 3124}, {"tag": "Permissions Required", "count": 1398}, {"tag": "Broken Link", "count": 1369}, {"tag": "Product", "count": 1248}, {"tag": "US Government Resource", "count": 1211}, {"tag": "Mitigation", "count": 485}, {"tag": "Technical Description", "count": 358}, {"tag": "Not Applicable", "count": 226}, {"tag": "URL Repurposed", "count": 40}, {"tag": "Press/Media Coverage", "count": 24}, {"tag": "Tool Signature", "count": 16}]}}, "2021": {"year": 2021, "total_cves": 20149, "date_data": {"monthly_distribution": {"1": 1524, "2": 1456, "3": 1446, "4": 1818, "5": 1473, "6": 1712, "7": 1582, "8": 2085, "9": 1902, "10": 1701, "11": 1508, "12": 1942}, "daily_analysis": {"total_days": 340, "avg_per_day": 59.26, "highest_day": {"date": "2021-04-22", "count": 295}, "lowest_day": {"date": "2021-01-31", "count": 1}}}, "cvss": {"v2.0": {"total": 20149, "severity_distribution": {"UNKNOWN": 20149}, "score_distribution": {"5.0": 2632, "4.3": 2826, "2.1": 1123, "5.5": 312, "6.8": 2089, "7.5": 1785, "4.6": 1030, "7.2": 674, "5.8": 483, "9.3": 347, "10.0": 371, "6.5": 1060, "3.5": 1530, "4.0": 1240, "8.8": 6, "6.4": 326, "3.6": 162, "7.1": 57, "9.0": 445, "4.9": 191, "2.3": 11, "5.2": 76, "3.8": 2, "2.7": 28, "2.6": 40, "4.4": 172, "4.1": 6, "6.9": 139, "7.8": 186, "3.3": 158, "6.0": 136, "8.3": 61, "8.5": 63, "5.1": 47, "2.9": 39, "6.1": 38, "7.9": 11, "1.9": 82, "1.8": 2, "7.7": 20, "4.8": 15, "9.4": 18, "6.2": 5, "6.7": 1, "6.6": 19, "4.7": 17, "5.6": 7, "3.2": 1, "6.3": 12, "7.6": 21, "5.7": 3, "1.2": 4, "7.0": 1, "8.7": 2, "5.9": 1, "5.4": 10, "8.0": 3, "1.4": 1, "1.7": 1, "7.4": 1}}, "v3.0": {"total": 1644, "severity_distribution": {"HIGH": 596, "MEDIUM": 828, "LOW": 101, "CRITICAL": 119}, "score_distribution": {"8.8": 142, "5.9": 72, "3.7": 14, "4.2": 5, "9.4": 2, "7.4": 15, "5.3": 69, "5.4": 139, "4.3": 133, "4.6": 9, "7.1": 23, "8.2": 18, "4.8": 14, "4.7": 12, "4.4": 20, "5.5": 16, "2.3": 1, "6.7": 10, "6.5": 81, "6.1": 34, "9.3": 6, "7.5": 59, "6.4": 56, "5.7": 3, "2.9": 1, "4.0": 24, "4.1": 3, "6.2": 22, "7.6": 8, "2.6": 2, "8.6": 9, "3.1": 11, "5.1": 9, "8.1": 32, "6.3": 25, "9.6": 14, "3.4": 2, "6.9": 2, "7.8": 206, "3.3": 49, "8.0": 12, "9.8": 33, "7.2": 4, "6.8": 21, "7.7": 31, "4.9": 19, "10.0": 19, "8.4": 8, "5.8": 3, "2.4": 2, "9.9": 17, "3.6": 1, "2.7": 11, "9.1": 24, "5.6": 5, "6.6": 7, "7.0": 4, "8.3": 5, "3.2": 2, "6.0": 8, "7.3": 18, "9.0": 4, "4.5": 2, "3.5": 2, "5.2": 2, "7.9": 1, "5.0": 3, "2.5": 1, "3.8": 1, "3.9": 1, "8.7": 1}}, "v3.1": {"total": 20045, "severity_distribution": {"HIGH": 8405, "MEDIUM": 8457, "CRITICAL": 2552, "LOW": 631}, "score_distribution": {"7.5": 2143, "6.5": 1311, "5.9": 228, "5.5": 1228, "8.1": 468, "7.8": 2195, "9.8": 1905, "6.1": 1260, "3.7": 52, "4.3": 558, "8.8": 1698, "5.4": 1071, "9.6": 139, "4.8": 349, "10.0": 83, "5.3": 716, "7.1": 229, "6.8": 199, "3.3": 208, "4.9": 255, "2.6": 10, "9.1": 286, "3.1": 43, "7.3": 179, "3.5": 55, "9.9": 59, "4.1": 26, "7.2": 482, "6.3": 113, "7.0": 119, "8.2": 170, "7.4": 97, "9.0": 49, "4.4": 195, "3.8": 16, "6.7": 239, "5.1": 15, "4.7": 87, "2.3": 12, "6.4": 71, "6.6": 33, "9.3": 22, "5.8": 47, "2.7": 40, "7.7": 74, "4.5": 19, "8.7": 28, "5.7": 66, "3.9": 21, "6.0": 66, "8.0": 105, "4.6": 66, "8.6": 124, "6.9": 15, "2.9": 7, "3.6": 5, "5.2": 19, "8.3": 47, "5.0": 46, "7.6": 60, "4.0": 47, "8.4": 138, "6.2": 42, "4.2": 38, "2.4": 21, "2.5": 105, "7.9": 11, "5.6": 32, "3.2": 14, "8.5": 30, "2.2": 3, "3.0": 3, "2.8": 2, "2.1": 1, "2.0": 5, "1.8": 3, "1.9": 2, "9.4": 9, "8.9": 8, "3.4": 2, "1.7": 1}}, "v4.0": {"total": 10, "severity_distribution": {"HIGH": 6, "MEDIUM": 4}, "score_distribution": {"8.7": 4, "8.6": 2, "6.9": 1, "5.9": 3}}, "epss_summary": {"epss_gt_0_1": 1018, "epss_gt_0_5": 426, "epss_gt_0_9": 89}}, "kev": {"kev_count": 214}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 1713}, {"name": "Google", "count": 1252}, {"name": "Fedoraproject", "count": 1137}, {"name": "Debian", "count": 1076}, {"name": "Oracle", "count": 909}, {"name": "Apple", "count": 778}, {"name": "Ibm", "count": 608}, {"name": "Cisco", "count": 591}, {"name": "Netapp", "count": 548}, {"name": "Siemens", "count": 450}, {"name": "Linux", "count": 430}, {"name": "Adobe", "count": 408}, {"name": "Huawei", "count": 327}, {"name": "Netgear", "count": 285}, {"name": "Redhat", "count": 282}, {"name": "Qualcomm", "count": 262}, {"name": "Apache", "count": 211}, {"name": "Intel", "count": 208}, {"name": "Sap", "count": 204}, {"name": "Dell", "count": 177}]}, "cwe": {"top_cwes": [{"cwe": "CWE-79", "count": 3191}, {"cwe": "CWE-787", "count": 1730}, {"cwe": "CWE-89", "count": 892}, {"cwe": "CWE-125", "count": 856}, {"cwe": "CWE-20", "count": 780}, {"cwe": "CWE-416", "count": 665}, {"cwe": "CWE-22", "count": 636}, {"cwe": "CWE-78", "count": 594}, {"cwe": "CWE-352", "count": 574}, {"cwe": "CWE-120", "count": 480}, {"cwe": "CWE-476", "count": 426}, {"cwe": "CWE-269", "count": 374}, {"cwe": "CWE-287", "count": 357}, {"cwe": "CWE-200", "count": 353}, {"cwe": "CWE-434", "count": 347}, {"cwe": "CWE-77", "count": 323}, {"cwe": "CWE-863", "count": 322}, {"cwe": "CWE-119", "count": 316}, {"cwe": "CWE-862", "count": 299}, {"cwe": "CWE-502", "count": 299}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 19810}, {"status": "Analyzed", "count": 339}], "cve_tags": [], "reference_tags": [{"tag": "Third Party Advisory", "count": 44359}, {"tag": "Vendor Advisory", "count": 30173}, {"tag": "Patch", "count": 15925}, {"tag": "Exploit", "count": 14835}, {"tag": "Mailing List", "count": 5412}, {"tag": "Issue Tracking", "count": 4855}, {"tag": "Release Notes", "count": 4720}, {"tag": "VDB Entry", "count": 4385}, {"tag": "Product", "count": 2055}, {"tag": "Permissions Required", "count": 1600}, {"tag": "Broken Link", "count": 1160}, {"tag": "US Government Resource", "count": 1073}, {"tag": "Mitigation", "count": 635}, {"tag": "Technical Description", "count": 518}, {"tag": "Not Applicable", "count": 394}, {"tag": "URL Repurposed", "count": 34}, {"tag": "Press/Media Coverage", "count": 22}, {"tag": "Tool Signature", "count": 10}]}}, "2022": {"year": 2022, "total_cves": 25074, "date_data": {"monthly_distribution": {"1": 2016, "2": 1942, "3": 2058, "4": 2046, "5": 2021, "6": 2280, "7": 1969, "8": 2317, "9": 2197, "10": 1849, "11": 1958, "12": 2421}, "daily_analysis": {"total_days": 352, "avg_per_day": 71.23, "highest_day": {"date": "2022-06-02", "count": 320}, "lowest_day": {"date": "2022-05-22", "count": 1}}}, "cvss": {"v2.0": {"total": 13226, "severity_distribution": {"UNKNOWN": 13226}, "score_distribution": {"7.5": 1501, "5.0": 1615, "4.3": 1854, "5.8": 238, "4.0": 831, "2.1": 589, "7.9": 8, "6.4": 281, "5.5": 171, "8.5": 45, "2.6": 38, "8.3": 31, "6.8": 1134, "3.5": 1065, "8.0": 1, "6.5": 820, "4.4": 124, "10.0": 404, "4.6": 457, "4.9": 157, "7.2": 525, "6.0": 96, "3.6": 79, "6.9": 115, "5.2": 7, "2.3": 4, "4.8": 7, "1.9": 57, "2.7": 10, "9.3": 254, "9.0": 192, "3.3": 69, "6.1": 16, "7.8": 210, "5.6": 1, "7.7": 7, "2.9": 28, "8.8": 2, "6.6": 15, "5.1": 56, "1.2": 3, "7.1": 48, "9.4": 8, "4.7": 16, "7.6": 10, "7.4": 1, "6.2": 5, "5.4": 10, "3.8": 1, "6.3": 1, "3.7": 3, "5.7": 2, "7.0": 1, "5.9": 1, "1.4": 1, "1.8": 1}}, "v3.0": {"total": 2000, "severity_distribution": {"MEDIUM": 666, "LOW": 133, "HIGH": 917, "CRITICAL": 284}, "score_distribution": {"6.5": 81, "2.1": 1, "2.4": 3, "5.3": 79, "7.1": 56, "7.3": 41, "6.2": 23, "4.3": 69, "8.8": 71, "5.4": 71, "10.0": 66, "5.7": 16, "4.4": 10, "4.0": 13, "6.8": 35, "8.6": 87, "7.5": 43, "2.7": 6, "3.0": 3, "5.9": 36, "3.1": 8, "8.4": 29, "6.3": 36, "7.8": 395, "3.3": 63, "9.8": 46, "7.0": 12, "7.7": 10, "7.6": 29, "8.1": 28, "9.1": 51, "2.2": 4, "3.7": 18, "9.0": 31, "7.4": 15, "5.8": 4, "4.8": 16, "4.1": 3, "5.6": 7, "4.9": 22, "5.5": 19, "8.2": 37, "9.3": 10, "4.6": 14, "3.5": 7, "2.0": 1, "6.4": 8, "6.1": 29, "4.5": 4, "5.2": 2, "8.0": 18, "9.6": 45, "8.3": 20, "4.7": 6, "7.2": 21, "6.6": 29, "6.7": 7, "8.5": 2, "9.4": 12, "5.1": 8, "3.8": 4, "3.4": 3, "5.0": 6, "6.9": 2, "9.9": 23, "4.2": 7, "2.9": 2, "8.7": 2, "3.9": 1, "7.9": 1, "3.6": 3, "2.5": 2, "2.8": 2, "6.0": 4, "2.3": 2}}, "v3.1": {"total": 24978, "severity_distribution": {"MEDIUM": 10670, "LOW": 942, "HIGH": 9606, "CRITICAL": 3758, "NONE": 2}, "score_distribution": {"5.3": 779, "3.7": 68, "5.0": 72, "5.4": 1226, "7.5": 2599, "5.5": 1687, "6.7": 347, "7.0": 177, "6.5": 1665, "4.3": 829, "6.1": 1275, "8.3": 65, "9.8": 3004, "4.8": 562, "8.8": 1819, "9.1": 299, "8.1": 408, "7.3": 224, "8.6": 115, "6.2": 86, "3.5": 303, "7.6": 58, "7.2": 789, "5.9": 313, "6.3": 346, "6.4": 128, "2.8": 12, "5.6": 35, "4.7": 163, "2.7": 47, "4.4": 175, "7.8": 2389, "3.1": 35, "2.6": 35, "3.3": 211, "3.0": 10, "2.4": 47, "4.2": 42, "4.6": 102, "5.8": 39, "8.2": 177, "2.2": 8, "10.0": 117, "7.1": 233, "4.9": 210, "3.4": 31, "6.8": 177, "7.7": 139, "3.8": 25, "5.1": 22, "4.0": 117, "9.4": 25, "3.2": 4, "9.0": 62, "9.3": 110, "9.6": 61, "6.6": 77, "8.4": 111, "8.0": 110, "4.5": 15, "6.9": 17, "9.9": 79, "7.4": 96, "2.5": 13, "8.5": 40, "8.7": 33, "2.0": 14, "5.7": 58, "4.1": 47, "6.0": 46, "5.2": 13, "3.9": 21, "2.3": 17, "7.9": 16, "2.9": 21, "1.9": 12, "3.6": 4, "2.1": 2, "8.9": 8, "1.8": 2, "0.0": 2, "9.2": 1}}, "v4.0": {"total": 31, "severity_distribution": {"MEDIUM": 16, "HIGH": 11, "CRITICAL": 3, "LOW": 1}, "score_distribution": {"5.1": 6, "8.8": 2, "8.6": 5, "8.7": 2, "9.3": 2, "5.3": 2, "6.9": 5, "2.1": 1, "9.2": 1, "6.3": 1, "5.5": 1, "7.1": 2, "5.2": 1}}, "unknown": {"total": 2, "severity_distribution": {"UNKNOWN": 2}, "score_distribution": {"0.0": 2}}, "epss_summary": {"epss_gt_0_1": 951, "epss_gt_0_5": 308, "epss_gt_0_9": 69}}, "kev": {"kev_count": 131}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Google", "count": 1808}, {"name": "Microsoft", "count": 1757}, {"name": "Debian", "count": 968}, {"name": "Fedoraproject", "count": 954}, {"name": "Apple", "count": 875}, {"name": "Linux", "count": 592}, {"name": "Oracle", "count": 551}, {"name": "Netapp", "count": 502}, {"name": "Adobe", "count": 461}, {"name": "Ibm", "count": 421}, {"name": "Jenkins", "count": 393}, {"name": "Tenda", "count": 390}, {"name": "Siemens", "count": 341}, {"name": "Redhat", "count": 333}, {"name": "Cisco", "count": 317}, {"name": "Huawei", "count": 316}, {"name": "Intel", "count": 249}, {"name": "Qualcomm", "count": 247}, {"name": "Mediatek", "count": 240}, {"name": "Apache", "count": 223}]}, "cwe": {"top_cwes": [{"cwe": "CWE-79", "count": 4379}, {"cwe": "CWE-787", "count": 3013}, {"cwe": "CWE-89", "count": 2232}, {"cwe": "CWE-125", "count": 1182}, {"cwe": "CWE-20", "count": 1067}, {"cwe": "CWE-416", "count": 1001}, {"cwe": "CWE-22", "count": 955}, {"cwe": "CWE-352", "count": 943}, {"cwe": "CWE-78", "count": 770}, {"cwe": "CWE-862", "count": 688}, {"cwe": "CWE-434", "count": 642}, {"cwe": "CWE-120", "count": 639}, {"cwe": "CWE-287", "count": 558}, {"cwe": "CWE-200", "count": 542}, {"cwe": "CWE-476", "count": 524}, {"cwe": "CWE-119", "count": 416}, {"cwe": "CWE-269", "count": 377}, {"cwe": "CWE-863", "count": 373}, {"cwe": "CWE-284", "count": 362}, {"cwe": "CWE-400", "count": 344}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 24770}, {"status": "Analyzed", "count": 304}], "cve_tags": [], "reference_tags": [{"tag": "Third Party Advisory", "count": 56153}, {"tag": "Vendor Advisory", "count": 30186}, {"tag": "Exploit", "count": 22182}, {"tag": "Patch", "count": 18182}, {"tag": "Issue Tracking", "count": 7734}, {"tag": "Mailing List", "count": 5637}, {"tag": "Release Notes", "count": 5352}, {"tag": "VDB Entry", "count": 3694}, {"tag": "Product", "count": 2564}, {"tag": "Permissions Required", "count": 2245}, {"tag": "Mitigation", "count": 1776}, {"tag": "Broken Link", "count": 1342}, {"tag": "US Government Resource", "count": 1336}, {"tag": "Technical Description", "count": 606}, {"tag": "Not Applicable", "count": 400}, {"tag": "Press/Media Coverage", "count": 38}, {"tag": "URL Repurposed", "count": 16}, {"tag": "Tool Signature", "count": 16}]}}, "2023": {"year": 2023, "total_cves": 28816, "date_data": {"monthly_distribution": {"1": 2337, "2": 2122, "3": 2516, "4": 2330, "5": 2418, "6": 2384, "7": 2305, "8": 2477, "9": 2148, "10": 2680, "11": 2449, "12": 2650}, "daily_analysis": {"total_days": 361, "avg_per_day": 79.82, "highest_day": {"date": "2023-01-26", "count": 348}, "lowest_day": {"date": "2023-02-05", "count": 1}}}, "cvss": {"v2.0": {"total": 1926, "severity_distribution": {"UNKNOWN": 1926}, "score_distribution": {"5.2": 230, "4.0": 458, "2.7": 30, "7.5": 86, "6.5": 589, "2.6": 21, "1.4": 13, "5.0": 95, "5.8": 109, "2.1": 12, "4.6": 37, "3.3": 78, "4.1": 5, "2.3": 8, "4.9": 7, "3.7": 3, "5.5": 7, "1.7": 19, "4.3": 34, "1.0": 2, "3.5": 1, "5.1": 11, "4.7": 7, "6.8": 12, "9.0": 4, "7.8": 7, "8.3": 13, "6.0": 2, "6.1": 3, "6.4": 5, "7.2": 1, "3.2": 6, "10.0": 5, "1.8": 1, "1.2": 1, "7.7": 3, "4.8": 1}}, "v3.0": {"total": 1160, "severity_distribution": {"HIGH": 574, "MEDIUM": 370, "CRITICAL": 117, "LOW": 99}, "score_distribution": {"8.5": 86, "6.5": 41, "8.7": 5, "7.5": 32, "7.4": 5, "5.3": 35, "7.1": 22, "7.3": 31, "9.0": 14, "8.8": 62, "7.6": 18, "4.6": 11, "7.8": 140, "7.2": 87, "3.3": 61, "4.9": 1, "9.8": 47, "8.2": 8, "6.8": 34, "9.1": 18, "5.0": 5, "5.9": 12, "4.3": 26, "2.2": 2, "6.6": 5, "3.9": 1, "6.3": 20, "8.0": 13, "5.5": 14, "9.4": 2, "5.1": 11, "6.4": 7, "2.5": 1, "9.3": 7, "5.4": 41, "4.2": 4, "3.8": 3, "6.7": 7, "3.1": 6, "8.3": 18, "8.4": 5, "3.5": 16, "8.6": 8, "5.7": 7, "4.7": 9, "6.1": 19, "5.8": 5, "4.0": 14, "9.6": 9, "8.1": 24, "9.9": 4, "2.4": 2, "4.4": 7, "4.8": 10, "5.2": 10, "3.4": 1, "6.0": 7, "4.5": 2, "8.9": 2, "7.7": 6, "10.0": 16, "4.1": 3, "6.2": 2, "3.0": 1, "2.6": 1, "7.9": 1, "5.6": 1, "3.2": 1, "2.7": 3, "7.0": 1}}, "v3.1": {"total": 28815, "severity_distribution": {"MEDIUM": 14071, "HIGH": 9773, "LOW": 1315, "CRITICAL": 3652, "NONE": 4}, "score_distribution": {"5.5": 1906, "7.5": 2539, "3.5": 520, "7.3": 279, "6.3": 838, "3.1": 100, "2.6": 31, "4.3": 1453, "9.8": 2812, "5.3": 924, "5.0": 109, "4.7": 250, "2.4": 89, "4.6": 129, "5.4": 1937, "2.8": 16, "6.5": 1713, "6.1": 1185, "8.8": 1842, "7.2": 660, "5.9": 735, "3.7": 108, "3.3": 204, "2.0": 19, "2.5": 11, "4.8": 371, "8.1": 373, "9.9": 209, "8.5": 73, "7.7": 74, "5.6": 44, "7.8": 2075, "9.0": 102, "7.4": 114, "7.6": 142, "10.0": 103, "9.6": 92, "6.6": 83, "6.8": 239, "9.1": 266, "7.0": 155, "4.0": 76, "5.7": 97, "4.4": 379, "8.6": 146, "4.2": 55, "7.1": 636, "6.7": 597, "6.4": 241, "8.3": 80, "8.0": 142, "5.8": 80, "6.2": 110, "3.2": 10, "2.3": 11, "8.7": 39, "8.2": 227, "3.9": 32, "2.7": 64, "4.9": 241, "8.4": 141, "1.9": 8, "2.1": 5, "4.1": 57, "6.0": 94, "9.3": 47, "8.9": 14, "5.2": 22, "5.1": 58, "1.8": 4, "7.9": 22, "9.4": 21, "6.9": 15, "4.5": 33, "2.2": 13, "3.8": 30, "2.9": 9, "3.4": 13, "0.0": 4, "3.6": 11, "3.0": 7}}, "v4.0": {"total": 53, "severity_distribution": {"HIGH": 25, "MEDIUM": 17, "CRITICAL": 4, "LOW": 7}, "score_distribution": {"8.7": 6, "5.3": 8, "5.1": 3, "7.3": 14, "9.1": 1, "2.0": 4, "4.8": 1, "5.4": 1, "7.1": 3, "6.9": 4, "2.3": 1, "9.2": 1, "8.2": 1, "9.4": 2, "8.6": 1, "1.9": 1, "2.1": 1}}, "unknown": {"total": 1, "severity_distribution": {"UNKNOWN": 1}, "score_distribution": {"0.0": 1}}, "epss_summary": {"epss_gt_0_1": 958, "epss_gt_0_5": 390, "epss_gt_0_9": 88}}, "kev": {"kev_count": 165}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 1943}, {"name": "Google", "count": 1791}, {"name": "Apple", "count": 967}, {"name": "Adobe", "count": 676}, {"name": "Linux", "count": 611}, {"name": "Fedoraproject", "count": 555}, {"name": "Debian", "count": 516}, {"name": "Unisoc", "count": 464}, {"name": "Ibm", "count": 416}, {"name": "Intel", "count": 351}, {"name": "Redhat", "count": 329}, {"name": "Oracle", "count": 326}, {"name": "Mediatek", "count": 324}, {"name": "Qualcomm", "count": 315}, {"name": "Samsung", "count": 282}, {"name": "Apache", "count": 266}, {"name": "Cisco", "count": 266}, {"name": "Dell", "count": 264}, {"name": "Jenkins", "count": 255}, {"name": "Huawei", "count": 254}]}, "cwe": {"top_cwes": [{"cwe": "CWE-79", "count": 6203}, {"cwe": "CWE-787", "count": 2683}, {"cwe": "CWE-89", "count": 2647}, {"cwe": "CWE-352", "count": 1637}, {"cwe": "CWE-125", "count": 1317}, {"cwe": "CWE-862", "count": 1159}, {"cwe": "CWE-22", "count": 1113}, {"cwe": "CWE-20", "count": 986}, {"cwe": "CWE-416", "count": 946}, {"cwe": "CWE-120", "count": 903}, {"cwe": "CWE-78", "count": 863}, {"cwe": "CWE-77", "count": 738}, {"cwe": "CWE-434", "count": 731}, {"cwe": "CWE-200", "count": 639}, {"cwe": "CWE-863", "count": 538}, {"cwe": "CWE-94", "count": 523}, {"cwe": "CWE-400", "count": 523}, {"cwe": "CWE-287", "count": 504}, {"cwe": "CWE-284", "count": 495}, {"cwe": "CWE-269", "count": 431}]}, "metadata": {"vulnerability_status": [{"status": "Modified", "count": 28240}, {"status": "Analyzed", "count": 576}], "cve_tags": [], "reference_tags": [{"tag": "Third Party Advisory", "count": 44760}, {"tag": "Vendor Advisory", "count": 34212}, {"tag": "Patch", "count": 19568}, {"tag": "Exploit", "count": 19147}, {"tag": "Release Notes", "count": 7028}, {"tag": "Issue Tracking", "count": 6420}, {"tag": "Mailing List", "count": 6119}, {"tag": "Permissions Required", "count": 5911}, {"tag": "Product", "count": 4849}, {"tag": "VDB Entry", "count": 4234}, {"tag": "Broken Link", "count": 1657}, {"tag": "Not Applicable", "count": 1219}, {"tag": "Mitigation", "count": 1121}, {"tag": "US Government Resource", "count": 1037}, {"tag": "Technical Description", "count": 756}, {"tag": "Press/Media Coverage", "count": 102}, {"tag": "URL Repurposed", "count": 8}, {"tag": "Tool Signature", "count": 2}]}}, "2024": {"year": 2024, "total_cves": 39953, "date_data": {"monthly_distribution": {"1": 2594, "2": 2778, "3": 3309, "4": 3621, "5": 4999, "6": 3078, "7": 3113, "8": 2896, "9": 2514, "10": 3564, "11": 4056, "12": 3431}, "daily_analysis": {"total_days": 357, "avg_per_day": 111.91, "highest_day": {"date": "2024-05-03", "count": 845}, "lowest_day": {"date": "2024-01-14", "count": 2}}}, "cvss": {"v2.0": {"total": 2971, "severity_distribution": {"UNKNOWN": 2971}, "score_distribution": {"5.1": 12, "5.0": 227, "6.5": 1001, "4.0": 494, "2.6": 36, "3.3": 115, "6.4": 5, "2.1": 10, "5.2": 38, "2.7": 11, "4.3": 17, "7.7": 6, "7.8": 5, "7.5": 383, "5.8": 164, "8.3": 30, "10.0": 15, "6.8": 29, "7.3": 2, "1.4": 5, "5.5": 16, "9.0": 283, "3.2": 2, "1.7": 19, "9.3": 2, "9.4": 1, "4.8": 1, "4.6": 15, "1.8": 2, "1.0": 4, "3.7": 1, "4.7": 3, "0.8": 1, "6.1": 3, "6.3": 2, "4.9": 2, "6.0": 1, "7.6": 3, "2.3": 2, "6.2": 2, "3.5": 1}}, "v3.0": {"total": 1908, "severity_distribution": {"HIGH": 1239, "MEDIUM": 300, "LOW": 198, "CRITICAL": 170, "NONE": 1}, "score_distribution": {"8.2": 25, "5.4": 17, "4.3": 25, "6.1": 9, "6.5": 60, "8.8": 254, "7.8": 612, "3.3": 164, "7.5": 122, "3.8": 2, "3.1": 8, "6.8": 62, "7.9": 3, "9.8": 87, "4.1": 1, "5.7": 6, "7.4": 13, "4.4": 12, "7.2": 50, "7.7": 11, "3.5": 4, "10.0": 5, "9.6": 16, "5.5": 13, "1.9": 1, "9.9": 10, "7.1": 30, "7.0": 14, "8.0": 18, "9.0": 5, "4.6": 3, "8.1": 29, "5.8": 3, "9.1": 38, "6.3": 4, "7.6": 7, "8.3": 11, "5.3": 29, "6.6": 6, "4.9": 6, "8.6": 11, "3.7": 2, "5.9": 7, "2.6": 2, "6.7": 11, "7.3": 15, "4.0": 6, "9.3": 6, "5.0": 3, "8.5": 3, "4.8": 5, "9.4": 3, "3.4": 5, "0.0": 1, "4.2": 2, "2.2": 2, "6.0": 1, "2.8": 1, "8.4": 10, "2.7": 2, "8.7": 1, "6.4": 2, "4.7": 2, "3.9": 1, "6.2": 3, "2.9": 1, "5.1": 1, "5.2": 1, "2.4": 1, "3.6": 1, "2.5": 1}}, "v3.1": {"total": 39097, "severity_distribution": {"MEDIUM": 19788, "LOW": 1582, "CRITICAL": 3751, "HIGH": 13969, "NONE": 7}, "score_distribution": {"5.6": 44, "4.3": 1937, "6.3": 1371, "3.5": 552, "9.1": 453, "8.3": 162, "9.8": 2466, "3.7": 155, "5.3": 1731, "8.8": 2639, "2.4": 135, "6.5": 2700, "8.4": 281, "7.2": 685, "2.6": 25, "5.5": 3281, "4.7": 478, "7.8": 3273, "6.7": 388, "7.5": 2499, "5.4": 1606, "7.3": 771, "6.4": 1326, "7.1": 1262, "4.4": 328, "5.7": 174, "9.6": 150, "4.9": 281, "4.6": 163, "6.2": 208, "3.8": 71, "6.1": 1437, "8.2": 328, "7.4": 190, "8.6": 197, "5.9": 685, "8.0": 307, "8.1": 542, "5.1": 86, "9.3": 117, "7.6": 226, "8.7": 61, "5.0": 117, "9.9": 169, "7.0": 177, "3.3": 241, "6.8": 347, "4.8": 425, "10.0": 234, "7.7": 142, "6.0": 84, "4.0": 113, "9.4": 45, "6.6": 122, "2.3": 18, "4.1": 69, "3.9": 32, "5.2": 29, "5.8": 94, "7.9": 30, "4.5": 40, "2.2": 26, "2.7": 82, "2.9": 24, "3.1": 100, "6.9": 35, "9.0": 115, "8.5": 187, "4.2": 89, "3.2": 2, "3.4": 15, "1.7": 1, "2.0": 15, "2.5": 21, "1.8": 7, "3.0": 21, "2.8": 19, "3.6": 12, "8.9": 10, "1.9": 6, "0.0": 7, "1.6": 1, "2.1": 1, "9.2": 2}}, "v4.0": {"total": 3576, "severity_distribution": {"MEDIUM": 2246, "CRITICAL": 275, "HIGH": 934, "LOW": 121}, "score_distribution": {"6.3": 52, "5.3": 1089, "5.1": 252, "10.0": 39, "9.0": 5, "8.7": 344, "4.8": 53, "1.0": 8, "8.6": 70, "8.5": 79, "7.3": 88, "2.0": 23, "7.1": 94, "2.3": 32, "6.9": 518, "7.5": 11, "8.2": 38, "5.2": 12, "8.9": 18, "5.7": 15, "9.2": 43, "7.0": 42, "7.7": 24, "9.3": 138, "6.7": 7, "5.9": 24, "6.8": 56, "5.4": 67, "4.6": 18, "8.1": 4, "2.1": 34, "1.8": 8, "8.4": 35, "9.4": 32, "6.4": 3, "1.3": 1, "8.8": 37, "6.0": 27, "8.3": 25, "5.6": 6, "5.5": 6, "9.1": 7, "7.4": 1, "1.2": 5, "1.9": 2, "7.2": 11, "6.2": 4, "7.8": 3, "6.1": 2, "9.5": 9, "6.5": 1, "9.9": 2, "7.6": 7, "5.8": 11, "4.3": 4, "4.1": 2, "4.9": 2, "2.4": 6, "6.6": 9, "4.4": 2, "5.0": 4, "2.7": 2, "7.9": 3}}, "unknown": {"total": 8, "severity_distribution": {"UNKNOWN": 8}, "score_distribution": {"0.0": 8}}, "epss_summary": {"epss_gt_0_1": 949, "epss_gt_0_5": 334, "epss_gt_0_9": 86}}, "kev": {"kev_count": 160}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Linux", "count": 4528}, {"name": "Microsoft", "count": 1803}, {"name": "Apple", "count": 959}, {"name": "Google", "count": 898}, {"name": "Adobe", "count": 760}, {"name": "Ibm", "count": 509}, {"name": "Debian", "count": 509}, {"name": "Tenda", "count": 432}, {"name": "Dlink", "count": 399}, {"name": "Oracle", "count": 384}, {"name": "Fedoraproject", "count": 361}, {"name": "Oretnom23", "count": 346}, {"name": "Cisco", "count": 324}, {"name": "Samsung", "count": 272}, {"name": "Apache", "count": 267}, {"name": "Totolink", "count": 262}, {"name": "Dell", "count": 259}, {"name": "Qualcomm", "count": 257}, {"name": "Campcodes", "count": 223}, {"name": "Huawei", "count": 220}]}, "cwe": {"top_cwes": [{"cwe": "CWE-79", "count": 9391}, {"cwe": "CWE-89", "count": 3364}, {"cwe": "CWE-787", "count": 2467}, {"cwe": "CWE-862", "count": 2234}, {"cwe": "CWE-352", "count": 1729}, {"cwe": "CWE-416", "count": 1699}, {"cwe": "CWE-125", "count": 1559}, {"cwe": "CWE-476", "count": 1359}, {"cwe": "CWE-22", "count": 1311}, {"cwe": "CWE-78", "count": 1034}, {"cwe": "CWE-434", "count": 935}, {"cwe": "CWE-121", "count": 903}, {"cwe": "CWE-94", "count": 870}, {"cwe": "CWE-200", "count": 837}, {"cwe": "CWE-120", "count": 822}, {"cwe": "CWE-284", "count": 784}, {"cwe": "CWE-20", "count": 721}, {"cwe": "CWE-77", "count": 617}, {"cwe": "CWE-502", "count": 543}, {"cwe": "CWE-122", "count": 532}]}, "metadata": {"vulnerability_status": [{"status": "Analyzed", "count": 17747}, {"status": "Modified", "count": 14432}, {"status": "Deferred", "count": 7769}, {"status": "Undergoing Analysis", "count": 5}], "cve_tags": [], "reference_tags": [{"tag": "Patch", "count": 44102}, {"tag": "Third Party Advisory", "count": 34380}, {"tag": "Vendor Advisory", "count": 23331}, {"tag": "Exploit", "count": 14039}, {"tag": "VDB Entry", "count": 8190}, {"tag": "Permissions Required", "count": 6451}, {"tag": "Product", "count": 6366}, {"tag": "Mailing List", "count": 5454}, {"tag": "Issue Tracking", "count": 4132}, {"tag": "Release Notes", "count": 3871}, {"tag": "Broken Link", "count": 2042}, {"tag": "Mitigation", "count": 537}, {"tag": "US Government Resource", "count": 528}, {"tag": "Not Applicable", "count": 454}, {"tag": "Technical Description", "count": 353}, {"tag": "Press/Media Coverage", "count": 92}, {"tag": "Related", "count": 15}, {"tag": "URL Repurposed", "count": 8}, {"tag": "Tool Signature", "count": 8}]}}, "2025": {"year": 2025, "total_cves": 48153, "date_data": {"monthly_distribution": {"1": 4275, "2": 3673, "3": 3998, "4": 4034, "5": 3980, "6": 3681, "7": 3776, "8": 3628, "9": 4321, "10": 4273, "11": 3021, "12": 5493}, "daily_analysis": {"total_days": 365, "avg_per_day": 131.93, "highest_day": {"date": "2025-02-26", "count": 792}, "lowest_day": {"date": "2025-02-02", "count": 3}}}, "cvss": {"v2.0": {"total": 5899, "severity_distribution": {"UNKNOWN": 5899}, "score_distribution": {"6.0": 22, "7.5": 1707, "2.6": 102, "6.2": 4, "4.0": 578, "4.3": 194, "1.7": 124, "5.8": 216, "6.5": 1339, "5.0": 406, "5.1": 37, "9.0": 530, "3.3": 264, "6.8": 39, "3.5": 11, "1.0": 23, "5.2": 23, "4.6": 19, "7.8": 3, "8.3": 25, "3.4": 1, "2.1": 31, "7.6": 5, "5.5": 55, "1.8": 14, "1.4": 3, "6.4": 5, "2.7": 7, "1.2": 8, "10.0": 47, "2.2": 2, "7.7": 24, "7.2": 5, "6.1": 5, "3.2": 3, "2.9": 1, "7.4": 2, "3.7": 2, "2.3": 1, "3.6": 1, "4.8": 2, "0.8": 5, "4.7": 2, "3.8": 1, "5.9": 1}}, "v3.0": {"total": 1136, "severity_distribution": {"MEDIUM": 339, "CRITICAL": 97, "LOW": 71, "HIGH": 629}, "score_distribution": {"5.3": 43, "5.6": 3, "9.8": 55, "5.5": 9, "6.1": 25, "6.8": 43, "4.9": 5, "4.0": 2, "6.6": 5, "3.1": 5, "4.4": 4, "7.3": 19, "8.1": 22, "3.6": 2, "7.0": 13, "7.8": 287, "7.2": 22, "7.5": 130, "3.3": 38, "8.0": 13, "6.5": 59, "9.1": 18, "6.3": 17, "8.3": 2, "8.8": 67, "4.6": 3, "5.4": 29, "7.6": 6, "8.2": 13, "2.4": 2, "3.5": 10, "7.1": 18, "7.7": 4, "9.6": 2, "9.4": 6, "7.4": 8, "4.3": 39, "5.8": 5, "5.9": 8, "10.0": 3, "4.2": 2, "8.4": 3, "6.9": 1, "9.0": 4, "4.7": 2, "6.7": 14, "6.2": 3, "9.3": 2, "5.0": 3, "4.8": 8, "5.2": 2, "2.7": 2, "6.4": 2, "3.7": 6, "3.8": 3, "9.9": 7, "2.1": 1, "2.5": 1, "4.5": 2, "5.1": 1, "3.4": 1, "8.6": 1, "8.7": 1}}, "v3.1": {"total": 44523, "severity_distribution": {"MEDIUM": 22169, "CRITICAL": 3820, "HIGH": 16457, "LOW": 2073, "NONE": 4}, "score_distribution": {"5.4": 1907, "5.6": 112, "9.8": 2533, "8.8": 2481, "7.5": 2848, "7.4": 139, "7.0": 248, "8.3": 95, "7.2": 592, "6.1": 1383, "6.5": 3560, "9.9": 147, "3.9": 23, "3.4": 24, "4.9": 381, "5.0": 151, "5.5": 3421, "6.3": 1606, "5.7": 117, "7.3": 2119, "3.1": 168, "3.7": 189, "7.8": 3111, "4.4": 229, "6.7": 304, "6.2": 163, "6.4": 1169, "5.1": 120, "5.3": 2033, "8.2": 269, "4.3": 2700, "8.4": 220, "8.1": 833, "6.8": 311, "4.1": 87, "4.7": 485, "5.8": 102, "3.5": 590, "9.1": 510, "6.6": 162, "7.1": 2255, "10.0": 206, "3.3": 322, "5.9": 628, "7.9": 32, "3.0": 13, "8.0": 193, "8.9": 17, "8.5": 210, "4.8": 405, "7.7": 158, "2.7": 124, "2.5": 46, "4.6": 171, "6.0": 90, "4.2": 92, "4.0": 163, "3.8": 84, "8.6": 252, "2.6": 29, "2.3": 20, "2.9": 48, "3.2": 35, "7.6": 265, "5.2": 32, "4.5": 63, "8.7": 120, "2.8": 25, "1.9": 9, "9.3": 177, "2.4": 262, "9.6": 112, "2.0": 21, "1.6": 5, "9.0": 95, "9.4": 39, "0.0": 4, "2.2": 20, "6.9": 22, "1.8": 4, "3.6": 9, "2.1": 3, "9.2": 1}}, "v4.0": {"total": 12421, "severity_distribution": {"HIGH": 3209, "CRITICAL": 1022, "MEDIUM": 5808, "LOW": 2373, "NONE": 9}, "score_distribution": {"7.5": 59, "8.7": 861, "8.4": 169, "9.3": 563, "8.6": 276, "10.0": 153, "8.5": 259, "9.4": 155, "8.3": 67, "7.3": 148, "5.1": 814, "6.9": 1327, "7.1": 293, "9.5": 31, "7.2": 63, "5.3": 1153, "8.8": 104, "9.2": 72, "1.3": 67, "2.9": 79, "5.4": 103, "6.8": 100, "8.2": 78, "1.9": 301, "2.3": 121, "5.2": 30, "4.8": 410, "5.9": 77, "5.8": 31, "4.3": 4, "5.6": 20, "7.4": 441, "6.1": 35, "6.0": 82, "6.2": 17, "9.9": 18, "6.7": 24, "7.0": 121, "6.3": 164, "2.1": 1151, "2.4": 30, "9.1": 14, "4.6": 59, "2.0": 478, "7.7": 97, "1.8": 21, "5.7": 62, "4.1": 16, "7.6": 18, "1.0": 25, "6.4": 50, "5.5": 1162, "1.1": 23, "9.0": 16, "4.4": 5, "8.1": 16, "2.7": 28, "4.5": 7, "8.9": 111, "4.7": 4, "7.8": 18, "6.6": 33, "7.9": 6, "4.0": 3, "8.0": 4, "1.7": 11, "5.0": 4, "0.0": 9, "4.9": 7, "6.5": 5, "1.2": 11, "2.6": 1, "0.3": 8, "0.9": 6, "2.5": 1, "0.5": 2, "0.6": 3, "2.2": 3, "3.7": 1, "3.8": 2}}, "unknown": {"total": 897, "severity_distribution": {"UNKNOWN": 897}, "score_distribution": {"0.0": 897}}, "epss_summary": {"epss_gt_0_1": 697, "epss_gt_0_5": 186, "epss_gt_0_9": 58}}, "kev": {"kev_count": 197}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Linux", "count": 4720}, {"name": "Microsoft", "count": 1938}, {"name": "Apple", "count": 1110}, {"name": "Adobe", "count": 829}, {"name": "Google", "count": 690}, {"name": "Debian", "count": 680}, {"name": "Phpgurukul", "count": 615}, {"name": "Ibm", "count": 609}, {"name": "Tenda", "count": 469}, {"name": "Fabian", "count": 353}, {"name": "Totolink", "count": 339}, {"name": "Dlink", "count": 329}, {"name": "Oracle", "count": 322}, {"name": "Campcodes", "count": 310}, {"name": "Samsung", "count": 298}, {"name": "Qualcomm", "count": 274}, {"name": "Fortinet", "count": 237}, {"name": "Code-Projects", "count": 231}, {"name": "Huawei", "count": 224}, {"name": "Dell", "count": 223}]}, "cwe": {"top_cwes": [{"cwe": "CWE-79", "count": 8837}, {"cwe": "CWE-89", "count": 5313}, {"cwe": "CWE-74", "count": 2573}, {"cwe": "CWE-862", "count": 2413}, {"cwe": "CWE-352", "count": 1996}, {"cwe": "CWE-476", "count": 1580}, {"cwe": "CWE-94", "count": 1456}, {"cwe": "CWE-787", "count": 1293}, {"cwe": "CWE-284", "count": 1253}, {"cwe": "CWE-416", "count": 1214}, {"cwe": "CWE-22", "count": 1172}, {"cwe": "CWE-119", "count": 1160}, {"cwe": "CWE-125", "count": 1103}, {"cwe": "CWE-434", "count": 1064}, {"cwe": "CWE-120", "count": 1027}, {"cwe": "CWE-78", "count": 1003}, {"cwe": "CWE-121", "count": 884}, {"cwe": "CWE-77", "count": 860}, {"cwe": "CWE-200", "count": 834}, {"cwe": "CWE-401", "count": 772}]}, "metadata": {"vulnerability_status": [{"status": "Analyzed", "count": 23649}, {"status": "Deferred", "count": 17963}, {"status": "Modified", "count": 6529}, {"status": "Undergoing Analysis", "count": 11}, {"status": "Awaiting Analysis", "count": 1}], "cve_tags": [], "reference_tags": [{"tag": "Third Party Advisory", "count": 28381}, {"tag": "Patch", "count": 25931}, {"tag": "Exploit", "count": 15853}, {"tag": "Vendor Advisory", "count": 15307}, {"tag": "VDB Entry", "count": 15189}, {"tag": "Product", "count": 6856}, {"tag": "Permissions Required", "count": 5921}, {"tag": "Issue Tracking", "count": 5710}, {"tag": "Release Notes", "count": 3416}, {"tag": "Mailing List", "count": 1229}, {"tag": "Broken Link", "count": 1222}, {"tag": "Mitigation", "count": 535}, {"tag": "US Government Resource", "count": 424}, {"tag": "Not Applicable", "count": 370}, {"tag": "Technical Description", "count": 184}, {"tag": "Press/Media Coverage", "count": 103}, {"tag": "Related", "count": 8}, {"tag": "URL Repurposed", "count": 5}, {"tag": "Tool Signature", "count": 1}]}}, "2026": {"year": 2026, "total_cves": 69597, "date_data": {"monthly_distribution": {"1": 4302, "2": 4616, "3": 6234, "4": 5810, "5": 6938, "6": 7942, "7": 9770, "8": 12259, "9": 11726, "10": 0, "11": 0, "12": 0}, "daily_analysis": {"total_days": 264, "avg_per_day": 263.62, "highest_day": {"date": "2026-09-08", "count": 1559}, "lowest_day": {"date": "2026-01-03", "count": 3}}}, "cvss": {"v2.0": {"total": 5118, "severity_distribution": {"UNKNOWN": 5118}, "score_distribution": {"5.0": 496, "4.3": 186, "4.6": 34, "6.5": 1122, "7.5": 1119, "5.8": 205, "3.3": 133, "1.7": 196, "9.0": 520, "4.0": 401, "5.5": 52, "2.6": 105, "6.4": 40, "10.0": 158, "8.3": 92, "6.0": 14, "4.7": 11, "2.1": 28, "5.1": 47, "1.2": 3, "6.2": 1, "5.9": 1, "2.2": 1, "7.6": 10, "6.8": 44, "1.8": 8, "3.6": 5, "5.2": 10, "1.0": 18, "3.5": 6, "6.1": 2, "2.7": 4, "7.8": 3, "7.7": 7, "8.5": 2, "3.2": 11, "1.4": 8, "2.4": 10, "7.1": 2, "4.8": 1, "2.9": 2}}, "v3.0": {"total": 628, "severity_distribution": {"MEDIUM": 195, "CRITICAL": 65, "HIGH": 336, "LOW": 29, "NONE": 3}, "score_distribution": {"6.4": 2, "9.6": 6, "7.5": 45, "9.1": 4, "7.8": 117, "6.3": 12, "8.1": 18, "4.2": 2, "7.1": 14, "2.8": 1, "6.5": 23, "5.9": 10, "7.0": 7, "9.8": 40, "3.3": 10, "6.0": 1, "5.3": 18, "5.7": 4, "10.0": 7, "4.4": 5, "5.5": 9, "7.3": 17, "4.7": 9, "8.8": 51, "4.8": 4, "5.8": 2, "2.7": 2, "6.1": 13, "7.2": 34, "6.7": 12, "7.9": 1, "4.9": 2, "8.2": 4, "4.3": 26, "4.6": 2, "5.4": 16, "7.6": 1, "6.8": 12, "8.6": 4, "8.7": 2, "5.0": 3, "7.7": 3, "8.3": 5, "8.0": 7, "2.2": 1, "4.1": 2, "7.4": 2, "8.5": 4, "9.0": 1, "9.3": 1, "1.8": 1, "9.9": 6, "3.7": 4, "0.0": 3, "5.6": 1, "2.4": 4, "3.8": 1, "3.1": 2, "5.2": 1, "6.2": 2, "6.6": 1, "3.5": 1, "3.9": 1, "2.5": 1, "4.0": 1}}, "v3.1": {"total": 63243, "severity_distribution": {"HIGH": 27333, "CRITICAL": 7634, "MEDIUM": 25693, "LOW": 2556, "NONE": 27}, "score_distribution": {"7.5": 5834, "9.8": 3914, "9.1": 1279, "5.3": 3190, "6.1": 1539, "7.2": 1129, "6.4": 1049, "8.2": 975, "9.9": 677, "8.8": 4619, "4.3": 3097, "6.2": 442, "5.5": 2909, "7.8": 4148, "8.4": 547, "8.1": 2348, "7.1": 1995, "5.4": 1937, "10.0": 452, "5.9": 732, "6.5": 4741, "6.8": 524, "4.0": 126, "8.3": 550, "8.6": 509, "7.6": 363, "3.5": 329, "6.3": 1545, "4.8": 387, "4.1": 76, "8.0": 373, "4.9": 455, "6.7": 307, "5.0": 282, "7.7": 535, "7.3": 1646, "7.4": 501, "4.6": 197, "2.0": 22, "9.0": 187, "3.3": 437, "3.7": 477, "2.4": 152, "5.8": 205, "5.6": 112, "9.4": 116, "2.7": 233, "3.1": 396, "9.6": 605, "2.9": 58, "7.0": 517, "5.7": 179, "4.2": 238, "8.5": 383, "8.9": 37, "3.4": 37, "4.7": 497, "9.3": 399, "5.1": 74, "7.9": 52, "4.4": 397, "2.2": 34, "6.6": 195, "8.7": 272, "2.3": 18, "6.0": 121, "3.8": 104, "3.2": 23, "2.6": 41, "2.8": 26, "1.8": 9, "6.9": 47, "4.5": 53, "3.9": 24, "5.2": 40, "1.9": 14, "0.0": 27, "3.0": 25, "3.6": 40, "2.5": 54, "9.2": 5, "2.1": 3}}, "v4.0": {"total": 21762, "severity_distribution": {"CRITICAL": 2156, "MEDIUM": 7730, "HIGH": 8258, "LOW": 3566, "NONE": 52}, "score_distribution": {"9.3": 1150, "6.9": 1503, "8.7": 2022, "5.1": 1115, "8.8": 595, "5.3": 1201, "6.8": 258, "8.5": 659, "8.6": 752, "7.1": 1183, "7.0": 252, "9.1": 98, "8.4": 334, "4.8": 314, "6.7": 95, "4.6": 160, "9.0": 58, "7.7": 284, "7.2": 208, "6.3": 545, "7.3": 247, "1.8": 36, "8.3": 247, "9.2": 331, "5.5": 1327, "5.6": 51, "4.1": 24, "8.2": 358, "2.3": 307, "5.9": 172, "1.7": 32, "2.0": 470, "6.0": 274, "2.7": 43, "0.1": 2, "5.7": 101, "5.2": 38, "7.5": 108, "2.1": 1740, "7.6": 163, "1.9": 481, "7.4": 526, "1.3": 127, "4.9": 58, "1.2": 42, "2.2": 3, "8.1": 24, "4.4": 13, "9.4": 274, "10.0": 177, "7.9": 15, "5.0": 7, "6.6": 60, "5.4": 93, "8.9": 229, "2.4": 38, "9.5": 57, "5.8": 86, "3.8": 3, "0.0": 52, "0.4": 1, "1.1": 46, "1.0": 19, "6.2": 28, "4.5": 12, "4.0": 13, "0.6": 12, "3.6": 6, "4.7": 10, "2.9": 133, "6.4": 55, "0.9": 13, "6.1": 81, "4.3": 23, "7.8": 42, "8.0": 10, "6.5": 12, "0.3": 4, "9.9": 11, "2.5": 1, "3.3": 2, "0.5": 4, "1.6": 1, "4.2": 1}}, "unknown": {"total": 1849, "severity_distribution": {"UNKNOWN": 1849}, "score_distribution": {"0.0": 1849}}, "epss_summary": {"epss_gt_0_1": 315, "epss_gt_0_5": 81, "epss_gt_0_9": 23}}, "kev": {"kev_count": 165}, "vendors": {"cna_assigners": [], "cpe_vendors": [{"name": "Microsoft", "count": 4359}, {"name": "Linux", "count": 4213}, {"name": "Google", "count": 3286}, {"name": "Oracle", "count": 2692}, {"name": "Apple", "count": 2289}, {"name": "Ibm", "count": 814}, {"name": "Adobe", "count": 783}, {"name": "Apache", "count": 727}, {"name": "Openclaw", "count": 577}, {"name": "Mozilla", "count": 435}, {"name": "Redhat", "count": 399}, {"name": "Dell", "count": 376}, {"name": "Tenda", "count": 272}, {"name": "Dlink", "count": 211}, {"name": "Gitlab", "count": 186}, {"name": "Samsung", "count": 183}, {"name": "Nvidia", "count": 177}, {"name": "Vmware", "count": 177}, {"name": "N8N", "count": 162}, {"name": "Cisco", "count": 156}]}, "cwe": {"top_cwes": [{"cwe": "CWE-79", "count": 6342}, {"cwe": "CWE-284", "count": 3721}, {"cwe": "CWE-862", "count": 3591}, {"cwe": "CWE-89", "count": 3571}, {"cwe": "CWE-22", "count": 2437}, {"cwe": "CWE-416", "count": 2388}, {"cwe": "CWE-78", "count": 1852}, {"cwe": "CWE-125", "count": 1799}, {"cwe": "CWE-787", "count": 1779}, {"cwe": "CWE-918", "count": 1737}, {"cwe": "CWE-20", "count": 1687}, {"cwe": "CWE-200", "count": 1658}, {"cwe": "CWE-94", "count": 1637}, {"cwe": "CWE-863", "count": 1627}, {"cwe": "CWE-74", "count": 1588}, {"cwe": "CWE-639", "count": 1558}, {"cwe": "CWE-306", "count": 1494}, {"cwe": "CWE-122", "count": 1386}, {"cwe": "CWE-121", "count": 1141}, {"cwe": "CWE-269", "count": 1126}]}, "metadata": {"vulnerability_status": [{"status": "Analyzed", "count": 30074}, {"status": "Deferred", "count": 25208}, {"status": "Awaiting Analysis", "count": 4954}, {"status": "Received", "count": 4268}, {"status": "Modified", "count": 4230}, {"status": "Undergoing Analysis", "count": 863}], "cve_tags": [], "reference_tags": [{"tag": "Vendor Advisory", "count": 32012}, {"tag": "Patch", "count": 26171}, {"tag": "Third Party Advisory", "count": 12540}, {"tag": "Exploit", "count": 9808}, {"tag": "Release Notes", "count": 9275}, {"tag": "Product", "count": 5327}, {"tag": "Permissions Required", "count": 4932}, {"tag": "VDB Entry", "count": 4808}, {"tag": "Issue Tracking", "count": 4477}, {"tag": "Mitigation", "count": 3443}, {"tag": "Mailing List", "count": 1621}, {"tag": "Broken Link", "count": 719}, {"tag": "US Government Resource", "count": 509}, {"tag": "Not Applicable", "count": 305}, {"tag": "Technical Description", "count": 61}, {"tag": "Press/Media Coverage", "count": 24}, {"tag": "URL Repurposed", "count": 3}]}}}}
\ No newline at end of file
diff --git a/web/epss.html b/web/epss.html
new file mode 100644
index 00000000000..239ccd4ce2a
--- /dev/null
+++ b/web/epss.html
@@ -0,0 +1,199 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>EPSS scores &mdash; CVEDB</title>
+
+<meta name="description" content="How many CVEs carry each EPSS exploit-probability score band.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    >Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      >Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  class="on" aria-current="page">Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph"><h1>EPSS scores</h1><span class="note">exploit probability, from FIRST</span></div>
+<p class="lede">EPSS gives each CVE a probability of exploitation in the next 30 days. Counts of
+how many sit in each band &mdash; the distribution is heavily weighted to the bottom.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Score bands</h2>
+<div class="panel"><div class="panel-b"><div id="buckets"></div></div></div>
+
+<h2>CVEs above each threshold</h2>
+<div class="panel"><div class="panel-b"><div id="thresholds"></div></div></div>
+
+<h2>Scored CVEs per year</h2>
+<div class="panel">
+  <div class="panel-h">How many CVEs from each year carry an EPSS score</div>
+  <div class="panel-b"><div id="coverage"></div></div>
+</div>
+
+<h2>Highest-scoring CVEs</h2>
+<div class="panel"><div id="high-table"></div></div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async (S) => {
+  const { fmt, chart, el, table } = CVE;
+  const YR = 2026;
+  const d = await CVE.json('epss_analysis.json');
+  const st = d.statistics || {};
+  // Two different populations, kept apart deliberately:
+  //  - matched: EPSS rows tied to a CVE this site counts. Comparable with every
+  //    other total on the site, so it is the headline.
+  //  - rows: every EPSS row, which is what the threshold statistics are computed
+  //    over, so it must be the denominator for their percentages.
+  const rows = d.total_cves_with_epss || 0;
+  const unmatched = d.epss_without_published_record || 0;
+  const total = d.total_cves_with_epss_matched ?? rows;
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'CVEs with an EPSS score', v: fmt.n(total),
+      sub: `average score <b>${(st.average_score ?? 0).toFixed(5)}</b>${unmatched
+        ? ` &middot; <b>${fmt.n(unmatched)}</b> further EPSS rows describe CVEs not counted here` : ''}` },
+    { lbl: 'Above 0.5', v: fmt.n(st.gt_0_5), sub: `<b>${fmt.share(st.gt_0_5, rows, 2)}</b> of scored rows` },
+    { lbl: 'Above 0.9', v: fmt.n(st.gt_0_9), sub: `<b>${fmt.share(st.gt_0_9, rows, 2)}</b> of scored rows` },
+    { lbl: 'Above 0.1', v: fmt.n(st.gt_0_1), sub: `<b>${fmt.share(st.gt_0_1, rows, 2)}</b> of scored rows` }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  const labels = {
+    very_low: 'Very low', low: 'Low', medium: 'Medium',
+    high: 'High', very_high: 'Very high', critical: 'Critical'
+  };
+  chart.hbars('#buckets', Object.entries(d.score_buckets || {})
+    .map(([k, v]) => ({ label: labels[k] || k, value: v })), { name: 'cve-icu-epss-bands' });
+
+  chart.hbars('#thresholds', [
+    { label: '> 0.1', value: st.gt_0_1 || 0 },
+    { label: '> 0.3', value: st.gt_0_3 || 0 },
+    { label: '> 0.5', value: st.gt_0_5 || 0 },
+    { label: '> 0.7', value: st.gt_0_7 || 0 },
+    { label: '> 0.9', value: st.gt_0_9 || 0 }
+  ], { name: 'cve-icu-epss-thresholds' });
+
+  const cov = d.year_coverage || {};
+  const years = Object.keys(cov).sort();
+  chart.bars('#coverage', years.map(y => ({
+    label: y, value: cov[y].with_epss || 0, current: +y === YR
+  })), { ticks: [years[0], years[years.length - 1]] , name: 'cve-icu-epss-coverage-per-year' });
+
+  table('#high-table', (d.high_risk_cves || []).slice(0, 50).map(c => ({
+    cve: c.cve_id,
+    score: c.epss_score,
+    pct: c.epss_percentile
+  })), [
+    { key: 'cve', label: 'CVE' },
+    { key: 'score', label: 'EPSS score', num: true, fmt: v => (+v).toFixed(5) },
+    { key: 'pct', label: 'Percentile', num: true, fmt: v => (v * 100).toFixed(3) + '%' }
+  ], { sort: { key: 'score', dir: -1 } }, { name: 'cve-icu-epss-highest-scoring' });
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/growth.html b/web/growth.html
new file mode 100644
index 00000000000..8e16f349064
--- /dev/null
+++ b/web/growth.html
@@ -0,0 +1,197 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>Year-over-year change &mdash; CVEDB</title>
+
+<meta name="description" content="How CVE publication counts changed from one year to the next, 1999 to 2026.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    class="on" aria-current="page">Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      >Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  >Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph">
+  <h1>Year-over-year change</h1>
+  <span class="note">1999&ndash;2026</span>
+</div>
+<p class="lede">The same counts as <a href="years.html" style="color:var(--accent)">Years</a>,
+expressed as change. 2026 is partial, so it is shown against both the same point
+last year and last year's completed total &mdash; those answer different questions.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Change per year</h2>
+<div class="panel">
+  <div class="panel-h">Percent change against the prior year
+    <span class="side">bars above the line are increases</span></div>
+  <div class="panel-b"><div id="chart-growth"></div></div>
+</div>
+
+<h2>Absolute counts</h2>
+<div class="panel">
+  <div class="panel-h">CVEs added compared with the year before</div>
+  <div class="panel-b"><div id="chart-abs"></div></div>
+</div>
+
+<h2>All years</h2>
+<div class="panel"><div id="growth-table"></div></div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async (S) => {
+  const { fmt, chart, el, table } = CVE;
+  const YR = 2026;
+  const g = await CVE.json('growth_analysis.json');
+  const data = g.growth_data || [];
+  const cur = data.find(d => d.is_ytd) || data[data.length - 1] || {};
+  const prevFull = (data.find(d => d.year === YR - 1) || {}).cves;
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: `${YR} so far`, v: fmt.n(cur.cves),
+      sub: `projected full year <b>${fmt.compact(cur.projected_full_year)}</b>` },
+    { lbl: `vs same point in ${YR - 1}`, v: fmt.pct(cur.ytd_vs_prev_ytd),
+      sub: `against <b>${fmt.n(cur.prev_year_ytd_actual)}</b> by this date` },
+    { lbl: `vs all of ${YR - 1}`, v: fmt.pct(cur.ytd_vs_prev_full),
+      sub: `against <b>${fmt.n(prevFull)}</b> for the full year` },
+    { lbl: 'Average annual change', v: fmt.pct(g.avg_annual_growth),
+      sub: 'across all years on record' }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}">
+      <div class="lbl">${t.lbl}</div><div class="v">${t.v}</div>
+      <div class="sub">${t.sub}</div></div>`).join('');
+
+  const withPrev = data.filter(d => d.year > 1999);
+  chart.bars('#chart-growth', withPrev.map(d => ({
+    label: String(d.year), value: Math.abs(d.growth_rate || 0),
+    current: d.year === YR, alt: (d.growth_rate || 0) < 0
+  })), { tall: true, ticks: ['2000', String(YR)] , name: 'cve-icu-yearly-change' });
+
+  chart.bars('#chart-abs', withPrev.map(d => ({
+    label: String(d.year), value: Math.abs(d.growth_absolute || 0),
+    current: d.year === YR, alt: (d.growth_absolute || 0) < 0
+  })), { ticks: ['2000', String(YR)] , name: 'cve-icu-yearly-change-absolute' });
+
+  table('#growth-table', data.slice().reverse().map(d => ({
+    year: d.year, cves: d.cves,
+    rate: d.growth_rate == null ? null : d.growth_rate,
+    abs: d.growth_absolute,
+    partial: d.is_ytd ? 'year to date' : ''
+  })), [
+    { key: 'year', label: 'Year', num: true, raw: true },
+    { key: 'cves', label: 'CVEs', num: true, bar: true },
+    { key: 'rate', label: 'Change', num: true,
+      fmt: v => v == null ? '<span class="faint">&mdash;</span>'
+        : `<span style="color:var(--${v > 0 ? 'live' : 'hot'})">${fmt.pct(v)}</span>` },
+    { key: 'abs', label: 'CVEs added', num: true,
+      fmt: v => v == null ? '&mdash;' : (v > 0 ? '+' : '') + fmt.n(v) },
+    { key: 'partial', label: '', fmt: v => v ? `<span class="pill warn">${v}</span>` : '' }
+  ], { sort: { key: 'year', dir: -1 } }, { name: 'cve-icu-growth-by-year' });
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/index.html b/web/index.html
new file mode 100644
index 00000000000..acc9ff25f57
--- /dev/null
+++ b/web/index.html
@@ -0,0 +1,235 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>CVEDB &mdash; how many CVEs</title>
+
+<meta name="description" content="Counts and statistics for every CVE published from 1999 to 2026. Updated hourly.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    class="on" aria-current="page">Home</a></li>
+    <li><a href="years.html"    >Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      >Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  >Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph">
+  <h1>CVEs published in 2026</h1>
+  <span class="note" id="asof"></span>
+</div>
+
+<div class="grid g3 kpi" id="tiles">
+  <div class="c"><div class="lbl">Loading</div><div class="v loading">&mdash;</div></div>
+</div>
+
+<h2>Per year <span class="side">1999&ndash;2026</span></h2>
+<div class="panel">
+  <div class="panel-h">CVEs published each year
+    <span class="side">2026 is a partial year</span></div>
+  <div class="panel-b"><div id="chart-years"></div></div>
+</div>
+
+<h2>Recent days <span class="side">most recent 90 days with data</span></h2>
+<div class="panel">
+  <div class="panel-h">CVEs published per day <span class="side" id="days-side"></span></div>
+  <div class="panel-b"><div id="chart-days"></div></div>
+</div>
+
+<h2>Breakdowns</h2>
+<div class="cols">
+  <div class="panel">
+    <div class="panel-h">Publishers <span class="side">in 2026</span></div>
+    <div class="rows" id="top-cna"></div>
+    <div class="panel-h" style="border-top:1px solid var(--line);border-bottom:0">
+      <a href="cna.html" style="color:var(--accent)">All publishers &rarr;</a></div>
+  </div>
+  <div class="panel">
+    <div class="panel-h">Weakness types <span class="side">all time</span></div>
+    <div class="rows" id="top-cwe"></div>
+    <div class="panel-h" style="border-top:1px solid var(--line);border-bottom:0">
+      <a href="cwe.html" style="color:var(--accent)">All weakness types &rarr;</a></div>
+  </div>
+  <div class="panel">
+    <div class="panel-h">Products <span class="side">CPE references</span></div>
+    <div class="rows" id="top-cpe"></div>
+    <div class="panel-h" style="border-top:1px solid var(--line);border-bottom:0">
+      <a href="cpe.html" style="color:var(--accent)">All products &rarr;</a></div>
+  </div>
+</div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async (S) => {
+  const { fmt, chart, el } = CVE;
+  const YR = 2026;
+
+  const years = Object.values(S.yearly_summary.years)
+    .map(y => ({ year: y.year, count: y.total_cves }))
+    .sort((a, b) => a.year - b.year);
+  const ytd = (years.find(y => y.year === YR) || {}).count || 0;
+
+  const daily = (S.calendar_analysis_current_year.daily_data || [])
+    .slice().sort((a, b) => a.date.localeCompare(b.date));
+  const last = daily[daily.length - 1] || {};
+  const dayNo = Math.max(1, Math.round((Date.now() - new Date(YR, 0, 1)) / 864e5));
+
+  const ytdRow = ((S.growth_analysis || {}).growth_data || []).find(r => r.is_ytd) || {};
+  const pace = ytdRow.projected_full_year;
+
+  // Three numbers, one line of context each: how many, how fast, how that is
+  // changing. Everything else lives in the charts below or on its own page.
+  const TILES = [
+    { lbl: 'Published to date', v: fmt.n(ytd),
+      sub: pace ? `on pace for <b>~${fmt.n(Math.round(pace / 1000) * 1000)}</b> this year`
+                : `day <b>${dayNo}</b> of ${YR}` },
+    { lbl: 'Average per day', v: fmt.n(Math.round(ytd / dayNo)),
+      sub: `across <b>${fmt.n(dayNo)}</b> days of ${YR}` },
+    { lbl: 'Year-over-year growth', v: fmt.pct(ytdRow.ytd_vs_prev_ytd),
+      sub: ytdRow.prev_year_ytd_actual
+        ? `vs <b>${fmt.n(ytdRow.prev_year_ytd_actual)}</b> by this date in ${YR - 1}`
+        : `no ${YR - 1} comparison available` }
+  ];
+
+  el('#tiles').innerHTML = TILES.map(t => `
+    <div class="c">
+      <div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div>
+      <div class="sub">${t.sub}</div>
+    </div>`).join('');
+  el('#asof').textContent = last.date ? `through ${fmt.day(last.date)}` : `${YR} to date`;
+
+  const cnas = (S.cna_analysis.cna_list || []).map(c => ({
+    label: c.name, value: (c.cves_by_year || {})[YR] || 0
+  })).sort((a, b) => b.value - a.value).slice(0, 8);
+  chart.rank('#top-cna', cnas, { compact: true, name: 'cve-icu-top-publishers' });
+
+  chart.rank('#top-cwe', (S.cwe_analysis.top_cwes || []).slice(0, 8)
+    .map(c => ({ label: c.description || c.name, sub: 'CWE-' + c.id, value: c.count })),
+    { compact: true, name: 'cve-icu-top-weaknesses' });
+
+  // top_cpes holds one row per CPE string, so the same product appears several
+  // times (windows_server_2012 r2 vs -, debian_linux 8/9/10/11). Rank the
+  // aggregated product list instead.
+  chart.rank('#top-cpe', (S.cpe_analysis.top_products || []).slice(0, 8)
+    .map(c => ({ label: c.product, value: c.count })), { compact: true, name: 'cve-icu-top-products' });
+
+  chart.bars('#chart-years', years.map(y => ({
+    label: String(y.year), value: y.count, current: y.year === YR
+  })), { tall: true, ticks: [1999, 2005, 2010, 2015, 2020, YR].map(String),
+       name: 'cve-icu-cves-by-year', label: 'CVEs published each year' });
+
+  const recent = daily.slice(-90);
+  chart.bars('#chart-days', recent.map(d => ({
+    label: d.date, value: d.value || 0, current: d === recent[recent.length - 1]
+  })), { ticks: [fmt.day(recent[0] && recent[0].date), fmt.day(last.date)],
+       name: 'cve-icu-recent-days', label: 'CVEs published per day' });
+  el('#days-side').textContent = recent.length
+    ? `${fmt.day(recent[0].date)} – ${fmt.day(last.date)}` : '';
+
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/kev.html b/web/kev.html
new file mode 100644
index 00000000000..3a51a62de4d
--- /dev/null
+++ b/web/kev.html
@@ -0,0 +1,206 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>KEV catalog &mdash; CVEDB</title>
+
+<meta name="description" content="How many CVEs are in the CISA Known Exploited Vulnerabilities catalog.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    >Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      >Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  class="on" aria-current="page">Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph">
+  <h1>KEV catalog</h1>
+  <span class="note">CISA Known Exploited Vulnerabilities &middot; catalog <b id="catver"></b></span>
+</div>
+<p class="lede">CVEs that CISA records as having been exploited. Counted two ways below: the year
+the CVE was published, and the year it was added to the catalog &mdash; those differ a lot.</p>
+
+<div class="grid" id="tiles"></div>
+
+<h2>Added to the catalog</h2>
+<div class="cols c2">
+  <div class="panel"><div class="panel-h">By year added <span class="side">when CISA listed it</span></div>
+    <div class="panel-b"><div id="by-added"></div></div></div>
+  <div class="panel"><div class="panel-h">By year published <span class="side">when the CVE was issued</span></div>
+    <div class="panel-b"><div id="by-pub"></div></div></div>
+</div>
+
+<h2>Additions per month</h2>
+<div class="panel"><div class="panel-b"><div id="timeline"></div></div></div>
+
+<h2>Breakdowns</h2>
+<div class="cols">
+  <div class="panel"><div class="panel-h">Vendors</div><div class="rows" id="vendors"></div></div>
+  <div class="panel"><div class="panel-h">Products</div><div class="rows" id="products"></div></div>
+  <div class="panel"><div class="panel-h">Weakness types</div><div class="rows" id="cwes"></div></div>
+</div>
+
+<h2>Most recent additions</h2>
+<div class="panel"><div id="recent-table"></div></div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async () => {
+  const { fmt, chart, el, table } = CVE;
+  const YR = 2026;
+  const d = await CVE.json('kev_analysis.json');
+  const st = d.statistics || {};
+  const total = d.total_kev_cves || 0;
+  el('#catver').textContent = d.catalog_version || '—';
+
+  el('#tiles').innerHTML = [
+    { lead: 1, lbl: 'CVEs in the catalog', v: fmt.n(total),
+      sub: `catalog version <b>${CVE.esc(d.catalog_version || '—')}</b>` },
+    { lbl: 'Added in 30 days', v: fmt.n(st.added_last_30_days), sub: 'most recent month' },
+    { lbl: 'Added in 90 days', v: fmt.n(st.added_last_90_days), sub: 'most recent quarter' },
+    { lbl: 'Linked to ransomware', v: fmt.n(st.ransomware_associated),
+      sub: `<b>${fmt.share(st.ransomware_associated, total, 0)}</b> of the catalog` }
+  ].map(t => `<div class="c ${t.lead ? 'lead' : ''}"><div class="lbl">${t.lbl}</div>
+      <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+  const added = d.by_year_added || {}, addedY = Object.keys(added).sort();
+  chart.bars('#by-added', addedY.map(y => ({
+    label: y, value: added[y], current: +y === YR
+  })), { ticks: [addedY[0], addedY[addedY.length - 1]] , name: 'cve-icu-kev-by-year-added' });
+
+  const pub = d.by_year_published || {}, pubY = Object.keys(pub).sort();
+  chart.bars('#by-pub', pubY.map(y => ({
+    label: y, value: pub[y], current: +y === YR
+  })), { ticks: [pubY[0], pubY[pubY.length - 1]] , name: 'cve-icu-kev-by-year-published' });
+
+  const tl = d.timeline || {}, months = Object.keys(tl).sort();
+  chart.bars('#timeline', months.map(m => ({ label: m, value: tl[m] })),
+    { tall: true, ticks: [months[0], months[months.length - 1]] , name: 'cve-icu-kev-additions-per-month' });
+
+  // these arrive as [name, count] pairs
+  const pairs = a => (a || []).map(x => Array.isArray(x)
+    ? { label: x[0], value: x[1] } : { label: x.name || x.vendor || x.product, value: x.count });
+  chart.rank('#vendors', pairs(d.top_vendors).slice(0, 10), { name: 'cve-icu-kev-vendors' });
+  chart.rank('#products', pairs(d.top_products).slice(0, 10), { name: 'cve-icu-kev-products' });
+  chart.rank('#cwes', pairs(d.top_cwes).slice(0, 10), { name: 'cve-icu-kev-weaknesses' });
+
+  table('#recent-table', (d.recent_additions || []).map(r => ({
+    cve: r.cve_id, vendor: r.vendor, product: r.product,
+    added: r.date_added, due: r.due_date, ransomware: r.ransomware
+  })), [
+    { key: 'cve', label: 'CVE' },
+    { key: 'vendor', label: 'Vendor' },
+    { key: 'product', label: 'Product' },
+    { key: 'added', label: 'Added' },
+    { key: 'due', label: 'Remediation due' },
+    { key: 'ransomware', label: 'Ransomware',
+      fmt: v => v && v !== 'Unknown' ? `<span class="pill warn">${CVE.esc(v)}</span>`
+        : `<span class="faint">${CVE.esc(v || '—')}</span>` }
+  ], { sort: { key: 'added', dir: -1 } }, { name: 'cve-icu-kev-recent-additions' });
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/scoring.html b/web/scoring.html
new file mode 100644
index 00000000000..d7ac8f01c33
--- /dev/null
+++ b/web/scoring.html
@@ -0,0 +1,207 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>Scoring &mdash; CVEDB</title>
+
+<meta name="description" content="Counts for the three CVE scoring systems: CVSS, EPSS and CISA KEV.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    >Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      >Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  class="on" aria-current="page">Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph"><h1>Scoring</h1><span class="note">three systems, three different questions</span></div>
+<p class="lede">Three separate records attach to CVEs. They are not ranks of each other and we do
+not combine them &mdash; below is how many CVEs each one covers.</p>
+
+<div class="grid g3" id="systems"></div>
+
+<h2>Coverage</h2>
+<div class="panel"><div class="panel-b"><div id="coverage"></div></div></div>
+
+<h2>How many carry each record</h2>
+<div class="cols">
+  <a class="panel" href="cvss.html" style="display:block">
+    <div class="panel-h">CVSS <span class="side">&rarr;</span></div>
+    <div class="panel-b"><div class="v" id="v-cvss" style="font:700 30px var(--num);letter-spacing:-.02em"></div>
+      <div class="muted" style="font-size:12.5px;margin-top:5px">scores recorded, across four metric versions</div></div>
+  </a>
+  <a class="panel" href="epss.html" style="display:block">
+    <div class="panel-h">EPSS <span class="side">&rarr;</span></div>
+    <div class="panel-b"><div class="v" id="v-epss" style="font:700 30px var(--num);letter-spacing:-.02em"></div>
+      <div class="muted" style="font-size:12.5px;margin-top:5px">CVEs with an exploit-probability score</div></div>
+  </a>
+  <a class="panel" href="kev.html" style="display:block">
+    <div class="panel-h">KEV <span class="side">&rarr;</span></div>
+    <div class="panel-b"><div class="v" id="v-kev" style="font:700 30px var(--num);letter-spacing:-.02em"></div>
+      <div class="muted" style="font-size:12.5px;margin-top:5px">CVEs in the CISA catalog</div></div>
+  </a>
+</div>
+
+<h2>Severity bands <span class="side">CVSS v3.1, the most-used version</span></h2>
+<div class="panel"><div class="panel-b"><div id="sev"></div></div></div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async (S) => {
+  const { fmt, chart, el } = CVE;
+  const [cmp, cvss, epss] = await Promise.all([
+    CVE.json('scoring_comparison.json'),
+    CVE.json('cvss_analysis.json'),
+    CVE.json('epss_analysis.json')
+  ]);
+  const total = Object.values(S.yearly_summary.years).reduce((s, y) => s + y.total_cves, 0);
+  const sys = cmp.systems || {};
+
+  el('#systems').innerHTML = ['cvss', 'epss', 'kev'].map(k => {
+    const s = sys[k] || {};
+    return `<div class="c">
+      <div class="lbl">${CVE.esc(s.name || k.toUpperCase())}</div>
+      <div class="v" style="font-size:19px;letter-spacing:-.01em;font-family:var(--sans);font-weight:650">
+        ${CVE.esc(s.question || '')}</div>
+      <div class="sub">${CVE.esc(s.description || '')}<br>
+        <span class="faint">${CVE.esc(s.source || '')} &middot; updated ${CVE.esc(s.update_frequency || '')}</span></div>
+    </div>`;
+  }).join('');
+
+  const kevN = cvss.kev_global_count || 0;
+  el('#v-cvss').textContent = fmt.n(cvss.total_cves_with_cvss);
+  el('#v-epss').textContent =
+    fmt.n(epss.total_cves_with_epss_matched ?? epss.total_cves_with_epss);
+  el('#v-kev').textContent = fmt.n(kevN);
+
+  // EPSS coverage is bucketed by publication date, so it is directly comparable
+  // with the site's own counts. A few EPSS rows describe CVEs this site does not
+  // count at all (rejected, or not yet published here) - shown separately.
+  const epssMatched = epss.total_cves_with_epss_matched ?? epss.total_cves_with_epss ?? 0;
+  const epssUnmatched = epss.epss_without_published_record ?? 0;
+
+  chart.hbars('#coverage', [
+    { label: 'CVEs counted here', value: total },
+    { label: 'With an EPSS score', value: epssMatched },
+    { label: 'CVSS scores', value: cvss.total_cves_with_cvss || 0 },
+    { label: 'In KEV', value: kevN }
+  ], { name: 'cve-icu-scoring-coverage' });
+  el('#coverage').insertAdjacentHTML('beforeend',
+    `<p class="faint" style="font-size:12px;margin-top:11px;line-height:1.6">
+     <b>With an EPSS score</b> is a genuine subset: EPSS rows are matched to CVEs by
+     publication date, the same basis every other count here uses.${epssUnmatched ? `
+     A further <b>${fmt.n(epssUnmatched)}</b> EPSS rows describe CVEs this site does not
+     count &mdash; rejected records, or ones not published here yet &mdash; and are left out
+     rather than attributed to a year.` : ''}<br>
+     <b>CVSS scores</b> is not a subset: it counts scores, not CVEs, because one CVE can
+     hold a score under several metric versions. It is the only bar that can exceed the total.</p>`);
+
+  const v31 = (cvss.severity_distribution || {})['v3.1'] || {};
+  chart.hbars('#sev', ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW', 'NONE']
+    .filter(k => v31[k]).map(k => ({ label: k, value: v31[k] })), { name: 'cve-icu-cvss-severity-bands' });
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file
diff --git a/web/static/css/style.css b/web/static/css/style.css
new file mode 100644
index 00000000000..52ba1086548
--- /dev/null
+++ b/web/static/css/style.css
@@ -0,0 +1,274 @@
+/* ============================================================================
+   CVEDB design system
+
+   A counting site: the numbers are the interface. Tokens below are the only
+   colours used - no literal hex values in templates, no inline styles.
+   ========================================================================== */
+
+:root{
+  /* surfaces, back to front */
+  --bg:#0f1116; --panel:#161920; --panel-2:#1c202a; --panel-3:#232834;
+  --line:#242935; --line-2:#2f3543;
+
+  /* text, loudest to quietest */
+  --fg:#e9ecf2; --dim:#99a1b1; --faint:#666e7e;
+
+  /* meaning */
+  --accent:#5b8cff; --accent-soft:rgba(91,140,255,.13);
+  --bar:#55688c; --bar-active:#6f9bff;
+  --live:#34d399; --warn:#e5c07b; --hot:#e0645f;
+
+  /* type */
+  --sans:Inter,-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,sans-serif;
+  --num:ui-monospace,"SF Mono",Menlo,Consolas,monospace;
+
+  /* rhythm */
+  --r:11px; --r-sm:8px; --gap:10px; --pad:16px;
+  --wrap:1280px;
+}
+:root[data-theme="light"]{
+  --bg:#ffffff; --panel:#f7f8fa; --panel-2:#eef0f4; --panel-3:#e4e7ee;
+  --line:#e3e6ec; --line-2:#d3d8e2;
+  --fg:#12151c; --dim:#5a6273; --faint:#8b93a3;
+  --accent:#2c5fd6; --accent-soft:rgba(44,95,214,.09);
+  --bar:#a9b6cf; --bar-active:#2c5fd6;
+  --live:#14895a; --warn:#9a6b12; --hot:#c0433d;
+}
+
+*{box-sizing:border-box;margin:0;padding:0}
+html{-webkit-text-size-adjust:100%}
+body{background:var(--bg);color:var(--fg);font:15px/1.5 var(--sans);
+  font-variant-numeric:tabular-nums;-webkit-font-smoothing:antialiased;
+  text-rendering:optimizeLegibility}
+a{color:inherit;text-decoration:none}
+.n{font-variant-numeric:tabular-nums;font-family:var(--num)}
+.skip{position:absolute;left:-9999px;top:0;background:var(--accent);color:#fff;
+  padding:9px 15px;border-radius:0 0 var(--r-sm) 0;z-index:100}
+.skip:focus{left:0}
+:focus-visible{outline:2px solid var(--accent);outline-offset:2px;border-radius:3px}
+
+/* ---------------------------------------------------------------- top bar */
+.bar{position:sticky;top:0;z-index:40;display:flex;align-items:center;gap:14px;
+  height:46px;padding:0 20px;border-bottom:1px solid var(--line);
+  background:color-mix(in srgb,var(--bg) 88%,transparent);backdrop-filter:blur(12px)}
+.brand{font-weight:700;letter-spacing:-.02em;font-size:15.5px;flex:none}
+.brand i{color:var(--accent);font-style:normal}
+.live{display:flex;align-items:center;gap:7px;font-size:13px;color:var(--dim);flex:none}
+.live .pip{width:7px;height:7px;border-radius:50%;background:var(--live);
+  box-shadow:0 0 0 3px color-mix(in srgb,var(--live) 22%,transparent);
+  animation:pulse 2.4s ease-in-out infinite}
+@keyframes pulse{0%,100%{opacity:1}50%{opacity:.45}}
+@media(prefers-reduced-motion:reduce){.live .pip{animation:none}}
+.live b{color:var(--fg);font-weight:600}
+.bar .right{margin-left:auto;display:flex;align-items:center;gap:9px;flex:none}
+
+.ico{border:1px solid var(--line);background:var(--panel-2);color:var(--dim);
+  width:30px;height:30px;border-radius:var(--r-sm);cursor:pointer;font-size:13px;
+  display:grid;place-items:center;flex:none}
+.ico:hover{color:var(--fg);border-color:var(--line-2)}
+
+/* -------------------------------------------------------------- main nav */
+.nav{border-bottom:1px solid var(--line);background:var(--bg);position:sticky;top:46px;z-index:35}
+.nav ul{display:flex;gap:2px;max-width:var(--wrap);margin:0 auto;padding:0 14px;
+  list-style:none;overflow-x:auto;scrollbar-width:none}
+.nav ul::-webkit-scrollbar{display:none}
+.nav a{display:block;padding:10px 12px;font-size:13.5px;font-weight:550;color:var(--dim);
+  white-space:nowrap;border-bottom:2px solid transparent;margin-bottom:-1px}
+.nav a:hover{color:var(--fg)}
+.nav a.on{color:var(--fg);border-bottom-color:var(--accent)}
+
+.wrap{max-width:var(--wrap);margin:0 auto;padding:20px 20px 64px}
+
+/* ------------------------------------------------------------- page head */
+.ph{display:flex;align-items:baseline;gap:12px;flex-wrap:wrap;margin-bottom:4px}
+.ph h1{font-size:21px;font-weight:680;letter-spacing:-.02em}
+.ph .note{font-size:13px;color:var(--faint)}
+.lede{color:var(--dim);font-size:13.5px;max-width:78ch;margin-bottom:18px}
+
+h2{font-size:12px;letter-spacing:.09em;text-transform:uppercase;color:var(--faint);
+  font-weight:650;margin:30px 0 11px;display:flex;align-items:center;gap:11px}
+h2::after{content:"";flex:1;height:1px;background:var(--line)}
+h2 .side{font-size:11.5px;letter-spacing:0;text-transform:none;color:var(--faint);font-weight:400}
+
+/* ----------------------------------------------------------------- scope */
+.seg{display:flex;background:var(--panel-2);border:1px solid var(--line);
+  border-radius:var(--r-sm);padding:2px;gap:2px;flex:none}
+.seg button{border:0;background:transparent;color:var(--dim);cursor:pointer;
+  font:600 12.5px var(--sans);padding:5px 13px;border-radius:6px;white-space:nowrap}
+.seg button.on{background:var(--accent);color:#fff}
+.seg button:not(.on):hover{color:var(--fg)}
+
+/* ----------------------------------------------------------------- tiles */
+.grid{display:grid;grid-template-columns:repeat(4,1fr);gap:var(--gap)}
+.grid.g3{grid-template-columns:repeat(3,1fr)}
+.grid.g2{grid-template-columns:repeat(2,1fr)}
+.grid.g4{grid-template-columns:repeat(4,1fr)}
+.ph-actions{display:flex;gap:6px}
+.kvline{display:flex;align-items:baseline;gap:8px;padding:5px 0;border-bottom:1px solid var(--line)}
+.kvline:last-child{border-bottom:0}
+.kvline span:first-child{color:var(--dim);min-width:74px}
+.kvline b{font-family:var(--num);font-weight:650}
+.c{background:var(--panel);border:1px solid var(--line);border-radius:var(--r);
+  padding:15px var(--pad);position:relative;overflow:hidden;min-width:0}
+.c.lead .v{font-size:56px}
+/* Only the home grid spans its lead tile: elsewhere the tile counts are even,
+   and a spanning lead leaves an orphan on the second row. */
+/* The home page leads with three headline numbers, sized to be read first. */
+.grid.kpi .c{padding:20px var(--pad) 26px}
+.grid.kpi .c .v{font-size:60px;margin:10px 0 6px}
+.grid.kpi .c .sub{font-size:13.5px}
+.c.wide .v{font-size:44px}
+.c .lbl{font-size:11.5px;letter-spacing:.055em;text-transform:uppercase;color:var(--faint);
+  font-weight:650;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+.c .v{font-size:36px;font-weight:700;letter-spacing:-.03em;line-height:1.04;
+  margin:8px 0 3px;font-family:var(--num)}
+.c .sub{font-size:12.5px;color:var(--dim)}
+.c .sub b{color:var(--fg);font-weight:600}
+.c .spark{position:absolute;right:0;bottom:0;width:58%;height:40px;color:var(--accent);
+  opacity:.4;pointer-events:none}
+.c .lbl,.c .v,.c .sub{position:relative;z-index:1}
+
+/* ---------------------------------------------------------------- panels */
+.panel{background:var(--panel);border:1px solid var(--line);border-radius:var(--r);
+  overflow:hidden;min-width:0}
+.panel-h{padding:10px 14px;border-bottom:1px solid var(--line);font-size:12.5px;
+  font-weight:620;display:flex;align-items:center;gap:9px;color:var(--dim)}
+.panel-h .side{margin-left:auto;color:var(--faint);font-size:11.5px;font-weight:400}
+.fl{display:flex;align-items:center;gap:6px;font-size:11.5px;color:var(--faint);
+  letter-spacing:.04em;text-transform:uppercase;font-weight:650}
+.fl select,.fl input{background:var(--panel-2);border:1px solid var(--line);color:var(--fg);
+  border-radius:var(--r-sm);padding:4px 8px;font:500 12.5px var(--sans);text-transform:none;
+  letter-spacing:0;min-width:104px}
+.fl select:hover,.fl input:hover{border-color:var(--line-2)}
+.fl input::placeholder{color:var(--faint)}
+.panel-b{padding:14px}
+.cols{display:grid;grid-template-columns:repeat(3,1fr);gap:var(--gap);align-items:start}
+.cols.c2{grid-template-columns:repeat(2,1fr)}
+.cols.wide-first{grid-template-columns:2fr 1fr}
+
+/* ------------------------------------------------------------- rank rows */
+.rows{display:flex;flex-direction:column}
+.r{display:grid;grid-template-columns:20px 1fr auto;gap:10px;align-items:center;
+  padding:6px 14px;font-size:13px;border-bottom:1px solid var(--line)}
+.r:last-child{border-bottom:0}
+.r:hover{background:var(--panel-2)}
+.r .i{color:var(--faint);font-size:11px;text-align:right;font-family:var(--num)}
+.r .t{min-width:0;display:flex;flex-direction:column;gap:3px}
+.r .t em{font-style:normal;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.r .t em small{color:var(--faint);font-size:11px;margin-left:6px}
+.r .g{height:3px;border-radius:2px;background:var(--panel-2);overflow:hidden}
+.r .g i{display:block;height:100%;background:var(--accent);opacity:.7;border-radius:2px}
+.r .g.alt i{background:var(--warn)}
+.r .g.hot i{background:var(--hot)}
+.r .v{font-family:var(--num);font-size:12.5px;font-weight:600}
+.r .v small{display:block;color:var(--faint);font-size:10.5px;font-weight:400;text-align:right}
+
+/* ---------------------------------------------------------------- tables */
+.tw{overflow-x:auto;-webkit-overflow-scrolling:touch}
+table{border-collapse:separate;border-spacing:0;width:100%;font-size:13px}
+thead th{position:sticky;top:0;background:var(--panel-2);text-align:left;padding:8px 12px;
+  font-weight:600;color:var(--dim);border-bottom:1px solid var(--line-2);white-space:nowrap;
+  font-size:11.5px;letter-spacing:.03em}
+thead th.num{text-align:right}
+thead th.sortable{cursor:pointer;user-select:none}
+thead th.sortable:hover{color:var(--fg);background:var(--panel-3)}
+thead th .ar{color:var(--accent);margin-left:5px;font-size:9px}
+tbody td{padding:6px 12px;border-bottom:1px solid var(--line);white-space:nowrap}
+tbody td.num{text-align:right;font-family:var(--num)}
+tbody tr:last-child td{border-bottom:0}
+tbody tr:hover td{background:var(--panel-2)}
+td .g{height:3px;border-radius:2px;background:var(--panel-2);overflow:hidden;min-width:54px}
+td .g i{display:block;height:100%;background:var(--accent);opacity:.7}
+
+/* ------------------------------------------------- charts (inline SVG) */
+.chart-svg{display:block;width:100%;height:auto;overflow:visible}
+.chart-svg.clickable .cbar{cursor:pointer}
+.chart-svg .gl{stroke:var(--line);stroke-width:1;stroke-dasharray:2 4}
+.chart-svg .ax{fill:var(--faint);font:11px var(--sans)}
+.chart-svg .hb-k{fill:var(--dim);font-size:12px}
+.chart-svg .hb-v{fill:var(--fg);font:600 12px var(--num)}
+/* Settled counts are quiet; the year still being added to is the loud one. */
+.chart-svg .cbar{fill:var(--bar);transition:fill .1s,opacity .1s}
+.chart-svg .cbar:hover{fill:var(--bar-active)}
+.chart-svg .cbar.cur,.chart-svg .cbar.sel{fill:var(--bar-active)}
+.chart-svg .cbar.alt{fill:var(--warn);opacity:.85}
+.chart-svg .track{fill:var(--panel-2)}
+.chart-svg .hc{fill:var(--panel-2)}
+.chart-svg .hc[data-l="1"]{fill:color-mix(in srgb,var(--accent) 26%,var(--panel-2))}
+.chart-svg .hc[data-l="2"]{fill:color-mix(in srgb,var(--accent) 46%,var(--panel-2))}
+.chart-svg .hc[data-l="3"]{fill:color-mix(in srgb,var(--accent) 68%,var(--panel-2))}
+.chart-svg .hc[data-l="4"]{fill:var(--accent)}
+.chart-svg .hc:hover{stroke:var(--fg);stroke-width:1.5}
+
+.heat-legend{display:flex;align-items:center;gap:6px;font-size:11px;color:var(--faint);margin-top:11px}
+.heat-legend i{width:12px;height:12px;border-radius:2.5px;display:block;background:var(--panel-2)}
+.heat-legend i[data-l="1"]{background:color-mix(in srgb,var(--accent) 26%,var(--panel-2))}
+.heat-legend i[data-l="2"]{background:color-mix(in srgb,var(--accent) 46%,var(--panel-2))}
+.heat-legend i[data-l="3"]{background:color-mix(in srgb,var(--accent) 68%,var(--panel-2))}
+.heat-legend i[data-l="4"]{background:var(--accent)}
+
+/* hover tooltip shared by every chart */
+.tip{position:fixed;z-index:80;display:none;pointer-events:none;
+  background:var(--panel-3);border:1px solid var(--line-2);color:var(--fg);
+  font:12px var(--num);padding:4px 8px;border-radius:6px;white-space:nowrap;
+  box-shadow:0 4px 14px rgba(0,0,0,.35)}
+
+/* export controls, attached under every chart and table */
+.exp{display:flex;gap:5px;justify-content:flex-end;margin-top:9px;flex-wrap:wrap}
+.exp-btn{border:1px solid var(--line);background:var(--panel-2);color:var(--dim);
+  font:600 10.5px var(--num);letter-spacing:.05em;padding:3px 9px;border-radius:5px;cursor:pointer}
+.exp-btn:hover:not(:disabled){color:var(--fg);border-color:var(--line-2)}
+.exp-btn:disabled{opacity:.6;cursor:default}
+.panel-b>.exp,.rows+.exp{margin-right:0}
+.rows+.exp{padding:0 14px 12px}
+.tw+.exp{padding:0 14px 12px}
+
+/* ------------------------------------------------------------- utilities */
+.muted{color:var(--dim)} .faint{color:var(--faint)}
+.pill{display:inline-block;font:650 10px var(--num);letter-spacing:.06em;text-transform:uppercase;
+  padding:2px 7px;border-radius:20px;background:var(--accent-soft);color:var(--accent);vertical-align:1px}
+.pill.live{background:color-mix(in srgb,var(--live) 16%,transparent);color:var(--live)}
+.pill.warn{background:color-mix(in srgb,var(--warn) 16%,transparent);color:var(--warn)}
+.chips{display:flex;flex-wrap:wrap;gap:5px}
+.chip{border:1px solid var(--line);background:var(--panel-2);color:var(--dim);cursor:pointer;
+  font:550 12px var(--num);padding:4px 9px;border-radius:6px}
+.chip:hover{color:var(--fg);border-color:var(--line-2)}
+.chip.on{background:var(--accent);border-color:var(--accent);color:#fff}
+.note-box{background:var(--panel);border:1px solid var(--line);border-left:3px solid var(--accent);
+  border-radius:var(--r-sm);padding:13px 15px;font-size:13.5px;color:var(--dim);line-height:1.6}
+.note-box b{color:var(--fg);font-weight:600}
+.note-box code{font:12px var(--num);background:var(--panel-2);padding:1px 5px;border-radius:3px}
+.empty{padding:34px 14px;text-align:center;color:var(--faint);font-size:13px}
+.loading{color:var(--faint)}
+
+/* ---------------------------------------------------------------- footer */
+.foot{border-top:1px solid var(--line);margin-top:40px}
+.foot .wrap{padding:22px 20px 40px;font-size:13px;color:var(--faint);line-height:1.8}
+.foot a{color:var(--dim)} .foot a:hover{color:var(--accent)}
+.foot code{font:12px var(--num);background:var(--panel);padding:2px 6px;border-radius:4px}
+.foot .fgrid{display:flex;gap:40px;flex-wrap:wrap;margin-bottom:16px}
+.foot .fgrid b{color:var(--dim);display:block;margin-bottom:5px;font-size:12px;
+  font-weight:650;letter-spacing:.05em;text-transform:uppercase}
+
+/* ------------------------------------------------------------ responsive */
+@media(max-width:1000px){
+  .grid,.grid.g3,.grid.g4{grid-template-columns:repeat(2,1fr)}
+  .grid.kpi{grid-template-columns:repeat(3,1fr)}
+  .grid.kpi .c .v{font-size:40px}
+  .cols,.cols.c2,.cols.wide-first{grid-template-columns:1fr}
+}
+@media(max-width:620px){
+  .grid,.grid.g3,.grid.g2,.grid.g4,.grid.kpi{grid-template-columns:1fr}
+  .grid.kpi .c .v{font-size:44px}
+  .c.lead .v{font-size:44px}
+  .c.wide .v{font-size:38px}
+  .wrap{padding:16px 14px 48px}
+  .bar{padding:0 14px;gap:10px}
+  .brand{font-size:14px} .live{font-size:12px}
+  .hb{grid-template-columns:92px 1fr 56px;gap:8px}
+  .foot .fgrid{gap:22px}
+}
+@media print{
+  .bar,.nav,.seg,.ico{display:none}
+  body{background:#fff;color:#000}
+}
diff --git a/static/images/logo.png b/web/static/images/logo.png
similarity index 100%
rename from static/images/logo.png
rename to web/static/images/logo.png
diff --git a/web/static/js/app.js b/web/static/js/app.js
new file mode 100644
index 00000000000..c7166744537
--- /dev/null
+++ b/web/static/js/app.js
@@ -0,0 +1,537 @@
+/* ============================================================================
+   CVEDB shared runtime.
+
+   One file for every page: fetching, formatting, charts and export. Charts are
+   inline SVG rather than a charting library - counts draw fine with SVG, it
+   keeps the site free of third-party JavaScript, and it means every chart can
+   be exported as a PNG without a rasteriser.
+   ========================================================================== */
+(function () {
+  'use strict';
+
+  /* ------------------------------------------------------------- fetching */
+  const cache = new Map();
+
+  async function json(name, { retries = 2, timeoutMs = 12000 } = {}) {
+    const url = 'data/' + name;
+    if (cache.has(url)) return cache.get(url);
+
+    const attempt = async (n) => {
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+      try {
+        // Always revalidate: the build runs hourly, and a cached payload would
+        // quietly serve yesterday's counts. Unchanged files come back 304.
+        const res = await fetch(url, { signal: ctrl.signal, cache: 'no-cache' });
+        if (!res.ok) throw Object.assign(new Error(`HTTP ${res.status} for ${url}`), { status: res.status });
+        return await res.json();
+      } catch (err) {
+        const retryable = err.name === 'AbortError' ||
+          [408, 425, 429, 500, 502, 503, 504].includes(err.status) ||
+          /failed to fetch|networkerror/i.test(err.message || '');
+        if (n < retries && retryable) {
+          await new Promise(r => setTimeout(r, 300 * 2 ** n));
+          return attempt(n + 1);
+        }
+        throw err;
+      } finally {
+        clearTimeout(timer);
+      }
+    };
+
+    const p = attempt(0).catch(err => { cache.delete(url); throw err; });
+    cache.set(url, p);
+    return p;
+  }
+
+  /* ----------------------------------------------------------- formatting */
+  const fmt = {
+    n: v => (v == null || Number.isNaN(+v) ? '—' : (+v).toLocaleString('en-US')),
+    compact: v => {
+      if (v == null || Number.isNaN(+v)) return '—';
+      v = +v;
+      if (Math.abs(v) >= 1e6) return (v / 1e6).toFixed(1).replace(/\.0$/, '') + 'M';
+      if (Math.abs(v) >= 1e3) return (v / 1e3).toFixed(1).replace(/\.0$/, '') + 'k';
+      return String(v);
+    },
+    pct: (v, d = 1) => (v == null ? '—' : (v > 0 ? '+' : '') + (+v).toFixed(d) + '%'),
+    share: (a, b, d = 1) => (!b ? '—' : (a / b * 100).toFixed(d) + '%'),
+    ago: iso => {
+      if (!iso) return '—';
+      const h = (Date.now() - new Date(iso).getTime()) / 36e5;
+      if (h < 0) return 'just now';
+      if (h < 1) return Math.max(1, Math.round(h * 60)) + ' min ago';
+      if (h < 48) return Math.round(h) + ' h ago';
+      return Math.round(h / 24) + ' d ago';
+    },
+    date: iso => iso ? new Date(iso).toLocaleDateString('en-US',
+      { year: 'numeric', month: 'short', day: 'numeric' }) : '—',
+    day: iso => iso ? new Date(iso + 'T00:00:00').toLocaleDateString('en-US',
+      { month: 'short', day: 'numeric' }) : '—'
+  };
+
+  const el = s => (typeof s === 'string' ? document.querySelector(s) : s);
+  const all = s => [...document.querySelectorAll(s)];
+  const esc = s => String(s ?? '').replace(/[&<>"]/g, c =>
+    ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]));
+
+  /* --------------------------------------------------------------- export */
+  function download(blob, filename) {
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url; a.download = filename;
+    document.body.appendChild(a); a.click(); a.remove();
+    setTimeout(() => URL.revokeObjectURL(url), 1000);
+  }
+
+  const slug = s => String(s || 'cve-icu').toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 60);
+
+  function toCSV(rows) {
+    if (!rows || !rows.length) return '';
+    const cols = Object.keys(rows[0]);
+    const cell = v => {
+      const s = v == null ? '' : String(v);
+      return /[",\n]/.test(s) ? '"' + s.replace(/"/g, '""') + '"' : s;
+    };
+    return [cols.join(','), ...rows.map(r => cols.map(c => cell(r[c])).join(','))].join('\n');
+  }
+
+  const exportData = {
+    csv(rows, name) { download(new Blob([toCSV(rows)], { type: 'text/csv;charset=utf-8' }), slug(name) + '.csv'); },
+    json(rows, name) { download(new Blob([JSON.stringify(rows, null, 2)], { type: 'application/json' }), slug(name) + '.json'); },
+
+    /** Rasterise an inline SVG chart to PNG.
+     *  CSS custom properties do not survive serialisation, so every paint and
+     *  font is resolved to a literal value on a clone before encoding. */
+    async png(svg, name, scale = 2) {
+      const clone = svg.cloneNode(true);
+      const srcNodes = svg.querySelectorAll('*');
+      const dstNodes = clone.querySelectorAll('*');
+      const PROPS = ['fill', 'stroke', 'stroke-width', 'stroke-dasharray', 'opacity',
+                     'font-family', 'font-size', 'font-weight', 'text-anchor'];
+      srcNodes.forEach((src, i) => {
+        const cs = getComputedStyle(src);
+        const dst = dstNodes[i];
+        PROPS.forEach(p => {
+          const v = cs.getPropertyValue(p);
+          if (v && v !== 'none' || (p === 'fill' && v === 'none')) dst.setAttribute(p, v.trim());
+        });
+        dst.removeAttribute('class');
+      });
+
+      // Size from the viewBox, not the rendered box, so an export is the same
+      // resolution whether it was taken on a phone or a wide monitor.
+      const vb = (svg.getAttribute('viewBox') || '').split(/[\s,]+/).map(Number);
+      const box = svg.getBoundingClientRect();
+      const w = Math.round(vb[2] || box.width || 900);
+      const h = Math.round(vb[3] || box.height || 320);
+      clone.setAttribute('width', w);
+      clone.setAttribute('height', h);
+      clone.setAttribute('xmlns', 'http://www.w3.org/2000/svg');
+
+      // opaque background so the PNG is readable outside the page's theme
+      const bg = getComputedStyle(document.body).backgroundColor || '#fff';
+      const rect = document.createElementNS('http://www.w3.org/2000/svg', 'rect');
+      rect.setAttribute('x', vb[0] ?? 0); rect.setAttribute('y', vb[1] ?? 0);
+      rect.setAttribute('width', vb[2] || w); rect.setAttribute('height', vb[3] || h);
+      rect.setAttribute('fill', bg);
+      clone.insertBefore(rect, clone.firstChild);
+
+      const src = new XMLSerializer().serializeToString(clone);
+      const url = 'data:image/svg+xml;charset=utf-8,' + encodeURIComponent(src);
+
+      await new Promise((resolve, reject) => {
+        const img = new Image();
+        img.onload = () => {
+          const c = document.createElement('canvas');
+          c.width = w * scale; c.height = h * scale;
+          const ctx = c.getContext('2d');
+          ctx.drawImage(img, 0, 0, c.width, c.height);
+          c.toBlob(b => { download(b, slug(name) + '.png'); resolve(); }, 'image/png');
+        };
+        img.onerror = reject;
+        img.src = url;
+      });
+    }
+  };
+
+  /** Attach PNG / CSV / JSON buttons under a chart or table. */
+  function attachExports(host, { svg, rows, name }) {
+    if (!host) return;
+    const bar = document.createElement('div');
+    bar.className = 'exp';
+    const mk = (label, fn) => {
+      const b = document.createElement('button');
+      b.type = 'button'; b.className = 'exp-btn'; b.textContent = label;
+      b.addEventListener('click', async () => {
+        const was = b.textContent;
+        b.disabled = true; b.textContent = '…';
+        try { await fn(); b.textContent = '✓'; }
+        catch (e) { console.error(e); b.textContent = 'failed'; }
+        setTimeout(() => { b.textContent = was; b.disabled = false; }, 900);
+      });
+      return b;
+    };
+    if (svg) bar.appendChild(mk('PNG', () => exportData.png(svg, name)));
+    if (rows && rows.length) {
+      bar.appendChild(mk('CSV', () => exportData.csv(rows, name)));
+      bar.appendChild(mk('JSON', () => exportData.json(rows, name)));
+    }
+    if (bar.children.length) host.appendChild(bar);
+  }
+
+  /* -------------------------------------------------------------- tooltip */
+  let tip;
+  function showTip(text, x, y) {
+    if (!tip) {
+      tip = document.createElement('div');
+      tip.className = 'tip';
+      document.body.appendChild(tip);
+    }
+    tip.textContent = text;
+    tip.style.display = 'block';
+    const r = tip.getBoundingClientRect();
+    tip.style.left = Math.min(window.innerWidth - r.width - 8, Math.max(8, x - r.width / 2)) + 'px';
+    tip.style.top = (y - r.height - 10) + 'px';
+  }
+  const hideTip = () => { if (tip) tip.style.display = 'none'; };
+
+  function wireTips(svg) {
+    svg.addEventListener('mousemove', e => {
+      const t = e.target.closest('[data-tip]');
+      if (t) showTip(t.dataset.tip, e.clientX, e.clientY);
+      else hideTip();
+    });
+    svg.addEventListener('mouseleave', hideTip);
+  }
+
+  /* --------------------------------------------------------------- charts */
+  const NS = 'http://www.w3.org/2000/svg';
+
+  function svgEl(host, w, h, label) {
+    const s = document.createElementNS(NS, 'svg');
+    s.setAttribute('viewBox', `0 0 ${w} ${h}`);
+    s.setAttribute('role', 'img');
+    s.setAttribute('preserveAspectRatio', 'xMidYMid meet');
+    if (label) s.setAttribute('aria-label', label);
+    s.classList.add('chart-svg');
+    host.appendChild(s);
+    return s;
+  }
+
+  function niceTicks(max, count = 4) {
+    if (max <= 0) return [0];
+    const raw = max / count;
+    const mag = 10 ** Math.floor(Math.log10(raw));
+    const step = [1, 2, 2.5, 5, 10].map(m => m * mag).find(s => s >= raw) || mag * 10;
+    const out = [];
+    // Run past max, not up to it: the top tick is the scale's ceiling, so if it
+    // stops below max the tallest bar is drawn above the plot area.
+    for (let v = 0; v < max; v += step) out.push(v);
+    out.push(out[out.length - 1] + step);
+    return out;
+  }
+
+  const chart = {
+    spark(values, w = 120, h = 40) {
+      const v = values.filter(x => Number.isFinite(x));
+      if (v.length < 2) return '';
+      const max = Math.max(...v), min = Math.min(...v), span = max - min || 1;
+      const pts = v.map((x, i) => [(i / (v.length - 1)) * w, h - ((x - min) / span) * (h - 2) - 1]);
+      const line = pts.map(p => p[0].toFixed(1) + ',' + p[1].toFixed(1)).join(' ');
+      return `<svg class="spark" viewBox="0 0 ${w} ${h}" preserveAspectRatio="none" aria-hidden="true">
+        <polygon points="0,${h} ${line} ${w},${h}" fill="currentColor" opacity=".16"/>
+        <polyline points="${line}" fill="none" stroke="currentColor" stroke-width="1.6"
+          stroke-linejoin="round" stroke-linecap="round" vector-effect="non-scaling-stroke"/>
+      </svg>`;
+    },
+
+    /** Vertical bars. items: [{label, value, current?, alt?}] */
+    bars(node, items, opt = {}) {
+      const host = el(node);
+      if (!host) return;
+      host.innerHTML = '';
+      if (!items.length) { host.innerHTML = '<div class="empty">No data</div>'; return; }
+
+      const W = 1000, H = opt.tall ? 300 : 210;
+      const mL = 46, mR = 10, mT = 12, mB = 26;
+      const iw = W - mL - mR, ih = H - mT - mB;
+      const max = Math.max(...items.map(i => i.value)) || 1;
+      const ticks = niceTicks(max);
+      const top = ticks[ticks.length - 1] || max;
+      const bw = Math.max(1, (iw / items.length) * 0.78);
+      const y = v => mT + ih - (v / top) * ih;
+
+      const svg = svgEl(host, W, H, opt.label || 'Bar chart');
+      const parts = [];
+      ticks.forEach(t => {
+        parts.push(`<line class="gl" x1="${mL}" y1="${y(t).toFixed(1)}" x2="${mL + iw}" y2="${y(t).toFixed(1)}"/>`);
+        parts.push(`<text class="ax" x="${mL - 8}" y="${(y(t) + 4).toFixed(1)}" text-anchor="end">${fmt.compact(t)}</text>`);
+      });
+      items.forEach((d, i) => {
+        const cx = mL + (i + 0.5) * (iw / items.length);
+        const hgt = Math.max(1, (d.value / top) * ih);
+        const cls = 'cbar' + (d.current ? ' cur' : '') + (d.alt ? ' alt' : '');
+        parts.push(`<rect class="${cls}" x="${(cx - bw / 2).toFixed(1)}" y="${(mT + ih - hgt).toFixed(1)}"
+          width="${bw.toFixed(1)}" height="${hgt.toFixed(1)}" rx="1.5"
+          data-tip="${esc(d.label)}: ${fmt.n(d.value)}" data-key="${esc(d.label)}"/>`);
+      });
+      (opt.ticks || [items[0].label, items[items.length - 1].label]).forEach((t, i, arr) => {
+        const x = mL + (arr.length === 1 ? iw / 2 : (i / (arr.length - 1)) * iw);
+        parts.push(`<text class="ax" x="${x.toFixed(1)}" y="${H - 8}" text-anchor="${
+          i === 0 ? 'start' : i === arr.length - 1 ? 'end' : 'middle'}">${esc(t)}</text>`);
+      });
+      svg.innerHTML = parts.join('');
+      wireTips(svg);
+      if (opt.onSelect) {
+        svg.classList.add('clickable');
+        svg.addEventListener('click', e => {
+          const r = e.target.closest('[data-key]');
+          if (r) opt.onSelect(r.dataset.key);
+        });
+      }
+      if (opt.export !== false) {
+        attachExports(host, {
+          svg, name: opt.name || opt.label || 'chart',
+          rows: items.map(i => ({ label: i.label, value: i.value }))
+        });
+      }
+      return svg;
+    },
+
+    /** Horizontal bars. items: [{label, value}] */
+    hbars(node, items, opt = {}) {
+      const host = el(node);
+      if (!host) return;
+      host.innerHTML = '';
+      if (!items.length) { host.innerHTML = '<div class="empty">No data</div>'; return; }
+
+      const rowH = 22, W = 1000, mL = 190, mR = 92, mT = 6;
+      const H = mT * 2 + items.length * rowH;
+      const iw = W - mL - mR;
+      const max = Math.max(...items.map(i => i.value)) || 1;
+
+      const svg = svgEl(host, W, H, opt.label || 'Horizontal bar chart');
+      const parts = [];
+      items.forEach((d, i) => {
+        const y = mT + i * rowH;
+        const w = Math.max(1, (d.value / max) * iw);
+        parts.push(`<text class="ax hb-k" x="${mL - 10}" y="${y + rowH / 2 + 4}" text-anchor="end">${esc(d.label)}</text>`);
+        parts.push(`<rect class="track" x="${mL}" y="${y + 4}" width="${iw}" height="${rowH - 9}" rx="2.5"/>`);
+        parts.push(`<rect class="cbar" x="${mL}" y="${y + 4}" width="${w.toFixed(1)}" height="${rowH - 9}" rx="2.5"
+          data-tip="${esc(d.label)}: ${fmt.n(d.value)}"/>`);
+        parts.push(`<text class="ax hb-v" x="${mL + iw + 10}" y="${y + rowH / 2 + 4}">${
+          opt.compact ? fmt.compact(d.value) : fmt.n(d.value)}</text>`);
+      });
+      svg.innerHTML = parts.join('');
+      wireTips(svg);
+      if (opt.export !== false) {
+        attachExports(host, {
+          svg, name: opt.name || opt.label || 'chart',
+          rows: items.map(i => ({ label: i.label, value: i.value }))
+        });
+      }
+      return svg;
+    },
+
+    /** Calendar heatmap. days: [{date:'YYYY-MM-DD', value}] */
+    heat(node, days, opt = {}) {
+      const host = el(node);
+      if (!host) return;
+      host.innerHTML = '';
+      if (!days.length) { host.innerHTML = '<div class="empty">No data</div>'; return; }
+
+      const vals = days.map(d => d.value).filter(v => v > 0).sort((a, b) => a - b);
+      const q = p => vals[Math.floor(vals.length * p)] || 0;
+      const cuts = [q(.25), q(.5), q(.75), q(.92)];
+      const level = v => !v ? 0 : v <= cuts[0] ? 1 : v <= cuts[1] ? 2 : v <= cuts[2] ? 3 : 4;
+
+      const cell = 13, gap = 3, pad = 26;
+      const first = new Date(days[0].date + 'T00:00:00');
+      const offset = first.getDay();
+      const weeks = Math.ceil((days.length + offset) / 7);
+      const W = pad + weeks * (cell + gap), H = pad + 7 * (cell + gap) + 4;
+
+      const svg = svgEl(host, W, H, 'Calendar heatmap of daily CVE counts');
+      const parts = [];
+      ['', 'Mon', '', 'Wed', '', 'Fri', ''].forEach((lbl, i) => {
+        if (lbl) parts.push(`<text class="ax" x="${pad - 6}" y="${pad + i * (cell + gap) + cell - 2}" text-anchor="end">${lbl}</text>`);
+      });
+      let lastMonth = '';
+      days.forEach((d, i) => {
+        const idx = i + offset;
+        const col = Math.floor(idx / 7), row = idx % 7;
+        const x = pad + col * (cell + gap), y = pad + row * (cell + gap);
+        parts.push(`<rect class="hc" data-l="${level(d.value)}" x="${x}" y="${y}"
+          width="${cell}" height="${cell}" rx="2.5"
+          data-tip="${d.date}: ${fmt.n(d.value)} CVEs"/>`);
+        const m = d.date.slice(0, 7);
+        if (m !== lastMonth && row <= 1) {
+          lastMonth = m;
+          const name = new Date(d.date + 'T00:00:00').toLocaleDateString('en-US', { month: 'short' });
+          parts.push(`<text class="ax" x="${x}" y="${pad - 8}">${name}</text>`);
+        }
+      });
+      svg.innerHTML = parts.join('');
+      wireTips(svg);
+
+      const legend = document.createElement('div');
+      legend.className = 'heat-legend';
+      legend.innerHTML = `<span>Fewer</span>${[0, 1, 2, 3, 4]
+        .map(l => `<i data-l="${l}"></i>`).join('')}<span>More</span>
+        <span style="margin-left:auto">${fmt.n(days.reduce((s, d) => s + d.value, 0))} CVEs across ${days.length} days</span>`;
+      host.appendChild(legend);
+
+      if (opt.export !== false) {
+        attachExports(host, {
+          svg, name: opt.name || 'cve-icu-daily-counts',
+          rows: days.map(d => ({ date: d.date, cves: d.value }))
+        });
+      }
+      return svg;
+    },
+
+    /** Ranked list with inline magnitude bars (a list, not a chart - CSV only). */
+    rank(node, items, opt = {}) {
+      const host = el(node);
+      if (!host) return;
+      if (!items.length) { host.innerHTML = '<div class="empty">No data</div>'; return; }
+      const max = Math.max(...items.map(i => i.value)) || 1;
+      host.innerHTML = items.map((i, n) => `
+        <div class="r">
+          <span class="i">${n + 1}</span>
+          <span class="t">
+            <em>${esc(i.label)}${i.sub ? `<small>${esc(i.sub)}</small>` : ''}</em>
+            <span class="g ${opt.tone || ''}"><i style="width:${(i.value / max * 100).toFixed(1)}%"></i></span>
+          </span>
+          <span class="v">${opt.compact ? fmt.compact(i.value) : fmt.n(i.value)}${
+            i.note ? `<small>${esc(i.note)}</small>` : ''}</span>
+        </div>`).join('');
+      if (opt.export !== false && opt.name) {
+        attachExports(host, { rows: items.map(i => ({ label: i.label, value: i.value })), name: opt.name });
+      }
+    }
+  };
+
+  /* ---------------------------------------------------------------- table */
+  function table(node, rows, cols, opt = {}) {
+    const host = el(node);
+    if (!host) return;
+    let sort = opt.sort || { key: cols.find(c => c.num)?.key, dir: -1 };
+
+    const maxes = {};
+    cols.filter(c => c.bar).forEach(c => {
+      maxes[c.key] = Math.max(...rows.map(r => +r[c.key] || 0)) || 1;
+    });
+
+    function draw() {
+      const data = [...rows].sort((a, b) => {
+        const x = a[sort.key], y = b[sort.key];
+        if (typeof x === 'number' && typeof y === 'number') return (x - y) * sort.dir;
+        return String(x).localeCompare(String(y)) * sort.dir;
+      });
+      host.innerHTML = `<div class="tw"><table>
+        <thead><tr>${cols.map(c => `<th class="${c.num ? 'num' : ''} sortable" data-k="${c.key}">
+          ${esc(c.label)}${sort.key === c.key ? `<span class="ar">${sort.dir < 0 ? '▼' : '▲'}</span>` : ''}
+        </th>`).join('')}</tr></thead>
+        <tbody>${data.map(r => `<tr>${cols.map(c => {
+          let v = r[c.key];
+          let disp = c.fmt ? c.fmt(v, r)
+            : typeof v === 'number' ? (c.raw ? String(v) : fmt.n(v))
+            : esc(v ?? '—');
+          if (c.bar) disp += `<span class="g" style="display:inline-block;width:54px;margin-left:9px;vertical-align:middle"><i style="width:${((+v || 0) / maxes[c.key] * 100).toFixed(1)}%"></i></span>`;
+          return `<td class="${c.num ? 'num' : ''}">${disp}</td>`;
+        }).join('')}</tr>`).join('')}</tbody></table></div>`;
+
+      host.querySelectorAll('th[data-k]').forEach(th => {
+        th.onclick = () => {
+          const k = th.dataset.k;
+          sort = sort.key === k ? { key: k, dir: -sort.dir } : { key: k, dir: -1 };
+          draw();
+        };
+      });
+      if (opt.export !== false && opt.name) {
+        attachExports(host, {
+          rows: data.map(r => Object.fromEntries(cols.map(c => [c.label, r[c.key]]))),
+          name: opt.name
+        });
+      }
+    }
+    draw();
+  }
+
+  /* ------------------------------------------------------------- URL state */
+  const url = {
+    get(key, fallback = null) {
+      const v = new URLSearchParams(location.search).get(key);
+      return v === null ? fallback : v;
+    },
+    set(obj, { replace = true } = {}) {
+      const p = new URLSearchParams(location.search);
+      Object.entries(obj).forEach(([k, v]) => {
+        if (v == null || v === '') p.delete(k); else p.set(k, v);
+      });
+      const q = p.toString();
+      const next = location.pathname + (q ? '?' + q : '');
+      history[replace ? 'replaceState' : 'pushState'](null, '', next);
+    },
+    /** Copy the current URL, reporting on the button that asked. */
+    async share(btn) {
+      try {
+        await navigator.clipboard.writeText(location.href);
+        if (btn) { const was = btn.textContent; btn.textContent = 'Copied'; setTimeout(() => btn.textContent = was, 1200); }
+      } catch (_) {
+        if (btn) btn.textContent = location.href;
+      }
+    }
+  };
+
+  /* ---------------------------------------------------------------- chrome */
+  function theme() {
+    const root = document.documentElement;
+    const btn = el('#theme');
+    if (!btn) return;
+    btn.onclick = () => {
+      const light = root.dataset.theme !== 'light';
+      root.dataset.theme = light ? 'light' : 'dark';
+      try { localStorage.setItem('cveicu-theme', light ? 'light' : 'dark'); } catch (_) {}
+    };
+  }
+
+  /* Two different ages, and conflating them overstated our freshness.
+     source_last_run is when the producer last gathered the data; data_as_of is
+     only when we downloaded it. The producer runs on its own schedule, so a
+     download minutes old routinely carries a snapshot hours old. Anything
+     labelled as data freshness reads source_last_run, and data_as_of is shown
+     only where we mean our own build. Fall back when there is no manifest. */
+  function freshness(meta) {
+    const dataAge = meta.source_last_run || meta.data_as_of;
+    all('[data-fresh]').forEach(e => { e.textContent = fmt.ago(dataAge); });
+    all('[data-asof]').forEach(e => { e.textContent = fmt.date(dataAge); });
+    all('[data-srcrun]').forEach(e => { e.textContent = fmt.ago(meta.source_last_run); });
+    all('[data-built]').forEach(e => { e.textContent = fmt.ago(meta.data_as_of); });
+  }
+
+  function fail(node, err) {
+    const host = el(node);
+    if (host) host.innerHTML =
+      `<div class="empty">Could not load this data.<br>
+       <span class="faint" style="font-size:12px">${esc(err.message || err)}</span></div>`;
+    console.error(err);
+  }
+
+  async function page(fn) {
+    theme();
+    try {
+      const summary = await json('homepage_summary.json');
+      freshness(summary);
+      await fn(summary);
+    } catch (err) {
+      fail('#main', err);
+    }
+  }
+
+  window.CVE = { json, fmt, chart, table, el, all, esc, theme, freshness, fail, page,
+                 exportData, attachExports, download, toCSV, url };
+})();
diff --git a/web/years.html b/web/years.html
new file mode 100644
index 00000000000..7bdddebaafd
--- /dev/null
+++ b/web/years.html
@@ -0,0 +1,384 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>CVEs by year &mdash; CVEDB</title>
+
+<meta name="description" content="How many CVEs were published each year from 1999 to 2026. Compare any set of years.">
+<meta name="robots" content="index, follow">
+<meta name="theme-color" content="#0f1116">
+<meta name="apple-mobile-web-app-title" content="CVEDB">
+<meta name="format-detection" content="telephone=no">
+
+<meta property="og:title" content="CVEDB">
+<meta property="og:description" content="Counts and statistics for every CVE published from 1999 to 2026.">
+<meta property="og:type" content="website">
+<meta property="og:url" content="https://cvedb.github.io">
+<meta property="og:image" content="https://cvedb.github.io/static/images/logo.png">
+
+<link rel="icon" type="image/png" href="static/images/logo.png">
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+<link rel="stylesheet" href="static/css/style.css?v=6ef77805">
+
+<!-- Page-specific head content (styles, preloads) -->
+
+
+<script>
+  // Applied before first paint so the theme never flashes.
+  (function(){
+    try {
+      var t = localStorage.getItem('cveicu-theme');
+      if (t === 'light' || (!t && window.matchMedia('(prefers-color-scheme: light)').matches)) {
+        document.documentElement.dataset.theme = 'light';
+      }
+    } catch (e) {}
+  })();
+</script>
+
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-W0CE61HN2F"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-W0CE61HN2F');
+</script>
+</head>
+<body>
+<a href="#main" class="skip">Skip to content</a>
+
+<header class="bar">
+  <a href="index.html" class="brand">CVE<i>.</i>ICU</a>
+  <span class="live"><span class="pip"></span> updated <b data-fresh>&mdash;</b></span>
+  <span class="right">
+    <button class="ico" id="theme" title="Switch light / dark" aria-label="Switch light or dark theme">◐</button>
+  </span>
+</header>
+
+<nav class="nav" aria-label="Sections">
+  <ul>
+    <li><a href="index.html"    >Home</a></li>
+    <li><a href="years.html"    class="on" aria-current="page">Years</a></li>
+    <li><a href="calendar.html" >Calendar</a></li>
+    <li><a href="cna.html"      >Publishers</a></li>
+    <li><a href="cpe.html"      >Products</a></li>
+    <li><a href="cwe.html"      >Weaknesses</a></li>
+    <li><a href="scoring.html"  >Scoring</a></li>
+    <li><a href="about.html"    >About</a></li>
+  </ul>
+</nav>
+
+<main id="main" class="wrap">
+
+<div class="ph">
+  <h1>CVEs by year</h1>
+  <span class="note">1999&ndash;2026</span>
+  <span style="margin-left:auto" class="ph-actions">
+    <button class="exp-btn" id="share">Share link</button>
+    <button class="exp-btn" id="print">Print</button>
+  </span>
+</div>
+<p class="lede">Select any set of years to compare. 2026 is still in progress,
+so its bar keeps growing.</p>
+
+<div class="grid g4" id="tiles"></div>
+
+<h2>Select years <span class="side" id="sel-note"></span></h2>
+<div class="panel">
+  <div class="panel-b">
+    <div class="chips" id="quick" style="margin-bottom:10px">
+      <button class="chip" data-q="recent5">Recent 5 years</button>
+      <button class="chip" data-q="2020s">2020s</button>
+      <button class="chip" data-q="2010s">2010s</button>
+      <button class="chip" data-q="2000s">2000s</button>
+      <button class="chip" data-q="all">All years</button>
+      <button class="chip" data-q="clear">Clear</button>
+    </div>
+    <div class="chips" id="chips"></div>
+  </div>
+</div>
+
+<h2>CVEs published each year <span class="side">selected years highlighted</span></h2>
+<div class="panel"><div class="panel-b"><div id="chart-years"></div></div></div>
+
+<div id="compare"></div>
+<div id="year-detail"></div>
+
+<h2>All years</h2>
+<div class="panel"><div id="year-table"></div></div>
+
+</main>
+
+<footer class="foot">
+  <div class="wrap">
+    <div class="fgrid">
+      <div>
+        <b>Counts</b>
+        <a href="years.html">By year</a> &middot;
+        <a href="calendar.html">By day</a> &middot;
+        <a href="growth.html">Year over year</a>
+      </div>
+      <div>
+        <b>Breakdowns</b>
+        <a href="cna.html">Publishers</a> &middot;
+        <a href="cpe.html">Products</a> &middot;
+        <a href="cwe.html">Weaknesses</a>
+      </div>
+      <div>
+        <b>Scoring</b>
+        <a href="cvss.html">CVSS</a> &middot;
+        <a href="epss.html">EPSS</a> &middot;
+        <a href="kev.html">KEV</a>
+      </div>
+      <div>
+        <b>Data</b>
+        <a href="https://nvd.nist.gov/" rel="noopener">NVD</a> &middot;
+        <a href="https://cve.org/" rel="noopener">CVE Program</a> &middot;
+        <a href="data-quality.html">Name matching</a>
+      </div>
+    </div>
+    <div>
+      Counts only. Every number is a direct count from the published record &mdash;
+      nothing here is weighted, scored or ranked by us.<br>
+      Data as of <b data-asof>&mdash;</b>, rebuilt <b data-built>&mdash;</b> &middot;
+      raw JSON at <code>cvedb.github.io/data/</code> &middot;
+      <a href="https://github.com/cvedb/cvedb.github.io" rel="noopener">source</a> &middot;
+      built by <a href="https://cvedb.github.io" rel="noopener">CVEDB</a>
+      &middot; &copy; 2026
+    </div>
+  </div>
+</footer>
+
+<script src="static/js/app.js?v=6ef77805"></script>
+
+<script>
+CVE.page(async (S) => {
+  const { fmt, chart, el, table, url } = CVE;
+  const YR = 2026;
+  const full = await CVE.json('yearly_summary.json');
+  const years = Object.values(full.years).sort((a, b) => a.year - b.year);
+  const allYears = years.map(y => y.year);
+  const grandTotal = years.reduce((s, y) => s + y.total_cves, 0);
+
+  const fromUrl = (url.get('years') || '').split(',').map(Number).filter(n => allYears.includes(n));
+  let selected = new Set(fromUrl.length ? fromUrl : [YR]);
+
+  const daysInYear = y => y === YR
+    ? Math.max(1, Math.round((Date.now() - new Date(YR, 0, 1)) / 864e5))
+    : ((y % 4 === 0 && y % 100 !== 0) || y % 400 === 0) ? 366 : 365;
+
+  /* ---------------- selection-aware metrics ---------------- */
+  function tiles() {
+    const sel = [...selected].sort((a, b) => a - b);
+    const picked = years.filter(y => selected.has(y.year));
+    const sum = picked.reduce((s, y) => s + y.total_cves, 0);
+    const days = sel.reduce((s, y) => s + daysInYear(y), 0);
+    const kev = picked.reduce((s, y) => s + ((y.kev || {}).kev_count || 0), 0);
+
+    el('#tiles').innerHTML = [
+      { lbl: 'Years selected', v: fmt.n(sel.length),
+        sub: sel.length ? (sel.length > 6
+          ? `${sel[0]}&ndash;${sel[sel.length - 1]}`
+          : sel.join(', ')) : 'none selected' },
+      { lbl: 'CVEs in selection', v: fmt.n(sum),
+        sub: `<b>${fmt.share(sum, grandTotal)}</b> of all ${fmt.compact(grandTotal)}` },
+      { lbl: 'Average per day', v: fmt.n(days ? Math.round(sum / days) : 0),
+        sub: `across <b>${fmt.n(days)}</b> days` },
+      { lbl: 'In the KEV catalog', v: fmt.n(kev),
+        sub: `<b>${fmt.share(kev, sum, 2)}</b> of the selection` }
+    ].map(t => `<div class="c"><div class="lbl">${t.lbl}</div>
+        <div class="v">${t.v}</div><div class="sub">${t.sub}</div></div>`).join('');
+
+    el('#sel-note').textContent = sel.length === 1
+      ? `${sel[0]} selected` : `${sel.length} years selected`;
+  }
+
+  /* ---------------- chips ---------------- */
+  function chips() {
+    el('#chips').innerHTML = allYears.map(y =>
+      `<button class="chip ${selected.has(y) ? 'on' : ''}" data-y="${y}"
+        aria-pressed="${selected.has(y)}">${y}</button>`).join('');
+  }
+
+  /* ---------------- main chart ---------------- */
+  function mainChart() {
+    chart.bars('#chart-years', years.map(y => ({
+      label: String(y.year), value: y.total_cves, current: selected.has(y.year)
+    })), {
+      tall: true, name: 'cve-icu-cves-by-year', label: 'CVEs published each year',
+      ticks: [1999, 2005, 2010, 2015, 2020, YR].map(String),
+      onSelect: key => { toggle(+key); }
+    });
+  }
+
+  /* ---------------- comparison across the selection ---------------- */
+  function compare() {
+    const sel = [...selected].sort((a, b) => a - b);
+    const host = el('#compare');
+    if (sel.length < 2) { host.innerHTML = ''; return; }
+    const picked = years.filter(y => selected.has(y.year));
+    host.innerHTML = `
+      <h2>Comparing ${sel.length} years</h2>
+      <div class="cols c2">
+        <div class="panel"><div class="panel-h">CVEs per selected year</div>
+          <div class="panel-b"><div id="cmp-total"></div></div></div>
+        <div class="panel"><div class="panel-h">Average per day <span class="side">normalises for ${YR} being partial</span></div>
+          <div class="panel-b"><div id="cmp-rate"></div></div></div>
+      </div>
+      <div class="panel" style="margin-top:10px">
+        <div class="panel-h">By month, selected years overlaid</div>
+        <div class="panel-b"><div id="cmp-month"></div></div></div>`;
+
+    chart.hbars('#cmp-total', picked.map(y => ({ label: String(y.year), value: y.total_cves })),
+      { name: 'cve-icu-selected-years-total', label: 'CVEs per selected year' });
+    chart.hbars('#cmp-rate', picked.map(y => ({
+      label: String(y.year), value: Math.round(y.total_cves / daysInYear(y.year))
+    })), { name: 'cve-icu-selected-years-per-day', label: 'Average CVEs per day' });
+
+    const mNames = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+    const monthRows = mNames.map((m, i) => {
+      const row = { month: m };
+      picked.forEach(y => {
+        row[y.year] = ((y.date_data || {}).monthly_distribution || {})[String(i + 1)] || 0;
+      });
+      return row;
+    });
+    table('#cmp-month', monthRows,
+      [{ key: 'month', label: 'Month' },
+       ...picked.map(y => ({ key: String(y.year), label: String(y.year), num: true, bar: true }))],
+      { sort: { key: 'month', dir: 1 }, name: 'cve-icu-selected-years-by-month' });
+  }
+
+  /* ---------------- single-year detail ---------------- */
+  function detail() {
+    const sel = [...selected];
+    const host = el('#year-detail');
+    if (sel.length !== 1) { host.innerHTML = ''; return; }
+    const yr = sel[0];
+    const y = years.find(x => x.year === yr);
+    if (!y) { host.innerHTML = ''; return; }
+
+    const mNames = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+    const months = (y.date_data || {}).monthly_distribution || {};
+    const prev = years.find(x => x.year === yr - 1);
+
+    host.innerHTML = `
+      <h2>${yr} in detail</h2>
+      <div class="cols c2">
+        <div class="panel"><div class="panel-h">By month <span class="side">${yr}</span></div>
+          <div class="panel-b"><div id="d-month"></div></div></div>
+        <div class="panel"><div class="panel-h">CVSS scores by version
+          <span class="side">a CVE may hold more than one</span></div>
+          <div class="panel-b"><div id="d-cvss"></div></div></div>
+      </div>
+      <div class="cols" style="margin-top:10px">
+        <div class="panel"><div class="panel-h">Top vendors</div><div class="rows" id="d-vendor"></div></div>
+        <div class="panel"><div class="panel-h">Top weaknesses</div><div class="rows" id="d-cwe"></div></div>
+        <div class="panel"><div class="panel-h">NVD record status</div><div class="rows" id="d-status"></div></div>
+      </div>
+      <div class="cols c2" style="margin-top:10px">
+        <div class="panel"><div class="panel-h">Reference types
+          <span class="side">how sources are tagged</span></div>
+          <div class="panel-b"><div id="d-refs"></div></div></div>
+        <div class="panel"><div class="panel-h">${yr} against ${yr - 1}</div>
+          <div class="panel-b" id="d-vs" style="font-size:13.5px;line-height:1.7"></div></div>
+      </div>`;
+
+    chart.bars('#d-month', mNames.map((m, i) => ({ label: m, value: months[String(i + 1)] || 0 })),
+      { ticks: ['Jan', 'Dec'], name: `cve-icu-${yr}-by-month`, label: `${yr} CVEs by month` });
+
+    chart.hbars('#d-cvss', Object.entries(y.cvss || {})
+      .map(([v, d]) => ({ label: v, value: d.total || 0 })).filter(x => x.value),
+      { name: `cve-icu-${yr}-cvss-versions`, label: `${yr} CVSS scores by version` });
+
+    chart.rank('#d-vendor', ((y.vendors || {}).cpe_vendors || []).slice(0, 8)
+      .map(v => ({ label: v.name, value: v.count })), { compact: true, name: `cve-icu-${yr}-vendors` });
+    chart.rank('#d-cwe', ((y.cwe || {}).top_cwes || []).slice(0, 8)
+      .map(c => ({ label: c.cwe, value: c.count })), { compact: true, name: `cve-icu-${yr}-weaknesses` });
+    chart.rank('#d-status', ((y.metadata || {}).vulnerability_status || [])
+      .map(s => ({ label: s.status, value: s.count })), { compact: true, name: `cve-icu-${yr}-status` });
+
+    const refs = ((y.metadata || {}).reference_tags || []).slice(0, 8)
+      .map(r => ({ label: r.tag, value: r.count }));
+    if (refs.length) {
+      chart.hbars('#d-refs', refs, { compact: true, name: `cve-icu-${yr}-reference-types`,
+        label: `${yr} reference types` });
+    } else {
+      el('#d-refs').innerHTML = '<div class="empty">No reference tags recorded for ' + yr + '.</div>';
+    }
+
+    const kevN = (y.kev || {}).kev_count || 0;
+    el('#d-vs').innerHTML = prev ? `
+      <div class="kvline"><span>CVEs</span><b>${fmt.n(y.total_cves)}</b>
+        <span class="faint">vs ${fmt.n(prev.total_cves)}</span>
+        <span style="color:var(--${y.total_cves >= prev.total_cves ? 'live' : 'hot'})">
+        ${fmt.pct((y.total_cves / prev.total_cves - 1) * 100)}</span></div>
+      <div class="kvline"><span>Per day</span><b>${fmt.n(Math.round(y.total_cves / daysInYear(yr)))}</b>
+        <span class="faint">vs ${fmt.n(Math.round(prev.total_cves / daysInYear(yr - 1)))}</span></div>
+      <div class="kvline"><span>In KEV</span><b>${fmt.n(kevN)}</b>
+        <span class="faint">vs ${fmt.n((prev.kev || {}).kev_count || 0)}</span></div>
+      ${yr === YR ? '<p class="faint" style="margin-top:9px">' + yr +
+        ' is a partial year, so the per-day figure is the fair comparison.</p>' : ''}`
+      : '<span class="faint">No prior year on record.</span>';
+  }
+
+  /* ---------------- table ---------------- */
+  let run = 0;
+  const rows = years.map(y => {
+    run += y.total_cves;
+    const prev = years.find(x => x.year === y.year - 1);
+    return {
+      year: y.year, cves: y.total_cves,
+      perday: Math.round(y.total_cves / daysInYear(y.year)),
+      change: prev ? +((y.total_cves / prev.total_cves - 1) * 100).toFixed(1) : null,
+      kev: (y.kev || {}).kev_count || 0,
+      running: run
+    };
+  }).reverse();
+
+  table('#year-table', rows, [
+    { key: 'year', label: 'Year', num: true, raw: true },
+    { key: 'cves', label: 'CVEs', num: true, bar: true },
+    { key: 'perday', label: 'Per day', num: true },
+    { key: 'change', label: 'vs prior year', num: true,
+      fmt: v => v == null ? '<span class="faint">&mdash;</span>'
+        : `<span style="color:var(--${v > 0 ? 'live' : 'hot'})">${fmt.pct(v)}</span>` },
+    { key: 'kev', label: 'In KEV', num: true },
+    { key: 'running', label: 'Running total', num: true }
+  ], { sort: { key: 'year', dir: -1 }, name: 'cve-icu-all-years' });
+
+  /* ---------------- wiring ---------------- */
+  function render() {
+    tiles(); chips(); mainChart(); compare(); detail();
+    url.set({ years: [...selected].sort((a, b) => a - b).join(',') || null });
+  }
+  function toggle(y) {
+    if (selected.has(y)) selected.delete(y); else selected.add(y);
+    render();
+  }
+  render();
+
+  el('#chips').addEventListener('click', e => {
+    const c = e.target.closest('.chip'); if (c) toggle(+c.dataset.y);
+  });
+  el('#quick').addEventListener('click', e => {
+    const b = e.target.closest('.chip'); if (!b) return;
+    const q = b.dataset.q;
+    if (q === 'clear') selected = new Set();
+    else if (q === 'all') selected = new Set(allYears);
+    else if (q === 'recent5') selected = new Set(allYears.slice(-5));
+    else {
+      const decade = parseInt(q, 10);
+      selected = new Set(allYears.filter(y => y >= decade && y < decade + 10));
+    }
+    render();
+  });
+  el('#share').addEventListener('click', () => url.share(el('#share')));
+  el('#print').addEventListener('click', () => window.print());
+});
+</script>
+
+</body>
+</html>
\ No newline at end of file